]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWG1/TRD/AliTRDcalibration.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix bug in RefMaker. A memset of Int_ts was used for fPID instead of
[u/mrichter/AliRoot.git] / PWG1 / TRD / AliTRDcalibration.cxx
CommitLineData
1ee39b3a 1
2/**************************************************************************
3* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4* *
5* Author: The ALICE Off-line Project. *
6* Contributors are mentioned in the code where appropriate. *
7* *
8* Permission to use, copy, modify and distribute this software and its *
9* documentation strictly for non-commercial purposes is hereby granted *
10* without fee, provided that the above copyright notice appears in all *
11* copies and that both the copyright notice and this permission notice *
12* appear in the supporting documentation. The authors make no claims *
13* about the suitability of this software for any purpose. It is *
14* provided "as is" without express or implied warranty. *
15**************************************************************************/
16
17/////////////////////////////////////////////////////////////////////////////////
18//
19// AliTRDcalibration
20//
21// Task to run the calibration offline.
22// Author:
23// R. Bailhache (rbailhache@ikf.uni-frankfurt.de, R.Bailhache@gsi.de)
24//
25//////////////////////////////////////////////////////////////////////////////////
26
27
28#include "Riostream.h"
29#include "TChain.h"
30#include "TTree.h"
31#include "TProfile2D.h"
32#include "TH2I.h"
33#include "TH1F.h"
34#include "TList.h"
35#include "TMath.h"
36#include "TCanvas.h"
37#include "TObject.h"
38#include "TFile.h"
39#include "TObjArray.h"
40#include "TGraph.h"
41#include "TStyle.h"
42#include "TLegend.h"
43#include "TGraphErrors.h"
44
45#include "AliTRDrecoTask.h"
46#include "AliAnalysisManager.h"
47
48#include "AliESDInputHandler.h"
49#include "AliTRDtrackV1.h"
50#include "AliTRDseedV1.h"
51#include "AliTRDcluster.h"
52#include "info/AliTRDtrackInfo.h"
53#include "AliTRDcalibDB.h"
54
55#include "AliTRDCalibraFillHisto.h"
56#include "AliTRDCalibraFit.h"
57#include "AliTRDCalibraVdriftLinearFit.h"
58#include "AliTRDCalibraMode.h"
59#include "AliTRDCalibraVector.h"
60#include "./Cal/AliTRDCalPad.h"
61#include "./Cal/AliTRDCalDet.h"
1ee39b3a 62
63#include "AliLog.h"
64
65#include "AliTRDcalibration.h"
66
67
68ClassImp(AliTRDcalibration)
69
70//________________________________________________________________________
71AliTRDcalibration::AliTRDcalibration()
f8f46e4d 72 :AliTRDrecoTask()
1ee39b3a 73 ,fTrackInfo(0)
74 ,ftrdTrack(0)
75 ,fcl(0)
76 ,fTRDCalibraFillHisto(0)
77 ,fNbTRDTrack(0)
78 ,fNbTRDTrackOffline(0)
79 ,fNbTRDTrackStandalone(0)
80 ,fNbTRDTracklet(0)
81 ,fNbTRDTrackletOffline(0)
82 ,fNbTRDTrackletStandalone(0)
83 ,fNbTimeBin(0x0)
84 ,fNbTimeBinOffline(0x0)
85 ,fNbTimeBinStandalone(0x0)
86 ,fNbClusters(0)
87 ,fNbClustersOffline(0)
88 ,fNbClustersStandalone(0)
1fb72fc9 89 ,fPHSM(0)
90 ,fCHSM(0)
1ee39b3a 91 ,fPHSum(0)
92 ,fCHSum(0)
93 ,fDetSum(0)
94 ,fDetSumVector(0)
95 ,fHisto2d(kTRUE)
96 ,fVector2d(kFALSE)
97 ,fVdriftLinear(kTRUE)
98 ,flow(0)
99 ,fhigh(30)
41753415 100 ,fNbTimeBins(0)
1ee39b3a 101 ,ffillZero(kFALSE)
102 ,fnormalizeNbOfCluster(kFALSE)
103 ,fmaxCluster(0)
104 ,fOfflineTracks(kFALSE)
105 ,fStandaloneTracks(kFALSE)
106 ,fCompressPerDetector(kFALSE)
1ee39b3a 107 ,fGraph(0x0)
1fb72fc9 108 ,fArrayCalib(0x0)
1ee39b3a 109 ,fPostProcess(kFALSE)
110{
111 // Constructor
112
113 fNRefFigures = 17;
114
115 for(Int_t k = 0; k < 3; k++)
116 {
117 fNz[k]=0;
118 fNrphi[k]=0;
119 }
120
121}
f8f46e4d 122
123AliTRDcalibration::AliTRDcalibration(char* name)
124 :AliTRDrecoTask(name, "Calibration on tracks")
125 ,fTrackInfo(0)
126 ,ftrdTrack(0)
127 ,fcl(0)
128 ,fTRDCalibraFillHisto(0)
129 ,fNbTRDTrack(0)
130 ,fNbTRDTrackOffline(0)
131 ,fNbTRDTrackStandalone(0)
132 ,fNbTRDTracklet(0)
133 ,fNbTRDTrackletOffline(0)
134 ,fNbTRDTrackletStandalone(0)
135 ,fNbTimeBin(0x0)
136 ,fNbTimeBinOffline(0x0)
137 ,fNbTimeBinStandalone(0x0)
138 ,fNbClusters(0)
139 ,fNbClustersOffline(0)
140 ,fNbClustersStandalone(0)
141 ,fPHSM(0)
142 ,fCHSM(0)
143 ,fPHSum(0)
144 ,fCHSum(0)
145 ,fDetSum(0)
146 ,fDetSumVector(0)
147 ,fHisto2d(kTRUE)
148 ,fVector2d(kFALSE)
149 ,fVdriftLinear(kTRUE)
150 ,flow(0)
151 ,fhigh(30)
152 ,fNbTimeBins(0)
153 ,ffillZero(kFALSE)
154 ,fnormalizeNbOfCluster(kFALSE)
155 ,fmaxCluster(0)
156 ,fOfflineTracks(kFALSE)
157 ,fStandaloneTracks(kFALSE)
158 ,fCompressPerDetector(kFALSE)
159 ,fGraph(0x0)
160 ,fArrayCalib(0x0)
161 ,fPostProcess(kFALSE)
162{
163 // Constructor
164
165 fNRefFigures = 17;
166
167 for(Int_t k = 0; k < 3; k++)
168 {
169 fNz[k]=0;
170 fNrphi[k]=0;
171 }
172
173}
174
1ee39b3a 175//________________________________________________________________________
176AliTRDcalibration::~AliTRDcalibration()
177{
178 // Default destructor
179
180 if(fNbTRDTrack) delete fNbTRDTrack;
181 if(fNbTRDTrackOffline) delete fNbTRDTrackOffline;
182 if(fNbTRDTrackStandalone) delete fNbTRDTrackStandalone;
183 if(fNbTRDTracklet) delete fNbTRDTracklet;
184 if(fNbTRDTrackletOffline) delete fNbTRDTrackletOffline;
185 if(fNbTRDTrackletStandalone) delete fNbTRDTrackletStandalone;
186 if(fNbTimeBin) delete fNbTimeBin;
187 if(fNbTimeBinOffline) delete fNbTimeBinOffline;
188 if(fNbTimeBinStandalone) delete fNbTimeBinStandalone;
189 if(fNbClusters) delete fNbClusters;
190 if(fNbClustersOffline) delete fNbClustersOffline;
191 if(fNbClustersStandalone) delete fNbClustersStandalone;
1fb72fc9 192 if(fPHSM) delete fPHSM;
193 if(fCHSM) delete fCHSM;
1ee39b3a 194 if(fPHSum) delete fPHSum;
195 if(fCHSum) delete fCHSum;
196 if(fDetSum) delete fDetSum;
197 if(fDetSumVector) delete fDetSumVector;
1ee39b3a 198 if(fGraph){fGraph->Delete(); delete fGraph;}
1fb72fc9 199 if(fArrayCalib){fArrayCalib->Delete(); delete fArrayCalib;}
200
1ee39b3a 201}
202//________________________________________________________________________
f8f46e4d 203void AliTRDcalibration::UserCreateOutputObjects()
1ee39b3a 204{
205 // Create output objects
206
1ee39b3a 207 // Number of time bins
41753415 208 if(fNbTimeBins==0) {
209 AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
210 fNbTimeBins = cal->GetNumberOfTimeBinsDCS();
211 if(fNbTimeBins <= 0){
212 AliWarning(Form("No of TimeBins from DB [%d] use default [30]", fNbTimeBins));
213 fNbTimeBins = 30;
214 }
215 }
1ee39b3a 216
217 // instance calibration: what to calibrate
218 fTRDCalibraFillHisto = AliTRDCalibraFillHisto::Instance();
219 fTRDCalibraFillHisto->SetHisto2d(fHisto2d); // choose to use histograms
220 fTRDCalibraFillHisto->SetVector2d(fVector2d); // choose to use vectors
221 fTRDCalibraFillHisto->SetCH2dOn(); // choose to calibrate the gain
222 fTRDCalibraFillHisto->SetPH2dOn(); // choose to calibrate the drift velocity
223 fTRDCalibraFillHisto->SetPRF2dOn(); // choose to look at the PRF
224 fTRDCalibraFillHisto->SetLinearFitterOn(fVdriftLinear); // Other possibility vdrift VDRIFT
225 fTRDCalibraFillHisto->SetLinearFitterDebugOn(fVdriftLinear); // Other possibility vdrift
226
227 // segmentation (should be per default the max and add at the end)
228 for(Int_t k = 0; k < 3; k++){
229 if(((fNz[k] != 10) && (fNrphi[k] != 10)) && ((fNz[k] != 100) && (fNrphi[k] != 100))) {
230 fTRDCalibraFillHisto->SetNz(k,fNz[k]); // Mode calibration
231 fTRDCalibraFillHisto->SetNrphi(k,fNrphi[k]); // Mode calibration
232 }
233 else {
234 if((fNz[k] == 100) && (fNrphi[k] == 100)) {
235 if(fVector2d) AliInfo("The mode all together is not supported by the vector method");
236 fTRDCalibraFillHisto->SetAllTogether(k);
237 }
238 if((fNz[k] == 10) && (fNrphi[k] == 10)) {
239 if(fVector2d) AliInfo("The mode per supermodule is not supported by the vector method");
240 fTRDCalibraFillHisto->SetPerSuperModule(k);
241 }
242 }
243 }
244
245 // Debug level
246 fTRDCalibraFillHisto->SetDebugLevel(DebugLevel()); //debug stuff
247
248 // Init the stuff
41753415 249 fTRDCalibraFillHisto->Init2Dhistos(fNbTimeBins); // initialise the histos
1ee39b3a 250
251 // cuts
252 fTRDCalibraFillHisto->SetNumberClusters(flow); // At least flow clusters
253 fTRDCalibraFillHisto->SetNumberClustersf(fhigh); // The more fhigh clusters
254 fTRDCalibraFillHisto->SetFillWithZero(ffillZero); // Fill zeros
255 fTRDCalibraFillHisto->SetNormalizeNbOfCluster(fnormalizeNbOfCluster); // For iterations
256
257 // Add them to the container
258 fContainer = new TObjArray();
259 if(fHisto2d) {
260 fContainer->Add(fTRDCalibraFillHisto->GetCH2d()); //TH2I
261 fContainer->Add(fTRDCalibraFillHisto->GetPH2d()); //TProfile2D
262 fContainer->Add(fTRDCalibraFillHisto->GetPRF2d()); //TProfile2D
263 }
264 if(fVdriftLinear) fContainer->Add(fTRDCalibraFillHisto->GetVdriftLinearFit()); // Other drift velocity
265 if(fVector2d) fContainer->Add(fTRDCalibraFillHisto->GetCalibraVector()); //calibra vector
266
267 if(DebugLevel()) {
268
269 // Init the debug histos
270 fNbTRDTrack = new TH1F("TRDTrack","TRDTrack",500,0,500);
271 fNbTRDTrack->Sumw2();
272 fNbTRDTrackOffline = new TH1F("TRDTrackOffline","TRDTrackOffline",500,0,500);
273 fNbTRDTrackOffline->Sumw2();
274 fNbTRDTrackStandalone = new TH1F("TRDTrackStandalone","TRDTrackStandalone",500,0,500);
275 fNbTRDTrackStandalone->Sumw2();
276 //
277 fNbTRDTracklet = new TH1F("TRDTracklet","TRDTracklet",540,0.,540.);
278 fNbTRDTracklet->Sumw2();
279 fNbTRDTrackletOffline = new TH1F("TRDTrackletOffline","TRDTrackletOffline",540,0.,540.);
280 fNbTRDTrackletOffline->Sumw2();
281 fNbTRDTrackletStandalone = new TH1F("TRDTrackletStandalone","TRDTrackletStandalone",540,0.,540.);
282 fNbTRDTrackletStandalone->Sumw2();
283 //
284 fNbTimeBin = new TH1F("TimeBin","TimeBin",35,0,35);
285 fNbTimeBin->Sumw2();
286 fNbTimeBinOffline = new TH1F("TimeBinOffline","TimeBinOffline",35,0,35);
287 fNbTimeBinOffline->Sumw2();
288 fNbTimeBinStandalone = new TH1F("TimeBinStandalone","TimeBinStandalone",35,0,35);
289 fNbTimeBinStandalone->Sumw2();
290 //
291 fNbClusters = new TH1F("NbClusters","",35,0,35);
292 fNbClusters->Sumw2();
293 fNbClustersOffline = new TH1F("NbClustersOffline","",35,0,35);
294 fNbClustersOffline->Sumw2();
295 fNbClustersStandalone = new TH1F("NbClustersStandalone","",35,0,35);
296 fNbClustersStandalone->Sumw2();
297 //
1fb72fc9 298 fPHSM = new TProfile2D("PH2dSM","Nz10Nrphi10"
299 ,fNbTimeBins,-0.05,(Double_t)((fNbTimeBins-0.5)/10.0)
300 ,18,0,18);
301 fPHSM->SetYTitle("Det/pad groups");
302 fPHSM->SetXTitle("time [#mus]");
303 fPHSM->SetZTitle("<PH> [a.u.]");
304 fPHSM->SetStats(0);
305 //
306 fCHSM = new TH2I("CH2dSM","Nz10Nrphi10",50,0,300,18,0,18);
307 fCHSM->SetYTitle("Det/pad groups");
308 fCHSM->SetXTitle("charge deposit [a.u]");
309 fCHSM->SetZTitle("counts");
310 fCHSM->SetStats(0);
311 fCHSM->Sumw2();
312 //
313 fPHSum = new TProfile2D("PH2dSum","Nz100Nrphi100"
314 ,fNbTimeBins,-0.05,(Double_t)((fNbTimeBins-0.5)/10.0)
315 ,1,0,1);
1ee39b3a 316 fPHSum->SetYTitle("Det/pad groups");
317 fPHSum->SetXTitle("time [#mus]");
318 fPHSum->SetZTitle("<PH> [a.u.]");
319 fPHSum->SetStats(0);
320 //
1fb72fc9 321 fCHSum = new TH2I("CH2dSum","Nz100Nrphi100",50,0,300,1,0,1);
1ee39b3a 322 fCHSum->SetYTitle("Det/pad groups");
323 fCHSum->SetXTitle("charge deposit [a.u]");
324 fCHSum->SetZTitle("counts");
325 fCHSum->SetStats(0);
326 fCHSum->Sumw2();
327
328 // Add them
329 fContainer->Add(fNbTRDTrack);
330 fContainer->Add(fNbTRDTrackOffline);
331 fContainer->Add(fNbTRDTrackStandalone);
332 fContainer->Add(fNbTRDTracklet);
333 fContainer->Add(fNbTRDTrackletOffline);
334 fContainer->Add(fNbTRDTrackletStandalone);
335 fContainer->Add(fNbTimeBin);
336 fContainer->Add(fNbTimeBinOffline);
337 fContainer->Add(fNbTimeBinStandalone);
338 fContainer->Add(fNbClusters);
339 fContainer->Add(fNbClustersOffline);
340 fContainer->Add(fNbClustersStandalone);
1fb72fc9 341 fContainer->Add(fPHSM);
342 fContainer->Add(fCHSM);
1ee39b3a 343 fContainer->Add(fPHSum);
344 fContainer->Add(fCHSum);
345
346 }
068e2c00 347 // Post output data
348 PostData(1, fContainer);
1ee39b3a 349}
350
351//________________________________________________________________________
f8f46e4d 352void AliTRDcalibration::UserExec(Option_t *)
1ee39b3a 353{
354 //
355 // Execute function where the reference data are filled
356 //
357
358 if(!fTracks) return;
359
360 // In total
361 Int_t nbTrdTracks = 0;
362 // standalone
363 Int_t nbTrdTracksStandalone = 0;
364 // offline
365 Int_t nbTrdTracksOffline = 0;
366
367
368 //
369 // Loop on track in the event
370 //
371 //printf("Total of %d\n",fTracks->GetEntriesFast());
372 for(Int_t itrk=0; itrk < fTracks->GetEntriesFast(); itrk++){
373
374 //printf("itrk %d\n",itrk);
375
376 fTrackInfo = (AliTRDtrackInfo*)fTracks->UncheckedAt(itrk);
377 ftrdTrack = fTrackInfo->GetTrack();
378 if(!ftrdTrack) continue;
379
380 nbTrdTracks++;
381
382 fTRDCalibraFillHisto->UpdateHistogramsV1(ftrdTrack);
383
384 if(DebugLevel()) {
385
386 Bool_t standalonetracklet = kFALSE;
387 const AliTRDseedV1 *tracklet = 0x0;
388 //
389 // Loop on tracklet in the event
390 //
391 for(Int_t itr = 0; itr < 6; itr++){
392 //printf("itr %d\n",itr);
393 if(!(tracklet = ftrdTrack->GetTracklet(itr))) continue;
394 if(!tracklet->IsOK()) continue;
395 // standalone
396 if(tracklet->IsStandAlone()) standalonetracklet = kTRUE;
397 Int_t nbclusters = 0;
398 // For PH
399 Double_t phtb[AliTRDseedV1::kNtb];
400 memset(phtb, 0, AliTRDseedV1::kNtb*sizeof(Double_t));
401 // For CH
402 Double_t sum = 0.0;
403 // normalisation
404 Float_t normalisation = 6.67;
405 Int_t detector = 0;
1fb72fc9 406 Int_t sector = 0;
1ee39b3a 407 Int_t crossrow = 0;
1fb72fc9 408 // Check no shared clusters
409 for(int icc=AliTRDseedV1::kNtb; icc<AliTRDseedV1::kNclusters; icc++){
410 if((fcl = tracklet->GetClusters(icc))) crossrow = 1;
411 }
412 // Loop on clusters
1ee39b3a 413 for(int ic=0; ic<AliTRDseedV1::kNtb; ic++){
1ee39b3a 414 if(!(fcl = tracklet->GetClusters(ic))) continue;
415 nbclusters++;
416 Int_t time = fcl->GetPadTime();
417 Float_t ch = tracklet->GetdQdl(ic);
418 Float_t qcl = TMath::Abs(fcl->GetQ());
419 detector = fcl->GetDetector();
420 if((time>-1) && (time<fNbTimeBins)) phtb[time]=qcl;
421 sum += ch/normalisation;
422 fNbTimeBin->Fill(time);
423 if(tracklet->IsStandAlone()) fNbTimeBinStandalone->Fill(time);
424 else fNbTimeBinOffline->Fill(time);
425 }
1fb72fc9 426 sector = AliTRDgeometry::GetSector(detector);
1ee39b3a 427
428 fNbTRDTracklet->Fill(detector);
429 if(tracklet->IsStandAlone()) fNbTRDTrackletStandalone->Fill(detector);
430 else fNbTRDTrackletOffline->Fill(detector);
431
432 fNbClusters->Fill(nbclusters);
433 if(tracklet->IsStandAlone()) fNbClustersStandalone->Fill(nbclusters);
434 else fNbClustersOffline->Fill(nbclusters);
435
436 if((nbclusters > flow) && (nbclusters < fhigh)){
1fb72fc9 437 fCHSM->Fill(sum/20.0,sector+0.5);
438 fCHSum->Fill(sum/20.0,0.5);
1ee39b3a 439 for(int ic=0; ic<fNbTimeBins; ic++){
1fb72fc9 440 if(ffillZero) {
441 fPHSum->Fill((Double_t)(ic/10.0),0.5,(Double_t)phtb[ic]);
442 fPHSM->Fill((Double_t)(ic/10.0),sector+0.5,(Double_t)phtb[ic]);
443 }
1ee39b3a 444 else {
1fb72fc9 445 if(phtb[ic] > 0.0) {
446 fPHSum->Fill((Double_t)(ic/10.0),0.0,(Double_t)phtb[ic]);
447 fPHSM->Fill((Double_t)(ic/10.0),sector+0.5,(Double_t)phtb[ic]);
448 }
1ee39b3a 449 }
450 }
451 }
452 }
453
454 if(standalonetracklet) nbTrdTracksStandalone++;
455 else nbTrdTracksOffline++;
456
457 }
458
459 }
460
461 if(DebugLevel()) {
462
463 //Fill Histos
464 fNbTRDTrack->Fill(nbTrdTracks);
465 fNbTRDTrackStandalone->Fill(nbTrdTracksStandalone);
466 fNbTRDTrackOffline->Fill(nbTrdTracksOffline);
467
468 }
068e2c00 469}
470
1ee39b3a 471//________________________________________________________________________
472void AliTRDcalibration::Terminate(Option_t *)
473{
474 // Draw result to the screen
475 // Called once at the end of the query
476
477 //printf("terminate\n");
478
479 if(fTRDCalibraFillHisto) fTRDCalibraFillHisto->DestroyDebugStreamer();
480
481}
482//________________________________________________________
483Bool_t AliTRDcalibration::GetRefFigure(Int_t ifig)
484{
485 //
486 // Draw filled histos
487 //
488
489 gStyle->SetPalette(1);
490 gStyle->SetOptStat(1111);
491 gStyle->SetPadBorderMode(0);
492 gStyle->SetCanvasColor(10);
493 gStyle->SetPadLeftMargin(0.13);
494 gStyle->SetPadRightMargin(0.13);
495
496 if(!fContainer) return kFALSE;
497
498 switch(ifig){
499 case kNbTrack:{
500 TCanvas *c0 = new TCanvas("c0","c0",10,10,510,510);
501 TLegend *legNbTrack = new TLegend(.7, .7, .98, .98);
502 legNbTrack->SetBorderSize(1);
503 TH1F *h = 0x0;
504 TH1F *ho = 0x0;
505 TH1F *hs = 0x0;
506 if(!(h = (TH1F *)fContainer->FindObject("TRDTrack"))) break;
507 if(!(ho = (TH1F *)fContainer->FindObject("TRDTrackOffline"))) break;
508 if(!(hs = (TH1F *)fContainer->FindObject("TRDTrackStandalone"))) break;
509 c0->cd();
510 //gPad->SetLogy();
511 gPad->SetGridy();
512 gPad->SetGridx();
513 h->Draw();
514 ho->Draw("same");
515 hs->Draw("same");
516 legNbTrack->AddEntry(h, "all", "p");
517 legNbTrack->AddEntry(ho, "offline", "p");
518 legNbTrack->AddEntry(hs, "standalone", "p");
519 legNbTrack->Draw("same");
520 return kTRUE;
521 }
522 case kNbTracklet:{
523 TLegend *legNbTracklet = new TLegend(.7, .7, .98, .98);
524 legNbTracklet->SetBorderSize(1);
525 TH1F *h = 0x0;
526 TH1F *ho = 0x0;
527 TH1F *hs = 0x0;
528 if(!(h = (TH1F *)fContainer->FindObject("TRDTracklet"))) break;
529 if(!(ho = (TH1F *)fContainer->FindObject("TRDTrackletOffline"))) break;
530 if(!(hs = (TH1F *)fContainer->FindObject("TRDTrackletStandalone"))) break;
531 h->Draw();
532 ho->Draw("same");
533 hs->Draw("same");
534 legNbTracklet->AddEntry(h, "all", "p");
535 legNbTracklet->AddEntry(ho, "offline", "p");
536 legNbTracklet->AddEntry(hs, "standalone", "p");
537 legNbTracklet->Draw("same");
538 gPad->SetLogy();
539 gPad->SetGridy();
540 gPad->SetGridx();
541 return kTRUE;
542 }
543 case kNbTimeBin:{
544 TLegend *legNbTimeBin = new TLegend(.7, .7, .98, .98);
545 legNbTimeBin->SetBorderSize(1);
546 TH1F *h = 0x0;
547 TH1F *ho = 0x0;
548 TH1F *hs = 0x0;
549 if(!(h = (TH1F *)fContainer->FindObject("TimeBin"))) break;
550 if(!(ho = (TH1F *)fContainer->FindObject("TimeBinOffline"))) break;
551 if(!(hs = (TH1F *)fContainer->FindObject("TimeBinStandalone"))) break;
552 h->Draw();
553 ho->Draw("same");
554 hs->Draw("same");
555 legNbTimeBin->AddEntry(h, "all", "p");
556 legNbTimeBin->AddEntry(ho, "offline", "p");
557 legNbTimeBin->AddEntry(hs, "standalone", "p");
558 legNbTimeBin->Draw("same");
559 //gPad->SetLogy();
560 gPad->SetGridy();
561 gPad->SetGridx();
562 return kTRUE;
563 }
564 case kNbClusters:{
565 TLegend *legNbClusters = new TLegend(.7, .7, .98, .98);
566 legNbClusters->SetBorderSize(1);
567 TH1F *h = 0x0;
568 TH1F *ho = 0x0;
569 TH1F *hs = 0x0;
570 if(!(h = (TH1F *)fContainer->FindObject("NbClusters"))) break;
571 if(!(ho = (TH1F *)fContainer->FindObject("NbClustersOffline"))) break;
572 if(!(hs = (TH1F *)fContainer->FindObject("NbClustersStandalone"))) break;
573 h->Draw();
574 ho->Draw("same");
575 hs->Draw("same");
576 legNbClusters->AddEntry(h, "all", "p");
577 legNbClusters->AddEntry(ho, "offline", "p");
578 legNbClusters->AddEntry(hs, "standalone", "p");
579 legNbClusters->Draw("same");
580 gPad->SetLogy();
581 gPad->SetGridy();
582 gPad->SetGridx();
583 return kTRUE;
584 }
585 case kPHSum:{
586 TProfile2D *h = 0x0;
587 if(!(h = (TProfile2D *)fContainer->FindObject("PH2dSum"))) break;
588 TH1D *projh = h->ProjectionX("projh",1,1,"e");
589 projh->Draw();
590 gPad->SetGridy();
591 gPad->SetGridx();
592 return kTRUE;
593 }
594 case kCHSum:{
595 TH2I *h = 0x0;
596 if(!(h = (TH2I *)fContainer->FindObject("CH2dSum"))) break;
597 TH1D *projh = h->ProjectionX("projhh",1,1,"e");
598 projh->Draw();
599 gPad->SetGridy();
600 gPad->SetGridx();
601 return kTRUE;
602 }
603 case kPH2D:{
604 if(!fHisto2d) {
605 AliInfo("Histo was not filled!");
606 break;
607 }
608 TProfile2D *h = 0x0;
609 if(!(h = (TProfile2D *)fContainer->FindObject("PH2d"))) break;
610 h->Draw("lego");
611 return kTRUE;
612 }
613 case kCH2D:{
614 if(!fHisto2d) {
615 AliInfo("Histo was not filled!");
616 break;
617 }
618 TH2I *h = 0x0;
619 if(!(h = (TH2I *)fContainer->FindObject("CH2d"))) break;
620 h->Draw("lego");
621 return kTRUE;
622 }
623 case kPRF2D:{
624 if(!fHisto2d) {
625 AliInfo("Histo was not filled!");
626 break;
627 }
628 TProfile2D *h = 0x0;
629 if(!(h = (TProfile2D *)fContainer->FindObject("PRF2d"))) break;
630 h->Draw("lego");
631 return kTRUE;
632 }
633 case kPH2DVector:{
634 if(!fVector2d) {
635 AliInfo("vector was not filled!");
636 break;
637 }
638 AliTRDCalibraVector *v = 0x0;
639 TGraphErrors *vdet = 0x0;
640 if(!(v = (AliTRDCalibraVector *)fContainer->FindObject("AliTRDCalibraVector"))) break;
641 Int_t detectormax = -1;
642 Int_t groupmax = -1;
643 if(!v->FindTheMaxEntries(1,detectormax,groupmax)) break;
644 if(!(vdet = v->ConvertVectorPHTGraphErrors((Int_t)detectormax,groupmax,"plotPH2dVector"))) break;
645 Int_t nbeentries = 0;
646 TH1F *ko = v->CorrectTheError(vdet,nbeentries);
647 ko->Draw();
648 AliInfo(Form("There are %d entries in the detector %d and group %d",nbeentries,detectormax,groupmax));
649 return kTRUE;
650 }
651case kCH2DVector:{
652 if(!fVector2d) {
653 AliInfo("vector was not filled!");
654 break;
655 }
656 AliTRDCalibraVector *v = 0x0;
657 TH1F *vdet = 0x0;
658 if(!(v = (AliTRDCalibraVector *)fContainer->FindObject("AliTRDCalibraVector"))) break;
659 Int_t detectormax = -1;
660 Int_t groupmax = -1;
661 if(!v->FindTheMaxEntries(0,detectormax,groupmax)) break;
662 if(!(vdet = v->ConvertVectorCHHisto((Int_t)detectormax,groupmax,"plotCH2dVector"))) break;
663 vdet->Draw();
664 AliInfo(Form("The detectormax and groupmax are %d and %d",detectormax,groupmax));
665 return kTRUE;
666 }
667 case kPRF2DVector:{
668 if(!fVector2d) {
669 AliInfo("vector was not filled!");
670 break;
671 }
672 AliTRDCalibraVector *v = 0x0;
673 TGraphErrors *vdet = 0x0;
674 if(!(v = (AliTRDCalibraVector *)fContainer->FindObject("AliTRDCalibraVector"))) break;
675 Int_t detectormax = -1;
676 Int_t groupmax = -1;
677 Int_t nbeentries = 0;
678 if(!v->FindTheMaxEntries(2,detectormax,groupmax)) break;
679 if(!(vdet = v->ConvertVectorPRFTGraphErrors((Int_t)detectormax,groupmax,"plotPRF2dVector"))) break;
680 TH1F *ko = v->CorrectTheError(vdet,nbeentries);
681 ko->Draw();
682 AliInfo(Form("The detectormax and groupmax are %d and %d",detectormax,groupmax));
683 return kTRUE;
684 }
685 case kLinearFitter:{
686 if(!fVdriftLinear) {
687 AliInfo("vdrift linear was not filled!");
688 break;
689 }
690 AliTRDCalibraVdriftLinearFit *h = 0x0;
691 TH2S *hdetector = 0x0;
692 if(!(h = (AliTRDCalibraVdriftLinearFit *)fContainer->FindObject("AliTRDCalibraVdriftLinearFit"))) break;
693 Double_t entries[540];
694 for(Int_t k = 0; k < 540; k++){
695 entries[k] = 0.0;
696 hdetector = 0x0;
697 if(!(hdetector = (TH2S *)h->GetLinearFitterHisto(k,kFALSE))) continue;
698 entries[k] = hdetector->GetEntries();
699 }
700 Double_t max = -10.0;
701 Double_t detectormax = -1;
702 for(Int_t k = 0; k < 540; k++){
703 if(entries[k] > max) {
704 max = entries[k];
705 detectormax = k;
706 }
707 }
708 hdetector = 0x0;
709 if((TMath::Abs(max) <= 0.001) || (detectormax <0.0) || (detectormax >=540.0)) break;
710 if(!(hdetector = (TH2S *)h->GetLinearFitterHisto((Int_t)detectormax,kFALSE))) break;
ca50a37e 711 AliInfo(Form("The detector with the maximum of entries is %f",detectormax));
1ee39b3a 712 hdetector->Draw();
713 return kTRUE;
714 }
715 case kGainFactor:{
716 if(!fPostProcess){
717 if(!PostProcess()) break;
718 }
719 TGraph *fgain = (TGraph *) fGraph->At(0);
720 if(!fgain) break;
721 fgain->Draw("ALP");
722 return kTRUE;
723 }
724 case kVdriftT0Factor:{
725 if(!fPostProcess){
726 if(!PostProcess()) break;
727 }
728 TCanvas *c = new TCanvas("c","c",10,10,510,510);
729 c->Divide(2,1);
730 TGraph *fvd = (TGraph *) fGraph->At(1);
731 if(fvd){
732 c->cd(1);
733 fvd->Draw("ALP");
734 }
735 TGraph *ft0 = (TGraph *) fGraph->At(2);
736 if(ft0){
737 c->cd(2);
738 ft0->Draw("ALP");
739 }
740 return kTRUE;
741 }
742 case kVdriftLorentzAngleFactor:{
743 if(!fVdriftLinear) {
744 AliInfo("vdrift linear was not filled!");
745 break;
746 }
747 if(!fPostProcess){
748 if(!PostProcess()) break;
749 }
750 TCanvas *c = new TCanvas("c","c",10,10,510,510);
751 c->Divide(2,1);
752 TGraph *fvdl = (TGraph *) fGraph->At(3);
753 if(fvdl){
754 c->cd(1);
755 fvdl->Draw("ALP");
756 }
757 TGraph *flal = (TGraph *) fGraph->At(4);
758 if(flal){
759 c->cd(2);
760 flal->Draw("ALP");
761 }
762 return kTRUE;
763 }
764 case kPRFFactor:{
765 if(!fPostProcess){
766 if(!PostProcess()) break;
767 }
768 TGraph *fprf = (TGraph *) fGraph->At(5);
769 if(!fprf) break;
770 fprf->Draw("ALP");
771 return kTRUE;
772 }
773 }
774
775 return kFALSE;
776
777}
778//________________________________________________________________________
779Bool_t AliTRDcalibration::PostProcess()
780{
781 //
782 // Fit the filled histos
1fb72fc9 783 // Put the calibration object in fArrayCalib
784 // 0 and 1 AliTRDCalDet and AliTRDCalPad gain
785 // 2 and 3 AliTRDCalDet and AliTRDCalPad vdrift PH
786 // 4 and 5 AliTRDCalDet and AliTRDCalPad timeoffset PH
787 // 6 AliTRDCalPad PRF
788 // 7 and 8 AliTRDCalDet and AliTRDCalPad vdrift second
789 // 9 and 10 AliTRDCalDet and AliTRDCalPad lorentz angle second
1ee39b3a 790 //
791
1fb72fc9 792 if(!fArrayCalib){
793 fArrayCalib = new TObjArray(11);
794 fArrayCalib->SetOwner();
795 }
796 else {
797 delete fArrayCalib;
798 PostProcess();
799 }
800
1ee39b3a 801 if(!fGraph){
802 fGraph = new TObjArray(6);
803 fGraph->SetOwner();
804 }
805 else {
806 delete fGraph;
807 PostProcess();
808 }
809
810 Bool_t storage[3] = {kFALSE,kFALSE,kFALSE};
811
1ee39b3a 812 // Objects for fitting
813 AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
814 calibra->SetDebugLevel(2); // 0 rien, 1 fitvoir, 2 debug files, 3 one detector
815
816 // Take the stuff
817 if (!fContainer) {
818 Printf("ERROR: list not available");
819 return kFALSE;
820 }
821
822 if(fHisto2d && fVector2d) AliInfo("We will only look at histos. Set fHisto2d off if you don't want");
823 AliTRDCalibraVector *calibraVector = 0x0;
824 if(fVector2d) calibraVector = (AliTRDCalibraVector *) fContainer->FindObject("CalibraVector");
825 //
826 // GAIN TH2I
827 //
828 Bool_t pass = kFALSE;
829 AliTRDCalibraVector *vvect = 0x0;
830 if(fHisto2d) {
831 TH2I *histogain = (TH2I *) fContainer->FindObject("CH2d");
832 if(histogain) {
833 histogain->SetDirectory(0);
834 calibra->SetMinEntries(20);
835 if(fCompressPerDetector){
836 if(AddStatsPerDetector(histogain)) pass = calibra->AnalyseCH(fCHSum);
837 }
838 else pass = calibra->AnalyseCH(histogain);
839 }
840 }
841 else {
842 if(fVector2d && calibraVector) {
843 calibra->SetMinEntries(20);
844 if(fCompressPerDetector){
845 if(!(vvect = calibraVector->AddStatsPerDetectorCH())) return kFALSE;
846 pass = calibra->AnalyseCH(vvect);
847 }
848 else pass = calibra->AnalyseCH(calibraVector);
849 }
850 }
851
852 if(pass)
853 {
854 Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(0))
855 + 6* 18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(0));
856 Int_t nbfit = calibra->GetNumberFit(); //Number of fits
857 Int_t nbE = calibra->GetNumberEnt(); //Number of detector mit entries
858 // enough statistics
859 if ((nbtg > 0) &&
860 (nbfit >= 0.001*nbE))
861 {
862 // create the cal objects
863 calibra->PutMeanValueOtherVectorFit(1,kTRUE);
864 TObjArray object = calibra->GetVectorFit();
865 AliTRDCalDet *objgaindet = calibra->CreateDetObjectGain(&object);
866 TObject *objgainpad = calibra->CreatePadObjectGain();
867 // store
1fb72fc9 868 fArrayCalib->AddAt(objgaindet,0);
869 fArrayCalib->AddAt(objgainpad,1);
1ee39b3a 870 storage[0] = kTRUE;
871 // Make graph
872 TGraph *graph = 0x0;
873 if(FillGraphIndex(&object,graph)){
874 fGraph->AddAt(graph,0);
875 }
876 }//if(enough statistics?)
877 calibra->ResetVectorFit();
878 }
879 else return kFALSE;
880
881 //
882 // VDRIFT average pulse height
883 //
884 pass = kFALSE;
885 if(fHisto2d) {
886 TProfile2D *histodriftvelocity = (TProfile2D *) fContainer->FindObject("PH2d");
887 if(histodriftvelocity) {
888 histodriftvelocity->SetDirectory(0);
889 calibra->SetMinEntries(20*20);
890 if(fCompressPerDetector){
891 if(AddStatsPerDetector(histodriftvelocity,1)) {
892 pass = calibra->AnalysePH(fDetSumVector);
893 }
894 }
895 else pass = calibra->AnalysePH(histodriftvelocity);
896 }
897 }
898 else {
899 if(fVector2d && calibraVector) {
900 calibra->SetMinEntries(20*20);
901 if(fCompressPerDetector){
902 if(!(vvect = calibraVector->AddStatsPerDetectorPH())) return kFALSE;
903 pass = calibra->AnalysePH(vvect);
904 }
905 else pass = calibra->AnalysePH(calibraVector);
906 }
907 }
908
909 if(pass) {
910 Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(1))
911 + 6* 18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(1));
912 Int_t nbfit = calibra->GetNumberFit();
913 Int_t nbE = calibra->GetNumberEnt();
914 // enough statistics
915 if ((nbtg > 0) &&
916 (nbfit >= 0.001*nbE))
917 {
918 // create the cal objects
919 calibra->PutMeanValueOtherVectorFit(1,kTRUE);
920 calibra->PutMeanValueOtherVectorFit2(1,kTRUE);
921 TObjArray object = calibra->GetVectorFit();
922 AliTRDCalDet *objdriftvelocitydet = calibra->CreateDetObjectVdrift(&object,kTRUE);
923 TObject *objdriftvelocitypad = calibra->CreatePadObjectVdrift();
924 TObjArray objectt = calibra->GetVectorFit2();
925 AliTRDCalDet *objtime0det = calibra->CreateDetObjectT0(&object,kTRUE);
926 TObject *objtime0pad = calibra->CreatePadObjectT0();
927 // store
1fb72fc9 928 fArrayCalib->AddAt(objdriftvelocitydet,2);
929 fArrayCalib->AddAt(objdriftvelocitypad,3);
1ee39b3a 930 //
1fb72fc9 931 fArrayCalib->AddAt(objtime0det,4);
932 fArrayCalib->AddAt(objtime0pad,5);
1ee39b3a 933 // Make graph
934 TGraph *graph = 0x0;
935 if(FillGraphIndex(&object,graph)){
936 fGraph->AddAt(graph,1);
937 }
938 TGraph *graphh = 0x0;
939 if(FillGraphIndex(&objectt,graphh)){
940 fGraph->AddAt(graphh,2);
941 }
942 }//if(enough statistics)
943 calibra->ResetVectorFit();
944 }
945 else return kFALSE;
946
947 //
948 // PRF
949 //
950 pass = kFALSE;
951 if(fHisto2d) {
952 TProfile2D *histoprf = (TProfile2D *) fContainer->FindObject("PRF2d");
953 if (histoprf) {
954 histoprf->SetDirectory(0);
955 calibra->SetMinEntries(600);
956 if(fCompressPerDetector){
957 if(AddStatsPerDetector(histoprf,2)) pass = calibra->AnalysePRFMarianFit(fDetSumVector);
958 }
959 else pass = calibra->AnalysePRFMarianFit(histoprf);
960 }
961 }
962 else {
963 if(fVector2d && calibraVector) {
964 calibra->SetMinEntries(600);
965 if(fCompressPerDetector){
966 if(!(vvect =calibraVector->AddStatsPerDetectorPRF())) return kFALSE;
967 pass = calibra->AnalysePRFMarianFit(vvect);
968 }
969 else pass = calibra->AnalysePRFMarianFit(calibraVector);
970 }
971 }
972
973 if(pass){
974 Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(2))
975 + 6* 18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(2));
976 Int_t nbfit = calibra->GetNumberFit();
977 Int_t nbE = calibra->GetNumberEnt();
978 // enough statistics
979 if ((nbtg > 0) &&
980 (nbfit >= 0.001*nbE)) {
981 TObjArray object = calibra->GetVectorFit();
982 TObject *objPRFpad = calibra->CreatePadObjectPRF(&object);
983 // store
1fb72fc9 984 fArrayCalib->AddAt(objPRFpad,6);
1ee39b3a 985 // Make graph
986 TGraph *graph = 0x0;
987 if(FillGraphIndex(&object,graph)){
988 fGraph->AddAt(graph,5);
989 }
990 }
991 calibra->ResetVectorFit();
992 }
993 else return kFALSE;
994
995 //
996 // VDRIFT linear fit
997 //
998 AliTRDCalibraVdriftLinearFit *vlinearfit = (AliTRDCalibraVdriftLinearFit *) fContainer->FindObject("LinearVdriftFit");
999 if (vlinearfit) {
1000 calibra->SetMinEntries(20*20);
1001 if(calibra->AnalyseLinearFitters(vlinearfit)) {
1002
1003 Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(2))
1004 + 6* 18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(2));
1005 Int_t nbfit = calibra->GetNumberFit();
1006 Int_t nbE = calibra->GetNumberEnt();
1007 // enough statistics
1008 if ((nbtg > 0) &&
1009 (nbfit >= 0.001*nbE))
1010 {
1011 // create the cal objects
1012 calibra->PutMeanValueOtherVectorFit(1,kTRUE);
1013 calibra->PutMeanValueOtherVectorFit2(1,kTRUE);
1014 TObjArray object = calibra->GetVectorFit();
1015 AliTRDCalDet *objdriftvelocitydet = calibra->CreateDetObjectVdrift(&object,kTRUE);
1016 TObject *objdriftvelocitypad = calibra->CreatePadObjectVdrift();
1017 TObjArray objectt = calibra->GetVectorFit2();
1018 AliTRDCalDet *objtime0det = calibra->CreateDetObjectT0(&object,kTRUE);
1019 TObject *objtime0pad = calibra->CreatePadObjectT0();
1020 // store dummy
1fb72fc9 1021 fArrayCalib->AddAt(objdriftvelocitydet,7);
1022 fArrayCalib->AddAt(objdriftvelocitypad,8);
1ee39b3a 1023 //
1fb72fc9 1024 fArrayCalib->AddAt(objtime0det,9);
1025 fArrayCalib->AddAt(objtime0pad,10);
1ee39b3a 1026 // Make graph
1027 TGraph *graph = 0x0;
1028 if(FillGraphIndex(&object,graph)){
1029 fGraph->AddAt(graph,3);
1030 }
1031 TGraph *graphh = 0x0;
1032 if(FillGraphIndex(&objectt,graphh)){
1033 fGraph->AddAt(graphh,4);
1034 }
1035 }//if(enough statistics)
1036 }// if fit
1037 calibra->ResetVectorFit();
1038 }
1039 else return kFALSE;
1040
1041 fPostProcess = kTRUE;
1042
1043 return kTRUE;
1044
1045}
1046
1047//________________________________________________________________________
1048Bool_t AliTRDcalibration::FillGraphIndex(const TObjArray *vectora,TGraph *graph) const
1049{
1050 //
1051 // Fill one value (the first one) per detector
1052 //
1053
1054 Int_t loop = (Int_t) vectora->GetEntriesFast();
1055 if(loop != 540) {
1056 AliInfo("The Vector Fit is not complete!");
1057 return kFALSE;
1058 }
1059
1060 Double_t x[540];
1061 Double_t y[540];
1062 for (Int_t k = 0; k < loop; k++) {
1063 if(!vectora->At(k)){
1064 x[k] = -1.0;
1065 y[k] = -1.0;
1066 continue;
1067 }
1068 x[k] = ((AliTRDCalibraFit::AliTRDFitInfo *) vectora->At(k))->GetDetector();
1069 y[k] = ((Float_t *)((AliTRDCalibraFit::AliTRDFitInfo *) vectora->At(k))->GetCoef())[0];
1070 }
1071
1072 if(!graph) graph = new TGraph(540,&x[0],&y[0]);
1073 else{
1074 graph->~TGraph();
1075 new(graph) TGraph(540,&x[0],&y[0]);
1076 }
1077
1078 return kTRUE;
1079
1080}
1081//________________________________________________________________________
1082Bool_t AliTRDcalibration::AddStatsPerDetector(const TH2I *ch)
1083{
1084 //
1085 // Add statistic per detector
1086 //
1087
1088 AliTRDCalibraMode calibMode = AliTRDCalibraMode();
1089 const char *name = ch->GetTitle();
1090 if(!SetNzFromTObject(name,0,&calibMode)) return 0x0;
1091 if(!SetNrphiFromTObject(name,0,&calibMode)) return 0x0;
1092 if(((calibMode.GetNz(0) == 100) && (calibMode.GetNrphi(0) == 100)) || ((calibMode.GetNz(0) == 10) && (calibMode.GetNrphi(0) == 10))) return kFALSE;
1093
1094 Int_t nybins = ch->GetNbinsY();// groups number
1095 Int_t nxbins = ch->GetNbinsX();// number of bins X
1096 TAxis *xaxis = ch->GetXaxis();
1097 Double_t lowedge = xaxis->GetBinLowEdge(1);
1098 Double_t upedge = xaxis->GetBinUpEdge(nxbins);
1099
1100 // number per chamber 2
1101 calibMode.ModePadCalibration(2,0);
1102 calibMode.ModePadFragmentation(0,2,0,0);
1103 calibMode.SetDetChamb2(0);
1104 Int_t perChamber2 = (Int_t) calibMode.GetDetChamb2(0);
1105
1106 // number per other chamber
1107 calibMode.ModePadCalibration(0,0);
1108 calibMode.ModePadFragmentation(0,0,0,0);
1109 calibMode.SetDetChamb0(0);
1110 Int_t perChamber0 = (Int_t) calibMode.GetDetChamb0(0);
1111
1112 if(nybins != (6*18*perChamber2+6*4*18*perChamber0)) return kFALSE;
1113
1114 // Create Histo
1115 TString nname((const char *)ch->GetName());
1116 nname += "PerDetector";
1117 TString title("Nz");
1118 title += 0;
1119 title += "Nrphi";
1120 title += 0;
1121 if(!fCHSum) fCHSum = new TH2I((const char *)nname,(const char *)title
1122 ,nxbins,lowedge,upedge,540,0,540);
1123 else{
1124 fCHSum->~TH2I();
1125 new(fCHSum) TH2I((const Char_t *) nname,(const char *)title
1126 ,nxbins,lowedge,upedge,540,0,540);
1127 }
1128 fCHSum->SetYTitle("Detector number");
1129 fCHSum->SetXTitle("charge deposit [a.u]");
1130 fCHSum->SetZTitle("counts");
1131 fCHSum->SetStats(0);
1132 fCHSum->Sumw2();
1133
1134 Int_t counter = 0;
1135
1136 for(Int_t det = 0; det < 540; det++){
1137
1138 Int_t numberofgroup = 0;
1139 if(AliTRDgeometry::GetStack(det) == 2) numberofgroup = perChamber2;
1140 else numberofgroup = perChamber0;
1141 TH1I *projch = (TH1I *) ch->ProjectionX("projch",counter+1,counter+numberofgroup,(Option_t *)"e");
1142 projch->SetDirectory(0);
1143
1144 for(Int_t nx = 0; nx <= nxbins; nx++) {
1145 fCHSum->SetBinContent(nx,det+1,projch->GetBinContent(nx));
1146 fCHSum->SetBinError(nx,det+1,projch->GetBinError(nx));
1147 }
1148
1149 counter += numberofgroup;
1150
1151 delete projch;
1152
1153 }
1154
1155 return kTRUE;
1156
1157}
1158//_____________________________________________________________________________________________________________________
1159Bool_t AliTRDcalibration::AddStatsPerDetector(const TProfile2D *ph,Int_t i)
1160{
1161 //
1162 // Add statistic per detector
1163 //
1164
1165 AliTRDCalibraMode calibMode = AliTRDCalibraMode();
1166 const char *name = ph->GetTitle();
1167 //printf("name %s\n",name);
1168 if(!SetNzFromTObject(name,0,&calibMode)) return kFALSE;
1169 if(!SetNrphiFromTObject(name,0,&calibMode)) return kFALSE;
1170 if(((calibMode.GetNz(0) == 100) && (calibMode.GetNrphi(0) == 100)) || ((calibMode.GetNz(0) == 10) && (calibMode.GetNrphi(0) == 10))) return kFALSE;
1171 //printf("Found mode Mz %d, Nrphi %d\n",calibMode.GetNz(0),calibMode.GetNrphi(0));
1172
1173
1174 Int_t nybins = ph->GetNbinsY();// groups number
1175 Int_t nxbins = ph->GetNbinsX();// number of bins X
1176 TAxis *xaxis = ph->GetXaxis();
1177 Double_t lowedge = xaxis->GetBinLowEdge(1);
1178 Double_t upedge = xaxis->GetBinUpEdge(nxbins);
1179
1180 // number per chamber 2
1181 calibMode.ModePadCalibration(2,0);
1182 calibMode.ModePadFragmentation(0,2,0,0);
1183 calibMode.SetDetChamb2(0);
1184 Int_t perChamber2 = (Int_t) calibMode.GetDetChamb2(0);
1185
1186 // number per other chamber
1187 calibMode.ModePadCalibration(0,0);
1188 calibMode.ModePadFragmentation(0,0,0,0);
1189 calibMode.SetDetChamb0(0);
1190 Int_t perChamber0 = (Int_t) calibMode.GetDetChamb0(0);
1191
1192 if(nybins != (6*18*perChamber2+6*4*18*perChamber0)) return kFALSE;
1193
1194 // Create calvector
1195 TString nbname((const char *)ph->GetName());
1196 nbname += "PerDetectorVector";
1197 if(!fDetSumVector) fDetSumVector = new AliTRDCalibraVector();
1198 else{
1199 fDetSumVector->~AliTRDCalibraVector();
1200 new(fDetSumVector) AliTRDCalibraVector();
1201 }
1202 if(i==1){
1203 fDetSumVector->SetTimeMax(nxbins);
1204 }
1205 if(i==2){
1206 fDetSumVector->SetNumberBinPRF(nxbins);
1207 fDetSumVector->SetPRFRange(TMath::Abs(lowedge));
1208 }
1209 fDetSumVector->SetDetCha0(i,1);
1210 fDetSumVector->SetDetCha2(i,1);
1211 fDetSumVector->SetNzNrphi(i,0,0);
1212 if(i==2) {
1213 Int_t nbg = GetNumberOfGroupsPRF((const char *)name);
1214 fDetSumVector->SetNbGroupPRF(nbg);
1215 }
1216
1217 // Create Histo
1218 TString nname((const char *)ph->GetName());
1219 nname += "PerDetector";
1220 TString title("Nz");
1221 title += 0;
1222 title += "Nrphi";
1223 title += 0;
1224 if(!fDetSum) fDetSum = new TH2D((const char *)nname,(const Char_t *) title
1225 ,nxbins,lowedge,upedge,540,0,540);
1226 else{
1227 fDetSum->~TH2D();
1228 new(fDetSum) TH2D((const Char_t *) nname,(const Char_t *) title
1229 ,nxbins,lowedge,upedge,540,0,540);
1230 }
1231 fDetSum->SetYTitle("Detector number");
1232 fDetSum->SetXTitle(xaxis->GetTitle());
1233 fDetSum->SetStats(0);
1234
1235 Int_t counter = 0;
1236
1237 for(Int_t det = 0; det < 540; det++){
1238
1239 Int_t numberofgroup = 0;
1240 if(AliTRDgeometry::GetStack(det) == 2) numberofgroup = perChamber2;
1241 else numberofgroup = perChamber0;
1242
1243 for(Int_t nx = 1; nx <= nxbins; nx++) {
1244
1245 Double_t entries = 0.0;
1246 Double_t sumw2 = 0.0;
1247 Double_t sumw = 0.0;
1248
1249 for(Int_t k = counter+1; k <= (counter+numberofgroup); k++){
1250 Int_t binnumber = ph->GetBin(nx,k);
1251 entries += ph->GetBinEntries(binnumber);
1252 sumw2 += (ph->GetBinError(binnumber)*ph->GetBinError(binnumber)+ph->GetBinContent(binnumber)*ph->GetBinContent(binnumber))*ph->GetBinEntries(binnumber);
1253 sumw += ph->GetBinContent(binnumber)*ph->GetBinEntries(binnumber);
1254 }
1255
1256 Double_t mean = 0.0;
1257 if(entries > 0.0) mean = sumw/entries;
1258 Double_t squaremean = 0.0;
1259 if(entries > 0.0) squaremean = sumw2/entries;
1260 Double_t errorf = squaremean - mean*mean;
1261 Double_t error = 0.0;
1262 if(entries > 0.0) error = TMath::Sqrt(TMath::Abs(errorf)/entries);
1263
1264 fDetSum->SetBinContent(nx,det+1,mean);
1265 fDetSum->SetBinError(nx,det+1,error);
1266
1267 if(i==1) fDetSumVector->FillVectorPH(det,0,nx-1,(Int_t)entries,(Float_t)mean,(Float_t)squaremean);
1268 if(i==2) fDetSumVector->FillVectorPRF(det,0,nx-1,(Int_t)entries,(Float_t)mean,(Float_t)squaremean);
1269
1270 }
1271
1272 counter += numberofgroup;
1273
1274 }
1275
1276 return kTRUE;
1277
1278
1279}
1280//_____________________________________________________________________________
1281Bool_t AliTRDcalibration::SetNrphiFromTObject(const char *name, Int_t i, AliTRDCalibraMode *calibMode) const
1282{
1283 //
1284 // Set the granularity from object
1285 //
1286
1287 const Char_t *patternrphi0 = "Nrphi0";
1288 const Char_t *patternrphi1 = "Nrphi1";
1289 const Char_t *patternrphi2 = "Nrphi2";
1290 const Char_t *patternrphi3 = "Nrphi3";
1291 const Char_t *patternrphi4 = "Nrphi4";
1292 const Char_t *patternrphi5 = "Nrphi5";
1293 const Char_t *patternrphi6 = "Nrphi6";
1294
1295
1296 const Char_t *patternrphi10 = "Nrphi10";
1297 const Char_t *patternrphi100 = "Nrphi100";
1298 const Char_t *patternz10 = "Nz10";
1299 const Char_t *patternz100 = "Nz100";
1300
1301 // Nrphi mode
1302 if ((strstr(name,patternrphi100)) && (strstr(name,patternz100))) {
1303 calibMode->SetAllTogether(i);
1304 return kTRUE;
1305 }
1306 if ((strstr(name,patternrphi10)) && (strstr(name,patternz10))) {
1307 calibMode->SetPerSuperModule(i);
1308 return kTRUE;
1309 }
1310
1311 if (strstr(name,patternrphi0)) {
1312 calibMode->SetNrphi(i ,0);
1313 return kTRUE;
1314 }
1315 if (strstr(name,patternrphi1)) {
1316 calibMode->SetNrphi(i, 1);
1317 return kTRUE;
1318 }
1319 if (strstr(name,patternrphi2)) {
1320 calibMode->SetNrphi(i, 2);
1321 return kTRUE;
1322 }
1323 if (strstr(name,patternrphi3)) {
1324 calibMode->SetNrphi(i, 3);
1325 return kTRUE;
1326 }
1327 if (strstr(name,patternrphi4)) {
1328 calibMode->SetNrphi(i, 4);
1329 return kTRUE;
1330 }
1331 if (strstr(name,patternrphi5)) {
1332 calibMode->SetNrphi(i, 5);
1333 return kTRUE;
1334 }
1335 if (strstr(name,patternrphi6)) {
1336 calibMode->SetNrphi(i, 6);
1337 return kTRUE;
1338 }
1339
1340 calibMode->SetNrphi(i ,0);
1341 return kFALSE;
1342
1343}
1344//_____________________________________________________________________________
1345Bool_t AliTRDcalibration::SetNzFromTObject(const char *name, Int_t i, AliTRDCalibraMode *calibMode) const
1346{
1347 //
1348 // Set fNz[i] of the AliTRDCalibraFit::Instance()
1349 // corresponding to the given TObject
1350 //
1351
1352 // Some patterns
1353 const Char_t *patternz0 = "Nz0";
1354 const Char_t *patternz1 = "Nz1";
1355 const Char_t *patternz2 = "Nz2";
1356 const Char_t *patternz3 = "Nz3";
1357 const Char_t *patternz4 = "Nz4";
1358
1359 const Char_t *patternrphi10 = "Nrphi10";
1360 const Char_t *patternrphi100 = "Nrphi100";
1361 const Char_t *patternz10 = "Nz10";
1362 const Char_t *patternz100 = "Nz100";
1363
1364 if ((strstr(name,patternrphi100)) && (strstr(name,patternz100))) {
1365 calibMode->SetAllTogether(i);
1366 return kTRUE;
1367 }
1368 if ((strstr(name,patternrphi10)) && (strstr(name,patternz10))) {
1369 calibMode->SetPerSuperModule(i);
1370 return kTRUE;
1371 }
1372 if (strstr(name,patternz0)) {
1373 calibMode->SetNz(i, 0);
1374 return kTRUE;
1375 }
1376 if (strstr(name,patternz1)) {
1377 calibMode->SetNz(i ,1);
1378 return kTRUE;
1379 }
1380 if (strstr(name,patternz2)) {
1381 calibMode->SetNz(i ,2);
1382 return kTRUE;
1383 }
1384 if (strstr(name,patternz3)) {
1385 calibMode->SetNz(i ,3);
1386 return kTRUE;
1387 }
1388 if (strstr(name,patternz4)) {
1389 calibMode->SetNz(i ,4);
1390 return kTRUE;
1391 }
1392
1393 calibMode->SetNz(i ,0);
1394 return kFALSE;
1395}
1396//____________________________________________________________________________________________________
1397Int_t AliTRDcalibration::GetNumberOfGroupsPRF(const char* nametitle) const
1398{
1399 //
1400 // Get numberofgroupsprf
1401 //
1402
1403 // Some patterns
1404 const Char_t *pattern0 = "Ngp0";
1405 const Char_t *pattern1 = "Ngp1";
1406 const Char_t *pattern2 = "Ngp2";
1407 const Char_t *pattern3 = "Ngp3";
1408 const Char_t *pattern4 = "Ngp4";
1409 const Char_t *pattern5 = "Ngp5";
1410 const Char_t *pattern6 = "Ngp6";
1411
1412 // Nrphi mode
1413 if (strstr(nametitle,pattern0)) {
1414 return 0;
1415 }
1416 if (strstr(nametitle,pattern1)) {
1417 return 1;
1418 }
1419 if (strstr(nametitle,pattern2)) {
1420 return 2;
1421 }
1422 if (strstr(nametitle,pattern3)) {
1423 return 3;
1424 }
1425 if (strstr(nametitle,pattern4)) {
1426 return 4;
1427 }
1428 if (strstr(nametitle,pattern5)) {
1429 return 5;
1430 }
1431 if (strstr(nametitle,pattern6)){
1432 return 6;
1433 }
1434 else return -1;
1ee39b3a 1435}