//\r
TH1::AddDirectory(kFALSE);\r
TObjArray *aFolderObj = new TObjArray;\r
+ if(!aFolderObj) return;\r
\r
//\r
// Reconstructed event vertex\r
\r
// export objects to analysis folder\r
fAnalysisFolder = ExportToFolder(aFolderObj);\r
+ if(!fAnalysisFolder) { \r
+ if(aFolderObj) delete aFolderObj;\r
+ return;\r
+ }\r
\r
// delete only TObjArray\r
if(aFolderObj) delete aFolderObj;\r
//_____________________________________________________________________________\r
TFolder* AliPtResolAnalysis::ExportToFolder(TObjArray * const array) \r
{\r
- // recreate folder avery time and export objects to new one\r
+ // recreate folder every time and export objects to new one\r
//\r
+ if(!array) return NULL;\r
+\r
AliPtResolAnalysis * comp=this;\r
TFolder *folder = comp->GetAnalysisFolder();\r
\r
//\r
TH1::AddDirectory(kFALSE);\r
TObjArray *aFolderObj = new TObjArray;\r
+ if(!aFolderObj) return;\r
\r
//\r
// Reconstructed event vertex\r
\r
// export objects to analysis folder\r
fAnalysisFolder = ExportToFolder(aFolderObj);\r
+ if(!fAnalysisFolder) { \r
+ if(aFolderObj) delete aFolderObj;\r
+ return;\r
+ }\r
\r
// delete only TObjArray\r
if(aFolderObj) delete aFolderObj;\r
{\r
// recreate folder avery time and export objects to new one\r
//\r
+ if(!array) return NULL;\r
+\r
AliPtResolAnalysisPbPb * comp=this;\r
TFolder *folder = comp->GetAnalysisFolder();\r
\r
Int_t binsMCTrackHist1[3]= {fPtCorrNbins, fEtaNbins, 90};\r
Double_t minMCTrackHist1[3]={0.,-1.,0.}; \r
Double_t maxMCTrackHist1[3]={10.,1.,2.*TMath::Pi()}; \r
- sprintf(name,"fMCTrackHist1_%d",i);\r
- sprintf(title,"mcPt:mcEta:mcPhi");\r
+ snprintf(name,256,"fMCTrackHist1_%d",i);\r
+ snprintf(title,256,"mcPt:mcEta:mcPhi");\r
\r
fMCTrackHist1[i] = new THnSparseF(name,title,3,binsMCTrackHist1,minMCTrackHist1,maxMCTrackHist1);\r
fMCTrackHist1[i]->SetBinEdges(0,fBinsPtCorr);\r
Int_t binsMCPrimTrackHist1[5]= {fPtCorrNbins,fEtaNbins,6,20,4000};\r
Double_t minMCPrimTrackHist1[5]={0.,-1.,0.,0.,0.}; \r
Double_t maxMCPrimTrackHist1[5]={10.,1.,6.,20.,4000.}; \r
- sprintf(name,"fMCPrimTrackHist1_%d",i);\r
- sprintf(title,"mcPt:mcEta:pid:mech:mother");\r
+ snprintf(name,256,"fMCPrimTrackHist1_%d",i);\r
+ snprintf(title,256,"mcPt:mcEta:pid:mech:mother");\r
\r
fMCPrimTrackHist1[i] = new THnSparseF(name,title,5,binsMCPrimTrackHist1,minMCPrimTrackHist1,maxMCPrimTrackHist1);\r
fMCPrimTrackHist1[i]->SetBinEdges(0,fBinsPtCorr);\r
Int_t binsMCPrimTrackHist2[3]= {4000,20,4000};\r
Double_t minMCPrimTrackHist2[3]={0.,0.,0.}; \r
Double_t maxMCPrimTrackHist2[3]={4000.,20.,4000.}; \r
- sprintf(name,"fMCPrimTrackHist2_%d",i);\r
- sprintf(title,"pdg:mech:mother");\r
+ snprintf(name,256,"fMCPrimTrackHist2_%d",i);\r
+ snprintf(title,256,"pdg:mech:mother");\r
\r
fMCPrimTrackHist2[i] = new THnSparseF(name,title,3,binsMCPrimTrackHist2,minMCPrimTrackHist2,maxMCPrimTrackHist2);\r
fMCPrimTrackHist2[i]->GetAxis(0)->SetTitle("pdg");\r
Int_t binsMCSecTrackHist1[5]= {fPtCorrNbins,fEtaNbins,6,20,4000};\r
Double_t minMCSecTrackHist1[5]={0.,-1.,0.,0.,0.}; \r
Double_t maxMCSecTrackHist1[5]={10.,1.,6.,20.,4000.}; \r
- sprintf(name,"fMCSecTrackHist1_%d",i);\r
- sprintf(title,"mcPt:mcEta:pid:mech:mother");\r
+ snprintf(name,256,"fMCSecTrackHist1_%d",i);\r
+ snprintf(title,256,"mcPt:mcEta:pid:mech:mother");\r
\r
fMCSecTrackHist1[i] = new THnSparseF(name,title,5,binsMCSecTrackHist1,minMCSecTrackHist1,maxMCSecTrackHist1);\r
fMCSecTrackHist1[i]->SetBinEdges(0,fBinsPtCorr);\r
Int_t binsRecTrackHist1[3]={fPtNbins,fEtaNbins,90};\r
Double_t minRecTrackHist1[3]={0.,-1.,0.}; \r
Double_t maxRecTrackHist1[3]={10.,1.,2.*TMath::Pi()};\r
- sprintf(name,"fRecTrackHist1_%d",i);\r
- sprintf(title,"Pt:Eta:Phi");\r
+ snprintf(name,256,"fRecTrackHist1_%d",i);\r
+ snprintf(title,256,"Pt:Eta:Phi");\r
fRecTrackHist1[i] = new THnSparseF(name,title,3,binsRecTrackHist1,minRecTrackHist1,maxRecTrackHist1);\r
fRecTrackHist1[i]->SetBinEdges(0,fBinsPt);\r
fRecTrackHist1[i]->SetBinEdges(1,fBinsEta);\r
\r
// \r
Int_t binsRecTrackMultHist1[2]={fPtNbins,fMultNbins};\r
-// Double_t minRecTrackMultHist1[2]={0.,-0.5}; \r
-// Double_t maxRecTrackMultHist1[2]={10.,149.5};\r
- sprintf(name,"fRecTrackMultHist_%d",i);\r
- sprintf(title,"Pt:Mult");\r
+ snprintf(name,256,"fRecTrackMultHist_%d",i);\r
+ snprintf(title,256,"Pt:Mult");\r
fRecTrackMultHist1[i] = new THnSparseF(name,title,2,binsRecTrackMultHist1); //,minRecTrackMultHist1,maxRecTrackMultHist1);\r
fRecTrackMultHist1[i]->SetBinEdges(0,fBinsPt);\r
fRecTrackMultHist1[i]->SetBinEdges(1,fBinsMult);\r
Int_t binsRecMCTrackHist1[4] = {fPtCorrNbins,fEtaNbins,100,100};\r
Double_t minRecMCTrackHist1[4]={0.,-1.,-0.5,-0.5}; \r
Double_t maxRecMCTrackHist1[4]={20.,1.,0.5,0.5}; \r
- sprintf(name,"fRecMCTrackHist1");\r
- sprintf(title,"mcPt:mcEta:(Pt-mcPt)/mcPt:(Eta-mcEta)");\r
+ snprintf(name,256,"fRecMCTrackHist1");\r
+ snprintf(title,256,"mcPt:mcEta:(Pt-mcPt)/mcPt:(Eta-mcEta)");\r
+\r
fRecMCTrackHist1 = new THnSparseF(name,title,4,binsRecMCTrackHist1,minRecMCTrackHist1,maxRecMCTrackHist1);\r
fRecMCTrackHist1->SetBinEdges(0,fBinsPtCorr);\r
fRecMCTrackHist1->SetBinEdges(1,fBinsEta);\r
Int_t binsMCMultRecTrackHist1[3] = {fPtCorrNbins,fEtaNbins,6};\r
Double_t minMCMultRecTrackHist1[3]={0.,-1.,0.}; \r
Double_t maxMCMultRecTrackHist1[3]={20.,1.,6.}; \r
- sprintf(name,"fMCMultRecTrackHist1");\r
- sprintf(title,"mcPt:mcEta:pid");\r
+ snprintf(name,256,"fMCMultRecTrackHist1");\r
+ snprintf(title,256,"mcPt:mcEta:pid");\r
fMCMultRecTrackHist1 = new THnSparseF(name,title,3,binsMCMultRecTrackHist1,minMCMultRecTrackHist1,maxMCMultRecTrackHist1);\r
fMCMultRecTrackHist1->SetBinEdges(0,fBinsPtCorr);\r
fMCMultRecTrackHist1->SetBinEdges(1,fBinsEta);\r
\r
for(Int_t i = 0; i<6; i++) \r
{ \r
- sprintf(name,"mc_pt_rec_prim_pid_%d",i); \r
+ snprintf(name,256,"mc_pt_rec_prim_pid_%d",i); \r
fMCPrimTrackHist1[2]->GetAxis(2)->SetRange(i+1,i+1);\r
h = fMCPrimTrackHist1[2]->Projection(0);\r
h->SetName(name);\r
aFolderObj->Add(h);\r
\r
- sprintf(name,"mc_pt_rec_sec_pid_%d",i); \r
+ snprintf(name,256,"mc_pt_rec_sec_pid_%d",i); \r
fMCSecTrackHist1[2]->GetAxis(2)->SetRange(i+1,i+1);\r
h = fMCSecTrackHist1[2]->Projection(0);\r
h->SetName(name);\r
if(j == 4) {\r
// decay\r
\r
- sprintf(name,"mc_pt_rec_sec_pid_%d_decay",i); \r
+ snprintf(name,256,"mc_pt_rec_sec_pid_%d_decay",i); \r
fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);\r
h = fMCSecTrackHist1[2]->Projection(0);\r
h->SetName(name);\r
aFolderObj->Add(h);\r
\r
- sprintf(name,"mc_eta_rec_sec_pid_%d_decay",i); \r
+ snprintf(name,256,"mc_eta_rec_sec_pid_%d_decay",i); \r
fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);\r
h = fMCSecTrackHist1[2]->Projection(1);\r
h->SetName(name);\r
aFolderObj->Add(h);\r
\r
- sprintf(name,"mc_mother_rec_sec_pid_%d_decay",i); \r
+ snprintf(name,256,"mc_mother_rec_sec_pid_%d_decay",i); \r
fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);\r
h = fMCSecTrackHist1[2]->Projection(4);\r
h->SetName(name);\r
} else if (j == 5) {\r
// conversion\r
\r
- sprintf(name,"mc_pt_rec_sec_pid_%d_conv",i); \r
+ snprintf(name,256,"mc_pt_rec_sec_pid_%d_conv",i); \r
fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);\r
h = fMCSecTrackHist1[2]->Projection(0);\r
h->SetName(name);\r
aFolderObj->Add(h);\r
\r
- sprintf(name,"mc_eta_rec_sec_pid_%d_conv",i); \r
+ snprintf(name,256,"mc_eta_rec_sec_pid_%d_conv",i); \r
fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);\r
h = fMCSecTrackHist1[2]->Projection(1);\r
h->SetName(name);\r
aFolderObj->Add(h);\r
\r
- sprintf(name,"mc_mother_rec_sec_pid_%d_conv",i); \r
+ snprintf(name,256,"mc_mother_rec_sec_pid_%d_conv",i); \r
fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);\r
h = fMCSecTrackHist1[2]->Projection(4);\r
h->SetName(name);\r
} else if (j == 13) {\r
// mat\r
\r
- sprintf(name,"mc_pt_rec_sec_pid_%d_mat",i); \r
+ snprintf(name,256,"mc_pt_rec_sec_pid_%d_mat",i); \r
fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);\r
h = fMCSecTrackHist1[2]->Projection(0);\r
h->SetName(name);\r
aFolderObj->Add(h);\r
\r
- sprintf(name,"mc_eta_rec_sec_pid_%d_mat",i); \r
+ snprintf(name,256,"mc_eta_rec_sec_pid_%d_mat",i); \r
fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);\r
h = fMCSecTrackHist1[2]->Projection(1);\r
h->SetName(name);\r
aFolderObj->Add(h);\r
\r
- sprintf(name,"mc_eta_mother_rec_sec_pid_%d_mat",i); \r
+ snprintf(name,256,"mc_eta_mother_rec_sec_pid_%d_mat",i); \r
fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);\r
h = fMCSecTrackHist1[2]->Projection(4,1);\r
h->SetName(name);\r
aFolderObj->Add(h);\r
\r
- sprintf(name,"mc_mother_rec_sec_pid_%d_mat",i); \r
+ snprintf(name,256,"mc_mother_rec_sec_pid_%d_mat",i); \r
fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);\r
h = fMCSecTrackHist1[2]->Projection(4);\r
h->SetName(name);\r
aFolderObj->Add(h);\r
\r
- sprintf(name,"mc_pt_mother_rec_sec_pid_%d_mat",i); \r
+ snprintf(name,256,"mc_pt_mother_rec_sec_pid_%d_mat",i); \r
fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);\r
h = fMCSecTrackHist1[2]->Projection(4,0);\r
h->SetName(name);\r
Int_t binsMCTrackHist1[4]= {fPtNbins, fEtaNbins, 90, fCentralityNbins};
Double_t minMCTrackHist1[4]={0.,-1.5,0., 0.};
Double_t maxMCTrackHist1[4]={50,1.5,2.*TMath::Pi(), 100.};
- sprintf(name,"fMCTrackHist1_%d",i);
- sprintf(title,"mcPt:mcEta:mcPhi:Centrality");
+ snprintf(name,256,"fMCTrackHist1_%d",i);
+ snprintf(title,256,"mcPt:mcEta:mcPhi:Centrality");
fMCTrackHist1[i] = new THnSparseF(name,title,4,binsMCTrackHist1,minMCTrackHist1,maxMCTrackHist1);
fMCTrackHist1[i]->SetBinEdges(0,fBinsPt);
Int_t binsMCPrimTrackHist1[6]= {fPtNbins,fEtaNbins,6,20,4000, fCentralityNbins};
Double_t minMCPrimTrackHist1[6]={0.,-1.5,0.,0.,0., 0.};
Double_t maxMCPrimTrackHist1[6]={50.,1.5,6.,20.,4000., 100.};
- sprintf(name,"fMCPrimTrackHist1_%d",i);
- sprintf(title,"mcPt:mcEta:pid:mech:mother:Centrality");
+ snprintf(name,256,"fMCPrimTrackHist1_%d",i);
+ snprintf(title,256,"mcPt:mcEta:pid:mech:mother:Centrality");
fMCPrimTrackHist1[i] = new THnSparseF(name,title,6,binsMCPrimTrackHist1,minMCPrimTrackHist1,maxMCPrimTrackHist1);
fMCPrimTrackHist1[i]->SetBinEdges(0,fBinsPt);
Int_t binsMCPrimTrackHist2[4]= {4000,20,4000,fCentralityNbins};
Double_t minMCPrimTrackHist2[4]={0.,0.,0., 0.};
Double_t maxMCPrimTrackHist2[4]={4000.,20.,4000., 100.};
- sprintf(name,"fMCPrimTrackHist2_%d",i);
- sprintf(title,"pdg:mech:mother:Centrality");
+ snprintf(name,256,"fMCPrimTrackHist2_%d",i);
+ snprintf(title,256,"pdg:mech:mother:Centrality");
fMCPrimTrackHist2[i] = new THnSparseF(name,title,4,binsMCPrimTrackHist2,minMCPrimTrackHist2,maxMCPrimTrackHist2);
fMCPrimTrackHist2[i]->SetBinEdges(3,fBinsCentrality);
Int_t binsMCSecTrackHist1[6]= {fPtNbins,fEtaNbins,6,20,4000, fCentralityNbins};
Double_t minMCSecTrackHist1[6]={0.,-1.5,0.,0.,0., 0.};
Double_t maxMCSecTrackHist1[6]={50.,1.5,6.,20.,4000., 100.};
- sprintf(name,"fMCSecTrackHist1_%d",i);
- sprintf(title,"mcPt:mcEta:pid:mech:mother:Centrality");
+ snprintf(name,256,"fMCSecTrackHist1_%d",i);
+ snprintf(title,256,"mcPt:mcEta:pid:mech:mother:Centrality");
fMCSecTrackHist1[i] = new THnSparseF(name,title,6,binsMCSecTrackHist1,minMCSecTrackHist1,maxMCSecTrackHist1);
fMCSecTrackHist1[i]->SetBinEdges(0,fBinsPt);
Int_t binsRecTrackHist1[4]={fPtNbins,fEtaNbins,90, fCentralityNbins};
Double_t minRecTrackHist1[4]={0.,-1.5,0., 0.};
Double_t maxRecTrackHist1[4]={50.,1.5,2.*TMath::Pi(), 100.};
- sprintf(name,"fRecTrackHist1_%d",i);
- sprintf(title,"Pt:Eta:Phi:Centrality");
+ snprintf(name,256,"fRecTrackHist1_%d",i);
+ snprintf(title,256,"Pt:Eta:Phi:Centrality");
fRecTrackHist1[i] = new THnSparseF(name,title,4,binsRecTrackHist1,minRecTrackHist1,maxRecTrackHist1);
fRecTrackHist1[i]->SetBinEdges(0,fBinsPt);
fRecTrackHist1[i]->SetBinEdges(1,fBinsEta);
fRecTrackHist1[i]->GetAxis(3)->SetTitle("Centrality");
fRecTrackHist1[i]->Sumw2();
- sprintf(name,"fRecTrackHist2_%d",i);
- sprintf(title,"Zv:Pt:Eta:Centrality");
+ snprintf(name,256,"fRecTrackHist2_%d",i);
+ snprintf(title,256,"Zv:Pt:Eta:Centrality");
fRecTrackHist2[i] = new THnSparseF(name,title,4,binsTrackEvent);
fRecTrackHist2[i]->SetBinEdges(0,fBinsZv);
fRecTrackHist2[i]->SetBinEdges(1,fBinsPt);
Int_t binsRecTrackMultHist1[3]={fPtNbins,fMultNbins, fCentralityNbins};
Double_t minRecTrackMultHist1[3]={0.,-0.5, -0.};
Double_t maxRecTrackMultHist1[3]={50.,10000.5, 100.};
- sprintf(name,"fRecTrackMultHist_%d",i);
- sprintf(title,"Pt:Mult:Centrality");
+ snprintf(name,256,"fRecTrackMultHist_%d",i);
+ snprintf(title,256,"Pt:Mult:Centrality");
fRecTrackMultHist1[i] = new THnSparseF(name,title,3,binsRecTrackMultHist1,minRecTrackMultHist1,maxRecTrackMultHist1);
fRecTrackMultHist1[i]->SetBinEdges(0,fBinsPt);
fRecTrackMultHist1[i]->SetBinEdges(1,fBinsMult);
Double_t minRecMCTrackHist1[5]={0.,-1.5,-0.5,-0.5, 0.};
Double_t maxRecMCTrackHist1[5]={50.,1.5,0.5,0.5, 100.};
- sprintf(name,"fRecMCTrackHist1");
- sprintf(title,"mcPt:mcEta:(Pt-mcPt)/mcPt:(Eta-mcEta):Centrality");
+ snprintf(name,256,"fRecMCTrackHist1");
+ snprintf(title,256,"mcPt:mcEta:(Pt-mcPt)/mcPt:(Eta-mcEta):Centrality");
fRecMCTrackHist1 = new THnSparseF(name,title,5,binsRecMCTrackHist1,minRecMCTrackHist1,maxRecMCTrackHist1);
fRecMCTrackHist1->SetBinEdges(0,fBinsPt);
fRecMCTrackHist1->SetBinEdges(1,fBinsEta);
Int_t binsMCMultRecTrackHist1[4] = {fPtNbins,fEtaNbins,6, fCentralityNbins};
Double_t minMCMultRecTrackHist1[4]={0.,-1.5,0., 0.};
Double_t maxMCMultRecTrackHist1[4]={50.,1.5,6., 100.};
- sprintf(name,"fMCMultRecTrackHist1");
- sprintf(title,"mcPt:mcEta:pid:Centrality");
+ snprintf(name,256,"fMCMultRecTrackHist1");
+ snprintf(title,256,"mcPt:mcEta:pid:Centrality");
fMCMultRecTrackHist1 = new THnSparseF(name,title,4,binsMCMultRecTrackHist1,minMCMultRecTrackHist1,maxMCMultRecTrackHist1);
fMCMultRecTrackHist1->SetBinEdges(0,fBinsPt);
fMCMultRecTrackHist1->SetBinEdges(1,fBinsEta);
for(Int_t i = 0; i<6; i++)
{
- sprintf(name,"mc_pt_rec_prim_pid_%d",i);
+ snprintf(name,256,"mc_pt_rec_prim_pid_%d",i);
fMCPrimTrackHist1[2]->GetAxis(2)->SetRange(i+1,i+1);
h = fMCPrimTrackHist1[2]->Projection(0);
h->SetName(name);
aFolderObj->Add(h);
- sprintf(name,"mc_pt_rec_sec_pid_%d",i);
+ snprintf(name,256,"mc_pt_rec_sec_pid_%d",i);
fMCSecTrackHist1[2]->GetAxis(2)->SetRange(i+1,i+1);
h = fMCSecTrackHist1[2]->Projection(0);
h->SetName(name);
if(j == 4) {
// decay
- sprintf(name,"mc_pt_rec_sec_pid_%d_decay",i);
+ snprintf(name,256,"mc_pt_rec_sec_pid_%d_decay",i);
fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);
h = fMCSecTrackHist1[2]->Projection(0);
h->SetName(name);
aFolderObj->Add(h);
- sprintf(name,"mc_eta_rec_sec_pid_%d_decay",i);
+ snprintf(name,256,"mc_eta_rec_sec_pid_%d_decay",i);
fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);
h = fMCSecTrackHist1[2]->Projection(1);
h->SetName(name);
aFolderObj->Add(h);
- sprintf(name,"mc_mother_rec_sec_pid_%d_decay",i);
+ snprintf(name,256,"mc_mother_rec_sec_pid_%d_decay",i);
fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);
h = fMCSecTrackHist1[2]->Projection(4);
h->SetName(name);
} else if (j == 5) {
// conversion
- sprintf(name,"mc_pt_rec_sec_pid_%d_conv",i);
+ snprintf(name,256,"mc_pt_rec_sec_pid_%d_conv",i);
fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);
h = fMCSecTrackHist1[2]->Projection(0);
h->SetName(name);
aFolderObj->Add(h);
- sprintf(name,"mc_eta_rec_sec_pid_%d_conv",i);
+ snprintf(name,256,"mc_eta_rec_sec_pid_%d_conv",i);
fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);
h = fMCSecTrackHist1[2]->Projection(1);
h->SetName(name);
aFolderObj->Add(h);
- sprintf(name,"mc_mother_rec_sec_pid_%d_conv",i);
+ snprintf(name,256,"mc_mother_rec_sec_pid_%d_conv",i);
fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);
h = fMCSecTrackHist1[2]->Projection(4);
h->SetName(name);
} else if (j == 13) {
// mat
- sprintf(name,"mc_pt_rec_sec_pid_%d_mat",i);
+ snprintf(name,256,"mc_pt_rec_sec_pid_%d_mat",i);
fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);
h = fMCSecTrackHist1[2]->Projection(0);
h->SetName(name);
aFolderObj->Add(h);
- sprintf(name,"mc_eta_rec_sec_pid_%d_mat",i);
+ snprintf(name,256,"mc_eta_rec_sec_pid_%d_mat",i);
fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);
h = fMCSecTrackHist1[2]->Projection(1);
h->SetName(name);
aFolderObj->Add(h);
- sprintf(name,"mc_eta_mother_rec_sec_pid_%d_mat",i);
+ snprintf(name,256,"mc_eta_mother_rec_sec_pid_%d_mat",i);
fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);
h = fMCSecTrackHist1[2]->Projection(4,1);
h->SetName(name);
aFolderObj->Add(h);
- sprintf(name,"mc_mother_rec_sec_pid_%d_mat",i);
+ snprintf(name,256,"mc_mother_rec_sec_pid_%d_mat",i);
fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);
h = fMCSecTrackHist1[2]->Projection(4);
h->SetName(name);
aFolderObj->Add(h);
- sprintf(name,"mc_pt_mother_rec_sec_pid_%d_mat",i);
+ snprintf(name,256,"mc_pt_mother_rec_sec_pid_%d_mat",i);
fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);
h = fMCSecTrackHist1[2]->Projection(4,0);
h->SetName(name);
Int_t binsMCAllPrimTrackMultHist1[3]={ptNbins,etaNbins,150};\r
Double_t minMCAllPrimTrackMultHist1[3]={0.,-1.,-0.5}; \r
Double_t maxMCAllPrimTrackMultHist1[3]={20.,1.,149.5}; \r
- sprintf(name,"fMCAllPrimTrackMultHist1");\r
- sprintf(title,"mcPt:mcEta:multiplicity");\r
+ snprintf(name,256,"fMCAllPrimTrackMultHist1");\r
+ snprintf(title,256,"mcPt:mcEta:multiplicity");\r
\r
fMCAllPrimTrackMultHist1 = new THnSparseF(name,title,3,binsMCAllPrimTrackMultHist1,minMCAllPrimTrackMultHist1,maxMCAllPrimTrackMultHist1);\r
fMCAllPrimTrackMultHist1->SetBinEdges(0,binsPt);\r
Int_t binsMCNDEventAllPrimTrackMultHist1[3]={ptNbins,etaNbins,150};\r
Double_t minMCNDEventAllPrimTrackMultHist1[3]={0.,-1.,-0.5}; \r
Double_t maxMCNDEventAllPrimTrackMultHist1[3]={20.,1.,149.5}; \r
- sprintf(name,"fMCNDEventAllPrimTrackMultHist1");\r
- sprintf(title,"mcPt:mcEta:multiplicity");\r
+ snprintf(name,256,"fMCNDEventAllPrimTrackMultHist1");\r
+ snprintf(title,256,"mcPt:mcEta:multiplicity");\r
\r
fMCNDEventAllPrimTrackMultHist1 = new THnSparseF(name,title,3,binsMCNDEventAllPrimTrackMultHist1,minMCNDEventAllPrimTrackMultHist1,maxMCNDEventAllPrimTrackMultHist1);\r
fMCNDEventAllPrimTrackMultHist1->SetBinEdges(0,binsPt);\r
Int_t binsMCNSDEventAllPrimTrackMultHist1[3]={ptNbins,etaNbins,150};\r
Double_t minMCNSDEventAllPrimTrackMultHist1[3]={0.,-1.,-0.5}; \r
Double_t maxMCNSDEventAllPrimTrackMultHist1[3]={20.,1.,149.5}; \r
- sprintf(name,"fMCNSDEventAllPrimTrackMultHist1");\r
- sprintf(title,"mcPt:mcEta:multiplicity");\r
+ snprintf(name,256,"fMCNSDEventAllPrimTrackMultHist1");\r
+ snprintf(title,256,"mcPt:mcEta:multiplicity");\r
\r
fMCNSDEventAllPrimTrackMultHist1 = new THnSparseF(name,title,3,binsMCNSDEventAllPrimTrackMultHist1,minMCNSDEventAllPrimTrackMultHist1,maxMCNSDEventAllPrimTrackMultHist1);\r
fMCNSDEventAllPrimTrackMultHist1->SetBinEdges(0,binsPt);\r
Int_t binsMCEventTriggerPrimTrackMultHist1[3]={ptNbins,etaNbins,150};\r
Double_t minMCEventTriggerPrimTrackMultHist1[3]={0.,-1.,-0.5}; \r
Double_t maxMCEventTriggerPrimTrackMultHist1[3]={20.,1.,149.5}; \r
- sprintf(name,"fMCTriggerPrimTrackMultHist1");\r
- sprintf(title,"mcPt:mcEta:multiplicity");\r
+ snprintf(name,256,"fMCTriggerPrimTrackMultHist1");\r
+ snprintf(title,256,"mcPt:mcEta:multiplicity");\r
\r
fMCTriggerPrimTrackMultHist1 = new THnSparseF(name,title,3,binsMCEventTriggerPrimTrackMultHist1,minMCEventTriggerPrimTrackMultHist1,maxMCEventTriggerPrimTrackMultHist1);\r
fMCTriggerPrimTrackMultHist1->SetBinEdges(0,binsPt);\r
Int_t binsMCEventPrimTrackMultHist1[3]={ptNbins,etaNbins,150};\r
Double_t minMCEventPrimTrackMultHist1[3]={0.,-1.,-0.5}; \r
Double_t maxMCEventPrimTrackMultHist1[3]={20.,1.,149.5}; \r
- sprintf(name,"fMCEventPrimTrackMultHist1");\r
- sprintf(title,"mcPt:mcEta:multiplicity");\r
+ snprintf(name,256,"fMCEventPrimTrackMultHist1");\r
+ snprintf(title,256,"mcPt:mcEta:multiplicity");\r
\r
fMCEventPrimTrackMultHist1 = new THnSparseF(name,title,3,binsMCEventPrimTrackMultHist1,minMCEventPrimTrackMultHist1,maxMCEventPrimTrackMultHist1);\r
fMCEventPrimTrackMultHist1->SetBinEdges(0,binsPt);\r
Int_t binsMCAllPrimTrackTrueMultHist1[3]={ptNbins,etaNbins,150};\r
Double_t minMCAllPrimTrackTrueMultHist1[3]={0.,-1.,-0.5}; \r
Double_t maxMCAllPrimTrackTrueMultHist1[3]={20.,1.,149.5}; \r
- sprintf(name,"fMCAllPrimTrackTrueMultHist1");\r
- sprintf(title,"mcPt:mcEta:true_mult");\r
+ snprintf(name,256,"fMCAllPrimTrackTrueMultHist1");\r
+ snprintf(title,256,"mcPt:mcEta:true_mult");\r
\r
fMCAllPrimTrackTrueMultHist1 = new THnSparseF(name,title,3,binsMCAllPrimTrackTrueMultHist1,minMCAllPrimTrackTrueMultHist1,maxMCAllPrimTrackTrueMultHist1);\r
fMCAllPrimTrackTrueMultHist1->SetBinEdges(0,binsPt);\r
Int_t binsMCNDEventAllPrimTrackTrueMultHist1[3]={ptNbins,etaNbins,150};\r
Double_t minMCNDEventAllPrimTrackTrueMultHist1[3]={0.,-1.,-0.5}; \r
Double_t maxMCNDEventAllPrimTrackTrueMultHist1[3]={20.,1.,149.5}; \r
- sprintf(name,"fMCNDEventAllPrimTrackTrueMultHist1");\r
- sprintf(title,"mcPt:mcEta:true_mult");\r
+ snprintf(name,256,"fMCNDEventAllPrimTrackTrueMultHist1");\r
+ snprintf(title,256,"mcPt:mcEta:true_mult");\r
\r
fMCNDEventAllPrimTrackTrueMultHist1 = new THnSparseF(name,title,3,binsMCNDEventAllPrimTrackTrueMultHist1,minMCNDEventAllPrimTrackTrueMultHist1,maxMCNDEventAllPrimTrackTrueMultHist1);\r
fMCNDEventAllPrimTrackTrueMultHist1->SetBinEdges(0,binsPt);\r
Int_t binsMCNSDEventAllPrimTrackTrueMultHist1[3]={ptNbins,etaNbins,150};\r
Double_t minMCNSDEventAllPrimTrackTrueMultHist1[3]={0.,-1.,-0.5}; \r
Double_t maxMCNSDEventAllPrimTrackTrueMultHist1[3]={20.,1.,149.5}; \r
- sprintf(name,"fMCNSDEventAllPrimTrackTrueMultHist1");\r
- sprintf(title,"mcPt:mcEta:true_mult");\r
+ snprintf(name,256,"fMCNSDEventAllPrimTrackTrueMultHist1");\r
+ snprintf(title,256,"mcPt:mcEta:true_mult");\r
\r
fMCNSDEventAllPrimTrackTrueMultHist1 = new THnSparseF(name,title,3,binsMCNSDEventAllPrimTrackTrueMultHist1,minMCNSDEventAllPrimTrackTrueMultHist1,maxMCNSDEventAllPrimTrackTrueMultHist1);\r
fMCNSDEventAllPrimTrackTrueMultHist1->SetBinEdges(0,binsPt);\r
Int_t binsMCEventTriggerPrimTrackTrueMultHist1[3]={ptNbins,etaNbins,150};\r
Double_t minMCEventTriggerPrimTrackTrueMultHist1[3]={0.,-1.,-0.5}; \r
Double_t maxMCEventTriggerPrimTrackTrueMultHist1[3]={20.,1.,149.5}; \r
- sprintf(name,"fMCTriggerPrimTrackTrueMultHist1");\r
- sprintf(title,"mcPt:mcEta:true_mult");\r
+ snprintf(name,256,"fMCTriggerPrimTrackTrueMultHist1");\r
+ snprintf(title,256,"mcPt:mcEta:true_mult");\r
\r
fMCTriggerPrimTrackTrueMultHist1 = new THnSparseF(name,title,3,binsMCEventTriggerPrimTrackTrueMultHist1,minMCEventTriggerPrimTrackTrueMultHist1,maxMCEventTriggerPrimTrackTrueMultHist1);\r
fMCTriggerPrimTrackTrueMultHist1->SetBinEdges(0,binsPt);\r
Int_t binsMCEventPrimTrackTrueMultHist1[3]={ptNbins,etaNbins,150};\r
Double_t minMCEventPrimTrackTrueMultHist1[3]={0.,-1.,-0.5}; \r
Double_t maxMCEventPrimTrackTrueMultHist1[3]={20.,1.,149.5}; \r
- sprintf(name,"fMCEventPrimTrackTrueMultHist1");\r
- sprintf(title,"mcPt:mcEta:true_mult");\r
+ snprintf(name,256,"fMCEventPrimTrackTrueMultHist1");\r
+ snprintf(title,256,"mcPt:mcEta:true_mult");\r
\r
fMCEventPrimTrackTrueMultHist1 = new THnSparseF(name,title,3,binsMCEventPrimTrackTrueMultHist1,minMCEventPrimTrackTrueMultHist1,maxMCEventPrimTrackTrueMultHist1);\r
fMCEventPrimTrackTrueMultHist1->SetBinEdges(0,binsPt);\r
Int_t binsMCAllPrimTrackTrueMultHist2[3]={ptNbins,150,150};\r
Double_t minMCAllPrimTrackTrueMultHist2[3]={0.,-0.5,-0.5}; \r
Double_t maxMCAllPrimTrackTrueMultHist2[3]={20.,149.5,149.5}; \r
- sprintf(name,"fMCAllPrimTrackTrueMultHist2");\r
- sprintf(title,"mcPt:mult:true_mult");\r
+ snprintf(name,256,"fMCAllPrimTrackTrueMultHist2");\r
+ snprintf(title,256,"mcPt:mult:true_mult");\r
\r
fMCAllPrimTrackTrueMultHist2 = new THnSparseF(name,title,3,binsMCAllPrimTrackTrueMultHist2,minMCAllPrimTrackTrueMultHist2,maxMCAllPrimTrackTrueMultHist2);\r
fMCAllPrimTrackTrueMultHist2->SetBinEdges(0,binsPt);\r
Int_t binsMCNDEventAllPrimTrackTrueMultHist2[3]={ptNbins,150,150};\r
Double_t minMCNDEventAllPrimTrackTrueMultHist2[3]={0.,-0.5,-0.5}; \r
Double_t maxMCNDEventAllPrimTrackTrueMultHist2[3]={20.,149.5,149.5}; \r
- sprintf(name,"fMCNDEventAllPrimTrackTrueMultHist2");\r
- sprintf(title,"mcPt:mult:true_mult");\r
+ snprintf(name,256,"fMCNDEventAllPrimTrackTrueMultHist2");\r
+ snprintf(title,256,"mcPt:mult:true_mult");\r
\r
fMCNDEventAllPrimTrackTrueMultHist2 = new THnSparseF(name,title,3,binsMCNDEventAllPrimTrackTrueMultHist2,minMCNDEventAllPrimTrackTrueMultHist2,maxMCNDEventAllPrimTrackTrueMultHist2);\r
fMCNDEventAllPrimTrackTrueMultHist2->SetBinEdges(0,binsPt);\r
Int_t binsMCNSDEventAllPrimTrackTrueMultHist2[3]={ptNbins,150,150};\r
Double_t minMCNSDEventAllPrimTrackTrueMultHist2[3]={0.,-0.5,-0.5}; \r
Double_t maxMCNSDEventAllPrimTrackTrueMultHist2[3]={20.,149.5,149.5}; \r
- sprintf(name,"fMCNSDEventAllPrimTrackTrueMultHist2");\r
- sprintf(title,"mcPt:mult:true_mult");\r
+ snprintf(name,256,"fMCNSDEventAllPrimTrackTrueMultHist2");\r
+ snprintf(title,256,"mcPt:mult:true_mult");\r
\r
fMCNSDEventAllPrimTrackTrueMultHist2 = new THnSparseF(name,title,3,binsMCNSDEventAllPrimTrackTrueMultHist2,minMCNSDEventAllPrimTrackTrueMultHist2,maxMCNSDEventAllPrimTrackTrueMultHist2);\r
fMCNSDEventAllPrimTrackTrueMultHist2->SetBinEdges(0,binsPt);\r
Int_t binsMCEventTriggerPrimTrackTrueMultHist2[3]={ptNbins,150,150};\r
Double_t minMCEventTriggerPrimTrackTrueMultHist2[3]={0.,-0.5,-0.5}; \r
Double_t maxMCEventTriggerPrimTrackTrueMultHist2[3]={20.,149.5,149.5}; \r
- sprintf(name,"fMCTriggerPrimTrackTrueMultHist2");\r
- sprintf(title,"mcPt:mult:true_mult");\r
+ snprintf(name,256,"fMCTriggerPrimTrackTrueMultHist2");\r
+ snprintf(title,256,"mcPt:mult:true_mult");\r
\r
fMCTriggerPrimTrackTrueMultHist2 = new THnSparseF(name,title,3,binsMCEventTriggerPrimTrackTrueMultHist2,minMCEventTriggerPrimTrackTrueMultHist2,maxMCEventTriggerPrimTrackTrueMultHist2);\r
fMCTriggerPrimTrackTrueMultHist2->SetBinEdges(0,binsPt);\r
Int_t binsMCEventPrimTrackTrueMultHist2[3]={ptNbins,150,150};\r
Double_t minMCEventPrimTrackTrueMultHist2[3]={0.,-0.5,-0.5}; \r
Double_t maxMCEventPrimTrackTrueMultHist2[3]={20.,149.5,149.5}; \r
- sprintf(name,"fMCEventPrimTrackTrueMultHist2");\r
- sprintf(title,"mcPt:mult:true_mult");\r
+ snprintf(name,256,"fMCEventPrimTrackTrueMultHist2");\r
+ snprintf(title,256,"mcPt:mult:true_mult");\r
\r
fMCEventPrimTrackTrueMultHist2 = new THnSparseF(name,title,3,binsMCEventPrimTrackTrueMultHist2,minMCEventPrimTrackTrueMultHist2,maxMCEventPrimTrackTrueMultHist2);\r
fMCEventPrimTrackTrueMultHist2->SetBinEdges(0,binsPt);\r
Int_t binsMCAllPrimTrackMeanPtTrueMult1[2]={100,150};\r
Double_t minMCAllPrimTrackMeanPtTrueMult1[2]={0.,-0.5}; \r
Double_t maxMCAllPrimTrackMeanPtTrueMult1[2]={10.,149.5}; \r
- sprintf(name,"fMCAllPrimTrackMeanPtTrueMult1");\r
- sprintf(title,"event <mcPt>:true_mult");\r
+ snprintf(name,256,"fMCAllPrimTrackMeanPtTrueMult1");\r
+ snprintf(title,256,"event <mcPt>:true_mult");\r
\r
fMCAllPrimTrackMeanPtTrueMult1 = new THnSparseF(name,title,2,binsMCAllPrimTrackMeanPtTrueMult1,minMCAllPrimTrackMeanPtTrueMult1,maxMCAllPrimTrackMeanPtTrueMult1);\r
fMCAllPrimTrackMeanPtTrueMult1->GetAxis(0)->SetTitle("<mcPt> (GeV/c)");\r
Int_t binsMCAllPrimTrackMeanPtMult1[2]={100,150};\r
Double_t minMCAllPrimTrackMeanPtMult1[2]={0.,-0.5}; \r
Double_t maxMCAllPrimTrackMeanPtMult1[2]={10.,149.5}; \r
- sprintf(name,"fMCAllPrimTrackMeanPtMult1");\r
- sprintf(title,"event <mcPt>:mult");\r
+ snprintf(name,256,"fMCAllPrimTrackMeanPtMult1");\r
+ snprintf(title,256,"event <mcPt>:mult");\r
\r
fMCAllPrimTrackMeanPtMult1 = new THnSparseF(name,title,2,binsMCAllPrimTrackMeanPtMult1,minMCAllPrimTrackMeanPtMult1,maxMCAllPrimTrackMeanPtMult1);\r
fMCAllPrimTrackMeanPtMult1->GetAxis(0)->SetTitle("<mcPt> (GeV/c)");\r
Int_t binsMCNDEventAllPrimTrackMeanPtTrueMult1[2]={100,150};\r
Double_t minMCNDEventAllPrimTrackMeanPtTrueMult1[2]={0.,-0.5}; \r
Double_t maxMCNDEventAllPrimTrackMeanPtTrueMult1[2]={10.,149.5}; \r
- sprintf(name,"fMCNDEventAllPrimTrackMeanPtTrueMult1");\r
- sprintf(title,"event <mcPt>:true_mult");\r
+ snprintf(name,256,"fMCNDEventAllPrimTrackMeanPtTrueMult1");\r
+ snprintf(title,256,"event <mcPt>:true_mult");\r
\r
fMCNDEventAllPrimTrackMeanPtTrueMult1 = new THnSparseF(name,title,2,binsMCNDEventAllPrimTrackMeanPtTrueMult1,minMCNDEventAllPrimTrackMeanPtTrueMult1,maxMCNDEventAllPrimTrackMeanPtTrueMult1);\r
fMCNDEventAllPrimTrackMeanPtTrueMult1->GetAxis(0)->SetTitle("<mcPt> (GeV/c)");\r
Int_t binsMCNDEventAllPrimTrackMeanPtMult1[2]={100,150};\r
Double_t minMCNDEventAllPrimTrackMeanPtMult1[2]={0.,-0.5}; \r
Double_t maxMCNDEventAllPrimTrackMeanPtMult1[2]={10.,149.5}; \r
- sprintf(name,"fMCNDEventAllPrimTrackMeanPtMult1");\r
- sprintf(title,"event <mcPt>:mult");\r
+ snprintf(name,256,"fMCNDEventAllPrimTrackMeanPtMult1");\r
+ snprintf(title,256,"event <mcPt>:mult");\r
\r
fMCNDEventAllPrimTrackMeanPtMult1 = new THnSparseF(name,title,2,binsMCNDEventAllPrimTrackMeanPtMult1,minMCNDEventAllPrimTrackMeanPtMult1,maxMCNDEventAllPrimTrackMeanPtMult1);\r
fMCNDEventAllPrimTrackMeanPtMult1->GetAxis(0)->SetTitle("<mcPt> (GeV/c)");\r
Int_t binsMCNSDEventAllPrimTrackMeanPtTrueMult1[2]={100,150};\r
Double_t minMCNSDEventAllPrimTrackMeanPtTrueMult1[2]={0.,-0.5}; \r
Double_t maxMCNSDEventAllPrimTrackMeanPtTrueMult1[2]={10.,149.5}; \r
- sprintf(name,"fMCNSDEventAllPrimTrackMeanPtTrueMult1");\r
- sprintf(title,"event <mcPt>:true_mult");\r
+ snprintf(name,256,"fMCNSDEventAllPrimTrackMeanPtTrueMult1");\r
+ snprintf(title,256,"event <mcPt>:true_mult");\r
\r
fMCNSDEventAllPrimTrackMeanPtTrueMult1 = new THnSparseF(name,title,2,binsMCNSDEventAllPrimTrackMeanPtTrueMult1,minMCNSDEventAllPrimTrackMeanPtTrueMult1,maxMCNSDEventAllPrimTrackMeanPtTrueMult1);\r
fMCNSDEventAllPrimTrackMeanPtTrueMult1->GetAxis(0)->SetTitle("<mcPt> (GeV/c)");\r
Int_t binsMCNSDEventAllPrimTrackMeanPtMult1[2]={100,150};\r
Double_t minMCNSDEventAllPrimTrackMeanPtMult1[2]={0.,-0.5}; \r
Double_t maxMCNSDEventAllPrimTrackMeanPtMult1[2]={10.,149.5}; \r
- sprintf(name,"fMCNSDEventAllPrimTrackMeanPtMult1");\r
- sprintf(title,"event <mcPt>:mult");\r
+ snprintf(name,256,"fMCNSDEventAllPrimTrackMeanPtMult1");\r
+ snprintf(title,256,"event <mcPt>:mult");\r
\r
fMCNSDEventAllPrimTrackMeanPtMult1 = new THnSparseF(name,title,2,binsMCNSDEventAllPrimTrackMeanPtMult1,minMCNSDEventAllPrimTrackMeanPtMult1,maxMCNSDEventAllPrimTrackMeanPtMult1);\r
fMCNSDEventAllPrimTrackMeanPtMult1->GetAxis(0)->SetTitle("<mcPt> (GeV/c)");\r
Int_t binsMCTriggerPrimTrackMeanPtTrueMult1[2]={100,150};\r
Double_t minMCTriggerPrimTrackMeanPtTrueMult1[2]={0.,-0.5}; \r
Double_t maxMCTriggerPrimTrackMeanPtTrueMult1[2]={10.,149.5}; \r
- sprintf(name,"fMCTriggerPrimTrackMeanPtTrueMult1");\r
- sprintf(title,"event <mcPt>:true_mult");\r
+ snprintf(name,256,"fMCTriggerPrimTrackMeanPtTrueMult1");\r
+ snprintf(title,256,"event <mcPt>:true_mult");\r
\r
fMCTriggerPrimTrackMeanPtTrueMult1 = new THnSparseF(name,title,2,binsMCTriggerPrimTrackMeanPtTrueMult1,minMCTriggerPrimTrackMeanPtTrueMult1,maxMCTriggerPrimTrackMeanPtTrueMult1);\r
fMCTriggerPrimTrackMeanPtTrueMult1->GetAxis(0)->SetTitle("<mcPt> (GeV/c)");\r
Int_t binsMCTriggerPrimTrackMeanPtMult1[2]={100,150};\r
Double_t minMCTriggerPrimTrackMeanPtMult1[2]={0.,-0.5}; \r
Double_t maxMCTriggerPrimTrackMeanPtMult1[2]={10.,149.5}; \r
- sprintf(name,"fMCTriggerPrimTrackMeanPtMult1");\r
- sprintf(title,"event <mcPt>:mult");\r
+ snprintf(name,256,"fMCTriggerPrimTrackMeanPtMult1");\r
+ snprintf(title,256,"event <mcPt>:mult");\r
\r
fMCTriggerPrimTrackMeanPtMult1 = new THnSparseF(name,title,2,binsMCTriggerPrimTrackMeanPtMult1,minMCTriggerPrimTrackMeanPtMult1,maxMCTriggerPrimTrackMeanPtMult1);\r
fMCTriggerPrimTrackMeanPtMult1->GetAxis(0)->SetTitle("<mcPt> (GeV/c)");\r
Int_t binsMCEventPrimTrackMeanPtTrueMult1[2]={100,150};\r
Double_t minMCEventPrimTrackMeanPtTrueMult1[2]={0.,-0.5}; \r
Double_t maxMCEventPrimTrackMeanPtTrueMult1[2]={10.,149.5}; \r
- sprintf(name,"fMCEventPrimTrackMeanPtTrueMult1");\r
- sprintf(title,"event <mcPt>:true_mult");\r
+ snprintf(name,256,"fMCEventPrimTrackMeanPtTrueMult1");\r
+ snprintf(title,256,"event <mcPt>:true_mult");\r
\r
fMCEventPrimTrackMeanPtTrueMult1 = new THnSparseF(name,title,2,binsMCEventPrimTrackMeanPtTrueMult1,minMCEventPrimTrackMeanPtTrueMult1,maxMCEventPrimTrackMeanPtTrueMult1);\r
fMCEventPrimTrackMeanPtTrueMult1->GetAxis(0)->SetTitle("<mcPt> (GeV/c)");\r
Int_t binsMCEventPrimTrackMeanPtMult1[2]={100,150};\r
Double_t minMCEventPrimTrackMeanPtMult1[2]={0.,-0.5}; \r
Double_t maxMCEventPrimTrackMeanPtMult1[2]={10.,149.5}; \r
- sprintf(name,"fMCEventPrimTrackMeanPtMult1");\r
- sprintf(title,"event <mcPt>:mult");\r
+ snprintf(name,256,"fMCEventPrimTrackMeanPtMult1");\r
+ snprintf(title,256,"event <mcPt>:mult");\r
\r
fMCEventPrimTrackMeanPtMult1 = new THnSparseF(name,title,2,binsMCEventPrimTrackMeanPtMult1,minMCEventPrimTrackMeanPtMult1,maxMCEventPrimTrackMeanPtMult1);\r
fMCEventPrimTrackMeanPtMult1->GetAxis(0)->SetTitle("<mcPt> (GeV/c)");\r
Int_t binsRecTrackHist1[3]={ptNbins,etaNbins,90};\r
Double_t minRecTrackHist1[3]={0.,-1.,0.}; \r
Double_t maxRecTrackHist1[3]={10.,1.,2.*TMath::Pi()};\r
- sprintf(name,"fRecTrackHist1_%d",i);\r
- sprintf(title,"Pt:Eta:Phi");\r
+ snprintf(name,256,"fRecTrackHist1_%d",i);\r
+ snprintf(title,256,"Pt:Eta:Phi");\r
\r
fRecTrackHist1[i] = new THnSparseF(name,title,3,binsRecTrackHist1,minRecTrackHist1,maxRecTrackHist1);\r
fRecTrackHist1[i]->SetBinEdges(0,binsPt);\r
for(Int_t i=0; i<8; i++) \r
{\r
// THnSparse track histograms\r
- sprintf(name,"fCorrRecTrackMultHist1_%d",i);\r
- sprintf(title,"Pt:Eta:mult");\r
+ snprintf(name,256,"fCorrRecTrackMultHist1_%d",i);\r
+ snprintf(title,256,"Pt:Eta:mult");\r
fCorrRecTrackMultHist1[i] = new THnSparseF(name,title,3,binsCorrRecTrackMultHist1,minCorrRecTrackMultHist1,maxCorrRecTrackMultHist1);\r
fCorrRecTrackMultHist1[i]->SetBinEdges(0,binsPt);\r
fCorrRecTrackMultHist1[i]->SetBinEdges(1,binsEta);\r
fCorrRecTrackMultHist1[i]->Sumw2();\r
\r
// THnSparse track histograms\r
- sprintf(name,"fCorrRecTrackTrueMultHist1_%d",i);\r
- sprintf(title,"Pt:Eta:true_mult");\r
+ snprintf(name,256,"fCorrRecTrackTrueMultHist1_%d",i);\r
+ snprintf(title,256,"Pt:Eta:true_mult");\r
fCorrRecTrackTrueMultHist1[i] = new THnSparseF(name,title,3,binsCorrRecTrackTrueMultHist1,minCorrRecTrackTrueMultHist1,maxCorrRecTrackTrueMultHist1);\r
fCorrRecTrackTrueMultHist1[i]->SetBinEdges(0,binsPt);\r
fCorrRecTrackTrueMultHist1[i]->SetBinEdges(1,binsEta);\r
fCorrRecTrackTrueMultHist1[i]->Sumw2();\r
\r
//\r
- sprintf(name,"fCorrRecTrackTrueMultHist2_%d",i);\r
- sprintf(title,"Pt:mult:true_mult");\r
+ snprintf(name,256,"fCorrRecTrackTrueMultHist2_%d",i);\r
+ snprintf(title,256,"Pt:mult:true_mult");\r
fCorrRecTrackTrueMultHist2[i] = new THnSparseF(name,title,3,binsCorrRecTrackTrueMultHist2,minCorrRecTrackTrueMultHist2,maxCorrRecTrackTrueMultHist2);\r
fCorrRecTrackTrueMultHist2[i]->SetBinEdges(0,binsPt);\r
fCorrRecTrackTrueMultHist2[i]->GetAxis(0)->SetTitle("Pt (GeV/c)");\r
fCorrRecTrackTrueMultHist2[i]->Sumw2();\r
\r
// THnSparse track histograms\r
- sprintf(name,"fCorrRecTrackMeanPtMultHist1_%d",i);\r
- s
printf(title,"<Pt>:mult");
\r+ snprintf(name,256,"fCorrRecTrackMeanPtMultHist1_%d",i);\r
+ s
nprintf(title,256,"<Pt>:mult");
\r fCorrRecTrackMeanPtMultHist1[i] = new THnSparseF(name,title,2,binsCorrRecTrackMeanPtMultHist1,minCorrRecTrackMeanPtMultHist1,maxCorrRecTrackMeanPtMultHist1);\r
fCorrRecTrackMeanPtMultHist1[i]->GetAxis(0)->SetTitle("<Pt> (GeV/c)");\r
fCorrRecTrackMeanPtMultHist1[i]->GetAxis(1)->SetTitle("multiplicity");\r
fCorrRecTrackMeanPtMultHist1[i]->Sumw2();\r
\r
// THnSparse track histograms\r
- sprintf(name,"fCorrRecTrackMeanPtTrueMultHist1_%d",i);\r
- s
printf(title,"<Pt>:true_mult");
\r+ snprintf(name,256,"fCorrRecTrackMeanPtTrueMultHist1_%d",i);\r
+ s
nprintf(title,256,"<Pt>:true_mult");
\r fCorrRecTrackMeanPtTrueMultHist1[i] = new THnSparseF(name,title,2,binsCorrRecTrackMeanPtTrueMultHist1,minCorrRecTrackMeanPtTrueMultHist1,maxCorrRecTrackMeanPtTrueMultHist1);\r
fCorrRecTrackMeanPtTrueMultHist1[i]->GetAxis(0)->SetTitle("<Pt> (GeV/c)");\r
fCorrRecTrackMeanPtTrueMultHist1[i]->GetAxis(1)->SetTitle("true multiplicity");\r
fCorrRecTrackMeanPtTrueMultHist1[i]->Sumw2();\r
\r
- sprintf(name,"fCorrRecTrackPt1_%d",i);\r
- sprintf(title,"pt small bining");\r
+ snprintf(name,256,"fCorrRecTrackPt1_%d",i);\r
+ snprintf(title,256,"pt small bining");\r
fCorrRecTrackPt1[i] = new THnSparseF(name,title,1,binsCorrRecTrackPt1,minCorrRecTrackPt1,maxCorrRecTrackPt1);\r
fCorrRecTrackPt1[i]->GetAxis(0)->SetTitle("Pt (GeV/c)");\r
fCorrRecTrackPt1[i]->Sumw2();\r
for(Int_t i=0; i<5; i++) \r
{\r
// event corrected histograms\r
- sprintf(name,"fCorrRecEventHist1_%d",i);\r
- sprintf(title,"mcZv:mult");\r
+ snprintf(name,256,"fCorrRecEventHist1_%d",i);\r
+ snprintf(title,256,"mcZv:mult");\r
fCorrRecEventHist1[i] = new THnSparseF("fCorrRecEventHist1","mcZv:mult",2,binsEventMatrix,minEventMatrix,maxEventMatrix);\r
fCorrRecEventHist1[i]->SetBinEdges(0,binsZv);\r
fCorrRecEventHist1[i]->GetAxis(0)->SetTitle("Zv (cm)");\r
fCorrRecEventHist1[i]->Sumw2();\r
\r
// empty event corrected histograms\r
- sprintf(name,"fCorrRecEventHist2_%d",i);\r
- sprintf(title,"mcZv:mult");\r
+ snprintf(name,256,"fCorrRecEventHist2_%d",i);\r
+ snprintf(title,256,"mcZv:mult");\r
fCorrRecEventHist2[i] = new THnSparseF("fCorrRecEventHist2","mcZv:mult",2,binsEventMatrix,minEventMatrix,maxEventMatrix);\r
fCorrRecEventHist2[i]->SetBinEdges(0,binsZv);\r
fCorrRecEventHist2[i]->GetAxis(0)->SetTitle("Zv (cm)");\r
Int_t binsCosmicsHisto[3]= {151, 300, ptNbins};\r
Double_t minCosmicsHisto[3]={-1.5, -2.*TMath::Pi(), 0.0}; \r
Double_t maxCosmicsHisto[3]={ 1.5, 2.*TMath::Pi(), 16.0}; \r
- sprintf(name,"fCosmicsHisto");\r
- sprintf(title,"deta:dphi:pt");\r
+ snprintf(name,256,"fCosmicsHisto");\r
+ snprintf(title,256,"deta:dphi:pt");\r
\r
fCosmicsHisto = new THnSparseF(name,title,3,binsCosmicsHisto,minCosmicsHisto,maxCosmicsHisto);\r
fCosmicsHisto->SetBinEdges(2,binsPt);\r
//\r
\r
//nCrossRows:chi2PerClust:nCrossRows/nFindableClust:fracSharedClust:DCAy:DCAz:eta:phi:pt:hasStrangeMother:isFromMaterial:isPrim:charge\r
- Int_t binsRecMCTrackHist[13]= {160, 10, 20, 20, 50, 50, 20, 90, ptNbins, 2, 2, 2, 3};\r
- Double_t minRecMCTrackHist[13]={0., 0., 0., 0.,-0.5,-0.5,-1.0, 0., ptMin, 0., 0., 0.,-1.};\r
- Double_t maxRecMCTrackHist[13]={160.,10.,1., 1., 0.5, 0.5, 1.0, 2.*TMath::Pi(), ptMax, 2., 2., 2., 2.};\r
+ Int_t binsRecMCTrackHist[13]= { 160, 10, 20, 20, 50, 50, 20, 90, ptNbins, 2, 2, 2, 3 };\r
+ Double_t minRecMCTrackHist[13]={ 0., 0., 0., 0., -0.5,-0.5,-1.0, 0., ptMin, 0., 0., 0.,-1. };\r
+ Double_t maxRecMCTrackHist[13]={ 160., 10., 1., 1., 0.5, 0.5, 1.0, 2.*TMath::Pi(), ptMax, 2., 2., 2., 2. };\r
\r
fRecMCTrackHist = new THnSparseF("fRecMCTrackHist","nCrossRows:chi2PerClust:nCrossRows/nFindableClust:fracSharedClust:DCAy:DCAz:eta:phi:pt:hasStrangeMother:isFromMaterial:isPrim:charge",13,binsRecMCTrackHist,minRecMCTrackHist,maxRecMCTrackHist);\r
fRecMCTrackHist->SetBinEdges(8,binsPt);\r
//\r
TH1::AddDirectory(kFALSE);\r
TObjArray *aFolderObj = new TObjArray;\r
+ if(!aFolderObj) return;\r
+\r
TH1D *h1D = 0; \r
TH2D *h2D = 0; \r
\r
// Event counters\r
//\r
h2D = (TH2D*)fEventCount->Projection(0,1);\r
+ if(!h2D) return;\r
h2D->SetName("trig_vs_trigANDvertex");\r
aFolderObj->Add(h2D);\r
\r
fEventCount->GetAxis(0)->SetRange(2,2); // triggered\r
h1D = (TH1D*)fEventCount->Projection(1);\r
+ if(!h1D) return;\r
h1D->SetTitle("rec. vertex for triggered events");\r
h1D->SetName("trigANDvertex");\r
aFolderObj->Add(h1D);\r
// Create rec. event histograms\r
//\r
h1D = (TH1D *)fRecEventHist->Projection(0);\r
+ if(!h1D) return;\r
h1D->SetName("rec_xv");\r
aFolderObj->Add(h1D);\r
\r
h1D = (TH1D *)fRecEventHist->Projection(1);\r
+ if(!h1D) return;\r
h1D->SetName("rec_yv");\r
aFolderObj->Add(h1D);\r
\r
h1D = (TH1D *)fRecEventHist->Projection(2);\r
+ if(!h1D) return;\r
h1D->SetName("rec_zv");\r
aFolderObj->Add(h1D);\r
\r
h2D = (TH2D *)fRecEventHist->Projection(3,4);\r
+ if(!h2D) return;\r
h2D->SetName("rec_resZv_vs_Mult");\r
aFolderObj->Add(h2D);\r
\r
h2D = (TH2D *)fRecEventHist->Projection(0,1);\r
+ if(!h2D) return;\r
h2D->SetName("rec_xv_vs_yv");\r
aFolderObj->Add(h2D);\r
\r
h2D = (TH2D *)fRecEventHist->Projection(0,2);\r
+ if(!h2D) return;\r
h2D->SetName("rec_xv_vs_zv");\r
aFolderObj->Add(h2D);\r
\r
h2D = (TH2D *)fRecEventHist->Projection(3,4);\r
+ if(!h2D) return;\r
h2D->SetName("rec_resZv_vs_Mult");\r
aFolderObj->Add(h2D);\r
\r
// Create mc event histograms\r
//\r
h2D = (TH2D *)fMCEventHist->Projection(0,1);\r
+ if(!h2D) return;\r
h2D->SetName("mc_xv_vs_yv");\r
aFolderObj->Add(h2D);\r
\r
h2D = (TH2D *)fMCEventHist->Projection(0,2);\r
+ if(!h2D) return;\r
h2D->SetName("mc_xv_vs_zv");\r
aFolderObj->Add(h2D);\r
\r
// Create rec-mc event histograms\r
//\r
h2D = (TH2D *)fRecMCEventHist->Projection(0,3);\r
+ if(!h2D) return;\r
h2D->SetName("rec_mc_deltaXv_vs_mult");\r
aFolderObj->Add(h2D);\r
\r
h2D = (TH2D *)fRecMCEventHist->Projection(1,3);\r
+ if(!h2D) return;\r
h2D->SetName("rec_mc_deltaYv_vs_mult");\r
aFolderObj->Add(h2D);\r
\r
h2D = (TH2D *)fRecMCEventHist->Projection(2,3);\r
+ if(!h2D) return;\r
h2D->SetName("rec_mc_deltaZv_vs_mult");\r
aFolderObj->Add(h2D);\r
\r
fRecMCTrackHist->GetAxis(4)->SetRangeUser(-maxDCAr,maxDCAr);\r
\r
h2D = (TH2D *)fRecMCTrackHist->Projection(7,5);\r
+ if(!h2D) return;\r
h2D->SetName("pt_vs_eta");\r
aFolderObj->Add(h2D);\r
\r
fRecMCTrackHist->GetAxis(7)->SetRangeUser(minPt,maxPt); \r
\r
h2D = (TH2D *)fRecMCTrackHist->Projection(0,5);\r
+ if(!h2D) return;\r
h2D->SetName("nClust_vs_eta");\r
aFolderObj->Add(h2D);\r
\r
h2D = (TH2D *)fRecMCTrackHist->Projection(1,5);\r
+ if(!h2D) return;\r
h2D->SetName("chi2PerClust_vs_eta");\r
aFolderObj->Add(h2D);\r
\r
h2D = (TH2D *)fRecMCTrackHist->Projection(2,5);\r
+ if(!h2D) return;\r
h2D->SetName("ratio_nClust_nFindableClust_vs_eta");\r
aFolderObj->Add(h2D);\r
\r
h2D = (TH2D *)fRecMCTrackHist->Projection(5,6);\r
+ if(!h2D) return;\r
h2D->SetName("eta_vs_phi");\r
aFolderObj->Add(h2D);\r
\r
fRecMCTrackHist->GetAxis(5)->SetRangeUser(minEta,maxEta); \r
\r
h2D = (TH2D *)fRecMCTrackHist->Projection(0,6);\r
+ if(!h2D) return;\r
h2D->SetName("nClust_vs_phi");\r
aFolderObj->Add(h2D);\r
\r
h2D = (TH2D *)fRecMCTrackHist->Projection(1,6);\r
+ if(!h2D) return;\r
h2D->SetName("chi2PerClust_vs_phi");\r
aFolderObj->Add(h2D);\r
\r
h2D = (TH2D *)fRecMCTrackHist->Projection(2,6);\r
+ if(!h2D) return;\r
h2D->SetName("ratio_nClust_nFindableClust_vs_phi");\r
aFolderObj->Add(h2D);\r
\r
fRecMCTrackHist->GetAxis(7)->SetRangeUser(0.0,maxPt); \r
\r
h2D = (TH2D *)fRecMCTrackHist->Projection(0,7);\r
+ if(!h2D) return;\r
h2D->SetName("nClust_vs_pt");\r
aFolderObj->Add(h2D);\r
\r
h2D = (TH2D *)fRecMCTrackHist->Projection(1,7);\r
+ if(!h2D) return;\r
h2D->SetName("chi2PerClust_vs_pt");\r
aFolderObj->Add(h2D);\r
\r
h2D = (TH2D *)fRecMCTrackHist->Projection(2,7);\r
+ if(!h2D) return;\r
h2D->SetName("ratio_nClust_nFindableClust_vs_pt");\r
aFolderObj->Add(h2D);\r
\r
h2D = (TH2D *)fRecMCTrackHist->Projection(6,7);\r
+ if(!h2D) return;\r
h2D->SetName("phi_vs_pt");\r
aFolderObj->Add(h2D);\r
\r
fRecMCTrackHist->GetAxis(4)->SetRangeUser(-maxDCAr,maxDCAr);\r
\r
h2D = (TH2D *)fRecMCTrackHist->Projection(0,1);\r
+ if(!h2D) return;\r
h2D->SetName("nClust_vs_chi2PerClust");\r
aFolderObj->Add(h2D);\r
\r
h2D = (TH2D *)fRecMCTrackHist->Projection(0,2);\r
+ if(!h2D) return;\r
h2D->SetName("nClust_vs_ratio_nClust_nFindableClust");\r
aFolderObj->Add(h2D);\r
\r
// sec\r
fRecMCTrackHist->GetAxis(9)->SetRange(1,1);\r
h1D = (TH1D *)fRecMCTrackHist->Projection(3);\r
+ if(!h1D) return;\r
h1D->SetName("dcay_sec");\r
aFolderObj->Add(h1D);\r
\r
// prim\r
fRecMCTrackHist->GetAxis(9)->SetRange(2,2);\r
h1D = (TH1D *)fRecMCTrackHist->Projection(3);\r
+ if(!h1D) return;\r
h1D->SetName("dcay_prim");\r
aFolderObj->Add(h1D);\r
\r
// sec\r
fRecMCTrackHist->GetAxis(9)->SetRange(1,1);\r
h1D = (TH1D *)fRecMCTrackHist->Projection(4);\r
+ if(!h1D) return;\r
h1D->SetName("dcaz_sec");\r
aFolderObj->Add(h1D);\r
\r
// prim\r
fRecMCTrackHist->GetAxis(9)->SetRange(2,2);\r
h1D = (TH1D *)fRecMCTrackHist->Projection(4);\r
+ if(!h1D) return;\r
h1D->SetName("dcaz_prim");\r
aFolderObj->Add(h1D);\r
\r
\r
// export objects to analysis folder\r
fAnalysisFolder = ExportToFolder(aFolderObj);\r
+ if(!fAnalysisFolder) {\r
+ if(aFolderObj) delete aFolderObj;\r
+ return;\r
+ }\r
\r
// delete only TObjArray\r
if(aFolderObj) delete aFolderObj;\r
\r
// get reconstructed vertex \r
const AliESDVertex* vtxESD = 0; \r
- if(evtCuts->IsRecVertexRequired()) \r
- {\r
- if(GetAnalysisMode() == AlidNdPtHelper::kTPC) {\r
+ if(GetAnalysisMode() == AlidNdPtHelper::kTPC) {\r
vtxESD = esdEvent->GetPrimaryVertexTPC();\r
- }\r
- else if(GetAnalysisMode() == AlidNdPtHelper::kTPCITS) {\r
- vtxESD = esdEvent->GetPrimaryVertexTracks();\r
- }\r
- else {\r
+ }\r
+ else if(GetAnalysisMode() == AlidNdPtHelper::kTPCITS) {\r
+ vtxESD = esdEvent->GetPrimaryVertexTracks();\r
+ }\r
+ else {\r
return;\r
- }\r
}\r
+\r
+ if(!vtxESD) return;\r
+\r
Bool_t isEventOK = evtCuts->AcceptEvent(esdEvent,mcEvent,vtxESD); \r
//printf("isEventOK %d, isEventTriggered %d \n",isEventOK, isEventTriggered);\r
//printf("GetAnalysisMode() %d \n",GetAnalysisMode());\r
//\r
TH1::AddDirectory(kFALSE);\r
TObjArray *aFolderObj = new TObjArray;\r
+ if(!aFolderObj) return; \r
+\r
TH1D *h1Dall = 0; \r
TH1D *h1D = 0; \r
TH1D *h1Dc = 0; \r
//eff vs eta\r
fRecMCTrackHistTPCITS->GetAxis(6)->SetRange(2,2); \r
h1Dall = (TH1D *)fRecMCTrackHistTPCITS->Projection(0);\r
+ if(!h1Dall) return;\r
fRecMCTrackHistTPCITS->GetAxis(5)->SetRange(2,2); \r
h1D = (TH1D *)fRecMCTrackHistTPCITS->Projection(0);\r
+ if(!h1D) return;\r
\r
h1Dc = (TH1D *)h1D->Clone("eff_vs_eta_TPCITS");\r
h1Dc->Divide(h1Dall);\r
fRecMCTrackHistTPCITS->GetAxis(6)->SetRange(2,2); \r
fRecMCTrackHistTPCITS->GetAxis(0)->SetRangeUser(-0.8, 0.799); \r
h1Dall = (TH1D *)fRecMCTrackHistTPCITS->Projection(1);\r
+ if(!h1Dall) return;\r
fRecMCTrackHistTPCITS->GetAxis(5)->SetRange(2,2); \r
h1D = (TH1D *)fRecMCTrackHistTPCITS->Projection(1);\r
+ if(!h1D) return;\r
\r
h1Dc = (TH1D *)h1D->Clone("eff_vs_phi_TPCITS");\r
h1Dc->Divide(h1Dall);\r
fRecMCTrackHistTPCITS->GetAxis(6)->SetRange(2,2); \r
fRecMCTrackHistTPCITS->GetAxis(0)->SetRangeUser(-0.8, 0.799); \r
h1Dall = (TH1D *)fRecMCTrackHistTPCITS->Projection(2);\r
+ if(!h1Dall) return;\r
fRecMCTrackHistTPCITS->GetAxis(5)->SetRange(2,2); \r
h1D = (TH1D *)fRecMCTrackHistTPCITS->Projection(2);\r
+ if(!h1D) return;\r
\r
h1Dc = (TH1D *)h1D->Clone("eff_vs_pT_TPCITS");\r
h1Dc->Divide(h1Dall);\r
\r
//eff vs eta\r
h1Dall = (TH1D *)fRecMCTrackHistITSTPC->Projection(0);\r
+ if(!h1Dall) return;\r
fRecMCTrackHistITSTPC->GetAxis(5)->SetRange(2,2); \r
h1D = (TH1D *)fRecMCTrackHistITSTPC->Projection(0);\r
+ if(!h1D) return;\r
\r
h1Dc = (TH1D *)h1D->Clone("eff_vs_eta_ITSTPC");\r
h1Dc->Divide(h1Dall);\r
//eff vs phi\r
fRecMCTrackHistITSTPC->GetAxis(0)->SetRangeUser(-0.8, 0.799); \r
h1Dall = (TH1D *)fRecMCTrackHistITSTPC->Projection(1);\r
+ if(!h1Dall) return;\r
fRecMCTrackHistITSTPC->GetAxis(5)->SetRange(2,2); \r
h1D = (TH1D *)fRecMCTrackHistITSTPC->Projection(1);\r
+ if(!h1D) return;\r
\r
h1Dc = (TH1D *)h1D->Clone("eff_vs_phi_ITSTPC");\r
h1Dc->Divide(h1Dall);\r
//eff vs pT\r
fRecMCTrackHistITSTPC->GetAxis(0)->SetRangeUser(-0.8, 0.799); \r
h1Dall = (TH1D *)fRecMCTrackHistITSTPC->Projection(2);\r
+ if(!h1Dall) return;\r
fRecMCTrackHistITSTPC->GetAxis(5)->SetRange(2,2); \r
h1D = (TH1D *)fRecMCTrackHistITSTPC->Projection(2);\r
+ if(!h1D) return;\r
\r
h1Dc = (TH1D *)h1D->Clone("eff_vs_pT_ITSTPC");\r
h1Dc->Divide(h1Dall);\r
\r
// export objects to analysis folder\r
fAnalysisFolder = ExportToFolder(aFolderObj);\r
+ if(!fAnalysisFolder) {\r
+ if(aFolderObj) delete aFolderObj;\r
+ return;\r
+ }\r
\r
// delete only TObjArray\r
if(aFolderObj) delete aFolderObj;\r
TVirtualPad* currentPad = gPad;
TAxis* axis = hRes2->GetXaxis();
Int_t nBins = axis->GetNbins();
- Bool_t overflowBinFits = kFALSE;
+ //Bool_t overflowBinFits = kFALSE;
TH1F* hRes, *hMean;
if (axis->GetXbins()->GetSize()){
hRes = new TH1F("hRes", "", nBins, axis->GetXbins()->GetArray());
fitFunc->SetFillStyle(0);
// create canvas for fits
TCanvas* canBinFits = NULL;
- Int_t nPads = (overflowBinFits) ? nBins+2 : nBins;
+ //Int_t nPads = (overflowBinFits) ? nBins+2 : nBins;
+ Int_t nPads = nBins;
Int_t nx = Int_t(sqrt(nPads-1.));// + 1;
Int_t ny = (nPads-1) / nx + 1;
if (drawBinFits) {
}
// loop over x bins and fit projection
- Int_t dBin = ((overflowBinFits) ? 1 : 0);
+ //Int_t dBin = ((overflowBinFits) ? 1 : 0);
+ Int_t dBin = 0;
for (Int_t bin = 1-dBin; bin <= nBins+dBin; bin++) {
if (drawBinFits) canBinFits->cd(bin + dBin);
Int_t bin0=TMath::Max(bin-integ,0);
--- /dev/null
+Double_t ApplyCorrections_PbPb(const char* datafile, const char* datatask, const char* corrfile, const char* idstring ,const char* outfile, const char* gifdir = 0)
+//Double_t ApplyCorrections_PbPb()
+{
+
+// tmp setting
+// const char* datafile = "/lustre/alice/train/V006.PbPb/2011-03-15_0009.5917/mergedPeriods/PbPb/2.76ATeV/LHC10h.pass1/mknichel_dNdPtPbPb_TPCITS_VZERO1.root";
+// const char* datatask = "mknichel_dNdPtPbPb_TPCITS_VZERO";
+// const char* corrfile = "/u/mknichel/alice/dNdPt_PbPb/2011-03-15/corrMatr_LHC10h8_TPCITS.root";
+// const char* idstring = "c0";
+// const char* outfile = "/u/mknichel/alice/dNdPt_PbPb/2011-03-15/finalSpectra_LHC10h.pass1_TPCITS.root";
+// const char* gifdir = "/u/mknichel/alice/dNdPt_PbPb/2011-03-15/LHC10h.pass1";
+
+
+Int_t c_first = 1;
+Int_t c_last = 11;
+
+TString id = TString(idstring);
+if ( id.Contains("c0-5") ) { c_first = c_last = 1; }
+if ( id.Contains("c5-10") ) { c_first = c_last = 2; }
+if ( id.Contains("c10-20") ) { c_first = c_last = 3; }
+if ( id.Contains("c20-30") ) { c_first = c_last = 4; }
+if ( id.Contains("c30-40") ) { c_first = c_last = 5; }
+if ( id.Contains("c40-50") ) { c_first = c_last = 6; }
+if ( id.Contains("c50-60") ) { c_first = c_last = 7; }
+if ( id.Contains("c60-70") ) { c_first = c_last = 8; }
+if ( id.Contains("c70-80") ) { c_first = c_last = 9; }
+if ( id.Contains("c80-90") ) { c_first = c_last = 10; }
+if ( id.Contains("c90-100") ) { c_first = c_last = 11; }
+
+ // settings vor zVertex cut (event and track level)
+ Double_t zVert = 10.0;
+
+ // setting on eta cut (track level)
+ Double_t eta = 0.8;
+
+ //load required libraries
+ //load required libraries
+ gSystem->AddIncludePath("-I$ROOTSYS/include -I$ALICE_ROOT/ -I$ALICE_ROOT/include -I$ALICE_ROOT/STEER -I$ALICE_ROOT/ANALYSIS -I$ALICE_ROOT/PWG0 -I$ALICE_ROOT/PWG1 -I$ALICE_ROOT/PWG2 -I$ALICE_ROOT/PWG3 -I$ALICE_ROOT/PWG3/vertexingHF -I$ALICE_ROOT/PWG4 -I$ALICE_ROOT/CORRFW -I$ALICE_ROOT/TPC -I$ALICE_ROOT/TRD -I$ALICE_ROOT/PWG3/muon -I$ALICE_ROOT/JETAN -I$ALICE_ROOT/ANALYSIS/Tender");
+
+ gSystem->Load("libCore");
+ gSystem->Load("libPhysics");
+ gSystem->Load("libMinuit");
+ gSystem->Load("libGui");
+ gSystem->Load("libXMLParser");
+
+ gSystem->Load("libGeom");
+ gSystem->Load("libVMC");
+
+ gSystem->Load("libNet");
+
+ gSystem->Load("libSTEERBase");
+ gSystem->Load("libESD");
+ gSystem->Load("libCDB");
+ gSystem->Load("libRAWDatabase");
+ gSystem->Load("libRAWDatarec");
+ gSystem->Load("libANALYSIS");
+
+
+
+ gSystem->Load("libANALYSIS.so");
+ gSystem->Load("libANALYSISalice.so");
+ gSystem->Load("libTENDER.so");
+ gSystem->Load("libCORRFW.so");
+ gSystem->Load("libPWG0base.so");
+ gSystem->Load("libPWG0dep");
+ gSystem->Load("libPWG0selectors.so");
+
+
+ // make plots nicer
+ gROOT->SetStyle("Plain");
+ gStyle->SetPalette(1);
+
+ // array for all histograms to be saved
+ TObjArray* Hists = new TObjArray();
+
+ // open file with correction matrices
+ TFile *fcorr = TFile::Open(corrfile,"READ");
+ if (!fcorr) return -2;
+
+ // load data
+ TFile* fdata = TFile::Open(datafile,"READ");
+ if (!fdata) return -1;
+ TList* ldata = dynamic_cast<TList*>(fdata->Get(datatask));
+ if (!ldata) return -1;
+ AlidNdPtAnalysisPbPb *obj = dynamic_cast<AlidNdPtAnalysisPbPb*>(ldata->FindObject("dNdPtAnalysisPbPb"));
+ if (!obj) return -1;
+
+ //Event statistics
+ THnSparse *fRecEventHist2 = obj->GetRecEventHist2(); //reconstructed events
+ fRecEventHist2->GetAxis(2)->SetRange(c_first,c_last); // select centrality
+ TH2D* h2RecEvent2All = (TH2D*) fRecEventHist2->Projection(0,1)->Clone("h2RecEvent2All");
+ fRecEventHist2->GetAxis(0)->SetRangeUser(-zVert, zVert-0.01);//zVer
+ TH2D* h2RecEvent2 = (TH2D*) fRecEventHist2->Projection(0,1)->Clone("h2RecEvent2");
+
+ Double_t ReconstructedEvents = h2RecEvent2->Integral();
+ Double_t ReconstructedEventsAll = h2RecEvent2All->Integral();
+
+ Hists->Add(h2RecEvent2);
+ Hists->Add(h2RecEvent2All);
+
+ printf("=== Number of events from DATA %lf ===\n",ReconstructedEvents);
+ printf("=== Number of events from DATA (before zVertex cut) %lf ===\n",ReconstructedEventsAll);
+
+ TH1D* h1ReconstructedEvents = new TH1D("h1ReconstructedEvents","h1ReconstructedEvents",1,0,1);
+ TH1D* h1ReconstructedEventsAll = new TH1D("h1ReconstructedEventsAll","h1ReconstructedEventsAll",1,0,1);
+
+ h1ReconstructedEvents->Fill(0,ReconstructedEvents);
+ h1ReconstructedEvents->SetEntries(ReconstructedEvents);
+ h1ReconstructedEventsAll->Fill(0,ReconstructedEventsAll);
+ h1ReconstructedEventsAll->SetEntries(ReconstructedEventsAll);
+
+ Hists->Add(h1ReconstructedEvents);
+ Hists->Add(h1ReconstructedEventsAll);
+
+ // retrieve tracks
+ THnSparse* fRecTrackHist2 = obj->GetRecTrackHist2(2); //after all cuts (2)
+ fRecTrackHist2->GetAxis(3)->SetRange(c_first,c_last); // select centrality
+ fRecTrackHist2->GetAxis(0)->SetRangeUser(-zVert, zVert-0.01); //zVertex
+ fRecTrackHist2->GetAxis(2)->SetRangeUser(-eta, eta-0.01); // eta
+
+ TH1D* h1RecTrackHist2_zv = fRecTrackHist2->Projection(0)->Clone("h1RecTrackHist2_zv");
+ TH1D* h1RecTrackHist2_pt = fRecTrackHist2->Projection(1)->Clone("h1RecTrackHist2_pt");
+ TH1D* h1RecTrackHist2_eta = fRecTrackHist2->Projection(2)->Clone("h1RecTrackHist2_eta");
+
+ Hists->Add(h1RecTrackHist2_zv);
+ Hists->Add(h1RecTrackHist2_pt);
+ Hists->Add(h1RecTrackHist2_eta);
+
+ // retrieve correction matrices for tracking efficiency (note different binning!)
+ TH1D* h1TrackCorr_pt = (TH1D*)fcorr->Get("h1TrackCorr_pt");
+ TH1D* h1TrackCorr_eta = (TH1D*)fcorr->Get("h1TrackCorr_eta");
+
+ // retrieve correction matrices for secondaries (note different binning!)
+ TH1D* h1SecCorr_pt = (TH1D*)fcorr->Get("h1SecCorr_pt");
+ TH1D* h1SecCorr_eta = (TH1D*)fcorr->Get("h1SecCorr_eta");
+
+ // create corrected spectra (as clone of raw data)
+ TH1D* h1Corrected_pt = h1RecTrackHist2_pt->Clone("h1Corrected_pt");
+ TH1D* h1Corrected_eta = h1RecTrackHist2_eta->Clone("h1Corrected_eta");
+
+ // secondaries correction for pt spectrum
+ for (int i=1; i <= h1Corrected_pt->GetNbinsX() ; i++) {
+ Double_t pt = h1Corrected_pt->GetBinCenter(i);
+ Double_t val = h1Corrected_pt->GetBinContent(i);
+ Double_t err = h1Corrected_pt->GetBinError(i);
+ if (pt >= 50) { pt = 49.5; } // above 50 GeV corr matr have low statistics
+ Double_t secCorr = h1SecCorr_pt->GetBinContent(h1SecCorr_pt->FindBin(pt));
+ Double_t secCorrErr = h1SecCorr_pt->GetBinError(h1SecCorr_pt->FindBin(pt));
+ Double_t effCorr = h1TrackCorr_pt->GetBinContent(h1TrackCorr_pt->FindBin(pt));
+ Double_t effCorrErr = h1TrackCorr_pt->GetBinError(h1TrackCorr_pt->FindBin(pt));
+ Double_t corr = effCorr*secCorr;
+ Double_t corrErr = effCorr*secCorrErr + secCorr*effCorrErr; // errors are correlated
+ Double_t cval = val*corr;
+ Double_t cerr = TMath::Sqrt(val*val*corrErr*corrErr + err*err*corr*corr);
+ h1Corrected_pt->SetBinContent(i,cval);
+ h1Corrected_pt->SetBinError(i,cerr);
+ }
+
+
+ // for eta the correction is simpler because of same binning
+ h1Corrected_eta->Multiply(h1SecCorr_eta);
+ h1Corrected_eta->Multiply(h1TrackCorr_eta);
+
+ Hists->Add(h1Corrected_pt);
+ Hists->Add(h1Corrected_eta);
+
+ // create final spectra (as clone of corrected data)
+ TH1D* dNdPt = h1Corrected_pt->Clone("dNdPt");
+ TH1D* dNdEta = h1Corrected_eta->Clone("dNdEta");
+
+ // also uncorrected spectra (as clone of raw data)
+ TH1D* dNdPt_raw = h1RecTrackHist2_pt->Clone("dNdPt_raw");
+ TH1D* dNdEta_raw = h1RecTrackHist2_eta->Clone("dNdEta_raw");
+
+ TH1D* dNdPt_nores = h1Corrected_pt->Clone("dNdPt_nores");
+
+
+//TF1 *fperi = new TF1("fperi","1.00343-0.000608425*x-6.7038e-05*x*x",5.,40.);
+//TF1 *fcent = new TF1("cent","1.01074e+00-1.98127e-03*x-1.19903e-04*x*x",5.,40.);
+TFile* fptcorr = TFile::Open("ptcorrPbPb_150511.root");
+
+TF1 * fun = 0;
+
+ TF1 *fcent = new TF1("fcent","1.01074e+00-1.98127e-03*x-1.19903e-04*x*x",5.,50.);
+ TF1 *fperi = new TF1("fperi","1.00343-0.000608425*x-6.7038e-05*x*x",5.,50.);
+Double_t downscale = 1.;
+ if (c_first != c_last) {
+ cout << "++++++++++++++++++++++++++++++++++++++++" << endl;
+ cout << "WARNING: pt resolution correction error!" << endl;
+ cout << " (works only for single centraliy bins) " << endl;
+ cout << "++++++++++++++++++++++++++++++++++++++++" << endl;
+ }
+ if (c_first == 1) {
+ fun = (TF1*) fptcorr->Get("ptcorr_c0");
+ downscale = 0.8;
+ cout << "+++++++++++++++++++++++++++++++++++++++++++" << endl;
+ cout << "0-5% central pt-resolution correction used!" << endl;
+ cout << "+++++++++++++++++++++++++++++++++++++++++++" << endl;
+ } else if (c_first == 2) {
+ downscale = 0.8;
+ fun =(TF1*) fptcorr->Get("ptcorr_c5");
+ cout << "+++++++++++++++++++++++++++++++++++++++++++" << endl;
+ cout << "5-10% central pt-resolution correction used!" << endl;
+ cout << "+++++++++++++++++++++++++++++++++++++++++++" << endl;
+ } else if (c_first == 3) {
+ downscale = 0.8;
+ fun =(TF1*) fptcorr->Get("ptcorr_c10");
+ cout << "+++++++++++++++++++++++++++++++++++++++++++" << endl;
+ cout << "10-20% central pt-resolution correction used!" << endl;
+ cout << "+++++++++++++++++++++++++++++++++++++++++++" << endl;
+ } else if (c_first == 4) {
+ downscale = 0.9;
+ fun =(TF1*) fptcorr->Get("ptcorr_c20");
+ cout << "+++++++++++++++++++++++++++++++++++++++++++" << endl;
+ cout << "20-30% central pt-resolution correction used!" << endl;
+ cout << "+++++++++++++++++++++++++++++++++++++++++++" << endl;
+ } else if (c_first == 5) {
+ fun =(TF1*) fptcorr->Get("ptcorr_c30");
+ cout << "+++++++++++++++++++++++++++++++++++++++++++" << endl;
+ cout << "30-40% central pt-resolution correction used!" << endl;
+ cout << "+++++++++++++++++++++++++++++++++++++++++++" << endl;
+ } else if (c_first == 6) {
+ fun =(TF1*) fptcorr->Get("ptcorr_c40");
+ cout << "+++++++++++++++++++++++++++++++++++++++++++" << endl;
+ cout << "40-50% central pt-resolution correction used!" << endl;
+ cout << "+++++++++++++++++++++++++++++++++++++++++++" << endl;
+ } else if (c_first == 7) {
+ fun =(TF1*) fptcorr->Get("ptcorr_c50");
+ cout << "+++++++++++++++++++++++++++++++++++++++++++" << endl;
+ cout << "50-60% central pt-resolution correction used!" << endl;
+ cout << "+++++++++++++++++++++++++++++++++++++++++++" << endl;
+ } else if (c_first == 8) {
+ fun =(TF1*) fptcorr->Get("ptcorr_c60");
+ cout << "+++++++++++++++++++++++++++++++++++++++++++" << endl;
+ cout << "60-70% central pt-resolution correction used!" << endl;
+ cout << "+++++++++++++++++++++++++++++++++++++++++++" << endl;
+ } else {
+ fun =(TF1*) fptcorr->Get("ptcorr_c70");
+ cout << "+++++++++++++++++++++++++++++++++++++++++++++" << endl;
+ cout << "70-80% central pt-resolution correction used!" << endl;
+ cout << "+++++++++++++++++++++++++++++++++++++++++++++" << endl;
+ }
+
+
+ // normalization and finalization
+ // 1/N_evt 1/(2 pi pt) 1/width 1/etarange
+
+ for (int i=1; i <= dNdPt->GetNbinsX() ;i++) {
+ Double_t pt = dNdPt->GetBinCenter(i);
+ Double_t width = dNdPt->GetBinWidth(i);
+ Double_t val = dNdPt->GetBinContent(i);
+ Double_t err = dNdPt->GetBinError(i);
+ Double_t corrPtResol = 1.0;
+ corrPtResol = 1.-((1.-fun->Eval(pt))*downscale );
+ if (pt < 10.) { corrPtResol = 1.0; }
+ Double_t cval = (val * corrPtResol)/(width * 2.0 * TMath::Pi() * 1.6 * ReconstructedEvents * pt);
+ Double_t cerr = (err * corrPtResol)/(width * 2.0 * TMath::Pi() * 1.6 * ReconstructedEvents * pt);
+ dNdPt->SetBinContent(i,cval);
+ dNdPt->SetBinError(i,cerr);
+ }
+ // for dndeta again simpler
+ dNdEta->Scale(1,"width");
+ dNdEta->Scale(1./ReconstructedEvents);
+
+ // normalization and finalization without resolution correction
+ // 1/N_evt 1/(2 pi pt) 1/width 1/etarange
+ for (int i=1; i <= dNdPt_nores->GetNbinsX() ;i++) {
+ Double_t pt = dNdPt_nores->GetBinCenter(i);
+ Double_t width = dNdPt_nores->GetBinWidth(i);
+ Double_t val = dNdPt_nores->GetBinContent(i);
+ Double_t err = dNdPt_nores->GetBinError(i);
+ Double_t cval = (val)/(width * 2.0 * TMath::Pi() * 1.6 * ReconstructedEvents * pt);
+ Double_t cerr = (err)/(width * 2.0 * TMath::Pi() * 1.6 * ReconstructedEvents * pt);
+ dNdPt_nores->SetBinContent(i,cval);
+ dNdPt_nores->SetBinError(i,cerr);
+ }
+
+ // normalization and finalization
+ // 1/N_evt 1/(2 pi pt) 1/width 1/etarange
+ for (int i=1; i <= dNdPt_raw->GetNbinsX() ;i++) {
+ Double_t pt = dNdPt_raw->GetBinCenter(i);
+ Double_t width = dNdPt_raw->GetBinWidth(i);
+ Double_t val = dNdPt_raw->GetBinContent(i);
+ Double_t err = dNdPt_raw->GetBinError(i);
+ Double_t cval = val/(width * 2.0 * TMath::Pi() * 1.6 * ReconstructedEvents * pt);
+ Double_t cerr = err/(width * 2.0 * TMath::Pi() * 1.6 * ReconstructedEvents * pt);
+ dNdPt_raw->SetBinContent(i,cval);
+ dNdPt_raw->SetBinError(i,cerr);
+ }
+ // for dndeta again simpler
+ dNdEta_raw->Scale(1,"width");
+ dNdEta_raw->Scale(1./ReconstructedEvents);
+
+ dNdEta->SetMarkerStyle(21);
+ dNdPt->SetMarkerStyle(21);
+ dNdPt->SetTitle("; p_{T} (GeV/c) ; 1/N_{evt} 1/(2#pi p_{T}) (d^{2}N_{ch})/(d#eta dp_{T}) (GeV/c)^{-2}");
+ dNdEta->SetTitle("; #eta ; 1/N_{evt} (d^{2}N_{ch})/(d#eta)");
+
+ dNdPt_raw->SetTitle("; p_{T} (GeV/c) ; 1/N_{evt} 1/(2#pi p_{T}) (d^{2}N_{ch})/(d#eta dp_{T}) (GeV/c)^{-2}");
+ dNdEta_raw->SetTitle("; #eta ; 1/N_{evt} (d^{2}N_{ch})/(d#eta)");
+
+ Hists->Add(dNdEta_raw);
+ Hists->Add(dNdPt_raw);
+ Hists->Add(dNdEta);
+ Hists->Add(dNdPt);
+ Hists->Add(dNdPt_nores);
+
+
+ // plot pictures and save to gifdir
+ for (i=0; i < Hists->LastIndex(); i++) {
+ TCanvas* ctmp = PlotHist(Hists->At(i),idstring);
+ if (gifdir && ctmp) {
+ TString gif(gifdir);
+ gif += '/';
+ gif += ctmp->GetName();
+ gif += ".gif";
+ ctmp->SaveAs(gif.Data(),"gif");
+ delete ctmp;
+ }
+ }
+
+ // save all correction matrices and control histograms to file
+ if (!outfile) { return; }
+ TFile *out = TFile::Open(outfile,"RECREATE");
+ Hists->Write();
+ out->Close();
+
+ return ReconstructedEvents;
+
+}
+
+//___________________________________________________________________________
+TCanvas* PlotHist(TObject* hobj, const char* label=0)
+{
+ TH1* h = dynamic_cast<TH1*>(hobj);
+ if (!h) return 0;
+ if (h->GetDimension() > 2) return 0;
+ h->SetStats(0);
+ if ( TString(h->GetName()).Contains("Events")) { h->SetStats(1); }
+ TString t(label);
+ if (label) t += "_";
+ t += h->GetName();
+ h->SetTitle(t.Data());
+ TCanvas* c = new TCanvas(t.Data(),t.Data());
+ if (h->GetDimension() >= 1) {
+ TString xlabel(h->GetXaxis()->GetTitle());
+ if (xlabel.Contains("Pt")) { c->SetLogx(); c->SetLogy(); h->GetXaxis()->SetRangeUser(0.1 , 100.); }
+ if (xlabel.Contains("p_{T}")) { c->SetLogx(); c->SetLogy(); h->GetXaxis()->SetRangeUser(0.1 , 100.); }
+ }
+ if (h->GetDimension() == 2) {
+ TString ylabel(h->GetYaxis()->GetTitle());
+ if (ylabel.Contains("Pt")) { c->SetLogy(); h->GetYaxis()->SetRangeUser(0.1 , 100.); }
+ if (ylabel.Contains("p_{T}")) { c->SetLogy(); h->GetYaxis()->SetRangeUser(0.1 , 100.); }
+ h->Draw("COLZ");
+ }
+ if (h->GetDimension() == 1) {
+ h->Draw();
+ }
+ return c;
+
+}
--- /dev/null
+Double_t ApplyCorrections_pp(const char* datafile, const char* datatask, const char* corrfile, const char* idstring ,const char* outfile, const char* gifdir = 0)
+//Double_t ApplyCorrections_pp()
+{
+
+// tmp setting
+// const char* mcfile = "/d/alice09/mknichel/train/V007.MC_pp/2011-05-05_2347.7147/mergedPeriods/MC_pp/7TeV/LHC10f6a/mknichel_dNdPtpp_TPCITS.root";
+// const char* mctask = "mknichel_dNdPtpp_TPCITS";
+// const char* idstring = "TPCITS";
+// const char* gifdir = "/u/mknichel/alice/dNdPt_pp/temp";
+// const char* datafile = "/d/alice09/mknichel/train/V007.MC_pp/2011-05-05_2347.7147/mergedPeriods/MC_pp/7TeV/LHC10f6a/mknichel_dNdPtpp_TPCITS.root";
+// const char* outfile = "/u/mknichel/alice/dNdPt_pp/temp/FinalSpectra.root";
+// const char* corrfile = "/u/mknichel/alice/dNdPt_pp/temp/corrMatr_LHC10f6a_TPCITS.root";
+// const char* gifdir = "/u/mknichel/alice/dNdPt_pp/temp";
+
+TString fname (datafile);
+
+TString id (idstring);
+TString taskname = "mknichel_dNdPtpp_" + id;
+TString objname = "dNdPtAnalysis_" + id;
+
+// tmp setting
+ // const char* datatask = "jotwinow_dNdPtAnalysis_TPCITS";
+// const char* corrfile = "/u/mknichel/alice/dNdPt_pp/2011-04-04_1251/corrMatr_LHC10f6a_TPCITS.root";
+// const char* idstring = "";
+// const char* outfile = "/u/mknichel/alice/dNdPt_pp/2011-04-04_1251/finalSpectra_LHC11a_TPCITS.root";
+// const char* gifdir = "/u/mknichel/alice/dNdPt_pp/2011-04-04_1251/plots";
+
+ // settings vor zVertex cut (event and track level)
+ Double_t zVert = 10.0;
+
+ // setting on eta cut (track level)
+ Double_t eta = 0.8;
+ /*
+ //load required libraries
+ //load required libraries
+ gSystem->AddIncludePath("-I$ROOTSYS/include -I$ALICE_ROOT/ -I$ALICE_ROOT/include -I$ALICE_ROOT/STEER -I$ALICE_ROOT/ANALYSIS -I$ALICE_ROOT/PWG0 -I$ALICE_ROOT/PWG1 -I$ALICE_ROOT/PWG2 -I$ALICE_ROOT/PWG3 -I$ALICE_ROOT/PWG3/vertexingHF -I$ALICE_ROOT/PWG4 -I$ALICE_ROOT/CORRFW -I$ALICE_ROOT/TPC -I$ALICE_ROOT/TRD -I$ALICE_ROOT/PWG3/muon -I$ALICE_ROOT/JETAN -I$ALICE_ROOT/ANALYSIS/Tender");
+
+ gSystem->Load("libCore");
+ gSystem->Load("libPhysics");
+ gSystem->Load("libMinuit");
+ gSystem->Load("libGui");
+ gSystem->Load("libXMLParser");
+
+ gSystem->Load("libGeom");
+ gSystem->Load("libVMC");
+
+ gSystem->Load("libNet");
+
+ gSystem->Load("libSTEERBase");
+ gSystem->Load("libESD");
+ gSystem->Load("libCDB");
+ gSystem->Load("libRAWDatabase");
+ gSystem->Load("libRAWDatarec");
+ gSystem->Load("libANALYSIS");
+
+
+
+ gSystem->Load("libANALYSIS.so");
+ gSystem->Load("libOADB.so");
+ gSystem->Load("libANALYSISalice.so");
+ gSystem->Load("libTENDER.so");
+ gSystem->Load("libCORRFW.so");
+ gSystem->Load("libPWG0base.so");
+ gSystem->Load("libPWG0dep");
+ gSystem->Load("libPWG0selectors.so");
+ */
+
+ // make plots nicer
+ gROOT->SetStyle("Plain");
+ gStyle->SetPalette(1);
+
+ // array for all histograms to be saves
+ TObjArray* Hists = new TObjArray();
+
+ // open file with correction matrices
+ TFile *fcorr = TFile::Open(corrfile,"READ");
+ if (!fcorr) return -2;
+
+ TH1D* dNdPt_MC = (TH1D*) fcorr->Get("dNdPt_MC");
+ TH1D* dNdEta_MC = (TH1D*) fcorr->Get("dNdEta_MC");
+ Hists->Add(dNdPt_MC);
+ Hists->Add(dNdEta_MC);
+
+ // load data
+ TFile* fdata = TFile::Open(datafile,"READ");
+ if (!fdata) return -1;
+ TList* ldata = dynamic_cast<TList*>(fdata->Get(taskname.Data()));
+ if (!ldata) return -1;
+ AlidNdPtAnalysis *obj = dynamic_cast<AlidNdPtAnalysis*>(ldata->FindObject(objname.Data()));
+ if (!obj) return -1;
+
+ //Event statistics
+ obj->GetRecEventHist2()->GetAxis(0)->SetRange();
+ THnSparse *fRecEventHist2 = obj->GetRecEventHist2(); //reconstructed events
+ TH1D* h1RecEventHist2_zv = (TH1D*) fRecEventHist2->Projection(0)->Clone("h1RecEventHist2_zv"); // zvertex distribution
+ TH2D* h2RecEvent2All = (TH2D*) fRecEventHist2->Projection(0,1)->Clone("h2RecEvent2All");
+ fRecEventHist2->GetAxis(0)->SetRangeUser(-zVert, zVert-0.01);//zVer
+ TH2D* h2RecEvent2 = (TH2D*) fRecEventHist2->Projection(0,1)->Clone("h2RecEvent2");
+ TH2D* h2RecEvent2Corrected = (TH2D*) fRecEventHist2->Projection(0,1)->Clone("h2RecEvent2Corrected"); //will be corrected
+
+ THnSparse* fEventCount = obj->GetEventCount();
+ Hists->Add(fEventCount);
+ Double_t TriggeredEventsNoVertex = fEventCount->Projection(0)->GetBinContent(2) - fEventCount->Projection(1)->GetBinContent(2); // all triggered events without rec. vertex
+ Double_t AllTriggeredEvents = fEventCount->Projection(0)->GetBinContent(2); // all
+
+ Double_t ReconstructedEvents = h2RecEvent2->Integral();
+ Double_t ReconstructedEventsAll = h2RecEvent2All->Integral();
+ Double_t TriggerEffInel = 0.864; //numeber from michele floris for 7TeV (I use it also for 2.76)
+ TriggerEffInel = 0.9379; //mc value from mc
+ if ( fname.Contains("900GeV") ) { TriggerEffInel = 0.9156; }
+ if ( fname.Contains("2.76TeV") ) { TriggerEffInel = 0.883; }
+ if ( fname.Contains("7TeV") ) { TriggerEffInel = 0.8524; }
+
+ cout << "Using Trigger_to_Inel efficiecy: " << TriggerEffInel <<endl;
+
+
+ Double_t ReconstructedEventsFraction = (ReconstructedEventsAll-ReconstructedEvents) / ReconstructedEventsAll;
+ Double_t SelectedEventsFraction = ReconstructedEvents / ReconstructedEventsAll;
+ Double_t InelasticEventsSimple = AllTriggeredEvents/TriggerEffInel*SelectedEventsFraction;
+
+ Hists->Add(h2RecEvent2);
+ Hists->Add(h2RecEvent2All);
+ Hists->Add(h2RecEvent2Corrected);
+
+ printf("=== Number of events from DATA %lf ===\n",ReconstructedEvents);
+ printf("=== Number of events from DATA (before zVertex cut) %lf ===\n",ReconstructedEventsAll);
+ printf("=== Number of events from DATA (all triggered) %lf ===\n",AllTriggeredEvents);
+
+ TH1D* h1ReconstructedEvents = new TH1D("h1ReconstructedEvents","h1ReconstructedEvents",1,0,1);
+ TH1D* h1ReconstructedEventsAll = new TH1D("h1ReconstructedEventsAll","h1ReconstructedEventsAll",1,0,1);
+
+ h1ReconstructedEvents->Fill(0,ReconstructedEvents);
+ h1ReconstructedEvents->SetEntries(ReconstructedEvents);
+ h1ReconstructedEventsAll->Fill(0,ReconstructedEventsAll);
+ h1ReconstructedEventsAll->SetEntries(ReconstructedEventsAll);
+
+ Hists->Add(h1ReconstructedEvents);
+ Hists->Add(h1ReconstructedEventsAll);
+
+ // retrieve corrections (event level)
+ TH2D* h2EventTriggerEffAll = (TH2D*)fcorr->Get("h2EventTriggerEffAll");
+ TH2D* h2EventTriggerCorrAll = (TH2D*)fcorr->Get("h2EventTriggerCorrAll");
+ TH2D* h2EventTriggerEff = (TH2D*)fcorr->Get("h2EventTriggerEff");
+ TH2D* h2EventTriggerCorr = (TH2D*)fcorr->Get("h2EventTriggerCorr");
+ TH2D* h2EventRecEffAll = (TH2D*)fcorr->Get("h2EventRecEffAll");
+ TH2D* h2EventRecCorrAll = (TH2D*)fcorr->Get("h2EventRecCorrAll");
+ TH2D* h2EventRecEff = (TH2D*)fcorr->Get("h2EventRecEff");
+ TH2D* h2EventRecCorr = (TH2D*)fcorr->Get("h2EventRecCorr");
+ TH2D* h2EventEffAll = (TH2D*)fcorr->Get("h2EventEffAll");
+ TH2D* h2EventCorrAll = (TH2D*)fcorr->Get("h2EventCorrAll");
+ TH2D* h2EventEff = (TH2D*)fcorr->Get("h2EventEff");
+ TH2D* h2EventCorr = (TH2D*)fcorr->Get("h2EventCorr");
+ TH1D* h1TriggerEff_bin0_zv = (TH1D*)fcorr->Get("h1TriggerEff_bin0_zv");
+ TH1D* h1TriggerCorr_bin0_zv = (TH1D*)fcorr->Get("h1TriggerCorr_bin0_zv");
+ TH1D* h1Ratio_zv = (TH1D*)fcorr->Get("h1Ratio_zv");
+ TH1D* corr_shape_trig0_zv = (TH1D*)fcorr->Get("corr_shape_trig0_zv");
+ TH1D* corr_shape_notrig0_zv = (TH1D*)fcorr->Get("corr_shape_notrig0_zv");
+
+
+ Double_t corrTrackMatch = 1.0;
+ //tracking efficiency is 2% to low in MC LHC10e13 900GeV as compared to data
+ if ( fname.Contains("900GeV") ) {
+ corrTrackMatch = 1.02;
+ cout << "900 GeV: correct tracking matching efficiency " <<endl;
+ }
+
+
+ // correct bin0
+ //h1RecEventHist2_zv->Scale(1./h1RecEventHist2_zv->Integral());
+ /*
+ TH1D* h1Bin0_zv = (TH1D*) h1RecEventHist2_zv->Clone("h1Bin0_zv");
+ h1Bin0_zv->Multiply(h1Ratio_zv);
+ h1Bin0_zv->Scale(1./h1Bin0_zv->Integral());
+ h1Bin0_zv->Scale(TriggeredEventsNoVertex);
+ //h1Bin0_zv->Multiply(h1TriggerCorr_bin0_zv);
+ h1Bin0_zv->GetXaxis()->SetRangeUser(-zVert, zVert-0.01); //zVertex
+ Double_t bin0EventsCorrected = h1Bin0_zv->Integral();
+ */
+ // this is what is used for normalization
+ Double_t InelasticEventsAll = AllTriggeredEvents/TriggerEffInel;
+ Double_t Bin0EventsAll = TriggeredEventsNoVertex;
+ Double_t UntriggeredEventsAll = InelasticEventsAll - AllTriggeredEvents;
+ cout << "cross check: INEL Events 1 " << InelasticEventsAll <<endl;
+ cout << "cross check: INEL Events 2 " << (ReconstructedEventsAll+Bin0EventsAll+UntriggeredEventsAll) <<endl;
+
+ // correct bin0
+ TH1D* h1Bin0_zv = (TH1D*) h1RecEventHist2_zv->Clone("h1Bin0_zv");
+ h1Bin0_zv->Multiply(corr_shape_trig0_zv); //correct for shape
+ h1Bin0_zv->Scale(1./h1Bin0_zv->Integral()); //normalize
+ h1Bin0_zv->Scale(Bin0EventsAll);
+ Double_t Bin0Events = h1Bin0_zv->Integral(5,8);
+
+ //correct untriggered
+ TH1D* h1NoTrig_zv = (TH1D*) h1RecEventHist2_zv->Clone("h1NoTrig_zv");
+ h1NoTrig_zv->Multiply(corr_shape_notrig0_zv); //correct for shape
+ h1NoTrig_zv->Scale(1./h1NoTrig_zv->Integral()); //normalize
+ h1NoTrig_zv->Scale(UntriggeredEventsAll);
+ Double_t UntriggeredEvents = h1NoTrig_zv->Integral(5,8);
+
+
+ Double_t InelasticEvents = ReconstructedEvents + Bin0Events + UntriggeredEvents;
+
+ /*
+ // my way (old)
+ TH1D* h1Bin0_zv = (TH1D*) h1RecEventHist2_zv->Clone("h1Bin0_zv");
+ h1Bin0_zv->Multiply(h1Ratio_zv);
+ h1Bin0_zv->Multiply(h1TriggerEff_bin0_zv);
+ h1Bin0_zv->Scale(1./h1Bin0_zv->Integral());
+ h1Bin0_zv->Scale(TriggeredEventsNoVertex);
+ h1Bin0_zv->Multiply(h1TriggerCorr_bin0_zv);
+ Double_t bin0EventsCorrected = h1Bin0_zv->Integral(5,8);
+ */
+
+ /*
+ //jaceks way (?)
+ h1RecEventHist2_zv->Scale(1./h1RecEventHist2_zv->Integral());
+ h1RecEventHist2_zv->Scale(TriggeredEventsNoVertex);
+ Double_t bin0EventsCorrected = h1RecEventHist2_zv->Integral(5,8);
+*/
+ // retrieve tracks
+ THnSparse* hSRecTrack; // = obj->GetRecTrackHist()->Clone("hsRecTrack"); //thnsparse to be corrected
+ THnSparse* fRecTrackHist2 = obj->GetRecTrackHist(); //after all cuts (2)
+ fRecTrackHist2->GetAxis(0)->SetRangeUser(-zVert, zVert-0.01); //zVertex
+ fRecTrackHist2->GetAxis(2)->SetRangeUser(-eta, eta-0.01); // eta
+ Int_t dims[4] = {0,1,2,3};
+ hSRecTrack = (THnSparse*) (fRecTrackHist2->Projection(4,dims,"e")->Clone("hSRecTrack"));
+ hSRecTrackAllMult = (THnSparse*) (fRecTrackHist2->Projection(3,dims,"e")->Clone("hSRecTrackAllMult"));
+
+ TH3D* h3RecTrackHist2 = fRecTrackHist2->Projection(0,1,2)->Clone("h3RecTrackHist2");
+
+ TH1D* h1RecTrackHist2_zv = fRecTrackHist2->Projection(0)->Clone("h1RecTrackHist2_zv");
+ TH1D* h1RecTrackHist2_pt = fRecTrackHist2->Projection(1)->Clone("h1RecTrackHist2_pt");
+ TH1D* h1RecTrackHist2_eta = fRecTrackHist2->Projection(2)->Clone("h1RecTrackHist2_eta");
+
+ Hists->Add(h1RecTrackHist2_zv);
+ Hists->Add(h1RecTrackHist2_pt);
+ Hists->Add(h1RecTrackHist2_eta);
+ Hists->Add(h3RecTrackHist2);
+
+ // generate corrections for events
+ TH1D* h1MCGeneratedEvents = (TH1D*)fcorr->Get("h1MCGeneratedEvents");
+ TH1D* h1MCReconstructedEvents = (TH1D*)fcorr->Get("h1MCReconstructedEvents");
+ TH1D* h1MCTriggeredEvents0mult = (TH1D*)fcorr->Get("h1MCTriggeredEvents0mult");
+ TH1D* h1MCTriggeredEventsAll0mult = (TH1D*)fcorr->Get("h1MCTriggeredEventsAll0mult");
+ TH1D* h1MCTriggeredEventsAll = (TH1D*)fcorr->Get("h1MCTriggeredEventsAll");
+ TH1D* h1MCTriggeredEvents = (TH1D*)fcorr->Get("h1MCTriggeredEvents");
+
+
+ Double_t MCGeneratedEvents = h1MCGeneratedEvents->GetEntries();
+ Double_t MCReconstructedEvents = h1MCReconstructedEvents->GetEntries();
+ Double_t CorrEvent = MCGeneratedEvents / MCReconstructedEvents;
+
+ Double_t MCTriggeredEvents = h1MCTriggeredEvents->GetEntries();
+ Double_t MCTriggeredEventsAll = h1MCTriggeredEventsAll->GetEntries();
+ Double_t MCTriggeredEvents0mult = h1MCTriggeredEvents0mult->GetEntries();
+ Double_t MCTriggeredEventsAll0mult = h1MCTriggeredEventsAll0mult->GetEntries();
+ Double_t CorrVtxEvent0mult = MCTriggeredEvents / (MCTriggeredEvents-MCTriggeredEvents0mult); //this is used
+ Double_t CorrVtxEventAll0mult = MCTriggeredEventsAll / (MCTriggeredEventsAll-MCTriggeredEventsAll0mult);
+
+ // correct for trigger/vertex inefficiencies
+ for (int xbin=1; xbin <= h2RecEvent2Corrected->GetNbinsX(); xbin++) {
+ for (int ybin=1; ybin <= h2RecEvent2Corrected->GetNbinsY(); ybin++) {
+ Double_t x = h2RecEvent2Corrected->GetXaxis()->GetBinCenter(xbin);
+ Double_t y = h2RecEvent2Corrected->GetYaxis()->GetBinCenter(ybin);
+ Int_t bin = h2EventCorr->FindBin(x,y);
+ Double_t corr = h2EventCorr->GetBinContent(bin);
+ Double_t correrr = h2EventCorr->GetBinError(bin);
+ if (corr < 0.01) { corr=1.; correrr=0.;} //bin empty in correction matrix
+ Double_t val = h2RecEvent2Corrected->GetBinContent(xbin,ybin);
+ Double_t err = h2RecEvent2Corrected->GetBinError(xbin,ybin);
+ h2RecEvent2Corrected->SetBinContent(xbin,ybin,corr*val);
+ h2RecEvent2Corrected->SetBinError(xbin,ybin,TMath::Sqrt(val*val*correrr*correrr + err*err*corr*corr));
+
+ }
+ }
+ //Double_t ReconstructedEventsCorrected = h2RecEvent2Corrected->Integral() * CorrVtxEvent0mult;
+ //Double_t ReconstructedEventsCorrected = h2RecEvent2Corrected->Integral() + bin0EventsCorrected;
+ printf("=== Number of events from DATA (final correction) %lf ===\n",InelasticEvents);
+ printf("=== Number of events from DATA (corr, no bin0) %lf ===\n",h2RecEvent2Corrected->Integral());
+ printf("=== Number of events from DATA (simple corr. 7TeV) %lf ===\n",InelasticEventsSimple);
+ printf("=== Number of events from DATA (simple correction) %lf ===\n",ReconstructedEvents * CorrEvent);
+ printf("=== Number of bin0events from DATA %lf ===\n",TriggeredEventsNoVertex);
+ //printf("=== Number of bin0events from DATA (corrected) %lf ===\n",bin0EventsCorrected);
+
+ // retrieve 3D correction matrices for tracking efficiency and secondaries (note different binning!)
+ TH3D* h3TrackEff = (TH3D*)fcorr->Get("h3TrackEff");
+ TH3D* h3TrackCorr = (TH3D*)fcorr->Get("h3TrackCorr");
+ TH3D* h3SecCont = (TH3D*)fcorr->Get("h3SecCont");
+ TH3D* h3SecCorr = (TH3D*)fcorr->Get("h3SecCorr");
+
+ // retrieve 3D thnsparse correction matrices for tracking efficiency and secondaries (note different binning!) --- this is used!!!!
+ THnSparse* hSTrackEff = (THnSparse*) fcorr->Get("hSTrackEff");
+ THnSparse* hSTrackCorr = (THnSparse*) fcorr->Get("hSTrackCorr");
+ THnSparse* hSSecCont = (THnSparse*) fcorr->Get("hSSecCont");
+ THnSparse* hSSecCorr = (THnSparse*) fcorr->Get("hSSecCorr");
+
+
+ // retrieve correction matrices for tracking efficiency (note different binning!)
+ TH1D* h1TrackCorr_pt = (TH1D*)fcorr->Get("h1TrackCorr_pt");
+ TH1D* h1TrackCorr_eta = (TH1D*)fcorr->Get("h1TrackCorr_eta");
+
+ // retrieve correction matrices for secondaries (note different binning!)
+ TH1D* h1SecCorr_pt = (TH1D*)fcorr->Get("h1SecCorr_pt");
+ TH1D* h1SecCorr_eta = (TH1D*)fcorr->Get("h1SecCorr_eta");
+
+ // create corrected spectra (as clone of raw data)
+ TH1D* h1Corrected_pt = h1RecTrackHist2_pt->Clone("h1Corrected_pt");
+ TH1D* h1Corrected_eta = h1RecTrackHist2_eta->Clone("h1Corrected_eta");
+
+ // secondaries correction for pt spectrum
+ for (int i=1; i <= h1Corrected_pt->GetNbinsX() ; i++) {
+ Double_t pt = h1Corrected_pt->GetBinCenter(i);
+ Double_t val = h1Corrected_pt->GetBinContent(i);
+ Double_t err = h1Corrected_pt->GetBinError(i);
+ if (pt >= 50) { pt = 49.5; } // above 50 GeV corr matr have low statistics
+ Double_t secCorr = h1SecCorr_pt->GetBinContent(h1SecCorr_pt->FindBin(pt));
+ Double_t secCorrErr = h1SecCorr_pt->GetBinError(h1SecCorr_pt->FindBin(pt));
+ Double_t cval = val*secCorr;
+ Double_t cerr = TMath::Sqrt(val*val*secCorrErr*secCorrErr + err*err*secCorr*secCorr);
+ h1Corrected_pt->SetBinContent(i,cval);
+ h1Corrected_pt->SetBinError(i,cerr);
+ }
+
+ // tracking efficiency correction pt spectrum
+ for (int i=1; i <= h1Corrected_pt->GetNbinsX() ;i++) {
+ Double_t pt = h1Corrected_pt->GetBinCenter(i);
+ Double_t val = h1Corrected_pt->GetBinContent(i);
+ Double_t err = h1Corrected_pt->GetBinError(i);
+ if (pt >= 50) { pt = 49.5; } // above 50 GeV corr matr have low statistics
+ Double_t effCorr = h1TrackCorr_pt->GetBinContent(h1TrackCorr_pt->FindBin(pt));
+ Double_t effCorrErr = h1TrackCorr_pt->GetBinError(h1TrackCorr_pt->FindBin(pt));
+
+ Double_t cval = corrTrackMatch * val * effCorr;
+ Double_t cerr = corrTrackMatch * TMath::Sqrt(val*val*effCorrErr*effCorrErr + err*err*effCorr*effCorr);
+ h1Corrected_pt->SetBinContent(i,cval);
+ h1Corrected_pt->SetBinError(i,cerr);
+ }
+
+
+
+ // efficiency and contamination correction for thnsparse
+ for (Long64_t j = 0; j < hSRecTrack->GetNbins(); j++) {
+ Int_t tc[4];
+ Double_t tval = hSRecTrack->GetBinContent(j,tc);
+ Double_t terr = hSRecTrack->GetBinError(j);
+ Double_t tzv = hSRecTrack->GetAxis(0)->GetBinCenter(tc[0]);
+ Double_t tpt = hSRecTrack->GetAxis(1)->GetBinCenter(tc[1]);
+ Double_t teta = hSRecTrack->GetAxis(2)->GetBinCenter(tc[2]);
+ Double_t tmultMB = hSRecTrack->GetAxis(3)->GetBinCenter(tc[3]);
+ if (tzv >= 10.0) { tzv = 9.9; }
+ if (teta >= 0.8) {teta = 0.79;}
+ if (tzv < -10.0) { tzv = -10.; }
+ if (teta < -0.8) { teta = -0.8; }
+ if (tpt >= 50.) { tpt = 49.5; } // above 50 GeV corr matr have low statistics
+ if (tpt < 0.15) { tpt = 0.175; } // also below 0.15
+ Double_t xvals[3];
+ xvals[0] = tzv;
+ xvals[1] = tpt;
+ xvals[2] = teta;
+ Double_t effCorr = hSTrackCorr->GetBinContent(hSTrackCorr->GetBin(xvals,kFALSE));
+ Double_t effCorrErr = hSTrackCorr->GetBinError(hSTrackCorr->GetBin(xvals,kFALSE));
+ Double_t secCorr = hSSecCont->GetBinContent(hSSecCont->GetBin(xvals,kFALSE));
+ Double_t secCorrErr = hSSecCont->GetBinError(hSSecCont->GetBin(xvals,kFALSE));
+// Double_t effCorr = h3TrackCorr->GetBinContent(h3TrackCorr->FindBin(tzv,tpt,teta));
+// Double_t effCorrErr = h3TrackCorr->GetBinError(h3TrackCorr->FindBin(tzv,tpt,teta));
+// Double_t secCorr = 1. - h3SecCont->GetBinContent(h3SecCont->FindBin(tzv,tpt,teta));
+// Double_t secCorrErr = h3SecCont->GetBinError(h3SecCont->FindBin(tzv,tpt,teta));
+ if (effCorr < 1.) { cout << "bin empty, use efficiency 1!" << endl; effCorr=1.; }
+ if (secCorr < 0.001) { cout << "bin empty, use contamination 0!" << endl; }
+ if (effCorrErr < 1e-9) { cout << "eff error empty!" << endl; }
+ if (secCorrErr < 1e-9) { cout << "cont error empty!" << endl;}
+ Double_t corr = corrTrackMatch * effCorr*(1.-secCorr);
+ //Double_t corrErr = corrTrackMatch * TMath::Sqrt(effCorr*secCorrErr + secCorr*effCorrErr);
+ Double_t ctval = tval*corr;
+ Double_t cterr = terr*corr; // errors are not correlated
+ //Double_t cterr = TMath::Sqrt(tval*tval*corrErr*corrErr + terr*terr*corr*corr); // errors are not correlated
+ hSRecTrack->SetBinContent(j,ctval);
+ hSRecTrack->SetBinError(j,cterr);
+ }
+
+ TH1D* effCorrPt = hSRecTrack->Projection(1)->Clone("effCorrPt");
+ TH1D* effCorrPtErr2 = hSRecTrack->Projection(1)->Clone("effCorrPtErr2");
+ TH1D* effCorrPtNorm = hSRecTrack->Projection(1)->Clone("effCorrPtNorm");
+ effCorrPt->Reset();
+ effCorrPtErr2->Reset();
+// effCorrPtNorm->Reset();
+ /*
+for (Long64_t j = 0; j < hSRecTrackAllMult->GetNbins(); j++) {
+ Int_t tc[3];
+ Double_t tval = hSRecTrackAllMult->GetBinContent(j,tc);
+ Double_t tzv = hSRecTrackAllMult->GetAxis(0)->GetBinCenter(tc[0]);
+ Double_t tpt = hSRecTrackAllMult->GetAxis(1)->GetBinCenter(tc[1]);
+ Double_t teta = hSRecTrackAllMult->GetAxis(2)->GetBinCenter(tc[2]);
+ if (tpt >= 50.) { tpt = 49.5; } // above 50 GeV corr matr have low statistics
+ Double_t effCorr = h3TrackCorr->GetBinContent(h3TrackCorr->FindBin(tzv,tpt,teta));
+ Double_t effCorrErr = h3TrackCorr->GetBinError(h3TrackCorr->FindBin(tzv,tpt,teta));
+ Double_t secCorr = 1. - h3SecCont->GetBinContent(h3SecCont->FindBin(tzv,tpt,teta));
+ Double_t secCorrErr = h3SecCont->GetBinError(h3SecCont->FindBin(tzv,tpt,teta));
+ if (effCorr < 0.1) { cout << "bin empty, use efficiency 1!" << endl; effCorr=1.; effCorrErr=0.; }
+ if (secCorr < 0.1) { cout << "bin empty, use contamination 0!" << endl; secCorr=1.; secCorrErr=0.; }
+ Double_t corr = effCorr*secCorr;
+ Double_t corrErr = effCorr*secCorrErr + secCorr*effCorrErr; // errors are correlated
+ effCorrPt->Fill(tpt,tval*corr);
+ effCorrPtErr2->Fill(tpt,tval*tval*corrErr*corrErr);
+ effCorrPtNorm->Fill(tpt,tval);
+ }
+
+ effCorrPt->Divide(effCorrPtNorm);
+ for (Int_t i = 4; i <= effCorrPtErr2->GetNbinsX(); i++) { effCorrPtErr2->SetBinContent(i,TMath::Sqrt(effCorrPtErr2->GetBinContent(i))); }
+ effCorrPtErr2->Divide(effCorrPtNorm);
+ cout << effCorrPt->GetBinContent(4) << endl;
+ cout << effCorrPtErr2->GetBinContent(4) << endl;
+ cout << effCorrPtNorm->GetBinContent(4) << endl;
+
+
+
+ TH1D* RecTrackPtCorrected = hSRecTrack->Projection(1)->Clone("RecTrackPtCorrected");
+ RecTrackPtCorrected->Reset();
+
+
+ for (Int_t i = 4; i <= RecTrackPtCorrected->GetNbinsX(); i++) {
+ if (0 == effCorrPtErr2->GetBinContent(i)) continue;
+ Double_t val = effCorrPt->GetBinContent(i);
+ cout << (val*val/effCorrPtNorm->GetBinContent(i)) << " " << effCorrPtErr2->GetBinContent(i) << endl;
+ Double_t err2 = (val*val/effCorrPtNorm->GetBinContent(i)) + effCorrPtErr2->GetBinContent(i);
+ RecTrackPtCorrected->SetBinContent(i,val);
+ RecTrackPtCorrected->SetBinError(i,TMath::Sqrt(err2));
+ }
+ */
+
+for (Long64_t j = 0; j < hSRecTrackAllMult->GetNbins(); j++) {
+ Int_t tc[3];
+ Double_t tval = hSRecTrackAllMult->GetBinContent(j,tc);
+ Double_t terr = TMath::Sqrt(tval); //hSRecTrackAllMult->GetBinError(j);
+ Double_t tzv = hSRecTrackAllMult->GetAxis(0)->GetBinCenter(tc[0]);
+ Double_t tpt = hSRecTrackAllMult->GetAxis(1)->GetBinCenter(tc[1]);
+ Double_t teta = hSRecTrackAllMult->GetAxis(2)->GetBinCenter(tc[2]);
+ Double_t tmultMB = hSRecTrack->GetAxis(3)->GetBinCenter(tc[3]);
+ if (tzv >= 10.0) { tzv = 9.9; }
+ if (teta >= 0.8) {teta = 0.79;}
+ if (tzv < -10.0) { tzv = -10.; }
+ if (teta < -0.8) { teta = -0.8; }
+ if (tpt >= 50.) { tpt = 49.5; } // above 50 GeV corr matr have low statistics
+ if (tpt < 0.15) { tpt = 0.175; } // also below 0.15
+ Double_t xvals[3];
+ xvals[0] = tzv;
+ xvals[1] = tpt;
+ xvals[2] = teta;
+ Double_t effCorr = hSTrackCorr->GetBinContent(hSTrackCorr->GetBin(xvals,kFALSE));
+ Double_t effCorrErr = hSTrackCorr->GetBinError(hSTrackCorr->GetBin(xvals,kFALSE));
+ Double_t secCont = hSSecCont->GetBinContent(hSSecCont->GetBin(xvals,kFALSE));
+ Double_t secContErr = hSSecCont->GetBinError(hSSecCont->GetBin(xvals,kFALSE));
+// Double_t effCorr = h3TrackCorr->GetBinContent(h3TrackCorr->FindBin(tzv,tpt,teta));
+// Double_t effCorrErr = h3TrackCorr->GetBinError(h3TrackCorr->FindBin(tzv,tpt,teta));
+// Double_t secCorr = 1. - h3SecCont->GetBinContent(h3SecCont->FindBin(tzv,tpt,teta));
+// Double_t secCorrErr = h3SecCont->GetBinError(h3SecCont->FindBin(tzv,tpt,teta));
+ if (effCorr < 1.) { cout << "bin empty, use efficiency 1!" << endl; effCorr=1.; }
+ if (secCont < 0.001) { cout << "bin empty, use contamination 0!" << endl; }
+ if (effCorrErr < 1e-9) { cout << "eff error empty!" << endl; }
+ if (secContErr < 1e-9) { cout << "cont error empty!" << endl;}
+ Double_t secCorr = (1.-secCont);
+ Double_t corr = corrTrackMatch * (effCorr*secCorr);
+ Double_t corrErr = corrTrackMatch * TMath::Sqrt(effCorr*secCorrErr + secCorr*effCorrErr);
+ Double_t ctval = tval*corr;
+ Double_t cterr = terr*corr; // errors are not correlated
+ //Double_t cterr = TMath::Sqrt(tval*tval*corrErr*corrErr + terr*terr*corr*corr); // errors are not correlated
+ hSRecTrackAllMult->SetBinContent(j,ctval);
+ hSRecTrackAllMult->SetBinError(j,cterr);
+ }
+
+ // create final spectrum in multiplicity bins
+ TH2D* dNdPtMult = hSRecTrack->Projection(3,1)->Clone("dNdPtMult");
+
+ // create final spectra (as clone of corrected data)
+ TH1D* dNdPt = hSRecTrackAllMult->Projection(1)->Clone("dNdPt");
+/*
+ // errors on pt spectrum from corrections
+ for (int i=1; i <= dNdPt->GetNbinsX() ; i++) {
+ Double_t pt = dNdPt->GetBinCenter(i);
+ Double_t val = dNdPt->GetBinContent(i);
+ Double_t err = dNdPt->GetBinError(i);
+ if (pt >= 50) { pt = 49.5; } // above 50 GeV corr matr have low statistics
+ Double_t secCorr = h1SecCorr_pt->GetBinContent(h1SecCorr_pt->FindBin(pt));
+ Double_t secCorrErr = h1SecCorr_pt->GetBinError(h1SecCorr_pt->FindBin(pt));
+ Double_t effCorr = h1TrackCorr_pt->GetBinContent(h1TrackCorr_pt->FindBin(pt));
+ Double_t effCorrErr = h1TrackCorr_pt->GetBinError(h1TrackCorr_pt->FindBin(pt));
+ Double_t corr = effCorr*secCorr;
+ Double_t corrErr = effCorr*secCorrErr + secCorr*effCorrErr; // errors are correlated
+ Double_t cval = val*secCorr;
+ Double_t cerr = TMath::Sqrt(val*val*corrErr*corrErr + err*err*corr*corr);
+ dNdPt->SetBinError(i,cerr);
+ }
+
+ // errors on pt spectrum from corrections
+ for (int i=1; i <= dNdPtMult->GetNbinsX() ; i++) {
+ for (int k=1; k <= dNdPtMult->GetNbinsY() ; k++) {
+ Double_t pt = dNdPt->GetBinCenter(i);
+ Double_t val = dNdPtMult->GetBinContent(i,k);
+ Double_t err = dNdPtMult->GetBinError(i,k);
+ if (pt >= 50) { pt = 49.5; } // above 50 GeV corr matr have low statistics
+ Double_t secCorr = h1SecCorr_pt->GetBinContent(h1SecCorr_pt->FindBin(pt));
+ Double_t secCorrErr = h1SecCorr_pt->GetBinError(h1SecCorr_pt->FindBin(pt));
+ Double_t effCorr = h1TrackCorr_pt->GetBinContent(h1TrackCorr_pt->FindBin(pt));
+ Double_t effCorrErr = h1TrackCorr_pt->GetBinError(h1TrackCorr_pt->FindBin(pt));
+ Double_t corr = effCorr*secCorr;
+ Double_t corrErr = effCorr*secCorrErr + secCorr*effCorrErr; // errors are correlated
+ Double_t cval = val*secCorr;
+ Double_t cerr = TMath::Sqrt(val*val*corrErr*corrErr + err*err*corr*corr);
+ dNdPtMult->SetBinError(i,k,cerr);
+ }
+ }
+*/
+
+ // for eta the correction is simpler because of same binning
+ h1Corrected_eta->Multiply(h1SecCorr_eta);
+ h1Corrected_eta->Multiply(h1TrackCorr_eta);
+
+ Hists->Add(h1Corrected_pt);
+ Hists->Add(h1Corrected_eta);
+
+
+ TH1D* dNdPt_simple = (TH1D*) h1Corrected_pt->Clone("dNdPt_simple");
+ TH1D* dNdPt_simple_nores = (TH1D*) h1Corrected_pt->Clone("dNdPt_simple_nores");
+
+
+ TH1D* dNdEta = hSRecTrackAllMult->Projection(2)->Clone("dNdEta");
+ TH1D* dNdEta_simple = h1Corrected_eta->Clone("dNdEta_simple");
+
+ // also uncorrected spectra (as clone of raw data)
+ TH1D* dNdPt_raw = (TH1D*) h1RecTrackHist2_pt->Clone("dNdPt_raw");
+ TH1D* dNdEta_raw = (TH1D*) h1RecTrackHist2_eta->Clone("dNdEta_raw");
+
+ // also uncorrected spectra (as clone of raw data)
+ TH1D* dNdPt_nores = (TH1D*) dNdPt->Clone("dNdPt_nores");
+ //TH1D* dNdEta_nores = h1Corrected_eta->Clone("dNdEta_nores");
+
+
+
+//TF1 *fperi = new TF1("fperi","1.00343-0.000608425*x-6.7038e-05*x*x",5.,50.);
+//TF1 *fcent = new TF1("cent","1.01074e+00-1.98127e-03*x-1.19903e-04*x*x",5.,50.);
+TFile* fptcorr = TFile::Open("ptcorr_140511.root");
+
+TF1 *fun = 0;
+TString id = TString(idstring);
+if ( fname.Contains("900GeV") ) {
+ TF1 *fun = (TF1*) fptcorr->Get("ptcorr_900");
+ cout << "++++++++++++++++++++++++++++++++++++++" << endl;
+ cout << "900GeV pt-resolution correction used!" << endl;
+ cout << "++++++++++++++++++++++++++++++++++++++" << endl;
+} elseif ( fname.Contains("2.76TeV") ) {
+ TF1 *fun = (TF1*) fptcorr->Get("ptcorr_2760");
+ cout << "+++++++++++++++++++++++++++++++++++++++++" << endl;
+ cout << "2.76TeV pt-resolution correction used!" << endl;
+ cout << "+++++++++++++++++++++++++++++++++++++++++" << endl;
+} elseif ( fname.Contains("7TeV") ) {
+ TF1 *fun = (TF1*) fptcorr->Get("ptcorr_7000");
+ cout << "+++++++++++++++++++++++++++++++++++++++++" << endl;
+ cout << "7TeV pt-resolution correction used!" << endl;
+ cout << "+++++++++++++++++++++++++++++++++++++++++" << endl;
+} else {
+ fun = TF1("none","1.",10.,50.);
+ cout << "++++++++++++++++++++++++++++++++++++++++" << endl;
+ cout << "ERROR! NO pt-resolution correction used!" << endl;
+ cout << "++++++++++++++++++++++++++++++++++++++++" << endl;
+}
+
+ // normalization and finalization
+ // 1/N_evt 1/(2 pi pt) 1/width 1/etarange
+ for (int i=1; i <= dNdPt->GetNbinsX() ;i++) {
+ Double_t pt = dNdPt->GetBinCenter(i);
+ Double_t width = dNdPt->GetBinWidth(i);
+ Double_t val = dNdPt->GetBinContent(i);
+ Double_t err = dNdPt->GetBinError(i);
+ Double_t corrPtResol = 1.0;
+ corrPtResol = fun->Eval(pt);
+ if (pt < 10.) { corrPtResol = 1.0; }
+ if (corrPtResol > 1.0 ) { corrPtResol = 1.0; }
+ Double_t cval = (val * corrPtResol)/(width * 2.0 * TMath::Pi() * 1.6 * InelasticEvents * pt);
+ Double_t cerr = (err * corrPtResol)/(width * 2.0 * TMath::Pi() * 1.6 * InelasticEvents * pt);
+// Double_t cval = (val * corrPtResol)/(width * 2.0 * TMath::Pi() * 1.6 * ReconstructedEvents * CorrEvent* pt);
+// Double_t cerr = (err * corrPtResol)/(width * 2.0 * TMath::Pi() * 1.6 * ReconstructedEvents * CorrEvent* pt);
+ dNdPt->SetBinContent(i,cval);
+ dNdPt->SetBinError(i,cerr);
+ }
+
+ // normalization and finalization without resolution correction
+ // 1/N_evt 1/(2 pi pt) 1/width 1/etarange
+ for (int i=1; i <= dNdPt_nores->GetNbinsX() ;i++) {
+ Double_t pt = dNdPt_nores->GetBinCenter(i);
+ Double_t width = dNdPt_nores->GetBinWidth(i);
+ Double_t val = dNdPt_nores->GetBinContent(i);
+ Double_t err = dNdPt_nores->GetBinError(i);
+ Double_t cval = (val)/(width * 2.0 * TMath::Pi() * 1.6 * InelasticEvents * pt);
+ Double_t cerr = (err)/(width * 2.0 * TMath::Pi() * 1.6 * InelasticEvents * pt);
+ dNdPt_nores->SetBinContent(i,cval);
+ dNdPt_nores->SetBinError(i,cerr);
+ }
+
+ // normalization and finalization without resolution correction
+ // 1/N_evt 1/(2 pi pt) 1/width 1/etarange
+ for (int i=1; i <= dNdPt_simple_nores->GetNbinsX() ;i++) {
+ Double_t pt = dNdPt_simple_nores->GetBinCenter(i);
+ Double_t width = dNdPt_simple_nores->GetBinWidth(i);
+ Double_t val = dNdPt_simple_nores->GetBinContent(i);
+ Double_t err = dNdPt_simple_nores->GetBinError(i);
+ Double_t cval = (val)/(width * 2.0 * TMath::Pi() * 1.6 * InelasticEvents * pt);
+ Double_t cerr = (err)/(width * 2.0 * TMath::Pi() * 1.6 * InelasticEvents * pt);
+ dNdPt_simple_nores->SetBinContent(i,cval);
+ dNdPt_simple_nores->SetBinError(i,cerr);
+ }
+
+ // for dndeta again simpler
+ dNdEta->Scale(1,"width");
+ dNdEta->Scale(1./InelasticEvents);
+ dNdEta_simple->Scale(1,"width");
+ dNdEta_simple->Scale(1./InelasticEvents);
+
+
+ // normalization and finalization
+ // 1/N_evt 1/(2 pi pt) 1/width 1/etarange
+ for (int i=1; i <= dNdPt_simple->GetNbinsX() ;i++) {
+ Double_t pt = dNdPt_simple->GetBinCenter(i);
+ Double_t width = dNdPt_simple->GetBinWidth(i);
+ Double_t val = dNdPt_simple->GetBinContent(i);
+ Double_t err = dNdPt_simple->GetBinError(i);
+ Double_t corrPtResol = 1.0;
+ corrPtResol = fun->Eval(pt);
+ if (pt < 10.) { corrPtResol = 1.0; }
+ if (corrPtResol > 1.0 ) { corrPtResol = 1.0; }
+ Double_t cval = (val * corrPtResol)/(width * 2.0 * TMath::Pi() * 1.6 * InelasticEvents * pt);
+ Double_t cerr = (err * corrPtResol)/(width * 2.0 * TMath::Pi() * 1.6 * InelasticEvents * pt);
+ dNdPt_simple->SetBinContent(i,cval);
+ dNdPt_simple->SetBinError(i,cerr);
+ }
+ /*
+ TH1D* dNdPt2 = (TH1D*) dNdPt->Clone("dNdPt2");
+ TH1D* dNdPt2_simple = (TH1D*) dNdPt_simple->Clone("dNdPt2_simple");
+ dNdPt2->Scale(InelasticEvents / (ReconstructedEvents * CorrEvent));
+ dNdPt2_simple->Scale(InelasticEvents / (ReconstructedEvents * CorrEvent));
+ Hists->Add(dNdPt2);
+ Hists->Add(dNdPt2_simple);
+ */
+
+ // normalization and finalization
+ // 1/N_evt 1/(2 pi pt) 1/width 1/etarange
+ for (int i=1; i <= dNdPt_raw->GetNbinsX() ;i++) {
+ Double_t pt = dNdPt_raw->GetBinCenter(i);
+ Double_t width = dNdPt_raw->GetBinWidth(i);
+ Double_t val = dNdPt_raw->GetBinContent(i);
+ Double_t err = dNdPt_raw->GetBinError(i);
+ Double_t cval = val/(width * 2.0 * TMath::Pi() * 1.6 * InelasticEvents * pt);
+ Double_t cerr = err/(width * 2.0 * TMath::Pi() * 1.6 * InelasticEvents * pt);
+ dNdPt_raw->SetBinContent(i,cval);
+ dNdPt_raw->SetBinError(i,cerr);
+ }
+ // for dndeta again simpler
+ dNdEta_raw->Scale(1,"width");
+ dNdEta_raw->Scale(1./InelasticEvents);
+
+ dNdEta->SetMarkerStyle(21);
+ dNdPt->SetMarkerStyle(21);
+ dNdPt->SetTitle("; p_{T} (GeV/c) ; 1/N_{evt} 1/(2#pi p_{T}) (d^{2}N_{ch})/(d#eta dp_{T})^{-2}");
+ dNdEta->SetTitle("; #eta ; 1/N_{evt} (d^{2}N_{ch})/(d#eta)");
+
+ dNdPt_raw->SetTitle("; p_{T} (GeV/c) ; 1/N_{evt} 1/(2#pi p_{T}) (d^{2}N_{ch})/(d#eta dp_{T})^{-2}");
+ dNdPt_nores->SetTitle("; p_{T} (GeV/c) ; 1/N_{evt} 1/(2#pi p_{T}) (d^{2}N_{ch})/(d#eta dp_{T})^{-2}");
+ dNdEta_raw->SetTitle("; #eta ; 1/N_{evt} (d^{2}N_{ch})/(d#eta)");
+
+ Hists->Add(dNdEta_raw);
+ Hists->Add(dNdPt_raw);
+ Hists->Add(dNdEta);
+ Hists->Add(dNdEta_simple);
+ Hists->Add(dNdPt);
+ Hists->Add(dNdPt_nores);
+ Hists->Add(dNdPt_simple);
+ Hists->Add(dNdPt_simple_nores);
+ Hists->Add(hSRecTrack);
+ Hists->Add(hSRecTrackAllMult);
+
+
+ // plot pictures and save to gifdir
+ for (i=0; i < Hists->LastIndex(); i++) {
+ TCanvas* ctmp = PlotHist(Hists->At(i),idstring);
+ if (gifdir && ctmp) {
+ TString gif(gifdir);
+ gif += '/';
+ gif += ctmp->GetName();
+ gif += ".gif";
+ ctmp->SaveAs(gif.Data(),"gif");
+ delete ctmp;
+ }
+ }
+
+ // save all correction matrices and control histograms to file
+ if (!outfile) { return; }
+ TFile *out = TFile::Open(outfile,"RECREATE");
+ Hists->Write();
+ out->Close();
+
+ return ReconstructedEvents;
+
+}
+
+//___________________________________________________________________________
+TCanvas* PlotHist(TObject* hobj, const char* label=0)
+{
+ TH1* h = dynamic_cast<TH1*>(hobj);
+ if (!h) return 0;
+ if (h->GetDimension() > 2) return 0;
+ h->SetStats(0);
+ if ( TString(h->GetName()).Contains("Events")) { h->SetStats(1); }
+ TString t(label);
+ if (label) t += "_";
+ t += h->GetName();
+ h->SetTitle(t.Data());
+ TCanvas* c = new TCanvas(t.Data(),t.Data());
+ if (h->GetDimension() >= 1) {
+ TString xlabel(h->GetXaxis()->GetTitle());
+ if (xlabel.Contains("Pt")) { c->SetLogx(); c->SetLogy(); h->GetXaxis()->SetRangeUser(0.1 , 100.); }
+ if (xlabel.Contains("p_{T}")) { c->SetLogx(); c->SetLogy(); h->GetXaxis()->SetRangeUser(0.1 , 100.); }
+ }
+ if (h->GetDimension() == 2) {
+ TString ylabel(h->GetYaxis()->GetTitle());
+ if (ylabel.Contains("Pt")) { c->SetLogy(); h->GetYaxis()->SetRangeUser(0.1 , 100.); }
+ if (ylabel.Contains("p_{T}")) { c->SetLogy(); h->GetYaxis()->SetRangeUser(0.1 , 100.); }
+ h->Draw("COLZ");
+ }
+ if (h->GetDimension() == 1) {
+ h->Draw();
+ }
+ return c;
+
+}
--- /dev/null
+&
+Double_t GenerateCorrMatr_PbPb(const char* mcfile, const char* mctask, const char* idstring ,const char* outfile, const char* gifdir = 0)
+//Double_t GenerateCorrMatr_PbPb_TPCIT()
+{
+
+Int_t c_first = 1;
+Int_t c_last = 11;
+
+TString id = TString(idstring);
+if ( id.Contains("c0-5") ) { c_first = c_last = 1; }
+if ( id.Contains("c5-10") ) { c_first = c_last = 2; }
+if ( id.Contains("c10-20") ) { c_first = c_last = 3; }
+if ( id.Contains("c20-30") ) { c_first = c_last = 4; }
+if ( id.Contains("c30-40") ) { c_first = c_last = 5; }
+if ( id.Contains("c40-50") ) { c_first = c_last = 6; }
+if ( id.Contains("c50-60") ) { c_first = c_last = 7; }
+if ( id.Contains("c60-70") ) { c_first = c_last = 8; }
+if ( id.Contains("c70-80") ) { c_first = c_last = 9; }
+if ( id.Contains("c80-90") ) { c_first = c_last = 10; }
+if ( id.Contains("c90-100") ) { c_first = c_last = 11; }
+
+//tmp setting
+ //const char* mcfile = "/lustre/alice/train/V006.MC_PbPb/2011-03-15_0037.5917/mergedPeriods/MC_PbPb/2.76ATeV/LHC10h8/mknichel_dNdPtPbPb_TPCITS_VZERO1.root";
+
+ //const char* mcfile = "/lustre/alice/train/V006.MC_PbPb/2011-03-13_0236.5847/mergedRuns/MC_PbPb/2.76ATeV/LHC11a7/137161.ana/mknichel_dNdPtPbPb_TPCITS_VZERO1.root";
+ //const char* mctask = "mknichel_dNdPtPbPb_TPCITS_VZERO";
+ //const char* idstring = "c70";
+ //const char* outfile = "/u/mknichel/alice/dNdPt_PbPb/2011-03-15/corrMatr_LHC10h8_TPCITS_c70.root";
+ //const char* gifdir ="/u/mknichel/alice/dNdPt_PbPb/2011-03-15/LHC10h8";
+
+ // settings vor zVertex cut (event and track level)
+ Double_t zVert = 10.0;
+
+ // setting on eta cut (track level)
+ Double_t eta = 0.8;
+
+ // strangeness scaling factor (for secondaries from strange decays)
+ Double_t sscale = 2.0;
+
+ //load required libraries
+ //load required libraries
+ gSystem->AddIncludePath("-I$ROOTSYS/include -I$ALICE_ROOT/ -I$ALICE_ROOT/include -I$ALICE_ROOT/STEER -I$ALICE_ROOT/ANALYSIS -I$ALICE_ROOT/PWG0 -I$ALICE_ROOT/PWG1 -I$ALICE_ROOT/PWG2 -I$ALICE_ROOT/PWG3 -I$ALICE_ROOT/PWG3/vertexingHF -I$ALICE_ROOT/PWG4 -I$ALICE_ROOT/CORRFW -I$ALICE_ROOT/TPC -I$ALICE_ROOT/TRD -I$ALICE_ROOT/PWG3/muon -I$ALICE_ROOT/JETAN -I$ALICE_ROOT/ANALYSIS/Tender");
+
+ gSystem->Load("libCore");
+ gSystem->Load("libPhysics");
+ gSystem->Load("libMinuit");
+ gSystem->Load("libGui");
+ gSystem->Load("libXMLParser");
+
+ gSystem->Load("libGeom");
+ gSystem->Load("libVMC");
+
+ gSystem->Load("libNet");
+
+
+ gSystem->Load("libSTEERBase");
+ gSystem->Load("libESD");
+ gSystem->Load("libCDB");
+ gSystem->Load("libRAWDatabase");
+ gSystem->Load("libRAWDatarec");
+ gSystem->Load("libANALYSIS");
+
+
+
+ gSystem->Load("libANALYSIS.so");
+ gSystem->Load("libANALYSISalice.so");
+ gSystem->Load("libTENDER.so");
+ gSystem->Load("libCORRFW.so");
+ gSystem->Load("libPWG0base.so");
+ gSystem->Load("libPWG0dep");
+ gSystem->Load("libPWG0selectors.so");
+
+
+
+
+
+ // make plots nicer
+ gROOT->SetStyle("Plain");
+ gStyle->SetPalette(1);
+
+ // array for all correction matrices
+ TObjArray* CorrMatr = new TObjArray();
+
+ // array for all control histograms
+ TObjArray* ContHist = new TObjArray();
+
+
+ // load mc information
+ TFile* fmc = TFile::Open(mcfile,"READ");
+ if (!fmc) return -1;
+ TList* lmc = dynamic_cast<TList*>(fmc->Get(mctask));
+ if (!lmc) return -1;
+ AlidNdPtAnalysisPbPb *obj = dynamic_cast<AlidNdPtAnalysisPbPb*>(lmc->FindObject("dNdPtAnalysisPbPb"));
+ if (!obj) return -1;
+
+//
+// create rebinned thnsparse
+//
+ //ptbins before rebinning: 73;
+ const Int_t etaNbins = 30;
+ const Int_t zvNbins = 12;
+ const Int_t centralityBins = 11;
+
+ //Double_t binsMult[multNbins+1] = {-0.5, 10000.5 }; // forPbPb --reduced!
+
+ // Set pt binning for corrections
+ const Int_t ptNbins = 30;
+ Double_t binsPt[31] = {0.0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1.0, 1.1, 1.2, 1.4, 1.6, 1.8, 2.0, 3.0, 4.0, 50.0, 100.0 };
+
+ Double_t binsEta[etaNbins+1] = {
+ -1.5, -1.4, -1.3, -1.2, -1.1, -1.0, -0.9, -0.8, -0.7, -0.6,
+ -0.5, -0.4, -0.3, -0.2, -0.1, 0.0, 0.1, 0.2, 0.3, 0.4,
+ 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4,
+ 1.5};
+
+ Double_t binsZv[zvNbins+1] = {-30.,-25.,-20.,-15.,-10.,-5.,0.,5.,10.,15.,20.,25.,30.};
+
+ Double_t binsCentrality[centralityBins+1] = {0., 5., 10., 20., 30., 40., 50., 60., 70., 80., 90., 100.};
+
+ Int_t binsTrackEventCorrMatrix[4]={zvNbins,ptNbins,etaNbins,centralityBins};
+ //Int_t binsTrackEvent[4]={zvNbins,ptNbins,etaNbins,centralityBins};
+ //Int_t binsTrackPtCorrelationMatrix[4]={ptNbins,ptNbins,etaNbins,centralityBins};
+/*
+ THnSparseF* fGenPrimTrackMatrix = new THnSparseF("fGenPrimTrackMatrix","mcZv:mcPt:mcEta:Centrality",4,binsTrackEventCorrMatrix);
+ fGenPrimTrackMatrix->SetBinEdges(0,binsZv);
+ fGenPrimTrackMatrix->SetBinEdges(1,binsPt);
+ fGenPrimTrackMatrix->SetBinEdges(2,binsEta);
+ fGenPrimTrackMatrix->SetBinEdges(3,binsCentrality);
+ fGenPrimTrackMatrix->GetAxis(0)->SetTitle("mcZv (cm)");
+ fGenPrimTrackMatrix->GetAxis(1)->SetTitle("mcPt (GeV/c)");
+ fGenPrimTrackMatrix->GetAxis(2)->SetTitle("mcEta");
+ fGenPrimTrackMatrix->GetAxis(3)->SetTitle("Centrality");
+ fGenPrimTrackMatrix->Sumw2();
+
+ THnSparseF* fRecPrimTrackMatrix = new THnSparseF("fRecPrimTrackMatrix","mcZv:mcPt:mcEta:Centrality",4,binsTrackEventCorrMatrix);
+ fRecPrimTrackMatrix->SetBinEdges(0,binsZv);
+ fRecPrimTrackMatrix->SetBinEdges(1,binsPt);
+ fRecPrimTrackMatrix->SetBinEdges(2,binsEta);
+ fRecPrimTrackMatrix->SetBinEdges(3,binsCentrality);
+ fRecPrimTrackMatrix->GetAxis(0)->SetTitle("mcZv (cm)");
+ fRecPrimTrackMatrix->GetAxis(1)->SetTitle("mcPt (GeV/c)");
+ fRecPrimTrackMatrix->GetAxis(2)->SetTitle("mcEta");
+ fRecPrimTrackMatrix->GetAxis(3)->SetTitle("Centrality");
+ fRecPrimTrackMatrix->Sumw2();
+
+ THnSparseF* fRecTrackMatrix = new THnSparseF("fRecTrackMatrix","mcZv:mcPt:mcEta:Centrality",4,binsTrackEventCorrMatrix);
+ fRecTrackMatrix->SetBinEdges(0,binsZv);
+ fRecTrackMatrix->SetBinEdges(1,binsPt);
+ fRecTrackMatrix->SetBinEdges(2,binsEta);
+ fRecTrackMatrix->SetBinEdges(3,binsCentrality);
+ fRecTrackMatrix->GetAxis(0)->SetTitle("mcZv (cm)");
+ fRecTrackMatrix->GetAxis(1)->SetTitle("mcPt (GeV/c)");
+ fRecTrackMatrix->GetAxis(2)->SetTitle("mcEta");
+ fRecTrackMatrix->GetAxis(3)->SetTitle("Centrality");
+ fRecTrackMatrix->Sumw2();
+
+ THnSparseF* fRecSecTrackMatrix = new THnSparseF("fRecSecTrackMatrix","mcZv:mcPt:mcEta:Centrality",4,binsTrackEventCorrMatrix);
+ fRecSecTrackMatrix->SetBinEdges(0,binsZv);
+ fRecSecTrackMatrix->SetBinEdges(1,binsPt);
+ fRecSecTrackMatrix->SetBinEdges(2,binsEta);
+ fRecSecTrackMatrix->SetBinEdges(3,binsCentrality);
+ fRecSecTrackMatrix->GetAxis(0)->SetTitle("mcZv (cm)");
+ fRecSecTrackMatrix->GetAxis(1)->SetTitle("Pt (GeV/c)");
+ fRecSecTrackMatrix->GetAxis(2)->SetTitle("Eta");
+ fRecSecTrackMatrix->GetAxis(3)->SetTitle("Centrality");
+ fRecSecTrackMatrix->Sumw2();
+*/
+
+ //Event statistics
+ THnSparse *fRecEventMatrix = obj->GetRecEventMatrix(); //all reconstructed events
+ fRecEventMatrix->GetAxis(2)->SetRange(c_first,c_last); // select centrality
+ TH2D* h2RecEventAll = fRecEventMatrix->Projection(0,1)->Clone("h2RecEventAll");
+ fRecEventMatrix->GetAxis(0)->SetRangeUser(-zVert, zVert-0.01);//zVer
+ TH2D* h2RecEvent = fRecEventMatrix->Projection(0,1)->Clone("h2RecEvent");
+ Double_t MCReconstructedEvents = h2RecEvent->Integral();
+ Double_t MCReconstructedEventsAll = h2RecEventAll->Integral();
+ ContHist->Add(h2RecEvent);
+ ContHist->Add(h2RecEventAll);
+
+ THnSparse *fTriggerEventMatrix = obj->GetTriggerEventMatrix(); //all triggered events
+ fTriggerEventMatrix->GetAxis(2)->SetRange(c_first,c_last); // select centrality
+ TH2D* h2TriggerEventAll = fTriggerEventMatrix->Projection(0,1)->Clone("h2TriggerEventAll");
+ fTriggerEventMatrix->GetAxis(0)->SetRangeUser(-zVert, zVert-0.01);//zVer
+ TH2D* h2TriggerEvent = fTriggerEventMatrix->Projection(0,1)->Clone("h2TriggerEvent");
+ Double_t MCTriggeredEvents = h2TriggerEvent->Integral();
+ Double_t MCTriggeredEventsAll = h2TriggerEventAll->Integral();
+ ContHist->Add(h2TriggerEvent);
+ ContHist->Add(h2TriggerEventAll);
+
+ THnSparse *fGenEventMatrix = obj->GetGenEventMatrix(); //all generated events
+ fGenEventMatrix->GetAxis(2)->SetRange(c_first,c_last); // select centrality
+ TH2D* h2GenEventAll = fGenEventMatrix->Projection(0,1)->Clone("h2GenEventAll");
+ fGenEventMatrix->GetAxis(0)->SetRangeUser(-zVert, zVert-0.01);//zVer
+ TH2D* h2GenEvent = fGenEventMatrix->Projection(0,1)->Clone("h2GenEvent");
+ Double_t MCGeneratedEvents = h2GenEvent->Integral();
+ Double_t MCGeneratedEventsAll = h2GenEventAll->Integral();
+ ContHist->Add(h2RecEvent);
+ ContHist->Add(h2RecEventAll);
+
+ printf("=== generated MC events for correction matrices %lf ===\n",MCGeneratedEvents);
+ printf("=== triggered MC events for correction matrices %lf ===\n",MCTriggeredEvents);
+ printf("=== recontructed MC events for correction matrices %lf ===\n",MCReconstructedEvents);
+ printf("\n");
+ printf("=== cut on the zVertex +- %lf ===\n",zVert);
+ printf("=== generated MC events (before zVertex cut) %lf ===\n",MCGeneratedEventsAll);
+ printf("=== triggered MC events (before zVertex cut) %lf ===\n",MCTriggeredEventsAll);
+ printf("=== recontructed MC events (before zVertex cut) %lf ===\n",MCReconstructedEventsAll);
+
+ TH1D* h1MCGeneratedEvents = new TH1D("h1MCGeneratedEvents","h1MCGeneratedEvents",1,0,1);
+ TH1D* h1MCTriggeredEvents = new TH1D("h1MCTriggeredEvents","h1MCTriggeredEvents",1,0,1);
+ TH1D* h1MCReconstructedEvents = new TH1D("h1MCReconstructedEvents","h1MCReconstructedEvents",1,0,1);
+ TH1D* h1MCGeneratedEventsAll = new TH1D("h1MCGeneratedEventsAll","h1MCGeneratedEventsAll",1,0,1);
+ TH1D* h1MCTriggeredEventsAll = new TH1D("h1MCTriggeredEventsAll","h1MCTriggeredEventsAll",1,0,1);
+ TH1D* h1MCReconstructedEventsAll = new TH1D("h1MCReconstructedEventsAll","h1MCReconstructedEventsAll",1,0,1);
+
+ h1MCGeneratedEvents->Fill(0,MCGeneratedEvents);
+ h1MCGeneratedEvents->SetEntries(MCGeneratedEvents);
+ h1MCTriggeredEvents->Fill(0,MCTriggeredEvents);
+ h1MCTriggeredEvents->SetEntries(MCTriggeredEvents);
+ h1MCReconstructedEvents->Fill(0,MCReconstructedEvents);
+ h1MCReconstructedEvents->SetEntries(MCReconstructedEvents);
+ h1MCGeneratedEventsAll->Fill(0,MCGeneratedEventsAll);
+ h1MCGeneratedEventsAll->SetEntries(MCGeneratedEventsAll);
+ h1MCTriggeredEventsAll->Fill(0,MCTriggeredEventsAll);
+ h1MCTriggeredEventsAll->SetEntries(MCTriggeredEventsAll);
+ h1MCReconstructedEventsAll->Fill(0,MCReconstructedEventsAll);
+ h1MCReconstructedEventsAll->SetEntries(MCReconstructedEventsAll);
+
+ ContHist->Add(h1MCGeneratedEvents);
+ ContHist->Add(h1MCTriggeredEvents);
+ ContHist->Add(h1MCReconstructedEvents);
+ ContHist->Add(h1MCGeneratedEventsAll);
+ ContHist->Add(h1MCTriggeredEventsAll);
+ ContHist->Add(h1MCReconstructedEventsAll);
+
+
+ // efficienfy and correction matrices for tigger and vertex efficiency
+ TH2D* h2EventTriggerEffAll = AlidNdPtHelper::GenerateCorrMatrix(h2TriggerEventAll,h2GenEventAll,"h2EventTriggerEffAll");
+ TH2D* h2EventTriggerCorrAll = AlidNdPtHelper::GenerateCorrMatrix(h2GenEventAll,h2TriggerEventAll,"h2EventTriggerCorrAll");
+ TH2D* h2EventTriggerEff = AlidNdPtHelper::GenerateCorrMatrix(h2TriggerEvent,h2GenEvent,"h2EventTriggerEff");
+ TH2D* h2EventTriggerCorr = AlidNdPtHelper::GenerateCorrMatrix(h2GenEvent,h2TriggerEvent,"h2EventTriggerCorr");
+
+ TH2D* h2EventRecEffAll = AlidNdPtHelper::GenerateCorrMatrix(h2RecEventAll,h2TriggerEventAll,"h2EventRecEffAll");
+ TH2D* h2EventRecCorrAll = AlidNdPtHelper::GenerateCorrMatrix(h2TriggerEventAll,h2RecEventAll,"h2EventRecCorrAll");
+ TH2D* h2EventRecEff = AlidNdPtHelper::GenerateCorrMatrix(h2RecEvent,h2TriggerEvent,"h2EventRecEff");
+ TH2D* h2EventRecCorr = AlidNdPtHelper::GenerateCorrMatrix(h2TriggerEvent,h2RecEvent,"h2EventRecCorr");
+
+ TH2D* h2EventEffAll = AlidNdPtHelper::GenerateCorrMatrix(h2RecEventAll,h2GenEventAll,"h2EventEffAll");
+ TH2D* h2EventCorrAll = AlidNdPtHelper::GenerateCorrMatrix(h2GenEventAll,h2RecEventAll,"h2EventCorrAll");
+ TH2D* h2EventEff = AlidNdPtHelper::GenerateCorrMatrix(h2RecEvent,h2GenEvent,"h2EventEff");
+ TH2D* h2EventCorr = AlidNdPtHelper::GenerateCorrMatrix(h2GenEvent,h2RecEvent,"h2EventCorr");
+
+ CorrMatr->Add(h2EventTriggerEffAll);
+ CorrMatr->Add(h2EventTriggerCorrAll);
+ CorrMatr->Add(h2EventTriggerEff);
+ CorrMatr->Add(h2EventTriggerCorr);
+ CorrMatr->Add(h2EventRecEffAll);
+ CorrMatr->Add(h2EventRecCorrAll);
+ CorrMatr->Add(h2EventRecEff);
+ CorrMatr->Add(h2EventRecCorr);
+ CorrMatr->Add(h2EventEffAll);
+ CorrMatr->Add(h2EventCorrAll);
+ CorrMatr->Add(h2EventEff);
+ CorrMatr->Add(h2EventCorr);
+
+
+
+ // all recontructed
+ THnSparse *fRecTrackMatrix = obj->GetRecTrackMatrix(); //all reconstructed tracks
+ fRecTrackMatrix->GetAxis(3)->SetRange(c_first,c_last); // select centrality
+ fRecTrackMatrix->GetAxis(0)->SetRangeUser(-zVert, zVert-0.01);//zVer
+ fRecTrackMatrix->GetAxis(2)->SetRangeUser(-eta, eta-0.01);//eta
+
+ TH3D* h3RecTrack = fRecTrackMatrix->Projection(0,1,2)->Clone("h3RecTrack");
+ TH2D* h2RecTrack_zv_pt = fRecTrackMatrix->Projection(0,1)->Clone("h2RecTrack_zv_pt");
+ TH2D* h2RecTrack_zv_eta = fRecTrackMatrix->Projection(0,2)->Clone("h2RecTrack_zv_eta");
+ TH2D* h2RecTrack_pt_eta = fRecTrackMatrix->Projection(1,2)->Clone("h2RecTrack_pt_eta");
+ TH1D* h1RecTrack_zv = fRecTrackMatrix->Projection(0)->Clone("h1RecTrack_zv");
+ TH1D* h1RecTrack_pt = fRecTrackMatrix->Projection(1)->Clone("h1RecTrack_pt");
+ TH1D* h1RecTrack_eta = fRecTrackMatrix->Projection(2)->Clone("h1RecTrack_eta");
+ Double_t MCReconstructedTracks = h3RecTrack->Integral();
+
+ h1RecTrack_pt = (TH1D*) h1RecTrack_pt->Rebin(ptNbins,"",binsPt); // rebin hist
+
+ ContHist->Add(h3RecTrack);
+ ContHist->Add(h2RecTrack_zv_pt);
+ ContHist->Add(h2RecTrack_zv_eta);
+ ContHist->Add(h2RecTrack_pt_eta);
+ ContHist->Add(h1RecTrack_zv);
+ ContHist->Add(h1RecTrack_pt);
+ ContHist->Add(h1RecTrack_eta);
+
+ // recontructed primary tracks
+ THnSparse *fRecPrimTrackMatrix = obj->GetRecPrimTrackMatrix();
+ fRecPrimTrackMatrix->GetAxis(3)->SetRange(c_first,c_last); // select centrality
+ THnSparse *fRecTrackMatrixScaled = fRecPrimTrackMatrix->Clone("fRecTrackMatrixScaled"); //used later for secondaries scaling
+ fRecPrimTrackMatrix->GetAxis(0)->SetRangeUser(-zVert, zVert-0.01);//zVer
+ fRecPrimTrackMatrix->GetAxis(2)->SetRangeUser(-eta, eta-0.01);//eta
+ TH3D* h3RecPrimTrack = fRecPrimTrackMatrix->Projection(0,1,2)->Clone("h3RecPrimTrack");
+ TH2D* h2RecPrimTrack_zv_pt = fRecPrimTrackMatrix->Projection(0,1)->Clone("h2RecPrimTrack_zv_pt");
+ TH2D* h2RecPrimTrack_zv_eta = fRecPrimTrackMatrix->Projection(0,2)->Clone("h2RecPrimTrack_zv_eta");
+ TH2D* h2RecPrimTrack_pt_eta = fRecPrimTrackMatrix->Projection(1,2)->Clone("h2RecPrimTrack_pt_eta");
+ TH1D* h1RecPrimTrack_zv = fRecPrimTrackMatrix->Projection(0)->Clone("h1RecPrimTrack_zv");
+ TH1D* h1RecPrimTrack_pt = fRecPrimTrackMatrix->Projection(1)->Clone("h1RecPrimTrack_pt");
+ TH1D* h1RecPrimTrack_eta = fRecPrimTrackMatrix->Projection(2)->Clone("h1RecPrimTrack_eta");
+ Double_t MCReconstructedPrimTracks = h3RecPrimTrack->Integral();
+
+ h1RecPrimTrack_pt = (TH1D*) h1RecPrimTrack_pt->Rebin(ptNbins,"",binsPt); // rebin hist
+
+ ContHist->Add(h3RecPrimTrack);
+ ContHist->Add(h2RecPrimTrack_zv_pt);
+ ContHist->Add(h2RecPrimTrack_zv_eta);
+ ContHist->Add(h2RecPrimTrack_pt_eta);
+ ContHist->Add(h1RecPrimTrack_zv);
+ ContHist->Add(h1RecPrimTrack_pt);
+ ContHist->Add(h1RecPrimTrack_eta);
+
+ // recontructed secondary tracks
+ THnSparse *fRecSecTrackMatrix = obj->GetRecSecTrackMatrix();
+ fRecSecTrackMatrix->GetAxis(3)->SetRange(c_first,c_last); // select centrality
+ THnSparse *fRecSecTrackMatrixScaled = fRecSecTrackMatrix->Clone("fRecSecTrackMatrixScaled"); //used later for secondaries scaling
+ fRecSecTrackMatrix->GetAxis(0)->SetRangeUser(-zVert, zVert-0.01);//zVer
+ fRecSecTrackMatrix->GetAxis(2)->SetRangeUser(-eta, eta-0.01);//eta
+ TH3D* h3RecSecTrack = fRecSecTrackMatrix->Projection(0,1,2)->Clone("h3RecSecTrack");
+ TH2D* h2RecSecTrack_zv_pt = fRecSecTrackMatrix->Projection(0,1)->Clone("h2RecSecTrack_zv_pt");
+ TH2D* h2RecSecTrack_zv_eta = fRecSecTrackMatrix->Projection(0,2)->Clone("h2RecSecTrack_zv_eta");
+ TH2D* h2RecSecTrack_pt_eta = fRecSecTrackMatrix->Projection(1,2)->Clone("h2RecSecTrack_pt_eta");
+ TH1D* h1RecSecTrack_zv = fRecSecTrackMatrix->Projection(0)->Clone("h1RecSecTrack_zv");
+ TH1D* h1RecSecTrack_pt = fRecSecTrackMatrix->Projection(1)->Clone("h1RecSecTrack_pt");
+ TH1D* h1RecSecTrack_eta = fRecSecTrackMatrix->Projection(2)->Clone("h1RecSecTrack_eta");
+ Double_t MCReconstructedSecTracks = h3RecSecTrack->Integral();
+
+ h1RecSecTrack_pt = (TH1D*) h1RecSecTrack_pt->Rebin(ptNbins,"",binsPt); // rebin hist
+
+ ContHist->Add(h3RecSecTrack);
+ ContHist->Add(h2RecSecTrack_zv_pt);
+ ContHist->Add(h2RecSecTrack_zv_eta);
+ ContHist->Add(h2RecSecTrack_pt_eta);
+ ContHist->Add(h1RecSecTrack_zv);
+ ContHist->Add(h1RecSecTrack_pt);
+ ContHist->Add(h1RecSecTrack_eta);
+
+ // generated primary tracks
+ THnSparse *fGenPrimTrackMatrix =obj->GetGenPrimTrackMatrix();
+ fGenPrimTrackMatrix->GetAxis(3)->SetRange(c_first,c_last); // select centrality
+ fGenPrimTrackMatrix->GetAxis(0)->SetRangeUser(-zVert, zVert-0.01);//zVer
+ fGenPrimTrackMatrix->GetAxis(2)->SetRangeUser(-eta, eta-0.01);//eta
+ TH3D* h3GenPrimTrack = fGenPrimTrackMatrix->Projection(0,1,2)->Clone("h3GenPrimTrack");
+ TH2D* h2GenPrimTrack_zv_Pt = fGenPrimTrackMatrix->Projection(0,1)->Clone("h2GenPrimTrack_zv_pt");
+ TH2D* h2GenPrimTrack_zv_eta = fGenPrimTrackMatrix->Projection(0,2)->Clone("h2GenPrimTrack_zv_eta");
+ TH2D* h2GenPrimTrack_pt_eta = fGenPrimTrackMatrix->Projection(1,2)->Clone("h2GenPrimTrack_pt_eta");
+ TH1D* h1GenPrimTrack_zv = fGenPrimTrackMatrix->Projection(0)->Clone("h1GenPrimTrack_zv");
+ TH1D* h1GenPrimTrack_pt = fGenPrimTrackMatrix->Projection(1)->Clone("h1GenPrimTrack_pt");
+ TH1D* h1GenPrimTrack_eta = fGenPrimTrackMatrix->Projection(2)->Clone("h1GenPrimTrack_eta");
+ Double_t MCGeneratedPrimTracks = h3GenPrimTrack->Integral();
+
+
+ // mc truth histogram (for self-consistency check)
+ TH1D* dNdPt_MC = h1GenPrimTrack_pt->Clone("dNdPt_MC");
+ // normalization and finalization
+ // 1/N_evt 1/(2 pi pt) 1/width 1/etarange
+ for (int ii=1; ii <= dNdPt_MC->GetNbinsX() ;ii++) {
+ Double_t pt = dNdPt_MC->GetBinCenter(ii);
+ Double_t width = dNdPt_MC->GetBinWidth(ii);
+ Double_t val = dNdPt_MC->GetBinContent(ii);
+ Double_t err = dNdPt_MC->GetBinError(ii);
+ Double_t cval = (val)/(width * 2.0 * TMath::Pi() * 1.6 * MCGeneratedEvents * pt);
+ Double_t cerr = (err)/(width * 2.0 * TMath::Pi() * 1.6 * MCGeneratedEvents * pt);
+ dNdPt_MC->SetBinContent(ii,cval);
+ dNdPt_MC->SetBinError(ii,cerr);
+ }
+ dNdPt_MC->SetMarkerStyle(21);
+ dNdPt_MC->SetTitle("; p_{T} (GeV/c) ; 1/N_{evt} 1/(2#pi p_{T}) (d^{2}N_{ch})/(d#eta dp_{T})^{-2}");
+ ContHist->Add(dNdPt_MC);
+
+
+
+ h1GenPrimTrack_pt = (TH1D*) h1GenPrimTrack_pt->Rebin(ptNbins,"",binsPt); // rebin hist
+
+ ContHist->Add(h3GenPrimTrack);
+ ContHist->Add(h2GenPrimTrack_zv_pt);
+ ContHist->Add(h2GenPrimTrack_zv_eta);
+ ContHist->Add(h2GenPrimTrack_pt_eta);
+ ContHist->Add(h1GenPrimTrack_zv);
+ ContHist->Add(h1GenPrimTrack_pt);
+ ContHist->Add(h1GenPrimTrack_eta);
+ printf("\n");
+ printf("==============================================================\n");
+ printf("=== recontructed MC tracks %lf ===\n",MCReconstructedTracks);
+ printf("=== recontructed MC secondary tracks %lf ===\n",MCReconstructedSecTracks);
+ printf("=== recontructed MC primary tracks %lf ===\n",MCReconstructedPrimTracks);
+ printf("=== generated MC primary track %lf ===\n",MCGeneratedPrimTracks);
+ printf("==============================================================\n");
+ printf("\n");
+
+// THnSparse *fSparseTriggerTrackEvent = obj->GetTriggerTrackEventMatrix();//Tracks from triggered events
+// THnSparse *fSparseVtxTrackEvent = obj->GetRecTrackEventMatrix();//Tracks from events with rec. vtx
+// THnSparse *fSparseGenTrackEvent = obj->GetGenTrackEventMatrix();//generated TrackEvent matrix
+
+ // tracking efficiencies + corrections
+ TH3D* h3TrackEff = AlidNdPtHelper::GenerateCorrMatrix(h3RecPrimTrack,h3GenPrimTrack,"h3TrackEff");
+ TH3D* h3TrackCorr = AlidNdPtHelper::GenerateCorrMatrix(h3GenPrimTrack,h3RecPrimTrack,"h3TrackCorr");
+
+ TH2D* h2TrackEff_zv_pt = AlidNdPtHelper::GenerateCorrMatrix(h2RecPrimTrack_zv_pt,h2GenPrimTrack_zv_pt,"h2TrackEff_zv_pt");
+ TH2D* h2TrackCorr_zv_pt = AlidNdPtHelper::GenerateCorrMatrix(h2GenPrimTrack_zv_pt,h2RecPrimTrack_zv_pt,"h2TrackCorr_zv_pt");
+ TH2D* h2TrackEff_zv_eta = AlidNdPtHelper::GenerateCorrMatrix(h2RecPrimTrack_zv_eta,h2GenPrimTrack_zv_eta,"h2TrackEff_zv_eta");
+ TH2D* h2TrackCorr_zv_eta = AlidNdPtHelper::GenerateCorrMatrix(h2GenPrimTrack_zv_eta,h2RecPrimTrack_zv_eta,"h2TrackCorr_zv_eta");
+ TH2D* h2TrackEff_pt_eta = AlidNdPtHelper::GenerateCorrMatrix(h2RecPrimTrack_pt_eta,h2GenPrimTrack_pt_eta,"h2TrackEff_pt_eta");
+ TH2D* h2TrackCorr_pt_eta = AlidNdPtHelper::GenerateCorrMatrix(h2GenPrimTrack_pt_eta,h2RecPrimTrack_pt_eta,"h2TrackCorr_pt_eta");
+
+ TH1D* h1TrackEff_zv = AlidNdPtHelper::GenerateCorrMatrix(h1RecPrimTrack_zv,h1GenPrimTrack_zv,"h1TrackEff_zv");
+ TH1D* h1TrackCorr_zv = AlidNdPtHelper::GenerateCorrMatrix(h1GenPrimTrack_zv,h1RecPrimTrack_zv,"h1TrackCorr_zv");
+ TH1D* h1TrackEff_pt = AlidNdPtHelper::GenerateCorrMatrix(h1RecPrimTrack_pt,h1GenPrimTrack_pt,"h1TrackEff_pt");
+ TH1D* h1TrackCorr_pt = AlidNdPtHelper::GenerateCorrMatrix(h1GenPrimTrack_pt,h1RecPrimTrack_pt,"h1TrackCorr_pt");
+ TH1D* h1TrackEff_eta = AlidNdPtHelper::GenerateCorrMatrix(h1RecPrimTrack_eta,h1GenPrimTrack_eta,"h1TrackEff_eta");
+ TH1D* h1TrackCorr_eta = AlidNdPtHelper::GenerateCorrMatrix(h1GenPrimTrack_eta,h1RecPrimTrack_eta,"h1TrackCorr_eta");
+
+ CorrMatr->Add(h3TrackEff);
+ CorrMatr->Add(h3TrackCorr);
+ CorrMatr->Add(h2TrackEff_zv_pt);
+ CorrMatr->Add(h2TrackCorr_zv_pt);
+ CorrMatr->Add(h2TrackEff_zv_eta);
+ CorrMatr->Add(h2TrackCorr_zv_eta);
+ CorrMatr->Add(h2TrackEff_pt_eta);
+ CorrMatr->Add(h2TrackCorr_pt_eta);
+ CorrMatr->Add(h1TrackEff_zv);
+ CorrMatr->Add(h1TrackCorr_zv);
+ CorrMatr->Add(h1TrackEff_pt);
+ CorrMatr->Add(h1TrackCorr_pt);
+ CorrMatr->Add(h1TrackEff_eta);
+ CorrMatr->Add(h1TrackCorr_eta);
+
+ // scale the secondaries before calculating correction matrices
+ for (Long64_t i = 0; i < fRecSecTrackMatrixScaled->GetNbins(); i++) {
+ Int_t c[3];
+ Double_t val = fRecSecTrackMatrixScaled->GetBinContent(i,c);
+ Double_t err = fRecSecTrackMatrixScaled->GetBinError(i);
+ Double_t pt = fRecSecTrackMatrixScaled->GetAxis(1)->GetBinCenter(c[1]);
+ Double_t scale = GetStrangenessCorrFactorPbPb(pt, sscale);
+ fRecSecTrackMatrixScaled->SetBinContent(c,val*scale);
+ fRecSecTrackMatrixScaled->SetBinError(c,err*scale);
+ }
+
+ // for correct determination of secondaries contamination, also the total total tracks have to be scaled
+ // this is done by taking primaries and adding the scaled secondaries
+ fRecTrackMatrixScaled->Add(fRecSecTrackMatrixScaled);
+
+ fRecSecTrackMatrixScaled->GetAxis(0)->SetRangeUser(-zVert, zVert-0.01);//zVer
+ fRecSecTrackMatrixScaled->GetAxis(2)->SetRangeUser(-eta, eta-0.01);//eta
+ fRecSecTrackMatrixScaled->GetAxis(3)->SetRange(c_first,c_last); // select centrality
+
+ TH3D* h3RecSecTrackScaled = fRecSecTrackMatrixScaled->Projection(0,1,2)->Clone("h3RecSecTrackScaled");
+ TH2D* h2RecSecTrackScaled_zv_pt = fRecSecTrackMatrixScaled->Projection(0,1)->Clone("h2RecSecTrackScaled_zv_pt");
+ TH2D* h2RecSecTrackScaled_zv_eta = fRecSecTrackMatrixScaled->Projection(0,2)->Clone("h2RecSecTrackScaled_zv_eta");
+ TH2D* h2RecSecTrackScaled_pt_eta = fRecSecTrackMatrixScaled->Projection(1,2)->Clone("h2RecSecTrackScaled_pt_eta");
+ TH1D* h1RecSecTrackScaled_zv = fRecSecTrackMatrixScaled->Projection(0)->Clone("h1RecSecTrackScaled_zv");
+ TH1D* h1RecSecTrackScaled_pt = fRecSecTrackMatrixScaled->Projection(1)->Clone("h1RecSecTrackScaled_pt");
+ TH1D* h1RecSecTrackScaled_eta = fRecSecTrackMatrixScaled->Projection(2)->Clone("h1RecSecTrackScaled_eta");
+
+ h1RecSecTrackScaled_pt = (TH1D*) h1RecSecTrackScaled_pt->Rebin(ptNbins,"",binsPt); // rebin hist
+
+ ContHist->Add(h3RecSecTrackScaled);
+ ContHist->Add(h2RecSecTrackScaled_zv_pt);
+ ContHist->Add(h2RecSecTrackScaled_zv_eta);
+ ContHist->Add(h2RecSecTrackScaled_pt_eta);
+ ContHist->Add(h1RecSecTrackScaled_zv);
+ ContHist->Add(h1RecSecTrackScaled_pt);
+ ContHist->Add(h1RecSecTrackScaled_eta);
+
+ fRecTrackMatrixScaled->GetAxis(0)->SetRangeUser(-zVert, zVert-0.01);//zVer
+ fRecTrackMatrixScaled->GetAxis(2)->SetRangeUser(-eta, eta-0.01);//eta
+
+ TH3D* h3RecTrackScaled = fRecTrackMatrixScaled->Projection(0,1,2)->Clone("h3RecTrackScaled");
+ TH2D* h2RecTrackScaled_zv_pt = fRecTrackMatrixScaled->Projection(0,1)->Clone("h2RecTrackScaled_zv_pt");
+ TH2D* h2RecTrackScaled_zv_eta = fRecTrackMatrixScaled->Projection(0,2)->Clone("h2RecTrackScaled_zv_eta");
+ TH2D* h2RecTrackScaled_pt_eta = fRecTrackMatrixScaled->Projection(1,2)->Clone("h2RecTrackScaled_pt_eta");
+ TH1D* h1RecTrackScaled_zv = fRecTrackMatrixScaled->Projection(0)->Clone("h1RecTrackScaled_zv");
+ TH1D* h1RecTrackScaled_pt = fRecTrackMatrixScaled->Projection(1)->Clone("h1RecTrackScaled_pt");
+ TH1D* h1RecTrackScaled_eta = fRecTrackMatrixScaled->Projection(2)->Clone("h1RecTrackScaled_eta");
+
+
+ h1RecTrackScaled_pt = (TH1D*) h1RecTrackScaled_pt->Rebin(ptNbins,"",binsPt); // rebin hist
+
+
+ ContHist->Add(h3RecTrackScaled);
+ ContHist->Add(h2RecTrackScaled_zv_pt);
+ ContHist->Add(h2RecTrackScaled_zv_eta);
+ ContHist->Add(h2RecTrackScaled_pt_eta);
+ ContHist->Add(h1RecTrackScaled_zv);
+ ContHist->Add(h1RecTrackScaled_pt);
+ ContHist->Add(h1RecTrackScaled_eta);
+
+ // create histograms for secondaries contamination and correction
+
+ TH3D* h3SecCont = AlidNdPtHelper::GenerateCorrMatrix(h3RecSecTrackScaled,h3RecTrackScaled,"h3SecCont");
+ TH3D* h3SecCorr = AlidNdPtHelper::GenerateContCorrMatrix(h3RecSecTrackScaled,h3RecTrackScaled,"h3SecCorr");
+ TH2D* h2SecCont_zv_pt = AlidNdPtHelper::GenerateCorrMatrix(h2RecSecTrackScaled_zv_pt,h2RecTrackScaled_zv_pt,"h2SecCont_zv_pt");
+ TH2D* h2SecCorr_zv_pt = AlidNdPtHelper::GenerateContCorrMatrix(h2RecSecTrackScaled_zv_pt,h2RecTrackScaled_zv_pt,"h2SecCorr_zv_pt");
+ TH2D* h2SecCont_zv_eta = AlidNdPtHelper::GenerateCorrMatrix(h2RecSecTrackScaled_zv_eta,h2RecTrackScaled_zv_eta,"h2SecCont_zv_eta");
+ TH2D* h2SecCorr_zv_eta = AlidNdPtHelper::GenerateContCorrMatrix(h2RecSecTrackScaled_zv_eta,h2RecTrackScaled_zv_eta,"h2SecCorr_zv_eta");
+ TH2D* h2SecCont_pt_eta = AlidNdPtHelper::GenerateCorrMatrix(h2RecSecTrackScaled_pt_eta,h2RecTrackScaled_pt_eta,"h2SecCont_pt_eta");
+ TH2D* h2SecCorr_pt_eta = AlidNdPtHelper::GenerateContCorrMatrix(h2RecSecTrackScaled_pt_eta,h2RecTrackScaled_pt_eta,"h2SecCorr_pt_eta");
+ TH1D* h1SecCont_zv = AlidNdPtHelper::GenerateCorrMatrix(h1RecSecTrackScaled_zv,h1RecTrackScaled_zv,"h1SecCont_zv");
+ TH1D* h1SecCorr_zv = AlidNdPtHelper::GenerateContCorrMatrix(h1RecSecTrackScaled_zv,h1RecTrackScaled_zv,"h1SecCorr_zv");
+ TH1D* h1SecCont_pt = AlidNdPtHelper::GenerateCorrMatrix(h1RecSecTrackScaled_pt,h1RecTrackScaled_pt,"h1SecCont_pt");
+ TH1D* h1SecCorr_pt = AlidNdPtHelper::GenerateContCorrMatrix(h1RecSecTrackScaled_pt,h1RecTrackScaled_pt,"h1SecCorr_pt");
+ TH1D* h1SecCont_eta = AlidNdPtHelper::GenerateCorrMatrix(h1RecSecTrackScaled_eta,h1RecTrackScaled_eta,"h1SecCont_eta");
+ TH1D* h1SecCorr_eta = AlidNdPtHelper::GenerateContCorrMatrix(h1RecSecTrackScaled_eta,h1RecTrackScaled_eta,"h1SecCorr_eta");
+
+ CorrMatr->Add(h3SecCont);
+ CorrMatr->Add(h3SecCorr);
+ CorrMatr->Add(h2SecCont_zv_pt);
+ CorrMatr->Add(h2SecCorr_zv_pt);
+ CorrMatr->Add(h2SecCont_zv_eta);
+ CorrMatr->Add(h2SecCorr_zv_eta);
+ CorrMatr->Add(h2SecCont_pt_eta);
+ CorrMatr->Add(h2SecCorr_pt_eta);
+ CorrMatr->Add(h1SecCont_zv);
+ CorrMatr->Add(h1SecCorr_zv);
+ CorrMatr->Add(h1SecCont_pt);
+ CorrMatr->Add(h1SecCorr_pt);
+ CorrMatr->Add(h1SecCont_eta);
+ CorrMatr->Add(h1SecCorr_eta);
+
+ // plot pictures and save to gifdir
+ for (i=0; i < CorrMatr->LastIndex(); i++) {
+ TCanvas* ctmp = PlotHist(CorrMatr->At(i),idstring);
+ if (gifdir && ctmp) {
+ TString gif(gifdir);
+ gif += '/';
+ gif += ctmp->GetName();
+ gif += ".gif";
+ ctmp->SaveAs(gif.Data(),"gif");
+ delete ctmp;
+ }
+ }
+ for (i=0; i < ContHist->LastIndex(); i++) {
+ TCanvas* ctmp = PlotHist(ContHist->At(i),idstring);
+ if (gifdir && ctmp) {
+ TString gif(gifdir);
+ gif += '/';
+ gif += ctmp->GetName();
+ gif += ".gif";
+ ctmp->SaveAs(gif.Data(),"gif");
+ delete ctmp;
+ }
+ }
+
+ // save all correction matrices and control histograms to file
+ if (!outfile) { return; }
+ TFile *out = TFile::Open(outfile,"RECREATE");
+ CorrMatr->Write();
+ ContHist->Write();
+ out->Close();
+
+ return MCReconstructedEvents;
+
+}
+
+
+//_____________________________________________________________________________
+Double_t GetStrangenessCorrFactorPbPb(Double_t pt, Double_t s)
+{
+ // data driven correction factor for secondaries (PbPb)
+
+ if (pt <= 0.25) return 1.0;
+ if (pt <= 0.5) return GetLinearInterpolationValue(0.25,1.0,0.5,0.60+0.40*s, pt);
+ if (pt <= 1.0) return GetLinearInterpolationValue(0.5,0.60+0.40*s,1.0,0.53+0.47*s, pt);
+ if (pt <= 2.0) return GetLinearInterpolationValue(1.0,0.53+0.47*s,2.0,0.44+0.56*s, pt);
+ if (pt <= 5.0) return GetLinearInterpolationValue(2.0,0.44+0.56*s,5.0,0.33+0.67*s, pt);
+ return 0.33+0.67*s;
+}
+
+
+//___________________________________________________________________________
+Double_t GetLinearInterpolationValue(const Double_t x1,const Double_t y1,const Double_t x2,const Double_t y2, const Double_t pt)
+{
+ //
+ // linear interpolation
+ //
+ return ((y2-y1)/(x2-x1))*pt+(y2-(((y2-y1)/(x2-x1))*x2));
+}
+
+//___________________________________________________________________________
+TCanvas* PlotHist(TObject* hobj, const char* label=0)
+{
+ TH1* h = dynamic_cast<TH1*>(hobj);
+ if (!h) return 0;
+ if (h->GetDimension() > 2) return 0;
+ h->SetStats(0);
+ if ( TString(h->GetName()).Contains("Events")) { h->SetStats(1); }
+ TString t(label);
+ if (label) t += "_";
+ t += h->GetName();
+ h->SetTitle(t.Data());
+ TCanvas* c = new TCanvas(t.Data(),t.Data());
+ if (h->GetDimension() >= 1) {
+ TString xlabel(h->GetXaxis()->GetTitle());
+ if (xlabel.Contains("Pt")) { c->SetLogx(); h->GetXaxis()->SetRangeUser(0.1 , 100.); }
+ }
+ if (h->GetDimension() == 1) {
+ if (xlabel.Contains("p_{T}")) { c->SetLogx(); c->SetLogy(); h->GetXaxis()->SetRangeUser(0.1 , 100.); }
+ }
+ if (h->GetDimension() == 2) {
+ TString ylabel(h->GetYaxis()->GetTitle());
+ if (ylabel.Contains("Pt")) { c->SetLogy(); h->GetYaxis()->SetRangeUser(0.1 , 100.); }
+ if (ylabel.Contains("p_{T}")) { c->SetLogy(); h->GetYaxis()->SetRangeUser(0.1 , 100.); }
+ h->Draw("COLZ");
+ }
+ if (h->GetDimension() == 1) {
+ h->Draw();
+ }
+ return c;
+
+}
+
+Int_t CheckLoadLibrary(const char* library)
+{
+ // checks if a library is already loaded, if not loads the library
+
+ if (strlen(gSystem->GetLibraries(Form("%s.so", library), "", kFALSE)) > 0)
+ return 1;
+
+ return gSystem->Load(library);
+}
--- /dev/null
+Double_t GenerateCorrMatr_pp(const char* mcfile, const char* mctask, const char* idstring ,const char* outfile, const char* gifdir = 0)
+//Double_t GenerateCorrMatr_pp()
+{
+//tmp setting
+// const char* mcfile = "/d/alice09/mknichel/train/V007.MC_pp/2011-05-05_2347.7147/mergedPeriods/MC_pp/7TeV/LHC10f6a/mknichel_dNdPtpp_TPCITS.root";
+// const char* mctask = "mknichel_dNdPtpp_TPCITS";
+// const char* idstring = "TPCITS";
+// const char* outfile = "/u/mknichel/alice/dNdPt_pp/temp/corrMatr_LHC10f6a_TPCITS.root";
+// const char* gifdir = "/u/mknichel/alice/dNdPt_pp/temp";
+
+TString fname (mcfile);
+
+TString id (idstring);
+TString taskname = "mknichel_dNdPtpp_" + id;
+TString objname = "dNdPtAnalysis_" + id;
+
+ // settings vor zVertex cut (event and track level)
+ Double_t zVert = 10.0;
+
+ // setting on eta cut (track level)
+ Double_t eta = 0.8;
+
+ // strangeness scaling factor (for secondaries from strange decays)
+ Double_t sscale = 2.0; //ignored
+
+
+ // Set pt binning
+ const Int_t ptNbins = 31;
+ Double_t bins[32] = {0.0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0,2.4,2.8, 3.0, 4.0, 50.0, 100.0 };
+ Double_t* binsPt = new Double_t[32];
+ for (int ibin=0; ibin<32; ibin++) {binsPt[ibin] = bins[ibin];}
+
+
+
+ Int_t ptNbinsTrackEventCorr = 36;
+ Int_t etaNbins = 30;
+ Int_t zvNbins = 12;
+
+ Double_t binsMultDefault[28] = {-0.5, 0.5 , 1.5 , 2.5 , 3.5 , 4.5 , 5.5 , 6.5 , 7.5 , 8.5,
+ 9.5, 10.5, 11.5, 12.5, 13.5, 14.5, 15.5, 16.5, 17.5, 18.5,
+ 19.5,20.5, 21.5, 22.5, 23.5, 24.5, 29.5, 149.5};
+
+ Double_t binsPtTrackEventCorrDefault[37] = {0.,0.05,0.1,0.15,0.2,0.25,0.3,0.35,0.4,0.45,0.5,0.55,0.6,0.65,0.7,0.75,0.8,0.85,0.9,0.95,1.0,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,1.9,2.0,2.2,2.4,2.6,3.0,4.0,50.0};
+
+ Double_t binsPtDefault[69] = {0.,0.05,0.1,0.15,0.2,0.25,0.3,0.35,0.4,0.45,0.5,0.55,0.6,0.65,0.7,0.75,0.8,0.85,0.9,0.95,1.0,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,1.9,2.0,2.2,2.4,2.6,2.8,3.0,3.2,3.4,3.6,3.8,4.0,4.5,5.0,5.5,6.0,6.5,7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0,18.0,20.0,22.0,24.0,26.0,28.0,30.0,32.0,34.0,36.0,40.0,45.0,50.0};
+
+ Double_t binsEtaDefault[31] = {-1.5,-1.4,-1.3,-1.2,-1.1,-1.0,-0.9,-0.8,-0.7,-0.6,-0.5,-0.4,-0.3,-0.2,-0.1,0.,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0,1.1,1.2,1.3,1.4,1.5};
+
+ Double_t binsZvDefault[13] = {-30.,-25.,-20.,-15.,-10.,-5.,0.,5.,10.,15.,20.,25.,30.};
+
+ // binning for corrections (note difference for efficiency and secondaries)
+ if (fname.Contains("2.76TeV") || fname.Contains("900GeV")) {
+
+ const Int_t ptNbinsSecCorr = 28;
+ const Int_t ptNbinsEffCorr = 31;
+ const Int_t etaNbinsCorr = 4;
+ const Int_t zvNbinsCorr = 4;
+ const Int_t multNbinsCorr = 2;
+ Double_t ptBinsSecCorr[29] = {0.0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1.0, 1.2, 1.4, 1.6, 2.0, 2.4, 3.0, 50.0, 100.0 };
+ Double_t ptBinsEffCorr[32] = {0.0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1.0, 1.2, 1.4, 1.6, 2.0, 2.4, 2.8, 3.0, 3.4, 4.0, 50.0, 100.0 };
+ Double_t etaBinsCorr[5] = {-0.8,-0.4,0.,0.4,0.8};
+
+ Double_t zvBinsCorr[5] = {-10.,-5.,0.,5.,10.};
+ Double_t multBinsCorr[3] = {-0.5,0.5,500.};
+
+
+ } else {
+
+ const Int_t ptNbinsSecCorr = 38;
+ const Int_t ptNbinsEffCorr = 50;
+ const Int_t etaNbinsCorr = 8;
+ const Int_t zvNbinsCorr = 4;
+ const Int_t multNbinsCorr = 2;
+ Double_t ptBinsSecCorr[39] = {0.,0.05,0.1,0.15,0.2,0.25,0.3,0.35,0.4,0.45,0.5,0.55,0.6,0.65,0.7,0.75,0.8,0.85,0.9,0.95,1.0,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,1.9,2.0,2.2,2.4,2.6,3.0,3.4,4.0,50.0,100.0};
+ Double_t ptBinsEffCorr[51] = {0.0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.2, 2.4, 2.6, 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.5, 5.0, 5.5, 6.0, 6.5, 7.0, 8.0, 10.0, 50.0, 100.0 };
+ Double_t etaBinsCorr[9] = {-0.8,-0.6,-0.4,-0.2,0.,0.2,0.4,0.6,0.8};
+
+ Double_t zvBinsCorr[5] = {-10.,-5.,0.,5.,10.};
+ Double_t multBinsCorr[3] = {-0.5,0.5,500.};
+
+ }
+
+
+ Int_t binsTrackEffCorr[3]={zvNbinsCorr,ptNbinsEffCorr,etaNbinsCorr};
+ Int_t binsTrackSecCorr[3]={zvNbinsCorr,ptNbinsSecCorr,etaNbinsCorr};
+
+ THnSparse* hSTrackEffCorr = new THnSparseF("hSTrackEffCorr","Zv:pT:eta",3,binsTrackEffCorr);
+ hSTrackEffCorr->SetBinEdges(0,zvBinsCorr);
+ hSTrackEffCorr->SetBinEdges(1,ptBinsEffCorr);
+ hSTrackEffCorr->SetBinEdges(2,etaBinsCorr);
+// hSTrackEffCorr->SetBinEdges(3,multBinsCorr);
+ hSTrackEffCorr->GetAxis(0)->SetTitle("Zv (cm)");
+ hSTrackEffCorr->GetAxis(1)->SetTitle("p_{T} (GeV/c)");
+ hSTrackEffCorr->GetAxis(2)->SetTitle("#eta");
+// hSTrackEffCorr->GetAxis(3)->SetTitle("mult MB");
+ hSTrackEffCorr->Sumw2();
+
+ THnSparse* hSTrackSecCorr = new THnSparseF("hSTrackSecCorr","Zv:pT:eta",3,binsTrackSecCorr);
+ hSTrackSecCorr->SetBinEdges(0,zvBinsCorr);
+ hSTrackSecCorr->SetBinEdges(1,ptBinsSecCorr);
+ hSTrackSecCorr->SetBinEdges(2,etaBinsCorr);
+// hSTrackSecCorr->SetBinEdges(3,multBinsCorr);
+ hSTrackSecCorr->GetAxis(0)->SetTitle("Zv (cm)");
+ hSTrackSecCorr->GetAxis(1)->SetTitle("p_{T} (GeV/c)");
+ hSTrackSecCorr->GetAxis(2)->SetTitle("#eta");
+// hSTrackSecCorr->GetAxis(3)->SetTitle("mult MB");
+ hSTrackSecCorr->Sumw2();
+
+
+ // make plots nicer
+ gROOT->SetStyle("Plain");
+ gStyle->SetPalette(1);
+
+ // array for all correction matrices
+ TObjArray* CorrMatr = new TObjArray();
+
+ // array for all control histograms
+ TObjArray* ContHist = new TObjArray();
+
+
+ // load mc information
+ TFile* fmc = TFile::Open(mcfile,"READ");
+ if (!fmc) return -1;
+ TList* lmc = dynamic_cast<TList*>(fmc->Get(taskname.Data()));
+ if (!lmc) return -1;
+ AlidNdPtAnalysis *obj = dynamic_cast<AlidNdPtAnalysis*>(lmc->FindObject(objname.Data()));
+ if (!obj) return -1;
+
+ //Event statistics
+ THnSparse *fRecEventMatrix = obj->GetRecEventMatrix(); //all reconstructed events
+ TH2D* h2RecEventAll = fRecEventMatrix->Projection(0,1)->Clone("h2RecEventAll");
+ fRecEventMatrix->GetAxis(0)->SetRangeUser(-zVert, zVert-0.01);//zVer
+ TH2D* h2RecEvent = fRecEventMatrix->Projection(0,1)->Clone("h2RecEvent");
+ Double_t MCReconstructedEvents = h2RecEvent->Integral();
+ Double_t MCReconstructedEventsAll = h2RecEventAll->Integral();
+ ContHist->Add(h2RecEvent);
+ ContHist->Add(h2RecEventAll);
+
+ THnSparse *fTriggerEventMatrix = obj->GetTriggerEventMatrix(); //all triggered events
+ Double_t MCTriggeredEventsAll0mult = obj->GetTriggerEventMatrix()->Projection(1)->Integral(1,1); // 0 contributers to vertex
+ TH2D* h2TriggerEventAll = fTriggerEventMatrix->Projection(0,1)->Clone("h2TriggerEventAll");
+ fTriggerEventMatrix->GetAxis(0)->SetRangeUser(-zVert, zVert-0.01);//zVer
+ Double_t MCTriggeredEvents0mult = obj->GetTriggerEventMatrix()->Projection(1)->Integral(1,1); // 0 contributers to vertex
+ TH2D* h2TriggerEvent = fTriggerEventMatrix->Projection(0,1)->Clone("h2TriggerEvent");
+ Double_t MCTriggeredEvents = h2TriggerEvent->Integral();
+ Double_t MCTriggeredEventsAll = h2TriggerEventAll->Integral();
+ ContHist->Add(h2TriggerEvent);
+ ContHist->Add(h2TriggerEventAll);
+
+ THnSparse *fGenEventMatrix = obj->GetGenEventMatrix(); //all generated events
+ TH2D* h2GenEventAll = fGenEventMatrix->Projection(0,1)->Clone("h2GenEventAll");
+ fGenEventMatrix->GetAxis(0)->SetRangeUser(-zVert, zVert-0.01);//zVer
+ TH2D* h2GenEvent = fGenEventMatrix->Projection(0,1)->Clone("h2GenEvent");
+ Double_t MCGeneratedEvents = h2GenEvent->Integral();
+ Double_t MCGeneratedEventsAll = h2GenEventAll->Integral();
+ ContHist->Add(h2RecEvent);
+ ContHist->Add(h2RecEventAll);
+
+ THnSparse *fRecEventHist = obj->GetRecEventHist();
+ THnSparse *fRecEventHist2 = obj->GetRecEventHist2();
+
+ printf("=== generated MC events for correction matrices %lf ===\n",MCGeneratedEvents);
+ printf("=== triggered MC events for correction matrices %lf ===\n",MCTriggeredEvents);
+ printf("=== recontructed MC events for correction matrices %lf ===\n",MCReconstructedEvents);
+ printf("\n");
+ printf("=== cut on the zVertex +- %lf ===\n",zVert);
+ printf("=== generated MC events (before zVertex cut) %lf ===\n",MCGeneratedEventsAll);
+ printf("=== triggered MC events (before zVertex cut) %lf ===\n",MCTriggeredEventsAll);
+ printf("=== recontructed MC events (before zVertex cut) %lf ===\n",MCReconstructedEventsAll);
+
+ TH1D* h1MCGeneratedEvents = new TH1D("h1MCGeneratedEvents","h1MCGeneratedEvents",1,0,1);
+ TH1D* h1MCTriggeredEvents = new TH1D("h1MCTriggeredEvents","h1MCTriggeredEvents",1,0,1);
+ TH1D* h1MCReconstructedEvents = new TH1D("h1MCReconstructedEvents","h1MCReconstructedEvents",1,0,1);
+ TH1D* h1MCGeneratedEventsAll = new TH1D("h1MCGeneratedEventsAll","h1MCGeneratedEventsAll",1,0,1);
+ TH1D* h1MCTriggeredEventsAll = new TH1D("h1MCTriggeredEventsAll","h1MCTriggeredEventsAll",1,0,1);
+ TH1D* h1MCReconstructedEventsAll = new TH1D("h1MCReconstructedEventsAll","h1MCReconstructedEventsAll",1,0,1);
+ TH1D* h1MCTriggeredEventsAll0mult = new TH1D("h1MCTriggeredEventsAll0mult","h1MCTriggeredEventsAll0mult",1,0,1);
+ TH1D* h1MCTriggeredEvents0mult = new TH1D("h1MCTriggeredEvents0mult","h1MCTriggeredEvents0mult",1,0,1);
+
+ h1MCGeneratedEvents->Fill(0,MCGeneratedEvents);
+ h1MCGeneratedEvents->SetEntries(MCGeneratedEvents);
+ h1MCTriggeredEvents->Fill(0,MCTriggeredEvents);
+ h1MCTriggeredEvents->SetEntries(MCTriggeredEvents);
+ h1MCReconstructedEvents->Fill(0,MCReconstructedEvents);
+ h1MCReconstructedEvents->SetEntries(MCReconstructedEvents);
+ h1MCGeneratedEventsAll->Fill(0,MCGeneratedEventsAll);
+ h1MCGeneratedEventsAll->SetEntries(MCGeneratedEventsAll);
+ h1MCTriggeredEventsAll->Fill(0,MCTriggeredEventsAll);
+ h1MCTriggeredEventsAll->SetEntries(MCTriggeredEventsAll);
+ h1MCReconstructedEventsAll->Fill(0,MCReconstructedEventsAll);
+ h1MCReconstructedEventsAll->SetEntries(MCReconstructedEventsAll);
+ h1MCTriggeredEventsAll0mult->Fill(0,MCTriggeredEventsAll0mult);
+ h1MCTriggeredEventsAll0mult->SetEntries(MCTriggeredEventsAll0mult);
+ h1MCTriggeredEvents0mult->Fill(0,MCTriggeredEvents0mult);
+ h1MCTriggeredEvents0mult->SetEntries(MCTriggeredEvents0mult);
+
+
+ ContHist->Add(h1MCGeneratedEvents);
+ ContHist->Add(h1MCTriggeredEvents);
+ ContHist->Add(h1MCReconstructedEvents);
+ ContHist->Add(h1MCGeneratedEventsAll);
+ ContHist->Add(h1MCTriggeredEventsAll);
+ ContHist->Add(h1MCReconstructedEventsAll);
+ ContHist->Add(h1MCTriggeredEvents0mult);
+ ContHist->Add(h1MCTriggeredEventsAll0mult);
+
+
+ // efficienfy and correction matrices for tigger and vertex efficiency
+ TH2D* h2EventTriggerEffAll = AlidNdPtHelper::GenerateCorrMatrix(h2TriggerEventAll,h2GenEventAll,"h2EventTriggerEffAll");
+ TH2D* h2EventTriggerCorrAll = AlidNdPtHelper::GenerateCorrMatrix(h2GenEventAll,h2TriggerEventAll,"h2EventTriggerCorrAll");
+ TH2D* h2EventTriggerEff = AlidNdPtHelper::GenerateCorrMatrix(h2TriggerEvent,h2GenEvent,"h2EventTriggerEff");
+ TH2D* h2EventTriggerCorr = AlidNdPtHelper::GenerateCorrMatrix(h2GenEvent,h2TriggerEvent,"h2EventTriggerCorr");
+
+ TH2D* h2EventRecEffAll = AlidNdPtHelper::GenerateCorrMatrix(h2RecEventAll,h2TriggerEventAll,"h2EventRecEffAll");
+ TH2D* h2EventRecCorrAll = AlidNdPtHelper::GenerateCorrMatrix(h2TriggerEventAll,h2RecEventAll,"h2EventRecCorrAll");
+ TH2D* h2EventRecEff = AlidNdPtHelper::GenerateCorrMatrix(h2RecEvent,h2TriggerEvent,"h2EventRecEff");
+ TH2D* h2EventRecCorr = AlidNdPtHelper::GenerateCorrMatrix(h2TriggerEvent,h2RecEvent,"h2EventRecCorr");
+
+ TH2D* h2EventEffAll = AlidNdPtHelper::GenerateCorrMatrix(h2RecEventAll,h2GenEventAll,"h2EventEffAll");
+ TH2D* h2EventCorrAll = AlidNdPtHelper::GenerateCorrMatrix(h2GenEventAll,h2RecEventAll,"h2EventCorrAll");
+ TH2D* h2EventEff = AlidNdPtHelper::GenerateCorrMatrix(h2RecEvent,h2GenEvent,"h2EventEff");
+ TH2D* h2EventCorr = AlidNdPtHelper::GenerateCorrMatrix(h2GenEvent,h2RecEvent,"h2EventCorr");
+
+ CorrMatr->Add(h2EventTriggerEffAll);
+ CorrMatr->Add(h2EventTriggerCorrAll);
+ CorrMatr->Add(h2EventTriggerEff);
+ CorrMatr->Add(h2EventTriggerCorr);
+ CorrMatr->Add(h2EventRecEffAll);
+ CorrMatr->Add(h2EventRecCorrAll);
+ CorrMatr->Add(h2EventRecEff);
+ CorrMatr->Add(h2EventRecCorr);
+ CorrMatr->Add(h2EventEffAll);
+ CorrMatr->Add(h2EventCorrAll);
+ CorrMatr->Add(h2EventEff);
+ CorrMatr->Add(h2EventCorr);
+
+ THnSparse* hSMultCorrelation = obj->GetEventMultCorrelationMatrix()->Clone("hSMultCorrelation");
+ CorrMatr->Add(hSMultCorrelation);
+ TH2D* h2MultCorrelation = hSMultCorrelation->Projection(0,1)->Clone("h2MultCorrelation");
+ CorrMatr->Add(h2MultCorrelation);
+
+ // all recontructed
+ THnSparse *fRecTrackMatrix = obj->GetRecTrackMatrix();
+ fRecTrackMatrix->GetAxis(0)->SetRangeUser(-zVert, zVert-0.01);//zVer
+ fRecTrackMatrix->GetAxis(2)->SetRangeUser(-eta, eta-0.01);//eta
+ TH3D* h3RecTrack = fRecTrackMatrix->Projection(0,1,2)->Clone("h3RecTrack");
+ TH2D* h2RecTrack_zv_pt = fRecTrackMatrix->Projection(0,1)->Clone("h2RecTrack_zv_pt");
+ TH2D* h2RecTrack_zv_eta = fRecTrackMatrix->Projection(0,2)->Clone("h2RecTrack_zv_eta");
+ TH2D* h2RecTrack_pt_eta = fRecTrackMatrix->Projection(1,2)->Clone("h2RecTrack_pt_eta");
+ TH1D* h1RecTrack_zv = fRecTrackMatrix->Projection(0)->Clone("h1RecTrack_zv");
+ TH1D* h1RecTrack_pt = fRecTrackMatrix->Projection(1)->Clone("h1RecTrack_pt");
+ TH1D* h1RecTrack_eta = fRecTrackMatrix->Projection(2)->Clone("h1RecTrack_eta");
+ Double_t MCReconstructedTracks = h3RecTrack->Integral();
+
+ ContHist->Add(h3RecTrack);
+ ContHist->Add(h2RecTrack_zv_pt);
+ ContHist->Add(h2RecTrack_zv_eta);
+ ContHist->Add(h2RecTrack_pt_eta);
+ ContHist->Add(h1RecTrack_zv);
+ ContHist->Add(h1RecTrack_pt);
+ ContHist->Add(h1RecTrack_eta);
+
+ // recontructed primary tracks
+ THnSparse *fRecPrimTrackMatrix = obj->GetRecPrimTrackMatrix();
+ THnSparse *fRecTrackMatrixScaled = fRecPrimTrackMatrix->Clone("fRecTrackMatrixScaled"); //used later for secondaries scaling
+ fRecPrimTrackMatrix->GetAxis(0)->SetRangeUser(-zVert, zVert-0.01);//zVer
+ fRecPrimTrackMatrix->GetAxis(2)->SetRangeUser(-eta, eta-0.01);//eta
+ TH3D* h3RecPrimTrack = fRecPrimTrackMatrix->Projection(0,1,2)->Clone("h3RecPrimTrack");
+ TH2D* h2RecPrimTrack_zv_pt = fRecPrimTrackMatrix->Projection(0,1)->Clone("h2RecPrimTrack_zv_pt");
+ TH2D* h2RecPrimTrack_zv_eta = fRecPrimTrackMatrix->Projection(0,2)->Clone("h2RecPrimTrack_zv_eta");
+ TH2D* h2RecPrimTrack_pt_eta = fRecPrimTrackMatrix->Projection(1,2)->Clone("h2RecPrimTrack_pt_eta");
+ TH1D* h1RecPrimTrack_zv = fRecPrimTrackMatrix->Projection(0)->Clone("h1RecPrimTrack_zv");
+ TH1D* h1RecPrimTrack_pt = fRecPrimTrackMatrix->Projection(1)->Clone("h1RecPrimTrack_pt");
+ TH1D* h1RecPrimTrack_eta = fRecPrimTrackMatrix->Projection(2)->Clone("h1RecPrimTrack_eta");
+ Double_t MCReconstructedPrimTracks = h3RecPrimTrack->Integral();
+
+ ContHist->Add(h3RecPrimTrack);
+ ContHist->Add(h2RecPrimTrack_zv_pt);
+ ContHist->Add(h2RecPrimTrack_zv_eta);
+ ContHist->Add(h2RecPrimTrack_pt_eta);
+ ContHist->Add(h1RecPrimTrack_zv);
+ ContHist->Add(h1RecPrimTrack_pt);
+ ContHist->Add(h1RecPrimTrack_eta);
+
+ // recontructed secondary tracks
+ THnSparse *fRecSecTrackMatrix = obj->GetRecSecTrackMatrix();
+ THnSparse *fRecSecTrackMatrixScaled = fRecSecTrackMatrix->Clone("fRecSecTrackMatrixScaled"); //used later for secondaries scaling
+ fRecSecTrackMatrix->GetAxis(0)->SetRangeUser(-zVert, zVert-0.01);//zVer
+ fRecSecTrackMatrix->GetAxis(2)->SetRangeUser(-eta, eta-0.01);//eta
+ TH3D* h3RecSecTrack = fRecSecTrackMatrix->Projection(0,1,2)->Clone("h3RecSecTrack");
+ TH2D* h2RecSecTrack_zv_pt = fRecSecTrackMatrix->Projection(0,1)->Clone("h2RecSecTrack_zv_pt");
+ TH2D* h2RecSecTrack_zv_eta = fRecSecTrackMatrix->Projection(0,2)->Clone("h2RecSecTrack_zv_eta");
+ TH2D* h2RecSecTrack_pt_eta = fRecSecTrackMatrix->Projection(1,2)->Clone("h2RecSecTrack_pt_eta");
+ TH1D* h1RecSecTrack_zv = fRecSecTrackMatrix->Projection(0)->Clone("h1RecSecTrack_zv");
+ TH1D* h1RecSecTrack_pt = fRecSecTrackMatrix->Projection(1)->Clone("h1RecSecTrack_pt");
+ TH1D* h1RecSecTrack_eta = fRecSecTrackMatrix->Projection(2)->Clone("h1RecSecTrack_eta");
+ Double_t MCReconstructedSecTracks = h3RecSecTrack->Integral();
+
+ ContHist->Add(h3RecSecTrack);
+ ContHist->Add(h2RecSecTrack_zv_pt);
+ ContHist->Add(h2RecSecTrack_zv_eta);
+ ContHist->Add(h2RecSecTrack_pt_eta);
+ ContHist->Add(h1RecSecTrack_zv);
+ ContHist->Add(h1RecSecTrack_pt);
+ ContHist->Add(h1RecSecTrack_eta);
+
+ // generated primary tracks
+ THnSparse *fGenPrimTrackMatrix = obj->GetGenPrimTrackMatrix();
+ fGenPrimTrackMatrix->GetAxis(0)->SetRangeUser(-zVert, zVert-0.01);//zVer
+ fGenPrimTrackMatrix->GetAxis(2)->SetRangeUser(-eta, eta-0.01);//eta
+ TH3D* h3GenPrimTrack = fGenPrimTrackMatrix->Projection(0,1,2)->Clone("h3GenPrimTrack");
+ TH2D* h2GenPrimTrack_zv_Pt = fGenPrimTrackMatrix->Projection(0,1)->Clone("h2GenPrimTrack_zv_pt");
+ TH2D* h2GenPrimTrack_zv_eta = fGenPrimTrackMatrix->Projection(0,2)->Clone("h2GenPrimTrack_zv_eta");
+ TH2D* h2GenPrimTrack_pt_eta = fGenPrimTrackMatrix->Projection(1,2)->Clone("h2GenPrimTrack_pt_eta");
+ TH1D* h1GenPrimTrack_zv = fGenPrimTrackMatrix->Projection(0)->Clone("h1GenPrimTrack_zv");
+ TH1D* h1GenPrimTrack_pt = fGenPrimTrackMatrix->Projection(1)->Clone("h1GenPrimTrack_pt");
+ TH1D* h1GenPrimTrack_eta = fGenPrimTrackMatrix->Projection(2)->Clone("h1GenPrimTrack_eta");
+ Double_t MCGeneratedPrimTracks = h3GenPrimTrack->Integral();
+
+ ContHist->Add(h3GenPrimTrack);
+ ContHist->Add(h2GenPrimTrack_zv_pt);
+ ContHist->Add(h2GenPrimTrack_zv_eta);
+ ContHist->Add(h2GenPrimTrack_pt_eta);
+ ContHist->Add(h1GenPrimTrack_zv);
+ ContHist->Add(h1GenPrimTrack_pt);
+ ContHist->Add(h1GenPrimTrack_eta);
+ printf("\n");
+ printf("==============================================================\n");
+ printf("=== recontructed MC tracks %lf ===\n",MCReconstructedTracks);
+ printf("=== recontructed MC secondary tracks %lf ===\n",MCReconstructedSecTracks);
+ printf("=== recontructed MC primary tracks %lf ===\n",MCReconstructedPrimTracks);
+ printf("=== generated MC primary track %lf ===\n",MCGeneratedPrimTracks);
+ printf("==============================================================\n");
+ printf("\n");
+
+ // mc truth histogram (for self-consistency check)
+ TH1D* dNdPt_MC = (TH1D*) h1GenPrimTrack_pt->Clone("dNdPt_MC");
+ TH1D* dNdEta_MC =(TH1D*) h1GenPrimTrack_eta->Clone("dNdEta_MC");
+ // normalization and finalization
+ // 1/N_evt 1/(2 pi pt) 1/width 1/etarange
+ for (int ii=1; ii <= dNdPt_MC->GetNbinsX() ;ii++) {
+ Double_t pt = dNdPt_MC->GetBinCenter(ii);
+ Double_t width = dNdPt_MC->GetBinWidth(ii);
+ Double_t val = dNdPt_MC->GetBinContent(ii);
+ Double_t err = dNdPt_MC->GetBinError(ii);
+ Double_t cval = (val)/(width * 2.0 * TMath::Pi() * 1.6 * MCGeneratedEvents * pt);
+ Double_t cerr = (err)/(width * 2.0 * TMath::Pi() * 1.6 * MCGeneratedEvents * pt);
+ dNdPt_MC->SetBinContent(ii,cval);
+ dNdPt_MC->SetBinError(ii,cerr);
+ }
+ dNdPt_MC->SetMarkerStyle(21);
+ dNdPt_MC->SetTitle("; p_{T} (GeV/c) ; 1/N_{evt} 1/(2#pi p_{T}) (d^{2}N_{ch})/(d#eta dp_{T})^{-2}");
+ dNdEta_MC->Scale(1,"width");
+ dNdEta_MC->Scale(1./MCGeneratedEvents);
+ ContHist->Add(dNdPt_MC);
+ ContHist->Add(dNdEta_MC);
+
+
+ // Rebin for corrections (pt)
+ cout << "rebinning...." << endl;
+
+ TH1D* h1RecPrimTrack_pt_Rebin = h1RecPrimTrack_pt->Rebin(ptNbins,"h1RecPrimTrack_pt_Rebin",binsPt);
+ TH1D* h1GenPrimTrack_pt_Rebin = h1GenPrimTrack_pt->Rebin(ptNbins,"h1GenPrimTrack_pt_Rebin",binsPt);
+ ContHist->Add(h1RecPrimTrack_pt_Rebin);
+ ContHist->Add(h1GenPrimTrack_pt_Rebin);
+
+
+// THnSparse *fSparseTriggerTrackEvent = obj->GetTriggerTrackEventMatrix();//Tracks from triggered events
+// THnSparse *fSparseVtxTrackEvent = obj->GetRecTrackEventMatrix();//Tracks from events with rec. vtx
+// THnSparse *fSparseGenTrackEvent = obj->GetGenTrackEventMatrix();//generated TrackEvent matrix
+
+ // tracking efficiencies + corrections
+ TH2D* h2TrackEff_zv_pt = AlidNdPtHelper::GenerateCorrMatrix(h2RecPrimTrack_zv_pt,h2GenPrimTrack_zv_pt,"h2TrackEff_zv_pt");
+ TH2D* h2TrackCorr_zv_pt = AlidNdPtHelper::GenerateCorrMatrix(h2GenPrimTrack_zv_pt,h2RecPrimTrack_zv_pt,"h2TrackCorr_zv_pt");
+ TH2D* h2TrackEff_zv_eta = AlidNdPtHelper::GenerateCorrMatrix(h2RecPrimTrack_zv_eta,h2GenPrimTrack_zv_eta,"h2TrackEff_zv_eta");
+ TH2D* h2TrackCorr_zv_eta = AlidNdPtHelper::GenerateCorrMatrix(h2GenPrimTrack_zv_eta,h2RecPrimTrack_zv_eta,"h2TrackCorr_zv_eta");
+ TH2D* h2TrackEff_pt_eta = AlidNdPtHelper::GenerateCorrMatrix(h2RecPrimTrack_pt_eta,h2GenPrimTrack_pt_eta,"h2TrackEff_pt_eta");
+ TH2D* h2TrackCorr_pt_eta = AlidNdPtHelper::GenerateCorrMatrix(h2GenPrimTrack_pt_eta,h2RecPrimTrack_pt_eta,"h2TrackCorr_pt_eta");
+
+
+ TH1D* h1TrackEff_zv = AlidNdPtHelper::GenerateCorrMatrix(h1RecPrimTrack_zv,h1GenPrimTrack_zv,"h1TrackEff_zv");
+ TH1D* h1TrackCorr_zv = AlidNdPtHelper::GenerateCorrMatrix(h1GenPrimTrack_zv,h1RecPrimTrack_zv,"h1TrackCorr_zv");
+ TH1D* h1TrackEff_pt = AlidNdPtHelper::GenerateCorrMatrix(h1RecPrimTrack_pt_Rebin,h1GenPrimTrack_pt_Rebin,"h1TrackEff_pt");
+ TH1D* h1TrackCorr_pt = AlidNdPtHelper::GenerateCorrMatrix(h1GenPrimTrack_pt_Rebin,h1RecPrimTrack_pt_Rebin,"h1TrackCorr_pt");
+ TH1D* h1TrackEff_eta = AlidNdPtHelper::GenerateCorrMatrix(h1RecPrimTrack_eta,h1GenPrimTrack_eta,"h1TrackEff_eta");
+ TH1D* h1TrackCorr_eta = AlidNdPtHelper::GenerateCorrMatrix(h1GenPrimTrack_eta,h1RecPrimTrack_eta,"h1TrackCorr_eta");
+ CorrMatr->Add(h2TrackEff_zv_pt);
+ CorrMatr->Add(h2TrackCorr_zv_pt);
+ CorrMatr->Add(h2TrackEff_zv_eta);
+ CorrMatr->Add(h2TrackCorr_zv_eta);
+ CorrMatr->Add(h2TrackEff_pt_eta);
+ CorrMatr->Add(h2TrackCorr_pt_eta);
+ CorrMatr->Add(h1TrackEff_zv);
+ CorrMatr->Add(h1TrackCorr_zv);
+ CorrMatr->Add(h1TrackEff_pt);
+ CorrMatr->Add(h1TrackCorr_pt);
+ CorrMatr->Add(h1TrackEff_eta);
+ CorrMatr->Add(h1TrackCorr_eta);
+
+ // scale the secondaries before calculating correction matrices
+ for (Long64_t i = 0; i < fRecSecTrackMatrixScaled->GetNbins(); i++) {
+ Int_t c[3];
+ Double_t val = fRecSecTrackMatrixScaled->GetBinContent(i,c);
+ Double_t err = fRecSecTrackMatrixScaled->GetBinError(i);
+ Double_t pt = fRecSecTrackMatrixScaled->GetAxis(1)->GetBinCenter(c[1]);
+ Double_t scale = GetStrangenessCorrFactor(pt,sscale);
+// Double_t scale = AlidNdPtHelper::GetStrangenessCorrFactor(pt);
+ fRecSecTrackMatrixScaled->SetBinContent(c,val*scale);
+ fRecSecTrackMatrixScaled->SetBinError(c,err*scale);
+ }
+
+ // for correct determination of secondaries contamination, also the total total tracks have to be scaled
+ // this is done by taking primaries and adding the scaled secondaries
+ fRecTrackMatrixScaled->Add(fRecSecTrackMatrixScaled);
+
+ fRecSecTrackMatrixScaled->GetAxis(0)->SetRangeUser(-zVert, zVert-0.01);//zVer
+ fRecSecTrackMatrixScaled->GetAxis(2)->SetRangeUser(-eta, eta-0.01);//eta
+
+ TH3D* h3RecSecTrackScaled = fRecSecTrackMatrixScaled->Projection(0,1,2)->Clone("h3RecSecTrackScaled");
+ TH2D* h2RecSecTrackScaled_zv_pt = fRecSecTrackMatrixScaled->Projection(0,1)->Clone("h2RecSecTrackScaled_zv_pt");
+ TH2D* h2RecSecTrackScaled_zv_eta = fRecSecTrackMatrixScaled->Projection(0,2)->Clone("h2RecSecTrackScaled_zv_eta");
+ TH2D* h2RecSecTrackScaled_pt_eta = fRecSecTrackMatrixScaled->Projection(1,2)->Clone("h2RecSecTrackScaled_pt_eta");
+ TH1D* h1RecSecTrackScaled_zv = fRecSecTrackMatrixScaled->Projection(0)->Clone("h1RecSecTrackScaled_zv");
+ TH1D* h1RecSecTrackScaled_pt = fRecSecTrackMatrixScaled->Projection(1)->Clone("h1RecSecTrackScaled_pt");
+ TH1D* h1RecSecTrackScaled_eta = fRecSecTrackMatrixScaled->Projection(2)->Clone("h1RecSecTrackScaled_eta");
+
+ ContHist->Add(h3RecSecTrackScaled);
+ ContHist->Add(h2RecSecTrackScaled_zv_pt);
+ ContHist->Add(h2RecSecTrackScaled_zv_eta);
+ ContHist->Add(h2RecSecTrackScaled_pt_eta);
+ ContHist->Add(h1RecSecTrackScaled_zv);
+ ContHist->Add(h1RecSecTrackScaled_pt);
+ ContHist->Add(h1RecSecTrackScaled_eta);
+
+ fRecTrackMatrixScaled->GetAxis(0)->SetRangeUser(-zVert, zVert-0.01);//zVer
+ fRecTrackMatrixScaled->GetAxis(2)->SetRangeUser(-eta, eta-0.01);//eta
+
+ TH3D* h3RecTrackScaled = fRecTrackMatrixScaled->Projection(0,1,2)->Clone("h3RecTrackScaled");
+ TH2D* h2RecTrackScaled_zv_pt = fRecTrackMatrixScaled->Projection(0,1)->Clone("h2RecTrackScaled_zv_pt");
+ TH2D* h2RecTrackScaled_zv_eta = fRecTrackMatrixScaled->Projection(0,2)->Clone("h2RecTrackScaled_zv_eta");
+ TH2D* h2RecTrackScaled_pt_eta = fRecTrackMatrixScaled->Projection(1,2)->Clone("h2RecTrackScaled_pt_eta");
+ TH1D* h1RecTrackScaled_zv = fRecTrackMatrixScaled->Projection(0)->Clone("h1RecTrackScaled_zv");
+ TH1D* h1RecTrackScaled_pt = fRecTrackMatrixScaled->Projection(1)->Clone("h1RecTrackScaled_pt");
+ TH1D* h1RecTrackScaled_eta = fRecTrackMatrixScaled->Projection(2)->Clone("h1RecTrackScaled_eta");
+
+ ContHist->Add(h3RecTrackScaled);
+ ContHist->Add(h2RecTrackScaled_zv_pt);
+ ContHist->Add(h2RecTrackScaled_zv_eta);
+ ContHist->Add(h2RecTrackScaled_pt_eta);
+ ContHist->Add(h1RecTrackScaled_zv);
+ ContHist->Add(h1RecTrackScaled_pt);
+ ContHist->Add(h1RecTrackScaled_eta);
+
+ // Rebin for corrections (pt)
+ TH1D* h1RecTrackScaled_pt_Rebin = h1RecTrackScaled_pt->Rebin(ptNbins,"h1RecTrackScaled_pt_Rebin",binsPt);
+ TH1D* h1RecSecTrackScaled_pt_Rebin = h1RecSecTrackScaled_pt->Rebin(ptNbins,"h1RecSecTrackScaled_pt_Rebin",binsPt);
+ ContHist->Add(h1RecTrackScaled_pt_Rebin);
+ ContHist->Add(h1RecSecTrackScaled_pt_Rebin);
+
+ // create histograms for secondaries contamination and correction
+
+ TH2D* h2SecCont_zv_pt = AlidNdPtHelper::GenerateCorrMatrix(h2RecSecTrackScaled_zv_pt,h2RecTrackScaled_zv_pt,"h2SecCont_zv_pt");
+ TH2D* h2SecCorr_zv_pt = AlidNdPtHelper::GenerateContCorrMatrix(h2RecSecTrackScaled_zv_pt,h2RecTrackScaled_zv_pt,"h2SecCorr_zv_pt");
+ TH2D* h2SecCont_zv_eta = AlidNdPtHelper::GenerateCorrMatrix(h2RecSecTrackScaled_zv_eta,h2RecTrackScaled_zv_eta,"h2SecCont_zv_eta");
+ TH2D* h2SecCorr_zv_eta = AlidNdPtHelper::GenerateContCorrMatrix(h2RecSecTrackScaled_zv_eta,h2RecTrackScaled_zv_eta,"h2SecCorr_zv_eta");
+ TH2D* h2SecCont_pt_eta = AlidNdPtHelper::GenerateCorrMatrix(h2RecSecTrackScaled_pt_eta,h2RecTrackScaled_pt_eta,"h2SecCont_pt_eta");
+ TH2D* h2SecCorr_pt_eta = AlidNdPtHelper::GenerateContCorrMatrix(h2RecSecTrackScaled_pt_eta,h2RecTrackScaled_pt_eta,"h2SecCorr_pt_eta");
+ TH1D* h1SecCont_zv = AlidNdPtHelper::GenerateCorrMatrix(h1RecSecTrackScaled_zv,h1RecTrackScaled_zv,"h1SecCont_zv");
+ TH1D* h1SecCorr_zv = AlidNdPtHelper::GenerateContCorrMatrix(h1RecSecTrackScaled_zv,h1RecTrackScaled_zv,"h1SecCorr_zv");
+ TH1D* h1SecCont_pt = AlidNdPtHelper::GenerateCorrMatrix(h1RecSecTrackScaled_pt_Rebin,h1RecTrackScaled_pt_Rebin,"h1SecCont_pt");
+ TH1D* h1SecCorr_pt = AlidNdPtHelper::GenerateContCorrMatrix(h1RecSecTrackScaled_pt_Rebin,h1RecTrackScaled_pt_Rebin,"h1SecCorr_pt");
+ TH1D* h1SecCont_eta = AlidNdPtHelper::GenerateCorrMatrix(h1RecSecTrackScaled_eta,h1RecTrackScaled_eta,"h1SecCont_eta");
+ TH1D* h1SecCorr_eta = AlidNdPtHelper::GenerateContCorrMatrix(h1RecSecTrackScaled_eta,h1RecTrackScaled_eta,"h1SecCorr_eta");
+
+ CorrMatr->Add(h2SecCont_zv_pt);
+ CorrMatr->Add(h2SecCorr_zv_pt);
+ CorrMatr->Add(h2SecCont_zv_eta);
+ CorrMatr->Add(h2SecCorr_zv_eta);
+ CorrMatr->Add(h2SecCont_pt_eta);
+ CorrMatr->Add(h2SecCorr_pt_eta);
+ CorrMatr->Add(h1SecCont_zv);
+ CorrMatr->Add(h1SecCorr_zv);
+ CorrMatr->Add(h1SecCont_pt);
+ CorrMatr->Add(h1SecCorr_pt);
+ CorrMatr->Add(h1SecCont_eta);
+ CorrMatr->Add(h1SecCorr_eta);
+
+ //vertex distribution for events with no vertex
+ fGenEventMatrix->GetAxis(0)->SetRange();
+ fGenEventMatrix->GetAxis(1)->SetRange(1,1);
+ TH1D* h1GenEventMatrix_bin0_zv = (TH1D*) fGenEventMatrix->Projection(0)->Clone("h1GenEventMatrix_bin0_zv");
+ ContHist->Add(h1GenEventMatrix_bin0_zv);
+
+ fTriggerEventMatrix->GetAxis(0)->SetRange();
+ fTriggerEventMatrix->GetAxis(1)->SetRange(1,1);
+ TH1D* h1TriggerEventMatrix_bin0_zv = (TH1D*) fTriggerEventMatrix->Projection(0)->Clone("h1TriggerEventMatrix_bin0_zv");
+ ContHist->Add(h1TriggerEventMatrix_bin0_zv);
+
+
+ fRecEventMatrix->GetAxis(0)->SetRange();
+ fRecEventMatrix->GetAxis(1)->SetRange();
+ TH1D* h1RecEventMatrix_zv = (TH1D*) fRecEventMatrix->Projection(0)->Clone("h1RecEventMatrix_zv");
+ h1RecEventMatrix_zv->Scale(1./h1RecEventMatrix_zv->Integral());
+ //ContHist->Add(h1TriggerEventMatrix_zv);
+
+ TH1D* h1TriggerEff_bin0_zv = AlidNdPtHelper::GenerateCorrMatrix(h1TriggerEventMatrix_bin0_zv,h1GenEventMatrix_bin0_zv,"h1TriggerEff_bin0_zv");
+ TH1D* h1TriggerCorr_bin0_zv = AlidNdPtHelper::GenerateCorrMatrix(h1GenEventMatrix_bin0_zv,h1TriggerEventMatrix_bin0_zv,"h1TriggerCorr_bin0_zv");
+ CorrMatr->Add(h1TriggerEff_bin0_zv);
+ CorrMatr->Add(h1TriggerCorr_bin0_zv);
+
+ TH1D* h1Ratio_zv = (TH1D*) h1GenEventMatrix_bin0_zv->Clone("h1Ratio_zv");
+ h1Ratio_zv->Scale(1./h1Ratio_zv->Integral());
+ h1Ratio_zv->Divide(h1RecEventMatrix_zv);
+ CorrMatr->Add(h1Ratio_zv);
+
+
+ // aded to correct sperately for zvert shape of triggered and untriggered bin0 events
+ fRecEventMatrix->GetAxis(0)->SetRange();
+ fRecEventMatrix->GetAxis(1)->SetRange();
+ fTriggerEventMatrix->GetAxis(1)->SetRangeUser(0,0);
+ fGenEventMatrix->GetAxis(1)->SetRangeUser(0,0);
+
+ TH1D* rec_zv = fRecEventMatrix->Projection(0)->Clone("rec_zv");
+ TH1D* trig0_zv = fTriggerEventMatrix->Projection(0)->Clone("trig0_zv");
+ TH1D* corr_shape_trig0_zv = AlidNdPtHelper::GenerateCorrMatrix(trig0_zv,rec_zv,"corr_shape_trig0_zv");
+ CorrMatr->Add(corr_shape_trig0_zv);
+
+ TH1D* gen0_zv = fGenEventMatrix->Projection(0)->Clone("gen0_zv");
+ TH1D* gen0notrig_zv = gen0_zv->Clone("gen0notrig_zv");
+ gen0notrig_zv->Add(trig0_zv,-1.);
+ TH1D* corr_shape_notrig0_zv = AlidNdPtHelper::GenerateCorrMatrix(gen0notrig_zv,rec_zv,"corr_shape_notrig0_zv");
+ CorrMatr->Add(corr_shape_notrig0_zv);
+
+
+ // efficienfy and correction for THnSparse
+ THnSparse* hSRecSecTrackMatrixScaled = AlidNdPtHelper::RebinTHnSparse(fRecSecTrackMatrixScaled,hSTrackSecCorr,"hSRecSecTrackMatrixScaled");
+ THnSparse* hSRecTrackMatrixScaled = AlidNdPtHelper::RebinTHnSparse(fRecTrackMatrixScaled,hSTrackSecCorr,"hSRecTrackMatrixScaled");
+ THnSparse* hSRecPrimTrackMatrix = AlidNdPtHelper::RebinTHnSparse(fRecPrimTrackMatrix,hSTrackEffCorr,"hSRecPrimTrackMatrix");
+ THnSparse* hSGenPrimTrackMatrix = AlidNdPtHelper::RebinTHnSparse(fGenPrimTrackMatrix,hSTrackEffCorr,"hSGenPrimTrackMatrix");
+ ContHist->Add(hSRecSecTrackMatrixScaled);
+ ContHist->Add(hSRecTrackMatrixScaled);
+ ContHist->Add(hSRecPrimTrackMatrix);
+ ContHist->Add(hSGenPrimTrackMatrix);
+
+ THnSparse* hSTrackEff = AlidNdPtHelper::GenerateCorrMatrix(hSRecPrimTrackMatrix,hSGenPrimTrackMatrix,"hSTrackEff");
+ THnSparse* hSTrackCorr = AlidNdPtHelper::GenerateCorrMatrix(hSGenPrimTrackMatrix,hSRecPrimTrackMatrix,"hSTrackCorr");
+ THnSparse* hSSecCont = AlidNdPtHelper::GenerateCorrMatrix(hSRecSecTrackMatrixScaled,hSRecTrackMatrixScaled,"hSSecCont");
+ THnSparse* hSSecCorr = AlidNdPtHelper::GenerateContCorrMatrix(hSRecSecTrackMatrixScaled,hSRecTrackMatrixScaled,"hSSecCorr");
+ CorrMatr->Add(hSTrackEff);
+ CorrMatr->Add(hSTrackCorr);
+ CorrMatr->Add(hSSecCont);
+ CorrMatr->Add(hSSecCorr);
+
+ // create th3 from thnsparse, used for corrections
+ TH3D* h3RecPrimTrack_Rebin = hSRecPrimTrackMatrix->Projection(0,1,2)->Clone("h3RecPrimTrack_Rebin");
+ TH3D* h3GenPrimTrack_Rebin = hSGenPrimTrackMatrix->Projection(0,1,2)->Clone("h3GenPrimTrack_Rebin");
+ TH3D* h3RecSecTrackScaled_Rebin = hSRecSecTrackMatrixScaled->Projection(0,1,2)->Clone("h3RecSecTrackScaled_Rebin");
+ TH3D* h3RecTrackScaled_Rebin = hSRecTrackMatrixScaled->Projection(0,1,2)->Clone("h3RecTrackScaled_Rebin");
+
+ TH3D* h3TrackEff = AlidNdPtHelper::GenerateCorrMatrix(h3RecPrimTrack_Rebin,h3GenPrimTrack_Rebin,"h3TrackEff");
+ TH3D* h3TrackCorr = AlidNdPtHelper::GenerateCorrMatrix(h3GenPrimTrack_Rebin,h3RecPrimTrack_Rebin,"h3TrackCorr");
+ TH3D* h3SecCont = AlidNdPtHelper::GenerateCorrMatrix(h3RecSecTrackScaled_Rebin,h3RecTrackScaled_Rebin,"h3SecCont");
+ TH3D* h3SecCorr = AlidNdPtHelper::GenerateContCorrMatrix(h3RecSecTrackScaled_Rebin,h3RecTrackScaled_Rebin,"h3SecCorr");
+ CorrMatr->Add(h3TrackEff);
+ CorrMatr->Add(h3TrackCorr);
+ CorrMatr->Add(h3SecCont);
+ CorrMatr->Add(h3SecCorr);
+
+ // check for trigger/vertex bias on track level
+ THnSparse* hSRecTrackEventMatrix = (THnSparse*) obj->GetRecTrackEventMatrix()->Clone("hSRecTrackEventMatrix");
+ THnSparse* hSGenTrackEventMatrix = (THnSparse*) obj->GetGenTrackEventMatrix()->Clone("hSGenTrackEventMatrix");
+ THnSparse* hSTriggerTrackEventMatrix = (THnSparse*) obj->GetTriggerTrackEventMatrix()->Clone("hSTriggerTrackEventMatrix");
+
+ hSRecTrackEventMatrix->GetAxis(0)->SetRangeUser(-zVert, zVert-0.01);//zVer
+ hSRecTrackEventMatrix->GetAxis(2)->SetRangeUser(-eta, eta-0.01);//eta
+ hSGenTrackEventMatrix->GetAxis(0)->SetRangeUser(-zVert, zVert-0.01);//zVer
+ hSGenTrackEventMatrix->GetAxis(2)->SetRangeUser(-eta, eta-0.01);//eta
+ hSTriggerTrackEventMatrix->GetAxis(0)->SetRangeUser(-zVert, zVert-0.01);//zVer
+ hSTriggerTrackEventMatrix->GetAxis(2)->SetRangeUser(-eta, eta-0.01);//eta
+
+
+ TH1D* h1TriggerBiasCorr_zv = AlidNdPtHelper::GenerateCorrMatrix(hSTriggerTrackEventMatrix->Projection(0),hSGenTrackEventMatrix->Projection(0),"h1TriggerBiasCorr_zv");
+ TH1D* h1TriggerBiasCorr_pt = AlidNdPtHelper::GenerateCorrMatrix(hSTriggerTrackEventMatrix->Projection(1),hSGenTrackEventMatrix->Projection(1),"h1TriggerBiasCorr_pt");
+ TH1D* h1TriggerBiasCorr_eta = AlidNdPtHelper::GenerateCorrMatrix(hSTriggerTrackEventMatrix->Projection(2),hSGenTrackEventMatrix->Projection(2),"h1TriggerBiasCorr_eta");
+
+ TH1D* h1VertexBiasCorr_zv = AlidNdPtHelper::GenerateCorrMatrix(hSRecTrackEventMatrix->Projection(0),hSTriggerTrackEventMatrix->Projection(0),"h1VertexBiasCorr_zv");
+ TH1D* h1VertexBiasCorr_pt = AlidNdPtHelper::GenerateCorrMatrix(hSRecTrackEventMatrix->Projection(1),hSTriggerTrackEventMatrix->Projection(1),"h1VertexBiasCorr_pt");
+ TH1D* h1VertexBiasCorr_eta = AlidNdPtHelper::GenerateCorrMatrix(hSRecTrackEventMatrix->Projection(2),hSTriggerTrackEventMatrix->Projection(2),"h1VertexBiasCorr_eta");
+
+ ContHist->Add(h1TriggerBiasCorr_zv);
+ ContHist->Add(h1TriggerBiasCorr_pt);
+ ContHist->Add(h1TriggerBiasCorr_eta);
+ ContHist->Add(h1VertexBiasCorr_zv);
+ ContHist->Add(h1VertexBiasCorr_pt);
+ ContHist->Add(h1VertexBiasCorr_eta);
+
+
+
+ // plot pictures and save to gifdir
+ for (i=0; i < CorrMatr->LastIndex(); i++) {
+ TCanvas* ctmp = PlotHist(CorrMatr->At(i),idstring);
+ if (gifdir && ctmp) {
+ TString gif(gifdir);
+ gif += '/';
+ gif += ctmp->GetName();
+ gif += ".gif";
+ ctmp->SaveAs(gif.Data(),"gif");
+ delete ctmp;
+ }
+ }
+ for (i=0; i < ContHist->LastIndex(); i++) {
+ TCanvas* ctmp = PlotHist(ContHist->At(i),idstring);
+ if (gifdir && ctmp) {
+ TString gif(gifdir);
+ gif += '/';
+ gif += ctmp->GetName();
+ gif += ".gif";
+ ctmp->SaveAs(gif.Data(),"gif");
+ delete ctmp;
+ }
+ }
+
+ // save all correction matrices and control histograms to file
+ if (!outfile) { return; }
+ TFile *out = TFile::Open(outfile,"RECREATE");
+ CorrMatr->Write();
+ ContHist->Write();
+ out->Close();
+
+ return MCReconstructedEvents;
+
+}
+
+
+//_____________________________________________________________________________
+Double_t GetStrangenessCorrFactor(Double_t pt, Double_t s)
+{
+ // data driven correction factor for secondaries (PbPb)
+
+ if (pt <= 0.17) return 1.0;
+ if (pt <= 0.4) return GetLinearInterpolationValue(0.17,1.0,0.4,1.07, pt);
+ if (pt <= 0.6) return GetLinearInterpolationValue(0.4,1.07,0.6,1.25, pt);
+ if (pt <= 1.2) return GetLinearInterpolationValue(0.6,1.25,1.2,1.5, pt);
+ return 1.5;
+}
+
+
+//___________________________________________________________________________
+Double_t GetLinearInterpolationValue(const Double_t x1,const Double_t y1,const Double_t x2,const Double_t y2, const Double_t pt)
+{
+ //
+ // linear interpolation
+ //
+ return ((y2-y1)/(x2-x1))*pt+(y2-(((y2-y1)/(x2-x1))*x2));
+}
+
+//___________________________________________________________________________
+TCanvas* PlotHist(TObject* hobj, const char* label=0)
+{
+ TH1* h = dynamic_cast<TH1*>(hobj);
+ if (!h) return 0;
+ if (h->GetDimension() > 2) return 0;
+ h->SetStats(0);
+ if ( TString(h->GetName()).Contains("Events")) { h->SetStats(1); }
+ TString t(label);
+ if (label) t += "_";
+ t += h->GetName();
+ h->SetTitle(t.Data());
+ TCanvas* c = new TCanvas(t.Data(),t.Data());
+ if (h->GetDimension() >= 1) {
+ TString xlabel(h->GetXaxis()->GetTitle());
+ if (xlabel.Contains("Pt")) { c->SetLogx(); h->GetXaxis()->SetRangeUser(0.1 , 100.); }
+ }
+ if (h->GetDimension() == 1) {
+ if (xlabel.Contains("p_{T}")) { c->SetLogx(); c->SetLogy(); h->GetXaxis()->SetRangeUser(0.1 , 100.); }
+ }
+ if (h->GetDimension() == 2) {
+ TString ylabel(h->GetYaxis()->GetTitle());
+ if (ylabel.Contains("Pt")) { c->SetLogy(); h->GetYaxis()->SetRangeUser(0.1 , 100.); }
+ if (ylabel.Contains("p_{T}")) { c->SetLogy(); h->GetYaxis()->SetRangeUser(0.1 , 100.); }
+ h->Draw("COLZ");
+ }
+ if (h->GetDimension() == 1) {
+ h->Draw();
+ }
+ return c;
+
+}
+
+Int_t CheckLoadLibrary(const char* library)
+{
+ // checks if a library is already loaded, if not loads the library
+
+ if (strlen(gSystem->GetLibraries(Form("%s.so", library), "", kFALSE)) > 0)
+ return 1;
+
+ return gSystem->Load(library);
+}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff