]> git.uio.no Git - u/mrichter/AliRoot.git/blame - TRD/AliTRDCalibTask.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
- reverting the unnecessary increment of the class version
[u/mrichter/AliRoot.git] / TRD / AliTRDCalibTask.cxx
CommitLineData
98937691 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// AliTRDCalibTask
20//
21// Offline TRD calibration task
22//
23// Author:
24// R. Bailhache (R.Bailhache@gsi.de)
25//
26//////////////////////////////////////////////////////////////////////////////////////
27
01239968 28#include <iostream>
29using namespace std;
98937691 30#include "Riostream.h"
31#include "TChain.h"
32#include "TTree.h"
33#include "TFile.h"
34#include "TProfile2D.h"
35#include "TH2I.h"
36#include "TH1F.h"
37#include "TH2F.h"
38#include "TList.h"
39#include "TMath.h"
40#include "TObject.h"
41#include "TObjArray.h"
42#include "TString.h"
43#include "TCanvas.h"
44#include "TLegend.h"
45#include "TStyle.h"
46#include "TLine.h"
57185ead 47#include "TIterator.h"
98937691 48
49#include "AliAnalysisTask.h"
50#include "AliAnalysisManager.h"
51
52#include "AliESDVertex.h"
53#include "AliESDEvent.h"
54#include "AliESDfriend.h"
55#include "AliESDInputHandler.h"
56#include "AliESDtrack.h"
57#include "AliESDfriendTrack.h"
58#include "AliTRDtrackV1.h"
59#include "AliTRDseedV1.h"
60#include "AliTRDcluster.h"
61#include "AliTRDgeometry.h"
62#include "AliESDtrackCuts.h"
63#include "AliESDVertex.h"
64#include "AliTRDCalDet.h"
65
57185ead 66#include "AliTRDCalibraVector.h"
98937691 67#include "AliTRDCalibraFillHisto.h"
68#include "AliTRDCalibraVdriftLinearFit.h"
69
70#include "AliTRDcalibDB.h"
a2a4ec8e 71#include "AliCDBId.h"
72#include "AliLog.h"
98937691 73
74
75#include "AliTRDCalibTask.h"
76
77
78ClassImp(AliTRDCalibTask)
79
80//________________________________________________________________________
81 AliTRDCalibTask::AliTRDCalibTask(const char *name)
01239968 82 : AliAnalysisTaskSE(name), fESD(0),
98937691 83 fESDfriend(0),
84 fkEsdTrack(0),
85 fFriendTrack(0),
86 fCalibObject(0),
87 fTrdTrack(0),
88 fCl(0),
89 fListHist(0),
90 fTRDCalibraFillHisto(0),
91 fNEvents(0),
92 fNbTRDTrack(0),
93 fNbTRDTrackOffline(0),
94 fNbTRDTrackStandalone(0),
95 fNbTPCTRDtrack(0),
96 fNbTimeBin(0),
97 fNbTimeBinOffline(0),
98 fNbTimeBinStandalone(0),
99 fNbClusters(0),
100 fNbClustersOffline(0),
101 fNbClustersStandalone(0),
102 fNbTracklets(0),
103 fNbTrackletsOffline(0),
104 fNbTrackletsStandalone(0),
105 fAbsoluteGain(0),
106 fCH2dSum(0),
107 fPH2dSum(0),
108 fCH2dSM(0),
109 fPH2dSM(0),
110 fHisto2d(kTRUE),
111 fVector2d(kFALSE),
112 fVdriftLinear(kTRUE),
113 fNbTimeBins(0),
114 fSelectedTrigger(new TObjArray()),
115 fRejected(kTRUE),
116 fEsdTrackCuts(0),
117 fRequirePrimaryVertex(kFALSE),
118 fVtxTPC(kFALSE),
119 fVtxSPD(kFALSE),
120 fMinNbContributors(0),
121 fRangePrimaryVertexZ(9999999.0),
122 fLow(0),
123 fHigh(30),
124 fFillZero(kFALSE),
125 fNormalizeNbOfCluster(kFALSE),
126 fRelativeScale(0.0),
127 fMaxCluster(100.0),
128 fNbMaxCluster(2),
129 fOfflineTracks(kFALSE),
130 fStandaloneTracks(kFALSE),
a2a4ec8e 131 fVersionGainUsed(-1),
132 fSubVersionGainUsed(-1),
133 fVersionGainLocalUsed(-1),
134 fSubVersionGainLocalUsed(-1),
135 fVersionVdriftUsed(-1),
136 fSubVersionVdriftUsed(-1),
98937691 137 fCalDetGain(0x0),
138 fMaxEvent(0),
139 fCounter(0),
140 fDebug(0)
141{
142 //
143 // Default constructor
144 //
145
146 fNz[0] = 0;
147 fNz[1] = 0;
148 fNz[2] = 0;
149
150 fNrphi[0] = 0;
151 fNrphi[1] = 0;
152 fNrphi[2] = 0;
153
154 // Define input and output slots here
155 // Input slot #0 works with a TChain
156 DefineInput(0, TChain::Class());
157
158 // Output slot #0 writes into a TList container
01239968 159 DefineOutput(1, TList::Class());
98937691 160
161
162}
163//____________________________________________________________________________________
164AliTRDCalibTask::~AliTRDCalibTask()
165{
166 //
167 // AliTRDCalibTask destructor
168 //
169
170 // Pointeur
171 if(fNEvents) delete fNEvents;
172 if(fNbTRDTrack) delete fNbTRDTrack;
173 if(fNbTRDTrackOffline) delete fNbTRDTrackOffline;
174 if(fNbTRDTrackStandalone) delete fNbTRDTrackStandalone;
175 if(fNbTPCTRDtrack) delete fNbTPCTRDtrack;
176 if(fNbTimeBin) delete fNbTimeBin;
177 if(fNbTimeBinOffline) delete fNbTimeBinOffline;
178 if(fNbTimeBinStandalone) delete fNbTimeBinStandalone;
179 if(fNbClusters) delete fNbClusters;
180 if(fNbClustersOffline) delete fNbClustersOffline;
181 if(fNbClustersStandalone) delete fNbClustersStandalone;
182 if(fNbTracklets) delete fNbTracklets;
183 if(fNbTrackletsOffline) delete fNbTrackletsOffline;
184 if(fNbTrackletsStandalone) delete fNbTrackletsStandalone;
185 if(fAbsoluteGain) delete fAbsoluteGain;
186 if(fCH2dSum) delete fCH2dSum;
187 if(fPH2dSum) delete fPH2dSum;
188 if(fCH2dSM) delete fCH2dSM;
189 if(fPH2dSM) delete fPH2dSM;
190 if(fCalDetGain) delete fCalDetGain;
191
192 if(fSelectedTrigger) {
193 fSelectedTrigger->Delete();
194 delete fSelectedTrigger;
195 }
196 if(fEsdTrackCuts) {
197 delete fEsdTrackCuts;
198 }
199
200}
01239968 201
202/*
98937691 203//________________________________________________________________________
204void AliTRDCalibTask::ConnectInputData(Option_t *)
205{
206 // Connect ESD or AOD here
01239968 207 // Called once per event
98937691 208
01239968 209 cout << "AliTRDCalibTask::ConnectInputData() IN" << endl;
210
211
212 // TTree* tree = dynamic_cast<TTree*> (GetInputData(0)); //pointer wird "umgecastet" auf anderen Variablentyp
213 // if (!tree) {
98937691 214 //Printf("ERROR: Could not read chain from input slot 0");
01239968 215 // } else {
98937691 216
01239968 217 AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
218
219 if (!esdH) {
220 //Printf("ERROR: Could not get ESDInputHandler");
221 } else {
222 fESD = esdH->GetEvent();
223 // esdH->SetActiveBranches("ESDfriend*");
224 if ((esdH->GetTree())->GetBranch("ESDfriend.")) fESDfriend = esdH->GetESDfriend();
225 //else printf("No friend ESD\n");
226 //Printf("*** CONNECTED NEW EVENT ****");
98937691 227 }
01239968 228
229
230 // }
231 //cout << "AliTRDCalibTask::ConnectInputData() OUT" << endl;
232
98937691 233}
01239968 234*/
235
98937691 236//________________________________________________________________________
01239968 237void AliTRDCalibTask::UserCreateOutputObjects()
98937691 238{
239 //
240 // Create the histos
241 //
01239968 242 //cout << "AliTRDCalibTask::CreateOutputObjects() IN" << endl;
98937691 243
244 // Number of time bins
245 if(fNbTimeBins==0) {
246 AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
247 fNbTimeBins = cal->GetNumberOfTimeBinsDCS();
248 if(fNbTimeBins <= 0){
249 AliWarning(Form("No of TimeBins from DB [%d] use default [30]", fNbTimeBins));
250 fNbTimeBins = 30;
251 }
252 }
a2a4ec8e 253
98937691 254 // instance calibration
255 fTRDCalibraFillHisto = AliTRDCalibraFillHisto::Instance();
256 fTRDCalibraFillHisto->SetHisto2d(fHisto2d); // choose to use histograms
257 fTRDCalibraFillHisto->SetVector2d(fVector2d); // choose to use vectors
258 fTRDCalibraFillHisto->SetCH2dOn(); // choose to calibrate the gain
259 fTRDCalibraFillHisto->SetPH2dOn(); // choose to calibrate the drift velocity
260 fTRDCalibraFillHisto->SetPRF2dOn(); // choose to look at the PRF
261 fTRDCalibraFillHisto->SetLinearFitterOn(fVdriftLinear); // Other possibility vdrift VDRIFT
262 fTRDCalibraFillHisto->SetLinearFitterDebugOn(fVdriftLinear); // Other possibility vdrift
263 for(Int_t k = 0; k < 3; k++){
264 if(((fNz[k] != 10) && (fNrphi[k] != 10)) && ((fNz[k] != 100) && (fNrphi[k] != 100))) {
265 fTRDCalibraFillHisto->SetNz(k,fNz[k]); // Mode calibration
266 fTRDCalibraFillHisto->SetNrphi(k,fNrphi[k]); // Mode calibration
267 }
268 else {
269 if((fNz[k] == 100) && (fNrphi[k] == 100)) {
270 if(fVector2d) AliInfo("The mode all together is not supported by the vector method");
271 fTRDCalibraFillHisto->SetAllTogether(k);
272 }
273 if((fNz[k] == 10) && (fNrphi[k] == 10)) {
274 if(fVector2d) AliInfo("The mode per supermodule is not supported by the vector method");
275 fTRDCalibraFillHisto->SetPerSuperModule(k);
276 }
277 }
278 }
279 // Variables for how to fill
280 fTRDCalibraFillHisto->SetFillWithZero(fFillZero);
281 fTRDCalibraFillHisto->SetNormalizeNbOfCluster(fNormalizeNbOfCluster);
282 fTRDCalibraFillHisto->SetMaxCluster(fMaxCluster);
283 fTRDCalibraFillHisto->SetNbMaxCluster(fNbMaxCluster);
284
285 // Init with 30 timebins
286 fTRDCalibraFillHisto->Init2Dhistos(fNbTimeBins); // initialise the histos
287 fTRDCalibraFillHisto->SetNumberClusters(fLow); // At least 11 clusters
288 fTRDCalibraFillHisto->SetNumberClustersf(fHigh); // At least 11 clusters
289 fRelativeScale = fTRDCalibraFillHisto->GetRelativeScale(); // Get the relative scale for the gain
290
291 // For testing only
292 if(fDebug > 2) fTRDCalibraFillHisto->SetDebugLevel(1); //debug stuff
293
294 // output list
295 fListHist = new TList();
296 if(fHisto2d) {
297 fListHist->Add(fTRDCalibraFillHisto->GetCH2d());
298 fListHist->Add(fTRDCalibraFillHisto->GetPH2d());
299 fListHist->Add(fTRDCalibraFillHisto->GetPRF2d());
300 }
301 if(fVdriftLinear) fListHist->Add((TObject *) fTRDCalibraFillHisto->GetVdriftLinearFit());
302 if(fVector2d) fListHist->Add((TObject *) fTRDCalibraFillHisto->GetCalibraVector()); //calibra vector
303 fNEvents = new TH1I("NEvents","NEvents", 2, 0, 2);
304 fListHist->Add(fNEvents);
305
306 // absolute gain calibration even without AliESDfriend
307 Int_t nBinsPt = 25;
308 Double_t minPt = 0.001;
309 Double_t maxPt = 10.0;
310
311 Double_t *binLimLogPt = new Double_t[nBinsPt+1];
312 Double_t *binLimPt = new Double_t[nBinsPt+1];
313 for(Int_t i=0; i<=nBinsPt; i++) binLimLogPt[i]=(Double_t)TMath::Log10(minPt) + (TMath::Log10(maxPt)-TMath::Log10(minPt))/nBinsPt*(Double_t)i ;
314 for(Int_t i=0; i<=nBinsPt; i++) binLimPt[i]=(Double_t)TMath::Power(10,binLimLogPt[i]);
315
316 fAbsoluteGain = new TH2F("AbsoluteGain","AbsoluteGain", 200, 0.0, 700.0, nBinsPt, binLimPt);
317 fAbsoluteGain->SetYTitle("Momentum at TRD");
318 fAbsoluteGain->SetXTitle("charge deposit [a.u]");
319 fAbsoluteGain->SetZTitle("counts");
320 fAbsoluteGain->SetStats(0);
321 fAbsoluteGain->Sumw2();
322 fListHist->Add(fAbsoluteGain);
323
324
325
326 /////////////////////////////////////////
327 // First debug level
328 ///////////////////////////////////////
329 if(fDebug > 0) {
330
331 // Standart with AliESDfriend
332 fPH2dSM = new TProfile2D("PH2dSM","Nz10Nrphi10"
333 ,fNbTimeBins,-0.05,(Double_t)((fNbTimeBins-0.5)/10.0)
334 ,18,0,18);
335 fPH2dSM->SetYTitle("Det/pad groups");
336 fPH2dSM->SetXTitle("time [#mus]");
337 fPH2dSM->SetZTitle("<PH> [a.u.]");
338 fPH2dSM->SetStats(0);
339 //
340 fCH2dSM = new TH2I("CH2dSM","Nz10Nrphi10",50,0,300,18,0,18);
341 fCH2dSM->SetYTitle("Det/pad groups");
342 fCH2dSM->SetXTitle("charge deposit [a.u]");
343 fCH2dSM->SetZTitle("counts");
344 fCH2dSM->SetStats(0);
345 fCH2dSM->Sumw2();
346 //
347 fPH2dSum = new TProfile2D("PH2dSum","Nz100Nrphi100"
348 ,fNbTimeBins,-0.05,(Double_t)((fNbTimeBins-0.5)/10.0)
349 ,1,0,1);
350 fPH2dSum->SetYTitle("Det/pad groups");
351 fPH2dSum->SetXTitle("time [#mus]");
352 fPH2dSum->SetZTitle("<PH> [a.u.]");
353 fPH2dSum->SetStats(0);
354 //
355 fCH2dSum = new TH2I("CH2dSum","Nz100Nrphi100",50,0,300,1,0,1);
356 fCH2dSum->SetYTitle("Det/pad groups");
357 fCH2dSum->SetXTitle("charge deposit [a.u]");
358 fCH2dSum->SetZTitle("counts");
359 fCH2dSum->SetStats(0);
360 fCH2dSum->Sumw2();
361
362 // Add them
363 fListHist->Add(fPH2dSM);
364 fListHist->Add(fCH2dSM);
365 fListHist->Add(fPH2dSum);
366 fListHist->Add(fCH2dSum);
367 }
368
369 /////////////////////////////////////////
370 // Second debug level
371 ///////////////////////////////////////
372 if(fDebug > 1) {
373
374 fNbTRDTrack = new TH1F("TRDTrack","TRDTrack",50,0,50);
375 fNbTRDTrack->Sumw2();
376 fNbTRDTrackOffline = new TH1F("TRDTrackOffline","TRDTrackOffline",50,0,50);
377 fNbTRDTrackOffline->Sumw2();
378 fNbTRDTrackStandalone = new TH1F("TRDTrackStandalone","TRDTrackStandalone",50,0,50);
379 fNbTRDTrackStandalone->Sumw2();
380 fNbTPCTRDtrack = new TH2F("NbTPCTRDtrack","NbTPCTRDtrack",100,0,100,100,0,100);
381 fNbTPCTRDtrack->Sumw2();
382 //
383 fNbTimeBin = new TH1F("NbTimeBin","NbTimeBin",35,0,35);
384 fNbTimeBin->Sumw2();
385 fNbTimeBinOffline = new TH1F("NbTimeBinOffline","NbTimeBinOffline",35,0,35);
386 fNbTimeBinOffline->Sumw2();
387 fNbTimeBinStandalone = new TH1F("NbTimeBinStandalone","NbTimeBinStandalone",35,0,35);
388 fNbTimeBinStandalone->Sumw2();
389 //
390 fNbClusters = new TH1F("NbClusters","",35,0,35);
391 fNbClusters->Sumw2();
392 fNbClustersOffline = new TH1F("NbClustersOffline","",35,0,35);
393 fNbClustersOffline->Sumw2();
394 fNbClustersStandalone = new TH1F("NbClustersStandalone","",35,0,35);
395 fNbClustersStandalone->Sumw2();
396 //
397 fNbTracklets = new TH1F("NbTracklets","NbTracklets",540,0.,540.);
398 fNbTracklets->Sumw2();
399 fNbTrackletsOffline = new TH1F("NbTrackletsOffline","NbTrackletsOffline",540,0.,540.);
400 fNbTrackletsOffline->Sumw2();
401 fNbTrackletsStandalone = new TH1F("NbTrackletsStandalone","NbTrackletsStandalone",540,0.,540.);
402 fNbTrackletsStandalone->Sumw2();
403
404 fListHist->Add(fNbTRDTrack);
405 fListHist->Add(fNbTRDTrackOffline);
406 fListHist->Add(fNbTRDTrackStandalone);
407 fListHist->Add(fNbTPCTRDtrack);
408
409 fListHist->Add(fNbTimeBin);
410 fListHist->Add(fNbTimeBinOffline);
411 fListHist->Add(fNbTimeBinStandalone);
412 fListHist->Add(fNbClusters);
413 fListHist->Add(fNbClustersOffline);
414 fListHist->Add(fNbClustersStandalone);
415 fListHist->Add(fNbTracklets);
416 fListHist->Add(fNbTrackletsOffline);
417 fListHist->Add(fNbTrackletsStandalone);
418
419 }
01239968 420 //cout << "AliTRDCalibTask::UserCreateOutputObjects() OUT" << endl;
421}
98937691 422
57185ead 423
01239968 424//________________________________________________________________________
425void AliTRDCalibTask::UserExec(Option_t *)
426{
427 //
428 // Filling of the histos
429 //
430 //cout << "AliTRDCalibTask::Exec() IN" << endl;
98937691 431
a2a4ec8e 432 // Init Versions and subversions used
433 if((fVersionGainUsed==-1) || (fSubVersionGainUsed==-1) || (fVersionGainLocalUsed==-1) || (fSubVersionGainLocalUsed==-1) || (fVersionVdriftUsed==-1) || (fSubVersionVdriftUsed==-1)) {
434 if(!SetVersionSubversion()) {
435 fVersionGainUsed=0;
436 fSubVersionGainUsed=0;
437 fVersionGainLocalUsed=0;
438 fSubVersionGainLocalUsed=0;
439 fVersionVdriftUsed=0;
440 fSubVersionVdriftUsed=0;
441 }
442 }
443 if(fCounter==0) {
444 fTRDCalibraFillHisto->SetVersionGainUsed(fVersionGainUsed); // Gain Used
445 fTRDCalibraFillHisto->SetSubVersionGainUsed(fSubVersionGainUsed); // Gain Used
446 fTRDCalibraFillHisto->SetVersionGainLocalUsed(fVersionGainLocalUsed); // Gain Used
447 fTRDCalibraFillHisto->SetSubVersionGainLocalUsed(fSubVersionGainLocalUsed); // Gain Used
448 fTRDCalibraFillHisto->SetVersionVdriftUsed(fVersionVdriftUsed); // Vdrift Used
449 fTRDCalibraFillHisto->SetSubVersionVdriftUsed(fSubVersionVdriftUsed); // Vdrift Used
450 fTRDCalibraFillHisto->InitCalDet();
451 }
452
01239968 453 // AliLog::SetGlobalLogLevel(AliLog::kError);
454 // cout << "AliTRDCalibTask::Exec() 1" << endl;
455 fESD = dynamic_cast<AliESDEvent*>(fInputEvent);
456 if(!fESD){
457 AliError("ESD Event missing");
458 PostData(1, fListHist);
459 return;
460 }
461
462 //printf("Counter %d\n",fCounter);
463
464 fCounter++;
465 //cout << "maxEvent = " << fMaxEvent << endl;
466 //if(fCounter%100==0) cout << "fCounter = " << fCounter << endl;
467 if((fMaxEvent != 0) && (fMaxEvent < fCounter)) return;
468 //if(fCounter%100==0) cout << "fCounter1 = " << fCounter << endl;
469 //cout << "event = " << fCounter << endl;
470
471 //printf("Counter %d\n",fCounter);
472
473 ///////////////////
474 // Check trigger
475 ///////////////////
476 Bool_t pass = kTRUE;
477 Int_t numberOfTriggerSelected = fSelectedTrigger->GetEntriesFast();
478 //printf("numberofTriggerSelected %d\n",numberOfTriggerSelected);
479 if(fRejected) {
480 pass = kTRUE;
481 for(Int_t k = 0; k < numberOfTriggerSelected; k++){
482 const TObjString *const obString=(TObjString*)fSelectedTrigger->At(k);
483 const TString tString=obString->GetString();
484 if(fESD->IsTriggerClassFired((const char*)tString)) {
485 pass = kFALSE;
486 }
487 }
488 }
489 else {
490 pass = kFALSE;
491 for(Int_t k = 0; k < numberOfTriggerSelected; k++){
492 const TObjString *const obString=(TObjString*)fSelectedTrigger->At(k);
493 const TString tString=obString->GetString();
494 if(fESD->IsTriggerClassFired((const char*)tString)) {
495 pass = kTRUE;
496 }
497 }
498 }
499 if(!pass) {
500 PostData(1, fListHist);
501 return;
502 }
503 //printf("Class Fired %s\n",(const char*)fESD->GetFiredTriggerClasses());
504 //printf("Trigger passed\n");
505
506 ///////////////////////////////
507 // Require a primary vertex
508 //////////////////////////////
509 if(fRequirePrimaryVertex) {
510 const AliESDVertex* vtxESD = 0x0;
511 if (fVtxTPC) vtxESD = fESD->GetPrimaryVertexTPC() ;
512 else if (fVtxSPD) vtxESD = fESD->GetPrimaryVertexSPD() ;
513 else vtxESD = fESD->GetPrimaryVertexTracks() ;
514 if(!vtxESD){
515 PostData(1, fListHist);
516 return;
517 }
518 Int_t nCtrb = vtxESD->GetNContributors();
519 if(nCtrb < fMinNbContributors) {
520 PostData(1, fListHist);
521 return;
522 }
523 Double_t zPosition = vtxESD->GetZ();
524 if(TMath::Abs(zPosition) > fRangePrimaryVertexZ) {
525 PostData(1, fListHist);
526 return;
527 }
528
529 }
530
531 //printf("Primary vertex passed\n");
532
533 fNEvents->Fill(1);
534
535 // In total
536 Int_t nbTrdTracks = 0;
537 // standalone
538 Int_t nbTrdTracksStandalone = 0;
539 // offline
540 Int_t nbTrdTracksOffline = 0;
541 // TPC
542 Int_t nbtrackTPC = 0;
543
544 Double_t nbTracks = fESD->GetNumberOfTracks();
545 //printf("Number of tracks %f\n",nbTracks);
546
547 if (nbTracks <= 0.0) {
548
549 if(fDebug > 1) {
550 fNbTRDTrack->Fill(nbTrdTracks);
551 fNbTRDTrackStandalone->Fill(nbTrdTracksStandalone);
552 fNbTRDTrackOffline->Fill(nbTrdTracksOffline);
553 }
554 PostData(1, fListHist);
555 return;
556 }
557
4c865c34 558
01239968 559 fESDfriend = dynamic_cast<AliESDfriend*> (fESD->FindListObject("AliESDfriend"));
560 if(!fESDfriend){
561 AliError("fESDfriend not available");
562 PostData(1, fListHist);
563 return;
564 }
565
566 //printf("has friends\n");
98937691 567
01239968 568 /*
569 ////////////////////////////////////
98937691 570 // Check the number of TPC tracks
571 ///////////////////////////////////
572 //printf("Nb of tracks %f\n",nbTracks);
573 for(Int_t itrk = 0; itrk < nbTracks; itrk++){
574 // Get ESD track
575 fkEsdTrack = fESD->GetTrack(itrk);
576 ULong_t status = fkEsdTrack->GetStatus();
577 if(status&(AliESDtrack::kTPCout)) nbtrackTPC++;
01239968 578 if((status&(AliESDtrack::kTRDout)) && (!(status&(AliESDtrack::kTRDin)))) {
579 nbTrdTracks++;
580 nbTrdTracksStandalone++;
581 }
582 if((status&(AliESDtrack::kTRDin))) {
583 nbTrdTracks++;
584 nbTrdTracksOffline++;
98937691 585 }
586 }
01239968 587
98937691 588 if((nbtrackTPC>0) && (nbTrdTracks > (3.0*nbtrackTPC))) pass = kFALSE;
589
590 if(fDebug > 1) {
591
592 fNbTRDTrack->Fill(nbTrdTracks);
593 fNbTRDTrackStandalone->Fill(nbTrdTracksStandalone);
594 fNbTRDTrackOffline->Fill(nbTrdTracksOffline);
595 fNbTPCTRDtrack->Fill(nbTrdTracks,nbtrackTPC);
596
597 }
598
599 if(!pass) {
01239968 600 PostData(1, fListHist);
98937691 601 return;
602 }
01239968 603 */
604
605 /////////////////////////////////////
606 // Loop on AliESDtrack
607 ////////////////////////////////////
608 //printf("Nb of tracks %f\n",nbTracks);
609 for(int itrk=0; itrk < nbTracks; ++itrk){
98937691 610
01239968 611 // Get ESD track
612 fkEsdTrack = fESD->GetTrack(itrk);
613 if(!fkEsdTrack) continue;
614 ULong_t status = fkEsdTrack->GetStatus();
615 if(status&(AliESDtrack::kTPCout)) ++nbtrackTPC;
616
617 // Quality cuts on the AliESDtrack
618 if((fEsdTrackCuts) && (!fEsdTrackCuts->IsSelected((AliVParticle *)fkEsdTrack))) {
619 //printf("Not a good track\n");
620 continue;
621 }
622
623 // First Absolute gain calibration
624 Int_t trdNTracklets = (Int_t) fkEsdTrack->GetTRDntracklets();
625 Int_t trdNTrackletsPID = (Int_t) fkEsdTrack->GetTRDntrackletsPID();
626 if((trdNTracklets > 0) && (trdNTrackletsPID > 0)) {
627 for(Int_t iPlane = 0; iPlane < 6; ++iPlane){
628 //Double_t slide = fkEsdTrack->GetTRDslice(iPlane);
629 //printf("Number of slide %d\n",fkEsdTrack->GetNumberOfTRDslices());
630 //Double_t momentum = fkEsdTrack->GetTRDmomentum(iPlane);
631 //printf("momentum %f, slide %f\n",momentum,slide);
632 if(fkEsdTrack->GetTRDslice(iPlane) > 0.0)
633 fAbsoluteGain->Fill(fkEsdTrack->GetTRDslice(iPlane)*8.0/100.0,
634 fkEsdTrack->GetTRDmomentum(iPlane));
635 }
636 }
637
638 // Other cuts
639 Bool_t good = kTRUE;
640 Bool_t standalonetrack = kFALSE;
641 Bool_t offlinetrack = kFALSE;
642 //ULong_t status = fkEsdTrack->GetStatus();
643
644 fFriendTrack = fESDfriend->GetTrack(itrk);
4c865c34 645 if(!fFriendTrack) {
646 //printf("No friend track %d\n",itrk);
647 continue;
648 }
01239968 649 //////////////////////////////////////
650 // Loop on calibration objects
651 //////////////////////////////////////
652 Int_t icalib=0;
653 Int_t nTRDtrackV1=0;
654 while((fCalibObject = (TObject *)(fFriendTrack->GetCalibObject(icalib++)))){
4c865c34 655 //printf("Name %s\n",fCalibObject->IsA()->GetName());
01239968 656 if(strcmp(fCalibObject->IsA()->GetName(), "AliTRDtrackV1") != 0) continue;
657 //printf("Find the calibration object\n");
658 ++nTRDtrackV1;
659
660 if((status&(AliESDtrack::kTRDout)) && (!(status&(AliESDtrack::kTRDin)))) {
661 standalonetrack = kTRUE;
662 }
663 if((status&(AliESDtrack::kTRDin))) {
664 offlinetrack = kTRUE;
665 }
666 if(fOfflineTracks){
667 if(!offlinetrack){
668 good = kFALSE;
669 }
670 }
671 else if(fStandaloneTracks){
672 if(!standalonetrack){
673 good = kFALSE;
674 }
675 }
676
677 fTrdTrack = (AliTRDtrackV1 *)fCalibObject;
678 if(good) {
679 //cout << "good" << endl;
680 fTRDCalibraFillHisto->UpdateHistogramsV1(fTrdTrack);
681 //printf("Fill fTRDCalibraFillHisto\n");
682 }
683
684 //////////////////////////////////
685 // Debug
686 ////////////////////////////////
687
688 if(fDebug > 0) {
689
690 //printf("Enter debug\n");
691
692 Int_t nbtracklets = 0;
693
694 // Check some stuff
695 Bool_t standalonetracklet = kFALSE;
696 const AliTRDseedV1 *tracklet = 0x0;
697 //////////////////////////////////////
698 // Loop tracklets
699 /////////////////////////////////////
700 Int_t nbclusters=0;
701 Double_t phtb[AliTRDseedV1::kNtb];
702 memset(phtb, 0, AliTRDseedV1::kNtb*sizeof(Double_t));
703 Double_t sum = 0.0;
704 Float_t normalisation = 6.67;
705 Int_t detector = 0;
706 Int_t sector = 0;
707 for(Int_t itr = 0; itr < 6; ++itr){
708
709 if(!(tracklet = fTrdTrack->GetTracklet(itr))) continue;
710 if(!tracklet->IsOK()) continue;
711 ++nbtracklets;
712 standalonetracklet = kFALSE;
713 if(tracklet->IsStandAlone()) standalonetracklet = kTRUE;
714
715 nbclusters = 0;
716 memset(phtb, 0, AliTRDseedV1::kNtb*sizeof(Double_t));
717 sum = 0.0;
718 detector = 0;
719 sector = 0;
720 //Int_t crossrow = 0;
721
722 // Check no shared clusters
723 //for(int icc=AliTRDseedV1::kNtb; icc<AliTRDseedV1::kNclusters; icc++){
724 // if((fcl = tracklet->GetClusters(icc))) crossrow = 1;
725 // }
726
727 // Loop on clusters
728 Int_t time = 0;
729 Float_t ch = 0;
730 Float_t qcl = 0;
731 for(int ic=0; ic<AliTRDseedV1::kNtb; ++ic){
732
733 if(!(fCl = tracklet->GetClusters(ic))) continue;
734 ++nbclusters;
735 time = fCl->GetPadTime();
736 ch = tracklet->GetdQdl(ic);
737 qcl = TMath::Abs(fCl->GetQ());
738 detector = fCl->GetDetector();
739 // Add the charge if shared cluster
740 if((ic+AliTRDseedV1::kNtb) < AliTRDseedV1::kNclusters) {
741 if((fCl = tracklet->GetClusters(ic+AliTRDseedV1::kNtb))) {
742 qcl += TMath::Abs(fCl->GetQ());
743 //printf("Add the cluster charge\n");
744 }
745 }
746 if((time>-1) && (time<fNbTimeBins)) phtb[time]=qcl;
747 if((fCalDetGain) && (fCalDetGain->GetValue(detector) > 0.0)) sum += ch*fCalDetGain->GetValue(detector)/normalisation;
748 else sum += ch/normalisation;
749
750 if(fDebug > 1) {
751 fNbTimeBin->Fill(time);
752 if(tracklet->IsStandAlone()) fNbTimeBinStandalone->Fill(time);
753 else fNbTimeBinOffline->Fill(time);
754 }
755 }
756 sector = AliTRDgeometry::GetSector(detector);
757
758 if(fDebug > 1) {
759 fNbTracklets->Fill(detector);
760 if(tracklet->IsStandAlone()) fNbTrackletsStandalone->Fill(detector);
761 else fNbTrackletsOffline->Fill(detector);
762
763 fNbClusters->Fill(nbclusters);
764 if(tracklet->IsStandAlone()) fNbClustersStandalone->Fill(nbclusters);
765 else fNbClustersOffline->Fill(nbclusters);
766 }
767
768 if(fDebug > 0) {
769 if((nbclusters > fLow) && (nbclusters < fHigh)){
770 if(fRelativeScale > 0.0) sum = sum/fRelativeScale;
771 fCH2dSM->Fill(sum,sector+0.5);
772 fCH2dSum->Fill(sum,0.5);
773 Bool_t checknoise = kTRUE;
774 if(fMaxCluster > 0) {
775 if(phtb[0] > fMaxCluster) checknoise = kFALSE;
776 if(fNbTimeBins > fNbMaxCluster) {
777 for(Int_t k = (fNbTimeBins-fNbMaxCluster); k < fNbTimeBins; k++){
778 if(phtb[k] > fMaxCluster) checknoise = kFALSE;
779 }
780 }
781 }
782 if(checknoise) {
783 for(int ic=0; ic<fNbTimeBins; ic++){
784 if(fFillZero) {
785 fPH2dSum->Fill((Double_t)(ic/10.0),0.5,(Double_t)phtb[ic]);
786 fPH2dSM->Fill((Double_t)(ic/10.0),sector+0.5,(Double_t)phtb[ic]);
787 }
788 else {
789 if(phtb[ic] > 0.0) {
790 fPH2dSum->Fill((Double_t)(ic/10.0),0.0,(Double_t)phtb[ic]);
791 fPH2dSM->Fill((Double_t)(ic/10.0),sector+0.5,(Double_t)phtb[ic]);
792 }
793 }
794 }
795 }
796 }
797 }
798 } // loop on tracklets
799
800 } // debug
801
802 }// while calibration objects
803 if(nTRDtrackV1 > 0) {
804 ++nbTrdTracks;
805 if((status&(AliESDtrack::kTRDout)) && (!(status&(AliESDtrack::kTRDin)))) {
806 ++nbTrdTracksStandalone;
807 }
808 if((status&(AliESDtrack::kTRDin))) {
809 ++nbTrdTracksOffline;
810 }
811 }
812 //delete fFriendTrack;
813 } // loop ESD track
814
815 if(fDebug > 1) {
816 fNbTRDTrack->Fill(nbTrdTracks);
817 fNbTRDTrackStandalone->Fill(nbTrdTracksStandalone);
818 fNbTRDTrackOffline->Fill(nbTrdTracksOffline);
819 fNbTPCTRDtrack->Fill(nbTrdTracks,nbtrackTPC);
820 }
821
822 // Post output data
823 PostData(1, fListHist);
824 //cout << "AliTRDCalibTask::Exec() OUT" << endl;
825}
98937691 826
98937691 827//________________________________________________________________________
828void AliTRDCalibTask::Terminate(Option_t *)
829{
830 //
831 // Terminate
832 //
833
834 if(fTRDCalibraFillHisto) fTRDCalibraFillHisto->DestroyDebugStreamer();
835
836
837}
838//_______________________________________________________
839Bool_t AliTRDCalibTask::Load(const Char_t *filename)
840{
841 //
842 // Generic container loader
843 //
844
845 if(!TFile::Open(filename)){
846 //AliWarning(Form("Couldn't open file %s.", filename));
847 return kFALSE;
848 }
849 TList *o = 0x0;
850 if(!(o = (TList*)gFile->Get(GetName()))){
851 //AliWarning("Missing histogram container.");
852 return kFALSE;
853 }
854 fListHist = (TList*)o->Clone(GetName());
855 gFile->Close();
856 return kTRUE;
857}
57185ead 858//_______________________________________________________
859Bool_t AliTRDCalibTask::Load(TList *lister)
860{
861 //
862 // Generic container loader
863 //
864
865 fListHist = (TList*)lister->Clone(GetName());
866 return kTRUE;
867}
98937691 868//________________________________________________________________________
869void AliTRDCalibTask::Plot()
870{
871 //
872 // Plot the histos stored in the TList
873 //
874
875 if(!fListHist) return;
876
877 /////////////////////////////////////
878 // Take the debug stuff
879 /////////////////////////////////////
880
881 TH1I *nEvents = (TH1I *) fListHist->FindObject("NEvents");
882
883 TH2F *absoluteGain = (TH2F *) fListHist->FindObject("AbsoluteGain");
884
885 TH1F *trdTrack = (TH1F *) fListHist->FindObject("TRDTrack");
886 TH1F *trdTrackOffline = (TH1F *) fListHist->FindObject("TRDTrackOffline");
887 TH1F *trdTrackStandalone = (TH1F *) fListHist->FindObject("TRDTrackStandalone");
888
889 TH2F *tpctrdTrack = (TH2F *) fListHist->FindObject("NbTPCTRDtrack");
890
891 TH1F *nbTimeBin = (TH1F *) fListHist->FindObject("NbTimeBin");
892 TH1F *nbTimeBinOffline = (TH1F *) fListHist->FindObject("NbTimeBinOffline");
893 TH1F *nbTimeBinStandalone = (TH1F *) fListHist->FindObject("NbTimeBinStandalone");
894
895 TH1F *nbClusters = (TH1F *) fListHist->FindObject("NbClusters");
896 TH1F *nbClustersOffline = (TH1F *) fListHist->FindObject("NbClustersOffline");
897 TH1F *nbClustersStandalone = (TH1F *) fListHist->FindObject("NbClustersStandalone");
898
899 TH1F *nbTracklets = (TH1F *) fListHist->FindObject("NbTracklets");
900 TH1F *nbTrackletsOffline = (TH1F *) fListHist->FindObject("NbTrackletsOffline");
901 TH1F *nbTrackletsStandalone = (TH1F *) fListHist->FindObject("NbTrackletsStandalone");
902
903 /////////////////////////////////////
904 // Take the calibration objects
905 /////////////////////////////////////
906
907 TH2I *ch2d = (TH2I *) fListHist->FindObject("CH2d");
908 TProfile2D *ph2d = (TProfile2D *) fListHist->FindObject("PH2d");
909
910 TH2I *ch2dSum = (TH2I *) fListHist->FindObject("CH2dSum");
911 TProfile2D *ph2dSum = (TProfile2D *) fListHist->FindObject("PH2dSum");
912
913 TH2I *ch2dSM = (TH2I *) fListHist->FindObject("CH2dSM");
914 TProfile2D *ph2dSM = (TProfile2D *) fListHist->FindObject("PH2dSM");
915
916 AliTRDCalibraVdriftLinearFit *linearfit = (AliTRDCalibraVdriftLinearFit *) fListHist->FindObject("AliTRDCalibraVdriftLinearFit");
917
918 ////////////////////////////////////////////////
919 // Add the AliTRDCalibraVdriftLinearFit
920 ///////////////////////////////////////////////
921
922 Int_t first = 0;
923 TH2S *histolinearfitsum = 0x0;
924
925 if(linearfit) {
926 for(Int_t det = 0; det < 540; det++) {
927 if(linearfit->GetLinearFitterHisto(det)){
928 if(TMath::Abs(first)<0.0001){
929 histolinearfitsum = linearfit->GetLinearFitterHisto(det);
930 first += 1;
931 }
932 else {
933 histolinearfitsum ->Add(linearfit->GetLinearFitterHisto(det));
934 }
935 }
936 }
937 }
938
939 ///////////////////////////
940 // Style
941 //////////////////////////
942
943 gStyle->SetPalette(1);
944 gStyle->SetOptStat(1111);
945 gStyle->SetOptFit(1111);
946 gStyle->SetPadBorderMode(0);
947 gStyle->SetCanvasColor(10);
948 gStyle->SetPadLeftMargin(0.13);
949 gStyle->SetPadRightMargin(0.13);
950
951 /////////////////////////
952 // Plot
953 ////////////////////////
954
955 if(nEvents) {
956
957 TCanvas *debugEvents = new TCanvas("cNEvents","cNEvents",10,10,510,510);
958 debugEvents->cd(1);
959 if(nEvents) nEvents->Draw();
960
961 }
962
963 if(absoluteGain) {
964
965 TCanvas *debugAbsoluteGain = new TCanvas("cAbsoluteGain","cAbsoluteGain",10,10,510,510);
966 debugAbsoluteGain->cd(1);
967 if(absoluteGain) absoluteGain->Draw();
968
969 }
970
971 if(trdTrack || tpctrdTrack) {
972
973 TCanvas *debugtrdtpcTrack = new TCanvas("TRDtracktpctrdtrack","TRDtracktpctrdtrack",10,10,510,510);
974 debugtrdtpcTrack->Divide(2,1);
975 debugtrdtpcTrack->cd(1);
976 if(trdTrack) trdTrack->Draw();
977 if(trdTrackOffline) trdTrackOffline->Draw("same");
978 if(trdTrackStandalone) trdTrackStandalone->Draw("same");
979 TLegend *leg = new TLegend(0.4,0.6,0.89,0.89);
980 if(trdTrack) leg->AddEntry(trdTrack,"All","p");
981 if(trdTrackOffline) leg->AddEntry(trdTrackOffline,"Offline","p");
982 if(trdTrackStandalone) leg->AddEntry(trdTrackStandalone,"Standalone","p");
983 leg->Draw("same");
984 debugtrdtpcTrack->cd(2);
985 if(tpctrdTrack) tpctrdTrack->Draw();
986 TLine *line = new TLine(0.0,0.0,100.0,100.0);
987 line->Draw("same");
988
989 }
990
991 if(nbTimeBin || nbTracklets || nbClusters) {
992
993 TCanvas *debugTracklets = new TCanvas("TRDtimebintrackletcluster","TRDtimebintrackletcluster",10,10,510,510);
994 debugTracklets->Divide(3,1);
995 debugTracklets->cd(1);
996 if(nbTimeBin) nbTimeBin->Draw();
997 if(nbTimeBinOffline) nbTimeBinOffline->Draw("same");
998 if(nbTimeBinStandalone) nbTimeBinStandalone->Draw("same");
999 TLegend *lega = new TLegend(0.4,0.6,0.89,0.89);
1000 if(nbTimeBin) lega->AddEntry(nbTimeBin,"All","p");
1001 if(nbTimeBinOffline) lega->AddEntry(nbTimeBinOffline,"Offline","p");
1002 if(nbTimeBinStandalone) lega->AddEntry(nbTimeBinStandalone,"Standalone","p");
1003 lega->Draw("same");
1004 debugTracklets->cd(2);
1005 if(nbTracklets) nbTracklets->Draw();
1006 if(nbTrackletsOffline) nbTrackletsOffline->Draw("same");
1007 if(nbTrackletsStandalone) nbTrackletsStandalone->Draw("same");
1008 TLegend *legb = new TLegend(0.4,0.6,0.89,0.89);
1009 if(nbTracklets) legb->AddEntry(nbTracklets,"All","p");
1010 if(nbTrackletsOffline) legb->AddEntry(nbTrackletsOffline,"Offline","p");
1011 if(nbTrackletsStandalone) legb->AddEntry(nbTrackletsStandalone,"Standalone","p");
1012 legb->Draw("same");
1013 debugTracklets->cd(3);
1014 if(nbClusters) nbClusters->Draw();
1015 if(nbClustersOffline) nbClustersOffline->Draw("same");
1016 if(nbClustersStandalone) nbClustersStandalone->Draw("same");
1017 TLegend *legc = new TLegend(0.4,0.6,0.89,0.89);
1018 if(nbClusters) legc->AddEntry(nbClusters,"All","p");
1019 if(nbClustersOffline) legc->AddEntry(nbClustersOffline,"Offline","p");
1020 if(nbClustersStandalone) legc->AddEntry(nbClustersStandalone,"Standalone","p");
1021 legc->Draw("same");
1022
1023 }
1024
1025 if(ch2dSum || ph2dSum || histolinearfitsum) {
1026
1027 TCanvas *debugSum = new TCanvas("SumCalibrationObjects","SumCalibrationObjects",10,10,510,510);
1028 debugSum->Divide(3,1);
1029 debugSum->cd(1);
1030 if(ch2dSum) ch2dSum->Draw("lego");
1031 debugSum->cd(2);
1032 if(ph2dSum) ph2dSum->Draw("lego");
1033 debugSum->cd(3);
1034 if(histolinearfitsum) histolinearfitsum->Draw();
1035
1036 }
1037
1038 if(ch2dSM || ph2dSM) {
1039
1040 TCanvas *debugSM = new TCanvas("SMCalibrationObjects","SMCalibrationObjects",10,10,510,510);
1041 debugSM->Divide(2,1);
1042 debugSM->cd(1);
1043 if(ch2dSM) ch2dSM->Draw("lego");
1044 debugSM->cd(2);
1045 if(ph2dSM) ph2dSM->Draw("lego");
1046
1047 }
1048
1049 if(ch2d || ph2d) {
1050
1051 TCanvas *debug = new TCanvas("CalibrationObjects","CalibrationObjects",10,10,510,510);
1052 debug->Divide(2,1);
1053 debug->cd(1);
1054 if(ch2d) ch2d->Draw("lego");
1055 debug->cd(2);
1056 if(ph2d) ph2d->Draw("lego");
1057
1058 }
1059
21185a48 1060}
57185ead 1061//_______________________________________________________________________________________
1062void AliTRDCalibTask::AddTask(const AliTRDCalibTask * calibTask) {
1063
1064 //
1065 // Add stats
1066 //
1067
1068 TList *listcalibTask = calibTask->GetList();
1069 if(!listcalibTask) return;
1070
1071 TH1I *nEvents = (TH1I *) listcalibTask->FindObject("NEvents");
1072 TH2F *absoluteGain = (TH2F *) listcalibTask->FindObject("AbsoluteGain");
1073
1074 TH1F *trdTrack = (TH1F *) listcalibTask->FindObject("TRDTrack");
1075 TH1F *trdTrackOffline = (TH1F *) listcalibTask->FindObject("TRDTrackOffline");
1076 TH1F *trdTrackStandalone = (TH1F *) listcalibTask->FindObject("TRDTrackStandalone");
1077
1078 TH2F *tpctrdTrack = (TH2F *) listcalibTask->FindObject("NbTPCTRDtrack");
1079
1080 TH1F *nbTimeBin = (TH1F *) listcalibTask->FindObject("NbTimeBin");
1081 TH1F *nbTimeBinOffline = (TH1F *) listcalibTask->FindObject("NbTimeBinOffline");
1082 TH1F *nbTimeBinStandalone = (TH1F *) listcalibTask->FindObject("NbTimeBinStandalone");
1083
1084 TH1F *nbClusters = (TH1F *) listcalibTask->FindObject("NbClusters");
1085 TH1F *nbClustersOffline = (TH1F *) listcalibTask->FindObject("NbClustersOffline");
1086 TH1F *nbClustersStandalone = (TH1F *) listcalibTask->FindObject("NbClustersStandalone");
1087
1088 TH1F *nbTracklets = (TH1F *) listcalibTask->FindObject("NbTracklets");
1089 TH1F *nbTrackletsOffline = (TH1F *) listcalibTask->FindObject("NbTrackletsOffline");
1090 TH1F *nbTrackletsStandalone = (TH1F *) listcalibTask->FindObject("NbTrackletsStandalone");
1091
1092 TH2I *ch2d = (TH2I *) listcalibTask->FindObject("CH2d");
1093 TProfile2D *ph2d = (TProfile2D *) listcalibTask->FindObject("PH2d");
1094 TProfile2D *prf2d = (TProfile2D *) listcalibTask->FindObject("PRF2d");
1095
1096 TH2I *ch2dSum = (TH2I *) listcalibTask->FindObject("CH2dSum");
1097 TProfile2D *ph2dSum = (TProfile2D *) listcalibTask->FindObject("PH2dSum");
1098
1099 TH2I *ch2dSM = (TH2I *) listcalibTask->FindObject("CH2dSM");
1100 TProfile2D *ph2dSM = (TProfile2D *) listcalibTask->FindObject("PH2dSM");
1101
1102 AliTRDCalibraVdriftLinearFit *linearfit = (AliTRDCalibraVdriftLinearFit *) listcalibTask->FindObject("AliTRDCalibraVdriftLinearFit");
1103 AliTRDCalibraVector *calibraVector = (AliTRDCalibraVector *) listcalibTask->FindObject("AliTRDCalibraVector");
1104
1105 //
1106
1107 TH1I *inEvents = (TH1I *) fListHist->FindObject("NEvents");
1108 TH2F *iabsoluteGain = (TH2F *) fListHist->FindObject("AbsoluteGain");
1109
1110 TH1F *itrdTrack = (TH1F *) fListHist->FindObject("TRDTrack");
1111 TH1F *itrdTrackOffline = (TH1F *) fListHist->FindObject("TRDTrackOffline");
1112 TH1F *itrdTrackStandalone = (TH1F *) fListHist->FindObject("TRDTrackStandalone");
1113
1114 TH2F *itpctrdTrack = (TH2F *) fListHist->FindObject("NbTPCTRDtrack");
21185a48 1115
57185ead 1116 TH1F *inbTimeBin = (TH1F *) fListHist->FindObject("NbTimeBin");
1117 TH1F *inbTimeBinOffline = (TH1F *) fListHist->FindObject("NbTimeBinOffline");
1118 TH1F *inbTimeBinStandalone = (TH1F *) fListHist->FindObject("NbTimeBinStandalone");
1119
1120 TH1F *inbClusters = (TH1F *) fListHist->FindObject("NbClusters");
1121 TH1F *inbClustersOffline = (TH1F *) fListHist->FindObject("NbClustersOffline");
1122 TH1F *inbClustersStandalone = (TH1F *) fListHist->FindObject("NbClustersStandalone");
1123
1124 TH1F *inbTracklets = (TH1F *) fListHist->FindObject("NbTracklets");
1125 TH1F *inbTrackletsOffline = (TH1F *) fListHist->FindObject("NbTrackletsOffline");
1126 TH1F *inbTrackletsStandalone = (TH1F *) fListHist->FindObject("NbTrackletsStandalone");
1127
1128 TH2I *ich2d = (TH2I *) fListHist->FindObject("CH2d");
1129 TProfile2D *iph2d = (TProfile2D *) fListHist->FindObject("PH2d");
1130 TProfile2D *iprf2d = (TProfile2D *) fListHist->FindObject("PRF2d");
1131
1132 TH2I *ich2dSum = (TH2I *) fListHist->FindObject("CH2dSum");
1133 TProfile2D *iph2dSum = (TProfile2D *) fListHist->FindObject("PH2dSum");
1134
1135 TH2I *ich2dSM = (TH2I *) fListHist->FindObject("CH2dSM");
1136 TProfile2D *iph2dSM = (TProfile2D *) fListHist->FindObject("PH2dSM");
1137
1138 AliTRDCalibraVdriftLinearFit *ilinearfit = (AliTRDCalibraVdriftLinearFit *) fListHist->FindObject("AliTRDCalibraVdriftLinearFit");
1139 AliTRDCalibraVector *icalibraVector = (AliTRDCalibraVector *) fListHist->FindObject("AliTRDCalibraVector");
1140
1141
1142 // Add
1143
1144 if(nEvents) {
1145 if(inEvents) {
1146 inEvents->Add(nEvents);
1147 //printf("Add Events\n");
1148 }
1149 else {
1150 //printf("Create new Events\n");
1151 inEvents = new TH1I(*nEvents);
1152 fListHist->Add(inEvents);
1153 }
1154 }
1155
1156 if(absoluteGain) {
1157 if(iabsoluteGain) iabsoluteGain->Add(absoluteGain);
1158 else {
1159 iabsoluteGain = new TH2F(*absoluteGain);
1160 fListHist->Add(iabsoluteGain);
1161 }
1162 }
1163
1164 if(trdTrack) {
1165 if(itrdTrack) itrdTrack->Add(trdTrack);
1166 else {
1167 itrdTrack = new TH1F(*trdTrack);
1168 fListHist->Add(itrdTrack);
1169 }
1170 }
1171
1172 if(trdTrackOffline) {
1173 if(itrdTrackOffline) itrdTrackOffline->Add(trdTrackOffline);
1174 else {
1175 itrdTrackOffline = new TH1F(*trdTrackOffline);
1176 fListHist->Add(itrdTrackOffline);
1177 }
1178 }
1179
1180 if(trdTrackStandalone) {
1181 if(itrdTrackStandalone) itrdTrackStandalone->Add(trdTrackStandalone);
1182 else {
1183 itrdTrackStandalone = new TH1F(*trdTrackStandalone);
1184 fListHist->Add(itrdTrackStandalone);
1185 }
1186 }
1187
1188 if(tpctrdTrack) {
1189 if(itpctrdTrack) itpctrdTrack->Add(tpctrdTrack);
1190 else {
1191 itpctrdTrack = new TH2F(*tpctrdTrack);
1192 fListHist->Add(itpctrdTrack);
1193 }
1194 }
1195
1196 if(nbTimeBin) {
1197 if(inbTimeBin) inbTimeBin->Add(nbTimeBin);
1198 else {
1199 inbTimeBin = new TH1F(*inbTimeBin);
1200 fListHist->Add(inbTimeBin);
1201 }
1202 }
1203
1204 if(nbTimeBinOffline) {
1205 if(inbTimeBinOffline) inbTimeBinOffline->Add(nbTimeBinOffline);
1206 else {
1207 inbTimeBinOffline = new TH1F(*nbTimeBinOffline);
1208 fListHist->Add(inbTimeBinOffline);
1209 }
1210 }
1211
1212 if(nbTimeBinStandalone) {
1213 if(inbTimeBinStandalone) inbTimeBinStandalone->Add(nbTimeBinStandalone);
1214 else {
1215 inbTimeBinStandalone = new TH1F(*nbTimeBinStandalone);
1216 fListHist->Add(inbTimeBinStandalone);
1217 }
1218 }
1219
1220 if(nbClusters) {
1221 if(inbClusters) inbClusters->Add(nbClusters);
1222 else {
1223 inbClusters = new TH1F(*nbClusters);
1224 fListHist->Add(inbClusters);
1225 }
1226 }
1227
1228 if(nbClustersOffline) {
1229 if(inbClustersOffline) inbClustersOffline->Add(nbClustersOffline);
1230 else {
1231 inbClustersOffline = new TH1F(*nbClustersOffline);
1232 fListHist->Add(inbClustersOffline);
1233 }
1234 }
1235
1236 if(nbClustersStandalone) {
1237 if(inbClustersStandalone) inbClustersStandalone->Add(nbClustersStandalone);
1238 else {
1239 inbClustersStandalone = new TH1F(*nbClustersStandalone);
1240 fListHist->Add(inbClustersStandalone);
1241 }
1242 }
1243
1244 if(nbTracklets) {
1245 if(inbTracklets) inbTracklets->Add(nbTracklets);
1246 else {
1247 inbTracklets = new TH1F(*nbTracklets);
1248 fListHist->Add(inbTracklets);
1249 }
1250 }
1251
1252 if(nbTrackletsOffline) {
1253 if(inbTrackletsOffline) inbTrackletsOffline->Add(nbTrackletsOffline);
1254 else {
1255 inbTrackletsOffline = new TH1F(*nbTrackletsOffline);
1256 fListHist->Add(inbTrackletsOffline);
1257 }
1258 }
1259
1260 if(nbTrackletsStandalone) {
1261 if(inbTrackletsStandalone) inbTrackletsStandalone->Add(nbTrackletsStandalone);
1262 else {
1263 inbTrackletsStandalone = new TH1F(*nbTrackletsStandalone);
1264 fListHist->Add(inbTrackletsStandalone);
1265 }
1266 }
1267
1268 if(ch2d) {
1269 if(ich2d) ich2d->Add(ch2d);
1270 else {
1271 ich2d = new TH2I(*ch2d);
1272 fListHist->Add(ich2d);
1273 }
1274 }
1275
1276 if(ph2d) {
1277 if(iph2d) iph2d->Add(ph2d);
1278 else {
1279 iph2d = new TProfile2D(*ph2d);
1280 fListHist->Add(iph2d);
1281 }
1282 }
1283
1284 if(prf2d) {
1285 if(iprf2d) iprf2d->Add(prf2d);
1286 else {
1287 iprf2d = new TProfile2D(*prf2d);
1288 fListHist->Add(iprf2d);
1289 }
1290 }
1291
1292 if(ch2dSum) {
1293 if(ich2dSum) ich2dSum->Add(ch2dSum);
1294 else {
1295 ich2dSum = new TH2I(*ch2dSum);
1296 fListHist->Add(ich2dSum);
1297 }
1298 }
1299
1300 if(ph2dSum) {
1301 if(iph2dSum) iph2dSum->Add(ph2dSum);
1302 else {
1303 iph2dSum = new TProfile2D(*ph2dSum);
1304 fListHist->Add(iph2dSum);
1305 }
1306 }
1307
1308 if(ch2dSM) {
1309 if(ich2dSM) ich2dSM->Add(ch2dSM);
1310 else {
1311 ich2dSM = new TH2I(*ch2dSM);
1312 fListHist->Add(ich2dSM);
1313 }
1314 }
1315
1316 if(ph2dSM) {
1317 if(iph2dSM) iph2dSM->Add(ph2dSM);
1318 else {
1319 iph2dSM = new TProfile2D(*ph2dSM);
1320 fListHist->Add(iph2dSM);
1321 }
1322 }
1323
1324 if(linearfit) {
1325 if(ilinearfit) ilinearfit->Add(linearfit);
1326 else {
1327 ilinearfit = new AliTRDCalibraVdriftLinearFit(*linearfit);
1328 fListHist->Add(ilinearfit);
1329 }
1330 }
1331
1332 if(calibraVector) {
1333 if(icalibraVector) icalibraVector->Add(calibraVector);
1334 else {
1335 icalibraVector = new AliTRDCalibraVector(*calibraVector);
1336 fListHist->Add(icalibraVector);
1337 }
1338 }
1339
1340}
1341//________________________________________________________________________________
1342Long64_t AliTRDCalibTask::Merge(TCollection *li) {
1343
1344 //
1345 // merge component
1346 //
1347
1348 TIterator* iter = li->MakeIterator();
1349 AliTRDCalibTask* cal = 0;
1350
1351 while ((cal = (AliTRDCalibTask*)iter->Next())) {
1352 if (!cal->InheritsFrom(AliTRDCalibTask::Class())) {
1353 Error("Merge","Attempt to add object of class %s to a %s", cal->ClassName(), this->ClassName());
1354 return -1;
1355 }
1356
1357 // add histograms here...
1358 this->AddTask(cal);
1359
1360 }
1361
1362 return 0;
1363
1364}
a2a4ec8e 1365//_____________________________________________________
1366Bool_t AliTRDCalibTask::SetVersionSubversion(){
1367 //
1368 // Load Chamber Gain factors into the Tender supply
1369 //
1370
1371 printf("SetVersionSubversion\n");
1372
1373 //find previous entry from the UserInfo
1374 TTree *tree=((TChain*)GetInputData(0))->GetTree();
1375 if (!tree) {
1376 AliError("Tree not found in ESDhandler");
1377 return kFALSE;
1378 }
1379
1380 TList *userInfo=(TList*)tree->GetUserInfo();
1381 if (!userInfo) {
1382 AliError("No UserInfo found in tree");
1383 return kFALSE;
1384 }
1385
1386 TList *cdbList=(TList*)userInfo->FindObject("cdbList");
1387 if (!cdbList) {
1388 AliError("No cdbList found in UserInfo");
1389 if (AliLog::GetGlobalLogLevel()>=AliLog::kError) userInfo->Print();
1390 return kFALSE;
1391 }
1392
1393 TIter nextCDB(cdbList);
1394 TObjString *os=0x0;
1395 while ( (os=(TObjString*)nextCDB()) ){
1396 if(os->GetString().Contains("TRD/Calib/ChamberGainFactor")){
1397 // Get Old gain calibration
1398 AliCDBId *id=AliCDBId::MakeFromString(os->GetString());
1399 fVersionGainUsed = id->GetVersion();
1400 fSubVersionGainUsed = id->GetSubVersion();
1401 } else if(os->GetString().Contains("TRD/Calib/ChamberVdrift")){
1402 // Get Old drift velocity calibration
1403 AliCDBId *id=AliCDBId::MakeFromString(os->GetString());
1404 fVersionVdriftUsed = id->GetVersion();
1405 fSubVersionVdriftUsed = id->GetSubVersion();
1406 } else if(os->GetString().Contains("TRD/Calib/LocalGainFactor")){
1407 // Get Old drift velocity calibration
1408 AliCDBId *id=AliCDBId::MakeFromString(os->GetString());
1409 fVersionGainLocalUsed = id->GetVersion();
1410 fSubVersionGainLocalUsed = id->GetSubVersion();
1411 }
1412 }
1413
1414 //printf("VersionGain %d, SubversionGain %d, VersionLocalGain %d, Subversionlocalgain %d, Versionvdrift %d, Subversionvdrift %d\n",fVersionGainUsed,fSubVersionGainUsed,fVersionGainLocalUsed,fSubVersionGainLocalUsed,fVersionVdriftUsed,fSubVersionVdriftUsed);
1415
1416 // Check
1417 if((fVersionGainUsed < 0) || (fVersionGainLocalUsed < 0) || (fSubVersionGainUsed < 0) || (fSubVersionGainLocalUsed < 0) || (fVersionVdriftUsed < 0) || (fSubVersionVdriftUsed < 0)) {
1418 AliError("No recent calibration found");
1419 return kFALSE;
1420 }
1421 else return kTRUE;
1422
1423}
1424
01239968 1425