Several changes:
authorgconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 20 Apr 2009 17:21:17 +0000 (17:21 +0000)
committergconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 20 Apr 2009 17:21:17 +0000 (17:21 +0000)
1) AddTaskPartCorr.C: The analysis train will call this macro to execute the tasks
2) Readers: Memory transient objects removed, now clusters and tracks selected and used in analysis are in TRefArrays.
3) AliAnaPi0.cxx: Protection added agains floating point exception when calculating the rapidity for MC particles
4)AliChargedParticles: New class for charged tracks selection for correlations.
5) Few coding violations  removed
6) In AliAnaParticleHadron* and AliAnaParticleJet* added option to fill histograms when trigger particle is isolated
7)AliAnaParticle* and AliIsolationCut: When adding clusters or tracks to reference lists in AliAODParticleCorrelation, use new with placement.

52 files changed:
PWG4/CMake_libPWG4PartCorrDep.txt
PWG4/PWG4PartCorrDepLinkDef.h
PWG4/PartCorrBase/AliAODPWG4Particle.cxx
PWG4/PartCorrBase/AliAODPWG4Particle.h
PWG4/PartCorrBase/AliAODPWG4ParticleCorrelation.cxx
PWG4/PartCorrBase/AliAODPWG4ParticleCorrelation.h
PWG4/PartCorrBase/AliAnaPartCorrBaseClass.cxx
PWG4/PartCorrBase/AliAnaPartCorrBaseClass.h
PWG4/PartCorrBase/AliAnaPartCorrMaker.cxx
PWG4/PartCorrBase/AliAnaPartCorrMaker.h
PWG4/PartCorrBase/AliAnaScale.cxx
PWG4/PartCorrBase/AliAnaScale.h
PWG4/PartCorrBase/AliAnalysisTaskParticleCorrelation.cxx
PWG4/PartCorrBase/AliAnalysisTaskParticleCorrelation.h
PWG4/PartCorrBase/AliCaloPID.cxx
PWG4/PartCorrBase/AliCaloPID.h
PWG4/PartCorrBase/AliCaloTrackAODReader.cxx
PWG4/PartCorrBase/AliCaloTrackAODReader.h
PWG4/PartCorrBase/AliCaloTrackESDReader.cxx
PWG4/PartCorrBase/AliCaloTrackESDReader.h
PWG4/PartCorrBase/AliCaloTrackMCReader.cxx
PWG4/PartCorrBase/AliCaloTrackMCReader.h
PWG4/PartCorrBase/AliCaloTrackReader.cxx
PWG4/PartCorrBase/AliCaloTrackReader.h
PWG4/PartCorrBase/AliFidutialCut.cxx
PWG4/PartCorrBase/AliFidutialCut.h
PWG4/PartCorrBase/AliIsolationCut.cxx
PWG4/PartCorrBase/AliIsolationCut.h
PWG4/PartCorrBase/AliMCAnalysisUtils.cxx
PWG4/PartCorrBase/AliMCAnalysisUtils.h
PWG4/PartCorrBase/AliNeutralMesonSelection.cxx
PWG4/PartCorrBase/AliNeutralMesonSelection.h
PWG4/PartCorrDep/AliAnaCaloTrigger.cxx
PWG4/PartCorrDep/AliAnaChargedParticles.cxx [new file with mode: 0755]
PWG4/PartCorrDep/AliAnaChargedParticles.h [new file with mode: 0755]
PWG4/PartCorrDep/AliAnaExample.cxx
PWG4/PartCorrDep/AliAnaExample.h
PWG4/PartCorrDep/AliAnaParticleHadronCorrelation.cxx
PWG4/PartCorrDep/AliAnaParticleHadronCorrelation.h
PWG4/PartCorrDep/AliAnaParticleIsolation.cxx
PWG4/PartCorrDep/AliAnaParticleIsolation.h
PWG4/PartCorrDep/AliAnaParticleJetFinderCorrelation.cxx
PWG4/PartCorrDep/AliAnaParticleJetFinderCorrelation.h
PWG4/PartCorrDep/AliAnaParticleJetLeadingConeCorrelation.cxx
PWG4/PartCorrDep/AliAnaParticleJetLeadingConeCorrelation.h
PWG4/PartCorrDep/AliAnaParticlePartonCorrelation.cxx
PWG4/PartCorrDep/AliAnaPhoton.cxx
PWG4/PartCorrDep/AliAnaPi0.cxx
PWG4/PartCorrDep/AliAnaPi0EbE.cxx
PWG4/PartCorrDep/AliAnaPi0EbE.h
PWG4/PartCorrDep/AliAnalysisTaskPHOSExample.cxx
PWG4/libPWG4PartCorrDep.pkg

index a1210c1fac0e52e0a57c857b93113313c0a95ed7..8f4bfe845fd2df611e1ed10632fe6d7a46828a9b 100755 (executable)
@@ -6,7 +6,7 @@ set(SRCS
        PartCorrDep/AliAnaPhoton.cxx PartCorrDep/AliAnaPi0.cxx PartCorrDep/AliAnaPi0EbE.cxx 
        PartCorrDep/AliAnaParticleIsolation.cxx PartCorrDep/AliAnaParticlePartonCorrelation.cxx 
        PartCorrDep/AliAnaParticleHadronCorrelation.cxx PartCorrDep/AliAnaParticleJetFinderCorrelation.cxx
-       PartCorrDep/AliAnaParticleJetLeadingConeCorrelation.cxx
+       PartCorrDep/AliAnaParticleJetLeadingConeCorrelation.cxx PartCorrDep/AliAnaChargedParticles.cxx
       
 )
 
index de652150388433d83f545d1aa01013328a43ffdb..2e4f72958d3a36403a157fe3eecd1a2df1dd2097 100755 (executable)
@@ -10,6 +10,7 @@
 #pragma link C++ class AliAnaPhoton+;
 #pragma link C++ class AliAnaPi0+;
 #pragma link C++ class AliAnaPi0EbE+;
+#pragma link C++ class AliAnaChargedParticles+;
 #pragma link C++ class AliAnaParticleIsolation+;
 #pragma link C++ class AliAnaParticlePartonCorrelation+;
 #pragma link C++ class AliAnaParticleHadronCorrelation+;
index b42a17195847904992774d106f438a2b1a8fe6f3..92ed8cd40be895679566bf1c6c83e3d635e268f5 100755 (executable)
@@ -35,130 +35,130 @@ AliVParticle(),
 fMomentum(0),fPdg(-1), fTag(-1), fLabel(-1), fCaloLabel(), fTrackLabel(),
 fDetector(""), fDisp(0), fTof(0), fCharged(0), fBadDist(0)
 {
-       // constructor
-       fCaloLabel [0] = -1;
-       fCaloLabel [1] = -1;
-       fTrackLabel[0] = -1;
-       fTrackLabel[1] = -1;
+  // constructor
+  fCaloLabel [0] = -1;
+  fCaloLabel [1] = -1;
+  fTrackLabel[0] = -1;
+  fTrackLabel[1] = -1;
 }
 
 //______________________________________________________________________________
 AliAODPWG4Particle::AliAODPWG4Particle(Double_t px, Double_t py, Double_t pz, Double_t e):
-AliVParticle(),
-fMomentum(0),fPdg(-1), fTag(-1),fLabel(-1),fCaloLabel(), fTrackLabel(),
-fDetector(""), fDisp(0),fTof(0),fCharged(0), fBadDist(0)
+  AliVParticle(),
+  fMomentum(0),fPdg(-1), fTag(-1),fLabel(-1),fCaloLabel(), fTrackLabel(),
+  fDetector(""), fDisp(0),fTof(0),fCharged(0), fBadDist(0)
 {
-       // constructor
-       fMomentum = new TLorentzVector(px, py, pz, e);
-       
-       fCaloLabel [0] = -1;
-       fCaloLabel [1] = -1;
-       fTrackLabel[0] = -1;
-       fTrackLabel[1] = -1;    
+  // constructor
+  fMomentum = new TLorentzVector(px, py, pz, e);
+  
+  fCaloLabel [0] = -1;
+  fCaloLabel [1] = -1;
+  fTrackLabel[0] = -1;
+  fTrackLabel[1] = -1; 
 }
 
 //______________________________________________________________________________
 AliAODPWG4Particle::AliAODPWG4Particle(TLorentzVector & p):
-AliVParticle(),
-fMomentum(0),fPdg(-1), fTag(-1),fLabel(-1),fCaloLabel(), fTrackLabel(),
-fDetector(""), fDisp(0),fTof(0),fCharged(0),fBadDist(0)
+  AliVParticle(),
+  fMomentum(0),fPdg(-1), fTag(-1),fLabel(-1),fCaloLabel(), fTrackLabel(),
+  fDetector(""), fDisp(0),fTof(0),fCharged(0),fBadDist(0)
 {
-       // constructor
-    fMomentum = new TLorentzVector(p);
-       
-       fCaloLabel [0] = -1;
-       fCaloLabel [1] = -1;
-       fTrackLabel[0] = -1;
-       fTrackLabel[1] = -1;
+  // constructor
+  fMomentum = new TLorentzVector(p);
+  
+  fCaloLabel [0] = -1;
+  fCaloLabel [1] = -1;
+  fTrackLabel[0] = -1;
+  fTrackLabel[1] = -1;
 }
 
 
 //______________________________________________________________________________
 AliAODPWG4Particle::~AliAODPWG4Particle() 
 {
-       // destructor
+  // destructor
     delete fMomentum;
 }
 
 //______________________________________________________________________________
 AliAODPWG4Particle::AliAODPWG4Particle(const AliAODPWG4Particle& part) :
-AliVParticle(part),
-fMomentum(0), fPdg(part.fPdg), fTag(part.fTag), fLabel(part.fLabel), fCaloLabel(), fTrackLabel(),
-fDetector(part.fDetector),fDisp(part.fDisp), fTof(part.fTof), fCharged(part.fCharged),  fBadDist(part.fBadDist)
-
+  AliVParticle(part),
+  fMomentum(0), fPdg(part.fPdg), fTag(part.fTag), fLabel(part.fLabel), fCaloLabel(), fTrackLabel(),
+  fDetector(part.fDetector),fDisp(part.fDisp), fTof(part.fTof), fCharged(part.fCharged),  fBadDist(part.fBadDist)
+    
 {
-       // Copy constructor
-       fMomentum = new TLorentzVector(*part.fMomentum);
-       
-       fCaloLabel [0] = part.fCaloLabel[0];
-       fCaloLabel [1] = part.fCaloLabel[1];
-       fTrackLabel[0] = part.fTrackLabel[0];
-       fTrackLabel[1] = part.fTrackLabel[1];
+  // Copy constructor
+  fMomentum = new TLorentzVector(*part.fMomentum);
+  
+  fCaloLabel [0] = part.fCaloLabel[0];
+  fCaloLabel [1] = part.fCaloLabel[1];
+  fTrackLabel[0] = part.fTrackLabel[0];
+  fTrackLabel[1] = part.fTrackLabel[1];
 }
 
 //______________________________________________________________________________
 AliAODPWG4Particle& AliAODPWG4Particle::operator=(const AliAODPWG4Particle& part)
 {
-       // Assignment operator
-       if(this!=&part) {
-               
-               fPdg = part.fPdg;
-               fTag = part.fTag;
-               fLabel = part.fLabel;
-               fCaloLabel [0] = part.fCaloLabel[0];
-               fCaloLabel [1] = part.fCaloLabel[1];
-               fTrackLabel[0] = part.fTrackLabel[0];
-               fTrackLabel[1] = part.fTrackLabel[1];
-               fDetector =part.fDetector;
-               
-               fDisp = part.fDisp; 
-               fTof = part.fTof; 
-               fCharged = part.fCharged; 
-               fBadDist=part.fBadDist;
-               
-               if (fMomentum ) delete fMomentum;       
-               fMomentum = new TLorentzVector(*part.fMomentum);
-       }
-       
-       return *this;
+  // Assignment operator
+  if(this!=&part) {
+    
+    fPdg = part.fPdg;
+    fTag = part.fTag;
+    fLabel = part.fLabel;
+    fCaloLabel [0] = part.fCaloLabel[0];
+    fCaloLabel [1] = part.fCaloLabel[1];
+    fTrackLabel[0] = part.fTrackLabel[0];
+    fTrackLabel[1] = part.fTrackLabel[1];
+    fDetector =part.fDetector;
+    
+    fDisp = part.fDisp; 
+    fTof = part.fTof; 
+    fCharged = part.fCharged; 
+    fBadDist=part.fBadDist;
+    
+    if (fMomentum ) delete fMomentum;  
+    fMomentum = new TLorentzVector(*part.fMomentum);
+  }
+  
+  return *this;
 }
 
 
 //_______________________________________________________________
 Bool_t AliAODPWG4Particle::IsPIDOK(const Int_t ipid, const Int_t pdgwanted) const{
-       // returns true if particle satisfies given PID criterium
+  // returns true if particle satisfies given PID criterium
        switch(ipid){
-               case 0: return kTRUE ; //No PID at all
-               case 1: 
-               {
-                       if (fPdg == pdgwanted) return kTRUE; 
-                       else return kFALSE; //Overall PID calculated with bayesian methods.
-               }
-               case 2: return fDisp ;   //only dispersion cut
-               case 3: return fTof ;    //Only TOF cut
-               case 4: return fCharged ;    //Only Charged cut
-               case 5: return fDisp && fTof ;  //Dispersion and TOF
-               case 6: return fDisp && fCharged ;  //Dispersion and Charged
-               case 7: return fTof  && fCharged ;  //TOF and Charged
-               case 8: return fDisp && fTof && fCharged ; // all 3 cuts
-               default: return kFALSE ; //Not known combination
+       case 0: return kTRUE ; //No PID at all
+       case 1: 
+         {
+           if (fPdg == pdgwanted) return kTRUE; 
+           else return kFALSE; //Overall PID calculated with bayesian methods.
+         }
+       case 2: return fDisp ;   //only dispersion cut
+       case 3: return fTof ;    //Only TOF cut
+       case 4: return fCharged ;    //Only Charged cut
+       case 5: return fDisp && fTof ;  //Dispersion and TOF
+       case 6: return fDisp && fCharged ;  //Dispersion and Charged
+       case 7: return fTof  && fCharged ;  //TOF and Charged
+       case 8: return fDisp && fTof && fCharged ; // all 3 cuts
+       default: return kFALSE ; //Not known combination
        }
 }
 
 //______________________________________________________________________________
 void AliAODPWG4Particle::Print(Option_t* /*option*/) const 
 {
-       // Print information of all data members
-       printf("Particle 4-vector:\n");
-       printf("     E  = %13.3f\n", E() );
-       printf("     Px = %13.3f\n", Px());
-       printf("     Py = %13.3f\n", Py());
-       printf("     Pz = %13.3f\n", Pz());
-       printf("TOF bit        : %d\n",fTof);
-       printf("Charged bit    : %d\n",fCharged);
-       printf("Dispersion bit : %d\n",fDisp);
-       printf("pdg : %d\n",fPdg);
-       printf("tag : %d\n",fTag);  
-       printf("Trigger Detector : %s\n",fDetector.Data());
-       
+  // Print information of all data members
+  printf("Particle 4-vector:\n");
+  printf("     E  = %13.3f\n", E() );
+  printf("     Px = %13.3f\n", Px());
+  printf("     Py = %13.3f\n", Py());
+  printf("     Pz = %13.3f\n", Pz());
+  printf("TOF bit        : %d\n",fTof);
+  printf("Charged bit    : %d\n",fCharged);
+  printf("Dispersion bit : %d\n",fDisp);
+  printf("pdg : %d\n",fPdg);
+  printf("tag : %d\n",fTag);  
+  printf("Trigger Detector : %s\n",fDetector.Data());
+  
 }
index 40547b81e0677eda4e8455d466ce05da4890b05d..e787de4edb173629c596fbb65dcd8e415709890d 100755 (executable)
@@ -19,85 +19,85 @@ class TString;
 #include "AliVParticle.h"
 
 class AliAODPWG4Particle : public AliVParticle {
-
+  
  public:
-    AliAODPWG4Particle();
-    AliAODPWG4Particle(Double_t px, Double_t py, Double_t pz, Double_t e);
-    AliAODPWG4Particle(TLorentzVector & p);  
-    virtual ~AliAODPWG4Particle();
-    AliAODPWG4Particle(const AliAODPWG4Particle& photon); 
-    AliAODPWG4Particle& operator=(const AliAODPWG4Particle& photon);
-
-    // AliVParticle methods
-    virtual Double_t Px()         const { return fMomentum->Px();      }
-    virtual Double_t Py()         const { return fMomentum->Py();      }
-    virtual Double_t Pz()         const { return fMomentum->Pz();      }
-    virtual Double_t Pt()         const { return fMomentum->Pt();      }
-    virtual Double_t P()          const { return fMomentum->P();       }
-    virtual Bool_t   PxPyPz(Double_t p[3]) const { p[0] = Px(); p[1] = Py(); p[2] = Pz(); return kTRUE; }
-    virtual Double_t OneOverPt()  const { return 1. / fMomentum->Pt(); }
-    virtual Double_t Phi()        const;
-    virtual Double_t Theta()      const { return fMomentum->Theta();   }
-    virtual Double_t E()          const { return fMomentum->E();       }
-    virtual Double_t M()          const { return fMomentum->M();       }
-    virtual Double_t Eta()        const { return fMomentum->Eta();     }
-    virtual Double_t Y()          const { return fMomentum->Rapidity();}
-    virtual Double_t Xv()         const {return -999.;} // put reasonable values here
-    virtual Double_t Yv()         const {return -999.;} //
-    virtual Double_t Zv()         const {return -999.;} //
-    virtual Bool_t   XvYvZv(Double_t x[3]) const { x[0] = Xv(); x[1] = Yv(); x[2] = Zv(); return kTRUE; }  
-    virtual void     Print(Option_t* /*option*/) const;
-
-    //
-    //Dummy
-    virtual Short_t Charge()      const { return 0;}
-    virtual const Double_t* PID() const { return NULL;}
-    //
-
-    virtual Int_t GetPdg()   const {return fPdg ; }
-    virtual Int_t GetTag()   const {return fTag ; }
-    virtual Int_t GetLabel()   const {return fLabel ; }
-       virtual Int_t GetCaloLabel (Int_t i) const {return fCaloLabel[i];}
-       virtual Int_t GetTrackLabel(Int_t i) const {return fTrackLabel[i];}
-    virtual TString GetDetector()   const {return fDetector ; }
-
-    virtual Bool_t   GetDispBit(void) const {return fDisp;}
-    virtual Bool_t   GetTOFBit(void) const {return fTof;}
-    virtual Bool_t   GetChargedBit(void) const {return fCharged;}
-    virtual Int_t    DistToBad() const  {return fBadDist ;} 
-
-    virtual void SetPdg(Int_t pdg)   {fPdg = pdg ; }
-    virtual void SetTag(Int_t tag)   {fTag = tag ; }
-    virtual void SetLabel(Int_t l)   {fLabel = l ; }
-       virtual void SetCaloLabel (Int_t a, Int_t b)   {fCaloLabel [0] = a; fCaloLabel [1] = b  ; }
-       virtual void SetTrackLabel(Int_t a, Int_t b)   {fTrackLabel[0] = a; fTrackLabel[1] = b  ; }
-       virtual void SetDetector(TString d)   {fDetector = d ; }
+  AliAODPWG4Particle();
+  AliAODPWG4Particle(Double_t px, Double_t py, Double_t pz, Double_t e);
+  AliAODPWG4Particle(TLorentzVector & p);  
+  virtual ~AliAODPWG4Particle();
+  AliAODPWG4Particle(const AliAODPWG4Particle& photon); 
+  AliAODPWG4Particle& operator=(const AliAODPWG4Particle& photon);
+  
+  // AliVParticle methods
+  virtual Double_t Px()         const { return fMomentum->Px();      }
+  virtual Double_t Py()         const { return fMomentum->Py();      }
+  virtual Double_t Pz()         const { return fMomentum->Pz();      }
+  virtual Double_t Pt()         const { return fMomentum->Pt();      }
+  virtual Double_t P()          const { return fMomentum->P();       }
+  virtual Bool_t   PxPyPz(Double_t p[3]) const { p[0] = Px(); p[1] = Py(); p[2] = Pz(); return kTRUE; }
+  virtual Double_t OneOverPt()  const { return 1. / fMomentum->Pt(); }
+  virtual Double_t Phi()        const;
+  virtual Double_t Theta()      const { return fMomentum->Theta();   }
+  virtual Double_t E()          const { return fMomentum->E();       }
+  virtual Double_t M()          const { return fMomentum->M();       }
+  virtual Double_t Eta()        const { return fMomentum->Eta();     }
+  virtual Double_t Y()          const { return fMomentum->Rapidity();}
+  virtual Double_t Xv()         const {return -999.;} // put reasonable values here
+  virtual Double_t Yv()         const {return -999.;} //
+  virtual Double_t Zv()         const {return -999.;} //
+  virtual Bool_t   XvYvZv(Double_t x[3]) const { x[0] = Xv(); x[1] = Yv(); x[2] = Zv(); return kTRUE; }  
+  virtual void     Print(Option_t* /*option*/) const;
+  
+  //
+  //Dummy
+  virtual Short_t Charge()      const { return 0;}
+  virtual const Double_t* PID() const { return NULL;}
+  //
+  
+  virtual Int_t GetPdg()   const {return fPdg ; }
+  virtual Int_t GetTag()   const {return fTag ; }
+  virtual Int_t GetLabel()   const {return fLabel ; }
+  virtual Int_t GetCaloLabel (Int_t i) const {return fCaloLabel[i];}
+  virtual Int_t GetTrackLabel(Int_t i) const {return fTrackLabel[i];}
+  virtual TString GetDetector()   const {return fDetector ; }
 
-    virtual void SetDispBit(Bool_t chi2){fDisp = chi2 ;} 
-    virtual void SetTOFBit(Bool_t tof){fTof = tof ;} 
-    virtual void SetChargedBit(Bool_t ch){fCharged = ch; }
-    virtual void SetDistToBad(Int_t dist){fBadDist=dist;} 
+  virtual Bool_t   GetDispBit(void) const {return fDisp;}
+  virtual Bool_t   GetTOFBit(void) const {return fTof;}
+  virtual Bool_t   GetChargedBit(void) const {return fCharged;}
+  virtual Int_t    DistToBad() const  {return fBadDist ;} 
+  
+  virtual void SetPdg(Int_t pdg)   {fPdg = pdg ; }
+  virtual void SetTag(Int_t tag)   {fTag = tag ; }
+  virtual void SetLabel(Int_t l)   {fLabel = l ; }
+  virtual void SetCaloLabel (Int_t a, Int_t b)   {fCaloLabel [0] = a; fCaloLabel [1] = b  ; }
+  virtual void SetTrackLabel(Int_t a, Int_t b)   {fTrackLabel[0] = a; fTrackLabel[1] = b  ; }
+  virtual void SetDetector(TString d)   {fDetector = d ; }
   
-       TLorentzVector  * Momentum() const {return fMomentum ; }
-    virtual void SetMomentum(TLorentzVector *lv) {fMomentum = lv ; }
+  virtual void SetDispBit(Bool_t chi2){fDisp = chi2 ;} 
+  virtual void SetTOFBit(Bool_t tof){fTof = tof ;} 
+  virtual void SetChargedBit(Bool_t ch){fCharged = ch; }
+  virtual void SetDistToBad(Int_t dist){fBadDist=dist;} 
   
-       Bool_t IsPIDOK(const Int_t ipid, const Int_t pdgwanted) const;
+  TLorentzVector       * Momentum() const {return fMomentum ; }
+  virtual void SetMomentum(TLorentzVector *lv) {fMomentum = lv ; }
+  
+  Bool_t IsPIDOK(const Int_t ipid, const Int_t pdgwanted) const;
   
  private:
-    TLorentzVector* fMomentum;  // Photon 4-momentum vector
-    Int_t           fPdg;       // id of particle
-    Int_t           fTag;       // tag of particle (decay, fragment, prompt photon)
-    Int_t           fLabel;     // MC label
-       Int_t                   fCaloLabel[2];  // CaloCluster index, 1 for photons, 2 for pi0.
-       Int_t           fTrackLabel[2]; // Track lable, 1 for pions, 2 for conversion photons 
-    TString         fDetector;  // Detector where particle was measured.
-       
-    Bool_t                     fDisp ;     //Dispersion bit
-    Bool_t                     fTof ;      //TOF bit
-    Bool_t                     fCharged ;  //Charged bit
-    Int_t           fBadDist ;  //Distance to bad module in module units
-       
-       ClassDef(AliAODPWG4Particle,1);
+  TLorentzVector* fMomentum;  // Photon 4-momentum vector
+  Int_t           fPdg;       // id of particle
+  Int_t           fTag;       // tag of particle (decay, fragment, prompt photon)
+  Int_t           fLabel;     // MC label
+  Int_t                  fCaloLabel[2];  // CaloCluster index, 1 for photons, 2 for pi0.
+  Int_t           fTrackLabel[2]; // Track lable, 1 for pions, 2 for conversion photons 
+  TString         fDetector;  // Detector where particle was measured.
+  
+  Bool_t         fDisp ;     //Dispersion bit
+  Bool_t         fTof ;      //TOF bit
+  Bool_t         fCharged ;  //Charged bit
+  Int_t           fBadDist ;  //Distance to bad module in module units
+  
+  ClassDef(AliAODPWG4Particle,1);
 };
 
 inline Double_t AliAODPWG4Particle::Phi() const
index 60f06750c2fa99166ed99def3313f0429d752cd6..421266a6a41991a9549079dc91538e2e8c586c72 100755 (executable)
 
 //-- Analysis system
 #include "AliAODPWG4ParticleCorrelation.h"
-#include "AliAODJet.h"
 
 ClassImp(AliAODPWG4ParticleCorrelation)
 
 
 //______________________________________________________________________________
-AliAODPWG4ParticleCorrelation::AliAODPWG4ParticleCorrelation() :
-    AliAODPWG4Particle(), fIsolated(kFALSE),
-    fRefTracks(new TRefArray()), fRefClusters(new TRefArray()),
-    fRefIsolationConeTracks(new TRefArray()), fRefIsolationConeClusters(new TRefArray()),
-    fRefBackgroundTracks(new TRefArray()), fRefBackgroundClusters(new TRefArray()),  
-    fLeadingDetector(""), fLeading(), fCorrJet(),  fCorrBkg(), fRefJet(0)
+ AliAODPWG4ParticleCorrelation::AliAODPWG4ParticleCorrelation() :
+   AliAODPWG4Particle(), fIsolated(kFALSE),
+   fRefTracks(new TRefArray()), fRefClusters(new TRefArray()),
+   fRefIsolationConeTracks(new TRefArray()), fRefIsolationConeClusters(new TRefArray()),
+   fRefBackgroundTracks(new TRefArray()), fRefBackgroundClusters(new TRefArray()),  
+   fLeadingDetector(""), fLeading(), fCorrJet(),  fCorrBkg(), fRefJet(0)
 {
   // constructor
 }
 
 //______________________________________________________________________________
 AliAODPWG4ParticleCorrelation::AliAODPWG4ParticleCorrelation(Double_t px, Double_t py, Double_t pz, Double_t e):
-    AliAODPWG4Particle(), fIsolated(kFALSE),
-    fRefTracks(new TRefArray()), fRefClusters(new TRefArray()),
-    fRefIsolationConeTracks(new TRefArray()), fRefIsolationConeClusters(new TRefArray()),
-    fRefBackgroundTracks(new TRefArray()), fRefBackgroundClusters(new TRefArray()),
-    fLeadingDetector(""),  fLeading(), fCorrJet(),
-    fCorrBkg(), fRefJet(0)
+  AliAODPWG4Particle(), fIsolated(kFALSE),
+  fRefTracks(new TRefArray()), fRefClusters(new TRefArray()),
+  fRefIsolationConeTracks(new TRefArray()), fRefIsolationConeClusters(new TRefArray()),
+  fRefBackgroundTracks(new TRefArray()), fRefBackgroundClusters(new TRefArray()),
+  fLeadingDetector(""),  fLeading(), fCorrJet(),
+  fCorrBkg(), fRefJet(0)
 {
   // constructor
-    SetMomentum(new TLorentzVector(px, py, pz, e));
+  SetMomentum(new TLorentzVector(px, py, pz, e));
 }
 
 //______________________________________________________________________________
 AliAODPWG4ParticleCorrelation::AliAODPWG4ParticleCorrelation(TLorentzVector & p):
-    AliAODPWG4Particle(p), fIsolated(kFALSE),
-    fRefTracks(new TRefArray()), fRefClusters(new TRefArray()),
-    fRefIsolationConeTracks(new TRefArray()), fRefIsolationConeClusters(new TRefArray()),
-    fRefBackgroundTracks(new TRefArray()), fRefBackgroundClusters(new TRefArray()),  
-    fLeadingDetector(""),  fLeading(), fCorrJet(), fCorrBkg(),fRefJet(0)
+  AliAODPWG4Particle(p), fIsolated(kFALSE),
+  fRefTracks(new TRefArray()), fRefClusters(new TRefArray()),
+  fRefIsolationConeTracks(new TRefArray()), fRefIsolationConeClusters(new TRefArray()),
+  fRefBackgroundTracks(new TRefArray()), fRefBackgroundClusters(new TRefArray()),  
+  fLeadingDetector(""),  fLeading(), fCorrJet(), fCorrBkg(),fRefJet(0)
 {
   // constructor
 }
 
 //______________________________________________________________________________
 AliAODPWG4ParticleCorrelation::AliAODPWG4ParticleCorrelation(AliAODPWG4Particle & p):
-    AliAODPWG4Particle(p), fIsolated(kFALSE),
-    fRefTracks(new TRefArray()), fRefClusters(new TRefArray()),
-    fRefIsolationConeTracks(new TRefArray()), fRefIsolationConeClusters(new TRefArray()),
-    fRefBackgroundTracks(new TRefArray()), fRefBackgroundClusters(new TRefArray()),  
-    fLeadingDetector(""),  fLeading(), fCorrJet(), fCorrBkg(),fRefJet(0)
+  AliAODPWG4Particle(p), fIsolated(kFALSE),
+  fRefTracks(new TRefArray()), fRefClusters(new TRefArray()),
+  fRefIsolationConeTracks(new TRefArray()), fRefIsolationConeClusters(new TRefArray()),
+  fRefBackgroundTracks(new TRefArray()), fRefBackgroundClusters(new TRefArray()),  
+  fLeadingDetector(""),  fLeading(), fCorrJet(), fCorrBkg(),fRefJet(0)
 {
   // constructor
-
+  
 }
 
 //______________________________________________________________________________
 AliAODPWG4ParticleCorrelation::~AliAODPWG4ParticleCorrelation() 
 {
   // destructor
-    delete fRefTracks;
-    delete fRefClusters;
-    delete fRefIsolationConeTracks;
-    delete fRefIsolationConeClusters;
-    delete fRefBackgroundTracks;
-    delete fRefBackgroundClusters;
-
+  delete fRefTracks;
+  delete fRefClusters;
+  delete fRefIsolationConeTracks;
+  delete fRefIsolationConeClusters;
+  delete fRefBackgroundTracks;
+  delete fRefBackgroundClusters;
+  
 }
 
 //______________________________________________________________________________
 AliAODPWG4ParticleCorrelation::AliAODPWG4ParticleCorrelation(const AliAODPWG4ParticleCorrelation& part) :
-    AliAODPWG4Particle(part), fIsolated(part.fIsolated),
-    fRefTracks(), fRefClusters(),
-    fRefIsolationConeTracks(), fRefIsolationConeClusters(),
-    fRefBackgroundTracks(), fRefBackgroundClusters(),   
-    fLeadingDetector(part.fLeadingDetector), fLeading(part.fLeading),  
-    fCorrJet(part.fCorrJet), fCorrBkg(part.fCorrBkg), fRefJet(part.fRefJet)
+  AliAODPWG4Particle(part), fIsolated(part.fIsolated),
+  fRefTracks(), fRefClusters(),
+  fRefIsolationConeTracks(), fRefIsolationConeClusters(),
+  fRefBackgroundTracks(), fRefBackgroundClusters(),   
+  fLeadingDetector(part.fLeadingDetector), fLeading(part.fLeading),  
+  fCorrJet(part.fCorrJet), fCorrBkg(part.fCorrBkg), fRefJet(part.fRefJet)
 {
   // Copy constructor
   fRefTracks                = new TRefArray(*part.fRefTracks);
@@ -114,27 +113,27 @@ AliAODPWG4ParticleCorrelation& AliAODPWG4ParticleCorrelation::operator=(const Al
   // Assignment operator
   if(this!=&part) {
   
-       fIsolated = part.fIsolated;
-       fRefJet   = part.fRefJet ;
-       fLeadingDetector =part.fLeadingDetector;
-       fLeading  = part.fLeading;
-       fCorrJet  = part.fCorrJet ;
-       fCorrBkg  = part.fCorrBkg;
-
-       if( fRefTracks )               delete fRefTracks ;
-       if( fRefClusters)              delete fRefClusters ;
-       if( fRefIsolationConeTracks )  delete fRefIsolationConeTracks ;
-       if( fRefIsolationConeClusters) delete fRefIsolationConeClusters ;
-       if( fRefBackgroundTracks )     delete fRefBackgroundTracks ;
-       if( fRefBackgroundClusters )   delete fRefBackgroundClusters ;
-
-       fRefTracks                = new TRefArray(*part.fRefTracks);
-       fRefClusters              = new TRefArray(*part.fRefClusters);
-       fRefIsolationConeTracks   = new TRefArray(*part.fRefIsolationConeTracks);
-       fRefIsolationConeClusters = new TRefArray(*part.fRefIsolationConeClusters);
-       fRefBackgroundTracks      = new TRefArray(*part.fRefBackgroundTracks);
-       fRefBackgroundClusters    = new TRefArray(*part.fRefBackgroundClusters);  
-  
+    fIsolated = part.fIsolated;
+    fRefJet   = part.fRefJet ;
+    fLeadingDetector =part.fLeadingDetector;
+    fLeading  = part.fLeading;
+    fCorrJet  = part.fCorrJet ;
+    fCorrBkg  = part.fCorrBkg;
+    
+    if( fRefTracks )               delete fRefTracks ;
+    if( fRefClusters)              delete fRefClusters ;
+    if( fRefIsolationConeTracks )  delete fRefIsolationConeTracks ;
+    if( fRefIsolationConeClusters) delete fRefIsolationConeClusters ;
+    if( fRefBackgroundTracks )     delete fRefBackgroundTracks ;
+    if( fRefBackgroundClusters )   delete fRefBackgroundClusters ;
+    
+    fRefTracks                = new TRefArray(*part.fRefTracks);
+    fRefClusters              = new TRefArray(*part.fRefClusters);
+    fRefIsolationConeTracks   = new TRefArray(*part.fRefIsolationConeTracks);
+    fRefIsolationConeClusters = new TRefArray(*part.fRefIsolationConeClusters);
+    fRefBackgroundTracks      = new TRefArray(*part.fRefBackgroundTracks);
+    fRefBackgroundClusters    = new TRefArray(*part.fRefBackgroundClusters);  
+    
   }
   
   return *this;
index ed9eae4fae3e886847ed56689be493e82b21ecc4..6a6c28b2745de6130b17a6fdd8b6a2286b2622df 100755 (executable)
 //-- ROOT system --
 
 //-- Analysis system
-#include "AliAODJet.h" 
+#include "AliAODJet.h"
 #include "AliAODPWG4Particle.h"
 
 class AliAODPWG4ParticleCorrelation : public AliAODPWG4Particle {
 
  public:
-    AliAODPWG4ParticleCorrelation();
-    AliAODPWG4ParticleCorrelation(Double_t px, Double_t py, Double_t pz, Double_t e);
-    AliAODPWG4ParticleCorrelation(TLorentzVector & p);  
-    AliAODPWG4ParticleCorrelation(AliAODPWG4Particle & p);  
-
-    virtual ~AliAODPWG4ParticleCorrelation();
-    AliAODPWG4ParticleCorrelation(const AliAODPWG4ParticleCorrelation& photon); 
-    AliAODPWG4ParticleCorrelation& operator=(const AliAODPWG4ParticleCorrelation& photon);
-
-    virtual Bool_t IsIsolated() const { return fIsolated ;}
-    virtual void    SetIsolated(Bool_t iso) {fIsolated = iso ;}
-
-    virtual TRefArray* GetRefTracks()    const { return  fRefTracks;}
-    virtual void       AddTrack(TObject *tr) {fRefTracks->Add(tr);}
-    virtual TObject*   GetTrack(Int_t i) const { return fRefTracks->At(i);}
-
-    virtual TRefArray* GetRefClusters()    const { return  fRefClusters;}
-    virtual void       AddCluster(TObject *tr) {fRefClusters->Add(tr);}
-    virtual TObject*   GetCluster(Int_t i) const { return fRefClusters->At(i);}
-
-    virtual TRefArray* GetRefIsolationConeTracks()  const { return  fRefIsolationConeTracks;}
-    virtual void     AddIsolationConeTrack(TObject *tr) {fRefIsolationConeTracks->Add(tr);}
-    virtual TObject* GetIsolationConeTrack(Int_t i) const { return fRefIsolationConeTracks->At(i);}
-
-    virtual TRefArray* GetRefIsolationConeClusters()  const { return  fRefIsolationConeClusters;}
-    virtual void     AddIsolationConeCluster(TObject *tr) {fRefIsolationConeClusters->Add(tr);}
-    virtual TObject* GetIsolationConeCluster(Int_t i) const { return fRefIsolationConeClusters->At(i);}
-
-    virtual TRefArray* GetRefBackgroundTracks()  const { return  fRefBackgroundTracks;}
-    virtual void     AddBackgroundTrack(TObject *tr) {fRefBackgroundTracks->Add(tr);}
-    virtual TObject* GetBackgroundTrack(Int_t i) const { return fRefBackgroundTracks->At(i);}
-
-    virtual TRefArray* GetRefBackgroundClusters()    const { return  fRefBackgroundClusters;}
-    virtual void       AddBackgroundCluster(TObject *tr) {fRefBackgroundClusters->Add(tr);}
-    virtual TObject*   GetBackgroundCluster(Int_t i) const { return fRefBackgroundClusters->At(i);}
-
-    virtual TString GetLeadingDetector()   const {return fLeadingDetector ; }
-    virtual void SetLeadingDetector(TString d)   {fLeadingDetector = d ; }
-    
-    virtual TLorentzVector  GetLeading()               const { return  fLeading;}
-    virtual void  SetLeading(TLorentzVector lead) {fLeading = lead;}
-
-    virtual TLorentzVector  GetCorrelatedJet()         const { return  fCorrJet;}
-    virtual void  SetCorrelatedJet(TLorentzVector jet) {fCorrJet = jet;}
-
-    virtual TLorentzVector  GetCorrelatedBackground()  const { return  fCorrBkg;}
-    virtual void  SetCorrelatedBackground(TLorentzVector bkg) {fCorrBkg = bkg;}
-
-    virtual void SetRefJet(AliAODJet* jet)  { fRefJet = jet;}
-    virtual      AliAODJet* GetJet() const {return ((AliAODJet*) fRefJet.GetObject());}
-    virtual TRef GetRefJet()         const {return fRefJet;}
-
-    virtual void   Print(Option_t* /*option*/) const;
-
+  AliAODPWG4ParticleCorrelation();
+  AliAODPWG4ParticleCorrelation(Double_t px, Double_t py, Double_t pz, Double_t e);
+  AliAODPWG4ParticleCorrelation(TLorentzVector & p);  
+  AliAODPWG4ParticleCorrelation(AliAODPWG4Particle & p);  
+  
+  virtual ~AliAODPWG4ParticleCorrelation();
+  AliAODPWG4ParticleCorrelation(const AliAODPWG4ParticleCorrelation& photon); 
+  AliAODPWG4ParticleCorrelation& operator=(const AliAODPWG4ParticleCorrelation& photon);
+  
+  virtual Bool_t IsIsolated() const { return fIsolated ;}
+  virtual void    SetIsolated(Bool_t iso) {fIsolated = iso ;}
+  
+  virtual TRefArray* GetRefTracks()    const { return  fRefTracks;}
+  virtual void       AddTrack(TObject *tr) {fRefTracks->Add(tr);}
+  virtual TObject*   GetTrack(Int_t i) const { return fRefTracks->At(i);}
+  
+  virtual TRefArray* GetRefClusters()    const { return  fRefClusters;}
+  virtual void       AddCluster(TObject *tr) {fRefClusters->Add(tr);}
+  virtual TObject*   GetCluster(Int_t i) const { return fRefClusters->At(i);}
+  
+  virtual TRefArray* GetRefIsolationConeTracks()  const { return  fRefIsolationConeTracks;}
+  virtual void     AddIsolationConeTrack(TObject *tr) {fRefIsolationConeTracks->Add(tr);}
+  virtual TObject* GetIsolationConeTrack(Int_t i) const { return fRefIsolationConeTracks->At(i);}
+  
+  virtual TRefArray* GetRefIsolationConeClusters()  const { return  fRefIsolationConeClusters;}
+  virtual void     AddIsolationConeCluster(TObject *tr)  {fRefIsolationConeClusters->Add(tr);}
+  virtual TObject* GetIsolationConeCluster(Int_t i) const { return fRefIsolationConeClusters->At(i);}
+  
+  virtual TRefArray* GetRefBackgroundTracks()  const { return  fRefBackgroundTracks;}
+  virtual void     AddBackgroundTrack(TObject *tr) {fRefBackgroundTracks->Add(tr);}
+  virtual TObject* GetBackgroundTrack(Int_t i) const { return fRefBackgroundTracks->At(i);}
+  
+  virtual TRefArray* GetRefBackgroundClusters()    const { return  fRefBackgroundClusters;}
+  virtual void       AddBackgroundCluster(TObject *tr) {fRefBackgroundClusters->Add(tr);}
+  virtual TObject*   GetBackgroundCluster(Int_t i) const { return fRefBackgroundClusters->At(i);}
+  
+  virtual TString GetLeadingDetector()   const {return fLeadingDetector ; }
+  virtual void SetLeadingDetector(TString d)   {fLeadingDetector = d ; }
+  
+  virtual TLorentzVector  GetLeading()               const { return  fLeading;}
+  virtual void  SetLeading(TLorentzVector lead) {fLeading = lead;}
+  
+  virtual TLorentzVector  GetCorrelatedJet()         const { return  fCorrJet;}
+  virtual void  SetCorrelatedJet(TLorentzVector jet) {fCorrJet = jet;}
+  
+  virtual TLorentzVector  GetCorrelatedBackground()  const { return  fCorrBkg;}
+  virtual void  SetCorrelatedBackground(TLorentzVector bkg) {fCorrBkg = bkg;}
+  
+  virtual void SetRefJet(AliAODJet* jet)  { fRefJet = jet;}
+  virtual      AliAODJet* GetJet() const {return ((AliAODJet*) fRefJet.GetObject());}
+  virtual TRef GetRefJet()         const {return fRefJet;}
+  
+  virtual void   Print(Option_t* /*option*/) const;
+  
  private:
-
-    Bool_t                fIsolated ; //Particle is isolated or not
-       
-    TRefArray*     fRefTracks;  // array of references to the tracks belonging to the jet / all selected hadrons  
-    TRefArray*     fRefClusters; // array of references to the clusters belonging to the jet / all selected hadrons  
-    
-    TRefArray*     fRefIsolationConeTracks;  // array of references to the tracks belonging to the cone around direct particle candidate  
-    TRefArray*     fRefIsolationConeClusters; // array of references to the clusters belonging to the  cone around direct particle candidate  
-
-    TRefArray*     fRefBackgroundTracks;  // array of references to the tracks for background stimation
-    TRefArray*     fRefBackgroundClusters; // array of references to the clusters for background stimation 
-
-    TString        fLeadingDetector; // Detector where leading particle was measured.
-    TLorentzVector fLeading;     // Leading Particle 4-momentum vector
-    
-    TLorentzVector fCorrJet;     // Jet  4-momentum vector
-    TLorentzVector fCorrBkg;     // Background  4-momentum vector
-
-    TRef           fRefJet; // Rerence to jet found with JETAN and correlated with particle
-
-    ClassDef(AliAODPWG4ParticleCorrelation,1);
+  
+  Bool_t        fIsolated ; //Particle is isolated or not
+  
+  TRefArray*     fRefTracks;  // array of references to the tracks belonging to the jet / all selected hadrons  
+  TRefArray*     fRefClusters; // array of references to the clusters belonging to the jet / all selected hadrons  
+  
+  TRefArray*     fRefIsolationConeTracks;  // array of references to the tracks belonging to the cone around direct particle candidate  
+  TRefArray*     fRefIsolationConeClusters; // array of references to the clusters belonging to the  cone around direct particle candidate  
+  
+  TRefArray*     fRefBackgroundTracks;  // array of references to the tracks for background stimation
+  TRefArray*     fRefBackgroundClusters; // array of references to the clusters for background stimation 
+  
+  TString        fLeadingDetector; // Detector where leading particle was measured.
+  TLorentzVector fLeading;     // Leading Particle 4-momentum vector
+  
+  TLorentzVector fCorrJet;     // Jet  4-momentum vector
+  TLorentzVector fCorrBkg;     // Background  4-momentum vector
+  
+  TRef           fRefJet; // Rerence to jet found with JETAN and correlated with particle
+  
+  ClassDef(AliAODPWG4ParticleCorrelation,1);
 };
 
 
index bee184fed3acb50a23a1a8736727fd472fc93fd0..42de88722971793ae177aaee5c390e2a01dbc5ad 100755 (executable)
 
 // --- ROOT system ---
 #include <TClonesArray.h>
+//#include <Riostream.h>
 
 //---- AliRoot system ----
-#include "AliAODPWG4Particle.h"
-#include "AliAODCaloCluster.h"
-#include "AliAODCaloCells.h"
-#include "AliAODTrack.h"
+#include "AliAODPWG4ParticleCorrelation.h"
 #include "AliAnaPartCorrBaseClass.h"
 #include "AliCaloTrackReader.h"
 #include "AliCaloPID.h"
@@ -35,8 +33,8 @@
 #include "AliIsolationCut.h"
 #include "AliMCAnalysisUtils.h"
 #include "AliNeutralMesonSelection.h"
-#include "AliLog.h"
-#include "AliAODPWG4ParticleCorrelation.h"
+#include "AliAODCaloCells.h" 
+#include "AliAODEvent.h"
 
 ClassImp(AliAnaPartCorrBaseClass)
   
@@ -48,7 +46,7 @@ ClassImp(AliAnaPartCorrBaseClass)
     fReader(0x0), fInputAODBranch(0x0), fInputAODName(""),
     fOutputAODBranch(0x0), fNewAOD(kFALSE),
     fOutputAODName(""), fOutputAODClassName(""),
-    fAODCaloClusters(0x0), fAODCaloCells(0x0), 
+    fAODCaloCells(0x0),//fAODCaloClusters(0x0),  
     fCaloPID(0x0), fFidCut(0x0), fIC(0x0),fMCUtils(0x0), fNMS(0x0),
     fHistoNPtBins(0),  fHistoPtMax(0.),  fHistoPtMin(0.),
     fHistoNPhiBins(0), fHistoPhiMax(0.), fHistoPhiMin(0.),
@@ -75,7 +73,7 @@ AliAnaPartCorrBaseClass::AliAnaPartCorrBaseClass(const AliAnaPartCorrBaseClass &
   fInputAODBranch(new TClonesArray(*abc.fInputAODBranch)), fInputAODName(abc.fInputAODName),
   fOutputAODBranch(new TClonesArray(*abc.fOutputAODBranch)),fNewAOD(abc.fNewAOD), 
   fOutputAODName(abc.fOutputAODName), fOutputAODClassName(abc.fOutputAODClassName),
-  fAODCaloClusters(new TClonesArray(*abc.fAODCaloClusters)),
+  //fAODCaloClusters(new TClonesArray(*abc.fAODCaloClusters)),
   fAODCaloCells(new AliAODCaloCells(*abc.fAODCaloCells)),
   fCaloPID(abc.fCaloPID), fFidCut(abc.fFidCut), fIC(abc.fIC),fMCUtils(abc.fMCUtils), fNMS(abc.fNMS),
   fHistoNPtBins(abc.fHistoNPtBins),   fHistoPtMax(abc.fHistoPtMax),   fHistoPtMin(abc.fHistoPtMin),
@@ -89,42 +87,42 @@ AliAnaPartCorrBaseClass::AliAnaPartCorrBaseClass(const AliAnaPartCorrBaseClass &
 //_________________________________________________________________________
 AliAnaPartCorrBaseClass & AliAnaPartCorrBaseClass::operator = (const AliAnaPartCorrBaseClass & abc)
 {
-       // assignment operator
-       
-       if(this == &abc) return *this;
-       ((TObject *)this)->operator=(abc);
-       
-       fDataMC             = abc.fDataMC;
-       fDebug              = abc.fDebug ;
-       fRecalculateCaloPID = abc.fRecalculateCaloPID ;
-       fCheckCaloPID       = abc.fCheckCaloPID ;
-       fCheckFidCut        = abc.fCheckFidCut ; 
-       
-       fReader             = abc.fReader ;
-       fAODCaloClusters   = new TClonesArray(*abc.fAODCaloClusters) ;
-       fAODCaloCells      = new AliAODCaloCells(*abc.fAODCaloCells) ;
-       
-       fMinPt   = abc.fMinPt;
-       fMaxPt   = abc.fMaxPt;
-       fCaloPID = abc.fCaloPID;  
-       fFidCut  = abc.fFidCut;
-       fIC      = abc.fIC;
-       fMCUtils = abc.fMCUtils;
-       fNMS     = abc.fNMS;
-               
-       fInputAODBranch     = new TClonesArray(*abc.fInputAODBranch) ;
-       fInputAODName       = abc.fInputAODName;
-       fOutputAODBranch    = new TClonesArray(*abc.fOutputAODBranch) ;
-       fNewAOD             = abc.fNewAOD ; 
-       fOutputAODName      = abc.fOutputAODName; 
-       fOutputAODClassName = abc.fOutputAODClassName;
-       
-       fHistoNPtBins  = abc.fHistoNPtBins;  fHistoPtMax  = abc.fHistoPtMax;  fHistoPtMin  = abc.fHistoPtMin;
-       fHistoNPhiBins = abc.fHistoNPhiBins; fHistoPhiMax = abc.fHistoPhiMax; fHistoPhiMin = abc.fHistoPhiMin;
-       fHistoNEtaBins = abc.fHistoNEtaBins; fHistoEtaMax = abc.fHistoEtaMax; fHistoEtaMin = abc.fHistoEtaMin;
-       
-       return *this;
+  // assignment operator
+  
+  if(this == &abc) return *this;
+  ((TObject *)this)->operator=(abc);
+  
+  fDataMC             = abc.fDataMC;
+  fDebug              = abc.fDebug ;
+  fRecalculateCaloPID = abc.fRecalculateCaloPID ;
+  fCheckCaloPID       = abc.fCheckCaloPID ;
+  fCheckFidCut        = abc.fCheckFidCut ; 
        
+  fReader             = abc.fReader ;
+  //fAODCaloClusters   = new TClonesArray(*abc.fAODCaloClusters) ;
+  fAODCaloCells      = new AliAODCaloCells(*abc.fAODCaloCells) ;
+  
+  fMinPt   = abc.fMinPt;
+  fMaxPt   = abc.fMaxPt;
+  fCaloPID = abc.fCaloPID;  
+  fFidCut  = abc.fFidCut;
+  fIC      = abc.fIC;
+  fMCUtils = abc.fMCUtils;
+  fNMS     = abc.fNMS;
+  
+  fInputAODBranch     = new TClonesArray(*abc.fInputAODBranch) ;
+  fInputAODName       = abc.fInputAODName;
+  fOutputAODBranch    = new TClonesArray(*abc.fOutputAODBranch) ;
+  fNewAOD             = abc.fNewAOD ; 
+  fOutputAODName      = abc.fOutputAODName; 
+  fOutputAODClassName = abc.fOutputAODClassName;
+  
+  fHistoNPtBins  = abc.fHistoNPtBins;  fHistoPtMax  = abc.fHistoPtMax;  fHistoPtMin  = abc.fHistoPtMin;
+  fHistoNPhiBins = abc.fHistoNPhiBins; fHistoPhiMax = abc.fHistoPhiMax; fHistoPhiMin = abc.fHistoPhiMin;
+  fHistoNEtaBins = abc.fHistoNEtaBins; fHistoEtaMax = abc.fHistoEtaMax; fHistoEtaMin = abc.fHistoEtaMin;
+  
+  return *this;
+  
 }
 
 //____________________________________________________________________________
@@ -132,79 +130,84 @@ AliAnaPartCorrBaseClass::~AliAnaPartCorrBaseClass()
 {
   // Remove all pointers except analysis output pointers.
        
-    if(fOutputAODBranch){
-               fOutputAODBranch->Clear() ; 
-               delete fOutputAODBranch ;
-       }
-       
-    if(fInputAODBranch){
-               fInputAODBranch->Clear() ; 
-               delete fInputAODBranch ;
-       }
-       
-       if(fAODCaloClusters){
-               fAODCaloClusters->Clear() ; 
-               delete fAODCaloClusters ;
-       }
-       
-       if(fAODCaloCells){
-               fAODCaloCells->Clear() ; 
-               delete fAODCaloCells ;
-       }
+  if(fOutputAODBranch){
+    fOutputAODBranch->Clear() ; 
+    delete fOutputAODBranch ;
+  }
+  
+  if(fInputAODBranch){
+    fInputAODBranch->Clear() ; 
+    delete fInputAODBranch ;
+  }
+  
+//     if(fAODCaloClusters){
+//             fAODCaloClusters->Clear() ; 
+//             delete fAODCaloClusters ;
+//     }
        
-       if(fReader)  delete fReader ;
-       if(fCaloPID) delete fCaloPID ;
-       if(fFidCut)  delete fFidCut ;
-       if(fIC)      delete fIC ;
-       if(fMCUtils) delete fMCUtils ;
-       if(fNMS)     delete fNMS ;
-
+  if(fAODCaloCells){
+    fAODCaloCells->Clear() ; 
+    delete fAODCaloCells ;
+  }
+  
+  if(fReader)  delete fReader ;
+  if(fCaloPID) delete fCaloPID ;
+  if(fFidCut)  delete fFidCut ;
+  if(fIC)      delete fIC ;
+  if(fMCUtils) delete fMCUtils ;
+  if(fNMS)     delete fNMS ;
+  
 }
 
-//____________________________________________________________________________
-void AliAnaPartCorrBaseClass::AddAODCaloCluster(AliAODCaloCluster calo) {
-  //Put AOD calo cluster in the CaloClusters array
-
-  Int_t i = fAODCaloClusters->GetEntriesFast();
-  new((*fAODCaloClusters)[i])  AliAODCaloCluster(calo);
-
-}
+////____________________________________________________________________________
+//void AliAnaPartCorrBaseClass::AddAODCaloCluster(AliAODCaloCluster calo) {
+//  //Put AOD calo cluster in the CaloClusters array
+//
+//  Int_t i = fAODCaloClusters->GetEntriesFast();
+//  new((*fAODCaloClusters)[i])  AliAODCaloCluster(calo);
+//
+//}
 
 
 //____________________________________________________________________________
 void AliAnaPartCorrBaseClass::AddAODParticle(AliAODPWG4Particle pc) {
   //Put AOD calo cluster in the AODParticleCorrelation array
   
-       if(fOutputAODBranch){
-               
-               Int_t i = fOutputAODBranch->GetEntriesFast();
-               //new((*fOutputAODBranch)[i])  AliAODPWG4Particle(pc);
-               if(strcmp(fOutputAODBranch->GetClass()->GetName(),"AliAODPWG4Particle")==0)
-                       new((*fOutputAODBranch)[i])  AliAODPWG4Particle(pc);
-               else   if(strcmp(fOutputAODBranch->GetClass()->GetName(),"AliAODPWG4ParticleCorrelation")==0)
-                       new((*fOutputAODBranch)[i])  AliAODPWG4ParticleCorrelation(pc);
-               else 
-                       AliFatal(Form(">>> Cannot add an object of type < %s >, to the AOD TClonesArray \n", 
-                                                 fOutputAODBranch->GetClass()->GetName()));
-       }
-       else AliFatal("AddAODParticle: No AOD branch available!!!");
-       
+  if(fOutputAODBranch){
+    
+    Int_t i = fOutputAODBranch->GetEntriesFast();
+    //new((*fOutputAODBranch)[i])  AliAODPWG4Particle(pc);
+    if(strcmp(fOutputAODBranch->GetClass()->GetName(),"AliAODPWG4Particle")==0)
+      new((*fOutputAODBranch)[i])  AliAODPWG4Particle(pc);
+    else   if(strcmp(fOutputAODBranch->GetClass()->GetName(),"AliAODPWG4ParticleCorrelation")==0)
+      new((*fOutputAODBranch)[i])  AliAODPWG4ParticleCorrelation(pc);
+    else {
+      printf("AliAnaPartCorrBaseClass::AddAODParticle() - Cannot add an object of type < %s >, to the AOD TClonesArray \n",  
+            fOutputAODBranch->GetClass()->GetName());
+      abort();    
+    }
+  }
+  else {
+    printf(" AliAnaPartCorrBaseClass::AddAODParticle() - No AOD branch available!!!\n");
+    abort();
+  }
+
 }      
 
 
 //___________________________________________________
-void AliAnaPartCorrBaseClass::ConnectAODCaloClusters() {
-  //Recover the list of AODCaloClusters
-
-  fAODCaloClusters = fReader->GetAOD()->GetCaloClusters();
-
-}
-
+//void AliAnaPartCorrBaseClass::ConnectAODCaloClusters() {
+//  //Recover the list of AODCaloClusters
+//
+//  fAODCaloClusters = fReader->GetOutputEvent()->GetCaloClusters();
+//
+//}
+//
 //___________________________________________________
 void AliAnaPartCorrBaseClass::ConnectAODPHOSCells() {
   //Recover the list of PHOS AODCaloCells 
 
-  fAODCaloCells = fReader->GetAOD()->GetPHOSCells();
+  fAODCaloCells = fReader->GetOutputEvent()->GetPHOSCells();
 
 }
 
@@ -212,80 +215,95 @@ void AliAnaPartCorrBaseClass::ConnectAODPHOSCells() {
 void AliAnaPartCorrBaseClass::ConnectAODEMCALCells() {
   //Recover the list of EMCAL AODCaloCells 
 
-  fAODCaloCells = fReader->GetAOD()->GetEMCALCells();
+  fAODCaloCells = fReader->GetOutputEvent()->GetEMCALCells();
 
 }
 
 //___________________________________________________
 void AliAnaPartCorrBaseClass::ConnectInputOutputAODBranches() {
-       //Recover ouput and input AOD pointers for each event in the maker
-       fOutputAODBranch =  (TClonesArray *) fReader->GetAOD()->FindListObject(fOutputAODName);
-       fInputAODBranch  =  (TClonesArray *) fReader->GetAOD()->FindListObject(fInputAODName);          
+  //Recover ouput and input AOD pointers for each event in the maker
+
+  fOutputAODBranch =  (TClonesArray *) fReader->GetOutputEvent()->FindListObject(fOutputAODName);
+  fInputAODBranch  =  (TClonesArray *) fReader->GetOutputEvent()->FindListObject(fInputAODName);               
+
 }
 
 //__________________________________________________
-TClonesArray *  AliAnaPartCorrBaseClass::GetAODCTS() const {
-  //Get list of tracks from reader
+TRefArray *  AliAnaPartCorrBaseClass::GetAODCTS() const {
+  //Get list of referenced tracks from reader
 
   return fReader->GetAODCTS(); 
 
 }
 
 //__________________________________________________
-TClonesArray *  AliAnaPartCorrBaseClass::GetAODPHOS() const {
-  //Get list of PHOS calo clusters from reader
+TRefArray *  AliAnaPartCorrBaseClass::GetAODPHOS() const {
+  //Get list of PHOS reference caloclusters from reader
 
   return fReader->GetAODPHOS(); 
 
 }
 
-
 //__________________________________________________
-TClonesArray *  AliAnaPartCorrBaseClass::GetAODEMCAL() const {
-  //Get list of emcal caloclusters from reader
+TRefArray *  AliAnaPartCorrBaseClass::GetAODEMCAL() const {
+  //Get list of emcal referenced caloclusters from reader
 
   return fReader->GetAODEMCAL(); 
 
 }
 
+//__________________________________________________
+TClonesArray *  AliAnaPartCorrBaseClass::GetAODCaloClusters() const {
+  //Get list of all caloclusters in AOD output file 
+
+  return fReader->GetOutputEvent()->GetCaloClusters(); 
+
+}
+
+//__________________________________________________
+TClonesArray *  AliAnaPartCorrBaseClass::GetAODTracks() const {
+  //Get list of all tracks in AOD output file 
+
+  return fReader->GetOutputEvent()->GetTracks(); 
+
+}
+
 //__________________________________________________
 TString  AliAnaPartCorrBaseClass::GetBaseParametersList()  {
   //Put data member values in string to keep in output container
 
-       TString parList ; //this will be list of parameters used for this analysis.
-       char onePar[255] ;
-       sprintf(onePar,"--- AliAnaPartCorrBaseClass ---\n") ;
-       parList+=onePar ;       
-       sprintf(onePar,"Minimal P_t: %2.2f ; Max\n", fMinPt) ;
-       parList+=onePar ;
-       sprintf(onePar,"Minimal P_t: %2.2f ; Max\n", fMaxPt) ;
-       parList+=onePar ;
-       sprintf(onePar,"fDataMC =%d (Check MC information, on/off) \n",fDataMC) ;
-       parList+=onePar ;
-       sprintf(onePar,"fCheckFidCut=%d (Check Fidutial cut selection on/off) \n",fCheckFidCut) ;
-       parList+=onePar ;
-       sprintf(onePar,"fCheckCaloPIC =%d (Use Bayesian PID in calorimetes, on/off) \n",fCheckCaloPID) ;
-       parList+=onePar ;
-       sprintf(onePar,"fRecalculateCaloPID  =%d (Calculate PID from shower/tof/tracking parameters, on/off) \n",fRecalculateCaloPID) ;
-       parList+=onePar ;
-
+  TString parList ; //this will be list of parameters used for this analysis.
+  char onePar[255] ;
+  sprintf(onePar,"--- AliAnaPartCorrBaseClass ---\n") ;
+  parList+=onePar ;    
+  sprintf(onePar,"Minimal P_t: %2.2f ; Max\n", fMinPt) ;
+  parList+=onePar ;
+  sprintf(onePar,"Minimal P_t: %2.2f ; Max\n", fMaxPt) ;
+  parList+=onePar ;
+  sprintf(onePar,"fDataMC =%d (Check MC information, on/off) \n",fDataMC) ;
+  parList+=onePar ;
+  sprintf(onePar,"fCheckFidCut=%d (Check Fidutial cut selection on/off) \n",fCheckFidCut) ;
+  parList+=onePar ;
+  sprintf(onePar,"fCheckCaloPIC =%d (Use Bayesian PID in calorimetes, on/off) \n",fCheckCaloPID) ;
+  parList+=onePar ;
+  sprintf(onePar,"fRecalculateCaloPID  =%d (Calculate PID from shower/tof/tracking parameters, on/off) \n",fRecalculateCaloPID) ;
+  parList+=onePar ;
+  
   return parList; 
 
 }
 
 //__________________________________________________
  TClonesArray * AliAnaPartCorrBaseClass::GetCreateOutputAODBranch() {
-        //Create AOD branch filled in the analysis
-        
-        //if(fDebug > 0 )
-        printf("Create AOD branch of %s objects and with name < %s >\n",
-                       fOutputAODClassName.Data(),fOutputAODName.Data()) ;
-        
-        TClonesArray * aodBranch = new TClonesArray(fOutputAODClassName, 0);
-        aodBranch->SetName(fOutputAODName);
-        
-        return aodBranch ;
-        
+   //Create AOD branch filled in the analysis
+   
+   printf("Create AOD branch of %s objects and with name < %s >\n",
+         fOutputAODClassName.Data(),fOutputAODName.Data()) ;
+   
+   TClonesArray * aodBranch = new TClonesArray(fOutputAODClassName, 0);
+   aodBranch->SetName(fOutputAODName);
+   return aodBranch ;
+   
  }
 
 //__________________________________________________
@@ -374,25 +392,25 @@ void AliAnaPartCorrBaseClass::InitParameters()
 //__________________________________________________________________
 void AliAnaPartCorrBaseClass::Print(const Option_t * opt) const
 {
-       //Print some relevant parameters set for the analysis
-       
-       if(! opt)
-               return;
-       printf("New AOD:            =     %d\n",fNewAOD);
-       printf("Input AOD name:     =     %s\n",fInputAODName.Data());
-       printf("Output AOD name:    =     %s\n",fOutputAODName.Data());
-       printf("Output AOD Class name: =  %s\n",fOutputAODClassName.Data());
-       printf("Min Photon pT       =     %2.2f\n",  fMinPt) ;
-       printf("Max Photon pT       =     %3.2f\n",  fMaxPt) ;
-       printf("Check PID           =     %d\n",     fCheckCaloPID) ;
-       printf("Recalculate PID     =     %d\n",     fRecalculateCaloPID) ;
-       printf("Check Fidutial cut  =     %d\n",     fCheckFidCut) ;
-       printf("Check MC labels     =     %d\n",     fDataMC);
-       printf("Debug Level         =     %d\n",     fDebug);
-       printf("Histograms: %3.1f < pT < %3.1f,  Nbin = %d\n", fHistoPtMin,  fHistoPtMax,  fHistoNPtBins);
-       printf("Histograms: %3.1f < phi < %3.1f, Nbin = %d\n", fHistoPhiMin, fHistoPhiMax, fHistoNPhiBins);
-       printf("Histograms: %3.1f < eta < %3.1f, Nbin = %d\n", fHistoEtaMin, fHistoEtaMax, fHistoNEtaBins);
-
-       printf("    \n") ;
-       
+  //Print some relevant parameters set for the analysis
+  
+  if(! opt)
+    return;
+  printf("New AOD:            =     %d\n",fNewAOD);
+  printf("Input AOD name:     =     %s\n",fInputAODName.Data());
+  printf("Output AOD name:    =     %s\n",fOutputAODName.Data());
+  printf("Output AOD Class name: =  %s\n",fOutputAODClassName.Data());
+  printf("Min Photon pT       =     %2.2f\n",  fMinPt) ;
+  printf("Max Photon pT       =     %3.2f\n",  fMaxPt) ;
+  printf("Check PID           =     %d\n",     fCheckCaloPID) ;
+  printf("Recalculate PID     =     %d\n",     fRecalculateCaloPID) ;
+  printf("Check Fidutial cut  =     %d\n",     fCheckFidCut) ;
+  printf("Check MC labels     =     %d\n",     fDataMC);
+  printf("Debug Level         =     %d\n",     fDebug);
+  printf("Histograms: %3.1f < pT < %3.1f,  Nbin = %d\n", fHistoPtMin,  fHistoPtMax,  fHistoNPtBins);
+  printf("Histograms: %3.1f < phi < %3.1f, Nbin = %d\n", fHistoPhiMin, fHistoPhiMax, fHistoNPhiBins);
+  printf("Histograms: %3.1f < eta < %3.1f, Nbin = %d\n", fHistoEtaMin, fHistoEtaMax, fHistoNEtaBins);
+  
+  printf("    \n") ;
+  
 } 
index 3dbdb350f2b1bae38606b009ee82afd784bb91e7..7525745c22bb4213f1f1d1349ee51326536593ce 100755 (executable)
@@ -10,6 +10,7 @@
 
 //ROOT
 class TClonesArray ;
+class TRefArray ;
 #include <TList.h>
 #include <TObject.h>
 
@@ -32,182 +33,184 @@ class AliAnaPartCorrBaseClass : public TObject {
        
 public: 
        
-       AliAnaPartCorrBaseClass() ; // default ctor
-       AliAnaPartCorrBaseClass(const AliAnaPartCorrBaseClass & g) ; // cpy ctor
-       AliAnaPartCorrBaseClass & operator = (const AliAnaPartCorrBaseClass & g) ;//cpy assignment
-       virtual ~AliAnaPartCorrBaseClass() ; //virtual dtor
-       
-       virtual void AddAODCaloCluster(AliAODCaloCluster calo) ;
-       virtual void AddAODParticle(AliAODPWG4Particle pc) ;
-
-       virtual void ConnectAODCaloClusters();
-       virtual void ConnectAODPHOSCells();
-       virtual void ConnectAODEMCALCells();
-       virtual void ConnectInputOutputAODBranches();
-       
-       virtual TList * GetCreateOutputObjects() { return (new TList) ;}
-       
-       virtual void Init() {;}
-       virtual void InitParameters() ;
-       
-       virtual void Print(const Option_t * ) const ;
-       
-       virtual void MakeAnalysisFillAOD()  {;}
-       
-       virtual void MakeAnalysisFillHistograms() {;}
-               
-       virtual Int_t GetDebug() const  { return fDebug ; }
-       virtual void SetDebug(Int_t d)   { fDebug = d ; }
-       
-       virtual Int_t GetEventNumber() const ;
-       
-       virtual AliCaloTrackReader * GetReader() const {return fReader ; }
-       virtual void SetReader(AliCaloTrackReader * reader) { fReader = reader ; }
-               
-       virtual void Terminate() {;}
-
-       //analysis AOD branch
-       virtual TClonesArray * GetCreateOutputAODBranch() ;
-       virtual TString GetInputAODName() const {return fInputAODName ; }
-       virtual void SetInputAODName(TString name)   { fInputAODName = name; }  
-       virtual TString GetOutputAODName()  const {return fOutputAODName ; }
-       virtual void SetOutputAODName(TString name)   { fNewAOD = kTRUE ; fOutputAODName = name; }
-       virtual Bool_t NewOutputAOD() const {return fNewAOD;}
-       virtual TString GetOutputAODClassName() const {return fOutputAODClassName;}
-       virtual void SetOutputAODClassName(TString name) {fOutputAODClassName = name; }
-       
-    virtual TClonesArray* GetInputAODBranch() const {return fInputAODBranch ;}
-       virtual TClonesArray* GetOutputAODBranch() const {return fOutputAODBranch ;}
-
-       virtual TClonesArray* GetAODCaloClusters() const {return fAODCaloClusters ;}
-       virtual AliAODCaloCells* GetAODCaloCells() const {return fAODCaloCells ;}
-       
-       virtual TClonesArray* GetAODCTS() const ;
-       virtual TClonesArray* GetAODEMCAL() const ;
-       virtual TClonesArray* GetAODPHOS() const ;
-       
-       virtual TString GetBaseParametersList();
-       
-       virtual TNamed * GetEMCALCells() const ;
-       virtual TNamed * GetPHOSCells() const ;
-       
-       virtual AliStack * GetMCStack() const ;
-       virtual AliHeader* GetMCHeader() const ;
-       virtual AliGenEventHeader* GetMCGenEventHeader() const ;
-       
-       //Analysis helpers classes pointers setters and getters
-       virtual AliCaloPID * GetCaloPID() const {return  fCaloPID ;}
-       virtual void SetCaloPID(AliCaloPID * pid) { fCaloPID = pid ;}
-       
-       virtual AliFidutialCut * GetFidutialCut() const {return  fFidCut ;}
-       virtual void SetFidutialCut(AliFidutialCut * fc) { fFidCut = fc ;}
-       
-       virtual AliIsolationCut * GetIsolationCut() const {return  fIC ;}
-       virtual void SetIsolationCut(AliIsolationCut * fc) { fIC = fc ;}
-       
-       virtual AliMCAnalysisUtils * GetMCAnalysisUtils() const {return  fMCUtils ;}
-       virtual void SetMCAnalysisUtils(AliMCAnalysisUtils * mcutils) { fMCUtils = mcutils ;}   
-       
-       virtual AliNeutralMesonSelection * GetNeutralMesonSelection() const {return  fNMS ;}
-       virtual void SetNeutralMesonSelection(AliNeutralMesonSelection * nms) { fNMS = nms ;}
-       
-       virtual Bool_t     IsDataMC() const {return fDataMC ; }
-       virtual void SwitchOnDataMC()    {fDataMC = kTRUE ; }
-       virtual void SwitchOffDataMC()    {fDataMC = kFALSE ; }
-       
-       virtual Bool_t IsFidutialCutOn() const {return fCheckFidCut ; }
-       virtual void SwitchOnFidutialCut() { fCheckFidCut = kTRUE;}
-       virtual void SwitchOffFidutialCut() { fCheckFidCut = kFALSE;}
-       
-       virtual Bool_t IsCaloPIDOn() const {return fCheckCaloPID ; }
-       virtual void SwitchOnCaloPID() { fCheckCaloPID = kTRUE;}
-       virtual void SwitchOffCaloPID() { fCheckCaloPID = kFALSE;}
-       
-       virtual Bool_t IsCaloPIDRecalculationOn() const {return fRecalculateCaloPID ; }
-       virtual void SwitchOnCaloPIDRecalculation() { fRecalculateCaloPID  = kTRUE;}
-       virtual void SwitchOffCaloPIDRecalculation() { fRecalculateCaloPID  = kFALSE;}
-       
-       virtual Float_t    GetMaxPt()         const {return fMaxPt ; }
-       virtual Float_t    GetMinPt()         const {return fMinPt ; }
-       virtual void SetMaxPt(Float_t pt)              {fMaxPt = pt ; }
-       virtual void SetMinPt(Float_t pt)              {fMinPt = pt ; }
-       void SetPtCutRange(Double_t ptmin, Double_t ptmax)
-       {  fMaxPt=ptmax;   fMinPt=ptmin;}
-       
-       //Histogrammes setters and getters
-       virtual void SetHistoPtRangeAndNBins(Float_t min, Float_t max, Int_t n) {
-               fHistoNPtBins = n ;
-               fHistoPtMax = max ;
-               fHistoPtMin = min ;
-       }
-       
-       Int_t   GetHistoNPtBins() const { return fHistoNPtBins ; }
-       Float_t GetHistoPtMin()   const { return fHistoPtMin ; }
-       Float_t GetHistoPtMax()   const { return fHistoPtMax ; }
-
-       virtual void SetHistoPhiRangeAndNBins(Float_t min, Float_t max, Int_t n) {
-               fHistoNPhiBins = n ;
-               fHistoPhiMax = max ;
-               fHistoPhiMin = min ;
-       }
-       
-       Int_t   GetHistoNPhiBins() const { return fHistoNPhiBins ; }
-       Float_t GetHistoPhiMin()   const { return fHistoPhiMin ; }
-       Float_t GetHistoPhiMax()   const { return fHistoPhiMax ; }
-
-       virtual void SetHistoEtaRangeAndNBins(Float_t min, Float_t max, Int_t n) {
-               fHistoNEtaBins = n ;
-               fHistoEtaMax = max ;
-               fHistoEtaMin = min ;
-       }
-       
-       Int_t   GetHistoNEtaBins() const { return fHistoNEtaBins ; }
-       Float_t GetHistoEtaMin()   const { return fHistoEtaMin ; }
-       Float_t GetHistoEtaMax()   const { return fHistoEtaMax ; }
-
-
-       private:    
-       
-       Bool_t fDataMC ;        //Flag to access MC data when using ESD or AOD     
-       Int_t fDebug ;          // Debug level
-       Bool_t fCheckFidCut ;   // Do analysis for clusters in defined region         
-       Bool_t fCheckCaloPID ;  // Do analysis for calorimeters
-       Bool_t fRecalculateCaloPID ; //Recalculate PID or use PID weights in calorimeters
-       Float_t fMinPt ; //Maximum pt of (trigger) particles in the analysis
-       Float_t fMaxPt ; //Minimum pt of (trigger) particles in the analysis
-       
-       AliCaloTrackReader * fReader;     //Acces to ESD/AOD/MC data
-       
-       TClonesArray* fInputAODBranch ;   //! Selected input particles branch
-       TString fInputAODName ;           // Name of input AOD branch;
-       TClonesArray* fOutputAODBranch ;  //! Selected output particles branch
-       Bool_t fNewAOD ;                  // Flag, new aod branch added to the analysis or not.
-       TString fOutputAODName ;          // Name of output AOD branch;
-       TString fOutputAODClassName;      // Type of aod objects to be stored in the TClonesArray (AliAODPWG4Particle, AliAODPWG4ParticleCorrelation ...)       
-
-       TClonesArray* fAODCaloClusters ;  //! selected PHOS/EMCAL CaloClusters
-       AliAODCaloCells * fAODCaloCells ; //! selected PHOS/EMCAL CaloCells
-       
-       //Analysis helper classes access pointers
-       AliCaloPID * fCaloPID;            // PID calculation
-       AliFidutialCut * fFidCut;         // Acceptance cuts
-       AliIsolationCut * fIC;            // Isolation cut 
-       AliMCAnalysisUtils * fMCUtils;    // MonteCarlo Analysis utils 
-       AliNeutralMesonSelection * fNMS;  // Neutral Meson Selection
-       
-       //Histograms binning and range    
-       Int_t   fHistoNPtBins ;  //Number of bins in pt axis
-       Float_t fHistoPtMax ;    //Maximum value of pt histogram range
-       Float_t fHistoPtMin ;    //Minimum value of pt histogram range
-       Int_t   fHistoNPhiBins ; //Number of bins in phi axis
-       Float_t fHistoPhiMax ;   //Maximum value of phi histogram range
-       Float_t fHistoPhiMin ;   //Minimum value of phi histogram range
-       Int_t   fHistoNEtaBins ; //Number of bins in eta axis
-       Float_t fHistoEtaMax ;   //Maximum value of eta histogram range
-       Float_t fHistoEtaMin ;   //Minimum value of eta histogram range
-                                               
-       ClassDef(AliAnaPartCorrBaseClass,3)
-} ;
+  AliAnaPartCorrBaseClass() ; // default ctor
+  AliAnaPartCorrBaseClass(const AliAnaPartCorrBaseClass & g) ; // cpy ctor
+  AliAnaPartCorrBaseClass & operator = (const AliAnaPartCorrBaseClass & g) ;//cpy assignment
+  virtual ~AliAnaPartCorrBaseClass() ; //virtual dtor
+  
+//     virtual void AddAODCaloCluster(AliAODCaloCluster calo) ;
+  virtual void AddAODParticle(AliAODPWG4Particle pc) ;
+//
+//     virtual void ConnectAODCaloClusters();
+  virtual void ConnectAODPHOSCells();
+  virtual void ConnectAODEMCALCells();
+  virtual void ConnectInputOutputAODBranches();
+  
+  virtual TList * GetCreateOutputObjects() { return (new TList) ;}
+  
+  virtual void Init() {;}
+  virtual void InitParameters() ;
+  
+  virtual void Print(const Option_t * ) const ;
+  
+  virtual void MakeAnalysisFillAOD()  {;}
+  
+  virtual void MakeAnalysisFillHistograms() {;}
+  
+  virtual Int_t GetDebug() const  { return fDebug ; }
+  virtual void SetDebug(Int_t d)   { fDebug = d ; }
+  
+  virtual Int_t GetEventNumber() const ;
+  
+  virtual AliCaloTrackReader * GetReader() const {return fReader ; }
+  virtual void SetReader(AliCaloTrackReader * reader) { fReader = reader ; }
+  
+  virtual void Terminate() {;}
+  
+  //analysis AOD branch
+  virtual TClonesArray * GetCreateOutputAODBranch() ;
+  virtual TString GetInputAODName() const {return fInputAODName ; }
+  virtual void SetInputAODName(TString name)   { fInputAODName = name; }       
+  virtual TString GetOutputAODName()  const {return fOutputAODName ; }
+  virtual void SetOutputAODName(TString name)   { fNewAOD = kTRUE ; fOutputAODName = name; }
+  virtual Bool_t NewOutputAOD() const {return fNewAOD;}
+  virtual TString GetOutputAODClassName() const {return fOutputAODClassName;}
+  virtual void SetOutputAODClassName(TString name) {fOutputAODClassName = name; }
+  
+  virtual TClonesArray* GetInputAODBranch() const {return fInputAODBranch ;}
+  virtual TClonesArray* GetOutputAODBranch() const {return fOutputAODBranch ;}
+
+//     virtual TClonesArray* GetAODCaloClusters() const {return fAODCaloClusters ;}
+  virtual TClonesArray* GetAODCaloClusters() const ;
+  virtual TClonesArray* GetAODTracks() const ; 
+  virtual AliAODCaloCells* GetAODCaloCells() const {return fAODCaloCells ;}
+  
+  virtual TRefArray* GetAODCTS() const ;
+  virtual TRefArray* GetAODEMCAL() const ;
+  virtual TRefArray* GetAODPHOS() const ;
+  
+  virtual TString      GetBaseParametersList();
+  
+  virtual TNamed * GetEMCALCells() const ;
+  virtual TNamed * GetPHOSCells() const ;
+  
+  virtual AliStack * GetMCStack() const ;
+  virtual AliHeader* GetMCHeader() const ;
+  virtual AliGenEventHeader* GetMCGenEventHeader() const ;
+  
+  //Analysis helpers classes pointers setters and getters
+  virtual AliCaloPID * GetCaloPID() const {return  fCaloPID ;}
+  virtual void SetCaloPID(AliCaloPID * pid) { fCaloPID = pid ;}
+  
+  virtual AliFidutialCut * GetFidutialCut() const {return  fFidCut ;}
+  virtual void SetFidutialCut(AliFidutialCut * fc) { fFidCut = fc ;}
+  
+  virtual AliIsolationCut * GetIsolationCut() const {return  fIC ;}
+  virtual void SetIsolationCut(AliIsolationCut * fc) { fIC = fc ;}
+  
+  virtual AliMCAnalysisUtils * GetMCAnalysisUtils() const {return  fMCUtils ;}
+  virtual void SetMCAnalysisUtils(AliMCAnalysisUtils * mcutils) { fMCUtils = mcutils ;}        
+  
+  virtual AliNeutralMesonSelection * GetNeutralMesonSelection() const {return  fNMS ;}
+  virtual void SetNeutralMesonSelection(AliNeutralMesonSelection * nms) { fNMS = nms ;}
+  
+  virtual Bool_t     IsDataMC() const {return fDataMC ; }
+  virtual void SwitchOnDataMC()    {fDataMC = kTRUE ; }
+  virtual void SwitchOffDataMC()    {fDataMC = kFALSE ; }
+  
+  virtual Bool_t IsFidutialCutOn() const {return fCheckFidCut ; }
+  virtual void SwitchOnFidutialCut() { fCheckFidCut = kTRUE;}
+  virtual void SwitchOffFidutialCut() { fCheckFidCut = kFALSE;}
+  
+  virtual Bool_t IsCaloPIDOn() const {return fCheckCaloPID ; }
+  virtual void SwitchOnCaloPID() { fCheckCaloPID = kTRUE;}
+  virtual void SwitchOffCaloPID() { fCheckCaloPID = kFALSE;}
+  
+  virtual Bool_t IsCaloPIDRecalculationOn() const {return fRecalculateCaloPID ; }
+  virtual void SwitchOnCaloPIDRecalculation() { fRecalculateCaloPID  = kTRUE;}
+  virtual void SwitchOffCaloPIDRecalculation() { fRecalculateCaloPID  = kFALSE;}
+  
+  virtual Float_t    GetMaxPt()         const {return fMaxPt ; }
+  virtual Float_t    GetMinPt()         const {return fMinPt ; }
+  virtual void SetMaxPt(Float_t pt)              {fMaxPt = pt ; }
+  virtual void SetMinPt(Float_t pt)              {fMinPt = pt ; }
+  void SetPtCutRange(Double_t ptmin, Double_t ptmax)
+  {  fMaxPt=ptmax;   fMinPt=ptmin;}
+  
+  //Histogrammes setters and getters
+  virtual void SetHistoPtRangeAndNBins(Float_t min, Float_t max, Int_t n) {
+    fHistoNPtBins = n ;
+    fHistoPtMax = max ;
+    fHistoPtMin = min ;
+  }
+  
+  Int_t   GetHistoNPtBins() const { return fHistoNPtBins ; }
+  Float_t GetHistoPtMin()   const { return fHistoPtMin ; }
+  Float_t GetHistoPtMax()   const { return fHistoPtMax ; }
+  
+  virtual void SetHistoPhiRangeAndNBins(Float_t min, Float_t max, Int_t n) {
+    fHistoNPhiBins = n ;
+    fHistoPhiMax = max ;
+    fHistoPhiMin = min ;
+  }
+  
+  Int_t   GetHistoNPhiBins() const { return fHistoNPhiBins ; }
+  Float_t GetHistoPhiMin()   const { return fHistoPhiMin ; }
+  Float_t GetHistoPhiMax()   const { return fHistoPhiMax ; }
+  
+  virtual void SetHistoEtaRangeAndNBins(Float_t min, Float_t max, Int_t n) {
+    fHistoNEtaBins = n ;
+    fHistoEtaMax = max ;
+    fHistoEtaMin = min ;
+  }
+  
+  Int_t   GetHistoNEtaBins() const { return fHistoNEtaBins ; }
+  Float_t GetHistoEtaMin()   const { return fHistoEtaMin ; }
+  Float_t GetHistoEtaMax()   const { return fHistoEtaMax ; }
+  
+  
+ private:    
+  
+  Bool_t  fDataMC ;             // Flag to access MC data when using ESD or AOD     
+  Int_t   fDebug ;              // Debug level
+  Bool_t  fCheckFidCut ;        // Do analysis for clusters in defined region         
+  Bool_t  fCheckCaloPID ;       // Do analysis for calorimeters
+  Bool_t  fRecalculateCaloPID ; // Recalculate PID or use PID weights in calorimeters
+  Float_t fMinPt ;              // Maximum pt of (trigger) particles in the analysis
+  Float_t fMaxPt ;              // Minimum pt of (trigger) particles in the analysis
+  
+  AliCaloTrackReader * fReader; // Acces to ESD/AOD/MC data
+  
+  TClonesArray* fInputAODBranch ;    //! Selected input particles branch
+  TString       fInputAODName ;      //  Name of input AOD branch;
+  TClonesArray* fOutputAODBranch ;   //! Selected output particles branch
+  Bool_t        fNewAOD ;            //  Flag, new aod branch added to the analysis or not.
+  TString       fOutputAODName ;     //  Name of output AOD branch;
+  TString       fOutputAODClassName; //  Type of aod objects to be stored in the TClonesArray (AliAODPWG4Particle, AliAODPWG4ParticleCorrelation ...)  
+  
+  //TClonesArray* fAODCaloClusters ;  //! selected PHOS/EMCAL CaloClusters
+  AliAODCaloCells * fAODCaloCells ; //! selected PHOS/EMCAL CaloCells
+  
+  //Analysis helper classes access pointers
+  AliCaloPID               * fCaloPID; // PID calculation
+  AliFidutialCut           * fFidCut;  // Acceptance cuts
+  AliIsolationCut          * fIC;      // Isolation cut 
+  AliMCAnalysisUtils       * fMCUtils; // MonteCarlo Analysis utils 
+  AliNeutralMesonSelection * fNMS;     // Neutral Meson Selection
+  
+  //Histograms binning and range    
+  Int_t   fHistoNPtBins ;  // Number of bins in pt axis
+  Float_t fHistoPtMax ;    // Maximum value of pt histogram range
+  Float_t fHistoPtMin ;    // Minimum value of pt histogram range
+  Int_t   fHistoNPhiBins ; // Number of bins in phi axis
+  Float_t fHistoPhiMax ;   // Maximum value of phi histogram range
+  Float_t fHistoPhiMin ;   // Minimum value of phi histogram range
+  Int_t   fHistoNEtaBins ; // Number of bins in eta axis
+  Float_t fHistoEtaMax ;   // Maximum value of eta histogram range
+  Float_t fHistoEtaMin ;   // Minimum value of eta histogram range
+  
+  ClassDef(AliAnaPartCorrBaseClass,3)
+    } ;
 
 
 #endif //ALIANAPARTCORRBASECLASS_H
index 2c8e1207bde7ed114b5c07abfcb7363d2da71081..b1bdc5502579edfe547a20c262b7d18a79b7f96f 100755 (executable)
 // -- Author: Gustavo Conesa (INFN-LNF)
 
 // --- ROOT system ---
-class TClonesArray;
+#include "TClonesArray.h"
 class TString ;
+#include "TList.h"
 //#include "Riostream.h"
 
 //---- AliRoot system ---- 
 #include "AliAnaPartCorrBaseClass.h" 
 #include "AliAnaPartCorrMaker.h" 
 #include "AliCaloTrackReader.h" 
-#include "AliLog.h"
 
 
 ClassImp(AliAnaPartCorrMaker)
@@ -45,14 +45,14 @@ fOutputContainer(new TList ), fAnalysisContainer(new TList ),
 fMakeHisto(0), fMakeAOD(0), fAnaDebug(0), 
 fReader(0x0), fAODBranchList(new TList )
 {
-       //Default Ctor
-       if(fAnaDebug > 1 ) printf("*** Analysis Maker  Constructor *** \n");
-       
-       //Initialize parameters, pointers and histograms
-       if(!fReader)
-               fReader = new AliCaloTrackReader();
-       
-       InitParameters();
+  //Default Ctor
+  if(fAnaDebug > 1 ) printf("*** Analysis Maker  Constructor *** \n");
+  
+  //Initialize parameters, pointers and histograms
+  if(!fReader)
+    fReader = new AliCaloTrackReader();
+  
+  InitParameters();
 }
 
 //____________________________________________________________________________
@@ -62,58 +62,58 @@ fOutputContainer(g. fOutputContainer), fAnalysisContainer(g.fAnalysisContainer),
 fMakeHisto(g.fMakeHisto), fMakeAOD(fMakeAOD), fAnaDebug(g. fAnaDebug),
 fReader(g.fReader), fAODBranchList(g.fAODBranchList)
 {
-       // cpy ctor
+  // cpy ctor
        
 }
 
 //_________________________________________________________________________
 AliAnaPartCorrMaker & AliAnaPartCorrMaker::operator = (const AliAnaPartCorrMaker & source)
 {
-       // assignment operator
-       
-       if(this == &source)return *this;
-       ((TObject *)this)->operator=(source);
-       
-       fOutputContainer    = source.fOutputContainer ;
-       fAnalysisContainer  = source.fAnalysisContainer ;
-       fAnaDebug           = source.fAnaDebug;
-       fMakeHisto          = source.fMakeHisto;
-       fMakeAOD            = source.fMakeAOD;
-       
-       fReader             = source.fReader ;
-       fAODBranchList      = source.fAODBranchList;
-       
-       return *this;
-       
+  // assignment operator
+  
+  if(this == &source)return *this;
+  ((TObject *)this)->operator=(source);
+  
+  fOutputContainer    = source.fOutputContainer ;
+  fAnalysisContainer  = source.fAnalysisContainer ;
+  fAnaDebug           = source.fAnaDebug;
+  fMakeHisto          = source.fMakeHisto;
+  fMakeAOD            = source.fMakeAOD;
+  
+  fReader             = source.fReader ;
+  fAODBranchList      = source.fAODBranchList;
+  
+  return *this;
+  
 }
 
 //____________________________________________________________________________
 AliAnaPartCorrMaker::~AliAnaPartCorrMaker() 
 {
-       // Remove all pointers.
-       
-       // Protection added in case of NULL pointers (MG)
-       if (fOutputContainer) {
-               fOutputContainer->Clear();
-               delete fOutputContainer ;
-       }   
-       
-       if (fAnalysisContainer) {
-               fAnalysisContainer->Clear();
-               delete fAnalysisContainer ;
-       }   
-       
-       if (fReader) delete fReader ;
-       
-       
-       if(fAODBranchList){
+  // Remove all pointers.
+  
+  // Protection added in case of NULL pointers (MG)
+  if (fOutputContainer) {
+    fOutputContainer->Clear();
+    delete fOutputContainer ;
+  }   
+  
+  if (fAnalysisContainer) {
+    fAnalysisContainer->Clear();
+    delete fAnalysisContainer ;
+  }   
+  
+  if (fReader) delete fReader ;
+  
+  
+  if(fAODBranchList){
 //             for(Int_t iaod = 0; iaod < fAODBranchList->GetEntries(); iaod++)
 //                     fAODBranchList->At(iaod)->Clear();
        
-               fAODBranchList->Clear();
-               delete fAODBranchList ;
-       }
-       
+    fAODBranchList->Clear();
+    delete fAODBranchList ;
+  }
+  
 }
 
 //________________________________________________________________________
@@ -124,129 +124,131 @@ TList * AliAnaPartCorrMaker::GetAODBranchList()
 // The list is filled in the maker, and new branch passed to the analysis frame
 // AliAnalysisTaskPartCorr
  
-       for(Int_t iana = 0; iana <  fAnalysisContainer->GetEntries(); iana++){
-                       
-               AliAnaPartCorrBaseClass * ana =  ((AliAnaPartCorrBaseClass *) fAnalysisContainer->At(iana)) ;
-               if(ana->NewOutputAOD()) fAODBranchList->Add(ana->GetCreateOutputAODBranch());
-       }
-
-       return fAODBranchList ;
-
+  for(Int_t iana = 0; iana <  fAnalysisContainer->GetEntries(); iana++){
+    
+    AliAnaPartCorrBaseClass * ana =  ((AliAnaPartCorrBaseClass *) fAnalysisContainer->At(iana)) ;
+    if(ana->NewOutputAOD()) fAODBranchList->Add(ana->GetCreateOutputAODBranch());
+  }
+  
+  return fAODBranchList ;
+  
 }
 
 //________________________________________________________________________
 TList *AliAnaPartCorrMaker::GetOutputContainer()
 {
 // Fill the output list of histograms during the CreateOutputObjects stage.
-       if(!fAnalysisContainer || fAnalysisContainer->GetEntries()==0)
-                       AliFatal("Analysis job list not initialized");
-                       
-       for(Int_t iana = 0; iana <  fAnalysisContainer->GetEntries(); iana++){
-               AliAnaPartCorrBaseClass * ana =  ((AliAnaPartCorrBaseClass *) fAnalysisContainer->At(iana)) ;
-               if(fMakeHisto){// Analysis with histograms as output on
-                       //Fill container with appropriate histograms                    
-                       TList * templist =  ana -> GetCreateOutputObjects(); 
-                               for(Int_t i = 0; i < templist->GetEntries(); i++)
-                                       fOutputContainer->Add(templist->At(i)) ;
-               }// Analysis with histograms as output on
-       }//Loop on analysis defined
-   return fOutputContainer;
+  if(!fAnalysisContainer || fAnalysisContainer->GetEntries()==0){
+    printf("AliAnaPartCorrMaker::GetOutputContainer() - Analysis job list not initialized\n");
+    abort();
+  }
+  for(Int_t iana = 0; iana <  fAnalysisContainer->GetEntries(); iana++){
+    AliAnaPartCorrBaseClass * ana =  ((AliAnaPartCorrBaseClass *) fAnalysisContainer->At(iana)) ;
+    if(fMakeHisto){// Analysis with histograms as output on
+      //Fill container with appropriate histograms                     
+      TList * templist =  ana -> GetCreateOutputObjects(); 
+      for(Int_t i = 0; i < templist->GetEntries(); i++)
+       fOutputContainer->Add(templist->At(i)) ;
+    }// Analysis with histograms as output on
+  }//Loop on analysis defined
+  return fOutputContainer;
 }
 
 //________________________________________________________________________
 void AliAnaPartCorrMaker::Init()
 {  
-       //Init container histograms and other common variables
-       
-       if(!fAnalysisContainer || fAnalysisContainer->GetEntries()==0)
-                       AliFatal("Analysis job list not initialized");
-                       
-       for(Int_t iana = 0; iana <  fAnalysisContainer->GetEntries(); iana++){
-                       
-               AliAnaPartCorrBaseClass * ana =  ((AliAnaPartCorrBaseClass *) fAnalysisContainer->At(iana)) ;
-               ana->SetReader(fReader); //SetReader for each analysis
-               ana->Init();
-               
-               }//Loop on analysis defined
+  //Init container histograms and other common variables
+  // Fill the output list of histograms during the CreateOutputObjects stage.
+  if(!fAnalysisContainer || fAnalysisContainer->GetEntries()==0){
+    printf("AliAnaPartCorrMaker::GetOutputInit() - Analysis job list not initialized\n");
+    abort();
+  }
+  
+  for(Int_t iana = 0; iana <  fAnalysisContainer->GetEntries(); iana++){
+    
+    AliAnaPartCorrBaseClass * ana =  ((AliAnaPartCorrBaseClass *) fAnalysisContainer->At(iana)) ;
+    ana->SetReader(fReader); //SetReader for each analysis
+    ana->Init();
+    
+  }//Loop on analysis defined
 }
 
 //____________________________________________________________________________
 void AliAnaPartCorrMaker::InitParameters()
-{
-       
-       //Init data members
-       fMakeHisto = kTRUE;
-       fMakeAOD = kTRUE; 
-       fAnaDebug = 0; // No debugging info displayed by default
-
+{      
+  //Init data members
+  
+  fMakeHisto = kTRUE;
+  fMakeAOD = kTRUE; 
+  fAnaDebug = 0; // No debugging info displayed by default
+  
 }
 
 //__________________________________________________________________
 void AliAnaPartCorrMaker::Print(const Option_t * opt) const
-{
-       
-       //Print some relevant parameters set for the analysis
-       if(! opt)
-               return;
-       
-       printf("***** Print: %s %s ******\n", GetName(), GetTitle() ) ;
-       printf("Debug level                =     %d\n", fAnaDebug) ;
-       printf("Produce Histo              =     %d\n", fMakeHisto) ;
-       printf("Produce AOD                =     %d\n", fMakeAOD) ;
-       
+{      
+  //Print some relevant parameters set for the analysis
+       
+  if(! opt)
+    return;
+  
+  printf("***** Print: %s %s ******\n", GetName(), GetTitle() ) ;
+  printf("Debug level                =     %d\n", fAnaDebug) ;
+  printf("Produce Histo              =     %d\n", fMakeHisto) ;
+  printf("Produce AOD                =     %d\n", fMakeAOD) ;
+  
 } 
 
 
 //____________________________________________________________________________
 Bool_t AliAnaPartCorrMaker::ProcessEvent(Int_t iEntry){
-       //Process analysis for this event
-       
-       if(fMakeHisto && !fOutputContainer)
-               AliFatal("Histograms not initialized");
-       
-       if(fAnaDebug >= 0 ) printf("***  Event %d   ***  \n",iEntry);
-       
-       //Each event needs an empty branch      
-       for(Int_t iaod = 0; iaod < fAODBranchList->GetEntries(); iaod++)
-               fAODBranchList->At(iaod)->Clear();
-       
-       //Tell the reader to fill the data in the 3 detector lists
-       fReader->FillInputEvent(iEntry);
-       
-       //Loop on analysis algorithms
-       if(fAnaDebug > 0 ) printf("*** Begin analysis *** \n");
-       Int_t nana = fAnalysisContainer->GetEntries() ;
-       for(Int_t iana = 0; iana <  nana; iana++){
-               
-               AliAnaPartCorrBaseClass * ana =  ((AliAnaPartCorrBaseClass *) fAnalysisContainer->At(iana)) ; 
-               
-               ana->ConnectInputOutputAODBranches(); //Sets branches for each analysis
-               
-               //Make analysis, create aods in aod branch or AODCaloClusters
-               if(fMakeAOD) ana->MakeAnalysisFillAOD()  ;
-               //Make further analysis with aod branch and fill histograms
-               if(fMakeHisto) ana->MakeAnalysisFillHistograms()  ;
-               
-       }
-               
-       fReader->ResetLists();
-       
-       if(fAnaDebug > 0 ) printf("*** End analysis *** \n");
-       
-       return kTRUE ;
-       
+  //Process analysis for this event
+  
+  if(fMakeHisto && !fOutputContainer){
+    printf("AliAnaPartCorrMaker::ProcessEvent() - Histograms not initialized\n");
+    abort();
+  }
+  if(fAnaDebug >= 0 ) printf("***  Event %d   ***  \n",iEntry);
+  
+  //Each event needs an empty branch   
+  for(Int_t iaod = 0; iaod < fAODBranchList->GetEntries(); iaod++)
+    fAODBranchList->At(iaod)->Clear();
+  
+  //Tell the reader to fill the data in the 3 detector lists
+  fReader->FillInputEvent(iEntry);
+  
+  //Loop on analysis algorithms
+  if(fAnaDebug > 0 ) printf("*** Begin analysis *** \n");
+  Int_t nana = fAnalysisContainer->GetEntries() ;
+  for(Int_t iana = 0; iana <  nana; iana++){
+    AliAnaPartCorrBaseClass * ana =  ((AliAnaPartCorrBaseClass *) fAnalysisContainer->At(iana)) ; 
+    ana->ConnectInputOutputAODBranches(); //Sets branches for each analysis
+    //Make analysis, create aods in aod branch or AODCaloClusters
+    if(fMakeAOD) ana->MakeAnalysisFillAOD()  ;
+    //Make further analysis with aod branch and fill histograms
+    if(fMakeHisto) ana->MakeAnalysisFillHistograms()  ;
+    
+  }
+  
+  fReader->ResetLists();
+  
+  if(fAnaDebug > 0 ) printf("*** End analysis *** \n");
+  
+  return kTRUE ;
+  
 }
 
 //________________________________________________________________________
 void AliAnaPartCorrMaker::Terminate()
 {  
-       //Execute Terminate of analysis
-       //Do some final plots.
-                       
-       for(Int_t iana = 0; iana <  fAnalysisContainer->GetEntries(); iana++){
-                       
-               AliAnaPartCorrBaseClass * ana =  ((AliAnaPartCorrBaseClass *) fAnalysisContainer->At(iana)) ;
-               ana->Terminate();
-
-       }//Loop on analysis defined
+  //Execute Terminate of analysis
+  //Do some final plots.
+  
+  for(Int_t iana = 0; iana <  fAnalysisContainer->GetEntries(); iana++){
+    
+    AliAnaPartCorrBaseClass * ana =  ((AliAnaPartCorrBaseClass *) fAnalysisContainer->At(iana)) ;
+    ana->Terminate();
+    
+  }//Loop on analysis defined
 }
index 7aacbfb1e55626eebd18799019aaec8fa2bf7eb5..e6dc9292e48ac094a06d553dffa7ac04f812f342 100755 (executable)
@@ -24,13 +24,13 @@ class AliCaloTrackReader ;
 
 class AliAnaPartCorrMaker : public TObject {
 
-public: 
+ public: 
   
   AliAnaPartCorrMaker() ; // default ctor
   AliAnaPartCorrMaker(const AliAnaPartCorrMaker & g) ; // cpy ctor
   AliAnaPartCorrMaker & operator = (const AliAnaPartCorrMaker & g) ;//cpy assignment
   virtual ~AliAnaPartCorrMaker() ; //virtual dtor
-
+  
   //Setter and getters
   TList * GetAODBranchList() ;
   TList * GetOutputContainer() ;
@@ -49,26 +49,26 @@ public:
   void Terminate();
 
   void AddAnalysis(TObject* ana, Int_t n) {
-       if ( fAnalysisContainer) fAnalysisContainer->AddAt(ana,n); 
-    else { printf("AnalysisContainer not initialized");
-              abort();}
-       }
-
+    if ( fAnalysisContainer) fAnalysisContainer->AddAt(ana,n); 
+    else { printf("AliAnaPartCorrMaker::AddAnalysis() - AnalysisContainer not initialized\n");
+      abort();}
+  }
+  
   AliCaloTrackReader * GetReader() const {return fReader ; }
   void SetReader(AliCaloTrackReader * reader) { fReader = reader ; }
-
+  
   //Others
   void Init();
   void InitParameters();
-
+  
   void Print(const Option_t * opt) const;
-
+  
   Bool_t ProcessEvent(Int_t iEntry) ;
-
+  
  private:
   
   //General Data members
-
+  
   TList * fOutputContainer ; // output histograms container
   TList * fAnalysisContainer ; // List with analysis pointers
   Bool_t  fMakeHisto ; // If true makes final analysis with histograms as output
index 6899facbd04f6ea87482f48da09dfa1eb767fc24..625d6468b2fe42cf0c9931248601d195c185e0a9 100755 (executable)
 //*-- Yves Schutz 
 //////////////////////////////////////////////////////////////////////////////
 
-#include <TFile.h> 
+//Root system
 #include <TH1.h>
 #include <TH1F.h>
-#include <TH1I.h>
-#include <TCanvas.h> 
+//#include "Riostream.h"
 
+//Analysis system
 #include "AliAnaScale.h" 
-#include "AliAnalysisManager.h"
-#include "Riostream.h"
 
 //______________________________________________________________________________
 AliAnaScale::AliAnaScale() : 
index 5d3e08d0ba2e3af516d3cae7ef706e3c7dafbdb5..bbbd0d78d074e9c86a5faa2d771d6144fd784061 100755 (executable)
@@ -9,9 +9,6 @@
 //////////////////////////////////////////////////////////////////////////////
 
 #include "AliAnalysisTask.h"  
-
-class TH1D ; 
-class TH1I ; 
 class TH1F ; 
 
 class AliAnaScale : public AliAnalysisTask {
@@ -38,7 +35,7 @@ private:
 
 
   // input and output
-  Int_t          fDebug ;         // Debug flag
+  Int_t     fDebug ;         // Debug flag
   // task parameters
   Float_t   fScale ;  // Scaling factor 
 
index 0a7172f885cb8dff0eed8830e163d022b6f7f3a8..789a399d68baf83d0ac903380b1b43ebdca97aa6 100755 (executable)
 
 // root
 #include <TROOT.h>
-#include <TSystem.h>
 #include <TInterpreter.h>
-#include <TChain.h>
-#include <TFile.h>
 //#include <Riostream.h>
 
 // analysis
 #include "AliAnalysisTaskParticleCorrelation.h"
-#include "AliAnalysisManager.h"
-#include "AliESDInputHandler.h"
-#include "AliMCEventHandler.h"
-#include "AliMCEvent.h"
 #include "AliAnaPartCorrMaker.h"
 #include "AliCaloTrackReader.h"
-#include "AliESDEvent.h"
-#include "AliAODEvent.h"
-#include "AliAODHandler.h"
-#include "AliStack.h"
-#include "AliLog.h"
 #include "AliPDG.h"
 
 ClassImp(AliAnalysisTaskParticleCorrelation)
@@ -54,7 +42,6 @@ ClassImp(AliAnalysisTaskParticleCorrelation)
     AliAnalysisTaskSE(),
     fAna(0x0),
     fOutputContainer(0x0),
-    //fAODBranch(0x0),
     fConfigName(0)
 {
   // Default constructor
@@ -62,23 +49,22 @@ ClassImp(AliAnalysisTaskParticleCorrelation)
 
 //_____________________________________________________
 AliAnalysisTaskParticleCorrelation::AliAnalysisTaskParticleCorrelation(const char* name):
-    AliAnalysisTaskSE(name),
-    fAna(0x0),
-    fOutputContainer(0x0),
-   // fAODBranch(0x0),
-    fConfigName("ConfigAnalysis")
+  AliAnalysisTaskSE(name),
+  fAna(0x0),
+  fOutputContainer(0x0),
+  fConfigName("")
 {
   // Default constructor
-
+  
   DefineOutput(1, TList::Class());
-
+  
 }
 
 //_____________________________________________________
 AliAnalysisTaskParticleCorrelation::~AliAnalysisTaskParticleCorrelation() 
 {
   // Remove all pointers
+  
   if(fOutputContainer){
     fOutputContainer->Clear() ; 
     delete fOutputContainer ;
@@ -89,47 +75,42 @@ AliAnalysisTaskParticleCorrelation::~AliAnalysisTaskParticleCorrelation()
 //_____________________________________________________
 void AliAnalysisTaskParticleCorrelation::UserCreateOutputObjects()
 {
-       // Create the output container
-       if (fDebug > 1) printf("AnalysisTaskParticleCorrelation::CreateOutputData() \n");
-       
-       
-//     TClonesArray * aodBranch = new TClonesArray(fAna->GetAODBranchClassName(), 0);
-//     aodBranch->SetName(fAna->GetAODBranchName());
-//     AddAODBranch("TClonesArray", &aodBranch);
-//     fAna->SetAODBranch(aodBranch);
-       
-       //Get list of aod arrays, add each aod array to analysis frame 
-       TClonesArray * array = 0;
-       TList * list = fAna->GetAODBranchList();
-       for(Int_t iaod = 0; iaod < list->GetEntries(); iaod++){
-               array = (TClonesArray*) list->At(iaod);
-               AddAODBranch("TClonesArray", &array);
-       } 
-       
-       //Histograms container
-       OpenFile(1);
-       fOutputContainer = fAna->GetOutputContainer();
-       
+  // Create the output container
+  if (fDebug > 1) printf("AliAnalysisTaskParticleCorrelation::CreateOutputData() - Begin \n");
+  
+  //Get list of aod arrays, add each aod array to analysis frame 
+  TClonesArray * array = 0;
+  TList * list = fAna->GetAODBranchList();
+  for(Int_t iaod = 0; iaod < list->GetEntries(); iaod++){
+    array = (TClonesArray*) list->At(iaod);
+    AddAODBranch("TClonesArray", &array);
+  } 
+  
+  //Histograms container
+  OpenFile(1);
+  fOutputContainer = fAna->GetOutputContainer();
+  if (fDebug > 1) printf("AliAnalysisTaskParticleCorrelation::CreateOutputData() - End \n");
 }
 
 //_____________________________________________________
 void AliAnalysisTaskParticleCorrelation::Init()
 {
   // Initialization
-  if (fDebug > 1) printf("AnalysisTaskParticleCorrelation::Init() \n");
   
-  // Call configuration file
-
-  if(fConfigName == ""){
-    fConfigName="ConfigAnalysis";
+  if (fDebug > 1) printf("AliAnalysisTaskParticleCorrelation::Init() - Begin \n");
+  
+  // Call configuration file if specified
+  
+  if (fConfigName.Length()) {
+    printf("AliAnalysisTaskParticleCorrelation::Init() - ### Configuration file is %s.C ###", fConfigName.Data());
+       gROOT->LoadMacro(fConfigName+".C");
+       fAna = (AliAnaPartCorrMaker*) gInterpreter->ProcessLine("ConfigAnalysis()");
   }
-  AliInfo(Form("### Configuration file is %s.C ###", fConfigName.Data()));
-  gROOT->LoadMacro(fConfigName+".C");
-  fAna = (AliAnaPartCorrMaker*) gInterpreter->ProcessLine("ConfigAnalysis()");
   
-  if(!fAna)
-    AliFatal("Analysis pointer not initialized, abort analysis!");
+  if(!fAna){
+    printf("AliAnalysisTaskParticleCorrelation::Init() Analysis maker pointer not initialized, no analysis specified, abort analysis!\n");
+    abort();
+  }
   
   // Add different generator particles to PDG Data Base 
   // to avoid problems when reading MC generator particles
@@ -138,7 +119,7 @@ void AliAnalysisTaskParticleCorrelation::Init()
   // Initialise analysis
   fAna->Init();
   
-  AliDebug(1,"End");
+  if (fDebug > 1) printf("AliAnalysisTaskParticleCorrelation::Init() - End \n");
   
 }
 
@@ -148,21 +129,22 @@ void AliAnalysisTaskParticleCorrelation::UserExec(Option_t */*option*/)
 {
   // Execute analysis for current event
   //
-  if (fDebug > 1) printf("AnalysisTaskParticleCorrelation::Exec() \n");
+  if (fDebug > 1) printf("AliAnalysisTaskParticleCorrelation::Exec() - Begin \n");
 
   //Get the type of data, check if type is correct
   Int_t  datatype = fAna->GetReader()->GetDataType();
   if(datatype != AliCaloTrackReader::kESD && datatype != AliCaloTrackReader::kAOD &&
      datatype != AliCaloTrackReader::kMC){
-    AliFatal("Wrong type of data");
+    printf("AliAnalysisTaskParticleCorrelation::Exec() - Wrong type of data\n");
     return ;
   }
-  
-  fAna->GetReader()->SetInputEvent(InputEvent(), AODEvent(), MCEvent());
+  fAna->GetReader()->SetInputOutputMCEvent(InputEvent(), AODEvent(), MCEvent());
 
   //Process event
   fAna->ProcessEvent((Int_t) Entry());
   
+  if (fDebug > 1) printf("AliAnalysisTaskParticleCorrelation::Exec() - End \n");
+  
   PostData(1, fOutputContainer);
   
 }
index 757f4d288b43852e719501d6055b790a20582314..942ecfd92b7186e27957cc31ef754df003bb7872 100755 (executable)
@@ -21,30 +21,31 @@ class TList;
 class AliAnalysisTaskParticleCorrelation : public AliAnalysisTaskSE
 {
  public:
-    AliAnalysisTaskParticleCorrelation();
-    AliAnalysisTaskParticleCorrelation(const char* name);
-    virtual ~AliAnalysisTaskParticleCorrelation() ;// virtual dtor
-    // Implementation of interface methods
-    virtual void UserCreateOutputObjects();
-    virtual void Init();
-    virtual void LocalInit() {Init();}
-    virtual void UserExec(Option_t *option);
-    virtual void Terminate(Option_t *option);
-
-    void SetConfigFileName(TString name ) {fConfigName = name ; }
-    TString GetConfigFileName() const {return fConfigName ; }
+  AliAnalysisTaskParticleCorrelation();
+  AliAnalysisTaskParticleCorrelation(const char* name);
+  virtual ~AliAnalysisTaskParticleCorrelation() ;// virtual dtor
+  
+  // Implementation of interface methods
+  virtual void UserCreateOutputObjects();
+  virtual void Init();
+  virtual void LocalInit() {Init();}
+  virtual void UserExec(Option_t *option);
+  virtual void Terminate(Option_t *option);
+  
+  void SetConfigFileName(TString name ) {fConfigName = name ; }
+  TString GetConfigFileName() const {return fConfigName ; }
 
+  void SetAnalysisMaker(AliAnaPartCorrMaker *maker) {fAna = maker;} 
+  
  private:
-    AliAnalysisTaskParticleCorrelation(const AliAnalysisTaskParticleCorrelation&); // Not implemented
-    AliAnalysisTaskParticleCorrelation& operator=(const AliAnalysisTaskParticleCorrelation&); // Not implemented
-
-    AliAnaPartCorrMaker* fAna; //  Pointer to the jet finder 
-    TList * fOutputContainer ; //! Histogram container
-    //TClonesArray * fAODBranch; //! AOD branch
-    TString fConfigName ; //Configuration file name
-
-    ClassDef(AliAnalysisTaskParticleCorrelation, 2); // Analysis task for standard gamma correlation analysis
+  AliAnalysisTaskParticleCorrelation(const AliAnalysisTaskParticleCorrelation&); // Not implemented
+  AliAnalysisTaskParticleCorrelation& operator=(const AliAnalysisTaskParticleCorrelation&); // Not implemented
+  
+  AliAnaPartCorrMaker* fAna; //  Pointer to the manager class 
+  TList * fOutputContainer ; //! Histogram container
+  TString fConfigName ; //Configuration file name
+  
+  ClassDef(AliAnalysisTaskParticleCorrelation, 2); // Analysis task for standard gamma correlation analysis
 };
+
 #endif //ALIANALYSISTASKPARTICLECORRELATION_H
index ee0efe8c47c839703442ac55ac63af36a2f3d102..0a5eb46f5f177ba466dcfcb44b30effcdb3de2bd 100755 (executable)
 
 // --- ROOT system ---
 #include <TMath.h>
-#include <TLorentzVector.h>
 #include <TString.h>
 #include <TFormula.h>
 
 //---- ANALYSIS system ----
-#include "AliLog.h"
 #include "AliCaloPID.h"
 #include "AliAODCaloCluster.h"
 #include "AliAODPWG4Particle.h"
@@ -48,10 +46,10 @@ fPHOSNeutralWeight(0.), fPHOSWeightFormula(0),
 fPHOSPhotonWeightFormula(0x0), fPHOSPi0WeightFormula(0x0),
 fDispCut(0.),fTOFCut(0.), fDebug(-1)
 {
-       //Ctor
-       
-       //Initialize parameters
-       InitParameters();
+  //Ctor
+  
+  //Initialize parameters
+  InitParameters();
 }
 
 //____________________________________________________________________________
@@ -72,274 +70,274 @@ fPHOSPi0WeightFormula(pid.fPHOSPi0WeightFormula),
 fDispCut(pid.fDispCut),fTOFCut(pid.fTOFCut),
 fDebug(pid.fDebug)
 {
-       // cpy ctor
+  // cpy ctor
        
 }
 
 //_________________________________________________________________________
 AliCaloPID & AliCaloPID::operator = (const AliCaloPID & pid)
 {
-       // assignment operator
-       
-       if(&pid == this) return *this;
-       
-       fEMCALPhotonWeight = pid. fEMCALPhotonWeight ;
-       fEMCALPi0Weight = pid.fEMCALPi0Weight ;
-       fEMCALElectronWeight = pid.fEMCALElectronWeight; 
-       fEMCALChargeWeight = pid.fEMCALChargeWeight;
-       fEMCALNeutralWeight = pid.fEMCALNeutralWeight;
-       
-       fPHOSPhotonWeight = pid.fPHOSPhotonWeight ;
-       fPHOSPi0Weight = pid.fPHOSPi0Weight ;
-       fPHOSElectronWeight = pid.fPHOSElectronWeight; 
-       fPHOSChargeWeight = pid.fPHOSChargeWeight;
-       fPHOSNeutralWeight = pid.fPHOSNeutralWeight;
-       
-       fPHOSWeightFormula       = pid.fPHOSWeightFormula; 
-       fPHOSPhotonWeightFormula = pid.fPHOSPhotonWeightFormula; 
-       fPHOSPi0WeightFormula    = pid.fPHOSPi0WeightFormula;
-       
-       fDispCut  = pid.fDispCut;
-       fTOFCut   = pid.fTOFCut;
-       fDebug    = pid.fDebug;
-       
-       return *this;
-       
+  // assignment operator
+  
+  if(&pid == this) return *this;
+  
+  fEMCALPhotonWeight = pid. fEMCALPhotonWeight ;
+  fEMCALPi0Weight = pid.fEMCALPi0Weight ;
+  fEMCALElectronWeight = pid.fEMCALElectronWeight; 
+  fEMCALChargeWeight = pid.fEMCALChargeWeight;
+  fEMCALNeutralWeight = pid.fEMCALNeutralWeight;
+  
+  fPHOSPhotonWeight = pid.fPHOSPhotonWeight ;
+  fPHOSPi0Weight = pid.fPHOSPi0Weight ;
+  fPHOSElectronWeight = pid.fPHOSElectronWeight; 
+  fPHOSChargeWeight = pid.fPHOSChargeWeight;
+  fPHOSNeutralWeight = pid.fPHOSNeutralWeight;
+  
+  fPHOSWeightFormula       = pid.fPHOSWeightFormula; 
+  fPHOSPhotonWeightFormula = pid.fPHOSPhotonWeightFormula; 
+  fPHOSPi0WeightFormula    = pid.fPHOSPi0WeightFormula;
+  
+  fDispCut  = pid.fDispCut;
+  fTOFCut   = pid.fTOFCut;
+  fDebug    = pid.fDebug;
+  
+  return *this;
+  
 }
 
 //_________________________________
 AliCaloPID::~AliCaloPID() {
-       //Dtor
-       
-       if(fPHOSPhotonWeightFormula) delete  fPHOSPhotonWeightFormula ;
-       if(fPHOSPi0WeightFormula) delete  fPHOSPi0WeightFormula ;
-       
+  //Dtor
+  
+  if(fPHOSPhotonWeightFormula) delete  fPHOSPhotonWeightFormula ;
+  if(fPHOSPi0WeightFormula) delete  fPHOSPi0WeightFormula ;
+  
 }
 
 
 //_______________________________________________________________
 void AliCaloPID::InitParameters()
 {
-       //Initialize the parameters of the PID.
-       
-       fEMCALPhotonWeight   = 0.8 ;
-       fEMCALPi0Weight      = 0.5 ;
-       fEMCALElectronWeight = 0.8 ;
-       fEMCALChargeWeight   = 0.5 ;
-       fEMCALNeutralWeight  = 0.5 ;
-       
-       fPHOSPhotonWeight    = 0.75 ;
-       fPHOSPi0Weight       = 0.8 ;
-       fPHOSElectronWeight  = 0.5 ;
-       fPHOSChargeWeight    = 0.5 ;
-       fPHOSNeutralWeight   = 0.5 ;
-       
-       //Formula to set the PID weight threshold for photon or pi0
-       fPHOSWeightFormula = kTRUE;
-       fPHOSPhotonWeightFormula = 
+  //Initialize the parameters of the PID.
+  
+  fEMCALPhotonWeight   = 0.8 ;
+  fEMCALPi0Weight      = 0.5 ;
+  fEMCALElectronWeight = 0.8 ;
+  fEMCALChargeWeight   = 0.5 ;
+  fEMCALNeutralWeight  = 0.5 ;
+  
+  fPHOSPhotonWeight    = 0.75 ;
+  fPHOSPi0Weight       = 0.8 ;
+  fPHOSElectronWeight  = 0.5 ;
+  fPHOSChargeWeight    = 0.5 ;
+  fPHOSNeutralWeight   = 0.5 ;
+  
+  //Formula to set the PID weight threshold for photon or pi0
+  fPHOSWeightFormula = kTRUE;
+  fPHOSPhotonWeightFormula = 
     new TFormula("photonWeight","0.98*(x<40)+ 0.68*(x>=100)+(x>=40 && x<100)*(0.98+x*(6e-3)-x*x*(2e-04)+x*x*x*(1.1e-06))");
-       fPHOSPi0WeightFormula = 
+  fPHOSPi0WeightFormula = 
     new TFormula("pi0Weight","0.98*(x<65)+ 0.915*(x>=100)+(x>=65 && x-x*(1.95e-3)-x*x*(4.31e-05)+x*x*x*(3.61e-07))");
-       
-    fDispCut  = 1.5;
-       fTOFCut   = 5.e-9;
-       fDebug = -1;
+  
+  fDispCut  = 1.5;
+  fTOFCut   = 5.e-9;
+  fDebug = -1;
 }
 
 //_______________________________________________________________
 Int_t AliCaloPID::GetPdg(const TString calo, const Double_t * pid, const Float_t energy) const {
-       //Return most probable identity of the particle.
-       
-       if(!pid) AliFatal("pid pointer not initialized!!!");
-       
-       Float_t wPh =  fPHOSPhotonWeight ;
-       Float_t wPi0 =  fPHOSPi0Weight ;
-       Float_t wE =  fPHOSElectronWeight ;
-       Float_t wCh =  fPHOSChargeWeight ;
-       Float_t wNe =  fPHOSNeutralWeight ;
-       
-       
-       if(calo == "PHOS" && fPHOSWeightFormula){
-               wPh  = fPHOSPhotonWeightFormula->Eval(energy) ;
-               wPi0 = fPHOSPi0WeightFormula->Eval(energy);
-       }
-       
-       if(calo == "EMCAL"){
-               
-               wPh  =  fEMCALPhotonWeight ;
-               wPi0 =  fEMCALPi0Weight ;
-               wE   =  fEMCALElectronWeight ;
-               wCh  =  fEMCALChargeWeight ;
-               wNe  =  fEMCALNeutralWeight ;
-               
-       }
-       
-       if(fDebug > 0)  printf("AliCaloPID::GetPdg: calo %s, ph %0.2f, pi0 %0.2f, el %0.2f, conv el %0.2f, hadrons: pion %0.2f, kaon %0.2f, proton %0.2f , neutron %0.2f, kaon %0.2f \n",
-                                                  calo.Data(),pid[AliAODCluster::kPhoton], pid[AliAODCluster::kPi0],
-                                                  pid[AliAODCluster::kElectron], pid[AliAODCluster::kEleCon],
-                                                  pid[AliAODCluster::kPion], pid[AliAODCluster::kKaon], pid[AliAODCluster::kProton],
-                                                  pid[AliAODCluster::kNeutron], pid[AliAODCluster::kKaon0]);
-       
-       Int_t pdg = kNeutralUnknown ;
-       Float_t chargedHadronWeight = pid[AliAODCluster::kProton]+pid[AliAODCluster::kKaon]+
+  //Return most probable identity of the particle.
+  
+  if(!pid){ 
+    printf("AliCaloPID::GetPdg() - pid pointer not initialized!!!\n");
+    abort();
+  }
+  
+  Float_t wPh =  fPHOSPhotonWeight ;
+  Float_t wPi0 =  fPHOSPi0Weight ;
+  Float_t wE =  fPHOSElectronWeight ;
+  Float_t wCh =  fPHOSChargeWeight ;
+  Float_t wNe =  fPHOSNeutralWeight ;
+  
+  
+  if(calo == "PHOS" && fPHOSWeightFormula){
+    wPh  = fPHOSPhotonWeightFormula->Eval(energy) ;
+    wPi0 = fPHOSPi0WeightFormula->Eval(energy);
+  }
+  
+  if(calo == "EMCAL"){
+    
+    wPh  =  fEMCALPhotonWeight ;
+    wPi0 =  fEMCALPi0Weight ;
+    wE   =  fEMCALElectronWeight ;
+    wCh  =  fEMCALChargeWeight ;
+    wNe  =  fEMCALNeutralWeight ;
+    
+  }
+  
+  if(fDebug > 0)  printf("AliCaloPID::GetPdg: calo %s, ph %0.2f, pi0 %0.2f, el %0.2f, conv el %0.2f, hadrons: pion %0.2f, kaon %0.2f, proton %0.2f , neutron %0.2f, kaon %0.2f \n",
+                        calo.Data(),pid[AliAODCluster::kPhoton], pid[AliAODCluster::kPi0],
+                        pid[AliAODCluster::kElectron], pid[AliAODCluster::kEleCon],
+                        pid[AliAODCluster::kPion], pid[AliAODCluster::kKaon], pid[AliAODCluster::kProton],
+                        pid[AliAODCluster::kNeutron], pid[AliAODCluster::kKaon0]);
+  
+  Int_t pdg = kNeutralUnknown ;
+  Float_t chargedHadronWeight = pid[AliAODCluster::kProton]+pid[AliAODCluster::kKaon]+
     pid[AliAODCluster::kPion]+pid[AliAODCluster::kMuon];
-       Float_t neutralHadronWeight = pid[AliAODCluster::kNeutron]+pid[AliAODCluster::kKaon0];
-       Float_t allChargedWeight    = pid[AliAODCluster::kElectron]+pid[AliAODCluster::kEleCon]+ chargedHadronWeight;
-       Float_t allNeutralWeight    = pid[AliAODCluster::kPhoton]+pid[AliAODCluster::kPi0]+ neutralHadronWeight;
-       
-       //Select most probable ID
-       if(calo=="PHOS"){
-               if(pid[AliAODCluster::kPhoton] > wPh) pdg = kPhoton ;
-               else if(pid[AliAODCluster::kPi0] > wPi0) pdg = kPi0 ; 
-               else if(pid[AliAODCluster::kElectron] > wE)  pdg = kElectron ;
-               else if(pid[AliAODCluster::kEleCon] >  wE) pdg = kEleCon ;
-               else if(chargedHadronWeight > wCh) pdg = kChargedHadron ;  
-               else if(neutralHadronWeight > wNe) pdg = kNeutralHadron ; 
-               else if(allChargedWeight >  allNeutralWeight)
-                       pdg = kChargedUnknown ; 
-               else 
-                       pdg = kNeutralUnknown ;
-       }
-       else{//EMCAL
-               if(pid[AliAODCluster::kPhoton]  > wPh) pdg = kPhoton ;
-               else if(pid[AliAODCluster::kPi0] > wPi0) pdg = kPi0 ; 
-               else if(pid[AliAODCluster::kElectron]  > wE) pdg = kElectron ;
-               else if(chargedHadronWeight + neutralHadronWeight > wCh) pdg = kChargedHadron ;  
-               else if(neutralHadronWeight + chargedHadronWeight > wNe) pdg = kNeutralHadron ; 
-               else pdg =  kNeutralUnknown ;
-               
-       }
-       
-       
-       if(fDebug > 0)printf("AliCaloPID::GetPdg:Final Pdg: %d \n", pdg);
-       
-       
-       
-       return pdg ;
-       
+  Float_t neutralHadronWeight = pid[AliAODCluster::kNeutron]+pid[AliAODCluster::kKaon0];
+  Float_t allChargedWeight    = pid[AliAODCluster::kElectron]+pid[AliAODCluster::kEleCon]+ chargedHadronWeight;
+  Float_t allNeutralWeight    = pid[AliAODCluster::kPhoton]+pid[AliAODCluster::kPi0]+ neutralHadronWeight;
+  
+  //Select most probable ID
+  if(calo=="PHOS"){
+    if(pid[AliAODCluster::kPhoton] > wPh) pdg = kPhoton ;
+    else if(pid[AliAODCluster::kPi0] > wPi0) pdg = kPi0 ; 
+    else if(pid[AliAODCluster::kElectron] > wE)  pdg = kElectron ;
+    else if(pid[AliAODCluster::kEleCon] >  wE) pdg = kEleCon ;
+    else if(chargedHadronWeight > wCh) pdg = kChargedHadron ;  
+    else if(neutralHadronWeight > wNe) pdg = kNeutralHadron ; 
+    else if(allChargedWeight >  allNeutralWeight)
+      pdg = kChargedUnknown ; 
+    else 
+      pdg = kNeutralUnknown ;
+  }
+  else{//EMCAL
+    if(pid[AliAODCluster::kPhoton]  > wPh) pdg = kPhoton ;
+    else if(pid[AliAODCluster::kPi0] > wPi0) pdg = kPi0 ; 
+    else if(pid[AliAODCluster::kElectron]  > wE) pdg = kElectron ;
+    else if(chargedHadronWeight + neutralHadronWeight > wCh) pdg = kChargedHadron ;  
+    else if(neutralHadronWeight + chargedHadronWeight > wNe) pdg = kNeutralHadron ; 
+    else pdg =  kNeutralUnknown ;
+    
+  }
+  
+  if(fDebug > 0)printf("AliCaloPID::GetPdg:Final Pdg: %d \n", pdg);
+   
+  return pdg ;
+  
 }
 
 //_______________________________________________________________
 Int_t AliCaloPID::GetPdg(const TString calo,const TLorentzVector mom, const AliAODCaloCluster * cluster) const {
-       //Recalculated PID with all parameters
-       if(fDebug > 0)printf("AliCaloPID::GetPdg: Calorimeter %s, E %3.2f, l0 %3.2f, l1 %3.2f, disp %3.2f, tof %1.11f, distCPV %3.2f, distToBC %1.1f, NMax %d\n",
-                                                calo.Data(),mom.E(),cluster->GetM02(),cluster->GetM20(),cluster->GetDispersion(),cluster->GetTOF(), 
-                                                cluster->GetEmcCpvDistance(), cluster->GetDistToBadChannel(),cluster->GetNExMax());
-       
-       if(calo == "EMCAL") {
-               if(cluster->GetM02()< 0.25) return kPhoton ;
-               else return  kNeutralHadron ; 
-       }
-       
-       //   if(calo == "PHOS") {
-       //    if(cluster->GetM02()< 0.25) return kPhoton ;
-       //    else return  kNeutralHadron ; 
-       //  }
-       
-       return  kNeutralHadron ; 
-       
+  //Recalculated PID with all parameters
+  if(fDebug > 0)printf("AliCaloPID::GetPdg: Calorimeter %s, E %3.2f, l0 %3.2f, l1 %3.2f, disp %3.2f, tof %1.11f, distCPV %3.2f, distToBC %1.1f, NMax %d\n",
+                      calo.Data(),mom.E(),cluster->GetM02(),cluster->GetM20(),cluster->GetDispersion(),cluster->GetTOF(), 
+                      cluster->GetEmcCpvDistance(), cluster->GetDistToBadChannel(),cluster->GetNExMax());
+  
+  if(calo == "EMCAL") {
+    if(cluster->GetM02()< 0.25) return kPhoton ;
+    else return  kNeutralHadron ; 
+  }
+  
+  //   if(calo == "PHOS") {
+  //    if(cluster->GetM02()< 0.25) return kPhoton ;
+  //    else return  kNeutralHadron ; 
+  //  }
+  
+  return  kNeutralHadron ; 
+  
 }
 
 //__________________________________________________
 TString  AliCaloPID::GetPIDParametersList()  {
-       //Put data member values in string to keep in output container
-       
-       TString parList ; //this will be list of parameters used for this analysis.
-       char onePar[255] ;
-       sprintf(onePar,"--- AliCaloPID ---\n") ;
-       parList+=onePar ;       
-       sprintf(onePar,"fDispCut =%2.2f (Cut on dispersion, used in PID evaluation) \n",fDispCut) ;
-       parList+=onePar ;
-       sprintf(onePar,"fTOFCut  =%e (Cut on TOF, used in PID evaluation) \n",fTOFCut) ;
-       parList+=onePar ;
-       sprintf(onePar,"fEMCALPhotonWeight =%2.2f (EMCAL bayesian weight for photons)\n",fEMCALPhotonWeight) ;
-       parList+=onePar ;
-       sprintf(onePar,"fEMCALPi0Weight =%2.2f (EMCAL bayesian weight for pi0)\n",fEMCALPi0Weight) ;
-       parList+=onePar ;
-       sprintf(onePar,"fEMCALElectronWeight =%2.2f(EMCAL bayesian weight for electrons)\n",fEMCALElectronWeight) ;
-       parList+=onePar ;
-       sprintf(onePar,"fEMCALChargeWeight =%2.2f (EMCAL bayesian weight for charged hadrons)\n",fEMCALChargeWeight) ;
-       parList+=onePar ;
-       sprintf(onePar,"fEMCALNeutralWeight =%2.2f (EMCAL bayesian weight for neutral hadrons)\n",fEMCALNeutralWeight) ;
-       parList+=onePar ;
-       sprintf(onePar,"fPHOSPhotonWeight =%2.2f (PHOS bayesian weight for photons)\n",fPHOSPhotonWeight) ;
-       parList+=onePar ;
-       sprintf(onePar,"fPHOSPi0Weight =%2.2f (PHOS bayesian weight for pi0)\n",fPHOSPi0Weight) ;
-       parList+=onePar ;
-       sprintf(onePar,"fPHOSElectronWeight =%2.2f(PHOS bayesian weight for electrons)\n",fPHOSElectronWeight) ;
-       parList+=onePar ;
-       sprintf(onePar,"fPHOSChargeWeight =%2.2f (PHOS bayesian weight for charged hadrons)\n",fPHOSChargeWeight) ;
-       parList+=onePar ;
-       sprintf(onePar,"fPHOSNeutralWeight =%2.2f (PHOS bayesian weight for neutral hadrons)\n",fPHOSNeutralWeight) ;
-       parList+=onePar ;
-       
-       if(fPHOSWeightFormula){
-               parList+="PHOS Photon Weight Formula: "+(fPHOSPhotonWeightFormula->GetExpFormula("p"));
-               parList+="PHOS Pi0    Weight Formula: "+(fPHOSPi0WeightFormula->GetExpFormula("p"));
-       }
-       
-       return parList; 
-       
+  //Put data member values in string to keep in output container
+  
+  TString parList ; //this will be list of parameters used for this analysis.
+  char onePar[255] ;
+  sprintf(onePar,"--- AliCaloPID ---\n") ;
+  parList+=onePar ;    
+  sprintf(onePar,"fDispCut =%2.2f (Cut on dispersion, used in PID evaluation) \n",fDispCut) ;
+  parList+=onePar ;
+  sprintf(onePar,"fTOFCut  =%e (Cut on TOF, used in PID evaluation) \n",fTOFCut) ;
+  parList+=onePar ;
+  sprintf(onePar,"fEMCALPhotonWeight =%2.2f (EMCAL bayesian weight for photons)\n",fEMCALPhotonWeight) ;
+  parList+=onePar ;
+  sprintf(onePar,"fEMCALPi0Weight =%2.2f (EMCAL bayesian weight for pi0)\n",fEMCALPi0Weight) ;
+  parList+=onePar ;
+  sprintf(onePar,"fEMCALElectronWeight =%2.2f(EMCAL bayesian weight for electrons)\n",fEMCALElectronWeight) ;
+  parList+=onePar ;
+  sprintf(onePar,"fEMCALChargeWeight =%2.2f (EMCAL bayesian weight for charged hadrons)\n",fEMCALChargeWeight) ;
+  parList+=onePar ;
+  sprintf(onePar,"fEMCALNeutralWeight =%2.2f (EMCAL bayesian weight for neutral hadrons)\n",fEMCALNeutralWeight) ;
+  parList+=onePar ;
+  sprintf(onePar,"fPHOSPhotonWeight =%2.2f (PHOS bayesian weight for photons)\n",fPHOSPhotonWeight) ;
+  parList+=onePar ;
+  sprintf(onePar,"fPHOSPi0Weight =%2.2f (PHOS bayesian weight for pi0)\n",fPHOSPi0Weight) ;
+  parList+=onePar ;
+  sprintf(onePar,"fPHOSElectronWeight =%2.2f(PHOS bayesian weight for electrons)\n",fPHOSElectronWeight) ;
+  parList+=onePar ;
+  sprintf(onePar,"fPHOSChargeWeight =%2.2f (PHOS bayesian weight for charged hadrons)\n",fPHOSChargeWeight) ;
+  parList+=onePar ;
+  sprintf(onePar,"fPHOSNeutralWeight =%2.2f (PHOS bayesian weight for neutral hadrons)\n",fPHOSNeutralWeight) ;
+  parList+=onePar ;
+  
+  if(fPHOSWeightFormula){
+    parList+="PHOS Photon Weight Formula: "+(fPHOSPhotonWeightFormula->GetExpFormula("p"));
+    parList+="PHOS Pi0    Weight Formula: "+(fPHOSPi0WeightFormula->GetExpFormula("p"));
+  }
+  
+  return parList; 
+  
 }
 
 //________________________________________________________________
 void AliCaloPID::Print(const Option_t * opt) const
 {
-       
-       //Print some relevant parameters set for the analysis
-       if(! opt)
-               return;
-       
-       printf("***** Print: %s %s ******\n", GetName(), GetTitle() ) ;
-       
-       printf("PHOS PID weight , photon %0.2f, pi0 %0.2f, e %0.2f, charge %0.2f, neutral %0.2f \n",  
-                  fPHOSPhotonWeight,  fPHOSPi0Weight, 
-                  fPHOSElectronWeight,  fPHOSChargeWeight,   fPHOSNeutralWeight) ; 
-       printf("EMCAL PID weight, photon %0.2f, pi0 %0.2f, e %0.2f, charge %0.2f, neutral %0.2f\n",   
-                  fEMCALPhotonWeight,  fEMCALPi0Weight, 
-                  fEMCALElectronWeight,  fEMCALChargeWeight,  fEMCALNeutralWeight) ; 
-       
-       printf("PHOS Parametrized weight on?  =     %d\n",  fPHOSWeightFormula) ; 
-       if(fPHOSWeightFormula){
-               printf("Photon weight formula = %s\n", (fPHOSPhotonWeightFormula->GetExpFormula("p")).Data());
-               printf("Pi0    weight formula = %s\n", (fPHOSPhotonWeightFormula->GetExpFormula("p")).Data());
-    }
-       
-       printf("TOF cut        = %e\n",fTOFCut);
-       printf("Dispersion cut = %2.2f\n",fDispCut);
-       printf("Debug level    = %d\n",fDebug);
-
-       printf(" \n");
-       
+  
+  //Print some relevant parameters set for the analysis
+  if(! opt)
+    return;
+  
+  printf("***** Print: %s %s ******\n", GetName(), GetTitle() ) ;
+  
+  printf("PHOS PID weight , photon %0.2f, pi0 %0.2f, e %0.2f, charge %0.2f, neutral %0.2f \n",  
+        fPHOSPhotonWeight,  fPHOSPi0Weight, 
+        fPHOSElectronWeight,  fPHOSChargeWeight,   fPHOSNeutralWeight) ; 
+  printf("EMCAL PID weight, photon %0.2f, pi0 %0.2f, e %0.2f, charge %0.2f, neutral %0.2f\n",   
+        fEMCALPhotonWeight,  fEMCALPi0Weight, 
+        fEMCALElectronWeight,  fEMCALChargeWeight,  fEMCALNeutralWeight) ; 
+  
+  printf("PHOS Parametrized weight on?  =     %d\n",  fPHOSWeightFormula) ; 
+  if(fPHOSWeightFormula){
+    printf("Photon weight formula = %s\n", (fPHOSPhotonWeightFormula->GetExpFormula("p")).Data());
+    printf("Pi0    weight formula = %s\n", (fPHOSPhotonWeightFormula->GetExpFormula("p")).Data());
+  }
+  
+  printf("TOF cut        = %e\n",fTOFCut);
+  printf("Dispersion cut = %2.2f\n",fDispCut);
+  printf("Debug level    = %d\n",fDebug);
+  
+  printf(" \n");
+  
 } 
 
 //_______________________________________________________________
 void AliCaloPID::SetPIDBits(const TString calo, const AliAODCaloCluster * cluster, AliAODPWG4Particle * ph) {
-       //Set Bits for PID selection
-       
-       //Dispersion/lambdas
-    Double_t disp=cluster->GetDispersion()  ;
+  //Set Bits for PID selection
+  
+  //Dispersion/lambdas
+  Double_t disp=cluster->GetDispersion()  ;
        //    Double_t m20=calo->GetM20() ;
        //    Double_t m02=calo->GetM02() ; 
-    ph->SetDispBit(disp<fDispCut) ;  
-       
-    //TOF
-    Double_t tof=cluster->GetTOF()  ;
-    ph->SetTOFBit(TMath::Abs(tof)<fTOFCut) ; 
-       
-    //Charged veto
-       //    Double_t cpvR=calo->GetEmcCpvDistance() ; 
-    Int_t ntr=cluster->GetNTracksMatched();  //number of track matched
-    ph->SetChargedBit(ntr>0) ;  //Temporary cut, should we evaluate distance?
-       
-    //Set PID pdg
-    ph->SetPdg(GetPdg(calo,cluster->PID(),ph->E()));
-    
-    if(fDebug > 0){ 
-      printf("AliCaloPID::SetPIDBits: TOF %e, Dispersion %2.2f, NTracks %d\n",tof , disp, ntr);        
-      printf("AliCaloPID::SetPIDBits: pdg %d, bits: TOF %d, Dispersion %d, Charge %d\n",
+  ph->SetDispBit(disp<fDispCut) ;  
+  
+  //TOF
+  Double_t tof=cluster->GetTOF()  ;
+  ph->SetTOFBit(TMath::Abs(tof)<fTOFCut) ; 
+  
+  //Charged veto
+  //    Double_t cpvR=calo->GetEmcCpvDistance() ; 
+  Int_t ntr=cluster->GetNTracksMatched();  //number of track matched
+  ph->SetChargedBit(ntr>0) ;  //Temporary cut, should we evaluate distance?
+  
+  //Set PID pdg
+  ph->SetPdg(GetPdg(calo,cluster->PID(),ph->E()));
+  
+  if(fDebug > 0){ 
+    printf("AliCaloPID::SetPIDBits: TOF %e, Dispersion %2.2f, NTracks %d\n",tof , disp, ntr);  
+    printf("AliCaloPID::SetPIDBits: pdg %d, bits: TOF %d, Dispersion %d, Charge %d\n",
             ph->GetPdg(), ph->GetTOFBit() , ph->GetDispBit() , ph->GetChargedBit()); 
-    }
+  }
 }
 
 
index 9c36bb65b3b1abb0e1ec33e5824d73b381dc7359..e190c38a1b9cd986874be0f160aeed70b1512efb 100755 (executable)
@@ -17,111 +17,110 @@ class TLorentzVector ;
 class TFormula ;
 
 //--- AliRoot system ---
-class AliLog ;
 class AliAODCaloCluster;
 class AliAODPWG4Particle;
 
 class AliCaloPID : public TObject {
        
-public: 
-       
-       AliCaloPID() ; // ctor
-       AliCaloPID(const AliCaloPID & g) ; // cpy ctor
-       AliCaloPID & operator = (const AliCaloPID & g) ;//cpy assignment
-       virtual ~AliCaloPID() ;//virtual dtor
-       
-       enum PidType {
-               kPhoton = 22,
-               kPi0 = 111,
-               kEta = 221, 
-               kElectron = 11, 
-               kEleCon = -11, 
-               kNeutralHadron = 2112, 
-               kChargedHadron = 211, 
-               kNeutralUnknown = 130, 
-               kChargedUnknown=321
-       };
-       
-       enum TagType {kPi0Decay, kEtaDecay, kOtherDecay, kConversion, kNoTag = -1};
-       
-       void InitParameters();
-       
-       Int_t GetPdg(const TString calo, const Double_t * pid, const Float_t energy) const ;
-       
-       Int_t GetPdg(const TString calo,const TLorentzVector mom, const AliAODCaloCluster * cluster) const ;
-       
-       TString GetPIDParametersList();
-               
-       void SetPIDBits(const TString calo,  const AliAODCaloCluster * cluster, AliAODPWG4Particle *aodph);
-       
-       void Print(const Option_t * opt)const;
-       
-       //Weight getters
-       Float_t  GetEMCALPhotonWeight() const  { return  fEMCALPhotonWeight  ; }
-       Float_t  GetEMCALPi0Weight() const     {  return fEMCALPi0Weight  ; }
-       Float_t  GetEMCALElectronWeight() const  { return  fEMCALElectronWeight  ; }
-       Float_t  GetEMCALChargeWeight() const     {  return fEMCALChargeWeight  ; }
-       Float_t  GetEMCALNeutralWeight() const     {  return fEMCALNeutralWeight  ; }
-       Float_t  GetPHOSPhotonWeight() const   {  return fPHOSPhotonWeight  ; }
-       Float_t  GetPHOSPi0Weight() const   {  return fPHOSPi0Weight  ; }
-       Float_t  GetPHOSElectronWeight() const   {  return fPHOSElectronWeight  ; }
-       Float_t  GetPHOSChargeWeight() const   {  return fPHOSChargeWeight  ; }
-       Float_t  GetPHOSNeutralWeight() const   {  return fPHOSNeutralWeight  ; }
-       
-       Bool_t  IsPHOSPIDWeightFormulaOn() const   {  return fPHOSWeightFormula  ; } 
-       TFormula * GetPHOSPhotonWeightFormula() const     {  return fPHOSPhotonWeightFormula  ; } 
-       TFormula * GetPHOSPi0WeightFormula() const    {  return fPHOSPi0WeightFormula  ; }
-       
-       //Weight setters
-       void SetEMCALPhotonWeight(Float_t  w){  fEMCALPhotonWeight = w ; }
-       void SetEMCALPi0Weight(Float_t  w){  fEMCALPi0Weight = w ; }
-       void SetEMCALElectronWeight(Float_t  w){  fEMCALElectronWeight = w ; }
-       void SetEMCALChargeWeight(Float_t  w){  fEMCALChargeWeight = w ; }
-       void SetEMCALNeutralWeight(Float_t  w){  fEMCALNeutralWeight = w ; }
-       void SetPHOSPhotonWeight(Float_t  w){  fPHOSPhotonWeight = w ; }
-       void SetPHOSPi0Weight(Float_t  w){  fPHOSPi0Weight = w ; }
-       void SetPHOSElectronWeight(Float_t  w){  fPHOSElectronWeight = w ; }
-       void SetPHOSChargeWeight(Float_t  w){  fPHOSChargeWeight = w ; }
-       void SetPHOSNeutralWeight(Float_t  w){  fPHOSNeutralWeight = w ; }
-       
-       void UsePHOSPIDWeightFormula(Bool_t par)  { fPHOSWeightFormula  = par; } 
-       void SetPHOSPhotonWeightFormula(TFormula * photon)    {  fPHOSPhotonWeightFormula  = photon; } 
-       void SetPHOSPi0WeightFormula(TFormula * pi0)   {  fPHOSPi0WeightFormula  = pi0; }
-       
-       //PID bits setters and getters
-       void SetDispersionCut(Float_t dcut ) {fDispCut = dcut; }
-       Float_t GetDispersionCut() const {return fDispCut ;}   
-       
-       void SetTOFCut(Float_t tcut ) {fTOFCut = tcut; }
-       Float_t GetTOFCut() const {return fTOFCut ;}   
-       
-       void SetDebug(Int_t deb) {fDebug=deb;}
-       Int_t GetDebug() const {return fDebug;} 
-       
-private:
-       
-       Float_t      fEMCALPhotonWeight; //Bayesian PID weight for photons in EMCAL 
-       Float_t      fEMCALPi0Weight;  //Bayesian PID weight for pi0 in EMCAL 
-       Float_t      fEMCALElectronWeight; //Bayesian PID weight for electrons in EMCAL 
-       Float_t      fEMCALChargeWeight;  //Bayesian PID weight for charged hadrons in EMCAL 
-       Float_t      fEMCALNeutralWeight;  //Bayesian PID weight for neutral hadrons in EMCAL 
-       Float_t      fPHOSPhotonWeight; //Bayesian PID weight for photons in PHOS 
-       Float_t      fPHOSPi0Weight; //Bayesian PID weight for pi0 in PHOS 
-       Float_t      fPHOSElectronWeight; //Bayesian PID weight for electrons in PHOS 
-       Float_t      fPHOSChargeWeight; //Bayesian PID weight for charged hadrons in PHOS 
-       Float_t      fPHOSNeutralWeight; //Bayesian PID weight for neutral hadrons in PHOS 
-       
-       Bool_t  fPHOSWeightFormula ; //Use parametrized weight threshold, function of energy
-       TFormula * fPHOSPhotonWeightFormula ; //Formula for photon weight
-       TFormula * fPHOSPi0WeightFormula ; //Formula for pi0 weight
-       
-       Float_t fDispCut;    //Cut on dispersion, used in PID evaluation
-       Float_t fTOFCut;     //Cut on TOF, used in PID evaluation
-       
-       Int_t    fDebug; //Debug level
-
-       ClassDef(AliCaloPID,3)
-} ;
+ public: 
+  
+  AliCaloPID() ; // ctor
+  AliCaloPID(const AliCaloPID & g) ; // cpy ctor
+  AliCaloPID & operator = (const AliCaloPID & g) ;//cpy assignment
+  virtual ~AliCaloPID() ;//virtual dtor
+  
+  enum PidType {
+    kPhoton = 22,
+    kPi0 = 111,
+    kEta = 221, 
+    kElectron = 11, 
+    kEleCon = -11, 
+    kNeutralHadron = 2112, 
+    kChargedHadron = 211, 
+    kNeutralUnknown = 130, 
+    kChargedUnknown=321
+  };
+  
+  enum TagType {kPi0Decay, kEtaDecay, kOtherDecay, kConversion, kNoTag = -1};
+  
+  void InitParameters();
+  
+  Int_t GetPdg(const TString calo, const Double_t * pid, const Float_t energy) const ;
+  
+  Int_t GetPdg(const TString calo,const TLorentzVector mom, const AliAODCaloCluster * cluster) const ;
+  
+  TString      GetPIDParametersList();
+  
+  void SetPIDBits(const TString calo,  const AliAODCaloCluster * cluster, AliAODPWG4Particle *aodph);
+  
+  void Print(const Option_t * opt)const;
+  
+  //Weight getters
+  Float_t  GetEMCALPhotonWeight() const  { return  fEMCALPhotonWeight  ; }
+  Float_t  GetEMCALPi0Weight() const     {  return fEMCALPi0Weight  ; }
+  Float_t  GetEMCALElectronWeight() const  { return  fEMCALElectronWeight  ; }
+  Float_t  GetEMCALChargeWeight() const     {  return fEMCALChargeWeight  ; }
+  Float_t  GetEMCALNeutralWeight() const     {  return fEMCALNeutralWeight  ; }
+  Float_t  GetPHOSPhotonWeight() const   {  return fPHOSPhotonWeight  ; }
+  Float_t  GetPHOSPi0Weight() const   {  return fPHOSPi0Weight  ; }
+  Float_t  GetPHOSElectronWeight() const   {  return fPHOSElectronWeight  ; }
+  Float_t  GetPHOSChargeWeight() const   {  return fPHOSChargeWeight  ; }
+  Float_t  GetPHOSNeutralWeight() const   {  return fPHOSNeutralWeight  ; }
+  
+  Bool_t  IsPHOSPIDWeightFormulaOn() const   {  return fPHOSWeightFormula  ; } 
+  TFormula * GetPHOSPhotonWeightFormula() const     {  return fPHOSPhotonWeightFormula  ; } 
+  TFormula * GetPHOSPi0WeightFormula() const    {  return fPHOSPi0WeightFormula  ; }
+  
+  //Weight setters
+  void SetEMCALPhotonWeight(Float_t  w){  fEMCALPhotonWeight = w ; }
+  void SetEMCALPi0Weight(Float_t  w){  fEMCALPi0Weight = w ; }
+  void SetEMCALElectronWeight(Float_t  w){  fEMCALElectronWeight = w ; }
+  void SetEMCALChargeWeight(Float_t  w){  fEMCALChargeWeight = w ; }
+  void SetEMCALNeutralWeight(Float_t  w){  fEMCALNeutralWeight = w ; }
+  void SetPHOSPhotonWeight(Float_t  w){  fPHOSPhotonWeight = w ; }
+  void SetPHOSPi0Weight(Float_t  w){  fPHOSPi0Weight = w ; }
+  void SetPHOSElectronWeight(Float_t  w){  fPHOSElectronWeight = w ; }
+  void SetPHOSChargeWeight(Float_t  w){  fPHOSChargeWeight = w ; }
+  void SetPHOSNeutralWeight(Float_t  w){  fPHOSNeutralWeight = w ; }
+  
+  void UsePHOSPIDWeightFormula(Bool_t par)  { fPHOSWeightFormula  = par; } 
+  void SetPHOSPhotonWeightFormula(TFormula * photon)    {  fPHOSPhotonWeightFormula  = photon; } 
+  void SetPHOSPi0WeightFormula(TFormula * pi0)   {  fPHOSPi0WeightFormula  = pi0; }
+  
+  //PID bits setters and getters
+  void SetDispersionCut(Float_t dcut ) {fDispCut = dcut; }
+  Float_t GetDispersionCut() const {return fDispCut ;}   
+  
+  void SetTOFCut(Float_t tcut ) {fTOFCut = tcut; }
+  Float_t GetTOFCut() const {return fTOFCut ;}   
+  
+  void SetDebug(Int_t deb) {fDebug=deb;}
+  Int_t GetDebug() const {return fDebug;}      
+  
+ private:
+  
+  Float_t      fEMCALPhotonWeight; //Bayesian PID weight for photons in EMCAL 
+  Float_t      fEMCALPi0Weight;  //Bayesian PID weight for pi0 in EMCAL 
+  Float_t      fEMCALElectronWeight; //Bayesian PID weight for electrons in EMCAL 
+  Float_t      fEMCALChargeWeight;  //Bayesian PID weight for charged hadrons in EMCAL 
+  Float_t      fEMCALNeutralWeight;  //Bayesian PID weight for neutral hadrons in EMCAL 
+  Float_t      fPHOSPhotonWeight; //Bayesian PID weight for photons in PHOS 
+  Float_t      fPHOSPi0Weight; //Bayesian PID weight for pi0 in PHOS 
+  Float_t      fPHOSElectronWeight; //Bayesian PID weight for electrons in PHOS 
+  Float_t      fPHOSChargeWeight; //Bayesian PID weight for charged hadrons in PHOS 
+  Float_t      fPHOSNeutralWeight; //Bayesian PID weight for neutral hadrons in PHOS 
+  
+  Bool_t  fPHOSWeightFormula ; //Use parametrized weight threshold, function of energy
+  TFormula * fPHOSPhotonWeightFormula ; //Formula for photon weight
+  TFormula * fPHOSPi0WeightFormula ; //Formula for pi0 weight
+  
+  Float_t fDispCut;    //Cut on dispersion, used in PID evaluation
+  Float_t fTOFCut;     //Cut on TOF, used in PID evaluation
+  
+  Int_t         fDebug; //Debug level
+  
+  ClassDef(AliCaloPID,3)
+    } ;
 
 
 #endif //ALICALOPID_H
index 74a5f60612684594c7bff4e1e983ac8bdf4e50a8..161ad92e27f0f69d72efcf313e05141591149f80 100755 (executable)
 //---- ANALYSIS system ----
 #include "AliCaloTrackAODReader.h" 
 #include "AliAODEvent.h"
-#include "AliAODVertex.h"
-#include "AliAODCaloCluster.h"
 #include "AliAODCaloCluster.h"
 #include "AliAODTrack.h"
-#include "AliMCEvent.h"
-#include "AliLog.h"
+#include "AliFidutialCut.h"
 
 ClassImp(AliCaloTrackAODReader)
 
@@ -71,14 +68,13 @@ AliCaloTrackAODReader::AliCaloTrackAODReader(const AliCaloTrackAODReader & g) :
 //____________________________________________________________________________
 void AliCaloTrackAODReader::FillInputCTS() {
   //Return array with CTS tracks
-  fAODCTS = new TClonesArray("AliAODTrack",0);
 
-  Int_t nTracks   = fAOD->GetNumberOfTracks() ;
-  Int_t naod = 0;
+  Int_t nTracks   = fInputEvent->GetNumberOfTracks() ;
+  Bool_t first = kTRUE;
   Double_t p[3];
   
   for (Int_t itrack =  0; itrack <  nTracks; itrack++) {////////////// track loop
-    AliAODTrack * track = fAOD->GetTrack(itrack) ; // retrieve track from esd
+    AliAODTrack * track = ((AliAODEvent*)fInputEvent)->GetTrack(itrack) ; // retrieve track from esd
     
     //     //We want tracks fitted in the detectors:
     //     ULong_t status=AliAODTrack::kTPCrefit;
@@ -98,7 +94,11 @@ void AliCaloTrackAODReader::FillInputCTS() {
       if(fDebug > 2 && momentum.Pt() > 0.1)printf("FillInputCTS():: Selected tracks E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f\n",
                                                  momentum.E(),momentum.Pt(),momentum.Phi()*TMath::RadToDeg(),momentum.Eta());
       
-      new((*fAODCTS)[naod++])  AliAODTrack(*track);
+      if(first){
+       new (fAODCTS) TRefArray(TProcessID::GetProcessWithUID(track)); 
+       first=kFALSE;
+      }     
+      fAODCTS->Add(track);
       
     }//Pt and Fidutial cut passed. 
     //}// track status
@@ -110,29 +110,34 @@ void AliCaloTrackAODReader::FillInputCTS() {
 void AliCaloTrackAODReader::FillInputEMCAL() {
   //Return array with EMCAL clusters in aod format
 
-   fAODEMCAL = new TClonesArray("AliAODCaloCluster",0);
-   TRefArray * caloClusters = new TRefArray();
-   fAOD->GetEMCALClusters(caloClusters);
-
+  Bool_t first = kTRUE;
+  
   //Get vertex for momentum calculation  
   Double_t v[3] ; //vertex ;
   GetVertex(v);
-
+  
   //Loop to select clusters in fidutial cut and fill container with aodClusters
-  Int_t naod = 0;
-  for (Int_t iclus =  0; iclus <  caloClusters->GetEntriesFast(); iclus++) {
-    AliAODCaloCluster * clus = (AliAODCaloCluster *) caloClusters->At(iclus) ;
-    TLorentzVector momentum ;
-    clus->GetMomentum(momentum, v);      
+  //Int_t naod = 0;
+  for (Int_t iclus =  0; iclus < ((AliAODEvent*)fInputEvent)->GetNCaloClusters(); iclus++) {
+    AliAODCaloCluster * clus = 0;
+    if ( (clus = ((AliAODEvent*)fInputEvent)->GetCaloCluster(iclus)) ) {
+      if (clus->IsEMCALCluster()){
+       TLorentzVector momentum ;
+       clus->GetMomentum(momentum, v);      
+       
+       if(fEMCALPtMin < momentum.Pt() && fFidutialCut->IsInFidutialCut(momentum,"EMCAL")){
     
-    if(fEMCALPtMin < momentum.Pt() && fFidutialCut->IsInFidutialCut(momentum,"EMCAL")){
-    
-      if(fDebug > 2 && momentum.E() > 0.1)printf("FillInputEMCAL():: Selected clusters E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f\n",
-                                                momentum.E(),momentum.Pt(),momentum.Phi()*TMath::RadToDeg(),momentum.Eta());
-
-      new((*fAODEMCAL)[naod++]) AliAODCaloCluster(*clus);
-
-    }//Pt and Fidutial cut passed.
+         if(fDebug > 2 && momentum.E() > 0.1)printf("FillInputEMCAL():: Selected clusters E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f\n",
+                                                    momentum.E(),momentum.Pt(),momentum.Phi()*TMath::RadToDeg(),momentum.Eta());
+         
+         if(first){
+           new (fAODEMCAL) TRefArray(TProcessID::GetProcessWithUID(clus)); 
+           first=kFALSE;
+         }
+         fAODEMCAL->Add(clus); 
+       }//Pt and Fidutial cut passed.
+      }//EMCAL cluster
+    }// cluster exists
   }//esd cluster loop
   
   if(fDebug > 1) printf("FillInputEMCAL():: aod entries %d\n", fAODEMCAL->GetEntriesFast());
@@ -143,30 +148,35 @@ void AliCaloTrackAODReader::FillInputEMCAL() {
 void AliCaloTrackAODReader::FillInputPHOS() {
   //Return array with PHOS clusters in aod format
 
-  fAODPHOS = new TClonesArray("AliAODCaloCluster",0);
-  TRefArray * caloClusters = new TRefArray();
-  fAOD->GetPHOSClusters(caloClusters);
-
+   Bool_t first = kTRUE;
+  
   //Get vertex for momentum calculation  
   Double_t v[3] ; //vertex ;
   GetVertex(v);
 
   //Loop to select clusters in fidutial cut and fill container with aodClusters
-  Int_t naod = 0;
-
-  for (Int_t iclus =  0; iclus <  caloClusters->GetEntriesFast(); iclus++) {
-    AliAODCaloCluster * clus = (AliAODCaloCluster *) caloClusters->At(iclus) ;
-    TLorentzVector momentum ;
-    clus->GetMomentum(momentum, v);      
-    
-    if(fPHOSPtMin < momentum.Pt() && fFidutialCut->IsInFidutialCut(momentum,"PHOS")){
-      
-      if(fDebug > 2 && momentum.E() > 0.1)printf("FillInputPHOS():: Selected clusters E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f\n",
-                                                momentum.E(),momentum.Pt(),momentum.Phi()*TMath::RadToDeg(),momentum.Eta());
-
-      new((*fAODPHOS)[naod++])  AliAODCaloCluster(*clus);
-      
-    }//Pt and Fidutial cut passed.
+  //Int_t naod = 0;
+
+  for (Int_t iclus =  0; iclus < ((AliAODEvent*)fInputEvent)->GetNCaloClusters(); iclus++) {
+    AliAODCaloCluster * clus = 0;
+    if ( (clus = ((AliAODEvent*)fInputEvent)->GetCaloCluster(iclus)) ) {
+      if (clus->IsPHOSCluster()){
+       TLorentzVector momentum ;
+       clus->GetMomentum(momentum, v);      
+       
+       if(fPHOSPtMin < momentum.Pt() && fFidutialCut->IsInFidutialCut(momentum,"PHOS")){
+         
+         if(fDebug > 2 && momentum.E() > 0.1)printf("FillInputPHOS():: Selected clusters E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f\n",
+                                                    momentum.E(),momentum.Pt(),momentum.Phi()*TMath::RadToDeg(),momentum.Eta());
+         
+         if(first){
+           new (fAODPHOS) TRefArray(TProcessID::GetProcessWithUID(clus)); 
+           first=kFALSE;
+         }     
+         fAODPHOS->Add(clus);  
+       }//Pt and Fidutial cut passed.
+      }//PHOS cluster
+    }//cluster exists
   }//esd cluster loop
   
   if(fDebug > 1) printf("FillInputPHOS():: aod entries %d\n", fAODPHOS->GetEntriesFast());
@@ -178,7 +188,7 @@ void AliCaloTrackAODReader::FillInputPHOS() {
 void AliCaloTrackAODReader::FillInputEMCALCells() {
   //Return array with EMCAL cells in aod format
 
-  fEMCALCells = (TNamed*) fAOD->GetEMCALCells(); 
+  fEMCALCells = (TNamed*) ((AliAODEvent*)fInputEvent)->GetEMCALCells(); 
 
 }
 
@@ -186,7 +196,7 @@ void AliCaloTrackAODReader::FillInputEMCALCells() {
 void AliCaloTrackAODReader::FillInputPHOSCells() {
   //Return array with PHOS cells in aod format
 
-  fPHOSCells = (TNamed*) fAOD->GetPHOSCells(); 
+  fPHOSCells = (TNamed*) ((AliAODEvent*)fInputEvent)->GetPHOSCells(); 
 
 }
 
@@ -194,21 +204,29 @@ void AliCaloTrackAODReader::FillInputPHOSCells() {
 void AliCaloTrackAODReader::GetVertex(Double_t  v[3]) const {
   //Return vertex position
 
-  v[0]=fAOD->GetVertex(0)->GetX() ;//CHECK!!!
-  v[1]=fAOD->GetVertex(0)->GetY() ;//CHECK!!!
-  v[2]=fAOD->GetVertex(0)->GetZ() ;//CHECK!!!
+  v[0] = ((AliAODEvent*)fInputEvent)->GetVertex(0)->GetX() ;//CHECK!!!
+  v[1] = ((AliAODEvent*)fInputEvent)->GetVertex(0)->GetY() ;//CHECK!!!
+  v[2] = ((AliAODEvent*)fInputEvent)->GetVertex(0)->GetZ() ;//CHECK!!!
 }
 
 
 //____________________________________________________________________________
-void AliCaloTrackAODReader::SetInputEvent(TObject* input, TObject* aod, TObject* mc) {
+void AliCaloTrackAODReader::SetInputOutputMCEvent(AliVEvent* input, AliAODEvent* aod, AliMCEvent* mc) {
   // Connect the data pointers
-
-  //If input is AOD, do analysis with input, if not, do analysis with the output aod.
-  if(!strcmp(input->GetName(),"AliESDEvent"))   SetAOD((AliAODEvent*) aod);
-  else if(!strcmp(input->GetName(),"AliAODEvent")) SetAOD((AliAODEvent*) input);
-  else AliFatal(Form("Unknown data format: %s",input->GetName()));
+  // If input is AOD, do analysis with input, if not, do analysis with the output aod.
+  if(!strcmp(input->GetName(),"AliESDEvent"))   {
+    SetInputEvent(aod);
+    SetOutputEvent(aod);
+  }
+  else if(!strcmp(input->GetName(),"AliAODEvent")){
+    SetInputEvent(input);
+    SetOutputEvent(aod);
+  }
+  else{ 
+    printf("AliCaloTrackAODReader::SetInputOutputMCEvent() - ABORT::Unknown data format: %s",input->GetName());
+    abort();
+  }
+  
+  SetMC(mc);
   
-  SetMC((AliMCEvent*) mc);
-
 }
index e8ebc8c5124f56849e7683f3870110eadba7d092..798195a1bcd4aade60196805e94ae124d768fb0c 100755 (executable)
@@ -20,25 +20,23 @@ class AliCaloTrackAODReader : public AliCaloTrackReader {
        
 public: 
        
-       AliCaloTrackAODReader() ; // ctor
-       AliCaloTrackAODReader(const AliCaloTrackAODReader & g)  ; // cpy ctor
-       //AliCaloTrackAODReader & operator = (const AliCaloTrackAODReader & g) ;//cpy assignment
-       virtual ~AliCaloTrackAODReader() {;} //virtual dtor
-       
-       void FillInputCTS()   ;
-       void FillInputEMCAL() ;
-       void FillInputPHOS()  ;
-       void FillInputEMCALCells() ;
-       void FillInputPHOSCells()  ;
-       
-       void GetVertex(Double_t v[3]) const ;
-       
-       AliVEvent*  GetInputEvent()   const {return GetAOD();}
-       void SetInputEvent(TObject* esd, TObject* aod, TObject* mc) ; 
-       
-       
-       ClassDef(AliCaloTrackAODReader,1)
-} ;
+  AliCaloTrackAODReader() ; // ctor
+  AliCaloTrackAODReader(const AliCaloTrackAODReader & g)  ; // cpy ctor
+  //AliCaloTrackAODReader & operator = (const AliCaloTrackAODReader & g) ;//cpy assignment
+  virtual ~AliCaloTrackAODReader() {;} //virtual dtor
+  
+  void FillInputCTS()   ;
+  void FillInputEMCAL() ;
+  void FillInputPHOS()  ;
+  void FillInputEMCALCells() ;
+  void FillInputPHOSCells()  ;
+  
+  void GetVertex(Double_t v[3]) const ;
+  void SetInputOutputMCEvent(AliVEvent* esd, AliAODEvent* aod, AliMCEvent* mc) ; 
+  
+  
+  ClassDef(AliCaloTrackAODReader,1)
+    } ;
 
 
 #endif //ALICALOTRACKAODREADER_H
index ad4791d19481e78c5796f838da739c8e5c0b7f84..0a2bd83662e0376e4826f55a7bc442f6f77237b9 100755 (executable)
 //---- ANALYSIS system ----
 #include "AliCaloTrackESDReader.h" 
 #include "AliESDEvent.h"
-#include "AliESDVertex.h"
 #include "AliESDCaloCluster.h"
 #include "AliAODCaloCluster.h"
 #include "AliAODTrack.h"
 #include "AliAODEvent.h"
-#include "AliMCEvent.h"
-#include "AliLog.h"
+#include "AliFidutialCut.h"
 
 ClassImp(AliCaloTrackESDReader)
 
@@ -53,9 +51,9 @@ AliCaloTrackReader()
 
 //____________________________________________________________________________
 AliCaloTrackESDReader::AliCaloTrackESDReader(const AliCaloTrackESDReader & g) :   
-AliCaloTrackReader(g)
+  AliCaloTrackReader(g)
 {
-       // cpy ctor
+  // cpy ctor
 }
 
 //_________________________________________________________________________
@@ -71,249 +69,263 @@ AliCaloTrackReader(g)
 
 //____________________________________________________________________________
 void AliCaloTrackESDReader::FillInputCTS() {
-       //Return array with CTS tracks
+  //Return array with CTS tracks
+  //TRefArray * fAODCTS = new TRefArray();
+  Int_t nTracks   = fInputEvent->GetNumberOfTracks() ;
+  Int_t naod = 0;
+  Double_t pos[3];
+  Double_t p[3];
+  Double_t covTr[21];
+  Double_t pid[10];
+  for (Int_t itrack =  0; itrack <  nTracks; itrack++) {////////////// track loop
+    AliESDtrack * track = (AliESDtrack*) ((AliESDEvent*)fInputEvent)->GetTrack(itrack) ; // retrieve track from esd
+    
+    //We want tracks fitted in the detectors:
+    ULong_t status=AliESDtrack::kTPCrefit;
+    status|=AliESDtrack::kITSrefit;
+    
+    if ( (track->GetStatus() & status) == status) {//Check if the bits we want are set
+      
+      track->GetPxPyPz(p) ;
+      TLorentzVector momentum(p[0],p[1],p[2],0);
+      
+      if(fCTSPtMin < momentum.Pt() &&fFidutialCut->IsInFidutialCut(momentum,"CTS")){
        
-       fAODCTS = new TClonesArray("AliAODTrack",0);
+       if(fDebug > 3 && momentum.Pt() > 0.2)printf("FillInputCTS():: Selected tracks E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f\n",
+                                                   momentum.E(),momentum.Pt(),momentum.Phi()*TMath::RadToDeg(),momentum.Eta());
        
-       Int_t nTracks   = fESD->GetNumberOfTracks() ;
-       Int_t naod = 0;
-       Double_t pos[3];
-       Double_t p[3];
-       Double_t covTr[21];
-       Double_t pid[10];
-       for (Int_t itrack =  0; itrack <  nTracks; itrack++) {////////////// track loop
-               AliESDtrack * track = fESD->GetTrack(itrack) ; // retrieve track from esd
-               
-               //We want tracks fitted in the detectors:
-               ULong_t status=AliESDtrack::kTPCrefit;
-               status|=AliESDtrack::kITSrefit;
-               
-               if ( (track->GetStatus() & status) == status) {//Check if the bits we want are set
-                       
-                       track->GetPxPyPz(p) ;
-                       TLorentzVector momentum(p[0],p[1],p[2],0);
-                       
-                       if(fCTSPtMin < momentum.Pt() &&fFidutialCut->IsInFidutialCut(momentum,"CTS")){
-                               
-                               if(fDebug > 3 && momentum.Pt() > 0.2)printf("FillInputCTS():: Selected tracks E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f\n",
-                                                                                                                       momentum.E(),momentum.Pt(),momentum.Phi()*TMath::RadToDeg(),momentum.Eta());
-                               
-                               track->GetXYZ(pos);
-                               track->GetCovarianceXYZPxPyPz(covTr);
-                               track->GetESDpid(pid);
-                               
-                               Float_t impactXY, impactZ;
-                               
-                               track->GetImpactParameters(impactXY,impactZ);
-                               
-                               if (impactXY<3) {
-                                       // track inside the beam pipe
-                                       
-                                       AliAODTrack *aodTrack = new((*fAODCTS)[naod++]) 
-                                       AliAODTrack(track->GetID(), track->GetLabel(), p, kTRUE, pos, kFALSE,covTr, (Short_t)track->GetSign(), track->GetITSClusterMap(), 
-                                                               pid,
-                                                               0x0,//primary,
-                                                               kTRUE, // check if this is right
-                                                               kTRUE, // check if this is right
-                                                               AliAODTrack::kPrimary, 
-                                                               0);
-                                       
-                                       aodTrack->SetFlags(track->GetStatus());
-                                       aodTrack->ConvertAliPIDtoAODPID();
-                               }
-                               else continue;   // outside the beam pipe: orphan track 
-                       }//Pt and Fidutial cut passed. 
-               }// track status
-       }// track loop
-       if(fDebug > 1) printf("FillInputCTS():: aod entries %d\n", fAODCTS->GetEntriesFast());
+       track->GetXYZ(pos);
+       track->GetCovarianceXYZPxPyPz(covTr);
+       track->GetESDpid(pid);
+       
+       Float_t impactXY, impactZ;
+       
+       track->GetImpactParameters(impactXY,impactZ);
+       
+       if (impactXY<3) {
+         // track inside the beam pipe
+         //Put new aod object in file in AOD tracks array
+         AliAODTrack *aodTrack = new((*(fOutputEvent->GetTracks()))[naod++]) 
+           AliAODTrack(track->GetID(), track->GetLabel(), p, kTRUE, pos, kFALSE,covTr, (Short_t)track->GetSign(), track->GetITSClusterMap(), 
+                       pid,
+                       0x0,//primary,
+                       kTRUE, // check if this is right
+                       kTRUE, // check if this is right
+                       AliAODTrack::kPrimary, 
+                       0);
+         
+         aodTrack->SetFlags(track->GetStatus());
+         aodTrack->ConvertAliPIDtoAODPID();
+         
+         fAODCTS->Add(aodTrack);                                       }
+       else continue;   // outside the beam pipe: orphan track 
+      }//Pt and Fidutial cut passed. 
+    }// track status
+  }// track loop
+  
+  //Put references to selected tracks in array
+  for(Int_t itrack = 0; itrack < (fOutputEvent->GetTracks())->GetEntriesFast(); itrack++){
+    AliAODTrack * track =  (AliAODTrack*) (fOutputEvent->GetTracks())->At(itrack);     
+    fAODCTS->Add(track);                               
+  }    
+  
+  if(fDebug > 1) printf("FillInputCTS():: aod entries %d\n", fAODCTS->GetEntriesFast());
 }
 
 //____________________________________________________________________________
 void AliCaloTrackESDReader::FillInputEMCAL() {
-       //Return array with EMCAL clusters in aod format
-       
-       fAODEMCAL = new TClonesArray("AliAODCaloCluster",0);
-       
-       TRefArray * caloClusters = new TRefArray();
-       fESD->GetEMCALClusters(caloClusters);
-       
-       //Get vertex for momentum calculation  
-       Double_t v[3] ; //vertex ;
-       GetVertex(v);
-       
-       //Loop to select clusters in fidutial cut and fill container with aodClusters
-       Int_t naod = 0;
-       Float_t pos[3] ;
-       //   Double_t * pid = new Double_t[AliPID::kSPECIESN];
-       
-       for (Int_t iclus =  0; iclus <  caloClusters->GetEntriesFast(); iclus++) {
-               AliESDCaloCluster * clus = (AliESDCaloCluster *) caloClusters->At(iclus) ;
-               TLorentzVector momentum ;
-               clus->GetMomentum(momentum, v);      
-               if(fDebug > 3 && momentum.E() > 0.1)printf("FillInputEMCAL():: all clusters E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f\n",
-                                                                                                  momentum.E(),momentum.Pt(),momentum.Phi()*TMath::RadToDeg(),momentum.Eta()); 
-               if(fEMCALPtMin < momentum.Pt() && fFidutialCut->IsInFidutialCut(momentum,"EMCAL")){
-                       
-                       if(fDebug > 2 && momentum.E() > 0.2)printf("FillInputEMCAL():: Selected clusters E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f\n",
-                                                                                                          momentum.E(),momentum.Pt(),momentum.Phi()*TMath::RadToDeg(),momentum.Eta());
-                       //       pid=clus->GetPid();      
-                       clus->GetPosition(pos) ;
-                       //       printf("Reader PID ESD: ph %0.2f, pi0 %0.2f, el %0.2f, conv el %0.2f,pi %0.2f, k %0.2f, p %0.2f, k0 %0.2f, n %0.2f, mu %0.2f \n",
-                       //           pid[AliPID::kPhoton],pid[AliPID::kPi0],
-                       //           pid[AliPID::kElectron],pid[AliPID::kEleCon],pid[AliPID::kPion],
-                       //           pid[AliPID::kKaon],pid[AliPID::kProton], pid[AliPID::kKaon0],
-                       //           pid[AliPID::kNeutron], pid[AliPID::kMuon]);
-                       Int_t id = clus->GetID();
-                       Int_t nLabel = clus->GetNLabels();
-                       Int_t *labels=0x0;
-                       if(clus->GetLabels()) labels =  (clus->GetLabels())->GetArray();
-                       
-                       Float_t energy = clus->E();
-                       Char_t ttype= AliAODCluster::kEMCALClusterv1;
-                       AliAODCaloCluster *caloCluster = new((*fAODEMCAL)[naod++]) 
-                       AliAODCaloCluster(id,nLabel,labels,energy, pos, NULL,ttype,0);
-                       
-                       caloCluster->SetPIDFromESD(clus->GetPid());
-                       caloCluster->SetCaloCluster(clus->GetDistanceToBadChannel(), clus->GetClusterDisp(), 
-                                                                               clus->GetM20(), clus->GetM02(),   
-                                                                               clus->GetEmcCpvDistance(),  clus->GetNExMax(), clus->GetTOF()) ;
-                                                                               
-                                                                                       
-                       if(fDebug > 3 && momentum.E() > 0.2)
-                               printf("FillInputEMCAL():: Selected clusters Distance BC %2.2f, dispersion %2.2f, M20 %f, M02 %3.2f, NexMax %d, TOF %e\n",
-                                               clus->GetDistanceToBadChannel(), clus->GetClusterDisp(),clus->GetM20(), clus->GetM02(),
-                                               clus->GetNExMax(), clus->GetTOF());
-                                                                               
-                       caloCluster->SetNCells(clus->GetNCells());
-                       caloCluster->SetCellsAbsId(clus->GetCellsAbsId());
-                       caloCluster->SetCellsAmplitudeFraction(clus->GetCellsAmplitudeFraction());
-                       
-                       TArrayI* matchedT =     clus->GetTracksMatched();
-                       if (matchedT && clus->GetTrackMatched() > 0) {  
-                               for (Int_t im = 0; im < matchedT->GetSize(); im++) {
-                                       caloCluster->AddTrackMatched((fESD->GetTrack(im)));
-                               }
-                       }
-                       
-               }//Pt and Fidutial cut passed.
-       }//esd cluster loop
-       
-       if(fDebug > 1) printf("FillInputEMCAL():: aod entries %d\n", fAODEMCAL->GetEntriesFast());
-       
+  //Return array with EMCAL clusters in aod format
+  
+  //Get vertex for momentum calculation  
+  Double_t v[3] ; //vertex ;
+  GetVertex(v);
+  
+  //Loop to select clusters in fidutial cut and fill container with aodClusters
+  Int_t naod = (fOutputEvent->GetCaloClusters())->GetEntriesFast();
+  Float_t pos[3] ;
+  //   Double_t * pid = new Double_t[AliPID::kSPECIESN];
+  for (Int_t iclus = 0; iclus < ((AliESDEvent*)fInputEvent)->GetNumberOfCaloClusters(); iclus++) {
+    AliESDCaloCluster * clus = 0;
+    if ( (clus = ((AliESDEvent*)fInputEvent)->GetCaloCluster(iclus)) ) {
+      if (clus->IsEMCAL()){
+       TLorentzVector momentum ;
+       clus->GetMomentum(momentum, v);      
+       if(fDebug > 3 && momentum.E() > 0.1)printf("FillInputEMCAL():: all clusters E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f\n",
+                                                  momentum.E(),momentum.Pt(),momentum.Phi()*TMath::RadToDeg(),momentum.Eta()); 
+       if(fEMCALPtMin < momentum.Pt() && fFidutialCut->IsInFidutialCut(momentum,"EMCAL")){
+         
+         if(fDebug > 2 && momentum.E() > 0.2)printf("FillInputEMCAL():: Selected clusters E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f\n",
+                                                    momentum.E(),momentum.Pt(),momentum.Phi()*TMath::RadToDeg(),momentum.Eta());
+         //       pid=clus->GetPid();      
+         clus->GetPosition(pos) ;
+         //       printf("Reader PID ESD: ph %0.2f, pi0 %0.2f, el %0.2f, conv el %0.2f,pi %0.2f, k %0.2f, p %0.2f, k0 %0.2f, n %0.2f, mu %0.2f \n",
+         //         pid[AliPID::kPhoton],pid[AliPID::kPi0],pid[AliPID::kElectron],pid[AliPID::kEleCon],pid[AliPID::kPion],
+         //         pid[AliPID::kKaon],pid[AliPID::kProton], pid[AliPID::kKaon0],pid[AliPID::kNeutron], pid[AliPID::kMuon]);
+         Int_t id = clus->GetID();
+         Int_t nLabel = clus->GetNLabels();
+         Int_t *labels=0x0;
+         if(clus->GetLabels()) labels =  (clus->GetLabels())->GetArray();
+         
+         Float_t energy = clus->E();
+         Char_t ttype= AliAODCluster::kEMCALClusterv1;
+         
+         //Put new aod object in file in AOD calo clusters array
+         AliAODCaloCluster *caloCluster = new((*(fOutputEvent->GetCaloClusters()))[naod++]) 
+           AliAODCaloCluster(id,nLabel,labels,energy, pos, NULL,ttype,0);
+         
+         caloCluster->SetPIDFromESD(clus->GetPid());
+         caloCluster->SetCaloCluster(clus->GetDistanceToBadChannel(), clus->GetClusterDisp(), 
+                                     clus->GetM20(), clus->GetM02(),   
+                                     clus->GetEmcCpvDistance(),  clus->GetNExMax(), clus->GetTOF()) ;
+         
+         
+         if(fDebug > 3 && momentum.E() > 0.2)
+           printf("FillInputEMCAL():: Selected clusters Distance BC %2.2f, dispersion %2.2f, M20 %f, M02 %3.2f, NexMax %d, TOF %e\n",
+                  clus->GetDistanceToBadChannel(), clus->GetClusterDisp(),clus->GetM20(), clus->GetM02(),
+                  clus->GetNExMax(), clus->GetTOF());
+         
+         caloCluster->SetNCells(clus->GetNCells());
+         caloCluster->SetCellsAbsId(clus->GetCellsAbsId());
+         caloCluster->SetCellsAmplitudeFraction(clus->GetCellsAmplitudeFraction());
+         
+         TArrayI* matchedT =   clus->GetTracksMatched();
+         if (matchedT && clus->GetTrackMatched() > 0) {        
+           for (Int_t im = 0; im < matchedT->GetSize(); im++) {
+             caloCluster->AddTrackMatched((fInputEvent->GetTrack(im)));
+           }
+         }
+         //Fill reference array
+       }//Pt and Fidutial cut passed.
+      }//EMCAL cluster
+    }//cluster exists
+  }//esd cluster loop
+  
+  //Put references to selected clusters in array
+  for(Int_t iclus = 0; iclus < (fOutputEvent->GetCaloClusters())->GetEntriesFast(); iclus++){
+    AliAODCaloCluster * clus =  (AliAODCaloCluster*) (fOutputEvent->GetCaloClusters())->At(iclus);     
+    fAODEMCAL->Add(clus);                              
+  }
+  if(fDebug > 1) printf("FillInputEMCAL():: aod entries %d\n", fAODEMCAL->GetEntriesFast());
+  
 }
 
 //____________________________________________________________________________
 void AliCaloTrackESDReader::FillInputPHOS() {
-       //Return array with PHOS clusters in aod format
-       fAODPHOS = new TClonesArray("AliAODCaloCluster",0);
-       
-       TRefArray * caloClusters = new TRefArray();
-       fESD->GetPHOSClusters(caloClusters);
-       
-       //Get vertex for momentum calculation  
-       Double_t v[3] ; //vertex ;
-       GetVertex(v);
-       
-       //Loop to select clusters in fidutial cut and fill container with aodClusters
-       Int_t naod = 0;
-       Float_t pos[3] ;
-       Double_t * pid = new Double_t[AliPID::kSPECIESN];
-       
-       for (Int_t iclus =  0; iclus <  caloClusters->GetEntriesFast(); iclus++) {
-               AliESDCaloCluster * clus = (AliESDCaloCluster *) caloClusters->At(iclus) ;
-               TLorentzVector momentum ;
-               clus->GetMomentum(momentum, v);      
-               if(fDebug > 3 && momentum.E() > 0.1)printf("FillInputPHOS():: all clusters E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f\n",
-                                                                                                  momentum.E(),momentum.Pt(),momentum.Phi()*TMath::RadToDeg(),momentum.Eta());
-               if(fPHOSPtMin < momentum.Pt() && fFidutialCut->IsInFidutialCut(momentum,"PHOS")){
-                       
-                       if(fDebug > 2 && momentum.E() > 0.1)printf("FillInputPHOS():: Selected clusters E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f\n",
-                                                                                                          momentum.E(),momentum.Pt(),momentum.Phi()*TMath::RadToDeg(),momentum.Eta());
-                       
-                       pid=clus->GetPid();      
-                       // printf("Reader PID ESD: ph %0.2f, pi0 %0.2f, el %0.2f, conv el %0.2f,pi %0.2f, k %0.2f, p %0.2f, k0 %0.2f, n %0.2f, mu %0.2f \n",
-                       //       pid[AliPID::kPhoton],pid[AliPID::kPi0],
-                       //       pid[AliPID::kElectron],pid[AliPID::kEleCon],pid[AliPID::kPion],
-                       //       pid[AliPID::kKaon],pid[AliPID::kProton], pid[AliPID::kKaon0],
-                       //       pid[AliPID::kNeutron], pid[AliPID::kMuon]);
-                       
-                       clus->GetPosition(pos) ;
-                       Int_t id = clus->GetID();
-                       Int_t nLabel = clus->GetNLabels();
-                       Int_t *labels=0x0;
-                       if(clus->GetLabels()) labels =  (clus->GetLabels())->GetArray();
-                       Float_t energy = clus->E();
-                       
-                       //Phos cluster type
-                       Char_t ttype= AliAODCluster::kPHOSNeutral;
-                       Float_t wNeutral = pid[AliPID::kNeutron]+ pid[AliPID::kKaon0]+pid[AliPID::kPhoton]+pid[AliPID::kPi0];
-                       Float_t wCharged = pid[AliPID::kMuon] + pid[AliPID::kElectron] + pid[AliPID::kEleCon]+ 
-                       pid[AliPID::kProton]+pid[AliPID::kKaon]+pid[AliPID::kPion];
-                       if( wCharged > wNeutral)  ttype= AliAODCluster::kPHOSCharged;
-                       
-                       AliAODCaloCluster *caloCluster = new((*fAODPHOS)[naod++]) 
-                       AliAODCaloCluster(id,nLabel,labels,energy, pos, NULL, ttype, 0);
-                       caloCluster->SetPIDFromESD(clus->GetPid());   
-                       caloCluster->SetCaloCluster(clus->GetDistanceToBadChannel(), clus->GetClusterDisp(), 
-                                                                               clus->GetM20(), clus->GetM02(),  
-                                                                               clus->GetEmcCpvDistance(),  clus->GetNExMax()) ;
-                                                                               
-                       if(fDebug > 3 && momentum.E() > 0.2)
-                               printf("FillInputPHOS():: Selected clusters Distance BC %2.2f, dispersion %2.2f, M20 %f, M02 %3.2f, EmcCpvDist %3.3f, NexMax %d, TOF %e\n",
-                                               clus->GetDistanceToBadChannel(), clus->GetClusterDisp(),clus->GetM20(), clus->GetM02(),
-                                               clus->GetEmcCpvDistance(),  clus->GetNExMax(), clus->GetTOF());
-
-                       caloCluster->SetNCells(clus->GetNCells());
-                       caloCluster->SetCellsAbsId(clus->GetCellsAbsId());
-                       caloCluster->SetCellsAmplitudeFraction(clus->GetCellsAmplitudeFraction());
-                       TArrayI* matchedT =     clus->GetTracksMatched();
-                       if (matchedT) { 
-                               for (Int_t im = 0; im < matchedT->GetSize(); im++) {
-                                       caloCluster->AddTrackMatched((fESD->GetTrack(im)));
-                               }
-                       }
-                       
-               }//Pt and Fidutial cut passed.
-       }//esd cluster loop
-       if(fDebug > 1) printf("FillInputPHOS():: aod entries %d\n", fAODPHOS->GetEntriesFast());
-       
-       
+  //Return array with PHOS clusters in aod format
+  
+  //Get vertex for momentum calculation  
+  Double_t v[3] ; //vertex ;
+  GetVertex(v);
+  
+  //Loop to select clusters in fidutial cut and fill container with aodClusters
+  Int_t naod = (fOutputEvent->GetCaloClusters())->GetEntriesFast();
+  Float_t pos[3] ;
+  Double_t * pid = new Double_t[AliPID::kSPECIESN];
+  
+  for (Int_t iclus = 0; iclus < ((AliESDEvent*)fInputEvent)->GetNumberOfCaloClusters(); iclus++) {
+    AliESDCaloCluster * clus = 0;
+    if ( (clus = ((AliESDEvent*)fInputEvent)->GetCaloCluster(iclus)) ) {
+      if (clus->IsPHOS()){
+       TLorentzVector momentum ;
+       clus->GetMomentum(momentum, v);      
+       if(fDebug > 3 && momentum.E() > 0.1)printf("FillInputPHOS():: all clusters E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f\n",
+                                                  momentum.E(),momentum.Pt(),momentum.Phi()*TMath::RadToDeg(),momentum.Eta());
+       if(fPHOSPtMin < momentum.Pt() && fFidutialCut->IsInFidutialCut(momentum,"PHOS")){
+         
+         if(fDebug > 2 && momentum.E() > 0.1)printf("FillInputPHOS():: Selected clusters E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f\n",
+                                                    momentum.E(),momentum.Pt(),momentum.Phi()*TMath::RadToDeg(),momentum.Eta());
+         
+         pid=clus->GetPid();      
+         // printf("Reader PID ESD: ph %0.2f, pi0 %0.2f, el %0.2f, conv el %0.2f,pi %0.2f, k %0.2f, p %0.2f, k0 %0.2f, n %0.2f, mu %0.2f \n",
+         //     pid[AliPID::kPhoton],pid[AliPID::kPi0],pid[AliPID::kElectron],pid[AliPID::kEleCon],pid[AliPID::kPion],
+         //     pid[AliPID::kKaon],pid[AliPID::kProton], pid[AliPID::kKaon0],pid[AliPID::kNeutron], pid[AliPID::kMuon]);
+         
+         clus->GetPosition(pos) ;
+         Int_t id = clus->GetID();
+         Int_t nLabel = clus->GetNLabels();
+         Int_t *labels=0x0;
+         if(clus->GetLabels()) labels =  (clus->GetLabels())->GetArray();
+         Float_t energy = clus->E();
+         
+         //Phos cluster type
+         Char_t ttype= AliAODCluster::kPHOSNeutral;
+         Float_t wNeutral = pid[AliPID::kNeutron]+ pid[AliPID::kKaon0]+pid[AliPID::kPhoton]+pid[AliPID::kPi0];
+         Float_t wCharged = pid[AliPID::kMuon] + pid[AliPID::kElectron] + pid[AliPID::kEleCon]+ 
+           pid[AliPID::kProton]+pid[AliPID::kKaon]+pid[AliPID::kPion];
+         if( wCharged > wNeutral)  ttype= AliAODCluster::kPHOSCharged;
+         
+         //Put new aod object in file in AOD calo clusters array
+         AliAODCaloCluster *caloCluster = new((*(fOutputEvent->GetCaloClusters()))[naod++]) 
+           AliAODCaloCluster(id,nLabel,labels,energy, pos, NULL, ttype, 0);
+         caloCluster->SetPIDFromESD(clus->GetPid());   
+         caloCluster->SetCaloCluster(clus->GetDistanceToBadChannel(), clus->GetClusterDisp(), 
+                                     clus->GetM20(), clus->GetM02(),  
+                                     clus->GetEmcCpvDistance(),  clus->GetNExMax()) ;
+         
+         if(fDebug > 3 && momentum.E() > 0.2)
+           printf("FillInputPHOS():: Selected clusters Distance BC %2.2f, dispersion %2.2f, M20 %f, M02 %3.2f, EmcCpvDist %3.3f, NexMax %d, TOF %e\n",
+                  clus->GetDistanceToBadChannel(), clus->GetClusterDisp(),clus->GetM20(), clus->GetM02(),
+                  clus->GetEmcCpvDistance(),  clus->GetNExMax(), clus->GetTOF());
+         
+         caloCluster->SetNCells(clus->GetNCells());
+         caloCluster->SetCellsAbsId(clus->GetCellsAbsId());
+         caloCluster->SetCellsAmplitudeFraction(clus->GetCellsAmplitudeFraction());
+         TArrayI* matchedT =   clus->GetTracksMatched();
+         if (matchedT) {       
+           for (Int_t im = 0; im < matchedT->GetSize(); im++) {
+             caloCluster->AddTrackMatched((fInputEvent->GetTrack(im)));
+           }
+         }
+       }//Pt and Fidutial cut passed.
+      }//PHOS cluster
+    }//cluster exists
+  }//esd cluster loop
+  
+  //Put references to selected clusters in array
+  for(Int_t iclus = 0; iclus < (fOutputEvent->GetCaloClusters())->GetEntriesFast(); iclus++){
+    AliAODCaloCluster * clus =  (AliAODCaloCluster*) (fOutputEvent->GetCaloClusters())->At(iclus);     
+    fAODPHOS->Add(clus);                               
+  }    
+  if(fDebug > 1) printf("FillInputPHOS():: aod entries %d\n", fAODPHOS->GetEntriesFast());
+  
 }
 
 //____________________________________________________________________________
 void AliCaloTrackESDReader::FillInputEMCALCells() {
-       //Return array with EMCAL cells in esd format
-       
-       fEMCALCells = (TNamed*) fESD->GetEMCALCells(); 
-       
+  //Return array with EMCAL cells in esd format
+  
+  fEMCALCells = (TNamed*) ((AliESDEvent*)fInputEvent)->GetEMCALCells(); 
+  
 }
 
 //____________________________________________________________________________
 void AliCaloTrackESDReader::FillInputPHOSCells() {
-       //Return array with PHOS cells in esd format
-       
-       fPHOSCells = (TNamed*) fESD->GetPHOSCells(); 
-       
+  //Return array with PHOS cells in esd format
+  
+  fPHOSCells = (TNamed*) ((AliESDEvent*)fInputEvent)->GetPHOSCells(); 
+  
 }
 
 //____________________________________________________________________________
 void AliCaloTrackESDReader::GetVertex(Double_t  v[3]) const {
-       //Return vertex position
-       
-       fESD->GetVertex()->GetXYZ(v) ;
-       
+  //Return vertex position
+  
+  ((AliESDEvent*)fInputEvent)->GetVertex()->GetXYZ(v) ;
+  
 }
 
 
 //____________________________________________________________________________
-void AliCaloTrackESDReader::SetInputEvent(TObject* esd, TObject* aod, TObject* mc) {
-       // Connect the data pointers
-       
-       if(strcmp(esd->GetName(),"AliESDEvent"))
-               AliFatal(Form("Wrong reader, here only ESDs. Input name: %s != AliESDEvent \n",esd->GetName()));
-       
-       SetESD((AliESDEvent*) esd);
-       SetAOD ((AliAODEvent*) aod);
-       SetMC((AliMCEvent*) mc);
-       
+void AliCaloTrackESDReader::SetInputOutputMCEvent(AliVEvent* esd, AliAODEvent* aod, AliMCEvent* mc) {
+  // Connect the data pointers
+  
+  if(strcmp(esd->GetName(),"AliESDEvent")){
+    printf("ABORT::Wrong reader, here only ESDs. Input name: %s != AliESDEvent \n",esd->GetName());
+    abort();
+  }
+  
+  SetInputEvent(esd);
+  SetOutputEvent(aod);
+  SetMC(mc);
+  
 }
index 6c7135f10b3383292811f52f7dff7a7c011b9fba..193c64cef60325ab52000909cf02582fa482c2cb 100755 (executable)
 #include "AliCaloTrackReader.h" 
 
 class AliCaloTrackESDReader : public AliCaloTrackReader {
-       
-public: 
-       
-       AliCaloTrackESDReader() ; // ctor
-       AliCaloTrackESDReader(const AliCaloTrackESDReader & g) ; // cpy ctor
-       //AliCaloTrackESDReader & operator = (const AliCaloTrackESDReader & g) ;//cpy assignment
-       virtual ~AliCaloTrackESDReader() {;} //virtual dtor
-       
-       void FillInputCTS  () ;
-       void FillInputEMCAL() ;
-       void FillInputPHOS () ;  
-       void FillInputEMCALCells() ;
-       void FillInputPHOSCells() ;
-       
-       void GetVertex(Double_t v[3]) const ;
-       
-       AliVEvent*  GetInputEvent() const {return GetESD();}
-       void SetInputEvent(TObject* esd, TObject* aod, TObject* mc) ; 
-       
-       ClassDef(AliCaloTrackESDReader,1)
-} ;
+  
+  public: 
+  
+  AliCaloTrackESDReader() ; // ctor
+  AliCaloTrackESDReader(const AliCaloTrackESDReader & g) ; // cpy ctor
+  //AliCaloTrackESDReader & operator = (const AliCaloTrackESDReader & g) ;//cpy assignment
+  virtual ~AliCaloTrackESDReader() {;} //virtual dtor
+  
+  void FillInputCTS  () ;
+  void FillInputEMCAL() ;
+  void FillInputPHOS () ;  
+  void FillInputEMCALCells() ;
+  void FillInputPHOSCells() ;
+  
+  void GetVertex(Double_t v[3]) const ;
+  void SetInputOutputMCEvent(AliVEvent* esd, AliAODEvent* aod, AliMCEvent* mc) ; 
+  
+  ClassDef(AliCaloTrackESDReader,1)
+    } ;
 
 
 #endif //ALICALOTRACKESDREADER_H
index b7c5fa45231fa9c4e835e3c64dce8780c03bf890..e24e0117e00c06dc642b0503797ec8572ec94545 100755 (executable)
@@ -9,7 +9,7 @@
  * without fee, provided that the above copyright notice appears in all   *
  * copies and that both the copyright notice and this permission notice   *
  * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is         *
+ * about the suitability of this software for any purpose. It is          *
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 /* $Id:  $ */
 
 #include <TParticle.h>
 #include <TRandom.h>
-#include <TClonesArray.h>
+#include <TArrayI.h>
 //#include "Riostream.h"
 
 //---- ANALYSIS system ----
 #include "AliCaloTrackMCReader.h" 
-#include "AliLog.h"
 #include "AliGenEventHeader.h"
 #include "AliStack.h"
 #include "AliAODCaloCluster.h"
 #include "AliAODTrack.h"
+#include "AliFidutialCut.h"
+#include "AliAODEvent.h"
+#include "TParticle.h"
 
-ClassImp(AliCaloTrackMCReader)
+  ClassImp(AliCaloTrackMCReader)
 
 //____________________________________________________________________________
 AliCaloTrackMCReader::AliCaloTrackMCReader() : 
   AliCaloTrackReader(), fDecayPi0(0), 
-  fNeutralParticlesArray(0x0),    fChargedParticlesArray(0x0), 
-  fStatusArray(0x0), fKeepAllStatus(0), fClonesArrayType(0), 
-  fCheckOverlap(0),  fEMCALOverlapAngle(0),fPHOSOverlapAngle(0),
-  fIndex2ndPhoton(0)
+  fNeutralParticlesArray(0x0), fChargedParticlesArray(0x0), 
+  fStatusArray(0x0), fKeepAllStatus(0), fCheckOverlap(0),  
+  fEMCALOverlapAngle(0),fPHOSOverlapAngle(0), fIndex2ndPhoton(0)
 {
   //Ctor
   
@@ -61,8 +62,7 @@ AliCaloTrackMCReader::AliCaloTrackMCReader(const AliCaloTrackMCReader & g) :
   fNeutralParticlesArray(g.fNeutralParticlesArray?new TArrayI(*g.fNeutralParticlesArray):0x0),
   fChargedParticlesArray(g.fChargedParticlesArray?new TArrayI(*g.fChargedParticlesArray):0x0),
   fStatusArray(g.fStatusArray?new TArrayI(*g.fStatusArray):0x0),
-  fKeepAllStatus(g.fKeepAllStatus), fClonesArrayType(g.fClonesArrayType),
-  fCheckOverlap(g.fCheckOverlap),
+  fKeepAllStatus(g.fKeepAllStatus), fCheckOverlap(g.fCheckOverlap),
   fEMCALOverlapAngle( g.fEMCALOverlapAngle), fPHOSOverlapAngle(g.fPHOSOverlapAngle),
   fIndex2ndPhoton(g.fIndex2ndPhoton)
 {
@@ -88,7 +88,6 @@ AliCaloTrackMCReader & AliCaloTrackMCReader::operator = (const AliCaloTrackMCRea
   fStatusArray = source.fStatusArray?new TArrayI(*source.fStatusArray):0x0;
  
   fKeepAllStatus = source.fKeepAllStatus ;
-  fClonesArrayType = source.fClonesArrayType ;
 
   return *this;
 
@@ -135,7 +134,6 @@ void AliCaloTrackMCReader::InitParameters()
   fStatusArray->SetAt(1,0); 
  
   fKeepAllStatus = kTRUE;
-  fClonesArrayType = kAliAOD ;
 
   fCheckOverlap = kFALSE;
   fEMCALOverlapAngle = 2.5 * TMath::DegToRad();
@@ -186,159 +184,139 @@ void  AliCaloTrackMCReader::CheckOverlap(const Float_t anglethres, const Int_t i
 
 //____________________________________________________________________________
 void  AliCaloTrackMCReader::FillCalorimeters(Int_t & iParticle, TParticle* particle, TLorentzVector momentum,
-                                            Int_t &indexPHOS, Int_t &indexEMCAL) {
-       //Fill AODCaloClusters or TParticles lists of PHOS or EMCAL
-       //In PHOS
-       if(fFillPHOS && fFidutialCut->IsInFidutialCut(momentum,"PHOS") && momentum.Pt() > fPHOSPtMin){
-               
-               if(fClonesArrayType == kTParticle) new((*fAODPHOS)[indexPHOS++])       TParticle(*particle) ;
-               else{
-                       Int_t index = iParticle ;
-                       Int_t pdg = TMath::Abs(particle->GetPdgCode());
-                       if(fCheckOverlap) 
-                         CheckOverlap(fPHOSOverlapAngle,particle->GetFirstMother(),index, iParticle, momentum, pdg);
-
-                       Char_t ttype= AliAODCluster::kPHOSNeutral;      
-                       Int_t labels[] = {index};
-                       Float_t x[] = {momentum.X(), momentum.Y(), momentum.Z()};
-                       AliAODCaloCluster *calo = new((*fAODPHOS)[indexPHOS++]) 
-                         AliAODCaloCluster(index,1,labels,momentum.E(), x, NULL, ttype, 0);
-               
-                       SetCaloClusterPID(pdg,calo) ;
-                       if(fDebug > 3 && momentum.Pt() > 0.2)
-                                       printf("Fill MC PHOS :: Selected tracks %s E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f\n",
-                                                       particle->GetName(),momentum.E(),momentum.Pt(),momentum.Phi()*TMath::RadToDeg(),momentum.Eta());                        
-               }
-       }
-       //In EMCAL
-       else if(fFillEMCAL && fFidutialCut->IsInFidutialCut(momentum,"EMCAL") && momentum.Pt() > fEMCALPtMin){
-               if(fClonesArrayType == kTParticle) new((*fAODEMCAL)[indexEMCAL++])       TParticle(*particle) ;
-               else{
-                                       Int_t index = iParticle ;
-                       Int_t pdg = TMath::Abs(particle->GetPdgCode());
-                       //Int_t pdgorg=pdg;
-                       if(fCheckOverlap) 
-                         CheckOverlap(fEMCALOverlapAngle,particle->GetFirstMother(),iParticle, index, momentum, pdg);
-
-                       Char_t ttype= AliAODCluster::kEMCALClusterv1;
-                       Int_t labels[] = {index};
-                       Float_t x[] = {momentum.X(), momentum.Y(), momentum.Z()};
-                       AliAODCaloCluster *calo = new((*fAODEMCAL)[indexEMCAL++]) 
-                       AliAODCaloCluster(iParticle,1,labels,momentum.E(), x, NULL, ttype, 0);
-                    
-                       SetCaloClusterPID(pdg,calo) ;
-                       if(fDebug > 3 && momentum.Pt() > 0.2)
-                                       printf("Fill MC EMCAL :: Selected tracks %s E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f\n",
-                                                       particle->GetName(),momentum.E(),momentum.Pt(),momentum.Phi()*TMath::RadToDeg(),momentum.Eta());        
-               }
-       }
+                                            Int_t &ncalo) {
+  //Fill AODCaloClusters or TParticles lists of PHOS or EMCAL
+  //In PHOS
+  if(fFillPHOS && fFidutialCut->IsInFidutialCut(momentum,"PHOS") && momentum.Pt() > fPHOSPtMin){
+    Int_t index = iParticle ;
+    Int_t pdg = TMath::Abs(particle->GetPdgCode());
+    if(fCheckOverlap) 
+      CheckOverlap(fPHOSOverlapAngle,particle->GetFirstMother(),index, iParticle, momentum, pdg);
+    
+    Char_t ttype= AliAODCluster::kPHOSNeutral; 
+    Int_t labels[] = {index};
+    Float_t x[] = {momentum.X(), momentum.Y(), momentum.Z()};
+    //Create object and write it to file
+    AliAODCaloCluster *calo = new((*(fOutputEvent->GetCaloClusters()))[ncalo++]) 
+      AliAODCaloCluster(index,1,labels,momentum.E(), x, NULL, ttype, 0);
+    
+    SetCaloClusterPID(pdg,calo) ;
+    if(fDebug > 3 && momentum.Pt() > 0.2)
+      printf("Fill MC PHOS :: Selected tracks %s E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f\n",
+            particle->GetName(),momentum.E(),momentum.Pt(),momentum.Phi()*TMath::RadToDeg(),momentum.Eta());                   
+    fAODPHOS->Add(calo);//reference the selected object to the list
+  }
+  //In EMCAL
+  else if(fFillEMCAL && fFidutialCut->IsInFidutialCut(momentum,"EMCAL") && momentum.Pt() > fEMCALPtMin){
+    Int_t index = iParticle ;
+    Int_t pdg = TMath::Abs(particle->GetPdgCode());
+    //Int_t pdgorg=pdg;
+    if(fCheckOverlap) 
+      CheckOverlap(fEMCALOverlapAngle,particle->GetFirstMother(),iParticle, index, momentum, pdg);
+    
+    Char_t ttype= AliAODCluster::kEMCALClusterv1;
+    Int_t labels[] = {index};
+    Float_t x[] = {momentum.X(), momentum.Y(), momentum.Z()};
+    //Create object and write it to file
+    AliAODCaloCluster *calo = new((*(fOutputEvent->GetCaloClusters()))[ncalo++]) 
+      AliAODCaloCluster(iParticle,1,labels,momentum.E(), x, NULL, ttype, 0);
+    
+    SetCaloClusterPID(pdg,calo) ;
+    if(fDebug > 3 && momentum.Pt() > 0.2)
+      printf("Fill MC EMCAL :: Selected tracks %s E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f\n",
+            particle->GetName(),momentum.E(),momentum.Pt(),momentum.Phi()*TMath::RadToDeg(),momentum.Eta());   
+    fAODEMCAL->Add(calo);//reference the selected object to the list
+  }
 }
 
 //____________________________________________________________________________
 void AliCaloTrackMCReader::FillInputEvent(Int_t iEntry){
-       //Fill the event counter and input lists that are needed, called by the analysis maker.
+  //Fill the event counter and input lists that are needed, called by the analysis maker.
+  
+  fEventNumber = iEntry;
+  Int_t iParticle = 0 ;
+  Double_t charge = 0.;
+  Int_t ncalo  = (fOutputEvent->GetCaloClusters())->GetEntriesFast();
+  Int_t ntrack = (fOutputEvent->GetTracks())->GetEntriesFast();
        
-       fEventNumber = iEntry;
+  for (iParticle = 0 ; iParticle <  GetStack()->GetNtrack() ; iParticle++) {
+    TParticle * particle = GetStack()->Particle(iParticle);
+    TLorentzVector momentum;
+    Float_t p[3];
+    Float_t x[3];
+    Int_t pdg = particle->GetPdgCode();                                                
+    
+    //Keep particles with a given status 
+    if(KeepParticleWithStatus(particle->GetStatusCode()) && (particle->Pt() > 0) ){
+      
+      //Skip bizarre particles, they crash when charge is calculated
+      //       if(TMath::Abs(pdg) == 3124 || TMath::Abs(pdg) > 10000000) continue ;
+      
+      charge = TDatabasePDG::Instance()->GetParticle(pdg)->Charge();
+      particle->Momentum(momentum);
+      //---------- Charged particles ----------------------
+      if((charge != 0) && (momentum.Pt() > fCTSPtMin) && (fFidutialCut->IsInFidutialCut(momentum,"CTS"))){
+       if(fFillCTS){
+         //Particles in CTS acceptance
+         if(fDebug > 3 && momentum.Pt() > 0.2)
+           printf("Fill MC CTS :: Selected tracks E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f\n",
+                  momentum.E(),momentum.Pt(),momentum.Phi()*TMath::RadToDeg(),momentum.Eta());
+         
+         x[0] = particle->Vx(); x[1] = particle->Vy(); x[2] = particle->Vz();
+         p[0] = particle->Px(); p[1] = particle->Py(); p[2] = particle->Pz();
+         //Create object and write it to file
+         AliAODTrack *aodTrack = new((*(fOutputEvent->GetTracks()))[ntrack++]) 
+           AliAODTrack(0, iParticle, p, kTRUE, x, kFALSE,NULL, 0, 0, 
+                       NULL,
+                       0x0,//primary,
+                       kFALSE, // No fit performed
+                       kFALSE, // No fit performed
+                       AliAODTrack::kPrimary, 
+                       0);
+         SetTrackChargeAndPID(pdg, aodTrack);
+         fAODCTS->Add(aodTrack);//reference the selected object to the list
+       }
+       //Keep some charged particles in calorimeters lists
+       if((fFillPHOS || fFillEMCAL) && KeepChargedParticles(pdg)) FillCalorimeters(iParticle, particle, momentum, ncalo);
        
-       if(fClonesArrayType == kTParticle){
-               fAODCTS = new TClonesArray("TParticle",0);
-               fAODEMCAL = new TClonesArray("TParticle",0);
-               fAODPHOS = new TClonesArray("TParticle",0);
+      }//Charged
+      
+      //-------------Neutral particles ----------------------
+      else if(charge == 0 && (fFillPHOS || fFillEMCAL)){
+       //Skip neutrinos or other neutral particles
+       //if(SkipNeutralParticles(pdg) || particle->IsPrimary()) continue ; // protection added (MG)
+       if(SkipNeutralParticles(pdg)) continue ;
+       //Fill particle/calocluster arrays
+       if(!fDecayPi0) {
+         FillCalorimeters(iParticle, particle, momentum, ncalo);
        }
-       else if(fClonesArrayType == kAliAOD){
-               fAODCTS = new TClonesArray("AliAODTrack",0);
-               fAODPHOS = new TClonesArray("AliAODCaloCluster",0);
-               fAODEMCAL = new TClonesArray("AliAODCaloCluster",0);
+       else {
+         //Sometimes pi0 are stable for the generator, if needed decay it by hand
+         if(pdg == 111 ){
+           if(momentum.Pt() >  fPHOSPtMin || momentum.Pt() >  fEMCALPtMin){
+             TLorentzVector lvGamma1, lvGamma2 ;
+             //Double_t angle = 0;
+             
+             //Decay
+             MakePi0Decay(momentum,lvGamma1,lvGamma2);//,angle);
+             
+             //Check if Pi0 is in the acceptance of the calorimeters, if aperture angle is small, keep it
+             TParticle * pPhoton1 = new TParticle(22,1,iParticle,0,0,0,lvGamma1.Px(),lvGamma1.Py(),
+                                                  lvGamma1.Pz(),lvGamma1.E(),0,0,0,0);   
+             TParticle * pPhoton2 = new TParticle(22,1,iParticle,0,0,0,lvGamma2.Px(),lvGamma2.Py(),
+                                                  lvGamma2.Pz(),lvGamma2.E(),0,0,0,0);
+             //Fill particle/calocluster arrays
+             FillCalorimeters(iParticle,pPhoton1,lvGamma1, ncalo);
+             FillCalorimeters(iParticle,pPhoton2,lvGamma2, ncalo);
+           }//pt cut
+         }//pi0
+         else FillCalorimeters(iParticle,particle, momentum, ncalo); //Add the rest
        }
-       else {AliFatal("Wrong clones type");}
-       
-       
-       Int_t indexCh    = 0 ;
-       Int_t indexEMCAL = 0 ;
-       Int_t indexPHOS  = 0 ;
-       
-       Int_t iParticle = 0 ;
-       Double_t charge = 0.;
-
-       for (iParticle = 0 ; iParticle <  GetStack()->GetNtrack() ; iParticle++) {
-               TParticle * particle = GetStack()->Particle(iParticle);
-               TLorentzVector momentum;
-               Float_t p[3];
-               Float_t x[3];
-               Int_t pdg = particle->GetPdgCode();                                             
-
-               //Keep particles with a given status 
-               if(KeepParticleWithStatus(particle->GetStatusCode()) && (particle->Pt() > 0) ){
-               
-                   //Skip bizarre particles, they crash when charge is calculated
-                 //    if(TMath::Abs(pdg) == 3124 || TMath::Abs(pdg) > 10000000) continue ;
-                       
-                       charge = TDatabasePDG::Instance()->GetParticle(pdg)->Charge();
-                       particle->Momentum(momentum);
-                       //---------- Charged particles ----------------------
-                       if((charge != 0) && (momentum.Pt() > fCTSPtMin) && (fFidutialCut->IsInFidutialCut(momentum,"CTS"))){
-                               if(fFillCTS){
-                                       //Particles in CTS acceptance
-                                       if(fDebug > 3 && momentum.Pt() > 0.2)
-                                               printf("Fill MC CTS :: Selected tracks E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f\n",
-                                                               momentum.E(),momentum.Pt(),momentum.Phi()*TMath::RadToDeg(),momentum.Eta());
-                                       
-                                       if(fClonesArrayType == kTParticle) new((*fAODCTS)[indexCh++])       TParticle(*particle) ;
-                                       else{
-                                               x[0] = particle->Vx(); x[1] = particle->Vy(); x[2] = particle->Vz();
-                                               p[0] = particle->Px(); p[1] = particle->Py(); p[2] = particle->Pz();
-                                               AliAODTrack *aodTrack = new((*fAODCTS)[indexCh++]) 
-                                               AliAODTrack(0, iParticle, p, kTRUE, x, kFALSE,NULL, 0, 0, 
-                                                                       NULL,
-                                                                       0x0,//primary,
-                                                                       kFALSE, // No fit performed
-                                                                       kFALSE, // No fit performed
-                                                                       AliAODTrack::kPrimary, 
-                                                                       0);
-                                               SetTrackChargeAndPID(pdg, aodTrack);
-                                       }
-                               }
-                               //Keep some charged particles in calorimeters lists
-                               if((fFillPHOS || fFillEMCAL) && KeepChargedParticles(pdg)) FillCalorimeters(iParticle, particle, momentum, indexPHOS, indexEMCAL);
-                               
-                       }//Charged
-                       
-                       //-------------Neutral particles ----------------------
-                       else if(charge == 0 && (fFillPHOS || fFillEMCAL)){
-                               //Skip neutrinos or other neutral particles
-                               //if(SkipNeutralParticles(pdg) || particle->IsPrimary()) continue ; // protection added (MG)
-                               if(SkipNeutralParticles(pdg)) continue ;
-                               //Fill particle/calocluster arrays
-                               if(!fDecayPi0) {
-                                       FillCalorimeters(iParticle, particle, momentum, indexPHOS, indexEMCAL);
-                               }
-                               else {
-                                       //Sometimes pi0 are stable for the generator, if needed decay it by hand
-                                       if(pdg == 111 ){
-                                               if(momentum.Pt() >  fPHOSPtMin || momentum.Pt() >  fEMCALPtMin){
-                                                       TLorentzVector lvGamma1, lvGamma2 ;
-                                                       //Double_t angle = 0;
-                                                       
-                                                       //Decay
-                                                       MakePi0Decay(momentum,lvGamma1,lvGamma2);//,angle);
-                                                       
-                                                       //Check if Pi0 is in the acceptance of the calorimeters, if aperture angle is small, keep it
-                                                       TParticle * pPhoton1 = new TParticle(22,1,iParticle,0,0,0,lvGamma1.Px(),lvGamma1.Py(),
-                                                                                                                                lvGamma1.Pz(),lvGamma1.E(),0,0,0,0);   
-                                                       TParticle * pPhoton2 = new TParticle(22,1,iParticle,0,0,0,lvGamma2.Px(),lvGamma2.Py(),
-                                                                                                                                lvGamma2.Pz(),lvGamma2.E(),0,0,0,0);
-                                                       //Fill particle/calocluster arrays
-                                                       FillCalorimeters(iParticle,pPhoton1,lvGamma1, indexPHOS, indexEMCAL);
-                                                       FillCalorimeters(iParticle,pPhoton2,lvGamma2, indexPHOS, indexEMCAL);
-                                               }//pt cut
-                                       }//pi0
-                                       else FillCalorimeters(iParticle,particle, momentum, indexPHOS, indexEMCAL); //Add the rest
-                               }
-                       }//neutral particles
-               } //particle with correct status
-       }//particle loop
-
-       fIndex2ndPhoton = -1; //In case of overlapping studies, reset for each event    
+      }//neutral particles
+    } //particle with correct status
+  }//particle loop
+  
+  fIndex2ndPhoton = -1; //In case of overlapping studies, reset for each event 
 }
 
 //________________________________________________________________
@@ -378,7 +356,6 @@ void AliCaloTrackMCReader::Print(const Option_t * opt) const
   Info("**** Print **** ", "%s %s", GetName(), GetTitle() ) ;
   
   printf("Decay Pi0?          : %d\n", fDecayPi0) ;
-  printf("TClonesArray type   : %d\n", fClonesArrayType) ;
   printf("Check Overlap in Calo?    : %d\n", fCheckOverlap) ;
   printf("Keep all status?    : %d\n", fKeepAllStatus) ;
   
@@ -441,10 +418,10 @@ void AliCaloTrackMCReader::MakePi0Decay(TLorentzVector &p0, TLorentzVector &p1,
 }
 
 //____________________________________________________________________________
-void AliCaloTrackMCReader::SetInputEvent(TObject* /*esd*/, TObject* aod, TObject* mc) {
+void AliCaloTrackMCReader::SetInputOutputMCEvent(AliVEvent* /*esd*/, AliAODEvent* aod, AliMCEvent* mc) {
   // Connect the data pointer
-  SetMC((AliMCEvent*) mc);
-  SetAOD((AliAODEvent*) aod);
+  SetMC(mc);
+  SetOutputEvent(aod);
 }
 
 
index 6e76e6b60a32552abe92978696028be1f17330bd..d0bca55bed58f18a34391ed8170e1426725a23b7 100755 (executable)
 //-- Author: Gustavo Conesa (INFN-LNF)
 
 // --- ROOT system ---
+class TArrayI   ;
+class TParticle ;
 
 // --- AliRoot system ---
 #include "AliCaloTrackReader.h" 
 class AliAODCaloCluster ;
 class AliAODTrack ;
+class AliAODEvent ;
+class AliMCEvent  ;
+class AliVEvent   ;
 
 class AliCaloTrackMCReader : public AliCaloTrackReader {
   
@@ -25,9 +30,7 @@ class AliCaloTrackMCReader : public AliCaloTrackReader {
   AliCaloTrackMCReader(const AliCaloTrackMCReader & g) ; // cpy ctor
   AliCaloTrackMCReader & operator = (const AliCaloTrackMCReader & g) ;//cpy assignment
   virtual ~AliCaloTrackMCReader() ;//virtual dtor
-  
-  enum clonesType {kTParticle, kAliAOD};
-  
+    
   void InitParameters();
   
   void Print(const Option_t * opt) const; 
@@ -36,9 +39,6 @@ class AliCaloTrackMCReader : public AliCaloTrackReader {
   void SwitchOffPi0Decay() { fDecayPi0 = kFALSE ; } 
   Int_t IsPi0DecaySwitchedOn() const { return fDecayPi0 ; } 
   
-  void SetClonesArrayType(Int_t type){fClonesArrayType = type ;} 
-  Bool_t GetClonesArrayType() const {return fClonesArrayType ;} 
-    
   void AddNeutralParticlesArray(TArrayI & array)  
   { fNeutralParticlesArray   = new TArrayI(array) ; }
   TArrayI * GetNeutralParticlesArray() const   {return  fNeutralParticlesArray;}
@@ -60,8 +60,8 @@ class AliCaloTrackMCReader : public AliCaloTrackReader {
   void GetVertex(Double_t v[3]) const ;
 
   void FillInputEvent(Int_t iEntry) ;
-  AliVEvent*  GetInputEvent() const {return GetMC();}
-  void SetInputEvent(TObject* esd, TObject* aod, TObject* mc) ;
+  AliVEvent*  GetInputEvent() const {return (AliVEvent *) GetMC();}
+  void SetInputOutputMCEvent(AliVEvent* esd, AliAODEvent* aod, AliMCEvent* mc) ;
   
   void SetCaloClusterPID(const Int_t pdgCode, AliAODCaloCluster *calo) const ;
   void SetTrackChargeAndPID(const Int_t pdgCode, AliAODTrack *track) const ;
@@ -79,22 +79,21 @@ class AliCaloTrackMCReader : public AliCaloTrackReader {
   void CheckOverlap(const Float_t anglethres, const Int_t imom, Int_t & iPrimary, Int_t & index, TLorentzVector & mom, Int_t & pdg);
   void MakePi0Decay(TLorentzVector &p0, TLorentzVector &p1, TLorentzVector &p2) const ;//, Double_t &angle); 
   void FillCalorimeters(Int_t & iParticle, TParticle* particle, TLorentzVector momentum,   
-                       Int_t &indexPHOS, Int_t &indexEMCAL) ;
+                       Int_t &naod) ;
   
   private:
-  Bool_t      fDecayPi0; //If not decayed, decay pi0 by hand
-  TArrayI * fNeutralParticlesArray ; //Do not keep neutral particles of this list in calorimeter.
-  TArrayI * fChargedParticlesArray ; //Keep charged particles of this list in calorimeter.
-  TArrayI * fStatusArray ; //Keep particles with status of the list.
-  Bool_t fKeepAllStatus ; //Do or do not select particles depending on their status code.
-  Int_t fClonesArrayType; //Analysis with TParticles or AliAODCaloCluster/Track?
-  Bool_t fCheckOverlap; //Check of overlapped photons from pi0 enter the calorimeter
-  Float_t fEMCALOverlapAngle; //Aperture angle of photons from decay that is not resolved by EMCAL, in radians
-  Float_t fPHOSOverlapAngle; //Aperture angle of photons from decay that is not resolved by PHOS, in radians
-  Int_t fIndex2ndPhoton; //Check overlap of first decay photon already done, internal use.
+  Bool_t    fDecayPi0 ;              // If not decayed, decay pi0 by hand
+  TArrayI * fNeutralParticlesArray ; // Do not keep neutral particles of this list in calorimeter.
+  TArrayI * fChargedParticlesArray ; // Keep charged particles of this list in calorimeter.
+  TArrayI * fStatusArray ;           // Keep particles with status of the list.
+  Bool_t    fKeepAllStatus ;         // Do or do not select particles depending on their status code.
+  Bool_t    fCheckOverlap;           // Check of overlapped photons from pi0 enter the calorimeter
+  Float_t   fEMCALOverlapAngle;      // Aperture angle of photons from decay that is not resolved by EMCAL, in radians
+  Float_t   fPHOSOverlapAngle;       // Aperture angle of photons from decay that is not resolved by PHOS, in radians
+  Int_t     fIndex2ndPhoton;         // Check overlap of first decay photon already done, internal use.
 
-  ClassDef(AliCaloTrackMCReader,2)
-    } ;
+  ClassDef(AliCaloTrackMCReader,3)
+} ;
 
 
 #endif //ALICALOTRACKMCREADER_H
index a61d8caa5a2988daa063965435f95baebe0cc6b1..44ede348d1856d5c30770b787dc717fca0a7958f 100755 (executable)
 // Base class for reading data: MonteCarlo, ESD or AOD, of PHOS EMCAL and 
 // Central Barrel Tracking detectors (CTS).
 // Not all MC particles/tracks/clusters are kept, some kinematical/fidutial restrictions are done.
-// Mother class of : AliCaloTrackESDReader: Fills ESD data in 3 TClonesArrays (PHOS, EMCAL, CTS)
-//                 : AliCaloTrackMCReader: Fills Kinematics data in 3 TClonesArrays (PHOS, EMCAL, CTS)
-//                 : AliCaloTrackAODReader: Fills AOD data in 3 TClonesArrays (PHOS, EMCAL, CTS) 
+// Mother class of : AliCaloTrackESDReader: Fills ESD data in 3 TRefArrays (PHOS, EMCAL, CTS)
+//                 : AliCaloTrackMCReader: Fills Kinematics data in 3 TRefArrays (PHOS, EMCAL, CTS)
+//                 : AliCaloTrackAODReader: Fills AOD data in 3 TRefArrays (PHOS, EMCAL, CTS) 
 //                
 //-- Author: Gustavo Conesa (LNF-INFN) 
 //////////////////////////////////////////////////////////////////////////////
 
 
 // --- ROOT system ---
-#include <TMath.h>
-#include <TLorentzVector.h>
-#include <TString.h>
+#include <TRefArray.h>
 
 //---- ANALYSIS system ----
 #include "AliCaloTrackReader.h"
-#include "AliLog.h"
-#include "AliStack.h"  
-#include "AliHeader.h"  
-#include "AliGenEventHeader.h"  
+#include "AliFidutialCut.h"
+#include "AliAODEvent.h"
+#include "AliMCEvent.h"
 
 ClassImp(AliCaloTrackReader)
   
@@ -44,11 +41,11 @@ ClassImp(AliCaloTrackReader)
 //____________________________________________________________________________
   AliCaloTrackReader::AliCaloTrackReader() : 
     TObject(), fEventNumber(-1), fDataType(0), fDebug(0), 
-       fFidutialCut(0x0),
+    fFidutialCut(0x0),
     fCTSPtMin(0), fEMCALPtMin(0),fPHOSPtMin(0),
-    fAODCTS(0x0), fAODEMCAL(0x0), fAODPHOS(0x0),
+    fAODCTS(new TRefArray()), fAODEMCAL(new TRefArray()), fAODPHOS(new TRefArray()),
     fEMCALCells(0x0), fPHOSCells(0x0),
-    fESD(0x0), fAOD(0x0),fMC(0x0),
+    fInputEvent(0x0), fOutputEvent(0x0),fMC(0x0),
     fFillCTS(0),fFillEMCAL(0),fFillPHOS(0),
     fFillEMCALCells(0),fFillPHOSCells(0)
 {
@@ -63,12 +60,12 @@ AliCaloTrackReader::AliCaloTrackReader(const AliCaloTrackReader & g) :
   TObject(g), fEventNumber(g.fEventNumber), fDataType(g.fDataType), fDebug(g.fDebug),
   fFidutialCut(g.fFidutialCut),
   fCTSPtMin(g.fCTSPtMin), fEMCALPtMin(g.fEMCALPtMin),fPHOSPtMin(g.fPHOSPtMin), 
-  fAODCTS(new TClonesArray(*g.fAODCTS)),  
-  fAODEMCAL(new TClonesArray(*g.fAODEMCAL)),
-  fAODPHOS(new TClonesArray(*g.fAODPHOS)),
+  fAODCTS(new TRefArray(*g.fAODCTS)),  
+  fAODEMCAL(new TRefArray(*g.fAODEMCAL)),
+  fAODPHOS(new TRefArray(*g.fAODPHOS)),
   fEMCALCells(new TNamed(*g.fEMCALCells)),
   fPHOSCells(new TNamed(*g.fPHOSCells)),
-  fESD(g.fESD), fAOD(g.fAOD), fMC(g.fMC),
+  fInputEvent(g.fInputEvent), fOutputEvent(g.fOutputEvent), fMC(g.fMC),
   fFillCTS(g.fFillCTS),fFillEMCAL(g.fFillEMCAL),fFillPHOS(g.fFillPHOS),
   fFillEMCALCells(g.fFillEMCALCells),fFillPHOSCells(g.fFillPHOSCells)
 {
@@ -92,15 +89,15 @@ AliCaloTrackReader & AliCaloTrackReader::operator = (const AliCaloTrackReader &
   fEMCALPtMin = source.fEMCALPtMin ;
   fPHOSPtMin  = source.fPHOSPtMin ; 
   
-  fAODCTS     = new TClonesArray(*source.fAODCTS) ;
-  fAODEMCAL   = new TClonesArray(*source.fAODEMCAL) ;
-  fAODPHOS    = new TClonesArray(*source.fAODPHOS) ;
+  fAODCTS     = new TRefArray(*source.fAODCTS) ;
+  fAODEMCAL   = new TRefArray(*source.fAODEMCAL) ;
+  fAODPHOS    = new TRefArray(*source.fAODPHOS) ;
   fEMCALCells = new TNamed(*source.fEMCALCells) ;
   fPHOSCells  = new TNamed(*source.fPHOSCells) ;
 
-  fESD = source.fESD;
-  fAOD = source.fAOD;
-  fMC  = source.fMC;
+  fInputEvent  = source.fInputEvent;
+  fOutputEvent = source.fOutputEvent;
+  fMC          = source.fMC;
   
   fFillCTS        = source.fFillCTS;
   fFillEMCAL      = source.fFillEMCAL;
@@ -143,18 +140,19 @@ AliCaloTrackReader::~AliCaloTrackReader() {
     delete fPHOSCells ;
   }
 
-  if(fESD) delete fESD ;
-  if(fAOD) delete fAOD ;
-  if(fMC) delete fMC ;
+  if(fInputEvent)  delete fInputEvent ;
+  if(fOutputEvent) delete fOutputEvent ;
+  if(fMC)          delete fMC ;
 }
 
+
 //____________________________________________________________________________
 AliStack* AliCaloTrackReader::GetStack() const {
   //Return pointer to stack
   if(fMC)
     return fMC->Stack();
   else{
-    printf("stack is not available"); 
+    if(fDebug > 1) printf("AliCaloTrackReader::GetStack() - Stack is not available\n"); 
     return 0x0 ;
   }
 }
@@ -165,7 +163,7 @@ AliHeader* AliCaloTrackReader::GetHeader() const {
   if(fMC)
     return fMC->Header();
   else{
-    printf("Header is not available\n"); 
+    printf("AliCaloTrackReader::Header is not available\n"); 
     return 0x0 ;
   }
 }
@@ -175,7 +173,7 @@ AliGenEventHeader* AliCaloTrackReader::GetGenEventHeader() const {
   if(fMC)
     return fMC->GenEventHeader();
   else{
-    printf("GenEventHeader is not available\n"); 
+    printf("AliCaloTrackReader::GenEventHeader is not available\n"); 
     return 0x0 ;
   }
 }
@@ -228,11 +226,15 @@ void AliCaloTrackReader::FillInputEvent(Int_t iEntry) {
   //Fill the event counter and input lists that are needed, called by the analysis maker.
   
   fEventNumber = iEntry;
-  if(fFillCTS) FillInputCTS();
+  if((fDataType != kAOD) && ((fOutputEvent->GetCaloClusters())->GetEntriesFast()!=0 ||(fOutputEvent->GetTracks())->GetEntriesFast()!=0)){
+    printf("ABORT: AliCaloTrackReader::AODCaloClusters or AODTracks already filled by the filter, do not use the ESD reader, use the AOD reader\n");
+    abort();
+  }
+  if(fFillCTS)   FillInputCTS();
   if(fFillEMCAL) FillInputEMCAL();
-  if(fFillPHOS) FillInputPHOS();
+  if(fFillPHOS)  FillInputPHOS();
   if(fFillEMCALCells) FillInputEMCALCells();
-  if(fFillPHOSCells) FillInputPHOSCells();
+  if(fFillPHOSCells)  FillInputPHOSCells();
 
 }
 
@@ -240,10 +242,10 @@ void AliCaloTrackReader::FillInputEvent(Int_t iEntry) {
 void AliCaloTrackReader::ResetLists() {
   //  Reset lists, called by the analysis maker 
 
-  if(fAODCTS) fAODCTS -> Clear();
+  if(fAODCTS)   fAODCTS -> Clear();
   if(fAODEMCAL) fAODEMCAL -> Clear();
-  if(fAODPHOS) fAODPHOS -> Clear();
+  if(fAODPHOS)  fAODPHOS -> Clear();
   if(fEMCALCells) fEMCALCells -> Clear();
-  if(fPHOSCells) fPHOSCells -> Clear();
+  if(fPHOSCells)  fPHOSCells -> Clear();
 
 }
index 5bcf7367980c33fd6bc72661ebb900fd8a54845c..a81a48d11ed2fcb700fd75651cf801c50d0891e0 100755 (executable)
@@ -8,33 +8,33 @@
 // Base class for reading data: MonteCarlo, ESD or AOD, of PHOS EMCAL and 
 // Central Barrel Tracking detectors.
 // Not all MC particles/tracks/clusters are kept, some kinematical restrictions are done.
-// Mother class of : AliCaloTrackESDReader: Fills ESD data in 3 TClonesArrays (PHOS, EMCAL, CTS)
-//                 : AliCaloTrackMCReader: Fills Kinematics data in 3 TClonesArrays (PHOS, EMCAL, CTS)
-//                 : AliCaloTrackAODReader: Fills AOD data in 3 TClonesArrays (PHOS, EMCAL, CTS) 
+// Mother class of : AliCaloTrackESDReader: Fills ESD data in 3 TRefArrays (PHOS, EMCAL, CTS)
+//                 : AliCaloTrackMCReader: Fills Kinematics data in 3 TRefArrays (PHOS, EMCAL, CTS)
+//                 : AliCaloTrackAODReader: Fills AOD data in 3 TRefArrays (PHOS, EMCAL, CTS) 
 //                          
 // -- Author: Gustavo Conesa (INFN-LNF)
 
 // --- ROOT system ---
 #include "TObject.h" 
-class TClonesArray ; 
+class TRefArray ; 
 class TLorentzVector ;
 class TString ;
-#include "TArrayF.h"  
+class TRefArray;
+class TArrayF;  
 
 //--- ANALYSIS system ---
 class AliStack ; 
 class AliHeader ; 
 class AliGenEventHeader ; 
-#include "AliESDEvent.h" 
-#include "AliAODEvent.h" 
-#include "AliMCEvent.h" 
-class AliLog ;
-#include "AliFidutialCut.h"
+class AliVEvent;
+class AliAODEvent;  
+class AliMCEvent;
+class AliFidutialCut;
 
 class AliCaloTrackReader : public TObject {
 
-public: 
-
+ public: 
+  
   AliCaloTrackReader() ; // ctor
   AliCaloTrackReader(const AliCaloTrackReader & g) ; // cpy ctor
   AliCaloTrackReader & operator = (const AliCaloTrackReader & g) ;//cpy assignment
@@ -90,50 +90,49 @@ public:
   virtual void FillInputEMCALCells() {;}
   virtual void FillInputPHOSCells()  {;}
 
-  virtual TClonesArray* GetAODCTS()   const {return fAODCTS ;}
-  virtual TClonesArray* GetAODEMCAL() const {return fAODEMCAL ;}
-  virtual TClonesArray* GetAODPHOS()  const {return fAODPHOS ;}
-  virtual TNamed* GetEMCALCells()     const {return fEMCALCells ;}
-  virtual TNamed* GetPHOSCells()      const {return fPHOSCells ;}
+  virtual TRefArray* GetAODCTS()   const {return fAODCTS ;}
+  virtual TRefArray* GetAODEMCAL() const {return fAODEMCAL ;}
+  virtual TRefArray* GetAODPHOS()  const {return fAODPHOS ;}
+  virtual TNamed* GetEMCALCells()  const {return fEMCALCells ;}
+  virtual TNamed* GetPHOSCells()   const {return fPHOSCells ;}
 
-  virtual AliStack*          GetStack()  const ;
-  virtual AliHeader*         GetHeader() const ;
+  virtual AliStack*    GetStack()      const ;
+  virtual AliHeader*   GetHeader()     const ;
   virtual AliGenEventHeader* GetGenEventHeader() const ;
-  virtual AliESDEvent* GetESD() const {return fESD;}
-  virtual AliAODEvent* GetAOD() const {return fAOD;}
-  virtual AliMCEvent*  GetMC()  const {return fMC;}
-  virtual AliVEvent*   GetInputEvent()        const {return (new AliESDEvent());}
+  virtual AliVEvent*   GetInputEvent()  const {return fInputEvent;}
+  virtual AliAODEvent* GetOutputEvent() const {return fOutputEvent;}
+  virtual AliMCEvent*  GetMC()          const {return fMC;}
   virtual void         GetVertex(Double_t * ) const {;}
 
-  virtual void SetESD( AliESDEvent* esd) {fESD = esd;}
-  virtual void SetAOD(AliAODEvent* aod)  {fAOD = aod;}
-  virtual void SetMC(AliMCEvent* mc)     {fMC  = mc;}
+  virtual void SetInputEvent(AliVEvent* input)  {fInputEvent  = input;}
+  virtual void SetOutputEvent(AliAODEvent* aod) {fOutputEvent = aod;}
+  virtual void SetMC(AliMCEvent* mc)            {fMC  = mc;}
 
   virtual void ResetLists();
 
   virtual AliFidutialCut * GetFidutialCut() const {return  fFidutialCut ;}
   virtual void SetFidutialCut(AliFidutialCut * fc) { fFidutialCut = fc ;}
 
-  virtual void SetInputEvent(TObject* /*esd*/, TObject* /*aod*/, TObject* /*mc*/) {;}
+  virtual void SetInputOutputMCEvent(AliVEvent* /*esd*/, AliAODEvent* /*aod*/, AliMCEvent* /*mc*/) {;}
 
  protected:
-  Int_t                           fEventNumber; // Event number
+  Int_t                   fEventNumber; // Event number
   Int_t            fDataType ;   // Select MC:Kinematics, Data:ESD/AOD, MCData:Both
   Int_t            fDebug;       // Debugging level
   AliFidutialCut * fFidutialCut; // Acceptance cuts
                
-  Float_t        fCTSPtMin;      // pT  Threshold on charged particles 
+  Float_t        fCTSPtMin;      // pT Threshold on charged particles 
   Float_t        fEMCALPtMin;    // pT Threshold on emcal clusters
-  Float_t        fPHOSPtMin;     // pT  Threshold on phos clusters
+  Float_t        fPHOSPtMin;     // pT Threshold on phos clusters
 
-  TClonesArray * fAODCTS ;        //! temporal array with tracks
-  TClonesArray * fAODEMCAL ;      //! temporal array with EMCAL CaloClusters
-  TClonesArray * fAODPHOS ;       //! temporal array with PHOS CaloClusters
+  TRefArray *    fAODCTS ;        //! temporal referenced array with tracks
+  TRefArray *    fAODEMCAL ;      //! temporal referenced array with EMCAL CaloClusters
+  TRefArray *    fAODPHOS ;       //! temporal referenced array with PHOS CaloClusters
   TNamed *       fEMCALCells ;    //! temporal array with EMCAL CaloCells, ESD or AOD
   TNamed *       fPHOSCells ;     //! temporal array with PHOS CaloCells, ESD or AOD
 
-  AliESDEvent *  fESD;            //! pointer to esd
-  AliAODEvent *  fAOD;            //! pointer to aod
+  AliVEvent   *  fInputEvent;     //! pointer to esd or aod input
+  AliAODEvent *  fOutputEvent;    //! pointer to aod output
   AliMCEvent  *  fMC;             //! Monte Carlo Event Handler  
 
   Bool_t         fFillCTS;        // use data from CTS
@@ -142,7 +141,7 @@ public:
   Bool_t         fFillEMCALCells; // use data from EMCAL
   Bool_t         fFillPHOSCells;  // use data from PHOS
 
-  ClassDef(AliCaloTrackReader,1)
+  ClassDef(AliCaloTrackReader,3)
 } ;
 
 
index b6f73a9a800980ba125c8b0cff1bd1890ac8f2cb..fb725e75b528379d78273d900b02fd3c3dfaa0fc 100755 (executable)
@@ -29,7 +29,6 @@
 //#include <TArrayF.h>
   
 //---- ANALYSIS system ----
-#include "AliLog.h"
 #include "AliFidutialCut.h"
 
 ClassImp(AliFidutialCut)
@@ -144,8 +143,8 @@ Bool_t AliFidutialCut::IsInFidutialCut(TLorentzVector momentum, TString det) con
     netaregions =  fCTSFidCutMaxEta->GetSize();
     nphiregions =  fCTSFidCutMaxPhi->GetSize();
     if(netaregions !=  fCTSFidCutMinEta->GetSize() || nphiregions !=  fCTSFidCutMinPhi->GetSize())
-      AliFatal(Form("Wrong number of CTS fidutial cut regions: nmaxeta %d != nmineta %d; nmaxphi %d != nminphi %d",
-                   netaregions, fCTSFidCutMinEta->GetSize(),  nphiregions, fCTSFidCutMinPhi->GetSize()));
+      printf("AliFidutialCut::IsInFidutialCut() - Wrong number of CTS fidutial cut regions: nmaxeta %d != nmineta %d; nmaxphi %d != nminphi %d",
+                   netaregions, fCTSFidCutMinEta->GetSize(),  nphiregions, fCTSFidCutMinPhi->GetSize());
     
     maxeta = fCTSFidCutMaxEta->GetArray();
     maxphi = fCTSFidCutMaxPhi->GetArray();
@@ -157,8 +156,8 @@ Bool_t AliFidutialCut::IsInFidutialCut(TLorentzVector momentum, TString det) con
     netaregions =  fEMCALFidCutMaxEta->GetSize();
     nphiregions =  fEMCALFidCutMaxPhi->GetSize();
     if(netaregions !=  fEMCALFidCutMinEta->GetSize() || nphiregions !=  fEMCALFidCutMinPhi->GetSize())
-      AliFatal(Form("Wrong number of EMCAL fidutial cut regions: nmaxeta %d != nmineta %d; nmaxphi %d != nminphi %d",
-                   netaregions, fEMCALFidCutMinEta->GetSize(),  nphiregions, fEMCALFidCutMinPhi->GetSize()));
+      printf("AliFidutialCut::IsInFidutialCut() - Wrong number of EMCAL fidutial cut regions: nmaxeta %d != nmineta %d; nmaxphi %d != nminphi %d",
+                   netaregions, fEMCALFidCutMinEta->GetSize(),  nphiregions, fEMCALFidCutMinPhi->GetSize());
     
     maxeta = fEMCALFidCutMaxEta->GetArray();
     maxphi = fEMCALFidCutMaxPhi->GetArray();
@@ -170,8 +169,8 @@ Bool_t AliFidutialCut::IsInFidutialCut(TLorentzVector momentum, TString det) con
     netaregions =  fPHOSFidCutMaxEta->GetSize();
     nphiregions =  fPHOSFidCutMaxPhi->GetSize();
     if(netaregions !=  fPHOSFidCutMinEta->GetSize() || nphiregions !=  fPHOSFidCutMinPhi->GetSize())
-      AliFatal(Form("Wrong number of PHOS fidutial cut regions: nmaxeta %d != nmineta %d; nmaxphi %d != nminphi %d",
-                   netaregions, fPHOSFidCutMinEta->GetSize(),  nphiregions, fPHOSFidCutMinPhi->GetSize()));
+      printf("AliFidutialCut::IsInFidutialCut() - Wrong number of PHOS fidutial cut regions: nmaxeta %d != nmineta %d; nmaxphi %d != nminphi %d",
+                   netaregions, fPHOSFidCutMinEta->GetSize(),  nphiregions, fPHOSFidCutMinPhi->GetSize());
     
     maxeta = fPHOSFidCutMaxEta->GetArray();
     maxphi = fPHOSFidCutMaxPhi->GetArray();
@@ -180,7 +179,7 @@ Bool_t AliFidutialCut::IsInFidutialCut(TLorentzVector momentum, TString det) con
     selection =  fPHOSFidutialCut ; 
   }
   else
-    AliFatal(Form("Wrong detector name = %s", det.Data()));
+    printf("AliFidutialCut::IsInFidutialCut() - Wrong detector name = %s", det.Data());
 
   //printf("IsInFidutialCut::nphiregions = %d, netaregions = %d\n",nphiregions, netaregions);
 
index 881c5245705618ce7988d6f343f962cd6db7d123..da2719a502e611f08aa5d614363264040c9fb27c 100755 (executable)
@@ -19,7 +19,6 @@ class TLorentzVector ;
 
 //--- AliRoot system ---
 
-class AliLog ;
 
 class AliFidutialCut : public TObject {
 
@@ -102,27 +101,26 @@ public:
    
    //Detector acceptance cuts
    Bool_t     fEMCALFidutialCut ; // Apply fidutial cuts to EMCAL clusters
-  Bool_t     fPHOSFidutialCut ;// Apply fidutial cuts to PHOS clusters
-  Bool_t     fCTSFidutialCut ;//Apply fidutial cuts to  CTS tracks
-  
-  TArrayF * fCTSFidCutMinEta ; //Take particles in CTS with eta > fCTSFidCutMinEta
-  TArrayF * fCTSFidCutMinPhi ; //Take particles in CTS with phi > fCTSFidCutMinPhi
-  TArrayF * fCTSFidCutMaxEta ; //Take particles in CTS with eta < fCTSFidCutMaxEta
-  TArrayF * fCTSFidCutMaxPhi ; //Take particles in CTS with phi > fCTSFidCutMaxPhi
-  
-  TArrayF * fEMCALFidCutMinEta ; //Take particles in EMCAL with eta > fEMCALFidCutMinEta
-  TArrayF * fEMCALFidCutMinPhi ; //Take particles in EMCAL with phi > fEMCALFidCutMinPhi
-  TArrayF * fEMCALFidCutMaxEta ; //Take particles in EMCAL with eta < fEMCALFidCutMaxEta
-  TArrayF * fEMCALFidCutMaxPhi ; //Take particles in EMCAL with phi > fEMCALFidCutMaxPhi
-  
-  TArrayF * fPHOSFidCutMinEta ; //Take particles in PHOS with eta > fPHOSFidCutMinEta
-  TArrayF * fPHOSFidCutMinPhi ; //Take particles in PHOS with phi > fPHOSFidCutMinPhi
-  TArrayF * fPHOSFidCutMaxEta ; //Take particles in PHOS with eta < fPHOSFidCutMaxEta
-  TArrayF * fPHOSFidCutMaxPhi ; //Take particles in PHOS with phi > fPHOSFidCutMaxPhi
-
+   Bool_t     fPHOSFidutialCut ;// Apply fidutial cuts to PHOS clusters
+   Bool_t     fCTSFidutialCut ;//Apply fidutial cuts to  CTS tracks
+   
+   TArrayF * fCTSFidCutMinEta ; //Take particles in CTS with eta > fCTSFidCutMinEta
+   TArrayF * fCTSFidCutMinPhi ; //Take particles in CTS with phi > fCTSFidCutMinPhi
+   TArrayF * fCTSFidCutMaxEta ; //Take particles in CTS with eta < fCTSFidCutMaxEta
+   TArrayF * fCTSFidCutMaxPhi ; //Take particles in CTS with phi > fCTSFidCutMaxPhi
+   
+   TArrayF * fEMCALFidCutMinEta ; //Take particles in EMCAL with eta > fEMCALFidCutMinEta
+   TArrayF * fEMCALFidCutMinPhi ; //Take particles in EMCAL with phi > fEMCALFidCutMinPhi
+   TArrayF * fEMCALFidCutMaxEta ; //Take particles in EMCAL with eta < fEMCALFidCutMaxEta
+   TArrayF * fEMCALFidCutMaxPhi ; //Take particles in EMCAL with phi > fEMCALFidCutMaxPhi
+   
+   TArrayF * fPHOSFidCutMinEta ; //Take particles in PHOS with eta > fPHOSFidCutMinEta
+   TArrayF * fPHOSFidCutMinPhi ; //Take particles in PHOS with phi > fPHOSFidCutMinPhi
+   TArrayF * fPHOSFidCutMaxEta ; //Take particles in PHOS with eta < fPHOSFidCutMaxEta
+   TArrayF * fPHOSFidCutMaxPhi ; //Take particles in PHOS with phi > fPHOSFidCutMaxPhi
   
   ClassDef(AliFidutialCut,1)
-} ;
+    } ;
 
 
 #endif //ALIFIDUTIALCUT_H
index 51aa77b3cf551a2c74c3d8697d5897e915dcd559..aefbcf6a41910879837553984809ae2fd715f482 100755 (executable)
 // --- ROOT system --- 
 //#include <Riostream.h>
 #include <TLorentzVector.h>
-#include <TSeqCollection.h>
+#include <TRefArray.h>
 
 // --- AliRoot system --- 
 #include "AliIsolationCut.h" 
-class AliLog ;
 #include "AliAODPWG4ParticleCorrelation.h"
 #include "AliAODTrack.h"
 #include "AliAODCaloCluster.h"
@@ -58,7 +57,7 @@ AliIsolationCut::AliIsolationCut(const AliIsolationCut & g) :
   fICMethod(g.fICMethod)
 {
   // cpy ctor
-
+  
 }
 
 //_________________________________________________________________________
@@ -67,7 +66,7 @@ AliIsolationCut & AliIsolationCut::operator = (const AliIsolationCut & source)
   // assignment operator
   
   if(&source == this) return *this;
-   
+  
   fConeSize = source.fConeSize ;
   fPtThreshold = source.fPtThreshold ; 
   fICMethod = source.fICMethod ;
@@ -77,132 +76,144 @@ AliIsolationCut & AliIsolationCut::operator = (const AliIsolationCut & source)
   
 }
 
-
 //____________________________________________________________________________
 TString AliIsolationCut::GetICParametersList()
 {
-       //Put data member values in string to keep in output container
-
-       TString parList ; //this will be list of parameters used for this analysis.
-       char onePar[255] ;
-       
-       sprintf(onePar,"--- AliIsolationCut ---\n") ;
-       parList+=onePar ;       
-       sprintf(onePar,"fConeSize: (isolation cone size) %1.2f\n",fConeSize) ;
-       parList+=onePar ;
-       sprintf(onePar,"fPtThreshold =%1.2f (isolation pt threshold) \n",fPtThreshold) ;
-       parList+=onePar ;
-       sprintf(onePar,"fPtFraction=%1.2f (isolation pt threshold fraction ) \n",fPtFraction) ;
-       parList+=onePar ;
-       sprintf(onePar,"fICMethod=%d (isolation cut case) \n",fICMethod) ;
-       parList+=onePar ;
-
-    return parList; 
+  //Put data member values in string to keep in output container
+  
+  TString parList ; //this will be list of parameters used for this analysis.
+  char onePar[255] ;
+  
+  sprintf(onePar,"--- AliIsolationCut ---\n") ;
+  parList+=onePar ;    
+  sprintf(onePar,"fConeSize: (isolation cone size) %1.2f\n",fConeSize) ;
+  parList+=onePar ;
+  sprintf(onePar,"fPtThreshold =%1.2f (isolation pt threshold) \n",fPtThreshold) ;
+  parList+=onePar ;
+  sprintf(onePar,"fPtFraction=%1.2f (isolation pt threshold fraction ) \n",fPtFraction) ;
+  parList+=onePar ;
+  sprintf(onePar,"fICMethod=%d (isolation cut case) \n",fICMethod) ;
+  parList+=onePar ;
+  
+  return parList; 
 }
 
 //____________________________________________________________________________
 void AliIsolationCut::InitParameters()
 {
   //Initialize the parameters of the analysis.
-
+  
   fConeSize             = 0.4 ; 
   fPtThreshold         = 1. ; 
   fPtFraction        = 0.1 ; 
-
+  
   fICMethod = kPtThresIC; // 0 pt threshol method, 1 cone pt sum method
-
+  
 }
 
 //__________________________________________________________________
-void  AliIsolationCut::MakeIsolationCut(TSeqCollection * plCTS,  TSeqCollection * plNe, Double_t * vertex, 
+void  AliIsolationCut::MakeIsolationCut(TRefArray * plCTS,  TRefArray * plNe, Double_t * vertex, 
                                        const Bool_t fillAOD, AliAODPWG4ParticleCorrelation  *pCandidate, 
                                        Int_t & n, Int_t & nfrac, Float_t &coneptsum,  Bool_t  &isolated) const
 {  
-       //Search in cone around a candidate particle if it is isolated 
-       Float_t phiC  = pCandidate->Phi() ;
-       Float_t etaC = pCandidate->Eta() ;
-       Float_t ptC = pCandidate->Pt() ;
-       Float_t pt     = -100. ;
-       Float_t eta   = -100.  ;
-       Float_t phi    = -100.  ;
-       Float_t rad   = -100 ;
-       
-       n = 0 ;
-       coneptsum = 0.; 
-       isolated = kFALSE;
-       
-       //Check charged particles in cone.
-       if(plCTS){
-               TVector3 p3;
-               for(Int_t ipr = 0;ipr < plCTS->GetEntries() ; ipr ++ ){
-                       AliAODTrack* track = (AliAODTrack *)(plCTS->At(ipr)) ; 
-                       //Do not count the candidate (pion, conversion photon) or the daughters of the candidate
-                       if(track->GetID() == pCandidate->GetTrackLabel(0) || track->GetID() == pCandidate->GetTrackLabel(1)) continue ;
-                       p3.SetXYZ(track->Px(),track->Py(),track->Pz());
-                       pt   = p3.Pt();
-                       eta  = p3.Eta();
-                       phi  = p3.Phi() ;
-                       if(phi<0) phi+=TMath::TwoPi();
-                       
-                       //Check if there is any particle inside cone with pt larger than  fPtThreshold
-                       rad = TMath::Sqrt((eta-etaC)*(eta-etaC)+ (phi-phiC)*(phi-phiC));
-                       
-                       if(rad < fConeSize){
-                               if(fillAOD) pCandidate->AddIsolationConeTrack(track);
-                               //printf("charged in isolation cone pt %f, phi %f, eta %f, R %f \n",pt,phi,eta,rad);
-                               coneptsum+=pt;
-                               if(pt > fPtThreshold ) n++;
-                               if(pt > fPtFraction*ptC ) nfrac++;  
-                       }
-               }// charged particle loop
-       }//Tracks
-       
-       //Check neutral particles in cone.  
-       if(plNe){
-               TLorentzVector mom ;
-               for(Int_t ipr = 0;ipr < plNe->GetEntries() ; ipr ++ ){
-                       AliAODCaloCluster * calo = (AliAODCaloCluster *)(plNe->At(ipr)) ;
-                       
-                       //Do not count the candidate (photon or pi0) or the daughters of the candidate
-                       if(calo->GetID() == pCandidate->GetCaloLabel(0) || calo->GetID() == pCandidate->GetCaloLabel(1)) continue ;      //Skip matched clusters with tracks
-                       
-                       if(calo->GetNTracksMatched() > 0) continue ; 
-                       
-                       calo->GetMomentum(mom,vertex);//Assume that come from vertex in straight line
-                       pt   = mom.Pt();
-                       eta  = mom.Eta();
-                       phi  = mom.Phi() ;
-                       if(phi<0) phi+=TMath::TwoPi();
-                       
-                       //Check if there is any particle inside cone with pt larger than  fPtThreshold
-                       rad = TMath::Sqrt((eta-etaC)*(eta-etaC)+ (phi-phiC)*(phi-phiC));
-                       if(rad < fConeSize){
-                               if(fillAOD) pCandidate->AddIsolationConeCluster(calo);
-                               //printf("neutral in isolation cone pt %f, phi %f, eta %f, R %f \n",pt,phi,eta,rad);
-                               coneptsum+=pt;
-                               if(pt > fPtThreshold ) n++;
-                               if(pt > fPtFraction*ptC ) nfrac++;
-                       }//in cone
-               }// neutral particle loop
-       }//neutrals
-       
-       //printf("Isolation Cut: in cone with: pT>pTthres %d, pT > pTfrac*pTcandidate %d \n",n,nfrac);
-       
-       //Check isolation, depending on method.
-       if( fICMethod == kPtThresIC){
-               if(n==0) isolated = kTRUE ;
-       }
-       else if( fICMethod == kSumPtIC){
-               if(coneptsum < fPtThreshold)
-                       isolated  =  kTRUE ;
-       }
-       else if( fICMethod == kPtFracIC){
-               if(nfrac==0) isolated = kTRUE ;
+  //Search in cone around a candidate particle if it is isolated 
+  Float_t phiC  = pCandidate->Phi() ;
+  Float_t etaC = pCandidate->Eta() ;
+  Float_t ptC = pCandidate->Pt() ;
+  Float_t pt     = -100. ;
+  Float_t eta   = -100.  ;
+  Float_t phi    = -100.  ;
+  Float_t rad   = -100 ;
+  Bool_t first   = kTRUE;
+  n = 0 ;
+  coneptsum = 0.; 
+  isolated = kFALSE;
+  
+  //Check charged particles in cone.
+  if(plCTS){
+    TVector3 p3;
+    for(Int_t ipr = 0;ipr < plCTS->GetEntries() ; ipr ++ ){
+      AliAODTrack* track = (AliAODTrack *)(plCTS->At(ipr)) ; 
+      //Do not count the candidate (pion, conversion photon) or the daughters of the candidate
+      if(track->GetID() == pCandidate->GetTrackLabel(0) || track->GetID() == pCandidate->GetTrackLabel(1)) continue ;
+      p3.SetXYZ(track->Px(),track->Py(),track->Pz());
+      pt   = p3.Pt();
+      eta  = p3.Eta();
+      phi  = p3.Phi() ;
+      if(phi<0) phi+=TMath::TwoPi();
+      
+      //Check if there is any particle inside cone with pt larger than  fPtThreshold
+      rad = TMath::Sqrt((eta-etaC)*(eta-etaC)+ (phi-phiC)*(phi-phiC));
+      
+      if(rad < fConeSize){
+       if(fillAOD) {
+         if(first) {
+           new (pCandidate->GetRefIsolationConeTracks()) TRefArray(TProcessID::GetProcessWithUID(track)); 
+           first = kFALSE;
+         }
+         pCandidate->AddIsolationConeTrack(track);
        }
-       else if( fICMethod == kSumPtFracIC){
-               if(coneptsum < fPtFraction*ptC)
-                       isolated  =  kTRUE ;
+       //printf("charged in isolation cone pt %f, phi %f, eta %f, R %f \n",pt,phi,eta,rad);
+       coneptsum+=pt;
+       if(pt > fPtThreshold ) n++;
+       if(pt > fPtFraction*ptC ) nfrac++;  
+      }
+    }// charged particle loop
+  }//Tracks
+  
+  //Check neutral particles in cone.  
+  if(plNe){
+    first= kTRUE;
+    TLorentzVector mom ;
+    for(Int_t ipr = 0;ipr < plNe->GetEntries() ; ipr ++ ){
+      AliAODCaloCluster * calo = (AliAODCaloCluster *)(plNe->At(ipr)) ;
+      
+      //Do not count the candidate (photon or pi0) or the daughters of the candidate
+      if(calo->GetID() == pCandidate->GetCaloLabel(0) || calo->GetID() == pCandidate->GetCaloLabel(1)) continue ;      //Skip matched clusters with tracks
+      
+      if(calo->GetNTracksMatched() > 0) continue ; 
+      
+      calo->GetMomentum(mom,vertex);//Assume that come from vertex in straight line
+      pt   = mom.Pt();
+      eta  = mom.Eta();
+      phi  = mom.Phi() ;
+      if(phi<0) phi+=TMath::TwoPi();
+      
+      //Check if there is any particle inside cone with pt larger than  fPtThreshold
+      rad = TMath::Sqrt((eta-etaC)*(eta-etaC)+ (phi-phiC)*(phi-phiC));
+      if(rad < fConeSize){
+       if(fillAOD) {
+         if(first) {
+           new (pCandidate->GetRefIsolationConeClusters()) TRefArray(TProcessID::GetProcessWithUID(calo)); 
+           first = kFALSE;
+         }
+         pCandidate->AddIsolationConeCluster(calo);
        }
+       //printf("neutral in isolation cone pt %f, phi %f, eta %f, R %f \n",pt,phi,eta,rad);
+       coneptsum+=pt;
+       if(pt > fPtThreshold ) n++;
+       if(pt > fPtFraction*ptC ) nfrac++;
+      }//in cone
+    }// neutral particle loop
+  }//neutrals
+  
+  //printf("Isolation Cut: in cone with: pT>pTthres %d, pT > pTfrac*pTcandidate %d \n",n,nfrac);
+  
+  //Check isolation, depending on method.
+  if( fICMethod == kPtThresIC){
+    if(n==0) isolated = kTRUE ;
+  }
+  else if( fICMethod == kSumPtIC){
+    if(coneptsum < fPtThreshold)
+      isolated  =  kTRUE ;
+  }
+  else if( fICMethod == kPtFracIC){
+    if(nfrac==0) isolated = kTRUE ;
+  }
+  else if( fICMethod == kSumPtFracIC){
+    if(coneptsum < fPtFraction*ptC)
+      isolated  =  kTRUE ;
+  }
 }
 
 //__________________________________________________________________
index c464f486d785750d027bc2a3f0eb14524e40b199..de4c4430eb3d6cef39164bd9722d21c7ffe8a315 100755 (executable)
@@ -15,7 +15,7 @@
 
 // --- ROOT system --- 
 #include <TObject.h>
-class TSeqCollection ;
+class TRefArray ;
 
 // --- ANALYSIS system ---
 class AliAODPWG4ParticleCorrelation ;
@@ -24,47 +24,47 @@ class AliIsolationCut : public TObject {
   
  public: 
   
-       AliIsolationCut() ; // default ctor
-       AliIsolationCut(const AliIsolationCut & g) ; // cpy ctor
-       AliIsolationCut & operator = (const AliIsolationCut & g) ;//cpy assignment
-       virtual ~AliIsolationCut() {;} //virtual dtalr
-       
-       enum type {kPtThresIC, kSumPtIC, kPtFracIC, kSumPtFracIC};
-       
-       Float_t    GetConeSize()        const {return fConeSize ; }
-       Float_t    GetPtThreshold()     const {return fPtThreshold ; }
-       Float_t    GetPtFraction()      const {return fPtFraction ; }
-       Int_t      GetICMethod()        const {return fICMethod ; }
-       TString    GetICParametersList() ; 
-       
-       void MakeIsolationCut(TSeqCollection * plCTS, TSeqCollection * plNe, Double_t * vertex, 
-                                                 const Bool_t fillAOD, AliAODPWG4ParticleCorrelation  * pCandidate,
-                                                 Int_t &n, Int_t & nfrac, Float_t &ptsum, Bool_t & isolated) const ;  
-       
-       void Print(const Option_t * opt)const;
-       
-       void SetConeSize(Float_t r)       {fConeSize = r ; }
-       void SetPtThreshold(Float_t pt)   {fPtThreshold = pt; }
-       void SetPtFraction(Float_t pt)    {fPtFraction = pt; }
-       void SetICMethod(Int_t i )        {fICMethod = i ; }
-       
-       void InitParameters();
-       
+  AliIsolationCut() ; // default ctor
+  AliIsolationCut(const AliIsolationCut & g) ; // cpy ctor
+  AliIsolationCut & operator = (const AliIsolationCut & g) ;//cpy assignment
+  virtual ~AliIsolationCut() {;} //virtual dtalr
   
-  private:
-     
-  Float_t      fConeSize ; //Size of the isolation cone 
+  enum type {kPtThresIC, kSumPtIC, kPtFracIC, kSumPtFracIC};
+  
+  Float_t    GetConeSize()        const {return fConeSize ; }
+  Float_t    GetPtThreshold()     const {return fPtThreshold ; }
+  Float_t    GetPtFraction()      const {return fPtFraction ; }
+  Int_t      GetICMethod()        const {return fICMethod ; }
+  TString    GetICParametersList() ; 
+  
+  void MakeIsolationCut(TRefArray * plCTS, TRefArray * plNe, Double_t * vertex, 
+                       const Bool_t fillAOD, AliAODPWG4ParticleCorrelation  * pCandidate,
+                       Int_t &n, Int_t & nfrac, Float_t &ptsum, Bool_t & isolated) const ;  
+  
+  void Print(const Option_t * opt)const;
+  
+  void SetConeSize(Float_t r)       {fConeSize = r ; }
+  void SetPtThreshold(Float_t pt)   {fPtThreshold = pt; }
+  void SetPtFraction(Float_t pt)    {fPtFraction = pt; }
+  void SetICMethod(Int_t i )        {fICMethod = i ; }
+  
+  void InitParameters();
+  
+  
+ private:
+  
+  Float_t      fConeSize ;    //Size of the isolation cone 
   Float_t      fPtThreshold ; //Mimium pt of the particles in the cone or sum in cone 
-  Float_t      fPtFraction ; //Fraction of the momentum of particles in cone or sum in cone
-  Int_t        fICMethod ; //Isolation cut method to be used
-                                           // kPtIC: Pt threshold method
-                                           // kSumPtIC: Cone pt sum method
-                                           // kPtFracIC:   Pt threshold, fraction of candidate pt, method
-                                           // kSumPtFracIC:   Cone pt sum , fraction of cone sum, method
-
+  Float_t      fPtFraction ;  //Fraction of the momentum of particles in cone or sum in cone
+  Int_t        fICMethod ;    //Isolation cut method to be used
+                              // kPtIC: Pt threshold method
+                              // kSumPtIC: Cone pt sum method
+                              // kPtFracIC:   Pt threshold, fraction of candidate pt, method
+                              // kSumPtFracIC:   Cone pt sum , fraction of cone sum, method
+  
   ClassDef(AliIsolationCut,1)
 } ;
+
 
 #endif //ALIISOLATIONCUT_H
 
index e0dcff2e5c330ce6dab3aae4840a7642d4b8a4f7..c5ee124beaaec7034bab2118a82ea023a9ad2442 100755 (executable)
 //                
 //*-- Author: Gustavo Conesa (LNF-INFN) 
 //////////////////////////////////////////////////////////////////////////////
-
+  
 
 // --- ROOT system ---
 #include <TMath.h>
-#include <TString.h>
 #include <TList.h>
 
 //---- ANALYSIS system ----
-#include "AliLog.h"
 #include "AliMCAnalysisUtils.h"
 #include "AliStack.h"
 #include "TParticle.h"
 #include "AliGenPythiaEventHeader.h"
 
-ClassImp(AliMCAnalysisUtils)
-
+  ClassImp(AliMCAnalysisUtils)
 
-//________________________________________________
-AliMCAnalysisUtils::AliMCAnalysisUtils() : 
-TObject(), fCurrentEvent(-1), fDebug(-1), 
-fJetsList(new TList), fMCGenerator("PYTHIA")
+ //________________________________________________
+  AliMCAnalysisUtils::AliMCAnalysisUtils() : 
+    TObject(), fCurrentEvent(-1), fDebug(-1), 
+    fJetsList(new TList), fMCGenerator("PYTHIA")
 {
-       //Ctor
+  //Ctor
 }
 
 //____________________________________________________________________________
 AliMCAnalysisUtils::AliMCAnalysisUtils(const AliMCAnalysisUtils & mcutils) :   
-TObject(mcutils), fCurrentEvent(mcutils.fCurrentEvent), fDebug(mcutils.fDebug),
-fJetsList(mcutils.fJetsList), fMCGenerator(mcutils.fMCGenerator)
+  TObject(mcutils), fCurrentEvent(mcutils.fCurrentEvent), fDebug(mcutils.fDebug),
+  fJetsList(mcutils.fJetsList), fMCGenerator(mcutils.fMCGenerator)
 {
-       // cpy ctor
-       
+  // cpy ctor
+  
 }
 
 //_________________________________________________________________________
 AliMCAnalysisUtils & AliMCAnalysisUtils::operator = (const AliMCAnalysisUtils & mcutils)
 {
-       // assignment operator
-       
-       if(&mcutils == this) return *this;
-       fCurrentEvent = mcutils.fCurrentEvent ;
-       fDebug        = mcutils.fDebug;
-       fJetsList     = mcutils.fJetsList;
-       fMCGenerator  = mcutils.fMCGenerator;
-
-       return *this;
-       
+  // assignment operator
+  
+  if(&mcutils == this) return *this;
+  fCurrentEvent = mcutils.fCurrentEvent ;
+  fDebug        = mcutils.fDebug;
+  fJetsList     = mcutils.fJetsList;
+  fMCGenerator  = mcutils.fMCGenerator;
+  
+  return *this; 
 }
 
 //____________________________________________________________________________
 AliMCAnalysisUtils::~AliMCAnalysisUtils() 
 {
-       // Remove all pointers.
-       
-       if (fJetsList) {
-               fJetsList->Clear();
-               delete fJetsList ;
-       }   
-
+  // Remove all pointers.
+  
+  if (fJetsList) {
+    fJetsList->Clear();
+    delete fJetsList ;
+  }     
 }
 
 //_________________________________________________________________________
@@ -89,12 +84,15 @@ Int_t AliMCAnalysisUtils::CheckOrigin(const Int_t label, AliStack * stack) const
   //Play with the MC stack if available
   //Check origin of the candidates, good for PYTHIA
   
-  if(!stack) AliFatal("Stack is not available, check analysis settings in configuration file, STOP!!");
+  if(!stack) {
+    printf("AliMCAnalysisUtils::CheckOrigin() - Stack is not available, check analysis settings in configuration file, STOP!!");
+    abort();
+  }
   //  printf("label %d, ntrack %d, nprim %d\n",label, stack->GetNtrack(), stack->GetNprimary());
-//   for(Int_t i = 0; i< stack->GetNprimary(); i++){
-//      TParticle *particle =   stack->Particle(i);
-//                     //particle->Print();
-//   }
+  //   for(Int_t i = 0; i< stack->GetNprimary(); i++){
+  //      TParticle *particle =   stack->Particle(i);
+  //                   //particle->Print();
+  //   }
   if(label >= 0 && label <  stack->GetNtrack()){
     //Mother
     TParticle * mom = stack->Particle(label);
@@ -195,22 +193,22 @@ Int_t AliMCAnalysisUtils::CheckOrigin(const Int_t label, AliStack * stack) const
 TList * AliMCAnalysisUtils::GetJets(Int_t iEvent, AliStack * stack, AliGenEventHeader * geh) {
  //Return list of jets (TParticles) and index of most likely parton that originated it.
        
-       if(fCurrentEvent!=iEvent){
-               fCurrentEvent = iEvent;
-               fJetsList = new TList;
-               Int_t nTriggerJets = 0;
-               Float_t tmpjet[]={0,0,0,0};
+  if(fCurrentEvent!=iEvent){
+    fCurrentEvent = iEvent;
+    fJetsList = new TList;
+    Int_t nTriggerJets = 0;
+    Float_t tmpjet[]={0,0,0,0};
                
-               //printf("Event %d %d\n",fCurrentEvent,iEvent);
-               //Get outgoing partons
-               if(stack->GetNtrack() < 8) return fJetsList;
-               TParticle * parton1 =  stack->Particle(6);
-               TParticle * parton2 =  stack->Particle(7);
-               if(fDebug > 2){
-                       printf("parton 6 : %s, pt %2.2f,E %2.2f, phi %2.2f, eta %2.2f \n",
-                               parton1->GetName(),parton1->Pt(),parton1->Energy(),parton1->Phi()*TMath::RadToDeg(),parton1->Eta());
-                       printf("parton 7 : %s, pt %2.2f,E %2.2f, phi %2.2f, eta %2.2f \n",
-                               parton2->GetName(),parton2->Pt(),parton2->Energy(),parton2->Phi()*TMath::RadToDeg(),parton2->Eta());
+    //printf("Event %d %d\n",fCurrentEvent,iEvent);
+    //Get outgoing partons
+    if(stack->GetNtrack() < 8) return fJetsList;
+    TParticle * parton1 =  stack->Particle(6);
+    TParticle * parton2 =  stack->Particle(7);
+    if(fDebug > 2){
+      printf("parton 6 : %s, pt %2.2f,E %2.2f, phi %2.2f, eta %2.2f \n",
+            parton1->GetName(),parton1->Pt(),parton1->Energy(),parton1->Phi()*TMath::RadToDeg(),parton1->Eta());
+      printf("parton 7 : %s, pt %2.2f,E %2.2f, phi %2.2f, eta %2.2f \n",
+            parton2->GetName(),parton2->Pt(),parton2->Energy(),parton2->Phi()*TMath::RadToDeg(),parton2->Eta());
                }
 //             //Trace the jet from the mother parton
 //             Float_t pt  = 0;
@@ -251,76 +249,76 @@ TList * AliMCAnalysisUtils::GetJets(Int_t iEvent, AliStack * stack, AliGenEventH
                
                //Get the jet, different way for different generator
                //PYTHIA
-               if(fMCGenerator == "PYTHIA"){
-                       TParticle * jet =  new TParticle;
-                       AliGenPythiaEventHeader* pygeh= (AliGenPythiaEventHeader*) geh;
-                       nTriggerJets =  pygeh->NTriggerJets();
-                       //if(fDebug > 1)
-                               printf("PythiaEventHeader: Njets: %d\n",nTriggerJets);
-                       Int_t iparton = -1;
-                       for(Int_t i = 0; i< nTriggerJets; i++){
-                               iparton=-1;
-                               pygeh->TriggerJet(i, tmpjet);
-                               jet = new TParticle(94, 21, -1, -1, -1, -1, tmpjet[0],tmpjet[1],tmpjet[2],tmpjet[3], 0,0,0,0);
-                               //Assign an outgoing parton as mother
-                               Float_t phidiff1 = TMath::Abs(jet->Phi()-parton1->Phi());               
-                               Float_t phidiff2 = TMath::Abs(jet->Phi()-parton2->Phi());
-                               if(phidiff1 > phidiff2) jet->SetFirstMother(7);
-                               else  jet->SetFirstMother(6);
-                               //jet->Print();
-                               if(fDebug > 1)
-                                 printf("PYTHIA Jet %d: mother %d, pt %2.2f,E %2.2f, phi %2.2f, eta %2.2f \n",
-                                        i, jet->GetFirstMother(),jet->Pt(),jet->Energy(),jet->Phi()*TMath::RadToDeg(),jet->Eta());
-                               fJetsList->Add(jet);                    
-                       }
-               }//Pythia triggered jets
-               //HERWIG
-               else if (fMCGenerator=="HERWIG"){
-                       Int_t pdg = -1;         
-                       //Check parton 1
-                       TParticle * tmp = parton1;
-                       if(parton1->GetPdgCode()!=22){
-                               while(pdg != 94){
-                                       if(tmp->GetFirstDaughter()==-1) return fJetsList;
-                                       tmp = stack->Particle(tmp->GetFirstDaughter());
-                                       pdg = tmp->GetPdgCode();
-                               }//while
-                               
-                               //Add found jet to list
-                               TParticle *jet1 = new TParticle(*tmp);
-                               jet1->SetFirstMother(6);
-                               fJetsList->Add(jet1);
-                               //printf("jet 1:  first daughter %d, last daughter %d\n", tmp->GetFirstDaughter(), tmp->GetLastDaughter());
-                               //tmp = stack->Particle(tmp->GetFirstDaughter());
-                               //tmp->Print();
-                               //jet1->Print();
-                               if(fDebug > 1)                  
-                                       printf("HERWIG Jet 1: mother %d, status %d, pt %2.2f,E %2.2f, phi %2.2f, eta %2.2f \n",
-                                               jet1->GetFirstMother(),jet1->GetStatusCode(),jet1->Pt(),jet1->Energy(),jet1->Phi()*TMath::RadToDeg(),jet1->Eta());
-                       }//not photon
-                               
-                       //Check parton 2
-                       pdg = -1;
-                       tmp = parton2;
-                       Int_t i = -1;
-                       if(parton2->GetPdgCode()!=22){
-                               while(pdg != 94){
-                                       if(tmp->GetFirstDaughter()==-1) return fJetsList;
-                                       i = tmp->GetFirstDaughter();
-                                       tmp = stack->Particle(tmp->GetFirstDaughter());
-                                       pdg = tmp->GetPdgCode();
-                               }//while
-                               //Add found jet to list
-                               TParticle *jet2 = new TParticle(*tmp);
-                               jet2->SetFirstMother(7);
-                               fJetsList->Add(jet2);
-                               //jet2->Print();
-                               if(fDebug > 1)
-                                       printf("HERWIG Jet 2: mother %d, status %d, pt %2.2f,E %2.2f, phi %2.2f, eta %2.2f \n",
-                                       jet2->GetFirstMother(),jet2->GetStatusCode(),jet2->Pt(),jet2->Energy(),jet2->Phi()*TMath::RadToDeg(),jet2->Eta());
-                                       Int_t first =  tmp->GetFirstDaughter();
-                                       Int_t last  =  tmp->GetLastDaughter();
-                                       printf("jet 2:  first daughter %d, last daughter %d, pdg %d\n",first, last, tmp->GetPdgCode());
+    if(fMCGenerator == "PYTHIA"){
+      TParticle * jet =  new TParticle;
+      AliGenPythiaEventHeader* pygeh= (AliGenPythiaEventHeader*) geh;
+      nTriggerJets =  pygeh->NTriggerJets();
+      //if(fDebug > 1)
+      printf("PythiaEventHeader: Njets: %d\n",nTriggerJets);
+      Int_t iparton = -1;
+      for(Int_t i = 0; i< nTriggerJets; i++){
+       iparton=-1;
+       pygeh->TriggerJet(i, tmpjet);
+       jet = new TParticle(94, 21, -1, -1, -1, -1, tmpjet[0],tmpjet[1],tmpjet[2],tmpjet[3], 0,0,0,0);
+       //Assign an outgoing parton as mother
+       Float_t phidiff1 = TMath::Abs(jet->Phi()-parton1->Phi());               
+       Float_t phidiff2 = TMath::Abs(jet->Phi()-parton2->Phi());
+       if(phidiff1 > phidiff2) jet->SetFirstMother(7);
+       else  jet->SetFirstMother(6);
+       //jet->Print();
+       if(fDebug > 1)
+         printf("PYTHIA Jet %d: mother %d, pt %2.2f,E %2.2f, phi %2.2f, eta %2.2f \n",
+                i, jet->GetFirstMother(),jet->Pt(),jet->Energy(),jet->Phi()*TMath::RadToDeg(),jet->Eta());
+       fJetsList->Add(jet);                    
+      }
+    }//Pythia triggered jets
+    //HERWIG
+    else if (fMCGenerator=="HERWIG"){
+      Int_t pdg = -1;          
+      //Check parton 1
+      TParticle * tmp = parton1;
+      if(parton1->GetPdgCode()!=22){
+       while(pdg != 94){
+         if(tmp->GetFirstDaughter()==-1) return fJetsList;
+         tmp = stack->Particle(tmp->GetFirstDaughter());
+         pdg = tmp->GetPdgCode();
+       }//while
+       
+       //Add found jet to list
+       TParticle *jet1 = new TParticle(*tmp);
+       jet1->SetFirstMother(6);
+       fJetsList->Add(jet1);
+       //printf("jet 1:  first daughter %d, last daughter %d\n", tmp->GetFirstDaughter(), tmp->GetLastDaughter());
+       //tmp = stack->Particle(tmp->GetFirstDaughter());
+       //tmp->Print();
+       //jet1->Print();
+       if(fDebug > 1)                  
+         printf("HERWIG Jet 1: mother %d, status %d, pt %2.2f,E %2.2f, phi %2.2f, eta %2.2f \n",
+                jet1->GetFirstMother(),jet1->GetStatusCode(),jet1->Pt(),jet1->Energy(),jet1->Phi()*TMath::RadToDeg(),jet1->Eta());
+      }//not photon
+      
+      //Check parton 2
+      pdg = -1;
+      tmp = parton2;
+      Int_t i = -1;
+      if(parton2->GetPdgCode()!=22){
+       while(pdg != 94){
+         if(tmp->GetFirstDaughter()==-1) return fJetsList;
+         i = tmp->GetFirstDaughter();
+         tmp = stack->Particle(tmp->GetFirstDaughter());
+         pdg = tmp->GetPdgCode();
+       }//while
+       //Add found jet to list
+       TParticle *jet2 = new TParticle(*tmp);
+       jet2->SetFirstMother(7);
+       fJetsList->Add(jet2);
+       //jet2->Print();
+       if(fDebug > 1)
+         printf("HERWIG Jet 2: mother %d, status %d, pt %2.2f,E %2.2f, phi %2.2f, eta %2.2f \n",
+                jet2->GetFirstMother(),jet2->GetStatusCode(),jet2->Pt(),jet2->Energy(),jet2->Phi()*TMath::RadToDeg(),jet2->Eta());
+       Int_t first =  tmp->GetFirstDaughter();
+       Int_t last  =  tmp->GetLastDaughter();
+       printf("jet 2:  first daughter %d, last daughter %d, pdg %d\n",first, last, tmp->GetPdgCode());
                                //      for(Int_t d = first ; d < last+1; d++){
 //                                             tmp = stack->Particle(d);
 //                                             if(i == tmp->GetFirstMother())
@@ -328,28 +326,28 @@ TList * AliMCAnalysisUtils::GetJets(Int_t iEvent, AliStack * stack, AliGenEventH
 //                                                     d,tmp->GetFirstMother(), tmp->GetName(), tmp->GetStatusCode(),tmp->Pt(),tmp->Energy(),tmp->Phi()*TMath::RadToDeg(),tmp->Eta());                    
 //                        }
                                                   //tmp->Print();
-                          }//not photon
-               }//Herwig generated jets
-       }
-       
-       return fJetsList;
+      }//not photon
+    }//Herwig generated jets
+  }
+  
+  return fJetsList;
 }
 
 //________________________________________________________________
 void AliMCAnalysisUtils::Print(const Option_t * opt) const
 {
-       
-       //Print some relevant parameters set for the analysis
      if(! opt)
-               return;
-       
      printf("***** Print: %s %s ******\n", GetName(), GetTitle() ) ;
-       
      printf("Debug level    = %d\n",fDebug);
      printf("MC Generator   = %s\n",fMCGenerator.Data());
-
      printf(" \n");
-       
+  //Print some relevant parameters set for the analysis
+ if(! opt)
+   return;
+ printf("***** Print: %s %s ******\n", GetName(), GetTitle() ) ;
+ printf("Debug level    = %d\n",fDebug);
+ printf("MC Generator   = %s\n",fMCGenerator.Data());
+ printf(" \n");
 } 
 
 
index a6484227f707bb8c14e107207b4024b3d94b7db1..22f0bbbd653fbe53ebafd7a6258f31e0067b5e37 100755 (executable)
@@ -19,10 +19,7 @@ class TString ;
 class TList ;
 
 //--- AliRoot system ---
-class AliLog ;
-//#include "AliStack.h"
 class AliStack ;
-//#include "AliGenPythiaEventHeader.h"
 class AliGenEventHeader ;
 
 class AliMCAnalysisUtils : public TObject {
index 93f8b4be4694ecc1a6e11853c6fb1dbf526f86c7..0613b5356a494dab6a3a21c744eb99fdc50f7649 100755 (executable)
 #include <TLorentzVector.h>
 #include <TH2.h>
 #include <TList.h>
-#include <TArrayD.h>
  
 //---- AliRoot system ----
 #include "AliNeutralMesonSelection.h" 
-#include "AliLog.h"
 
 ClassImp(AliNeutralMesonSelection)
   
@@ -42,10 +40,11 @@ ClassImp(AliNeutralMesonSelection)
     fhAnglePairAllCut(0), 
     fhInvMassPairNoCut(0), fhInvMassPairOpeningAngleCut(0), 
     fhInvMassPairAllCut(0),
-       fHistoNEBins(0),   fHistoEMax(0.),   fHistoEMin(0.),
-       fHistoNPtBins(0),  fHistoPtMax(0.),  fHistoPtMin(0.),
-       fHistoNAngleBins(0), fHistoAngleMax(0.), fHistoAngleMin(0.),
-       fHistoNIMBins(0), fHistoIMMax(0.), fHistoIMMin(0.){
+    fHistoNEBins(0),   fHistoEMax(0.),   fHistoEMin(0.),
+    fHistoNPtBins(0),  fHistoPtMax(0.),  fHistoPtMin(0.),
+    fHistoNAngleBins(0), fHistoAngleMax(0.), fHistoAngleMin(0.),
+    fHistoNIMBins(0), fHistoIMMax(0.), fHistoIMMin(0.)
+{
   //Default Ctor
   
   //Initialize parameters
@@ -130,72 +129,71 @@ AliNeutralMesonSelection::~AliNeutralMesonSelection()
 //________________________________________________________________________
 TList *  AliNeutralMesonSelection::GetCreateOutputObjects()
 {  
-       
-       // Create histograms to be saved in output file and 
-       // store them in outputContainer of the analysis class that calls this class.
-       
-       TList * outputContainer = new TList() ; 
-       outputContainer->SetName("MesonDecayHistos") ; 
-                         
-       fhAnglePairNoCut  = new TH2F
+  // Create histograms to be saved in output file and 
+  // store them in outputContainer of the analysis class that calls this class.
+  
+  TList * outputContainer = new TList() ; 
+  outputContainer->SetName("MesonDecayHistos") ; 
+  
+  fhAnglePairNoCut  = new TH2F
     ("AnglePairNoCut",
      "Angle between all #gamma pair vs E_{#pi^{0}}",fHistoNEBins,fHistoEMin,fHistoEMax,fHistoNAngleBins,fHistoAngleMin,fHistoAngleMax); 
-       fhAnglePairNoCut->SetYTitle("Angle (rad)");
-       fhAnglePairNoCut->SetXTitle("E_{ #pi^{0}} (GeV)");
-       
-       fhAnglePairOpeningAngleCut  = new TH2F
+  fhAnglePairNoCut->SetYTitle("Angle (rad)");
+  fhAnglePairNoCut->SetXTitle("E_{ #pi^{0}} (GeV)");
+  
+  fhAnglePairOpeningAngleCut  = new TH2F
     ("AnglePairOpeningAngleCut",
      "Angle between all #gamma pair (opening angle + azimuth cut) vs E_{#pi^{0}}"
      ,fHistoNEBins,fHistoEMin,fHistoEMax,fHistoNAngleBins,fHistoAngleMin,fHistoAngleMax); 
-       fhAnglePairOpeningAngleCut->SetYTitle("Angle (rad)");
-       fhAnglePairOpeningAngleCut->SetXTitle("E_{ #pi^{0}} (GeV)");
-       
-       fhAnglePairAllCut  = new TH2F
+  fhAnglePairOpeningAngleCut->SetYTitle("Angle (rad)");
+  fhAnglePairOpeningAngleCut->SetXTitle("E_{ #pi^{0}} (GeV)");
+  
+  fhAnglePairAllCut  = new TH2F
     ("AnglePairAllCut",
      "Angle between all #gamma pair (opening angle + inv mass cut+azimuth) vs E_{#pi^{0}}"
      ,fHistoNEBins,fHistoEMin,fHistoEMax,fHistoNAngleBins,fHistoAngleMin,fHistoAngleMax); 
-       fhAnglePairAllCut->SetYTitle("Angle (rad)");
-       fhAnglePairAllCut->SetXTitle("E_{ #pi^{0}} (GeV)");    
-       
-       //
-       fhInvMassPairNoCut  = new TH2F
+  fhAnglePairAllCut->SetYTitle("Angle (rad)");
+  fhAnglePairAllCut->SetXTitle("E_{ #pi^{0}} (GeV)");    
+  
+  //
+  fhInvMassPairNoCut  = new TH2F
     ("InvMassPairNoCut","Invariant Mass of all #gamma pair vs E_{#pi^{0}}",
      fHistoNPtBins,fHistoPtMin,fHistoPtMax,fHistoNIMBins,fHistoIMMin,fHistoIMMax); 
-       fhInvMassPairNoCut->SetYTitle("Invariant Mass (GeV/c^{2})");
-       fhInvMassPairNoCut->SetXTitle("E_{ #pi^{0}} (GeV)");
-       
-       fhInvMassPairOpeningAngleCut  = new TH2F
+  fhInvMassPairNoCut->SetYTitle("Invariant Mass (GeV/c^{2})");
+  fhInvMassPairNoCut->SetXTitle("E_{ #pi^{0}} (GeV)");
+  
+  fhInvMassPairOpeningAngleCut  = new TH2F
     ("InvMassPairOpeningAngleCut",
      "Invariant Mass of #gamma pair (angle cut) vs E_{#pi^{0}}",
      fHistoNPtBins,fHistoPtMin,fHistoPtMax,fHistoNIMBins,fHistoIMMin,fHistoIMMax); 
-       fhInvMassPairOpeningAngleCut->SetYTitle("Invariant Mass (GeV/c^{2})");
-       fhInvMassPairOpeningAngleCut->SetXTitle(" E_{#pi^{0}}(GeV)");
-       
-       fhInvMassPairAllCut  = new TH2F
+  fhInvMassPairOpeningAngleCut->SetYTitle("Invariant Mass (GeV/c^{2})");
+  fhInvMassPairOpeningAngleCut->SetXTitle(" E_{#pi^{0}}(GeV)");
+  
+  fhInvMassPairAllCut  = new TH2F
     ("InvMassPairAllCut",
      "Invariant Mass of #gamma pair (opening angle+invmass cut) vs E_{#pi^{0}}",
      fHistoNPtBins,fHistoPtMin,fHistoPtMax,fHistoNIMBins,fHistoIMMin,fHistoIMMax); 
-       fhInvMassPairAllCut->SetYTitle("Invariant Mass (GeV/c^{2})");
-       fhInvMassPairAllCut->SetXTitle("E_{#pi^{0}}(GeV)");
-       
-       outputContainer->Add(fhAnglePairNoCut) ; 
-       outputContainer->Add(fhAnglePairOpeningAngleCut) ;
-       outputContainer->Add(fhAnglePairAllCut) ; 
-       
-       outputContainer->Add(fhInvMassPairNoCut) ; 
-       outputContainer->Add(fhInvMassPairOpeningAngleCut) ; 
-       outputContainer->Add(fhInvMassPairAllCut) ; 
-       
-       return outputContainer;
+  fhInvMassPairAllCut->SetYTitle("Invariant Mass (GeV/c^{2})");
+  fhInvMassPairAllCut->SetXTitle("E_{#pi^{0}}(GeV)");
+  
+  outputContainer->Add(fhAnglePairNoCut) ; 
+  outputContainer->Add(fhAnglePairOpeningAngleCut) ;
+  outputContainer->Add(fhAnglePairAllCut) ; 
+  
+  outputContainer->Add(fhInvMassPairNoCut) ; 
+  outputContainer->Add(fhInvMassPairOpeningAngleCut) ; 
+  outputContainer->Add(fhInvMassPairAllCut) ; 
+  
+  return outputContainer;
 }
 
- //____________________________________________________________________________
+//____________________________________________________________________________
 void AliNeutralMesonSelection::InitParameters()
 {
+  
   //Initialize the parameters of the analysis.
   fKeepNeutralMesonHistos = kFALSE ;
-
+  
   fAngleMaxParam.Set(4) ;
   fAngleMaxParam.AddAt(0.4,0);//={0.4,-0.25,0.025,-2e-4};
   fAngleMaxParam.AddAt(-0.25,1) ;
@@ -251,7 +249,7 @@ Bool_t  AliNeutralMesonSelection::SelectPair(TLorentzVector gammai, TLorentzVect
   //Search for the neutral pion within selection cuts
   Bool_t goodpair = kFALSE ;
   
-  Double_t pt  = (gammai+gammaj).Pt();
+//  Double_t pt  = (gammai+gammaj).Pt();
   Double_t phi = (gammai+gammaj).Phi();
   if(phi < 0)
     phi+=TMath::TwoPi();
@@ -267,14 +265,14 @@ Bool_t  AliNeutralMesonSelection::SelectPair(TLorentzVector gammai, TLorentzVect
   if(IsAngleInWindow(angle,e)){
     fhAnglePairOpeningAngleCut     ->Fill(e,angle);
     fhInvMassPairOpeningAngleCut->Fill(e,invmass);
-    AliDebug(2,Form("Angle cut: pt %f, phi %f",pt,phi));
+    //AliDebug(2,Form("Angle cut: pt %f, phi %f",pt,phi));
     
     //Cut on the invariant mass of the pair
     if((invmass>fInvMassMinCut) && (invmass<fInvMassMaxCut)){ 
       fhInvMassPairAllCut  ->Fill(e,invmass);
       fhAnglePairAllCut       ->Fill(e,angle);
       goodpair = kTRUE;
-      AliDebug(2,Form("IM cut: pt %f, phi %f",pt,phi));
+      //AliDebug(2,Form("IM cut: pt %f, phi %f",pt,phi));
     }//(invmass>0.125) && (invmass<0.145)
   }//Opening angle cut
   
@@ -303,11 +301,11 @@ void AliNeutralMesonSelection::Print(const Option_t * opt) const
   printf("Keep Neutral Meson Histos = %d\n",fKeepNeutralMesonHistos);
   
   if(fKeepNeutralMesonHistos){
-       printf("Histograms: %3.1f < E  < %3.1f,  Nbin = %d\n", fHistoEMin,  fHistoEMax,  fHistoNEBins);
-       printf("Histograms: %3.1f < pT < %3.1f,  Nbin = %d\n", fHistoPtMin,  fHistoPtMax,  fHistoNPtBins);
-       printf("Histograms: %3.1f < angle < %3.1f, Nbin = %d\n", fHistoAngleMin, fHistoAngleMax, fHistoNAngleBins);
-       printf("Histograms: %3.1f < IM < %3.1f, Nbin = %d\n", fHistoIMMin, fHistoIMMax, fHistoNIMBins);
-  
+    printf("Histograms: %3.1f < E  < %3.1f,  Nbin = %d\n", fHistoEMin,  fHistoEMax,  fHistoNEBins);
+    printf("Histograms: %3.1f < pT < %3.1f,  Nbin = %d\n", fHistoPtMin,  fHistoPtMax,  fHistoNPtBins);
+    printf("Histograms: %3.1f < angle < %3.1f, Nbin = %d\n", fHistoAngleMin, fHistoAngleMax, fHistoNAngleBins);
+    printf("Histograms: %3.1f < IM < %3.1f, Nbin = %d\n", fHistoIMMin, fHistoIMMax, fHistoNIMBins);
+    
   }
-
+  
 } 
index e26b3d2ba3a7dc23ce9155e611f8ea0dc277edce..fbb8b43caeb2180456950d7bb6eb75bae70c72b9 100755 (executable)
@@ -20,115 +20,114 @@ class TList ;
 class TH2F ;
 
 //--- ANALYSIS system ---
-class AliLog ;
 
 class AliNeutralMesonSelection : public TObject {
-       
-public: 
-       
-       AliNeutralMesonSelection() ; // default ctor
-       AliNeutralMesonSelection(const AliNeutralMesonSelection & g) ; // cpy ctor
-       AliNeutralMesonSelection & operator = (const AliNeutralMesonSelection & g) ;//cpy assignment
-       virtual ~AliNeutralMesonSelection() ; //virtual dtor
-       
-       TList * GetCreateOutputObjects();
-       
-       Double_t GetAngleMaxParam(Int_t i) const {return fAngleMaxParam.At(i) ; }
-       void SetAngleMaxParam(Int_t i, Double_t par){fAngleMaxParam.AddAt(par,i) ; }
-       
-       Double_t GetInvMassMaxCut() const {return fInvMassMaxCut ; }
-       Double_t GetInvMassMinCut() const {return fInvMassMinCut ; }
-       void SetInvMassCutRange(Double_t invmassmin, Double_t invmassmax)
-       {fInvMassMaxCut =invmassmax;  fInvMassMinCut =invmassmin;}      
-       
-       Double_t GetMass() const {return fM ; }
-       void SetMass(Double_t m) { fM =m ; }
-       
-       Bool_t AreNeutralMesonSelectionHistosKept() const { return fKeepNeutralMesonHistos ; }
-       void KeepNeutralMesonSelectionHistos(Bool_t keep) { fKeepNeutralMesonHistos = keep ; }
-       
-       void InitParameters();  
-       Bool_t IsAngleInWindow(const Float_t angle, const Float_t e) const ;
-       void Print(const Option_t * opt) const;
-       
-       Bool_t  SelectPair(TLorentzVector particlei,  TLorentzVector particlej)  ;
-       
-       //Histogrammes setters and getters
-       
-       virtual void SetHistoERangeAndNBins(Float_t min, Float_t max, Int_t n) {
-               fHistoNEBins = n ;
-               fHistoEMax = max ;
-               fHistoEMin = min ;
-       }
-       
-       Int_t   GetHistoNEBins() const { return fHistoNEBins ; }
-       Float_t GetHistoEMin()   const { return fHistoEMin ; }
-       Float_t GetHistoEMax()   const { return fHistoEMax ; }
-
-       virtual void SetHistoPtRangeAndNBins(Float_t min, Float_t max, Int_t n) {
-               fHistoNPtBins = n ;
-               fHistoPtMax = max ;
-               fHistoPtMin = min ;
-       }
-       
-       Int_t   GetHistoNPtBins() const { return fHistoNPtBins ; }
-       Float_t GetHistoPtMin()   const { return fHistoPtMin ; }
-       Float_t GetHistoPtMax()   const { return fHistoPtMax ; }
-
-       virtual void SetHistoAngleRangeAndNBins(Float_t min, Float_t max, Int_t n) {
-               fHistoNAngleBins = n ;
-               fHistoAngleMax = max ;
-               fHistoAngleMin = min ;
-       }
-       
-       Int_t   GetHistoNAngleBins() const { return fHistoNAngleBins ; }
-       Float_t GetHistoAngleMin()   const { return fHistoAngleMin ; }
-       Float_t GetHistoAngleMax()   const { return fHistoAngleMax ; }
-
-       virtual void SetHistoIMRangeAndNBins(Float_t min, Float_t max, Int_t n) {
-               fHistoNIMBins = n ;
-               fHistoIMMax = max ;
-               fHistoIMMin = min ;
-       }
-       
-       Int_t   GetHistoNIMBins() const { return fHistoNIMBins ; }
-       Float_t GetHistoIMMin()   const { return fHistoIMMin ; }
-       Float_t GetHistoIMMax()   const { return fHistoIMMax ; }
-       
-       
-private:
-       Double_t fM ; //mass of the neutral meson
-       Double_t   fInvMassMaxCut ;  // Invariant Mass cut maximum
-       Double_t   fInvMassMinCut ;  // Invariant Masscut minimun
-       TArrayD    fAngleMaxParam ; //Max opening angle selection parameters
-       
-       Bool_t  fKeepNeutralMesonHistos ; // Keep neutral meson selection histograms
-       
-       //Histograms
-       TH2F * fhAnglePairNoCut  ;  //Aperture angle of decay photons, no cuts
-       TH2F * fhAnglePairOpeningAngleCut   ;  //Aperture angle of decay photons, cut on opening angle
-       TH2F * fhAnglePairAllCut   ;  //Aperture angle of decay photons, all cuts
-       TH2F * fhInvMassPairNoCut    ;  //Invariant mass of decay photons, no cuts
-       TH2F * fhInvMassPairOpeningAngleCut  ;  //Invariant mass of decay photons, cut on opening angle
-       TH2F * fhInvMassPairAllCut   ;  //Invariant mass of decay photons, all cuts
-       
-       //Histograms binning and range    
-       Int_t   fHistoNEBins ;  //Number of bins in pi0 E axis
-       Float_t fHistoEMax ;    //Maximum value of pi0 E histogram range
-       Float_t fHistoEMin ;    //Minimum value of pi0 E histogram range
-       Int_t   fHistoNPtBins ;  //Number of bins in Pt trigger axis
-       Float_t fHistoPtMax ;    //Maximum value of Pt trigger histogram range
-       Float_t fHistoPtMin ;    //Minimum value of Pt trigger histogram range          
-       Int_t   fHistoNAngleBins ; //Number of bins in angle axis
-       Float_t fHistoAngleMax ;//Maximum value of angle histogram range
-       Float_t fHistoAngleMin ;//Minimum value of angle histogram range
-       Int_t   fHistoNIMBins ; //Number of bins in Invariant Mass axis
-       Float_t fHistoIMMax ;   //Maximum value of Invariant Mass histogram range
-       Float_t fHistoIMMin ;   //Minimum value of Invariant Mass histogram range
-       
-       ClassDef(AliNeutralMesonSelection,2)
+  
+ public: 
+  
+  AliNeutralMesonSelection() ; // default ctor
+  AliNeutralMesonSelection(const AliNeutralMesonSelection & g) ; // cpy ctor
+  AliNeutralMesonSelection & operator = (const AliNeutralMesonSelection & g) ;//cpy assignment
+  virtual ~AliNeutralMesonSelection() ; //virtual dtor
+  
+  TList * GetCreateOutputObjects();
+  
+  Double_t GetAngleMaxParam(Int_t i) const {return fAngleMaxParam.At(i) ; }
+  void SetAngleMaxParam(Int_t i, Double_t par){fAngleMaxParam.AddAt(par,i) ; }
+  
+  Double_t GetInvMassMaxCut() const {return fInvMassMaxCut ; }
+  Double_t GetInvMassMinCut() const {return fInvMassMinCut ; }
+  void SetInvMassCutRange(Double_t invmassmin, Double_t invmassmax)
+  {fInvMassMaxCut =invmassmax;  fInvMassMinCut =invmassmin;}   
+  
+  Double_t GetMass() const {return fM ; }
+  void SetMass(Double_t m) { fM =m ; }
+  
+  Bool_t AreNeutralMesonSelectionHistosKept() const { return fKeepNeutralMesonHistos ; }
+  void KeepNeutralMesonSelectionHistos(Bool_t keep) { fKeepNeutralMesonHistos = keep ; }
+  
+  void InitParameters();       
+  Bool_t IsAngleInWindow(const Float_t angle, const Float_t e) const ;
+  void Print(const Option_t * opt) const;
+  
+  Bool_t  SelectPair(TLorentzVector particlei,  TLorentzVector particlej)  ;
+  
+  //Histogrammes setters and getters
+  
+  virtual void SetHistoERangeAndNBins(Float_t min, Float_t max, Int_t n) {
+    fHistoNEBins = n ;
+    fHistoEMax = max ;
+    fHistoEMin = min ;
+  }
+  
+  Int_t   GetHistoNEBins() const { return fHistoNEBins ; }
+  Float_t GetHistoEMin()   const { return fHistoEMin ; }
+  Float_t GetHistoEMax()   const { return fHistoEMax ; }
+  
+  virtual void SetHistoPtRangeAndNBins(Float_t min, Float_t max, Int_t n) {
+    fHistoNPtBins = n ;
+    fHistoPtMax = max ;
+    fHistoPtMin = min ;
+  }
+  
+  Int_t   GetHistoNPtBins() const { return fHistoNPtBins ; }
+  Float_t GetHistoPtMin()   const { return fHistoPtMin ; }
+  Float_t GetHistoPtMax()   const { return fHistoPtMax ; }
+  
+  virtual void SetHistoAngleRangeAndNBins(Float_t min, Float_t max, Int_t n) {
+    fHistoNAngleBins = n ;
+    fHistoAngleMax = max ;
+    fHistoAngleMin = min ;
+  }
+  
+  Int_t   GetHistoNAngleBins() const { return fHistoNAngleBins ; }
+  Float_t GetHistoAngleMin()   const { return fHistoAngleMin ; }
+  Float_t GetHistoAngleMax()   const { return fHistoAngleMax ; }
+  
+  virtual void SetHistoIMRangeAndNBins(Float_t min, Float_t max, Int_t n) {
+    fHistoNIMBins = n ;
+    fHistoIMMax = max ;
+    fHistoIMMin = min ;
+  }
+  
+  Int_t   GetHistoNIMBins() const { return fHistoNIMBins ; }
+  Float_t GetHistoIMMin()   const { return fHistoIMMin ; }
+  Float_t GetHistoIMMax()   const { return fHistoIMMax ; }
+  
+  
+ private:
+  Double_t fM ; //mass of the neutral meson
+  Double_t   fInvMassMaxCut ;  // Invariant Mass cut maximum
+  Double_t   fInvMassMinCut ;  // Invariant Masscut minimun
+  TArrayD    fAngleMaxParam ; //Max opening angle selection parameters
+  
+  Bool_t  fKeepNeutralMesonHistos ; // Keep neutral meson selection histograms
+  
+  //Histograms
+  TH2F * fhAnglePairNoCut  ;  //Aperture angle of decay photons, no cuts
+  TH2F * fhAnglePairOpeningAngleCut   ;  //Aperture angle of decay photons, cut on opening angle
+  TH2F * fhAnglePairAllCut   ;  //Aperture angle of decay photons, all cuts
+  TH2F * fhInvMassPairNoCut    ;  //Invariant mass of decay photons, no cuts
+  TH2F * fhInvMassPairOpeningAngleCut  ;  //Invariant mass of decay photons, cut on opening angle
+  TH2F * fhInvMassPairAllCut   ;  //Invariant mass of decay photons, all cuts
+  
+  //Histograms binning and range    
+  Int_t   fHistoNEBins ;  //Number of bins in pi0 E axis
+  Float_t fHistoEMax ;    //Maximum value of pi0 E histogram range
+  Float_t fHistoEMin ;    //Minimum value of pi0 E histogram range
+  Int_t   fHistoNPtBins ;  //Number of bins in Pt trigger axis
+  Float_t fHistoPtMax ;    //Maximum value of Pt trigger histogram range
+  Float_t fHistoPtMin ;    //Minimum value of Pt trigger histogram range               
+  Int_t   fHistoNAngleBins ; //Number of bins in angle axis
+  Float_t fHistoAngleMax ;//Maximum value of angle histogram range
+  Float_t fHistoAngleMin ;//Minimum value of angle histogram range
+  Int_t   fHistoNIMBins ; //Number of bins in Invariant Mass axis
+  Float_t fHistoIMMax ;   //Maximum value of Invariant Mass histogram range
+  Float_t fHistoIMMin ;   //Minimum value of Invariant Mass histogram range
+  
+  ClassDef(AliNeutralMesonSelection,2)
     
-} ;
+    } ;
 
 
 #endif //ALINEUTRALMESONSELECTION_H
index a941a8d9ed25e1c48ade9cd2d1ff28816e93b0fd..3ed46c59dc63cca6bc817927d86838eceadd5128 100755 (executable)
@@ -29,7 +29,6 @@
 //Aliroot
 #include "AliAnaCaloTrigger.h" 
 #include "AliStack.h"
-#include "AliLog.h"
 #include "AliESDCaloCluster.h"
 #include "AliMCEvent.h"
 #include "AliESDEvent.h"
@@ -40,7 +39,6 @@ AliAnaCaloTrigger::AliAnaCaloTrigger() :
   fCalorimeter("PHOS"),
   fNtTrigger22(0), 
   fNtTriggerNN(0)
-
 {
   // Default Constructor.
 
@@ -53,7 +51,6 @@ AliAnaCaloTrigger::AliAnaCaloTrigger(const char *name) :
   fCalorimeter("PHOS"),
   fNtTrigger22(0), 
   fNtTriggerNN(0)
-
 {
   // Constructor.
   // Output slot 
@@ -93,10 +90,10 @@ AliAnaCaloTrigger & AliAnaCaloTrigger::operator = (const AliAnaCaloTrigger & sou
 AliAnaCaloTrigger::~AliAnaCaloTrigger()
 {
   // dtor
-       if(fOutputContainer){
-               fOutputContainer->Clear() ; 
-               delete fOutputContainer ;
-       }
+  if(fOutputContainer){
+    fOutputContainer->Clear() ; 
+    delete fOutputContainer ;
+  }
 }
 
 
@@ -125,116 +122,116 @@ void AliAnaCaloTrigger::UserCreateOutputObjects()
 //______________________________________________________________________________
 void AliAnaCaloTrigger::UserExec(Option_t *) 
 {
-       // Processing of one event
-       
-       if ( !((Entry()-1)%100) ) 
-               printf(" Processing event # %lld\n",  Entry()) ; 
-       AliESDEvent* esd = (AliESDEvent*)InputEvent();
+  // Processing of one event
+  
+  if ( !((Entry()-1)%100) ) 
+    printf(" Processing event # %lld\n",  Entry()) ; 
+  AliESDEvent* esd = (AliESDEvent*)InputEvent();
+  
+  //Get MC data, if available
+  AliStack* stack = 0x0; 
+  if(MCEvent())
+    stack = MCEvent()->Stack();
+  
+  // Get trigger information of fCalorimeter 
+  TArrayF * triggerAmplitudes = 0x0 ;
+  TArrayF * triggerPosition   = 0x0 ;
+  Int_t numberOfCaloClusters  =  esd->GetNumberOfCaloClusters() ;
+  
+  if(fCalorimeter == "PHOS"){
+    triggerAmplitudes      = esd->GetPHOSTriggerAmplitudes();
+    triggerPosition        = esd->GetPHOSTriggerPosition();
+  }
+  else if(fCalorimeter == "EMCAL"){
+    triggerAmplitudes    = esd->GetEMCALTriggerAmplitudes();
+    triggerPosition      = esd->GetEMCALTriggerPosition();
+  }
+  
+  if( triggerAmplitudes && triggerPosition ){
+    // trigger amplitudes
+    const Float_t ka22    = static_cast<Float_t>(triggerAmplitudes->At(0)) ; 
+    const Float_t ka22O   = static_cast<Float_t>(triggerAmplitudes->At(1)) ; 
+    const Float_t kaNN    = static_cast<Float_t>(triggerAmplitudes->At(2)) ; 
+    const Float_t kaNNO   = static_cast<Float_t>(triggerAmplitudes->At(3)) ; 
+    
+    // trigger position
+    const Float_t kx22  =  static_cast<Float_t>(triggerPosition->At(0)) ; 
+    const Float_t ky22  =  static_cast<Float_t>(triggerPosition->At(1)) ;
+    const Float_t kz22  =  static_cast<Float_t>(triggerPosition->At(2)) ;
+    const Float_t kxNN  =  static_cast<Float_t>(triggerPosition->At(3)) ; 
+    const Float_t kyNN  =  static_cast<Float_t>(triggerPosition->At(4)) ;
+    const Float_t kzNN  =  static_cast<Float_t>(triggerPosition->At(5)) ; 
+    
+    //printf("ka22 %f, ka220 %f, kaNN %f, kaNN0 %f\n",ka22,ka22O,kaNN,kaNNO);
+    //printf("kx22 %f, ky22 %f, kz22 %f, kxNN %f, kyNN %f, kzNN %f \n",kx22,ky22,kz22,kxNN,kyNN,kzNN);
+    
+    Float_t enMax       = 0. ;
+    Float_t phEnMax     = 0. ;
+    Float_t etaMax      = 0.5 ;
+    Float_t phiMax      = 0. ; 
+    Float_t phEtaMax    = 0.5 ;
+    Float_t phPhiMax    = 0. ; 
+    
+    TVector3 vpos22(kx22, ky22, kz22) ;
+    TVector3 vposNN(kxNN, kyNN, kzNN) ;
+    Float_t eta22 = vpos22.Eta() ; 
+    Float_t phi22 = vpos22.Phi() * TMath::RadToDeg() + 360. ; 
+    Float_t etaNN = vposNN.Eta() ; 
+    Float_t phiNN = vposNN.Phi() * TMath::RadToDeg() + 360. ; 
+    
+    
+    Int_t      icaloCluster = 0 ; 
+    Int_t      labelmax     = -1 ;
+    // loop over the Calorimeters Clusters
+    
+    for(icaloCluster = 0 ; icaloCluster < numberOfCaloClusters ; icaloCluster++) {
+      
+      AliESDCaloCluster * cluster = esd->GetCaloCluster(icaloCluster) ;
+      
+      if (cluster && ( (fCalorimeter == "PHOS" && cluster->IsPHOS())  ||  
+                      (fCalorimeter == "EMCAL" && cluster->IsEMCAL()))) {
        
-       //Get MC data, if available
-       AliStack* stack = 0x0; 
-       if(MCEvent())
-               stack = MCEvent()->Stack();
+       Float_t cluEnergy = cluster->E() ; 
+       Float_t pos[3] ;
+       TVector3 vpos ;
        
-       // Get trigger information of fCalorimeter 
-       TArrayF * triggerAmplitudes = 0x0 ;
-       TArrayF * triggerPosition   = 0x0 ;
-       Int_t numberOfCaloClusters  =  esd->GetNumberOfCaloClusters() ;
+       cluster->GetPosition( pos ) ;
        
-       if(fCalorimeter == "PHOS"){
-               triggerAmplitudes      = esd->GetPHOSTriggerAmplitudes();
-               triggerPosition        = esd->GetPHOSTriggerPosition();
+       if ( cluEnergy > enMax) { 
+         enMax    = cluEnergy ; 
+         vpos.SetXYZ(pos[0], pos[1], pos[2]) ; 
+         etaMax   = vpos.Eta() ; 
+         phiMax   = vpos.Phi() ; 
+         labelmax = cluster->GetLabel();
        }
-       else if(fCalorimeter == "EMCAL"){
-               triggerAmplitudes    = esd->GetEMCALTriggerAmplitudes();
-               triggerPosition      = esd->GetEMCALTriggerPosition();
-       }
-       
-       if( triggerAmplitudes && triggerPosition ){
-               // trigger amplitudes
-               const Float_t ka22    = static_cast<Float_t>(triggerAmplitudes->At(0)) ; 
-               const Float_t ka22O   = static_cast<Float_t>(triggerAmplitudes->At(1)) ; 
-               const Float_t kaNN    = static_cast<Float_t>(triggerAmplitudes->At(2)) ; 
-               const Float_t kaNNO   = static_cast<Float_t>(triggerAmplitudes->At(3)) ; 
-               
-               // trigger position
-               const Float_t kx22  =  static_cast<Float_t>(triggerPosition->At(0)) ; 
-               const Float_t ky22  =  static_cast<Float_t>(triggerPosition->At(1)) ;
-               const Float_t kz22  =  static_cast<Float_t>(triggerPosition->At(2)) ;
-               const Float_t kxNN  =  static_cast<Float_t>(triggerPosition->At(3)) ; 
-               const Float_t kyNN  =  static_cast<Float_t>(triggerPosition->At(4)) ;
-               const Float_t kzNN  =  static_cast<Float_t>(triggerPosition->At(5)) ; 
-               
-               //printf("ka22 %f, ka220 %f, kaNN %f, kaNN0 %f\n",ka22,ka22O,kaNN,kaNNO);
-               //printf("kx22 %f, ky22 %f, kz22 %f, kxNN %f, kyNN %f, kzNN %f \n",kx22,ky22,kz22,kxNN,kyNN,kzNN);
-               
-               Float_t enMax       = 0. ;
-               Float_t phEnMax     = 0. ;
-               Float_t etaMax      = 0.5 ;
-               Float_t phiMax      = 0. ; 
-               Float_t phEtaMax    = 0.5 ;
-               Float_t phPhiMax    = 0. ; 
-               
-               TVector3 vpos22(kx22, ky22, kz22) ;
-               TVector3 vposNN(kxNN, kyNN, kzNN) ;
-               Float_t eta22 = vpos22.Eta() ; 
-               Float_t phi22 = vpos22.Phi() * TMath::RadToDeg() + 360. ; 
-               Float_t etaNN = vposNN.Eta() ; 
-               Float_t phiNN = vposNN.Phi() * TMath::RadToDeg() + 360. ; 
-               
-               
-               Int_t      icaloCluster = 0 ; 
-               Int_t      labelmax     = -1 ;
-               // loop over the Calorimeters Clusters
-               
-               for(icaloCluster = 0 ; icaloCluster < numberOfCaloClusters ; icaloCluster++) {
-                       
-                       AliESDCaloCluster * cluster = esd->GetCaloCluster(icaloCluster) ;
-                       
-                       if (cluster && ( (fCalorimeter == "PHOS" && cluster->IsPHOS())  ||  
-                                                       (fCalorimeter == "EMCAL" && cluster->IsEMCAL()))) {
-                               
-                               Float_t cluEnergy = cluster->E() ; 
-                               Float_t pos[3] ;
-                               TVector3 vpos ;
-                               
-                               cluster->GetPosition( pos ) ;
-                               
-                               if ( cluEnergy > enMax) { 
-                                       enMax    = cluEnergy ; 
-                                       vpos.SetXYZ(pos[0], pos[1], pos[2]) ; 
-                                       etaMax   = vpos.Eta() ; 
-                                       phiMax   = vpos.Phi() ; 
-                                       labelmax = cluster->GetLabel();
-                               }
-                               
-                               Double_t * pid = cluster->GetPid() ;
-                               
-                               if(pid[AliPID::kPhoton] > 0.9) {
-                                       if ( cluEnergy > phEnMax) { 
-                                               phEnMax   = cluEnergy ; 
-                                               vpos.SetXYZ(pos[0], pos[1], pos[2]) ; 
-                                               phEtaMax = vpos.Eta() ; 
-                                               phPhiMax = vpos.Phi() ; 
-                                       }
-                               }
-                       }//if cluster
-                       
-                   Float_t ptGen = -1;
-                       if(stack && labelmax < stack->GetNtrack() && labelmax >= 0 ){
-                               TParticle * particle = stack->Particle(labelmax); 
-                               ptGen = particle->Energy();
-                       }
-                       
-                       fNtTrigger22->Fill(ka22, ka22O, ptGen, enMax, phEnMax, eta22, phi22, etaMax, phiMax * TMath::RadToDeg() + 360., phEtaMax, phPhiMax * TMath::RadToDeg() + 360.);
-                       fNtTriggerNN->Fill(kaNN, kaNNO, ptGen, enMax, phEnMax, etaNN, phiNN, etaMax, phiMax * TMath::RadToDeg() + 360., phEtaMax, phPhiMax * TMath::RadToDeg() + 360.);
-               
-               }//CaloCluster loop
-               
-       }//If trigger arrays filled
        
-       PostData(1, fOutputContainer);
+       Double_t * pid = cluster->GetPid() ;
        
+       if(pid[AliPID::kPhoton] > 0.9) {
+         if ( cluEnergy > phEnMax) { 
+           phEnMax   = cluEnergy ; 
+           vpos.SetXYZ(pos[0], pos[1], pos[2]) ; 
+           phEtaMax = vpos.Eta() ; 
+           phPhiMax = vpos.Phi() ; 
+         }
+       }
+      }//if cluster
+      
+      Float_t ptGen = -1;
+      if(stack && labelmax < stack->GetNtrack() && labelmax >= 0 ){
+       TParticle * particle = stack->Particle(labelmax); 
+       ptGen = particle->Energy();
+      }
+      
+      fNtTrigger22->Fill(ka22, ka22O, ptGen, enMax, phEnMax, eta22, phi22, etaMax, phiMax * TMath::RadToDeg() + 360., phEtaMax, phPhiMax * TMath::RadToDeg() + 360.);
+      fNtTriggerNN->Fill(kaNN, kaNNO, ptGen, enMax, phEnMax, etaNN, phiNN, etaMax, phiMax * TMath::RadToDeg() + 360., phEtaMax, phPhiMax * TMath::RadToDeg() + 360.);
+      
+    }//CaloCluster loop
+    
+  }//If trigger arrays filled
+  
+  PostData(1, fOutputContainer);
+  
 }
 
 //______________________________________________________________________________
diff --git a/PWG4/PartCorrDep/AliAnaChargedParticles.cxx b/PWG4/PartCorrDep/AliAnaChargedParticles.cxx
new file mode 100755 (executable)
index 0000000..684b3aa
--- /dev/null
@@ -0,0 +1,321 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+/* $Id: $ */
+
+//_________________________________________________________________________
+//
+// Class for track selection and identification (not done now)
+// Tracks from the CTS are kept in the AOD.
+// Few histograms produced.
+//
+//-- Author: Gustavo Conesa (INFN-LNF)
+//_________________________________________________________________________
+
+
+// --- ROOT system ---
+#include "TClonesArray.h"
+#include "TParticle.h"
+#include "TH2F.h"
+
+//---- AliRoot system ----
+#include "AliAnaChargedParticles.h"
+#include "AliCaloTrackReader.h"
+#include "AliAODPWG4Particle.h"
+#include "AliStack.h"
+#include "AliCaloPID.h"
+#include "AliFidutialCut.h"
+#include "AliAODTrack.h"
+
+ClassImp(AliAnaChargedParticles)
+  
+//____________________________________________________________________________
+  AliAnaChargedParticles::AliAnaChargedParticles() : 
+    AliAnaPartCorrBaseClass(),fPdg(0), fhPt(0),fhPhi(0),fhEta(0), 
+    fhPtPion(0),fhPhiPion(0),fhEtaPion(0),
+    fhPtProton(0),fhPhiProton(0),fhEtaProton(0),
+    fhPtElectron(0),fhPhiElectron(0),fhEtaElectron(0),
+    fhPtKaon(0),fhPhiKaon(0),fhEtaKaon(0),
+    fhPtUnknown(0),fhPhiUnknown(0),fhEtaUnknown(0)
+      
+{
+  //Default Ctor
+
+  //Initialize parameters
+  InitParameters();
+}
+
+//____________________________________________________________________________
+AliAnaChargedParticles::AliAnaChargedParticles(const AliAnaChargedParticles & ch) :   
+  AliAnaPartCorrBaseClass(ch), fPdg(ch.fPdg),  fhPt(ch.fhPt),  fhPhi(ch.fhPhi),fhEta(ch.fhEta), 
+  fhPtPion(ch. fhPtPion),fhPhiPion(ch.fhPhiPion),fhEtaPion(ch.fhEtaPion),
+  fhPtProton(ch.fhPtProton),fhPhiProton(ch.fhPhiProton),fhEtaProton(ch.fhEtaProton),
+  fhPtElectron(ch. fhPtElectron),fhPhiElectron(ch.fhPhiElectron),fhEtaElectron(ch.fhEtaElectron),
+  fhPtKaon(ch. fhPtKaon),fhPhiKaon(ch.fhPhiKaon),fhEtaKaon(ch.fhEtaKaon),
+  fhPtUnknown(ch.fhPtUnknown),fhPhiUnknown(ch.fhPhiUnknown),fhEtaUnknown(ch.fhEtaUnknown)
+  
+{
+  // cpy ctor
+  
+}
+
+//_________________________________________________________________________
+AliAnaChargedParticles & AliAnaChargedParticles::operator = (const AliAnaChargedParticles & ch)
+{
+  // assignment operator
+  
+  if(this == &ch)return *this;
+  ((AliAnaPartCorrBaseClass *)this)->operator=(ch);
+  fPdg = ch.fPdg;
+  fhPt = ch.fhPt;
+  fhPhi = ch.fhPhi;
+  fhEta = ch.fhEta;
+  
+  fhPtPion = ch. fhPtPion; fhPhiPion = ch.fhPhiPion; fhEtaPion = ch.fhEtaPion; 
+  fhPtProton = ch.fhPtProton; fhPhiProton = ch.fhPhiProton; fhEtaProton = ch.fhEtaProton; 
+  fhPtElectron = ch. fhPtElectron; fhPhiElectron = ch.fhPhiElectron; fhEtaElectron = ch.fhEtaElectron; 
+  fhPtKaon = ch. fhPtKaon; fhPhiKaon = ch.fhPhiKaon; fhEtaKaon = ch.fhEtaKaon; 
+  fhPtUnknown = ch.fhPtUnknown; fhPhiUnknown = ch.fhPhiUnknown; fhEtaUnknown = ch.fhEtaUnknown;
+
+  return *this;
+  
+}
+
+//________________________________________________________________________
+TList *  AliAnaChargedParticles::GetCreateOutputObjects()
+{  
+  // Create histograms to be saved in output file and 
+  // store them in fOutputContainer
+  
+  
+  TList * outputContainer = new TList() ; 
+  outputContainer->SetName("ExampleHistos") ; 
+  
+  Int_t nptbins  = GetHistoNPtBins();
+  Int_t nphibins = GetHistoNPhiBins();
+  Int_t netabins = GetHistoNEtaBins();
+  Float_t ptmax  = GetHistoPtMax();
+  Float_t phimax = GetHistoPhiMax();
+  Float_t etamax = GetHistoEtaMax();
+  Float_t ptmin  = GetHistoPtMin();
+  Float_t phimin = GetHistoPhiMin();
+  Float_t etamin = GetHistoEtaMin();   
+  
+  fhPt  = new TH1F ("hPtCharged","p_T distribution", nptbins,ptmin,ptmax); 
+  fhPt->SetXTitle("p_{T} (GeV/c)");
+  outputContainer->Add(fhPt);
+  
+  fhPhi  = new TH2F ("hPhiCharged","#phi distribution",nptbins,ptmin,ptmax, nphibins,phimin,phimax); 
+  fhPhi->SetXTitle("#phi (rad)");
+  outputContainer->Add(fhPhi);
+  
+  fhEta  = new TH2F ("hEtaCharged","#eta distribution",nptbins,ptmin,ptmax, netabins,etamin,etamax); 
+  fhEta->SetXTitle("#eta ");
+  outputContainer->Add(fhEta);
+  
+  
+  if(IsDataMC()){
+    
+    fhPtPion  = new TH1F ("hPtChargedPion","p_T distribution from #pi", nptbins,ptmin,ptmax); 
+    fhPtPion->SetXTitle("p_{T} (GeV/c)");
+    outputContainer->Add(fhPtPion);
+    
+    fhPhiPion  = new TH2F ("hPhiChargedPion","#phi distribution from #pi",nptbins,ptmin,ptmax, nphibins,phimin,phimax); 
+    fhPhiPion->SetXTitle("#phi (rad)");
+    outputContainer->Add(fhPhiPion);
+    
+    fhEtaPion  = new TH2F ("hEtaChargedPion","#eta distribution from #pi",nptbins,ptmin,ptmax, netabins,etamin,etamax); 
+    fhEtaPion->SetXTitle("#eta ");
+    outputContainer->Add(fhEtaPion);
+    
+    fhPtProton  = new TH1F ("hPtChargedProton","p_T distribution from proton", nptbins,ptmin,ptmax); 
+    fhPtProton->SetXTitle("p_{T} (GeV/c)");
+    outputContainer->Add(fhPtProton);
+    
+    fhPhiProton  = new TH2F ("hPhiChargedProton","#phi distribution from proton",nptbins,ptmin,ptmax, nphibins,phimin,phimax); 
+    fhPhiProton->SetXTitle("#phi (rad)");
+    outputContainer->Add(fhPhiProton);
+    
+    fhEtaProton  = new TH2F ("hEtaChargedProton","#eta distribution from proton",nptbins,ptmin,ptmax, netabins,etamin,etamax); 
+    fhEtaProton->SetXTitle("#eta ");
+    outputContainer->Add(fhEtaProton);
+    
+    fhPtKaon  = new TH1F ("hPtChargedKaon","p_T distribution from kaon", nptbins,ptmin,ptmax); 
+    fhPtKaon->SetXTitle("p_{T} (GeV/c)");
+    outputContainer->Add(fhPtKaon);
+    
+    fhPhiKaon  = new TH2F ("hPhiChargedKaon","#phi distribution from kaon",nptbins,ptmin,ptmax, nphibins,phimin,phimax); 
+    fhPhiKaon->SetXTitle("#phi (rad)");
+    outputContainer->Add(fhPhiKaon);
+    
+    fhEtaKaon  = new TH2F ("hEtaChargedKaon","#eta distribution from kaon",nptbins,ptmin,ptmax, netabins,etamin,etamax); 
+    fhEtaKaon->SetXTitle("#eta ");
+    outputContainer->Add(fhEtaKaon);
+    
+    
+    fhPtElectron  = new TH1F ("hPtChargedElectron","p_T distribution from electron", nptbins,ptmin,ptmax); 
+    fhPtElectron->SetXTitle("p_{T} (GeV/c)");
+    outputContainer->Add(fhPtElectron);
+    
+    fhPhiElectron  = new TH2F ("hPhiChargedElectron","#phi distribution from electron",nptbins,ptmin,ptmax, nphibins,phimin,phimax); 
+    fhPhiElectron->SetXTitle("#phi (rad)");
+    outputContainer->Add(fhPhiElectron);
+    
+    fhEtaElectron  = new TH2F ("hEtaChargedElectron","#eta distribution from electron",nptbins,ptmin,ptmax, netabins,etamin,etamax); 
+    fhEtaElectron->SetXTitle("#eta ");
+    outputContainer->Add(fhEtaElectron);
+    
+    fhPtUnknown  = new TH1F ("hPtChargedUnknown","p_T distribution from unknown", nptbins,ptmin,ptmax); 
+    fhPtUnknown->SetXTitle("p_{T} (GeV/c)");
+    outputContainer->Add(fhPtUnknown);
+    
+    fhPhiUnknown  = new TH2F ("hPhiChargedUnknown","#phi distribution from unknown",nptbins,ptmin,ptmax, nphibins,phimin,phimax); 
+    fhPhiUnknown->SetXTitle("#phi (rad)");
+    outputContainer->Add(fhPhiUnknown);
+    
+    fhEtaUnknown  = new TH2F ("hEtaChargedUnknown","#eta distribution from unknown",nptbins,ptmin,ptmax, netabins,etamin,etamax); 
+    fhEtaUnknown->SetXTitle("#eta ");
+    outputContainer->Add(fhEtaUnknown);
+    
+  }
+  return outputContainer;
+}
+
+//__________________________________________________
+void AliAnaChargedParticles::InitParameters()
+{ 
+  //Initialize the parameters of the analysis.
+  SetOutputAODClassName("AliAODPWG4Particle");
+  SetOutputAODName("Charged");
+  fPdg = -1; //Select all tracks 
+  
+}
+
+//__________________________________________________________________
+void AliAnaChargedParticles::Print(const Option_t * opt) const
+{
+  //Print some relevant parameters set for the analysis
+  if(! opt)
+    return;
+  
+  printf("Min Pt = %3.2f\n", GetMinPt());
+  printf("Max Pt = %3.2f\n", GetMaxPt());
+  printf("Select clusters with pdg %d \n",fPdg);
+  
+} 
+
+//____________________________________________________________________________
+void AliAnaChargedParticles::Init()
+{  
+  //Init
+  //Do some checks
+  if(!GetReader()->IsCTSSwitchedOn()){
+    printf("!!ABORT: You want to use CTS tracks in analysis but not read!! \n!!Check the configuration file!!\n");
+    abort();
+  }
+  
+}
+
+//__________________________________________________________________
+void  AliAnaChargedParticles::MakeAnalysisFillAOD() 
+{
+  //Do analysis and fill aods
+  if(!GetAODCTS() || GetAODCTS()->GetEntriesFast() == 0) return ;
+  Int_t ntracks = GetAODCTS()->GetEntriesFast();
+  
+  //Some prints
+  if(GetDebug() > 0)
+    printf("AliAnaChargedParticles : in CTS aod entries %d\n", ntracks);
+  
+  //Fill AODParticle with CTS aods
+  TVector3 p3;
+  for(Int_t i = 0; i < ntracks; i++){
+    
+    AliAODTrack * track =  (AliAODTrack*) (GetAODCTS()->At(i));
+    
+    //Fill AODParticle after some selection       
+    Double_t mom[3] = {track->Px(),track->Py(),track->Pz()};
+    p3.SetXYZ(mom[0],mom[1],mom[2]);
+    
+    //Acceptance selection
+    Bool_t in =  GetFidutialCut()->IsInFidutialCut(mom,"CTS") ;
+    if(GetDebug() > 1) printf("track pt %2.2f, phi %2.2f, in fidutial cut %d\n",p3.Pt(), p3.Phi(), in);
+    if(p3.Pt() > GetMinPt() && in) {
+      //Keep only particles identified with fPdg
+      //Selection not done for the moment
+      //Should be done here.
+      
+      AliAODPWG4Particle tr = AliAODPWG4Particle(mom[0],mom[1],mom[2],0);
+      tr.SetDetector("CTS");
+      tr.SetLabel(track->GetLabel());
+      tr.SetTrackLabel(track->GetID(),-1);
+      AddAODParticle(tr);
+    }//selection
+  }//loop
+  
+  if(GetDebug() > 0)   
+    printf("AliAnaChargedParticles: final aod branch entries %d\n", GetOutputAODBranch()->GetEntriesFast());   
+} 
+
+//__________________________________________________________________
+void  AliAnaChargedParticles::MakeAnalysisFillHistograms() 
+{
+  //Do analysis and fill histograms
+  
+  //Loop on stored AODParticles
+  Int_t naod = GetOutputAODBranch()->GetEntriesFast();
+  if(GetDebug() > 0) printf("AliAnaChargedParticles::histo aod branch entries %d\n", naod);
+  for(Int_t iaod = 0; iaod < naod ; iaod++){
+    AliAODPWG4Particle* tr =  (AliAODPWG4Particle*) (GetOutputAODBranch()->At(iaod));
+    
+    fhPt->Fill(tr->Pt());
+    fhPhi->Fill(tr->Pt(), tr->Phi());
+    fhEta->Fill(tr->Pt(), tr->Eta());
+    
+    if(IsDataMC()){
+      //Play with the MC stack if available            
+      TParticle * mom = GetMCStack()->Particle(tr->GetLabel());
+      Int_t mompdg =TMath::Abs(mom->GetPdgCode());
+      
+      if(mompdg==211){
+       fhPtPion->Fill(tr->Pt());
+       fhPhiPion->Fill(tr->Pt(), tr->Phi());
+       fhEtaPion->Fill(tr->Pt(), tr->Eta());
+      }
+      else if(mompdg==2212){
+       fhPtProton->Fill(tr->Pt());
+       fhPhiProton->Fill(tr->Pt(), tr->Phi());
+       fhEtaProton->Fill(tr->Pt(), tr->Eta());
+      }
+      else if(mompdg==321){
+       fhPtKaon->Fill(tr->Pt());
+       fhPhiKaon->Fill(tr->Pt(), tr->Phi());
+       fhEtaKaon->Fill(tr->Pt(), tr->Eta());
+      }
+      else if(mompdg==11){
+       fhPtElectron->Fill(tr->Pt());
+       fhPhiElectron->Fill(tr->Pt(), tr->Phi());
+       fhEtaElectron->Fill(tr->Pt(), tr->Eta());
+      }
+      else {
+       //printf("unknown pdg %d\n",mompdg);
+       fhPtUnknown->Fill(tr->Pt());
+       fhPhiUnknown->Fill(tr->Pt(), tr->Phi());
+       fhEtaUnknown->Fill(tr->Pt(), tr->Eta());
+      }
+    }//Work with stack also
+  }// aod branch loop
+  
+}
diff --git a/PWG4/PartCorrDep/AliAnaChargedParticles.h b/PWG4/PartCorrDep/AliAnaChargedParticles.h
new file mode 100755 (executable)
index 0000000..78d264e
--- /dev/null
@@ -0,0 +1,81 @@
+#ifndef ALIANACHARGEDPARTICLES_H
+#define ALIANACHARGEDPARTICLES_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice     */
+/* $Id: $ */
+
+//_________________________________________________________________________
+// Example class on how to read AODCaloClusters, ESDCaloCells and AODTracks and how 
+// fill AODs with PWG4PartCorr analysis frame
+// Select the type of detector information that you want to analyze, CTS (tracking), PHOS or EMCAL
+// Select the PID custer type of the calorimeters
+// Set min momentum of the cluster/tracks
+// Fill few histograms
+//
+//-- Author: Gustavo Conesa (INFN-LNF)
+
+class TH2F; 
+#include "AliAnaPartCorrBaseClass.h"
+class AliAnaChargedParticles : public AliAnaPartCorrBaseClass {
+  
+ public: 
+  
+  AliAnaChargedParticles() ; // default ctor
+  AliAnaChargedParticles(const AliAnaChargedParticles & g) ; // cpy ctor
+  AliAnaChargedParticles & operator = (const AliAnaChargedParticles & g) ;//cpy assignment
+  virtual ~AliAnaChargedParticles() {;} //virtual dtor
+  
+  TList * GetCreateOutputObjects();
+  
+  void Init();
+  void InitParameters();
+  
+  void Print(const Option_t * opt) const;
+  
+  void MakeAnalysisFillAOD()  ;
+  
+  void MakeAnalysisFillHistograms() ; 
+  
+  Int_t GetPdgOfSelectedCharged() const {return fPdg ;}
+  void SelectChargedWithPdg( Int_t pdg ) {fPdg = pdg; }
+  
+  //void Terminate();
+  
+ private:
+  
+  Int_t  fPdg ; //identified particle id
+  //Histograms 
+  TH1F * fhPt; //! pT distribution
+  TH2F * fhPhi; //! phi distribution vs pT
+  TH2F * fhEta; //! eta distribution vs pT
+  
+  //MC
+  TH1F * fhPtPion; //! pT distribution
+  TH2F * fhPhiPion; //! phi distribution vs pT
+  TH2F * fhEtaPion; //! eta distribution vs pT
+  
+  TH1F * fhPtProton; //! pT distribution
+  TH2F * fhPhiProton; //! phi distribution vs pT
+  TH2F * fhEtaProton; //! eta distribution vs pT
+  
+  TH1F * fhPtElectron; //! pT distribution
+  TH2F * fhPhiElectron; //! phi distribution vs pT
+  TH2F * fhEtaElectron; //! eta distribution vs pT
+  
+  TH1F * fhPtKaon; //! pT distribution
+  TH2F * fhPhiKaon; //! phi distribution vs pT
+  TH2F * fhEtaKaon; //! eta distribution vs pT
+  
+  TH1F * fhPtUnknown; //! pT distribution
+  TH2F * fhPhiUnknown; //! phi distribution vs pT
+  TH2F * fhEtaUnknown; //! eta distribution vs pT
+  
+  ClassDef(AliAnaChargedParticles,1)
+    } ;
+
+
+#endif //ALIANACHARGEDPARTICLES_H
+
+
+
index b26c5ea1f679f64624f5017842afa570843cbd96..32c62d315f091478e17c4fae9e33ebd79f28a78c 100755 (executable)
 
 // --- ROOT system ---
 //#include "Riostream.h"
-#include "TClonesArray.h"
+#include "TRefArray.h"
 #include "TParticle.h"
 #include "TCanvas.h"
 #include "TPad.h"
 #include "TROOT.h"
+#include "TH2F.h"
 
 //---- AliRoot system ----
 #include "AliAnaExample.h"
 #include "AliCaloTrackReader.h"
-#include "AliLog.h"
 #include "AliAODPWG4Particle.h"
 #include "AliESDCaloCells.h"
 #include "AliStack.h"
 #include "AliCaloPID.h"
+#include "AliFidutialCut.h"
+#include "AliAODCaloCells.h"
+#include "AliAODCaloCluster.h"
+#include "AliAODTrack.h"
 
 ClassImp(AliAnaExample)
   
@@ -100,69 +104,67 @@ AliAnaExample & AliAnaExample::operator = (const AliAnaExample & ex)
 //________________________________________________________________________
 TList *  AliAnaExample::GetCreateOutputObjects()
 {  
-       // Create histograms to be saved in output file and 
-       // store them in fOutputContainer
-       
-       AliDebug(1,"Init parton histograms");
-       
-       TList * outputContainer = new TList() ; 
-       outputContainer->SetName("ExampleHistos") ; 
-       
-       Int_t nptbins  = GetHistoNPtBins();
-       Int_t nphibins = GetHistoNPhiBins();
-       Int_t netabins = GetHistoNEtaBins();
-       Float_t ptmax  = GetHistoPtMax();
-       Float_t phimax = GetHistoPhiMax();
-       Float_t etamax = GetHistoEtaMax();
-       Float_t ptmin  = GetHistoPtMin();
-       Float_t phimin = GetHistoPhiMin();
-       Float_t etamin = GetHistoEtaMin();      
-       
-       fhPt  = new TH1F ("hPt","p_T distribution", nptbins,ptmin,ptmax); 
-       fhPt->SetXTitle("p_{T} (GeV/c)");
-       outputContainer->Add(fhPt);
-       
-       fhPhi  = new TH1F ("hPhi","#phi distribution",nphibins,phimin,phimax); 
-       fhPhi->SetXTitle("#phi (rad)");
-       outputContainer->Add(fhPhi);
-       
-       fhEta  = new TH1F ("hEta","#eta distribution",netabins,etamin,etamax); 
-       fhEta->SetXTitle("#eta ");
-       outputContainer->Add(fhEta);
-       
-       if(GetReader()->GetDataType()!= AliCaloTrackReader::kMC) {
-               
-               //Calo cells
-               fhNCells  = new TH1F ("hNCells","# cells per event", 100,0,1000); 
-               fhNCells->SetXTitle("n cells");
-               outputContainer->Add(fhNCells);
-               
-               fhAmplitude  = new TH1F ("hAmplitude","#eta distribution", 100,0,1000); 
-               fhAmplitude->SetXTitle("Amplitude ");
-               outputContainer->Add(fhAmplitude);
-       } 
-       
-       if(IsDataMC()){
-               fh2Pt  = new TH2F ("h2Pt","p_T distribution, reconstructed vs generated", nptbins,ptmin,ptmax,nptbins,ptmin,ptmax); 
-               fh2Pt->SetXTitle("p_{T,rec} (GeV/c)");
-               fh2Pt->SetYTitle("p_{T,gen} (GeV/c)");
-               outputContainer->Add(fh2Pt);
-               
-               fh2Phi  = new TH2F ("h2Phi","#phi distribution, reconstructed vs generated", nphibins,phimin,phimax, nphibins,phimin,phimax); 
-               fh2Phi->SetXTitle("#phi_{rec} (rad)");
-               fh2Phi->SetYTitle("#phi_{gen} (rad)");
-               outputContainer->Add(fh2Phi);
-               
-               fh2Eta  = new TH2F ("h2Eta","#eta distribution, reconstructed vs generated", netabins,etamin,etamax,netabins,etamin,etamax); 
-               fh2Eta->SetXTitle("#eta_{rec} ");
-               fh2Eta->SetYTitle("#eta_{gen} ");
-               outputContainer->Add(fh2Eta);
-               
-       }
-       return outputContainer;
+  // Create histograms to be saved in output file and 
+  // store them in fOutputContainer
+    
+  TList * outputContainer = new TList() ; 
+  outputContainer->SetName("ExampleHistos") ; 
+  
+  Int_t nptbins  = GetHistoNPtBins();
+  Int_t nphibins = GetHistoNPhiBins();
+  Int_t netabins = GetHistoNEtaBins();
+  Float_t ptmax  = GetHistoPtMax();
+  Float_t phimax = GetHistoPhiMax();
+  Float_t etamax = GetHistoEtaMax();
+  Float_t ptmin  = GetHistoPtMin();
+  Float_t phimin = GetHistoPhiMin();
+  Float_t etamin = GetHistoEtaMin();   
+  
+  fhPt  = new TH1F ("hPt","p_T distribution", nptbins,ptmin,ptmax); 
+  fhPt->SetXTitle("p_{T} (GeV/c)");
+  outputContainer->Add(fhPt);
+  
+  fhPhi  = new TH1F ("hPhi","#phi distribution",nphibins,phimin,phimax); 
+  fhPhi->SetXTitle("#phi (rad)");
+  outputContainer->Add(fhPhi);
+  
+  fhEta  = new TH1F ("hEta","#eta distribution",netabins,etamin,etamax); 
+  fhEta->SetXTitle("#eta ");
+  outputContainer->Add(fhEta);
+  
+  if(GetReader()->GetDataType()!= AliCaloTrackReader::kMC) {
+    
+    //Calo cells
+    fhNCells  = new TH1F ("hNCells","# cells per event", 100,0,1000); 
+    fhNCells->SetXTitle("n cells");
+    outputContainer->Add(fhNCells);
+    
+    fhAmplitude  = new TH1F ("hAmplitude","#eta distribution", 100,0,1000); 
+    fhAmplitude->SetXTitle("Amplitude ");
+    outputContainer->Add(fhAmplitude);
+  } 
+  
+  if(IsDataMC()){
+    fh2Pt  = new TH2F ("h2Pt","p_T distribution, reconstructed vs generated", nptbins,ptmin,ptmax,nptbins,ptmin,ptmax); 
+    fh2Pt->SetXTitle("p_{T,rec} (GeV/c)");
+    fh2Pt->SetYTitle("p_{T,gen} (GeV/c)");
+    outputContainer->Add(fh2Pt);
+    
+    fh2Phi  = new TH2F ("h2Phi","#phi distribution, reconstructed vs generated", nphibins,phimin,phimax, nphibins,phimin,phimax); 
+    fh2Phi->SetXTitle("#phi_{rec} (rad)");
+    fh2Phi->SetYTitle("#phi_{gen} (rad)");
+    outputContainer->Add(fh2Phi);
+    
+    fh2Eta  = new TH2F ("h2Eta","#eta distribution, reconstructed vs generated", netabins,etamin,etamax,netabins,etamin,etamax); 
+    fh2Eta->SetXTitle("#eta_{rec} ");
+    fh2Eta->SetYTitle("#eta_{gen} ");
+    outputContainer->Add(fh2Eta);
+    
+  }
+  return outputContainer;
 }
 
- //__________________________________________________
+//__________________________________________________
 void AliAnaExample::InitParameters()
 { 
   //Initialize the parameters of the analysis.
@@ -190,198 +192,191 @@ void AliAnaExample::Print(const Option_t * opt) const
 //__________________________________________________________________
 void  AliAnaExample::MakeAnalysisFillAOD() 
 {
-       //Do analysis and fill aods
-       
-       //Some prints
-       if(GetDebug() > 0){
-               if(fDetector == "EMCAL" && GetAODEMCAL())printf("Example : in EMCAL aod entries %d\n", GetAODEMCAL()->GetEntriesFast());
-               if(fDetector == "CTS" && GetAODCTS())printf("Example : in CTS aod entries %d\n", GetAODCTS()->GetEntriesFast());
-               if(fDetector == "PHOS" && GetAODPHOS())printf("Example : in PHOS aod entries %d\n", GetAODPHOS()->GetEntriesFast());
-       }
-       
-       //Get List with tracks or clusters  
-       TClonesArray * partList = new TClonesArray;
-       if(fDetector == "CTS") partList = GetAODCTS();
-       else if(fDetector == "EMCAL") partList = GetAODEMCAL();
-       else if(fDetector == "PHOS") partList = GetAODPHOS();
-       
-       if(!partList || partList->GetEntriesFast() == 0) return ;
-       
-       //Fill AODCaloClusters and AODParticle with PHOS/EMCAL aods
-       if(fDetector == "EMCAL" || fDetector == "PHOS"){
-               
-               //WORK WITH CALOCLUSTERS 
-               if(GetReader()->GetDataType()!= AliCaloTrackReader::kMC){ 
-                       ConnectAODCaloClusters(); //Do Only when filling AODCaloClusters 
-                       if(GetDebug() > 0) printf("Example: in calo clusters aod entries %d\n", GetAODCaloClusters()->GetEntriesFast());
-               }
-               //Get vertex for photon momentum calculation
-               Double_t v[3] ; //vertex ;
-               GetReader()->GetVertex(v);
-               
-               TLorentzVector mom ;
-               for(Int_t i = 0; i < partList->GetEntriesFast(); i++){
-                       
-                       AliAODCaloCluster * calo =  (AliAODCaloCluster*) (partList->At(i));
-                       
-                       //Fill AODCaloClusters  
-                       if(GetReader()->GetDataType()!= AliCaloTrackReader::kMC) 
-                               AddAODCaloCluster(AliAODCaloCluster(*(calo)));
-                       
-                       //Fill AODParticle after some selection
-                       calo->GetMomentum(mom,v);
-                       Int_t pdg = fPdg;
-                       
-                       if(IsCaloPIDOn()){
-                               Double_t pid[13];
-                               calo->GetPID(pid);
-                               pdg = GetCaloPID()->GetPdg(fDetector,pid,mom.E());
-                               //pdg = GetCaloPID()->GetPdg(fDetector,mom,
-                               //                calo->GetM02(), calo->GetM02(),
-                               //                calo->GetDispersion(), 0, 0); 
-                       }
-                       
-                       //Acceptance selection   
-                       Bool_t in = kTRUE;
-                       if(IsFidutialCutOn())
-                               in =  GetFidutialCut()->IsInFidutialCut(mom,fDetector) ;
-                       
-                       if(GetDebug() > 1) printf("cluster pt %2.2f, phi %2.2f, pdg %d, in fidutial cut %d \n",mom.Pt(), mom.Phi(), pdg, in);
-                       
-                       //Select cluster if momentum, pdg and acceptance are good
-                       if(mom.Pt() > GetMinPt() && pdg ==fPdg && in) {
-                               AliAODPWG4Particle ph = AliAODPWG4Particle(mom);
-                               //AddAODParticleCorrelation(AliAODPWG4ParticleCorrelation(mom));
-                               ph.SetLabel(calo->GetLabel(0));
-                               ph.SetPdg(pdg);
-                               ph.SetDetector(fDetector);
-                               AddAODParticle(ph);
-                       }//selection
-               }//loop
-               
-               if(GetReader()->GetDataType()!= AliCaloTrackReader::kMC) {
-                       //WORK WITH ESDCALOCELLS
-                       //Don't connect in the same analysis PHOS and EMCAL cells.
-                       
-                       AliESDCaloCells * esdCell = new AliESDCaloCells ;
-                       if(fDetector == "PHOS") {
-                               ConnectAODPHOSCells(); //Do Only when filling AODCaloCells
-                               esdCell = (AliESDCaloCells *) GetPHOSCells();
-                       }
-                       else  {
-                               ConnectAODEMCALCells(); //Do Only when filling AODCaloCells
-                               esdCell = (AliESDCaloCells *) GetEMCALCells();
-                       }
-                       
-                       if(!esdCell) AliFatal("No CELLS available for analysis");
-                       
-                       //Some prints
-                       if(GetDebug() > 0 && esdCell )
-                               printf("Example : in ESD %s cell entries %d\n", fDetector.Data(), esdCell->GetNumberOfCells());    
-                       
-                       //Fill AODCells in file
-                       Int_t ncells = esdCell->GetNumberOfCells() ;
-                       GetAODCaloCells()->CreateContainer(ncells);
-                       
-                       GetAODCaloCells()->SetType((AliAODCaloCells::AODCells_t) esdCell->GetType());
-                       
-                       for (Int_t iCell = 0; iCell < ncells; iCell++) {      
-                               if(GetDebug() > 2)  printf("cell : amp %f, absId %d,  time %f\n", esdCell->GetAmplitude(iCell), esdCell->GetCellNumber(iCell), esdCell->GetTime(iCell));
-                               
-                               GetAODCaloCells()->SetCell(iCell,esdCell->GetCellNumber(iCell),esdCell->GetAmplitude(iCell));
-                       }
-                       GetAODCaloCells()->Sort();
-               } 
-       }//cluster-cell analysis
-       else if(fDetector == "CTS"){ //Track analysis
-               //Fill AODParticle with CTS aods
-               TVector3 p3;
-               for(Int_t i = 0; i < GetAODCTS()->GetEntriesFast(); i++){
-                       
-                       AliAODTrack * track =  (AliAODTrack*) (GetAODCTS()->At(i));
-                       
-                       //Fill AODParticle after some selection       
-                       Double_t mom[3] = {track->Px(),track->Py(),track->Pz()};
-                       p3.SetXYZ(mom[0],mom[1],mom[2]);
-                       
-                       //Acceptance selection
-                       Bool_t in =  GetFidutialCut()->IsInFidutialCut(mom,"CTS") ;
-                       if(GetDebug() > 1) printf("track pt %2.2f, phi %2.2f, in fidutial cut %d\n",p3.Pt(), p3.Phi(), in);
-                       if(p3.Pt() > GetMinPt() && in) {
-                               AliAODPWG4Particle tr = AliAODPWG4Particle(mom[0],mom[1],mom[2],0);
-                               tr.SetDetector("CTS");
-                               AddAODParticle(tr);
-                       }//selection
-               }//loop
-       }//CTS analysis
+  //Do analysis and fill aods
+  
+  //Some prints
+  if(GetDebug() > 0){
+    if(fDetector == "EMCAL" && GetAODEMCAL())printf("Example : in EMCAL aod entries %d\n", GetAODEMCAL()->GetEntriesFast());
+    if(fDetector == "CTS" && GetAODCTS())printf("Example : in CTS aod entries %d\n", GetAODCTS()->GetEntriesFast());
+    if(fDetector == "PHOS" && GetAODPHOS())printf("Example : in PHOS aod entries %d\n", GetAODPHOS()->GetEntriesFast());
+  }
+  
+  //Get List with tracks or clusters  
+  TRefArray * partList = new TRefArray();
+  if(fDetector == "CTS") partList = GetAODCTS();
+  else if(fDetector == "EMCAL") partList = GetAODEMCAL();
+  else if(fDetector == "PHOS") partList = GetAODPHOS();
+  
+  if(!partList || partList->GetEntriesFast() == 0) return ;
+  
+  //Fill AODCaloClusters and AODParticle with PHOS/EMCAL aods
+  if(fDetector == "EMCAL" || fDetector == "PHOS"){
+    
+    //Get vertex for photon momentum calculation
+    Double_t v[3] ; //vertex ;
+    GetReader()->GetVertex(v);
+    
+    TLorentzVector mom ;
+    for(Int_t i = 0; i < partList->GetEntriesFast(); i++){
+      
+      AliAODCaloCluster * calo =  (AliAODCaloCluster*) (partList->At(i));
+      
+      //Fill AODParticle after some selection
+      calo->GetMomentum(mom,v);
+      Int_t pdg = fPdg;
+      
+      if(IsCaloPIDOn()){
+       Double_t pid[13];
+       calo->GetPID(pid);
+       pdg = GetCaloPID()->GetPdg(fDetector,pid,mom.E());
+       //pdg = GetCaloPID()->GetPdg(fDetector,mom,
+       //                calo->GetM02(), calo->GetM02(),
+       //                calo->GetDispersion(), 0, 0); 
+      }
+      
+      //Acceptance selection   
+      Bool_t in = kTRUE;
+      if(IsFidutialCutOn())
+       in =  GetFidutialCut()->IsInFidutialCut(mom,fDetector) ;
+      
+      if(GetDebug() > 1) printf("cluster pt %2.2f, phi %2.2f, pdg %d, in fidutial cut %d \n",mom.Pt(), mom.Phi(), pdg, in);
+      
+      //Select cluster if momentum, pdg and acceptance are good
+      if(mom.Pt() > GetMinPt() && pdg ==fPdg && in) {
+       AliAODPWG4Particle ph = AliAODPWG4Particle(mom);
+       //AddAODParticleCorrelation(AliAODPWG4ParticleCorrelation(mom));
+       ph.SetLabel(calo->GetLabel(0));
+       ph.SetPdg(pdg);
+       ph.SetDetector(fDetector);
+       AddAODParticle(ph);
+      }//selection
+    }//loop
+    
+    if(GetReader()->GetDataType()!= AliCaloTrackReader::kMC) {
+      //WORK WITH ESDCALOCELLS
+      //Don't connect in the same analysis PHOS and EMCAL cells.
+      
+      AliESDCaloCells * esdCell = new AliESDCaloCells ;
+      if(fDetector == "PHOS") {
+       //ConnectAODPHOSCells(); //Do Only when filling AODCaloCells
+       esdCell = (AliESDCaloCells *) GetPHOSCells();
+      }
+      else  {
+       //ConnectAODEMCALCells(); //Do Only when filling AODCaloCells
+       esdCell = (AliESDCaloCells *) GetEMCALCells();
+      }
+      
+      if(!esdCell) {
+       printf("FillAOD ABORT: No CELLS available for analysis");
+       abort();
+      }
+      //Some prints
+      if(GetDebug() > 0 && esdCell )
+       printf("Example : in ESD %s cell entries %d\n", fDetector.Data(), esdCell->GetNumberOfCells());    
+      
+      //Fill AODCells in file
+      Int_t ncells = esdCell->GetNumberOfCells() ;
+      GetAODCaloCells()->CreateContainer(ncells);
+      
+      GetAODCaloCells()->SetType((AliAODCaloCells::AODCells_t) esdCell->GetType());
+      
+      for (Int_t iCell = 0; iCell < ncells; iCell++) {      
+       if(GetDebug() > 2)  printf("cell : amp %f, absId %d,  time %f\n", esdCell->GetAmplitude(iCell), esdCell->GetCellNumber(iCell), esdCell->GetTime(iCell));
        
-       if(GetDebug() > 0) {
-               if(fDetector!="CTS" && GetReader()->GetDataType()!= AliCaloTrackReader::kMC) 
-                       printf("Example: final aod calocluster entries %d\n", GetAODCaloClusters()->GetEntriesFast());
-               printf("Example: final aod branch entries %d\n", GetOutputAODBranch()->GetEntriesFast());  
-               //      if(fDetector!="CTS" && GetReader()->GetDataType()!= AliCaloTrackReader::kMC) 
-               //printf("Example: final aod cell  entries %d\n", GetAODCaloCells()->GetNumberOfCells());
-       }
+       GetAODCaloCells()->SetCell(iCell,esdCell->GetCellNumber(iCell),esdCell->GetAmplitude(iCell));
+      }
+      GetAODCaloCells()->Sort();
+    } 
+  }//cluster-cell analysis
+  else if(fDetector == "CTS"){ //Track analysis
+    //Fill AODParticle with CTS aods
+    TVector3 p3;
+    for(Int_t i = 0; i < GetAODCTS()->GetEntriesFast(); i++){
+      
+      AliAODTrack * track =  (AliAODTrack*) (GetAODCTS()->At(i));
+      
+      //Fill AODParticle after some selection       
+      Double_t mom[3] = {track->Px(),track->Py(),track->Pz()};
+      p3.SetXYZ(mom[0],mom[1],mom[2]);
+      
+      //Acceptance selection
+      Bool_t in =  GetFidutialCut()->IsInFidutialCut(mom,"CTS") ;
+      if(GetDebug() > 1) printf("track pt %2.2f, phi %2.2f, in fidutial cut %d\n",p3.Pt(), p3.Phi(), in);
+      if(p3.Pt() > GetMinPt() && in) {
+       AliAODPWG4Particle tr = AliAODPWG4Particle(mom[0],mom[1],mom[2],0);
+       tr.SetDetector("CTS");
+       AddAODParticle(tr);
+      }//selection
+    }//loop
+  }//CTS analysis
+  
+  if(GetDebug() > 0) {
+    if(fDetector!="CTS" && GetReader()->GetDataType()!= AliCaloTrackReader::kMC) 
+      //printf("Example: final aod calocluster entries %d\n", GetAODCaloClusters()->GetEntriesFast());
+      printf("Example: final aod branch entries %d\n", GetOutputAODBranch()->GetEntriesFast());  
+    // if(fDetector!="CTS" && GetReader()->GetDataType()!= AliCaloTrackReader::kMC) 
+    //printf("Example: final aod cell  entries %d\n", GetAODCaloCells()->GetNumberOfCells());
+  }
 } 
 
 //__________________________________________________________________
 void  AliAnaExample::MakeAnalysisFillHistograms() 
 {
-       //Do analysis and fill histograms
-       
-       //Loop on stored AODParticles
-       Int_t naod = GetOutputAODBranch()->GetEntriesFast();
-       if(GetDebug() > 0) printf("histo aod branch entries %d\n", naod);
-       for(Int_t iaod = 0; iaod < naod ; iaod++){
-               AliAODPWG4Particle* ph =  (AliAODPWG4Particle*) (GetOutputAODBranch()->At(iaod));
-               
-               fhPt->Fill(ph->Pt());
-               fhPhi->Fill(ph->Phi());
-               fhEta->Fill(ph->Eta());
-               
-               if(IsDataMC()){
-                       //Play with the MC stack if available
-                       AliStack * stack =  GetMCStack() ;
-                       
-                       if(ph->GetLabel() < 0 || !stack) {
-                               printf("*** bad label or no stack ***:  label %d \n", ph->GetLabel());
-                               continue;
-                       }
-                       
-                       if(ph->GetLabel() >=  stack->GetNtrack()) {
-                               printf("*** large label ***:  label %d, n tracks %d \n", ph->GetLabel(), stack->GetNtrack());
-                               continue ;
-                       }
-                       
-                       TParticle * mom = GetMCStack()->Particle(ph->GetLabel());
-                       
-                       fh2Pt->Fill(ph->Pt(), mom->Pt());
-                       fh2Phi->Fill(ph->Phi(), mom->Phi());
-                       fh2Eta->Fill(ph->Eta(), mom->Eta());
-               }//Work with stack also
-       }// aod branch loop
-       
-       // CaloCells histograms
-       if(GetReader()->GetDataType()!= AliCaloTrackReader::kMC) {
-               if(GetAODCaloCells()){
-                       
-                       Int_t ncells = GetAODCaloCells()->GetNumberOfCells();
-                       fhNCells->Fill(ncells) ;
-                       
-                       for (Int_t iCell = 0; iCell < ncells; iCell++) {      
-                               if(GetDebug() > 2)  printf("cell : amp %f, absId %d \n", GetAODCaloCells()->GetAmplitude(iCell), GetAODCaloCells()->GetCellNumber(iCell));
-                               fhAmplitude->Fill(GetAODCaloCells()->GetAmplitude(iCell));
-                       }
-               }//calo cells container exist
-       }
+  //Do analysis and fill histograms
+  
+  //Loop on stored AODParticles
+  Int_t naod = GetOutputAODBranch()->GetEntriesFast();
+  if(GetDebug() > 0) printf("histo aod branch entries %d\n", naod);
+  for(Int_t iaod = 0; iaod < naod ; iaod++){
+    AliAODPWG4Particle* ph =  (AliAODPWG4Particle*) (GetOutputAODBranch()->At(iaod));
+    
+    fhPt->Fill(ph->Pt());
+    fhPhi->Fill(ph->Phi());
+    fhEta->Fill(ph->Eta());
+    
+    if(IsDataMC()){
+      //Play with the MC stack if available
+      AliStack * stack =  GetMCStack() ;
+      
+      if(ph->GetLabel() < 0 || !stack) {
+       printf("*** bad label or no stack ***:  label %d \n", ph->GetLabel());
+       continue;
+      }
+      
+      if(ph->GetLabel() >=  stack->GetNtrack()) {
+       printf("*** large label ***:  label %d, n tracks %d \n", ph->GetLabel(), stack->GetNtrack());
+       continue ;
+      }
+      
+      TParticle * mom = GetMCStack()->Particle(ph->GetLabel());
+      
+      fh2Pt->Fill(ph->Pt(), mom->Pt());
+      fh2Phi->Fill(ph->Phi(), mom->Phi());
+      fh2Eta->Fill(ph->Eta(), mom->Eta());
+    }//Work with stack also
+  }// aod branch loop
+  
+  // CaloCells histograms
+  if(GetReader()->GetDataType()!= AliCaloTrackReader::kMC) {
+    if(GetAODCaloCells()){
+      
+      Int_t ncells = GetAODCaloCells()->GetNumberOfCells();
+      fhNCells->Fill(ncells) ;
+      
+      for (Int_t iCell = 0; iCell < ncells; iCell++) {      
+       if(GetDebug() > 2)  printf("cell : amp %f, absId %d \n", GetAODCaloCells()->GetAmplitude(iCell), GetAODCaloCells()->GetCellNumber(iCell));
+       fhAmplitude->Fill(GetAODCaloCells()->GetAmplitude(iCell));
+      }
+    }//calo cells container exist
+  }
 }
 
 //__________________________________________________________________
 void  AliAnaExample::Terminate() 
 {
-
+  
   //Do some plots to end
-
+  
   printf(" *** %s Report:", GetName()) ; 
   printf("        pt         : %5.3f , RMS : %5.3f \n", fhPt->GetMean(),   fhPt->GetRMS() ) ;
  
index a034079c6b00a527d72c6621c64902ce6856f613..891a4110a22275b0720cfd01601013da7c6de7fe 100755 (executable)
 //
 //-- Author: Gustavo Conesa (INFN-LNF)
 
-#include "TH2F.h" 
+// --- Root system ---