emcClusterContent.h

Go to the documentation of this file.

#ifndef __emcClusterContent_h__
#define __emcClusterContent_h__

#include "phool.h"
#include "PHObject.h"

#include <cmath>
#ifndef NAN
static const float NAN = sqrt(-1);
#endif

class emcClusterContent : public PHObject
{
public:

  // CREATORS

  virtual ~emcClusterContent(){}

  emcClusterContent* clone(void) const { warning("clone()"); return 0; }

  emcClusterContent* create(void) const { warning("create()"); return 0; }

  // ACCESSORS.

  virtual int arm() const { warning("int arm()"); return -1; }

  virtual bool canBeMerged() const { return false; }

  virtual float chi2() const { warning("float chi2()"); return NAN; }

  virtual float corrdispy() const { warning("float corrdispy()"); return NAN; }
  virtual float corrdispz() const { warning("float corrdispz()"); return NAN; }

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

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

  virtual float dispy() const { warning("float dispy()"); return NAN; }
  virtual float dispz() const { warning("float dispz()"); return NAN; }

  virtual float dx() const { warning("float dx()"); return NAN; }
  virtual float dy() const { warning("float dy()"); return NAN; }
  virtual float dz() const { warning("float dz()"); return NAN; }

  // Measured energy in GeV.
  virtual float e() const { warning("float e()"); return NAN; }

  // Measured energy (GeV) in a 3x3 array around central tower.
  virtual float e9() const { warning("float e9()"); return NAN; }

  // used to be called ecorecorr for PbSc and ecorr for PbGl. GeV.
  virtual float ecore() const { warning("float ecore()"); return NAN; }

  // energy of the central tower. GeV.
  virtual float ecent() const { warning("float ecent()"); return NAN; }


  virtual float etofmin() const { warning("float etofmin()"); return NAN; }
  virtual float etofmax() const { warning("float etofmax()"); return NAN; }

  virtual bool has_rawtdc() const { return false; }

  virtual bool has_yz_cg() const { return false; }

  /* List of nDST variables taken out in pDST
     (see offline/analysis/Run4HardpDST/containers/PhPhotonSngl.h) */
  virtual bool has_id() const { return true; }
  virtual bool has_pid() const { return true; }
  virtual bool has_type() const { return true; }
  virtual bool has_Dxyz() const { return true; }
  virtual bool has_E9() const { return true; }
  virtual bool has_Etofmin() const { return true; }
  virtual bool has_Etofmax() const { return true; }
  virtual bool has_Quality() const { return true; }
  virtual bool has_Phi() const { return true; }
  virtual bool has_Theta() const { return true; }
  virtual bool has_Tofdisp() const { return true; }
  virtual bool has_Tofmin() const { return true; }
  virtual bool has_Tofmax() const { return true; }
  virtual bool has_Tofcorrmin() const { return true; }
  virtual bool has_Tofcorrmax() const { return true; }
   

  virtual int id() const { warning("int id()"); return -1; }

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

  virtual int isValid() const;
  // generic check for implemented methods
  int isValid(const float f) const;
  int isValid(const int i) const;
  int isValid(const unsigned int i) const;

  virtual bool isMerged() const { return (simfrac()>0 && simfrac()<1.0); }

  virtual bool isSimulated() const { return (simfrac()==1.0); }

  virtual int iypos() const { warning("int iypos()"); return -1; }
  virtual int izpos() const { warning("int izpos()"); return -1; }

  virtual float quality() const { warning("float quality()"); return NAN; }

  virtual int multiplicity() const { warning("multiplicity()"); return -1; }

  //{@
  virtual float padispy() const { warning("float padispy()"); return NAN; }
  virtual float padispz() const { warning("padispz()"); return NAN; }

  virtual float partesum(int index) const { warning("float partesum(int index)"); return NAN; }

  virtual float prob_photon() const { warning("float prob_photon()"); return NAN; }

  virtual float phi() const { warning("float phi()"); return NAN; }

  virtual int pid() const { warning("int pid()"); return -1; }

  virtual void print(std::ostream& out=std::cout) const;

  virtual float rawtdc() const { warning("float rawtdc()"); return NAN; }

  virtual int sector() const { warning("int sector()"); return -1; }

  virtual float simfrac() const { warning("float simfrac()"); return NAN; }

  virtual float tof() const { warning("float tof()"); return NAN; }

  virtual float tofcorr() const { warning("float tofcorr()"); return NAN; }

  virtual float tofhad() const { warning("float tofhad()"); return NAN; }

  virtual float tofdisp() const { warning(""); return NAN; }

  virtual float tofmin() const { warning("float tofmin()"); return NAN; }
  virtual float tofmax() const { warning("float tofmax()"); return NAN; }
  virtual float tofcorrmin() const { warning("float tofcorrmin()"); return NAN; }
  virtual float tofcorrmax() const { warning("float tofcorrmax()"); return NAN; }

  virtual float theta() const { warning("float theta()"); return NAN; }

  virtual int towerid(int index) const { warning("int towerid(int index)"); return -1; }

  int twrhit() const { return multiplicity(); }

  virtual int type() const { warning("int type()"); return -1; }

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

  virtual float x() const { warning("float x()"); return NAN; }
  virtual float y() const { warning("float y()"); return NAN; }
  virtual float z() const { warning("float z()"); return NAN; }

  virtual float ycg() const { warning("float ycg()"); return NAN; }
  virtual float zcg() const { warning("float zcg()"); return NAN; }

  //  Extra variables for vetoes of charged particles...
  virtual short emcpc3       () const {warning("short emcpc3()"); return 0;}
  virtual short emcpc3neartrk() const {warning("short emcpc3neartrk()"); return 0;}
  virtual float emcpc3dz     () const {warning("float emcpc3dz()"); return NAN;}
  virtual float emcpc3dphi   () const {warning("float emcpc3dphi()"); return NAN;}
  virtual short emctrk       () const {warning("short emctrk()"); return 0;}
  virtual float emctrkdz     () const {warning("float emctrkdz()"); return NAN;}
  virtual float emctrkdphi   () const {warning("float emctrkdphi()"); return NAN;}
  virtual float pemctrk      () const {warning("float pemctrk()"); return NAN;}
  virtual short emctrkquality() const {warning("short emctrkquality()"); return 0;}




  virtual void set_arm(int) { warning("set_arm(int)"); }
  virtual void set_chi2(float) { warning("set_chi2(float)"); }
  virtual void set_corrdisp(float corrdispy, float corrdispz) { warning("set_corrdisp(float corrdispy, float corrdispz)"); }
  virtual void set_cutword(unsigned int) { warning("set_cutword(unsigned int)"); }
  virtual void set_disp(float dispy, float _dispz) { warning(" void set_disp(float dispy, float _dispz)"); }
  virtual void set_dxyz(float dx, float dy, float dz) 
  { warning("void set_dxyz(float dx, float dy, float dz) "); }
  virtual void set_e(float) { warning("void set_e(float)"); }
  virtual void set_e9(float) { warning("void set_e9(float)"); }
  virtual void set_ecore(float) { warning("set_ecore(float)"); }
  virtual void set_ecent(float) { warning("set_ecent(float)"); }
  virtual void set_etofmin(float) { warning("set_etofmin(float)"); }
  virtual void set_etofmax(float) { warning("set_etofmax(float)"); }
  virtual void set_id(int id) { warning("set_id(int id)"); }
  virtual void set_ipos(int iy, int iz)  { warning("set_ipos(int iy, int iz)"); }
  virtual void set_quality(float) { warning("set_quality(float)"); }
  virtual void set_maps(unsigned int deadmap, unsigned int warnmap)
  { warning("set_maps(unsigned int deadmap, unsigned int warnmap)"); }
  virtual void set_multiplicity(int) { warning("set_multiplicity(int)"); }
  virtual void set_padisp(float padispy, float padispz) 
  { warning("set_padisp(float padispy, float padispz)"); }
  virtual void set_partesum(int index, float value) { warning("set_partesum(int index, float value)"); }
  virtual void set_prob_photon(float) { warning("set_prob_photon(float)"); }
  virtual void set_phi(float) { warning("set_phi(float)"); }
  virtual void set_pid(int) { warning("set_pid(int)"); }
  virtual void set_rawtdc(float) { warning("set_rawtdc(float)"); }
  virtual void set_sector(int) { warning("set_sector(int)"); }
  virtual void set_simfrac(float) { warning("set_simfrac(float)"); }
  virtual void set_tof(float) { warning("set_tof(float)"); }
  virtual void set_tofhad(float) { warning("set_tofhad(float) "); }
  virtual void set_tofdisp(float) { warning("set_tofdisp(float)"); }
  virtual void set_tofmin(float) { warning("set_tofmin(float)"); }
  virtual void set_tofmax(float) { warning("set_tofmax(float)"); }
  virtual void set_tofcorr(float) { warning("set_tofcorr(float)"); }
  virtual void set_tofcorrmin(float) { warning("set_tofcorrmin(float)"); }
  virtual void set_tofcorrmax(float) { warning("set_tofcorrmax(float)"); }
  virtual void set_theta(float) { warning("set_theta(float)"); }
  virtual void set_towerid(int index, int value) { warning("set_towerid(int index, int value)"); }
  virtual void set_type(int) { warning("set_type(int)"); }
  virtual void set_xyz(float x, float y, float z) { warning("set_xyz(float x, float y, float z)"); }
  virtual void set_yz_cg(float ycg, float zcg)   { warning("set_yz_cg(float ycg, float zcg)"); }

  //  Extra variables for vetoes of charged particles...
  virtual void set_emcpc3       (short) {warning("set_emcpc3(short)");}
  virtual void set_emcpc3neartrk(short) {warning("set_emcpc3neartrk(short)");}
  virtual void set_emcpc3dz     (float) {warning("set_emcpc3dz(float)");}
  virtual void set_emcpc3dphi   (float) {warning("set_emcpc3dphi(float)");}
  virtual void set_emctrk       (short) {warning("set_emctrk(short)");}
  virtual void set_emctrkdz     (float) {warning("set_emctrkdz(float)");}
  virtual void set_emctrkdphi   (float) {warning("set_emctrkdphi(float)");}
  virtual void set_pemctrk      (float) {warning("set_pemctrk(float)");}
  virtual void set_emctrkquality(short) {warning("set_emctrkquality(short)");}
  void ShutUp(const int i = 1);
  // this should be a generic copy content of any emcClusterContent to any emcClusterContent
  virtual void Copy(const emcClusterContent &src);


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

private: 
  void warning(const char* field) const;

  ClassDef(emcClusterContent,0) // EMCAL Cluster data (ABC)
    
};

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

#endif