From: kaamodt Date: Sun, 29 Mar 2009 16:36:48 +0000 (+0000) Subject: Changed to new naming scheme for histograms, added functionality to the analysis... X-Git-Url: http://git.uio.no/git/?a=commitdiff_plain;h=32a6d40787a451142541421f014989ecb80abc7c;p=u%2Fmrichter%2FAliRoot.git Changed to new naming scheme for histograms, added functionality to the analysis task to do combinations without applying any cuts to the v0. Added more cuts. Changed to use better values for cuts. --- diff --git a/PWG4/GammaConv/AliAnalysisTaskGammaConversion.cxx b/PWG4/GammaConv/AliAnalysisTaskGammaConversion.cxx index 5df0c831888..8e983c93e5b 100644 --- a/PWG4/GammaConv/AliAnalysisTaskGammaConversion.cxx +++ b/PWG4/GammaConv/AliAnalysisTaskGammaConversion.cxx @@ -46,7 +46,7 @@ ClassImp(AliAnalysisTaskGammaConversion) AliAnalysisTaskGammaConversion::AliAnalysisTaskGammaConversion(): - AliAnalysisTaskSE(), +AliAnalysisTaskSE(), fV0Reader(NULL), fStack(NULL), fOutputContainer(NULL), @@ -57,6 +57,9 @@ AliAnalysisTaskGammaConversion::AliAnalysisTaskGammaConversion(): fMCEtas(), fMCGammaChic(), fKFReconstructedGammas(), + fIsTrueReconstructedGammas(), + electronv1(), + electronv2(), fElectronMass(-1), fGammaMass(-1), fPi0Mass(-1), @@ -64,6 +67,7 @@ AliAnalysisTaskGammaConversion::AliAnalysisTaskGammaConversion(): fGammaWidth(-1), fPi0Width(-1), fEtaWidth(-1), + fMinOpeningAngleGhostCut(0.), fCalculateBackground(kFALSE), fWriteNtuple(kFALSE), fGammaNtuple(NULL), @@ -74,7 +78,7 @@ AliAnalysisTaskGammaConversion::AliAnalysisTaskGammaConversion(): // Common I/O in slot 0 DefineInput (0, TChain::Class()); DefineOutput(0, TTree::Class()); - + // Your private output DefineOutput(1, TList::Class()); } @@ -91,6 +95,9 @@ AliAnalysisTaskGammaConversion::AliAnalysisTaskGammaConversion(const char* name) fMCEtas(), fMCGammaChic(), fKFReconstructedGammas(), + fIsTrueReconstructedGammas(), + electronv1(), + electronv2(), fElectronMass(-1), fGammaMass(-1), fPi0Mass(-1), @@ -98,6 +105,7 @@ AliAnalysisTaskGammaConversion::AliAnalysisTaskGammaConversion(const char* name) fGammaWidth(-1), fPi0Width(-1), fEtaWidth(-1), + fMinOpeningAngleGhostCut(0.), fCalculateBackground(kFALSE), fWriteNtuple(kFALSE), fGammaNtuple(NULL), @@ -107,7 +115,7 @@ AliAnalysisTaskGammaConversion::AliAnalysisTaskGammaConversion(const char* name) // Common I/O in slot 0 DefineInput (0, TChain::Class()); DefineOutput(0, TTree::Class()); - + // Your private output DefineOutput(1, TList::Class()); } @@ -115,7 +123,7 @@ AliAnalysisTaskGammaConversion::AliAnalysisTaskGammaConversion(const char* name) AliAnalysisTaskGammaConversion::~AliAnalysisTaskGammaConversion() { // Remove all pointers - + if(fOutputContainer){ fOutputContainer->Clear() ; delete fOutputContainer ; @@ -139,257 +147,416 @@ void AliAnalysisTaskGammaConversion::Init() void AliAnalysisTaskGammaConversion::Exec(Option_t */*option*/) { // Execute analysis for current event - + ConnectInputData(""); - + //clear vectors fMCAllGammas.clear(); fMCPi0s.clear(); fMCEtas.clear(); fMCGammaChic.clear(); - + fKFReconstructedGammas.clear(); - + fIsTrueReconstructedGammas.clear(); + electronv1.clear(); + electronv2.clear(); + //Clear the data in the v0Reader fV0Reader->UpdateEventByEventData(); + // Process the MC information if(fDoMCTruth){ ProcessMCData(); } - + + //Process the v0 information with no cuts + ProcessV0sNoCut(); + // Process the v0 information ProcessV0s(); - + //calculate background if flag is set if(fCalculateBackground){ CalculateBackground(); } - + // Process reconstructed gammas ProcessGammasForNeutralMesonAnalysis(); - - PostData(1, fOutputContainer); + PostData(1, fOutputContainer); + } void AliAnalysisTaskGammaConversion::ConnectInputData(Option_t */*option*/){ // see header file for documentation - + if(fV0Reader == NULL){ // Write warning here cuts and so on are default if this ever happens } fV0Reader->Initialize(); } + + void AliAnalysisTaskGammaConversion::ProcessMCData(){ // see header file for documentation - + fStack = fV0Reader->GetMCStack(); + if(fV0Reader->CheckForPrimaryVertex() == kFALSE){ + return; // aborts if the primary vertex does not have contributors. + } + for (Int_t iTracks = 0; iTracks < fStack->GetNtrack(); iTracks++) { TParticle* particle = (TParticle *)fStack->Particle(iTracks); - + if (!particle) { //print warning here continue; } - - if(particle->Pt()GetPtCut()){ - continue; - } - - if(TMath::Abs(particle->Eta())> fV0Reader->GetEtaCut()){ - continue; - } - - if(particle->R()>fV0Reader->GetMaxRCut()){ // cuts on distance from collision point - continue; - } + if(TMath::Abs(particle->Eta())> fV0Reader->GetEtaCut() ) continue; + + if(particle->R()>fV0Reader->GetMaxRCut()) continue; // cuts on distance from collision point + Double_t tmpPhi=particle->Phi(); + if(particle->Phi()> TMath::Pi()){ tmpPhi = particle->Phi()-(2*TMath::Pi()); } - - + + Double_t rapidity; + if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){ + rapidity=0; + } + else{ + rapidity = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz()))); + } + //process the gammas - if (particle->GetPdgCode()== 22){ - fMCAllGammas.push_back(particle); - if(particle->GetMother(0)>-1){ //Means we have a mother - if( fStack->Particle(particle->GetMother(0))->GetPdgCode() != 22 ){//Checks for a non gamma mother. - fHistograms->FillHistogram("MC_Gamma_Energy", particle->Energy()); - fHistograms->FillHistogram("MC_Gamma_Pt", particle->Pt()); - fHistograms->FillHistogram("MC_Gamma_Eta", particle->Eta()); - - fHistograms->FillHistogram("MC_Gamma_Phi", tmpPhi); - - //adding the conversion points from all gammas with e+e- daughters - if(particle->GetNDaughters() >= 2){ - TParticle* daughter0 = NULL; - TParticle* daughter1 = NULL; - - for(Int_t daughterIndex=particle->GetFirstDaughter();daughterIndex<=particle->GetLastDaughter();daughterIndex++){ - TParticle *tmpDaughter = fStack->Particle(daughterIndex); - if(tmpDaughter->GetUniqueID() == 5){ - if(tmpDaughter->GetPdgCode() == 11){ - daughter0 = tmpDaughter; - } - else if(tmpDaughter->GetPdgCode() == -11){ - daughter1 = tmpDaughter; - } - } - } + if (particle->GetPdgCode() == 22){ + + if(particle->GetMother(0) >-1 && fStack->Particle(particle->GetMother(0))->GetPdgCode() == 22){ + continue; // no photon as mothers! + } - if(daughter0 == NULL || daughter1 == NULL){ // means we do not have two daughters from pair production - continue; - } + if(particle->GetMother(0) >= fStack->GetNprimary()){ + continue; // the gamma has a mother, and it is not a primary particle + } - if(daughter0->R()>fV0Reader->GetMaxRCut() || daughter1->R()>fV0Reader->GetMaxRCut()){ - continue; + fMCAllGammas.push_back(particle); + + fHistograms->FillHistogram("MC_allGamma_Energy", particle->Energy()); + fHistograms->FillHistogram("MC_allGamma_Pt", particle->Pt()); + fHistograms->FillHistogram("MC_allGamma_Eta", particle->Eta()); + fHistograms->FillHistogram("MC_allGamma_Phi", tmpPhi); + fHistograms->FillHistogram("MC_allGamma_Rapid", rapidity); + + + if(particle->GetMother(0) < 0){ // direct gamma + fHistograms->FillHistogram("MC_allDirectGamma_Energy",particle->Energy()); + fHistograms->FillHistogram("MC_allDirectGamma_Pt", particle->Pt()); + fHistograms->FillHistogram("MC_allDirectGamma_Eta", particle->Eta()); + fHistograms->FillHistogram("MC_allDirectGamma_Phi", tmpPhi); + fHistograms->FillHistogram("MC_allDirectGamma_Rapid", rapidity); + } + + + // looking for conversion (electron + positron from pairbuilding (= 5) ) + TParticle* ePos = NULL; + TParticle* eNeg = NULL; + + if(particle->GetNDaughters() >= 2){ + for(Int_t daughterIndex=particle->GetFirstDaughter();daughterIndex<=particle->GetLastDaughter();daughterIndex++){ + TParticle *tmpDaughter = fStack->Particle(daughterIndex); + if(tmpDaughter->GetUniqueID() == 5){ + if(tmpDaughter->GetPdgCode() == 11){ + eNeg = tmpDaughter; + } + else if(tmpDaughter->GetPdgCode() == -11){ + ePos = tmpDaughter; } - - if((daughter0->GetPdgCode() == -11 && daughter1->GetPdgCode()) == 11 || - (daughter0->GetPdgCode() == 11 && daughter1->GetPdgCode() == -11)){ - - // begin Mapping - Int_t rBin = fHistograms->GetRBin(daughter0->R()); - Int_t phiBin = fHistograms->GetPhiBin(daughter0->Phi()); - - TString nameMCMappingPhiR=""; - nameMCMappingPhiR.Form("MC_EP_Mapping-Phi%02d-R%02d",phiBin,rBin); - fHistograms->FillHistogram(nameMCMappingPhiR, daughter0->Vz(), particle->Eta()); - - TString nameMCMappingPhi=""; - nameMCMappingPhi.Form("MC_EP_Mapping-Phi%02d",phiBin); - fHistograms->FillHistogram(nameMCMappingPhi, particle->Eta()); - - TString nameMCMappingR=""; - nameMCMappingR.Form("MC_EP_Mapping-R%02d",rBin); - fHistograms->FillHistogram(nameMCMappingR, particle->Eta()); - - TString nameMCMappingPhiInR=""; - nameMCMappingPhiInR.Form("MC_EP_Mapping_Phi_R-%02d",rBin); - fHistograms->FillHistogram(nameMCMappingPhiInR, tmpPhi); - //end mapping - - fHistograms->FillHistogram("MC_EP_R",daughter0->R()); - fHistograms->FillHistogram("MC_EP_ZR",daughter0->Vz(),daughter0->R()); - fHistograms->FillHistogram("MC_EP_XY",daughter0->Vx(),daughter0->Vy()); - fHistograms->FillHistogram("MC_EP_OpeningAngle",GetMCOpeningAngle(daughter0, daughter1)); - }// end if((daughter0->GetPdgCode() == -11 && daughter1->GetPdgCode()) == 11 ||....... approx 20 lines above - }// end if(particle->GetNDaughters() >= 2){ - } // end if( fStack->Particle(particle->GetMother(0))->GetPdgCode() != 22 ) + } + } + } + + + if(ePos == NULL || eNeg == NULL){ // means we do not have two daughters from pair production + continue; + } + + + Double_t ePosPhi = ePos->Phi(); + if(ePos->Phi()> TMath::Pi()) ePosPhi = ePos->Phi()-(2*TMath::Pi()); + + Double_t eNegPhi = eNeg->Phi(); + if(eNeg->Phi()> TMath::Pi()) eNegPhi = eNeg->Phi()-(2*TMath::Pi()); + + + if(ePos->Pt()GetPtCut() || eNeg->Pt()GetPtCut()){ + continue; // no reconstruction below the Pt cut + } + + if(TMath::Abs(ePos->Eta())> fV0Reader->GetEtaCut() || TMath::Abs(eNeg->Eta())> fV0Reader->GetEtaCut()){ + continue; + } + + if(ePos->R()>fV0Reader->GetMaxRCut()){ + continue; // cuts on distance from collision point + } + + + if((TMath::Abs(ePos->Vz()) * fV0Reader->GetLineCutZRSlope()) - fV0Reader->GetLineCutZValue() > ePos->R()){ + continue; // line cut to exclude regions where we do not reconstruct + } + + fHistograms->FillHistogram("MC_ConvGamma_Energy", particle->Energy()); + fHistograms->FillHistogram("MC_ConvGamma_Pt", particle->Pt()); + fHistograms->FillHistogram("MC_ConvGamma_Eta", particle->Eta()); + fHistograms->FillHistogram("MC_ConvGamma_Phi", tmpPhi); + fHistograms->FillHistogram("MC_ConvGamma_Rapid", rapidity); + fHistograms->FillHistogram("MC_ConvGamma_Pt_Eta", particle->Pt(),particle->Eta()); + + fHistograms->FillHistogram("MC_E_Energy", eNeg->Energy()); + fHistograms->FillHistogram("MC_E_Pt", eNeg->Pt()); + fHistograms->FillHistogram("MC_E_Eta", eNeg->Eta()); + fHistograms->FillHistogram("MC_E_Phi", eNegPhi); + + fHistograms->FillHistogram("MC_P_Energy", ePos->Energy()); + fHistograms->FillHistogram("MC_P_Pt", ePos->Pt()); + fHistograms->FillHistogram("MC_P_Eta", ePos->Eta()); + fHistograms->FillHistogram("MC_P_Phi", ePosPhi); + + + + //cout << "filled histos for converted gamma, ePos, eNeg" << endl; + + // begin Mapping + Int_t rBin = fHistograms->GetRBin(ePos->R()); + Int_t phiBin = fHistograms->GetPhiBin(particle->Phi()); + + TString nameMCMappingPhiR=""; + nameMCMappingPhiR.Form("MC_Conversion_Mapping-Phi%02d-R%02d",phiBin,rBin); + fHistograms->FillHistogram(nameMCMappingPhiR, ePos->Vz(), particle->Eta()); + + TString nameMCMappingPhi=""; + nameMCMappingPhi.Form("MC_Conversion_Mapping-Phi%02d",phiBin); + fHistograms->FillHistogram(nameMCMappingPhi, particle->Eta()); + + TString nameMCMappingR=""; + nameMCMappingR.Form("MC_Conversion_Mapping-R%02d",rBin); + fHistograms->FillHistogram(nameMCMappingR, particle->Eta()); + + TString nameMCMappingPhiInR=""; + nameMCMappingPhiInR.Form("MC_Conversion_Mapping_Phi_R-%02d",rBin); + fHistograms->FillHistogram(nameMCMappingPhiInR, tmpPhi); + //end mapping + + fHistograms->FillHistogram("MC_Conversion_R",ePos->R()); + fHistograms->FillHistogram("MC_Conversion_ZR",ePos->Vz(),ePos->R()); + fHistograms->FillHistogram("MC_Conversion_XY",ePos->Vx(),ePos->Vy()); + fHistograms->FillHistogram("MC_Conversion_OpeningAngle",GetMCOpeningAngle(ePos, eNeg)); + + //cout << "mapping is done" << endl; + + + if(particle->GetMother(0) < 0){ // no mother = direct gamma, still inside converted + fHistograms->FillHistogram("MC_ConvDirectGamma_Energy",particle->Energy()); + fHistograms->FillHistogram("MC_ConvDirectGamma_Pt", particle->Pt()); + fHistograms->FillHistogram("MC_ConvDirectGamma_Eta", particle->Eta()); + fHistograms->FillHistogram("MC_ConvDirectGamma_Phi", tmpPhi); + fHistograms->FillHistogram("MC_ConvDirectGamma_Rapid", rapidity); + + } // end direct gamma + else{ // mother exits if( fStack->Particle(particle->GetMother(0))->GetPdgCode()==10441 ||//chic0 fStack->Particle(particle->GetMother(0))->GetPdgCode()==20443 ||//psi2S fStack->Particle(particle->GetMother(0))->GetPdgCode()==445 //chic2 ){ fMCGammaChic.push_back(particle); } - }// end if(particle->GetMother(0)>-1) - else{//means we have a primary particle - fHistograms->FillHistogram("MC_DirectGamma_Energy",particle->Energy()); - fHistograms->FillHistogram("MC_DirectGamma_Pt", particle->Pt()); - fHistograms->FillHistogram("MC_DirectGamma_Eta", particle->Eta()); - fHistograms->FillHistogram("MCDirectGammaPhi", tmpPhi); - - //adding the conversion points from all gammas with e+e- daughters - if(particle->GetNDaughters() == 2){ - TParticle* daughter0 = (TParticle*)fStack->Particle(particle->GetFirstDaughter()); - TParticle* daughter1 = (TParticle*)fStack->Particle(particle->GetLastDaughter()); - if((daughter0->GetPdgCode() == -11 && daughter1->GetPdgCode() == 11) || - (daughter0->GetPdgCode() == 11 && daughter1->GetPdgCode() == -11)){ - - fHistograms->FillHistogram("MC_EP_R",daughter0->R()); - fHistograms->FillHistogram("MC_EP_ZR",daughter0->Vz(),daughter0->R()); - fHistograms->FillHistogram("MC_EP_XY",daughter0->Vx(),daughter0->Vy()); - fHistograms->FillHistogram("MC_EP_OpeningAngle",GetMCOpeningAngle(daughter0, daughter1)); - + } // end if mother exits + } // end if particle is a photon + + if(particle->GetNDaughters() == 2){ + + TParticle* daughter0 = (TParticle*)fStack->Particle(particle->GetFirstDaughter()); + TParticle* daughter1 = (TParticle*)fStack->Particle(particle->GetLastDaughter()); + + if(daughter0->GetPdgCode() != 22 || daughter1->GetPdgCode() != 22) continue; //check for gamma gamma daughters + + + + // check for conversions now -> have to pass eta and line cut! + Bool_t daughter0Electron = kFALSE; + Bool_t daughter0Positron = kFALSE; + Bool_t daughter1Electron = kFALSE; + Bool_t daughter1Positron = kFALSE; + + + + if(daughter0->GetNDaughters() >= 2){ + for(Int_t TrackIndex=daughter0->GetFirstDaughter();TrackIndex<=daughter0->GetLastDaughter();TrackIndex++){ + TParticle *tmpDaughter = fStack->Particle(TrackIndex); + if(tmpDaughter->GetUniqueID() == 5){ + if(tmpDaughter->GetPdgCode() == 11){ + if( TMath::Abs(tmpDaughter->Eta()) <= fV0Reader->GetEtaCut() ){ + if( ( TMath::Abs(tmpDaughter->Vz()) * fV0Reader->GetLineCutZRSlope()) - fV0Reader->GetLineCutZValue() < tmpDaughter->R() ){ + daughter0Electron = kTRUE; + } + + } + } + else if(tmpDaughter->GetPdgCode() == -11){ + if( TMath::Abs(tmpDaughter->Eta()) <= fV0Reader->GetEtaCut() ){ + if( ( TMath::Abs(tmpDaughter->Vz()) * fV0Reader->GetLineCutZRSlope()) - fV0Reader->GetLineCutZValue() < tmpDaughter->R() ){ + daughter0Positron = kTRUE; + } + + } + + } } } - }// end else - }// end if (particle->GetPdgCode()== 22){ - else if (TMath::Abs(particle->GetPdgCode())== 11){ // Means we have an electron or a positron - if(particle->GetMother(0)>-1){ // means we have a mother - if( fStack->Particle(particle->GetMother(0))->GetPdgCode()==22 ){ // Means we have a gamma mother - if(particle->GetPdgCode() == 11){//electron - fHistograms->FillHistogram("MC_E_Energy", particle->Energy()); - fHistograms->FillHistogram("MC_E_Pt", particle->Pt()); - fHistograms->FillHistogram("MC_E_Eta", particle->Eta()); - fHistograms->FillHistogram("MC_E_Phi", tmpPhi); - } - if(particle->GetPdgCode() == -11){//positron - fHistograms->FillHistogram("MC_P_Energy", particle->Energy()); - fHistograms->FillHistogram("MC_P_Pt", particle->Pt()); - fHistograms->FillHistogram("MC_P_Eta", particle->Eta()); - fHistograms->FillHistogram("MC_P_Phi", tmpPhi); + } + + + + if(daughter1->GetNDaughters() >= 2){ + for(Int_t TrackIndex=daughter1->GetFirstDaughter();TrackIndex<=daughter1->GetLastDaughter();TrackIndex++){ + TParticle *tmpDaughter = fStack->Particle(TrackIndex); + if(tmpDaughter->GetUniqueID() == 5){ + if(tmpDaughter->GetPdgCode() == 11){ + if( TMath::Abs(tmpDaughter->Eta()) <= fV0Reader->GetEtaCut() ){ + if( ( TMath::Abs(tmpDaughter->Vz()) * fV0Reader->GetLineCutZRSlope()) - fV0Reader->GetLineCutZValue() < tmpDaughter->R() ){ + daughter1Electron = kTRUE; + } + + } + } + else if(tmpDaughter->GetPdgCode() == -11){ + if( TMath::Abs(tmpDaughter->Eta()) <= fV0Reader->GetEtaCut() ){ + if( ( TMath::Abs(tmpDaughter->Vz()) * fV0Reader->GetLineCutZRSlope()) - fV0Reader->GetLineCutZValue() < tmpDaughter->R() ){ + daughter1Positron = kTRUE; + } + + } + + } } } } - } // end else if (TMath::Abs(particle->GetPdgCode())== 11) - else if(particle->GetNDaughters() == 2){ - - TParticle* daughter0 = (TParticle*)fStack->Particle(particle->GetFirstDaughter()); - TParticle* daughter1 = (TParticle*)fStack->Particle(particle->GetLastDaughter()); - if(daughter0->GetPdgCode() == 22 && daughter1->GetPdgCode() == 22){//check for gamma gamma daughters - - if(particle->GetPdgCode()==111){//Pi0 - + + + + + if(particle->GetPdgCode()==111){ //Pi0 + if( iTracks >= fStack->GetNprimary()){ + fHistograms->FillHistogram("MC_Pi0_Secondaries_Eta", particle->Eta()); + fHistograms->FillHistogram("MC_Pi0_Secondaries_Rapid", rapidity); fHistograms->FillHistogram("MC_Pi0_Secondaries_Phi", tmpPhi); - - if( iTracks >= fStack->GetNprimary()){ - - fHistograms->FillHistogram("MC_Pi0_Secondaries_Eta", particle->Eta()); - - fHistograms->FillHistogram("MC_Pi0_Secondaries_Phi", tmpPhi); - fHistograms->FillHistogram("MC_Pi0_Secondaries_Pt", particle->Pt()); - fHistograms->FillHistogram("MC_Pi0_Secondaries_Energy", particle->Energy()); - fHistograms->FillHistogram("MC_Pi0_Secondaries_R", particle->R()); - fHistograms->FillHistogram("MC_Pi0_Secondaries_ZR", particle->Vz(),particle->R()); - fHistograms->FillHistogram("MC_Pi0_Secondaries_GammaDaughter_OpeningAngle", GetMCOpeningAngle(daughter0,daughter1)); - fHistograms->FillHistogram("MC_Pi0_Secondaries_XY", particle->Vx(),particle->Vy());//only fill from one daughter to avoid multiple filling + fHistograms->FillHistogram("MC_Pi0_Secondaries_Pt", particle->Pt()); + fHistograms->FillHistogram("MC_Pi0_Secondaries_Energy", particle->Energy()); + fHistograms->FillHistogram("MC_Pi0_Secondaries_R", particle->R()); + fHistograms->FillHistogram("MC_Pi0_Secondaries_ZR", particle->Vz(),particle->R()); + fHistograms->FillHistogram("MC_Pi0_Secondaries_GammaDaughter_OpeningAngle", GetMCOpeningAngle(daughter0,daughter1)); + fHistograms->FillHistogram("MC_Pi0_Secondaries_XY", particle->Vx(),particle->Vy());//only fill from one daughter to avoid multiple filling + + if(TMath::Abs(daughter0->Eta()) <= fV0Reader->GetEtaCut() && TMath::Abs(daughter1->Eta()) <= fV0Reader->GetEtaCut() ){ + fHistograms->FillHistogram("MC_Pi0_Secondaries_Pt_Eta_withinAcceptance", particle->Pt(),particle->Eta()); + fHistograms->FillHistogram("MC_Pi0_Secondaries_Pt_Rapid_withinAcceptance", particle->Pt(),rapidity); + if(daughter0Electron && daughter0Positron && daughter1Electron && daughter1Positron){ + fHistograms->FillHistogram("MC_Pi0_Secondaries_Pt_Eta_ConvGamma_withinAcceptance", particle->Pt(),particle->Eta()); + fHistograms->FillHistogram("MC_Pi0_Secondaries_Pt_Rapid_ConvGamma_withinAcceptance", particle->Pt(),rapidity); + } } - else{ - fHistograms->FillHistogram("MC_Pi0_Eta", particle->Eta()); - - fHistograms->FillHistogram("MC_Pi0_Phi", tmpPhi); - fHistograms->FillHistogram("MC_Pi0_Pt", particle->Pt()); - fHistograms->FillHistogram("MC_Pi0_Energy", particle->Energy()); - fHistograms->FillHistogram("MC_Pi0_R", particle->R()); - fHistograms->FillHistogram("MC_Pi0_ZR", particle->Vz(),particle->R()); - fHistograms->FillHistogram("MC_Pi0_GammaDaughter_OpeningAngle", GetMCOpeningAngle(daughter0,daughter1)); - fHistograms->FillHistogram("MC_Pi0_XY", particle->Vx(), particle->Vy());//only fill from one daughter to avoid multiple filling + } + else{ + fHistograms->FillHistogram("MC_Pi0_Eta", particle->Eta()); + fHistograms->FillHistogram("MC_Pi0_Rapid", rapidity); + fHistograms->FillHistogram("MC_Pi0_Phi", tmpPhi); + fHistograms->FillHistogram("MC_Pi0_Pt", particle->Pt()); + fHistograms->FillHistogram("MC_Pi0_Energy", particle->Energy()); + fHistograms->FillHistogram("MC_Pi0_R", particle->R()); + fHistograms->FillHistogram("MC_Pi0_ZR", particle->Vz(),particle->R()); + fHistograms->FillHistogram("MC_Pi0_GammaDaughter_OpeningAngle", GetMCOpeningAngle(daughter0,daughter1)); + fHistograms->FillHistogram("MC_Pi0_XY", particle->Vx(), particle->Vy());//only fill from one daughter to avoid multiple filling + + if(TMath::Abs(daughter0->Eta()) <= fV0Reader->GetEtaCut() && TMath::Abs(daughter1->Eta()) <= fV0Reader->GetEtaCut() ){ + fHistograms->FillHistogram("MC_Pi0_Pt_Eta_withinAcceptance", particle->Pt(),particle->Eta()); + fHistograms->FillHistogram("MC_Pi0_Pt_Rapid_withinAcceptance", particle->Pt(),rapidity); + if(daughter0Electron && daughter0Positron && daughter1Electron && daughter1Positron){ + fHistograms->FillHistogram("MC_Pi0_Pt_Eta_ConvGamma_withinAcceptance", particle->Pt(),particle->Eta()); + fHistograms->FillHistogram("MC_Pi0_Pt_Rapid_ConvGamma_withinAcceptance", particle->Pt(),rapidity); + } } } - else if(particle->GetPdgCode()==221){//Eta - fHistograms->FillHistogram("MC_Eta_Eta", particle->Eta()); - - fHistograms->FillHistogram("MC_Eta_Phi",tmpPhi); - fHistograms->FillHistogram("MC_Eta_Pt", particle->Pt()); - fHistograms->FillHistogram("MC_Eta_Energy", particle->Energy()); - fHistograms->FillHistogram("MC_Eta_R", particle->R()); - fHistograms->FillHistogram("MC_Eta_ZR", particle->Vz(),particle->R()); - fHistograms->FillHistogram("MC_Eta_GammaDaughter_OpeningAngle", GetMCOpeningAngle(daughter0,daughter1)); - fHistograms->FillHistogram("MC_Eta_XY", particle->Vx(), particle->Vy());//only fill from one daughter to avoid multiple filling + } + + if(particle->GetPdgCode()==221){ //Eta + fHistograms->FillHistogram("MC_Eta_Eta", particle->Eta()); + fHistograms->FillHistogram("MC_Eta_Rapid", rapidity); + fHistograms->FillHistogram("MC_Eta_Phi",tmpPhi); + fHistograms->FillHistogram("MC_Eta_Pt", particle->Pt()); + fHistograms->FillHistogram("MC_Eta_Energy", particle->Energy()); + fHistograms->FillHistogram("MC_Eta_R", particle->R()); + fHistograms->FillHistogram("MC_Eta_ZR", particle->Vz(),particle->R()); + fHistograms->FillHistogram("MC_Eta_GammaDaughter_OpeningAngle", GetMCOpeningAngle(daughter0,daughter1)); + fHistograms->FillHistogram("MC_Eta_XY", particle->Vx(), particle->Vy());//only fill from one daughter to avoid multiple filling + + if(TMath::Abs(daughter0->Eta()) <= fV0Reader->GetEtaCut() && TMath::Abs(daughter1->Eta()) <= fV0Reader->GetEtaCut() ){ + fHistograms->FillHistogram("MC_Eta_Pt_Eta_withinAcceptance", particle->Pt(),particle->Eta()); + fHistograms->FillHistogram("MC_Eta_Pt_Rapid_withinAcceptance", particle->Pt(),rapidity); + if(daughter0Electron && daughter0Positron && daughter1Electron && daughter1Positron){ + fHistograms->FillHistogram("MC_Eta_Pt_Eta_ConvGamma_withinAcceptance", particle->Pt(),particle->Eta()); + fHistograms->FillHistogram("MC_Eta_Pt_Rapid_ConvGamma_withinAcceptance", particle->Pt(),rapidity); + } + } - - //the match data should be filled no matter which mother the gamma-gamma comes from - fHistograms->FillHistogram("MC_Match_Gamma_R", particle->R()); - fHistograms->FillHistogram("MC_Match_Gamma_ZR", particle->Vz(),particle->R()); - fHistograms->FillHistogram("MC_Match_Gamma_XY", particle->Vx(),particle->Vy()); - fHistograms->FillHistogram("MC_Match_Gamma_Mass", particle->GetCalcMass()); - fHistograms->FillHistogram("MC_Match_Gamma_OpeningAngle", GetMCOpeningAngle(daughter0,daughter1)); - fHistograms->FillHistogram("MC_Match_Gamma_Energy", particle->Energy()); - fHistograms->FillHistogram("MC_Match_Gamma_Pt", particle->Pt()); - fHistograms->FillHistogram("MC_Match_Gamma_Eta", particle->Eta()); - fHistograms->FillHistogram("MC_Match_Gamma_Phi",tmpPhi); + + } + + // all motherparticles with 2 gammas as daughters + fHistograms->FillHistogram("MC_Mother_R", particle->R()); + fHistograms->FillHistogram("MC_Mother_ZR", particle->Vz(),particle->R()); + fHistograms->FillHistogram("MC_Mother_XY", particle->Vx(),particle->Vy()); + fHistograms->FillHistogram("MC_Mother_Mass", particle->GetCalcMass()); + fHistograms->FillHistogram("MC_Mother_GammaDaughter_OpeningAngle", GetMCOpeningAngle(daughter0,daughter1)); + fHistograms->FillHistogram("MC_Mother_Energy", particle->Energy()); + fHistograms->FillHistogram("MC_Mother_Pt", particle->Pt()); + fHistograms->FillHistogram("MC_Mother_Eta", particle->Eta()); + fHistograms->FillHistogram("MC_Mother_Rapid", rapidity); + fHistograms->FillHistogram("MC_Mother_Phi",tmpPhi); + fHistograms->FillHistogram("MC_Mother_InvMass_vs_Pt",particle->GetMass(),particle->Pt()); + if(TMath::Abs(daughter0->Eta()) <= fV0Reader->GetEtaCut() && TMath::Abs(daughter1->Eta()) <= fV0Reader->GetEtaCut() ){ + fHistograms->FillHistogram("MC_Mother_Pt_Eta_withinAcceptance", particle->Pt(),particle->Eta()); + fHistograms->FillHistogram("MC_Mother_Pt_Rapid_withinAcceptance", particle->Pt(),rapidity); + fHistograms->FillHistogram("MC_Mother_InvMass_vs_Pt_withinAcceptance",particle->GetMass(),particle->Pt()); + if(daughter0Electron && daughter0Positron && daughter1Electron && daughter1Positron){ + fHistograms->FillHistogram("MC_Mother_Pt_Eta_ConvGamma_withinAcceptance", particle->Pt(),particle->Eta()); + fHistograms->FillHistogram("MC_Mother_Pt_Rapid_ConvGamma_withinAcceptance", particle->Pt(),rapidity); + fHistograms->FillHistogram("MC_Mother_InvMass_vs_Pt_ConvGamma_withinAcceptance",particle->GetMass(),particle->Pt()); + + } + + } - }// end else if(particle->GetNDaughters() == 2) + + //cout << "mother histos are filled" << endl; + + } // end if(particle->GetNDaughters() == 2) + }// end for (Int_t iTracks = 0; iTracks < fStack->GetNtrack(); iTracks++) + + //cout << "right before the end of processMCdata" << endl; + } // end ProcessMCData -void AliAnalysisTaskGammaConversion::FillNtuple(){ + +void AliAnalysisTaskGammaConversion::FillNtuple(){ + if(fGammaNtuple == NULL){ return; } @@ -434,92 +601,194 @@ void AliAnalysisTaskGammaConversion::FillNtuple(){ fGammaNtuple->Fill(values); } fV0Reader->ResetV0IndexNumber(); - + +} + +void AliAnalysisTaskGammaConversion::ProcessV0sNoCut(){ + + Int_t numberOfV0s = fV0Reader->GetNumberOfV0s(); + for(Int_t i=0;iGetV0(i); + + if(fV0Reader->CheckForPrimaryVertex() == kFALSE){ + return; + } + + if(fDoMCTruth){ + + if(fV0Reader->HasSameMCMother() == kFALSE){ + continue; + } + + TParticle * negativeMC = (TParticle*)fV0Reader->GetNegativeMCParticle(); + TParticle * positiveMC = (TParticle*)fV0Reader->GetPositiveMCParticle(); + + if(TMath::Abs(negativeMC->GetPdgCode())!=11 || TMath::Abs(positiveMC->GetPdgCode())!=11){ + continue; + } + if(negativeMC->GetPdgCode()==positiveMC->GetPdgCode()){ + continue; + } + + if(fV0Reader->GetMotherMCParticle()->GetPdgCode() == 22){ + + fHistograms->FillHistogram("ESD_NoCutConvGamma_Pt", fV0Reader->GetMotherCandidatePt()); + fHistograms->FillHistogram("ESD_NoCutConvGamma_Energy", fV0Reader->GetMotherCandidateEnergy()); + fHistograms->FillHistogram("ESD_NoCutConvGamma_Eta", fV0Reader->GetMotherCandidateEta()); + fHistograms->FillHistogram("ESD_NoCutConvGamma_Phi", fV0Reader->GetMotherCandidatePhi()); + fHistograms->FillHistogram("ESD_NoCutConvGamma_Mass", fV0Reader->GetMotherCandidateMass()); + fHistograms->FillHistogram("ESD_NoCutConvGamma_Width", fV0Reader->GetMotherCandidateWidth()); + fHistograms->FillHistogram("ESD_NoCutConvGamma_Chi2", fV0Reader->GetMotherCandidateChi2()); + fHistograms->FillHistogram("ESD_NoCutConvGamma_NDF", fV0Reader->GetMotherCandidateNDF()); + fHistograms->FillHistogram("ESD_NoCutConvGamma_Rapid", fV0Reader->GetMotherCandidateRapidity()); + fHistograms->FillHistogram("ESD_NoCutConvGamma_Pt_Eta", fV0Reader->GetMotherCandidatePt(),fV0Reader->GetMotherCandidateEta()); + + fHistograms->FillHistogram("ESD_NoCutConversion_XY", fV0Reader->GetX(),fV0Reader->GetY()); + fHistograms->FillHistogram("ESD_NoCutConversion_R", fV0Reader->GetXYRadius()); + fHistograms->FillHistogram("ESD_NoCutConversion_ZR", fV0Reader->GetZ(),fV0Reader->GetXYRadius()); + fHistograms->FillHistogram("ESD_NoCutConversion_OpeningAngle", fV0Reader->GetOpeningAngle()); + + /* + ESD_NoCutConvGamma_Pt + ESD_NoCutConvGamma_Energy + ESD_NoCutConvGamma_Eta + ESD_NoCutConvGamma_Phi + ESD_NoCutConvGamma_Mass + ESD_NoCutConvGamma_Width + ESD_NoCutConvGamma_Chi2 + ESD_NoCutConvGamma_NDF + ESD_NoCutConvGamma_PtvsEta + ESD_NoCutConversion_XY + ESD_NoCutConversion_R + ESD_NoCutConversion_ZR + ESD_NoCutConversion_OpeningAngle + */ + } + } + } + fV0Reader->ResetV0IndexNumber(); } void AliAnalysisTaskGammaConversion::ProcessV0s(){ // see header file for documentation - + if(fWriteNtuple == kTRUE){ FillNtuple(); } - + Int_t nSurvivingV0s=0; while(fV0Reader->NextV0()){ nSurvivingV0s++; + + //-------------------------- filling v0 information ------------------------------------- - fHistograms->FillHistogram("ESD_EP_OpeningAngle", fV0Reader->GetOpeningAngle()); - fHistograms->FillHistogram("ESD_EP_R", fV0Reader->GetXYRadius()); - fHistograms->FillHistogram("ESD_EP_ZR", fV0Reader->GetZ(),fV0Reader->GetXYRadius()); - fHistograms->FillHistogram("ESD_EP_XY", fV0Reader->GetX(),fV0Reader->GetY()); - - + fHistograms->FillHistogram("ESD_Conversion_R", fV0Reader->GetXYRadius()); + fHistograms->FillHistogram("ESD_Conversion_ZR", fV0Reader->GetZ(),fV0Reader->GetXYRadius()); + fHistograms->FillHistogram("ESD_Conversion_XY", fV0Reader->GetX(),fV0Reader->GetY()); + fHistograms->FillHistogram("ESD_Conversion_OpeningAngle", fV0Reader->GetOpeningAngle()); + fHistograms->FillHistogram("ESD_E_Energy", fV0Reader->GetNegativeTrackEnergy()); fHistograms->FillHistogram("ESD_E_Pt", fV0Reader->GetNegativeTrackPt()); fHistograms->FillHistogram("ESD_E_Eta", fV0Reader->GetNegativeTrackEta()); fHistograms->FillHistogram("ESD_E_Phi", fV0Reader->GetNegativeTrackPhi()); - + fHistograms->FillHistogram("ESD_P_Energy", fV0Reader->GetPositiveTrackEnergy()); fHistograms->FillHistogram("ESD_P_Pt", fV0Reader->GetPositiveTrackPt()); fHistograms->FillHistogram("ESD_P_Eta", fV0Reader->GetPositiveTrackEta()); fHistograms->FillHistogram("ESD_P_Phi", fV0Reader->GetPositiveTrackPhi()); - - fHistograms->FillHistogram("ESD_Gamma_Energy", fV0Reader->GetMotherCandidateEnergy()); - fHistograms->FillHistogram("ESD_Gamma_Pt", fV0Reader->GetMotherCandidatePt()); - fHistograms->FillHistogram("ESD_Gamma_Eta", fV0Reader->GetMotherCandidateEta()); - fHistograms->FillHistogram("ESD_Gamma_Phi", fV0Reader->GetMotherCandidatePhi()); - - + + fHistograms->FillHistogram("ESD_ConvGamma_Energy", fV0Reader->GetMotherCandidateEnergy()); + fHistograms->FillHistogram("ESD_ConvGamma_Pt", fV0Reader->GetMotherCandidatePt()); + fHistograms->FillHistogram("ESD_ConvGamma_Eta", fV0Reader->GetMotherCandidateEta()); + fHistograms->FillHistogram("ESD_ConvGamma_Phi", fV0Reader->GetMotherCandidatePhi()); + fHistograms->FillHistogram("ESD_ConvGamma_Mass", fV0Reader->GetMotherCandidateMass()); + fHistograms->FillHistogram("ESD_ConvGamma_Width", fV0Reader->GetMotherCandidateWidth()); + fHistograms->FillHistogram("ESD_ConvGamma_Chi2", fV0Reader->GetMotherCandidateChi2()); + fHistograms->FillHistogram("ESD_ConvGamma_NDF", fV0Reader->GetMotherCandidateNDF()); + fHistograms->FillHistogram("ESD_ConvGamma_Rapid", fV0Reader->GetMotherCandidateRapidity()); + fHistograms->FillHistogram("ESD_ConvGamma_Pt_Eta", fV0Reader->GetMotherCandidatePt(),fV0Reader->GetMotherCandidateEta()); + + // begin mapping Int_t rBin = fHistograms->GetRBin(fV0Reader->GetXYRadius()); Int_t phiBin = fHistograms->GetPhiBin(fV0Reader->GetNegativeTrackPhi()); Double_t motherCandidateEta= fV0Reader->GetMotherCandidateEta(); - + TString nameESDMappingPhiR=""; - nameESDMappingPhiR.Form("ESD_EP_Mapping-Phi%02d-R%02d",phiBin,rBin); + nameESDMappingPhiR.Form("ESD_Conversion_Mapping-Phi%02d-R%02d",phiBin,rBin); fHistograms->FillHistogram(nameESDMappingPhiR, fV0Reader->GetZ(), motherCandidateEta); - + TString nameESDMappingPhi=""; - nameESDMappingPhi.Form("ESD_EP_Mapping-Phi%02d",phiBin); + nameESDMappingPhi.Form("ESD_Conversion_Mapping-Phi%02d",phiBin); fHistograms->FillHistogram(nameESDMappingPhi, fV0Reader->GetZ(), motherCandidateEta); - + TString nameESDMappingR=""; - nameESDMappingR.Form("ESD_EP_Mapping-R%02d",rBin); + nameESDMappingR.Form("ESD_Conversion_Mapping-R%02d",rBin); fHistograms->FillHistogram(nameESDMappingR, fV0Reader->GetZ(), motherCandidateEta); - + TString nameESDMappingPhiInR=""; - nameESDMappingPhiInR.Form("ESD_EP_Mapping_Phi_R-%02d",rBin); + nameESDMappingPhiInR.Form("ESD_Conversion_Mapping_Phi_R-%02d",rBin); fHistograms->FillHistogram(nameESDMappingPhiInR, fV0Reader->GetMotherCandidatePhi()); // end mapping - + fKFReconstructedGammas.push_back(*fV0Reader->GetMotherCandidateKFCombination()); + electronv1.push_back(fV0Reader->GetCurrentV0()->GetPindex()); + electronv2.push_back(fV0Reader->GetCurrentV0()->GetNindex()); + //----------------------------------- checking for "real" conversions (MC match) -------------------------------------- if(fDoMCTruth){ + if(fV0Reader->HasSameMCMother() == kFALSE){ + fIsTrueReconstructedGammas.push_back(kFALSE); continue; } - + + TParticle * negativeMC = (TParticle*)fV0Reader->GetNegativeMCParticle(); TParticle * positiveMC = (TParticle*)fV0Reader->GetPositiveMCParticle(); - if(negativeMC->GetPdgCode()!=11 || positiveMC->GetPdgCode()!=-11){ + if(TMath::Abs(negativeMC->GetPdgCode())!=11 || TMath::Abs(positiveMC->GetPdgCode())!=11){ + fIsTrueReconstructedGammas.push_back(kFALSE); continue; } + if(negativeMC->GetPdgCode()==positiveMC->GetPdgCode()){ + fIsTrueReconstructedGammas.push_back(kFALSE); + continue; + } + if(fV0Reader->GetMotherMCParticle()->GetPdgCode() == 22){ - fHistograms->FillHistogram("ESD_Match_Gamma_XY", fV0Reader->GetX(),fV0Reader->GetY()); - fHistograms->FillHistogram("ESD_Match_Gamma_OpeningAngle", fV0Reader->GetOpeningAngle()); - fHistograms->FillHistogram("ESD_Match_Gamma_Pt", fV0Reader->GetMotherCandidatePt()); - fHistograms->FillHistogram("ESD_Match_Gamma_Energy", fV0Reader->GetMotherCandidateEnergy()); - fHistograms->FillHistogram("ESD_Match_Gamma_Eta", fV0Reader->GetMotherCandidateEta()); - - fHistograms->FillHistogram("ESD_Match_Gamma_Phi", fV0Reader->GetMotherCandidatePhi()); - fHistograms->FillHistogram("ESD_Match_Gamma_Mass", fV0Reader->GetMotherCandidateMass()); - fHistograms->FillHistogram("ESD_Match_Gamma_Width", fV0Reader->GetMotherCandidateWidth()); - fHistograms->FillHistogram("ESD_Match_Gamma_Chi2", fV0Reader->GetMotherCandidateChi2()); - fHistograms->FillHistogram("ESD_Match_Gamma_NDF", fV0Reader->GetMotherCandidateNDF()); - fHistograms->FillHistogram("ESD_Match_Gamma_R", fV0Reader->GetXYRadius()); - fHistograms->FillHistogram("ESD_Match_Gamma_ZR", fV0Reader->GetZ(),fV0Reader->GetXYRadius()); + fIsTrueReconstructedGammas.push_back(kTRUE); + + fHistograms->FillHistogram("ESD_TrueConvGamma_Pt", fV0Reader->GetMotherCandidatePt()); + fHistograms->FillHistogram("ESD_TrueConvGamma_Energy", fV0Reader->GetMotherCandidateEnergy()); + fHistograms->FillHistogram("ESD_TrueConvGamma_Eta", fV0Reader->GetMotherCandidateEta()); + fHistograms->FillHistogram("ESD_TrueConvGamma_Phi", fV0Reader->GetMotherCandidatePhi()); + fHistograms->FillHistogram("ESD_TrueConvGamma_Mass", fV0Reader->GetMotherCandidateMass()); + fHistograms->FillHistogram("ESD_TrueConvGamma_Width", fV0Reader->GetMotherCandidateWidth()); + fHistograms->FillHistogram("ESD_TrueConvGamma_Chi2", fV0Reader->GetMotherCandidateChi2()); + fHistograms->FillHistogram("ESD_TrueConvGamma_NDF", fV0Reader->GetMotherCandidateNDF()); + fHistograms->FillHistogram("ESD_TrueConvGamma_Pt_Eta", fV0Reader->GetMotherCandidatePt(),fV0Reader->GetMotherCandidateEta()); + fHistograms->FillHistogram("ESD_TrueConvGamma_Rapid", fV0Reader->GetMotherCandidateRapidity()); + fHistograms->FillHistogram("ESD_TrueConvGamma_TrackLength", /*fV0Reader->GetNegativeTrackLength()*/fV0Reader->GetNegativeNTPCClusters()); + fHistograms->FillHistogram("ESD_TrueConvGamma_TrackLength", /*fV0Reader->GetPositiveTrackLength()*/fV0Reader->GetPositiveNTPCClusters()); + fHistograms->FillHistogram("ESD_TrueConvGamma_TrackLengthVSInvMass",/*fV0Reader->GetNegativeTrackLength()*/fV0Reader->GetNegativeNTPCClusters(),fV0Reader->GetMotherCandidateMass()); + fHistograms->FillHistogram("ESD_TrueConvGamma_TrackLengthVSInvMass",/*fV0Reader->GetPositiveTrackLength()*/fV0Reader->GetPositiveNTPCClusters(),fV0Reader->GetMotherCandidateMass()); + + fHistograms->FillHistogram("ESD_TrueConversion_XY", fV0Reader->GetX(),fV0Reader->GetY()); + fHistograms->FillHistogram("ESD_TrueConversion_R", fV0Reader->GetXYRadius()); + fHistograms->FillHistogram("ESD_TrueConversion_ZR", fV0Reader->GetZ(),fV0Reader->GetXYRadius()); + fHistograms->FillHistogram("ESD_TrueConversion_OpeningAngle", fV0Reader->GetOpeningAngle()); + + + /* + fHistograms->FillHistogram("ESD_TrueConversion_XY", fV0Reader->GetX(),fV0Reader->GetY()); + fHistograms->FillHistogram("ESD_TrueConversion_R", fV0Reader->GetXYRadius()); + fHistograms->FillHistogram("ESD_TrueConversion_ZR", fV0Reader->GetZ(),fV0Reader->GetXYRadius()); + fHistograms->FillHistogram("ESD_TrueConversion_OpeningAngle", fV0Reader->GetOpeningAngle()); + */ + + //resolution Double_t mcpt = fV0Reader->GetMotherMCParticle()->Pt(); @@ -528,84 +797,114 @@ void AliAnalysisTaskGammaConversion::ProcessV0s(){ if(mcpt != 0){ resdPt = ((esdpt - mcpt)/mcpt)*100; } - + fHistograms->FillHistogram("Resolution_dPt", mcpt, resdPt); fHistograms->FillHistogram("Resolution_MC_Pt", mcpt); fHistograms->FillHistogram("Resolution_ESD_Pt", esdpt); - + Double_t resdZ = 0; if(fV0Reader->GetNegativeMCParticle()->Vz() != 0){ resdZ = ((fV0Reader->GetZ() -fV0Reader->GetNegativeMCParticle()->Vz())/fV0Reader->GetNegativeMCParticle()->Vz())*100; } - + fHistograms->FillHistogram("Resolution_dZ", fV0Reader->GetNegativeMCParticle()->Vz(), resdZ); fHistograms->FillHistogram("Resolution_MC_Z", fV0Reader->GetNegativeMCParticle()->Vz()); fHistograms->FillHistogram("Resolution_ESD_Z", fV0Reader->GetZ()); - + Double_t resdR = 0; if(fV0Reader->GetNegativeMCParticle()->R() != 0){ resdR = ((fV0Reader->GetXYRadius() - fV0Reader->GetNegativeMCParticle()->R())/fV0Reader->GetNegativeMCParticle()->R())*100; } + fHistograms->FillHistogram("Resolution_dR", fV0Reader->GetNegativeMCParticle()->R(), resdR); fHistograms->FillHistogram("Resolution_MC_R", fV0Reader->GetNegativeMCParticle()->R()); fHistograms->FillHistogram("Resolution_ESD_R", fV0Reader->GetXYRadius()); fHistograms->FillHistogram("Resolution_dR_dPt", resdR, resdPt); + }//if(fV0Reader->GetMotherMCParticle()->GetPdgCode() == 22) + else{ + fIsTrueReconstructedGammas.push_back(kFALSE); } - } - } - fHistograms->FillHistogram("NumberOfSurvivingV0s", nSurvivingV0s); - fHistograms->FillHistogram("NumberOfV0s", fV0Reader->GetNumberOfV0s()); + }//if(fDoMCTruth) + }//while(fV0Reader->NextV0) + fHistograms->FillHistogram("ESD_NumberOfSurvivingV0s", nSurvivingV0s); + fHistograms->FillHistogram("ESD_NumberOfV0s", fV0Reader->GetNumberOfV0s()); + + //cout << "nearly at the end of doMCTruth" << endl; + } void AliAnalysisTaskGammaConversion::ProcessGammasForNeutralMesonAnalysis(){ // see header file for documentation - + for(UInt_t firstGammaIndex=0;firstGammaIndexGetMass(massTwoGammaCandidate,widthTwoGammaCandidate); if(twoGammaCandidate->GetNDF()>0){ chi2TwoGammaCandidate = twoGammaCandidate->GetChi2()/twoGammaCandidate->GetNDF(); - if(chi2TwoGammaCandidate>0 && chi2TwoGammaCandidateGetChi2CutMeson()){ - - TVector3 vectorTwoGammaCandidate(twoGammaCandidate->Px(),twoGammaCandidate->Py(),twoGammaCandidate->Pz()); - - Double_t openingAngleTwoGammaCandidate = twoGammaDecayCandidateDaughter0->GetAngle(*twoGammaDecayCandidateDaughter1); - - //Calculating by hand the radius - Double_t tmpX= twoGammaCandidate->GetX(); - Double_t tmpY= twoGammaCandidate->GetY(); - - Double_t radiusTwoGammaCandidate = TMath::Sqrt(tmpX*tmpX + tmpY*tmpY); - - fHistograms->FillHistogram("ESD_TwoGammaCombination_GammaDaughter_OpeningAngle", openingAngleTwoGammaCandidate); - fHistograms->FillHistogram("ESD_TwoGammaCombination_Energy", twoGammaCandidate->GetE()); - fHistograms->FillHistogram("ESD_TwoGammaCombination_Pt", sqrt(twoGammaCandidate->GetPx()*twoGammaCandidate->GetPx()+twoGammaCandidate->GetPy()*twoGammaCandidate->GetPy())); - fHistograms->FillHistogram("ESD_TwoGammaCombination_Eta", vectorTwoGammaCandidate.Eta()); - fHistograms->FillHistogram("ESD_TwoGammaCombination_Phi", vectorTwoGammaCandidate.Phi()); - fHistograms->FillHistogram("ESD_TwoGammaCombination_Mass", massTwoGammaCandidate); - fHistograms->FillHistogram("ESD_TwoGammaCombination_R", radiusTwoGammaCandidate); - fHistograms->FillHistogram("ESD_TwoGammaCombination_ZR", tmpY, radiusTwoGammaCandidate); - fHistograms->FillHistogram("ESD_TwoGammaCombination_XY", tmpX, tmpY); - fHistograms->FillHistogram("InvMass_vs_Pt_Spectra",massTwoGammaCandidate ,sqrt(twoGammaCandidate->GetPx()*twoGammaCandidate->GetPx()+twoGammaCandidate->GetPy()*twoGammaCandidate->GetPy())); + + if(chi2TwoGammaCandidate>0 && chi2TwoGammaCandidateGetChi2CutMeson()){ + + TVector3 MomentumVectorTwoGammaCandidate(twoGammaCandidate->GetPx(),twoGammaCandidate->GetPy(),twoGammaCandidate->GetPz()); + TVector3 SpaceVectorTwoGammaCandidate(twoGammaCandidate->GetX(),twoGammaCandidate->GetY(),twoGammaCandidate->GetZ()); + + Double_t openingAngleTwoGammaCandidate = twoGammaDecayCandidateDaughter0->GetAngle(*twoGammaDecayCandidateDaughter1); + Double_t rapidity; + if(twoGammaCandidate->GetE() - twoGammaCandidate->GetPz() == 0 || twoGammaCandidate->GetE() + twoGammaCandidate->GetPz() == 0){ + rapidity=0; + } + else{ + rapidity = 0.5*(TMath::Log((twoGammaCandidate->GetE() +twoGammaCandidate->GetPz()) / (twoGammaCandidate->GetE()-twoGammaCandidate->GetPz()))); + } + + if(openingAngleTwoGammaCandidate < fMinOpeningAngleGhostCut) continue; // minimum opening angle to avoid using ghosttracks + + fHistograms->FillHistogram("ESD_Mother_GammaDaughter_OpeningAngle", openingAngleTwoGammaCandidate); + fHistograms->FillHistogram("ESD_Mother_Energy", twoGammaCandidate->GetE()); + fHistograms->FillHistogram("ESD_Mother_Pt", MomentumVectorTwoGammaCandidate.Pt()); + fHistograms->FillHistogram("ESD_Mother_Eta", MomentumVectorTwoGammaCandidate.Eta()); + fHistograms->FillHistogram("ESD_Mother_Rapid", rapidity); + fHistograms->FillHistogram("ESD_Mother_Phi", SpaceVectorTwoGammaCandidate.Phi()); + fHistograms->FillHistogram("ESD_Mother_Mass", massTwoGammaCandidate); + fHistograms->FillHistogram("ESD_Mother_R", SpaceVectorTwoGammaCandidate.Pt()); // Pt in Space == R!!! + fHistograms->FillHistogram("ESD_Mother_ZR", twoGammaCandidate->GetZ(), SpaceVectorTwoGammaCandidate.Pt()); + fHistograms->FillHistogram("ESD_Mother_XY", twoGammaCandidate->GetX(), twoGammaCandidate->GetY()); + fHistograms->FillHistogram("ESD_Mother_InvMass_vs_Pt",massTwoGammaCandidate ,MomentumVectorTwoGammaCandidate.Pt()); } } delete twoGammaCandidate; + + //cout << "nearly at the end of processgamma for neutral meson ..." << endl; + + } } } void AliAnalysisTaskGammaConversion::CalculateBackground(){ // see header file for documentation - + vector vectorCurrentEventGoodV0s = fV0Reader->GetCurrentEventGoodV0s(); vector vectorPreviousEventGoodV0s = fV0Reader->GetPreviousEventGoodV0s(); for(UInt_t iCurrent=0;iCurrentGetNDF()>0){ chi2BG = backgroundCandidate->GetChi2()/backgroundCandidate->GetNDF(); if(chi2BG>0 && chi2BGGetChi2CutMeson()){ - - TVector3 vectorBGCandidate(backgroundCandidate->Px(),backgroundCandidate->Py(),backgroundCandidate->Pz()); - + + TVector3 MomentumVectorbackgroundCandidate(backgroundCandidate->GetPx(),backgroundCandidate->GetPy(),backgroundCandidate->GetPz()); + TVector3 SpaceVectorbackgroundCandidate(backgroundCandidate->GetX(),backgroundCandidate->GetY(),backgroundCandidate->GetZ()); + Double_t openingAngleBG = currentEventGoodV0->GetAngle(*previousGoodV0); - //Calculating by hand the radius (find a better way) - Double_t tmpX= backgroundCandidate->GetX(); - Double_t tmpY= backgroundCandidate->GetY(); - - Double_t radiusBG = TMath::Sqrt(tmpX*tmpX + tmpY*tmpY); + Double_t rapidity; + if(backgroundCandidate->GetE() - backgroundCandidate->GetPz() == 0 || backgroundCandidate->GetE() + backgroundCandidate->GetPz() == 0) rapidity=0; + else rapidity = 0.5*(TMath::Log((backgroundCandidate->GetE() +backgroundCandidate->GetPz()) / (backgroundCandidate->GetE()-backgroundCandidate->GetPz()))); + + + + if(openingAngleBG < fMinOpeningAngleGhostCut ) continue; // minimum opening angle to avoid using ghosttracks + + fHistograms->FillHistogram("ESD_Background_GammaDaughter_OpeningAngle", openingAngleBG); fHistograms->FillHistogram("ESD_Background_Energy", backgroundCandidate->GetE()); - fHistograms->FillHistogram("ESD_Background_Pt", sqrt(backgroundCandidate->GetPx()*backgroundCandidate->GetPx()+backgroundCandidate->GetPy()*backgroundCandidate->GetPy())); - fHistograms->FillHistogram("ESD_Background_Eta", vectorBGCandidate.Eta()); - fHistograms->FillHistogram("ESD_Background_Phi", vectorBGCandidate.Phi()); + fHistograms->FillHistogram("ESD_Background_Pt", MomentumVectorbackgroundCandidate.Pt()); + fHistograms->FillHistogram("ESD_Background_Eta", MomentumVectorbackgroundCandidate.Eta()); + fHistograms->FillHistogram("ESD_Background_Rapidity", rapidity); + fHistograms->FillHistogram("ESD_Background_Phi", SpaceVectorbackgroundCandidate.Phi()); fHistograms->FillHistogram("ESD_Background_Mass", massBG); - fHistograms->FillHistogram("ESD_Background_R", radiusBG); - fHistograms->FillHistogram("ESD_Background_ZR", tmpY, radiusBG); - fHistograms->FillHistogram("ESD_Background_XY", tmpX, tmpY); - fHistograms->FillHistogram("Background_InvMass_vs_Pt_Spectra",massBG,sqrt(backgroundCandidate->GetPx()*backgroundCandidate->GetPx()+backgroundCandidate->GetPy()*backgroundCandidate->GetPy())); + fHistograms->FillHistogram("ESD_Background_R", SpaceVectorbackgroundCandidate.Pt()); // Pt in Space == R!!!! + fHistograms->FillHistogram("ESD_Background_ZR", backgroundCandidate->GetZ(), SpaceVectorbackgroundCandidate.Pt()); + fHistograms->FillHistogram("ESD_Background_XY", backgroundCandidate->GetX(), backgroundCandidate->GetY()); + fHistograms->FillHistogram("ESD_Background_InvMass_vs_Pt",massBG,MomentumVectorbackgroundCandidate.Pt()); } } delete backgroundCandidate; + //cout << "nearly at the end of background" << endl; + } } } @@ -667,11 +974,11 @@ void AliAnalysisTaskGammaConversion::UserCreateOutputObjects() if(fOutputContainer == NULL){ fOutputContainer = new TList(); } - + //Adding the histograms to the output container fHistograms->GetOutputContainer(fOutputContainer); - - + + if(fWriteNtuple){ if(fGammaNtuple == NULL){ fGammaNtuple = new TNtuple("V0ntuple","V0ntuple","OnTheFly:HasVertex:NegPIDProb:PosPIDProb:X:Y:Z:R:MotherCandidateNDF:MotherCandidateChi2:MotherCandidateEnergy:MotherCandidateEta:MotherCandidatePt:MotherCandidateMass:MotherCandidateWidth:MCMotherCandidatePT:EPOpeningAngle:ElectronEnergy:ElectronPt:ElectronEta:ElectronPhi:PositronEnergy:PositronPt:PositronEta:PositronPhi:HasSameMCMother:MotherMCParticlePIDCode",50000); @@ -684,7 +991,7 @@ void AliAnalysisTaskGammaConversion::UserCreateOutputObjects() ntupleTList->Add((TNtuple*)fGammaNtuple); fOutputContainer->Add(ntupleTList); } - + fOutputContainer->SetName(GetName()); } diff --git a/PWG4/GammaConv/AliAnalysisTaskGammaConversion.h b/PWG4/GammaConv/AliAnalysisTaskGammaConversion.h index bcff03f59e4..6d442979741 100644 --- a/PWG4/GammaConv/AliAnalysisTaskGammaConversion.h +++ b/PWG4/GammaConv/AliAnalysisTaskGammaConversion.h @@ -27,76 +27,84 @@ class AliStack; class AliAnalysisTaskGammaConversion : public AliAnalysisTaskSE { public: - AliAnalysisTaskGammaConversion(); - AliAnalysisTaskGammaConversion(const char* name); - virtual ~AliAnalysisTaskGammaConversion() ;// virtual destructor + AliAnalysisTaskGammaConversion(); + AliAnalysisTaskGammaConversion(const char* name); + virtual ~AliAnalysisTaskGammaConversion() ;// virtual destructor - // Implementation of interface methods - virtual void UserCreateOutputObjects(); - virtual void Init(); - virtual void LocalInit() {Init();} - virtual void Exec(Option_t *option); - virtual void Terminate(Option_t *option); - virtual void ConnectInputData(Option_t *); + // Implementation of interface methods + virtual void UserCreateOutputObjects(); + virtual void Init(); + virtual void LocalInit() {Init();} + virtual void Exec(Option_t *option); + virtual void Terminate(Option_t *option); + virtual void ConnectInputData(Option_t *); - void ProcessMCData(); - void ProcessV0s(); - void ProcessGammasForNeutralMesonAnalysis(); - void SetHistograms(AliGammaConversionHistograms *histograms){fHistograms=histograms;} - void SetDoMCTruth(Bool_t flag){fDoMCTruth=flag;} - void SetElectronMass(Double_t electronMass){fElectronMass = electronMass;} - void SetGammaMass(Double_t gammaMass){fGammaMass = gammaMass;} - void SetGammaWidth(Double_t gammaWidth){fGammaWidth = gammaWidth;} - void SetPi0Mass(Double_t pi0Mass){fPi0Mass = pi0Mass;} - void SetPi0Width(Double_t pi0Width){fPi0Width = pi0Width;} - void SetEtaMass(Double_t etaMass){fEtaMass = etaMass;} - void SetEtaWidth(Double_t etaWidth){fEtaWidth = etaWidth;} - void SetV0Reader(AliV0Reader* reader){fV0Reader=reader;} - void SetCalculateBackground(Bool_t bg){fCalculateBackground=bg;} - void CalculateBackground(); - void SetWriteNtuple(Bool_t writeNtuple){fWriteNtuple = writeNtuple;} - void FillNtuple(); - Double_t GetMCOpeningAngle(TParticle* daughter0, TParticle* daughter1) const; + void ProcessMCData(); + void ProcessV0sNoCut(); + void ProcessV0s(); + void ProcessGammasForNeutralMesonAnalysis(); + void SetHistograms(AliGammaConversionHistograms *histograms){fHistograms=histograms;} + void SetDoMCTruth(Bool_t flag){fDoMCTruth=flag;} + void SetElectronMass(Double_t electronMass){fElectronMass = electronMass;} + void SetGammaMass(Double_t gammaMass){fGammaMass = gammaMass;} + void SetGammaWidth(Double_t gammaWidth){fGammaWidth = gammaWidth;} + void SetPi0Mass(Double_t pi0Mass){fPi0Mass = pi0Mass;} + void SetPi0Width(Double_t pi0Width){fPi0Width = pi0Width;} + void SetEtaMass(Double_t etaMass){fEtaMass = etaMass;} + void SetEtaWidth(Double_t etaWidth){fEtaWidth = etaWidth;} + void SetMinOpeningAngleGhostCut(Double_t ghostCut){fMinOpeningAngleGhostCut = ghostCut;} + void SetV0Reader(AliV0Reader* reader){fV0Reader=reader;} + void SetCalculateBackground(Bool_t bg){fCalculateBackground=bg;} + void CalculateBackground(); + void SetWriteNtuple(Bool_t writeNtuple){fWriteNtuple = writeNtuple;} + void FillNtuple(); + Double_t GetMCOpeningAngle(TParticle* daughter0, TParticle* daughter1) const; private: - AliAnalysisTaskGammaConversion(const AliAnalysisTaskGammaConversion&); // Not implemented - AliAnalysisTaskGammaConversion& operator=(const AliAnalysisTaskGammaConversion&); // Not implemented + AliAnalysisTaskGammaConversion(const AliAnalysisTaskGammaConversion&); // Not implemented + AliAnalysisTaskGammaConversion& operator=(const AliAnalysisTaskGammaConversion&); // Not implemented - AliV0Reader* fV0Reader; + AliV0Reader* fV0Reader; - AliStack * fStack; + AliStack * fStack; - TList * fOutputContainer ; // Histogram container + TList * fOutputContainer ; // Histogram container - AliGammaConversionHistograms *fHistograms; + AliGammaConversionHistograms *fHistograms; - Bool_t fDoMCTruth; + Bool_t fDoMCTruth; - vector fMCAllGammas; - vector fMCPi0s; - vector fMCEtas; - vector fMCGammaChic; - - vector fKFReconstructedGammas; - - //mass defines - Double_t fElectronMass; - Double_t fGammaMass; - Double_t fPi0Mass; - Double_t fEtaMass; - - // width defines - Double_t fGammaWidth; - Double_t fPi0Width; - Double_t fEtaWidth; - Bool_t fCalculateBackground; - Bool_t fWriteNtuple; - TNtuple *fGammaNtuple; - TNtuple *fNeutralMesonNtuple; - - Int_t fTotalNumberOfAddedNtupleEntries; - - ClassDef(AliAnalysisTaskGammaConversion, 1); // Analysis task for gamma conversions + vector fMCAllGammas; + vector fMCPi0s; + vector fMCEtas; + vector fMCGammaChic; + + vector fKFReconstructedGammas; + vector fIsTrueReconstructedGammas; + vector electronv1; + vector electronv2; + + //mass defines + Double_t fElectronMass; + Double_t fGammaMass; + Double_t fPi0Mass; + Double_t fEtaMass; + + // width defines + Double_t fGammaWidth; + Double_t fPi0Width; + Double_t fEtaWidth; + + Double_t fMinOpeningAngleGhostCut; + + Bool_t fCalculateBackground; + Bool_t fWriteNtuple; + TNtuple *fGammaNtuple; + TNtuple *fNeutralMesonNtuple; + + Int_t fTotalNumberOfAddedNtupleEntries; + + ClassDef(AliAnalysisTaskGammaConversion, 2); // Analysis task for gamma conversions }; #endif //ALIANALYSISTASKGAMMA_H diff --git a/PWG4/GammaConv/AliGammaConversionHistograms.cxx b/PWG4/GammaConv/AliGammaConversionHistograms.cxx index 2ca295fe872..ea6377092a7 100644 --- a/PWG4/GammaConv/AliGammaConversionHistograms.cxx +++ b/PWG4/GammaConv/AliGammaConversionHistograms.cxx @@ -88,8 +88,8 @@ AliGammaConversionHistograms & AliGammaConversionHistograms::operator = (const A AliGammaConversionHistograms::~AliGammaConversionHistograms() { //destructor - - + + } void AliGammaConversionHistograms::AddHistogram(TString histogramName, TString histogramTitle, Int_t nXBins, Double_t firstX,Double_t lastX,TString xAxisTitle, TString yAxisTitle){ @@ -114,7 +114,7 @@ void AliGammaConversionHistograms::FillHistogram(TString histogramName, Double_t //see header file for documentation TH1 *tmp = (TH1*)fHistogramMap->GetValue(histogramName.Data()); if(tmp){ - tmp->Fill(xValue); + tmp->Fill(xValue); } } @@ -128,12 +128,12 @@ void AliGammaConversionHistograms::FillHistogram(TString histogramName, Double_t void AliGammaConversionHistograms::GetOutputContainer(TList *fOutputContainer){ //checking if the container is alrerady created - + if(fOutputContainer == NULL){ //print warning return; } - + if(fHistogramMap != NULL){ TIter iter(fHistogramMap); TObjString *histogramName; @@ -265,7 +265,7 @@ Int_t AliGammaConversionHistograms::GetPhiBin(Double_t phi) const{ void AliGammaConversionHistograms::InitializeMappingValues(Int_t nPhiIndex, Int_t nRIndex, Int_t nBinsR, Double_t minRadius, Double_t maxRadius,Int_t nBinsPhi, Double_t minPhi, Double_t maxPhi){ // Initializing the valuse for the mapping - + fNPhiIndex = nPhiIndex; fNRIndex = nRIndex; fMinRadius = minRadius; @@ -284,11 +284,11 @@ void AliGammaConversionHistograms::InitializeMappingValues(Int_t nPhiIndex, Int_ //mapping void AliGammaConversionHistograms::AddMappingHistograms(Int_t nPhiIndex, Int_t nRIndex,Int_t nXBins, Double_t firstX, Double_t lastX, Int_t nYBins, Double_t firstY, Double_t lastY, TString xAxisTitle, TString yAxisTitle){ // see header file for documentation - + for(Int_t phi =0; phi<=fNPhiIndex;phi++){ - + for(Int_t r =0; rGetInputEventHandler()); if(fESDHandler == NULL){ //print warning here } - + // Get pointer to esd event from input handler fESDEvent = fESDHandler->GetEvent(); if(fESDEvent == NULL){ //print warning here } - + //Get pointer to MCTruth fMCTruth = (AliMCEventHandler*)((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler()); if(fMCTruth == NULL){ //print warning here } - + //Get pointer to the mc stack fMCStack = fMCTruth->MCEvent()->Stack(); if(fMCStack == NULL){ //print warning here } - + AliKFParticle::SetField(fESDEvent->GetMagneticField()); - + } AliESDv0* AliV0Reader::GetV0(Int_t index){ //see header file for documentation - + fCurrentV0 = fESDEvent->GetV0(index); UpdateV0Information(); return fCurrentV0; } + Bool_t AliV0Reader::CheckForPrimaryVertex(){ return fESDEvent->GetPrimaryVertex()->GetNContributors()>0; } + + Bool_t AliV0Reader::NextV0(){ //see header file for documentation - + Bool_t iResult=kFALSE; while(fCurrentV0IndexNumberGetNumberOfV0s()){ fCurrentV0 = fESDEvent->GetV0(fCurrentV0IndexNumber); - + //checks if on the fly mode is set if ( !fCurrentV0->GetOnFlyStatus() ){ - fCurrentV0IndexNumber++; if(fHistograms != NULL){ - fHistograms->FillHistogram("V0MassDebugCut1",GetMotherCandidateMass()); + fHistograms->FillHistogram("ESD_CutGetOnFly_InvMass",GetMotherCandidateMass()); } + fCurrentV0IndexNumber++; continue; } - - if(fESDEvent->GetPrimaryVertex()->GetNContributors()<=0) {//checks if we have a vertex - fCurrentV0IndexNumber++; + + //checks if we have a prim vertex + if(fESDEvent->GetPrimaryVertex()->GetNContributors()<=0) { if(fHistograms != NULL){ - fHistograms->FillHistogram("V0MassDebugCut2",GetMotherCandidateMass()); + fHistograms->FillHistogram("ESD_CutNContributors_InvMass",GetMotherCandidateMass()); } + fCurrentV0IndexNumber++; continue; } - + + //Check the pid probability if(CheckPIDProbability(fPIDProbabilityCutNegativeParticle,fPIDProbabilityCutPositiveParticle)==kFALSE){ - fCurrentV0IndexNumber++; if(fHistograms != NULL){ - fHistograms->FillHistogram("V0MassDebugCut3",GetMotherCandidateMass()); + fHistograms->FillHistogram("ESD_CutPIDProb_InvMass",GetMotherCandidateMass()); } + fCurrentV0IndexNumber++; continue; } - + + fCurrentV0->GetXYZ(fCurrentXValue,fCurrentYValue,fCurrentZValue); - + + if(GetXYRadius()>fMaxR){ // cuts on distance from collision point + if(fHistograms != NULL){ + fHistograms->FillHistogram("ESD_CutR_InvMass",GetMotherCandidateMass()); + } fCurrentV0IndexNumber++; + continue; + } + + + if((TMath::Abs(fCurrentZValue)*fLineCutZRSlope)-fLineCutZValue > GetXYRadius() ){ // cuts out regions where we do not reconstruct if(fHistograms != NULL){ - fHistograms->FillHistogram("V0MassDebugCut4",GetMotherCandidateMass()); + fHistograms->FillHistogram("ESD_CutLine_InvMass",GetMotherCandidateMass()); } + fCurrentV0IndexNumber++; + continue; + } + + + if(UpdateV0Information() == kFALSE){ + fCurrentV0IndexNumber++; continue; } - - UpdateV0Information(); - + if(fUseKFParticle){ if(fCurrentMotherKFCandidate->GetNDF()<=0){ - fCurrentV0IndexNumber++; if(fHistograms != NULL){ - fHistograms->FillHistogram("V0MassDebugCut5",GetMotherCandidateMass()); + fHistograms->FillHistogram("ESD_CutNDF_InvMass",GetMotherCandidateMass()); } + fCurrentV0IndexNumber++; continue; } + + Double_t chi2V0 = fCurrentMotherKFCandidate->GetChi2()/fCurrentMotherKFCandidate->GetNDF(); if(chi2V0 > fChi2CutConversion || chi2V0 <=0){ - fCurrentV0IndexNumber++; if(fHistograms != NULL){ - fHistograms->FillHistogram("V0MassDebugCut6",GetMotherCandidateMass()); + fHistograms->FillHistogram("ESD_CutChi2_InvMass",GetMotherCandidateMass()); } - continue; + fCurrentV0IndexNumber++; + continue; } - + + if(TMath::Abs(fMotherCandidateLorentzVector->Eta())> fEtaCut){ - fCurrentV0IndexNumber++; if(fHistograms != NULL){ - fHistograms->FillHistogram("V0MassDebugCut7",GetMotherCandidateMass()); + fHistograms->FillHistogram("ESD_CutEta_InvMass",GetMotherCandidateMass()); } + fCurrentV0IndexNumber++; continue; } - + + if(fMotherCandidateLorentzVector->Pt()FillHistogram("V0MassDebugCut8",GetMotherCandidateMass()); + fHistograms->FillHistogram("ESD_CutPt_InvMass",GetMotherCandidateMass()); } + fCurrentV0IndexNumber++; continue; } + + } else if(fUseESDTrack){ //TODO } - iResult=kTRUE;//means we have a v0 who survived all the cuts applied + fCurrentEventGoodV0s.push_back(*fCurrentMotherKFCandidate); + iResult=kTRUE;//means we have a v0 who survived all the cuts applied + fCurrentV0IndexNumber++; - + break; } return iResult; } -void AliV0Reader::UpdateV0Information(){ +Bool_t AliV0Reader::UpdateV0Information(){ //see header file for documentation - + + Bool_t iResult=kTRUE; // for taking out not refitted, kinks and like sign tracks + + Bool_t switchTracks = kFALSE; + + fCurrentNegativeESDTrack = fESDEvent->GetTrack(fCurrentV0->GetNindex()); + fCurrentPositiveESDTrack = fESDEvent->GetTrack(fCurrentV0->GetPindex()); + + if(fCurrentNegativeESDTrack->GetSign() == fCurrentPositiveESDTrack->GetSign()){ // avoid like sign + iResult=kFALSE; + if(fHistograms != NULL){ + fHistograms->FillHistogram("ESD_CutLikeSign_InvMass",GetMotherCandidateMass()); + } + } + + if(fCurrentPositiveESDTrack->GetSign() == -1 && fCurrentNegativeESDTrack->GetSign() == 1){ // switch wrong signed tracks + fCurrentNegativeESDTrack = fESDEvent->GetTrack(fCurrentV0->GetPindex()); + fCurrentPositiveESDTrack = fESDEvent->GetTrack(fCurrentV0->GetNindex()); + switchTracks = kTRUE; + } + + if( !(fCurrentNegativeESDTrack->GetStatus() & AliESDtrack::kTPCrefit) || + !(fCurrentPositiveESDTrack->GetStatus() & AliESDtrack::kTPCrefit) ){ + // if( !(fCurrentNegativeESDTrack->GetStatus() & AliESDtrack::kITSrefit) || + // !(fCurrentPositiveESDTrack->GetStatus() & AliESDtrack::kITSrefit) ){ + + iResult=kFALSE; + if(fHistograms != NULL){ + fHistograms->FillHistogram("ESD_CutRefit_InvMass",GetMotherCandidateMass()); + } + } + + + if( fCurrentNegativeESDTrack->GetKinkIndex(0) > 0 || + fCurrentPositiveESDTrack->GetKinkIndex(0) > 0) { + + iResult=kFALSE; + if(fHistograms != NULL){ + fHistograms->FillHistogram("ESD_CutKink_InvMass",GetMotherCandidateMass()); + } + } + + + if(fCurrentNegativeKFParticle != NULL){ delete fCurrentNegativeKFParticle; } - fCurrentNegativeKFParticle = new AliKFParticle(*(fCurrentV0->GetParamN()),fNegativeTrackPID); - + if(switchTracks == kFALSE){ + fCurrentNegativeKFParticle = new AliKFParticle(*(fCurrentV0->GetParamN()),fNegativeTrackPID); + } + else{ + fCurrentNegativeKFParticle = new AliKFParticle(*(fCurrentV0->GetParamP()),fNegativeTrackPID); + } + if(fCurrentPositiveKFParticle != NULL){ delete fCurrentPositiveKFParticle; } - fCurrentPositiveKFParticle = new AliKFParticle(*(fCurrentV0->GetParamP()),fPositiveTrackPID); + if(switchTracks == kFALSE){ + fCurrentPositiveKFParticle = new AliKFParticle(*(fCurrentV0->GetParamP()),fPositiveTrackPID); + } + else{ + fCurrentPositiveKFParticle = new AliKFParticle(*(fCurrentV0->GetParamN()),fPositiveTrackPID); + } if(fCurrentMotherKFCandidate != NULL){ delete fCurrentMotherKFCandidate; } fCurrentMotherKFCandidate = new AliKFParticle(*fCurrentNegativeKFParticle,*fCurrentPositiveKFParticle); - fCurrentNegativeESDTrack = fESDEvent->GetTrack(fCurrentV0->GetNindex()); - - fCurrentPositiveESDTrack = fESDEvent->GetTrack(fCurrentV0->GetPindex()); if(fPositiveTrackPID==-11 && fNegativeTrackPID==11){ fCurrentMotherKFCandidate->SetMassConstraint(0,fNSigmaMass); } - + + + + if(fUseImprovedVertex == kTRUE){ AliKFVertex primaryVertexImproved(*GetPrimaryVertex()); primaryVertexImproved+=*fCurrentMotherKFCandidate; fCurrentMotherKFCandidate->SetProductionVertex(primaryVertexImproved); } - + fCurrentMotherKFCandidate->GetMass(fMotherCandidateKFMass,fMotherCandidateKFWidth); - - + + if(fNegativeTrackLorentzVector != NULL){ delete fNegativeTrackLorentzVector; } @@ -325,7 +411,7 @@ void AliV0Reader::UpdateV0Information(){ else if(fUseESDTrack){ fNegativeTrackLorentzVector = new TLorentzVector(fCurrentNegativeESDTrack->Px(),fCurrentNegativeESDTrack->Py(),fCurrentNegativeESDTrack->Pz()); } - + if(fPositiveTrackLorentzVector != NULL){ delete fPositiveTrackLorentzVector; } @@ -335,7 +421,7 @@ void AliV0Reader::UpdateV0Information(){ else if(fUseESDTrack){ fPositiveTrackLorentzVector = new TLorentzVector(fCurrentPositiveESDTrack->Px(),fCurrentPositiveESDTrack->Py(),fCurrentPositiveESDTrack->Pz()); } - + if(fMotherCandidateLorentzVector != NULL){ delete fMotherCandidateLorentzVector; } @@ -345,11 +431,12 @@ void AliV0Reader::UpdateV0Information(){ else if(fUseESDTrack){ fMotherCandidateLorentzVector = new TLorentzVector(*fNegativeTrackLorentzVector + *fPositiveTrackLorentzVector); } - + if(fPositiveTrackPID==-11 && fNegativeTrackPID==11){ fMotherCandidateLorentzVector->SetXYZM(fMotherCandidateLorentzVector->Px() ,fMotherCandidateLorentzVector->Py(),fMotherCandidateLorentzVector->Pz(),0.); } + if(fDoMC == kTRUE){ fMotherMCParticle= NULL; fNegativeMCParticle = fMCStack->Particle(TMath::Abs(fESDEvent->GetTrack(fCurrentV0->GetNindex())->GetLabel())); @@ -358,12 +445,19 @@ void AliV0Reader::UpdateV0Information(){ fMotherMCParticle = fMCStack->Particle(fPositiveMCParticle->GetMother(0)); } } - fCurrentEventGoodV0s.push_back(*fCurrentMotherKFCandidate); + + // if(iResult==kTRUE){ + // fCurrentEventGoodV0s.push_back(*fCurrentMotherKFCandidate); // moved it to NextV0() after all the cuts are applied + // } + + return iResult; } + + Bool_t AliV0Reader::HasSameMCMother(){ //see header file for documentation - + Bool_t iResult = kFALSE; if(fDoMC == kTRUE){ if(fNegativeMCParticle != NULL && fPositiveMCParticle != NULL){ @@ -378,17 +472,17 @@ Bool_t AliV0Reader::HasSameMCMother(){ Bool_t AliV0Reader::CheckPIDProbability(Double_t negProbCut, Double_t posProbCut){ //see header file for documentation - + Bool_t iResult=kFALSE; - + Double_t *posProbArray = new Double_t[10]; Double_t *negProbArray = new Double_t[10]; AliESDtrack* negTrack = fESDEvent->GetTrack(fCurrentV0->GetNindex()); AliESDtrack* posTrack = fESDEvent->GetTrack(fCurrentV0->GetPindex()); - + negTrack->GetTPCpid(negProbArray); posTrack->GetTPCpid(posProbArray); - + if(negProbArray!=NULL && posProbArray!=NULL){ if(negProbArray[GetSpeciesIndex(-1)]>=negProbCut && posProbArray[GetSpeciesIndex(1)]>=posProbCut){ iResult=kTRUE; @@ -400,15 +494,15 @@ Bool_t AliV0Reader::CheckPIDProbability(Double_t negProbCut, Double_t posProbCut } void AliV0Reader::GetPIDProbability(Double_t &negPIDProb,Double_t & posPIDProb){ - + Double_t *posProbArray = new Double_t[10]; Double_t *negProbArray = new Double_t[10]; AliESDtrack* negTrack = fESDEvent->GetTrack(fCurrentV0->GetNindex()); AliESDtrack* posTrack = fESDEvent->GetTrack(fCurrentV0->GetPindex()); - + negTrack->GetTPCpid(negProbArray); posTrack->GetTPCpid(posProbArray); - + if(negProbArray!=NULL && posProbArray!=NULL){ negPIDProb = negProbArray[GetSpeciesIndex(-1)]; posPIDProb = posProbArray[GetSpeciesIndex(1)]; @@ -419,19 +513,37 @@ void AliV0Reader::GetPIDProbability(Double_t &negPIDProb,Double_t & posPIDProb){ void AliV0Reader::UpdateEventByEventData(){ //see header file for documentation - + if(fCurrentEventGoodV0s.size() >0 ){ - fPreviousEventGoodV0s.clear(); - fPreviousEventGoodV0s = fCurrentEventGoodV0s; + // fPreviousEventGoodV0s.clear(); + // fPreviousEventGoodV0s = fCurrentEventGoodV0s; + if(fPreviousEventGoodV0s.size()>19){ + for(UInt_t nCurrent=0;nCurrentPhi()> TMath::Pi()){ offset = -2*TMath::Pi(); @@ -441,7 +553,7 @@ Double_t AliV0Reader::GetNegativeTrackPhi() const{ Double_t AliV0Reader::GetPositiveTrackPhi() const{ //see header file for documentation - + Double_t offset=0; if(fPositiveTrackLorentzVector->Phi()> TMath::Pi()){ offset = -2*TMath::Pi(); @@ -451,7 +563,7 @@ Double_t AliV0Reader::GetPositiveTrackPhi() const{ Double_t AliV0Reader::GetMotherCandidatePhi() const{ //see header file for documentation - + Double_t offset=0; if(fMotherCandidateLorentzVector->Phi()> TMath::Pi()){ offset = -2*TMath::Pi(); @@ -459,11 +571,26 @@ Double_t AliV0Reader::GetMotherCandidatePhi() const{ return fMotherCandidateLorentzVector->Phi()+offset; } -Int_t AliV0Reader::GetSpeciesIndex(Int_t chargeOfTrack){ + +Double_t AliV0Reader::GetMotherCandidateRapidity() const{ //see header file for documentation + + Double_t rapidity=0; + if(fMotherCandidateLorentzVector->Energy() - fMotherCandidateLorentzVector->Pz() == 0 || fMotherCandidateLorentzVector->Energy() + fMotherCandidateLorentzVector->Pz() == 0) rapidity=0; + else rapidity = 0.5*(TMath::Log((fMotherCandidateLorentzVector->Energy() + fMotherCandidateLorentzVector->Pz()) / (fMotherCandidateLorentzVector->Energy()-fMotherCandidateLorentzVector->Pz()))); + return rapidity; + +} + - Int_t iResult = 10; // Unknown particle + + +Int_t AliV0Reader::GetSpeciesIndex(Int_t chargeOfTrack){ + //see header file for documentation + + Int_t iResult = 10; // Unknown particle + if(chargeOfTrack==-1){ //negative track switch(abs(fNegativeTrackPID)){ case 11: //electron @@ -493,7 +620,7 @@ Int_t AliV0Reader::GetSpeciesIndex(Int_t chargeOfTrack){ case 311: //K0 iResult = 8; break; - + //Put in here for kSPECIES::kEleCon ???? } } @@ -526,7 +653,7 @@ Int_t AliV0Reader::GetSpeciesIndex(Int_t chargeOfTrack){ case 311: //K0 iResult = 8; break; - + //Put in here for kSPECIES::kEleCon ???? } } diff --git a/PWG4/GammaConv/AliV0Reader.h b/PWG4/GammaConv/AliV0Reader.h index d6a376dce8e..2fd6517d137 100644 --- a/PWG4/GammaConv/AliV0Reader.h +++ b/PWG4/GammaConv/AliV0Reader.h @@ -280,6 +280,12 @@ class AliV0Reader : public TObject { */ Double_t GetMotherCandidatePhi() const; + /* + * Gets the Rapidity of the mother candidate. + */ + Double_t GetMotherCandidateRapidity() const; + + /* * Update data which need to be updated every event. */ @@ -300,6 +306,12 @@ class AliV0Reader : public TObject { */ Double_t GetPtCut() const{return fPtCut;} + /* + * Gets the line cut values. + */ + Double_t GetLineCutZRSlope() const{return fLineCutZRSlope;} + Double_t GetLineCutZValue() const{return fLineCutZValue;} + /* * Gets the Chi2 cut value for the conversions. */ @@ -310,6 +322,12 @@ class AliV0Reader : public TObject { */ Double_t GetChi2CutMeson() const{return fChi2CutMeson;} + Double_t GetPositiveTrackLength() const{return fCurrentPositiveESDTrack->GetIntegratedLength();} + Double_t GetNegativeTrackLength() const{return fCurrentNegativeESDTrack->GetIntegratedLength();} + + Double_t GetPositiveNTPCClusters() const{return fCurrentPositiveESDTrack->GetTPCNcls();} + Double_t GetNegativeNTPCClusters() const{return fCurrentNegativeESDTrack->GetTPCNcls();} + /* * Sets the MaxRCut value. */ @@ -325,6 +343,12 @@ class AliV0Reader : public TObject { */ void SetPtCut(Double_t ptCut){fPtCut=ptCut;} + /* + * Sets the LineCut values. + */ + void SetLineCutZRSlope(Double_t LineCutZRSlope){fLineCutZRSlope=LineCutZRSlope;} + void SetLineCutZValue(Double_t LineCutZValue){fLineCutZValue=LineCutZValue;} + /* * Sets the Chi2Cut value for conversions. */ @@ -378,7 +402,7 @@ class AliV0Reader : public TObject { /* * Updates the V0 information of the current V0. */ - void UpdateV0Information(); + Bool_t UpdateV0Information(); /* * Resets the V0 index. @@ -450,6 +474,8 @@ class AliV0Reader : public TObject { Double_t fMaxR; Double_t fEtaCut; Double_t fPtCut; + Double_t fLineCutZRSlope; + Double_t fLineCutZValue; Double_t fChi2CutConversion; Double_t fChi2CutMeson; Double_t fPIDProbabilityCutNegativeParticle; @@ -465,7 +491,7 @@ class AliV0Reader : public TObject { vector fCurrentEventGoodV0s; vector fPreviousEventGoodV0s; - ClassDef(AliV0Reader,0) + ClassDef(AliV0Reader,1) }; diff --git a/PWG4/macros/ConfigGammaConversion.C b/PWG4/macros/ConfigGammaConversion.C index 4de085316b4..a42bc2bb0bd 100644 --- a/PWG4/macros/ConfigGammaConversion.C +++ b/PWG4/macros/ConfigGammaConversion.C @@ -1,4 +1,5 @@ /** VERSION NUMBER 0 */ +/** new Version Kenneth */ Bool_t usePWG4PartCorr = kTRUE; @@ -22,9 +23,12 @@ Int_t numberOfFilesToAnalyze=0; Int_t pidOfNegativeTrack=11; Int_t pidOfPositiveTrack=-11; -Double_t maxRCut = 200.; +Double_t LineCutZRSlope = 0.662487; +Double_t LineCutZValue = 7.; + +Double_t maxRCut = 160.; Double_t etaCut = 1.2; -Double_t ptCut = 0.1; +Double_t ptCut = 0.02; Double_t chi2CutConversion = 20.; Double_t chi2CutMeson = 20.; @@ -49,7 +53,9 @@ Double_t pi0Width = 0.01; Double_t etaWidth = 0.01; // define the probability of track being an electron -Double_t probElectron = 0.5; +Double_t probElectron = 0.002; + +Double_t minOpeningAngleGhostCut = 0.01; /** ----------------------------------end define cuts here----------------------------------*/ @@ -63,148 +69,236 @@ Double_t minPhi = -TMath::Pi(); Double_t maxPhi = TMath::Pi(); /** ------------------------------- end Phi/R Mapping ------------------------------------*/ + + /** ------------------- define which histograms to plot here --------------------------------*/ /** NB: to change the bin numbers, see below the histogram flags */ -Bool_t plotMCEPR = kTRUE; -Bool_t plotMCEPZR = kTRUE; -Bool_t plotMCEPXY = kTRUE; -Bool_t plotMCEPOpeningAngle = kTRUE; - -Bool_t plotMCEEnergy = kTRUE; -Bool_t plotMCEPt = kTRUE; -Bool_t plotMCEEta = kTRUE; -Bool_t plotMCEPhi = kTRUE; - -Bool_t plotMCPEnergy = kTRUE; -Bool_t plotMCPPt = kTRUE; -Bool_t plotMCPEta = kTRUE; -Bool_t plotMCPPhi = kTRUE; - -Bool_t plotMCGammaEnergy = kTRUE; -Bool_t plotMCGammaPt = kTRUE; -Bool_t plotMCGammaEta = kTRUE; -Bool_t plotMCGammaPhi = kTRUE; - -Bool_t plotMCDirectGammaEnergy = kTRUE; -Bool_t plotMCDirectGammaPt = kTRUE; -Bool_t plotMCDirectGammaEta = kTRUE; -Bool_t plotMCDirectGammaPhi = kTRUE; - -Bool_t plotMCMatchGammaEta = kTRUE; -Bool_t plotMCMatchGammaPhi = kTRUE; -Bool_t plotMCMatchGammaPt = kTRUE; -Bool_t plotMCMatchGammaEnergy = kTRUE; -Bool_t plotMCMatchGammaMass = kTRUE; -Bool_t plotMCMatchGammaOpeningAngle = kTRUE; -Bool_t plotMCMatchGammaR = kTRUE; -Bool_t plotMCMatchGammaZR = kTRUE; -Bool_t plotMCMatchGammaXY = kTRUE; - -Bool_t plotMCPi0Eta = kTRUE; -Bool_t plotMCPi0Phi = kTRUE; -Bool_t plotMCPi0Pt = kTRUE; -Bool_t plotMCPi0Energy = kTRUE; -Bool_t plotMCPi0Mass = kTRUE; -Bool_t plotMCPi0OpeningAngle = kTRUE; -Bool_t plotMCPi0R = kTRUE; -Bool_t plotMCPi0ZR = kTRUE; -Bool_t plotMCPi0XY = kTRUE; - -Bool_t plotMCEtaEta = kTRUE; -Bool_t plotMCEtaPhi = kTRUE; -Bool_t plotMCEtaPt = kTRUE; -Bool_t plotMCEtaEnergy = kTRUE; -Bool_t plotMCEtaMass = kTRUE; -Bool_t plotMCEtaOpeningAngleGamma = kTRUE; -Bool_t plotMCEtaR = kTRUE; -Bool_t plotMCEtaZR = kTRUE; -Bool_t plotMCEtaXY = kTRUE; - +Bool_t plotMCConversionR = kTRUE; +Bool_t plotMCConversionZR = kTRUE; +Bool_t plotMCConversionXY = kTRUE; +Bool_t plotMCConversionOpeningAngle = kTRUE; + +Bool_t plotMCEEnergy = kTRUE; +Bool_t plotMCEPt = kTRUE; +Bool_t plotMCEEta = kTRUE; +Bool_t plotMCEPhi = kTRUE; + +Bool_t plotMCPEnergy = kTRUE; +Bool_t plotMCPPt = kTRUE; +Bool_t plotMCPEta = kTRUE; +Bool_t plotMCPPhi = kTRUE; + +Bool_t plotMCallGammaEnergy = kTRUE; +Bool_t plotMCallGammaPt = kTRUE; +Bool_t plotMCallGammaEta = kTRUE; +Bool_t plotMCallGammaPhi = kTRUE; +Bool_t plotMCallGammaRapid = kTRUE; + + +Bool_t plotMCConvGammaEnergy = kTRUE; +Bool_t plotMCConvGammaPt = kTRUE; +Bool_t plotMCConvGammaEta = kTRUE; +Bool_t plotMCConvGammaPhi = kTRUE; +Bool_t plotMCConvGammaRapid = kTRUE; +Bool_t plotMCConvGammaPtvsEta = kTRUE; + +Bool_t plotMCallDirectGammaEnergy = kTRUE; +Bool_t plotMCallDirectGammaPt = kTRUE; +Bool_t plotMCallDirectGammaEta = kTRUE; +Bool_t plotMCallDirectGammaPhi = kTRUE; +Bool_t plotMCallDirectGammaRapid = kTRUE; + + +Bool_t plotMCConvDirectGammaEnergy = kTRUE; +Bool_t plotMCConvDirectGammaPt = kTRUE; +Bool_t plotMCConvDirectGammaEta = kTRUE; +Bool_t plotMCConvDirectGammaPhi = kTRUE; +Bool_t plotMCConvDirectGammaRapid = kTRUE; + +Bool_t plotMCMotherEta = kTRUE; +Bool_t plotMCMotherRapid = kTRUE; +Bool_t plotMCMotherPhi = kTRUE; +Bool_t plotMCMotherPt = kTRUE; +Bool_t plotMCMotherEnergy = kTRUE; +Bool_t plotMCMotherMass = kTRUE; +Bool_t plotMCMotherOpeningAngle = kTRUE; +Bool_t plotMCMotherR = kTRUE; +Bool_t plotMCMotherZR = kTRUE; +Bool_t plotMCMotherXY = kTRUE; +Bool_t plotMCMotherPtvsEtaWithinAcceptance = kTRUE; +Bool_t plotMCMotherPtvsRapidWithinAcceptance = kTRUE; +Bool_t plotMCMotherPtvsEtaConvGammaWithinAcceptance = kTRUE; +Bool_t plotMCMotherPtvsRapidConvGammaWithinAcceptance = kTRUE; +Bool_t plotMCMotherSpectra = kTRUE; + +Bool_t plotMCPi0Eta = kTRUE; +Bool_t plotMCPi0Rapid = kTRUE; +Bool_t plotMCPi0Phi = kTRUE; +Bool_t plotMCPi0Pt = kTRUE; +Bool_t plotMCPi0Energy = kTRUE; +Bool_t plotMCPi0Mass = kTRUE; +Bool_t plotMCPi0OpeningAngle = kTRUE; +Bool_t plotMCPi0R = kTRUE; +Bool_t plotMCPi0ZR = kTRUE; +Bool_t plotMCPi0XY = kTRUE; +Bool_t plotMCPi0PtvsEtaWithinAcceptance = kTRUE; +Bool_t plotMCPi0PtvsRapidWithinAcceptance = kTRUE; +Bool_t plotMCPi0PtvsEtaConvGammaWithinAcceptance = kTRUE; +Bool_t plotMCPi0PtvsRapidConvGammaWithinAcceptance = kTRUE; + + +Bool_t plotMCPi0SecondaryEta = kTRUE; +Bool_t plotMCPi0SecondaryRapid = kTRUE; +Bool_t plotMCPi0SecondaryPhi = kTRUE; +Bool_t plotMCPi0SecondaryPt = kTRUE; +Bool_t plotMCPi0SecondaryEnergy = kTRUE; +Bool_t plotMCPi0SecondaryMass = kTRUE; +Bool_t plotMCPi0SecondaryOpeningAngle = kTRUE; +Bool_t plotMCPi0SecondaryR = kTRUE; +Bool_t plotMCPi0SecondaryZR = kTRUE; +Bool_t plotMCPi0SecondaryXY = kTRUE; +Bool_t plotMCPi0SecondaryPtvsEtaWithinAcceptance = kTRUE; +Bool_t plotMCPi0SecondaryPtvsRapidWithinAcceptance = kTRUE; +Bool_t plotMCPi0SecondaryPtvsEtaConvGammaWithinAcceptance = kTRUE; +Bool_t plotMCPi0SecondaryPtvsRapidConvGammaWithinAcceptance = kTRUE; + + +Bool_t plotMCEtaEta = kTRUE; +Bool_t plotMCEtaRapid = kTRUE; +Bool_t plotMCEtaPhi = kTRUE; +Bool_t plotMCEtaPt = kTRUE; +Bool_t plotMCEtaEnergy = kTRUE; +Bool_t plotMCEtaMass = kTRUE; +Bool_t plotMCEtaOpeningAngleGamma = kTRUE; +Bool_t plotMCEtaR = kTRUE; +Bool_t plotMCEtaZR = kTRUE; +Bool_t plotMCEtaXY = kTRUE; +Bool_t plotMCEtaPtvsEtaWithinAcceptance = kTRUE; +Bool_t plotMCEtaPtvsRapidWithinAcceptance = kTRUE; +Bool_t plotMCEtaPtvsEtaConvGammaWithinAcceptance = kTRUE; +Bool_t plotMCEtaPtvsRapidConvGammaWithinAcceptance = kTRUE; + + // Histograms from esd tracks -Bool_t plotESDEPR = kTRUE; -Bool_t plotESDEPZR = kTRUE; -Bool_t plotESDEPXY = kTRUE; -Bool_t plotESDEPOpeningAngle = kTRUE; - -Bool_t plotESDEEnergy = kTRUE; -Bool_t plotESDEPt = kTRUE; -Bool_t plotESDEEta = kTRUE; -Bool_t plotESDEPhi = kTRUE; - -Bool_t plotESDPEnergy = kTRUE; -Bool_t plotESDPPt = kTRUE; -Bool_t plotESDPEta = kTRUE; -Bool_t plotESDPPhi = kTRUE; - -Bool_t plotESDGammaEnergy = kTRUE; -Bool_t plotESDGammaPt = kTRUE; -Bool_t plotESDGammaEta = kTRUE; -Bool_t plotESDGammaPhi = kTRUE; - -Bool_t plotESDMatchGammaOpeningAngle = kTRUE; -Bool_t plotESDMatchGammaEnergy = kTRUE; -Bool_t plotESDMatchGammaPt = kTRUE; -Bool_t plotESDMatchGammaEta = kTRUE; -Bool_t plotESDMatchGammaPhi = kTRUE; -Bool_t plotESDMatchGammaMass = kTRUE; -Bool_t plotESDMatchGammaWidth = kTRUE; -Bool_t plotESDMatchGammaChi2 = kTRUE; -Bool_t plotESDMatchGammaNDF = kTRUE; -Bool_t plotESDMatchGammaR = kTRUE; -Bool_t plotESDMatchGammaZR = kTRUE; -Bool_t plotESDMatchGammaXY = kTRUE; - -Bool_t plotESDTwoGammaCombinationOpeningAngleGamma = kTRUE; -Bool_t plotESDTwoGammaCombinationEnergy = kTRUE; -Bool_t plotESDTwoGammaCombinationPt = kTRUE; -Bool_t plotESDTwoGammaCombinationEta = kTRUE; -Bool_t plotESDTwoGammaCombinationPhi = kTRUE; -Bool_t plotESDTwoGammaCombinationMass = kTRUE; -Bool_t plotESDTwoGammaCombinationR = kTRUE; -Bool_t plotESDTwoGammaCombinationZR = kTRUE; -Bool_t plotESDTwoGammaCombinationXY = kTRUE; - -Bool_t plotESDBackgroundOpeningAngleGamma = kTRUE; -Bool_t plotESDBackgroundEnergy = kTRUE; -Bool_t plotESDBackgroundPt = kTRUE; -Bool_t plotESDBackgroundEta = kTRUE; -Bool_t plotESDBackgroundPhi = kTRUE; -Bool_t plotESDBackgroundMass = kTRUE; -Bool_t plotESDBackgroundR = kTRUE; -Bool_t plotESDBackgroundZR = kTRUE; -Bool_t plotESDBackgroundXY = kTRUE; - -Bool_t plotMapping = kTRUE; - -Bool_t plotResolutiondPt = kTRUE; -Bool_t plotResolutiondR = kTRUE; -Bool_t plotResolutiondZ = kTRUE; - -Bool_t plotResolutiondRdPt = kTRUE; - -Bool_t plotResolutionMCPt = kTRUE; -Bool_t plotResolutionMCR = kTRUE; -Bool_t plotResolutionMCZ = kTRUE; - -Bool_t plotResolutionESDPt = kTRUE; -Bool_t plotResolutionESDR = kTRUE; -Bool_t plotResolutionESDZ = kTRUE; - -Bool_t plotNumberOfV0s = kTRUE; -Bool_t plotNumberOfSurvivingV0s = kTRUE; +Bool_t plotESDConversionR = kTRUE; +Bool_t plotESDConversionZR = kTRUE; +Bool_t plotESDConversionXY = kTRUE; +Bool_t plotESDConversionOpeningAngle = kTRUE; + +Bool_t plotESDEEnergy = kTRUE; +Bool_t plotESDEPt = kTRUE; +Bool_t plotESDEEta = kTRUE; +Bool_t plotESDEPhi = kTRUE; + +Bool_t plotESDPEnergy = kTRUE; +Bool_t plotESDPPt = kTRUE; +Bool_t plotESDPEta = kTRUE; +Bool_t plotESDPPhi = kTRUE; + +Bool_t plotESDConvGammaEnergy = kTRUE; +Bool_t plotESDConvGammaPt = kTRUE; +Bool_t plotESDConvGammaEta = kTRUE; +Bool_t plotESDConvGammaPhi = kTRUE; +Bool_t plotESDConvGammaMass = kTRUE; +Bool_t plotESDConvGammaWidth = kTRUE; +Bool_t plotESDConvGammaChi2 = kTRUE; +Bool_t plotESDConvGammaNDF = kTRUE; +Bool_t plotESDConvGammaRapid = kTRUE; +Bool_t plotESDConvGammaPtvsEta = kTRUE; + +Bool_t plotESDTrueConvGammaEnergy = kTRUE; +Bool_t plotESDTrueConvGammaPt = kTRUE; +Bool_t plotESDTrueConvGammaEta = kTRUE; +Bool_t plotESDTrueConvGammaPhi = kTRUE; +Bool_t plotESDTrueConvGammaMass = kTRUE; +Bool_t plotESDTrueConvGammaWidth = kTRUE; +Bool_t plotESDTrueConvGammaChi2 = kTRUE; +Bool_t plotESDTrueConvGammaNDF = kTRUE; +Bool_t plotESDTrueConvGammaRapid = kTRUE; +Bool_t plotESDTrueConvGammaPtvsEta = kTRUE; +Bool_t plotESDTrueConversionR = kTRUE; +Bool_t plotESDTrueConversionZR = kTRUE; +Bool_t plotESDTrueConversionXY = kTRUE; +Bool_t plotESDTrueConversionOpeningAngle = kTRUE; + +Bool_t plotESDNoCutConvGammaEnergy = kTRUE; +Bool_t plotESDNoCutConvGammaPt = kTRUE; +Bool_t plotESDNoCutConvGammaEta = kTRUE; +Bool_t plotESDNoCutConvGammaPhi = kTRUE; +Bool_t plotESDNoCutConvGammaMass = kTRUE; +Bool_t plotESDNoCutConvGammaWidth = kTRUE; +Bool_t plotESDNoCutConvGammaChi2 = kTRUE; +Bool_t plotESDNoCutConvGammaNDF = kTRUE; +Bool_t plotESDNoCutConvGammaRapid = kTRUE; +Bool_t plotESDNoCutConvGammaPtvsEta = kTRUE; +Bool_t plotESDNoCutConversionR = kTRUE; +Bool_t plotESDNoCutConversionZR = kTRUE; +Bool_t plotESDNoCutConversionXY = kTRUE; +Bool_t plotESDNoCutConversionOpeningAngle = kTRUE; + +Bool_t plotESDMotherOpeningAngleGamma = kTRUE; +Bool_t plotESDMotherEnergy = kTRUE; +Bool_t plotESDMotherPt = kTRUE; +Bool_t plotESDMotherEta = kTRUE; +Bool_t plotESDMotherPhi = kTRUE; +Bool_t plotESDMotherMass = kTRUE; +Bool_t plotESDMotherR = kTRUE; +Bool_t plotESDMotherZR = kTRUE; +Bool_t plotESDMotherXY = kTRUE; +Bool_t plotESDMotherRapid = kTRUE; + + +Bool_t plotESDBackgroundOpeningAngleGamma = kTRUE; +Bool_t plotESDBackgroundEnergy = kTRUE; +Bool_t plotESDBackgroundPt = kTRUE; +Bool_t plotESDBackgroundEta = kTRUE; +Bool_t plotESDBackgroundPhi = kTRUE; +Bool_t plotESDBackgroundMass = kTRUE; +Bool_t plotESDBackgroundR = kTRUE; +Bool_t plotESDBackgroundZR = kTRUE; +Bool_t plotESDBackgroundXY = kTRUE; +Bool_t plotESDBackgroundRapid = kTRUE; + + + +Bool_t plotMapping = kFALSE; + +Bool_t plotResolutiondPt = kTRUE; +Bool_t plotResolutiondR = kTRUE; +Bool_t plotResolutiondZ = kTRUE; + +Bool_t plotResolutiondRdPt = kTRUE; + +Bool_t plotResolutionMCPt = kTRUE; +Bool_t plotResolutionMCR = kTRUE; +Bool_t plotResolutionMCZ = kTRUE; + +Bool_t plotResolutionESDPt = kTRUE; +Bool_t plotResolutionESDR = kTRUE; +Bool_t plotResolutionESDZ = kTRUE; + +Bool_t plotESDNumberOfV0s = kTRUE; +Bool_t plotESDNumberOfSurvivingV0s = kTRUE; // debug histograms -Bool_t plotV0MassDebugCut1 = kTRUE; -Bool_t plotV0MassDebugCut2 = kTRUE; -Bool_t plotV0MassDebugCut3 = kTRUE; -Bool_t plotV0MassDebugCut4 = kTRUE; -Bool_t plotV0MassDebugCut5 = kTRUE; -Bool_t plotV0MassDebugCut6 = kTRUE; -Bool_t plotV0MassDebugCut7 = kTRUE; -Bool_t plotV0MassDebugCut8 = kTRUE; - -Bool_t plotPi0Spectra = kTRUE; -Bool_t plotEtaSpectra = kTRUE; +Bool_t plotESDCutGetOnFly = kTRUE; +Bool_t plotESDCutNContributors = kTRUE; +Bool_t plotESDCutLikeSign = kTRUE; +Bool_t plotESDCutRefit = kTRUE; +Bool_t plotESDCutKink = kTRUE; +Bool_t plotESDCutPIDProb = kTRUE; +Bool_t plotESDCutR = kTRUE; +Bool_t plotESDCutLine = kTRUE; +Bool_t plotESDCutNDF = kTRUE; +Bool_t plotESDCutChi2 = kTRUE; +Bool_t plotESDCutEta = kTRUE; +Bool_t plotESDCutPt = kTRUE; +Bool_t plotESDTrueConvGammaTrackLength =kTRUE; +Bool_t plotESDTrueConvGammaTrackLengthVSInvMass =kTRUE; + + +Bool_t plotPi0Spectra = kTRUE; +Bool_t plotEtaSpectra = kTRUE; /** ----------------- end define which histograms to plot here -------------------------------*/ @@ -213,58 +307,63 @@ Bool_t plotEtaSpectra = kTRUE; /** ----------- Define the binning for the different plot types here -------------------------*/ //R-plots -Int_t nXBinsR = 1000; +Int_t nXBinsR = 500; Double_t firstXBinR = 0.; Double_t lastXBinR = 250.; //ZR-plots -Int_t nXBinsZR = 2000; -Double_t firstXBinZR = -10.; -Double_t lastXBinZR = 10.; -Int_t nYBinsZR = 1000; +Int_t nXBinsZR = 1200; +Double_t firstXBinZR = -300.; +Double_t lastXBinZR = 300.; +Int_t nYBinsZR = 500; Double_t firstYBinZR = 0.; Double_t lastYBinZR = 250.; //XY-plots -Int_t nXBinsXY = 2000; +Int_t nXBinsXY = 1000; Double_t firstXBinXY = -250.; Double_t lastXBinXY = 250.; -Int_t nYBinsXY = 2000; +Int_t nYBinsXY = 1000; Double_t firstYBinXY = -250.; Double_t lastYBinXY = 250.; //OpenAngle-plots -Int_t nXBinsOpeningAngle = 200; +Int_t nXBinsOpeningAngle = 400; Double_t firstXBinOpeningAngle = 0.; -Double_t lastXBinOpeningAngle = TMath::Pi()/2; +Double_t lastXBinOpeningAngle = TMath::Pi(); //Energy-plots -Int_t nXBinsEnergy = 500; +Int_t nXBinsEnergy = 200; Double_t firstXBinEnergy = 0.; -Double_t lastXBinEnergy = 5.; +Double_t lastXBinEnergy = 50.; //Pt-plots -Int_t nXBinsPt = 500; +Int_t nXBinsPt = 200; Double_t firstXBinPt = 0.; -Double_t lastXBinPt = 5.; +Double_t lastXBinPt = 50.; //Eta-plots -Int_t nXBinsEta = 400; +Int_t nXBinsEta = 40; Double_t firstXBinEta = -2.; Double_t lastXBinEta = 2.; +//Rapidity +Int_t nXBinsRapid = 200; +Double_t firstXBinRapid = -10.; +Double_t lastXBinRapid = 10.; + //Phi-plots -Int_t nXBinsPhi = 720; +Int_t nXBinsPhi = 72; Double_t firstXBinPhi = -TMath::Pi(); Double_t lastXBinPhi = TMath::Pi(); //Mapping-plots -Int_t nXBinsMapping = 40; -Double_t firstXBinMapping = -20.; -Double_t lastXBinMapping = 20.; -Int_t nYBinsMapping = 30; -Double_t firstYBinMapping = -1.5; -Double_t lastYBinMapping = 1.5; +Int_t nXBinsMapping = 400; +Double_t firstXBinMapping = -100.; +Double_t lastXBinMapping = 100.; +Int_t nYBinsMapping = 40; +Double_t firstYBinMapping = -2; +Double_t lastYBinMapping = 2; //ResolutionPlots //RESdPt @@ -276,46 +375,46 @@ Int_t firstYBinResdPt= -5; Int_t lastYBinResdPt=5; //RESdR -Int_t nXBinsResdR=1000; +Int_t nXBinsResdR=500; Int_t firstXBinResdR= 0; Int_t lastXBinResdR=250; -Int_t nYBinsResdR=1000; +Int_t nYBinsResdR=100; Int_t firstYBinResdR= -25; Int_t lastYBinResdR=25; //RESdZ -Int_t nXBinsResdZ=2000; +Int_t nXBinsResdZ=80; Int_t firstXBinResdZ= -20; Int_t lastXBinResdZ=20; -Int_t nYBinsResdZ=1000; +Int_t nYBinsResdZ=80; Int_t firstYBinResdZ= -20; Int_t lastYBinResdZ=20; //RESdRdPt -Int_t nXBinsResdRdPt=1000; +Int_t nXBinsResdRdPt=440; Int_t firstXBinResdRdPt= -22; Int_t lastXBinResdRdPt=22; -Int_t nYBinsResdRdPt=1000; +Int_t nYBinsResdRdPt=100; Int_t firstYBinResdRdPt= -5; Int_t lastYBinResdRdPt=5; //RESMCPt -Int_t nXBinsResPt=500; +Int_t nXBinsResPt=100; Int_t firstXBinResPt= 0; Int_t lastXBinResPt=5; //RESMCR -Int_t nXBinsResR=1000; +Int_t nXBinsResR=500; Int_t firstXBinResR= 0; Int_t lastXBinResR=250; //RESMCZ -Int_t nXBinsResZ=1000; +Int_t nXBinsResZ=500; Int_t firstXBinResZ= 0; Int_t lastXBinResZ=250; //GammaMass-plots -Int_t nXBinsGammaMass = 100; +Int_t nXBinsGammaMass = 4000; Double_t firstXBinGammaMass = 0.; Double_t lastXBinGammaMass = 1.; @@ -345,12 +444,17 @@ Double_t firstXBinGammaNDF = 0.; Double_t lastXBinGammaNDF = 10.; //Spectra-plots -Int_t nXBinsSpectra = 100; +Int_t nXBinsSpectra = 500; Double_t firstXBinSpectra = 0.; Double_t lastXBinSpectra = 1.; -Int_t nYBinsSpectra = 500; +Int_t nYBinsSpectra = 100; Double_t firstYBinSpectra = 0.; -Double_t lastYBinSpectra = 100.; +Double_t lastYBinSpectra = 50.; + +//track length plots +Int_t nXBinsTrackLength = 1000; +Double_t firstXBinTrackLength = 0; +Double_t lastXBinTrackLength = 500; /** ---------- end Define the binning for the different plot types here ----------------------*/ @@ -369,17 +473,19 @@ Bool_t writeNtuple = kFALSE; Bool_t scanArguments(TString arguments){ Bool_t iResult = kTRUE; - + + // cout<<"All arguments: "<GetEntries() && iResult==kTRUE; i++) { argument=((TObjString*)pTokens->At(i))->GetString(); - + if(argument.IsNull()) continue; // -- deconvolute-time option if(argument.CompareTo("-data-list") == 0){ @@ -420,7 +526,7 @@ Bool_t scanArguments(TString arguments){ } } } - + delete pTokens; } if (bMissingParam) { @@ -431,11 +537,11 @@ Bool_t scanArguments(TString arguments){ } void ConfigGammaConversion(TString arguments){ - + if(!scanArguments(arguments)){ break; } - + if(numberOfFilesToAnalyze==0){ ifstream dataInStream; dataInStream.open(dataList.Data()); @@ -447,56 +553,86 @@ void ConfigGammaConversion(TString arguments){ while ( !dataInStream.eof() ) { getline(dataInStream, line); - numberOfFilesToAnalyze++; + if(line.compare("") != 0){//checks if there is an empty line in the data list + numberOfFilesToAnalyze++; + } } } cout<<"Number Of files to analyze: "<LoadMacro("$ALICE_ROOT/PWG0/CreateESDChain.C"); // load the CreateChain macro - + AliLog::SetGlobalLogLevel(AliLog::kError); - + //-------------------------------- Creating the histograms ------------------------------- AliGammaConversionHistograms * histograms = new AliGammaConversionHistograms(); - - if(plotMCEPR == kTRUE){ histograms->AddHistogram("MC_EP_R","Radius of gamma conversion points",nXBinsR, firstXBinR, lastXBinR,"counts","cm");} - if(plotMCEPZR == kTRUE){ histograms->AddHistogram("MC_EP_ZR","Radius of gamma conversion points vs Z",nXBinsZR, firstXBinZR, lastXBinZR, nYBinsZR, firstYBinZR, lastYBinZR, "cm", "cm");} - if(plotMCEPXY == kTRUE){ histograms->AddHistogram("MC_EP_XY","Gamma XY converison point.",nXBinsXY, firstXBinXY, lastXBinXY, nYBinsXY, firstYBinXY, lastYBinXY, "cm", "cm");} - if(plotMCEPOpeningAngle == kTRUE){ histograms->AddHistogram("MC_EP_OpeningAngle","Opening angle of e+e- pairs from gamma conversion",nXBinsOpeningAngle, firstXBinOpeningAngle, lastXBinOpeningAngle, "counts", "cm");} - + + if(plotMCConversionR == kTRUE){ histograms->AddHistogram("MC_Conversion_R","Radius of gamma conversion points",nXBinsR, firstXBinR, lastXBinR,"counts","cm");} + if(plotMCConversionZR == kTRUE){ histograms->AddHistogram("MC_Conversion_ZR","Radius of gamma conversion points vs Z",nXBinsZR, firstXBinZR, lastXBinZR, nYBinsZR, firstYBinZR, lastYBinZR, "cm", "cm");} + if(plotMCConversionXY == kTRUE){ histograms->AddHistogram("MC_Conversion_XY","Gamma XY converison point.",nXBinsXY, firstXBinXY, lastXBinXY, nYBinsXY, firstYBinXY, lastYBinXY, "cm", "cm");} + if(plotMCConversionOpeningAngle == kTRUE){ histograms->AddHistogram("MC_Conversion_OpeningAngle","Opening angle of e+e- pairs from gamma conversion",nXBinsOpeningAngle, firstXBinOpeningAngle, lastXBinOpeningAngle, "counts", "cm");} + if(plotMCEEnergy == kTRUE){ histograms->AddHistogram("MC_E_Energy" ,"" , nXBinsEnergy, firstXBinEnergy, lastXBinEnergy, "", "");} if(plotMCEPt == kTRUE){ histograms->AddHistogram("MC_E_Pt" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, "", "");} if(plotMCEEta == kTRUE){ histograms->AddHistogram("MC_E_Eta" ,"" , nXBinsEta, firstXBinEta, lastXBinEta, "", "");} if(plotMCEPhi == kTRUE){ histograms->AddHistogram("MC_E_Phi" ,"" , nXBinsPhi, firstXBinPhi, lastXBinPhi, "", "");} - + if(plotMCPEnergy == kTRUE){ histograms->AddHistogram("MC_P_Energy" ,"" , nXBinsEnergy, firstXBinEnergy, lastXBinEnergy, "", "");} if(plotMCPPt == kTRUE){ histograms->AddHistogram("MC_P_Pt" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, "", "");} if(plotMCPEta == kTRUE){ histograms->AddHistogram("MC_P_Eta" ,"" , nXBinsEta, firstXBinEta, lastXBinEta, "", "");} if(plotMCPPhi == kTRUE){ histograms->AddHistogram("MC_P_Phi" ,"" , nXBinsPhi, firstXBinPhi, lastXBinPhi, "", "");} - - if(plotMCGammaEnergy == kTRUE){ histograms->AddHistogram("MC_Gamma_Energy" ,"" , nXBinsEnergy, firstXBinEnergy, lastXBinEnergy, "", "");} - if(plotMCGammaPt == kTRUE){ histograms->AddHistogram("MC_Gamma_Pt" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, "", "");} - if(plotMCGammaEta == kTRUE){ histograms->AddHistogram("MC_Gamma_Eta" ,"" , nXBinsEta, firstXBinEta, lastXBinEta, "", "");} - if(plotMCGammaPhi == kTRUE){ histograms->AddHistogram("MC_Gamma_Phi" ,"" , nXBinsPhi, firstXBinPhi, lastXBinPhi, "", "");} - - if(plotMCDirectGammaEnergy == kTRUE){ histograms->AddHistogram("MC_DirectGamma_Energy" ,"" , nXBinsEnergy, firstXBinEnergy, lastXBinEnergy, "", "");} - if(plotMCDirectGammaPt == kTRUE){ histograms->AddHistogram("MC_DirectGamma_Pt" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, "", "");} - if(plotMCDirectGammaEta == kTRUE){ histograms->AddHistogram("MC_DirectGamma_Eta" ,"" , nXBinsEta, firstXBinEta, lastXBinEta, "", "");} - if(plotMCDirectGammaPhi == kTRUE){ histograms->AddHistogram("MC_DirectGamma_Phi" ,"" , nXBinsPhi, firstXBinPhi, lastXBinPhi, "", "");} - - if(plotMCMatchGammaEta == kTRUE){ histograms->AddHistogram("MC_Match_Gamma_Eta" ,"" , nXBinsEta, firstXBinEta, lastXBinEta, "", "");} - if(plotMCMatchGammaPhi == kTRUE){ histograms->AddHistogram("MC_Match_Gamma_Phi" ,"" , nXBinsPhi, firstXBinPhi, lastXBinPhi, "", "");} - if(plotMCMatchGammaPt == kTRUE){ histograms->AddHistogram("MC_Match_Gamma_Pt" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, "", "");} - if(plotMCMatchGammaEnergy == kTRUE){ histograms->AddHistogram("MC_Match_Gamma_Energy" ,"" , nXBinsEnergy, firstXBinEnergy, lastXBinEnergy, "", "");} - if(plotMCMatchGammaMass == kTRUE){ histograms->AddHistogram("MC_Match_Gamma_Mass" ,"" , nXBinsGammaMass, firstXBinGammaMass, lastXBinGammaMass, "", "");} - if(plotMCMatchGammaOpeningAngle == kTRUE){ histograms->AddHistogram("MC_Match_Gamma_OpeningAngle" ,"" , nXBinsOpeningAngle, firstXBinOpeningAngle, lastXBinOpeningAngle, "", "");} - if(plotMCMatchGammaR == kTRUE){ histograms->AddHistogram("MC_Match_Gamma_R" ,"" , nXBinsR, firstXBinR, lastXBinR, "", "");} - if(plotMCMatchGammaZR == kTRUE){ histograms->AddHistogram("MC_Match_Gamma_ZR" ,"" , nXBinsZR, firstXBinZR, lastXBinZR, nYBinsZR, firstYBinZR, lastYBinZR, "", "");} - if(plotMCMatchGammaXY == kTRUE){ histograms->AddHistogram("MC_Match_Gamma_XY" ,"" , nXBinsXY, firstXBinXY, lastXBinXY, nYBinsXY, firstYBinXY, lastYBinXY, "", "");} - - if(plotMCPi0Eta == kTRUE){ histograms->AddHistogram("MC_Pi0_Eta" ,"" , nXBinsEta, firstXBinEta, lastXBinEta, "", "");} + + if(plotMCallGammaEnergy == kTRUE){ histograms->AddHistogram("MC_allGamma_Energy" ,"" , nXBinsEnergy, firstXBinEnergy, lastXBinEnergy, "", "");} + if(plotMCallGammaPt == kTRUE){ histograms->AddHistogram("MC_allGamma_Pt" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, "", "");} + if(plotMCallGammaEta == kTRUE){ histograms->AddHistogram("MC_allGamma_Eta" ,"" , nXBinsEta, firstXBinEta, lastXBinEta, "", "");} + if(plotMCallGammaPhi == kTRUE){ histograms->AddHistogram("MC_allGamma_Phi" ,"" , nXBinsPhi, firstXBinPhi, lastXBinPhi, "", "");} + if(plotMCallGammaRapid == kTRUE){ histograms->AddHistogram("MC_allGamma_Rapid" ,"" , nXBinsRapid, firstXBinRapid, lastXBinRapid, "", "");} + + if(plotMCConvGammaEnergy == kTRUE){ histograms->AddHistogram("MC_ConvGamma_Energy" ,"" , nXBinsEnergy, firstXBinEnergy, lastXBinEnergy, "", "");} + if(plotMCConvGammaPt == kTRUE){ histograms->AddHistogram("MC_ConvGamma_Pt" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, "", "");} + if(plotMCConvGammaEta == kTRUE){ histograms->AddHistogram("MC_ConvGamma_Eta" ,"" , nXBinsEta, firstXBinEta, lastXBinEta, "", "");} + if(plotMCConvGammaPhi == kTRUE){ histograms->AddHistogram("MC_ConvGamma_Phi" ,"" , nXBinsPhi, firstXBinPhi, lastXBinPhi, "", "");} + if(plotMCConvGammaRapid == kTRUE){ histograms->AddHistogram("MC_ConvGamma_Rapid" ,"" , nXBinsRapid, firstXBinRapid, lastXBinRapid, "", "");} + if(plotMCConvGammaPtvsEta == kTRUE){ histograms->AddHistogram("MC_ConvGamma_Pt_Eta","", nXBinsPt, firstXBinPt, lastXBinPt,nXBinsEta, firstXBinEta, lastXBinEta,"","");} + + if(plotMCallDirectGammaEnergy == kTRUE){ histograms->AddHistogram("MC_allDirectGamma_Energy" ,"" , nXBinsEnergy, firstXBinEnergy, lastXBinEnergy, "", "");} + if(plotMCallDirectGammaPt == kTRUE){ histograms->AddHistogram("MC_allDirectGamma_Pt" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, "", "");} + if(plotMCallDirectGammaEta == kTRUE){ histograms->AddHistogram("MC_allDirectGamma_Eta" ,"" , nXBinsEta, firstXBinEta, lastXBinEta, "", "");} + if(plotMCallDirectGammaPhi == kTRUE){ histograms->AddHistogram("MC_allDirectGamma_Phi" ,"" , nXBinsPhi, firstXBinPhi, lastXBinPhi, "", "");} + if(plotMCallDirectGammaRapid == kTRUE){ histograms->AddHistogram("MC_allDirectGamma_Rapid" ,"" , nXBinsRapid, firstXBinRapid, lastXBinRapid, "", "");} + + if(plotMCConvDirectGammaEnergy == kTRUE){ histograms->AddHistogram("MC_ConvDirectGamma_Energy" ,"" , nXBinsEnergy, firstXBinEnergy, lastXBinEnergy, "", "");} + if(plotMCConvDirectGammaPt == kTRUE){ histograms->AddHistogram("MC_ConvDirectGamma_Pt" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, "", "");} + if(plotMCConvDirectGammaEta == kTRUE){ histograms->AddHistogram("MC_ConvDirectGamma_Eta" ,"" , nXBinsEta, firstXBinEta, lastXBinEta, "", "");} + if(plotMCConvDirectGammaPhi == kTRUE){ histograms->AddHistogram("MC_ConvDirectGamma_Phi" ,"" , nXBinsPhi, firstXBinPhi, lastXBinPhi, "", "");} + if(plotMCConvDirectGammaRapid == kTRUE){ histograms->AddHistogram("MC_ConvDirectGamma_Rapid" ,"" , nXBinsRapid, firstXBinRapid, lastXBinRapid, "", "");} + + if(plotMCMotherEta == kTRUE){ histograms->AddHistogram("MC_Mother_Eta" ,"" , nXBinsEta, firstXBinEta, lastXBinEta, "", "");} + if(plotMCMotherPhi == kTRUE){ histograms->AddHistogram("MC_Mother_Phi" ,"" , nXBinsPhi, firstXBinPhi, lastXBinPhi, "", "");} + if(plotMCMotherRapid == kTRUE){ histograms->AddHistogram("MC_Mother_Rapid" ,"" , nXBinsRapid, firstXBinRapid, lastXBinRapid, "", "");} + if(plotMCMotherPt == kTRUE){ histograms->AddHistogram("MC_Mother_Pt" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, "", "");} + if(plotMCMotherEnergy == kTRUE){ histograms->AddHistogram("MC_Mother_Energy" ,"" , nXBinsEnergy, firstXBinEnergy, lastXBinEnergy, "", "");} + if(plotMCMotherMass == kTRUE){ histograms->AddHistogram("MC_Mother_Mass" ,"" , nXBinsGammaMass, firstXBinGammaMass, lastXBinGammaMass, "", "");} + if(plotMCMotherOpeningAngle == kTRUE){ histograms->AddHistogram("MC_Mother_GammaDaughter_OpeningAngle" ,"" , nXBinsOpeningAngle, firstXBinOpeningAngle, lastXBinOpeningAngle, "", "");} + if(plotMCMotherR == kTRUE){ histograms->AddHistogram("MC_Mother_R" ,"" , nXBinsR, firstXBinR, lastXBinR, "", "");} + if(plotMCMotherZR == kTRUE){ histograms->AddHistogram("MC_Mother_ZR" ,"" , nXBinsZR, firstXBinZR, lastXBinZR, nYBinsZR, firstYBinZR, lastYBinZR, "", "");} + if(plotMCMotherXY == kTRUE){ histograms->AddHistogram("MC_Mother_XY" ,"" , nXBinsXY, firstXBinXY, lastXBinXY, nYBinsXY, firstYBinXY, lastYBinXY, "", "");} + if(plotMCMotherPtvsEtaWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Mother_Pt_Eta_withinAcceptance" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, nXBinsEta, firstXBinEta, lastXBinEta, "", "");} + if(plotMCMotherPtvsRapidWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Mother_Pt_Rapid_withinAcceptance" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, nXBinsRapid, firstXBinRapid, lastXBinRapid, "", "");} + if(plotMCMotherPtvsEtaConvGammaWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Mother_Pt_Eta_ConvGamma_withinAcceptance" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, nXBinsEta, firstXBinEta, lastXBinEta, "", "");} + if(plotMCMotherPtvsRapidConvGammaWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Mother_Pt_Rapid_ConvGamma_withinAcceptance" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, nXBinsRapid, firstXBinRapid, lastXBinRapid, "", "");} + + if(plotMCMotherSpectra == kTRUE){ + histograms->AddHistogram("MC_Mother_InvMass_vs_Pt" ,"" ,nXBinsSpectra, firstXBinSpectra, lastXBinSpectra, nYBinsSpectra, firstYBinSpectra, lastYBinSpectra, "", ""); + histograms->AddHistogram("MC_Mother_InvMass_vs_Pt_withinAcceptance" ,"" ,nXBinsSpectra, firstXBinSpectra, lastXBinSpectra, nYBinsSpectra, firstYBinSpectra, lastYBinSpectra, "", ""); + histograms->AddHistogram("MC_Mother_InvMass_vs_Pt_ConvGamma_withinAcceptance" ,"" ,nXBinsSpectra, firstXBinSpectra, lastXBinSpectra, nYBinsSpectra, firstYBinSpectra, lastYBinSpectra, "", ""); + } + + + if(plotMCPi0Eta == kTRUE){ histograms->AddHistogram("MC_Pi0_Eta" ,"" , nXBinsEta, firstXBinEta, lastXBinEta, "", "");} + if(plotMCPi0Rapid == kTRUE){ histograms->AddHistogram("MC_Pi0_Rapid" ,"" , nXBinsRapid, firstXBinRapid, lastXBinRapid, "", "");} if(plotMCPi0Phi == kTRUE){ histograms->AddHistogram("MC_Pi0_Phi" ,"" , nXBinsPhi, firstXBinPhi, lastXBinPhi, "", "");} if(plotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_Pi0_Pt" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, "", "");} if(plotMCPi0Energy == kTRUE){ histograms->AddHistogram("MC_Pi0_Energy" ,"" , nXBinsEnergy, firstXBinEnergy, lastXBinEnergy, "", "");} @@ -505,18 +641,31 @@ void ConfigGammaConversion(TString arguments){ if(plotMCPi0R == kTRUE){ histograms->AddHistogram("MC_Pi0_R" ,"" , nXBinsR, firstXBinR, lastXBinR, "", "");} if(plotMCPi0ZR == kTRUE){ histograms->AddHistogram("MC_Pi0_ZR" ,"" , nXBinsZR, firstXBinZR, lastXBinZR, nYBinsZR, firstYBinZR, lastYBinZR, "", "");} if(plotMCPi0XY == kTRUE){ histograms->AddHistogram("MC_Pi0_XY" ,"" , nXBinsXY, firstXBinXY, lastXBinXY, nYBinsXY, firstYBinXY, lastYBinXY, "", "");} - - if(plotMCPi0Eta == kTRUE){ histograms->AddHistogram("MC_Pi0_Secondaries_Eta" ,"" , nXBinsEta, firstXBinEta, lastXBinEta, "", "");} - if(plotMCPi0Phi == kTRUE){ histograms->AddHistogram("MC_Pi0_Secondaries_Phi" ,"" , nXBinsPhi, firstXBinPhi, lastXBinPhi, "", "");} - if(plotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_Pi0_Secondaries_Pt" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, "", "");} - if(plotMCPi0Energy == kTRUE){ histograms->AddHistogram("MC_Pi0_Secondaries_Energy" ,"" , nXBinsEnergy, firstXBinEnergy, lastXBinEnergy, "", "");} - if(plotMCPi0Mass == kTRUE){ histograms->AddHistogram("MC_Pi0_Secondaries_Mass" ,"" , nXBinsPi0Mass, firstXBinPi0Mass, lastXBinPi0Mass, "", "");} - if(plotMCPi0OpeningAngle == kTRUE){ histograms->AddHistogram("MC_Pi0_Secondaries_GammaDaughter_OpeningAngle" ,"" , nXBinsOpeningAngle, firstXBinOpeningAngle, lastXBinOpeningAngle, "", "");} - if(plotMCPi0R == kTRUE){ histograms->AddHistogram("MC_Pi0_Secondaries_R" ,"" , nXBinsR, firstXBinR, lastXBinR, "", "");} - if(plotMCPi0ZR == kTRUE){ histograms->AddHistogram("MC_Pi0_Secondaries_ZR" ,"" , nXBinsZR, firstXBinZR, lastXBinZR, nYBinsZR, firstYBinZR, lastYBinZR, "", "");} - if(plotMCPi0XY == kTRUE){ histograms->AddHistogram("MC_Pi0_Secondaries_XY" ,"" , nXBinsXY, firstXBinXY, lastXBinXY, nYBinsXY, firstYBinXY, lastYBinXY, "", "");} - + if(plotMCPi0PtvsEtaWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Pi0_Pt_Eta_withinAcceptance" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, nXBinsEta, firstXBinEta, lastXBinEta, "", "");} + if(plotMCPi0PtvsRapidWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Pi0_Pt_Rapid_withinAcceptance" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, nXBinsRapid, firstXBinRapid, lastXBinRapid, "", "");} + if(plotMCPi0PtvsEtaConvGammaWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Pi0_Pt_Eta_ConvGamma_withinAcceptance" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, nXBinsEta, firstXBinEta, lastXBinEta, "", "");} + if(plotMCPi0PtvsRapidConvGammaWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Pi0_Pt_Rapid_ConvGamma_withinAcceptance" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, nXBinsRapid, firstXBinRapid, lastXBinRapid, "", "");} + + + if(plotMCPi0SecondaryEta == kTRUE){ histograms->AddHistogram("MC_Pi0_Secondaries_Eta" ,"" , nXBinsEta, firstXBinEta, lastXBinEta, "", "");} + if(plotMCPi0SecondaryRapid == kTRUE){ histograms->AddHistogram("MC_Pi0_Secondaries_Rapid" ,"" , nXBinsRapid, firstXBinRapid, lastXBinRapid, "", "");} + if(plotMCPi0SecondaryPhi == kTRUE){ histograms->AddHistogram("MC_Pi0_Secondaries_Phi" ,"" , nXBinsPhi, firstXBinPhi, lastXBinPhi, "", "");} + if(plotMCPi0SecondaryPt == kTRUE){ histograms->AddHistogram("MC_Pi0_Secondaries_Pt" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, "", "");} + if(plotMCPi0SecondaryEnergy == kTRUE){ histograms->AddHistogram("MC_Pi0_Secondaries_Energy" ,"" , nXBinsEnergy, firstXBinEnergy, lastXBinEnergy, "", "");} + if(plotMCPi0SecondaryMass == kTRUE){ histograms->AddHistogram("MC_Pi0_Secondaries_Mass" ,"" , nXBinsPi0Mass, firstXBinPi0Mass, lastXBinPi0Mass, "", "");} + if(plotMCPi0SecondaryOpeningAngle == kTRUE){ histograms->AddHistogram("MC_Pi0_Secondaries_GammaDaughter_OpeningAngle" ,"" , nXBinsOpeningAngle, firstXBinOpeningAngle, lastXBinOpeningAngle, "", "");} + if(plotMCPi0SecondaryR == kTRUE){ histograms->AddHistogram("MC_Pi0_Secondaries_R" ,"" , nXBinsR, firstXBinR, lastXBinR, "", "");} + if(plotMCPi0SecondaryZR == kTRUE){ histograms->AddHistogram("MC_Pi0_Secondaries_ZR" ,"" , nXBinsZR, firstXBinZR, lastXBinZR, nYBinsZR, firstYBinZR, lastYBinZR, "", "");} + if(plotMCPi0SecondaryXY == kTRUE){ histograms->AddHistogram("MC_Pi0_Secondaries_XY" ,"" , nXBinsXY, firstXBinXY, lastXBinXY, nYBinsXY, firstYBinXY, lastYBinXY, "", "");} + if(plotMCPi0SecondaryPtvsEtaWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Pi0_Secondaries_Pt_Eta_withinAcceptance" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, nXBinsEta, firstXBinEta, lastXBinEta, "", "");} + if(plotMCPi0SecondaryPtvsRapidWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Pi0_Secondaries_Pt_Rapid_withinAcceptance" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, nXBinsRapid, firstXBinRapid, lastXBinRapid, "", "");} + if(plotMCPi0SecondaryPtvsEtaConvGammaWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Pi0_Secondaries_Pt_Eta_ConvGamma_withinAcceptance" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, nXBinsEta, firstXBinEta, lastXBinEta, "", "");} + if(plotMCPi0SecondaryPtvsRapidConvGammaWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Pi0_Secondaries_Pt_Rapid_ConvGamma_withinAcceptance" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, nXBinsRapid, firstXBinRapid, lastXBinRapid, "", "");} + + + if(plotMCEtaEta == kTRUE){ histograms->AddHistogram("MC_Eta_Eta" ,"" , nXBinsEta, firstXBinEta, lastXBinEta, "", "");} + if(plotMCEtaRapid == kTRUE){ histograms->AddHistogram("MC_Eta_Rapid" ,"" , nXBinsRapid, firstXBinRapid, lastXBinRapid, "", "");} if(plotMCEtaPhi == kTRUE){ histograms->AddHistogram("MC_Eta_Phi" ,"" , nXBinsPhi, firstXBinPhi, lastXBinPhi, "", "");} if(plotMCEtaPt == kTRUE){ histograms->AddHistogram("MC_Eta_Pt" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, "", "");} if(plotMCEtaEnergy == kTRUE){ histograms->AddHistogram("MC_Eta_Energy" ,"" , nXBinsEnergy, firstXBinEnergy, lastXBinEnergy, "", "");} @@ -525,51 +674,89 @@ void ConfigGammaConversion(TString arguments){ if(plotMCEtaR == kTRUE){ histograms->AddHistogram("MC_Eta_R" ,"" , nXBinsR, firstXBinR, lastXBinR, "", "");} if(plotMCEtaZR == kTRUE){ histograms->AddHistogram("MC_Eta_ZR" ,"" , nXBinsZR, firstXBinZR, lastXBinZR, nYBinsZR, firstYBinZR, lastYBinZR, "", "");} if(plotMCEtaXY == kTRUE){ histograms->AddHistogram("MC_Eta_XY" ,"" , nXBinsXY, firstXBinXY, lastXBinXY, nYBinsXY, firstYBinXY, lastYBinXY, "", "");} - - // Histograms from esd tracks - if(plotESDEPR == kTRUE){ histograms->AddHistogram("ESD_EP_R" ,"" , nXBinsR, firstXBinR, lastXBinR, "", "");} - if(plotESDEPZR == kTRUE){ histograms->AddHistogram("ESD_EP_ZR" ,"" , nXBinsZR, firstXBinZR, lastXBinZR, nYBinsZR, firstYBinZR, lastYBinZR, "", "");} - if(plotESDEPXY == kTRUE){ histograms->AddHistogram("ESD_EP_XY" ,"" , nXBinsXY, firstXBinXY, lastXBinXY, nYBinsXY, firstYBinXY, lastYBinXY, "", "");} - if(plotESDEPOpeningAngle == kTRUE){ histograms->AddHistogram("ESD_EP_OpeningAngle" ,"" , nXBinsOpeningAngle, firstXBinOpeningAngle, lastXBinOpeningAngle, "", "");} - + if(plotMCEtaPtvsEtaWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Eta_Pt_Eta_withinAcceptance" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, nXBinsEta, firstXBinEta, lastXBinEta, "", "");} + if(plotMCEtaPtvsRapidWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Eta_Pt_Rapid_withinAcceptance" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, nXBinsRapid, firstXBinRapid, lastXBinRapid, "", "");} + if(plotMCEtaPtvsEtaConvGammaWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Eta_Pt_Eta_ConvGamma_withinAcceptance" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, nXBinsEta, firstXBinEta, lastXBinEta, "", "");} + if(plotMCEtaPtvsRapidConvGammaWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Eta_Pt_Rapid_ConvGamma_withinAcceptance" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, nXBinsRapid, firstXBinRapid, lastXBinRapid, "", "");} + + + // Histograms from esd tracks if(plotESDEEnergy == kTRUE){ histograms->AddHistogram("ESD_E_Energy" ,"" , nXBinsEnergy, firstXBinEnergy, lastXBinEnergy, "", "");} if(plotESDEPt == kTRUE){ histograms->AddHistogram("ESD_E_Pt" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, "", "");} if(plotESDEEta == kTRUE){ histograms->AddHistogram("ESD_E_Eta" ,"" , nXBinsEta, firstXBinEta, lastXBinEta, "", "");} if(plotESDEPhi == kTRUE){ histograms->AddHistogram("ESD_E_Phi" ,"" , nXBinsPhi, firstXBinPhi, lastXBinPhi, "", "");} - + if(plotESDPEnergy == kTRUE){ histograms->AddHistogram("ESD_P_Energy" ,"" , nXBinsEnergy, firstXBinEnergy, lastXBinEnergy, "", "");} if(plotESDPPt == kTRUE){ histograms->AddHistogram("ESD_P_Pt" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, "", "");} if(plotESDPEta == kTRUE){ histograms->AddHistogram("ESD_P_Eta" ,"" , nXBinsEta, firstXBinEta, lastXBinEta, "", "");} if(plotESDPPhi == kTRUE){ histograms->AddHistogram("ESD_P_Phi" ,"" , nXBinsPhi, firstXBinPhi, lastXBinPhi, "", "");} - - if(plotESDGammaEnergy == kTRUE){ histograms->AddHistogram("ESD_Gamma_Energy" ,"" , nXBinsEnergy, firstXBinEnergy, lastXBinEnergy, "", "");} - if(plotESDGammaPt == kTRUE){ histograms->AddHistogram("ESD_Gamma_Pt" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, "", "");} - if(plotESDGammaEta == kTRUE){ histograms->AddHistogram("ESD_Gamma_Eta" ,"" , nXBinsEta, firstXBinEta, lastXBinEta, "", "");} - if(plotESDGammaPhi == kTRUE){ histograms->AddHistogram("ESD_Gamma_Phi" ,"" , nXBinsPhi, firstXBinPhi, lastXBinPhi, "", "");} - - if(plotESDMatchGammaOpeningAngle == kTRUE){ histograms->AddHistogram("ESD_Match_Gamma_OpeningAngle" ,"" , nXBinsOpeningAngle, firstXBinOpeningAngle, lastXBinOpeningAngle, "", "");} - if(plotESDMatchGammaEnergy == kTRUE){ histograms->AddHistogram("ESD_Match_Gamma_Energy" ,"" , nXBinsEnergy, firstXBinEnergy, lastXBinEnergy, "", "");} - if(plotESDMatchGammaPt == kTRUE){ histograms->AddHistogram("ESD_Match_Gamma_Pt" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, "", "");} - if(plotESDMatchGammaEta == kTRUE){ histograms->AddHistogram("ESD_Match_Gamma_Eta" ,"" , nXBinsEta, firstXBinEta, lastXBinEta, "", "");} - if(plotESDMatchGammaPhi == kTRUE){ histograms->AddHistogram("ESD_Match_Gamma_Phi" ,"" , nXBinsPhi, firstXBinPhi, lastXBinPhi, "", "");} - if(plotESDMatchGammaMass == kTRUE){ histograms->AddHistogram("ESD_Match_Gamma_Mass" ,"" , nXBinsGammaMass, firstXBinGammaMass, lastXBinGammaMass, "", "");} - if(plotESDMatchGammaWidth == kTRUE){ histograms->AddHistogram("ESD_Match_Gamma_Width" ,"" , nXBinsGammaWidth, firstXBinGammaWidth, lastXBinGammaWidth, "", "");} - if(plotESDMatchGammaChi2 == kTRUE){ histograms->AddHistogram("ESD_Match_Gamma_Chi2" ,"" , nXBinsGammaChi2, firstXBinGammaChi2, lastXBinGammaChi2, "", "");} - if(plotESDMatchGammaNDF == kTRUE){ histograms->AddHistogram("ESD_Match_Gamma_NDF" ,"" , nXBinsGammaNDF, firstXBinGammaNDF, lastXBinGammaNDF, "", "");} - if(plotESDMatchGammaR == kTRUE){ histograms->AddHistogram("ESD_Match_Gamma_R" ,"" , nXBinsR, firstXBinR, lastXBinR, "", "");} - if(plotESDMatchGammaZR == kTRUE){ histograms->AddHistogram("ESD_Match_Gamma_ZR" ,"" , nXBinsZR, firstXBinZR, lastXBinZR, nYBinsZR, firstYBinZR, lastYBinZR, "", "");} - if(plotESDMatchGammaXY == kTRUE){ histograms->AddHistogram("ESD_Match_Gamma_XY" ,"" , nXBinsXY, firstXBinXY, lastXBinXY, nYBinsXY, firstYBinXY, lastYBinXY, "", "");} - - if(plotESDTwoGammaCombinationOpeningAngleGamma == kTRUE){ histograms->AddHistogram("ESD_TwoGammaCombination_GammaDaughter_OpeningAngle" ,"" , nXBinsOpeningAngle, firstXBinOpeningAngle, lastXBinOpeningAngle, "", "");} - if(plotESDTwoGammaCombinationEnergy == kTRUE){ histograms->AddHistogram("ESD_TwoGammaCombination_Energy" ,"" , nXBinsEnergy, firstXBinEnergy, lastXBinEnergy, "", "");} - if(plotESDTwoGammaCombinationPt == kTRUE){ histograms->AddHistogram("ESD_TwoGammaCombination_Pt" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, "", "");} - if(plotESDTwoGammaCombinationEta == kTRUE){ histograms->AddHistogram("ESD_TwoGammaCombination_Eta" ,"" , nXBinsEta, firstXBinEta, lastXBinEta, "", "");} - if(plotESDTwoGammaCombinationPhi == kTRUE){ histograms->AddHistogram("ESD_TwoGammaCombination_Phi" ,"" , nXBinsPhi, firstXBinPhi, lastXBinPhi, "", "");} - if(plotESDTwoGammaCombinationMass == kTRUE){ histograms->AddHistogram("ESD_TwoGammaCombination_Mass" ,"" , nXBinsPi0Mass, firstXBinPi0Mass, lastXBinPi0Mass, "", "");} - if(plotESDTwoGammaCombinationR == kTRUE){ histograms->AddHistogram("ESD_TwoGammaCombination_R" ,"" , nXBinsR, firstXBinR, lastXBinR, "", "");} - if(plotESDTwoGammaCombinationZR == kTRUE){ histograms->AddHistogram("ESD_TwoGammaCombination_ZR" ,"" , nXBinsZR, firstXBinZR, lastXBinZR, nYBinsZR, firstYBinZR, lastYBinZR, "", "");} - if(plotESDTwoGammaCombinationXY == kTRUE){ histograms->AddHistogram("ESD_TwoGammaCombination_XY" ,"" , nXBinsXY, firstXBinXY, lastXBinXY, nYBinsXY, firstYBinXY, lastYBinXY, "", "");} - + + if(plotESDConvGammaEnergy == kTRUE){ histograms->AddHistogram("ESD_ConvGamma_Energy" ,"" , nXBinsEnergy, firstXBinEnergy, lastXBinEnergy, "", "");} + if(plotESDConvGammaPt == kTRUE){ histograms->AddHistogram("ESD_ConvGamma_Pt" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, "", "");} + if(plotESDConvGammaEta == kTRUE){ histograms->AddHistogram("ESD_ConvGamma_Eta" ,"" , nXBinsEta, firstXBinEta, lastXBinEta, "", "");} + if(plotESDConvGammaPhi == kTRUE){ histograms->AddHistogram("ESD_ConvGamma_Phi" ,"" , nXBinsPhi, firstXBinPhi, lastXBinPhi, "", "");} + if(plotESDConvGammaMass == kTRUE){ histograms->AddHistogram("ESD_ConvGamma_Mass" ,"" , nXBinsGammaMass, firstXBinGammaMass, lastXBinGammaMass, "", "");} + if(plotESDConvGammaWidth == kTRUE){ histograms->AddHistogram("ESD_ConvGamma_Width" ,"" , nXBinsGammaWidth, firstXBinGammaWidth, lastXBinGammaWidth, "", "");} + if(plotESDConvGammaChi2 == kTRUE){ histograms->AddHistogram("ESD_ConvGamma_Chi2" ,"" , nXBinsGammaChi2, firstXBinGammaChi2, lastXBinGammaChi2, "", "");} + if(plotESDConvGammaNDF == kTRUE){ histograms->AddHistogram("ESD_ConvGamma_NDF" ,"" , nXBinsGammaNDF, firstXBinGammaNDF, lastXBinGammaNDF, "", "");} + if(plotESDConvGammaRapid == kTRUE){ histograms->AddHistogram("ESD_ConvGamma_Rapid" ,"" , nXBinsRapid, firstXBinRapid, lastXBinRapid, "", "");} + if(plotESDConvGammaPtvsEta == kTRUE){ histograms->AddHistogram("ESD_ConvGamma_Pt_Eta","", nXBinsPt, firstXBinPt, lastXBinPt,nXBinsEta, firstXBinEta, lastXBinEta,"","" );} + + if(plotESDConversionR == kTRUE){ histograms->AddHistogram("ESD_Conversion_R" ,"" , nXBinsR, firstXBinR, lastXBinR, "", "");} + if(plotESDConversionZR == kTRUE){ histograms->AddHistogram("ESD_Conversion_ZR" ,"" , nXBinsZR, firstXBinZR, lastXBinZR, nYBinsZR, firstYBinZR, lastYBinZR, "", "");} + if(plotESDConversionXY == kTRUE){ histograms->AddHistogram("ESD_Conversion_XY" ,"" , nXBinsXY, firstXBinXY, lastXBinXY, nYBinsXY, firstYBinXY, lastYBinXY, "", "");} + if(plotESDConversionOpeningAngle == kTRUE){ histograms->AddHistogram("ESD_Conversion_OpeningAngle" ,"" , nXBinsOpeningAngle, firstXBinOpeningAngle, lastXBinOpeningAngle, "", "");} + + + if(plotESDTrueConvGammaEnergy == kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_Energy" ,"" , nXBinsEnergy, firstXBinEnergy, lastXBinEnergy, "", "");} + if(plotESDTrueConvGammaPt == kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_Pt" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, "", "");} + if(plotESDTrueConvGammaEta == kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_Eta" ,"" , nXBinsEta, firstXBinEta, lastXBinEta, "", "");} + if(plotESDTrueConvGammaPhi == kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_Phi" ,"" , nXBinsPhi, firstXBinPhi, lastXBinPhi, "", "");} + if(plotESDTrueConvGammaMass == kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_Mass" ,"" , nXBinsGammaMass, firstXBinGammaMass, lastXBinGammaMass, "", "");} + if(plotESDTrueConvGammaWidth == kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_Width" ,"" , nXBinsGammaWidth, firstXBinGammaWidth, lastXBinGammaWidth, "", "");} + if(plotESDTrueConvGammaChi2 == kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_Chi2" ,"" , nXBinsGammaChi2, firstXBinGammaChi2, lastXBinGammaChi2, "", "");} + if(plotESDTrueConvGammaNDF == kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_NDF" ,"" , nXBinsGammaNDF, firstXBinGammaNDF, lastXBinGammaNDF, "", "");} + if(plotESDTrueConvGammaRapid == kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_Rapid" ,"" , nXBinsRapid, firstXBinRapid, lastXBinRapid, "", "");} + if(plotESDTrueConvGammaPtvsEta == kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_Pt_Eta" ,"" , nXBinsPt, firstXBinPt, lastXBinPt,nXBinsEta, firstXBinEta, lastXBinEta, "", "");} + + if(plotESDTrueConversionR == kTRUE){ histograms->AddHistogram("ESD_TrueConversion_R" ,"" , nXBinsR, firstXBinR, lastXBinR, "", "");} + if(plotESDTrueConversionZR == kTRUE){ histograms->AddHistogram("ESD_TrueConversion_ZR" ,"" , nXBinsZR, firstXBinZR, lastXBinZR, nYBinsZR, firstYBinZR, lastYBinZR, "", "");} + if(plotESDTrueConversionXY == kTRUE){ histograms->AddHistogram("ESD_TrueConversion_XY" ,"" , nXBinsXY, firstXBinXY, lastXBinXY, nYBinsXY, firstYBinXY, lastYBinXY, "", "");} + if(plotESDTrueConversionOpeningAngle == kTRUE){ histograms->AddHistogram("ESD_TrueConversion_OpeningAngle" ,"" , nXBinsOpeningAngle, firstXBinOpeningAngle, lastXBinOpeningAngle, "", "");} + + + + if(plotESDNoCutConvGammaEnergy == kTRUE){ histograms->AddHistogram("ESD_NoCutConvGamma_Energy" ,"" , nXBinsEnergy, firstXBinEnergy, lastXBinEnergy, "", "");} + if(plotESDNoCutConvGammaPt == kTRUE){ histograms->AddHistogram("ESD_NoCutConvGamma_Pt" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, "", "");} + if(plotESDNoCutConvGammaEta == kTRUE){ histograms->AddHistogram("ESD_NoCutConvGamma_Eta" ,"" , nXBinsEta, firstXBinEta, lastXBinEta, "", "");} + if(plotESDNoCutConvGammaPhi == kTRUE){ histograms->AddHistogram("ESD_NoCutConvGamma_Phi" ,"" , nXBinsPhi, firstXBinPhi, lastXBinPhi, "", "");} + if(plotESDNoCutConvGammaMass == kTRUE){ histograms->AddHistogram("ESD_NoCutConvGamma_Mass" ,"" , nXBinsGammaMass, firstXBinGammaMass, lastXBinGammaMass, "", "");} + if(plotESDNoCutConvGammaWidth == kTRUE){ histograms->AddHistogram("ESD_NoCutConvGamma_Width" ,"" , nXBinsGammaWidth, firstXBinGammaWidth, lastXBinGammaWidth, "", "");} + if(plotESDNoCutConvGammaChi2 == kTRUE){ histograms->AddHistogram("ESD_NoCutConvGamma_Chi2" ,"" , nXBinsGammaChi2, firstXBinGammaChi2, lastXBinGammaChi2, "", "");} + if(plotESDNoCutConvGammaNDF == kTRUE){ histograms->AddHistogram("ESD_NoCutConvGamma_NDF" ,"" , nXBinsGammaNDF, firstXBinGammaNDF, lastXBinGammaNDF, "", "");} + if(plotESDNoCutConvGammaRapid == kTRUE){ histograms->AddHistogram("ESD_NoCutConvGamma_Rapid" ,"" , nXBinsRapid, firstXBinRapid, lastXBinRapid, "", "");} + if(plotESDNoCutConvGammaPtvsEta == kTRUE){ histograms->AddHistogram("ESD_NoCutConvGamma_Pt_Eta" ,"" , nXBinsPt, firstXBinPt, lastXBinPt,nXBinsEta, firstXBinEta, lastXBinEta, "", "");} + + if(plotESDNoCutConversionR == kTRUE){ histograms->AddHistogram("ESD_NoCutConversion_R" ,"" , nXBinsR, firstXBinR, lastXBinR, "", "");} + if(plotESDNoCutConversionZR == kTRUE){ histograms->AddHistogram("ESD_NoCutConversion_ZR" ,"" , nXBinsZR, firstXBinZR, lastXBinZR, nYBinsZR, firstYBinZR, lastYBinZR, "", "");} + if(plotESDNoCutConversionXY == kTRUE){ histograms->AddHistogram("ESD_NoCutConversion_XY" ,"" , nXBinsXY, firstXBinXY, lastXBinXY, nYBinsXY, firstYBinXY, lastYBinXY, "", "");} + if(plotESDNoCutConversionOpeningAngle == kTRUE){ histograms->AddHistogram("ESD_NoCutConversion_OpeningAngle" ,"" , nXBinsOpeningAngle, firstXBinOpeningAngle, lastXBinOpeningAngle, "", "");} + + + + + if(plotESDMotherOpeningAngleGamma == kTRUE){ histograms->AddHistogram("ESD_Mother_GammaDaughter_OpeningAngle" ,"" , nXBinsOpeningAngle, firstXBinOpeningAngle, lastXBinOpeningAngle, "", "");} + if(plotESDMotherEnergy == kTRUE){ histograms->AddHistogram("ESD_Mother_Energy" ,"" , nXBinsEnergy, firstXBinEnergy, lastXBinEnergy, "", "");} + if(plotESDMotherPt == kTRUE){ histograms->AddHistogram("ESD_Mother_Pt" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, "", "");} + if(plotESDMotherEta == kTRUE){ histograms->AddHistogram("ESD_Mother_Eta" ,"" , nXBinsEta, firstXBinEta, lastXBinEta, "", "");} + if(plotESDMotherPhi == kTRUE){ histograms->AddHistogram("ESD_Mother_Phi" ,"" , nXBinsPhi, firstXBinPhi, lastXBinPhi, "", "");} + if(plotESDMotherMass == kTRUE){ histograms->AddHistogram("ESD_Mother_Mass" ,"" , nXBinsPi0Mass, firstXBinPi0Mass, lastXBinPi0Mass, "", "");} + if(plotESDMotherR == kTRUE){ histograms->AddHistogram("ESD_Mother_R" ,"" , nXBinsR, firstXBinR, lastXBinR, "", "");} + if(plotESDMotherZR == kTRUE){ histograms->AddHistogram("ESD_Mother_ZR" ,"" , nXBinsZR, firstXBinZR, lastXBinZR, nYBinsZR, firstYBinZR, lastYBinZR, "", "");} + if(plotESDMotherXY == kTRUE){ histograms->AddHistogram("ESD_Mother_XY" ,"" , nXBinsXY, firstXBinXY, lastXBinXY, nYBinsXY, firstYBinXY, lastYBinXY, "", "");} + if(plotESDMotherRapid == kTRUE){ histograms->AddHistogram("ESD_Mother_Rapid" ,"" , nXBinsRapid, firstXBinRapid, lastXBinRapid, "", "");} + + if(plotESDBackgroundOpeningAngleGamma == kTRUE){ histograms->AddHistogram("ESD_Background_GammaDaughter_OpeningAngle" ,"" , nXBinsOpeningAngle, firstXBinOpeningAngle, lastXBinOpeningAngle, "", "");} if(plotESDBackgroundEnergy == kTRUE){ histograms->AddHistogram("ESD_Background_Energy" ,"" , nXBinsEnergy, firstXBinEnergy, lastXBinEnergy, "", "");} if(plotESDBackgroundPt == kTRUE){ histograms->AddHistogram("ESD_Background_Pt" ,"" , nXBinsPt, firstXBinPt, lastXBinPt, "", "");} @@ -579,87 +766,115 @@ void ConfigGammaConversion(TString arguments){ if(plotESDBackgroundR == kTRUE){ histograms->AddHistogram("ESD_Background_R" ,"" , nXBinsR, firstXBinR, lastXBinR, "", "");} if(plotESDBackgroundZR == kTRUE){ histograms->AddHistogram("ESD_Background_ZR" ,"" , nXBinsZR, firstXBinZR, lastXBinZR, nYBinsZR, firstYBinZR, lastYBinZR, "", "");} if(plotESDBackgroundXY == kTRUE){ histograms->AddHistogram("ESD_Background_XY" ,"" , nXBinsXY, firstXBinXY, lastXBinXY, nYBinsXY, firstYBinXY, lastYBinXY, "", "");} + if(plotESDBackgroundRapid == kTRUE){ histograms->AddHistogram("ESD_Background_Rapid" ,"" , nXBinsRapid, firstXBinRapid, lastXBinRapid, "", "");} + if(plotMapping == kTRUE){ histograms->InitializeMappingValues(nPhiIndex,nRIndex,nXBinsMapping,minRadius,maxRadius,nYBinsMapping,minPhi,maxPhi); histograms->AddMappingHistograms(nPhiIndex,nRIndex,nXBinsMapping,minRadius,maxRadius,nYBinsMapping,minPhi,maxPhi); } - + if(plotResolutiondPt == kTRUE){histograms->AddHistogram("Resolution_dPt" ,"" , nXBinsResdPt, firstXBinResdPt, lastXBinResdPt, nYBinsResdPt, firstYBinResdPt, lastYBinResdPt, "", "");} if(plotResolutiondR == kTRUE){histograms->AddHistogram("Resolution_dR" ,"" , nXBinsResdR, firstXBinResdR, lastXBinResdR, nYBinsResdR, firstYBinResdR, lastYBinResdR, "", "");} if(plotResolutiondZ == kTRUE){histograms->AddHistogram("Resolution_dZ" ,"" , nXBinsResdZ, firstXBinResdZ, lastXBinResdZ, nYBinsResdZ, firstYBinResdZ, lastYBinResdZ, "", "");} - + if(plotResolutiondRdPt == kTRUE){histograms->AddHistogram("Resolution_dR_dPt" ,"" , nXBinsResdRdPt, firstXBinResdRdPt, lastXBinResdRdPt, nYBinsResdRdPt, firstYBinResdRdPt, lastYBinResdRdPt, "", "");} - + if(plotResolutionMCPt == kTRUE){histograms->AddHistogram("Resolution_MC_Pt" ,"" , nXBinsResPt, firstXBinResPt, lastXBinResPt,"","");} if(plotResolutionMCR == kTRUE){histograms->AddHistogram("Resolution_MC_R" ,"" , nXBinsResR, firstXBinResR, lastXBinResR,"","");} if(plotResolutionMCZ == kTRUE){histograms->AddHistogram("Resolution_MC_Z" ,"" , nXBinsResZ, firstXBinResZ, lastXBinResZ,"","");} - + if(plotResolutionESDPt == kTRUE){histograms->AddHistogram("Resolution_ESD_Pt" ,"" , nXBinsResPt, firstXBinResPt, lastXBinResPt,"","");} if(plotResolutionESDR == kTRUE){histograms->AddHistogram("Resolution_ESD_R" ,"" , nXBinsResR, firstXBinResR, lastXBinResR,"","");} if(plotResolutionESDZ == kTRUE){histograms->AddHistogram("Resolution_ESD_Z" ,"" , nXBinsResZ, firstXBinResZ, lastXBinResZ,"","");} - - if(plotNumberOfV0s == kTRUE){histograms->AddHistogram("NumberOfV0s","Number of v0s",100, 0, 100,"","");} - if(plotNumberOfSurvivingV0s == kTRUE){histograms->AddHistogram("NumberOfSurvivingV0s","Number of surviving v0s",100, 0, 100,"","");} - + + if(plotESDNumberOfV0s == kTRUE){histograms->AddHistogram("ESD_NumberOfV0s","Number of v0s",100, 0, 100,"","");} + if(plotESDNumberOfSurvivingV0s == kTRUE){histograms->AddHistogram("ESD_NumberOfSurvivingV0s","Number of surviving v0s",100, 0, 100,"","");} + // debug histograms - if(plotV0MassDebugCut1 == kTRUE){histograms->AddHistogram("V0MassDebugCut1" ,"debug1" , nXBinsGammaMass, firstXBinGammaMass, lastXBinGammaMass,"","");} - if(plotV0MassDebugCut2 == kTRUE){histograms->AddHistogram("V0MassDebugCut2" ,"debug2" , nXBinsGammaMass, firstXBinGammaMass, lastXBinGammaMass,"","");} - if(plotV0MassDebugCut3 == kTRUE){histograms->AddHistogram("V0MassDebugCut3" ,"debug3" , nXBinsGammaMass, firstXBinGammaMass, lastXBinGammaMass,"","");} - if(plotV0MassDebugCut4 == kTRUE){histograms->AddHistogram("V0MassDebugCut4" ,"debug4" , nXBinsGammaMass, firstXBinGammaMass, lastXBinGammaMass,"","");} - if(plotV0MassDebugCut5 == kTRUE){histograms->AddHistogram("V0MassDebugCut5" ,"debug5" , nXBinsGammaMass, firstXBinGammaMass, lastXBinGammaMass,"","");} - if(plotV0MassDebugCut6 == kTRUE){histograms->AddHistogram("V0MassDebugCut6" ,"debug6" , nXBinsGammaMass, firstXBinGammaMass, lastXBinGammaMass,"","");} - if(plotV0MassDebugCut7 == kTRUE){histograms->AddHistogram("V0MassDebugCut7" ,"debug7" , nXBinsGammaMass, firstXBinGammaMass, lastXBinGammaMass,"","");} - if(plotV0MassDebugCut8 == kTRUE){histograms->AddHistogram("V0MassDebugCut8" ,"debug8" , nXBinsGammaMass, firstXBinGammaMass, lastXBinGammaMass,"","");} - - - if(plotPi0Spectra == kTRUE){histograms->AddHistogram("InvMass_vs_Pt_Spectra" ,"Invariant Mass vs Pt" , nXBinsSpectra, firstXBinSpectra, lastXBinSpectra,nYBinsSpectra, firstYBinSpectra, lastYBinSpectra,"InvMass [GeV]","Pt [GeV]");} - - if(plotPi0Spectra == kTRUE && calculateBackground == kTRUE){histograms->AddHistogram("Background_InvMass_vs_Pt_Spectra" ,"Background Invariant Mass vs Pt" , nXBinsSpectra, firstXBinSpectra, lastXBinSpectra,nYBinsSpectra, firstYBinSpectra, lastYBinSpectra,"InvMass [GeV]","Pt [GeV]");} - - - + if(plotESDCutGetOnFly == kTRUE){histograms->AddHistogram("ESD_CutGetOnFly_InvMass" ,"Not GetOnFly" , nXBinsGammaMass, firstXBinGammaMass, lastXBinGammaMass,"","");} + if(plotESDCutNContributors == kTRUE){histograms->AddHistogram("ESD_CutNContributors_InvMass" ,"NContributors <= 0" , nXBinsGammaMass, firstXBinGammaMass, lastXBinGammaMass,"","");} + if(plotESDCutLikeSign == kTRUE){histograms->AddHistogram("ESD_CutLikeSign_InvMass" ,"LikeSign" , nXBinsGammaMass, firstXBinGammaMass, lastXBinGammaMass,"","");} + if(plotESDCutRefit == kTRUE){histograms->AddHistogram("ESD_CutRefit_InvMass" ,"No TPC refit" , nXBinsGammaMass, firstXBinGammaMass, lastXBinGammaMass,"","");} + if(plotESDCutKink == kTRUE){histograms->AddHistogram("ESD_CutKink_InvMass" ,"Kinks" , nXBinsGammaMass, firstXBinGammaMass, lastXBinGammaMass,"","");} + if(plotESDCutPIDProb == kTRUE){histograms->AddHistogram("ESD_CutPIDProb_InvMass" ,"wrong TPC PID" , nXBinsGammaMass, firstXBinGammaMass, lastXBinGammaMass,"","");} + if(plotESDCutR == kTRUE){histograms->AddHistogram("ESD_CutR_InvMass" ,"Above RMax" , nXBinsGammaMass, firstXBinGammaMass, lastXBinGammaMass,"","");} + if(plotESDCutNDF == kTRUE){histograms->AddHistogram("ESD_CutNDF_InvMass" ,"NDF <= 0" , nXBinsGammaMass, firstXBinGammaMass, lastXBinGammaMass,"","");} + if(plotESDCutChi2 == kTRUE){histograms->AddHistogram("ESD_CutChi2_InvMass" ,"#chi^{2} > Max" , nXBinsGammaMass, firstXBinGammaMass, lastXBinGammaMass,"","");} + if(plotESDCutEta == kTRUE){histograms->AddHistogram("ESD_CutEta_InvMass" ,"Above #eta max" , nXBinsGammaMass, firstXBinGammaMass, lastXBinGammaMass,"","");} + if(plotESDCutPt == kTRUE){histograms->AddHistogram("ESD_CutPt_InvMass" ,"Below p_{t} min" , nXBinsGammaMass, firstXBinGammaMass, lastXBinGammaMass,"","");} + if(plotESDCutLine == kTRUE){histograms->AddHistogram("ESD_CutLine_InvMass" ,"Out of reconstruction area" , nXBinsGammaMass, firstXBinGammaMass, lastXBinGammaMass,"","");} + if(plotESDTrueConvGammaTrackLength == kTRUE){histograms->AddHistogram("ESD_TrueConvGamma_TrackLength","Track length of TrueConvGamma",nXBinsTrackLength,firstXBinTrackLength,lastXBinTrackLength,"","");} + if(plotESDTrueConvGammaTrackLengthVSInvMass == kTRUE){histograms->AddHistogram("ESD_TrueConvGamma_TrackLengthVSInvMass","Track length of TrueConvGamma vs Inv mass",nXBinsTrackLength,firstXBinTrackLength,lastXBinTrackLength,nXBinsPt, firstXBinPt, lastXBinPt,"","");} + + + if(plotPi0Spectra == kTRUE){ +histograms->AddHistogram("ESD_Mother_InvMass_vs_Pt" ,"Invariant Mass vs Pt" , nXBinsSpectra, firstXBinSpectra, lastXBinSpectra,nYBinsSpectra, firstYBinSpectra, lastYBinSpectra,"InvMass [GeV]","Pt [GeV]"); +} + if(plotPi0Spectra == kTRUE && calculateBackground == kTRUE){ +histograms->AddHistogram("ESD_Background_InvMass_vs_Pt" ,"Background Invariant Mass vs Pt" , nXBinsSpectra, firstXBinSpectra, lastXBinSpectra,nYBinsSpectra, firstYBinSpectra, lastYBinSpectra,"InvMass [GeV]","Pt [GeV]"); +} + + + //------------------------------ end Creating the histograms ----------------------------- - + // Create the Analysis manager AliAnalysisManager *mgr = new AliAnalysisManager("My Manager", "My Analysis"); - + // Define Input Event Handler AliESDInputHandler* inpHandler = new AliESDInputHandler(); - + // Define Output Event Handler AliAODHandler* aodHandler = new AliAODHandler(); - aodHandler->SetOutputFileName("aodAliGammaConversion.root"); - + TString fileOutAOD = "AOD_"+ outputFileName + outputFileAppendix + ".root"; + aodHandler->SetOutputFileName(fileOutAOD); + // aodHandler->SetOutputFileName("aodAliGammaConversion.root"); + // Define MC Truth Event Handler AliMCEventHandler* mcHandler = new AliMCEventHandler(); - + // Add Handlers to the Task Manager mgr->SetInputEventHandler (inpHandler); mgr->SetOutputEventHandler (aodHandler); mgr->SetMCtruthEventHandler(mcHandler); - + // Be sure you are told what you are doing - mgr->SetDebugLevel(10); - + // mgr->SetDebugLevel(10); + // Declare Common Input Tchain - AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer(); - + AliAnalysisDataContainer *cinput1 = NULL; + if(usePWG4PartCorr){ + cinput1 = mgr->CreateContainer("Chain",TChain::Class(),AliAnalysisManager::kInputContainer); + } + else{ + cinput1 = mgr->GetCommonInputContainer(); + } + // Common Output Tree in common ‘default’ output file - AliAnalysisDataContainer *coutput1 = mgr->GetCommonOutputContainer(); - + AliAnalysisDataContainer *coutput1 = NULL; + if(usePWG4PartCorr){ + coutput1 = mgr->CreateContainer("tree",TTree::Class(),AliAnalysisManager::kOutputContainer, "default"); + } + else{ + coutput1 = mgr->GetCommonOutputContainer(); + } + // Private output objects - outputFileName.ReplaceAll(".root",""); - outputFileAppendix..ReplaceAll(".root",""); + if(outputFileName.Contains(".root")){ + outputFileName.ReplaceAll(".root",""); + } + if(outputFileAppendix.Contains(".root")){ + outputFileAppendix.ReplaceAll(".root",""); + } TString fileOut = outputFileName + outputFileAppendix + ".root"; - + AliAnalysisDataContainer *coutput2 = mgr->CreateContainer("histogramsAliGammaConversion", TList::Class(),AliAnalysisManager::kOutputContainer, fileOut); - - - + + //------------------------ END: Define input/output handlers --------------------------------------------------- - - + + //check for errors in the specified data if(useKFParticle == kTRUE && useESDTrack == kTRUE){ //Print warning, cannot use both @@ -667,8 +882,8 @@ void ConfigGammaConversion(TString arguments){ if(useKFParticle == kFALSE && useESDTrack == kFALSE){ //Print warning, one have to be specified } - - + + //Create the V0Reader AliV0Reader * v0Reader = new AliV0Reader(); if(useKFParticle){ @@ -682,6 +897,8 @@ void ConfigGammaConversion(TString arguments){ v0Reader->SetMaxRCut(maxRCut); v0Reader->SetEtaCut(etaCut); v0Reader->SetPtCut(ptCut); + v0Reader->SetLineCutZRSlope(LineCutZRSlope); + v0Reader->SetLineCutZValue(LineCutZValue); v0Reader->SetChi2CutConversion(chi2CutConversion); v0Reader->SetChi2CutMeson(chi2CutMeson); v0Reader->SetPIDProbability(probElectron); @@ -691,56 +908,58 @@ void ConfigGammaConversion(TString arguments){ v0Reader->SetSigmaMass(sigmaCutGammaMass); v0Reader->SetUseImprovedVertex(useImprovedVertex); v0Reader->SetDoMCTruth(doMCTruth); - + // Create the GammaConversionTask AliAnalysisTaskGammaConversion *gammaconversion = new AliAnalysisTaskGammaConversion("GammaConversionTask"); gammaconversion->SetDebugLevel(10); - + gammaconversion->SetWriteNtuple(writeNtuple); - + gammaconversion->SetV0Reader(v0Reader); gammaconversion->SetCalculateBackground(calculateBackground); gammaconversion->Init(); - + gammaconversion->SetElectronMass(electronMass); gammaconversion->SetGammaMass(gammaMass); gammaconversion->SetPi0Mass(pi0Mass); gammaconversion->SetEtaMass(etaMass); - + gammaconversion->SetGammaWidth(gammaWidth); gammaconversion->SetPi0Width(pi0Width); gammaconversion->SetEtaWidth(etaWidth); + gammaconversion->SetMinOpeningAngleGhostCut(minOpeningAngleGhostCut); + // define the width constraint used by KF particle. Double_t gammaWidth = 0.01; Double_t pi0Width = 0.01; Double_t etaWidth = 0.01; - + gammaconversion->SetHistograms(histograms); v0Reader->SetHistograms(histograms);// also give the pointer to the v0reader, for debugging cuts - + gammaconversion->SetDoMCTruth(doMCTruth); - - + + // Add task to the manager mgr->AddTask(gammaconversion); - + // Connect I/O to the task mgr->ConnectInput (gammaconversion, 0, cinput1); mgr->ConnectOutput(gammaconversion, 0, coutput1); mgr->ConnectOutput(gammaconversion, 1, coutput2); - + if(dataList.IsNull()){ cout<<"Data list is not set, aborting."<InitAnalysis(); - + mgr->PrintStatus(); - + mgr->StartAnalysis("local",chain); } @@ -750,7 +969,7 @@ void build() { gSystem->Load("libTree.so"); gSystem->Load("libGeom"); // gSystem->Load("libANALYSISalice"); - + //// //Setting up ESD.par// //// @@ -758,7 +977,7 @@ void build() { setupPar("ESD"); gSystem->Load("libVMC.so"); gSystem->Load("libESD.so"); - + //// //// //Setting up STEERBase.par// @@ -766,33 +985,33 @@ void build() { cout<<"compiling STEERBase"<Load("libSTEERBase.so"); - + //// //Setting up AOD.par// //// cout<<"compiling AOD"<Load("libAOD.so"); - + //// //Setting up ANALYSIS.par// //// cout<<"compiling ANALYSIS"<Load("libANALYSIS.so"); - + //// //Setting up ANALYSISalice.par// //// cout<<"compiling ANALUSISalice"<Load("libANALYSISalice.so"); - + //// //Setting up PWG4Gamma.par// //// // cout<<"compiling GammaConv"<ProcessLine(processline); const char* ocwd = gSystem->WorkingDirectory(); gSystem->ChangeDirectory(pararchivename); - + // check for BUILD.sh and execute if (!gSystem->AccessPathName("PROOF-INF/BUILD.sh")) { printf("*******************************\n"); printf("*** Building PAR archive ***\n"); printf("*******************************\n"); - + if (gSystem->Exec("PROOF-INF/BUILD.sh")) { - Error("runAnalysis","Cannot Build the PAR Archive! - Abort!"); - return -1; + Error("runAnalysis","Cannot Build the PAR Archive! - Abort!"); + return -1; } } // check for SETUP.C and execute @@ -834,7 +1053,7 @@ Int_t setupPar(const char* pararchivename) { printf("*******************************\n"); gROOT->Macro("PROOF-INF/SETUP.C"); } - + gSystem->ChangeDirectory("../"); } return 1;