d28d6ac82f685ec880b53f315263b5442da02a26
[u/mrichter/AliRoot.git] / TRD / AliTRDCalibra.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 // AliTRDCalibra                                                               
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.        
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 calibration. 
26 //Begin_Html
27 /*
28 <br>
29 <CENTER>
30 <TABLE border=1>
31 <TR><TD><center>Nz</center></TD><TD><center> 0 </center></TD><TD><center> 1 </center></TD><TD><center> 2 </center></TD><TD><center> 3 </center></TD><TD><center> 4 </center></TD></TR>
32 <TR><TD><CENTER>group of row pads per detector</CENTER></TD><TD><CENTER>1</CENTER></TD><TD><CENTER>2</CENTER></TD><TD><CENTER>4</CENTER></TD><TD><CENTER>6(chamb2)<br> 8(others chambers)</CENTER></TD><TD><CENTER>12 (chamb2)<br> 16 (chamb0)</CENTER></TD></TR>
33 <TR><TD><CENTER>row pads per group</CENTER></TD><TD><CENTER>12 (chamb2)<br> 16 (chamb0)</CENTER></TD><TD><CENTER>6 (chamb2)<br> 8 (chamb0)</CENTER></TD><TD><CENTER>3 (chamb2)<br> 4 (chamb0)</CENTER></TD><TD><CENTER>2</CENTER></TD><TD><CENTER>1</CENTER></TD></TR>
34 <TR><TD><CENTER>~distance [cm]</CENTER></TD><TD><CENTER>106 (chamb2)<br> 130 (chamb0)</CENTER></TD><TD><CENTER>53 (chamb2)<br> 65 (chamb0)</CENTER></TD><TD><CENTER>26.5 (chamb2)<br> 32.5 (chamb0)</CENTER></TD><TD><CENTER>17 (chamb2)<br> 17 (chamb0)</CENTER></TD><TD><CENTER>9 (chamb2)<br> 9 (chamb0)</CENTER></TD></TR>
35 <CAPTION>In the z direction</CAPTION>
36 </TABLE>
37 </CENTER>
38 <CENTER>
39 <br>
40 <TABLE border=1>
41 <TR><TD><center>Nrphi</center></TD><TD><center> 0 </center></TD><TD><center> 1 </center></TD><TD><center> 2 </center></TD><TD><center> 3 </center></TD><TD><center> 4 </center></TD><TD><center> 5 </center></TD><TD><center> 6 </center></TD></TR>
42 <TR><TD><CENTER>group of col pads per detector</CENTER></TD><TD><CENTER>1</CENTER></TD><TD><CENTER>2</CENTER></TD><TD><CENTER>4</CENTER></TD><TD><CENTER>8</CENTER></TD><TD><CENTER>16</CENTER></TD><TD><center>36</center></TD><TD><center>144</center></TD></TR>
43 <TR><TD><CENTER>col pads per group</CENTER></TD><TD><CENTER>144</CENTER></TD><TD><CENTER>72</CENTER></TD><TD><CENTER>36</CENTER></TD><TD><CENTER>18</CENTER></TD><TD><CENTER>9</CENTER></TD><TD><center>4</center></TD><TD><center>1</center></TD></TR>
44 <TR><TD><CENTER>~distance [cm]</CENTER></TD><TD><CENTER>113.4</CENTER></TD><TD><CENTER>56.7</CENTER></TD><TD><CENTER>25.3</CENTER></TD><TD><CENTER>14.3</CENTER></TD><TD><CENTER>7.25</CENTER></TD><TD><center>3.2</center></TD><TD><center>0.8</center></TD></TR>
45 <CAPTION>In the rphi direction</CAPTION>
46 </TABLE>
47 </CENTER>
48 <br>
49 */
50 //End_Html 
51 //
52 // Fill histograms or vectors
53 //----------------------------
54 //   
55 // 2D Histograms (Histo2d) or vectors (Vector2d), then converted in Trees, will be filled
56 // from RAW DATA in a run or from reconstructed TRD tracks during the offline tracking 
57 // in the function "FollowBackProlongation" (AliTRDtracker)
58 // Per default the functions to fill are off.                                   
59 //
60 //Begin_Html
61 /*
62 Example of 2D histos for the relative gain (left) and the drift velocity (right) calibration of the sector 13 <br>
63 <center>
64 <img src="./gif/2dhisto.gif" width="600" height="350"><br>
65 </center>
66 */
67 //End_Html    
68 //
69 // Fit the histograms to find the coefficients 
70 //---------------------------------------------
71 //
72 // These 2D histograms or vectors (first converted in 1D histos) will be fitted  
73 // if they have enough entries, otherwise the (default) value of the choosen database 
74 // will be put. For the relative gain calibration the resulted factors will be globally 
75 // normalized to the gain factors of the choosen database. It unables to precise     
76 // previous calibration procedure.
77 // The function SetDebug enables the user to see:                                     
78 // _fDebug = 0: nothing, only the values are written in the tree if wanted
79 // _fDebug = 1: a comparaison of the coefficients found and the default values 
80 //              in the choosen database.
81 //              fCoef , histogram of the coefs as function of the calibration group number
82 //              fDelta , histogram of the relative difference of the coef with the default
83 //                        value in the database as function of the calibration group number
84 //              fError , dirstribution of this relative difference
85 // _fDebug = 2: only the fit of the choosen calibration group fFitVoir (SetFitVoir)
86 // _fDebug = 3: The coefficients in the choosen detector fDet (SetDet) as function of the
87 //              pad row and col number
88 // _fDebug = 4; The coeffcicients in the choosen detector fDet (SetDet) like in the 3 but with
89 //              also the comparaison histograms of the 1 for this detector
90 //
91 //Begin_Html
92 /*
93 Example of fCoef for the relative gain calibration of the sector 13 <br>
94 <center>
95 <img src="./gif/coef.gif"  width="400" height="460">
96 </center><br>
97 Example of fDelta (right) and fError (left) for the relative gain calibration of the sector 13 <br>
98 <center>
99 <img src="./gif/detlaerror.gif"  width="550" height="380"><br>
100 </center>
101 */
102 //End_Html 
103 //                            
104 // Author:
105 //   R. Bailhache (R.Bailhache@gsi.de)
106 //                            
107 //////////////////////////////////////////////////////////////////////////////////////
108
109 #include <TTree.h>
110 #include <TLine.h>
111 #include <TH1I.h>
112 #include <TStyle.h>
113 #include <TProfile2D.h>
114 #include <TFile.h>
115 #include <TCanvas.h>
116 #include <TGraphErrors.h>
117 #include <TObjArray.h>
118 #include <TChain.h>
119 #include <TH1.h>
120 #include <TH1I.h>
121 #include <TH1F.h>
122 #include <TF1.h>
123 #include <TH2F.h>
124 #include <TAxis.h>
125 #include <TStopwatch.h>
126 #include <TMath.h>
127 #include <TLegend.h>
128 #include <TDirectory.h>
129 #include <TROOT.h>
130
131 #include "AliLog.h"
132 #include "AliCDBManager.h"
133 #include "AliRun.h"
134 #include "AliRunLoader.h"
135 #include "AliLoader.h"
136 #include "AliRawReaderFile.h"
137 #include "AliRawReader.h"
138
139 #include "AliTRDCalibra.h"
140 #include "AliTRDcalibDB.h"
141 #include "AliTRDCommonParam.h"
142 #include "AliTRDmcmTracklet.h"
143 #include "AliTRDpadPlane.h"
144 #include "AliTRDcluster.h"
145 #include "AliTRDtrack.h"
146 #include "AliTRDdigit.h"
147 #include "AliTRDdigitsManager.h"
148 #include "AliTRD.h"
149 #include "AliTRDgeometry.h"
150 #include "./Cal/AliTRDCalROC.h"
151 #include "./Cal/AliTRDCalPad.h"
152 #include "./Cal/AliTRDCalDet.h"
153 #include "AliTRDrawData.h"
154
155 ClassImp(AliTRDCalibra)
156
157 AliTRDCalibra* AliTRDCalibra::fgInstance = 0;
158 Bool_t AliTRDCalibra::fgTerminated = kFALSE;
159
160 //_____________singleton implementation_________________________________________________
161 AliTRDCalibra *AliTRDCalibra::Instance()
162 {
163   //
164   // Singleton implementation
165   //
166
167   if (fgTerminated != kFALSE) {
168     return 0;
169   }
170
171   if (fgInstance == 0) {
172     fgInstance = new AliTRDCalibra();
173   }
174
175   return fgInstance;
176
177 }
178
179 //______________________________________________________________________________________
180 void AliTRDCalibra::Terminate()
181 {
182   //
183   // Singleton implementation
184   // Deletes the instance of this class
185   //
186
187   fgTerminated = kTRUE;
188
189   if (fgInstance != 0) {
190     delete fgInstance;
191     fgInstance = 0;
192   }
193
194 }
195
196 //______________________________________________________________________________________
197 AliTRDCalibra::AliTRDCalibra()
198   :TObject()
199   ,fMITracking(kFALSE)
200   ,fMcmTracking(kFALSE)
201   ,fMcmCorrectAngle(kFALSE)
202   ,fCH2dOn(kFALSE)
203   ,fPH2dOn(kFALSE)
204   ,fPRF2dOn(kFALSE)
205   ,fHisto2d(kFALSE)
206   ,fVector2d(kFALSE)
207   ,fRelativeScale(0)
208   ,fCountRelativeScale(0)
209   ,fRelativeScaleAuto(kFALSE)
210   ,fThresholdDigit(0)
211   ,fThresholdClusterPRF1(0.0)
212   ,fThresholdClusterPRF2(0.0)
213   ,fCenterOfflineCluster(kFALSE)
214   ,fTraMaxPad(kFALSE)
215   ,fWriteNameCoef(0)
216   ,fWriteName(0)
217   ,fFitPHOn(kFALSE)
218   ,fFitPHPeriode(0)
219   ,fBeginFitCharge(0.0)
220   ,fRangeFitPRF(0.0)
221   ,fMeanChargeOn(kFALSE)
222   ,fFitChargeBisOn(kFALSE)
223   ,fT0Shift(0.0)
224   ,fAccCDB(kFALSE)
225   ,fNumberFit(0)
226   ,fStatisticMean(0.0)
227   ,fDebug(0)
228   ,fFitVoir(0)
229   ,fPRF(0)
230   ,fGain(0)
231   ,fT0(0)
232   ,fVdrift(0)
233   ,fVdriftDetector(0)
234   ,fVdriftPad(0x0)
235   ,fT0Detector(0)
236   ,fT0Pad(0x0)
237   ,fPRFDetector(0)
238   ,fPRFPad(0x0)
239   ,fCoefCH(0x0)
240   ,fDetectorAliTRDtrack(kFALSE)
241   ,fChamberAliTRDtrack(-1)
242   ,fDetectorPreviousTrack(-1)
243   ,fGoodTrack(kTRUE)
244   ,fAmpTotal(0x0)
245   ,fPHPlace(0x0)
246   ,fPHValue(0x0)
247   ,fNumberClusters(0)
248   ,fProcent(0.0)
249   ,fDifference(0)
250   ,fNumberTrack(0)
251   ,fDeltaPRF(0)
252   ,fErrorPRF(0)
253   ,fCoefPRFDB(0)
254   ,fTimeMax(0)
255   ,fSf(0.0)
256   ,fScaleFitFactor(0.0)
257   ,fMinEntries(0)
258   ,fEntriesCurrent(0)
259   ,fL3P0(0.0)
260   ,fL3P2(0.0)
261   ,fG3P2(0.0)
262   ,fVectorPH(0)
263   ,fPlaPH(0)
264   ,fNumberBinCharge(0)
265   ,fVectorCH(0)
266   ,fPlaCH(0)
267   ,fVectorFitCH(0)
268   ,fNumberBinPRF(0)
269   ,fVectorPRF(0)
270   ,fPlaPRF(0)
271   ,fPH2d(0x0)
272   ,fPRF2d(0x0)
273   ,fCH2d(0x0)
274   ,fRebin(0)
275 {
276   //
277   // Default constructor
278   //
279
280   for (Int_t i = 0; i < 3; i++) {
281     fNz[i]    = 0;
282     fNrphi[i] = 0;
283   }
284
285   for (Int_t k = 0; k < 3; k++) {
286     fNtotal[k]    = 0;
287     fDetChamb2[k] = 0;
288     fDetChamb0[k] = 0;
289   }
290
291   // Write
292   for (Int_t i = 0; i < 3; i++) {
293     fWriteCoef[i] = kFALSE;
294     fWrite[i]     = kFALSE;
295   }
296
297   // Debug Mode
298   for (Int_t k = 0; k < 3; k++) {
299     fDet[k] = 0;
300   }
301
302   for (Int_t i = 0; i < 2; i++) {
303     fPhd[i] = 0.0;
304   }
305
306   // Init
307   Init();
308   
309 }
310
311 //______________________________________________________________________________________
312 AliTRDCalibra::AliTRDCalibra(const AliTRDCalibra &c)
313   :TObject(c)
314   ,fMITracking(kFALSE)
315   ,fMcmTracking(kFALSE)
316   ,fMcmCorrectAngle(kFALSE)
317   ,fCH2dOn(kFALSE)
318   ,fPH2dOn(kFALSE)
319   ,fPRF2dOn(kFALSE)
320   ,fHisto2d(kFALSE)
321   ,fVector2d(kFALSE)
322   ,fRelativeScale(0)
323   ,fCountRelativeScale(0)
324   ,fRelativeScaleAuto(kFALSE)
325   ,fThresholdDigit(0)
326   ,fThresholdClusterPRF1(0.0)
327   ,fThresholdClusterPRF2(0.0)
328   ,fCenterOfflineCluster(kFALSE)
329   ,fTraMaxPad(kFALSE)
330   ,fWriteNameCoef(0)
331   ,fWriteName(0)
332   ,fFitPHOn(kFALSE)
333   ,fFitPHPeriode(0)
334   ,fBeginFitCharge(0.0)
335   ,fRangeFitPRF(0.0)
336   ,fMeanChargeOn(kFALSE)
337   ,fFitChargeBisOn(kFALSE)
338   ,fT0Shift(0.0)
339   ,fAccCDB(kFALSE)
340   ,fNumberFit(0)
341   ,fStatisticMean(0.0)
342   ,fDebug(0)
343   ,fFitVoir(0)
344   ,fPRF(0)
345   ,fGain(0)
346   ,fT0(0)
347   ,fVdrift(0)
348   ,fVdriftDetector(0)
349   ,fVdriftPad(0x0)
350   ,fT0Detector(0)
351   ,fT0Pad(0x0)
352   ,fPRFDetector(0)
353   ,fPRFPad(0x0)
354   ,fCoefCH(0x0)
355   ,fDetectorAliTRDtrack(kFALSE)
356   ,fChamberAliTRDtrack(-1)
357   ,fDetectorPreviousTrack(-1)
358   ,fGoodTrack(kTRUE)
359   ,fAmpTotal(0x0)
360   ,fPHPlace(0x0)
361   ,fPHValue(0x0)
362   ,fNumberClusters(0)
363   ,fProcent(0.0)
364   ,fDifference(0)
365   ,fNumberTrack(0)
366   ,fDeltaPRF(0)
367   ,fErrorPRF(0)
368   ,fCoefPRFDB(0)
369   ,fTimeMax(0)
370   ,fSf(0.0)
371   ,fScaleFitFactor(0.0)
372   ,fMinEntries(0)
373   ,fEntriesCurrent(0)
374   ,fL3P0(0.0)
375   ,fL3P2(0.0)
376   ,fG3P2(0.0)
377   ,fVectorPH(0)
378   ,fPlaPH(0)
379   ,fNumberBinCharge(0)
380   ,fVectorCH(0)
381   ,fPlaCH(0)
382   ,fVectorFitCH(0)
383   ,fNumberBinPRF(0)
384   ,fVectorPRF(0)
385   ,fPlaPRF(0)
386   ,fPH2d(0x0)
387   ,fPRF2d(0x0)
388   ,fCH2d(0x0)
389   ,fRebin(0)
390 {
391   //
392   // Copy constructor
393   //
394
395 }
396
397 //____________________________________________________________________________________
398 AliTRDCalibra::~AliTRDCalibra()
399 {
400   //
401   // AliTRDCalibra destructor
402   //
403
404   ClearHistos();
405   ClearTree();
406
407 }
408
409 //_____________________________________________________________________________
410 void AliTRDCalibra::Destroy() 
411 {
412   //
413   // Delete instance 
414   //
415
416   if (fgInstance) {
417     delete fgInstance;
418     fgInstance = 0x0;
419   }
420
421 }
422
423 //_____________________________________________________________________________
424 void AliTRDCalibra::ClearHistos() 
425 {
426   //
427   // Delete the histos
428   //
429
430   if (fPH2d) {
431     delete fPH2d;
432     fPH2d  = 0x0;
433   }
434   if (fCH2d) {
435     delete fCH2d;
436     fCH2d  = 0x0;
437   }
438   if (fPRF2d) {
439     delete fPRF2d;
440     fPRF2d = 0x0;
441   }
442
443 }
444
445 //_____________________________________________________________________________
446 void AliTRDCalibra::ClearTree() 
447 {
448   //
449   // Delete the trees
450   //
451   
452   if (fPRF) {
453     delete fPRF;
454     fPRF    = 0x0;
455   }
456   if (fGain) {
457     delete fGain;
458     fGain   = 0x0;
459   }
460   if (fT0) {
461     delete fT0;
462     fT0     = 0x0;
463   }
464   if (fVdrift) {
465     delete fVdrift;
466     fVdrift = 0x0;
467   }
468
469 }
470
471 //_____________________________________________________________________________
472 void AliTRDCalibra::Init() 
473 {
474   //
475   // Init some default values
476   //
477
478   // How to fill the 2D
479   fThresholdDigit       = 5;
480   fThresholdClusterPRF1 = 2.0;
481   fThresholdClusterPRF2 = 20.0;
482   
483   // Store the Info
484   fNumberBinCharge      = 100;
485   fNumberBinPRF         = 20;
486   
487   // Write
488   fWriteName            = "TRD.calibration.root";
489   fWriteNameCoef        = "TRD.coefficient.root";
490   
491   // Fit
492   fFitPHPeriode         = 1;
493   fBeginFitCharge       = 3.5;
494   fRangeFitPRF          = 0.5;
495   fMinEntries           = 800;
496   fT0Shift              = 0.143397;
497   
498   // Internal variables
499   
500   // Fill the 2D histos in the offline tracking
501   fDetectorPreviousTrack = -1;
502   fChamberAliTRDtrack    = -1;
503   fGoodTrack             = kTRUE;
504
505   fProcent               = 6.0;
506   fDifference            = 17;
507   fNumberClusters        = 18;
508   fNumberTrack           = 0;
509   fNumberUsedCh[0]       = 0;
510   fNumberUsedCh[1]       = 0;
511   fNumberUsedPh[0]       = 0;
512   fNumberUsedPh[1]       = 0;
513   
514   // Variables in the loop
515   for (Int_t k = 0; k < 4; k++) {
516     fChargeCoef[k] = 1.0;
517     fVdriftCoef[k] = 1.5;
518     fT0Coef[k]     = -1.0;
519   }
520   for (Int_t i = 0; i < 2; i++) {
521     fPRFCoef[i]    = -1.0;
522   }
523   
524   // Pad calibration
525   for (Int_t i = 0; i < 3; i++) {
526     fRowMin[i]    = -1;
527     fRowMax[i]    = -1;
528     fColMax[i]    = -1;
529     fColMin[i]    = -1;
530     fNnZ[i]       = -1;
531     fNnRphi[i]    = -1;
532     fNfragZ[i]    = -1;
533     fNfragRphi[i] = -1;
534     fXbins[i]     = -1;
535   }
536   
537   // Local database to be changed
538   fRebin = 1;
539   
540 }
541
542 //____________Functions fit Online CH2d________________________________________
543 Bool_t AliTRDCalibra::FitCHOnline(TH2I *ch)
544 {
545   //
546   // Fit the 1D histos, projections of the 2D ch on the Xaxis, for each
547   // calibration group normalized the resulted coefficients (to 1 normally)
548   // and write the results in a tree
549   //
550    
551   // Number of Xbins (detectors or groups of pads)
552   TAxis   *xch     = ch->GetXaxis();
553   Int_t    nbins   = xch->GetNbins();
554   TAxis   *yph     = ch->GetYaxis();
555   Int_t    nybins  = yph->GetNbins();
556   Double_t lowedge = xch->GetBinLowEdge(1);
557   Double_t upedge  = xch->GetBinUpEdge(xch->GetNbins());
558   if (!InitFit(nbins,lowedge,upedge,0)) {
559     return kFALSE;
560   }
561   fStatisticMean = 0.0;
562   fNumberFit     = 0;
563
564   // For memory
565   if (fVectorCH) {
566     fVectorCH->Clear();
567   }
568   if (fPlaCH) {
569     fPlaCH->Clear();
570   }
571   
572   // Init fCountDet and fCount
573   InitfCountDetAndfCount(0);
574   
575   // Beginning of the loop betwwen dect1 and dect2
576   for (Int_t idect = fDect1[0]; idect < fDect2[0]; idect++) {
577
578     TH1I *projch = (TH1I *) ch->ProjectionY("projch",idect+1,idect+1,(Option_t *)"e");
579     projch->SetDirectory(0);
580
581     // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
582     UpdatefCountDetAndfCount(idect,0);
583     
584     // Reconstruction of the row and pad group: rowmin, row max ...
585     ReconstructFitRowMinRowMax(idect, 0);
586     
587     // Number of entries for this calibration group
588     Double_t nentries = 0.0;
589     for (Int_t k = 0; k < nybins; k++) {
590       nentries += ch->GetBinContent(ch->GetBin(idect+1,k+1));
591     }
592       
593     // Rebin and statistic stuff
594     // Rebin
595     if (fRebin > 1) {
596       projch = ReBin((TH1I *) projch);
597     }
598     // This detector has not enough statistics or was off
599     if (nentries < fMinEntries) {
600       // Fill with the default infos
601       NotEnoughStatistic(idect,0);
602       // Memory!!!
603       if (fDebug != 2) {
604         delete projch;
605       }
606       continue;
607     }
608     
609     // Statistics of the group fitted
610     AliInfo(Form("For the group number %d there are %f stats",idect,nentries));
611     fStatisticMean += nentries;
612     fNumberFit++; 
613     
614     // Method Mean and fit
615     // idect is egal for fDebug = 0 and 2, only to fill the hist 
616     FitCH((TH1 *) projch,(Int_t) (idect-fDect1[0]));
617     // Method fit bis
618     // idect is egal for fDebug = 0 and 2, only to fill the hist
619     if (fFitChargeBisOn) { 
620       FitBisCH((TH1 *) projch,(Int_t) (idect-fDect1[0]));
621     }
622     
623     // Visualise the detector for fDebug 3 or 4
624     // Here is the reconstruction of the pad and row group is used!
625     if (fDebug >= 3) {
626       FillCoefChargeDB();
627     }
628     // Fill Infos Fit
629     FillInfosFit(idect,0);
630     
631     // Memory!!!
632     if (fDebug != 2) {
633       delete projch;
634     }
635     
636   } // Boucle object
637
638   // Normierungcharge
639   if (fDebug != 2) {
640     NormierungCharge();
641   }
642   
643   // Error
644   if ((fDebug == 1) || 
645       (fDebug == 4)) {
646     ErrorCH();
647   }
648  
649   // Plot
650   // 0 no plot, 1 and 4 error plot, 3 and 4 DB plot
651   if ((fDebug == 1) || 
652       (fDebug == 4)) {
653     PlotCH();
654   }
655   if ((fDebug == 4) || 
656       (fDebug == 3)) {
657     PlotCHDB();
658   }
659
660   // Mean Statistic
661   if (fNumberFit > 0) {
662     AliInfo(Form("There is a mean statistic of: %d",(Int_t) fStatisticMean/fNumberFit));
663     fStatisticMean = fStatisticMean / fNumberFit;
664   }
665   else {
666     AliInfo("There is no fit!");
667   }
668   
669   // Write the things!
670   ConvertVectorFitCHTree();
671   if (fWriteCoef[0]) {
672     WriteFitInfos(0);       
673   }
674
675   return kTRUE;
676   
677 }
678
679 //____________Functions fit Online CH2d________________________________________
680 Bool_t AliTRDCalibra::FitCHOnline()
681 {
682   //
683   // Reconstruct a 1D histo from the vectorCH for each calibration group,
684   // fit the histo, normalized the resulted coefficients (to 1 normally)
685   // and write the results in a tree
686   //
687
688   // Number of Xbins (detectors or groups of pads)
689   if (!InitFit(0,0,0,0)) {
690     return kFALSE;
691   }
692   fStatisticMean = 0.0;
693   fNumberFit     = 0;
694  
695   // Init fCountDet and fCount
696   InitfCountDetAndfCount(0);
697
698   // Beginning of the loop between dect1 and dect2
699   for (Int_t idect = fDect1[0]; idect < fDect2[0]; idect++) {
700     
701     // Search if the group is in the VectorCH
702     Int_t place = SearchInVector(idect,0);
703        
704     // Is in
705     TH1F *projch = 0x0;
706     TString name("CH");
707     name += idect;
708     if (place != -1) {
709       // Variable
710       AliTRDCTInfo *fCHInfo = new AliTRDCTInfo();
711       // Retrieve
712       fCHInfo = ((AliTRDCTInfo *) fVectorCH->At(place));
713       projch  = ConvertVectorCTHisto(fCHInfo,(const char *) name);
714       projch->SetDirectory(0);
715       delete fCHInfo;
716     }
717
718     // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
719     UpdatefCountDetAndfCount(idect,0);
720     
721     // Reconstruction of the row and pad group: rowmin, row max ...
722     ReconstructFitRowMinRowMax(idect,0);
723     
724     // Number of entries
725     Double_t nentries = 0.0;
726     if (projch) {
727       for (Int_t k = 0; k < fNumberBinCharge; k++) {
728         nentries += projch->GetBinContent(k+1);
729       }
730     }
731   
732     // Rebin and statistic stuff
733     // Rebin
734     if ((fRebin >  1) && 
735         (place != -1)) {
736       projch = ReBin((TH1F *) projch);
737     }
738
739     // This detector has not enough statistics or was not found in VectorCH
740     if ((place == -1) || 
741         ((place != -1) && 
742          (nentries < fMinEntries))) {
743       
744       // Fill with the default infos
745       NotEnoughStatistic(idect,0);
746
747       // Memory!!!
748       if (fDebug != 2) {
749         delete projch;
750       }     
751       
752       continue;
753
754     }
755
756     // Statistic of the histos fitted
757     AliInfo(Form("For the group number %d there are %f stats",idect,nentries));
758     fNumberFit++;
759     fStatisticMean += nentries;
760     
761     // Method Mean and fit
762     // idect is egal for fDebug = 0 and 2, only to fill the hist 
763     FitCH((TH1 *) projch,(Int_t) (idect-fDect1[0]));
764     
765     // Method fit bis
766     // idect is egal for fDebug = 0 and 2, only to fill the hist
767     if (fFitChargeBisOn) { 
768       FitBisCH((TH1 *) projch,(Int_t) (idect-fDect1[0]));
769     }
770     
771     // Visualise the detector for fDebug 3 or 4
772     // Here is the reconstruction of the pad and row group is used!
773     if (fDebug >= 3) {
774       FillCoefChargeDB();
775     }
776     
777     // Fill Infos Fit
778     FillInfosFit(idect,0); 
779     
780     // Memory!!!
781     if (fDebug != 2) {
782       delete projch;
783     }
784     
785   } // Boucle object
786
787   // Normierungcharge
788   if (fDebug != 2) {
789     NormierungCharge();
790   }
791   
792   // Error
793   if ((fDebug == 1) || 
794       (fDebug == 4)) {
795     ErrorCH();
796   }
797   
798   // Plot
799   // 0 no plot, 1 and 4 error plot, 3 and 4 DB plot
800   if ((fDebug == 1) || 
801       (fDebug == 4)){
802     PlotCH();
803   }
804   if((fDebug == 4) || 
805      (fDebug == 3)){
806     PlotCHDB();
807   }
808   
809   // Mean Statistics
810   if (fNumberFit > 0) {
811     AliInfo(Form("There is a mean statistic of: %d",(Int_t) fStatisticMean / fNumberFit));
812     fStatisticMean = fStatisticMean / fNumberFit;
813   }
814   else {
815     AliInfo("There is no fit!");
816   }
817   
818   // Write the things!
819   ConvertVectorFitCHTree();
820   if (fWriteCoef[0]) {
821     WriteFitInfos(0);      
822   }
823
824   return kTRUE;
825   
826 }
827
828 //____________Functions fit Online CH2d________________________________________
829 Bool_t AliTRDCalibra::FitCHOnline(TTree *tree)
830 {
831   //
832   // Look if the calibration group can be found in the tree, if yes take the
833   // histo, fit it, normalized the resulted coefficients (to 1 normally) and
834   // write the results in a tree
835   //
836    
837   // Number of Xbins (detectors or groups of pads)
838   if (!InitFit(0,0,0,0)) {
839     return kFALSE;
840   }
841   fStatisticMean = 0.0;
842   fNumberFit     = 0;
843   
844   // For memory
845   if (fVectorCH) {
846     fVectorCH->Clear();
847   }
848   if (fPlaCH) {
849     fPlaCH->Clear();
850   }
851    
852   // Init fCountDet and fCount
853   InitfCountDetAndfCount(0);
854   TH1F      *projch      = 0x0;
855   tree->SetBranchAddress("histo",&projch);
856   TObjArray *vectorplace = ConvertTreeVector(tree);
857
858   // Beginning of the loop between dect1 and dect2
859   for (Int_t idect = fDect1[0]; idect < fDect2[0]; idect++) {
860     
861     //Search if the group is in the VectorCH
862     Int_t place = SearchInTreeVector(vectorplace,idect);
863     
864     // Is in
865     if (place != -1) {
866       // Variable
867       tree->GetEntry(place);
868     }
869     
870     // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
871     UpdatefCountDetAndfCount(idect,0);
872     
873     // Reconstruction of the row and pad group: rowmin, row max ...
874     ReconstructFitRowMinRowMax(idect,0);
875     
876     // Number of entries
877     Double_t nentries = 0.0;
878     if (projch) {
879       for (Int_t k = 0; k < projch->GetXaxis()->GetNbins(); k++) {
880         nentries += projch->GetBinContent(k+1);
881       }
882     }    
883
884     // Rebin and statistic stuff
885     // Rebin
886     if ((fRebin  >  1) && 
887         (place  != -1)) {
888       projch = ReBin((TH1F *) projch);
889     }
890
891     // This detector has not enough statistics or was not found in VectorCH
892     if((place == -1) || 
893        ((place    !=          -1) && 
894         (nentries  < fMinEntries))) {
895       
896       // Fill with the default infos
897       NotEnoughStatistic(idect,0);
898       
899       continue;
900
901     }
902     
903     // Statistics of the group fitted
904     AliInfo(Form("For the group number %d there are %f stats",idect,nentries));
905     fNumberFit++;
906     fStatisticMean += nentries;
907    
908     // Method Mean and fit
909     // idect is egal for fDebug = 0 and 2, only to fill the hist 
910     FitCH((TH1 *) projch,(Int_t) (idect-fDect1[0]));
911
912     // Method fit bis
913     // idect is egal for fDebug = 0 and 2, only to fill the hist
914     if (fFitChargeBisOn) { 
915       FitBisCH((TH1 *) projch,(Int_t) (idect-fDect1[0]));
916     }
917
918     // Visualise the detector for fDebug 3 or 4
919     // Here is the reconstruction of the pad and row group is used!
920     if (fDebug >= 3) {
921       FillCoefChargeDB();
922     }    
923
924     // Fill Infos Fit
925     FillInfosFit(idect,0); 
926     
927   } // Boucle object
928
929   // Normierungcharge
930   if (fDebug != 2) {
931     NormierungCharge();
932   }
933
934   // Error
935   if ((fDebug == 1) || 
936       (fDebug == 4)) {
937     ErrorCH();
938   }
939  
940   // Plot
941   // 0 no plot, 1 and 4 error plot, 3 and 4 DB plot
942   if ((fDebug == 1) || 
943       (fDebug == 4)){
944     PlotCH();
945   }
946   if ((fDebug == 4) || 
947       (fDebug == 3)){
948     PlotCHDB();
949   }
950
951   // Mean Statistic
952   if (fNumberFit > 0) {
953     AliInfo(Form("There is a mean statistic of: %d",(Int_t) fStatisticMean / fNumberFit));
954     fStatisticMean = fStatisticMean / fNumberFit;
955   }
956   else {
957     AliInfo("There is no fit!");
958   }
959
960   // Write the things!
961   ConvertVectorFitCHTree();
962   if (fWriteCoef[0]) {
963     WriteFitInfos(0);      
964   }
965
966   return kTRUE;
967   
968 }
969
970 //________________functions fit Online PH2d____________________________________
971 Bool_t AliTRDCalibra::FitPHOnline(TProfile2D *ph)
972 {
973   //
974   // Take the 1D profiles (average pulse height), projections of the 2D PH
975   // on the Xaxis, for each calibration group
976   // Fit or use the slope of the average pulse height to reconstruct the
977   // drift velocity write the results in a tree
978   // A first calibration of T0 is also made  using the same method (slope method)
979   //
980  
981   // Number of Xbins (detectors or groups of pads)
982   TAxis   *xph     = ph->GetXaxis();
983   TAxis   *yph     = ph->GetYaxis();
984   Int_t    nbins   = xph->GetNbins();
985   Int_t    nybins  = yph->GetNbins();
986   Double_t lowedge = xph->GetBinLowEdge(1);
987   Double_t upedge  = xph->GetBinUpEdge(xph->GetNbins());
988   if (!InitFit(nbins,lowedge,upedge,1)) {
989     return kFALSE;
990   }
991   fStatisticMean = 0.0;
992   fNumberFit     = 0;
993
994   // For memory
995   if (fVectorPH) {
996     fVectorPH->Clear();
997   }
998   if (fPlaPH) {
999     fPlaPH->Clear();
1000   }
1001
1002   // Init fCountDet and fCount
1003   InitfCountDetAndfCount(1);
1004   
1005   // Beginning of the loop
1006   for (Int_t idect = fDect1[1]; idect < fDect2[1]; idect++) {
1007       
1008     TH1D *projph = (TH1D *) ph->ProjectionY("projph",idect+1,idect+1,(Option_t *) "e");
1009     projph->SetDirectory(0); 
1010
1011     // Number of entries for this calibration group
1012     Double_t nentries = 0;
1013     for (Int_t k = 0; k < nybins; k++) {
1014       nentries += ph->GetBinEntries(ph->GetBin(idect+1,k+1));
1015     }
1016   
1017     // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
1018     UpdatefCountDetAndfCount(idect,1);
1019
1020     // Reconstruction of the row and pad group: rowmin, row max ...
1021     ReconstructFitRowMinRowMax(idect,1);
1022     
1023     // Rebin and statistic stuff
1024     // This detector has not enough statistics or was off
1025     if (nentries  < fMinEntries) {
1026       
1027       // Fill with the default values
1028       NotEnoughStatistic(idect,1);     
1029       
1030       // Memory!!!
1031       if (fDebug != 2) {
1032         delete projph;
1033       }
1034            
1035       continue;
1036
1037     }
1038     
1039     // Statistics of the histos fitted
1040     AliInfo(Form("For the group number %d there are %f stats",idect,nentries));
1041     fNumberFit++;
1042     fStatisticMean += nentries;
1043     
1044     // Calcul of "real" coef
1045     CalculVdriftCoefMean(fCountDet[1],(Int_t) (idect - fDect1[1]));
1046     CalculT0CoefMean(fCountDet[1],(Int_t) (idect - fDect1[1]));
1047     
1048     // Method Mean and fit
1049     // idect is egal for fDebug = 0 and 2, only to fill the hist 
1050     FitPente((TH1 *) projph,(Int_t) (idect - fDect1[1]));
1051
1052     // Method fit bis
1053     // idect is egal for fDebug = 0 and 2, only to fill the hist
1054     if (fFitPHOn) { 
1055       FitPH((TH1 *) projph,(Int_t) (idect - fDect1[1]));
1056     }
1057      
1058     // Visualise the detector for fDebug 3 or 4
1059     // Here is the reconstruction of the pad and row group is used!
1060     if (fDebug >= 3) {
1061       FillCoefVdriftDB();
1062       FillCoefT0DB();
1063     }
1064
1065     // Fill the tree if end of a detector or only the pointer to the branch!!!
1066     FillInfosFit(idect,1);
1067     
1068     // Memory!!!
1069     if (fDebug != 2) {
1070       delete projph;
1071     }
1072   
1073   } // Boucle object
1074
1075   // Error
1076   if ((fDebug == 1) || 
1077       (fDebug == 4)) {
1078     ErrorPH();
1079     ErrorT0();
1080   }
1081  
1082   // Plot
1083   // 0 no plot, 1 and 4 error plot, 3 and 4 DB plot
1084   if ((fDebug == 1) || 
1085       (fDebug == 4)) {
1086     PlotPH();
1087     PlotT0();
1088   }
1089   if ((fDebug == 4) || 
1090       (fDebug == 3)) {
1091     PlotPHDB();
1092     PlotT0DB();
1093   }
1094
1095   // Mean Statistic
1096   if (fNumberFit > 0) {
1097     AliInfo(Form("There is a mean statistic of: %d",(Int_t) fStatisticMean / fNumberFit));
1098     fStatisticMean = fStatisticMean / fNumberFit;
1099   }
1100   else {
1101     AliInfo("There is no fit!");
1102   }
1103
1104   // Write the things!
1105   if(fWriteCoef[1]) {
1106     WriteFitInfos(1);
1107   }
1108
1109   return kTRUE;
1110   
1111 }
1112
1113 //____________Functions fit Online PH2d________________________________________
1114 Bool_t AliTRDCalibra::FitPHOnline()
1115 {
1116   //
1117   // Reconstruct the average pulse height from the vectorPH for each
1118   // calibration group
1119   // Fit or use the slope of the average pulse height to reconstruct the
1120   // drift velocity write the results in a tree
1121   // A first calibration of T0 is also made  using the same method (slope method)
1122   //
1123    
1124   // Number of Xbins (detectors or groups of pads)
1125   if (!InitFit(0,0,0,1)) {
1126     return kFALSE;
1127   }
1128   fStatisticMean = 0.0;
1129   fNumberFit     = 0;
1130
1131   // Init fCountDet and fCount
1132   InitfCountDetAndfCount(1);
1133
1134   // Beginning of the loop
1135   for (Int_t idect = fDect1[1]; idect < fDect2[1]; idect++) {
1136
1137     // Search if the group is in the VectorCH
1138     Int_t place = SearchInVector(idect,1);
1139     
1140     // Is in
1141     TH1F    *projph = 0x0;
1142     TString name("PH");
1143     name += idect;
1144     if (place != -1) {
1145       // Variable
1146       AliTRDPInfo *fPHInfo = new AliTRDPInfo();
1147       // Retrieve
1148       fPHInfo = (AliTRDPInfo *) fVectorPH->At(place);
1149       projph  = CorrectTheError((TGraphErrors *) ConvertVectorPHisto(fPHInfo,(const char *) name));
1150       projph->SetDirectory(0);
1151       delete fPHInfo;
1152     }
1153
1154     // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
1155     UpdatefCountDetAndfCount(idect,1);
1156     
1157     // Reconstruction of the row and pad group: rowmin, row max ...
1158     ReconstructFitRowMinRowMax(idect,1);
1159
1160     // Rebin and statistic stuff
1161     // This detector has not enough statistics or was off
1162     if ((place == -1) || 
1163         ((place           !=          -1) && 
1164          (fEntriesCurrent <  fMinEntries))) {
1165       
1166       // Fill with the default values
1167       NotEnoughStatistic(idect,1);
1168
1169       // Memory!!!
1170       if (fDebug != 2) {
1171         delete projph;
1172       }
1173
1174       continue;
1175
1176     }
1177
1178     // Statistic of the histos fitted
1179     AliInfo(Form("For the group number %d there are %d stats",idect,fEntriesCurrent));
1180     fNumberFit++;
1181     fStatisticMean += fEntriesCurrent;
1182
1183     // Calcul of "real" coef
1184     CalculVdriftCoefMean(fCountDet[1],(Int_t) (idect - fDect1[1]));
1185     CalculT0CoefMean(fCountDet[1],(Int_t) (idect - fDect1[1]));
1186
1187     // Method Mean and fit
1188     // idect is egal for fDebug = 0 and 2, only to fill the hist 
1189     FitPente((TH1 *) projph,(Int_t) (idect - fDect1[1]));
1190
1191     // Method fit bis
1192     // idect is egal for fDebug = 0 and 2, only to fill the hist
1193     if (fFitPHOn) { 
1194       FitPH((TH1 *) projph,(Int_t) (idect - fDect1[1]));
1195     }
1196   
1197     // Visualise the detector for fDebug 3 or 4
1198     // Here is the reconstruction of the pad and row group is used!
1199     if (fDebug >= 3) {
1200       FillCoefVdriftDB();
1201       FillCoefT0DB();
1202     }
1203     
1204     // Fill the tree if end of a detector or only the pointer to the branch!!!
1205     FillInfosFit(idect,1);
1206     
1207     // Memory!!!
1208     if (fDebug != 2) {
1209       delete projph;
1210     }
1211     
1212   } // Boucle object
1213   
1214   // Error
1215   if ((fDebug == 1) || 
1216       (fDebug == 4)) {
1217     ErrorPH();
1218     ErrorT0();
1219   }
1220  
1221   // Plot
1222   // 0 no plot, 1 and 4 error plot, 3 and 4 DB plot
1223   if ((fDebug == 1) || 
1224       (fDebug == 4)) {
1225     PlotPH();
1226     PlotT0();
1227   }
1228   if ((fDebug == 4) || 
1229       (fDebug == 3)) {
1230     PlotPHDB();
1231     PlotT0DB();
1232   }
1233   
1234   // Mean Statistic
1235   if (fNumberFit > 0) {
1236     AliInfo(Form("There is a mean statistic of: %d",(Int_t) fStatisticMean / fNumberFit));
1237     fStatisticMean = fStatisticMean / fNumberFit;
1238   }
1239   else {
1240     AliInfo("There is no fit!");
1241   }
1242   
1243   // Write the things!
1244   if (fWriteCoef[1]) {
1245     WriteFitInfos(1);
1246   }
1247
1248   return kTRUE;
1249   
1250 }
1251
1252 //____________Functions fit Online PH2d________________________________________
1253 Bool_t AliTRDCalibra::FitPHOnline(TTree *tree)
1254 {
1255   //
1256   // Look if the calibration group can be found in the tree, if yes take the
1257   // histo, fit it, and write the results in a tree
1258   // A first calibration of T0 is also made  using the same method (slope method)
1259   //
1260    
1261   // Number of Xbins (detectors or groups of pads)
1262   if (!InitFit(0,0,0,1)) {
1263     return kFALSE;
1264   }
1265   fStatisticMean = 0.0;
1266   fNumberFit     = 0;
1267
1268   // For memory
1269   if (fVectorPH) {
1270     fVectorPH->Clear();
1271   }
1272   if (fPlaPH) {
1273     fPlaPH->Clear();
1274   }
1275
1276   // Init fCountDet and fCount
1277   InitfCountDetAndfCount(1);
1278   TGraphErrors *projphtree  = 0x0;
1279   tree->SetBranchAddress("histo",&projphtree);
1280   TObjArray    *vectorplace = ConvertTreeVector(tree);
1281   
1282   // Beginning of the loop
1283   for (Int_t idect = fDect1[1]; idect < fDect2[1]; idect++) {
1284
1285     // Search if the group is in the VectorCH
1286     Int_t place = SearchInTreeVector(vectorplace,idect);
1287     
1288     TH1F *projph = 0x0;
1289     // Is in
1290     if (place != -1) {
1291       // Variable
1292       tree->GetEntry(place);
1293       projph = CorrectTheError(projphtree);
1294     }
1295     
1296     // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
1297     UpdatefCountDetAndfCount(idect,1);
1298
1299     // Reconstruction of the row and pad group: rowmin, row max ...
1300     ReconstructFitRowMinRowMax(idect,1);
1301
1302     // Rebin and statistic stuff
1303     // This detector has not enough statistics or was off
1304     if((place == -1) || 
1305        ((place           !=         -1) && 
1306         (fEntriesCurrent < fMinEntries))) {
1307       
1308       // Fill with the default values
1309       NotEnoughStatistic(idect,1);
1310       
1311       // Memory!!!
1312       if (fDebug != 2) {
1313         delete projph;
1314       }
1315       
1316       continue;
1317
1318     }
1319     
1320     // Statistics of the histos fitted
1321     AliInfo(Form("For the group number %d there are %d stats",idect,fEntriesCurrent));
1322     fNumberFit++;
1323     fStatisticMean += fEntriesCurrent;
1324
1325     // Calcul of "real" coef
1326     CalculVdriftCoefMean(fCountDet[1],(Int_t) (idect - fDect1[1]));
1327     CalculT0CoefMean(fCountDet[1],(Int_t) (idect - fDect1[1]));
1328     
1329     // Method Mean and fit
1330     // idect is egal for fDebug = 0 and 2, only to fill the hist 
1331     FitPente((TH1 *) projph,(Int_t) (idect - fDect1[1]));
1332     // Method fit bis
1333     // idect is egal for fDebug = 0 and 2, only to fill the hist
1334     if (fFitPHOn) { 
1335       FitPH((TH1 *) projph,(Int_t) (idect - fDect1[1]));
1336     }
1337   
1338     // Visualise the detector for fDebug 3 or 4
1339     // Here is the reconstruction of the pad and row group is used!
1340     if (fDebug >= 3) {
1341       FillCoefVdriftDB();
1342       FillCoefT0DB();
1343     }
1344
1345     // Fill the tree if end of a detector or only the pointer to the branch!!!
1346     FillInfosFit(idect,1);
1347
1348     // Memory!!!
1349     if (fDebug != 2) {
1350       delete projph;
1351     }
1352        
1353   } // Boucle object
1354
1355   // Error
1356   if ((fDebug == 1) || 
1357       (fDebug == 4)) {
1358     ErrorPH();
1359     ErrorT0();
1360   }
1361  
1362   // Plot
1363   // 0 no plot, 1 and 4 error plot, 3 and 4 DB plot
1364   if ((fDebug == 1) || 
1365       (fDebug == 4)){
1366     PlotPH();
1367     PlotT0();
1368   }
1369   if ((fDebug == 4) || 
1370       (fDebug == 3)){
1371     PlotPHDB();
1372     PlotT0DB();
1373   }
1374
1375   // Mean Statistics
1376   if (fNumberFit > 0) {
1377     AliInfo(Form("There is a mean statistic of: %d",(Int_t) fStatisticMean / fNumberFit));
1378     fStatisticMean = fStatisticMean / fNumberFit;
1379   }
1380   else {
1381     AliInfo("There is no fit!");
1382   }
1383   
1384   // Write the things!
1385   if (fWriteCoef[1]) {
1386     WriteFitInfos(1);
1387   }
1388
1389   return kTRUE;
1390   
1391 }
1392
1393 //____________Functions fit Online PRF2d_______________________________________
1394 Bool_t AliTRDCalibra::FitPRFOnline(TProfile2D *prf)
1395 {
1396   //
1397   // Take the 1D profiles (pad response function), projections of the 2D PRF
1398   // on the Xaxis, for each calibration group
1399   // Fit with a gaussian to reconstruct the sigma of the pad response function
1400   // write the results in a tree
1401   //
1402
1403   // Number of Xbins (detectors or groups of pads)
1404   TAxis   *xprf    = prf->GetXaxis();
1405   TAxis   *yprf    = prf->GetYaxis();
1406   Int_t    nybins  = yprf->GetNbins();
1407   Int_t    nbins   = xprf->GetNbins();
1408   Double_t lowedge = xprf->GetBinLowEdge(1);
1409   Double_t upedge  = xprf->GetBinUpEdge(xprf->GetNbins());
1410   if (!InitFit(nbins,lowedge,upedge,2)) {
1411     return kFALSE;
1412   }
1413   fStatisticMean = 0.0;
1414   fNumberFit     = 0;
1415
1416   // For memory
1417   if (fVectorPRF) {
1418     fVectorPRF->Clear();
1419   }
1420   if (fPlaPRF) {
1421     fPlaPRF->Clear();
1422   }
1423   
1424   // Init fCountDet and fCount
1425   InitfCountDetAndfCount(2);
1426   
1427   // Beginning of the loop
1428   for (Int_t idect = fDect1[2]; idect < fDect2[2]; idect++) {
1429
1430     TH1D *projprf = (TH1D *) prf->ProjectionY("projprf",idect+1,idect+1,(Option_t *) "e");
1431     projprf->SetDirectory(0);
1432     
1433     // Number of entries for this calibration group
1434     Double_t nentries = 0;
1435     for (Int_t k = 0; k < nybins; k++) {
1436       nentries += prf->GetBinEntries(prf->GetBin(idect+1,k+1));
1437     }
1438     
1439     // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
1440     UpdatefCountDetAndfCount(idect,2);
1441     
1442     // Reconstruction of the row and pad group: rowmin, row max ...
1443     ReconstructFitRowMinRowMax(idect,2);
1444     
1445     // Rebin and statistic stuff
1446     // This detector has not enough statistics or was off
1447     if (nentries < fMinEntries) {
1448       
1449       // Fill with the default values
1450       NotEnoughStatistic(idect,2);
1451       
1452       // Memory!
1453       if (fDebug != 2) {
1454         delete projprf;
1455       }
1456       
1457       continue;
1458
1459     }
1460     
1461     // Statistics of the histos fitted
1462     AliInfo(Form("For the group number %d there are %f stats",idect,nentries));
1463     fNumberFit++;
1464     fStatisticMean += nentries;
1465     
1466     // Calcul of "real" coef
1467     if ((fDebug == 1) || 
1468         (fDebug == 4)) {
1469       CalculPRFCoefMean(fCountDet[2],(Int_t) (idect - fDect1[2]));
1470     }
1471     
1472     // Method Mean and fit
1473     // idect is egal for fDebug = 0 and 2, only to fill the hist 
1474     FitPRF((TH1 *) projprf,(Int_t) (idect - fDect1[2]));
1475     
1476     // Visualise the detector for fDebug 3 or 4
1477     // Here is the reconstruction of the pad and row group is used!
1478     if (fDebug >= 3) {
1479       FillCoefPRFDB();
1480     }
1481
1482     // Fill the tree if end of a detector or only the pointer to the branch!!!
1483     FillInfosFit(idect,2);
1484     
1485     // Memory!!!
1486     if (fDebug != 2) {
1487       delete projprf;
1488     }
1489     
1490   } // Boucle object
1491
1492   // Error
1493   if ((fDebug == 1) || 
1494       (fDebug == 4)) {
1495     ErrorPRF();
1496   }
1497  
1498   // Plot
1499   // No plot, 1 and 4 error plot, 3 and 4 DB plot
1500   if ((fDebug == 1) || 
1501       (fDebug == 4)) {
1502     PlotPRF();
1503   }
1504   if ((fDebug == 4) || 
1505       (fDebug == 3)){
1506     PlotPRFDB();
1507   }
1508
1509   // Mean Statistic
1510   if (fNumberFit > 0) {
1511     AliInfo(Form("There is a mean statistic of: %d",(Int_t) fStatisticMean / fNumberFit));
1512     fStatisticMean = fStatisticMean / fNumberFit;
1513   }
1514   else {
1515     AliInfo("There is no fit!");
1516   }
1517
1518   // Write the things!
1519   if (fWriteCoef[2]) {
1520     WriteFitInfos(2);
1521   }
1522
1523   return kTRUE;
1524   
1525 }
1526
1527 //____________Functions fit Online PRF2d_______________________________________
1528 Bool_t AliTRDCalibra::FitPRFOnline(TTree *tree)
1529 {
1530   //
1531   // Look if the calibration group can be found in the tree, if yes take
1532   // the histo, fit it, and write the results in a tree
1533   //
1534   
1535   // Number of Xbins (detectors or groups of pads)
1536   if (!InitFit(0,0,0,2)) {
1537     return kFALSE;
1538   }
1539   fStatisticMean = 0.0;
1540   fNumberFit     = 0;
1541
1542   // For memory
1543   if (fVectorPRF) {
1544     fVectorPRF->Clear();
1545   }
1546   if (fPlaPRF) {
1547     fPlaPRF->Clear();
1548   }
1549
1550   // Init fCountDet and fCount
1551   InitfCountDetAndfCount(2);
1552   TGraphErrors *projprftree = 0x0;
1553   tree->SetBranchAddress("histo",&projprftree);
1554   TObjArray    *vectorplace = ConvertTreeVector(tree);
1555
1556   // Beginning of the loop
1557   for (Int_t idect = fDect1[2]; idect < fDect2[2]; idect++) {
1558
1559     // Search if the group is in the VectorCH
1560     Int_t place = SearchInTreeVector(vectorplace,idect);
1561     
1562     // Is in   
1563     TH1F *projprf = 0x0;
1564     if (place != -1) {
1565       // Variable
1566       tree->GetEntry(place);
1567       projprf = CorrectTheError(projprftree);
1568     }
1569
1570     // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
1571     UpdatefCountDetAndfCount(idect,2);
1572
1573     // Reconstruction of the row and pad group: rowmin, row max ...
1574     ReconstructFitRowMinRowMax(idect,2);
1575
1576     // Rebin and statistic stuff
1577     // This detector has not enough statistics or was off
1578     if ((place == -1) ||
1579         ((place           !=          -1) &&
1580          (fEntriesCurrent  < fMinEntries))) {
1581       
1582       // Fill with the default values
1583       NotEnoughStatistic(idect,2);
1584       
1585       // Memory!!!
1586       if (fDebug != 2) {
1587         delete projprf;
1588       }
1589       
1590       continue;
1591
1592     }
1593
1594     // Statistics of the histos fitted
1595     AliInfo(Form("For the group number %d there are %d stats",idect,fEntriesCurrent));
1596     fNumberFit++;
1597     fStatisticMean += fEntriesCurrent;
1598         
1599     // Calcul of "real" coef
1600     if ((fDebug == 1) || 
1601         (fDebug == 4)){
1602       CalculPRFCoefMean(fCountDet[2],(Int_t) (idect - fDect1[2]));
1603     }
1604     
1605     // Method Mean and fit
1606     // idect is egal for fDebug = 0 and 2, only to fill the hist 
1607     FitPRF((TH1 *) projprf,(Int_t) (idect - fDect1[2]));
1608     // Visualise the detector for fDebug 3 or 4
1609     // Here is the reconstruction of the pad and row group is used!
1610     if (fDebug >= 3) {
1611       FillCoefPRFDB();
1612     }
1613     // Fill the tree if end of a detector or only the pointer to the branch!!!
1614     FillInfosFit(idect,2);
1615
1616     // Memory!!!
1617     if (fDebug != 2) {
1618       delete projprf;
1619     }                
1620     
1621   } // Boucle object
1622
1623   // Error
1624   if ((fDebug == 1) || 
1625       (fDebug == 4)) {
1626     ErrorPRF();
1627   }
1628   
1629   // Plot
1630   // No plot, 1 and 4 error plot, 3 and 4 DB plot
1631   if ((fDebug == 1) || 
1632       (fDebug == 4)){
1633     PlotPRF();
1634   }
1635   if ((fDebug == 4) || 
1636       (fDebug == 3)){
1637     PlotPRFDB();
1638   }
1639   
1640   // Mean Statistics
1641   if (fNumberFit > 0) {
1642     AliInfo(Form("There is a mean statistic of: %d",(Int_t) fStatisticMean / fNumberFit));
1643     fStatisticMean = fStatisticMean / fNumberFit;
1644   }
1645   else {
1646     AliInfo("There is no fit!");
1647   }
1648
1649   // Write the things!
1650   if (fWriteCoef[2]) {
1651     WriteFitInfos(2);
1652   }
1653
1654   return kTRUE;
1655   
1656 }
1657
1658 //____________Functions fit Online PRF2d_______________________________________
1659 Bool_t AliTRDCalibra::FitPRFOnline()
1660 {
1661   //
1662   // Reconstruct the 1D histo (pad response function) from the vectorPRD for
1663   // each calibration group
1664   // Fit with a gaussian to reconstruct the sigma of the pad response function
1665   // write the results in a tree
1666   //
1667   
1668   // Number of Xbins (detectors or groups of pads)
1669   if (!InitFit(0,0,0,2)) {
1670     return kFALSE;
1671   }
1672   fStatisticMean = 0.0;
1673   fNumberFit     = 0;
1674
1675   // Init fCountDet and fCount
1676   InitfCountDetAndfCount(2);
1677
1678   // Beginning of the loop
1679   for (Int_t idect = fDect1[2]; idect < fDect2[2]; idect++) {
1680
1681     // Search if the group is in the VectorCH
1682     Int_t place = SearchInVector(idect,2);
1683     
1684     // Is in
1685     TH1F   *projprf = 0x0;
1686     TString name("PRF");
1687     name += idect;
1688     if (place != -1) {
1689       // Variable
1690       AliTRDPInfo *fPRFInfo = new AliTRDPInfo();
1691       // Retrieve
1692       fPRFInfo = (AliTRDPInfo *) fVectorPRF->At(place);
1693       projprf = CorrectTheError((TGraphErrors *) ConvertVectorPHisto(fPRFInfo,(const char *)name));
1694       projprf->SetDirectory(0);
1695       delete fPRFInfo;
1696     }
1697
1698     // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
1699     UpdatefCountDetAndfCount(idect,2);
1700
1701     // Reconstruction of the row and pad group: rowmin, row max ...
1702     ReconstructFitRowMinRowMax(idect,2);
1703
1704     // Rebin and statistic stuff
1705     // This detector has not enough statistics or was off
1706     if ((place == -1) ||
1707         ((place           != -1) &&
1708          (fEntriesCurrent < fMinEntries))) {
1709
1710       // Fill with the default values
1711       NotEnoughStatistic(idect,2);
1712
1713       // Memory
1714       if (fDebug != 2) {
1715         delete projprf;
1716       }
1717
1718       continue;
1719
1720     }
1721
1722     // Statistic of the histos fitted
1723     AliInfo(Form("For the group number %d there are %d stats", idect,fEntriesCurrent));
1724     fNumberFit++;
1725     fStatisticMean += fEntriesCurrent;
1726
1727     // Calcul of "real" coef
1728     if ((fDebug == 1) || 
1729         (fDebug == 4)) {
1730       CalculPRFCoefMean(fCountDet[2],(Int_t) (idect-fDect1[2]));
1731     }
1732
1733     // Method Mean and fit
1734     // idect is egal for fDebug = 0 and 2, only to fill the hist 
1735     FitPRF((TH1 *) projprf,(Int_t) (idect-fDect1[2]));
1736     // Visualise the detector for fDebug 3 or 4
1737     // Here is the reconstruction of the pad and row group is used!
1738     if (fDebug >= 3) {
1739       FillCoefPRFDB();
1740     }
1741     // Fill the tree if end of a detector or only the pointer to the branch!!!
1742     FillInfosFit(idect,2);
1743                     
1744     // Memory!!!
1745     if (fDebug != 2) {
1746       delete projprf;
1747     }
1748     
1749   } // Boucle object
1750
1751   // Error
1752   if ((fDebug == 1) || 
1753       (fDebug == 4)) {
1754     ErrorPRF();
1755   }
1756  
1757   // Plot
1758   // No plot, 1 and 4 error plot, 3 and 4 DB plot
1759   if ((fDebug == 1) || 
1760       (fDebug == 4)) {
1761     PlotPRF();
1762   }
1763   if ((fDebug == 4) || 
1764       (fDebug == 3)) {
1765     PlotPRFDB();
1766   }
1767
1768   // Mean Statistics
1769   if (fNumberFit > 0) {
1770     AliInfo(Form("There is a mean statistic of: %d",(Int_t) fStatisticMean / fNumberFit));
1771   }
1772   else {
1773     AliInfo("There is no fit!");
1774   }
1775
1776   // Write the things!
1777   if (fWriteCoef[2]) {
1778     WriteFitInfos(2);
1779   }
1780
1781   return kTRUE;
1782   
1783 }
1784
1785 //____________Functions for initialising the AliTRDCalibra in the code_________
1786 Bool_t AliTRDCalibra::Init2Dhistos()
1787 {
1788   //
1789   // For the offline tracking
1790   // This function will be called in the function AliReconstruction::Run() 
1791   // Init the calibration mode (Nz, Nrphi), the 2D histograms if fHisto2d = kTRUE, 
1792   //
1793
1794   // DB Setting
1795   // Get cal
1796   AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
1797   if (!cal) {
1798     AliInfo("Could not get calibDB");
1799     return kFALSE;
1800   }
1801
1802   // Some parameters
1803   fTimeMax = cal->GetNumberOfTimeBins();
1804   fSf      = cal->GetSamplingFrequency();
1805   if (fRelativeScaleAuto) {
1806     fRelativeScale = 0;
1807   }
1808   else {
1809     fRelativeScale = 20;
1810   }
1811
1812   // Create the 2D histos corresponding to the pad groupCalibration mode
1813   if (fCH2dOn) {
1814
1815     AliInfo(Form("The pad calibration mode for the relative gain calibration: Nz %d, and Nrphi %d"
1816                 ,fNz[0]
1817                 ,fNrphi[0]));
1818     
1819     // Calcul the number of Xbins
1820     fNtotal[0] = 0;
1821     ModePadCalibration(2,0);
1822     ModePadFragmentation(0,2,0,0);
1823     fDetChamb2[0] = fNfragZ[0] * fNfragRphi[0];
1824     if (fDebug == 4) {
1825       AliInfo(Form("For the chamber 2: %d",fDetChamb2[0]));
1826     }
1827     fNtotal[0] += 6 * 18 * fDetChamb2[0];
1828     ModePadCalibration(0,0);
1829     ModePadFragmentation(0,0,0,0);
1830     fDetChamb0[0] = fNfragZ[0] * fNfragRphi[0];
1831     if (fDebug == 4) {
1832       AliInfo(Form("For the other chamber 0: %d",fDetChamb0[0]));
1833     }
1834     fNtotal[0] += 6 * 4 * 18 * fDetChamb0[0];
1835     AliInfo(Form("Total number of Xbins: %d",fNtotal[0]));
1836
1837     // Create the 2D histo
1838     if (fHisto2d) {
1839       CreateCH2d(fNtotal[0]);
1840     }
1841     if (fVector2d) {
1842       fVectorCH = new TObjArray();
1843       fPlaCH    = new TObjArray();
1844     }
1845
1846     // Variable
1847     fAmpTotal = new Float_t[TMath::Max(fDetChamb2[0],fDetChamb0[0])];
1848     for (Int_t k = 0; k < TMath::Max(fDetChamb2[0],fDetChamb0[0]); k++) {
1849       fAmpTotal[k] = 0.0;
1850     } 
1851
1852   }
1853
1854   if (fPH2dOn) {
1855
1856     AliInfo(Form("The pad calibration mode for the drift velocity calibration: Nz %d, and Nrphi %d"
1857                 ,fNz[1]
1858                 ,fNrphi[1]));
1859     
1860     // Calcul the number of Xbins
1861     fNtotal[1] = 0;
1862     ModePadCalibration(2,1);
1863     ModePadFragmentation(0,2,0,1);
1864     fDetChamb2[1] = fNfragZ[1]*fNfragRphi[1];
1865     if (fDebug == 4) {
1866       AliInfo(Form("For the chamber 2: %d",fDetChamb2[1]));
1867     }
1868     fNtotal[1] += 6 * 18 * fDetChamb2[1];
1869     ModePadCalibration(0,1);
1870     ModePadFragmentation(0,0,0,1);
1871     fDetChamb0[1] = fNfragZ[1] * fNfragRphi[1];
1872     if (fDebug == 4) {
1873       AliInfo(Form("For the chamber 0: %d",fDetChamb0[1]));
1874     }
1875     fNtotal[1] += 6 * 4 * 18 * fDetChamb0[1];
1876     AliInfo(Form("Total number of Xbins: %d",fNtotal[1]));
1877
1878     // Create the 2D histo
1879     if (fHisto2d) {
1880       CreatePH2d(fNtotal[1]);
1881     }
1882     if (fVector2d) {
1883       fVectorPH = new TObjArray();
1884       fPlaPH    = new TObjArray();
1885     }
1886    
1887     // Variable
1888     fPHPlace = new Short_t[fTimeMax];
1889     for (Int_t k = 0; k < fTimeMax; k++) {
1890       fPHPlace[k] = -1;
1891     } 
1892     fPHValue = new Float_t[fTimeMax];
1893     for (Int_t k = 0; k < fTimeMax; k++) {
1894       fPHValue[k] = -1.0;
1895     }
1896
1897   }
1898
1899   if (fPRF2dOn) {
1900
1901     AliInfo(Form("The pad calibration mode for the PRF calibration: Nz %d, and Nrphi %d"
1902                 ,fNz[2]
1903                 ,fNrphi[2]));
1904     
1905     // Calcul the number of Xbins
1906     fNtotal[2] = 0;
1907     ModePadCalibration(2,2);
1908     ModePadFragmentation(0,2,0,2);
1909     fDetChamb2[2] = fNfragZ[2] * fNfragRphi[2];
1910     if (fDebug == 4) {
1911       AliInfo(Form("For the chamber 2: %d",fDetChamb2[2]));
1912     }
1913     fNtotal[2] += 6 * 18 * fDetChamb2[2];
1914     ModePadCalibration(0,2);
1915     ModePadFragmentation(0,0,0,2);
1916     fDetChamb0[2] = fNfragZ[2] * fNfragRphi[2];
1917     if (fDebug == 4) {
1918       AliInfo(Form("For the chamber 0: %d",fDetChamb0[2]));
1919     }
1920     fNtotal[2] += 6 * 4 * 18 * fDetChamb0[2];
1921     AliInfo(Form("Total number of Xbins: %d",fNtotal[2]));
1922
1923     // Create the 2D histo
1924     if (fHisto2d) {
1925       CreatePRF2d(fNtotal[2]);
1926     }
1927     if (fVector2d) {
1928       fVectorPRF = new TObjArray();
1929       fPlaPRF    = new TObjArray();
1930     }
1931   
1932   }
1933
1934   return kTRUE;
1935
1936 }
1937
1938 //____________Functions for filling the histos in the code_____________________
1939
1940 //____________Offine tracking in the AliTRDtracker_____________________________
1941 Bool_t AliTRDCalibra::ResetTrack()
1942 {
1943   //
1944   // For the offline tracking
1945   // This function will be called in the function
1946   // AliTRDtracker::FollowBackPropagation() at the beginning 
1947   // Reset the parameter to know we have a new TRD track
1948   //
1949   
1950   fDetectorAliTRDtrack = kFALSE;
1951   return kTRUE;
1952
1953 }
1954
1955 //____________Offline tracking in the AliTRDtracker____________________________
1956 Bool_t AliTRDCalibra::UpdateHistograms(AliTRDcluster *cl, AliTRDtrack *t)
1957 {
1958   //
1959   // For the offline tracking
1960   // This function will be called in the function
1961   // AliTRDtracker::FollowBackPropagation() in the loop over the clusters
1962   // of TRD tracks 
1963   // Fill the 2D histos or the vectors with the info of the clusters at
1964   // the end of a detectors if the track is "good"
1965   //
1966
1967   // Get the parameter object
1968   AliTRDCommonParam *parCom = AliTRDCommonParam::Instance();
1969   if (!parCom) {
1970     AliInfo("Could not get CommonParam");
1971     return kFALSE;
1972   }
1973
1974   // Get the parameter object
1975   AliTRDcalibDB     *cal    = AliTRDcalibDB::Instance();
1976   if (!cal) {
1977     AliInfo("Could not get calibDB");
1978     return kFALSE;
1979   }
1980  
1981   // Localisation of the detector
1982   Int_t detector = cl->GetDetector();
1983   Int_t chamber  = GetChamber(detector);
1984   Int_t plane    = GetPlane(detector);
1985
1986   // Fill the infos for the previous clusters if not the same
1987   // detector anymore or if not the same track
1988   if (((detector != fDetectorPreviousTrack) || (!fDetectorAliTRDtrack)) && 
1989       (fDetectorPreviousTrack != -1)) {
1990
1991     fNumberTrack++;   
1992     
1993     // If the same track, then look if the previous detector is in
1994     // the same plane, if yes: not a good track
1995     if (fDetectorAliTRDtrack && 
1996         (GetPlane(detector) <= GetPlane(fDetectorPreviousTrack))) {
1997       fGoodTrack = kFALSE;
1998     }
1999
2000     // Fill only if the track doesn't touch a masked pad or doesn't
2001     // appear in the middle (fGoodTrack)
2002     if (fGoodTrack) {
2003
2004       // Gain calibration
2005       if (fCH2dOn) {
2006         FillTheInfoOfTheTrackCH();
2007       }
2008
2009       // PH calibration
2010       if (fPH2dOn) {
2011         FillTheInfoOfTheTrackPH();    
2012       }
2013     
2014     } // if a good track
2015     
2016     ResetfVariables();
2017    
2018   } // Fill at the end the charge
2019   
2020   // Calcul the position of the detector
2021   if (detector != fDetectorPreviousTrack) {
2022     LocalisationDetectorXbins(detector);
2023   }
2024
2025   // Reset the good track for the PRF
2026   Bool_t good = kTRUE;
2027   
2028   // Localisation of the cluster
2029   Double_t pos[3] = { 0.0, 0.0, 0.0 };
2030   pos[0] = cl->GetX();
2031   pos[1] = cl->GetY();
2032   pos[2] = cl->GetZ();
2033   Int_t    time   = cl->GetLocalTimeBin();
2034   
2035   // Reset the detector
2036   fDetectorPreviousTrack = detector;
2037   fDetectorAliTRDtrack   = kTRUE;
2038   
2039   // Position of the cluster
2040   AliTRDpadPlane *padplane = parCom->GetPadPlane(plane,chamber);
2041   Int_t    row        = padplane->GetPadRowNumber(pos[2]);
2042   Double_t offsetz    = padplane->GetPadRowOffset(row,pos[2]);
2043   Double_t offsettilt = padplane->GetTiltOffset(offsetz);
2044   Int_t    col        = padplane->GetPadColNumber(pos[1] + offsettilt,offsetz);
2045   
2046   // See if we are not near a masked pad
2047   if (!IsPadOn(detector,col,row)) {
2048     good       = kFALSE;
2049     fGoodTrack = kFALSE;
2050   }
2051
2052   if (col > 0) {
2053     if (!IsPadOn(detector,col-1,row)) {
2054       fGoodTrack = kFALSE;
2055       good       = kFALSE;
2056     }
2057   }
2058
2059   if (col < 143) {
2060     if (!IsPadOn(detector,col+1,row)) {
2061       fGoodTrack = kFALSE;
2062       good       = kFALSE;
2063     }
2064   }
2065
2066   // Row of the cluster and position in the pad groups
2067   Int_t posr[3] = { 0, 0, 0 };
2068   if ((fCH2dOn)  && (fNnZ[0] != 0)) {
2069     posr[0] = (Int_t) row / fNnZ[0];
2070   }
2071   if ((fPH2dOn)  && (fNnZ[1] != 0)) {
2072     posr[1] = (Int_t) row / fNnZ[1];
2073   }
2074   if ((fPRF2dOn) && (fNnZ[2] != 0)) {
2075     posr[2] = (Int_t) row / fNnZ[2];
2076   }  
2077       
2078   // Col of the cluster and position in the pad groups
2079   Int_t posc[3] = { 0, 0, 0 };
2080   if ((fCH2dOn)  && (fNnRphi[0] != 0)) {
2081     posc[0] = (Int_t) col / fNnRphi[0];
2082   }
2083   if ((fPH2dOn)  && (fNnRphi[1] != 0)) {
2084     posc[1] = (Int_t) col / fNnRphi[1];
2085   }
2086   if ((fPRF2dOn) && (fNnRphi[2] != 0)) {
2087     posc[2] = (Int_t) col / fNnRphi[2];
2088   }
2089
2090   // Charge in the cluster
2091   // For the moment take the abs
2092   Float_t  q       = TMath::Abs(cl->GetQ());
2093   Short_t *signals = cl->GetSignals();
2094
2095   // Correction due to the track angle
2096   Float_t correction    = 1.0;
2097   Float_t normalisation = 6.67;
2098   if ((q >0) && (t->GetNdedx() > 0)) {
2099     correction = t->GetClusterdQdl((t->GetNdedx() - 1)) / (q * normalisation);
2100   }
2101
2102   // Fill the fAmpTotal with the charge
2103   if (fCH2dOn) {
2104     if (!fTraMaxPad){ 
2105       fAmpTotal[(Int_t) (posc[0]*fNfragZ[0]+posr[0])] += q * correction;
2106     }
2107     else {
2108       fAmpTotal[(Int_t) (posc[0]*fNfragZ[0]+posr[0])] += ((Float_t) signals[3]) * correction;
2109     }
2110   }
2111
2112   // Fill the fPHPlace and value
2113   if (fPH2dOn) {
2114     fPHPlace[time] = posc[1]*fNfragZ[1]+posr[1];
2115     if (!fTraMaxPad) {
2116       fPHValue[time] = q * correction;
2117     }
2118     else {
2119       fPHValue[time] = ((Float_t) signals[3]) * correction;
2120     }
2121   }
2122
2123   // Fill direct the PRF
2124   if ((fPRF2dOn) && (good)) {
2125
2126     Float_t yminus  = 0.0;
2127     Float_t xcenter = 0.0;
2128     Float_t ycenter = 0.0;
2129     Float_t ymax    = 0.0;
2130     Bool_t  echec   = kFALSE;
2131     
2132     if ((cl->From3pad()) && (!cl->IsUsed())) { 
2133          
2134       // Center 3 balanced
2135       if ((((Float_t) signals[3]) > fThresholdClusterPRF2) && 
2136           (((Float_t) signals[2]) > fThresholdClusterPRF2) && 
2137           (((Float_t) signals[4]) > fThresholdClusterPRF2) && 
2138           (((Float_t) signals[1]) < fThresholdClusterPRF1) && 
2139           (((Float_t) signals[5]) < fThresholdClusterPRF1) && 
2140           (q * correction > 130.0)) {
2141         // Col correspond to signals[3]
2142         if (fCenterOfflineCluster) {
2143           xcenter = cl->GetCenter();
2144         }
2145         else {
2146           // Security of the denomiateur is 0
2147           if ((((Float_t) (((Float_t) signals[3]) * ((Float_t) signals[3]))) / 
2148                            ((Float_t) (((Float_t) signals[2]) * ((Float_t) signals[4])))) != 1.0) {
2149             xcenter = 0.5 * (TMath::Log((Float_t) (((Float_t) signals[4]) / ((Float_t) signals[2]))))
2150                           / (TMath::Log(((Float_t) (((Float_t) signals[3]) * ((Float_t) signals[3]))) 
2151                                       / ((Float_t) (((Float_t) signals[2]) * ((Float_t) signals[4])))));
2152           }
2153           else {
2154             xcenter = -100.0;
2155           }
2156         }
2157         if ((xcenter > -0.5) && (xcenter < 0.5)) {
2158           ycenter = (Float_t) (((Float_t) signals[3]) 
2159                             / (((Float_t) signals[2]) + ((Float_t) signals[3]) + (((Float_t) signals[4]))));
2160           yminus  = (Float_t) (((Float_t) signals[2]) 
2161                             / (((Float_t) signals[2]) + ((Float_t) signals[3]) + (((Float_t) signals[4]))));
2162           ymax    = (Float_t) (((Float_t) signals[4]) 
2163                             / (((Float_t) signals[2]) + ((Float_t) signals[3]) + (((Float_t) signals[4]))));
2164           if ((ycenter > 0.485) && 
2165               (TMath::Abs(((Float_t) signals[2]) + ((Float_t) signals[3]) + (((Float_t) signals[4])) - q) < 8.0)) {
2166             echec = kTRUE;
2167           }
2168         }
2169       }
2170       
2171       // Fill only if it is in the drift region!
2172       if ((((Float_t) (((Float_t) time) / fSf)) > 0.3) && (echec)) {
2173         if (fHisto2d) {
2174           fPRF2d->Fill((fXbins[2]+posc[2]*fNfragZ[2]+posr[2]+0.5),xcenter,ycenter);
2175           if (xcenter < 0.0) {
2176             fPRF2d->Fill((fXbins[2]+posc[2]*fNfragZ[2]+posr[2]+0.5),-(xcenter+1.0),yminus);
2177           }
2178           if (xcenter > 0.0) {
2179             fPRF2d->Fill((fXbins[2]+posc[2]*fNfragZ[2]+posr[2]+0.5),1.0-xcenter,ymax);
2180           }
2181         }
2182         if (fVector2d) {
2183           UpdateVectorPRF(fXbins[2]+posc[2]*fNfragZ[2]+posr[2],xcenter,ycenter);
2184           if (xcenter < 0.0) {
2185             UpdateVectorPRF(fXbins[2]+posc[2]*fNfragZ[2]+posr[2],-(xcenter+1.0),yminus);
2186           }
2187           if (xcenter > 0.0) {
2188             UpdateVectorPRF(fXbins[2]+posc[2]*fNfragZ[2]+posr[2],1.0-xcenter,ymax);
2189           }
2190         }
2191       } // If in the drift region
2192
2193     } // Cluster isole
2194
2195   } // PRF2dOn  
2196   
2197   return kTRUE;
2198   
2199 }
2200
2201 //____________Online trackling in AliTRDtrigger________________________________
2202 Bool_t AliTRDCalibra::UpdateHistogramcm(AliTRDmcmTracklet *trk)
2203 {
2204   //
2205   // For the tracking
2206   // This function will be called in the function AliTRDtrigger::TestTracklet
2207   // before applying the pt cut on the tracklets 
2208   // Fill the infos for the tracklets fTrkTest if the tracklets is "good"
2209   //
2210   
2211   // Localisation of the Xbins involved
2212   Int_t idect = trk->GetDetector();
2213   LocalisationDetectorXbins(idect);
2214
2215   // Get the parameter object
2216   AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
2217   if (!cal) {
2218     AliInfo("Could not get calibDB");
2219     return kFALSE;
2220   }
2221    
2222   // Reset
2223   ResetfVariables();
2224
2225   // Row of the tracklet and position in the pad groups
2226   Int_t row     = trk->GetRow();
2227   Int_t posr[3] = { 0, 0, 0 };
2228   if ((fCH2dOn)  && (fNnZ[0] != 0)) {
2229     posr[0] = (Int_t) row / fNnZ[0];
2230   }
2231   if ((fPH2dOn)  && (fNnZ[1] != 0)) {
2232     posr[1] = (Int_t) row / fNnZ[1];
2233   }
2234   if ((fPRF2dOn) && (fNnZ[2] != 0)) {
2235     posr[2] = (Int_t) row / fNnZ[2];
2236   }
2237  
2238   // Eventuelle correction due to track angle in z direction
2239   Float_t correction = 1.0;
2240   if (fMcmCorrectAngle) {
2241     Float_t z = trk->GetRowz();
2242     Float_t r = trk->GetTime0();
2243     correction = r / TMath::Sqrt((r*r+z*z));
2244   }
2245
2246   // Boucle sur les clusters
2247   // Condition on number of cluster: don't come from the middle of the detector
2248   if (trk->GetNclusters() >= fNumberClusters) {
2249
2250     for (Int_t icl = 0; icl < trk->GetNclusters(); icl++) {
2251
2252       Float_t amp[3] = { 0.0, 0.0, 0.0 };
2253       Int_t   time   = trk->GetClusterTime(icl);
2254       Int_t   col    = trk->GetClusterCol(icl);
2255             
2256       amp[0] = trk->GetClusterADC(icl)[0] * correction;
2257       amp[1] = trk->GetClusterADC(icl)[1] * correction;
2258       amp[2] = trk->GetClusterADC(icl)[2] * correction;
2259            
2260       if ((amp[0] < 0.0) || 
2261           (amp[1] < 0.0) || 
2262           (amp[2] < 0.0)) {
2263         continue;
2264       }
2265
2266       // Col of cluster and position in the pad groups
2267       Int_t posc[3] = { 0, 0, 0 };
2268       if ((fCH2dOn)  && (fNnRphi[0] != 0)) {
2269         posc[0] = (Int_t) col / fNnRphi[0];
2270       }
2271       if ((fPH2dOn)  && (fNnRphi[1] != 0)) {
2272         posc[1] = (Int_t) col / fNnRphi[1];
2273       }
2274       if ((fPRF2dOn) && (fNnRphi[2] != 0)) {
2275         posc[2] = (Int_t) col / fNnRphi[2];
2276       }
2277
2278       // See if we are not near a masked pad
2279       Bool_t good = kTRUE;
2280       if (!IsPadOn(idect,col,row)) {
2281         fGoodTrack = kFALSE;
2282         good       = kFALSE;
2283       }
2284
2285       if (col >   0) {
2286         if (!IsPadOn(idect,col-1,row)) {
2287           fGoodTrack = kFALSE;
2288           good       = kFALSE;
2289         }
2290       }
2291       
2292       if (col < 143) {
2293         if (!IsPadOn(idect,col+1,row)) {
2294           fGoodTrack = kFALSE;
2295           good       = kFALSE;
2296         }
2297       }
2298
2299       // Total spectrum
2300       if (fPH2dOn) {
2301         fPHPlace[time] = posc[1] * fNfragZ[1] + posr[1];
2302       }
2303
2304       if (!fTraMaxPad) {
2305         if (fCH2dOn) {
2306           fAmpTotal[(Int_t) (posc[0]*fNfragZ[0]+posr[0])] += (Float_t) (amp[0]+amp[1]+amp[2]);
2307         }
2308         if (fPH2dOn) {
2309           fPHValue[time] = (Float_t) (amp[0]+amp[1]+amp[2]);
2310         }
2311       }
2312       else {
2313         if (fCH2dOn) {
2314           fAmpTotal[(Int_t) (posc[0]*fNfragZ[0]+posr[0])] += (Float_t) amp[1];
2315         }
2316         if (fPH2dOn) {
2317           fPHValue[time] = amp[1];
2318         }
2319       }
2320             
2321       // Fill PRF direct
2322       if (fPRF2dOn && good) {
2323         if ((amp[0] > fThresholdClusterPRF2) && 
2324             (amp[1] > fThresholdClusterPRF2) && 
2325             (amp[2] > fThresholdClusterPRF2) && 
2326             ((amp[0]+amp[1]+amp[2]) > 130.0)) {
2327           // Security of the denomiateur is 0
2328           if ((((Float_t) (((Float_t) amp[1]) * ((Float_t) amp[1]))) 
2329              / ((Float_t) (((Float_t) amp[0]) * ((Float_t) amp[2])))) != 1.0) {
2330             Float_t xcenter = 0.5 * (TMath::Log(amp[2] / amp[0]))
2331                                   / (TMath::Log((amp[1]*amp[1]) / (amp[0]*amp[2])));
2332             Float_t ycenter = amp[1] / (amp[0] + amp[1] + amp[2]);
2333             if ((xcenter > -0.5) && 
2334                 (xcenter <  0.5) && 
2335                 (ycenter >  0.485)) {
2336               Float_t yminus = amp[0] / (amp[0]+amp[1]+amp[2]);
2337               Float_t ymax   = amp[2] / (amp[0]+amp[1]+amp[2]);
2338               // Fill only if it is in the drift region!
2339               if (((Float_t) time / fSf) > 0.3) {
2340                 if (fHisto2d) {
2341                   fPRF2d->Fill((fXbins[2]+posc[2]*fNfragZ[2]+posr[2]+0.5),xcenter,ycenter);
2342                   if (xcenter < 0.0) {
2343                     fPRF2d->Fill((fXbins[2]+posc[2]*fNfragZ[2]+posr[2]+0.5),-(xcenter+1.0),yminus);
2344                   }
2345                   if (xcenter > 0.0) {
2346                     fPRF2d->Fill((fXbins[2]+posc[2]*fNfragZ[2]+posr[2]+0.5),(1.0-xcenter),ymax);
2347                   }
2348                 }
2349                 if (fVector2d) {
2350                   UpdateVectorPRF((fXbins[2]+posc[2]*fNfragZ[2]+posr[2]),xcenter,ycenter);
2351                   if (xcenter < 0.0) {
2352                     UpdateVectorPRF(fXbins[2]+posc[2]*fNfragZ[2]+posr[2],-(xcenter+1.0),yminus);
2353                   }
2354                   if (xcenter > 0.0) {
2355                     UpdateVectorPRF(fXbins[2]+posc[2]*fNfragZ[2]+posr[2],(1.0-xcenter),ymax);
2356                   }
2357                 }
2358               } 
2359             }
2360           }
2361         }
2362       }
2363       
2364     } // Boucle clusters
2365     
2366     // Fill the charge
2367     if (fCH2dOn && fGoodTrack) {
2368       FillTheInfoOfTheTrackCH();
2369     }
2370
2371     // PH calibration
2372     if (fPH2dOn && fGoodTrack) {
2373       FillTheInfoOfTheTrackPH();        
2374     }
2375         
2376   } // Condition on number of clusters
2377
2378   return kTRUE;
2379   
2380 }
2381
2382 //____________Functions for seeing if the pad is really okey___________________
2383
2384 //_____________________________________________________________________________
2385 Bool_t AliTRDCalibra::SetModeCalibrationFromTObject(TObject *object, Int_t i)
2386 {
2387   //
2388   // Set fNz[i] and fNrphi[i] of the AliTRDCalibra::Instance()
2389   // corresponding to the given TObject
2390   //
2391
2392   const char *nametitle = object->GetTitle();
2393
2394   // Some patterns
2395   const Char_t *patternz0    = "Nz0";
2396   const Char_t *patternz1    = "Nz1";
2397   const Char_t *patternz2    = "Nz2";
2398   const Char_t *patternz3    = "Nz3";
2399   const Char_t *patternz4    = "Nz4";
2400   const Char_t *patternrphi0 = "Nrphi0";
2401   const Char_t *patternrphi1 = "Nrphi1";
2402   const Char_t *patternrphi2 = "Nrphi2";
2403   const Char_t *patternrphi3 = "Nrphi3";
2404   const Char_t *patternrphi4 = "Nrphi4";
2405   const Char_t *patternrphi5 = "Nrphi5";
2406   const Char_t *patternrphi6 = "Nrphi6";
2407
2408   UShort_t testz    = 0;
2409   UShort_t testrphi = 0;
2410
2411   // Nz mode
2412   if (strstr(nametitle,patternz0)) {
2413     testz++;
2414     fNz[i] = 0;
2415   }
2416   if (strstr(nametitle,patternz1)) {
2417     testz++;
2418     fNz[i] = 1;
2419   }
2420   if (strstr(nametitle,patternz2)) {
2421     testz++;
2422     fNz[i] = 2;
2423   }
2424   if (strstr(nametitle,patternz3)) {
2425     testz++;
2426     fNz[i] = 3;
2427   }
2428   if (strstr(nametitle,patternz4)) {
2429     testz++;
2430     fNz[i] = 4;
2431   }
2432
2433   // Nrphi mode
2434   if (strstr(nametitle,patternrphi0)) {
2435     testrphi++;
2436     fNrphi[i] = 0;
2437   }
2438   if (strstr(nametitle,patternrphi1)) {
2439     testrphi++;
2440     fNrphi[i] = 1;
2441   }
2442   if (strstr(nametitle,patternrphi2)) {
2443     testrphi++;
2444     fNrphi[i] = 2;
2445   }
2446   if (strstr(nametitle,patternrphi3)) {
2447     testrphi++;
2448     fNrphi[i] = 3;
2449   }
2450   if (strstr(nametitle,patternrphi4)) {
2451     testrphi++;
2452     fNrphi[i] = 4;
2453   }
2454   if (strstr(nametitle,patternrphi5)) {
2455     testrphi++;
2456     fNrphi[i] = 5;
2457   }
2458   if (strstr(nametitle,patternrphi6)) {
2459     testrphi++;
2460     fNrphi[i] = 6;
2461   }
2462  
2463   // Look if all is okey
2464   if ((testz    == 1) && 
2465       (testrphi == 1)) {
2466     return kTRUE;
2467   }
2468   else {
2469     fNrphi[i] = 0;
2470     fNz[i]    = 0;
2471     return kFALSE;
2472   }
2473   
2474 }
2475
2476 //_____________________________________________________________________________
2477 Bool_t AliTRDCalibra::IsPadOn(Int_t detector, Int_t col, Int_t row) const
2478 {
2479   //
2480   // Look in the choosen database if the pad is On.
2481   // If no the track will be "not good"
2482   //
2483
2484   // Get the parameter object
2485   AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
2486   if (!cal) {
2487     AliInfo("Could not get calibDB");
2488     return kFALSE;
2489   }
2490   
2491   Int_t npads  = 18;
2492   Int_t colmcm = (Int_t) col / npads;
2493   
2494   if (!cal->IsChamberInstalled(detector)     || 
2495        cal->IsChamberMasked(detector)        || 
2496        cal->IsMCMMasked(detector,colmcm,row) || 
2497        cal->IsPadMasked(detector,col,row)) {
2498     return kFALSE;
2499   }
2500   else {
2501     return kTRUE;
2502   }
2503   
2504 }
2505
2506 //____________Functions for plotting the 2D____________________________________
2507
2508 //_____________________________________________________________________________
2509 void AliTRDCalibra::Plot2d()
2510 {
2511   //
2512   // Plot the 2D histos 
2513   //
2514  
2515   if (fCH2dOn) {
2516     PlotCH2d();
2517   }
2518   if (fPH2dOn) {
2519     PlotPH2d();
2520   }
2521   if (fPRF2dOn) {
2522     PlotPRF2d();
2523   }
2524
2525 }
2526
2527 //____________Writing the 2D___________________________________________________
2528
2529 //_____________________________________________________________________________
2530 Bool_t AliTRDCalibra::Write2d()
2531 {
2532   //
2533   // Write the 2D histograms or the vectors converted in trees in the file
2534   // "TRD.calibration.root" 
2535   //
2536   
2537   TFile *fout = TFile::Open(fWriteName,"RECREATE");
2538   // Check if the file could be opened
2539   if (!fout || !fout->IsOpen()) {
2540     AliInfo("No File found!");
2541     return kFALSE;
2542   }
2543   AliInfo(Form("Numbertrack: %d Numberusedch[0]: %d, Numberusedch[1]: %d Numberusedph[0]: %d, Numberusedph[1]: %d"
2544               ,fNumberTrack
2545               ,fNumberUsedCh[0]
2546               ,fNumberUsedCh[1]
2547               ,fNumberUsedPh[0]
2548               ,fNumberUsedPh[1]));
2549   
2550   TStopwatch stopwatch;
2551   stopwatch.Start();
2552   AliInfo("Write2d");
2553
2554   if ((fCH2dOn ) && (fWrite[0])) {
2555     if (fHisto2d) {
2556       fout->WriteTObject(fCH2d);
2557     }
2558     if (fVector2d) {
2559       TString name("Nz");
2560       name += fNz[0];
2561       name += "Nrphi";
2562       name += fNrphi[0];
2563       TTree *treeCH2d = ConvertVectorCTTreeHisto(fVectorCH,fPlaCH,"treeCH2d",(const char *) name);
2564       fout->WriteTObject(treeCH2d);
2565     }
2566   }
2567   if ((fPH2dOn ) && (fWrite[1])) {
2568     if (fHisto2d) {
2569       fout->WriteTObject(fPH2d);
2570     }
2571     if (fVector2d) {
2572       TString name("Nz");
2573       name += fNz[1];
2574       name += "Nrphi";
2575       name += fNrphi[1];
2576       TTree *treePH2d = ConvertVectorPTreeHisto(fVectorPH,fPlaPH,"treePH2d",(const char *) name);
2577       fout->WriteTObject(treePH2d);
2578     }
2579   }
2580   if ((fPRF2dOn ) && (fWrite[2])) {
2581     if (fHisto2d) {
2582       fout->WriteTObject(fPRF2d);
2583     }
2584     if (fVector2d) {
2585       TString name("Nz");
2586       name += fNz[2];
2587       name += "Nrphi";
2588       name += fNrphi[2];
2589       TTree *treePRF2d = ConvertVectorPTreeHisto(fVectorPRF,fPlaPRF,"treePRF2d",(const char *) name);
2590       fout->WriteTObject(treePRF2d);
2591     }
2592   }
2593   
2594   fout->Close();
2595   
2596   AliInfo(Form("Execution time Write2d: R:%.2fs C:%.2fs"
2597               ,stopwatch.RealTime(),stopwatch.CpuTime()));
2598
2599   return kTRUE;
2600   
2601 }
2602
2603 //_____________________________________________________________________________
2604 AliTRDCalDet *AliTRDCalibra::CreateDetObjectTree(TTree *tree, Int_t i)
2605 {
2606   //
2607   // It creates the AliTRDCalDet object from the tree of the coefficient
2608   // for the calibration i (i != 2)
2609   // It takes the mean value of the coefficients per detector 
2610   // This object has to be written in the database
2611   //
2612   
2613   // Create the DetObject
2614   AliTRDCalDet *object = 0x0;
2615   if (i == 0) {
2616     object = new AliTRDCalDet("ChamberGainFactor","GainFactor (detector value)");
2617   }
2618   if (i == 1) {
2619     object = new AliTRDCalDet("ChamberVdrift","TRD drift velocities (detector value)");
2620   }
2621   else {
2622     object = new AliTRDCalDet("ChamberT0","T0 (detector value)");
2623   }
2624   
2625   // Read the Tree
2626   Int_t   detector = -1;
2627   Float_t values[2304];
2628   tree->SetBranchAddress("detector",&detector);
2629   if (i == 0) {
2630     tree->SetBranchAddress("gainPad",values);
2631   }
2632   if (i == 1) {
2633     tree->SetBranchAddress("vdrift" ,values);
2634   }
2635   if (i == 3) {
2636     tree->SetBranchAddress("t0"     ,values);
2637   }
2638   
2639   // For calculating the mean
2640   Float_t mean            = 0.0;
2641   Int_t   nto             = 0;
2642   Int_t   numberofentries = tree->GetEntries();
2643   
2644   if (numberofentries != 540) {
2645     AliInfo("The tree is not complete");
2646   }
2647   
2648   for (Int_t det = 0; det < numberofentries; ++det) {
2649     tree->GetEntry(det);
2650     if (GetChamber(detector) == 2) {
2651       nto = 1728;
2652     }
2653     else {
2654       nto = 2304;
2655     }
2656     mean = 0.0;
2657     for (Int_t k = 0; k < nto; k++) {
2658       mean += TMath::Abs(values[k]) / nto;  
2659     }
2660     object->SetValue(detector,mean);
2661   }
2662
2663   return object;
2664
2665 }
2666
2667 //_____________________________________________________________________________
2668 TObject *AliTRDCalibra::CreatePadObjectTree(TTree *tree, Int_t i
2669                                           , AliTRDCalDet *detobject)
2670 {
2671   //
2672   // It Creates the AliTRDCalPad object from the tree of the
2673   // coefficient for the calibration i (i != 2)
2674   // You need first to create the object for the detectors,
2675   // where the mean value is put.
2676   // This object has to be written in the database
2677   //
2678   
2679   // Create the DetObject
2680   AliTRDCalPad *object = 0x0;
2681   if (i == 0) {
2682     object = new AliTRDCalPad("GainFactor","GainFactor (local variations)");
2683   }
2684   if (i == 1) {
2685     object = new AliTRDCalPad("LocalVdrift","TRD drift velocities (local variations)");
2686   }
2687   else {
2688     object = new AliTRDCalPad("LocalT0","T0 (local variations)");
2689   }
2690   
2691   // Read the Tree
2692   Int_t   detector = -1;
2693   Float_t values[2304];
2694   tree->SetBranchAddress("detector",&detector);
2695   if (i == 0) {
2696     tree->SetBranchAddress("gainPad",values);
2697   }
2698   if (i == 1) {
2699     tree->SetBranchAddress("vdrift" ,values);
2700   }
2701   if (i == 3) {
2702     tree->SetBranchAddress("t0"     ,values);
2703   }
2704   
2705   // Variables
2706   Float_t mean            = 0.0;
2707   Int_t   numberofentries = tree->GetEntries();
2708   
2709   if (numberofentries != 540) {
2710     AliInfo("The tree is not complete");
2711   }
2712   
2713   for (Int_t det = 0; det < numberofentries; ++det) {
2714     tree->GetEntry(det);
2715     AliTRDCalROC *calROC = object->GetCalROC(detector);
2716     mean = detobject->GetValue(detector);
2717     if (mean == 0) {
2718       continue;
2719     }
2720     Int_t rowMax = calROC->GetNrows();
2721     Int_t colMax = calROC->GetNcols();
2722     for (Int_t row = 0; row < rowMax; ++row) {
2723       for (Int_t col = 0; col < colMax; ++col) {
2724         if (i == 0) {
2725           calROC->SetValue(col,row,TMath::Abs(values[(Int_t) (col*rowMax+row)])/mean);
2726         }
2727         if (i == 1) {
2728           calROC->SetValue(col,row,TMath::Abs(values[(Int_t) (col*rowMax+row)])/mean);
2729         }
2730         if (i == 3) {
2731           if (values[(Int_t) (col*rowMax+row)]/mean < 0.0) {
2732             calROC->SetValue(col,row,0.0);
2733           }
2734           if (values[(Int_t) (col*rowMax+row)]/mean >= 0.0) {
2735             calROC->SetValue(col,row,values[(Int_t) (col*rowMax+row)]/mean);
2736           }
2737         }
2738       } // Col
2739     } // Row
2740   }
2741
2742   return object;
2743
2744 }
2745
2746 //_____________________________________________________________________________
2747 TObject *AliTRDCalibra::CreatePadObjectTree(TTree *tree)
2748 {
2749   //
2750   // It Creates the AliTRDCalPad object from the tree of the
2751   // coefficient for the calibration PRF (i = 2)
2752   // This object has to be written in the database
2753   //
2754   
2755   // Create the DetObject
2756   AliTRDCalPad *object = new AliTRDCalPad("PRFWidth","PRFWidth");
2757
2758   // Read the Tree
2759   Int_t   detector = -1;
2760   Float_t values[2304];
2761   tree->SetBranchAddress("detector",&detector);
2762   tree->SetBranchAddress("width"   ,values);
2763    
2764   // Variables
2765   Int_t numberofentries = tree->GetEntries();
2766
2767   if (numberofentries != 540) {
2768     AliInfo("The tree is not complete");
2769   }
2770
2771   for (Int_t det = 0; det < numberofentries; ++det) {
2772     tree->GetEntry(det);
2773     AliTRDCalROC *calROC = object->GetCalROC(detector);
2774     Int_t rowMax = calROC->GetNrows();
2775     Int_t colMax = calROC->GetNcols();
2776     for (Int_t row = 0; row < rowMax; ++row) {
2777       for (Int_t col = 0; col < colMax; ++col) {
2778         calROC->SetValue(col,row,TMath::Abs(values[(Int_t) (col*rowMax+row)]));
2779       } // Col
2780     } // Row
2781   }
2782
2783   return object;
2784
2785 }
2786
2787 //_____________________________________________________________________________
2788 void AliTRDCalibra::SetRelativeScale(Float_t RelativeScale)
2789 {
2790   //
2791   // Set the factor that will divide the deposited charge
2792   // to fit in the histo range [0,300]
2793   //
2794  
2795   if (RelativeScale > 0.0) {
2796     fRelativeScale = RelativeScale;
2797   } 
2798   else {
2799     AliInfo("RelativeScale must be strict positif!");
2800   }
2801
2802
2803
2804 //_____________________________________________________________________________
2805 void AliTRDCalibra::SetNz(Int_t i, Short_t Nz)
2806 {
2807   //
2808   // Set the mode of calibration group in the z direction for the parameter i
2809   // 
2810
2811   if ((Nz >= 0) && 
2812       (Nz <  5)) {
2813     fNz[i] = Nz; 
2814   }
2815   else { 
2816     AliInfo("You have to choose between 0 and 4");
2817   }
2818
2819 }
2820
2821 //_____________________________________________________________________________
2822 void AliTRDCalibra::SetNrphi(Int_t i, Short_t Nrphi)
2823 {
2824   //
2825   // Set the mode of calibration group in the rphi direction for the parameter i
2826   //
2827  
2828   if ((Nrphi >= 0) && 
2829       (Nrphi <  7)) {
2830     fNrphi[i] = Nrphi; 
2831   }
2832   else {
2833     AliInfo("You have to choose between 0 and 6");
2834   }
2835
2836 }
2837
2838 //_____________________________________________________________________________
2839 void AliTRDCalibra::SetPeriodeFitPH(Int_t periodeFitPH)
2840
2841   //
2842   // Set FitPH if 1 then each detector will be fitted
2843   //
2844
2845   if (periodeFitPH > 0) {
2846     fFitPHPeriode   = periodeFitPH; 
2847   }
2848   else {
2849     AliInfo("periodeFitPH must be higher than 0!");
2850   }
2851
2852 }
2853
2854 //_____________________________________________________________________________
2855 void AliTRDCalibra::SetBeginFitCharge(Float_t beginFitCharge)
2856
2857   //
2858   // The fit of the deposited charge distribution begins at
2859   // histo->Mean()/beginFitCharge
2860   // You can here set beginFitCharge
2861   //
2862
2863   if (beginFitCharge > 0) {
2864     fBeginFitCharge = beginFitCharge; 
2865   }
2866   else {
2867     AliInfo("beginFitCharge must be strict positif!");
2868   }
2869
2870 }
2871
2872 //_____________________________________________________________________________
2873 void AliTRDCalibra::SetT0Shift(Float_t t0Shift) 
2874
2875   //
2876   // The t0 calculated with the maximum positif slope is shift from t0Shift
2877   // You can here set t0Shift
2878   //
2879
2880   if (t0Shift > 0) {
2881     fT0Shift = t0Shift; 
2882   } 
2883   else {
2884     AliInfo("t0Shift must be strict positif!");
2885   }
2886
2887 }
2888
2889 //_____________________________________________________________________________
2890 void AliTRDCalibra::SetRangeFitPRF(Float_t rangeFitPRF)
2891
2892   //
2893   // The fit of the PRF is from -rangeFitPRF to rangeFitPRF
2894   // You can here set rangeFitPRF
2895   //
2896
2897   if ((rangeFitPRF >    0) && 
2898       (rangeFitPRF <= 1.0)) {
2899     fRangeFitPRF = rangeFitPRF;
2900   } 
2901   else {
2902     AliInfo("rangeFitPRF must be between 0 and 1.0");
2903   }
2904
2905 }
2906
2907 //_____________________________________________________________________________
2908 void AliTRDCalibra::SetRebin(Short_t rebin)
2909
2910   //
2911   // Rebin with rebin time less bins the Ch histo
2912   // You can set here rebin that should divide the number of bins of CH histo
2913   //
2914
2915   if (rebin > 0) {
2916     fRebin = rebin; 
2917     AliInfo("You have to be sure that fRebin divides fNumberBinCharge used!");
2918   } 
2919   else {
2920     AliInfo("You have to choose a positiv value!");
2921   }
2922
2923 }
2924
2925 //_____________________________________________________________________________
2926 TTree *AliTRDCalibra::Sum2Trees(const Char_t *filename1
2927                               , const Char_t *filename2
2928                               , const Char_t *variablecali)
2929 {
2930   //
2931   // It returns the sum of two trees with the name variablecali
2932   // in the files filenam1 and filename2 equivalent of merging two 2D histos
2933   // The name of the resulting tree is the same as the two input trees
2934   // variablecali can be treeCH2d, treePH2d or treePRF2d 
2935   //
2936
2937   // Variables
2938   TChain    *treeChain   = new TChain(variablecali);
2939   TObjArray *vectorplace = new TObjArray();
2940   TObjArray *where       = new TObjArray();
2941   
2942   // First tree
2943   // Take the tree
2944   TFile *file1 = new TFile(filename1,"READ");
2945   TTree *tree1 = (TTree *) file1->Get(variablecali);
2946
2947   gDirectory = gROOT;
2948
2949   // Take the places
2950   vectorplace = ConvertTreeVector(tree1);
2951
2952   // Say where it is in tree 1
2953   for (Int_t jui = 0; jui < (Int_t) vectorplace->GetEntriesFast(); jui++) {
2954     AliTRDPlace *placejui = new AliTRDPlace();
2955     placejui->SetPlace(jui);
2956     TObjArray *chainplace = new TObjArray();
2957     chainplace->Add((TObject *) placejui);
2958     where->Add((TObject *) chainplace);
2959   }
2960
2961   // Add to the chain
2962   treeChain->Add(filename1);
2963   delete file1;
2964
2965   // Second tree
2966   // Take the tree
2967   TFile *file2 = new TFile(filename2,"READ");
2968   TTree *tree2 = (TTree *) file2->Get(variablecali);
2969
2970   gDirectory = gROOT;
2971
2972   // Take the places
2973   TObjArray *vector2 = ConvertTreeVector(tree2);
2974   Int_t j = treeChain->GetEntries();
2975
2976   for (Int_t jui = 0; jui < (Int_t) vector2->GetEntriesFast(); jui++) {
2977     // Search if already found
2978     Int_t place = SearchInTreeVector(vectorplace,((AliTRDPlace *) vector2->At(jui))->GetPlace());
2979     // Create a new element in the two std vectors
2980     if (place == -1) {
2981       AliTRDPlace *placejjui  = new AliTRDPlace();
2982       placejjui->SetPlace((j+jui));
2983       TObjArray   *chainplace = new TObjArray();
2984       chainplace->Add((TObject *) placejjui);
2985       vectorplace->Add((TObject *) (vector2->At(jui)));
2986       where->Add((TObject *) chainplace);
2987     }
2988     // Update the element at the place "place" in the std vector whereinthechain
2989     else {
2990       AliTRDPlace *placejjui  = new AliTRDPlace();
2991       placejjui->SetPlace((j+jui));
2992       TObjArray   *chainplace = ((TObjArray *) where->At(place));
2993       chainplace->Add((TObject *) placejjui);
2994       where->AddAt((TObject *) chainplace,place);
2995     }
2996   }
2997
2998   // Add to the Chain
2999   treeChain->Add(filename2);
3000   delete file2; 
3001
3002   // Take care of the profile
3003   const Char_t *pattern = "P";
3004   TTree *tree = 0x0;
3005
3006   if (!strstr(variablecali,pattern)) {
3007
3008     // Ready to read the chain
3009     TH1F *his = 0x0;
3010     treeChain->SetBranchAddress("histo",&his);
3011
3012     // Initialise the final tree
3013     Int_t group   = -1;
3014     TH1F *histsum = 0x0;
3015    
3016     tree = new TTree(variablecali,variablecali);
3017     tree->Branch("groupnumber",&group,"groupnumber/I");
3018     tree->Branch("histo","TH1F",&histsum,32000,0);
3019
3020     // Init histsum
3021     if (treeChain->GetEntries() < 1) {
3022       return tree1; 
3023     }
3024     
3025     for (Int_t h = 0; h < (Int_t) vectorplace->GetEntriesFast(); h++) {
3026       group = ((AliTRDPlace *) vectorplace->At(h))->GetPlace();
3027       TObjArray *chainplace = ((TObjArray *) where->At(h));
3028       treeChain->GetEntry(((AliTRDPlace *) chainplace->At(0))->GetPlace());
3029       //Init for the first time
3030       if (h == 0)  {
3031         histsum = new TH1F("","",his->GetXaxis()->GetNbins()
3032                                 ,his->GetXaxis()->GetBinLowEdge(1)
3033                                 ,his->GetXaxis()->GetBinUpEdge(his->GetXaxis()->GetNbins()));
3034         histsum->Sumw2();
3035       }
3036       // Reset for each new group
3037       histsum->SetEntries(0.0);
3038       for (Int_t l = 0; l <= histsum->GetXaxis()->GetNbins(); l++) {
3039         histsum->SetBinContent(l,0.0);
3040         histsum->SetBinError(l,0.0);
3041       }
3042       histsum->Add(his,1);
3043       if ((Int_t) chainplace->GetEntriesFast() > 1) {
3044         for (Int_t s = 1; s < (Int_t) chainplace->GetEntriesFast(); s++) {
3045           treeChain->GetEntry(((AliTRDPlace *) chainplace->At(s))->GetPlace());
3046           histsum->Add(his,1);
3047         }
3048       }
3049       tree->Fill();
3050     }
3051
3052   }
3053   else {
3054
3055     // Ready to read the chain
3056     TGraphErrors *his = 0x0;
3057     treeChain->SetBranchAddress("histo",&his);
3058     
3059     // Initialise the final tree
3060     Int_t         group   = -1;
3061     TGraphErrors *histsum = 0x0;
3062     Double_t     *xref    = 0x0;
3063   
3064     tree = new TTree(variablecali,variablecali);
3065     tree->Branch("groupnumber",&group,"groupnumber/I");
3066     tree->Branch("histo","TGraphErrors",&histsum,32000,0);
3067
3068     // Init histsum
3069     if (treeChain->GetEntries() < 1) {
3070       return tree1; 
3071     }
3072
3073     for (Int_t h = 0; h < (Int_t) vectorplace->GetEntriesFast(); h++) {
3074
3075       group = ((AliTRDPlace *) vectorplace->At(h))->GetPlace();
3076       TObjArray *chainplace = ((TObjArray *) where->At(h));
3077       treeChain->GetEntry(((AliTRDPlace *) chainplace->At(0))->GetPlace());
3078       //Init or reset for a new group
3079       Int_t nbins = his->GetN();
3080       Double_t *x;
3081       x    = new Double_t[nbins];
3082       xref = his->GetX();
3083       Double_t *ex;
3084       ex   = new Double_t[nbins];
3085       Double_t *y;
3086       y    = new Double_t[nbins];
3087       Double_t *ey;
3088       ey   = new Double_t[nbins];
3089      
3090       for (Int_t lo = 0; lo < nbins; lo++) {
3091         x[lo]  = xref[lo];
3092         ex[lo] = 0.0;
3093         y[lo]  = 0.0;
3094         ey[lo] = 0.0;
3095       }
3096       delete histsum;
3097       histsum = new TGraphErrors(nbins,x,y,ex,ey);
3098
3099       // Add the first
3100       histsum = AddProfiles(his,histsum);
3101       if ((Int_t) chainplace->GetEntriesFast() > 1) {
3102         for (Int_t s = 1; s < (Int_t) chainplace->GetEntriesFast(); s++) {
3103           treeChain->GetEntry(((AliTRDPlace *) chainplace->At(s))->GetPlace());
3104           histsum = AddProfiles(his,histsum);
3105         }
3106       }
3107
3108       tree->Fill();
3109
3110     }
3111
3112   }
3113     
3114   return tree;
3115
3116 }
3117
3118 //____________Function fill 2D for the moment out of the code__________________
3119
3120 //____________Function fill 2D all objects from digits_________________________
3121 Bool_t AliTRDCalibra::Create2DDiSimOnline(Int_t iev1, Int_t iev2)
3122 {
3123   //
3124   // Only for simulations, after the simulation, create the 2D histos
3125   // from the digits stored in the file "TRD.Digits.root" 
3126   // Only for CH and PH
3127   //
3128   
3129   const Int_t kNplan = 6;
3130   const Int_t kNcham = 5;
3131
3132   // RunLoader and so on
3133   if (gAlice) {
3134     delete gAlice->GetRunLoader();
3135     delete gAlice;
3136     gAlice = 0;
3137   }
3138  
3139   AliRunLoader *rl = AliRunLoader::Open("galice.root");
3140   if (!rl) {
3141     return kFALSE;
3142   }
3143
3144   rl->LoadgAlice();
3145   gAlice = rl->GetAliRun();
3146   if (!gAlice) {
3147     return kFALSE;
3148   }
3149
3150   // Import the Trees for the event nEvent in the file
3151   rl->LoadKinematics();
3152   rl->GetEvent(0);
3153   rl->LoadHeader();
3154   
3155   AliLoader *loader = rl->GetLoader("TRDLoader");
3156   if (!loader) {
3157     AliInfo("No TRDLLoader found!");
3158     return kFALSE;
3159   }
3160
3161   // Get the pointer to the TRD detector 
3162   AliTRD *trd = (AliTRD *) gAlice->GetDetector("TRD");
3163   if (!trd) {
3164     AliInfo("No TRD detector found");
3165     return kFALSE;
3166   }
3167
3168   // Get the pointer to the geometry object
3169   AliTRDgeometry *geo;
3170   if (trd) {
3171     geo = trd->GetGeometry();
3172   }
3173   else {
3174     AliInfo("No TRD geometry found");
3175     return kFALSE;
3176   }
3177
3178   // DB Setting
3179   AliCDBManager *man = AliCDBManager::Instance();
3180   if (!man) {
3181     AliInfo("Could not get CDB Manager");
3182     return kFALSE;
3183   }
3184  
3185   // Get the parameter object
3186   AliTRDCommonParam *parCom = AliTRDCommonParam::Instance();
3187   if (!parCom) {
3188     AliInfo("Could not get CommonParam");
3189     return kFALSE;
3190   }
3191   AliTRDcalibDB     *cal    = AliTRDcalibDB::Instance();
3192   if (!cal) {
3193     AliInfo("Could not get calibDB");
3194     return kFALSE;
3195   }
3196
3197   // Some parameters
3198   fTimeMax = cal->GetNumberOfTimeBins();
3199   fSf      = (Float_t) cal->GetSamplingFrequency();
3200   if (fRelativeScaleAuto) {
3201     fRelativeScale = 0;
3202   }
3203   else {
3204     if (fRelativeScale <= 0.0) {
3205       AliInfo("You have to set the relativescale factor per hand!");
3206       return kFALSE;
3207     }
3208   }
3209
3210   // Create the 2D histos corresponding to the pad group calibration mode
3211   if (fCH2dOn) {
3212
3213     AliInfo(Form("We will fill the CH2d histo with the pad calibration mode: Nz %d, and Nrphi %d"
3214                 ,fNz[0]
3215                 ,fNrphi[0]));
3216     
3217     // Calcul the number of Xbins
3218     fNtotal[0]    = 0;
3219     ModePadCalibration(2,0);
3220     ModePadFragmentation(0,2,0,0);
3221     fDetChamb2[0] = fNfragZ[0] * fNfragRphi[0];
3222     fNtotal[0]   += 6 * 18 * fDetChamb2[0];
3223     ModePadCalibration(0,0);
3224     ModePadFragmentation(0,0,0,0);
3225     fDetChamb0[0] = fNfragZ[0] * fNfragRphi[0];
3226     fNtotal[0]   += 6 * 4 * 18 * fDetChamb0[0];
3227     AliInfo(Form("Total number of Xbins: %d",fNtotal[0]));
3228
3229     // Create the 2D histo
3230     if (fHisto2d) {
3231       CreateCH2d(fNtotal[0]);
3232     }
3233     if (fVector2d) {
3234       fVectorCH = new TObjArray();
3235       fPlaCH    = new TObjArray();
3236     }
3237     
3238   }
3239   
3240   if (fPH2dOn) {
3241
3242     AliInfo(Form("We will fill the PH2d histo with the pad calibration mode: Nz %d, and Nrphi %d"
3243                 ,fNz[1]
3244                 ,fNrphi[1]));
3245     
3246     // Calcul the number of Xbins
3247     fNtotal[1]    = 0;
3248     ModePadCalibration(2,1);
3249     ModePadFragmentation(0,2,0,1);
3250     fDetChamb2[1] = fNfragZ[1] * fNfragRphi[1];
3251     fNtotal[1]   += 6 * 18 * fDetChamb2[1];
3252     ModePadCalibration(0,1);
3253     ModePadFragmentation(0,0,0,1);
3254     fDetChamb0[1] = fNfragZ[1] * fNfragRphi[1];
3255     fNtotal[1]   += 6 * 4 * 18 * fDetChamb0[1];
3256     AliInfo(Form("Total number of Xbins: %d",fNtotal[1]));
3257
3258     // Create the 2D histo
3259     if (fHisto2d) {
3260       CreatePH2d(fNtotal[1]);
3261     }
3262     if (fVector2d) {
3263       fVectorPH = new TObjArray();
3264       fPlaPH    = new TObjArray();
3265     }
3266
3267   }
3268
3269   loader->LoadDigits();
3270   AliInfo("LoadDigits ");
3271   AliTRDdigitsManager *digitsManager = new AliTRDdigitsManager();
3272
3273   //iev2 egal to the max if 0
3274   if (iev2 == 0) {
3275     iev2 = rl->GetNumberOfEvents();
3276     AliInfo(Form("Total number of events: %d",iev2));
3277   }
3278
3279   // Loop on event
3280   for (Int_t ievent = iev1; ievent < iev2; ievent++) {
3281     AliInfo(Form("Process event %d",ievent));
3282     rl->GetEvent(ievent);
3283     if (!loader->TreeD()) {
3284       AliInfo("loader Loading Digits ... ");
3285       loader->LoadDigits();
3286     }
3287     digitsManager->ReadDigits(loader->TreeD());
3288     AliInfo("digitsManager Read Digits Done");
3289     // Read the digits from the file
3290     if (!(digitsManager->ReadDigits(loader->TreeD()))) {
3291       return kFALSE;
3292     }
3293
3294     // Loop on detector
3295     for (Int_t iSect = 0; iSect < 18; iSect++) {
3296       for (Int_t iChamb = 0; iChamb < kNcham; iChamb++) {
3297         for (Int_t iPlane = 0; iPlane < kNplan; iPlane++) {
3298           
3299           // A little geometry:
3300           Int_t iDet   = geo->GetDetector(iPlane,iChamb,iSect);
3301           Int_t rowMax = parCom->GetRowMax(iPlane,iChamb,iSect);
3302           Int_t colMax = parCom->GetColMax(iPlane);
3303
3304           // Variables for the group
3305           LocalisationDetectorXbins(iDet);
3306
3307           // In the cas of charge
3308           Float_t *amptotal;
3309           amptotal = new Float_t[fNfragRphi[0]*fNfragZ[0]];
3310           if (fCH2dOn) {
3311             for (Int_t k = 0; k < fNfragRphi[0]*fNfragZ[0]; k++) {
3312               amptotal[k] = 0.0;
3313             }
3314           }
3315
3316           // Loop through the detector pixel
3317           for (Int_t time = 0; time < fTimeMax; time++) {
3318             for (Int_t  col = 0;  col <  colMax;  col++) {
3319               for (Int_t  row = 0;  row <  rowMax;  row++) {
3320
3321                 // Amplitude and position in pad group 
3322                 AliTRDdigit *digit   = digitsManager->GetDigit(row,col,time,iDet);
3323                 Int_t        amp     = digit->GetAmp();
3324                 Int_t        posr[2] = {0,0};
3325                 Int_t        posc[2] = {0,0};
3326                 if ((fCH2dOn) && 
3327                     (fNnZ[0]    != 0)) {
3328                   posr[0] = (Int_t) row / fNnZ[0];
3329                 }
3330                 if ((fCH2dOn) && 
3331                     (fNnRphi[0] != 0)) {
3332                   posc[0] = (Int_t) col / fNnRphi[0];
3333                 }
3334                 if ((fPH2dOn) && 
3335                     (fNnZ[1]    != 0)) {
3336                   posr[1] = (Int_t) row / fNnZ[1];
3337                 }
3338                 if ((fPH2dOn) && 
3339                     (fNnRphi[1] != 0)) {
3340                   posc[1] = (Int_t) col / fNnRphi[1];
3341                 }
3342
3343                 // Total spectrum
3344                 if (fCH2dOn) {
3345                   if (amp < fThresholdDigit) {
3346                     amp = 0;
3347                   }
3348                   amptotal[(Int_t) (posc[0]*fNfragZ[0]+posr[0])] += amp;
3349                 }
3350                 if (fPH2dOn) {
3351                   if (fHisto2d) {
3352                     fPH2d->Fill((fXbins[1]+posc[1]*fNfragZ[1]+posr[1])+0.5,(Float_t) time/fSf,(Double_t) amp);
3353                   }
3354                   if (fVector2d) {
3355                     UpdateVectorPH((fXbins[1]+posc[1]*fNfragZ[1]+posr[1]),time,(Double_t) amp);
3356                   }
3357                 }
3358              
3359                 // Memory stuff
3360                 delete digit;
3361
3362               } // Boucle row
3363             } // Boucle col
3364           } // Boucle time
3365
3366           if (fCH2dOn) {
3367
3368             // If automatic scale
3369             if ((fCountRelativeScale < 100) && (fRelativeScaleAuto)) {
3370               // Take only the one zone track
3371               for (Int_t k = 0; k < fNfragZ[0]*fNfragRphi[0]; k++) {
3372                 if ((fCountRelativeScale < 100) && (amptotal[k] > 2.0)) {
3373                   fRelativeScale += amptotal[k]*0.014*0.01;
3374                   fCountRelativeScale++;
3375                 }
3376               }
3377             }
3378             
3379             // We fill the CH2d after having scale with the first 100
3380             if ((fCountRelativeScale >= 100) && (fRelativeScaleAuto)) {
3381               // Case of
3382               for (Int_t k = 0; k < fNfragZ[0]*fNfragRphi[0]; k++) {
3383                 if (fHisto2d && 
3384                     (amptotal[k] > 0.0)) {
3385                   fCH2d->Fill(fXbins[0]+k+0.5,amptotal[k]/fRelativeScale);
3386                 }
3387                 if (fVector2d && 
3388                     (amptotal[k] > 0.0)) {
3389                   UpdateVectorCH(fXbins[0]+k ,amptotal[k]/fRelativeScale);
3390                 }
3391               }
3392             }
3393
3394             // No relative salce
3395             if (!fRelativeScaleAuto) {
3396               for (Int_t k = 0; k < fNfragZ[0]*fNfragRphi[0]; k++) {
3397                 if (fHisto2d && 
3398                     (amptotal[k] > 0.0)) {
3399                   fCH2d->Fill(fXbins[0]+k+0.5, amptotal[k]/fRelativeScale); 
3400                 }
3401                 if (fVector2d && 
3402                     (amptotal[k] > 0.0)) {
3403                   UpdateVectorCH(fXbins[0]+k, amptotal[k]/fRelativeScale);
3404                 }
3405               }
3406             }
3407
3408           }
3409
3410           delete amptotal;        
3411           
3412         } // Boucle chamber
3413       } // Boucle plane
3414     } // Boucle sect
3415     
3416     loader->UnloadDigits();  
3417     
3418   } // Boucle event
3419   
3420   if (fDebug == 1) {
3421     if (fPH2dOn && fHisto2d) {
3422       PlotPH2d();
3423     }
3424     if (fCH2dOn && fHisto2d) {
3425       PlotCH2d();
3426     }  
3427   }
3428   
3429   if (fWrite[0] || fWrite[1]) {
3430
3431     TFile *fout = TFile::Open(fWriteName,"RECREATE");
3432     // Check if the file could be opened
3433     if (!fout || !fout->IsOpen()) {
3434       AliInfo("<No File found!");
3435       return kFALSE;
3436     }
3437
3438     if (fCH2dOn && fHisto2d && fWrite[0]) {
3439       fout->WriteTObject(fCH2d);
3440     }
3441     if (fPH2dOn && fHisto2d && fWrite[1]) {
3442       fout->WriteTObject(fPH2d);
3443     }
3444
3445     if (fVector2d && fCH2dOn && fWrite[0]) {
3446       TString name("Nz");
3447       name += fNz[0];
3448       name += "Nrphi";
3449       name += fNrphi[0];
3450       TTree *treeCH2d = ConvertVectorCTTreeHisto(fVectorCH,fPlaCH,"treeCH2d",(const char *) name);
3451       fout->WriteTObject(treeCH2d);
3452     }
3453
3454     if (fVector2d && fPH2dOn && fWrite[1]) {
3455       TString name("Nz");
3456       name += fNz[1];
3457       name += "Nrphi";
3458       name += fNrphi[1];
3459       TTree *treePH2d = ConvertVectorPTreeHisto(fVectorPH,fPlaPH,"treePH2d",(const char *) name);
3460       fout->WriteTObject(treePH2d);
3461     }
3462
3463     fout->Close();
3464
3465   }
3466  
3467   return kTRUE;
3468
3469 }
3470
3471 //____________Function fill 2D all objects from Raw Data_______________________
3472 Bool_t AliTRDCalibra::Create2DRaDaOnline(Int_t iev1, Int_t iev2)
3473 {
3474   //
3475   // After having written the RAW DATA in the current directory, create the
3476   // 2D histos from these RAW DATA  
3477   // Only for CH and PH
3478   //
3479   
3480   const Int_t kNplan = 6;
3481   const Int_t kNcham = 5;
3482   TString dirname(".");
3483   
3484   // DB Setting
3485   AliCDBManager *man = AliCDBManager::Instance();
3486   if (!man) {
3487     AliInfo("Could not get CDB Manager");
3488     return kFALSE;
3489   }
3490
3491   // Get the parameter object
3492   AliTRDCommonParam *parCom = AliTRDCommonParam::Instance();
3493   if (!parCom) {
3494     AliInfo("Could not get CommonParam");
3495     return kFALSE;
3496   }
3497
3498   AliTRDcalibDB     *cal    = AliTRDcalibDB::Instance();
3499   if (!cal) {
3500     AliInfo("Could not get calibDB");
3501     return kFALSE;
3502   }
3503
3504   // Some parameters
3505   fTimeMax = cal->GetNumberOfTimeBins();
3506   fSf      = (Float_t) cal->GetSamplingFrequency();
3507   if (fRelativeScaleAuto) {
3508     fRelativeScale = 0;
3509   }
3510   else {
3511     if (fRelativeScale <= 0.0) {
3512       AliInfo("You have to set the relativescale factor per hand!");
3513       return kFALSE;
3514     }
3515   }
3516
3517   // Create the 2D histo corresponding to the pad group calibration mode
3518   if (fCH2dOn) {
3519
3520     AliInfo(Form("We will fill the CH2d histo with the pad calibration mode: Nz %d, and Nrphi %d"
3521                 ,fNz[0]
3522                 ,fNrphi[0]));
3523     
3524     // Calcul the number of Xbins
3525     fNtotal[0]    = 0;
3526     ModePadCalibration(2,0);
3527     ModePadFragmentation(0,2,0,0);
3528     fDetChamb2[0] = fNfragZ[0] * fNfragRphi[0];
3529     fNtotal[0]   += 6 * 18 * fDetChamb2[0];
3530     ModePadCalibration(0,0);
3531     ModePadFragmentation(0,0,0,0);
3532     fDetChamb0[0] = fNfragZ[0] * fNfragRphi[0];
3533     fNtotal[0]   += 6 * 4 * 18 * fDetChamb0[0];
3534     AliInfo(Form("Total number of Xbins: %d",fNtotal[0]));
3535     
3536     // Create the 2D histo
3537     if (fHisto2d) {
3538       CreateCH2d(fNtotal[0]);
3539     }
3540     if (fVector2d) {
3541       fVectorCH = new TObjArray();
3542       fPlaCH    = new TObjArray();
3543     }
3544
3545   }
3546   
3547   if(fPH2dOn) {
3548
3549     AliInfo(Form("We will fill the PH2d histo with the pad calibration mode: Nz %d, and Nrphi %d"
3550                 ,fNz[1]
3551                 ,fNrphi[1]));
3552     
3553     // Calcul the number of Xbins
3554     fNtotal[1]    = 0;
3555     ModePadCalibration(2,1);
3556     ModePadFragmentation(0,2,0,1);
3557     fDetChamb2[1] = fNfragZ[1] * fNfragRphi[1];
3558     fNtotal[1]   += 6 * 18 * fDetChamb2[1];
3559     ModePadCalibration(0,1);
3560     ModePadFragmentation(0,0,0,1);
3561     fDetChamb0[1] = fNfragZ[1] * fNfragRphi[1];
3562     fNtotal[1]   += 6 * 4 * 18 * fDetChamb0[1];
3563     AliInfo(Form("Total number of Xbins: %d",fNtotal[1]));
3564
3565     // Create the 2D histo
3566     if (fHisto2d) {
3567       CreatePH2d(fNtotal[1]);
3568     }
3569     if (fVector2d){
3570       fVectorPH = new TObjArray();
3571       fPlaPH    = new TObjArray();
3572     }
3573
3574   }
3575    
3576   AliTRDrawData *rawdata = new AliTRDrawData();
3577   AliInfo("AliTRDrawData object created ");
3578   
3579   // Loop on events
3580   for (Int_t ievent = iev1; ievent < iev2; ievent++) {
3581    
3582     // AliRawReaderFile
3583     AliRawReaderFile *readerfile = new AliRawReaderFile(dirname,ievent);
3584     if (!readerfile) {
3585       AliInfo("No readerfile found!");
3586       return kFALSE;
3587     }
3588  
3589     AliTRDdigitsManager *digitsManager = rawdata->Raw2Digits((AliRawReader *) readerfile);
3590     if (!digitsManager) {
3591       AliInfo("No DigitsManager done!");
3592       return kFALSE;
3593     }
3594  
3595     // Loop on detectors
3596     for (Int_t iSect = 0; iSect < 18; iSect++) {
3597       for (Int_t iPlane = 0; iPlane < kNplan; iPlane++) {
3598         for (Int_t iChamb = 0; iChamb < kNcham; iChamb++) {
3599           
3600           // A little geometry:
3601           Int_t iDet   = AliTRDgeometry::GetDetector(iPlane,iChamb,iSect);
3602           Int_t rowMax = parCom->GetRowMax(iPlane,iChamb,iSect);
3603           Int_t colMax = parCom->GetColMax(iPlane);
3604
3605           // Variables for the group
3606           LocalisationDetectorXbins(iDet);
3607         
3608           // In the cas of charge
3609           Float_t *amptotal;
3610           amptotal = new Float_t[fNfragRphi[0]*fNfragZ[0]];
3611           if(fCH2dOn) {
3612             for (Int_t k = 0; k < fNfragRphi[0]*fNfragZ[0]; k++) {
3613               amptotal[k] = 0.0;
3614             }
3615           }
3616
3617           // Loop through the detector pixel
3618           for (Int_t time = 0; time < fTimeMax; time++) {
3619             for (Int_t  col = 0;  col <  colMax;  col++) {
3620               for (Int_t  row = 0;  row <  rowMax;  row++) {
3621
3622                 // Amplitude and position of the digit
3623                 AliTRDdigit *digit   = digitsManager->GetDigit(row,col,time,iDet);
3624                 Int_t        amp     = digit->GetAmp();
3625                 Int_t        posr[2] = { 0, 0 };
3626                 Int_t        posc[2] = { 0, 0 };
3627                 if ((fCH2dOn) && 
3628                     (fNnZ[0]    != 0)) {
3629                   posr[0] = (Int_t) row / fNnZ[0];
3630                 }
3631                 if ((fCH2dOn) && 
3632                     (fNnRphi[0] != 0)) {
3633                   posc[0] = (Int_t) col / fNnRphi[0];
3634                 }
3635                 if ((fPH2dOn) && 
3636                     (fNnZ[1]    != 0)) {
3637                   posr[1] = (Int_t) row / fNnZ[1];
3638                 }
3639                 if ((fPH2dOn) && 
3640                     (fNnRphi[1] != 0)) {
3641                   posc[1] = (Int_t) col / fNnRphi[1];
3642                 }
3643                 
3644                 // Total spectrum
3645                 if (fCH2dOn) {
3646                   if (amp < fThresholdDigit) {
3647                     amp = 0;
3648                   }
3649                   amptotal[(Int_t) (posc[0]*fNfragZ[0]+posr[0])] += amp;
3650                 }
3651
3652                 if (fPH2dOn ) {
3653                   if (fHisto2d) {
3654                     fPH2d->Fill((fXbins[1]+posc[1]*fNfragZ[1]+posr[1])+0.5,(Float_t)time/fSf,amp);
3655                   }
3656                   if (fVector2d) {
3657                     UpdateVectorPH(fXbins[1]+posc[1]*fNfragZ[1]+posr[1],time,amp);
3658                   }
3659                 }
3660
3661                 delete digit;
3662
3663               } // Boucle row
3664             } // Boucle col
3665           } // Boucle time
3666
3667           if (fCH2dOn) {
3668
3669             // If automatic scale
3670             if ((fCountRelativeScale < 100) && (fRelativeScaleAuto)) {
3671               // Take only the one zone track
3672               for (Int_t k = 0; k < fNfragZ[0]*fNfragRphi[0]; k++) {
3673                 if ((fCountRelativeScale < 100) && (amptotal[k] > 2.0)) {
3674                   fRelativeScale += amptotal[k] * 0.014 * 0.01;
3675                   fCountRelativeScale++;
3676                 }
3677               }
3678             }
3679             
3680             // We fill the CH2d after having scale with the first 100
3681             if ((fCountRelativeScale >= 100) && (fRelativeScaleAuto)) {
3682               // Case of