Remove kX0shift5 since all planes are now equal
[u/mrichter/AliRoot.git] / TRD / AliTRDCalibraFillHisto.cxx
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  **************************************************************************/
15
16 /* $Id$ */
17
18 /////////////////////////////////////////////////////////////////////////////////
19 // 
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.
25 // The user has to choose with the functions SetNz and SetNrphi the precision of the
26 // calibration (see AliTRDCalibraMode). 
27 // 2D Histograms (Histo2d) or vectors (Vector2d), then converted in Trees, will be filled
28 // from RAW DATA in a run or from reconstructed TRD tracks during the offline tracking 
29 // in the function "FollowBackProlongation" (AliTRDtracker)
30 // Per default the functions to fill are off.                                   
31 //                        
32 // Author:
33 //   R. Bailhache (R.Bailhache@gsi.de)
34 //                            
35 //////////////////////////////////////////////////////////////////////////////////////
36
37 #include <TTree.h>
38 #include <TProfile2D.h>
39 #include <TProfile.h>
40 #include <TFile.h>
41 #include <TChain.h>
42 #include <TStyle.h>
43 #include <TCanvas.h>
44 #include <TGraphErrors.h>
45 #include <TObjArray.h>
46 #include <TH1F.h>
47 #include <TH2I.h>
48 #include <TH2.h>
49 #include <TStopwatch.h>
50 #include <TMath.h>
51 #include <TDirectory.h>
52 #include <TROOT.h>
53
54 #include "AliLog.h"
55 #include "AliCDBManager.h"
56
57 #include "AliTRDCalibraFillHisto.h"
58 #include "AliTRDCalibraMode.h"
59 #include "AliTRDCalibraVector.h"
60 #include "AliTRDcalibDB.h"
61 #include "AliTRDCommonParam.h"
62 #include "AliTRDmcmTracklet.h"
63 #include "AliTRDpadPlane.h"
64 #include "AliTRDcluster.h"
65 #include "AliTRDtrack.h"
66
67
68 ClassImp(AliTRDCalibraFillHisto)
69
70 AliTRDCalibraFillHisto* AliTRDCalibraFillHisto::fgInstance = 0;
71 Bool_t AliTRDCalibraFillHisto::fgTerminated = kFALSE;
72
73 //_____________singleton implementation_________________________________________________
74 AliTRDCalibraFillHisto *AliTRDCalibraFillHisto::Instance()
75 {
76   //
77   // Singleton implementation
78   //
79
80   if (fgTerminated != kFALSE) {
81     return 0;
82   }
83
84   if (fgInstance == 0) {
85     fgInstance = new AliTRDCalibraFillHisto();
86   }
87
88   return fgInstance;
89
90 }
91
92 //______________________________________________________________________________________
93 void AliTRDCalibraFillHisto::Terminate()
94 {
95   //
96   // Singleton implementation
97   // Deletes the instance of this class
98   //
99
100   fgTerminated = kTRUE;
101
102   if (fgInstance != 0) {
103     delete fgInstance;
104     fgInstance = 0;
105   }
106
107 }
108
109 //______________________________________________________________________________________
110 AliTRDCalibraFillHisto::AliTRDCalibraFillHisto()
111   :TObject()
112   ,fMITracking(kFALSE)
113   ,fMcmTracking(kFALSE)
114   ,fMcmCorrectAngle(kFALSE)
115   ,fCH2dOn(kFALSE)
116   ,fPH2dOn(kFALSE)
117   ,fPRF2dOn(kFALSE)
118   ,fHisto2d(kFALSE)
119   ,fVector2d(kFALSE)
120   ,fRelativeScale(0)
121   ,fCountRelativeScale(0)
122   ,fRelativeScaleAuto(kFALSE)
123   ,fThresholdClusterPRF1(0.0)
124   ,fThresholdClusterPRF2(0.0)
125   ,fCenterOfflineCluster(kFALSE)
126   ,fWriteName(0)
127   ,fCalibraMode(0)
128   ,fDetectorAliTRDtrack(kFALSE)
129   ,fChamberAliTRDtrack(-1)
130   ,fDetectorPreviousTrack(-1)
131   ,fGoodTrack(kTRUE)
132   ,fAmpTotal(0x0)
133   ,fPHPlace(0x0)
134   ,fPHValue(0x0)
135   ,fNumberClusters(0)
136   ,fProcent(0.0)
137   ,fDifference(0)
138   ,fNumberTrack(0)
139   ,fTimeMax(0)
140   ,fSf(0.0)
141   ,fNumberBinCharge(0)
142   ,fNumberBinPRF(0)
143   ,fCalibraVector(0)
144   ,fPH2d(0x0)
145   ,fPRF2d(0x0)
146   ,fCH2d(0x0)
147 {
148   //
149   // Default constructor
150   //
151
152   fCalibraMode = new AliTRDCalibraMode();
153
154   // Write
155   for (Int_t i = 0; i < 3; i++) {
156     fWrite[i]     = kFALSE;
157   }
158
159   // Init
160   Init();
161   
162 }
163
164 //______________________________________________________________________________________
165 AliTRDCalibraFillHisto::AliTRDCalibraFillHisto(const AliTRDCalibraFillHisto &c)
166   :TObject(c)
167   ,fMITracking(kFALSE)
168   ,fMcmTracking(kFALSE)
169   ,fMcmCorrectAngle(kFALSE)
170   ,fCH2dOn(kFALSE)
171   ,fPH2dOn(kFALSE)
172   ,fPRF2dOn(kFALSE)
173   ,fHisto2d(kFALSE)
174   ,fVector2d(kFALSE)
175   ,fRelativeScale(0)
176   ,fCountRelativeScale(0)
177   ,fRelativeScaleAuto(kFALSE)
178   ,fThresholdClusterPRF1(0.0)
179   ,fThresholdClusterPRF2(0.0)
180   ,fCenterOfflineCluster(kFALSE)
181   ,fWriteName(0)
182   ,fCalibraMode(0)
183   ,fDetectorAliTRDtrack(kFALSE)
184   ,fChamberAliTRDtrack(-1)
185   ,fDetectorPreviousTrack(-1)
186   ,fGoodTrack(kTRUE)
187   ,fAmpTotal(0x0)
188   ,fPHPlace(0x0)
189   ,fPHValue(0x0)
190   ,fNumberClusters(0)
191   ,fProcent(0.0)
192   ,fDifference(0)
193   ,fNumberTrack(0)
194   ,fTimeMax(0)
195   ,fSf(0.0)
196   ,fNumberBinCharge(0)
197   ,fNumberBinPRF(0)
198   ,fCalibraVector(0)
199   ,fPH2d(0x0)
200   ,fPRF2d(0x0)
201   ,fCH2d(0x0) 
202 {
203   //
204   // Copy constructor
205   //
206
207 }
208
209 //____________________________________________________________________________________
210 AliTRDCalibraFillHisto::~AliTRDCalibraFillHisto()
211 {
212   //
213   // AliTRDCalibraFillHisto destructor
214   //
215
216   ClearHistos();
217   
218 }
219
220 //_____________________________________________________________________________
221 void AliTRDCalibraFillHisto::Destroy() 
222 {
223   //
224   // Delete instance 
225   //
226
227   if (fgInstance) {
228     delete fgInstance;
229     fgInstance = 0x0;
230   }
231
232 }
233
234 //_____________________________________________________________________________
235 void AliTRDCalibraFillHisto::ClearHistos() 
236 {
237   //
238   // Delete the histos
239   //
240
241   if (fPH2d) {
242     delete fPH2d;
243     fPH2d  = 0x0;
244   }
245   if (fCH2d) {
246     delete fCH2d;
247     fCH2d  = 0x0;
248   }
249   if (fPRF2d) {
250     delete fPRF2d;
251     fPRF2d = 0x0;
252   }
253
254 }
255
256 //_____________________________________________________________________________
257 void AliTRDCalibraFillHisto::Init() 
258 {
259   //
260   // Init some default values
261   //
262
263   // How to fill the 2D
264   fThresholdClusterPRF1 = 2.0;
265   fThresholdClusterPRF2 = 15.0;
266   
267   // Store the Info
268   fNumberBinCharge      = 100;
269   fNumberBinPRF         = 40;
270   
271   // Write
272   fWriteName            = "TRD.calibration.root";
273   
274   // Internal variables
275   
276   // Fill the 2D histos in the offline tracking
277   fDetectorPreviousTrack = -1;
278   fChamberAliTRDtrack    = -1;
279   fGoodTrack             = kTRUE;
280
281   fProcent               = 6.0;
282   fDifference            = 17;
283   fNumberClusters        = 18;
284   fNumberTrack           = 0;
285   fNumberUsedCh[0]       = 0;
286   fNumberUsedCh[1]       = 0;
287   fNumberUsedPh[0]       = 0;
288   fNumberUsedPh[1]       = 0;
289  
290 }
291
292 //____________Functions for initialising the AliTRDCalibraFillHisto in the code_________
293 Bool_t AliTRDCalibraFillHisto::Init2Dhistos()
294 {
295   //
296   // For the offline tracking
297   // This function will be called in the function AliReconstruction::Run() 
298   // Init the calibration mode (Nz, Nrphi), the 2D histograms if fHisto2d = kTRUE, 
299   //
300
301   // DB Setting
302   // Get cal
303   AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
304   if (!cal) {
305     AliInfo("Could not get calibDB");
306     return kFALSE;
307   }
308   AliTRDCommonParam *parCom = AliTRDCommonParam::Instance();
309   if (!parCom) {
310     AliInfo("Could not get CommonParam");
311     return kFALSE;
312   }
313
314   // Some parameters
315   fTimeMax = cal->GetNumberOfTimeBins();
316   fSf      = parCom->GetSamplingFrequency();
317   if (fRelativeScaleAuto) {
318     fRelativeScale = 0;
319   }
320   else {
321     fRelativeScale = 20;
322   }
323
324   //If vector method On initialised all the stuff
325   if(fVector2d){
326     fCalibraVector = new AliTRDCalibraVector();
327   }
328
329
330   // Create the 2D histos corresponding to the pad groupCalibration mode
331   if (fCH2dOn) {
332
333     AliInfo(Form("The pad calibration mode for the relative gain calibration: Nz %d, and Nrphi %d"
334                 ,fCalibraMode->GetNz(0)
335                 ,fCalibraMode->GetNrphi(0)));
336     
337     // Calcul the number of Xbins
338     Int_t Ntotal0 = 0;
339     fCalibraMode->ModePadCalibration(2,0);
340     fCalibraMode->ModePadFragmentation(0,2,0,0);
341     fCalibraMode->SetDetChamb2(0);
342     Ntotal0 += 6 * 18 * fCalibraMode->GetDetChamb2(0);
343     fCalibraMode->ModePadCalibration(0,0);
344     fCalibraMode->ModePadFragmentation(0,0,0,0);
345     fCalibraMode->SetDetChamb0(0);
346     Ntotal0 += 6 * 4 * 18 * fCalibraMode->GetDetChamb0(0);
347     AliInfo(Form("Total number of Xbins: %d",Ntotal0));
348
349     // Create the 2D histo
350     if (fHisto2d) {
351       CreateCH2d(Ntotal0);
352     }
353     if (fVector2d) {
354       fCalibraVector->SetNumberBinCharge(fNumberBinCharge);
355     }
356
357     // Variable
358     fAmpTotal = new Float_t[TMath::Max(fCalibraMode->GetDetChamb2(0),fCalibraMode->GetDetChamb0(0))];
359     for (Int_t k = 0; k < TMath::Max(fCalibraMode->GetDetChamb2(0),fCalibraMode->GetDetChamb0(0)); k++) {
360       fAmpTotal[k] = 0.0;
361     } 
362
363   }
364
365   if (fPH2dOn) {
366
367     AliInfo(Form("The pad calibration mode for the drift velocity calibration: Nz %d, and Nrphi %d"
368                 ,fCalibraMode->GetNz(1)
369                 ,fCalibraMode->GetNrphi(1)));
370     
371     // Calcul the number of Xbins
372     Int_t Ntotal1 = 0;
373     fCalibraMode->ModePadCalibration(2,1);
374     fCalibraMode->ModePadFragmentation(0,2,0,1);
375     fCalibraMode->SetDetChamb2(1);
376     Ntotal1 += 6 * 18 * fCalibraMode->GetDetChamb2(1);
377     fCalibraMode->ModePadCalibration(0,1);
378     fCalibraMode->ModePadFragmentation(0,0,0,1);
379     fCalibraMode->SetDetChamb0(1);
380     Ntotal1 += 6 * 4 * 18 * fCalibraMode->GetDetChamb0(1);
381     AliInfo(Form("Total number of Xbins: %d",Ntotal1));
382
383     // Create the 2D histo
384     if (fHisto2d) {
385       CreatePH2d(Ntotal1);
386     }
387     if (fVector2d) {
388       fCalibraVector->SetTimeMax(fTimeMax);
389     }
390    
391     // Variable
392     fPHPlace = new Short_t[fTimeMax];
393     for (Int_t k = 0; k < fTimeMax; k++) {
394       fPHPlace[k] = -1;
395     } 
396     fPHValue = new Float_t[fTimeMax];
397     for (Int_t k = 0; k < fTimeMax; k++) {
398       fPHValue[k] = 0.0;
399     }
400
401   }
402
403   if (fPRF2dOn) {
404
405     AliInfo(Form("The pad calibration mode for the PRF calibration: Nz %d, and Nrphi %d"
406                 ,fCalibraMode->GetNz(2)
407                 ,fCalibraMode->GetNrphi(2)));
408     
409     // Calcul the number of Xbins
410     Int_t Ntotal2 = 0;
411     fCalibraMode->ModePadCalibration(2,2);
412     fCalibraMode->ModePadFragmentation(0,2,0,2);
413     fCalibraMode->SetDetChamb2(2);
414     Ntotal2 += 6 * 18 * fCalibraMode->GetDetChamb2(2);
415     fCalibraMode->ModePadCalibration(0,2);
416     fCalibraMode->ModePadFragmentation(0,0,0,2);
417     fCalibraMode->SetDetChamb0(2);
418     Ntotal2 += 6 * 4 * 18 * fCalibraMode->GetDetChamb0(2);
419     AliInfo(Form("Total number of Xbins: %d",Ntotal2));
420
421     // Create the 2D histo
422     if (fHisto2d) {
423       CreatePRF2d(Ntotal2);
424     }
425     if (fVector2d) {
426       fCalibraVector->SetNumberBinPRF(fNumberBinPRF);
427     }
428   
429   }
430
431   return kTRUE;
432
433 }
434
435 //____________Functions for filling the histos in the code_____________________
436
437 //____________Offine tracking in the AliTRDtracker_____________________________
438 Bool_t AliTRDCalibraFillHisto::ResetTrack()
439 {
440   //
441   // For the offline tracking
442   // This function will be called in the function
443   // AliTRDtracker::FollowBackPropagation() at the beginning 
444   // Reset the parameter to know we have a new TRD track
445   //
446   
447   fDetectorAliTRDtrack = kFALSE;
448   return kTRUE;
449
450 }
451
452 //____________Offline tracking in the AliTRDtracker____________________________
453 Bool_t AliTRDCalibraFillHisto::UpdateHistograms(AliTRDcluster *cl, AliTRDtrack *t)
454 {
455   //
456   // For the offline tracking
457   // This function will be called in the function
458   // AliTRDtracker::FollowBackPropagation() in the loop over the clusters
459   // of TRD tracks 
460   // Fill the 2D histos or the vectors with the info of the clusters at
461   // the end of a detectors if the track is "good"
462   //
463
464   // Get the parameter object
465   AliTRDCommonParam *parCom = AliTRDCommonParam::Instance();
466   if (!parCom) {
467     AliInfo("Could not get CommonParam");
468     return kFALSE;
469   }
470
471   // Get the parameter object
472   AliTRDcalibDB     *cal    = AliTRDcalibDB::Instance();
473   if (!cal) {
474     AliInfo("Could not get calibDB");
475     return kFALSE;
476   }
477  
478   // Localisation of the detector
479   Int_t detector = cl->GetDetector();
480   Int_t chamber  = GetChamber(detector);
481   Int_t plane    = GetPlane(detector);
482
483   // Fill the infos for the previous clusters if not the same
484   // detector anymore or if not the same track
485   if (((detector != fDetectorPreviousTrack) || (!fDetectorAliTRDtrack)) && 
486       (fDetectorPreviousTrack != -1)) {
487     
488     fNumberTrack++;   
489     
490     // If the same track, then look if the previous detector is in
491     // the same plane, if yes: not a good track
492     if (fDetectorAliTRDtrack && 
493         (GetPlane(detector) <= GetPlane(fDetectorPreviousTrack))) {
494       fGoodTrack = kFALSE;
495     }
496
497     // Fill only if the track doesn't touch a masked pad or doesn't
498     // appear in the middle (fGoodTrack)
499     if (fGoodTrack) {
500
501       // Gain calibration
502       if (fCH2dOn) {
503         FillTheInfoOfTheTrackCH();
504       }
505       
506       // PH calibration
507       if (fPH2dOn) {
508         FillTheInfoOfTheTrackPH();    
509       }
510       
511     } // if a good track
512     
513     ResetfVariables();
514     
515   } // Fill at the end the charge
516   
517   // Calcul the position of the detector
518   if (detector != fDetectorPreviousTrack) {
519     LocalisationDetectorXbins(detector);
520   }
521
522   // Reset the good track for the PRF
523   Bool_t good = kTRUE;
524   
525   // Localisation of the cluster
526   Double_t pos[3] = { 0.0, 0.0, 0.0 };
527   pos[0] = cl->GetX();
528   pos[1] = cl->GetY();
529   pos[2] = cl->GetZ();
530   Int_t    time   = cl->GetLocalTimeBin();
531   
532   // Reset the detector
533   fDetectorPreviousTrack = detector;
534   fDetectorAliTRDtrack   = kTRUE;
535   
536   // Position of the cluster
537   AliTRDpadPlane *padplane = parCom->GetPadPlane(plane,chamber);
538   Int_t    row        = padplane->GetPadRowNumber(pos[2]);
539   Double_t offsetz    = padplane->GetPadRowOffset(row,pos[2]);
540   Double_t offsettilt = padplane->GetTiltOffset(offsetz);
541   Int_t    col        = padplane->GetPadColNumber(pos[1]+offsettilt,offsetz);
542   
543   // See if we are not near a masked pad
544   if (!IsPadOn(detector,col,row)) {
545     good       = kFALSE;
546     fGoodTrack = kFALSE;
547   }
548
549   if (col > 0) {
550     if (!IsPadOn(detector,col-1,row)) {
551       fGoodTrack = kFALSE;
552       good       = kFALSE;
553     }
554   }
555
556   if (col < 143) {
557     if (!IsPadOn(detector,col+1,row)) {
558       fGoodTrack = kFALSE;
559       good       = kFALSE;
560     }
561   }
562
563   // Row of the cluster and position in the pad groups
564   Int_t posr[3] = { 0, 0, 0 };
565   if ((fCH2dOn)  && (fCalibraMode->GetNnZ(0) != 0)) {
566     posr[0] = (Int_t) row / fCalibraMode->GetNnZ(0);
567   }
568   if ((fPH2dOn)  && (fCalibraMode->GetNnZ(1) != 0)) {
569     posr[1] = (Int_t) row / fCalibraMode->GetNnZ(1);
570   }
571   if ((fPRF2dOn) && (fCalibraMode->GetNnZ(2) != 0)) {
572     posr[2] = (Int_t) row / fCalibraMode->GetNnZ(2);
573   }  
574       
575   // Col of the cluster and position in the pad groups
576   Int_t posc[3] = { 0, 0, 0 };
577   if ((fCH2dOn)  && (fCalibraMode->GetNnRphi(0) != 0)) {
578     posc[0] = (Int_t) col / fCalibraMode->GetNnRphi(0);
579   }
580   if ((fPH2dOn)  && (fCalibraMode->GetNnRphi(1) != 0)) {
581     posc[1] = (Int_t) col / fCalibraMode->GetNnRphi(1);
582   }
583   if ((fPRF2dOn) && (fCalibraMode->GetNnRphi(2) != 0)) {
584     posc[2] = (Int_t) col / fCalibraMode->GetNnRphi(2);
585   }
586
587   // Charge in the cluster
588   // For the moment take the abs
589   Float_t  q        = TMath::Abs(cl->GetQ());
590   Short_t  *signals = cl->GetSignals();
591  
592   // Correction due to the track angle
593   Float_t correction    = 1.0;
594   Float_t normalisation = 6.67;
595   if ((q >0) && (t->GetNdedx() > 0)) {
596     correction = t->GetClusterdQdl((t->GetNdedx() - 1)) / (normalisation);
597   }
598
599   // Fill the fAmpTotal with the charge
600   if (fCH2dOn) {
601     fAmpTotal[(Int_t) (posc[0]*fCalibraMode->GetNfragZ(0)+posr[0])] += correction;
602   }
603
604   // Fill the fPHPlace and value
605   if (fPH2dOn) {
606     fPHPlace[time] = posc[1]*fCalibraMode->GetNfragZ(1)+posr[1];
607     fPHValue[time] = correction;
608   }
609
610   // Fill direct the PRF
611   if ((fPRF2dOn) && (good)) {
612
613     Float_t yminus  = 0.0;
614     Float_t xcenter = 0.0;
615     Float_t ycenter = 0.0;
616     Float_t ymax    = 0.0;
617     Bool_t  echec   = kFALSE;
618     
619     if ((cl->From3pad()) && (!cl->IsUsed())) { 
620          
621       // Center 3 balanced and cut on the cluster shape
622       if ((((Float_t) signals[3]) > fThresholdClusterPRF2) && 
623           (((Float_t) signals[2]) > fThresholdClusterPRF2) && 
624           (((Float_t) signals[4]) > fThresholdClusterPRF2) && 
625           (((Float_t) signals[1]) < fThresholdClusterPRF1) && 
626           (((Float_t) signals[5]) < fThresholdClusterPRF1) && 
627           ((((Float_t) signals[2])*((Float_t) signals[4])/(((Float_t) signals[3])*((Float_t) signals[3]))) < 0.06)) {
628
629
630         //First calculate the position of the cluster and the y
631         //echec enables to repair cases where it fails
632         //
633         // Col correspond to signals[3]
634         if (fCenterOfflineCluster) {
635           xcenter = cl->GetCenter();
636         }
637         else {
638           // Security if the denomiateur is 0 
639           if ((((Float_t) (((Float_t) signals[3]) * ((Float_t) signals[3]))) / 
640                            ((Float_t) (((Float_t) signals[2]) * ((Float_t) signals[4])))) != 1.0) {
641             xcenter = 0.5 * (TMath::Log((Float_t) (((Float_t) signals[4]) / ((Float_t) signals[2]))))
642                           / (TMath::Log(((Float_t) (((Float_t) signals[3]) * ((Float_t) signals[3]))) 
643                                       / ((Float_t) (((Float_t) signals[2]) * ((Float_t) signals[4])))));
644           }
645           else {
646             echec = kTRUE;
647           }
648         }
649         //after having calculating the position calculate the y
650         if (TMath::Abs(xcenter) < 0.5) {
651           ycenter = (Float_t) (((Float_t) signals[3]) 
652                             / (((Float_t) signals[2]) + ((Float_t) signals[3]) + (((Float_t) signals[4]))));
653           yminus  = (Float_t) (((Float_t) signals[2]) 
654                             / (((Float_t) signals[2]) + ((Float_t) signals[3]) + (((Float_t) signals[4]))));
655           ymax    = (Float_t) (((Float_t) signals[4]) 
656                             / (((Float_t) signals[2]) + ((Float_t) signals[3]) + (((Float_t) signals[4]))));
657           //If the charge of the cluster is too far away from the corrected one cut
658           if ((TMath::Abs(((Float_t) signals[2]) + ((Float_t) signals[3]) + (((Float_t) signals[4])) - q) > 10.0)) {
659             echec = kTRUE;
660           }
661         }
662         else {
663           echec = kTRUE;
664         }
665       
666         //Then Fill the histo if no echec
667         //
668         // Fill only if it is in the drift region!
669         if ((((Float_t) (((Float_t) time) / fSf)) > 0.3) && (!echec)) {
670           if (fHisto2d) {
671             fPRF2d->Fill((fCalibraMode->GetXbins(2)+posc[2]*fCalibraMode->GetNfragZ(2)+posr[2]+0.5),xcenter,ycenter);
672             fPRF2d->Fill((fCalibraMode->GetXbins(2)+posc[2]*fCalibraMode->GetNfragZ(2)+posr[2]+0.5),-(xcenter+1.0),yminus);
673             fPRF2d->Fill((fCalibraMode->GetXbins(2)+posc[2]*fCalibraMode->GetNfragZ(2)+posr[2]+0.5),1.0-xcenter,ymax);
674           }
675           if (fVector2d) {
676             fCalibraVector->UpdateVectorPRF(fCalibraMode->GetXbins(2)+posc[2]*fCalibraMode->GetNfragZ(2)+posr[2],xcenter,ycenter);
677             fCalibraVector->UpdateVectorPRF(fCalibraMode->GetXbins(2)+posc[2]*fCalibraMode->GetNfragZ(2)+posr[2],-(xcenter+1.0),yminus);
678             fCalibraVector->UpdateVectorPRF(fCalibraMode->GetXbins(2)+posc[2]*fCalibraMode->GetNfragZ(2)+posr[2],1.0-xcenter,ymax);
679           }
680         } // If in the drift region
681       } // center 3 balanced and cut on the cluster shape
682     } // Cluster isole
683   } // PRF2dOn  
684   
685   return kTRUE;
686   
687 }
688
689 //____________Online trackling in AliTRDtrigger________________________________
690 Bool_t AliTRDCalibraFillHisto::UpdateHistogramcm(AliTRDmcmTracklet *trk)
691 {
692   //
693   // For the tracking
694   // This function will be called in the function AliTRDtrigger::TestTracklet
695   // before applying the pt cut on the tracklets 
696   // Fill the infos for the tracklets fTrkTest if the tracklets is "good"
697   //
698   
699   // Localisation of the Xbins involved
700   Int_t idect = trk->GetDetector();
701   LocalisationDetectorXbins(idect);
702
703   // Get the parameter object
704   AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
705   if (!cal) {
706     AliInfo("Could not get calibDB");
707     return kFALSE;
708   }
709    
710   // Reset
711   ResetfVariables();
712  
713   // Row of the tracklet and position in the pad groups
714   Int_t row     = trk->GetRow();
715   Int_t posr[3] = { 0, 0, 0 };
716   if ((fCH2dOn)  && (fCalibraMode->GetNnZ(0) != 0)) {
717     posr[0] = (Int_t) row / fCalibraMode->GetNnZ(0);
718   }
719   if ((fPH2dOn)  && (fCalibraMode->GetNnZ(1) != 0)) {
720     posr[1] = (Int_t) row / fCalibraMode->GetNnZ(1);
721   }
722   if ((fPRF2dOn) && (fCalibraMode->GetNnZ(2) != 0)) {
723     posr[2] = (Int_t) row / fCalibraMode->GetNnZ(2);
724   }
725  
726   // Eventuelle correction due to track angle in z direction
727   Float_t correction = 1.0;
728   if (fMcmCorrectAngle) {
729     Float_t z = trk->GetRowz();
730     Float_t r = trk->GetTime0();
731     correction = r / TMath::Sqrt((r*r+z*z));
732   }
733
734   // Boucle sur les clusters
735   // Condition on number of cluster: don't come from the middle of the detector
736   if (trk->GetNclusters() >= fNumberClusters) {
737
738     for (Int_t icl = 0; icl < trk->GetNclusters(); icl++) {
739
740       Float_t amp[3] = { 0.0, 0.0, 0.0 };
741       Int_t   time   = trk->GetClusterTime(icl);
742       Int_t   col    = trk->GetClusterCol(icl);
743             
744       amp[0] = trk->GetClusterADC(icl)[0] * correction;
745       amp[1] = trk->GetClusterADC(icl)[1] * correction;
746       amp[2] = trk->GetClusterADC(icl)[2] * correction;
747
748       
749       if ((amp[0] < 0.0) || 
750           (amp[1] < 0.0) || 
751           (amp[2] < 0.0)) {
752         continue;
753       }
754
755       // Col of cluster and position in the pad groups
756       Int_t posc[3] = { 0, 0, 0 };
757       if ((fCH2dOn)  && (fCalibraMode->GetNnRphi(0) != 0)) {
758         posc[0] = (Int_t) col / fCalibraMode->GetNnRphi(0);
759       }
760       if ((fPH2dOn)  && (fCalibraMode->GetNnRphi(1) != 0)) {
761         posc[1] = (Int_t) col / fCalibraMode->GetNnRphi(1);
762       }
763       if ((fPRF2dOn) && (fCalibraMode->GetNnRphi(2) != 0)) {
764         posc[2] = (Int_t) col / fCalibraMode->GetNnRphi(2);
765       }
766
767       // See if we are not near a masked pad
768       Bool_t good = kTRUE;
769       if (!IsPadOn(idect,col,row)) {
770         fGoodTrack = kFALSE;
771         good       = kFALSE;
772       }
773
774       if (col >   0) {
775         if (!IsPadOn(idect,col-1,row)) {
776           fGoodTrack = kFALSE;
777           good       = kFALSE;
778         }
779       }
780       
781       if (col < 143) {
782         if (!IsPadOn(idect,col+1,row)) {
783           fGoodTrack = kFALSE;
784           good       = kFALSE;
785         }
786       }
787
788       // Total spectrum
789       if (fPH2dOn) {
790         fPHPlace[time] = posc[1] * fCalibraMode->GetNfragZ(1) + posr[1];
791       }
792
793       if (fCH2dOn) {
794         fAmpTotal[(Int_t) (posc[0]*fCalibraMode->GetNfragZ(0)+posr[0])] += (Float_t) (amp[0]+amp[1]+amp[2]);
795       }
796       if (fPH2dOn) {
797         fPHValue[time] = (Float_t) (amp[0]+amp[1]+amp[2]);
798       }
799       
800             
801       // Fill PRF direct
802       if (fPRF2dOn && good) {
803         
804         if ((amp[0] > fThresholdClusterPRF2) && 
805             (amp[1] > fThresholdClusterPRF2) && 
806             (amp[2] > fThresholdClusterPRF2) && 
807             ((amp[0]*amp[2]/(amp[1]*amp[1])) < 0.06)) {
808         
809           // Security of the denomiateur is 0
810           if ((((Float_t) (((Float_t) amp[1]) * ((Float_t) amp[1]))) 
811              / ((Float_t) (((Float_t) amp[0]) * ((Float_t) amp[2])))) != 1.0) {
812             Float_t xcenter = 0.5 * (TMath::Log(amp[2] / amp[0]))
813                                   / (TMath::Log((amp[1]*amp[1]) / (amp[0]*amp[2])));
814             Float_t ycenter = amp[1] / (amp[0] + amp[1] + amp[2]);
815
816             if (TMath::Abs(xcenter) < 0.5) {
817               Float_t yminus = amp[0] / (amp[0]+amp[1]+amp[2]);
818               Float_t ymax   = amp[2] / (amp[0]+amp[1]+amp[2]);
819               // Fill only if it is in the drift region!
820               if (((Float_t) time / fSf) > 0.3) {
821                 if (fHisto2d) {
822                   fPRF2d->Fill((fCalibraMode->GetXbins(2)+posc[2]*fCalibraMode->GetNfragZ(2)+posr[2]+0.5),xcenter,ycenter);
823                   fPRF2d->Fill((fCalibraMode->GetXbins(2)+posc[2]*fCalibraMode->GetNfragZ(2)+posr[2]+0.5),-(xcenter+1.0),yminus);
824                   fPRF2d->Fill((fCalibraMode->GetXbins(2)+posc[2]*fCalibraMode->GetNfragZ(2)+posr[2]+0.5),(1.0-xcenter),ymax);
825                 }
826                 if (fVector2d) {
827                   fCalibraVector->UpdateVectorPRF((fCalibraMode->GetXbins(2)+posc[2]*fCalibraMode->GetNfragZ(2)+posr[2]),xcenter,ycenter);
828                   fCalibraVector->UpdateVectorPRF(fCalibraMode->GetXbins(2)+posc[2]*fCalibraMode->GetNfragZ(2)+posr[2],-(xcenter+1.0),yminus);
829                   fCalibraVector->UpdateVectorPRF(fCalibraMode->GetXbins(2)+posc[2]*fCalibraMode->GetNfragZ(2)+posr[2],(1.0-xcenter),ymax);
830                 }
831               }//in the drift region 
832             }//in the middle
833           }//denominateur security
834         }//cluster shape and thresholds
835       }//good and PRF On
836       
837     } // Boucle clusters
838     
839     // Fill the charge
840     if (fCH2dOn && fGoodTrack) {
841       FillTheInfoOfTheTrackCH();
842     }
843
844     // PH calibration
845     if (fPH2dOn && fGoodTrack) {
846       FillTheInfoOfTheTrackPH();        
847     }
848
849     fNumberTrack++;
850         
851   } // Condition on number of clusters
852
853   return kTRUE;
854   
855 }
856
857 //_____________________________________________________________________________
858 Bool_t AliTRDCalibraFillHisto::IsPadOn(Int_t detector, Int_t col, Int_t row) const
859 {
860   //
861   // Look in the choosen database if the pad is On.
862   // If no the track will be "not good"
863   //
864
865   // Get the parameter object
866   AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
867   if (!cal) {
868     AliInfo("Could not get calibDB");
869     return kFALSE;
870   }
871   
872   if (!cal->IsChamberInstalled(detector)     || 
873        cal->IsChamberMasked(detector)        ||
874        cal->IsPadMasked(detector,col,row)) {
875     return kFALSE;
876   }
877   else {
878     return kTRUE;
879   }
880   
881 }
882
883 //____________Functions for plotting the 2D____________________________________
884
885 //_____________________________________________________________________________
886 void AliTRDCalibraFillHisto::Plot2d()
887 {
888   //
889   // Plot the 2D histos 
890   //
891  
892   if (fPH2dOn) {
893     TCanvas *cph2d = new TCanvas("cph2d","",50,50,600,800);
894     cph2d->cd();
895     fPH2d->Draw("LEGO");
896   }
897   if (fCH2dOn) {
898     TCanvas *cch2d = new TCanvas("cch2d","",50,50,600,800);
899     cch2d->cd();
900     fCH2d->Draw("LEGO");
901   }
902   if (fPRF2dOn) {
903     TCanvas *cPRF2d = new TCanvas("cPRF2d","",50,50,600,800);
904     cPRF2d->cd();
905     fPRF2d->Draw("LEGO");
906   }
907
908 }
909
910 //____________Writing the 2D___________________________________________________
911
912 //_____________________________________________________________________________
913 Bool_t AliTRDCalibraFillHisto::Write2d()
914 {
915   //
916   // Write the 2D histograms or the vectors converted in trees in the file
917   // "TRD.calibration.root" 
918   //
919   
920   TFile *fout = TFile::Open(fWriteName,"RECREATE");
921   // Check if the file could be opened
922   if (!fout || !fout->IsOpen()) {
923     AliInfo("No File found!");
924     return kFALSE;
925   }
926   AliInfo(Form("Numbertrack: %d Numberusedch[0]: %d, Numberusedch[1]: %d Numberusedph[0]: %d, Numberusedph[1]: %d"
927               ,fNumberTrack
928               ,fNumberUsedCh[0]
929               ,fNumberUsedCh[1]
930               ,fNumberUsedPh[0]
931               ,fNumberUsedPh[1]));
932   
933   TStopwatch stopwatch;
934   stopwatch.Start();
935   AliInfo("Write2d");
936
937   if ((fCH2dOn ) && (fWrite[0])) {
938     if (fHisto2d) {
939       fout->WriteTObject(fCH2d);
940     }
941     if (fVector2d) {
942       TString name("Nz");
943       name += fCalibraMode->GetNz(0);
944       name += "Nrphi";
945       name += fCalibraMode->GetNrphi(0);
946       TTree *treeCH2d = fCalibraVector->ConvertVectorCTTreeHisto(fCalibraVector->GetVectorCH(),fCalibraVector->GetPlaCH(),"treeCH2d",(const char *) name);
947       fout->WriteTObject(treeCH2d);
948     }
949   }
950   if ((fPH2dOn ) && (fWrite[1])) {
951     if (fHisto2d) {
952       fout->WriteTObject(fPH2d);
953     }
954     if (fVector2d) {
955       TString name("Nz");
956       name += fCalibraMode->GetNz(1);
957       name += "Nrphi";
958       name += fCalibraMode->GetNrphi(1);
959       TTree *treePH2d = fCalibraVector->ConvertVectorPTreeHisto(fCalibraVector->GetVectorPH(),fCalibraVector->GetPlaPH(),"treePH2d",(const char *) name);
960       fout->WriteTObject(treePH2d);
961     }
962   }
963   if ((fPRF2dOn ) && (fWrite[2])) {
964     if (fHisto2d) {
965       fout->WriteTObject(fPRF2d);
966     }
967     if (fVector2d) {
968       TString name("Nz");
969       name += fCalibraMode->GetNz(2);
970       name += "Nrphi";
971       name += fCalibraMode->GetNrphi(2);
972       TTree *treePRF2d = fCalibraVector->ConvertVectorPTreeHisto(fCalibraVector->GetVectorPRF(),fCalibraVector->GetPlaPRF(),"treePRF2d",(const char *) name);
973       fout->WriteTObject(treePRF2d);
974     }
975   }
976   
977   fout->Close();
978   
979   AliInfo(Form("Execution time Write2d: R:%.2fs C:%.2fs"
980               ,stopwatch.RealTime(),stopwatch.CpuTime()));
981
982   return kTRUE;
983   
984 }
985
986 //____________Probe the histos_________________________________________________
987 Double_t *AliTRDCalibraFillHisto::StatH(TH2 *h, Int_t i)
988 {
989   //
990   // Check the number of stats in h, 0 is TH2I 1 is TProfile2D
991   // debug mode with 2 for TH2I and 3 for TProfile2D
992   // It gives a pointer to a Double_t[7] with the info following...
993   // [0] : number of calibration groups with entries
994   // [1] : minimal number of entries found
995   // [2] : calibration group number of the min
996   // [3] : maximal number of entries found
997   // [4] : calibration group number of the max
998   // [5] : mean number of entries found
999   // [6] : mean relativ error
1000   //
1001
1002   Double_t *info = new Double_t[7];
1003    
1004   // Number of Xbins (detectors or groups of pads)
1005   Int_t    nbins   = h->GetNbinsX(); //number of calibration groups
1006   Int_t    nybins  = h->GetNbinsY(); //number of bins per histo
1007
1008   // Initialise
1009   Double_t nbwe = 0; //number of calibration groups with entries
1010   Double_t minentries = 0; //minimal number of entries found
1011   Double_t maxentries = 0; //maximal number of entries found
1012   Double_t placemin = 0; //calibration group number of the min
1013   Double_t placemax = -1; //calibration group number of the max
1014   Double_t meanstats = 0.0; //mean number of entries over the calibration group with at least ome entry
1015   Double_t meanrelativerror = 0.0; //mean relativ error in the TProfile2D
1016
1017   Double_t counter = 0;
1018
1019   //Debug
1020   TH1F *NbEntries = 0x0;//distribution of the number of entries
1021   TH1F *NbEntriesPerGroup = 0x0;//Number of entries per group
1022   TProfile *NbEntriesPerSp = 0x0;//Number of entries for one supermodule
1023     
1024   // Beginning of the loop over the calibration groups 
1025   for (Int_t idect = 0; idect < nbins; idect++) {
1026
1027     TH1I *projch = (TH1I *) h->ProjectionY("projch",idect+1,idect+1,(Option_t *)"e");
1028     projch->SetDirectory(0);
1029     
1030     // Number of entries for this calibration group
1031     Double_t nentries = 0.0;
1032     if((i%2) == 0){
1033       for (Int_t k = 0; k < nybins; k++) {
1034         nentries += h->GetBinContent(h->GetBin(idect+1,k+1));
1035       }
1036     }
1037     else{
1038       for (Int_t k = 0; k < nybins; k++) {
1039         nentries += ((TProfile2D *)h)->GetBinEntries(h->GetBin(idect+1,k+1));
1040         if(h->GetBinContent(h->GetBin(idect+1,k+1)) != 0) {
1041           meanrelativerror += (h->GetBinError(h->GetBin(idect+1,k+1))
1042                             / (TMath::Abs(h->GetBinContent(h->GetBin(idect+1,k+1)))));
1043           counter++;
1044         } 
1045       }
1046     }
1047
1048     //Debug
1049     if(i > 1){
1050       if((!((Bool_t)NbEntries)) && (nentries > 0)){
1051         NbEntries = new TH1F("Number of entries","Number of entries"
1052                                ,100,(Int_t)nentries/2,nentries*2);
1053         NbEntries->SetDirectory(0);
1054         NbEntriesPerGroup = new TH1F("Number of entries per group","Number of entries per group"
1055                                ,nbins,0,nbins);
1056         NbEntriesPerGroup->SetDirectory(0);
1057         NbEntriesPerSp = new TProfile("Number of entries per supermodule","Number of entries per supermodule"
1058                                ,(Int_t)(nbins/18),0,(Int_t)(nbins/18));
1059         NbEntriesPerSp->SetDirectory(0);
1060       }
1061       if(NbEntries){
1062         if(nentries > 0) NbEntries->Fill(nentries);
1063         NbEntriesPerGroup->Fill(idect+0.5,nentries);
1064         NbEntriesPerSp->Fill((idect%((Int_t)(nbins/18)))+0.5,nentries);
1065       }
1066     }
1067
1068     //min amd max
1069     if(nentries > maxentries){
1070       maxentries = nentries;
1071       placemax = idect;
1072     }
1073     if(idect == 0) {
1074       minentries = nentries;
1075     }
1076     if(nentries < minentries){
1077       minentries = nentries;
1078       placemin = idect;
1079     }
1080     //nbwe
1081     if(nentries > 0) {
1082       nbwe++;
1083       meanstats += nentries;
1084     }
1085
1086   }//calibration groups loop
1087   
1088   if(nbwe > 0) meanstats /= nbwe;
1089   if(counter > 0) meanrelativerror /= counter;
1090
1091   AliInfo(Form("There are %f calibration groups with entries",nbwe));
1092   AliInfo(Form("The minimum number of entries is %f for the group %f",minentries,placemin));
1093   AliInfo(Form("The maximum number of entries is %f for the group %f",maxentries,placemax));
1094   AliInfo(Form("The mean number of entries is %f",meanstats));
1095   if((i%2) == 1) AliInfo(Form("The mean relative error is %f",meanrelativerror));
1096
1097   info[0] = nbwe;
1098   info[1] = minentries;
1099   info[2] = placemin;
1100   info[3] = maxentries;
1101   info[4] = placemax;
1102   info[5] = meanstats;
1103   info[6] = meanrelativerror;
1104
1105   if(i > 1){
1106     gStyle->SetPalette(1);
1107     gStyle->SetOptStat(1111);
1108     gStyle->SetPadBorderMode(0);
1109     gStyle->SetCanvasColor(10);
1110     gStyle->SetPadLeftMargin(0.13);
1111     gStyle->SetPadRightMargin(0.01);
1112     TCanvas *stat = new TCanvas("stat","",50,50,600,800);
1113     stat->Divide(2,1);
1114     stat->cd(1);
1115     NbEntries->Draw("");
1116     stat->cd(2);
1117     NbEntriesPerSp->SetStats(0);
1118     NbEntriesPerSp->Draw("");
1119     TCanvas *stat1 = new TCanvas("stat1","",50,50,600,800);
1120     stat1->cd();
1121     NbEntriesPerGroup->SetStats(0);
1122     NbEntriesPerGroup->Draw("");
1123   }
1124
1125   return info;
1126
1127 }
1128
1129 //_____________________________________________________________________________
1130 void AliTRDCalibraFillHisto::SetRelativeScale(Float_t RelativeScale)
1131 {
1132   //
1133   // Set the factor that will divide the deposited charge
1134   // to fit in the histo range [0,300]
1135   //
1136  
1137   if (RelativeScale > 0.0) {
1138     fRelativeScale = RelativeScale;
1139   } 
1140   else {
1141     AliInfo("RelativeScale must be strict positif!");
1142   }
1143
1144
1145
1146 //_____________________________________________________________________________
1147 void AliTRDCalibraFillHisto::SetNz(Int_t i, Short_t Nz)
1148 {
1149   //
1150   // Set the mode of calibration group in the z direction for the parameter i
1151   // 
1152
1153   if ((Nz >= 0) && 
1154       (Nz <  5)) {
1155     fCalibraMode->SetNz(i, Nz); 
1156   }
1157   else { 
1158     AliInfo("You have to choose between 0 and 4");
1159   }
1160
1161 }
1162
1163 //_____________________________________________________________________________
1164 void AliTRDCalibraFillHisto::SetNrphi(Int_t i, Short_t Nrphi)
1165 {
1166   //
1167   // Set the mode of calibration group in the rphi direction for the parameter i
1168   //
1169  
1170   if ((Nrphi >= 0) && 
1171       (Nrphi <  7)) {
1172     fCalibraMode->SetNrphi(i ,Nrphi); 
1173   }
1174   else {
1175     AliInfo("You have to choose between 0 and 6");
1176   }
1177
1178 }
1179
1180 //____________Protected Functions______________________________________________
1181 //____________Create the 2D histo to be filled online__________________________
1182 //
1183
1184 //_____________________________________________________________________________
1185 void AliTRDCalibraFillHisto::CreatePRF2d(Int_t nn)
1186 {
1187   //
1188   // Create the 2D histos
1189   //
1190
1191   TString name("Nz");
1192   name += fCalibraMode->GetNz(2);
1193   name += "Nrphi";
1194   name += fCalibraMode->GetNrphi(2);
1195
1196   fPRF2d = new TProfile2D("PRF2d",(const Char_t *) name
1197                                  ,nn,0,nn,fNumberBinPRF,-1.5,1.5);
1198   fPRF2d->SetXTitle("Det/pad groups");
1199   fPRF2d->SetYTitle("Position x/W [pad width units]");
1200   fPRF2d->SetZTitle("Q_{i}/Q_{total}");
1201   fPRF2d->SetStats(0);
1202
1203 }
1204
1205 //_____________________________________________________________________________
1206 void AliTRDCalibraFillHisto::CreatePH2d(Int_t nn)
1207 {
1208   //
1209   // Create the 2D histos
1210   //
1211
1212   TString name("Nz");
1213   name += fCalibraMode->GetNz(1);
1214   name += "Nrphi";
1215   name += fCalibraMode->GetNrphi(1);
1216
1217   fPH2d = new TProfile2D("PH2d",(const Char_t *) name
1218                                ,nn,0,nn,fTimeMax
1219                                ,-0.5/fSf,(Float_t) (fTimeMax-0.5)/fSf);
1220   fPH2d->SetXTitle("Det/pad groups");
1221   fPH2d->SetYTitle("time [#mus]");
1222   fPH2d->SetZTitle("<PH> [a.u.]");
1223   fPH2d->SetStats(0);
1224
1225 }
1226
1227 //_____________________________________________________________________________
1228 void AliTRDCalibraFillHisto::CreateCH2d(Int_t nn)
1229 {
1230   //
1231   // Create the 2D histos
1232   //
1233
1234   TString name("Nz");
1235   name += fCalibraMode->GetNz(0);
1236   name += "Nrphi";
1237   name += fCalibraMode->GetNrphi(0);
1238
1239   fCH2d = new TH2I("CH2d",(const Char_t *) name
1240                          ,nn,0,nn,fNumberBinCharge,0,300);
1241   fCH2d->SetXTitle("Det/pad groups");
1242   fCH2d->SetYTitle("charge deposit [a.u]");
1243   fCH2d->SetZTitle("counts");
1244   fCH2d->SetStats(0);
1245   fCH2d->Sumw2();
1246
1247 }
1248
1249 //____________Offine tracking in the AliTRDtracker_____________________________
1250 void AliTRDCalibraFillHisto::FillTheInfoOfTheTrackCH()
1251 {
1252   //
1253   // For the offline tracking or mcm tracklets
1254   // This function will be called in the functions UpdateHistogram... 
1255   // to fill the info of a track for the relativ gain calibration
1256   //
1257         
1258   Int_t nb =  0; // Nombre de zones traversees
1259   Int_t fd = -1; // Premiere zone non nulle
1260   
1261   
1262   // See if the track goes through different zones
1263   for (Int_t k = 0; k < fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0); k++) {
1264     if (fAmpTotal[k] > 0.0) {
1265       nb++;
1266       if (nb == 1) {
1267         fd = k;
1268       }
1269     }
1270   }
1271  
1272   // If automatic scale
1273   if ((fCountRelativeScale < 100) && (fRelativeScaleAuto)) {
1274     // Take only the one zone track
1275     if (nb == 1) {
1276       fRelativeScale += fAmpTotal[fd] * 0.014 * 0.01;
1277       fCountRelativeScale++;
1278     }
1279   }
1280
1281   // We fill the CH2d after having scale with the first 100
1282   if ((fCountRelativeScale >= 100) && (fRelativeScaleAuto)) {
1283     // Case of track with only one zone
1284     if (nb == 1) {
1285       if (fHisto2d) {
1286         fCH2d->Fill(fCalibraMode->GetXbins(0)+fd+0.5,fAmpTotal[fd]/fRelativeScale);
1287       }
1288       if (fVector2d) {
1289         fCalibraVector->UpdateVectorCH(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/fRelativeScale);
1290       }
1291     } // Case 1 zone
1292     // Case of track with two zones
1293     if (nb == 2) {
1294       // Two zones voisines sinon rien!
1295       if ((fAmpTotal[fd]   > 0.0) && 
1296           (fAmpTotal[fd+1] > 0.0)) {
1297         // One of the two very big
1298         if (fAmpTotal[fd] > fProcent*fAmpTotal[fd+1]) {
1299           if (fHisto2d) {
1300             fCH2d->Fill(fCalibraMode->GetXbins(0)+fd+0.5,fAmpTotal[fd]/fRelativeScale);
1301           }
1302           if (fVector2d) {
1303             fCalibraVector->UpdateVectorCH(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/fRelativeScale);
1304           }
1305         }
1306         if (fAmpTotal[fd+1] > fProcent*fAmpTotal[fd])  {
1307           if (fHisto2d) {
1308             fCH2d->Fill(fCalibraMode->GetXbins(0)+fd+1.5,fAmpTotal[fd+1]/fRelativeScale);
1309           }
1310           if (fVector2d) {
1311             fCalibraVector->UpdateVectorCH(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd+1]/fRelativeScale);
1312           }
1313         }
1314       }
1315     } // Case 2 zones
1316   }
1317
1318   // Fill with no automatic scale
1319   if (!fRelativeScaleAuto) {
1320     // Case of track with only one zone
1321     if (nb == 1) {
1322       fNumberUsedCh[0]++;
1323       if (fHisto2d) {
1324         fCH2d->Fill(fCalibraMode->GetXbins(0)+fd+0.5,fAmpTotal[fd]/fRelativeScale);
1325       }
1326       if (fVector2d) {
1327         fCalibraVector->UpdateVectorCH(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/fRelativeScale);
1328       }
1329     } // Case 1 zone
1330     // Case of track with two zones
1331     if (nb == 2) {
1332       // Two zones voisines sinon rien!
1333       // Case 1
1334       if ((fAmpTotal[fd]   > 0.0) && 
1335           (fAmpTotal[fd+1] > 0.0)) {
1336         // One of the two very big
1337         if (fAmpTotal[fd] > fProcent*fAmpTotal[fd+1]) {
1338           if (fHisto2d) {
1339             fCH2d->Fill(fCalibraMode->GetXbins(0)+fd+0.5,fAmpTotal[fd]/fRelativeScale);
1340           }
1341           if (fVector2d) {
1342             fCalibraVector->UpdateVectorCH(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/fRelativeScale);
1343           }
1344           fNumberUsedCh[1]++;
1345         }
1346         if (fAmpTotal[fd+1] > fProcent*fAmpTotal[fd]) {
1347           if (fHisto2d) {
1348             fCH2d->Fill(fCalibraMode->GetXbins(0)+fd+1.5,fAmpTotal[fd+1]/fRelativeScale);
1349           }
1350           if (fVector2d) {
1351             fCalibraVector->UpdateVectorCH(fCalibraMode->GetXbins(0)+fd+1,fAmpTotal[fd+1]/fRelativeScale);
1352           }
1353           fNumberUsedCh[1]++;
1354         }
1355       }
1356       // Case 2
1357       if (fCalibraMode->GetNfragZ(0) > 1) {
1358         if (fAmpTotal[fd] > 0.0) {
1359           if ((fd+fCalibraMode->GetNfragZ(0)) < (fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0))) {
1360             if (fAmpTotal[fd+fCalibraMode->GetNfragZ(0)] > 0.0) {
1361               // One of the two very big
1362               if (fAmpTotal[fd] > fProcent*fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]) {
1363                 if (fHisto2d) {
1364                   fCH2d->Fill(fCalibraMode->GetXbins(0)+fd+0.5,fAmpTotal[fd]/fRelativeScale);
1365                 }
1366                 if (fVector2d) {
1367                   fCalibraVector->UpdateVectorCH(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/fRelativeScale);
1368                 }
1369                 fNumberUsedCh[1]++;
1370               }
1371               if (fAmpTotal[fd+fCalibraMode->GetNfragZ(0)] > fProcent*fAmpTotal[fd]) {
1372                 if (fHisto2d) {
1373                   fCH2d->Fill(fCalibraMode->GetXbins(0)+fd+fCalibraMode->GetNfragZ(0)
1374                             + 0.5,fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/fRelativeScale);
1375                 }
1376                 fNumberUsedCh[1]++;
1377                 if (fVector2d) {
1378                   fCalibraVector->UpdateVectorCH(fCalibraMode->GetXbins(0)+fd+fCalibraMode->GetNfragZ(0)
1379                                                 ,fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/fRelativeScale);
1380                 }
1381               }
1382             }
1383           }
1384         }
1385       }
1386     } // Case 2 zones
1387
1388   }
1389
1390 }
1391
1392 //____________Offine tracking in the AliTRDtracker_____________________________
1393 void AliTRDCalibraFillHisto::ResetfVariables()
1394 {
1395   //
1396   // Reset values of fAmpTotal, fPHValue and fPHPlace for
1397   // the updateHistogram... functions
1398   //
1399
1400   // Reset the good track
1401   fGoodTrack = kTRUE;
1402   
1403   // Reset the fAmpTotal where we put value
1404   if (fCH2dOn) {
1405     for (Int_t k = 0; k < fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0); k++) {
1406       fAmpTotal[k] = 0.0;
1407     }
1408   }
1409   
1410   // Reset the fPHValue
1411   if (fPH2dOn) {
1412     for (Int_t k = 0; k < fTimeMax; k++) {
1413       fPHValue[k] = 0.0;
1414       fPHPlace[k] = -1;
1415     }
1416   }
1417
1418 }
1419
1420 //____________Offine tracking in the AliTRDtracker_____________________________
1421 void AliTRDCalibraFillHisto::FillTheInfoOfTheTrackPH()
1422 {
1423   //
1424   // For the offline tracking or mcm tracklets
1425   // This function will be called in the functions UpdateHistogram... 
1426   // to fill the info of a track for the drift velocity  calibration
1427   //
1428     
1429   Int_t nb  =  1; // Nombre de zones traversees 1, 2 ou plus de 3
1430   Int_t fd1 = -1; // Premiere zone non nulle
1431   Int_t fd2 = -1; // Deuxieme zone non nulle
1432   Int_t k1  = -1; // Debut de la premiere zone
1433   Int_t k2  = -1; // Debut de la seconde zone
1434
1435   // See if the track goes through different zones
1436   for (Int_t k = 0; k < fTimeMax; k++) {
1437     if (fPHValue[k] > 0.0) {
1438       if (fd1 == -1) {
1439         fd1 = fPHPlace[k];
1440         k1  = k;              
1441       }
1442       if (fPHPlace[k] != fd1) {
1443         if (fd2 == -1) {
1444           k2  = k;
1445           fd2 = fPHPlace[k];
1446           nb  = 2;
1447         }
1448         if (fPHPlace[k] != fd2) {
1449           nb = 3;
1450         }
1451       }
1452     }
1453   }
1454   
1455   // Fill 
1456   // Case of track with only one zone
1457   if (nb == 1) {
1458     fNumberUsedPh[0]++;
1459     //fd1 is the only zone
1460     for (Int_t i = 0; i < fTimeMax; i++) {
1461       if (fHisto2d) {
1462         fPH2d->Fill((fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) i/fSf,(Float_t) fPHValue[i]);
1463       }
1464       if (fVector2d) {
1465         fCalibraVector->UpdateVectorPH((fCalibraMode->GetXbins(1)+fd1),i,fPHValue[i]);
1466       }
1467     }
1468   } // Case 1 zone
1469   // Case of track with two zones
1470   if (nb == 2) {
1471     // Two zones voisines sinon rien!
1472     // Case 1
1473     if ((fd1 == fd2+1) || 
1474         (fd2 == fd1+1)) {
1475       // One of the two fast all the think
1476       if (k2 > (k1+fDifference)) {
1477         //we choose to fill the fd1 with all the values
1478         fNumberUsedPh[1]++;
1479         for (Int_t i = 0; i < fTimeMax; i++) {
1480           if (fHisto2d) {
1481             fPH2d->Fill((fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) i/fSf,(Float_t) fPHValue[i]);
1482           }
1483           if (fVector2d) {
1484             fCalibraVector->UpdateVectorPH((fCalibraMode->GetXbins(1)+fd1),i,fPHValue[i]);
1485           }
1486         }
1487       }
1488       if ((k2+fDifference) < fTimeMax) {
1489         //we choose to fill the fd2 with all the values
1490         fNumberUsedPh[1]++;
1491         for (Int_t i = 0; i < fTimeMax; i++) {
1492           if (fHisto2d) {
1493             fPH2d->Fill((fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) i/fSf,(Float_t) fPHValue[i]);
1494           }
1495           if (fVector2d) {
1496             fCalibraVector->UpdateVectorPH((fCalibraMode->GetXbins(1)+fd2),i,fPHValue[i]);
1497           }
1498         }
1499       }
1500     }
1501     // Two zones voisines sinon rien!
1502     if (fCalibraMode->GetNfragZ(1) > 1) {
1503       // Case 2
1504       if ((fd1+fCalibraMode->GetNfragZ(1)) < (fCalibraMode->GetNfragZ(1)*fCalibraMode->GetNfragRphi(1))) {
1505         if (fd2 == (fd1+fCalibraMode->GetNfragZ(1))) {
1506           // One of the two fast all the think
1507           if (k2 > (k1+fDifference)) {
1508             //we choose to fill the fd1 with all the values
1509             fNumberUsedPh[1]++;
1510             for (Int_t i = 0; i < fTimeMax; i++) {
1511               if (fHisto2d) {
1512                 fPH2d->Fill((fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) i/fSf,(Float_t) fPHValue[i]);
1513               }
1514               if (fVector2d) {
1515                 fCalibraVector->UpdateVectorPH((fCalibraMode->GetXbins(1)+fd1),i,fPHValue[i]);
1516               }
1517             }
1518           }
1519           if ((k2+fDifference) < fTimeMax) {
1520             //we choose to fill the fd2 with all the values
1521             fNumberUsedPh[1]++;
1522             for (Int_t i = 0; i < fTimeMax; i++) {
1523               if (fHisto2d) {
1524                 fPH2d->Fill((fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) i/fSf,(Float_t) fPHValue[i]);
1525               }
1526               if (fVector2d) {
1527                 fCalibraVector->UpdateVectorPH((fCalibraMode->GetXbins(1)+fd2),i,fPHValue[i]);
1528               }
1529             }
1530           }
1531         }
1532       }
1533       // Two zones voisines sinon rien!
1534       // Case 3
1535       if ((fd1 - fCalibraMode->GetNfragZ(1)) >= 0) {
1536         if (fd2 == (fd1 - fCalibraMode->GetNfragZ(1))) {
1537           // One of the two fast all the think
1538           if (k2 > (k1 + fDifference)) {
1539             //we choose to fill the fd1 with all the values
1540             fNumberUsedPh[1]++;
1541             for (Int_t i = 0; i < fTimeMax; i++) {
1542               if (fHisto2d) {
1543                 fPH2d->Fill((fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) i/fSf,(Float_t) fPHValue[i]);
1544               }
1545               if (fVector2d) {
1546                 fCalibraVector->UpdateVectorPH((fCalibraMode->GetXbins(1)+fd1),i,fPHValue[i]);
1547               }
1548             }
1549           }
1550           if ((k2+fDifference) < fTimeMax) {
1551             //we choose to fill the fd2 with all the values
1552             fNumberUsedPh[1]++;
1553             for (Int_t i = 0; i < fTimeMax; i++) {
1554               if (fHisto2d) {
1555                 fPH2d->Fill((fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) i/fSf,(Float_t) fPHValue[i]);
1556               }
1557               if (fVector2d) {
1558                 fCalibraVector->UpdateVectorPH((fCalibraMode->GetXbins(1)+fd2),i,fPHValue[i]);
1559               }
1560             }
1561           }
1562         }
1563       }
1564     }
1565
1566   } // case 2 zones
1567
1568 }
1569
1570 //____________Set the pad calibration variables for the detector_______________
1571 Bool_t AliTRDCalibraFillHisto::LocalisationDetectorXbins(Int_t detector)
1572 {
1573   //
1574   // For the detector calcul the first Xbins and set the number of row
1575   // and col pads per calibration groups, the number of calibration
1576   // groups in the detector.
1577   //
1578   
1579   // first Xbins of the detector
1580   if (fCH2dOn) {
1581     fCalibraMode->CalculXBins(detector,0);
1582   }
1583   if (fPH2dOn) {
1584     fCalibraMode->CalculXBins(detector,1);
1585   }
1586   if (fPRF2dOn) {
1587     fCalibraMode->CalculXBins(detector,2);
1588   }
1589
1590   // fragmentation of idect
1591   for (Int_t i = 0; i < 3; i++) {
1592     fCalibraMode->ModePadCalibration((Int_t) GetChamber(detector),i);
1593     fCalibraMode->ModePadFragmentation((Int_t) GetPlane(detector)
1594                        , (Int_t) GetChamber(detector)
1595                        , (Int_t) GetSector(detector),i);
1596   }
1597   
1598   return kTRUE;
1599
1600 }
1601
1602 //
1603 //____________Some basic geometry function_____________________________________
1604 //
1605
1606 //_____________________________________________________________________________
1607 Int_t AliTRDCalibraFillHisto::GetPlane(Int_t d) const
1608 {
1609   //
1610   // Reconstruct the plane number from the detector number
1611   //
1612
1613   return ((Int_t) (d % 6));
1614
1615 }
1616
1617 //_____________________________________________________________________________
1618 Int_t AliTRDCalibraFillHisto::GetChamber(Int_t d) const
1619 {
1620   //
1621   // Reconstruct the chamber number from the detector number
1622   //
1623   Int_t fgkNplan = 6;
1624
1625   return ((Int_t) (d % 30) / fgkNplan);
1626
1627 }
1628
1629 //_____________________________________________________________________________
1630 Int_t AliTRDCalibraFillHisto::GetSector(Int_t d) const
1631 {
1632   //
1633   // Reconstruct the sector number from the detector number
1634   //
1635   Int_t fg = 30;
1636
1637   return ((Int_t) (d / fg));
1638
1639 }