e922d841b349994b000ddc205450c81fc55f977f
[u/mrichter/AliRoot.git] / TRD / AliTRDCalibraFit.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 // AliTRDCalibraFit                                                               
21 //                                                                             
22 // This class is for the TRD calibration of the relative gain factor, the drift velocity,
23 // the time 0 and the pad response function. It fits the histos.       
24 // The 2D histograms or vectors (first converted in 1D histos) will be fitted  
25 // if they have enough entries, otherwise the (default) value of the choosen database 
26 // will be put. For the relative gain calibration the resulted factors will be globally 
27 // normalized to the gain factors of the choosen database. It unables to precise     
28 // previous calibration procedure.
29 // The function SetDebug enables the user to see:                                     
30 // _fDebug = 0: nothing, only the values are written in the tree if wanted
31 // _fDebug = 1: only the fit of the choosen calibration group fFitVoir (SetFitVoir)
32 // _fDebug = 2: a comparaison of the coefficients found and the default values 
33 //              in the choosen database.
34 //              fCoef , histogram of the coefs as function of the calibration group number
35 //              fDelta , histogram of the relative difference of the coef with the default
36 //                        value in the database as function of the calibration group number
37 //              fError , dirstribution of this relative difference
38 // _fDebug = 3: The coefficients in the choosen detector fDet (SetDet) as function of the
39 //              pad row and col number
40 // _fDebug = 4; The coeffcicients in the choosen detector fDet (SetDet) like in the 3 but with
41 //              also the comparaison histograms of the 1 for this detector
42 //
43 //                            
44 // Author:
45 //   R. Bailhache (R.Bailhache@gsi.de)
46 //                            
47 //////////////////////////////////////////////////////////////////////////////////////
48
49 #include <TLine.h>
50 #include <TH1I.h>
51 #include <TStyle.h>
52 #include <TProfile2D.h>
53 #include <TCanvas.h>
54 #include <TGraphErrors.h>
55 #include <TObjArray.h>
56 #include <TH1.h>
57 #include <TH1F.h>
58 #include <TF1.h>
59 #include <TAxis.h>
60 #include <TMath.h>
61 #include <TDirectory.h>
62 #include <TROOT.h>
63 #include <TTreeStream.h>
64 #include <TLinearFitter.h>
65 #include <TVectorD.h>
66 #include <TArrayF.h>
67
68 #include "AliLog.h"
69 #include "AliMathBase.h"
70
71 #include "AliTRDCalibraFit.h"
72 #include "AliTRDCalibraMode.h"
73 #include "AliTRDCalibraVector.h"
74 #include "AliTRDCalibraVdriftLinearFit.h"
75 #include "AliTRDcalibDB.h"
76 #include "AliTRDgeometry.h"
77 #include "AliTRDpadPlane.h"
78 #include "AliTRDgeometry.h"
79 #include "AliTRDCommonParam.h"
80 #include "./Cal/AliTRDCalROC.h"
81 #include "./Cal/AliTRDCalPad.h"
82 #include "./Cal/AliTRDCalDet.h"
83
84
85 ClassImp(AliTRDCalibraFit)
86
87 AliTRDCalibraFit* AliTRDCalibraFit::fgInstance = 0;
88 Bool_t AliTRDCalibraFit::fgTerminated = kFALSE;
89
90 //_____________singleton implementation_________________________________________________
91 AliTRDCalibraFit *AliTRDCalibraFit::Instance()
92 {
93   //
94   // Singleton implementation
95   //
96
97   if (fgTerminated != kFALSE) {
98     return 0;
99   }
100
101   if (fgInstance == 0) {
102     fgInstance = new AliTRDCalibraFit();
103   }
104
105   return fgInstance;
106
107 }
108 //______________________________________________________________________________________
109 void AliTRDCalibraFit::Terminate()
110 {
111   //
112   // Singleton implementation
113   // Deletes the instance of this class
114   //
115
116   fgTerminated = kTRUE;
117
118   if (fgInstance != 0) {
119     delete fgInstance;
120     fgInstance = 0;
121   }
122
123 }
124 //______________________________________________________________________________________
125 AliTRDCalibraFit::AliTRDCalibraFit()
126   :TObject()
127   ,fGeo(0)
128   ,fNumberOfBinsExpected(0)
129   ,fMethod(0)
130   ,fBeginFitCharge(3.5)
131   ,fFitPHPeriode(1)
132   ,fTakeTheMaxPH(kTRUE)
133   ,fT0Shift0(0.124797)
134   ,fT0Shift1(0.267451)
135   ,fRangeFitPRF(1.0)
136   ,fAccCDB(kFALSE)
137   ,fMinEntries(800)
138   ,fRebin(1)
139   ,fNumberFit(0)
140   ,fNumberFitSuccess(0)
141   ,fNumberEnt(0)
142   ,fStatisticMean(0.0)
143   ,fDebugStreamer(0x0)
144   ,fDebugLevel(0)
145   ,fFitVoir(0)
146   ,fMagneticField(0.5)
147   ,fCalibraMode(new AliTRDCalibraMode())
148   ,fCurrentCoefE(0.0)
149   ,fCurrentCoefE2(0.0)
150   ,fDect1(0)
151   ,fDect2(0)
152   ,fScaleFitFactor(0.0)
153   ,fEntriesCurrent(0)
154   ,fCountDet(0)
155   ,fCount(0)
156   ,fNbDet(0)
157   ,fCalDet(0x0)
158   ,fCalROC(0x0)
159   ,fCalDet2(0x0)
160   ,fCalROC2(0x0)
161   ,fCurrentCoefDetector(0x0)
162   ,fCurrentCoefDetector2(0x0)
163   ,fVectorFit(0)
164   ,fVectorFit2(0)
165 {
166   //
167   // Default constructor
168   //
169
170   fGeo         = new AliTRDgeometry();  
171  
172   // Current variables initialised
173   for (Int_t k = 0; k < 2; k++) {
174     fCurrentCoef[k]  = 0.0;
175     fCurrentCoef2[k] = 0.0;
176   }
177   for (Int_t i = 0; i < 3; i++) {
178     fPhd[i]          = 0.0;
179     fDet[i]          = 0;
180   }
181  
182 }
183 //______________________________________________________________________________________
184 AliTRDCalibraFit::AliTRDCalibraFit(const AliTRDCalibraFit &c)
185 :TObject(c)
186 ,fGeo(0)
187 ,fNumberOfBinsExpected(c.fNumberOfBinsExpected)
188 ,fMethod(c.fMethod)
189 ,fBeginFitCharge(c.fBeginFitCharge)
190 ,fFitPHPeriode(c.fFitPHPeriode)
191 ,fTakeTheMaxPH(c.fTakeTheMaxPH)
192 ,fT0Shift0(c.fT0Shift0)
193 ,fT0Shift1(c.fT0Shift1)
194 ,fRangeFitPRF(c.fRangeFitPRF)
195 ,fAccCDB(c.fAccCDB)
196 ,fMinEntries(c.fMinEntries)
197 ,fRebin(c.fRebin)
198 ,fNumberFit(c.fNumberFit)
199 ,fNumberFitSuccess(c.fNumberFitSuccess)
200 ,fNumberEnt(c.fNumberEnt)
201 ,fStatisticMean(c.fStatisticMean)
202 ,fDebugStreamer(0x0)
203 ,fDebugLevel(c.fDebugLevel)
204 ,fFitVoir(c.fFitVoir)
205 ,fMagneticField(c.fMagneticField)
206 ,fCalibraMode(0x0)
207 ,fCurrentCoefE(c.fCurrentCoefE)
208 ,fCurrentCoefE2(c.fCurrentCoefE2)
209 ,fDect1(c.fDect1)
210 ,fDect2(c.fDect2)
211 ,fScaleFitFactor(c.fScaleFitFactor)
212 ,fEntriesCurrent(c.fEntriesCurrent)
213 ,fCountDet(c.fCountDet)
214 ,fCount(c.fCount)
215 ,fNbDet(c.fNbDet)
216 ,fCalDet(0x0)
217 ,fCalROC(0x0)
218 ,fCalDet2(0x0)
219 ,fCalROC2(0x0)
220 ,fCurrentCoefDetector(0x0)
221 ,fCurrentCoefDetector2(0x0)
222 ,fVectorFit(0)
223 ,fVectorFit2(0)
224 {
225   //
226   // Copy constructor
227   //
228
229   if(c.fCalibraMode)   fCalibraMode = new AliTRDCalibraMode(*c.fCalibraMode);
230  
231   //Current variables initialised
232   for (Int_t k = 0; k < 2; k++) {
233     fCurrentCoef[k]  = 0.0;
234     fCurrentCoef2[k] = 0.0;
235   }
236   for (Int_t i = 0; i < 3; i++) {
237     fPhd[i]          = 0.0;
238     fDet[i]          = 0;
239   }
240   if(c.fCalDet) fCalDet   = new AliTRDCalDet(*c.fCalDet);
241   if(c.fCalDet2) fCalDet2 = new AliTRDCalDet(*c.fCalDet2);
242   
243   if(c.fCalROC) fCalROC   = new AliTRDCalROC(*c.fCalROC);
244   if(c.fCalROC2) fCalROC  = new AliTRDCalROC(*c.fCalROC2);
245
246   fVectorFit.SetName(c.fVectorFit.GetName());
247   for(Int_t k = 0; k < c.fVectorFit.GetEntriesFast(); k++){
248     AliTRDFitInfo *fitInfo = new AliTRDFitInfo();
249     Int_t detector         = ((AliTRDFitInfo *)c.fVectorFit.UncheckedAt(k))->GetDetector();
250     Int_t ntotal = 1;
251     if (GetStack(detector) == 2) {
252       ntotal = 1728;
253     }
254     else {
255       ntotal = 2304;
256     }
257     Float_t *coef = new Float_t[ntotal];
258     for (Int_t i = 0; i < ntotal; i++) {
259       coef[i] = ((AliTRDFitInfo *)c.fVectorFit.UncheckedAt(k))->GetCoef()[i];
260     }
261     fitInfo->SetCoef(coef);
262     fitInfo->SetDetector(detector);
263     fVectorFit.Add((TObject *) fitInfo);
264   }
265   fVectorFit.SetName(c.fVectorFit.GetName());
266   for(Int_t k = 0; k < c.fVectorFit2.GetEntriesFast(); k++){
267     AliTRDFitInfo *fitInfo = new AliTRDFitInfo();
268     Int_t detector         = ((AliTRDFitInfo *)c.fVectorFit2.UncheckedAt(k))->GetDetector();
269     Int_t ntotal = 1;
270     if (GetStack(detector) == 2) {
271       ntotal = 1728;
272     }
273     else {
274       ntotal = 2304;
275     }
276     Float_t *coef = new Float_t[ntotal];
277     for (Int_t i = 0; i < ntotal; i++) {
278       coef[i] = ((AliTRDFitInfo *)c.fVectorFit2.UncheckedAt(k))->GetCoef()[i];
279     }
280     fitInfo->SetCoef(coef);
281     fitInfo->SetDetector(detector);
282     fVectorFit2.Add((TObject *) fitInfo);
283   }
284   if (fGeo) {
285     delete fGeo;
286   }
287   fGeo = new AliTRDgeometry();
288
289 }
290 //____________________________________________________________________________________
291 AliTRDCalibraFit::~AliTRDCalibraFit()
292 {
293   //
294   // AliTRDCalibraFit destructor
295   //
296   if ( fDebugStreamer ) delete fDebugStreamer;
297   if ( fCalDet )  delete fCalDet;
298   if ( fCalDet2 ) delete fCalDet2;
299   if ( fCalROC )  delete fCalROC;
300   if ( fCalROC2 ) delete fCalROC2;
301   if( fCurrentCoefDetector ) delete [] fCurrentCoefDetector;
302   if( fCurrentCoefDetector2 ) delete [] fCurrentCoefDetector2; 
303   fVectorFit.Delete();
304   fVectorFit2.Delete();
305   if (fGeo) {
306     delete fGeo;
307   }
308
309 }
310 //_____________________________________________________________________________
311 void AliTRDCalibraFit::Destroy() 
312 {
313   //
314   // Delete instance 
315   //
316
317   if (fgInstance) {
318     delete fgInstance;
319     fgInstance = 0x0;
320   }
321
322 }
323 //_____________________________________________________________________________
324 void AliTRDCalibraFit::DestroyDebugStreamer() 
325 {
326   //
327   // Delete DebugStreamer
328   //
329
330   if ( fDebugStreamer ) delete fDebugStreamer;
331   fDebugStreamer = 0x0;
332  
333 }
334 //__________________________________________________________________________________
335 void AliTRDCalibraFit::RangeChargeIntegration(Float_t vdrift, Float_t t0, Int_t &begin, Int_t &peak, Int_t &end) const
336 {
337   //
338   // From the drift velocity and t0
339   // return the position of the peak and maximum negative slope
340   //
341   
342   const Float_t kDrWidth = AliTRDgeometry::DrThick();    // drift region
343   Double_t widbins = 0.1;                                // 0.1 mus
344
345   //peak and maxnegslope in mus
346   Double_t begind = t0*widbins + fT0Shift0;
347   Double_t peakd  = t0*widbins + fT0Shift1;
348   Double_t maxnegslope = (kDrWidth + vdrift*peakd)/vdrift; 
349
350   // peak and maxnegslope in timebin
351   begin = TMath::Nint(begind*widbins);
352   peak  = TMath::Nint(peakd*widbins);
353   end   = TMath::Nint(maxnegslope*widbins); 
354
355 }
356 //____________Functions fit Online CH2d________________________________________
357 Bool_t AliTRDCalibraFit::AnalyseCH(const TH2I *ch)
358 {
359   //
360   // Fit the 1D histos, projections of the 2D ch on the Xaxis, for each
361   // calibration group normalized the resulted coefficients (to 1 normally)
362   //
363
364   // Set the calibration mode
365   const char *name = ch->GetTitle();
366   if(!SetModeCalibration(name,0)) return kFALSE;
367
368   // Number of Ybins (detectors or groups of pads)
369   Int_t    nbins   = ch->GetNbinsX();// charge
370   Int_t    nybins  = ch->GetNbinsY();// groups number
371   if (!InitFit(nybins,0)) {
372     return kFALSE;
373   }
374   if (!InitFitCH()) {
375     return kFALSE;
376   }
377   fStatisticMean        = 0.0;
378   fNumberFit            = 0;
379   fNumberFitSuccess     = 0;
380   fNumberEnt            = 0;
381   // Init fCountDet and fCount
382   InitfCountDetAndfCount(0);
383   // Beginning of the loop betwwen dect1 and dect2
384   for (Int_t idect = fDect1; idect < fDect2; idect++) {
385     // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi...
386     UpdatefCountDetAndfCount(idect,0);
387     ReconstructFitRowMinRowMax(idect, 0);
388     // Take the histo
389     TH1I *projch = (TH1I *) ch->ProjectionX("projch",idect+1,idect+1,(Option_t *)"e");
390     projch->SetDirectory(0);
391     // Number of entries for this calibration group
392     Double_t nentries = 0.0;
393     Double_t mean = 0.0;
394     for (Int_t k = 0; k < nbins; k++) {
395       Int_t binnb = (nbins+2)*(idect+1)+(k+1);
396       nentries += ch->GetBinContent(binnb);
397       mean += projch->GetBinCenter(k+1)*projch->GetBinContent(k+1);
398       projch->SetBinError(k+1,TMath::Sqrt(projch->GetBinContent(k+1)));
399     }
400     projch->SetEntries(nentries);
401     //printf("The number of entries for the group %d is %f\n",idect,nentries);
402     if (nentries > 0) {
403       fNumberEnt++;
404       mean /= nentries;
405     }
406     // Rebin and statistic stuff
407     if (fRebin > 1) {
408       projch = ReBin((TH1I *) projch);
409     }
410     // This detector has not enough statistics or was off
411     if (nentries <= fMinEntries) {
412       NotEnoughStatisticCH(idect);
413       if (fDebugLevel != 1) {
414         delete projch;
415       }
416       continue;
417     }
418     // Statistics of the group fitted
419     fStatisticMean += nentries;
420     fNumberFit++;
421     //Method choosen
422     switch(fMethod)
423       {
424       case 0: FitMeanW((TH1 *) projch, nentries); break;
425       case 1: FitMean((TH1 *) projch, nentries, mean); break;
426       case 2: FitCH((TH1 *) projch, mean); break;
427       case 3: FitBisCH((TH1 *) projch, mean); break;
428       default: return kFALSE;
429       }
430     // Fill Infos Fit
431     FillInfosFitCH(idect);
432     // Memory!!!
433     if (fDebugLevel != 1) {
434       delete projch;
435     }
436   } // Boucle object
437   // Normierungcharge
438   if (fDebugLevel != 1) {
439     NormierungCharge();
440   }
441   // Mean Statistic
442   if (fNumberFit > 0) {
443     AliInfo(Form("There are %d with at least one entries. %d fits have been proceeded (sucessfully or not...). There is a mean statistic of: %d over these fitted histograms and %d successfulled fits",fNumberEnt, fNumberFit, (Int_t) fStatisticMean/fNumberFit, fNumberFitSuccess));
444     fStatisticMean = fStatisticMean / fNumberFit;
445   }
446   else {
447     AliInfo(Form("There are %d with at least one entries. There is no fit!",fNumberEnt));
448   }
449   delete fDebugStreamer;
450   fDebugStreamer = 0x0;
451
452   return kTRUE;
453 }
454 //____________Functions fit Online CH2d________________________________________
455 Bool_t AliTRDCalibraFit::AnalyseCH(AliTRDCalibraVector *calvect)
456 {
457   //
458   // Reconstruct a 1D histo from the vectorCH for each calibration group,
459   // fit the histo, normalized the resulted coefficients (to 1 normally)
460   //
461
462   // Set the calibraMode
463   const char *name = calvect->GetNameCH();
464   if(!SetModeCalibration(name,0)) return kFALSE;  
465
466   // Number of Xbins (detectors or groups of pads)
467   if (!InitFit((432*calvect->GetDetCha0(0)+108*calvect->GetDetCha2(0)),0)) {
468     return kFALSE;
469   }
470   if (!InitFitCH()) {
471     return kFALSE;
472   }
473   fStatisticMean        = 0.0;
474   fNumberFit            = 0;
475   fNumberFitSuccess     = 0;
476   fNumberEnt            = 0;
477   // Init fCountDet and fCount
478   InitfCountDetAndfCount(0);
479   // Beginning of the loop between dect1 and dect2
480   for (Int_t idect = fDect1; idect < fDect2; idect++) {
481     // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi...........
482     UpdatefCountDetAndfCount(idect,0);
483     ReconstructFitRowMinRowMax(idect,0);
484     // Take the histo
485     Double_t nentries = 0.0;
486     Double_t mean = 0.0;
487     if(!calvect->GetCHEntries(fCountDet)) {
488       NotEnoughStatisticCH(idect);
489       continue;
490     }
491     
492     TString tname("CH");
493     tname += idect;
494     TH1F *projch  = calvect->ConvertVectorCHHisto(fCountDet,(idect-(fCount-(fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0)))),(const char *) tname);
495     projch->SetDirectory(0);
496     for (Int_t k = 0; k < calvect->GetNumberBinCharge(); k++) {
497       nentries += projch->GetBinContent(k+1);
498       mean += projch->GetBinCenter(k+1)*projch->GetBinContent(k+1);
499     }
500     if (nentries > 0) {
501       fNumberEnt++;
502       mean /= nentries;
503     }
504     //printf("The number of entries for the group %d is %f\n",idect,nentries);
505     // Rebin
506     if (fRebin >  1) {
507       projch = ReBin((TH1F *) projch);
508     }
509     // This detector has not enough statistics or was not found in VectorCH
510     if (nentries <= fMinEntries) {
511       NotEnoughStatisticCH(idect);
512       continue;
513     }
514     // Statistic of the histos fitted
515     fStatisticMean += nentries;
516     fNumberFit++;
517     //Method choosen
518     switch(fMethod)
519       {
520       case 0: FitMeanW((TH1 *) projch, nentries); break;
521       case 1: FitMean((TH1 *) projch, nentries, mean); break;
522       case 2: FitCH((TH1 *) projch, mean); break;
523       case 3: FitBisCH((TH1 *) projch, mean); break;
524       default: return kFALSE;
525       }
526     // Fill Infos Fit
527     FillInfosFitCH(idect); 
528   } // Boucle object
529   // Normierungcharge
530   if (fDebugLevel != 1) {
531     NormierungCharge();
532   }
533   // Mean Statistics
534   if (fNumberFit > 0) {
535     AliInfo(Form("There are %d with at least one entries. %d fits have been proceeded (sucessfully or not...). There is a mean statistic of: %d over these fitted histograms and %d successfulled fits",fNumberEnt, fNumberFit, (Int_t) fStatisticMean/fNumberFit, fNumberFitSuccess));
536     fStatisticMean = fStatisticMean / fNumberFit;
537   }
538   else {
539     AliInfo(Form("There are %d with at least one entries. There is no fit!",fNumberEnt));
540   }
541   delete fDebugStreamer;
542   fDebugStreamer = 0x0;
543   return kTRUE;
544 }
545 //________________functions fit Online PH2d____________________________________
546 Bool_t AliTRDCalibraFit::AnalysePH(const TProfile2D *ph)
547 {
548   //
549   // Take the 1D profiles (average pulse height), projections of the 2D PH
550   // on the Xaxis, for each calibration group
551   // Reconstruct a drift velocity
552   // A first calibration of T0 is also made  using the same method
553   //
554
555   // Set the calibration mode
556   const char *name = ph->GetTitle();
557   if(!SetModeCalibration(name,1)) return kFALSE;
558   
559   //printf("Mode calibration set\n");
560
561   // Number of Xbins (detectors or groups of pads)
562   Int_t    nbins   = ph->GetNbinsX();// time
563   Int_t    nybins  = ph->GetNbinsY();// calibration group
564   if (!InitFit(nybins,1)) {
565     return kFALSE;
566   }
567
568   //printf("Init fit\n");
569
570   if (!InitFitPH()) {
571     return kFALSE;
572   }
573
574   //printf("Init fit PH\n");
575
576   fStatisticMean        = 0.0;
577   fNumberFit            = 0;
578   fNumberFitSuccess     = 0;
579   fNumberEnt            = 0;
580   // Init fCountDet and fCount
581   InitfCountDetAndfCount(1);
582   //printf("Init Count Det and fCount %d, %d\n",fDect1,fDect2);
583
584   // Beginning of the loop
585   for (Int_t idect = fDect1; idect < fDect2; idect++) {
586     //printf("idect = %d\n",idect);
587     // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi.......
588     UpdatefCountDetAndfCount(idect,1);
589     ReconstructFitRowMinRowMax(idect,1);
590     // Take the histo
591     TH1D *projph = (TH1D *) ph->ProjectionX("projph",idect+1,idect+1,(Option_t *) "e");
592     projph->SetDirectory(0); 
593     // Number of entries for this calibration group
594     Double_t nentries = 0;
595     for (Int_t k = 0; k < nbins; k++) {
596       Int_t binnb = (nbins+2)*(idect+1)+(k+1);
597       nentries += ph->GetBinEntries(binnb);
598     }
599     if (nentries > 0) {
600       fNumberEnt++;
601     }  
602     //printf("The number of entries for the group %d is %f\n",idect,nentries);
603     // This detector has not enough statistics or was off
604     if (nentries  <= fMinEntries) {
605       //printf("Not enough statistic!\n");
606       NotEnoughStatisticPH(idect,nentries);     
607       if (fDebugLevel != 1) {
608         delete projph;
609       }
610       continue;
611     }
612     // Statistics of the histos fitted
613     fNumberFit++;
614     fStatisticMean += nentries;
615     // Calcul of "real" coef
616     CalculVdriftCoefMean();
617     CalculT0CoefMean();
618     //Method choosen
619     //printf("Method\n");
620     switch(fMethod)
621       {
622       case 0: FitLagrangePoly((TH1 *) projph); break;
623       case 1: FitPente((TH1 *) projph); break;
624       case 2: FitPH((TH1 *) projph,(Int_t) (idect - fDect1)); break;
625       default: return kFALSE;
626       }
627     // Fill the tree if end of a detector or only the pointer to the branch!!!
628     FillInfosFitPH(idect,nentries);
629     // Memory!!!
630     if (fDebugLevel != 1) {
631       delete projph;
632     }
633   } // Boucle object
634   // Mean Statistic
635   if (fNumberFit > 0) {
636     AliInfo(Form("There are %d with at least one entries. %d fits have been proceeded (sucessfully or not...). There is a mean statistic of: %d over these fitted histograms and %d successfulled fits",fNumberEnt, fNumberFit, (Int_t) fStatisticMean/fNumberFit,fNumberFitSuccess));
637     fStatisticMean = fStatisticMean / fNumberFit;
638   }
639   else {
640     AliInfo(Form("There are %d with at least one entries. There is no fit!",fNumberEnt));
641   }
642   delete fDebugStreamer;
643   fDebugStreamer = 0x0;
644   return kTRUE;
645 }
646 //____________Functions fit Online PH2d________________________________________
647 Bool_t AliTRDCalibraFit::AnalysePH(AliTRDCalibraVector *calvect)
648 {
649   //
650   // Reconstruct the average pulse height from the vectorPH for each
651   // calibration group
652   // Reconstruct a drift velocity
653   // A first calibration of T0 is also made  using the same method (slope method)
654   //
655
656   // Set the calibration mode
657   const char *name = calvect->GetNamePH();
658   if(!SetModeCalibration(name,1)) return kFALSE;
659
660   // Number of Xbins (detectors or groups of pads)
661   if (!InitFit((432*calvect->GetDetCha0(1)+108*calvect->GetDetCha2(1)),1)) {
662     return kFALSE;
663   }
664   if (!InitFitPH()) {
665     return kFALSE;
666   }
667   fStatisticMean        = 0.0;
668   fNumberFit            = 0;
669   fNumberFitSuccess     = 0;
670   fNumberEnt            = 0;
671   // Init fCountDet and fCount
672   InitfCountDetAndfCount(1);
673   // Beginning of the loop
674   for (Int_t idect = fDect1; idect < fDect2; idect++) {
675     // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi...........
676     UpdatefCountDetAndfCount(idect,1);
677     ReconstructFitRowMinRowMax(idect,1);
678     // Take the histo
679     fEntriesCurrent = 0;
680     if(!calvect->GetPHEntries(fCountDet)) {
681       NotEnoughStatisticPH(idect,fEntriesCurrent);
682       continue;
683     }
684     TString tname("PH");
685     tname += idect;
686     TH1F *projph  = calvect->CorrectTheError((TGraphErrors *) (calvect->ConvertVectorPHTGraphErrors(fCountDet,(idect-(fCount-(fCalibraMode->GetNfragZ(1)*fCalibraMode->GetNfragRphi(1)))),(const char *) tname)),fEntriesCurrent);
687     projph->SetDirectory(0);
688     if(fEntriesCurrent > 0) fNumberEnt++;
689     //printf("The number of entries for the group %d is %d\n",idect,fEntriesCurrent);
690     // This detector has not enough statistics or was off
691     if (fEntriesCurrent <=  fMinEntries) {
692       //printf("Not enough stat!\n");
693       NotEnoughStatisticPH(idect,fEntriesCurrent);
694       continue;
695     }
696     // Statistic of the histos fitted
697     fNumberFit++;
698     fStatisticMean += fEntriesCurrent;
699     // Calcul of "real" coef
700     CalculVdriftCoefMean();
701     CalculT0CoefMean();
702     //Method choosen
703     switch(fMethod)
704       {
705       case 0: FitLagrangePoly((TH1 *) projph); break;
706       case 1: FitPente((TH1 *) projph); break;
707       case 2: FitPH((TH1 *) projph,(Int_t) (idect - fDect1)); break;
708       default: return kFALSE;
709       }
710     // Fill the tree if end of a detector or only the pointer to the branch!!!
711     FillInfosFitPH(idect,fEntriesCurrent);
712   } // Boucle object
713   
714   // Mean Statistic
715   if (fNumberFit > 0) {
716     AliInfo(Form("There are %d with at least one entries. %d fits have been proceeded (sucessfully or not...). There is a mean statistic of: %d over these fitted histograms and %d successfulled fits",fNumberEnt, fNumberFit, (Int_t) fStatisticMean/fNumberFit,fNumberFitSuccess));
717     fStatisticMean = fStatisticMean / fNumberFit;
718   }
719   else {
720     AliInfo(Form("There are %d with at least one entries. There is no fit!",fNumberEnt));
721   }
722   delete fDebugStreamer;
723   fDebugStreamer = 0x0;
724   return kTRUE;
725 }
726 //____________Functions fit Online PRF2d_______________________________________
727 Bool_t AliTRDCalibraFit::AnalysePRF(const TProfile2D *prf)
728 {
729   //
730   // Take the 1D profiles (pad response function), projections of the 2D PRF
731   // on the Xaxis, for each calibration group
732   // Fit with a gaussian to reconstruct the sigma of the pad response function
733   //
734
735   // Set the calibration mode
736   const char *name = prf->GetTitle();
737   if(!SetModeCalibration(name,2)) return kFALSE;
738
739   // Number of Ybins (detectors or groups of pads)
740   Int_t    nybins  = prf->GetNbinsY();// calibration groups
741   Int_t    nbins   = prf->GetNbinsX();// bins
742   Int_t    nbg     = GetNumberOfGroupsPRF((const char *)prf->GetTitle());
743   if((nbg > 0) || (nbg == -1)) return kFALSE;
744   if (!InitFit(nybins,2)) {
745     return kFALSE;
746   }
747   if (!InitFitPRF()) {
748     return kFALSE;
749   }
750   fStatisticMean        = 0.0;
751   fNumberFit            = 0;
752   fNumberFitSuccess     = 0;
753   fNumberEnt            = 0;
754   // Init fCountDet and fCount
755   InitfCountDetAndfCount(2);
756   // Beginning of the loop
757   for (Int_t idect = fDect1; idect < fDect2; idect++) {
758     // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi......
759     UpdatefCountDetAndfCount(idect,2);
760     ReconstructFitRowMinRowMax(idect,2);
761     // Take the histo
762     TH1D *projprf = (TH1D *) prf->ProjectionX("projprf",idect+1,idect+1,(Option_t *) "e");
763     projprf->SetDirectory(0);
764     // Number of entries for this calibration group
765     Double_t nentries = 0;
766     for (Int_t k = 0; k < nbins; k++) {
767       Int_t binnb = (nbins+2)*(idect+1)+(k+1);
768       nentries += prf->GetBinEntries(binnb);
769     }
770     if(nentries > 0) fNumberEnt++;
771     // This detector has not enough statistics or was off
772     if (nentries <= fMinEntries) {
773       NotEnoughStatisticPRF(idect);
774       if (fDebugLevel != 1) {
775         delete projprf;
776       }
777       continue;
778     }
779     // Statistics of the histos fitted
780     fNumberFit++;
781     fStatisticMean += nentries;
782     // Calcul of "real" coef
783     CalculPRFCoefMean();
784     //Method choosen
785     switch(fMethod)
786       {
787       case 0: FitPRF((TH1 *) projprf); break;
788       case 1: RmsPRF((TH1 *) projprf); break;
789       default: return kFALSE;
790       }
791     // Fill the tree if end of a detector or only the pointer to the branch!!!
792     FillInfosFitPRF(idect);
793     // Memory!!!
794     if (fDebugLevel != 1) {
795       delete projprf;
796     }
797   } // Boucle object
798   // Mean Statistic
799   if (fNumberFit > 0) {
800     AliInfo(Form("There are %d with at least one entries.",fNumberEnt));
801     AliInfo(Form("%d fits have been proceeded (sucessfully or not...).",fNumberFit));
802     AliInfo(Form("There is a mean statistic of: %d over these fitted histograms and %d successfulled fits"
803                 ,(Int_t) fStatisticMean/fNumberFit,fNumberFitSuccess));
804     fStatisticMean = fStatisticMean / fNumberFit;
805   }
806   else {
807     AliInfo(Form("There are %d with at least one entries. There is no fit!",fNumberEnt));
808   }
809   delete fDebugStreamer;
810   fDebugStreamer = 0x0;
811   return kTRUE;
812 }
813 //____________Functions fit Online PRF2d_______________________________________
814 Bool_t AliTRDCalibraFit::AnalysePRFMarianFit(const TProfile2D *prf)
815 {
816   //
817   // Take the 1D profiles (pad response function), projections of the 2D PRF
818   // on the Xaxis, for each calibration group
819   // Fit with a gaussian to reconstruct the sigma of the pad response function
820   //
821
822   // Set the calibration mode
823   const char *name = prf->GetTitle();
824   if(!SetModeCalibration(name,2)) return kFALSE;
825
826   // Number of Ybins (detectors or groups of pads)
827   TAxis   *xprf    = prf->GetXaxis();
828   TAxis   *yprf    = prf->GetYaxis();
829   Int_t    nybins  = yprf->GetNbins();// calibration groups
830   Int_t    nbins   = xprf->GetNbins();// bins
831   Float_t  lowedge = (Float_t) xprf->GetBinLowEdge(1);//lowedge in bins
832   Float_t  upedge  = (Float_t) xprf->GetBinUpEdge(nbins);//upedge in bins
833   Int_t    nbg     = GetNumberOfGroupsPRF((const char *)name);
834   if(nbg == -1) return kFALSE;
835   if(nbg > 0) fMethod = 1;
836   else fMethod = 0;
837   if (!InitFit(nybins,2)) {
838     return kFALSE;
839   }
840   if (!InitFitPRF()) {
841     return kFALSE;
842   }
843   fStatisticMean        = 0.0;
844   fNumberFit            = 0;
845   fNumberFitSuccess     = 0;
846   fNumberEnt            = 0;
847   // Init fCountDet and fCount
848   InitfCountDetAndfCount(2);
849   // Beginning of the loop
850   for (Int_t idect = fDect1; idect < fDect2; idect++) {
851     // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi.......
852     UpdatefCountDetAndfCount(idect,2);
853     ReconstructFitRowMinRowMax(idect,2);
854     // Build the array of entries and sum
855     TArrayD arraye  = TArrayD(nbins);
856     TArrayD arraym  = TArrayD(nbins);
857     TArrayD arrayme = TArrayD(nbins);
858     Double_t nentries = 0;
859     //printf("nbins %d\n",nbins);
860     for (Int_t k = 0; k < nbins; k++) {
861       Int_t binnb = (nbins+2)*(idect+1)+(k+1);
862       Double_t entries = (Double_t)prf->GetBinEntries(binnb);
863       Double_t mean    = (Double_t)prf->GetBinContent(binnb);
864       Double_t error   = (Double_t)prf->GetBinError(binnb); 
865       //printf("for %d we have %f\n",k,entries);
866       nentries += entries;
867       arraye.AddAt(entries,k);
868       arraym.AddAt(mean,k);
869       arrayme.AddAt(error,k);
870     }
871     if(nentries > 0) fNumberEnt++;
872     //printf("The number of entries for the group %d is %f\n",idect,nentries);
873     // This detector has not enough statistics or was off
874     if (nentries <= fMinEntries) {
875       NotEnoughStatisticPRF(idect);
876       continue;
877     }
878     // Statistics of the histos fitted
879     fNumberFit++;
880     fStatisticMean += nentries;
881     // Calcul of "real" coef
882     CalculPRFCoefMean();
883     //Method choosen
884     switch(fMethod)
885       {
886       case 0: FitPRFGausMI( arraye.GetArray(), arraym.GetArray(), arrayme.GetArray(), nbins, lowedge, upedge); break;
887       case 1: FitTnpRange( arraye.GetArray(), arraym.GetArray(), arrayme.GetArray(), nbg, nbins); break;
888       default: return kFALSE;
889       }
890     // Fill the tree if end of a detector or only the pointer to the branch!!!
891     FillInfosFitPRF(idect);
892   } // Boucle object
893   // Mean Statistic
894   if (fNumberFit > 0) {
895     AliInfo(Form("There are %d with at least one entries.",fNumberEnt));
896     AliInfo(Form("%d fits have been proceeded (sucessfully or not...).",fNumberFit));
897     AliInfo(Form("There is a mean statistic of: %d over these fitted histograms and %d successfulled fits"
898                 ,(Int_t) fStatisticMean/fNumberFit,fNumberFitSuccess));
899     fStatisticMean = fStatisticMean / fNumberFit;
900   }
901   else {
902     AliInfo(Form("There are %d with at least one entries. There is no fit!",fNumberEnt));
903   }
904   delete fDebugStreamer;
905   fDebugStreamer = 0x0;
906   return kTRUE;
907 }
908 //____________Functions fit Online PRF2d_______________________________________
909 Bool_t AliTRDCalibraFit::AnalysePRF(AliTRDCalibraVector *calvect)
910 {
911   //
912   // Reconstruct the 1D histo (pad response function) from the vectorPRD for
913   // each calibration group
914   // Fit with a gaussian to reconstruct the sigma of the pad response function
915   //
916
917   // Set the calibra mode
918   const char *name = calvect->GetNamePRF();
919   if(!SetModeCalibration(name,2)) return kFALSE;
920   //printf("test0 %s\n",name);
921
922   // Number of Xbins (detectors or groups of pads)
923   if (!InitFit((432*calvect->GetDetCha0(2)+108*calvect->GetDetCha2(2)),2)) {
924     //printf("test1\n");
925     return kFALSE;
926   }
927   if (!InitFitPRF()) {
928     ///printf("test2\n");
929     return kFALSE;
930   }
931   fStatisticMean        = 0.0;
932   fNumberFit            = 0;
933   fNumberFitSuccess     = 0;
934   fNumberEnt            = 0;
935   // Init fCountDet and fCount
936   InitfCountDetAndfCount(2);
937   // Beginning of the loop
938   for (Int_t idect = fDect1; idect < fDect2; idect++) {
939     // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi........
940     UpdatefCountDetAndfCount(idect,2);
941     ReconstructFitRowMinRowMax(idect,2);
942     // Take the histo
943     fEntriesCurrent = 0;
944     if(!calvect->GetPRFEntries(fCountDet)) {
945       NotEnoughStatisticPRF(idect);
946       continue;
947     }
948     TString tname("PRF");
949     tname += idect;
950     TH1F *projprf  = calvect->CorrectTheError((TGraphErrors *) (calvect->ConvertVectorPRFTGraphErrors(fCountDet,(idect-(fCount-(fCalibraMode->GetNfragZ(1)*fCalibraMode->GetNfragRphi(1)))),(const char *) tname)),fEntriesCurrent);
951     projprf->SetDirectory(0);
952     if(fEntriesCurrent > 0) fNumberEnt++;
953     // This detector has not enough statistics or was off
954     if (fEntriesCurrent <= fMinEntries) {
955       NotEnoughStatisticPRF(idect);
956       continue;
957     }
958     // Statistic of the histos fitted
959     fNumberFit++;
960     fStatisticMean += fEntriesCurrent;
961     // Calcul of "real" coef
962     CalculPRFCoefMean();
963     //Method choosen
964     switch(fMethod)
965       {
966       case 1: FitPRF((TH1 *) projprf); break;
967       case 2: RmsPRF((TH1 *) projprf); break;
968       default: return kFALSE;
969       }    
970     // Fill the tree if end of a detector or only the pointer to the branch!!!
971     FillInfosFitPRF(idect);
972   } // Boucle object
973   // Mean Statistics
974   if (fNumberFit > 0) {
975     AliInfo(Form("There are %d with at least one entries. %d fits have been proceeded (sucessfully or not...). There is a mean statistic of: %d over these fitted histograms and %d successfulled fits",fNumberEnt, fNumberFit, (Int_t) fStatisticMean/fNumberFit,fNumberFitSuccess));
976   }
977   else {
978     AliInfo(Form("There are %d with at least one entries. There is no fit!",fNumberEnt));
979   }
980   delete fDebugStreamer;
981   fDebugStreamer = 0x0;
982   return kTRUE;
983 }
984 //____________Functions fit Online PRF2d_______________________________________
985 Bool_t AliTRDCalibraFit::AnalysePRFMarianFit(AliTRDCalibraVector *calvect)
986 {
987   //
988   // Reconstruct the 1D histo (pad response function) from the vectorPRD for
989   // each calibration group
990   // Fit with a gaussian to reconstruct the sigma of the pad response function
991   //
992
993   // Set the calibra mode
994   const char *name = calvect->GetNamePRF();
995   if(!SetModeCalibration(name,2)) return kFALSE;
996   //printf("test0 %s\n",name);
997   Int_t    nbg     = GetNumberOfGroupsPRF((const char *)name);
998   //printf("test1 %d\n",nbg);
999   if(nbg == -1) return kFALSE;
1000   if(nbg > 0) fMethod = 1;
1001   else fMethod = 0;
1002   // Number of Xbins (detectors or groups of pads)
1003   if (!InitFit((432*calvect->GetDetCha0(2)+108*calvect->GetDetCha2(2)),2)) {
1004     //printf("test2\n");
1005     return kFALSE;
1006   }
1007   if (!InitFitPRF()) {
1008     //printf("test3\n");
1009     return kFALSE;
1010   }
1011   fStatisticMean        = 0.0;
1012   fNumberFit            = 0;
1013   fNumberFitSuccess     = 0;
1014   fNumberEnt            = 0;
1015   // Variables
1016   Int_t nbins           = 0;
1017   Double_t *arrayx       = 0;
1018   Double_t *arraye       = 0;
1019   Double_t *arraym       = 0;
1020   Double_t *arrayme      = 0;
1021   Float_t lowedge       = 0.0;
1022   Float_t upedge        = 0.0;
1023   // Init fCountDet and fCount
1024   InitfCountDetAndfCount(2);
1025   // Beginning of the loop
1026   for (Int_t idect = fDect1; idect < fDect2; idect++) {
1027     // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi......
1028     UpdatefCountDetAndfCount(idect,2);
1029     ReconstructFitRowMinRowMax(idect,2);
1030     // Take the histo
1031     fEntriesCurrent  = 0;
1032     if(!calvect->GetPRFEntries(fCountDet)) {
1033       NotEnoughStatisticPRF(idect);
1034       continue;
1035     }
1036     TString tname("PRF");
1037     tname += idect;
1038     TGraphErrors *projprftree  = calvect->ConvertVectorPRFTGraphErrors(fCountDet,(idect-(fCount-(fCalibraMode->GetNfragZ(1)*fCalibraMode->GetNfragRphi(1)))),(const char *) tname);
1039     nbins   = projprftree->GetN();
1040     arrayx  = (Double_t *)projprftree->GetX();
1041     arraye  = (Double_t *)projprftree->GetEX();
1042     arraym  = (Double_t *)projprftree->GetY();
1043     arrayme = (Double_t *)projprftree->GetEY();
1044     Float_t step = arrayx[1]-arrayx[0];
1045     lowedge = arrayx[0] - step/2.0;
1046     upedge  = arrayx[(nbins-1)] + step/2.0;
1047     //printf("nbins est %d\n",nbins);
1048     for(Int_t k = 0; k < nbins; k++){
1049       fEntriesCurrent += (Int_t)arraye[k];
1050       //printf("for %d we have %f, %f\n",k,arraye[k],((projprftree->GetEX())[k]));
1051       if(arraye[k]>0.0) arrayme[k] = TMath::Sqrt(TMath::Abs(arrayme[k]-arraym[k]*arraym[k])/arraye[k]);
1052     }
1053     if(fEntriesCurrent > 0) fNumberEnt++;
1054     //printf("The number of entries for the group %d is %d\n",idect,fEntriesCurrent);
1055     // This detector has not enough statistics or was off
1056     if (fEntriesCurrent <= fMinEntries) {
1057       NotEnoughStatisticPRF(idect);
1058       continue;
1059     }
1060     // Statistic of the histos fitted
1061     fNumberFit++;
1062     fStatisticMean += fEntriesCurrent;
1063     // Calcul of "real" coef
1064     CalculPRFCoefMean();
1065     //Method choosen
1066     switch(fMethod)
1067       {
1068       case 0: FitPRFGausMI(arraye,arraym,arrayme,nbins,lowedge,upedge); break;
1069       case 1: FitTnpRange(arraye,arraym,arrayme,nbg,nbins); break;
1070       default: return kFALSE;
1071       }    
1072     // Fill the tree if end of a detector or only the pointer to the branch!!!
1073     FillInfosFitPRF(idect);
1074   } // Boucle object
1075   // Mean Statistics
1076   if (fNumberFit > 0) {
1077     AliInfo(Form("There are %d with at least one entries. %d fits have been proceeded (sucessfully or not...). There is a mean statistic of: %d over these fitted histograms and %d successfulled fits",fNumberEnt, fNumberFit, (Int_t) fStatisticMean/fNumberFit,fNumberFitSuccess));
1078   }
1079   else {
1080     AliInfo(Form("There are %d with at least one entries. There is no fit!",fNumberEnt));
1081   }
1082   delete fDebugStreamer;
1083   fDebugStreamer = 0x0;
1084   return kTRUE;
1085 }
1086 //____________Functions fit Online CH2d________________________________________
1087 Bool_t AliTRDCalibraFit::AnalyseLinearFitters(AliTRDCalibraVdriftLinearFit *calivdli)
1088 {
1089   //
1090   // The linear method
1091   //
1092
1093   fStatisticMean        = 0.0;
1094   fNumberFit            = 0;
1095   fNumberFitSuccess     = 0;
1096   fNumberEnt            = 0;
1097   if(!InitFitLinearFitter()) return kFALSE;
1098
1099   
1100   for(Int_t idet = 0; idet < 540; idet++){
1101
1102
1103     //printf("detector number %d\n",idet);
1104
1105     // Take the result
1106     TVectorD param(2);
1107     TVectorD error(3);
1108     fEntriesCurrent = 0;
1109     fCountDet       = idet;
1110     Bool_t here     = calivdli->GetParam(idet,&param);
1111     Bool_t heree    = calivdli->GetError(idet,&error);
1112     //printf("here %d and heree %d\n",here, heree);
1113     if(heree) {
1114       fEntriesCurrent = (Int_t) error[2];
1115       fNumberEnt++;
1116     }
1117     //printf("Number of entries %d\n",fEntriesCurrent);
1118     // Nothing found or not enough statistic
1119     if((!heree) || (!here) || (fEntriesCurrent <= fMinEntries)) {
1120       NotEnoughStatisticLinearFitter();
1121       continue;
1122     }
1123     //param.Print();
1124     //error.Print();
1125     //Statistics
1126     fNumberFit++;
1127     fStatisticMean += fEntriesCurrent;     
1128
1129     // Check the fit
1130     if((-(param[1])) <= 0.0) {
1131       NotEnoughStatisticLinearFitter();
1132       continue;
1133     }
1134
1135     // CalculDatabaseVdriftandTan
1136     CalculVdriftLorentzCoef();
1137
1138     // Statistics   
1139     fNumberFitSuccess ++;
1140
1141     // Put the fCurrentCoef
1142     fCurrentCoef[0]  = -param[1];
1143     // here the database must be the one of the reconstruction for the lorentz angle....
1144     fCurrentCoef2[0] = (param[0]+fCurrentCoef[1]*fCurrentCoef2[1])/fCurrentCoef[0];
1145     fCurrentCoefE    = error[1];
1146     fCurrentCoefE2   = error[0];
1147     if((fCurrentCoef2[0] != 0.0) && (param[0] != 0.0)){
1148       fCurrentCoefE2 = (fCurrentCoefE2/param[0]+fCurrentCoefE/fCurrentCoef[0])*fCurrentCoef2[0];
1149     }    
1150
1151     // Fill
1152     FillInfosFitLinearFitter();
1153
1154     
1155   }
1156   // Mean Statistics
1157   if (fNumberFit > 0) {
1158     AliInfo(Form("There are %d with at least one entries. %d fits have been proceeded (sucessfully or not...). There is a mean statistic of: %d over these fitted histograms and %d successfulled fits",fNumberEnt, fNumberFit, (Int_t) fStatisticMean/fNumberFit,fNumberFitSuccess));
1159   }
1160   else {
1161     AliInfo(Form("There are %d with at least one entries. There is no fit!",fNumberEnt));
1162   }
1163   delete fDebugStreamer;
1164   fDebugStreamer = 0x0;
1165   return kTRUE;
1166   
1167 }
1168 //____________Functions for seeing if the pad is really okey___________________
1169 //_____________________________________________________________________________
1170 Int_t AliTRDCalibraFit::GetNumberOfGroupsPRF(const char* nametitle)
1171 {
1172   //
1173   // Get numberofgroupsprf
1174   //
1175   
1176   // Some patterns
1177   const Char_t *pattern0 = "Ngp0";
1178   const Char_t *pattern1 = "Ngp1";
1179   const Char_t *pattern2 = "Ngp2";
1180   const Char_t *pattern3 = "Ngp3";
1181   const Char_t *pattern4 = "Ngp4";
1182   const Char_t *pattern5 = "Ngp5";
1183   const Char_t *pattern6 = "Ngp6";
1184
1185   // Nrphi mode
1186   if (strstr(nametitle,pattern0)) {
1187     return 0;
1188   }
1189   if (strstr(nametitle,pattern1)) {
1190     return 1;
1191   }
1192   if (strstr(nametitle,pattern2)) {
1193     return 2;
1194   }
1195   if (strstr(nametitle,pattern3)) {
1196     return 3;
1197   }
1198   if (strstr(nametitle,pattern4)) {
1199     return 4;
1200   }
1201   if (strstr(nametitle,pattern5)) {
1202     return 5;
1203   }
1204   if (strstr(nametitle,pattern6)){
1205     return 6;
1206   }
1207   else return -1;
1208  
1209
1210 }
1211 //_____________________________________________________________________________
1212 Bool_t AliTRDCalibraFit::SetModeCalibration(const char *name, Int_t i)
1213 {
1214   //
1215   // Set fNz[i] and fNrphi[i] of the AliTRDCalibraFit::Instance()
1216   // corresponding to the given name
1217   //
1218
1219   if(!SetNzFromTObject(name,i)) return kFALSE;
1220   if(!SetNrphiFromTObject(name,i)) return kFALSE;
1221   
1222   return kTRUE; 
1223
1224 }
1225 //_____________________________________________________________________________
1226 Bool_t AliTRDCalibraFit::SetNrphiFromTObject(const char *name, Int_t i)
1227 {
1228   //
1229   // Set fNrphi[i] of the AliTRDCalibraFit::Instance()
1230   // corresponding to the given TObject
1231   //
1232   
1233   // Some patterns
1234   const Char_t *patternrphi0 = "Nrphi0";
1235   const Char_t *patternrphi1 = "Nrphi1";
1236   const Char_t *patternrphi2 = "Nrphi2";
1237   const Char_t *patternrphi3 = "Nrphi3";
1238   const Char_t *patternrphi4 = "Nrphi4";
1239   const Char_t *patternrphi5 = "Nrphi5";
1240   const Char_t *patternrphi6 = "Nrphi6";
1241
1242   
1243   const Char_t *patternrphi10 = "Nrphi10";
1244   const Char_t *patternrphi100 = "Nrphi100";
1245   const Char_t *patternz10 = "Nz10";
1246   const Char_t *patternz100 = "Nz100";
1247
1248   // Nrphi mode
1249   if ((strstr(name,patternrphi100)) && (strstr(name,patternz100))) {
1250     fCalibraMode->SetAllTogether(i);
1251     fNbDet = 540;
1252     if (fDebugLevel > 1) {
1253       AliInfo(Form("fNbDet %d and 100",fNbDet));
1254     }
1255     return kTRUE;
1256   }
1257   if ((strstr(name,patternrphi10)) && (strstr(name,patternz10))) {
1258     fCalibraMode->SetPerSuperModule(i);
1259     fNbDet = 30;
1260     if (fDebugLevel > 1) {
1261       AliInfo(Form("fNDet %d and 100",fNbDet));
1262     }
1263     return kTRUE;
1264   }
1265   
1266   if (strstr(name,patternrphi0)) {
1267     fCalibraMode->SetNrphi(i ,0);
1268     if (fDebugLevel > 1) {
1269       AliInfo(Form("fNbDet %d and 0",fNbDet));
1270     }
1271     return kTRUE;
1272   }
1273   if (strstr(name,patternrphi1)) {
1274     fCalibraMode->SetNrphi(i, 1);
1275     if (fDebugLevel > 1) {
1276       AliInfo(Form("fNbDet %d and 1",fNbDet));
1277     }
1278     return kTRUE;
1279   }
1280   if (strstr(name,patternrphi2)) {
1281     fCalibraMode->SetNrphi(i, 2);
1282     if (fDebugLevel > 1) {
1283       AliInfo(Form("fNbDet %d and 2",fNbDet));
1284     }    
1285     return kTRUE;
1286   }
1287   if (strstr(name,patternrphi3)) {
1288     fCalibraMode->SetNrphi(i, 3);
1289     if (fDebugLevel > 1) {
1290       AliInfo(Form("fNbDet %d and 3",fNbDet));
1291     }   
1292     return kTRUE;
1293   }
1294   if (strstr(name,patternrphi4)) {
1295     fCalibraMode->SetNrphi(i, 4);
1296     if (fDebugLevel > 1) {
1297       AliInfo(Form("fNbDet %d and 4",fNbDet));
1298     }   
1299     return kTRUE;
1300   }
1301   if (strstr(name,patternrphi5)) {
1302     fCalibraMode->SetNrphi(i, 5);
1303     if (fDebugLevel > 1) {
1304       AliInfo(Form("fNbDet %d and 5",fNbDet));
1305     }
1306     return kTRUE;
1307   }
1308   if (strstr(name,patternrphi6)) {
1309     fCalibraMode->SetNrphi(i, 6);
1310     if (fDebugLevel > 1) {
1311       AliInfo(Form("fNbDet %d and 6",fNbDet));
1312     }
1313     return kTRUE;
1314   }
1315   
1316   if (fDebugLevel > 1) {
1317     AliInfo(Form("fNbDet %d and rest",fNbDet));
1318   }
1319   fCalibraMode->SetNrphi(i ,0);
1320   return kFALSE;
1321   
1322 }
1323 //_____________________________________________________________________________
1324 Bool_t AliTRDCalibraFit::SetNzFromTObject(const char *name, Int_t i)
1325 {
1326   //
1327   // Set fNz[i] of the AliTRDCalibraFit::Instance()
1328   // corresponding to the given TObject
1329   //
1330
1331   // Some patterns
1332   const Char_t *patternz0    = "Nz0";
1333   const Char_t *patternz1    = "Nz1";
1334   const Char_t *patternz2    = "Nz2";
1335   const Char_t *patternz3    = "Nz3";
1336   const Char_t *patternz4    = "Nz4";
1337
1338   const Char_t *patternrphi10 = "Nrphi10";
1339   const Char_t *patternrphi100 = "Nrphi100";
1340   const Char_t *patternz10 = "Nz10";
1341   const Char_t *patternz100 = "Nz100";
1342
1343   if ((strstr(name,patternrphi100)) && (strstr(name,patternz100))) {
1344     fCalibraMode->SetAllTogether(i);
1345     fNbDet = 540;
1346     if (fDebugLevel > 1) {
1347       AliInfo(Form("fNbDet %d and 100",fNbDet));
1348     }
1349     return kTRUE;
1350   }
1351   if ((strstr(name,patternrphi10)) && (strstr(name,patternz10))) {
1352     fCalibraMode->SetPerSuperModule(i);
1353     fNbDet = 30;
1354     if (fDebugLevel > 1) {
1355       AliInfo(Form("fNbDet %d and 10",fNbDet));
1356     }
1357     return kTRUE;
1358   }
1359   if (strstr(name,patternz0)) {
1360     fCalibraMode->SetNz(i, 0);
1361     if (fDebugLevel > 1) {
1362       AliInfo(Form("fNbDet %d and 0",fNbDet));
1363     }
1364     return kTRUE;
1365   }
1366   if (strstr(name,patternz1)) {
1367     fCalibraMode->SetNz(i ,1);
1368     if (fDebugLevel > 1) {
1369       AliInfo(Form("fNbDet %d and 1",fNbDet));
1370     }
1371     return kTRUE;
1372   }
1373   if (strstr(name,patternz2)) {
1374     fCalibraMode->SetNz(i ,2);
1375     if (fDebugLevel > 1) {    
1376       AliInfo(Form("fNbDet %d and 2",fNbDet));
1377     }
1378     return kTRUE;
1379   }
1380   if (strstr(name,patternz3)) {
1381     fCalibraMode->SetNz(i ,3);
1382     if (fDebugLevel > 1) {
1383       AliInfo(Form("fNbDet %d and 3",fNbDet));
1384     }
1385     return kTRUE;  
1386   }
1387   if (strstr(name,patternz4)) {
1388     fCalibraMode->SetNz(i ,4);
1389     if (fDebugLevel > 1) {    
1390       AliInfo(Form("fNbDet %d and 4",fNbDet));
1391     }
1392     return kTRUE;
1393   }
1394  
1395   if (fDebugLevel > 1) {
1396     AliInfo(Form("fNbDet %d and rest",fNbDet));
1397   }
1398   fCalibraMode->SetNz(i ,0);
1399   return kFALSE;
1400 }
1401 //______________________________________________________________________
1402 void AliTRDCalibraFit::RemoveOutliers(Int_t type, Bool_t perdetector){
1403   //
1404   // Remove the results too far from the mean value and rms
1405   // type: 0 gain, 1 vdrift
1406   // perdetector
1407   //
1408
1409   Int_t loop = (Int_t) fVectorFit.GetEntriesFast();
1410   if(loop != 540) {
1411     AliInfo("The Vector Fit is not complete!");
1412     return;
1413   }
1414   Int_t detector = -1;
1415   Int_t sector = -1;
1416   Float_t value  = 0.0;
1417
1418   /////////////////////////////////
1419   // Calculate the mean values
1420   ////////////////////////////////
1421   // Initialisation
1422   ////////////////////////
1423   Double_t meanAll = 0.0;
1424    Double_t rmsAll = 0.0;
1425    Int_t countAll = 0;
1426    ////////////
1427   // compute
1428   ////////////
1429   for (Int_t k = 0; k < loop; k++) {
1430     detector  = ((AliTRDFitInfo *) fVectorFit.At(k))->GetDetector();
1431     sector = GetSector(detector);
1432     if(perdetector){
1433       value = ((AliTRDFitInfo *) fVectorFit.At(k))->GetCoef()[0];
1434       if(value > 0.0) {
1435         rmsAll += value*value;
1436         meanAll += value;
1437         countAll++;
1438       }
1439     }
1440     else {
1441       Int_t rowMax    = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
1442       Int_t colMax    = fGeo->GetColMax(GetLayer(detector));
1443       for (Int_t row = 0; row < rowMax; row++) {
1444         for (Int_t col = 0; col < colMax; col++) {
1445           value = ((AliTRDFitInfo *) fVectorFit.At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
1446           if(value > 0.0) {
1447             rmsAll += value*value;
1448             meanAll += value;
1449             countAll++;
1450           }
1451           
1452         } // Col
1453       } // Row
1454     }
1455   }  
1456   if(countAll > 0) {
1457     meanAll = meanAll/countAll;
1458     rmsAll = TMath::Sqrt(TMath::Abs(rmsAll/countAll - (meanAll*meanAll)));
1459   }
1460   //printf("RemoveOutliers: meanAll %f and rmsAll %f\n",meanAll,rmsAll);
1461   /////////////////////////////////////////////////
1462   // Remove outliers
1463   ////////////////////////////////////////////////
1464   Double_t defaultvalue = -1.0;
1465   if(type==1) defaultvalue = -1.5;
1466   for (Int_t k = 0; k < loop; k++) {
1467     detector  = ((AliTRDFitInfo *) fVectorFit.At(k))->GetDetector();
1468     sector = GetSector(detector);
1469     Int_t rowMax    = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
1470     Int_t colMax    = fGeo->GetColMax(GetLayer(detector));
1471     Float_t *coef = ((AliTRDFitInfo *) fVectorFit.At(k))->GetCoef();
1472   
1473     // remove the results too far away  
1474     for (Int_t row = 0; row < rowMax; row++) {
1475       for (Int_t col = 0; col < colMax; col++) {
1476         value = coef[(Int_t)(col*rowMax+row)];
1477         if((value > 0.0) && (rmsAll > 0.0) && (TMath::Abs(value-meanAll) > (2*rmsAll))) {
1478           coef[(Int_t)(col*rowMax+row)] = defaultvalue;
1479         }
1480       } // Col
1481     } // Row
1482   }
1483 }
1484 //______________________________________________________________________
1485 void AliTRDCalibraFit::RemoveOutliers2(Bool_t perdetector){
1486   //
1487   // Remove the results too far from the mean and rms
1488   // perdetector
1489   //
1490
1491   Int_t loop = (Int_t) fVectorFit2.GetEntriesFast();
1492   if(loop != 540) {
1493     AliInfo("The Vector Fit is not complete!");
1494     return;
1495   }
1496   Int_t detector = -1;
1497   Int_t sector = -1;
1498   Float_t value  = 0.0;
1499
1500   /////////////////////////////////
1501   // Calculate the mean values
1502   ////////////////////////////////
1503   // Initialisation
1504   ////////////////////////
1505   Double_t meanAll = 0.0;
1506   Double_t rmsAll = 0.0;
1507   Int_t countAll = 0;
1508   /////////////
1509   // compute
1510   ////////////
1511   for (Int_t k = 0; k < loop; k++) {
1512     detector  = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetDetector();
1513     sector = GetSector(detector);
1514     if(perdetector){
1515       value = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetCoef()[0];
1516       if(value < 70.0) {
1517         meanAll += value;
1518         rmsAll += value*value;
1519         countAll++;
1520       }
1521     }
1522     else {
1523       Int_t rowMax    = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
1524       Int_t colMax    = fGeo->GetColMax(GetLayer(detector));
1525       for (Int_t row = 0; row < rowMax; row++) {
1526         for (Int_t col = 0; col < colMax; col++) {
1527           value = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
1528           if(value < 70.0) {
1529             rmsAll += value*value;
1530             meanAll += value;
1531             countAll++;
1532           }       
1533         } // Col
1534       } // Row
1535     }
1536   }  
1537   if(countAll > 0) {
1538     meanAll = meanAll/countAll;
1539     rmsAll = TMath::Sqrt(TMath::Abs(rmsAll/countAll - (meanAll*meanAll)));
1540   }
1541   //printf("Remove outliers 2: meanAll %f, rmsAll %f\n",meanAll,rmsAll);
1542   /////////////////////////////////////////////////
1543   // Remove outliers
1544   ////////////////////////////////////////////////
1545   for (Int_t k = 0; k < loop; k++) {
1546     detector  = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetDetector();
1547     sector = GetSector(detector);
1548     Int_t rowMax    = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
1549     Int_t colMax    = fGeo->GetColMax(GetLayer(detector));
1550     Float_t *coef = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetCoef();
1551   
1552     // remove the results too far away  
1553     for (Int_t row = 0; row < rowMax; row++) {
1554       for (Int_t col = 0; col < colMax; col++) {
1555         value = coef[(Int_t)(col*rowMax+row)];
1556         if((value < 70.0) && (rmsAll > 0.0) && (TMath::Abs(value-meanAll) > (2.5*rmsAll))) coef[(Int_t)(col*rowMax+row)] = 100.0;
1557       } // Col
1558     } // Row
1559   }
1560 }
1561 //______________________________________________________________________
1562 void AliTRDCalibraFit::PutMeanValueOtherVectorFit(Int_t ofwhat, Bool_t perdetector){
1563   //
1564   // ofwhat is equaled to 0: mean value of all passing detectors
1565   // ofwhat is equaled to 1: mean value of the detector, otherwise supermodule, otherwise all
1566   //
1567
1568   Int_t loop = (Int_t) fVectorFit.GetEntriesFast();
1569   if(loop != 540) {
1570     AliInfo("The Vector Fit is not complete!");
1571     return;
1572   }
1573   Int_t detector = -1;
1574   Int_t sector = -1;
1575   Float_t value  = 0.0;
1576
1577   /////////////////////////////////
1578   // Calculate the mean values
1579   ////////////////////////////////
1580   // Initialisation
1581   ////////////////////////
1582   Double_t meanAll = 0.0;
1583   Double_t meanSupermodule[18];
1584   Double_t meanDetector[540];
1585   Double_t rmsAll = 0.0;
1586   Double_t rmsSupermodule[18];
1587   Double_t rmsDetector[540];
1588   Int_t countAll = 0;
1589   Int_t countSupermodule[18];
1590   Int_t countDetector[540];
1591   for(Int_t sm = 0; sm < 18; sm++){
1592     rmsSupermodule[sm] = 0.0;
1593     meanSupermodule[sm] = 0.0;
1594     countSupermodule[sm] = 0;
1595   }
1596   for(Int_t det = 0; det < 540; det++){
1597     rmsDetector[det] = 0.0;
1598     meanDetector[det] = 0.0;
1599     countDetector[det] = 0;
1600   }
1601   ////////////
1602   // compute
1603   ////////////
1604   for (Int_t k = 0; k < loop; k++) {
1605     detector  = ((AliTRDFitInfo *) fVectorFit.At(k))->GetDetector();
1606     sector = GetSector(detector);
1607     if(perdetector){
1608       value = ((AliTRDFitInfo *) fVectorFit.At(k))->GetCoef()[0];
1609       if(value > 0.0) {
1610         rmsDetector[detector] += value*value;
1611         meanDetector[detector] += value;
1612         countDetector[detector]++;
1613         rmsSupermodule[sector] += value*value;
1614         meanSupermodule[sector] += value;
1615         countSupermodule[sector]++;
1616         rmsAll += value*value;
1617         meanAll += value;
1618         countAll++;
1619       }
1620     }
1621     else {
1622       Int_t rowMax    = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
1623       Int_t colMax    = fGeo->GetColMax(GetLayer(detector));
1624       for (Int_t row = 0; row < rowMax; row++) {
1625         for (Int_t col = 0; col < colMax; col++) {
1626           value = ((AliTRDFitInfo *) fVectorFit.At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
1627           if(value > 0.0) {
1628             rmsDetector[detector] += value*value;
1629             meanDetector[detector] += value;
1630             countDetector[detector]++;
1631             rmsSupermodule[sector] += value*value;
1632             meanSupermodule[sector] += value;
1633             countSupermodule[sector]++;
1634             rmsAll += value*value;
1635             meanAll += value;
1636             countAll++;
1637           }
1638           
1639         } // Col
1640       } // Row
1641     }
1642   }  
1643   if(countAll > 0) {
1644     meanAll = meanAll/countAll;
1645     rmsAll = TMath::Abs(rmsAll/countAll - (meanAll*meanAll));
1646   }
1647   for(Int_t sm = 0; sm < 18; sm++){
1648     if(countSupermodule[sm] > 0) {
1649       meanSupermodule[sm] = meanSupermodule[sm]/countSupermodule[sm];
1650       rmsSupermodule[sm] = TMath::Abs(rmsSupermodule[sm]/countSupermodule[sm] - (meanSupermodule[sm]*meanSupermodule[sm]));
1651     }
1652   }
1653   for(Int_t det = 0; det < 540; det++){
1654     if(countDetector[det] > 0) {
1655       meanDetector[det] = meanDetector[det]/countDetector[det];
1656       rmsDetector[det] = TMath::Abs(rmsDetector[det]/countDetector[det] - (meanDetector[det]*meanDetector[det]));
1657     }
1658   }
1659   //printf("Put mean value, meanAll %f, rmsAll %f\n",meanAll,rmsAll);
1660   ///////////////////////////////////////////////
1661   // Put the mean value for the no-fitted
1662   /////////////////////////////////////////////  
1663   for (Int_t k = 0; k < loop; k++) {
1664     detector  = ((AliTRDFitInfo *) fVectorFit.At(k))->GetDetector();
1665     sector = GetSector(detector);
1666     Int_t rowMax    = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
1667     Int_t colMax    = fGeo->GetColMax(GetLayer(detector));
1668     Float_t *coef = ((AliTRDFitInfo *) fVectorFit.At(k))->GetCoef();
1669
1670     for (Int_t row = 0; row < rowMax; row++) {
1671       for (Int_t col = 0; col < colMax; col++) {
1672         value = coef[(Int_t)(col*rowMax+row)];
1673         if(value < 0.0) {
1674           if((ofwhat == 0) && (meanAll > 0.0) && (countAll > 15)) coef[(Int_t)(col*rowMax+row)] = -TMath::Abs(meanAll);
1675           if(ofwhat == 1){
1676             if((meanDetector[detector] > 0.0) && (countDetector[detector] > 20)) coef[(Int_t)(col*rowMax+row)] = -TMath::Abs(meanDetector[detector]);
1677             else if((meanSupermodule[sector] > 0.0) && (countSupermodule[sector] > 15)) coef[(Int_t)(col*rowMax+row)] = -TMath::Abs(meanSupermodule[sector]);
1678             else if((meanAll > 0.0) && (countAll > 15)) coef[(Int_t)(col*rowMax+row)] = -TMath::Abs(meanAll);
1679           }  
1680         }
1681         // Debug
1682         if(fDebugLevel > 1){
1683           
1684           if ( !fDebugStreamer ) {
1685             //debug stream
1686             TDirectory *backup = gDirectory;
1687             fDebugStreamer = new TTreeSRedirector("TRDDebugFit.root");
1688             if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
1689           } 
1690           
1691           Float_t coefnow      = coef[(Int_t)(col*rowMax+row)]; 
1692           
1693           (* fDebugStreamer) << "PutMeanValueOtherVectorFit"<<
1694             "detector="<<detector<<
1695             "sector="<<sector<<
1696             "row="<<row<<
1697             "col="<<col<<
1698             "before="<<value<<
1699             "after="<<coefnow<<
1700             "\n";  
1701         }
1702       } // Col
1703     } // Row
1704   }
1705 }
1706 //______________________________________________________________________
1707 void AliTRDCalibraFit::PutMeanValueOtherVectorFit2(Int_t ofwhat, Bool_t perdetector){
1708   //
1709   // ofwhat is equaled to 0: mean value of all passing detectors
1710   // ofwhat is equaled to 1: mean value of the detector, otherwise supermodule, otherwise all
1711   //
1712
1713   Int_t loop = (Int_t) fVectorFit2.GetEntriesFast();
1714   if(loop != 540) {
1715     AliInfo("The Vector Fit is not complete!");
1716     return;
1717   }
1718   Int_t detector = -1;
1719   Int_t sector = -1;
1720   Float_t value  = 0.0;
1721
1722   /////////////////////////////////
1723   // Calculate the mean values
1724   ////////////////////////////////
1725   // Initialisation
1726   ////////////////////////
1727   Double_t meanAll = 0.0;
1728   Double_t rmsAll = 0.0;
1729   Double_t meanSupermodule[18];
1730   Double_t rmsSupermodule[18];
1731   Double_t meanDetector[540];
1732   Double_t rmsDetector[540];
1733   Int_t countAll = 0;
1734   Int_t countSupermodule[18];
1735   Int_t countDetector[540];
1736   for(Int_t sm = 0; sm < 18; sm++){
1737     rmsSupermodule[sm] = 0.0;
1738     meanSupermodule[sm] = 0.0;
1739     countSupermodule[sm] = 0;
1740   }
1741   for(Int_t det = 0; det < 540; det++){
1742     rmsDetector[det] = 0.0;
1743     meanDetector[det] = 0.0;
1744     countDetector[det] = 0;
1745   }
1746   // compute
1747   ////////////
1748   for (Int_t k = 0; k < loop; k++) {
1749     detector  = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetDetector();
1750     sector = GetSector(detector);
1751     if(perdetector){
1752       value = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetCoef()[0];
1753       if(value < 70.0) {
1754         rmsDetector[detector] += value*value;
1755         meanDetector[detector] += value;
1756         countDetector[detector]++;
1757         rmsSupermodule[sector] += value*value;
1758         meanSupermodule[sector] += value;
1759         countSupermodule[sector]++;
1760         meanAll += value;
1761         rmsAll += value*value;
1762         countAll++;
1763       }
1764     }
1765     else {
1766       Int_t rowMax    = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
1767       Int_t colMax    = fGeo->GetColMax(GetLayer(detector));
1768       for (Int_t row = 0; row < rowMax; row++) {
1769         for (Int_t col = 0; col < colMax; col++) {
1770           value = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
1771           if(value < 70.0) {
1772             rmsDetector[detector] += value*value;
1773             meanDetector[detector] += value;
1774             countDetector[detector]++;
1775             rmsSupermodule[sector] += value*value;
1776             meanSupermodule[sector] += value;
1777             countSupermodule[sector]++;
1778             rmsAll += value*value;
1779             meanAll += value;
1780             countAll++;
1781           }
1782           
1783         } // Col
1784       } // Row
1785     }
1786   }  
1787   if(countAll > 0) {
1788     meanAll = meanAll/countAll;
1789     rmsAll = TMath::Abs(rmsAll/countAll - (meanAll*meanAll));
1790   }
1791   for(Int_t sm = 0; sm < 18; sm++){
1792     if(countSupermodule[sm] > 0) {
1793       meanSupermodule[sm] = meanSupermodule[sm]/countSupermodule[sm];
1794       rmsSupermodule[sm] = TMath::Abs(rmsSupermodule[sm]/countSupermodule[sm] - (meanSupermodule[sm]*meanSupermodule[sm]));
1795     }
1796   }
1797   for(Int_t det = 0; det < 540; det++){
1798     if(countDetector[det] > 0) {
1799       meanDetector[det] = meanDetector[det]/countDetector[det];
1800       rmsDetector[det] = TMath::Abs(rmsDetector[det]/countDetector[det] - (meanDetector[det]*meanDetector[det]));
1801     }
1802   }
1803   //printf("Put mean value 2: meanAll %f, rmsAll %f\n",meanAll,rmsAll);
1804   ////////////////////////////////////////////
1805   // Put the mean value for the no-fitted
1806   /////////////////////////////////////////////  
1807   for (Int_t k = 0; k < loop; k++) {
1808     detector  = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetDetector();
1809     sector = GetSector(detector);
1810     Int_t rowMax    = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
1811     Int_t colMax    = fGeo->GetColMax(GetLayer(detector));
1812     Float_t *coef = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetCoef();
1813
1814     for (Int_t row = 0; row < rowMax; row++) {
1815       for (Int_t col = 0; col < colMax; col++) {
1816         value = coef[(Int_t)(col*rowMax+row)];
1817         if(value > 70.0) {
1818           if((ofwhat == 0) && (meanAll > -1.5) && (countAll > 15)) coef[(Int_t)(col*rowMax+row)] = meanAll+100.0;
1819           if(ofwhat == 1){
1820             if((meanDetector[detector] > -1.5) && (countDetector[detector] > 20)) coef[(Int_t)(col*rowMax+row)] = meanDetector[detector]+100.0;
1821             else if((meanSupermodule[sector] > -1.5) && (countSupermodule[sector] > 15)) coef[(Int_t)(col*rowMax+row)] = meanSupermodule[sector]+100.0;
1822             else if((meanAll > -1.5) && (countAll > 15)) coef[(Int_t)(col*rowMax+row)] = meanAll+100.0;
1823           }  
1824         }
1825         // Debug
1826         if(fDebugLevel > 1){
1827           
1828           if ( !fDebugStreamer ) {
1829             //debug stream
1830             TDirectory *backup = gDirectory;
1831             fDebugStreamer = new TTreeSRedirector("TRDDebugFit.root");
1832             if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
1833           } 
1834           
1835           Float_t coefnow      = coef[(Int_t)(col*rowMax+row)]; 
1836           
1837           (* fDebugStreamer) << "PutMeanValueOtherVectorFit2"<<
1838             "detector="<<detector<<
1839             "sector="<<sector<<
1840             "row="<<row<<
1841             "col="<<col<<
1842             "before="<<value<<
1843             "after="<<coefnow<<
1844             "\n";  
1845         }
1846       } // Col
1847     } // Row
1848   }
1849   
1850 }
1851 //_____________________________________________________________________________
1852 AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectVdrift(const TObjArray *vectorFit, Bool_t perdetector)
1853 {
1854   //
1855   // It creates the AliTRDCalDet object from the AliTRDFitInfo
1856   // It takes the mean value of the coefficients per detector 
1857   // This object has to be written in the database
1858   //
1859   
1860   // Create the DetObject
1861   AliTRDCalDet *object = new AliTRDCalDet("ChamberVdrift","TRD drift velocities (detector value)");
1862
1863   Int_t loop = (Int_t) vectorFit->GetEntriesFast();
1864   if(loop != 540) AliInfo("The Vector Fit is not complete!");
1865   Int_t detector = -1;
1866   Float_t value  = 0.0;
1867   
1868   //
1869   for (Int_t k = 0; k < loop; k++) {
1870     detector  = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
1871     Float_t mean  = 0.0;
1872     if(perdetector){
1873       mean = TMath::Abs(((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[0]);
1874     }
1875     else {
1876       Int_t   count = 0;
1877       Int_t rowMax    = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
1878       Int_t colMax    = fGeo->GetColMax(GetLayer(detector));
1879       for (Int_t row = 0; row < rowMax; row++) {
1880         for (Int_t col = 0; col < colMax; col++) {
1881           value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
1882           mean += TMath::Abs(value);
1883           count++;       
1884         } // Col
1885       } // Row
1886       if(count > 0) mean = mean/count;
1887     }
1888     object->SetValue(detector,mean);
1889   }
1890   
1891   return object;
1892 }
1893 //_____________________________________________________________________________
1894 AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectGain(const TObjArray *vectorFit, Bool_t meanOtherBefore, Double_t scaleFitFactor, Bool_t perdetector)
1895 {
1896   //
1897   // It creates the AliTRDCalDet object from the AliTRDFitInfo
1898   // It takes the mean value of the coefficients per detector 
1899   // This object has to be written in the database
1900   //
1901   
1902   // Create the DetObject
1903   AliTRDCalDet *object = new AliTRDCalDet("ChamberGainFactor","GainFactor (detector value)");
1904   
1905  
1906   Int_t loop = (Int_t) vectorFit->GetEntriesFast();
1907   if(loop != 540) AliInfo("The Vector Fit is not complete!");
1908   Int_t detector = -1;
1909   Float_t value  = 0.0;
1910
1911   for (Int_t k = 0; k < loop; k++) {
1912     detector  = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();  
1913     Float_t mean  = 0.0;
1914     if(perdetector){
1915       value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[0];
1916       if(!meanOtherBefore){
1917         if(value > 0) value = value*scaleFitFactor;
1918       }
1919       else value = value*scaleFitFactor;
1920       mean = TMath::Abs(value);
1921     }
1922     else{
1923       Int_t   count = 0;
1924       Int_t rowMax    = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
1925       Int_t colMax    = fGeo->GetColMax(GetLayer(detector));
1926       for (Int_t row = 0; row < rowMax; row++) {
1927         for (Int_t col = 0; col < colMax; col++) {
1928           value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
1929           if(!meanOtherBefore) {
1930             if(value > 0) value = value*scaleFitFactor;
1931           }
1932           else value = value*scaleFitFactor;
1933           mean += TMath::Abs(value);
1934           count++;       
1935         } // Col
1936       } // Row
1937       if(count > 0) mean = mean/count;
1938     }
1939     object->SetValue(detector,mean);
1940   }
1941  
1942   return object;
1943 }
1944 //_____________________________________________________________________________
1945 AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectT0(const TObjArray *vectorFit, Bool_t perdetector)
1946 {
1947   //
1948   // It creates the AliTRDCalDet object from the AliTRDFitInfo2
1949   // It takes the min value of the coefficients per detector 
1950   // This object has to be written in the database
1951   //
1952   
1953   // Create the DetObject
1954   AliTRDCalDet *object = new AliTRDCalDet("ChamberT0","T0 (detector value)");
1955   
1956   Int_t loop = (Int_t) vectorFit->GetEntriesFast();
1957   if(loop != 540) AliInfo("The Vector Fit is not complete!");
1958   Int_t detector = -1;
1959   Float_t value  = 0.0;
1960
1961   for (Int_t k = 0; k < loop; k++) {
1962     detector  = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();   
1963     Float_t min  = 100.0;
1964     if(perdetector){
1965       value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[0];
1966       // check successful
1967       if(value > 70.0) value = value-100.0;
1968       //
1969       min = value;
1970     }
1971     else{
1972       Int_t rowMax    = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
1973       Int_t colMax    = fGeo->GetColMax(GetLayer(detector));
1974       for (Int_t row = 0; row < rowMax; row++) {
1975         for (Int_t col = 0; col < colMax; col++) {
1976           value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
1977           // check successful
1978           if(value > 70.0) value = value-100.0;
1979           //
1980           if(min > value) min = value;
1981         } // Col
1982       } // Row
1983     }
1984     object->SetValue(detector,min);
1985   }
1986
1987   return object;
1988
1989 }
1990 //_____________________________________________________________________________
1991 AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectLorentzAngle(const TObjArray *vectorFit)
1992 {
1993   //
1994   // It creates the AliTRDCalDet object from the AliTRDFitInfo2
1995   // It takes the min value of the coefficients per detector 
1996   // This object has to be written in the database
1997   //
1998   
1999   // Create the DetObject
2000   AliTRDCalDet *object = new AliTRDCalDet("tan(lorentzangle)","tan(lorentzangle) (detector value)");
2001   
2002   
2003   Int_t loop = (Int_t) vectorFit->GetEntriesFast();
2004   if(loop != 540) AliInfo("The Vector Fit is not complete!");
2005   Int_t detector = -1;
2006   Float_t value  = 0.0;
2007
2008   for (Int_t k = 0; k < loop; k++) {
2009     detector  = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
2010     /*
2011       Int_t rowMax    = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
2012       Int_t colMax    = fGeo->GetColMax(GetLayer(detector));
2013       Float_t min  = 100.0;
2014       for (Int_t row = 0; row < rowMax; row++) {
2015       for (Int_t col = 0; col < colMax; col++) {
2016       value = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
2017       mean += -TMath::Abs(value);
2018       count++;       
2019       } // Col
2020       } // Row
2021       if(count > 0) mean = mean/count;
2022     */
2023     value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[0];
2024     object->SetValue(detector,-TMath::Abs(value));
2025   }
2026
2027   return object;
2028   
2029 }
2030 //_____________________________________________________________________________
2031 TObject *AliTRDCalibraFit::CreatePadObjectGain(const TObjArray *vectorFit, Double_t scaleFitFactor, const AliTRDCalDet *detobject)
2032 {
2033   //
2034   // It Creates the AliTRDCalPad object from AliTRDFitInfo
2035   // You need first to create the object for the detectors,
2036   // where the mean value is put.
2037   // This object has to be written in the database
2038   //
2039   
2040   // Create the DetObject
2041   AliTRDCalPad *object = new AliTRDCalPad("GainFactor","GainFactor (local variations)");
2042   
2043   if(!vectorFit){
2044     for(Int_t k = 0; k < 540; k++){
2045       AliTRDCalROC *calROC = object->GetCalROC(k);
2046       Int_t nchannels = calROC->GetNchannels();
2047       for(Int_t ch = 0; ch < nchannels; ch++){
2048         calROC->SetValue(ch,1.0);
2049       }
2050     }
2051   }
2052   else{
2053
2054     Int_t loop = (Int_t) vectorFit->GetEntriesFast();
2055     if(loop != 540) AliInfo("The Vector Fit is not complete!");
2056     Int_t detector = -1;
2057     Float_t value  = 0.0;
2058     
2059     for (Int_t k = 0; k < loop; k++) {
2060       detector  = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
2061       AliTRDCalROC *calROC = object->GetCalROC(detector);
2062       Float_t mean         = detobject->GetValue(detector);
2063       if(mean == 0) continue;
2064       Int_t rowMax    = calROC->GetNrows();
2065       Int_t colMax    = calROC->GetNcols();
2066       for (Int_t row = 0; row < rowMax; row++) {
2067         for (Int_t col = 0; col < colMax; col++) {
2068           value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
2069           if(value > 0) value = value*scaleFitFactor;
2070           calROC->SetValue(col,row,TMath::Abs(value)/mean);
2071         } // Col
2072       } // Row
2073     } 
2074   }
2075
2076   return object;  
2077 }
2078 //_____________________________________________________________________________
2079 TObject *AliTRDCalibraFit::CreatePadObjectVdrift(const TObjArray *vectorFit, const AliTRDCalDet *detobject)
2080 {
2081   //
2082   // It Creates the AliTRDCalPad object from AliTRDFitInfo
2083   // You need first to create the object for the detectors,
2084   // where the mean value is put.
2085   // This object has to be written in the database
2086   //
2087
2088   // Create the DetObject
2089   AliTRDCalPad *object = new AliTRDCalPad("LocalVdrift","TRD drift velocities (local variations)");
2090
2091   if(!vectorFit){
2092     for(Int_t k = 0; k < 540; k++){
2093       AliTRDCalROC *calROC = object->GetCalROC(k);
2094       Int_t nchannels = calROC->GetNchannels();
2095       for(Int_t ch = 0; ch < nchannels; ch++){
2096         calROC->SetValue(ch,1.0);
2097       }
2098     }
2099   }
2100   else {
2101     
2102     Int_t loop = (Int_t) vectorFit->GetEntriesFast();
2103     if(loop != 540) AliInfo("The Vector Fit is not complete!");
2104     Int_t detector = -1;
2105     Float_t value  = 0.0;
2106     
2107     for (Int_t k = 0; k < loop; k++) {
2108       detector  = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
2109       AliTRDCalROC *calROC = object->GetCalROC(detector);
2110       Float_t mean         = detobject->GetValue(detector);
2111       if(mean == 0) continue;
2112       Int_t rowMax    = calROC->GetNrows();
2113       Int_t colMax    = calROC->GetNcols();
2114       for (Int_t row = 0; row < rowMax; row++) {
2115         for (Int_t col = 0; col < colMax; col++) {
2116           value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
2117           calROC->SetValue(col,row,TMath::Abs(value)/mean);
2118         } // Col
2119       } // Row
2120     } 
2121   }
2122   return object;    
2123
2124 }
2125 //_____________________________________________________________________________
2126 TObject *AliTRDCalibraFit::CreatePadObjectT0(const TObjArray *vectorFit, const AliTRDCalDet *detobject)
2127 {
2128   //
2129   // It Creates the AliTRDCalPad object from AliTRDFitInfo2
2130   // You need first to create the object for the detectors,
2131   // where the mean value is put.
2132   // This object has to be written in the database
2133   //
2134   
2135   // Create the DetObject
2136   AliTRDCalPad *object = new AliTRDCalPad("LocalT0","T0 (local variations)");
2137
2138   if(!vectorFit){
2139     for(Int_t k = 0; k < 540; k++){
2140       AliTRDCalROC *calROC = object->GetCalROC(k);
2141       Int_t nchannels = calROC->GetNchannels();
2142       for(Int_t ch = 0; ch < nchannels; ch++){
2143         calROC->SetValue(ch,0.0);
2144       }
2145     }
2146   }
2147   else {
2148     
2149     Int_t loop = (Int_t) vectorFit->GetEntriesFast();
2150     if(loop != 540) AliInfo("The Vector Fit is not complete!");
2151     Int_t detector = -1;
2152     Float_t value  = 0.0;
2153     
2154     for (Int_t k = 0; k < loop; k++) {
2155       detector  = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
2156       AliTRDCalROC *calROC = object->GetCalROC(detector);
2157       Float_t min          = detobject->GetValue(detector);
2158       Int_t rowMax    = calROC->GetNrows();
2159       Int_t colMax    = calROC->GetNcols();
2160       for (Int_t row = 0; row < rowMax; row++) {
2161         for (Int_t col = 0; col < colMax; col++) {
2162           value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
2163           // check successful
2164           if(value > 70.0) value = value - 100.0;
2165           //
2166           calROC->SetValue(col,row,value-min);
2167         } // Col
2168       } // Row
2169     } 
2170   }
2171   return object;    
2172
2173 }
2174 //_____________________________________________________________________________
2175 TObject *AliTRDCalibraFit::CreatePadObjectPRF(const TObjArray *vectorFit)
2176 {
2177   //
2178   // It Creates the AliTRDCalPad object from AliTRDFitInfo
2179   // This object has to be written in the database
2180   //
2181   
2182   // Create the DetObject
2183   AliTRDCalPad *object = new AliTRDCalPad("PRFWidth","PRFWidth");
2184
2185   Int_t loop = (Int_t) vectorFit->GetEntriesFast();
2186   if(loop != 540) AliInfo("The Vector Fit is not complete!");
2187   Int_t detector = -1;
2188   Float_t value  = 0.0;
2189
2190   for (Int_t k = 0; k < loop; k++) {
2191     detector  = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
2192     AliTRDCalROC *calROC = object->GetCalROC(detector);
2193     Int_t rowMax    = calROC->GetNrows();
2194     Int_t colMax    = calROC->GetNcols();
2195     for (Int_t row = 0; row < rowMax; row++) {
2196       for (Int_t col = 0; col < colMax; col++) {
2197         value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
2198         calROC->SetValue(col,row,TMath::Abs(value));
2199       } // Col
2200     } // Row
2201   } 
2202
2203   return object;  
2204
2205 }
2206 //_____________________________________________________________________________
2207 AliTRDCalDet *AliTRDCalibraFit::MakeOutliersStatDet(const TObjArray *vectorFit, const char *name, Double_t &mean)
2208 {
2209   //
2210   // It Creates the AliTRDCalDet object from AliTRDFitInfo
2211   // 0 successful fit 1 not successful fit
2212   // mean is the mean value over the successful fit
2213   // do not use it for t0: no meaning
2214   //
2215   
2216   // Create the CalObject
2217   AliTRDCalDet *object = new AliTRDCalDet(name,name);
2218   mean = 0.0;
2219   Int_t count = 0;
2220   
2221   Int_t loop = (Int_t) vectorFit->GetEntriesFast();
2222   if(loop != 540) {
2223     AliInfo("The Vector Fit is not complete! We initialise all outliers");
2224     for(Int_t k = 0; k < 540; k++){
2225       object->SetValue(k,1.0);
2226     }
2227   }
2228   Int_t detector = -1;
2229   Float_t value  = 0.0;
2230   
2231   for (Int_t k = 0; k < loop; k++) {
2232     detector  = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
2233     value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[0];
2234     if(value <= 0) object->SetValue(detector,1.0);
2235     else {
2236       object->SetValue(detector,0.0);
2237       mean += value;
2238       count++;
2239     }
2240   }
2241   if(count > 0) mean /= count;
2242   return object;  
2243 }
2244 //_____________________________________________________________________________
2245 TObject *AliTRDCalibraFit::MakeOutliersStatPad(const TObjArray *vectorFit, const char *name, Double_t &mean)
2246 {
2247   //
2248   // It Creates the AliTRDCalPad object from AliTRDFitInfo
2249   // 0 not successful fit 1 successful fit
2250   // mean mean value over the successful fit
2251   //
2252   
2253   // Create the CalObject
2254   AliTRDCalPad *object = new AliTRDCalPad(name,name);
2255   mean = 0.0;
2256   Int_t count = 0;
2257   
2258   Int_t loop = (Int_t) vectorFit->GetEntriesFast();
2259   if(loop != 540) {
2260     AliInfo("The Vector Fit is not complete! We initialise all outliers");
2261     for(Int_t k = 0; k < 540; k++){
2262       AliTRDCalROC *calROC = object->GetCalROC(k);
2263       Int_t nchannels = calROC->GetNchannels();
2264       for(Int_t ch = 0; ch < nchannels; ch++){
2265         calROC->SetValue(ch,1.0);
2266       }
2267     }
2268   }
2269   Int_t detector = -1;
2270   Float_t value  = 0.0;
2271   
2272   for (Int_t k = 0; k < loop; k++) {
2273     detector  = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
2274     AliTRDCalROC *calROC = object->GetCalROC(detector);
2275     Int_t nchannels    = calROC->GetNchannels();
2276     for (Int_t ch = 0; ch < nchannels; ch++) {
2277       value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[ch];
2278       if(value <= 0) calROC->SetValue(ch,1.0);
2279       else {
2280         calROC->SetValue(ch,0.0);
2281         mean += value;
2282         count++;
2283       }
2284     } // channels
2285   }
2286   if(count > 0) mean /= count;
2287   return object;  
2288 }
2289 //_____________________________________________________________________________
2290 void AliTRDCalibraFit::SetPeriodeFitPH(Int_t periodeFitPH)
2291
2292   //
2293   // Set FitPH if 1 then each detector will be fitted
2294   //
2295
2296   if (periodeFitPH > 0) {
2297     fFitPHPeriode   = periodeFitPH; 
2298   }
2299   else {
2300     AliInfo("periodeFitPH must be higher than 0!");
2301   }
2302
2303 }
2304 //_____________________________________________________________________________
2305 void AliTRDCalibraFit::SetBeginFitCharge(Float_t beginFitCharge)
2306
2307   //
2308   // The fit of the deposited charge distribution begins at
2309   // histo->Mean()/beginFitCharge
2310   // You can here set beginFitCharge
2311   //
2312
2313   if (beginFitCharge > 0) {
2314     fBeginFitCharge = beginFitCharge; 
2315   }
2316   else {
2317     AliInfo("beginFitCharge must be strict positif!");
2318   }
2319
2320 }
2321
2322 //_____________________________________________________________________________
2323 void AliTRDCalibraFit::SetT0Shift0(Float_t t0Shift) 
2324
2325   //
2326   // The t0 calculated with the maximum positif slope is shift from t0Shift0
2327   // You can here set t0Shift0
2328   //
2329
2330   if (t0Shift > 0) {
2331     fT0Shift0 = t0Shift; 
2332   } 
2333   else {
2334     AliInfo("t0Shift0 must be strict positif!");
2335   }
2336
2337 }
2338
2339 //_____________________________________________________________________________
2340 void AliTRDCalibraFit::SetT0Shift1(Float_t t0Shift) 
2341
2342   //
2343   // The t0 calculated with the maximum of the amplification region is shift from t0Shift1
2344   // You can here set t0Shift1
2345   //
2346
2347   if (t0Shift > 0) {
2348     fT0Shift1 = t0Shift; 
2349   } 
2350   else {
2351     AliInfo("t0Shift must be strict positif!");
2352   }
2353
2354 }
2355
2356 //_____________________________________________________________________________
2357 void AliTRDCalibraFit::SetRangeFitPRF(Float_t rangeFitPRF)
2358
2359   //
2360   // The fit of the PRF is from -rangeFitPRF to rangeFitPRF
2361   // You can here set rangeFitPRF
2362   //
2363
2364   if ((rangeFitPRF >    0) && 
2365       (rangeFitPRF <= 1.5)) {
2366     fRangeFitPRF = rangeFitPRF;
2367   } 
2368   else {
2369     AliInfo("rangeFitPRF must be between 0 and 1.0");
2370   }
2371
2372 }
2373
2374 //_____________________________________________________________________________
2375 void AliTRDCalibraFit::SetMinEntries(Int_t minEntries)
2376
2377   //
2378   // Minimum entries for fitting
2379   //
2380
2381   if (minEntries >    0) {
2382     fMinEntries = minEntries;
2383   } 
2384   else {
2385     AliInfo("fMinEntries must be >= 0.");
2386   }
2387
2388 }
2389
2390 //_____________________________________________________________________________
2391 void AliTRDCalibraFit::SetRebin(Short_t rebin)
2392
2393   //
2394   // Rebin with rebin time less bins the Ch histo
2395   // You can set here rebin that should divide the number of bins of CH histo
2396   //
2397
2398   if (rebin > 0) {
2399     fRebin = rebin; 
2400     AliInfo("You have to be sure that fRebin divides fNumberBinCharge used!");
2401   } 
2402   else {
2403     AliInfo("You have to choose a positiv value!");
2404   }
2405
2406 }
2407 //_____________________________________________________________________________
2408 Bool_t AliTRDCalibraFit::FillVectorFit()
2409 {
2410   //
2411   // For the Fit functions fill the vector Fit
2412   //
2413
2414   AliTRDFitInfo *fitInfo = new AliTRDFitInfo();
2415
2416   Int_t ntotal = 1;
2417   if (GetStack(fCountDet) == 2) {
2418     ntotal = 1728;
2419   }
2420   else {
2421     ntotal = 2304;
2422   }
2423
2424   //printf("For the detector %d , ntotal %d and fCoefCH[0] %f\n",countdet,ntotal,fCoefCH[0]);
2425   Float_t *coef = new Float_t[ntotal];
2426   for (Int_t i = 0; i < ntotal; i++) {
2427     coef[i] = fCurrentCoefDetector[i];
2428   }
2429   
2430   Int_t detector = fCountDet;
2431   // Set
2432   fitInfo->SetCoef(coef);
2433   fitInfo->SetDetector(detector);
2434   fVectorFit.Add((TObject *) fitInfo);
2435
2436   return kTRUE;
2437
2438 }
2439 //_____________________________________________________________________________
2440 Bool_t AliTRDCalibraFit::FillVectorFit2()
2441 {
2442   //
2443   // For the Fit functions fill the vector Fit
2444   //
2445
2446   AliTRDFitInfo *fitInfo = new AliTRDFitInfo();
2447
2448   Int_t ntotal = 1;
2449   if (GetStack(fCountDet) == 2) {
2450     ntotal = 1728;
2451   }
2452   else {
2453     ntotal = 2304;
2454   }
2455
2456   //printf("For the detector %d , ntotal %d and fCoefCH[0] %f\n",countdet,ntotal,fCoefCH[0]);
2457   Float_t *coef = new Float_t[ntotal];
2458   for (Int_t i = 0; i < ntotal; i++) {
2459     coef[i] = fCurrentCoefDetector2[i];
2460   }
2461   
2462   Int_t detector = fCountDet;
2463   // Set
2464   fitInfo->SetCoef(coef);
2465   fitInfo->SetDetector(detector);
2466   fVectorFit2.Add((TObject *) fitInfo);
2467
2468   return kTRUE;
2469
2470 }
2471 //____________Functions for initialising the AliTRDCalibraFit in the code_________
2472 Bool_t AliTRDCalibraFit::InitFit(Int_t nbins, Int_t i)
2473 {
2474   //
2475   // Init the number of expected bins and fDect1[i] fDect2[i] 
2476   //
2477
2478   gStyle->SetPalette(1);
2479   gStyle->SetOptStat(1111);
2480   gStyle->SetPadBorderMode(0);
2481   gStyle->SetCanvasColor(10);
2482   gStyle->SetPadLeftMargin(0.13);
2483   gStyle->SetPadRightMargin(0.01);
2484   
2485   // Mode groups of pads: the total number of bins!
2486   CalculNumberOfBinsExpected(i);
2487   
2488   // Quick verification that we have the good pad calibration mode!
2489   if (fNumberOfBinsExpected != nbins) {
2490     AliInfo(Form("It doesn't correspond to the mode of pad group calibration: expected %d and seen %d!",fNumberOfBinsExpected,nbins));
2491     return kFALSE;
2492   }
2493   
2494   // Security for fDebug 3 and 4
2495   if ((fDebugLevel >= 3) && 
2496       ((fDet[0] >  5) || 
2497        (fDet[1] >  4) || 
2498        (fDet[2] > 17))) {
2499     AliInfo("This detector doesn't exit!");
2500     return kFALSE;
2501   }
2502
2503   // Determine fDet1 and fDet2 and set the fNfragZ and fNfragRphi for debug 3 and 4
2504   CalculDect1Dect2(i);
2505
2506  
2507   return kTRUE;
2508 }
2509 //____________Functions for initialising the AliTRDCalibraFit in the code_________
2510 Bool_t AliTRDCalibraFit::InitFitCH()
2511 {
2512   //
2513   // Init the fVectorFitCH for normalisation
2514   // Init the histo for debugging 
2515   //
2516
2517   gDirectory = gROOT;
2518  
2519   fScaleFitFactor = 0.0;
2520   fCurrentCoefDetector   = new Float_t[2304];
2521   for (Int_t k = 0; k < 2304; k++) {
2522     fCurrentCoefDetector[k] = 0.0;    
2523   }
2524   fVectorFit.SetName("gainfactorscoefficients");
2525
2526   // fDebug == 0 nothing
2527   // fDebug == 1 and fFitVoir no histo
2528   if (fDebugLevel == 1) {
2529     if(!CheckFitVoir()) return kFALSE;
2530   }
2531   //Get the CalDet object
2532   if(fAccCDB){
2533     AliTRDcalibDB     *cal    = AliTRDcalibDB::Instance();
2534     if (!cal) {
2535       AliInfo("Could not get calibDB");
2536       return kFALSE;
2537     }
2538     if(fCalDet) delete fCalDet;
2539     fCalDet = new AliTRDCalDet(*(cal->GetGainFactorDet()));
2540   }
2541   else{
2542     Float_t devalue = 1.0;
2543     if(fCalDet) delete fCalDet;
2544     fCalDet = new AliTRDCalDet("ChamberGainFactor","GainFactor (detector value)");
2545     for(Int_t k = 0; k < 540; k++){
2546       fCalDet->SetValue(k,devalue);
2547     }
2548   }
2549   return kTRUE;
2550   
2551 }
2552 //____________Functions for initialising the AliTRDCalibraFit in the code_________
2553 Bool_t AliTRDCalibraFit::InitFitPH()
2554 {
2555   //
2556   // Init the arrays of results 
2557   // Init the histos for debugging 
2558   //
2559
2560   gDirectory = gROOT;
2561   fVectorFit.SetName("driftvelocitycoefficients");
2562   fVectorFit2.SetName("t0coefficients");
2563
2564   fCurrentCoefDetector   = new Float_t[2304];
2565   for (Int_t k = 0; k < 2304; k++) {
2566     fCurrentCoefDetector[k] = 0.0;    
2567   }
2568
2569   fCurrentCoefDetector2   = new Float_t[2304];
2570   for (Int_t k = 0; k < 2304; k++) {
2571     fCurrentCoefDetector2[k] = 0.0;    
2572   }
2573  
2574   //fDebug == 0 nothing
2575   // fDebug == 1 and fFitVoir no histo
2576   if (fDebugLevel == 1) {
2577     if(!CheckFitVoir()) return kFALSE;
2578   }
2579   //Get the CalDet object
2580   if(fAccCDB){
2581     AliTRDcalibDB     *cal    = AliTRDcalibDB::Instance();
2582     if (!cal) {
2583       AliInfo("Could not get calibDB");
2584       return kFALSE;
2585     }
2586     if(fCalDet) delete fCalDet;
2587     if(fCalDet2) delete fCalDet2;
2588     fCalDet  = new AliTRDCalDet(*(cal->GetVdriftDet()));
2589     fCalDet2 = new AliTRDCalDet(*(cal->GetT0Det())); 
2590   }
2591   else{
2592     Float_t devalue  = 1.5;
2593     Float_t devalue2 = 0.0; 
2594     if(fCalDet) delete fCalDet;
2595     if(fCalDet2) delete fCalDet2;
2596     fCalDet  = new AliTRDCalDet("ChamberVdrift","TRD drift velocities (detector value)");
2597     fCalDet2 = new AliTRDCalDet("ChamberT0","T0 (detector value)");
2598     for(Int_t k = 0; k < 540; k++){
2599       fCalDet->SetValue(k,devalue);
2600       fCalDet2->SetValue(k,devalue2);
2601     }
2602   }
2603   return kTRUE;
2604 }
2605 //____________Functions for initialising the AliTRDCalibraFit in the code_________
2606 Bool_t AliTRDCalibraFit::InitFitPRF()
2607 {
2608   //
2609   // Init the calibration mode (Nz, Nrphi), the histograms for
2610   // debugging the fit methods if fDebug > 0, 
2611   //
2612   
2613   gDirectory = gROOT;
2614   fVectorFit.SetName("prfwidthcoefficients");
2615  
2616   fCurrentCoefDetector   = new Float_t[2304];
2617   for (Int_t k = 0; k < 2304; k++) {
2618     fCurrentCoefDetector[k] = 0.0;    
2619   }
2620   
2621   // fDebug == 0 nothing
2622   // fDebug == 1 and fFitVoir no histo
2623   if (fDebugLevel == 1) {
2624     if(!CheckFitVoir()) return kFALSE;
2625   }
2626   return kTRUE;
2627 }
2628 //____________Functions for initialising the AliTRDCalibraFit in the code_________
2629 Bool_t AliTRDCalibraFit::InitFitLinearFitter()
2630 {
2631   //
2632   // Init the fCalDet, fVectorFit fCurrentCoefDetector 
2633   //
2634   
2635   gDirectory = gROOT;
2636  
2637   fCurrentCoefDetector   = new Float_t[2304];
2638   fCurrentCoefDetector2  = new Float_t[2304];
2639   for (Int_t k = 0; k < 2304; k++) {
2640     fCurrentCoefDetector[k]  = 0.0;
2641     fCurrentCoefDetector2[k] = 0.0;    
2642   }
2643
2644   //printf("test0\n");
2645   
2646   AliTRDcalibDB     *cal    = AliTRDcalibDB::Instance();
2647   if (!cal) {
2648     AliInfo("Could not get calibDB");
2649     return kFALSE;
2650   }
2651   
2652   //Get the CalDet object
2653   if(fAccCDB){
2654     if(fCalDet) delete fCalDet;
2655     if(fCalDet2) delete fCalDet2;
2656     fCalDet  = new AliTRDCalDet(*(cal->GetVdriftDet()));
2657     //printf("test1\n");
2658     fCalDet2 = new AliTRDCalDet("lorentz angle tan","lorentz angle tan (detector value)");
2659     //printf("test2\n");
2660     for(Int_t k = 0; k < 540; k++){
2661       fCalDet2->SetValue(k,AliTRDCommonParam::Instance()->GetOmegaTau(fCalDet->GetValue(k)));
2662     }
2663     //printf("test3\n");
2664   }
2665   else{
2666     Float_t devalue  = 1.5;
2667     Float_t devalue2 = AliTRDCommonParam::Instance()->GetOmegaTau(1.5); 
2668     if(fCalDet) delete fCalDet;
2669     if(fCalDet2) delete fCalDet2;
2670     //printf("test1\n");
2671     fCalDet  = new AliTRDCalDet("ChamberVdrift","TRD drift velocities (detector value)");
2672     fCalDet2 = new AliTRDCalDet("lorentz angle tan","lorentz angle tan (detector value)");
2673     //printf("test2\n");
2674     for(Int_t k = 0; k < 540; k++){
2675       fCalDet->SetValue(k,devalue);
2676       fCalDet2->SetValue(k,devalue2);
2677     }
2678     //printf("test3\n");
2679   }
2680   return kTRUE;
2681 }
2682
2683 //____________Functions for initialising the AliTRDCalibraFit in the code_________
2684 void AliTRDCalibraFit::InitfCountDetAndfCount(Int_t i)
2685 {
2686   //
2687   // Init the current detector where we are fCountDet and the
2688   // next fCount for the functions Fit... 
2689   //
2690
2691   // Loop on the Xbins of ch!!
2692   fCountDet = -1; // Current detector
2693   fCount    =  0; // To find the next detector
2694   
2695   // If fDebug >= 3
2696   if (fDebugLevel >= 3) {
2697     // Set countdet to the detector
2698     fCountDet = AliTRDgeometry::GetDetector(fDet[0],fDet[1],fDet[2]);
2699     // Set counter to write at the end of the detector
2700     fCount = fDect2;
2701     // Get the right calib objects
2702     SetCalROC(i);
2703   }
2704   if(fDebugLevel == 1) {
2705     fCountDet = 0;
2706     fCalibraMode->CalculXBins(fCountDet,i);
2707     if((fCalibraMode->GetNz(i)!=100) && (fCalibraMode->GetNrphi(i)!=100)){
2708       while(fCalibraMode->GetXbins(i) <=fFitVoir){
2709         fCountDet++;
2710         fCalibraMode->CalculXBins(fCountDet,i);
2711         //printf("GetXBins %d\n",fCalibraMode->GetXbins(i));
2712       }      
2713     }
2714     else {
2715       fCountDet++;
2716     }
2717     fCount    = fCalibraMode->GetXbins(i);
2718     fCountDet--;
2719     // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
2720     fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),i);
2721     fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
2722                                       ,(Int_t) GetStack(fCountDet)
2723                                       ,(Int_t) GetSector(fCountDet),i);
2724   }
2725 }
2726 //_______________________________________________________________________________
2727 void AliTRDCalibraFit::CalculNumberOfBinsExpected(Int_t i)
2728 {
2729   //
2730   // Calculate the number of bins expected (calibration groups)
2731   //
2732   
2733   fNumberOfBinsExpected = 0;
2734   // All
2735   if((fCalibraMode->GetNz(i) == 100) && (fCalibraMode->GetNrphi(i) == 100)){
2736     fNumberOfBinsExpected = 1;
2737     return;
2738   }
2739   // Per supermodule
2740   if((fCalibraMode->GetNz(i) == 10) && (fCalibraMode->GetNrphi(i) == 10)){
2741     fNumberOfBinsExpected = 18;
2742     return;
2743   }
2744   // More
2745   fCalibraMode->ModePadCalibration(2,i);
2746   fCalibraMode->ModePadFragmentation(0,2,0,i);
2747   fCalibraMode->SetDetChamb2(i);
2748   if (fDebugLevel > 1) {
2749     AliInfo(Form("For the chamber 2: %d",fCalibraMode->GetDetChamb2(i)));
2750   }
2751   fNumberOfBinsExpected += 6 * 18 * fCalibraMode->GetDetChamb2(i);
2752   fCalibraMode->ModePadCalibration(0,i);
2753   fCalibraMode->ModePadFragmentation(0,0,0,i);
2754   fCalibraMode->SetDetChamb0(i);
2755   if (fDebugLevel > 1) {
2756     AliInfo(Form("For the other chamber 0: %d",fCalibraMode->GetDetChamb0(i)));
2757   }
2758   fNumberOfBinsExpected += 6 * 4 * 18 * fCalibraMode->GetDetChamb0(i);
2759  
2760 }
2761 //_______________________________________________________________________________
2762 void AliTRDCalibraFit::CalculDect1Dect2(Int_t i)
2763 {
2764   //
2765   // Calculate the range of fits
2766   //
2767   
2768   fDect1 = -1;
2769   fDect2 = -1;
2770   if (fDebugLevel == 1) {
2771     fDect1 = fFitVoir;
2772     fDect2 = fDect1 +1;
2773   }
2774   if ((fDebugLevel == 2) || (fDebugLevel == 0)) {
2775     fDect1 = 0;
2776     fDect2 = fNumberOfBinsExpected;
2777   }
2778   if (fDebugLevel >= 3) {
2779     fCountDet = AliTRDgeometry::GetDetector(fDet[0],fDet[1],fDet[2]);
2780     fCalibraMode->CalculXBins(fCountDet,i);
2781     fDect1 = fCalibraMode->GetXbins(i);
2782     // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
2783     fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),i);
2784     fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
2785                                       ,(Int_t) GetStack(fCountDet)
2786                                       ,(Int_t) GetSector(fCountDet),i);
2787     // Set for the next detector
2788     fDect2 = fDect1 + fCalibraMode->GetNfragZ(i)*fCalibraMode->GetNfragRphi(i);
2789   }
2790 }
2791 //_______________________________________________________________________________
2792 Bool_t AliTRDCalibraFit::CheckFitVoir()
2793 {
2794   //
2795   // Check if fFitVoir is in the range
2796   //
2797   
2798   if (fFitVoir < fNumberOfBinsExpected) {
2799     AliInfo(Form("We will see the fit of the object %d",fFitVoir));
2800   }
2801   else {
2802     AliInfo("fFitVoir is out of range of the histo!");
2803     return kFALSE;
2804   }
2805   return kTRUE;
2806 }
2807 //____________Functions for initialising the AliTRDCalibraFit in the code_________
2808 void AliTRDCalibraFit::UpdatefCountDetAndfCount(Int_t idect, Int_t i)
2809 {
2810   //
2811   // See if we are in a new detector and update the
2812   // variables fNfragZ and fNfragRphi if yes 
2813   // Will never happen for only one detector (3 and 4)
2814   // Doesn't matter for 2
2815   //
2816   if (fCount == idect) {
2817     // On en est au detector (or first detector in the group)
2818     fCountDet += 1;
2819     AliDebug(2,Form("We are at the detector %d\n",fCountDet));
2820     // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
2821     fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),i);
2822     fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
2823                                        ,(Int_t) GetStack(fCountDet)
2824                                        ,(Int_t) GetSector(fCountDet),i);
2825     // Set for the next detector
2826     fCount += fCalibraMode->GetNfragZ(i)*fCalibraMode->GetNfragRphi(i);
2827     // calib objects
2828     SetCalROC(i);
2829   }
2830 }
2831 //____________Functions for initialising the AliTRDCalibraFit in the code_________
2832 void AliTRDCalibraFit::ReconstructFitRowMinRowMax(Int_t idect, Int_t i)
2833 {
2834   //
2835   // Reconstruct the min pad row, max pad row, min pad col and
2836   // max pad col of the calibration group for the Fit functions
2837   // idect is the calibration group inside the detector
2838   //
2839   if (fDebugLevel !=  1) {
2840     fCalibraMode->ReconstructionRowPadGroup((Int_t) (idect-(fCount-(fCalibraMode->GetNfragZ(i)*fCalibraMode->GetNfragRphi(i)))),i);
2841   }
2842   AliDebug(2,Form("AliTRDCalibraFit::ReconstructFitRowMinRowMax: the local calibration group is %d",idect-(fCount-(fCalibraMode->GetNfragZ(i)*fCalibraMode->GetNfragRphi(i)))));
2843   AliDebug(2,Form("AliTRDCalibraFit::ReconstructFitRowMinRowMax: the number of group per detector is %d",fCalibraMode->GetNfragZ(i)*fCalibraMode->GetNfragRphi(i)));
2844 }
2845 //____________Functions for initialising the AliTRDCalibraFit in the code_________
2846 Bool_t AliTRDCalibraFit::NotEnoughStatisticCH(Int_t idect)
2847 {
2848   //
2849   // For the case where there are not enough entries in the histograms
2850   // of the calibration group, the value present in the choosen database
2851   // will be put. A negativ sign enables to know that a fit was not possible.
2852   //
2853   
2854   if (fDebugLevel == 1) {
2855     AliInfo("The element has not enough statistic to be fitted");
2856   }
2857   else if (fNbDet > 0){
2858     Int_t firstdetector = fCountDet;
2859     Int_t lastdetector  = fCountDet+fNbDet;
2860     AliInfo(Form("The element %d containing the detectors %d to %d has not enough statistic to be fitted"
2861                  ,idect,firstdetector,lastdetector));
2862     // loop over detectors
2863     for(Int_t det = firstdetector; det < lastdetector; det++){
2864
2865       //Set the calibration object again
2866       fCountDet = det;
2867       SetCalROC(0);   
2868
2869       // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
2870       // Put them at 1
2871       fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),0);
2872       fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
2873                                          ,(Int_t) GetStack(fCountDet)
2874                                          ,(Int_t) GetSector(fCountDet),0);
2875       // Reconstruct row min row max
2876       ReconstructFitRowMinRowMax(idect,0);      
2877
2878       // Calcul the coef from the database choosen for the detector
2879       CalculChargeCoefMean(kFALSE);
2880       
2881       //stack 2, not stack 2
2882       Int_t factor = 0;
2883       if(GetStack(fCountDet) == 2) factor = 12;
2884       else factor = 16;
2885       
2886       // Fill the fCurrentCoefDetector with negative value to say: not fitted
2887       for (Int_t k = fCalibraMode->GetRowMin(0); k < fCalibraMode->GetRowMax(0); k++) {
2888         for (Int_t j = fCalibraMode->GetColMin(0); j < fCalibraMode->GetColMax(0); j++) {
2889           fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
2890         }
2891       }
2892       
2893       //Put default value negative
2894       fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
2895       fCurrentCoefE   = 0.0;
2896       
2897       // Fill the stuff
2898       FillVectorFit();
2899       // Debug
2900       if(fDebugLevel > 1){ 
2901         
2902         if ( !fDebugStreamer ) {
2903           //debug stream
2904           TDirectory *backup = gDirectory;
2905           fDebugStreamer = new TTreeSRedirector("TRDDebugFitCH.root");
2906           if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
2907         } 
2908         
2909         Int_t   detector   = fCountDet;
2910         Int_t   caligroup  = idect;
2911         Short_t rowmin     = fCalibraMode->GetRowMin(0);
2912         Short_t rowmax     = fCalibraMode->GetRowMax(0);
2913         Short_t colmin     = fCalibraMode->GetColMin(0);
2914         Short_t colmax     = fCalibraMode->GetColMax(0);
2915         Float_t gf         = fCurrentCoef[0]; 
2916         Float_t gfs        = fCurrentCoef[1]; 
2917         Float_t gfE        = fCurrentCoefE;
2918         
2919         (*fDebugStreamer) << "FillFillCH" <<
2920           "detector=" << detector <<
2921           "caligroup=" << caligroup <<
2922           "rowmin=" << rowmin <<
2923           "rowmax=" << rowmax <<
2924           "colmin=" << colmin <<
2925           "colmax=" << colmax <<
2926           "gf=" << gf <<
2927           "gfs=" << gfs <<
2928           "gfE=" << gfE <<
2929           "\n"; 
2930         
2931       }
2932       // Reset
2933       for (Int_t k = 0; k < 2304; k++) {
2934         fCurrentCoefDetector[k] = 0.0;
2935       }
2936       
2937     }// loop detector
2938     AliDebug(2,Form("Check the count now: fCountDet %d",fCountDet));
2939   }
2940   else {
2941
2942     AliInfo(Form("The element %d in this detector %d has not enough statistic to be fitted"
2943                  ,idect-(fCount-(fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0))),fCountDet));
2944     
2945     // Calcul the coef from the database choosen
2946     CalculChargeCoefMean(kFALSE);
2947
2948     //stack 2, not stack 2
2949     Int_t factor = 0;
2950     if(GetStack(fCountDet) == 2) factor = 12;
2951     else factor = 16;
2952     
2953     // Fill the fCurrentCoefDetector with negative value to say: not fitted
2954     for (Int_t k = fCalibraMode->GetRowMin(0); k < fCalibraMode->GetRowMax(0); k++) {
2955       for (Int_t j = fCalibraMode->GetColMin(0); j < fCalibraMode->GetColMax(0); j++) {
2956         fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
2957       }
2958     }
2959     
2960     //Put default value negative
2961     fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
2962     fCurrentCoefE   = 0.0;
2963    
2964     FillFillCH(idect);
2965   }
2966   
2967   return kTRUE;
2968 }
2969
2970
2971 //____________Functions for initialising the AliTRDCalibraFit in the code_________
2972 Bool_t AliTRDCalibraFit::NotEnoughStatisticPH(Int_t idect,Double_t nentries)
2973 {
2974   //
2975   // For the case where there are not enough entries in the histograms
2976   // of the calibration group, the value present in the choosen database
2977   // will be put. A negativ sign enables to know that a fit was not possible.
2978   //
2979   if (fDebugLevel == 1) {
2980     AliInfo("The element has not enough statistic to be fitted");
2981   }
2982   else if (fNbDet > 0) {
2983
2984     Int_t firstdetector = fCountDet;
2985     Int_t lastdetector  = fCountDet+fNbDet;
2986     AliInfo(Form("The element %d containing the detectors %d to %d has not enough statistic to be fitted"
2987                  ,idect,firstdetector,lastdetector));
2988     // loop over detectors
2989     for(Int_t det = firstdetector; det < lastdetector; det++){
2990
2991       //Set the calibration object again
2992       fCountDet = det;
2993       SetCalROC(1);   
2994
2995       // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
2996       // Put them at 1
2997       fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),1);
2998       fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
2999                                          ,(Int_t) GetStack(fCountDet)
3000                                          ,(Int_t) GetSector(fCountDet),1);
3001       // Reconstruct row min row max
3002       ReconstructFitRowMinRowMax(idect,1);      
3003
3004       // Calcul the coef from the database choosen for the detector
3005       CalculVdriftCoefMean();
3006       CalculT0CoefMean();
3007       
3008       //stack 2, not stack 2
3009       Int_t factor = 0;
3010       if(GetStack(fCountDet) == 2) factor = 12;
3011       else factor = 16;
3012       
3013       // Fill the fCurrentCoefDetector with negative value to say: not fitted
3014       for (Int_t k = fCalibraMode->GetRowMin(1); k < fCalibraMode->GetRowMax(1); k++) {
3015         for (Int_t j = fCalibraMode->GetColMin(1); j < fCalibraMode->GetColMax(1); j++) {
3016           fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
3017           fCurrentCoefDetector2[(Int_t)(j*factor+k)] = fCurrentCoef2[1] + 100.0;
3018         }
3019       }
3020       
3021       //Put default value negative
3022       fCurrentCoef[0]  = -TMath::Abs(fCurrentCoef[1]);
3023       fCurrentCoefE    = 0.0;
3024       fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
3025       fCurrentCoefE2   = 0.0;
3026             
3027       // Fill the stuff
3028       FillVectorFit();
3029       FillVectorFit2();
3030       // Debug
3031       if(fDebugLevel > 1){ 
3032
3033         if ( !fDebugStreamer ) {
3034           //debug stream
3035           TDirectory *backup = gDirectory;
3036           fDebugStreamer = new TTreeSRedirector("TRDDebugFitPH.root");
3037           if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
3038         } 
3039         
3040         
3041         Int_t   detector     = fCountDet;
3042         Int_t   caligroup    = idect;
3043         Short_t rowmin       = fCalibraMode->GetRowMin(1);
3044         Short_t rowmax       = fCalibraMode->GetRowMax(1);
3045         Short_t colmin       = fCalibraMode->GetColMin(1);
3046         Short_t colmax       = fCalibraMode->GetColMax(1);
3047         Float_t vf           = fCurrentCoef[0]; 
3048         Float_t vs           = fCurrentCoef[1]; 
3049         Float_t vfE          = fCurrentCoefE;
3050         Float_t t0f          = fCurrentCoef2[0]; 
3051         Float_t t0s          = fCurrentCoef2[1]; 
3052         Float_t t0E          = fCurrentCoefE2;
3053         
3054         
3055         
3056         (* fDebugStreamer) << "FillFillPH"<<
3057         "detector="<<detector<<
3058           "nentries="<<nentries<<
3059           "caligroup="<<caligroup<<
3060           "rowmin="<<rowmin<<
3061           "rowmax="<<rowmax<<
3062           "colmin="<<colmin<<
3063           "colmax="<<colmax<<
3064           "vf="<<vf<<
3065           "vs="<<vs<<
3066           "vfE="<<vfE<<
3067           "t0f="<<t0f<<
3068           "t0s="<<t0s<<
3069           "t0E="<<t0E<<
3070           "\n";  
3071       }
3072       // Reset
3073       for (Int_t k = 0; k < 2304; k++) {
3074         fCurrentCoefDetector[k] = 0.0;
3075         fCurrentCoefDetector2[k] = 0.0;
3076       }
3077       
3078     }// loop detector
3079     AliDebug(2,Form("Check the count now: fCountDet %d",fCountDet));
3080   }    
3081   else {
3082
3083     AliInfo(Form("The element %d in this detector %d has not enough statistic to be fitted"
3084                  ,idect-(fCount-(fCalibraMode->GetNfragZ(1)*fCalibraMode->GetNfragRphi(1))),fCountDet));
3085
3086     CalculVdriftCoefMean();
3087     CalculT0CoefMean();
3088   
3089     //stack 2 and not stack 2
3090     Int_t factor = 0;
3091     if(GetStack(fCountDet) == 2) factor = 12;
3092     else factor = 16;
3093
3094
3095     // Fill the fCurrentCoefDetector 2
3096     for (Int_t k = fCalibraMode->GetRowMin(1); k < fCalibraMode->GetRowMax(1); k++) {
3097       for (Int_t j = fCalibraMode->GetColMin(1); j < fCalibraMode->GetColMax(1); j++) {
3098         fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
3099         fCurrentCoefDetector2[(Int_t)(j*factor+k)] = fCurrentCoef2[1] + 100.0;
3100       }
3101     }
3102
3103     // Put the default value
3104     fCurrentCoef[0]  = -TMath::Abs(fCurrentCoef[1]);
3105     fCurrentCoefE    = 0.0;
3106     fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
3107     fCurrentCoefE2   = 0.0;
3108      
3109     FillFillPH(idect,nentries);
3110     
3111   }
3112   
3113   return kTRUE;
3114   
3115 }
3116
3117
3118 //____________Functions for initialising the AliTRDCalibraFit in the code_________
3119 Bool_t AliTRDCalibraFit::NotEnoughStatisticPRF(Int_t idect)
3120 {
3121   //
3122   // For the case where there are not enough entries in the histograms
3123   // of the calibration group, the value present in the choosen database
3124   // will be put. A negativ sign enables to know that a fit was not possible.
3125   //
3126   
3127   if (fDebugLevel == 1) {
3128     AliInfo("The element has not enough statistic to be fitted");
3129   }
3130   else if (fNbDet > 0){
3131   
3132     Int_t firstdetector = fCountDet;
3133     Int_t lastdetector  = fCountDet+fNbDet;
3134     AliInfo(Form("The element %d containing the detectors %d to %d has not enough statistic to be fitted"
3135                  ,idect,firstdetector,lastdetector));
3136     
3137     // loop over detectors
3138     for(Int_t det = firstdetector; det < lastdetector; det++){
3139
3140       //Set the calibration object again
3141       fCountDet = det;
3142       SetCalROC(2);   
3143
3144       // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
3145       // Put them at 1
3146       fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),2);
3147       fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
3148                                          ,(Int_t) GetStack(fCountDet)
3149                                          ,(Int_t) GetSector(fCountDet),2);
3150       // Reconstruct row min row max
3151       ReconstructFitRowMinRowMax(idect,2);      
3152
3153       // Calcul the coef from the database choosen for the detector
3154       CalculPRFCoefMean();
3155       
3156       //stack 2, not stack 2
3157       Int_t factor = 0;
3158       if(GetStack(fCountDet) == 2) factor = 12;
3159       else factor = 16;
3160       
3161       // Fill the fCurrentCoefDetector with negative value to say: not fitted
3162       for (Int_t k = fCalibraMode->GetRowMin(2); k < fCalibraMode->GetRowMax(2); k++) {
3163         for (Int_t j = fCalibraMode->GetColMin(2); j < fCalibraMode->GetColMax(2); j++) {
3164           fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
3165         }
3166       }
3167       
3168       //Put default value negative
3169       fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
3170       fCurrentCoefE   = 0.0;
3171       
3172       // Fill the stuff
3173       FillVectorFit();
3174       // Debug
3175       if(fDebugLevel > 1){
3176         
3177         if ( !fDebugStreamer ) {
3178           //debug stream
3179           TDirectory *backup = gDirectory;
3180           fDebugStreamer = new TTreeSRedirector("TRDDebugFitPRF.root");
3181           if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
3182         } 
3183         
3184         Int_t   detector     = fCountDet;
3185         Int_t   layer        = GetLayer(fCountDet);
3186         Int_t   caligroup    = idect;
3187         Short_t rowmin       = fCalibraMode->GetRowMin(2);
3188         Short_t rowmax       = fCalibraMode->GetRowMax(2);
3189         Short_t colmin       = fCalibraMode->GetColMin(2);
3190         Short_t colmax       = fCalibraMode->GetColMax(2);
3191         Float_t widf         = fCurrentCoef[0]; 
3192         Float_t wids         = fCurrentCoef[1]; 
3193         Float_t widfE        = fCurrentCoefE;
3194         
3195         (* fDebugStreamer) << "FillFillPRF"<<
3196           "detector="<<detector<<
3197           "layer="<<layer<<
3198           "caligroup="<<caligroup<<
3199           "rowmin="<<rowmin<<
3200           "rowmax="<<rowmax<<
3201           "colmin="<<colmin<<
3202           "colmax="<<colmax<<
3203           "widf="<<widf<<
3204           "wids="<<wids<<
3205           "widfE="<<widfE<<
3206           "\n";  
3207       }
3208       // Reset
3209       for (Int_t k = 0; k < 2304; k++) {
3210         fCurrentCoefDetector[k] = 0.0;
3211       }
3212       
3213     }// loop detector
3214     AliDebug(2,Form("Check the count now: fCountDet %d",fCountDet));
3215   }
3216   else {
3217     
3218     AliInfo(Form("The element %d in this detector %d has not enough statistic to be fitted"
3219                  ,idect-(fCount-(fCalibraMode->GetNfragZ(2)*fCalibraMode->GetNfragRphi(2))),fCountDet));
3220     
3221     CalculPRFCoefMean();
3222     
3223     // stack 2 and not stack 2
3224     Int_t factor = 0;
3225     if(GetStack(fCountDet) == 2) factor = 12;
3226     else factor = 16;
3227
3228     
3229     // Fill the fCurrentCoefDetector
3230     for (Int_t k = fCalibraMode->GetRowMin(2); k < fCalibraMode->GetRowMax(2); k++) {
3231       for (Int_t j = fCalibraMode->GetColMin(2); j < fCalibraMode->GetColMax(2); j++) {
3232         fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
3233       }
3234     }
3235
3236     // Put the default value
3237     fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
3238     fCurrentCoefE   = 0.0;
3239     
3240     FillFillPRF(idect);
3241   }
3242   
3243   return kTRUE;
3244
3245 }
3246 //____________Functions for initialising the AliTRDCalibraFit in the code_________
3247 Bool_t AliTRDCalibraFit::NotEnoughStatisticLinearFitter()
3248 {
3249   //
3250   // For the case where there are not enough entries in the histograms
3251   // of the calibration group, the value present in the choosen database
3252   // will be put. A negativ sign enables to know that a fit was not possible.
3253   //
3254   
3255   // Calcul the coef from the database choosen
3256   CalculVdriftLorentzCoef();
3257
3258   Int_t factor = 0;
3259   if(GetStack(fCountDet) == 2) factor = 1728;
3260   else factor = 2304;
3261     
3262     
3263   // Fill the fCurrentCoefDetector
3264   for (Int_t k = 0; k < factor; k++) {
3265     fCurrentCoefDetector[k] = -TMath::Abs(fCurrentCoef[1]);
3266     // should be negative
3267     fCurrentCoefDetector2[k] = +TMath::Abs(fCurrentCoef2[1]);
3268   }
3269    
3270   
3271   //Put default opposite sign
3272   fCurrentCoef[0]  = -TMath::Abs(fCurrentCoef[1]);
3273   fCurrentCoefE    = 0.0;
3274   fCurrentCoef2[0] = +TMath::Abs(fCurrentCoef2[1]);
3275   fCurrentCoefE2 = 0.0; 
3276   
3277   FillFillLinearFitter();
3278     
3279   return kTRUE;
3280 }
3281
3282 //____________Functions for initialising the AliTRDCalibraFit in the code_________
3283 Bool_t AliTRDCalibraFit::FillInfosFitCH(Int_t idect)
3284 {
3285   //
3286   // Fill the coefficients found with the fits or other
3287   // methods from the Fit functions
3288   //
3289
3290   if (fDebugLevel != 1) {
3291     if (fNbDet > 0){
3292       Int_t firstdetector = fCountDet;
3293       Int_t lastdetector  = fCountDet+fNbDet;
3294       AliInfo(Form("The element %d containing the detectors %d to %d has been fitted"
3295                    ,idect,firstdetector,lastdetector));
3296       // loop over detectors
3297       for(Int_t det = firstdetector; det < lastdetector; det++){
3298         
3299         //Set the calibration object again
3300         fCountDet = det;
3301         SetCalROC(0);   
3302         
3303         // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
3304         // Put them at 1
3305         fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),0);
3306         fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
3307                                            ,(Int_t) GetStack(fCountDet)
3308                                            ,(Int_t) GetSector(fCountDet),0);
3309         // Reconstruct row min row max
3310         ReconstructFitRowMinRowMax(idect,0);      
3311         
3312         // Calcul the coef from the database choosen for the detector
3313         if(fCurrentCoef[0] < 0.0) CalculChargeCoefMean(kFALSE);
3314         else CalculChargeCoefMean(kTRUE);
3315         
3316         //stack 2, not stack 2
3317         Int_t factor = 0;
3318         if(GetStack(fCountDet) == 2) factor = 12;
3319         else factor = 16;
3320         
3321         // Fill the fCurrentCoefDetector with negative value to say: not fitted
3322         Double_t coeftoput = 1.0;
3323         if(fCurrentCoef[0] < 0.0) coeftoput = - TMath::Abs(fCurrentCoef[1]);
3324         else coeftoput = fCurrentCoef[0];
3325         for (Int_t k = fCalibraMode->GetRowMin(0); k < fCalibraMode->GetRowMax(0); k++) {
3326           for (Int_t j = fCalibraMode->GetColMin(0); j < fCalibraMode->GetColMax(0); j++) {
3327             fCurrentCoefDetector[(Int_t)(j*factor+k)] = coeftoput;
3328           }
3329         }
3330         
3331         // Fill the stuff
3332         FillVectorFit();
3333         // Debug
3334         if(fDebugLevel > 1){ 
3335           
3336           if ( !fDebugStreamer ) {
3337             //debug stream
3338             TDirectory *backup = gDirectory;
3339             fDebugStreamer = new TTreeSRedirector("TRDDebugFitCH.root");
3340             if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
3341           } 
3342           
3343           Int_t   detector   = fCountDet;
3344           Int_t   caligroup  = idect;
3345           Short_t rowmin     = fCalibraMode->GetRowMin(0);
3346           Short_t rowmax     = fCalibraMode->GetRowMax(0);
3347           Short_t colmin     = fCalibraMode->GetColMin(0);
3348           Short_t colmax     = fCalibraMode->GetColMax(0);
3349           Float_t gf         = fCurrentCoef[0]; 
3350           Float_t gfs        = fCurrentCoef[1]; 
3351           Float_t gfE        = fCurrentCoefE;
3352           
3353           (*fDebugStreamer) << "FillFillCH" <<
3354             "detector=" << detector <<
3355             "caligroup=" << caligroup <<
3356             "rowmin=" << rowmin <<
3357             "rowmax=" << rowmax <<
3358             "colmin=" << colmin <<
3359             "colmax=" << colmax <<
3360             "gf=" << gf <<
3361             "gfs=" << gfs <<
3362             "gfE=" << gfE <<
3363             "\n"; 
3364           
3365         }
3366         // Reset
3367         for (Int_t k = 0; k < 2304; k++) {
3368           fCurrentCoefDetector[k] = 0.0;
3369         }
3370         
3371       }// loop detector
3372       //printf("Check the count now: fCountDet %d\n",fCountDet);
3373     }
3374     else{
3375       
3376       Int_t factor = 0;
3377       if(GetStack(fCountDet) == 2) factor = 12;
3378       else factor = 16; 
3379       
3380       for (Int_t k = fCalibraMode->GetRowMin(0); k < fCalibraMode->GetRowMax(0); k++) {
3381         for (Int_t j = fCalibraMode->GetColMin(0); j < fCalibraMode->GetColMax(0); j++) {
3382           fCurrentCoefDetector[(Int_t)(j*factor+k)] = fCurrentCoef[0];
3383         }
3384       }
3385       
3386       FillFillCH(idect);
3387     }
3388   }
3389
3390   return kTRUE;
3391
3392 }
3393 //____________Functions for initialising the AliTRDCalibraFit in the code_________
3394 Bool_t AliTRDCalibraFit::FillInfosFitPH(Int_t idect,Double_t nentries)
3395 {
3396   //
3397   // Fill the coefficients found with the fits or other
3398   // methods from the Fit functions
3399   //
3400
3401   if (fDebugLevel != 1) {
3402     if (fNbDet > 0){
3403       
3404       Int_t firstdetector = fCountDet;
3405       Int_t lastdetector  = fCountDet+fNbDet;
3406       AliInfo(Form("The element %d containing the detectors %d to %d has been fitted"
3407                    ,idect,firstdetector,lastdetector));
3408       
3409       // loop over detectors
3410       for(Int_t det = firstdetector; det < lastdetector; det++){
3411         
3412         //Set the calibration object again
3413         fCountDet = det;
3414         SetCalROC(1);   
3415         
3416         // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
3417         // Put them at 1
3418         fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),1);
3419         fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
3420                                            ,(Int_t) GetStack(fCountDet)
3421                                            ,(Int_t) GetSector(fCountDet),1);
3422         // Reconstruct row min row max
3423         ReconstructFitRowMinRowMax(idect,1);      
3424         
3425         // Calcul the coef from the database choosen for the detector
3426         CalculVdriftCoefMean();
3427         CalculT0CoefMean();
3428                 
3429         //stack 2, not stack 2
3430         Int_t factor = 0;
3431         if(GetStack(fCountDet) == 2) factor = 12;
3432         else factor = 16;
3433         
3434         // Fill the fCurrentCoefDetector with negative value to say: not fitted
3435         Double_t coeftoput  = 1.5;
3436         Double_t coeftoput2 = 0.0; 
3437
3438         if(fCurrentCoef[0] < 0.0) coeftoput = - TMath::Abs(fCurrentCoef[1]);
3439         else coeftoput = fCurrentCoef[0];
3440
3441         if(fCurrentCoef2[0] > 70.0) coeftoput2 = fCurrentCoef2[1] + 100.0;
3442         else coeftoput2 = fCurrentCoef2[0];
3443
3444         for (Int_t k = fCalibraMode->GetRowMin(1); k < fCalibraMode->GetRowMax(1); k++) {
3445           for (Int_t j = fCalibraMode->GetColMin(1); j < fCalibraMode->GetColMax(1); j++) {
3446             fCurrentCoefDetector[(Int_t)(j*factor+k)]  = coeftoput;
3447             fCurrentCoefDetector2[(Int_t)(j*factor+k)] = coeftoput2;
3448           }
3449         }
3450         
3451         // Fill the stuff
3452         FillVectorFit();
3453         FillVectorFit2();
3454         // Debug
3455         if(fDebugLevel > 1){ 
3456           
3457           if ( !fDebugStreamer ) {
3458             //debug stream
3459             TDirectory *backup = gDirectory;
3460             fDebugStreamer = new TTreeSRedirector("TRDDebugFitPH.root");
3461             if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
3462           } 
3463           
3464           
3465           Int_t   detector     = fCountDet;
3466           Int_t   caligroup    = idect;
3467           Short_t rowmin       = fCalibraMode->GetRowMin(1);
3468           Short_t rowmax       = fCalibraMode->GetRowMax(1);
3469           Short_t colmin       = fCalibraMode->GetColMin(1);
3470           Short_t colmax       = fCalibraMode->GetColMax(1);
3471           Float_t vf           = fCurrentCoef[0]; 
3472           Float_t vs           = fCurrentCoef[1]; 
3473           Float_t vfE          = fCurrentCoefE;
3474           Float_t t0f          = fCurrentCoef2[0]; 
3475           Float_t t0s          = fCurrentCoef2[1]; 
3476           Float_t t0E          = fCurrentCoefE2;
3477           
3478           
3479           
3480           (* fDebugStreamer) << "FillFillPH"<<
3481             "detector="<<detector<<
3482             "nentries="<<nentries<<
3483             "caligroup="<<caligroup<<
3484             "rowmin="<<rowmin<<
3485             "rowmax="<<rowmax<<
3486             "colmin="<<colmin<<
3487             "colmax="<<colmax<<
3488             "vf="<<vf<<
3489             "vs="<<vs<<
3490             "vfE="<<vfE<<
3491             "t0f="<<t0f<<
3492             "t0s="<<t0s<<
3493             "t0E="<<t0E<<
3494             "\n";  
3495         }
3496         // Reset
3497         for (Int_t k = 0; k < 2304; k++) {
3498           fCurrentCoefDetector[k] = 0.0;
3499           fCurrentCoefDetector2[k] = 0.0;
3500         }
3501         
3502       }// loop detector
3503       //printf("Check the count now: fCountDet %d\n",fCountDet);
3504     }
3505     else {
3506       
3507       Int_t factor = 0;
3508       if(GetStack(fCountDet) == 2) factor = 12;
3509       else factor = 16; 
3510       
3511       for (Int_t k = fCalibraMode->GetRowMin(1); k < fCalibraMode->GetRowMax(1); k++) {
3512         for (Int_t j = fCalibraMode->GetColMin(1); j < fCalibraMode->GetColMax(1); j++) {
3513           fCurrentCoefDetector[(Int_t)(j*factor+k)]  = fCurrentCoef[0];
3514           fCurrentCoefDetector2[(Int_t)(j*factor+k)] = fCurrentCoef2[0];
3515         }
3516       }  
3517       
3518       FillFillPH(idect,nentries);
3519     }
3520   }
3521   return kTRUE;
3522 }
3523 //____________Functions for initialising the AliTRDCalibraFit in the code_________
3524 Bool_t AliTRDCalibraFit::FillInfosFitPRF(Int_t idect)
3525 {
3526   //
3527   // Fill the coefficients found with the fits or other
3528   // methods from the Fit functions
3529   //
3530   
3531   if (fDebugLevel != 1) {
3532     if (fNbDet > 0){
3533     
3534       Int_t firstdetector = fCountDet;
3535       Int_t lastdetector  = fCountDet+fNbDet;
3536       AliInfo(Form("The element %d containing the detectors %d to %d has been fitted"
3537                    ,idect,firstdetector,lastdetector));
3538       
3539       // loop over detectors
3540       for(Int_t det = firstdetector; det < lastdetector; det++){
3541         
3542         //Set the calibration object again
3543         fCountDet = det;
3544         SetCalROC(2);   
3545         
3546         // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
3547         // Put them at 1
3548         fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),2);
3549         fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
3550                                            ,(Int_t) GetStack(fCountDet)
3551                                            ,(Int_t) GetSector(fCountDet),2);
3552         // Reconstruct row min row max
3553         ReconstructFitRowMinRowMax(idect,2);      
3554         
3555         // Calcul the coef from the database choosen for the detector
3556         CalculPRFCoefMean();
3557         
3558         //stack 2, not stack 2
3559         Int_t factor = 0;
3560         if(GetStack(fCountDet) == 2) factor = 12;
3561         else factor = 16;
3562         
3563         // Fill the fCurrentCoefDetector with negative value to say: not fitted
3564         Double_t coeftoput = 1.0;
3565         if(fCurrentCoef[0] < 0.0) coeftoput = - TMath::Abs(fCurrentCoef[1]);
3566         else coeftoput = fCurrentCoef[0];
3567         for (Int_t k = fCalibraMode->GetRowMin(2); k < fCalibraMode->GetRowMax(2); k++) {
3568           for (Int_t j = fCalibraMode->GetColMin(2); j < fCalibraMode->GetColMax(2); j++) {
3569             fCurrentCoefDetector[(Int_t)(j*factor+k)] = coeftoput;
3570           }
3571         }
3572         
3573         // Fill the stuff
3574         FillVectorFit();
3575         // Debug
3576         if(fDebugLevel > 1){
3577           
3578           if ( !fDebugStreamer ) {
3579             //debug stream
3580             TDirectory *backup = gDirectory;
3581             fDebugStreamer = new TTreeSRedirector("TRDDebugFitPRF.root");
3582             if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
3583           } 
3584           
3585           Int_t   detector     = fCountDet;
3586           Int_t   layer        = GetLayer(fCountDet);
3587           Int_t   caligroup    = idect;
3588           Short_t rowmin       = fCalibraMode->GetRowMin(2);
3589           Short_t rowmax       = fCalibraMode->GetRowMax(2);
3590           Short_t colmin       = fCalibraMode->GetColMin(2);
3591           Short_t colmax       = fCalibraMode->GetColMax(2);
3592           Float_t widf         = fCurrentCoef[0]; 
3593           Float_t wids         = fCurrentCoef[1]; 
3594           Float_t widfE        = fCurrentCoefE;
3595           
3596           (* fDebugStreamer) << "FillFillPRF"<<
3597             "detector="<<detector<<
3598             "layer="<<layer<<
3599             "caligroup="<<caligroup<<
3600             "rowmin="<<rowmin<<
3601             "rowmax="<<rowmax<<
3602             "colmin="<<colmin<<
3603             "colmax="<<colmax<<
3604             "widf="<<widf<<
3605             "wids="<<wids<<
3606             "widfE="<<widfE<<
3607             "\n";  
3608         }
3609         // Reset
3610         for (Int_t k = 0; k < 2304; k++) {
3611           fCurrentCoefDetector[k] = 0.0;
3612         }
3613         
3614       }// loop detector
3615       //printf("Check the count now: fCountDet %d\n",fCountDet);
3616     }
3617     else {
3618       
3619       Int_t factor = 0;
3620       if(GetStack(fCountDet) == 2) factor = 12;
3621       else factor = 16; 
3622       
3623       // Pointer to the branch
3624       for (Int_t k = fCalibraMode->GetRowMin(2); k < fCalibraMode->GetRowMax(2); k++) {
3625         for (Int_t j = fCalibraMode->GetColMin(2); j < fCalibraMode->GetColMax(2); j++) {
3626           fCurrentCoefDetector[(Int_t)(j*factor+k)] = fCurrentCoef[0];
3627         }
3628       }
3629       FillFillPRF(idect);   
3630     }
3631   }
3632   
3633   return kTRUE;
3634
3635 }
3636 //____________Functions for initialising the AliTRDCalibraFit in the code_________
3637 Bool_t AliTRDCalibraFit::FillInfosFitLinearFitter()
3638 {
3639   //
3640   // Fill the coefficients found with the fits or other
3641   // methods from the Fit functions
3642   //
3643   
3644   Int_t factor = 0;
3645   if(GetStack(fCountDet) == 2) factor = 1728;
3646   else factor = 2304; 
3647   
3648   // Pointer to the branch
3649   for (Int_t k = 0; k < factor; k++) {
3650     fCurrentCoefDetector[k]  = fCurrentCoef[0];
3651     fCurrentCoefDetector2[k] = fCurrentCoef2[0];
3652   }
3653   
3654   FillFillLinearFitter();
3655   
3656   return kTRUE;
3657
3658 }
3659 //________________________________________________________________________________
3660 void AliTRDCalibraFit::FillFillCH(Int_t idect)
3661 {
3662   //
3663   // DebugStream and fVectorFit
3664   //
3665
3666   // End of one detector
3667   if ((idect == (fCount-1))) {
3668     FillVectorFit();
3669     // Reset
3670     for (Int_t k = 0; k < 2304; k++) {
3671       fCurrentCoefDetector[k] = 0.0;
3672     }
3673   }
3674
3675   if(fDebugLevel > 1){ 
3676
3677     if ( !fDebugStreamer ) {
3678       //debug stream
3679       TDirectory *backup = gDirectory;
3680       fDebugStreamer = new TTreeSRedirector("TRDDebugFitCH.root");
3681       if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
3682     } 
3683     
3684     Int_t   detector   = fCountDet;
3685     Int_t   caligroup  = idect;
3686     Short_t rowmin     = fCalibraMode->GetRowMin(0);
3687     Short_t rowmax     = fCalibraMode->GetRowMax(0);
3688     Short_t colmin     = fCalibraMode->GetColMin(0);
3689     Short_t colmax     = fCalibraMode->GetColMax(0);
3690     Float_t gf         = fCurrentCoef[0]; 
3691     Float_t gfs        = fCurrentCoef[1]; 
3692     Float_t gfE        = fCurrentCoefE;
3693     
3694     (*fDebugStreamer) << "FillFillCH" <<
3695       "detector=" << detector <<
3696       "caligroup=" << caligroup <<
3697       "rowmin=" << rowmin <<
3698       "rowmax=" << rowmax <<
3699       "colmin=" << colmin <<
3700       "colmax=" << colmax <<
3701       "gf=" << gf <<
3702       "gfs=" << gfs <<
3703       "gfE=" << gfE <<
3704       "\n"; 
3705     
3706   }
3707 }
3708 //________________________________________________________________________________
3709 void AliTRDCalibraFit::FillFillPH(Int_t idect,Double_t nentries)
3710 {
3711   //
3712   // DebugStream and fVectorFit and fVectorFit2
3713   //
3714   
3715   // End of one detector
3716     if ((idect == (fCount-1))) {
3717       FillVectorFit();
3718       FillVectorFit2();
3719       // Reset
3720       for (Int_t k = 0; k < 2304; k++) {
3721         fCurrentCoefDetector[k] = 0.0;
3722         fCurrentCoefDetector2[k] = 0.0;
3723       }
3724     }
3725
3726     if(fDebugLevel > 1){ 
3727
3728       if ( !fDebugStreamer ) {
3729         //debug stream
3730         TDirectory *backup = gDirectory;
3731         fDebugStreamer = new TTreeSRedirector("TRDDebugFitPH.root");
3732         if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
3733       } 
3734       
3735        
3736       Int_t   detector     = fCountDet;
3737       Int_t   caligroup    = idect;
3738       Short_t rowmin       = fCalibraMode->GetRowMin(1);
3739       Short_t rowmax       = fCalibraMode->GetRowMax(1);
3740       Short_t colmin       = fCalibraMode->GetColMin(1);
3741       Short_t colmax       = fCalibraMode->GetColMax(1);
3742       Float_t vf           = fCurrentCoef[0]; 
3743       Float_t vs           = fCurrentCoef[1]; 
3744       Float_t vfE          = fCurrentCoefE;
3745       Float_t t0f          = fCurrentCoef2[0]; 
3746       Float_t t0s          = fCurrentCoef2[1]; 
3747       Float_t t0E          = fCurrentCoefE2;
3748    
3749
3750
3751       (* fDebugStreamer) << "FillFillPH"<<
3752         "detector="<<detector<<
3753         "nentries="<<nentries<<
3754         "caligroup="<<caligroup<<
3755         "rowmin="<<rowmin<<
3756         "rowmax="<<rowmax<<
3757         "colmin="<<colmin<<
3758         "colmax="<<colmax<<
3759         "vf="<<vf<<
3760         "vs="<<vs<<
3761         "vfE="<<vfE<<
3762         "t0f="<<t0f<<
3763         "t0s="<<t0s<<
3764         "t0E="<<t0E<<
3765         "\n";  
3766     }
3767
3768 }
3769 //________________________________________________________________________________
3770 void AliTRDCalibraFit::FillFillPRF(Int_t idect)
3771 {
3772   //
3773   // DebugStream and fVectorFit
3774   //
3775
3776     // End of one detector
3777     if ((idect == (fCount-1))) {
3778       FillVectorFit();
3779       // Reset
3780       for (Int_t k = 0; k < 2304; k++) {
3781         fCurrentCoefDetector[k] = 0.0;
3782       }
3783     }
3784
3785     
3786     if(fDebugLevel > 1){
3787
3788       if ( !fDebugStreamer ) {
3789         //debug stream
3790         TDirectory *backup = gDirectory;
3791         fDebugStreamer = new TTreeSRedirector("TRDDebugFitPRF.root");
3792         if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
3793       } 
3794       
3795       Int_t   detector     = fCountDet;
3796       Int_t   layer        = GetLayer(fCountDet);
3797       Int_t   caligroup    = idect;
3798       Short_t rowmin       = fCalibraMode->GetRowMin(2);
3799       Short_t rowmax       = fCalibraMode->GetRowMax(2);
3800       Short_t colmin       = fCalibraMode->GetColMin(2);
3801       Short_t colmax       = fCalibraMode->GetColMax(2);
3802       Float_t widf         = fCurrentCoef[0]; 
3803       Float_t wids         = fCurrentCoef[1]; 
3804       Float_t widfE        = fCurrentCoefE;
3805
3806       (* fDebugStreamer) << "FillFillPRF"<<
3807         "detector="<<detector<<
3808         "layer="<<layer<<
3809         "caligroup="<<caligroup<<
3810         "rowmin="<<rowmin<<
3811         "rowmax="<<rowmax<<
3812         "colmin="<<colmin<<
3813         "colmax="<<colmax<<
3814         "widf="<<widf<<
3815         "wids="<<wids<<
3816         "widfE="<<widfE<<
3817         "\n";  
3818     }
3819
3820 }
3821 //________________________________________________________________________________
3822 void AliTRDCalibraFit::FillFillLinearFitter()
3823 {
3824   //
3825   // DebugStream and fVectorFit
3826   //
3827
3828   // End of one detector
3829   FillVectorFit();
3830   FillVectorFit2();
3831   
3832   
3833   // Reset
3834   for (Int_t k = 0; k < 2304; k++) {
3835   fCurrentCoefDetector[k]  = 0.0;
3836   fCurrentCoefDetector2[k] = 0.0;
3837   }
3838   
3839
3840   if(fDebugLevel > 1){
3841
3842     if ( !fDebugStreamer ) {
3843       //debug stream
3844       TDirectory *backup = gDirectory;
3845       fDebugStreamer = new TTreeSRedirector("TRDDebugFitLinearFitter.root");
3846       if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
3847     } 
3848     
3849     //Debug: comparaison of the different methods (okey for first time but not for iterative procedure)
3850     AliTRDpadPlane *padplane = fGeo->GetPadPlane(GetLayer(fCountDet),GetStack(fCountDet));
3851     Float_t rowmd            = (padplane->GetRow0()+padplane->GetRowEnd())/2.;
3852     Float_t r                = AliTRDgeometry::GetTime0(GetLayer(fCountDet)); 
3853     Float_t tiltangle        = padplane->GetTiltingAngle();
3854     Int_t   detector         = fCountDet;
3855     Int_t   stack            = GetStack(fCountDet);
3856     Int_t   layer            = GetLayer(fCountDet);
3857     Float_t vf               = fCurrentCoef[0]; 
3858     Float_t vs               = fCurrentCoef[1]; 
3859     Float_t vfE              = fCurrentCoefE;
3860     Float_t lorentzangler    = fCurrentCoef2[0];
3861     Float_t elorentzangler   = fCurrentCoefE2;
3862     Float_t lorentzangles    = fCurrentCoef2[1];
3863    
3864     (* fDebugStreamer) << "FillFillLinearFitter"<<
3865       "detector="<<detector<<
3866       "stack="<<stack<<
3867       "layer="<<layer<<
3868       "rowmd="<<rowmd<<
3869       "r="<<r<<
3870       "tiltangle="<<tiltangle<<
3871       "vf="<<vf<<
3872       "vs="<<vs<<
3873       "vfE="<<vfE<<
3874       "lorentzangler="<<lorentzangler<<
3875       "Elorentzangler="<<elorentzangler<<
3876       "lorentzangles="<<lorentzangles<<
3877       "\n";  
3878   }
3879   
3880 }
3881 //
3882 //____________Calcul Coef Mean_________________________________________________
3883 //
3884 //_____________________________________________________________________________
3885 Bool_t AliTRDCalibraFit::CalculT0CoefMean()
3886 {
3887   //
3888   // For the detector Dect calcul the mean time 0
3889   // for the calibration group idect from the choosen database
3890   //
3891
3892   fCurrentCoef2[1] = 0.0;
3893   if(fDebugLevel != 1){
3894     if(((fCalibraMode->GetNz(1) > 0) ||
3895        (fCalibraMode->GetNrphi(1) > 0)) && ((fCalibraMode->GetNz(1)    != 10) && (fCalibraMode->GetNz(1)    != 100))) {
3896
3897       for (Int_t row = fCalibraMode->GetRowMin(1); row < fCalibraMode->GetRowMax(1); row++) {
3898         for (Int_t col = fCalibraMode->GetColMin(1); col < fCalibraMode->GetColMax(1); col++) {
3899           fCurrentCoef2[1] += (Float_t) (fCalROC2->GetValue(col,row)+fCalDet2->GetValue(fCountDet));
3900         }
3901       }
3902       
3903       fCurrentCoef2[1] = fCurrentCoef2[1] / ((fCalibraMode->GetColMax(1)-fCalibraMode->GetColMin(1))*(fCalibraMode->GetRowMax(1)-fCalibraMode->GetRowMin(1)));
3904     
3905     }
3906     else {
3907      
3908       if(!fAccCDB){
3909         fCurrentCoef2[1] = fCalDet2->GetValue(fCountDet);
3910       }
3911       else{
3912         
3913         for(Int_t row = 0; row < fGeo->GetRowMax(GetLayer(fCountDet),GetStack(fCountDet),GetSector(fCountDet)); row++){
3914           for(Int_t col = 0; col < fGeo->GetColMax(GetLayer(fCountDet)); col++){
3915             fCurrentCoef2[1] += (Float_t) (fCalROC2->GetValue(col,row)+fCalDet2->GetValue(fCountDet));
3916           }
3917         }
3918         fCurrentCoef2[1] = fCurrentCoef2[1] / ((fGeo->GetRowMax(GetLayer(fCountDet),GetStack(fCountDet),GetSector(fCountDet)))*(fGeo->GetColMax(GetLayer(fCountDet))));
3919       
3920       }
3921     }
3922   }
3923   return kTRUE;
3924 }
3925
3926 //_____________________________________________________________________________
3927 Bool_t AliTRDCalibraFit::CalculChargeCoefMean(Bool_t vrai)
3928 {
3929   //
3930   // For the detector Dect calcul the mean gain factor
3931   // for the calibration group idect from the choosen database
3932   //
3933
3934   fCurrentCoef[1] = 0.0;
3935   if(fDebugLevel != 1){
3936     if (((fCalibraMode->GetNz(0)    > 0) || 
3937         (fCalibraMode->GetNrphi(0) > 0)) && ((fCalibraMode->GetNz(0)    != 10) && (fCalibraMode->GetNz(0)    != 100))) {
3938       for (Int_t row = fCalibraMode->GetRowMin(0); row < fCalibraMode->GetRowMax(0); row++) {
3939         for (Int_t col = fCalibraMode->GetColMin(0); col < fCalibraMode->GetColMax(0); col++) {
3940           fCurrentCoef[1] += (Float_t) (fCalROC->GetValue(col,row)*fCalDet->GetValue(fCountDet));
3941           if (vrai) fScaleFitFactor += (Float_t) (fCalROC->GetValue(col,row)*fCalDet->GetValue(fCountDet));
3942         }
3943       }
3944       fCurrentCoef[1] = fCurrentCoef[1] / ((fCalibraMode->GetColMax(0)-fCalibraMode->GetColMin(0))*(fCalibraMode->GetRowMax(0)-fCalibraMode->GetRowMin(0)));
3945     }
3946     else {
3947       //Per detectors
3948       fCurrentCoef[1] = (Float_t) fCalDet->GetValue(fCountDet);
3949       if (vrai) fScaleFitFactor += ((Float_t) fCalDet->GetValue(fCountDet))*(fCalibraMode->GetColMax(0)-fCalibraMode->GetColMin(0))*(fCalibraMode->GetRowMax(0)-fCalibraMode->GetRowMin(0));
3950     }    
3951   }
3952   return kTRUE;
3953 }
3954 //_____________________________________________________________________________
3955 Bool_t AliTRDCalibraFit::CalculPRFCoefMean()
3956 {
3957   //
3958   // For the detector Dect calcul the mean sigma of pad response
3959   // function for the calibration group idect from the choosen database
3960   //
3961   
3962   fCurrentCoef[1] = 0.0;
3963   if(fDebugLevel != 1){
3964     for (Int_t row = fCalibraMode->GetRowMin(2); row < fCalibraMode->GetRowMax(2); row++) {
3965       for (Int_t col = fCalibraMode->GetColMin(2); col < fCalibraMode->GetColMax(2); col++) {
3966         fCurrentCoef[1] += (Float_t) fCalROC->GetValue(col,row);
3967       }
3968     }
3969     fCurrentCoef[1] = fCurrentCoef[1] / ((fCalibraMode->GetColMax(2)-fCalibraMode->GetColMin(2))*(fCalibraMode->GetRowMax(2)-fCalibraMode->GetRowMin(2)));
3970   }
3971   return kTRUE;
3972 }
3973 //_____________________________________________________________________________
3974 Bool_t AliTRDCalibraFit::CalculVdriftCoefMean()
3975 {
3976   //
3977   // For the detector dect calcul the mean drift velocity for the
3978   // calibration group idect from the choosen database
3979   //
3980
3981   fCurrentCoef[1] = 0.0;
3982   if(fDebugLevel != 1){
3983     if (((fCalibraMode->GetNz(1)    > 0) || 
3984         (fCalibraMode->GetNrphi(1) > 0)) && ((fCalibraMode->GetNz(1)    != 10) && (fCalibraMode->GetNz(1)    != 100))) {
3985       
3986       for (Int_t row = fCalibraMode->GetRowMin(1); row < fCalibraMode->GetRowMax(1); row++) {
3987         for (Int_t col = fCalibraMode->GetColMin(1); col < fCalibraMode->GetColMax(1); col++) {
3988           fCurrentCoef[1] += (Float_t) (fCalROC->GetValue(col,row)*fCalDet->GetValue(fCountDet));
3989         }
3990       }
3991       
3992       fCurrentCoef[1] = fCurrentCoef[1] / ((fCalibraMode->GetColMax(1)-fCalibraMode->GetColMin(1))*(fCalibraMode->GetRowMax(1)-fCalibraMode->GetRowMin(1)));
3993     
3994     }
3995     else {
3996       //per detectors
3997       fCurrentCoef[1] = (Float_t) fCalDet->GetValue(fCountDet);
3998     }  
3999   }
4000   return kTRUE;
4001 }
4002 //_____________________________________________________________________________
4003 Bool_t AliTRDCalibraFit::CalculVdriftLorentzCoef()
4004 {
4005   //
4006   // For the detector fCountDet, mean drift velocity and tan lorentzangle
4007   //
4008
4009   fCurrentCoef[1]  = fCalDet->GetValue(fCountDet);
4010   fCurrentCoef2[1] = fCalDet2->GetValue(fCountDet); 
4011
4012   return kTRUE;
4013 }
4014 //_____________________________________________________________________________
4015 Float_t AliTRDCalibraFit::GetPRFDefault(Int_t layer) const
4016 {
4017   //
4018   // Default width of the PRF if there is no database as reference
4019   //
4020   switch(layer)
4021     {
4022       // default database
4023       //case 0:  return 0.515;
4024       //case 1:  return 0.502;
4025       //case 2:  return 0.491;
4026       //case 3:  return 0.481;
4027       //case 4:  return 0.471;
4028       //case 5:  return 0.463;
4029       //default: return 0.0;
4030
4031       // fit database
4032     case 0:  return 0.538429;
4033     case 1:  return 0.524302;
4034     case 2:  return 0.511591;
4035     case 3:  return 0.500140;
4036     case 4:  return 0.489821;
4037     case 5:  return 0.480524;
4038     default: return 0.0;
4039   }
4040 }
4041 //________________________________________________________________________________
4042 void AliTRDCalibraFit::SetCalROC(Int_t i)
4043 {
4044   //
4045   // Set the calib object for fCountDet
4046   //
4047
4048   Float_t value = 0.0;
4049   
4050   //Get the CalDet object
4051   if(fAccCDB){
4052     AliTRDcalibDB     *cal    = AliTRDcalibDB::Instance();
4053     if (!cal) {
4054       AliInfo("Could not get calibDB");
4055       return;
4056     }
4057     switch (i)
4058       {
4059       case 0: 
4060         if( fCalROC ){ 
4061           fCalROC->~AliTRDCalROC();
4062           new(fCalROC) AliTRDCalROC(*(cal->GetGainFactorROC(fCountDet)));
4063         }else fCalROC = new AliTRDCalROC(*(cal->GetGainFactorROC(fCountDet)));
4064         break;
4065       case 1:
4066         if( fCalROC ){ 
4067           fCalROC->~AliTRDCalROC();
4068           new(fCalROC) AliTRDCalROC(*(cal->GetVdriftROC(fCountDet)));
4069         }else fCalROC = new AliTRDCalROC(*(cal->GetVdriftROC(fCountDet)));
4070         if( fCalROC2 ){ 
4071           fCalROC2->~AliTRDCalROC();
4072           new(fCalROC2) AliTRDCalROC(*(cal->GetT0ROC(fCountDet)));
4073         }else fCalROC2 = new AliTRDCalROC(*(cal->GetT0ROC(fCountDet)));
4074         break;
4075       case 2:
4076         if( fCalROC ){ 
4077           fCalROC->~AliTRDCalROC();
4078           new(fCalROC) AliTRDCalROC(*(cal->GetPRFROC(fCountDet)));
4079         }else fCalROC = new AliTRDCalROC(*(cal->GetPRFROC(fCountDet)));
4080         break; 
4081       default: return;
4082       }
4083   }
4084   else{
4085     switch (i)
4086       {
4087       case 0:
4088         if(fCalROC) delete fCalROC;
4089         fCalROC = new AliTRDCalROC(GetLayer(fCountDet),GetStack(fCountDet)); 
4090         for(Int_t k = 0; k < fCalROC->GetNchannels(); k++){
4091           fCalROC->SetValue(k,1.0);
4092         }
4093         break;
4094       case 1:
4095         if(fCalROC)  delete fCalROC;
4096         if(fCalROC2) delete fCalROC2;
4097         fCalROC  = new AliTRDCalROC(GetLayer(fCountDet),GetStack(fCountDet));
4098         fCalROC2 = new AliTRDCalROC(GetLayer(fCountDet),GetStack(fCountDet));
4099         for(Int_t k = 0; k < fCalROC->GetNchannels(); k++){
4100           fCalROC->SetValue(k,1.0);
4101           fCalROC2->SetValue(k,0.0);
4102         }
4103         break;
4104       case 2:
4105         if(fCalROC) delete fCalROC;
4106         value = GetPRFDefault(GetLayer(fCountDet));
4107         fCalROC = new AliTRDCalROC(GetLayer(fCountDet),GetStack(fCountDet)); 
4108         for(Int_t k = 0; k < fCalROC->GetNchannels(); k++){
4109           fCalROC->SetValue(k,value);
4110         }
4111         break;
4112       default: return; 
4113       }
4114   }
4115   
4116 }
4117 //____________Fit Methods______________________________________________________
4118
4119 //_____________________________________________________________________________
4120 void AliTRDCalibraFit::FitPente(TH1* projPH)
4121 {
4122   //
4123   // Slope methode for the drift velocity
4124   //
4125   
4126   // Constants
4127   const Float_t kDrWidth = AliTRDgeometry::DrThick();
4128   Int_t binmax           = 0;
4129   Int_t binmin           = 0;
4130   fPhd[0]                = 0.0;
4131   fPhd[1]                = 0.0;
4132   fPhd[2]                = 0.0;
4133   Int_t ju               = 0;
4134   fCurrentCoefE          = 0.0;
4135   fCurrentCoefE2         = 0.0;
4136   fCurrentCoef[0]        = 0.0;
4137   fCurrentCoef2[0]       = 0.0;
4138   TLine *line            = new TLine();
4139
4140   // Some variables
4141   TAxis   *xpph    = projPH->GetXaxis();
4142   Int_t    nbins   = xpph->GetNbins();
4143   Double_t lowedge = xpph->GetBinLowEdge(1);
4144   Double_t upedge  = xpph->GetBinUpEdge(xpph->GetNbins());
4145   Double_t widbins = (upedge - lowedge) / nbins;
4146   Double_t limit   = upedge + 0.5 * widbins; 
4147   Bool_t put = kTRUE;