Correct MCReader: do not fill created AODCaloClusters to AODEvent
authorgconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 2 Sep 2010 16:06:26 +0000 (16:06 +0000)
committergconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 2 Sep 2010 16:06:26 +0000 (16:06 +0000)
AliAnaPhoton: Use cell cut only for data, not for MC data
All: Remove declaration, usage of AliAODCaloClusters and move to AliVClusters
AliCaloTrackESD/AODReader: Clean up a bit the classes, move the track status initizalization to the AliCaloTrackReader
Declare as virtual in AliCaloTrackReader some setters only used in AliCaloTrackMCReader

24 files changed:
PWG4/PartCorrBase/AliCaloPID.cxx
PWG4/PartCorrBase/AliCaloPID.h
PWG4/PartCorrBase/AliCaloTrackAODReader.cxx
PWG4/PartCorrBase/AliCaloTrackESDReader.cxx
PWG4/PartCorrBase/AliCaloTrackESDReader.h
PWG4/PartCorrBase/AliCaloTrackMCReader.cxx
PWG4/PartCorrBase/AliCaloTrackMCReader.h
PWG4/PartCorrBase/AliCaloTrackReader.cxx
PWG4/PartCorrBase/AliCaloTrackReader.h
PWG4/PartCorrBase/AliIsolationCut.cxx
PWG4/PartCorrDep/AliAnaBtag.cxx
PWG4/PartCorrDep/AliAnaElectron.cxx
PWG4/PartCorrDep/AliAnaExample.cxx
PWG4/PartCorrDep/AliAnaParticleHadronCorrelation.cxx
PWG4/PartCorrDep/AliAnaParticleHadronCorrelation.h
PWG4/PartCorrDep/AliAnaParticleIsolation.cxx
PWG4/PartCorrDep/AliAnaParticleJetLeadingConeCorrelation.cxx
PWG4/PartCorrDep/AliAnaParticleJetLeadingConeCorrelation.h
PWG4/PartCorrDep/AliAnaPhoton.cxx
PWG4/PartCorrDep/AliAnaPhoton.h
PWG4/PartCorrDep/AliAnaPi0.cxx
PWG4/PartCorrDep/AliAnaPi0EbE.cxx
PWG4/macros/AddTaskPartCorr.C
PWG4/macros/QA/AddTaskCalorimeterQA.C

index b80f755bf0d0f77cf31dde0972ecba27d8e558bf..177947f844f5ff42c8e47104bfda690c3bcb0fc9 100755 (executable)
@@ -20,7 +20,7 @@
 // being kPhoton, kElectron, kPi0 ... as defined in the header file
 //   - GetPdg(const TString calo, const Double_t * pid, const Float_t energy)
 //      Reads the PID weights array of the ESDs and depending on its magnitude identifies the particle
-//   - GetPdg(const TString calo,const TLorentzVector mom, const AliAODCaloCluster * cluster)
+//   - GetPdg(const TString calo,const TLorentzVector mom, const AliVCluster * cluster)
 //      Recalcultes PID, the bayesian or any new one to be implemented in the future
 //      Right now only the possibility to recalculate EMCAL with bayesian and simple PID.
 //      In order to recalculate Bayesian, it is necessary to load the EMCALUtils library
@@ -46,7 +46,7 @@
 
 //---- ANALYSIS system ----
 #include "AliCaloPID.h"
-#include "AliAODCaloCluster.h"
+#include "AliVCluster.h"
 #include "AliAODPWG4Particle.h"
 #include "AliEMCALPIDUtils.h"
 ClassImp(AliCaloPID)
@@ -294,7 +294,7 @@ Int_t AliCaloPID::GetPdg(const TString calo, const Double_t * pid, const Float_t
 }
 
 //_______________________________________________________________
-Int_t AliCaloPID::GetPdg(const TString calo,const TLorentzVector mom, const AliAODCaloCluster * cluster) const {
+Int_t AliCaloPID::GetPdg(const TString calo,const TLorentzVector mom, const AliVCluster * cluster) const {
   //Recalculated PID with all parameters
   Float_t lambda0 = cluster->GetM02();
   Float_t energy = mom.E();    
@@ -415,7 +415,7 @@ void AliCaloPID::Print(const Option_t * opt) const
 } 
 
 //_______________________________________________________________
-void AliCaloPID::SetPIDBits(const TString calo, const AliAODCaloCluster * cluster, AliAODPWG4Particle * ph) {
+void AliCaloPID::SetPIDBits(const TString calo, const AliVCluster * cluster, AliAODPWG4Particle * ph) {
   //Set Bits for PID selection
   
   //Dispersion/lambdas
index 465cc938338f5ed89e2a2cae8aed627675d24abc..c461e9186fad2f85cf7d083078f9d4c1cb01774e 100755 (executable)
@@ -10,7 +10,7 @@
 // being kPhoton, kElectron, kPi0 ... as defined in the header file
 //   - GetPdg(const TString calo, const Double_t * pid, const Float_t energy)
 //      Reads the PID weights array of the ESDs and depending on its magnitude identifies the particle
-//   - GetPdg(const TString calo,const TLorentzVector mom, const AliAODCaloCluster * cluster)
+//   - GetPdg(const TString calo,const TLorentzVector mom, const AliVCluster * cluster)
 //      Recalcultes PID, the bayesian or any new one to be implemented in the future
 //      Right now only the possibility to recalculate EMCAL with bayesian and simple PID.
 //      In order to recalculate Bayesian, it is necessary to load the EMCALUtils library
@@ -35,7 +35,7 @@ class TLorentzVector ;
 class TTask;
 
 //--- AliRoot system ---
-class AliAODCaloCluster;
+class AliVCluster;
 class AliAODPWG4Particle;
 class AliEMCALPIDUtils;
 
@@ -72,11 +72,11 @@ public:
   
   Int_t GetPdg(const TString calo, const Double_t * pid, const Float_t energy) const ;
   
-  Int_t GetPdg(const TString calo,const TLorentzVector mom, const AliAODCaloCluster * cluster) const ;
+  Int_t GetPdg(const TString calo,const TLorentzVector mom, const AliVCluster * cluster) const ;
   
   TString      GetPIDParametersList();
   
-  void SetPIDBits(const TString calo,  const AliAODCaloCluster * cluster, AliAODPWG4Particle *aodph);
+  void SetPIDBits(const TString calo,  const AliVCluster * cluster, AliAODPWG4Particle *aodph);
   
   void Print(const Option_t * opt)const;
   
index 44997506752f8d16fa5419a373b81e5557605986..ef90778301f4ade5ceb18bcca4cfee62ed2fb760 100755 (executable)
 
 //---- ANALYSIS system ----
 #include "AliCaloTrackAODReader.h" 
-#include "AliAODCaloCluster.h"
-#include "AliAODTrack.h"
-#include "AliESDtrack.h"
-#include "AliFiducialCut.h"
 #include "AliAODInputHandler.h"
 #include "AliMultiEventInputHandler.h"
 #include "AliAnalysisManager.h"
@@ -52,30 +48,8 @@ AliCaloTrackAODReader::AliCaloTrackAODReader() :
   fDataType=kAOD;
   fReadStack          = kTRUE;
   fReadAODMCParticles = kFALSE;
-  //We want tracks fitted in the detectors:
-  fTrackStatus=AliESDtrack::kTPCrefit;
-  fTrackStatus|=AliESDtrack::kITSrefit;
-
 }
-/*
-//____________________________________________________________________________
-AliCaloTrackAODReader::AliCaloTrackAODReader(const AliCaloTrackAODReader & aodr) :   
-  AliCaloTrackReader(aodr), fWriteOutputStdAOD(aodr.fWriteOutputStdAOD)
-{
-  // cpy ctor
-}
-*/
-//_________________________________________________________________________
-//AliCaloTrackAODReader & AliCaloTrackAODReader::operator = (const AliCaloTrackAODReader & source)
-//{
-//  // assignment operator
-//
-//  if(&source == this) return *this;
-//
-//  return *this;
-//
-//}
-
 
 //____________________________________________________________________________
 //void AliCaloTrackAODReader::GetSecondInputAODVertex(Double_t  v[3]) const {
index 63a1f6ae5c9949b592c1fb6156c8320a6cec0707..2562064067cdb3460655773774a10c585ef18dc2 100755 (executable)
 // Class for reading data (ESDs) in order to do prompt gamma 
 // or other particle identification and correlations
 //
-// It is a filtering class, transforms ESD tracks or CaloClusters
-// into AOD tracks and calocluters, which are the basic input of the analysis
-// classes in this frame.
-// It is recommended to use the official filter AliAnalysisTaskESDfilter, and 
-// then the reader for AODs AliCaloTrackAODReader.
+//
 //
 //
 //*-- Author: Gustavo Conesa (LNF-INFN) 
 
 //---- ANALYSIS system ----
 #include "AliCaloTrackESDReader.h" 
-#include "AliESDCaloCluster.h"
-#include "AliAODCaloCluster.h"
-#include "AliAODTrack.h"
-#include "AliAODPid.h"
 #include "AliAODEvent.h"
 #include "AliMultiEventInputHandler.h"
 #include "AliAnalysisManager.h"
-#include "AliFiducialCut.h"
 #include "AliMixedEvent.h"
 
 
@@ -58,375 +49,8 @@ AliCaloTrackReader()
   fDataType=kESD;
   fReadStack          = kTRUE;
   fReadAODMCParticles = kFALSE;
-  //We want tracks fitted in the detectors:
-  fTrackStatus=AliESDtrack::kTPCrefit;
-  fTrackStatus|=AliESDtrack::kITSrefit;
-  //This reader creates the AOD objects (Tracks-clusters), so it owns them 
-  //fAODCTS  ->SetOwner(kTRUE);
-  //fAODEMCAL->SetOwner(kTRUE);
-  //fAODPHOS ->SetOwner(kTRUE);
-}
-/*
-//____________________________________________________________________________
-AliCaloTrackESDReader::AliCaloTrackESDReader(const AliCaloTrackESDReader & g) :   
-  AliCaloTrackReader(g)
-{
-  // cpy ctor
-}
-*/
-//_________________________________________________________________________
-//AliCaloTrackESDReader & AliCaloTrackESDReader::operator = (const AliCaloTrackESDReader & source)
-//{
-//     // assignment operator
-//     
-//     if(&source == this) return *this;
-//     
-//     return *this;
-//     
-//}
-
-//____________________________________________________________________________
-//void AliCaloTrackESDReader::FillInputCTS() {
-//  //Return array with CTS tracks
-//  if(fDebug > 2 ) printf("AliCaloTrackESDReader::FillInputCTS()\n");
-//
-//  //TObjArray * fAODCTS = new TObjArray();
-//  Int_t nTracks   = fInputEvent->GetNumberOfTracks() ;
-//  Int_t naod = 0;
-//  Double_t pos[3];
-//  Double_t p[3];
-//  Double_t covTr[21];
-//  Double_t pid[10];
-//  Double_t bfield = fInputEvent->GetMagneticField();
-//
-//  Double_t      timezero        = 0;   //TO BE FIXED
-// 
-//  //List of output tracks 
-//  TClonesArray &tracks = *(fOutputEvent->GetTracks());
-//
-//  //To be replaced by call to AliEMCALGeoUtils when the class becomes available
-//  Double_t radius = 441.0; //[cm] EMCAL radius +13cm
-//
-//  if(fDebug > 1) printf("AliCaloTrackESDReader::FillInputCTS() - org entries %d\n", nTracks);
-//  for (Int_t itrack =  0; itrack <  nTracks; itrack++) {////////////// track loop
-//    AliESDtrack * track = (AliESDtrack*) fInputEvent->GetTrack(itrack) ; // retrieve track from esd
-//    
-//    //We want tracks fitted in the detectors: TPCrefit, ITSrefit ... check the set bits.
-//     if (fTrackStatus && !((track->GetStatus() & fTrackStatus) == fTrackStatus)) continue ;
-//      
-//     track->GetPxPyPz(p) ;
-//     TLorentzVector momentum(p[0],p[1],p[2],0);
-//      
-//     if(fCTSPtMin < momentum.Pt()){
-//             
-//             if(fCheckFidCut && !fFiducialCut->IsInFiducialCut(momentum,"CTS")) continue;
-//             
-//             if(fDebug > 3 && momentum.Pt() > 0.2) printf("AliCaloTrackESDReader::FillInputCTS() - Selected tracks E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f\n",
-//                                                 momentum.E(),momentum.Pt(),momentum.Phi()*TMath::RadToDeg(),momentum.Eta());
-//     
-//             track->GetXYZ(pos);
-//             track->GetCovarianceXYZPxPyPz(covTr);
-//             track->GetESDpid(pid);
-//     
-//             Float_t impactXY, impactZ;
-//     
-//             track->GetImpactParameters(impactXY,impactZ);
-//     
-//             if (impactXY<3) {
-//               // track inside the beam pipe
-//               //Put new aod object in file in AOD tracks array
-//               AliAODTrack *aodTrack = new(tracks[naod++]) 
-//                 //AliAODTrack *aodTrack = new((*(fOutputEvent->GetTracks()))[naod++]) 
-//                 AliAODTrack(track->GetID(), track->GetLabel(), p, kTRUE, pos, kFALSE,covTr, (Short_t)track->GetSign(), track->GetITSClusterMap(), 
-//                             pid,
-//                             0x0,//primary,
-//                             kTRUE, // check if this is right
-//                             kTRUE, // check if this is right
-//                             AliAODTrack::kPrimary, 
-//                             0);
-//               
-//               aodTrack->SetFlags(track->GetStatus());
-//               aodTrack->ConvertAliPIDtoAODPID();
-//
-//               //fill needed AliAODPid information, including
-//               //Extrapolate track to EMCAL surface for AOD-level track-cluster matching
-//               AliAODPid *aodpid = new AliAODPid;
-//               aodpid->SetITSsignal(track->GetITSsignal());
-//               aodpid->SetTPCsignal(track->GetTPCsignal());
-//               //n TRD planes = 6
-//               Int_t nslices = track->GetNumberOfTRDslices()*6;
-//               Double_t *trdslices = new Double_t[nslices];
-//               for(Int_t iSl =0; iSl < track->GetNumberOfTRDslices(); iSl++) {
-//                 for(Int_t iPl =0; iPl<6; iPl++) trdslices[iPl*track->GetNumberOfTRDslices()+iSl] = track->GetTRDslice(iPl,iSl);
-//               }
-//               aodpid->SetTRDsignal(track->GetNumberOfTRDslices()*6,trdslices);
-//               Double_t times[AliAODPid::kSPECIES]; track->GetIntegratedTimes(times);
-//               aodpid->SetIntegratedTimes(times);
-//
-//               aodpid->SetTOFsignal(track->GetTOFsignal()-timezero); // to be fixed 
-//               aodpid->SetHMPIDsignal(track->GetHMPIDsignal());
-//
-//               Double_t emcpos[3] = {0.,0.,0.};
-//               Double_t emcmom[3] = {0.,0.,0.};
-//               aodpid->SetEMCALPosition(emcpos);
-//               aodpid->SetEMCALMomentum(emcmom);
-//               
-//               AliExternalTrackParam *outerparam = (AliExternalTrackParam*)track->GetOuterParam();
-//               if(!outerparam) continue;
-//               
-//               Bool_t okpos = outerparam->GetXYZAt(radius,bfield,emcpos);
-//               Bool_t okmom = outerparam->GetPxPyPzAt(radius,bfield,emcmom);
-//               if(!(okpos && okmom)) continue;
-//               
-//               aodpid->SetEMCALPosition(emcpos);
-//               aodpid->SetEMCALMomentum(emcmom);
-//               
-//               aodTrack->SetDetPID(aodpid);
-//             }
-//             else continue;   // outside the beam pipe: orphan track 
-//     }//Pt and Fiducial cut passed. 
-//  }// track loop
-//
-//  //Put references to selected tracks in array
-//  for(Int_t itrack = 0; itrack < (fOutputEvent->GetTracks())->GetEntriesFast(); itrack++){
-//    AliAODTrack * track =  (AliAODTrack*) (fOutputEvent->GetTracks())->At(itrack);   
-//    fAODCTS->Add(track);                             
-//  }  
-//  
-//  if(fDebug > 1) printf("AliCaloTrackESDReader::FillInputCTS() - aod entries %d\n", fAODCTS->GetEntriesFast());
-//}
-//
-////____________________________________________________________________________
-//void AliCaloTrackESDReader::FillInputEMCAL() {
-//    //Return array with EMCAL clusters in aod format
-//  if(fDebug > 2 ) printf("AliCaloTrackESDReader::FillInputEMCAL()\n");
-//  
-//  Float_t pos[3] ;
-//  Int_t naod      = (fOutputEvent->GetCaloClusters())->GetEntriesFast();
-//  Int_t nTracks   = fInputEvent->GetNumberOfTracks() ;
-//  
-//    //Loop to select clusters in fiducial cut and fill container with aodClusters
-//  for (Int_t iclus = 0; iclus < fInputEvent->GetNumberOfCaloClusters(); iclus++) {
-//    AliESDCaloCluster * clus = 0;
-//    if ( (clus = (AliESDCaloCluster *)fInputEvent->GetCaloCluster(iclus)) ) {
-//      if (clus->IsEMCAL()){
-//        
-//          //Check if the cluster contains any bad channel and if close to calorimeter borders
-//        Int_t vindex = 0 ;  
-//        if (fMixedEvent) 
-//          vindex = fMixedEvent->EventIndexForCaloCluster(iclus);
-//
-//        if( GetCaloUtils()->ClusterContainsBadChannel("EMCAL",clus->GetCellsAbsId(), clus->GetNCells())) 
-//          continue;
-//        if(!GetCaloUtils()->CheckCellFiducialRegion(clus, fInputEvent->GetEMCALCells(), fInputEvent, vindex)) 
-//          continue;
-//        
-//        TLorentzVector momentum ;
-//        clus->GetMomentum(momentum, fVertex[vindex]);      
-//        if(fDebug > 3 && momentum.E() > 0.1) 
-//          printf("AliCaloTrackESDReader::FillInputEMCAL() - all clusters E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f\n",
-//                                                    momentum.E(),momentum.Pt(),momentum.Phi()*TMath::RadToDeg(),momentum.Eta()); 
-//        if(fEMCALPtMin < momentum.Pt()){
-//          
-//          if(fCheckFidCut && !fFiducialCut->IsInFiducialCut(momentum,"EMCAL")) 
-//            continue;
-//          
-//          if(fDebug > 2 && momentum.E() > 0.1) 
-//            printf("AliCaloTrackESDReader::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());
-//          
-//          clus->GetPosition(pos) ;
-//          Int_t id = clus->GetID();
-//
-//          Int_t nLabel  = clus->GetNLabels();
-//          Int_t *labels = clus->GetLabels();
-//          
-//          Float_t energy = clus->E();
-//          Char_t ttype= AliAODCluster::kEMCALClusterv1;
-//          
-//            //Recalibrate the cluster energy 
-//          if(GetCaloUtils()->IsRecalibrationOn())    
-//            energy = GetCaloUtils()->RecalibrateClusterEnergy(clus, GetEMCALCells());
-//          
-//          
-//            //Put new aod object in file in AOD calo clusters array
-//          AliAODCaloCluster *caloCluster = new((*(fOutputEvent->GetCaloClusters()))[naod++]) 
-//          AliAODCaloCluster(id,nLabel,labels,energy, pos, NULL,ttype,0);
-//          
-//            //       printf("Reader PID ESD: ph %0.2f, pi0 %0.2f, el %0.2f, conv el %0.2f,pi %0.2f, k %0.2f, p %0.2f, k0 %0.2f, n %0.2f, mu %0.2f \n",
-//            //            pid[AliPID::kPhoton],pid[AliPID::kPi0],pid[AliPID::kElectron],pid[AliPID::kEleCon],pid[AliPID::kPion],
-//            //            pid[AliPID::kKaon],pid[AliPID::kProton], pid[AliPID::kKaon0],pid[AliPID::kNeutron], pid[AliPID::kMuon]);
-//          caloCluster->SetPIDFromESD(clus->GetPID());
-//          caloCluster->SetCaloCluster(clus->GetDistanceToBadChannel(), clus->GetDispersion(), 
-//                                      clus->GetM20(), clus->GetM02(),   
-//                                      clus->GetEmcCpvDistance(),  clus->GetNExMax(), clus->GetTOF()) ;
-//          
-//          
-//          if(fDebug > 3 && momentum.E() > 0.1)
-//            printf("AliCaloTrackESDReader::FillInputEMCAL() - Selected clusters Distance BC %2.2f, dispersion %2.2f, M20 %f, M02 %3.2f, NexMax %d, TOF %e\n",
-//                   clus->GetDistanceToBadChannel(), clus->GetDispersion(),clus->GetM20(), clus->GetM02(),
-//                   clus->GetNExMax(), clus->GetTOF());
-//          
-//          caloCluster->SetNCells(clus->GetNCells());
-//          caloCluster->SetCellsAbsId(clus->GetCellsAbsId());
-//          caloCluster->SetCellsAmplitudeFraction(clus->GetCellsAmplitudeFraction());
-//          
-//          TArrayI* matchedT =        clus->GetTracksMatched();
-//          if (nTracks > 0 && matchedT && clus->GetTrackMatchedIndex() >= 0) {        
-//            for (Int_t im = 0; im < matchedT->GetSize(); im++) {
-//              Int_t iESDtrack = matchedT->At(im);
-//              if(iESDtrack < nTracks && iESDtrack > -1)
-//                caloCluster->AddTrackMatched((fInputEvent->GetTrack(iESDtrack)));
-//            }
-//          }
-//            //Fill reference array
-//        }//Pt and Fiducial cut passed.
-//      }//EMCAL cluster
-//    }//cluster exists
-//  }//esd cluster loop
-//  
-//    //Put references to selected clusters in array
-//  for(Int_t iclus = 0; iclus < (fOutputEvent->GetCaloClusters())->GetEntriesFast(); iclus++){
-//    AliAODCaloCluster * clus =  (AliAODCaloCluster*) (fOutputEvent->GetCaloClusters())->At(iclus);   
-//    if (fMixedEvent) {
-//      clus->SetID(iclus) ;   
-//    }      
-//    fAODEMCAL->Add(clus);                            
-//  }
-//  if(fDebug > 1) printf("AliCaloTrackESDReader::FillInputEMCAL() - aod entries %d\n", fAODEMCAL->GetEntriesFast());
-//  
-//}
-//
-//  //____________________________________________________________________________
-//void AliCaloTrackESDReader::FillInputPHOS() {
-//  //Return array with PHOS clusters in aod format
-//  if(fDebug > 2 ) printf("AliCaloTrackESDReader::FillInputPHOS()\n");
-//
-//  Int_t nPHOS = (fOutputEvent->GetCaloClusters())->GetEntriesFast();  
-//  Float_t pos[3] ;
-//  Int_t naod      = (fOutputEvent->GetCaloClusters())->GetEntriesFast();
-//  Int_t nTracks   = fInputEvent->GetNumberOfTracks() ;
-//
-//    //Loop to select clusters in fiducial cut and fill container with aodClusters
-//  for (Int_t iclus = 0; iclus < fInputEvent->GetNumberOfCaloClusters(); iclus++) {
-//    AliESDCaloCluster * clus = 0;
-//    if ( (clus = (AliESDCaloCluster *)fInputEvent->GetCaloCluster(iclus)) ) {
-//      if (clus->IsPHOS()){        
-//          //Check if the cluster contains any bad channel and if close to calorimeter borders
-//        Int_t vindex = 0 ;  
-//        if (fMixedEvent) 
-//          vindex = fMixedEvent->EventIndexForCaloCluster(iclus);
-//        if( GetCaloUtils()->ClusterContainsBadChannel("PHOS",clus->GetCellsAbsId(), clus->GetNCells())) 
-//          continue;
-//        if(!GetCaloUtils()->CheckCellFiducialRegion(clus, (AliESDCaloCells*)fInputEvent->GetPHOSCells(), fInputEvent, vindex)) 
-//          continue;
-//        
-//        TLorentzVector momentum ;
-//        clus->GetMomentum(momentum, fVertex[vindex]);      
-//        if(fDebug > 3 && momentum.E() > 0.1)
-//          printf("AliCaloTrackESDReader::FillInputPHOS() - all clusters E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f\n",
-//                                                   momentum.E(),momentum.Pt(),momentum.Phi()*TMath::RadToDeg(),momentum.Eta());
-//        if(fPHOSPtMin < momentum.Pt()){
-//          
-//          if(fCheckFidCut && !fFiducialCut->IsInFiducialCut(momentum,"PHOS")) 
-//            continue;
-//          
-//          if(fDebug > 2 && momentum.E() > 0.1)
-//            printf("AliCaloTrackESDReader::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());
-//          
-//          clus->GetPosition(pos) ;
-//          Int_t id = clus->GetID();
-//          Int_t nLabel  = clus->GetNLabels();
-//          Int_t *labels = clus->GetLabels();
-//          Float_t energy = clus->E();
-//          
-//            //Phos cluster type
-//          const Double_t * pid = clus->GetPID();
-//            // printf("Reader PID ESD: ph %0.2f, pi0 %0.2f, el %0.2f, conv el %0.2f,pi %0.2f, k %0.2f, p %0.2f, k0 %0.2f, n %0.2f, mu %0.2f \n",
-//            //        pid[AliPID::kPhoton],pid[AliPID::kPi0],pid[AliPID::kElectron],pid[AliPID::kEleCon],pid[AliPID::kPion],
-//            //        pid[AliPID::kKaon],pid[AliPID::kProton], pid[AliPID::kKaon0],pid[AliPID::kNeutron], pid[AliPID::kMuon]);
-//          Char_t ttype= AliAODCluster::kPHOSNeutral;
-//          Float_t wNeutral = pid[AliPID::kNeutron]+ pid[AliPID::kKaon0]+pid[AliPID::kPhoton]+pid[AliPID::kPi0];
-//          Float_t wCharged = pid[AliPID::kMuon] + pid[AliPID::kElectron] + pid[AliPID::kEleCon]+ 
-//          pid[AliPID::kProton]+pid[AliPID::kKaon]+pid[AliPID::kPion];
-//          if( wCharged > wNeutral)  ttype= AliAODCluster::kPHOSCharged;
-//          
-//            //Recalibrate the cluster energy 
-//          if(GetCaloUtils()->IsRecalibrationOn()) 
-//            energy = GetCaloUtils()->RecalibrateClusterEnergy(clus, GetPHOSCells());
-//          
-//            //Put new aod object in file in AOD calo clusters array
-//          AliAODCaloCluster *caloCluster = new((*(fOutputEvent->GetCaloClusters()))[naod++]) 
-//          AliAODCaloCluster(id,nLabel,labels,energy, pos, NULL, ttype, 0);
-//          
-//          
-//          caloCluster->SetPIDFromESD(pid);   
-//          caloCluster->SetCaloCluster(clus->GetDistanceToBadChannel(), clus->GetDispersion(), 
-//                                      clus->GetM20(), clus->GetM02(),  
-//                                      clus->GetEmcCpvDistance(),  clus->GetNExMax()) ;
-//          
-//          if(fDebug > 3 && momentum.E() > 0.2)
-//            printf("AliCaloTrackESDReader::FillInputPHOS() - Selected clusters Distance BC %2.2f, dispersion %2.2f, M20 %f, M02 %3.2f, EmcCpvDist %3.3f,  NexMax %d, TOF %e\n",
-//                   clus->GetDistanceToBadChannel(), clus->GetDispersion(),clus->GetM20(), clus->GetM02(),
-//                   clus->GetEmcCpvDistance(),  clus->GetNExMax(), clus->GetTOF());
-//          
-//          caloCluster->SetNCells(clus->GetNCells());
-//          caloCluster->SetCellsAbsId(clus->GetCellsAbsId());
-//          caloCluster->SetCellsAmplitudeFraction(clus->GetCellsAmplitudeFraction());
-//          
-//          TArrayI* matchedT =        clus->GetTracksMatched();
-//          if (nTracks > 0 && matchedT && clus->GetTrackMatchedIndex() >= 0) {        
-//            for (Int_t im = 0; im < matchedT->GetSize(); im++) {
-//              Int_t iESDtrack = matchedT->At(im);
-//              if(iESDtrack < nTracks && iESDtrack > -1)
-//                caloCluster->AddTrackMatched((fInputEvent->GetTrack(iESDtrack)));
-//            }
-//          }
-//        }//Pt and Fiducial cut passed.
-//      }//PHOS cluster
-//    }//cluster exists
-//  }//esd cluster loop
-//  
-//    //Put references to selected clusters in array
-//  
-//  for(Int_t iclus = nPHOS; iclus < (fOutputEvent->GetCaloClusters())->GetEntriesFast(); iclus++){
-//    AliAODCaloCluster * clus =  (AliAODCaloCluster*) (fOutputEvent->GetCaloClusters())->At(iclus);   
-//    if (fMixedEvent) {
-//      clus->SetID(iclus) ; 
-//    }                    
-//    fAODPHOS->Add(clus);                             
-//  }
-//  if(fDebug > 1) printf("AliCaloTrackESDReader::FillInputPHOS() - aod entries %d\n", fAODPHOS->GetEntriesFast());
-//  
-//}
-//
-//  //____________________________________________________________________________
-//void AliCaloTrackESDReader::FillInputEMCALCells() {
-//  //Return array with EMCAL cells in esd format
-//  
-//  fEMCALCells = fInputEvent->GetEMCALCells(); 
-//  
-//}
-//
-////____________________________________________________________________________
-//void AliCaloTrackESDReader::FillInputPHOSCells() {
-//  //Return array with PHOS cells in esd format
-//  
-//  fPHOSCells = fInputEvent->GetPHOSCells(); 
-//  
-//}
-//
-
-//____________________________________________________________________________
-//void AliCaloTrackESDReader::GetVertex(Double_t  v[3]) const {
-//  //Return vertex position
-//  
-//  //((AliESDEvent*)fInputEvent)->GetVertex()->GetXYZ(v) ;//SPD
-//  fInputEvent->GetPrimaryVertex()->GetXYZ(v);
-//     
-//}
 
+}
 
 //____________________________________________________________________________
 Double_t AliCaloTrackESDReader::GetBField() const {
index c903e630cc835a24d05e207116c05a71962d5eb3..9c08307e6a3f30f5edc8122789277fa1226b4df6 100755 (executable)
@@ -8,11 +8,8 @@
 // Class for reading data (ESDs) in order to do prompt gamma 
 //  or other particle identification and correlations
 // 
-// It is a filtering class, transforms ESD tracks or CaloClusters
-// into AOD tracks and calocluters, which are the basic input of the analysis
-// classes in this frame.
-// It is recommended to use the official filter AliAnalysisTaskESDfilter, and 
-// then the reader for AODs AliCaloTrackAODReader.//
+//
+//
 //
 //*-- Author: Gustavo Conesa (INFN-LNF)
 
@@ -30,14 +27,7 @@ class AliCaloTrackESDReader : public AliCaloTrackReader {
   //AliCaloTrackESDReader(const AliCaloTrackESDReader & g) ; // cpy ctor
   //AliCaloTrackESDReader & operator = (const AliCaloTrackESDReader & g) ;//cpy assignment
   virtual ~AliCaloTrackESDReader() {;} //virtual dtor
-  
-//  void FillInputCTS  () ;
-//  void FillInputEMCAL() ;
-//  void FillInputPHOS () ;  
-//  void FillInputEMCALCells() ;
-//  void FillInputPHOSCells() ;
-  
-//  void GetVertex(Double_t v[3]) const ;
+
   Double_t GetBField() const;
   void SetInputOutputMCEvent(AliVEvent* esd, AliAODEvent* aod, AliMCEvent* mc) ; 
        
index 7a210d677e0cae665c6fd43913de65fe276e1654..184669cb7760f1333b7764fe57404710ef70b867 100755 (executable)
@@ -37,7 +37,7 @@
 #include "AliCaloTrackMCReader.h" 
 #include "AliGenEventHeader.h"
 #include "AliStack.h"
-#include "AliAODCaloCluster.h"
+#include "AliVCluster.h"
 #include "AliAODTrack.h"
 #include "AliAODEvent.h"
 #include "AliFiducialCut.h"
@@ -189,8 +189,7 @@ void  AliCaloTrackMCReader::CheckOverlap(const Float_t anglethres, const Int_t i
 }
 
 //____________________________________________________________________________
-void  AliCaloTrackMCReader::FillCalorimeters(Int_t & iParticle, TParticle* particle, TLorentzVector momentum,
-                                            Int_t &ncalo) {
+void  AliCaloTrackMCReader::FillCalorimeters(Int_t & iParticle, TParticle* particle, TLorentzVector momentum) {
   //Fill AODCaloClusters or TParticles lists of PHOS or EMCAL
   //In PHOS
   if(fFillPHOS && momentum.Pt() > fPHOSPtMin){
@@ -202,12 +201,11 @@ void  AliCaloTrackMCReader::FillCalorimeters(Int_t & iParticle, TParticle* parti
     if(fCheckOverlap) 
       CheckOverlap(fPHOSOverlapAngle,particle->GetFirstMother(),index, iParticle, momentum, pdg);
     
-    Char_t ttype= AliAODCluster::kPHOSNeutral; 
+    Char_t ttype= AliVCluster::kPHOSNeutral;   
     Int_t labels[] = {index};
     Float_t x[] = {momentum.X(), momentum.Y(), momentum.Z()};
     //Create object and write it to file
-    AliAODCaloCluster *calo = new((*(fOutputEvent->GetCaloClusters()))[ncalo++]) 
-      AliAODCaloCluster(index,1,labels,momentum.E(), x, NULL, ttype, 0);
+    AliAODCaloCluster *calo = new AliAODCaloCluster(index,1,labels,momentum.E(), x, NULL, ttype, 0);
     
     SetCaloClusterPID(pdg,calo) ;
     if(fDebug > 3 && momentum.Pt() > 0.2)
@@ -227,12 +225,11 @@ void  AliCaloTrackMCReader::FillCalorimeters(Int_t & iParticle, TParticle* parti
     if(fCheckOverlap) 
       CheckOverlap(fEMCALOverlapAngle,particle->GetFirstMother(),iParticle, index, momentum, pdg);
     
-    Char_t ttype= AliAODCluster::kEMCALClusterv1;
+    Char_t ttype= AliVCluster::kEMCALClusterv1;
     Int_t labels[] = {index};
     Float_t x[] = {momentum.X(), momentum.Y(), momentum.Z()};
     //Create object and write it to file
-    AliAODCaloCluster *calo = new((*(fOutputEvent->GetCaloClusters()))[ncalo++]) 
-      AliAODCaloCluster(iParticle,1,labels,momentum.E(), x, NULL, ttype, 0);
+    AliAODCaloCluster *calo = new AliAODCaloCluster(iParticle,1,labels,momentum.E(), x, NULL, ttype, 0);
     
     SetCaloClusterPID(pdg,calo) ;
     if(fDebug > 3 && momentum.Pt() > 0.2)
@@ -256,8 +253,6 @@ Bool_t AliCaloTrackMCReader::FillInputEvent(const Int_t iEntry, const char * cur
        
   Int_t iParticle = 0 ;
   Double_t charge = 0.;
-  Int_t ncalo  = (fOutputEvent->GetCaloClusters())->GetEntriesFast();
-  Int_t ntrack = (fOutputEvent->GetTracks())->GetEntriesFast();
        
   for (iParticle = 0 ; iParticle <  GetStack()->GetNtrack() ; iParticle++) {
     TParticle * particle = GetStack()->Particle(iParticle);
@@ -288,8 +283,7 @@ Bool_t AliCaloTrackMCReader::FillInputEvent(const Int_t iEntry, const char * cur
          x[0] = particle->Vx(); x[1] = particle->Vy(); x[2] = particle->Vz();
          p[0] = particle->Px(); p[1] = particle->Py(); p[2] = particle->Pz();
          //Create object and write it to file
-         AliAODTrack *aodTrack = new((*(fOutputEvent->GetTracks()))[ntrack++]) 
-           AliAODTrack(0, iParticle, p, kTRUE, x, kFALSE,NULL, 0, 0, 
+         AliAODTrack *aodTrack = new AliAODTrack(0, iParticle, p, kTRUE, x, kFALSE,NULL, 0, 0, 
                        NULL,
                        0x0,//primary,
                        kFALSE, // No fit performed
@@ -300,7 +294,7 @@ Bool_t AliCaloTrackMCReader::FillInputEvent(const Int_t iEntry, const char * cur
          fAODCTS->Add(aodTrack);//reference the selected object to the list
        }
        //Keep some charged particles in calorimeters lists
-       if((fFillPHOS || fFillEMCAL) && KeepChargedParticles(pdg)) FillCalorimeters(iParticle, particle, momentum, ncalo);
+       if((fFillPHOS || fFillEMCAL) && KeepChargedParticles(pdg)) FillCalorimeters(iParticle, particle, momentum);
        
       }//Charged
       
@@ -311,7 +305,7 @@ Bool_t AliCaloTrackMCReader::FillInputEvent(const Int_t iEntry, const char * cur
        if(SkipNeutralParticles(pdg)) continue ;
        //Fill particle/calocluster arrays
        if(!fDecayPi0) {
-         FillCalorimeters(iParticle, particle, momentum, ncalo);
+         FillCalorimeters(iParticle, particle, momentum);
        }
        else {
          //Sometimes pi0 are stable for the generator, if needed decay it by hand
@@ -329,11 +323,11 @@ Bool_t AliCaloTrackMCReader::FillInputEvent(const Int_t iEntry, const char * cur
              TParticle * pPhoton2 = new TParticle(22,1,iParticle,0,0,0,lvGamma2.Px(),lvGamma2.Py(),
                                                   lvGamma2.Pz(),lvGamma2.E(),0,0,0,0);
              //Fill particle/calocluster arrays
-             FillCalorimeters(iParticle,pPhoton1,lvGamma1, ncalo);
-             FillCalorimeters(iParticle,pPhoton2,lvGamma2, ncalo);
+             FillCalorimeters(iParticle,pPhoton1,lvGamma1);
+             FillCalorimeters(iParticle,pPhoton2,lvGamma2);
            }//pt cut
          }//pi0
-         else FillCalorimeters(iParticle,particle, momentum, ncalo); //Add the rest
+         else FillCalorimeters(iParticle,particle, momentum); //Add the rest
        }
       }//neutral particles
     } //particle with correct status
@@ -379,6 +373,8 @@ void AliCaloTrackMCReader::Print(const Option_t * opt) const
   if(! opt)
     return;
   
+  AliCaloTrackReader::Print(opt);
+  
   printf("**** Print **** %s %s ****\n", GetName(), GetTitle() ) ;
   
   printf("Decay Pi0?          : %d\n", fDecayPi0) ;
@@ -704,7 +700,7 @@ void AliCaloTrackMCReader::SetTrackChargeAndPID(const Int_t pdgCode, AliAODTrack
 }
 
 //____________________________________________________________________
-void AliCaloTrackMCReader::SetCaloClusterPID(const Int_t pdgCode, AliAODCaloCluster *calo) const {
+void AliCaloTrackMCReader::SetCaloClusterPID(const Int_t pdgCode, AliVCluster *calo) const {
 //Give a PID weight for CaloClusters equal to 1 depending on the particle type
 
   Float_t pid[13] = {0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.};
@@ -712,198 +708,198 @@ void AliCaloTrackMCReader::SetCaloClusterPID(const Int_t pdgCode, AliAODCaloClus
   switch (pdgCode) {
 
   case 22: // gamma
-    pid[AliAODCaloCluster::kPhoton] = 1.;
+    pid[AliVCluster::kPhoton] = 1.;
     calo->SetPID(pid);
     break;
 
   case 11: // e- 
-    pid[AliAODCaloCluster::kElectron] = 1.;
+    pid[AliVCluster::kElectron] = 1.;
     calo->SetPID(pid);
     break;
     
   case -11: // e+
-    pid[AliAODCaloCluster::kElectron] = 1.;
+    pid[AliVCluster::kElectron] = 1.;
     calo->SetPID(pid);
     break;
     
   case 13: // mu- 
-    pid[AliAODCaloCluster::kCharged] = 1.;
+    pid[AliVCluster::kCharged] = 1.;
     calo->SetPID(pid);
     break;
     
   case -13: // mu+
-    pid[AliAODCaloCluster::kCharged] = 1.;
+    pid[AliVCluster::kCharged] = 1.;
     calo->SetPID(pid);
     break;
     
   case 111: // pi0
-    pid[AliAODCaloCluster::kPi0] = 1.;
+    pid[AliVCluster::kPi0] = 1.;
     calo->SetPID(pid);
     break;
     
   case 211: // pi+
-    pid[AliAODCaloCluster::kCharged] = 1.;
+    pid[AliVCluster::kCharged] = 1.;
     calo->SetPID(pid);
     break;
     
   case -211: // pi-
-    pid[AliAODCaloCluster::kCharged] = 1.;
+    pid[AliVCluster::kCharged] = 1.;
     calo->SetPID(pid);
     break;
     
   case 130: // K0L
-    pid[AliAODCaloCluster::kKaon0] = 1.;
-    pid[AliAODCaloCluster::kNeutral] = 1;
+    pid[AliVCluster::kKaon0] = 1.;
+    pid[AliVCluster::kNeutral] = 1;
     calo->SetPID(pid);
     break;
     
   case 321: // K+
-    pid[AliAODCaloCluster::kCharged] = 1.;
+    pid[AliVCluster::kCharged] = 1.;
     calo->SetPID(pid);
     break;
     
   case -321: // K- 
-    pid[AliAODCaloCluster::kCharged] = 1.;
+    pid[AliVCluster::kCharged] = 1.;
     calo->SetPID(pid);
     break;
     
   case 2112: // n
-    pid[AliAODCaloCluster::kNeutron] = 1.;
-    pid[AliAODCaloCluster::kNeutral] = 1.;
+    pid[AliVCluster::kNeutron] = 1.;
+    pid[AliVCluster::kNeutral] = 1.;
     calo->SetPID(pid);
     break;
     
   case 2212: // p
-    pid[AliAODCaloCluster::kCharged] = 1.;
+    pid[AliVCluster::kCharged] = 1.;
     calo->SetPID(pid);
     break;
     
   case -2212: // anti-p
-    pid[AliAODCaloCluster::kCharged] = 1.;
+    pid[AliVCluster::kCharged] = 1.;
     calo->SetPID(pid);
     break;
 
   case 310: // K0S
-    pid[AliAODCaloCluster::kKaon0] = 1.;
-    pid[AliAODCaloCluster::kNeutral] = 1.;
+    pid[AliVCluster::kKaon0] = 1.;
+    pid[AliVCluster::kNeutral] = 1.;
     calo->SetPID(pid);
     break;
     
   case 311: // K0
-    pid[AliAODCaloCluster::kKaon0] = 1.;
-    pid[AliAODCaloCluster::kNeutral] = 1.;
+    pid[AliVCluster::kKaon0] = 1.;
+    pid[AliVCluster::kNeutral] = 1.;
     calo->SetPID(pid);
     break;
     
   case -311: // anti-K0
-    pid[AliAODCaloCluster::kKaon0] = 1.;
-    pid[AliAODCaloCluster::kNeutral] = 1.;
+    pid[AliVCluster::kKaon0] = 1.;
+    pid[AliVCluster::kNeutral] = 1.;
     calo->SetPID(pid);
     break;
     
   case 221: // eta
-    pid[AliAODCaloCluster::kNeutral] = 1.;
+    pid[AliVCluster::kNeutral] = 1.;
     calo->SetPID(pid);
     break;
 
   case 3122: // lambda
-    pid[AliAODCaloCluster::kUnknown] = 1.;
+    pid[AliVCluster::kUnknown] = 1.;
     calo->SetPID(pid);
     break;
 
   case 3222: // Sigma+
-    pid[AliAODCaloCluster::kUnknown] = 1.;
+    pid[AliVCluster::kUnknown] = 1.;
     calo->SetPID(pid);
     break;
 
   case 3212: // Sigma0
-    pid[AliAODCaloCluster::kUnknown] = 1.;
+    pid[AliVCluster::kUnknown] = 1.;
     calo->SetPID(pid);
     break;
 
   case 3112: // Sigma-
-    pid[AliAODCaloCluster::kUnknown] = 1.;
+    pid[AliVCluster::kUnknown] = 1.;
     calo->SetPID(pid);
     break;
 
   case 3322: // Xi0
-    pid[AliAODCaloCluster::kUnknown] = 1.;
+    pid[AliVCluster::kUnknown] = 1.;
     calo->SetPID(pid);
     break;
 
   case 3312: // Xi-
-    pid[AliAODCaloCluster::kUnknown] = 1.;
+    pid[AliVCluster::kUnknown] = 1.;
     calo->SetPID(pid);
     break;
 
   case 3334: // Omega-
-    pid[AliAODCaloCluster::kUnknown] = 1.;
+    pid[AliVCluster::kUnknown] = 1.;
     calo->SetPID(pid);
     break;
 
   case -2112: // n-bar
-    pid[AliAODCaloCluster::kNeutron] = 1.;
-    pid[AliAODCaloCluster::kNeutral] = 1.;
+    pid[AliVCluster::kNeutron] = 1.;
+    pid[AliVCluster::kNeutral] = 1.;
     calo->SetPID(pid);
     break;
 
   case -3122: // anti-Lambda
-    pid[AliAODCaloCluster::kUnknown] = 1.;
+    pid[AliVCluster::kUnknown] = 1.;
     calo->SetPID(pid);
     break;
 
   case -3222: // anti-Sigma-
-    pid[AliAODCaloCluster::kUnknown] = 1.;
+    pid[AliVCluster::kUnknown] = 1.;
     calo->SetPID(pid);
     break;
 
   case -3212: // anti-Sigma0
-    pid[AliAODCaloCluster::kUnknown] = 1.;
+    pid[AliVCluster::kUnknown] = 1.;
     calo->SetPID(pid);
     break;
 
   case -3112: // anti-Sigma+
-    pid[AliAODCaloCluster::kUnknown] = 1.;
+    pid[AliVCluster::kUnknown] = 1.;
     calo->SetPID(pid);
     break;
 
   case -3322: // anti-Xi0
-    pid[AliAODCaloCluster::kUnknown] = 1.;
+    pid[AliVCluster::kUnknown] = 1.;
     calo->SetPID(pid);
     break;
 
   case -3312: // anti-Xi+
-    pid[AliAODCaloCluster::kUnknown] = 1.;
+    pid[AliVCluster::kUnknown] = 1.;
     calo->SetPID(pid);
     break;
 
   case -3334: // anti-Omega+
-    pid[AliAODCaloCluster::kUnknown] = 1.;
+    pid[AliVCluster::kUnknown] = 1.;
     calo->SetPID(pid);
     break;
 
   case 411: // D+
-    pid[AliAODCaloCluster::kUnknown] = 1.;
+    pid[AliVCluster::kUnknown] = 1.;
     calo->SetPID(pid);
     break;
 
   case -411: // D- 
-    pid[AliAODCaloCluster::kUnknown] = 1.;
+    pid[AliVCluster::kUnknown] = 1.;
     calo->SetPID(pid);
     break;
 
   case 421: // D0
-    pid[AliAODCaloCluster::kUnknown] = 1.;
+    pid[AliVCluster::kUnknown] = 1.;
     calo->SetPID(pid);
     break;
 
   case -421: // anti-D0
-    pid[AliAODCaloCluster::kUnknown] = 1.;
+    pid[AliVCluster::kUnknown] = 1.;
     calo->SetPID(pid);
     break;
 
   default : // unknown
-    pid[AliAODCaloCluster::kUnknown] = 1.;
+    pid[AliVCluster::kUnknown] = 1.;
     calo->SetPID(pid);
  }
 
index 4a418b5c3e5670dd2474fda2b57c8834d044ac81..14964644166d0edbe7e9c1e68d5d1211e347ffbe 100755 (executable)
@@ -21,7 +21,7 @@ class TParticle ;
 
 // --- AliRoot system ---
 #include "AliCaloTrackReader.h" 
-class AliAODCaloCluster ;
+class AliVCluster ;
 class AliAODTrack ;
 class AliAODEvent ;
 class AliMCEvent  ;
@@ -69,7 +69,7 @@ public:
   AliVEvent*  GetInputEvent() const {return (AliVEvent *) GetMC();}
   void SetInputOutputMCEvent(AliVEvent* esd, AliAODEvent* aod, AliMCEvent* mc) ;
   
-  void SetCaloClusterPID(const Int_t pdgCode, AliAODCaloCluster *calo) const ;
+  void SetCaloClusterPID(const Int_t pdgCode, AliVCluster *calo) const ;
   void SetTrackChargeAndPID(const Int_t pdgCode, AliAODTrack *track) const ;
   
   void SwitchOnOverlapCheck()  {fCheckOverlap = kTRUE;}
@@ -84,8 +84,7 @@ public:
   
   void CheckOverlap(const Float_t anglethres, const Int_t imom, Int_t & iPrimary, Int_t & index, TLorentzVector & mom, Int_t & pdg);
   void MakePi0Decay(TLorentzVector &p0, TLorentzVector &p1, TLorentzVector &p2) const ;//, Double_t &angle); 
-  void FillCalorimeters(Int_t & iParticle, TParticle* particle, TLorentzVector momentum,   
-                       Int_t &naod) ;
+  void FillCalorimeters(Int_t & iParticle, TParticle* particle, TLorentzVector momentum) ;
   
   private:
   Bool_t    fDecayPi0 ;              // If not decayed, decay pi0 by hand
index 7fbc14f4a6b6348b43618c6cd8158adb859c214a..3a610c3492fcae78fe02c3efae879120facfb314 100755 (executable)
@@ -42,6 +42,7 @@
 #include "AliVTrack.h"
 #include "AliVParticle.h"
 #include "AliMixedEvent.h"
+#include "AliESDtrack.h"
 
 ClassImp(AliCaloTrackReader)
   
@@ -399,6 +400,11 @@ void AliCaloTrackReader::InitParameters()
   fFiredTriggerClassName      = "";
                
   fAnaLED = kFALSE;
+  
+  //We want tracks fitted in the detectors:
+  fTrackStatus=AliESDtrack::kTPCrefit;
+  fTrackStatus|=AliESDtrack::kITSrefit;  
+  
 }
 
 //________________________________________________________________
index 59288a3995a5a83893955316beaf73a5dffdc73c..da564d855f82c1a067c4b24b14ffe2c203d0f3b7 100755 (executable)
@@ -202,6 +202,24 @@ public:
   void SwitchOffWriteDeltaAOD() {fWriteOutputDeltaAOD = kFALSE ; }
   Bool_t WriteDeltaAODToFile() const {return fWriteOutputDeltaAOD ; } 
   
+  
+  //MC reader methods:
+  
+  virtual void AddNeutralParticlesArray(TArrayI & /*array*/)  { ; }  
+  virtual void AddChargedParticlesArray(TArrayI & /*array*/)  { ; } 
+  virtual void AddStatusArray(TArrayI & /*array*/)            { ; }
+  
+  virtual void SwitchOnPi0Decay()         { ; } 
+  virtual void SwitchOffPi0Decay()        { ; } 
+  virtual void SwitchOnStatusSelection()  { ; }
+  virtual void SwitchOffStatusSelection() { ; }
+  virtual void SwitchOnOverlapCheck()     { ; }
+  virtual void SwitchOffOverlapCheck()    { ; }
+  
+  virtual void SetEMCALOverlapAngle(Float_t /*angle*/)  { ; }
+  virtual void SetPHOSOverlapAngle(Float_t /*angle*/)   { ; }
+  
+  
  protected:
   Int_t                   fEventNumber;    // Event number
   TString          fCurrentFileName;// Current file name under analysis
index 0e57cbbedd76144901042d48e86c8de987ca74d9..6efed3e5f37a4f9be486fa9ec02bb7eb9b5a1254 100755 (executable)
@@ -34,7 +34,7 @@
 #include "AliIsolationCut.h" 
 #include "AliAODPWG4ParticleCorrelation.h"
 #include "AliAODTrack.h"
-#include "AliAODCaloCluster.h"
+#include "AliVCluster.h"
 #include "AliCaloTrackReader.h"
 
 ClassImp(AliIsolationCut)
@@ -188,7 +188,7 @@ void  AliIsolationCut::MakeIsolationCut(TObjArray * const plCTS,  TObjArray * co
        }
     TLorentzVector mom ;
     for(Int_t ipr = 0;ipr < plNe->GetEntries() ; ipr ++ ){
-      AliAODCaloCluster * calo = (AliAODCaloCluster *)(plNe->At(ipr)) ;
+      AliVCluster * calo = (AliVCluster *)(plNe->At(ipr)) ;
       
       //Do not count the candidate (photon or pi0) or the daughters of the candidate
       if(calo->GetID() == pCandidate->GetCaloLabel(0) || calo->GetID() == pCandidate->GetCaloLabel(1)) continue ;      //Skip matched clusters with tracks
index d750e9ee3a6448041c9a58dd91f7ecc08db17677..1bcfa1077068c13f71b1b1ecbfae4c059061413c 100644 (file)
@@ -35,7 +35,7 @@
 #include "AliAnaBtag.h" \r
 #include "AliCaloTrackReader.h"\r
 #include "AliMCAnalysisUtils.h"\r
-#include "AliAODCaloCluster.h"\r
+#include "AliVCluster.h"\r
 #include "AliFiducialCut.h"\r
 #include "AliAODTrack.h"\r
 #include "AliAODPid.h"\r
@@ -214,7 +214,7 @@ void  AliAnaBtag::MakeAnalysisFillAOD()
   //CLUSTER STUFF\r
   if(1){\r
     for(Int_t iclus = 0; iclus < ntot; iclus++) {\r
-      AliAODCaloCluster * clus = (AliAODCaloCluster*) (cl->At(iclus));\r
+      AliVCluster * clus = (AliVCluster*) (cl->At(iclus));\r
       if(!clus) continue;\r
       fhClusterEnergy->Fill(clus->E());\r
     }\r
@@ -281,7 +281,7 @@ void  AliAnaBtag::MakeAnalysisFillAOD()
         Double_t minPt   = -1;\r
 \r
        for(Int_t iclus = 0; iclus < ntot; iclus++) {\r
-         AliAODCaloCluster * clus = (AliAODCaloCluster*) (cl->At(iclus));\r
+         AliVCluster * clus = (AliVCluster*) (cl->At(iclus));\r
          if(!clus) continue;\r
 \r
          //As of 11-Oct-2009\r
@@ -418,89 +418,89 @@ void  AliAnaBtag::MakeAnalysisFillAOD()
 void  AliAnaBtag::MakeAnalysisFillHistograms() \r
 {\r
   //Do analysis and fill histograms\r
-\r
+  \r
   AliStack * stack = 0x0;\r
-//   TParticle * primary = 0x0;\r
-\r
-\r
-\r
-\r
+  //   TParticle * primary = 0x0;\r
+  \r
+  \r
+  \r
+  \r
   if(IsDataMC()) {\r
     if(GetReader()->ReadStack()){\r
       stack =  GetMCStack() ;      \r
       if(!stack)\r
-       printf("AliAnaBtag::MakeAnalysisFillHistograms() *** no stack ***: \n");\r
+        printf("AliAnaBtag::MakeAnalysisFillHistograms() *** no stack ***: \n");\r
       \r
     }\r
   }// is data and MC\r
-\r
+  \r
   ////////////////////////////////////\r
   //Loop over jets and check for b-tag\r
   ////////////////////////////////////\r
   double maxjetEta=-4.;\r
   double maxjetPhi=-4.;\r
-\r
-  Int_t njets = (GetReader()->GetOutputEvent())->GetNJets();\r
+  \r
+  Int_t njets = 0; \r
+  if(GetReader()->GetOutputEvent()) njets = (GetReader()->GetOutputEvent())->GetNJets();\r
   if(njets > 0) {\r
     if(GetDebug() > 0) printf("AliAnaBtag::MakeAnalysisFillHistograms() - Jet AOD branch has %d jets.  Performing b-jet tag analysis\n",njets);\r
-\r
+    \r
     for(Int_t ijet = 0; ijet < njets ; ijet++) {\r
       AliAODJet * jet = (AliAODJet*)(GetReader()->GetOutputEvent())->GetJet(ijet) ;\r
-\r
+      \r
       if(ijet==0){\r
         maxjetEta=jet->Eta();\r
         maxjetPhi=jet->Phi();\r
       }\r
-\r
+      \r
       fhJets->Fill(jet->Pt(),1);\r
       fhJetsAllEtaPhi->Fill(jet->Eta(),jet->Phi());\r
-\r
+      \r
       if(jet->Pt() < 0.) continue; //This has to be adjusted depending on pp or AA!\r
       fhJets->Fill(jet->Pt(),3); //All jets after pt cut\r
-\r
+      \r
       //Geometric EMCAL cut\r
       if(TMath::Abs(jet->Eta()) > fJetEtaCut) continue;\r
       if(jet->Phi() < fJetPhiMin || jet->Phi() > fJetPhiMax) continue;\r
       fhJets->Fill(jet->Pt(),4); //All jets after geometric cut\r
-\r
+      \r
       Bool_t leadJet  = kFALSE;\r
       if (ijet==0){ \r
-       fhJets->Fill(jet->Pt(),5); //Leading jets\r
-       leadJet= kTRUE;\r
+        fhJets->Fill(jet->Pt(),5); //Leading jets\r
+        leadJet= kTRUE;\r
       }\r
-\r
-\r
+      \r
+      \r
       Bool_t dvmJet = kFALSE;  \r
       TRefArray* rt = jet->GetRefTracks();\r
       Int_t ntrk = rt->GetEntries();\r
-\r
+      \r
       for(Int_t itrk = 0; itrk < ntrk; itrk++) {\r
        AliAODTrack* jetTrack = (AliAODTrack*)jet->GetTrack(itrk);\r
-       Bool_t isDVM = CheckIfBjet(jetTrack);\r
-       if(isDVM) dvmJet = kTRUE;\r
+        Bool_t isDVM = CheckIfBjet(jetTrack);\r
+        if(isDVM) dvmJet = kTRUE;\r
       }\r
-\r
+      \r
       if(dvmJet)\r
-       fhJets->Fill(jet->Pt(),6);\r
-\r
-\r
-\r
+        fhJets->Fill(jet->Pt(),6);\r
+      \r
+      \r
       if(IsDataMC()) {\r
-       //determine tagging efficiency & mis-tagging rate\r
-       //using b-quarks from stack\r
-       Bool_t isTrueBjet = IsMcBJet(jet->Eta(), jet->Phi());\r
-       Bool_t isTrueDjet = IsMcDJet(jet->Eta(), jet->Phi());\r
-       if (isTrueBjet && GetDebug() > 0) printf("== True Bjet==\n");\r
-       if (isTrueDjet && GetDebug() > 0) printf("== True Charm-jet==\n");\r
-       if (dvmJet && GetDebug() > 0)     printf("== found DVM jet==\n");\r
+        //determine tagging efficiency & mis-tagging rate\r
+        //using b-quarks from stack\r
+        Bool_t isTrueBjet = IsMcBJet(jet->Eta(), jet->Phi());\r
+        Bool_t isTrueDjet = IsMcDJet(jet->Eta(), jet->Phi());\r
+        if (isTrueBjet && GetDebug() > 0) printf("== True Bjet==\n");\r
+        if (isTrueDjet && GetDebug() > 0) printf("== True Charm-jet==\n");\r
+        if (dvmJet && GetDebug() > 0)     printf("== found DVM jet==\n");\r
       }\r
-\r
+      \r
     } //jet loop\r
   } //jets exist\r
   \r
-\r
-\r
-\r
+  \r
+  \r
+  \r
   //Electron loop, read back electrons, fill histos\r
   Int_t naod = GetOutputAODBranch()->GetEntriesFast();\r
   if(GetDebug() > 0) printf("AliAnaBtag::MakeAnalysisFillHistograms() - aod branch entries %d\n", naod);\r
@@ -508,25 +508,25 @@ void  AliAnaBtag::MakeAnalysisFillHistograms()
   for(Int_t iaod = 0; iaod < naod ; iaod++){\r
     AliAODPWG4Particle* ele =  (AliAODPWG4Particle*) (GetOutputAODBranch()->At(iaod));\r
     Int_t pdg = ele->GetPdg();\r
-\r
-\r
+    \r
+    \r
     if(TMath::Abs(pdg) != AliCaloPID::kElectron) continue; //not necessary..\r
-\r
+    \r
     //MC tag of this electron\r
     //    Int_t mctag = ele->GetTag();\r
-\r
-\r
+    \r
+    \r
     fhElectrons->Fill(ele->Pt(),1); //All electrons\r
     Bool_t photonic = kFALSE;\r
     photonic = PhotonicV0(ele->GetTrackLabel(0)); //check against V0s\r
     if(!photonic) fhElectrons->Fill(ele->Pt(),3); //nonphotonic electrons\r
     if(photonic) fhElectrons->Fill(ele->Pt(),4);  //photonic electrons\r
-\r
+    \r
     //Fill electron histograms \r
     Float_t phiele = ele->Phi();\r
     Float_t etaele = ele->Eta();\r
-\r
-\r
+    \r
+    \r
     if(ele->GetBtag()>0){ // removed bit tag shit\r
       fhElectrons->Fill(ele->Pt(),5);\r
       if(!photonic) fhElectrons->Fill(ele->Pt(),6);\r
@@ -541,7 +541,7 @@ void  AliAnaBtag::MakeAnalysisFillHistograms()
     }\r
     \r
   }//electron aod loop\r
-\r
+  \r
 }\r
 \r
 //__________________________________________________________________\r
index ad4cfacf701ae174db023eb7a8a763c6982be121..d0ad62b2408d5a64bbad28a46b9ba6e661cbf51b 100755 (executable)
@@ -36,7 +36,7 @@
 #include "AliAnaElectron.h" \r
 #include "AliCaloTrackReader.h"\r
 #include "AliMCAnalysisUtils.h"\r
-#include "AliAODCaloCluster.h"\r
+#include "AliVCluster.h"\r
 #include "AliFiducialCut.h"\r
 #include "AliAODTrack.h"\r
 #include "AliAODPid.h"\r
@@ -783,7 +783,7 @@ void  AliAnaElectron::MakeAnalysisFillAOD()
         Double_t minPt   = -1;\r
 \r
        for(Int_t iclus = 0; iclus < ntot; iclus++) {\r
-         AliAODCaloCluster * clus = (AliAODCaloCluster*) (cl->At(iclus));\r
+         AliVCluster * clus = (AliVCluster*) (cl->At(iclus));\r
          if(!clus) continue;\r
 \r
          //As of 11-Oct-2009\r
index 9229707c714022aff70a8b2b77d54b133d9fd5ea..8336a624938cf47c018a2845166e7dc07fb4a93e 100755 (executable)
@@ -157,7 +157,7 @@ void  AliAnaExample::MakeAnalysisFillAOD()
   
   if(!partList || partList->GetEntriesFast() == 0) return ;
   
-  //Fill AODCaloClusters and AODParticle with PHOS/EMCAL aods
+  //Fill AODParticle with PHOS/EMCAL aods
   if(fDetector == "EMCAL" || fDetector == "PHOS"){
     
     //Get vertex for photon momentum calculation
@@ -223,7 +223,6 @@ void  AliAnaExample::MakeAnalysisFillAOD()
   
   if(GetDebug() > 0) {
     if(fDetector!="CTS" && GetReader()->GetDataType()!= AliCaloTrackReader::kMC) 
-      //printf("Example: final aod calocluster entries %d\n", GetAODCaloClusters()->GetEntriesFast());
       printf("AliAnaExample::MakeAnalysisFillAOD() - Final aod branch entries %d\n", GetOutputAODBranch()->GetEntriesFast());  
     // if(fDetector!="CTS" && GetReader()->GetDataType()!= AliCaloTrackReader::kMC) 
     //printf("Example: final aod cell  entries %d\n", GetAODCaloCells()->GetNumberOfCells());
index e7d2d041a51b4ae4ba892cb50f00e86f9988c18a..5cca75028b379ee5a448b2561f0690eec960e9fb 100755 (executable)
@@ -40,7 +40,7 @@
 #include "AliAODPWG4ParticleCorrelation.h"
 #include "AliFiducialCut.h"
 #include "AliAODTrack.h"
-#include "AliAODCaloCluster.h"
+#include "AliVCluster.h"
 #include "AliMCAnalysisUtils.h"
 #include "TParticle.h"
 #include "AliStack.h"
@@ -817,7 +817,7 @@ void  AliAnaParticleHadronCorrelation::MakeNeutralCorrelationFillAOD(AliAODPWG4P
     //Int_t iEvent= GetReader()->GetEventNumber() ;
   Int_t nclus = pl->GetEntriesFast();
   for(Int_t iclus = 0;iclus < nclus ; iclus ++ ){
-    AliAODCaloCluster * calo = (AliAODCaloCluster *) (pl->At(iclus)) ;
+    AliVCluster * calo = (AliVCluster *) (pl->At(iclus)) ;
     
     Int_t evtIndex1 = 0 ; 
     if (GetMixedEvent()) {
@@ -879,7 +879,7 @@ void  AliAnaParticleHadronCorrelation::MakeNeutralCorrelationFillAOD(AliAODPWG4P
         //Search the photon companion in case it comes from  a Pi0 decay
         //Apply several cuts to select the good pair;
       for(Int_t jclus = iclus+1; jclus < pl->GetEntries() ; jclus ++ ){
-        AliAODCaloCluster * calo2 = (AliAODCaloCluster *) (pl->At(jclus)) ;
+        AliVCluster * calo2 = (AliVCluster *) (pl->At(jclus)) ;
         Int_t evtIndex2 = 0 ; 
         if (GetMixedEvent()) {
           evtIndex2=GetMixedEvent()->EventIndexForCaloCluster(calo->GetID()) ; 
@@ -1072,7 +1072,7 @@ void  AliAnaParticleHadronCorrelation::MakeNeutralCorrelationFillHistograms(AliA
 
 
 //____________________________________________________________________________
-Bool_t  AliAnaParticleHadronCorrelation::SelectCluster(AliAODCaloCluster * calo, Double_t *vertex, TLorentzVector & mom, Int_t & pdg) {
+Bool_t  AliAnaParticleHadronCorrelation::SelectCluster(AliVCluster * calo, Double_t *vertex, TLorentzVector & mom, Int_t & pdg) {
   //Select cluster depending on its pid and acceptance selections
   
   //Skip matched clusters with tracks
index 02645dc136ecb846c8da4139733634bfae552724..941a9a62bf03da857611b66e20f056b324f1df03 100755 (executable)
@@ -61,7 +61,7 @@ class AliAnaParticleHadronCorrelation : public AliAnaPartCorrBaseClass {
   void MakeAnalysisFillAOD()  ;
   void MakeAnalysisFillHistograms() ; 
   
-  Bool_t SelectCluster(AliAODCaloCluster * calo, Double_t *vertex, TLorentzVector & mom, Int_t & pdg) ;
+  Bool_t SelectCluster(AliVCluster * calo, Double_t *vertex, TLorentzVector & mom, Int_t & pdg) ;
   
  private:
   
index a065f62f3373f8fdf79fa178eb486667e9b9541b..adce75d7f624bd2c20b540c7686b03c218698ae9 100755 (executable)
@@ -41,7 +41,7 @@
 #include "AliAODPWG4ParticleCorrelation.h"
 #include "AliMCAnalysisUtils.h"
 #include "AliAODTrack.h"
-#include "AliAODCaloCluster.h"
+#include "AliVCluster.h"
 
 ClassImp(AliAnaParticleIsolation)
   
@@ -796,7 +796,7 @@ void  AliAnaParticleIsolation::MakeAnalysisFillHistograms()
     if(refclusters){    
       TLorentzVector mom ;
       for(Int_t icalo=0; icalo < refclusters->GetEntriesFast(); icalo++){
-        AliAODCaloCluster* calo = (AliAODCaloCluster *) refclusters->At(icalo);
+        AliVCluster* calo = (AliVCluster *) refclusters->At(icalo);
         Int_t input = 0;
         //                     if     (fCalorimeter == "EMCAL" && GetReader()->GetAODEMCALNormalInputEntries() <= icalo) input = 1 ;
         //                     else if(fCalorimeter == "PHOS"  && GetReader()->GetAODPHOSNormalInputEntries()  <= icalo) input = 1;
index a969f359707fee3c71440cf893e8e07254bcf463..4c8d64e0e7a9bc88508887c4e9a1ef995b4c8a9d 100755 (executable)
@@ -36,7 +36,7 @@
 
 //---- Analysis system ----
 #include "AliAODTrack.h"
-#include "AliAODCaloCluster.h"
+#include "AliVCluster.h"
 #include "AliCaloTrackReader.h"
 #include "AliNeutralMesonSelection.h"
 #include "AliAnaParticleJetLeadingConeCorrelation.h"  
@@ -44,7 +44,6 @@
 #include "AliAODPWG4ParticleCorrelation.h"
 #include "AliFiducialCut.h"
 #include "AliAODTrack.h"
-#include "AliAODCaloCluster.h"
 
 ClassImp(AliAnaParticleJetLeadingConeCorrelation)
 
@@ -953,7 +952,7 @@ void  AliAnaParticleJetLeadingConeCorrelation::GetLeadingPi0(AliAODPWG4ParticleC
          
     //Cluster loop, select pairs with good pt, phi and fill AODs or histograms
     for(Int_t iclus = 0;iclus < GetAODEMCAL()->GetEntriesFast() ; iclus ++ ){
-      AliAODCaloCluster * calo = (AliAODCaloCluster *)(GetAODEMCAL()->At(iclus)) ;
+      AliVCluster * calo = (AliVCluster *)(GetAODEMCAL()->At(iclus)) ;
       
          //Input from second AOD?
          Int_t inputi = 0;
@@ -993,7 +992,7 @@ void  AliAnaParticleJetLeadingConeCorrelation::GetLeadingPi0(AliAODPWG4ParticleC
        //Search the photon companion in case it comes from  a Pi0 decay
        //Apply several cuts to select the good pair
        for(Int_t jclus = iclus+1; jclus < GetAODEMCAL()->GetEntriesFast() ; jclus ++ ){
-         AliAODCaloCluster * calo2 = (AliAODCaloCluster *) (GetAODEMCAL()->At(jclus)) ;
+         AliVCluster * calo2 = (AliVCluster *) (GetAODEMCAL()->At(jclus)) ;
          
          //Input from second AOD?
          Int_t inputj = 0;
@@ -1502,7 +1501,7 @@ void AliAnaParticleJetLeadingConeCorrelation::MakeAODJet(AliAODPWG4ParticleCorre
        }
          
     for(Int_t iclus = 0;iclus < (GetAODEMCAL())->GetEntriesFast() ; iclus ++ ){
-      AliAODCaloCluster * calo = (AliAODCaloCluster *) (GetAODEMCAL()->At(iclus)) ;
+      AliVCluster * calo = (AliVCluster *) (GetAODEMCAL()->At(iclus)) ;
       
       //Cluster selection, not charged
       if(IsTrackMatched(calo)) continue ;
@@ -1622,7 +1621,7 @@ void AliAnaParticleJetLeadingConeCorrelation::MakeJetFromAOD(AliAODPWG4ParticleC
     //Loop on jet particles
     if(refclusters){
       for(Int_t iclus = 0;iclus < refclusters->GetEntriesFast() ; iclus ++ ){
-                 AliAODCaloCluster * calo = (AliAODCaloCluster *) refclusters->At(iclus) ;
+                 AliVCluster * calo = (AliVCluster *) refclusters->At(iclus) ;
                  
                  //Input from second AOD?
                  Int_t input = 0;
@@ -1640,7 +1639,7 @@ void AliAnaParticleJetLeadingConeCorrelation::MakeJetFromAOD(AliAODPWG4ParticleC
     //Loop on background particles
     if(refclustersbkg){
       for(Int_t iclus = 0;iclus < refclustersbkg->GetEntriesFast() ; iclus ++ ){
-                 AliAODCaloCluster * calo = (AliAODCaloCluster *) refclustersbkg->At(iclus) ;
+                 AliVCluster * calo = (AliVCluster *) refclustersbkg->At(iclus) ;
 
                  //Input from second AOD?
                  Int_t input = 0;
@@ -1668,7 +1667,7 @@ void AliAnaParticleJetLeadingConeCorrelation::MakeJetFromAOD(AliAODPWG4ParticleC
 }
 
 //____________________________________________________________________________
-Bool_t  AliAnaParticleJetLeadingConeCorrelation::SelectCluster(AliAODCaloCluster * calo, Double_t *vertex, TLorentzVector & mom, Int_t & pdg) {
+Bool_t  AliAnaParticleJetLeadingConeCorrelation::SelectCluster(AliVCluster * calo, Double_t *vertex, TLorentzVector & mom, Int_t & pdg) {
   //Select cluster depending on its pid and acceptance selections
   
   //Skip matched clusters with tracks
index aa113e9519ec3940a64d1881a144616a869bb821..583664c63666c5cf3b6601a4ceb623b21141ef8c 100755 (executable)
@@ -21,7 +21,7 @@ class TH2F;
 
 //---- Analysis system ----
 class AliAODTrack;
-class AliAODCaloCluster;
+class AliVCluster;
 class AliCaloTrackReader;
 class AliNeutralMesonSelection;
 
@@ -125,7 +125,7 @@ public:
   void MakeJetFromAOD(AliAODPWG4ParticleCorrelation * particle, const TLorentzVector pLeading, 
                      TLorentzVector & jet, TLorentzVector & bkg) const ; 
   
-  Bool_t  SelectCluster(AliAODCaloCluster * calo, Double_t *vertex, TLorentzVector & mom, Int_t & pdg) ;
+  Bool_t  SelectCluster(AliVCluster * calo, Double_t *vertex, TLorentzVector & mom, Int_t & pdg) ;
   
  private:
   
index a965348c253e63a557bc5ba9fb66ac97c7f3c5dd..baee29296a0b8785a648d6f1a25b1b6833a92a8a 100755 (executable)
@@ -38,7 +38,7 @@
 #include "AliCaloPID.h"
 #include "AliMCAnalysisUtils.h"
 #include "AliFiducialCut.h"
-#include "AliAODCaloCluster.h"
+#include "AliVCluster.h"
 #include "AliAODMCParticle.h"
 #include "AliMixedEvent.h"
 
@@ -49,12 +49,12 @@ ClassImp(AliAnaPhoton)
   AliAnaPhoton::AliAnaPhoton() : 
     AliAnaPartCorrBaseClass(), fCalorimeter(""), 
     fMinDist(0.),fMinDist2(0.),fMinDist3(0.),fRejectTrackMatch(0),
-       fCheckConversion(kFALSE),fAddConvertedPairsToAOD(kFALSE), fMassCut(0),
+    fCheckConversion(kFALSE),fAddConvertedPairsToAOD(kFALSE), fMassCut(0),
     fTimeCutMin(-1), fTimeCutMax(9999999), fNCellsCut(0),
-       fhPtPhoton(0),fhPhiPhoton(0),fhEtaPhoton(0),
+    fhPtPhoton(0),fhPhiPhoton(0),fhEtaPhoton(0),
     //MC
     fhDeltaE(0), fhDeltaPt(0),fhRatioE(0), fhRatioPt(0),fh2E(0),fh2Pt(0),
-       fhPtMCPhoton(0),fhPhiMCPhoton(0),fhEtaMCPhoton(0), 
+    fhPtMCPhoton(0),fhPhiMCPhoton(0),fhEtaMCPhoton(0), 
     fhPtPrompt(0),fhPhiPrompt(0),fhEtaPrompt(0), 
     fhPtFragmentation(0),fhPhiFragmentation(0),fhEtaFragmentation(0), 
     fhPtISR(0),fhPhiISR(0),fhEtaISR(0), 
@@ -473,18 +473,20 @@ void  AliAnaPhoton::MakeAnalysisFillAOD()
     pl = GetAODPHOS();
   else if (fCalorimeter == "EMCAL")
     pl = GetAODEMCAL();
-  
-  //Fill AODCaloClusters and AODParticle with PHOS/EMCAL aods
+
+
+  //Fill AODParticle with PHOS/EMCAL aods
   TLorentzVector mom, mom2 ;
   Int_t nCaloClusters = pl->GetEntriesFast();
+  if(GetDebug() > 0) printf("AliAnaPhoton::MakeAnalysisFillAOD() - input %s cluster entries %d\n", fCalorimeter.Data(), nCaloClusters);
   Bool_t * indexConverted = new Bool_t[nCaloClusters];
   for (Int_t i = 0; i < nCaloClusters; i++) 
     indexConverted[i] = kFALSE;
        
   for(Int_t icalo = 0; icalo < nCaloClusters; icalo++){    
          
-         AliAODCaloCluster * calo =  (AliAODCaloCluster*) (pl->At(icalo));     
-    
+         AliVCluster * calo =  (AliVCluster*) (pl->At(icalo)); 
+    //printf("calo %d, %f\n",icalo,calo->E());
     Int_t evtIndex = 0 ; 
     if (GetMixedEvent()) {
       evtIndex=GetMixedEvent()->EventIndexForCaloCluster(calo->GetID()) ; 
@@ -510,15 +512,17 @@ void  AliAnaPhoton::MakeAnalysisFillAOD()
     
     if(tof < fTimeCutMin || tof > fTimeCutMax) continue;
          
-    if(calo->GetNCells() <= fNCellsCut) continue;
+    if(calo->GetNCells() <= fNCellsCut && GetReader()->GetDataType() != AliCaloTrackReader::kMC) 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 %2.2f, pT %2.2f, Ecl %2.2f, phi %2.2f, eta %2.2f\n",GetReader()->GetEventNumber(),(GetReader()->GetCurrentFileName()).Data(), 
+      //     mom.E(), mom.Pt(),calo->E(),mom.Phi()*TMath::RadToDeg(),mom.Eta());
     
     //Check acceptance selection
     if(IsFiducialCutOn()){
       Bool_t in = GetFiducialCut()->IsInFiducialCut(mom,fCalorimeter) ;
       if(! in ) continue ;
     }
+    //printf("Fiducial cut passed \n");
     
     //Create AOD for analysis
     AliAODPWG4Particle aodph = AliAODPWG4Particle(mom);
@@ -605,7 +609,7 @@ void  AliAnaPhoton::MakeAnalysisFillAOD()
         //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);
-        AliAODCaloCluster * calo2 =  (AliAODCaloCluster*) (pl->At(jcalo));              //Get cluster kinematics
+        AliVCluster * calo2 =  (AliVCluster*) (pl->At(jcalo));              //Get cluster kinematics
         Int_t evtIndex2 = 0 ; 
         if (GetMixedEvent()) {
           evtIndex2=GetMixedEvent()->EventIndexForCaloCluster(calo2->GetID()) ; 
index e2c71cc07d295398d94c4e0f4199370e6bcb35bd..19d88f4b62a4b7bd1e6c16a40a0c6175c2f30bd5 100755 (executable)
@@ -21,8 +21,6 @@ class TObjString;
 
 // --- ANALYSIS system ---
 #include "AliAnaPartCorrBaseClass.h"
-//#include "AliStack.h"
-//#include "TParticle.h"
 class AliStack;
 class TParticle;
 
index bbd5dcf2550e92a5d2ed24abb4a3a43339f0c8db..ec3a93c3628f0844e56c6283de35f14b2bc9e131 100755 (executable)
@@ -41,7 +41,6 @@
 #include "AliStack.h"
 #include "AliFiducialCut.h"
 #include "TParticle.h"
-#include "AliAODCaloCluster.h"
 #include "AliVEvent.h"
 #include "AliESDCaloCluster.h"
 #include "AliESDEvent.h"
@@ -317,7 +316,7 @@ TList * AliAnaPi0::GetCreateOutputObjects()
        
        
   //Histograms filled only if MC data is requested     
-  if(IsDataMC() || (GetReader()->GetDataType() == AliCaloTrackReader::kMC) ){
+  if(IsDataMC()){
     // if(fhEtalon->GetXaxis()->GetXbins() && fhEtalon->GetXaxis()->GetXbins()->GetSize()){ //Variable bin size
     //   fhPrimPt = new TH1D("hPrimPt","Primary pi0 pt",fhEtalon->GetXaxis()->GetNbins(),fhEtalon->GetXaxis()->GetXbins()->GetArray()) ;
     //   fhPrimAccPt = new TH1D("hPrimAccPt","Primary pi0 pt with both photons in acceptance",fhEtalon->GetXaxis()->GetNbins(),
@@ -552,6 +551,8 @@ void AliAnaPi0::MakeAnalysisFillHistograms()
   }// DoOwnMix
   
   //Acceptance
+    printf("Fill acceptance histograms? %d, %d\n", IsDataMC(), GetReader()->ReadStack());
+
   if(IsDataMC() && GetReader()->ReadStack()){  
     AliStack * stack = GetMCStack();
     if(stack && (IsDataMC() || (GetReader()->GetDataType() == AliCaloTrackReader::kMC)) ){
@@ -809,7 +810,7 @@ Int_t AliAnaPi0::GetEventIndex(AliAODPWG4Particle * part, Double_t * vert)
     GetMixedEvent()->GetVertexOfEvent(rv)->GetXYZ(vert); 
     if(vert[2] < -fZvtxCut || vert[2] > fZvtxCut)
       rv = -2 ; //Event can not be used (vertex, centrality,... cuts not fulfilled)
-  } else {
+  } else if(GetReader()->GetDataType()!=AliCaloTrackReader::kMC){
     Double_t * tempo = GetReader()->GetVertex() ;
     vert[0] = tempo[0] ; 
     vert[1] = tempo[1] ; 
@@ -818,6 +819,8 @@ Int_t AliAnaPi0::GetEventIndex(AliAODPWG4Particle * part, Double_t * vert)
       rv = -1 ; //Event can not be used (vertex, centrality,... cuts not fulfilled)
     else 
       rv = 0 ;
-  }
+  }//No MC reader
+  else rv = 0;
+  
   return rv ; 
 }
index e093d3f4d96ae73696d5cbbd4cdcd497ee31726f..c88ac03d30e5ee8ba062f0e1e5841099a04de46e 100755 (executable)
@@ -42,7 +42,7 @@
 #include "AliStack.h"
 #include "AliFiducialCut.h"
 #include "TParticle.h"
-#include "AliAODCaloCluster.h"
+#include "AliVCluster.h"
 #include "AliAODEvent.h"
 #include "AliAODMCParticle.h"
 
@@ -479,10 +479,10 @@ void  AliAnaPi0EbE::MakeShowerShapeIdentification()
     pl = GetAODPHOS();
   else if (fCalorimeter == "EMCAL")
     pl = GetAODEMCAL();
-  //Fill AODCaloClusters and AODParticle with PHOS aods
+
   TLorentzVector mom ;
   for(Int_t icalo = 0; icalo < pl->GetEntriesFast(); icalo++){
-    AliAODCaloCluster * calo = (AliAODCaloCluster*) (pl->At(icalo));   
+    AliVCluster * calo = (AliVCluster*) (pl->At(icalo));       
     
     //Cluster selection, not charged, with pi0 id and in fiducial cut
          
index a88ed8c64d4d29409860dce3011decc5e44e5724..adaf552ce8703fbf39a07e43024b31af2eec84ad 100644 (file)
@@ -136,7 +136,7 @@ AliAnalysisTaskParticleCorrelation *AddTaskPartCorr(TString data, TString calori
   else {//EMCAL
     //anaphoton->SetNCellCut(0);// At least 2 cells
     anaphoton->SetMinPt(0.1); // no effect minium EMCAL cut.
-    if(kUseKinematics) anaphoton->SetTimeCut(525,725);// Time window of [550-750] ns
+    if(!kUseKinematics) anaphoton->SetTimeCut(400,900);// Time window of [400-900] ns
     anaphoton->SetMinDistanceToBadChannel(6, 12, 18);
   }
   anaphoton->SetCalorimeter(calorimeter);
@@ -191,7 +191,8 @@ AliAnalysisTaskParticleCorrelation *AddTaskPartCorr(TString data, TString calori
   anapi0->SetNZvertBin(1);
   anapi0->SetNRPBin(1);
   anapi0->SetNMaxEvMix(10);
-  anapi0->SwitchOffDataMC() ;//Access MC stack and fill more histograms
+  if(kUseKinematics)anapi0->SwitchOnDataMC() ;//Access MC stack and fill more histograms
+  else anapi0->SwitchOffDataMC() ;
   if(calorimeter=="PHOS") anapi0->SetNumberOfModules(3); //PHOS first year
   else  anapi0->SetNumberOfModules(4); //EMCAL first year
   anapi0->SetHistoPtRangeAndNBins(0, 50, 200) ;
index 6b58ae7b35df241c3ab10783d75a8e9d4b8e55b9..97580d504432ec2679fb9e1ffe3ecefac62db76f 100644 (file)
@@ -115,7 +115,7 @@ AliAnalysisTaskParticleCorrelation *AddTaskCalorimeterQA(TString data, Bool_t kP
   emcalQA->SwitchOffFiducialCut();
   emcalQA->SwitchOffPlotsMaking();
   emcalQA->SwitchOnCalorimetersCorrelation();
-  if(kUseKinematics)emcalQA->SetTimeCut(420,825);//Open for the moment
+  if(!kUseKinematics)emcalQA->SetTimeCut(400,850);//Open for the moment
   //Set Histrograms bins and ranges
   emcalQA->SetHistoPtRangeAndNBins(0, 5, 50) ;
   emcalQA->SetHistoFinePtRangeAndNBins(0, 5, 1000) ; // bining for fhAmpId