#include <AliMCEventHandler.h>
#include "TRandom3.h"
#include "AliTriggerAnalysis.h"
+#include "AliESDCentrality.h"
class AliESDTrackCuts;
class AliCFContainer;
fTriggerAnalysis(NULL),
fMultiplicity(0),
fUseMultiplicity(0),
- fUseMultiplicityBin(0)
+ fUseMultiplicityBin(0),
+ fUseCentrality(0),
+ fUseCentralityBin(0)
{
// Default constructor
fTriggerAnalysis(NULL),
fMultiplicity(0),
fUseMultiplicity(0),
- fUseMultiplicityBin(0)
+ fUseMultiplicityBin(0),
+ fUseCentrality(0),
+ fUseCentralityBin(0)
{
// Common I/O in slot 0
DefineInput (0, TChain::Class());
// Using standard function for setting Cuts
Bool_t selectPrimaries=kTRUE;
fEsdTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);
+ fEsdTrackCuts->SetMaxDCAToVertexZ(2);
fEsdTrackCuts->SetEtaRange(-0.8, 0.8);
fEsdTrackCuts->SetPtRange(0.15);
return;
}
+ if(fV0Reader->GetIsHeavyIon()){
+ if(fUseCentrality>0){
+ AliESDCentrality *esdCentrality = fV0Reader->GetESDEvent()->GetCentrality();
+ Int_t centralityC = -1;
+
+ if(fUseCentrality==1){
+ centralityC = esdCentrality->GetCentralityClass10("V0M");
+ if( centralityC != fUseCentralityBin ){
+ eventQuality=7;
+ fHistograms->FillHistogram("ESD_EventQuality",eventQuality);
+ return;
+ }
+ }
+
+ if(fUseCentrality==2){
+ centralityC = esdCentrality->GetCentralityClass10("CL1");
+ if( centralityC != fUseCentralityBin ){
+ eventQuality=7;
+ fHistograms->FillHistogram("ESD_EventQuality",eventQuality);
+ return;
+ }
+ }
+ }
+ }
eventQuality=3;
fHistograms->FillHistogram("ESD_EventQuality",eventQuality);
Int_t zBin = fHistograms->GetZBin(ePos->Vz());
Int_t phiBin = fHistograms->GetPhiBin(particle->Phi());
Double_t rFMD=30;
+ Double_t rITSTPCMin=50;
+ Double_t rITSTPCMax=80;
TVector3 vtxPos(ePos->Vx(),ePos->Vy(),ePos->Vz());
fHistograms->FillHistogram(nameMCMappingFMDPhiInZ, vtxPos.Phi());
}
+ if(ePos->R()>rITSTPCMin && ePos->R()<rITSTPCMax){
+ TString nameMCMappingITSTPCPhiInZ="";
+ nameMCMappingITSTPCPhiInZ.Form("MC_Conversion_Mapping_ITSTPC_Phi_in_Z_%02d",zBin);
+ fHistograms->FillHistogram(nameMCMappingITSTPCPhiInZ, vtxPos.Phi());
+ }
+
TString nameMCMappingRInZ="";
nameMCMappingRInZ.Form("MC_Conversion_Mapping_R_in_Z_%02d",zBin);
fHistograms->FillHistogram(nameMCMappingRInZ,ePos->R() );
Int_t zBin = fHistograms->GetZBin(fV0Reader->GetZ());
Int_t phiBin = fHistograms->GetPhiBin(fV0Reader->GetNegativeTrackPhi());
Double_t rFMD=30;
-
+ Double_t rITSTPCMin=50;
+ Double_t rITSTPCMax=80;
// Double_t motherCandidateEta= fV0Reader->GetMotherCandidateEta();
fHistograms->FillHistogram(nameESDMappingFMDPhiInZ, vtxConv.Phi());
}
+ if(fV0Reader->GetXYRadius()>rITSTPCMin && fV0Reader->GetXYRadius()<rITSTPCMax){
+ TString nameESDMappingITSTPCPhiInZ="";
+ nameESDMappingITSTPCPhiInZ.Form("ESD_Conversion_Mapping_ITSTPC_Phi_in_Z_%02d",zBin);
+ fHistograms->FillHistogram(nameESDMappingITSTPCPhiInZ, vtxConv.Phi());
+ }
TString nameESDMappingRInZ="";
nameESDMappingRInZ.Form("ESD_Conversion_Mapping_R_in_Z_%02d",zBin);
//----------------------------------- checking for "real" conversions (MC match) --------------------------------------
if(fDoMCTruth){
+ TParticle * negativeMC = (TParticle*)fV0Reader->GetNegativeMCParticle();
+ TParticle * positiveMC = (TParticle*)fV0Reader->GetPositiveMCParticle();
if(fV0Reader->HasSameMCMother() == kFALSE){
+ fHistograms->FillHistogram("ESD_TrueConvCombinatorial_R", fV0Reader->GetXYRadius());
+ if(TMath::Abs(negativeMC->GetPdgCode())==11 && TMath::Abs(positiveMC->GetPdgCode())==11){
+ fHistograms->FillHistogram("ESD_TrueConvCombinatorialElec_R", fV0Reader->GetXYRadius());
+ }
continue;
}
- TParticle * negativeMC = (TParticle*)fV0Reader->GetNegativeMCParticle();
- TParticle * positiveMC = (TParticle*)fV0Reader->GetPositiveMCParticle();
+ // Moved up to check true electron background
+ // TParticle * negativeMC = (TParticle*)fV0Reader->GetNegativeMCParticle();
+ // TParticle * positiveMC = (TParticle*)fV0Reader->GetPositiveMCParticle();
if(TMath::Abs(negativeMC->GetPdgCode())!=11 || TMath::Abs(positiveMC->GetPdgCode())!=11){
continue;
(negativeMC->GetUniqueID() == 0 && positiveMC->GetUniqueID() ==0) ){// fill r distribution for Dalitz decays
if(fV0Reader->GetMotherMCParticle()->GetPdgCode() == 111){ //pi0
fHistograms->FillHistogram("ESD_TrueDalitzContamination_R", fV0Reader->GetXYRadius());
+ fHistograms->FillHistogram("ESD_TrueConvDalitzPi0_R", fV0Reader->GetXYRadius());
}
+ if(fV0Reader->GetMotherMCParticle()->GetPdgCode() == 221){ //eta
+ fHistograms->FillHistogram("ESD_TrueConvDalitzEta_R", fV0Reader->GetXYRadius());
+ }
+
}
if(negativeMC->GetUniqueID() != 5 || positiveMC->GetUniqueID() !=5){// check if the daughters come from a conversion
void SetUseMultiplicity(Int_t useMultiplicity) {fUseMultiplicity=useMultiplicity;}
void SetUseMultiplicityBin(Int_t useMultiplicityBin) {fUseMultiplicityBin=useMultiplicityBin;}
Int_t CalculateMultiplicityBin();
+ void SetUseCentrality(Int_t useCentrality) {fUseCentrality=useCentrality;}
+ void SetUseCentralityBin(Int_t useCentralityBin) {fUseCentralityBin=useCentralityBin;}
+
+
+
+
private:
AliAnalysisTaskGammaConversion(const AliAnalysisTaskGammaConversion&); // Not implemented
AliAnalysisTaskGammaConversion& operator=(const AliAnalysisTaskGammaConversion&); // Not implemented
Int_t fMultiplicity;
Int_t fUseMultiplicity;
Int_t fUseMultiplicityBin;
- ClassDef(AliAnalysisTaskGammaConversion, 15); // Analysis task for gamma conversions
+ Int_t fUseCentrality;
+ Int_t fUseCentralityBin;
+ ClassDef(AliAnalysisTaskGammaConversion, 16); // Analysis task for gamma conversions
};
#endif //ALIANALYSISTASKGAMMA_H
// AddHistogram(nameMCPhiInR, titleMCPhiInR, nXBins, firstX, lastX, xAxisTitle, yAxisTitle);
AddHistogram(nameMCFMDPhiInZ, titleMCFMDPhiInZ, nXBins, -TMath::Pi(), TMath::Pi(), xAxisTitle, yAxisTitle);
+ //Mapping Phi in Z for ITSTPC
+ TString nameMCITSTPCPhiInZ="";
+ nameMCITSTPCPhiInZ.Form("MC_Conversion_Mapping_ITSTPC_Phi_in_Z_%02d",z);
+ TString titleMCITSTPCPhiInZ="";
+ titleMCITSTPCPhiInZ.Form("MC Mapping ITSTPC of Phi in Z%02d",z);
+ // AddHistogram(nameMCPhiInR, titleMCPhiInR, nXBins, firstX, lastX, xAxisTitle, yAxisTitle);
+ AddHistogram(nameMCITSTPCPhiInZ, titleMCITSTPCPhiInZ, nXBins, -TMath::Pi(), TMath::Pi(), xAxisTitle, yAxisTitle);
+
//Mapping R in Z
TString nameMCRInZ="";
// AddHistogram(nameESDPhiInR, titleESDPhiInR, nXBins, firstX, lastX, xAxisTitle, yAxisTitle);
AddHistogram(nameESDFMDPhiInZ, titleESDFMDPhiInZ, nXBins, -TMath::Pi(), TMath::Pi(), xAxisTitle, yAxisTitle);
+ //Mapping Phi in Z for ITSTPC
+ TString nameESDITSTPCPhiInZ="";
+ nameESDITSTPCPhiInZ.Form("ESD_Conversion_Mapping_ITSTPC_Phi_in_Z_%02d",z);
+ TString titleESDITSTPCPhiInZ="";
+ titleESDITSTPCPhiInZ.Form("ESD Mapping ITSTPC of Phi in Z%02d",z);
+ // AddHistogram(nameESDPhiInR, titleESDPhiInR, nXBins, firstX, lastX, xAxisTitle, yAxisTitle);
+ AddHistogram(nameESDITSTPCPhiInZ, titleESDITSTPCPhiInZ, nXBins, -TMath::Pi(), TMath::Pi(), xAxisTitle, yAxisTitle);
+
//Mapping R in Z
TString nameESDRInZ="";
fNumberOfESDTracks(0),
nEventsForBGCalculation(20),
fUseChargedTrackMultiplicityForBG(kTRUE),
- fNumberOfGoodV0s(0)
+ fNumberOfGoodV0s(0),
+ fIsHeavyIon(0)
{
//fESDpid = new AliESDpid;
}
fNumberOfESDTracks(original.fNumberOfESDTracks),
nEventsForBGCalculation(original.nEventsForBGCalculation),
fUseChargedTrackMultiplicityForBG(original.fUseChargedTrackMultiplicityForBG),
- fNumberOfGoodV0s(original.fNumberOfGoodV0s)
+ fNumberOfGoodV0s(original.fNumberOfGoodV0s),
+ fIsHeavyIon(original.fIsHeavyIon)
{
}
multiplicityBinLimitsArray[3] = 27.5;
multiplicityBinLimitsArray[4] = 41.5;
multiplicityBinLimitsArray[5] = 100.;
-
+ if(fIsHeavyIon){
+ multiplicityBinLimitsArray[0] = 0;
+ multiplicityBinLimitsArray[1] = 200.;
+ multiplicityBinLimitsArray[2] = 500.;
+ multiplicityBinLimitsArray[3] = 1000.;
+ multiplicityBinLimitsArray[4] = 1500.;
+ multiplicityBinLimitsArray[5] = 3000.;
+ }
fBGEventHandler = new AliGammaConversionBGHandler(9,6,nEventsForBGCalculation);
}
else{
multiplicityBinLimitsArray[2] = 4;
multiplicityBinLimitsArray[3] = 5;
multiplicityBinLimitsArray[4] = 9999;
+ if(fIsHeavyIon){
+ multiplicityBinLimitsArray[0] = 2;
+ multiplicityBinLimitsArray[1] = 10;
+ multiplicityBinLimitsArray[2] = 30;
+ multiplicityBinLimitsArray[3] = 50;
+ multiplicityBinLimitsArray[4] = 9999;
+ }
fBGEventHandler = new AliGammaConversionBGHandler(9,5,nEventsForBGCalculation);
}
static AliESDpid* GetESDpid() {return fgESDpid;}
void SetUseChargedTracksMultiplicityForBG(Bool_t flag){fUseChargedTrackMultiplicityForBG = flag;}
-
+ void SetIsHeavyIon(Int_t isHeavyIon) {fIsHeavyIon=isHeavyIon;}
+ Int_t GetIsHeavyIon() const { return fIsHeavyIon;}
+
Int_t GetPindex(Int_t i) {return fV0Pindex.at(i);}
Int_t GetNindex(Int_t i) {return fV0Nindex.at(i);}
Bool_t fUseChargedTrackMultiplicityForBG;
Int_t fNumberOfGoodV0s;
+ Int_t fIsHeavyIon;
- ClassDef(AliV0Reader,16)
+ ClassDef(AliV0Reader,17)
};
inline void AliV0Reader::InitESDpid(Int_t type)
* about the suitability of this software for any purpose. It is *
* provided "as is" without express or implied warranty. *
**************************************************************************/
-const int c_array_size = 23;
+const int c_array_size = 26;
class AliAnalysisDataContainer;
class AliGammaConversionHistograms;
//Svein
Bool_t kGCRunGammaJetTask = kFALSE;
/** ---------------------------------- define cuts here ------------------------------------*/
-TString kGCAnalysisCutSelectionId="90035620401003321022000"; // do not change here, use -set-cut-selection in argument instead
+TString kGCAnalysisCutSelectionId="90035620401003321022000000"; // do not change here, use -set-cut-selection in argument instead
Int_t kGCNEventsForBGCalculation=20;
Bool_t kGCUseMultiplicity = kFALSE;
Int_t kGCUseMultiplicityBin=0;
+Int_t kGCIsHeavyIon = 0;
+Int_t kGCUseCentrality = 0;
+Int_t kGCUseCentralityBin = 0;
+
+
+
/** ---------------------------------- define pi0 dalitz cuts here ------------------------------------*/
Bool_t kGCRunStandalone = kTRUE;
Bool_t kGCplotESDTrueDalitzContaminationR = kTRUE;
+Bool_t kGCplotESDTruePi0DalitzContaminationR = kTRUE;
+Bool_t kGCplotESDTrueEtaDalitzContaminationR = kTRUE;
+Bool_t kGCplotESDTrueCombinatorialContaminationR = kTRUE;
+Bool_t kGCplotESDTrueCombinatorialElecContaminationR = kTRUE;
+
Bool_t kGCplotESDTrueConvGammaEnergy = kFALSE;
Bool_t kGCplotESDTrueConvGammaPt = kTRUE;
Bool_t kGCplotESDTrueConvGammaEta = kTRUE;
//EventQuality-plot
-Int_t kGCnXBinsEvtQ= 8;
+Int_t kGCnXBinsEvtQ= 9;
Double_t kGCfirstXBinEvtQ=-1.5;
-Double_t kGClastXBinEvtQ=6.5;
+Double_t kGClastXBinEvtQ=7.5;
//R-plots
Int_t kGCnXBinsR = 400;
gammaconversion->SetUseMultiplicity(kGCUseMultiplicity);
gammaconversion->SetUseMultiplicityBin(kGCUseMultiplicityBin);
+ v0Reader->SetIsHeavyIon(kGCIsHeavyIon);
+ gammaconversion->SetUseCentrality(kGCUseCentrality);
+ if(kGCUseCentrality){
+ gammaconversion->SetUseCentralityBin(kGCUseCentralityBin);
+ }
+
+
+
+
// for CF
gammaconversion->SetCFManager(man);
gammaconversion->SetDoCF(kGCrunCF);
if(kGCplotESDTrueDalitzContaminationR == kTRUE){ histograms->AddHistogram("ESD_TrueDalitzContamination_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");}
-
+ if(kGCplotESDTruePi0DalitzContaminationR == kTRUE){ histograms->AddHistogram("ESD_TrueConvDalitzPi0_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");}
+ if(kGCplotESDTrueEtaDalitzContaminationR == kTRUE){ histograms->AddHistogram("ESD_TrueConvDalitzEta_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");}
+ if(kGCplotESDTrueCombinatorialContaminationR == kTRUE){ histograms->AddHistogram("ESD_TrueConvCombinatorial_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");}
+ if(kGCplotESDTrueCombinatorialElecContaminationR == kTRUE){ histograms->AddHistogram("ESD_TrueConvCombinatorialElec_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");}
+
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, "", "");}
Int_t removePileUp=array[20];
Int_t selectV0AND=array[21];
Int_t multiplicityBin=array[22];
+ Int_t isHeavyIon=array[23];
+ Int_t useCentrality=array[24];
+ Int_t centralityBin=array[25];
+ cout<<"CentralityBin::"<< centralityBin <<endl;
+ cout<<"Use Centrality::"<< useCentrality <<endl;
+ cout<<"Heavy Ion::"<< isHeavyIon<<endl;
cout<<"Multiplicity Bin::"<< multiplicityBin<<endl;
cout<<"Select V0AND::"<< selectV0AND<<endl;
cout<<"Remove PileUp::"<< removePileUp<<endl;
case 3:
kGCnumberOfRotationEventsForBG = 20;
break;
+ case 4:
+ kGCnumberOfRotationEventsForBG = 2;
+ break;
default:
return iResult;
default:
return iResult;
}
+
+ switch(isHeavyIon){
+ case 0:
+ kGCIsHeavyIon=0;
+ break;
+ case 1:
+ kGCIsHeavyIon=1;
+ break;
+ default:
+ return iResult;
+ }
+
+ switch(useCentrality){
+ case 0:
+ kGCUseCentrality=0;
+ break;
+ case 1:
+ kGCUseCentrality=1;// GetCentralityClass10("V0M")
+ break;
+ case 2:
+ kGCUseCentrality=2; // GetCentralityClass10("CL1")
+ break;
+ default:
+ return iResult;
+ }
+
+ switch(centralityBin){
+ case 0:
+ kGCUseCentralityBin=0;
+ break;
+ case 1:
+ kGCUseCentralityBin=1;
+ break;
+ case 2:
+ kGCUseCentralityBin=2;
+ break;
+ case 3:
+ kGCUseCentralityBin=3;
+ break;
+ case 4:
+ kGCUseCentralityBin=4;
+ break;
+ case 5:
+ kGCUseCentralityBin=5;
+ break;
+ case 6:
+ kGCUseCentralityBin=6;
+ break;
+ case 7:
+ kGCUseCentralityBin=7;
+ break;
+ case 8:
+ kGCUseCentralityBin=8;
+ break;
+ case 9:
+ kGCUseCentralityBin=9;
+ break;
+ default:
+ return iResult;
+ }
iResult=1;
return iResult;
ASSIGNARRAY(20);
ASSIGNARRAY(21);
ASSIGNARRAY(22);
+ ASSIGNARRAY(23);
+ ASSIGNARRAY(24);
+ ASSIGNARRAY(25);
}
}