From 2c75809c3cddc866013bfaf1751673a81016e94e Mon Sep 17 00:00:00 2001 From: fbock Date: Thu, 4 Sep 2014 07:18:01 +0200 Subject: [PATCH] added functionality to run with calo-calo and conv-calo neutral pions to omega task --- ...alysisTaskNeutralMesonToPiPlPiMiPiZero.cxx | 692 +++++++++++++++--- ...AnalysisTaskNeutralMesonToPiPlPiMiPiZero.h | 179 +++-- PWGGA/GammaConv/AliCaloPhotonCuts.cxx | 166 +++-- PWGGA/GammaConv/AliCaloPhotonCuts.h | 8 +- PWGGA/GammaConv/AliPrimaryPionCuts.cxx | 47 +- PWGGA/GammaConv/AliPrimaryPionCuts.h | 5 +- ...vNeutralMesonPiPlPiMiPiZero_CaloMode_pPb.C | 326 +++++++++ ...NeutralMesonPiPlPiMiPiZero_ConvMode_pPb.C} | 52 +- ...NeutralMesonPiPlPiMiPiZero_MixedMode_pPb.C | 338 +++++++++ 9 files changed, 1525 insertions(+), 288 deletions(-) create mode 100644 PWGGA/GammaConv/macros/AddTask_GammaConvNeutralMesonPiPlPiMiPiZero_CaloMode_pPb.C rename PWGGA/GammaConv/macros/{AddTask_GammaConvNeutralMesonPiPlPiMiPiZero_pPb.C => AddTask_GammaConvNeutralMesonPiPlPiMiPiZero_ConvMode_pPb.C} (85%) create mode 100644 PWGGA/GammaConv/macros/AddTask_GammaConvNeutralMesonPiPlPiMiPiZero_MixedMode_pPb.C diff --git a/PWGGA/GammaConv/AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero.cxx b/PWGGA/GammaConv/AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero.cxx index 1d0f7ca1a6c..f8acd8046c9 100644 --- a/PWGGA/GammaConv/AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero.cxx +++ b/PWGGA/GammaConv/AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero.cxx @@ -72,18 +72,23 @@ AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::AliAnalysisTaskNeutralMesonToPiPlPi fReaderGammas(NULL), fSelectorNegPionIndex(0), fSelectorPosPionIndex(0), - fGoodGammas(NULL), + fGoodConvGammas(NULL), + fClusterCandidates(NULL), fNeutralPionCandidates(NULL), fGoodVirtualParticles(NULL), fEventCutArray(NULL), fGammaCutArray(NULL), + fClusterCutArray(NULL), fPionCutArray(NULL), fNeutralPionMesonCutArray(NULL), fMesonCutArray(NULL), fEventCuts(NULL), fConversionCuts(NULL), + fClusterCuts(NULL), fHistoConvGammaPt(NULL), fHistoConvGammaEta(NULL), + fHistoClusterGammaPt(NULL), + fHistoClusterGammaEta(NULL), fHistoNegPionPt(NULL), fHistoPosPionPt(NULL), fHistoNegPionPhi(NULL), @@ -119,6 +124,8 @@ AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::AliAnalysisTaskNeutralMesonToPiPlPi fHistoTrueMotherGammaGammaFromOmegaInvMassPt(NULL), fHistoTrueConvGammaPt(NULL), fHistoTrueConvGammaFromNeutralMesonPt(NULL), + fHistoTrueClusterGammaPt(NULL), + fHistoTrueClusterGammaFromNeutralMesonPt(NULL), fHistoTruePosPionPt(NULL), fHistoTruePosPionFromNeutralMesonPt(NULL), fHistoTrueNegPionPt(NULL), @@ -139,7 +146,8 @@ AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::AliAnalysisTaskNeutralMesonToPiPlPi fDoMesonAnalysis(kTRUE), fDoMesonQA(kFALSE), fIsFromMBHeader(kTRUE), - fIsMC(kFALSE) + fIsMC(kFALSE), + fNeutralPionMode(0) { } @@ -163,18 +171,23 @@ AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::AliAnalysisTaskNeutralMesonToPiPlPi fReaderGammas(NULL), fSelectorNegPionIndex(0), fSelectorPosPionIndex(0), - fGoodGammas(NULL), + fGoodConvGammas(NULL), + fClusterCandidates(NULL), fNeutralPionCandidates(NULL), fGoodVirtualParticles(NULL), fEventCutArray(NULL), fGammaCutArray(NULL), + fClusterCutArray(NULL), fPionCutArray(NULL), fNeutralPionMesonCutArray(NULL), fMesonCutArray(NULL), fEventCuts(NULL), fConversionCuts(NULL), + fClusterCuts(NULL), fHistoConvGammaPt(NULL), fHistoConvGammaEta(NULL), + fHistoClusterGammaPt(NULL), + fHistoClusterGammaEta(NULL), fHistoNegPionPt(NULL), fHistoPosPionPt(NULL), fHistoNegPionPhi(NULL), @@ -210,6 +223,8 @@ AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::AliAnalysisTaskNeutralMesonToPiPlPi fHistoTrueMotherGammaGammaFromOmegaInvMassPt(NULL), fHistoTrueConvGammaPt(NULL), fHistoTrueConvGammaFromNeutralMesonPt(NULL), + fHistoTrueClusterGammaPt(NULL), + fHistoTrueClusterGammaFromNeutralMesonPt(NULL), fHistoTruePosPionPt(NULL), fHistoTruePosPionFromNeutralMesonPt(NULL), fHistoTrueNegPionPt(NULL), @@ -230,7 +245,8 @@ AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::AliAnalysisTaskNeutralMesonToPiPlPi fDoMesonAnalysis(kTRUE), fDoMesonQA(kFALSE), fIsFromMBHeader(kTRUE), - fIsMC(kFALSE) + fIsMC(kFALSE), + fNeutralPionMode(0) { DefineOutput(1, TList::Class()); } @@ -242,10 +258,15 @@ AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::~AliAnalysisTaskNeutralMesonToPiPlP // virtual destructor // cout<<"Destructor"<At(iCut))->GetCutNumber(); TString cutstringPion = ((AliPrimaryPionCuts*)fPionCutArray->At(iCut))->GetCutNumber(); - TString cutstringGamma = ((AliConversionPhotonCuts*)fGammaCutArray->At(iCut))->GetCutNumber(); + TString cutstringConvGamma = ""; + if (fNeutralPionMode < 2) cutstringConvGamma = ((AliConversionPhotonCuts*)fGammaCutArray->At(iCut))->GetCutNumber(); + TString cutstringCaloGamma = ""; + if (fNeutralPionMode > 0) cutstringCaloGamma = ((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutNumber(); TString cutstringNeutralPion= ((AliConversionMesonCuts*)fNeutralPionMesonCutArray->At(iCut))->GetCutNumber(); TString cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber(); - TString fullCutString = Form("%s_%s_%s_%s_%s",cutstringEvent.Data(),cutstringGamma.Data(),cutstringNeutralPion.Data(), cutstringPion.Data(),cutstringMeson.Data()); + TString fullCutString = ""; + if (fNeutralPionMode == 0) fullCutString = Form("%i_%s_%s_%s_%s_%s",fNeutralPionMode,cutstringEvent.Data(),cutstringConvGamma.Data(),cutstringNeutralPion.Data(), cutstringPion.Data(),cutstringMeson.Data()); + else if (fNeutralPionMode == 1) fullCutString = Form("%i_%s_%s_%s_%s_%s_%s",fNeutralPionMode,cutstringEvent.Data(),cutstringConvGamma.Data(),cutstringCaloGamma.Data(),cutstringNeutralPion.Data(), cutstringPion.Data(),cutstringMeson.Data()); + else if (fNeutralPionMode == 2) fullCutString = Form("%i_%s_%s_%s_%s_%s",fNeutralPionMode,cutstringEvent.Data(),cutstringCaloGamma.Data(),cutstringNeutralPion.Data(), cutstringPion.Data(),cutstringMeson.Data()); + TString nameBackList = Form("%s Back histograms",fullCutString.Data()); TString nameMotherList = Form("%s Mother histograms",fullCutString.Data()); @@ -345,7 +374,8 @@ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::UserCreateOutputObjects() fOutputContainer->SetOwner(kTRUE); } - fGoodGammas = new TList(); + fGoodConvGammas = new TList(); + fClusterCandidates = new TList(); fNeutralPionCandidates = new TList(); fGoodVirtualParticles = new TList(); @@ -356,8 +386,14 @@ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::UserCreateOutputObjects() fHistoNEvents = new TH1I*[fnCuts]; fHistoNGoodESDTracks = new TH1I*[fnCuts]; fProfileEtaShift = new TProfile*[fnCuts]; - fHistoConvGammaPt = new TH1F*[fnCuts]; - fHistoConvGammaEta = new TH1F*[fnCuts]; + if (fNeutralPionMode < 2){ + fHistoConvGammaPt = new TH1F*[fnCuts]; + fHistoConvGammaEta = new TH1F*[fnCuts]; + } + if (fNeutralPionMode > 0){ + fHistoClusterGammaPt = new TH1F*[fnCuts]; + fHistoClusterGammaEta = new TH1F*[fnCuts]; + } fHistoNegPionPt = new TH1F*[fnCuts]; fHistoPosPionPt = new TH1F*[fnCuts]; fHistoNegPionPhi = new TH1F*[fnCuts]; @@ -381,11 +417,17 @@ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::UserCreateOutputObjects() for(Int_t iCut = 0; iCutAt(iCut))->GetCutNumber(); TString cutstringPion = ((AliPrimaryPionCuts*)fPionCutArray->At(iCut))->GetCutNumber(); - TString cutstringGamma = ((AliConversionPhotonCuts*)fGammaCutArray->At(iCut))->GetCutNumber(); + TString cutstringConvGamma = ""; + if (fNeutralPionMode < 2) cutstringConvGamma = ((AliConversionPhotonCuts*)fGammaCutArray->At(iCut))->GetCutNumber(); + TString cutstringCaloGamma = ""; + if (fNeutralPionMode > 0) cutstringCaloGamma = ((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutNumber(); TString cutstringNeutralPion= ((AliConversionMesonCuts*)fNeutralPionMesonCutArray->At(iCut))->GetCutNumber(); TString cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber(); - TString fullCutString = Form("%s_%s_%s_%s_%s",cutstringEvent.Data(),cutstringGamma.Data(),cutstringNeutralPion.Data(), cutstringPion.Data(),cutstringMeson.Data()); + TString fullCutString = ""; + if (fNeutralPionMode == 0) fullCutString = Form("%i_%s_%s_%s_%s_%s",fNeutralPionMode,cutstringEvent.Data(),cutstringConvGamma.Data(),cutstringNeutralPion.Data(), cutstringPion.Data(),cutstringMeson.Data()); + else if (fNeutralPionMode == 1) fullCutString = Form("%i_%s_%s_%s_%s_%s_%s",fNeutralPionMode,cutstringEvent.Data(),cutstringConvGamma.Data(),cutstringCaloGamma.Data(),cutstringNeutralPion.Data(), cutstringPion.Data(),cutstringMeson.Data()); + else if (fNeutralPionMode == 2) fullCutString = Form("%i_%s_%s_%s_%s_%s",fNeutralPionMode,cutstringEvent.Data(),cutstringCaloGamma.Data(),cutstringNeutralPion.Data(), cutstringPion.Data(),cutstringMeson.Data()); TString nameCutFolder = Form("Cut Number %s", fullCutString.Data()); TString nameESDList = Form("%s ESD histograms", fullCutString.Data()); @@ -417,10 +459,18 @@ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::UserCreateOutputObjects() fProfileEtaShift[iCut] = new TProfile("Eta Shift","Eta Shift",1, -0.5,0.5); fESDList[iCut]->Add(fProfileEtaShift[iCut]); - fHistoConvGammaPt[iCut] = new TH1F("ESD_ConvGamma_Pt","ESD_ConvGamma_Pt",250,0,25); - fESDList[iCut]->Add(fHistoConvGammaPt[iCut]); - fHistoConvGammaEta[iCut] = new TH1F("ESD_ConvGamma_Eta","ESD_ConvGamma_Eta",600,-1.5,1.5); - fESDList[iCut]->Add(fHistoConvGammaEta[iCut]); + if (fNeutralPionMode < 2){ + fHistoConvGammaPt[iCut] = new TH1F("ESD_ConvGamma_Pt","ESD_ConvGamma_Pt",250,0,25); + fESDList[iCut]->Add(fHistoConvGammaPt[iCut]); + fHistoConvGammaEta[iCut] = new TH1F("ESD_ConvGamma_Eta","ESD_ConvGamma_Eta",600,-1.5,1.5); + fESDList[iCut]->Add(fHistoConvGammaEta[iCut]); + } + if (fNeutralPionMode > 0){ + fHistoClusterGammaPt[iCut] = new TH1F("ESD_ClusterGamma_Pt","ESD_ClusterGamma_Pt",250,0,25); + fESDList[iCut]->Add(fHistoClusterGammaPt[iCut]); + fHistoClusterGammaEta[iCut] = new TH1F("ESD_ClusterGamma_Eta","ESD_ClusterGamma_Eta",600,-1.5,1.5); + fESDList[iCut]->Add(fHistoClusterGammaEta[iCut]); + } fHistoNegPionPt[iCut] = new TH1F("ESD_PrimaryNegPions_Pt","ESD_PrimaryNegPions_Pt",1000,0,25); fESDList[iCut]->Add(fHistoNegPionPt[iCut]); fHistoPosPionPt[iCut] = new TH1F("ESD_PrimaryPosPions_Pt","ESD_PrimaryPosPions_Pt",1000,0,25); @@ -483,8 +533,14 @@ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::UserCreateOutputObjects() fMCList = new TList*[fnCuts]; // True Histogramms fTrueList = new TList*[fnCuts]; - fHistoTrueConvGammaPt = new TH1F*[fnCuts]; - fHistoTrueConvGammaFromNeutralMesonPt = new TH1F*[fnCuts]; + if (fNeutralPionMode < 2){ + fHistoTrueConvGammaPt = new TH1F*[fnCuts]; + fHistoTrueConvGammaFromNeutralMesonPt = new TH1F*[fnCuts]; + } + if (fNeutralPionMode > 0){ + fHistoTrueClusterGammaPt = new TH1F*[fnCuts]; + fHistoTrueClusterGammaFromNeutralMesonPt = new TH1F*[fnCuts]; + } fHistoTruePosPionPt = new TH1F*[fnCuts]; fHistoTrueNegPionPt = new TH1F*[fnCuts]; fHistoTruePosPionFromNeutralMesonPt = new TH1F*[fnCuts]; @@ -492,7 +548,9 @@ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::UserCreateOutputObjects() fHistoMCAllGammaPt = new TH1F*[fnCuts]; - fHistoMCConvGammaPt = new TH1F*[fnCuts]; + if (fNeutralPionMode < 2){ + fHistoMCConvGammaPt = new TH1F*[fnCuts]; + } fHistoMCAllPosPionsPt = new TH1F*[fnCuts]; fHistoMCAllNegPionsPt = new TH1F*[fnCuts]; fHistoMCGammaFromNeutralMesonPt = new TH1F*[fnCuts]; @@ -522,11 +580,17 @@ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::UserCreateOutputObjects() for(Int_t iCut = 0; iCutAt(iCut))->GetCutNumber(); TString cutstringPion = ((AliPrimaryPionCuts*)fPionCutArray->At(iCut))->GetCutNumber(); - TString cutstringGamma = ((AliConversionPhotonCuts*)fGammaCutArray->At(iCut))->GetCutNumber(); + TString cutstringConvGamma = ""; + if (fNeutralPionMode < 2) cutstringConvGamma = ((AliConversionPhotonCuts*)fGammaCutArray->At(iCut))->GetCutNumber(); + TString cutstringCaloGamma = ""; + if (fNeutralPionMode > 0) cutstringCaloGamma = ((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutNumber(); TString cutstringNeutralPion= ((AliConversionMesonCuts*)fNeutralPionMesonCutArray->At(iCut))->GetCutNumber(); TString cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber(); - TString fullCutString = Form("%s_%s_%s_%s_%s",cutstringEvent.Data(),cutstringGamma.Data(),cutstringNeutralPion.Data(), cutstringPion.Data(),cutstringMeson.Data()); + TString fullCutString = ""; + if (fNeutralPionMode == 0) fullCutString = Form("%i_%s_%s_%s_%s_%s",fNeutralPionMode,cutstringEvent.Data(),cutstringConvGamma.Data(),cutstringNeutralPion.Data(), cutstringPion.Data(),cutstringMeson.Data()); + else if (fNeutralPionMode == 1) fullCutString = Form("%i_%s_%s_%s_%s_%s_%s",fNeutralPionMode,cutstringEvent.Data(),cutstringConvGamma.Data(),cutstringCaloGamma.Data(),cutstringNeutralPion.Data(), cutstringPion.Data(),cutstringMeson.Data()); + else if (fNeutralPionMode == 2) fullCutString = Form("%i_%s_%s_%s_%s_%s",fNeutralPionMode,cutstringEvent.Data(),cutstringCaloGamma.Data(),cutstringNeutralPion.Data(), cutstringPion.Data(),cutstringMeson.Data()); TString nameMCList = Form("%s MC histograms", fullCutString.Data()); TString nameTrueRecList = Form("%s True histograms", fullCutString.Data()); @@ -537,8 +601,11 @@ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::UserCreateOutputObjects() fHistoMCAllGammaPt[iCut] = new TH1F("MC_AllGamma_Pt","MC_AllGamma_Pt",250,0,25); fMCList[iCut]->Add(fHistoMCAllGammaPt[iCut]); - fHistoMCConvGammaPt[iCut] = new TH1F("MC_ConvGamma_Pt","MC_ConvGamma_Pt",250,0,25); - fMCList[iCut]->Add(fHistoMCConvGammaPt[iCut]); + if (fNeutralPionMode < 2){ + fHistoMCConvGammaPt[iCut] = new TH1F("MC_ConvGamma_Pt","MC_ConvGamma_Pt",250,0,25); + fMCList[iCut]->Add(fHistoMCConvGammaPt[iCut]); + } + fHistoMCAllPosPionsPt[iCut] = new TH1F("MC_AllPosPions_Pt","MC_AllPosPions_Pt",1000,0,25); fMCList[iCut]->Add(fHistoMCAllPosPionsPt[iCut]); fHistoMCAllNegPionsPt[iCut] = new TH1F("MC_AllNegPions_Pt","MC_AllNegPions_Pt",1000,0,25); @@ -571,11 +638,18 @@ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::UserCreateOutputObjects() fTrueList[iCut]->SetOwner(kTRUE); fCutFolder[iCut]->Add(fTrueList[iCut]); - fHistoTrueConvGammaPt[iCut] = new TH1F("ESD_TrueConvGamma_Pt","ESD_TrueConvGamma_Pt",250,0,25); - fTrueList[iCut]->Add(fHistoTrueConvGammaPt[iCut]); - fHistoTrueConvGammaFromNeutralMesonPt[iCut] = new TH1F("ESD_TrueConvGammaFromNeutralMeson_Pt","ESD_TrueConvGammaFromNeutralMeson_Pt",250,0,25); - fTrueList[iCut]->Add(fHistoTrueConvGammaFromNeutralMesonPt[iCut]); - + if (fNeutralPionMode < 2){ + fHistoTrueConvGammaPt[iCut] = new TH1F("ESD_TrueConvGamma_Pt","ESD_TrueConvGamma_Pt",250,0,25); + fTrueList[iCut]->Add(fHistoTrueConvGammaPt[iCut]); + fHistoTrueConvGammaFromNeutralMesonPt[iCut] = new TH1F("ESD_TrueConvGammaFromNeutralMeson_Pt","ESD_TrueConvGammaFromNeutralMeson_Pt",250,0,25); + fTrueList[iCut]->Add(fHistoTrueConvGammaFromNeutralMesonPt[iCut]); + } + if (fNeutralPionMode > 0){ + fHistoTrueClusterGammaPt[iCut] = new TH1F("ESD_TrueClusterGamma_Pt","ESD_TrueClusterGamma_Pt",250,0,25); + fTrueList[iCut]->Add(fHistoTrueClusterGammaPt[iCut]); + fHistoTrueClusterGammaFromNeutralMesonPt[iCut] = new TH1F("ESD_TrueClusterGammaFromNeutralMeson_Pt","ESD_TrueClusterGammaFromNeutralMeson_Pt",250,0,25); + fTrueList[iCut]->Add(fHistoTrueClusterGammaFromNeutralMesonPt[iCut]); + } fHistoTruePosPionPt[iCut] = new TH1F("ESD_TruePosPion_Pt","ESD_TruePosPion_Pt",1000,0,25); fTrueList[iCut]->Add(fHistoTruePosPionPt[iCut]); fHistoTrueNegPionPt[iCut] = new TH1F("ESD_TrueNegPion_Pt","ESD_TrueNegPion_Pt",1000,0,25); @@ -641,11 +715,20 @@ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::UserCreateOutputObjects() fCutFolder[iCut]->Add( ((AliPrimaryPionCuts*)fPionCutArray->At(iCut))->GetCutHistograms() ); } } - if( fGammaCutArray ) { - if( ((AliConversionPhotonCuts*)fGammaCutArray->At(iCut))->GetCutHistograms() ) { - fCutFolder[iCut]->Add( ((AliConversionPhotonCuts*)fGammaCutArray->At(iCut))->GetCutHistograms() ); + if (fNeutralPionMode < 2){ + if( fGammaCutArray ) { + if( ((AliConversionPhotonCuts*)fGammaCutArray->At(iCut))->GetCutHistograms() ) { + fCutFolder[iCut]->Add( ((AliConversionPhotonCuts*)fGammaCutArray->At(iCut))->GetCutHistograms() ); + } } - } + } + if (fNeutralPionMode > 0){ + if( fClusterCutArray ) { + if( ((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutHistograms() ) { + fCutFolder[iCut]->Add( ((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutHistograms() ); + } + } + } if( fNeutralPionMesonCutArray ) { if( ((AliConversionMesonCuts*)fNeutralPionMesonCutArray->At(iCut))->GetCutHistograms() ) { fCutFolder[iCut]->Add( ((AliConversionMesonCuts*)fNeutralPionMesonCutArray->At(iCut))->GetCutHistograms()); @@ -722,19 +805,33 @@ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::UserExec(Option_t *){ ProcessMCParticles(); } - ProcessPhotonCandidates(); // Process this cuts gammas - ProcessNeutralPionCandidatesPureConversions(); // Process neutral pion candidates + if (fNeutralPionMode < 2){ + ProcessConversionPhotonCandidates(); // Process this cuts conversion gammas + } + if (fNeutralPionMode > 0){ + ProcessCaloPhotonCandidates(); // Process this cuts calo gammas + } + + if (fNeutralPionMode == 0 ){ + ProcessNeutralPionCandidatesPureConversions(); // Process neutral pion candidates purely from conversions + } + if (fNeutralPionMode == 1){ + ProcessNeutralPionCandidatesMixedConvCalo(); // Process neutral pion candidates mixed conv and calo + } + if (fNeutralPionMode == 2){ + ProcessNeutralPionCandidatesPureCalo(); // Process neutral pion candidates purely from calo + } + ProcessPionCandidates(); // Process this cuts gammas CalculateMesonCandidates(); CalculateBackground(); UpdateEventByEventData(); - fGoodGammas->Clear(); // delete this cuts good gammas -// if (fNeutralPionCandidates->GetEntries()>0)cout << "##################################"<< fNeutralPionCandidates->GetEntries() << endl; - if(fNeutralPionCandidates->GetEntries()>0){ - fNeutralPionCandidates->Clear(); - } + + if (fGoodConvGammas->GetEntries()>0) fGoodConvGammas->Clear(); + if (fClusterCandidates->GetEntries()>0) fClusterCandidates->Clear(); + if (fNeutralPionCandidates->GetEntries()>0) fNeutralPionCandidates->Clear(); fGoodVirtualParticles->Clear(); // delete this cuts good gammas } @@ -772,8 +869,122 @@ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::Terminate(const Option_t *){ ///Grid } + +//________________________________________________________________________ +void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessCaloPhotonCandidates() +{ + + Int_t nclus = 0; + nclus = fInputEvent->GetNumberOfCaloClusters(); + +// cout << nclus << endl; + + if(nclus == 0) return; + + // vertex + Double_t vertex[3] = {0}; + InputEvent()->GetPrimaryVertex()->GetXYZ(vertex); + + // Loop over EMCal clusters + for(Long_t i = 0; i < nclus; i++){ + + AliVCluster* clus = NULL; + clus = fInputEvent->GetCaloCluster(i); + if (!clus) continue; + if(!((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->ClusterIsSelected(clus,fInputEvent,fIsMC)) continue; + // TLorentzvector with cluster + TLorentzVector clusterVector; + clus->GetMomentum(clusterVector,vertex); + + TLorentzVector* tmpvec = new TLorentzVector(); + tmpvec->SetPxPyPzE(clusterVector.Px(),clusterVector.Py(),clusterVector.Pz(),clusterVector.E()); + + // convert to AODConversionPhoton + AliAODConversionPhoton *PhotonCandidate=new AliAODConversionPhoton(tmpvec); + if(!PhotonCandidate) continue; + + // Flag Photon as CaloPhoton + PhotonCandidate->SetIsCaloPhoton(); + PhotonCandidate->SetCaloClusterRef(i); + // get MC label + if(fIsMC){ + Int_t* mclabelsCluster = clus->GetLabels(); + PhotonCandidate->SetNCaloPhotonMCLabels(clus->GetNLabels()); +// cout << clus->GetNLabels() << endl; + if (clus->GetNLabels()>0){ + for (Int_t k =0; k< (Int_t)clus->GetNLabels(); k++){ + if (k< 20)PhotonCandidate->SetCaloPhotonMCLabel(k,mclabelsCluster[k]); +// Int_t pdgCode = fMCStack->Particle(mclabelsCluster[k])->GetPdgCode(); +// cout << "label " << k << "\t" << mclabelsCluster[k] << " pdg code: " << pdgCode << endl; + } + } + } + + fIsFromMBHeader = kTRUE; + // test whether largest contribution to cluster orginates in added signals + if (fIsMC && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetCaloPhotonMCLabel(0), fMCStack, fInputEvent) == 0) fIsFromMBHeader = kFALSE; + + if (fIsFromMBHeader){ + fHistoClusterGammaPt[fiCut]->Fill(PhotonCandidate->Pt()); + fHistoClusterGammaEta[fiCut]->Fill(PhotonCandidate->Eta()); + } + fClusterCandidates->Add(PhotonCandidate); // if no second loop is required add to events good gammas + + if(fIsMC){ +// if(fInputEvent->IsA()==AliESDEvent::Class()){ + ProcessTrueCaloPhotonCandidates(PhotonCandidate); +// } else { +// ProcessTrueClusterCandidatesAOD(PhotonCandidate); +// } + } + + delete tmpvec; + } + +} + +//________________________________________________________________________ +void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessTrueCaloPhotonCandidates(AliAODConversionPhoton *TruePhotonCandidate) +{ + TParticle *Photon = NULL; + if (!TruePhotonCandidate->GetIsCaloPhoton()) AliFatal("CaloPhotonFlag has not been set task will abort"); +// fHistoTrueNLabelsInClus[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMCLabels()); + + if (TruePhotonCandidate->GetNCaloPhotonMCLabels()>0)Photon = fMCStack->Particle(TruePhotonCandidate->GetCaloPhotonMCLabel(0)); + else return; + + if(Photon == NULL){ + // cout << "no photon" << endl; + return; + } + +// Int_t pdgCodeParticle = Photon->GetPdgCode(); + TruePhotonCandidate->SetCaloPhotonMCFlags(fMCStack); + + // True Photon + if(fIsFromMBHeader){ + if(TruePhotonCandidate->GetCaloPhotonMCLabel(0) <= fMCStack->GetNprimary()){ + if (TruePhotonCandidate->IsLargestComponentPhoton()){ + fHistoTrueClusterGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt()); + if (GammaIsNeutralMesonPiPlPiMiPiZeroDaughter(TruePhotonCandidate->GetCaloPhotonMCLabel(0))){ + fHistoTrueClusterGammaFromNeutralMesonPt[fiCut]->Fill(TruePhotonCandidate->Pt()); + } + } + if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion()){ + fHistoTrueClusterGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt()); + if (GammaIsNeutralMesonPiPlPiMiPiZeroDaughter(TruePhotonCandidate->GetCaloPhotonMCLabel(0))){ + fHistoTrueClusterGammaFromNeutralMesonPt[fiCut]->Fill(TruePhotonCandidate->Pt()); + } + } + } + } + return; +} + + + //________________________________________________________________________ -void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessPhotonCandidates(){ +void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessConversionPhotonCandidates(){ Int_t nV0 = 0; TList *GoodGammasStepOne = new TList(); TList *GoodGammasStepTwo = new TList(); @@ -800,7 +1011,7 @@ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessPhotonCandidates(){ if(!((AliConversionPhotonCuts*)fGammaCutArray->At(fiCut))->UseElecSharingCut() && !((AliConversionPhotonCuts*)fGammaCutArray->At(fiCut))->UseToCloseV0sCut()){ // if no post reader loop is required add to events good gammas - fGoodGammas->Add(PhotonCandidate); + fGoodConvGammas->Add(PhotonCandidate); if(fIsFromMBHeader){ fHistoConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt()); @@ -808,7 +1019,7 @@ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessPhotonCandidates(){ } if(fMCEvent){ - ProcessTruePhotonCandidates(PhotonCandidate); + ProcessTrueConversionPhotonCandidates(PhotonCandidate); } } else if(((AliConversionPhotonCuts*)fGammaCutArray->At(fiCut))->UseElecSharingCut()){ // if Shared Electron cut is enabled, Fill array, add to step one ((AliConversionPhotonCuts*)fGammaCutArray->At(fiCut))->FillElectonLabelArray(PhotonCandidate,nV0); @@ -835,13 +1046,13 @@ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessPhotonCandidates(){ } if(!((AliConversionPhotonCuts*)fGammaCutArray->At(fiCut))->RejectSharedElectronV0s(PhotonCandidate,i,GoodGammasStepOne->GetEntries())) continue; if(!((AliConversionPhotonCuts*)fGammaCutArray->At(fiCut))->UseToCloseV0sCut()){ // To Colse v0s cut diabled, step two not needed - fGoodGammas->Add(PhotonCandidate); + fGoodConvGammas->Add(PhotonCandidate); if(fIsFromMBHeader){ fHistoConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt()); fHistoConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta()); } if(fMCEvent){ - ProcessTruePhotonCandidates(PhotonCandidate); + ProcessTrueConversionPhotonCandidates(PhotonCandidate); } } else GoodGammasStepTwo->Add(PhotonCandidate); // Close v0s cut enabled -> add to list two @@ -861,7 +1072,7 @@ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessPhotonCandidates(){ } if(!((AliConversionPhotonCuts*)fGammaCutArray->At(fiCut))->RejectToCloseV0s(PhotonCandidate,GoodGammasStepTwo,i)) continue; - fGoodGammas->Add(PhotonCandidate); // Add gamma to current cut TList + fGoodConvGammas->Add(PhotonCandidate); // Add gamma to current cut TList if(fIsFromMBHeader){ fHistoConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt()); // Differences to old V0Reader in p_t due to conversion KF->TLorentzVector @@ -869,7 +1080,7 @@ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessPhotonCandidates(){ } if(fMCEvent){ - ProcessTruePhotonCandidates(PhotonCandidate); + ProcessTrueConversionPhotonCandidates(PhotonCandidate); } } } @@ -881,7 +1092,7 @@ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessPhotonCandidates(){ } //________________________________________________________________________ -void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessTruePhotonCandidates(AliAODConversionPhoton *TruePhotonCandidate) +void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessTrueConversionPhotonCandidates(AliAODConversionPhoton *TruePhotonCandidate) { // Process True Photons AliStack *MCStack = fMCEvent->Stack(); @@ -921,12 +1132,12 @@ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessTruePhotonCandidates(Al //________________________________________________________________________ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessNeutralPionCandidatesPureConversions(){ // Conversion Gammas - if(fGoodGammas->GetEntries()>1){ - for(Int_t firstGammaIndex=0;firstGammaIndexGetEntries()-1;firstGammaIndex++){ - AliAODConversionPhoton *gamma0=dynamic_cast(fGoodGammas->At(firstGammaIndex)); + if(fGoodConvGammas->GetEntries()>1){ + for(Int_t firstGammaIndex=0;firstGammaIndexGetEntries()-1;firstGammaIndex++){ + AliAODConversionPhoton *gamma0=dynamic_cast(fGoodConvGammas->At(firstGammaIndex)); if (gamma0==NULL) continue; - for(Int_t secondGammaIndex=firstGammaIndex+1;secondGammaIndexGetEntries();secondGammaIndex++){ - AliAODConversionPhoton *gamma1=dynamic_cast(fGoodGammas->At(secondGammaIndex)); + for(Int_t secondGammaIndex=firstGammaIndex+1;secondGammaIndexGetEntries();secondGammaIndex++){ + AliAODConversionPhoton *gamma1=dynamic_cast(fGoodConvGammas->At(secondGammaIndex)); //Check for same Electron ID if (gamma1==NULL) continue; if(gamma0->GetTrackLabelPositive() == gamma1->GetTrackLabelPositive() || @@ -960,6 +1171,117 @@ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessNeutralPionCandidatesPu } +//________________________________________________________________________ +void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessNeutralPionCandidatesPureCalo(){ + + // Conversion Gammas + if(fClusterCandidates->GetEntries()>0){ + + // vertex + Double_t vertex[3] = {0}; + InputEvent()->GetPrimaryVertex()->GetXYZ(vertex); + + for(Int_t firstGammaIndex=0;firstGammaIndexGetEntries();firstGammaIndex++){ + AliAODConversionPhoton *gamma0=dynamic_cast(fClusterCandidates->At(firstGammaIndex)); + if (gamma0==NULL) continue; + + for(Int_t secondGammaIndex=0;secondGammaIndexGetEntries();secondGammaIndex++){ + if (firstGammaIndex == secondGammaIndex) continue; + AliAODConversionPhoton *gamma1=dynamic_cast(fClusterCandidates->At(secondGammaIndex)); + if (gamma1==NULL) continue; + + AliAODConversionMother *pi0cand = new AliAODConversionMother(gamma0,gamma1); + pi0cand->SetLabels(firstGammaIndex,secondGammaIndex); + + if((((AliConversionMesonCuts*)fNeutralPionMesonCutArray->At(fiCut))->MesonIsSelected(pi0cand,kTRUE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift()))){ + fHistoGammaGammaInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt()); + if (pi0cand->M() > ((AliConversionMesonCuts*)fNeutralPionMesonCutArray->At(fiCut))->GetSelectionLow() && pi0cand->M() < ((AliConversionMesonCuts*)fNeutralPionMesonCutArray->At(fiCut))->GetSelectionHigh()){ + fNeutralPionCandidates->Add(pi0cand); +// cout << "Pi0 candidate " << pi0cand->M() << "\t" << pi0cand->Pt() << endl; + } + + if(fIsMC){ +// if(fInputEvent->IsA()==AliESDEvent::Class()) + ProcessTrueNeutralPionCandidatesPureCalo(pi0cand,gamma0,gamma1); +// if(fInputEvent->IsA()==AliAODEvent::Class()) +// ProcessTrueNeutralPionCandidatesPureConversionsAOD(pi0cand,gamma0,gamma1); + } + } + } + } + } +} + +//______________________________________________________________________ +void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessTrueNeutralPionCandidatesPureCalo( AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1) +{ + // Process True Mesons + AliStack *MCStack = fMCEvent->Stack(); + + Bool_t isTruePi0 = kFALSE; + Int_t gamma0MCLabel = TrueGammaCandidate0->GetCaloPhotonMCLabel(0); // get most probable MC label + Int_t gamma0MotherLabel = -1; + Int_t motherRealLabel = -1; + + if(gamma0MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother + TParticle * gammaMC0 = (TParticle*)MCStack->Particle(gamma0MCLabel); + if (TrueGammaCandidate0->IsLargestComponentPhoton() || TrueGammaCandidate0->IsLargestComponentElectron()){ // largest component is electro magnetic + // get mother of interest (pi0 or eta) + if (TrueGammaCandidate0->IsLargestComponentPhoton()){ // for photons its the direct mother + gamma0MotherLabel=gammaMC0->GetMother(0); + motherRealLabel=gammaMC0->GetFirstMother(); + } else if (TrueGammaCandidate0->IsLargestComponentElectron()){ // for electrons its either the direct mother or for conversions the grandmother + if (TrueGammaCandidate0->IsConversion()){ + gamma0MotherLabel=MCStack->Particle(gammaMC0->GetMother(0))->GetMother(0); + motherRealLabel=MCStack->Particle(gammaMC0->GetMother(0))->GetMother(0); + } else { + gamma0MotherLabel=gammaMC0->GetMother(0); + motherRealLabel=gammaMC0->GetMother(0); + } + } + } + } + + if (!TrueGammaCandidate1->GetIsCaloPhoton()) AliFatal("CaloPhotonFlag has not been set. Aborting"); + + Int_t gamma1MCLabel = TrueGammaCandidate1->GetCaloPhotonMCLabel(0); // get most probable MC label + Int_t gamma1MotherLabel = -1; + // check if + if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother + // Daughters Gamma 1 + TParticle * gammaMC1 = (TParticle*)MCStack->Particle(gamma1MCLabel); + if (TrueGammaCandidate1->IsLargestComponentPhoton() || TrueGammaCandidate1->IsLargestComponentElectron()){ // largest component is electro magnetic + // get mother of interest (pi0 or eta) + if (TrueGammaCandidate1->IsLargestComponentPhoton()){ // for photons its the direct mother + gamma1MotherLabel=gammaMC1->GetMother(0); + } else if (TrueGammaCandidate1->IsLargestComponentElectron()){ // for electrons its either the direct mother or for conversions the grandmother + if (TrueGammaCandidate1->IsConversion()) gamma1MotherLabel=MCStack->Particle(gammaMC1->GetMother(0))->GetMother(0); + else gamma1MotherLabel=gammaMC1->GetMother(0); + } + } + } + + if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){ + if(((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 111){ + isTruePi0=kTRUE; + } + } + + if(isTruePi0){// True Pion + Pi0Candidate->SetTrueMesonValue(1); + Pi0Candidate->SetMCLabel(motherRealLabel); + fHistoTrueMotherGammaGammaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt()); + if( IsEtaPiPlPiMiPiZeroDaughter(motherRealLabel) ) { + fHistoTrueMotherGammaGammaFromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt()); + } + if( IsOmegaPiPlPiMiPiZeroDaughter(motherRealLabel) ) { + fHistoTrueMotherGammaGammaFromOmegaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt()); + } + } +} + + + //______________________________________________________________________ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessTrueNeutralPionCandidatesPureConversions(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1) { @@ -1043,6 +1365,7 @@ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessTrueNeutralPionCandidat } } } + //______________________________________________________________________ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessTrueNeutralPionCandidatesPureConversionsAOD(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1) { @@ -1143,6 +1466,134 @@ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessTrueNeutralPionCandidat } +//________________________________________________________________________ +void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessNeutralPionCandidatesMixedConvCalo(){ + + // Conversion Gammas + if(fGoodConvGammas->GetEntries()>0){ + // vertex + Double_t vertex[3] = {0}; + InputEvent()->GetPrimaryVertex()->GetXYZ(vertex); + + for(Int_t firstGammaIndex=0;firstGammaIndexGetEntries();firstGammaIndex++){ + AliAODConversionPhoton *gamma0=dynamic_cast(fGoodConvGammas->At(firstGammaIndex)); + if (gamma0==NULL) continue; + + for(Int_t secondGammaIndex=0;secondGammaIndexGetEntries();secondGammaIndex++){ + Bool_t matched = kFALSE; + AliAODConversionPhoton *gamma1=dynamic_cast(fClusterCandidates->At(secondGammaIndex)); + if (gamma1==NULL) continue; + + if (gamma1->GetIsCaloPhoton()){ + AliVCluster* cluster = fInputEvent->GetCaloCluster(gamma1->GetCaloClusterRef()); + matched = ((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->MatchConvPhotonToCluster(gamma0,cluster, fInputEvent ); + } + + AliAODConversionMother *pi0cand = new AliAODConversionMother(gamma0,gamma1); + pi0cand->SetLabels(firstGammaIndex,secondGammaIndex); + + if((((AliConversionMesonCuts*)fNeutralPionMesonCutArray->At(fiCut))->MesonIsSelected(pi0cand,kTRUE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift()))){ + if (!matched){ + fHistoGammaGammaInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt()); + if (pi0cand->M() > ((AliConversionMesonCuts*)fNeutralPionMesonCutArray->At(fiCut))->GetSelectionLow() && pi0cand->M() < ((AliConversionMesonCuts*)fNeutralPionMesonCutArray->At(fiCut))->GetSelectionHigh()){ + fNeutralPionCandidates->Add(pi0cand); + // cout << "Pi0 candidate " << pi0cand->M() << "\t" << pi0cand->Pt() << endl; + } + + if(fIsMC){ +// if(fInputEvent->IsA()==AliESDEvent::Class()) + ProcessTrueNeutralPionCandidatesMixedConvCalo(pi0cand,gamma0,gamma1); +// if(fInputEvent->IsA()==AliAODEvent::Class()) +// ProcessTrueMesonCandidatesAOD(pi0cand,gamma0,gamma1, matched); + } + } + } + } + } + } +} + +//______________________________________________________________________ +void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessTrueNeutralPionCandidatesMixedConvCalo( AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1) +{ + // Process True Mesons + AliStack *MCStack = fMCEvent->Stack(); + if(TrueGammaCandidate0->GetV0Index()GetNumberOfV0s()){ + Bool_t isTruePi0 = kFALSE; + Bool_t isTruePi0Dalitz = kFALSE; + Bool_t gamma0DalitzCand = kFALSE; + + Int_t gamma0MCLabel = TrueGammaCandidate0->GetMCParticleLabel(MCStack); + Int_t gamma0MotherLabel = -1; + Int_t motherRealLabel = -1; + if(gamma0MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother + // Daughters Gamma 0 + TParticle * negativeMC = (TParticle*)TrueGammaCandidate0->GetNegativeMCDaughter(MCStack); + TParticle * positiveMC = (TParticle*)TrueGammaCandidate0->GetPositiveMCDaughter(MCStack); + TParticle * gammaMC0 = (TParticle*)MCStack->Particle(gamma0MCLabel); + if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){ // Electrons ... + if(negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() ==5){ // ... From Conversion ... + if(gammaMC0->GetPdgCode() == 22){ // ... with Gamma Mother + gamma0MotherLabel=gammaMC0->GetFirstMother(); + motherRealLabel=gammaMC0->GetFirstMother(); + } + } + if(gammaMC0->GetPdgCode() ==111){ // Dalitz candidate + gamma0DalitzCand = kTRUE; + gamma0MotherLabel=-111; + motherRealLabel=gamma0MCLabel; + } + + } + } + + if (!TrueGammaCandidate1->GetIsCaloPhoton()) AliFatal("CaloPhotonFlag has not been set. Aborting"); + + Int_t gamma1MCLabel = TrueGammaCandidate1->GetCaloPhotonMCLabel(0); // get most probable MC label + Int_t gamma1MotherLabel = -1; + // check if + + if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother + // Daughters Gamma 1 + TParticle * gammaMC1 = (TParticle*)MCStack->Particle(gamma1MCLabel); + if (TrueGammaCandidate1->IsLargestComponentPhoton() || TrueGammaCandidate1->IsLargestComponentElectron()){ // largest component is electro magnetic + // get mother of interest (pi0 or eta) + if (TrueGammaCandidate1->IsLargestComponentPhoton()){ // for photons its the direct mother + gamma1MotherLabel=gammaMC1->GetMother(0); + } else if (TrueGammaCandidate1->IsLargestComponentElectron()){ // for electrons its either the direct mother or for conversions the grandmother + if (TrueGammaCandidate1->IsConversion()) gamma1MotherLabel=MCStack->Particle(gammaMC1->GetMother(0))->GetMother(0); + else gamma1MotherLabel=gammaMC1->GetMother(0); + } + } + } + + if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){ + if(((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 111){ + isTruePi0=kTRUE; + } + } + + if (gamma0DalitzCand ){ + if (gamma0DalitzCand && gamma0MCLabel >=0 && gamma0MCLabel==gamma1MotherLabel){ + if (gamma0MotherLabel == -111) isTruePi0Dalitz = kTRUE; + } + } + + if(isTruePi0 || isTruePi0Dalitz ){ + Pi0Candidate->SetTrueMesonValue(1); + Pi0Candidate->SetMCLabel(motherRealLabel); + fHistoTrueMotherGammaGammaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt()); + if( IsEtaPiPlPiMiPiZeroDaughter(motherRealLabel) ) { + fHistoTrueMotherGammaGammaFromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt()); + } + if( IsOmegaPiPlPiMiPiZeroDaughter(motherRealLabel) ) { + fHistoTrueMotherGammaGammaFromOmegaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt()); + } + } + } +} + + //________________________________________________________________________ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessPionCandidates(){ @@ -1243,13 +1694,15 @@ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessPionCandidates(){ } } - AliAODConversionPhoton *vParticle = new AliAODConversionPhoton(virtualPhoton); //To Apply PsiPairCut + AliAODConversionPhoton *vParticle = new AliAODConversionPhoton(virtualPhoton); //To apply mass 2 pion mass cut if (((AliPrimaryPionCuts*)fPionCutArray->At(fiCut))->DoMassCut()){ if (vParticle->GetMass() < ((AliPrimaryPionCuts*)fPionCutArray->At(fiCut))->GetMassCut()){ fGoodVirtualParticles->Add( vParticle ); + fHistoPionPionInvMassPt[fiCut]->Fill( vParticle->GetMass(),vParticle->Pt()); } } else { fGoodVirtualParticles->Add( vParticle ); + fHistoPionPionInvMassPt[fiCut]->Fill( vParticle->GetMass(),vParticle->Pt()); } Double_t clsToFPos = -1.0; @@ -1260,7 +1713,7 @@ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessPionCandidates(){ Float_t dcaToVertexXYNeg = -1.0; Float_t dcaToVertexZNeg = -1.0; - fHistoPionPionInvMassPt[fiCut]->Fill( vParticle->GetMass(),vParticle->Pt()); + if ( fDoMesonQA ) { clsToFPos = ((AliPrimaryPionCuts*)fPionCutArray->At(fiCut))->GetNFindableClustersTPC(posPionCandidate); @@ -1307,18 +1760,35 @@ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessPionCandidates(){ if (fMCEvent){ if (fPositiveMCParticle && fNegativeMCParticle ) { - if(TMath::Abs(fNegativeMCParticle->GetPdgCode())==211 && TMath::Abs(fPositiveMCParticle->GetPdgCode())==211){ // Pions ... - fHistoTruePionPionInvMassPt[fiCut]->Fill(vParticle->GetMass(),vParticle->Pt()); - if (motherlabeln == motherlabelp){ - fHistoTruePionPionFromSameMotherInvMassPt[fiCut]->Fill(vParticle->GetMass(),vParticle->Pt()); - if( IsEtaPiPlPiMiPiZeroDaughter(labeln) ) { //|| IsOmegaPiPlPiMiPiZeroDaughter(labeln) - fHistoTruePionPionFromEtaInvMassPt[fiCut]->Fill(vParticle->GetMass(),vParticle->Pt()); + if (((AliPrimaryPionCuts*)fPionCutArray->At(fiCut))->DoMassCut()){ + if (vParticle->GetMass() < ((AliPrimaryPionCuts*)fPionCutArray->At(fiCut))->GetMassCut()){ + if(TMath::Abs(fNegativeMCParticle->GetPdgCode())==211 && TMath::Abs(fPositiveMCParticle->GetPdgCode())==211){ // Pions ... + fHistoTruePionPionInvMassPt[fiCut]->Fill(vParticle->GetMass(),vParticle->Pt()); + if (motherlabeln == motherlabelp){ + fHistoTruePionPionFromSameMotherInvMassPt[fiCut]->Fill(vParticle->GetMass(),vParticle->Pt()); + if( IsEtaPiPlPiMiPiZeroDaughter(labeln) ) { //|| IsOmegaPiPlPiMiPiZeroDaughter(labeln) + fHistoTruePionPionFromEtaInvMassPt[fiCut]->Fill(vParticle->GetMass(),vParticle->Pt()); + } + if( IsOmegaPiPlPiMiPiZeroDaughter(labeln) ) { //|| + fHistoTruePionPionFromOmegaInvMassPt[fiCut]->Fill(vParticle->GetMass(),vParticle->Pt()); + } + } } - if( IsOmegaPiPlPiMiPiZeroDaughter(labeln) ) { //|| - fHistoTruePionPionFromOmegaInvMassPt[fiCut]->Fill(vParticle->GetMass(),vParticle->Pt()); + } + } else { + if(TMath::Abs(fNegativeMCParticle->GetPdgCode())==211 && TMath::Abs(fPositiveMCParticle->GetPdgCode())==211){ // Pions ... + fHistoTruePionPionInvMassPt[fiCut]->Fill(vParticle->GetMass(),vParticle->Pt()); + if (motherlabeln == motherlabelp){ + fHistoTruePionPionFromSameMotherInvMassPt[fiCut]->Fill(vParticle->GetMass(),vParticle->Pt()); + if( IsEtaPiPlPiMiPiZeroDaughter(labeln) ) { //|| IsOmegaPiPlPiMiPiZeroDaughter(labeln) + fHistoTruePionPionFromEtaInvMassPt[fiCut]->Fill(vParticle->GetMass(),vParticle->Pt()); + } + if( IsOmegaPiPlPiMiPiZeroDaughter(labeln) ) { //|| + fHistoTruePionPionFromOmegaInvMassPt[fiCut]->Fill(vParticle->GetMass(),vParticle->Pt()); + } } } - } + } } } @@ -1347,27 +1817,43 @@ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessMCParticles(){ } if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack,fInputEvent)){ - // find MC photons - if(((AliConversionPhotonCuts*)fGammaCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kFALSE)){ - fHistoMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma - if(particle->GetMother(0) >-1){ - if (fMCStack->Particle(particle->GetMother(0))->GetPdgCode() ==111){ - if (fMCStack->Particle(particle->GetMother(0))->GetMother(0) > -1){ - if ( fMCStack->Particle((fMCStack->Particle(particle->GetMother(0)))->GetMother(0))->GetPdgCode() == 221 || - fMCStack->Particle((fMCStack->Particle(particle->GetMother(0)))->GetMother(0))->GetPdgCode() == 223 ){ - if ( fMCStack->Particle(particle->GetMother(0))->GetNDaughters()==3 ) - fHistoMCGammaFromNeutralMesonPt[fiCut]->Fill(particle->Pt()); // All photons from eta or omega via pi0 + if (fNeutralPionMode < 2){ + if(((AliConversionPhotonCuts*)fGammaCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kFALSE)){ + fHistoMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma + if(particle->GetMother(0) >-1){ + if (fMCStack->Particle(particle->GetMother(0))->GetPdgCode() ==111){ + if (fMCStack->Particle(particle->GetMother(0))->GetMother(0) > -1){ + if ( fMCStack->Particle((fMCStack->Particle(particle->GetMother(0)))->GetMother(0))->GetPdgCode() == 221 || + fMCStack->Particle((fMCStack->Particle(particle->GetMother(0)))->GetMother(0))->GetPdgCode() == 223 ){ + if ( fMCStack->Particle(particle->GetMother(0))->GetNDaughters()==3 ) + fHistoMCGammaFromNeutralMesonPt[fiCut]->Fill(particle->Pt()); // All photons from eta or omega via pi0 + } } } - } - } + } + } + } else if (fNeutralPionMode == 2){ + if(((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->ClusterIsSelectedMC(particle,fMCStack)){ + fHistoMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma + if(particle->GetMother(0) >-1){ + if (fMCStack->Particle(particle->GetMother(0))->GetPdgCode() ==111){ + if (fMCStack->Particle(particle->GetMother(0))->GetMother(0) > -1){ + if ( fMCStack->Particle((fMCStack->Particle(particle->GetMother(0)))->GetMother(0))->GetPdgCode() == 221 || + fMCStack->Particle((fMCStack->Particle(particle->GetMother(0)))->GetMother(0))->GetPdgCode() == 223 ){ + if ( fMCStack->Particle(particle->GetMother(0))->GetNDaughters()==3 ) + fHistoMCGammaFromNeutralMesonPt[fiCut]->Fill(particle->Pt()); // All photons from eta or omega via pi0 + } + } + } + } + } + } + if (fNeutralPionMode < 2){ + if (((AliConversionPhotonCuts*)fGammaCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kTRUE)){ + fHistoMCConvGammaPt[fiCut]->Fill(particle->Pt()); + } // Converted MC Gamma } - - if(((AliConversionPhotonCuts*)fGammaCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kTRUE)){ - fHistoMCConvGammaPt[fiCut]->Fill(particle->Pt()); - } // Converted MC Gamma - if(((AliPrimaryPionCuts*)fPionCutArray->At(fiCut))->PionIsSelectedMC(i,fMCStack)){ if( particle->GetPdgCode() == 211){ fHistoMCAllPosPionsPt[fiCut]->Fill(particle->Pt()); // All pos pions @@ -1406,15 +1892,28 @@ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessMCParticles(){ TParticle *neutPion = fMCStack->Particle(labelNeutPion); TParticle *gamma1 = fMCStack->Particle(neutPion->GetDaughter(0)); TParticle *gamma2 = fMCStack->Particle(neutPion->GetDaughter(1)); - if( - ((AliConversionPhotonCuts*)fGammaCutArray->At(fiCut))->PhotonIsSelectedMC(gamma1,fMCStack,kFALSE) && // test first daugther of pi0 - ((AliConversionPhotonCuts*)fGammaCutArray->At(fiCut))->PhotonIsSelectedMC(gamma2,fMCStack,kFALSE) && // test second daughter of pi0 - ((AliPrimaryPionCuts*)fPionCutArray->At(fiCut))->PionIsSelectedMC(labelNegPion,fMCStack) && // test negative pion - ((AliPrimaryPionCuts*)fPionCutArray->At(fiCut))->PionIsSelectedMC(labelPosPion,fMCStack) // test positive pion - ) { - if(particle->GetPdgCode() == 221) fHistoMCEtaPiPlPiMiPiZeroInAccPt[fiCut]->Fill(particle->Pt(), weighted ); // MC Eta pi+ pi- pi0 with gamma's and e+e- in acc - if(particle->GetPdgCode() == 223) fHistoMCOmegaPiPlPiMiPiZeroInAccPt[fiCut]->Fill(particle->Pt(), weighted ); // MC Omega pi+ pi- pi0 with gamma's and e+e- in acc - } + if (fNeutralPionMode == 0){ + if( + ((AliConversionPhotonCuts*)fGammaCutArray->At(fiCut))->PhotonIsSelectedMC(gamma1,fMCStack,kFALSE) && // test first daugther of pi0 + ((AliConversionPhotonCuts*)fGammaCutArray->At(fiCut))->PhotonIsSelectedMC(gamma2,fMCStack,kFALSE) && // test second daughter of pi0 + ((AliPrimaryPionCuts*)fPionCutArray->At(fiCut))->PionIsSelectedMC(labelNegPion,fMCStack) && // test negative pion + ((AliPrimaryPionCuts*)fPionCutArray->At(fiCut))->PionIsSelectedMC(labelPosPion,fMCStack) // test positive pion + ) { + if(particle->GetPdgCode() == 221) fHistoMCEtaPiPlPiMiPiZeroInAccPt[fiCut]->Fill(particle->Pt(), weighted ); // MC Eta pi+ pi- pi0 with gamma's and e+e- in acc + if(particle->GetPdgCode() == 223) fHistoMCOmegaPiPlPiMiPiZeroInAccPt[fiCut]->Fill(particle->Pt(), weighted ); // MC Omega pi+ pi- pi0 with gamma's and e+e- in acc + } + } else if (fNeutralPionMode == 2){ + if( + ((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->ClusterIsSelectedMC(gamma1,fMCStack) && // test first daugther of pi0 + ((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->ClusterIsSelectedMC(gamma2,fMCStack) && // test second daughter of pi0 + ((AliPrimaryPionCuts*)fPionCutArray->At(fiCut))->PionIsSelectedMC(labelNegPion,fMCStack) && // test negative pion + ((AliPrimaryPionCuts*)fPionCutArray->At(fiCut))->PionIsSelectedMC(labelPosPion,fMCStack) // test positive pion + ) { + if(particle->GetPdgCode() == 221) fHistoMCEtaPiPlPiMiPiZeroInAccPt[fiCut]->Fill(particle->Pt(), weighted ); // MC Eta pi+ pi- pi0 with gamma's and e+e- in acc + if(particle->GetPdgCode() == 223) fHistoMCOmegaPiPlPiMiPiZeroInAccPt[fiCut]->Fill(particle->Pt(), weighted ); // MC Omega pi+ pi- pi0 with gamma's and e+e- in acc + } + } + } } } @@ -1448,7 +1947,8 @@ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::CalculateMesonCandidates(){ if( ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){ mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fNumberOfESDTracks); } else { - mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGoodGammas->GetEntries()); + if (fNeutralPionMode < 2) mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGoodConvGammas->GetEntries()); + else mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fClusterCandidates->GetEntries()); } fHistoMotherInvMassPt[fiCut]->Fill(mesoncand->M(),mesoncand->Pt()); @@ -1476,7 +1976,8 @@ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::CalculateBackground(){ if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){ mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fNumberOfESDTracks); } else { - mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGoodGammas->GetEntries()); + if (fNeutralPionMode < 2) mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGoodConvGammas->GetEntries()); + else mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fClusterCandidates->GetEntries()); } Int_t method = 1; @@ -1638,8 +2139,9 @@ void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::UpdateEventByEventData(){ if(fNeutralPionCandidates->GetEntries() >0 ){ if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){ fBGHandler[fiCut]->AddMesonEvent(fNeutralPionCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fV0Reader->GetNumberOfPrimaryTracks(),0); - } else{ // means we use #V0s for multiplicity - fBGHandler[fiCut]->AddMesonEvent(fNeutralPionCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fGoodGammas->GetEntries(),0); + } else { // means we use #V0s for multiplicity + if (fNeutralPionMode < 2) fBGHandler[fiCut]->AddMesonEvent(fNeutralPionCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fGoodConvGammas->GetEntries(),0); + else fBGHandler[fiCut]->AddMesonEvent(fNeutralPionCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fClusterCandidates->GetEntries(),0); } } } else if ( method == 2 ){ diff --git a/PWGGA/GammaConv/AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero.h b/PWGGA/GammaConv/AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero.h index a99d92ec3cd..88dc959a810 100644 --- a/PWGGA/GammaConv/AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero.h +++ b/PWGGA/GammaConv/AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero.h @@ -11,6 +11,7 @@ #include "AliPrimaryPionSelector.h" #include "AliConversionMesonCuts.h" #include "AliConvEventCuts.h" +#include "AliCaloPhotonCuts.h" #include "AliGammaConversionAODBGHandler.h" #include "TProfile2D.h" @@ -20,7 +21,6 @@ class AliESDEvent; class AliESDtrack; class AliESDtrackCuts; class AliESDpidCuts; -class AliV0Reader; class AliTriggerAnalysis; class AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero: public AliAnalysisTaskSE @@ -38,7 +38,6 @@ class AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero: public AliAnalysisTaskSE void SetMoveParticleAccordingToVertex(Bool_t flag){fMoveParticleAccordingToVertex = flag;} - void SetIsHeavyIon(Int_t flag){ if (flag == 1 || flag ==2 ){ fIsHeavyIon = 1; @@ -48,37 +47,47 @@ class AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero: public AliAnalysisTaskSE } void SetIsMC(Bool_t isMC){fIsMC=isMC;} - void SetConversionCutList(Int_t nCuts, TList *CutArray){ - fnCuts= nCuts; - fGammaCutArray = CutArray; - } - void SetEventCutList(Int_t nCuts, TList *CutArray){ - fnCuts= nCuts; + void SetEventCutList(Int_t nCuts, TList *CutArray){ + fnCuts= nCuts; fEventCutArray = CutArray; } - - void SetPionCutList(TList *CutArray){ - fPionCutArray = CutArray; - } - void SetNeutralPionCutList(TList *CutArray){ - fNeutralPionMesonCutArray = CutArray; - } - void SetMesonCutList(TList *CutArray){ - fMesonCutArray = CutArray; - } + void SetConversionCutList(TList *CutArray){ fGammaCutArray = CutArray;} + void SetClusterCutList(TList *CutArray){ fClusterCutArray = CutArray;} + void SetPionCutList(TList *CutArray){ fPionCutArray = CutArray;} + void SetNeutralPionCutList(TList *CutArray){ fNeutralPionMesonCutArray = CutArray; } + void SetMesonCutList(TList *CutArray){ fMesonCutArray = CutArray; } void SetDoMesonQA(Bool_t flag){ fDoMesonQA = flag; } + void SetNeutralPionMode(Int_t mode){fNeutralPionMode = mode; } private: void InitBack(); - void ProcessPhotonCandidates(); - void ProcessTruePhotonCandidates(AliAODConversionPhoton*); + + // routines for photon selection from conversions + void ProcessConversionPhotonCandidates(); + void ProcessTrueConversionPhotonCandidates(AliAODConversionPhoton*); + + // routines for photon selection from clusters + void ProcessCaloPhotonCandidates(); + void ProcessTrueCaloPhotonCandidates(AliAODConversionPhoton *TruePhotonCandidate); + void ProcessTrueMesonCandidates(AliAODConversionMother *Pi0Candidate, AliAODConversionMother *TrueNeutralPionCandidate, AliAODConversionPhoton *TrueVirtualGammaCandidate); void MoveParticleAccordingToVertex(AliAODConversionMother* particle,const AliGammaConversionAODBGHandler::GammaConversionVertex *vertex); - void ProcessNeutralPionCandidatesPureConversions(); + + // routines for neutral pion candidates from pure conversion + void ProcessNeutralPionCandidatesPureConversions(); void ProcessTrueNeutralPionCandidatesPureConversions(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1); void ProcessTrueNeutralPionCandidatesPureConversionsAOD(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1); + + // routines for neutral pion candidates from pure calo + void ProcessNeutralPionCandidatesPureCalo(); + void ProcessTrueNeutralPionCandidatesPureCalo(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1); + + // routines for neutral pion candidates from mixed conv + calo + void ProcessNeutralPionCandidatesMixedConvCalo(); + void ProcessTrueNeutralPionCandidatesMixedConvCalo( AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1); + void ProcessPionCandidates(); void ProcessMCParticles(); void CalculateMesonCandidates(); @@ -90,75 +99,82 @@ class AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero: public AliAnalysisTaskSE Bool_t IsOmegaPiPlPiMiPiZeroDaughter( Int_t label ) const; Bool_t GammaIsNeutralMesonPiPlPiMiPiZeroDaughter( Int_t label ) const; - AliV0ReaderV1 *fV0Reader; // - AliPrimaryPionSelector *fPionSelector; // - AliGammaConversionAODBGHandler **fBGHandler; // - AliESDEvent *fESDEvent; // - AliMCEvent *fMCEvent; // - AliStack *fMCStack; // - TList **fCutFolder; // - TList **fESDList; // - TList **fBackList; // - TList **fMotherList; // - TList **fTrueList; // - TList **fMCList; // - TList *fOutputContainer; // - TClonesArray *fReaderGammas; // - vector fSelectorNegPionIndex; // - vector fSelectorPosPionIndex; // - TList *fGoodGammas; // - TList *fNeutralPionCandidates; // - TList *fGoodVirtualParticles; // - TList *fEventCutArray; // - TList *fGammaCutArray; // - TList *fPionCutArray; // - TList *fNeutralPionMesonCutArray; // - TList *fMesonCutArray; // - AliConvEventCuts *fEventCuts; // - AliConversionPhotonCuts *fConversionCuts; // + AliV0ReaderV1 *fV0Reader; // V0Reader for basic conversion photon selection + AliPrimaryPionSelector *fPionSelector; // primary charged pion selector, basic selection of pi+,pi- + AliGammaConversionAODBGHandler **fBGHandler; // BG handler + AliESDEvent *fESDEvent; // current event + AliMCEvent *fMCEvent; // current MC event + AliStack *fMCStack; // current MC stack + TList **fCutFolder; // list of output folders with main cut name + TList **fESDList; // list with main output histograms for data + TList **fBackList; // list with THnSparseF for BG + TList **fMotherList; // list with THnSparseF for FG + TList **fTrueList; // list with validated reconstructed MC histograms + TList **fMCList; // list with pure MC histograms + TList *fOutputContainer; // output container + TClonesArray *fReaderGammas; // array with photon from fV0Reader + vector fSelectorNegPionIndex; // array with pion indices for negative pions from fPionSelector + vector fSelectorPosPionIndex; // array with pion indices for positive pions from fPionSelector + TList *fGoodConvGammas; // good conv gammas after selection + TList *fClusterCandidates; //! good calo gammas after selection + TList *fNeutralPionCandidates; // good neutral pion candidates + TList *fGoodVirtualParticles; // combination of pi+pi- candidates + TList *fEventCutArray; // array with event cuts + TList *fGammaCutArray; // array with Conversion Cuts + TList *fClusterCutArray; // array with Cluster Cuts + TList *fPionCutArray; // array with charged pion cuts + TList *fNeutralPionMesonCutArray; // array with neutral pion cuts + TList *fMesonCutArray; // array with neutral meson cuts + AliConvEventCuts *fEventCuts; // current event cuts + AliConversionPhotonCuts *fConversionCuts; // current conversion cuts + AliCaloPhotonCuts *fClusterCuts; // current cluster cuts // reconstructed particles - TH1F **fHistoConvGammaPt; // - TH1F **fHistoConvGammaEta; // - TH1F **fHistoNegPionPt; // - TH1F **fHistoPosPionPt; // - TH1F **fHistoNegPionPhi; // - TH1F **fHistoPosPionPhi; // - TH1F **fHistoNegPionEta; // - TH1F **fHistoPosPionEta; // - TH2F **fHistoNegPionClsTPC; // - TH2F **fHistoPosPionClsTPC; // - TH2F **fHistoPionDCAxy; // - TH2F **fHistoPionDCAz; // - TH2F **fHistoPionTPCdEdxNSigma; // - TH2F **fHistoPionTPCdEdx; // - TH2F **fHistoPionPionInvMassPt; // - TH2F **fHistoGammaGammaInvMassPt; // - TH2F **fHistoMotherInvMassPt; // - THnSparseF **fTHnSparseMotherInvMassPtZM; // - TH2F **fHistoMotherBackInvMassPt; // - THnSparseF **fTHnSparseMotherBackInvMassPtZM; // + TH1F **fHistoConvGammaPt; // array of histos of conversion photon, pt + TH1F **fHistoConvGammaEta; // array of histos of conversion photon, eta + TH1F **fHistoClusterGammaPt; // array of histos of Cluster photon, pt + TH1F **fHistoClusterGammaEta; // array of histos of Cluster photon, eta + TH1F **fHistoNegPionPt; // array of histos of negative pion, pt + TH1F **fHistoPosPionPt; // array of histos of positive pion, pt + TH1F **fHistoNegPionPhi; // array of histos of negative pion, phi + TH1F **fHistoPosPionPhi; // array of histos of positive pion, phi + TH1F **fHistoNegPionEta; // array of histos of negative pion, eta + TH1F **fHistoPosPionEta; // array of histos of positive pion, eta + TH2F **fHistoNegPionClsTPC; // array of histos of negative pion, findable tpc cluster, pT + TH2F **fHistoPosPionClsTPC; // array of histos of positive pion, findable tpc cluster, pT + TH2F **fHistoPionDCAxy; // array of histos of pion, dca_xy, pT + TH2F **fHistoPionDCAz; // array of histos of pion, dca_z, pT + TH2F **fHistoPionTPCdEdxNSigma; // array of histos of pion, p, TPC nSigma dEdx pion + TH2F **fHistoPionTPCdEdx; // array of histos of pion, p, TPC dEdx + TH2F **fHistoPionPionInvMassPt; // array of histos of pion pion, invMass, pT_{pi+pi-} + TH2F **fHistoGammaGammaInvMassPt; // array of histos of gamma-gamma, invMass, pT_{gamma gamma} + TH2F **fHistoMotherInvMassPt; // array of histos of pi+pi-pi0 same event, invMass, pT_{pi+pi-pi0} + THnSparseF **fTHnSparseMotherInvMassPtZM; // array of THnSparseF of pi+pi-pi0 same event, invMass, pT_{pi+pi-pi0}, Z, M + TH2F **fHistoMotherBackInvMassPt; // array of histos of pi+pi-pi0 mixed event, invMass, pT_{pi+pi-pi0} + THnSparseF **fTHnSparseMotherBackInvMassPtZM; // array of THnSparseF of pi+pi-pi0 mixed event, invMass, pT_{pi+pi-pi0}, Z, M // pure MC properties - TH1F **fHistoMCAllGammaPt; // - TH1F **fHistoMCConvGammaPt; // - TH1F **fHistoMCAllPosPionsPt; // - TH1F **fHistoMCAllNegPionsPt; // - TH1F **fHistoMCGammaFromNeutralMesonPt; // - TH1F **fHistoMCPosPionsFromNeutralMesonPt; // - TH1F **fHistoMCNegPionsFromNeutralMesonPt; // - TH1F **fHistoMCEtaPiPlPiMiPiZeroPt; // - TH1F **fHistoMCEtaPiPlPiMiPiZeroInAccPt; // - TH1F **fHistoMCOmegaPiPlPiMiPiZeroPt; // - TH1F **fHistoMCOmegaPiPlPiMiPiZeroInAccPt; // + TH1F **fHistoMCAllGammaPt; // array of histos of all produced gammas in the specified y range + TH1F **fHistoMCConvGammaPt; // array of histos of all converted gammas in the specified y range + TH1F **fHistoMCAllPosPionsPt; // array of histos with all produced primary positive pions in the specified y range + TH1F **fHistoMCAllNegPionsPt; // array of histos with all produced primary negative pions in the specified y range + TH1F **fHistoMCGammaFromNeutralMesonPt; // array of histos of all produced gammas from omega or eta via pi+pi-pi0 in the specified y range/ + TH1F **fHistoMCPosPionsFromNeutralMesonPt; // array of histos of all produced positive pions from omega or eta via pi+pi-pi0 in the specified y range/ + TH1F **fHistoMCNegPionsFromNeutralMesonPt; // array of histos of all produced negative pions from omega or eta via pi+pi-pi0 in the specified y range/ + TH1F **fHistoMCEtaPiPlPiMiPiZeroPt; // array of histos of produced etas via pi+pi-pi0 in the specified y range + TH1F **fHistoMCEtaPiPlPiMiPiZeroInAccPt; // array of histos of produced etas via pi+pi-pi0 in the specified y range, with decay products in respective y, eta ranges + TH1F **fHistoMCOmegaPiPlPiMiPiZeroPt; // array of histos of produced omegas via pi+pi-pi0 in the specified y range + TH1F **fHistoMCOmegaPiPlPiMiPiZeroInAccPt; // array of histos of produced omegas via pi+pi-pi0 in the specified y range, with decay products in respective y, eta ranges // reconstructed particles MC validated TH2F **fHistoTrueMotherPiPlPiMiPiZeroInvMassPt; // histos with reconstructed validated eta or omega, inv mass, pT TH2F **fHistoTrueMotherGammaGammaInvMassPt; // histos with reconstructed validated pi0, inv mass, pT TH2F **fHistoTrueMotherGammaGammaFromEtaInvMassPt; // histos with reconstructed validated pi0, inv mass, pT TH2F **fHistoTrueMotherGammaGammaFromOmegaInvMassPt; // histos with reconstructed validated pi0, inv mass, pT - TH1F **fHistoTrueConvGammaPt; // histos with reconstructed validated gamma, pT - TH1F **fHistoTrueConvGammaFromNeutralMesonPt; // histos with reconstructed validated gamma from eta or omega via pi0, pT + TH1F **fHistoTrueConvGammaPt; // histos with reconstructed validated conv gamma, pT + TH1F **fHistoTrueConvGammaFromNeutralMesonPt; // histos with reconstructed validated conv gamma from eta or omega via pi0, pT + TH1F **fHistoTrueClusterGammaPt; // histos with reconstructed validated cluster gamma, pT + TH1F **fHistoTrueClusterGammaFromNeutralMesonPt; // histos with reconstructed validated cluster gamma from eta or omega via pi0, pT TH1F **fHistoTruePosPionPt; // histos with reconstructed validated positive pion, pT TH1F **fHistoTruePosPionFromNeutralMesonPt; // histos with reconstructed validated positive pion from eta or omega, pT TH1F **fHistoTrueNegPionPt; // histos with reconstructed validated negative pion, pT @@ -182,12 +198,13 @@ class AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero: public AliAnalysisTaskSE Bool_t fDoMesonQA; // Flag for switching on small meson QA Bool_t fIsFromMBHeader; // Flag for particle whether it belongs to accepted header Bool_t fIsMC; // Flag for MC + Int_t fNeutralPionMode; // Flag how neutral pion is reconstructed 0=PCM-PCM, 1=PCM-Calo, 2=Calo-Calo private: AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero( const AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero& ); // Not implemented AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero& operator=( const AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero& ); // Not implemented - ClassDef( AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero, 1 ); + ClassDef( AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero, 2 ); }; #endif // ALIANALYSISTASKNEUTRALMESONTOPIPLPIMIPIZERO_H diff --git a/PWGGA/GammaConv/AliCaloPhotonCuts.cxx b/PWGGA/GammaConv/AliCaloPhotonCuts.cxx index d1cfa29a238..3b28168e592 100644 --- a/PWGGA/GammaConv/AliCaloPhotonCuts.cxx +++ b/PWGGA/GammaConv/AliCaloPhotonCuts.cxx @@ -43,7 +43,7 @@ #include "AliAODMCHeader.h" #include "AliPicoTrack.h" #include "AliEMCALRecoUtils.h" -#include "AliPHOSGeoUtils.h" +#include "AliTrackerBase.h" class iostream; @@ -118,6 +118,8 @@ AliCaloPhotonCuts::AliCaloPhotonCuts(const char *name,const char *title) : fHistDistanceToBadChannelAfterAcc(NULL), fHistClusterRBeforeQA(NULL), fHistClusterRAfterQA(NULL), + fHistClusterdEtadPhiBeforeQA(NULL), + fHistClusterdEtadPhiAfterQA(NULL), fHistClusterTimevsEBeforeQA(NULL), fHistClusterTimevsEAfterQA(NULL), fHistExoticCellBeforeQA(NULL), @@ -185,8 +187,10 @@ AliCaloPhotonCuts::AliCaloPhotonCuts(const AliCaloPhotonCuts &ref) : fHistClusterEtavsPhiAfterQA(NULL), fHistDistanceToBadChannelBeforeAcc(NULL), fHistDistanceToBadChannelAfterAcc(NULL), - fHistClusterRBeforeQA(NULL), - fHistClusterRAfterQA(NULL), + fHistClusterRBeforeQA(NULL), + fHistClusterRAfterQA(NULL), + fHistClusterdEtadPhiBeforeQA(NULL), + fHistClusterdEtadPhiAfterQA(NULL), fHistClusterTimevsEBeforeQA(NULL), fHistClusterTimevsEAfterQA(NULL), fHistExoticCellBeforeQA(NULL), @@ -290,10 +294,14 @@ void AliCaloPhotonCuts::InitCutHistograms(TString name){ fHistograms->Add(fHistDistanceToBadChannelAfterAcc); // Cluster quality related histograms - fHistClusterRBeforeQA = new TH1F(Form("R_Cluster_beforeClusterQA %s",GetCutNumber().Data()),"R of cluster",200,400,500); - fHistograms->Add(fHistClusterRBeforeQA); - fHistClusterRAfterQA = new TH1F(Form("R_Cluster_afterClusterQA %s",GetCutNumber().Data()),"R of cluster_matched",200,400,500); - fHistograms->Add(fHistClusterRAfterQA); + fHistClusterRBeforeQA = new TH1F(Form("R_Cluster_beforeClusterQA %s",GetCutNumber().Data()),"R of cluster",200,400,500); + fHistograms->Add(fHistClusterRBeforeQA); + fHistClusterRAfterQA = new TH1F(Form("R_Cluster_afterClusterQA %s",GetCutNumber().Data()),"R of cluster_matched",200,400,500); + fHistograms->Add(fHistClusterRAfterQA); + fHistClusterdEtadPhiBeforeQA=new TH2F(Form("dEtaVsdPhi_beforeClusterQA %s",GetCutNumber().Data()),"dEtaVsdPhi_beforeClusterQA",240,-0.3,0.3,240,-0.3,0.3); + fHistograms->Add(fHistClusterdEtadPhiBeforeQA); + fHistClusterdEtadPhiAfterQA=new TH2F(Form("dEtaVsdPhi_afterClusterQA %s",GetCutNumber().Data()),"dEtaVsdPhi_afterClusterQA",240,-0.3,0.3,240,-0.3,0.3); + fHistograms->Add(fHistClusterdEtadPhiAfterQA); fHistClusterTimevsEBeforeQA=new TH2F(Form("ClusterTimeVsE_beforeClusterQA %s",GetCutNumber().Data()),"ClusterTimeVsE_beforeClusterQA",400,-10e-6,10e-6,100,0.,40); fHistograms->Add(fHistClusterTimevsEBeforeQA); fHistClusterTimevsEAfterQA=new TH2F(Form("ClusterTimeVsE_afterClusterQA %s",GetCutNumber().Data()),"ClusterTimeVsE_afterClusterQA",400,-10e-6,10e-6,100,0.,40); @@ -686,17 +694,10 @@ Bool_t AliCaloPhotonCuts::MatchConvPhotonToCluster(AliAODConversionPhoton* convP } } -//cout << "Got the event" << endl; - Double_t vertex[3] = {0,0,0}; event->GetPrimaryVertex()->GetXYZ(vertex); if(!cluster->IsEMCAL() && !cluster->IsPHOS()){AliError("Cluster is neither EMCAL nor PHOS, returning"); return kFALSE;} - // TLorentzvector with cluster - TLorentzVector clusterVector; - cluster->GetMomentum(clusterVector,vertex); - Double_t etaCluster = clusterVector.Eta(); - Double_t phiCluster = clusterVector.Phi(); Float_t clusterPosition[3] = {0,0,0}; cluster->GetPosition(clusterPosition); @@ -726,66 +727,69 @@ Bool_t AliCaloPhotonCuts::MatchConvPhotonToCluster(AliAODConversionPhoton* convP } } } -//cout << "found track " << endl; -// AliVTrack *outTrack = 0x00; -// if (esdev) -// outTrack = new AliESDtrack(*((AliESDtrack*)inTrack)); -// else -// outTrack = new AliAODTrack(*((AliAODTrack*)inTrack)); - - Bool_t propagated = kFALSE; - TVector3 VecPHOS(0,0,0); - //Double_t EMCALpos[3]={0,0,0}; - - if(cluster->IsEMCAL()){ - //AliExternalTrackParam t; - //t.CopyFromVTrack(inTrack); - //Double_t b[3]={0,0,0}; - //t.GetBxByBz(b); - //propagated = t.PropagateToBxByBz(clusterR,b); - //t.GetXYZ(EMCALpos); - propagated = AliEMCALRecoUtils::ExtrapolateTrackToEMCalSurface(inTrack, clusterR, 0.000510999, 20, 0.05); - } - if(cluster->IsPHOS()){ - AliExternalTrackParam t;// = inTrack->GetOuterParam(); - t.CopyFromVTrack(inTrack); - Double_t b[3]={0,0,0}; - Double_t PHOSpos[3]={0,0,0}; - t.GetBxByBz(b); - propagated = t.PropagateToBxByBz(clusterR,b); - t.GetXYZ(PHOSpos); - VecPHOS.SetXYZ(PHOSpos[0],PHOSpos[1],PHOSpos[2]); - } - - if (propagated){ -//cout << "Track "<< i << "\t"<< inTrack->GetTrackPhiOnEMCal() << "\t" << inTrack->GetTrackEtaOnEMCal() << endl; -//cout << "Cluster " << phiCluster << "\t" << etaCluster << endl; - Double_t dPhi = 0; - Double_t dEta = 0; - if(cluster->IsEMCAL()){ - //TVector3 VecEMCAL(EMCALpos[0],EMCALpos[1],EMCALpos[2]); - //dPhi=TMath::Abs(phiCluster-VecEMCAL.Phi()); - //dEta=TMath::Abs(etaCluster-VecEMCAL.Eta()); - dPhi = TMath::Abs(phiCluster-inTrack->GetTrackPhiOnEMCal()); - dEta = TMath::Abs(etaCluster-inTrack->GetTrackEtaOnEMCal()); - } - if(cluster->IsPHOS()){ - dPhi = TMath::Abs(phiCluster-VecPHOS.Phi()); - dEta = TMath::Abs(etaCluster-VecPHOS.Eta()); - } - - Double_t dR2 = dPhi*dPhi + dEta*dEta; -//cout << "distance to cluster \t" << TMath::Sqrt(dR2) << endl; - if (fHistDistanceTrackToClusterBeforeQA)fHistDistanceTrackToClusterBeforeQA->Fill(TMath::Sqrt(dR2)); - if(dR2 < fMinDistTrackToCluster*fMinDistTrackToCluster){ - matched = kTRUE; - if (fHistDistanceTrackToClusterAfterQA)fHistDistanceTrackToClusterAfterQA->Fill(TMath::Sqrt(dR2)); - if (fHistClusterRAfterQA) fHistClusterRAfterQA->Fill(clusterR); - } - } - } + if( inTrack->Pt() < 0.005 ) continue; + + AliESDtrack *esdt = dynamic_cast(inTrack); + AliAODTrack *aodt = 0; + if (!esdt) { + aodt = dynamic_cast(inTrack); + if (!aodt){AliError("Track is neither ESD nor AOD, continue"); continue;} + } + + AliExternalTrackParam *trackParam = 0; + if (esdt) { + const AliExternalTrackParam *in = esdt->GetInnerParam(); + if (!in){AliError("Could not get InnerParam of Track, continue"); continue;} + trackParam = new AliExternalTrackParam(*in); + } else { + Double_t xyz[3] = {0}, pxpypz[3] = {0}, cv[21] = {0}; + aodt->PxPyPz(pxpypz); + aodt->XvYvZv(xyz); + aodt->GetCovarianceXYZPxPyPz(cv); + trackParam = new AliExternalTrackParam(xyz,pxpypz,cv,aodt->Charge()); + } + + Bool_t propagated = kFALSE; + AliExternalTrackParam emcParam(*trackParam); + Float_t dPhi = 0; + Float_t dEta = 0; + + if(cluster->IsEMCAL()){ + Float_t eta = 0; Float_t phi = 0; Float_t pt = 0; + propagated = AliEMCALRecoUtils::ExtrapolateTrackToEMCalSurface(&emcParam, 430, 0.000510999, 20, eta, phi, pt); + if(propagated){ + propagated = AliEMCALRecoUtils::ExtrapolateTrackToCluster(&emcParam, cluster, 0.000510999, 5, dEta, dPhi); + } + } + if(cluster->IsPHOS()){ + propagated = AliTrackerBase::PropagateTrackToBxByBz(&emcParam, clusterR, 0.000510999, 20, kTRUE, 0.8, -1); + if (propagated){ + Double_t trkPos[3] = {0,0,0}; + emcParam.GetXYZ(trkPos); + TVector3 trkPosVec(trkPos[0],trkPos[1],trkPos[2]); + TVector3 clsPosVec(clusterPosition); + dPhi = clsPosVec.DeltaPhi(trkPosVec); + dEta = clsPosVec.Eta()-trkPosVec.Eta(); + } + } + + if (propagated){ + Float_t dR2 = dPhi*dPhi + dEta*dEta; + if (fHistDistanceTrackToClusterBeforeQA)fHistDistanceTrackToClusterBeforeQA->Fill(TMath::Sqrt(dR2)); + if (fHistClusterdEtadPhiBeforeQA) fHistClusterdEtadPhiBeforeQA->Fill(dEta, dPhi); + if(dR2 < fMinDistTrackToCluster*fMinDistTrackToCluster){ + matched = kTRUE; + if (fHistDistanceTrackToClusterAfterQA)fHistDistanceTrackToClusterAfterQA->Fill(TMath::Sqrt(dR2)); + if (fHistClusterdEtadPhiAfterQA) fHistClusterdEtadPhiAfterQA->Fill(dEta, dPhi); + if (fHistClusterRAfterQA) fHistClusterRAfterQA->Fill(clusterR); + } + + } + delete trackParam; + } return matched; + } //____________________________________________________________________________________________ @@ -1185,39 +1189,39 @@ Bool_t AliCaloPhotonCuts::SetTrackMatchingCut(Int_t trackMatching) break; case 1: if (!fUseDistTrackToCluster) fUseDistTrackToCluster=1; - fMinDistTrackToCluster=0.04; + fMinDistTrackToCluster= 0.03; //0.04; break; case 2: if (!fUseDistTrackToCluster) fUseDistTrackToCluster=1; - fMinDistTrackToCluster=0.05; + fMinDistTrackToCluster= 0.035; //0.05; break; case 3: if (!fUseDistTrackToCluster) fUseDistTrackToCluster=1; - fMinDistTrackToCluster=0.1; + fMinDistTrackToCluster= 0.04; //0.1; break; case 4: if (!fUseDistTrackToCluster) fUseDistTrackToCluster=1; - fMinDistTrackToCluster=0.13; + fMinDistTrackToCluster= 0.045; //0.13; break; case 5: if (!fUseDistTrackToCluster) fUseDistTrackToCluster=1; - fMinDistTrackToCluster=0.15; + fMinDistTrackToCluster= 0.05; //0.15 break; case 6: if (!fUseDistTrackToCluster) fUseDistTrackToCluster=1; - fMinDistTrackToCluster=0.2; + fMinDistTrackToCluster= 0.055; //0.2; break; case 7: if (!fUseDistTrackToCluster) fUseDistTrackToCluster=1; - fMinDistTrackToCluster=0.3; + fMinDistTrackToCluster= 0.06; //0.3; break; case 8: if (!fUseDistTrackToCluster) fUseDistTrackToCluster=1; - fMinDistTrackToCluster=0.4; + fMinDistTrackToCluster= 0.07; //0.4; break; case 9: if (!fUseDistTrackToCluster) fUseDistTrackToCluster=1; - fMinDistTrackToCluster=0.5; + fMinDistTrackToCluster= 0.1; //0.5; break; default: diff --git a/PWGGA/GammaConv/AliCaloPhotonCuts.h b/PWGGA/GammaConv/AliCaloPhotonCuts.h index df4cd6c0818..414f677f661 100644 --- a/PWGGA/GammaConv/AliCaloPhotonCuts.h +++ b/PWGGA/GammaConv/AliCaloPhotonCuts.h @@ -170,8 +170,10 @@ class AliCaloPhotonCuts : public AliAnalysisCuts { TH2F* fHistClusterEtavsPhiAfterQA; // eta-phi-distribution of all after cluster quality cuts TH1F* fHistDistanceToBadChannelBeforeAcc; // distance to bad channel before acceptance cuts TH1F* fHistDistanceToBadChannelAfterAcc; // distance to bad channel after acceptance cuts - TH1F *fHistClusterRBeforeQA; // cluster position in R=SQRT(x^2+y^2) (before QA) - TH1F *fHistClusterRAfterQA; // cluster position in R=SQRT(x^2+y^2) for matched tracks (After QA) + TH1F* fHistClusterRBeforeQA; // cluster position in R=SQRT(x^2+y^2) (before QA) + TH1F* fHistClusterRAfterQA; // cluster position in R=SQRT(x^2+y^2) for matched tracks (After QA) + TH2F* fHistClusterdEtadPhiBeforeQA; // 2-dim plot dEta vs. dPhi + TH2F* fHistClusterdEtadPhiAfterQA; // 2-dim plot dEta vs. dPhi for matched tracks (after QA) TH2F* fHistClusterTimevsEBeforeQA; // Cluster time vs E before cluster quality cuts TH2F* fHistClusterTimevsEAfterQA; // Cluster time vs E after cluster quality cuts TH2F* fHistExoticCellBeforeQA; // Exotic cell: 1-Ecross/E cell vs Ecluster before acceptance cuts @@ -194,7 +196,7 @@ class AliCaloPhotonCuts : public AliAnalysisCuts { private: - ClassDef(AliCaloPhotonCuts,1) + ClassDef(AliCaloPhotonCuts,2) }; #endif diff --git a/PWGGA/GammaConv/AliPrimaryPionCuts.cxx b/PWGGA/GammaConv/AliPrimaryPionCuts.cxx index fe29afd7224..e1262ca1343 100644 --- a/PWGGA/GammaConv/AliPrimaryPionCuts.cxx +++ b/PWGGA/GammaConv/AliPrimaryPionCuts.cxx @@ -100,7 +100,8 @@ AliPrimaryPionCuts::AliPrimaryPionCuts(const char *name,const char *title) : Ali fHistTrackDCAzPtbefore(NULL), fHistTrackDCAzPtafter(NULL), fHistTrackNFindClsPtTPCbefore(NULL), - fHistTrackNFindClsPtTPCafter(NULL) + fHistTrackNFindClsPtTPCafter(NULL), + fStringITSClusterCut("") { InitPIDResponse(); for(Int_t jj=0;jj %3.2f \n", fMinClsTPC); + printf("\t min N cluster TPC/ findable > %3.2f \n", fMinClsTPCToF); +// printf("\t dca > %3.2f \n", fMinClsTPCToF); +// "kDCAcut", // 3 + printf("\t min pT > %3.2f \n", fPtCut); + printf("PID cuts \n"); + if (fDodEdxSigmaITSCut)printf("\t %3.2f < ITS n_sigma pi < %3.2f \n", fPIDnSigmaBelowPionLineITS, fPIDnSigmaAbovePionLineITS ); + if (fDodEdxSigmaTPCCut)printf("\t %3.2f < TPC n_sigma pi < %3.2f \n", fPIDnSigmaBelowPionLineTPC, fPIDnSigmaAbovePionLineTPC ); + if (fDoTOFsigmaCut)printf("\t %3.2f < TOF n_sigma pi < %3.2f \n", fPIDnSigmaBelowPionLineTOF, fPIDnSigmaAbovePionLineTOF ); + if (fDoMassCut) printf("two-pion mass cut < %3.2f \n", fMassCut); + printf("\n\n"); +} + + + ///________________________________________________________________________ Bool_t AliPrimaryPionCuts::SetITSdEdxCutPionLine(Int_t ededxSigmaCut){ switch(ededxSigmaCut){ @@ -713,31 +742,38 @@ Bool_t AliPrimaryPionCuts::SetITSClusterCut(Int_t clsITSCut){ switch(clsITSCut){ case 0: fEsdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kOff); + fStringITSClusterCut= "no SPD cluster requirement"; break; case 1: fEsdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kFirst); + fStringITSClusterCut= "first SPD cluster required"; break; //1 hit first layer of SPD case 2: fEsdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny); + fStringITSClusterCut= "first or second SPD cluster required"; break; //1 hit in any layer of SPD case 3: fEsdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kFirst); fEsdTrackCuts->SetMinNClustersITS(4); + fStringITSClusterCut= "first SPD cluster required, min number of ITS clusters = 4"; // 4 hits in total in the ITS. At least 1 hit in the first layer of SPD break; case 4: fEsdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny); fEsdTrackCuts->SetMinNClustersITS(3); + fStringITSClusterCut= "first or second SPD cluster required, min number of ITS clusters = 3"; // 3 hits in total in the ITS. At least 1 hit in any layer of SPD break; case 5: fEsdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny); fEsdTrackCuts->SetMinNClustersITS(4); + fStringITSClusterCut= "first or second SPD cluster required, min number of ITS clusters = 4"; // 4 hits in total in the ITS. At least 1 hit in any layer of SPD break; case 6: fEsdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny); fEsdTrackCuts->SetMinNClustersITS(5); + fStringITSClusterCut= "first or second SPD cluster required, min number of ITS clusters = 5"; // 5 hits in total in the ITS. At least 1 hit in any layer of SPD break; default: @@ -899,7 +935,8 @@ Bool_t AliPrimaryPionCuts::SetDCACut(Int_t dcaCut) fEsdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0182+0.0350/pt^1.01"); fEsdTrackCuts->SetMaxChi2TPCConstrainedGlobal(36); break; - case 2: fEsdTrackCuts->SetMaxDCAToVertexZ(2); + case 2: + fEsdTrackCuts->SetMaxDCAToVertexZ(2); fEsdTrackCuts->SetMaxDCAToVertexXY(1); fEsdTrackCuts->SetMaxChi2TPCConstrainedGlobal(36); break; @@ -971,7 +1008,7 @@ Bool_t AliPrimaryPionCuts::SetMassCut(Int_t massCut){ break; case 2: // cut at 0.7 GeV/c^2 fDoMassCut = kTRUE; - fMassCut = 0.7; + fMassCut = 0.75; break; case 3: // cut at 0.6 GeV/c^2 fDoMassCut = kTRUE; diff --git a/PWGGA/GammaConv/AliPrimaryPionCuts.h b/PWGGA/GammaConv/AliPrimaryPionCuts.h index e6aef3a8ca0..ce400351b75 100644 --- a/PWGGA/GammaConv/AliPrimaryPionCuts.h +++ b/PWGGA/GammaConv/AliPrimaryPionCuts.h @@ -90,7 +90,8 @@ class AliPrimaryPionCuts : public AliAnalysisCuts { AliPIDResponse * GetPIDResponse() { return fPIDResponse;} void PrintCuts(); - + void PrintCutsWithValues(); + void InitCutHistograms(TString name="",Bool_t preCut = kTRUE,TString cutName=""); void SetFillCutHistograms(TString name="",Bool_t preCut = kTRUE,TString cutName=""){if(!fHistograms){InitCutHistograms(name,preCut,cutName);};} TList *GetCutHistograms(){return fHistograms;} @@ -167,6 +168,8 @@ class AliPrimaryPionCuts : public AliAnalysisCuts { TH2F *fHistTrackNFindClsPtTPCbefore; TH2F *fHistTrackNFindClsPtTPCafter; + TString fStringITSClusterCut; + private: AliPrimaryPionCuts(const AliPrimaryPionCuts&); // not implemented diff --git a/PWGGA/GammaConv/macros/AddTask_GammaConvNeutralMesonPiPlPiMiPiZero_CaloMode_pPb.C b/PWGGA/GammaConv/macros/AddTask_GammaConvNeutralMesonPiPlPiMiPiZero_CaloMode_pPb.C new file mode 100644 index 00000000000..1f9d6c979f2 --- /dev/null +++ b/PWGGA/GammaConv/macros/AddTask_GammaConvNeutralMesonPiPlPiMiPiZero_CaloMode_pPb.C @@ -0,0 +1,326 @@ +void AddTask_GammaConvNeutralMesonPiPlPiMiPiZero_CaloMode_pPb( + Int_t trainConfig = 1, + Bool_t isMC = kFALSE, //run MC + Bool_t enableQAMesonTask = kTRUE, //enable QA in AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero + TString fileNameInputForWeighting = "MCSpectraInput.root", // path to file for weigting input + Bool_t doWeighting = kFALSE, //enable Weighting + TString generatorName = "HIJING", + TString cutnumberAODBranch = "0000000060084001001500000" + ) { + + // ================= Load Librariers ================================= + gSystem->Load("libCore.so"); + gSystem->Load("libTree.so"); + gSystem->Load("libGeom.so"); + gSystem->Load("libVMC.so"); + gSystem->Load("libPhysics.so"); + gSystem->Load("libMinuit"); + gSystem->Load("libSTEERBase"); + gSystem->Load("libESD"); + gSystem->Load("libAOD"); + gSystem->Load("libANALYSIS"); + gSystem->Load("libANALYSISalice"); + gSystem->Load("libPWGGAGammaConv.so"); + gSystem->Load("libCDB.so"); + gSystem->Load("libSTEER.so"); + gSystem->Load("libSTEERBase.so"); + gSystem->Load("libTENDER.so"); + gSystem->Load("libTENDERSupplies.so"); + + Int_t isHeavyIon = 2; + Int_t neutralPionMode = 2; + + // ================== GetAnalysisManager =============================== + AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); + if (!mgr) { + Error(Form("AddTask_GammaConvNeutralMesonPiPlPiMiPiZero_pPb_%i",trainConfig), "No analysis manager found."); + return ; + } + + // ================== GetInputEventHandler ============================= + AliVEventHandler *inputHandler=mgr->GetInputEventHandler(); + + //========= Add PID Reponse to ANALYSIS manager ==== + if(!(AliPIDResponse*)mgr->GetTask("PIDResponseTask")){ + gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C"); + AddTaskPIDResponse(isMC); + } + + //========= Set Cutnumber for V0Reader ================================ + TString cutnumberPhoton = "060084001001500000000"; + TString cutnumberEvent = "8000000"; + TString PionCuts = "000000200"; //Electron Cuts + + + + Bool_t doEtaShift = kFALSE; + + AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer(); + + //========= Add V0 Reader to ANALYSIS manager if not yet existent ===== + if( !(AliV0ReaderV1*)mgr->GetTask("V0ReaderV1") ){ + AliV0ReaderV1 *fV0ReaderV1 = new AliV0ReaderV1("V0ReaderV1"); + + fV0ReaderV1->SetUseOwnXYZCalculation(kTRUE); + fV0ReaderV1->SetCreateAODs(kFALSE);// AOD Output + fV0ReaderV1->SetUseAODConversionPhoton(kTRUE); + + if (!mgr) { + Error("AddTask_V0ReaderV1", "No analysis manager found."); + return; + } + + AliConvEventCuts *fEventCuts=NULL; + if(cutnumberEvent!=""){ + fEventCuts= new AliConvEventCuts(cutnumberEvent.Data(),cutnumberEvent.Data()); + fEventCuts->SetPreSelectionCutFlag(kTRUE); + if(fEventCuts->InitializeCutsFromCutString(cutnumberEvent.Data())){ + fEventCuts->DoEtaShift(doEtaShift); + fV0ReaderV1->SetEventCuts(fEventCuts); + fEventCuts->SetFillCutHistograms("",kTRUE); + } + } + + // Set AnalysisCut Number + AliConversionPhotonCuts *fCuts=NULL; + if(cutnumberPhoton!=""){ + fCuts= new AliConversionPhotonCuts(cutnumberPhoton.Data(),cutnumberPhoton.Data()); + fCuts->SetPreSelectionCutFlag(kTRUE); + fCuts->SetIsHeavyIon(isHeavyIon); + if(fCuts->InitializeCutsFromCutString(cutnumberPhoton.Data())){ + fV0ReaderV1->SetConversionCuts(fCuts); + fCuts->SetFillCutHistograms("",kTRUE); + } + } + + if(inputHandler->IsA()==AliAODInputHandler::Class()){ + // AOD mode + fV0ReaderV1->SetDeltaAODBranchName(Form("GammaConv_%s_gamma",cutnumberAODBranch.Data())); + } + fV0ReaderV1->Init(); + + AliLog::SetGlobalLogLevel(AliLog::kInfo); + + //connect input V0Reader + mgr->AddTask(fV0ReaderV1); + mgr->ConnectInput(fV0ReaderV1,0,cinput); + } + + //================================================ + //========= Add Electron Selector ================ + + + if( !(AliPrimaryPionSelector*)mgr->GetTask("PionSelector") ){ + + AliPrimaryPionSelector *fPionSelector = new AliPrimaryPionSelector("PionSelector"); + // Set AnalysisCut Number + + AliPrimaryPionCuts *fPionCuts=0; + if( PionCuts!=""){ + fPionCuts= new AliPrimaryPionCuts(PionCuts.Data(),PionCuts.Data()); + if(fPionCuts->InitializeCutsFromCutString(PionCuts.Data())){ + fPionSelector->SetPrimaryPionCuts(fPionCuts); + fPionCuts->SetFillCutHistograms("",kTRUE); + + } + } + + fPionSelector->Init(); + mgr->AddTask(fPionSelector); + + AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer(); + + //connect input V0Reader + mgr->ConnectInput (fPionSelector,0,cinput1); + + } + + + + AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero *task=NULL; + + task= new AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero(Form("GammaConvNeutralMesonPiPlPiMiPiZero_%i_%i",neutralPionMode, trainConfig)); + + task->SetIsHeavyIon(2); + task->SetIsMC(isMC); + + // Cut Numbers to use in Analysis + Int_t numberOfCuts = 1; + + TString *eventCutArray = new TString[numberOfCuts]; + TString *ClusterCutarray = new TString[numberOfCuts]; + TString *PionCutarray = new TString[numberOfCuts]; + TString *NeutralPionCutarray = new TString[numberOfCuts]; + TString *MesonCutarray = new TString[numberOfCuts]; + + Bool_t doEtaShiftIndCuts = kFALSE; + TString stringShift = ""; + + // Shifting in pPb direction + + doEtaShiftIndCuts = kTRUE; + stringShift = "pPb"; + + // EMCAL modes + if( trainConfig == 1 ) { + // everything open + eventCutArray[ 0] = "8000011"; ClusterCutarray[0] = "10000040022030000"; PionCutarray[0] = "000010400"; NeutralPionCutarray[0] = "01035030000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 2 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, min pt charged pi = 100 MeV + eventCutArray[ 0] = "8000011"; ClusterCutarray[0] = "10000040022030000"; PionCutarray[0] = "002010700"; NeutralPionCutarray[0] = "01035030000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 3 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 5 sigma, min pt charged pi = 100 MeV + eventCutArray[ 0] = "8000011"; ClusterCutarray[0] = "10000040022030000"; PionCutarray[0] = "002013700"; NeutralPionCutarray[0] = "01035030000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 4 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 4 sigma, min pt charged pi = 100 MeV + eventCutArray[ 0] = "8000011"; ClusterCutarray[0] = "10000040022030000"; PionCutarray[0] = "002016700"; NeutralPionCutarray[0] = "01035030000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 5 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 4 sigma, min pt charged pi = 100 MeV + // closing neural pion cuts, 0.1 < M_gamma,gamma < 0.145 + eventCutArray[ 0] = "8000011"; ClusterCutarray[0] = "10000040022030000"; PionCutarray[0] = "002016700"; NeutralPionCutarray[0] = "01035031000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 6 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 4 sigma, min pt charged pi = 100 MeV + // closing neural pion cuts, 0.11 < M_gamma,gamma < 0.145 + eventCutArray[ 0] = "8000011"; ClusterCutarray[0] = "10000040022030000"; PionCutarray[0] = "002016700"; NeutralPionCutarray[0] = "01035032000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 7 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 4 sigma, min pt charged pi = 100 MeV + // closing neural pion cuts, 0.12 < M_gamma,gamma < 0.145 + eventCutArray[ 0] = "8000011"; ClusterCutarray[0] = "10000040022030000"; PionCutarray[0] = "002016700"; NeutralPionCutarray[0] = "01035033000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 8 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 5 sigma, min pt charged pi = 100 MeV + // closing neural pion cuts, 0.12 < M_gamma,gamma < 0.145 + eventCutArray[ 0] = "8000011"; ClusterCutarray[0] = "10000040022030000"; PionCutarray[0] = "002013700"; NeutralPionCutarray[0] = "01035033000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 9 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, pi+pi- mass Cut at 0.75, min pt charged pi = 100 MeV + // closing neural pion cuts, 0.1 < M_gamma,gamma < 0.145 + eventCutArray[ 0] = "8000011"; ClusterCutarray[0] = "10000040022030000"; PionCutarray[0] = "002010702"; NeutralPionCutarray[0] = "01035031000000"; MesonCutarray[0] = "01035030000000"; + } + + + // PHOS modes + if( trainConfig == 31 ) { + // everything open + eventCutArray[ 0] = "8000011"; ClusterCutarray[0] = "20000030022000000"; PionCutarray[0] = "000010400"; NeutralPionCutarray[0] = "01035030000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 32 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, min pt charged pi = 100 MeV + eventCutArray[ 0] = "8000011"; ClusterCutarray[0] = "20000030022000000"; PionCutarray[0] = "002010700"; NeutralPionCutarray[0] = "01035030000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 33 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 5 sigma, min pt charged pi = 100 MeV + eventCutArray[ 0] = "8000011"; ClusterCutarray[0] = "20000030022000000"; PionCutarray[0] = "002013700"; NeutralPionCutarray[0] = "01035030000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 34 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 4 sigma, min pt charged pi = 100 MeV + eventCutArray[ 0] = "8000011"; ClusterCutarray[0] = "20000030022000000"; PionCutarray[0] = "002016700"; NeutralPionCutarray[0] = "01035030000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 35 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 4 sigma, min pt charged pi = 100 MeV + // closing neural pion cuts, 0.1 < M_gamma,gamma < 0.145 + eventCutArray[ 0] = "8000011"; ClusterCutarray[0] = "20000030022000000"; PionCutarray[0] = "002016700"; NeutralPionCutarray[0] = "01035031000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 36 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 4 sigma, min pt charged pi = 100 MeV + // closing neural pion cuts, 0.11 < M_gamma,gamma < 0.145 + eventCutArray[ 0] = "8000011"; ClusterCutarray[0] = "20000030022000000"; PionCutarray[0] = "002016700"; NeutralPionCutarray[0] = "01035032000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 37 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 4 sigma, min pt charged pi = 100 MeV + // closing neural pion cuts, 0.12 < M_gamma,gamma < 0.145 + eventCutArray[ 0] = "8000011"; ClusterCutarray[0] = "20000030022000000"; PionCutarray[0] = "002016700"; NeutralPionCutarray[0] = "01035033000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 38 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 5 sigma, min pt charged pi = 100 MeV + // closing neural pion cuts, 0.12 < M_gamma,gamma < 0.145 + eventCutArray[ 0] = "8000011"; ClusterCutarray[0] = "20000030022000000"; PionCutarray[0] = "002013700"; NeutralPionCutarray[0] = "01035033000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 39 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, pi+pi- mass Cut at 0.75, min pt charged pi = 100 MeV + // closing neural pion cuts, 0.1 < M_gamma,gamma < 0.145 + eventCutArray[ 0] = "8000011"; ClusterCutarray[0] = "20000030022000000"; PionCutarray[0] = "002010702"; NeutralPionCutarray[0] = "01035031000000"; MesonCutarray[0] = "01035030000000"; + } + + + TList *EventCutList = new TList(); + TList *ClusterCutList = new TList(); + TList *NeutralPionCutList = new TList(); + TList *MesonCutList = new TList(); + TList *PionCutList = new TList(); + + TList *HeaderList = new TList(); + TObjString *Header1 = new TObjString("pi0_1"); + HeaderList->Add(Header1); + TObjString *Header3 = new TObjString("eta_2"); + HeaderList->Add(Header3); + + EventCutList->SetOwner(kTRUE); + AliConvEventCuts **analysisEventCuts = new AliConvEventCuts*[numberOfCuts]; + ClusterCutList->SetOwner(kTRUE); + AliCaloPhotonCuts **analysisClusterCuts = new AliCaloPhotonCuts*[numberOfCuts]; + NeutralPionCutList->SetOwner(kTRUE); + AliConversionMesonCuts **analysisNeutralPionCuts = new AliConversionMesonCuts*[numberOfCuts]; + MesonCutList->SetOwner(kTRUE); + AliConversionMesonCuts **analysisMesonCuts = new AliConversionMesonCuts*[numberOfCuts]; + PionCutList->SetOwner(kTRUE); + AliPrimaryPionCuts **analysisPionCuts = new AliPrimaryPionCuts*[numberOfCuts]; + + for(Int_t i = 0; iInitializeCutsFromCutString(eventCutArray[i].Data()); + EventCutList->Add(analysisEventCuts[i]); + analysisEventCuts[i]->SetFillCutHistograms("",kFALSE); + + analysisClusterCuts[i] = new AliCaloPhotonCuts(); + if( ! analysisClusterCuts[i]->InitializeCutsFromCutString(ClusterCutarray[i].Data()) ) { + cout<<"ERROR: analysisClusterCuts [" <Add(analysisClusterCuts[i]); + analysisClusterCuts[i]->SetFillCutHistograms(""); + } + + analysisNeutralPionCuts[i] = new AliConversionMesonCuts(); + if( ! analysisNeutralPionCuts[i]->InitializeCutsFromCutString(NeutralPionCutarray[i].Data()) ) { + cout<<"ERROR: analysisMesonCuts [ " <Add(analysisNeutralPionCuts[i]); + analysisNeutralPionCuts[i]->SetFillCutHistograms(""); + } + + analysisMesonCuts[i] = new AliConversionMesonCuts(); + if( ! analysisMesonCuts[i]->InitializeCutsFromCutString(MesonCutarray[i].Data()) ) { + cout<<"ERROR: analysisMesonCuts [ " <Add(analysisMesonCuts[i]); + analysisMesonCuts[i]->SetFillCutHistograms(""); + } + analysisEventCuts[i]->SetAcceptedHeader(HeaderList); + + TString cutName( Form("%s_%s_%s_%s_%s",eventCutArray[i].Data(), ClusterCutarray[i].Data(),PionCutarray[i].Data(),NeutralPionCutarray[i].Data(), MesonCutarray[i].Data() ) ); + analysisPionCuts[i] = new AliPrimaryPionCuts(); + if( !analysisPionCuts[i]->InitializeCutsFromCutString(PionCutarray[i].Data())) { + cout<< "ERROR: analysisPionCuts [ " <Add(analysisPionCuts[i]); + analysisPionCuts[i]->SetFillCutHistograms("",kFALSE,cutName); + } + } + + task->SetNeutralPionMode(neutralPionMode); + task->SetEventCutList(numberOfCuts,EventCutList); + task->SetClusterCutList(ClusterCutList); + task->SetNeutralPionCutList(NeutralPionCutList); + task->SetMesonCutList(MesonCutList); + task->SetPionCutList(PionCutList); + + task->SetMoveParticleAccordingToVertex(kTRUE); + + if(enableQAMesonTask) task->SetDoMesonQA(kTRUE); + + //connect containers + AliAnalysisDataContainer *coutput = + mgr->CreateContainer(Form("GammaConvNeutralMesonPiPlPiMiPiZero_%i_%i",neutralPionMode, trainConfig), TList::Class(), + AliAnalysisManager::kOutputContainer,Form("GammaConvNeutralMesonPiPlPiMiPiZero_%i_%i.root",neutralPionMode, trainConfig)); + + mgr->AddTask(task); + mgr->ConnectInput(task,0,cinput); + mgr->ConnectOutput(task,1,coutput); + + return; + +} diff --git a/PWGGA/GammaConv/macros/AddTask_GammaConvNeutralMesonPiPlPiMiPiZero_pPb.C b/PWGGA/GammaConv/macros/AddTask_GammaConvNeutralMesonPiPlPiMiPiZero_ConvMode_pPb.C similarity index 85% rename from PWGGA/GammaConv/macros/AddTask_GammaConvNeutralMesonPiPlPiMiPiZero_pPb.C rename to PWGGA/GammaConv/macros/AddTask_GammaConvNeutralMesonPiPlPiMiPiZero_ConvMode_pPb.C index 944ae890515..06e508b53f6 100644 --- a/PWGGA/GammaConv/macros/AddTask_GammaConvNeutralMesonPiPlPiMiPiZero_pPb.C +++ b/PWGGA/GammaConv/macros/AddTask_GammaConvNeutralMesonPiPlPiMiPiZero_ConvMode_pPb.C @@ -1,4 +1,4 @@ -void AddTask_GammaConvNeutralMesonPiPlPiMiPiZero_pPb( +void AddTask_GammaConvNeutralMesonPiPlPiMiPiZero_ConvMode_pPb( Int_t trainConfig = 1, Bool_t isMC = kFALSE, //run MC Bool_t enableQAMesonTask = kTRUE, //enable QA in AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero @@ -28,6 +28,7 @@ void AddTask_GammaConvNeutralMesonPiPlPiMiPiZero_pPb( gSystem->Load("libTENDERSupplies.so"); Int_t isHeavyIon = 2; + Int_t neutralPionMode = 0; // ================== GetAnalysisManager =============================== AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); @@ -49,7 +50,9 @@ void AddTask_GammaConvNeutralMesonPiPlPiMiPiZero_pPb( TString cutnumberPhoton = "060084001001500000000"; TString cutnumberEvent = "8000000"; TString PionCuts = "000000200"; //Electron Cuts - + + + Bool_t doEtaShift = kFALSE; AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer(); @@ -136,7 +139,7 @@ void AddTask_GammaConvNeutralMesonPiPlPiMiPiZero_pPb( AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero *task=NULL; - task= new AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero(Form("GammaConvNeutralMesonPiPlPiMiPiZero_%i",trainConfig)); + task= new AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero(Form("GammaConvNeutralMesonPiPlPiMiPiZero_%i_%i",neutralPionMode, trainConfig)); task->SetIsHeavyIon(2); task->SetIsMC(isMC); @@ -159,33 +162,37 @@ void AddTask_GammaConvNeutralMesonPiPlPiMiPiZero_pPb( stringShift = "pPb"; if( trainConfig == 1 ) { - // everything open - eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; PionCutarray[0] = "000000400"; NeutralPionCutarray[0] = "01035030000000"; MesonCutarray[0] = "01035030000000"; + // everything open, min pt charged pi = 100 MeV + eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; PionCutarray[0] = "000010400"; NeutralPionCutarray[0] = "01035030000000"; MesonCutarray[0] = "01035030000000"; } else if( trainConfig == 2 ) { - // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma - eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; PionCutarray[0] = "002000700"; NeutralPionCutarray[0] = "01035030000000"; MesonCutarray[0] = "01035030000000"; + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, min pt charged pi = 100 MeV + eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; PionCutarray[0] = "002010700"; NeutralPionCutarray[0] = "01035030000000"; MesonCutarray[0] = "01035030000000"; } else if( trainConfig == 3 ) { - // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 5 sigma - eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; PionCutarray[0] = "002003700"; NeutralPionCutarray[0] = "01035030000000"; MesonCutarray[0] = "01035030000000"; + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 5 sigma, min pt charged pi = 100 MeV + eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; PionCutarray[0] = "002013700"; NeutralPionCutarray[0] = "01035030000000"; MesonCutarray[0] = "01035030000000"; } else if( trainConfig == 4 ) { - // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 4 sigma - eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; PionCutarray[0] = "002006700"; NeutralPionCutarray[0] = "01035030000000"; MesonCutarray[0] = "01035030000000"; + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 4 sigma, min pt charged pi = 100 MeV + eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; PionCutarray[0] = "002016700"; NeutralPionCutarray[0] = "01035030000000"; MesonCutarray[0] = "01035030000000"; } else if( trainConfig == 5 ) { - // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 4 sigma + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 4 sigma, min pt charged pi = 100 MeV // closing neural pion cuts, 0.1 < M_gamma,gamma < 0.145 - eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; PionCutarray[0] = "002006700"; NeutralPionCutarray[0] = "01035031000000"; MesonCutarray[0] = "01035030000000"; + eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; PionCutarray[0] = "002016700"; NeutralPionCutarray[0] = "01035031000000"; MesonCutarray[0] = "01035030000000"; } else if( trainConfig == 6 ) { - // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 4 sigma + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 4 sigma, min pt charged pi = 100 MeV // closing neural pion cuts, 0.11 < M_gamma,gamma < 0.145 - eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; PionCutarray[0] = "002006700"; NeutralPionCutarray[0] = "01035032000000"; MesonCutarray[0] = "01035030000000"; + eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; PionCutarray[0] = "002016700"; NeutralPionCutarray[0] = "01035032000000"; MesonCutarray[0] = "01035030000000"; } else if( trainConfig == 7 ) { - // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 4 sigma + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 4 sigma, min pt charged pi = 100 MeV // closing neural pion cuts, 0.12 < M_gamma,gamma < 0.145 - eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; PionCutarray[0] = "002006700"; NeutralPionCutarray[0] = "01035033000000"; MesonCutarray[0] = "01035030000000"; + eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; PionCutarray[0] = "002016700"; NeutralPionCutarray[0] = "01035033000000"; MesonCutarray[0] = "01035030000000"; } else if( trainConfig == 8 ) { - // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 5 sigma + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 5 sigma, min pt charged pi = 100 MeV // closing neural pion cuts, 0.12 < M_gamma,gamma < 0.145 - eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; PionCutarray[0] = "002003700"; NeutralPionCutarray[0] = "01035033000000"; MesonCutarray[0] = "01035030000000"; + eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; PionCutarray[0] = "002013700"; NeutralPionCutarray[0] = "01035033000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 9 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, pi+pi- mass cut of 0.75, min pt charged pi = 100 MeV + // closing neural pion cuts, 0.1 < M_gamma,gamma < 0.145 + eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; PionCutarray[0] = "002010702"; NeutralPionCutarray[0] = "01035031000000"; MesonCutarray[0] = "01035030000000"; } TList *EventCutList = new TList(); @@ -257,8 +264,9 @@ void AddTask_GammaConvNeutralMesonPiPlPiMiPiZero_pPb( } } + task->SetNeutralPionMode(0); task->SetEventCutList(numberOfCuts,EventCutList); - task->SetConversionCutList(numberOfCuts,ConvCutList); + task->SetConversionCutList(ConvCutList); task->SetNeutralPionCutList(NeutralPionCutList); task->SetMesonCutList(MesonCutList); task->SetPionCutList(PionCutList); @@ -269,8 +277,8 @@ void AddTask_GammaConvNeutralMesonPiPlPiMiPiZero_pPb( //connect containers AliAnalysisDataContainer *coutput = - mgr->CreateContainer(Form("GammaConvNeutralMesonPiPlPiMiPiZero_%i",trainConfig), TList::Class(), - AliAnalysisManager::kOutputContainer,Form("GammaConvNeutralMesonPiPlPiMiPiZero_%i.root",trainConfig)); + mgr->CreateContainer(Form("GammaConvNeutralMesonPiPlPiMiPiZero_%i_%i",neutralPionMode, trainConfig), TList::Class(), + AliAnalysisManager::kOutputContainer,Form("GammaConvNeutralMesonPiPlPiMiPiZero_%i_%i.root",neutralPionMode, trainConfig)); mgr->AddTask(task); mgr->ConnectInput(task,0,cinput); diff --git a/PWGGA/GammaConv/macros/AddTask_GammaConvNeutralMesonPiPlPiMiPiZero_MixedMode_pPb.C b/PWGGA/GammaConv/macros/AddTask_GammaConvNeutralMesonPiPlPiMiPiZero_MixedMode_pPb.C new file mode 100644 index 00000000000..d17b6774eb6 --- /dev/null +++ b/PWGGA/GammaConv/macros/AddTask_GammaConvNeutralMesonPiPlPiMiPiZero_MixedMode_pPb.C @@ -0,0 +1,338 @@ +void AddTask_GammaConvNeutralMesonPiPlPiMiPiZero_MixedMode_pPb( + Int_t trainConfig = 1, + Bool_t isMC = kFALSE, //run MC + Bool_t enableQAMesonTask = kTRUE, //enable QA in AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero + TString fileNameInputForWeighting = "MCSpectraInput.root", // path to file for weigting input + Bool_t doWeighting = kFALSE, //enable Weighting + TString generatorName = "HIJING", + TString cutnumberAODBranch = "0000000060084001001500000" + ) { + + // ================= Load Librariers ================================= + gSystem->Load("libCore.so"); + gSystem->Load("libTree.so"); + gSystem->Load("libGeom.so"); + gSystem->Load("libVMC.so"); + gSystem->Load("libPhysics.so"); + gSystem->Load("libMinuit"); + gSystem->Load("libSTEERBase"); + gSystem->Load("libESD"); + gSystem->Load("libAOD"); + gSystem->Load("libANALYSIS"); + gSystem->Load("libANALYSISalice"); + gSystem->Load("libPWGGAGammaConv.so"); + gSystem->Load("libCDB.so"); + gSystem->Load("libSTEER.so"); + gSystem->Load("libSTEERBase.so"); + gSystem->Load("libTENDER.so"); + gSystem->Load("libTENDERSupplies.so"); + + Int_t isHeavyIon = 2; + Int_t neutralPionMode = 1; + + // ================== GetAnalysisManager =============================== + AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); + if (!mgr) { + Error(Form("AddTask_GammaConvNeutralMesonPiPlPiMiPiZero_pPb_%i",trainConfig), "No analysis manager found."); + return ; + } + + // ================== GetInputEventHandler ============================= + AliVEventHandler *inputHandler=mgr->GetInputEventHandler(); + + //========= Add PID Reponse to ANALYSIS manager ==== + if(!(AliPIDResponse*)mgr->GetTask("PIDResponseTask")){ + gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C"); + AddTaskPIDResponse(isMC); + } + + //========= Set Cutnumber for V0Reader ================================ + TString cutnumberPhoton = "060084001001500000000"; + TString cutnumberEvent = "8000000"; + TString PionCuts = "000000200"; //Electron Cuts + + + + Bool_t doEtaShift = kFALSE; + + AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer(); + + //========= Add V0 Reader to ANALYSIS manager if not yet existent ===== + if( !(AliV0ReaderV1*)mgr->GetTask("V0ReaderV1") ){ + AliV0ReaderV1 *fV0ReaderV1 = new AliV0ReaderV1("V0ReaderV1"); + + fV0ReaderV1->SetUseOwnXYZCalculation(kTRUE); + fV0ReaderV1->SetCreateAODs(kFALSE);// AOD Output + fV0ReaderV1->SetUseAODConversionPhoton(kTRUE); + + if (!mgr) { + Error("AddTask_V0ReaderV1", "No analysis manager found."); + return; + } + + AliConvEventCuts *fEventCuts=NULL; + if(cutnumberEvent!=""){ + fEventCuts= new AliConvEventCuts(cutnumberEvent.Data(),cutnumberEvent.Data()); + fEventCuts->SetPreSelectionCutFlag(kTRUE); + if(fEventCuts->InitializeCutsFromCutString(cutnumberEvent.Data())){ + fEventCuts->DoEtaShift(doEtaShift); + fV0ReaderV1->SetEventCuts(fEventCuts); + fEventCuts->SetFillCutHistograms("",kTRUE); + } + } + + // Set AnalysisCut Number + AliConversionPhotonCuts *fCuts=NULL; + if(cutnumberPhoton!=""){ + fCuts= new AliConversionPhotonCuts(cutnumberPhoton.Data(),cutnumberPhoton.Data()); + fCuts->SetPreSelectionCutFlag(kTRUE); + fCuts->SetIsHeavyIon(isHeavyIon); + if(fCuts->InitializeCutsFromCutString(cutnumberPhoton.Data())){ + fV0ReaderV1->SetConversionCuts(fCuts); + fCuts->SetFillCutHistograms("",kTRUE); + } + } + + if(inputHandler->IsA()==AliAODInputHandler::Class()){ + // AOD mode + fV0ReaderV1->SetDeltaAODBranchName(Form("GammaConv_%s_gamma",cutnumberAODBranch.Data())); + } + fV0ReaderV1->Init(); + + AliLog::SetGlobalLogLevel(AliLog::kInfo); + + //connect input V0Reader + mgr->AddTask(fV0ReaderV1); + mgr->ConnectInput(fV0ReaderV1,0,cinput); + } + + //================================================ + //========= Add Electron Selector ================ + + + if( !(AliPrimaryPionSelector*)mgr->GetTask("PionSelector") ){ + + AliPrimaryPionSelector *fPionSelector = new AliPrimaryPionSelector("PionSelector"); + // Set AnalysisCut Number + + AliPrimaryPionCuts *fPionCuts=0; + if( PionCuts!=""){ + fPionCuts= new AliPrimaryPionCuts(PionCuts.Data(),PionCuts.Data()); + if(fPionCuts->InitializeCutsFromCutString(PionCuts.Data())){ + fPionSelector->SetPrimaryPionCuts(fPionCuts); + fPionCuts->SetFillCutHistograms("",kTRUE); + + } + } + + fPionSelector->Init(); + mgr->AddTask(fPionSelector); + + AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer(); + + //connect input V0Reader + mgr->ConnectInput (fPionSelector,0,cinput1); + + } + + + + AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero *task=NULL; + + task= new AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero(Form("GammaConvNeutralMesonPiPlPiMiPiZero_%i_%i",neutralPionMode, trainConfig)); + + task->SetIsHeavyIon(2); + task->SetIsMC(isMC); + + // Cut Numbers to use in Analysis + Int_t numberOfCuts = 1; + + TString *eventCutArray = new TString[numberOfCuts]; + TString *ClusterCutarray = new TString[numberOfCuts]; + TString *ConvCutarray = new TString[numberOfCuts]; + TString *PionCutarray = new TString[numberOfCuts]; + TString *NeutralPionCutarray = new TString[numberOfCuts]; + TString *MesonCutarray = new TString[numberOfCuts]; + + Bool_t doEtaShiftIndCuts = kFALSE; + TString stringShift = ""; + + // Shifting in pPb direction + + doEtaShiftIndCuts = kTRUE; + stringShift = "pPb"; + + // EMCAL mode + if( trainConfig == 1 ) { + // everything open + eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; ClusterCutarray[0] = "10000040022030000"; PionCutarray[0] = "000010400"; NeutralPionCutarray[0] = "01035030000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 2 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, min pt charged pi = 100 MeV + eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; ClusterCutarray[0] = "10000040022030000"; PionCutarray[0] = "002010700"; NeutralPionCutarray[0] = "01035030000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 3 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 5 sigma, min pt charged pi = 100 MeV + eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; ClusterCutarray[0] = "10000040022030000"; PionCutarray[0] = "002013700"; NeutralPionCutarray[0] = "01035030000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 4 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 4 sigma, min pt charged pi = 100 MeV + eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; ClusterCutarray[0] = "10000040022030000"; PionCutarray[0] = "002016700"; NeutralPionCutarray[0] = "01035030000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 5 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 4 sigma, min pt charged pi = 100 MeV + // closing neural pion cuts, 0.1 < M_gamma,gamma < 0.145 + eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; ClusterCutarray[0] = "10000040022030000"; PionCutarray[0] = "002016700"; NeutralPionCutarray[0] = "01035031000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 6 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 4 sigma, min pt charged pi = 100 MeV + // closing neural pion cuts, 0.11 < M_gamma,gamma < 0.145 + eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; ClusterCutarray[0] = "10000040022030000"; PionCutarray[0] = "002016700"; NeutralPionCutarray[0] = "01035032000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 7 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 4 sigma, min pt charged pi = 100 MeV + // closing neural pion cuts, 0.12 < M_gamma,gamma < 0.145 + eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; ClusterCutarray[0] = "10000040022030000"; PionCutarray[0] = "002016700"; NeutralPionCutarray[0] = "01035033000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 8 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 5 sigma, min pt charged pi = 100 MeV + // closing neural pion cuts, 0.12 < M_gamma,gamma < 0.145 + eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; ClusterCutarray[0] = "10000040022030000"; PionCutarray[0] = "002013700"; NeutralPionCutarray[0] = "01035033000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 9 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, pi+pi- mass Cut at 0.75, min pt charged pi = 100 MeV + // closing neural pion cuts, 0.1 < M_gamma,gamma < 0.145 + eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; ClusterCutarray[0] = "10000040022030000"; PionCutarray[0] = "002010702"; NeutralPionCutarray[0] = "01035031000000"; MesonCutarray[0] = "01035030000000"; + } + + // PHOS mode + if( trainConfig == 31 ) { + // everything open + eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; ClusterCutarray[0] = "20000030022000000"; PionCutarray[0] = "000010400"; NeutralPionCutarray[0] = "01035030000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 32 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, min pt charged pi = 100 MeV + eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; ClusterCutarray[0] = "20000030022000000"; PionCutarray[0] = "002010700"; NeutralPionCutarray[0] = "01035030000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 33 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 5 sigma, min pt charged pi = 100 MeV + eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; ClusterCutarray[0] = "20000030022000000"; PionCutarray[0] = "002013700"; NeutralPionCutarray[0] = "01035030000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 34 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 4 sigma, min pt charged pi = 100 MeV + eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; ClusterCutarray[0] = "20000030022000000"; PionCutarray[0] = "002016700"; NeutralPionCutarray[0] = "01035030000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 35 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 4 sigma, min pt charged pi = 100 MeV + // closing neural pion cuts, 0.1 < M_gamma,gamma < 0.145 + eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; ClusterCutarray[0] = "20000030022000000"; PionCutarray[0] = "002016700"; NeutralPionCutarray[0] = "01035031000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 36 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 4 sigma, min pt charged pi = 100 MeV + // closing neural pion cuts, 0.11 < M_gamma,gamma < 0.145 + eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; ClusterCutarray[0] = "20000030022000000"; PionCutarray[0] = "002016700"; NeutralPionCutarray[0] = "01035032000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 37 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 4 sigma, min pt charged pi = 100 MeV + // closing neural pion cuts, 0.12 < M_gamma,gamma < 0.145 + eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; ClusterCutarray[0] = "20000030022000000"; PionCutarray[0] = "002016700"; NeutralPionCutarray[0] = "01035033000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 38 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, ITS dEdx = \pm 5 sigma, min pt charged pi = 100 MeV + // closing neural pion cuts, 0.12 < M_gamma,gamma < 0.145 + eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; ClusterCutarray[0] = "20000030022000000"; PionCutarray[0] = "002013700"; NeutralPionCutarray[0] = "01035033000000"; MesonCutarray[0] = "01035030000000"; + } else if( trainConfig == 39 ) { + // closing charged pion cuts, minimum TPC cluster = 80, TPC dEdx pi = \pm 3 sigma, pi+pi- mass Cut at 0.75, min pt charged pi = 100 MeV + // closing neural pion cuts, 0.1 < M_gamma,gamma < 0.145 + eventCutArray[ 0] = "8000011"; ConvCutarray[0] = "002091170008260400000"; ClusterCutarray[0] = "20000030022000000"; PionCutarray[0] = "002010702"; NeutralPionCutarray[0] = "01035031000000"; MesonCutarray[0] = "01035030000000"; + } + + TList *EventCutList = new TList(); + TList *ConvCutList = new TList(); + TList *ClusterCutList = new TList(); + TList *NeutralPionCutList = new TList(); + TList *MesonCutList = new TList(); + TList *PionCutList = new TList(); + + TList *HeaderList = new TList(); + TObjString *Header1 = new TObjString("pi0_1"); + HeaderList->Add(Header1); + TObjString *Header3 = new TObjString("eta_2"); + HeaderList->Add(Header3); + + EventCutList->SetOwner(kTRUE); + AliConvEventCuts **analysisEventCuts = new AliConvEventCuts*[numberOfCuts]; + ConvCutList->SetOwner(kTRUE); + AliConversionPhotonCuts **analysisCuts = new AliConversionPhotonCuts*[numberOfCuts]; + ClusterCutList->SetOwner(kTRUE); + AliCaloPhotonCuts **analysisClusterCuts = new AliCaloPhotonCuts*[numberOfCuts]; + NeutralPionCutList->SetOwner(kTRUE); + AliConversionMesonCuts **analysisNeutralPionCuts = new AliConversionMesonCuts*[numberOfCuts]; + MesonCutList->SetOwner(kTRUE); + AliConversionMesonCuts **analysisMesonCuts = new AliConversionMesonCuts*[numberOfCuts]; + PionCutList->SetOwner(kTRUE); + AliPrimaryPionCuts **analysisPionCuts = new AliPrimaryPionCuts*[numberOfCuts]; + + for(Int_t i = 0; iInitializeCutsFromCutString(eventCutArray[i].Data()); + EventCutList->Add(analysisEventCuts[i]); + analysisEventCuts[i]->SetFillCutHistograms("",kFALSE); + + analysisCuts[i] = new AliConversionPhotonCuts(); + if( ! analysisCuts[i]->InitializeCutsFromCutString(ConvCutarray[i].Data()) ) { + cout<<"ERROR: analysisCuts [" <Add(analysisCuts[i]); + analysisCuts[i]->SetFillCutHistograms("",kFALSE); + } + + analysisClusterCuts[i] = new AliCaloPhotonCuts(); + if( ! analysisClusterCuts[i]->InitializeCutsFromCutString(ClusterCutarray[i].Data()) ) { + cout<<"ERROR: analysisClusterCuts [" <Add(analysisClusterCuts[i]); + analysisClusterCuts[i]->SetFillCutHistograms(""); + } + + analysisNeutralPionCuts[i] = new AliConversionMesonCuts(); + if( ! analysisNeutralPionCuts[i]->InitializeCutsFromCutString(NeutralPionCutarray[i].Data()) ) { + cout<<"ERROR: analysisMesonCuts [ " <Add(analysisNeutralPionCuts[i]); + analysisNeutralPionCuts[i]->SetFillCutHistograms(""); + } + + analysisMesonCuts[i] = new AliConversionMesonCuts(); + if( ! analysisMesonCuts[i]->InitializeCutsFromCutString(MesonCutarray[i].Data()) ) { + cout<<"ERROR: analysisMesonCuts [ " <Add(analysisMesonCuts[i]); + analysisMesonCuts[i]->SetFillCutHistograms(""); + } + analysisEventCuts[i]->SetAcceptedHeader(HeaderList); + + TString cutName( Form("%s_%s_%s_%s_%s_%s",eventCutArray[i].Data(), ConvCutarray[i].Data(), ClusterCutarray[i].Data(),PionCutarray[i].Data(),NeutralPionCutarray[i].Data(), MesonCutarray[i].Data() ) ); + analysisPionCuts[i] = new AliPrimaryPionCuts(); + if( !analysisPionCuts[i]->InitializeCutsFromCutString(PionCutarray[i].Data())) { + cout<< "ERROR: analysisPionCuts [ " <Add(analysisPionCuts[i]); + analysisPionCuts[i]->SetFillCutHistograms("",kFALSE,cutName); + } + } + + task->SetNeutralPionMode(neutralPionMode); + task->SetEventCutList(numberOfCuts,EventCutList); + task->SetConversionCutList(ConvCutList); + task->SetClusterCutList(ClusterCutList); + task->SetNeutralPionCutList(NeutralPionCutList); + task->SetMesonCutList(MesonCutList); + task->SetPionCutList(PionCutList); + + task->SetMoveParticleAccordingToVertex(kTRUE); + + if(enableQAMesonTask) task->SetDoMesonQA(kTRUE); + + //connect containers + AliAnalysisDataContainer *coutput = + mgr->CreateContainer(Form("GammaConvNeutralMesonPiPlPiMiPiZero_%i_%i",neutralPionMode, trainConfig), TList::Class(), + AliAnalysisManager::kOutputContainer,Form("GammaConvNeutralMesonPiPlPiMiPiZero_%i_%i.root",neutralPionMode, trainConfig)); + + mgr->AddTask(task); + mgr->ConnectInput(task,0,cinput); + mgr->ConnectOutput(task,1,coutput); + + return; + +} -- 2.39.3