PWG4/AliGammaReader.h

   1 #ifndef ALIGAMMAREADER_H
   2 #define ALIGAMMAREADER_H
   3 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   4  * See cxx source for full Copyright notice     */
   5 /* $Id$ */
   6
   7 /* History of cvs commits:
   8  *
   9  * $Log$
  10  * Revision 1.2  2007/08/17 12:40:04  schutz
  11  * New analysis classes by Gustavo Conesa
  12  *
  13  * Revision 1.1.2.1  2007/07/26 10:32:09  schutz
  14  * new analysis classes in the the new analysis framework
  15  *
  16  *
  17  */
  18
  19 //_________________________________________________________________________
  20 // Base class for reading data: MonteCarlo, ESD or AOD, of PHOS EMCAL and
  21 // Central Barrel Tracking detectors.
  22 // Not all MC particles/tracks/clusters are kept, some kinematical restrictions are done.
  23 // Mother class of : AliGammaDataReader: Fills ESD data in 3 TClonesArrays (PHOS, EMCAL, CTS)
  24 //                 : AliGammaMCReader: Fills Kinematics data in 3 TClonesArrays (PHOS, EMCAL, CTS)
  25 //                 : AliGammaMCDataReader: Fills ESD data in 3 TClonesArrays (PHOS, EMCAL, CTS)
  26 //                             and MC data in other 3 TClonesArray
  27 //*-- Author: Gustavo Conesa (INFN-LNF)
  28
  29 // --- ROOT system ---
  30 #include "TObject.h"
  31
  32 class TClonesArray ;
  33 class TFormula ;
  34 class TParticle ;
  35 class Riostream ;
  36 //--- AliRoot system ---
  37
  38 class AliStack ;
  39 class AliESDEvent ;
  40 class AliLog ;
  41
  42 class AliGammaReader : public TObject {
  43
  44 public:
  45
  46   AliGammaReader() ; // ctor
  47   AliGammaReader(const AliGammaReader & g) ; // cpy ctor
  48   AliGammaReader & operator = (const AliGammaReader & g) ;//cpy assignment
  49   virtual ~AliGammaReader() {;} //virtual dtor
  50
  51   enum PidType {
  52     kPhoton = 22,
  53     kPi0 = 111,
  54     kEta = 221,
  55     kElectron = 11,
  56     kEleCon = 13,
  57     kNeutralHadron = 2112,
  58     kChargedHadron = 211,
  59     kNeutralUnknown = 130,
  60     kChargedUnknown=321
  61   };
  62
  63   enum PhotonStatusType {
  64     kPromptPhoton=2,
  65     kFragmentPhoton=3,
  66     kPi0DecayPhoton=4,
  67     kEtaDecayPhoton=5,
  68     kOtherDecayPhoton=6,
  69     kUnknown=7
  70   };
  71
  72   enum Datatype {kData, kMC, kMCData};
  73
  74   void InitParameters();
  75
  76   Int_t GetDataType() const { return fDataType ; }
  77   void SetDataType(Int_t data ){fDataType = data ; }
  78
  79   virtual Float_t  GetCTSEtaCut() const {return fCTSEtaCut ; }
  80   virtual Float_t  GetEMCALEtaCut() const {return fEMCALEtaCut ; }
  81   virtual Float_t  GetPHOSEtaCut() const {return fPHOSEtaCut ; }
  82   virtual Float_t  GetPhiEMCALCut(Int_t i) { return  fPhiEMCALCut[i]  ; }
  83   virtual Float_t  GetPhiPHOSCut(Int_t i) { return  fPhiPHOSCut[i]  ; }
  84   virtual Float_t  GetNeutralPtCut()    {  return fNeutralPtCut  ; }
  85   virtual Float_t  GetChargedPtCut()  {  return fChargedPtCut  ; }
  86
  87   virtual Float_t  GetEMCALIPDistance()  const {  return fEMCALIPDistance ; }
  88   virtual Float_t  GetPHOSIPDistance()  const {  return fPHOSIPDistance ; }
  89   virtual Float_t  GetEMCALMinAngle()  const {  return fEMCALMinAngle ; }
  90   virtual Float_t  GetPHOSMinAngle()  const {  return fPHOSMinAngle ; }
  91
  92   virtual Bool_t   IsEMCALPIDOn() const {return fEMCALPID ; }
  93   virtual Bool_t   IsPHOSPIDOn() const {return fPHOSPID ; }
  94   virtual Float_t  GetEMCALPhotonWeight() const  { return  fEMCALPhotonWeight  ; }
  95   virtual Float_t  GetEMCALPi0Weight() const     {  return fEMCALPi0Weight  ; }
  96   virtual Float_t  GetEMCALElectronWeight() const  { return  fEMCALElectronWeight  ; }
  97   virtual Float_t  GetEMCALChargeWeight() const     {  return fEMCALChargeWeight  ; }
  98   virtual Float_t  GetEMCALNeutralWeight() const     {  return fEMCALNeutralWeight  ; }
  99   virtual Float_t  GetPHOSPhotonWeight() const   {  return fPHOSPhotonWeight  ; }
 100   virtual Float_t  GetPHOSPi0Weight() const   {  return fPHOSPi0Weight  ; }
 101   virtual Float_t  GetPHOSElectronWeight() const   {  return fPHOSElectronWeight  ; }
 102   virtual Float_t  GetPHOSChargeWeight() const   {  return fPHOSChargeWeight  ; }
 103   virtual Float_t  GetPHOSNeutralWeight() const   {  return fPHOSNeutralWeight  ; }
 104
 105   virtual Bool_t  IsPHOSPIDWeightFormulaOn() const   {  return fPHOSWeightFormula  ; }
 106   virtual TFormula * GetPHOSPhotonWeightFormula() const     {  return fPHOSPhotonWeightFormula  ; }
 107   virtual TFormula * GetPHOSPi0WeightFormula() const    {  return fPHOSPi0WeightFormula  ; }
 108
 109   virtual void Print(const Option_t * opt)const;
 110
 111   virtual void SetCTSEtaCut(Float_t eta){ fCTSEtaCut= eta ; }
 112   virtual void SetEMCALEtaCut(Float_t eta){ fEMCALEtaCut= eta ; }
 113   virtual void SetPHOSEtaCut(Float_t eta){ fPHOSEtaCut= eta ; }
 114   virtual void SetPhiEMCALCut(Float_t  phi0, Float_t  phi1)
 115   { fPhiEMCALCut[0]= phi0 ; fPhiEMCALCut[1]= phi1 ;}
 116   virtual void SetPhiPHOSCut(Float_t  phi0, Float_t  phi1)
 117   { fPhiPHOSCut[0]= phi0 ; fPhiPHOSCut[1]= phi1 ;}
 118   virtual void SetNeutralPtCut(Float_t  pt){  fNeutralPtCut = pt ; }
 119   virtual void SetChargedPtCut(Float_t  pt){  fChargedPtCut = pt ; }
 120
 121  virtual void SetEMCALIPDistance(Float_t  d){  fEMCALIPDistance = d ; }
 122   virtual void SetPHOSIPDistance(Float_t  d){  fPHOSIPDistance = d ; }
 123   virtual void SetEMCALMinAngle(Float_t  d){  fEMCALMinAngle = d ; }
 124   virtual void SetPHOSMinAngle(Float_t  d){  fPHOSMinAngle = d ; }
 125
 126   virtual void SetEMCALPIDOn(Bool_t pid){ fEMCALPID= pid ; }
 127   virtual void SetPHOSPIDOn(Bool_t pid){ fPHOSPID= pid ; }
 128   virtual void SetEMCALPhotonWeight(Float_t  w){  fEMCALPhotonWeight = w ; }
 129   virtual void SetEMCALPi0Weight(Float_t  w){  fEMCALPi0Weight = w ; }
 130   virtual void SetEMCALElectronWeight(Float_t  w){  fEMCALElectronWeight = w ; }
 131   virtual void SetEMCALChargeWeight(Float_t  w){  fEMCALChargeWeight = w ; }
 132   virtual void SetEMCALNeutralWeight(Float_t  w){  fEMCALNeutralWeight = w ; }
 133   virtual void SetPHOSPhotonWeight(Float_t  w){  fPHOSPhotonWeight = w ; }
 134   virtual void SetPHOSPi0Weight(Float_t  w){  fPHOSPi0Weight = w ; }
 135   virtual void SetPHOSElectronWeight(Float_t  w){  fPHOSElectronWeight = w ; }
 136   virtual void SetPHOSChargeWeight(Float_t  w){  fPHOSChargeWeight = w ; }
 137   virtual void SetPHOSNeutralWeight(Float_t  w){  fPHOSNeutralWeight = w ; }
 138
 139   virtual void UsePHOSPIDWeightFormula(Bool_t par)  { fPHOSWeightFormula  = par; }
 140   virtual void SetPHOSPhotonWeightFormula(TFormula * photon)    {  fPHOSPhotonWeightFormula  = photon; }
 141   virtual void SetPHOSPi0WeightFormula(TFormula * pi0)   {  fPHOSPi0WeightFormula  = pi0; }
 142
 143   virtual Bool_t IsEMCALOn() const  { return fSwitchOnEMCAL ; }
 144   virtual Bool_t IsPHOSOn() const  { return fSwitchOnPHOS ; }
 145   virtual Bool_t IsCTSOn() const  { return fSwitchOnCTS ; }
 146
 147   virtual void SwitchOnEMCAL(Bool_t sw) {fSwitchOnEMCAL = sw ; }
 148   virtual void SwitchOnPHOS(Bool_t sw) {fSwitchOnPHOS = sw ; }
 149   virtual void SwitchOnCTS(Bool_t sw) {fSwitchOnCTS = sw ; }
 150
 151   virtual void CreateParticleList(TObject* , TObject * ,
 152                                   TClonesArray * , TClonesArray * , TClonesArray *,
 153                                   TClonesArray * , TClonesArray * , TClonesArray * ) {;}
 154
 155  protected:
 156
 157   Int_t        fDataType ; //Select MC:Kinematics, Data:ESD/AOD, MCData:Both
 158
 159   Bool_t     fSwitchOnEMCAL ; //Do not consider EMCAL neutral particles/clusters
 160   Bool_t     fSwitchOnPHOS ;//Do not consider PHOS neutral particles/clusters
 161   Bool_t     fSwitchOnCTS ;//Do not consider tracks/ charged particles
 162
 163   //Kinematical cuts
 164   Float_t      fCTSEtaCut ;//CTS  pseudorapidity acceptance
 165   Float_t      fEMCALEtaCut ;//EMCAL pseudorapidity acceptance
 166   Float_t      fPHOSEtaCut ;//PHOS pseudorapidity acceptance
 167   Float_t      fPhiEMCALCut[2]; //EMCAL phi acceptance
 168   Float_t      fPhiPHOSCut[2];  //PHOS phi acceptance
 169   Float_t      fNeutralPtCut; //pT Threshold on neutral particles
 170   Float_t      fChargedPtCut;  // pT  Threshold on charged particles
 171
 172   //Overlapping
 173   Float_t      fEMCALIPDistance; //Calorimeter IP distance.
 174   Float_t      fPHOSIPDistance; //Calorimeter IP distance
 175   Float_t      fEMCALMinAngle; //Gamma decay minimum aperture angle for overlapping.
 176   Float_t      fPHOSMinAngle; //Gamma decay minimum aperture angle for overlapping.
 177
 178   //PID
 179   Bool_t       fEMCALPID ;//Fill EMCAL particle lists with particles with corresponding pid
 180   Bool_t       fPHOSPID;  //Fill PHOS particle lists with particles with corresponding pid
 181   Float_t      fEMCALPhotonWeight; //Bayesian PID weight for photons in EMCAL
 182   Float_t      fEMCALPi0Weight;  //Bayesian PID weight for pi0 in EMCAL
 183   Float_t      fEMCALElectronWeight; //Bayesian PID weight for electrons in EMCAL
 184   Float_t      fEMCALChargeWeight;  //Bayesian PID weight for charged hadrons in EMCAL
 185   Float_t      fEMCALNeutralWeight;  //Bayesian PID weight for neutral hadrons in EMCAL
 186   Float_t      fPHOSPhotonWeight; //Bayesian PID weight for photons in PHOS
 187   Float_t      fPHOSPi0Weight; //Bayesian PID weight for pi0 in PHOS
 188   Float_t      fPHOSElectronWeight; //Bayesian PID weight for electrons in PHOS
 189   Float_t      fPHOSChargeWeight; //Bayesian PID weight for charged hadrons in PHOS
 190   Float_t      fPHOSNeutralWeight; //Bayesian PID weight for neutral hadrons in PHOS
 191
 192   Bool_t  fPHOSWeightFormula ; //Use parametrized weight threshold, function of energy
 193   TFormula * fPHOSPhotonWeightFormula ; //Formula for photon weight
 194   TFormula * fPHOSPi0WeightFormula ; //Formula for pi0 weight
 195
 196   ClassDef(AliGammaReader,1)
 197 } ;
 198
 199
 200 #endif //ALIGAMMAREADER_H
 201
 202
 203