52ac63b1206f5d3a22f5c6a115552479ca885213
[u/mrichter/AliRoot.git] / TOF / macrosQA / MakeTrendingTOFQA.C
1 //fbellini@cern.ch, 11/11/2011
2 //-----------------------------------------------------------
3 Int_t MakeTrendingTOFQA(char * runlist, Int_t year=2011, char *period="LHC11d", char* pass="cpass1", Int_t trainId=0){
4   Int_t filesCounter=0;
5   
6   if (!runlist) {
7     printf("Invalid list of runs given as input: nothing done\n");
8     return 1;
9   }     
10   Int_t runNumber;
11   char infile[300]; 
12   char postFileName[20];
13   
14   char trendFileName[100]; 
15   //Define trending output
16   if (trainId==0){
17     sprintf(trendFileName,"treeTOFQA_%s_%s.root",period,pass);  
18   }else{
19     sprintf(trendFileName,"treeTOFQA_QA%i_%s_%s.root",trainId,period,pass);
20   }
21   TFile * trendFile=new TFile(trendFileName,"recreate");
22   
23   Double_t avTime=-9999., peakTime=-9999., spreadTime=-9999., peakTimeErr=-9999., spreadTimeErr=-9999., negTimeRatio=-9999.,
24     avRawTime=-9999., peakRawTime=-9999., spreadRawTime=-9999., peakRawTimeErr=-9999., spreadRawTimeErr=-9999., 
25     avTot=-9999., peakTot=-9999.,spreadTot=-9999.,  peakTotErr=-9999.,spreadTotErr=-9999.,
26     orphansRatio=-9999., avL=-9999., negLratio=-9999.,
27     effPt1=-9999., effPt2=-9999., matchEffLinFit1Gev=-9999.,matchEffLinFit1GevErr=-9999.;
28   
29   Double_t avPiDiffTime=-9999.,peakPiDiffTime=-9999., spreadPiDiffTime=-9999.,peakPiDiffTimeErr=-9999., spreadPiDiffTimeErr=-9999.;
30   
31   Double_t avT0A=-9999.,peakT0A=-9999., spreadT0A=-9999.,peakT0AErr=-9999., spreadT0AErr=-9999.;
32   Double_t avT0C=-9999.,peakT0C=-9999., spreadT0C=-9999.,peakT0CErr=-9999., spreadT0CErr=-9999.;
33   Double_t avT0AC=-9999.,peakT0AC=-9999., spreadT0AC=-9999.,peakT0ACErr=-9999., spreadT0ACErr=-9999.;
34   Double_t avT0res=-9999.,peakT0res=-9999., spreadT0res=-9999.,peakT0resErr=-9999., spreadT0resErr=-9999.;
35   Double_t avT0fillRes=-9999.;
36
37   Int_t avMulti=0;
38   Float_t fractionEventsWHits=-9999.;
39   
40   TTree * ttree=new TTree("trendTree","tree of trending variables");
41   ttree->Branch("run",&runNumber,"run/I");
42   ttree->Branch("avMulti",&avMulti,"avMulti/I");
43   ttree->Branch("fractionEventsWHits",&fractionEventsWHits,"fractionEventsWHits/F");
44   ttree->Branch("avTime",&avTime,"avTime/D"); //mean time
45   ttree->Branch("peakTime",&peakTime,"peakTime/D"); //main peak time after fit
46   ttree->Branch("spreadTime",&spreadTime,"spreadTime/D"); //spread of main peak of time after fit
47   ttree->Branch("peakTimeErr",&peakTimeErr,"peakTimeErr/D"); //main peak time after fit error
48   ttree->Branch("spreadTimeErr",&spreadTimeErr,"spreadTimeErr/D"); //spread of main peak of time after fit error
49   ttree->Branch("negTimeRatio",&negTimeRatio,"negTimeRatio/D"); //negative time ratio
50   
51   ttree->Branch("avRawTime",&avRawTime,"avRawTime/D"); //mean raw time
52   ttree->Branch("peakRawTime",&peakRawTime,"peakRawTime/D"); //mean peak of RAW TIME after fit
53   ttree->Branch("spreadRawTime",&spreadRawTime,"spreadRawTime/D"); //spread of main peak of raw time after fit
54   ttree->Branch("peakRawTimeErr",&peakRawTimeErr,"peakRawTimeErr/D"); //main peak raw  time after fit error
55   ttree->Branch("spreadRawTimeErr",&spreadRawTimeErr,"spreadRawTimeErr/D"); //spread of  raw main peak of time after fit error
56   
57   ttree->Branch("avTot",&avTot,"avTot/D"); //main peak tot
58   ttree->Branch("peakTot",&peakTot,"peakTot/D"); // main peak of tot after fit
59   ttree->Branch("spreadTot",&spreadTot,"spreadTot/D"); //spread of main peak of tot after fit
60   ttree->Branch("peakTotErr",&peakTotErr,"peakTotErr/D"); // main peak of tot after fit
61   ttree->Branch("spreadTotErr",&spreadTotErr,"spreadTotErr/D"); //spread of main peak of tot after fit
62   
63   ttree->Branch("orphansRatio",&orphansRatio,"orphansRatio/D"); //orphans ratio
64
65   ttree->Branch("avL",&avL,"avL/D"); //mean track length
66   ttree->Branch("negLratio",&negLratio,"negLratio/D");//ratio of tracks with track length <350 cm
67
68   ttree->Branch("effPt1",&effPt1,"effPt1/D");//matching eff at 1 GeV/c
69   ttree->Branch("effPt2",&effPt2,"effPt2/D"); //matching eff at 2 GeV/c
70   ttree->Branch("matchEffLinFit1Gev",&matchEffLinFit1Gev,"matchEffLinFit1Gev/D");//matching eff fit param 
71   ttree->Branch("matchEffLinFit1GevErr",&matchEffLinFit1GevErr,"matchEffLinFit1GevErr/D");////matching eff fit param error
72   
73   ttree->Branch("avPiDiffTime",&avPiDiffTime,"avPiDiffTime/D"); //mean t-texp
74   ttree->Branch("peakPiDiffTime",&peakPiDiffTime,"peakPiDiffTime/D"); //main peak t-texp after fit
75   ttree->Branch("spreadPiDiffTime",&spreadPiDiffTime,"spreadPiDiffTime/D"); //spread of main peak t-texp after fit
76   ttree->Branch("peakPiDiffTimeErr",&peakPiDiffTimeErr,"peakPiDiffTimeErr/D"); //main peak t-texp after fit error
77   ttree->Branch("spreadPiDiffTimeErr",&spreadPiDiffTimeErr,"spreadPiDiffTimeErr/D"); //spread of main peak of t-texp after fit error
78
79   ttree->Branch("avT0A",&avT0A,"avT0A/D"); //main peak t0A
80   ttree->Branch("peakT0A",&peakT0A,"peakT0A/D"); // main peak of t0A after fit
81   ttree->Branch("spreadT0A",&spreadT0A,"spreadTot/D"); //spread of main peak of t0A after fit
82   ttree->Branch("peakT0AErr",&peakT0AErr,"peakT0AErr/D"); // main peak of t0A after fit
83   ttree->Branch("spreadT0AErr",&spreadT0AErr,"spreadT0AErr/D"); //spread of main peak of t0A after fit
84
85   ttree->Branch("avT0C",&avT0C,"avT0C/D"); //main peak t0C
86   ttree->Branch("peakT0C",&peakT0C,"peakT0C/D"); // main peak of t0C after fit
87   ttree->Branch("spreadT0C",&spreadT0C,"spreadT0C/D"); //spread of main peak of t0C after fit
88   ttree->Branch("peakT0CErr",&peakT0CErr,"peakT0CErr/D"); // main peak of t0C after fit
89   ttree->Branch("spreadT0CErr",&spreadT0CErr,"spreadT0CErr/D"); //spread of main peak of t0C after fit
90  
91   ttree->Branch("avT0AC",&avT0AC,"avT0AC/D"); //main peak t0AC
92   ttree->Branch("peakT0AC",&peakT0AC,"peakT0AC/D"); // main peak of t0AC after fit
93   ttree->Branch("spreadT0AC",&spreadT0AC,"spreadT0AC/D"); //spread of main peak of t0AC after fit
94   ttree->Branch("peakT0ACErr",&peakT0ACErr,"peakT0ACErr/D"); // main peak of t0AC after fit
95   ttree->Branch("spreadT0ACErr",&spreadT0ACErr,"spreadT0ACErr/D"); //spread of main peak of t0AC after fit
96  
97   ttree->Branch("avT0res",&avT0res,"avT0res/D"); //main peak t0AC
98   ttree->Branch("peakT0res",&peakT0res,"peakT0res/D"); // main peak of t0AC after fit
99   ttree->Branch("spreadT0res",&spreadT0res,"spreadT0res/D"); //spread of main peak of t0AC after fit
100   ttree->Branch("peakT0resErr",&peakT0resErr,"peakT0resErr/D"); // main peak of t0AC after fit
101   ttree->Branch("spreadT0resErr",&spreadT0resErr,"spreadT0resErr/D"); //spread of main peak of t0AC after fit
102   ttree->Branch("avT0fillRes",&avT0fillRes,"avT0fillRes/D"); //t0 fill res
103   
104
105   FILE * files = fopen(runlist, "r") ; 
106   while (fscanf(files,"%d",&runNumber)==1 ){
107     
108     //reset all variables
109     avTime=-9999.; peakTime=-9999.; spreadTime=-9999.; peakTimeErr=-9999.; spreadTimeErr=-9999.;negTimeRatio=-9999.;
110     avRawTime=-9999.; peakRawTime=-9999.; spreadRawTime=-9999.; peakRawTimeErr=-9999.; spreadRawTimeErr=-9999.; 
111     avTot=-9999.; peakTot=-9999.;spreadTot=-9999.;  peakTotErr=-9999.;spreadTotErr=-9999.;
112     orphansRatio=-9999.; avL=-9999.; negLratio=-9999.;
113     effPt1=-9999.; effPt2=-9999.; matchEffLinFit1Gev=-9999.;matchEffLinFit1GevErr=-9999.;
114     
115     avPiDiffTime=-9999.;peakPiDiffTime=-9999.; spreadPiDiffTime=-9999.;peakPiDiffTimeErr=-9999.; spreadPiDiffTimeErr=-9999.;
116     
117     avT0A=-9999.;peakT0A=-9999.; spreadT0A=-9999.;peakT0AErr=-9999.; spreadT0AErr=-9999.;
118     avT0C=-9999.;peakT0C=-9999.; spreadT0C=-9999.;peakT0CErr=-9999.; spreadT0CErr=-9999.;
119     avT0AC=-9999.;peakT0AC=-9999.; spreadT0AC=-9999.;peakT0ACErr=-9999.; spreadT0ACErr=-9999.;
120     avT0res=-9999.;peakT0res=-9999.; spreadT0res=-9999.;peakT0resErr=-9999.; spreadT0resErr=-9999.;
121     avMulti=0; avT0fillRes=0.;
122     fractionEventsWHits=-9999.;
123     
124     //get QAtrain output
125     //SetQAtrainOutputName(runNumber, year,period,pass,trainId);
126     if (trainId==0){
127       sprintf(infile,"alien:///alice/data/%i/%s/000%d/ESDs/%s/QAresults.root",year,period,runNumber,pass);
128     } else{
129       sprintf(infile,"alien:///alice/data/%i/%s/000%d/ESDs/%s/QA%i/QAresults.root",year,period,runNumber,pass,trainId);
130     }
131     printf("============== Opening QA file(s) for run %i =======================\n",runNumber);
132     
133     
134     //run post-analysis
135     if (RunESDQApostAnalysis(infile,runNumber,kTRUE)==0){
136       filesCounter++;
137       
138       //get post-analysis output
139       sprintf(postFileName,"postQA_%i.root",runNumber);
140       TFile *postfile=TFile::Open(postFileName);
141       if (!postfile) {
142         printf("Post-analysis output not found - cannot perform trending analysis. Exiting.");
143         return 2;
144       } else {
145         printf("==============  Retrieving post-analysis for run %i ===============\n",runNumber);
146       }
147       //postfile->ls();
148       //save quantities for trending
149       
150       //--------------------------------- Multiplicity ----------------------------------//
151       TH1F*hMulti=(TH1F*)postfile->Get("hTOFmatchedPerEvt");
152       if ((hMulti)&&(hMulti->GetEntries()>0)) {
153         avMulti=hMulti->GetMean();
154       }
155       
156       //--------------------------------- T0F signal ----------------------------------//
157       
158       TH1F*hTime=(TH1F*)postfile->Get("hTOFmatchedESDtime");
159       if ((hTime)&&(hTime->GetEntries()>0)) {
160         avTime=hTime->GetMean();
161         hTime->Fit("landau","","",0.,50.);
162         peakTime=(hTime->GetFunction("landau"))->GetParameter(1);
163         spreadTime=(hTime->GetFunction("landau"))->GetParameter(2);
164         peakTimeErr=(hTime->GetFunction("landau"))->GetParError(1);
165         spreadTimeErr=(hTime->GetFunction("landau"))->GetParError(2);
166         
167         negTimeRatio=((Double_t)hTime->Integral(1,3)*100.)/((Double_t)hTime->Integral());
168         printf("Main peak time (landau): mean = %f +- %f\n",peakTime,peakTimeErr );
169         printf("Main peak time (landau): spread = %f +- %f\n",spreadTime,spreadTimeErr );
170         printf("Ratio of tracks with time<12.5 ns / total = %f\n",negTimeRatio );
171         
172         //add integral of main peak over total
173       }
174       printf("---------------------------------------------------------------- \n");
175       TH1F * hRawTime = (TH1F*)postfile->Get("hTOFmatchedESDrawTime");
176       if ((hRawTime)&&(hRawTime->GetEntries()>0)){
177         avRawTime=hRawTime->GetMean();
178         hRawTime->Fit("landau","","",200.,250.);
179         peakRawTime=(hRawTime->GetFunction("landau"))->GetParameter(1);
180         spreadRawTime=(hRawTime->GetFunction("landau"))->GetParameter(2);
181         peakRawTimeErr=(hRawTime->GetFunction("landau"))->GetParError(1);
182         spreadRawTimeErr=(hRawTime->GetFunction("landau"))->GetParError(2);
183         printf("Main peak raw time (landau): mean = %f +- %f\n",peakTime,peakTimeErr );
184         printf("Main peak raw time (landau): spread = %f +- %f\n",spreadRawTime,spreadRawTimeErr );
185       }
186       
187       printf("---------------------------------------------------------------- \n");
188       
189       TH1F * hTot = (TH1F*)postfile->Get("hTOFmatchedESDToT");
190       if ((hTot)&&(hTot->GetEntries()>0)){
191         avTot=hTot->GetMean();
192         hTot->Fit("gaus","","",0.,50.);
193         peakTot=(hTot->GetFunction("gaus"))->GetParameter(1);
194         spreadTot=(hTot->GetFunction("gaus"))->GetParameter(2);
195         peakTotErr=(hTot->GetFunction("gaus"))->GetParError(1);
196         spreadTotErr=(hTot->GetFunction("gaus"))->GetParError(2);
197         printf("Main peak ToT (gaus): mean = %f +- %f\n",peakTot,peakTotErr );
198         printf("Main peak ToT (gaus): spread = %f +- %f\n",spreadTot,spreadTotErr );    
199       }      
200       printf("---------------------------------------------------------------- \n");
201       TH1F * hOrphansRatio=(TH1F*)postfile->Get("hOrphansRatio");
202       if (hOrphansRatio)
203         orphansRatio=hOrphansRatio->GetMean();
204       
205       TH1F * hL=(TH1F*)postfile->Get("hTOFmatchedESDtrkLength");
206       if (hL)
207         avL=hL->GetMean();
208       
209       TH1F *hLnegRatio =(TH1F*)postfile->Get("hLnegRatio");
210       if (hLnegRatio)
211         negLratio=hLnegRatio->GetMean();
212       
213       //--------------------------------- matching eff ----------------------------------//
214      
215       //Double_t linFitEff1Param[3]={0.,0.,0.};
216       TH1F *hMatchingVsPt =(TH1F*)postfile->Get("hTOFmatchedESDPt");
217       if (hMatchingVsPt) {
218         if (hMatchingVsPt->GetEntries()>0){
219           hMatchingVsPt->Fit("pol0","","",1.0,5.);
220           hMatchingVsPt->Draw();
221           if (hMatchingVsPt->GetFunction("pol0")){
222             matchEffLinFit1Gev=(hMatchingVsPt->GetFunction("pol0"))->GetParameter(0);
223             matchEffLinFit1GevErr=(hMatchingVsPt->GetFunction("pol0"))->GetParError(0); 
224             printf("Matching efficiency fit param is %f +- %f\n",matchEffLinFit1Gev,matchEffLinFit1GevErr );
225           }
226         } else {
227           printf("WARNING: matching efficiency plot has 0 entries. Skipped!\n");
228         }
229       } else {
230         printf("WARNING: cannot retrieve matching efficiency plot\n");
231       }
232
233       //--------------------------------- t-texp ----------------------------------//
234      
235        TH1F*hPiDiffTime=(TH1F*)postfile->Get("hTOFmatchedExpTimePi");
236       if ((hPiDiffTime)&&(hPiDiffTime->GetEntries()>0)) {
237         avPiDiffTime=hPiDiffTime->GetMean();
238         hPiDiffTime->Fit("gaus","","",-1000.,500.);
239         if (hPiDiffTime->GetFunction("gaus")){
240           peakPiDiffTime=(hPiDiffTime->GetFunction("gaus"))->GetParameter(1);
241           spreadPiDiffTime=(hPiDiffTime->GetFunction("gaus"))->GetParameter(2);
242           peakPiDiffTimeErr=(hPiDiffTime->GetFunction("gaus"))->GetParError(1);
243           spreadPiDiffTimeErr=(hPiDiffTime->GetFunction("gaus"))->GetParError(2);
244           printf("Main peak t-t_exp (gaus): mean = %f +- %f\n",peakPiDiffTime,peakPiDiffTimeErr );
245           printf("Main peak t-t_exp (gaus): spread = %f +- %f\n",spreadPiDiffTime,spreadPiDiffTimeErr );
246         }
247       }
248       //--------------------------------- T0 detector ----------------------------------//
249       
250       TH1F*hT0A=(TH1F*)postfile->Get("hEventT0DetA");
251       if ((hT0A)&&(hT0A->GetEntries()>0)) {
252         avhT0A=hT0A->GetMean();
253         hT0A->Fit("gaus");
254         peakT0A=(hT0A->GetFunction("gaus"))->GetParameter(1);
255         spreadT0A=(hT0A->GetFunction("gaus"))->GetParameter(2);
256         peakT0AErr=(hT0A->GetFunction("gaus"))->GetParError(1);
257         spreadT0AErr=(hT0A->GetFunction("gaus"))->GetParError(2);       
258         printf("Main peak T0A(gaus): mean = %f +- %f\n",peakT0A,peakT0AErr );
259         printf("Main peak T0A (gaus): spread = %f +- %f\n",spreadT0A,spreadT0AErr );     
260         //add integral of main peak over total
261       }
262
263     TH1F*hT0C=(TH1F*)postfile->Get("hEventT0DetC");
264       if ((hT0C)&&(hT0C->GetEntries()>0)) {
265         avhT0C=hT0C->GetMean();
266         hT0C->Fit("gaus");
267         peakT0C=(hT0C->GetFunction("gaus"))->GetParameter(1);
268         spreadT0C=(hT0C->GetFunction("gaus"))->GetParameter(2);
269         peakT0CErr=(hT0C->GetFunction("gaus"))->GetParError(1);
270         spreadT0CErr=(hT0C->GetFunction("gaus"))->GetParError(2);       
271         printf("Main peak T0C(gaus): mean = %f +- %f\n",peakT0C,peakT0CErr );
272         printf("Main peak T0C (gaus): spread = %f +- %f\n",spreadT0C,spreadT0CErr );     
273         //add integral of main peak over total
274       }
275
276        TH1F*hT0AC=(TH1F*)postfile->Get("hEventT0DetAND");
277       if ((hT0AC)&&(hT0AC->GetEntries()>0)) {
278         avhT0AC=hT0AC->GetMean();
279         hT0AC->Fit("gaus");
280         peakT0AC=(hT0AC->GetFunction("gaus"))->GetParameter(1);
281         spreadT0AC=(hT0AC->GetFunction("gaus"))->GetParameter(2);
282         peakT0ACErr=(hT0AC->GetFunction("gaus"))->GetParError(1);
283         spreadT0ACErr=(hT0AC->GetFunction("gaus"))->GetParError(2);     
284         printf("Main peak T0AC(gaus): mean = %f +- %f\n",peakT0AC,peakT0ACErr );
285         printf("Main peak T0AC (gaus): spread = %f +- %f\n",spreadT0AC,spreadT0ACErr );  
286       }
287       
288       TH1F*hT0res=(TH1F*)postfile->Get("hT0DetRes");
289       if ((hT0res)&&(hT0res->GetEntries()>0)) {
290         avhT0res=hT0res->GetMean();
291         hT0res->Fit("gaus");
292         peakT0res=(hT0res->GetFunction("gaus"))->GetParameter(1);
293         spreadT0res=(hT0res->GetFunction("gaus"))->GetParameter(2);
294         peakT0resErr=(hT0res->GetFunction("gaus"))->GetParError(1);
295         spreadT0resErr=(hT0res->GetFunction("gaus"))->GetParError(2);   
296         printf("Main peak T0res(gaus): mean = %f +- %f\n",peakT0res,peakT0resErr );
297         printf("Main peak T0res (gaus): spread = %f +- %f\n",spreadT0res,spreadT0resErr );       
298         //add integral of main peak over total
299       }
300
301       TH1F*hT0fillRes=(TH1F*)postfile->Get("hT0fillRes");
302       if ((hT0fillRes)&&(hT0fillRes->GetEntries()>0)) {
303         avT0fillRes=hT0fillRes->GetMean();
304       }
305       
306       ttree->Fill();
307       printf("==============  Saving trending quantities for run %i ===============\n",runNumber);
308       if (postfile->IsOpen()) {
309         printf("Trying to close\n");
310         postfile->Close();
311       }  
312     } else {
313       printf("==============   QA for run %i not available - skipping ===============\n",runNumber);
314     }
315     
316   } 
317   printf("Number of files processed = %i\n",filesCounter);
318   
319   trendFile->cd();
320   ttree->Write();
321   trendFile->Close();
322
323   return  MakeTrendingFromTreeWithErrors(trendFileName); 
324 }
325
326 //______________________________________________________________________________
327
328 Int_t MakeTrendingFromTreeWithErrors(char* trendFileName=NULL){
329
330    if (!trendFileName) 
331     return 3;
332   
333    TFile *fin=TFile::Open(trendFileName);
334    if (!fin) 
335      return 4;
336    Int_t runNumber;
337    Double_t avTime=0., peakTime=0., spreadTime=0., peakTimeErr=0., spreadTimeErr=0.,negTimeRatio=0.,
338      avRawTime=0., peakRawTime=0., spreadRawTime=0., peakRawTimeErr=0., spreadRawTimeErr=0., 
339      avTot=0., peakTot=0.,spreadTot=0.,  peakTotErr=0.,spreadTotErr=0.,
340      orphansRatio=0., avL=0., negLratio=0.,
341      effPt1=0., effPt2=0., matchEffLinFit1Gev=0.,matchEffLinFit1GevErr=0.;
342    Double_t avDiffTime=0.,peakDiffTime=0., spreadDiffTime=0.,peakDiffTimeErr=0., spreadDiffTimeErr=0.,avT0fillRes=0.;
343    
344    Double_t avT0A=0.,peakT0A=0., spreadT0A=0.,peakT0AErr=0., spreadT0AErr=0.;
345    Double_t avT0C=0.,peakT0C=0., spreadT0C=0.,peakT0CErr=0., spreadT0CErr=0.;
346    Double_t avT0AC=0.,peakT0AC=0., spreadT0AC=0.,peakT0ACErr=0., spreadT0ACErr=0.;
347    Double_t avT0res=0.,peakT0res=0., spreadT0res=0.,peakT0resErr=0., spreadT0resErr=0.;
348    Int_t avMulti=0;
349    Float_t fractionEventsWHits=0;
350    
351    TTree * ttree=(TTree*)fin->Get("trendTree");
352    ttree->SetBranchAddress("run",&runNumber);
353    
354    ttree->SetBranchAddress("avTime",&avTime); //mean time
355    ttree->SetBranchAddress("peakTime",&peakTime); //main peak time after fit
356    ttree->SetBranchAddress("spreadTime",&spreadTime); //spread of main peak of time after fit
357    ttree->SetBranchAddress("peakTimeErr",&peakTimeErr); //main peak time after fit error
358    ttree->SetBranchAddress("spreadTimeErr",&spreadTimeErr); //spread of main peak of time after fit error
359    
360    ttree->SetBranchAddress("negTimeRatio",&negTimeRatio); //negative time ratio
361    
362    ttree->SetBranchAddress("avRawTime",&avRawTime); //mean raw time
363    ttree->SetBranchAddress("peakRawTime",&peakRawTime); //mean peak of raw time after fit
364    ttree->SetBranchAddress("spreadRawTime",&spreadRawTime); //spread of main peak of raw time after fit
365    ttree->SetBranchAddress("peakRawTimeErr",&peakRawTimeErr); //main peak raw  time after fit error
366    ttree->SetBranchAddress("spreadRawTimeErr",&spreadRawTimeErr); //spread of  raw main peak of time after fit error
367   
368    ttree->SetBranchAddress("avTot",&avTot); //main peak tot
369    ttree->SetBranchAddress("peakTot",&peakTot); // main peak of tot after fit
370    ttree->SetBranchAddress("spreadTot",&spreadTot); //spread of main peak of tot after fit
371    ttree->SetBranchAddress("peakTotErr",&peakTotErr); // main peak of tot after fit
372    ttree->SetBranchAddress("spreadTotErr",&spreadTotErr); //spread of main peak of tot after fit
373    
374    ttree->SetBranchAddress("orphansRatio",&orphansRatio); //orphans ratio
375    
376    ttree->SetBranchAddress("avL",&avL); //mean track length
377    ttree->SetBranchAddress("negLratio",&negLratio);//ratio of tracks with track length <350 cm
378    
379    ttree->SetBranchAddress("effPt1",&effPt1);//matching eff at 1 GeV/c
380    ttree->SetBranchAddress("effPt2",&effPt2); //matching eff at 2 GeV/c
381    ttree->SetBranchAddress("matchEffLinFit1Gev",&matchEffLinFit1Gev);//matching eff fit param 
382    ttree->SetBranchAddress("matchEffLinFit1GevErr",&matchEffLinFit1GevErr);////matching eff fit param error
383    
384    ttree->SetBranchAddress("avPiDiffTime",&avDiffTime); //mean t-texp
385    ttree->SetBranchAddress("peakPiDiffTime",&peakDiffTime); //main peak t-texp after fit
386    ttree->SetBranchAddress("spreadPiDiffTime",&spreadDiffTime); //spread of main peak t-texp after fit
387    ttree->SetBranchAddress("peakPiDiffTimeErr",&peakDiffTimeErr); //main peak t-texp after fit error
388    ttree->SetBranchAddress("spreadPiDiffTimeErr",&spreadDiffTimeErr); //spread of main peak of t-texp after fit error
389    
390    ttree->SetBranchAddress("avT0A",&avT0A); //main peak t0A
391    ttree->SetBranchAddress("peakT0A",&peakT0A); // main peak of t0A after fit
392    ttree->SetBranchAddress("spreadT0A",&spreadT0A); //spread of main peak of t0A after fit
393    ttree->SetBranchAddress("peakT0AErr",&peakT0AErr); // main peak of t0A after fit
394    ttree->SetBranchAddress("spreadT0AErr",&spreadT0AErr); //spread of main peak of t0A after fit
395    
396    ttree->SetBranchAddress("avT0C",&avT0C); //main peak t0C
397    ttree->SetBranchAddress("peakT0C",&peakT0C); // main peak of t0C after fit
398    ttree->SetBranchAddress("spreadT0C",&spreadT0C); //spread of main peak of t0C after fit
399    ttree->SetBranchAddress("peakT0CErr",&peakT0CErr); // main peak of t0C after fit
400    ttree->SetBranchAddress("spreadT0CErr",&spreadT0CErr); //spread of main peak of t0C after fit
401    
402    ttree->SetBranchAddress("avT0AC",&avT0AC); //main peak t0AC
403    ttree->SetBranchAddress("peakT0AC",&peakT0AC); // main peak of t0AC after fit
404    ttree->SetBranchAddress("spreadT0AC",&spreadT0AC); //spread of main peak of t0AC after fit
405    ttree->SetBranchAddress("peakT0ACErr",&peakT0ACErr); // main peak of t0AC after fit
406    ttree->SetBranchAddress("spreadT0ACErr",&spreadT0ACErr); //spread of main peak of t0AC after fit
407    
408    ttree->SetBranchAddress("avT0res",&avT0res); //main peak t0AC
409    ttree->SetBranchAddress("peakT0res",&peakT0res); // main peak of t0AC after fit
410    ttree->SetBranchAddress("spreadT0res",&spreadT0res); //spread of main peak of t0AC after fit
411    ttree->SetBranchAddress("peakT0resErr",&peakT0resErr); // main peak of t0AC after fit
412    ttree->SetBranchAddress("spreadT0resErr",&spreadT0resErr); //spread of main peak of t0AC after fit
413     ttree->SetBranchAddress("avT0fillRes",&avT0fillRes); //t0 fill res
414
415    Int_t nRuns=ttree->GetEntries();
416    TList lista;
417    
418       TH1F * hAvDiffTimeVsRun=new TH1F("hAvDiffTimeVsRun","hAvDiffTimeVsRun;run;<t^{TOF}-t_{exp,#pi}> (ps)",nRuns,0., nRuns);//, 600, 0. , 600.);
419    hAvDiffTimeVsRun->SetDrawOption("E1");
420    hAvDiffTimeVsRun->SetMarkerStyle(20);
421    hAvDiffTimeVsRun->SetMarkerColor(kBlue);
422    //   hAvTimeVsRun->GetYaxis()->SetRangeUser(0.0, 50.0);
423
424    TH1F * hPeakDiffTimeVsRun=new TH1F("hPeakDiffTimeVsRun","hPeakDiffTimeVsRun (gaussian fit) ;run; <t^{TOF}-t_{exp,#pi}> (ps)",nRuns,0., nRuns);//,600, 0. , 600. );
425    hPeakDiffTimeVsRun->SetDrawOption("E1");
426    hPeakDiffTimeVsRun->SetMarkerStyle(20);
427    hPeakDiffTimeVsRun->SetMarkerColor(kBlue);
428    
429   TH1F * hSpreadTimeVsRun=new TH1F("hSpreadDiffTimeVsRun","hSpreadDiffTimeVsRun (gaussian fit);run; #sigma(t^{TOF}-t_{exp,#pi}) (ns)",nRuns,0., nRuns);//, 100, 0. , 100.);
430   hSpreadDiffTimeVsRun->SetDrawOption("E1");
431   hSpreadDiffTimeVsRun->SetMarkerStyle(20);
432   hSpreadDiffTimeVsRun->SetMarkerColor(kBlue);
433
434    TH1F * hAvTimeVsRun=new TH1F("hAvTimeVsRun","hAvTimeVsRun;run;<t^{TOF}> (ns)",nRuns,0., nRuns);//, 600, 0. , 600.);
435    hAvTimeVsRun->SetDrawOption("E1");
436    hAvTimeVsRun->SetMarkerStyle(20);
437    hAvTimeVsRun->SetMarkerColor(kBlue);
438    //   hAvTimeVsRun->GetYaxis()->SetRangeUser(0.0, 50.0);
439
440    TH1F * hPeakTimeVsRun=new TH1F("hPeakTimeVsRun","hPeakTimeVsRun (gaussian fit);run;t_{peak}^{TOF} (ns)",nRuns,0., nRuns);//,600, 0. , 600. );
441    hPeakTimeVsRun->SetDrawOption("E1");
442    hPeakTimeVsRun->SetMarkerStyle(20);
443    hPeakTimeVsRun->SetMarkerColor(kBlue);
444    
445   TH1F * hSpreadTimeVsRun=new TH1F("hSpreadTimeVsRun","hSpreadTimeVsRun (gaussian fit);run; #sigma(t^{TOF}) (ns)",nRuns,0., nRuns);//, 100, 0. , 100.);
446   hSpreadTimeVsRun->SetDrawOption("E1");
447   hSpreadTimeVsRun->SetMarkerStyle(20);
448   hSpreadTimeVsRun->SetMarkerColor(kBlue);
449   
450   
451   TH1F * hAvRawTimeVsRun=new TH1F("hAvRawTimeVsRun","hAvRawTimeVsRun;run;<t_{raw}^{TOF}> (ns)",nRuns,0., nRuns);//, 600, 0. , 600.);
452   hAvRawTimeVsRun->SetDrawOption("E1");
453   hAvRawTimeVsRun->SetMarkerStyle(21);
454   hAvRawTimeVsRun->SetMarkerColor(kGreen);
455
456   TH1F * hPeakRawTimeVsRun=new TH1F("hPeakRawTimeVsRun","hPeakRawTimeVsRun (gaussian fit);run;t_{peak,raw}^{TOF} (ns)",nRuns,0., nRuns);//, 600, 0. , 600.);
457   hPeakRawTimeVsRun->SetDrawOption("E1");
458   hPeakRawTimeVsRun->SetMarkerStyle(21);
459   hPeakRawTimeVsRun->SetMarkerColor(kGreen);
460
461   TH1F * hSpreadRawTimeVsRun=new TH1F("hSpreadRawTimeVsRun","hSpreadRawTimeVsRun (gaussian fit);run;#sigma(t_{raw}^{TOF}) (ns)",nRuns,0., nRuns);//, 100, 0. , 100.);
462   hSpreadRawTimeVsRun->SetDrawOption("E1");
463   hSpreadRawTimeVsRun->SetMarkerStyle(21);
464   hSpreadRawTimeVsRun->SetMarkerColor(kGreen);
465    
466   TH1F * hAvTotVsRun=new TH1F("hAvTotVsRun","hAvTotVsRun;run;<ToT> (ns)",nRuns,0., nRuns);//, 50, 0. , 50.);
467    hAvTotVsRun->SetDrawOption("E1");
468    hAvTotVsRun->SetMarkerStyle(22);
469    
470    TH1F * hPeakTotVsRun=new TH1F("hPeakTotVsRun","hPeakTotVsRun (gaussian fit);run;ToT_{peak} (ns)",nRuns,0., nRuns);//, 50, 0. , 50.);
471    hPeakTotVsRun->SetDrawOption("E1");
472    hPeakTotVsRun->SetMarkerStyle(22);
473    
474    TH1F * hSpreadTotVsRun=new TH1F("hSpreadTotVsRun","hSpreadTotVsRun (gaussian fit);#sigma(ToT) (ns)",nRuns,0., nRuns);//, 50, 0. , 50.);
475    hSpreadTotVsRun->SetDrawOption("E1");
476    hSpreadTotVsRun->SetMarkerStyle(22);
477    
478    TH1F * hNegTimeRatioVsRun=new TH1F("hNegTimeRatioVsRun","hNegTimeRatioVsRun;run;ratio of tracks with t^{TOF}<12.5 ns (%)",nRuns, 0., nRuns);//, 100, 0. , 100.);
479    hNegTimeRatioVsRun->SetDrawOption("E");
480
481    TH1F * hOrphansRatioVsRun=new TH1F("hOrphansRatioVsRun","hOrphansRatioVsRun; run; ratio of orphans (%)",nRuns, 0., nRuns);//, 1000, 0. , 100.);
482    hOrphansRatioVsRun->SetDrawOption("E");
483
484    TH1F * hMeanLVsRun=new TH1F("hMeanLVsRun","hMeanLVsRun;run; <L> (cm)",nRuns, 0., nRuns);//, 350, 350. , 700.);
485    hMeanLVsRun->SetDrawOption("E");
486    TH1F * hNegLRatioVsRun=new TH1F("hNegLRatioVsRun","hNegLRatioVsRun;run; ratio of tracks with L<350 cm (%)",nRuns, 0., nRuns);//, 1000, 0. , 100.);
487    hNegLRatioVsRun->SetDrawOption("E");
488    TH1F * hMatchEffVsRun=new TH1F("hMatchEffVsRun","hMatchEffVsRun;run;matching efficiency (pT>1.5 GeV/c)",nRuns, 0., nRuns);//, 100, 0. , 1.);
489    hMatchEffVsRun->SetDrawOption("E");
490    TH1F * hMatchEffVsRun1=new TH1F("hMatchEffVsRun1","hMatchEffVsRun;run;matching efficiency (pT>1.0 GeV/c)",nRuns, 0., nRuns);
491    hMatchEffVsRun1->SetDrawOption("E");
492    TH1F * hPeakT0AVsRun=new TH1F("hPeakT0AVsRun","hPeakT0AVsRun (gaussian fit);run;t0A (ps)",nRuns,0., nRuns);
493    TH1F * hPeakT0CVsRun=new TH1F("hPeakT0CVsRun","hPeakT0CVsRun (gaussian fit);run;t0AC (ps)",nRuns,0., nRuns);
494    TH1F * hPeakT0ACVsRun=new TH1F("hPeakT0ACVsRun","hPeakT0ACVsRun (gaussian fit);run;t0AC (ps)",nRuns,0., nRuns);
495    TH1F * hT0fillResVsRun=new TH1F("hT0fillResVsRun","hT0fillResVsRun;run;t0_spread (ps)",nRuns,0., nRuns);
496   
497    lista.Add(hAvDiffTimeVsRun);
498    lista.Add(hPeakDiffTimeVsRun);
499    lista.Add(hSpreadDiffTimeVsRun);
500    lista.Add(hAvTimeVsRun);
501    lista.Add(hPeakTimeVsRun);
502    lista.Add(hSpreadTimeVsRun);
503    lista.Add(  hAvRawTimeVsRun);
504    lista.Add(  hPeakRawTimeVsRun);
505    lista.Add(  hSpreadRawTimeVsRun); 
506    lista.Add(  hAvTotVsRun);
507    lista.Add(  hPeakTotVsRun);
508    lista.Add(  hSpreadTotVsRun);
509    lista.Add(  hNegTimeRatioVsRun);
510    lista.Add(  hOrphansRatioVsRun);
511    lista.Add( hMeanLVsRun);
512    lista.Add(  hNegLRatioVsRun);
513    lista.Add(  hMatchEffVsRun);
514    lista.Add(hPeakT0AVsRun);
515    lista.Add(hPeakT0CVsRun);
516    lista.Add(hPeakT0ACVsRun);
517    lista.Add(hT0fillResVsRun);
518   char runlabel[6];
519    
520   for (Int_t irun=0;irun<nRuns;irun++){
521     ttree->GetEntry(irun);
522     
523     sprintf(runlabel,"%i",runNumber);
524     
525     hAvDiffTimeVsRun->SetBinContent(irun+1, avDiffTime);
526     hAvDiffTimeVsRun->GetXaxis()->SetBinLabel(irun+1,runlabel);
527
528     hPeakDiffTimeVsRun->SetBinContent(irun+1,peakDiffTime);
529     hPeakDiffTimeVsRun->SetBinError(irun+1,peakDiffTimeErr);
530     hPeakDiffTimeVsRun->GetXaxis()->SetBinLabel(irun+1,runlabel);
531
532     hSpreadDiffTimeVsRun->SetBinContent(irun+1,spreadDiffTime);
533     hSpreadDiffTimeVsRun->SetBinError(irun+1,spreadDiffTimeErr);
534     hSpreadDiffTimeVsRun->GetXaxis()->SetBinLabel(irun+1,runlabel);
535
536     hAvTimeVsRun->SetBinContent(irun+1, avTime);
537     hAvTimeVsRun->GetXaxis()->SetBinLabel(irun+1,runlabel);
538
539     hPeakTimeVsRun->SetBinContent(irun+1,peakTime);
540     hPeakTimeVsRun->SetBinError(irun+1,peakTimeErr);
541     hPeakTimeVsRun->GetXaxis()->SetBinLabel(irun+1,runlabel);
542
543     hSpreadTimeVsRun->SetBinContent(irun+1,spreadTime);
544     hSpreadTimeVsRun->SetBinError(irun+1,spreadTimeErr);
545     hSpreadTimeVsRun->GetXaxis()->SetBinLabel(irun+1,runlabel);
546
547     hAvRawTimeVsRun->SetBinContent(irun+1, avRawTime);
548     hAvRawTimeVsRun->GetXaxis()->SetBinLabel(irun+1,runlabel);
549     
550     hPeakRawTimeVsRun->SetBinContent(irun+1,peakRawTime);
551     hPeakRawTimeVsRun->SetBinError(irun+1,peakRawTimeErr);
552     hPeakRawTimeVsRun->GetXaxis()->SetBinLabel(irun+1,runlabel);
553
554     hSpreadRawTimeVsRun->SetBinContent(irun+1,spreadRawTime);
555     hSpreadRawTimeVsRun->SetBinError(irun+1,spreadRawTimeErr);
556     hSpreadRawTimeVsRun->GetXaxis()->SetBinLabel(irun+1,runlabel);
557
558     hAvTotVsRun->SetBinContent(irun,avTot);
559     hAvTotVsRun->GetXaxis()->SetBinLabel(irun+1,runlabel);
560
561     hPeakTotVsRun->SetBinContent(irun,peakTot);
562     hPeakTotVsRun->SetBinError(irun+1,peakTotErr);
563     hPeakTotVsRun->GetXaxis()->SetBinLabel(irun+1,runlabel);
564
565     hSpreadTotVsRun->SetBinContent(irun,spreadTot);
566     hSpreadTotVsRun->SetBinError(irun+1,spreadTotErr);
567     hSpreadTotVsRun->GetXaxis()->SetBinLabel(irun+1,runlabel);
568     
569     hNegTimeRatioVsRun->SetBinContent(irun,negTimeRatio);
570     hNegTimeRatioVsRun->GetXaxis()->SetBinLabel(irun+1,runlabel);
571     
572     hOrphansRatioVsRun->SetBinContent(irun,orphansRatio);
573     hOrphansRatioVsRun->GetXaxis()->SetBinLabel(irun+1,runlabel);
574     
575     hMeanLVsRun->SetBinContent(irun,avL);
576     hMeanLVsRun->GetXaxis()->SetBinLabel(irun+1,runlabel);
577     
578     hNegLRatioVsRun->SetBinContent(irun,negLratio);
579     hNegLRatioVsRun->GetXaxis()->SetBinLabel(irun+1,runlabel);
580
581     hMatchEffVsRun->SetBinContent(irun,matchEffLinFit1Gev);
582     hMatchEffVsRun->SetBinError(irun+1,matchEffLinFit1GevErr);
583     hMatchEffVsRun->GetXaxis()->SetBinLabel(irun+1,runlabel);
584
585     hPeakT0AVsRun->SetBinContent(irun+1,peakT0A);
586     hPeakT0AVsRun->SetBinError(irun+1,spreadT0A);
587     hPeakT0AVsRun->GetXaxis()->SetBinLabel(irun+1,runlabel);
588
589     hPeakT0CVsRun->SetBinContent(irun+1,peakT0C);
590     hPeakT0CVsRun->SetBinError(irun+1,spreadT0C);
591     hPeakT0CVsRun->GetXaxis()->SetBinLabel(irun+1,runlabel);
592     
593     hPeakT0ACVsRun->SetBinContent(irun+1,peakT0AC);
594     hPeakT0ACVsRun->SetBinError(irun+1,spreadT0AC);
595     hPeakT0ACVsRun->GetXaxis()->SetBinLabel(irun+1,runlabel);
596     hT0fillResVsRun->SetBinContent(irun+1,avT0fillRes);
597
598   }
599   
600   char  outfilename[200];
601   sprintf(outfilename, "trend_%s",trendFileName);
602   TFile * fout=new TFile(outfilename,"recreate");
603   fout->cd();
604   lista.Write();
605   fout->Close();
606
607   return 0;
608 }
609
610 //------------------------------------------------------------------------------------
611
612 Int_t RunESDQApostAnalysis(char *qafilename=NULL, Int_t runNumber=-1, Bool_t IsOnGrid=kFALSE, Bool_t canvasE=kFALSE) {
613   
614   Bool_t debug=kFALSE;
615   
616   /*access qa PWG1 output files - saved locally or on grid as specified by the second argument */
617   
618   char defaultQAoutput[30]="QAresults.root";
619   TGrid::Connect("alien://");
620   TFile * fin= TFile::Open(qafilename,"r");
621   printf("Opening file %s\n",qafilename);
622   if (!fin) {
623     printf("ERROR: QA output not found. Exiting with status -1\n");
624       return -1;
625   } else {
626     printf("INFO: QA output file %s open. \n",fin->GetName());
627   }
628   
629  
630   //access histograms lists
631   char tofQAdirName[15]="TOF_Performance";
632   char genListName[15]="cGeneralTOFqa";
633   char t0ListName[15]="cTimeZeroTOFqa";
634   char pidListName[15]="cPIDTOFqa"; 
635   char posListName[15]="cPositiveTOFqa";
636   char negListName[15]="cNegativeTOFqa";
637   
638   TDirectoryFile * tofQAdir=(TDirectoryFile*)fin->Get(tofQAdirName);
639   if(debug){
640     printf("------------------------------------------------------------------\n");
641     tofQAdir->ls();
642     printf("------------------------------------------------------------------\n");
643   }
644   
645   TList * generalList=(TList*)tofQAdir->Get(genListName);
646   TList  *timeZeroList=(TList*)tofQAdir->Get(t0ListName);
647   TList  *pidList=(TList*)tofQAdir->Get(pidListName);
648   TList  *posList=(TList*)tofQAdir->Get(posListName);
649   TList  *negList=(TList*)tofQAdir->Get(negListName);
650
651   if (!generalList) printf("WARNING: general QA histograms absent or not accessible\n");
652   if (!timeZeroList) printf("WARNING: timeZero QA histograms absent or not accessible\n");
653   if (!pidList) printf("WARNING: PID QA histograms absent or not accessible\n");
654   if (!posList) printf("WARNING: general QA histograms for positive tracks absent or not accessible\n");
655   if (!negList) printf("WARNING: general QA histograms for negative tracks absent or not accessible\n");
656
657   if ( (!generalList) && (!timeZeroList) && (!pidList) ){
658     printf("ERROR: no QA available \n");
659     return 1;
660   }
661   
662   if (debug){
663     generalList->ls();
664     printf("------------------------------------------------------------------\n");
665     timeZeroList->ls();
666     printf("------------------------------------------------------------------\n");
667     pidList->ls();
668     printf("------------------------------------------------------------------\n");
669       }
670
671   /*set graphic style*/
672   gStyle->SetCanvasColor(kWhite);
673   gStyle->SetFrameFillColor(kWhite);
674   gStyle->SetFrameBorderMode(0);
675   gStyle->SetCanvasBorderMode(0);
676   gStyle->SetTitleFillColor(kWhite);
677   gStyle->SetTitleBorderSize(0)  ;
678   gStyle->SetTitleFont(42);
679   gStyle->SetTextFont(42);
680   gStyle->SetPalette(1);
681   gStyle->SetStatColor(kWhite); 
682   gStyle->SetStatBorderSize(1);
683   gStyle->SetOptStat(111111);
684   
685   //DEFINE OUTPUT FILE 
686   char outfilename[60];
687   sprintf(outfilename,"postQA_%i.root",runNumber);
688   TFile * fout=new TFile(outfilename,"recreate");
689
690   TH1I* hRunNumber=new TH1I("hRunNumber","hRunNumber;run",1,runNumber,runNumber+1);
691   hRunNumber->Fill(runNumber);
692
693    //-------------------------------------------------------------
694   /*GENERAL MONITOR - MULTIPLICITY*/
695   TH1F*hMulti= (TH1F*) generalList->At(0);
696
697   TH1F* hFractionEventsWhits=new TH1F("hFractionEventsWhits","hFractionEventsWhits;fraction of events with hits (%)",200,0.,100.);
698   Float_t fraction=0.0;
699   if (hMulti->GetEntries()>0.0) fraction=((Float_t) hMulti->GetBinContent(1))/((Float_t) hMulti->GetEntries());
700   else fraction=0.0;
701   hFractionEventsWhits->Fill(fraction*100.);
702
703   //-------------------------------------------------------------
704   /*GENERAL MONITOR - TIMING AND GEOMETRY*/
705   TH1F * hTime = (TH1F*) generalList->At(1);
706   hTime->SetMarkerStyle(8);
707   hTime->SetMarkerSize(0.7);
708   hTime->SetMarkerColor(kBlue);
709   hTime->SetLineColor(kBlue);
710   hTime->SetFillColor(kBlue);
711   hTime->SetFillStyle(3001);
712   hTime->Rebin(2);
713   hTime->GetYaxis()->SetTitle("matched tracks"); 
714   hTime->GetYaxis()->SetTitleOffset(1.35);
715   
716   TH1F * hRawTime = (TH1F*) generalList->At(2);
717   hRawTime->SetMarkerStyle(21);
718   hRawTime->SetMarkerSize(0.7);
719   hRawTime->SetMarkerColor(kGreen);
720   hRawTime->SetLineColor(kGreen);
721   hRawTime->SetFillColor(kGreen);
722   hRawTime->SetFillStyle(3001); 
723   hRawTime->Rebin(2);
724   hRawTime->GetYaxis()->SetTitle("matched tracks");
725   hRawTime->GetYaxis()->SetTitleOffset(1.35);
726   
727   TLegend *lTime = new TLegend(0.7125881,0.6052519,0.979435,0.7408306,NULL,"brNDC");
728   lTime->SetTextSize(0.04281433);
729   lTime->AddEntry(hRawTime, "raw","L");
730   lTime->AddEntry(hTime, "ESD","L"); 
731   lTime->SetFillColor(kWhite);
732   lTime->SetShadowColor(0);
733
734   TH1F * hTot = (TH1F*) generalList->At(3);
735   hTot->SetMarkerStyle(8);
736   hTot->SetMarkerSize(0.7);
737   hTot->SetMarkerColor(kViolet-3);
738   hTot->SetLineColor(kViolet-3);
739   hTot->SetFillColor(kViolet-3);
740   hTot->SetFillStyle(3001);
741   //hTime->SetDrawOption();
742   hTot->GetYaxis()->SetTitle("matched tracks");
743   hTot->GetYaxis()->SetTitleOffset(1.35);
744   
745   
746   char orphansTxt[200];
747   Float_t orphansRatio=0.0;
748   if (hTot->GetEntries()>1){
749     orphansRatio=((Float_t) hTot->GetBinContent(1))/((Float_t) hTot->GetEntries()) ;
750   }
751   sprintf(orphansTxt,"orphans/matched tracks = %.4f ",orphansRatio);
752   TH1F * hOrphansRatio=new TH1F("hOrphansRatio","Percentage of signals with only leading edge; percentage (%)",1000,0.,100.);
753   hOrphansRatio->Fill(orphansRatio*100.);  
754
755
756   TPaveText *tOrphans = new TPaveText(0.38,0.63,0.88,0.7, "NDC");
757   //NDC sets coords relative to pad
758   tOrphans->SetBorderSize(0);
759   tOrphans->SetTextSize(0.045);
760   tOrphans->SetFillColor(0); //white background
761   tOrphans->SetTextAlign(12);
762   tOrphans->SetTextColor(kViolet-3);
763   tOrphans->AddText(orphansTxt);
764       
765   TH1F * hL = (TH1F*) generalList->At(4);
766   hL->SetMarkerStyle(8);
767   hL->SetMarkerSize(0.7);
768   hL->SetMarkerColor(kOrange-3);
769   hL->SetLineColor(kOrange-3);
770   hL->SetFillColor(kOrange-3);
771   hL->SetFillStyle(3001);
772   //hTime->SetDrawOption();
773   hL->GetYaxis()->SetTitle("matched tracks");
774   hL->GetYaxis()->SetTitleOffset(1.35);
775
776   char negLengthTxt[200];
777   Float_t negLengthRatio=0.0;
778   if (hL->GetEntries()>1){
779     negLengthRatio=(hL->Integral(1,750))/((Float_t) hL->GetEntries()) ;
780   }
781   sprintf(negLengthTxt,"tracks with L<350cm /matched tracks = %.5f ",negLengthRatio);
782   TH1F * hLnegRatio=new TH1F("hLnegRatio","Ratio of TOF-matched tracks with L<350cm; ratio (%)",10000,0.,100.);
783   hLnegRatio->Fill(negLengthRatio*100);
784   
785
786
787   TPaveText *tLength = new TPaveText(0.15,0.83,0.65,0.87, "NDC");
788   //NDC sets coords relative to pad
789   tLength->SetBorderSize(0);
790   tLength->SetTextSize(0.04);
791   tLength->SetFillColor(0); //white background
792   tLength->SetTextAlign(11);
793   tLength->SetTextColor(kOrange-3);
794   tLength->AddText(negLengthTxt);
795  
796   if (canvasE){
797   TCanvas *cTrackProperties= new TCanvas("cTrackProperties","summary of matched tracks properties",900,900);
798   cTrackProperties->Divide(2,2);
799   cTrackProperties->cd(1);
800   gPad->SetLogy();
801   hTime->Draw("BAR");
802   hRawTime ->Draw("BARsame");
803   lTime->Draw();  
804   cTrackProperties->cd(2);
805   gPad->SetLogy();
806   hTot->Draw("BAR");
807   tOrphans->Draw(); 
808   cTrackProperties->cd(3);
809   gPad->SetLogy();
810   hL->Draw("BAR");
811   tLength->Draw(); 
812   }
813   fout->cd();
814   hRunNumber->Write();
815   hMulti->Write();
816   hFractionEventsWhits->Write();
817   hTime->Write();
818   hRawTime->Write();
819   hTot->Write();
820   hOrphansRatio->Write();
821   hL->Write();
822   hLnegRatio->Write();
823   
824   TH2F* hDxPos4profile = (TH2F*) generalList->At(14);
825   TH2F* hDxNeg4profile = (TH2F*) generalList->At(13);
826     
827   char profilename[30];
828   const Int_t ybinMin = 0;
829   const Int_t ybinMax =hDxPos4profile->GetYaxis()->GetNbins() ;
830   sprintf(profilename,"profDxPos");
831   TProfile * profDxPos = (TProfile*)hDxPos4profile->ProfileX(profilename, ybinMin,ybinMax); 
832   sprintf(profilename,"profDxNeg");
833   profDxPos->SetLineWidth(2);
834   TProfile * profDxNeg = (TProfile*)hDxNeg4profile->ProfileX(profilename, ybinMin, ybinMax); 
835   profDxNeg->SetLineWidth(2);  
836  
837   TH1 *profRatioPosOverNegDx = (TH1*) profDxPos->Clone();
838   profRatioPosOverNegDx->SetName("profRatioPosOverNegDx");
839   profRatioPosOverNegDx->Divide((TH1*) profDxNeg);
840   profRatioPosOverNegDx->GetYaxis()->SetRangeUser(-5.,5.);
841   profRatioPosOverNegDx->GetXaxis()->SetRangeUser(0.,2.);
842   if (canvasE){
843   TCanvas *residuals= new TCanvas("residuals","residuals",900,450);
844   residuals->Divide(2,1);
845   residuals->cd(1);
846   hDxPos4profile->GetYaxis()->SetRangeUser(-5.,5.);
847   hDxPos4profile->Draw("colz");
848   profDxPos->SetLineColor(kRed);
849   profDxPos ->Draw("same");
850   residuals->cd(2);
851   hDxNeg4profile->GetYaxis()->SetRangeUser(-5.,5.); 
852   hDxNeg4profile->Draw("colz");
853   profDxNeg->SetLineColor(kBlue);
854   profDxNeg->Draw("same"); 
855   }
856
857   fout->cd();
858   hDxPos4profile->Write();
859   hDxNeg4profile->Write();
860   profDxPos->Write();
861   profDxNeg->Write();
862   profRatioPosOverNegDx->Write();
863   //-------------------------------------------------------------
864   /* T0 DETECTOR MONITOR*/
865
866  TH1F * hT0AC = (TH1F*) timeZeroList->At(0);
867  hT0AC->SetMarkerStyle(8);
868  hT0AC->SetMarkerSize(0.7);
869  hT0AC->SetMarkerColor(kRed);
870  hT0AC->SetLineColor(kRed);
871  hT0AC->SetFillColor(kRed);
872  hT0AC->SetFillStyle(1001);
873  hT0AC->Rebin(2);
874  hT0AC->GetYaxis()->SetTitle("events"); 
875  hT0AC->GetYaxis()->SetTitleOffset(1.35);
876  hT0AC->GetXaxis()->SetLabelSize(0.03);
877  
878  TH1F * hT0A = (TH1F*) timeZeroList->At(1);
879  hT0A->SetMarkerStyle(8);
880  hT0A->SetMarkerSize(0.7);
881  hT0A->SetMarkerColor(kBlue);
882  hT0A->SetLineColor(kBlue);
883  hT0A->SetFillColor(kBlue);
884  hT0A->SetFillStyle(1001);
885  hT0A->Rebin(2);
886  hT0A->GetYaxis()->SetTitle("events"); 
887  hT0A->GetYaxis()->SetTitleOffset(1.35);
888  hT0A->GetXaxis()->SetLabelSize(0.03);
889
890  TH1F * hT0C = (TH1F*) timeZeroList->At(2);
891  hT0C->SetMarkerStyle(8);
892  hT0C->SetMarkerSize(0.7);
893  hT0C->SetMarkerColor(kGreen);
894  hT0C->SetLineColor(kGreen);
895  hT0C->SetFillColor(kGreen);
896  hT0C->SetFillStyle(1001);
897  hT0C->Rebin(2);
898  hT0C->GetYaxis()->SetTitle("events"); 
899  hT0C->GetYaxis()->SetTitleOffset(1.35);
900  hT0C->GetXaxis()->SetLabelSize(0.03);
901  
902  TLegend *lT0 = new TLegend(0.7125881,0.6052519,0.979435,0.7408306,NULL,"brNDC");
903   lT0->SetTextSize(0.041);
904   lT0->AddEntry(hT0AC, "T0 A&C","L");
905   lT0->AddEntry(hT0A, "T0 A","L"); 
906   lT0->AddEntry(hT0C, "T0 C","L");
907   lT0->SetFillColor(kWhite);
908   lT0->SetShadowColor(0);
909   
910   TH1F * hT0res = (TH1F*) timeZeroList->At(3);
911   hT0res->GetXaxis()->SetLabelSize(0.03);
912   if (canvasE){
913   TCanvas *cT0detector= new TCanvas("cT0detector","T0 detector",900,450);
914   cT0detector->Divide(2,1);
915   cT0detector->cd(1);
916   hT0AC->Draw("BAR");
917   hT0AC->SetTitle("timeZero measured by T0 detector");
918   hT0A ->Draw("BARsame");
919   hT0C ->Draw("BARsame");
920   lT0->Draw();  
921   cT0detector->cd(2);
922   // gPad->SetLogy();
923   hT0res->Draw();
924   // myText1->Draw(); 
925   // cTrackProperties->cd(3);
926   // gPad->SetLogy();
927   // hL->Draw("BAR");
928   // myText2->Draw(); 
929   }
930
931   TH1F * hT0fillRes = (TH1F*) timeZeroList->At(8);
932   hT0fillRes->GetXaxis()->SetLabelSize(0.03);
933
934   fout->cd();
935   hT0AC->Write();
936   hT0A->Write();
937   hT0C->Write();
938   hT0res->Write();
939   hT0fillRes->Write();
940   lT0->Write();
941   
942
943   //-------------------------------------------------------------
944   /*MATCHING EFFICIENCY  MONITOR*/
945
946   //TH1F * hMatchingVsP =new TH1F("hMatchingVsP","Matching probability vs. P; P(GeV/c); matching probability", 50, 0., 5. );
947   
948   TH1F * hMatchingVsPt =new TH1F("hMatchingVsPt","Matching probability vs. Pt; Pt(GeV/c); matching probability", 50, 0., 5. );
949   
950   TH1F * hMatchingVsEta =new TH1F("hMatchingVsEta","Matching probability vs. #\Eta; #\Eta; matching probability", 20, -1., 1.);
951   
952   TH1F * hMatchingVsPhi =new TH1F("hMatchingVsPhi","Matching probability vs. Phi; Phi(rad); matching probability", 628, 0., 6.28);
953   
954   /*/matching as function of p
955   TH1F * hDenom=(TH1F*)generalList->At(9); 
956   if (hDenom) {  
957       hMatchingVsP=(TH1F*) generalList->At(5); 
958       hMatchingVsP->Rebin(5);
959       hDenom->Rebin(5);
960       hMatchingVsP->Divide(hDenom);
961       hMatchingVsP->GetYaxis()->SetTitle("matching efficiency");
962       hMatchingVsP->SetTitle("TOF matching efficiency as function of momentum");
963       }*/
964   
965   //matching as function of pT
966   
967   // hDenom->Clear();
968   TH1F * hDenom=(TH1F*)generalList->At(10); 
969   if (hDenom) {  
970     hMatchingVsPt=(TH1F*) generalList->At(6); 
971     hMatchingVsPt->Rebin(5);
972     hDenom->Rebin(5);
973     hMatchingVsPt->Divide(hDenom);
974     hMatchingVsPt->GetYaxis()->SetTitle("matching efficiency");
975     hMatchingVsPt->SetTitle("TOF matching efficiency as function of transverse momentum");
976     hMatchingVsPt->GetYaxis()->SetRangeUser(0,1.2); 
977   }
978   
979   //matching as function of eta
980   hDenom->Clear();
981   hDenom=(TH1F*)generalList->At(11); 
982   if (hDenom) {  
983     hMatchingVsEta=(TH1F*) generalList->At(7); 
984     hMatchingVsEta->Rebin(5);
985     hDenom->Rebin(5);
986     hMatchingVsEta->Divide(hDenom);
987     hMatchingVsEta->GetXaxis()->SetRangeUser(-1,1);
988     hMatchingVsEta->GetYaxis()->SetTitle("matching efficiency");
989     hMatchingVsEta->GetYaxis()->SetRangeUser(0,1.2);
990     hMatchingVsEta->SetTitle("TOF matching efficiency as function of pseudorapidity");
991   }
992   //matching as function of phi
993   hDenom->Clear();
994   hDenom=(TH1F*)generalList->At(12); 
995   if (hDenom) {  
996     hMatchingVsPhi=(TH1F*) generalList->At(8); 
997     //hMatchingVsPhi->Rebin(5);
998     //hDenom->Rebin(5);
999     hMatchingVsPhi->Divide(hDenom);
1000     hMatchingVsPhi->GetYaxis()->SetTitle("matching efficiency");
1001     hMatchingVsPhi->SetTitle("TOF matching efficiency as function of phi");
1002     hMatchingVsPhi->GetYaxis()->SetRangeUser(0,1.2);
1003   }
1004   if (  canvasE){
1005 TCanvas *cMatchingPerformance= new TCanvas("cMatchingPerformance","summary of matching performance",700,400);
1006   cMatchingPerformance->Divide(2,2);
1007   cMatchingPerformance->cd(1);
1008   gPad->SetGridy();
1009   hMatchingVsPt->Draw();
1010   cMatchingPerformance->cd(2);
1011   gPad->SetGridy();
1012   hMatchingVsEta->Draw();
1013   cMatchingPerformance->cd(3);
1014   gPad->SetGridy();
1015   hMatchingVsPhi->Draw();
1016   }
1017   fout->cd();
1018   hMatchingVsPt->Write();
1019   hMatchingVsEta->Write();
1020   hMatchingVsPhi->Write();
1021   
1022   //----------------------------------------------------
1023   /* PID PERFORMANCE MONITOR */
1024
1025   TH2F * hBetaP=(TH2F*)pidList->At(0);
1026   hBetaP->GetYaxis()->SetRangeUser(0.,1.2);
1027   TH1F * hMass=(TH1F*)pidList->At(1);
1028   //hMass->SetMarkerColor(kBlue);
1029   //hMass->SetLineColor(kBlue);
1030   hMass->SetFillColor(kAzure+10);
1031   hMass->SetFillStyle(1001);
1032   hMass->Rebin(2);
1033   hMass->GetYaxis()->SetTitle("tracks"); 
1034   hMass->GetYaxis()->SetTitleOffset(1.35);
1035   hMass->GetXaxis()->SetLabelSize(0.03);
1036
1037   TH1F * hPionDiff=(TH1F*)pidList->At(3); 
1038   
1039
1040   TH2F * hDiffTimePi=(TH2F*)pidList->At(4); 
1041   hDiffTimePi->GetYaxis()->SetRangeUser(-2000.,2000.);
1042   //hDiffTime->GetYaxis()->Rebin(2);//1 bin=10 ps
1043   sprintf(profilename,"profDiffTimePi");
1044  
1045   TProfile * profDiffTimePi = (TProfile*)hDiffTimePi->ProfileX(profilename, 490, 510); 
1046   profDiffTimePi->SetLineWidth(2);
1047   profDiffTimePi->SetLineColor(kRed+2); 
1048
1049   TH2F * hDiffTimePiTh=(TH2F*)pidList->At(6); 
1050   //hDiffTime->GetYaxis()->Rebin(2);//1 bin=10 ps
1051   sprintf(profilename,"profDiffTimePiTh");
1052   hDiffTimePiTh->GetYaxis()->SetRangeUser(-2000.,2000.); 
1053   
1054   TProfile * profDiffTimePiTh = (TProfile*)hDiffTimePiTh->ProfileX(profilename, 490, 510);
1055   profDiffTimePiTh->SetLineWidth(2);
1056   profDiffTimePiTh->SetLineColor(kRed+2);
1057
1058   TH2F * hDiffTimeKa=(TH2F*)pidList->At(9); 
1059   //hDiffTime->GetYaxis()->Rebin(2);//1 bin=10 ps
1060   sprintf(profilename,"profDiffTimeKa");
1061   hDiffTimeKa->GetYaxis()->SetRangeUser(-2000.,2000.);
1062   
1063   TProfile * profDiffTimeKa = (TProfile*)hDiffTimeKa->ProfileX(profilename, 490, 510); 
1064   profDiffTimeKa->SetLineWidth(2);
1065   profDiffTimeKa->SetLineColor(kBlue);  
1066
1067  TH2F * hDiffTimeKaTh=(TH2F*)pidList->At(11); 
1068   //hDiffTime->GetYaxis()->Rebin(2);//1 bin=10 ps
1069   sprintf(profilename,"profDiffTimeKaTh");
1070   hDiffTimeKaTh->GetYaxis()->SetRangeUser(-2000.,2000.);
1071   TProfile * profDiffTimeKaTh = (TProfile*)hDiffTimeKaTh->ProfileX(profilename, 490, 510); 
1072   profDiffTimeKaTh->SetLineWidth(2);
1073   profDiffTimeKaTh->SetLineColor(kBlue);
1074   
1075   TH2F * hDiffTimePro=(TH2F*)pidList->At(14); 
1076   //hDiffTime->GetYaxis()->Rebin(2);//1 bin=10 ps
1077   sprintf(profilename,"profDiffTimePro");
1078   hDiffTimePro->GetYaxis()->SetRangeUser(-2000.,2000.);
1079   TProfile * profDiffTimePro = (TProfile*)hDiffTimePro->ProfileX(profilename, 490, 510); 
1080   profDiffTimePro->SetLineWidth(2);
1081   profDiffTimePro->SetLineColor(kGreen+2);  
1082
1083   TH2F * hDiffTimeProTh=(TH2F*)pidList->At(16); 
1084   //hDiffTime->GetYaxis()->Rebin(2);//1 bin=10 ps
1085   sprintf(profilename,"profDiffTimeProTh");
1086   hDiffTimeProTh->GetYaxis()->SetRangeUser(-2000.,2000.);
1087   TProfile * profDiffTimeProTh = (TProfile*)hDiffTimeProTh->ProfileX(profilename, 490, 510);
1088   profDiffTimeProTh->SetLineWidth(2);
1089   profDiffTimeProTh->SetLineColor(kGreen+2);
1090
1091   if (canvasE){
1092   TCanvas *cPidPerformance= new TCanvas("cPidPerformance","summary of pid performance",800,800);
1093   cPidPerformance->Divide(2,1);
1094   cPidPerformance->cd(1);
1095   gPad->SetGridy();
1096   gPad->SetGridx();
1097   gPad->SetLogz();
1098   hBetaP->Draw("colz"); 
1099   
1100   cPidPerformance->cd(2);
1101   gPad->SetLogy();
1102   gPad->SetGridy();
1103   hMass->Draw("HIST BAR");
1104   
1105   TLegend * lPid=new TLegend(0.75,0.75,0.95,0.95,"PID");
1106   lPid->AddEntry(profDiffTimePi,"#pi^{#pm}","l");
1107   lPid->AddEntry(profDiffTimeKa,"K^{#pm}","l");
1108   lPid->AddEntry(profDiffTimePro,"p^{#pm}","l");
1109
1110   gStyle->SetOptStat(10);
1111   TCanvas *cPidPerformance2= new TCanvas("cPidPerformance2","summary of pid performance - tracking",700,700);
1112   cPidPerformance2->Divide(2,2);
1113   cPidPerformance2->cd(1);
1114   gPad->SetLogz();
1115   hDiffTimePi->Draw("colz");
1116   // profDiffTimePi->Draw("same");
1117   
1118   cPidPerformance2->cd(2);
1119   gPad->SetLogz();
1120   hDiffTimeKa->Draw("colz");
1121   //profDiffTimeKa->Draw("same");
1122   cPidPerformance2->cd(3);
1123   gPad->SetLogz();
1124   hDiffTimePro->Draw("colz");
1125   //  profDiffTimePro->Draw("same");
1126  
1127  // cPidPerformance2->cd(4);
1128  //  profDiffTimePi->Draw();
1129  //  profDiffTimeKa->Draw("same");
1130  //  profDiffTimePro->Draw("same");
1131  //  lPid->Draw("same");
1132   
1133 TCanvas *cPidPerformanceTh= new TCanvas("cPidPerformanceTh","summary of pid performance - theoretical times",700,700);
1134   cPidPerformanceTh->Divide(2,2);
1135   cPidPerformanceTh->cd(1);
1136   gPad->SetLogz();
1137   hDiffTimePiTh->Draw("colz");
1138   profDiffTimePiTh->Draw("same");
1139   cPidPerformanceTh->cd(2);
1140   gPad->SetLogz();
1141   hDiffTimeKaTh->Draw("colz");
1142   profDiffTimeKaTh->Draw("same");
1143   cPidPerformanceTh->cd(3);
1144   gPad->SetLogz();
1145   hDiffTimeProTh->Draw("colz");
1146   profDiffTimeProTh->Draw("same");
1147   // cPidPerformanceTh->cd(4);
1148   // profDiffTimePiTh->Draw();
1149   // profDiffTimeKaTh->Draw("same");
1150   // profDiffTimeProTh->Draw("same");
1151   // lPid->Draw("same");
1152   }
1153   
1154   TH1F * hPionDiff=(TH1F*)pidList->FindObject("hTOFmatchedExpTimePi"); 
1155   TH1F * hKaonDiff=(TH1F*)pidList->FindObject("hTOFmatchedExpTimeKa"); 
1156   TH1F * hProtonDiff=(TH1F*)pidList->FindObject("hTOFmatchedExpTimePro"); 
1157  
1158
1159   fout->cd();
1160   hPionDiff->Write();
1161   hKaonDiff->Write();
1162   hProtonDiff->Write();
1163
1164   hBetaP->Write();
1165   hMass->Write();
1166   hDiffTimePi->Write();
1167   profDiffTimePi->Write();
1168   hDiffTimeKa->Write();
1169   profDiffTimeKa->Write();
1170   hDiffTimePro->Write();
1171   profDiffTimePro->Write();
1172   //lPid->Draw();
1173   hDiffTimePiTh->Write();
1174   profDiffTimePiTh->Write();
1175   hDiffTimeKaTh->Write();
1176   profDiffTimeKaTh->Write();
1177   hDiffTimeProTh->Write();
1178   profDiffTimeProTh->Write();
1179   
1180   //SIGMAS PID
1181   TH2F * hSigmaPi=(TH2F*)pidList->At(7); 
1182   sprintf(profilename,"profSigmaPi");
1183   hSigmaPi->GetYaxis()->SetRangeUser(-5.,5.);
1184   TProfile * profSigmaPi = (TProfile*)hSigmaPi->ProfileX(profilename); 
1185   profSigmaPi->SetLineWidth(2);
1186   profSigmaPi->SetLineColor(kRed+2); 
1187
1188   TH2F * hSigmaKa=(TH2F*)pidList->At(12); 
1189   sprintf(profilename,"profSigmaKa");
1190   hSigmaKa->GetYaxis()->SetRangeUser(-5.,5.);
1191   TProfile * profSigmaKa = (TProfile*)hSigmaKa->ProfileX(profilename); 
1192   profSigmaKa->SetLineWidth(2);
1193   profSigmaKa->SetLineColor(kBlue);  
1194
1195   TH2F * hSigmaPro=(TH2F*)pidList->At(17); 
1196   sprintf(profilename,"profSigmaPro");
1197   hSigmaPro->GetYaxis()->SetRangeUser(-5.,5.);
1198   TProfile * profSigmaPro = (TProfile*)hSigmaPro->ProfileX(profilename); 
1199   profSigmaPro->SetLineWidth(2);
1200   profSigmaPro->SetLineColor(kGreen+2);  
1201
1202
1203   if (canvasE){
1204   TCanvas *cPidPerformance= new TCanvas("cPidPerformance","summary of pid performance",800,800);
1205   cPidPerformance->Divide(2,1);
1206   cPidPerformance->cd(1);
1207   gPad->SetGridy();
1208   gPad->SetGridx();
1209   gPad->SetLogz();
1210   hBetaP->Draw("colz"); 
1211   
1212   cPidPerformance->cd(2);
1213   gPad->SetLogy();
1214   gPad->SetGridy();
1215   hMass->Draw("HIST BAR");
1216
1217   TLegend * lSigmaPid=new TLegend(0.75,0.75,0.95,0.95,"#sigma_{PID}");
1218   lSigmaPid->AddEntry(profSigmaPi,"#pi^{#pm}","l");
1219   lSigmaPid->AddEntry(profSigmaKa,"K^{#pm}","l");
1220   lSigmaPid->AddEntry(profSigmaPro,"p^{#pm}","l");
1221
1222   TCanvas *cPidPerformance3= new TCanvas("cPidPerformance3","summary of pid performance - sigmas",1200,400);
1223   cPidPerformance3->Divide(3,1);
1224   cPidPerformance3->cd(1);
1225   gPad->SetLogz();
1226   gPad->SetGridy();
1227
1228   hSigmaPi->Draw("colz");
1229   profSigmaPi->Draw("same");
1230
1231   cPidPerformance3->cd(2);
1232   gPad->SetLogz();
1233   gPad->SetGridy();
1234   hSigmaKa->Draw("colz");
1235   profSigmaKa->Draw("same");
1236
1237   cPidPerformance3->cd(3);
1238   gPad->SetLogz();
1239   hSigmaPro->Draw("colz");
1240   profSigmaPro->Draw("same");
1241   }
1242
1243   fout->cd();
1244   hSigmaPi->Write();
1245   profSigmaPi->Write();
1246   hSigmaKa->Write();
1247   profSigmaKa->Write();
1248   hSigmaPro->Write();
1249   profSigmaPro->Write();
1250
1251   return 0;
1252 }
1253
1254 //----------------------------------------------------------
1255 char * SetQAtrainOutputName(Int_t run=0,Int_t year=2011,char *period="LHC11a", char* pass="cpass1",Int_t trainId=76){
1256   
1257   char infile[200];
1258   sprintf(infile,"alien:///alice/data/%i/%s/000%d/ESDs/%s/QA%i/QAresults.root",year,period,runNumber,pass,trainId);
1259   return infile;
1260   
1261 }
1262
1263
1264