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