]> git.uio.no Git - u/mrichter/AliRoot.git/blame - TRD/AliTRDCalibraFillHisto.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
initialize x,y,z such to avoid unconditional jump (bug #81839)
[u/mrichter/AliRoot.git] / TRD / AliTRDCalibraFillHisto.cxx
CommitLineData
64942b85 1//**************************************************************************
2// * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3// * *
4// * Author: The ALICE Off-line Project. *
5// * Contributors are mentioned in the code where appropriate. *
6// * *
7// * Permission to use, copy, modify and distribute this software and its *
8// * documentation strictly for non-commercial purposes is hereby granted *
9// * without fee, provided that the above copyright notice appears in all *
10// * copies and that both the copyright notice and this permission notice *
11//* appear in the supporting documentation. The authors make no claims *
12//* about the suitability of this software for any purpose. It is *
13//* provided "as is" without express or implied warranty. *
14//**************************************************************************/
55a288e5 15
16/* $Id$ */
17
18/////////////////////////////////////////////////////////////////////////////////
170c35f1 19//
55a288e5 20// AliTRDCalibraFillHisto
21//
22// This class is for the TRD calibration of the relative gain factor, the drift velocity,
23// the time 0 and the pad response function. It fills histos or vectors.
24// It can be used for the calibration per chamber but also per group of pads and eventually per pad.
170c35f1 25// The user has to choose with the functions SetNz and SetNrphi the precision of the calibration (see AliTRDCalibraMode).
55a288e5 26// 2D Histograms (Histo2d) or vectors (Vector2d), then converted in Trees, will be filled
27// from RAW DATA in a run or from reconstructed TRD tracks during the offline tracking
28// in the function "FollowBackProlongation" (AliTRDtracker)
29// Per default the functions to fill are off.
30//
1785640c 31// Authors:
32// R. Bailhache (R.Bailhache@gsi.de, rbailhache@ikf.uni-frankfurt.de)
33// J. Book (jbook@ikf.uni-frankfurt.de)
55a288e5 34//
35//////////////////////////////////////////////////////////////////////////////////////
36
55a288e5 37#include <TProfile2D.h>
38#include <TProfile.h>
39#include <TFile.h>
55a288e5 40#include <TStyle.h>
41#include <TCanvas.h>
55a288e5 42#include <TObjArray.h>
d0569428 43#include <TObject.h>
55a288e5 44#include <TH1F.h>
45#include <TH2I.h>
46#include <TH2.h>
47#include <TStopwatch.h>
48#include <TMath.h>
49#include <TDirectory.h>
170c35f1 50#include <TTreeStream.h>
51#include <TVectorD.h>
6bbdc11a 52#include <TLinearFitter.h>
55a288e5 53
54#include "AliLog.h"
55a288e5 55
56#include "AliTRDCalibraFillHisto.h"
57#include "AliTRDCalibraMode.h"
58#include "AliTRDCalibraVector.h"
3a0f6479 59#include "AliTRDCalibraVdriftLinearFit.h"
55a288e5 60#include "AliTRDcalibDB.h"
61#include "AliTRDCommonParam.h"
55a288e5 62#include "AliTRDpadPlane.h"
63#include "AliTRDcluster.h"
bcb6fb78 64#include "AliTRDtrackV1.h"
3a0f6479 65#include "AliRawReader.h"
66#include "AliRawReaderDate.h"
f162af62 67#include "AliTRDgeometry.h"
d0569428 68#include "./Cal/AliTRDCalROC.h"
a2a4ec8e 69#include "./Cal/AliTRDCalPad.h"
d0569428 70#include "./Cal/AliTRDCalDet.h"
170c35f1 71
1785640c 72#include "AliTRDdigitsManager.h"
73#include "AliTRDdigitsParam.h"
74#include "AliTRDSignalIndex.h"
75#include "AliTRDarrayADC.h"
76
fd50bb14 77#include "AliTRDrawStream.h"
78
a2a4ec8e 79#include "AliCDBEntry.h"
80#include "AliCDBManager.h"
fd50bb14 81
170c35f1 82#ifdef ALI_DATE
83#include "event.h"
84#endif
55a288e5 85
3a0f6479 86
55a288e5 87ClassImp(AliTRDCalibraFillHisto)
88
89AliTRDCalibraFillHisto* AliTRDCalibraFillHisto::fgInstance = 0;
90Bool_t AliTRDCalibraFillHisto::fgTerminated = kFALSE;
91
92//_____________singleton implementation_________________________________________________
93AliTRDCalibraFillHisto *AliTRDCalibraFillHisto::Instance()
94{
95 //
96 // Singleton implementation
97 //
98
99 if (fgTerminated != kFALSE) {
100 return 0;
101 }
102
103 if (fgInstance == 0) {
104 fgInstance = new AliTRDCalibraFillHisto();
105 }
106
107 return fgInstance;
108
109}
110
111//______________________________________________________________________________________
112void AliTRDCalibraFillHisto::Terminate()
113{
114 //
115 // Singleton implementation
116 // Deletes the instance of this class
117 //
118
119 fgTerminated = kTRUE;
120
121 if (fgInstance != 0) {
122 delete fgInstance;
123 fgInstance = 0;
124 }
125
126}
3a0f6479 127
55a288e5 128//______________________________________________________________________________________
129AliTRDCalibraFillHisto::AliTRDCalibraFillHisto()
130 :TObject()
f162af62 131 ,fGeo(0)
01239968 132 ,fCalibDB(0)
64942b85 133 ,fIsHLT(kFALSE)
55a288e5 134 ,fCH2dOn(kFALSE)
135 ,fPH2dOn(kFALSE)
136 ,fPRF2dOn(kFALSE)
137 ,fHisto2d(kFALSE)
138 ,fVector2d(kFALSE)
170c35f1 139 ,fLinearFitterOn(kFALSE)
140 ,fLinearFitterDebugOn(kFALSE)
55a288e5 141 ,fRelativeScale(0)
170c35f1 142 ,fThresholdClusterPRF2(15.0)
b70c68da 143 ,fLimitChargeIntegration(kFALSE)
f9ed5395 144 ,fFillWithZero(kFALSE)
64942b85 145 ,fNormalizeNbOfCluster(kFALSE)
146 ,fMaxCluster(0)
147 ,fNbMaxCluster(0)
d085ba91 148 ,fFirstRunGain(0)
4c865c34 149 ,fVersionGainUsed(0)
150 ,fSubVersionGainUsed(0)
d085ba91 151 ,fFirstRunGainLocal(0)
a2a4ec8e 152 ,fVersionGainLocalUsed(0)
153 ,fSubVersionGainLocalUsed(0)
d085ba91 154 ,fFirstRunVdrift(0)
4c865c34 155 ,fVersionVdriftUsed(0)
156 ,fSubVersionVdriftUsed(0)
170c35f1 157 ,fCalibraMode(new AliTRDCalibraMode())
158 ,fDebugStreamer(0)
159 ,fDebugLevel(0)
55a288e5 160 ,fDetectorPreviousTrack(-1)
e4db522f 161 ,fMCMPrevious(-1)
162 ,fROBPrevious(-1)
64942b85 163 ,fNumberClusters(1)
bcb6fb78 164 ,fNumberClustersf(30)
6aafa7ea 165 ,fNumberClustersProcent(0.5)
166 ,fThresholdClustersDAQ(120.0)
167 ,fNumberRowDAQ(2)
168 ,fNumberColDAQ(4)
170c35f1 169 ,fProcent(6.0)
170 ,fDifference(17)
171 ,fNumberTrack(0)
172 ,fTimeMax(0)
173 ,fSf(10.0)
e526983e 174 ,fNumberBinCharge(50)
175 ,fNumberBinPRF(10)
176 ,fNgroupprf(3)
55a288e5 177 ,fAmpTotal(0x0)
178 ,fPHPlace(0x0)
179 ,fPHValue(0x0)
170c35f1 180 ,fGoodTracklet(kTRUE)
1ca79a00 181 ,fLinearFitterTracklet(0x0)
170c35f1 182 ,fEntriesCH(0x0)
183 ,fEntriesLinearFitter(0x0)
184 ,fCalibraVector(0x0)
55a288e5 185 ,fPH2d(0x0)
186 ,fPRF2d(0x0)
187 ,fCH2d(0x0)
d0569428 188 ,fLinearFitterArray(540)
3a0f6479 189 ,fLinearVdriftFit(0x0)
d0569428 190 ,fCalDetGain(0x0)
191 ,fCalROCGain(0x0)
55a288e5 192{
193 //
194 // Default constructor
195 //
196
170c35f1 197 //
198 // Init some default values
199 //
55a288e5 200
170c35f1 201 fNumberUsedCh[0] = 0;
202 fNumberUsedCh[1] = 0;
203 fNumberUsedPh[0] = 0;
204 fNumberUsedPh[1] = 0;
3a0f6479 205
f162af62 206 fGeo = new AliTRDgeometry();
01239968 207 fCalibDB = AliTRDcalibDB::Instance();
55a288e5 208}
f162af62 209
55a288e5 210//______________________________________________________________________________________
211AliTRDCalibraFillHisto::AliTRDCalibraFillHisto(const AliTRDCalibraFillHisto &c)
f162af62 212 :TObject(c)
213 ,fGeo(0)
01239968 214 ,fCalibDB(0)
64942b85 215 ,fIsHLT(c.fIsHLT)
f162af62 216 ,fCH2dOn(c.fCH2dOn)
217 ,fPH2dOn(c.fPH2dOn)
218 ,fPRF2dOn(c.fPRF2dOn)
219 ,fHisto2d(c.fHisto2d)
220 ,fVector2d(c.fVector2d)
221 ,fLinearFitterOn(c.fLinearFitterOn)
222 ,fLinearFitterDebugOn(c.fLinearFitterDebugOn)
223 ,fRelativeScale(c.fRelativeScale)
224 ,fThresholdClusterPRF2(c.fThresholdClusterPRF2)
b70c68da 225 ,fLimitChargeIntegration(c.fLimitChargeIntegration)
37b0cf5e 226 ,fFillWithZero(c.fFillWithZero)
64942b85 227 ,fNormalizeNbOfCluster(c.fNormalizeNbOfCluster)
228 ,fMaxCluster(c.fMaxCluster)
229 ,fNbMaxCluster(c.fNbMaxCluster)
d085ba91 230 ,fFirstRunGain(c.fFirstRunGain)
4c865c34 231 ,fVersionGainUsed(c.fVersionGainUsed)
232 ,fSubVersionGainUsed(c.fSubVersionGainUsed)
d085ba91 233 ,fFirstRunGainLocal(c.fFirstRunGainLocal)
a2a4ec8e 234 ,fVersionGainLocalUsed(c.fVersionGainLocalUsed)
235 ,fSubVersionGainLocalUsed(c.fSubVersionGainLocalUsed)
d085ba91 236 ,fFirstRunVdrift(c.fFirstRunVdrift)
4c865c34 237 ,fVersionVdriftUsed(c.fVersionVdriftUsed)
238 ,fSubVersionVdriftUsed(c.fSubVersionVdriftUsed)
f162af62 239 ,fCalibraMode(0x0)
240 ,fDebugStreamer(0)
241 ,fDebugLevel(c.fDebugLevel)
f162af62 242 ,fDetectorPreviousTrack(c.fDetectorPreviousTrack)
e4db522f 243 ,fMCMPrevious(c.fMCMPrevious)
244 ,fROBPrevious(c.fROBPrevious)
f162af62 245 ,fNumberClusters(c.fNumberClusters)
bcb6fb78 246 ,fNumberClustersf(c.fNumberClustersf)
6aafa7ea 247 ,fNumberClustersProcent(c.fNumberClustersProcent)
248 ,fThresholdClustersDAQ(c.fThresholdClustersDAQ)
249 ,fNumberRowDAQ(c.fNumberRowDAQ)
1785640c 250 ,fNumberColDAQ(c.fNumberColDAQ)
f162af62 251 ,fProcent(c.fProcent)
252 ,fDifference(c.fDifference)
253 ,fNumberTrack(c.fNumberTrack)
254 ,fTimeMax(c.fTimeMax)
255 ,fSf(c.fSf)
256 ,fNumberBinCharge(c.fNumberBinCharge)
257 ,fNumberBinPRF(c.fNumberBinPRF)
258 ,fNgroupprf(c.fNgroupprf)
3a0f6479 259 ,fAmpTotal(0x0)
260 ,fPHPlace(0x0)
261 ,fPHValue(0x0)
f162af62 262 ,fGoodTracklet(c.fGoodTracklet)
1ca79a00 263 ,fLinearFitterTracklet(0x0)
3a0f6479 264 ,fEntriesCH(0x0)
265 ,fEntriesLinearFitter(0x0)
f162af62 266 ,fCalibraVector(0x0)
267 ,fPH2d(0x0)
268 ,fPRF2d(0x0)
269 ,fCH2d(0x0)
d0569428 270 ,fLinearFitterArray(540)
3a0f6479 271 ,fLinearVdriftFit(0x0)
d0569428 272 ,fCalDetGain(0x0)
273 ,fCalROCGain(0x0)
55a288e5 274{
275 //
276 // Copy constructor
277 //
170c35f1 278 if(c.fCalibraMode) fCalibraMode = new AliTRDCalibraMode(*c.fCalibraMode);
279 if(c.fCalibraVector) fCalibraVector = new AliTRDCalibraVector(*c.fCalibraVector);
280 if(c.fPH2d) {
281 fPH2d = new TProfile2D(*c.fPH2d);
282 fPH2d->SetDirectory(0);
283 }
284 if(c.fPRF2d) {
285 fPRF2d = new TProfile2D(*c.fPRF2d);
286 fPRF2d->SetDirectory(0);
287 }
288 if(c.fCH2d) {
289 fCH2d = new TH2I(*c.fCH2d);
290 fCH2d->SetDirectory(0);
291 }
3a0f6479 292 if(c.fLinearVdriftFit){
293 fLinearVdriftFit = new AliTRDCalibraVdriftLinearFit(*c.fLinearVdriftFit);
170c35f1 294 }
3a0f6479 295
d0569428 296 if(c.fCalDetGain) fCalDetGain = new AliTRDCalDet(*c.fCalDetGain);
d0569428 297 if(c.fCalROCGain) fCalROCGain = new AliTRDCalROC(*c.fCalROCGain);
d0569428 298
f162af62 299 if (fGeo) {
300 delete fGeo;
301 }
302 fGeo = new AliTRDgeometry();
01239968 303 fCalibDB = AliTRDcalibDB::Instance();
fdc15553 304
305 fNumberUsedCh[0] = 0;
306 fNumberUsedCh[1] = 0;
307 fNumberUsedPh[0] = 0;
308 fNumberUsedPh[1] = 0;
309
55a288e5 310}
f162af62 311
55a288e5 312//____________________________________________________________________________________
313AliTRDCalibraFillHisto::~AliTRDCalibraFillHisto()
314{
315 //
316 // AliTRDCalibraFillHisto destructor
317 //
318
319 ClearHistos();
170c35f1 320 if ( fDebugStreamer ) delete fDebugStreamer;
f162af62 321
d0569428 322 if ( fCalDetGain ) delete fCalDetGain;
d0569428 323 if ( fCalROCGain ) delete fCalROCGain;
d0569428 324
1ca79a00 325 if( fLinearFitterTracklet ) { delete fLinearFitterTracklet; }
326
327 delete [] fPHPlace;
328 delete [] fPHValue;
329 delete [] fEntriesCH;
330 delete [] fEntriesLinearFitter;
331 delete [] fAmpTotal;
332
333 for(Int_t idet=0; idet<AliTRDgeometry::kNdet; idet++){
334 TLinearFitter *f = (TLinearFitter*)fLinearFitterArray.At(idet);
335 if(f) { delete f;}
336 }
46c4871e 337 if(fLinearVdriftFit) delete fLinearVdriftFit;
f162af62 338 if (fGeo) {
339 delete fGeo;
340 }
55a288e5 341
342}
55a288e5 343//_____________________________________________________________________________
344void AliTRDCalibraFillHisto::Destroy()
345{
346 //
347 // Delete instance
348 //
349
350 if (fgInstance) {
351 delete fgInstance;
352 fgInstance = 0x0;
353 }
55a288e5 354}
bcb6fb78 355//_____________________________________________________________________________
356void AliTRDCalibraFillHisto::DestroyDebugStreamer()
357{
358 //
359 // Delete DebugStreamer
360 //
55a288e5 361
bcb6fb78 362 if ( fDebugStreamer ) delete fDebugStreamer;
64942b85 363 fDebugStreamer = 0x0;
bcb6fb78 364
365}
55a288e5 366//_____________________________________________________________________________
367void AliTRDCalibraFillHisto::ClearHistos()
368{
369 //
370 // Delete the histos
371 //
372
373 if (fPH2d) {
374 delete fPH2d;
375 fPH2d = 0x0;
376 }
377 if (fCH2d) {
378 delete fCH2d;
379 fCH2d = 0x0;
380 }
381 if (fPRF2d) {
382 delete fPRF2d;
383 fPRF2d = 0x0;
384 }
3a0f6479 385
55a288e5 386}
bcb6fb78 387//////////////////////////////////////////////////////////////////////////////////
388// calibration with AliTRDtrackV1: Init, Update
389//////////////////////////////////////////////////////////////////////////////////
55a288e5 390//____________Functions for initialising the AliTRDCalibraFillHisto in the code_________
9ff7be6d 391Bool_t AliTRDCalibraFillHisto::Init2Dhistos(Int_t nboftimebin)
55a288e5 392{
393 //
bcb6fb78 394 // Init the histograms and stuff to be filled
d0569428 395 //
396
55a288e5 397 // DB Setting
398 // Get cal
399 AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
400 if (!cal) {
401 AliInfo("Could not get calibDB");
402 return kFALSE;
403 }
404 AliTRDCommonParam *parCom = AliTRDCommonParam::Instance();
405 if (!parCom) {
406 AliInfo("Could not get CommonParam");
407 return kFALSE;
408 }
409
410 // Some parameters
9ff7be6d 411 if(nboftimebin > 0) fTimeMax = nboftimebin;
c698a3d9 412 else fTimeMax = cal->GetNumberOfTimeBinsDCS();
5496295d 413 if(fTimeMax <= 0) fTimeMax = 30;
09ea3770 414 printf("////////////////////////////////////////////\n");
415 printf("Number of time bins in calibration component %d\n",fTimeMax);
416 printf("////////////////////////////////////////////\n");
d95484e4 417 fSf = parCom->GetSamplingFrequency();
64942b85 418 if(!fNormalizeNbOfCluster) fRelativeScale = 20.0;
419 else fRelativeScale = 1.18;
d95484e4 420 fNumberClustersf = fTimeMax;
6aafa7ea 421 fNumberClusters = (Int_t)(fNumberClustersProcent*fTimeMax);
d0569428 422
1ca79a00 423 // Init linear fitter
424 if(!fLinearFitterTracklet) {
425 fLinearFitterTracklet = new TLinearFitter(2,"pol1");
64942b85 426 fLinearFitterTracklet->StoreData(kTRUE);
1ca79a00 427 }
170c35f1 428
3a0f6479 429 // Calcul Xbins Chambd0, Chamb2
0c349049 430 Int_t ntotal0 = CalculateTotalNumberOfBins(0);
431 Int_t ntotal1 = CalculateTotalNumberOfBins(1);
432 Int_t ntotal2 = CalculateTotalNumberOfBins(2);
3a0f6479 433
434 // If vector method On initialised all the stuff
435 if(fVector2d){
55a288e5 436 fCalibraVector = new AliTRDCalibraVector();
170c35f1 437 fCalibraVector->SetNumberBinCharge(fNumberBinCharge);
438 fCalibraVector->SetTimeMax(fTimeMax);
439 if(fNgroupprf != 0) {
440 fCalibraVector->SetNumberBinPRF(2*fNgroupprf*fNumberBinPRF);
441 fCalibraVector->SetPRFRange((Float_t)(3.0*fNgroupprf));
442 }
443 else {
444 fCalibraVector->SetNumberBinPRF(fNumberBinPRF);
445 fCalibraVector->SetPRFRange(1.5);
446 }
3a0f6479 447 for(Int_t k = 0; k < 3; k++){
448 fCalibraVector->SetDetCha0(k,fCalibraMode->GetDetChamb0(k));
449 fCalibraVector->SetDetCha2(k,fCalibraMode->GetDetChamb2(k));
450 }
e526983e 451 fCalibraVector->SetNzNrphi(0,fCalibraMode->GetNz(0),fCalibraMode->GetNrphi(0));
452 fCalibraVector->SetNzNrphi(1,fCalibraMode->GetNz(1),fCalibraMode->GetNrphi(1));
453 fCalibraVector->SetNzNrphi(2,fCalibraMode->GetNz(2),fCalibraMode->GetNrphi(2));
454 fCalibraVector->SetNbGroupPRF(fNgroupprf);
55a288e5 455 }
170c35f1 456
55a288e5 457 // Create the 2D histos corresponding to the pad groupCalibration mode
458 if (fCH2dOn) {
459
460 AliInfo(Form("The pad calibration mode for the relative gain calibration: Nz %d, and Nrphi %d"
461 ,fCalibraMode->GetNz(0)
462 ,fCalibraMode->GetNrphi(0)));
463
55a288e5 464 // Create the 2D histo
465 if (fHisto2d) {
0c349049 466 CreateCH2d(ntotal0);
55a288e5 467 }
55a288e5 468 // Variable
469 fAmpTotal = new Float_t[TMath::Max(fCalibraMode->GetDetChamb2(0),fCalibraMode->GetDetChamb0(0))];
470 for (Int_t k = 0; k < TMath::Max(fCalibraMode->GetDetChamb2(0),fCalibraMode->GetDetChamb0(0)); k++) {
471 fAmpTotal[k] = 0.0;
472 }
170c35f1 473 //Statistics
0c349049 474 fEntriesCH = new Int_t[ntotal0];
475 for(Int_t k = 0; k < ntotal0; k++){
170c35f1 476 fEntriesCH[k] = 0;
477 }
3a0f6479 478
55a288e5 479 }
55a288e5 480 if (fPH2dOn) {
481
482 AliInfo(Form("The pad calibration mode for the drift velocity calibration: Nz %d, and Nrphi %d"
483 ,fCalibraMode->GetNz(1)
484 ,fCalibraMode->GetNrphi(1)));
485
55a288e5 486 // Create the 2D histo
487 if (fHisto2d) {
0c349049 488 CreatePH2d(ntotal1);
55a288e5 489 }
55a288e5 490 // Variable
491 fPHPlace = new Short_t[fTimeMax];
492 for (Int_t k = 0; k < fTimeMax; k++) {
493 fPHPlace[k] = -1;
494 }
495 fPHValue = new Float_t[fTimeMax];
496 for (Int_t k = 0; k < fTimeMax; k++) {
497 fPHValue[k] = 0.0;
498 }
170c35f1 499 }
500 if (fLinearFitterOn) {
46c4871e 501 if(fLinearFitterDebugOn) {
502 fLinearFitterArray.SetName("ArrayLinearFitters");
503 fEntriesLinearFitter = new Int_t[540];
504 for(Int_t k = 0; k < 540; k++){
505 fEntriesLinearFitter[k] = 0;
506 }
170c35f1 507 }
3a0f6479 508 fLinearVdriftFit = new AliTRDCalibraVdriftLinearFit();
55a288e5 509 }
510
511 if (fPRF2dOn) {
512
513 AliInfo(Form("The pad calibration mode for the PRF calibration: Nz %d, and Nrphi %d"
514 ,fCalibraMode->GetNz(2)
515 ,fCalibraMode->GetNrphi(2)));
55a288e5 516 // Create the 2D histo
517 if (fHisto2d) {
0c349049 518 CreatePRF2d(ntotal2);
55a288e5 519 }
55a288e5 520 }
521
522 return kTRUE;
523
a2a4ec8e 524}
525///////////////////////////////////////////////////////////////////////////////////////////////////////////////
526Bool_t AliTRDCalibraFillHisto::InitCalDet()
527{
528 //
529 // Init the Gain Cal Det
530 //
531
532 // DB Setting
533 // Get cal
d085ba91 534 AliCDBEntry *entry = AliCDBManager::Instance()->Get("TRD/Calib/ChamberGainFactor",fFirstRunGain,fVersionGainUsed,fSubVersionGainUsed);
3b0c1edc 535 if(!entry) {
536 AliError("No gain det calibration entry found");
537 return kFALSE;
538 }
539 AliTRDCalDet *calDet = (AliTRDCalDet *)entry->GetObject();
540 if(!calDet) {
541 AliError("No calDet gain found");
a2a4ec8e 542 return kFALSE;
a2a4ec8e 543 }
3b0c1edc 544
545
546 if( fCalDetGain ){
547 fCalDetGain->~AliTRDCalDet();
548 new(fCalDetGain) AliTRDCalDet(*(calDet));
549 }else fCalDetGain = new AliTRDCalDet(*(calDet));
550
a2a4ec8e 551
552 // title CH2d
553 TString name("Ver");
554 name += fVersionGainUsed;
555 name += "Subver";
556 name += fSubVersionGainUsed;
ca7e6e64 557 name += "FirstRun";
558 name += fFirstRunGain;
a2a4ec8e 559 name += "Nz";
560 name += fCalibraMode->GetNz(0);
561 name += "Nrphi";
562 name += fCalibraMode->GetNrphi(0);
563
564 fCH2d->SetTitle(name);
565
566 // title PH2d
567 TString namee("Ver");
568 namee += fVersionVdriftUsed;
569 namee += "Subver";
570 namee += fSubVersionVdriftUsed;
ca7e6e64 571 namee += "FirstRun";
572 namee += fFirstRunVdrift;
a2a4ec8e 573 namee += "Nz";
574 namee += fCalibraMode->GetNz(1);
575 namee += "Nrphi";
576 namee += fCalibraMode->GetNrphi(1);
577
578 fPH2d->SetTitle(namee);
579
580
581 return kTRUE;
582
583}
584///////////////////////////////////////////////////////////////////////////////////////////////////////////////
585Bool_t AliTRDCalibraFillHisto::InitCalPad(Int_t detector)
586{
587 //
588 // Init the Gain Cal Pad
589 //
590
591 // DB Setting
592 // Get cal
593 AliCDBEntry *entry = AliCDBManager::Instance()->Get("TRD/Calib/LocalGainFactor",AliCDBManager::Instance()->GetRun(),fVersionGainLocalUsed,fSubVersionGainLocalUsed);
3b0c1edc 594 if(!entry) {
595 AliError("No gain pad calibration entry found");
596 return kFALSE;
597 }
598 AliTRDCalPad *calPad = (AliTRDCalPad *)entry->GetObject();
599 if(!calPad) {
600 AliError("No calPad gain found");
601 return kFALSE;
602 }
603 AliTRDCalROC *calRoc = (AliTRDCalROC *)calPad->GetCalROC(detector);
604 if(!calRoc) {
605 AliError("No calRoc gain found");
606 return kFALSE;
607 }
a2a4ec8e 608
3b0c1edc 609 if( fCalROCGain ){
610 fCalROCGain->~AliTRDCalROC();
611 new(fCalROCGain) AliTRDCalROC(*(calRoc));
612 }else fCalROCGain = new AliTRDCalROC(*(calRoc));
a2a4ec8e 613
614
a2a4ec8e 615
3b0c1edc 616
a2a4ec8e 617
618 return kTRUE;
619
170c35f1 620}
55a288e5 621//____________Offline tracking in the AliTRDtracker____________________________
6bbdc11a 622Bool_t AliTRDCalibraFillHisto::UpdateHistogramsV1(const AliTRDtrackV1 *t)
55a288e5 623{
624 //
bcb6fb78 625 // Use AliTRDtrackV1 for the calibration
55a288e5 626 //
627
bcb6fb78 628
629 const AliTRDseedV1 *tracklet = 0x0; // tracklet per plane
4aad967c 630 AliTRDcluster *cl = 0x0; // cluster attached now to the tracklet
1785640c 631 AliTRDcluster *cls = 0x0; // shared cluster attached now to the tracklet
4aad967c 632 Bool_t newtr = kTRUE; // new track
bcb6fb78 633
1ca79a00 634 // Get cal
01239968 635 // AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
636 /*
1ca79a00 637 if (!cal) {
638 AliInfo("Could not get calibDB");
639 return kFALSE;
640 }
01239968 641*/
642 if (!fCalibDB) {
643 AliInfo("Could not get calibDB");
644 return kFALSE;
645 }
646
bcb6fb78 647
648 ///////////////////////////
649 // loop over the tracklet
650 ///////////////////////////
651 for(Int_t itr = 0; itr < 6; itr++){
55a288e5 652
bcb6fb78 653 if(!(tracklet = t->GetTracklet(itr))) continue;
654 if(!tracklet->IsOK()) continue;
655 fNumberTrack++;
656 ResetfVariablestracklet();
657
658 //////////////////////////////////////////
659 // localisation of the tracklet and dqdl
660 //////////////////////////////////////////
053767a4 661 Int_t layer = tracklet->GetPlane();
bcb6fb78 662 Int_t ic = 0;
663 while(!(cl = tracklet->GetClusters(ic++))) continue;
664 Int_t detector = cl->GetDetector();
665 if (detector != fDetectorPreviousTrack) {
4aad967c 666 // if not a new track
667 if(!newtr){
668 // don't use the rest of this track if in the same plane
669 if (layer == GetLayer(fDetectorPreviousTrack)) {
670 //printf("bad tracklet, same layer for detector %d\n",detector);
671 break;
672 }
bcb6fb78 673 }
674 //Localise the detector bin
675 LocalisationDetectorXbins(detector);
bcb6fb78 676 // Get calib objects
a2a4ec8e 677 if(!fIsHLT) InitCalPad(detector);
678
bcb6fb78 679 // reset
680 fDetectorPreviousTrack = detector;
55a288e5 681 }
4aad967c 682 newtr = kFALSE;
55a288e5 683
bcb6fb78 684 ////////////////////////////
685 // loop over the clusters
686 ////////////////////////////
687 Int_t nbclusters = 0;
e3cf3d02 688 for(int jc=0; jc<AliTRDseedV1::kNtb; jc++){
7bce990c 689 if(!(cl = tracklet->GetClusters(jc))) continue;
bcb6fb78 690 nbclusters++;
691
692 // Store the info bis of the tracklet
693 Int_t row = cl->GetPadRow();
694 Int_t col = cl->GetPadCol();
d95484e4 695 CheckGoodTrackletV1(cl);
bcb6fb78 696 Int_t group[2] = {0,0};
697 if(fCH2dOn) group[0] = CalculateCalibrationGroup(0,row,col);
698 if(fPH2dOn) group[1] = CalculateCalibrationGroup(1,row,col);
1785640c 699 // Add the charge if shared cluster
700 cls = tracklet->GetClusters(jc+AliTRDseedV1::kNtb);
701 //
702 StoreInfoCHPHtrack(cl, tracklet->GetdQdl(jc),group,row,col,cls);
bcb6fb78 703 }
704
705 ////////////////////////////////////////
706 // Fill the stuffs if a good tracklet
707 ////////////////////////////////////////
708 if (fGoodTracklet) {
e526983e 709
bcb6fb78 710 // drift velocity unables to cut bad tracklets
711 Bool_t pass = FindP1TrackPHtrackletV1(tracklet, nbclusters);
712
e526983e 713 //printf("pass %d and nbclusters %d\n",pass,nbclusters);
714
55a288e5 715 // Gain calibration
716 if (fCH2dOn) {
bcb6fb78 717 FillTheInfoOfTheTrackCH(nbclusters);
55a288e5 718 }
bcb6fb78 719
55a288e5 720 // PH calibration
721 if (fPH2dOn) {
722 FillTheInfoOfTheTrackPH();
723 }
bcb6fb78 724
725 if(pass && fPRF2dOn) HandlePRFtrackletV1(tracklet,nbclusters);
726
727 } // if a good tracklet
bcb6fb78 728 }
4aad967c 729
55a288e5 730 return kTRUE;
731
732}
bcb6fb78 733///////////////////////////////////////////////////////////////////////////////////
734// Routine inside the update with AliTRDtrack
735///////////////////////////////////////////////////////////////////////////////////
736//____________Offine tracking in the AliTRDtracker_____________________________
bcb6fb78 737Bool_t AliTRDCalibraFillHisto::FindP1TrackPHtrackletV1(const AliTRDseedV1 *tracklet, Int_t nbclusters)
170c35f1 738{
739 //
bcb6fb78 740 // Drift velocity calibration:
741 // Fit the clusters with a straight line
742 // From the slope find the drift velocity
170c35f1 743 //
744
bcb6fb78 745 ////////////////////////////////////////////////
746 //Number of points: if less than 3 return kFALSE
747 /////////////////////////////////////////////////
748 if(nbclusters <= 2) return kFALSE;
170c35f1 749
bcb6fb78 750 ////////////
751 //Variables
752 ////////////
bcb6fb78 753 // results of the linear fit
754 Double_t dydt = 0.0; // dydt tracklet after straight line fit
755 Double_t errorpar = 0.0; // error after straight line fit on dy/dt
756 Double_t pointError = 0.0; // error after straight line fit
757 // pad row problemes: avoid tracklet that cross pad rows, tilting angle in the constant
758 Int_t crossrow = 0; // if it crosses a pad row
759 Int_t rowp = -1; // if it crosses a pad row
760 Float_t tnt = tracklet->GetTilt(); // tan tiltingangle
1ca79a00 761 fLinearFitterTracklet->ClearPoints();
762
170c35f1 763
bcb6fb78 764 ///////////////////////////////////////////
765 // Take the parameters of the track
766 //////////////////////////////////////////
767 // take now the snp, tnp and tgl from the track
768 Double_t snp = tracklet->GetSnp(); // sin dy/dx at the end of the chamber
769 Double_t tnp = 0.0; // dy/dx at the end of the chamber
770 if( TMath::Abs(snp) < 1.){
60e55aee 771 tnp = snp / TMath::Sqrt((1.-snp)*(1.+snp));
bcb6fb78 772 }
773 Double_t tgl = tracklet->GetTgl(); // dz/dl
774 Double_t dzdx = tgl*TMath::Sqrt(1+tnp*tnp); // dz/dx calculated from dz/dl
775 // at the entrance
776 //Double_t tnp = tracklet->GetYref(1); // dy/dx at the entrance of the chamber
777 //Double_t tgl = tracklet->GetZref(1); // dz/dl at the entrance of the chamber
778 //Double_t dzdx = tgl; //*TMath::Sqrt(1+tnp*tnp); // dz/dx from dz/dl
779 // at the end with correction due to linear fit
780 //Double_t tnp = tracklet->GetYfit(1); // dy/dx at the end of the chamber after fit correction
781 //Double_t tgl = tracklet->GetZfit(1); // dz/dl at the end of the chamber after fit correction
782
783
784 ////////////////////////////
785 // loop over the clusters
786 ////////////////////////////
787 Int_t nbli = 0;
788 AliTRDcluster *cl = 0x0;
6aafa7ea 789 //////////////////////////////
790 // Check no shared clusters
791 //////////////////////////////
792 for(int icc=AliTRDseedV1::kNtb; icc<AliTRDseedV1::kNclusters; icc++){
3b0c1edc 793 cl = tracklet->GetClusters(icc);
794 if(cl) crossrow = 1;
6aafa7ea 795 }
796 //////////////////////////////////
797 // Loop clusters
798 //////////////////////////////////
e3cf3d02 799 for(int ic=0; ic<AliTRDseedV1::kNtb; ic++){
bcb6fb78 800 if(!(cl = tracklet->GetClusters(ic))) continue;
b70c68da 801 if((fLimitChargeIntegration) && (!cl->IsInChamber())) continue;
bcb6fb78 802
803 Double_t ycluster = cl->GetY();
804 Int_t time = cl->GetPadTime();
805 Double_t timeis = time/fSf;
806 //See if cross two pad rows
807 Int_t row = cl->GetPadRow();
808 if(rowp==-1) rowp = row;
809 if(row != rowp) crossrow = 1;
810
1ca79a00 811 fLinearFitterTracklet->AddPoint(&timeis,ycluster,1);
bcb6fb78 812 nbli++;
170c35f1 813
1785640c 814
55a288e5 815 }
816
bcb6fb78 817 ////////////////////////////////////
818 // Do the straight line fit now
819 ///////////////////////////////////
1ca79a00 820 if(nbli <= 2){
821 fLinearFitterTracklet->ClearPoints();
822 return kFALSE;
823 }
bcb6fb78 824 TVectorD pars;
1ca79a00 825 fLinearFitterTracklet->Eval();
826 fLinearFitterTracklet->GetParameters(pars);
827 pointError = TMath::Sqrt(fLinearFitterTracklet->GetChisquare()/(nbli-2));
828 errorpar = fLinearFitterTracklet->GetParError(1)*pointError;
bcb6fb78 829 dydt = pars[1];
64942b85 830 //printf("chis %f, nbli %d, pointError %f, parError %f, errorpar %f\n",fLinearFitterTracklet->GetChisquare(),nbli,pointError,fLinearFitterTracklet->GetParError(1),errorpar);
1ca79a00 831 fLinearFitterTracklet->ClearPoints();
170c35f1 832
bcb6fb78 833 ////////////////////////////////
834 // Debug stuff
835 ///////////////////////////////
836
837
838 if(fDebugLevel > 0){
839 if ( !fDebugStreamer ) {
840 //debug stream
841 TDirectory *backup = gDirectory;
842 fDebugStreamer = new TTreeSRedirector("TRDdebugCalibraFill.root");
843 if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
844 }
845
846
053767a4 847 Int_t layer = GetLayer(fDetectorPreviousTrack);
64942b85 848
bcb6fb78 849 (* fDebugStreamer) << "FindP1TrackPHtrackletV1"<<
850 //"snpright="<<snpright<<
64942b85 851 "nbli="<<nbli<<
bcb6fb78 852 "nbclusters="<<nbclusters<<
853 "detector="<<fDetectorPreviousTrack<<
053767a4 854 "layer="<<layer<<
bcb6fb78 855 "snp="<<snp<<
856 "tnp="<<tnp<<
857 "tgl="<<tgl<<
858 "tnt="<<tnt<<
859 "dydt="<<dydt<<
860 "dzdx="<<dzdx<<
861 "crossrow="<<crossrow<<
862 "errorpar="<<errorpar<<
863 "pointError="<<pointError<<
864 "\n";
865
170c35f1 866 }
867
bcb6fb78 868 /////////////////////////
869 // Cuts quality
870 ////////////////////////
c1105918 871
bcb6fb78 872 if(nbclusters < fNumberClusters) return kFALSE;
873 if(nbclusters > fNumberClustersf) return kFALSE;
64942b85 874 if(pointError >= 0.3) return kFALSE;
c1105918 875 if(crossrow == 1) return kTRUE;
170c35f1 876
bcb6fb78 877 ///////////////////////
878 // Fill
879 //////////////////////
170c35f1 880
bcb6fb78 881 if(fLinearFitterOn){
882 //Add to the linear fitter of the detector
883 if( TMath::Abs(snp) < 1.){
884 Double_t x = tnp-dzdx*tnt;
bcb6fb78 885 if(fLinearFitterDebugOn) {
46c4871e 886 (GetLinearFitter(fDetectorPreviousTrack,kTRUE))->AddPoint(&x,dydt);
887 fEntriesLinearFitter[fDetectorPreviousTrack]++;
bcb6fb78 888 }
46c4871e 889 fLinearVdriftFit->Update(fDetectorPreviousTrack,x,pars[1]);
bcb6fb78 890 }
170c35f1 891 }
892
893 return kTRUE;
170c35f1 894}
bcb6fb78 895//____________Offine tracking in the AliTRDtracker_____________________________
bcb6fb78 896Bool_t AliTRDCalibraFillHisto::HandlePRFtrackletV1(const AliTRDseedV1 *tracklet, Int_t nbclusters)
897{
898 //
899 // PRF width calibration
900 // Assume a Gaussian shape: determinate the position of the three pad clusters
901 // Fit with a straight line
902 // Take the fitted values for all the clusters (3 or 2 pad clusters)
903 // Fill the PRF as function of angle of the track
904 //
905 //
906
4aad967c 907 //printf("begin\n");
bcb6fb78 908 ///////////////////////////////////////////
909 // Take the parameters of the track
910 //////////////////////////////////////////
911 // take now the snp, tnp and tgl from the track
912 Double_t snp = tracklet->GetSnp(); // sin dy/dx at the end of the chamber
913 Double_t tnp = 0.0; // dy/dx at the end of the chamber
914 if( TMath::Abs(snp) < 1.){
60e55aee 915 tnp = snp / TMath::Sqrt((1.-snp)*(1.+snp));
bcb6fb78 916 }
917 Double_t tgl = tracklet->GetTgl(); // dz/dl
918 Double_t dzdx = tgl*TMath::Sqrt(1+tnp*tnp); // dz/dx calculated from dz/dl
919 // at the entrance
920 //Double_t tnp = tracklet->GetYref(1); // dy/dx at the entrance of the chamber
921 //Double_t tgl = tracklet->GetZref(1); // dz/dl at the entrance of the chamber
922 //Double_t dzdx = tgl; //*TMath::Sqrt(1+tnp*tnp); // dz/dx from dz/dl
923 // at the end with correction due to linear fit
924 //Double_t tnp = tracklet->GetYfit(1); // dy/dx at the end of the chamber after fit correction
925 //Double_t tgl = tracklet->GetZfit(1); // dz/dl at the end of the chamber after fit correction
926
927 ///////////////////////////////
928 // Calculate tnp group shift
929 ///////////////////////////////
930 Bool_t echec = kFALSE;
931 Double_t shift = 0.0;
932 //Calculate the shift in x coresponding to this tnp
933 if(fNgroupprf != 0.0){
934 shift = -3.0*(fNgroupprf-1)-1.5;
935 Double_t limithigh = -0.2*(fNgroupprf-1);
936 if((tnp < (-0.2*fNgroupprf)) || (tnp > (0.2*fNgroupprf))) echec = kTRUE;
937 else{
938 while(tnp > limithigh){
939 limithigh += 0.2;
940 shift += 3.0;
170c35f1 941 }
942 }
170c35f1 943 }
bcb6fb78 944 // do nothing if out of tnp range
4aad967c 945 //printf("echec %d\n",(Int_t)echec);
bcb6fb78 946 if(echec) return kFALSE;
3a0f6479 947
bcb6fb78 948 ///////////////////////
949 // Variables
950 //////////////////////
3a0f6479 951
bcb6fb78 952 Int_t nb3pc = 0; // number of three pads clusters used for fit
e3cf3d02 953 // to see the difference between the fit and the 3 pad clusters position
954 Double_t padPositions[AliTRDseedV1::kNtb];
955 memset(padPositions, 0, AliTRDseedV1::kNtb*sizeof(Double_t));
1ca79a00 956 fLinearFitterTracklet->ClearPoints();
957
4aad967c 958 //printf("loop clusters \n");
bcb6fb78 959 ////////////////////////////
960 // loop over the clusters
961 ////////////////////////////
962 AliTRDcluster *cl = 0x0;
e3cf3d02 963 for(int ic=0; ic<AliTRDseedV1::kNtb; ic++){
6cb3ebda 964 // reject shared clusters on pad row
e526983e 965 if((ic+AliTRDseedV1::kNtb) < AliTRDseedV1::kNclusters) {
35a82746 966 cl = tracklet->GetClusters(ic+AliTRDseedV1::kNtb);
967 if(cl) continue;
e526983e 968 }
35a82746 969 cl = tracklet->GetClusters(ic);
970 if(!cl) continue;
e526983e 971 Double_t time = cl->GetPadTime();
bcb6fb78 972 if((time<=7) || (time>=21)) continue;
973 Short_t *signals = cl->GetSignals();
974 Float_t xcenter = 0.0;
7bce990c 975 Bool_t echec1 = kTRUE;
e4db522f 976
bcb6fb78 977 /////////////////////////////////////////////////////////////
978 // Center 3 balanced: position with the center of the pad
979 /////////////////////////////////////////////////////////////
980 if ((((Float_t) signals[3]) > 0.0) &&
981 (((Float_t) signals[2]) > 0.0) &&
982 (((Float_t) signals[4]) > 0.0)) {
7bce990c 983 echec1 = kFALSE;
bcb6fb78 984 // Security if the denomiateur is 0
985 if ((((Float_t) (((Float_t) signals[3]) * ((Float_t) signals[3]))) /
986 ((Float_t) (((Float_t) signals[2]) * ((Float_t) signals[4])))) != 1.0) {
987 xcenter = 0.5 * (TMath::Log((Float_t) (((Float_t) signals[4]) / ((Float_t) signals[2]))))
988 / (TMath::Log(((Float_t) (((Float_t) signals[3]) * ((Float_t) signals[3])))
989 / ((Float_t) (((Float_t) signals[2]) * ((Float_t) signals[4])))));
3a0f6479 990 }
bcb6fb78 991 else {
7bce990c 992 echec1 = kTRUE;
bcb6fb78 993 }
994 }
7bce990c 995 if(TMath::Abs(xcenter) > 0.5) echec1 = kTRUE;
996 if(echec1) continue;
e4db522f 997
bcb6fb78 998 ////////////////////////////////////////////////////////
7bce990c 999 //if no echec1: calculate with the position of the pad
bcb6fb78 1000 // Position of the cluster
1001 // fill the linear fitter
1002 ///////////////////////////////////////////////////////
1003 Double_t padPosition = xcenter + cl->GetPadCol();
1004 padPositions[ic] = padPosition;
1005 nb3pc++;
1ca79a00 1006 fLinearFitterTracklet->AddPoint(&time, padPosition,1);
e4db522f 1007
e4db522f 1008
bcb6fb78 1009 }//clusters loop
1010
4aad967c 1011 //printf("Fin loop clusters \n");
bcb6fb78 1012 //////////////////////////////
1013 // fit with a straight line
1014 /////////////////////////////
1ca79a00 1015 if(nb3pc < 3){
1ca79a00 1016 fLinearFitterTracklet->ClearPoints();
1ca79a00 1017 return kFALSE;
1018 }
1019 fLinearFitterTracklet->Eval();
bcb6fb78 1020 TVectorD line(2);
1ca79a00 1021 fLinearFitterTracklet->GetParameters(line);
bcb6fb78 1022 Float_t pointError = -1.0;
1ca79a00 1023 if( fLinearFitterTracklet->GetChisquare()>=0.0) {
1024 pointError = TMath::Sqrt( fLinearFitterTracklet->GetChisquare()/(nb3pc-2));
4aad967c 1025 }
1ca79a00 1026 fLinearFitterTracklet->ClearPoints();
1027
4aad967c 1028 //printf("PRF second loop \n");
bcb6fb78 1029 ////////////////////////////////////////////////
1030 // Fill the PRF: Second loop over clusters
1031 //////////////////////////////////////////////
e3cf3d02 1032 for(int ic=0; ic<AliTRDseedV1::kNtb; ic++){
6cb3ebda 1033 // reject shared clusters on pad row
3b0c1edc 1034 cl = tracklet->GetClusters(ic+AliTRDseedV1::kNtb);
1035 if(((ic+AliTRDseedV1::kNtb) < AliTRDseedV1::kNclusters) && (cl)) continue;
6cb3ebda 1036 //
3b0c1edc 1037 cl = tracklet->GetClusters(ic);
1038 if(!cl) continue;
162a3e73 1039
bcb6fb78 1040 Short_t *signals = cl->GetSignals(); // signal
e526983e 1041 Double_t time = cl->GetPadTime(); // time bin
bcb6fb78 1042 Float_t padPosTracklet = line[0]+line[1]*time; // reconstruct position from fit
1043 Float_t padPos = cl->GetPadCol(); // middle pad
1044 Double_t dpad = padPosTracklet - padPos; // reconstruct position relative to middle pad from fit
1045 Float_t ycenter = 0.0; // relative center charge
1046 Float_t ymin = 0.0; // relative left charge
1047 Float_t ymax = 0.0; // relative right charge
162a3e73 1048
bcb6fb78 1049 ////////////////////////////////////////////////////////////////
1050 // Calculate ycenter, ymin and ymax even for two pad clusters
1051 ////////////////////////////////////////////////////////////////
1052 if(((((Float_t) signals[3]) > 0.0) && (((Float_t) signals[2]) > 0.0)) ||
1053 ((((Float_t) signals[3]) > 0.0) && (((Float_t) signals[4]) > 0.0))){
1054 Float_t sum = ((Float_t) signals[2]) + ((Float_t) signals[3]) + ((Float_t) signals[4]);
1055 if(sum > 0.0) ycenter = ((Float_t) signals[3])/ sum;
1056 if(sum > 0.0) ymin = ((Float_t) signals[2])/ sum;
1057 if(sum > 0.0) ymax = ((Float_t) signals[4])/ sum;
3a0f6479 1058 }
1059
bcb6fb78 1060 /////////////////////////
1061 // Calibration group
1062 ////////////////////////
1063 Int_t rowcl = cl->GetPadRow(); // row of cluster
1064 Int_t colcl = cl->GetPadCol(); // col of cluster
1065 Int_t grouplocal = CalculateCalibrationGroup(2,rowcl,colcl); // calcul the corresponding group
1066 Int_t caligroup = fCalibraMode->GetXbins(2)+ grouplocal; // calcul the corresponding group
1067 Float_t xcl = cl->GetY(); // y cluster
1068 Float_t qcl = cl->GetQ(); // charge cluster
053767a4 1069 Int_t layer = GetLayer(fDetectorPreviousTrack); // layer
1070 Int_t stack = GetStack(fDetectorPreviousTrack); // stack
bcb6fb78 1071 Double_t xdiff = dpad; // reconstructed position constant
1072 Double_t x = dpad; // reconstructed position moved
1073 Float_t ep = pointError; // error of fit
1074 Float_t signal1 = (Float_t)signals[1]; // signal at the border
1075 Float_t signal3 = (Float_t)signals[3]; // signal
1076 Float_t signal2 = (Float_t)signals[2]; // signal
1077 Float_t signal4 = (Float_t)signals[4]; // signal
1078 Float_t signal5 = (Float_t)signals[5]; // signal at the border
1079
1ca79a00 1080
1081
bcb6fb78 1082 /////////////////////
1083 // Debug stuff
1084 ////////////////////
1085
1086 if(fDebugLevel > 0){
1087 if ( !fDebugStreamer ) {
1088 //debug stream
1089 TDirectory *backup = gDirectory;
1090 fDebugStreamer = new TTreeSRedirector("TRDdebugCalibraFill.root");
1091 if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
1092 }
1093
1094 x = xdiff;
1095 Int_t type=0;
1096 Float_t y = ycenter;
1097 (* fDebugStreamer) << "HandlePRFtrackletV1"<<
1098 "caligroup="<<caligroup<<
1099 "detector="<<fDetectorPreviousTrack<<
053767a4 1100 "layer="<<layer<<
1101 "stack="<<stack<<
bcb6fb78 1102 "npoints="<<nbclusters<<
1103 "Np="<<nb3pc<<
1104 "ep="<<ep<<
1105 "type="<<type<<
1106 "snp="<<snp<<
1107 "tnp="<<tnp<<
1108 "tgl="<<tgl<<
1109 "dzdx="<<dzdx<<
1110 "padPos="<<padPos<<
1111 "padPosition="<<padPositions[ic]<<
1112 "padPosTracklet="<<padPosTracklet<<
1113 "x="<<x<<
1114 "y="<<y<<
1115 "xcl="<<xcl<<
1116 "qcl="<<qcl<<
1117 "signal1="<<signal1<<
1118 "signal2="<<signal2<<
1119 "signal3="<<signal3<<
1120 "signal4="<<signal4<<
1121 "signal5="<<signal5<<
1122 "time="<<time<<
1123 "\n";
1124 x=-(xdiff+1);
1125 y = ymin;
1126 type=-1;
1127 (* fDebugStreamer) << "HandlePRFtrackletV1"<<
1128 "caligroup="<<caligroup<<
1129 "detector="<<fDetectorPreviousTrack<<
053767a4 1130 "layer="<<layer<<
1131 "stack="<<stack<<
bcb6fb78 1132 "npoints="<<nbclusters<<
1133 "Np="<<nb3pc<<
1134 "ep="<<ep<<
1135 "type="<<type<<
1136 "snp="<<snp<<
1137 "tnp="<<tnp<<
1138 "tgl="<<tgl<<
1139 "dzdx="<<dzdx<<
1140 "padPos="<<padPos<<
1141 "padPosition="<<padPositions[ic]<<
1142 "padPosTracklet="<<padPosTracklet<<
1143 "x="<<x<<
1144 "y="<<y<<
1145 "xcl="<<xcl<<
1146 "qcl="<<qcl<<
1147 "signal1="<<signal1<<
1148 "signal2="<<signal2<<
1149 "signal3="<<signal3<<
1150 "signal4="<<signal4<<
1151 "signal5="<<signal5<<
1152 "time="<<time<<
1153 "\n";
1154 x=1-xdiff;
1155 y = ymax;
1156 type=1;
1157 (* fDebugStreamer) << "HandlePRFtrackletV1"<<
1158 "caligroup="<<caligroup<<
1159 "detector="<<fDetectorPreviousTrack<<
053767a4 1160 "layer="<<layer<<
1161 "stack="<<stack<<
bcb6fb78 1162 "npoints="<<nbclusters<<
1163 "Np="<<nb3pc<<
1164 "ep="<<ep<<
1165 "type="<<type<<
1166 "snp="<<snp<<
1167 "tnp="<<tnp<<
1168 "tgl="<<tgl<<
1169 "dzdx="<<dzdx<<
1170 "padPos="<<padPos<<
1171 "padPosition="<<padPositions[ic]<<
1172 "padPosTracklet="<<padPosTracklet<<
1173 "x="<<x<<
1174 "y="<<y<<
1175 "xcl="<<xcl<<
1176 "qcl="<<qcl<<
1177 "signal1="<<signal1<<
1178 "signal2="<<signal2<<
1179 "signal3="<<signal3<<
1180 "signal4="<<signal4<<
1181 "signal5="<<signal5<<
1182 "time="<<time<<
1183 "\n";
e4db522f 1184
bcb6fb78 1185 }
1186
1187 /////////////////////
1188 // Cuts quality
1189 /////////////////////
1190 if(nbclusters < fNumberClusters) continue;
1191 if(nbclusters > fNumberClustersf) continue;
1192 if(nb3pc <= 5) continue;
1193 if((time >= 21) || (time < 7)) continue;
1194 if(TMath::Abs(qcl) < 80) continue;
1195 if( TMath::Abs(snp) > 1.) continue;
1196
1197
1198 ////////////////////////
1199 // Fill the histos
1200 ///////////////////////
1201 if (fHisto2d) {
1202 if(TMath::Abs(dpad) < 1.5) {
1203 fPRF2d->Fill(shift+dpad,(caligroup+0.5),ycenter);
1204 fPRF2d->Fill(shift-dpad,(caligroup+0.5),ycenter);
1205 //printf("place %f, ycenter %f\n",(shift+dpad),ycenter);
e4db522f 1206 }
bcb6fb78 1207 if((ymin > 0.0) && (TMath::Abs(dpad+1.0) < 1.5)) {
1208 fPRF2d->Fill(shift-(dpad+1.0),(caligroup+0.5),ymin);
1209 fPRF2d->Fill(shift+(dpad+1.0),(caligroup+0.5),ymin);
e4db522f 1210 }
bcb6fb78 1211 if((ymax > 0.0) && (TMath::Abs(dpad-1.0) < 1.5)) {
1212 fPRF2d->Fill(shift+1.0-dpad,(caligroup+0.5),ymax);
1213 fPRF2d->Fill(shift-1.0+dpad,(caligroup+0.5),ymax);
e4db522f 1214 }
bcb6fb78 1215 }
1216 // vector method
1217 if (fVector2d) {
1218 if(TMath::Abs(dpad) < 1.5) {
1219 fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift+dpad,ycenter);
1220 fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift-dpad,ycenter);
1221 }
1222 if((ymin > 0.0) && (TMath::Abs(dpad+1.0) < 1.5)) {
1223 fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift-(dpad+1.0),ymin);
1224 fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift+(dpad+1.0),ymin);
1225 }
1226 if((ymax > 0.0) && (TMath::Abs(dpad-1.0) < 1.5)) {
1227 fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift+1.0-dpad,ymax);
1228 fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift-1.0+dpad,ymax);
170c35f1 1229 }
3a0f6479 1230 }
bcb6fb78 1231 } // second loop over clusters
1232
1233
1234 return kTRUE;
170c35f1 1235}
bcb6fb78 1236///////////////////////////////////////////////////////////////////////////////////////
1237// Pad row col stuff: see if masked or not
1238///////////////////////////////////////////////////////////////////////////////////////
1239//_____________________________________________________________________________
6bbdc11a 1240void AliTRDCalibraFillHisto::CheckGoodTrackletV1(const AliTRDcluster *cl)
d95484e4 1241{
1242 //
1243 // See if we are not near a masked pad
1244 //
1245
1246 if(cl->IsMasked()) fGoodTracklet = kFALSE;
1247
1248
1249}
1250//_____________________________________________________________________________
6bbdc11a 1251void AliTRDCalibraFillHisto::CheckGoodTrackletV0(const Int_t detector,const Int_t row,const Int_t col)
170c35f1 1252{
1253 //
bcb6fb78 1254 // See if we are not near a masked pad
170c35f1 1255 //
1256
bcb6fb78 1257 if (!IsPadOn(detector, col, row)) {
1258 fGoodTracklet = kFALSE;
1259 }
170c35f1 1260
bcb6fb78 1261 if (col > 0) {
1262 if (!IsPadOn(detector, col-1, row)) {
1263 fGoodTracklet = kFALSE;
1264 }
1265 }
170c35f1 1266
bcb6fb78 1267 if (col < 143) {
1268 if (!IsPadOn(detector, col+1, row)) {
1269 fGoodTracklet = kFALSE;
1270 }
1271 }
1272
170c35f1 1273}
bcb6fb78 1274//_____________________________________________________________________________
1275Bool_t AliTRDCalibraFillHisto::IsPadOn(Int_t detector, Int_t row, Int_t col) const
170c35f1 1276{
1277 //
bcb6fb78 1278 // Look in the choosen database if the pad is On.
1279 // If no the track will be "not good"
170c35f1 1280 //
170c35f1 1281
bcb6fb78 1282 // Get the parameter object
1283 AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
1284 if (!cal) {
1285 AliInfo("Could not get calibDB");
1286 return kFALSE;
1287 }
1288
1289 if (!cal->IsChamberInstalled(detector) ||
1290 cal->IsChamberMasked(detector) ||
1291 cal->IsPadMasked(detector,col,row)) {
1292 return kFALSE;
1293 }
1294 else {
1295 return kTRUE;
1296 }
1297
170c35f1 1298}
bcb6fb78 1299///////////////////////////////////////////////////////////////////////////////////////
1300// Calibration groups: calculate the number of groups, localise...
1301////////////////////////////////////////////////////////////////////////////////////////
1302//_____________________________________________________________________________
1303Int_t AliTRDCalibraFillHisto::CalculateCalibrationGroup(Int_t i, Int_t row, Int_t col) const
170c35f1 1304{
1305 //
bcb6fb78 1306 // Calculate the calibration group number for i
170c35f1 1307 //
170c35f1 1308
bcb6fb78 1309 // Row of the cluster and position in the pad groups
1310 Int_t posr = 0;
1311 if (fCalibraMode->GetNnZ(i) != 0) {
1312 posr = (Int_t) row / fCalibraMode->GetNnZ(i);
1313 }
1314
1315
1316 // Col of the cluster and position in the pad groups
1317 Int_t posc = 0;
1318 if (fCalibraMode->GetNnRphi(i) != 0) {
1319 posc = (Int_t) col / fCalibraMode->GetNnRphi(i);
1320 }
170c35f1 1321
bcb6fb78 1322 return posc*fCalibraMode->GetNfragZ(i)+posr;
170c35f1 1323
1324}
bcb6fb78 1325//____________________________________________________________________________________
1326Int_t AliTRDCalibraFillHisto::CalculateTotalNumberOfBins(Int_t i)
170c35f1 1327{
3a0f6479 1328 //
bcb6fb78 1329 // Calculate the total number of calibration groups
3a0f6479 1330 //
1331
bcb6fb78 1332 Int_t ntotal = 0;
64942b85 1333
1334 // All together
1335 if((fCalibraMode->GetNz(i)==100) && (fCalibraMode->GetNrphi(i)==100)){
1336 ntotal = 1;
1337 AliInfo(Form("Total number of Xbins: %d for i %d",ntotal,i));
1338 return ntotal;
1339 }
1340
1341 // Per Supermodule
1342 if((fCalibraMode->GetNz(i)==10) && (fCalibraMode->GetNrphi(i)==10)){
1343 ntotal = 18;
1344 AliInfo(Form("Total number of Xbins: %d for i %d",ntotal,i));
1345 return ntotal;
1346 }
1347
1348 // More
bcb6fb78 1349 fCalibraMode->ModePadCalibration(2,i);
1350 fCalibraMode->ModePadFragmentation(0,2,0,i);
1351 fCalibraMode->SetDetChamb2(i);
1352 ntotal += 6 * 18 * fCalibraMode->GetDetChamb2(i);
1353 fCalibraMode->ModePadCalibration(0,i);
1354 fCalibraMode->ModePadFragmentation(0,0,0,i);
1355 fCalibraMode->SetDetChamb0(i);
1356 ntotal += 6 * 4 * 18 * fCalibraMode->GetDetChamb0(i);
1357 AliInfo(Form("Total number of Xbins: %d for i %d",ntotal,i));
1358 return ntotal;
1359
1360}
1361//_____________________________________________________________________________
1362void AliTRDCalibraFillHisto::SetNz(Int_t i, Short_t Nz)
1363{
1364 //
1365 // Set the mode of calibration group in the z direction for the parameter i
1366 //
1367
1368 if ((Nz >= 0) &&
1369 (Nz < 5)) {
1370 fCalibraMode->SetNz(i, Nz);
1371 }
1372 else {
1373 AliInfo("You have to choose between 0 and 4");
55a288e5 1374 }
170c35f1 1375
bcb6fb78 1376}
1377//_____________________________________________________________________________
1378void AliTRDCalibraFillHisto::SetNrphi(Int_t i, Short_t Nrphi)
1379{
1380 //
1381 // Set the mode of calibration group in the rphi direction for the parameter i
1382 //
1383
1384 if ((Nrphi >= 0) &&
1385 (Nrphi < 7)) {
1386 fCalibraMode->SetNrphi(i ,Nrphi);
1387 }
1388 else {
1389 AliInfo("You have to choose between 0 and 6");
3a0f6479 1390 }
55a288e5 1391
bcb6fb78 1392}
64942b85 1393
1394//_____________________________________________________________________________
1395void AliTRDCalibraFillHisto::SetAllTogether(Int_t i)
1396{
1397 //
1398 // Set the mode of calibration group all together
1399 //
1400 if(fVector2d == kTRUE) {
1401 AliInfo("Can not work with the vector method");
1402 return;
1403 }
1404 fCalibraMode->SetAllTogether(i);
1405
1406}
1407
1408//_____________________________________________________________________________
1409void AliTRDCalibraFillHisto::SetPerSuperModule(Int_t i)
1410{
1411 //
1412 // Set the mode of calibration group per supermodule
1413 //
1414 if(fVector2d == kTRUE) {
1415 AliInfo("Can not work with the vector method");
1416 return;
1417 }
1418 fCalibraMode->SetPerSuperModule(i);
1419
1420}
1421
bcb6fb78 1422//____________Set the pad calibration variables for the detector_______________
1423Bool_t AliTRDCalibraFillHisto::LocalisationDetectorXbins(Int_t detector)
1424{
1425 //
1426 // For the detector calcul the first Xbins and set the number of row
1427 // and col pads per calibration groups, the number of calibration
1428 // groups in the detector.
1429 //
1430
1431 // first Xbins of the detector
1432 if (fCH2dOn) {
1433 fCalibraMode->CalculXBins(detector,0);
55a288e5 1434 }
bcb6fb78 1435 if (fPH2dOn) {
1436 fCalibraMode->CalculXBins(detector,1);
55a288e5 1437 }
170c35f1 1438 if (fPRF2dOn) {
bcb6fb78 1439 fCalibraMode->CalculXBins(detector,2);
55a288e5 1440 }
bcb6fb78 1441
1442 // fragmentation of idect
1443 for (Int_t i = 0; i < 3; i++) {
053767a4 1444 fCalibraMode->ModePadCalibration((Int_t) GetStack(detector),i);
1445 fCalibraMode->ModePadFragmentation((Int_t) GetLayer(detector)
1446 , (Int_t) GetStack(detector)
bcb6fb78 1447 , (Int_t) GetSector(detector),i);
170c35f1 1448 }
55a288e5 1449
bcb6fb78 1450 return kTRUE;
1451
55a288e5 1452}
bcb6fb78 1453//_____________________________________________________________________________
1454void AliTRDCalibraFillHisto::SetNumberGroupsPRF(Short_t numberGroupsPRF)
55a288e5 1455{
1456 //
bcb6fb78 1457 // Should be between 0 and 6
55a288e5 1458 //
bcb6fb78 1459
1460 if ((numberGroupsPRF < 0) || (numberGroupsPRF > 6)) {
1461 AliInfo("The number of groups must be between 0 and 6!");
1462 }
1463 else {
1464 fNgroupprf = numberGroupsPRF;
1465 }
55a288e5 1466
bcb6fb78 1467}
1468///////////////////////////////////////////////////////////////////////////////////////////
1469// Per tracklet: store or reset the info, fill the histos with the info
1470//////////////////////////////////////////////////////////////////////////////////////////
1471//_____________________________________________________________________________
1785640c 1472void AliTRDCalibraFillHisto::StoreInfoCHPHtrack(const AliTRDcluster *cl,const Double_t dqdl,const Int_t *group,const Int_t row,const Int_t col,const AliTRDcluster *cls)
bcb6fb78 1473{
1474 //
1475 // Store the infos in fAmpTotal, fPHPlace and fPHValue
1476 // Correct from the gain correction before
1785640c 1477 // cls is shared cluster if any
bcb6fb78 1478 //
1479
09ea3770 1480 //printf("StoreInfoCHPHtrack\n");
1481
bcb6fb78 1482 // time bin of the cluster not corrected
1483 Int_t time = cl->GetPadTime();
e526983e 1484 Float_t charge = TMath::Abs(cl->GetQ());
09ea3770 1485 if(cls) {
1486 charge += TMath::Abs(cls->GetQ());
1487 //printf("AliTRDCalibraFillHisto::Add the cluster charge");
1488 }
e526983e 1489
1490 //printf("Store::time %d, amplitude %f\n",time,dqdl);
1491
bcb6fb78 1492 //Correct for the gain coefficient used in the database for reconstruction
64942b85 1493 Float_t correctthegain = 1.0;
1494 if(fIsHLT) correctthegain = fCalDetGain->GetValue(fDetectorPreviousTrack);
1495 else correctthegain = fCalDetGain->GetValue(fDetectorPreviousTrack)*fCalROCGain->GetValue(col,row);
bcb6fb78 1496 Float_t correction = 1.0;
1497 Float_t normalisation = 6.67;
1498 // we divide with gain in AliTRDclusterizer::Transform...
1499 if( correctthegain > 0 ) normalisation /= correctthegain;
55a288e5 1500
55a288e5 1501
bcb6fb78 1502 // take dd/dl corrected from the angle of the track
1503 correction = dqdl / (normalisation);
1504
55a288e5 1505
bcb6fb78 1506 // Fill the fAmpTotal with the charge
b70c68da 1507 if (fCH2dOn) {
e526983e 1508 if((!fLimitChargeIntegration) || (cl->IsInChamber())) {
1509 //printf("Store::group %d, amplitude %f\n",group[0],correction);
1510 fAmpTotal[(Int_t) group[0]] += correction;
1511 }
bcb6fb78 1512 }
55a288e5 1513
bcb6fb78 1514 // Fill the fPHPlace and value
1515 if (fPH2dOn) {
1516 fPHPlace[time] = group[1];
e526983e 1517 fPHValue[time] = charge;
bcb6fb78 1518 }
1519
1520}
1521//____________Offine tracking in the AliTRDtracker_____________________________
1522void AliTRDCalibraFillHisto::ResetfVariablestracklet()
1523{
1524 //
1525 // Reset values per tracklet
1526 //
1527
1528 //Reset good tracklet
1529 fGoodTracklet = kTRUE;
1530
1531 // Reset the fPHValue
1532 if (fPH2dOn) {
1533 //Reset the fPHValue and fPHPlace
1534 for (Int_t k = 0; k < fTimeMax; k++) {
1535 fPHValue[k] = 0.0;
1536 fPHPlace[k] = -1;
55a288e5 1537 }
bcb6fb78 1538 }
55a288e5 1539
bcb6fb78 1540 // Reset the fAmpTotal where we put value
1541 if (fCH2dOn) {
1542 for (Int_t k = 0; k < fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0); k++) {
1543 fAmpTotal[k] = 0.0;
55a288e5 1544 }
55a288e5 1545 }
55a288e5 1546}
bcb6fb78 1547//____________Offine tracking in the AliTRDtracker_____________________________
1548void AliTRDCalibraFillHisto::FillTheInfoOfTheTrackCH(Int_t nbclusters)
170c35f1 1549{
1550 //
bcb6fb78 1551 // For the offline tracking or mcm tracklets
1552 // This function will be called in the functions UpdateHistogram...
1553 // to fill the info of a track for the relativ gain calibration
170c35f1 1554 //
bcb6fb78 1555
1556 Int_t nb = 0; // Nombre de zones traversees
1557 Int_t fd = -1; // Premiere zone non nulle
1558 Float_t totalcharge = 0.0; // Total charge for the supermodule histo
170c35f1 1559
e526983e 1560 //printf("CH2d nbclusters %d, fNumberClusters %d, fNumberClustersf %d\n",nbclusters,fNumberClusters,fNumberClustersf);
1561
bcb6fb78 1562 if(nbclusters < fNumberClusters) return;
1563 if(nbclusters > fNumberClustersf) return;
64942b85 1564
1565
1566 // Normalize with the number of clusters
1567 Double_t normalizeCst = fRelativeScale;
1568 if(fNormalizeNbOfCluster) normalizeCst = normalizeCst*nbclusters;
e526983e 1569
1570 //printf("Number of groups in one detector %d\n",fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0));
bcb6fb78 1571
1572 // See if the track goes through different zones
1573 for (Int_t k = 0; k < fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0); k++) {
e526983e 1574 //printf("fAmpTotal %f for %d\n",fAmpTotal[k],k);
bcb6fb78 1575 if (fAmpTotal[k] > 0.0) {
1576 totalcharge += fAmpTotal[k];
1577 nb++;
1578 if (nb == 1) {
1579 fd = k;
1580 }
170c35f1 1581 }
170c35f1 1582 }
170c35f1 1583
e526983e 1584 //printf("CH2d: nb %d, fd %d, calibration group %d, amplitude %f, detector %d\n",nb,fd,fCalibraMode->GetXbins(0),fAmpTotal[fd]/normalizeCst,fDetectorPreviousTrack);
bcb6fb78 1585
1586 switch (nb)
1587 {
1588 case 1:
1589 fNumberUsedCh[0]++;
1590 fEntriesCH[fCalibraMode->GetXbins(0)+fd]++;
1591 if (fHisto2d) {
64942b85 1592 FillCH2d(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/normalizeCst);
1593 //fCH2d->Fill(fAmpTotal[fd]/normalizeCst,fCalibraMode->GetXbins(0)+fd+0.5);
bcb6fb78 1594 }
1595 if (fVector2d) {
64942b85 1596 fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd,fAmpTotal[fd]/normalizeCst);
bcb6fb78 1597 }
1598 break;
1599 case 2:
1600 if ((fAmpTotal[fd] > 0.0) &&
1601 (fAmpTotal[fd+1] > 0.0)) {
1602 // One of the two very big
1603 if (fAmpTotal[fd] > fProcent*fAmpTotal[fd+1]) {
1604 if (fHisto2d) {
64942b85 1605 FillCH2d(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/normalizeCst);
1606 //fCH2d->Fill(fAmpTotal[fd]/normalizeCst,fCalibraMode->GetXbins(0)+fd+0.5);
bcb6fb78 1607 }
1608 if (fVector2d) {
64942b85 1609 fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd,fAmpTotal[fd]/normalizeCst);
bcb6fb78 1610 }
1611 fNumberUsedCh[1]++;
1612 fEntriesCH[fCalibraMode->GetXbins(0)+fd]++;
1613 }
1614 if (fAmpTotal[fd+1] > fProcent*fAmpTotal[fd]) {
1615 if (fHisto2d) {
64942b85 1616 FillCH2d(fCalibraMode->GetXbins(0)+fd+1,fAmpTotal[fd+1]/normalizeCst);
1617 //fCH2d->Fill(fAmpTotal[fd+1]/normalizeCst,fCalibraMode->GetXbins(0)+fd+1.5);
bcb6fb78 1618 }
1619 if (fVector2d) {
64942b85 1620 fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd+1,fAmpTotal[fd+1]/normalizeCst);
bcb6fb78 1621 }
1622 fNumberUsedCh[1]++;
1623 fEntriesCH[fCalibraMode->GetXbins(0)+fd+1]++;
1624 }
1625 }
1626 if (fCalibraMode->GetNfragZ(0) > 1) {
1627 if (fAmpTotal[fd] > 0.0) {
1628 if ((fd+fCalibraMode->GetNfragZ(0)) < (fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0))) {
1629 if (fAmpTotal[fd+fCalibraMode->GetNfragZ(0)] > 0.0) {
1630 // One of the two very big
1631 if (fAmpTotal[fd] > fProcent*fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]) {
1632 if (fHisto2d) {
64942b85 1633 FillCH2d(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/normalizeCst);
1634 //fCH2d->Fill(fAmpTotal[fd]/normalizeCst,fCalibraMode->GetXbins(0)+fd+0.5);
bcb6fb78 1635 }
1636 if (fVector2d) {
64942b85 1637 fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd,fAmpTotal[fd]/normalizeCst);
bcb6fb78 1638 }
1639 fNumberUsedCh[1]++;
1640 fEntriesCH[fCalibraMode->GetXbins(0)+fd]++;
1641 }
1642 if (fAmpTotal[fd+fCalibraMode->GetNfragZ(0)] > fProcent*fAmpTotal[fd]) {
1643 if (fHisto2d) {
64942b85 1644 FillCH2d(fCalibraMode->GetXbins(0)+fd+fCalibraMode->GetNfragZ(0),fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/normalizeCst);
1645 //fCH2d->Fill(fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/normalizeCst,fCalibraMode->GetXbins(0)+fd+fCalibraMode->GetNfragZ(0)+0.5);
bcb6fb78 1646 }
1647 fNumberUsedCh[1]++;
1648 fEntriesCH[fCalibraMode->GetXbins(0)+fd+fCalibraMode->GetNfragZ(0)]++;
1649 if (fVector2d) {
64942b85 1650 fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd+fCalibraMode->GetNfragZ(0),fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/normalizeCst);
bcb6fb78 1651 }
1652 }
1653 }
1654 }
1655 }
1656 }
1657 break;
1658 default: break;
3d1ad7ac 1659 }
170c35f1 1660}
bcb6fb78 1661//____________Offine tracking in the AliTRDtracker_____________________________
1662void AliTRDCalibraFillHisto::FillTheInfoOfTheTrackPH()
170c35f1 1663{
1664 //
bcb6fb78 1665 // For the offline tracking or mcm tracklets
1666 // This function will be called in the functions UpdateHistogram...
1667 // to fill the info of a track for the drift velocity calibration
170c35f1 1668 //
bcb6fb78 1669
1670 Int_t nb = 1; // Nombre de zones traversees 1, 2 ou plus de 3
1671 Int_t fd1 = -1; // Premiere zone non nulle
1672 Int_t fd2 = -1; // Deuxieme zone non nulle
1673 Int_t k1 = -1; // Debut de la premiere zone
1674 Int_t k2 = -1; // Debut de la seconde zone
1675 Int_t nbclusters = 0; // number of clusters
170c35f1 1676
170c35f1 1677
170c35f1 1678
bcb6fb78 1679 // See if the track goes through different zones
1680 for (Int_t k = 0; k < fTimeMax; k++) {
1681 if (fPHValue[k] > 0.0) {
1682 nbclusters++;
1683 if (fd1 == -1) {
1684 fd1 = fPHPlace[k];
1685 k1 = k;
1686 }
1687 if (fPHPlace[k] != fd1) {
1688 if (fd2 == -1) {
1689 k2 = k;
1690 fd2 = fPHPlace[k];
1691 nb = 2;
1692 }
1693 if (fPHPlace[k] != fd2) {
1694 nb = 3;
1695 }
1696 }
55a288e5 1697 }
1698 }
55a288e5 1699
64942b85 1700 // See if noise before and after
1701 if(fMaxCluster > 0) {
1702 if(fPHValue[0] > fMaxCluster) return;
1703 if(fTimeMax > fNbMaxCluster) {
1704 for(Int_t k = (fTimeMax-fNbMaxCluster); k < fTimeMax; k++){
1705 if(fPHValue[k] > fMaxCluster) return;
1706 }
1707 }
1708 }
1709
4aad967c 1710 //printf("nbclusters %d, low limit %d, high limit %d\n",nbclusters,fNumberClusters,fNumberClustersf);
1711
bcb6fb78 1712 if(nbclusters < fNumberClusters) return;
1713 if(nbclusters > fNumberClustersf) return;
3a0f6479 1714
bcb6fb78 1715 switch(nb)
1716 {
170c35f1 1717 case 1:
bcb6fb78 1718 fNumberUsedPh[0]++;
1719 for (Int_t i = 0; i < fTimeMax; i++) {
1720 if (fHisto2d) {
37b0cf5e 1721 if(fFillWithZero) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
1722 else {
1723 if(((Float_t) fPHValue[i] > 0.0)) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
1724 }
bcb6fb78 1725 //printf("Fill the time bin %d with %f\n",i,fPHValue[i]);
1726 }
1727 if (fVector2d) {
37b0cf5e 1728 if(fFillWithZero) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
1729 else {
1730 if(((Float_t) fPHValue[i] > 0.0)) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
1731 }
bcb6fb78 1732 }
55a288e5 1733 }
170c35f1 1734 break;
1735 case 2:
bcb6fb78 1736 if ((fd1 == fd2+1) ||
1737 (fd2 == fd1+1)) {
1738 // One of the two fast all the think
1739 if (k2 > (k1+fDifference)) {
1740 //we choose to fill the fd1 with all the values
1741 fNumberUsedPh[1]++;
1742 for (Int_t i = 0; i < fTimeMax; i++) {
1743 if (fHisto2d) {
37b0cf5e 1744 if(fFillWithZero) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
1745 else {
1746 if(((Float_t) fPHValue[i] > 0.0)) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
1747 }
bcb6fb78 1748 }
1749 if (fVector2d) {
37b0cf5e 1750 if(fFillWithZero) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
1751 else {
1752 if(((Float_t) fPHValue[i] > 0.0)) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
1753 }
bcb6fb78 1754 }
55a288e5 1755 }
55a288e5 1756 }
bcb6fb78 1757 if ((k2+fDifference) < fTimeMax) {
1758 //we choose to fill the fd2 with all the values
1759 fNumberUsedPh[1]++;
1760 for (Int_t i = 0; i < fTimeMax; i++) {
1761 if (fHisto2d) {
37b0cf5e 1762 if(fFillWithZero) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) fPHValue[i]);
1763 else {
1764 if(((Float_t) fPHValue[i] > 0.0)) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) fPHValue[i]);
1765 }
bcb6fb78 1766 }
55a288e5 1767 if (fVector2d) {
37b0cf5e 1768 if(fFillWithZero) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd2,i,fPHValue[i]);
1769 else {
1770 if(((Float_t) fPHValue[i] > 0.0)) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd2,i,fPHValue[i]);
1771 }
bcb6fb78 1772 }
55a288e5 1773 }
55a288e5 1774 }
1775 }
bcb6fb78 1776 // Two zones voisines sinon rien!
1777 if (fCalibraMode->GetNfragZ(1) > 1) {
1778 // Case 2
1779 if ((fd1+fCalibraMode->GetNfragZ(1)) < (fCalibraMode->GetNfragZ(1)*fCalibraMode->GetNfragRphi(1))) {
1780 if (fd2 == (fd1+fCalibraMode->GetNfragZ(1))) {
1781 // One of the two fast all the think
1782 if (k2 > (k1+fDifference)) {
1783 //we choose to fill the fd1 with all the values
1784 fNumberUsedPh[1]++;
1785 for (Int_t i = 0; i < fTimeMax; i++) {
55a288e5 1786 if (fHisto2d) {
37b0cf5e 1787 if(fFillWithZero) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
1788 else {
1789 if(((Float_t) fPHValue[i] > 0.0)) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
1790 }
55a288e5 1791 }
1792 if (fVector2d) {
37b0cf5e 1793 if(fFillWithZero) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
1794 else {
1795 if(((Float_t) fPHValue[i] > 0.0)) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
1796 }
55a288e5 1797 }
55a288e5 1798 }
bcb6fb78 1799 }
1800 if ((k2+fDifference) < fTimeMax) {
1801 //we choose to fill the fd2 with all the values
1802 fNumberUsedPh[1]++;
1803 for (Int_t i = 0; i < fTimeMax; i++) {
55a288e5 1804 if (fHisto2d) {
37b0cf5e 1805 if(fFillWithZero) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) fPHValue[i]);
1806 else {
1807 if(((Float_t) fPHValue[i] > 0.0)) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) fPHValue[i]);
1808 }
170c35f1 1809 }
1810 if (fVector2d) {
37b0cf5e 1811 if(fFillWithZero) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd2,i,fPHValue[i]);
1812 else {
1813 if(((Float_t) fPHValue[i] > 0.0)) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd2,i,fPHValue[i]);
1814 }
170c35f1 1815 }
55a288e5 1816 }
1817 }
1818 }
1819 }
170c35f1 1820 // Two zones voisines sinon rien!
1821 // Case 3
1822 if ((fd1 - fCalibraMode->GetNfragZ(1)) >= 0) {
1823 if (fd2 == (fd1 - fCalibraMode->GetNfragZ(1))) {
1824 // One of the two fast all the think
1825 if (k2 > (k1 + fDifference)) {
1826 //we choose to fill the fd1 with all the values
1827 fNumberUsedPh[1]++;
1828 for (Int_t i = 0; i < fTimeMax; i++) {
1829 if (fHisto2d) {
37b0cf5e 1830 if(fFillWithZero) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
1831 else {
1832 if(((Float_t) fPHValue[i] > 0.0)) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
1833 }
170c35f1 1834 }
1835 if (fVector2d) {
37b0cf5e 1836 if(fFillWithZero) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
1837 else {
1838 if(((Float_t) fPHValue[i] > 0.0)) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
1839 }
170c35f1 1840 }
55a288e5 1841 }
1842 }
170c35f1 1843 if ((k2+fDifference) < fTimeMax) {
1844 //we choose to fill the fd2 with all the values
1845 fNumberUsedPh[1]++;
1846 for (Int_t i = 0; i < fTimeMax; i++) {
1847 if (fHisto2d) {
37b0cf5e 1848 if(fFillWithZero) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) fPHValue[i]);
1849 else {
1850 if(((Float_t) fPHValue[i] > 0.0)) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) fPHValue[i]);
1851 }
170c35f1 1852 }
1853 if (fVector2d) {
37b0cf5e 1854 if(fFillWithZero) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd2,i,fPHValue[i]);
1855 else {
1856 if(((Float_t) fPHValue[i] > 0.0)) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd2,i,fPHValue[i]);
1857 }
170c35f1 1858 }
55a288e5 1859 }
1860 }
1861 }
1862 }
1863 }
170c35f1 1864 break;
1865 default: break;
1866 }
55a288e5 1867}
bcb6fb78 1868//////////////////////////////////////////////////////////////////////////////////////////
1869// DAQ process functions
1870/////////////////////////////////////////////////////////////////////////////////////////
1871//_____________________________________________________________________
8df1f8f5 1872Int_t AliTRDCalibraFillHisto::ProcessEventDAQ(AliRawReader *rawReader)
fd50bb14 1873 { //main
1874 //
1875 // Event Processing loop - AliTRDrawStream
1876 //
1877 // 0 timebin problem
1878 // 1 no input
1879 // 2 input
1880 // Same algorithm as TestBeam but different reader
1881 //
1882
fd50bb14 1883 AliTRDrawStream *rawStream = new AliTRDrawStream(rawReader);
fd50bb14 1884
1885 AliTRDdigitsManager *digitsManager = new AliTRDdigitsManager(kTRUE);
1886 digitsManager->CreateArrays();
1887
1888 Int_t withInput = 1;
1889
1890 Double_t phvalue[16][144][36];
1891 for(Int_t k = 0; k < 36; k++){
1892 for(Int_t j = 0; j < 16; j++){
1893 for(Int_t c = 0; c < 144; c++){
1894 phvalue[j][c][k] = 0.0;
1895 }
1896 }
1897 }
1898
1899 fDetectorPreviousTrack = -1;
1900 fMCMPrevious = -1;
1901 fROBPrevious = -1;
1902
1903 Int_t nbtimebin = 0;
1904 Int_t baseline = 10;
1905
1906
1907 fTimeMax = 0;
1908
1909 Int_t det = 0;
1910 while ((det = rawStream->NextChamber(digitsManager, NULL, NULL)) >= 0) { //idetector
1911
1912 if (digitsManager->GetIndexes(det)->HasEntry()) {//QA
1913 // printf("there is ADC data on this chamber!\n");
1914
1915 AliTRDarrayADC *digits = (AliTRDarrayADC *) digitsManager->GetDigits(det); //mod
1916 if (digits->HasData()) { //array
1917
1918 AliTRDSignalIndex *indexes = digitsManager->GetIndexes(det);
1919 if (indexes->IsAllocated() == kFALSE) {
1920 AliError("Indexes do not exist!");
1921 break;
1922 }
1923 Int_t iRow = 0;
1924 Int_t iCol = 0;
1925 indexes->ResetCounters();
1926
1927 while (indexes->NextRCIndex(iRow, iCol)) { //column,row
1928 //printf(" det %d \t row %d \t col %d \t digit\n",det,iRow,iCol);
1929 //while (rawStream->Next()) {
1930
1931 Int_t idetector = det; // current detector
1932 //Int_t imcm = rawStream->GetMCM(); // current MCM
1933 //Int_t irob = rawStream->GetROB(); // current ROB
1934
1935
1936 if((fDetectorPreviousTrack != idetector) && (fDetectorPreviousTrack != -1)) {
1937 // Fill
1938 withInput = TMath::Max(FillDAQ(phvalue),withInput);
1939
1940 // reset
1941 for(Int_t k = 0; k < 36; k++){
1942 for(Int_t j = 0; j < 16; j++){
1943 for(Int_t c = 0; c < 144; c++){
1944 phvalue[j][c][k] = 0.0;
1945 }
1946 }
1947 }
1948 }
1949
1950 fDetectorPreviousTrack = idetector;
1951 //fMCMPrevious = imcm;
1952 //fROBPrevious = irob;
1953
1954 // nbtimebin = rawStream->GetNumberOfTimeBins(); // number of time bins read from data
1955 AliTRDdigitsParam *digitParam = (AliTRDdigitsParam *)digitsManager->GetDigitsParam();
1956 nbtimebin = digitParam->GetNTimeBins(det); // number of time bins read from data
1957 baseline = digitParam->GetADCbaseline(det); // baseline
1958
1959 if(nbtimebin == 0) return 0;
1960 if((fTimeMax != 0) && (nbtimebin != fTimeMax)) return 0;
1961 fTimeMax = nbtimebin;
1962
1963 fNumberClustersf = fTimeMax;
1964 fNumberClusters = (Int_t)(fNumberClustersProcent*fTimeMax);
1965
1966
1967 for(Int_t itime = 0; itime < nbtimebin; itime++) {
1968 // phvalue[row][col][itime] = signal[itime]-baseline;
1969 phvalue[iRow][iCol][itime] = (Short_t)(digits->GetData(iRow,iCol,itime) - baseline);
1970 /*if(phvalue[iRow][iCol][itime] >= 20) {
1971 printf("----------> phvalue[%d][%d][%d] %d baseline %d \n",
1972 iRow,
1973 iCol,
1974 itime,
1975 (Short_t)(digits->GetData(iRow,iCol,itime)),
1976 baseline);
1977 }*/
1978 }
1979
1980 }//column,row
1981
1982 // fill the last one
1983 if(fDetectorPreviousTrack != -1){
1984
1985 // Fill
1986 withInput = TMath::Max(FillDAQ(phvalue),withInput);
1987 // printf("\n ---> withinput %d\n\n",withInput);
1988 // reset
1989 for(Int_t k = 0; k < 36; k++){
1990 for(Int_t j = 0; j < 16; j++){
1991 for(Int_t c = 0; c < 144; c++){
1992 phvalue[j][c][k] = 0.0;
1993 }
1994 }
1995 }
1996 }
1997
1998 }//array
1999 }//QA
2000 digitsManager->ClearArrays(det);
2001 }//idetector
2002 delete digitsManager;
2003
2004 delete rawStream;
2005 return withInput;
2006 }//main
2007//_____________________________________________________________________
bcb6fb78 2008//////////////////////////////////////////////////////////////////////////////
2009// Routine inside the DAQ process
2010/////////////////////////////////////////////////////////////////////////////
2011//_______________________________________________________________________
bcb6fb78 2012Int_t AliTRDCalibraFillHisto::FillDAQ(Double_t phvalue[16][144][36]){
2013
2014 //
2015 // Look for the maximum by collapsing over the time
2016 // Sum over four pad col and two pad row
2017 //
2018
2019 Int_t used = 0;
2020
2021
2022 Int_t idect = fDetectorPreviousTrack;
d95484e4 2023 //printf("Enter Detector %d\n",fDetectorPreviousTrack);
bcb6fb78 2024 Double_t sum[36];
2025 for(Int_t tb = 0; tb < 36; tb++){
2026 sum[tb] = 0.0;
2027 }
2028
d95484e4 2029 //fGoodTracklet = kTRUE;
2030 //fDetectorPreviousTrack = 0;
bcb6fb78 2031
2032
2033 ///////////////////////////
2034 // look for maximum
2035 /////////////////////////
2036
2037 Int_t imaxRow = 0;
2038 Int_t imaxCol = 0;
2039 Double_t integralMax = -1;
2040
2041 for (Int_t ir = 1; ir <= 15; ir++)
2042 {
2043 for (Int_t ic = 2; ic <= 142; ic++)
2044 {
2045 Double_t integral = 0;
6aafa7ea 2046 for (Int_t ishiftR = 0; ishiftR < fNumberRowDAQ; ishiftR++)
bcb6fb78 2047 {
6aafa7ea 2048 for (Int_t ishiftC = -fNumberColDAQ; ishiftC < fNumberColDAQ; ishiftC++)
bcb6fb78 2049 {
2050 if (ir + ishiftR >= 1 && ir + ishiftR <= 16 &&
2051 ic + ishiftC >= 1 && ic + ishiftC <= 144)
2052 {
2053
2054 for(Int_t tb = 0; tb< fTimeMax; tb++){
2055 integral += phvalue[ir + ishiftR-1][ic + ishiftC-1][tb];
2056 }// addtb
2057 } //addsignal
2058 } //shiftC
2059 } // shiftR
bcb6fb78 2060 if (integralMax < integral)
2061 {
2062 imaxRow = ir;
2063 imaxCol = ic;
2064 integralMax = integral;
1785640c 2065
bcb6fb78 2066 } // check max integral
2067 } //ic
2068 } // ir
2069
1785640c 2070 // printf("imaxRow %d, imaxCol %d, fTimeMax %d, integralMax %f\n",imaxRow,imaxCol,fTimeMax, integralMax);
6aafa7ea 2071 //if((imaxRow == 0) || (imaxRow >= 15) || (imaxCol <= 3) || (imaxCol >= 140)) {
2072 // used=1;
2073 // return used;
2074 // }
1785640c 2075
6aafa7ea 2076 if(((imaxRow + fNumberRowDAQ) > 16) || (imaxRow == 0) || ((imaxCol - fNumberColDAQ) <= 1) || ((imaxCol + fNumberColDAQ) >= 144)) {
27b46d95 2077 used=1;
2078 return used;
2079 }
d95484e4 2080 //CheckGoodTrackletV0(fDetectorPreviousTrack,imaxRow,imaxCol);
2081 //if(!fGoodTracklet) used = 1;;
bcb6fb78 2082
2083 // /////////////////////////////////////////////////////
2084 // sum ober 2 row and 4 pad cols for each time bins
2085 // ////////////////////////////////////////////////////
2086
2087
1785640c 2088
6aafa7ea 2089 for (Int_t ishiftR = 0; ishiftR < fNumberRowDAQ; ishiftR++)
bcb6fb78 2090 {
6aafa7ea 2091 for (Int_t ishiftC = -fNumberColDAQ; ishiftC < fNumberColDAQ; ishiftC++)
bcb6fb78 2092 {
6aafa7ea 2093 if (imaxRow + ishiftR >= 1 && imaxRow + ishiftR <= 16 &&
2094 imaxCol + ishiftC >= 1 && imaxCol + ishiftC <= 144)
2095 {
2096 for(Int_t it = 0; it < fTimeMax; it++){
2097 sum[it] += phvalue[imaxRow + ishiftR-1][imaxCol + ishiftC-1][it];
2098 }
2099 }
2100 } // col shift
2101 }// row shift
bcb6fb78 2102
2103 Int_t nbcl = 0;
2104 Double_t sumcharge = 0.0;
2105 for(Int_t it = 0; it < fTimeMax; it++){
2106 sumcharge += sum[it];
1785640c 2107 if(sum[it] > fThresholdClustersDAQ) nbcl++;
bcb6fb78 2108 }
2109
2110
2111 /////////////////////////////////////////////////////////
2112 // Debug
2113 ////////////////////////////////////////////////////////
2114 if(fDebugLevel > 0){
2115 if ( !fDebugStreamer ) {
2116 //debug stream
2117 TDirectory *backup = gDirectory;
2118 fDebugStreamer = new TTreeSRedirector("TRDdebugCalibraFill.root");
2119 if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
2120 }
2121
2122 Double_t amph0 = sum[0];
2123 Double_t amphlast = sum[fTimeMax-1];
2124 Double_t rms = TMath::RMS(fTimeMax,sum);
2125 Int_t goodtracklet = (Int_t) fGoodTracklet;
2126 for(Int_t it = 0; it < fTimeMax; it++){
2127 Double_t clustera = sum[it];
2128
2129 (* fDebugStreamer) << "FillDAQa"<<
2130 "ampTotal="<<sumcharge<<
2131 "row="<<imaxRow<<
2132 "col="<<imaxCol<<
2133 "detector="<<idect<<
2134 "amph0="<<amph0<<
2135 "amphlast="<<amphlast<<
2136 "goodtracklet="<<goodtracklet<<
2137 "clustera="<<clustera<<
2138 "it="<<it<<
2139 "rms="<<rms<<
6aafa7ea 2140 "nbcl="<<nbcl<<
bcb6fb78 2141 "\n";
2142 }
2143 }
2144
2145 ////////////////////////////////////////////////////////
2146 // fill
2147 ///////////////////////////////////////////////////////
6aafa7ea 2148 //printf("fNumberClusters %d, fNumberClustersf %d\n",fNumberClusters,fNumberClustersf);
bcb6fb78 2149 if(sum[0] > 100.0) used = 1;
2150 if(nbcl < fNumberClusters) used = 1;
2151 if(nbcl > fNumberClustersf) used = 1;
2152
2153 //if(fDetectorPreviousTrack == 15){
2154 // printf("rms %f and first time bin %f\n",TMath::RMS(fTimeMax,sum),sum[0]);
2155 //}
2156 //if((TMath::RMS(fTimeMax,sum) <= 10.0) && (sum[0] > 200.0)) return 1;
2157 if(used == 0){
2158 for(Int_t it = 0; it < fTimeMax; it++){
37b0cf5e 2159 if(fFillWithZero) UpdateDAQ(fDetectorPreviousTrack,0,0,it,sum[it],fTimeMax);
2160 else{
1785640c 2161 if(sum[it] > 0.0) UpdateDAQ(fDetectorPreviousTrack,0,0,it,sum[it],fTimeMax);
37b0cf5e 2162 }
1785640c 2163 //if(fFillWithZero) UpdateDAQ(0,0,0,it,sum[it],fTimeMax);
6aafa7ea 2164 //else{
1785640c 2165 // if(sum[it] > 0.0) UpdateDAQ(0,0,0,it,sum[it],fTimeMax);
2166 //}
bcb6fb78 2167 }
2168
2169
2170 //((TH2I *)GetCH2d()->Fill(sumcharge/30.0,fDetectorPreviousTrack));
2171 used = 2;
d95484e4 2172 //printf("Pass Detector %d\n",fDetectorPreviousTrack);
2173
bcb6fb78 2174 }
2175
2176 return used;
2177
2178}
2179//____________Online trackling in AliTRDtrigger________________________________
2180Bool_t AliTRDCalibraFillHisto::UpdateDAQ(Int_t det, Int_t /*row*/, Int_t /*col*/, Int_t timebin, Float_t signal, Int_t nbtimebins)
2181{
2182 //
2183 // For the DAQ
2184 // Fill a simple average pulse height
2185 //
2186
2187
2188 ((TProfile2D *)GetPH2d(nbtimebins,fSf))->Fill((Float_t) timebin/fSf,det+0.5,(Float_t) signal);
2189
2190
2191 return kTRUE;
2192
2193}
2194//____________Write_____________________________________________________
2195//_____________________________________________________________________
2196void AliTRDCalibraFillHisto::Write2d(const Char_t *filename, Bool_t append)
2197{
2198 //
2199 // Write infos to file
2200 //
2201
2202 //For debugging
2203 if ( fDebugStreamer ) {
2204 delete fDebugStreamer;
2205 fDebugStreamer = 0x0;
2206 }
2207
2208 AliInfo(Form("Numbertrack: %d Numberusedch[0]: %d, Numberusedch[1]: %d Numberusedph[0]: %d, Numberusedph[1]: %d"
2209 ,fNumberTrack
2210 ,fNumberUsedCh[0]
2211 ,fNumberUsedCh[1]
2212 ,fNumberUsedPh[0]
2213 ,fNumberUsedPh[1]));
2214
2215 TDirectory *backup = gDirectory;
2216 TString option;
2217
2218 if ( append )
2219 option = "update";
2220 else
2221 option = "recreate";
2222
2223 TFile f(filename,option.Data());
2224
2225 TStopwatch stopwatch;
2226 stopwatch.Start();
2227 if(fVector2d) {
2228 f.WriteTObject(fCalibraVector);
2229 }
2230
2231 if (fCH2dOn ) {
2232 if (fHisto2d) {
2233 f.WriteTObject(fCH2d);
2234 }
2235 }
2236 if (fPH2dOn ) {
2237 if (fHisto2d) {
2238 f.WriteTObject(fPH2d);
2239 }
2240 }
2241 if (fPRF2dOn) {
2242 if (fHisto2d) {
2243 f.WriteTObject(fPRF2d);
2244 }
2245 }
2246 if(fLinearFitterOn){
46c4871e 2247 if(fLinearFitterDebugOn) AnalyseLinearFitter();
bcb6fb78 2248 f.WriteTObject(fLinearVdriftFit);
2249 }
2250
2251 f.Close();
2252
2253 if ( backup ) backup->cd();
2254
2255 AliInfo(Form("Execution time Write2d: R:%.2fs C:%.2fs"
2256 ,stopwatch.RealTime(),stopwatch.CpuTime()));
2257}
2258//////////////////////////////////////////////////////////////////////////////////////////////////////////////
2259// Stats stuff
2260//////////////////////////////////////////////////////////////////////////////////////////////////////////////
2261//___________________________________________probe the histos__________________________________________________
2262Double_t *AliTRDCalibraFillHisto::StatH(TH2 *h, Int_t i)
2263{
2264 //
2265 // Check the number of stats in h, 0 is TH2I 1 is TProfile2D
2266 // debug mode with 2 for TH2I and 3 for TProfile2D
2267 // It gives a pointer to a Double_t[7] with the info following...
2268 // [0] : number of calibration groups with entries
2269 // [1] : minimal number of entries found
2270 // [2] : calibration group number of the min
2271 // [3] : maximal number of entries found
2272 // [4] : calibration group number of the max
2273 // [5] : mean number of entries found
2274 // [6] : mean relative error
2275 //
2276
2277 Double_t *info = new Double_t[7];
2278
2279 // Number of Xbins (detectors or groups of pads)
2280 Int_t nbins = h->GetNbinsY(); //number of calibration groups
2281 Int_t nxbins = h->GetNbinsX(); //number of bins per histo
2282
2283 // Initialise
2284 Double_t nbwe = 0; //number of calibration groups with entries
2285 Double_t minentries = 0; //minimal number of entries found
2286 Double_t maxentries = 0; //maximal number of entries found
2287 Double_t placemin = 0; //calibration group number of the min
2288 Double_t placemax = -1; //calibration group number of the max
2289 Double_t meanstats = 0.0; //mean number of entries over the calibration group with at least ome entry
2290 Double_t meanrelativerror = 0.0; //mean relativ error in the TProfile2D
2291
2292 Double_t counter = 0;
2293
2294 //Debug
2295 TH1F *nbEntries = 0x0;//distribution of the number of entries
2296 TH1F *nbEntriesPerGroup = 0x0;//Number of entries per group
2297 TProfile *nbEntriesPerSp = 0x0;//Number of entries for one supermodule
2298
2299 // Beginning of the loop over the calibration groups
2300 for (Int_t idect = 0; idect < nbins; idect++) {
2301
2302 TH1I *projch = (TH1I *) h->ProjectionX("projch",idect+1,idect+1,(Option_t *)"e");
2303 projch->SetDirectory(0);
2304
2305 // Number of entries for this calibration group
2306 Double_t nentries = 0.0;
2307 if((i%2) == 0){
2308 for (Int_t k = 0; k < nxbins; k++) {
2309 nentries += h->GetBinContent(h->GetBin(k+1,idect+1));
3a0f6479 2310 }
bcb6fb78 2311 }
2312 else{
2313 for (Int_t k = 0; k < nxbins; k++) {
2314 nentries += ((TProfile2D *)h)->GetBinEntries(h->GetBin(k+1,idect+1));
2315 if(h->GetBinContent(h->GetBin(k+1,idect+1)) != 0) {
2316 meanrelativerror += (h->GetBinError(h->GetBin(k+1,idect+1))/(TMath::Abs(h->GetBinContent(h->GetBin(k+1,idect+1)))));
2317 counter++;
2318 }
2319 }
2320 }
2321
2322 //Debug
2323 if(i > 1){
35a82746 2324 if(nentries > 0){
2325 if(!((Bool_t)nbEntries)) nbEntries = new TH1F("Number of entries","Number of entries",100,(Int_t)nentries/2,nentries*2);
bcb6fb78 2326 nbEntries->SetDirectory(0);
35a82746 2327 nbEntries->Fill(nentries);
2328 if(!((Bool_t)nbEntriesPerGroup)) nbEntriesPerGroup = new TH1F("Number of entries per group","Number of entries per group",nbins,0,nbins);
bcb6fb78 2329 nbEntriesPerGroup->SetDirectory(0);
bcb6fb78 2330 nbEntriesPerGroup->Fill(idect+0.5,nentries);
35a82746 2331 if(!((Bool_t)nbEntriesPerSp)) nbEntriesPerSp = new TProfile("Number of entries per supermodule","Number of entries per supermodule",(Int_t)(nbins/18),0,(Int_t)(nbins/18));
2332 nbEntriesPerSp->SetDirectory(0);
bcb6fb78 2333 nbEntriesPerSp->Fill((idect%((Int_t)(nbins/18)))+0.5,nentries);
170c35f1 2334 }
2335 }
bcb6fb78 2336
2337 //min amd max
2338 if(nentries > maxentries){
2339 maxentries = nentries;
2340 placemax = idect;
2341 }
2342 if(idect == 0) {
2343 minentries = nentries;
2344 }
2345 if(nentries < minentries){
2346 minentries = nentries;
2347 placemin = idect;
2348 }
2349 //nbwe
2350 if(nentries > 0) {
2351 nbwe++;
2352 meanstats += nentries;
2353 }
2354 }//calibration groups loop
2355
2356 if(nbwe > 0) meanstats /= nbwe;
2357 if(counter > 0) meanrelativerror /= counter;
2358
2359 AliInfo(Form("There are %f calibration groups with entries",nbwe));
2360 AliInfo(Form("The minimum number of entries is %f for the group %f",minentries,placemin));
2361 AliInfo(Form("The maximum number of entries is %f for the group %f",maxentries,placemax));
2362 AliInfo(Form("The mean number of entries is %f",meanstats));
2363 if((i%2) == 1) AliInfo(Form("The mean relative error is %f",meanrelativerror));
2364
2365 info[0] = nbwe;
2366 info[1] = minentries;
2367 info[2] = placemin;
2368 info[3] = maxentries;
2369 info[4] = placemax;
2370 info[5] = meanstats;
2371 info[6] = meanrelativerror;
2372
35a82746 2373 if(nbEntries && nbEntriesPerSp && nbEntriesPerGroup){
bcb6fb78 2374 gStyle->SetPalette(1);
2375 gStyle->SetOptStat(1111);
2376 gStyle->SetPadBorderMode(0);
2377 gStyle->SetCanvasColor(10);
2378 gStyle->SetPadLeftMargin(0.13);
2379 gStyle->SetPadRightMargin(0.01);
2380 TCanvas *stat = new TCanvas("stat","",50,50,600,800);
2381 stat->Divide(2,1);
2382 stat->cd(1);
2383 nbEntries->Draw("");
2384 stat->cd(2);
2385 nbEntriesPerSp->SetStats(0);
2386 nbEntriesPerSp->Draw("");
2387 TCanvas *stat1 = new TCanvas("stat1","",50,50,600,800);
2388 stat1->cd();
2389 nbEntriesPerGroup->SetStats(0);
2390 nbEntriesPerGroup->Draw("");
2391 }
2392
2393 return info;
2394
2395}
2396//____________________________________________________________________________
2397Double_t *AliTRDCalibraFillHisto::GetMeanMedianRMSNumberCH()
2398{
2399 //
2400 // Return a Int_t[4] with:
2401 // 0 Mean number of entries
2402 // 1 median of number of entries
2403 // 2 rms of number of entries
2404 // 3 number of group with entries
2405 //
2406
35a82746 2407 Double_t *stat = new Double_t[4];
bcb6fb78 2408 stat[3] = 0.0;
2409
2410 Int_t nbofgroups = CalculateTotalNumberOfBins(0);
35a82746 2411
2412 Double_t *weight = new Double_t[nbofgroups];
2413 Double_t *nonul = new Double_t[nbofgroups];
bcb6fb78 2414
2415 for(Int_t k = 0; k < nbofgroups; k++){
2416 if(fEntriesCH[k] > 0) {
2417 weight[k] = 1.0;
2418 nonul[(Int_t)stat[3]] = fEntriesCH[k];
2419 stat[3]++;
2420 }
2421 else weight[k] = 0.0;
170c35f1 2422 }
bcb6fb78 2423 stat[0] = TMath::Mean(nbofgroups,fEntriesCH,weight);
2424 stat[1] = TMath::Median(nbofgroups,fEntriesCH,weight);
2425 stat[2] = TMath::RMS((Int_t)stat[3],nonul);
2426
35a82746 2427 delete [] weight;
2428 delete [] nonul;
2429
bcb6fb78 2430 return stat;
2431
170c35f1 2432}
bcb6fb78 2433//____________________________________________________________________________
2434Double_t *AliTRDCalibraFillHisto::GetMeanMedianRMSNumberLinearFitter() const
55a288e5 2435{
2436 //
bcb6fb78 2437 // Return a Int_t[4] with:
2438 // 0 Mean number of entries
2439 // 1 median of number of entries
2440 // 2 rms of number of entries
2441 // 3 number of group with entries
55a288e5 2442 //
2443
bcb6fb78 2444 Double_t *stat = new Double_t[4];
2445 stat[3] = 0.0;
55a288e5 2446
bcb6fb78 2447 Int_t nbofgroups = 540;
2448 Double_t *weight = new Double_t[nbofgroups];
2449 Int_t *nonul = new Int_t[nbofgroups];
55a288e5 2450
bcb6fb78 2451 for(Int_t k = 0; k < nbofgroups; k++){
2452 if(fEntriesLinearFitter[k] > 0) {
2453 weight[k] = 1.0;
2454 nonul[(Int_t) stat[3]] = fEntriesLinearFitter[k];
2455 stat[3]++;
d0569428 2456 }
bcb6fb78 2457 else weight[k] = 0.0;
d0569428 2458 }
bcb6fb78 2459 stat[0] = TMath::Mean(nbofgroups,fEntriesLinearFitter,weight);
2460 stat[1] = TMath::Median(nbofgroups,fEntriesLinearFitter,weight);
2461 stat[2] = TMath::RMS((Int_t)stat[3],nonul);
55a288e5 2462
35a82746 2463 delete [] weight;
2464 delete [] nonul;
2465
bcb6fb78 2466 return stat;
170c35f1 2467
bcb6fb78 2468}
2469//////////////////////////////////////////////////////////////////////////////////////
2470// Create Histos
2471//////////////////////////////////////////////////////////////////////////////////////
2472//_____________________________________________________________________________
2473void AliTRDCalibraFillHisto::CreatePRF2d(Int_t nn)
2474{
2475 //
2476 // Create the 2D histos: here we have 2*fNgroupprf bins in tnp of 0.2 amplitude each
2477 // If fNgroupprf is zero then no binning in tnp
2478 //
d0569428 2479
bcb6fb78 2480 TString name("Nz");
2481 name += fCalibraMode->GetNz(2);
2482 name += "Nrphi";
2483 name += fCalibraMode->GetNrphi(2);
2484 name += "Ngp";
2485 name += fNgroupprf;
d0569428 2486
bcb6fb78 2487 if(fNgroupprf != 0){
2488
2489 fPRF2d = new TProfile2D("PRF2d",(const Char_t *) name
2490 ,2*fNgroupprf*fNumberBinPRF,-3.0*fNgroupprf,3.0*fNgroupprf,nn,0,nn);
2491 fPRF2d->SetYTitle("Det/pad groups");
2492 fPRF2d->SetXTitle("Position x/W [pad width units]");
2493 fPRF2d->SetZTitle("Q_{i}/Q_{total}");
2494 fPRF2d->SetStats(0);
d0569428 2495 }
bcb6fb78 2496 else{
2497 fPRF2d = new TProfile2D("PRF2d",(const Char_t *) name
2498 ,fNumberBinPRF,-1.5,1.5,nn,0,nn);
2499 fPRF2d->SetYTitle("Det/pad groups");
2500 fPRF2d->SetXTitle("Position x/W [pad width units]");
2501 fPRF2d->SetZTitle("Q_{i}/Q_{total}");
2502 fPRF2d->SetStats(0);
d0569428 2503 }
d0569428 2504
2505}
bcb6fb78 2506
2507//_____________________________________________________________________________
2508void AliTRDCalibraFillHisto::CreatePH2d(Int_t nn)
d0569428 2509{
2510 //
bcb6fb78 2511 // Create the 2D histos
d0569428 2512 //
2513
4c865c34 2514 TString name("Ver");
2515 name += fVersionVdriftUsed;
2516 name += "Subver";
2517 name += fSubVersionVdriftUsed;
ca7e6e64 2518 name += "FirstRun";
2519 name += fFirstRunVdrift;
4c865c34 2520 name += "Nz";
bcb6fb78 2521 name += fCalibraMode->GetNz(1);
2522 name += "Nrphi";
2523 name += fCalibraMode->GetNrphi(1);
d0569428 2524
bcb6fb78 2525 fPH2d = new TProfile2D("PH2d",(const Char_t *) name
2526 ,fTimeMax,-0.5/fSf,(Float_t) (fTimeMax-0.5)/fSf
2527 ,nn,0,nn);
2528 fPH2d->SetYTitle("Det/pad groups");
2529 fPH2d->SetXTitle("time [#mus]");
2530 fPH2d->SetZTitle("<PH> [a.u.]");
2531 fPH2d->SetStats(0);
d0569428 2532
bcb6fb78 2533}
2534//_____________________________________________________________________________
2535void AliTRDCalibraFillHisto::CreateCH2d(Int_t nn)
2536{
2537 //
2538 // Create the 2D histos
2539 //
d0569428 2540
4c865c34 2541 TString name("Ver");
2542 name += fVersionGainUsed;
2543 name += "Subver";
2544 name += fSubVersionGainUsed;
2545 name += "Nz";
bcb6fb78 2546 name += fCalibraMode->GetNz(0);
2547 name += "Nrphi";
2548 name += fCalibraMode->GetNrphi(0);
4c865c34 2549
bcb6fb78 2550 fCH2d = new TH2I("CH2d",(const Char_t *) name
2551 ,fNumberBinCharge,0,300,nn,0,nn);
2552 fCH2d->SetYTitle("Det/pad groups");
2553 fCH2d->SetXTitle("charge deposit [a.u]");
2554 fCH2d->SetZTitle("counts");
2555 fCH2d->SetStats(0);
2556 fCH2d->Sumw2();
d0569428 2557
bcb6fb78 2558}
2559//////////////////////////////////////////////////////////////////////////////////
2560// Set relative scale
2561/////////////////////////////////////////////////////////////////////////////////
2562//_____________________________________________________________________________
2563void AliTRDCalibraFillHisto::SetRelativeScale(Float_t RelativeScale)
2564{
2565 //
2566 // Set the factor that will divide the deposited charge
2567 // to fit in the histo range [0,300]
2568 //
2569
2570 if (RelativeScale > 0.0) {
2571 fRelativeScale = RelativeScale;
2572 }
2573 else {
2574 AliInfo("RelativeScale must be strict positif!");
d0569428 2575 }
bcb6fb78 2576
2577}
2578//////////////////////////////////////////////////////////////////////////////////
2579// Quick way to fill a histo
2580//////////////////////////////////////////////////////////////////////////////////
2581//_____________________________________________________________________
2582void AliTRDCalibraFillHisto::FillCH2d(Int_t x, Float_t y)
2583{
2584 //
2585 // FillCH2d: Marian style
2586 //
2587
2588 //skip simply the value out of range
2589 if((y>=300.0) || (y<0.0)) return;
2590
2591 //Calcul the y place
2592 Int_t yplace = (Int_t) (fNumberBinCharge*y/300.0)+1;
2593 Int_t place = (fNumberBinCharge+2)*(x+1)+yplace;
d0569428 2594
bcb6fb78 2595 //Fill
2596 fCH2d->GetArray()[place]++;
2597
d0569428 2598}
bcb6fb78 2599
2600//////////////////////////////////////////////////////////////////////////////////
2601// Geometrical functions
2602///////////////////////////////////////////////////////////////////////////////////
d0569428 2603//_____________________________________________________________________________
053767a4 2604Int_t AliTRDCalibraFillHisto::GetLayer(Int_t d) const
d0569428 2605{
2606 //
053767a4 2607 // Reconstruct the layer number from the detector number
d0569428 2608 //
2609
2610 return ((Int_t) (d % 6));
2611
2612}
2613
2614//_____________________________________________________________________________
053767a4 2615Int_t AliTRDCalibraFillHisto::GetStack(Int_t d) const
d0569428 2616{
2617 //
053767a4 2618 // Reconstruct the stack number from the detector number
d0569428 2619 //
053767a4 2620 const Int_t kNlayer = 6;
d0569428 2621
053767a4 2622 return ((Int_t) (d % 30) / kNlayer);
d0569428 2623
2624}
2625
2626//_____________________________________________________________________________
2627Int_t AliTRDCalibraFillHisto::GetSector(Int_t d) const
2628{
2629 //
2630 // Reconstruct the sector number from the detector number
2631 //
2632 Int_t fg = 30;
2633
2634 return ((Int_t) (d / fg));
2635
2636}
bcb6fb78 2637///////////////////////////////////////////////////////////////////////////////////
2638// Getter functions for DAQ of the CH2d and the PH2d
2639//////////////////////////////////////////////////////////////////////////////////
d0569428 2640//_____________________________________________________________________
2641TProfile2D* AliTRDCalibraFillHisto::GetPH2d(Int_t nbtimebin, Float_t samplefrequency)
2642{
2643 //
2644 // return pointer to fPH2d TProfile2D
2645 // create a new TProfile2D if it doesn't exist allready
2646 //
2647 if ( fPH2d )
2648 return fPH2d;
2649
2650 // Some parameters
2651 fTimeMax = nbtimebin;
2652 fSf = samplefrequency;
2653
170c35f1 2654 CreatePH2d(540);
2655
2656 return fPH2d;
2657}
2658//_____________________________________________________________________
bcb6fb78 2659TH2I* AliTRDCalibraFillHisto::GetCH2d()
2660{
2661 //
2662 // return pointer to fCH2d TH2I
2663 // create a new TH2I if it doesn't exist allready
2664 //
2665 if ( fCH2d )
2666 return fCH2d;
2667
2668 CreateCH2d(540);
2669
2670 return fCH2d;
2671}
2672////////////////////////////////////////////////////////////////////////////////////////////
2673// Drift velocity calibration
2674///////////////////////////////////////////////////////////////////////////////////////////
2675//_____________________________________________________________________
170c35f1 2676TLinearFitter* AliTRDCalibraFillHisto::GetLinearFitter(Int_t detector, Bool_t force)
2677{
2678 //
2679 // return pointer to TLinearFitter Calibration
2680 // if force is true create a new TLinearFitter if it doesn't exist allready
2681 //
170c35f1 2682
d0569428 2683 if ((!force) || (fLinearFitterArray.UncheckedAt(detector))){
2684 return (TLinearFitter*)fLinearFitterArray.UncheckedAt(detector);
2685 }
2686
2687 // if we are forced and TLinearFitter doesn't yet exist create it
170c35f1 2688
d0569428 2689 // new TLinearFitter
2690 TLinearFitter *linearfitter = new TLinearFitter(2,"pol1");
2691 fLinearFitterArray.AddAt(linearfitter,detector);
2692 return linearfitter;
170c35f1 2693}
170c35f1 2694
3a0f6479 2695//____________________________________________________________________________
2696void AliTRDCalibraFillHisto::AnalyseLinearFitter()
2697{
2698 //
2699 // Analyse array of linear fitter because can not be written
2700 // Store two arrays: one with the param the other one with the error param + number of entries
2701 //
2702
2703 for(Int_t k = 0; k < 540; k++){
2704 TLinearFitter *linearfitter = GetLinearFitter(k);
2705 if((linearfitter!=0) && (fEntriesLinearFitter[k]>10)){
2706 TVectorD *par = new TVectorD(2);
2707 TVectorD pare = TVectorD(2);
2708 TVectorD *parE = new TVectorD(3);
c1105918 2709 if((linearfitter->EvalRobust(0.8)==0)) {
2710 //linearfitter->Eval();
2711 linearfitter->GetParameters(*par);
2712 //linearfitter->GetErrors(pare);
2713 //Float_t ppointError = TMath::Sqrt(TMath::Abs(linearfitter->GetChisquare())/fEntriesLinearFitter[k]);
2714 //(*parE)[0] = pare[0]*ppointError;
2715 //(*parE)[1] = pare[1]*ppointError;
2716
2717 (*parE)[0] = 0.0;
2718 (*parE)[1] = 0.0;
2719 (*parE)[2] = (Double_t) fEntriesLinearFitter[k];
2720 ((TObjArray *)fLinearVdriftFit->GetPArray())->AddAt(par,k);
2721 ((TObjArray *)fLinearVdriftFit->GetEArray())->AddAt(parE,k);
2722 }
3a0f6479 2723 }
2724 }
1f3c89d8 2725}
1785640c 2726
a2a4ec8e 2727
35a82746 2728