]> 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
Coverity 18187
[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"
54f2ff1c 38#include "TH2S.h"
98937691 39#include "TList.h"
40#include "TMath.h"
41#include "TObject.h"
42#include "TObjArray.h"
43#include "TString.h"
44#include "TCanvas.h"
45#include "TLegend.h"
46#include "TStyle.h"
47#include "TLine.h"
57185ead 48#include "TIterator.h"
54f2ff1c 49#include "TLinearFitter.h"
50#include "TVectorD.h"
98937691 51
52#include "AliAnalysisTask.h"
53#include "AliAnalysisManager.h"
54
c1105918 55#include "AliExternalTrackParam.h"
98937691 56#include "AliESDVertex.h"
57#include "AliESDEvent.h"
58#include "AliESDfriend.h"
89f7cf44 59#include "AliCentrality.h"
98937691 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"
70
57185ead 71#include "AliTRDCalibraVector.h"
98937691 72#include "AliTRDCalibraFillHisto.h"
73#include "AliTRDCalibraVdriftLinearFit.h"
a0bb5615 74#include "AliTRDCalibraExbAltFit.h"
98937691 75
76#include "AliTRDcalibDB.h"
a2a4ec8e 77#include "AliCDBId.h"
78#include "AliLog.h"
98937691 79
b2277aa2 80#include "AliTRDCalibChamberStatus.h"
98937691 81
82#include "AliTRDCalibTask.h"
83
84
85ClassImp(AliTRDCalibTask)
86
87//________________________________________________________________________
88 AliTRDCalibTask::AliTRDCalibTask(const char *name)
01239968 89 : AliAnalysisTaskSE(name), fESD(0),
98937691 90 fESDfriend(0),
91 fkEsdTrack(0),
92 fFriendTrack(0),
93 fCalibObject(0),
94 fTrdTrack(0),
95 fCl(0),
96 fListHist(0),
97 fTRDCalibraFillHisto(0),
b2277aa2 98 fTRDChamberStatus(0),
98937691 99 fNEvents(0),
a5dcf618 100 fNEventsInput(0),
98937691 101 fNbTRDTrack(0),
102 fNbTRDTrackOffline(0),
103 fNbTRDTrackStandalone(0),
104 fNbTPCTRDtrack(0),
c1105918 105 fNbGoodTracks(0),
98937691 106 fNbTimeBin(0),
107 fNbTimeBinOffline(0),
108 fNbTimeBinStandalone(0),
109 fNbClusters(0),
110 fNbClustersOffline(0),
111 fNbClustersStandalone(0),
112 fNbTracklets(0),
113 fNbTrackletsOffline(0),
114 fNbTrackletsStandalone(0),
115 fAbsoluteGain(0),
116 fCH2dSum(0),
117 fPH2dSum(0),
118 fCH2dSM(0),
119 fPH2dSM(0),
54f2ff1c 120 fCH2dTest(0),
121 fPH2dTest(0),
122 fLinearVdriftTest(0),
123 fOnInstance(kTRUE),
98937691 124 fHisto2d(kTRUE),
125 fVector2d(kFALSE),
126 fVdriftLinear(kTRUE),
a0bb5615 127 fExbAlt(kFALSE),
5f689709 128 fDebugLevelTRDCalibraFillHisto(0),
98937691 129 fNbTimeBins(0),
5f689709 130 fNumberBinCharge(50),
131 fSelectTrigger(kTRUE),
98937691 132 fSelectedTrigger(new TObjArray()),
133 fRejected(kTRUE),
134 fEsdTrackCuts(0),
135 fRequirePrimaryVertex(kFALSE),
136 fVtxTPC(kFALSE),
137 fVtxSPD(kFALSE),
138 fMinNbContributors(0),
139 fRangePrimaryVertexZ(9999999.0),
c1105918 140 fMinNbTracks(9),
5f689709 141 fMaxNbTracks(999999999),
142 fCutWithVdriftCalib(kFALSE),
143 fMinNbTRDtracklets(0),
144 fMinTRDMomentum(0),
98937691 145 fLow(0),
146 fHigh(30),
147 fFillZero(kFALSE),
148 fNormalizeNbOfCluster(kFALSE),
149 fRelativeScale(0.0),
150 fMaxCluster(100.0),
151 fNbMaxCluster(2),
152 fOfflineTracks(kFALSE),
153 fStandaloneTracks(kFALSE),
d085ba91 154 fFirstRunGain(-1),
a2a4ec8e 155 fVersionGainUsed(-1),
156 fSubVersionGainUsed(-1),
d085ba91 157 fFirstRunGainLocal(-1),
a2a4ec8e 158 fVersionGainLocalUsed(-1),
159 fSubVersionGainLocalUsed(-1),
d085ba91 160 fFirstRunVdrift(-1),
a2a4ec8e 161 fVersionVdriftUsed(-1),
162 fSubVersionVdriftUsed(-1),
b2277aa2 163 fFirstRunExB(-1),
164 fVersionExBUsed(-1),
165 fSubVersionExBUsed(-1),
98937691 166 fCalDetGain(0x0),
167 fMaxEvent(0),
168 fCounter(0),
169 fDebug(0)
170{
171 //
172 // Default constructor
173 //
174
175 fNz[0] = 0;
176 fNz[1] = 0;
177 fNz[2] = 0;
178
179 fNrphi[0] = 0;
180 fNrphi[1] = 0;
181 fNrphi[2] = 0;
182
183 // Define input and output slots here
184 // Input slot #0 works with a TChain
185 DefineInput(0, TChain::Class());
186
187 // Output slot #0 writes into a TList container
01239968 188 DefineOutput(1, TList::Class());
98937691 189
190
191}
192//____________________________________________________________________________________
193AliTRDCalibTask::~AliTRDCalibTask()
194{
195 //
196 // AliTRDCalibTask destructor
197 //
198
199 // Pointeur
200 if(fNEvents) delete fNEvents;
a5dcf618 201 if(fNEventsInput) delete fNEventsInput;
98937691 202 if(fNbTRDTrack) delete fNbTRDTrack;
203 if(fNbTRDTrackOffline) delete fNbTRDTrackOffline;
204 if(fNbTRDTrackStandalone) delete fNbTRDTrackStandalone;
205 if(fNbTPCTRDtrack) delete fNbTPCTRDtrack;
c1105918 206 if(fNbGoodTracks) delete fNbGoodTracks;
98937691 207 if(fNbTimeBin) delete fNbTimeBin;
208 if(fNbTimeBinOffline) delete fNbTimeBinOffline;
209 if(fNbTimeBinStandalone) delete fNbTimeBinStandalone;
210 if(fNbClusters) delete fNbClusters;
211 if(fNbClustersOffline) delete fNbClustersOffline;
212 if(fNbClustersStandalone) delete fNbClustersStandalone;
213 if(fNbTracklets) delete fNbTracklets;
214 if(fNbTrackletsOffline) delete fNbTrackletsOffline;
215 if(fNbTrackletsStandalone) delete fNbTrackletsStandalone;
216 if(fAbsoluteGain) delete fAbsoluteGain;
217 if(fCH2dSum) delete fCH2dSum;
218 if(fPH2dSum) delete fPH2dSum;
219 if(fCH2dSM) delete fCH2dSM;
220 if(fPH2dSM) delete fPH2dSM;
54f2ff1c 221 if(fCH2dTest) delete fCH2dTest;
222 if(fPH2dTest) delete fPH2dTest;
223 if(fLinearVdriftTest) delete fLinearVdriftTest;
98937691 224 if(fCalDetGain) delete fCalDetGain;
225
226 if(fSelectedTrigger) {
227 fSelectedTrigger->Delete();
228 delete fSelectedTrigger;
229 }
230 if(fEsdTrackCuts) {
231 delete fEsdTrackCuts;
232 }
233
b2277aa2 234 if(fTRDChamberStatus) delete fTRDChamberStatus;
235
98937691 236}
01239968 237
98937691 238//________________________________________________________________________
01239968 239void AliTRDCalibTask::UserCreateOutputObjects()
98937691 240{
241 //
242 // Create the histos
243 //
01239968 244 //cout << "AliTRDCalibTask::CreateOutputObjects() IN" << endl;
98937691 245
246 // Number of time bins
247 if(fNbTimeBins==0) {
248 AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
249 fNbTimeBins = cal->GetNumberOfTimeBinsDCS();
250 if(fNbTimeBins <= 0){
251 AliWarning(Form("No of TimeBins from DB [%d] use default [30]", fNbTimeBins));
252 fNbTimeBins = 30;
253 }
254 }
a2a4ec8e 255
54f2ff1c 256 // output list
257 fListHist = new TList();
258 fListHist->SetOwner();
b2277aa2 259
260 // init chamber status
261 fTRDChamberStatus = new AliTRDCalibChamberStatus();
262 fTRDChamberStatus->Init();
263 fListHist->Add(fTRDChamberStatus->GetSparseI());
264
98937691 265 // instance calibration
266 fTRDCalibraFillHisto = AliTRDCalibraFillHisto::Instance();
54f2ff1c 267 if(fOnInstance) {
5f689709 268 fTRDCalibraFillHisto->SetNumberBinCharge(fNumberBinCharge); // set number of bin of the charge distribution
269 fTRDCalibraFillHisto->SetCutWithVdriftCalib(fCutWithVdriftCalib); // cut vdrift
270 fTRDCalibraFillHisto->SetMinNbTRDtracklets(fMinNbTRDtracklets); // min number of TRD tracklets
271 fTRDCalibraFillHisto->SetMinTRDMomentum(fMinTRDMomentum); // min TRD momentum
54f2ff1c 272 fTRDCalibraFillHisto->SetHisto2d(fHisto2d); // choose to use histograms
273 fTRDCalibraFillHisto->SetVector2d(fVector2d); // choose to use vectors
274 fTRDCalibraFillHisto->SetCH2dOn(); // choose to calibrate the gain
275 fTRDCalibraFillHisto->SetPH2dOn(); // choose to calibrate the drift velocity
276 fTRDCalibraFillHisto->SetPRF2dOn(); // choose to look at the PRF
277 fTRDCalibraFillHisto->SetLinearFitterOn(fVdriftLinear); // Other possibility vdrift VDRIFT
278 fTRDCalibraFillHisto->SetLinearFitterDebugOn(fVdriftLinear); // Other possibility vdrift
a0bb5615 279 fTRDCalibraFillHisto->SetExbAltFitOn(fExbAlt); // Alternative method for exb
54f2ff1c 280 for(Int_t k = 0; k < 3; k++){
281 if(((fNz[k] != 10) && (fNrphi[k] != 10)) && ((fNz[k] != 100) && (fNrphi[k] != 100))) {
282 fTRDCalibraFillHisto->SetNz(k,fNz[k]); // Mode calibration
283 fTRDCalibraFillHisto->SetNrphi(k,fNrphi[k]); // Mode calibration
98937691 284 }
54f2ff1c 285 else {
286 if((fNz[k] == 100) && (fNrphi[k] == 100)) {
287 if(fVector2d) AliInfo("The mode all together is not supported by the vector method");
288 fTRDCalibraFillHisto->SetAllTogether(k);
289 }
290 if((fNz[k] == 10) && (fNrphi[k] == 10)) {
291 if(fVector2d) AliInfo("The mode per supermodule is not supported by the vector method");
292 fTRDCalibraFillHisto->SetPerSuperModule(k);
293 }
98937691 294 }
295 }
54f2ff1c 296 // Variables for how to fill
297 fTRDCalibraFillHisto->SetFillWithZero(fFillZero);
298 fTRDCalibraFillHisto->SetNormalizeNbOfCluster(fNormalizeNbOfCluster);
299 fTRDCalibraFillHisto->SetMaxCluster(fMaxCluster);
300 fTRDCalibraFillHisto->SetNbMaxCluster(fNbMaxCluster);
98937691 301
54f2ff1c 302 // Init with 30 timebins
303 fTRDCalibraFillHisto->Init2Dhistos(fNbTimeBins); // initialise the histos
304 fTRDCalibraFillHisto->SetNumberClusters(fLow); // At least 11 clusters
305 fTRDCalibraFillHisto->SetNumberClustersf(fHigh); // At least 11 clusters
306
307 // For testing only
5f689709 308 fTRDCalibraFillHisto->SetDebugLevel(fDebugLevelTRDCalibraFillHisto); //debug stuff
54f2ff1c 309
310 if(fHisto2d) {
311 fListHist->Add(fTRDCalibraFillHisto->GetCH2d());
312 fListHist->Add(fTRDCalibraFillHisto->GetPH2d());
313 fListHist->Add(fTRDCalibraFillHisto->GetPRF2d());
314 }
315 if(fVdriftLinear) fListHist->Add((TObject *)fTRDCalibraFillHisto->GetVdriftLinearFit());
a0bb5615 316 if(fVector2d) fListHist->Add((TObject *) fTRDCalibraFillHisto->GetCalibraVector()); //calibra vector
317 if(fExbAlt) fListHist->Add((TObject *)fTRDCalibraFillHisto->GetExbAltFit());
54f2ff1c 318 }
98937691 319 fRelativeScale = fTRDCalibraFillHisto->GetRelativeScale(); // Get the relative scale for the gain
320
54f2ff1c 321 fNEvents = new TH1I(Form("NEvents_%s",(const char*)fName),"NEvents", 2, 0, 2);
98937691 322 fListHist->Add(fNEvents);
54f2ff1c 323 fNEventsInput = new TH1I(Form("NEventsInput_%s",(const char*)fName),"NEventsInput", 2, 0, 2);
a5dcf618 324 fListHist->Add(fNEventsInput);
98937691 325
326 // absolute gain calibration even without AliESDfriend
327 Int_t nBinsPt = 25;
328 Double_t minPt = 0.001;
329 Double_t maxPt = 10.0;
330
331 Double_t *binLimLogPt = new Double_t[nBinsPt+1];
332 Double_t *binLimPt = new Double_t[nBinsPt+1];
333 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 ;
334 for(Int_t i=0; i<=nBinsPt; i++) binLimPt[i]=(Double_t)TMath::Power(10,binLimLogPt[i]);
335
54f2ff1c 336 fAbsoluteGain = new TH2F(Form("AbsoluteGain_%s",(const char*)fName),"AbsoluteGain", 200, 0.0, 700.0, nBinsPt, binLimPt);
98937691 337 fAbsoluteGain->SetYTitle("Momentum at TRD");
338 fAbsoluteGain->SetXTitle("charge deposit [a.u]");
339 fAbsoluteGain->SetZTitle("counts");
340 fAbsoluteGain->SetStats(0);
341 fAbsoluteGain->Sumw2();
342 fListHist->Add(fAbsoluteGain);
343
98937691 344 /////////////////////////////////////////
345 // First debug level
346 ///////////////////////////////////////
347 if(fDebug > 0) {
54f2ff1c 348
349 fLinearVdriftTest = new TH2S(Form("LFDV0testversion_%s",(const char*)fName),"LFDV0testversion",36,-0.9,0.9,48,-1.2,1.2);
350 fLinearVdriftTest->SetXTitle("tan(phi_{track})");
351 fLinearVdriftTest->SetYTitle("dy/dt");
352 fLinearVdriftTest->SetZTitle("Number of tracklets");
353 fLinearVdriftTest->SetStats(0);
354 fLinearVdriftTest->SetDirectory(0);
98937691 355
356 // Standart with AliESDfriend
54f2ff1c 357 fPH2dTest = new TProfile2D(Form("PH2dTest_%s",(const char*)fName),"Nz0Nrphi0"
358 ,fNbTimeBins,-0.05,(Double_t)((fNbTimeBins-0.5)/10.0)
359 ,540,0,540);
360 fPH2dTest->SetYTitle("Det/pad groups");
361 fPH2dTest->SetXTitle("time [#mus]");
362 fPH2dTest->SetZTitle("<PH> [a.u.]");
363 fPH2dTest->SetStats(0);
364 //
365 fCH2dTest = new TH2I(Form("CH2dTest_%s",(const char*)fName),"Nz0Nrphi0",50,0,300,540,0,540);
366 fCH2dTest->SetYTitle("Det/pad groups");
367 fCH2dTest->SetXTitle("charge deposit [a.u]");
368 fCH2dTest->SetZTitle("counts");
369 fCH2dTest->SetStats(0);
370 fCH2dTest->Sumw2();
371
372 //
373 fPH2dSM = new TProfile2D(Form("PH2dSM_%s",(const char*)fName),"Nz10Nrphi10"
98937691 374 ,fNbTimeBins,-0.05,(Double_t)((fNbTimeBins-0.5)/10.0)
375 ,18,0,18);
376 fPH2dSM->SetYTitle("Det/pad groups");
377 fPH2dSM->SetXTitle("time [#mus]");
378 fPH2dSM->SetZTitle("<PH> [a.u.]");
379 fPH2dSM->SetStats(0);
380 //
54f2ff1c 381 fCH2dSM = new TH2I(Form("CH2dSM_%s",(const char*)fName),"Nz10Nrphi10",50,0,300,18,0,18);
98937691 382 fCH2dSM->SetYTitle("Det/pad groups");
383 fCH2dSM->SetXTitle("charge deposit [a.u]");
384 fCH2dSM->SetZTitle("counts");
385 fCH2dSM->SetStats(0);
386 fCH2dSM->Sumw2();
387 //
54f2ff1c 388 fPH2dSum = new TProfile2D(Form("PH2dSum_%s",(const char*)fName),"Nz100Nrphi100"
98937691 389 ,fNbTimeBins,-0.05,(Double_t)((fNbTimeBins-0.5)/10.0)
390 ,1,0,1);
391 fPH2dSum->SetYTitle("Det/pad groups");
392 fPH2dSum->SetXTitle("time [#mus]");
393 fPH2dSum->SetZTitle("<PH> [a.u.]");
394 fPH2dSum->SetStats(0);
395 //
54f2ff1c 396 fCH2dSum = new TH2I(Form("CH2dSum_%s",(const char*)fName),"Nz100Nrphi100",50,0,300,1,0,1);
98937691 397 fCH2dSum->SetYTitle("Det/pad groups");
398 fCH2dSum->SetXTitle("charge deposit [a.u]");
399 fCH2dSum->SetZTitle("counts");
400 fCH2dSum->SetStats(0);
401 fCH2dSum->Sumw2();
54f2ff1c 402
98937691 403
404 // Add them
54f2ff1c 405 fListHist->Add(fLinearVdriftTest);
406 fListHist->Add(fPH2dTest);
407 fListHist->Add(fCH2dTest);
98937691 408 fListHist->Add(fPH2dSM);
409 fListHist->Add(fCH2dSM);
410 fListHist->Add(fPH2dSum);
411 fListHist->Add(fCH2dSum);
54f2ff1c 412
98937691 413 }
414
415 /////////////////////////////////////////
416 // Second debug level
417 ///////////////////////////////////////
418 if(fDebug > 1) {
419
54f2ff1c 420 fNbGoodTracks = new TH2F(Form("NbGoodTracks_%s",(const char*)fName),"NbGoodTracks",500,0.0,2500.0,200,0.0,100.0);
421 fNbGoodTracks->SetXTitle("Nb of good tracks");
422 fNbGoodTracks->SetYTitle("Centrality");
423 fNbGoodTracks->SetStats(0);
424
425 fNbTRDTrack = new TH1F(Form("TRDTrack_%s",(const char*)fName),"TRDTrack",50,0,50);
98937691 426 fNbTRDTrack->Sumw2();
54f2ff1c 427 fNbTRDTrackOffline = new TH1F(Form("TRDTrackOffline_%s",(const char*)fName),"TRDTrackOffline",50,0,50);
98937691 428 fNbTRDTrackOffline->Sumw2();
54f2ff1c 429 fNbTRDTrackStandalone = new TH1F(Form("TRDTrackStandalone_%s",(const char*)fName),"TRDTrackStandalone",50,0,50);
98937691 430 fNbTRDTrackStandalone->Sumw2();
54f2ff1c 431 fNbTPCTRDtrack = new TH2F(Form("NbTPCTRDtrack_%s",(const char*)fName),"NbTPCTRDtrack",100,0,100,100,0,100);
98937691 432 fNbTPCTRDtrack->Sumw2();
433 //
54f2ff1c 434 fNbTimeBin = new TH1F(Form("NbTimeBin_%s",(const char*)fName),"NbTimeBin",35,0,35);
98937691 435 fNbTimeBin->Sumw2();
54f2ff1c 436 fNbTimeBinOffline = new TH1F(Form("NbTimeBinOffline_%s",(const char*)fName),"NbTimeBinOffline",35,0,35);
98937691 437 fNbTimeBinOffline->Sumw2();
54f2ff1c 438 fNbTimeBinStandalone = new TH1F(Form("NbTimeBinStandalone_%s",(const char*)fName),"NbTimeBinStandalone",35,0,35);
98937691 439 fNbTimeBinStandalone->Sumw2();
440 //
54f2ff1c 441 fNbClusters = new TH1F(Form("NbClusters_%s",(const char*)fName),"",35,0,35);
98937691 442 fNbClusters->Sumw2();
54f2ff1c 443 fNbClustersOffline = new TH1F(Form("NbClustersOffline_%s",(const char*)fName),"",35,0,35);
98937691 444 fNbClustersOffline->Sumw2();
54f2ff1c 445 fNbClustersStandalone = new TH1F(Form("NbClustersStandalone_%s",(const char*)fName),"",35,0,35);
98937691 446 fNbClustersStandalone->Sumw2();
447 //
54f2ff1c 448 fNbTracklets = new TH1F(Form("NbTracklets_%s",(const char*)fName),"NbTracklets",540,0.,540.);
98937691 449 fNbTracklets->Sumw2();
54f2ff1c 450 fNbTrackletsOffline = new TH1F(Form("NbTrackletsOffline_%s",(const char*)fName),"NbTrackletsOffline",540,0.,540.);
98937691 451 fNbTrackletsOffline->Sumw2();
54f2ff1c 452 fNbTrackletsStandalone = new TH1F(Form("NbTrackletsStandalone_%s",(const char*)fName),"NbTrackletsStandalone",540,0.,540.);
98937691 453 fNbTrackletsStandalone->Sumw2();
454
54f2ff1c 455 fListHist->Add(fNbGoodTracks);
456
98937691 457 fListHist->Add(fNbTRDTrack);
458 fListHist->Add(fNbTRDTrackOffline);
459 fListHist->Add(fNbTRDTrackStandalone);
460 fListHist->Add(fNbTPCTRDtrack);
461
462 fListHist->Add(fNbTimeBin);
463 fListHist->Add(fNbTimeBinOffline);
464 fListHist->Add(fNbTimeBinStandalone);
465 fListHist->Add(fNbClusters);
466 fListHist->Add(fNbClustersOffline);
467 fListHist->Add(fNbClustersStandalone);
468 fListHist->Add(fNbTracklets);
469 fListHist->Add(fNbTrackletsOffline);
470 fListHist->Add(fNbTrackletsStandalone);
471
472 }
fdc15553 473
474 delete [] binLimLogPt;
475 delete [] binLimPt;
476
c7cb134f 477 PostData(1,fListHist);
478
01239968 479 //cout << "AliTRDCalibTask::UserCreateOutputObjects() OUT" << endl;
98937691 480
fdc15553 481}
57185ead 482
01239968 483//________________________________________________________________________
484void AliTRDCalibTask::UserExec(Option_t *)
485{
486 //
487 // Filling of the histos
488 //
489 //cout << "AliTRDCalibTask::Exec() IN" << endl;
98937691 490
a2a4ec8e 491 // Init Versions and subversions used
ca7e6e64 492 if((fFirstRunGain==-1) || (fVersionGainUsed==-1) || (fSubVersionGainUsed==-1) || (fFirstRunGainLocal==-1) || (fVersionGainLocalUsed==-1) || (fSubVersionGainLocalUsed==-1) || (fFirstRunVdrift==-1) || (fVersionVdriftUsed==-1) || (fSubVersionVdriftUsed==-1)) {
a2a4ec8e 493 if(!SetVersionSubversion()) {
ca7e6e64 494 PostData(1, fListHist);
495 return;
a2a4ec8e 496 }
497 }
498 if(fCounter==0) {
54f2ff1c 499 if(fOnInstance) {
500 fTRDCalibraFillHisto->SetFirstRunGain(fFirstRunGain); // Gain Used
501 fTRDCalibraFillHisto->SetVersionGainUsed(fVersionGainUsed); // Gain Used
502 fTRDCalibraFillHisto->SetSubVersionGainUsed(fSubVersionGainUsed); // Gain Used
503 fTRDCalibraFillHisto->SetFirstRunGainLocal(fFirstRunGainLocal); // Gain Used
504 fTRDCalibraFillHisto->SetVersionGainLocalUsed(fVersionGainLocalUsed); // Gain Used
505 fTRDCalibraFillHisto->SetSubVersionGainLocalUsed(fSubVersionGainLocalUsed); // Gain Used
506 fTRDCalibraFillHisto->SetFirstRunVdrift(fFirstRunVdrift); // Vdrift Used
507 fTRDCalibraFillHisto->SetVersionVdriftUsed(fVersionVdriftUsed); // Vdrift Used
508 fTRDCalibraFillHisto->SetSubVersionVdriftUsed(fSubVersionVdriftUsed); // Vdrift Used
b2277aa2 509 if((fFirstRunExB != -1) && (fVersionExBUsed != -1) && (fSubVersionExBUsed != -1)){
510 fTRDCalibraFillHisto->SetFirstRunExB(fFirstRunExB); // ExB Used
511 fTRDCalibraFillHisto->SetVersionExBUsed(fVersionExBUsed); // ExB Used
512 fTRDCalibraFillHisto->SetSubVersionExBUsed(fSubVersionExBUsed); // ExB Used
513 }
54f2ff1c 514 fTRDCalibraFillHisto->InitCalDet();
515 }
516 if(fDebug > 1){
517 // title CH2dTest
518 TString name("Ver");
519 name += fVersionGainUsed;
520 name += "Subver";
521 name += fSubVersionGainUsed;
522 name += "FirstRun";
523 name += fFirstRunGain;
524 name += "Nz0Nrphi0";
525 fCH2dTest->SetTitle(name);
526 // title PH2dTest
527 TString namee("Ver");
528 namee += fVersionVdriftUsed;
529 namee += "Subver";
530 namee += fSubVersionVdriftUsed;
531 namee += "FirstRun";
532 namee += fFirstRunVdrift;
533 namee += "Nz0Nrphi0";
534 fPH2dTest->SetTitle(namee);
535 }
a2a4ec8e 536 }
537
01239968 538 // AliLog::SetGlobalLogLevel(AliLog::kError);
539 // cout << "AliTRDCalibTask::Exec() 1" << endl;
540 fESD = dynamic_cast<AliESDEvent*>(fInputEvent);
541 if(!fESD){
542 AliError("ESD Event missing");
543 PostData(1, fListHist);
544 return;
545 }
c1105918 546
547 const char* type = fESD->GetBeamType();
548
01239968 549
550 //printf("Counter %d\n",fCounter);
551
552 fCounter++;
a5dcf618 553 fNEventsInput->Fill(1);
554
01239968 555 //cout << "maxEvent = " << fMaxEvent << endl;
556 //if(fCounter%100==0) cout << "fCounter = " << fCounter << endl;
c1105918 557 if((fMaxEvent != 0) && (fMaxEvent < fCounter)) {
558 PostData(1, fListHist);
559 return;
560 }
01239968 561 //if(fCounter%100==0) cout << "fCounter1 = " << fCounter << endl;
562 //cout << "event = " << fCounter << endl;
563
564 //printf("Counter %d\n",fCounter);
565
566 ///////////////////
567 // Check trigger
568 ///////////////////
569 Bool_t pass = kTRUE;
c1105918 570
5f689709 571 if (fSelectTrigger) {
c1105918 572
573 //printf("Will check the triggers\n");
574
575 Int_t numberOfTriggerSelected = fSelectedTrigger->GetEntriesFast();
576 //printf("numberofTriggerSelected %d\n",numberOfTriggerSelected);
577 if(fRejected) {
578 pass = kTRUE;
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)) {
583 pass = kFALSE;
584 }
01239968 585 }
586 }
c1105918 587 else {
588 pass = kFALSE;
589 for(Int_t k = 0; k < numberOfTriggerSelected; k++){
590 const TObjString *const obString=(TObjString*)fSelectedTrigger->At(k);
591 const TString tString=obString->GetString();
592 if(fESD->IsTriggerClassFired((const char*)tString)) {
593 pass = kTRUE;
594 }
01239968 595 }
596 }
c1105918 597 if(!pass) {
598 PostData(1, fListHist);
599 return;
600 }
601
01239968 602 }
c1105918 603
01239968 604 //printf("Class Fired %s\n",(const char*)fESD->GetFiredTriggerClasses());
605 //printf("Trigger passed\n");
606
607 ///////////////////////////////
608 // Require a primary vertex
609 //////////////////////////////
610 if(fRequirePrimaryVertex) {
611 const AliESDVertex* vtxESD = 0x0;
612 if (fVtxTPC) vtxESD = fESD->GetPrimaryVertexTPC() ;
613 else if (fVtxSPD) vtxESD = fESD->GetPrimaryVertexSPD() ;
614 else vtxESD = fESD->GetPrimaryVertexTracks() ;
615 if(!vtxESD){
616 PostData(1, fListHist);
617 return;
618 }
619 Int_t nCtrb = vtxESD->GetNContributors();
620 if(nCtrb < fMinNbContributors) {
621 PostData(1, fListHist);
622 return;
623 }
624 Double_t zPosition = vtxESD->GetZ();
625 if(TMath::Abs(zPosition) > fRangePrimaryVertexZ) {
626 PostData(1, fListHist);
627 return;
628 }
629
630 }
631
632 //printf("Primary vertex passed\n");
633
c1105918 634 //////////////////////////////////////
635 // Requirement on number of good tracks
636 //////////////////////////////////////
637 Int_t nGoodParticles = 0;
638 Double_t nbTracks = fESD->GetNumberOfTracks();
639 for(Int_t itrack = 0; itrack < nbTracks; itrack++) {
640 if(ParticleGood(itrack)) nGoodParticles++;
641 }
54f2ff1c 642 if(fDebug > 1) {
c1105918 643 // Centrality
89f7cf44 644 AliCentrality *esdCentrality = fESD->GetCentrality();
c1105918 645 Float_t centrality = esdCentrality->GetCentralityPercentile("V0M");
646 //Float_t centralityb = esdCentrality->GetCentralityPercentile("CL1");
647 fNbGoodTracks->Fill(nGoodParticles,centrality);
648 //printf("centrality %f, centralityb %f\n",centrality,centralityb);
649 }
650
6cd743ca 651 //printf("Beam type %s\n",(const char*)type);
e8200e16 652 if (!strstr(type,"p-p")) {
653 //if (strstr(type,"A-A")) {
6cd743ca 654 //printf("Will check the number of good tracks %f %f %f\n",nGoodParticles,fMinNbTracks,fMaxNbTracks);
c1105918 655 if((nGoodParticles < fMinNbTracks) || (nGoodParticles > fMaxNbTracks)) {
656 PostData(1, fListHist);
657 return;
658 }
659 }
660
01239968 661 fNEvents->Fill(1);
662
663 // In total
664 Int_t nbTrdTracks = 0;
665 // standalone
666 Int_t nbTrdTracksStandalone = 0;
667 // offline
668 Int_t nbTrdTracksOffline = 0;
669 // TPC
670 Int_t nbtrackTPC = 0;
671
c1105918 672
01239968 673
674 if (nbTracks <= 0.0) {
675
676 if(fDebug > 1) {
677 fNbTRDTrack->Fill(nbTrdTracks);
678 fNbTRDTrackStandalone->Fill(nbTrdTracksStandalone);
679 fNbTRDTrackOffline->Fill(nbTrdTracksOffline);
680 }
681 PostData(1, fListHist);
682 return;
683 }
684
4c865c34 685
01239968 686 fESDfriend = dynamic_cast<AliESDfriend*> (fESD->FindListObject("AliESDfriend"));
687 if(!fESDfriend){
688 AliError("fESDfriend not available");
689 PostData(1, fListHist);
690 return;
691 }
20dfc307 692
693 if(fESDfriend->TestSkipBit()) {
694 PostData(1, fListHist);
695 return;
696 }
01239968 697
698 //printf("has friends\n");
98937691 699
01239968 700 /////////////////////////////////////
701 // Loop on AliESDtrack
702 ////////////////////////////////////
703 //printf("Nb of tracks %f\n",nbTracks);
704 for(int itrk=0; itrk < nbTracks; ++itrk){
98937691 705
01239968 706 // Get ESD track
707 fkEsdTrack = fESD->GetTrack(itrk);
708 if(!fkEsdTrack) continue;
709 ULong_t status = fkEsdTrack->GetStatus();
710 if(status&(AliESDtrack::kTPCout)) ++nbtrackTPC;
711
b2277aa2 712 fFriendTrack = fESDfriend->GetTrack(itrk);
713 if(!fFriendTrack) {
714 //printf("No friend track %d\n",itrk);
01239968 715 continue;
716 }
b2277aa2 717
01239968 718 // Other cuts
b2277aa2 719 fTrdTrack = 0x0;
01239968 720 Bool_t good = kTRUE;
721 Bool_t standalonetrack = kFALSE;
722 Bool_t offlinetrack = kFALSE;
723 //ULong_t status = fkEsdTrack->GetStatus();
724
01239968 725 //////////////////////////////////////
726 // Loop on calibration objects
727 //////////////////////////////////////
728 Int_t icalib=0;
729 Int_t nTRDtrackV1=0;
730 while((fCalibObject = (TObject *)(fFriendTrack->GetCalibObject(icalib++)))){
4c865c34 731 //printf("Name %s\n",fCalibObject->IsA()->GetName());
01239968 732 if(strcmp(fCalibObject->IsA()->GetName(), "AliTRDtrackV1") != 0) continue;
733 //printf("Find the calibration object\n");
734 ++nTRDtrackV1;
735
736 if((status&(AliESDtrack::kTRDout)) && (!(status&(AliESDtrack::kTRDin)))) {
737 standalonetrack = kTRUE;
738 }
739 if((status&(AliESDtrack::kTRDin))) {
740 offlinetrack = kTRUE;
741 }
742 if(fOfflineTracks){
743 if(!offlinetrack){
744 good = kFALSE;
745 }
746 }
747 else if(fStandaloneTracks){
748 if(!standalonetrack){
749 good = kFALSE;
750 }
751 }
752
753 fTrdTrack = (AliTRDtrackV1 *)fCalibObject;
b2277aa2 754 // process chamberstatus
755 fTRDChamberStatus->ProcessTrack(fTrdTrack);
756 }
757
758 // Quality cuts on the AliESDtrack
759 if((fEsdTrackCuts) && (!fEsdTrackCuts->IsSelected((AliVParticle *)fkEsdTrack))) {
760 //printf("Not a good track\n");
761 continue;
762 }
763
764 // First Absolute gain calibration
765 Int_t trdNTracklets = (Int_t) fkEsdTrack->GetTRDntracklets();
766 Int_t trdNTrackletsPID = (Int_t) fkEsdTrack->GetTRDntrackletsPID();
767 //printf("Number of trd tracklets %d and PID trd tracklets %d\n",trdNTracklets,trdNTrackletsPID);
768 if((trdNTracklets > 0) && (trdNTrackletsPID > 0)) {
769 for(Int_t iPlane = 0; iPlane < 6; ++iPlane){
770 //Double_t slide = fkEsdTrack->GetTRDslice(iPlane);
771 //printf("Number of slide %d\n",fkEsdTrack->GetNumberOfTRDslices());
772 //Double_t momentum = fkEsdTrack->GetTRDmomentum(iPlane);
773 //printf("momentum %f, slide %f\n",momentum,slide);
774 if(fkEsdTrack->GetTRDslice(iPlane) > 0.0)
775 fAbsoluteGain->Fill(fkEsdTrack->GetTRDslice(iPlane)*8.0/100.0,
776 fkEsdTrack->GetTRDmomentum(iPlane));
01239968 777 }
b2277aa2 778 }
779
780
781 if(!fTrdTrack) continue;
782
783 if(good && fOnInstance) {
784 //cout << "good" << endl;
5f689709 785 fTRDCalibraFillHisto->UpdateHistogramsV1(fTrdTrack,fkEsdTrack);
b2277aa2 786 //printf("Fill fTRDCalibraFillHisto\n");
787 }
788
01239968 789
b2277aa2 790
791 //////////////////////////////////
792 // Debug
793 ////////////////////////////////
794
795 if(fDebug > 0) {
796
797 //printf("Enter debug\n");
01239968 798
b2277aa2 799 Int_t nbtracklets = 0;
800
801 // Check some stuff
802 Bool_t standalonetracklet = kFALSE;
803 const AliTRDseedV1 *tracklet = 0x0;
804 //////////////////////////////////////
805 // Loop tracklets
806 /////////////////////////////////////
807 Int_t nbclusters=0;
808 Double_t phtb[AliTRDseedV1::kNtb];
809 memset(phtb, 0, AliTRDseedV1::kNtb*sizeof(Double_t));
810 Double_t sum = 0.0;
f29cf84c 811 Float_t normalisation = 1.13;
b2277aa2 812 Int_t detector = 0;
813 Int_t sector = 0;
814 for(Int_t itr = 0; itr < 6; ++itr){
01239968 815
b2277aa2 816 if(!(tracklet = fTrdTrack->GetTracklet(itr))) continue;
817 if(!tracklet->IsOK()) continue;
818 ++nbtracklets;
819 standalonetracklet = kFALSE;
820 if(tracklet->IsStandAlone()) standalonetracklet = kTRUE;
01239968 821
b2277aa2 822 nbclusters = 0;
823 memset(phtb, 0, AliTRDseedV1::kNtb*sizeof(Double_t));
824 sum = 0.0;
825 detector = 0;
826 sector = 0;
827 //Int_t crossrow = 0;
01239968 828
01239968 829 // Check no shared clusters
830 //for(int icc=AliTRDseedV1::kNtb; icc<AliTRDseedV1::kNclusters; icc++){
831 // if((fcl = tracklet->GetClusters(icc))) crossrow = 1;
832 // }
b2277aa2 833
01239968 834 // Loop on clusters
b2277aa2 835 Int_t time = 0;
836 Float_t ch = 0;
837 Float_t qcl = 0;
838 for(int ic=0; ic<AliTRDseedV1::kNtb; ++ic){
839
840 if(!(fCl = tracklet->GetClusters(ic))) continue;
841 ++nbclusters;
842 time = fCl->GetPadTime();
f29cf84c 843 //ch = tracklet->GetdQdl(ic);
844 ch = tracklet->GetQperTB(ic);
b2277aa2 845 qcl = TMath::Abs(fCl->GetQ());
846 detector = fCl->GetDetector();
847 // Add the charge if shared cluster
848 if((ic+AliTRDseedV1::kNtb) < AliTRDseedV1::kNclusters) {
849 if((fCl = tracklet->GetClusters(ic+AliTRDseedV1::kNtb))) {
850 qcl += TMath::Abs(fCl->GetQ());
851 //printf("Add the cluster charge\n");
01239968 852 }
853 }
b2277aa2 854 if((time>-1) && (time<fNbTimeBins)) phtb[time]=qcl;
855 if((fCalDetGain) && (fCalDetGain->GetValue(detector) > 0.0)) sum += ch*fCalDetGain->GetValue(detector)/normalisation;
856 else sum += ch/normalisation;
01239968 857
858 if(fDebug > 1) {
b2277aa2 859 fNbTimeBin->Fill(time);
860 if(tracklet->IsStandAlone()) fNbTimeBinStandalone->Fill(time);
861 else fNbTimeBinOffline->Fill(time);
862 }
863 }
864 sector = AliTRDgeometry::GetSector(detector);
865
866 if(fDebug > 1) {
867 fNbTracklets->Fill(detector);
868 if(tracklet->IsStandAlone()) fNbTrackletsStandalone->Fill(detector);
869 else fNbTrackletsOffline->Fill(detector);
01239968 870
b2277aa2 871 fNbClusters->Fill(nbclusters);
872 if(tracklet->IsStandAlone()) fNbClustersStandalone->Fill(nbclusters);
873 else fNbClustersOffline->Fill(nbclusters);
874 }
875
876 if((nbclusters > fLow) && (nbclusters < fHigh)){
877 if(fRelativeScale > 0.0) sum = sum/fRelativeScale;
878 fCH2dTest->Fill(sum,detector+0.5);
879 fCH2dSM->Fill(sum,sector+0.5);
880 fCH2dSum->Fill(sum,0.5);
881 Bool_t checknoise = kTRUE;
882 if(fMaxCluster > 0) {
883 if(phtb[0] > fMaxCluster) checknoise = kFALSE;
884 if(fNbTimeBins > fNbMaxCluster) {
885 for(Int_t k = (fNbTimeBins-fNbMaxCluster); k < fNbTimeBins; k++){
886 if(phtb[k] > fMaxCluster) checknoise = kFALSE;
01239968 887 }
54f2ff1c 888 }
b2277aa2 889 }
890 if(checknoise) {
891 for(int ic=0; ic<fNbTimeBins; ic++){
892 if(fFillZero) {
893 fPH2dTest->Fill((Double_t)(ic/10.0),detector+0.5,(Double_t)phtb[ic]);
894 fPH2dSum->Fill((Double_t)(ic/10.0),0.5,(Double_t)phtb[ic]);
895 fPH2dSM->Fill((Double_t)(ic/10.0),sector+0.5,(Double_t)phtb[ic]);
896 }
897 else {
898 if(phtb[ic] > 0.0) {
54f2ff1c 899 fPH2dTest->Fill((Double_t)(ic/10.0),detector+0.5,(Double_t)phtb[ic]);
b2277aa2 900 fPH2dSum->Fill((Double_t)(ic/10.0),0.0,(Double_t)phtb[ic]);
54f2ff1c 901 fPH2dSM->Fill((Double_t)(ic/10.0),sector+0.5,(Double_t)phtb[ic]);
902 }
01239968 903 }
904 }
905 }
b2277aa2 906 }
907 if(detector == 0) FindP1TrackPHtrackletV1Test(tracklet,nbclusters);
01239968 908
b2277aa2 909 } // loop on tracklets
01239968 910
b2277aa2 911
912 } // debug
913
01239968 914 if(nTRDtrackV1 > 0) {
915 ++nbTrdTracks;
916 if((status&(AliESDtrack::kTRDout)) && (!(status&(AliESDtrack::kTRDin)))) {
917 ++nbTrdTracksStandalone;
918 }
919 if((status&(AliESDtrack::kTRDin))) {
920 ++nbTrdTracksOffline;
921 }
922 }
923 //delete fFriendTrack;
924 } // loop ESD track
925
926 if(fDebug > 1) {
927 fNbTRDTrack->Fill(nbTrdTracks);
928 fNbTRDTrackStandalone->Fill(nbTrdTracksStandalone);
929 fNbTRDTrackOffline->Fill(nbTrdTracksOffline);
930 fNbTPCTRDtrack->Fill(nbTrdTracks,nbtrackTPC);
931 }
932
933 // Post output data
934 PostData(1, fListHist);
935 //cout << "AliTRDCalibTask::Exec() OUT" << endl;
936}
98937691 937
98937691 938//________________________________________________________________________
939void AliTRDCalibTask::Terminate(Option_t *)
940{
941 //
942 // Terminate
943 //
944
945 if(fTRDCalibraFillHisto) fTRDCalibraFillHisto->DestroyDebugStreamer();
946
947
948}
949//_______________________________________________________
950Bool_t AliTRDCalibTask::Load(const Char_t *filename)
951{
952 //
953 // Generic container loader
954 //
955
956 if(!TFile::Open(filename)){
957 //AliWarning(Form("Couldn't open file %s.", filename));
958 return kFALSE;
959 }
960 TList *o = 0x0;
961 if(!(o = (TList*)gFile->Get(GetName()))){
962 //AliWarning("Missing histogram container.");
963 return kFALSE;
964 }
965 fListHist = (TList*)o->Clone(GetName());
966 gFile->Close();
967 return kTRUE;
968}
57185ead 969//_______________________________________________________
970Bool_t AliTRDCalibTask::Load(TList *lister)
971{
972 //
973 // Generic container loader
974 //
975
976 fListHist = (TList*)lister->Clone(GetName());
977 return kTRUE;
978}
57185ead 979//_______________________________________________________________________________________
980void AliTRDCalibTask::AddTask(const AliTRDCalibTask * calibTask) {
981
982 //
983 // Add stats
984 //
985
986 TList *listcalibTask = calibTask->GetList();
987 if(!listcalibTask) return;
988
b2277aa2 989 THnSparseI *histoEntries = (THnSparseI *) listcalibTask->FindObject("NumberOfEntries");
990
991 TH1I *nEvents = (TH1I *) listcalibTask->FindObject(Form("NEvents_%s",(const char*)calibTask->GetName()));
992 TH1I *nEventsInput = (TH1I *) listcalibTask->FindObject(Form("NEventsInput_%s",(const char*)calibTask->GetName()));
993 TH2F *absoluteGain = (TH2F *) listcalibTask->FindObject(Form("AbsoluteGain_%s",(const char*)calibTask->GetName()));
57185ead 994
b2277aa2 995 TH1F *trdTrack = (TH1F *) listcalibTask->FindObject(Form("TRDTrack_%s",(const char*)calibTask->GetName()));
996 TH1F *trdTrackOffline = (TH1F *) listcalibTask->FindObject(Form("TRDTrackOffline_%s",(const char*)calibTask->GetName()));
997 TH1F *trdTrackStandalone = (TH1F *) listcalibTask->FindObject(Form("TRDTrackStandalone_%s",(const char*)calibTask->GetName()));
57185ead 998
b2277aa2 999 TH2F *tpctrdTrack = (TH2F *) listcalibTask->FindObject(Form("NbTPCTRDtrack_%s",(const char*)calibTask->GetName()));
57185ead 1000
b2277aa2 1001 TH1F *nbTimeBin = (TH1F *) listcalibTask->FindObject(Form("NbTimeBin_%s",(const char*)calibTask->GetName()));
1002 TH1F *nbTimeBinOffline = (TH1F *) listcalibTask->FindObject(Form("NbTimeBinOffline_%s",(const char*)calibTask->GetName()));
1003 TH1F *nbTimeBinStandalone = (TH1F *) listcalibTask->FindObject(Form("NbTimeBinStandalone_%s",(const char*)calibTask->GetName()));
57185ead 1004
b2277aa2 1005 TH1F *nbClusters = (TH1F *) listcalibTask->FindObject(Form("NbClusters_%s",(const char*)calibTask->GetName()));
1006 TH1F *nbClustersOffline = (TH1F *) listcalibTask->FindObject(Form("NbClustersOffline_%s",(const char*)calibTask->GetName()));
1007 TH1F *nbClustersStandalone = (TH1F *) listcalibTask->FindObject(Form("NbClustersStandalone_%s",(const char*)calibTask->GetName()));
57185ead 1008
b2277aa2 1009 TH1F *nbTracklets = (TH1F *) listcalibTask->FindObject(Form("NbTracklets_%s",(const char*)calibTask->GetName()));
1010 TH1F *nbTrackletsOffline = (TH1F *) listcalibTask->FindObject(Form("NbTrackletsOffline_%s",(const char*)calibTask->GetName()));
1011 TH1F *nbTrackletsStandalone = (TH1F *) listcalibTask->FindObject(Form("NbTrackletsStandalone_%s",(const char*)calibTask->GetName()));
57185ead 1012
1013 TH2I *ch2d = (TH2I *) listcalibTask->FindObject("CH2d");
1014 TProfile2D *ph2d = (TProfile2D *) listcalibTask->FindObject("PH2d");
1015 TProfile2D *prf2d = (TProfile2D *) listcalibTask->FindObject("PRF2d");
1016
b2277aa2 1017 TH2I *ch2dSum = (TH2I *) listcalibTask->FindObject(Form("CH2dSum_%s",(const char*)calibTask->GetName()));
1018 TProfile2D *ph2dSum = (TProfile2D *) listcalibTask->FindObject(Form("PH2dSum_%s",(const char*)calibTask->GetName()));
57185ead 1019
b2277aa2 1020 TH2I *ch2dSM = (TH2I *) listcalibTask->FindObject(Form("CH2dSM_%s",(const char*)calibTask->GetName()));
1021 TProfile2D *ph2dSM = (TProfile2D *) listcalibTask->FindObject(Form("PH2dSM_%s",(const char*)calibTask->GetName()));
57185ead 1022
1023 AliTRDCalibraVdriftLinearFit *linearfit = (AliTRDCalibraVdriftLinearFit *) listcalibTask->FindObject("AliTRDCalibraVdriftLinearFit");
a0bb5615 1024 AliTRDCalibraExbAltFit *exbaltfit = (AliTRDCalibraExbAltFit *) listcalibTask->FindObject("AliTRDCalibraExbAltFit");
57185ead 1025 AliTRDCalibraVector *calibraVector = (AliTRDCalibraVector *) listcalibTask->FindObject("AliTRDCalibraVector");
1026
1027 //
1028
b2277aa2 1029 THnSparseI *inhistoEntries = (THnSparseI *) fListHist->FindObject("NumberOfEntries");
57185ead 1030
b2277aa2 1031 TH1I *inEventsInput = (TH1I *) fListHist->FindObject(Form("NEventsInput_%s",(const char*)fName));
1032 TH1I *inEvents = (TH1I *) fListHist->FindObject(Form("NEvents_%s",(const char*)fName));
1033 TH2F *iabsoluteGain = (TH2F *) fListHist->FindObject(Form("AbsoluteGain_%s",(const char*)fName));
57185ead 1034
b2277aa2 1035 TH1F *itrdTrack = (TH1F *) fListHist->FindObject(Form("TRDTrack_%s",(const char*)fName));
1036 TH1F *itrdTrackOffline = (TH1F *) fListHist->FindObject(Form("TRDTrackOffline_%s",(const char*)fName));
1037 TH1F *itrdTrackStandalone = (TH1F *) fListHist->FindObject(Form("TRDTrackStandalone_%s",(const char*)fName));
21185a48 1038
b2277aa2 1039 TH2F *itpctrdTrack = (TH2F *) fListHist->FindObject(Form("NbTPCTRDtrack_%s",(const char*)fName));
57185ead 1040
b2277aa2 1041 TH1F *inbTimeBin = (TH1F *) fListHist->FindObject(Form("NbTimeBin_%s",(const char*)fName));
1042 TH1F *inbTimeBinOffline = (TH1F *) fListHist->FindObject(Form("NbTimeBinOffline_%s",(const char*)fName));
1043 TH1F *inbTimeBinStandalone = (TH1F *) fListHist->FindObject(Form("NbTimeBinStandalone_%s",(const char*)fName));
57185ead 1044
b2277aa2 1045 TH1F *inbClusters = (TH1F *) fListHist->FindObject(Form("NbClusters_%s",(const char*)fName));
1046 TH1F *inbClustersOffline = (TH1F *) fListHist->FindObject(Form("NbClustersOffline_%s",(const char*)fName));
1047 TH1F *inbClustersStandalone = (TH1F *) fListHist->FindObject(Form("NbClustersStandalone_%s",(const char*)fName));
1048
1049 TH1F *inbTracklets = (TH1F *) fListHist->FindObject(Form("NbTracklets_%s",(const char*)fName));
1050 TH1F *inbTrackletsOffline = (TH1F *) fListHist->FindObject(Form("NbTrackletsOffline_%s",(const char*)fName));
1051 TH1F *inbTrackletsStandalone = (TH1F *) fListHist->FindObject(Form("NbTrackletsStandalone_%s",(const char*)fName));
57185ead 1052
1053 TH2I *ich2d = (TH2I *) fListHist->FindObject("CH2d");
1054 TProfile2D *iph2d = (TProfile2D *) fListHist->FindObject("PH2d");
1055 TProfile2D *iprf2d = (TProfile2D *) fListHist->FindObject("PRF2d");
1056
b2277aa2 1057 TH2I *ich2dSum = (TH2I *) fListHist->FindObject(Form("CH2dSum_%s",(const char*)fName));
1058 TProfile2D *iph2dSum = (TProfile2D *) fListHist->FindObject(Form("PH2dSum_%s",(const char*)fName));
57185ead 1059
b2277aa2 1060 TH2I *ich2dSM = (TH2I *) fListHist->FindObject(Form("CH2dSM_%s",(const char*)fName));
1061 TProfile2D *iph2dSM = (TProfile2D *) fListHist->FindObject(Form("PH2dSM_%s",(const char*)fName));
57185ead 1062
1063 AliTRDCalibraVdriftLinearFit *ilinearfit = (AliTRDCalibraVdriftLinearFit *) fListHist->FindObject("AliTRDCalibraVdriftLinearFit");
a0bb5615 1064 AliTRDCalibraExbAltFit *iexbaltfit = (AliTRDCalibraExbAltFit *) fListHist->FindObject("AliTRDCalibraExbAltFit");
57185ead 1065 AliTRDCalibraVector *icalibraVector = (AliTRDCalibraVector *) fListHist->FindObject("AliTRDCalibraVector");
1066
1067
1068 // Add
a5dcf618 1069
b2277aa2 1070 if(histoEntries) {
1071 if(inhistoEntries) {
1072 inhistoEntries->Add(histoEntries);
1073 //printf("Add Events\n");
1074 }
1075 else {
1076 //printf("Create new Events\n");
1077 inhistoEntries = (THnSparseI *) histoEntries->Clone();
1078 fListHist->Add(inhistoEntries);
1079 }
1080 }
1081
a5dcf618 1082 if(nEventsInput) {
1083 if(inEventsInput) {
1084 inEventsInput->Add(nEventsInput);
1085 //printf("Add Events\n");
1086 }
1087 else {
1088 //printf("Create new Events\n");
1089 inEventsInput = new TH1I(*nEventsInput);
1090 fListHist->Add(inEventsInput);
1091 }
1092 }
57185ead 1093
1094 if(nEvents) {
1095 if(inEvents) {
1096 inEvents->Add(nEvents);
1097 //printf("Add Events\n");
1098 }
1099 else {
1100 //printf("Create new Events\n");
1101 inEvents = new TH1I(*nEvents);
1102 fListHist->Add(inEvents);
1103 }
1104 }
1105
1106 if(absoluteGain) {
1107 if(iabsoluteGain) iabsoluteGain->Add(absoluteGain);
1108 else {
1109 iabsoluteGain = new TH2F(*absoluteGain);
1110 fListHist->Add(iabsoluteGain);
1111 }
1112 }
1113
1114 if(trdTrack) {
1115 if(itrdTrack) itrdTrack->Add(trdTrack);
1116 else {
1117 itrdTrack = new TH1F(*trdTrack);
1118 fListHist->Add(itrdTrack);
1119 }
1120 }
1121
1122 if(trdTrackOffline) {
1123 if(itrdTrackOffline) itrdTrackOffline->Add(trdTrackOffline);
1124 else {
1125 itrdTrackOffline = new TH1F(*trdTrackOffline);
1126 fListHist->Add(itrdTrackOffline);
1127 }
1128 }
1129
1130 if(trdTrackStandalone) {
1131 if(itrdTrackStandalone) itrdTrackStandalone->Add(trdTrackStandalone);
1132 else {
1133 itrdTrackStandalone = new TH1F(*trdTrackStandalone);
1134 fListHist->Add(itrdTrackStandalone);
1135 }
1136 }
1137
1138 if(tpctrdTrack) {
1139 if(itpctrdTrack) itpctrdTrack->Add(tpctrdTrack);
1140 else {
1141 itpctrdTrack = new TH2F(*tpctrdTrack);
1142 fListHist->Add(itpctrdTrack);
1143 }
1144 }
1145
1146 if(nbTimeBin) {
1147 if(inbTimeBin) inbTimeBin->Add(nbTimeBin);
1148 else {
1149 inbTimeBin = new TH1F(*inbTimeBin);
1150 fListHist->Add(inbTimeBin);
1151 }
1152 }
1153
1154 if(nbTimeBinOffline) {
1155 if(inbTimeBinOffline) inbTimeBinOffline->Add(nbTimeBinOffline);
1156 else {
1157 inbTimeBinOffline = new TH1F(*nbTimeBinOffline);
1158 fListHist->Add(inbTimeBinOffline);
1159 }
1160 }
1161
1162 if(nbTimeBinStandalone) {
1163 if(inbTimeBinStandalone) inbTimeBinStandalone->Add(nbTimeBinStandalone);
1164 else {
1165 inbTimeBinStandalone = new TH1F(*nbTimeBinStandalone);
1166 fListHist->Add(inbTimeBinStandalone);
1167 }
1168 }
1169
1170 if(nbClusters) {
1171 if(inbClusters) inbClusters->Add(nbClusters);
1172 else {
1173 inbClusters = new TH1F(*nbClusters);
1174 fListHist->Add(inbClusters);
1175 }
1176 }
1177
1178 if(nbClustersOffline) {
1179 if(inbClustersOffline) inbClustersOffline->Add(nbClustersOffline);
1180 else {
1181 inbClustersOffline = new TH1F(*nbClustersOffline);
1182 fListHist->Add(inbClustersOffline);
1183 }
1184 }
1185
1186 if(nbClustersStandalone) {
1187 if(inbClustersStandalone) inbClustersStandalone->Add(nbClustersStandalone);
1188 else {
1189 inbClustersStandalone = new TH1F(*nbClustersStandalone);
1190 fListHist->Add(inbClustersStandalone);
1191 }
1192 }
1193
1194 if(nbTracklets) {
1195 if(inbTracklets) inbTracklets->Add(nbTracklets);
1196 else {
1197 inbTracklets = new TH1F(*nbTracklets);
1198 fListHist->Add(inbTracklets);
1199 }
1200 }
1201
1202 if(nbTrackletsOffline) {
1203 if(inbTrackletsOffline) inbTrackletsOffline->Add(nbTrackletsOffline);
1204 else {
1205 inbTrackletsOffline = new TH1F(*nbTrackletsOffline);
1206 fListHist->Add(inbTrackletsOffline);
1207 }
1208 }
1209
1210 if(nbTrackletsStandalone) {
1211 if(inbTrackletsStandalone) inbTrackletsStandalone->Add(nbTrackletsStandalone);
1212 else {
1213 inbTrackletsStandalone = new TH1F(*nbTrackletsStandalone);
1214 fListHist->Add(inbTrackletsStandalone);
1215 }
1216 }
1217
1218 if(ch2d) {
1219 if(ich2d) ich2d->Add(ch2d);
1220 else {
1221 ich2d = new TH2I(*ch2d);
1222 fListHist->Add(ich2d);
1223 }
1224 }
1225
1226 if(ph2d) {
1227 if(iph2d) iph2d->Add(ph2d);
1228 else {
1229 iph2d = new TProfile2D(*ph2d);
1230 fListHist->Add(iph2d);
1231 }
1232 }
1233
1234 if(prf2d) {
1235 if(iprf2d) iprf2d->Add(prf2d);
1236 else {
1237 iprf2d = new TProfile2D(*prf2d);
1238 fListHist->Add(iprf2d);
1239 }
1240 }
1241
1242 if(ch2dSum) {
1243 if(ich2dSum) ich2dSum->Add(ch2dSum);
1244 else {
1245 ich2dSum = new TH2I(*ch2dSum);
1246 fListHist->Add(ich2dSum);
1247 }
1248 }
1249
1250 if(ph2dSum) {
1251 if(iph2dSum) iph2dSum->Add(ph2dSum);
1252 else {
1253 iph2dSum = new TProfile2D(*ph2dSum);
1254 fListHist->Add(iph2dSum);
1255 }
1256 }
1257
1258 if(ch2dSM) {
1259 if(ich2dSM) ich2dSM->Add(ch2dSM);
1260 else {
1261 ich2dSM = new TH2I(*ch2dSM);
1262 fListHist->Add(ich2dSM);
1263 }
1264 }
1265
1266 if(ph2dSM) {
1267 if(iph2dSM) iph2dSM->Add(ph2dSM);
1268 else {
1269 iph2dSM = new TProfile2D(*ph2dSM);
1270 fListHist->Add(iph2dSM);
1271 }
1272 }
1273
1274 if(linearfit) {
1275 if(ilinearfit) ilinearfit->Add(linearfit);
1276 else {
1277 ilinearfit = new AliTRDCalibraVdriftLinearFit(*linearfit);
1278 fListHist->Add(ilinearfit);
1279 }
a0bb5615 1280 }
1281
1282 if(exbaltfit) {
1283 if(iexbaltfit) iexbaltfit->Add(exbaltfit);
1284 else {
1285 iexbaltfit = new AliTRDCalibraExbAltFit(*exbaltfit);
1286 fListHist->Add(iexbaltfit);
1287 }
1288 }
57185ead 1289
1290 if(calibraVector) {
1291 if(icalibraVector) icalibraVector->Add(calibraVector);
1292 else {
1293 icalibraVector = new AliTRDCalibraVector(*calibraVector);
1294 fListHist->Add(icalibraVector);
1295 }
1296 }
1297
1298}
1299//________________________________________________________________________________
1300Long64_t AliTRDCalibTask::Merge(TCollection *li) {
1301
1302 //
1303 // merge component
1304 //
1305
1306 TIterator* iter = li->MakeIterator();
1307 AliTRDCalibTask* cal = 0;
1308
1309 while ((cal = (AliTRDCalibTask*)iter->Next())) {
1310 if (!cal->InheritsFrom(AliTRDCalibTask::Class())) {
1311 Error("Merge","Attempt to add object of class %s to a %s", cal->ClassName(), this->ClassName());
1312 return -1;
1313 }
1314
1315 // add histograms here...
1316 this->AddTask(cal);
1317
1318 }
1319
1320 return 0;
1321
1322}
a2a4ec8e 1323//_____________________________________________________
1324Bool_t AliTRDCalibTask::SetVersionSubversion(){
1325 //
1326 // Load Chamber Gain factors into the Tender supply
1327 //
1328
1329 printf("SetVersionSubversion\n");
1330
1331 //find previous entry from the UserInfo
1332 TTree *tree=((TChain*)GetInputData(0))->GetTree();
1333 if (!tree) {
1334 AliError("Tree not found in ESDhandler");
1335 return kFALSE;
1336 }
1337
1338 TList *userInfo=(TList*)tree->GetUserInfo();
1339 if (!userInfo) {
1340 AliError("No UserInfo found in tree");
1341 return kFALSE;
1342 }
1343
1344 TList *cdbList=(TList*)userInfo->FindObject("cdbList");
1345 if (!cdbList) {
1346 AliError("No cdbList found in UserInfo");
1347 if (AliLog::GetGlobalLogLevel()>=AliLog::kError) userInfo->Print();
1348 return kFALSE;
1349 }
1350
1351 TIter nextCDB(cdbList);
1352 TObjString *os=0x0;
1353 while ( (os=(TObjString*)nextCDB()) ){
1354 if(os->GetString().Contains("TRD/Calib/ChamberGainFactor")){
1355 // Get Old gain calibration
1356 AliCDBId *id=AliCDBId::MakeFromString(os->GetString());
d085ba91 1357 fFirstRunGain = id->GetFirstRun();
a2a4ec8e 1358 fVersionGainUsed = id->GetVersion();
1359 fSubVersionGainUsed = id->GetSubVersion();
1360 } else if(os->GetString().Contains("TRD/Calib/ChamberVdrift")){
1361 // Get Old drift velocity calibration
1362 AliCDBId *id=AliCDBId::MakeFromString(os->GetString());
d085ba91 1363 fFirstRunVdrift = id->GetFirstRun();
a2a4ec8e 1364 fVersionVdriftUsed = id->GetVersion();
1365 fSubVersionVdriftUsed = id->GetSubVersion();
1366 } else if(os->GetString().Contains("TRD/Calib/LocalGainFactor")){
1367 // Get Old drift velocity calibration
1368 AliCDBId *id=AliCDBId::MakeFromString(os->GetString());
d085ba91 1369 fFirstRunGainLocal = id->GetFirstRun();
a2a4ec8e 1370 fVersionGainLocalUsed = id->GetVersion();
1371 fSubVersionGainLocalUsed = id->GetSubVersion();
709b13d5 1372 } else if((os->GetString().Contains("TRD/Calib/ChamberExB")) && (!os->GetString().Contains("TRD/Calib/ChamberExBAlt"))){
b2277aa2 1373 // Get Old drift velocity calibration
1374 AliCDBId *id=AliCDBId::MakeFromString(os->GetString());
1375 fFirstRunExB = id->GetFirstRun();
1376 fVersionExBUsed = id->GetVersion();
1377 fSubVersionExBUsed = id->GetSubVersion();
709b13d5 1378 //printf("Version %d and subversion %d\n",fVersionExBUsed,fSubVersionExBUsed);
a2a4ec8e 1379 }
1380 }
1381
1382 //printf("VersionGain %d, SubversionGain %d, VersionLocalGain %d, Subversionlocalgain %d, Versionvdrift %d, Subversionvdrift %d\n",fVersionGainUsed,fSubVersionGainUsed,fVersionGainLocalUsed,fSubVersionGainLocalUsed,fVersionVdriftUsed,fSubVersionVdriftUsed);
1383
1384 // Check
d085ba91 1385 if((fFirstRunGain < 0) ||
1386 (fFirstRunGainLocal < 0) ||
1387 (fFirstRunVdrift < 0) ||
1388 (fVersionGainUsed < 0) ||
1389 (fVersionGainLocalUsed < 0) ||
1390 (fSubVersionGainUsed < 0) ||
1391 (fSubVersionGainLocalUsed < 0) ||
1392 (fVersionVdriftUsed < 0) ||
1393 (fSubVersionVdriftUsed < 0)) {
a2a4ec8e 1394 AliError("No recent calibration found");
1395 return kFALSE;
1396 }
1397 else return kTRUE;
1398
1399}
c1105918 1400//_________________________________________________________________________________________________________________________
1401Bool_t AliTRDCalibTask::ParticleGood(int i) const {
1402
1403 //
1404 // Definition of good tracks
1405 //
1406
1407
1408 AliESDtrack *track = fESD->GetTrack(i);
1409 if (!track->IsOn(AliESDtrack::kTPCrefit)) return 0; // TPC refit
1410 if (track->GetTPCNcls() < 90) return 0; // number of TPC clusters
1411 if (fabs(track->Eta())>0.8) return 0; // fiducial pseudorapidity
1412 Float_t r,z;
1413 track->GetImpactParametersTPC(r,z);
1414 if (fabs(z)>2.0) return 0; // impact parameter in z
1415 if (fabs(r)>2.0) return 0; // impact parameter in xy
1416 if (r==0) return 0;
1417 return 1;
1418
1419
1420}
54f2ff1c 1421//______________________________________________________________________________________________________________________
1422Bool_t AliTRDCalibTask::FindP1TrackPHtrackletV1Test(const AliTRDseedV1 *tracklet, Int_t nbclusters)
1423{
1424 //
1425 // Drift velocity calibration:
1426 // Fit the clusters with a straight line
1427 // From the slope find the drift velocity
1428 //
1429
1430 ////////////////////////////////////////////////
1431 //Number of points: if less than 3 return kFALSE
1432 /////////////////////////////////////////////////
1433 if(nbclusters <= 2) return kFALSE;
1434
1435 ////////////
1436 //Variables
1437 ////////////
1438 // results of the linear fit
1439 Double_t dydt = 0.0; // dydt tracklet after straight line fit
1440 Double_t errorpar = 0.0; // error after straight line fit on dy/dt
1441 Double_t pointError = 0.0; // error after straight line fit
1442 // pad row problemes: avoid tracklet that cross pad rows, tilting angle in the constant
1443 Int_t crossrow = 0; // if it crosses a pad row
1444 Int_t rowp = -1; // if it crosses a pad row
1445 Float_t tnt = tracklet->GetTilt(); // tan tiltingangle
1446 TLinearFitter linearFitterTracklet(2,"pol1");
1447 linearFitterTracklet.StoreData(kTRUE);
1448
1449
1450 ///////////////////////////////////////////
1451 // Take the parameters of the track
1452 //////////////////////////////////////////
1453 // take now the snp, tnp and tgl from the track
1454 Double_t snp = tracklet->GetSnp(); // sin dy/dx at the end of the chamber
1455 Double_t tnp = 0.0; // dy/dx at the end of the chamber
1456 if( TMath::Abs(snp) < 1.){
1457 tnp = snp / TMath::Sqrt((1.-snp)*(1.+snp));
1458 }
1459 Double_t tgl = tracklet->GetTgl(); // dz/dl
1460 Double_t dzdx = tgl*TMath::Sqrt(1+tnp*tnp); // dz/dx calculated from dz/dl
1461 // at the entrance
1462 //Double_t tnp = tracklet->GetYref(1); // dy/dx at the entrance of the chamber
1463 //Double_t tgl = tracklet->GetZref(1); // dz/dl at the entrance of the chamber
1464 //Double_t dzdx = tgl; //*TMath::Sqrt(1+tnp*tnp); // dz/dx from dz/dl
1465 // at the end with correction due to linear fit
1466 //Double_t tnp = tracklet->GetYfit(1); // dy/dx at the end of the chamber after fit correction
1467 //Double_t tgl = tracklet->GetZfit(1); // dz/dl at the end of the chamber after fit correction
1468
1469
1470 ////////////////////////////
1471 // loop over the clusters
1472 ////////////////////////////
1473 Int_t nbli = 0;
1474 AliTRDcluster *cl = 0x0;
1475 //////////////////////////////
1476 // Check no shared clusters
1477 //////////////////////////////
1478 for(int icc=AliTRDseedV1::kNtb; icc<AliTRDseedV1::kNclusters; icc++){
1479 cl = tracklet->GetClusters(icc);
1480 if(cl) crossrow = 1;
1481 }
1482 //////////////////////////////////
1483 // Loop clusters
1484 //////////////////////////////////
1485 for(int ic=0; ic<AliTRDseedV1::kNtb; ic++){
1486 if(!(cl = tracklet->GetClusters(ic))) continue;
1487 //if((fLimitChargeIntegration) && (!cl->IsInChamber())) continue;
1488
1489 Double_t ycluster = cl->GetY();
1490 Int_t time = cl->GetPadTime();
1491 Double_t timeis = time/10.0;
1492 //See if cross two pad rows
1493 Int_t row = cl->GetPadRow();
1494 if(rowp==-1) rowp = row;
1495 if(row != rowp) crossrow = 1;
c1105918 1496
54f2ff1c 1497 linearFitterTracklet.AddPoint(&timeis,ycluster,1);
1498 nbli++;
a2a4ec8e 1499
54f2ff1c 1500
1501 }
1502
1503 ////////////////////////////////////
1504 // Do the straight line fit now
1505 ///////////////////////////////////
1506 if(nbli <= 2){
1507 linearFitterTracklet.ClearPoints();
1508 return kFALSE;
1509 }
1510 TVectorD pars;
1511 linearFitterTracklet.Eval();
1512 linearFitterTracklet.GetParameters(pars);
1513 pointError = TMath::Sqrt(linearFitterTracklet.GetChisquare()/(nbli-2));
1514 errorpar = linearFitterTracklet.GetParError(1)*pointError;
1515 dydt = pars[1];
1516 //printf("chis %f, nbli %d, pointError %f, parError %f, errorpar %f\n",linearFitterTracklet->GetChisquare(),nbli,pointError,linearFitterTracklet->GetParError(1),errorpar);
1517 linearFitterTracklet.ClearPoints();
1518
1519 /////////////////////////
1520 // Cuts quality
1521 ////////////////////////
1522
1523 if(nbclusters < fLow) return kFALSE;
1524 if(nbclusters > fHigh) return kFALSE;
1525 if(pointError >= 0.3) return kFALSE;
1526 if(crossrow == 1) return kTRUE;
1527
1528 ///////////////////////
1529 // Fill
1530 //////////////////////
1531
1532 if(fDebug > 0){
1533 //Add to the linear fitter of the detector
1534 if( TMath::Abs(snp) < 1.){
1535 Double_t x = tnp-dzdx*tnt;
1536 //if(!fLinearVdriftTest) printf("Not there\n");
1537 Double_t nbentries = fLinearVdriftTest->GetEntries();
1538 if(nbentries < (5.0*32767)) fLinearVdriftTest->Fill(x,dydt);
1539 }
1540 }
1541
1542 return kTRUE;
1543}
01239968 1544