emcTowerContent.h

Go to the documentation of this file.

#ifndef __EMCTOWERCONTENT_H__
#define __EMCTOWERCONTENT_H__

#include "PHObject.h"
#include <iostream>

class emcTowerContent : public PHObject 
{
public:

  virtual ~emcTowerContent();

  virtual emcTowerContent* clone() const { warning("clone"); return 0; }

  virtual emcTowerContent* create() const { warning("create") ; return 0; }

  virtual int ADC(void) const { warning("ADC"); return 0; }

  virtual int AMUPre(void) const { warning("AMUPre"); return 0; }

  virtual int AMUPost(void) const { warning("AMUPost"); return 0; }

  virtual int AMUTAC(void) const { warning("AMUTAC"); return 0; }

  virtual int BeamClock(void) const { warning("BeamClock"); return 0; }

  virtual int Channel(void) const { warning("Channel"); return 0; }

  virtual int DataError(void) const { warning("DataError"); return 0; }
  
  virtual float Energy(void) const { warning("Energy"); return 0; }

  virtual unsigned int ErrorNeighbours(void) const 
  { warning("ErrorNeighbours"); return 0; }

  virtual int FEM(void) const { warning("FEM"); return 0; }


  virtual bool hasCalib(void) const { return false; }

  virtual bool hasDC(void) const { return false; }

  virtual bool hasGain(void) const { return false; }

  virtual bool hasMerSimStatus(void) const { return false; }

  virtual bool hasRaw(void) const { return false; }

  virtual bool hasReference(void) const;

  
  virtual bool canHaveCalib() const { return false; }

  virtual bool canHaveDC() const { return false; }

  virtual bool canHaveGain() const { return false; }

  virtual bool canHaveMerSimStatus() const { return false; }

  virtual bool canHaveRaw() const { return false; }

  virtual int HG(void) const { warning("HG"); return 0; }

  virtual int HGPost(void) const { warning("HGPost"); return 0; }

  virtual int HGPre(void) const { warning("HGPre"); return 0; }

  virtual int HGPP(void) const;

  virtual float Gain(void) const { warning("Gain"); return 0; }

  virtual void identify(std::ostream& os=std::cout) const;

  virtual bool isSimulated(void) const 
  { warning("isSimulated"); return false; }

  virtual bool isMerged(void) const { warning("isMerged"); return false; }

  virtual bool isReference(void) const;

  virtual int isValid() const;

  virtual bool isZero(void) const { warning("isZero"); return 0; }

  virtual int LG(void) const { warning("LG"); return 0; }

  virtual int LGPost(void) const { warning("LGPost"); return 0; }

  virtual int LGPre(void) const { warning("LGPre"); return 0; }

  virtual int LGPP(void) const;

  virtual void print(std::ostream& /*out*/=std::cout, int /*level*/=0) const 
  { warning("print"); }

  virtual emcTowerContent* Reference(void) const;

  virtual void SetADCTDC(int /*adc*/, int /*tdc*/, int /*hg*/=0, int /*lg*/=0) 
  { warning("SetADCTDC"); }

  virtual void SetCalibrated(float /*energy*/, float /*tof*/) 
  { warning("SetCalibrated"); }

  virtual void SetDataError(int /*dataerror*/) { warning("SetDataError"); }

  virtual void SetID(int /*fem*/, int /*channel*/) { warning("SetID"); }

  virtual void SetGain(float /*gain*/) { warning("SetGain"); }

  virtual void SetNeighbours(unsigned int /*_error*/, 
                             unsigned int /*_warning*/) 
  { warning("SetNeighbours"); }

  virtual void SetMerSimStatus(bool /*ismerged*/, bool /*issimulated*/)
  { warning("SetMerSimStatus"); }

  virtual void SetRaw(int /*hgpost*/, int /*hgpre*/, 
                      int /*lgpost*/, int /*lgpre*/,
                      int /*tac*/,
                      int /*amupre*/=0,
                      int /*amupost*/=0,
                      int /*amutac*/=0,
                      int /*beamclock*/=0) { warning("SetRaw"); }

  virtual void SetSimFrac(float /*simfrac*/) { warning("SetSimFrac"); }

  virtual void SetToF(float /*tof*/) { warning("SetTOF"); }

  virtual float SimFrac() const { return 0; }

  virtual int TAC(void) const { warning("TAC"); return 0; }

  virtual int TDC(void) const { warning("TDC"); return 0; }

  virtual float ToF(void) const { warning("TOF"); return 0; }

  virtual float UncorrectedToF() const { warning("UncorrectedToF"); return 0; }

  virtual int TowerID(void) const { warning("TowerID"); return 0; }    

  int TowerId(void) const { return TowerID(); }

  int towerid(void) const { return TowerID(); }

  virtual unsigned int WarnNeighbours(void) const 
  { warning("WarnNeighbours"); return 0; }  

  virtual void Zero(void) { warning("Zero"); }

  void ShutUp(const int i = 1);

protected:
  emcTowerContent& operator=(const emcTowerContent& rhs);

private:

  void warning(const char*) const;

  ClassDef(emcTowerContent,0) // EMCAL Tower data (ABC)

};

inline 
std::ostream& operator<<(std::ostream& out, const emcTowerContent& tc)
{
  tc.print(out); 
  return out;
}

#endif