Move from ESD and AOD readers the common methods for centrality, v0 and B field acces...
authorgconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 28 Feb 2011 21:44:53 +0000 (21:44 +0000)
committergconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 28 Feb 2011 21:44:53 +0000 (21:44 +0000)
23 files changed:
PWG4/PartCorrBase/AliAnaPartCorrBaseClass.cxx
PWG4/PartCorrBase/AliAnaPartCorrBaseClass.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/PartCorrDep/AliAnaBtag.cxx
PWG4/PartCorrDep/AliAnaCalorimeterQA.cxx
PWG4/PartCorrDep/AliAnaChargedParticles.cxx
PWG4/PartCorrDep/AliAnaElectron.cxx
PWG4/PartCorrDep/AliAnaExample.cxx
PWG4/PartCorrDep/AliAnaParticleHadronCorrelation.cxx
PWG4/PartCorrDep/AliAnaParticleIsolation.cxx
PWG4/PartCorrDep/AliAnaParticleJetFinderCorrelation.cxx
PWG4/PartCorrDep/AliAnaParticleJetLeadingConeCorrelation.cxx
PWG4/PartCorrDep/AliAnaPhoton.cxx
PWG4/PartCorrDep/AliAnaPi0.cxx
PWG4/PartCorrDep/AliAnaPi0EbE.cxx
PWG4/PartCorrDep/AliAnaShowerParameter.cxx

index 4c6556f..fe04623 100755 (executable)
@@ -265,26 +265,26 @@ void AliAnaPartCorrBaseClass::ConnectInputOutputAODBranches() {
 //}
 //
 //__________________________________________________
-TObjArray *  AliAnaPartCorrBaseClass::GetAODCTS() const {
+TObjArray *  AliAnaPartCorrBaseClass::GetCTSTracks() const {
   //Get list of referenced tracks from reader
 
-  return fReader->GetAODCTS(); 
+  return fReader->GetCTSTracks(); 
 
 }
 
 //__________________________________________________
-TObjArray *  AliAnaPartCorrBaseClass::GetAODPHOS() const {
+TObjArray *  AliAnaPartCorrBaseClass::GetPHOSClusters() const {
   //Get list of PHOS reference caloclusters from reader
 
-  return fReader->GetAODPHOS(); 
+  return fReader->GetPHOSClusters(); 
 
 }
 
 //__________________________________________________
-TObjArray *  AliAnaPartCorrBaseClass::GetAODEMCAL() const {
+TObjArray *  AliAnaPartCorrBaseClass::GetEMCALClusters() const {
   //Get list of emcal referenced caloclusters from reader
 
-  return fReader->GetAODEMCAL(); 
+  return fReader->GetEMCALClusters(); 
 
 }
 
index 2308cb8..9caed13 100755 (executable)
@@ -47,14 +47,8 @@ private:
   
 public:
 
-  virtual void AddAODParticle(AliAODPWG4Particle part) ;
-  
-  virtual void ConnectInputOutputAODBranches();
   
-  virtual TList * GetCreateOutputObjects()      { return (new TList) ;}
-       
-  virtual void AddToHistogramsName(TString add) { fAddToHistogramsName = add; }  
-  virtual TString GetAddedHistogramsStringToName() {return fAddToHistogramsName ;}
+  //General methods, to be declared in deriving classes if needed
   
   virtual void Init() {;}
   virtual void InitParameters() ;
@@ -65,123 +59,152 @@ public:
   
   virtual void MakeAnalysisFillHistograms() {;}
        
-  virtual TObjString * GetAnalysisCuts() {return 0x0;}
+  virtual void Terminate(TList * /*outputList*/) {;}
+    
+  
+  //Histograms, cuts 
+  virtual TList * GetCreateOutputObjects()      { return (new TList) ;}
        
-  virtual Int_t GetDebug() const  { return fDebug ; }
-  virtual void SetDebug(Int_t d)   { fDebug = d ; }
+  virtual void AddToHistogramsName(TString add) { fAddToHistogramsName = add; }  
+  virtual TString GetAddedHistogramsStringToName() {return fAddToHistogramsName ;}
   
+  virtual TObjString * GetAnalysisCuts() {return 0x0;}
+  TString      GetBaseParametersList();
+
+  //Getters, setters
+  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 AliCaloTrackReader * GetReader()            const { return fReader   ; }
   virtual void SetReader(AliCaloTrackReader * const reader) { fReader = reader ; }
     
-  //Calorimeter helper class access methods
-  AliEMCALGeoUtils *  GetEMCALGeometry() const { return fCaloUtils->GetEMCALGeometry(); }
-  AliPHOSGeoUtils  *  GetPHOSGeometry()  const { return fCaloUtils->GetPHOSGeometry() ; }
+  //Calorimeter specific access methods
+  AliCalorimeterUtils * GetCaloUtils()            const { return fCaloUtils                     ; }
+  void    SetCaloUtils(AliCalorimeterUtils * caloutils) { fCaloUtils = caloutils                ; }    
+
+  AliEMCALGeoUtils *  GetEMCALGeometry()          const { return fCaloUtils->GetEMCALGeometry() ; }
+  AliPHOSGeoUtils  *  GetPHOSGeometry()           const { return fCaloUtils->GetPHOSGeometry()  ; }
   
   Int_t GetModuleNumberCellIndexes(const Int_t absId, const TString calo, Int_t & icol, Int_t & irow, Int_t &iRCU) const {
          return fCaloUtils->GetModuleNumberCellIndexes(absId, calo, icol, irow,iRCU);}
   Int_t GetModuleNumber(AliAODPWG4Particle * part) const {
          return fCaloUtils->GetModuleNumber(part, fReader->GetInputEvent());}
-  Int_t GetModuleNumber(AliVCluster * cluster) const {
+  Int_t GetModuleNumber(AliVCluster * cluster)     const {
          return fCaloUtils->GetModuleNumber(cluster);}
        
   //Centrality
   AliCentrality* GetCentrality()      const  { return fReader->GetCentrality()      ;}
   Int_t          GetEventCentrality() const  { return fReader->GetEventCentrality() ;}
-  virtual void Terminate(TList * /*outputList*/) {;}
        
-  //analysis AOD branch
+  //AOD branch
+  virtual void AddAODParticle(AliAODPWG4Particle part) ;
+  virtual void ConnectInputOutputAODBranches();
+  
   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 AliCalorimeterUtils * GetCaloUtils() const {return fCaloUtils ; }
-  void SetCaloUtils(AliCalorimeterUtils * caloutils) { fCaloUtils = caloutils ; }      
-       
-  virtual TString GetAODObjArrayName() const {return fAODObjArrayName;}
-  virtual void SetAODObjArrayName(TString name) {fAODObjArrayName = name; }
+  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 TString GetAODObjArrayName()       const { return fAODObjArrayName ; }
+  virtual void SetAODObjArrayName(TString name)    { fAODObjArrayName = name ; }
   
-  virtual TClonesArray* GetInputAODBranch() const {return fInputAODBranch ;}
-  virtual TClonesArray* GetOutputAODBranch() const {if(fNewAOD) return fOutputAODBranch; else return fInputAODBranch ;}
+  virtual TClonesArray* GetInputAODBranch()  const { return fInputAODBranch  ; }
+  virtual TClonesArray* GetOutputAODBranch() const { if(fNewAOD) return fOutputAODBranch; else return fInputAODBranch ; }
   virtual TClonesArray* GetAODBranch(TString aodBranchName) const ;
        
-  virtual TClonesArray* GetAODCaloClusters() const ;
-  virtual TClonesArray* GetAODTracks() const ; 
-  virtual AliVCaloCells* GetPHOSCells()  const {return fReader->GetPHOSCells()  ;}
-  virtual AliVCaloCells* GetEMCALCells() const {return fReader->GetEMCALCells() ;}
-
-  virtual TObjArray* GetAODCTS() const ;
-  virtual TObjArray* GetAODEMCAL() const ;
-  virtual TObjArray* GetAODPHOS() const ;
-  
-  virtual TString      GetBaseParametersList();
-    
-  virtual AliStack * GetMCStack() const ;
-  virtual AliHeader* GetMCHeader() const ;
-  virtual AliGenEventHeader* GetMCGenEventHeader() const ;
+  //Track cluster arrays access methods
+  virtual TClonesArray*  GetAODCaloClusters() const ;
+  virtual TClonesArray*  GetAODTracks()       const ;  
+  virtual AliVCaloCells* GetPHOSCells()       const { return fReader->GetPHOSCells()  ;}
+  virtual AliVCaloCells* GetEMCALCells()      const { return fReader->GetEMCALCells() ;}
+  virtual TObjArray*     GetCTSTracks()       const ;
+  virtual TObjArray*     GetEMCALClusters()   const ;
+  virtual TObjArray*     GetPHOSClusters()    const ;
+  
+  //MC event acces methods
+  virtual AliStack *                 GetMCStack()          const ;
+  virtual AliHeader*                 GetMCHeader()         const ;
+  virtual AliGenEventHeader        * GetMCGenEventHeader() const ;
   
   //Analysis helpers classes pointers setters and getters
-  virtual AliCaloPID * GetCaloPID() {if(!fCaloPID) fCaloPID = new AliCaloPID(); return  fCaloPID ;}
-  virtual void SetCaloPID(AliCaloPID * const pid) { fCaloPID = pid ;}
-  
-  virtual AliFiducialCut * GetFiducialCut() {if(!fFidCut) fFidCut = new AliFiducialCut(); return  fFidCut ;}
-  virtual void SetFiducialCut(AliFiducialCut * const fc) { fFidCut = fc ;}
-  
-  virtual AliIsolationCut * GetIsolationCut() {if(!fIC) fIC = new AliIsolationCut();  return  fIC ;}
-  virtual void SetIsolationCut(AliIsolationCut * const ic) { fIC = ic ;}
-  
-  virtual AliMCAnalysisUtils * GetMCAnalysisUtils()  {if(!fMCUtils) fMCUtils = new AliMCAnalysisUtils(); return  fMCUtils ;}
-  virtual void SetMCAnalysisUtils(AliMCAnalysisUtils * const mcutils) { fMCUtils = mcutils ;}  
-  
-  virtual AliNeutralMesonSelection * GetNeutralMesonSelection()  {if(!fNMS) fNMS = new AliNeutralMesonSelection(); return  fNMS ;}
-  virtual void SetNeutralMesonSelection(AliNeutralMesonSelection * const nms) { fNMS = nms ;}
+  virtual AliCaloPID               * GetCaloPID()                { if(!fCaloPID) fCaloPID = new AliCaloPID();           return  fCaloPID ; }
+  virtual AliFiducialCut           * GetFiducialCut()            { if(!fFidCut)  fFidCut = new AliFiducialCut();        return  fFidCut  ; }
+  virtual AliIsolationCut          * GetIsolationCut()           { if(!fIC)      fIC = new AliIsolationCut();           return  fIC      ; }
+  virtual AliMCAnalysisUtils       * GetMCAnalysisUtils()        { if(!fMCUtils) fMCUtils = new AliMCAnalysisUtils();   return  fMCUtils ; }
+  virtual AliNeutralMesonSelection * GetNeutralMesonSelection()  { if(!fNMS)     fNMS = new AliNeutralMesonSelection(); return  fNMS     ; }
+
+  virtual void SetCaloPID(AliCaloPID * const pid)                             { fCaloPID = pid     ; }
+  virtual void SetFiducialCut(AliFiducialCut * const fc)                      { fFidCut  = fc      ; }
+  virtual void SetIsolationCut(AliIsolationCut * const ic)                    { fIC      = ic      ; }
+  virtual void SetMCAnalysisUtils(AliMCAnalysisUtils * const mcutils)         { fMCUtils = mcutils ; } 
+  virtual void SetNeutralMesonSelection(AliNeutralMesonSelection * const nms) { fNMS     = nms     ; }
        
-  virtual Bool_t     IsDataMC()       {return fDataMC ; }
-  virtual void SwitchOnDataMC()       {fDataMC = kTRUE ; if(!fMCUtils)fMCUtils = new AliMCAnalysisUtils();}
-  virtual void SwitchOffDataMC()      {fDataMC = kFALSE ; }
-  
-  virtual Bool_t IsFiducialCutOn()       { return fCheckFidCut ; }
-  virtual void SwitchOnFiducialCut()     { fCheckFidCut = kTRUE;  if(!fFidCut)fFidCut = new AliFiducialCut();}
-  virtual void SwitchOffFiducialCut()    { fCheckFidCut = kFALSE;}
-  
-  virtual Bool_t IsCaloPIDOn()       { return fCheckCaloPID ; }
-  virtual void SwitchOnCaloPID()     { fCheckCaloPID = kTRUE; if(!fCaloPID)fCaloPID = new AliCaloPID();}
-  virtual void SwitchOffCaloPID()    { fCheckCaloPID = kFALSE;}
-  
-  virtual Bool_t IsCaloPIDRecalculationOn()       { 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 ; }
-  virtual void SetPtCutRange(Double_t ptmin, Double_t ptmax)
+  virtual Bool_t IsDataMC()                   const { return fDataMC                ; }
+  virtual void   SwitchOnDataMC()                   { fDataMC = kTRUE ; if(!fMCUtils)fMCUtils = new AliMCAnalysisUtils();}
+  virtual void   SwitchOffDataMC()                  { fDataMC = kFALSE              ; }
+  
+  virtual Bool_t IsFiducialCutOn()            const { return fCheckFidCut           ; }
+  virtual void   SwitchOnFiducialCut()              { fCheckFidCut = kTRUE;  if(!fFidCut)fFidCut = new AliFiducialCut();}
+  virtual void   SwitchOffFiducialCut()             { fCheckFidCut = kFALSE         ; }
+    
+  virtual Bool_t IsCaloPIDOn()                const { return fCheckCaloPID          ; }
+  virtual void   SwitchOnCaloPID()                  { fCheckCaloPID = kTRUE; if(!fCaloPID)fCaloPID = new AliCaloPID();}
+  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   ; }
+  virtual void    SetPtCutRange(Double_t ptmin, Double_t ptmax)
   {  fMaxPt=ptmax;   fMinPt=ptmin;}
+  
   //Setters for parameters of event buffers
-  virtual void SetMultiBin(Int_t n=1) {fMultiBin=n ;} //number of bins in Multiplicity  
-  virtual void SetNZvertBin(Int_t n=1) {fNZvertBin=n ;} //number of bins for vertex position
-  virtual void SetNRPBin(Int_t n=1)    {fNrpBin=n ;}    //number of bins in reaction plain  
+  virtual void SetMultiBin(Int_t n=1)    { fMultiBin  = n ;} //number of bins in Multiplicity  
+  virtual void SetNZvertBin(Int_t n=1)   { fNZvertBin = n ;} //number of bins for vertex position
+  virtual void SetNRPBin(Int_t n=1)      { fNrpBin    = n ;} //number of bins in reaction plain  
   virtual void SetMultiplicity(Int_t multimin, Int_t multimax) {fMinMulti = multimin ; fMaxMulti = multimax ; }
-  virtual void SwitchOnEventSelection()    {fUseSelectEvent = kTRUE ; }
-  virtual void SwitchOffEventSelection()   {fUseSelectEvent = kFALSE ; } 
+  virtual void SwitchOnEventSelection()  { fUseSelectEvent = kTRUE  ; }
+  virtual void SwitchOffEventSelection() { fUseSelectEvent = kFALSE ; } 
   //Getters for event selection
-  virtual Int_t GetMultiBin()  const       {return fMultiBin ;} //number of bins in Multiplicity 
-  virtual Int_t GetNZvertBin() const       {return fNZvertBin ;} //number of bins in vertex   
-  virtual Int_t GetNRPBin()    const       {return fNrpBin ;}    //number of bins in reaction plain 
+  virtual Int_t   GetMultiBin()    const { return fMultiBin  ; } //number of bins in Multiplicity 
+  virtual Int_t   GetNZvertBin()   const { return fNZvertBin ; } //number of bins in vertex   
+  virtual Int_t   GetNRPBin()      const { return fNrpBin    ; } //number of bins in reaction plain 
   //Getters for event selection
-  virtual Float_t GetZvertexCut() const {return GetReader()->GetZvertexCut();} //cut on vertex position  
-  virtual Int_t GetMaxMulti()     const {return fMaxMulti  ; }  
-  virtual Int_t GetMinMulti()     const {return fMinMulti  ; }  
+  virtual Float_t GetZvertexCut()  const { return GetReader()->GetZvertexCut();} //cut on vertex position  
+  virtual Int_t   GetMaxMulti()    const { return fMaxMulti  ; }  
+  virtual Int_t   GetMinMulti()    const { return fMinMulti  ; }  
   
   // Do correlation analysis with different event buffers
-  virtual Bool_t DoEventSelect() const {return fUseSelectEvent ; }
+  virtual Bool_t DoEventSelect()  const { return fUseSelectEvent ; }
+  
+  //Mixed event
+  virtual AliMixedEvent * GetMixedEvent()         { return GetReader()->GetMixedEvent()  ; } 
+  virtual Int_t           GetNMixedEvent()  const { return GetReader()->GetNMixedEvent() ; } 
+  
+  //Vertex methods
+  virtual void      GetVertex(Double_t vertex[3]) const { GetReader()->GetVertex(vertex) ; } 
+  virtual void      GetVertex(Double_t vertex[3],const Int_t evtIndex) const { GetReader()->GetVertex(vertex,evtIndex)       ; } 
+  virtual Double_t* GetVertex(const Int_t evtIndex)             const { return GetReader()->GetVertex(evtIndex)              ; } 
+  
+       virtual Bool_t    IsTrackMatched(const AliVCluster * cluster) const { return fCaloPID->IsTrackMatched(cluster, fCaloUtils) ; } 
+  
+  //MULTIPLICITY
+  Int_t GetTrackMultiplicity()      const { return fReader->GetTrackMultiplicity() ; }
+  //VZERO
+  Int_t GetV0Signal(Int_t i )       const { return fReader->GetV0Signal(i)         ; }
+  Int_t GetV0Multiplicity(Int_t i ) const { return fReader->GetV0Multiplicity(i)   ; }
+  
+  
   
   //Histogrammes setters and getters
   //Pt, Energy 
@@ -191,9 +214,9 @@ public:
     fHistoPtMin = min ;
   }
   
-  virtual Int_t   GetHistoPtBins()  const { return fHistoPtBins; }
-  virtual Float_t GetHistoPtMin()   const { return fHistoPtMin ; }
-  virtual Float_t GetHistoPtMax()   const { return fHistoPtMax ; }
+  virtual Int_t   GetHistoPtBins() const { return fHistoPtBins ; }
+  virtual Float_t GetHistoPtMin()  const { return fHistoPtMin  ; }
+  virtual Float_t GetHistoPtMax()  const { return fHistoPtMax  ; }
   
     //Azimuthal angle
   virtual void SetHistoPhiRangeAndNBins(Float_t min, Float_t max, Int_t n) {
@@ -225,8 +248,8 @@ public:
   }
        
   virtual Int_t   GetHistoMassBins()  const { return fHistoMassBins ; }
-  virtual Float_t GetHistoMassMin()   const { return fHistoMassMin ; }
-  virtual Float_t GetHistoMassMax()   const { return fHistoMassMax ; }
+  virtual Float_t GetHistoMassMin()   const { return fHistoMassMin  ; }
+  virtual Float_t GetHistoMassMax()   const { return fHistoMassMax  ; }
        
   //Asymetry
   virtual void SetHistoAsymmetryRangeAndNBins(Float_t min, Float_t max, Int_t n) {
@@ -236,8 +259,8 @@ public:
   }
        
   virtual Int_t   GetHistoAsymmetryBins()  const { return fHistoAsymBins ; }
-  virtual Float_t GetHistoAsymmetryMin()   const { return fHistoAsymMin ; }
-  virtual Float_t GetHistoAsymmetryMax()   const { return fHistoAsymMax ; }    
+  virtual Float_t GetHistoAsymmetryMin()   const { return fHistoAsymMin  ; }
+  virtual Float_t GetHistoAsymmetryMax()   const { return fHistoAsymMax  ; }   
   
   
   //VZero
@@ -248,8 +271,8 @@ public:
   }
        
   virtual Int_t GetHistoV0SignalBins()  const { return fHistoV0SBins ; }
-  virtual Int_t GetHistoV0SignalMin()   const { return fHistoV0SMin ; }
-  virtual Int_t GetHistoV0SignalMax()   const { return fHistoV0SMax ; }
+  virtual Int_t GetHistoV0SignalMin()   const { return fHistoV0SMin  ; }
+  virtual Int_t GetHistoV0SignalMax()   const { return fHistoV0SMax  ; }
        
   virtual void SetHistoV0MultiplicityRangeAndNBins(Int_t min, Int_t max, Int_t n) {
     fHistoV0MBins = n ;
@@ -258,8 +281,8 @@ public:
   }
        
   virtual Int_t GetHistoV0MultiplicityBins()  const { return fHistoV0MBins ; }
-  virtual Int_t GetHistoV0MultiplicityMin()   const { return fHistoV0MMin ; }
-  virtual Int_t GetHistoV0MultiplicityMax()   const { return fHistoV0MMax ; }
+  virtual Int_t GetHistoV0MultiplicityMin()   const { return fHistoV0MMin  ; }
+  virtual Int_t GetHistoV0MultiplicityMax()   const { return fHistoV0MMax  ; }
   
   virtual void SetHistoTrackMultiplicityRangeAndNBins(Int_t min, Int_t max, Int_t n) {
     fHistoTrMBins = n ;
@@ -268,28 +291,13 @@ public:
   }
        
   virtual Int_t GetHistoTrackMultiplicityBins()  const { return fHistoTrMBins ; }
-  virtual Int_t GetHistoTrackMultiplicityMin()   const { return fHistoTrMMin ; }
-  virtual Int_t GetHistoTrackMultiplicityMax()   const { return fHistoTrMMax ; }
+  virtual Int_t GetHistoTrackMultiplicityMin()   const { return fHistoTrMMin  ; }
+  virtual Int_t GetHistoTrackMultiplicityMax()   const { return fHistoTrMMax  ; }
   
-  virtual AliMixedEvent * GetMixedEvent()          { return GetReader()->GetMixedEvent() ; } 
-  virtual Int_t           GetNMixedEvent()   const { return GetReader()->GetNMixedEvent() ; } 
+  void   SwitchOnPlotsMaking()  { fMakePlots = kTRUE  ; }
+  void   SwitchOffPlotsMaking() { fMakePlots = kFALSE ; }
+  Bool_t MakePlotsOn()    const { return fMakePlots   ; }
   
-  virtual void      GetVertex(Double_t vertex[3])   const { GetReader()->GetVertex(vertex) ; } 
-  virtual void      GetVertex(Double_t vertex[3],const Int_t evtIndex) const { GetReader()->GetVertex(vertex,evtIndex) ; } 
-  virtual Double_t* GetVertex(const Int_t evtIndex) const { return GetReader()->GetVertex(evtIndex) ; } 
-
-       virtual Bool_t IsTrackMatched(const AliVCluster * cluster) const { return fCaloPID->IsTrackMatched(cluster, fCaloUtils); } 
-  
-  void SwitchOnPlotsMaking()  {fMakePlots = kTRUE  ;}
-  void SwitchOffPlotsMaking() {fMakePlots = kFALSE ;}
-  Bool_t MakePlotsOn() const  {return fMakePlots;}
-  
-  //MULTIPLICITY
-  Int_t GetTrackMultiplicity() const {return fReader->GetTrackMultiplicity();}
-  //VZERO
-  Int_t GetV0Signal(Int_t i )       const {return fReader->GetV0Signal(i);}
-  Int_t GetV0Multiplicity(Int_t i ) const {return fReader->GetV0Multiplicity(i);}
-
 private:    
   
   Bool_t   fDataMC ;             // Flag to access MC data when using ESD or AOD     
@@ -353,7 +361,7 @@ private:
   Int_t   fHistoTrMMax   ;  // Maximum value of track multiplicity histogram range
   Int_t   fHistoTrMMin   ;  // Minimum value of track multiplicity histogram range
   
-  ClassDef(AliAnaPartCorrBaseClass,15)
+  ClassDef(AliAnaPartCorrBaseClass,16)
 } ;
 
 
index 97783c7..e1e7861 100755 (executable)
@@ -60,16 +60,6 @@ AliCaloTrackAODReader::AliCaloTrackAODReader() :
 //}
 
 //____________________________________________________________________________
-Double_t AliCaloTrackAODReader::GetBField() const {
-  //Return magnetic field
-
-  Double_t bfield = fInputEvent->GetMagneticField();
-
-  return bfield;
-
-}
-
-//____________________________________________________________________________
 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.
index 18b275d..6593de6 100755 (executable)
 //
 // -- Author: Gustavo Conesa (INFN-LNF)
 
-// --- ROOT system --- 
-
-// --- AliRoot system ---
 #include "AliCaloTrackReader.h" 
-#include "AliAODEvent.h"
 
 class AliCaloTrackAODReader : public AliCaloTrackReader {
        
 public: 
        
   AliCaloTrackAODReader() ; // ctor
-  //AliCaloTrackAODReader(const AliCaloTrackAODReader & g)  ; // cpy ctor
-  //AliCaloTrackAODReader & operator = (const AliCaloTrackAODReader & g) ;//cpy assignment
   virtual ~AliCaloTrackAODReader() {;} //virtual dtor
   
-       
-  Double_t GetBField() const;
-
-  //void GetSecondInputAODVertex(Double_t v[3]) const ;
-  
   void SetInputOutputMCEvent(AliVEvent* esd, AliAODEvent* aod, AliMCEvent* mc) ; 
-
-  TString GetFiredTriggerClasses() {return ((AliAODEvent*)GetInputEvent())->GetFiredTriggerClasses();} 
-
-  AliCentrality* GetCentrality() const {return 0x0;}
-
   
   ClassDef(AliCaloTrackAODReader,5)
 } ;
index ac5e0c3..b208f9b 100755 (executable)
@@ -35,7 +35,6 @@
 #include "AliMultiEventInputHandler.h"
 #include "AliAnalysisManager.h"
 #include "AliMixedEvent.h"
-#include "AliESDVZERO.h"
 
 
 ClassImp(AliCaloTrackESDReader)
@@ -54,16 +53,6 @@ AliCaloTrackReader()
 }
 
 //____________________________________________________________________________
-Double_t AliCaloTrackESDReader::GetBField() const {
-  //Return magnetic field
-
-  Double_t bfield = fInputEvent->GetMagneticField();
-
-  return bfield;
-}
-
-
-//____________________________________________________________________________
 void AliCaloTrackESDReader::SetInputOutputMCEvent(AliVEvent* esd, AliAODEvent* aod, AliMCEvent* mc) {
   // Connect the data pointers
   
@@ -94,27 +83,3 @@ void AliCaloTrackESDReader::SetInputOutputMCEvent(AliVEvent* esd, AliAODEvent* a
   SetMC(mc);
   
 }
-
-//____________________________________________________________________________
-void AliCaloTrackESDReader::FillInputVZERO(){
-  //Fill VZERO information in data member, add all the channels information.
-  AliESDVZERO* esdV0 = ((AliESDEvent*)fInputEvent)->GetVZEROData();
-  //printf("Init V0: ADC (%d,%d), Multiplicity (%d,%d) \n",fV0ADC[0],fV0ADC[1],fV0Mul[0],fV0Mul[1]);
-
-  if (esdV0) 
-  {
-    for (Int_t i = 0; i < 32; i++)
-    {
-      fV0ADC[0] += (Int_t)esdV0->GetAdcV0C(i);
-      fV0ADC[1] += (Int_t)esdV0->GetAdcV0A(i);
-      fV0Mul[0] += (Int_t)esdV0->GetMultiplicityV0C(i);
-      fV0Mul[1] += (Int_t)esdV0->GetMultiplicityV0A(i);
-    }
-    if(fDebug > 0)
-      printf("V0: ADC (%d,%d), Multiplicity (%d,%d) \n",fV0ADC[0],fV0ADC[1],fV0Mul[0],fV0Mul[1]);
-  }
-  else
-  {
-    printf("Cannot retrieve V0 ESD! Run w/ null V0 charges");
-  }
-}
index 86ba5cf..f5b84b6 100755 (executable)
 //
 //*-- Author: Gustavo Conesa (INFN-LNF)
 
-// --- ROOT system --- 
-
-// --- AliRoot system ---
-#include "AliCaloTrackReader.h" 
 #include "AliESDEvent.h"
-class AliCentrality;
+#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
 
-  Double_t GetBField() const;
   void SetInputOutputMCEvent(AliVEvent* esd, AliAODEvent* aod, AliMCEvent* mc) ; 
        
   TString GetFiredTriggerClasses() {return ((AliESDEvent*)GetInputEvent())->GetFiredTriggerClasses();}
-  
-  AliCentrality* GetCentrality() const {AliESDEvent* event = dynamic_cast<AliESDEvent*> (fInputEvent); 
-                                           if(event) return event->GetCentrality(); else return 0x0;}
-  
-  void FillInputVZERO();
-
+    
   ClassDef(AliCaloTrackESDReader,1)
 } ;
 
index e56dfd9..a6698d0 100755 (executable)
@@ -112,9 +112,9 @@ void AliCaloTrackMCReader::InitParameters()
   fReadAODMCParticles = kFALSE; //This class only works with Kinematics.root input.
   
   //For this reader we own the objects of the arrays
-  fAODCTS  ->SetOwner(kTRUE); 
-  fAODEMCAL->SetOwner(kTRUE); 
-  fAODPHOS ->SetOwner(kTRUE); 
+  fCTSTracks    ->SetOwner(kTRUE); 
+  fEMCALClusters->SetOwner(kTRUE); 
+  fPHOSClusters ->SetOwner(kTRUE); 
   
 }
 
@@ -183,7 +183,7 @@ void  AliCaloTrackMCReader::FillCalorimeters(Int_t & iParticle, TParticle* parti
     if(fDebug > 3 && momentum.Pt() > 0.2)
       printf("AliCaloTrackMCReader::FillCalorimeters() - PHOS : Selected cluster %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
+    fPHOSClusters->Add(calo);//reference the selected object to the list
   }
   
   //In EMCAL
@@ -207,7 +207,7 @@ void  AliCaloTrackMCReader::FillCalorimeters(Int_t & iParticle, TParticle* parti
     if(fDebug > 3 && momentum.Pt() > 0.2)
       printf("AliCaloTrackMCReader::FillCalorimeters() - EMCAL : Selected cluster %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
+    fEMCALClusters->Add(calo);//reference the selected object to the list
   }
 }
 
@@ -272,7 +272,7 @@ Bool_t AliCaloTrackMCReader::FillInputEvent(const Int_t iEntry, const char * /*c
                                                   AliAODTrack::kPrimary, 
                                                   0);
           SetTrackChargeAndPID(pdg, aodTrack);
-          fAODCTS->Add(aodTrack);//reference the selected object to the list
+          fCTSTracks->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);
index 3375f77..6d7ee69 100755 (executable)
@@ -40,62 +40,60 @@ class AliCaloTrackMCReader : public AliCaloTrackReader {
   AliCaloTrackMCReader & operator = (const AliCaloTrackMCReader & g) ;//cpy assignment
 
 public:
-  void InitParameters();
+  void   InitParameters();
   
-  void Print(const Option_t * opt) const; 
+  void   Print(const Option_t * opt) const; 
   
-  void SwitchOnPi0Decay()  { fDecayPi0 = kTRUE ; } 
-  void SwitchOffPi0Decay() { fDecayPi0 = kFALSE ; } 
-  Int_t IsPi0DecaySwitchedOn() const { return fDecayPi0 ; } 
+  void   SwitchOnPi0Decay()           { fDecayPi0 = kTRUE  ; } 
+  void   SwitchOffPi0Decay()          { fDecayPi0 = kFALSE ; } 
+  Int_t  IsPi0DecaySwitchedOn() const { return fDecayPi0   ; } 
   
-  void AddNeutralParticlesArray(TArrayI & array)  
-  { fNeutralParticlesArray   = new TArrayI(array) ; }
-  TArrayI * GetNeutralParticlesArray() const   {return  fNeutralParticlesArray;}
-  Bool_t SkipNeutralParticles(Int_t pdg) const ;
+  void      AddNeutralParticlesArray(TArrayI & array)  
+      { fNeutralParticlesArray   = new TArrayI(array) ; }
+  TArrayI * GetNeutralParticlesArray()      const {return  fNeutralParticlesArray;}
+  Bool_t    SkipNeutralParticles(Int_t pdg) const ;
   
-  void AddChargedParticlesArray(TArrayI & array)  
-  { fChargedParticlesArray   = new TArrayI(array) ; }
-  TArrayI * GetChargedParticlesArray() const   {return  fChargedParticlesArray;}
-  Bool_t KeepChargedParticles(Int_t pdg) const ;
+  void      AddChargedParticlesArray(TArrayI & array)  
+      { fChargedParticlesArray   = new TArrayI(array) ; }
+  TArrayI * GetChargedParticlesArray()   const {return  fChargedParticlesArray;}
+  Bool_t    KeepChargedParticles(Int_t pdg) const ;
 
   void AddStatusArray(TArrayI & array)  
-  { fStatusArray   = new TArrayI(array) ; }
-  TArrayI * GetStatusArray() const   {return  fStatusArray;}
+      { fStatusArray   = new TArrayI(array) ; }
+  TArrayI * GetStatusArray()             const {return  fStatusArray;}
   
-  void SwitchOnStatusSelection()  {fKeepAllStatus = kFALSE;}
-  void SwitchOffStatusSelection() {fKeepAllStatus = kTRUE;}
+  void   SwitchOnStatusSelection()  { fKeepAllStatus = kFALSE ; }
+  void   SwitchOffStatusSelection() { fKeepAllStatus = kTRUE  ; }
   Bool_t KeepParticleWithStatus(Int_t status) const ;
   
-  void SwitchOnOnlyGeneratorParticles()  {fOnlyGeneratorParticles = kTRUE;}
-  void SwitchOffOnlyGeneratorParticles() {fOnlyGeneratorParticles = kFALSE;}
+  void   SwitchOnOnlyGeneratorParticles()  {fOnlyGeneratorParticles = kTRUE  ; }
+  void   SwitchOffOnlyGeneratorParticles() {fOnlyGeneratorParticles = kFALSE ; }
   
-  void GetVertex(Double_t v[3]) const ;
+  void      GetVertex(Double_t v[3]) const ;
   Double_t* GetVertex(const Int_t evtIndex) const {return fVertex[evtIndex];}
-  void GetVertex(Double_t vertex[3], const Int_t evtIndex) const 
+  void      GetVertex(Double_t vertex[3], const Int_t evtIndex) const 
     {vertex[0]=fVertex[evtIndex][0];  vertex[1]=fVertex[evtIndex][1];  vertex[2]=fVertex[evtIndex][2];}   
   
   Bool_t FillInputEvent(const Int_t iEntry, const char * currentFileName) ;
   AliVEvent*  GetInputEvent() const {return (AliVEvent *) GetMC();}
-  void SetInputOutputMCEvent(AliVEvent* esd, AliAODEvent* aod, AliMCEvent* mc) ;
+  void   SetInputOutputMCEvent(AliVEvent* esd, AliAODEvent* aod, AliMCEvent* mc) ;
   
-  void SetCaloClusterPID(const Int_t pdgCode, AliVCluster *calo) const ;
-  void SetTrackChargeAndPID(const Int_t pdgCode, AliAODTrack *track) const ;
+  void   SetCaloClusterPID(const Int_t pdgCode, AliVCluster *calo)     const ;
+  void   SetTrackChargeAndPID(const Int_t pdgCode, AliAODTrack *track) const ;
   
-  void SwitchOnOverlapCheck()  {fCheckOverlap = kTRUE;}
-  void SwitchOffOverlapCheck() {fCheckOverlap = kFALSE;}
+  void   SwitchOnOverlapCheck()  {fCheckOverlap = kTRUE  ; }
+  void   SwitchOffOverlapCheck() {fCheckOverlap = kFALSE ; }
 
-  Float_t GetEMCALOverlapAngle()  const {return fEMCALOverlapAngle ;}
-  Float_t GetPHOSOverlapAngle() const {return fPHOSOverlapAngle ;}
-  void SetEMCALOverlapAngle(Float_t angle)  {fEMCALOverlapAngle = angle;}
-  void SetPHOSOverlapAngle(Float_t angle) {fPHOSOverlapAngle = angle;}
-  
-  AliCentrality* GetCentrality() const {return 0x0;}
-  
+  Float_t GetEMCALOverlapAngle() const {return fEMCALOverlapAngle ; }
+  Float_t GetPHOSOverlapAngle()  const {return fPHOSOverlapAngle  ; }
+  void    SetEMCALOverlapAngle(Float_t angle)  {fEMCALOverlapAngle = angle ; }
+  void    SetPHOSOverlapAngle(Float_t angle)   {fPHOSOverlapAngle  = angle ; }
+    
  private:
   
-  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) ;
+  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) ;
   
   private:
   Bool_t    fDecayPi0 ;              // If not decayed, decay pi0 by hand
index 36a4d9b..7dd5d39 100755 (executable)
@@ -45,6 +45,7 @@
 #include "AliESDtrack.h"
 #include "AliESDtrackCuts.h"
 #include "AliTriggerAnalysis.h"
+#include "AliESDVZERO.h";
 
 //---- PartCorr/EMCAL ---
 #include "AliEMCALRecoUtils.h"
@@ -59,7 +60,7 @@ ClassImp(AliCaloTrackReader)
     fDataType(0), fDebug(0), 
     fFiducialCut(0x0), fCheckFidCut(kFALSE), fComparePtHardAndJetPt(kFALSE), fPtHardAndJetPtFactor(7),
     fCTSPtMin(0), fEMCALPtMin(0),fPHOSPtMin(0), fAODBranchList(new TList ),
-    fAODCTS(new TObjArray()), fAODEMCAL(new TObjArray()), fAODPHOS(new TObjArray()),
+    fCTSTracks(new TObjArray()), fEMCALClusters(new TObjArray()), fPHOSClusters(new TObjArray()),
     fEMCALCells(0x0), fPHOSCells(0x0),
     fInputEvent(0x0), fOutputEvent(0x0),fMC(0x0),
     fFillCTS(0),fFillEMCAL(0),fFillPHOS(0),
@@ -67,8 +68,8 @@ ClassImp(AliCaloTrackReader)
     fRemoveSuspiciousClusters(kFALSE), fSmearClusterEnergy(kFALSE), fRandom(),
 //    fSecondInputAODTree(0x0), fSecondInputAODEvent(0x0),
 //    fSecondInputFileName(""),fSecondInputFirstEvent(0), 
-//    fAODCTSNormalInputEntries(0), fAODEMCALNormalInputEntries(0), 
-//    fAODPHOSNormalInputEntries(0), 
+//    fCTSTracksNormalInputEntries(0), fEMCALClustersNormalInputEntries(0), 
+//    fPHOSClustersNormalInputEntries(0), 
     fTrackStatus(0),   fESDtrackCuts(0), fTrackMult(0), fTrackMultEtaCut(0.8),
     fReadStack(kFALSE), fReadAODMCParticles(kFALSE), 
     fDeltaAODFileName("deltaAODPartCorr.root"),fFiredTriggerClassName(""),
@@ -97,22 +98,22 @@ AliCaloTrackReader::~AliCaloTrackReader() {
     delete fAODBranchList ;
   }  
   
-  if(fAODCTS){
-    if(fDataType!=kMC)fAODCTS->Clear() ; 
-    else              fAODCTS->Delete() ; 
-    delete fAODCTS ;
+  if(fCTSTracks){
+    if(fDataType!=kMC)fCTSTracks->Clear() ; 
+    else              fCTSTracks->Delete() ; 
+    delete fCTSTracks ;
   }
   
-  if(fAODEMCAL){
-    if(fDataType!=kMC)fAODEMCAL->Clear("C") ; 
-    else              fAODEMCAL->Delete() ; 
-    delete fAODEMCAL ;
+  if(fEMCALClusters){
+    if(fDataType!=kMC)fEMCALClusters->Clear("C") ; 
+    else              fEMCALClusters->Delete() ; 
+    delete fEMCALClusters ;
   }
   
-  if(fAODPHOS){
-    if(fDataType!=kMC)fAODPHOS->Clear("C") ; 
-    else              fAODPHOS->Delete() ; 
-    delete fAODPHOS ;
+  if(fPHOSClusters){
+    if(fDataType!=kMC)fPHOSClusters->Clear("C") ; 
+    else              fPHOSClusters->Delete() ; 
+    delete fPHOSClusters ;
   }
   
 //  if(fEMCALCells){
@@ -551,9 +552,9 @@ Bool_t AliCaloTrackReader::FillInputEvent(const Int_t iEntry, const char * /*cur
 void AliCaloTrackReader::ResetLists() {
   //  Reset lists, called by the analysis maker 
 
-  if(fAODCTS)     fAODCTS     -> Clear();
-  if(fAODEMCAL)   fAODEMCAL   -> Clear("C");
-  if(fAODPHOS)    fAODPHOS    -> Clear("C");
+  if(fCTSTracks)     fCTSTracks     -> Clear();
+  if(fEMCALClusters)   fEMCALClusters   -> Clear("C");
+  if(fPHOSClusters)    fPHOSClusters    -> Clear("C");
 //  if(fEMCALCells) fEMCALCells -> Clear("");
 //  if(fPHOSCells)  fPHOSCells  -> Clear("");
 
@@ -731,14 +732,14 @@ void AliCaloTrackReader::FillInputCTS() {
         track->SetID(itrack);
       }
       
-      fAODCTS->Add(track);        
+      fCTSTracks->Add(track);        
        
     }//Pt and Fiducial cut passed. 
   }// track loop
        
-  //fAODCTSNormalInputEntries = fAODCTS->GetEntriesFast();
+  //fCTSTracksNormalInputEntries = fCTSTracks->GetEntriesFast();
   if(fDebug > 1) 
-    printf("AliCaloTrackReader::FillInputCTS()   - aod entries %d, input tracks %d, pass status %d, multipliticy %d\n", fAODCTS->GetEntriesFast(), nTracks, nstatus, fTrackMult);//fAODCTSNormalInputEntries);
+    printf("AliCaloTrackReader::FillInputCTS()   - aod entries %d, input tracks %d, pass status %d, multipliticy %d\n", fCTSTracks->GetEntriesFast(), nTracks, nstatus, fTrackMult);//fCTSTracksNormalInputEntries);
   
     //  //If second input event available, add the clusters.
     //  if(fSecondInputAODTree && fSecondInputAODEvent){
@@ -760,12 +761,12 @@ void AliCaloTrackReader::FillInputCTS() {
     //                   if(fDebug > 2 && momentum.Pt() > 0.1) printf("AliCaloTrackReader::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());
     //                   
-    //                   fAODCTS->Add(track);
+    //                   fCTSTracks->Add(track);
     //                   
     //           }//Pt and Fiducial cut passed. 
     //   }// track loop
     //   
-    //   if(fDebug > 1) printf("AliCaloTrackReader::FillInputCTS()   - aod normal entries %d, after second input %d\n", fAODCTSNormalInputEntries, fAODCTS->GetEntriesFast());
+    //   if(fDebug > 1) printf("AliCaloTrackReader::FillInputCTS()   - aod normal entries %d, after second input %d\n", fCTSTracksNormalInputEntries, fCTSTracks->GetEntriesFast());
     //  }      //second input loop
     // 
 }
@@ -854,7 +855,7 @@ void AliCaloTrackReader::FillInputEMCALAlgorithm(AliVCluster * clus, const Int_t
     if (fMixedEvent) 
       clus->SetID(iclus) ; 
     
-    fAODEMCAL->Add(clus);      
+    fEMCALClusters->Add(clus); 
   }
 }
 
@@ -900,8 +901,8 @@ void AliCaloTrackReader::FillInputEMCAL() {
     
   }
     
-  //fAODEMCALNormalInputEntries = fAODEMCAL->GetEntriesFast();
-  if(fDebug > 1) printf("AliCaloTrackReader::FillInputEMCAL() - aod entries %d\n",  fAODEMCAL->GetEntriesFast());//fAODEMCALNormalInputEntries);
+  //fEMCALClustersNormalInputEntries = fEMCALClusters->GetEntriesFast();
+  if(fDebug > 1) printf("AliCaloTrackReader::FillInputEMCAL() - aod entries %d\n",  fEMCALClusters->GetEntriesFast());//fEMCALClustersNormalInputEntries);
   
     //If second input event available, add the clusters.
     //  if(fSecondInputAODTree && fSecondInputAODEvent){
@@ -921,13 +922,13 @@ void AliCaloTrackReader::FillInputEMCAL() {
     //
     //                                         if(fDebug > 2 && momentum.E() > 0.1) printf("AliCaloTrackReader::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());
-    //                                   fAODEMCAL->Add(clus); 
+    //                                   fEMCALClusters->Add(clus);    
     //                                 }//Pt and Fiducial cut passed.
     //                         }//EMCAL cluster
     //                 }// cluster exists
     //         }// cluster loop
     //         
-    //   if(fDebug > 1) printf("AliCaloTrackReader::FillInputEMCAL() - aod normal entries %d, after second input %d\n", fAODEMCALNormalInputEntries, fAODEMCAL->GetEntriesFast());
+    //   if(fDebug > 1) printf("AliCaloTrackReader::FillInputEMCAL() - aod normal entries %d, after second input %d\n", fEMCALClustersNormalInputEntries, fEMCALClusters->GetEntriesFast());
     //
     // } //second input loop
 }
@@ -976,15 +977,15 @@ void AliCaloTrackReader::FillInputPHOS() {
             clus->SetID(iclus) ; 
           }              
           
-          fAODPHOS->Add(clus); 
+          fPHOSClusters->Add(clus);    
           
         }//Pt and Fiducial cut passed.
       }//PHOS cluster
     }//cluster exists
   }//esd cluster loop
   
-  //fAODPHOSNormalInputEntries = fAODPHOS->GetEntriesFast() ;
-  if(fDebug > 1) printf("AliCaloTrackReader::FillInputPHOS()  - aod entries %d\n",  fAODPHOS->GetEntriesFast());//fAODPHOSNormalInputEntries);
+  //fPHOSClustersNormalInputEntries = fPHOSClusters->GetEntriesFast() ;
+  if(fDebug > 1) printf("AliCaloTrackReader::FillInputPHOS()  - aod entries %d\n",  fPHOSClusters->GetEntriesFast());//fPHOSClustersNormalInputEntries);
   
     //If second input event available, add the clusters.
     //  if(fSecondInputAODTree && fSecondInputAODEvent){  
@@ -1004,12 +1005,12 @@ void AliCaloTrackReader::FillInputPHOS() {
     //
     //                                         if(fDebug > 2 && momentum.E() > 0.1) printf("AliCaloTrackReader::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());
-    //                                         fAODPHOS->Add(clus);    
+    //                                         fPHOSClusters->Add(clus);       
     //                                 }//Pt and Fiducial cut passed.
     //                         }//PHOS cluster
     //                 }// cluster exists
     //         }// cluster loop
-    //         if(fDebug > 1) printf("AliCaloTrackReader::FillInputPHOS()  - aod normal entries %d, after second input %d\n", fAODPHOSNormalInputEntries, fAODPHOS->GetEntriesFast());
+    //         if(fDebug > 1) printf("AliCaloTrackReader::FillInputPHOS()  - aod normal entries %d, after second input %d\n", fPHOSClustersNormalInputEntries, fPHOSClusters->GetEntriesFast());
     //  }      //second input loop
   
 }
@@ -1030,6 +1031,33 @@ void AliCaloTrackReader::FillInputPHOSCells() {
   
 }
 
+//____________________________________________________________________________
+void AliCaloTrackReader::FillInputVZERO(){
+  //Fill VZERO information in data member, add all the channels information.
+  AliVVZERO* v0 = fInputEvent->GetVZEROData();
+  //printf("Init V0: ADC (%d,%d), Multiplicity (%d,%d) \n",fV0ADC[0],fV0ADC[1],fV0Mul[0],fV0Mul[1]);
+  
+  if (v0) 
+  {
+    AliESDVZERO* esdV0 = dynamic_cast<AliESDVZERO*> (v0);
+    for (Int_t i = 0; i < 32; i++)
+    {
+      if(esdV0){//Only available in ESDs
+        fV0ADC[0] += (Int_t)esdV0->GetAdcV0C(i);
+        fV0ADC[1] += (Int_t)esdV0->GetAdcV0A(i);
+      }
+      fV0Mul[0] += (Int_t)v0->GetMultiplicityV0C(i);
+      fV0Mul[1] += (Int_t)v0->GetMultiplicityV0A(i);
+    }
+    if(fDebug > 0)
+      printf("V0: ADC (%d,%d), Multiplicity (%d,%d) \n",fV0ADC[0],fV0ADC[1],fV0Mul[0],fV0Mul[1]);
+  }
+  else
+  {
+    printf("Cannot retrieve V0 ESD! Run w/ null V0 charges");
+  }
+}
+
 
 //____________________________________________________________________________
 Bool_t AliCaloTrackReader::IsEMCALCluster(AliVCluster* cluster) const {
index 388e30f..1c3b1be 100755 (executable)
@@ -29,7 +29,7 @@ class TTree ;
 class AliStack ; 
 class AliHeader ; 
 class AliGenEventHeader ; 
-class AliVEvent;
+#include "AliVEvent.h"
 class AliAODEvent;
 class AliMCEvent;
 class AliMixedEvent;
@@ -69,20 +69,19 @@ public:
   virtual Int_t   GetDataType()        const { return fDataType       ; }
   virtual void    SetDataType(Int_t data )   { fDataType = data       ; }
 
-  virtual Int_t   GetEventNumber()     const {return fEventNumber     ; }
-  //virtual TString GetCurrentFileName() const {return fCurrentFileName ; }
+  virtual Int_t   GetEventNumber()     const { return fEventNumber    ; }
+  //virtual TString GetCurrentFileName() const { return fCurrentFileName ; }
        
-  TString         GetTaskName()        const {return fTaskName        ; }
-  void            SetTaskName(TString name)  {fTaskName = name        ; }
+  TString         GetTaskName()        const { return fTaskName       ; }
+  void            SetTaskName(TString name)  { fTaskName = name       ; }
     
-
   //---------------------------------------
   //Input/output event setters and getters
   //---------------------------------------
   virtual void    SetInputEvent(AliVEvent* const input) ;
-  virtual void    SetOutputEvent(AliAODEvent* const aod) {fOutputEvent = aod;}
-  virtual void    SetMC(AliMCEvent* const mc)            {fMC  = mc;}
-  virtual void    SetInputOutputMCEvent(AliVEvent* /*esd*/, AliAODEvent* /*aod*/, AliMCEvent* /*mc*/) {;}
+  virtual void    SetOutputEvent(AliAODEvent* const aod) { fOutputEvent = aod ; }
+  virtual void    SetMC(AliMCEvent* const mc)            { fMC          = mc  ; }
+  virtual void    SetInputOutputMCEvent(AliVEvent* /*esd*/, AliAODEvent* /*aod*/, AliMCEvent* /*mc*/) { ; }
   
   // Delta AODs
   virtual TList * GetAODBranchList()      const { return fAODBranchList        ; }
@@ -97,51 +96,51 @@ public:
   //------------------------------------------------------------
   
   //Minimum pt setters and getters 
-  virtual Float_t  GetEMCALPtMin()      const { return fEMCALPtMin ; }
-  virtual Float_t  GetPHOSPtMin()       const { return fPHOSPtMin  ; }
-  virtual Float_t  GetCTSPtMin()        const { return fCTSPtMin   ; }
+  virtual Float_t  GetEMCALPtMin()        const { return fEMCALPtMin ; }
+  virtual Float_t  GetPHOSPtMin()         const { return fPHOSPtMin  ; }
+  virtual Float_t  GetCTSPtMin()          const { return fCTSPtMin   ; }
   
-  virtual void     SetEMCALPtMin(Float_t  pt) { fEMCALPtMin = pt   ; }
-  virtual void     SetPHOSPtMin(Float_t  pt)  { fPHOSPtMin  = pt   ; }
-  virtual void     SetCTSPtMin(Float_t  pt)   { fCTSPtMin   = pt   ; }  
+  virtual void     SetEMCALPtMin(Float_t  pt)   { fEMCALPtMin = pt   ; }
+  virtual void     SetPHOSPtMin(Float_t  pt)    { fPHOSPtMin  = pt   ; }
+  virtual void     SetCTSPtMin(Float_t  pt)     { fCTSPtMin   = pt   ; }  
   
   // Fidutial cuts  
-  virtual AliFiducialCut * GetFiducialCut()   {if(!fFiducialCut) fFiducialCut = new AliFiducialCut(); 
-    return  fFiducialCut ;}
+  virtual AliFiducialCut * GetFiducialCut()     { if(!fFiducialCut) fFiducialCut = new AliFiducialCut(); 
+                                                return  fFiducialCut ;}
   virtual void SetFiducialCut(AliFiducialCut * const fc) { fFiducialCut = fc ;}
-  virtual Bool_t IsFiducialCutOn()     const  { return fCheckFidCut ; }
-  virtual void SwitchOnFiducialCut()          { fCheckFidCut = kTRUE;  fFiducialCut = new AliFiducialCut();}
-  virtual void SwitchOffFiducialCut()         { fCheckFidCut = kFALSE;}
+  virtual Bool_t IsFiducialCutOn()        const { return fCheckFidCut   ; }
+  virtual void SwitchOnFiducialCut()            { fCheckFidCut = kTRUE;  fFiducialCut = new AliFiducialCut();}
+  virtual void SwitchOffFiducialCut()           { fCheckFidCut = kFALSE ; }
   
   // Cluster origin
   Bool_t IsEMCALCluster(AliVCluster *clus) const;
   Bool_t IsPHOSCluster (AliVCluster *clus) const;
   //Patch for cluster origin for Old AODs implementation
-  void   SwitchOnOldAODs()         { fOldAOD = kTRUE     ; }
-  void   SwitchOffOldAODs()        { fOldAOD = kFALSE    ; }
+  void   SwitchOnOldAODs()              { fOldAOD = kTRUE          ; }
+  void   SwitchOffOldAODs()             { fOldAOD = kFALSE         ; }
   
   // Cluster/track/cells switchs
-  Bool_t IsCTSSwitchedOn()   const { return fFillCTS     ; }
-  void   SwitchOnCTS()             { fFillCTS = kTRUE    ; }
-  void   SwitchOffCTS()            { fFillCTS = kFALSE   ; }
+  Bool_t IsCTSSwitchedOn()        const { return fFillCTS          ; }
+  void   SwitchOnCTS()                  { fFillCTS = kTRUE         ; }
+  void   SwitchOffCTS()                 { fFillCTS = kFALSE        ; }
 
-  Bool_t IsEMCALSwitchedOn() const { return fFillEMCAL   ; }
-  void   SwitchOnEMCAL()           { fFillEMCAL = kTRUE  ; }
-  void   SwitchOffEMCAL()          { fFillEMCAL = kFALSE ; }
+  Bool_t IsEMCALSwitchedOn()      const { return fFillEMCAL        ; }
+  void   SwitchOnEMCAL()                { fFillEMCAL = kTRUE       ; }
+  void   SwitchOffEMCAL()               { fFillEMCAL = kFALSE      ; }
 
-  Bool_t IsPHOSSwitchedOn()  const { return fFillPHOS    ; }
-  void   SwitchOnPHOS()            { fFillPHOS = kTRUE   ; }
-  void   SwitchOffPHOS()           { fFillPHOS = kFALSE  ; }
+  Bool_t IsPHOSSwitchedOn()       const { return fFillPHOS         ; }
+  void   SwitchOnPHOS()                 { fFillPHOS = kTRUE        ; }
+  void   SwitchOffPHOS()                { fFillPHOS = kFALSE       ; }
 
   Bool_t IsEMCALCellsSwitchedOn() const { return fFillEMCALCells   ; }
   void   SwitchOnEMCALCells()           { fFillEMCALCells = kTRUE  ; }
   void   SwitchOffEMCALCells()          { fFillEMCALCells = kFALSE ; }
 
-  Bool_t IsPHOSCellsSwitchedOn()  const { return fFillPHOSCells   ; }
-  void   SwitchOnPHOSCells()            { fFillPHOSCells = kTRUE  ; }
-  void   SwitchOffPHOSCells()           { fFillPHOSCells = kFALSE ; }
+  Bool_t IsPHOSCellsSwitchedOn()  const { return fFillPHOSCells    ; }
+  void   SwitchOnPHOSCells()            { fFillPHOSCells = kTRUE   ; }
+  void   SwitchOffPHOSCells()           { fFillPHOSCells = kFALSE  ; }
 
-  // Filling/ filtering methods
+  // Filling/ filtering / detector information access methods
   virtual Bool_t FillInputEvent(const Int_t iEntry, const char *currentFileName)  ;
   virtual void   FillInputCTS() ;
   virtual void   FillInputEMCAL() ;
@@ -149,15 +148,19 @@ public:
   virtual void   FillInputPHOS() ;
   virtual void   FillInputEMCALCells() ;
   virtual void   FillInputPHOSCells() ;
+  virtual void   FillInputVZERO() ;  
+  
+  Int_t          GetV0Signal(Int_t i)                    const { return fV0ADC[i] ; }
+  Int_t          GetV0Multiplicity(Int_t i)              const { return fV0Mul[i] ; }
+  
   void           SetEMCALClusterListName(TString &name) {fEMCALClustersListName = name ; }
 
-  // Arrayes with clusters/track/cells access methods
-  //FIXME CHANGE NAMES, remove AOD, now they are VClusters, VTracks ...
-  virtual TObjArray*     GetAODCTS()      const { return fAODCTS     ; }
-  virtual TObjArray*     GetAODEMCAL()    const { return fAODEMCAL   ; }
-  virtual TObjArray*     GetAODPHOS()     const { return fAODPHOS    ; }
-  virtual AliVCaloCells* GetEMCALCells()  const { return fEMCALCells ; }
-  virtual AliVCaloCells* GetPHOSCells()   const { return fPHOSCells  ; }
+  // Arrayes with clusters/track/cells access method
+  virtual TObjArray*     GetCTSTracks()     const { return fCTSTracks     ; }
+  virtual TObjArray*     GetEMCALClusters() const { return fEMCALClusters ; }
+  virtual TObjArray*     GetPHOSClusters()  const { return fPHOSClusters  ; }
+  virtual AliVCaloCells* GetEMCALCells()    const { return fEMCALCells    ; }
+  virtual AliVCaloCells* GetPHOSCells()     const { return fPHOSCells     ; }
 
   //Methods for mixing with external input file (AOD)
   //virtual TTree* GetSecondInputAODTree() const {return  fSecondInputAODTree ; } 
@@ -184,13 +187,13 @@ public:
   // Event/track selection methods
   //-------------------------------------
   
-  void    SetFiredTriggerClassName(TString name ) { fFiredTriggerClassName = name ; }
-  TString GetFiredTriggerClassName()        const { return fFiredTriggerClassName ; }
-  virtual TString GetFiredTriggerClasses()        { return ""                     ; } // look the ESD/AOD reader 
+  void    SetFiredTriggerClassName(TString name ) { fFiredTriggerClassName = name   ; }
+  TString GetFiredTriggerClassName()        const { return fFiredTriggerClassName   ; }
+  virtual TString GetFiredTriggerClasses()        { return ""                       ; } // look the ESD/AOD reader 
   
-  void    SwitchOnEventSelection()                { fDoEventSelection = kTRUE  ; }
-  void    SwitchOffEventSelection()               { fDoEventSelection = kFALSE ; }
-  Bool_t  IsEventSelectionDone()            const { return fDoEventSelection   ; } 
+  void    SwitchOnEventSelection()                { fDoEventSelection = kTRUE       ; }
+  void    SwitchOffEventSelection()               { fDoEventSelection = kFALSE      ; }
+  Bool_t  IsEventSelectionDone()            const { return fDoEventSelection        ; } 
   
   void    SwitchOnV0ANDSelection()                { fDoV0ANDEventSelection = kTRUE  ; }
   void    SwitchOffV0ANDSelection()               { fDoV0ANDEventSelection = kFALSE ; }
@@ -207,62 +210,58 @@ public:
   void    SetTrackMultiplicityEtaCut(Float_t eta) { fTrackMultEtaCut = eta  ; }                
   
   // Calorimeter specific and patches
-  void    AnalyzeOnlyLED()                        {fAnaLED = kTRUE  ; }
-  void    AnalyzeOnlyPhysics()                    {fAnaLED = kFALSE ; }
+  void    AnalyzeOnlyLED()                        { fAnaLED = kTRUE         ; }
+  void    AnalyzeOnlyPhysics()                    { fAnaLED = kFALSE        ; }
   
-  void    SwitchOnCaloFilterPatch()               {fCaloFilterPatch = kTRUE ; fFillCTS = kFALSE    ; }
-  void    SwitchOffCaloFilterPatch()              {fCaloFilterPatch = kFALSE                       ; }
-  Bool_t  IsCaloFilterPatchOn()             const {if(fDataType == kAOD) { return fCaloFilterPatch ; } 
-                                                   else                  { return kFALSE           ; } }
+  void    SwitchOnCaloFilterPatch()               { fCaloFilterPatch = kTRUE ; fFillCTS = kFALSE    ; }
+  void    SwitchOffCaloFilterPatch()              { fCaloFilterPatch = kFALSE                       ; }
+  Bool_t  IsCaloFilterPatchOn()             const { if(fDataType == kAOD) { return fCaloFilterPatch ; } 
+                                                    else                  { return kFALSE           ; } }
        
   //-------------------------------
   //Vertex methods
   //-------------------------------
   virtual void      GetVertex(Double_t v[3])        const ;
-  virtual Double_t* GetVertex(const Int_t evtIndex) const {return fVertex[evtIndex];}
+  virtual Double_t* GetVertex(const Int_t evtIndex) const { return fVertex[evtIndex]            ; }
   virtual void      GetVertex(Double_t vertex[3],   const Int_t evtIndex) const ;
   virtual void      FillVertexArray();
   virtual Bool_t    CheckForPrimaryVertex();
  // virtual void       GetSecondInputAODVertex(Double_t *) const {;}
-  virtual Float_t   GetZvertexCut()                 const {return fZvtxCut ;} //cut on vertex position  
-  virtual void      SetZvertexCut(Float_t zcut=10.)       {fZvtxCut=zcut   ;} //cut on vertex position
+  virtual Float_t   GetZvertexCut()                 const { return fZvtxCut                     ; } //cut on vertex position  
+  virtual void      SetZvertexCut(Float_t zcut=10.)       { fZvtxCut=zcut                       ; } //cut on vertex position
 
   //------------------------
   // Centrality
   //------------------------
-  virtual AliCentrality* GetCentrality() const {return 0x0;} //Actual method to recover the pointer is in the ESD/AODReader
-  void    SetCentralityClass(TString name)     { fCentralityClass   = name       ;}
-  void    SetCentralityOpt(Int_t opt)          { fCentralityOpt     = opt        ;}
-  TString GetCentralityClass()           const { return fCentralityClass         ;}
-  Int_t   GetCentralityOpt()             const { return fCentralityOpt           ;}
-  Int_t   GetEventCentrality()           const ;
-  void    SetCentralityBin(Int_t min, Int_t max) //Set the centrality bin to select the event. If used, then need to get percentile
-                                               {fCentralityBin[0]=min; fCentralityBin[1]=max;  
-                                                if(min>=0 && max > 0) fCentralityOpt = 100 ; }
-  Float_t GetCentralityBin(Int_t i)     const  { if(i < 0 || i > 1) return 0 ; 
-                                                else return fCentralityBin[i]   ; }
+  virtual AliCentrality* GetCentrality()            const { return fInputEvent->GetCentrality() ; }
+  virtual void      SetCentralityClass(TString name)      { fCentralityClass   = name           ; }
+  virtual void      SetCentralityOpt(Int_t opt)           { fCentralityOpt     = opt            ; }
+  virtual TString   GetCentralityClass()            const { return fCentralityClass             ; }
+  virtual Int_t     GetCentralityOpt()              const { return fCentralityOpt               ; }
+  virtual Int_t     GetEventCentrality()            const ;
+  virtual void      SetCentralityBin(Int_t min, Int_t max) //Set the centrality bin to select the event. If used, then need to get percentile
+                                                          { fCentralityBin[0]=min; fCentralityBin[1]=max;  
+                                                           if(min>=0 && max > 0) fCentralityOpt = 100 ; }
+  virtual Float_t GetCentralityBin(Int_t i)        const { if(i < 0 || i > 1) return 0 ; 
+                                                           else return fCentralityBin[i]              ; }
   
   //-------------------------------------
   // Other methods
   //-------------------------------------
-  AliCalorimeterUtils * GetCaloUtils()            const { return fCaloUtils      ; }
-  void   SetCaloUtils(AliCalorimeterUtils * caloutils)  { fCaloUtils = caloutils ; }  
+  AliCalorimeterUtils * GetCaloUtils()            const { return fCaloUtils                       ; }
+  void   SetCaloUtils(AliCalorimeterUtils * caloutils)  { fCaloUtils = caloutils                  ; }  
   
-  void   SwitchOnSuspiciousClustersRemoval()            { fRemoveSuspiciousClusters = kTRUE ;  }
-  void   SwitchOffSuspiciousClustersRemoval()           { fRemoveSuspiciousClusters = kFALSE ; }
-  Bool_t IsSuspiciousClustersRemovalOn()          const { return fRemoveSuspiciousClusters   ; } 
+  void   SwitchOnSuspiciousClustersRemoval()            { fRemoveSuspiciousClusters = kTRUE       ; }
+  void   SwitchOffSuspiciousClustersRemoval()           { fRemoveSuspiciousClusters = kFALSE      ; }
+  Bool_t IsSuspiciousClustersRemovalOn()          const { return fRemoveSuspiciousClusters        ; } 
   
   //Use only for MC
-  void    SwitchOnClusterEnergySmearing()               { fSmearClusterEnergy = kTRUE    ; }
-  void    SwitchOffClusterEnergySmearing()              { fSmearClusterEnergy = kFALSE   ; }
-  Bool_t  IsClusterEnergySmeared()                const { return fSmearClusterEnergy     ; }   
+  void    SwitchOnClusterEnergySmearing()               { fSmearClusterEnergy = kTRUE             ; }
+  void    SwitchOffClusterEnergySmearing()              { fSmearClusterEnergy = kFALSE            ; }
+  Bool_t  IsClusterEnergySmeared()                const { return fSmearClusterEnergy              ; }   
   void    SetSmearingParameters(Int_t i, Float_t param) { if(i < 3)fSmearClusterParam[i] = param  ; }
-  
-  virtual void FillInputVZERO()                         { ; } // done in the AOD/ESD reader
-  Int_t   GetV0Signal(Int_t i)                    const { return fV0ADC[i] ; }
-  Int_t   GetV0Multiplicity(Int_t i)              const { return fV0Mul[i] ; }
-  
-  virtual Double_t GetBField()                    const { return 0.        ; } // get in the AOD/ESD reader
+    
+  virtual Double_t GetBField()                    const { return fInputEvent->GetMagneticField()  ; } 
   
   //------------------------------------------------
   // MC analysis specific methods
@@ -309,7 +308,9 @@ public:
   virtual void SwitchOffStatusSelection()                     { ; }
   virtual void SwitchOnOverlapCheck()                         { ; }
   virtual void SwitchOffOverlapCheck()                        { ; }
-  
+  virtual void SwitchOnOnlyGeneratorParticles()               { ; }
+  virtual void SwitchOffOnlyGeneratorParticles()              { ; }
+
   virtual void SetEMCALOverlapAngle(Float_t /*angle*/)        { ; }
   virtual void SetPHOSOverlapAngle(Float_t /*angle*/)         { ; }
 
@@ -331,11 +332,11 @@ public:
 
   TList          * fAODBranchList ; //! List with AOD branches created and needed in analysis  
   //FIXME CHANGE NAMES, remove AOD, now they are VClusters, VTracks ...
-  TObjArray      * fAODCTS ;        //! temporal referenced array with tracks
-  TObjArray      * fAODEMCAL ;      //! temporal referenced array with EMCAL CaloClusters
-  TObjArray      * fAODPHOS ;       //! temporal referenced array with PHOS CaloClusters
-  AliVCaloCells  * fEMCALCells ;    //! temporal array with EMCAL CaloCells, ESD or AOD
-  AliVCaloCells  * fPHOSCells ;     //! temporal array with PHOS CaloCells, ESD or AOD
+  TObjArray      * fCTSTracks ;     //! temporal array with tracks
+  TObjArray      * fEMCALClusters ; //! temporal array with EMCAL CaloClusters
+  TObjArray      * fPHOSClusters ;  //! temporal array with PHOS  CaloClusters
+  AliVCaloCells  * fEMCALCells ;    //! temporal array with EMCAL CaloCells
+  AliVCaloCells  * fPHOSCells ;     //! temporal array with PHOS  CaloCells
 
   AliVEvent      * fInputEvent;     //! pointer to esd or aod input
   AliAODEvent    * fOutputEvent;    //! pointer to aod output
@@ -398,7 +399,7 @@ public:
   Int_t            fCentralityOpt;      // Option for the returned value of the centrality, possible options 5, 10, 100
   Int_t            fCentralityBin[2];   // Minimum and maximum value of the centrality for the analysis
   
-  ClassDef(AliCaloTrackReader,26)
+  ClassDef(AliCaloTrackReader,27)
 } ;
 
 
index 398a2ee..196bd69 100644 (file)
@@ -238,10 +238,10 @@ void  AliAnaBtag::MakeAnalysisFillAOD()
   //Double_t bfield = 0.;\r
   if(GetDebug()>0) printf("AliAnaBtag::MakeAnalysisFillAOD() - Write ntuple flag is %d \n",fWriteNtuple);\r
   //if(GetReader()->GetDataType() != AliCaloTrackReader::kMC) bfield = GetReader()->GetBField();\r
-  TObjArray *cl = GetAODEMCAL();\r
+  TObjArray *cl = GetEMCALClusters();\r
   \r
-  if(!GetAODCTS() || GetAODCTS()->GetEntriesFast() == 0) return ;\r
-  Int_t ntracks = GetAODCTS()->GetEntriesFast();\r
+  if(!GetCTSTracks() || GetCTSTracks()->GetEntriesFast() == 0) return ;\r
+  Int_t ntracks = GetCTSTracks()->GetEntriesFast();\r
   if(GetDebug() > 0)\r
     printf("AliAnaBtag::MakeAnalysisFillAOD() - In CTS aod entries %d\n", ntracks);\r
   \r
@@ -264,7 +264,7 @@ void  AliAnaBtag::MakeAnalysisFillAOD()
   \r
   for (Int_t itrk =  0; itrk <  ntracks; itrk++) {////////////// track loop\r
     iCluster = -999; //start with no match\r
-    AliAODTrack * track = (AliAODTrack*) (GetAODCTS()->At(itrk)) ;\r
+    AliAODTrack * track = (AliAODTrack*) (GetCTSTracks()->At(itrk)) ;\r
     if(track->GetLabel()<0){\r
       if(GetDebug()>0)\r
         printf("Negative track label, aborting!\n");\r
@@ -656,10 +656,10 @@ Int_t AliAnaBtag::GetDVMBtag(AliAODTrack * tr, Int_t &pair, Int_t &start, Int_t
 //   Int_t nvtx2 = 0;\r
 //   Int_t nvtx3 = 0;\r
 \r
-  for (Int_t k2 =0; k2 < GetAODCTS()->GetEntriesFast() ; k2++) {\r
+  for (Int_t k2 =0; k2 < GetCTSTracks()->GetEntriesFast() ; k2++) {\r
 \r
     //loop over assoc\r
-    AliAODTrack* track2 = (AliAODTrack*)GetAODCTS()->At(k2);\r
+    AliAODTrack* track2 = (AliAODTrack*)GetCTSTracks()->At(k2);\r
     Int_t id1 = tr->GetID();\r
     Int_t id2 = track2->GetID();\r
     if(id1 == id2) continue;\r
index f8b1f43..c22198b 100755 (executable)
@@ -1362,13 +1362,13 @@ void  AliAnaCalorimeterQA::MakeAnalysisFillHistograms()
   
   
   //Get List with CaloClusters  
-  if      (fCalorimeter == "PHOS")  caloClusters = GetAODPHOS();
-  else if (fCalorimeter == "EMCAL") caloClusters = GetAODEMCAL();
+  if      (fCalorimeter == "PHOS")  caloClusters = GetPHOSClusters();
+  else if (fCalorimeter == "EMCAL") caloClusters = GetEMCALClusters();
   else 
     AliFatal(Form("AliAnaCalorimeterQA::MakeAnalysisFillHistograms() - Wrong calorimeter name <%s>, END\n", fCalorimeter.Data()));
   
-  //  if     (fCalorimeter == "EMCAL") GetReader()->GetInputEvent()->GetEMCALClusters(caloClusters);//GetAODEMCAL();
-  //  else if(fCalorimeter == "PHOS")  GetReader()->GetInputEvent()->GetPHOSClusters (caloClusters);//GetAODPHOS();
+  //  if     (fCalorimeter == "EMCAL") GetReader()->GetInputEvent()->GetEMCALClusters(caloClusters);//GetEMCALClusters();
+  //  else if(fCalorimeter == "PHOS")  GetReader()->GetInputEvent()->GetPHOSClusters (caloClusters);//GetPHOSClusters();
   //  else 
   //    AliFatal(Form("AliAnaCalorimeterQA::MakeAnalysisFillHistograms() - Wrong calorimeter name <%s>, END\n", fCalorimeter.Data()));
   
@@ -2338,8 +2338,8 @@ void AliAnaCalorimeterQA::Correlate(){
   // Correlate information from PHOS and EMCAL and with V0 and track multiplicity
  
   //Clusters 
-  TObjArray * caloClustersEMCAL = GetAODEMCAL();
-  TObjArray * caloClustersPHOS  = GetAODPHOS();
+  TObjArray * caloClustersEMCAL = GetEMCALClusters();
+  TObjArray * caloClustersPHOS  = GetPHOSClusters();
   
   Int_t nclEMCAL = caloClustersEMCAL->GetEntriesFast();
   Int_t nclPHOS  = caloClustersPHOS ->GetEntriesFast();
index 0f8cc0c..20519e7 100755 (executable)
@@ -262,8 +262,8 @@ void AliAnaChargedParticles::Init()
 void  AliAnaChargedParticles::MakeAnalysisFillAOD() 
 {
   //Do analysis and fill aods
-  if(!GetAODCTS() || GetAODCTS()->GetEntriesFast() == 0) return ;
-  Int_t ntracks = GetAODCTS()->GetEntriesFast();
+  if(!GetCTSTracks() || GetCTSTracks()->GetEntriesFast() == 0) return ;
+  Int_t ntracks = GetCTSTracks()->GetEntriesFast();
   Double_t vert[3] = {0,0,0}; //vertex ;
   //Some prints
   if(GetDebug() > 0)
@@ -274,7 +274,7 @@ void  AliAnaChargedParticles::MakeAnalysisFillAOD()
   Int_t evtIndex = 0;
   for(Int_t i = 0; i < ntracks; i++){
     
-    AliAODTrack * track =  (AliAODTrack*) (GetAODCTS()->At(i));
+    AliAODTrack * track =  (AliAODTrack*) (GetCTSTracks()->At(i));
     
     //Fill AODParticle after some selection       
     Double_t mom[3] = {track->Px(),track->Py(),track->Pz()};
@@ -298,7 +298,7 @@ void  AliAnaChargedParticles::MakeAnalysisFillAOD()
       tr.SetTrackLabel(track->GetID(),-1);
     //  tr.SetChargedBit(track->Charge());
          //Input from second AOD?
-         //if(GetReader()->GetAODCTSNormalInputEntries() <= i) tr.SetInputFileIndex(1);
+         //if(GetReader()->GetCTSTracksNormalInputEntries() <= i) tr.SetInputFileIndex(1);
                
       AddAODParticle(tr);
     }//selection
@@ -328,7 +328,7 @@ void  AliAnaChargedParticles::MakeAnalysisFillHistograms()
     fhPhi->Fill(tr->Pt(), tr->Phi());
     fhEta->Fill(tr->Pt(), tr->Eta());
     //for charge information
-    AliAODTrack * track =  (AliAODTrack*) (GetAODCTS()->At(iaod));
+    AliAODTrack * track =  (AliAODTrack*) (GetCTSTracks()->At(iaod));
     if(track->Charge()>0)fhPtEtaPhiPos->Fill(tr->Pt(), tr->Eta(),tr->Phi());
     if(track->Charge()<0)fhPtEtaPhiNeg->Fill(tr->Pt(), tr->Eta(),tr->Phi());
     
index 196d052..f1ac76b 100755 (executable)
@@ -677,13 +677,13 @@ void  AliAnaElectron::MakeAnalysisFillAOD()
     abort();\r
   }\r
   \r
-  TObjArray *cl = GetAODEMCAL();\r
+  TObjArray *cl = GetEMCALClusters();\r
   \r
   ////////////////////////////////////////////////\r
   //Start from tracks and get associated clusters \r
   ////////////////////////////////////////////////\r
-  if(!GetAODCTS() || GetAODCTS()->GetEntriesFast() == 0) return ;\r
-  Int_t ntracks = GetAODCTS()->GetEntriesFast();\r
+  if(!GetCTSTracks() || GetCTSTracks()->GetEntriesFast() == 0) return ;\r
+  Int_t ntracks = GetCTSTracks()->GetEntriesFast();\r
   Int_t refmult = 0; Int_t refmult2 = 0;\r
   if(GetDebug() > 0)\r
     printf("AliAnaElectron::MakeAnalysisFillAOD() - In CTS aod entries %d\n", ntracks);\r
@@ -695,7 +695,7 @@ void  AliAnaElectron::MakeAnalysisFillAOD()
 \r
   for (Int_t itrk =  0; itrk <  ntracks; itrk++) {////////////// track loop\r
     iCluster = -999; //start with no match\r
-    AliAODTrack * track = (AliAODTrack*) (GetAODCTS()->At(itrk)) ;\r
+    AliAODTrack * track = (AliAODTrack*) (GetCTSTracks()->At(itrk)) ;\r
     //Added negative track condition. Seems that about 3-4% of the tracks have negative label. Causes crashes sometimes.\r
     if(track->GetLabel()<0){\r
       printf("Negative track label! Not sure what it  means, abort track. \n");\r
@@ -771,7 +771,7 @@ void  AliAnaElectron::MakeAnalysisFillAOD()
        if(IsDataMC()) {\r
          //Input from second AOD?\r
          Int_t input = 0;\r
-         //if(GetReader()->GetAODCTSNormalInputEntries() <= itrk) input = 1;\r
+         //if(GetReader()->GetCTSTracksNormalInputEntries() <= itrk) input = 1;\r
          tmctag = GetMCAnalysisUtils()->CheckOrigin(track->GetLabel(),GetReader(),input);\r
 \r
          if(trkChgHad) fhPtHadron->Fill(track->Pt(),GetMCSource(tmctag));\r
@@ -845,7 +845,7 @@ void  AliAnaElectron::MakeAnalysisFillAOD()
            if(IsDataMC()) {  \r
              //Do you want the cluster or the track label?\r
              Int_t input = 0;\r
-             //if(GetReader()->GetAODEMCALNormalInputEntries() <= iclus) input = 1;\r
+             //if(GetReader()->GetEMCALClustersNormalInputEntries() <= iclus) input = 1;\r
              cmctag = GetMCAnalysisUtils()->CheckOrigin(clus->GetLabel(),GetReader(),input);\r
            }\r
            \r
@@ -906,7 +906,7 @@ void  AliAnaElectron::MakeAnalysisFillAOD()
            tr.SetDetector("CTS"); //PID determined by CTS\r
          }\r
 \r
-         //if(GetReader()->GetAODCTSNormalInputEntries() <= itrk) tr.SetInputFileIndex(1);\r
+         //if(GetReader()->GetCTSTracksNormalInputEntries() <= itrk) tr.SetInputFileIndex(1);\r
          //Make this preserve sign of particle\r
          if(track->Charge() < 0) tr.SetPdg(11); //electron is 11\r
          else  tr.SetPdg(-11); //positron is -11\r
@@ -1339,9 +1339,9 @@ Int_t AliAnaElectron::GetDVMBtag(AliAODTrack * tr )
   Int_t nvtx2 = 0;\r
   Int_t nvtx3 = 0;\r
 \r
-  for (Int_t k2 =0; k2 < GetAODCTS()->GetEntriesFast() ; k2++) {\r
+  for (Int_t k2 =0; k2 < GetCTSTracks()->GetEntriesFast() ; k2++) {\r
     //loop over assoc\r
-    AliAODTrack* track2 = (AliAODTrack*)GetAODCTS()->At(k2);\r
+    AliAODTrack* track2 = (AliAODTrack*)GetCTSTracks()->At(k2);\r
     Int_t id1 = tr->GetID();\r
     Int_t id2 = track2->GetID();\r
     if(id1 == id2) continue;\r
@@ -1482,14 +1482,14 @@ Double_t AliAnaElectron::GetIPSignificance(AliAODTrack *tr, Double_t jetPhi)
   //for the given jet\r
 \r
   Int_t trackIndex = 0;\r
-  Int_t ntrk = GetAODCTS()->GetEntriesFast();\r
+  Int_t ntrk = GetCTSTracks()->GetEntriesFast();\r
   for (Int_t k2 =0; k2 < ntrk ; k2++) {\r
     //loop over assoc\r
-    AliAODTrack* track2 = (AliAODTrack*)GetAODCTS()->At(k2);\r
+    AliAODTrack* track2 = (AliAODTrack*)GetCTSTracks()->At(k2);\r
     int id1 = tr->GetID();\r
     int id2 = track2->GetID();\r
     if(id1 == id2) {\r
-      trackIndex = k2;//FIXME: check if GetAODCTS stores tracks in the\r
+      trackIndex = k2;//FIXME: check if GetCTSTracks stores tracks in the\r
                      //same order of the event\r
       break;\r
     }\r
@@ -1575,7 +1575,7 @@ Bool_t AliAnaElectron::PhotonicPrim(const AliAODPWG4Particle* part)
 \r
   Int_t pdg1 = part->GetPdg();\r
   Int_t trackId = part->GetTrackLabel(0);\r
-  AliAODTrack* track = (AliAODTrack*)GetAODCTS()->At(trackId);\r
+  AliAODTrack* track = (AliAODTrack*)GetCTSTracks()->At(trackId);\r
   if(!track) {\r
     if(GetDebug() > 0) printf("AliAnaElectron::PhotonicPrim - can't get the AOD Track from the particle!  Skipping the photonic check");\r
     return kFALSE; //Don't proceed because we can't get the track\r
@@ -1596,7 +1596,7 @@ Bool_t AliAnaElectron::PhotonicPrim(const AliAODPWG4Particle* part)
     if(pdg1*pdg2 > 0) continue; //skip same-sign pairs\r
 \r
     //propagate to common vertex and check opening angle\r
-    AliAODTrack* track2 = (AliAODTrack*)GetAODCTS()->At(track2Id);\r
+    AliAODTrack* track2 = (AliAODTrack*)GetCTSTracks()->At(track2Id);\r
     if(!track2) {\r
       if(GetDebug() >0) printf("AliAnaElectron::PhotonicPrim - problem getting the partner track.  Continuing on to the next one");\r
       continue;\r
index 505cf48..f1259a8 100755 (executable)
@@ -144,16 +144,16 @@ void  AliAnaExample::MakeAnalysisFillAOD()
   
   //Some prints
   if(GetDebug() > 0){
-    if(fDetector == "EMCAL" && GetAODEMCAL())printf("AliAnaExample::MakeAnalysisFillAOD() - In EMCAL aod entries %d\n", GetAODEMCAL()->GetEntriesFast());
-    if(fDetector == "CTS"   && GetAODCTS())  printf("AliAnaExample::MakeAnalysisFillAOD() - In CTS aod entries %d\n",   GetAODCTS()  ->GetEntriesFast());
-    if(fDetector == "PHOS"  && GetAODPHOS()) printf("AliAnaExample::MakeAnalysisFillAOD() - In PHOS aod entries %d\n",  GetAODPHOS() ->GetEntriesFast());
+    if(fDetector == "EMCAL" && GetEMCALClusters())printf("AliAnaExample::MakeAnalysisFillAOD() - In EMCAL aod entries %d\n", GetEMCALClusters()->GetEntriesFast());
+    if(fDetector == "CTS"   && GetCTSTracks())  printf("AliAnaExample::MakeAnalysisFillAOD() - In CTS aod entries %d\n",   GetCTSTracks()  ->GetEntriesFast());
+    if(fDetector == "PHOS"  && GetPHOSClusters()) printf("AliAnaExample::MakeAnalysisFillAOD() - In PHOS aod entries %d\n",  GetPHOSClusters() ->GetEntriesFast());
   }
   
   //Get List with tracks or clusters  
   TObjArray * partList = 0x0;
-  if(fDetector == "CTS")        partList = GetAODCTS();
-  else if(fDetector == "EMCAL") partList = GetAODEMCAL();
-  else if(fDetector == "PHOS")  partList = GetAODPHOS();
+  if(fDetector == "CTS")        partList = GetCTSTracks();
+  else if(fDetector == "EMCAL") partList = GetEMCALClusters();
+  else if(fDetector == "PHOS")  partList = GetPHOSClusters();
   
   if(!partList || partList->GetEntriesFast() == 0) return ;
   
@@ -213,9 +213,9 @@ void  AliAnaExample::MakeAnalysisFillAOD()
   else if(fDetector == "CTS"){ //Track analysis
     //Fill AODParticle with CTS aods
     TVector3 p3;
-    for(Int_t i = 0; i < GetAODCTS()->GetEntriesFast(); i++){
+    for(Int_t i = 0; i < GetCTSTracks()->GetEntriesFast(); i++){
       
-      AliAODTrack * track =  (AliAODTrack*) (GetAODCTS()->At(i));
+      AliAODTrack * track =  (AliAODTrack*) (GetCTSTracks()->At(i));
       
       //Fill AODParticle after some selection       
       Double_t mom[3] = {track->Px(),track->Py(),track->Pz()};
index 81c86cc..38015d5 100755 (executable)
@@ -614,16 +614,16 @@ void  AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD()
   if(GetDebug() > 1){
     printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - Begin hadron correlation analysis, fill AODs \n");
     printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - In particle branch aod entries %d\n", GetInputAODBranch()->GetEntriesFast());
-    printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - In CTS aod entries %d\n", GetAODCTS()->GetEntriesFast());
-    printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - In EMCAL aod entries %d\n", GetAODEMCAL()->GetEntriesFast());
-    printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - In PHOS aod entries %d\n", GetAODPHOS()->GetEntriesFast());
+    printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - In CTS aod entries %d\n", GetCTSTracks()->GetEntriesFast());
+    printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - In EMCAL aod entries %d\n", GetEMCALClusters()->GetEntriesFast());
+    printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - In PHOS aod entries %d\n", GetPHOSClusters()->GetEntriesFast());
   }
   
   //Loop on stored AOD particles, trigger
   Double_t ptTrig    = 0.;
   Int_t    trigIndex = -1;
   Int_t naod = GetInputAODBranch()->GetEntriesFast();
-  //fhNclustersNtracks->Fill(naod, GetAODCTS()->GetEntriesFast());
+  //fhNclustersNtracks->Fill(naod, GetCTSTracks()->GetEntriesFast());
   for(Int_t iaod = 0; iaod < naod ; iaod++){
     AliAODPWG4ParticleCorrelation* particle =  (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(iaod));
     //find the leading particles with highest momentum
@@ -639,7 +639,7 @@ void  AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD()
     AliAODPWG4ParticleCorrelation* particle =  (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(trigIndex));
     //Make correlation with charged hadrons
     if(GetReader()->IsCTSSwitchedOn() )
-      MakeChargedCorrelation(particle, GetAODCTS(),kFALSE);
+      MakeChargedCorrelation(particle, GetCTSTracks(),kFALSE);
     
     TObjArray * pi0list = (TObjArray*) GetAODBranch(fPi0AODBranchName); //For the future, foresee more possible pi0 lists
     if(fNeutralCorr && pi0list && pi0list->GetEntriesFast() > 0)
@@ -734,7 +734,7 @@ void  AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms()
     
     //Make correlation with charged hadrons
     if(GetReader()->IsCTSSwitchedOn() )
-      MakeChargedCorrelation(particle, GetAODCTS(),kTRUE);
+      MakeChargedCorrelation(particle, GetCTSTracks(),kTRUE);
     
     TObjArray * pi0list = (TObjArray*) GetAODBranch(fPi0AODBranchName); //For the future, foresee more possible pi0 lists
     if(fNeutralCorr && pi0list && pi0list->GetEntriesFast() > 0)
@@ -761,7 +761,7 @@ void  AliAnaParticleHadronCorrelation::MakeChargedCorrelation(AliAODPWG4Particle
   GetReader()->GetVertex(v);
   if(!GetMixedEvent() && TMath::Abs(v[2]) > GetZvertexCut()) return ;  
 
-  Int_t nTracks = GetAODCTS()->GetEntriesFast() ;
+  Int_t nTracks = GetCTSTracks()->GetEntriesFast() ;
   
   if (GetMixedEvent()) {
     evtIndex11 = GetMixedEvent()->EventIndexForCaloCluster(aodParticle->GetCaloLabel(0)) ;
@@ -812,8 +812,8 @@ void  AliAnaParticleHadronCorrelation::MakeChargedCorrelation(AliAODPWG4Particle
     if(GetDebug() > 1)printf("indexPhoton1 = %d, indexPhoton2 = %d \n", indexPhoton1, indexPhoton2);
     
     if(indexPhoton1!=-1 && indexPhoton2!=-1){
-      if(aodParticle->GetDetector()=="EMCAL") clusters = GetAODEMCAL() ;
-      else  clusters = GetAODPHOS() ;
+      if(aodParticle->GetDetector()=="EMCAL") clusters = GetEMCALClusters() ;
+      else  clusters = GetPHOSClusters() ;
       for(Int_t iclus = 0; iclus < clusters->GetEntriesFast(); iclus++){
         AliVCluster * photon =  (AliVCluster*) (clusters->At(iclus));  
         photon->GetMomentum(photonMom,GetVertex(0)) ;
@@ -1051,9 +1051,9 @@ void  AliAnaParticleHadronCorrelation::MakeChargedCorrelation(AliAODPWG4Particle
 //
 //      //Input from second AOD?
 //    Int_t inputi = 0;
-//    if     (aodParticle->GetDetector() == "EMCAL" && GetReader()->GetAODEMCALNormalInputEntries() <= iclus) 
+//    if     (aodParticle->GetDetector() == "EMCAL" && GetReader()->GetEMCALClustersNormalInputEntries() <= iclus) 
 //      inputi = 1 ;
-//    else if(aodParticle->GetDetector() == "PHOS"  && GetReader()->GetAODPHOSNormalInputEntries()  <= iclus) 
+//    else if(aodParticle->GetDetector() == "PHOS"  && GetReader()->GetPHOSClustersNormalInputEntries()  <= iclus) 
 //      inputi = 1;
 //    
 //      //Cluster selection, not charged, with photon or pi0 id and in fiducial cut
@@ -1115,9 +1115,9 @@ void  AliAnaParticleHadronCorrelation::MakeChargedCorrelation(AliAODPWG4Particle
 //        
 //          //Input from second AOD?
 //        Int_t inputj = 0;
-//        if     (aodParticle->GetDetector() == "EMCAL" && GetReader()->GetAODEMCALNormalInputEntries() <= jclus) 
+//        if     (aodParticle->GetDetector() == "EMCAL" && GetReader()->GetEMCALClustersNormalInputEntries() <= jclus) 
 //          inputj = 1;
-//        else if(aodParticle->GetDetector() == "PHOS"  && GetReader()->GetAODPHOSNormalInputEntries()  <= jclus) 
+//        else if(aodParticle->GetDetector() == "PHOS"  && GetReader()->GetPHOSClustersNormalInputEntries()  <= jclus) 
 //          inputj = 1;
 //        
 //          //Cluster selection, not charged with photon or pi0 id and in fiducial cut
@@ -1261,8 +1261,8 @@ void  AliAnaParticleHadronCorrelation::MakeNeutralCorrelation(AliAODPWG4Particle
     if(GetDebug() > 1)printf("indexPhoton1 = %d, indexPhoton2 = %d \n", indexPhoton1, indexPhoton2);
     
     if(indexPhoton1!=-1 && indexPhoton2!=-1){
-      if(aodParticle->GetDetector()=="EMCAL") clusters = GetAODEMCAL() ;
-      else                                    clusters = GetAODPHOS() ;
+      if(aodParticle->GetDetector()=="EMCAL") clusters = GetEMCALClusters() ;
+      else                                    clusters = GetPHOSClusters() ;
       for(Int_t iclus = 0; iclus < clusters->GetEntriesFast(); iclus++){
         AliVCluster * photon =  (AliVCluster*) (clusters->At(iclus));  
         photon->GetMomentum(photonMom,GetVertex(0)) ;
index b99a1ba..bd2ec4a 100755 (executable)
@@ -561,9 +561,9 @@ void  AliAnaParticleIsolation::MakeAnalysisFillAOD()
   
   //Select the calorimeter for candidate isolation with neutral particles
   if(fCalorimeter == "PHOS")
-    pl = GetAODPHOS();
+    pl = GetPHOSClusters();
   else if (fCalorimeter == "EMCAL")
-    pl = GetAODEMCAL();
+    pl = GetEMCALClusters();
   
   //Loop on AOD branch, filled previously in AliAnaPhoton
   TLorentzVector mom ;
@@ -593,7 +593,7 @@ void  AliAnaParticleIsolation::MakeAnalysisFillAOD()
 
     //After cuts, study isolation
     n=0; nfrac = 0; isolated = kFALSE; coneptsum = 0;
-    GetIsolationCut()->MakeIsolationCut(GetAODCTS(),pl,GetReader(), kTRUE, aodinput, GetAODObjArrayName(), n,nfrac,coneptsum, isolated);
+    GetIsolationCut()->MakeIsolationCut(GetCTSTracks(),pl,GetReader(), kTRUE, aodinput, GetAODObjArrayName(), n,nfrac,coneptsum, isolated);
     aodinput->SetIsolated(isolated);
     if(GetDebug() > 1 && isolated) printf("AliAnaParticleIsolation::MakeAnalysisFillAOD() : Particle %d IS ISOLATED \n",iaod);  
          
@@ -655,7 +655,7 @@ void  AliAnaParticleIsolation::MakeAnalysisFillHistograms()
     //Tracks
     coneptsum = 0;
     Double_t sumptFR = 0. ;
-    TObjArray * trackList   = GetAODCTS() ;
+    TObjArray * trackList   = GetCTSTracks() ;
     for(Int_t itrack=0; itrack < trackList->GetEntriesFast(); itrack++){
       AliAODTrack* track = (AliAODTrack *) trackList->At(itrack);
       //fill the histograms at forward range
@@ -692,8 +692,8 @@ void  AliAnaParticleIsolation::MakeAnalysisFillHistograms()
       for(Int_t icalo=0; icalo < refclusters->GetEntriesFast(); icalo++){
         AliVCluster* calo = (AliVCluster *) refclusters->At(icalo);
         Int_t input = 0;
-        //                     if     (fCalorimeter == "EMCAL" && GetReader()->GetAODEMCALNormalInputEntries() <= icalo) input = 1 ;
-        //                     else if(fCalorimeter == "PHOS"  && GetReader()->GetAODPHOSNormalInputEntries()  <= icalo) input = 1;
+        //                     if     (fCalorimeter == "EMCAL" && GetReader()->GetEMCALClustersNormalInputEntries() <= icalo) input = 1 ;
+        //                     else if(fCalorimeter == "PHOS"  && GetReader()->GetPHOSClustersNormalInputEntries()  <= icalo) input = 1;
         
         //Get Momentum vector, 
         if     (input == 0) calo->GetMomentum(mom,vertex) ;//Assume that come from vertex in straight line
index 7f40db8..7554570 100755 (executable)
@@ -356,14 +356,14 @@ void  AliAnaParticleJetFinderCorrelation::MakeAnalysisFillHistograms()
     
     Int_t ntracks =  0;
     if(!fUseJetRefTracks)
-      ntracks =GetAODCTS()->GetEntriesFast();
+      ntracks =GetCTSTracks()->GetEntriesFast();
     else //If you want to use jet tracks from JETAN
       ntracks =  (jet->GetRefTracks())->GetEntriesFast();
     
     AliAODTrack* track = 0x0 ;
     for(Int_t ipr = 0;ipr < ntracks ; ipr ++ ){
       if(!fUseJetRefTracks)
-        track = (AliAODTrack *) (GetAODCTS()->At(ipr)) ; 
+        track = (AliAODTrack *) (GetCTSTracks()->At(ipr)) ; 
       else //If you want to use jet tracks from JETAN
         track = (AliAODTrack *) ((jet->GetRefTracks())->At(ipr));
       
index d6f83cf..8916930 100755 (executable)
@@ -901,7 +901,7 @@ void  AliAnaParticleJetLeadingConeCorrelation::GetLeadingCharge(AliAODPWG4Partic
   //Search for the charged particle with highest pt and with 
   //Phi=Phi_trigger-Pi and pT=0.1E_gamma 
   
-  if(GetAODCTS()){
+  if(GetCTSTracks()){
     Double_t ptTrig  = particle->Pt();
     Double_t phiTrig = particle->Phi();
     Double_t rat     = -100 ;
@@ -911,8 +911,8 @@ void  AliAnaParticleJetLeadingConeCorrelation::GetLeadingCharge(AliAODPWG4Partic
     Double_t phi     = -100.;
     TVector3 p3;
     
-    for(Int_t ipr = 0;ipr < GetAODCTS()->GetEntriesFast() ; ipr ++ ){
-      AliAODTrack* track = (AliAODTrack *)(GetAODCTS()->At(ipr)) ;
+    for(Int_t ipr = 0;ipr < GetCTSTracks()->GetEntriesFast() ; ipr ++ ){
+      AliAODTrack* track = (AliAODTrack *)(GetCTSTracks()->At(ipr)) ;
       p3.SetXYZ(track->Px(),track->Py(),track->Pz());
       pt   = p3.Pt();
       phi  = p3.Phi() ;
@@ -941,7 +941,7 @@ void  AliAnaParticleJetLeadingConeCorrelation::GetLeadingPi0(AliAODPWG4ParticleC
   //Search for the neutral pion with highest pt and with 
   //Phi=Phi_trigger-Pi and pT=0.1E_gamma
   
-  if(GetAODEMCAL()){
+  if(GetEMCALClusters()){
     Double_t ptTrig  = particle->Pt();
     Double_t phiTrig = particle->Phi();
     Double_t rat     = -100 ;
@@ -963,13 +963,13 @@ void  AliAnaParticleJetLeadingConeCorrelation::GetLeadingPi0(AliAODPWG4ParticleC
     }
          
     //Cluster loop, select pairs with good pt, phi and fill AODs or histograms
-    for(Int_t iclus = 0;iclus < GetAODEMCAL()->GetEntriesFast() ; iclus ++ ){
-      AliVCluster * calo = (AliVCluster *)(GetAODEMCAL()->At(iclus)) ;
+    for(Int_t iclus = 0;iclus < GetEMCALClusters()->GetEntriesFast() ; iclus ++ ){
+      AliVCluster * calo = (AliVCluster *)(GetEMCALClusters()->At(iclus)) ;
       
       //Input from second AOD?
       //Int_t inputi = 0;
-      //         if     (particle->GetDetector() == "EMCAL" && GetReader()->GetAODEMCALNormalInputEntries() <= iclus) inputi = 1 ;
-      //         else if(particle->GetDetector() == "PHOS"  && GetReader()->GetAODPHOSNormalInputEntries()  <= iclus) inputi = 1;
+      //         if     (particle->GetDetector() == "EMCAL" && GetReader()->GetEMCALClustersNormalInputEntries() <= iclus) inputi = 1 ;
+      //         else if(particle->GetDetector() == "PHOS"  && GetReader()->GetPHOSClustersNormalInputEntries()  <= iclus) inputi = 1;
       
       //Cluster selection, not charged, with photon or pi0 id and in fiducial cut
       Int_t pdgi=0;
@@ -1004,13 +1004,13 @@ void  AliAnaParticleJetLeadingConeCorrelation::GetLeadingPi0(AliAODPWG4ParticleC
       else if(pdgi == AliCaloPID::kPhoton){    
         //Search the photon companion in case it comes from  a Pi0 decay
         //Apply several cuts to select the good pair
-        for(Int_t jclus = iclus+1; jclus < GetAODEMCAL()->GetEntriesFast() ; jclus ++ ){
-          AliVCluster * calo2 = (AliVCluster *) (GetAODEMCAL()->At(jclus)) ;
+        for(Int_t jclus = iclus+1; jclus < GetEMCALClusters()->GetEntriesFast() ; jclus ++ ){
+          AliVCluster * calo2 = (AliVCluster *) (GetEMCALClusters()->At(jclus)) ;
           
           //Input from second AOD?
           //Int_t inputj = 0;
-          //     if     (particle->GetDetector() == "EMCAL" && GetReader()->GetAODEMCALNormalInputEntries() <= jclus) inputj = 1;
-          //     else if(particle->GetDetector() == "PHOS"  && GetReader()->GetAODPHOSNormalInputEntries()  <= jclus) inputj = 1;
+          //     if     (particle->GetDetector() == "EMCAL" && GetReader()->GetEMCALClustersNormalInputEntries() <= jclus) inputj = 1;
+          //     else if(particle->GetDetector() == "PHOS"  && GetReader()->GetPHOSClustersNormalInputEntries()  <= jclus) inputj = 1;
           
           //Cluster selection, not charged with photon or pi0 id and in fiducial cut
           Int_t pdgj=0;
@@ -1295,8 +1295,8 @@ void  AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillAOD()
   if(GetDebug() > 1){
     printf("AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillAOD() - Begin jet leading cone  correlation analysis, fill AODs \n");
     printf("AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillAOD() - In particle branch aod entries %d\n", GetInputAODBranch()->GetEntriesFast());
-    printf("AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillAOD() - In CTS aod entries %d\n", GetAODCTS()->GetEntriesFast());
-    printf("AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillAOD() - In EMCAL aod entries %d\n", GetAODEMCAL()->GetEntriesFast());
+    printf("AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillAOD() - In CTS aod entries %d\n", GetCTSTracks()->GetEntriesFast());
+    printf("AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillAOD() - In EMCAL aod entries %d\n", GetEMCALClusters()->GetEntriesFast());
   }
   
   TLorentzVector pLeading(0,0,0,0); //It will contain the kinematics of the found leading particle
@@ -1336,8 +1336,8 @@ void  AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillHistograms()
   if(GetDebug() > 1){
     printf("AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillHistograms() - Begin jet leading cone  correlation analysis, fill histograms \n");
     printf("AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillHistograms() - In particle branch aod entries %d\n", GetInputAODBranch()->GetEntriesFast());
-    printf("AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillHistograms() - In CTS aod entries %d\n", GetAODCTS()->GetEntriesFast());
-    printf("AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillHistograms() - In EMCAL aod entries %d\n", GetAODEMCAL()->GetEntriesFast());
+    printf("AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillHistograms() - In CTS aod entries %d\n", GetCTSTracks()->GetEntriesFast());
+    printf("AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillHistograms() - In EMCAL aod entries %d\n", GetEMCALClusters()->GetEntriesFast());
   }
   
   TLorentzVector pLeading(0,0,0,0) ;
@@ -1449,7 +1449,7 @@ void AliAnaParticleJetLeadingConeCorrelation::MakeAODJet(AliAODPWG4ParticleCorre
   if(fPbPb && !fSeveralConeAndPtCuts && ptTrig > fPtTriggerSelectionCut)  ptcut = fJetPtThresPbPb ;
   
   //Add charged particles to jet if they are in cone around the leading particle
-  if(!GetAODCTS()) {
+  if(!GetCTSTracks()) {
     printf("AliAnaParticleJetLeadingConeCorrelation::MakeAODJet() - Cannot construct jets without tracks, STOP analysis");
     return;
   }
@@ -1460,8 +1460,8 @@ void AliAnaParticleJetLeadingConeCorrelation::MakeAODJet(AliAODPWG4ParticleCorre
   TObjArray * reftracks  = new TObjArray;
   TObjArray * reftracksbkg  = new TObjArray;
   
-  for(Int_t ipr = 0;ipr < (GetAODCTS())->GetEntriesFast() ; ipr ++ ){
-    AliAODTrack* track = (AliAODTrack *)((GetAODCTS())->At(ipr)) ;
+  for(Int_t ipr = 0;ipr < (GetCTSTracks())->GetEntriesFast() ; ipr ++ ){
+    AliAODTrack* track = (AliAODTrack *)((GetCTSTracks())->At(ipr)) ;
     p3.SetXYZ(track->Px(),track->Py(),track->Pz());
     
     //Particles in jet 
@@ -1503,7 +1503,7 @@ void AliAnaParticleJetLeadingConeCorrelation::MakeAODJet(AliAODPWG4ParticleCorre
   //Initialize reference arrays that will contain jet and background tracks
   TObjArray * refclusters  = new TObjArray;
   TObjArray * refclustersbkg  = new TObjArray;
-  if(!fJetsOnlyInCTS && GetAODEMCAL()){
+  if(!fJetsOnlyInCTS && GetEMCALClusters()){
     
        //Get vertex for photon momentum calculation
        Double_t vertex[]  = {0,0,0} ; //vertex 
@@ -1514,16 +1514,16 @@ void AliAnaParticleJetLeadingConeCorrelation::MakeAODJet(AliAODPWG4ParticleCorre
                //if(GetReader()->GetSecondInputAODTree()) GetReader()->GetSecondInputAODVertex(vertex2);
        }
          
-    for(Int_t iclus = 0;iclus < (GetAODEMCAL())->GetEntriesFast() ; iclus ++ ){
-      AliVCluster * calo = (AliVCluster *) (GetAODEMCAL()->At(iclus)) ;
+    for(Int_t iclus = 0;iclus < (GetEMCALClusters())->GetEntriesFast() ; iclus ++ ){
+      AliVCluster * calo = (AliVCluster *) (GetEMCALClusters()->At(iclus)) ;
       
       //Cluster selection, not charged
       if(IsTrackMatched(calo)) continue ;
       
          //Input from second AOD?
          Int_t input = 0;
-//       if     (particle->GetDetector() == "EMCAL" && GetReader()->GetAODEMCALNormalInputEntries() <= iclus) input = 1 ;
-//       else if(particle->GetDetector() == "PHOS"  && GetReader()->GetAODPHOSNormalInputEntries()  <= iclus) input = 1;
+//       if     (particle->GetDetector() == "EMCAL" && GetReader()->GetEMCALClustersNormalInputEntries() <= iclus) input = 1 ;
+//       else if(particle->GetDetector() == "PHOS"  && GetReader()->GetPHOSClustersNormalInputEntries()  <= iclus) input = 1;
 //             
          //Get Momentum vector, 
          if     (input == 0) calo->GetMomentum(lv,vertex) ;//Assume that come from vertex in straight line
@@ -1639,8 +1639,8 @@ void AliAnaParticleJetLeadingConeCorrelation::MakeJetFromAOD(AliAODPWG4ParticleC
                  
                  //Input from second AOD?
                  Int_t input = 0;
-       //        if     (particle->GetDetector() == "EMCAL" && GetReader()->GetAODEMCALNormalInputEntries() <= iclus) input = 1 ;
-//               else if(particle->GetDetector() == "PHOS"  && GetReader()->GetAODPHOSNormalInputEntries()  <= iclus) input = 1;
+       //        if     (particle->GetDetector() == "EMCAL" && GetReader()->GetEMCALClustersNormalInputEntries() <= iclus) input = 1 ;
+//               else if(particle->GetDetector() == "PHOS"  && GetReader()->GetPHOSClustersNormalInputEntries()  <= iclus) input = 1;
                  
                  //Get Momentum vector, 
                  if     (input == 0) calo->GetMomentum(lv,vertex) ;//Assume that come from vertex in straight line
@@ -1657,8 +1657,8 @@ void AliAnaParticleJetLeadingConeCorrelation::MakeJetFromAOD(AliAODPWG4ParticleC
 
                  //Input from second AOD?
                  Int_t input = 0;
-//               if     (particle->GetDetector() == "EMCAL" && GetReader()->GetAODEMCALNormalInputEntries() <= iclus) input = 1 ;
-//               else if(particle->GetDetector() == "PHOS"  && GetReader()->GetAODPHOSNormalInputEntries()  <= iclus) input = 1;
+//               if     (particle->GetDetector() == "EMCAL" && GetReader()->GetEMCALClustersNormalInputEntries() <= iclus) input = 1 ;
+//               else if(particle->GetDetector() == "PHOS"  && GetReader()->GetPHOSClustersNormalInputEntries()  <= iclus) input = 1;
                  
                  //Get Momentum vector, 
                  if     (input == 0) calo->GetMomentum(lv,vertex) ;//Assume that come from vertex in straight line
index 9f61628..4248ccb 100755 (executable)
@@ -682,9 +682,9 @@ void  AliAnaPhoton::MakeAnalysisFillAOD()
   //Select the Calorimeter of the photon
   TObjArray * pl = 0x0; 
   if(fCalorimeter == "PHOS")
-    pl = GetAODPHOS();
+    pl = GetPHOSClusters();
   else if (fCalorimeter == "EMCAL")
-    pl = GetAODEMCAL();
+    pl = GetEMCALClusters();
   
   if(!pl) {
     Info("MakeAnalysisFillAOD","TObjArray with %s clusters is NULL!\n",fCalorimeter.Data());
@@ -722,9 +722,9 @@ void  AliAnaPhoton::MakeAnalysisFillAOD()
          
     //Input from second AOD?
     //Int_t input = 0;
-    //    if (fCalorimeter == "EMCAL" && GetReader()->GetAODEMCALNormalInputEntries() <= icalo) 
+    //    if (fCalorimeter == "EMCAL" && GetReader()->GetEMCALClustersNormalInputEntries() <= icalo) 
     //      input = 1 ;
-    //    else if(fCalorimeter == "PHOS"  && GetReader()->GetAODPHOSNormalInputEntries()  <= icalo) 
+    //    else if(fCalorimeter == "PHOS"  && GetReader()->GetPHOSClustersNormalInputEntries()  <= icalo) 
     //      input = 1;
          
     //Get Momentum vector, 
index 90ba694..ed8c292 100755 (executable)
@@ -1543,16 +1543,16 @@ void AliAnaPi0::MakeAnalysisFillHistograms()
   // Count the number of clusters and cells, in case multiplicity bins dependent on such numbers
   // are requested
   if(fCalorimeter=="EMCAL"){ 
-    nClus = GetAODEMCAL()  ->GetEntriesFast();
+    nClus = GetEMCALClusters()  ->GetEntriesFast();
     nCell = GetEMCALCells()->GetNumberOfCells();
     for(Int_t icl=0; icl < nClus; icl++) {
-      Float_t e1 = ((AliVCluster*)GetAODEMCAL()->At(icl))->E();
+      Float_t e1 = ((AliVCluster*)GetEMCALClusters()->At(icl))->E();
       eClusTot +=  e1;
 //      if(e1 > emax) emax = e1;
-//      ((AliVCluster*)GetAODEMCAL()->At(icl))->GetPosition(pos1);
+//      ((AliVCluster*)GetEMCALClusters()->At(icl))->GetPosition(pos1);
 //      for(Int_t icl2=icl+1; icl2 < nClus; icl2++) {
-//        Float_t e2 = ((AliVCluster*)GetAODEMCAL()->At(icl2))->E();
-//        ((AliVCluster*)GetAODEMCAL()->At(icl2))->GetPosition(pos2);
+//        Float_t e2 = ((AliVCluster*)GetEMCALClusters()->At(icl2))->E();
+//        ((AliVCluster*)GetEMCALClusters()->At(icl2))->GetPosition(pos2);
 //        rtmp  =  TMath::Sqrt((pos1[0]-pos2[0])*(pos1[0]-pos2[0]) + (pos1[2]-pos2[2])*(pos1[2]-pos2[2]));
 //        rtmpw =  TMath::Sqrt((pos1[0]*e1-pos2[0]*e2)*(pos1[0]*e1-pos2[0]*e2) + (pos1[2]*e1-pos2[2]*e2)*(pos1[2]*e1-pos2[2]*e2))/(e1+e2);
 //        rxz  += rtmp;  
@@ -1560,7 +1560,7 @@ void AliAnaPi0::MakeAnalysisFillHistograms()
 //        ncomb++;
 //        fhClusterPairDist      ->Fill(rtmp);
 //        fhClusterPairDistWeight->Fill(rtmpw);
-//        //printf("Distance: %f; weighted  %f\n ",rtmp,rtmp/(e1+((AliVCluster*)GetAODEMCAL()->At(icl2))->E()));
+//        //printf("Distance: %f; weighted  %f\n ",rtmp,rtmp/(e1+((AliVCluster*)GetEMCALClusters()->At(icl2))->E()));
 //
 //      }// second cluster loop
     }// first cluster
@@ -1568,15 +1568,15 @@ void AliAnaPi0::MakeAnalysisFillHistograms()
     for(Int_t jce=0; jce < nCell; jce++) eCellTot +=  GetEMCALCells()->GetAmplitude(jce);
   }
   else {                     
-    nClus = GetAODPHOS()  ->GetEntriesFast();
-    nCell = GetPHOSCells()->GetNumberOfCells();
+    nClus = GetPHOSClusters()->GetEntriesFast();
+    nCell = GetPHOSCells()   ->GetNumberOfCells();
     for(Int_t icl=0; icl < nClus; icl++) {
-      Float_t e1 = ((AliVCluster*)GetAODPHOS()->At(icl))->E();
+      Float_t e1 = ((AliVCluster*)GetPHOSClusters()->At(icl))->E();
       eClusTot +=  e1;
-//      ((AliVCluster*)GetAODPHOS()->At(icl))->GetPosition(pos1);
+//      ((AliVCluster*)GetPHOSClusters()->At(icl))->GetPosition(pos1);
 //      for(Int_t icl2=icl+1; icl2 < nClus; icl2++) {
-//        Float_t e2 = ((AliVCluster*)GetAODPHOS()->At(icl2))->E();
-//        ((AliVCluster*)GetAODPHOS()->At(icl2))->GetPosition(pos2);
+//        Float_t e2 = ((AliVCluster*)GetPHOSClusters()->At(icl2))->E();
+//        ((AliVCluster*)GetPHOSClusters()->At(icl2))->GetPosition(pos2);
 //        rtmp  = TMath::Sqrt((pos1[0]-pos2[0])*(pos1[0]-pos2[0]) + (pos1[2]-pos2[2])*(pos1[2]-pos2[2]));
 //        rtmpw =  TMath::Sqrt((pos1[0]*e1-pos2[0]*e2)*(pos1[0]*e1-pos2[0]*e2) + (pos1[2]*e1-pos2[2]*e2)*(pos1[2]*e1-pos2[2]*e2))/(e1+e2);
 //        rxz  += rtmp;  
index 11dd298..f6ce520 100755 (executable)
@@ -509,9 +509,9 @@ void  AliAnaPi0EbE::MakeShowerShapeIdentification()
   TObjArray * pl = 0x0; 
   //Select the Calorimeter of the photon
   if(fCalorimeter == "PHOS")
-    pl = GetAODPHOS();
+    pl = GetPHOSClusters();
   else if (fCalorimeter == "EMCAL")
-    pl = GetAODEMCAL();
+    pl = GetEMCALClusters();
   
   if(!pl) {
     Info("MakeShowerShapeIdentification","TObjArray with %s clusters is NULL!\n",fCalorimeter.Data());
@@ -540,8 +540,8 @@ void  AliAnaPi0EbE::MakeShowerShapeIdentification()
          
     //Input from second AOD?
     //Int_t input = 0;
-    // if     (fCalorimeter == "EMCAL" && GetReader()->GetAODEMCALNormalInputEntries() <= icalo) input = 1 ;
-    // else if(fCalorimeter == "PHOS"  && GetReader()->GetAODPHOSNormalInputEntries()  <= icalo) input = 1;
+    // if     (fCalorimeter == "EMCAL" && GetReader()->GetEMCALClustersNormalInputEntries() <= icalo) input = 1 ;
+    // else if(fCalorimeter == "PHOS"  && GetReader()->GetPHOSClustersNormalInputEntries()  <= icalo) input = 1;
          
     //Get Momentum vector, 
     //if     (input == 0) 
index 08f5e18..486ed4f 100644 (file)
@@ -652,9 +652,9 @@ void  AliAnaShowerParameter::MakeAnalysisFillAOD()
   //Select the Calorimeter of the photon
   TObjArray * pl = 0x0; 
   if(fCalorimeter == "PHOS")
-    pl = GetAODPHOS();
+    pl = GetPHOSClusters();
   else if (fCalorimeter == "EMCAL")
-    pl = GetAODEMCAL();
+    pl = GetEMCALClusters();
   
   if(!pl){
     printf("AliAnaShowerParameter::MakeAnalysisFillAOD() - Careful cluster array NULL!!\n");
@@ -868,9 +868,9 @@ void  AliAnaShowerParameter::MakeAnalysisFillHistograms()
     
     //Get the list of clusters from the AOD and loop over them to find the onces corresponding to the reconstructed 'photons'.
     if(fCalorimeter == "PHOS")
-      pl = GetAODPHOS();
+      pl = GetPHOSClusters();
     else if (fCalorimeter == "EMCAL")
-      pl = GetAODEMCAL();
+      pl = GetEMCALClusters();
     if(pl){
       //Some values are stored in AliAODCaloCluster objects only; we need to fetch them.
       for(Int_t icalo = 0; icalo < pl->GetEntriesFast(); icalo++){