fSelectParticles(1),
fSelectParticlesAssoc(1),
fCheckSDD(true),
+ fCorrStrangeness(true),
fSelOption(1),
fESDEvent(0),
fAODEvent(0),
fNMcPrimAccept(0),
fNRecAccept(0),
+ fNRecAcceptStrangeCorr(0),
fNMcPrimAcceptTracklet(0),
fNRecAcceptTracklet(0),
fVzEvent(0),
fNmcNch(0),
fPNmcNch(0),
fNmcNchVtx(0),
+ fNmcNchVtxStrangeCorr(0),
fPNmcNchVtx(0),
fNmcNchTracklet(0),
fPNmcNchTracklet(0),
//Constructor
- for(Int_t i = 0;i< 6;i++){
+ for(Int_t i = 0;i< 8;i++){
fMapSingleTrig[i] = 0;
fMapPair[i] = 0;
fMapEvent[i] = 0;
fNmcNch = new TH2F("fNmcNch", "fNmcNch", 100,-0.5,99.5,100,-0.5,99.5);
fPNmcNch = new TProfile("pNmcNch", "pNmcNch", 100,-0.5,99.5);
fNmcNchVtx = new TH2F("fNmcNchVtx", "fNmcNchVtx", 100,-0.5,99.5,100,-0.5,99.5);
+ fNmcNchVtxStrangeCorr = new TH2F("fNmcNchVtxStrangeCorr", "fNmcNchVtxStrangeCorr", 100,-0.5,99.5,100,-0.5,99.5);
fPNmcNchVtx = new TProfile("pNmcNchVtx", "pNmcNchVtx", 100,-0.5,99.5);
fNmcNchTracklet = new TH2F("fNmcNchTracklet", "fNmcNchTracklet", 100,-0.5,99.5,100,-0.5,99.5);
//--------------------
TString dataType[2] ={"ESD", "AOD"};
- TString labels[6]={Form("%sAllAllMcNmc",dataType[fMode].Data()),
+ TString labels[8]={Form("%sAllAllMcNmc",dataType[fMode].Data()),
Form("%sTrigAllMcNmc",dataType[fMode].Data()),
Form("%sTrigVtxMcNmc",dataType[fMode].Data()),
Form("%sTrigVtxMcNrec",dataType[fMode].Data()),
Form("%sTrigVtxRecMcPropNrec",dataType[fMode].Data()),
- Form("%sTrigVtxRecNrec",dataType[fMode].Data())};
+ Form("%sTrigVtxRecNrec",dataType[fMode].Data()),
+ Form("%sTrigVtxRecMcPropNrecStrangeCorr",dataType[fMode].Data()),
+ Form("%sTrigVtxRecNrecStrangeCorr",dataType[fMode].Data())};
- for(Int_t i=0;i<6;i++){
+ for(Int_t i=0;i<8;i++){
fMapSingleTrig[i] = new THnSparseD(Form("fMapSingleTrig%s", labels[i].Data()),"eta:pt:Nrec",
3,binsEffHisto,minEffHisto,maxEffHisto);
360, 0.,2*TMath::Pi());
fDcaXY[i] = new TH1F(Form("fDcaXY%s",labels[i].Data()),
Form("fDcaXY%s",labels[i].Data()) ,
- 200, -3,3);
+ 200, -0.3,0.3);
fDcaZ[i] = new TH1F(Form("fDcaZ%s",labels[i].Data()),
Form("fDcaZ%s",labels[i].Data()) ,
- 200, -10,10);
+ 200, -2.2,2.2);
fPtSeed[i] = new TH1F(Form("fPSeedt%s",labels[i].Data()),
Form("fPtSeed%s",labels[i].Data()) ,
500, 0., 50);
fHists->Add(fNmcNch);
fHists->Add(fPNmcNch);
fHists->Add(fNmcNchVtx);
+ fHists->Add(fNmcNchVtxStrangeCorr);
fHists->Add(fPNmcNchVtx);
fHists->Add(fNmcNchTracklet);
fHists->Add(fChargedPi0);
fHists->Add(fVertexCheck);
- for(Int_t i=0;i<6;i++){
+ for(Int_t i=0;i<8;i++){
fHists->Add(fMapSingleTrig[i]);
fHists->Add(fMapPair[i]);
fHists->Add(fMapEvent[i]);
// - for Data, only step 5 is performed
// - for kinematics-only, only step 0 is processed
- // - trigger - - vertex - - tracks - - multiplicity -
- // step 5 = Triggered events, reconstructed accepted vertex, reconstructed tracks, reconstructed multiplicity
- // step 4 = Triggered events, reconstructed accepted vertex, reconstructed tracks with MC properties, reconstructed multiplicity
- // step 3 = Triggered events, reconstructed accepted vertex, mc primary particles, reconstructed multiplicity
- // step 2 = Triggered events, reconstructed accepted vertex, mc primary particles, true multiplicity
- // step 1 = Triggered events, all mc primary particles, true multiplicity
- // step 0 = All events, all mc primary particles, true multiplicity
+ // - trigger - - vertex - - tracks - - multiplicity -
+ // step 7 = Triggered events, reconstructed accepted vertex, reconstructed tracks + strangness corr, reconstructed multiplicity+strangeCorr
+ // step 6 = Triggered events, reconstructed accepted vertex, reconstructed tracks with MC prop + stangess corr, reconstructed multiplicity+strangeCorr
+ // step 5 = Triggered events, reconstructed accepted vertex, reconstructed tracks, reconstructed multiplicity
+ // step 4 = Triggered events, reconstructed accepted vertex, reconstructed tracks with MC properties, reconstructed multiplicity
+ // step 3 = Triggered events, reconstructed accepted vertex, mc primary particles, reconstructed multiplicity
+ // step 2 = Triggered events, reconstructed accepted vertex, mc primary particles, true multiplicity
+ // step 1 = Triggered events, all mc primary particles, true multiplicity
+ // step 0 = All events, all mc primary particles, true multiplicity
if(fDebug) Printf("UserExec: Event starts");
vector<Float_t> eta;
vector<Float_t> phi;
vector<Short_t> charge;
+ vector<Float_t> strangenessWeight;
vector<Float_t> px;
vector<Float_t> py;
vector<Float_t> pz;
//reset values
fNMcPrimAccept=0;// number of accepted primaries
fNRecAccept=0; // number of accepted tracks
+ fNRecAcceptStrangeCorr=0; // number of accepted tracks + strangeness correction
fNMcPrimAcceptTracklet=0;// number of accepted primaries (no pt cut)
fNRecAcceptTracklet=0; // number of accepted tracklets
//step 5 = TrigVtxRecNrec
// read tracks
- if(fESDEvent) ntracks = ReadEventESD(pt, eta, phi, charge,nTracksTracklets, 5);
- else if(fAODEvent)ntracks = ReadEventAOD(pt, eta, phi, charge,nTracksTracklets, 5);
+ if(fESDEvent) ntracks = ReadEventESD(pt, eta, phi, charge,strangenessWeight, nTracksTracklets, 5);
+ else if(fAODEvent)ntracks = ReadEventAOD(pt, eta, phi, charge,strangenessWeight, nTracksTracklets, 5);
else Printf("Fatal Error");
// analyse
if(pt.size()){ //(internally ntracks=fNRecAccept)
- Analyse(pt, eta, phi, charge, ntracks, nTracksTracklets[1], nTracksTracklets[2], 5);//step 5 = TrigVtxRecNrec
+ Analyse(pt, eta, phi, charge, strangenessWeight, ntracks, nTracksTracklets[1], nTracksTracklets[2], 5);//step 5 = TrigVtxRecNrec
+ }
+
+ if(fCorrStrangeness){
+ //step 7 = TrigVtxRecNrecStrangeCorr
+
+ // read tracks
+ if(fESDEvent) ntracks = ReadEventESD(pt, eta, phi, charge, strangenessWeight, nTracksTracklets, 7);//stagness version not yet implemented
+ else if(fAODEvent)ntracks = ReadEventAOD(pt, eta, phi, charge, strangenessWeight, nTracksTracklets, 7);
+ else Printf("Fatal Error");
+
+ // analyse
+ if(pt.size()){ //(internally ntracks=fNRecAccept)
+ Analyse(pt, eta, phi, charge, strangenessWeight, fNRecAcceptStrangeCorr, nTracksTracklets[1], nTracksTracklets[2], 7);//step 7 = TrigVtxRecNrecStrangeCorr
+ }
}
if(fUseMC){
// step 4 = TrigVtxRecMcPropNrec
// read tracks
- if(fESDEvent) ntracks = ReadEventESDRecMcProp(pt, eta, phi, charge, nTracksTracklets, 4);
- else if(fAODEvent) ntracks = ReadEventAODRecMcProp(pt, eta, phi, charge, nTracksTracklets, 4);
+ if(fESDEvent) ntracks = ReadEventESDRecMcProp(pt, eta, phi, charge,strangenessWeight, nTracksTracklets, 4);
+ else if(fAODEvent) ntracks = ReadEventAODRecMcProp(pt, eta, phi, charge,strangenessWeight, nTracksTracklets, 4);
else Printf("Fatal Error");
//analyse
if(pt.size()){//(internally ntracks=fNRecAccept)
- Analyse(pt, eta, phi, charge, ntracks, nTracksTracklets[1], nTracksTracklets[2], 4); //step 4 = TrigVtxRecMcPropNrec
+ Analyse(pt, eta, phi, charge,strangenessWeight, ntracks, nTracksTracklets[1], nTracksTracklets[2], 4); //step 4 = TrigVtxRecMcPropNrec
}
+
+ if(fCorrStrangeness){
+ // step 6 = TrigVtxRecMcPropNrecStrangeCorr
+
+ // read tracks
+ if(fESDEvent) ntracks = ReadEventESDRecMcProp(pt, eta, phi, charge, strangenessWeight, nTracksTracklets, 6);//stagness version not yet implemented
+ else if(fAODEvent) ntracks = ReadEventAODRecMcProp(pt, eta, phi, charge, strangenessWeight, nTracksTracklets, 6);
+ else Printf("Fatal Error");
+
+ //analyse
+ if(pt.size()){//(internally ntracks=fNRecAccept)
+ Analyse(pt, eta, phi, charge, strangenessWeight, fNRecAcceptStrangeCorr, nTracksTracklets[1], nTracksTracklets[2], 6); //step 6 = TrigVtxRecMcPropNrecStrangeCorr
+ }
+ }
// step 3 = TrigVtxMcNrec
// read tracks
- if(fESDEvent) ntracks = ReadEventESDMC(pt, eta, phi, charge, nTracksTracklets, 3);
- else if(fAODEvent) ntracks = ReadEventAODMC(pt, eta, phi, charge, nTracksTracklets, 3);
+ if(fESDEvent) ntracks = ReadEventESDMC(pt, eta, phi, charge, strangenessWeight, nTracksTracklets, 3);
+ else if(fAODEvent) ntracks = ReadEventAODMC(pt, eta, phi, charge, strangenessWeight, nTracksTracklets, 3);
else Printf("Fatal Error");
// analyse
if(pt.size()){
- Analyse(pt, eta, phi, charge, fNRecAccept, nTracksTracklets[1],nTracksTracklets[2], 3); //step 3 = TrigVtxMcNrec
- Analyse(pt, eta, phi, charge, fNMcPrimAccept, nTracksTracklets[1],nTracksTracklets[2], 2); //step 2 = TrigVtxMcNmc
+ Analyse(pt, eta, phi, charge, strangenessWeight, fNRecAccept, nTracksTracklets[1],nTracksTracklets[2], 3); //step 3 = TrigVtxMcNrec
+ Analyse(pt, eta, phi, charge, strangenessWeight, fNMcPrimAccept, nTracksTracklets[1],nTracksTracklets[2], 2); //step 2 = TrigVtxMcNmc
}
}
fNRecAcceptTracklet=0; // number of accepted tracklets
if(CheckEvent(false)){// all events, with and without reconstucted vertex
- if(fESDEvent) ntracks = ReadEventESDMC(pt, eta, phi, charge, nTracksTracklets, 1);//read tracks
- else if(fAODEvent) ntracks = ReadEventAODMC(pt, eta, phi, charge, nTracksTracklets, 1);//read tracks
+ if(fESDEvent) ntracks = ReadEventESDMC(pt, eta, phi, charge, strangenessWeight, nTracksTracklets, 1);//read tracks
+ else if(fAODEvent) ntracks = ReadEventAODMC(pt, eta, phi, charge, strangenessWeight, nTracksTracklets, 1);//read tracks
else Printf("Fatal Error");
// analyse
if(pt.size()){
- Analyse(pt, eta, phi, charge, fNMcPrimAccept, nTracksTracklets[1],nTracksTracklets[2], 1); // step 1 = TrigAllMcNmc
+ Analyse(pt, eta, phi, charge, strangenessWeight, fNMcPrimAccept, nTracksTracklets[1],nTracksTracklets[2], 1); // step 1 = TrigAllMcNmc
- Analyse(pt, eta, phi, charge, fNMcPrimAccept, nTracksTracklets[1],nTracksTracklets[2], 0); //first part of step 0 // step 0 = AllAllMcNmc
+ Analyse(pt, eta, phi, charge, strangenessWeight, fNMcPrimAccept, nTracksTracklets[1],nTracksTracklets[2], 0); //first part of step 0 // step 0 = AllAllMcNmc
}
if(CheckEvent(false)){
//read tracks
- if(fESDEvent) ntracks = ReadEventESDMC(pt, eta, phi, charge, nTracksTracklets, 0);
- else if(fAODEvent) ntracks = ReadEventAODMC(pt, eta, phi, charge, nTracksTracklets, 0);
+ if(fESDEvent) ntracks = ReadEventESDMC(pt, eta, phi, charge, strangenessWeight, nTracksTracklets, 0);
+ else if(fAODEvent) ntracks = ReadEventAODMC(pt, eta, phi, charge, strangenessWeight, nTracksTracklets, 0);
else Printf("Fatal Error");
//analyse
if(pt.size()){
- Analyse(pt, eta, phi, charge, fNMcPrimAccept, nTracksTracklets[1],nTracksTracklets[2], 0); //second part of step 0 // step 0 = AllAllMcNmc
+ Analyse(pt, eta, phi, charge, strangenessWeight, fNMcPrimAccept, nTracksTracklets[1],nTracksTracklets[2], 0); //second part of step 0 // step 0 = AllAllMcNmc
}
}
}
if(fMcOnly){
// read event
- if(fMode==0) ntracks = ReadEventESDMC(pt, eta, phi, charge, nTracksTracklets, 0);
- else if (fMode==1) ntracks = ReadEventAODMC(pt, eta, phi, charge, nTracksTracklets, 0);
+ if(fMode==0) ntracks = ReadEventESDMC(pt, eta, phi, charge, strangenessWeight, nTracksTracklets, 0);
+ else if (fMode==1) ntracks = ReadEventAODMC(pt, eta, phi, charge, strangenessWeight, nTracksTracklets, 0);
// analyse
if(pt.size()){
- Analyse(pt, eta, phi, charge, fNMcPrimAccept, nTracksTracklets[1],nTracksTracklets[2], 0);
+ Analyse(pt, eta, phi, charge, strangenessWeight, fNMcPrimAccept, nTracksTracklets[1],nTracksTracklets[2], 0);
}
}
//________________________________________________________________________
-Int_t AliAnalysisTaskMinijet::ReadEventESD( vector<Float_t> &ptArray, vector<Float_t> &etaArray,
+Int_t AliAnalysisTaskMinijet::ReadEventESD( vector<Float_t> &ptArray, vector<Float_t> &etaArray,
vector<Float_t> &phiArray, vector<Short_t> &chargeArray,
- vector<Int_t> &nTracksTracklets, const Int_t step)
+ vector<Float_t> &strangeArray,
+ vector<Int_t> &nTracksTracklets, const Int_t step)
{
// gives back the number of esd tracks and pointer to arrays with track
// properties (pt, eta, phi)
etaArray.clear();
phiArray.clear();
chargeArray.clear();
+ strangeArray.clear();
nTracksTracklets.clear();
const AliESDVertex* vtxSPD = fESDEvent->GetPrimaryVertexSPD(); // uses track or SPD vertexer
//first loop to check how many tracks are accepted
//------------------
Int_t nAcceptedTracks=0;
+ Float_t nAcceptedTracksStrange=0;
for (Int_t iTracks = 0; iTracks < ntracks; iTracks++) {
AliESDtrack *esdTrack = (AliESDtrack *)fESDEvent->GetTrack(iTracks);
etaArray.push_back(track->Eta());
phiArray.push_back(track->Phi());
chargeArray.push_back(track->Charge());
+ strangeArray.push_back(1);
++nAcceptedTracks;
fHistPt->Fill(track->Pt());
}
//________________________________________________________________________
Int_t AliAnalysisTaskMinijet::ReadEventESDRecMcProp( vector<Float_t> &ptArray, vector<Float_t> &etaArray,
- vector<Float_t> &phiArray, vector<Short_t> &chargeArray,
- vector<Int_t> &nTracksTracklets, const Int_t step)
+ vector<Float_t> &phiArray, vector<Short_t> &chargeArray,
+ vector<Float_t> &strangeArray,
+ vector<Int_t> &nTracksTracklets, const Int_t step)
{
// gives back the number of esd tracks and pointer to arrays with track
// properties (pt, eta, phi) of mc particles if available
etaArray.clear();
phiArray.clear();
chargeArray.clear();
+ strangeArray.clear();
nTracksTracklets.clear();
etaArray.push_back(track->Eta());
phiArray.push_back(track->Phi());
chargeArray.push_back(track->Charge());
+ strangeArray.push_back(1);
++nAcceptedTracks;
}
}
etaArray.push_back(partOfTrack->Eta());
phiArray.push_back(partOfTrack->Phi());
chargeArray.push_back(vtrack->Charge());
+ strangeArray.push_back(1);
++nAcceptedTracks;
}
}
//________________________________________________________________________
Int_t AliAnalysisTaskMinijet::ReadEventESDMC(vector<Float_t> &ptArray, vector<Float_t> &etaArray,
- vector<Float_t> &phiArray, vector<Short_t> &chargeArray,
- vector<Int_t> &nTracksTracklets, const Int_t step)
+ vector<Float_t> &phiArray, vector<Short_t> &chargeArray,
+ vector<Float_t> &strangeArray,
+ vector<Int_t> &nTracksTracklets, const Int_t step)
{
// gives back the number of charged prim MC particle and pointer to arrays
// with particle properties (pt, eta, phi)
etaArray.clear();
phiArray.clear();
chargeArray.clear();
+ strangeArray.clear();
nTracksTracklets.clear();
fNMcPrimAccept=0;
etaArray.push_back(track->Eta());
phiArray.push_back(track->Phi());
chargeArray.push_back(track->Charge());
-
+ strangeArray.push_back(1);
} //track loop
//________________________________________________________________________
Int_t AliAnalysisTaskMinijet::ReadEventAOD( vector<Float_t> &ptArray, vector<Float_t> &etaArray,
- vector<Float_t> &phiArray, vector<Short_t> &chargeArray,
- vector<Int_t> &nTracksTracklets, const Int_t step)
+ vector<Float_t> &phiArray, vector<Short_t> &chargeArray,
+ vector<Float_t> &strangeArray,
+ vector<Int_t> &nTracksTracklets, const Int_t step)
{
// gives back the number of AOD tracks and pointer to arrays with track
// properties (pt, eta, phi)
etaArray.clear();
phiArray.clear();
chargeArray.clear();
+ strangeArray.clear();
nTracksTracklets.clear();
TClonesArray *mcArray=0x0;
- if(fAnalysePrimOnly){
+ if(fAnalysePrimOnly || (fCorrStrangeness && fUseMC)){
mcArray = (TClonesArray*)fAODEvent->FindListObject(AliAODMCParticle::StdBranchName());
}
Int_t nAcceptedTracks=0;
+ Float_t nAcceptedTracksStrange=0;
for (Int_t iTracks = 0; iTracks < ntracks; iTracks++) {
AliAODTrack *track = (AliAODTrack *)fAODEvent->GetTrack(iTracks);
if (!track) {
if(!(static_cast<AliAODMCParticle*>(mcArray->At(vtrack->GetLabel()))->IsPhysicalPrimary()))continue;
}
+ Double_t save= track->Pt();
+ Double_t d0rphiz[2],covd0[3];
+ track->PropagateToDCA(fAODEvent->GetPrimaryVertex(),fAODEvent->GetMagneticField(),9999.,d0rphiz,covd0);
+ if(TMath::Abs(save - track->Pt())>1e-6) Printf("Before pt=%f, After pt=%f",save, track->Pt());
+
if(track->TestFilterBit(fFilterBit) && TMath::Abs(track->Eta())<fEtaCut
&& track->Pt()>fPtMin && track->Pt()<fPtMax){
chargeArray.push_back(track->Charge());
fHistPt->Fill(track->Pt());
+
+ //correction for underestimation of strangeness in Monte Carlos -> underestimation of contamination
+ Float_t factor=1.;
+ if(fUseMC && fCorrStrangeness && step==7){
+ if(vtrack->GetLabel()>0){
+ AliAODMCParticle* mcprong =(AliAODMCParticle*)mcArray->At(vtrack->GetLabel());
+ if(mcprong){
+ Int_t labmom = mcprong->GetMother();
+ if(labmom>=0){
+ AliAODMCParticle* mcmother=(AliAODMCParticle*)mcArray->At(labmom);
+ Int_t pdgMother=0;
+ if(mcmother) {
+ pdgMother = mcmother->GetPdgCode();
+ if(TMath::Abs(pdgMother)==310 || TMath::Abs(pdgMother)==130 || TMath::Abs(pdgMother)==321){ //K^0_S, K^0_L, K^+-
+ if(track->Pt()<=1)factor=1./0.7; // values from strangeness publication
+ else factor=1./0.6;// values from strangeness publication
+ }
+ if(TMath::Abs(pdgMother)==3122) { //Lambda
+ factor=1./0.25; // values from strangeness publication
+ }
+ }
+ }
+ }
+ }
+ }
+ nAcceptedTracksStrange+=factor;
+ strangeArray.push_back(factor);
+ fDcaXY[step]->Fill(d0rphiz[0], factor);
+ fDcaZ[step]->Fill(d0rphiz[0], factor);
+
}
}
//need to check this option for MC
fNRecAccept = nAcceptedTracks; // needed for MC case //step5 = TrigVtxRecNrec
fNRecAcceptTracklet = ntrackletsAccept; // needed for MC case //step5 = TrigVtxRecNrec
}
+ if(step==7)fNRecAcceptStrangeCorr = nAcceptedTracksStrange;
+
return fNRecAccept; // at the moment, always return reconstructed multiplicity
}
//________________________________________________________________________
Int_t AliAnalysisTaskMinijet::ReadEventAODRecMcProp( vector<Float_t> &ptArray, vector<Float_t> &etaArray,
- vector<Float_t> &phiArray, vector<Short_t> &chargeArray,
- vector<Int_t> &nTracksTracklets, const Int_t step)
+ vector<Float_t> &phiArray, vector<Short_t> &chargeArray,
+ vector<Float_t> &strangeArray,
+ vector<Int_t> &nTracksTracklets, const Int_t step)
{
// gives back the number of AOD tracks and pointer to arrays with track
// properties (pt, eta, phi)
etaArray.clear();
phiArray.clear();
chargeArray.clear();
+ strangeArray.clear();
nTracksTracklets.clear();
track->Pt()>fPtMin && track->Pt()<fPtMax){
nAcceptedTracks++;
+ Float_t factor=1.;
//save track properties in vector
if(vtrack->GetLabel()<=0){ //fake tracks before "label<0", but crash in AOD079 // what is the meaning of label 0
etaArray.push_back(track->Eta());
phiArray.push_back(track->Phi());
chargeArray.push_back(track->Charge());
+
}
else{//mc properties
AliAODMCParticle *partOfTrack = (AliAODMCParticle*)mcArray->At(vtrack->GetLabel());
etaArray.push_back(partOfTrack->Eta());
phiArray.push_back(partOfTrack->Phi());
chargeArray.push_back(vtrack->Charge());//partOfTrack?
+
+ //correction for underestimation of strangeness in Monte Carlos -> underestimation of contamination
+ if(fUseMC && fCorrStrangeness && step==6){
+ Int_t labmom = partOfTrack->GetMother();
+ if(labmom>=0){
+ AliAODMCParticle* mcmother=(AliAODMCParticle*)mcArray->At(labmom);
+ Int_t pdgMother=0;
+ if(mcmother) {
+ pdgMother = mcmother->GetPdgCode();
+ if(TMath::Abs(pdgMother)==310 || TMath::Abs(pdgMother)==130 || TMath::Abs(pdgMother)==321){ //K^0_S, K^0_L, K^+-
+ if(track->Pt()<=1)factor=1./0.7; // values from strangeness publication
+ else factor=1./0.6;// values from strangeness publication
+ }
+ if(TMath::Abs(pdgMother)==3122) { //Lambda
+ factor=1./0.25; // values from strangeness publication
+ }
+ }
+ }
+ }
}
}
+ strangeArray.push_back(factor);
+
}
}
//need to check this option for MC
//________________________________________________________________________
Int_t AliAnalysisTaskMinijet::ReadEventAODMC( vector<Float_t> &ptArray, vector<Float_t> &etaArray,
- vector<Float_t> &phiArray, vector<Short_t> &chargeArray,
- vector<Int_t> &nTracksTracklets, const Int_t step)
+ vector<Float_t> &phiArray, vector<Short_t> &chargeArray,
+ vector<Float_t> &strangeArray,
+ vector<Int_t> &nTracksTracklets, const Int_t step)
{
// gives back the number of AOD MC particles and pointer to arrays with particle
// properties (pt, eta, phi)
etaArray.clear();
phiArray.clear();
chargeArray.clear();
+ strangeArray.clear();
nTracksTracklets.clear();
//check vertex
etaArray.push_back(track->Eta());
phiArray.push_back(track->Phi());
chargeArray.push_back(track->Charge());
+ strangeArray.push_back(1);
}
nTracksTracklets.push_back(nChargedPrim);
}
if(step==3){ // step 3 = Trig vtx Mc
fNmcNchVtx->Fill( fNMcPrimAccept,fNRecAccept);
+ fNmcNchVtxStrangeCorr->Fill( fNMcPrimAccept,fNRecAcceptStrangeCorr);
fPNmcNchVtx->Fill(fNMcPrimAccept,fNRecAccept);
fNmcNchVtxTracklet->Fill( fNMcPrimAcceptTracklet,fNRecAcceptTracklet);
fPNmcNchVtxTracklet->Fill(fNMcPrimAcceptTracklet,fNRecAcceptTracklet);
const vector<Float_t> &eta,
const vector<Float_t> &phi,
const vector<Short_t> &charge,
+ const vector<Float_t> &strangeWeight,
const Int_t ntracksCharged,
const Int_t ntracklets,
const Int_t nAll,
Float_t etaEventAxis=0; // eta event axis
Float_t phiEventAxis=0; // phi event axis
Short_t chargeEventAxis=0; // charge event axis
+ Float_t strangeWeightEventAxis=0; // strange weight event axis
Float_t ptOthers = 0; // pt others // for all other tracks around event axis -> see loop
Float_t etaOthers = 0; // eta others
Float_t phiOthers = 0; // phi others
Short_t chargeOthers = 0; // charge others
+ Float_t strangeWeightOthers = 0; // strange weight others
Int_t *pindexInnerEta = new Int_t [nAll+1];
Float_t *ptInnerEta = new Float_t[nAll+1];
//fill single particle correction for first step of pair correction
Double_t propAll[3] = {eta[i],pt[i],ntracksCharged };
- fMapAll[step]->Fill(propAll);
+ fMapAll[step]->Fill(propAll, strangeWeight[i]);
//filling of simple check plots
etaEventAxis = eta[pindexInnerEta[axis]];
phiEventAxis = phi[pindexInnerEta[axis]];
chargeEventAxis = charge[pindexInnerEta[axis]];
+ strangeWeightEventAxis = strangeWeight[pindexInnerEta[axis]];
fPtSeed[step] -> Fill( ptEventAxis);
fEtaSeed[step] -> Fill(etaEventAxis);
fPhiSeed[step] -> Fill(phiEventAxis);
Double_t prop[3] = {etaEventAxis,ptEventAxis,ntracksCharged };
- fMapSingleTrig[step]->Fill(prop);
+ fMapSingleTrig[step]->Fill(prop, strangeWeightEventAxis);
//associated tracks
for (Int_t iTrack = axis+1; iTrack < nAll; iTrack++) {
etaOthers = eta[pindexInnerEta[iTrack]];
phiOthers = phi[pindexInnerEta[iTrack]];
chargeOthers = charge[pindexInnerEta[iTrack]];
+ strangeWeightOthers = strangeWeight[pindexInnerEta[iTrack]];
//plot only properties of tracks with pt>ptassoc
Float_t dEta=etaOthers-etaEventAxis;
- fDPhiDEtaEventAxis[step]->Fill(dPhi, dEta);
- fDPhiEventAxis[step]->Fill(dPhi);
+ fDPhiDEtaEventAxis[step]->Fill(dPhi, dEta, strangeWeightEventAxis*strangeWeightOthers);
+ fDPhiEventAxis[step]->Fill(dPhi, strangeWeightEventAxis*strangeWeightOthers);
//check outliers
if(ptEventAxis< 0.4 || ptEventAxis > 100) Printf("particles out of range pt");
Bool_t isLikeSign = CheckLikeSign(chargeEventAxis, chargeOthers);
Double_t prop6[6] = {ptEventAxis,ptOthers,dEta,dPhi,ntracksCharged, isLikeSign };
- fMapPair[step]->Fill(prop6);
+ fMapPair[step]->Fill(prop6, strangeWeightEventAxis*strangeWeightOthers);
}// end of inner track loop
void SetSelectParticles(Int_t selectParticles) {fSelectParticles = selectParticles;}\r
void SetSelectParticlesAssoc(Int_t selectParticlesAssoc) {fSelectParticlesAssoc = selectParticlesAssoc;}\r
void SetCheckSDD (Bool_t checkSDD, Int_t selOption) {fCheckSDD = checkSDD; fSelOption = selOption;}\r
-\r
+ void SetCorrStrangeness (Bool_t corrStrangeness) {fCorrStrangeness = corrStrangeness;}\r
\r
private:\r
\r
Int_t ReadEventESD (std::vector<Float_t> &pt, std::vector<Float_t> &eta,\r
std::vector<Float_t> &phi, std::vector<Short_t> &charge,\r
+ std::vector<Float_t> &strangnessWeight,\r
std::vector<Int_t> &nTracksTracklets, const Int_t step);\r
Int_t ReadEventESDRecMcProp(std::vector<Float_t> &pt, std::vector<Float_t> &eta,\r
std::vector<Float_t> &phi, std::vector<Short_t> &charge,\r
+ std::vector<Float_t> &strangnessWeight,\r
std::vector<Int_t> &nTracksTracklets, const Int_t step);\r
Int_t ReadEventESDMC (std::vector<Float_t> &pt, std::vector<Float_t> &eta,\r
std::vector<Float_t> &phi, std::vector<Short_t> &charge,\r
+ std::vector<Float_t> &strangnessWeight,\r
std::vector<Int_t> &nTracksTracklets, const Int_t step);\r
\r
Int_t ReadEventAOD (std::vector<Float_t> &pt, std::vector<Float_t> &eta, \r
std::vector<Float_t> &phi, std::vector<Short_t> &charge,\r
+ std::vector<Float_t> &strangnessWeight,\r
std::vector<Int_t> &nTracksTracklets, const Int_t step);\r
Int_t ReadEventAODRecMcProp(std::vector<Float_t> &pt, std::vector<Float_t> &eta,\r
std::vector<Float_t> &phi, std::vector<Short_t> &charge,\r
+ std::vector<Float_t> &strangnessWeight,\r
std::vector<Int_t> &nTracksTracklets, const Int_t step);\r
Int_t ReadEventAODMC (std::vector<Float_t> &pt, std::vector<Float_t> &eta, \r
std::vector<Float_t> &phi, std::vector<Short_t> &charge,\r
+ std::vector<Float_t> &strangnessWeight,\r
std::vector<Int_t> &nTracksTracklets, const Int_t step);\r
\r
void Analyse (const std::vector<Float_t> &pt, \r
const std::vector<Float_t> &eta, \r
const std::vector<Float_t> &phi, \r
const std::vector<Short_t> &charge, \r
+ const std::vector<Float_t> &strangnessWeight,\r
const Int_t ntacks, const Int_t ntacklets=0, \r
const Int_t nAll=0, const Int_t step=0);\r
\r
Int_t fSelectParticles; // only in cas of MC: use also neutral particles or not \r
Int_t fSelectParticlesAssoc; // only in cas of MC: use also neutral particles or not \r
Bool_t fCheckSDD; // check if SDD was in read out partition (needed for LHC11a)\r
+ Bool_t fCorrStrangeness; // for data correction -> Pythia simulations underestimate contamination from strangness\r
Int_t fSelOption; // 0 = use hit in SDD for event selection, 1 = use trigger for event selection\r
\r
AliESDEvent *fESDEvent; //! esd event\r
AliAODEvent *fAODEvent; //! aod event\r
Int_t fNMcPrimAccept; // global variable for mc multiplucity\r
Int_t fNRecAccept; // global variable for rec multiplucity\r
+ Float_t fNRecAcceptStrangeCorr; // global variable for rec multiplucity\r
Int_t fNMcPrimAcceptTracklet; // global variable for mc multiplucity\r
Int_t fNRecAcceptTracklet; // global variable for rec multiplucity\r
Float_t fVzEvent; // global variable for rec vertex position\r
TH2F *fNmcNch; // N mc - N ch rec\r
TProfile *fPNmcNch; // N mc - N ch rec\r
TH2F *fNmcNchVtx; // N mc - N ch rec for events with reconstructed vertex\r
+ TH2F *fNmcNchVtxStrangeCorr; // N mc - N ch rec for events with reconstructed vertex + strangeness correction\r
TProfile *fPNmcNchVtx; // N mc - N ch rec for events with reconstructed vertex\r
TH2F *fNmcNchTracklet; // N mc - N ch rec\r
TProfile *fPNmcNchTracklet; // N mc - N ch rec\r
TH2F *fChargedPi0; // charged versus charged+Pi0\r
TH1F *fVertexCheck; // check which fraction of events has vtx_rec but no good vtx_mc\r
\r
- THnSparse *fMapSingleTrig[6]; //! multi-dim histo for trigger track properties\r
- THnSparse *fMapPair[6]; //! multi-dim histo for pair properties\r
- THnSparse *fMapEvent[6]; //! multi-dim histo for event properties\r
- THnSparse *fMapAll[6]; //! multi-dim histo for properties of all analysed tracks\r
+ THnSparse *fMapSingleTrig[8]; //! multi-dim histo for trigger track properties\r
+ THnSparse *fMapPair[8]; //! multi-dim histo for pair properties\r
+ THnSparse *fMapEvent[8]; //! multi-dim histo for event properties\r
+ THnSparse *fMapAll[8]; //! multi-dim histo for properties of all analysed tracks\r
\r
- TH1F * fVertexZ[6]; // z of vertex\r
- TH1F * fNcharge[6]; // pt\r
- TH1F * fPt[6]; // pt\r
- TH1F * fEta[6]; // eta\r
- TH1F * fPhi[6]; // phi\r
- TH1F * fDcaXY[6]; // dca xy direction\r
- TH1F * fDcaZ[6]; // dca z direction\r
-\r
- TH1F * fPtSeed[6]; // pt of seed (event axis)\r
- TH1F * fEtaSeed[6]; // eta of seed \r
- TH1F * fPhiSeed[6]; // phi of seed\r
-\r
- TH1F * fPtOthers[6]; // pt of all other particels used in dEtadPhi\r
- TH1F * fEtaOthers[6]; // eta of all other particels used in dEtadPhi\r
- TH1F * fPhiOthers[6]; // phi of all other particels used in dEtadPhi\r
- TH2F * fPtEtaOthers[6]; // pt-eta of all other particels used in dEtadPhi\r
-\r
-\r
- TH2F * fPhiEta[6]; // eta - phi\r
- TH2F * fDPhiDEtaEventAxis[6]; // correlation dEta-dPhi towards event axis\r
- TH2F * fDPhiDEtaEventAxisSeeds[6]; // correlation dEta-dPhi towards event axis of trigger particles\r
- TH1F * fTriggerNch[6]; // number of triggers with accepted-track number\r
- TH2F * fTriggerNchSeeds[6]; // number of triggers with accepted-track number\r
- TH1F * fTriggerTracklet[6]; // number of triggers with accepted-tracklet number\r
- TH2F * fNch07Nch[6]; // nCharged with pT>fTriggerPtCut vs nCharged\r
- TProfile * fPNch07Nch[6]; // nCharged with pT>fTriggerPtCut vs nCharged\r
+ TH1F * fVertexZ[8]; // z of vertex\r
+ TH1F * fNcharge[8]; // pt\r
+ TH1F * fPt[8]; // pt\r
+ TH1F * fEta[8]; // eta\r
+ TH1F * fPhi[8]; // phi\r
+ TH1F * fDcaXY[8]; // dca xy direction\r
+ TH1F * fDcaZ[8]; // dca z direction\r
+\r
+ TH1F * fPtSeed[8]; // pt of seed (event axis)\r
+ TH1F * fEtaSeed[8]; // eta of seed \r
+ TH1F * fPhiSeed[8]; // phi of seed\r
+\r
+ TH1F * fPtOthers[8]; // pt of all other particels used in dEtadPhi\r
+ TH1F * fEtaOthers[8]; // eta of all other particels used in dEtadPhi\r
+ TH1F * fPhiOthers[8]; // phi of all other particels used in dEtadPhi\r
+ TH2F * fPtEtaOthers[8]; // pt-eta of all other particels used in dEtadPhi\r
+\r
+\r
+ TH2F * fPhiEta[8]; // eta - phi\r
+ TH2F * fDPhiDEtaEventAxis[8]; // correlation dEta-dPhi towards event axis\r
+ TH2F * fDPhiDEtaEventAxisSeeds[8]; // correlation dEta-dPhi towards event axis of trigger particles\r
+ TH1F * fTriggerNch[8]; // number of triggers with accepted-track number\r
+ TH2F * fTriggerNchSeeds[8]; // number of triggers with accepted-track number\r
+ TH1F * fTriggerTracklet[8]; // number of triggers with accepted-tracklet number\r
+ TH2F * fNch07Nch[8]; // nCharged with pT>fTriggerPtCut vs nCharged\r
+ TProfile * fPNch07Nch[8]; // nCharged with pT>fTriggerPtCut vs nCharged\r
\r
- TH2F * fNch07Tracklet[6]; // nCharged with pT>fTriggerPtCut vs nTracklet\r
- TH2F * fNchTracklet[6]; // nCharged vs nTracklet\r
- TProfile * fPNch07Tracklet[6]; // nCharged with pT>fTriggerPtCut vs nTracklet\r
+ TH2F * fNch07Tracklet[8]; // nCharged with pT>fTriggerPtCut vs nTracklet\r
+ TH2F * fNchTracklet[8]; // nCharged vs nTracklet\r
+ TProfile * fPNch07Tracklet[8]; // nCharged with pT>fTriggerPtCut vs nTracklet\r
\r
- TH1F * fDPhiEventAxis[6]; // delta phi of associate tracks to event axis\r
+ TH1F * fDPhiEventAxis[8]; // delta phi of associate tracks to event axis\r
\r
AliAnalysisTaskMinijet(const AliAnalysisTaskMinijet&); // not implemented\r
AliAnalysisTaskMinijet& operator=(const AliAnalysisTaskMinijet&); // not implemented\r
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff