Record changes.
[u/mrichter/AliRoot.git] / TPC / AliTPCCalibViewer.cxx
CommitLineData
39bcd65d 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
16
17///////////////////////////////////////////////////////////////////////////////
18// //
19// Class for viewing/visualizing TPC calibration data //
20// base on TTree functionality for visualization //
21///////////////////////////////////////////////////////////////////////////////
22
23//
24// ROOT includes
25//
26#include <iostream>
27#include <TString.h>
28#include <TRandom.h>
29#include <TLegend.h>
30#include <TLine.h>
31#include <TCanvas.h>
32#include <TROOT.h>
33#include <TStyle.h>
34#include <TH1F.h>
35#include <THashTable.h>
36#include <TObjString.h>
37#include "TTreeStream.h"
38#include "TFile.h"
39#include "TKey.h"
40
41
42//
43// AliRoot includes
44//
45#include "AliTPCCalibViewer.h"
46
47ClassImp(AliTPCCalibViewer)
48
49AliTPCCalibViewer::AliTPCCalibViewer()
50 :TObject(),
51 fTree(0),
52 fFile(0),
53 fListOfObjectsToBeDeleted(0)
54{
55 //
56 // Default constructor
57 //
58
59}
60
61//_____________________________________________________________________________
62AliTPCCalibViewer::AliTPCCalibViewer(const AliTPCCalibViewer &c)
63 :TObject(c),
64 fTree(0),
65 fFile(0),
66 fListOfObjectsToBeDeleted(0)
67{
68 //
69 // dummy AliTPCCalibViewer copy constructor
70 // not yet working!!!
71 //
72 fTree = c.fTree;
73 //fFile = new TFile(*(c.fFile));
74 fListOfObjectsToBeDeleted = c.fListOfObjectsToBeDeleted;
75}
76
77//_____________________________________________________________________________
78AliTPCCalibViewer::AliTPCCalibViewer(TTree* tree)
79 :TObject(),
80 fTree(0),
81 fFile(0),
82 fListOfObjectsToBeDeleted(0)
83{
84 //
85 // Constructor that initializes the calibration viewer
86 //
87 fTree = tree;
88 fListOfObjectsToBeDeleted = new TObjArray();
89}
90
91//_____________________________________________________________________________
92AliTPCCalibViewer::AliTPCCalibViewer(char* fileName, char* treeName)
93 :TObject(),
94 fTree(0),
95 fFile(0),
96 fListOfObjectsToBeDeleted(0)
97{
98 //
99 // Constructor to initialize the calibration viewer
100 // the file 'fileName' contains the tree 'treeName'
101 //
102 fFile = new TFile(fileName, "read");
103 fTree = (TTree*) fFile->Get(treeName);
104 fListOfObjectsToBeDeleted = new TObjArray();
105}
106
107//____________________________________________________________________________
108AliTPCCalibViewer & AliTPCCalibViewer::operator =(const AliTPCCalibViewer & param)
109{
110 //
111 // assignment operator - dummy
112 // not yet working!!!
113 //
114 fTree = param.fTree;
115 //fFile = new TFile(*(param.fFile));
116 fListOfObjectsToBeDeleted = param.fListOfObjectsToBeDeleted;
117 return (*this);
118}
119
120//_____________________________________________________________________________
121AliTPCCalibViewer::~AliTPCCalibViewer()
122{
123 //
124 // AliTPCCalibViewer destructor
125 // all objects will be deleted, the file will be closed, the pictures will disapear
126 //
127 /*if (fTree) {
128 delete fTree;
129 fTree = 0;
130 }*/
131 if (fFile) {
132 fFile->Close();
133 fFile = 0;
134 }
135
136 for (Int_t i = fListOfObjectsToBeDeleted->GetEntriesFast()-1; i >= 0; i--) {
137 //cout << "Index " << i << " trying to delete the following object: " << fListOfObjectsToBeDeleted->At(i)->GetName() << "..."<< endl;
138 delete fListOfObjectsToBeDeleted->At(i);
139 }
140 delete fListOfObjectsToBeDeleted;
141}
142
143//_____________________________________________________________________________
144Int_t AliTPCCalibViewer::EasyDraw(const char* drawCommand, const char* sector, const char* cuts, const char* drawOptions, Bool_t writeDrawCommand) const {
145 //
146 // easy drawing of data, use '~' for abbreviation of '.fElements'
147 // example: EasyDraw("CETmean~-CETmean_mean", "A", "(CETmean~-CETmean_mean)>0")
148 // sector: sector-number - only the specified sector will be drwawn
149 // 'A'/'C' or 'a'/'c' - side A/C will be drawn
150 // 'ALL' - whole TPC will be drawn, projected on one side
151 // cuts: specifies cuts
152 // drawOptions: draw options like 'same'
153 // writeDrawCommand: write the command, that is passed to TTree::Draw
154 //
155 TString drawStr(drawCommand);
156 TString sectorStr(sector);
157 sectorStr.ToUpper();
158 TString cutStr("");
159 TString drawOptionsStr("profcolz ");
160 TRandom rnd(0);
161 Int_t rndNumber = rnd.Integer(10000);
162 if (drawOptions && drawOptions != "")
163 drawOptionsStr += drawOptions;
164
165 if (sectorStr == "A") {
166 drawStr += ":gy.fElements:gx.fElements>>prof";
167 drawStr += rndNumber;
168 drawStr += "(330,-250,250,330,-250,250)";
169 cutStr += "(sector/18)%2==0 ";
170 }
171 else if (sectorStr == "C") {
172 drawStr += ":gy.fElements:gx.fElements>>prof";
173 drawStr += rndNumber;
174 drawStr += "(330,-250,250,330,-250,250)";
175 cutStr += "(sector/18)%2==1 ";
176 }
177 else if (sectorStr == "ALL") {
178 drawStr += ":gy.fElements:gx.fElements>>prof";
179 drawStr += rndNumber;
180 drawStr += "(330,-250,250,330,-250,250)";
181 }
182 else if (sectorStr.IsDigit()) {
183 Int_t isec = sectorStr.Atoi();
184 drawStr += ":rpad.fElements:row.fElements>>prof";
185 drawStr += rndNumber;
186 if (isec < 36 && isec >= 0)
187 drawStr += "(63,0,63,108,-54,54)";
188 else if (isec < 72 && isec >= 36)
189 drawStr += "(96,0,96,140,-70,70)";
190 else {
191 Error("EasyDraw","The TPC contains only sectors between 0 and 71.");
192 return -1;
193 }
194 cutStr += "(sector==";
195 cutStr += isec;
196 cutStr += ") ";
197 }
198
199 if (cuts && cuts[0] != 0) {
200 if (cutStr.Length() != 0) cutStr += "&& ";
201 cutStr += "(";
202 cutStr += cuts;
203 cutStr += ")";
204 }
205 drawStr.ReplaceAll("~", ".fElements");
206 cutStr.ReplaceAll("~", ".fElements");
207 if (writeDrawCommand) std::cout << "fTree->Draw(\"" << drawStr << "\", \"" << cutStr << "\", \"" << drawOptionsStr << "\");" << std::endl;
208 return fTree->Draw(drawStr.Data(), cutStr.Data(), drawOptionsStr.Data());
209}
210
211Int_t AliTPCCalibViewer::EasyDraw(const char* drawCommand, Int_t sector, const char* cuts, const char* drawOptions, Bool_t writeDrawCommand) const {
212 //
213 // easy drawing of data, use '~' for abbreviation of '.fElements'
214 // example: EasyDraw("CETmean~-CETmean_mean", 34, "(CETmean~-CETmean_mean)>0")
215 // sector: sector-number - only the specified sector will be drwawn
216 // cuts: specifies cuts
217 // drawOptions: draw options like 'same'
218 // writeDrawCommand: write the command, that is passed to TTree::Draw
219 //
220 if (sector >= 0 && sector < 72) {
221 char sectorChr[3];
222 sprintf(sectorChr, "%i", sector);
223 return EasyDraw(drawCommand, sectorChr, cuts, drawOptions, writeDrawCommand);
224 }
225 Error("EasyDraw","The TPC contains only sectors between 0 and 71.");
226 return -1;
227}
228
229//_____________________________________________________________________________
230Int_t AliTPCCalibViewer::EasyDraw1D(const char* drawCommand, const char* sector, const char* cuts, const char* drawOptions, Bool_t writeDrawCommand) const {
231 //
232 // easy drawing of data, use '~' for abbreviation of '.fElements'
233 // example: EasyDraw("CETmean~-CETmean_mean", "A", "(CETmean~-CETmean_mean)>0")
234 // sector: sector-number - the specified sector will be drwawn
235 // 'A'/'C' or 'a'/'c' - side A/C will be drawn
236 // 'ALL' - whole TPC will be drawn, projected on one side
237 // cuts: specifies cuts
238 // drawOptions: draw options like 'same'
239 // writeDrawCommand: write the command, that is passed to TTree::Draw
240 //
241
242 TString drawStr(drawCommand);
243 TString sectorStr(sector);
244 TString drawOptionsStr(drawOptions);
245 sectorStr.ToUpper();
246 TString cutStr("");
247
248 if (sectorStr == "A")
249 cutStr += "(sector/18)%2==0 ";
250 else if (sectorStr == "C")
251 cutStr += "(sector/18)%2==1 ";
252 else if (sectorStr.IsDigit()) {
253 Int_t isec = sectorStr.Atoi();
254 if (isec < 0 || isec > 71) {
255 Error("EasyDraw","The TPC contains only sectors between 0 and 71.");
256 return -1;
257 }
258 cutStr += "(sector==";
259 cutStr += isec;
260 cutStr += ") ";
261 }
262
263 if (cuts && cuts[0] != 0) {
264 if (cutStr.Length() != 0) cutStr += "&& ";
265 cutStr += "(";
266 cutStr += cuts;
267 cutStr += ")";
268 }
269
270 drawStr.ReplaceAll("~", ".fElements");
271 cutStr.ReplaceAll("~", ".fElements");
272 if (writeDrawCommand) std::cout << "fTree->Draw(\"" << drawStr << "\", \"" << cutStr << "\", \"" << drawOptionsStr << "\");" << std::endl;
273 return fTree->Draw(drawStr.Data(), cutStr.Data(), drawOptionsStr.Data());
274}
275
276Int_t AliTPCCalibViewer::EasyDraw1D(const char* drawCommand, Int_t sector, const char* cuts, const char* drawOptions, Bool_t writeDrawCommand) const {
277 //
278 // easy drawing of data, use '~' for abbreviation of '.fElements'
279 // example: EasyDraw("CETmean~-CETmean_mean", 34, "(CETmean~-CETmean_mean)>0")
280 // sector: sector-number - the specified sector will be drwawn
281 // cuts: specifies cuts
282 // drawOptions: draw options like 'same'
283 // writeDrawCommand: write the command, that is passed to TTree::Draw
284 //
285
286 if (sector >= 0 && sector < 72) {
287 char sectorChr[3];
288 sprintf(sectorChr, "%i", sector);
289 return EasyDraw1D(drawCommand, sectorChr, cuts, drawOptions, writeDrawCommand);
290 }
291 Error("EasyDraw","The TPC contains only sectors between 0 and 71.");
292 return -1;
293}
294
295//_____________________________________________________________________________
296Int_t AliTPCCalibViewer::DrawHisto1D(const char* type, Int_t sector, TVectorF& nsigma, Bool_t plotMean, Bool_t plotMedian, Bool_t plotLTM) const {
297 //
298 // draws a 1-dimensional histogram of 'type' for sector 'sector'
299 // TVectorF nsigma: Specifies, for which distances from the mean/median/LTM lines should be drawn, in units of sigma
300 // example: nsigma={2, 4, 6}: Three lines will be drawn, distance to mean/median/LTM: 2, 3 and 6 sigma
301 // plotMean, plotMedian, plotLTM: specifies, if mean, median and LTM should be drawn as lines into the histogram
302 //
303
304 TString typeStr(type);
305 TString sectorStr("sector==");
306 sectorStr += sector;
307
308 TCanvas* canvas = ((TCanvas*)gROOT->GetListOfCanvases()->Last());
309 Int_t oldOptStat = gStyle->GetOptStat();
310 gStyle->SetOptStat(0000000);
311
312 if (!canvas) {
313 canvas = new TCanvas();
314 fListOfObjectsToBeDeleted->Add(canvas);
315 }
316
317 char c[500];
318 sprintf(c, "%s, sector: %i", type, sector);
319 TLegend * legend = new TLegend(.8,.6, .99, .99, c);
320 fListOfObjectsToBeDeleted->Add(legend);
321
322 Int_t nentries = fTree->Draw((typeStr+".fElements").Data(), sectorStr.Data(), "");
323 ((TH1F*)canvas->GetPrimitive("htemp"))->SetTitle("");
324
325 //****************************************************************
326 //!!!!!!!!!!!!!!!!! Needs further investigaton !!!!!!!!!!!!!!!!!!!
327 //****************************************************************
328 //fListOfObjectsToBeDeleted->Add(canvas->GetPrimitive("htemp"));
329/*
330 By default the temporary histogram created is called "htemp", but only in
331 the one dimensional Draw("e1") it contains the TTree's data points. For
332 a two dimensional Draw, the data is filled into a TGraph which is named
333 "Graph". They can be retrieved by calling
334 TH1F *htemp = (TH1F*)gPad->GetPrimitive("htemp"); // 1D
335 TGraph *graph = (TGraph*)gPad->GetPrimitive("Graph"); // 2D
336*/
337
338 canvas->Update();
339 Double_t sigma = 0;
340
341 if (plotMean) {
342 fTree->Draw((typeStr+"_Mean").Data(), sectorStr.Data(), "goff");
343 Double_t lineX = fTree->GetV1()[0];
344 fTree->Draw((typeStr+"_RMS").Data(), sectorStr.Data(), "goff");
345 sigma = fTree->GetV1()[0];
346 TLine* line = new TLine(lineX, 0, lineX, canvas->GetUymax());
347 fListOfObjectsToBeDeleted->Add(line);
348 line->SetLineColor(kRed);
349 line->SetLineWidth(2);
350 line->SetLineStyle(1);
351 line->Draw();
352 sprintf(c, "Mean: %f", lineX);
353 legend->AddEntry(line, c, "l");
354
355 for (Int_t i = 0; i < nsigma.GetNoElements(); i++) {
356 TLine* linePlusSigma = new TLine(lineX+nsigma[i]*sigma, 0, lineX+nsigma[i]*sigma, canvas->GetUymax());
357 fListOfObjectsToBeDeleted->Add(linePlusSigma);
358 linePlusSigma->SetLineColor(kRed);
359 linePlusSigma->SetLineStyle(2+i);
360 linePlusSigma->Draw();
361
362 TLine* lineMinusSigma = new TLine(lineX-nsigma[i]*sigma, 0, lineX-nsigma[i]*sigma, canvas->GetUymax());
363 fListOfObjectsToBeDeleted->Add(lineMinusSigma);
364 lineMinusSigma->SetLineColor(kRed);
365 lineMinusSigma->SetLineStyle(2+i);
366 lineMinusSigma->Draw();
367 sprintf(c, "%i #sigma = %f",(Int_t)(nsigma[i]), (Float_t)(nsigma[i]*sigma));
368 std::cout << "nsigma-char*: " << c << std::endl;
369 legend->AddEntry(lineMinusSigma, c, "l");
370 }
371 }
372
373 if (plotMedian) {
374 fTree->Draw((typeStr+"_Median").Data(), sectorStr.Data(), "goff");
375 Double_t lineX = fTree->GetV1()[0];
376 fTree->Draw((typeStr+"_RMS").Data(), sectorStr.Data(), "goff");
377 sigma = fTree->GetV1()[0];
378 TLine* line = new TLine(lineX, 0, lineX, canvas->GetUymax());
379 fListOfObjectsToBeDeleted->Add(line);
380 line->SetLineColor(kBlue);
381 line->SetLineWidth(2);
382 line->SetLineStyle(1);
383 line->Draw();
384 sprintf(c, "Median: %f", lineX);
385 legend->AddEntry(line, c, "l");
386
387 for (Int_t i = 0; i < nsigma.GetNoElements(); i++) {
388 TLine* linePlusSigma = new TLine(lineX+nsigma[i]*sigma, 0, lineX+nsigma[i]*sigma, canvas->GetUymax());
389 fListOfObjectsToBeDeleted->Add(linePlusSigma);
390 linePlusSigma->SetLineColor(kBlue);
391 linePlusSigma->SetLineStyle(2+i);
392 linePlusSigma->Draw();
393
394 TLine* lineMinusSigma = new TLine(lineX-nsigma[i]*sigma, 0, lineX-nsigma[i]*sigma, canvas->GetUymax());
395 fListOfObjectsToBeDeleted->Add(lineMinusSigma);
396 lineMinusSigma->SetLineColor(kBlue);
397 lineMinusSigma->SetLineStyle(2+i);
398 lineMinusSigma->Draw();
399 sprintf(c, "%i #sigma = %f",(Int_t)(nsigma[i]), (Float_t)(nsigma[i]*sigma));
400 legend->AddEntry(lineMinusSigma, c, "l");
401 }
402 }
403
404 if (plotLTM) {
405 fTree->Draw((typeStr+"_LTM").Data(), sectorStr.Data(), "goff");
406 Double_t lineX = fTree->GetV1()[0];
407 fTree->Draw((typeStr+"_RMS_LTM").Data(), sectorStr.Data(), "goff");
408 sigma = fTree->GetV1()[0];
409 TLine* line = new TLine(lineX, 0, lineX, canvas->GetUymax());
410 fListOfObjectsToBeDeleted->Add(line);
411 line->SetLineColor(kGreen+2);
412 line->SetLineWidth(2);
413 line->SetLineStyle(1);
414 line->Draw();
415 sprintf(c, "LTM: %f", lineX);
416 legend->AddEntry(line, c, "l");
417
418 for (Int_t i = 0; i < nsigma.GetNoElements(); i++) {
419 TLine* linePlusSigma = new TLine(lineX+nsigma[i]*sigma, 0, lineX+nsigma[i]*sigma, canvas->GetUymax());
420 fListOfObjectsToBeDeleted->Add(linePlusSigma);
421 linePlusSigma->SetLineColor(kGreen+2);
422 linePlusSigma->SetLineStyle(2+i);
423 linePlusSigma->Draw();
424
425 TLine* lineMinusSigma = new TLine(lineX-nsigma[i]*sigma, 0, lineX-nsigma[i]*sigma, canvas->GetUymax());
426 fListOfObjectsToBeDeleted->Add(lineMinusSigma);
427 lineMinusSigma->SetLineColor(kGreen+2);
428 lineMinusSigma->SetLineStyle(2+i);
429 lineMinusSigma->Draw();
430 sprintf(c, "%i #sigma = %f", (Int_t)(nsigma[i]), (Float_t)(nsigma[i]*sigma));
431 legend->AddEntry(lineMinusSigma, c, "l");
432 }
433 }
434 legend->Draw();
435 gStyle->SetOptStat(oldOptStat);
436 return nentries;
437}
438
439//_____________________________________________________________________________
440void AliTPCCalibViewer::SigmaCut(const char* type, Int_t sector, Float_t sigmaMax, Float_t sigmaStep, Bool_t plotMean, Bool_t plotMedian, Bool_t plotLTM) const {
441 //
442 // Creates a histogram, where you can see, how much of the data are inside sigma-intervals around the mean/median/LTM
443 // type: For which type of data the histogram is generated, e.g. 'CEQmean'
444 // sector: For which sector the histogram is generated
445 // sigmaMax: up to which sigma around the mean/median/LTM the histogram is generated
446 // sigmaStep: the binsize of the generated histogram
447 // plotMean/plotMedian/plotLTM: specifies where to put the center
448 //
449 Int_t oldOptStat = gStyle->GetOptStat();
450 gStyle->SetOptStat(0000000);
451
452 TString typeStr(type);
453 TString sectorStr("sector==");
454 sectorStr += sector;
455 Int_t entries = fTree->Draw((typeStr+".fElements").Data(), sectorStr.Data(), "goff");
456 char headline[500];
457 sprintf(headline, "%s in sector %i; Multiples of #sigma; Fraction of used pads", type, sector);
458 TH1F *histMean = new TH1F("histMean",headline, (Int_t)(sigmaMax/sigmaStep+1), 0, sigmaMax+sigmaStep);
459 sprintf(headline, "%s in sector %i; Multiples of #sigma; Fraction of used pads", type, sector);
460 TH1F *histMedian = new TH1F("histMedian",headline, (Int_t)(sigmaMax/sigmaStep+1), 0, sigmaMax+sigmaStep);
461 sprintf(headline, "%s in sector %i; Multiples of #sigma; Fraction of used pads", type, sector);
462 TH1F *histLTM = new TH1F("histLTM",headline, (Int_t)(sigmaMax/sigmaStep+1), 0, sigmaMax+sigmaStep);
463 histMean->SetDirectory(0);
464 histMedian->SetDirectory(0);
465 histLTM->SetDirectory(0);
466 fListOfObjectsToBeDeleted->Add(histMean);
467 fListOfObjectsToBeDeleted->Add(histMedian);
468 fListOfObjectsToBeDeleted->Add(histLTM);
469
470
471 // example-cut: sector==34 && TMath::Abs(CEQmean.fElements - CEQmean_Mean) < nsigma * CEQmean_RMS
472 for (Float_t nsigma = 0; nsigma <= sigmaMax; nsigma += sigmaStep) {
473 std::cout << "Calculating histograms, step: " << (Int_t)(nsigma/sigmaStep) << " of: " << (Int_t)(sigmaMax/sigmaStep) << "\r" << std::flush;
474 char cuts[5000];
475
476 if (plotMean) {
477 sprintf(cuts, "sector==%i && ( %s.fElements - %s_Median) < %f * %s_RMS", sector, type, type, nsigma, type );
478 sprintf(cuts, "%s && (-%s.fElements + %s_Median) < %f * %s_RMS", cuts, type, type, nsigma, type );
479 Float_t value = (Float_t)fTree->Draw((typeStr+".fElements").Data(), cuts, "goff")/entries;
480 histMean->Fill(nsigma, value);
481 }
482 if (plotMedian) {
483 sprintf(cuts, "sector==%i && ( %s.fElements - %s_Mean) < %f * %s_RMS", sector, type, type, nsigma, type );
484 sprintf(cuts, "%s && (-%s.fElements + %s_Mean) < %f * %s_RMS", cuts, type, type, nsigma, type );
485 Float_t value = (Float_t)fTree->Draw((typeStr+".fElements").Data(), cuts, "goff")/entries;
486 histMedian->Fill(nsigma, value);
487 }
488 if (plotLTM) {
489 sprintf(cuts, "sector==%i && ( %s.fElements - %s_LTM) < %f * %s_RMS_LTM", sector, type, type, nsigma, type );
490 sprintf(cuts, "%s && (-%s.fElements + %s_LTM) < %f * %s_RMS_LTM", cuts, type, type, nsigma, type );
491 Float_t value = (Float_t)fTree->Draw((typeStr+".fElements").Data(), cuts, "goff")/entries;
492 histLTM->Fill(nsigma, value);
493 }
494 }
495
496 char c[500];
497 sprintf(c, "Sigma Cut");
498 TLegend * legend = new TLegend(.85,.8, .99, .99, c);
499 fListOfObjectsToBeDeleted->Add(legend);
500
501 if (plotMean){
502 histMean->SetLineColor(kBlack);
503 sprintf(c, "Mean");
504 legend->AddEntry(histMean, c, "l");
505 histMean->Draw();
506 }
507 if (plotMedian){
508 histMedian->SetLineColor(kRed);
509 sprintf(c, "Median");
510 legend->AddEntry(histMedian, c, "l");
511 histMedian->Draw("same");
512 }
513 if (plotLTM){
514 histLTM->SetLineColor(kBlue);
515 sprintf(c, "LTM");
516 legend->AddEntry(histLTM, c, "l");
517 histLTM->Draw("same");
518 }
519
520 legend->Draw();
521 gStyle->SetOptStat(oldOptStat);
522}
523
524
525//_____________________________________________________________________________
526AliTPCCalPad* AliTPCCalibViewer::GetCalPad(const char* desiredData, char* cuts, char* calPadName) const {
527 //
528 // creates a AliTPCCalPad out of the 'desiredData'
529 // the functionality of EasyDraw1D is used
530 // calPadName specifies the name of the created AliTPCCalPad
531 // - this takes a while -
532 //
533 TString drawStr(desiredData);
534 drawStr.Append(":channel~");
535 AliTPCCalPad * createdCalPad = new AliTPCCalPad(calPadName, calPadName);
536 Int_t entries = 0;
537 for (Int_t sec = 0; sec < 72; sec++) {
538 entries = EasyDraw1D(drawStr.Data(), (Int_t)sec, cuts, "goff");
539 for (Int_t i = 0; i < entries; i++)
540 createdCalPad->GetCalROC(sec)->SetValue((UInt_t)(fTree->GetV2()[i]), (Float_t)(fTree->GetV1()[i]));
541 }
542 return createdCalPad;
543}
544
545//_____________________________________________________________________________
546AliTPCCalROC* AliTPCCalibViewer::GetCalROC(const char* desiredData, UInt_t sector, char* cuts) const {
547 //
548 // creates a AliTPCCalROC out of the desiredData
549 // the functionality of EasyDraw1D is used
550 // sector specifies the sector of the created AliTPCCalROC
551 //
552 TString drawStr(desiredData);
553 drawStr.Append(":channel~");
554 Int_t entries = EasyDraw1D(drawStr.Data(), (Int_t)sector, cuts, "goff");
555 AliTPCCalROC * createdROC = new AliTPCCalROC(sector);
556 for (Int_t i = 0; i < entries; i++)
557 createdROC->SetValue((UInt_t)(fTree->GetV2()[i]), fTree->GetV1()[i]);
558 return createdROC;
559}
560
561
562TObjArray* AliTPCCalibViewer::GetListOfVariables(Bool_t printList) {
563 //
564 // scan the tree - produces a list of available variables in the tree
565 // printList: print the list to the screen, after the scan is done
566 //
567 TObjArray* arr = new TObjArray();
568 TObjString* str = 0;
569 Int_t nentries = fTree->GetListOfBranches()->GetEntries();
570 for (Int_t i = 0; i < nentries; i++) {
571 str = new TObjString(fTree->GetListOfBranches()->At(i)->GetName());
572 str->String().ReplaceAll("_Median", "");
573 str->String().ReplaceAll("_Mean", "");
574 str->String().ReplaceAll("_RMS", "");
575 str->String().ReplaceAll("_LTM", "");
576 str->String().ReplaceAll("_OutlierCutted", "");
577 str->String().ReplaceAll(".", "");
578 if (!arr->FindObject(str) &&
579 !(str->String() == "channel" || str->String() == "gx" || str->String() == "gy" ||
580 str->String() == "lx" || str->String() == "ly" || str->String() == "pad" ||
581 str->String() == "row" || str->String() == "rpad" || str->String() == "sector" ))
582 arr->Add(str);
583 }
584 arr->Sort();
585
586 if (printList) {
587 TIterator* iter = arr->MakeIterator();
588 iter->Reset();
589 TObjString* currentStr = 0;
590 while ( (currentStr = (TObjString*)(iter->Next())) ) {
591 std::cout << currentStr->GetString().Data() << std::endl;
592 }
593 delete iter;
594 }
595 return arr;
596}
597
598
599TObjArray* AliTPCCalibViewer::GetListOfNormalizationVariables(Bool_t printList) {
600 //
601 // produces a list of available variables for normalization in the tree
602 // printList: print the list to the screen, after the scan is done
603 //
604 TObjArray* arr = new TObjArray();
605 arr->Add(new TObjString("_Mean"));
606 arr->Add(new TObjString("_Mean_OutlierCutted"));
607 arr->Add(new TObjString("_Median"));
608 arr->Add(new TObjString("_Median_OutlierCutted"));
609 arr->Add(new TObjString("_LTM"));
610 arr->Add(new TObjString("_LTM_OutlierCutted"));
611 arr->Add(new TObjString("LFitIntern_4_8.fElements"));
612 arr->Add(new TObjString("GFitIntern_Lin.fElements"));
613 arr->Add(new TObjString("GFitIntern_Par.fElements"));
614
615 if (printList) {
616 TIterator* iter = arr->MakeIterator();
617 iter->Reset();
618 TObjString* currentStr = 0;
619 while ((currentStr = (TObjString*)(iter->Next()))) {
620 std::cout << currentStr->GetString().Data() << std::endl;
621 }
622 delete iter;
623 }
624 return arr;
625}
626
627
628TFriendElement* AliTPCCalibViewer::AddReferenceTree(const char* filename, const char* treename, const char* refname){
629 //
630 // add a reference tree to the current tree
631 // by default the treename is 'calPads' and the reference treename is 'R'
632 //
633 TFile *file = new TFile(filename);
634 fListOfObjectsToBeDeleted->Add(file);
635 TTree * tree = (TTree*)file->Get(treename);
636 return AddFriend(tree, refname);
637}
638
639
640TObjArray* AliTPCCalibViewer::GetArrayOfCalPads(){
641 //
642 // Returns a TObjArray with all AliTPCCalPads that are stored in the tree
643 // - this takes a while -
644 //
645 TObjArray *listOfCalPads = GetListOfVariables();
646 TObjArray *calPadsArray = new TObjArray();
647 Int_t numberOfCalPads = listOfCalPads->GetEntries();
648 for (Int_t i = 0; i < numberOfCalPads; i++) {
649 std::cout << "Creating calPad " << (i+1) << " of " << numberOfCalPads << "\r" << std::flush;
650 char* calPadName = (char*)((TObjString*)(listOfCalPads->At(i)))->GetString().Data();
651 TString drawCommand = ((TObjString*)(listOfCalPads->At(i)))->GetString();
652 drawCommand.Append("~");
653 AliTPCCalPad* calPad = GetCalPad(drawCommand.Data(), "", calPadName);
654 calPadsArray->Add(calPad);
655 }
656 std::cout << std::endl;
657 listOfCalPads->Delete();
658 delete listOfCalPads;
659 return calPadsArray;
660}
661
662
663void AliTPCCalibViewer::MakeTreeWithObjects(const char * fileName, TObjArray * array, const char * mapFileName) {
664 //
665 // Write tree with all available information
666 // im mapFileName is speciefied, the Map information are also written to the tree
667 // AliTPCCalPad-Objects are written directly to the tree, so that they can be accessd later on
668 // (does not work!!!)
669 //
670 AliTPCROC* tpcROCinstance = AliTPCROC::Instance();
671
672 TObjArray* mapIROCs = 0;
673 TObjArray* mapOROCs = 0;
674 TVectorF *mapIROCArray = 0;
675 TVectorF *mapOROCArray = 0;
676 Int_t mapEntries = 0;
677 TString* mapNames = 0;
678
679 if (mapFileName) {
680 TFile mapFile(mapFileName, "read");
681
682 TList* listOfROCs = mapFile.GetListOfKeys();
683 mapEntries = listOfROCs->GetEntries()/2;
684 mapIROCs = new TObjArray(mapEntries*2);
685 mapOROCs = new TObjArray(mapEntries*2);
686 mapIROCArray = new TVectorF[mapEntries];
687 mapOROCArray = new TVectorF[mapEntries];
688
689 mapNames = new TString[mapEntries];
690 for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
691 TString ROCname(((TKey*)(listOfROCs->At(ivalue*2)))->GetName());
692 ROCname.Remove(ROCname.Length()-4, 4);
693 mapIROCs->AddAt((AliTPCCalROC*)mapFile.Get((ROCname + "IROC").Data()), ivalue);
694 mapOROCs->AddAt((AliTPCCalROC*)mapFile.Get((ROCname + "OROC").Data()), ivalue);
695 mapNames[ivalue].Append(ROCname);
696 }
697
698 for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
699 mapIROCArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(0));
700 mapOROCArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(36));
701
702 for (UInt_t ichannel = 0; ichannel < tpcROCinstance->GetNChannels(0); ichannel++)
703 (mapIROCArray[ivalue])[ichannel] = ((AliTPCCalROC*)(mapIROCs->At(ivalue)))->GetValue(ichannel);
704 for (UInt_t ichannel = 0; ichannel < tpcROCinstance->GetNChannels(36); ichannel++)
705 (mapOROCArray[ivalue])[ichannel] = ((AliTPCCalROC*)(mapOROCs->At(ivalue)))->GetValue(ichannel);
706 }
707
708 } // if (mapFileName)
709
710 TTreeSRedirector cstream(fileName);
711 Int_t arrayEntries = array->GetEntries();
712
713 // Read names of AliTPCCalPads and save them in names[]
714 TString* names = new TString[arrayEntries];
715 for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++)
716 names[ivalue].Append(((AliTPCCalPad*)array->At(ivalue))->GetName());
717
718 for (UInt_t isector = 0; isector < tpcROCinstance->GetNSectors(); isector++) {
719
720 TVectorF *vectorArray = new TVectorF[arrayEntries];
721 for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++)
722 vectorArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(isector));
723
724
725 //
726 // fill vectors of variable per pad
727 //
728 TVectorF *posArray = new TVectorF[8];
729 for (Int_t ivalue = 0; ivalue < 8; ivalue++)
730 posArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(isector));
731
732 Float_t posG[3] = {0};
733 Float_t posL[3] = {0};
734 Int_t ichannel = 0;
735 for (UInt_t irow = 0; irow < tpcROCinstance->GetNRows(isector); irow++) {
736 for (UInt_t ipad = 0; ipad < tpcROCinstance->GetNPads(isector, irow); ipad++) {
737 tpcROCinstance->GetPositionLocal(isector, irow, ipad, posL);
738 tpcROCinstance->GetPositionGlobal(isector, irow, ipad, posG);
739 posArray[0][ichannel] = irow;
740 posArray[1][ichannel] = ipad;
741 posArray[2][ichannel] = posL[0];
742 posArray[3][ichannel] = posL[1];
743 posArray[4][ichannel] = posG[0];
744 posArray[5][ichannel] = posG[1];
745 posArray[6][ichannel] = (Int_t)(ipad - (Double_t)(tpcROCinstance->GetNPads(isector, irow))/2);
746 posArray[7][ichannel] = ichannel;
747
748 // loop over array containing AliTPCCalPads
749 for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
750 AliTPCCalPad* calPad = (AliTPCCalPad*) array->At(ivalue);
751 AliTPCCalROC* calROC = calPad->GetCalROC(isector);
752 if (calROC)
753 (vectorArray[ivalue])[ichannel] = calROC->GetValue(irow, ipad);
754 else
755 (vectorArray[ivalue])[ichannel] = 0;
756 }
757 ichannel++;
758 }
759 }
760 AliTPCCalROC dummyROC(0);
761 for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
762 AliTPCCalROC *roc = ((AliTPCCalPad*)array->At(ivalue))->GetCalROC(isector);
763 if (!roc) roc = &dummyROC;
764 cstream << "calPads" <<
765 (Char_t*)((names[ivalue] + ".=").Data()) << &vectorArray[ivalue];
766 cstream << "calPads" <<
767 (Char_t*)((names[ivalue] + "Pad.=").Data()) << roc;
768 }
769
770 if (mapFileName) {
771 for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
772 if (isector < 36)
773 cstream << "calPads" <<
774 (Char_t*)((mapNames[ivalue] + ".=").Data()) << &mapIROCArray[ivalue];
775 else
776 cstream << "calPads" <<
777 (Char_t*)((mapNames[ivalue] + ".=").Data()) << &mapOROCArray[ivalue];
778 }
779 }
780
781 cstream << "calPads" <<
782 "sector=" << isector;
783
784 cstream << "calPads" <<
785 "row.=" << &posArray[0] <<
786 "pad.=" << &posArray[1] <<
787 "lx.=" << &posArray[2] <<
788 "ly.=" << &posArray[3] <<
789 "gx.=" << &posArray[4] <<
790 "gy.=" << &posArray[5] <<
791 "rpad.=" << &posArray[6] <<
792 "channel.=" << &posArray[7];
793
794 cstream << "calPads" <<
795 "\n";
796
797 delete[] posArray;
798 delete[] vectorArray;
799 } //for (UInt_t isector = 0; isector < tpcROCinstance->GetNSectors(); isector++)
800
801 delete[] names;
802 if (mapFileName) {
803 delete mapIROCs;
804 delete mapOROCs;
805 delete[] mapIROCArray;
806 delete[] mapOROCArray;
807 delete[] mapNames;
808 }
809}
810
811void AliTPCCalibViewer::MakeTree(const char * fileName, TObjArray * array, const char * mapFileName, AliTPCCalPad* outlierPad, Float_t ltmFraction) {
812 //
813 // Write a tree with all available information
814 // im mapFileName is speciefied, the Map information are also written to the tree
815 // pads specified in outlierPad are not used for calculating statistics
816 // - the same function as AliTPCCalPad::MakeTree -
817 //
818 AliTPCROC* tpcROCinstance = AliTPCROC::Instance();
819
820 TObjArray* mapIROCs = 0;
821 TObjArray* mapOROCs = 0;
822 TVectorF *mapIROCArray = 0;
823 TVectorF *mapOROCArray = 0;
824 Int_t mapEntries = 0;
825 TString* mapNames = 0;
826
827 if (mapFileName) {
828 TFile mapFile(mapFileName, "read");
829
830 TList* listOfROCs = mapFile.GetListOfKeys();
831 mapEntries = listOfROCs->GetEntries()/2;
832 mapIROCs = new TObjArray(mapEntries*2);
833 mapOROCs = new TObjArray(mapEntries*2);
834 mapIROCArray = new TVectorF[mapEntries];
835 mapOROCArray = new TVectorF[mapEntries];
836
837 mapNames = new TString[mapEntries];
838 for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
839 TString ROCname(((TKey*)(listOfROCs->At(ivalue*2)))->GetName());
840 ROCname.Remove(ROCname.Length()-4, 4);
841 mapIROCs->AddAt((AliTPCCalROC*)mapFile.Get((ROCname + "IROC").Data()), ivalue);
842 mapOROCs->AddAt((AliTPCCalROC*)mapFile.Get((ROCname + "OROC").Data()), ivalue);
843 mapNames[ivalue].Append(ROCname);
844 }
845
846 for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
847 mapIROCArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(0));
848 mapOROCArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(36));
849
850 for (UInt_t ichannel = 0; ichannel < tpcROCinstance->GetNChannels(0); ichannel++)
851 (mapIROCArray[ivalue])[ichannel] = ((AliTPCCalROC*)(mapIROCs->At(ivalue)))->GetValue(ichannel);
852 for (UInt_t ichannel = 0; ichannel < tpcROCinstance->GetNChannels(36); ichannel++)
853 (mapOROCArray[ivalue])[ichannel] = ((AliTPCCalROC*)(mapOROCs->At(ivalue)))->GetValue(ichannel);
854 }
855
856 } // if (mapFileName)
857
858 TTreeSRedirector cstream(fileName);
859 Int_t arrayEntries = array->GetEntries();
860
861 TString* names = new TString[arrayEntries];
862 for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++)
863 names[ivalue].Append(((AliTPCCalPad*)array->At(ivalue))->GetName());
864
865 for (UInt_t isector = 0; isector < tpcROCinstance->GetNSectors(); isector++) {
866 //
867 // get statistic for given sector
868 //
869 TVectorF median(arrayEntries);
870 TVectorF mean(arrayEntries);
871 TVectorF rms(arrayEntries);
872 TVectorF ltm(arrayEntries);
873 TVectorF ltmrms(arrayEntries);
874 TVectorF medianWithOut(arrayEntries);
875 TVectorF meanWithOut(arrayEntries);
876 TVectorF rmsWithOut(arrayEntries);
877 TVectorF ltmWithOut(arrayEntries);
878 TVectorF ltmrmsWithOut(arrayEntries);
879
880 TVectorF *vectorArray = new TVectorF[arrayEntries];
881 for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++)
882 vectorArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(isector));
883
884 for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
885 AliTPCCalPad* calPad = (AliTPCCalPad*) array->At(ivalue);
886 AliTPCCalROC* calROC = calPad->GetCalROC(isector);
887 AliTPCCalROC* outlierROC = 0;
888 if (outlierPad) outlierROC = outlierPad->GetCalROC(isector);
889 if (calROC) {
890 median[ivalue] = calROC->GetMedian();
891 mean[ivalue] = calROC->GetMean();
892 rms[ivalue] = calROC->GetRMS();
893 Double_t ltmrmsValue = 0;
894 ltm[ivalue] = calROC->GetLTM(&ltmrmsValue, ltmFraction);
895 ltmrms[ivalue] = ltmrmsValue;
896 if (outlierROC) {
897 medianWithOut[ivalue] = calROC->GetMedian(outlierROC);
898 meanWithOut[ivalue] = calROC->GetMean(outlierROC);
899 rmsWithOut[ivalue] = calROC->GetRMS(outlierROC);
900 ltmrmsValue = 0;
901 ltmWithOut[ivalue] = calROC->GetLTM(&ltmrmsValue, ltmFraction, outlierROC);
902 ltmrmsWithOut[ivalue] = ltmrmsValue;
903 }
904 }
905 else {
906 median[ivalue] = 0.;
907 mean[ivalue] = 0.;
908 rms[ivalue] = 0.;
909 ltm[ivalue] = 0.;
910 ltmrms[ivalue] = 0.;
911 medianWithOut[ivalue] = 0.;
912 meanWithOut[ivalue] = 0.;
913 rmsWithOut[ivalue] = 0.;
914 ltmWithOut[ivalue] = 0.;
915 ltmrmsWithOut[ivalue] = 0.;
916 }
917 }
918
919 //
920 // fill vectors of variable per pad
921 //
922 TVectorF *posArray = new TVectorF[8];
923 for (Int_t ivalue = 0; ivalue < 8; ivalue++)
924 posArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(isector));
925
926 Float_t posG[3] = {0};
927 Float_t posL[3] = {0};
928 Int_t ichannel = 0;
929 for (UInt_t irow = 0; irow < tpcROCinstance->GetNRows(isector); irow++) {
930 for (UInt_t ipad = 0; ipad < tpcROCinstance->GetNPads(isector, irow); ipad++) {
931 tpcROCinstance->GetPositionLocal(isector, irow, ipad, posL);
932 tpcROCinstance->GetPositionGlobal(isector, irow, ipad, posG);
933 posArray[0][ichannel] = irow;
934 posArray[1][ichannel] = ipad;
935 posArray[2][ichannel] = posL[0];
936 posArray[3][ichannel] = posL[1];
937 posArray[4][ichannel] = posG[0];
938 posArray[5][ichannel] = posG[1];
939 posArray[6][ichannel] = (Int_t)(ipad - (Double_t)(tpcROCinstance->GetNPads(isector, irow))/2);
940 posArray[7][ichannel] = ichannel;
941
942 // loop over array containing AliTPCCalPads
943 for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
944 AliTPCCalPad* calPad = (AliTPCCalPad*) array->At(ivalue);
945 AliTPCCalROC* calROC = calPad->GetCalROC(isector);
946 if (calROC)
947 (vectorArray[ivalue])[ichannel] = calROC->GetValue(irow, ipad);
948 else
949 (vectorArray[ivalue])[ichannel] = 0;
950 }
951 ichannel++;
952 }
953 }
954
955 cstream << "calPads" <<
956 "sector=" << isector;
957
958 for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
959 cstream << "calPads" <<
960 (Char_t*)((names[ivalue] + "_Median=").Data()) << median[ivalue] <<
961 (Char_t*)((names[ivalue] + "_Mean=").Data()) << mean[ivalue] <<
962 (Char_t*)((names[ivalue] + "_RMS=").Data()) << rms[ivalue] <<
963 (Char_t*)((names[ivalue] + "_LTM=").Data()) << ltm[ivalue] <<
964 (Char_t*)((names[ivalue] + "_RMS_LTM=").Data()) << ltmrms[ivalue];
965 if (outlierPad) {
966 cstream << "calPads" <<
967 (Char_t*)((names[ivalue] + "_Median_OutlierCutted=").Data()) << medianWithOut[ivalue] <<
968 (Char_t*)((names[ivalue] + "_Mean_OutlierCutted=").Data()) << meanWithOut[ivalue] <<
969 (Char_t*)((names[ivalue] + "_RMS_OutlierCutted=").Data()) << rmsWithOut[ivalue] <<
970 (Char_t*)((names[ivalue] + "_LTM_OutlierCutted=").Data()) << ltmWithOut[ivalue] <<
971 (Char_t*)((names[ivalue] + "_RMS_LTM_OutlierCutted=").Data()) << ltmrmsWithOut[ivalue];
972 }
973 }
974
975 for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
976 cstream << "calPads" <<
977 (Char_t*)((names[ivalue] + ".=").Data()) << &vectorArray[ivalue];
978 }
979
980 if (mapFileName) {
981 for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
982 if (isector < 36)
983 cstream << "calPads" <<
984 (Char_t*)((mapNames[ivalue] + ".=").Data()) << &mapIROCArray[ivalue];
985 else
986 cstream << "calPads" <<
987 (Char_t*)((mapNames[ivalue] + ".=").Data()) << &mapOROCArray[ivalue];
988 }
989 }
990
991 cstream << "calPads" <<
992 "row.=" << &posArray[0] <<
993 "pad.=" << &posArray[1] <<
994 "lx.=" << &posArray[2] <<
995 "ly.=" << &posArray[3] <<
996 "gx.=" << &posArray[4] <<
997 "gy.=" << &posArray[5] <<
998 "rpad.=" << &posArray[6] <<
999 "channel.=" << &posArray[7];
1000
1001 cstream << "calPads" <<
1002 "\n";
1003
1004 delete[] posArray;
1005 delete[] vectorArray;
1006 }
1007
1008
1009 delete[] names;
1010 if (mapFileName) {
1011 delete mapIROCs;
1012 delete mapOROCs;
1013 delete[] mapIROCArray;
1014 delete[] mapOROCArray;
1015 delete[] mapNames;
1016 }
1017}
1018