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),
fHistoTrueMotherGammaGammaFromOmegaInvMassPt(NULL),
fHistoTrueConvGammaPt(NULL),
fHistoTrueConvGammaFromNeutralMesonPt(NULL),
+ fHistoTrueClusterGammaPt(NULL),
+ fHistoTrueClusterGammaFromNeutralMesonPt(NULL),
fHistoTruePosPionPt(NULL),
fHistoTruePosPionFromNeutralMesonPt(NULL),
fHistoTrueNegPionPt(NULL),
fDoMesonAnalysis(kTRUE),
fDoMesonQA(kFALSE),
fIsFromMBHeader(kTRUE),
- fIsMC(kFALSE)
+ fIsMC(kFALSE),
+ fNeutralPionMode(0)
{
}
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),
fHistoTrueMotherGammaGammaFromOmegaInvMassPt(NULL),
fHistoTrueConvGammaPt(NULL),
fHistoTrueConvGammaFromNeutralMesonPt(NULL),
+ fHistoTrueClusterGammaPt(NULL),
+ fHistoTrueClusterGammaFromNeutralMesonPt(NULL),
fHistoTruePosPionPt(NULL),
fHistoTruePosPionFromNeutralMesonPt(NULL),
fHistoTrueNegPionPt(NULL),
fDoMesonAnalysis(kTRUE),
fDoMesonQA(kFALSE),
fIsFromMBHeader(kTRUE),
- fIsMC(kFALSE)
+ fIsMC(kFALSE),
+ fNeutralPionMode(0)
{
DefineOutput(1, TList::Class());
}
// virtual destructor
//
cout<<"Destructor"<<endl;
- if(fGoodGammas){
- delete fGoodGammas;
- fGoodGammas = 0x0;
+ if(fGoodConvGammas){
+ delete fGoodConvGammas;
+ fGoodConvGammas = 0x0;
}
+ if(fClusterCandidates){
+ delete fClusterCandidates;
+ fClusterCandidates = 0x0;
+ }
+
if(fNeutralPionCandidates){
delete fNeutralPionCandidates;
fNeutralPionCandidates = 0x0;
fTHnSparseMotherBackInvMassPtZM = new THnSparseF*[fnCuts];
fBGHandler = new AliGammaConversionAODBGHandler*[fnCuts];
+
for(Int_t iCut = 0; iCut<fnCuts;iCut++){
TString cutstringEvent = ((AliConvEventCuts*)fEventCutArray->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());
fOutputContainer->SetOwner(kTRUE);
}
- fGoodGammas = new TList();
+ fGoodConvGammas = new TList();
+ fClusterCandidates = new TList();
fNeutralPionCandidates = new TList();
fGoodVirtualParticles = new TList();
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];
for(Int_t iCut = 0; iCut<fnCuts;iCut++){
TString cutstringEvent = ((AliConvEventCuts*)fEventCutArray->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 nameCutFolder = Form("Cut Number %s", fullCutString.Data());
TString nameESDList = Form("%s ESD histograms", fullCutString.Data());
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);
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];
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];
for(Int_t iCut = 0; iCut<fnCuts;iCut++){
TString cutstringEvent = ((AliConvEventCuts*)fEventCutArray->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 nameMCList = Form("%s MC histograms", fullCutString.Data());
TString nameTrueRecList = Form("%s True histograms", fullCutString.Data());
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);
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);
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());
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
}
///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();
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());
}
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);
}
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
}
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
}
if(fMCEvent){
- ProcessTruePhotonCandidates(PhotonCandidate);
+ ProcessTrueConversionPhotonCandidates(PhotonCandidate);
}
}
}
}
//________________________________________________________________________
-void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessTruePhotonCandidates(AliAODConversionPhoton *TruePhotonCandidate)
+void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessTrueConversionPhotonCandidates(AliAODConversionPhoton *TruePhotonCandidate)
{
// Process True Photons
AliStack *MCStack = fMCEvent->Stack();
//________________________________________________________________________
void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessNeutralPionCandidatesPureConversions(){
// Conversion Gammas
- if(fGoodGammas->GetEntries()>1){
- for(Int_t firstGammaIndex=0;firstGammaIndex<fGoodGammas->GetEntries()-1;firstGammaIndex++){
- AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGoodGammas->At(firstGammaIndex));
+ if(fGoodConvGammas->GetEntries()>1){
+ for(Int_t firstGammaIndex=0;firstGammaIndex<fGoodConvGammas->GetEntries()-1;firstGammaIndex++){
+ AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGoodConvGammas->At(firstGammaIndex));
if (gamma0==NULL) continue;
- for(Int_t secondGammaIndex=firstGammaIndex+1;secondGammaIndex<fGoodGammas->GetEntries();secondGammaIndex++){
- AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fGoodGammas->At(secondGammaIndex));
+ for(Int_t secondGammaIndex=firstGammaIndex+1;secondGammaIndex<fGoodConvGammas->GetEntries();secondGammaIndex++){
+ AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fGoodConvGammas->At(secondGammaIndex));
//Check for same Electron ID
if (gamma1==NULL) continue;
if(gamma0->GetTrackLabelPositive() == gamma1->GetTrackLabelPositive() ||
}
+//________________________________________________________________________
+void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessNeutralPionCandidatesPureCalo(){
+
+ // Conversion Gammas
+ if(fClusterCandidates->GetEntries()>0){
+
+ // vertex
+ Double_t vertex[3] = {0};
+ InputEvent()->GetPrimaryVertex()->GetXYZ(vertex);
+
+ for(Int_t firstGammaIndex=0;firstGammaIndex<fClusterCandidates->GetEntries();firstGammaIndex++){
+ AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fClusterCandidates->At(firstGammaIndex));
+ if (gamma0==NULL) continue;
+
+ for(Int_t secondGammaIndex=0;secondGammaIndex<fClusterCandidates->GetEntries();secondGammaIndex++){
+ if (firstGammaIndex == secondGammaIndex) continue;
+ AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(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)
{
}
}
}
+
//______________________________________________________________________
void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessTrueNeutralPionCandidatesPureConversionsAOD(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1)
{
}
+//________________________________________________________________________
+void AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero::ProcessNeutralPionCandidatesMixedConvCalo(){
+
+ // Conversion Gammas
+ if(fGoodConvGammas->GetEntries()>0){
+ // vertex
+ Double_t vertex[3] = {0};
+ InputEvent()->GetPrimaryVertex()->GetXYZ(vertex);
+
+ for(Int_t firstGammaIndex=0;firstGammaIndex<fGoodConvGammas->GetEntries();firstGammaIndex++){
+ AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGoodConvGammas->At(firstGammaIndex));
+ if (gamma0==NULL) continue;
+
+ for(Int_t secondGammaIndex=0;secondGammaIndex<fClusterCandidates->GetEntries();secondGammaIndex++){
+ Bool_t matched = kFALSE;
+ AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(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()<fInputEvent->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(){
}
}
- 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;
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);
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());
+ }
}
}
- }
+ }
}
}
}
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
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
+ }
+ }
+
}
}
}
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());
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;
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 ){
#include "AliPrimaryPionSelector.h"
#include "AliConversionMesonCuts.h"
#include "AliConvEventCuts.h"
+#include "AliCaloPhotonCuts.h"
#include "AliGammaConversionAODBGHandler.h"
#include "TProfile2D.h"
class AliESDtrack;
class AliESDtrackCuts;
class AliESDpidCuts;
-class AliV0Reader;
class AliTriggerAnalysis;
class AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero: public AliAnalysisTaskSE
void SetMoveParticleAccordingToVertex(Bool_t flag){fMoveParticleAccordingToVertex = flag;}
-
void SetIsHeavyIon(Int_t flag){
if (flag == 1 || flag ==2 ){
fIsHeavyIon = 1;
}
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();
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<Int_t> fSelectorNegPionIndex; //
- vector<Int_t> 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<Int_t> fSelectorNegPionIndex; // array with pion indices for negative pions from fPionSelector
+ vector<Int_t> 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
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
#include "AliAODMCHeader.h"
#include "AliPicoTrack.h"
#include "AliEMCALRecoUtils.h"
-#include "AliPHOSGeoUtils.h"
+#include "AliTrackerBase.h"
class iostream;
fHistDistanceToBadChannelAfterAcc(NULL),
fHistClusterRBeforeQA(NULL),
fHistClusterRAfterQA(NULL),
+ fHistClusterdEtadPhiBeforeQA(NULL),
+ fHistClusterdEtadPhiAfterQA(NULL),
fHistClusterTimevsEBeforeQA(NULL),
fHistClusterTimevsEAfterQA(NULL),
fHistExoticCellBeforeQA(NULL),
fHistClusterEtavsPhiAfterQA(NULL),
fHistDistanceToBadChannelBeforeAcc(NULL),
fHistDistanceToBadChannelAfterAcc(NULL),
- fHistClusterRBeforeQA(NULL),
- fHistClusterRAfterQA(NULL),
+ fHistClusterRBeforeQA(NULL),
+ fHistClusterRAfterQA(NULL),
+ fHistClusterdEtadPhiBeforeQA(NULL),
+ fHistClusterdEtadPhiAfterQA(NULL),
fHistClusterTimevsEBeforeQA(NULL),
fHistClusterTimevsEAfterQA(NULL),
fHistExoticCellBeforeQA(NULL),
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);
}
}
-//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);
}
}
}
-//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<AliESDtrack*>(inTrack);
+ AliAODTrack *aodt = 0;
+ if (!esdt) {
+ aodt = dynamic_cast<AliAODTrack*>(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;
+
}
//____________________________________________________________________________________________
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:
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
private:
- ClassDef(AliCaloPhotonCuts,1)
+ ClassDef(AliCaloPhotonCuts,2)
};
#endif
fHistTrackDCAzPtbefore(NULL),
fHistTrackDCAzPtafter(NULL),
fHistTrackNFindClsPtTPCbefore(NULL),
- fHistTrackNFindClsPtTPCafter(NULL)
+ fHistTrackNFindClsPtTPCafter(NULL),
+ fStringITSClusterCut("")
{
InitPIDResponse();
for(Int_t jj=0;jj<kNCuts;jj++){ fCuts[jj]=0; }
if(!SetCut(cutIds(ii),fCuts[ii]))return kFALSE;
}
- PrintCuts();
+ PrintCutsWithValues();
return kTRUE;
}
///________________________________________________________________________
}
///________________________________________________________________________
-
void AliPrimaryPionCuts::PrintCuts() {
// Print out current Cut Selection
for(Int_t ic = 0; ic < kNCuts; ic++) {
}
}
+///________________________________________________________________________
+void AliPrimaryPionCuts::PrintCutsWithValues() {
+ // Print out current Cut Selection with value
+ printf("\nCharged Pion cutnumber \n");
+ for(Int_t ic = 0; ic < kNCuts; ic++) {
+ printf("%d",fCuts[ic]);
+ }
+ printf("\n\n");
+
+ printf("Acceptance cuts \n");
+ if (fDoEtaCut) printf("\t |eta_{pi+-}| < %3.2f \n", fEtaCut);
+ else printf("\t none \n");
+ printf("Track cuts \n");
+ printf("\t %s \n", fStringITSClusterCut.Data());
+ printf("\t min N cluster TPC > %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){
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:
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;
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;
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;}
TH2F *fHistTrackNFindClsPtTPCbefore;
TH2F *fHistTrackNFindClsPtTPCafter;
+ TString fStringITSClusterCut;
+
private:
AliPrimaryPionCuts(const AliPrimaryPionCuts&); // not implemented
--- /dev/null
+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; i<numberOfCuts; i++){
+ analysisEventCuts[i] = new AliConvEventCuts();
+ analysisEventCuts[i]->InitializeCutsFromCutString(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 [" <<i<<"]"<<endl;
+ return 0;
+ } else {
+ ClusterCutList->Add(analysisClusterCuts[i]);
+ analysisClusterCuts[i]->SetFillCutHistograms("");
+ }
+
+ analysisNeutralPionCuts[i] = new AliConversionMesonCuts();
+ if( ! analysisNeutralPionCuts[i]->InitializeCutsFromCutString(NeutralPionCutarray[i].Data()) ) {
+ cout<<"ERROR: analysisMesonCuts [ " <<i<<" ] "<<endl;
+ return 0;
+ } else {
+ NeutralPionCutList->Add(analysisNeutralPionCuts[i]);
+ analysisNeutralPionCuts[i]->SetFillCutHistograms("");
+ }
+
+ analysisMesonCuts[i] = new AliConversionMesonCuts();
+ if( ! analysisMesonCuts[i]->InitializeCutsFromCutString(MesonCutarray[i].Data()) ) {
+ cout<<"ERROR: analysisMesonCuts [ " <<i<<" ] "<<endl;
+ return 0;
+ } else {
+ MesonCutList->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 [ " <<i<<" ] "<<endl;
+ return 0;
+ } else {
+ PionCutList->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;
+
+}
-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
gSystem->Load("libTENDERSupplies.so");
Int_t isHeavyIon = 2;
+ Int_t neutralPionMode = 0;
// ================== GetAnalysisManager ===============================
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
TString cutnumberPhoton = "060084001001500000000";
TString cutnumberEvent = "8000000";
TString PionCuts = "000000200"; //Electron Cuts
-
+
+
+
Bool_t doEtaShift = kFALSE;
AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
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);
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();
}
}
+ task->SetNeutralPionMode(0);
task->SetEventCutList(numberOfCuts,EventCutList);
- task->SetConversionCutList(numberOfCuts,ConvCutList);
+ task->SetConversionCutList(ConvCutList);
task->SetNeutralPionCutList(NeutralPionCutList);
task->SetMesonCutList(MesonCutList);
task->SetPionCutList(PionCutList);
//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);
--- /dev/null
+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; i<numberOfCuts; i++){
+ analysisEventCuts[i] = new AliConvEventCuts();
+ analysisEventCuts[i]->InitializeCutsFromCutString(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 [" <<i<<"]"<<endl;
+ return 0;
+ } else {
+ ConvCutList->Add(analysisCuts[i]);
+ analysisCuts[i]->SetFillCutHistograms("",kFALSE);
+ }
+
+ analysisClusterCuts[i] = new AliCaloPhotonCuts();
+ if( ! analysisClusterCuts[i]->InitializeCutsFromCutString(ClusterCutarray[i].Data()) ) {
+ cout<<"ERROR: analysisClusterCuts [" <<i<<"]"<<endl;
+ return 0;
+ } else {
+ ClusterCutList->Add(analysisClusterCuts[i]);
+ analysisClusterCuts[i]->SetFillCutHistograms("");
+ }
+
+ analysisNeutralPionCuts[i] = new AliConversionMesonCuts();
+ if( ! analysisNeutralPionCuts[i]->InitializeCutsFromCutString(NeutralPionCutarray[i].Data()) ) {
+ cout<<"ERROR: analysisMesonCuts [ " <<i<<" ] "<<endl;
+ return 0;
+ } else {
+ NeutralPionCutList->Add(analysisNeutralPionCuts[i]);
+ analysisNeutralPionCuts[i]->SetFillCutHistograms("");
+ }
+
+ analysisMesonCuts[i] = new AliConversionMesonCuts();
+ if( ! analysisMesonCuts[i]->InitializeCutsFromCutString(MesonCutarray[i].Data()) ) {
+ cout<<"ERROR: analysisMesonCuts [ " <<i<<" ] "<<endl;
+ return 0;
+ } else {
+ MesonCutList->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 [ " <<i<<" ] "<<endl;
+ return 0;
+ } else {
+ PionCutList->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;
+
+}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff