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