#include "AliLog.h"
#include "AliESDtrackCuts.h"
#include "TNtuple.h"
+#include "AliCFManager.h" // for CF
+#include "AliCFContainer.h" // for CF
class AliKFVertex;
class AliAODHandler;
AliAnalysisTaskSE(),
fV0Reader(NULL),
fStack(NULL),
+ fMCTruth(NULL), // for CF
+ fMCEvent(NULL), // for CF
fESDEvent(NULL),
fOutputContainer(NULL),
+ fCFManager(0x0), // for CF
fHistograms(NULL),
fDoMCTruth(kFALSE),
fDoNeutralMeson(kFALSE),
fLeadingChargedIndex(-1),
fAODBranch(NULL),
fAODBranchName("GammaConv")//,
-// fAODObjects(NULL)
+ // fAODObjects(NULL)
{
// Default constructor
// Common I/O in slot 0
// Your private output
DefineOutput(1, TList::Class());
-
+
// Define standard ESD track cuts for Gamma-hadron correlation
SetESDtrackCuts();
}
AliAnalysisTaskSE(name),
fV0Reader(NULL),
fStack(NULL),
+ fMCTruth(NULL), // for CF
+ fMCEvent(NULL), // for CF
fESDEvent(NULL),
fOutputContainer(0x0),
+ fCFManager(0x0), // for CF
fHistograms(NULL),
fDoMCTruth(kFALSE),
fDoNeutralMeson(kFALSE),
// Your private output
DefineOutput(1, TList::Class());
-
+ DefineOutput(2, AliCFContainer::Class()); // for CF
+
+
// Define standard ESD track cuts for Gamma-hadron correlation
SetESDtrackCuts();
}
if(fV0Reader){
delete fV0Reader;
}
+
+ // for CF
+ if(fCFManager){
+ delete fCFManager;
+ }
+
if (fAODBranch) {
fAODBranch->Clear();
delete fAODBranch ;
void AliAnalysisTaskGammaConversion::SetESDtrackCuts()
{
// SetESDtrackCuts
-
+
fEsdTrackCuts = new AliESDtrackCuts("AliESDtrackCuts");
-//standard cuts from:
-//http://aliceinfo.cern.ch/alicvs/viewvc/PWG0/dNdEta/CreateCuts.C?revision=1.4&view=markup
-//fEsdTrackCuts->SetMinNClustersTPC(50);
-//fEsdTrackCuts->SetMaxChi2PerClusterTPC(3.5);
-//fEsdTrackCuts->SetMaxCovDiagonalElements(2,2,0.5,0.5,2);
+ //standard cuts from:
+ //http://aliceinfo.cern.ch/alicvs/viewvc/PWG0/dNdEta/CreateCuts.C?revision=1.4&view=markup
+ //fEsdTrackCuts->SetMinNClustersTPC(50);
+ //fEsdTrackCuts->SetMaxChi2PerClusterTPC(3.5);
+ //fEsdTrackCuts->SetMaxCovDiagonalElements(2,2,0.5,0.5,2);
fEsdTrackCuts->SetRequireTPCRefit(kTRUE);
fEsdTrackCuts->SetRequireITSRefit(kTRUE);
fEsdTrackCuts->SetMaxNsigmaToVertex(3);
fEsdTrackCuts->SetRequireSigmaToVertex(kTRUE);
// fEsdTrackCuts->SetAcceptKinkDaughters(kFALSE);
-
+
}
void AliAnalysisTaskGammaConversion::Exec(Option_t */*option*/)
//Each event needs an empty branch
fAODBranch->Clear();
-
+
if(fKFReconstructedGammasTClone == NULL){
fKFReconstructedGammasTClone = new TClonesArray("AliKFParticle",0);
}
if(fChargedParticles == NULL){
fChargedParticles = new TClonesArray("AliESDtrack",0);
}
-
+
//clear TClones
fKFReconstructedGammasTClone->Clear();
fCurrentEventPosElectronTClone->Clear();
fKFReconstructedGammasCutTClone->Clear();
fPreviousEventTLVNegElectronTClone->Clear();
fPreviousEventTLVPosElectronTClone->Clear();
-
+
//clear vectors
// fKFReconstructedGammas.clear();
fElectronv1.clear();
fChargedParticles->Clear();
fChargedParticlesId.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();
-
+
//Fill Gamma AOD
FillAODWithConversionGammas() ;
-
+
//calculate background if flag is set
if(fCalculateBackground){
CalculateBackground();
}
-
-
-
-
+
+
+
+
// Process reconstructed gammas
if(fDoNeutralMeson == kTRUE){
- ProcessGammasForNeutralMesonAnalysis();
+ ProcessGammasForNeutralMesonAnalysis();
}
-
+
CheckV0Efficiency();
-
+
//Process reconstructed gammas electrons for Chi_c Analysis
if(fDoChic == kTRUE){
ProcessGammaElectronsForChicAnalysis();
if(fDoJet == kTRUE){
ProcessGammasForGammaJetAnalysis();
}
-
+
PostData(1, fOutputContainer);
+ PostData(2, fCFManager->GetParticleContainer()); // for CF
}
// see header file for documentation
fStack = fV0Reader->GetMCStack();
-
+ fMCTruth = fV0Reader->GetMCTruth(); // for CF
+ fMCEvent = fV0Reader->GetMCEvent(); // for CF
+
+
+ // for CF
+ if(!fMCEvent) cout << "NO MC INFO FOUND" << endl;
+ fCFManager->SetEventInfo(fMCEvent);
+ Double_t containerInput[3];
+ // end for CF
+
+
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);
//print warning here
continue;
}
-
+
+
+
+
///////////////////////Begin Chic Analysis/////////////////////////////
-
-
+
+
if(particle->GetPdgCode() == 443){//Is JPsi
-
+
if(particle->GetNDaughters()==2){
if(TMath::Abs(fStack->Particle(particle->GetFirstDaughter())->GetPdgCode()) == 11 &&
TMath::Abs(fStack->Particle(particle->GetLastDaughter())->GetPdgCode()) == 11){
TParticle* daug1 = fStack->Particle(particle->GetLastDaughter());
if(TMath::Abs(daug0->Eta()) < 0.9 && TMath::Abs(daug1->Eta()) < 0.9)
fHistograms->FillTable("Table_Electrons",3);//e+ e- from J/Psi inside acceptance
-
+
if( TMath::Abs(daug0->Eta()) < 0.9){
if(daug0->GetPdgCode() == -11)
fHistograms->FillTable("Table_Electrons",1);//e+ from J/Psi inside acceptance
else
fHistograms->FillTable("Table_Electrons",2);//e- from J/Psi inside acceptance
-
+
}
if(TMath::Abs(daug1->Eta()) < 0.9){
if(daug1->GetPdgCode() == -11)
if( particle->GetNDaughters() == 2){
TParticle* daug0 = fStack->Particle(particle->GetFirstDaughter());
TParticle* daug1 = fStack->Particle(particle->GetLastDaughter());
-
+
if( (daug0->GetPdgCode() == 443 || daug0->GetPdgCode() == 22) && (daug1->GetPdgCode() == 443 || daug1->GetPdgCode() == 22) ){
if( daug0->GetPdgCode() == 443){
TParticle* daugE0 = fStack->Particle(daug0->GetFirstDaughter());
TParticle* daugE1 = fStack->Particle(daug0->GetLastDaughter());
if( TMath::Abs(daug1->Eta()) < 1.2 && TMath::Abs(daugE0->Eta()) < 0.9 && TMath::Abs(daugE1->Eta()) < 0.9 )
fHistograms->FillTable("Table_Electrons",18);
-
+
}//if
else if (daug1->GetPdgCode() == 443){
TParticle* daugE0 = fStack->Particle(daug1->GetFirstDaughter());
}//gamma o Jpsi
}//GetNDaughters
}
-
-
+
+
/////////////////////End Chic Analysis////////////////////////////
-
-
+
+
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->GetMother(0) >-1 && fStack->Particle(particle->GetMother(0))->GetPdgCode() == 22){
continue; // no photon as mothers!
}
-
+
if(particle->GetMother(0) >= fStack->GetNprimary()){
continue; // the gamma has a mother, and it is not a primary 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);
+ // for CF
+ containerInput[0] = particle->Pt();
+ containerInput[1] = particle->Eta();
+ containerInput[2] = fStack->Particle(particle->GetMother(0))->GetMass();
+ fCFManager->GetParticleContainer()->Fill(containerInput,kStepGenerated); // generated gamma
if(particle->GetMother(0) < 0){ // direct gamma
fHistograms->FillHistogram("MC_allDirectGamma_Energy",particle->Energy());
fHistograms->FillHistogram("MC_allDirectGamma_Rapid", rapidity);
}
-
// looking for conversion (electron + positron from pairbuilding (= 5) )
TParticle* ePos = NULL;
TParticle* eNeg = NULL;
if(ePos->Pt()<fV0Reader->GetPtCut() || eNeg->Pt()<fV0Reader->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()) > 240){
+
+ if(TMath::Abs(ePos->Vz()) > fV0Reader->GetMaxZCut()){
continue; // outside material
}
+
if((TMath::Abs(ePos->Vz()) * fV0Reader->GetLineCutZRSlope()) - fV0Reader->GetLineCutZValue() > ePos->R()){
continue; // line cut to exclude regions where we do not reconstruct
}
+
+ // for CF
+ fCFManager->GetParticleContainer()->Fill(containerInput,kStepReconstructable); // reconstructable gamma
+
fHistograms->FillHistogram("MC_ConvGamma_Energy", particle->Energy());
fHistograms->FillHistogram("MC_ConvGamma_Pt", particle->Pt());
fHistograms->FillHistogram("MC_ConvGamma_Eta", particle->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());
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());
} // 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);
- }
+ fStack->Particle(particle->GetMother(0))->GetPdgCode()==20443 ||//psi2S
+ fStack->Particle(particle->GetMother(0))->GetPdgCode()==445 //chic2
+ ){
+ fMCGammaChic.push_back(particle);
+ }
*/
} // end if mother exits
} // end if particle is a photon
}
}
-
+
if(particle->GetPdgCode()==111){ //Pi0
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(gammaEtaCut && gammaRCut){
// 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_Eta_XY", particle->Vx(), particle->Vy());//only fill from one daughter to avoid multiple filling
if(gammaEtaCut && gammaRCut){
- // if(TMath::Abs(daughter0->Eta()) <= fV0Reader->GetEtaCut() && TMath::Abs(daughter1->Eta()) <= fV0Reader->GetEtaCut() ){
+ // 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_Mother_Rapid", rapidity);
fHistograms->FillHistogram("MC_Mother_Phi",tmpPhi);
fHistograms->FillHistogram("MC_Mother_InvMass_vs_Pt",particle->GetMass(),particle->Pt());
-
+
if(gammaEtaCut && gammaRCut){
- // if(TMath::Abs(daughter0->Eta()) <= fV0Reader->GetEtaCut() && TMath::Abs(daughter1->Eta()) <= fV0Reader->GetEtaCut() ){
+ // 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());
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 passed R and eta cut
-
+
} // 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(){
//Fills the ntuple with the different values
-
+
if(fGammaNtuple == NULL){
return;
}
void AliAnalysisTaskGammaConversion::ProcessV0sNoCut(){
// Process all the V0's without applying any cuts to it
-
+
Int_t numberOfV0s = fV0Reader->GetNumberOfV0s();
for(Int_t i=0;i<numberOfV0s;i++){
/*AliESDv0 * cV0 = */fV0Reader->GetV0(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_NDF", fV0Reader->GetMotherCandidateNDF());
fHistograms->FillHistogram("ESD_NoCutConvGamma_Rapid", fV0Reader->GetMotherCandidateRapidity());
fHistograms->FillHistogram("ESD_NoCutConvGamma_Pt_Eta", fV0Reader->GetMotherCandidatePt(),fV0Reader->GetMotherCandidateEta());
-
+
fHistograms->FillHistogram("ESD_NoCutConvGamma_Pt_Chi2", fV0Reader->GetMotherCandidatePt(), fV0Reader->GetMotherCandidateChi2());
fHistograms->FillHistogram("ESD_NoCutConvGamma_Eta_Chi2", fV0Reader->GetMotherCandidateEta(), fV0Reader->GetMotherCandidateChi2());
fHistograms->FillHistogram("ESD_NoCutConvGamma_MC_Pt_Eta", fV0Reader->GetMotherMCParticle()->Pt(),fV0Reader->GetMotherMCParticle()->Eta());
fHistograms->FillHistogram("ESD_NoCutConversion_MC_ZR", negativeMC->Vz(),negativeMC->R());
fHistograms->FillHistogram("ESD_NoCutConversion_MC_XY", negativeMC->Vx(),negativeMC->Vy());
-
-
}
}
}
fHistograms->FillHistogram("ESD_ConvGamma_Eta_Chi2", fV0Reader->GetMotherCandidateEta(), fV0Reader->GetMotherCandidateChi2());
-
// begin mapping
Int_t rBin = fHistograms->GetRBin(fV0Reader->GetXYRadius());
Int_t phiBin = fHistograms->GetPhiBin(fV0Reader->GetNegativeTrackPhi());
// end mapping
new((*fKFReconstructedGammasTClone)[fKFReconstructedGammasTClone->GetEntriesFast()]) AliKFParticle(*fV0Reader->GetMotherCandidateKFCombination());
-
+
// fKFReconstructedGammas.push_back(*fV0Reader->GetMotherCandidateKFCombination());
fElectronv1.push_back(fV0Reader->GetCurrentV0()->GetPindex());
fElectronv2.push_back(fV0Reader->GetCurrentV0()->GetNindex());
-
+
//----------------------------------- checking for "real" conversions (MC match) --------------------------------------
if(fDoMCTruth){
TParticle * negativeMC = (TParticle*)fV0Reader->GetNegativeMCParticle();
// TParticle * positiveMC = (TParticle*)fV0Reader->GetPositiveMCParticle(); // not used any longer
-
+
if(fV0Reader->GetMotherMCParticle()->GetPdgCode() == 22){
fHistograms->FillHistogram("ESD_TrueConvGamma_Pt", fV0Reader->GetMotherCandidatePt());
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_TrueConvGamma_Pt_Chi2", fV0Reader->GetMotherCandidatePt(), fV0Reader->GetMotherCandidateChi2());
fHistograms->FillHistogram("ESD_TrueConvGamma_Eta_Chi2", fV0Reader->GetMotherCandidateEta(), fV0Reader->GetMotherCandidateChi2());
-
+
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());
-
+
//store MCTruth properties
fHistograms->FillHistogram("ESD_TrueConvGamma_MC_Pt_Eta", fV0Reader->GetMotherMCParticle()->Pt(),fV0Reader->GetMotherMCParticle()->Eta());
fHistograms->FillHistogram("ESD_TrueConversion_MC_ZR", negativeMC->Vz(),negativeMC->R());
fHistograms->FillHistogram("ESD_TrueConversion_MC_XY", negativeMC->Vx(),negativeMC->Vy());
-
+
//resolution
Double_t mcpt = fV0Reader->GetMotherMCParticle()->Pt();
Double_t esdpt = fV0Reader->GetMotherCandidatePt();
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());
}//while(fV0Reader->NextV0)
fHistograms->FillHistogram("ESD_NumberOfSurvivingV0s", nSurvivingV0s);
fHistograms->FillHistogram("ESD_NumberOfV0s", fV0Reader->GetNumberOfV0s());
-
- //cout << "nearly at the end of doMCTruth" << endl;
-
}
void AliAnalysisTaskGammaConversion::FillAODWithConversionGammas(){
// Fill AOD with reconstructed Gamma
-
+
for(Int_t gammaIndex=0;gammaIndex<fKFReconstructedGammasTClone->GetEntriesFast();gammaIndex++){
// for(UInt_t gammaIndex=0;gammaIndex<fKFReconstructedGammas.size();gammaIndex++){
//Create AOD particle object from AliKFParticle
-
+
/* AliKFParticle * gammakf = &fKFReconstructedGammas[gammaIndex];
//You could add directly AliKFParticle objects to the AOD, avoiding dependences with PartCorr
//but this means that I have to work a little bit more in my side.
//AODPWG4Particle objects are simpler and lighter, I think
AliAODPWG4Particle gamma = AliAODPWG4Particle(gammakf->Px(),gammakf->Py(),gammakf->Pz(), gammakf->E());
gamma.SetLabel(-1);//How to get the MC label of the reconstructed gamma?
- gamma.SetCaloLabel(-1,-1); //How to get the MC label of the 2 electrons that form the gamma?
- gamma.SetDetector("CTS"); //tag the gamma as reconstructed in the central barrel
- gamma.SetPdg(AliCaloPID::kPhotonConv); //photon id
- gamma.SetTag(-1); //Here I usually put a flag saying that montecarlo says it is prompt, decay fragmentation photon, or hadrons or whatever
-
- //Add it to the aod list
- Int_t i = fAODBranch->GetEntriesFast();
- new((*fAODBranch)[i]) AliAODPWG4Particle(gamma);
+ gamma.SetCaloLabel(-1,-1); //How to get the MC label of the 2 electrons that form the gamma?
+ gamma.SetDetector("CTS"); //tag the gamma as reconstructed in the central barrel
+ gamma.SetPdg(AliCaloPID::kPhotonConv); //photon id
+ gamma.SetTag(-1); //Here I usually put a flag saying that montecarlo says it is prompt, decay fragmentation photon, or hadrons or whatever
+
+ //Add it to the aod list
+ Int_t i = fAODBranch->GetEntriesFast();
+ new((*fAODBranch)[i]) AliAODPWG4Particle(gamma);
*/
// AliKFParticle * gammakf = &fKFReconstructedGammas[gammaIndex];
AliKFParticle * gammakf = (AliKFParticle *)fKFReconstructedGammasTClone->At(gammaIndex);
aodObject.SetLabel2(fElectronv2[gammaIndex]);
Int_t i = fAODBranch->GetEntriesFast();
new((*fAODBranch)[i]) AliGammaConversionAODObject(aodObject);
- }
-
+ }
+
}
// AliKFParticle * twoGammaDecayCandidateDaughter0 = &fKFReconstructedGammas[firstGammaIndex];
// AliKFParticle * twoGammaDecayCandidateDaughter1 = &fKFReconstructedGammas[secondGammaIndex];
-
+
AliKFParticle * twoGammaDecayCandidateDaughter0 = (AliKFParticle *)fKFReconstructedGammasTClone->At(firstGammaIndex);
AliKFParticle * twoGammaDecayCandidateDaughter1 = (AliKFParticle *)fKFReconstructedGammasTClone->At(secondGammaIndex);
-
+
if(fElectronv1[firstGammaIndex]==fElectronv1[secondGammaIndex] || fElectronv1[firstGammaIndex]==fElectronv2[secondGammaIndex]){
continue;
}
if(fElectronv2[firstGammaIndex]==fElectronv1[secondGammaIndex] || fElectronv2[firstGammaIndex]==fElectronv2[secondGammaIndex]){
continue;
}
-
+
AliKFParticle *twoGammaCandidate = new AliKFParticle(*twoGammaDecayCandidateDaughter0,*twoGammaDecayCandidateDaughter1);
Double_t massTwoGammaCandidate = 0.;
}
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());
}
}
delete twoGammaCandidate;
-
- //cout << "nearly at the end of processgamma for neutral meson ..." << endl;
-
-
}
}
}
vector<AliKFParticle> vectorCurrentEventGoodV0s = fV0Reader->GetCurrentEventGoodV0s();
vector<AliKFParticle> vectorPreviousEventGoodV0s = fV0Reader->GetPreviousEventGoodV0s();
-
+
for(UInt_t iCurrent=0;iCurrent<vectorCurrentEventGoodV0s.size();iCurrent++){
AliKFParticle * currentEventGoodV0 = &vectorCurrentEventGoodV0s.at(iCurrent);
for(UInt_t iPrevious=0;iPrevious<vectorPreviousEventGoodV0s.size();iPrevious++){
AliKFParticle * previousGoodV0 = &vectorPreviousEventGoodV0s.at(iPrevious);
-
+
AliKFParticle *backgroundCandidate = new AliKFParticle(*currentEventGoodV0,*previousGoodV0);
Double_t massBG =0.;
TVector3 spaceVectorbackgroundCandidate(backgroundCandidate->GetX(),backgroundCandidate->GetY(),backgroundCandidate->GetZ());
Double_t openingAngleBG = currentEventGoodV0->GetAngle(*previousGoodV0);
-
+
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());
}
}
delete backgroundCandidate;
- //cout << "nearly at the end of background" << endl;
-
}
}
}
void AliAnalysisTaskGammaConversion::ProcessGammasForGammaJetAnalysis(){
//ProcessGammasForGammaJetAnalysis
-
+
Double_t distIsoMin;
-
+
CreateListOfChargedParticles();
-
-
+
+
// for(UInt_t gammaIndex=0;gammaIndex<fKFReconstructedGammas.size();gammaIndex++){
for(Int_t gammaIndex=0;gammaIndex<fKFReconstructedGammasTClone->GetEntriesFast();gammaIndex++){
AliKFParticle * currentGamma = (AliKFParticle*)fKFReconstructedGammasTClone->At(gammaIndex);
TVector3 momentumVectorCurrentGamma(currentGamma->GetPx(),currentGamma->GetPy(),currentGamma->GetPz());
-
+
if( momentumVectorCurrentGamma.Pt()> fMinPtForGammaJet){
distIsoMin=GetMinimumDistanceToCharge(gammaIndex);
-
+
if (distIsoMin > fMinIsoConeSize && fLeadingChargedIndex>=0){
CalculateJetCone(gammaIndex);
}
void AliAnalysisTaskGammaConversion::CreateListOfChargedParticles(){
// CreateListOfChargedParticles
-
+
fESDEvent = fV0Reader->GetESDEvent();
for(Int_t iTracks = 0; iTracks < fESDEvent->GetNumberOfTracks(); iTracks++){
AliESDtrack* curTrack = fESDEvent->GetTrack(iTracks);
-
+
if(!curTrack){
continue;
}
-
+
if(fEsdTrackCuts->AcceptTrack(curTrack) ){
new((*fChargedParticles)[fChargedParticles->GetEntriesFast()]) AliESDtrack(*curTrack);
// fChargedParticles.push_back(curTrack);
}
void AliAnalysisTaskGammaConversion::CalculateJetCone(Int_t gammaIndex){
// CaculateJetCone
-
+
Double_t cone;
Double_t coneSize=0.3;
Double_t ptJet=0;
-
+
// AliKFParticle * currentGamma = &fKFReconstructedGammas[gammaIndex];
AliKFParticle * currentGamma = (AliKFParticle*)fKFReconstructedGammasTClone->At(gammaIndex);
TVector3 momentumVectorCurrentGamma(currentGamma->GetPx(),currentGamma->GetPy(),currentGamma->GetPz());
-
+
AliESDtrack* leadingCharged = (AliESDtrack*)(fChargedParticles->At(fLeadingChargedIndex));
Double_t momLeadingCharged[3];
leadingCharged->GetConstrainedPxPyPz(momLeadingCharged);
-
+
TVector3 momentumVectorLeadingCharged(momLeadingCharged[0],momLeadingCharged[1],momLeadingCharged[2]);
-
+
Double_t phi1=momentumVectorLeadingCharged.Phi();
Double_t eta1=momentumVectorLeadingCharged.Eta();
Double_t phi3=momentumVectorCurrentGamma.Phi();
-
+
for(Int_t iCh=0;iCh<fChargedParticles->GetEntriesFast();iCh++){
AliESDtrack* curTrack = (AliESDtrack*)(fChargedParticles->At(iCh));
Int_t chId = fChargedParticlesId[iCh];
TVector3 momentumVectorChargedParticle(mom[0],mom[1],mom[2]);
Double_t phi2=momentumVectorChargedParticle.Phi();
Double_t eta2=momentumVectorChargedParticle.Eta();
-
-
+
+
cone=100.;
if( TMath::Abs(phi2 - phi1) <= ( TMath::TwoPi()-coneSize) ){
cone = TMath::Sqrt( TMath::Power((eta2-eta1),2)+ TMath::Power((phi2-phi1),2) );
cone = TMath::Sqrt( TMath::Power((eta2-eta1),2)+ TMath::Power((phi2+TMath::TwoPi()-phi1),2) );
}
}
-
+
if(cone <coneSize&& momentumVectorChargedParticle.Pt()>fMinPtJetCone ){
ptJet+= momentumVectorChargedParticle.Pt();
Double_t ffzHdrGam = momentumVectorChargedParticle.Pt()/momentumVectorCurrentGamma.Pt();
Double_t imbalanceHdrGam=-momentumVectorChargedParticle.Dot(momentumVectorCurrentGamma)/momentumVectorCurrentGamma.Mag2();
fHistograms->FillHistogram("ESD_FFzHdrGam",ffzHdrGam);
fHistograms->FillHistogram("ESD_ImbalanceHdrGam",imbalanceHdrGam);
-
+
}
-
+
Double_t dphiHdrGam=phi3-phi2;
if ( dphiHdrGam < (-TMath::PiOver2())){
dphiHdrGam+=(TMath::TwoPi());
}
-
+
if ( dphiHdrGam > (3.*TMath::PiOver2()) ){
dphiHdrGam-=(TMath::TwoPi());
}
-
+
if (momentumVectorChargedParticle.Pt()>fMinPtGamChargedCorr){
fHistograms->FillHistogram("ESD_dphiHdrGamIsolated",dphiHdrGam);
}
}//track loop
-
-
+
+
}
Double_t AliAnalysisTaskGammaConversion::GetMinimumDistanceToCharge(Int_t indexHighestPtGamma){
// GetMinimumDistanceToCharge
-
+
Double_t fIsoMin=100.;
Double_t ptLeadingCharged=-1.;
-
+
AliKFParticle * gammaHighestPt = (AliKFParticle*)fKFReconstructedGammasTClone->At(indexHighestPtGamma);
TVector3 momentumVectorgammaHighestPt(gammaHighestPt->GetPx(),gammaHighestPt->GetPy(),gammaHighestPt->GetPz());
-
+
Double_t phi1=momentumVectorgammaHighestPt.Phi();
Double_t eta1=momentumVectorgammaHighestPt.Eta();
-
+
for(Int_t iCh=0;iCh<fChargedParticles->GetEntriesFast();iCh++){
AliESDtrack* curTrack = (AliESDtrack*)(fChargedParticles->At(iCh));
Int_t chId = fChargedParticlesId[iCh];
Double_t phi2=momentumVectorChargedParticle.Phi();
Double_t eta2=momentumVectorChargedParticle.Eta();
Double_t iso=pow( (pow( (eta1-eta2),2)+ pow((phi1-phi2),2)),0.5 );
-
+
if(momentumVectorChargedParticle.Pt()>fMinPtIsoCone ){
if (iso<fIsoMin){
fIsoMin=iso;
}
}
-
+
Double_t dphiHdrGam=phi1-phi2;
if ( dphiHdrGam < (-TMath::PiOver2())){
dphiHdrGam+=(TMath::TwoPi());
}
-
+
if ( dphiHdrGam > (3.*TMath::PiOver2()) ){
dphiHdrGam-=(TMath::TwoPi());
}
if (momentumVectorChargedParticle.Pt()>fMinPtGamChargedCorr){
fHistograms->FillHistogram("ESD_dphiHdrGam",dphiHdrGam);
}
-
+
if (dphiHdrGam>0.9*TMath::Pi() && dphiHdrGam<1.1*TMath::Pi()){
- if (momentumVectorChargedParticle.Pt()> ptLeadingCharged && momentumVectorChargedParticle.Pt()>0.1*momentumVectorgammaHighestPt.Pt()){
+ if (momentumVectorChargedParticle.Pt()> ptLeadingCharged && momentumVectorChargedParticle.Pt()>0.1*momentumVectorgammaHighestPt.Pt()){
ptLeadingCharged=momentumVectorChargedParticle.Pt();
fLeadingChargedIndex=iCh;
}
}
-
+
}//track loop
fHistograms->FillHistogram("ESD_MinimumIsoDistance",fIsoMin);
return fIsoMin;
-
+
}
- Int_t AliAnalysisTaskGammaConversion::GetIndexHighestPtGamma(){
- //GetIndexHighestPtGamma
-
+Int_t AliAnalysisTaskGammaConversion::GetIndexHighestPtGamma(){
+ //GetIndexHighestPtGamma
+
Int_t indexHighestPtGamma=-1;
//Double_t
fGammaPtHighest = -100.;
-
+
for(Int_t firstGammaIndex=0;firstGammaIndex<fKFReconstructedGammasTClone->GetEntriesFast();firstGammaIndex++){
AliKFParticle * gammaHighestPtCandidate = (AliKFParticle*)fKFReconstructedGammasTClone->At(firstGammaIndex);
- TVector3 momentumVectorgammaHighestPtCandidate(gammaHighestPtCandidate->GetPx(),gammaHighestPtCandidate->GetPy(),gammaHighestPtCandidate->GetPz());
- if (momentumVectorgammaHighestPtCandidate.Pt() > fGammaPtHighest){
- fGammaPtHighest=momentumVectorgammaHighestPtCandidate.Pt();
- //gammaHighestPt = gammaHighestPtCandidate;
- indexHighestPtGamma=firstGammaIndex;
- }
+ TVector3 momentumVectorgammaHighestPtCandidate(gammaHighestPtCandidate->GetPx(),gammaHighestPtCandidate->GetPy(),gammaHighestPtCandidate->GetPz());
+ if (momentumVectorgammaHighestPtCandidate.Pt() > fGammaPtHighest){
+ fGammaPtHighest=momentumVectorgammaHighestPtCandidate.Pt();
+ //gammaHighestPt = gammaHighestPtCandidate;
+ indexHighestPtGamma=firstGammaIndex;
+ }
}
-
+
return indexHighestPtGamma;
-
+
}
fAODBranch = new TClonesArray("AliGammaConversionAODObject", 0);
fAODBranch->SetName(fAODBranchName);
AddAODBranch("TClonesArray", &fAODBranch);
-
+
// Create the output container
if(fOutputContainer != NULL){
delete fOutputContainer;
void AliAnalysisTaskGammaConversion::CheckV0Efficiency(){
// see header file for documentation
-
+
vector<Int_t> indexOfGammaParticle;
-
+
fStack = fV0Reader->GetMCStack();
-
+
if(fV0Reader->CheckForPrimaryVertex() == kFALSE){
return; // aborts if the primary vertex does not have contributors.
}
-
+
for (Int_t iTracks = 0; iTracks < fStack->GetNprimary(); iTracks++) {
TParticle* particle = (TParticle *)fStack->Particle(iTracks);
if(particle->GetPdgCode()==22){ //Gamma
}
}
}
-
+
Int_t nFoundGammas=0;
Int_t nNotFoundGammas=0;
-
+
Int_t numberOfV0s = fV0Reader->GetNumberOfV0s();
for(Int_t i=0;i<numberOfV0s;i++){
fV0Reader->GetV0(i);
-
+
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){
//TParticle * v0Gamma = fV0Reader->GetMotherMCParticle();
for(UInt_t mcIndex=0;mcIndex<indexOfGammaParticle.size();mcIndex++){
}
}
}
- // cout<<"Found: "<<nFoundGammas<<" of: "<<indexOfGammaParticle.size()<<endl;
}
void AliAnalysisTaskGammaConversion::ProcessGammaElectronsForChicAnalysis(){
// see header file for documantation
-
+
fESDEvent = fV0Reader->GetESDEvent();
-
-
- TClonesArray * vESDeNegTemp = new TClonesArray("AliESDtrack",0);
+
+
+ TClonesArray * vESDeNegTemp = new TClonesArray("AliESDtrack",0);
TClonesArray * vESDePosTemp = new TClonesArray("AliESDtrack",0);
TClonesArray * vESDxNegTemp = new TClonesArray("AliESDtrack",0);
TClonesArray * vESDxPosTemp = new TClonesArray("AliESDtrack",0);
TClonesArray * vESDeNegNoJPsi = new TClonesArray("AliESDtrack",0);
TClonesArray * vESDePosNoJPsi = new TClonesArray("AliESDtrack",0);
-
+
/*
vector <AliESDtrack*> vESDeNegTemp(0);
vector <AliESDtrack*> vESDePosTemp(0);
vector <AliESDtrack*> vESDeNegNoJPsi(0);
vector <AliESDtrack*> vESDePosNoJPsi(0);
*/
-
-
+
+
fHistograms->FillTable("Table_Electrons",0);//Count number of Events
-
+
for(Int_t iTracks = 0; iTracks < fESDEvent->GetNumberOfTracks(); iTracks++){
AliESDtrack* curTrack = fESDEvent->GetTrack(iTracks);
-
+
if(!curTrack){
//print warning here
continue;
}
-
+
double p[3];if(!curTrack->GetConstrainedPxPyPz(p))continue;
double r[3];curTrack->GetConstrainedXYZ(r);
-
+
TVector3 rXYZ(r);
-
+
fHistograms->FillTable("Table_Electrons",4);//Count number of ESD tracks
-
+
Bool_t flagKink = kTRUE;
Bool_t flagTPCrefit = kTRUE;
Bool_t flagTRDrefit = kTRUE;
Bool_t flagITSrefit = kTRUE;
Bool_t flagTRDout = kTRUE;
Bool_t flagVertex = kTRUE;
-
-
+
+
//Cuts ---------------------------------------------------------------
-
+
if(curTrack->GetKinkIndex(0) > 0){
fHistograms->FillHistogram("Table_Electrons",5);//Count kink
flagKink = kFALSE;
}
-
+
ULong_t trkStatus = curTrack->GetStatus();
-
+
ULong_t tpcRefit = (trkStatus & AliESDtrack::kTPCrefit);
-
+
if(!tpcRefit){
fHistograms->FillHistogram("Table_Electrons",9);//Count not TPCrefit
flagTPCrefit = kFALSE;
}
-
+
ULong_t itsRefit = (trkStatus & AliESDtrack::kITSrefit);
if(!itsRefit){
fHistograms->FillHistogram("Table_Electrons",10);//Count not ITSrefit
flagITSrefit = kFALSE;
}
-
+
ULong_t trdRefit = (trkStatus & AliESDtrack::kTRDrefit);
-
+
if(!trdRefit){
fHistograms->FillHistogram("Table_Electrons",8); //Count not TRDrefit
flagTRDrefit = kFALSE;
}
-
+
ULong_t trdOut = (trkStatus & AliESDtrack::kTRDout);
-
+
if(!trdOut) {
fHistograms->FillHistogram("Table_Electrons",7); //Count not TRDout
flagTRDout = kFALSE;
}
-
+
double nsigmaToVxt = GetSigmaToVertex(curTrack);
-
+
if(nsigmaToVxt > 3){
fHistograms->FillHistogram("Table_Electrons",6); //Count Tracks with number of sigmas > 3
flagVertex = kFALSE;
}
-
+
if(! (flagKink && flagTPCrefit && flagITSrefit && flagTRDrefit && flagTRDout && flagVertex ) ) continue;
fHistograms->FillHistogram("Table_Electrons",11);//Count Tracks passed Cuts
-
-
+
+
Stat_t pid, weight;
GetPID(curTrack, pid, weight);
-
+
if(pid!=0){
fHistograms->FillHistogram("Table_Electrons",12); //Count Tracks with pid != 0
}
-
+
if(pid == 0){
fHistograms->FillHistogram("Table_Electrons",13); //Count Tracks with pid != 0
}
-
-
-
-
+
+
+
+
Int_t labelMC = TMath::Abs(curTrack->GetLabel());
TParticle* curParticle = fStack->Particle(labelMC);
-
-
-
-
+
+
+
+
TLorentzVector curElec;
curElec.SetXYZM(p[0],p[1],p[2],fElectronMass);
-
-
-
-
+
+
+
+
if(curTrack->GetSign() > 0){
-
+
// vESDxPosTemp.push_back(curTrack);
new((*vESDxPosTemp)[vESDxPosTemp->GetEntriesFast()]) AliESDtrack(*curTrack);
-
+
if( pid == 0){
-
+
fHistograms->FillHistogram("ESD_ElectronPosNegPt",curElec.Pt());
fHistograms->FillHistogram("ESD_ElectronPosPt",curElec.Pt());
fHistograms->FillHistogram("MC_ElectronPosNegPt",curParticle->Pt());
fHistograms->FillHistogram("MC_ElectronPosNegEta",curParticle->Eta());
// vESDePosTemp.push_back(curTrack);
new((*vESDePosTemp)[vESDePosTemp->GetEntriesFast()]) AliESDtrack(*curTrack);
-
+
}
-
+
}
else {
// vESDxNegTemp.push_back(curTrack);
- if(vESDxNegTemp == NULL){
- cout<<"TCloes is zero god damn it"<<endl;
- }
- if(curTrack == NULL){
- cout<<"curTrack is zero god damn it"<<endl;
- }
-
+ /* if(vESDxNegTemp == NULL){
+ cout<<"TCloes is zero"<<endl;
+ }
+ if(curTrack == NULL){
+ cout<<"curTrack is zero"<<endl;
+ }
+ */
new((*vESDxNegTemp)[vESDxNegTemp->GetEntriesFast()]) AliESDtrack(*curTrack);
-
+
if( pid == 0){
-
+
fHistograms->FillHistogram("ESD_ElectronPosNegPt",curElec.Pt());
fHistograms->FillHistogram("ESD_ElectronNegPt",curElec.Pt());
fHistograms->FillHistogram("MC_ElectronPosNegPt",curParticle->Pt());
fHistograms->FillHistogram("MC_ElectronPosNegEta",curParticle->Eta());
//vESDeNegTemp.push_back(curTrack);
new((*vESDeNegTemp)[vESDeNegTemp->GetEntriesFast()]) AliESDtrack(*curTrack);
-
+
}
-
+
}
-
+
}
-
-
+
+
Bool_t ePosJPsi = kFALSE;
Bool_t eNegJPsi = kFALSE;
Bool_t ePosPi0 = kFALSE;
Bool_t eNegPi0 = kFALSE;
UInt_t iePosJPsi=0,ieNegJPsi=0,iePosPi0=0,ieNegPi0=0;
-
+
for(Int_t iNeg=0; iNeg < vESDeNegTemp->GetEntriesFast(); iNeg++){
if(fStack->Particle(TMath::Abs(((AliESDtrack*)(vESDeNegTemp->At(iNeg)))->GetLabel()))->GetPdgCode() == 11)
if(fStack->Particle(TMath::Abs(((AliESDtrack*)(vESDeNegTemp->At(iNeg)))->GetLabel()))->GetMother(0) > -1){
new((*vESDeNegNoJPsi)[vESDeNegNoJPsi->GetEntriesFast()]) AliESDtrack(*(AliESDtrack*)(vESDeNegTemp->At(iNeg)));
// cout<<"ESD No Positivo JPsi "<<endl;
}
-
+
}
}
-
+
for(Int_t iPos=0; iPos < vESDePosTemp->GetEntriesFast(); iPos++){
if(fStack->Particle(TMath::Abs(((AliESDtrack*)(vESDePosTemp->At(iPos)))->GetLabel()))->GetPdgCode() == -11)
if(fStack->Particle(TMath::Abs(((AliESDtrack*)(vESDePosTemp->At(iPos)))->GetLabel()))->GetMother(0) > -1){
new((*vESDePosNoJPsi)[vESDePosNoJPsi->GetEntriesFast()]) AliESDtrack(*(AliESDtrack*)(vESDePosTemp->At(iPos)));
// cout<<"ESD No Negativo JPsi "<<endl;
}
-
+
}
}
fHistograms->FillHistogram("MC_ElectronPosNegPi0Angle",GetMCOpeningAngle(fStack->Particle(TMath::Abs(((AliESDtrack*)(vESDeNegTemp->At(ieNegPi0)))->GetLabel())),
fStack->Particle(TMath::Abs(((AliESDtrack*)(vESDePosTemp->At(iePosPi0)))->GetLabel()))));
}
-
-
+
+
FillAngle("ESD_eNegePosAngleBeforeCut",GetTLorentzVector(vESDeNegTemp),GetTLorentzVector(vESDePosTemp));
-
+
CleanWithAngleCuts(*vESDeNegTemp,*vESDePosTemp,*fKFReconstructedGammasTClone);
// vector <TLorentzVector> vCurrentTLVeNeg = GetTLorentzVector(fCurrentEventNegElectron);
// vector <TLorentzVector> vCurrentTLVePos = GetTLorentzVector(fCurrentEventPosElectron);
-
+
TClonesArray vCurrentTLVeNeg = GetTLorentzVector(fCurrentEventNegElectronTClone);
TClonesArray vCurrentTLVePos = GetTLorentzVector(fCurrentEventPosElectronTClone);
-
-
+
+
FillAngle("ESD_eNegePosAngleAfterCut",vCurrentTLVeNeg,vCurrentTLVePos);
-
-
-
-
+
+
+
+
//FillAngle("ESD_eNegePosAngleAfterCut",CurrentTLVeNeg,CurrentTLVePos);
-
-
+
+
FillElectronInvMass("ESD_InvMass_ePluseMinus",vCurrentTLVeNeg,vCurrentTLVePos);
FillElectronInvMass("ESD_InvMass_xPlusxMinus",GetTLorentzVector(vESDxNegTemp),GetTLorentzVector(vESDxPosTemp));
-
-
-
+
+
+
FillGammaElectronInvMass("ESD_InvMass_GammaePluseMinusChiC","ESD_InvMass_GammaePluseMinusChiCDiff",*fKFReconstructedGammasCutTClone,vCurrentTLVeNeg,vCurrentTLVePos);
-
+
FillGammaElectronInvMass("ESD_InvMass_GammaePluseMinusPi0","ESD_InvMass_GammaePluseMinusPi0Diff",
*fKFReconstructedGammasCutTClone,vCurrentTLVeNeg,vCurrentTLVePos);
-
+
//BackGround
-
+
//Like Sign e+e-
ElectronBackground("ESD_ENegBackground",vCurrentTLVeNeg);
ElectronBackground("ESD_EPosBackground",vCurrentTLVePos);
ElectronBackground("ESD_EPosENegBackground",vCurrentTLVeNeg);
ElectronBackground("ESD_EPosENegBackground",vCurrentTLVePos);
-
+
// Like Sign e+e- no JPsi
ElectronBackground("ESD_EPosENegNoJPsiBG",GetTLorentzVector(vESDeNegNoJPsi));
ElectronBackground("ESD_EPosENegNoJPsiBG",GetTLorentzVector(vESDePosNoJPsi));
-
+
//Mixed Event
-
+
if( fCurrentEventPosElectronTClone->GetEntriesFast() > 0 && fCurrentEventNegElectronTClone->GetEntriesFast() > 0 && fKFReconstructedGammasCutTClone->GetEntriesFast() > 0 ){
FillGammaElectronInvMass("ESD_EPosENegGammaBackgroundMX","ESD_EPosENegGammaBackgroundMXDiff",
*fKFReconstructedGammasCutTClone,*fPreviousEventTLVNegElectronTClone,*fPreviousEventTLVPosElectronTClone);
*fPreviousEventTLVNegElectronTClone = vCurrentTLVeNeg;
*fPreviousEventTLVPosElectronTClone = vCurrentTLVePos;
-
+
}
-
+
/*
//Photons P
Double_t vtx[3];
vtx[0]=0;vtx[1]=0;vtx[2]=0;
for(UInt_t i=0;i<fKFReconstructedGammasChic.size();i++){
-
+
// if(fMCGammaChicTempCut[i]->GetMother(0) < 0) continue;
-
-
-
+
+
+
Int_t tempLabel = fStack->Particle(fMCGammaChicTempCut[i]->GetMother(0))->GetPdgCode();
// cout<<" Label Pedro Gonzalez " <<tempLabel <<endl;
-
+
// cout<<" Label Distance"<<fKFReconstructedGammasChic[i].GetDistanceFromVertex(vtx)<<endl;
-
+
if( tempLabel == 10441 || tempLabel == 20443 || tempLabel == 445 )
-
+
fHistograms->FillHistogram("ESD_PhotonsMomentum",fKFReconstructedGammasChic[i].GetMomentum());
-
-
+
+
}
-
-
+
+
*/
-
-
+
+
}
/*
TClonesArray const tlVeNeg,TClonesArray const tlVePos)
{
//see header file for documentation
-
+
for( Int_t iNeg=0; iNeg < tlVeNeg.GetEntriesFast(); iNeg++ ){
-
+
for (Int_t iPos=0; iPos < tlVePos.GetEntriesFast(); iPos++){
-
+
TLorentzVector xy = *((TLorentzVector *)(tlVePos.At(iPos))) + *((TLorentzVector *)(tlVeNeg.At(iNeg)));
-
+
for (Int_t iGam=0; iGam < fKFGammas.GetEntriesFast(); iGam++){
-
+
// AliKFParticle * gammaCandidate = &fKFGammas[iGam];
AliKFParticle * gammaCandidate = (AliKFParticle *)(fKFGammas.At(iGam));
TLorentzVector g;
-
+
g.SetXYZM(gammaCandidate->GetPx(),gammaCandidate->GetPy(),gammaCandidate->GetPz(),fGammaMass);
TLorentzVector xyg = xy + g;
fHistograms->FillHistogram(histoMass.Data(),xyg.M());
}
}
}
-
+
}
void AliAnalysisTaskGammaConversion::ElectronBackground(TString hBg, TClonesArray e)
{
for (Int_t j=i+1; j < e.GetEntriesFast(); j++)
{
TLorentzVector ee = (*(TLorentzVector*)(e.At(i))) + (*(TLorentzVector*)(e.At(j)));
-
+
fHistograms->FillHistogram(hBg.Data(),ee.M());
}
}
TClonesArray const positiveElectrons,
TClonesArray const gammas){
// see header file for documentation
-
+
UInt_t sizeN = negativeElectrons.GetEntriesFast();
UInt_t sizeP = positiveElectrons.GetEntriesFast();
UInt_t sizeG = gammas.GetEntriesFast();
-
-
-
+
+
+
vector <Bool_t> xNegBand(sizeN);
vector <Bool_t> xPosBand(sizeP);
vector <Bool_t> gammaBand(sizeG);
-
-
+
+
for(UInt_t iNeg=0; iNeg < sizeN; iNeg++) xNegBand[iNeg]=kTRUE;
for(UInt_t iPos=0; iPos < sizeP; iPos++) xPosBand[iPos]=kTRUE;
for(UInt_t iGam=0; iGam < sizeG; iGam++) gammaBand[iGam]=kTRUE;
-
-
- for(UInt_t iPos=0; iPos < sizeP; iPos++){
+
+ for(UInt_t iPos=0; iPos < sizeP; iPos++){
+
Double_t aP[3];
((AliESDtrack*)(positiveElectrons.At(iPos)))->GetConstrainedPxPyPz(aP);
-
+
TVector3 ePosV(aP[0],aP[1],aP[2]);
-
+
for(UInt_t iNeg=0; iNeg < sizeN; iNeg++){
-
+
Double_t aN[3];
((AliESDtrack*)(negativeElectrons.At(iNeg)))->GetConstrainedPxPyPz(aN);
TVector3 eNegV(aN[0],aN[1],aN[2]);
-
+
if(ePosV.Angle(eNegV) < 0.05){ //e+e- from gamma
xPosBand[iPos]=kFALSE;
xNegBand[iNeg]=kFALSE;
}
-
+
for(UInt_t iGam=0; iGam < sizeG; iGam++){
AliKFParticle* gammaCandidate = (AliKFParticle*)gammas.At(iGam);
TVector3 gammaCandidateVector(gammaCandidate->Px(),gammaCandidate->Py(),gammaCandidate->Pz());
}
}
}
-
-
-
-
+
+
+
+
for(UInt_t iPos=0; iPos < sizeP; iPos++){
if(xPosBand[iPos]){
new((*fCurrentEventPosElectronTClone)[fCurrentEventPosElectronTClone->GetEntriesFast()]) AliESDtrack((*(AliESDtrack*)(positiveElectrons.At(iPos))));
// see header file for documentation
pid = -1;
weight = -1;
-
+
double wpart[5];
double wpartbayes[5];
-
+
//get probability of the diffenrent particle types
track->GetESDpid(wpart);
-
+
// Tentative particle type "concentrations"
double c[5]={0.01, 0.01, 0.85, 0.10, 0.05};
-
+
//Bayes' formula
double rcc = 0.;
for (int i = 0; i < 5; i++)
{
rcc+=(c[i] * wpart[i]);
}
-
-
-
+
+
+
for (int i=0; i<5; i++) {
if( rcc!=0){
wpartbayes[i] = c[i] * wpart[i] / rcc;
}
}
-
-
-
+
+
+
Float_t max=0.;
int ipid=-1;
//find most probable particle in ESD pid
{
if (wpartbayes[i] > max)
{
- ipid = i;
- max = wpartbayes[i];
+ ipid = i;
+ max = wpartbayes[i];
}
}
-
+
pid = ipid;
weight = max;
}
double AliAnalysisTaskGammaConversion::GetSigmaToVertex(AliESDtrack* t)
{
// Calculates the number of sigma to the vertex.
-
+
Float_t b[2];
Float_t bRes[2];
Float_t bCov[3];
}
bRes[0] = TMath::Sqrt(bCov[0]);
bRes[1] = TMath::Sqrt(bCov[2]);
-
+
// -----------------------------------
// How to get to a n-sigma cut?
//
//
// It means that for a 2-dim gauss: n_sigma(d) = Sqrt(2)*ErfInv(1 - Exp((-x**2)/2)
// Can this be expressed in a different way?
-
+
if (bRes[0] == 0 || bRes[1] ==0)
return -1;
-
+
double d = TMath::Sqrt(TMath::Power(b[0]/bRes[0],2) + TMath::Power(b[1]/bRes[1],2));
-
+
// stupid rounding problem screws up everything:
// if d is too big, TMath::Exp(...) gets 0, and TMath::ErfInverse(1) that should be infinite, gets 0 :(
if (TMath::Exp(-d * d / 2) < 1e-10)
return 1000;
-
-
+
+
d = TMath::ErfInverse(1 - TMath::Exp(-d * d / 2)) * TMath::Sqrt(2);
return d;
}
//Return TLoresntz vector of track?
// vector <TLorentzVector> tlVtrack(0);
TClonesArray array("TLorentzVector",0);
-
+
for(Int_t itrack=0; itrack < esdTrack->GetEntriesFast(); itrack++){
double p[3];
//esdTrack[itrack]->GetConstrainedPxPyPz(p);
new((array)[array.GetEntriesFast()]) TLorentzVector(currentTrack);
// tlVtrack.push_back(currentTrack);
}
-
+
return array;
-
+
// return tlVtrack;
}
#ifndef ALIANALYSISTASKGAMMACONVERSION_H
#define ALIANALYSISTASKGAMMACONVERSION_H
-
+
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
// Class used to do analysis on conversion pairs
//---------------------------------------------
////////////////////////////////////////////////
-
+
#include "AliAnalysisTaskSE.h"
#include <vector>
#include "AliV0Reader.h"
class AliESDInputHandler;
class AliESDEvent;
class AliAODEvent;
+class AliMCEvent;
class TList;
class AliStack;
class AliESDtrackCuts;
-
+class AliCFManager; // for CF
+class AliCFContainer; // for CF
class AliAnalysisTaskGammaConversion : public AliAnalysisTaskSE
{
+
+ // for CF
+ enum{
+ kStepGenerated = 0,
+ kStepReconstructable = 1,
+ kStepLikeSign = 2,
+ kStepTPCRefit = 3,
+ kStepKinks = 4,
+ kStepGetOnFly = 5,
+ kStepNContributors = 6,
+ kStepTPCPID = 7,
+ kStepR = 8,
+ kStepLine = 9,
+ kStepZ = 10,
+ kStepNDF = 11,
+ kStepChi2 = 12,
+ kStepEta = 13,
+ kStepPt = 14
+ };
+
+
+
+
public:
AliAnalysisTaskGammaConversion();
AliAnalysisTaskGammaConversion(const char* name);
virtual ~AliAnalysisTaskGammaConversion() ;// virtual destructor
-
+
// Implementation of interface methods
virtual void UserCreateOutputObjects();
virtual void Init();
virtual void Exec(Option_t *option);
virtual void Terminate(Option_t *option);
virtual void ConnectInputData(Option_t *);
-
+
void ProcessMCData();
void ProcessV0sNoCut();
void ProcessV0s();
void ProcessGammasForNeutralMesonAnalysis();
-
+
+ // for CF
+ void SetCFManager(AliCFManager *io) {fCFManager = io;};
+ AliCFManager *GetCFManager() const {return fCFManager;}
+
+
// AOD
TString GetAODBranchName() const {return fAODBranchName;}
void SetAODBranchName(TString name) {fAODBranchName = name ;}
void FillAODWithConversionGammas();
// end AOD
-
-
- // for GammaJetAnalysis
+
+
+ // for GammaJetAnalysis
void ProcessGammasForGammaJetAnalysis();
void CreateListOfChargedParticles();
Double_t GetMinimumDistanceToCharge(Int_t indexHighestPtGamma);
Int_t GetIndexHighestPtGamma();
void SetESDtrackCuts();
// end of Gamma Jet
-
+
void SetMinPtForGammaJet(Double_t minPtForGammaJet){fMinPtForGammaJet=minPtForGammaJet;}
void SetMinIsoConeSize(Double_t minIsoConeSize){fMinIsoConeSize=minIsoConeSize;}
void SetMinPtIsoCone(Double_t minPtIsoCone){fMinPtIsoCone=minPtIsoCone;}
void SetMinPtGamChargedCorr(Double_t minPtGamChargedCorr){fMinPtGamChargedCorr=minPtGamChargedCorr;}
void SetMinPtJetCone(Double_t minPtJetCone){fMinPtJetCone=minPtJetCone;}
-
+
void SetHistograms(AliGammaConversionHistograms *const histograms){fHistograms=histograms;}
void SetDoMCTruth(Bool_t flag){fDoMCTruth=flag;}
void SetDoNeutralMeson(Bool_t flag){fDoNeutralMeson=flag;}
void SetDoJet(Bool_t flag){fDoJet=flag;}
void SetDoChic(Bool_t flag){fDoChic=flag;}
-
+
void SetElectronMass(Double_t electronMass){fElectronMass = electronMass;}
void SetGammaMass(Double_t gammaMass){fGammaMass = gammaMass;}
void SetGammaWidth(Double_t gammaWidth){fGammaWidth = gammaWidth;}
void FillNtuple();
Double_t GetMCOpeningAngle(TParticle* const daughter0, TParticle* const daughter1) const;
void CheckV0Efficiency();
-
-
+
+
//////////////////Chi_c Analysis////////////////////////////
void GetPID(AliESDtrack *track, Stat_t &pid, Stat_t &weight);
double GetSigmaToVertex(AliESDtrack* t);
TClonesArray GetTLorentzVector(TClonesArray* esdTrack);
void ProcessGammaElectronsForChicAnalysis();
///////////////////////////////////////////////////////////////
-
-
+
+
private:
AliAnalysisTaskGammaConversion(const AliAnalysisTaskGammaConversion&); // Not implemented
AliAnalysisTaskGammaConversion& operator=(const AliAnalysisTaskGammaConversion&); // Not implemented
-
+
AliV0Reader* fV0Reader; // The V0 reader object
-
+
AliStack * fStack; // pointer to the MC particle stack
+ AliMCEventHandler *fMCTruth; // for CF pointer to MCTruth
+ AliMCEvent *fMCEvent; // for CF pointer to the MC Event
AliESDEvent* fESDEvent; //pointer to the ESDEvent
- TList * fOutputContainer ; // Histogram container
+ TList * fOutputContainer; // Histogram container
+ AliCFManager *fCFManager; // for CF
+ // AliCFContainer *container; // for CF
+
+
AliGammaConversionHistograms *fHistograms; // Pointer to the histogram handling class
-
+
Bool_t fDoMCTruth; // Flag to switch on/off MC truth
Bool_t fDoNeutralMeson; // flag
Bool_t fDoJet; // flag
Bool_t fDoChic; // flag
-
+
TClonesArray * fKFReconstructedGammasTClone; //! transient
TClonesArray * fCurrentEventPosElectronTClone; //! transient
TClonesArray * fCurrentEventNegElectronTClone; //! transient
TClonesArray * fKFReconstructedGammasCutTClone; //! transient
TClonesArray * fPreviousEventTLVNegElectronTClone; //! transient
TClonesArray * fPreviousEventTLVPosElectronTClone; //! transient
-
+
// vector<AliKFParticle> fKFReconstructedGammas; // vector containing all reconstructed gammas
vector<Int_t> fElectronv1; // vector containing index of electron 1
vector<Int_t> fElectronv2; // vector containing index of electron 2
-
+
///////Chi_c Analysis///////////////////////////
// vector<AliESDtrack*> fCurrentEventPosElectron; // comment here
// vector<AliESDtrack*> fCurrentEventNegElectron; // comment here
// vector<TLorentzVector> fPreviousEventTLVNegElectron; // comment here
// vector<TLorentzVector> fPreviousEventTLVPosElectron; // comment here
//////////////////////////////////////////////////
-
+
//mass defines
Double_t fElectronMass; //electron mass
Double_t fGammaMass; //gamma mass
Double_t fPi0Mass; //pi0mass
Double_t fEtaMass; //eta mass
-
+
// width defines
Double_t fGammaWidth; //gamma width cut
Double_t fPi0Width; // pi0 width cut
Double_t fEtaWidth; // eta width cut
-
+
Double_t fMinOpeningAngleGhostCut; // minimum angle cut
-
+
AliESDtrackCuts* fEsdTrackCuts; // Object containing the parameters of the esd track cuts
-
+
Bool_t fCalculateBackground; //flag to set backgrount calculation on/off
Bool_t fWriteNtuple; // flag to set if writing to ntuple on/off
TNtuple *fGammaNtuple; // Ntuple for gamma values
TNtuple *fNeutralMesonNtuple;// NTuple for mesons
-
+
Int_t fTotalNumberOfAddedNtupleEntries; // number of added ntuple entries
-
+
TClonesArray* fChargedParticles; //! transient
vector<Int_t> fChargedParticlesId; //! transient
-
+
Double_t fGammaPtHighest; //! transient
Double_t fMinPtForGammaJet; //! transient
Double_t fMinIsoConeSize; //! transient
Double_t fMinPtGamChargedCorr; //! transient
Double_t fMinPtJetCone; //! transient
Int_t fLeadingChargedIndex; //! transient
-
+
TClonesArray* fAODBranch ; //! selected particles branch
TString fAODBranchName; // New AOD branch name
-
+
// TClonesArray *fAODObjects;
-
+
ClassDef(AliAnalysisTaskGammaConversion, 4); // Analysis task for gamma conversions
};
-
+
#endif //ALIANALYSISTASKGAMMA_H
-/**************************************************************************\r
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *\r
- * *\r
- * Author: Ana Marin, Kathrin Koch, Kenneth Aamodt *\r
- * Version 1.0 *\r
- * *\r
- * Permission to use, copy, modify and distribute this software and its *\r
- * documentation strictly for non-commercial purposes is hereby granted *\r
- * without fee, provided that the above copyright notice appears in all *\r
- * copies and that both the copyright notice and this permission notice *\r
- * appear in the supporting documentation. The authors make no claims *\r
- * about the suitability of this software for any purpose. It is *\r
- * provided "as is" without express or implied warranty. *\r
- **************************************************************************/\r
-\r
-////////////////////////////////////////////////\r
-//--------------------------------------------- \r
-// Class used to do analysis on conversion pairs\r
-//---------------------------------------------\r
-////////////////////////////////////////////////\r
-\r
-// --- ROOT system ---\r
-#include <TMath.h>\r
-\r
-//---- ANALYSIS system ----\r
-#include "AliV0Reader.h"\r
-#include "AliAnalysisManager.h"\r
-#include "AliESDInputHandler.h"\r
-#include "AliESDtrack.h"\r
-#include "AliMCEvent.h"\r
-#include "AliKFVertex.h"\r
-\r
-#include "AliStack.h"\r
-#include "AliMCEventHandler.h"\r
-\r
-\r
-class iostream;\r
-class AliESDv0;\r
-class TFormula;\r
-\r
-using namespace std;\r
-\r
-ClassImp(AliV0Reader)\r
-\r
-\r
-\r
-AliV0Reader::AliV0Reader() :\r
-TObject(),\r
- fMCStack(NULL),\r
- fMCTruth(NULL),\r
- fChain(NULL),\r
- fESDHandler(NULL),\r
- fESDEvent(NULL),\r
- fHistograms(NULL),\r
- fCurrentV0IndexNumber(0),\r
- fCurrentV0(NULL),\r
- fCurrentNegativeKFParticle(NULL),\r
- fCurrentPositiveKFParticle(NULL),\r
- fCurrentMotherKFCandidate(NULL),\r
- fCurrentNegativeESDTrack(NULL),\r
- fCurrentPositiveESDTrack(NULL),\r
- fNegativeTrackLorentzVector(NULL),\r
- fPositiveTrackLorentzVector(NULL),\r
- fMotherCandidateLorentzVector(NULL),\r
- fCurrentXValue(0),\r
- fCurrentYValue(0),\r
- fCurrentZValue(0),\r
- fPositiveTrackPID(0),\r
- fNegativeTrackPID(0),\r
- fNegativeMCParticle(NULL),\r
- fPositiveMCParticle(NULL),\r
- fMotherMCParticle(NULL),\r
- fMotherCandidateKFMass(0),\r
- fMotherCandidateKFWidth(0),\r
- fUseKFParticle(kTRUE),\r
- fUseESDTrack(kFALSE),\r
- fDoMC(kFALSE),\r
- fMaxR(10000),// 100 meter(outside of ALICE)\r
- fEtaCut(0.),\r
- fPtCut(0.),\r
- fLineCutZRSlope(0.),\r
- fLineCutZValue(0.),\r
- fChi2CutConversion(0.),\r
- fChi2CutMeson(0.),\r
- fPIDProbabilityCutNegativeParticle(0),\r
- fPIDProbabilityCutPositiveParticle(0),\r
- fXVertexCut(0.),\r
- fYVertexCut(0.),\r
- fZVertexCut(0.),\r
- fNSigmaMass(0.),\r
- fUseImprovedVertex(kFALSE),\r
- fCurrentEventGoodV0s(),\r
- fPreviousEventGoodV0s()\r
-{\r
- \r
-}\r
-\r
-\r
-AliV0Reader::AliV0Reader(const AliV0Reader & original) :\r
- TObject(original),\r
- fMCStack(original.fMCStack),\r
- fMCTruth(original.fMCTruth),\r
- fChain(original.fChain),\r
- fESDHandler(original.fESDHandler),\r
- fESDEvent(original.fESDEvent),\r
- fHistograms(original.fHistograms),\r
- fCurrentV0IndexNumber(original.fCurrentV0IndexNumber),\r
- fCurrentV0(original.fCurrentV0),\r
- fCurrentNegativeKFParticle(original.fCurrentNegativeKFParticle),\r
- fCurrentPositiveKFParticle(original.fCurrentPositiveKFParticle),\r
- fCurrentMotherKFCandidate(original.fCurrentMotherKFCandidate),\r
- fCurrentNegativeESDTrack(original.fCurrentNegativeESDTrack),\r
- fCurrentPositiveESDTrack(original.fCurrentPositiveESDTrack),\r
- fNegativeTrackLorentzVector(original.fNegativeTrackLorentzVector),\r
- fPositiveTrackLorentzVector(original.fPositiveTrackLorentzVector),\r
- fMotherCandidateLorentzVector(original.fMotherCandidateLorentzVector),\r
- fCurrentXValue(original.fCurrentXValue),\r
- fCurrentYValue(original.fCurrentYValue),\r
- fCurrentZValue(original.fCurrentZValue),\r
- fPositiveTrackPID(original.fPositiveTrackPID),\r
- fNegativeTrackPID(original.fNegativeTrackPID),\r
- fNegativeMCParticle(original.fNegativeMCParticle),\r
- fPositiveMCParticle(original.fPositiveMCParticle),\r
- fMotherMCParticle(original.fMotherMCParticle),\r
- fMotherCandidateKFMass(original.fMotherCandidateKFMass),\r
- fMotherCandidateKFWidth(original.fMotherCandidateKFWidth),\r
- fUseKFParticle(kTRUE),\r
- fUseESDTrack(kFALSE),\r
- fDoMC(kFALSE),\r
- fMaxR(original.fMaxR),\r
- fEtaCut(original.fEtaCut),\r
- fPtCut(original.fPtCut),\r
- fLineCutZRSlope(original.fLineCutZRSlope),\r
- fLineCutZValue(original.fLineCutZValue),\r
- fChi2CutConversion(original.fChi2CutConversion),\r
- fChi2CutMeson(original.fChi2CutMeson),\r
- fPIDProbabilityCutNegativeParticle(original.fPIDProbabilityCutNegativeParticle),\r
- fPIDProbabilityCutPositiveParticle(original.fPIDProbabilityCutPositiveParticle),\r
- fXVertexCut(original.fXVertexCut),\r
- fYVertexCut(original.fYVertexCut),\r
- fZVertexCut(original.fZVertexCut),\r
- fNSigmaMass(original.fNSigmaMass),\r
- fUseImprovedVertex(original.fUseImprovedVertex),\r
- fCurrentEventGoodV0s(original.fCurrentEventGoodV0s),\r
- fPreviousEventGoodV0s(original.fPreviousEventGoodV0s)\r
-{\r
- \r
-}\r
-\r
-\r
-AliV0Reader & AliV0Reader::operator = (const AliV0Reader & /*source*/)\r
-{\r
- // assignment operator\r
- return *this;\r
-}\r
-\r
-void AliV0Reader::Initialize(){\r
- //see header file for documentation\r
- \r
- // Get the input handler from the manager\r
- fESDHandler = (AliESDInputHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());\r
- if(fESDHandler == NULL){\r
- //print warning here\r
- }\r
- \r
- // Get pointer to esd event from input handler\r
- fESDEvent = fESDHandler->GetEvent();\r
- if(fESDEvent == NULL){\r
- //print warning here\r
- }\r
- \r
- //Get pointer to MCTruth\r
- fMCTruth = (AliMCEventHandler*)((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler());\r
- if(fMCTruth == NULL){\r
- //print warning here\r
- }\r
- \r
- //Get pointer to the mc stack\r
- fMCStack = fMCTruth->MCEvent()->Stack();\r
- if(fMCStack == NULL){\r
- //print warning here\r
- }\r
- \r
- AliKFParticle::SetField(fESDEvent->GetMagneticField());\r
- \r
-}\r
-\r
-AliESDv0* AliV0Reader::GetV0(Int_t index){\r
- //see header file for documentation\r
- \r
- fCurrentV0 = fESDEvent->GetV0(index);\r
- UpdateV0Information();\r
- return fCurrentV0;\r
-}\r
-\r
-Bool_t AliV0Reader::CheckForPrimaryVertex(){\r
- return fESDEvent->GetPrimaryVertex()->GetNContributors()>0;\r
-}\r
-\r
-\r
-\r
-Bool_t AliV0Reader::NextV0(){\r
- //see header file for documentation\r
- \r
- Bool_t iResult=kFALSE;\r
- while(fCurrentV0IndexNumber<fESDEvent->GetNumberOfV0s()){\r
- fCurrentV0 = fESDEvent->GetV0(fCurrentV0IndexNumber);\r
- \r
- //checks if on the fly mode is set\r
- if ( !fCurrentV0->GetOnFlyStatus() ){\r
- if(fHistograms != NULL){\r
- fHistograms->FillHistogram("ESD_CutGetOnFly_InvMass",GetMotherCandidateMass());\r
- }\r
- fCurrentV0IndexNumber++;\r
- continue;\r
- }\r
- \r
- //checks if we have a prim vertex\r
- if(fESDEvent->GetPrimaryVertex()->GetNContributors()<=0) { \r
- if(fHistograms != NULL){\r
- fHistograms->FillHistogram("ESD_CutNContributors_InvMass",GetMotherCandidateMass());\r
- }\r
- fCurrentV0IndexNumber++;\r
- continue;\r
- }\r
- \r
- //Check the pid probability\r
- if(CheckPIDProbability(fPIDProbabilityCutNegativeParticle,fPIDProbabilityCutPositiveParticle)==kFALSE){\r
- if(fHistograms != NULL){\r
- fHistograms->FillHistogram("ESD_CutPIDProb_InvMass",GetMotherCandidateMass());\r
- }\r
- fCurrentV0IndexNumber++;\r
- continue;\r
- }\r
- \r
- \r
- fCurrentV0->GetXYZ(fCurrentXValue,fCurrentYValue,fCurrentZValue);\r
- \r
- \r
- if(GetXYRadius()>fMaxR){ // cuts on distance from collision point\r
- if(fHistograms != NULL){\r
- fHistograms->FillHistogram("ESD_CutR_InvMass",GetMotherCandidateMass());\r
- }\r
- fCurrentV0IndexNumber++;\r
- continue;\r
- } \r
- \r
- \r
- if((TMath::Abs(fCurrentZValue)*fLineCutZRSlope)-fLineCutZValue > GetXYRadius() ){ // cuts out regions where we do not reconstruct\r
- if(fHistograms != NULL){\r
- fHistograms->FillHistogram("ESD_CutLine_InvMass",GetMotherCandidateMass());\r
- }\r
- fCurrentV0IndexNumber++;\r
- continue;\r
- } \r
- \r
- \r
- if(UpdateV0Information() == kFALSE){\r
- fCurrentV0IndexNumber++;\r
- continue;\r
- }\r
- \r
- if(fUseKFParticle){\r
- if(fCurrentMotherKFCandidate->GetNDF()<=0){\r
- if(fHistograms != NULL){\r
- fHistograms->FillHistogram("ESD_CutNDF_InvMass",GetMotherCandidateMass());\r
- }\r
- fCurrentV0IndexNumber++;\r
- continue;\r
- }\r
- \r
- \r
- Double_t chi2V0 = fCurrentMotherKFCandidate->GetChi2()/fCurrentMotherKFCandidate->GetNDF();\r
- if(chi2V0 > fChi2CutConversion || chi2V0 <=0){\r
- if(fHistograms != NULL){\r
- fHistograms->FillHistogram("ESD_CutChi2_InvMass",GetMotherCandidateMass());\r
- }\r
- fCurrentV0IndexNumber++;\r
- continue;\r
- }\r
- \r
- \r
- if(TMath::Abs(fMotherCandidateLorentzVector->Eta())> fEtaCut){\r
- if(fHistograms != NULL){\r
- fHistograms->FillHistogram("ESD_CutEta_InvMass",GetMotherCandidateMass());\r
- }\r
- fCurrentV0IndexNumber++;\r
- continue;\r
- }\r
- \r
- \r
- if(fMotherCandidateLorentzVector->Pt()<fPtCut){\r
- if(fHistograms != NULL){\r
- fHistograms->FillHistogram("ESD_CutPt_InvMass",GetMotherCandidateMass());\r
- }\r
- fCurrentV0IndexNumber++;\r
- continue;\r
- }\r
- \r
- \r
- }\r
- else if(fUseESDTrack){\r
- //TODO\r
- }\r
-\r
- fCurrentEventGoodV0s.push_back(*fCurrentMotherKFCandidate);\r
-\r
- iResult=kTRUE;//means we have a v0 who survived all the cuts applied\r
- \r
- fCurrentV0IndexNumber++;\r
- \r
- break;\r
- }\r
- return iResult; \r
-}\r
-\r
-Bool_t AliV0Reader::UpdateV0Information(){\r
- //see header file for documentation\r
-\r
- Bool_t iResult=kTRUE; // for taking out not refitted, kinks and like sign tracks \r
-\r
- Bool_t switchTracks = kFALSE;\r
- \r
- fCurrentNegativeESDTrack = fESDEvent->GetTrack(fCurrentV0->GetNindex());\r
- fCurrentPositiveESDTrack = fESDEvent->GetTrack(fCurrentV0->GetPindex());\r
- \r
- if(fCurrentNegativeESDTrack->GetSign() == fCurrentPositiveESDTrack->GetSign()){ // avoid like sign\r
- iResult=kFALSE;\r
- if(fHistograms != NULL){\r
- fHistograms->FillHistogram("ESD_CutLikeSign_InvMass",GetMotherCandidateMass());\r
- }\r
- }\r
- \r
- if(fCurrentPositiveESDTrack->GetSign() == -1 && fCurrentNegativeESDTrack->GetSign() == 1){ // switch wrong signed tracks\r
- fCurrentNegativeESDTrack = fESDEvent->GetTrack(fCurrentV0->GetPindex());\r
- fCurrentPositiveESDTrack = fESDEvent->GetTrack(fCurrentV0->GetNindex());\r
- switchTracks = kTRUE;\r
- }\r
-\r
- if( !(fCurrentNegativeESDTrack->GetStatus() & AliESDtrack::kTPCrefit) || \r
- !(fCurrentPositiveESDTrack->GetStatus() & AliESDtrack::kTPCrefit) ){\r
- // if( !(fCurrentNegativeESDTrack->GetStatus() & AliESDtrack::kITSrefit) || \r
- // !(fCurrentPositiveESDTrack->GetStatus() & AliESDtrack::kITSrefit) ){\r
- \r
- iResult=kFALSE;\r
- if(fHistograms != NULL){\r
- fHistograms->FillHistogram("ESD_CutRefit_InvMass",GetMotherCandidateMass());\r
- }\r
- }\r
- \r
- \r
- if( fCurrentNegativeESDTrack->GetKinkIndex(0) > 0 || \r
- fCurrentPositiveESDTrack->GetKinkIndex(0) > 0) { \r
- \r
- iResult=kFALSE;\r
- if(fHistograms != NULL){\r
- fHistograms->FillHistogram("ESD_CutKink_InvMass",GetMotherCandidateMass());\r
- }\r
- }\r
-\r
-\r
- \r
- if(fCurrentNegativeKFParticle != NULL){\r
- delete fCurrentNegativeKFParticle;\r
- }\r
- if(switchTracks == kFALSE){\r
- fCurrentNegativeKFParticle = new AliKFParticle(*(fCurrentV0->GetParamN()),fNegativeTrackPID);\r
- }\r
- else{\r
- fCurrentNegativeKFParticle = new AliKFParticle(*(fCurrentV0->GetParamP()),fNegativeTrackPID);\r
- }\r
-\r
- if(fCurrentPositiveKFParticle != NULL){\r
- delete fCurrentPositiveKFParticle;\r
- }\r
- if(switchTracks == kFALSE){\r
- fCurrentPositiveKFParticle = new AliKFParticle(*(fCurrentV0->GetParamP()),fPositiveTrackPID);\r
- }\r
- else{\r
- fCurrentPositiveKFParticle = new AliKFParticle(*(fCurrentV0->GetParamN()),fPositiveTrackPID);\r
- }\r
- \r
- if(fCurrentMotherKFCandidate != NULL){\r
- delete fCurrentMotherKFCandidate;\r
- }\r
- fCurrentMotherKFCandidate = new AliKFParticle(*fCurrentNegativeKFParticle,*fCurrentPositiveKFParticle);\r
-\r
-\r
- if(fPositiveTrackPID==-11 && fNegativeTrackPID==11){\r
- fCurrentMotherKFCandidate->SetMassConstraint(0,fNSigmaMass);\r
- }\r
- \r
- \r
- \r
- \r
- if(fUseImprovedVertex == kTRUE){\r
- AliKFVertex primaryVertexImproved(*GetPrimaryVertex());\r
- primaryVertexImproved+=*fCurrentMotherKFCandidate;\r
- fCurrentMotherKFCandidate->SetProductionVertex(primaryVertexImproved);\r
- }\r
- \r
- fCurrentMotherKFCandidate->GetMass(fMotherCandidateKFMass,fMotherCandidateKFWidth);\r
- \r
- \r
- if(fNegativeTrackLorentzVector != NULL){\r
- delete fNegativeTrackLorentzVector;\r
- }\r
- if(fUseKFParticle){\r
- fNegativeTrackLorentzVector = new TLorentzVector(fCurrentNegativeKFParticle->Px(),fCurrentNegativeKFParticle->Py(),fCurrentNegativeKFParticle->Pz());\r
- }\r
- else if(fUseESDTrack){\r
- fNegativeTrackLorentzVector = new TLorentzVector(fCurrentNegativeESDTrack->Px(),fCurrentNegativeESDTrack->Py(),fCurrentNegativeESDTrack->Pz());\r
- }\r
- \r
- if(fPositiveTrackLorentzVector != NULL){\r
- delete fPositiveTrackLorentzVector;\r
- }\r
- if(fUseKFParticle){\r
- fPositiveTrackLorentzVector = new TLorentzVector(fCurrentPositiveKFParticle->Px(),fCurrentPositiveKFParticle->Py(),fCurrentPositiveKFParticle->Pz());\r
- }\r
- else if(fUseESDTrack){\r
- fPositiveTrackLorentzVector = new TLorentzVector(fCurrentPositiveESDTrack->Px(),fCurrentPositiveESDTrack->Py(),fCurrentPositiveESDTrack->Pz());\r
- }\r
- \r
- if(fMotherCandidateLorentzVector != NULL){\r
- delete fMotherCandidateLorentzVector;\r
- }\r
- if(fUseKFParticle){\r
- fMotherCandidateLorentzVector = new TLorentzVector(*fNegativeTrackLorentzVector + *fPositiveTrackLorentzVector);\r
- }\r
- else if(fUseESDTrack){\r
- fMotherCandidateLorentzVector = new TLorentzVector(*fNegativeTrackLorentzVector + *fPositiveTrackLorentzVector);\r
- }\r
- \r
- if(fPositiveTrackPID==-11 && fNegativeTrackPID==11){\r
- fMotherCandidateLorentzVector->SetXYZM(fMotherCandidateLorentzVector->Px() ,fMotherCandidateLorentzVector->Py(),fMotherCandidateLorentzVector->Pz(),0.); \r
- }\r
- \r
- \r
- if(fDoMC == kTRUE){\r
- fMotherMCParticle= NULL;\r
- fNegativeMCParticle = fMCStack->Particle(TMath::Abs(fESDEvent->GetTrack(fCurrentV0->GetNindex())->GetLabel()));\r
- fPositiveMCParticle = fMCStack->Particle(TMath::Abs(fESDEvent->GetTrack(fCurrentV0->GetPindex())->GetLabel()));\r
- if(fPositiveMCParticle->GetMother(0)>-1){\r
- fMotherMCParticle = fMCStack->Particle(fPositiveMCParticle->GetMother(0));\r
- }\r
- }\r
- \r
- // if(iResult==kTRUE){\r
- // fCurrentEventGoodV0s.push_back(*fCurrentMotherKFCandidate); // moved it to NextV0() after all the cuts are applied\r
- // }\r
-\r
- return iResult;\r
-}\r
-\r
-\r
-\r
-Bool_t AliV0Reader::HasSameMCMother(){\r
- //see header file for documentation\r
- \r
- Bool_t iResult = kFALSE;\r
- if(fDoMC == kTRUE){\r
- if(fNegativeMCParticle != NULL && fPositiveMCParticle != NULL){\r
- if(fNegativeMCParticle->GetMother(0) == fPositiveMCParticle->GetMother(0))\r
- if(fMotherMCParticle){\r
- iResult = kTRUE;\r
- }\r
- }\r
- }\r
- return iResult;\r
-}\r
-\r
-Bool_t AliV0Reader::CheckPIDProbability(Double_t negProbCut, Double_t posProbCut){\r
- //see header file for documentation\r
- \r
- Bool_t iResult=kFALSE;\r
- \r
- Double_t *posProbArray = new Double_t[10];\r
- Double_t *negProbArray = new Double_t[10];\r
- AliESDtrack* negTrack = fESDEvent->GetTrack(fCurrentV0->GetNindex());\r
- AliESDtrack* posTrack = fESDEvent->GetTrack(fCurrentV0->GetPindex());\r
- \r
- negTrack->GetTPCpid(negProbArray);\r
- posTrack->GetTPCpid(posProbArray);\r
- \r
- if(negProbArray!=NULL && posProbArray!=NULL){\r
- if(negProbArray[GetSpeciesIndex(-1)]>=negProbCut && posProbArray[GetSpeciesIndex(1)]>=posProbCut){\r
- iResult=kTRUE;\r
- }\r
- }\r
- delete [] posProbArray;\r
- delete [] negProbArray;\r
- return iResult;\r
-}\r
-\r
-void AliV0Reader::GetPIDProbability(Double_t &negPIDProb,Double_t & posPIDProb){\r
- \r
- Double_t *posProbArray = new Double_t[10];\r
- Double_t *negProbArray = new Double_t[10];\r
- AliESDtrack* negTrack = fESDEvent->GetTrack(fCurrentV0->GetNindex());\r
- AliESDtrack* posTrack = fESDEvent->GetTrack(fCurrentV0->GetPindex());\r
- \r
- negTrack->GetTPCpid(negProbArray);\r
- posTrack->GetTPCpid(posProbArray);\r
- \r
- if(negProbArray!=NULL && posProbArray!=NULL){\r
- negPIDProb = negProbArray[GetSpeciesIndex(-1)];\r
- posPIDProb = posProbArray[GetSpeciesIndex(1)];\r
- }\r
- delete [] posProbArray;\r
- delete [] negProbArray;\r
-}\r
-\r
-void AliV0Reader::UpdateEventByEventData(){\r
- //see header file for documentation\r
- \r
- if(fCurrentEventGoodV0s.size() >0 ){\r
- // fPreviousEventGoodV0s.clear();\r
- // fPreviousEventGoodV0s = fCurrentEventGoodV0s;\r
- if(fPreviousEventGoodV0s.size()>19){\r
- for(UInt_t nCurrent=0;nCurrent<fCurrentEventGoodV0s.size();nCurrent++){\r
- fPreviousEventGoodV0s.erase(fPreviousEventGoodV0s.begin());\r
- fPreviousEventGoodV0s.push_back(fCurrentEventGoodV0s.at(nCurrent));\r
- }\r
- }\r
- else{\r
- for(UInt_t nCurrent=0;nCurrent<fCurrentEventGoodV0s.size();nCurrent++){\r
- if(fPreviousEventGoodV0s.size()<20){\r
- fPreviousEventGoodV0s.push_back(fCurrentEventGoodV0s.at(nCurrent));\r
- }\r
- else{\r
- fPreviousEventGoodV0s.erase(fPreviousEventGoodV0s.begin());\r
- fPreviousEventGoodV0s.push_back(fCurrentEventGoodV0s.at(nCurrent));\r
- }\r
- }\r
- }\r
- }\r
- fCurrentEventGoodV0s.clear();\r
- \r
- fCurrentV0IndexNumber=0;\r
-}\r
-\r
-\r
-Double_t AliV0Reader::GetNegativeTrackPhi() const{\r
- //see header file for documentation\r
- \r
- Double_t offset=0;\r
- if(fNegativeTrackLorentzVector->Phi()> TMath::Pi()){\r
- offset = -2*TMath::Pi();\r
- }\r
- return fNegativeTrackLorentzVector->Phi()+offset;\r
-}\r
-\r
-Double_t AliV0Reader::GetPositiveTrackPhi() const{\r
- //see header file for documentation\r
- \r
- Double_t offset=0;\r
- if(fPositiveTrackLorentzVector->Phi()> TMath::Pi()){\r
- offset = -2*TMath::Pi();\r
- }\r
- return fPositiveTrackLorentzVector->Phi()+offset;\r
-}\r
-\r
-Double_t AliV0Reader::GetMotherCandidatePhi() const{\r
- //see header file for documentation\r
- \r
- Double_t offset=0;\r
- if(fMotherCandidateLorentzVector->Phi()> TMath::Pi()){\r
- offset = -2*TMath::Pi();\r
- }\r
- return fMotherCandidateLorentzVector->Phi()+offset;\r
-}\r
-\r
-\r
-Double_t AliV0Reader::GetMotherCandidateRapidity() const{\r
- //see header file for documentation\r
- \r
- Double_t rapidity=0;\r
- if(fMotherCandidateLorentzVector->Energy() - fMotherCandidateLorentzVector->Pz() == 0 || fMotherCandidateLorentzVector->Energy() + fMotherCandidateLorentzVector->Pz() == 0) rapidity=0;\r
- else rapidity = 0.5*(TMath::Log((fMotherCandidateLorentzVector->Energy() + fMotherCandidateLorentzVector->Pz()) / (fMotherCandidateLorentzVector->Energy()-fMotherCandidateLorentzVector->Pz())));\r
- return rapidity;\r
- \r
-}\r
-\r
-\r
-\r
-\r
-\r
-Int_t AliV0Reader::GetSpeciesIndex(Int_t chargeOfTrack){\r
- //see header file for documentation\r
- \r
- Int_t iResult = 10; // Unknown particle\r
- \r
- if(chargeOfTrack==-1){ //negative track\r
- switch(abs(fNegativeTrackPID)){\r
- case 11: //electron\r
- iResult = 0;\r
- break;\r
- case 13: //muon\r
- iResult = 1;\r
- break;\r
- case 211: //pion\r
- iResult = 2;\r
- break;\r
- case 321: //kaon\r
- iResult = 3;\r
- break;\r
- case 2212: //proton\r
- iResult = 4;\r
- break;\r
- case 22: //photon\r
- iResult = 5;\r
- break;\r
- case 111: //pi0\r
- iResult = 6;\r
- break;\r
- case 2112: //neutron\r
- iResult = 7;\r
- break;\r
- case 311: //K0\r
- iResult = 8;\r
- break;\r
- \r
- //Put in here for kSPECIES::kEleCon ????\r
- }\r
- }\r
- else if(chargeOfTrack==1){ //positive track\r
- switch(abs(fPositiveTrackPID)){\r
- case 11: //electron\r
- iResult = 0;\r
- break;\r
- case 13: //muon\r
- iResult = 1;\r
- break;\r
- case 211: //pion\r
- iResult = 2;\r
- break;\r
- case 321: //kaon\r
- iResult = 3;\r
- break;\r
- case 2212: //proton\r
- iResult = 4;\r
- break;\r
- case 22: //photon\r
- iResult = 5;\r
- break;\r
- case 111: //pi0\r
- iResult = 6;\r
- break;\r
- case 2112: //neutron\r
- iResult = 7;\r
- break;\r
- case 311: //K0\r
- iResult = 8;\r
- break;\r
- \r
- //Put in here for kSPECIES::kEleCon ????\r
- }\r
- }\r
- else{\r
- //Wrong parameter.. Print warning\r
- }\r
- return iResult;\r
-}\r
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * *
+ * Author: Ana Marin, Kathrin Koch, Kenneth Aamodt *
+ * Version 1.0 *
+ * *
+ * Permission to use, copy, modify and distribute this software and its *
+ * documentation strictly for non-commercial purposes is hereby granted *
+ * without fee, provided that the above copyright notice appears in all *
+ * copies and that both the copyright notice and this permission notice *
+ * appear in the supporting documentation. The authors make no claims *
+ * about the suitability of this software for any purpose. It is *
+ * provided "as is" without express or implied warranty. *
+ **************************************************************************/
+
+////////////////////////////////////////////////
+//---------------------------------------------
+// Class used to do analysis on conversion pairs
+//---------------------------------------------
+////////////////////////////////////////////////
+
+// --- ROOT system ---
+#include <TMath.h>
+
+//---- ANALYSIS system ----
+#include "AliV0Reader.h"
+#include "AliAnalysisManager.h"
+#include "AliESDInputHandler.h"
+#include "AliESDtrack.h"
+#include "AliMCEvent.h"
+#include "AliKFVertex.h"
+
+#include "AliStack.h"
+#include "AliMCEventHandler.h"
+
+
+class iostream;
+class AliESDv0;
+class TFormula;
+
+using namespace std;
+
+ClassImp(AliV0Reader)
+
+
+
+AliV0Reader::AliV0Reader() :
+ TObject(),
+ fMCStack(NULL),
+ fMCTruth(NULL),
+ fMCEvent(NULL), // for CF
+ fChain(NULL),
+ fESDHandler(NULL),
+ fESDEvent(NULL),
+ fHistograms(NULL),
+ fCurrentV0IndexNumber(0),
+ fCurrentV0(NULL),
+ fCurrentNegativeKFParticle(NULL),
+ fCurrentPositiveKFParticle(NULL),
+ fCurrentMotherKFCandidate(NULL),
+ fCurrentNegativeESDTrack(NULL),
+ fCurrentPositiveESDTrack(NULL),
+ fNegativeTrackLorentzVector(NULL),
+ fPositiveTrackLorentzVector(NULL),
+ fMotherCandidateLorentzVector(NULL),
+ fCurrentXValue(0),
+ fCurrentYValue(0),
+ fCurrentZValue(0),
+ fPositiveTrackPID(0),
+ fNegativeTrackPID(0),
+ fNegativeMCParticle(NULL),
+ fPositiveMCParticle(NULL),
+ fMotherMCParticle(NULL),
+ fMotherCandidateKFMass(0),
+ fMotherCandidateKFWidth(0),
+ fUseKFParticle(kTRUE),
+ fUseESDTrack(kFALSE),
+ fDoMC(kFALSE),
+ fMaxR(10000),// 100 meter(outside of ALICE)
+ fEtaCut(0.),
+ fPtCut(0.),
+ fMaxZ(0.),
+ fLineCutZRSlope(0.),
+ fLineCutZValue(0.),
+ fChi2CutConversion(0.),
+ fChi2CutMeson(0.),
+ fPIDProbabilityCutNegativeParticle(0),
+ fPIDProbabilityCutPositiveParticle(0),
+ fXVertexCut(0.),
+ fYVertexCut(0.),
+ fZVertexCut(0.),
+ fNSigmaMass(0.),
+ fUseImprovedVertex(kFALSE),
+ fUseOwnXYZCalculation(kFALSE),
+ fCurrentEventGoodV0s(),
+ fPreviousEventGoodV0s()
+{
+
+}
+
+
+AliV0Reader::AliV0Reader(const AliV0Reader & original) :
+ TObject(original),
+ fMCStack(original.fMCStack),
+ fMCTruth(original.fMCTruth),
+ fMCEvent(original.fMCEvent), // for CF
+ fChain(original.fChain),
+ fESDHandler(original.fESDHandler),
+ fESDEvent(original.fESDEvent),
+ fHistograms(original.fHistograms),
+ fCurrentV0IndexNumber(original.fCurrentV0IndexNumber),
+ fCurrentV0(original.fCurrentV0),
+ fCurrentNegativeKFParticle(original.fCurrentNegativeKFParticle),
+ fCurrentPositiveKFParticle(original.fCurrentPositiveKFParticle),
+ fCurrentMotherKFCandidate(original.fCurrentMotherKFCandidate),
+ fCurrentNegativeESDTrack(original.fCurrentNegativeESDTrack),
+ fCurrentPositiveESDTrack(original.fCurrentPositiveESDTrack),
+ fNegativeTrackLorentzVector(original.fNegativeTrackLorentzVector),
+ fPositiveTrackLorentzVector(original.fPositiveTrackLorentzVector),
+ fMotherCandidateLorentzVector(original.fMotherCandidateLorentzVector),
+ fCurrentXValue(original.fCurrentXValue),
+ fCurrentYValue(original.fCurrentYValue),
+ fCurrentZValue(original.fCurrentZValue),
+ fPositiveTrackPID(original.fPositiveTrackPID),
+ fNegativeTrackPID(original.fNegativeTrackPID),
+ fNegativeMCParticle(original.fNegativeMCParticle),
+ fPositiveMCParticle(original.fPositiveMCParticle),
+ fMotherMCParticle(original.fMotherMCParticle),
+ fMotherCandidateKFMass(original.fMotherCandidateKFMass),
+ fMotherCandidateKFWidth(original.fMotherCandidateKFWidth),
+ fUseKFParticle(kTRUE),
+ fUseESDTrack(kFALSE),
+ fDoMC(kFALSE),
+ fMaxR(original.fMaxR),
+ fEtaCut(original.fEtaCut),
+ fPtCut(original.fPtCut),
+ fMaxZ(original.fMaxZ),
+ fLineCutZRSlope(original.fLineCutZRSlope),
+ fLineCutZValue(original.fLineCutZValue),
+ fChi2CutConversion(original.fChi2CutConversion),
+ fChi2CutMeson(original.fChi2CutMeson),
+ fPIDProbabilityCutNegativeParticle(original.fPIDProbabilityCutNegativeParticle),
+ fPIDProbabilityCutPositiveParticle(original.fPIDProbabilityCutPositiveParticle),
+ fXVertexCut(original.fXVertexCut),
+ fYVertexCut(original.fYVertexCut),
+ fZVertexCut(original.fZVertexCut),
+ fNSigmaMass(original.fNSigmaMass),
+ fUseImprovedVertex(original.fUseImprovedVertex),
+ fUseOwnXYZCalculation(original.fUseOwnXYZCalculation),
+ fCurrentEventGoodV0s(original.fCurrentEventGoodV0s),
+ fPreviousEventGoodV0s(original.fPreviousEventGoodV0s)
+{
+
+}
+
+
+AliV0Reader & AliV0Reader::operator = (const AliV0Reader & /*source*/)
+{
+ // assignment operator
+ return *this;
+}
+
+void AliV0Reader::Initialize(){
+ //see header file for documentation
+
+ // Get the input handler from the manager
+ fESDHandler = (AliESDInputHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
+ 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
+ }
+
+
+ // for CF
+ //Get pointer to the mc event
+ fMCEvent = fMCTruth->MCEvent();
+ if(fMCEvent == 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(fCurrentV0IndexNumber<fESDEvent->GetNumberOfV0s()){
+ fCurrentV0 = fESDEvent->GetV0(fCurrentV0IndexNumber);
+
+ // moved it up here so that the correction framework can access pt and eta information
+ if(UpdateV0Information() == kFALSE){
+ fCurrentV0IndexNumber++;
+ continue;
+ }
+
+ Double_t containerInput[3];
+ containerInput[0] = GetMotherCandidatePt();
+ containerInput[1] = GetMotherCandidateEta();
+ containerInput[2] = GetMotherCandidateMass();
+
+
+ //checks if on the fly mode is set
+ if ( !fCurrentV0->GetOnFlyStatus() ){
+ if(fHistograms != NULL){
+ fHistograms->FillHistogram("ESD_CutGetOnFly_InvMass",GetMotherCandidateMass());
+ }
+ fCurrentV0IndexNumber++;
+ continue;
+ }
+ fCFManager->GetParticleContainer()->Fill(containerInput,kStepGetOnFly); // for CF
+
+ //checks if we have a prim vertex
+ if(fESDEvent->GetPrimaryVertex()->GetNContributors()<=0) {
+ if(fHistograms != NULL){
+ fHistograms->FillHistogram("ESD_CutNContributors_InvMass",GetMotherCandidateMass());
+ }
+ fCurrentV0IndexNumber++;
+ continue;
+ }
+ fCFManager->GetParticleContainer()->Fill(containerInput,kStepNContributors); // for CF
+
+
+ //Check the pid probability
+ if(CheckPIDProbability(fPIDProbabilityCutNegativeParticle,fPIDProbabilityCutPositiveParticle)==kFALSE){
+ if(fHistograms != NULL){
+ fHistograms->FillHistogram("ESD_CutPIDProb_InvMass",GetMotherCandidateMass());
+ }
+ fCurrentV0IndexNumber++;
+ continue;
+ }
+ fCFManager->GetParticleContainer()->Fill(containerInput,kStepTPCPID); // for CF
+
+
+
+
+ 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;
+ }
+ fCFManager->GetParticleContainer()->Fill(containerInput,kStepR); // for CF
+
+
+
+ if((TMath::Abs(fCurrentZValue)*fLineCutZRSlope)-fLineCutZValue > GetXYRadius() ){ // cuts out regions where we do not reconstruct
+ if(fHistograms != NULL){
+ fHistograms->FillHistogram("ESD_CutLine_InvMass",GetMotherCandidateMass());
+ }
+ fCurrentV0IndexNumber++;
+ continue;
+ }
+ fCFManager->GetParticleContainer()->Fill(containerInput,kStepLine); // for CF
+
+
+ if(TMath::Abs(fCurrentZValue) > fMaxZ ){ // cuts out regions where we do not reconstruct
+ if(fHistograms != NULL){
+ fHistograms->FillHistogram("ESD_CutZ_InvMass",GetMotherCandidateMass());
+ }
+ fCurrentV0IndexNumber++;
+ continue;
+ }
+ fCFManager->GetParticleContainer()->Fill(containerInput,kStepZ); // for CF
+
+
+ /* Moved further up so corr framework can work
+ if(UpdateV0Information() == kFALSE){
+ fCurrentV0IndexNumber++;
+ continue;
+ }
+ */
+
+ if(fUseKFParticle){
+ if(fCurrentMotherKFCandidate->GetNDF()<=0){
+ if(fHistograms != NULL){
+ fHistograms->FillHistogram("ESD_CutNDF_InvMass",GetMotherCandidateMass());
+ }
+ fCurrentV0IndexNumber++;
+ continue;
+ }
+ fCFManager->GetParticleContainer()->Fill(containerInput,kStepNDF); // for CF
+
+
+ Double_t chi2V0 = fCurrentMotherKFCandidate->GetChi2()/fCurrentMotherKFCandidate->GetNDF();
+ if(chi2V0 > fChi2CutConversion || chi2V0 <=0){
+ if(fHistograms != NULL){
+ fHistograms->FillHistogram("ESD_CutChi2_InvMass",GetMotherCandidateMass());
+ }
+ fCurrentV0IndexNumber++;
+ continue;
+ }
+ fCFManager->GetParticleContainer()->Fill(containerInput,kStepChi2); // for CF
+
+
+ if(TMath::Abs(fMotherCandidateLorentzVector->Eta())> fEtaCut){
+ if(fHistograms != NULL){
+ fHistograms->FillHistogram("ESD_CutEta_InvMass",GetMotherCandidateMass());
+ }
+ fCurrentV0IndexNumber++;
+ continue;
+ }
+ fCFManager->GetParticleContainer()->Fill(containerInput,kStepEta); // for CF
+
+
+ if(fMotherCandidateLorentzVector->Pt()<fPtCut){
+ if(fHistograms != NULL){
+ fHistograms->FillHistogram("ESD_CutPt_InvMass",GetMotherCandidateMass());
+ }
+ fCurrentV0IndexNumber++;
+ continue;
+ }
+ fCFManager->GetParticleContainer()->Fill(containerInput,kStepPt); // for CF
+
+
+ }
+ else if(fUseESDTrack){
+ //TODO
+ }
+
+ fCurrentEventGoodV0s.push_back(*fCurrentMotherKFCandidate);
+
+ iResult=kTRUE;//means we have a v0 who survived all the cuts applied
+
+ fCurrentV0IndexNumber++;
+
+ break;
+ }
+ return iResult;
+}
+
+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;
+ }
+ if(switchTracks == kFALSE){
+ fCurrentNegativeKFParticle = new AliKFParticle(*(fCurrentV0->GetParamN()),fNegativeTrackPID);
+ }
+ else{
+ fCurrentNegativeKFParticle = new AliKFParticle(*(fCurrentV0->GetParamP()),fNegativeTrackPID);
+ }
+
+ if(fCurrentPositiveKFParticle != NULL){
+ delete fCurrentPositiveKFParticle;
+ }
+ 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);
+
+
+ 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;
+ }
+ if(fUseKFParticle){
+ fNegativeTrackLorentzVector = new TLorentzVector(fCurrentNegativeKFParticle->Px(),fCurrentNegativeKFParticle->Py(),fCurrentNegativeKFParticle->Pz());
+ }
+ else if(fUseESDTrack){
+ fNegativeTrackLorentzVector = new TLorentzVector(fCurrentNegativeESDTrack->Px(),fCurrentNegativeESDTrack->Py(),fCurrentNegativeESDTrack->Pz());
+ }
+
+ if(fPositiveTrackLorentzVector != NULL){
+ delete fPositiveTrackLorentzVector;
+ }
+ if(fUseKFParticle){
+ fPositiveTrackLorentzVector = new TLorentzVector(fCurrentPositiveKFParticle->Px(),fCurrentPositiveKFParticle->Py(),fCurrentPositiveKFParticle->Pz());
+ }
+ else if(fUseESDTrack){
+ fPositiveTrackLorentzVector = new TLorentzVector(fCurrentPositiveESDTrack->Px(),fCurrentPositiveESDTrack->Py(),fCurrentPositiveESDTrack->Pz());
+ }
+
+ if(fMotherCandidateLorentzVector != NULL){
+ delete fMotherCandidateLorentzVector;
+ }
+ if(fUseKFParticle){
+ fMotherCandidateLorentzVector = new TLorentzVector(*fNegativeTrackLorentzVector + *fPositiveTrackLorentzVector);
+ }
+ 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()));
+ fPositiveMCParticle = fMCStack->Particle(TMath::Abs(fESDEvent->GetTrack(fCurrentV0->GetPindex())->GetLabel()));
+ if(fPositiveMCParticle->GetMother(0)>-1){
+ fMotherMCParticle = fMCStack->Particle(fPositiveMCParticle->GetMother(0));
+ }
+ }
+
+ // if(iResult==kTRUE){
+ // fCurrentEventGoodV0s.push_back(*fCurrentMotherKFCandidate); // moved it to NextV0() after all the cuts are applied
+ // }
+
+
+ // for CF
+ Double_t containerInput[3];
+ containerInput[0] = GetMotherCandidatePt();
+ containerInput[1] = GetMotherCandidateEta();
+ containerInput[2] = GetMotherCandidateMass();
+
+ fCFManager->GetParticleContainer()->Fill(containerInput,kStepLikeSign); // for CF
+ fCFManager->GetParticleContainer()->Fill(containerInput,kStepTPCRefit); // for CF
+ fCFManager->GetParticleContainer()->Fill(containerInput,kStepKinks); // for CF
+
+ return iResult;
+}
+
+
+
+Bool_t AliV0Reader::HasSameMCMother(){
+ //see header file for documentation
+
+ Bool_t iResult = kFALSE;
+ if(fDoMC == kTRUE){
+ if(fNegativeMCParticle != NULL && fPositiveMCParticle != NULL){
+ if(fNegativeMCParticle->GetMother(0) == fPositiveMCParticle->GetMother(0))
+ if(fMotherMCParticle){
+ iResult = kTRUE;
+ }
+ }
+ }
+ return iResult;
+}
+
+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;
+ }
+ }
+ delete [] posProbArray;
+ delete [] negProbArray;
+ return iResult;
+}
+
+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)];
+ }
+ delete [] posProbArray;
+ delete [] negProbArray;
+}
+
+void AliV0Reader::UpdateEventByEventData(){
+ //see header file for documentation
+
+ if(fCurrentEventGoodV0s.size() >0 ){
+ // fPreviousEventGoodV0s.clear();
+ // fPreviousEventGoodV0s = fCurrentEventGoodV0s;
+ if(fPreviousEventGoodV0s.size()>19){
+ for(UInt_t nCurrent=0;nCurrent<fCurrentEventGoodV0s.size();nCurrent++){
+ fPreviousEventGoodV0s.erase(fPreviousEventGoodV0s.begin());
+ fPreviousEventGoodV0s.push_back(fCurrentEventGoodV0s.at(nCurrent));
+ }
+ }
+ else{
+ for(UInt_t nCurrent=0;nCurrent<fCurrentEventGoodV0s.size();nCurrent++){
+ if(fPreviousEventGoodV0s.size()<20){
+ fPreviousEventGoodV0s.push_back(fCurrentEventGoodV0s.at(nCurrent));
+ }
+ else{
+ fPreviousEventGoodV0s.erase(fPreviousEventGoodV0s.begin());
+ fPreviousEventGoodV0s.push_back(fCurrentEventGoodV0s.at(nCurrent));
+ }
+ }
+ }
+ }
+ fCurrentEventGoodV0s.clear();
+
+ fCurrentV0IndexNumber=0;
+}
+
+
+Double_t AliV0Reader::GetNegativeTrackPhi() const{
+ //see header file for documentation
+
+ Double_t offset=0;
+ if(fNegativeTrackLorentzVector->Phi()> TMath::Pi()){
+ offset = -2*TMath::Pi();
+ }
+ return fNegativeTrackLorentzVector->Phi()+offset;
+}
+
+Double_t AliV0Reader::GetPositiveTrackPhi() const{
+ //see header file for documentation
+
+ Double_t offset=0;
+ if(fPositiveTrackLorentzVector->Phi()> TMath::Pi()){
+ offset = -2*TMath::Pi();
+ }
+ return fPositiveTrackLorentzVector->Phi()+offset;
+}
+
+Double_t AliV0Reader::GetMotherCandidatePhi() const{
+ //see header file for documentation
+
+ Double_t offset=0;
+ if(fMotherCandidateLorentzVector->Phi()> TMath::Pi()){
+ offset = -2*TMath::Pi();
+ }
+ return fMotherCandidateLorentzVector->Phi()+offset;
+}
+
+
+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 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
+ iResult = 0;
+ break;
+ case 13: //muon
+ iResult = 1;
+ break;
+ case 211: //pion
+ iResult = 2;
+ break;
+ case 321: //kaon
+ iResult = 3;
+ break;
+ case 2212: //proton
+ iResult = 4;
+ break;
+ case 22: //photon
+ iResult = 5;
+ break;
+ case 111: //pi0
+ iResult = 6;
+ break;
+ case 2112: //neutron
+ iResult = 7;
+ break;
+ case 311: //K0
+ iResult = 8;
+ break;
+
+ //Put in here for kSPECIES::kEleCon ????
+ }
+ }
+ else if(chargeOfTrack==1){ //positive track
+ switch(abs(fPositiveTrackPID)){
+ case 11: //electron
+ iResult = 0;
+ break;
+ case 13: //muon
+ iResult = 1;
+ break;
+ case 211: //pion
+ iResult = 2;
+ break;
+ case 321: //kaon
+ iResult = 3;
+ break;
+ case 2212: //proton
+ iResult = 4;
+ break;
+ case 22: //photon
+ iResult = 5;
+ break;
+ case 111: //pi0
+ iResult = 6;
+ break;
+ case 2112: //neutron
+ iResult = 7;
+ break;
+ case 311: //K0
+ iResult = 8;
+ break;
+
+ //Put in here for kSPECIES::kEleCon ????
+ }
+ }
+ else{
+ //Wrong parameter.. Print warning
+ }
+ return iResult;
+}
+
+Bool_t GetHelixCenter(AliESDtrack* track, Double_t b,Int_t charge, Double_t center[2]){
+ // see header file for documentation
+
+ Double_t pi = 3.14159265358979323846;
+
+ Double_t helix[6];
+ track->GetHelixParameters(helix,b);
+
+ Double_t xpos = helix[5];
+ Double_t ypos = helix[0];
+ Double_t radius = TMath::Abs(1./helix[4]);
+ Double_t phi = helix[2];
+
+ if(phi < 0){
+ phi = phi + 2*pi;
+ }
+
+ phi -= pi/2.;
+ Double_t xpoint = radius * TMath::Cos(phi);
+ Double_t ypoint = radius * TMath::Sin(phi);
+
+ if(charge > 0){
+ xpoint = - xpoint;
+ ypoint = - ypoint;
+ }
+
+ if(charge < 0){
+ xpoint = xpoint;
+ ypoint = ypoint;
+ }
+ center[0] = xpos + xpoint;
+ center[1] = ypos + ypoint;
+
+ return 1;
+}
+
+Bool_t GetConvPosXY(AliESDtrack* ptrack,AliESDtrack* ntrack, Double_t b, Double_t convpos[2]){
+ //see header file for documentation
+
+ Double_t helixcenterpos[2];
+ GetHelixCenter(ptrack,b,ptrack->Charge(),helixcenterpos);
+
+ Double_t helixcenterneg[2];
+ GetHelixCenter(ntrack,b,ntrack->Charge(),helixcenterneg);
+
+ Double_t poshelix[6];
+ ptrack->GetHelixParameters(poshelix,b);
+ Double_t posradius = TMath::Abs(1./poshelix[4]);
+
+ Double_t neghelix[6];
+ ntrack->GetHelixParameters(neghelix,b);
+ Double_t negradius = TMath::Abs(1./neghelix[4]);
+
+ Double_t xpos = helixcenterpos[0];
+ Double_t ypos = helixcenterpos[1];
+ Double_t xneg = helixcenterneg[0];
+ Double_t yneg = helixcenterneg[1];
+
+ convpos[0] = (xpos*negradius + xneg*posradius)/(negradius+posradius);
+ convpos[1] = (ypos*negradius+ yneg*posradius)/(negradius+posradius);
+
+ return 1;
+}
+
+
+
+Double_t GetConvPosZ(AliESDtrack* ptrack,AliESDtrack* ntrack, Double_t b){
+ //see header file for documentation
+
+ Double_t helixpos[6];
+ ptrack->GetHelixParameters(helixpos,b);
+
+ Double_t helixneg[6];
+ ntrack->GetHelixParameters(helixneg,b);
+
+ Double_t negtrackradius = TMath::Abs(1./helixneg[4]);
+ Double_t postrackradius = TMath::Abs(1./helixpos[4]);
+
+ Double_t pi = 3.14159265358979323846;
+
+ Double_t convpos[2];
+ GetConvPosXY(ptrack,ntrack,b,convpos);
+
+ Double_t convposx = convpos[0];
+ Double_t convposy = convpos[1];
+
+ Double_t helixcenterpos[2];
+ GetHelixCenter(ptrack,b,ptrack->Charge(),helixcenterpos);
+
+ Double_t helixcenterneg[2];
+ GetHelixCenter(ntrack,b,ntrack->Charge(),helixcenterneg);
+
+ Double_t xpos = helixcenterpos[0];
+ Double_t ypos = helixcenterpos[1];
+ Double_t xneg = helixcenterneg[0];
+ Double_t yneg = helixcenterneg[1];
+
+ Double_t delta_x_pos = convposx - xpos;
+ Double_t delta_y_pos = convposy - ypos;
+
+ Double_t delta_x_neg = convposx - xneg;
+ Double_t delta_y_neg = convposy - yneg;
+
+ Double_t alpha_pos = pi + TMath::ATan2(-delta_y_pos,-delta_x_pos);
+ Double_t alpha_neg = pi + TMath::ATan2(-delta_y_neg,-delta_x_neg);
+
+ Double_t vertex_x_neg = xneg + TMath::Abs(negtrackradius)*
+ TMath::Cos(alpha_neg);
+ Double_t vertex_y_neg = yneg + TMath::Abs(negtrackradius)*
+ TMath::Sin(alpha_neg);
+
+ Double_t vertex_x_pos = xpos + TMath::Abs(postrackradius)*
+ TMath::Cos(alpha_pos);
+ Double_t vertex_y_pos = ypos + TMath::Abs(postrackradius)*
+ TMath::Sin(alpha_pos);
+
+ Double_t x0neg = helixneg[5];
+ Double_t y0neg = helixneg[0];
+
+ Double_t x0pos = helixpos[5];
+ Double_t y0pos = helixpos[0];
+
+ Double_t d_neg = TMath::Sqrt((vertex_x_neg - x0neg)*(vertex_x_neg - x0neg)
+ +(vertex_y_neg - y0neg)*(vertex_y_neg - y0neg));
+
+ Double_t d_pos = TMath::Sqrt((vertex_x_pos - x0pos)*(vertex_x_pos - x0pos)
+ +(vertex_y_pos - y0pos)*(vertex_y_pos - y0pos));
+
+ Double_t r_neg = TMath::Sqrt(negtrackradius*negtrackradius -
+ d_neg*d_neg/4.);
+
+ Double_t r_pos = TMath::Sqrt(postrackradius*postrackradius -
+ d_pos*d_pos/4.);
+
+ Double_t deltabeta_neg = 2*(pi + TMath::ATan2(-d_neg/2.,-r_neg));
+ Double_t deltabeta_pos = 2*(pi + TMath::ATan2(-d_pos/2.,-r_pos));
+
+ Double_t delta_U_neg = negtrackradius*deltabeta_neg;
+ Double_t delta_U_pos = postrackradius*deltabeta_pos;
+
+ Double_t zphase_neg = ntrack->GetZ() + delta_U_neg * ntrack->GetTgl();
+ Double_t zphase_pos = ptrack->GetZ() + delta_U_pos * ptrack->GetTgl();
+
+ Double_t convposz =
+ (zphase_pos*negtrackradius+zphase_neg*postrackradius)/(negtrackradius+postrackradius);
+
+ return convposz;
+}
-#ifndef ALIV0READER_H\r
-#define ALIV0READER_H\r
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *\r
- * See cxx source for full Copyright notice */\r
-\r
-////////////////////////////////////////////////\r
-//--------------------------------------------- \r
-// Class used to do analysis on conversion pairs\r
-//---------------------------------------------\r
-////////////////////////////////////////////////\r
-\r
-// --- ROOT system ---\r
-#include "TObject.h" \r
-#include "AliESDv0.h"\r
-#include "AliESDEvent.h"\r
-#include "AliKFParticle.h"\r
-#include "TParticle.h"\r
-#include "AliGammaConversionHistograms.h"\r
-#include <vector>\r
-\r
-class TClonesArray; \r
-class TFormula;\r
-class Riostream;\r
-class TChain;\r
-//--- AliRoot system ---\r
-\r
-class AliStack;\r
-class AliESDEvent; \r
-class AliMCEventHandler;\r
-class AliESDInputHandler;\r
-class AliESDVertex;\r
-class AliLog;\r
-class TChain;\r
-class TChain;\r
-\r
-\r
-\r
-class AliV0Reader : public TObject {\r
-\r
- public: \r
-\r
- AliV0Reader(); //constructor\r
- AliV0Reader(const AliV0Reader & g); //copy constructor\r
- AliV0Reader & operator = (const AliV0Reader & g); //assignment operator\r
- virtual ~AliV0Reader() {;} //virtual destructor\r
- /*\r
- *Initialize the reader\r
- */\r
- void Initialize();\r
-\r
- /*\r
- * Returns AliESDEvent\r
- */ \r
- AliESDEvent* GetESDEvent() const{return fESDEvent;} \r
-\r
- /*\r
- *Returns the number of v0s in the event, no cuts applied.\r
- */\r
- Int_t GetNumberOfV0s() const{return fESDEvent->GetNumberOfV0s();}\r
-\r
- /*\r
- * Check if there are any more good v0s left in the v0 stack\r
- * if so, fCurrent v0 is set to this v0 and can be retrieved\r
- * by GetCurrentV0 function.\r
- * returns kFALSE if there is no more good v0s in the v0 stack\r
- */\r
- Bool_t NextV0();\r
- \r
- /*\r
- * Returns the v0 at the given index, no checks are done on the v0. \r
- */\r
- AliESDv0* GetV0(Int_t index);\r
-\r
- /*\r
- * Returns the current v0\r
- */\r
- AliESDv0* GetCurrentV0() const{return fCurrentV0;}\r
-\r
- /*\r
- * Returns the negative ESD track which belongs to fCurrentV0\r
- */\r
- AliESDtrack* GetNegativeESDTrack(){return fESDEvent->GetTrack(fCurrentV0->GetNindex());}\r
-\r
- /*\r
- * Returns the positive ESD track which belongs to fCurrentV0\r
- */\r
- AliESDtrack* GetPositiveESDTrack(){return fESDEvent->GetTrack(fCurrentV0->GetPindex());}\r
-\r
- /*\r
- * Returns the negative KF particle which belongs to fCurrentV0\r
- */\r
- AliKFParticle* GetNegativeKFParticle() const{return fCurrentNegativeKFParticle;}\r
-\r
- /*\r
- * Returns the positive KF particle which belongs to fCurrentV0\r
- */\r
- AliKFParticle* GetPositiveKFParticle() const{return fCurrentPositiveKFParticle;}\r
-\r
- /*\r
- * Returns the KFParticle object of the 2 tracks.\r
- */\r
- AliKFParticle* GetMotherCandidateKFCombination() const{return fCurrentMotherKFCandidate;}\r
-\r
- /*\r
- * Checks the probablity that the PID of the particle is what we want it to be.\r
- */\r
- Bool_t CheckPIDProbability(Double_t negProbCut, Double_t posProbCut);\r
- \r
- /*\r
- * Checks if the PID of the two particles are within our cuts.\r
- */\r
- void GetPIDProbability(Double_t &negPIDProb, Double_t &posPIDProb);\r
-\r
- /*\r
- *Get the negative MC TParticle from the stack \r
- */\r
- TParticle * GetNegativeMCParticle() const{return fNegativeMCParticle;}\r
-\r
- /*\r
- *Get the positive MC TParticle from the stack \r
- */\r
- TParticle * GetPositiveMCParticle() const{return fPositiveMCParticle;}\r
-\r
- /*\r
- *Get the mother MC TParticle from the stack \r
- */\r
- TParticle * GetMotherMCParticle() const{return fMotherMCParticle;}\r
-\r
- /*\r
- * Flag to see if the v0 particles share the same mother\r
- */\r
- Bool_t HasSameMCMother();\r
-\r
-\r
- /*\r
- *Get the PID of the MC mother particle\r
- */\r
- Int_t GetMotherMCParticlePDGCode() const{if(fMotherMCParticle != NULL){ cout<<"MCParticle exists"<<endl;} return fMotherMCParticle->GetPdgCode();}\r
-\r
- /*\r
- *Get the MC stack \r
- */\r
- AliStack* GetMCStack() const{return fMCStack;}\r
-\r
- /*\r
- *Get the magnetic field from the ESD event \r
- */\r
- Double_t GetMagneticField() const{return fESDEvent->GetMagneticField();}\r
-\r
- /*\r
- *Get the primary vertex from the esd event\r
- */\r
- const AliESDVertex *GetPrimaryVertex() const {return fESDEvent->GetPrimaryVertex();}\r
-\r
- /*\r
- * Set the PID of the negative track\r
- */\r
- void SetNegativeTrackPID(Int_t negTrackPID){fNegativeTrackPID=negTrackPID;}\r
-\r
- /*\r
- * Set the PID of the positive track\r
- */\r
- void SetPositiveTrackPID(Int_t posTrackPID){fPositiveTrackPID=posTrackPID;}\r
-\r
- /*\r
- * Set the flag to use the kfparticle class. Will also disable the use of esd tracks\r
- */\r
- void UseKFParticle(){fUseKFParticle = kTRUE; fUseESDTrack = kFALSE;}\r
-\r
- /*\r
- * Set the flag to use the esd track class. Will also disable the use of kf particles\r
- */\r
- void UseESDTrack(){fUseESDTrack = kTRUE; fUseKFParticle = kFALSE;}\r
-\r
- /*\r
- * Set the flag to use improved vertex or not\r
- */\r
- void SetUseImprovedVertex(Bool_t useImprovedVertex){fUseImprovedVertex=useImprovedVertex;}\r
-\r
- /*\r
- * Return the number in the species array belonging to the negative or positive track pid.\r
- */\r
- Int_t GetSpeciesIndex(Int_t chargeOfTrack);\r
-\r
- /*\r
- * Return the x coordinate of the v0\r
- */\r
- Double_t GetX() const{return fCurrentXValue;}\r
-\r
- /*\r
- * Return the y coordinate of the v0\r
- */\r
- Double_t GetY() const{return fCurrentYValue;}\r
-\r
- /*\r
- * Return the Z coordinate of the v0\r
- */\r
- Double_t GetZ() const{return fCurrentZValue;}\r
-\r
- /*\r
- * Return the radius of the v0\r
- */\r
- Double_t GetXYRadius() const{return sqrt((Double_t)(fCurrentXValue*fCurrentXValue + fCurrentYValue*fCurrentYValue));}\r
-\r
- /*\r
- * Get the opening angle between the two tracks\r
- */\r
- Double_t GetOpeningAngle(){return fNegativeTrackLorentzVector->Angle(fPositiveTrackLorentzVector->Vect());}\r
-\r
- /*\r
- * Gets the Energy of the negative track.\r
- */\r
- Double_t GetNegativeTrackEnergy() const{return fCurrentNegativeKFParticle->E();}\r
-\r
- /*\r
- * Gets the Energy of the positive track.\r
- */\r
- Double_t GetPositiveTrackEnergy() const{return fCurrentPositiveKFParticle->E();}\r
-\r
- /*\r
- * Gets the Energy of the mother candidate.\r
- */\r
- Double_t GetMotherCandidateEnergy() const{return fCurrentMotherKFCandidate->E();}\r
-\r
- /*\r
- * Gets the Pt of the negative track.\r
- */\r
- Double_t GetNegativeTrackPt() const{return fNegativeTrackLorentzVector->Pt();}\r
-\r
- /*\r
- * Gets the Pt of the positive track.\r
- */\r
- Double_t GetPositiveTrackPt() const{return fPositiveTrackLorentzVector->Pt();}\r
-\r
- /*\r
- * Gets the Pt of the mother candidate.\r
- */\r
- Double_t GetMotherCandidatePt() const{return fMotherCandidateLorentzVector->Pt();}\r
-\r
- /*\r
- * Gets the Eta of the negative track.\r
- */\r
- Double_t GetNegativeTrackEta() const{return fNegativeTrackLorentzVector->Eta();}\r
- /*\r
- * Gets the Eta of the positive track.\r
- */\r
- Double_t GetPositiveTrackEta() const{return fPositiveTrackLorentzVector->Eta();}\r
- /*\r
- * Gets the Eta of the mother candidate.\r
- */\r
- Double_t GetMotherCandidateEta() const{return fMotherCandidateLorentzVector->Eta();}\r
-\r
- /*\r
- * Gets the NDF of the mother candidate.\r
- */\r
- Double_t GetMotherCandidateNDF() const{return fCurrentMotherKFCandidate->GetNDF();}\r
-\r
- /*\r
- * Gets the Chi2 of the mother candidate.\r
- */\r
- Double_t GetMotherCandidateChi2() const{return fCurrentMotherKFCandidate->GetChi2();}\r
-\r
- /*\r
- * Gets the Mass of the mother candidate.\r
- */\r
- Double_t GetMotherCandidateMass() const{return fMotherCandidateKFMass;}\r
-\r
- /*\r
- * Gets the Width of the mother candidate.\r
- */\r
- Double_t GetMotherCandidateWidth() const{return fMotherCandidateKFWidth;}\r
-\r
- /*\r
- * Gets the Phi of the negative track.\r
- */\r
- Double_t GetNegativeTrackPhi() const;\r
-\r
- /*\r
- * Gets the Phi of the positive track.\r
- */\r
- Double_t GetPositiveTrackPhi() const;\r
-\r
- /*\r
- * Gets the Phi of the mother candidate.\r
- */\r
- Double_t GetMotherCandidatePhi() const;\r
-\r
- /*\r
- * Gets the Rapidity of the mother candidate.\r
- */\r
- Double_t GetMotherCandidateRapidity() const;\r
-\r
-\r
- /*\r
- * Update data which need to be updated every event.\r
- */\r
- void UpdateEventByEventData();\r
- \r
- /*\r
- * Gets the MaxRCut value.\r
- */\r
- Double_t GetMaxRCut() const{return fMaxR;}\r
-\r
- /*\r
- * Gets the Eta cut value.\r
- */\r
- Double_t GetEtaCut() const{return fEtaCut;}\r
-\r
- /*\r
- * Gets the Pt cut value.\r
- */\r
- Double_t GetPtCut() const{return fPtCut;}\r
-\r
- /*\r
- * Gets the line cut values.\r
- */\r
- Double_t GetLineCutZRSlope() const{return fLineCutZRSlope;}\r
- Double_t GetLineCutZValue() const{return fLineCutZValue;}\r
- \r
- /*\r
- * Gets the Chi2 cut value for the conversions.\r
- */\r
- Double_t GetChi2CutConversion() const{return fChi2CutConversion;}\r
-\r
- /*\r
- * Gets the Chi2 cut value for the mesons.\r
- */\r
- Double_t GetChi2CutMeson() const{return fChi2CutMeson;}\r
-\r
- Double_t GetPositiveTrackLength() const{return fCurrentPositiveESDTrack->GetIntegratedLength();}\r
- Double_t GetNegativeTrackLength() const{return fCurrentNegativeESDTrack->GetIntegratedLength();}\r
-\r
- Double_t GetPositiveNTPCClusters() const{return fCurrentPositiveESDTrack->GetTPCNcls();}\r
- Double_t GetNegativeNTPCClusters() const{return fCurrentNegativeESDTrack->GetTPCNcls();}\r
-\r
- /*\r
- * Sets the MaxRCut value.\r
- */\r
- void SetMaxRCut(Double_t maxR){fMaxR=maxR;}\r
-\r
- /*\r
- * Sets the EtaCut value.\r
- */\r
- void SetEtaCut(Double_t etaCut){fEtaCut=etaCut;}\r
-\r
- /*\r
- * Sets the PtCut value.\r
- */\r
- void SetPtCut(Double_t ptCut){fPtCut=ptCut;}\r
-\r
- /*\r
- * Sets the LineCut values.\r
- */\r
- void SetLineCutZRSlope(Double_t LineCutZRSlope){fLineCutZRSlope=LineCutZRSlope;}\r
- void SetLineCutZValue(Double_t LineCutZValue){fLineCutZValue=LineCutZValue;}\r
-\r
- /*\r
- * Sets the Chi2Cut value for conversions.\r
- */\r
- void SetChi2CutConversion(Double_t chi2){fChi2CutConversion=chi2;}\r
-\r
- /*\r
- * Sets the Chi2Cut for the mesons.\r
- */\r
- void SetChi2CutMeson(Double_t chi2){fChi2CutMeson=chi2;}\r
- \r
- /*\r
- * Sets the XVertexCut value.\r
- */\r
- void SetXVertexCut(Double_t xVtx){fCurrentXValue=xVtx;}\r
-\r
- /*\r
- * Sets the YVertexCut value.\r
- */\r
- void SetYVertexCut(Double_t yVtx){fCurrentYValue=yVtx;}\r
-\r
- /*\r
- * Sets the ZVertexCut value.\r
- */\r
- void SetZVertexCut(Double_t zVtx){fCurrentZValue=zVtx;}\r
-\r
- /*\r
- * Sets the PIDProbabilityCut value for track particles.\r
- */\r
- void SetPIDProbability(Double_t pidProb){fPIDProbabilityCutPositiveParticle=pidProb; fPIDProbabilityCutNegativeParticle=pidProb;}\r
-\r
- /*\r
- * Sets the PIDProbability cut value for the negative track.\r
- */\r
- void SetPIDProbabilityNegativeParticle(Double_t pidProb){fPIDProbabilityCutNegativeParticle=pidProb;}\r
-\r
- /*\r
- * Sets the PIDProbability cut value for the positive track.\r
- */\r
- void SetPIDProbabilityPositiveParticle(Double_t pidProb){fPIDProbabilityCutPositiveParticle=pidProb;}\r
-\r
- /*\r
- * Sets the SigmaMassCut value.\r
- */\r
- void SetSigmaMass(Double_t sigmaMass){fNSigmaMass=sigmaMass;}\r
-\r
- /*\r
- * Sets the flag to enable/disable the usage of MC information. \r
- */\r
- void SetDoMCTruth(Bool_t doMC){fDoMC = doMC;}\r
-\r
- /*\r
- * Updates the V0 information of the current V0.\r
- */\r
- Bool_t UpdateV0Information();\r
-\r
- /*\r
- * Resets the V0 index.\r
- */\r
- void ResetV0IndexNumber(){fCurrentV0IndexNumber=0;}\r
-\r
- /*\r
- * Sets the histograms.\r
- */\r
- void SetHistograms(AliGammaConversionHistograms *histograms){fHistograms=histograms;}\r
-\r
- /*\r
- * Check for primary vertex.\r
- */\r
- Bool_t CheckForPrimaryVertex();\r
-\r
- /*\r
- * Gets a vector of good v0s.\r
- */\r
- vector<AliKFParticle> GetCurrentEventGoodV0s() const{return fCurrentEventGoodV0s;}\r
-\r
- /*\r
- * Gets the vector of previous events v0s (for bacground analysis)\r
- */\r
- vector<AliKFParticle> GetPreviousEventGoodV0s() const{return fPreviousEventGoodV0s;}\r
-\r
- private:\r
- AliStack * fMCStack; // pointer to MonteCarlo particle stack \r
- AliMCEventHandler* fMCTruth; // pointer to the MC event handler\r
- TChain * fChain; // pointer to the TChain\r
- \r
- AliESDInputHandler* fESDHandler; //! pointer to esd object\r
- AliESDEvent *fESDEvent; //! pointer to esd object\r
-\r
- AliGammaConversionHistograms *fHistograms; //! pointer to histogram handling class\r
- \r
- Int_t fCurrentV0IndexNumber;\r
- AliESDv0 * fCurrentV0; //! pointer to the current v0\r
- AliKFParticle * fCurrentNegativeKFParticle; //! pointer to the negative KF particle\r
- AliKFParticle * fCurrentPositiveKFParticle; //! pointer to the positive KF particle\r
- AliKFParticle * fCurrentMotherKFCandidate; //! pointer to the positive KF particle\r
-\r
- AliESDtrack * fCurrentNegativeESDTrack; //! pointer to the negative ESD track\r
- AliESDtrack * fCurrentPositiveESDTrack; //! pointer to the positive ESD track\r
- \r
- TLorentzVector * fNegativeTrackLorentzVector; //! pointer to the negative Track Lorentz Vector\r
- TLorentzVector * fPositiveTrackLorentzVector; //! pointer to the positive Track Lorentz Vector\r
- TLorentzVector * fMotherCandidateLorentzVector; //! pointer to the mother candidate Track Lorentz Vector\r
-\r
- Double_t fCurrentXValue; // current x value\r
- Double_t fCurrentYValue; // current y value\r
- Double_t fCurrentZValue; // current z value\r
-\r
- Int_t fPositiveTrackPID; // positive track pid\r
- Int_t fNegativeTrackPID; // negative track pid\r
-\r
- TParticle *fNegativeMCParticle; //!\r
- TParticle *fPositiveMCParticle; //!\r
- TParticle *fMotherMCParticle; //!\r
-\r
- Double_t fMotherCandidateKFMass; // mass of mother candidate KF particle\r
- Double_t fMotherCandidateKFWidth; // width of mother candidate KF particle\r
-\r
- Bool_t fUseKFParticle; // flag \r
- Bool_t fUseESDTrack; // flag \r
- Bool_t fDoMC; // flag \r
-\r
- //cuts\r
- Double_t fMaxR; //r cut\r
- Double_t fEtaCut; //eta cut\r
- Double_t fPtCut; // pt cut\r
- Double_t fLineCutZRSlope; //linecut\r
- Double_t fLineCutZValue; //linecut\r
- Double_t fChi2CutConversion; //chi2cut\r
- Double_t fChi2CutMeson; //chi2cut\r
- Double_t fPIDProbabilityCutNegativeParticle; //pid cut\r
- Double_t fPIDProbabilityCutPositiveParticle; //pid cut\r
- Double_t fXVertexCut; //vertex cut\r
- Double_t fYVertexCut; //vertex cut\r
- Double_t fZVertexCut; // vertexcut\r
- \r
- Double_t fNSigmaMass; //nsigma cut\r
- \r
- Bool_t fUseImprovedVertex; //flag\r
- \r
- vector<AliKFParticle> fCurrentEventGoodV0s; //vector of good v0s\r
- vector<AliKFParticle> fPreviousEventGoodV0s; // vector of good v0s from prevous events\r
-\r
- ClassDef(AliV0Reader,2)\r
-};\r
-\r
-\r
-#endif\r
-\r
-\r
-\r
+#ifndef ALIV0READER_H
+#define ALIV0READER_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+////////////////////////////////////////////////
+//---------------------------------------------
+// Class used to do analysis on conversion pairs
+//---------------------------------------------
+////////////////////////////////////////////////
+
+// --- ROOT system ---
+#include "TObject.h"
+#include "AliMCEvent.h" // for CF
+#include "AliESDv0.h"
+#include "AliESDEvent.h"
+#include "AliKFParticle.h"
+#include "TParticle.h"
+#include "AliGammaConversionHistograms.h"
+#include <vector>
+#include "AliCFManager.h"
+
+
+class TClonesArray;
+class TFormula;
+class Riostream;
+class TChain;
+
+//--- AliRoot system ---
+
+class AliStack;
+class AliMCEvent; // for CF
+class AliESDEvent;
+class AliMCEventHandler;
+class AliESDInputHandler;
+class AliESDVertex;
+class AliLog;
+class TChain;
+class TChain;
+class AliCFManager; // for CF
+class AliCFContainer; // for CF
+
+
+
+class AliV0Reader : public TObject {
+
+ public:
+
+
+ // for CF
+ enum{
+ kStepGenerated = 0,
+ kStepReconstructable = 1,
+ kStepLikeSign = 2,
+ kStepTPCRefit = 3,
+ kStepKinks = 4,
+ kStepGetOnFly = 5,
+ kStepNContributors = 6,
+ kStepTPCPID = 7,
+ kStepR = 8,
+ kStepLine = 9,
+ kStepZ = 10,
+ kStepNDF = 11,
+ kStepChi2 = 12,
+ kStepEta = 13,
+ kStepPt = 14
+ };
+
+
+
+ AliV0Reader(); //constructor
+ AliV0Reader(const AliV0Reader & g); //copy constructor
+ AliV0Reader & operator = (const AliV0Reader & g); //assignment operator
+ virtual ~AliV0Reader() {;} //virtual destructor
+ /*
+ *Initialize the reader
+ */
+ void Initialize();
+
+
+ // for CF
+ void SetCFManager(AliCFManager *io){fCFManager = io;};
+ AliCFManager *GetCFManager() const {return fCFManager;}
+
+
+
+
+ /*
+ * Returns AliESDEvent
+ */
+ AliESDEvent* GetESDEvent() const{return fESDEvent;}
+
+ /*
+ *Returns the number of v0s in the event, no cuts applied.
+ */
+ Int_t GetNumberOfV0s() const{return fESDEvent->GetNumberOfV0s();}
+
+ /*
+ * Check if there are any more good v0s left in the v0 stack
+ * if so, fCurrent v0 is set to this v0 and can be retrieved
+ * by GetCurrentV0 function.
+ * returns kFALSE if there is no more good v0s in the v0 stack
+ */
+ Bool_t NextV0();
+
+ /*
+ * Returns the v0 at the given index, no checks are done on the v0.
+ */
+ AliESDv0* GetV0(Int_t index);
+
+ /*
+ * Returns the current v0
+ */
+ AliESDv0* GetCurrentV0() const{return fCurrentV0;}
+
+ /*
+ * Returns the negative ESD track which belongs to fCurrentV0
+ */
+ AliESDtrack* GetNegativeESDTrack(){return fESDEvent->GetTrack(fCurrentV0->GetNindex());}
+
+ /*
+ * Returns the positive ESD track which belongs to fCurrentV0
+ */
+ AliESDtrack* GetPositiveESDTrack(){return fESDEvent->GetTrack(fCurrentV0->GetPindex());}
+
+ /*
+ * Returns the negative KF particle which belongs to fCurrentV0
+ */
+ AliKFParticle* GetNegativeKFParticle() const{return fCurrentNegativeKFParticle;}
+
+ /*
+ * Returns the positive KF particle which belongs to fCurrentV0
+ */
+ AliKFParticle* GetPositiveKFParticle() const{return fCurrentPositiveKFParticle;}
+
+ /*
+ * Returns the KFParticle object of the 2 tracks.
+ */
+ AliKFParticle* GetMotherCandidateKFCombination() const{return fCurrentMotherKFCandidate;}
+
+ /*
+ * Checks the probablity that the PID of the particle is what we want it to be.
+ */
+ Bool_t CheckPIDProbability(Double_t negProbCut, Double_t posProbCut);
+
+ /*
+ * Checks if the PID of the two particles are within our cuts.
+ */
+ void GetPIDProbability(Double_t &negPIDProb, Double_t &posPIDProb);
+
+ /*
+ *Get the negative MC TParticle from the stack
+ */
+ TParticle * GetNegativeMCParticle() const{return fNegativeMCParticle;}
+
+ /*
+ *Get the positive MC TParticle from the stack
+ */
+ TParticle * GetPositiveMCParticle() const{return fPositiveMCParticle;}
+
+ /*
+ *Get the mother MC TParticle from the stack
+ */
+ TParticle * GetMotherMCParticle() const{return fMotherMCParticle;}
+
+ /*
+ * Flag to see if the v0 particles share the same mother
+ */
+ Bool_t HasSameMCMother();
+
+
+ /*
+ *Get the PID of the MC mother particle
+ */
+ Int_t GetMotherMCParticlePDGCode() const{if(fMotherMCParticle != NULL){ cout<<"MCParticle exists"<<endl;} return fMotherMCParticle->GetPdgCode();}
+
+ /*
+ *Get the MC stack
+ */
+ AliStack* GetMCStack() const{return fMCStack;}
+
+
+ /*
+ * Setup AliMCEventHandler
+ */
+ AliMCEventHandler* GetMCTruth() const{return fMCTruth;} // for CF
+
+
+ /*
+ *Get the MC stack
+ */
+ AliMCEvent* GetMCEvent() const{return fMCEvent;} // for CF
+
+
+ /*
+ *Get the magnetic field from the ESD event
+ */
+ Double_t GetMagneticField() const{return fESDEvent->GetMagneticField();}
+
+ /*
+ *Get the primary vertex from the esd event
+ */
+ const AliESDVertex *GetPrimaryVertex() const {return fESDEvent->GetPrimaryVertex();}
+
+ /*
+ * Set the PID of the negative track
+ */
+ void SetNegativeTrackPID(Int_t negTrackPID){fNegativeTrackPID=negTrackPID;}
+
+ /*
+ * Set the PID of the positive track
+ */
+ void SetPositiveTrackPID(Int_t posTrackPID){fPositiveTrackPID=posTrackPID;}
+
+ /*
+ * Set the flag to use the kfparticle class. Will also disable the use of esd tracks
+ */
+ void UseKFParticle(){fUseKFParticle = kTRUE; fUseESDTrack = kFALSE;}
+
+ /*
+ * Set the flag to use the esd track class. Will also disable the use of kf particles
+ */
+ void UseESDTrack(){fUseESDTrack = kTRUE; fUseKFParticle = kFALSE;}
+
+ /*
+ * Set the flag to use improved vertex or not
+ */
+ void SetUseImprovedVertex(Bool_t useImprovedVertex){fUseImprovedVertex=useImprovedVertex;}
+
+ /*
+ * Return the number in the species array belonging to the negative or positive track pid.
+ */
+ Int_t GetSpeciesIndex(Int_t chargeOfTrack);
+
+ /*
+ * Return the x coordinate of the v0
+ */
+ Double_t GetX() const{return fCurrentXValue;}
+
+ /*
+ * Return the y coordinate of the v0
+ */
+ Double_t GetY() const{return fCurrentYValue;}
+
+ /*
+ * Return the Z coordinate of the v0
+ */
+ Double_t GetZ() const{return fCurrentZValue;}
+
+ /*
+ * Return the radius of the v0
+ */
+ Double_t GetXYRadius() const{return sqrt((Double_t)(fCurrentXValue*fCurrentXValue + fCurrentYValue*fCurrentYValue));}
+
+ /*
+ * Get the opening angle between the two tracks
+ */
+ Double_t GetOpeningAngle(){return fNegativeTrackLorentzVector->Angle(fPositiveTrackLorentzVector->Vect());}
+
+ /*
+ * Gets the Energy of the negative track.
+ */
+ Double_t GetNegativeTrackEnergy() const{return fCurrentNegativeKFParticle->E();}
+
+ /*
+ * Gets the Energy of the positive track.
+ */
+ Double_t GetPositiveTrackEnergy() const{return fCurrentPositiveKFParticle->E();}
+
+ /*
+ * Gets the Energy of the mother candidate.
+ */
+ Double_t GetMotherCandidateEnergy() const{return fCurrentMotherKFCandidate->E();}
+
+ /*
+ * Gets the Pt of the negative track.
+ */
+ Double_t GetNegativeTrackPt() const{return fNegativeTrackLorentzVector->Pt();}
+
+ /*
+ * Gets the Pt of the positive track.
+ */
+ Double_t GetPositiveTrackPt() const{return fPositiveTrackLorentzVector->Pt();}
+
+ /*
+ * Gets the Pt of the mother candidate.
+ */
+ Double_t GetMotherCandidatePt() const{return fMotherCandidateLorentzVector->Pt();}
+
+ /*
+ * Gets the Eta of the negative track.
+ */
+ Double_t GetNegativeTrackEta() const{return fNegativeTrackLorentzVector->Eta();}
+ /*
+ * Gets the Eta of the positive track.
+ */
+ Double_t GetPositiveTrackEta() const{return fPositiveTrackLorentzVector->Eta();}
+ /*
+ * Gets the Eta of the mother candidate.
+ */
+ Double_t GetMotherCandidateEta() const{return fMotherCandidateLorentzVector->Eta();}
+
+ /*
+ * Gets the NDF of the mother candidate.
+ */
+ Double_t GetMotherCandidateNDF() const{return fCurrentMotherKFCandidate->GetNDF();}
+
+ /*
+ * Gets the Chi2 of the mother candidate.
+ */
+ Double_t GetMotherCandidateChi2() const{return fCurrentMotherKFCandidate->GetChi2();}
+
+ /*
+ * Gets the Mass of the mother candidate.
+ */
+ Double_t GetMotherCandidateMass() const{return fMotherCandidateKFMass;}
+
+ /*
+ * Gets the Width of the mother candidate.
+ */
+ Double_t GetMotherCandidateWidth() const{return fMotherCandidateKFWidth;}
+
+ /*
+ * Gets the Phi of the negative track.
+ */
+ Double_t GetNegativeTrackPhi() const;
+
+ /*
+ * Gets the Phi of the positive track.
+ */
+ Double_t GetPositiveTrackPhi() const;
+
+ /*
+ * Gets the Phi of the mother candidate.
+ */
+ Double_t GetMotherCandidatePhi() const;
+
+ /*
+ * Gets the Rapidity of the mother candidate.
+ */
+ Double_t GetMotherCandidateRapidity() const;
+
+
+ /*
+ * Update data which need to be updated every event.
+ */
+ void UpdateEventByEventData();
+
+ /*
+ * Gets the MaxRCut value.
+ */
+ Double_t GetMaxRCut() const{return fMaxR;}
+
+ /*
+ * Gets the Eta cut value.
+ */
+ Double_t GetEtaCut() const{return fEtaCut;}
+
+ /*
+ * Gets the Pt cut value.
+ */
+ Double_t GetPtCut() const{return fPtCut;}
+
+
+ /*
+ * Gets the MaxZCut value.
+ */
+ Double_t GetMaxZCut() const{return fMaxZ;}
+
+
+ /*
+ * 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.
+ */
+ Double_t GetChi2CutConversion() const{return fChi2CutConversion;}
+
+ /*
+ * Gets the Chi2 cut value for the mesons.
+ */
+ 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.
+ */
+ void SetMaxRCut(Double_t maxR){fMaxR=maxR;}
+
+ /*
+ * Sets the EtaCut value.
+ */
+ void SetEtaCut(Double_t etaCut){fEtaCut=etaCut;}
+
+ /*
+ * Sets the PtCut value.
+ */
+ void SetPtCut(Double_t ptCut){fPtCut=ptCut;}
+
+
+ /*
+ * Sets the MaxZCut value.
+ */
+ void SetMaxZCut(Double_t maxZ){fMaxZ=maxZ;}
+
+
+ /*
+ * Sets the LineCut values.
+ */
+ void SetLineCutZRSlope(Double_t LineCutZRSlope){fLineCutZRSlope=LineCutZRSlope;}
+ void SetLineCutZValue(Double_t LineCutZValue){fLineCutZValue=LineCutZValue;}
+
+ /*
+ * Sets the Chi2Cut value for conversions.
+ */
+ void SetChi2CutConversion(Double_t chi2){fChi2CutConversion=chi2;}
+
+ /*
+ * Sets the Chi2Cut for the mesons.
+ */
+ void SetChi2CutMeson(Double_t chi2){fChi2CutMeson=chi2;}
+
+ /*
+ * Sets the XVertexCut value.
+ */
+ void SetXVertexCut(Double_t xVtx){fCurrentXValue=xVtx;}
+
+ /*
+ * Sets the YVertexCut value.
+ */
+ void SetYVertexCut(Double_t yVtx){fCurrentYValue=yVtx;}
+
+ /*
+ * Sets the ZVertexCut value.
+ */
+ void SetZVertexCut(Double_t zVtx){fCurrentZValue=zVtx;}
+
+ /*
+ * Sets the PIDProbabilityCut value for track particles.
+ */
+ void SetPIDProbability(Double_t pidProb){fPIDProbabilityCutPositiveParticle=pidProb; fPIDProbabilityCutNegativeParticle=pidProb;}
+
+ /*
+ * Sets the PIDProbability cut value for the negative track.
+ */
+ void SetPIDProbabilityNegativeParticle(Double_t pidProb){fPIDProbabilityCutNegativeParticle=pidProb;}
+
+ /*
+ * Sets the PIDProbability cut value for the positive track.
+ */
+ void SetPIDProbabilityPositiveParticle(Double_t pidProb){fPIDProbabilityCutPositiveParticle=pidProb;}
+
+ /*
+ * Sets the SigmaMassCut value.
+ */
+ void SetSigmaMass(Double_t sigmaMass){fNSigmaMass=sigmaMass;}
+
+ /*
+ * Sets the flag to enable/disable the usage of MC information.
+ */
+ void SetDoMCTruth(Bool_t doMC){fDoMC = doMC;}
+
+ /*
+ * Updates the V0 information of the current V0.
+ */
+ Bool_t UpdateV0Information();
+
+ /*
+ * Resets the V0 index.
+ */
+ void ResetV0IndexNumber(){fCurrentV0IndexNumber=0;}
+
+ /*
+ * Sets the histograms.
+ */
+ void SetHistograms(AliGammaConversionHistograms *histograms){fHistograms=histograms;}
+
+ /*
+ * Check for primary vertex.
+ */
+ Bool_t CheckForPrimaryVertex();
+
+ /*
+ * Gets a vector of good v0s.
+ */
+ vector<AliKFParticle> GetCurrentEventGoodV0s() const{return fCurrentEventGoodV0s;}
+
+ /*
+ * Gets the vector of previous events v0s (for bacground analysis)
+ */
+ vector<AliKFParticle> GetPreviousEventGoodV0s() const{return fPreviousEventGoodV0s;}
+
+ void SetUseOwnXYZCalculation(Bool_t flag){fUseOwnXYZCalculation=flag;}
+
+ Bool_t GetHelixCenter(AliESDtrack* track, Double_t b,Int_t charge, Double_t center[2]);
+
+ Bool_t GetConvPosXY(AliESDtrack* ptrack,AliESDtrack* ntrack, Double_t b, Double_t convpos[2]);
+
+ Double_t GetConvPosZ(AliESDtrack* ptrack,AliESDtrack* ntrack, Double_t b);
+
+ private:
+ AliStack * fMCStack; // pointer to MonteCarlo particle stack
+ AliMCEventHandler* fMCTruth; // for CF pointer to the MC object
+ AliMCEvent *fMCEvent; // for CF pointer to MC event
+ TChain * fChain; // pointer to the TChain
+
+ AliESDInputHandler* fESDHandler; //! pointer to esd object
+ AliESDEvent *fESDEvent; //! pointer to esd object
+
+
+ // for CF
+ AliCFManager *fCFManager;
+ AliCFContainer *container;
+
+
+ AliGammaConversionHistograms *fHistograms; //! pointer to histogram handling class
+
+ Int_t fCurrentV0IndexNumber;
+ AliESDv0 * fCurrentV0; //! pointer to the current v0
+ AliKFParticle * fCurrentNegativeKFParticle; //! pointer to the negative KF particle
+ AliKFParticle * fCurrentPositiveKFParticle; //! pointer to the positive KF particle
+ AliKFParticle * fCurrentMotherKFCandidate; //! pointer to the positive KF particle
+
+ AliESDtrack * fCurrentNegativeESDTrack; //! pointer to the negative ESD track
+ AliESDtrack * fCurrentPositiveESDTrack; //! pointer to the positive ESD track
+
+ TLorentzVector * fNegativeTrackLorentzVector; //! pointer to the negative Track Lorentz Vector
+ TLorentzVector * fPositiveTrackLorentzVector; //! pointer to the positive Track Lorentz Vector
+ TLorentzVector * fMotherCandidateLorentzVector; //! pointer to the mother candidate Track Lorentz Vector
+
+ Double_t fCurrentXValue; // current x value
+ Double_t fCurrentYValue; // current y value
+ Double_t fCurrentZValue; // current z value
+
+ Int_t fPositiveTrackPID; // positive track pid
+ Int_t fNegativeTrackPID; // negative track pid
+
+ TParticle *fNegativeMCParticle; //!
+ TParticle *fPositiveMCParticle; //!
+ TParticle *fMotherMCParticle; //!
+
+ Double_t fMotherCandidateKFMass; // mass of mother candidate KF particle
+ Double_t fMotherCandidateKFWidth; // width of mother candidate KF particle
+
+ Bool_t fUseKFParticle; // flag
+ Bool_t fUseESDTrack; // flag
+ Bool_t fDoMC; // flag
+
+ //cuts
+ Double_t fMaxR; //r cut
+ Double_t fEtaCut; //eta cut
+ Double_t fPtCut; // pt cut
+ Double_t fMaxZ; //z cut
+ Double_t fLineCutZRSlope; //linecut
+ Double_t fLineCutZValue; //linecut
+ Double_t fChi2CutConversion; //chi2cut
+ Double_t fChi2CutMeson; //chi2cut
+ Double_t fPIDProbabilityCutNegativeParticle; //pid cut
+ Double_t fPIDProbabilityCutPositiveParticle; //pid cut
+ Double_t fXVertexCut; //vertex cut
+ Double_t fYVertexCut; //vertex cut
+ Double_t fZVertexCut; // vertexcut
+
+ Double_t fNSigmaMass; //nsigma cut
+
+ Bool_t fUseImprovedVertex; //flag
+
+ Bool_t fUseOwnXYZCalculation; //flag that determines if we use our own calculation of xyz (markus)
+
+ vector<AliKFParticle> fCurrentEventGoodV0s; //vector of good v0s
+ vector<AliKFParticle> fPreviousEventGoodV0s; // vector of good v0s from prevous events
+
+ ClassDef(AliV0Reader,3)
+};
+#endif
+
+
+
ALICEINC += -I../$(JETAN_INCLUDE)
endif
+ifneq ($(CORRFW_INCLUDE),)
+ ALICEINC += -I../$(CORRFW_INCLUDE)
+endif
+
ifneq ($(PHOSUtils_INCLUDE),)
ALICEINC += -I../$(PHOSUtils_INCLUDE)
CXXFLAGS+=-D__PHOSUTIL__
Double_t kGCmaxRCut = 180.;
Double_t kGCetaCut = 1.2;
Double_t kGCptCut = 0.02;
+Double_t kGCmaxZCut = 240.;
Double_t kGCchi2CutConversion = 20.;
Double_t kGCchi2CutMeson = 20.;
/** ----------------------------------end define cuts here----------------------------------*/
/** -------------------------------- Phi/R Mapping ---------------------------------------*/
-Int_t kGCnPhiIndex = 18;
-Int_t kGCnRIndex = 40;
+Int_t kGCnPhiIndex = 8;
+Int_t kGCnRIndex = 4;
Double_t kGCminRadius = 0.;
Double_t kGCmaxRadius = 200.;
Double_t kGCmaxPhi = TMath::Pi();
/** ------------------------------- end Phi/R Mapping ------------------------------------*/
+Bool_t kGCdoOwnXYZCalculation = kFALSE;
+
+Bool_t fWriteStandardAOD =kFALSE;
+
/** ------------------- define which histograms to plot here --------------------------------*/
/** NB: to change the bin numbers, see below the histogram flags */
Bool_t kGCplotESDBackgroundXY = kTRUE;
Bool_t kGCplotESDBackgroundRapid = kTRUE;
-Bool_t kGCplotMapping = kFALSE;
+Bool_t kGCplotMapping = kTRUE;
Bool_t kGCplotResolutiondPt = kTRUE;
Bool_t kGCplotResolutiondR = kTRUE;
cout<<"Switching off kGCdoMCTruth"<<endl;
kGCdoMCTruth = kFALSE;
}
+ else if (argument.CompareTo("-use-own-xyz") == 0){
+ cout<<"Switching on use own xyz calculation"<<endl;
+ kGCdoOwnXYZCalculation = kTRUE;
+ }
else if(argument.CompareTo("-append-to-output-file") == 0){
if((bMissingParam=(++i>=pTokens->GetEntries()))) break;
- kGCoutputFileAppendix = "_"+((TObjString*)pTokens->At(i))->GetString();
+ kGCoutputFileAppendix = TString("_")+((TObjString*)pTokens->At(i))->GetString();
if(kGCoutputFileAppendix.IsNull()){
cout<<"-appending-to-output-file is NULL"<<endl;
iResult=kFALSE;
// Check if the file $ALICE_ROOT/PWG4/GammaConv/AliAnalysisTaskGammaConversion.cxx exists.
// If yes, we set kGCusePWG4PartCorr to false since we have a newer version
// If no, kGCusePWG4PartCorr is true.
-
+
TString file = gSystem->Getenv("ALICE_ROOT");
file+="/PWG4/PartCorr/AliAnalysisTaskGammaConversion.cxx";
-
+
ifstream stream;
stream.open(file.Data());
-
+
if(!stream){
kGCusePWG4PartCorr=kFALSE;
}
if(!scanArguments(arguments)){
break;
}
-
+
SetVersionLibrary(); // checks if PWG4GammaConv or PWG4PartCorr is used
-
+
if(cin_esd == NULL && kGCrunOnTrain == kTRUE){
cout<<"Error: kGCrunOnTrain flag is set to true but the input AliAnalysisDataContainer is NULL"<<endl;
cout<<" you must also supply the AliAnalysisDataContainer as an argument"<<endl;
return;
}
-
+
if(cin_esd != NULL && kGCrunOnTrain == kFALSE){
cout<<"Error: kGCrunOnTrain flag is set to false but the input AliAnalysisDataContainer is not null"<<endl;
cout<<" add -run-on-train to the arguments to turn switch kGCrunOnTrain to kTRUE"<<endl;
}
}
cout<<"Number Of files to analyze: "<<kGCnumberOfFilesToAnalyze<<endl;
-
+
build();//build (if necessary) and load the libraries needed
-
+
gROOT->LoadMacro("$ALICE_ROOT/PWG0/CreateESDChain.C"); // load the CreateChain macro
-
+
AliLog::SetGlobalLogLevel(AliLog::kError);
+
+
+ // ------------------------------------------------------------------------
+
+ // for CF
+
+ //Container def.
+ const Double_t ptmin = kGCfirstXBinPt;
+ const Double_t ptmax = kGClastXBinPt;
+ const Double_t etamin = kGCfirstXBinEta;
+ const Double_t etamax = kGClastXBinEta;
+ const Double_t massmin = kGCfirstXBinPi0Mass;
+ const Double_t massmax = kGClastXBinPi0Mass;
+
+
+ // sensitive variables
+ UInt_t ipt = 0;
+ UInt_t ieta = 1;
+ UInt_t imass = 2;
+
+ //how many selection steps
+ UInt_t nstep = 15;
+ const Int_t nvar = 3;
+ const Int_t nbin0 = kGCnXBinsPt;
+ const Int_t nbin1 = kGCnXBinsEta;
+ const Int_t nbin2 = kGCnXBinsPi0Mass;
+
+ //arrays for the number of bins in each dimension
+ Int_t iBin[nvar];
+ iBin[0] = nbin0;
+ iBin[1] = nbin1;
+ iBin[2] = nbin2;
+
+ //arrays for lower bounds
+ Double_t *binLim0 = new Double_t[nbin0+1];
+ Double_t *binLim1 = new Double_t[nbin1+1];
+ Double_t *binLim2 = new Double_t[nbin2+1];
+
+ // values for lower bounds
+ for(Int_t i = 0; i <= nbin0; i++) binLim0[i] = ptmin + (ptmax - ptmin)/nbin0*i;
+ for(Int_t i = 0; i <= nbin1; i++) binLim1[i] = etamin + (etamax - etamin)/nbin1*i;
+ for(Int_t i = 0; i <= nbin2; i++) binLim2[i] = massmin + (massmax - massmin)/nbin2*i;
+
+ // create container
+ AliCFContainer *container = new AliCFContainer("container","container for gammaconversion", nstep,nvar,iBin);
+ container->SetBinLimits(ipt,binLim0);
+ container->SetBinLimits(ieta,binLim1);
+ container->SetBinLimits(imass,binLim2);
+
+ AliCFManager *man = new AliCFManager();
+ man->SetParticleContainer(container);
+
+ // end ---------------------------------------------------------------------------
+
+
}
-
+
AliGammaConversionHistograms* histograms = new AliGammaConversionHistograms();
AddHistograms(histograms);
// Create the Analysis manager
AliAnalysisManager *mgr =NULL;
if(kGCrunOnTrain == kFALSE){
- mgr = new AliAnalysisManager("My Manager", "My Analysis");
+ mgr = new AliAnalysisManager("My Manager", "My Analysis");
}
else{
mgr = AliAnalysisManager::GetAnalysisManager();
}
-
+
if (!mgr) {
::Error("ConfigGammaConversion", "No analysis manager to connect to.");
return NULL;
}
}
AliESDInputHandler* inpHandler = NULL;
-
+
if(kGCrunOnTrain == kFALSE){
// Define Input Event Handler
inpHandler = new AliESDInputHandler();
return NULL;
}
}
-
-
+
// Define Output Event Handler and ad
- if(kGCrunOnTrain == kFALSE){
+ // if(kGCrunOnTrain == kFALSE){
+ if(fWriteStandardAOD == kTRUE){
AliAODHandler* aodHandler = new AliAODHandler();
TString fileOutAOD = "AOD_"+ kGCoutputFileName + kGCoutputFileAppendix + ".root";
aodHandler->SetOutputFileName(fileOutAOD);
mgr->SetOutputEventHandler (aodHandler);
}
-
+
if(kGCrunOnTrain == kFALSE){
mgr->SetInputEventHandler (inpHandler);
mgr->SetMCtruthEventHandler(mcHandler);
}
// Be sure you are told what you are doing
- // mgr->SetDebugLevel(10);
+ mgr->SetDebugLevel(10);
// Declare Common Input Tchain
AliAnalysisDataContainer *cinput1 = NULL;
}
else{
if(kGCrunOnTrain == kFALSE){
- cinput1 = mgr->GetCommonInputContainer();
+ cinput1 = mgr->GetCommonInputContainer(); // added by kenneth to avoid writing the standard AOD
}
else{
// cinput = cin_esd;
coutput1 = mgr->CreateContainer("tree",TTree::Class(),AliAnalysisManager::kOutputContainer, "default");
}
else{
- coutput1 = mgr->GetCommonOutputContainer();
+ if(fWriteStandardAOD){
+ coutput1 = mgr->GetCommonOutputContainer();
+ }
}
// Private output objects
kGCoutputFileAppendix.ReplaceAll(".root","");
}
TString fileOut = kGCoutputFileName + kGCoutputFileAppendix + ".root";
-
+
AliAnalysisDataContainer *coutput2 = mgr->CreateContainer("histogramsAliGammaConversion", TList::Class(),AliAnalysisManager::kOutputContainer, fileOut);
+ // for CF
+ AliAnalysisDataContainer *coutput3 = mgr->CreateContainer("ccontainer0",AliCFContainer::Class(),AliAnalysisManager::kOutputContainer,fileOut);
+
//------------------------ END: Define input/output handlers ---------------------------------------------------
//check for errors in the specified data
if(kGCuseKFParticle == kTRUE && kGCuseESDTrack == kTRUE){
//Print warning, cannot use both
::Error("ConfigGammaConversion","Both kGCuseKFParticle and kGCuseESDTracks can be true at the same time")
- }
+ }
if(kGCuseKFParticle == kFALSE && kGCuseESDTrack == kFALSE){
//Print warning, one have to be specified
::Error("ConfigGammaConversion","Both kGCuseKFParticle and kGCuseESDTracks can be false at the same time")
- }
-
+ }
+
+
//Create the V0Reader
AliV0Reader * v0Reader = new AliV0Reader();
if(kGCuseKFParticle){
v0Reader->SetPtCut(kGCptCut);
v0Reader->SetLineCutZRSlope(kGCLineCutZRSlope);
v0Reader->SetLineCutZValue(kGCLineCutZValue);
+ v0Reader->SetMaxZCut(kGCmaxZCut);
v0Reader->SetChi2CutConversion(kGCchi2CutConversion);
v0Reader->SetChi2CutMeson(kGCchi2CutMeson);
v0Reader->SetPIDProbability(kGCprobElectron);
v0Reader->SetSigmaMass(kGCsigmaCutGammaMass);
v0Reader->SetUseImprovedVertex(kGCuseImprovedVertex);
v0Reader->SetDoMCTruth(kGCdoMCTruth);
+ v0Reader->SetUseOwnXYZCalculation(kGCdoOwnXYZCalculation);
+ // for CF
+ v0Reader->SetCFManager(man);
+
// Create the GammaConversionTask
AliAnalysisTaskGammaConversion *gammaconversion = new AliAnalysisTaskGammaConversion("GammaConversionTask");
gammaconversion->SetGammaWidth(kGCgammaWidth);
gammaconversion->SetPi0Width(kGCpi0Width);
gammaconversion->SetEtaWidth(kGCetaWidth);
-
+
gammaconversion->SetMinOpeningAngleGhostCut(kGCminOpeningAngleGhostCut);
// define the width constraint used by KF particle.
v0Reader->SetHistograms(histograms);// also give the pointer to the v0reader, for debugging cuts
gammaconversion->SetDoMCTruth(kGCdoMCTruth);
-
+
gammaconversion->SetDoNeutralMeson(kGCrunNeutralMeson);
gammaconversion->SetDoJet(kGCrunJet);
gammaconversion->SetDoChic(kGCrunChic);
-
+ // for CF
+ gammaconversion->SetCFManager(man);
+
// Add task to the manager
mgr->AddTask(gammaconversion);
// Connect I/O to the task
mgr->ConnectInput (gammaconversion, 0, cinput1);
-
- if(kGCrunOnTrain == kFALSE){
+
+ if(fWriteStandardAOD){
mgr->ConnectOutput(gammaconversion, 0, coutput1);
- mgr->ConnectOutput(gammaconversion, 1, coutput2);
}
+ mgr->ConnectOutput(gammaconversion, 1, coutput2);
+ mgr->ConnectOutput(gammaconversion, 2, coutput3);
+
if(kGCrunOnTrain == kFALSE){
if(kGCdataList.IsNull()){
cout<<"Data list is not set, aborting."<<endl;
return;
}
-
+
if(kGCrunOnTrain == kFALSE){
TChain* chain= CreateESDChain(kGCdataList,kGCnumberOfFilesToAnalyze);
-
+
mgr->InitAnalysis();
-
+
mgr->PrintStatus();
-
+
mgr->StartAnalysis("local",chain);
}
}
}
void build() {
-
+
TStopwatch timer;
timer.Start();
gSystem->Load("libTree.so");
////
//Setting up ANALYSISalice.par//
////
- cout<<"compiling ANALUSISalice"<<endl;
+ cout<<"compiling ANALYSISalice"<<endl;
setupPar("ANALYSISalice");
gSystem->Load("libANALYSISalice.so");
+ ////
+ //Setting up CORRFW.par//
+ ////
+ cout<<"compiling CORRFW"<<endl;
+ setupPar("CORRFW");
+ gSystem->Load("CORRFW.so");
+
////
//Setting up PWG4GammaConv.par//
////
if (kGCplotdPhiHdrGam == kTRUE){
histograms->AddHistogram("ESD_dphiHdrGam","ESD_dphiHdrGam", kGCnXBinsdphiHdrGam,kGCfirstXBindphiHdrGam,kGClastXBindphiHdrGam,"dphiHdrGam (rad)","Counts");
}
-
+
if (kGCplotdPhiHdrGamIsolated == kTRUE){
histograms->AddHistogram("ESD_dphiHdrGamIsolated","ESD_dphiHdrGamIsolated", kGCnXBinsdphiHdrGam,kGCfirstXBindphiHdrGam,kGClastXBindphiHdrGam,"dphiHdrGamIsolated (rad)","Counts");
}
-
+
if (kGCplotMinimumIsoDistance == kTRUE){
histograms->AddHistogram("ESD_MinimumIsoDistance","ESD_MinimumIsoDistance", kGCnXBinsMinimumIsoDistance,kGCfirstXBinMinimumIsoDistance,kGClastXBinMinimumIsoDistance,"Minimum Iso Distance (rad)","Counts");
}
-
+
if (kGCplotFFzHdrGam == kTRUE){
histograms->AddHistogram("ESD_FFzHdrGam","ESD_FFzHdrGam", kGCnXBinsFFzHdrGam, kGCfirstXBinFFzHdrGam,kGClastXBinFFzHdrGam,"FFz Hdr Gam","Counts");
}
-
+
if (kGCplotImbalanceHdrGam == kTRUE){
histograms->AddHistogram("ESD_ImbalanceHdrGam","ESD_ImbalanceHdrGam", kGCnXBinsImbalanceHdrGam, kGCfirstXBinImbalanceHdrGam,kGClastXBinImbalanceHdrGam,"Imbalance Hdr Gam","Counts");
}
}//end if(kGCrunJet)
-
+
//---------------------------------------------- Chi_c ---------------------------------------------------------
if(kGCrunChic){
-
+
if(kGCplotESDInvMassePluseMinus == kTRUE){histograms->AddHistogram("ESD_InvMass_ePluseMinus","",kGCnXBinsJPsiMass, kGCfirstXBinJPsiMass, kGClastXBinJPsiMass, "",
- "");}
+ "");}
if(kGCplotESDInvMassePluseMinus == kTRUE){histograms->AddHistogram("ESD_InvMass_ePluseMinusTest","",kGCnXBinsJPsiMass, kGCfirstXBinJPsiMass, kGClastXBinJPsiMass,
- "","");}
+ "","");}
if(kGCplotESDInvMassePluseMinus == kTRUE){histograms->AddHistogram("ESD_InvMass_xPlusxMinus","",kGCnXBinsJPsiMass, kGCfirstXBinJPsiMass, kGClastXBinJPsiMass, "",
- "");}
+ "");}
if(kGCplotESDElectronPosNegPt == kTRUE){histograms->AddHistogram("ESD_ElectronPosNegPt","",kGCnXBinsEPosNegPt,kGCfirstXBinEPosNegPt,kGClastXBinEPosNegPt,"","");}
if(kGCplotESDElectronPosNegEta == kTRUE){histograms->AddHistogram("ESD_ElectronPosNegEta","",kGCnXBinsEPosNegEta,kGCfirstXBinEPosNegEta,kGClastXBinEPosNegEta,"","
-");}
-
+ ");}
+
if(kGCplotESDElectronPosNegPt == kTRUE){histograms->AddHistogram("ESD_ElectronPosPt","",kGCnXBinsEPosNegPt,kGCfirstXBinEPosNegPt,kGClastXBinEPosNegPt,"","");}
if(kGCplotESDElectronPosNegPt == kTRUE){histograms->AddHistogram("ESD_ElectronNegPt","",kGCnXBinsEPosNegPt,kGCfirstXBinEPosNegPt,kGClastXBinEPosNegPt,"","");}
-
+
if(kGCplotESDElectronPosNegAngle == kTRUE){histograms->AddHistogram("ESD_ElectronPosNegJPsiAngle","",kGCnXBinsEPosNegAngle,kGCfirstXBinEPosNegAngle,kGClastXBinEPo
- sNegAngle,"","");}
+ sNegAngle,"","");}
if(kGCplotMCElectronPosNegPt == kTRUE){histograms->AddHistogram("MC_ElectronPosNegPt","",kGCnXBinsEPosNegPt,kGCfirstXBinEPosNegPt,kGClastXBinEPosNegPt,"","");}
if(kGCplotMCElectronPosNegEta == kTRUE){histograms->AddHistogram("MC_ElectronPosNegEta","",kGCnXBinsEPosNegEta,kGCfirstXBinEPosNegEta,kGClastXBinEPosNegEta,"","")
;}
if(kGCplotMCElectronPosNegJPsiAngle == kTRUE){histograms->AddHistogram("MC_ElectronPosNegJPsiAngle","",kGCnXBinsEPosNegAngle,kGCfirstXBinEPosNegAngle,kGClastXBinE
- PosNegAngle,"","");}
+ PosNegAngle,"","");}
if(kGCplotESDePoseNegAngle == kTRUE){histograms->AddHistogram("ESD_eNegePosAngleBeforeCut","",kGCnXBinsEPosNegAngle,kGCfirstXBinEPosNegAngle,kGClastXBinEPosNegAngle,"","");}
if(kGCplotESDePoseNegAngle == kTRUE){histograms->AddHistogram("ESD_eNegePosAngleAfterCut","",kGCnXBinsEPosNegAngle,kGCfirstXBinEPosNegAngle,kGClastXBinEPosNegAngle,"","");}
if(kGCplotESDInvMassGammaePluseMinusChiC == kTRUE) {histograms->AddHistogram("ESD_InvMass_GammaePluseMinusChiC","",kGCnXBinsChicMass,kGCfirstXBinChicMass,kGClastXBinChicMass,"","");}
if(kGCplotESDInvMassGammaePluseMinusPi0 == kTRUE) {histograms->AddHistogram("ESD_InvMass_GammaePluseMinusPi0","",kGCnXBinsPi0Mass,kGCfirstXBinPi0Mass,kGClastXBinPi0Mass,"","");}
if(kGCplotESDElectronPosNegPi0Angle == kTRUE){histograms->AddHistogram("ESD_ElectronPosNegPi0Angle","",kGCnXBinsEPosNegAngle,kGCfirstXBinEPosNegAngle,kGClastXBinEPosNegAngle,"","");}
if(kGCplotMCElectronPosNegPi0Angle == kTRUE){histograms->AddHistogram("MC_ElectronPosNegPi0Angle","",kGCnXBinsEPosNegAngle,kGCfirstXBinEPosNegAngle,kGClastXBinEPosNegAngle,"","");}
-
+
if(kGCplotESDEPosBackground == kTRUE){histograms->AddHistogram("ESD_EPosBackground","",kGCnXBinsEBackground,kGCfirstXBinEBackground,kGClastXBinEBackground,"","");}
-
+
if(kGCplotESDEPosBackground == kTRUE){histograms->AddHistogram("ESD_EPosENegNoJPsiBG","",kGCnXBinsEBackground,kGCfirstXBinEBackground,kGClastXBinEBackground,"","");}
-
-
+
+
if(kGCplotESDENegBackground == kTRUE){histograms->AddHistogram("ESD_ENegBackground","",kGCnXBinsEBackground,kGCfirstXBinEBackground,kGClastXBinEBackground,"","");}
if(kGCplotESDEPosENegBackground == kTRUE){histograms->AddHistogram("ESD_EPosENegBackground","",kGCnXBinsEBackground,kGCfirstXBinEBackground,kGClastXBinEBackground,"","");}
if(kGCplotESDEPosENegBackgroundCut == kTRUE){histograms->AddHistogram("ESD_EPosENegBackgroundCut","",kGCnXBinsEBackgroundCut,kGCfirstXBinEBackgroundCut,kGClastXBinEBackgroundCut,"","");}
-
+
if(kGCplotESDEPosENegGammaBackgroundMX == kTRUE){histograms->AddHistogram("ESD_EPosENegGammaBackgroundMX","",kGCnXBinsEBackground,kGCfirstXBinEBackground,kGClastXBinEBackground,"","");}
if(kGCplotESDEPosENegGammaBackgroundMX == kTRUE){histograms->AddHistogram("ESD_EPosENegGammaBackgroundMXDiff","",kGCnXBinsEBackground,kGCfirstXBinEBackground,kGClastXBinEBackground,"","");}
-
+
if(kGCplotTableElectrons == kTRUE){ histograms->AddTable("Table_Electrons","",kGCnElementsElectronTable,kGCelectronTable);}
}// end kGCrunChic
-
+
//---------------------------------------------- Neutral Meson ---------------------------------------------------------
if(kGCrunNeutralMeson){
if(kGCplotMCConversionR == kTRUE){ histograms->AddHistogram("MC_Conversion_R","Radius of gamma conversion points",kGCnXBinsR, kGCfirstXBinR, kGClastXBinR,"counts","cm");}
if(kGCplotMCConversionZR == kTRUE){ histograms->AddHistogram("MC_Conversion_ZR","Radius of gamma conversion points vs Z",kGCnXBinsZR, kGCfirstXBinZR, kGClastXBinZR, kGCnYBinsZR, kGCfirstYBinZR, kGClastYBinZR, "cm", "cm");}
if(kGCplotMCConversionXY == kTRUE){ histograms->AddHistogram("MC_Conversion_XY","Gamma XY converison point.",kGCnXBinsXY, kGCfirstXBinXY, kGClastXBinXY, kGCnYBinsXY, kGCfirstYBinXY, kGClastYBinXY, "cm", "cm");}
if(kGCplotMCConversionOpeningAngle == kTRUE){ histograms->AddHistogram("MC_Conversion_OpeningAngle","Opening angle of e+e- pairs from gamma conversion",kGCnXBinsOpeningAngle, kGCfirstXBinOpeningAngle, kGClastXBinOpeningAngle, "counts", "cm");}
-
+
if(kGCplotMCEEnergy == kTRUE){ histograms->AddHistogram("MC_E_Energy" ,"" , kGCnXBinsEnergy, kGCfirstXBinEnergy, kGClastXBinEnergy, "", "");}
if(kGCplotMCEPt == kTRUE){ histograms->AddHistogram("MC_E_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
if(kGCplotMCEEta == kTRUE){ histograms->AddHistogram("MC_E_Eta" ,"" , kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
if(kGCplotMCEPhi == kTRUE){ histograms->AddHistogram("MC_E_Phi" ,"" , kGCnXBinsPhi, kGCfirstXBinPhi, kGClastXBinPhi, "", "");}
-
+
if(kGCplotMCPEnergy == kTRUE){ histograms->AddHistogram("MC_P_Energy" ,"" , kGCnXBinsEnergy, kGCfirstXBinEnergy, kGClastXBinEnergy, "", "");}
if(kGCplotMCPPt == kTRUE){ histograms->AddHistogram("MC_P_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
if(kGCplotMCPEta == kTRUE){ histograms->AddHistogram("MC_P_Eta" ,"" , kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
if(kGCplotMCPPhi == kTRUE){ histograms->AddHistogram("MC_P_Phi" ,"" , kGCnXBinsPhi, kGCfirstXBinPhi, kGClastXBinPhi, "", "");}
-
+
if(kGCplotMCallGammaEnergy == kTRUE){ histograms->AddHistogram("MC_allGamma_Energy" ,"" , kGCnXBinsEnergy, kGCfirstXBinEnergy, kGClastXBinEnergy, "", "");}
if(kGCplotMCallGammaPt == kTRUE){ histograms->AddHistogram("MC_allGamma_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
if(kGCplotMCallGammaEta == kTRUE){ histograms->AddHistogram("MC_allGamma_Eta" ,"" , kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
if(kGCplotMCallGammaPhi == kTRUE){ histograms->AddHistogram("MC_allGamma_Phi" ,"" , kGCnXBinsPhi, kGCfirstXBinPhi, kGClastXBinPhi, "", "");}
if(kGCplotMCallGammaRapid == kTRUE){ histograms->AddHistogram("MC_allGamma_Rapid" ,"" , kGCnXBinsRapid, kGCfirstXBinRapid, kGClastXBinRapid, "", "");}
-
+
if(kGCplotMCConvGammaEnergy == kTRUE){ histograms->AddHistogram("MC_ConvGamma_Energy" ,"" , kGCnXBinsEnergy, kGCfirstXBinEnergy, kGClastXBinEnergy, "", "");}
if(kGCplotMCConvGammaPt == kTRUE){ histograms->AddHistogram("MC_ConvGamma_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
if(kGCplotMCConvGammaEta == kTRUE){ histograms->AddHistogram("MC_ConvGamma_Eta" ,"" , kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
if(kGCplotMCConvGammaPhi == kTRUE){ histograms->AddHistogram("MC_ConvGamma_Phi" ,"" , kGCnXBinsPhi, kGCfirstXBinPhi, kGClastXBinPhi, "", "");}
if(kGCplotMCConvGammaRapid == kTRUE){ histograms->AddHistogram("MC_ConvGamma_Rapid" ,"" , kGCnXBinsRapid, kGCfirstXBinRapid, kGClastXBinRapid, "", "");}
if(kGCplotMCConvGammaPtvsEta == kTRUE){ histograms->AddHistogram("MC_ConvGamma_Pt_Eta","", kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt,kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta,"","");}
-
+
if(kGCplotMCallDirectGammaEnergy == kTRUE){ histograms->AddHistogram("MC_allDirectGamma_Energy" ,"" , kGCnXBinsEnergy, kGCfirstXBinEnergy, kGClastXBinEnergy, "", "");}
if(kGCplotMCallDirectGammaPt == kTRUE){ histograms->AddHistogram("MC_allDirectGamma_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
if(kGCplotMCallDirectGammaEta == kTRUE){ histograms->AddHistogram("MC_allDirectGamma_Eta" ,"" , kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
if(kGCplotMCallDirectGammaPhi == kTRUE){ histograms->AddHistogram("MC_allDirectGamma_Phi" ,"" , kGCnXBinsPhi, kGCfirstXBinPhi, kGClastXBinPhi, "", "");}
if(kGCplotMCallDirectGammaRapid == kTRUE){ histograms->AddHistogram("MC_allDirectGamma_Rapid" ,"" , kGCnXBinsRapid, kGCfirstXBinRapid, kGClastXBinRapid, "", "");}
-
+
if(kGCplotMCConvDirectGammaEnergy == kTRUE){ histograms->AddHistogram("MC_ConvDirectGamma_Energy" ,"" , kGCnXBinsEnergy, kGCfirstXBinEnergy, kGClastXBinEnergy, "", "");}
if(kGCplotMCConvDirectGammaPt == kTRUE){ histograms->AddHistogram("MC_ConvDirectGamma_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
if(kGCplotMCConvDirectGammaEta == kTRUE){ histograms->AddHistogram("MC_ConvDirectGamma_Eta" ,"" , kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
if(kGCplotMCConvDirectGammaPhi == kTRUE){ histograms->AddHistogram("MC_ConvDirectGamma_Phi" ,"" , kGCnXBinsPhi, kGCfirstXBinPhi, kGClastXBinPhi, "", "");}
if(kGCplotMCConvDirectGammaRapid == kTRUE){ histograms->AddHistogram("MC_ConvDirectGamma_Rapid" ,"" , kGCnXBinsRapid, kGCfirstXBinRapid, kGClastXBinRapid, "", "");}
-
+
if(kGCplotMCMotherEta == kTRUE){ histograms->AddHistogram("MC_Mother_Eta" ,"" , kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
if(kGCplotMCMotherPhi == kTRUE){ histograms->AddHistogram("MC_Mother_Phi" ,"" , kGCnXBinsPhi, kGCfirstXBinPhi, kGClastXBinPhi, "", "");}
if(kGCplotMCMotherRapid == kTRUE){ histograms->AddHistogram("MC_Mother_Rapid" ,"" , kGCnXBinsRapid, kGCfirstXBinRapid, kGClastXBinRapid, "", "");}
if(kGCplotMCMotherPtvsRapidWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Mother_Pt_Rapid_withinAcceptance" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, kGCnXBinsRapid, kGCfirstXBinRapid, kGClastXBinRapid, "", "");}
if(kGCplotMCMotherPtvsEtaConvGammaWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Mother_Pt_Eta_ConvGamma_withinAcceptance" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
if(kGCplotMCMotherPtvsRapidConvGammaWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Mother_Pt_Rapid_ConvGamma_withinAcceptance" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, kGCnXBinsRapid, kGCfirstXBinRapid, kGClastXBinRapid, "", "");}
-
+
if(kGCplotMCMotherSpectra == kTRUE){
histograms->AddHistogram("MC_Mother_InvMass_vs_Pt" ,"" ,kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra, kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra, "", "");
histograms->AddHistogram("MC_Mother_InvMass_vs_Pt_withinAcceptance" ,"" ,kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra, kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra, "", "");
histograms->AddHistogram("MC_Mother_InvMass_vs_Pt_ConvGamma_withinAcceptance" ,"" ,kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra, kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra, "", "");
}
-
-
+
+
if(kGCplotMCPi0Eta == kTRUE){ histograms->AddHistogram("MC_Pi0_Eta" ,"" , kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
if(kGCplotMCPi0Rapid == kTRUE){ histograms->AddHistogram("MC_Pi0_Rapid" ,"" , kGCnXBinsRapid, kGCfirstXBinRapid, kGClastXBinRapid, "", "");}
if(kGCplotMCPi0Phi == kTRUE){ histograms->AddHistogram("MC_Pi0_Phi" ,"" , kGCnXBinsPhi, kGCfirstXBinPhi, kGClastXBinPhi, "", "");}
if(kGCplotMCPi0PtvsEtaConvGammaWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Pi0_Pt_Eta_ConvGamma_withinAcceptance" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
if(kGCplotMCPi0PtvsRapidConvGammaWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Pi0_Pt_Rapid_ConvGamma_withinAcceptance" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, kGCnXBinsRapid, kGCfirstXBinRapid, kGClastXBinRapid, "", "");}
if(kGCplotMCPi0ZRConvGammaWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Pi0_ZR_ConvGamma_withinAcceptance" ,"" , kGCnXBinsZR, kGCfirstXBinZR, kGClastXBinZR, kGCnYBinsZR, kGCfirstYBinZR, kGClastYBinZR, "", "");}
-
-
+
+
if(kGCplotMCPi0SecondaryEta == kTRUE){ histograms->AddHistogram("MC_Pi0_Secondaries_Eta" ,"" , kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
if(kGCplotMCPi0SecondaryRapid == kTRUE){ histograms->AddHistogram("MC_Pi0_Secondaries_Rapid" ,"" , kGCnXBinsRapid, kGCfirstXBinRapid, kGClastXBinRapid, "", "");}
if(kGCplotMCPi0SecondaryPhi == kTRUE){ histograms->AddHistogram("MC_Pi0_Secondaries_Phi" ,"" , kGCnXBinsPhi, kGCfirstXBinPhi, kGClastXBinPhi, "", "");}
if(kGCplotMCPi0SecondaryPtvsRapidWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Pi0_Secondaries_Pt_Rapid_withinAcceptance" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, kGCnXBinsRapid, kGCfirstXBinRapid, kGClastXBinRapid, "", "");}
if(kGCplotMCPi0SecondaryPtvsEtaConvGammaWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Pi0_Secondaries_Pt_Eta_ConvGamma_withinAcceptance" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
if(kGCplotMCPi0SecondaryPtvsRapidConvGammaWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Pi0_Secondaries_Pt_Rapid_ConvGamma_withinAcceptance" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, kGCnXBinsRapid, kGCfirstXBinRapid, kGClastXBinRapid, "", "");}
-
-
-
+
+
+
if(kGCplotMCEtaEta == kTRUE){ histograms->AddHistogram("MC_Eta_Eta" ,"" , kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
if(kGCplotMCEtaRapid == kTRUE){ histograms->AddHistogram("MC_Eta_Rapid" ,"" , kGCnXBinsRapid, kGCfirstXBinRapid, kGClastXBinRapid, "", "");}
if(kGCplotMCEtaPhi == kTRUE){ histograms->AddHistogram("MC_Eta_Phi" ,"" , kGCnXBinsPhi, kGCfirstXBinPhi, kGClastXBinPhi, "", "");}
if(kGCplotMCEtaPtvsEtaConvGammaWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Eta_Pt_Eta_ConvGamma_withinAcceptance" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
if(kGCplotMCEtaPtvsRapidConvGammaWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Eta_Pt_Rapid_ConvGamma_withinAcceptance" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, kGCnXBinsRapid, kGCfirstXBinRapid, kGClastXBinRapid, "", "");}
if(kGCplotMCEtaZRConvGammaWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Eta_ZR_ConvGamma_withinAcceptance" ,"" , kGCnXBinsZR, kGCfirstXBinZR, kGClastXBinZR, kGCnYBinsZR, kGCfirstYBinZR, kGClastYBinZR, "", "");}
-
-
+
+
// Histograms from esd tracks
if(kGCplotESDEEnergy == kTRUE){ histograms->AddHistogram("ESD_E_Energy" ,"" , kGCnXBinsEnergy, kGCfirstXBinEnergy, kGClastXBinEnergy, "", "");}
if(kGCplotESDEPt == kTRUE){ histograms->AddHistogram("ESD_E_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
if(kGCplotESDEEta == kTRUE){ histograms->AddHistogram("ESD_E_Eta" ,"" , kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
if(kGCplotESDEPhi == kTRUE){ histograms->AddHistogram("ESD_E_Phi" ,"" , kGCnXBinsPhi, kGCfirstXBinPhi, kGClastXBinPhi, "", "");}
-
+
if(kGCplotESDPEnergy == kTRUE){ histograms->AddHistogram("ESD_P_Energy" ,"" , kGCnXBinsEnergy, kGCfirstXBinEnergy, kGClastXBinEnergy, "", "");}
if(kGCplotESDPPt == kTRUE){ histograms->AddHistogram("ESD_P_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
if(kGCplotESDPEta == kTRUE){ histograms->AddHistogram("ESD_P_Eta" ,"" , kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
if(kGCplotESDPPhi == kTRUE){ histograms->AddHistogram("ESD_P_Phi" ,"" , kGCnXBinsPhi, kGCfirstXBinPhi, kGClastXBinPhi, "", "");}
-
+
if(kGCplotESDConvGammaEnergy == kTRUE){ histograms->AddHistogram("ESD_ConvGamma_Energy" ,"" , kGCnXBinsEnergy, kGCfirstXBinEnergy, kGClastXBinEnergy, "", "");}
if(kGCplotESDConvGammaPt == kTRUE){ histograms->AddHistogram("ESD_ConvGamma_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
if(kGCplotESDConvGammaEta == kTRUE){ histograms->AddHistogram("ESD_ConvGamma_Eta" ,"" , kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
if(kGCplotESDConvGammaPtvsEta == kTRUE){ histograms->AddHistogram("ESD_ConvGamma_Pt_Eta","", kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt,kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta,"","" );}
if(kGCplotESDConvGammaPtvsChi2 == kTRUE){ histograms->AddHistogram("ESD_ConvGamma_Pt_Chi2" ,"" ,kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, kGCnXBinsGammaChi2, kGCfirstXBinGammaChi2, kGClastXBinGammaChi2, "", "");}
if(kGCplotESDConvGammaEtavsChi2 == kTRUE){ histograms->AddHistogram("ESD_ConvGamma_Eta_Chi2" ,"" ,kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, kGCnXBinsGammaChi2, kGCfirstXBinGammaChi2, kGClastXBinGammaChi2, "", "");}
-
-
-
+
+
+
if(kGCplotESDConversionR == kTRUE){ histograms->AddHistogram("ESD_Conversion_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");}
if(kGCplotESDConversionZR == kTRUE){ histograms->AddHistogram("ESD_Conversion_ZR" ,"" , kGCnXBinsZR, kGCfirstXBinZR, kGClastXBinZR, kGCnYBinsZR, kGCfirstYBinZR, kGClastYBinZR, "", "");}
if(kGCplotESDConversionXY == kTRUE){ histograms->AddHistogram("ESD_Conversion_XY" ,"" , kGCnXBinsXY, kGCfirstXBinXY, kGClastXBinXY, kGCnYBinsXY, kGCfirstYBinXY, kGClastYBinXY, "", "");}
if(kGCplotESDConversionOpeningAngle == kTRUE){ histograms->AddHistogram("ESD_Conversion_OpeningAngle" ,"" , kGCnXBinsOpeningAngle, kGCfirstXBinOpeningAngle, kGClastXBinOpeningAngle, "", "");}
-
-
+
+
if(kGCplotESDTrueConvGammaEnergy == kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_Energy" ,"" , kGCnXBinsEnergy, kGCfirstXBinEnergy, kGClastXBinEnergy, "", "");}
if(kGCplotESDTrueConvGammaPt == kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
if(kGCplotESDTrueConvGammaEta == kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_Eta" ,"" , kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
if(kGCplotESDTrueConvGammaPtvsEta == kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_Pt_Eta" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt,kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
if(kGCplotESDTrueConvGammaPtvsChi2 == kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_Pt_Chi2" ,"" ,kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, kGCnXBinsGammaChi2, kGCfirstXBinGammaChi2, kGClastXBinGammaChi2, "", "");}
if(kGCplotESDTrueConvGammaEtavsChi2 == kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_Eta_Chi2" ,"" ,kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, kGCnXBinsGammaChi2, kGCfirstXBinGammaChi2, kGClastXBinGammaChi2, "", "");}
-
+
if(kGCplotESDTrueConversionR == kTRUE){ histograms->AddHistogram("ESD_TrueConversion_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");}
if(kGCplotESDTrueConversionZR == kTRUE){ histograms->AddHistogram("ESD_TrueConversion_ZR" ,"" , kGCnXBinsZR, kGCfirstXBinZR, kGClastXBinZR, kGCnYBinsZR, kGCfirstYBinZR, kGClastYBinZR, "", "");}
if(kGCplotESDTrueConversionXY == kTRUE){ histograms->AddHistogram("ESD_TrueConversion_XY" ,"" , kGCnXBinsXY, kGCfirstXBinXY, kGClastXBinXY, kGCnYBinsXY, kGCfirstYBinXY, kGClastYBinXY, "", "");}
if(kGCplotESDTrueConversionOpeningAngle == kTRUE){ histograms->AddHistogram("ESD_TrueConversion_OpeningAngle" ,"" , kGCnXBinsOpeningAngle, kGCfirstXBinOpeningAngle, kGClastXBinOpeningAngle, "", "");}
-
+
if(kGCplotESDTrueConvGammaMCPtEta == kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_MC_Pt_Eta" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
if(kGCplotESDTrueConversionMCZR == kTRUE){ histograms->AddHistogram("ESD_TrueConversion_MC_ZR" ,"" , kGCnXBinsZR, kGCfirstXBinZR, kGClastXBinZR, kGCnYBinsZR, kGCfirstYBinZR, kGClastYBinZR, "", "");}
if(kGCplotESDTrueConversionMCXY == kTRUE){ histograms->AddHistogram("ESD_TrueConversion_MC_XY" ,"" , kGCnXBinsXY, kGCfirstXBinXY, kGClastXBinXY, kGCnYBinsXY, kGCfirstYBinXY, kGClastYBinXY, "", "");}
-
-
-
+
+
+
if(kGCplotESDNoCutConvGammaEnergy == kTRUE){ histograms->AddHistogram("ESD_NoCutConvGamma_Energy" ,"" , kGCnXBinsEnergy, kGCfirstXBinEnergy, kGClastXBinEnergy, "", "");}
if(kGCplotESDNoCutConvGammaPt == kTRUE){ histograms->AddHistogram("ESD_NoCutConvGamma_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
if(kGCplotESDNoCutConvGammaEta == kTRUE){ histograms->AddHistogram("ESD_NoCutConvGamma_Eta" ,"" , kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
if(kGCplotESDNoCutConvGammaPtvsEta == kTRUE){ histograms->AddHistogram("ESD_NoCutConvGamma_Pt_Eta" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt,kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
if(kGCplotESDNoCutConvGammaPtvsChi2 == kTRUE){ histograms->AddHistogram("ESD_NoCutConvGamma_Pt_Chi2" ,"" ,kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, kGCnXBinsGammaChi2, kGCfirstXBinGammaChi2, kGClastXBinGammaChi2, "", "");}
if(kGCplotESDNoCutConvGammaEtavsChi2 == kTRUE){ histograms->AddHistogram("ESD_NoCutConvGamma_Eta_Chi2" ,"" ,kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, kGCnXBinsGammaChi2, kGCfirstXBinGammaChi2, kGClastXBinGammaChi2, "", "");}
-
+
if(kGCplotESDNoCutConversionR == kTRUE){ histograms->AddHistogram("ESD_NoCutConversion_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");}
if(kGCplotESDNoCutConversionZR == kTRUE){ histograms->AddHistogram("ESD_NoCutConversion_ZR" ,"" , kGCnXBinsZR, kGCfirstXBinZR, kGClastXBinZR, kGCnYBinsZR, kGCfirstYBinZR, kGClastYBinZR, "", "");}
if(kGCplotESDNoCutConversionXY == kTRUE){ histograms->AddHistogram("ESD_NoCutConversion_XY" ,"" , kGCnXBinsXY, kGCfirstXBinXY, kGClastXBinXY, kGCnYBinsXY, kGCfirstYBinXY, kGClastYBinXY, "", "");}
if(kGCplotESDNoCutConversionOpeningAngle == kTRUE){ histograms->AddHistogram("ESD_NoCutConversion_OpeningAngle" ,"" , kGCnXBinsOpeningAngle, kGCfirstXBinOpeningAngle, kGClastXBinOpeningAngle, "", "");}
-
+
if(kGCplotESDNoCutConvGammaMCPtEta == kTRUE){ histograms->AddHistogram("ESD_NoCutConvGamma_MC_Pt_Eta" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
if(kGCplotESDNoCutConversionMCZR == kTRUE){ histograms->AddHistogram("ESD_NoCutConversion_MC_ZR" ,"" , kGCnXBinsZR, kGCfirstXBinZR, kGClastXBinZR, kGCnYBinsZR, kGCfirstYBinZR, kGClastYBinZR, "", "");}
if(kGCplotESDNoCutConversionMCXY == kTRUE){ histograms->AddHistogram("ESD_NoCutConversion_MC_XY" ,"" , kGCnXBinsXY, kGCfirstXBinXY, kGClastXBinXY, kGCnYBinsXY, kGCfirstYBinXY, kGClastYBinXY, "", "");}
-
-
-
+
+
+
if(kGCplotESDMotherOpeningAngleGamma == kTRUE){ histograms->AddHistogram("ESD_Mother_GammaDaughter_OpeningAngle" ,"" , kGCnXBinsOpeningAngle, kGCfirstXBinOpeningAngle, kGClastXBinOpeningAngle, "", "");}
if(kGCplotESDMotherEnergy == kTRUE){ histograms->AddHistogram("ESD_Mother_Energy" ,"" , kGCnXBinsEnergy, kGCfirstXBinEnergy, kGClastXBinEnergy, "", "");}
if(kGCplotESDMotherPt == kTRUE){ histograms->AddHistogram("ESD_Mother_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
if(kGCplotESDMotherZR == kTRUE){ histograms->AddHistogram("ESD_Mother_ZR" ,"" , kGCnXBinsZR, kGCfirstXBinZR, kGClastXBinZR, kGCnYBinsZR, kGCfirstYBinZR, kGClastYBinZR, "", "");}
if(kGCplotESDMotherXY == kTRUE){ histograms->AddHistogram("ESD_Mother_XY" ,"" , kGCnXBinsXY, kGCfirstXBinXY, kGClastXBinXY, kGCnYBinsXY, kGCfirstYBinXY, kGClastYBinXY, "", "");}
if(kGCplotESDMotherRapid == kTRUE){ histograms->AddHistogram("ESD_Mother_Rapid" ,"" , kGCnXBinsRapid, kGCfirstXBinRapid, kGClastXBinRapid, "", "");}
-
-
+
+
if(kGCplotESDBackgroundOpeningAngleGamma == kTRUE){ histograms->AddHistogram("ESD_Background_GammaDaughter_OpeningAngle" ,"" , kGCnXBinsOpeningAngle, kGCfirstXBinOpeningAngle, kGClastXBinOpeningAngle, "", "");}
if(kGCplotESDBackgroundEnergy == kTRUE){ histograms->AddHistogram("ESD_Background_Energy" ,"" , kGCnXBinsEnergy, kGCfirstXBinEnergy, kGClastXBinEnergy, "", "");}
if(kGCplotESDBackgroundPt == kTRUE){ histograms->AddHistogram("ESD_Background_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
if(kGCplotESDBackgroundZR == kTRUE){ histograms->AddHistogram("ESD_Background_ZR" ,"" , kGCnXBinsZR, kGCfirstXBinZR, kGClastXBinZR, kGCnYBinsZR, kGCfirstYBinZR, kGClastYBinZR, "", "");}
if(kGCplotESDBackgroundXY == kTRUE){ histograms->AddHistogram("ESD_Background_XY" ,"" , kGCnXBinsXY, kGCfirstXBinXY, kGClastXBinXY, kGCnYBinsXY, kGCfirstYBinXY, kGClastYBinXY, "", "");}
if(kGCplotESDBackgroundRapid == kTRUE){ histograms->AddHistogram("ESD_Background_Rapid" ,"" , kGCnXBinsRapid, kGCfirstXBinRapid, kGClastXBinRapid, "", "");}
-
-
+
+
if(kGCplotMapping == kTRUE){
- histograms->InitializeMappingValues(nPhiIndex,nRIndex,kGCnXBinsMapping,minRadius,maxRadius,kGCnYBinsMapping,minPhi,maxPhi);
- histograms->AddMappingHistograms(nPhiIndex,nRIndex,kGCnXBinsMapping,minRadius,maxRadius,kGCnYBinsMapping,minPhi,maxPhi);
+ histograms->InitializeMappingValues(kGCnPhiIndex,kGCnRIndex,kGCnXBinsMapping,kGCminRadius,kGCmaxRadius,kGCnYBinsMapping,kGCminPhi,kGCmaxPhi);
+ histograms->AddMappingHistograms(kGCnPhiIndex,kGCnRIndex,kGCnXBinsMapping,kGCminRadius,kGCmaxRadius,kGCnYBinsMapping,kGCminPhi,kGCmaxPhi);
}
-
+
if(kGCplotResolutiondPt == kTRUE){histograms->AddHistogram("Resolution_dPt" ,"" , kGCnXBinsResdPt, kGCfirstXBinResdPt, kGClastXBinResdPt, kGCnYBinsResdPt, kGCfirstYBinResdPt, kGClastYBinResdPt, "", "");}
if(kGCplotResolutiondR == kTRUE){histograms->AddHistogram("Resolution_dR" ,"" , kGCnXBinsResdR, kGCfirstXBinResdR, kGClastXBinResdR, kGCnYBinsResdR, kGCfirstYBinResdR, kGClastYBinResdR, "", "");}
if(kGCplotResolutiondZ == kTRUE){histograms->AddHistogram("Resolution_dZ" ,"" , kGCnXBinsResdZ, kGCfirstXBinResdZ, kGClastXBinResdZ, kGCnYBinsResdZ, kGCfirstYBinResdZ, kGClastYBinResdZ, "", "");}
-
+
if(kGCplotResolutiondRdPt == kTRUE){histograms->AddHistogram("Resolution_dR_dPt" ,"" , kGCnXBinsResdRdPt, kGCfirstXBinResdRdPt, kGClastXBinResdRdPt, kGCnYBinsResdRdPt, kGCfirstYBinResdRdPt, kGClastYBinResdRdPt, "", "");}
-
+
if(kGCplotResolutionMCPt == kTRUE){histograms->AddHistogram("Resolution_MC_Pt" ,"" , kGCnXBinsResPt, kGCfirstXBinResPt, kGClastXBinResPt,"","");}
if(kGCplotResolutionMCR == kTRUE){histograms->AddHistogram("Resolution_MC_R" ,"" , kGCnXBinsResR, kGCfirstXBinResR, kGClastXBinResR,"","");}
if(kGCplotResolutionMCZ == kTRUE){histograms->AddHistogram("Resolution_MC_Z" ,"" , kGCnXBinsResZ, kGCfirstXBinResZ, kGClastXBinResZ,"","");}
-
+
if(kGCplotResolutionESDPt == kTRUE){histograms->AddHistogram("Resolution_ESD_Pt" ,"" , kGCnXBinsResPt, kGCfirstXBinResPt, kGClastXBinResPt,"","");}
if(kGCplotResolutionESDR == kTRUE){histograms->AddHistogram("Resolution_ESD_R" ,"" , kGCnXBinsResR, kGCfirstXBinResR, kGClastXBinResR,"","");}
if(kGCplotResolutionESDZ == kTRUE){histograms->AddHistogram("Resolution_ESD_Z" ,"" , kGCnXBinsResZ, kGCfirstXBinResZ, kGClastXBinResZ,"","");}
-
+
if(kGCplotESDNumberOfV0s == kTRUE){histograms->AddHistogram("ESD_NumberOfV0s","Number of v0s",100, 0, 100,"","");}
if(kGCplotESDNumberOfSurvivingV0s == kTRUE){histograms->AddHistogram("ESD_NumberOfSurvivingV0s","Number of surviving v0s",100, 0, 100,"","");}
-
+
// debug histograms
if(kGCplotESDCutGetOnFly == kTRUE){histograms->AddHistogram("ESD_CutGetOnFly_InvMass" ,"Not GetOnFly" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
if(kGCplotESDCutNContributors == kTRUE){histograms->AddHistogram("ESD_CutNContributors_InvMass" ,"NContributors <= 0" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
if(kGCplotESDCutLine == kTRUE){histograms->AddHistogram("ESD_CutLine_InvMass" ,"Out of reconstruction area" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
if(kGCplotESDTrueConvGammaTrackLength == kTRUE){histograms->AddHistogram("ESD_TrueConvGamma_TrackLength","Track length of TrueConvGamma",kGCnXBinsTrackLength,kGCfirstXBinTrackLength,kGClastXBinTrackLength,"","");}
if(kGCplotESDTrueConvGammaTrackLengthVSInvMass == kTRUE){histograms->AddHistogram("ESD_TrueConvGamma_TrackLengthVSInvMass","Track length of TrueConvGamma vs Inv mass",kGCnXBinsTrackLength,kGCfirstXBinTrackLength,kGClastXBinTrackLength,kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt,"","");}
-
-
+
+
if(kGCplotPi0Spectra == kTRUE){
histograms->AddHistogram("ESD_Mother_InvMass_vs_Pt" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
histograms->AddHistogram("ESD_Mother_InvMass","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff