2 /**************************************************************************
3 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
5 * Author: The ALICE Off-line Project. *
6 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
17 /////////////////////////////////////////////////////////////////////////////////
21 // Offline TRD calibration task
24 // R. Bailhache (R.Bailhache@gsi.de)
26 //////////////////////////////////////////////////////////////////////////////////////
30 #include "Riostream.h"
34 #include "TProfile2D.h"
42 #include "TObjArray.h"
48 #include "TIterator.h"
49 #include "TLinearFitter.h"
52 #include "AliAnalysisTask.h"
53 #include "AliAnalysisManager.h"
55 #include "AliExternalTrackParam.h"
56 #include "AliESDVertex.h"
57 #include "AliESDEvent.h"
58 #include "AliESDfriend.h"
59 #include "AliCentrality.h"
60 #include "AliESDInputHandler.h"
61 #include "AliESDtrack.h"
62 #include "AliESDfriendTrack.h"
63 #include "AliTRDtrackV1.h"
64 #include "AliTRDseedV1.h"
65 #include "AliTRDcluster.h"
66 #include "AliTRDgeometry.h"
67 #include "AliESDtrackCuts.h"
68 #include "AliESDVertex.h"
69 #include "AliTRDCalDet.h"
71 #include "AliTRDCalibraVector.h"
72 #include "AliTRDCalibraFillHisto.h"
73 #include "AliTRDCalibraVdriftLinearFit.h"
74 #include "AliTRDCalibraExbAltFit.h"
76 #include "AliTRDcalibDB.h"
80 #include "AliTRDCalibChamberStatus.h"
82 #include "AliTRDCalibTask.h"
85 ClassImp(AliTRDCalibTask)
87 //________________________________________________________________________
88 AliTRDCalibTask::AliTRDCalibTask(const char *name)
89 : AliAnalysisTaskSE(name), fESD(0),
97 fTRDCalibraFillHisto(0),
102 fNbTRDTrackOffline(0),
103 fNbTRDTrackStandalone(0),
107 fNbTimeBinOffline(0),
108 fNbTimeBinStandalone(0),
110 fNbClustersOffline(0),
111 fNbClustersStandalone(0),
113 fNbTrackletsOffline(0),
114 fNbTrackletsStandalone(0),
122 fLinearVdriftTest(0),
126 fVdriftLinear(kTRUE),
129 fSelectedTrigger(new TObjArray()),
132 fRequirePrimaryVertex(kFALSE),
135 fMinNbContributors(0),
136 fRangePrimaryVertexZ(9999999.0),
142 fNormalizeNbOfCluster(kFALSE),
146 fOfflineTracks(kFALSE),
147 fStandaloneTracks(kFALSE),
149 fVersionGainUsed(-1),
150 fSubVersionGainUsed(-1),
151 fFirstRunGainLocal(-1),
152 fVersionGainLocalUsed(-1),
153 fSubVersionGainLocalUsed(-1),
155 fVersionVdriftUsed(-1),
156 fSubVersionVdriftUsed(-1),
159 fSubVersionExBUsed(-1),
166 // Default constructor
177 // Define input and output slots here
178 // Input slot #0 works with a TChain
179 DefineInput(0, TChain::Class());
181 // Output slot #0 writes into a TList container
182 DefineOutput(1, TList::Class());
186 //____________________________________________________________________________________
187 AliTRDCalibTask::~AliTRDCalibTask()
190 // AliTRDCalibTask destructor
194 if(fNEvents) delete fNEvents;
195 if(fNEventsInput) delete fNEventsInput;
196 if(fNbTRDTrack) delete fNbTRDTrack;
197 if(fNbTRDTrackOffline) delete fNbTRDTrackOffline;
198 if(fNbTRDTrackStandalone) delete fNbTRDTrackStandalone;
199 if(fNbTPCTRDtrack) delete fNbTPCTRDtrack;
200 if(fNbGoodTracks) delete fNbGoodTracks;
201 if(fNbTimeBin) delete fNbTimeBin;
202 if(fNbTimeBinOffline) delete fNbTimeBinOffline;
203 if(fNbTimeBinStandalone) delete fNbTimeBinStandalone;
204 if(fNbClusters) delete fNbClusters;
205 if(fNbClustersOffline) delete fNbClustersOffline;
206 if(fNbClustersStandalone) delete fNbClustersStandalone;
207 if(fNbTracklets) delete fNbTracklets;
208 if(fNbTrackletsOffline) delete fNbTrackletsOffline;
209 if(fNbTrackletsStandalone) delete fNbTrackletsStandalone;
210 if(fAbsoluteGain) delete fAbsoluteGain;
211 if(fCH2dSum) delete fCH2dSum;
212 if(fPH2dSum) delete fPH2dSum;
213 if(fCH2dSM) delete fCH2dSM;
214 if(fPH2dSM) delete fPH2dSM;
215 if(fCH2dTest) delete fCH2dTest;
216 if(fPH2dTest) delete fPH2dTest;
217 if(fLinearVdriftTest) delete fLinearVdriftTest;
218 if(fCalDetGain) delete fCalDetGain;
220 if(fSelectedTrigger) {
221 fSelectedTrigger->Delete();
222 delete fSelectedTrigger;
225 delete fEsdTrackCuts;
228 if(fTRDChamberStatus) delete fTRDChamberStatus;
232 //________________________________________________________________________
233 void AliTRDCalibTask::UserCreateOutputObjects()
238 //cout << "AliTRDCalibTask::CreateOutputObjects() IN" << endl;
240 // Number of time bins
242 AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
243 fNbTimeBins = cal->GetNumberOfTimeBinsDCS();
244 if(fNbTimeBins <= 0){
245 AliWarning(Form("No of TimeBins from DB [%d] use default [30]", fNbTimeBins));
251 fListHist = new TList();
252 fListHist->SetOwner();
254 // init chamber status
255 fTRDChamberStatus = new AliTRDCalibChamberStatus();
256 fTRDChamberStatus->Init();
257 fListHist->Add(fTRDChamberStatus->GetSparseI());
259 // instance calibration
260 fTRDCalibraFillHisto = AliTRDCalibraFillHisto::Instance();
262 fTRDCalibraFillHisto->SetHisto2d(fHisto2d); // choose to use histograms
263 fTRDCalibraFillHisto->SetVector2d(fVector2d); // choose to use vectors
264 fTRDCalibraFillHisto->SetCH2dOn(); // choose to calibrate the gain
265 fTRDCalibraFillHisto->SetPH2dOn(); // choose to calibrate the drift velocity
266 fTRDCalibraFillHisto->SetPRF2dOn(); // choose to look at the PRF
267 fTRDCalibraFillHisto->SetLinearFitterOn(fVdriftLinear); // Other possibility vdrift VDRIFT
268 fTRDCalibraFillHisto->SetLinearFitterDebugOn(fVdriftLinear); // Other possibility vdrift
269 fTRDCalibraFillHisto->SetExbAltFitOn(fExbAlt); // Alternative method for exb
270 for(Int_t k = 0; k < 3; k++){
271 if(((fNz[k] != 10) && (fNrphi[k] != 10)) && ((fNz[k] != 100) && (fNrphi[k] != 100))) {
272 fTRDCalibraFillHisto->SetNz(k,fNz[k]); // Mode calibration
273 fTRDCalibraFillHisto->SetNrphi(k,fNrphi[k]); // Mode calibration
276 if((fNz[k] == 100) && (fNrphi[k] == 100)) {
277 if(fVector2d) AliInfo("The mode all together is not supported by the vector method");
278 fTRDCalibraFillHisto->SetAllTogether(k);
280 if((fNz[k] == 10) && (fNrphi[k] == 10)) {
281 if(fVector2d) AliInfo("The mode per supermodule is not supported by the vector method");
282 fTRDCalibraFillHisto->SetPerSuperModule(k);
286 // Variables for how to fill
287 fTRDCalibraFillHisto->SetFillWithZero(fFillZero);
288 fTRDCalibraFillHisto->SetNormalizeNbOfCluster(fNormalizeNbOfCluster);
289 fTRDCalibraFillHisto->SetMaxCluster(fMaxCluster);
290 fTRDCalibraFillHisto->SetNbMaxCluster(fNbMaxCluster);
292 // Init with 30 timebins
293 fTRDCalibraFillHisto->Init2Dhistos(fNbTimeBins); // initialise the histos
294 fTRDCalibraFillHisto->SetNumberClusters(fLow); // At least 11 clusters
295 fTRDCalibraFillHisto->SetNumberClustersf(fHigh); // At least 11 clusters
298 if(fDebug > 2) fTRDCalibraFillHisto->SetDebugLevel(1); //debug stuff
301 fListHist->Add(fTRDCalibraFillHisto->GetCH2d());
302 fListHist->Add(fTRDCalibraFillHisto->GetPH2d());
303 fListHist->Add(fTRDCalibraFillHisto->GetPRF2d());
305 if(fVdriftLinear) fListHist->Add((TObject *)fTRDCalibraFillHisto->GetVdriftLinearFit());
306 if(fVector2d) fListHist->Add((TObject *) fTRDCalibraFillHisto->GetCalibraVector()); //calibra vector
307 if(fExbAlt) fListHist->Add((TObject *)fTRDCalibraFillHisto->GetExbAltFit());
309 fRelativeScale = fTRDCalibraFillHisto->GetRelativeScale(); // Get the relative scale for the gain
311 fNEvents = new TH1I(Form("NEvents_%s",(const char*)fName),"NEvents", 2, 0, 2);
312 fListHist->Add(fNEvents);
313 fNEventsInput = new TH1I(Form("NEventsInput_%s",(const char*)fName),"NEventsInput", 2, 0, 2);
314 fListHist->Add(fNEventsInput);
316 // absolute gain calibration even without AliESDfriend
318 Double_t minPt = 0.001;
319 Double_t maxPt = 10.0;
321 Double_t *binLimLogPt = new Double_t[nBinsPt+1];
322 Double_t *binLimPt = new Double_t[nBinsPt+1];
323 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 ;
324 for(Int_t i=0; i<=nBinsPt; i++) binLimPt[i]=(Double_t)TMath::Power(10,binLimLogPt[i]);
326 fAbsoluteGain = new TH2F(Form("AbsoluteGain_%s",(const char*)fName),"AbsoluteGain", 200, 0.0, 700.0, nBinsPt, binLimPt);
327 fAbsoluteGain->SetYTitle("Momentum at TRD");
328 fAbsoluteGain->SetXTitle("charge deposit [a.u]");
329 fAbsoluteGain->SetZTitle("counts");
330 fAbsoluteGain->SetStats(0);
331 fAbsoluteGain->Sumw2();
332 fListHist->Add(fAbsoluteGain);
334 /////////////////////////////////////////
336 ///////////////////////////////////////
339 fLinearVdriftTest = new TH2S(Form("LFDV0testversion_%s",(const char*)fName),"LFDV0testversion",36,-0.9,0.9,48,-1.2,1.2);
340 fLinearVdriftTest->SetXTitle("tan(phi_{track})");
341 fLinearVdriftTest->SetYTitle("dy/dt");
342 fLinearVdriftTest->SetZTitle("Number of tracklets");
343 fLinearVdriftTest->SetStats(0);
344 fLinearVdriftTest->SetDirectory(0);
346 // Standart with AliESDfriend
347 fPH2dTest = new TProfile2D(Form("PH2dTest_%s",(const char*)fName),"Nz0Nrphi0"
348 ,fNbTimeBins,-0.05,(Double_t)((fNbTimeBins-0.5)/10.0)
350 fPH2dTest->SetYTitle("Det/pad groups");
351 fPH2dTest->SetXTitle("time [#mus]");
352 fPH2dTest->SetZTitle("<PH> [a.u.]");
353 fPH2dTest->SetStats(0);
355 fCH2dTest = new TH2I(Form("CH2dTest_%s",(const char*)fName),"Nz0Nrphi0",50,0,300,540,0,540);
356 fCH2dTest->SetYTitle("Det/pad groups");
357 fCH2dTest->SetXTitle("charge deposit [a.u]");
358 fCH2dTest->SetZTitle("counts");
359 fCH2dTest->SetStats(0);
363 fPH2dSM = new TProfile2D(Form("PH2dSM_%s",(const char*)fName),"Nz10Nrphi10"
364 ,fNbTimeBins,-0.05,(Double_t)((fNbTimeBins-0.5)/10.0)
366 fPH2dSM->SetYTitle("Det/pad groups");
367 fPH2dSM->SetXTitle("time [#mus]");
368 fPH2dSM->SetZTitle("<PH> [a.u.]");
369 fPH2dSM->SetStats(0);
371 fCH2dSM = new TH2I(Form("CH2dSM_%s",(const char*)fName),"Nz10Nrphi10",50,0,300,18,0,18);
372 fCH2dSM->SetYTitle("Det/pad groups");
373 fCH2dSM->SetXTitle("charge deposit [a.u]");
374 fCH2dSM->SetZTitle("counts");
375 fCH2dSM->SetStats(0);
378 fPH2dSum = new TProfile2D(Form("PH2dSum_%s",(const char*)fName),"Nz100Nrphi100"
379 ,fNbTimeBins,-0.05,(Double_t)((fNbTimeBins-0.5)/10.0)
381 fPH2dSum->SetYTitle("Det/pad groups");
382 fPH2dSum->SetXTitle("time [#mus]");
383 fPH2dSum->SetZTitle("<PH> [a.u.]");
384 fPH2dSum->SetStats(0);
386 fCH2dSum = new TH2I(Form("CH2dSum_%s",(const char*)fName),"Nz100Nrphi100",50,0,300,1,0,1);
387 fCH2dSum->SetYTitle("Det/pad groups");
388 fCH2dSum->SetXTitle("charge deposit [a.u]");
389 fCH2dSum->SetZTitle("counts");
390 fCH2dSum->SetStats(0);
395 fListHist->Add(fLinearVdriftTest);
396 fListHist->Add(fPH2dTest);
397 fListHist->Add(fCH2dTest);
398 fListHist->Add(fPH2dSM);
399 fListHist->Add(fCH2dSM);
400 fListHist->Add(fPH2dSum);
401 fListHist->Add(fCH2dSum);
405 /////////////////////////////////////////
406 // Second debug level
407 ///////////////////////////////////////
410 fNbGoodTracks = new TH2F(Form("NbGoodTracks_%s",(const char*)fName),"NbGoodTracks",500,0.0,2500.0,200,0.0,100.0);
411 fNbGoodTracks->SetXTitle("Nb of good tracks");
412 fNbGoodTracks->SetYTitle("Centrality");
413 fNbGoodTracks->SetStats(0);
415 fNbTRDTrack = new TH1F(Form("TRDTrack_%s",(const char*)fName),"TRDTrack",50,0,50);
416 fNbTRDTrack->Sumw2();
417 fNbTRDTrackOffline = new TH1F(Form("TRDTrackOffline_%s",(const char*)fName),"TRDTrackOffline",50,0,50);
418 fNbTRDTrackOffline->Sumw2();
419 fNbTRDTrackStandalone = new TH1F(Form("TRDTrackStandalone_%s",(const char*)fName),"TRDTrackStandalone",50,0,50);
420 fNbTRDTrackStandalone->Sumw2();
421 fNbTPCTRDtrack = new TH2F(Form("NbTPCTRDtrack_%s",(const char*)fName),"NbTPCTRDtrack",100,0,100,100,0,100);
422 fNbTPCTRDtrack->Sumw2();
424 fNbTimeBin = new TH1F(Form("NbTimeBin_%s",(const char*)fName),"NbTimeBin",35,0,35);
426 fNbTimeBinOffline = new TH1F(Form("NbTimeBinOffline_%s",(const char*)fName),"NbTimeBinOffline",35,0,35);
427 fNbTimeBinOffline->Sumw2();
428 fNbTimeBinStandalone = new TH1F(Form("NbTimeBinStandalone_%s",(const char*)fName),"NbTimeBinStandalone",35,0,35);
429 fNbTimeBinStandalone->Sumw2();
431 fNbClusters = new TH1F(Form("NbClusters_%s",(const char*)fName),"",35,0,35);
432 fNbClusters->Sumw2();
433 fNbClustersOffline = new TH1F(Form("NbClustersOffline_%s",(const char*)fName),"",35,0,35);
434 fNbClustersOffline->Sumw2();
435 fNbClustersStandalone = new TH1F(Form("NbClustersStandalone_%s",(const char*)fName),"",35,0,35);
436 fNbClustersStandalone->Sumw2();
438 fNbTracklets = new TH1F(Form("NbTracklets_%s",(const char*)fName),"NbTracklets",540,0.,540.);
439 fNbTracklets->Sumw2();
440 fNbTrackletsOffline = new TH1F(Form("NbTrackletsOffline_%s",(const char*)fName),"NbTrackletsOffline",540,0.,540.);
441 fNbTrackletsOffline->Sumw2();
442 fNbTrackletsStandalone = new TH1F(Form("NbTrackletsStandalone_%s",(const char*)fName),"NbTrackletsStandalone",540,0.,540.);
443 fNbTrackletsStandalone->Sumw2();
445 fListHist->Add(fNbGoodTracks);
447 fListHist->Add(fNbTRDTrack);
448 fListHist->Add(fNbTRDTrackOffline);
449 fListHist->Add(fNbTRDTrackStandalone);
450 fListHist->Add(fNbTPCTRDtrack);
452 fListHist->Add(fNbTimeBin);
453 fListHist->Add(fNbTimeBinOffline);
454 fListHist->Add(fNbTimeBinStandalone);
455 fListHist->Add(fNbClusters);
456 fListHist->Add(fNbClustersOffline);
457 fListHist->Add(fNbClustersStandalone);
458 fListHist->Add(fNbTracklets);
459 fListHist->Add(fNbTrackletsOffline);
460 fListHist->Add(fNbTrackletsStandalone);
464 delete [] binLimLogPt;
467 PostData(1,fListHist);
469 //cout << "AliTRDCalibTask::UserCreateOutputObjects() OUT" << endl;
473 //________________________________________________________________________
474 void AliTRDCalibTask::UserExec(Option_t *)
477 // Filling of the histos
479 //cout << "AliTRDCalibTask::Exec() IN" << endl;
481 // Init Versions and subversions used
482 if((fFirstRunGain==-1) || (fVersionGainUsed==-1) || (fSubVersionGainUsed==-1) || (fFirstRunGainLocal==-1) || (fVersionGainLocalUsed==-1) || (fSubVersionGainLocalUsed==-1) || (fFirstRunVdrift==-1) || (fVersionVdriftUsed==-1) || (fSubVersionVdriftUsed==-1)) {
483 if(!SetVersionSubversion()) {
484 PostData(1, fListHist);
490 fTRDCalibraFillHisto->SetFirstRunGain(fFirstRunGain); // Gain Used
491 fTRDCalibraFillHisto->SetVersionGainUsed(fVersionGainUsed); // Gain Used
492 fTRDCalibraFillHisto->SetSubVersionGainUsed(fSubVersionGainUsed); // Gain Used
493 fTRDCalibraFillHisto->SetFirstRunGainLocal(fFirstRunGainLocal); // Gain Used
494 fTRDCalibraFillHisto->SetVersionGainLocalUsed(fVersionGainLocalUsed); // Gain Used
495 fTRDCalibraFillHisto->SetSubVersionGainLocalUsed(fSubVersionGainLocalUsed); // Gain Used
496 fTRDCalibraFillHisto->SetFirstRunVdrift(fFirstRunVdrift); // Vdrift Used
497 fTRDCalibraFillHisto->SetVersionVdriftUsed(fVersionVdriftUsed); // Vdrift Used
498 fTRDCalibraFillHisto->SetSubVersionVdriftUsed(fSubVersionVdriftUsed); // Vdrift Used
499 if((fFirstRunExB != -1) && (fVersionExBUsed != -1) && (fSubVersionExBUsed != -1)){
500 fTRDCalibraFillHisto->SetFirstRunExB(fFirstRunExB); // ExB Used
501 fTRDCalibraFillHisto->SetVersionExBUsed(fVersionExBUsed); // ExB Used
502 fTRDCalibraFillHisto->SetSubVersionExBUsed(fSubVersionExBUsed); // ExB Used
504 fTRDCalibraFillHisto->InitCalDet();
509 name += fVersionGainUsed;
511 name += fSubVersionGainUsed;
513 name += fFirstRunGain;
515 fCH2dTest->SetTitle(name);
517 TString namee("Ver");
518 namee += fVersionVdriftUsed;
520 namee += fSubVersionVdriftUsed;
522 namee += fFirstRunVdrift;
523 namee += "Nz0Nrphi0";
524 fPH2dTest->SetTitle(namee);
528 // AliLog::SetGlobalLogLevel(AliLog::kError);
529 // cout << "AliTRDCalibTask::Exec() 1" << endl;
530 fESD = dynamic_cast<AliESDEvent*>(fInputEvent);
532 AliError("ESD Event missing");
533 PostData(1, fListHist);
537 const char* type = fESD->GetBeamType();
540 //printf("Counter %d\n",fCounter);
543 fNEventsInput->Fill(1);
545 //cout << "maxEvent = " << fMaxEvent << endl;
546 //if(fCounter%100==0) cout << "fCounter = " << fCounter << endl;
547 if((fMaxEvent != 0) && (fMaxEvent < fCounter)) {
548 PostData(1, fListHist);
551 //if(fCounter%100==0) cout << "fCounter1 = " << fCounter << endl;
552 //cout << "event = " << fCounter << endl;
554 //printf("Counter %d\n",fCounter);
561 if (strstr(type,"p-p")) {
563 //printf("Will check the triggers\n");
565 Int_t numberOfTriggerSelected = fSelectedTrigger->GetEntriesFast();
566 //printf("numberofTriggerSelected %d\n",numberOfTriggerSelected);
569 for(Int_t k = 0; k < numberOfTriggerSelected; k++){
570 const TObjString *const obString=(TObjString*)fSelectedTrigger->At(k);
571 const TString tString=obString->GetString();
572 if(fESD->IsTriggerClassFired((const char*)tString)) {
579 for(Int_t k = 0; k < numberOfTriggerSelected; k++){
580 const TObjString *const obString=(TObjString*)fSelectedTrigger->At(k);
581 const TString tString=obString->GetString();
582 if(fESD->IsTriggerClassFired((const char*)tString)) {
588 PostData(1, fListHist);
594 //printf("Class Fired %s\n",(const char*)fESD->GetFiredTriggerClasses());
595 //printf("Trigger passed\n");
597 ///////////////////////////////
598 // Require a primary vertex
599 //////////////////////////////
600 if(fRequirePrimaryVertex) {
601 const AliESDVertex* vtxESD = 0x0;
602 if (fVtxTPC) vtxESD = fESD->GetPrimaryVertexTPC() ;
603 else if (fVtxSPD) vtxESD = fESD->GetPrimaryVertexSPD() ;
604 else vtxESD = fESD->GetPrimaryVertexTracks() ;
606 PostData(1, fListHist);
609 Int_t nCtrb = vtxESD->GetNContributors();
610 if(nCtrb < fMinNbContributors) {
611 PostData(1, fListHist);
614 Double_t zPosition = vtxESD->GetZ();
615 if(TMath::Abs(zPosition) > fRangePrimaryVertexZ) {
616 PostData(1, fListHist);
622 //printf("Primary vertex passed\n");
624 //////////////////////////////////////
625 // Requirement on number of good tracks
626 //////////////////////////////////////
627 Int_t nGoodParticles = 0;
628 Double_t nbTracks = fESD->GetNumberOfTracks();
629 for(Int_t itrack = 0; itrack < nbTracks; itrack++) {
630 if(ParticleGood(itrack)) nGoodParticles++;
634 AliCentrality *esdCentrality = fESD->GetCentrality();
635 Float_t centrality = esdCentrality->GetCentralityPercentile("V0M");
636 //Float_t centralityb = esdCentrality->GetCentralityPercentile("CL1");
637 fNbGoodTracks->Fill(nGoodParticles,centrality);
638 //printf("centrality %f, centralityb %f\n",centrality,centralityb);
641 //printf("Beam type %s\n",(const char*)type);
642 if (!strstr(type,"p-p")) {
643 //if (strstr(type,"A-A")) {
644 //printf("Will check the number of good tracks %f %f %f\n",nGoodParticles,fMinNbTracks,fMaxNbTracks);
645 if((nGoodParticles < fMinNbTracks) || (nGoodParticles > fMaxNbTracks)) {
646 PostData(1, fListHist);
654 Int_t nbTrdTracks = 0;
656 Int_t nbTrdTracksStandalone = 0;
658 Int_t nbTrdTracksOffline = 0;
660 Int_t nbtrackTPC = 0;
664 if (nbTracks <= 0.0) {
667 fNbTRDTrack->Fill(nbTrdTracks);
668 fNbTRDTrackStandalone->Fill(nbTrdTracksStandalone);
669 fNbTRDTrackOffline->Fill(nbTrdTracksOffline);
671 PostData(1, fListHist);
676 fESDfriend = dynamic_cast<AliESDfriend*> (fESD->FindListObject("AliESDfriend"));
678 AliError("fESDfriend not available");
679 PostData(1, fListHist);
683 if(fESDfriend->TestSkipBit()) {
684 PostData(1, fListHist);
688 //printf("has friends\n");
690 /////////////////////////////////////
691 // Loop on AliESDtrack
692 ////////////////////////////////////
693 //printf("Nb of tracks %f\n",nbTracks);
694 for(int itrk=0; itrk < nbTracks; ++itrk){
697 fkEsdTrack = fESD->GetTrack(itrk);
698 if(!fkEsdTrack) continue;
699 ULong_t status = fkEsdTrack->GetStatus();
700 if(status&(AliESDtrack::kTPCout)) ++nbtrackTPC;
702 fFriendTrack = fESDfriend->GetTrack(itrk);
704 //printf("No friend track %d\n",itrk);
711 Bool_t standalonetrack = kFALSE;
712 Bool_t offlinetrack = kFALSE;
713 //ULong_t status = fkEsdTrack->GetStatus();
715 //////////////////////////////////////
716 // Loop on calibration objects
717 //////////////////////////////////////
720 while((fCalibObject = (TObject *)(fFriendTrack->GetCalibObject(icalib++)))){
721 //printf("Name %s\n",fCalibObject->IsA()->GetName());
722 if(strcmp(fCalibObject->IsA()->GetName(), "AliTRDtrackV1") != 0) continue;
723 //printf("Find the calibration object\n");
726 if((status&(AliESDtrack::kTRDout)) && (!(status&(AliESDtrack::kTRDin)))) {
727 standalonetrack = kTRUE;
729 if((status&(AliESDtrack::kTRDin))) {
730 offlinetrack = kTRUE;
737 else if(fStandaloneTracks){
738 if(!standalonetrack){
743 fTrdTrack = (AliTRDtrackV1 *)fCalibObject;
744 // process chamberstatus
745 fTRDChamberStatus->ProcessTrack(fTrdTrack);
748 // Quality cuts on the AliESDtrack
749 if((fEsdTrackCuts) && (!fEsdTrackCuts->IsSelected((AliVParticle *)fkEsdTrack))) {
750 //printf("Not a good track\n");
754 // First Absolute gain calibration
755 Int_t trdNTracklets = (Int_t) fkEsdTrack->GetTRDntracklets();
756 Int_t trdNTrackletsPID = (Int_t) fkEsdTrack->GetTRDntrackletsPID();
757 //printf("Number of trd tracklets %d and PID trd tracklets %d\n",trdNTracklets,trdNTrackletsPID);
758 if((trdNTracklets > 0) && (trdNTrackletsPID > 0)) {
759 for(Int_t iPlane = 0; iPlane < 6; ++iPlane){
760 //Double_t slide = fkEsdTrack->GetTRDslice(iPlane);
761 //printf("Number of slide %d\n",fkEsdTrack->GetNumberOfTRDslices());
762 //Double_t momentum = fkEsdTrack->GetTRDmomentum(iPlane);
763 //printf("momentum %f, slide %f\n",momentum,slide);
764 if(fkEsdTrack->GetTRDslice(iPlane) > 0.0)
765 fAbsoluteGain->Fill(fkEsdTrack->GetTRDslice(iPlane)*8.0/100.0,
766 fkEsdTrack->GetTRDmomentum(iPlane));
771 if(!fTrdTrack) continue;
773 if(good && fOnInstance) {
774 //cout << "good" << endl;
775 fTRDCalibraFillHisto->UpdateHistogramsV1(fTrdTrack);
776 //printf("Fill fTRDCalibraFillHisto\n");
781 //////////////////////////////////
783 ////////////////////////////////
787 //printf("Enter debug\n");
789 Int_t nbtracklets = 0;
792 Bool_t standalonetracklet = kFALSE;
793 const AliTRDseedV1 *tracklet = 0x0;
794 //////////////////////////////////////
796 /////////////////////////////////////
798 Double_t phtb[AliTRDseedV1::kNtb];
799 memset(phtb, 0, AliTRDseedV1::kNtb*sizeof(Double_t));
801 Float_t normalisation = 1.13;
804 for(Int_t itr = 0; itr < 6; ++itr){
806 if(!(tracklet = fTrdTrack->GetTracklet(itr))) continue;
807 if(!tracklet->IsOK()) continue;
809 standalonetracklet = kFALSE;
810 if(tracklet->IsStandAlone()) standalonetracklet = kTRUE;
813 memset(phtb, 0, AliTRDseedV1::kNtb*sizeof(Double_t));
817 //Int_t crossrow = 0;
819 // Check no shared clusters
820 //for(int icc=AliTRDseedV1::kNtb; icc<AliTRDseedV1::kNclusters; icc++){
821 // if((fcl = tracklet->GetClusters(icc))) crossrow = 1;
828 for(int ic=0; ic<AliTRDseedV1::kNtb; ++ic){
830 if(!(fCl = tracklet->GetClusters(ic))) continue;
832 time = fCl->GetPadTime();
833 //ch = tracklet->GetdQdl(ic);
834 ch = tracklet->GetQperTB(ic);
835 qcl = TMath::Abs(fCl->GetQ());
836 detector = fCl->GetDetector();
837 // Add the charge if shared cluster
838 if((ic+AliTRDseedV1::kNtb) < AliTRDseedV1::kNclusters) {
839 if((fCl = tracklet->GetClusters(ic+AliTRDseedV1::kNtb))) {
840 qcl += TMath::Abs(fCl->GetQ());
841 //printf("Add the cluster charge\n");
844 if((time>-1) && (time<fNbTimeBins)) phtb[time]=qcl;
845 if((fCalDetGain) && (fCalDetGain->GetValue(detector) > 0.0)) sum += ch*fCalDetGain->GetValue(detector)/normalisation;
846 else sum += ch/normalisation;
849 fNbTimeBin->Fill(time);
850 if(tracklet->IsStandAlone()) fNbTimeBinStandalone->Fill(time);
851 else fNbTimeBinOffline->Fill(time);
854 sector = AliTRDgeometry::GetSector(detector);
857 fNbTracklets->Fill(detector);
858 if(tracklet->IsStandAlone()) fNbTrackletsStandalone->Fill(detector);
859 else fNbTrackletsOffline->Fill(detector);
861 fNbClusters->Fill(nbclusters);
862 if(tracklet->IsStandAlone()) fNbClustersStandalone->Fill(nbclusters);
863 else fNbClustersOffline->Fill(nbclusters);
866 if((nbclusters > fLow) && (nbclusters < fHigh)){
867 if(fRelativeScale > 0.0) sum = sum/fRelativeScale;
868 fCH2dTest->Fill(sum,detector+0.5);
869 fCH2dSM->Fill(sum,sector+0.5);
870 fCH2dSum->Fill(sum,0.5);
871 Bool_t checknoise = kTRUE;
872 if(fMaxCluster > 0) {
873 if(phtb[0] > fMaxCluster) checknoise = kFALSE;
874 if(fNbTimeBins > fNbMaxCluster) {
875 for(Int_t k = (fNbTimeBins-fNbMaxCluster); k < fNbTimeBins; k++){
876 if(phtb[k] > fMaxCluster) checknoise = kFALSE;
881 for(int ic=0; ic<fNbTimeBins; ic++){
883 fPH2dTest->Fill((Double_t)(ic/10.0),detector+0.5,(Double_t)phtb[ic]);
884 fPH2dSum->Fill((Double_t)(ic/10.0),0.5,(Double_t)phtb[ic]);
885 fPH2dSM->Fill((Double_t)(ic/10.0),sector+0.5,(Double_t)phtb[ic]);
889 fPH2dTest->Fill((Double_t)(ic/10.0),detector+0.5,(Double_t)phtb[ic]);
890 fPH2dSum->Fill((Double_t)(ic/10.0),0.0,(Double_t)phtb[ic]);
891 fPH2dSM->Fill((Double_t)(ic/10.0),sector+0.5,(Double_t)phtb[ic]);
897 if(detector == 0) FindP1TrackPHtrackletV1Test(tracklet,nbclusters);
899 } // loop on tracklets
904 if(nTRDtrackV1 > 0) {
906 if((status&(AliESDtrack::kTRDout)) && (!(status&(AliESDtrack::kTRDin)))) {
907 ++nbTrdTracksStandalone;
909 if((status&(AliESDtrack::kTRDin))) {
910 ++nbTrdTracksOffline;
913 //delete fFriendTrack;
917 fNbTRDTrack->Fill(nbTrdTracks);
918 fNbTRDTrackStandalone->Fill(nbTrdTracksStandalone);
919 fNbTRDTrackOffline->Fill(nbTrdTracksOffline);
920 fNbTPCTRDtrack->Fill(nbTrdTracks,nbtrackTPC);
924 PostData(1, fListHist);
925 //cout << "AliTRDCalibTask::Exec() OUT" << endl;
928 //________________________________________________________________________
929 void AliTRDCalibTask::Terminate(Option_t *)
935 if(fTRDCalibraFillHisto) fTRDCalibraFillHisto->DestroyDebugStreamer();
939 //_______________________________________________________
940 Bool_t AliTRDCalibTask::Load(const Char_t *filename)
943 // Generic container loader
946 if(!TFile::Open(filename)){
947 //AliWarning(Form("Couldn't open file %s.", filename));
951 if(!(o = (TList*)gFile->Get(GetName()))){
952 //AliWarning("Missing histogram container.");
955 fListHist = (TList*)o->Clone(GetName());
959 //_______________________________________________________
960 Bool_t AliTRDCalibTask::Load(TList *lister)
963 // Generic container loader
966 fListHist = (TList*)lister->Clone(GetName());
969 //_______________________________________________________________________________________
970 void AliTRDCalibTask::AddTask(const AliTRDCalibTask * calibTask) {
976 TList *listcalibTask = calibTask->GetList();
977 if(!listcalibTask) return;
979 THnSparseI *histoEntries = (THnSparseI *) listcalibTask->FindObject("NumberOfEntries");
981 TH1I *nEvents = (TH1I *) listcalibTask->FindObject(Form("NEvents_%s",(const char*)calibTask->GetName()));
982 TH1I *nEventsInput = (TH1I *) listcalibTask->FindObject(Form("NEventsInput_%s",(const char*)calibTask->GetName()));
983 TH2F *absoluteGain = (TH2F *) listcalibTask->FindObject(Form("AbsoluteGain_%s",(const char*)calibTask->GetName()));
985 TH1F *trdTrack = (TH1F *) listcalibTask->FindObject(Form("TRDTrack_%s",(const char*)calibTask->GetName()));
986 TH1F *trdTrackOffline = (TH1F *) listcalibTask->FindObject(Form("TRDTrackOffline_%s",(const char*)calibTask->GetName()));
987 TH1F *trdTrackStandalone = (TH1F *) listcalibTask->FindObject(Form("TRDTrackStandalone_%s",(const char*)calibTask->GetName()));
989 TH2F *tpctrdTrack = (TH2F *) listcalibTask->FindObject(Form("NbTPCTRDtrack_%s",(const char*)calibTask->GetName()));
991 TH1F *nbTimeBin = (TH1F *) listcalibTask->FindObject(Form("NbTimeBin_%s",(const char*)calibTask->GetName()));
992 TH1F *nbTimeBinOffline = (TH1F *) listcalibTask->FindObject(Form("NbTimeBinOffline_%s",(const char*)calibTask->GetName()));
993 TH1F *nbTimeBinStandalone = (TH1F *) listcalibTask->FindObject(Form("NbTimeBinStandalone_%s",(const char*)calibTask->GetName()));
995 TH1F *nbClusters = (TH1F *) listcalibTask->FindObject(Form("NbClusters_%s",(const char*)calibTask->GetName()));
996 TH1F *nbClustersOffline = (TH1F *) listcalibTask->FindObject(Form("NbClustersOffline_%s",(const char*)calibTask->GetName()));
997 TH1F *nbClustersStandalone = (TH1F *) listcalibTask->FindObject(Form("NbClustersStandalone_%s",(const char*)calibTask->GetName()));
999 TH1F *nbTracklets = (TH1F *) listcalibTask->FindObject(Form("NbTracklets_%s",(const char*)calibTask->GetName()));
1000 TH1F *nbTrackletsOffline = (TH1F *) listcalibTask->FindObject(Form("NbTrackletsOffline_%s",(const char*)calibTask->GetName()));
1001 TH1F *nbTrackletsStandalone = (TH1F *) listcalibTask->FindObject(Form("NbTrackletsStandalone_%s",(const char*)calibTask->GetName()));
1003 TH2I *ch2d = (TH2I *) listcalibTask->FindObject("CH2d");
1004 TProfile2D *ph2d = (TProfile2D *) listcalibTask->FindObject("PH2d");
1005 TProfile2D *prf2d = (TProfile2D *) listcalibTask->FindObject("PRF2d");
1007 TH2I *ch2dSum = (TH2I *) listcalibTask->FindObject(Form("CH2dSum_%s",(const char*)calibTask->GetName()));
1008 TProfile2D *ph2dSum = (TProfile2D *) listcalibTask->FindObject(Form("PH2dSum_%s",(const char*)calibTask->GetName()));
1010 TH2I *ch2dSM = (TH2I *) listcalibTask->FindObject(Form("CH2dSM_%s",(const char*)calibTask->GetName()));
1011 TProfile2D *ph2dSM = (TProfile2D *) listcalibTask->FindObject(Form("PH2dSM_%s",(const char*)calibTask->GetName()));
1013 AliTRDCalibraVdriftLinearFit *linearfit = (AliTRDCalibraVdriftLinearFit *) listcalibTask->FindObject("AliTRDCalibraVdriftLinearFit");
1014 AliTRDCalibraExbAltFit *exbaltfit = (AliTRDCalibraExbAltFit *) listcalibTask->FindObject("AliTRDCalibraExbAltFit");
1015 AliTRDCalibraVector *calibraVector = (AliTRDCalibraVector *) listcalibTask->FindObject("AliTRDCalibraVector");
1019 THnSparseI *inhistoEntries = (THnSparseI *) fListHist->FindObject("NumberOfEntries");
1021 TH1I *inEventsInput = (TH1I *) fListHist->FindObject(Form("NEventsInput_%s",(const char*)fName));
1022 TH1I *inEvents = (TH1I *) fListHist->FindObject(Form("NEvents_%s",(const char*)fName));
1023 TH2F *iabsoluteGain = (TH2F *) fListHist->FindObject(Form("AbsoluteGain_%s",(const char*)fName));
1025 TH1F *itrdTrack = (TH1F *) fListHist->FindObject(Form("TRDTrack_%s",(const char*)fName));
1026 TH1F *itrdTrackOffline = (TH1F *) fListHist->FindObject(Form("TRDTrackOffline_%s",(const char*)fName));
1027 TH1F *itrdTrackStandalone = (TH1F *) fListHist->FindObject(Form("TRDTrackStandalone_%s",(const char*)fName));
1029 TH2F *itpctrdTrack = (TH2F *) fListHist->FindObject(Form("NbTPCTRDtrack_%s",(const char*)fName));
1031 TH1F *inbTimeBin = (TH1F *) fListHist->FindObject(Form("NbTimeBin_%s",(const char*)fName));
1032 TH1F *inbTimeBinOffline = (TH1F *) fListHist->FindObject(Form("NbTimeBinOffline_%s",(const char*)fName));
1033 TH1F *inbTimeBinStandalone = (TH1F *) fListHist->FindObject(Form("NbTimeBinStandalone_%s",(const char*)fName));
1035 TH1F *inbClusters = (TH1F *) fListHist->FindObject(Form("NbClusters_%s",(const char*)fName));
1036 TH1F *inbClustersOffline = (TH1F *) fListHist->FindObject(Form("NbClustersOffline_%s",(const char*)fName));
1037 TH1F *inbClustersStandalone = (TH1F *) fListHist->FindObject(Form("NbClustersStandalone_%s",(const char*)fName));
1039 TH1F *inbTracklets = (TH1F *) fListHist->FindObject(Form("NbTracklets_%s",(const char*)fName));
1040 TH1F *inbTrackletsOffline = (TH1F *) fListHist->FindObject(Form("NbTrackletsOffline_%s",(const char*)fName));
1041 TH1F *inbTrackletsStandalone = (TH1F *) fListHist->FindObject(Form("NbTrackletsStandalone_%s",(const char*)fName));
1043 TH2I *ich2d = (TH2I *) fListHist->FindObject("CH2d");
1044 TProfile2D *iph2d = (TProfile2D *) fListHist->FindObject("PH2d");
1045 TProfile2D *iprf2d = (TProfile2D *) fListHist->FindObject("PRF2d");
1047 TH2I *ich2dSum = (TH2I *) fListHist->FindObject(Form("CH2dSum_%s",(const char*)fName));
1048 TProfile2D *iph2dSum = (TProfile2D *) fListHist->FindObject(Form("PH2dSum_%s",(const char*)fName));
1050 TH2I *ich2dSM = (TH2I *) fListHist->FindObject(Form("CH2dSM_%s",(const char*)fName));
1051 TProfile2D *iph2dSM = (TProfile2D *) fListHist->FindObject(Form("PH2dSM_%s",(const char*)fName));
1053 AliTRDCalibraVdriftLinearFit *ilinearfit = (AliTRDCalibraVdriftLinearFit *) fListHist->FindObject("AliTRDCalibraVdriftLinearFit");
1054 AliTRDCalibraExbAltFit *iexbaltfit = (AliTRDCalibraExbAltFit *) fListHist->FindObject("AliTRDCalibraExbAltFit");
1055 AliTRDCalibraVector *icalibraVector = (AliTRDCalibraVector *) fListHist->FindObject("AliTRDCalibraVector");
1061 if(inhistoEntries) {
1062 inhistoEntries->Add(histoEntries);
1063 //printf("Add Events\n");
1066 //printf("Create new Events\n");
1067 inhistoEntries = (THnSparseI *) histoEntries->Clone();
1068 fListHist->Add(inhistoEntries);
1074 inEventsInput->Add(nEventsInput);
1075 //printf("Add Events\n");
1078 //printf("Create new Events\n");
1079 inEventsInput = new TH1I(*nEventsInput);
1080 fListHist->Add(inEventsInput);
1086 inEvents->Add(nEvents);
1087 //printf("Add Events\n");
1090 //printf("Create new Events\n");
1091 inEvents = new TH1I(*nEvents);
1092 fListHist->Add(inEvents);
1097 if(iabsoluteGain) iabsoluteGain->Add(absoluteGain);
1099 iabsoluteGain = new TH2F(*absoluteGain);
1100 fListHist->Add(iabsoluteGain);
1105 if(itrdTrack) itrdTrack->Add(trdTrack);
1107 itrdTrack = new TH1F(*trdTrack);
1108 fListHist->Add(itrdTrack);
1112 if(trdTrackOffline) {
1113 if(itrdTrackOffline) itrdTrackOffline->Add(trdTrackOffline);
1115 itrdTrackOffline = new TH1F(*trdTrackOffline);
1116 fListHist->Add(itrdTrackOffline);
1120 if(trdTrackStandalone) {
1121 if(itrdTrackStandalone) itrdTrackStandalone->Add(trdTrackStandalone);
1123 itrdTrackStandalone = new TH1F(*trdTrackStandalone);
1124 fListHist->Add(itrdTrackStandalone);
1129 if(itpctrdTrack) itpctrdTrack->Add(tpctrdTrack);
1131 itpctrdTrack = new TH2F(*tpctrdTrack);
1132 fListHist->Add(itpctrdTrack);
1137 if(inbTimeBin) inbTimeBin->Add(nbTimeBin);
1139 inbTimeBin = new TH1F(*inbTimeBin);
1140 fListHist->Add(inbTimeBin);
1144 if(nbTimeBinOffline) {
1145 if(inbTimeBinOffline) inbTimeBinOffline->Add(nbTimeBinOffline);
1147 inbTimeBinOffline = new TH1F(*nbTimeBinOffline);
1148 fListHist->Add(inbTimeBinOffline);
1152 if(nbTimeBinStandalone) {
1153 if(inbTimeBinStandalone) inbTimeBinStandalone->Add(nbTimeBinStandalone);
1155 inbTimeBinStandalone = new TH1F(*nbTimeBinStandalone);
1156 fListHist->Add(inbTimeBinStandalone);
1161 if(inbClusters) inbClusters->Add(nbClusters);
1163 inbClusters = new TH1F(*nbClusters);
1164 fListHist->Add(inbClusters);
1168 if(nbClustersOffline) {
1169 if(inbClustersOffline) inbClustersOffline->Add(nbClustersOffline);
1171 inbClustersOffline = new TH1F(*nbClustersOffline);
1172 fListHist->Add(inbClustersOffline);
1176 if(nbClustersStandalone) {
1177 if(inbClustersStandalone) inbClustersStandalone->Add(nbClustersStandalone);
1179 inbClustersStandalone = new TH1F(*nbClustersStandalone);
1180 fListHist->Add(inbClustersStandalone);
1185 if(inbTracklets) inbTracklets->Add(nbTracklets);
1187 inbTracklets = new TH1F(*nbTracklets);
1188 fListHist->Add(inbTracklets);
1192 if(nbTrackletsOffline) {
1193 if(inbTrackletsOffline) inbTrackletsOffline->Add(nbTrackletsOffline);
1195 inbTrackletsOffline = new TH1F(*nbTrackletsOffline);
1196 fListHist->Add(inbTrackletsOffline);
1200 if(nbTrackletsStandalone) {
1201 if(inbTrackletsStandalone) inbTrackletsStandalone->Add(nbTrackletsStandalone);
1203 inbTrackletsStandalone = new TH1F(*nbTrackletsStandalone);
1204 fListHist->Add(inbTrackletsStandalone);
1209 if(ich2d) ich2d->Add(ch2d);
1211 ich2d = new TH2I(*ch2d);
1212 fListHist->Add(ich2d);
1217 if(iph2d) iph2d->Add(ph2d);
1219 iph2d = new TProfile2D(*ph2d);
1220 fListHist->Add(iph2d);
1225 if(iprf2d) iprf2d->Add(prf2d);
1227 iprf2d = new TProfile2D(*prf2d);
1228 fListHist->Add(iprf2d);
1233 if(ich2dSum) ich2dSum->Add(ch2dSum);
1235 ich2dSum = new TH2I(*ch2dSum);
1236 fListHist->Add(ich2dSum);
1241 if(iph2dSum) iph2dSum->Add(ph2dSum);
1243 iph2dSum = new TProfile2D(*ph2dSum);
1244 fListHist->Add(iph2dSum);
1249 if(ich2dSM) ich2dSM->Add(ch2dSM);
1251 ich2dSM = new TH2I(*ch2dSM);
1252 fListHist->Add(ich2dSM);
1257 if(iph2dSM) iph2dSM->Add(ph2dSM);
1259 iph2dSM = new TProfile2D(*ph2dSM);
1260 fListHist->Add(iph2dSM);
1265 if(ilinearfit) ilinearfit->Add(linearfit);
1267 ilinearfit = new AliTRDCalibraVdriftLinearFit(*linearfit);
1268 fListHist->Add(ilinearfit);
1273 if(iexbaltfit) iexbaltfit->Add(exbaltfit);
1275 iexbaltfit = new AliTRDCalibraExbAltFit(*exbaltfit);
1276 fListHist->Add(iexbaltfit);
1281 if(icalibraVector) icalibraVector->Add(calibraVector);
1283 icalibraVector = new AliTRDCalibraVector(*calibraVector);
1284 fListHist->Add(icalibraVector);
1289 //________________________________________________________________________________
1290 Long64_t AliTRDCalibTask::Merge(TCollection *li) {
1296 TIterator* iter = li->MakeIterator();
1297 AliTRDCalibTask* cal = 0;
1299 while ((cal = (AliTRDCalibTask*)iter->Next())) {
1300 if (!cal->InheritsFrom(AliTRDCalibTask::Class())) {
1301 Error("Merge","Attempt to add object of class %s to a %s", cal->ClassName(), this->ClassName());
1305 // add histograms here...
1313 //_____________________________________________________
1314 Bool_t AliTRDCalibTask::SetVersionSubversion(){
1316 // Load Chamber Gain factors into the Tender supply
1319 printf("SetVersionSubversion\n");
1321 //find previous entry from the UserInfo
1322 TTree *tree=((TChain*)GetInputData(0))->GetTree();
1324 AliError("Tree not found in ESDhandler");
1328 TList *userInfo=(TList*)tree->GetUserInfo();
1330 AliError("No UserInfo found in tree");
1334 TList *cdbList=(TList*)userInfo->FindObject("cdbList");
1336 AliError("No cdbList found in UserInfo");
1337 if (AliLog::GetGlobalLogLevel()>=AliLog::kError) userInfo->Print();
1341 TIter nextCDB(cdbList);
1343 while ( (os=(TObjString*)nextCDB()) ){
1344 if(os->GetString().Contains("TRD/Calib/ChamberGainFactor")){
1345 // Get Old gain calibration
1346 AliCDBId *id=AliCDBId::MakeFromString(os->GetString());
1347 fFirstRunGain = id->GetFirstRun();
1348 fVersionGainUsed = id->GetVersion();
1349 fSubVersionGainUsed = id->GetSubVersion();
1350 } else if(os->GetString().Contains("TRD/Calib/ChamberVdrift")){
1351 // Get Old drift velocity calibration
1352 AliCDBId *id=AliCDBId::MakeFromString(os->GetString());
1353 fFirstRunVdrift = id->GetFirstRun();
1354 fVersionVdriftUsed = id->GetVersion();
1355 fSubVersionVdriftUsed = id->GetSubVersion();
1356 } else if(os->GetString().Contains("TRD/Calib/LocalGainFactor")){
1357 // Get Old drift velocity calibration
1358 AliCDBId *id=AliCDBId::MakeFromString(os->GetString());
1359 fFirstRunGainLocal = id->GetFirstRun();
1360 fVersionGainLocalUsed = id->GetVersion();
1361 fSubVersionGainLocalUsed = id->GetSubVersion();
1362 } else if(os->GetString().Contains("TRD/Calib/ChamberExB")){
1363 // Get Old drift velocity calibration
1364 AliCDBId *id=AliCDBId::MakeFromString(os->GetString());
1365 fFirstRunExB = id->GetFirstRun();
1366 fVersionExBUsed = id->GetVersion();
1367 fSubVersionExBUsed = id->GetSubVersion();
1371 //printf("VersionGain %d, SubversionGain %d, VersionLocalGain %d, Subversionlocalgain %d, Versionvdrift %d, Subversionvdrift %d\n",fVersionGainUsed,fSubVersionGainUsed,fVersionGainLocalUsed,fSubVersionGainLocalUsed,fVersionVdriftUsed,fSubVersionVdriftUsed);
1374 if((fFirstRunGain < 0) ||
1375 (fFirstRunGainLocal < 0) ||
1376 (fFirstRunVdrift < 0) ||
1377 (fVersionGainUsed < 0) ||
1378 (fVersionGainLocalUsed < 0) ||
1379 (fSubVersionGainUsed < 0) ||
1380 (fSubVersionGainLocalUsed < 0) ||
1381 (fVersionVdriftUsed < 0) ||
1382 (fSubVersionVdriftUsed < 0)) {
1383 AliError("No recent calibration found");
1389 //_________________________________________________________________________________________________________________________
1390 Bool_t AliTRDCalibTask::ParticleGood(int i) const {
1393 // Definition of good tracks
1397 AliESDtrack *track = fESD->GetTrack(i);
1398 if (!track->IsOn(AliESDtrack::kTPCrefit)) return 0; // TPC refit
1399 if (track->GetTPCNcls() < 90) return 0; // number of TPC clusters
1400 if (fabs(track->Eta())>0.8) return 0; // fiducial pseudorapidity
1402 track->GetImpactParametersTPC(r,z);
1403 if (fabs(z)>2.0) return 0; // impact parameter in z
1404 if (fabs(r)>2.0) return 0; // impact parameter in xy
1410 //______________________________________________________________________________________________________________________
1411 Bool_t AliTRDCalibTask::FindP1TrackPHtrackletV1Test(const AliTRDseedV1 *tracklet, Int_t nbclusters)
1414 // Drift velocity calibration:
1415 // Fit the clusters with a straight line
1416 // From the slope find the drift velocity
1419 ////////////////////////////////////////////////
1420 //Number of points: if less than 3 return kFALSE
1421 /////////////////////////////////////////////////
1422 if(nbclusters <= 2) return kFALSE;
1427 // results of the linear fit
1428 Double_t dydt = 0.0; // dydt tracklet after straight line fit
1429 Double_t errorpar = 0.0; // error after straight line fit on dy/dt
1430 Double_t pointError = 0.0; // error after straight line fit
1431 // pad row problemes: avoid tracklet that cross pad rows, tilting angle in the constant
1432 Int_t crossrow = 0; // if it crosses a pad row
1433 Int_t rowp = -1; // if it crosses a pad row
1434 Float_t tnt = tracklet->GetTilt(); // tan tiltingangle
1435 TLinearFitter linearFitterTracklet(2,"pol1");
1436 linearFitterTracklet.StoreData(kTRUE);
1439 ///////////////////////////////////////////
1440 // Take the parameters of the track
1441 //////////////////////////////////////////
1442 // take now the snp, tnp and tgl from the track
1443 Double_t snp = tracklet->GetSnp(); // sin dy/dx at the end of the chamber
1444 Double_t tnp = 0.0; // dy/dx at the end of the chamber
1445 if( TMath::Abs(snp) < 1.){
1446 tnp = snp / TMath::Sqrt((1.-snp)*(1.+snp));
1448 Double_t tgl = tracklet->GetTgl(); // dz/dl
1449 Double_t dzdx = tgl*TMath::Sqrt(1+tnp*tnp); // dz/dx calculated from dz/dl
1451 //Double_t tnp = tracklet->GetYref(1); // dy/dx at the entrance of the chamber
1452 //Double_t tgl = tracklet->GetZref(1); // dz/dl at the entrance of the chamber
1453 //Double_t dzdx = tgl; //*TMath::Sqrt(1+tnp*tnp); // dz/dx from dz/dl
1454 // at the end with correction due to linear fit
1455 //Double_t tnp = tracklet->GetYfit(1); // dy/dx at the end of the chamber after fit correction
1456 //Double_t tgl = tracklet->GetZfit(1); // dz/dl at the end of the chamber after fit correction
1459 ////////////////////////////
1460 // loop over the clusters
1461 ////////////////////////////
1463 AliTRDcluster *cl = 0x0;
1464 //////////////////////////////
1465 // Check no shared clusters
1466 //////////////////////////////
1467 for(int icc=AliTRDseedV1::kNtb; icc<AliTRDseedV1::kNclusters; icc++){
1468 cl = tracklet->GetClusters(icc);
1469 if(cl) crossrow = 1;
1471 //////////////////////////////////
1473 //////////////////////////////////
1474 for(int ic=0; ic<AliTRDseedV1::kNtb; ic++){
1475 if(!(cl = tracklet->GetClusters(ic))) continue;
1476 //if((fLimitChargeIntegration) && (!cl->IsInChamber())) continue;
1478 Double_t ycluster = cl->GetY();
1479 Int_t time = cl->GetPadTime();
1480 Double_t timeis = time/10.0;
1481 //See if cross two pad rows
1482 Int_t row = cl->GetPadRow();
1483 if(rowp==-1) rowp = row;
1484 if(row != rowp) crossrow = 1;
1486 linearFitterTracklet.AddPoint(&timeis,ycluster,1);
1492 ////////////////////////////////////
1493 // Do the straight line fit now
1494 ///////////////////////////////////
1496 linearFitterTracklet.ClearPoints();
1500 linearFitterTracklet.Eval();
1501 linearFitterTracklet.GetParameters(pars);
1502 pointError = TMath::Sqrt(linearFitterTracklet.GetChisquare()/(nbli-2));
1503 errorpar = linearFitterTracklet.GetParError(1)*pointError;
1505 //printf("chis %f, nbli %d, pointError %f, parError %f, errorpar %f\n",linearFitterTracklet->GetChisquare(),nbli,pointError,linearFitterTracklet->GetParError(1),errorpar);
1506 linearFitterTracklet.ClearPoints();
1508 /////////////////////////
1510 ////////////////////////
1512 if(nbclusters < fLow) return kFALSE;
1513 if(nbclusters > fHigh) return kFALSE;
1514 if(pointError >= 0.3) return kFALSE;
1515 if(crossrow == 1) return kTRUE;
1517 ///////////////////////
1519 //////////////////////
1522 //Add to the linear fitter of the detector
1523 if( TMath::Abs(snp) < 1.){
1524 Double_t x = tnp-dzdx*tnt;
1525 //if(!fLinearVdriftTest) printf("Not there\n");
1526 Double_t nbentries = fLinearVdriftTest->GetEntries();
1527 if(nbentries < (5.0*32767)) fLinearVdriftTest->Fill(x,dydt);