#include "AliIsolationCut.h"
#include "AliMCAnalysisUtils.h"
#include "AliNeutralMesonSelection.h"
-#include "AliAODCaloCells.h"
+#include "AliVCaloCells.h"
#include "AliAODEvent.h"
#include "AliAODHandler.h"
#include "AliAnalysisManager.h"
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.),
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),
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;
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;
// 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
// 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
}
-
-//___________________________________________________
-//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()) {
}
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
}
-//__________________________________________________
-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
//fReader = new AliCaloTrackReader(); //Initialized in maker
//fCaloUtils = new AliCalorimeterUtils();//Initialized in maker
-
- //fAnaOutContainer = new TList();
-
+
fNewAOD = kFALSE ;
fOutputAODName = "PartCorr";
fOutputAODClassName = "AliAODPWG4Particle";
class TObjString;
//Analysis
-class AliESDCaloCluster;
-class AliAODCaloCluster;
-class AliAODCaloCells;
+class AliVCaloCells;
#include "AliCaloTrackReader.h"
#include "AliCaloPID.h"
#include "AliFiducialCut.h"
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 ;}
virtual void MakeAnalysisFillAOD() {;}
virtual void MakeAnalysisFillHistograms() {;}
-
- virtual void MakeMixingAnalysisFillHistograms() {;}
-
+
virtual TObjString * GetAnalysisCuts() {return 0x0;}
virtual Int_t GetDebug() const { return fDebug ; }
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() ; }
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; }
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 ;}
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 ;
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 ;
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 ;
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 ;
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
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
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
- ClassDef(AliAnaPartCorrBaseClass,7)
+ ClassDef(AliAnaPartCorrBaseClass,8)
} ;
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");
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
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;
}
//________________________________________________________________________
-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 ;
}
}// Analysis with histograms as output on
}//Loop on analysis defined
-
fhNEvents = new TH1I("hNEvents", "Number of analyzed events" , 1 , 0 , 1 ) ;
fOutputContainer->Add(fhNEvents);
printf("AliAnaPartCorrMaker::GetOutputInit() - Analysis job list not initialized!!!\n");
//abort();
}
-
- //Initialize the geometry pointers
- //GetCaloUtils()->InitPHOSGeometry();
- //GetCaloUtils()->InitEMCALGeometry();
//Initialize reader
GetReader()->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();
fMakeHisto = kTRUE;
fMakeAOD = kTRUE;
- fMakeMixing = kFALSE;
fAnaDebug = 0; // No debugging info displayed by default
}
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") ;
//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){
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
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 ; }
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) {
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)
} ;
//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);
//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);
// 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()
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),
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
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)),
if(fFiducialCut) delete fFiducialCut ;
+ if(fAODBranchList){
+ fAODBranchList->Delete();
+ delete fAODBranchList ;
+ }
+
if(fAODCTS){
fAODCTS->Clear() ;
delete fAODCTS ;
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);
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 ;
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
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
//
//
// 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 ;
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
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)) ) {
//
// 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);
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
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)) ) {
//
// 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
}
- //____________________________________________________________________________
+//____________________________________________________________________________
void AliCaloTrackReader::FillInputPHOSCells() {
//Return array with PHOS cells in aod format
}
+//____________________________________________________________________________
+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();
+ }
+
+}
+
+
+
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 ;}
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) ;
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
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
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
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)
} ;
/* $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()
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)");
//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 ;
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;
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
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;
}
TParticle * mom = GetMCStack()->Particle(ph->GetLabel());
- ptprim = mom->Pt();
+ ptprim = mom->Pt();
phiprim = mom->Phi();
etaprim = mom->Eta();
}
}//Work with stack also
}// aod branch loop
- // CaloCells histograms
- if(GetReader()->GetDataType()!= AliCaloTrackReader::kMC) {
- if(GetAODCaloCells()){
-
- Int_t ncells = GetAODCaloCells()->GetNumberOfCells();
- fhNCells->Fill(ncells) ;
-
- for (Int_t iCell = 0; iCell < ncells; iCell++) {
- if(GetDebug() > 2) printf("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)
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++);
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
//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";
}
//__________________________________________________________________
-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)
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
{
//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
//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);
}
}
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();
//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);
private:
- Int_t SelectJet(AliAODPWG4Particle * particle) const ;
+ Int_t SelectJet(AliAODPWG4Particle * particle, AliAODEvent * event) const ;
void MakeAnalysisFillAOD() ;
void MakeAnalysisFillHistograms() ;
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;
//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
//__________________________________________________________________
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())
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];
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;
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)
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
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()));
}//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();
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());
}
//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);
}
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.
-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.
reader->SetEMCALPtMin(0.1);
reader->SetPHOSPtMin(0.);
reader->SetCTSPtMin(0.);
+ if(outputAOD) reader->SwitchOffWriteDeltaAOD() ;
+ if(oldAOD) reader->SwitchOnOldAODs();
if(kPrintSettings) reader->Print("");
// *** Calorimeters Utils ***
//==============================================================================
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);
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff