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