fCutFolder(NULL),
fESDList(NULL),
fBackList(NULL),
+ fMotherList(NULL),
fTrueList(NULL),
fMCList(NULL),
fOutputContainer(0),
hMCChiCPt(NULL),
hMCChiCInAccPt(NULL),
hESDEposEnegTruePi0DalitzInvMassPt(NULL),
+ hESDEposEnegTruePi0DalitzPsiPairDPhi(NULL),
hESDEposEnegTrueEtaDalitzInvMassPt(NULL),
+ hESDEposEnegTrueEtaDalitzPsiPairDPhi(NULL),
hESDEposEnegTruePhotonInvMassPt(NULL),
+ hESDEposEnegTruePhotonPsiPairDPhi(NULL),
hESDEposEnegTrueJPsiInvMassPt(NULL),
hESDTrueMotherChiCInvMassPt(NULL),
hESDTrueMotherChiCDiffInvMassPt(NULL),
hESDTrueMotherInvMassPt(NULL),
hESDTrueMotherDalitzInvMassPt(NULL),
hESDTrueMotherPi0GGInvMassPt(NULL),
+ hESDTruePrimaryMotherPi0GGInvMassPt(NULL),
+ hESDTrueSecondaryMotherPi0GGInvMassPt(NULL),
hESDTruePrimaryMotherInvMassMCPt(NULL),
+ hESDTruePrimaryMotherInvMassPt(NULL),
+ hESDTruePrimaryMotherW0WeightingInvMassPt(NULL),
hESDTruePrimaryPi0DalitzESDPtMCPt(NULL),
hESDTrueSecondaryMotherInvMassPt(NULL),
hESDTrueSecondaryMotherFromK0sInvMassPt(NULL),
hESDTruePi0DalitzSecElectronPt(NULL),
hNEvents(NULL),
hNGoodESDTracks(NULL),
+ hEtaShift(NULL),
fRandom(0),
fUnsmearedPx(NULL),
fUnsmearedPy(NULL),
fMoveParticleAccordingToVertex(kFALSE),
fIsHeavyIon(kFALSE),
fDoMesonAnalysis(kTRUE),
+ fDoChicAnalysis(kFALSE),
+ fDoMesonQA(kFALSE),
fIsFromMBHeader(kTRUE),
fIsMC(kFALSE)
{
fCutFolder(NULL),
fESDList(NULL),
fBackList(NULL),
+ fMotherList(NULL),
fTrueList(NULL),
fMCList(NULL),
fOutputContainer(0),
hMCChiCPt(NULL),
hMCChiCInAccPt(NULL),
hESDEposEnegTruePi0DalitzInvMassPt(NULL),
+ hESDEposEnegTruePi0DalitzPsiPairDPhi(NULL),
hESDEposEnegTrueEtaDalitzInvMassPt(NULL),
+ hESDEposEnegTrueEtaDalitzPsiPairDPhi(NULL),
hESDEposEnegTruePhotonInvMassPt(NULL),
+ hESDEposEnegTruePhotonPsiPairDPhi(NULL),
hESDEposEnegTrueJPsiInvMassPt(NULL),
hESDTrueMotherChiCInvMassPt(NULL),
hESDTrueMotherChiCDiffInvMassPt(NULL),
hESDTrueMotherInvMassPt(NULL),
hESDTrueMotherDalitzInvMassPt(NULL),
hESDTrueMotherPi0GGInvMassPt(NULL),
+ hESDTruePrimaryMotherPi0GGInvMassPt(NULL),
+ hESDTrueSecondaryMotherPi0GGInvMassPt(NULL),
hESDTruePrimaryMotherInvMassMCPt(NULL),
+ hESDTruePrimaryMotherInvMassPt(NULL),
+ hESDTruePrimaryMotherW0WeightingInvMassPt(NULL),
hESDTruePrimaryPi0DalitzESDPtMCPt(NULL),
hESDTrueSecondaryMotherInvMassPt(NULL),
hESDTrueSecondaryMotherFromK0sInvMassPt(NULL),
hESDTruePi0DalitzSecElectronPt(NULL),
hNEvents(NULL),
hNGoodESDTracks(NULL),
+ hEtaShift(NULL),
fRandom(0),
fUnsmearedPx(NULL),
fUnsmearedPy(NULL),
fMoveParticleAccordingToVertex(kFALSE),
fIsHeavyIon(kFALSE),
fDoMesonAnalysis(kTRUE),
+ fDoChicAnalysis(kFALSE),
+ fDoMesonQA(kFALSE),
fIsFromMBHeader(kTRUE),
fIsMC(kFALSE)
{
fGammasPool = 0x0;
}
}
-
//___________________________________________________________
void AliAnalysisTaskGammaConvDalitzV1::InitBack(){
- Double_t *zBinLimitsArray= new Double_t[9];
- zBinLimitsArray[0] = -50.00;
- zBinLimitsArray[1] = -3.375;
- zBinLimitsArray[2] = -1.605;
- zBinLimitsArray[3] = -0.225;
- zBinLimitsArray[4] = 1.065;
- zBinLimitsArray[5] = 2.445;
- zBinLimitsArray[6] = 4.245;
- zBinLimitsArray[7] = 50.00;
- zBinLimitsArray[8] = 1000.00;
-
- Double_t *multiplicityBinLimitsArrayTracks= new Double_t[6];
- multiplicityBinLimitsArrayTracks[0] = 0;
- multiplicityBinLimitsArrayTracks[1] = 8.5;
- multiplicityBinLimitsArrayTracks[2] = 16.5;
- multiplicityBinLimitsArrayTracks[3] = 27.5;
- multiplicityBinLimitsArrayTracks[4] = 41.5;
- multiplicityBinLimitsArrayTracks[5] = 200.;
-
- if(fIsHeavyIon){
- multiplicityBinLimitsArrayTracks[0] = 0;
- multiplicityBinLimitsArrayTracks[1] = 200.;
- multiplicityBinLimitsArrayTracks[2] = 500.;
- multiplicityBinLimitsArrayTracks[3] = 1000.;
- multiplicityBinLimitsArrayTracks[4] = 1500.;
- multiplicityBinLimitsArrayTracks[5] = 5000.;
- }
-
- Double_t *multiplicityBinLimitsArrayV0s= new Double_t[5];
-
- multiplicityBinLimitsArrayV0s[0] = 2;
- multiplicityBinLimitsArrayV0s[1] = 3;
- multiplicityBinLimitsArrayV0s[2] = 4;
- multiplicityBinLimitsArrayV0s[3] = 5;
- multiplicityBinLimitsArrayV0s[4] = 9999;
-
- if(fIsHeavyIon){
- multiplicityBinLimitsArrayV0s[0] = 2;
- multiplicityBinLimitsArrayV0s[1] = 10;
- multiplicityBinLimitsArrayV0s[2] = 30;
- multiplicityBinLimitsArrayV0s[3] = 50;
- multiplicityBinLimitsArrayV0s[4] = 9999;
- }
-
const Int_t nDim = 4;
- Int_t nBins[nDim] = {1000,250,8,5};
- Double_t xMin[nDim] = {0,0, 0,0};
- Double_t xMax[nDim] = {1,25,8,5};
-
- sESDMotherInvMassPtZM = new THnSparseF*[fnCuts];
+ Int_t nBins[nDim] = {800,250,7,4};
+ Double_t xMin[nDim] = {0,0, 0,0};
+ Double_t xMax[nDim] = {0.8,25,7,4};
+
+ sESDMotherInvMassPtZM = new THnSparseF*[fnCuts];
sESDMotherBackInvMassPtZM = new THnSparseF*[fnCuts];
-
fBGHandler = new AliGammaConversionAODBGHandler*[fnCuts];
-
+ //fBGHandlerRP = new AliConversionAODBGHandlerRP*[fnCuts];
for(Int_t iCut = 0; iCut<fnCuts;iCut++){
+ //if (((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->DoBGCalculation()){
+
+
+ TString cutstringElectron = ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetCutNumber();
+ TString cutstringMeson = ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->GetCutNumber();
+ TString cutstringGamma = ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutNumber();
- TString cutstringElectron = ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetCutNumber();
- TString cutstringMeson = ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->GetCutNumber();
- TString cutstringGamma = ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutNumber();
+
+ Int_t collisionSystem = atoi((TString)(((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutNumber())(0,1));
+ Int_t centMin = atoi((TString)(((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutNumber())(1,1));
+ Int_t centMax = atoi((TString)(((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutNumber())(2,1));
+
+ if(collisionSystem == 1 || collisionSystem == 2 ||
+ collisionSystem == 5 || collisionSystem == 8 ||
+ collisionSystem == 9){
+ centMin = centMin*10;
+ centMax = centMax*10;
+ }
+ else if(collisionSystem == 3 || collisionSystem == 6){
+ centMin = centMin*5;
+ centMax = centMax*5;
+ }
+ else if(collisionSystem == 4 || collisionSystem == 7){
+ centMin = ((centMin*5)+45);
+ centMax = ((centMax*5)+45);
+ }
- fBackList[iCut] = new TList();
- fBackList[iCut]->SetName(Form("%s_%s_%s Back histograms",cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
- fBackList[iCut]->SetOwner(kTRUE);
- fCutFolder[iCut]->Add(fBackList[iCut]);
+ fBackList[iCut] = new TList();
+ fBackList[iCut]->SetName(Form("%s_%s_%s Back histograms",cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
+ fBackList[iCut]->SetOwner(kTRUE);
+ fCutFolder[iCut]->Add(fBackList[iCut]);
- sESDMotherInvMassPtZM[iCut] = new THnSparseF("Back_Mother_InvMass_Pt_z_m","Back_Mother_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
- sESDMotherInvMassPtZM[iCut]->Sumw2();
- fBackList[iCut]->Add(sESDMotherInvMassPtZM[iCut]);
- sESDMotherBackInvMassPtZM[iCut] = new THnSparseF("Back_Back_InvMass_Pt_z_m","Back_Back_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
- sESDMotherBackInvMassPtZM[iCut]->Sumw2();
- fBackList[iCut]->Add(sESDMotherBackInvMassPtZM[iCut]);
+ sESDMotherBackInvMassPtZM[iCut] = new THnSparseF("Back_Back_InvMass_Pt_z_m","Back_Back_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
+ fBackList[iCut]->Add(sESDMotherBackInvMassPtZM[iCut]);
- if(((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->UseTrackMultiplicity()) {
- fBGHandler[iCut] = new AliGammaConversionAODBGHandler(9,6,((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->NumberOfRotationEvents());
- fBGHandler[iCut]->Initialize(zBinLimitsArray, multiplicityBinLimitsArrayTracks);
- }
- else{
- fBGHandler[iCut] = new AliGammaConversionAODBGHandler(9,5,((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->NumberOfRotationEvents());
- fBGHandler[iCut]->Initialize(zBinLimitsArray, multiplicityBinLimitsArrayV0s);
- }
- if( ( (AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetBKGMethod() == 3 ){
+ fMotherList[iCut] = new TList();
+ fMotherList[iCut]->SetName(Form("%s_%s_%s Mother histograms",cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
+ fMotherList[iCut]->SetOwner(kTRUE);
+ fCutFolder[iCut]->Add(fMotherList[iCut]);
+
+ sESDMotherInvMassPtZM[iCut] = new THnSparseF("Back_Mother_InvMass_Pt_z_m","Back_Mother_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
+ fMotherList[iCut]->Add(sESDMotherInvMassPtZM[iCut]);
+
+
+ fBGHandler[iCut] = new AliGammaConversionAODBGHandler(
+ collisionSystem,centMin,centMax,
+ ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->NumberOfRotationEvents(),
+ ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->UseTrackMultiplicity());
+
+ if( ( (AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetBKGMethod() == 3 ){
fGammasPool[iCut] = new TList();
- }
- }
+ }
+ //}
+ }
}
//______________________________________________________________________
fCutFolder = new TList*[fnCuts];
fESDList = new TList*[fnCuts];
fBackList = new TList*[fnCuts];
+ fMotherList = new TList*[fnCuts];
hNEvents = new TH1I*[fnCuts];
hNGoodESDTracks = new TH1I*[fnCuts];
+ hEtaShift = new TProfile*[fnCuts];
hESDConvGammaPt = new TH1F*[fnCuts];
hESDDalitzElectronPt = new TH1F*[fnCuts];
hESDDalitzPositronPt = new TH1F*[fnCuts];
hESDDalitzElectronPhi = new TH1F*[fnCuts];
hESDDalitzPositronPhi = new TH1F*[fnCuts];
+
+ if( fDoMesonQA ) {
hESDDalitzElectronAfterPt = new TH1F*[fnCuts];
hESDDalitzPositronAfterPt = new TH1F*[fnCuts];
hESDDalitzElectronAfterPhi = new TH1F*[fnCuts];
hESDEposEnegPsiPairDPhi = new TH2F*[fnCuts];
hESDEposEnegInvMassPt = new TH2F*[fnCuts];
hESDEposEnegLikeSignBackInvMassPt = new TH2F*[fnCuts];
+
+ }
+
+
+
hESDMotherInvMassPt = new TH2F*[fnCuts];
+
+ if(fDoChicAnalysis) {
hESDPi0MotherInvMassPt = new TH2F*[fnCuts];
hESDPi0MotherDiffInvMassPt = new TH2F*[fnCuts];
- hESDPi0MotherDiffLimInvMassPt = new TH2F*[fnCuts];
+ hESDPi0MotherDiffLimInvMassPt = new TH2F*[fnCuts];
+ }
+
+
hESDMotherBackInvMassPt = new TH2F*[fnCuts];
else hNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",200,0,200);
fESDList[iCut]->Add(hNGoodESDTracks[iCut]);
+ hEtaShift[iCut] = new TProfile("Eta Shift","Eta Shift",1, -0.5,0.5);
+ fESDList[iCut]->Add(hEtaShift[iCut]);
+
hESDConvGammaPt[iCut] = new TH1F("ESD_ConvGamma_Pt","ESD_ConvGamma_Pt",250,0,25);
fESDList[iCut]->Add(hESDConvGammaPt[iCut]);
hESDDalitzPositronPhi[iCut] = new TH1F("ESD_DalitzPositron_Phi","ESD_DalitzPositron_Phi",360,0,2*TMath::Pi());
fESDList[iCut]->Add(hESDDalitzPositronPhi[iCut]);
+
+ if ( fDoMesonQA ) {
+
+
hESDDalitzElectronAfterPt[iCut] = new TH1F("ESD_DalitzElectron_After_Pt","ESD_DalitzElectron_After_Pt",1000,0,25);
fESDList[iCut]->Add(hESDDalitzElectronAfterPt[iCut]);
hESDDalitzPositronAfterPt[iCut] = new TH1F("ESD_DalitzPositron_After_Pt","ESD_DalitzPositron_After_Pt",1000,0,25);
fESDList[iCut]->Add(hESDDalitzPositronAfterPt[iCut]);
-
-
+
hESDDalitzElectronAfterPhi[iCut] = new TH1F("ESD_DalitzElectron_After_Phi","ESD_DalitzElectron_After_Phi",360,0,2*TMath::Pi());
fESDList[iCut]->Add(hESDDalitzElectronAfterPhi[iCut]);
hESDDalitzPosEleAfterTPCdEdxSignal[iCut] =new TH2F("ESD_DalitzPosEle_After_TPCdEdxSignal","ESD_DalitzPosEle_After_TPCdEdxSignal" ,150,0.05,20.0,800,0.0,200);
fESDList[iCut]->Add(hESDDalitzPosEleAfterTPCdEdxSignal[iCut]);
+ hESDMotherPhi[iCut] = new TH1F("ESD_DalitzMother_Phi","ESD_DalitzMother_Phi",360,0,2*TMath::Pi());
+ fESDList[iCut]->Add(hESDMotherPhi[iCut]);
+
hESDEposEnegPsiPairDPhi[iCut] = new TH2F("ESD_EposEneg_PsiPair_DPhi","ESD_EposEneg_PsiPair_DPhi", 100, -1.0,1.0,100,-1.0,1.0 );
fESDList[iCut]->Add(hESDEposEnegPsiPairDPhi[iCut]);
hESDEposEnegLikeSignBackInvMassPt[iCut] = new TH2F("ESD_EposEneg_LikeSignBack_InvMassPt","ESD_EposEneg_LikeSignBack_InvMassPt",5000,0.,5.,100,0.,10.);
fESDList[iCut]->Add(hESDEposEnegLikeSignBackInvMassPt[iCut]);
+
+ }
+
+
+
+
+
+
+
- hESDMotherInvMassPt[iCut] = new TH2F("ESD_DalitzMother_InvMass_Pt","ESD_DalitzMother_InvMass_Pt",1000,0,1,250,0,25);
+ hESDMotherInvMassPt[iCut] = new TH2F("ESD_DalitzMother_InvMass_Pt","ESD_DalitzMother_InvMass_Pt",800,0,0.8,250,0,25);
fESDList[iCut]->Add(hESDMotherInvMassPt[iCut]);
- hESDMotherPhi[iCut] = new TH1F("ESD_DalitzMother_Phi","ESD_DalitzMother_Phi",360,0,2*TMath::Pi());
- fESDList[iCut]->Add(hESDMotherPhi[iCut]);
+
+ if( fDoChicAnalysis) {
hESDPi0MotherInvMassPt[iCut] = new TH2F("ESD_Pi0Mother_InvMass_Pt","ESD_Pi0Mother_InvMass_Pt",4000,0,4,250,0,25);
fESDList[iCut]->Add(hESDPi0MotherInvMassPt[iCut]);
hESDPi0MotherDiffLimInvMassPt[iCut] = new TH2F("ESD_Pi0Mother_DiffLimInvMass_Pt","ESD_Pi0Mother_DiffLimInvMass_Pt",2000,0,2,250,0,25);
fESDList[iCut]->Add(hESDPi0MotherDiffLimInvMassPt[iCut]);
+
+ }
- hESDMotherBackInvMassPt[iCut] = new TH2F("ESD_DalitzBackground_InvMass_Pt","ESD_DalitzBackground_InvMass_Pt",1000,0,1,250,0,25);
- fESDList[iCut]->Add(hESDMotherBackInvMassPt[iCut]);
+ hESDMotherBackInvMassPt[iCut] = new TH2F("ESD_DalitzBackground_InvMass_Pt","ESD_DalitzBackground_InvMass_Pt",800,0,0.8,250,0,25);
+ fESDList[iCut]->Add(hESDMotherBackInvMassPt[iCut]);
+ if ( fDoMesonQA ) {
+
TAxis *AxisAfter = hESDDalitzPosEleAfterTPCdEdx[iCut]->GetXaxis();
Int_t bins = AxisAfter->GetNbins();
Double_t from = AxisAfter->GetXmin();
AxisAfter->Set(bins, newBins);
delete [] newBins;
+
+ }
hMCEtaInAccPt = new TH1F*[fnCuts];
hMCChiCPt = new TH1F*[fnCuts];
hMCChiCInAccPt = new TH1F*[fnCuts];
+
+
+ if ( fDoMesonQA ) {
+ hESDEposEnegTruePi0DalitzInvMassPt = new TH2F*[fnCuts];
+ hESDEposEnegTruePi0DalitzPsiPairDPhi = new TH2F*[fnCuts];
+ hESDEposEnegTrueEtaDalitzInvMassPt = new TH2F*[fnCuts];
+ hESDEposEnegTrueEtaDalitzPsiPairDPhi = new TH2F*[fnCuts];
+ hESDEposEnegTruePhotonInvMassPt = new TH2F*[fnCuts];
+ hESDEposEnegTruePhotonPsiPairDPhi = new TH2F*[fnCuts];
+ hESDEposEnegTrueJPsiInvMassPt = new TH2F*[fnCuts];
+ }
- hESDEposEnegTruePi0DalitzInvMassPt = new TH2F*[fnCuts];
- hESDEposEnegTrueEtaDalitzInvMassPt = new TH2F*[fnCuts];
- hESDEposEnegTruePhotonInvMassPt = new TH2F*[fnCuts];
- hESDEposEnegTrueJPsiInvMassPt = new TH2F*[fnCuts];
+ if( fDoChicAnalysis ){
hESDTrueMotherChiCInvMassPt = new TH2F*[fnCuts];
hESDTrueMotherChiCDiffInvMassPt = new TH2F*[fnCuts];
+ }
+
+
hESDTrueMotherInvMassPt = new TH2F*[fnCuts];
hESDTrueMotherDalitzInvMassPt = new TH2F*[fnCuts];
hESDTrueMotherPi0GGInvMassPt = new TH2F*[fnCuts];
+ hESDTruePrimaryMotherPi0GGInvMassPt = new TH2F*[fnCuts];
+ hESDTrueSecondaryMotherPi0GGInvMassPt = new TH2F*[fnCuts];
hESDTruePrimaryPi0DalitzESDPtMCPt = new TH2F*[fnCuts];
hESDTruePrimaryMotherInvMassMCPt = new TH2F*[fnCuts];
+ hESDTruePrimaryMotherInvMassPt = new TH2F*[fnCuts];
+ hESDTruePrimaryMotherW0WeightingInvMassPt = new TH2F*[fnCuts];
hESDTrueSecondaryMotherInvMassPt = new TH2F*[fnCuts];
hESDTrueSecondaryMotherFromK0sInvMassPt = new TH2F*[fnCuts];
hESDTrueBckGGInvMassPt = new TH2F*[fnCuts];
fMCList[iCut]->Add(hMCAllElectronsPt[iCut]);
hMCPi0DalitzGammaPt[iCut] = new TH1F("MC_Pi0DalitzGamma_Pt","MC_Pi0DalitzGamma_Pt",250,0,25);
+ hMCPi0DalitzGammaPt[iCut]->Sumw2();
fMCList[iCut]->Add(hMCPi0DalitzGammaPt[iCut]);
hMCPi0DalitzPositronPt[iCut] = new TH1F("MC_Pi0DalitzPositron_Pt","MC_Pi0DalitzPositron_Pt",1000,0,25);
+ hMCPi0DalitzPositronPt[iCut]->Sumw2();
fMCList[iCut]->Add(hMCPi0DalitzPositronPt[iCut]);
hMCPi0DalitzElectronPt[iCut] = new TH1F("MC_Pi0DalitzElectron_Pt","MC_Pi0DalitzElectron_Pt",1000,0,25);
+ hMCPi0DalitzElectronPt[iCut]->Sumw2();
fMCList[iCut]->Add(hMCPi0DalitzElectronPt[iCut]);
hMCPi0Pt[iCut] = new TH1F("MC_Pi0_Pt","MC_Pi0_Pt",250,0,25);
+ hMCPi0Pt[iCut]->Sumw2();
fMCList[iCut]->Add(hMCPi0Pt[iCut]);
hMCPi0GGPt[iCut] = new TH1F("MC_Pi0_GG_Pt","MC_Pi0_GG_Pt",250,0,25);
+ hMCPi0GGPt[iCut]->Sumw2();
fMCList[iCut]->Add(hMCPi0GGPt[iCut]);
hMCEtaPt[iCut] = new TH1F("MC_Eta_Pt","MC_Eta_Pt",250,0,25);
+ hMCEtaPt[iCut]->Sumw2();
fMCList[iCut]->Add(hMCEtaPt[iCut]);
hMCEtaGGPt[iCut] = new TH1F("MC_Eta_GG_Pt","MC_Eta_GG_Pt",250,0,25);
+ hMCEtaGGPt[iCut]->Sumw2();
fMCList[iCut]->Add(hMCEtaGGPt[iCut]);
hMCPi0InAccPt[iCut] = new TH1F("MC_Pi0DalitzInAcc_Pt","MC_Pi0DalitzInAcc_Pt",250,0,25);
+ hMCPi0InAccPt[iCut]->Sumw2();
fMCList[iCut]->Add(hMCPi0InAccPt[iCut]);
hMCEtaInAccPt[iCut] = new TH1F("MC_EtaDalitzInAcc_Pt","MC_EtaDalitzInAcc_Pt",250,0,25);
+ hMCEtaInAccPt[iCut]->Sumw2();
fMCList[iCut]->Add(hMCEtaInAccPt[iCut]);
hMCChiCPt[iCut] = new TH1F("MC_ChiC_Pt","MC_ChiC_Pt",250,0,25);
fTrueList[iCut]->SetOwner(kTRUE);
fCutFolder[iCut]->Add(fTrueList[iCut]);
-
+ if ( fDoMesonQA ) {
+
+
hESDEposEnegTruePi0DalitzInvMassPt[iCut] = new TH2F("ESD_EposEneg_TruePi0Dalitz_InvMassPt","ESD_EposEneg_TruePi0Dalitz_InvMassPt",5000,0.,5.,100,0.,10.);
fTrueList[iCut]->Add(hESDEposEnegTruePi0DalitzInvMassPt[iCut]);
+
+ hESDEposEnegTruePi0DalitzPsiPairDPhi[iCut] = new TH2F("ESD_EposEneg_TruePi0Dalitz_PsiPair_DPhi","ESD_EposEneg_TruePi0Dalitz_PsiPair_DPhi", 100, -1.0,1.0,100,-1.0,1.0 );
+ fTrueList[iCut]->Add(hESDEposEnegTruePi0DalitzPsiPairDPhi[iCut]);
+
hESDEposEnegTrueEtaDalitzInvMassPt[iCut] = new TH2F("ESD_EposEneg_TrueEtaDalitz_InvMassPt","ESD_EposEneg_TrueEtaDalitz_InvMassPt",5000,0.,5.,100,0.,10.);
fTrueList[iCut]->Add(hESDEposEnegTrueEtaDalitzInvMassPt[iCut]);
+
+ hESDEposEnegTrueEtaDalitzPsiPairDPhi[iCut] = new TH2F("ESD_EposEneg_TrueEtaDalitz_PsiPair_DPhi","ESD_EposEneg_TrueEtaDalitz_PsiPair_DPhi", 100, -1.0,1.0,100,-1.0,1.0 );
+ fTrueList[iCut]->Add(hESDEposEnegTrueEtaDalitzPsiPairDPhi[iCut]);
hESDEposEnegTruePhotonInvMassPt[iCut] = new TH2F("ESD_EposEneg_TruePhoton_InvMassPt","ESD_EposEneg_TruePhoton_InvMassPt",5000,0.,5.,100,0.,10.);
fTrueList[iCut]->Add(hESDEposEnegTruePhotonInvMassPt[iCut]);
-
+
+ hESDEposEnegTruePhotonPsiPairDPhi[iCut] = new TH2F("ESD_EposEneg_TruePhoton_PsiPair_DPhi","ESD_EposEneg_TruePhoton_PsiPair_DPhi", 100, -1.0,1.0,100,-1.0,1.0 );
+ fTrueList[iCut]->Add(hESDEposEnegTruePhotonPsiPairDPhi[iCut]);
+
hESDEposEnegTrueJPsiInvMassPt[iCut] = new TH2F("ESD_EposEneg_TrueJPsi_InvMassPt","ESD_EposEneg_TrueJPsi_InvMassPt",5000,0.,5.,100,0.,10.);
fTrueList[iCut]->Add(hESDEposEnegTrueJPsiInvMassPt[iCut]);
+
+
+
+ }
+
+
hESDTruePositronPt[iCut] = new TH1F("ESD_TruePositron_Pt","ESD_TruePositron_Pt",1000,0,25);
fTrueList[iCut]->Add(hESDTruePositronPt[iCut]);
hESDTruePi0DalitzSecPositronPt[iCut] = new TH1F("ESD_TruePi0DalitzSecPositron_Pt","ESD_TruePi0DalitzSecPositron_Pt",1000,0,25);
fTrueList[iCut]->Add(hESDTruePi0DalitzSecPositronPt[iCut]);
- hESDTrueMotherChiCInvMassPt[iCut] = new TH2F("ESD_TrueMotherChiC_InvMass_Pt","ESD_TrueMotherChiC_InvMass_Pt",1000,0,4,250,0,25);
+ if( fDoChicAnalysis) {
+
+ hESDTrueMotherChiCInvMassPt[iCut] = new TH2F("ESD_TrueMotherChiC_InvMass_Pt","ESD_TrueMotherChiC_InvMass_Pt",4000,0,4,250,0,25);
fTrueList[iCut]->Add(hESDTrueMotherChiCInvMassPt[iCut]);
- hESDTrueMotherChiCDiffInvMassPt[iCut] = new TH2F("ESD_TrueMotherChiCDiff_InvMass_Pt","ESD_TrueMotherChiCDiff_InvMass_Pt",1000,0,1,250,0,25);
+ hESDTrueMotherChiCDiffInvMassPt[iCut] = new TH2F("ESD_TrueMotherChiCDiff_InvMass_Pt","ESD_TrueMotherChiCDiff_InvMass_Pt",2000,0,2,250,0,25);
fTrueList[iCut]->Add(hESDTrueMotherChiCDiffInvMassPt[iCut]);
+
+ }
- hESDTrueMotherInvMassPt[iCut] = new TH2F("ESD_TrueMother_InvMass_Pt","ESD_TrueMother_InvMass_Pt",1000,0,1,250,0,25);
+ hESDTrueMotherInvMassPt[iCut] = new TH2F("ESD_TrueMother_InvMass_Pt","ESD_TrueMother_InvMass_Pt",800,0,0.8,250,0,25);
+ hESDTrueMotherInvMassPt[iCut]->Sumw2();
fTrueList[iCut]->Add(hESDTrueMotherInvMassPt[iCut]);
- hESDTrueMotherDalitzInvMassPt[iCut] = new TH2F("ESD_TrueMother_Dalitz_InvMass_Pt","ESD_TrueMother_Dalitz_InvMass_Pt",1000,0,1,250,0,25);
+ hESDTrueMotherDalitzInvMassPt[iCut] = new TH2F("ESD_TrueMother_Dalitz_InvMass_Pt","ESD_TrueMother_Dalitz_InvMass_Pt",800,0,0.8,250,0,25);
+ hESDTrueMotherDalitzInvMassPt[iCut]->Sumw2();
fTrueList[iCut]->Add(hESDTrueMotherDalitzInvMassPt[iCut]);
- hESDTrueMotherPi0GGInvMassPt[iCut] = new TH2F("ESD_TrueMotherPi0GG_InvMass_Pt","ESD_TrueMotherPi0GG_InvMass_Pt",1000,0,1,250,0,25);
+ hESDTrueMotherPi0GGInvMassPt[iCut] = new TH2F("ESD_TrueMotherPi0GG_InvMass_Pt","ESD_TrueMotherPi0GG_InvMass_Pt",800,0,0.8,250,0,25);
+ hESDTrueMotherPi0GGInvMassPt[iCut]->Sumw2();
fTrueList[iCut]->Add(hESDTrueMotherPi0GGInvMassPt[iCut]);
+
+ hESDTruePrimaryMotherPi0GGInvMassPt[iCut] = new TH2F("ESD_TruePrimaryMotherPi0GG_InvMass_Pt","ESD_TruePrimaryMotherPi0GG_InvMass_Pt",800,0,0.8,250,0,25);
+ hESDTruePrimaryMotherPi0GGInvMassPt[iCut]->Sumw2();
+ fTrueList[iCut]->Add(hESDTruePrimaryMotherPi0GGInvMassPt[iCut]);
+
+ hESDTrueSecondaryMotherPi0GGInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryMotherPi0GG_InvMass_Pt","ESD_TrueSecondaryMotherPi0GG_InvMass_Pt",800,0,0.8,250,0,25);
+ hESDTrueSecondaryMotherPi0GGInvMassPt[iCut]->Sumw2();
+ fTrueList[iCut]->Add(hESDTrueSecondaryMotherPi0GGInvMassPt[iCut]);
+
hESDTruePrimaryPi0DalitzESDPtMCPt[iCut] = new TH2F("ESD_TruePrimaryPi0Dalitz_ESDPt_MCPt","ESD_TruePrimaryPi0Dalitz_ESDPt_MCPt",250,0,25,250,0,25);
+ hESDTruePrimaryPi0DalitzESDPtMCPt[iCut]->Sumw2();
fTrueList[iCut]->Add(hESDTruePrimaryPi0DalitzESDPtMCPt[iCut]);
- hESDTruePrimaryMotherInvMassMCPt[iCut] = new TH2F("ESD_TruePrimaryMother_InvMass_MCPt","ESD_TrueDalitzPrimaryMother_InvMass_MCPt",1000,0,1,250,0,25);
+ hESDTruePrimaryMotherInvMassMCPt[iCut] = new TH2F("ESD_TruePrimaryMother_InvMass_MCPt","ESD_TrueDalitzPrimaryMother_InvMass_MCPt",800,0,0.8,250,0,25);
+ hESDTruePrimaryMotherInvMassMCPt[iCut]->Sumw2();
fTrueList[iCut]->Add(hESDTruePrimaryMotherInvMassMCPt[iCut]);
- hESDTrueSecondaryMotherInvMassPt[iCut] = new TH2F("ESD_TrueDalitzSecondaryMother_InvMass_Pt","ESD_TrueDalitzSecondaryMother_InvMass_Pt",1000,0,1,250,0,25);
+ hESDTruePrimaryMotherInvMassPt[iCut] = new TH2F("ESD_TruePrimaryMother_InvMass_Pt","ESD_TruePrimaryMother_InvMass_Pt",800,0,0.8,250,0,25);
+ hESDTruePrimaryMotherInvMassPt[iCut]->Sumw2();
+ fTrueList[iCut]->Add(hESDTruePrimaryMotherInvMassPt[iCut]);
+ hESDTruePrimaryMotherW0WeightingInvMassPt[iCut] = new TH2F("ESD_TruePrimaryMotherW0Weighting_InvMass_Pt","ESD_TruePrimaryMotherW0Weighting_InvMass_Pt",800,0,0.8,250,0,25);
+ hESDTruePrimaryMotherW0WeightingInvMassPt[iCut]->Sumw2();
+ fTrueList[iCut]->Add(hESDTruePrimaryMotherW0WeightingInvMassPt[iCut]);
+
+ hESDTrueSecondaryMotherInvMassPt[iCut] = new TH2F("ESD_TrueDalitzSecondaryMother_InvMass_Pt","ESD_TrueDalitzSecondaryMother_InvMass_Pt",800,0,0.8,250,0,25);
+ hESDTrueSecondaryMotherInvMassPt[iCut]->Sumw2();
fTrueList[iCut]->Add(hESDTrueSecondaryMotherInvMassPt[iCut]);
// hESDTrueSecondaryMotherFromK0sInvMassPt[iCut] = new TH2F("ESD_TrueDalitzSecondaryMotherFromK0s_InvMass_Pt","ESD_TrueDalitzSecondaryMotherFromK0s_InvMass_Pt",1000,0,1,250,0,25);
// fTrueList[iCut]->Add(hESDTrueSecondaryMotherFromK0sInvMassPt[iCut]);
- hESDTrueBckGGInvMassPt[iCut] = new TH2F("ESD_TrueDalitzBckGG_InvMass_Pt","ESD_TrueDalitzBckGG_InvMass_Pt",1000,0,1,250,0,25);
+ hESDTrueBckGGInvMassPt[iCut] = new TH2F("ESD_TrueDalitzBckGG_InvMass_Pt","ESD_TrueDalitzBckGG_InvMass_Pt",800,0,0.8,250,0,25);
fTrueList[iCut]->Add(hESDTrueBckGGInvMassPt[iCut]);
- hESDTrueBckContInvMassPt[iCut] = new TH2F("ESD_TrueDalitzBckCont_InvMass_Pt","ESD_TrueDalitzBckCont_InvMass_Pt",1000,0,1,250,0,25);
+ hESDTrueBckContInvMassPt[iCut] = new TH2F("ESD_TrueDalitzBckCont_InvMass_Pt","ESD_TrueDalitzBckCont_InvMass_Pt",800,0,0.8,250,0,25);
fTrueList[iCut]->Add(hESDTrueBckContInvMassPt[iCut]);
// hESDTrueMotherGGInvMassPt[iCut] = new TH2F("ESD_TrueGammaGamma_InvMass_Pt","ESD_TrueGammaGamma_InvMass_Pt",1000,0,1,250,0,25);
// fTrueList[iCut]->Add(hESDTrueMotherGGInvMassPt[iCut]);
}
}
+
+ fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1");
+ if(!fV0Reader){printf("Error: No V0 Reader");return;} // GetV0Reader
+
+ if(fV0Reader)
+ if((AliConversionCuts*)fV0Reader->GetConversionCuts())
+ if(((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms())
+ fOutputContainer->Add(((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms());
+
+
+
+ fElecSelector=(AliDalitzElectronSelector*)AliAnalysisManager::GetAnalysisManager()->GetTask("ElectronSelector");
+ if(!fElecSelector){printf("Error: No ElectronSelector");return;} // GetV0Reader
+
+ if( fElecSelector ){
+
+ if ( ((AliDalitzElectronCuts*)fElecSelector->GetDalitzElectronCuts())->GetCutHistograms() ){
+ fOutputContainer->Add( ((AliDalitzElectronCuts*)fElecSelector->GetDalitzElectronCuts())->GetCutHistograms() );
+ }
+ }
+
+ for(Int_t iCut = 0; iCut<fnCuts;iCut++){
+
+ if( fCutElectronArray ){
+ if( ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetCutHistograms() ) {
+ fCutFolder[iCut]->Add( ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetCutHistograms() );
+ }
+ }
+
+ if( fCutMesonArray ) {
+ if( ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->GetCutHistograms() ) {
+ fCutFolder[iCut]->Add( ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->GetCutHistograms());
+ }
+ }
+
+ if( fCutGammaArray ) {
+ if( ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutHistograms() ) {
+ fCutFolder[iCut]->Add( ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutHistograms() );
+ }
+ }
+ }
PostData(1, fOutputContainer);
fSelectorElectronIndex = fElecSelector->GetReconstructedElectronsIndex(); // Electrons from default Cut
fSelectorPositronIndex = fElecSelector->GetReconstructedPositronsIndex(); // Positrons from default Cut
- CountESDTracks(); // Estimate Event Multiplicity
+ //CountESDTracks(); // Estimate Event Multiplicity
+ fNumberOfESDTracks = fV0Reader->GetNumberOfPrimaryTracks();
//AddTaskContainers(); //Add conatiner
for(Int_t iCut = 0; iCut<fnCuts; iCut++){
Bool_t AliAnalysisTaskGammaConvDalitzV1::Notify()
{
for(Int_t iCut = 0; iCut<fnCuts;iCut++){
- if(!((AliConversionCuts*)fCutGammaArray->At(iCut))->GetDoEtaShift()) continue; // No Eta Shift requested, continue
+
+
+ if( !((AliConversionCuts*)fCutGammaArray->At(iCut))->GetDoEtaShift() ){
+
+ /*if (((AliConversionCuts*)fCutGammaArray->At(iCut))->GetEtaShift() != 0.){
+ printf("Error: Gamma Conversion Dalitz Task %s :: Eta Shift not requested but set to %f, reset to 00. \n\n",
+ (((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutNumber()).Data(),((AliConversionCuts*)fCutGammaArray->At(iCut))->GetEtaShift());
+ ((AliConversionCuts*)fCutGammaArray->At(iCut))->SetEtaShift(0.);
+ ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->SetEtaShift(0.);
+
+
+ }*/
+ hEtaShift[iCut]->Fill(0.,0.);
+ continue; // No Eta Shift requested, continue
+ }
+
if( ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetEtaShift() == 0.0){ // Eta Shift requested but not set, get shift automatically
((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCorrectEtaShiftFromPeriod(fV0Reader->GetPeriodName());
((AliConversionCuts*)fCutGammaArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->SetEtaShift( ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetEtaShift() );
+ hEtaShift[iCut]->Fill(0.,(((AliConversionCuts*)fCutGammaArray->At(iCut))->GetEtaShift()));
continue;
}
else{
- printf(" Gamma Conversion Task %s :: Eta Shift Manually Set to %f \n\n",
+ printf(" Gamma Conversion Dalitz Task %s :: Eta Shift Manually Set to %f \n\n",
(((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutNumber()).Data(),((AliConversionCuts*)fCutGammaArray->At(iCut))->GetEtaShift());
((AliConversionCuts*)fCutGammaArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->SetEtaShift( ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetEtaShift() );
+ hEtaShift[iCut]->Fill(0.,(((AliConversionCuts*)fCutGammaArray->At(iCut))->GetEtaShift()));
}
}
void AliAnalysisTaskGammaConvDalitzV1::Terminate(const Option_t *)
{
- if( fElecSelector ){
-
- if ( ((AliDalitzElectronCuts*)fElecSelector->GetDalitzElectronCuts())->GetCutHistograms() ){
- fOutputContainer->Add( ((AliDalitzElectronCuts*)fElecSelector->GetDalitzElectronCuts())->GetCutHistograms() );
- }
- }
-
- if ( fV0Reader ) {
-
- if ( ((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms() ){
- fOutputContainer->Add( ((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms() );
- }
- }
-
- for(Int_t iCut = 0; iCut<fnCuts;iCut++){
-
- if( fCutElectronArray ){
- if( ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetCutHistograms() ) {
- fCutFolder[iCut]->Add( ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetCutHistograms() );
- }
- }
-
- if( fCutMesonArray ) {
- if( ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->GetCutHistograms() ) {
- fCutFolder[iCut]->Add( ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->GetCutHistograms());
- }
- }
-
- if( fCutGammaArray ) {
- if( ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutHistograms() ) {
- fCutFolder[iCut]->Add( ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutHistograms() );
- }
- }
- }
+///Grid
}
//________________________________________________________________________
}
- vector<Int_t> lGoodElectronIndex(0);
- vector<Int_t> lGoodPositronIndex(0);
-
+ vector<Int_t> lGoodElectronIndexPrev(0);
+ vector<Int_t> lGoodPositronIndexPrev(0);
+
+
+
for(UInt_t i = 0; i < fSelectorElectronIndex.size(); i++){
AliESDtrack* electronCandidate = fESDEvent->GetTrack(fSelectorElectronIndex[i]);
if(! ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelected(electronCandidate) ) continue;
- lGoodElectronIndex.push_back( fSelectorElectronIndex[i] );
+ lGoodElectronIndexPrev.push_back( fSelectorElectronIndex[i] );
hESDDalitzElectronPt[fiCut]->Fill(electronCandidate->Pt());
hESDDalitzElectronPhi[fiCut]->Fill(electronCandidate->Phi());
if( fMCEvent ) {
AliESDtrack* positronCandidate = fESDEvent->GetTrack( fSelectorPositronIndex[i] );
if(! ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelected(positronCandidate) ) continue;
- lGoodPositronIndex.push_back( fSelectorPositronIndex[i] );
+ lGoodPositronIndexPrev.push_back( fSelectorPositronIndex[i] );
hESDDalitzPositronPt[fiCut]->Fill( positronCandidate->Pt() );
hESDDalitzPositronPhi[fiCut]->Fill( positronCandidate->Phi() );
}
- vector<Bool_t> lElectronPsiIndex(lGoodElectronIndex.size(), kTRUE);
- vector<Bool_t> lPositronPsiIndex(lGoodPositronIndex.size(), kTRUE);
+ vector<Bool_t> lElectronPsiIndex(lGoodElectronIndexPrev.size(), kTRUE);
+ vector<Bool_t> lPositronPsiIndex(lGoodPositronIndexPrev.size(), kTRUE);
if( ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->DoPsiPairCut() == kTRUE ){
- for( UInt_t i = 0; i < lGoodElectronIndex.size(); i++ ) {
+ for( UInt_t i = 0; i < lGoodElectronIndexPrev.size(); i++ ) {
- AliESDtrack *electronCandidate = fESDEvent->GetTrack(lGoodElectronIndex[i]);
+ AliESDtrack *electronCandidate = fESDEvent->GetTrack(lGoodElectronIndexPrev[i]);
- for(UInt_t j = 0; j < lGoodPositronIndex.size(); j++){
- AliESDtrack *positronCandidate = fESDEvent->GetTrack(lGoodPositronIndex[j]);
+ for(UInt_t j = 0; j < lGoodPositronIndexPrev.size(); j++){
+ AliESDtrack *positronCandidate = fESDEvent->GetTrack(lGoodPositronIndexPrev[j]);
Double_t psiPair = GetPsiPair(positronCandidate,electronCandidate);
Double_t deltaPhi = magField * TVector2::Phi_mpi_pi( electronCandidate->GetConstrainedParam()->Phi()-positronCandidate->GetConstrainedParam()->Phi());
}
+ vector<Int_t> lGoodElectronIndex(0);
+ vector<Int_t> lGoodPositronIndex(0);
+
+
+ for( UInt_t i = 0; i < lGoodElectronIndexPrev.size(); i++ ) {
+
+ if( lElectronPsiIndex[i] == kTRUE )
+ lGoodElectronIndex.push_back( lGoodElectronIndexPrev[i] );
+ }
+
+ for( UInt_t i = 0; i < lGoodPositronIndexPrev.size(); i++ ) {
+
+ if( lPositronPsiIndex[i] == kTRUE )
+ lGoodPositronIndex.push_back( lGoodPositronIndexPrev[i] );
+ }
+
+
+
for(UInt_t i = 0; i < lGoodElectronIndex.size(); i++){
- if( lElectronPsiIndex[i] == kFALSE ) continue;
+ //if( lElectronPsiIndex[i] == kFALSE ) continue;
AliESDtrack *electronCandidate = fESDEvent->GetTrack(lGoodElectronIndex[i]);
for(UInt_t j = 0; j < lGoodPositronIndex.size(); j++){
- if( lPositronPsiIndex[j] == kFALSE ) continue;
+ //if( lPositronPsiIndex[j] == kFALSE ) continue;
AliESDtrack *positronCandidate = fESDEvent->GetTrack(lGoodPositronIndex[j]);
AliKFParticle positronCandidateKF( *positronCandidate->GetConstrainedParam(), ::kPositron );
Double_t deltaPhi = magField * TVector2::Phi_mpi_pi( electronCandidate->GetConstrainedParam()->Phi()-positronCandidate->GetConstrainedParam()->Phi());
-
- AliKFConversionPhoton* virtualPhoton = new AliKFConversionPhoton(electronCandidateKF,positronCandidateKF);
+ AliKFConversionPhoton* virtualPhoton = NULL;
+ virtualPhoton = new AliKFConversionPhoton(electronCandidateKF,positronCandidateKF);
AliKFVertex primaryVertexImproved(*fInputEvent->GetPrimaryVertex());
virtualPhoton->SetProductionVertex(primaryVertexImproved);
virtualPhoton->SetTrackLabels( lGoodPositronIndex[j], lGoodElectronIndex[i]);
-
- if(fMCEvent){
-
- // AliStack *fMCStack= fMCEvent->Stack();
- Int_t labeln=TMath::Abs(electronCandidate->GetLabel());
- Int_t labelp=TMath::Abs(positronCandidate->GetLabel());
- TParticle *fNegativeMCParticle = fMCStack->Particle(labeln);
- TParticle *fPositiveMCParticle = fMCStack->Particle(labelp);
- if( fPositiveMCParticle && fNegativeMCParticle) {
+
+
+ if( fMCEvent ) {
+
+ Int_t labeln=TMath::Abs(electronCandidate->GetLabel());
+ Int_t labelp=TMath::Abs(positronCandidate->GetLabel());
+ TParticle *fNegativeMCParticle = fMCStack->Particle(labeln);
+ TParticle *fPositiveMCParticle = fMCStack->Particle(labelp);
+
+ if( fPositiveMCParticle && fNegativeMCParticle) {
virtualPhoton->SetMCLabelPositive(labelp);
virtualPhoton->SetMCLabelNegative(labeln);
-
- }
-
- TParticle *mcVgamma=virtualPhoton->GetMCParticle(fMCStack);
-
-
- if(mcVgamma){
- // Check if it is a true photon
- if(mcVgamma->GetPdgCode() == 22){
- isPhoton = kTRUE;
- }else if(mcVgamma->GetPdgCode() == 443){
- isJPsi = kTRUE;
- }
- else if( IsDalitz( mcVgamma ) ){
- if ( mcVgamma->GetPdgCode() == 111 ) isPi0Dalitz = kTRUE;
- else if( mcVgamma->GetPdgCode() == 221 ) isEtaDalitz = kTRUE;
- }
- }
- }
-
-
- AliAODConversionPhoton *vphoton = new AliAODConversionPhoton(virtualPhoton); //To Apply PsiPairCut
-
+ }
+ }
+
+ AliAODConversionPhoton *vphoton = new AliAODConversionPhoton(virtualPhoton); //To Apply PsiPairCut
+
+ if ( fDoMesonQA ) {
+
+ if( fMCEvent ) {
+
+ TParticle *mcVgamma=virtualPhoton->GetMCParticle(fMCStack);
+
+ if(mcVgamma){
+ // Check if it is a true photon
+ if(mcVgamma->GetPdgCode() == 22){
+ isPhoton = kTRUE;
+ }else if(mcVgamma->GetPdgCode() == 443){
+ isJPsi = kTRUE;
+ }
+ else if( IsDalitz( mcVgamma ) ){
+ if ( mcVgamma->GetPdgCode() == 111 ) isPi0Dalitz = kTRUE;
+ else if( mcVgamma->GetPdgCode() == 221 ) isEtaDalitz = kTRUE;
+ }
+ }
+
+ if(isPhoton){
+ hESDEposEnegTruePhotonInvMassPt[fiCut]->Fill(vphoton->GetMass(),vphoton->Pt());
+ hESDEposEnegTruePhotonPsiPairDPhi[fiCut]->Fill(deltaPhi,psiPair);
+ }
+ else if(isJPsi){
+ hESDEposEnegTrueJPsiInvMassPt[fiCut]->Fill(vphoton->GetMass(),vphoton->Pt());
+ }
+ else if(isPi0Dalitz){
+ hESDEposEnegTruePi0DalitzInvMassPt[fiCut]->Fill(vphoton->GetMass(),vphoton->Pt());
+ hESDEposEnegTruePi0DalitzPsiPairDPhi[fiCut]->Fill(deltaPhi,psiPair);
+ }
+ else if(isEtaDalitz){
+ hESDEposEnegTrueEtaDalitzInvMassPt[fiCut]->Fill(vphoton->GetMass(),vphoton->Pt());
+ hESDEposEnegTrueEtaDalitzPsiPairDPhi[fiCut]->Fill(deltaPhi,psiPair);
+ }
+ }
+ }
+
+
+
+ if ( fDoMesonQA ) {
+
hESDEposEnegPsiPairDPhi[fiCut]->Fill(deltaPhi,psiPair);
hESDEposEnegInvMassPt[fiCut]->Fill(vphoton->GetMass(),vphoton->Pt());
+
+ }
- if( fMCEvent ) {
- if(isPhoton) hESDEposEnegTruePhotonInvMassPt[fiCut]->Fill(vphoton->GetMass(),vphoton->Pt());
- else if(isJPsi) hESDEposEnegTrueJPsiInvMassPt[fiCut]->Fill(vphoton->GetMass(),vphoton->Pt());
- else if(isPi0Dalitz)hESDEposEnegTruePi0DalitzInvMassPt[fiCut]->Fill(vphoton->GetMass(),vphoton->Pt());
- else if(isEtaDalitz)hESDEposEnegTrueEtaDalitzInvMassPt[fiCut]->Fill(vphoton->GetMass(),vphoton->Pt());
-
- }
-
- fGoodVirtualGammas->Add( vphoton );
+ if( ! fDoChicAnalysis ) {
+
+ if ( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoMassCut() == kTRUE ) {
+
+ Double_t MassCutMax = 1000.0;
+ if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->GetMassCutLowPt() >= ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->GetMassCutHighPt() ){
+ MassCutMax = ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->GetMassCutLowPt();
+ }
+ else {
+ MassCutMax = ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->GetMassCutHighPt();
+ }
+
+ if( vphoton->GetMass() > MassCutMax ) {
+
+
+ delete vphoton;
+ vphoton = 0x0;
+ delete virtualPhoton;
+ virtualPhoton = 0x0;
+ continue;
+
+ }
+
+ }
+ }
+
+
+ fGoodVirtualGammas->Add( vphoton );
+ delete virtualPhoton;
+ virtualPhoton=NULL;
}
}
-
+
//Computing mixing event
+
+ if( fDoMesonQA ) {
- for(UInt_t i = 0; i < lGoodElectronIndex.size(); i++){
+ for(UInt_t i = 0; i < lGoodElectronIndex.size(); i++){
- if( lElectronPsiIndex[i] == kFALSE ) continue;
+ //if( lElectronPsiIndex[i] == kFALSE ) continue;
AliESDtrack *electronCandidate1 = fESDEvent->GetTrack(lGoodElectronIndex[i]);
for(UInt_t j = i+1; j < lGoodElectronIndex.size(); j++){
- if( lElectronPsiIndex[j] == kFALSE ) continue;
+ //if( lElectronPsiIndex[j] == kFALSE ) continue;
AliESDtrack *electronCandidate2 = fESDEvent->GetTrack(lGoodElectronIndex[j]);
hESDEposEnegLikeSignBackInvMassPt[fiCut]->Fill(vphoton->GetMass(),vphoton->Pt());
delete vphoton;
delete virtualPhoton;
-
+ vphoton = 0x0;
+ virtualPhoton = 0x0;
}
}
- for(UInt_t i = 0; i < lGoodPositronIndex.size(); i++){
+ for(UInt_t i = 0; i < lGoodPositronIndex.size(); i++){
+
+
- if( lPositronPsiIndex[i] == kFALSE ) continue;
+ //if( lPositronPsiIndex[i] == kFALSE ) continue;
AliESDtrack *positronCandidate1 = fESDEvent->GetTrack(lGoodPositronIndex[i]);
for(UInt_t j = i+1; j < lGoodPositronIndex.size(); j++){
- if( lPositronPsiIndex[j] == kFALSE ) continue;
+ // if( lPositronPsiIndex[j] == kFALSE ) continue;
AliESDtrack *positronCandidate2 = fESDEvent->GetTrack(lGoodPositronIndex[j]);
delete vphoton;
- delete virtualPhoton;
+ delete virtualPhoton;
+ vphoton = 0x0;
+ virtualPhoton = 0x0;
}
}
-
+ }
}
//________________________________________________________________________
AliAODConversionMother *pi0cand = new AliAODConversionMother(gamma,Vgamma);
pi0cand->SetLabels(GammaIndex,virtualGammaIndex);
+
- if( ( ((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelected(pi0cand,kTRUE)) ){
+ if( ( ((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelected(pi0cand,kTRUE,((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetEtaShift())) ){
+
+ //cout<< "Meson Accepted "<<endl;
Int_t zbin= fBGHandler[fiCut]->GetZBinIndex(fESDEvent->GetPrimaryVertex()->GetZ());
Int_t mbin = 0;
mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGoodGammas->GetEntries());
}
- AliESDtrack *positronVgamma = fESDEvent->GetTrack( Vgamma->GetTrackLabelPositive() );
- AliESDtrack *electronVgamma = fESDEvent->GetTrack( Vgamma->GetTrackLabelNegative() );
- Double_t clsToFPos = ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetNFindableClustersTPC(positronVgamma);
- Double_t clsToFNeg = ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetNFindableClustersTPC(electronVgamma);
+ AliESDtrack *positronVgamma = 0;
+ AliESDtrack *electronVgamma = 0;
- Float_t bPos[2];
- Float_t bCovPos[3];
- positronVgamma->GetImpactParameters(bPos,bCovPos);
- if (bCovPos[0]<=0 || bCovPos[2]<=0) {
- AliDebug(1, "Estimated b resolution lower or equal zero!");
- bCovPos[0]=0; bCovPos[2]=0;
- }
+ Double_t clsToFPos = -1.0;
+ Double_t clsToFNeg = -1.0;
- Float_t bNeg[2];
- Float_t bCovNeg[3];
- positronVgamma->GetImpactParameters(bNeg,bCovNeg);
- if (bCovNeg[0]<=0 || bCovNeg[2]<=0) {
- AliDebug(1, "Estimated b resolution lower or equal zero!");
- bCovNeg[0]=0; bCovNeg[2]=0;
- }
+ Float_t dcaToVertexXYPos = -1.0;
+ Float_t dcaToVertexZPos = -1.0;
+ Float_t dcaToVertexXYNeg = -1.0;
+ Float_t dcaToVertexZNeg = -1.0;
+
+
+ if ( fDoMesonQA ) {
+
+ positronVgamma = fESDEvent->GetTrack( Vgamma->GetTrackLabelPositive() );
+ electronVgamma = fESDEvent->GetTrack( Vgamma->GetTrackLabelNegative() );
+ clsToFPos = ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetNFindableClustersTPC(positronVgamma);
+ clsToFNeg = ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetNFindableClustersTPC(electronVgamma);
- Float_t dcaToVertexXYPos = bPos[0];
- Float_t dcaToVertexZPos = bPos[1];
- Float_t dcaToVertexXYNeg = bNeg[0];
- Float_t dcaToVertexZNeg = bNeg[1];
+ Float_t bPos[2];
+ Float_t bCovPos[3];
+ positronVgamma->GetImpactParameters(bPos,bCovPos);
+ if (bCovPos[0]<=0 || bCovPos[2]<=0) {
+ AliDebug(1, "Estimated b resolution lower or equal zero!");
+ bCovPos[0]=0; bCovPos[2]=0;
+ }
+
+ Float_t bNeg[2];
+ Float_t bCovNeg[3];
+ positronVgamma->GetImpactParameters(bNeg,bCovNeg);
+ if (bCovNeg[0]<=0 || bCovNeg[2]<=0) {
+ AliDebug(1, "Estimated b resolution lower or equal zero!");
+ bCovNeg[0]=0; bCovNeg[2]=0;
+ }
+
+ dcaToVertexXYPos = bPos[0];
+ dcaToVertexZPos = bPos[1];
+ dcaToVertexXYNeg = bNeg[0];
+ dcaToVertexZNeg = bNeg[1];
+
+ }
if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoMassCut() == kTRUE ) {
if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->MassCut( pi0cand->Pt() , Vgamma->GetMass() ) == kTRUE ){
hESDMotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
- hESDMotherPhi[fiCut]->Fill(pi0cand->Phi());
+
Double_t sparesFill[4] = {pi0cand->M(),pi0cand->Pt(),(Double_t)zbin,(Double_t)mbin};
sESDMotherInvMassPtZM[fiCut]->Fill(sparesFill,1);
- if( lGoodVirtualGamma[virtualGammaIndex] == kFALSE ) {
- hESDDalitzElectronAfterPt[fiCut]->Fill( electronVgamma->Pt() );
- hESDDalitzPositronAfterPt[fiCut]->Fill( positronVgamma->Pt() );
+ if ( fDoMesonQA ) {
+
+ hESDMotherPhi[fiCut]->Fill(pi0cand->Phi());
- hESDDalitzElectronAfterPhi[fiCut]->Fill( electronVgamma->Phi() );
- hESDDalitzPositronAfterPhi[fiCut]->Fill( positronVgamma->Phi() );
+ if( lGoodVirtualGamma[virtualGammaIndex] == kFALSE ) {
+
+ hESDDalitzElectronAfterPt[fiCut]->Fill( electronVgamma->Pt() );
+ hESDDalitzPositronAfterPt[fiCut]->Fill( positronVgamma->Pt() );
+
+ hESDDalitzElectronAfterPhi[fiCut]->Fill( electronVgamma->Phi() );
+ hESDDalitzPositronAfterPhi[fiCut]->Fill( positronVgamma->Phi() );
- hESDDalitzElectronAfterNFindClsTPC[fiCut]->Fill(clsToFNeg,electronVgamma->Pt());
- hESDDalitzPositronAfterNFindClsTPC[fiCut]->Fill(clsToFPos,positronVgamma->Pt());
+ hESDDalitzElectronAfterNFindClsTPC[fiCut]->Fill(clsToFNeg,electronVgamma->Pt());
+ hESDDalitzPositronAfterNFindClsTPC[fiCut]->Fill(clsToFPos,positronVgamma->Pt());
- hESDDalitzPosEleAfterDCAxy[fiCut]->Fill( dcaToVertexXYNeg, electronVgamma->Pt() );
- hESDDalitzPosEleAfterDCAz[fiCut]->Fill( dcaToVertexZNeg, electronVgamma->Pt() );
- hESDDalitzPosEleAfterDCAxy[fiCut]->Fill( dcaToVertexXYPos, positronVgamma->Pt() );
- hESDDalitzPosEleAfterDCAz[fiCut]->Fill( dcaToVertexZPos, positronVgamma->Pt() );
+ hESDDalitzPosEleAfterDCAxy[fiCut]->Fill( dcaToVertexXYNeg, electronVgamma->Pt() );
+ hESDDalitzPosEleAfterDCAz[fiCut]->Fill( dcaToVertexZNeg, electronVgamma->Pt() );
+ hESDDalitzPosEleAfterDCAxy[fiCut]->Fill( dcaToVertexXYPos, positronVgamma->Pt() );
+ hESDDalitzPosEleAfterDCAz[fiCut]->Fill( dcaToVertexZPos, positronVgamma->Pt() );
- hESDDalitzPosEleAfterTPCdEdx[fiCut]->Fill( positronVgamma->P(),((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetPIDResponse()->NumberOfSigmasTPC(positronVgamma, AliPID::kElectron) );
- hESDDalitzPosEleAfterTPCdEdx[fiCut]->Fill( electronVgamma->P(),((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetPIDResponse()->NumberOfSigmasTPC(electronVgamma, AliPID::kElectron) );
+ hESDDalitzPosEleAfterTPCdEdx[fiCut]->Fill( positronVgamma->P(),((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetPIDResponse()->NumberOfSigmasTPC(positronVgamma, AliPID::kElectron) );
+ hESDDalitzPosEleAfterTPCdEdx[fiCut]->Fill( electronVgamma->P(),((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetPIDResponse()->NumberOfSigmasTPC(electronVgamma, AliPID::kElectron) );
- hESDDalitzPosEleAfterTPCdEdxSignal[fiCut]->Fill( positronVgamma->P(), TMath::Abs(positronVgamma->GetTPCsignal()));
- hESDDalitzPosEleAfterTPCdEdxSignal[fiCut]->Fill( electronVgamma->P(), TMath::Abs(electronVgamma->GetTPCsignal()));
-
+ hESDDalitzPosEleAfterTPCdEdxSignal[fiCut]->Fill( positronVgamma->P(), TMath::Abs(positronVgamma->GetTPCsignal()));
+ hESDDalitzPosEleAfterTPCdEdxSignal[fiCut]->Fill( electronVgamma->P(), TMath::Abs(electronVgamma->GetTPCsignal()));
- lGoodVirtualGamma[virtualGammaIndex] = kTRUE;
+ lGoodVirtualGamma[virtualGammaIndex] = kTRUE;
+ }
}
Double_t sparesFill[4] = {pi0cand->M(),pi0cand->Pt(),(Double_t)zbin,(Double_t)mbin};
sESDMotherInvMassPtZM[fiCut]->Fill(sparesFill,1);
- if( lGoodVirtualGamma[virtualGammaIndex] == kFALSE ) {
+
+ if ( fDoMesonQA ) {
+
+ hESDMotherPhi[fiCut]->Fill(pi0cand->Phi());
+
+ if( lGoodVirtualGamma[virtualGammaIndex] == kFALSE ) {
hESDDalitzElectronAfterPt[fiCut]->Fill( electronVgamma->Pt() );
hESDDalitzPositronAfterPt[fiCut]->Fill( positronVgamma->Pt() );
lGoodVirtualGamma[virtualGammaIndex] = kTRUE;
- }
+ }
+ }
}
-
+ if( fDoChicAnalysis) {
hESDPi0MotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
hESDPi0MotherDiffInvMassPt[fiCut]->Fill( diffMass , pi0cand->Pt() );
- if(Vgamma->GetMass() > 2.5 && Vgamma->GetMass()<3.4 ){
+ if( Vgamma->GetMass() > 2.5 && Vgamma->GetMass() < 3.4){
hESDPi0MotherDiffLimInvMassPt[fiCut]->Fill( diffMass , pi0cand->Pt() );
- }
+ }
+ }
if(fMCEvent){
ProcessTrueMesonCandidates(pi0cand,gamma,Vgamma);
}
AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(¤tEventGoodV0,&previousGoodV0);
- if( ( ((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE) ) ){
+
+
+ if( ( ((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE, ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetEtaShift()))){
if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoMassCut() == kTRUE ) {
if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->MassCut( backgroundCandidate->Pt() , currentEventGoodV0.GetMass() ) == kTRUE ){
}
AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(¤tEventGoodV0,&previousGoodV0);
- if((((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE))){
+
+ if((((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE,((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetEtaShift()))){
if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoMassCut() == kTRUE ) {
AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(¤tEventGoodV0,&previousGoodV0);
+
- if((((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE))){
+ if((((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE, ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetEtaShift()))){
if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoMassCut() == kTRUE ) {
method = ( (AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetBKGMethod();
+
+
+
if( method == 1 ) {
if(fGoodGammas->GetEntries() > 0 ){
AliStack *MCStack = fMCEvent->Stack();
if( TrueGammaCandidate->GetV0Index()<fESDEvent->GetNumberOfV0s() ){
+
+
+ //cout<<"Entro True Meson"<<endl;
Bool_t isTruePi0 = kFALSE;
Bool_t isTrueEta = kFALSE;
Bool_t massCutAccept = kFALSE;
- Bool_t isTrueChiC = kFALSE;
+ //Bool_t isTrueChiC = kFALSE;
Int_t gammaMCLabel = TrueGammaCandidate->GetMCParticleLabel(MCStack);
Int_t gammaMotherLabel = -1;
}
- if(gammaMotherLabel>=0 && ( gammaMotherLabel == virtualGammaGrandMotherLabel) ){
- if(((TParticle*)MCStack->Particle(virtualGammaGrandMotherLabel))->GetPdgCode() == 445 ||
- ((TParticle*)MCStack->Particle(virtualGammaGrandMotherLabel))->GetPdgCode() == 10443 ||
- ((TParticle*)MCStack->Particle(virtualGammaGrandMotherLabel))->GetPdgCode() == 20443 ){
- isTrueChiC=kTRUE;
- hESDTrueMotherChiCInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
- hESDTrueMotherChiCDiffInvMassPt[fiCut]->Fill(Pi0Candidate->M()-TrueVirtualGammaCandidate->GetMass(),Pi0Candidate->Pt());
- }
- }
+ if( fDoChicAnalysis) {
+ if(gammaMotherLabel>=0 && ( gammaMotherLabel == virtualGammaGrandMotherLabel) ){
+ if(((TParticle*)MCStack->Particle(virtualGammaGrandMotherLabel))->GetPdgCode() == 445 ||
+ ((TParticle*)MCStack->Particle(virtualGammaGrandMotherLabel))->GetPdgCode() == 10443 ||
+ ((TParticle*)MCStack->Particle(virtualGammaGrandMotherLabel))->GetPdgCode() == 20443 ){
+ //isTrueChiC=kTRUE;
+ hESDTrueMotherChiCInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
+ hESDTrueMotherChiCDiffInvMassPt[fiCut]->Fill(Pi0Candidate->M()-TrueVirtualGammaCandidate->GetMass(),Pi0Candidate->Pt());
+ }
+ }
+ }
if( ( isTruePi0 || isTrueEta) && massCutAccept ){ // True Pion or Eta
- if ( virtualGamma == 1 ) { //True Dalitz
-
- hESDTrueMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
- hESDTrueMotherDalitzInvMassPt[fiCut]->Fill( TrueVirtualGammaCandidate->GetMass(),Pi0Candidate->Pt());
-
+ if ( virtualGamma == 1 ) { //True Dalitz
+
+ Float_t weighted= 1;
+
+ if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoWeights() ) {
+ if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(gammaMotherLabel, fMCStack,fInputEvent)){
+ if (((TParticle*)MCStack->Particle(gammaMotherLabel))->Pt()>0.005){
+ weighted= ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gammaMotherLabel,fMCStack,fInputEvent);
+ }
+ }
+ }
+
+ hESDTrueMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
+ hESDTrueMotherDalitzInvMassPt[fiCut]->Fill( TrueVirtualGammaCandidate->GetMass(),Pi0Candidate->Pt(),weighted);
+
if(gammaMotherLabel < MCStack->GetNprimary()){ // Only primary pi0 for efficiency calculation
- Float_t weighted= 1;
- if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(gammaMotherLabel, fMCStack,fInputEvent)){
- if (((TParticle*)MCStack->Particle(gammaMotherLabel))->Pt()>0.005){
- weighted= ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gammaMotherLabel,fMCStack,fInputEvent);
- }
- }
+
+ hESDTruePrimaryMotherInvMassPt[fiCut]->Fill( Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
+ hESDTruePrimaryMotherW0WeightingInvMassPt[fiCut]->Fill( Pi0Candidate->M(), Pi0Candidate->Pt() );
+
hESDTruePrimaryMotherInvMassMCPt[fiCut]->Fill(Pi0Candidate->M(),((TParticle*)MCStack->Particle(virtualGammaMotherLabel))->Pt(),weighted);
if(isTruePi0){ // Only primaries for unfolding
hESDTruePrimaryPi0DalitzESDPtMCPt[fiCut]->Fill(Pi0Candidate->Pt(),((TParticle*)MCStack->Particle(virtualGammaMotherLabel))->Pt(),weighted);
}
}
else { // Secondary Meson
- hESDTrueSecondaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
- //if (((TParticle*)MCStack->Particle(virtualGammaMotherLabel))->GetMother(0) >-1){
- // if(MCStack->Particle(((TParticle*)MCStack->Particle(virtualGammaMotherLabel))->GetMother(0))->GetPdgCode()==kK0Short){
- // hESDTrueSecondaryMotherFromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
- // }
+ Float_t weightedSec= 1;
+
+ if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoWeights() ) {
+ Int_t secMotherLabel = ((TParticle*)MCStack->Particle(gammaMotherLabel))->GetMother(0);
+ if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(gammaMotherLabel, fMCStack, fInputEvent) && MCStack->Particle(gammaMotherLabel)->GetPdgCode()==310){
+ weightedSec= ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),secMotherLabel, fMCStack, fInputEvent)/2.; //invariant mass is additive thus the weight for the daughters has to be devide by two for the K0s at a certain pt
+ }
+ }
+
+ hESDTrueSecondaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
}
}
+
+
else if ( virtualGamma == 0 ){
- hESDTrueMotherPi0GGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt()); // Pi0 from GG
+
+ Float_t weighted= 1;
+
+ if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoWeights() ) {
+ if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(gammaMotherLabel, fMCStack,fInputEvent)){
+ if (((TParticle*)MCStack->Particle(gammaMotherLabel))->Pt()>0.005){
+ weighted= ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gammaMotherLabel,fMCStack,fInputEvent);
+ }
+ }
+ }
+
+ hESDTrueMotherPi0GGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted); // Pi0 from GG
+
+ if( gammaMotherLabel < MCStack->GetNprimary() ){
+ hESDTruePrimaryMotherPi0GGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
+ }
+ else {
+
+ Float_t weightedSec= 1;
+
+ if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoWeights() ) {
+ Int_t secMotherLabel = ((TParticle*)MCStack->Particle(gammaMotherLabel))->GetMother(0);
+ if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(gammaMotherLabel, fMCStack, fInputEvent) && MCStack->Particle(gammaMotherLabel)->GetPdgCode()==310){
+ weightedSec= ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),secMotherLabel, fMCStack, fInputEvent)/2.; //invariant mass is additive thus the weight for the daughters has to be devide by two for the K0s at a certain pt
+ }
+ }
+ hESDTrueSecondaryMotherPi0GGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
+ }
}
}
if( particle->GetPdgCode() == 11)hMCAllElectronsPt[fiCut]->Fill(particle->Pt()); // All electrons
}
- if(((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelectedMC(particle,fMCStack,((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetEtaShift()) ){
+ if(((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelectedMC( particle,fMCStack,((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetEtaShift() ) ){
Float_t weighted= 1;
-
+
+ if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoWeights() ) {
if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
if (particle->Pt()>0.005){
weighted= ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack,fInputEvent);
}
}
-
+ }
+
if(particle->GetPdgCode() == 111)hMCPi0GGPt[fiCut]->Fill( particle->Pt() , weighted); // All MC Pi0 GG decay
if(particle->GetPdgCode() == 221)hMCEtaGGPt[fiCut]->Fill( particle->Pt() , weighted); // All MC Eta GG decay
}
{
- Float_t weighted= 1;
-
+ Float_t weighted= 1;
+ if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoWeights() ) {
if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack,fInputEvent)){
if (particle->Pt()>0.005){
weighted= ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack,fInputEvent);
}
}
-
+ }
if(particle->GetPdgCode() == 111)hMCPi0Pt[fiCut]->Fill(particle->Pt(), weighted); // All MC Pi0
if(particle->GetPdgCode() == 221)hMCEtaPt[fiCut]->Fill(particle->Pt(), weighted); // All MC Eta
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff