1) Do not fill aod file if not requested
authorgconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 17 Aug 2010 14:49:12 +0000 (14:49 +0000)
committergconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 17 Aug 2010 14:49:12 +0000 (14:49 +0000)
2) Added method to find out if cluster has a match working for AODs and ESDs
3) Added a method to select EMCAL/PHOS clusters in case of AOD produced with versions before 4.20
4) Clean AliAnaPartCorrBase and AliCaloTrackReader from filling Standard AOD methods
5) Remove from AliAnaExample the Cell access information part.
6)AliAnaPartCorrMaker: Remove obsolete methods for mixing

17 files changed:
PWG4/PartCorrBase/AliAnaPartCorrBaseClass.cxx
PWG4/PartCorrBase/AliAnaPartCorrBaseClass.h
PWG4/PartCorrBase/AliAnaPartCorrMaker.cxx
PWG4/PartCorrBase/AliAnaPartCorrMaker.h
PWG4/PartCorrBase/AliAnalysisTaskParticleCorrelation.cxx
PWG4/PartCorrBase/AliAnalysisTaskParticleCorrelationM.cxx
PWG4/PartCorrBase/AliCaloTrackReader.cxx
PWG4/PartCorrBase/AliCaloTrackReader.h
PWG4/PartCorrDep/AliAnaExample.cxx
PWG4/PartCorrDep/AliAnaExample.h
PWG4/PartCorrDep/AliAnaParticleHadronCorrelation.cxx
PWG4/PartCorrDep/AliAnaParticleJetFinderCorrelation.cxx
PWG4/PartCorrDep/AliAnaParticleJetFinderCorrelation.h
PWG4/PartCorrDep/AliAnaParticleJetLeadingConeCorrelation.cxx
PWG4/PartCorrDep/AliAnaPhoton.cxx
PWG4/PartCorrDep/AliAnaPi0EbE.cxx
PWG4/macros/AddTaskPartCorr.C

index 030b581..081e642 100755 (executable)
@@ -33,7 +33,7 @@
 #include "AliIsolationCut.h"
 #include "AliMCAnalysisUtils.h"
 #include "AliNeutralMesonSelection.h"
-#include "AliAODCaloCells.h" 
+#include "AliVCaloCells.h" 
 #include "AliAODEvent.h"
 #include "AliAODHandler.h"
 #include "AliAnalysisManager.h"
@@ -51,10 +51,8 @@ ClassImp(AliAnaPartCorrBaseClass)
     fOutputAODBranch(0x0), fNewAOD(kFALSE),
     fOutputAODName(""), fOutputAODClassName(""),
     fAODObjArrayName(""), fAddToHistogramsName(""),
-    fAODCaloCells(0x0),//fAODCaloClusters(0x0),  
     fCaloPID(0x0), fFidCut(0x0), fIC(0x0),fMCUtils(0x0), fNMS(0x0),
     fCaloUtils(0x0),
-    //fAnaOutContainer(0x0),
     fHistoPtBins(0),   fHistoPtMax(0.),   fHistoPtMin(0.),
     fHistoPhiBins(0),  fHistoPhiMax(0.),  fHistoPhiMin(0.),
     fHistoEtaBins(0),  fHistoEtaMax(0.),  fHistoEtaMin(0.),
@@ -78,12 +76,9 @@ AliAnaPartCorrBaseClass::AliAnaPartCorrBaseClass(const AliAnaPartCorrBaseClass &
   fOutputAODName(abc.fOutputAODName), fOutputAODClassName(abc.fOutputAODClassName),
   fAODObjArrayName(abc.fAODObjArrayName),
   fAddToHistogramsName(abc.fAddToHistogramsName),
-  //fAODCaloClusters(new TClonesArray(*abc.fAODCaloClusters)),
-  fAODCaloCells(new AliAODCaloCells(*abc.fAODCaloCells)),
   fCaloPID(new AliCaloPID(*abc.fCaloPID)), fFidCut(new AliFiducialCut(*abc.fFidCut)), fIC(new AliIsolationCut(*abc.fIC)),
   fMCUtils(new AliMCAnalysisUtils(*abc.fMCUtils)), fNMS(new AliNeutralMesonSelection(*abc.fNMS)),
   fCaloUtils(new AliCalorimeterUtils(*abc.fCaloUtils)),
-  //fAnaOutContainer(abc.fAnaOutContainer),
   fHistoPtBins(abc.fHistoPtBins),     fHistoPtMax(abc.fHistoPtMax),     fHistoPtMin(abc.fHistoPtMin),
   fHistoPhiBins(abc.fHistoPhiBins),   fHistoPhiMax(abc.fHistoPhiMax),   fHistoPhiMin(abc.fHistoPhiMin),
   fHistoEtaBins(abc.fHistoEtaBins),   fHistoEtaMax(abc.fHistoEtaMax),   fHistoEtaMin(abc.fHistoEtaMin),
@@ -109,9 +104,6 @@ AliAnaPartCorrBaseClass & AliAnaPartCorrBaseClass::operator = (const AliAnaPartC
   fCheckCaloPID       = abc.fCheckCaloPID ;
   fCheckFidCut        = abc.fCheckFidCut ; 
        
-  //delete fAODCaloClusters; fAODCaloClusters   = new TClonesArray(*abc.fAODCaloClusters) ;
-  delete fAODCaloCells ; fAODCaloCells      = new AliAODCaloCells(*abc.fAODCaloCells) ;
-  
   fMinPt   = abc.fMinPt;
   fMaxPt   = abc.fMaxPt;
        
@@ -122,8 +114,6 @@ AliAnaPartCorrBaseClass & AliAnaPartCorrBaseClass::operator = (const AliAnaPartC
   delete fNMS;       fNMS       = new AliNeutralMesonSelection(*abc.fNMS);
   delete fCaloUtils; fCaloUtils = new AliCalorimeterUtils(*abc.fCaloUtils);
   delete fReader;    fReader    = new AliCaloTrackReader(*abc.fReader) ;
-
-  //fAnaOutContainer     = abc.fAnaOutContainer;
        
   delete fInputAODBranch;  fInputAODBranch      = new TClonesArray(*abc.fInputAODBranch) ;
   fInputAODName        = abc.fInputAODName;
@@ -158,22 +148,6 @@ AliAnaPartCorrBaseClass::~AliAnaPartCorrBaseClass()
 //    delete fInputAODBranch ;
 //  }
   
-//     if(fAODCaloClusters){
-//             fAODCaloClusters->Clear() ; 
-//             delete fAODCaloClusters ;
-//     }
-       
-  if(fAODCaloCells){
-    fAODCaloCells->Clear() ; 
-    delete fAODCaloCells ;
-  }
-       
-  //Already deleted in maker
-//  if(fAnaOutContainer){
-//     fAnaOutContainer->Clear() ; 
-//     delete fAnaOutContainer ;
-//  }
-               
   //if(fCaloUtils)    delete fCaloUtils ; //Already deleted in maker
   //if(fReader)       delete fReader ;    //Already deleted in maker
        
@@ -193,16 +167,6 @@ AliAnaPartCorrBaseClass::~AliAnaPartCorrBaseClass()
 //   printf("--- analysis deleted \n");
 }
 
-////____________________________________________________________________________
-//void AliAnaPartCorrBaseClass::AddAODCaloCluster(AliAODCaloCluster calo) {
-//  //Put AOD calo cluster in the CaloClusters array
-//
-//  Int_t i = fAODCaloClusters->GetEntriesFast();
-//  new((*fAODCaloClusters)[i])  AliAODCaloCluster(calo);
-//
-//}
-
-
 //____________________________________________________________________________
 void AliAnaPartCorrBaseClass::AddAODParticle(AliAODPWG4Particle pc) {
   //Put AOD calo cluster in the AODParticleCorrelation array
@@ -228,91 +192,78 @@ void AliAnaPartCorrBaseClass::AddAODParticle(AliAODPWG4Particle pc) {
 
 }      
 
-
-//___________________________________________________
-//void AliAnaPartCorrBaseClass::ConnectAODCaloClusters() {
-//  //Recover the list of AODCaloClusters
-//
-//  fAODCaloClusters = fReader->GetOutputEvent()->GetCaloClusters();
-//
-//}
-//
-//___________________________________________________
-void AliAnaPartCorrBaseClass::ConnectAODPHOSCells() {
-  //Recover the list of PHOS AODCaloCells 
-
-  fAODCaloCells = fReader->GetOutputEvent()->GetPHOSCells();
-
-}
-
-//___________________________________________________
-void AliAnaPartCorrBaseClass::ConnectAODEMCALCells() {
-  //Recover the list of EMCAL AODCaloCells 
-
-  fAODCaloCells = fReader->GetOutputEvent()->GetEMCALCells();
-
-}
-
-//___________________________________________________
+//___________________________________________________________________________
 TClonesArray * AliAnaPartCorrBaseClass::GetAODBranch(TString aodName) const {
        //Recover ouput and input AOD pointers for each event in the maker
        
        //Delta AODs
        if(fDebug > 3) printf("AliAnaPartCorrBaseClass::GetAODBranch() - Get Input Branch with name: <%s>; \n",aodName.Data());
        
-       //Get the AOD handler, if output AOD is created use it, if not get the branches from the input which should be deltaAODs
-       AliAODHandler* aodHandler = 0x0;
-       Bool_t outAOD = kFALSE;
-       if((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler()) outAOD = kTRUE;
-       if(outAOD) aodHandler = (AliAODHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler()); 
-       else       aodHandler = (AliAODHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetInputEventHandler());
-       
-       if (aodHandler->GetExtensions()) { 
-               AliAODExtension *ext = (AliAODExtension*)aodHandler->GetExtensions()->FindObject(GetReader()->GetDeltaAODFileName()); 
-               if(ext){
-                       AliAODEvent *aodEvent = ext->GetAOD(); 
-                       TClonesArray * aodbranch =  (TClonesArray*) aodEvent->FindListObject(aodName);
-                       if(aodbranch) return aodbranch;
-                       else {
-                               if(outAOD) return  (TClonesArray *) fReader->GetOutputEvent()->FindListObject(aodName);
-                               else       return  (TClonesArray *) fReader->GetInputEvent() ->FindListObject(aodName);
-                       }
-               }
-               else{//If no Delta AODs, kept in standard branch, to revise. 
-                       if(outAOD) return (TClonesArray *) fReader->GetOutputEvent()->FindListObject(aodName);
-                       else       return (TClonesArray *) fReader->GetInputEvent() ->FindListObject(aodName);
-               }
-       }
-       else{ //If no Delta AODs, kept in standard branch, to revise. 
-               if(outAOD) return (TClonesArray *) fReader->GetOutputEvent()->FindListObject(aodName);
-               else      return  (TClonesArray *) fReader->GetInputEvent() ->FindListObject(aodName);
-       }
+  //Get the AOD handler, if output AOD is created use it, if not get the branches from the input which should be deltaAODs
+  AliAODHandler* aodHandler = 0x0;
+  Bool_t outAOD = kFALSE;
+  if((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler()) outAOD = kTRUE;
+  if(outAOD) aodHandler = (AliAODHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler()); 
+  else              aodHandler = (AliAODHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetInputEventHandler());
+  
+  if(!GetReader()->WriteDeltaAODToFile())
+  {
+    return  (TClonesArray *) (fReader->GetAODBranchList())->FindObject(aodName);
+  }
+  else if (aodHandler->GetExtensions())
+  { 
+    AliAODExtension *ext = (AliAODExtension*)aodHandler->GetExtensions()->FindObject(GetReader()->GetDeltaAODFileName()); 
+    if(ext){
+      AliAODEvent *aodEvent = ext->GetAOD(); 
+      TClonesArray * aodbranch =  (TClonesArray*) aodEvent->FindListObject(aodName);
+      if(aodbranch) return aodbranch;
+      else {
+        if(outAOD) return  (TClonesArray *) fReader->GetOutputEvent()->FindListObject(aodName);
+        else       return  (TClonesArray *) fReader->GetInputEvent() ->FindListObject(aodName);
+      }
+    }
+    else{//If no Delta AODs, kept in standard branch, to revise. 
+      if(outAOD) return (TClonesArray *) fReader->GetOutputEvent()->FindListObject(aodName);
+      else       return (TClonesArray *) fReader->GetInputEvent() ->FindListObject(aodName);
+    }
+  }
+  else{ //If no Delta AODs, kept in standard branch, to revise. 
+    if(outAOD) return (TClonesArray *) fReader->GetOutputEvent()->FindListObject(aodName);
+    else       return  (TClonesArray *) fReader->GetInputEvent() ->FindListObject(aodName);
+  }
+  
 }
 
 
+
 //___________________________________________________
 void AliAnaPartCorrBaseClass::ConnectInputOutputAODBranches() {
   //Recover ouput and input AOD pointers for each event in the maker
        
   //Delta AODs
   if(fDebug > 3) printf("AliAnaPartCorrBaseClass::ConnectInputOutputAODBranches() - Connect Input with name: <%s>; Connect output with name <%s>\n",fInputAODName.Data(),fOutputAODName.Data());
-
+  
        //Get the AOD handler, if output AOD is created use it, if not get the branches from the input which should be deltaAODs
        AliAODHandler* aodHandler = 0x0;
        Bool_t outAOD = kFALSE;
        if((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler()) outAOD = kTRUE;
        if(outAOD) aodHandler = (AliAODHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler()); 
-       else       aodHandler = (AliAODHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetInputEventHandler());
+       else         aodHandler = (AliAODHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetInputEventHandler());
        
-  if (aodHandler->GetExtensions()) { 
-
+  if(!GetReader()->WriteDeltaAODToFile())
+  {
+    fOutputAODBranch =  (TClonesArray *) (fReader->GetAODBranchList())->FindObject(fOutputAODName);
+    fInputAODBranch  =  (TClonesArray *) (fReader->GetAODBranchList())->FindObject(fInputAODName);     
+  }
+  else if (aodHandler->GetExtensions()) { 
+    
          AliAODExtension *ext = (AliAODExtension*)aodHandler->GetExtensions()->FindObject(GetReader()->GetDeltaAODFileName()); 
          if(ext){
-         AliAODEvent *aodEvent = ext->GetAOD(); 
-         if(fNewAOD)fOutputAODBranch = (TClonesArray*) aodEvent->FindListObject(fOutputAODName);
-         fInputAODBranch = (TClonesArray*) aodEvent->FindListObject(fInputAODName);      
-         if(!fOutputAODBranch && fNewAOD) fOutputAODBranch =  (TClonesArray *) fReader->GetOutputEvent()->FindListObject(fOutputAODName);
-         if(!fInputAODBranch)  fInputAODBranch  =  (TClonesArray *) fReader->GetOutputEvent()->FindListObject(fInputAODName);
+      AliAODEvent *aodEvent = ext->GetAOD(); 
+      if(fNewAOD)fOutputAODBranch = (TClonesArray*) aodEvent->FindListObject(fOutputAODName);
+      fInputAODBranch = (TClonesArray*) aodEvent->FindListObject(fInputAODName);         
+      if(!fOutputAODBranch && fNewAOD) fOutputAODBranch =  (TClonesArray *) fReader->GetOutputEvent()->FindListObject(fOutputAODName);
+      if(!fInputAODBranch)  fInputAODBranch  =  (TClonesArray *) fReader->GetOutputEvent()->FindListObject(fInputAODName);
          }
          else{//If no Delta AODs, kept in standard branch, to revise. 
                  if(fNewAOD && fReader->GetOutputEvent()) {
@@ -339,13 +290,49 @@ void AliAnaPartCorrBaseClass::ConnectInputOutputAODBranches() {
   }
        
   if(GetDebug() > 1){
-       if(fNewAOD && !fOutputAODBranch) 
-               printf(" AliAnaPartCorrBaseClass::ConnectInputOutputAODBranches() - Output Branch <%s>, not found!\n",fOutputAODName.Data());
-       if(!fNewAOD && !fInputAODBranch) 
-               printf(" AliAnaPartCorrBaseClass::ConnectInputOutputAODBranches() - Input Branch  <%s>, not found!\n",fInputAODName.Data());
+    if(fNewAOD && !fOutputAODBranch) 
+      printf(" AliAnaPartCorrBaseClass::ConnectInputOutputAODBranches() - Output Branch <%s>, not found!\n",fOutputAODName.Data());
+    if(!fNewAOD && !fInputAODBranch) 
+      printf(" AliAnaPartCorrBaseClass::ConnectInputOutputAODBranches() - Input Branch  <%s>, not found!\n",fInputAODName.Data());
   }
 }
 
+//__________________________________________________________________________
+Bool_t AliAnaPartCorrBaseClass::IsTrackMatched(AliVCluster* cluster) const {
+  //Check if there is any track attached to this cluster
+  
+  Int_t nMatches = cluster->GetNTracksMatched();
+//  printf("N matches %d, first match %d\n",nMatches,cluster->GetTrackMatchedIndex());
+//  if     (cluster->GetTrackMatched(0))        printf("\t matched track id %d\n",((AliVTrack*)cluster->GetTrackMatched(0))->GetID()) ;
+//  else if(cluster->GetTrackMatchedIndex()>=0) printf("\t matched track id %d\n",((AliVTrack*) GetReader()->GetInputEvent()->GetTrack(cluster->GetTrackMatchedIndex()))->GetID()) ;
+
+  if(fReader->GetDataType()==AliCaloTrackReader::kESD)
+  {
+    
+    if (nMatches > 0) {
+      if (nMatches == 1 ) {
+        Int_t iESDtrack = cluster->GetTrackMatchedIndex();
+        //printf("Track Matched index %d\n",iESDtrack);
+        if(iESDtrack==-1) return kFALSE ;// Default value of array, there is no match
+        else              return kTRUE;
+      }//Just one, check
+      else return kTRUE ;//More than one, there is a match.
+    }// > 0
+    else return kFALSE; //It does not happen, but in case
+      
+  }//ESDs
+  else
+  {
+    //AODs
+    if(nMatches > 0) return kTRUE; //There is at least one match.
+    else             return kFALSE;
+    
+  }//AODs or MC (copy into AOD)
+  
+  return kFALSE;
+  
+}
+
 //__________________________________________________
 TObjArray *  AliAnaPartCorrBaseClass::GetAODCTS() const {
   //Get list of referenced tracks from reader
@@ -437,23 +424,6 @@ TString  AliAnaPartCorrBaseClass::GetBaseParametersList()  {
  }
 
 //__________________________________________________
-TNamed *  AliAnaPartCorrBaseClass::GetPHOSCells() const {
-  //Get list of PHOS calo cells (ESD or AOD) from reader
-  
-  return fReader->GetPHOSCells(); 
-  
-}
-
-
-//__________________________________________________
-TNamed *  AliAnaPartCorrBaseClass::GetEMCALCells() const {
-  //Get list of emcal calo cells (ESD or AOD) from reader
-  
-  return fReader->GetEMCALCells(); 
-
-}
-
-//__________________________________________________
 Int_t AliAnaPartCorrBaseClass::GetEventNumber() const {
        //Get current event number
        
@@ -497,9 +467,7 @@ void AliAnaPartCorrBaseClass::InitParameters()
 
   //fReader    = new AliCaloTrackReader(); //Initialized in maker
   //fCaloUtils = new AliCalorimeterUtils();//Initialized in maker
-  
-  //fAnaOutContainer = new TList();
-       
+       
   fNewAOD              = kFALSE ;
   fOutputAODName       = "PartCorr";
   fOutputAODClassName  = "AliAODPWG4Particle";
index 61d3d58..05e307f 100755 (executable)
@@ -18,9 +18,7 @@ class TObjArray ;
 class TObjString;
 
   //Analysis
-class AliESDCaloCluster;
-class AliAODCaloCluster;
-class AliAODCaloCells;
+class AliVCaloCells;
 #include "AliCaloTrackReader.h"   
 #include "AliCaloPID.h"
 #include "AliFiducialCut.h"
@@ -47,16 +45,12 @@ private:
   AliAnaPartCorrBaseClass & operator = (const AliAnaPartCorrBaseClass & g) ;//cpy assignment
   
 public:
-    // virtual void AddAODCaloCluster(AliAODCaloCluster calo) ;
+
   virtual void AddAODParticle(AliAODPWG4Particle part) ;
   
-    // virtual void ConnectAODCaloClusters();
-  virtual void ConnectAODPHOSCells();
-  virtual void ConnectAODEMCALCells();
   virtual void ConnectInputOutputAODBranches();
   
   virtual TList * GetCreateOutputObjects()      { return (new TList) ;}
-    //virtual TList * GetAnalysisOutputContainer()  { return fAnaOutContainer ;} 
        
   virtual void AddToHistogramsName(TString add) { fAddToHistogramsName = add; }  
   virtual TString GetAddedHistogramsStringToName() {return fAddToHistogramsName ;}
@@ -69,9 +63,7 @@ public:
   virtual void MakeAnalysisFillAOD()  {;}
   
   virtual void MakeAnalysisFillHistograms() {;}
-  
-  virtual void MakeMixingAnalysisFillHistograms() {;}
-       
+       
   virtual TObjString * GetAnalysisCuts() {return 0x0;}
        
   virtual Int_t GetDebug() const  { return fDebug ; }
@@ -82,7 +74,7 @@ public:
   virtual AliCaloTrackReader * GetReader() const {return fReader ; }
   virtual void SetReader(AliCaloTrackReader * const reader) { fReader = reader ; }
   
-    //Calorimeter helper class access methods
+  //Calorimeter helper class access methods
   AliEMCALGeoUtils *  GetEMCALGeometry() const { return fCaloUtils->GetEMCALGeometry(); }
   AliPHOSGeoUtils  *  GetPHOSGeometry()  const { return fCaloUtils->GetPHOSGeometry() ; }
   
@@ -92,12 +84,10 @@ public:
          return fCaloUtils->GetModuleNumber(part, fReader->GetInputEvent());}
   Int_t GetModuleNumber(AliVCluster * cluster) const {
          return fCaloUtils->GetModuleNumber(cluster);}
-    //  Int_t GetModuleNumber(AliAODCaloCluster * cluster) const {
-    //   return fCaloUtils->GetModuleNumber(cluster);}
-       
+       
   virtual void Terminate(TList * /*outputList*/) {;}
        
-    //analysis AOD branch
+  //analysis AOD branch
   virtual TClonesArray * GetCreateOutputAODBranch() ;
   virtual TString GetInputAODName() const {return fInputAODName ; }
   virtual void SetInputAODName(TString name)   { fInputAODName = name; }       
@@ -116,25 +106,22 @@ public:
   virtual TClonesArray* GetOutputAODBranch() const {if(fNewAOD) return fOutputAODBranch; else return fInputAODBranch ;}
   virtual TClonesArray* GetAODBranch(TString aodBranchName) const ;
        
-    // virtual TClonesArray* GetAODCaloClusters() const {return fAODCaloClusters ;}
   virtual TClonesArray* GetAODCaloClusters() const ;
   virtual TClonesArray* GetAODTracks() const ; 
-  virtual AliAODCaloCells* GetAODCaloCells() const {return fAODCaloCells ;}
-  
+  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 TNamed * GetEMCALCells() const ;
-  virtual TNamed * GetPHOSCells() const ;
-  
+    
   virtual AliStack * GetMCStack() const ;
   virtual AliHeader* GetMCHeader() const ;
   virtual AliGenEventHeader* GetMCGenEventHeader() const ;
   
-    //Analysis helpers classes pointers setters and getters
+  //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 ;}
   
@@ -173,8 +160,8 @@ public:
   virtual void SetPtCutRange(Double_t ptmin, Double_t ptmax)
   {  fMaxPt=ptmax;   fMinPt=ptmin;}
   
-    //Histogrammes setters and getters
-    //Pt, Energy 
+  //Histogrammes setters and getters
+  //Pt, Energy 
   virtual void SetHistoPtRangeAndNBins(Float_t min, Float_t max, Int_t n) {
     fHistoPtBins = n ;
     fHistoPtMax = max ;
@@ -196,7 +183,7 @@ public:
   virtual Float_t GetHistoPhiMin()   const { return fHistoPhiMin ; }
   virtual Float_t GetHistoPhiMax()   const { return fHistoPhiMax ; }
   
-    //Pseudorapidity-rapidity
+  //Pseudorapidity-rapidity
   virtual void SetHistoEtaRangeAndNBins(Float_t min, Float_t max, Int_t n) {
     fHistoEtaBins = n ;
     fHistoEtaMax  = max ;
@@ -207,7 +194,7 @@ public:
   virtual Float_t GetHistoEtaMin()   const { return fHistoEtaMin ; }
   virtual Float_t GetHistoEtaMax()   const { return fHistoEtaMax ; }
   
-    //Mass
+  //Mass
   virtual void SetHistoMassRangeAndNBins(Float_t min, Float_t max, Int_t n) {
     fHistoMassBins = n ;
     fHistoMassMax  = max ;
@@ -218,7 +205,7 @@ public:
   virtual Float_t GetHistoMassMin()   const { return fHistoMassMin ; }
   virtual Float_t GetHistoMassMax()   const { return fHistoMassMax ; }
        
-    //Asymetry
+  //Asymetry
   virtual void SetHistoAsymmetryRangeAndNBins(Float_t min, Float_t max, Int_t n) {
     fHistoAsymBins = n ;
     fHistoAsymMax  = max ;
@@ -233,7 +220,8 @@ public:
   Int_t GetNMixedEvent() const { return fNMixedEvent ; } 
   Double_t *  GetVertex(Int_t i) const { return fVertex[i] ; } 
 
-       
+       virtual Bool_t IsTrackMatched(AliVCluster * cluster) const ; 
+  
 private:    
   
   Bool_t  fDataMC ;             // Flag to access MC data when using ESD or AOD     
@@ -255,10 +243,7 @@ private:
   TString       fAODObjArrayName ;   // Name of ref array kept in a TList in AliAODParticleCorrelation with clusters or track references.
   TString       fAddToHistogramsName;// Add this string to histograms name
   
-    //TClonesArray* fAODCaloClusters ;  //! selected PHOS/EMCAL CaloClusters
-  AliAODCaloCells * fAODCaloCells ; //! selected PHOS/EMCAL CaloCells
-  
-    //Analysis helper classes access pointers
+  //Analysis helper classes access pointers
   AliCaloPID               * fCaloPID; //! PID calculation
   AliFiducialCut           * fFidCut;  //! Acceptance cuts
   AliIsolationCut          * fIC;      //! Isolation cut 
@@ -266,9 +251,8 @@ private:
   AliNeutralMesonSelection * fNMS;     //! Neutral Meson Selection
   AliCalorimeterUtils      * fCaloUtils ; //  Pointer to CalorimeterUtils
   
-    //TList * fAnaOutContainer;        // Temporal histogram output container, contents to be added to the main container passed to the main analysis frame
-  
-    //Histograms binning and range    
+
+  //Histograms binning and range    
   Int_t   fHistoPtBins   ;  // Number of bins in pt axis
   Float_t fHistoPtMax    ;  // Maximum value of pt histogram range
   Float_t fHistoPtMin    ;  // Minimum value of pt histogram range
@@ -291,7 +275,7 @@ private:
 
   
        
-  ClassDef(AliAnaPartCorrBaseClass,7)
+  ClassDef(AliAnaPartCorrBaseClass,8)
 } ;
 
 
index 75af2aa..cdfa952 100755 (executable)
@@ -43,9 +43,9 @@ ClassImp(AliAnaPartCorrMaker)
 AliAnaPartCorrMaker::AliAnaPartCorrMaker() : 
 TObject(),
 fOutputContainer(new TList ), fAnalysisContainer(new TList ),
-fMakeHisto(kFALSE), fMakeAOD(kFALSE), fMakeMixing(kFALSE), fAnaDebug(0), 
+fMakeHisto(kFALSE), fMakeAOD(kFALSE), fAnaDebug(0), 
 fReader(0), fCaloUtils(0), 
-fAODBranchList(new TList ),fCuts(new TList), fhNEvents(0x0)
+fCuts(new TList), fhNEvents(0x0)
 {
   //Default Ctor
   if(fAnaDebug > 1 ) printf("*** Analysis Maker  Constructor *** \n");
@@ -58,12 +58,11 @@ fAODBranchList(new TList ),fCuts(new TList), fhNEvents(0x0)
 AliAnaPartCorrMaker::AliAnaPartCorrMaker(const AliAnaPartCorrMaker & maker) :   
 TObject(),
 fOutputContainer(new TList()), fAnalysisContainer(new TList()), 
-fMakeHisto(maker.fMakeHisto), fMakeAOD(maker.fMakeAOD), fMakeMixing(maker.fMakeMixing), 
+fMakeHisto(maker.fMakeHisto), fMakeAOD(maker.fMakeAOD),
 fAnaDebug(maker.fAnaDebug),
 fReader(),//new AliCaloTrackReader(*maker.fReader)), 
 fCaloUtils(),//(new AliCalorimeterUtils(*maker.fCaloUtils)),
-fAODBranchList(new TList()), fCuts(new TList()), 
-fhNEvents(maker.fhNEvents)
+fCuts(new TList()), fhNEvents(maker.fhNEvents)
 {
   // cpy ctor
        
@@ -110,15 +109,6 @@ AliAnaPartCorrMaker::~AliAnaPartCorrMaker()
   if (fReader)    delete fReader ;
   if (fCaloUtils) delete fCaloUtils ;
 
-       
-  if(fAODBranchList){
-//             for(Int_t iaod = 0; iaod < fAODBranchList->GetEntries(); iaod++)
-//                     fAODBranchList->At(iaod)->Clear();
-       
-    fAODBranchList->Delete();
-    delete fAODBranchList ;
-  }
-  
   if(fCuts){
          fCuts->Delete();
          delete fCuts;
@@ -147,20 +137,23 @@ TList * AliAnaPartCorrMaker::GetListOfAnalysisCuts()
 }
 
 //________________________________________________________________________
-TList * AliAnaPartCorrMaker::GetAODBranchList()
+TList * AliAnaPartCorrMaker::FillAndGetAODBranchList()
 { 
        
        // Get any new output AOD branches from analysis and put them in a list
        // The list is filled in the maker, and new branch passed to the analysis frame
        // AliAnalysisTaskPartCorr
-       
+  
+       TList *aodBranchList = fReader->GetAODBranchList() ;
+  
        for(Int_t iana = 0; iana <  fAnalysisContainer->GetEntries(); iana++){
                
                AliAnaPartCorrBaseClass * ana =  ((AliAnaPartCorrBaseClass *) fAnalysisContainer->At(iana)) ;
-               if(ana->NewOutputAOD()) fAODBranchList->Add(ana->GetCreateOutputAODBranch());
+               if(ana->NewOutputAOD()) aodBranchList->Add(ana->GetCreateOutputAODBranch());
+    
        }
        
-       return fAODBranchList ;
+       return aodBranchList ;
        
 }
 
@@ -198,7 +191,6 @@ TList *AliAnaPartCorrMaker::GetOutputContainer()
     }// Analysis with histograms as output on
   }//Loop on analysis defined
   
-       
   fhNEvents        = new TH1I("hNEvents", "Number of analyzed events"   , 1 , 0 , 1  ) ;
   fOutputContainer->Add(fhNEvents);
        
@@ -216,10 +208,6 @@ void AliAnaPartCorrMaker::Init()
     printf("AliAnaPartCorrMaker::GetOutputInit() - Analysis job list not initialized!!!\n");
     //abort();
   }
-
-  //Initialize the geometry pointers
-  //GetCaloUtils()->InitPHOSGeometry();
-  //GetCaloUtils()->InitEMCALGeometry();
        
   //Initialize reader
   GetReader()->Init();
@@ -230,7 +218,7 @@ void AliAnaPartCorrMaker::Init()
     
     AliAnaPartCorrBaseClass * ana =  ((AliAnaPartCorrBaseClass *) fAnalysisContainer->At(iana)) ;
     ana->SetReader(fReader); //SetReader for each analysis
-       ana->SetCaloUtils(fCaloUtils); //Set CaloUtils for each analysis
+    ana->SetCaloUtils(fCaloUtils); //Set CaloUtils for each analysis
 
     ana->Init();
     
@@ -244,7 +232,6 @@ void AliAnaPartCorrMaker::InitParameters()
   
   fMakeHisto  = kTRUE;
   fMakeAOD    = kTRUE; 
-  fMakeMixing = kFALSE;
   fAnaDebug   = 0; // No debugging info displayed by default
        
 }
@@ -261,7 +248,6 @@ void AliAnaPartCorrMaker::Print(const Option_t * opt) const
   printf("Debug level                =     %d\n", fAnaDebug) ;
   printf("Produce Histo              =     %d\n", fMakeHisto) ;
   printf("Produce AOD                =     %d\n", fMakeAOD) ;
-  printf("Mixing Analysis            =     %d\n", fMakeMixing) ;
   printf("Number of analysis tasks   =     %d\n", fAnalysisContainer->GetEntries()) ;
   if(!strcmp("all",opt)){
          printf("Print analysis Tasks settings :\n") ;
@@ -293,14 +279,16 @@ void AliAnaPartCorrMaker::ProcessEvent(const Int_t iEntry, const char * currentF
                  //printf("fAODBranchList %p, entries %d\n",fAODBranchList,fAODBranchList->GetEntries());
          }
   }
+  
   //Each event needs an empty branch
-  Int_t nAODBranches = fAODBranchList->GetEntries();
+  TList * aodList = fReader->GetAODBranchList();
+  Int_t nAODBranches = aodList->GetEntries();
   for(Int_t iaod = 0; iaod < nAODBranches; iaod++){
-         //fAODBranchList->At(iaod)->Clear();
-         TClonesArray *tca = dynamic_cast<TClonesArray*> (fAODBranchList->At(iaod));
+         //aodList->At(iaod)->Clear();
+         TClonesArray *tca = dynamic_cast<TClonesArray*> (aodList->At(iaod));
          if(tca) tca->Delete();
   }
-
+  
   //Tell the reader to fill the data in the 3 detector lists
   Bool_t ok = fReader->FillInputEvent(iEntry, currentFileName);
   if(!ok){
@@ -318,14 +306,12 @@ void AliAnaPartCorrMaker::ProcessEvent(const Int_t iEntry, const char * currentF
   for(Int_t iana = 0; iana <  nana; iana++){
     AliAnaPartCorrBaseClass * ana =  ((AliAnaPartCorrBaseClass *) fAnalysisContainer->At(iana)) ; 
     
-       ana->ConnectInputOutputAODBranches(); //Sets branches for each analysis
+    ana->ConnectInputOutputAODBranches(); //Sets branches for each analysis
     //Make analysis, create aods in aod branch or AODCaloClusters
-       if(fMakeAOD   && !fMakeMixing)  ana->MakeAnalysisFillAOD()  ;
+    if(fMakeAOD  )  ana->MakeAnalysisFillAOD()  ;
     //Make further analysis with aod branch and fill histograms
-    if(fMakeHisto && !fMakeMixing)  ana->MakeAnalysisFillHistograms()  ;
-    //Make analysis with delta AODs of different events
-       if(fMakeMixing)                 ana->MakeMixingAnalysisFillHistograms()  ;
-
+    if(fMakeHisto)  ana->MakeAnalysisFillHistograms()  ;
+    
   }
        
   fhNEvents->Fill(0); //Event analyzed
index 50c0a5c..07f085b 100755 (executable)
@@ -37,10 +37,11 @@ class AliAnaPartCorrMaker : public TObject {
  public:
        
   //Setter and getters
-  TList * GetAODBranchList() ;
   TList * GetListOfAnalysisCuts();
   TList * GetOutputContainer() ;
 
+  TList * FillAndGetAODBranchList();
+  
   Int_t GetAnaDebug() const  { return fAnaDebug ; }
   void SetAnaDebug(Int_t d)  { fAnaDebug = d ; }
        
@@ -51,9 +52,7 @@ class AliAnaPartCorrMaker : public TObject {
   Bool_t AreAODsMade() const { return fMakeAOD ; }
   void SwitchOnAODsMaker()   { fMakeAOD = kTRUE ; }
   void SwitchOffAODsMaker()  { fMakeAOD = kFALSE ; }
-  
-  void SwitchOnMixingAnalysis() {fMakeMixing = kTRUE;} //Called by the task, no need to be set by user.
-       
+       
   void Terminate(TList * outputList);
 
   void AddAnalysis(TObject* ana, Int_t n) {
@@ -84,18 +83,16 @@ class AliAnaPartCorrMaker : public TObject {
   TList * fAnalysisContainer ; // List with analysis pointers
   Bool_t  fMakeHisto ;         // If true makes final analysis with histograms as output
   Bool_t  fMakeAOD ;           // If true makes analysis generating AODs
-  Bool_t  fMakeMixing;         // If true it makes mixing analysis
   Int_t   fAnaDebug;           // Debugging info.
        
   AliCaloTrackReader  *  fReader ;     //  Pointer to reader 
   AliCalorimeterUtils *  fCaloUtils ;  //  Pointer to CalorimeterUtils
 
-  TList * fAODBranchList ;     //! List with AOD branches created and needed in analysis  
   TList * fCuts ;                 //! List with analysis cuts
 
   TH1I  * fhNEvents;           //! Number of events counter histogram
        
-  ClassDef(AliAnaPartCorrMaker,5)
+  ClassDef(AliAnaPartCorrMaker,7)
 } ;
  
 
index 841b143..e62a038 100755 (executable)
@@ -88,18 +88,27 @@ void AliAnalysisTaskParticleCorrelation::UserCreateOutputObjects()
   
   //Get list of aod arrays, add each aod array to analysis frame 
   TClonesArray *array = 0;
-  TList * list = fAna->GetAODBranchList();
-  TString deltaAODName = (fAna->GetReader())->GetDeltaAODFileName();
-  for(Int_t iaod = 0; iaod < list->GetEntries(); iaod++){
-    array = (TClonesArray*) list->At(iaod);
-       if(deltaAODName!="") AddAODBranch("TClonesArray", &array, deltaAODName);//Put it in DeltaAOD file
-       else AddAODBranch("TClonesArray", &array);//Put it in standard AOD file
-  } 
-       
+  TList * list = fAna->FillAndGetAODBranchList(); //Loop the analysis and create the list of branches
+  if (DebugLevel() >= 1) printf("AliAnalysisTaskParticleCorrelation::UserCreateOutputObjects() - n AOD branches %d\n",list->GetEntries());
+  
+  //Put the delta AODs in output file, std or delta
+  if((fAna->GetReader())->WriteDeltaAODToFile()){
+    TString deltaAODName = (fAna->GetReader())->GetDeltaAODFileName();
+    for(Int_t iaod = 0; iaod < list->GetEntries(); iaod++){
+      array = (TClonesArray*) list->At(iaod);
+      if(deltaAODName!="") AddAODBranch("TClonesArray", &array, deltaAODName);//Put it in DeltaAOD file
+      else AddAODBranch("TClonesArray", &array);//Put it in standard AOD file
+    } 
+       }
+  
   //Histograms container
   OpenFile(1);
   fOutputContainer = fAna->GetOutputContainer();
+  
+  if (DebugLevel() >= 1) printf("AliAnalysisTaskParticleCorrelation::UserCreateOutputObjects() - n histograms %d\n",fOutputContainer->GetEntries());
+
   fOutputContainer->SetOwner(kTRUE);
+  
   if (DebugLevel() > 1) printf("AliAnalysisTaskParticleCorrelation::UserCreateOutputObjects() - End\n");
  
   PostData(1,fOutputContainer);
index a7a81b1..973c4b7 100755 (executable)
@@ -93,18 +93,27 @@ void AliAnalysisTaskParticleCorrelationM::UserCreateOutputObjects()
   
   //Get list of aod arrays, add each aod array to analysis frame 
   TClonesArray *array = 0;
-  TList * list = fAna->GetAODBranchList();
-  TString deltaAODName = (fAna->GetReader())->GetDeltaAODFileName();
-  for(Int_t iaod = 0; iaod < list->GetEntries(); iaod++){
-    array = (TClonesArray*) list->At(iaod);
-       if(deltaAODName!="") AddAODBranch("TClonesArray", &array, deltaAODName);//Put it in DeltaAOD file
-       else AddAODBranch("TClonesArray", &array);//Put it in standard AOD file
-  } 
+  TList * list = fAna->FillAndGetAODBranchList();
+  if (DebugLevel() >= 1) printf("AliAnalysisTaskParticleCorrelationM::UserCreateOutputObjects() - n AOD branches %d\n",list->GetEntries());
+
+  //Put the delta AODs in output file, std or delta
+  if((fAna->GetReader())->WriteDeltaAODToFile()){
+    TString deltaAODName = (fAna->GetReader())->GetDeltaAODFileName();
+    for(Int_t iaod = 0; iaod < list->GetEntries(); iaod++){
+      array = (TClonesArray*) list->At(iaod);
+      if(deltaAODName!="") AddAODBranch("TClonesArray", &array, deltaAODName);//Put it in DeltaAOD file
+      else AddAODBranch("TClonesArray", &array);//Put it in standard AOD file
+    } 
+       }
        
   //Histograms container
   OpenFile(1);
   fOutputContainer = fAna->GetOutputContainer();
+  
+  if (DebugLevel() >= 1) printf("AliAnalysisTaskParticleCorrelationM::UserCreateOutputObjects() - n histograms %d\n",fOutputContainer->GetEntries());
+  
   fOutputContainer->SetOwner(kTRUE);
+  
   if (DebugLevel() > 1) printf("AliAnalysisTaskParticleCorrelationM::UserCreateOutputObjects() - End\n");
  
   PostData(1,fOutputContainer);
index c6da7f7..0763812 100755 (executable)
@@ -20,7 +20,7 @@
 // Not all MC particles/tracks/clusters are kept, some kinematical/fiducial restrictions are done.
 // Mother class of : AliCaloTrackESDReader: Fills ESD data in 3 TObjArrays (PHOS, EMCAL, CTS)
 //                 : AliCaloTrackMCReader: Fills Kinematics data in 3 TObjArrays (PHOS, EMCAL, CTS)
-//                 : AliCaloTrackAODReader: Fills AOD data in 3 TObjArrays (PHOS, EMCAL, CTS) 
+//                 : AliCaloTrackReader: Fills AOD data in 3 TObjArrays (PHOS, EMCAL, CTS) 
 //              
 // This part is commented: Mixing analysis can be done, input AOD with events
 // is opened in the AliCaloTrackReader::Init()
@@ -50,7 +50,7 @@ ClassImp(AliCaloTrackReader)
   AliCaloTrackReader::AliCaloTrackReader() : 
     TObject(), fEventNumber(-1), fCurrentFileName(""),fDataType(0), fDebug(0), 
     fFiducialCut(0x0), fCheckFidCut(kFALSE), fComparePtHardAndJetPt(kFALSE), fPtHardAndJetPtFactor(7),
-    fCTSPtMin(0), fEMCALPtMin(0),fPHOSPtMin(0),
+    fCTSPtMin(0), fEMCALPtMin(0),fPHOSPtMin(0), fAODBranchList(new TList ),
     fAODCTS(new TObjArray()), fAODEMCAL(new TObjArray()), fAODPHOS(new TObjArray()),
     fEMCALCells(0x0), fPHOSCells(0x0),
     fInputEvent(0x0), fOutputEvent(0x0),fMC(0x0),
@@ -64,7 +64,8 @@ ClassImp(AliCaloTrackReader)
     fReadStack(kFALSE), fReadAODMCParticles(kFALSE), 
     fDeltaAODFileName("deltaAODPartCorr.root"),fFiredTriggerClassName(""),
     fAnaLED(kFALSE),fTaskName(""),fCaloUtils(0x0), 
-    fMixedEvent(NULL), fNMixedEvent(1), fVertex(NULL), fWriteOutputStdAOD(kFALSE)
+    fMixedEvent(NULL), fNMixedEvent(1), fVertex(NULL), 
+    fWriteOutputDeltaAOD(kFALSE),fOldAOD(kFALSE)
 {
   //Ctor
   
@@ -80,6 +81,7 @@ AliCaloTrackReader::AliCaloTrackReader(const AliCaloTrackReader & reader) :
   fComparePtHardAndJetPt(reader.fComparePtHardAndJetPt),
   fPtHardAndJetPtFactor(reader.fPtHardAndJetPtFactor),
   fCTSPtMin(reader.fCTSPtMin), fEMCALPtMin(reader.fEMCALPtMin),fPHOSPtMin(reader.fPHOSPtMin), 
+  fAODBranchList(new TList()),
   fAODCTS(new TObjArray(*reader.fAODCTS)),  
   fAODEMCAL(new TObjArray(*reader.fAODEMCAL)),
   fAODPHOS(new TObjArray(*reader.fAODPHOS)),
@@ -168,6 +170,11 @@ AliCaloTrackReader::~AliCaloTrackReader() {
   
   if(fFiducialCut) delete fFiducialCut ;
        
+  if(fAODBranchList){
+    fAODBranchList->Delete();
+    delete fAODBranchList ;
+  }  
+  
   if(fAODCTS){
     fAODCTS->Clear() ; 
     delete fAODCTS ;
@@ -412,7 +419,7 @@ void AliCaloTrackReader::Print(const Option_t * opt) const
   printf("Use EMCAL Cells =     %d\n", fFillEMCALCells) ;
   printf("Use PHOS  Cells =     %d\n", fFillPHOSCells) ;
   printf("Track status    =     %d\n", (Int_t) fTrackStatus) ;
-  printf("Write std AOD   =     %d\n", fWriteOutputStdAOD) ;
+  printf("Write delta AOD =     %d\n", fWriteOutputDeltaAOD) ;
 
   if(fComparePtHardAndJetPt)
          printf("Compare jet pt and pt hard to accept event, factor = %2.2f",fPtHardAndJetPtFactor);
@@ -468,13 +475,6 @@ Bool_t AliCaloTrackReader::FillInputEvent(const Int_t iEntry, const char * curre
          if(eventType!=8)return kFALSE;
   }
                
-  if(fOutputEvent && (fDataType != kAOD) && ((fOutputEvent->GetCaloClusters())->GetEntriesFast()!=0 ||(fOutputEvent->GetTracks())->GetEntriesFast()!=0)){
-    if (fFillCTS || fFillEMCAL || fFillPHOS) {
-      printf("AliCaloTrackReader::AODCaloClusters or AODTracks already filled by the filter, do not use the ESD reader, use the AOD reader, STOP\n");
-                 abort();
-    }
-  }
-
   //In case of analysis of events with jets, skip those with jet pt > 5 pt hard        
   if(fComparePtHardAndJetPt && GetStack()) {
     if(!ComparePtHardAndJetPt()) return kFALSE ;
@@ -568,12 +568,13 @@ Double_t * AliCaloTrackReader::GetVertex() {
   return fVertex[0] ; 
 }
 
-  //____________________________________________________________________________
+//____________________________________________________________________________
 void AliCaloTrackReader::FillInputCTS() {
-    //Return array with Central Tracking System (CTS) tracks
-  if(fDebug > 2 ) printf("AliCaloTrackAODReader::FillInputCTS()\n");
+  //Return array with Central Tracking System (CTS) tracks
+  
+  if(fDebug > 2 ) printf("AliCaloTrackReader::FillInputCTS()\n");
+  
   Int_t nTracks   = fInputEvent->GetNumberOfTracks() ;
-  Int_t naod = 0;
   Double_t p[3];
   for (Int_t itrack =  0; itrack <  nTracks; itrack++) {////////////// track loop
     AliVTrack * track = (AliVTrack*)fInputEvent->GetTrack(itrack) ; // retrieve track from esd
@@ -591,34 +592,25 @@ void AliCaloTrackReader::FillInputCTS() {
         continue;
       
       if(fDebug > 2 && momentum.Pt() > 0.1) 
-        printf("AliCaloTrackAODReader::FillInputCTS() - Selected tracks E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f\n",
+        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());
       
       if (fMixedEvent) {
         track->SetID(itrack);
       }
-      if(fWriteOutputStdAOD){
-        AliAODTrack * aodTrack = dynamic_cast<AliAODTrack*> (track) ;
-        if (aodTrack) {
-          AliAODTrack* newtrack = new((*(fOutputEvent->GetTracks()))[naod++]) AliAODTrack(*aodTrack);
-          fAODCTS->Add(newtrack); //Use AOD stored in output for references.
-        } else {
-          AliError("Can only write AOD tracks to output AOD !") ;
-        }
-      }
-      else {
-        fAODCTS->Add(track);        
-      } 
+      
+      fAODCTS->Add(track);        
+       
     }//Pt and Fiducial cut passed. 
   }// track loop
        
   //fAODCTSNormalInputEntries = fAODCTS->GetEntriesFast();
-  if(fDebug > 1) printf("AliCaloTrackAODReader::FillInputCTS()   - aod entries %d\n", fAODCTS->GetEntriesFast());//fAODCTSNormalInputEntries);
+  if(fDebug > 1) printf("AliCaloTrackReader::FillInputCTS()   - aod entries %d\n", fAODCTS->GetEntriesFast());//fAODCTSNormalInputEntries);
   
     //  //If second input event available, add the clusters.
     //  if(fSecondInputAODTree && fSecondInputAODEvent){
     //   nTracks   = fSecondInputAODEvent->GetNumberOfTracks() ;
-    //   if(fDebug > 1) printf("AliCaloTrackAODReader::FillInputCTS()   - Add second input tracks, entries %d\n", nTracks) ;
+    //   if(fDebug > 1) printf("AliCaloTrackReader::FillInputCTS()   - Add second input tracks, entries %d\n", nTracks) ;
     //   for (Int_t itrack =  0; itrack <  nTracks; itrack++) {////////////// track loop
     //           AliAODTrack * track = ((AliAODEvent*)fSecondInputAODEvent)->GetTrack(itrack) ; // retrieve track from esd
     //           
@@ -632,35 +624,31 @@ void AliCaloTrackReader::FillInputCTS() {
     //
     //                   if(fCheckFidCut && !fFiducialCut->IsInFiducialCut(momentum,"CTS")) continue;
     //
-    //                   if(fDebug > 2 && momentum.Pt() > 0.1) printf("AliCaloTrackAODReader::FillInputCTS() - Selected tracks E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f\n",
+    //                   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());
     //                   
-    //                   if(fWriteOutputStdAOD){
-    //                           AliAODTrack* newtrack = new((*(fOutputEvent->GetTracks()))[naod++]) AliAODTrack(*track);
-    //                           fAODCTS->Add(newtrack); //Use AOD stored in output for references.
-    //                   }
-    //                   else fAODCTS->Add(track);
+    //                   fAODCTS->Add(track);
     //                   
     //           }//Pt and Fiducial cut passed. 
     //   }// track loop
     //   
-    //   if(fDebug > 1) printf("AliCaloTrackAODReader::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", fAODCTSNormalInputEntries, fAODCTS->GetEntriesFast());
     //  }      //second input loop
     // 
 }
 
   //____________________________________________________________________________
 void AliCaloTrackReader::FillInputEMCAL() {
-    //Return array with EMCAL clusters in aod format
-  if(fDebug > 2 ) printf("AliCaloTrackAODReader::FillInputEMCAL()\n");
+  //Return array with EMCAL clusters in aod format
   
-  Int_t naod =  (fOutputEvent->GetCaloClusters())->GetEntriesFast();
-    //Loop to select clusters in fiducial cut and fill container with aodClusters
+  if(fDebug > 2 ) printf("AliCaloTrackReader::FillInputEMCAL()\n");
+  
+  //Loop to select clusters in fiducial cut and fill container with aodClusters
   Int_t nclusters = fInputEvent->GetNumberOfCaloClusters();
   for (Int_t iclus =  0; iclus <  nclusters; iclus++) {
     AliVCluster * clus = 0;
     if ( (clus = fInputEvent->GetCaloCluster(iclus)) ) {
-      if (clus->IsEMCAL()){
+      if (IsEMCALCluster(clus)){
         
         //Check if the cluster contains any bad channel and if close to calorimeter borders
         Int_t vindex = 0 ;  
@@ -682,7 +670,7 @@ void AliCaloTrackReader::FillInputEMCAL() {
             continue;
           
           if(fDebug > 2 && momentum.E() > 0.1) 
-            printf("AliCaloTrackAODReader::FillInputEMCAL() - Selected clusters E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f\n",
+            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());
           
           //Recalibrate the cluster energy 
@@ -694,29 +682,21 @@ void AliCaloTrackReader::FillInputEMCAL() {
           if (fMixedEvent) {
             clus->SetID(iclus) ; 
           }
-          if(fWriteOutputStdAOD){
-            AliAODCaloCluster * aodClus = dynamic_cast<AliAODCaloCluster*> (clus) ;
-            if (aodClus) {
-              AliAODCaloCluster * newclus = new((*(fOutputEvent->GetCaloClusters()))[naod++])AliAODCaloCluster(*aodClus);
-              fAODEMCAL->Add(newclus); 
-            } else {
-              AliError("Can only write AOD clusters to output AOD !") ;
-            }
-          } else {
-            fAODEMCAL->Add(clus);      
-          }
+            
+          fAODEMCAL->Add(clus);        
+          
         }//Pt and Fiducial cut passed.
       }//EMCAL cluster
     }// cluster exists
   }// cluster loop
   //fAODEMCALNormalInputEntries = fAODEMCAL->GetEntriesFast();
-  if(fDebug > 1) printf("AliCaloTrackAODReader::FillInputEMCAL() - aod entries %d\n",  fAODEMCAL->GetEntriesFast());//fAODEMCALNormalInputEntries);
+  if(fDebug > 1) printf("AliCaloTrackReader::FillInputEMCAL() - aod entries %d\n",  fAODEMCAL->GetEntriesFast());//fAODEMCALNormalInputEntries);
   
     //If second input event available, add the clusters.
     //  if(fSecondInputAODTree && fSecondInputAODEvent){
     //   GetSecondInputAODVertex(v);
     //   nclusters = ((AliAODEvent*)fSecondInputAODEvent)->GetNumberOfCaloClusters();
-    //   if(fDebug > 1) printf("AliCaloTrackAODReader::FillInputEMCAL() - Add second input clusters, entries %d\n", nclusters) ;
+    //   if(fDebug > 1) printf("AliCaloTrackReader::FillInputEMCAL() - Add second input clusters, entries %d\n", nclusters) ;
     //         for (Int_t iclus =  0; iclus < nclusters; iclus++) {
     //                 AliAODCaloCluster * clus = 0;
     //                 if ( (clus = ((AliAODEvent*)fSecondInputAODEvent)->GetCaloCluster(iclus)) ) {
@@ -728,38 +708,32 @@ void AliCaloTrackReader::FillInputEMCAL() {
     //
     //                                         if(fCheckFidCut && !fFiducialCut->IsInFiducialCut(momentum,"EMCAL")) continue;
     //
-    //                                         if(fDebug > 2 && momentum.E() > 0.1) printf("AliCaloTrackAODReader::FillInputEMCAL() - Selected clusters E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f\n",
+    //                                         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());
-    //                                         if(fWriteOutputStdAOD){
-    //                                                 AliAODCaloCluster * newclus = new((*(fOutputEvent->GetCaloClusters()))[naod++])AliAODCaloCluster(*clus);
-    //                                             fAODEMCAL->Add(newclus);    
-    //                                         }
-    //                                         else fAODEMCAL->Add(clus);      
+    //                                   fAODEMCAL->Add(clus); 
     //                                 }//Pt and Fiducial cut passed.
     //                         }//EMCAL cluster
     //                 }// cluster exists
     //         }// cluster loop
     //         
-    //   if(fDebug > 1) printf("AliCaloTrackAODReader::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", fAODEMCALNormalInputEntries, fAODEMCAL->GetEntriesFast());
     //
     // } //second input loop
 }
 
   //____________________________________________________________________________
 void AliCaloTrackReader::FillInputPHOS() {
-    //Return array with PHOS clusters in aod format
-  if(fDebug > 2 ) printf("AliCaloTrackAODReader::FillInputPHOS()\n");
-       
-    //Get vertex for momentum calculation  
+  //Return array with PHOS clusters in aod format
   
-  Int_t naod =  (fOutputEvent->GetCaloClusters())->GetEntriesFast();
-    //Loop to select clusters in fiducial cut and fill container with aodClusters
+  if(fDebug > 2 ) printf("AliCaloTrackReader::FillInputPHOS()\n");
+         
+  //Loop to select clusters in fiducial cut and fill container with aodClusters
   Int_t nclusters = fInputEvent->GetNumberOfCaloClusters();
   for (Int_t iclus = 0; iclus < nclusters; iclus++) {
     AliVCluster * clus = 0;
     if ( (clus = fInputEvent->GetCaloCluster(iclus)) ) {
-      if (clus->IsPHOS()){
-          //Check if the cluster contains any bad channel and if close to calorimeter borders
+      if (IsPHOSCluster(clus)){
+        //Check if the cluster contains any bad channel and if close to calorimeter borders
         Int_t vindex = 0 ;  
         if (fMixedEvent) 
           vindex = fMixedEvent->EventIndexForCaloCluster(iclus);
@@ -778,7 +752,7 @@ void AliCaloTrackReader::FillInputPHOS() {
             continue;
           
           if(fDebug > 2 && momentum.E() > 0.1) 
-            printf("AliCaloTrackAODReader::FillInputPHOS() - Selected clusters E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f\n",
+            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());
           
             //Recalibrate the cluster energy 
@@ -791,30 +765,21 @@ void AliCaloTrackReader::FillInputPHOS() {
             clus->SetID(iclus) ; 
           }              
           
-          if(fWriteOutputStdAOD){
-            AliAODCaloCluster * aodClus = dynamic_cast<AliAODCaloCluster*> (clus) ;
-            if (aodClus) {
-              AliAODCaloCluster * newclus = new((*(fOutputEvent->GetCaloClusters()))[naod++])AliAODCaloCluster(*aodClus);
-              fAODPHOS->Add(newclus);  
-            } else {
-              AliError("Can only write AOD clusters to output AOD !") ;
-            }
-          } else {
-            fAODPHOS->Add(clus);       
-          }
+          fAODPHOS->Add(clus); 
+          
         }//Pt and Fiducial cut passed.
       }//PHOS cluster
     }//cluster exists
   }//esd cluster loop
   
   //fAODPHOSNormalInputEntries = fAODPHOS->GetEntriesFast() ;
-  if(fDebug > 1) printf("AliCaloTrackAODReader::FillInputPHOS()  - aod entries %d\n",  fAODPHOS->GetEntriesFast());//fAODPHOSNormalInputEntries);
+  if(fDebug > 1) printf("AliCaloTrackReader::FillInputPHOS()  - aod entries %d\n",  fAODPHOS->GetEntriesFast());//fAODPHOSNormalInputEntries);
   
     //If second input event available, add the clusters.
     //  if(fSecondInputAODTree && fSecondInputAODEvent){  
     //   GetSecondInputAODVertex(v);
     //   nclusters = ((AliAODEvent*)fSecondInputAODEvent)->GetNumberOfCaloClusters();
-    //   if(fDebug > 1) printf("AliCaloTrackAODReader::FillInputPHOS()  - Add second input clusters, entries %d\n", nclusters);
+    //   if(fDebug > 1) printf("AliCaloTrackReader::FillInputPHOS()  - Add second input clusters, entries %d\n", nclusters);
     //         for (Int_t iclus =  0; iclus < nclusters; iclus++) {
     //                 AliAODCaloCluster * clus = 0;
     //                 if ( (clus = ((AliAODEvent*)fSecondInputAODEvent)->GetCaloCluster(iclus)) ) {
@@ -826,23 +791,19 @@ void AliCaloTrackReader::FillInputPHOS() {
     //
     //                                         if(fCheckFidCut && !fFiducialCut->IsInFiducialCut(momentum,"PHOS")) continue;
     //
-    //                                         if(fDebug > 2 && momentum.E() > 0.1) printf("AliCaloTrackAODReader::FillInputPHOS() - Selected clusters E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f\n",
+    //                                         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());
-    //                                         if(fWriteOutputStdAOD){
-    //                                                 AliAODCaloCluster * newclus = new((*(fOutputEvent->GetCaloClusters()))[naod++])AliAODCaloCluster(*clus);
-    //                                             fAODPHOS->Add(newclus);     
-    //                                         }
-    //                                         else fAODPHOS->Add(clus);       
+    //                                         fAODPHOS->Add(clus);    
     //                                 }//Pt and Fiducial cut passed.
     //                         }//PHOS cluster
     //                 }// cluster exists
     //         }// cluster loop
-    //         if(fDebug > 1) printf("AliCaloTrackAODReader::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", fAODPHOSNormalInputEntries, fAODPHOS->GetEntriesFast());
     //  }      //second input loop
   
 }
 
-  //____________________________________________________________________________
+//____________________________________________________________________________
 void AliCaloTrackReader::FillInputEMCALCells() {
     //Return array with EMCAL cells in aod format
   
@@ -850,7 +811,7 @@ void AliCaloTrackReader::FillInputEMCALCells() {
   
 }
 
-  //____________________________________________________________________________
+//____________________________________________________________________________
 void AliCaloTrackReader::FillInputPHOSCells() {
     //Return array with PHOS cells in aod format
   
@@ -858,3 +819,40 @@ void AliCaloTrackReader::FillInputPHOSCells() {
   
 }
 
+//____________________________________________________________________________
+Bool_t AliCaloTrackReader::IsEMCALCluster(AliVCluster* cluster) const {
+  // Check if it is a cluster from EMCAL. For old AODs cluster type has
+  // different number and need to patch here
+    
+  if(fDataType==kAOD && fOldAOD)
+  {
+    if (cluster->GetType() == 2) return kTRUE;
+    else                         return kFALSE;
+  }
+  else 
+  {
+    return cluster->IsEMCAL();
+  }
+
+}
+
+//____________________________________________________________________________
+Bool_t AliCaloTrackReader::IsPHOSCluster(AliVCluster * cluster) const {
+  //Check if it is a cluster from PHOS.For old AODs cluster type has
+  // different number and need to patch here
+  
+  if(fDataType==kAOD && fOldAOD)
+  {
+    Int_t type = cluster->GetType();
+    if (type == 0 || type == 1) return kTRUE;
+    else                        return kFALSE;
+  }
+  else 
+  {
+    return cluster->IsPHOS();
+  }
+  
+}
+
+
+
index 262054b..45c51b1 100755 (executable)
@@ -47,7 +47,7 @@ private:
 
 public:
   enum inputDataType {kESD, kAOD, kMC};
-  
+    
   //Select generated events, depending on comparison of pT hard and jets.
   virtual Bool_t ComparePtHardAndJetPt() ;
   virtual Bool_t IsPtHardAndJetPtComparisonSet() const {return  fComparePtHardAndJetPt ;}
@@ -76,25 +76,29 @@ public:
   virtual void SetCTSPtMin(Float_t  pt)   { fCTSPtMin = pt ; }
   
   //Input setters and getters
-
+  Bool_t IsEMCALCluster(AliVCluster *clus) const;
+  Bool_t IsPHOSCluster (AliVCluster *clus)  const;
+  void SwitchOnOldAODs()   {fOldAOD = kTRUE  ; }
+  void SwitchOffOldAODs()  {fOldAOD = kFALSE ; }
+  
   Bool_t IsCTSSwitchedOn()  const { return fFillCTS ; }
-  void SwitchOnCTS()    {fFillCTS = kTRUE ; }
+  void SwitchOnCTS()    {fFillCTS = kTRUE  ; }
   void SwitchOffCTS()   {fFillCTS = kFALSE ; }
 
   Bool_t IsEMCALSwitchedOn() const { return fFillEMCAL ; }
-  void SwitchOnEMCAL()  {fFillEMCAL = kTRUE ; }
+  void SwitchOnEMCAL()  {fFillEMCAL = kTRUE  ; }
   void SwitchOffEMCAL() {fFillEMCAL = kFALSE ; }
 
   Bool_t IsPHOSSwitchedOn()  const { return fFillPHOS ; }
-  void SwitchOnPHOS()   {fFillPHOS = kTRUE ; }
+  void SwitchOnPHOS()   {fFillPHOS = kTRUE  ; }
   void SwitchOffPHOS()  {fFillPHOS = kFALSE ; }
 
   Bool_t IsEMCALCellsSwitchedOn() const { return fFillEMCALCells ; }
-  void SwitchOnEMCALCells()  {fFillEMCALCells = kTRUE ; }
+  void SwitchOnEMCALCells()  {fFillEMCALCells = kTRUE  ; }
   void SwitchOffEMCALCells() {fFillEMCALCells = kFALSE ; }
 
   Bool_t IsPHOSCellsSwitchedOn()  const { return fFillPHOSCells ; }
-  void SwitchOnPHOSCells()   {fFillPHOSCells = kTRUE ; }
+  void SwitchOnPHOSCells()   {fFillPHOSCells = kTRUE  ; }
   void SwitchOffPHOSCells()  {fFillPHOSCells = kFALSE ; }
 
   virtual Bool_t FillInputEvent(const Int_t iEntry, const char *currentFileName)  ;
@@ -103,12 +107,14 @@ public:
   virtual void FillInputPHOS() ;
   virtual void FillInputEMCALCells() ;
   virtual void FillInputPHOSCells() ;
+  
+  virtual TList * GetAODBranchList() const { return fAODBranchList ; }
 
-  virtual TObjArray* GetAODCTS()   const {return fAODCTS ;}
+  virtual TObjArray* GetAODCTS()   const {return fAODCTS   ;}
   virtual TObjArray* GetAODEMCAL() const {return fAODEMCAL ;}
-  virtual TObjArray* GetAODPHOS()  const {return fAODPHOS ;}
+  virtual TObjArray* GetAODPHOS()  const {return fAODPHOS  ;}
   virtual AliVCaloCells* GetEMCALCells()  const { return fEMCALCells ;}
-  virtual AliVCaloCells* GetPHOSCells()   const { return fPHOSCells ;}
+  virtual AliVCaloCells* GetPHOSCells()   const { return fPHOSCells  ;}
 
   //Get MC  informatio
   //Kinematics and galice.root available 
@@ -191,10 +197,11 @@ public:
   void SetCaloUtils(AliCalorimeterUtils * caloutils) { fCaloUtils = caloutils ; }
   
   Double_t * GetVertex() ;  
+    
+  void SwitchOnWriteDeltaAOD()  {fWriteOutputDeltaAOD = kTRUE ;  }
+  void SwitchOffWriteDeltaAOD() {fWriteOutputDeltaAOD = kFALSE ; }
+  Bool_t WriteDeltaAODToFile() const {return fWriteOutputDeltaAOD ; } 
   
-  void SwitchOnWriteStdAOD()  {fWriteOutputStdAOD = kTRUE;}
-  void SwitchOffWriteStdAOD() {fWriteOutputStdAOD = kFALSE;}
-
  protected:
   Int_t                   fEventNumber; // Event number
   TString          fCurrentFileName; // Current file name under analysis
@@ -210,6 +217,7 @@ public:
   Float_t        fEMCALPtMin;    // pT Threshold on emcal clusters
   Float_t        fPHOSPtMin;     // pT Threshold on phos clusters
 
+  TList *        fAODBranchList ; //! List with AOD branches created and needed in analysis  
   TObjArray *    fAODCTS ;        //! temporal referenced array with tracks
   TObjArray *    fAODEMCAL ;      //! temporal referenced array with EMCAL CaloClusters
   TObjArray *    fAODPHOS ;       //! temporal referenced array with PHOS CaloClusters
@@ -252,10 +260,10 @@ public:
   Int_t          fNMixedEvent ;        //! number of events in mixed event buffer
   Double_t **    fVertex ;             //! vertex array 3 dim for each mixed event buffer
   
-  Bool_t              fWriteOutputStdAOD;   // Write selected standard tracks and caloclusters in output AOD
-
-       
-  ClassDef(AliCaloTrackReader,17)
+  Bool_t         fWriteOutputDeltaAOD; // Write the created delta AOD objects into file  
+       Bool_t         fOldAOD;              // Old AODs, before revision 4.20
+  
+  ClassDef(AliCaloTrackReader,19)
 } ;
 
 
index 0e490be..9229707 100755 (executable)
@@ -15,7 +15,7 @@
 /* $Id: $ */
 
 //_________________________________________________________________________
-// Example class on how to read AODCaloClusters, ESDCaloCells and AODTracks and how 
+// Example class on how to read CaloClusters, and AODTracks and how 
 // fill AODs with PWG4PartCorr analysis frame
 // Select the type of detector information that you want to analyze, CTS (tracking), PHOS or EMCAL
 // Select the PID custer type of the calorimeters
 #include "AliAnaExample.h"
 #include "AliCaloTrackReader.h"
 #include "AliAODPWG4Particle.h"
-#include "AliESDCaloCells.h"
 #include "AliStack.h"
 #include "AliCaloPID.h"
 #include "AliFiducialCut.h"
-#include "AliAODCaloCells.h"
-#include "AliAODCaloCluster.h"
+#include "AliVCluster.h"
 #include "AliAODTrack.h"
 
 ClassImp(AliAnaExample)
   
 //____________________________________________________________________________
   AliAnaExample::AliAnaExample() : 
-    AliAnaPartCorrBaseClass(),fPdg(0),  fDetector(""), fhPt(0),fhPhi(0),fhEta(0),  fh2Pt(0),fh2Phi(0),fh2Eta(0),
-    fhNCells(0), fhAmplitude(0)
+    AliAnaPartCorrBaseClass(),fPdg(0),  fDetector(""), fhPt(0),fhPhi(0),fhEta(0),  fh2Pt(0),fh2Phi(0),fh2Eta(0)
 {
   //Default Ctor
 
   //Initialize parameters
   InitParameters();
 }
-/*
-//____________________________________________________________________________
-AliAnaExample::AliAnaExample(const AliAnaExample & ex) :   
-  AliAnaPartCorrBaseClass(ex), fPdg(ex.fPdg), fDetector(ex.fDetector), fhPt(ex.fhPt),  fhPhi(ex.fhPhi),fhEta(ex.fhEta), 
-  fh2Pt(ex.fh2Pt),  fh2Phi(ex.fh2Phi),fh2Eta(ex.fh2Eta), fhNCells(ex.fhNCells), fhAmplitude(ex.fhAmplitude)
-{
-  // cpy ctor
-  
-}
-
-//_________________________________________________________________________
-AliAnaExample & AliAnaExample::operator = (const AliAnaExample & ex)
-{
-  // assignment operator
-
-  if(this == &ex)return *this;
-  ((AliAnaPartCorrBaseClass *)this)->operator=(ex);
-  fPdg = ex.fPdg;
-  fDetector = ex.fDetector;
-  fhPt = ex.fhPt;
-  fhPhi = ex.fhPhi;
-  fhEta = ex.fhEta;
-  fh2Pt = ex.fh2Pt;
-  fh2Phi = ex.fh2Phi;
-  fh2Eta = ex.fh2Eta;
-  fhNCells = ex.fhNCells;
-  fhAmplitude = ex.fhAmplitude;
-
-  return *this;
-
-}
-*/
-// //____________________________________________________________________________
-// AliAnaExample::~AliAnaExample() 
-// {
-//   // Remove all pointers except analysis output pointers.
-
-//   ;
-// }
-
 
 //________________________________________________________________________
 TList *  AliAnaExample::GetCreateOutputObjects()
@@ -132,18 +88,6 @@ TList *  AliAnaExample::GetCreateOutputObjects()
   fhEta->SetXTitle("#eta ");
   outputContainer->Add(fhEta);
   
-  if(GetReader()->GetDataType()!= AliCaloTrackReader::kMC) {
-    
-    //Calo cells
-    fhNCells  = new TH1F ("hNCells","# cells per event", 100,0,1000); 
-    fhNCells->SetXTitle("n cells");
-    outputContainer->Add(fhNCells);
-    
-    fhAmplitude  = new TH1F ("hAmplitude","#eta distribution", 100,0,1000); 
-    fhAmplitude->SetXTitle("Amplitude ");
-    outputContainer->Add(fhAmplitude);
-  } 
-  
   if(IsDataMC()){
     fh2Pt  = new TH2F ("h2Pt","p_T distribution, reconstructed vs generated", nptbins,ptmin,ptmax,nptbins,ptmin,ptmax); 
     fh2Pt->SetXTitle("p_{T,rec} (GeV/c)");
@@ -201,15 +145,15 @@ 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 == "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());
   }
   
   //Get List with tracks or clusters  
   TObjArray * partList = 0x0;
-  if(fDetector == "CTS") partList = GetAODCTS();
+  if(fDetector == "CTS")        partList = GetAODCTS();
   else if(fDetector == "EMCAL") partList = GetAODEMCAL();
-  else if(fDetector == "PHOS") partList = GetAODPHOS();
+  else if(fDetector == "PHOS")  partList = GetAODPHOS();
   
   if(!partList || partList->GetEntriesFast() == 0) return ;
   
@@ -223,74 +167,38 @@ void  AliAnaExample::MakeAnalysisFillAOD()
     TLorentzVector mom ;
     for(Int_t i = 0; i < partList->GetEntriesFast(); i++){
       
-      AliAODCaloCluster * calo =  (AliAODCaloCluster*) (partList->At(i));
+      AliVCluster * calo =  (AliVCluster*) (partList->At(i));
       
       //Fill AODParticle after some selection
       calo->GetMomentum(mom,v);
       Int_t pdg = fPdg;
       
       if(IsCaloPIDOn()){
-       const Double_t *pid = calo->GetPID();
-       pdg = GetCaloPID()->GetPdg(fDetector,pid,mom.E());
-       //pdg = GetCaloPID()->GetPdg(fDetector,mom,
-       //                calo->GetM02(), calo->GetM02(),
-       //                calo->GetDispersion(), 0, 0); 
+        const Double_t *pid = calo->GetPID();
+        pdg = GetCaloPID()->GetPdg(fDetector,pid,mom.E());
+        //pdg = GetCaloPID()->GetPdg(fDetector,mom,
+        //               calo->GetM02(), calo->GetM02(),
+        //               calo->GetDispersion(), 0, 0); 
       }
       
       //Acceptance selection   
       Bool_t in = kTRUE;
       if(IsFiducialCutOn())
-       in =  GetFiducialCut()->IsInFiducialCut(mom,fDetector) ;
+        in =  GetFiducialCut()->IsInFiducialCut(mom,fDetector) ;
       
       if(GetDebug() > 1) printf("AliAnaExample::MakeAnalysisFillAOD() - Cluster pt %2.2f, phi %2.2f, pdg %d, in fiducial cut %d \n",mom.Pt(), mom.Phi(), pdg, in);
       
       //Select cluster if momentum, pdg and acceptance are good
       if(mom.Pt() > GetMinPt() && pdg ==fPdg && in) {
-       AliAODPWG4Particle ph = AliAODPWG4Particle(mom);
-       //AddAODParticleCorrelation(AliAODPWG4ParticleCorrelation(mom));
-       ph.SetLabel(calo->GetLabel());
-       ph.SetPdg(pdg);
-       ph.SetDetector(fDetector);
-       AddAODParticle(ph);
+        AliAODPWG4Particle ph = AliAODPWG4Particle(mom);
+        //AddAODParticleCorrelation(AliAODPWG4ParticleCorrelation(mom));
+        ph.SetLabel(calo->GetLabel());
+        ph.SetPdg(pdg);
+        ph.SetDetector(fDetector);
+        AddAODParticle(ph);
       }//selection
     }//loop
-    
-    if(GetReader()->GetDataType()!= AliCaloTrackReader::kMC) {
-      //WORK WITH ESDCALOCELLS
-      //Don't connect in the same analysis PHOS and EMCAL cells.
-      
-      AliESDCaloCells * esdCell = new AliESDCaloCells ;
-      if(fDetector == "PHOS") {
-       ConnectAODPHOSCells(); //Do Only when filling AODCaloCells
-       esdCell = (AliESDCaloCells *) GetPHOSCells();
-      }
-      else  {
-       ConnectAODEMCALCells(); //Do Only when filling AODCaloCells
-       esdCell = (AliESDCaloCells *) GetEMCALCells();
-      }
-      
-      if(!esdCell) {
-       printf("AliAnaExample::MakeAnalysisFillAOD() - STOP: No CELLS available for analysis");
-       abort();
-      }
-      //Some prints
-      if(GetDebug() > 0 && esdCell )
-       printf("AliAnaExample::MakeAnalysisFillAOD() - In ESD %s cell entries %d\n", fDetector.Data(), esdCell->GetNumberOfCells());    
-      
-      //Fill AODCells in file
-      Int_t ncells = esdCell->GetNumberOfCells() ;
-      GetAODCaloCells()->CreateContainer(ncells);
-      
-      GetAODCaloCells()->SetType(esdCell->GetType());
-      
-      for (Int_t iCell = 0; iCell < ncells; iCell++) {      
-       if(GetDebug() > 2)  printf("AliAnaExample::MakeAnalysisFillAOD() - Cell : amp %f, absId %d,  time %f\n", esdCell->GetAmplitude(iCell), esdCell->GetCellNumber(iCell), esdCell->GetTime(iCell));
-       
-       GetAODCaloCells()->SetCell(iCell,esdCell->GetCellNumber(iCell),esdCell->GetAmplitude(iCell));
-      }
-      GetAODCaloCells()->Sort();
-    } 
-  }//cluster-cell analysis
+  }//Calorimeters
   else if(fDetector == "CTS"){ //Track analysis
     //Fill AODParticle with CTS aods
     TVector3 p3;
@@ -306,9 +214,9 @@ void  AliAnaExample::MakeAnalysisFillAOD()
       Bool_t in =  GetFiducialCut()->IsInFiducialCut(mom,"CTS") ;
       if(GetDebug() > 1) printf("AliAnaExample::MakeAnalysisFillAOD() - Track pt %2.2f, phi %2.2f, in fiducial cut %d\n",p3.Pt(), p3.Phi(), in);
       if(p3.Pt() > GetMinPt() && in) {
-       AliAODPWG4Particle tr = AliAODPWG4Particle(mom[0],mom[1],mom[2],0);
-       tr.SetDetector("CTS");
-       AddAODParticle(tr);
+        AliAODPWG4Particle tr = AliAODPWG4Particle(mom[0],mom[1],mom[2],0);
+        tr.SetDetector("CTS");
+        AddAODParticle(tr);
       }//selection
     }//loop
   }//CTS analysis
@@ -338,7 +246,7 @@ void  AliAnaExample::MakeAnalysisFillHistograms()
     fhEta->Fill(ph->Eta());
     
     if(IsDataMC()){
-      //Play with the MC stack if available
+    //Play with the MC stack if available
          Float_t ptprim  = 0;
          Float_t phiprim = 0;
          Float_t etaprim = 0;
@@ -356,7 +264,7 @@ void  AliAnaExample::MakeAnalysisFillHistograms()
                  }
       
                  TParticle * mom = GetMCStack()->Particle(ph->GetLabel());
-         ptprim  = mom->Pt();
+      ptprim  = mom->Pt();
                  phiprim = mom->Phi();
                  etaprim = mom->Eta();
          }
@@ -369,20 +277,7 @@ void  AliAnaExample::MakeAnalysisFillHistograms()
     }//Work with stack also
   }// aod branch loop
   
-  // CaloCells histograms
-  if(GetReader()->GetDataType()!= AliCaloTrackReader::kMC) {
-    if(GetAODCaloCells()){
-      
-      Int_t ncells = GetAODCaloCells()->GetNumberOfCells();
-      fhNCells->Fill(ncells) ;
-      
-      for (Int_t iCell = 0; iCell < ncells; iCell++) {      
-       if(GetDebug() > 2)  printf("AliAnaExample::MakeAnalysisFillHistograms() - Cell : amp %f, absId %d \n", GetAODCaloCells()->GetAmplitude(iCell), GetAODCaloCells()->GetCellNumber(iCell));
-       fhAmplitude->Fill(GetAODCaloCells()->GetAmplitude(iCell));
-      }
-    }//calo cells container exist
-  }
-}
+ }
 
 //________________________________________________________________________
 void AliAnaExample::ReadHistograms(TList* outputList)
@@ -399,11 +294,6 @@ void AliAnaExample::ReadHistograms(TList* outputList)
        fhPhi  = (TH1F *) outputList->At(index++); 
        fhEta  = (TH1F *) outputList->At(index++);
        
-       if(GetReader()->GetDataType()!= AliCaloTrackReader::kMC) {
-        fhNCells     = (TH1F *) outputList->At(index++); 
-        fhAmplitude  = (TH1F *) outputList->At(index++); 
-       }
-       
        if(IsDataMC()){
          fh2Pt  = (TH2F *) outputList->At(index++); 
          fh2Phi = (TH2F *) outputList->At(index++); 
index 6d9797c..dbfa602 100755 (executable)
@@ -64,11 +64,9 @@ class AliAnaExample : public AliAnaPartCorrBaseClass {
   TH2F * fh2Pt; //!pT distribution, reconstructed vs generated
   TH2F * fh2Phi; //! phi distribution, reconstructed vs generated
   TH2F * fh2Eta; //! eta distribution, reconstructed vs generated
-  //Calo Cells
-  TH1F * fhNCells; //! Number of towers/crystals with signal
-  TH1F * fhAmplitude; //! Amplitude measured in towers/crystals
-  ClassDef(AliAnaExample,1)
-    } ;
+  
+  ClassDef(AliAnaExample,2)
+} ;
 
 
 #endif //ALIANAEXAMPLE_H
index 4293f08..e7d2d04 100755 (executable)
@@ -1076,7 +1076,7 @@ Bool_t  AliAnaParticleHadronCorrelation::SelectCluster(AliAODCaloCluster * calo,
   //Select cluster depending on its pid and acceptance selections
   
   //Skip matched clusters with tracks
-  if(calo->GetNTracksMatched() > 0) return kFALSE;
+  if(IsTrackMatched(calo)) return kFALSE;
   
   TString detector = "";
   if     (calo->IsPHOS())  detector= "PHOS";
index ac1c368..d57105c 100755 (executable)
@@ -199,16 +199,16 @@ void AliAnaParticleJetFinderCorrelation::InitParameters()
   }
 
 //__________________________________________________________________
-Int_t  AliAnaParticleJetFinderCorrelation::SelectJet(AliAODPWG4Particle * particle) const 
+Int_t  AliAnaParticleJetFinderCorrelation::SelectJet(AliAODPWG4Particle * particle, AliAODEvent *event) const 
 {
   //Returns the index of the jet that is opposite to the particle
   
-  Int_t njets = (GetReader()->GetOutputEvent())->GetNJets() ;  
+  Int_t njets = event->GetNJets() ;    
   
   AliAODJet * jet = 0 ;
   Int_t index = -1;
   for(Int_t ijet = 0; ijet < njets ; ijet++){
-    jet = (GetReader()->GetOutputEvent())->GetJet(ijet) ;        
+    jet = event->GetJet(ijet) ;          
     Float_t dphi  = TMath::Abs(particle->Phi()-jet->Phi());
     Float_t ratio = jet->Pt()/particle->Pt();
     if(GetDebug() > 3)
@@ -230,32 +230,49 @@ return index ;
 void  AliAnaParticleJetFinderCorrelation::MakeAnalysisFillAOD() 
 {  
   //Particle-Jet Correlation Analysis, fill AODs
+
+  //Get the event, check if there are AODs available, if not, skip this analysis
+  AliAODEvent * event = NULL;
+  if(GetReader()->GetOutputEvent()) 
+  {
+    event = dynamic_cast<AliAODEvent*>(GetReader()->GetOutputEvent()); 
+  }
+  else if(GetReader()->GetDataType() == AliCaloTrackReader::kAOD) 
+  {   
+    event = dynamic_cast<AliAODEvent*>(GetReader()->GetInputEvent()); 
+  }
+  else 
+  {
+    if(GetDebug() > 3) printf("AliAnaParticleJetFinderCorrelation::MakeAnalysisFillAOD() - There are no jets available for this analysis\n");
+    return;
+  }
+    
   if(!GetInputAODBranch()){
     printf("AliAnaParticleJetFinderCorrelation::MakeAnalysisFillAOD() - No input particles in AOD with name branch < %s > \n",GetInputAODName().Data());
     abort();
   }
   
   if(strcmp(GetInputAODBranch()->GetClass()->GetName(), "AliAODPWG4ParticleCorrelation")){
-       printf("AliAnaParticleJetFinderCorrelation::MakeAnalysisFillAOD() - Wrong type of AOD object, change AOD class name in input AOD: It should be <AliAODPWG4ParticleCorrelation> and not <%s> \n",GetInputAODBranch()->GetClass()->GetName());
-       abort();
+    printf("AliAnaParticleJetFinderCorrelation::MakeAnalysisFillAOD() - Wrong type of AOD object, change AOD class name in input AOD: It should be <AliAODPWG4ParticleCorrelation> and not <%s> \n",GetInputAODBranch()->GetClass()->GetName());
+    abort();
   }
        
   Int_t ntrig =  GetInputAODBranch()->GetEntriesFast() ;  
   if(GetDebug() > 3){
     printf("AliAnaParticleJetFinderCorrelation::MakeAnalysisFillAOD() - Begin jet finder  correlation analysis, fill AODs \n");
     printf("AliAnaParticleJetFinderCorrelation::MakeAnalysisFillAOD() - In particle branch aod entries %d\n", ntrig);
-    printf("AliAnaParticleJetFinderCorrelation::MakeAnalysisFillAOD() - In jet      branch aod entries %d\n", (GetReader()->GetOutputEvent())->GetNJets());
+    printf("AliAnaParticleJetFinderCorrelation::MakeAnalysisFillAOD() - In jet      branch aod entries %d\n", event->GetNJets());
   }
-       
+  
   //Loop on stored AOD particles, trigger
   for(Int_t iaod = 0; iaod < ntrig ; iaod++){
     AliAODPWG4ParticleCorrelation* particle =  (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(iaod));
        
     //Correlate with jets
-    Int_t ijet = SelectJet(particle);
+    Int_t ijet = SelectJet(particle,event);
     if(ijet > -1){
       if(GetDebug() > 2) printf ("AliAnaParticleJetFinderCorrelation::MakeAnalysisFillAOD() - Jet with index %d selected \n",ijet);
-      AliAODJet *jet = (GetReader()->GetOutputEvent())->GetJet(ijet);            
+      AliAODJet *jet = event->GetJet(ijet);     
       particle->SetRefJet(jet);        
     }
   } // input aod loop            
@@ -268,15 +285,31 @@ void  AliAnaParticleJetFinderCorrelation::MakeAnalysisFillHistograms()
 {
   //Particle-Jet Correlation Analysis, fill histograms
   
+  //Get the event, check if there are AODs available, if not, skip this analysis
+  AliAODEvent * event = NULL;
+  if(GetReader()->GetOutputEvent()) 
+  {
+    event = dynamic_cast<AliAODEvent*>(GetReader()->GetOutputEvent()); 
+  }
+  else if(GetReader()->GetDataType() == AliCaloTrackReader::kAOD) 
+  {  
+    event = dynamic_cast<AliAODEvent*>(GetReader()->GetInputEvent()); 
+  }
+  else {
+    if(GetDebug() > 3) printf("AliAnaParticleJetFinderCorrelation::MakeAnalysisFillHistograms() - There are no jets available for this analysis\n");
+    return;
+  }
+  
   if(!GetInputAODBranch()){
     printf("AliAnaParticleJetFinderCorrelation::MakeAnalysisFillHistograms() - No input particles in AOD with name branch < %s > \n",GetInputAODName().Data());
     abort();
   }
+  
   Int_t ntrig   =  GetInputAODBranch()->GetEntriesFast() ;    
   if(GetDebug() > 1){
     printf("AliAnaParticleJetFinderCorrelation::MakeAnalysisFillHistograms() - Begin jet finder  correlation analysis, fill histograms \n");
     printf("AliAnaParticleJetFinderCorrelation::MakeAnalysisFillHistograms() - In particle branch aod entries %d\n", ntrig);
-    printf("AliAnaParticleJetFinderCorrelation::MakeAnalysisFillHistograms() - In jet      branch aod entries %d\n", (GetReader()->GetOutputEvent())->GetNJets());
+    printf("AliAnaParticleJetFinderCorrelation::MakeAnalysisFillHistograms() - In jet output branch aod entries %d\n", event->GetNJets());
   }
   
   //Loop on stored AOD particles, trigger
@@ -290,11 +323,11 @@ void  AliAnaParticleJetFinderCorrelation::MakeAnalysisFillHistograms()
     //If correlation not made before, do it now.
     if(fMakeCorrelationInHistoMaker){
       //Correlate with jets
-      Int_t ijet = SelectJet(particlecorr);
+      Int_t ijet = SelectJet(particlecorr,event);
       if(ijet > -1){
-       if(GetDebug() > 2) printf ("AliAnaParticleJetFinderCorrelation::MakeAnalysisFillHistograms() - Jet with index %d selected \n",ijet);
-       jet = (GetReader()->GetOutputEvent())->GetJet(ijet);
-       particlecorr->SetRefJet(jet);   
+        if(GetDebug() > 2) printf ("AliAnaParticleJetFinderCorrelation::MakeAnalysisFillHistograms() - Jet with index %d selected \n",ijet);
+        jet = event->GetJet(ijet);
+        particlecorr->SetRefJet(jet);  
       }
     }
     
@@ -330,9 +363,9 @@ void  AliAnaParticleJetFinderCorrelation::MakeAnalysisFillHistograms()
     
     for(Int_t ipr = 0;ipr < ntracks ; ipr ++ ){
       if(!fUseJetRefTracks)
-       track = (AliAODTrack *) (GetAODCTS()->At(ipr)) ; 
+        track = (AliAODTrack *) (GetAODCTS()->At(ipr)) ; 
       else //If you want to use jet tracks from JETAN
-       track = (AliAODTrack *) ((jet->GetRefTracks())->At(ipr));
+        track = (AliAODTrack *) ((jet->GetRefTracks())->At(ipr));
       
       p3.SetXYZ(track->Px(),track->Py(),track->Pz());
       pt    = p3.Pt();
@@ -343,11 +376,11 @@ void  AliAnaParticleJetFinderCorrelation::MakeAnalysisFillHistograms()
       //Check if there is any particle inside cone with pt larger than  fPtThreshold
       rad = TMath::Sqrt((eta-etaJet)*(eta-etaJet)+ (phi-phiJet)*(phi-phiJet));
       if(rad < fConeSize  && pt > fPtThresholdInCone){ 
-       //printf("charged in jet cone pt %f, phi %f, eta %f, R %f \n",pt,phi,eta,rad);
-       npartcone++;
-       fhFFz ->Fill(ptTrig, pt/ptTrig);
-       fhFFxi->Fill(ptTrig, TMath::Log(ptTrig/pt));
-       fhFFpt->Fill(ptTrig, pt);
+        //printf("charged in jet cone pt %f, phi %f, eta %f, R %f \n",pt,phi,eta,rad);
+        npartcone++;
+        fhFFz ->Fill(ptTrig, pt/ptTrig);
+        fhFFxi->Fill(ptTrig, TMath::Log(ptTrig/pt));
+        fhFFpt->Fill(ptTrig, pt);
       }
     }//Tracks
     fhNTracksInCone->Fill(ptTrig, npartcone);
index 4c2eb78..71694fd 100755 (executable)
@@ -59,7 +59,7 @@ class AliAnaParticleJetFinderCorrelation : public AliAnaPartCorrBaseClass {
   
  private:
   
-  Int_t SelectJet(AliAODPWG4Particle * particle) const ;
+  Int_t SelectJet(AliAODPWG4Particle * particle, AliAODEvent * event) const ;
   
   void MakeAnalysisFillAOD() ;
   void MakeAnalysisFillHistograms() ;
index a93f84f..a52e6de 100755 (executable)
@@ -1519,7 +1519,7 @@ void AliAnaParticleJetLeadingConeCorrelation::MakeAODJet(AliAODPWG4ParticleCorre
       AliAODCaloCluster * calo = (AliAODCaloCluster *) (GetAODEMCAL()->At(iclus)) ;
       
       //Cluster selection, not charged
-      if(calo->GetNTracksMatched() > 0) continue ;
+      if(IsTrackMatched(calo)) continue ;
       
          //Input from second AOD?
          Int_t input = 0;
@@ -1686,7 +1686,7 @@ Bool_t  AliAnaParticleJetLeadingConeCorrelation::SelectCluster(AliAODCaloCluster
   //Select cluster depending on its pid and acceptance selections
   
   //Skip matched clusters with tracks
-  if(calo->GetNTracksMatched() > 0) return kFALSE;
+  if(IsTrackMatched(calo)) return kFALSE;
   
   //Check PID
   calo->GetMomentum(mom,vertex);//Assume that come from vertex in straight line
index 5e5e462..a965348 100755 (executable)
@@ -446,10 +446,10 @@ void AliAnaPhoton::InitParameters()
 //__________________________________________________________________
 void  AliAnaPhoton::MakeAnalysisFillAOD() 
 {
-    //Do analysis and fill aods
-    //Search for photons in fCalorimeter 
+  //Do analysis and fill aods
+  //Search for photons in fCalorimeter 
   
-    //Get vertex for photon momentum calculation
+  //Get vertex for photon momentum calculation
   
   for (Int_t iev = 0; iev < GetNMixedEvent(); iev++) {
     if (!GetMixedEvent()) 
@@ -457,24 +457,24 @@ void  AliAnaPhoton::MakeAnalysisFillAOD()
     else 
       GetMixedEvent()->GetVertexOfEvent(iev)->GetXYZ(GetVertex(iev)); 
   } 
-
-//  Double_t vertex2[] = {0,0,0} ; //vertex from second input aod
-//  
-//  if(GetReader()->GetDataType()!= AliCaloTrackReader::kMC) 
-//  {
-//       if(GetReader()->GetSecondInputAODTree()) 
-//      GetReader()->GetSecondInputAODVertex(vertex2);
-//  }
-    //printf("Vertex 0: %f,%f,%f\n",vertex[0],vertex[1],vertex[2]);
-    //printf("Vertex 1: %f,%f,%f\n",vertex2[0],vertex2[1],vertex2[2]);
-    //Select the Calorimeter of the photon
+  
+  //  Double_t vertex2[] = {0,0,0} ; //vertex from second input aod
+  //  
+  //  if(GetReader()->GetDataType()!= AliCaloTrackReader::kMC) 
+  //  {
+  //     if(GetReader()->GetSecondInputAODTree()) 
+  //      GetReader()->GetSecondInputAODVertex(vertex2);
+  //  }
+  //printf("Vertex 0: %f,%f,%f\n",vertex[0],vertex[1],vertex[2]);
+  //printf("Vertex 1: %f,%f,%f\n",vertex2[0],vertex2[1],vertex2[2]);
+  //Select the Calorimeter of the photon
   TObjArray * pl = 0x0; 
   if(fCalorimeter == "PHOS")
     pl = GetAODPHOS();
   else if (fCalorimeter == "EMCAL")
     pl = GetAODEMCAL();
   
-    //Fill AODCaloClusters and AODParticle with PHOS/EMCAL aods
+  //Fill AODCaloClusters and AODParticle with PHOS/EMCAL aods
   TLorentzVector mom, mom2 ;
   Int_t nCaloClusters = pl->GetEntriesFast();
   Bool_t * indexConverted = new Bool_t[nCaloClusters];
@@ -484,27 +484,27 @@ void  AliAnaPhoton::MakeAnalysisFillAOD()
   for(Int_t icalo = 0; icalo < nCaloClusters; icalo++){    
          
          AliAODCaloCluster * calo =  (AliAODCaloCluster*) (pl->At(icalo));     
-  
+    
     Int_t evtIndex = 0 ; 
     if (GetMixedEvent()) {
       evtIndex=GetMixedEvent()->EventIndexForCaloCluster(calo->GetID()) ; 
     }
-      //Cluster selection, not charged, with photon id and in fiducial cut
+    //Cluster selection, not charged, with photon id and in fiducial cut
          
-      //Input from second AOD?
+    //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()->GetAODEMCALNormalInputEntries() <= icalo) 
+    //      input = 1 ;
+    //    else if(fCalorimeter == "PHOS"  && GetReader()->GetAODPHOSNormalInputEntries()  <= icalo) 
+    //      input = 1;
          
-      //Get Momentum vector, 
+    //Get Momentum vector, 
     if (input == 0) 
       calo->GetMomentum(mom,GetVertex(evtIndex)) ;//Assume that come from vertex in straight line
-//    else if(input == 1) 
-//      calo->GetMomentum(mom,vertex2);//Assume that come from vertex in straight line  
+    //    else if(input == 1) 
+    //      calo->GetMomentum(mom,vertex2);//Assume that come from vertex in straight line  
     
-      //If too small or big pt, skip it
+    //If too small or big pt, skip it
     if(mom.Pt() < GetMinPt() || mom.Pt() > GetMaxPt() ) continue ; 
     Double_t tof = calo->GetTOF()*1e9;
     
@@ -512,28 +512,28 @@ void  AliAnaPhoton::MakeAnalysisFillAOD()
          
     if(calo->GetNCells() <= fNCellsCut) continue;
          
-      //printf("AliAnaPhoton::Current Event %d; Current File Name : %s, E %f, pT %f, Ecl %f\n",GetReader()->GetEventNumber(),(GetReader()->GetCurrentFileName()).Data(), mom.E(), mom.Pt(),calo->E());
+    //printf("AliAnaPhoton::Current Event %d; Current File Name : %s, E %f, pT %f, Ecl %f\n",GetReader()->GetEventNumber(),(GetReader()->GetCurrentFileName()).Data(), mom.E(), mom.Pt(),calo->E());
     
-      //Check acceptance selection
+    //Check acceptance selection
     if(IsFiducialCutOn()){
       Bool_t in = GetFiducialCut()->IsInFiducialCut(mom,fCalorimeter) ;
       if(! in ) continue ;
     }
     
-      //Create AOD for analysis
+    //Create AOD for analysis
     AliAODPWG4Particle aodph = AliAODPWG4Particle(mom);
     Int_t label = calo->GetLabel();
     aodph.SetLabel(label);
     aodph.SetInputFileIndex(input);
     
-      //printf("Index %d, Id %d\n",icalo, calo->GetID());
-      //Set the indeces of the original caloclusters  
+    //printf("Index %d, Id %d\n",icalo, calo->GetID());
+    //Set the indeces of the original caloclusters  
     aodph.SetCaloLabel(calo->GetID(),-1);
     aodph.SetDetector(fCalorimeter);
     if(GetDebug() > 1) 
       printf("AliAnaPhoton::MakeAnalysisFillAOD() - Min pt cut and fiducial cut passed: pt %3.2f, phi %2.2f, eta %1.2f\n",aodph.Pt(),aodph.Phi(),aodph.Eta()); 
     
-      //Check Distance to Bad channel, set bit.
+    //Check Distance to Bad channel, set bit.
     Double_t distBad=calo->GetDistanceToBadChannel() ; //Distance to bad channel
     if(distBad < 0.) distBad=9999. ; //workout strange convension dist = -1. ;
     if(distBad < fMinDist) //In bad channel (PHOS cristal size 2.2x2.2 cm)
@@ -541,26 +541,27 @@ void  AliAnaPhoton::MakeAnalysisFillAOD()
     
     if(GetDebug() > 1) printf("AliAnaPhoton::MakeAnalysisFillAOD() - Bad channel cut passed %4.2f\n",distBad);
     
-    if(distBad > fMinDist3) aodph.SetDistToBad(2) ;
+    if     (distBad > fMinDist3) aodph.SetDistToBad(2) ;
     else if(distBad > fMinDist2) aodph.SetDistToBad(1) ; 
-    else aodph.SetDistToBad(0) ;
+    else                         aodph.SetDistToBad(0) ;
     
-      //Skip matched clusters with tracks
-    if(fRejectTrackMatch && calo->GetNTracksMatched() > 0) continue ;
+    //Skip matched clusters with tracks
+    if(fRejectTrackMatch && IsTrackMatched(calo)) continue ;
+    if(GetDebug() > 1) printf("AliAnaPhoton::MakeAnalysisFillAOD() - TrackMatching cut passed \n");
     
-      //Check PID
-      //PID selection or bit setting
+    //Check PID
+    //PID selection or bit setting
     if(GetReader()->GetDataType() == AliCaloTrackReader::kMC){
-        //Get most probable PID, check PID weights (in MC this option is mandatory)
+      //Get most probable PID, check PID weights (in MC this option is mandatory)
       aodph.SetPdg(GetCaloPID()->GetPdg(fCalorimeter,calo->GetPID(),mom.E()));//PID with weights
       if(GetDebug() > 1) printf("AliAnaPhoton::MakeAnalysisFillAOD() - PDG of identified particle %d\n",aodph.GetPdg());        
-        //If primary is not photon, skip it.
+      //If primary is not photon, skip it.
       if(aodph.GetPdg() != AliCaloPID::kPhoton) continue ;
     }                                  
     else if(IsCaloPIDOn()){
       
-        //Get most probable PID, 2 options check PID weights 
-        //or redo PID, recommended option for EMCal.           
+      //Get most probable PID, 2 options check PID weights 
+      //or redo PID, recommended option for EMCal.             
       if(!IsCaloPIDRecalculationOn())
         aodph.SetPdg(GetCaloPID()->GetPdg(fCalorimeter,calo->GetPID(),mom.E()));//PID with weights
       else
@@ -568,21 +569,21 @@ void  AliAnaPhoton::MakeAnalysisFillAOD()
       
       if(GetDebug() > 1) printf("AliAnaPhoton::MakeAnalysisFillAOD() - PDG of identified particle %d\n",aodph.GetPdg());
       
-        //If cluster does not pass pid, not photon, skip it.
+      //If cluster does not pass pid, not photon, skip it.
       if(aodph.GetPdg() != AliCaloPID::kPhoton) continue ;                     
       
     }
     else{
-        //Set PID bits for later selection (AliAnaPi0 for example)
-        //GetPDG already called in SetPIDBits.
+      //Set PID bits for later selection (AliAnaPi0 for example)
+      //GetPDG already called in SetPIDBits.
       GetCaloPID()->SetPIDBits(fCalorimeter,calo,&aodph);
       if(GetDebug() > 1) printf("AliAnaPhoton::MakeAnalysisFillAOD() - PID Bits set \n");              
     }
     
     if(GetDebug() > 1) printf("AliAnaPhoton::MakeAnalysisFillAOD() - Photon selection cuts passed: pT %3.2f, pdg %d\n",aodph.Pt(), aodph.GetPdg());
     
-      //Play with the MC stack if available
-      //Check origin of the candidates
+    //Play with the MC stack if available
+    //Check origin of the candidates
     if(IsDataMC()){
       
       aodph.SetTag(GetMCAnalysisUtils()->CheckOrigin(calo->GetLabels(),calo->GetNLabels(),GetReader(), aodph.GetInputFileIndex()));
@@ -590,33 +591,33 @@ void  AliAnaPhoton::MakeAnalysisFillAOD()
     }//Work with stack also   
     
     
-      // Check if cluster comes from a conversion in the material in front of the calorimeter
-      // Do invariant mass of all pairs, if mass is close to 0, then it is conversion.
+    // Check if cluster comes from a conversion in the material in front of the calorimeter
+    // Do invariant mass of all pairs, if mass is close to 0, then it is conversion.
     
     if(fCheckConversion && nCaloClusters > 1){
       Bool_t bConverted = kFALSE;
       Int_t id2 = -1;
                  
-        //Check if set previously as converted couple, if so skip its use.
+      //Check if set previously as converted couple, if so skip its use.
       if (indexConverted[icalo]) continue;
                  
       for(Int_t jcalo = icalo + 1 ; jcalo < nCaloClusters ; jcalo++) {
-          //Check if set previously as converted couple, if so skip its use.
+        //Check if set previously as converted couple, if so skip its use.
         if (indexConverted[jcalo]) continue;
-          //printf("Check Conversion indeces %d and %d\n",icalo,jcalo);
+        //printf("Check Conversion indeces %d and %d\n",icalo,jcalo);
         AliAODCaloCluster * calo2 =  (AliAODCaloCluster*) (pl->At(jcalo));              //Get cluster kinematics
         Int_t evtIndex2 = 0 ; 
         if (GetMixedEvent()) {
           evtIndex2=GetMixedEvent()->EventIndexForCaloCluster(calo2->GetID()) ; 
         }        
         calo2->GetMomentum(mom2,GetVertex(evtIndex2));
-          //Check only certain regions
+        //Check only certain regions
         Bool_t in2 = kTRUE;
         if(IsFiducialCutOn()) in2 =  GetFiducialCut()->IsInFiducialCut(mom2,fCalorimeter) ;
         if(!in2) continue;      
         
-          //Get mass of pair, if small, take this pair.
-          //printf("\t both in calo, mass %f, cut %f\n",(mom+mom2).M(),fMassCut);
+        //Get mass of pair, if small, take this pair.
+        //printf("\t both in calo, mass %f, cut %f\n",(mom+mom2).M(),fMassCut);
         if((mom+mom2).M() < fMassCut){  
           bConverted = kTRUE;
           id2 = calo2->GetID();
@@ -628,38 +629,38 @@ void  AliAnaPhoton::MakeAnalysisFillAOD()
                  
       if(bConverted){ 
         if(fAddConvertedPairsToAOD){
-            //Create AOD of pair analysis
+          //Create AOD of pair analysis
           TLorentzVector mpair = mom+mom2;
           AliAODPWG4Particle aodpair = AliAODPWG4Particle(mpair);
           aodpair.SetLabel(aodph.GetLabel());
           aodpair.SetInputFileIndex(input);
           
-            //printf("Index %d, Id %d\n",icalo, calo->GetID());
-            //Set the indeces of the original caloclusters  
+          //printf("Index %d, Id %d\n",icalo, calo->GetID());
+          //Set the indeces of the original caloclusters  
           aodpair.SetCaloLabel(calo->GetID(),id2);
           aodpair.SetDetector(fCalorimeter);
           aodpair.SetPdg(aodph.GetPdg());
           aodpair.SetTag(aodph.GetTag());
           
-            //Add AOD with pair object to aod branch
+          //Add AOD with pair object to aod branch
           AddAODParticle(aodpair);
-            //printf("\t \t both added pair\n");
+          //printf("\t \t both added pair\n");
         }
         
-          //Do not add the current calocluster
+        //Do not add the current calocluster
         continue;
       }//converted pair
     }//check conversion
-     //printf("\t \t added single cluster %d\n",icalo);
+    //printf("\t \t added single cluster %d\n",icalo);
          
-      //Add AOD with photon object to aod branch
+    //Add AOD with photon object to aod branch
     AddAODParticle(aodph);
     
   }//loop
   
   delete [] indexConverted;
        
-  if(GetDebug() > 1) printf("AliAnaPhoton::MakeAnalysisFillAOD()  End fill AODs \n");  
+  if(GetDebug() > 1) printf("AliAnaPhoton::MakeAnalysisFillAOD()  End fill AODs, with %d entries \n",GetOutputAODBranch()->GetEntriesFast());  
   
 }
 
index 4de6c12..e093d3f 100755 (executable)
@@ -467,7 +467,7 @@ void  AliAnaPi0EbE::MakeShowerShapeIdentification()
   
   //Get vertex for photon momentum calculation
   Double_t vertex[]  = {0,0,0} ; //vertex 
-  Double_t vertex2[] = {0,0,0} ; //vertex from second aod input
+  //Double_t vertex2[] = {0,0,0} ; //vertex from second aod input
   if(GetReader()->GetDataType() != AliCaloTrackReader::kMC) 
   {
          GetReader()->GetVertex(vertex);
@@ -536,7 +536,7 @@ void  AliAnaPi0EbE::MakeShowerShapeIdentification()
     }                                  
     else if(IsCaloPIDOn()){
       //Skip matched clusters with tracks
-      if(calo->GetNTracksMatched() > 0) continue ;
+      if(IsTrackMatched(calo)) continue ;
       
       //Get most probable PID, 2 options check PID weights 
       //or redo PID, recommended option for EMCal.             
index 6f3bfdf..b1ac69f 100644 (file)
@@ -1,4 +1,4 @@
-AliAnalysisTaskParticleCorrelation *AddTaskPartCorr(TString data, TString calorimeter, Bool_t kPrintSettings = kFALSE,Bool_t kSimulation = kFALSE)
+AliAnalysisTaskParticleCorrelation *AddTaskPartCorr(TString data, TString calorimeter, Bool_t kPrintSettings = kFALSE,Bool_t kSimulation = kFALSE, Bool_t outputAOD=kFALSE, Bool_t oldAOD=kFALSE)
 {
   // Creates a PartCorr task, configures it and adds it to the analysis manager.
   
@@ -75,6 +75,8 @@ AliAnalysisTaskParticleCorrelation *AddTaskPartCorr(TString data, TString calori
   reader->SetEMCALPtMin(0.1); 
   reader->SetPHOSPtMin(0.);
   reader->SetCTSPtMin(0.);
+  if(outputAOD)  reader->SwitchOffWriteDeltaAOD()  ;
+  if(oldAOD) reader->SwitchOnOldAODs();
   if(kPrintSettings) reader->Print("");
   
   // *** Calorimeters Utils    ***
@@ -536,7 +538,7 @@ AliAnalysisTaskParticleCorrelation *AddTaskPartCorr(TString data, TString calori
   //==============================================================================
   mgr->ConnectInput  (task, 0, mgr->GetCommonInputContainer());
   // AOD output slot will be used in a different way in future
-  if(!data.Contains("delta")) mgr->ConnectOutput (task, 0, mgr->GetCommonOutputContainer());
+  if(!data.Contains("delta")   && outputAOD) mgr->ConnectOutput (task, 0, mgr->GetCommonOutputContainer());
   mgr->ConnectOutput (task, 1, cout_pc);
   mgr->ConnectOutput (task, 2, cout_cuts);