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