1 //------------------------------------------------------------------------------
2 // Implementation of AliTPCPerformanceSummary class.
3 // It has only static member functions to extract some TPC Performance
4 // parameters and produce trend graphs.
5 // The function MakeReport is to be called for every run. It reads AliPerformanceTPC
6 // and AliPerformanceDEdx objects from file and produces a
7 // rootfile with the results stored in a TTree.
8 // The function MakeReport needs a list of these rootfiles as input
9 // and writes the output (tree and histograms) to another rootfile.
11 // Author: M.Knichel 2010-05-21
12 //------------------------------------------------------------------------------
26 #include "THnSparse.h"
33 #include "TTreeStream.h"
34 #include "AliPerformanceTPC.h"
35 #include "AliPerformanceDEdx.h"
36 #include "AliPerformanceDCA.h"
38 #include "AliTPCPerformanceSummary.h"
40 ClassImp(AliTPCPerformanceSummary)
42 //_____________________________________________________________________________
43 Int_t AliTPCPerformanceSummary::WriteToTTreeSRedirector(const AliPerformanceTPC* pTPC, const AliPerformanceDEdx* pTPCgain, TTreeSRedirector* pcstream, Int_t run)
46 // Extracts performance parameters from pTPC and pTPCgain.
47 // Output is written to pcstream.
48 // The run number must be provided since it is not stored in
49 // AliPerformanceTPC or AliPerformanceDEdx.
52 if (!pcstream) return -1;
53 (*pcstream)<<"tpcQA"<<"run="<<run;
55 returncode += AnalyzeNCL(pTPC, pcstream);
56 returncode += AnalyzeDrift(pTPC, pcstream);
57 returncode += AnalyzeDriftPos(pTPC, pcstream);
58 returncode += AnalyzeDriftNeg(pTPC, pcstream);
59 returncode += AnalyzeGain(pTPCgain, pcstream);
60 returncode += AnalyzeDCARPhi(pTPC, pcstream);
61 returncode += AnalyzeDCARPhiPos(pTPC, pcstream);
62 returncode += AnalyzeDCARPhiNeg(pTPC, pcstream);
63 returncode += AnalyzeEvent(pTPC, pcstream);
64 (*pcstream)<<"tpcQA"<<"\n";
68 //_____________________________________________________________________________
69 Int_t AliTPCPerformanceSummary::WriteToFile(const AliPerformanceTPC* pTPC, const AliPerformanceDEdx* pTPCgain, const Char_t* outfile, Int_t run)
72 // Extracts performance parameters from pTPC and pTPCgain.
73 // Output is written to a TTree saved in outfile.
74 // The run number must be provided since it is not stored in
75 // AliPerformanceTPC or AliPerformanceDEdx.
77 // The function creates a TTreeSRedirector and calls the
78 // function WriteToTTreeSRedirector.
81 if (!outfile) return -1;
82 TTreeSRedirector* pcstream = 0;
83 pcstream = new TTreeSRedirector(outfile);
84 if (!pcstream) return -1;
85 Int_t returncode = WriteToTTreeSRedirector(pTPC, pTPCgain, pcstream, run);
86 if (pcstream) { delete pcstream; pcstream = 0; }
91 //_____________________________________________________________________________
92 Int_t AliTPCPerformanceSummary::MakeReport(const Char_t* infile, const Char_t* outfile, Int_t run)
95 // Reads QA information (AliPerformanceTPC and AliPerformanceDEdx) from
96 // infile (this must be a rootfile) and writes the output to a TTree
98 // The run number must be provided since it is not stored in
99 // AliPerformanceTPC or AliPerformanceDEdx.
101 // The input objects must be named "AliPerformanceTPC" and
102 // "AliPerformanceDEdxTPCInner" and stored in a TList which name must
103 // be one of the following: "TPC", "TPCQA", "TPC_PerformanceQA"
104 // or "TPC_PerformanceQA/TPC" (with directory)
107 if (!infile) return -1;
108 if (!outfile) return -1;
110 f=TFile::Open(infile,"read");
112 printf("File %s not available\n", infile);
116 list = dynamic_cast<TList*>(f->Get("TPC"));
117 if (!list) { list = dynamic_cast<TList*>(f->Get("TPCQA")); }
118 if (!list) { list = dynamic_cast<TList*>(f->Get("TPC_PerformanceQA")); }
119 if (!list) { list = dynamic_cast<TList*>(f->Get("TPC_PerformanceQA/TPCQA")); }
121 printf("QA %s not available\n", infile);
124 AliPerformanceTPC* pTPC = 0;
125 AliPerformanceDEdx* pTPCgain = 0;
126 if (list) { pTPC = (AliPerformanceTPC*)(list->FindObject("AliPerformanceTPC")); }
127 if (list) { pTPCgain = (AliPerformanceDEdx*)(list->FindObject("AliPerformanceDEdxTPCInner")); }
129 Int_t returncode = 0;
130 returncode = WriteToFile(pTPC, pTPCgain, outfile, run);
131 if (f) { delete f; f=0; }
135 //_____________________________________________________________________________
136 Int_t AliTPCPerformanceSummary::ProduceTrends(const Char_t* infilelist, const Char_t* outfile)
139 // Produces trend graphs.
141 // Input: infilelist is a textfile with one rootfile per line.
142 // There should be one rootfile for each run, the rootfile must
143 // contain the output of the MakeReport function
144 // Output: the information for all runs is merged into a TTree
145 // that is saved in outfile along with the trend graphs.
146 // Trend graphs are stored as TCanvas objects to include axis labels etc.
149 if (!infilelist) return -1;
150 if (!outfile) return -1;
152 TChain* chain = new TChain("tpcQA");
160 if (!currentFile.Contains("root")) continue; // protection
161 chain->Add(currentFile.Data());
164 //TTree *tree = chain;
165 TTree *tree = chain->CopyTree("1");
166 if (chain) { delete chain; chain=0; }
167 //TGraph* graph = dynamic_cast<TGraph*>(tree->DrawClone("run:run"));
168 //TGraph *graph = (TGraph*)gPad->GetPrimitive("Graph");
170 TFile* out = new TFile(outfile,"RECREATE");
172 Char_t* condition = "meanTPCncl>0";
173 SaveGraph(tree,"meanTPCnclF","run",condition);
174 SaveGraph(tree,"rmsTPCnclF","run",condition);
175 SaveGraph(tree,"meanTPCChi2","run",condition);
176 SaveGraph(tree,"rmsTPCChi2","run",condition);
177 SaveGraph(tree,"slopeATPCnclF","run",condition);
178 SaveGraph(tree,"slopeCTPCnclF","run",condition);
179 SaveGraph(tree,"slopeATPCnclFErr","run",condition);
180 SaveGraph(tree,"slopeCTPCnclFErr","run",condition);
181 SaveGraph(tree,"meanTPCncl","run",condition);
182 SaveGraph(tree,"rmsTPCncl","run",condition);
183 SaveGraph(tree,"slopeATPCncl","run",condition);
184 SaveGraph(tree,"slopeCTPCncl","run",condition);
185 SaveGraph(tree,"slopeATPCnclErr","run",condition);
186 SaveGraph(tree,"slopeCTPCnclErr","run",condition);
188 SaveGraph(tree,"offsetdRA","run",condition);
189 SaveGraph(tree,"slopedRA","run",condition);
190 SaveGraph(tree,"offsetdRC","run",condition);
191 SaveGraph(tree,"slopedRC","run",condition);
192 SaveGraph(tree,"offsetdRAErr","run",condition);
193 SaveGraph(tree,"slopedRAErr","run",condition);
194 SaveGraph(tree,"offsetdRCErr","run",condition);
195 SaveGraph(tree,"slopedRCErr","run",condition);
196 SaveGraph(tree,"offsetdRAchi2","run",condition);
197 SaveGraph(tree,"slopedRAchi2","run",condition);
198 SaveGraph(tree,"offsetdRCchi2","run",condition);
199 SaveGraph(tree,"slopedRCchi2","run",condition);
201 SaveGraph(tree,"offsetdRAPos","run",condition);
203 SaveGraph(tree,"slopedRAPos","run",condition);
204 SaveGraph(tree,"offsetdRCPos","run",condition);
205 SaveGraph(tree,"slopedRCPos","run",condition);
206 SaveGraph(tree,"offsetdRAErrPos","run",condition);
207 SaveGraph(tree,"slopedRAErrPos","run",condition);
208 SaveGraph(tree,"offsetdRCErrPos","run",condition);
209 SaveGraph(tree,"slopedRCErrPos","run",condition);
210 SaveGraph(tree,"offsetdRAchi2Pos","run",condition);
211 SaveGraph(tree,"slopedRAchi2Pos","run",condition);
212 SaveGraph(tree,"offsetdRCchi2Pos","run",condition);
213 SaveGraph(tree,"slopedRCchi2Pos","run",condition);
215 SaveGraph(tree,"offsetdRANeg","run",condition);
216 SaveGraph(tree,"slopedRANeg","run",condition);
217 SaveGraph(tree,"offsetdRCNeg","run",condition);
218 SaveGraph(tree,"slopedRCNeg","run",condition);
219 SaveGraph(tree,"offsetdRAErrNeg","run",condition);
220 SaveGraph(tree,"slopedRAErrNeg","run",condition);
221 SaveGraph(tree,"offsetdRCErrNeg","run",condition);
222 SaveGraph(tree,"slopedRCErrNeg","run",condition);
223 SaveGraph(tree,"offsetdRAchi2Neg","run",condition);
224 SaveGraph(tree,"slopedRAchi2Neg","run",condition);
225 SaveGraph(tree,"offsetdRCchi2Neg","run",condition);
226 SaveGraph(tree,"slopedRCchi2Neg","run",condition);
228 SaveGraph(tree,"offsetdZAPos","run",condition);
229 SaveGraph(tree,"slopedZAPos","run",condition);
230 SaveGraph(tree,"offsetdZCPos","run",condition);
231 SaveGraph(tree,"slopedZCPos","run",condition);
232 SaveGraph(tree,"offsetdZAErrPos","run",condition);
233 SaveGraph(tree,"slopedZAErrPos","run",condition);
234 SaveGraph(tree,"offsetdZCErrPos","run",condition);
235 SaveGraph(tree,"slopedZCErrPos","run",condition);
236 SaveGraph(tree,"offsetdZAchi2Pos","run",condition);
237 SaveGraph(tree,"slopedZAchi2Pos","run",condition);
238 SaveGraph(tree,"offsetdZCchi2Pos","run",condition);
239 SaveGraph(tree,"slopedZCchi2Pos","run",condition);
241 SaveGraph(tree,"offsetdZANeg","run",condition);
242 SaveGraph(tree,"slopedZANeg","run",condition);
243 SaveGraph(tree,"offsetdZCNeg","run",condition);
244 SaveGraph(tree,"slopedZCNeg","run",condition);
245 SaveGraph(tree,"offsetdZAErrNeg","run",condition);
246 SaveGraph(tree,"slopedZAErrNeg","run",condition);
247 SaveGraph(tree,"offsetdZCErrNeg","run",condition);
248 SaveGraph(tree,"slopedZCErrNeg","run",condition);
249 SaveGraph(tree,"offsetdZAchi2Neg","run",condition);
250 SaveGraph(tree,"slopedZAchi2Neg","run",condition);
251 SaveGraph(tree,"offsetdZCchi2Neg","run",condition);
252 SaveGraph(tree,"slopedZCchi2Neg","run",condition);
254 SaveGraph(tree,"offsetdZA","run",condition);
255 SaveGraph(tree,"slopedZA","run",condition);
256 SaveGraph(tree,"offsetdZC","run",condition);
257 SaveGraph(tree,"slopedZC","run",condition);
258 SaveGraph(tree,"offsetdZAErr","run",condition);
259 SaveGraph(tree,"slopedZAErr","run",condition);
260 SaveGraph(tree,"offsetdZCErr","run",condition);
261 SaveGraph(tree,"slopedZCErr","run",condition);
262 SaveGraph(tree,"offsetdZAchi2","run",condition);
263 SaveGraph(tree,"slopedZAchi2","run",condition);
264 SaveGraph(tree,"offsetdZCchi2","run",condition);
265 SaveGraph(tree,"slopedZCchi2","run",condition);
267 SaveGraph(tree,"meanVertX","run",condition);
268 SaveGraph(tree,"rmsVertX","run",condition);
269 SaveGraph(tree,"meanVertY","run",condition);
270 SaveGraph(tree,"rmsVertY","run",condition);
271 SaveGraph(tree,"meanVertZ","run",condition);
272 SaveGraph(tree,"rmsVertZ","run",condition);
273 SaveGraph(tree,"vertStatus","run",condition);
274 SaveGraph(tree,"meanMult","run",condition);
275 SaveGraph(tree,"rmsMult","run",condition);
276 SaveGraph(tree,"meanMultPos","run",condition);
277 SaveGraph(tree,"rmsMultPos","run",condition);
278 SaveGraph(tree,"meanMultNeg","run",condition);
279 SaveGraph(tree,"rmsMultNeg","run",condition);
280 SaveGraph(tree,"vertAll","run",condition);
281 SaveGraph(tree,"vertOK","run",condition);
286 if (tree) { delete tree; tree=0; }
287 if (out) { delete out; out=0; }
291 //_____________________________________________________________________________
292 Int_t AliTPCPerformanceSummary::SaveGraph(TTree* tree, const Char_t* y, const Char_t* x, const Char_t* condition)
295 // Creates a Graph and writes the canvas to the current directory
296 // called by ProduceTrends function.
302 tree->Draw(s.Data(),condition,"goff");
303 TCanvas* c = new TCanvas(s.Data(),s.Data());
305 TPad* p = new TPad("pad0","pad0",0,0,1,1);
308 if (tree->GetSelectedRows() > 0) {
309 TGraph* graph = new TGraph(tree->GetSelectedRows(), tree->GetV2(), tree->GetV1());
311 graph->GetXaxis()->SetTitle(x);
312 graph->GetYaxis()->SetTitle(y);
316 //graph->Write(s.Data());
322 //_____________________________________________________________________________
323 Int_t AliTPCPerformanceSummary::AnalyzeDCARPhi(const AliPerformanceTPC* pTPC, TTreeSRedirector* pcstream)
326 // Analyse DCA R imperfections
329 if (!pcstream) return 8;
333 static Double_t offsetdRA=0;
334 static Double_t slopedRA=0;
335 static Double_t offsetdRC=0;
336 static Double_t slopedRC=0;
337 static Double_t offsetdRAErr=0;
338 static Double_t slopedRAErr=0;
339 static Double_t offsetdRCErr=0;
340 static Double_t slopedRCErr=0;
341 static Double_t offsetdRAchi2=0;
342 static Double_t slopedRAchi2=0;
343 static Double_t offsetdRCchi2=0;
344 static Double_t slopedRCchi2=0;
346 //AliPerformanceTPC* pTPC = dynamic_cast<AliPerformanceTPC*>(pTPCObject);
349 static TF1 *fpol1 = new TF1("fpol1","pol1");
351 his2D = pTPC->GetTPCTrackHisto()->Projection(3,5);
352 his2D->FitSlicesY(0,0,-1,10,"QNR",&arrayFit);
354 his1D = (TH1*) arrayFit.At(1);
355 his1D->Fit(fpol1,"QNRROB=0.8","QNR",-0.8,-0.1);
356 offsetdRC=fpol1->GetParameter(0);
357 slopedRC=fpol1->GetParameter(1);
358 offsetdRCchi2=fpol1->GetChisquare();
359 slopedRCchi2=fpol1->GetChisquare();
361 his1D->Fit(fpol1,"QNRROB=0.8","QNR",0.1,0.8);
362 offsetdRA=fpol1->GetParameter(0);
363 slopedRA=fpol1->GetParameter(1);
364 offsetdRAErr=fpol1->GetParError(0);
365 slopedRAErr=fpol1->GetParError(1);
366 offsetdRAchi2=fpol1->GetChisquare();
367 slopedRAchi2=fpol1->GetChisquare();
369 printf("DCA R QA report\n");
370 printf("offsetdRA\t%f\n",offsetdRA);
371 printf("slopedRA\t%f\n",slopedRA);
372 printf("offsetdRC\t%f\n",offsetdRC);
373 printf("slopedRC\t%f\n",slopedRC);
377 (*pcstream)<<"tpcQA"<<
378 "offsetdRA="<< offsetdRA<<
379 "slopedRA="<< slopedRA<<
380 "offsetdRC="<< offsetdRC<<
381 "slopedRC="<<slopedRC<<
383 "offsetdRAErr="<< offsetdRAErr<<
384 "slopedRAErr="<< slopedRAErr<<
385 "offsetdRCErr="<< offsetdRCErr<<
386 "slopedRCErr="<<slopedRCErr<<
388 "offsetdRAchi2="<< offsetdRAchi2<<
389 "slopedRAchi2="<< slopedRAchi2<<
390 "offsetdRCchi2="<< offsetdRCchi2<<
391 "slopedRCchi2="<<slopedRCchi2;
396 //_____________________________________________________________________________
397 Int_t AliTPCPerformanceSummary::AnalyzeDCARPhiPos(const AliPerformanceTPC* pTPC, TTreeSRedirector* pcstream)
400 // Analyse DCA R imperfections for positive particles
403 if (!pcstream) return 16;
404 if (!pTPC) return 16;
407 static Double_t offsetdRAPos=0;
408 static Double_t slopedRAPos=0;
409 static Double_t offsetdRCPos=0;
410 static Double_t slopedRCPos=0;
411 static Double_t offsetdRAErrPos=0;
412 static Double_t slopedRAErrPos=0;
413 static Double_t offsetdRCErrPos=0;
414 static Double_t slopedRCErrPos=0;
415 static Double_t offsetdRAchi2Pos=0;
416 static Double_t slopedRAchi2Pos=0;
417 static Double_t offsetdRCchi2Pos=0;
418 static Double_t slopedRCchi2Pos=0;
420 //AliPerformanceTPC* pTPC = dynamic_cast<AliPerformanceTPC*>(pTPCObject);
423 static TF1 *fpol1 = new TF1("fpol1","pol1");
425 pTPC->GetTPCTrackHisto()->GetAxis(8)->SetRangeUser(0,10);
426 his2D = pTPC->GetTPCTrackHisto()->Projection(3,5);
427 his2D->FitSlicesY(0,0,-1,10,"QNR",&arrayFit);
429 pTPC->GetTPCTrackHisto()->GetAxis(8)->SetRangeUser(-10,10);
430 his1D = (TH1*) arrayFit.At(1);
431 his1D->Fit(fpol1,"QNRROB=0.8","QNR",-0.8,-0.1);
432 offsetdRCPos=fpol1->GetParameter(0);
433 slopedRCPos=fpol1->GetParameter(1);
434 offsetdRCchi2Pos=fpol1->GetChisquare();
435 slopedRCchi2Pos=fpol1->GetChisquare();
437 his1D->Fit(fpol1,"QNRROB=0.8","QNR",0.1,0.8);
438 offsetdRAPos=fpol1->GetParameter(0);
439 slopedRAPos=fpol1->GetParameter(1);
440 offsetdRAErrPos=fpol1->GetParError(0);
441 slopedRAErrPos=fpol1->GetParError(1);
442 offsetdRAchi2Pos=fpol1->GetChisquare();
443 slopedRAchi2Pos=fpol1->GetChisquare();
445 printf("DCA R QA Pos report\n");
446 printf("offsetdRAPos\t%f\n",offsetdRAPos);
447 printf("slopedRAPos\t%f\n",slopedRAPos);
448 printf("offsetdRCPos\t%f\n",offsetdRCPos);
449 printf("slopedRCPos\t%f\n",slopedRCPos);
453 (*pcstream)<<"tpcQA"<<
454 "offsetdRAPos="<< offsetdRAPos<<
455 "slopedRAPos="<< slopedRAPos<<
456 "offsetdRCPos="<< offsetdRCPos<<
457 "slopedRCPos="<<slopedRCPos<<
459 "offsetdRAErrPos="<< offsetdRAErrPos<<
460 "slopedRAErrPos="<< slopedRAErrPos<<
461 "offsetdRCErrPos="<< offsetdRCErrPos<<
462 "slopedRCErrPos="<<slopedRCErrPos<<
464 "offsetdRAchi2Pos="<< offsetdRAchi2Pos<<
465 "slopedRAchi2Pos="<< slopedRAchi2Pos<<
466 "offsetdRCchi2Pos="<< offsetdRCchi2Pos<<
467 "slopedRCchi2Pos="<<slopedRCchi2Pos;
472 //_____________________________________________________________________________
473 Int_t AliTPCPerformanceSummary::AnalyzeDCARPhiNeg(const AliPerformanceTPC* pTPC, TTreeSRedirector* pcstream)
476 // Analyse DCA R imperfections for negative particles
478 if (!pcstream) return 32;
479 if (!pTPC) return 32;
482 static Double_t offsetdRANeg=0;
483 static Double_t slopedRANeg=0;
484 static Double_t offsetdRCNeg=0;
485 static Double_t slopedRCNeg=0;
486 static Double_t offsetdRAErrNeg=0;
487 static Double_t slopedRAErrNeg=0;
488 static Double_t offsetdRCErrNeg=0;
489 static Double_t slopedRCErrNeg=0;
490 static Double_t offsetdRAchi2Neg=0;
491 static Double_t slopedRAchi2Neg=0;
492 static Double_t offsetdRCchi2Neg=0;
493 static Double_t slopedRCchi2Neg=0;
495 //AliPerformanceTPC* pTPC = dynamic_cast<AliPerformanceTPC*>(pTPCObject);
498 static TF1 *fpol1 = new TF1("fpol1","pol1");
500 pTPC->GetTPCTrackHisto()->GetAxis(8)->SetRangeUser(-10,0);
501 his2D = pTPC->GetTPCTrackHisto()->Projection(3,5);
502 his2D->FitSlicesY(0,0,-1,10,"QNR",&arrayFit);
504 pTPC->GetTPCTrackHisto()->GetAxis(8)->SetRangeUser(-10,10);
505 his1D = (TH1*) arrayFit.At(1);
506 his1D->Fit(fpol1,"QNRROB=0.8","QNR",-0.8,-0.1);
507 offsetdRCNeg=fpol1->GetParameter(0);
508 slopedRCNeg=fpol1->GetParameter(1);
509 offsetdRCchi2Neg=fpol1->GetChisquare();
510 slopedRCchi2Neg=fpol1->GetChisquare();
512 his1D->Fit(fpol1,"QNRROB=0.8","QNR",0.1,0.8);
513 offsetdRANeg=fpol1->GetParameter(0);
514 slopedRANeg=fpol1->GetParameter(1);
515 offsetdRAErrNeg=fpol1->GetParError(0);
516 slopedRAErrNeg=fpol1->GetParError(1);
517 offsetdRAchi2Neg=fpol1->GetChisquare();
518 slopedRAchi2Neg=fpol1->GetChisquare();
520 printf("DCA R QA Neg report\n");
521 printf("offsetdRANeg\t%f\n",offsetdRANeg);
522 printf("slopedRANeg\t%f\n",slopedRANeg);
523 printf("offsetdRCNeg\t%f\n",offsetdRCNeg);
524 printf("slopedRCNeg\t%f\n",slopedRCNeg);
526 // dump drift QA values
528 (*pcstream)<<"tpcQA"<<
529 "offsetdRANeg="<< offsetdRANeg<<
530 "slopedRANeg="<< slopedRANeg<<
531 "offsetdRCNeg="<< offsetdRCNeg<<
532 "slopedRCNeg="<<slopedRCNeg<<
534 "offsetdRAErrNeg="<< offsetdRAErrNeg<<
535 "slopedRAErrNeg="<< slopedRAErrNeg<<
536 "offsetdRCErrNeg="<< offsetdRCErrNeg<<
537 "slopedRCErrNeg="<<slopedRCErrNeg<<
539 "offsetdRAchi2Neg="<< offsetdRAchi2Neg<<
540 "slopedRAchi2Neg="<< slopedRAchi2Neg<<
541 "offsetdRCchi2Neg="<< offsetdRCchi2Neg<<
542 "slopedRCchi2Neg="<<slopedRCchi2Neg;
547 //_____________________________________________________________________________
548 Int_t AliTPCPerformanceSummary::AnalyzeNCL(const AliPerformanceTPC* pTPC, TTreeSRedirector* pcstream)
551 // Analyse number of TPC clusters
554 if (!pcstream) return 1;
558 static Double_t meanTPCnclF=0;
559 static Double_t rmsTPCnclF=0;
560 static Double_t meanTPCChi2=0;
561 static Double_t rmsTPCChi2=0;
562 static Double_t slopeATPCnclF=0;
563 static Double_t slopeCTPCnclF=0;
564 static Double_t slopeATPCnclFErr=0;
565 static Double_t slopeCTPCnclFErr=0;
566 static Double_t meanTPCncl=0;
567 static Double_t rmsTPCncl=0;
568 static Double_t slopeATPCncl=0;
569 static Double_t slopeCTPCncl=0;
570 static Double_t slopeATPCnclErr=0;
571 static Double_t slopeCTPCnclErr=0;
574 static TF1 *fpol1 = new TF1("fpol1","pol1");
578 // pt cut - +-0.250 GeV
579 pTPC->GetTPCTrackHisto()->GetAxis(5)->SetRangeUser(-1.,1.);
580 pTPC->GetTPCTrackHisto()->GetAxis(7)->SetRangeUser(0.25,10);
581 his1D = pTPC->GetTPCTrackHisto()->Projection(0);
582 meanTPCncl= his1D->GetMean();
583 rmsTPCncl= his1D->GetRMS();
585 his1D = pTPC->GetTPCTrackHisto()->Projection(1);
586 meanTPCChi2= his1D->GetMean();
587 rmsTPCChi2= his1D->GetRMS();
589 hprof = pTPC->GetTPCTrackHisto()->Projection(0,5)->ProfileX();
590 hprof->Fit(fpol1,"QNR","QNR",0,0.8);
591 slopeATPCncl= fpol1->GetParameter(1);
592 slopeATPCnclErr= fpol1->GetParError(1);
593 hprof->Fit(fpol1,"QNR","QNR",-0.8,0.0);
594 slopeCTPCncl= fpol1->GetParameter(1);
595 slopeCTPCnclErr= fpol1->GetParameter(1);
600 pTPC->GetTPCTrackHisto()->GetAxis(2)->SetRangeUser(0.4,1.1);
601 his1D = pTPC->GetTPCTrackHisto()->Projection(2);
602 meanTPCnclF= his1D->GetMean();
603 rmsTPCnclF= his1D->GetRMS();
605 his1D = pTPC->GetTPCTrackHisto()->Projection(2,5)->ProfileX();
606 his1D->Fit(fpol1,"QNR","QNR",0,0.8);
607 slopeATPCnclF= fpol1->GetParameter(1);
608 slopeATPCnclFErr= fpol1->GetParError(1);
609 his1D->Fit(fpol1,"QNR","QNR",-0.8,0.0);
610 slopeCTPCnclF= fpol1->GetParameter(1);
611 slopeCTPCnclFErr= fpol1->GetParameter(1);
613 printf("Cluster QA report\n");
614 printf("meanTPCnclF=\t%f\n",meanTPCnclF);
615 printf("rmsTPCnclF=\t%f\n",rmsTPCnclF);
616 printf("slopeATPCnclF=\t%f\n",slopeATPCnclF);
617 printf("slopeCTPCnclF=\t%f\n",slopeCTPCnclF);
618 printf("meanTPCncl=\t%f\n",meanTPCncl);
619 printf("rmsTPCncl=\t%f\n",rmsTPCncl);
620 printf("slopeATPCncl=\t%f\n",slopeATPCncl);
621 printf("slopeCTPCncl=\t%f\n",slopeCTPCncl);
622 printf("meanTPCChi2=\t%f\n",meanTPCChi2);
623 printf("rmsTPCChi2=\t%f\n",rmsTPCChi2);
625 // dump results to the tree
627 (*pcstream)<<"tpcQA"<<
628 "meanTPCnclF="<<meanTPCnclF <<
629 "rmsTPCnclF="<<rmsTPCnclF <<
630 "meanTPCChi2="<<meanTPCChi2 <<
631 "rmsTPCChi2="<<rmsTPCChi2 <<
632 "slopeATPCnclF="<< slopeATPCnclF<<
633 "slopeCTPCnclF="<< slopeCTPCnclF<<
634 "slopeATPCnclFErr="<< slopeATPCnclFErr<<
635 "slopeCTPCnclFErr="<< slopeCTPCnclFErr<<
636 "meanTPCncl="<<meanTPCncl <<
637 "rmsTPCncl="<< rmsTPCncl<<
638 "slopeATPCncl="<< slopeATPCncl<<
639 "slopeCTPCncl="<< slopeCTPCncl<<
640 "slopeATPCnclErr="<< slopeATPCnclErr<<
641 "slopeCTPCnclErr="<< slopeCTPCnclErr;
646 //_____________________________________________________________________________
647 Int_t AliTPCPerformanceSummary::AnalyzeDrift(const AliPerformanceTPC* pTPC, TTreeSRedirector* pcstream)
650 // Analyse DCA Z imperferctions (drift velocity)
653 if (!pcstream) return 2;
657 static Double_t offsetdZA=0;
658 static Double_t slopedZA=0;
659 static Double_t offsetdZC=0;
660 static Double_t slopedZC=0;
661 static Double_t offsetdZAErr=0;
662 static Double_t slopedZAErr=0;
663 static Double_t offsetdZCErr=0;
664 static Double_t slopedZCErr=0;
665 static Double_t offsetdZAchi2=0;
666 static Double_t slopedZAchi2=0;
667 static Double_t offsetdZCchi2=0;
668 static Double_t slopedZCchi2=0;
671 static TF1 *fpol1 = new TF1("fpol1","pol1");
673 his2D = pTPC->GetTPCTrackHisto()->Projection(4,5);
674 his2D->FitSlicesY(0,0,-1,10,"QNR",&arrayFit);
676 his1D = (TH1*) arrayFit.At(1);
677 his1D->Fit(fpol1,"QNRROB=0.8","QNR",-0.8,-0.1);
678 offsetdZC=fpol1->GetParameter(0);
679 slopedZC=fpol1->GetParameter(1);
680 offsetdZCErr=fpol1->GetParError(0);
681 slopedZCErr=fpol1->GetParError(1);
682 offsetdZCchi2=fpol1->GetChisquare();
683 slopedZCchi2=fpol1->GetChisquare();
685 his1D->Fit(fpol1,"QNRROB=0.8","QNR",0.1,0.8);
686 offsetdZA=fpol1->GetParameter(0);
687 slopedZA=fpol1->GetParameter(1);
688 offsetdZAErr=fpol1->GetParError(0);
689 slopedZAErr=fpol1->GetParError(1);
690 offsetdZAchi2=fpol1->GetChisquare();
691 slopedZAchi2=fpol1->GetChisquare();
693 printf("Drift velocity QA report\n");
694 printf("offsetdZA\t%f\n",offsetdZA);
695 printf("slopedZA\t%f\n",slopedZA);
696 printf("offsetdZC\t%f\n",offsetdZC);
697 printf("slopedZC\t%f\n",slopedZC);
699 // dump drift QA values
701 (*pcstream)<<"tpcQA"<<
702 "offsetdZA="<< offsetdZA<<
703 "slopedZA="<< slopedZA<<
704 "offsetdZC="<< offsetdZC<<
705 "slopedZC="<<slopedZC<<
707 "offsetdZAErr="<< offsetdZAErr<<
708 "slopedZAErr="<< slopedZAErr<<
709 "offsetdZCErr="<< offsetdZCErr<<
710 "slopedZCErr="<<slopedZCErr<<
712 "offsetdZAchi2="<< offsetdZAchi2<<
713 "slopedZAchi2="<< slopedZAchi2<<
714 "offsetdZCchi2="<< offsetdZCchi2<<
715 "slopedZCchi2="<<slopedZCchi2;
720 //_____________________________________________________________________________
721 Int_t AliTPCPerformanceSummary::AnalyzeDriftPos(const AliPerformanceTPC* pTPC, TTreeSRedirector* pcstream)
724 // Analyse DCA Z imperferctions (drift velocity)
725 // for positive particles
727 if (!pcstream) return 64;
728 if (!pTPC) return 64;
731 static Double_t offsetdZAPos=0;
732 static Double_t slopedZAPos=0;
733 static Double_t offsetdZCPos=0;
734 static Double_t slopedZCPos=0;
735 static Double_t offsetdZAErrPos=0;
736 static Double_t slopedZAErrPos=0;
737 static Double_t offsetdZCErrPos=0;
738 static Double_t slopedZCErrPos=0;
739 static Double_t offsetdZAchi2Pos=0;
740 static Double_t slopedZAchi2Pos=0;
741 static Double_t offsetdZCchi2Pos=0;
742 static Double_t slopedZCchi2Pos=0;
745 static TF1 *fpol1 = new TF1("fpol1","pol1");
747 pTPC->GetTPCTrackHisto()->GetAxis(8)->SetRangeUser(0,10);
748 his2D = pTPC->GetTPCTrackHisto()->Projection(4,5);
749 his2D->FitSlicesY(0,0,-1,10,"QNR",&arrayFit);
751 pTPC->GetTPCTrackHisto()->GetAxis(8)->SetRangeUser(-10,10);
752 his1D = (TH1*) arrayFit.At(1);
753 his1D->Fit(fpol1,"QNRROB=0.8","QNR",-0.8,-0.1);
754 offsetdZCPos=fpol1->GetParameter(0);
755 slopedZCPos=fpol1->GetParameter(1);
756 offsetdZCErrPos=fpol1->GetParError(0);
757 slopedZCErrPos=fpol1->GetParError(1);
758 offsetdZCchi2Pos=fpol1->GetChisquare();
759 slopedZCchi2Pos=fpol1->GetChisquare();
761 his1D->Fit(fpol1,"QNRROB=0.8","QNR",0.1,0.8);
762 offsetdZAPos=fpol1->GetParameter(0);
763 slopedZAPos=fpol1->GetParameter(1);
764 offsetdZAErrPos=fpol1->GetParError(0);
765 slopedZAErrPos=fpol1->GetParError(1);
766 offsetdZAchi2Pos=fpol1->GetChisquare();
767 slopedZAchi2Pos=fpol1->GetChisquare();
769 printf("Drift velocity QA report\n");
770 printf("offsetdZAPos\t%f\n",offsetdZAPos);
771 printf("slopedZAPos\t%f\n",slopedZAPos);
772 printf("offsetdZCPos\t%f\n",offsetdZCPos);
773 printf("slopedZCPos\t%f\n",slopedZCPos);
775 // dump drift QA values
777 (*pcstream)<<"tpcQA"<<
778 "offsetdZAPos="<< offsetdZAPos<<
779 "slopedZAPos="<< slopedZAPos<<
780 "offsetdZCPos="<< offsetdZCPos<<
781 "slopedZCPos="<<slopedZCPos<<
783 "offsetdZAErrPos="<< offsetdZAErrPos<<
784 "slopedZAErrPos="<< slopedZAErrPos<<
785 "offsetdZCErrPos="<< offsetdZCErrPos<<
786 "slopedZCErrPos="<<slopedZCErrPos<<
788 "offsetdZAchi2Pos="<< offsetdZAchi2Pos<<
789 "slopedZAchi2Pos="<< slopedZAchi2Pos<<
790 "offsetdZCchi2Pos="<< offsetdZCchi2Pos<<
791 "slopedZCchi2Pos="<<slopedZCchi2Pos;
796 //_____________________________________________________________________________
797 Int_t AliTPCPerformanceSummary::AnalyzeDriftNeg(const AliPerformanceTPC* pTPC, TTreeSRedirector* pcstream)
800 // Analyse DCA Z imperferctions (drift velocity)
801 // for negative particles
803 if (!pcstream) return 128;
804 if (!pTPC) return 128;
807 static Double_t offsetdZANeg=0;
808 static Double_t slopedZANeg=0;
809 static Double_t offsetdZCNeg=0;
810 static Double_t slopedZCNeg=0;
811 static Double_t offsetdZAErrNeg=0;
812 static Double_t slopedZAErrNeg=0;
813 static Double_t offsetdZCErrNeg=0;
814 static Double_t slopedZCErrNeg=0;
815 static Double_t offsetdZAchi2Neg=0;
816 static Double_t slopedZAchi2Neg=0;
817 static Double_t offsetdZCchi2Neg=0;
818 static Double_t slopedZCchi2Neg=0;
821 static TF1 *fpol1 = new TF1("fpol1","pol1");
823 pTPC->GetTPCTrackHisto()->GetAxis(8)->SetRangeUser(-10,0);
824 his2D = pTPC->GetTPCTrackHisto()->Projection(4,5);
825 his2D->FitSlicesY(0,0,-1,10,"QNR",&arrayFit);
827 pTPC->GetTPCTrackHisto()->GetAxis(8)->SetRangeUser(-10,10);
828 his1D = (TH1*) arrayFit.At(1);
829 his1D->Fit(fpol1,"QNRROB=0.8","QNR",-0.8,-0.1);
830 offsetdZCNeg=fpol1->GetParameter(0);
831 slopedZCNeg=fpol1->GetParameter(1);
832 offsetdZCErrNeg=fpol1->GetParError(0);
833 slopedZCErrNeg=fpol1->GetParError(1);
834 offsetdZCchi2Neg=fpol1->GetChisquare();
835 slopedZCchi2Neg=fpol1->GetChisquare();
837 his1D->Fit(fpol1,"QNRROB=0.8","QNR",0.1,0.8);
838 offsetdZANeg=fpol1->GetParameter(0);
839 slopedZANeg=fpol1->GetParameter(1);
840 offsetdZAErrNeg=fpol1->GetParError(0);
841 slopedZAErrNeg=fpol1->GetParError(1);
842 offsetdZAchi2Neg=fpol1->GetChisquare();
843 slopedZAchi2Neg=fpol1->GetChisquare();
845 printf("Drift velocity QA report\n");
846 printf("offsetdZANeg\t%f\n",offsetdZANeg);
847 printf("slopedZANeg\t%f\n",slopedZANeg);
848 printf("offsetdZCNeg\t%f\n",offsetdZCNeg);
849 printf("slopedZCNeg\t%f\n",slopedZCNeg);
851 // dump drift QA values
853 (*pcstream)<<"tpcQA"<<
854 "offsetdZANeg="<< offsetdZANeg<<
855 "slopedZANeg="<< slopedZANeg<<
856 "offsetdZCNeg="<< offsetdZCNeg<<
857 "slopedZCNeg="<<slopedZCNeg<<
859 "offsetdZAErrNeg="<< offsetdZAErrNeg<<
860 "slopedZAErrNeg="<< slopedZAErrNeg<<
861 "offsetdZCErrNeg="<< offsetdZCErrNeg<<
862 "slopedZCErrNeg="<<slopedZCErrNeg<<
864 "offsetdZAchi2Neg="<< offsetdZAchi2Neg<<
865 "slopedZAchi2Neg="<< slopedZAchi2Neg<<
866 "offsetdZCchi2Neg="<< offsetdZCchi2Neg<<
867 "slopedZCchi2Neg="<<slopedZCchi2Neg;
872 //_____________________________________________________________________________
873 Int_t AliTPCPerformanceSummary::AnalyzeGain(const AliPerformanceDEdx* pTPCgain, TTreeSRedirector* pcstream)
879 if (!pcstream) return 4;
880 if (!pTPCgain) return 4;
882 static TVectorD meanMIPvsSector(36);
883 static TVectorD sector(36);
884 static Float_t meanMIP = 0;
885 static Float_t resolutionMIP = 0;
886 static Float_t attachSlopeC = 0;
887 static Float_t attachSlopeA = 0;
889 meanMIPvsSector.Zero();
891 // select MIP particles
893 pTPCgain->GetDeDxHisto()->GetAxis(7)->SetRangeUser(0.4,0.55);
894 pTPCgain->GetDeDxHisto()->GetAxis(0)->SetRangeUser(35,60);
895 pTPCgain->GetDeDxHisto()->GetAxis(6)->SetRangeUser(80,160);
896 pTPCgain->GetDeDxHisto()->GetAxis(5)->SetRangeUser(-1,1);
898 // MIP position and resolution
900 TF1 gausFit("gausFit","gaus");
901 TH1 * hisProj1D = pTPCgain->GetDeDxHisto()->Projection(0);
902 hisProj1D->Fit(&gausFit,"QN","QN");
904 meanMIP = gausFit.GetParameter(1);
906 if (meanMIP!=0) resolutionMIP = gausFit.GetParameter(2)/meanMIP;
908 // MIP position vs. dip angle (attachment)
910 pTPCgain->GetDeDxHisto()->GetAxis(5)->SetRangeUser(-3,0);
911 TH2* his2D = pTPCgain->GetDeDxHisto()->Projection(0,5);
912 TF1 * fpol = new TF1("fpol","pol1");
914 his2D->FitSlicesY(0,0,-1,10,"QN",&arrayFit);
916 TH1 * his1D = (TH1*) arrayFit.At(1);
917 his1D->Fit(fpol,"QNROB=0.8","QNR",-1,0);
918 attachSlopeC = fpol->GetParameter(1);
920 pTPCgain->GetDeDxHisto()->GetAxis(5)->SetRangeUser(0,3);
921 TH2* his2DA = pTPCgain->GetDeDxHisto()->Projection(0,5);
922 TF1 * fpolA = new TF1("fpolA","pol1");
924 his2DA->FitSlicesY(0,0,-1,10,"QN",&arrayFit);
926 TH1 * his1DA = (TH1*) arrayFit.At(1);
927 his1DA->Fit(fpolA,"QNROB=0.8","QN",0,1);
928 attachSlopeA = fpolA->GetParameter(1);
930 // MIP position vs. sector
932 pTPCgain->GetDeDxHisto()->GetAxis(5)->SetRangeUser(-3,0); // C side
933 for(Int_t i = 0; i < 18; i++) { // loop over sectors; correct mapping to be checked!
935 Float_t phiLow = -TMath::Pi() + i*(20./360.)*(2*TMath::Pi());
936 Float_t phiUp = -TMath::Pi() + (i+1)*(20./360.)*(2*TMath::Pi());
937 pTPCgain->GetDeDxHisto()->GetAxis(1)->SetRangeUser(phiLow,phiUp);
938 his1D = pTPCgain->GetDeDxHisto()->Projection(0);
939 TF1 gausFunc("gausFunc","gaus");
940 his1D->Fit(&gausFunc, "QN");
941 meanMIPvsSector(i) = gausFunc.GetParameter(1);
946 pTPCgain->GetDeDxHisto()->GetAxis(5)->SetRangeUser(0,3); // A side
947 for(Int_t i = 0; i < 18; i++) { // loop over sectors; correct mapping to be checked!
949 Float_t phiLow = -TMath::Pi() + i*(20./360.)*(2*TMath::Pi());
950 Float_t phiUp = -TMath::Pi() + (i+1)*(20./360.)*(2*TMath::Pi());
951 pTPCgain->GetDeDxHisto()->GetAxis(1)->SetRangeUser(phiLow,phiUp);
952 his1D = pTPCgain->GetDeDxHisto()->Projection(0);
953 TF1 gausFunc("gausFunc","gaus");
954 his1D->Fit(&gausFunc, "QN");
955 meanMIPvsSector(i+18) = gausFunc.GetParameter(1);
960 printf("Gain QA report\n");
961 printf("MIP mean\t%f\n",meanMIP);
962 printf("MIP resolution\t%f\n",resolutionMIP);
963 printf("MIPslopeA\t%f\n",attachSlopeA);
964 printf("MIPslopeC\t%f\n",attachSlopeC);
966 (*pcstream)<<"tpcQA"<<
967 "MIPattachSlopeC="<<attachSlopeC<<
968 "MIPattachSlopeA="<<attachSlopeA<<
969 "resolutionMIP="<<resolutionMIP<<
970 "meanMIPvsSector.="<<&meanMIPvsSector<<
971 "sector.="<<§or<<
977 //_____________________________________________________________________________
978 Int_t AliTPCPerformanceSummary::AnalyzeEvent(const AliPerformanceTPC* pTPC, TTreeSRedirector* pcstream)
981 // Analyse Primary Vertex Distribution and Multiplicities
983 if (!pcstream) return 1;
988 static Double_t meanVertX=0;
989 static Double_t rmsVertX=0;
990 static Double_t meanVertY=0;
991 static Double_t rmsVertY=0;
992 static Double_t meanVertZ=0;
993 static Double_t rmsVertZ=0;
994 static Double_t vertStatus=0;
995 static Double_t meanMult=0;
996 static Double_t rmsMult=0;
997 static Double_t meanMultPos=0;
998 static Double_t rmsMultPos=0;
999 static Double_t meanMultNeg=0;
1000 static Double_t rmsMultNeg=0;
1001 static Double_t vertAll = 0;
1002 static Double_t vertOK = 0;
1006 his1D = pTPC->GetTPCEventHisto()->Projection(6);
1007 vertAll = his1D->GetEntries();
1010 pTPC->GetTPCEventHisto()->GetAxis(6)->SetRangeUser(1,1);
1012 his1D = pTPC->GetTPCEventHisto()->Projection(6);
1013 vertOK = his1D->GetEntries();
1016 vertStatus = vertOK / vertAll;
1018 his1D = pTPC->GetTPCEventHisto()->Projection(0);
1019 meanVertX = his1D->GetMean();
1020 rmsVertX = his1D->GetRMS();
1023 his1D = pTPC->GetTPCEventHisto()->Projection(1);
1024 meanVertY = his1D->GetMean();
1025 rmsVertY = his1D->GetRMS();
1028 his1D = pTPC->GetTPCEventHisto()->Projection(2);
1029 meanVertZ = his1D->GetMean();
1030 rmsVertZ = his1D->GetRMS();
1033 his1D = pTPC->GetTPCEventHisto()->Projection(3);
1034 meanMult = his1D->GetMean();
1035 rmsMult = his1D->GetRMS();
1038 his1D = pTPC->GetTPCEventHisto()->Projection(4);
1039 meanMultPos = his1D->GetMean();
1040 rmsMultPos = his1D->GetRMS();
1043 his1D = pTPC->GetTPCEventHisto()->Projection(5);
1044 meanMultNeg = his1D->GetMean();
1045 rmsMultNeg = his1D->GetRMS();
1048 pTPC->GetTPCEventHisto()->GetAxis(6)->SetRangeUser(0,1);
1050 (*pcstream)<<"tpcQA"<<
1051 "meanVertX="<<meanVertX<<
1052 "rmsVertX="<<rmsVertX<<
1053 "meanVertY="<<meanVertY<<
1054 "rmsVertY="<<rmsVertY<<
1055 "meanVertZ="<<meanVertZ<<
1056 "rmsVertZ="<<rmsVertZ<<
1057 "vertStatus="<<vertStatus<<
1058 "vertAll="<<vertAll<<
1060 "meanMult="<<meanMult<<
1061 "rmsMult="<<rmsMult<<
1062 "meanMultPos="<<meanMultPos<<
1063 "rmsMultPos="<<rmsMultPos<<
1064 "meanMultNeg="<<meanMultNeg<<
1065 "rmsMultNeg="<<rmsMultNeg;