-extractFlowVZERO(Int_t itech=0,Int_t ibin = 3,Int_t step = 0,Int_t arm=2,Float_t pTh = 0.9,Int_t charge=0,Int_t addbins=0){
- TCanvas *can1 = new TCanvas("cV0Acheck","cV0Acheck");
+TFile *fo = NULL;
+TF1 *fPsi = NULL;
+
+Bool_t kLib = kFALSE;
+Bool_t kVZEROrescorr = kTRUE; // VZERO resolution corrections
+Bool_t kNUAcorr = kTRUE; // NUA corrections
+Bool_t kNUOcorr = kFALSE; // Not Uniform Occupancy (TOF) corrections
+Bool_t kPIDcorr = kFALSE; // PID corrections
+Bool_t kFEEDcorr = kFALSE; // antiproton feed-down corrections
+Bool_t kCleanMemory = kTRUE; // if kFALSE take care of the large numbers of TCanvases
+
+TH1D *hNUO[8]; // NUO corrections
+
+void LoadLib();
+void extractFlowVZERO(Int_t icentr,const char *type="",Int_t arm=2,Float_t pTh=0.8,Bool_t isMC=kFALSE,Int_t addbin=0);
+TProfile *extractFlowVZEROsingle(Int_t icentr,Int_t spec,Int_t arm=2,Bool_t isMC=kFALSE,Float_t pTh=0.9,Int_t addbin=0,const char *nameSp="",Float_t detMin=0,Float_t detMax=1,Int_t chMin=-1,Int_t chMax=1);
+void compareTPCTOF(Int_t icentr,Int_t spec,Int_t arm=2,Float_t pTh=0.9,Int_t addbin=0);
+void plotQApid(Int_t ic,Float_t pt,Int_t addbin=0);
+
+void LoadLib(){
+ if(! kLib){
+ gSystem->Load("libVMC");
+ gSystem->Load("libPhysics");
+ gSystem->Load("libTree");
+ gSystem->Load("libSTEERBase");
+ gSystem->Load("libANALYSIS");
+ gSystem->Load("libAOD");
+ gSystem->Load("libESD");
+ gSystem->Load("libANALYSIS");
+ gSystem->Load("libANALYSISalice");
+ gSystem->Load("libCORRFW");
+ gSystem->Load("libNetx");
+ gSystem->Load("libPWGflowBase");
+ gSystem->Load("libPWGflowTasks");
+
+ kLib = kTRUE;
+ }
+}
-/*
-read outVZEROv2.root or outVZEROv3.root files
+void extractFlowVZERO(Int_t icentr,const char *type,Int_t arm,Float_t pTh,Bool_t isMC,Int_t addbin){
+ LoadLib();
-itech=0 TPC stand alone PID and selection
-itech=1 TPC stand alone PID but TOF track selection
-itech=2 TPC&TOF PID (TOF strictly required)
-itech=3 TPC|TOF PID (the same of before but using TPC stand alone when TOF not available)
+ char name[100];
+ snprintf(name,100,"AnalysisResults%s.root",type);
+ if(!fo) fo = new TFile(name);
-ibin = centrality bin
+ new TCanvas();
-step = species (0=all charges, 1=pi, 2=K, 3=p, 4=e, 5=d, 6=t, 7=3He
+ Int_t cMin[] = {0,5,10,20,30,40,50,60,70};
+ Int_t cMax[] = {5,10,20,30,40,50,60,70,80};
-arm = armonic 2 (v2) or 3 (v3)
+ if(kNUOcorr){ // Compute correction for NUO in TOF
+ compareTPCTOF(icentr,0,arm,pTh,addbin);
+// compareTPCTOF(icentr,1,arm,pTh,addbin);
+// compareTPCTOF(icentr,2,arm,pTh,addbin);
+// compareTPCTOF(icentr,3,arm,pTh,addbin);
+// compareTPCTOF(icentr,4,arm,pTh,addbin);
+ }
-pTh = probability threshold = 0.6 , 0.8 , 0.9 , 0.95
+ TProfile *pAll;
+ pAll=extractFlowVZEROsingle(icentr,0,arm,0,pTh,addbin,"all",0,1);
+ pAll->SetMarkerStyle(24);
+ TProfile *pPiTOF,*pPiTPC,*pPiTPC2;
+ pPiTOF=extractFlowVZEROsingle(icentr,1,arm,0,pTh,addbin,"piTOF",1,1);
+ pPiTPC=extractFlowVZEROsingle(icentr,1,arm,0,pTh,addbin,"piTPC",0,0);
+ pPiTPC2=extractFlowVZEROsingle(icentr,1,arm,0,pTh,addbin,"piTPC2",2,2);
+ pPiTPC->Add(pPiTPC2);
+
+ TH1D *hPi = pPiTOF->ProjectionX("hPi");
+ hPi->SetLineColor(4);
+ hPi->SetMarkerColor(4);
+ hPi->SetMarkerStyle(20);
+ for(Int_t i=1;i <=hPi->GetNbinsX();i++){
+ Float_t x = hPi->GetBinCenter(i);
+ if(x < 0.2){
+ hPi->SetBinContent(i,0);
+ hPi->SetBinError(i,0);
+ }
+ else if(x < 0.5){
+ hPi->SetBinContent(i,pPiTPC->GetBinContent(i));
+ hPi->SetBinError(i,pPiTPC->GetBinError(i));
+ }
+ else{
+ if(kNUOcorr){
+ hPi->SetBinContent(i,pPiTOF->GetBinContent(i) + hNUO[0]->GetBinContent(i));
+ hPi->SetBinError(i,pPiTOF->GetBinError(i));
+ }
+ else{
+ hPi->SetBinContent(i,pPiTOF->GetBinContent(i));
+ hPi->SetBinError(i,pPiTOF->GetBinError(i));
+ }
+ }
+ }
-charge = 1(pos), -1(neg), 0(both)
+ TProfile *pElTOF,*pElTPC,*pElTPC2;
+ pElTOF=extractFlowVZEROsingle(icentr,4,arm,0,pTh,addbin,"piTOF",1,1);
+ pElTPC=extractFlowVZEROsingle(icentr,4,arm,0,pTh,addbin,"piTPC",0,0);
+ pElTPC2=extractFlowVZEROsingle(icentr,4,arm,0,pTh,addbin,"piTPC2",2,2);
+ pElTPC->Add(pElTPC2);
+
+ TH1D *hEl = pElTOF->ProjectionX("hEl");
+ hEl->SetLineColor(6);
+ hEl->SetMarkerColor(6);
+ hEl->SetMarkerStyle(20);
+ for(Int_t i=1;i <=hEl->GetNbinsX();i++){
+ Float_t x = hEl->GetBinCenter(i);
+ if(x < 0.2){
+ hEl->SetBinContent(i,0);
+ hEl->SetBinError(i,0);
+ }
+ else if(x < 0.3){
+ hEl->SetBinContent(i,pElTPC->GetBinContent(i));
+ hEl->SetBinError(i,pElTPC->GetBinError(i));
+ }
+ else{
+ if(kNUOcorr){
+ hEl->SetBinContent(i,pElTOF->GetBinContent(i) + hNUO[0]->GetBinContent(i));
+ hEl->SetBinError(i,pElTOF->GetBinError(i));
+ }
+ else{
+ hEl->SetBinContent(i,pElTOF->GetBinContent(i));
+ hEl->SetBinError(i,pElTOF->GetBinError(i));
+ }
+ }
+ }
-addbins = to merge more centrality bin (i.e. ibin = 2, addbins = 3 merge 2,3,4,5 centrality bins) - preliminary version!!!!!!
+ TProfile *pKTOF,*pKTPC,*pKTPC2;
+ pKTOF=extractFlowVZEROsingle(icentr,2,arm,0,pTh,addbin,"kaTOF",1,1);
+ pKTPC=extractFlowVZEROsingle(icentr,2,arm,0,pTh,addbin,"kaTPC",0,0);
+ pKTPC2=extractFlowVZEROsingle(icentr,2,arm,0,pTh,addbin,"kaTPC2",2,2);
+ pKTPC->Add(pKTPC2);
+
+ TH1D *hK = pKTOF->ProjectionX("hKa");
+ hK->SetLineColor(1);
+ hK->SetMarkerColor(1);
+ hK->SetMarkerStyle(21);
+ for(Int_t i=1;i <=hK->GetNbinsX();i++){
+ Float_t x = hK->GetBinCenter(i);
+ if(x < 0.25){
+ hK->SetBinContent(i,0);
+ hK->SetBinError(i,0);
+ }
+ else if(x < 0.45){
+ hK->SetBinContent(i,pKTPC->GetBinContent(i));
+ hK->SetBinError(i,pKTPC->GetBinError(i));
+ }
+ else{
+ if(kNUOcorr){
+ hK->SetBinContent(i,pKTOF->GetBinContent(i) + hNUO[0]->GetBinContent(i));
+ hK->SetBinError(i,pKTOF->GetBinError(i));
+ }
+ else{
+ hK->SetBinContent(i,pKTOF->GetBinContent(i));
+ hK->SetBinError(i,pKTOF->GetBinError(i));
+ }
+ }
+ }
-*/
+ TProfile *pPrTOF,*pPrTOF2,*pPrTPC,*pPrTPC2;
+ pPrTOF=extractFlowVZEROsingle(icentr,3,arm,0,pTh,addbin,"prTOF",1,1,-1,-1);
+ pPrTOF2=extractFlowVZEROsingle(icentr,3,arm,0,pTh,addbin,"prTOF2",1,1,-1,1);
+ pPrTPC=extractFlowVZEROsingle(icentr,3,arm,0,pTh,addbin,"prTPC",0,0,-1,-1);
+ pPrTPC2=extractFlowVZEROsingle(icentr,3,arm,0,pTh,addbin,"prTPC2",2,2,-1,-1);
+ pPrTPC->Add(pPrTPC2);
+
+ TH1D *hPr = pPrTOF->ProjectionX("hPr");
+ hPr->SetLineColor(2);
+ hPr->SetMarkerColor(2);
+ hPr->SetMarkerStyle(22);
+ for(Int_t i=1;i <=hPr->GetNbinsX();i++){
+ Float_t x = hPr->GetBinCenter(i);
+ if(x < 0.3){
+ hPr->SetBinContent(i,0);
+ hPr->SetBinError(i,0);
+ }
+ else if(x < 1.0){
+ hPr->SetBinContent(i,pPrTPC->GetBinContent(i));
+ hPr->SetBinError(i,pPrTPC->GetBinError(i));
+ }
+ else{
+ if(x < 3){
+ if(kNUOcorr){
+ hPr->SetBinContent(i,pPrTOF->GetBinContent(i) + hNUO[0]->GetBinContent(i));
+ hPr->SetBinError(i,pPrTOF->GetBinError(i));
+ }
+ else{
+ hPr->SetBinContent(i,pPrTOF->GetBinContent(i));
+ hPr->SetBinError(i,pPrTOF->GetBinError(i));
+ }
+ }
+ else{
+ if(kNUOcorr){
+ hPr->SetBinContent(i,pPrTOF2->GetBinContent(i) + hNUO[0]->GetBinContent(i));
+ hPr->SetBinError(i,pPrTOF2->GetBinError(i));
+ }
+ else{
+ hPr->SetBinContent(i,pPrTOF2->GetBinContent(i));
+ hPr->SetBinError(i,pPrTOF2->GetBinError(i));
+ }
+ }
+ }
+ }
+
+ pAll->Draw();
+ hPi->Draw("SAME");
+ hK->Draw("SAME");
+ hPr->Draw("SAME");
- // load libraries
- gSystem->Load("libANALYSIS");
- gSystem->Load("libANALYSISalice");
- gSystem->Load("libCORRFW.so");
- // get objects
- char filein[100];
- sprintf(filein,"outVZEROv%i.root",arm);
- TFile *f=new TFile(filein);
- sprintf(filein,"contVZEROv%i",arm);
- TList *l = f->Get(filein);
- l->ls();
- AliCFContainer *c = l->At(0);
- AliCFContainer *c3 = l->At(1);
- TProfile *p1 = l->At(2);
- TProfile *p2 = l->At(3);
- TProfile *p3 = l->At(4);
- Int_t iVar[2] = {1,3};
+ char name[100];
- Int_t iVarPsi[1] = {5};
- /* 0=centrality , 1= cos(arm*deltaphi) , 2=charge , 3=pt , 4=probability , 5=EP , 6=PIDmask*/
- Double_t iMin[7] = {ibin,-1,-1.5,0,pTh+0.00001,-3.14,0};
- Double_t iMax[7] = {ibin+addbins,1,1.5,20,1.1,3.14,1};
- char *iTechName[4] = {"tpc","tpcInTof","tof","tpcORtof"};
+ // PID correction
+ if(kPIDcorr){
+ TFile *fPidTOF = new TFile("$ALICE_ROOT/PWGCF/FLOW/other/BayesianPIDcontTPCTOF.root");
+ TFile *fPidTPC = new TFile("$ALICE_ROOT/PWGCF/FLOW/other/BayesianPIDcontTPC.root");
+ // pi histos
+ sprintf(name,"Pi_IDas_Picentr%i_pth%4.2f",icentr,pTh);
+ TH1D *hPidPiPi=(TH1D *) fPidTOF->Get(name);
+ sprintf(name,"Pi_IDas_Elcentr%i_pth%4.2f",icentr,pTh);
+ TH1D *hPidPiEl=(TH1D *) fPidTOF->Get(name);
+ sprintf(name,"Pi_IDas_Kacentr%i_pth%4.2f",icentr,pTh);
+ TH1D *hPidPiKa=(TH1D *) fPidTOF->Get(name);
+ sprintf(name,"Pi_IDas_Prcentr%i_pth%4.2f",icentr,pTh);
+ TH1D *hPidPiPr=(TH1D *) fPidTOF->Get(name);
+ TH1D *hPidAll = new TH1D(*hPidPiPi);
+ hPidAll->Add(hPidPiKa);
+ hPidAll->Add(hPidPiPr);
+ hPidAll->Add(hPidPiEl);
+ hPidPiPi->Divide(hPidAll);
+ hPidPiKa->Divide(hPidAll);
+ hPidPiPr->Divide(hPidAll);
+ hPidPiEl->Divide(hPidAll);
+
+ sprintf(name,"Pi_IDas_Picentr%i_pth%4.2f",icentr,pTh);
+ TH1D *hPidPiPiTPC=(TH1D *) fPidTPC->Get(name);
+ sprintf(name,"Pi_IDas_Elcentr%i_pth%4.2f",icentr,pTh);
+ TH1D *hPidPiElTPC=(TH1D *) fPidTPC->Get(name);
+ sprintf(name,"Pi_IDas_Kacentr%i_pth%4.2f",icentr,pTh);
+ TH1D *hPidPiKaTPC=(TH1D *) fPidTPC->Get(name);
+ sprintf(name,"Pi_IDas_Prcentr%i_pth%4.2f",icentr,pTh);
+ TH1D *hPidPiPrTPC=(TH1D *) fPidTPC->Get(name);
+ hPidAll->Reset();
+ hPidAll->Add(hPidPiPiTPC);
+ hPidAll->Add(hPidPiKaTPC);
+ hPidAll->Add(hPidPiPrTPC);
+ hPidAll->Add(hPidPiElTPC);
+ hPidPiPiTPC->Divide(hPidAll);
+ hPidPiKaTPC->Divide(hPidAll);
+ hPidPiPrTPC->Divide(hPidAll);
+ hPidPiElTPC->Divide(hPidAll);
+
+ // K histos
+ sprintf(name,"Ka_IDas_Picentr%i_pth%4.2f",icentr,pTh);
+ TH1D *hPidKaPi=(TH1D *) fPidTOF->Get(name);
+ sprintf(name,"Ka_IDas_Elcentr%i_pth%4.2f",icentr,pTh);
+ TH1D *hPidKaEl=(TH1D *) fPidTOF->Get(name);
+ sprintf(name,"Ka_IDas_Kacentr%i_pth%4.2f",icentr,pTh);
+ TH1D *hPidKaKa=(TH1D *) fPidTOF->Get(name);
+ sprintf(name,"Ka_IDas_Prcentr%i_pth%4.2f",icentr,pTh);
+ TH1D *hPidKaPr=(TH1D *) fPidTOF->Get(name);
+ hPidAll->Reset();
+ hPidAll->Add(hPidKaPi);
+ hPidAll->Add(hPidKaKa);
+ hPidAll->Add(hPidKaPr);
+ hPidAll->Add(hPidKaEl);
+ hPidKaPi->Divide(hPidAll);
+ hPidKaKa->Divide(hPidAll);
+ hPidKaPr->Divide(hPidAll);
+ hPidKaEl->Divide(hPidAll);
+
+ sprintf(name,"Ka_IDas_Picentr%i_pth%4.2f",icentr,pTh);
+ TH1D *hPidKaPiTPC=(TH1D *) fPidTPC->Get(name);
+ sprintf(name,"Ka_IDas_Elcentr%i_pth%4.2f",icentr,pTh);
+ TH1D *hPidKaElTPC=(TH1D *) fPidTPC->Get(name);
+ sprintf(name,"Ka_IDas_Kacentr%i_pth%4.2f",icentr,pTh);
+ TH1D *hPidKaKaTPC=(TH1D *) fPidTPC->Get(name);
+ sprintf(name,"Ka_IDas_Prcentr%i_pth%4.2f",icentr,pTh);
+ TH1D *hPidKaPrTPC=(TH1D *) fPidTPC->Get(name);
+ hPidAll->Reset();
+ hPidAll->Add(hPidKaPiTPC);
+ hPidAll->Add(hPidKaKaTPC);
+ hPidAll->Add(hPidKaPrTPC);
+ hPidAll->Add(hPidKaElTPC);
+ hPidKaPiTPC->Divide(hPidAll);
+ hPidKaKaTPC->Divide(hPidAll);
+ hPidKaPrTPC->Divide(hPidAll);
+ hPidKaElTPC->Divide(hPidAll);
+
+ // pr histos
+ sprintf(name,"Pr_IDas_Picentr%i_pth%4.2f",icentr,pTh);
+ TH1D *hPidPrPi=(TH1D *) fPidTOF->Get(name);
+ sprintf(name,"Pr_IDas_Elcentr%i_pth%4.2f",icentr,pTh);
+ TH1D *hPidPrEl=(TH1D *) fPidTOF->Get(name);
+ sprintf(name,"Pr_IDas_Kacentr%i_pth%4.2f",icentr,pTh);
+ TH1D *hPidPrKa=(TH1D *) fPidTOF->Get(name);
+ sprintf(name,"Pr_IDas_Prcentr%i_pth%4.2f",icentr,pTh);
+ TH1D *hPidPrPr=(TH1D *) fPidTOF->Get(name);
+ hPidAll->Reset();
+ hPidAll->Add(hPidPrPi);
+ hPidAll->Add(hPidPrKa);
+ hPidAll->Add(hPidPrPr);
+ hPidAll->Add(hPidPrEl);
+ hPidPrPi->Divide(hPidAll);
+ hPidPrKa->Divide(hPidAll);
+ hPidPrPr->Divide(hPidAll);
+ hPidPrEl->Divide(hPidAll);
+
+ sprintf(name,"Pr_IDas_Picentr%i_pth%4.2f",icentr,pTh);
+ TH1D *hPidPrPiTPC=(TH1D *) fPidTPC->Get(name);
+ sprintf(name,"Pr_IDas_Elcentr%i_pth%4.2f",icentr,pTh);
+ TH1D *hPidPrElTPC=(TH1D *) fPidTPC->Get(name);
+ sprintf(name,"Pr_IDas_Kacentr%i_pth%4.2f",icentr,pTh);
+ TH1D *hPidPrKaTPC=(TH1D *) fPidTPC->Get(name);
+ sprintf(name,"Pr_IDas_Prcentr%i_pth%4.2f",icentr,pTh);
+ TH1D *hPidPrPrTPC=(TH1D *) fPidTPC->Get(name);
+ hPidAll->Reset();
+ hPidAll->Add(hPidPrPiTPC);
+ hPidAll->Add(hPidPrKaTPC);
+ hPidAll->Add(hPidPrPrTPC);
+ hPidAll->Add(hPidPrElTPC);
+ hPidPrPiTPC->Divide(hPidAll);
+ hPidPrKaTPC->Divide(hPidAll);
+ hPidPrPrTPC->Divide(hPidAll);
+ hPidPrElTPC->Divide(hPidAll);
+
+ for(Int_t k=1;k <=hPi->GetNbinsX();k++){
+ Float_t pt = hPi->GetBinCenter(k);
+ Float_t xPi=hPi->GetBinContent(k)*hPidPiPi->Interpolate(pt) + hK->GetBinContent(k)*hPidPiKa->Interpolate(pt) + hPr->GetBinContent(k)*hPidPiPr->Interpolate(pt) + hEl->GetBinContent(k)*hPidPiEl->Interpolate(pt);
+ if(pt < 0.5)
+ xPi=hPi->GetBinContent(k)*hPidPiPiTPC->Interpolate(pt) + hK->GetBinContent(k)*hPidPiKaTPC->Interpolate(pt) + hPr->GetBinContent(k)*hPidPiPrTPC->Interpolate(pt) + hEl->GetBinContent(k)*hPidPiElTPC->Interpolate(pt);
+ Float_t xKa=hPi->GetBinContent(k)*hPidKaPi->Interpolate(pt) + hK->GetBinContent(k)*hPidKaKa->Interpolate(pt) + hPr->GetBinContent(k)*hPidKaPr->Interpolate(pt) + hEl->GetBinContent(k)*hPidKaEl->Interpolate(pt);
+ if(pt < 0.45)
+ xKa=hPi->GetBinContent(k)*hPidKaPiTPC->Interpolate(pt) + hK->GetBinContent(k)*hPidKaKaTPC->Interpolate(pt) + hPr->GetBinContent(k)*hPidKaPrTPC->Interpolate(pt) + hEl->GetBinContent(k)*hPidKaElTPC->Interpolate(pt);
+ Float_t xPr=hPi->GetBinContent(k)*hPidPrPi->Interpolate(pt) + hK->GetBinContent(k)*hPidPrKa->Interpolate(pt) + hPr->GetBinContent(k)*hPidPrPr->Interpolate(pt) + hEl->GetBinContent(k)*hPidPrEl->Interpolate(pt);
+ if(pt < 1)
+ xPr=hPi->GetBinContent(k)*hPidPrPiTPC->Interpolate(pt) + hK->GetBinContent(k)*hPidPrKaTPC->Interpolate(pt) + hPr->GetBinContent(k)*hPidPrPrTPC->Interpolate(pt) + hEl->GetBinContent(k)*hPidPrElTPC->Interpolate(pt);
+
+ hPi->SetBinContent(k,hPi->GetBinContent(k)*2 - xPi);
+ hK->SetBinContent(k,hK->GetBinContent(k)*2 - xKa);
+ hPr->SetBinContent(k,hPr->GetBinContent(k)*2 - xPr);
+ }
+ }
- Bool_t kOnlyTPC = kFALSE;
- if(itech==0 && (step!=0)){
- kOnlyTPC = kTRUE;
- }
- else if(itech==1 && (step!=0)){
- iMin[6] = 2;
- iMax[6] = 2;
- }
- else if(itech==2 || itech==1){
- iMin[6] = 1;
- iMax[6] = 1;
+ // antiproton Feed down
+ TProfile *pFromLambda = extractFlowVZEROsingle(icentr,11,arm,0,pTh,addbin,"pFromLambda",1,1);
+ TProfile *piFromK = extractFlowVZEROsingle(icentr,12,arm,0,pTh,addbin,"piFromK",1,1,1,1);
+ TProfile *pFromLambda2 = extractFlowVZEROsingle(icentr,11,arm,0,0.6,addbin,"pFromLambdanoPID",0,1);
+ TProfile *piFromK2 = extractFlowVZEROsingle(icentr,12,arm,0,0.6,addbin,"piFromKnoPID",0,1);
+ TProfile *piFromK3 = extractFlowVZEROsingle(icentr,12,arm,0,0.6,addbin,"piFromKnoPIDtof",1,1);
+
+ TH1D *hFeedSyst = NULL;
+
+ if(kFEEDcorr){
+ hFeedSyst = new TH1D(*hPr);
+ hFeedSyst->SetName("hFeedSyst");
+ hFeedSyst->Reset();
+ for(Int_t k=1;k <=hPr->GetNbinsX();k++){
+ Float_t contam = 3.23174e-01 * TMath::Exp(- 9.46743e-01 * hPr->GetBinCenter(k));
+ Float_t corr = contam * pFromLambda->GetBinContent(k)/(1-contam);
+ Float_t corrErr = contam * pFromLambda->GetBinError(k)/(1-contam);
+ Float_t value = hPr->GetBinContent(k)/(1-contam) - corr;
+ Float_t valueErr = hPr->GetBinError(k)/(1-contam);
+
+ hFeedSyst->SetBinContent(k,hPr->GetBinContent(k) - value);
+ hFeedSyst->SetBinContent(k,sqrt(corrErr*corrErr + valueErr*valueErr - hPr->GetBinError(k)*hPr->GetBinError(k)));
+
+ hPr->SetBinContent(k,value);
+ hPr->SetBinError(k,sqrt(corrErr*corrErr + valueErr*valueErr));
+
+ }
+ hFeedSyst->Divide(hPr);
}
- else{
- iMin[6] = 0;
- iMax[6] = 1;
+
+ // write output
+ snprintf(name,100,"results%03i-%03iv%i_pTh%3.1f%s.root",cMin[icentr],cMax[icentr+addbin],arm,pTh,type);
+ TFile *fout = new TFile(name,"RECREATE");
+ pAll->ProjectionX()->Write();
+ hPi->Write();
+ hK->Write();
+ hPr->Write();
+ if(isMC){
+ TH1D *pTmp = extractFlowVZEROsingle(icentr,0,arm,1,pTh,addbin,"allMC",1,1,-1,1)->ProjectionX();
+ pTmp->SetLineColor(6);
+ pTmp->SetMarkerColor(6);
+ pTmp->SetMarkerStyle(24);
+ pTmp->Write();
+ pTmp = extractFlowVZEROsingle(icentr,1,arm,1,pTh,addbin,"piMC",1,1,-1,1)->ProjectionX();
+ pTmp->SetLineColor(4);
+ pTmp->SetMarkerColor(4);
+ pTmp->SetMarkerStyle(24);
+ pTmp->Write();
+ pTmp = extractFlowVZEROsingle(icentr,2,arm,1,pTh,addbin,"kaMC",1,1,-1,1)->ProjectionX();
+ pTmp->SetLineColor(1);
+ pTmp->SetMarkerColor(1);
+ pTmp->SetMarkerStyle(25);
+ pTmp->Write();
+ pTmp = extractFlowVZEROsingle(icentr,3,arm,1,pTh,addbin,"prMC",1,1,-1,-1)->ProjectionX();
+ pTmp->SetLineColor(2);
+ pTmp->SetMarkerColor(2);
+ pTmp->SetMarkerStyle(26);
+ pTmp->Write();
}
+ extractFlowVZEROsingle(icentr,2,arm,0,pTh,addbin,"kProf")->Write();
+ extractFlowVZEROsingle(icentr,9,arm,0,pTh,addbin,"ks",0,1,1,1)->Write();
+ extractFlowVZEROsingle(icentr,9,arm,0,pTh,addbin,"ksMy",0,1,-1,-1)->Write();
+ extractFlowVZEROsingle(icentr,10,arm,0,pTh,addbin,"lambda")->Write();
+ pFromLambda->Write();
+ piFromK->Write();
+ pFromLambda2->Write();
+ piFromK2->Write();
+ piFromK3->Write();
+ if(hFeedSyst) hFeedSyst->Write();
+ fout->Close();
+}
+
+TProfile *extractFlowVZEROsingle(Int_t icentr,Int_t spec,Int_t arm,Bool_t isMC,Float_t pTh,Int_t addbin,const char *nameSp,Float_t detMin,Float_t detMax,Int_t chMin,Int_t chMax){
+ LoadLib();
+
+ pTh += 0.00001;
+
+ // NUA correction currently are missing
+ char name[100];
+ char stringa[200];
+
+ snprintf(name,100,"AnalysisResults.root");
+ if(!fo) fo = new TFile(name);
+ snprintf(name,100,"contVZEROv%i",arm);
+ TList *cont = (TList *) fo->Get(name);
+
+ cont->ls();
+
+ Float_t xMin[5] = {icentr/*centrality bin*/,chMin/*charge*/,pTh/*prob*/,-TMath::Pi()/arm/*Psi*/,detMin/*PID mask*/};
+ Float_t xMax[5] = {icentr+addbin,chMax,1.0,TMath::Pi()/arm,detMax};
+
+ cont->ls();
+
+ TProfile *p1 = cont->At(2);
+ TProfile *p2 = cont->At(3);
+ TProfile *p3 = cont->At(4);
- if(charge==-1) iMax[2]=0;
- if(charge==1) iMin[2]=0;
+ TH2F *hPsi2DA = cont->At(5);
+ TH2F *hPsi2DC = cont->At(6);
- // EP distribution needed for NUA corrections
- TH2F *hPhiA = l->At(5);
- TH2F *hPhiC = l->At(6);
+ TH1D *hPsiA = hPsi2DA->ProjectionY("PsiA",icentr+1,icentr+addbin+1);
+ TH1D *hPsiC = hPsi2DC->ProjectionY("PsiC",icentr+1,icentr+addbin+1);
- TH1D *hPhiPA = hPhiA->ProjectionY("_py",iMin[0]+1,iMax[0]+1);
- TH1D *hPhiPC = hPhiC->ProjectionY("_py",iMin[0]+1,iMax[0]+1);
+ if(!fPsi) fPsi = new TF1("fPsi","pol0",-TMath::Pi()/arm,TMath::Pi()/arm);
+ hPsiA->Fit(fPsi,"0");
+ Float_t offsetA = fPsi->GetParameter(0);
+ hPsiC->Fit(fPsi,"0");
+ Float_t offsetC = fPsi->GetParameter(0);
+
+ Int_t nbinPsi = hPsiA->GetNbinsX();
+
+ Float_t *NUAcorrA = new Float_t[nbinPsi];
+ Float_t *NUAcorrC = new Float_t[nbinPsi];
+
+ for(Int_t i=0;i < nbinPsi;i++){
+ NUAcorrA[i] = offsetA/(hPsiA->GetBinContent(i+1));
+ NUAcorrC[i] = offsetC/(hPsiC->GetBinContent(i+1));
+ }
- // EP resolution variables
Float_t res1=0,res2=0,res3=0;
Float_t eres1=0,eres2=0,eres3=0;
- for(Int_t i=iMin[0];i<=iMax[0];i++){ // in case of more centrality bins weighting with the errors
+ for(Int_t i = icentr; i <= icentr+addbin;i++){
if(p1->GetBinError(i+1)){
eres1 += 1./p1->GetBinError(i+1)/p1->GetBinError(i+1);
res1 += p1->GetBinContent(i+1)/p1->GetBinError(i+1)/p1->GetBinError(i+1);
eres3 += 1./p3->GetBinError(i+1)/p3->GetBinError(i+1);
res3 += p3->GetBinContent(i+1)/p3->GetBinError(i+1)/p3->GetBinError(i+1);
}
+ }
+
+ res1 /= eres1;
+ res2 /= eres2;
+ res3 /= eres3;
+
+ eres1 = sqrt(1./eres1);
+ eres2 = sqrt(1./eres2);
+ eres3 = sqrt(1./eres3);
+
+ AliFlowVZEROResults *a = (AliFlowVZEROResults *) cont->At(0);
+ AliFlowVZEROResults *b = (AliFlowVZEROResults *) cont->At(1);
+ TProfile *pp,*pp2;
+ if(kNUAcorr){ // with NUA corrections
+ pp = a->GetV2reweight(spec,xMin,xMax,3,NUAcorrA);
+ pp2 = b->GetV2reweight(spec,xMin,xMax,3,NUAcorrC);
+ }
+ else{
+ pp = a->GetV2(spec,xMin,xMax);
+ pp2 = b->GetV2(spec,xMin,xMax);
+ }
+
+ Float_t scaling = sqrt(res1*res3/res2);
+ if(kVZEROrescorr){
+ pp->Scale(1./scaling);
+ }
- if(eres1) res1 /= eres1;
- if(eres2) res2 /= eres2;
- if(eres3) res3 /= eres3;
+ Float_t err1_2 = eres1*eres1/res1/res1/4 +
+ eres2*eres2/res2/res2/4 +
+ eres3*eres3/res3/res3/4;
+ Float_t err2_2 = err1_2;
+ err1_2 /= scaling*scaling;
+ printf("resolution V0A = %f +/- %f\n",scaling,err1_2);
+ scaling = sqrt(res2*res3/res1);
+ err2_2 /= scaling*scaling;
+ if(kVZEROrescorr){
+ pp2->Scale(1./scaling);
+ }
+ printf("resolution V0C =%f +/- %f\n",scaling,err2_2);
- if(eres1) eres1 = TMath::Sqrt(1./eres1);
- if(eres1) eres2 = TMath::Sqrt(1./eres2);
- if(eres1) eres3 = TMath::Sqrt(1./eres3);
+ pp->SetName("V0A");
+ pp2->SetName("V0C");
+
+ if(! kCleanMemory){
+ new TCanvas();
+ pp->Draw();
+ pp2->Draw("SAME");
}
- // NUA correction (fit to EP distribution)
- TF1 *fpol = new TF1("fPol","pol0");
- hPhiPA->Fit("fPol","","",-TMath::Pi()/arm,TMath::Pi()/arm);
- Float_t scalA = fPol->GetParameter(0);
- hPhiPC->Fit("fPol","","",-TMath::Pi()/arm,TMath::Pi()/arm);
- Float_t scalC = fPol->GetParameter(0);
-
- AliCFContainer *c2[20];
- AliCFContainer *c4[20];
- TH2D *h[20],*h2[20];
-
- AliCFContainer *c2bis[20];
- AliCFContainer *c4bis[20];
-
- AliCFContainer *cPsi2[20];
- AliCFContainer *cPsi4[20];
- TH1D *hPsi[20],*hPsi2[20];
- AliCFContainer *cPsi2bis[20];
- AliCFContainer *cPsi4bis[20];
-
- Float_t intA = 0;
- Float_t intC = 0;
-
- for(Int_t i=5;i<15;i++){
- printf("%i\n",i);
- iMin[5] = hPhiPA->GetBinCenter(i+1);
- iMax[5] = hPhiPA->GetBinCenter(i+1);
- if(!kOnlyTPC){
- c2[i] = c->MakeSlice(2,iVar,iMin,iMax);
- c4[i]= c3->MakeSlice(2,iVar,iMin,iMax);
+ TProfile *pData = new TProfile(*pp);
+ pData->Add(pp2);
+ snprintf(stringa,100,"%sData",nameSp);
+ pData->SetName(stringa);
+
+ TProfile *pMc = NULL;
+
+ TProfile *ppMC;
+ TProfile *ppMC2;
+
+ if(isMC){
+ snprintf(name,100,"contVZEROmc");
+ cont = (TList *) fo->Get(name);
+ cont->ls();
+ if(arm == 2){
+ AliFlowVZEROResults *c = (AliFlowVZEROResults *) cont->At(0);
+ if(! kCleanMemory) c->GetV2(spec,xMin,xMax)->Draw("SAME");
}
- else{ // merge to maskPID bins (TPC standalone without TOF + TPC stand alone with TOF)
- iMin[6] = 0;
- iMax[6] = 0;
- c2[i] = c->MakeSlice(2,iVar,iMin,iMax);
- c4[i]= c3->MakeSlice(2,iVar,iMin,iMax);
-
- iMin[6] = 2;
- iMax[6] = 2;
- c2bis[i] = c->MakeSlice(2,iVar,iMin,iMax);
- c4bis[i]= c3->MakeSlice(2,iVar,iMin,iMax);
- }
-
-
- if(!kOnlyTPC){
- cPsi2[i] = c->MakeSlice(1,iVarPsi,iMin,iMax);
- cPsi4[i]= c3->MakeSlice(1,iVarPsi,iMin,iMax);
+ AliFlowVZEROResults *cA;
+ if(fo->Get("contVZEROv2")) cA = (AliFlowVZEROResults *) cont->At(1+2*(arm==3));
+ else cA = (AliFlowVZEROResults *) cont->At(0);
+ AliFlowVZEROResults *cC;
+ if(fo->Get("contVZEROv2")) cC = (AliFlowVZEROResults *) cont->At(2+2*(arm==3));
+ else cC = (AliFlowVZEROResults *) cont->At(1);
+
+ TProfile *p1mc = cont->At(5+3*(arm==3));
+ TProfile *p2mc = cont->At(6+3*(arm==3));
+ TProfile *p3mc = cont->At(7+3*(arm==3));
+
+ Float_t resMC1=0,resMC2=0,resMC3=0;
+ Float_t eresMC1=0,eresMC2=0,eresMC3=0;
+
+ for(Int_t i = icentr; i <= icentr+addbin;i++){
+ if(p1mc->GetBinError(i+1)){
+ eresMC1 += 1./p1mc->GetBinError(i+1)/p1mc->GetBinError(i+1);
+ resMC1 += p1mc->GetBinContent(i+1)/p1mc->GetBinError(i+1)/p1mc->GetBinError(i+1);
+ }
+ if(p2mc->GetBinError(i+1)){
+ eresMC2 += 1./p2mc->GetBinError(i+1)/p2mc->GetBinError(i+1);
+ resMC2 += p2mc->GetBinContent(i+1)/p2mc->GetBinError(i+1)/p2mc->GetBinError(i+1);
+ }
+ if(p3mc->GetBinError(i+1)){
+ eresMC3 += 1./p3mc->GetBinError(i+1)/p3mc->GetBinError(i+1);
+ resMC3 += p3mc->GetBinContent(i+1)/p3mc->GetBinError(i+1)/p3mc->GetBinError(i+1);
+ }
}
- else{ // merge to maskPID bins (TPC standalone without TOF + TPC stand alone with TOF)
- iMin[6] = 0;
- iMax[6] = 0;
- cPsi2[i] = c->MakeSlice(1,iVarPsi,iMin,iMax);
- cPsi4[i]= c3->MakeSlice(1,iVarPsi,iMin,iMax);
-
- iMin[6] = 2;
- iMax[6] = 2;
- cPsi2bis[i] = c->MakeSlice(1,iVarPsi,iMin,iMax);
- cPsi4bis[i]= c3->MakeSlice(1,iVarPsi,iMin,iMax);
+
+ resMC1 /= eresMC1;
+ resMC2 /= eresMC2;
+ resMC3 /= eresMC3;
+
+ eresMC1 = sqrt(1./eresMC1);
+ eresMC2 = sqrt(1./eresMC2);
+ eresMC3 = sqrt(1./eresMC3);
+
+ ppMC = cA->GetV2(spec,xMin,xMax);
+ ppMC2 = cC->GetV2(spec,xMin,xMax);
+
+ scaling = sqrt(resMC1*resMC3/resMC2);
+ ppMC->Scale(1./scaling);
+
+ err1_2 = eresMC1*eresMC1/resMC1/resMC1/4 +
+ eresMC2*eresMC2/resMC2/resMC2/4 +
+ eresMC3*eresMC3/resMC3/resMC3/4;
+ err2_2 = err1_2;
+ err1_2 /= scaling*scaling;
+ printf("resolution V0A (MC) = %f +/- %f\n",scaling,err1_2);
+ scaling = sqrt(resMC2*resMC3/resMC1);
+ err2_2 /= scaling*scaling;
+ ppMC2->Scale(1./scaling);
+ printf("resolution V0C (MC) =%f +/- %f\n",scaling,err2_2);
+
+ ppMC->SetName("V0Amc");
+ ppMC2->SetName("V0Cmc");
+
+ if(! kCleanMemory){
+ ppMC->Draw("SAME");
+ ppMC2->Draw("SAME");
}
- h[i] = (TH2D *) c2[i]->Project(step,0,1);
- h2[i] = (TH2D *) c4[i]->Project(step,0,1);
- if(kOnlyTPC){
- TH2D *htemp = (TH2D *) c2bis[i]->Project(step,0,1);
- h[i]->Add(htemp);
- htemp = (TH2D *) c4bis[i]->Project(step,0,1);
- h2[i]->Add(htemp);
- }
+ pMc = new TProfile(*ppMC);
+ pMc->Add(ppMC2);
+ snprintf(stringa,100,"%sMC",nameSp);
+ pMc->SetName(stringa);
+ pMc->SetLineColor(2);
+ }
+
+ if(! kCleanMemory){
+ new TCanvas();
+ pData->Draw();
+ }
+ if(pMc && !kCleanMemory){
+ pMc->Draw("SAME");
+ TH1D *hData = pData->ProjectionX();
+ TH1D *hMc = pMc->ProjectionX();
+ hData->Divide(hMc);
+ new TCanvas();
+ hData->Draw();
+ }
- if(hPhiPA->GetBinContent(i)) h[i]->Scale(scalA/hPhiPA->GetBinContent(i+1)); // reweighting for NUA correction
- if(hPhiPC->GetBinContent(i)) h2[i]->Scale(scalC/hPhiPC->GetBinContent(i+1)); // reweighting for NUA correction
+ delete[] NUAcorrA;
+ delete[] NUAcorrC;
- hPsi[i] = (TH1D *) cPsi2[i]->Project(step,0);
- hPsi2[i] = (TH1D *) cPsi4[i]->Project(step,0);
+ if(kCleanMemory){
+ if(pp) delete pp;
+ if(pp2) delete pp2;
+ if(ppMC) delete ppMC;
+ if(ppMC2) delete ppMC2;
+ }
- if(kOnlyTPC){ // merge to maskPID bins (TPC standalone without TOF + TPC stand alone with TOF)
- TH1D *htemp2 = (TH1D *) cPsi2bis[i]->Project(step,0);
- hPsi[i]->Add(htemp2);
- htemp2 = (TH1D *) cPsi4bis[i]->Project(step,0);
- hPsi2[i]->Add(htemp2);
- }
+ delete cont;
- if(hPhiPA->GetBinContent(i+1)) hPsi[i]->Scale(scalA/hPhiPA->GetBinContent(i+1)); // check of reweighting for NUA correction
- if(hPhiPC->GetBinContent(i+1)) hPsi2[i]->Scale(scalC/hPhiPC->GetBinContent(i+1)); // check of reweighting for NUA correction
+ if(isMC) return pMc;
+ return pData;
+}
+void compareTPCTOF(Int_t icentr,Int_t spec,Int_t arm,Float_t pTh,Int_t addbin){
+ LoadLib();
+ Float_t ptMaxFit[8] = {20,0.7,0.55,1.2,2,2,2,2};
- intA += hPsi[i]->Integral();
- intC += hPsi2[i]->Integral();
+ TProfile *pTPC = extractFlowVZEROsingle(icentr,spec,arm,0,pTh,addbin,"TPC",0,0,-1,-1+2*(spec!=3)); // TPC && !TOF (TPC PID)
+ TProfile *pTPC2 = extractFlowVZEROsingle(icentr,spec,arm,0,pTh,addbin,"TPCextra",2,2,-1,-1+2*(spec!=3)); //TPC && TOF (TPC PID)
- }
+ TProfile *pTOF = extractFlowVZEROsingle(icentr,spec,arm,0,pTh,addbin,"TOF",1,1,-1,-1+2*(spec!=3)); //TPC && TOF (TPC&TOF PID)
-// hPhiPA->Scale(intA / (scalA)/10);
-// hPhiPC->Scale(intC / (scalC)/10);
-
- // NUA correction check V0A
- hPhiPA->Draw();
- hPsi[5]->Draw("SAME");
- hPsi[5]->Scale(scalA / intA * 10);
- for(Int_t i=6;i<15;i++){
- h[5]->Add(h[i]);
- h2[5]->Add(h2[i]);
- hPsi[i]->Draw("SAME");
- hPsi[i]->Scale(scalA / intA * 10);
- }
+ if(spec > 0) pTPC->Add(pTPC2);
+ else pTPC->Add(pTOF);
- // NUA correction check V0C
- TCanvas *can2 = new TCanvas("cV0Ccheck","cV0Ccheck");
- hPhiPC->Draw();
- hPsi2[5]->Draw("SAME");
- for(Int_t i=6;i<15;i++){
- h[5]->Add(h[i]);
- h2[5]->Add(h2[i]);
- hPsi2[i]->Draw("SAME");
- hPsi2[i]->Scale(scalC /intC * 10);
- }
- hPsi2[5]->Scale(scalC /intC * 10);
+ char name[100];
+ snprintf(name,100,"NUO_%i",spec);
- // Flow for V0A and V0C separately
- TCanvas *can3 = new TCanvas("cFlowComp","cFlowComp");
- TProfile *pp = h[5]->ProfileY();
- pp->Draw();
- TProfile *pp2 = h2[5]->ProfileY();
- pp2->Draw("SAME");
+ hNUO[spec] = pTPC->ProjectionX(name);
+ hNUO[spec]->Add(pTOF,-1);
- printf("nev (selected within 0-80%) = %i\n",p1->GetEntries());
+ if(spec && hNUO[0]) hNUO[spec]->Add(hNUO[0],-1);
+ if(! kCleanMemory){
+ new TCanvas();
+ pTPC->Draw();
+ pTOF->Draw("SAME");
- // correction for resoltion
- Float_t scaling = sqrt(res1*res3/res2);
- pp->Scale(1./scaling);
- printf("resolution V0A = %f\n",scaling);
- Float_t err1_2 = eres1*eres1/res1/res1/4 +
- eres2*eres2/res2/res2/4 +
- eres3*eres3/res3/res3/4;
- Float_t err2_2 = err1_2;
- err1_2 /= scaling*scaling;
- scaling = sqrt(res2*res3/res1);
- err2_2 /= scaling*scaling;
- pp2->Scale(1./scaling);
- printf("resolution V0C =%f\n",scaling);
-
- char title[100];
- sprintf(title,"VZERO EP;p_{t} (GeV/c);v_{%i}",arm);
- pp->SetTitle(title);
-
- // Average V0A-V0C
- TH1D *pAll = pp->ProjectionX();
-
- for(Int_t i=1;i <= pAll->GetNbinsX();i++){
- Float_t e1 = err1_2*pp->GetBinContent(i)*pp->GetBinContent(i) + pp->GetBinError(i)*pp->GetBinError(i);
- Float_t e2 = err2_2*pp2->GetBinContent(i)*pp2->GetBinContent(i) + pp2->GetBinError(i)*pp2->GetBinError(i);
- Float_t xval = 0,exval = 0;
- if(e1 >0 && e2>0){
- xval = (pp->GetBinContent(i)/e1 + pp2->GetBinContent(i)/e2)/(1/e1 + 1/e2);
- exval = 1./sqrt(1/e1 + 1/e2);
- }
- pAll->SetBinContent(i,xval);
- pAll->SetBinError(i,exval);
+ new TCanvas();
+ pTPC->SetLineColor(1);
+ pTOF->SetLineColor(2);
}
- // combined measurement
- TCanvas *can4 = new TCanvas("cFlowCombined","cFlowCombined");
- pAll->Draw();
- char name[100];
- sprintf(name,"out%i-%i_%i_%4.2f_%i%sv%i.root",iMin[0],iMax[0],step,pTh,charge,iTechName[itech],arm);
- TFile *fout = new TFile(name,"RECREATE");
+ hNUO[spec]->Draw();
- pAll->SetName("histo");
- pAll->Write();
- can1->Write();
- can2->Write();
- can3->Write();
- fout->Close();
+ if(kCleanMemory){
+ if(pTPC) delete pTPC;
+ if(pTPC2) delete pTPC2;
+ if(pTOF) delete pTOF;
+ }
+}
+
+void plotQApid(Int_t ic,Float_t pt,Int_t addbin){
+ char name[100];
+ char stringa[200];
+ LoadLib();
+
+ snprintf(name,100,"AnalysisResults.root");
+ if(!fo) fo = new TFile(name);
+ snprintf(name,100,"contVZEROv2");
+ TList *cont = (TList *) fo->Get(name);
+ AliFlowVZEROResults *pidqa = cont->FindObject("qaPID");
+ Float_t xval[2] = {2.,pt+0.00001};
+ Float_t xval2[2] = {2.+addbin,pt+0.00001};
+
+ TProfile *proTPCpi = pidqa->GetV2(0,xval,xval2);
+ TProfile *proTOFpi = pidqa->GetV2(1,xval,xval2);
+ TProfile *proTPCka = pidqa->GetV2(2,xval,xval2);
+ TProfile *proTOFka = pidqa->GetV2(3,xval,xval2);
+ TProfile *proTPCpr = pidqa->GetV2(4,xval,xval2);
+ TProfile *proTOFpr = pidqa->GetV2(5,xval,xval2);
+
+ proTPCpi->SetName("hPiTPC");
+ proTOFpi->SetName("hPiTOF");
+ proTPCka->SetName("hKaTPC");
+ proTOFka->SetName("hKaTOF");
+ proTPCpr->SetName("hPrTPC");
+ proTOFpr->SetName("hPrTOF");
+
+ proTPCpi->GetXaxis()->SetTitle("dE/dx - dE/dx_{calc}^{#pi} (a.u)");
+ proTOFpi->GetXaxis()->SetTitle("t_{tof} - t_{calc}^{#pi} (ps)");
+ proTPCka->GetXaxis()->SetTitle("dE/dx - dE/dx_{calc}^{K} (a.u)");
+ proTOFka->GetXaxis()->SetTitle("t_{tof} - t_{calc}^{K} (ps)");
+ proTPCpr->GetXaxis()->SetTitle("dE/dx - dE/dx_{calc}^{p} (a.u)");
+ proTOFpr->GetXaxis()->SetTitle("t_{tof} - t_{calc}^{p} (ps)");
+
+ TCanvas *c = new TCanvas("cVproj","cVproj");
+ c->Divide(2,3);
+ c->cd(1);
+ proTPCpi->Draw();
+ c->cd(2);
+ proTOFpi->Draw();
+ c->cd(3);
+ proTPCka->Draw();
+ c->cd(4);
+ proTOFka->Draw();
+ c->cd(5);
+ proTPCpr->Draw();
+ c->cd(6);
+ proTOFpr->Draw();
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff