]> git.uio.no Git - u/mrichter/AliRoot.git/blame - TRD/AliTRDCalibraFit.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Moving some classes in more appropiate places
[u/mrichter/AliRoot.git] / TRD / AliTRDCalibraFit.cxx
CommitLineData
55a288e5 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
64942b85 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
55a288e5 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
55a288e5 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
55a288e5 49#include <TLine.h>
50#include <TH1I.h>
51#include <TStyle.h>
52#include <TProfile2D.h>
55a288e5 53#include <TCanvas.h>
54#include <TGraphErrors.h>
55a288e5 55#include <TObjArray.h>
56#include <TH1.h>
57#include <TH1F.h>
58#include <TF1.h>
55a288e5 59#include <TAxis.h>
55a288e5 60#include <TMath.h>
55a288e5 61#include <TDirectory.h>
3a0f6479 62#include <TTreeStream.h>
63#include <TLinearFitter.h>
64#include <TVectorD.h>
daa7dc79 65#include <TROOT.h>
4c865c34 66#include <TString.h>
55a288e5 67
68#include "AliLog.h"
3a0f6479 69#include "AliMathBase.h"
55a288e5 70
71#include "AliTRDCalibraFit.h"
72#include "AliTRDCalibraMode.h"
73#include "AliTRDCalibraVector.h"
3a0f6479 74#include "AliTRDCalibraVdriftLinearFit.h"
a0bb5615 75#include "AliTRDCalibraExbAltFit.h"
55a288e5 76#include "AliTRDcalibDB.h"
77#include "AliTRDgeometry.h"
3a0f6479 78#include "AliTRDpadPlane.h"
79#include "AliTRDgeometry.h"
a076fc2f 80#include "AliTRDCommonParam.h"
55a288e5 81#include "./Cal/AliTRDCalROC.h"
82#include "./Cal/AliTRDCalPad.h"
83#include "./Cal/AliTRDCalDet.h"
84
85
86ClassImp(AliTRDCalibraFit)
87
88AliTRDCalibraFit* AliTRDCalibraFit::fgInstance = 0;
89Bool_t AliTRDCalibraFit::fgTerminated = kFALSE;
90
91//_____________singleton implementation_________________________________________________
92AliTRDCalibraFit *AliTRDCalibraFit::Instance()
93{
94 //
95 // Singleton implementation
96 //
97
98 if (fgTerminated != kFALSE) {
99 return 0;
100 }
101
102 if (fgInstance == 0) {
103 fgInstance = new AliTRDCalibraFit();
104 }
105
106 return fgInstance;
107
108}
55a288e5 109//______________________________________________________________________________________
110void AliTRDCalibraFit::Terminate()
111{
112 //
113 // Singleton implementation
114 // Deletes the instance of this class
115 //
116
117 fgTerminated = kTRUE;
118
119 if (fgInstance != 0) {
120 delete fgInstance;
121 fgInstance = 0;
122 }
123
124}
55a288e5 125//______________________________________________________________________________________
126AliTRDCalibraFit::AliTRDCalibraFit()
127 :TObject()
f162af62 128 ,fGeo(0)
3a0f6479 129 ,fNumberOfBinsExpected(0)
130 ,fMethod(0)
131 ,fBeginFitCharge(3.5)
132 ,fFitPHPeriode(1)
413153cb 133 ,fTakeTheMaxPH(kTRUE)
134 ,fT0Shift0(0.124797)
135 ,fT0Shift1(0.267451)
3a0f6479 136 ,fRangeFitPRF(1.0)
55a288e5 137 ,fAccCDB(kFALSE)
3a0f6479 138 ,fMinEntries(800)
139 ,fRebin(1)
54f2ff1c 140 ,fScaleGain(0.02431)
55a288e5 141 ,fNumberFit(0)
142 ,fNumberFitSuccess(0)
143 ,fNumberEnt(0)
144 ,fStatisticMean(0.0)
3a0f6479 145 ,fDebugStreamer(0x0)
146 ,fDebugLevel(0)
55a288e5 147 ,fFitVoir(0)
3a0f6479 148 ,fMagneticField(0.5)
149 ,fCalibraMode(new AliTRDCalibraMode())
150 ,fCurrentCoefE(0.0)
151 ,fCurrentCoefE2(0.0)
152 ,fDect1(0)
153 ,fDect2(0)
55a288e5 154 ,fScaleFitFactor(0.0)
155 ,fEntriesCurrent(0)
3a0f6479 156 ,fCountDet(0)
157 ,fCount(0)
64942b85 158 ,fNbDet(0)
3a0f6479 159 ,fCalDet(0x0)
160 ,fCalROC(0x0)
161 ,fCalDet2(0x0)
162 ,fCalROC2(0x0)
840ec79d 163 ,fCalDetVdriftUsed(0x0)
164 ,fCalDetExBUsed(0x0)
3a0f6479 165 ,fCurrentCoefDetector(0x0)
166 ,fCurrentCoefDetector2(0x0)
167 ,fVectorFit(0)
168 ,fVectorFit2(0)
55a288e5 169{
170 //
171 // Default constructor
172 //
173
3a0f6479 174 fGeo = new AliTRDgeometry();
175
176 // Current variables initialised
177 for (Int_t k = 0; k < 2; k++) {
178 fCurrentCoef[k] = 0.0;
179 fCurrentCoef2[k] = 0.0;
55a288e5 180 }
55a288e5 181 for (Int_t i = 0; i < 3; i++) {
3a0f6479 182 fPhd[i] = 0.0;
183 fDet[i] = 0;
55a288e5 184 }
3a0f6479 185
55a288e5 186}
55a288e5 187//______________________________________________________________________________________
188AliTRDCalibraFit::AliTRDCalibraFit(const AliTRDCalibraFit &c)
3a0f6479 189:TObject(c)
190,fGeo(0)
191,fNumberOfBinsExpected(c.fNumberOfBinsExpected)
192,fMethod(c.fMethod)
193,fBeginFitCharge(c.fBeginFitCharge)
194,fFitPHPeriode(c.fFitPHPeriode)
195,fTakeTheMaxPH(c.fTakeTheMaxPH)
413153cb 196,fT0Shift0(c.fT0Shift0)
197,fT0Shift1(c.fT0Shift1)
3a0f6479 198,fRangeFitPRF(c.fRangeFitPRF)
199,fAccCDB(c.fAccCDB)
200,fMinEntries(c.fMinEntries)
201,fRebin(c.fRebin)
54f2ff1c 202,fScaleGain(c.fScaleGain)
3a0f6479 203,fNumberFit(c.fNumberFit)
204,fNumberFitSuccess(c.fNumberFitSuccess)
205,fNumberEnt(c.fNumberEnt)
206,fStatisticMean(c.fStatisticMean)
207,fDebugStreamer(0x0)
208,fDebugLevel(c.fDebugLevel)
209,fFitVoir(c.fFitVoir)
210,fMagneticField(c.fMagneticField)
211,fCalibraMode(0x0)
212,fCurrentCoefE(c.fCurrentCoefE)
213,fCurrentCoefE2(c.fCurrentCoefE2)
214,fDect1(c.fDect1)
215,fDect2(c.fDect2)
216,fScaleFitFactor(c.fScaleFitFactor)
217,fEntriesCurrent(c.fEntriesCurrent)
218,fCountDet(c.fCountDet)
219,fCount(c.fCount)
64942b85 220,fNbDet(c.fNbDet)
3a0f6479 221,fCalDet(0x0)
222,fCalROC(0x0)
223,fCalDet2(0x0)
224,fCalROC2(0x0)
840ec79d 225,fCalDetVdriftUsed(0x0)
226,fCalDetExBUsed(0x0)
3a0f6479 227,fCurrentCoefDetector(0x0)
228,fCurrentCoefDetector2(0x0)
229,fVectorFit(0)
230,fVectorFit2(0)
55a288e5 231{
232 //
233 // Copy constructor
234 //
235
3a0f6479 236 if(c.fCalibraMode) fCalibraMode = new AliTRDCalibraMode(*c.fCalibraMode);
237
238 //Current variables initialised
239 for (Int_t k = 0; k < 2; k++) {
240 fCurrentCoef[k] = 0.0;
241 fCurrentCoef2[k] = 0.0;
242 }
243 for (Int_t i = 0; i < 3; i++) {
244 fPhd[i] = 0.0;
245 fDet[i] = 0;
246 }
247 if(c.fCalDet) fCalDet = new AliTRDCalDet(*c.fCalDet);
248 if(c.fCalDet2) fCalDet2 = new AliTRDCalDet(*c.fCalDet2);
64942b85 249
3a0f6479 250 if(c.fCalROC) fCalROC = new AliTRDCalROC(*c.fCalROC);
251 if(c.fCalROC2) fCalROC = new AliTRDCalROC(*c.fCalROC2);
252
840ec79d 253 if(c.fCalDetVdriftUsed) fCalDetVdriftUsed = new AliTRDCalDet(*c.fCalDetVdriftUsed);
254 if(c.fCalDetExBUsed) fCalDetExBUsed = new AliTRDCalDet(*c.fCalDetExBUsed);
255
3a0f6479 256 fVectorFit.SetName(c.fVectorFit.GetName());
257 for(Int_t k = 0; k < c.fVectorFit.GetEntriesFast(); k++){
258 AliTRDFitInfo *fitInfo = new AliTRDFitInfo();
259 Int_t detector = ((AliTRDFitInfo *)c.fVectorFit.UncheckedAt(k))->GetDetector();
260 Int_t ntotal = 1;
053767a4 261 if (GetStack(detector) == 2) {
3a0f6479 262 ntotal = 1728;
263 }
264 else {
265 ntotal = 2304;
266 }
267 Float_t *coef = new Float_t[ntotal];
268 for (Int_t i = 0; i < ntotal; i++) {
269 coef[i] = ((AliTRDFitInfo *)c.fVectorFit.UncheckedAt(k))->GetCoef()[i];
270 }
271 fitInfo->SetCoef(coef);
272 fitInfo->SetDetector(detector);
273 fVectorFit.Add((TObject *) fitInfo);
274 }
275 fVectorFit.SetName(c.fVectorFit.GetName());
276 for(Int_t k = 0; k < c.fVectorFit2.GetEntriesFast(); k++){
277 AliTRDFitInfo *fitInfo = new AliTRDFitInfo();
278 Int_t detector = ((AliTRDFitInfo *)c.fVectorFit2.UncheckedAt(k))->GetDetector();
279 Int_t ntotal = 1;
053767a4 280 if (GetStack(detector) == 2) {
3a0f6479 281 ntotal = 1728;
282 }
283 else {
284 ntotal = 2304;
285 }
286 Float_t *coef = new Float_t[ntotal];
287 for (Int_t i = 0; i < ntotal; i++) {
288 coef[i] = ((AliTRDFitInfo *)c.fVectorFit2.UncheckedAt(k))->GetCoef()[i];
289 }
290 fitInfo->SetCoef(coef);
291 fitInfo->SetDetector(detector);
292 fVectorFit2.Add((TObject *) fitInfo);
293 }
294 if (fGeo) {
295 delete fGeo;
296 }
297 fGeo = new AliTRDgeometry();
55a288e5 298
3a0f6479 299}
55a288e5 300//____________________________________________________________________________________
301AliTRDCalibraFit::~AliTRDCalibraFit()
302{
303 //
304 // AliTRDCalibraFit destructor
305 //
3a0f6479 306 if ( fDebugStreamer ) delete fDebugStreamer;
307 if ( fCalDet ) delete fCalDet;
308 if ( fCalDet2 ) delete fCalDet2;
309 if ( fCalROC ) delete fCalROC;
1ca79a00 310 if ( fCalROC2 ) delete fCalROC2;
840ec79d 311 if ( fCalDetVdriftUsed) delete fCalDetVdriftUsed;
312 if ( fCalDetExBUsed) delete fCalDetExBUsed;
1ca79a00 313 if( fCurrentCoefDetector ) delete [] fCurrentCoefDetector;
314 if( fCurrentCoefDetector2 ) delete [] fCurrentCoefDetector2;
3a0f6479 315 fVectorFit.Delete();
316 fVectorFit2.Delete();
f162af62 317 if (fGeo) {
318 delete fGeo;
319 }
320
55a288e5 321}
55a288e5 322//_____________________________________________________________________________
323void AliTRDCalibraFit::Destroy()
324{
325 //
326 // Delete instance
327 //
328
329 if (fgInstance) {
330 delete fgInstance;
331 fgInstance = 0x0;
332 }
333
64942b85 334}
335//_____________________________________________________________________________
336void AliTRDCalibraFit::DestroyDebugStreamer()
337{
338 //
339 // Delete DebugStreamer
340 //
341
342 if ( fDebugStreamer ) delete fDebugStreamer;
343 fDebugStreamer = 0x0;
344
413153cb 345}
346//__________________________________________________________________________________
979b168f 347void AliTRDCalibraFit::RangeChargeIntegration(Float_t vdrift, Float_t t0, Int_t &begin, Int_t &peak, Int_t &end) const
413153cb 348{
349 //
350 // From the drift velocity and t0
351 // return the position of the peak and maximum negative slope
352 //
353
354 const Float_t kDrWidth = AliTRDgeometry::DrThick(); // drift region
355 Double_t widbins = 0.1; // 0.1 mus
356
357 //peak and maxnegslope in mus
358 Double_t begind = t0*widbins + fT0Shift0;
359 Double_t peakd = t0*widbins + fT0Shift1;
360 Double_t maxnegslope = (kDrWidth + vdrift*peakd)/vdrift;
361
362 // peak and maxnegslope in timebin
363 begin = TMath::Nint(begind*widbins);
364 peak = TMath::Nint(peakd*widbins);
365 end = TMath::Nint(maxnegslope*widbins);
366
55a288e5 367}
55a288e5 368//____________Functions fit Online CH2d________________________________________
979b168f 369Bool_t AliTRDCalibraFit::AnalyseCH(const TH2I *ch)
55a288e5 370{
371 //
372 // Fit the 1D histos, projections of the 2D ch on the Xaxis, for each
373 // calibration group normalized the resulted coefficients (to 1 normally)
55a288e5 374 //
375
3a0f6479 376 // Set the calibration mode
4c865c34 377 //const char *name = ch->GetTitle();
378 TString name = ch->GetTitle();
64942b85 379 if(!SetModeCalibration(name,0)) return kFALSE;
3a0f6479 380
381 // Number of Ybins (detectors or groups of pads)
382 Int_t nbins = ch->GetNbinsX();// charge
383 Int_t nybins = ch->GetNbinsY();// groups number
384 if (!InitFit(nybins,0)) {
55a288e5 385 return kFALSE;
386 }
3a0f6479 387 if (!InitFitCH()) {
55a288e5 388 return kFALSE;
389 }
390 fStatisticMean = 0.0;
391 fNumberFit = 0;
392 fNumberFitSuccess = 0;
393 fNumberEnt = 0;
55a288e5 394 // Init fCountDet and fCount
395 InitfCountDetAndfCount(0);
55a288e5 396 // Beginning of the loop betwwen dect1 and dect2
3a0f6479 397 for (Int_t idect = fDect1; idect < fDect2; idect++) {
398 // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi...
55a288e5 399 UpdatefCountDetAndfCount(idect,0);
55a288e5 400 ReconstructFitRowMinRowMax(idect, 0);
3a0f6479 401 // Take the histo
402 TH1I *projch = (TH1I *) ch->ProjectionX("projch",idect+1,idect+1,(Option_t *)"e");
403 projch->SetDirectory(0);
55a288e5 404 // Number of entries for this calibration group
405 Double_t nentries = 0.0;
406 Double_t mean = 0.0;
3a0f6479 407 for (Int_t k = 0; k < nbins; k++) {
408 Int_t binnb = (nbins+2)*(idect+1)+(k+1);
409 nentries += ch->GetBinContent(binnb);
55a288e5 410 mean += projch->GetBinCenter(k+1)*projch->GetBinContent(k+1);
3a0f6479 411 projch->SetBinError(k+1,TMath::Sqrt(projch->GetBinContent(k+1)));
55a288e5 412 }
3a0f6479 413 projch->SetEntries(nentries);
414 //printf("The number of entries for the group %d is %f\n",idect,nentries);
55a288e5 415 if (nentries > 0) {
416 fNumberEnt++;
417 mean /= nentries;
418 }
55a288e5 419 // Rebin and statistic stuff
55a288e5 420 if (fRebin > 1) {
421 projch = ReBin((TH1I *) projch);
422 }
423 // This detector has not enough statistics or was off
3a0f6479 424 if (nentries <= fMinEntries) {
425 NotEnoughStatisticCH(idect);
426 if (fDebugLevel != 1) {
55a288e5 427 delete projch;
428 }
429 continue;
430 }
55a288e5 431 // Statistics of the group fitted
55a288e5 432 fStatisticMean += nentries;
433 fNumberFit++;
3a0f6479 434 //Method choosen
435 switch(fMethod)
436 {
437 case 0: FitMeanW((TH1 *) projch, nentries); break;
438 case 1: FitMean((TH1 *) projch, nentries, mean); break;
439 case 2: FitCH((TH1 *) projch, mean); break;
440 case 3: FitBisCH((TH1 *) projch, mean); break;
441 default: return kFALSE;
442 }
55a288e5 443 // Fill Infos Fit
3a0f6479 444 FillInfosFitCH(idect);
55a288e5 445 // Memory!!!
3a0f6479 446 if (fDebugLevel != 1) {
55a288e5 447 delete projch;
448 }
55a288e5 449 } // Boucle object
55a288e5 450 // Normierungcharge
3a0f6479 451 if (fDebugLevel != 1) {
55a288e5 452 NormierungCharge();
453 }
55a288e5 454 // Mean Statistic
455 if (fNumberFit > 0) {
3a0f6479 456 AliInfo(Form("There are %d with at least one entries. %d fits have been proceeded (sucessfully or not...). There is a mean statistic of: %d over these fitted histograms and %d successfulled fits",fNumberEnt, fNumberFit, (Int_t) fStatisticMean/fNumberFit, fNumberFitSuccess));
55a288e5 457 fStatisticMean = fStatisticMean / fNumberFit;
458 }
459 else {
460 AliInfo(Form("There are %d with at least one entries. There is no fit!",fNumberEnt));
461 }
3a0f6479 462 delete fDebugStreamer;
463 fDebugStreamer = 0x0;
464
55a288e5 465 return kTRUE;
55a288e5 466}
55a288e5 467//____________Functions fit Online CH2d________________________________________
3a0f6479 468Bool_t AliTRDCalibraFit::AnalyseCH(AliTRDCalibraVector *calvect)
55a288e5 469{
470 //
471 // Reconstruct a 1D histo from the vectorCH for each calibration group,
472 // fit the histo, normalized the resulted coefficients (to 1 normally)
55a288e5 473 //
474
3a0f6479 475 // Set the calibraMode
4c865c34 476 //const char *name = calvect->GetNameCH();
477 TString name = calvect->GetNameCH();
64942b85 478 if(!SetModeCalibration(name,0)) return kFALSE;
55a288e5 479
3a0f6479 480 // Number of Xbins (detectors or groups of pads)
481 if (!InitFit((432*calvect->GetDetCha0(0)+108*calvect->GetDetCha2(0)),0)) {
55a288e5 482 return kFALSE;
483 }
3a0f6479 484 if (!InitFitCH()) {
55a288e5 485 return kFALSE;
486 }
487 fStatisticMean = 0.0;
488 fNumberFit = 0;
489 fNumberFitSuccess = 0;
490 fNumberEnt = 0;
55a288e5 491 // Init fCountDet and fCount
492 InitfCountDetAndfCount(0);
55a288e5 493 // Beginning of the loop between dect1 and dect2
3a0f6479 494 for (Int_t idect = fDect1; idect < fDect2; idect++) {
495 // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi...........
55a288e5 496 UpdatefCountDetAndfCount(idect,0);
55a288e5 497 ReconstructFitRowMinRowMax(idect,0);
3a0f6479 498 // Take the histo
55a288e5 499 Double_t nentries = 0.0;
500 Double_t mean = 0.0;
e526983e 501 if(!calvect->GetCHEntries(fCountDet)) {
502 NotEnoughStatisticCH(idect);
503 continue;
504 }
505
506 TString tname("CH");
507 tname += idect;
508 TH1F *projch = calvect->ConvertVectorCHHisto(fCountDet,(idect-(fCount-(fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0)))),(const char *) tname);
509 projch->SetDirectory(0);
510 for (Int_t k = 0; k < calvect->GetNumberBinCharge(); k++) {
511 nentries += projch->GetBinContent(k+1);
512 mean += projch->GetBinCenter(k+1)*projch->GetBinContent(k+1);
513 }
514 if (nentries > 0) {
515 fNumberEnt++;
516 mean /= nentries;
517 }
518 //printf("The number of entries for the group %d is %f\n",idect,nentries);
519 // Rebin
520 if (fRebin > 1) {
521 projch = ReBin((TH1F *) projch);
55a288e5 522 }
55a288e5 523 // This detector has not enough statistics or was not found in VectorCH
3a0f6479 524 if (nentries <= fMinEntries) {
525 NotEnoughStatisticCH(idect);
55a288e5 526 continue;
55a288e5 527 }
55a288e5 528 // Statistic of the histos fitted
55a288e5 529 fStatisticMean += nentries;
530 fNumberFit++;
3a0f6479 531 //Method choosen
532 switch(fMethod)
533 {
534 case 0: FitMeanW((TH1 *) projch, nentries); break;
535 case 1: FitMean((TH1 *) projch, nentries, mean); break;
536 case 2: FitCH((TH1 *) projch, mean); break;
537 case 3: FitBisCH((TH1 *) projch, mean); break;
538 default: return kFALSE;
539 }
55a288e5 540 // Fill Infos Fit
3a0f6479 541 FillInfosFitCH(idect);
55a288e5 542 } // Boucle object
55a288e5 543 // Normierungcharge
3a0f6479 544 if (fDebugLevel != 1) {
55a288e5 545 NormierungCharge();
546 }
55a288e5 547 // Mean Statistics
548 if (fNumberFit > 0) {
3a0f6479 549 AliInfo(Form("There are %d with at least one entries. %d fits have been proceeded (sucessfully or not...). There is a mean statistic of: %d over these fitted histograms and %d successfulled fits",fNumberEnt, fNumberFit, (Int_t) fStatisticMean/fNumberFit, fNumberFitSuccess));
55a288e5 550 fStatisticMean = fStatisticMean / fNumberFit;
551 }
552 else {
553 AliInfo(Form("There are %d with at least one entries. There is no fit!",fNumberEnt));
554 }
3a0f6479 555 delete fDebugStreamer;
556 fDebugStreamer = 0x0;
55a288e5 557 return kTRUE;
55a288e5 558}
54f2ff1c 559//____________Functions fit Online CH2d________________________________________
560Double_t AliTRDCalibraFit::AnalyseCHAllTogether(const TH2I *ch)
561{
562 //
563 // Fit the 1D histos, projections of the 2D ch on the Xaxis, for each
564 // calibration group normalized the resulted coefficients (to 1 normally)
565 //
566 Int_t nbins = ch->GetNbinsX();// charge
567 Int_t nybins = ch->GetNbinsY();// groups number
568 // Take the histo
569 TH1I *projch = (TH1I *) ch->ProjectionX("projch",1,nybins+1,(Option_t *)"e");
570 projch->SetDirectory(0);
571 // Number of entries for this calibration group
572 Double_t nentries = 0.0;
573 Double_t mean = 0.0;
574 for (Int_t k = 0; k < nbins; k++) {
575 nentries += projch->GetBinContent(k+1);
576 mean += projch->GetBinCenter(k+1)*projch->GetBinContent(k+1);
577 projch->SetBinError(k+1,TMath::Sqrt(projch->GetBinContent(k+1)));
578 }
579 projch->SetEntries(nentries);
580 //printf("The number of entries for the group %d is %f\n",idect,nentries);
581 if (nentries > 0) {
54f2ff1c 582 mean /= nentries;
583 }
584 // This detector has not enough statistics or was off
585 if (nentries <= fMinEntries) {
586 delete projch;
587 AliInfo(Form("There are %d entries for all together, it is not enough (%d)",(Int_t) nentries, fMinEntries));
588 return -100.0;
589 }
590 //Method choosen
591 switch(fMethod)
592 {
593 case 0: FitMeanW((TH1 *) projch, nentries); break;
594 case 1: FitMean((TH1 *) projch, nentries, mean); break;
595 case 2: FitCH((TH1 *) projch, mean); break;
596 case 3: FitBisCH((TH1 *) projch, mean); break;
b88b6bcc 597 default: return -100.0;
54f2ff1c 598 }
599 delete fDebugStreamer;
600 fDebugStreamer = 0x0;
601
602 if(fCurrentCoef[0] > 0.0) return fCurrentCoef[0];
603 else return -100.0;
604
605}
3a0f6479 606//________________functions fit Online PH2d____________________________________
b88b6bcc 607Double_t AliTRDCalibraFit::AnalysePHAllTogether(const TProfile2D *ph)
55a288e5 608{
609 //
3a0f6479 610 // Take the 1D profiles (average pulse height), projections of the 2D PH
611 // on the Xaxis, for each calibration group
612 // Reconstruct a drift velocity
613 // A first calibration of T0 is also made using the same method
55a288e5 614 //
615
3a0f6479 616 // Number of Xbins (detectors or groups of pads)
617 Int_t nbins = ph->GetNbinsX();// time
618 Int_t nybins = ph->GetNbinsY();// calibration group
b88b6bcc 619
620 // Take the histo
621 TH1D *projph = (TH1D *) ph->ProjectionX("projph",1,nybins+1,(Option_t *) "e");
622 projph->SetDirectory(0);
623 // Number of entries for this calibration group
624 Double_t nentries = 0;
625 for(Int_t idect = 0; idect < nybins; idect++){
626 for (Int_t k = 0; k < nbins; k++) {
627 Int_t binnb = (nbins+2)*(idect+1)+(k+1);
628 nentries += ph->GetBinEntries(binnb);
629 }
55a288e5 630 }
b88b6bcc 631 //printf("AnalysePHAllTogether:: the number of entries is %f\n",nentries);
632 // This detector has not enough statistics or was off
633 if (nentries <= fMinEntries) {
634 AliInfo(Form("There are %d entries for all together, it is not enough (%d)",(Int_t) nentries, fMinEntries));
635 if (fDebugLevel != 1) {
636 delete projph;
637 }
638 return -100.0;
639 }
640 //Method choosen
641 //printf("Method\n");
642 switch(fMethod)
643 {
644 case 0: FitLagrangePoly((TH1 *) projph); break;
645 case 1: FitPente((TH1 *) projph); break;
646 case 2: FitPH((TH1 *) projph,0); break;
647 default: return -100.0;
648 }
649 // Memory!!!
650 if (fDebugLevel != 1) {
651 delete projph;
652 }
653 delete fDebugStreamer;
654 fDebugStreamer = 0x0;
655
656 if(fCurrentCoef[0] > 0.0) return fCurrentCoef[0];
657 else return -100.0;
658
659}
660//____________Functions fit Online PH2d________________________________________
661Bool_t AliTRDCalibraFit::AnalysePH(AliTRDCalibraVector *calvect)
662{
663 //
664 // Reconstruct the average pulse height from the vectorPH for each
665 // calibration group
666 // Reconstruct a drift velocity
667 // A first calibration of T0 is also made using the same method (slope method)
668 //
6aafa7ea 669
b88b6bcc 670 // Set the calibration mode
671 //const char *name = calvect->GetNamePH();
672 TString name = calvect->GetNamePH();
673 if(!SetModeCalibration(name,1)) return kFALSE;
6aafa7ea 674
b88b6bcc 675 // Number of Xbins (detectors or groups of pads)
676 if (!InitFit((432*calvect->GetDetCha0(1)+108*calvect->GetDetCha2(1)),1)) {
677 return kFALSE;
678 }
3a0f6479 679 if (!InitFitPH()) {
55a288e5 680 return kFALSE;
681 }
682 fStatisticMean = 0.0;
683 fNumberFit = 0;
684 fNumberFitSuccess = 0;
685 fNumberEnt = 0;
55a288e5 686 // Init fCountDet and fCount
3a0f6479 687 InitfCountDetAndfCount(1);
688 // Beginning of the loop
689 for (Int_t idect = fDect1; idect < fDect2; idect++) {
b88b6bcc 690 // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi...........
3a0f6479 691 UpdatefCountDetAndfCount(idect,1);
692 ReconstructFitRowMinRowMax(idect,1);
693 // Take the histo
b88b6bcc 694 fEntriesCurrent = 0;
695 if(!calvect->GetPHEntries(fCountDet)) {
696 NotEnoughStatisticPH(idect,fEntriesCurrent);
697 continue;
55a288e5 698 }
b88b6bcc 699 TString tname("PH");
700 tname += idect;
701 TH1F *projph = calvect->CorrectTheError((TGraphErrors *) (calvect->ConvertVectorPHTGraphErrors(fCountDet,(idect-(fCount-(fCalibraMode->GetNfragZ(1)*fCalibraMode->GetNfragRphi(1)))),(const char *) tname)),fEntriesCurrent);
702 projph->SetDirectory(0);
703 if(fEntriesCurrent > 0) fNumberEnt++;
704 //printf("The number of entries for the group %d is %d\n",idect,fEntriesCurrent);
3a0f6479 705 // This detector has not enough statistics or was off
b88b6bcc 706 if (fEntriesCurrent <= fMinEntries) {
707 //printf("Not enough stat!\n");
708 NotEnoughStatisticPH(idect,fEntriesCurrent);
55a288e5 709 continue;
55a288e5 710 }
b88b6bcc 711 // Statistic of the histos fitted
55a288e5 712 fNumberFit++;
b88b6bcc 713 fStatisticMean += fEntriesCurrent;
3a0f6479 714 // Calcul of "real" coef
715 CalculVdriftCoefMean();
716 CalculT0CoefMean();
717 //Method choosen
718 switch(fMethod)
719 {
720 case 0: FitLagrangePoly((TH1 *) projph); break;
721 case 1: FitPente((TH1 *) projph); break;
722 case 2: FitPH((TH1 *) projph,(Int_t) (idect - fDect1)); break;
723 default: return kFALSE;
724 }
725 // Fill the tree if end of a detector or only the pointer to the branch!!!
b88b6bcc 726 FillInfosFitPH(idect,fEntriesCurrent);
55a288e5 727 } // Boucle object
b88b6bcc 728
55a288e5 729 // Mean Statistic
730 if (fNumberFit > 0) {
3a0f6479 731 AliInfo(Form("There are %d with at least one entries. %d fits have been proceeded (sucessfully or not...). There is a mean statistic of: %d over these fitted histograms and %d successfulled fits",fNumberEnt, fNumberFit, (Int_t) fStatisticMean/fNumberFit,fNumberFitSuccess));
55a288e5 732 fStatisticMean = fStatisticMean / fNumberFit;
733 }
734 else {
735 AliInfo(Form("There are %d with at least one entries. There is no fit!",fNumberEnt));
736 }
3a0f6479 737 delete fDebugStreamer;
738 fDebugStreamer = 0x0;
55a288e5 739 return kTRUE;
55a288e5 740}
b88b6bcc 741//________________functions fit Online PH2d____________________________________
742Bool_t AliTRDCalibraFit::AnalysePH(const TProfile2D *ph)
55a288e5 743{
744 //
b88b6bcc 745 // Take the 1D profiles (average pulse height), projections of the 2D PH
746 // on the Xaxis, for each calibration group
3a0f6479 747 // Reconstruct a drift velocity
b88b6bcc 748 // A first calibration of T0 is also made using the same method
55a288e5 749 //
750
3a0f6479 751 // Set the calibration mode
b88b6bcc 752 //const char *name = ph->GetTitle();
753 TString name = ph->GetTitle();
64942b85 754 if(!SetModeCalibration(name,1)) return kFALSE;
b88b6bcc 755
756 //printf("Mode calibration set\n");
3a0f6479 757
758 // Number of Xbins (detectors or groups of pads)
b88b6bcc 759 Int_t nbins = ph->GetNbinsX();// time
760 Int_t nybins = ph->GetNbinsY();// calibration group
761 if (!InitFit(nybins,1)) {
55a288e5 762 return kFALSE;
763 }
b88b6bcc 764
765 //printf("Init fit\n");
766
3a0f6479 767 if (!InitFitPH()) {
55a288e5 768 return kFALSE;
769 }
b88b6bcc 770
771 //printf("Init fit PH\n");
772
55a288e5 773 fStatisticMean = 0.0;
774 fNumberFit = 0;
775 fNumberFitSuccess = 0;
776 fNumberEnt = 0;
55a288e5 777 // Init fCountDet and fCount
778 InitfCountDetAndfCount(1);
b88b6bcc 779 //printf("Init Count Det and fCount %d, %d\n",fDect1,fDect2);
780
55a288e5 781 // Beginning of the loop
3a0f6479 782 for (Int_t idect = fDect1; idect < fDect2; idect++) {
b88b6bcc 783 //printf("idect = %d\n",idect);
784 // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi.......
55a288e5 785 UpdatefCountDetAndfCount(idect,1);
55a288e5 786 ReconstructFitRowMinRowMax(idect,1);
3a0f6479 787 // Take the histo
b88b6bcc 788 TH1D *projph = (TH1D *) ph->ProjectionX("projph",idect+1,idect+1,(Option_t *) "e");
789 projph->SetDirectory(0);
790 // Number of entries for this calibration group
791 Double_t nentries = 0;
792 for (Int_t k = 0; k < nbins; k++) {
793 Int_t binnb = (nbins+2)*(idect+1)+(k+1);
794 nentries += ph->GetBinEntries(binnb);
3a0f6479 795 }
b88b6bcc 796 if (nentries > 0) {
797 fNumberEnt++;
798 }
799 //printf("The number of entries for the group %d is %f\n",idect,nentries);
55a288e5 800 // This detector has not enough statistics or was off
b88b6bcc 801 if (nentries <= fMinEntries) {
802 //printf("Not enough statistic!\n");
803 NotEnoughStatisticPH(idect,nentries);
804 if (fDebugLevel != 1) {
805 delete projph;
806 }
55a288e5 807 continue;
55a288e5 808 }
b88b6bcc 809 // Statistics of the histos fitted
55a288e5 810 fNumberFit++;
b88b6bcc 811 fStatisticMean += nentries;
55a288e5 812 // Calcul of "real" coef
3a0f6479 813 CalculVdriftCoefMean();
814 CalculT0CoefMean();
815 //Method choosen
b88b6bcc 816 //printf("Method\n");
3a0f6479 817 switch(fMethod)
818 {
819 case 0: FitLagrangePoly((TH1 *) projph); break;
820 case 1: FitPente((TH1 *) projph); break;
821 case 2: FitPH((TH1 *) projph,(Int_t) (idect - fDect1)); break;
822 default: return kFALSE;
823 }
55a288e5 824 // Fill the tree if end of a detector or only the pointer to the branch!!!
b88b6bcc 825 FillInfosFitPH(idect,nentries);
826 // Memory!!!
827 if (fDebugLevel != 1) {
828 delete projph;
829 }
55a288e5 830 } // Boucle object
55a288e5 831 // Mean Statistic
832 if (fNumberFit > 0) {
3a0f6479 833 AliInfo(Form("There are %d with at least one entries. %d fits have been proceeded (sucessfully or not...). There is a mean statistic of: %d over these fitted histograms and %d successfulled fits",fNumberEnt, fNumberFit, (Int_t) fStatisticMean/fNumberFit,fNumberFitSuccess));
55a288e5 834 fStatisticMean = fStatisticMean / fNumberFit;
835 }
836 else {
837 AliInfo(Form("There are %d with at least one entries. There is no fit!",fNumberEnt));
838 }
3a0f6479 839 delete fDebugStreamer;
840 fDebugStreamer = 0x0;
55a288e5 841 return kTRUE;
55a288e5 842}
3a0f6479 843//____________Functions fit Online PRF2d_______________________________________
979b168f 844Bool_t AliTRDCalibraFit::AnalysePRF(const TProfile2D *prf)
55a288e5 845{
846 //
3a0f6479 847 // Take the 1D profiles (pad response function), projections of the 2D PRF
848 // on the Xaxis, for each calibration group
849 // Fit with a gaussian to reconstruct the sigma of the pad response function
55a288e5 850 //
851
3a0f6479 852 // Set the calibration mode
4c865c34 853 //const char *name = prf->GetTitle();
854 TString name = prf->GetTitle();
64942b85 855 if(!SetModeCalibration(name,2)) return kFALSE;
55a288e5 856
3a0f6479 857 // Number of Ybins (detectors or groups of pads)
858 Int_t nybins = prf->GetNbinsY();// calibration groups
859 Int_t nbins = prf->GetNbinsX();// bins
860 Int_t nbg = GetNumberOfGroupsPRF((const char *)prf->GetTitle());
861 if((nbg > 0) || (nbg == -1)) return kFALSE;
862 if (!InitFit(nybins,2)) {
55a288e5 863 return kFALSE;
864 }
3a0f6479 865 if (!InitFitPRF()) {
55a288e5 866 return kFALSE;
867 }
868 fStatisticMean = 0.0;
869 fNumberFit = 0;
870 fNumberFitSuccess = 0;
871 fNumberEnt = 0;
55a288e5 872 // Init fCountDet and fCount
3a0f6479 873 InitfCountDetAndfCount(2);
55a288e5 874 // Beginning of the loop
3a0f6479 875 for (Int_t idect = fDect1; idect < fDect2; idect++) {
876 // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi......
877 UpdatefCountDetAndfCount(idect,2);
878 ReconstructFitRowMinRowMax(idect,2);
879 // Take the histo
880 TH1D *projprf = (TH1D *) prf->ProjectionX("projprf",idect+1,idect+1,(Option_t *) "e");
881 projprf->SetDirectory(0);
882 // Number of entries for this calibration group
883 Double_t nentries = 0;
884 for (Int_t k = 0; k < nbins; k++) {
885 Int_t binnb = (nbins+2)*(idect+1)+(k+1);
886 nentries += prf->GetBinEntries(binnb);
55a288e5 887 }
3a0f6479 888 if(nentries > 0) fNumberEnt++;
55a288e5 889 // This detector has not enough statistics or was off
3a0f6479 890 if (nentries <= fMinEntries) {
891 NotEnoughStatisticPRF(idect);
892 if (fDebugLevel != 1) {
893 delete projprf;
55a288e5 894 }
55a288e5 895 continue;
55a288e5 896 }
3a0f6479 897 // Statistics of the histos fitted
55a288e5 898 fNumberFit++;
3a0f6479 899 fStatisticMean += nentries;
55a288e5 900 // Calcul of "real" coef
3a0f6479 901 CalculPRFCoefMean();
902 //Method choosen
903 switch(fMethod)
904 {
905 case 0: FitPRF((TH1 *) projprf); break;
906 case 1: RmsPRF((TH1 *) projprf); break;
907 default: return kFALSE;
908 }
55a288e5 909 // Fill the tree if end of a detector or only the pointer to the branch!!!
3a0f6479 910 FillInfosFitPRF(idect);
55a288e5 911 // Memory!!!
3a0f6479 912 if (fDebugLevel != 1) {
913 delete projprf;
55a288e5 914 }
55a288e5 915 } // Boucle object
55a288e5 916 // Mean Statistic
917 if (fNumberFit > 0) {
918 AliInfo(Form("There are %d with at least one entries.",fNumberEnt));
919 AliInfo(Form("%d fits have been proceeded (sucessfully or not...).",fNumberFit));
920 AliInfo(Form("There is a mean statistic of: %d over these fitted histograms and %d successfulled fits"
921 ,(Int_t) fStatisticMean/fNumberFit,fNumberFitSuccess));
922 fStatisticMean = fStatisticMean / fNumberFit;
923 }
924 else {
925 AliInfo(Form("There are %d with at least one entries. There is no fit!",fNumberEnt));
926 }
3a0f6479 927 delete fDebugStreamer;
928 fDebugStreamer = 0x0;
55a288e5 929 return kTRUE;
55a288e5 930}
3a0f6479 931//____________Functions fit Online PRF2d_______________________________________
979b168f 932Bool_t AliTRDCalibraFit::AnalysePRFMarianFit(const TProfile2D *prf)
55a288e5 933{
934 //
3a0f6479 935 // Take the 1D profiles (pad response function), projections of the 2D PRF
936 // on the Xaxis, for each calibration group
937 // Fit with a gaussian to reconstruct the sigma of the pad response function
55a288e5 938 //
3a0f6479 939
940 // Set the calibration mode
4c865c34 941 //const char *name = prf->GetTitle();
942 TString name = prf->GetTitle();
64942b85 943 if(!SetModeCalibration(name,2)) return kFALSE;
3a0f6479 944
945 // Number of Ybins (detectors or groups of pads)
946 TAxis *xprf = prf->GetXaxis();
947 TAxis *yprf = prf->GetYaxis();
948 Int_t nybins = yprf->GetNbins();// calibration groups
949 Int_t nbins = xprf->GetNbins();// bins
950 Float_t lowedge = (Float_t) xprf->GetBinLowEdge(1);//lowedge in bins
951 Float_t upedge = (Float_t) xprf->GetBinUpEdge(nbins);//upedge in bins
952 Int_t nbg = GetNumberOfGroupsPRF((const char *)name);
953 if(nbg == -1) return kFALSE;
954 if(nbg > 0) fMethod = 1;
955 else fMethod = 0;
956 if (!InitFit(nybins,2)) {
55a288e5 957 return kFALSE;
958 }
3a0f6479 959 if (!InitFitPRF()) {
55a288e5 960 return kFALSE;
961 }
962 fStatisticMean = 0.0;
3a0f6479 963 fNumberFit = 0;
55a288e5 964 fNumberFitSuccess = 0;
965 fNumberEnt = 0;
55a288e5 966 // Init fCountDet and fCount
3a0f6479 967 InitfCountDetAndfCount(2);
55a288e5 968 // Beginning of the loop
3a0f6479 969 for (Int_t idect = fDect1; idect < fDect2; idect++) {
970 // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi.......
971 UpdatefCountDetAndfCount(idect,2);
972 ReconstructFitRowMinRowMax(idect,2);
973 // Build the array of entries and sum
974 TArrayD arraye = TArrayD(nbins);
975 TArrayD arraym = TArrayD(nbins);
976 TArrayD arrayme = TArrayD(nbins);
977 Double_t nentries = 0;
978 //printf("nbins %d\n",nbins);
979 for (Int_t k = 0; k < nbins; k++) {
980 Int_t binnb = (nbins+2)*(idect+1)+(k+1);
981 Double_t entries = (Double_t)prf->GetBinEntries(binnb);
982 Double_t mean = (Double_t)prf->GetBinContent(binnb);
983 Double_t error = (Double_t)prf->GetBinError(binnb);
984 //printf("for %d we have %f\n",k,entries);
985 nentries += entries;
986 arraye.AddAt(entries,k);
987 arraym.AddAt(mean,k);
988 arrayme.AddAt(error,k);
55a288e5 989 }
3a0f6479 990 if(nentries > 0) fNumberEnt++;
991 //printf("The number of entries for the group %d is %f\n",idect,nentries);
55a288e5 992 // This detector has not enough statistics or was off
3a0f6479 993 if (nentries <= fMinEntries) {
994 NotEnoughStatisticPRF(idect);
55a288e5 995 continue;
55a288e5 996 }
55a288e5 997 // Statistics of the histos fitted
55a288e5 998 fNumberFit++;
3a0f6479 999 fStatisticMean += nentries;
55a288e5 1000 // Calcul of "real" coef
3a0f6479 1001 CalculPRFCoefMean();
1002 //Method choosen
1003 switch(fMethod)
1004 {
1005 case 0: FitPRFGausMI( arraye.GetArray(), arraym.GetArray(), arrayme.GetArray(), nbins, lowedge, upedge); break;
1006 case 1: FitTnpRange( arraye.GetArray(), arraym.GetArray(), arrayme.GetArray(), nbg, nbins); break;
1007 default: return kFALSE;
1008 }
55a288e5 1009 // Fill the tree if end of a detector or only the pointer to the branch!!!
3a0f6479 1010 FillInfosFitPRF(idect);
55a288e5 1011 } // Boucle object
3a0f6479 1012 // Mean Statistic
55a288e5 1013 if (fNumberFit > 0) {
1014 AliInfo(Form("There are %d with at least one entries.",fNumberEnt));
1015 AliInfo(Form("%d fits have been proceeded (sucessfully or not...).",fNumberFit));
1016 AliInfo(Form("There is a mean statistic of: %d over these fitted histograms and %d successfulled fits"
1017 ,(Int_t) fStatisticMean/fNumberFit,fNumberFitSuccess));
1018 fStatisticMean = fStatisticMean / fNumberFit;
1019 }
1020 else {
1021 AliInfo(Form("There are %d with at least one entries. There is no fit!",fNumberEnt));
1022 }
3a0f6479 1023 delete fDebugStreamer;
1024 fDebugStreamer = 0x0;
55a288e5 1025 return kTRUE;
55a288e5 1026}
55a288e5 1027//____________Functions fit Online PRF2d_______________________________________
3a0f6479 1028Bool_t AliTRDCalibraFit::AnalysePRF(AliTRDCalibraVector *calvect)
55a288e5 1029{
1030 //
3a0f6479 1031 // Reconstruct the 1D histo (pad response function) from the vectorPRD for
1032 // each calibration group
55a288e5 1033 // Fit with a gaussian to reconstruct the sigma of the pad response function
55a288e5 1034 //
1035
3a0f6479 1036 // Set the calibra mode
4c865c34 1037 //const char *name = calvect->GetNamePRF();
1038 TString name = calvect->GetNamePRF();
64942b85 1039 if(!SetModeCalibration(name,2)) return kFALSE;
3a0f6479 1040 //printf("test0 %s\n",name);
55a288e5 1041
1042 // Number of Xbins (detectors or groups of pads)
3a0f6479 1043 if (!InitFit((432*calvect->GetDetCha0(2)+108*calvect->GetDetCha2(2)),2)) {
1044 //printf("test1\n");
1045 return kFALSE;
1046 }
1047 if (!InitFitPRF()) {
1048 ///printf("test2\n");
55a288e5 1049 return kFALSE;
1050 }
1051 fStatisticMean = 0.0;
1052 fNumberFit = 0;
1053 fNumberFitSuccess = 0;
1054 fNumberEnt = 0;
55a288e5 1055 // Init fCountDet and fCount
1056 InitfCountDetAndfCount(2);
55a288e5 1057 // Beginning of the loop
3a0f6479 1058 for (Int_t idect = fDect1; idect < fDect2; idect++) {
1059 // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi........
55a288e5 1060 UpdatefCountDetAndfCount(idect,2);
55a288e5 1061 ReconstructFitRowMinRowMax(idect,2);
3a0f6479 1062 // Take the histo
3a0f6479 1063 fEntriesCurrent = 0;
e526983e 1064 if(!calvect->GetPRFEntries(fCountDet)) {
1065 NotEnoughStatisticPRF(idect);
1066 continue;
3a0f6479 1067 }
e526983e 1068 TString tname("PRF");
1069 tname += idect;
1070 TH1F *projprf = calvect->CorrectTheError((TGraphErrors *) (calvect->ConvertVectorPRFTGraphErrors(fCountDet,(idect-(fCount-(fCalibraMode->GetNfragZ(1)*fCalibraMode->GetNfragRphi(1)))),(const char *) tname)),fEntriesCurrent);
1071 projprf->SetDirectory(0);
1072 if(fEntriesCurrent > 0) fNumberEnt++;
55a288e5 1073 // This detector has not enough statistics or was off
3a0f6479 1074 if (fEntriesCurrent <= fMinEntries) {
1075 NotEnoughStatisticPRF(idect);
55a288e5 1076 continue;
55a288e5 1077 }
3a0f6479 1078 // Statistic of the histos fitted
55a288e5 1079 fNumberFit++;
3a0f6479 1080 fStatisticMean += fEntriesCurrent;
55a288e5 1081 // Calcul of "real" coef
3a0f6479 1082 CalculPRFCoefMean();
1083 //Method choosen
1084 switch(fMethod)
1085 {
1086 case 1: FitPRF((TH1 *) projprf); break;
1087 case 2: RmsPRF((TH1 *) projprf); break;
1088 default: return kFALSE;
1089 }
55a288e5 1090 // Fill the tree if end of a detector or only the pointer to the branch!!!
3a0f6479 1091 FillInfosFitPRF(idect);
55a288e5 1092 } // Boucle object
3a0f6479 1093 // Mean Statistics
55a288e5 1094 if (fNumberFit > 0) {
3a0f6479 1095 AliInfo(Form("There are %d with at least one entries. %d fits have been proceeded (sucessfully or not...). There is a mean statistic of: %d over these fitted histograms and %d successfulled fits",fNumberEnt, fNumberFit, (Int_t) fStatisticMean/fNumberFit,fNumberFitSuccess));
55a288e5 1096 }
1097 else {
1098 AliInfo(Form("There are %d with at least one entries. There is no fit!",fNumberEnt));
1099 }
3a0f6479 1100 delete fDebugStreamer;
1101 fDebugStreamer = 0x0;
55a288e5 1102 return kTRUE;
55a288e5 1103}
55a288e5 1104//____________Functions fit Online PRF2d_______________________________________
3a0f6479 1105Bool_t AliTRDCalibraFit::AnalysePRFMarianFit(AliTRDCalibraVector *calvect)
55a288e5 1106{
1107 //
1108 // Reconstruct the 1D histo (pad response function) from the vectorPRD for
1109 // each calibration group
1110 // Fit with a gaussian to reconstruct the sigma of the pad response function
55a288e5 1111 //
1112
3a0f6479 1113 // Set the calibra mode
4c865c34 1114 //const char *name = calvect->GetNamePRF();
1115 TString name = calvect->GetNamePRF();
64942b85 1116 if(!SetModeCalibration(name,2)) return kFALSE;
3a0f6479 1117 //printf("test0 %s\n",name);
1118 Int_t nbg = GetNumberOfGroupsPRF((const char *)name);
64942b85 1119 //printf("test1 %d\n",nbg);
3a0f6479 1120 if(nbg == -1) return kFALSE;
1121 if(nbg > 0) fMethod = 1;
1122 else fMethod = 0;
1123 // Number of Xbins (detectors or groups of pads)
1124 if (!InitFit((432*calvect->GetDetCha0(2)+108*calvect->GetDetCha2(2)),2)) {
1125 //printf("test2\n");
55a288e5 1126 return kFALSE;
1127 }
3a0f6479 1128 if (!InitFitPRF()) {
1129 //printf("test3\n");
55a288e5 1130 return kFALSE;
1131 }
1132 fStatisticMean = 0.0;
1133 fNumberFit = 0;
1134 fNumberFitSuccess = 0;
1135 fNumberEnt = 0;
3a0f6479 1136 // Variables
1137 Int_t nbins = 0;
1138 Double_t *arrayx = 0;
1139 Double_t *arraye = 0;
1140 Double_t *arraym = 0;
1141 Double_t *arrayme = 0;
1142 Float_t lowedge = 0.0;
1143 Float_t upedge = 0.0;
55a288e5 1144 // Init fCountDet and fCount
1145 InitfCountDetAndfCount(2);
55a288e5 1146 // Beginning of the loop
3a0f6479 1147 for (Int_t idect = fDect1; idect < fDect2; idect++) {
1148 // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi......
55a288e5 1149 UpdatefCountDetAndfCount(idect,2);
55a288e5 1150 ReconstructFitRowMinRowMax(idect,2);
3a0f6479 1151 // Take the histo
3a0f6479 1152 fEntriesCurrent = 0;
e526983e 1153 if(!calvect->GetPRFEntries(fCountDet)) {
1154 NotEnoughStatisticPRF(idect);
1155 continue;
3a0f6479 1156 }
e526983e 1157 TString tname("PRF");
1158 tname += idect;
1159 TGraphErrors *projprftree = calvect->ConvertVectorPRFTGraphErrors(fCountDet,(idect-(fCount-(fCalibraMode->GetNfragZ(1)*fCalibraMode->GetNfragRphi(1)))),(const char *) tname);
1160 nbins = projprftree->GetN();
1161 arrayx = (Double_t *)projprftree->GetX();
1162 arraye = (Double_t *)projprftree->GetEX();
1163 arraym = (Double_t *)projprftree->GetY();
1164 arrayme = (Double_t *)projprftree->GetEY();
1165 Float_t step = arrayx[1]-arrayx[0];
1166 lowedge = arrayx[0] - step/2.0;
1167 upedge = arrayx[(nbins-1)] + step/2.0;
1168 //printf("nbins est %d\n",nbins);
1169 for(Int_t k = 0; k < nbins; k++){
1170 fEntriesCurrent += (Int_t)arraye[k];
1171 //printf("for %d we have %f, %f\n",k,arraye[k],((projprftree->GetEX())[k]));
1172 if(arraye[k]>0.0) arrayme[k] = TMath::Sqrt(TMath::Abs(arrayme[k]-arraym[k]*arraym[k])/arraye[k]);
1173 }
1174 if(fEntriesCurrent > 0) fNumberEnt++;
3a0f6479 1175 //printf("The number of entries for the group %d is %d\n",idect,fEntriesCurrent);
1176 // This detector has not enough statistics or was off
1177 if (fEntriesCurrent <= fMinEntries) {
1178 NotEnoughStatisticPRF(idect);
55a288e5 1179 continue;
55a288e5 1180 }
55a288e5 1181 // Statistic of the histos fitted
55a288e5 1182 fNumberFit++;
1183 fStatisticMean += fEntriesCurrent;
55a288e5 1184 // Calcul of "real" coef
3a0f6479 1185 CalculPRFCoefMean();
1186 //Method choosen
1187 switch(fMethod)
1188 {
1189 case 0: FitPRFGausMI(arraye,arraym,arrayme,nbins,lowedge,upedge); break;
1190 case 1: FitTnpRange(arraye,arraym,arrayme,nbg,nbins); break;
1191 default: return kFALSE;
1192 }
55a288e5 1193 // Fill the tree if end of a detector or only the pointer to the branch!!!
3a0f6479 1194 FillInfosFitPRF(idect);
55a288e5 1195 } // Boucle object
55a288e5 1196 // Mean Statistics
1197 if (fNumberFit > 0) {
3a0f6479 1198 AliInfo(Form("There are %d with at least one entries. %d fits have been proceeded (sucessfully or not...). There is a mean statistic of: %d over these fitted histograms and %d successfulled fits",fNumberEnt, fNumberFit, (Int_t) fStatisticMean/fNumberFit,fNumberFitSuccess));
55a288e5 1199 }
1200 else {
1201 AliInfo(Form("There are %d with at least one entries. There is no fit!",fNumberEnt));
1202 }
3a0f6479 1203 delete fDebugStreamer;
1204 fDebugStreamer = 0x0;
55a288e5 1205 return kTRUE;
55a288e5 1206}
3a0f6479 1207//____________Functions fit Online CH2d________________________________________
1208Bool_t AliTRDCalibraFit::AnalyseLinearFitters(AliTRDCalibraVdriftLinearFit *calivdli)
55a288e5 1209{
1210 //
3a0f6479 1211 // The linear method
55a288e5 1212 //
1213
55a288e5 1214 fStatisticMean = 0.0;
1215 fNumberFit = 0;
1216 fNumberFitSuccess = 0;
1217 fNumberEnt = 0;
3a0f6479 1218 if(!InitFitLinearFitter()) return kFALSE;
55a288e5 1219
3a0f6479 1220
1221 for(Int_t idet = 0; idet < 540; idet++){
55a288e5 1222
55a288e5 1223
3a0f6479 1224 //printf("detector number %d\n",idet);
55a288e5 1225
3a0f6479 1226 // Take the result
1227 TVectorD param(2);
1228 TVectorD error(3);
1229 fEntriesCurrent = 0;
1230 fCountDet = idet;
1231 Bool_t here = calivdli->GetParam(idet,&param);
1232 Bool_t heree = calivdli->GetError(idet,&error);
1233 //printf("here %d and heree %d\n",here, heree);
1234 if(heree) {
1235 fEntriesCurrent = (Int_t) error[2];
55a288e5 1236 fNumberEnt++;
55a288e5 1237 }
3a0f6479 1238 //printf("Number of entries %d\n",fEntriesCurrent);
1239 // Nothing found or not enough statistic
1240 if((!heree) || (!here) || (fEntriesCurrent <= fMinEntries)) {
1241 NotEnoughStatisticLinearFitter();
1242 continue;
1243 }
1244 //param.Print();
1245 //error.Print();
1246 //Statistics
1247 fNumberFit++;
1248 fStatisticMean += fEntriesCurrent;
55a288e5 1249
3a0f6479 1250 // Check the fit
1251 if((-(param[1])) <= 0.0) {
1252 NotEnoughStatisticLinearFitter();
1253 continue;
1254 }
55a288e5 1255
3a0f6479 1256 // CalculDatabaseVdriftandTan
1257 CalculVdriftLorentzCoef();
840ec79d 1258 //printf("AliTRDCalibraFit::AnalyzeVdriftLinearFit detector %d, vdrift %f and %f and exB %f and %f\n",idet,fCalDetVdriftUsed->GetValue(idet),fCurrentCoef[1],fCalDetExBUsed->GetValue(idet),fCurrentCoef2[1]);
55a288e5 1259
3a0f6479 1260 // Statistics
1261 fNumberFitSuccess ++;
55a288e5 1262
3a0f6479 1263 // Put the fCurrentCoef
1264 fCurrentCoef[0] = -param[1];
1265 // here the database must be the one of the reconstruction for the lorentz angle....
1266 fCurrentCoef2[0] = (param[0]+fCurrentCoef[1]*fCurrentCoef2[1])/fCurrentCoef[0];
1267 fCurrentCoefE = error[1];
1268 fCurrentCoefE2 = error[0];
daa7dc79 1269 if((TMath::Abs(fCurrentCoef2[0]) > 0.0000001) && (TMath::Abs(param[0]) > 0.0000001)){
3a0f6479 1270 fCurrentCoefE2 = (fCurrentCoefE2/param[0]+fCurrentCoefE/fCurrentCoef[0])*fCurrentCoef2[0];
1271 }
55a288e5 1272
3a0f6479 1273 // Fill
1274 FillInfosFitLinearFitter();
55a288e5 1275
55a288e5 1276
55a288e5 1277 }
55a288e5 1278 // Mean Statistics
1279 if (fNumberFit > 0) {
3a0f6479 1280 AliInfo(Form("There are %d with at least one entries. %d fits have been proceeded (sucessfully or not...). There is a mean statistic of: %d over these fitted histograms and %d successfulled fits",fNumberEnt, fNumberFit, (Int_t) fStatisticMean/fNumberFit,fNumberFitSuccess));
55a288e5 1281 }
1282 else {
1283 AliInfo(Form("There are %d with at least one entries. There is no fit!",fNumberEnt));
1284 }
3a0f6479 1285 delete fDebugStreamer;
1286 fDebugStreamer = 0x0;
55a288e5 1287 return kTRUE;
1288
a0bb5615 1289}
1290//______________________________________________________________________________________
1291Bool_t AliTRDCalibraFit::AnalyseExbAltFit(AliTRDCalibraExbAltFit *calivdli)
1292{
1293 //
1294 // The linear method
1295 //
1296
1297 fStatisticMean = 0.0;
1298 fNumberFit = 0;
1299 fNumberFitSuccess = 0;
1300 fNumberEnt = 0;
1301 if(!InitFitExbAlt()) return kFALSE;
1302
1303
1304 for(Int_t idet = 0; idet < 540; idet++){
1305
1306
1307 //printf("detector number %d\n",idet);
1308
1309 // Take the result
1310 TVectorD param(3);
1311 TVectorD error(3);
1312 fEntriesCurrent = 0;
1313 fCountDet = idet;
1314 Bool_t here = calivdli->GetParam(idet,&param);
1315 Bool_t heree = calivdli->GetError(idet,&error);
1316 //printf("here %d and heree %d\n",here, heree);
1317 if(heree) {
1318 fEntriesCurrent = (Int_t) error[2];
1319 fNumberEnt++;
1320 }
1321 //printf("Number of entries %d\n",fEntriesCurrent);
1322 // Nothing found or not enough statistic
1323 if((!heree) || (!here) || (fEntriesCurrent <= fMinEntries)) {
1324 NotEnoughStatisticExbAlt();
1325 continue;
1326 }
1327 //param.Print();
1328 //error.Print();
1329 //Statistics
1330 fNumberFit++;
1331 fStatisticMean += fEntriesCurrent;
1332
1333 // Statistics
1334 fNumberFitSuccess ++;
1335
1336 // Put the fCurrentCoef
1337 if(TMath::Abs(param[2])>0.0001){
1338 fCurrentCoef2[0] = -param[1]/2/param[2];
1339 fCurrentCoefE2 = 0;//error[1];
1340 }else{
1341 fCurrentCoef2[0] = 100;
1342 fCurrentCoefE2 = 0;//error[1];
1343 }
1344
1345 // Fill
1346 FillInfosFitExbAlt();
1347
1348 }
1349 // Mean Statistics
1350 if (fNumberFit > 0) {
1351 AliInfo(Form("There are %d with at least one entries. %d fits have been proceeded (sucessfully or not...). There is a mean statistic of: %d over these fitted histograms and %d successfulled fits",fNumberEnt, fNumberFit, (Int_t) fStatisticMean/fNumberFit,fNumberFitSuccess));
1352 }
1353 else {
1354 AliInfo(Form("There are %d with at least one entries. There is no fit!",fNumberEnt));
1355 }
1356 delete fDebugStreamer;
1357 fDebugStreamer = 0x0;
1358 return kTRUE;
1359
54f2ff1c 1360}
1361//____________Functions fit Online CH2d________________________________________
840ec79d 1362void AliTRDCalibraFit::AnalyseLinearFittersAllTogether(AliTRDCalibraVdriftLinearFit *calivdli, Double_t &vdriftoverall, Double_t &exboverall)
54f2ff1c 1363{
1364 //
1365 // The linear method
1366 //
1367
840ec79d 1368 // Get the mean vdrift and exb used
1369 Double_t meanvdriftused = 0.0;
1370 Double_t meanexbused = 0.0;
1371 Double_t counterdet = 0.0;
1372 if((!fCalDetVdriftUsed) || (!fCalDetExBUsed)) {
1373 vdriftoverall = -100.0;
1374 exboverall = 100.0;
1375 return;
1376 }
1377
54f2ff1c 1378 // Add histos
1379
1380 TH2S *linearfitterhisto = 0x0;
1381
1382 for(Int_t idet = 0; idet < 540; idet++){
1383
1384 TH2S * u = calivdli->GetLinearFitterHistoForce(idet);
840ec79d 1385 Double_t detectorentries = u->Integral();
1386 meanvdriftused += fCalDetVdriftUsed->GetValue(idet)*detectorentries;
1387 meanexbused += fCalDetExBUsed->GetValue(idet)*detectorentries;
1388 counterdet += detectorentries;
1389
1390 //printf("detectorentries %f\n",detectorentries);
1391
1392 //printf("AliTRDCalibraFit::AnalyzeVdriftLinearFitsAllTogether detector %d, vdrift %f and exB %f\n",idet,fCalDetVdriftUsed->GetValue(idet),fCalDetExBUsed->GetValue(idet));
1393
54f2ff1c 1394 if(idet == 0) linearfitterhisto = u;
1395 else linearfitterhisto->Add(u);
1396
1397 }
840ec79d 1398 if(counterdet > 0.0){
1399 meanvdriftused = meanvdriftused/counterdet;
1400 meanexbused = meanexbused/counterdet;
1401 }
1402 else {
1403 vdriftoverall = -100.0;
1404 exboverall = 100.0;
1405 return;
1406 }
1407
1408
1409 //printf("AliTRDCalibraFit::AnalyzeVdriftLinearFitsAllTogether MEAN vdrift %f and exB %f\n",meanvdriftused,meanexbused);
54f2ff1c 1410
1411 // Fit
1412
1413 Int_t entries = 0;
1414 TAxis *xaxis = linearfitterhisto->GetXaxis();
1415 TAxis *yaxis = linearfitterhisto->GetYaxis();
1416 TLinearFitter linearfitter = TLinearFitter(2,"pol1");
1417 //printf("test\n");
1418 Double_t integral = linearfitterhisto->Integral();
1419 //printf("Integral is %f\n",integral);
1420 Bool_t securitybreaking = kFALSE;
1421 if(TMath::Abs(integral-1199) < 0.00001) securitybreaking = kTRUE;
1422 for(Int_t ibinx = 0; ibinx < linearfitterhisto->GetNbinsX(); ibinx++){
1423 for(Int_t ibiny = 0; ibiny < linearfitterhisto->GetNbinsY(); ibiny++){
1424 if(linearfitterhisto->GetBinContent(ibinx+1,ibiny+1)>0){
1425 Double_t x = xaxis->GetBinCenter(ibinx+1);
1426 Double_t y = yaxis->GetBinCenter(ibiny+1);
1427
1428 for(Int_t k = 0; k < (Int_t)linearfitterhisto->GetBinContent(ibinx+1,ibiny+1); k++){
1429 if(!securitybreaking){
1430 linearfitter.AddPoint(&x,y);
1431 entries++;
1432 }
1433 else {
1434 if(entries< 1198){
1435 linearfitter.AddPoint(&x,y);
1436 entries++;
1437 }
1438 }
1439 }
1440
1441 }
1442 }
1443 }
1444
b88b6bcc 1445 //printf("AnalyseLinearFittersAllTogether::Find %d entries\n",entries);
1446 //printf("Minstats %d\n",fMinEntries);
54f2ff1c 1447
840ec79d 1448
1449
1450 // Eval the linear fitter
54f2ff1c 1451 if(entries > fMinEntries){
1452 TVectorD par = TVectorD(2);
1453 //printf("Fit\n");
1454 if((linearfitter.EvalRobust(0.8)==0)) {
1455 //printf("Take the param\n");
1456 linearfitter.GetParameters(par);
1457 //printf("Done\n");
840ec79d 1458 //par.Print();
54f2ff1c 1459 //printf("Finish\n");
1460 // Put the fCurrentCoef
1461 fCurrentCoef[0] = -par[1];
1462 // here the database must be the one of the reconstruction for the lorentz angle....
840ec79d 1463 if(fCurrentCoef[0] > 0.0) fCurrentCoef2[0] = (par[0]+meanvdriftused*meanexbused)/fCurrentCoef[0];
1464 else fCurrentCoef2[0] = 100.0;
1465
1466 }
1467 else {
1468
1469 fCurrentCoef[0] = -100.0;
1470 fCurrentCoef2[0] = 100.0;
54f2ff1c 1471
54f2ff1c 1472 }
54f2ff1c 1473
1474
1475 }
1476 else {
840ec79d 1477
1478 fCurrentCoef[0] = -100.0;
1479 fCurrentCoef2[0] = 100.0;
1480
54f2ff1c 1481 }
1482
840ec79d 1483 vdriftoverall = fCurrentCoef[0];
1484 exboverall = fCurrentCoef2[0];
1485
1486
54f2ff1c 1487 delete linearfitterhisto;
1488 delete fDebugStreamer;
1489 fDebugStreamer = 0x0;
1490
55a288e5 1491}
55a288e5 1492//____________Functions for seeing if the pad is really okey___________________
3a0f6479 1493//_____________________________________________________________________________
4c865c34 1494Int_t AliTRDCalibraFit::GetNumberOfGroupsPRF(TString nametitle)
3a0f6479 1495{
1496 //
1497 // Get numberofgroupsprf
1498 //
1499
1500 // Some patterns
1501 const Char_t *pattern0 = "Ngp0";
1502 const Char_t *pattern1 = "Ngp1";
1503 const Char_t *pattern2 = "Ngp2";
1504 const Char_t *pattern3 = "Ngp3";
1505 const Char_t *pattern4 = "Ngp4";
1506 const Char_t *pattern5 = "Ngp5";
1507 const Char_t *pattern6 = "Ngp6";
1508
1509 // Nrphi mode
4c865c34 1510 if (strstr(nametitle.Data(),pattern0)) {
3a0f6479 1511 return 0;
1512 }
4c865c34 1513 if (strstr(nametitle.Data(),pattern1)) {
3a0f6479 1514 return 1;
1515 }
4c865c34 1516 if (strstr(nametitle.Data(),pattern2)) {
3a0f6479 1517 return 2;
1518 }
4c865c34 1519 if (strstr(nametitle.Data(),pattern3)) {
3a0f6479 1520 return 3;
1521 }
4c865c34 1522 if (strstr(nametitle.Data(),pattern4)) {
3a0f6479 1523 return 4;
1524 }
4c865c34 1525 if (strstr(nametitle.Data(),pattern5)) {
3a0f6479 1526 return 5;
1527 }
4c865c34 1528 if (strstr(nametitle.Data(),pattern6)){
3a0f6479 1529 return 6;
1530 }
1531 else return -1;
1532
55a288e5 1533
3a0f6479 1534}
55a288e5 1535//_____________________________________________________________________________
4c865c34 1536Bool_t AliTRDCalibraFit::SetModeCalibration(TString name, Int_t i)
55a288e5 1537{
1538 //
1539 // Set fNz[i] and fNrphi[i] of the AliTRDCalibraFit::Instance()
3a0f6479 1540 // corresponding to the given name
55a288e5 1541 //
1542
3a0f6479 1543 if(!SetNzFromTObject(name,i)) return kFALSE;
1544 if(!SetNrphiFromTObject(name,i)) return kFALSE;
1545
1546 return kTRUE;
55a288e5 1547
3a0f6479 1548}
1549//_____________________________________________________________________________
4c865c34 1550Bool_t AliTRDCalibraFit::SetNrphiFromTObject(TString name, Int_t i)
3a0f6479 1551{
1552 //
1553 // Set fNrphi[i] of the AliTRDCalibraFit::Instance()
1554 // corresponding to the given TObject
1555 //
1556
55a288e5 1557 // Some patterns
55a288e5 1558 const Char_t *patternrphi0 = "Nrphi0";
1559 const Char_t *patternrphi1 = "Nrphi1";
1560 const Char_t *patternrphi2 = "Nrphi2";
1561 const Char_t *patternrphi3 = "Nrphi3";
1562 const Char_t *patternrphi4 = "Nrphi4";
1563 const Char_t *patternrphi5 = "Nrphi5";
1564 const Char_t *patternrphi6 = "Nrphi6";
1565
64942b85 1566
1567 const Char_t *patternrphi10 = "Nrphi10";
1568 const Char_t *patternrphi100 = "Nrphi100";
1569 const Char_t *patternz10 = "Nz10";
1570 const Char_t *patternz100 = "Nz100";
1571
55a288e5 1572 // Nrphi mode
4c865c34 1573 if ((strstr(name.Data(),patternrphi100)) && (strstr(name.Data(),patternz100))) {
64942b85 1574 fCalibraMode->SetAllTogether(i);
1575 fNbDet = 540;
1576 if (fDebugLevel > 1) {
1577 AliInfo(Form("fNbDet %d and 100",fNbDet));
1578 }
1579 return kTRUE;
1580 }
4c865c34 1581 if ((strstr(name.Data(),patternrphi10)) && (strstr(name.Data(),patternz10))) {
64942b85 1582 fCalibraMode->SetPerSuperModule(i);
1583 fNbDet = 30;
1584 if (fDebugLevel > 1) {
1585 AliInfo(Form("fNDet %d and 100",fNbDet));
1586 }
1587 return kTRUE;
1588 }
1589
4c865c34 1590 if (strstr(name.Data(),patternrphi0)) {
55a288e5 1591 fCalibraMode->SetNrphi(i ,0);
64942b85 1592 if (fDebugLevel > 1) {
1593 AliInfo(Form("fNbDet %d and 0",fNbDet));
1594 }
3a0f6479 1595 return kTRUE;
55a288e5 1596 }
4c865c34 1597 if (strstr(name.Data(),patternrphi1)) {
55a288e5 1598 fCalibraMode->SetNrphi(i, 1);
64942b85 1599 if (fDebugLevel > 1) {
1600 AliInfo(Form("fNbDet %d and 1",fNbDet));
1601 }
3a0f6479 1602 return kTRUE;
55a288e5 1603 }
4c865c34 1604 if (strstr(name.Data(),patternrphi2)) {
55a288e5 1605 fCalibraMode->SetNrphi(i, 2);
64942b85 1606 if (fDebugLevel > 1) {
1607 AliInfo(Form("fNbDet %d and 2",fNbDet));
1608 }
3a0f6479 1609 return kTRUE;
55a288e5 1610 }
4c865c34 1611 if (strstr(name.Data(),patternrphi3)) {
55a288e5 1612 fCalibraMode->SetNrphi(i, 3);
64942b85 1613 if (fDebugLevel > 1) {
1614 AliInfo(Form("fNbDet %d and 3",fNbDet));
1615 }
3a0f6479 1616 return kTRUE;
55a288e5 1617 }
4c865c34 1618 if (strstr(name.Data(),patternrphi4)) {
55a288e5 1619 fCalibraMode->SetNrphi(i, 4);
64942b85 1620 if (fDebugLevel > 1) {
1621 AliInfo(Form("fNbDet %d and 4",fNbDet));
1622 }
3a0f6479 1623 return kTRUE;
55a288e5 1624 }
4c865c34 1625 if (strstr(name.Data(),patternrphi5)) {
55a288e5 1626 fCalibraMode->SetNrphi(i, 5);
64942b85 1627 if (fDebugLevel > 1) {
1628 AliInfo(Form("fNbDet %d and 5",fNbDet));
1629 }
3a0f6479 1630 return kTRUE;
55a288e5 1631 }
4c865c34 1632 if (strstr(name.Data(),patternrphi6)) {
55a288e5 1633 fCalibraMode->SetNrphi(i, 6);
64942b85 1634 if (fDebugLevel > 1) {
1635 AliInfo(Form("fNbDet %d and 6",fNbDet));
1636 }
55a288e5 1637 return kTRUE;
1638 }
55a288e5 1639
64942b85 1640 if (fDebugLevel > 1) {
1641 AliInfo(Form("fNbDet %d and rest",fNbDet));
1642 }
3a0f6479 1643 fCalibraMode->SetNrphi(i ,0);
1644 return kFALSE;
64942b85 1645
55a288e5 1646}
55a288e5 1647//_____________________________________________________________________________
4c865c34 1648Bool_t AliTRDCalibraFit::SetNzFromTObject(TString name, Int_t i)
55a288e5 1649{
1650 //
3a0f6479 1651 // Set fNz[i] of the AliTRDCalibraFit::Instance()
1652 // corresponding to the given TObject
55a288e5 1653 //
3a0f6479 1654
1655 // Some patterns
1656 const Char_t *patternz0 = "Nz0";
1657 const Char_t *patternz1 = "Nz1";
1658 const Char_t *patternz2 = "Nz2";
1659 const Char_t *patternz3 = "Nz3";
1660 const Char_t *patternz4 = "Nz4";
64942b85 1661
1662 const Char_t *patternrphi10 = "Nrphi10";
1663 const Char_t *patternrphi100 = "Nrphi100";
1664 const Char_t *patternz10 = "Nz10";
1665 const Char_t *patternz100 = "Nz100";
1666
4c865c34 1667 if ((strstr(name.Data(),patternrphi100)) && (strstr(name.Data(),patternz100))) {
64942b85 1668 fCalibraMode->SetAllTogether(i);
1669 fNbDet = 540;
1670 if (fDebugLevel > 1) {
1671 AliInfo(Form("fNbDet %d and 100",fNbDet));
1672 }
1673 return kTRUE;
1674 }
4c865c34 1675 if ((strstr(name.Data(),patternrphi10)) && (strstr(name.Data(),patternz10))) {
64942b85 1676 fCalibraMode->SetPerSuperModule(i);
1677 fNbDet = 30;
1678 if (fDebugLevel > 1) {
1679 AliInfo(Form("fNbDet %d and 10",fNbDet));
1680 }
1681 return kTRUE;
1682 }
4c865c34 1683 if (strstr(name.Data(),patternz0)) {
3a0f6479 1684 fCalibraMode->SetNz(i, 0);
64942b85 1685 if (fDebugLevel > 1) {
1686 AliInfo(Form("fNbDet %d and 0",fNbDet));
1687 }
3a0f6479 1688 return kTRUE;
55a288e5 1689 }
4c865c34 1690 if (strstr(name.Data(),patternz1)) {
3a0f6479 1691 fCalibraMode->SetNz(i ,1);
64942b85 1692 if (fDebugLevel > 1) {
1693 AliInfo(Form("fNbDet %d and 1",fNbDet));
1694 }
3a0f6479 1695 return kTRUE;
55a288e5 1696 }
4c865c34 1697 if (strstr(name.Data(),patternz2)) {
3a0f6479 1698 fCalibraMode->SetNz(i ,2);
64942b85 1699 if (fDebugLevel > 1) {
1700 AliInfo(Form("fNbDet %d and 2",fNbDet));
1701 }
3a0f6479 1702 return kTRUE;
55a288e5 1703 }
4c865c34 1704 if (strstr(name.Data(),patternz3)) {
3a0f6479 1705 fCalibraMode->SetNz(i ,3);
64942b85 1706 if (fDebugLevel > 1) {
1707 AliInfo(Form("fNbDet %d and 3",fNbDet));
1708 }
3a0f6479 1709 return kTRUE;
55a288e5 1710 }
4c865c34 1711 if (strstr(name.Data(),patternz4)) {
3a0f6479 1712 fCalibraMode->SetNz(i ,4);
64942b85 1713 if (fDebugLevel > 1) {
1714 AliInfo(Form("fNbDet %d and 4",fNbDet));
1715 }
3a0f6479 1716 return kTRUE;
55a288e5 1717 }
64942b85 1718
1719 if (fDebugLevel > 1) {
1720 AliInfo(Form("fNbDet %d and rest",fNbDet));
1721 }
3a0f6479 1722 fCalibraMode->SetNz(i ,0);
1723 return kFALSE;
1724}
64942b85 1725//______________________________________________________________________
6aafa7ea 1726void AliTRDCalibraFit::RemoveOutliers(Int_t type, Bool_t perdetector){
1727 //
1728 // Remove the results too far from the mean value and rms
1729 // type: 0 gain, 1 vdrift
1730 // perdetector
1731 //
1732
1733 Int_t loop = (Int_t) fVectorFit.GetEntriesFast();
1734 if(loop != 540) {
1735 AliInfo("The Vector Fit is not complete!");
1736 return;
1737 }
1738 Int_t detector = -1;
1739 Int_t sector = -1;
1740 Float_t value = 0.0;
1741
1742 /////////////////////////////////
1743 // Calculate the mean values
1744 ////////////////////////////////
1745 // Initialisation
1746 ////////////////////////
1747 Double_t meanAll = 0.0;
1748 Double_t rmsAll = 0.0;
1749 Int_t countAll = 0;
1750 ////////////
1751 // compute
1752 ////////////
1753 for (Int_t k = 0; k < loop; k++) {
1754 detector = ((AliTRDFitInfo *) fVectorFit.At(k))->GetDetector();
1755 sector = GetSector(detector);
1756 if(perdetector){
1757 value = ((AliTRDFitInfo *) fVectorFit.At(k))->GetCoef()[0];
1758 if(value > 0.0) {
1759 rmsAll += value*value;
1760 meanAll += value;
1761 countAll++;
1762 }
1763 }
1764 else {
1765 Int_t rowMax = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
1766 Int_t colMax = fGeo->GetColMax(GetLayer(detector));
1767 for (Int_t row = 0; row < rowMax; row++) {
1768 for (Int_t col = 0; col < colMax; col++) {
1769 value = ((AliTRDFitInfo *) fVectorFit.At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
1770 if(value > 0.0) {
1771 rmsAll += value*value;
1772 meanAll += value;
1773 countAll++;
1774 }
1775
1776 } // Col
1777 } // Row
1778 }
1779 }
1780 if(countAll > 0) {
1781 meanAll = meanAll/countAll;
1782 rmsAll = TMath::Sqrt(TMath::Abs(rmsAll/countAll - (meanAll*meanAll)));
1783 }
1784 //printf("RemoveOutliers: meanAll %f and rmsAll %f\n",meanAll,rmsAll);
1785 /////////////////////////////////////////////////
1786 // Remove outliers
1787 ////////////////////////////////////////////////
1788 Double_t defaultvalue = -1.0;
1789 if(type==1) defaultvalue = -1.5;
1790 for (Int_t k = 0; k < loop; k++) {
1791 detector = ((AliTRDFitInfo *) fVectorFit.At(k))->GetDetector();
1792 sector = GetSector(detector);
1793 Int_t rowMax = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
1794 Int_t colMax = fGeo->GetColMax(GetLayer(detector));
1795 Float_t *coef = ((AliTRDFitInfo *) fVectorFit.At(k))->GetCoef();
1796
1797 // remove the results too far away
1798 for (Int_t row = 0; row < rowMax; row++) {
1799 for (Int_t col = 0; col < colMax; col++) {
1800 value = coef[(Int_t)(col*rowMax+row)];
1801 if((value > 0.0) && (rmsAll > 0.0) && (TMath::Abs(value-meanAll) > (2*rmsAll))) {
1802 coef[(Int_t)(col*rowMax+row)] = defaultvalue;
1803 }
1804 } // Col
1805 } // Row
1806 }
1807}
1808//______________________________________________________________________
1809void AliTRDCalibraFit::RemoveOutliers2(Bool_t perdetector){
1810 //
1811 // Remove the results too far from the mean and rms
1812 // perdetector
1813 //
1814
1815 Int_t loop = (Int_t) fVectorFit2.GetEntriesFast();
1816 if(loop != 540) {
1817 AliInfo("The Vector Fit is not complete!");
1818 return;
1819 }
1820 Int_t detector = -1;
1821 Int_t sector = -1;
1822 Float_t value = 0.0;
1823
1824 /////////////////////////////////
1825 // Calculate the mean values
1826 ////////////////////////////////
1827 // Initialisation
1828 ////////////////////////
1829 Double_t meanAll = 0.0;
1830 Double_t rmsAll = 0.0;
1831 Int_t countAll = 0;
1832 /////////////
1833 // compute
1834 ////////////
1835 for (Int_t k = 0; k < loop; k++) {
1836 detector = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetDetector();
1837 sector = GetSector(detector);
1838 if(perdetector){
1839 value = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetCoef()[0];
1840 if(value < 70.0) {
1841 meanAll += value;
1842 rmsAll += value*value;
1843 countAll++;
1844 }
1845 }
1846 else {
1847 Int_t rowMax = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
1848 Int_t colMax = fGeo->GetColMax(GetLayer(detector));
1849 for (Int_t row = 0; row < rowMax; row++) {
1850 for (Int_t col = 0; col < colMax; col++) {
1851 value = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
1852 if(value < 70.0) {
1853 rmsAll += value*value;
1854 meanAll += value;
1855 countAll++;
1856 }
1857 } // Col
1858 } // Row
1859 }
1860 }
1861 if(countAll > 0) {
1862 meanAll = meanAll/countAll;
1863 rmsAll = TMath::Sqrt(TMath::Abs(rmsAll/countAll - (meanAll*meanAll)));
1864 }
1865 //printf("Remove outliers 2: meanAll %f, rmsAll %f\n",meanAll,rmsAll);
1866 /////////////////////////////////////////////////
1867 // Remove outliers
1868 ////////////////////////////////////////////////
1869 for (Int_t k = 0; k < loop; k++) {
1870 detector = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetDetector();
1871 sector = GetSector(detector);
1872 Int_t rowMax = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
1873 Int_t colMax = fGeo->GetColMax(GetLayer(detector));
1874 Float_t *coef = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetCoef();
1875
1876 // remove the results too far away
1877 for (Int_t row = 0; row < rowMax; row++) {
1878 for (Int_t col = 0; col < colMax; col++) {
1879 value = coef[(Int_t)(col*rowMax+row)];
b88b6bcc 1880 if((value < 70.0) && (rmsAll > 0.0) && (TMath::Abs(value-meanAll) > (2.5*rmsAll))) {
1881 //printf("value outlier %f\n",value);
1882 coef[(Int_t)(col*rowMax+row)] = 100.0;
1883 }
6aafa7ea 1884 } // Col
1885 } // Row
1886 }
1887}
1888//______________________________________________________________________
64942b85 1889void AliTRDCalibraFit::PutMeanValueOtherVectorFit(Int_t ofwhat, Bool_t perdetector){
1890 //
1891 // ofwhat is equaled to 0: mean value of all passing detectors
1892 // ofwhat is equaled to 1: mean value of the detector, otherwise supermodule, otherwise all
1893 //
1894
1895 Int_t loop = (Int_t) fVectorFit.GetEntriesFast();
1896 if(loop != 540) {
1897 AliInfo("The Vector Fit is not complete!");
1898 return;
1899 }
1900 Int_t detector = -1;
1901 Int_t sector = -1;
1902 Float_t value = 0.0;
1903
1904 /////////////////////////////////
1905 // Calculate the mean values
1906 ////////////////////////////////
1907 // Initialisation
1908 ////////////////////////
1909 Double_t meanAll = 0.0;
1910 Double_t meanSupermodule[18];
1911 Double_t meanDetector[540];
6aafa7ea 1912 Double_t rmsAll = 0.0;
1913 Double_t rmsSupermodule[18];
1914 Double_t rmsDetector[540];
64942b85 1915 Int_t countAll = 0;
1916 Int_t countSupermodule[18];
1917 Int_t countDetector[540];
1918 for(Int_t sm = 0; sm < 18; sm++){
6aafa7ea 1919 rmsSupermodule[sm] = 0.0;
64942b85 1920 meanSupermodule[sm] = 0.0;
1921 countSupermodule[sm] = 0;
1922 }
1923 for(Int_t det = 0; det < 540; det++){
6aafa7ea 1924 rmsDetector[det] = 0.0;
64942b85 1925 meanDetector[det] = 0.0;
1926 countDetector[det] = 0;
1927 }
6aafa7ea 1928 ////////////
64942b85 1929 // compute
1930 ////////////
1931 for (Int_t k = 0; k < loop; k++) {
1932 detector = ((AliTRDFitInfo *) fVectorFit.At(k))->GetDetector();
1933 sector = GetSector(detector);
1934 if(perdetector){
1935 value = ((AliTRDFitInfo *) fVectorFit.At(k))->GetCoef()[0];
1936 if(value > 0.0) {
6aafa7ea 1937 rmsDetector[detector] += value*value;
64942b85 1938 meanDetector[detector] += value;
1939 countDetector[detector]++;
6aafa7ea 1940 rmsSupermodule[sector] += value*value;
64942b85 1941 meanSupermodule[sector] += value;
1942 countSupermodule[sector]++;
6aafa7ea 1943 rmsAll += value*value;
64942b85 1944 meanAll += value;
1945 countAll++;
1946 }
1947 }
1948 else {
1949 Int_t rowMax = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
1950 Int_t colMax = fGeo->GetColMax(GetLayer(detector));
1951 for (Int_t row = 0; row < rowMax; row++) {
1952 for (Int_t col = 0; col < colMax; col++) {
1953 value = ((AliTRDFitInfo *) fVectorFit.At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
1954 if(value > 0.0) {
6aafa7ea 1955 rmsDetector[detector] += value*value;
64942b85 1956 meanDetector[detector] += value;
1957 countDetector[detector]++;
6aafa7ea 1958 rmsSupermodule[sector] += value*value;
64942b85 1959 meanSupermodule[sector] += value;
1960 countSupermodule[sector]++;
6aafa7ea 1961 rmsAll += value*value;
64942b85 1962 meanAll += value;
1963 countAll++;
1964 }
1965
1966 } // Col
1967 } // Row
1968 }
1969 }
6aafa7ea 1970 if(countAll > 0) {
1971 meanAll = meanAll/countAll;
1972 rmsAll = TMath::Abs(rmsAll/countAll - (meanAll*meanAll));
1973 }
64942b85 1974 for(Int_t sm = 0; sm < 18; sm++){
6aafa7ea 1975 if(countSupermodule[sm] > 0) {
1976 meanSupermodule[sm] = meanSupermodule[sm]/countSupermodule[sm];
1977 rmsSupermodule[sm] = TMath::Abs(rmsSupermodule[sm]/countSupermodule[sm] - (meanSupermodule[sm]*meanSupermodule[sm]));
1978 }
64942b85 1979 }
1980 for(Int_t det = 0; det < 540; det++){
6aafa7ea 1981 if(countDetector[det] > 0) {
1982 meanDetector[det] = meanDetector[det]/countDetector[det];
1983 rmsDetector[det] = TMath::Abs(rmsDetector[det]/countDetector[det] - (meanDetector[det]*meanDetector[det]));
1984 }
64942b85 1985 }
6aafa7ea 1986 //printf("Put mean value, meanAll %f, rmsAll %f\n",meanAll,rmsAll);
1987 ///////////////////////////////////////////////
64942b85 1988 // Put the mean value for the no-fitted
1989 /////////////////////////////////////////////
1990 for (Int_t k = 0; k < loop; k++) {
1991 detector = ((AliTRDFitInfo *) fVectorFit.At(k))->GetDetector();
1992 sector = GetSector(detector);
1993 Int_t rowMax = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
1994 Int_t colMax = fGeo->GetColMax(GetLayer(detector));
1995 Float_t *coef = ((AliTRDFitInfo *) fVectorFit.At(k))->GetCoef();
1996
1997 for (Int_t row = 0; row < rowMax; row++) {
1998 for (Int_t col = 0; col < colMax; col++) {
1999 value = coef[(Int_t)(col*rowMax+row)];
2000 if(value < 0.0) {
6aafa7ea 2001 if((ofwhat == 0) && (meanAll > 0.0) && (countAll > 15)) coef[(Int_t)(col*rowMax+row)] = -TMath::Abs(meanAll);
64942b85 2002 if(ofwhat == 1){
6aafa7ea 2003 if((meanDetector[detector] > 0.0) && (countDetector[detector] > 20)) coef[(Int_t)(col*rowMax+row)] = -TMath::Abs(meanDetector[detector]);
2004 else if((meanSupermodule[sector] > 0.0) && (countSupermodule[sector] > 15)) coef[(Int_t)(col*rowMax+row)] = -TMath::Abs(meanSupermodule[sector]);
2005 else if((meanAll > 0.0) && (countAll > 15)) coef[(Int_t)(col*rowMax+row)] = -TMath::Abs(meanAll);
64942b85 2006 }
2007 }
2008 // Debug
2009 if(fDebugLevel > 1){
2010
2011 if ( !fDebugStreamer ) {
2012 //debug stream
2013 TDirectory *backup = gDirectory;
2014 fDebugStreamer = new TTreeSRedirector("TRDDebugFit.root");
2015 if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
2016 }
2017
2018 Float_t coefnow = coef[(Int_t)(col*rowMax+row)];
2019
2020 (* fDebugStreamer) << "PutMeanValueOtherVectorFit"<<
2021 "detector="<<detector<<
2022 "sector="<<sector<<
2023 "row="<<row<<
2024 "col="<<col<<
2025 "before="<<value<<
2026 "after="<<coefnow<<
2027 "\n";
2028 }
2029 } // Col
2030 } // Row
2031 }
64942b85 2032}
2033//______________________________________________________________________
2034void AliTRDCalibraFit::PutMeanValueOtherVectorFit2(Int_t ofwhat, Bool_t perdetector){
2035 //
2036 // ofwhat is equaled to 0: mean value of all passing detectors
2037 // ofwhat is equaled to 1: mean value of the detector, otherwise supermodule, otherwise all
2038 //
2039
2040 Int_t loop = (Int_t) fVectorFit2.GetEntriesFast();
2041 if(loop != 540) {
2042 AliInfo("The Vector Fit is not complete!");
2043 return;
2044 }
2045 Int_t detector = -1;
2046 Int_t sector = -1;
2047 Float_t value = 0.0;
2048
2049 /////////////////////////////////
2050 // Calculate the mean values
2051 ////////////////////////////////
2052 // Initialisation
2053 ////////////////////////
2054 Double_t meanAll = 0.0;
6aafa7ea 2055 Double_t rmsAll = 0.0;
64942b85 2056 Double_t meanSupermodule[18];
6aafa7ea 2057 Double_t rmsSupermodule[18];
64942b85 2058 Double_t meanDetector[540];
6aafa7ea 2059 Double_t rmsDetector[540];
64942b85 2060 Int_t countAll = 0;
2061 Int_t countSupermodule[18];
2062 Int_t countDetector[540];
2063 for(Int_t sm = 0; sm < 18; sm++){
6aafa7ea 2064 rmsSupermodule[sm] = 0.0;
64942b85 2065 meanSupermodule[sm] = 0.0;
2066 countSupermodule[sm] = 0;
2067 }
2068 for(Int_t det = 0; det < 540; det++){
6aafa7ea 2069 rmsDetector[det] = 0.0;
64942b85 2070 meanDetector[det] = 0.0;
2071 countDetector[det] = 0;
2072 }
2073 // compute
2074 ////////////
2075 for (Int_t k = 0; k < loop; k++) {
2076 detector = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetDetector();
2077 sector = GetSector(detector);
2078 if(perdetector){
2079 value = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetCoef()[0];
2080 if(value < 70.0) {
6aafa7ea 2081 rmsDetector[detector] += value*value;
64942b85 2082 meanDetector[detector] += value;
2083 countDetector[detector]++;
6aafa7ea 2084 rmsSupermodule[sector] += value*value;
64942b85 2085 meanSupermodule[sector] += value;
2086 countSupermodule[sector]++;
2087 meanAll += value;
6aafa7ea 2088 rmsAll += value*value;
64942b85 2089 countAll++;
2090 }
2091 }
2092 else {
2093 Int_t rowMax = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
2094 Int_t colMax = fGeo->GetColMax(GetLayer(detector));
2095 for (Int_t row = 0; row < rowMax; row++) {
2096 for (Int_t col = 0; col < colMax; col++) {
2097 value = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
2098 if(value < 70.0) {
6aafa7ea 2099 rmsDetector[detector] += value*value;
64942b85 2100 meanDetector[detector] += value;
2101 countDetector[detector]++;
6aafa7ea 2102 rmsSupermodule[sector] += value*value;
64942b85 2103 meanSupermodule[sector] += value;
2104 countSupermodule[sector]++;
6aafa7ea 2105 rmsAll += value*value;
64942b85 2106 meanAll += value;
2107 countAll++;
2108 }
2109
2110 } // Col
2111 } // Row
2112 }
2113 }
6aafa7ea 2114 if(countAll > 0) {
2115 meanAll = meanAll/countAll;
2116 rmsAll = TMath::Abs(rmsAll/countAll - (meanAll*meanAll));
2117 }
64942b85 2118 for(Int_t sm = 0; sm < 18; sm++){
6aafa7ea 2119 if(countSupermodule[sm] > 0) {
2120 meanSupermodule[sm] = meanSupermodule[sm]/countSupermodule[sm];
2121 rmsSupermodule[sm] = TMath::Abs(rmsSupermodule[sm]/countSupermodule[sm] - (meanSupermodule[sm]*meanSupermodule[sm]));
2122 }
64942b85 2123 }
2124 for(Int_t det = 0; det < 540; det++){
6aafa7ea 2125 if(countDetector[det] > 0) {
2126 meanDetector[det] = meanDetector[det]/countDetector[det];
2127 rmsDetector[det] = TMath::Abs(rmsDetector[det]/countDetector[det] - (meanDetector[det]*meanDetector[det]));
2128 }
64942b85 2129 }
6aafa7ea 2130 //printf("Put mean value 2: meanAll %f, rmsAll %f\n",meanAll,rmsAll);
2131 ////////////////////////////////////////////
64942b85 2132 // Put the mean value for the no-fitted
2133 /////////////////////////////////////////////
2134 for (Int_t k = 0; k < loop; k++) {
2135 detector = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetDetector();
2136 sector = GetSector(detector);
2137 Int_t rowMax = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
2138 Int_t colMax = fGeo->GetColMax(GetLayer(detector));
2139 Float_t *coef = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetCoef();
2140
2141 for (Int_t row = 0; row < rowMax; row++) {
2142 for (Int_t col = 0; col < colMax; col++) {
2143 value = coef[(Int_t)(col*rowMax+row)];
2144 if(value > 70.0) {
840ec79d 2145 if((ofwhat == 0) && (meanAll > -3.0) && (countAll > 15)) coef[(Int_t)(col*rowMax+row)] = meanAll+100.0;
64942b85 2146 if(ofwhat == 1){
840ec79d 2147 if((meanDetector[detector] > -3.0) && (countDetector[detector] > 20)) coef[(Int_t)(col*rowMax+row)] = meanDetector[detector]+100.0;
2148 else if((meanSupermodule[sector] > -3.0) && (countSupermodule[sector] > 15)) coef[(Int_t)(col*rowMax+row)] = meanSupermodule[sector]+100.0;
2149 else if((meanAll > -3.0) && (countAll > 15)) coef[(Int_t)(col*rowMax+row)] = meanAll+100.0;
64942b85 2150 }
2151 }
2152 // Debug
2153 if(fDebugLevel > 1){
2154
2155 if ( !fDebugStreamer ) {
2156 //debug stream
2157 TDirectory *backup = gDirectory;
2158 fDebugStreamer = new TTreeSRedirector("TRDDebugFit.root");
2159 if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
2160 }
2161
2162 Float_t coefnow = coef[(Int_t)(col*rowMax+row)];
2163
2164 (* fDebugStreamer) << "PutMeanValueOtherVectorFit2"<<
2165 "detector="<<detector<<
2166 "sector="<<sector<<
2167 "row="<<row<<
2168 "col="<<col<<
2169 "before="<<value<<
2170 "after="<<coefnow<<
2171 "\n";
2172 }
2173 } // Col
2174 } // Row
2175 }
2176
2177}
3a0f6479 2178//_____________________________________________________________________________
979b168f 2179AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectVdrift(const TObjArray *vectorFit, Bool_t perdetector)
3a0f6479 2180{
2181 //
2182 // It creates the AliTRDCalDet object from the AliTRDFitInfo
2183 // It takes the mean value of the coefficients per detector
2184 // This object has to be written in the database
2185 //
55a288e5 2186
3a0f6479 2187 // Create the DetObject
2188 AliTRDCalDet *object = new AliTRDCalDet("ChamberVdrift","TRD drift velocities (detector value)");
2189
2190 Int_t loop = (Int_t) vectorFit->GetEntriesFast();
2191 if(loop != 540) AliInfo("The Vector Fit is not complete!");
2192 Int_t detector = -1;
2193 Float_t value = 0.0;
64942b85 2194
2195 //
3a0f6479 2196 for (Int_t k = 0; k < loop; k++) {
2197 detector = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
2198 Float_t mean = 0.0;
2199 if(perdetector){
2200 mean = TMath::Abs(((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[0]);
55a288e5 2201 }
2202 else {
3a0f6479 2203 Int_t count = 0;
053767a4 2204 Int_t rowMax = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
2205 Int_t colMax = fGeo->GetColMax(GetLayer(detector));
3a0f6479 2206 for (Int_t row = 0; row < rowMax; row++) {
2207 for (Int_t col = 0; col < colMax; col++) {
2208 value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
2209 mean += TMath::Abs(value);
2210 count++;
2211 } // Col
2212 } // Row
2213 if(count > 0) mean = mean/count;
55a288e5 2214 }
2215 object->SetValue(detector,mean);
2216 }
3a0f6479 2217
55a288e5 2218 return object;
55a288e5 2219}
55a288e5 2220//_____________________________________________________________________________
979b168f 2221AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectGain(const TObjArray *vectorFit, Bool_t meanOtherBefore, Double_t scaleFitFactor, Bool_t perdetector)
55a288e5 2222{
2223 //
3a0f6479 2224 // It creates the AliTRDCalDet object from the AliTRDFitInfo
2225 // It takes the mean value of the coefficients per detector
55a288e5 2226 // This object has to be written in the database
2227 //
2228
2229 // Create the DetObject
3a0f6479 2230 AliTRDCalDet *object = new AliTRDCalDet("ChamberGainFactor","GainFactor (detector value)");
55a288e5 2231
54f2ff1c 2232 fScaleGain = scaleFitFactor;
3a0f6479 2233
2234 Int_t loop = (Int_t) vectorFit->GetEntriesFast();
2235 if(loop != 540) AliInfo("The Vector Fit is not complete!");
2236 Int_t detector = -1;
2237 Float_t value = 0.0;
2238
2239 for (Int_t k = 0; k < loop; k++) {
2240 detector = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
2241 Float_t mean = 0.0;
2242 if(perdetector){
2243 value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[0];
64942b85 2244 if(!meanOtherBefore){
2245 if(value > 0) value = value*scaleFitFactor;
2246 }
2247 else value = value*scaleFitFactor;
3a0f6479 2248 mean = TMath::Abs(value);
2249 }
2250 else{
2251 Int_t count = 0;
053767a4 2252 Int_t rowMax = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
2253 Int_t colMax = fGeo->GetColMax(GetLayer(detector));
3a0f6479 2254 for (Int_t row = 0; row < rowMax; row++) {
2255 for (Int_t col = 0; col < colMax; col++) {
2256 value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
64942b85 2257 if(!meanOtherBefore) {
2258 if(value > 0) value = value*scaleFitFactor;
2259 }
2260 else value = value*scaleFitFactor;
3a0f6479 2261 mean += TMath::Abs(value);
2262 count++;
2263 } // Col
2264 } // Row
2265 if(count > 0) mean = mean/count;
2266 }
ba1aa7a7 2267 if(mean < 0.1) mean = 0.1;
3a0f6479 2268 object->SetValue(detector,mean);
55a288e5 2269 }
3a0f6479 2270
2271 return object;
2272}
2273//_____________________________________________________________________________
979b168f 2274AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectT0(const TObjArray *vectorFit, Bool_t perdetector)
3a0f6479 2275{
2276 //
2277 // It creates the AliTRDCalDet object from the AliTRDFitInfo2
2278 // It takes the min value of the coefficients per detector
2279 // This object has to be written in the database
2280 //
55a288e5 2281
3a0f6479 2282 // Create the DetObject
2283 AliTRDCalDet *object = new AliTRDCalDet("ChamberT0","T0 (detector value)");
55a288e5 2284
3a0f6479 2285 Int_t loop = (Int_t) vectorFit->GetEntriesFast();
2286 if(loop != 540) AliInfo("The Vector Fit is not complete!");
2287 Int_t detector = -1;
2288 Float_t value = 0.0;
2289
2290 for (Int_t k = 0; k < loop; k++) {
2291 detector = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
2292 Float_t min = 100.0;
2293 if(perdetector){
64942b85 2294 value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[0];
b88b6bcc 2295 //printf("Create det object %f for %d\n",value,k);
64942b85 2296 // check successful
2297 if(value > 70.0) value = value-100.0;
2298 //
2299 min = value;
55a288e5 2300 }
3a0f6479 2301 else{
053767a4 2302 Int_t rowMax = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
2303 Int_t colMax = fGeo->GetColMax(GetLayer(detector));
3a0f6479 2304 for (Int_t row = 0; row < rowMax; row++) {
2305 for (Int_t col = 0; col < colMax; col++) {
2306 value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
64942b85 2307 // check successful
2308 if(value > 70.0) value = value-100.0;
2309 //
3a0f6479 2310 if(min > value) min = value;
2311 } // Col
2312 } // Row
2313 }
2314 object->SetValue(detector,min);
55a288e5 2315 }
2316
2317 return object;
2318
2319}
55a288e5 2320//_____________________________________________________________________________
979b168f 2321AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectLorentzAngle(const TObjArray *vectorFit)
55a288e5 2322{
2323 //
3a0f6479 2324 // It creates the AliTRDCalDet object from the AliTRDFitInfo2
2325 // It takes the min value of the coefficients per detector
55a288e5 2326 // This object has to be written in the database
2327 //
2328
2329 // Create the DetObject
3a0f6479 2330 AliTRDCalDet *object = new AliTRDCalDet("tan(lorentzangle)","tan(lorentzangle) (detector value)");
2331
2332
2333 Int_t loop = (Int_t) vectorFit->GetEntriesFast();
2334 if(loop != 540) AliInfo("The Vector Fit is not complete!");
2335 Int_t detector = -1;
2336 Float_t value = 0.0;
55a288e5 2337
3a0f6479 2338 for (Int_t k = 0; k < loop; k++) {
2339 detector = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
2340 /*
053767a4 2341 Int_t rowMax = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
2342 Int_t colMax = fGeo->GetColMax(GetLayer(detector));
3a0f6479 2343 Float_t min = 100.0;
2344 for (Int_t row = 0; row < rowMax; row++) {
2345 for (Int_t col = 0; col < colMax; col++) {
2346 value = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
2347 mean += -TMath::Abs(value);
2348 count++;
55a288e5 2349 } // Col
3a0f6479 2350 } // Row
2351 if(count > 0) mean = mean/count;
2352 */
2353 value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[0];
840ec79d 2354 if(value > 70.0) value = value-100.0;
2355 object->SetValue(detector,value);
55a288e5 2356 }
2357
2358 return object;
3a0f6479 2359
a0bb5615 2360}
2361//_____________________________________________________________________________
2362AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectExbAlt(const TObjArray *vectorFit)
2363{
2364 //
2365 // It creates the AliTRDCalDet object from the AliTRDFitInfo2
2366 // It takes the min value of the coefficients per detector
2367 // This object has to be written in the database
2368 //
2369
2370 // Create the DetObject
2371 AliTRDCalDet *object = new AliTRDCalDet("tan(lorentzangle)","tan(lorentzangle) (detector value)");
2372
2373
2374 Int_t loop = (Int_t) vectorFit->GetEntriesFast();
2375 if(loop != 540) AliInfo("The Vector Fit is not complete!");
2376 Int_t detector = -1;
2377 Float_t value = 0.0;
2378
2379 for (Int_t k = 0; k < loop; k++) {
2380 detector = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
2381 /*
2382 Int_t rowMax = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
2383 Int_t colMax = fGeo->GetColMax(GetLayer(detector));
2384 Float_t min = 100.0;
2385 for (Int_t row = 0; row < rowMax; row++) {
2386 for (Int_t col = 0; col < colMax; col++) {
2387 value = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
2388 mean += -TMath::Abs(value);
2389 count++;
2390 } // Col
2391 } // Row
2392 if(count > 0) mean = mean/count;
2393 */
2394 value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[0];
2395 //if(value > 70.0) value = value-100.0;
2396 object->SetValue(detector,value);
2397 }
2398
2399 return object;
2400
55a288e5 2401}
55a288e5 2402//_____________________________________________________________________________
979b168f 2403TObject *AliTRDCalibraFit::CreatePadObjectGain(const TObjArray *vectorFit, Double_t scaleFitFactor, const AliTRDCalDet *detobject)
3a0f6479 2404{
55a288e5 2405 //
3a0f6479 2406 // It Creates the AliTRDCalPad object from AliTRDFitInfo
2407 // You need first to create the object for the detectors,
2408 // where the mean value is put.
2409 // This object has to be written in the database
55a288e5 2410 //
3a0f6479 2411
2412 // Create the DetObject
2413 AliTRDCalPad *object = new AliTRDCalPad("GainFactor","GainFactor (local variations)");
2414
2415 if(!vectorFit){
2416 for(Int_t k = 0; k < 540; k++){
2417 AliTRDCalROC *calROC = object->GetCalROC(k);
2418 Int_t nchannels = calROC->GetNchannels();
2419 for(Int_t ch = 0; ch < nchannels; ch++){
2420 calROC->SetValue(ch,1.0);
2421 }
2422 }
55a288e5 2423 }
3a0f6479 2424 else{
2425
2426 Int_t loop = (Int_t) vectorFit->GetEntriesFast();
2427 if(loop != 540) AliInfo("The Vector Fit is not complete!");
2428 Int_t detector = -1;
2429 Float_t value = 0.0;
2430
2431 for (Int_t k = 0; k < loop; k++) {
2432 detector = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
2433 AliTRDCalROC *calROC = object->GetCalROC(detector);
2434 Float_t mean = detobject->GetValue(detector);
daa7dc79 2435 if(TMath::Abs(mean) <= 0.0000000001) continue;
3a0f6479 2436 Int_t rowMax = calROC->GetNrows();
2437 Int_t colMax = calROC->GetNcols();
2438 for (Int_t row = 0; row < rowMax; row++) {
2439 for (Int_t col = 0; col < colMax; col++) {
2440 value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
2441 if(value > 0) value = value*scaleFitFactor;
2442 calROC->SetValue(col,row,TMath::Abs(value)/mean);
2443 } // Col
2444 } // Row
2445 }
55a288e5 2446 }
2447
3a0f6479 2448 return object;
55a288e5 2449}
55a288e5 2450//_____________________________________________________________________________
979b168f 2451TObject *AliTRDCalibraFit::CreatePadObjectVdrift(const TObjArray *vectorFit, const AliTRDCalDet *detobject)
3a0f6479 2452{
55a288e5 2453 //
3a0f6479 2454 // It Creates the AliTRDCalPad object from AliTRDFitInfo
2455 // You need first to create the object for the detectors,
2456 // where the mean value is put.
2457 // This object has to be written in the database
55a288e5 2458 //
2459
3a0f6479 2460 // Create the DetObject
2461 AliTRDCalPad *object = new AliTRDCalPad("LocalVdrift","TRD drift velocities (local variations)");
2462
2463 if(!vectorFit){
2464 for(Int_t k = 0; k < 540; k++){
2465 AliTRDCalROC *calROC = object->GetCalROC(k);
2466 Int_t nchannels = calROC->GetNchannels();
2467 for(Int_t ch = 0; ch < nchannels; ch++){
2468 calROC->SetValue(ch,1.0);
2469 }
2470 }
55a288e5 2471 }
2472 else {
3a0f6479 2473
2474 Int_t loop = (Int_t) vectorFit->GetEntriesFast();
2475 if(loop != 540) AliInfo("The Vector Fit is not complete!");
2476 Int_t detector = -1;
2477 Float_t value = 0.0;
2478
2479 for (Int_t k = 0; k < loop; k++) {
2480 detector = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
2481 AliTRDCalROC *calROC = object->GetCalROC(detector);
2482 Float_t mean = detobject->GetValue(detector);
2483 if(mean == 0) continue;
2484 Int_t rowMax = calROC->GetNrows();
2485 Int_t colMax = calROC->GetNcols();
2486 for (Int_t row = 0; row < rowMax; row++) {
2487 for (Int_t col = 0; col < colMax; col++) {
2488 value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
2489 calROC->SetValue(col,row,TMath::Abs(value)/mean);
2490 } // Col
2491 } // Row
2492 }
55a288e5 2493 }
3a0f6479 2494 return object;
55a288e5 2495
2496}
55a288e5 2497//_____________________________________________________________________________
979b168f 2498TObject *AliTRDCalibraFit::CreatePadObjectT0(const TObjArray *vectorFit, const AliTRDCalDet *detobject)
3a0f6479 2499{
55a288e5 2500 //
3a0f6479 2501 // It Creates the AliTRDCalPad object from AliTRDFitInfo2
2502 // You need first to create the object for the detectors,
2503 // where the mean value is put.
2504 // This object has to be written in the database
55a288e5 2505 //
3a0f6479 2506
2507 // Create the DetObject
2508 AliTRDCalPad *object = new AliTRDCalPad("LocalT0","T0 (local variations)");
2509
2510 if(!vectorFit){
2511 for(Int_t k = 0; k < 540; k++){
2512 AliTRDCalROC *calROC = object->GetCalROC(k);
2513 Int_t nchannels = calROC->GetNchannels();
2514 for(Int_t ch = 0; ch < nchannels; ch++){
2515 calROC->SetValue(ch,0.0);
2516 }
2517 }
55a288e5 2518 }
2519 else {
3a0f6479 2520
2521 Int_t loop = (Int_t) vectorFit->GetEntriesFast();
2522 if(loop != 540) AliInfo("The Vector Fit is not complete!");
2523 Int_t detector = -1;
2524 Float_t value = 0.0;
2525
2526 for (Int_t k = 0; k < loop; k++) {
2527 detector = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
2528 AliTRDCalROC *calROC = object->GetCalROC(detector);
2529 Float_t min = detobject->GetValue(detector);
2530 Int_t rowMax = calROC->GetNrows();
2531 Int_t colMax = calROC->GetNcols();
2532 for (Int_t row = 0; row < rowMax; row++) {
2533 for (Int_t col = 0; col < colMax; col++) {
2534 value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
64942b85 2535 // check successful
2536 if(value > 70.0) value = value - 100.0;
2537 //
3a0f6479 2538 calROC->SetValue(col,row,value-min);
2539 } // Col
2540 } // Row
2541 }
55a288e5 2542 }
3a0f6479 2543 return object;
55a288e5 2544
2545}
3a0f6479 2546//_____________________________________________________________________________
979b168f 2547TObject *AliTRDCalibraFit::CreatePadObjectPRF(const TObjArray *vectorFit)
3a0f6479 2548{
2549 //
2550 // It Creates the AliTRDCalPad object from AliTRDFitInfo
2551 // This object has to be written in the database
2552 //
2553
2554 // Create the DetObject
2555 AliTRDCalPad *object = new AliTRDCalPad("PRFWidth","PRFWidth");
2556
2557 Int_t loop = (Int_t) vectorFit->GetEntriesFast();
2558 if(loop != 540) AliInfo("The Vector Fit is not complete!");
2559 Int_t detector = -1;
2560 Float_t value = 0.0;
55a288e5 2561
3a0f6479 2562 for (Int_t k = 0; k < loop; k++) {
2563 detector = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
2564 AliTRDCalROC *calROC = object->GetCalROC(detector);
2565 Int_t rowMax = calROC->GetNrows();
2566 Int_t colMax = calROC->GetNcols();
2567 for (Int_t row = 0; row < rowMax; row++) {
2568 for (Int_t col = 0; col < colMax; col++) {
2569 value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
2570 calROC->SetValue(col,row,TMath::Abs(value));
2571 } // Col
2572 } // Row
2573 }
2574
2575 return object;
2576
2577}
55a288e5 2578//_____________________________________________________________________________
979b168f 2579AliTRDCalDet *AliTRDCalibraFit::MakeOutliersStatDet(const TObjArray *vectorFit, const char *name, Double_t &mean)
3a0f6479 2580{
2581 //
2582 // It Creates the AliTRDCalDet object from AliTRDFitInfo
2583 // 0 successful fit 1 not successful fit
2584 // mean is the mean value over the successful fit
2585 // do not use it for t0: no meaning
2586 //
2587
2588 // Create the CalObject
2589 AliTRDCalDet *object = new AliTRDCalDet(name,name);
2590 mean = 0.0;
2591 Int_t count = 0;
2592
2593 Int_t loop = (Int_t) vectorFit->GetEntriesFast();
2594 if(loop != 540) {
2595 AliInfo("The Vector Fit is not complete! We initialise all outliers");
2596 for(Int_t k = 0; k < 540; k++){
2597 object->SetValue(k,1.0);
2598 }
2599 }
2600 Int_t detector = -1;
2601 Float_t value = 0.0;
2602
2603 for (Int_t k = 0; k < loop; k++) {
2604 detector = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
2605 value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[0];
2606 if(value <= 0) object->SetValue(detector,1.0);
2607 else {
2608 object->SetValue(detector,0.0);
2609 mean += value;
2610 count++;
2611 }
2612 }
2613 if(count > 0) mean /= count;
2614 return object;
2615}
2616//_____________________________________________________________________________
979b168f 2617TObject *AliTRDCalibraFit::MakeOutliersStatPad(const TObjArray *vectorFit, const char *name, Double_t &mean)
3a0f6479 2618{
2619 //
2620 // It Creates the AliTRDCalPad object from AliTRDFitInfo
2621 // 0 not successful fit 1 successful fit
2622 // mean mean value over the successful fit
2623 //
2624
2625 // Create the CalObject
2626 AliTRDCalPad *object = new AliTRDCalPad(name,name);
2627 mean = 0.0;
2628 Int_t count = 0;
2629
2630 Int_t loop = (Int_t) vectorFit->GetEntriesFast();
2631 if(loop != 540) {
2632 AliInfo("The Vector Fit is not complete! We initialise all outliers");
2633 for(Int_t k = 0; k < 540; k++){
2634 AliTRDCalROC *calROC = object->GetCalROC(k);
2635 Int_t nchannels = calROC->GetNchannels();
2636 for(Int_t ch = 0; ch < nchannels; ch++){
2637 calROC->SetValue(ch,1.0);
2638 }
2639 }
2640 }
2641 Int_t detector = -1;
2642 Float_t value = 0.0;
2643
2644 for (Int_t k = 0; k < loop; k++) {
2645 detector = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
2646 AliTRDCalROC *calROC = object->GetCalROC(detector);
2647 Int_t nchannels = calROC->GetNchannels();
2648 for (Int_t ch = 0; ch < nchannels; ch++) {
2649 value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[ch];
2650 if(value <= 0) calROC->SetValue(ch,1.0);
2651 else {
2652 calROC->SetValue(ch,0.0);
2653 mean += value;
2654 count++;
2655 }
2656 } // channels
2657 }
2658 if(count > 0) mean /= count;
2659 return object;
2660}
2661//_____________________________________________________________________________
2662void AliTRDCalibraFit::SetPeriodeFitPH(Int_t periodeFitPH)
55a288e5 2663{
2664 //
3a0f6479 2665 // Set FitPH if 1 then each detector will be fitted
55a288e5 2666 //
2667
3a0f6479 2668 if (periodeFitPH > 0) {
2669 fFitPHPeriode = periodeFitPH;
55a288e5 2670 }
2671 else {
3a0f6479 2672 AliInfo("periodeFitPH must be higher than 0!");
55a288e5 2673 }
2674
2675}
55a288e5 2676//_____________________________________________________________________________
2677void AliTRDCalibraFit::SetBeginFitCharge(Float_t beginFitCharge)
2678{
2679 //
2680 // The fit of the deposited charge distribution begins at
2681 // histo->Mean()/beginFitCharge
2682 // You can here set beginFitCharge
2683 //
2684
2685 if (beginFitCharge > 0) {
2686 fBeginFitCharge = beginFitCharge;
2687 }
2688 else {
2689 AliInfo("beginFitCharge must be strict positif!");
2690 }
2691
2692}
2693
2694//_____________________________________________________________________________
413153cb 2695void AliTRDCalibraFit::SetT0Shift0(Float_t t0Shift)
2696{
2697 //
2698 // The t0 calculated with the maximum positif slope is shift from t0Shift0
2699 // You can here set t0Shift0
2700 //
2701
2702 if (t0Shift > 0) {
2703 fT0Shift0 = t0Shift;
2704 }
2705 else {
2706 AliInfo("t0Shift0 must be strict positif!");
2707 }
2708
2709}
2710
2711//_____________________________________________________________________________
2712void AliTRDCalibraFit::SetT0Shift1(Float_t t0Shift)
55a288e5 2713{
2714 //
413153cb 2715 // The t0 calculated with the maximum of the amplification region is shift from t0Shift1
2716 // You can here set t0Shift1
55a288e5 2717 //
2718
2719 if (t0Shift > 0) {
413153cb 2720 fT0Shift1 = t0Shift;
55a288e5 2721 }
2722 else {
2723 AliInfo("t0Shift must be strict positif!");
2724 }
2725
2726}
2727
2728//_____________________________________________________________________________
2729void AliTRDCalibraFit::SetRangeFitPRF(Float_t rangeFitPRF)
2730{
2731 //
2732 // The fit of the PRF is from -rangeFitPRF to rangeFitPRF
2733 // You can here set rangeFitPRF
2734 //
2735
2736 if ((rangeFitPRF > 0) &&
2737 (rangeFitPRF <= 1.5)) {
2738 fRangeFitPRF = rangeFitPRF;
2739 }
2740 else {
2741 AliInfo("rangeFitPRF must be between 0 and 1.0");
2742 }
2743
2744}
2745
3a0f6479 2746//_____________________________________________________________________________
2747void AliTRDCalibraFit::SetMinEntries(Int_t minEntries)
2748{
2749 //
2750 // Minimum entries for fitting
2751 //
2752
2753 if (minEntries > 0) {
2754 fMinEntries = minEntries;
2755 }
2756 else {
2757 AliInfo("fMinEntries must be >= 0.");
2758 }
2759
2760}
2761
55a288e5 2762//_____________________________________________________________________________
2763void AliTRDCalibraFit::SetRebin(Short_t rebin)
2764{
2765 //
2766 // Rebin with rebin time less bins the Ch histo
2767 // You can set here rebin that should divide the number of bins of CH histo
2768 //
2769
2770 if (rebin > 0) {
2771 fRebin = rebin;
2772 AliInfo("You have to be sure that fRebin divides fNumberBinCharge used!");
2773 }
2774 else {
2775 AliInfo("You have to choose a positiv value!");
2776 }
2777
2778}
55a288e5 2779//_____________________________________________________________________________
3a0f6479 2780Bool_t AliTRDCalibraFit::FillVectorFit()
55a288e5 2781{
2782 //
3a0f6479 2783 // For the Fit functions fill the vector Fit
55a288e5 2784 //
55a288e5 2785
3a0f6479 2786 AliTRDFitInfo *fitInfo = new AliTRDFitInfo();
55a288e5 2787
3a0f6479 2788 Int_t ntotal = 1;
053767a4 2789 if (GetStack(fCountDet) == 2) {
3a0f6479 2790 ntotal = 1728;
55a288e5 2791 }
3a0f6479 2792 else {
2793 ntotal = 2304;
55a288e5 2794 }
3a0f6479 2795
2796 //printf("For the detector %d , ntotal %d and fCoefCH[0] %f\n",countdet,ntotal,fCoefCH[0]);
2797 Float_t *coef = new Float_t[ntotal];
2798 for (Int_t i = 0; i < ntotal; i++) {
2799 coef[i] = fCurrentCoefDetector[i];
55a288e5 2800 }
3a0f6479 2801
2802 Int_t detector = fCountDet;
2803 // Set
2804 fitInfo->SetCoef(coef);
2805 fitInfo->SetDetector(detector);
2806 fVectorFit.Add((TObject *) fitInfo);
2807
2808 return kTRUE;
55a288e5 2809
3a0f6479 2810}
55a288e5 2811//_____________________________________________________________________________
3a0f6479 2812Bool_t AliTRDCalibraFit::FillVectorFit2()
55a288e5 2813{
2814 //
3a0f6479 2815 // For the Fit functions fill the vector Fit
55a288e5 2816 //
55a288e5 2817
3a0f6479 2818 AliTRDFitInfo *fitInfo = new AliTRDFitInfo();
55a288e5 2819
3a0f6479 2820 Int_t ntotal = 1;
053767a4 2821 if (GetStack(fCountDet) == 2) {
3a0f6479 2822 ntotal = 1728;
55a288e5 2823 }
3a0f6479 2824 else {
2825 ntotal = 2304;
55a288e5 2826 }
3a0f6479 2827
2828 //printf("For the detector %d , ntotal %d and fCoefCH[0] %f\n",countdet,ntotal,fCoefCH[0]);
2829 Float_t *coef = new Float_t[ntotal];
2830 for (Int_t i = 0; i < ntotal; i++) {
2831 coef[i] = fCurrentCoefDetector2[i];
55a288e5 2832 }
3a0f6479 2833
2834 Int_t detector = fCountDet;
2835 // Set
2836 fitInfo->SetCoef(coef);
2837 fitInfo->SetDetector(detector);
2838 fVectorFit2.Add((TObject *) fitInfo);
55a288e5 2839
3a0f6479 2840 return kTRUE;
55a288e5 2841
3a0f6479 2842}
2843//____________Functions for initialising the AliTRDCalibraFit in the code_________
2844Bool_t AliTRDCalibraFit::InitFit(Int_t nbins, Int_t i)
55a288e5 2845{
2846 //
3a0f6479 2847 // Init the number of expected bins and fDect1[i] fDect2[i]
55a288e5 2848 //
2849
3a0f6479 2850 gStyle->SetPalette(1);
2851 gStyle->SetOptStat(1111);
2852 gStyle->SetPadBorderMode(0);
2853 gStyle->SetCanvasColor(10);
2854 gStyle->SetPadLeftMargin(0.13);
2855 gStyle->SetPadRightMargin(0.01);
2856
2857 // Mode groups of pads: the total number of bins!
2858 CalculNumberOfBinsExpected(i);
2859
2860 // Quick verification that we have the good pad calibration mode!
2861 if (fNumberOfBinsExpected != nbins) {
64942b85 2862 AliInfo(Form("It doesn't correspond to the mode of pad group calibration: expected %d and seen %d!",fNumberOfBinsExpected,nbins));
3a0f6479 2863 return kFALSE;
55a288e5 2864 }
3a0f6479 2865
2866 // Security for fDebug 3 and 4
2867 if ((fDebugLevel >= 3) &&
2868 ((fDet[0] > 5) ||
2869 (fDet[1] > 4) ||
2870 (fDet[2] > 17))) {
2871 AliInfo("This detector doesn't exit!");
2872 return kFALSE;
55a288e5 2873 }
2874
3a0f6479 2875 // Determine fDet1 and fDet2 and set the fNfragZ and fNfragRphi for debug 3 and 4
2876 CalculDect1Dect2(i);
55a288e5 2877
3a0f6479 2878
2879 return kTRUE;
55a288e5 2880}
3a0f6479 2881//____________Functions for initialising the AliTRDCalibraFit in the code_________
2882Bool_t AliTRDCalibraFit::InitFitCH()
55a288e5 2883{
2884 //
3a0f6479 2885 // Init the fVectorFitCH for normalisation
2886 // Init the histo for debugging
55a288e5 2887 //
2888
3a0f6479 2889 gDirectory = gROOT;
2890
2891 fScaleFitFactor = 0.0;
f29cf84c 2892 if( fCurrentCoefDetector ) delete [] fCurrentCoefDetector;
3a0f6479 2893 fCurrentCoefDetector = new Float_t[2304];
2894 for (Int_t k = 0; k < 2304; k++) {
2895 fCurrentCoefDetector[k] = 0.0;
2896 }
2897 fVectorFit.SetName("gainfactorscoefficients");
55a288e5 2898
3a0f6479 2899 // fDebug == 0 nothing
2900 // fDebug == 1 and fFitVoir no histo
2901 if (fDebugLevel == 1) {
2902 if(!CheckFitVoir()) return kFALSE;
2903 }
2904 //Get the CalDet object
2905 if(fAccCDB){
2906 AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
2907 if (!cal) {
2908 AliInfo("Could not get calibDB");
2909 return kFALSE;
55a288e5 2910 }
3a0f6479 2911 if(fCalDet) delete fCalDet;
2912 fCalDet = new AliTRDCalDet(*(cal->GetGainFactorDet()));
55a288e5 2913 }
3a0f6479 2914 else{
2915 Float_t devalue = 1.0;
2916 if(fCalDet) delete fCalDet;
2917 fCalDet = new AliTRDCalDet("ChamberGainFactor","GainFactor (detector value)");
2918 for(Int_t k = 0; k < 540; k++){
2919 fCalDet->SetValue(k,devalue);
55a288e5 2920 }
2921 }
3a0f6479 2922 return kTRUE;
2923
55a288e5 2924}
3a0f6479 2925//____________Functions for initialising the AliTRDCalibraFit in the code_________
2926Bool_t AliTRDCalibraFit::InitFitPH()
55a288e5 2927{
2928 //
3a0f6479 2929 // Init the arrays of results
2930 // Init the histos for debugging
55a288e5 2931 //
55a288e5 2932
3a0f6479 2933 gDirectory = gROOT;
2934 fVectorFit.SetName("driftvelocitycoefficients");
2935 fVectorFit2.SetName("t0coefficients");
55a288e5 2936
f29cf84c 2937 if( fCurrentCoefDetector ) delete [] fCurrentCoefDetector;
3a0f6479 2938 fCurrentCoefDetector = new Float_t[2304];
2939 for (Int_t k = 0; k < 2304; k++) {
2940 fCurrentCoefDetector[k] = 0.0;
2941 }
f29cf84c 2942 if( fCurrentCoefDetector2 ) delete [] fCurrentCoefDetector2;
3a0f6479 2943 fCurrentCoefDetector2 = new Float_t[2304];
2944 for (Int_t k = 0; k < 2304; k++) {
2945 fCurrentCoefDetector2[k] = 0.0;
55a288e5 2946 }
2947
3a0f6479 2948 //fDebug == 0 nothing
2949 // fDebug == 1 and fFitVoir no histo
2950 if (fDebugLevel == 1) {
2951 if(!CheckFitVoir()) return kFALSE;
2952 }
2953 //Get the CalDet object
2954 if(fAccCDB){
2955 AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
2956 if (!cal) {
2957 AliInfo("Could not get calibDB");
2958 return kFALSE;
2959 }
2960 if(fCalDet) delete fCalDet;
2961 if(fCalDet2) delete fCalDet2;
2962 fCalDet = new AliTRDCalDet(*(cal->GetVdriftDet()));
2963 fCalDet2 = new AliTRDCalDet(*(cal->GetT0Det()));
2964 }
2965 else{
2966 Float_t devalue = 1.5;
2967 Float_t devalue2 = 0.0;
2968 if(fCalDet) delete fCalDet;
2969 if(fCalDet2) delete fCalDet2;
2970 fCalDet = new AliTRDCalDet("ChamberVdrift","TRD drift velocities (detector value)");
2971 fCalDet2 = new AliTRDCalDet("ChamberT0","T0 (detector value)");
2972 for(Int_t k = 0; k < 540; k++){
2973 fCalDet->SetValue(k,devalue);
2974 fCalDet2->SetValue(k,devalue2);
2975 }
2976 }
2977 return kTRUE;
55a288e5 2978}
3a0f6479 2979//____________Functions for initialising the AliTRDCalibraFit in the code_________
2980Bool_t AliTRDCalibraFit::InitFitPRF()
55a288e5 2981{
2982 //
3a0f6479 2983 // Init the calibration mode (Nz, Nrphi), the histograms for
2984 // debugging the fit methods if fDebug > 0,
2985 //
2986
2987 gDirectory = gROOT;
2988 fVectorFit.SetName("prfwidthcoefficients");
2989
f29cf84c 2990 if( fCurrentCoefDetector ) delete [] fCurrentCoefDetector;
3a0f6479 2991 fCurrentCoefDetector = new Float_t[2304];
2992 for (Int_t k = 0; k < 2304; k++) {
2993 fCurrentCoefDetector[k] = 0.0;
55a288e5 2994 }
2995
3a0f6479 2996 // fDebug == 0 nothing
2997 // fDebug == 1 and fFitVoir no histo
2998 if (fDebugLevel == 1) {
2999 if(!CheckFitVoir()) return kFALSE;
3000 }
3001 return kTRUE;
55a288e5 3002}
3a0f6479 3003//____________Functions for initialising the AliTRDCalibraFit in the code_________
3004Bool_t AliTRDCalibraFit::InitFitLinearFitter()
55a288e5 3005{
3006 //
3a0f6479 3007 // Init the fCalDet, fVectorFit fCurrentCoefDetector
55a288e5 3008 //
3a0f6479 3009
3010 gDirectory = gROOT;
3011
f29cf84c 3012 if( fCurrentCoefDetector ) delete [] fCurrentCoefDetector;
3013 if( fCurrentCoefDetector2 ) delete [] fCurrentCoefDetector2;
3a0f6479 3014 fCurrentCoefDetector = new Float_t[2304];
3015 fCurrentCoefDetector2 = new Float_t[2304];
3016 for (Int_t k = 0; k < 2304; k++) {
3017 fCurrentCoefDetector[k] = 0.0;
3018 fCurrentCoefDetector2[k] = 0.0;
55a288e5 3019 }
3020
840ec79d 3021 if((!fCalDetVdriftUsed) || (!fCalDetExBUsed)) return kFALSE;
3022
55a288e5 3023 return kTRUE;
55a288e5 3024}
55a288e5 3025//____________Functions for initialising the AliTRDCalibraFit in the code_________
a0bb5615 3026Bool_t AliTRDCalibraFit::InitFitExbAlt()
3027{
3028 //
3029 // Init the fCalDet, fVectorFit fCurrentCoefDetector
3030 //
3031
3032 gDirectory = gROOT;
3033
f29cf84c 3034 if( fCurrentCoefDetector2 ) delete [] fCurrentCoefDetector2;
3035 fCurrentCoefDetector2 = new Float_t[2304];
a0bb5615 3036 for (Int_t k = 0; k < 2304; k++) {
3037 fCurrentCoefDetector2[k] = 0.0;
3038 }
3039
3040 return kTRUE;
3041}
3042//____________Functions for initialising the AliTRDCalibraFit in the code_________
3a0f6479 3043void AliTRDCalibraFit::InitfCountDetAndfCount(Int_t i)
55a288e5 3044{
3045 //
3a0f6479 3046 // Init the current detector where we are fCountDet and the
3047 // next fCount for the functions Fit...
55a288e5 3048 //
3049
3a0f6479 3050 // Loop on the Xbins of ch!!
3051 fCountDet = -1; // Current detector
3052 fCount = 0; // To find the next detector
3053
3054 // If fDebug >= 3
3055 if (fDebugLevel >= 3) {
3056 // Set countdet to the detector
3057 fCountDet = AliTRDgeometry::GetDetector(fDet[0],fDet[1],fDet[2]);
3058 // Set counter to write at the end of the detector
3059 fCount = fDect2;
3060 // Get the right calib objects
3061 SetCalROC(i);
3062 }
3063 if(fDebugLevel == 1) {
3064 fCountDet = 0;
3065 fCalibraMode->CalculXBins(fCountDet,i);
6aafa7ea 3066 if((fCalibraMode->GetNz(i)!=100) && (fCalibraMode->GetNrphi(i)!=100)){
3067 while(fCalibraMode->GetXbins(i) <=fFitVoir){
3068 fCountDet++;
3069 fCalibraMode->CalculXBins(fCountDet,i);
3070 //printf("GetXBins %d\n",fCalibraMode->GetXbins(i));
3071 }
3072 }
3073 else {
3a0f6479 3074 fCountDet++;
6aafa7ea 3075 }
3a0f6479 3076 fCount = fCalibraMode->GetXbins(i);
3077 fCountDet--;
3078 // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
053767a4 3079 fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),i);
3080 fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
3081 ,(Int_t) GetStack(fCountDet)
3082 ,(Int_t) GetSector(fCountDet),i);
3a0f6479 3083 }
3084}
3085//_______________________________________________________________________________
3086void AliTRDCalibraFit::CalculNumberOfBinsExpected(Int_t i)
3087{
3088 //
3089 // Calculate the number of bins expected (calibration groups)
3090 //
3091
3092 fNumberOfBinsExpected = 0;
64942b85 3093 // All
3094 if((fCalibraMode->GetNz(i) == 100) && (fCalibraMode->GetNrphi(i) == 100)){
3095 fNumberOfBinsExpected = 1;
3096 return;
3097 }
3098 // Per supermodule
3099 if((fCalibraMode->GetNz(i) == 10) && (fCalibraMode->GetNrphi(i) == 10)){
3100 fNumberOfBinsExpected = 18;
3101 return;
3102 }
3103 // More
55a288e5 3104 fCalibraMode->ModePadCalibration(2,i);
3105 fCalibraMode->ModePadFragmentation(0,2,0,i);
3106 fCalibraMode->SetDetChamb2(i);
3a0f6479 3107 if (fDebugLevel > 1) {
55a288e5 3108 AliInfo(Form("For the chamber 2: %d",fCalibraMode->GetDetChamb2(i)));
3109 }
3a0f6479 3110 fNumberOfBinsExpected += 6 * 18 * fCalibraMode->GetDetChamb2(i);
55a288e5 3111 fCalibraMode->ModePadCalibration(0,i);
3112 fCalibraMode->ModePadFragmentation(0,0,0,i);
3113 fCalibraMode->SetDetChamb0(i);
3a0f6479 3114 if (fDebugLevel > 1) {
55a288e5 3115 AliInfo(Form("For the other chamber 0: %d",fCalibraMode->GetDetChamb0(i)));
3116 }
3a0f6479 3117 fNumberOfBinsExpected += 6 * 4 * 18 * fCalibraMode->GetDetChamb0(i);
3118
3119}
3120//_______________________________________________________________________________
3121void AliTRDCalibraFit::CalculDect1Dect2(Int_t i)
3122{
3123 //
3124 // Calculate the range of fits
3125 //
55a288e5 3126
3a0f6479 3127 fDect1 = -1;
3128 fDect2 = -1;
3129 if (fDebugLevel == 1) {
3130 fDect1 = fFitVoir;
3131 fDect2 = fDect1 +1;
55a288e5 3132 }
3a0f6479 3133 if ((fDebugLevel == 2) || (fDebugLevel == 0)) {
3134 fDect1 = 0;
3135 fDect2 = fNumberOfBinsExpected;
55a288e5 3136 }
3a0f6479 3137 if (fDebugLevel >= 3) {
3138 fCountDet = AliTRDgeometry::GetDetector(fDet[0],fDet[1],fDet[2]);
3139 fCalibraMode->CalculXBins(fCountDet,i);
3140 fDect1 = fCalibraMode->GetXbins(i);
3141 // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
053767a4 3142 fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),i);
3143 fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
3144 ,(Int_t) GetStack(fCountDet)
3145 ,(Int_t) GetSector(fCountDet),i);
3a0f6479 3146 // Set for the next detector
3147 fDect2 = fDect1 + fCalibraMode->GetNfragZ(i)*fCalibraMode->GetNfragRphi(i);
55a288e5 3148 }
55a288e5 3149}
3a0f6479 3150//_______________________________________________________________________________
3151Bool_t AliTRDCalibraFit::CheckFitVoir()
55a288e5 3152{
3153 //
3a0f6479 3154 // Check if fFitVoir is in the range
55a288e5 3155 //
3156
3a0f6479 3157 if (fFitVoir < fNumberOfBinsExpected) {
3158 AliInfo(Form("We will see the fit of the object %d",fFitVoir));
55a288e5 3159 }
3a0f6479 3160 else {
3161 AliInfo("fFitVoir is out of range of the histo!");
3162 return kFALSE;
3163 }
3164 return kTRUE;
55a288e5 3165}
55a288e5 3166//____________Functions for initialising the AliTRDCalibraFit in the code_________
3167void AliTRDCalibraFit::UpdatefCountDetAndfCount(Int_t idect, Int_t i)
3168{
3169 //
3170 // See if we are in a new detector and update the
3171 // variables fNfragZ and fNfragRphi if yes
3a0f6479 3172 // Will never happen for only one detector (3 and 4)
3173 // Doesn't matter for 2
3174 //
3175 if (fCount == idect) {
64942b85 3176 // On en est au detector (or first detector in the group)
3177 fCountDet += 1;
3178 AliDebug(2,Form("We are at the detector %d\n",fCountDet));
3179 // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
3180 fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),i);
3181 fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
053767a4 3182 ,(Int_t) GetStack(fCountDet)
3183 ,(Int_t) GetSector(fCountDet),i);
64942b85 3184 // Set for the next detector
3185 fCount += fCalibraMode->GetNfragZ(i)*fCalibraMode->GetNfragRphi(i);
3186 // calib objects
3187 SetCalROC(i);
3188 }
55a288e5 3189}
55a288e5 3190//____________Functions for initialising the AliTRDCalibraFit in the code_________
3191void AliTRDCalibraFit::ReconstructFitRowMinRowMax(Int_t idect, Int_t i)
3192{
3193 //
3194 // Reconstruct the min pad row, max pad row, min pad col and
3195 // max pad col of the calibration group for the Fit functions
64942b85 3196 // idect is the calibration group inside the detector
55a288e5 3197 //
3a0f6479 3198 if (fDebugLevel != 1) {
3199 fCalibraMode->ReconstructionRowPadGroup((Int_t) (idect-(fCount-(fCalibraMode->GetNfragZ(i)*fCalibraMode->GetNfragRphi(i)))),i);
55a288e5 3200 }
64942b85 3201 AliDebug(2,Form("AliTRDCalibraFit::ReconstructFitRowMinRowMax: the local calibration group is %d",idect-(fCount-(fCalibraMode->GetNfragZ(i)*fCalibraMode->GetNfragRphi(i)))));
3202 AliDebug(2,Form("AliTRDCalibraFit::ReconstructFitRowMinRowMax: the number of group per detector is %d",fCalibraMode->GetNfragZ(i)*fCalibraMode->GetNfragRphi(i)));
55a288e5 3203}
55a288e5 3204//____________Functions for initialising the AliTRDCalibraFit in the code_________
3a0f6479 3205Bool_t AliTRDCalibraFit::NotEnoughStatisticCH(Int_t idect)
55a288e5 3206{
3207 //
3208 // For the case where there are not enough entries in the histograms
3a0f6479 3209 // of the calibration group, the value present in the choosen database
3210 // will be put. A negativ sign enables to know that a fit was not possible.
3211 //
3212
3213 if (fDebugLevel == 1) {
3214 AliInfo("The element has not enough statistic to be fitted");
55a288e5 3215 }
64942b85 3216 else if (fNbDet > 0){
3217 Int_t firstdetector = fCountDet;
3218 Int_t lastdetector = fCountDet+fNbDet;
840ec79d 3219 //AliInfo(Form("The element %d containing the detectors %d to %d has not enough statistic to be fitted",idect,firstdetector,lastdetector));
64942b85 3220 // loop over detectors
3221 for(Int_t det = firstdetector; det < lastdetector; det++){
3222
3223 //Set the calibration object again
3224 fCountDet = det;
3225 SetCalROC(0);
3226
3227 // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
3228 // Put them at 1
3229 fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),0);
3230 fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
3231 ,(Int_t) GetStack(fCountDet)
3232 ,(Int_t) GetSector(fCountDet),0);
3233 // Reconstruct row min row max
3234 ReconstructFitRowMinRowMax(idect,0);
3235
3236 // Calcul the coef from the database choosen for the detector
3237 CalculChargeCoefMean(kFALSE);
3238
3239 //stack 2, not stack 2
3240 Int_t factor = 0;
3241 if(GetStack(fCountDet) == 2) factor = 12;
3242 else factor = 16;
3243
3244 // Fill the fCurrentCoefDetector with negative value to say: not fitted
3245 for (Int_t k = fCalibraMode->GetRowMin(0); k < fCalibraMode->GetRowMax(0); k++) {
3246 for (Int_t j = fCalibraMode->GetColMin(0); j < fCalibraMode->GetColMax(0); j++) {
3247 fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
3248 }
3249 }
3250
3251 //Put default value negative
3252 fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
3253 fCurrentCoefE = 0.0;
3254
3255 // Fill the stuff
3256 FillVectorFit();
3257 // Debug
3258 if(fDebugLevel > 1){
3259
3260 if ( !fDebugStreamer ) {
3261 //debug stream
3262 TDirectory *backup = gDirectory;
3263 fDebugStreamer = new TTreeSRedirector("TRDDebugFitCH.root");
3264 if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
3265 }
3266
3267 Int_t detector = fCountDet;
3268 Int_t caligroup = idect;
3269 Short_t rowmin = fCalibraMode->GetRowMin(0);
3270 Short_t rowmax = fCalibraMode->GetRowMax(0);
3271 Short_t colmin = fCalibraMode->GetColMin(0);
3272 Short_t colmax = fCalibraMode->GetColMax(0);
3273 Float_t gf = fCurrentCoef[0];
3274 Float_t gfs = fCurrentCoef[1];
3275 Float_t gfE = fCurrentCoefE;
3276
3277 (*fDebugStreamer) << "FillFillCH" <<
3278 "detector=" << detector <<
3279 "caligroup=" << caligroup <<
3280 "rowmin=" << rowmin <<
3281 "rowmax=" << rowmax <<
3282 "colmin=" << colmin <<
3283 "colmax=" << colmax <<
3284 "gf=" << gf <<
3285 "gfs=" << gfs <<
3286 "gfE=" << gfE <<
3287 "\n";
3288
3289 }
3290 // Reset
3291 for (Int_t k = 0; k < 2304; k++) {
3292 fCurrentCoefDetector[k] = 0.0;
3293 }
3294
3295 }// loop detector
3296 AliDebug(2,Form("Check the count now: fCountDet %d",fCountDet));
3297 }
3a0f6479 3298 else {
55a288e5 3299
840ec79d 3300//AliInfo(Form("The element %d in this detector %d has not enough statistic to be fitted",idect-(fCount-(fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0))),fCountDet));
3a0f6479 3301
3302 // Calcul the coef from the database choosen
3303 CalculChargeCoefMean(kFALSE);
55a288e5 3304
053767a4 3305 //stack 2, not stack 2
3a0f6479 3306 Int_t factor = 0;
053767a4 3307 if(GetStack(fCountDet) == 2) factor = 12;
3a0f6479 3308 else factor = 16;
55a288e5 3309
3a0f6479 3310 // Fill the fCurrentCoefDetector with negative value to say: not fitted
3311 for (Int_t k = fCalibraMode->GetRowMin(0); k < fCalibraMode->GetRowMax(0); k++) {
3312 for (Int_t j = fCalibraMode->GetColMin(0); j < fCalibraMode->GetColMax(0); j++) {
3313 fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
55a288e5 3314 }
3315 }
3a0f6479 3316
3317 //Put default value negative
3318 fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
3319 fCurrentCoefE = 0.0;
3320
3321 FillFillCH(idect);
3322 }
3323
3324 return kTRUE;
55a288e5 3325}
3326
3a0f6479 3327
3328//____________Functions for initialising the AliTRDCalibraFit in the code_________
64942b85 3329Bool_t AliTRDCalibraFit::NotEnoughStatisticPH(Int_t idect,Double_t nentries)
55a288e5 3330{
3331 //
3a0f6479 3332 // For the case where there are not enough entries in the histograms
3333 // of the calibration group, the value present in the choosen database
3334 // will be put. A negativ sign enables to know that a fit was not possible.
55a288e5 3335 //
3a0f6479 3336 if (fDebugLevel == 1) {
3337 AliInfo("The element has not enough statistic to be fitted");
3338 }
64942b85 3339 else if (fNbDet > 0) {
3340
3341 Int_t firstdetector = fCountDet;
3342 Int_t lastdetector = fCountDet+fNbDet;
840ec79d 3343//AliInfo(Form("The element %d containing the detectors %d to %d has not enough statistic to be fitted",idect,firstdetector,lastdetector));
64942b85 3344 // loop over detectors
3345 for(Int_t det = firstdetector; det < lastdetector; det++){
3346
3347 //Set the calibration object again
3348 fCountDet = det;
3349 SetCalROC(1);
3350
3351 // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
3352 // Put them at 1
3353 fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),1);
3354 fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
3355 ,(Int_t) GetStack(fCountDet)
3356 ,(Int_t) GetSector(fCountDet),1);
3357 // Reconstruct row min row max
3358 ReconstructFitRowMinRowMax(idect,1);
3359
3360 // Calcul the coef from the database choosen for the detector
3361 CalculVdriftCoefMean();
3362 CalculT0CoefMean();
3363
3364 //stack 2, not stack 2
3365 Int_t factor = 0;
3366 if(GetStack(fCountDet) == 2) factor = 12;
3367 else factor = 16;
3368
3369 // Fill the fCurrentCoefDetector with negative value to say: not fitted
3370 for (Int_t k = fCalibraMode->GetRowMin(1); k < fCalibraMode->GetRowMax(1); k++) {
3371 for (Int_t j = fCalibraMode->GetColMin(1); j < fCalibraMode->GetColMax(1); j++) {
3372 fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
3373 fCurrentCoefDetector2[(Int_t)(j*factor+k)] = fCurrentCoef2[1] + 100.0;
3374 }
3375 }
3376
3377 //Put default value negative
3378 fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
3379 fCurrentCoefE = 0.0;
3380 fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
3381 fCurrentCoefE2 = 0.0;
3382
3383 // Fill the stuff
3384 FillVectorFit();
3385 FillVectorFit2();
3386 // Debug
3387 if(fDebugLevel > 1){
3388
3389 if ( !fDebugStreamer ) {
3390 //debug stream
3391 TDirectory *backup = gDirectory;
3392 fDebugStreamer = new TTreeSRedirector("TRDDebugFitPH.root");
3393 if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
3394 }
3395
3396
3397 Int_t detector = fCountDet;
3398 Int_t caligroup = idect;
3399 Short_t rowmin = fCalibraMode->GetRowMin(1);
3400 Short_t rowmax = fCalibraMode->GetRowMax(1);
3401 Short_t colmin = fCalibraMode->GetColMin(1);
3402 Short_t colmax = fCalibraMode->GetColMax(1);
3403 Float_t vf = fCurrentCoef[0];
3404 Float_t vs = fCurrentCoef[1];
3405 Float_t vfE = fCurrentCoefE;
3406 Float_t t0f = fCurrentCoef2[0];
3407 Float_t t0s = fCurrentCoef2[1];
3408 Float_t t0E = fCurrentCoefE2;
3409
3410
3411
3412 (* fDebugStreamer) << "FillFillPH"<<
3413 "detector="<<detector<<
3414 "nentries="<<nentries<<
3415 "caligroup="<<caligroup<<
3416 "rowmin="<<rowmin<<
3417 "rowmax="<<rowmax<<
3418 "colmin="<<colmin<<
3419 "colmax="<<colmax<<
3420 "vf="<<vf<<
3421 "vs="<<vs<<
3422 "vfE="<<vfE<<
3423 "t0f="<<t0f<<
3424 "t0s="<<t0s<<
3425 "t0E="<<t0E<<
3426 "\n";
3427 }
3428 // Reset
3429 for (Int_t k = 0; k < 2304; k++) {
3430 fCurrentCoefDetector[k] = 0.0;
3431 fCurrentCoefDetector2[k] = 0.0;
3432 }
3433
3434 }// loop detector
3435 AliDebug(2,Form("Check the count now: fCountDet %d",fCountDet));
3436 }
3a0f6479 3437 else {
55a288e5 3438
840ec79d 3439//AliInfo(Form("The element %d in this detector %d has not enough statistic to be fitted",idect-(fCount-(fCalibraMode->GetNfragZ(1)*fCalibraMode->GetNfragRphi(1))),fCountDet));
55a288e5 3440
3a0f6479 3441 CalculVdriftCoefMean();
3442 CalculT0CoefMean();
55a288e5 3443
053767a4 3444 //stack 2 and not stack 2
3a0f6479 3445 Int_t factor = 0;
053767a4 3446 if(GetStack(fCountDet) == 2) factor = 12;
3a0f6479 3447 else factor = 16;
55a288e5 3448
55a288e5 3449
3a0f6479 3450 // Fill the fCurrentCoefDetector 2
3451 for (Int_t k = fCalibraMode->GetRowMin(1); k < fCalibraMode->GetRowMax(1); k++) {
3452 for (Int_t j = fCalibraMode->GetColMin(1); j < fCalibraMode->GetColMax(1); j++) {
3453 fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
64942b85 3454 fCurrentCoefDetector2[(Int_t)(j*factor+k)] = fCurrentCoef2[1] + 100.0;
55a288e5 3455 }
3456 }
55a288e5 3457
3a0f6479 3458 // Put the default value
3459 fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
3460 fCurrentCoefE = 0.0;
64942b85 3461 fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
3a0f6479 3462 fCurrentCoefE2 = 0.0;
3463
64942b85 3464 FillFillPH(idect,nentries);
3a0f6479 3465
3466 }
55a288e5 3467
3a0f6479 3468 return kTRUE;
64942b85 3469
3a0f6479 3470}
3471
3472
3473//____________Functions for initialising the AliTRDCalibraFit in the code_________
3474Bool_t AliTRDCalibraFit::NotEnoughStatisticPRF(Int_t idect)
3475{
3476 //
3477 // For the case where there are not enough entries in the histograms
3478 // of the calibration group, the value present in the choosen database
3479 // will be put. A negativ sign enables to know that a fit was not possible.
3480 //
55a288e5 3481
3a0f6479 3482 if (fDebugLevel == 1) {
3483 AliInfo("The element has not enough statistic to be fitted");
55a288e5 3484 }
64942b85 3485 else if (fNbDet > 0){
3486
3487 Int_t firstdetector = fCountDet;
3488 Int_t lastdetector = fCountDet+fNbDet;
840ec79d 3489// AliInfo(Form("The element %d containing the detectors %d to %d has not enough statistic to be fitted",idect,firstdetector,lastdetector));
64942b85 3490
3491 // loop over detectors
3492 for(Int_t det = firstdetector; det < lastdetector; det++){
3493
3494 //Set the calibration object again
3495 fCountDet = det;
3496 SetCalROC(2);
3497
3498 // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
3499 // Put them at 1
3500 fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),2);
3501 fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
3502 ,(Int_t) GetStack(fCountDet)
3503 ,(Int_t) GetSector(fCountDet),2);
3504 // Reconstruct row min row max
3505 ReconstructFitRowMinRowMax(idect,2);
3506
3507 // Calcul the coef from the database choosen for the detector
3508 CalculPRFCoefMean();
3509
3510 //stack 2, not stack 2
3511 Int_t factor = 0;
3512 if(GetStack(fCountDet) == 2) factor = 12;
3513 else factor = 16;
3514
3515 // Fill the fCurrentCoefDetector with negative value to say: not fitted
3516 for (Int_t k = fCalibraMode->GetRowMin(2); k < fCalibraMode->GetRowMax(2); k++) {
3517 for (Int_t j = fCalibraMode->GetColMin(2); j < fCalibraMode->GetColMax(2); j++) {
3518 fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
3519 }
3520 }
3521
3522 //Put default value negative
3523 fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
3524 fCurrentCoefE = 0.0;
3525
3526 // Fill the stuff
3527 FillVectorFit();
3528 // Debug
3529 if(fDebugLevel > 1){
3530
3531 if ( !fDebugStreamer ) {
3532 //debug stream
3533 TDirectory *backup = gDirectory;
3534 fDebugStreamer = new TTreeSRedirector("TRDDebugFitPRF.root");
3535 if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
3536 }
3537
3538 Int_t detector = fCountDet;
3539 Int_t layer = GetLayer(fCountDet);
3540 Int_t caligroup = idect;
3541 Short_t rowmin = fCalibraMode->GetRowMin(2);
3542 Short_t rowmax = fCalibraMode->GetRowMax(2);
3543 Short_t colmin = fCalibraMode->GetColMin(2);
3544 Short_t colmax = fCalibraMode->GetColMax(2);
3545 Float_t widf = fCurrentCoef[0];
3546 Float_t wids = fCurrentCoef[1];
3547 Float_t widfE = fCurrentCoefE;
3548
3549 (* fDebugStreamer) << "FillFillPRF"<<
3550 "detector="<<detector<<
3551 "layer="<<layer<<
3552 "caligroup="<<caligroup<<
3553 "rowmin="<<rowmin<<
3554 "rowmax="<<rowmax<<
3555 "colmin="<<colmin<<
3556 "colmax="<<colmax<<
3557 "widf="<<widf<<
3558 "wids="<<wids<<
3559 "widfE="<<widfE<<
3560 "\n";
3561 }
3562 // Reset
3563 for (Int_t k = 0; k < 2304; k++) {
3564 fCurrentCoefDetector[k] = 0.0;
3565 }
3566
3567 }// loop detector
3568 AliDebug(2,Form("Check the count now: fCountDet %d",fCountDet));
3569 }
3a0f6479 3570 else {
3571
840ec79d 3572// 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));
3a0f6479 3573
3574 CalculPRFCoefMean();
3575
053767a4 3576 // stack 2 and not stack 2
3a0f6479 3577 Int_t factor = 0;
053767a4 3578 if(GetStack(fCountDet) == 2) factor = 12;
3a0f6479 3579 else factor = 16;
55a288e5 3580
55a288e5 3581
3a0f6479 3582 // Fill the fCurrentCoefDetector
3583 for (Int_t k = fCalibraMode->GetRowMin(2); k < fCalibraMode->GetRowMax(2); k++) {
3584 for (Int_t j = fCalibraMode->GetColMin(2); j < fCalibraMode->GetColMax(2); j++) {
64942b85 3585 fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
55a288e5 3586 }
3587 }
55a288e5 3588
3a0f6479 3589 // Put the default value
64942b85 3590 fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
3a0f6479 3591 fCurrentCoefE = 0.0;
3592
3593 FillFillPRF(idect);
3594 }
3595
3596 return kTRUE;
55a288e5 3597
3a0f6479 3598}
3599//____________Functions for initialising the AliTRDCalibraFit in the code_________
3600Bool_t AliTRDCalibraFit::NotEnoughStatisticLinearFitter()
55a288e5 3601{
3602 //
3a0f6479 3603 // For the case where there are not enough entries in the histograms
3604 // of the calibration group, the value present in the choosen database
3605 // will be put. A negativ sign enables to know that a fit was not possible.
3606 //
3607
3608 // Calcul the coef from the database choosen
3609 CalculVdriftLorentzCoef();
3610
3611 Int_t factor = 0;
053767a4 3612 if(GetStack(fCountDet) == 2) factor = 1728;
3a0f6479 3613 else factor = 2304;
3614
3615
3616 // Fill the fCurrentCoefDetector
3617 for (Int_t k = 0; k < factor; k++) {
3618 fCurrentCoefDetector[k] = -TMath::Abs(fCurrentCoef[1]);
3619 // should be negative
840ec79d 3620 fCurrentCoefDetector2[k] = fCurrentCoef2[1]+100.0;
55a288e5 3621 }
3a0f6479 3622
3623
840ec79d 3624 //Put default opposite sign only for vdrift
3a0f6479 3625 fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
3626 fCurrentCoefE = 0.0;
840ec79d 3627 fCurrentCoef2[0] = fCurrentCoef2[1]+100.0;
3a0f6479 3628 fCurrentCoefE2 = 0.0;
3629
3630 FillFillLinearFitter();
3631
3632 return kTRUE;
55a288e5 3633}
3634
a0bb5615 3635//____________Functions for initialising the AliTRDCalibraFit in the code_________
3636Bool_t AliTRDCalibraFit::NotEnoughStatisticExbAlt()
3637{
3638 //
3639 // For the case where there are not enough entries in the histograms
3640 // of the calibration group, the value present in the choosen database
3641 // will be put. A negativ sign enables to know that a fit was not possible.
3642 //
3643
3644 Int_t factor = 0;
3645 if(GetStack(fCountDet) == 2) factor = 1728;
3646 else factor = 2304;
3647
3648
3649 // Fill the fCurrentCoefDetector
3650 for (Int_t k = 0; k < factor; k++) {
3651 fCurrentCoefDetector2[k] = 100.0;
3652 }
3653
3654 fCurrentCoef2[0] = 100.0;
3655 fCurrentCoefE2 = 0.0;
3656
3657 FillFillExbAlt();
3658
3659 return kTRUE;
3660}
3661
3a0f6479 3662//____________Functions for initialising the AliTRDCalibraFit in the code_________
3663Bool_t AliTRDCalibraFit::FillInfosFitCH(Int_t idect)
55a288e5 3664{
3665 //
3a0f6479 3666 // Fill the coefficients found with the fits or other
3667 // methods from the Fit functions
3668 //
3669
3670 if (fDebugLevel != 1) {
64942b85 3671 if (fNbDet > 0){
3672 Int_t firstdetector = fCountDet;
3673 Int_t lastdetector = fCountDet+fNbDet;
840ec79d 3674 // AliInfo(Form("The element %d containing the detectors %d to %d has been fitted",idect,firstdetector,lastdetector));
64942b85 3675 // loop over detectors
3676 for(Int_t det = firstdetector; det < lastdetector; det++){
3677
3678 //Set the calibration object again
3679 fCountDet = det;
3680 SetCalROC(0);
3681
3682 // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
3683 // Put them at 1
3684 fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),0);
3685 fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
3686 ,(Int_t) GetStack(fCountDet)
3687 ,(Int_t) GetSector(fCountDet),0);
3688 // Reconstruct row min row max
3689 ReconstructFitRowMinRowMax(idect,0);
3690
3691 // Calcul the coef from the database choosen for the detector
3692 if(fCurrentCoef[0] < 0.0) CalculChargeCoefMean(kFALSE);
3693 else CalculChargeCoefMean(kTRUE);
3694
3695 //stack 2, not stack 2
3696 Int_t factor = 0;
3697 if(GetStack(fCountDet) == 2) factor = 12;
3698 else factor = 16;
3699
3700 // Fill the fCurrentCoefDetector with negative value to say: not fitted
3701 Double_t coeftoput = 1.0;
3702 if(fCurrentCoef[0] < 0.0) coeftoput = - TMath::Abs(fCurrentCoef[1]);
3703 else coeftoput = fCurrentCoef[0];
3704 for (Int_t k = fCalibraMode->GetRowMin(0); k < fCalibraMode->GetRowMax(0); k++) {
3705 for (Int_t j = fCalibraMode->GetColMin(0); j < fCalibraMode->GetColMax(0); j++) {
3706 fCurrentCoefDetector[(Int_t)(j*factor+k)] = coeftoput;
3707 }
3708 }
3709
3710 // Fill the stuff
3711 FillVectorFit();
3712 // Debug
3713 if(fDebugLevel > 1){
3714
3715 if ( !fDebugStreamer ) {
3716 //debug stream
3717 TDirectory *backup = gDirectory;
3718 fDebugStreamer = new TTreeSRedirector("TRDDebugFitCH.root");
3719 if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
3720 }
3721
3722 Int_t detector = fCountDet;
3723 Int_t caligroup = idect;
3724 Short_t rowmin = fCalibraMode->GetRowMin(0);
3725 Short_t rowmax = fCalibraMode->GetRowMax(0);
3726 Short_t colmin = fCalibraMode->GetColMin(0);
3727 Short_t colmax = fCalibraMode->GetColMax(0);
3728 Float_t gf = fCurrentCoef[0];
3729 Float_t gfs = fCurrentCoef[1];
3730 Float_t gfE = fCurrentCoefE;
3731
3732 (*fDebugStreamer) << "FillFillCH" <<
3733 "detector=" << detector <<
3734 "caligroup=" << caligroup <<
3735 "rowmin=" << rowmin <<
3736 "rowmax=" << rowmax <<
3737 "colmin=" << colmin <<
3738 "colmax=" << colmax <<
3739 "gf=" << gf <<
3740 "gfs=" << gfs <<
3741 "gfE=" << gfE <<
3742 "\n";
3743
3744 }
3745 // Reset
3746 for (Int_t k = 0; k < 2304; k++) {
3747 fCurrentCoefDetector[k] = 0.0;
3748 }
3749
3750 }// loop detector
3751 //printf("Check the count now: fCountDet %d\n",fCountDet);
3752 }
3753 else{
3754
3755 Int_t factor = 0;
3756 if(GetStack(fCountDet) == 2) factor = 12;
3757 else factor = 16;
3758
3759 for (Int_t k = fCalibraMode->GetRowMin(0); k < fCalibraMode->GetRowMax(0); k++) {
3760 for (Int_t j = fCalibraMode->GetColMin(0); j < fCalibraMode->GetColMax(0); j++) {
3761 fCurrentCoefDetector[(Int_t)(j*factor+k)] = fCurrentCoef[0];
3762 }
3a0f6479 3763 }
64942b85 3764
3765 FillFillCH(idect);
55a288e5 3766 }
3767 }
55a288e5 3768
3a0f6479 3769 return kTRUE;
3770
3771}
3772//____________Functions for initialising the AliTRDCalibraFit in the code_________
64942b85 3773Bool_t AliTRDCalibraFit::FillInfosFitPH(Int_t idect,Double_t nentries)
55a288e5 3774{
3775 //
3a0f6479 3776 // Fill the coefficients found with the fits or other
3777 // methods from the Fit functions
3778 //
3779
3780 if (fDebugLevel != 1) {
64942b85 3781 if (fNbDet > 0){
3782
3783 Int_t firstdetector = fCountDet;
3784 Int_t lastdetector = fCountDet+fNbDet;
840ec79d 3785// AliInfo(Form("The element %d containing the detectors %d to %d has been fitted",idect,firstdetector,lastdetector));
64942b85 3786
3787 // loop over detectors
3788 for(Int_t det = firstdetector; det < lastdetector; det++){
3789
3790 //Set the calibration object again
3791 fCountDet = det;
3792 SetCalROC(1);
3793
3794 // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
3795 // Put them at 1
3796 fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),1);
3797 fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
3798 ,(Int_t) GetStack(fCountDet)
3799 ,(Int_t) GetSector(fCountDet),1);
3800 // Reconstruct row min row max
3801 ReconstructFitRowMinRowMax(idect,1);
3802
3803 // Calcul the coef from the database choosen for the detector
3804 CalculVdriftCoefMean();
3805 CalculT0CoefMean();
3806
3807 //stack 2, not stack 2
3808 Int_t factor = 0;
3809 if(GetStack(fCountDet) == 2) factor = 12;
3810 else factor = 16;
3811
3812 // Fill the fCurrentCoefDetector with negative value to say: not fitted
3813 Double_t coeftoput = 1.5;
3814 Double_t coeftoput2 = 0.0;
3815
3816 if(fCurrentCoef[0] < 0.0) coeftoput = - TMath::Abs(fCurrentCoef[1]);
3817 else coeftoput = fCurrentCoef[0];
3818
3819 if(fCurrentCoef2[0] > 70.0) coeftoput2 = fCurrentCoef2[1] + 100.0;
3820 else coeftoput2 = fCurrentCoef2[0];
3821
3822 for (Int_t k = fCalibraMode->GetRowMin(1); k < fCalibraMode->GetRowMax(1); k++) {
3823 for (Int_t j = fCalibraMode->GetColMin(1); j < fCalibraMode->GetColMax(1); j++) {
3824 fCurrentCoefDetector[(Int_t)(j*factor+k)] = coeftoput;
3825 fCurrentCoefDetector2[(Int_t)(j*factor+k)] = coeftoput2;
3826 }
3827 }
3828
3829 // Fill the stuff
3830 FillVectorFit();
3831 FillVectorFit2();
3832 // Debug
3833 if(fDebugLevel > 1){
3834
3835 if ( !fDebugStreamer ) {
3836 //debug stream
3837 TDirectory *backup = gDirectory;
3838 fDebugStreamer = new TTreeSRedirector("TRDDebugFitPH.root");
3839 if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
3840 }
3841
3842
3843 Int_t detector = fCountDet;
3844 Int_t caligroup = idect;
3845 Short_t rowmin = fCalibraMode->GetRowMin(1);
3846 Short_t rowmax = fCalibraMode->GetRowMax(1);
3847 Short_t colmin = fCalibraMode->GetColMin(1);
3848 Short_t colmax = fCalibraMode->GetColMax(1);
3849 Float_t vf = fCurrentCoef[0];
3850 Float_t vs = fCurrentCoef[1];
3851 Float_t vfE = fCurrentCoefE;
3852 Float_t t0f = fCurrentCoef2[0];
3853 Float_t t0s = fCurrentCoef2[1];
3854 Float_t t0E = fCurrentCoefE2;
3855
3856
3857
3858 (* fDebugStreamer) << "FillFillPH"<<
3859 "detector="<<detector<<
3860 "nentries="<<nentries<<
3861 "caligroup="<<caligroup<<
3862 "rowmin="<<rowmin<<
3863 "rowmax="<<rowmax<<
3864 "colmin="<<colmin<<
3865 "colmax="<<colmax<<
3866 "vf="<<vf<<
3867 "vs="<<vs<<
3868 "vfE="<<vfE<<
3869 "t0f="<<t0f<<
3870 "t0s="<<t0s<<
3871 "t0E="<<t0E<<
3872 "\n";
3873 }
3874 // Reset
3875 for (Int_t k = 0; k < 2304; k++) {
3876 fCurrentCoefDetector[k] = 0.0;
3877 fCurrentCoefDetector2[k] = 0.0;
3878 }
3879
3880 }// loop detector
3881 //printf("Check the count now: fCountDet %d\n",fCountDet);
3882 }
3883 else {
3884
3885 Int_t factor = 0;
3886 if(GetStack(fCountDet) == 2) factor = 12;
3887 else factor = 16;
3888
3889 for (Int_t k = fCalibraMode->GetRowMin(1); k < fCalibraMode->GetRowMax(1); k++) {
3890 for (Int_t j = fCalibraMode->GetColMin(1); j < fCalibraMode->GetColMax(1); j++) {
3891 fCurrentCoefDetector[(Int_t)(j*factor+k)] = fCurrentCoef[0];
3892 fCurrentCoefDetector2[(Int_t)(j*factor+k)] = fCurrentCoef2[0];
3893 }
3894 }
3895
3896 FillFillPH(idect,nentries);
3897 }
55a288e5 3898 }
3a0f6479 3899 return kTRUE;
55a288e5 3900}
3a0f6479 3901//____________Functions for initialising the AliTRDCalibraFit in the code_________
3902Bool_t AliTRDCalibraFit::FillInfosFitPRF(Int_t idect)
55a288e5 3903{
3904 //
3a0f6479 3905 // Fill the coefficients found with the fits or other
3906 // methods from the Fit functions
55a288e5 3907 //
3a0f6479 3908
3909 if (fDebugLevel != 1) {
64942b85 3910 if (fNbDet > 0){
3a0f6479 3911
64942b85 3912 Int_t firstdetector = fCountDet;
3913 Int_t lastdetector = fCountDet+fNbDet;
840ec79d 3914// AliInfo(Form("The element %d containing the detectors %d to %d has been fitted",idect,firstdetector,lastdetector));
64942b85 3915
3916 // loop over detectors
3917 for(Int_t det = firstdetector; det < lastdetector; det++){
3918
3919 //Set the calibration object again
3920 fCountDet = det;
3921 SetCalROC(2);
3922
3923 // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
3924 // Put them at 1
3925 fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),2);
3926 fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
3927 ,(Int_t) GetStack(fCountDet)
3928 ,(Int_t) GetSector(fCountDet),2);
3929 // Reconstruct row min row max
3930 ReconstructFitRowMinRowMax(idect,2);
3931
3932 // Calcul the coef from the database choosen for the detector
3933 CalculPRFCoefMean();
3934
3935 //stack 2, not stack 2
3936 Int_t factor = 0;
3937 if(GetStack(fCountDet) == 2) factor = 12;
3938 else factor = 16;
3939
3940 // Fill the fCurrentCoefDetector with negative value to say: not fitted
3941 Double_t coeftoput = 1.0;
3942 if(fCurrentCoef[0] < 0.0) coeftoput = - TMath::Abs(fCurrentCoef[1]);
3943 else coeftoput = fCurrentCoef[0];
3944 for (Int_t k = fCalibraMode->GetRowMin(2); k < fCalibraMode->GetRowMax(2); k++) {
3945 for (Int_t j = fCalibraMode->GetColMin(2); j < fCalibraMode->GetColMax(2); j++) {
3946 fCurrentCoefDetector[(Int_t)(j*factor+k)] = coeftoput;
3947 }
3948 }
3949
3950 // Fill the stuff
3951 FillVectorFit();
3952 // Debug
3953 if(fDebugLevel > 1){
3954
3955 if ( !fDebugStreamer ) {
3956 //debug stream
3957 TDirectory *backup = gDirectory;
3958 fDebugStreamer = new TTreeSRedirector("TRDDebugFitPRF.root");
3959 if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
3960 }
3961
3962 Int_t detector = fCountDet;
3963 Int_t layer = GetLayer(fCountDet);
3964 Int_t caligroup = idect;
3965 Short_t rowmin = fCalibraMode->GetRowMin(2);
3966 Short_t rowmax = fCalibraMode->GetRowMax(2);
3967 Short_t colmin = fCalibraMode->GetColMin(2);
3968 Short_t colmax = fCalibraMode->GetColMax(2);
3969 Float_t widf = fCurrentCoef[0];
3970 Float_t wids = fCurrentCoef[1];
3971 Float_t widfE = fCurrentCoefE;
3972
3973 (* fDebugStreamer) << "FillFillPRF"<<
3974 "detector="<<detector<<
3975 "layer="<<layer<<
3976 "caligroup="<<caligroup<<
3977 "rowmin="<<rowmin<<
3978 "rowmax="<<rowmax<<
3979 "colmin="<<colmin<<
3980 "colmax="<<colmax<<
3981 "widf="<<widf<<
3982 "wids="<<wids<<
3983 "widfE="<<widfE<<
3984 "\n";
3985 }
3986 // Reset
3987 for (Int_t k = 0; k < 2304; k++) {
3988 fCurrentCoefDetector[k] = 0.0;
3989 }
3990
3991 }// loop detector
3992 //printf("Check the count now: fCountDet %d\n",fCountDet);
3993 }
3994 else {
3995
3996 Int_t factor = 0;
3997 if(GetStack(fCountDet) == 2) factor = 12;
3998 else factor = 16;
3999
4000 // Pointer to the branch
4001 for (Int_t k = fCalibraMode->GetRowMin(2); k < fCalibraMode->GetRowMax(2); k++) {
4002 for (Int_t j = fCalibraMode->GetColMin(2); j < fCalibraMode->GetColMax(2); j++) {
4003 fCurrentCoefDetector[(Int_t)(j*factor+k)] = fCurrentCoef[0];
4004 }
3a0f6479 4005 }
64942b85 4006 FillFillPRF(idect);
55a288e5 4007 }
4008 }
64942b85 4009
3a0f6479 4010 return kTRUE;
55a288e5 4011
3a0f6479 4012}
4013//____________Functions for initialising the AliTRDCalibraFit in the code_________
4014Bool_t AliTRDCalibraFit::FillInfosFitLinearFitter()
55a288e5 4015{
4016 //
3a0f6479 4017 // Fill the coefficients found with the fits or other
4018 // methods from the Fit functions
55a288e5 4019 //
3a0f6479 4020
4021 Int_t factor = 0;
053767a4 4022 if(GetStack(fCountDet) == 2) factor = 1728;
3a0f6479 4023 else factor = 2304;
4024
4025 // Pointer to the branch
4026 for (Int_t k = 0; k < factor; k++) {
4027 fCurrentCoefDetector[k] = fCurrentCoef[0];
4028 fCurrentCoefDetector2[k] = fCurrentCoef2[0];
55a288e5 4029 }
3a0f6479 4030
4031 FillFillLinearFitter();
4032
4033 return kTRUE;
55a288e5 4034
a0bb5615 4035}
4036//____________Functions for initialising the AliTRDCalibraFit in the code_________
4037Bool_t AliTRDCalibraFit::FillInfosFitExbAlt()
4038{
4039 //
4040 // Fill the coefficients found with the fits or other
4041 // methods from the Fit functions
4042 //
4043
4044 Int_t factor = 0;
4045 if(GetStack(fCountDet) == 2) factor = 1728;
4046 else factor = 2304;
4047
4048 // Pointer to the branch
4049 for (Int_t k = 0; k < factor; k++) {
4050 fCurrentCoefDetector2[k] = fCurrentCoef2[0];
4051 }
4052
4053 FillFillExbAlt();
4054
4055 return kTRUE;
4056
55a288e5 4057}
3a0f6479 4058//________________________________________________________________________________
4059void AliTRDCalibraFit::FillFillCH(Int_t idect)
55a288e5 4060{
4061 //
3a0f6479 4062 // DebugStream and fVectorFit
55a288e5 4063 //
4064
3a0f6479 4065 // End of one detector
4066 if ((idect == (fCount-1))) {
4067 FillVectorFit();
4068 // Reset
4069 for (Int_t k = 0; k < 2304; k++) {
4070 fCurrentCoefDetector[k] = 0.0;
4071 }
55a288e5 4072 }
4073
3a0f6479 4074 if(fDebugLevel > 1){
55a288e5 4075
3a0f6479 4076 if ( !fDebugStreamer ) {
4077 //debug stream
4078 TDirectory *backup = gDirectory;
4aad967c 4079 fDebugStreamer = new TTreeSRedirector("TRDDebugFitCH.root");
3a0f6479 4080 if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
4081 }
4082
4083 Int_t detector = fCountDet;
4084 Int_t caligroup = idect;
4085 Short_t rowmin = fCalibraMode->GetRowMin(0);
4086 Short_t rowmax = fCalibraMode->GetRowMax(0);
4087 Short_t colmin = fCalibraMode->GetColMin(0);
4088 Short_t colmax = fCalibraMode->GetColMax(0);
4089 Float_t gf = fCurrentCoef[0];
4090 Float_t gfs = fCurrentCoef[1];
4091 Float_t gfE = fCurrentCoefE;
4092
413153cb 4093 (*fDebugStreamer) << "FillFillCH" <<
3a0f6479 4094 "detector=" << detector <<
4095 "caligroup=" << caligroup <<
4096 "rowmin=" << rowmin <<
4097 "rowmax=" << rowmax <<
4098 "colmin=" << colmin <<
4099 "colmax=" << colmax <<
4100 "gf=" << gf <<
4101 "gfs=" << gfs <<
4102 "gfE=" << gfE <<
4103 "\n";
4104
4105 }
4106}
4107//________________________________________________________________________________
64942b85 4108void AliTRDCalibraFit::FillFillPH(Int_t idect,Double_t nentries)
55a288e5 4109{
4110 //
3a0f6479 4111 // DebugStream and fVectorFit and fVectorFit2
55a288e5 4112 //
3a0f6479 4113
4114 // End of one detector
4115 if ((idect == (fCount-1))) {
4116 FillVectorFit();
4117 FillVectorFit2();
4118 // Reset
4119 for (Int_t k = 0; k < 2304; k++) {
4120 fCurrentCoefDetector[k] = 0.0;
4121 fCurrentCoefDetector2[k] = 0.0;
4122 }
4123 }
4124
4125 if(fDebugLevel > 1){
4126
4127 if ( !fDebugStreamer ) {
4128 //debug stream
4129 TDirectory *backup = gDirectory;
4aad967c 4130 fDebugStreamer = new TTreeSRedirector("TRDDebugFitPH.root");
3a0f6479 4131 if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
4132 }
4133
4134
4135 Int_t detector = fCountDet;
4136 Int_t caligroup = idect;
4137 Short_t rowmin = fCalibraMode->GetRowMin(1);
4138 Short_t rowmax = fCalibraMode->GetRowMax(1);
4139 Short_t colmin = fCalibraMode->GetColMin(1);
4140 Short_t colmax = fCalibraMode->GetColMax(1);
4141 Float_t vf = fCurrentCoef[0];
4142 Float_t vs = fCurrentCoef[1];
4143 Float_t vfE = fCurrentCoefE;
4144 Float_t t0f = fCurrentCoef2[0];
4145 Float_t t0s = fCurrentCoef2[1];
4146 Float_t t0E = fCurrentCoefE2;
4147
55a288e5 4148
3a0f6479 4149
413153cb 4150 (* fDebugStreamer) << "FillFillPH"<<
3a0f6479 4151 "detector="<<detector<<
64942b85 4152 "nentries="<<nentries<<
3a0f6479 4153 "caligroup="<<caligroup<<
4154 "rowmin="<<rowmin<<
4155 "rowmax="<<rowmax<<
4156 "colmin="<<colmin<<
4157 "colmax="<<colmax<<
4158 "vf="<<vf<<
4159 "vs="<<vs<<
4160 "vfE="<<vfE<<
4161 "t0f="<<t0f<<
4162 "t0s="<<t0s<<
4163 "t0E="<<t0E<<
4164 "\n";
4165 }
55a288e5 4166
4167}
3a0f6479 4168//________________________________________________________________________________
4169void AliTRDCalibraFit::FillFillPRF(Int_t idect)
4170{
4171 //
4172 // DebugStream and fVectorFit
4173 //
55a288e5 4174
3a0f6479 4175 // End of one detector
4176 if ((idect == (fCount-1))) {
4177 FillVectorFit();
4178 // Reset
4179 for (Int_t k = 0; k < 2304; k++) {
4180 fCurrentCoefDetector[k] = 0.0;
4181 }
4182 }
4183
4184
4185 if(fDebugLevel > 1){
4186
4187 if ( !fDebugStreamer ) {
4188 //debug stream
4189 TDirectory *backup = gDirectory;
4aad967c 4190 fDebugStreamer = new TTreeSRedirector("TRDDebugFitPRF.root");
3a0f6479 4191 if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
4192 }
4193
4194 Int_t detector = fCountDet;
053767a4 4195 Int_t layer = GetLayer(fCountDet);
3a0f6479 4196 Int_t caligroup = idect;
4197 Short_t rowmin = fCalibraMode->GetRowMin(2);
4198 Short_t rowmax = fCalibraMode->GetRowMax(2);
4199 Short_t colmin = fCalibraMode->GetColMin(2);
4200 Short_t colmax = fCalibraMode->GetColMax(2);
4201 Float_t widf = fCurrentCoef[0];
4202 Float_t wids = fCurrentCoef[1];
4203 Float_t widfE = fCurrentCoefE;
4204
413153cb 4205 (* fDebugStreamer) << "FillFillPRF"<<
3a0f6479 4206 "detector="<<detector<<
053767a4 4207 "layer="<<layer<<
3a0f6479 4208 "caligroup="<<caligroup<<
4209 "rowmin="<<rowmin<<
4210 "rowmax="<<rowmax<<
4211 "colmin="<<colmin<<
4212 "colmax="<<colmax<<
4213 "widf="<<widf<<
4214 "wids="<<wids<<
4215 "widfE="<<widfE<<
4216 "\n";
4217 }
4218
4219}
4220//________________________________________________________________________________
4221void AliTRDCalibraFit::FillFillLinearFitter()
55a288e5 4222{
4223 //
3a0f6479 4224 // DebugStream and fVectorFit
55a288e5 4225 //
3a0f6479 4226
4227 // End of one detector
4228 FillVectorFit();
4229 FillVectorFit2();
4230
4231
4232 // Reset
4233 for (Int_t k = 0; k < 2304; k++) {
4234 fCurrentCoefDetector[k] = 0.0;
4235 fCurrentCoefDetector2[k] = 0.0;
55a288e5 4236 }
3a0f6479 4237
55a288e5 4238
3a0f6479 4239 if(fDebugLevel > 1){
55a288e5 4240
3a0f6479 4241 if ( !fDebugStreamer ) {
4242 //debug stream
4243 TDirectory *backup = gDirectory;
4aad967c 4244 fDebugStreamer = new TTreeSRedirector("TRDDebugFitLinearFitter.root");
3a0f6479 4245 if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
4246 }
4247
4248 //Debug: comparaison of the different methods (okey for first time but not for iterative procedure)
053767a4 4249 AliTRDpadPlane *padplane = fGeo->GetPadPlane(GetLayer(fCountDet),GetStack(fCountDet));
3a0f6479 4250 Float_t rowmd = (padplane->GetRow0()+padplane->GetRowEnd())/2.;
053767a4 4251 Float_t r = AliTRDgeometry::GetTime0(GetLayer(fCountDet));
3a0f6479 4252 Float_t tiltangle = padplane->GetTiltingAngle();
4253 Int_t detector = fCountDet;
053767a4 4254 Int_t stack = GetStack(fCountDet);
4255 Int_t layer = GetLayer(fCountDet);
3a0f6479 4256 Float_t vf = fCurrentCoef[0];
4257 Float_t vs = fCurrentCoef[1];
4258 Float_t vfE = fCurrentCoefE;
4259 Float_t lorentzangler = fCurrentCoef2[0];
e6381f8e 4260 Float_t elorentzangler = fCurrentCoefE2;
3a0f6479 4261 Float_t lorentzangles = fCurrentCoef2[1];
4262
413153cb 4263 (* fDebugStreamer) << "FillFillLinearFitter"<<
3a0f6479 4264 "detector="<<detector<<
053767a4 4265 "stack="<<stack<<
4266 "layer="<<layer<<
3a0f6479 4267 "rowmd="<<rowmd<<
4268 "r="<<r<<
4269 "tiltangle="<<tiltangle<<
4270 "vf="<<vf<<
4271 "vs="<<vs<<
4272 "vfE="<<vfE<<
4273 "lorentzangler="<<lorentzangler<<
e6381f8e 4274 "Elorentzangler="<<elorentzangler<<
3a0f6479 4275 "lorentzangles="<<lorentzangles<<
4276 "\n";
4277 }
4278
a0bb5615 4279}
4280//________________________________________________________________________________
4281void AliTRDCalibraFit::FillFillExbAlt()
4282{
4283 //
4284 // DebugStream and fVectorFit
4285 //
4286
4287 // End of one detector
4288 FillVectorFit2();
4289
4290
4291 // Reset
4292 for (Int_t k = 0; k < 2304; k++) {
4293 fCurrentCoefDetector2[k] = 0.0;
4294 }
4295
4296
4297 if(fDebugLevel > 1){
4298
4299 if ( !fDebugStreamer ) {
4300 //debug stream
4301 TDirectory *backup = gDirectory;
4302 fDebugStreamer = new TTreeSRedirector("TRDDebugFitExbAlt.root");
4303 if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
4304 }
4305
4306 //Debug: comparaison of the different methods (okey for first time but not for iterative procedure)
4307 AliTRDpadPlane *padplane = fGeo->GetPadPlane(GetLayer(fCountDet),GetStack(fCountDet));
4308 Float_t rowmd = (padplane->GetRow0()+padplane->GetRowEnd())/2.;
4309 Float_t r = AliTRDgeometry::GetTime0(GetLayer(fCountDet));
4310 Float_t tiltangle = padplane->GetTiltingAngle();
4311 Int_t detector = fCountDet;
4312 Int_t stack = GetStack(fCountDet);
4313 Int_t layer = GetLayer(fCountDet);
4314 Float_t vf = fCurrentCoef2[0];
4315 Float_t vfE = fCurrentCoefE2;
4316
4317 (* fDebugStreamer) << "FillFillLinearFitter"<<
4318 "detector="<<detector<<
4319 "stack="<<stack<<
4320 "layer="<<layer<<
4321 "rowmd="<<rowmd<<
4322 "r="<<r<<
4323 "tiltangle="<<tiltangle<<
4324 "vf="<<vf<<
4325 "vfE="<<vfE<<
4326 "\n";
4327 }
4328
3a0f6479 4329}
55a288e5 4330//
4331//____________Calcul Coef Mean_________________________________________________
4332//
55a288e5 4333//_____________________________________________________________________________
3a0f6479 4334Bool_t AliTRDCalibraFit::CalculT0CoefMean()
55a288e5 4335{
4336 //
4337 // For the detector Dect calcul the mean time 0
4338 // for the calibration group idect from the choosen database
4339 //
4340
3a0f6479 4341 fCurrentCoef2[1] = 0.0;
4342 if(fDebugLevel != 1){
64942b85 4343 if(((fCalibraMode->GetNz(1) > 0) ||
4344 (fCalibraMode->GetNrphi(1) > 0)) && ((fCalibraMode->GetNz(1) != 10) && (fCalibraMode->GetNz(1) != 100))) {
4345
3a0f6479 4346 for (Int_t row = fCalibraMode->GetRowMin(1); row < fCalibraMode->GetRowMax(1); row++) {
4347 for (Int_t col = fCalibraMode->GetColMin(1); col < fCalibraMode->GetColMax(1); col++) {
4348 fCurrentCoef2[1] += (Float_t) (fCalROC2->GetValue(col,row)+fCalDet2->GetValue(fCountDet));
55a288e5 4349 }
3a0f6479 4350 }
64942b85 4351
3a0f6479 4352 fCurrentCoef2[1] = fCurrentCoef2[1] / ((fCalibraMode->GetColMax(1)-fCalibraMode->GetColMin(1))*(fCalibraMode->GetRowMax(1)-fCalibraMode->GetRowMin(1)));
64942b85 4353
3a0f6479 4354 }
4355 else {
64942b85 4356
3a0f6479 4357 if(!fAccCDB){
4358 fCurrentCoef2[1] = fCalDet2->GetValue(fCountDet);
4359 }
4360 else{
64942b85 4361
053767a4 4362 for(Int_t row = 0; row < fGeo->GetRowMax(GetLayer(fCountDet),GetStack(fCountDet),GetSector(fCountDet)); row++){
4363 for(Int_t col = 0; col < fGeo->GetColMax(GetLayer(fCountDet)); col++){
3a0f6479 4364 fCurrentCoef2[1] += (Float_t) (fCalROC2->GetValue(col,row)+fCalDet2->GetValue(fCountDet));
4365 }
55a288e5 4366 }
053767a4 4367 fCurrentCoef2[1] = fCurrentCoef2[1] / ((fGeo->GetRowMax(GetLayer(fCountDet),GetStack(fCountDet),GetSector(fCountDet)))*(fGeo->GetColMax(GetLayer(fCountDet))));
64942b85 4368
55a288e5 4369 }
4370 }
55a288e5 4371 }
55a288e5 4372 return kTRUE;
55a288e5 4373}
4374
4375//_____________________________________________________________________________
3a0f6479 4376Bool_t AliTRDCalibraFit::CalculChargeCoefMean(Bool_t vrai)
55a288e5 4377{
4378 //
4379 // For the detector Dect calcul the mean gain factor
4380 // for the calibration group idect from the choosen database
4381 //
4382
3a0f6479 4383 fCurrentCoef[1] = 0.0;
4384 if(fDebugLevel != 1){
64942b85 4385 if (((fCalibraMode->GetNz(0) > 0) ||
4386 (fCalibraMode->GetNrphi(0) > 0)) && ((fCalibraMode->GetNz(0) != 10) && (fCalibraMode->GetNz(0) != 100))) {
3a0f6479 4387 for (Int_t row = fCalibraMode->GetRowMin(0); row < fCalibraMode->GetRowMax(0); row++) {
4388 for (Int_t col = fCalibraMode->GetColMin(0); col < fCalibraMode->GetColMax(0); col++) {
4389 fCurrentCoef[1] += (Float_t) (fCalROC->GetValue(col,row)*fCalDet->GetValue(fCountDet));
4390 if (vrai) fScaleFitFactor += (Float_t) (fCalROC->GetValue(col,row)*fCalDet->GetValue(fCountDet));
55a288e5 4391 }
4392 }
3a0f6479 4393 fCurrentCoef[1] = fCurrentCoef[1] / ((fCalibraMode->GetColMax(0)-fCalibraMode->GetColMin(0))*(fCalibraMode->GetRowMax(0)-fCalibraMode->GetRowMin(0)));
55a288e5 4394 }
3a0f6479 4395 else {
4396 //Per detectors
4397 fCurrentCoef[1] = (Float_t) fCalDet->GetValue(fCountDet);
4398 if (vrai) fScaleFitFactor += ((Float_t) fCalDet->GetValue(fCountDet))*(fCalibraMode->GetColMax(0)-fCalibraMode->GetColMin(0))*(fCalibraMode->GetRowMax(0)-fCalibraMode->GetRowMin(0));
4399 }
55a288e5 4400 }
55a288e5 4401 return kTRUE;
55a288e5 4402}
55a288e5 4403//_____________________________________________________________________________
3a0f6479 4404Bool_t AliTRDCalibraFit::CalculPRFCoefMean()
55a288e5 4405{
4406 //
4407 // For the detector Dect calcul the mean sigma of pad response
4408 // function for the calibration group idect from the choosen database
4409 //
3a0f6479 4410
4411 fCurrentCoef[1] = 0.0;
4412 if(fDebugLevel != 1){
55a288e5 4413 for (Int_t row = fCalibraMode->GetRowMin(2); row < fCalibraMode->GetRowMax(2); row++) {
4414 for (Int_t col = fCalibraMode->GetColMin(2); col < fCalibraMode->GetColMax(2); col++) {
3a0f6479 4415 fCurrentCoef[1] += (Float_t) fCalROC->GetValue(col,row);
55a288e5 4416 }
4417 }
3a0f6479 4418 fCurrentCoef[1] = fCurrentCoef[1] / ((fCalibraMode->GetColMax(2)-fCalibraMode->GetColMin(2))*(fCalibraMode->GetRowMax(2)-fCalibraMode->GetRowMin(2)));
55a288e5 4419 }
55a288e5 4420 return kTRUE;
55a288e5 4421}
55a288e5 4422//_____________________________________________________________________________
3a0f6479 4423Bool_t AliTRDCalibraFit::CalculVdriftCoefMean()
55a288e5 4424{
4425 //
4426 // For the detector dect calcul the mean drift velocity for the
4427 // calibration group idect from the choosen database
4428 //
4429
3a0f6479 4430 fCurrentCoef[1] = 0.0;
4431 if(fDebugLevel != 1){
64942b85 4432 if (((fCalibraMode->GetNz(1) > 0) ||
4433 (fCalibraMode->GetNrphi(1) > 0)) && ((fCalibraMode->GetNz(1) != 10) && (fCalibraMode->GetNz(1) != 100))) {
4434
3a0f6479 4435 for (Int_t row = fCalibraMode->GetRowMin(1); row < fCalibraMode->GetRowMax(1); row++) {
4436 for (Int_t col = fCalibraMode->GetColMin(1); col < fCalibraMode->GetColMax(1); col++) {
4437 fCurrentCoef[1] += (Float_t) (fCalROC->GetValue(col,row)*fCalDet->GetValue(fCountDet));
55a288e5 4438 }
4439 }
64942b85 4440
3a0f6479 4441 fCurrentCoef[1] = fCurrentCoef[1] / ((fCalibraMode->GetColMax(1)-fCalibraMode->GetColMin(1))*(fCalibraMode->GetRowMax(1)-fCalibraMode->GetRowMin(1)));
64942b85 4442
55a288e5 4443 }
3a0f6479 4444 else {
4445 //per detectors
4446 fCurrentCoef[1] = (Float_t) fCalDet->GetValue(fCountDet);
4447 }
55a288e5 4448 }
55a288e5 4449 return kTRUE;
55a288e5 4450}
3a0f6479 4451//_____________________________________________________________________________
4452Bool_t AliTRDCalibraFit::CalculVdriftLorentzCoef()
4453{
4454 //
4455 // For the detector fCountDet, mean drift velocity and tan lorentzangle
4456 //
4457
840ec79d 4458 fCurrentCoef[1] = fCalDetVdriftUsed->GetValue(fCountDet);
4459 fCurrentCoef2[1] = fCalDetExBUsed->GetValue(fCountDet);
55a288e5 4460
3a0f6479 4461 return kTRUE;
4462}
55a288e5 4463//_____________________________________________________________________________
053767a4 4464Float_t AliTRDCalibraFit::GetPRFDefault(Int_t layer) const
55a288e5 4465{
4466 //
4467 // Default width of the PRF if there is no database as reference
4468 //
053767a4 4469 switch(layer)
3a0f6479 4470 {
4471 // default database
4472 //case 0: return 0.515;
4473 //case 1: return 0.502;
4474 //case 2: return 0.491;
4475 //case 3: return 0.481;
4476 //case 4: return 0.471;
4477 //case 5: return 0.463;
4478 //default: return 0.0;
4479
4480 // fit database
4481 case 0: return 0.538429;
4482 case 1: return 0.524302;
4483 case 2: return 0.511591;
4484 case 3: return 0.500140;
4485 case 4: return 0.489821;
4486 case 5: return 0.480524;
4487 default: return 0.0;
55a288e5 4488 }
3a0f6479 4489}
4490//________________________________________________________________________________
4491void AliTRDCalibraFit::SetCalROC(Int_t i)
4492{
4493 //
4494 // Set the calib object for fCountDet
4495 //
4496
4497 Float_t value = 0.0;
4498
4499 //Get the CalDet object
4500 if(fAccCDB){
4501 AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
4502 if (!cal) {
4503 AliInfo("Could not get calibDB");
4504 return;
4505 }
4506 switch (i)
4507 {
4508 case 0:
64942b85 4509 if( fCalROC ){
4510 fCalROC->~AliTRDCalROC();
4511 new(fCalROC) AliTRDCalROC(*(cal->GetGainFactorROC(fCountDet)));
4512 }else fCalROC = new AliTRDCalROC(*(cal->GetGainFactorROC(fCountDet)));
3a0f6479 4513 break;
4514 case 1:
64942b85 4515 if( fCalROC ){
4516 fCalROC->~AliTRDCalROC();
4517 new(fCalROC) AliTRDCalROC(*(cal->GetVdriftROC(fCountDet)));
4518 }else fCalROC = new AliTRDCalROC(*(cal->GetVdriftROC(fCountDet)));
4519 if( fCalROC2 ){
4520 fCalROC2->~AliTRDCalROC();
4521 new(fCalROC2) AliTRDCalROC(*(cal->GetT0ROC(fCountDet)));
4522 }else fCalROC2 = new AliTRDCalROC(*(cal->GetT0ROC(fCountDet)));
3a0f6479 4523 break;
4524 case 2:
64942b85 4525 if( fCalROC ){
4526 fCalROC->~AliTRDCalROC();
4527 new(fCalROC) AliTRDCalROC(*(cal->GetPRFROC(fCountDet)));
4528 }else fCalROC = new AliTRDCalROC(*(cal->GetPRFROC(fCountDet)));
4529 break;
3a0f6479 4530 default: return;
4531 }
55a288e5 4532 }
3a0f6479 4533 else{
4534 switch (i)
4535 {
4536 case 0:
4537 if(fCalROC) delete fCalROC;
053767a4 4538 fCalROC = new AliTRDCalROC(GetLayer(fCountDet),GetStack(fCountDet));
3a0f6479 4539 for(Int_t k = 0; k < fCalROC->GetNchannels(); k++){
4540 fCalROC->SetValue(k,1.0);
4541 }
4542 break;
4543 case 1:
4544 if(fCalROC) delete fCalROC;
4545 if(fCalROC2) delete fCalROC2;
053767a4 4546 fCalROC = new AliTRDCalROC(GetLayer(fCountDet),GetStack(fCountDet));
4547 fCalROC2 = new AliTRDCalROC(GetLayer(fCountDet),GetStack(fCountDet));
3a0f6479 4548 for(Int_t k = 0; k < fCalROC->GetNchannels(); k++){
4549 fCalROC->SetValue(k,1.0);
4550 fCalROC2->SetValue(k,0.0);
4551 }
4552 break;
4553 case 2:
4554 if(fCalROC) delete fCalROC;
053767a4 4555 value = GetPRFDefault(GetLayer(fCountDet));
4556 fCalROC = new AliTRDCalROC(GetLayer(fCountDet),GetStack(fCountDet));
3a0f6479 4557 for(Int_t k = 0; k < fCalROC->GetNchannels(); k++){
4558 fCalROC->SetValue(k,value);
4559 }
4560 break;
4561 default: return;
4562 }
55a288e5 4563 }
4564
4565}
55a288e5 4566//____________Fit Methods______________________________________________________
4567
4568//_____________________________________________________________________________
3a0f6479 4569void AliTRDCalibraFit::FitPente(TH1* projPH)
55a288e5 4570{
4571 //
4572 // Slope methode for the drift velocity
4573 //
4574
4575 // Constants
4576 const Float_t kDrWidth = AliTRDgeometry::DrThick();
3a0f6479 4577 Int_t binmax = 0;
4578 Int_t binmin = 0;
4579 fPhd[0] = 0.0;
4580 fPhd[1] = 0.0;
4581 fPhd[2] = 0.0;
4582 Int_t ju = 0;
4583 fCurrentCoefE = 0.0;
4584 fCurrentCoefE2 = 0.0;
4585 fCurrentCoef[0] = 0.0;
4586 fCurrentCoef2[0] = 0.0;
4587 TLine *line = new TLine();
55a288e5 4588
4589 // Some variables
4590 TAxis *xpph = projPH->GetXaxis();
4591 Int_t nbins = xpph->GetNbins();
4592 Double_t lowedge = xpph->GetBinLowEdge(1);
4593 Double_t upedge = xpph->GetBinUpEdge(xpph->GetNbins());
4594 Double_t widbins = (upedge - lowedge) / nbins;
4595 Double_t limit = upedge + 0.5 * widbins;
4596 Bool_t put = kTRUE;
4597
4598 // Beginning of the signal
4599 TH1D *pentea = new TH1D("pentea","pentea",projPH->GetNbinsX(),0,(Float_t) limit);
4600 for (Int_t k = 1; k < projPH->GetNbinsX(); k++) {
4601 pentea->SetBinContent(k,(Double_t) (projPH->GetBinContent(k+1) - projPH->GetBinContent(k)));
4602 }
55a288e5 4603 binmax = (Int_t) pentea->GetMaximumBin();
55a288e5 4604 if (binmax <= 1) {
4605 binmax = 2;
4606 AliInfo("Put the binmax from 1 to 2 to enable the fit");
4607 }
4608 if (binmax >= nbins) {
4609 binmax = nbins-1;
4610 put = kFALSE;
4611 AliInfo("Put the binmax from nbins-1 to nbins-2 to enable the fit");
4612 }
4613 pentea->Fit("pol2","0MR","",TMath::Max(pentea->GetBinCenter(binmax-1),0.0),pentea->GetBinCenter(binmax+1));
4614 Float_t l3P1am = pentea->GetFunction("pol2")->GetParameter(1);
4615 Float_t l3P2am = pentea->GetFunction("pol2")->GetParameter(2);
4616 Float_t l3P1amE = pentea->GetFunction("pol2")->GetParError(1);
4617 Float_t l3P2amE = pentea->GetFunction("pol2")->GetParError(2);
daa7dc79 4618 if (TMath::Abs(l3P2am) > 0.00000001) {
55a288e5 4619 fPhd[0] = -(l3P1am / (2 * l3P2am));
4620 }
4621 if(!fTakeTheMaxPH){
daa7dc79 4622 if((TMath::Abs(l3P1am) > 0.0000000001) && (TMath::Abs(l3P2am) > 0.00000000001)){
3a0f6479 4623 fCurrentCoefE2 = (l3P1amE/l3P1am + l3P2amE/l3P2am)*fPhd[0];
55a288e5 4624 }
4625 }
55a288e5 4626 // Amplification region
4627 binmax = 0;
4628 ju = 0;
4629 for (Int_t kbin = 1; kbin < projPH->GetNbinsX(); kbin ++) {
3a0f6479 4630 if (((projPH->GetBinContent(kbin+1) - projPH->GetBinContent(kbin)) <= 0.0) && (ju == 0) && (kbin > (fPhd[0]/widbins))) {
55a288e5 4631 binmax = kbin;
4632 ju = 1;
4633 }
4634 }
55a288e5 4635 if (binmax <= 1) {
4636 binmax = 2;
4637 AliInfo("Put the binmax from 1 to 2 to enable the fit");
4638 }
4639 if (binmax >= nbins) {
4640 binmax = nbins-1;
4641 put = kFALSE;
4642 AliInfo("Put the binmax from nbins-1 to nbins-2 to enable the fit");
4643 }
4644 projPH->Fit("pol2","0MR","",TMath::Max(projPH->GetBinCenter(binmax-1),0.0),projPH->GetBinCenter(binmax+1));
4645 Float_t l3P1amf = projPH->GetFunction("pol2")->GetParameter(1);
4646 Float_t l3P2amf = projPH->GetFunction("pol2")->GetParameter(2);
4647 Float_t l3P1amfE = projPH->GetFunction("pol2")->GetParError(1);
4648 Float_t l3P2amfE = projPH->GetFunction("pol2")->GetParError(2);
daa7dc79 4649 if (TMath::Abs(l3P2amf) > 0.00000000001) {
55a288e5 4650 fPhd[1] = -(l3P1amf / (2 * l3P2amf));
4651 }
daa7dc79 4652 if((TMath::Abs(l3P1amf) > 0.0000000001) && (TMath::Abs(l3P2amf) > 0.000000001)){
3a0f6479 4653 fCurrentCoefE = (l3P1amfE/l3P1amf + l3P2amfE/l3P2amf)*fPhd[1];
55a288e5 4654 }
4655 if(fTakeTheMaxPH){
3a0f6479 4656 fCurrentCoefE2 = fCurrentCoefE;
55a288e5 4657 }
55a288e5 4658 // Drift region
4659 TH1D *pente = new TH1D("pente","pente",projPH->GetNbinsX(),0,(Float_t) limit);
4660 for (Int_t k = TMath::Min(binmax+4,projPH->GetNbinsX()); k < projPH->GetNbinsX(); k++) {
4661 pente->SetBinContent(k,(Double_t) (projPH->GetBinContent(k+1) - projPH->GetBinContent(k)));
4662 }
4663 binmin = 0;
4664 if(pente->GetEntries() > 0) binmin = (Int_t) pente->GetMinimumBin();
4665 if (binmin <= 1) {
4666 binmin = 2;
4667 AliInfo("Put the binmax from 1 to 2 to enable the fit");
4668 }
4669 if (binmin >= nbins) {
4670 binmin = nbins-1;
4671 put = kFALSE;
4672 AliInfo("Put the binmax from nbins-1 to nbins-2 to enable the fit");
4673 }
55a288e5 4674 pente->Fit("pol2"
4675 ,"0MR"
4676 ,""
4677 ,TMath::Max(pente->GetBinCenter(binmin-1), 0.0)
4678 ,TMath::Min(pente->GetBinCenter(binmin+1),(Double_t) limit));
4679 Float_t l3P1dr = pente->GetFunction("pol2")->GetParameter(1);
4680 Float_t l3P2dr = pente->GetFunction("pol2")->GetParameter(2);
4681 Float_t l3P1drE = pente->GetFunction("pol2")->GetParError(1);
4682 Float_t l3P2drE = pente->GetFunction("pol2")->GetParError(2);
daa7dc79 4683 if (TMath::Abs(l3P2dr) > 0.00000001) {
55a288e5 4684 fPhd[2] = -(l3P1dr / (2 * l3P2dr));
4685 }
daa7dc79 4686 if((TMath::Abs(l3P1dr) > 0.0000000001) && (TMath::Abs(l3P2dr) > 0.00000000001)){
3a0f6479 4687 fCurrentCoefE += (l3P1drE/l3P1dr + l3P2drE/l3P2dr)*fPhd[2];
55a288e5 4688 }
413153cb 4689 Float_t fPhdt0 = 0.0;
4690 Float_t t0Shift = 0.0;
4691 if(fTakeTheMaxPH) {
4692 fPhdt0 = fPhd[1];
4693 t0Shift = fT0Shift1;
4694 }
4695 else {
4696 fPhdt0 = fPhd[0];
4697 t0Shift = fT0Shift0;
4698 }
55a288e5 4699
4700 if ((fPhd[2] > fPhd[0]) &&
4701 (fPhd[2] > fPhd[1]) &&
4702 (fPhd[1] > fPhd[0]) &&
4703 (put)) {
3a0f6479 4704 fCurrentCoef[0] = (kDrWidth) / (fPhd[2]-fPhd[1]);
4705 fNumberFitSuccess++;
4706
55a288e5 4707 if (fPhdt0 >= 0.0) {
413153cb 4708 fCurrentCoef2[0] = (fPhdt0 - t0Shift) / widbins;
b88b6bcc 4709 if (fCurrentCoef2[0] < -3.0) {
64942b85 4710 fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
55a288e5 4711 }
4712 }
4713 else {
64942b85 4714 fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
55a288e5 4715 }
3a0f6479 4716
55a288e5 4717 }
4718 else {
3a0f6479 4719 fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
64942b85 4720 fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
55a288e5 4721 }
4722
3a0f6479 4723 if (fDebugLevel == 1) {
55a288e5 4724 TCanvas *cpentei = new TCanvas("cpentei","cpentei",50,50,600,800);
4725 cpentei->cd();
4726 projPH->Draw();
4727 line->SetLineColor(2);
4728 line->DrawLine(fPhd[0],0,fPhd[0],projPH->GetMaximum());
4729 line->DrawLine(fPhd[1],0,fPhd[1],projPH->GetMaximum());
4730 line->DrawLine(fPhd[2],0,fPhd[2],projPH->GetMaximum());
4731 AliInfo(Form("fPhd[0] (beginning of the signal): %f" ,(Float_t) fPhd[0]));
4732 AliInfo(Form("fPhd[1] (end of the amplification region): %f" ,(Float_t) fPhd[1]));
4733 AliInfo(Form("fPhd[2] (end of the drift region): %f" ,(Float_t) fPhd[2]));
3a0f6479 4734 AliInfo(Form("fVriftCoef[1] (with only the drift region(default)): %f",(Float_t) fCurrentCoef[0]));
55a288e5 4735 TCanvas *cpentei2 = new TCanvas("cpentei2","cpentei2",50,50,600,800);
4736 cpentei2->cd();
4737 pentea->Draw();
4738 TCanvas *cpentei3 = new TCanvas("cpentei3","cpentei3",50,50,600,800);
4739 cpentei3->cd();
4740 pente->Draw();
4741 }
3a0f6479 4742 else {
55a288e5 4743 delete pentea;
55a288e5 4744 delete pente;
4745 }
55a288e5 4746}
55a288e5 4747//_____________________________________________________________________________
3a0f6479 4748void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
55a288e5 4749{
4750 //
4751 // Slope methode but with polynomes de Lagrange
4752 //
6aafa7ea 4753
55a288e5 4754 // Constants
4755 const Float_t kDrWidth = AliTRDgeometry::DrThick();
3a0f6479 4756 Int_t binmax = 0;
4757 Int_t binmin = 0;
fdc15553 4758 //Double_t *x = new Double_t[5];
4759 //Double_t *y = new Double_t[5];
4760 Double_t x[5];
4761 Double_t y[5];
3a0f6479 4762 x[0] = 0.0;
4763 x[1] = 0.0;
4764 x[2] = 0.0;
4765 x[3] = 0.0;
4766 x[4] = 0.0;
4767 y[0] = 0.0;
4768 y[1] = 0.0;
4769 y[2] = 0.0;
4770 y[3] = 0.0;
4771 y[4] = 0.0;
4772 fPhd[0] = 0.0;
4773 fPhd[1] = 0.0;
4774 fPhd[2] = 0.0;
4775 Int_t ju = 0;
4776 fCurrentCoefE = 0.0;
4777 fCurrentCoefE2 = 1.0;
4778 fCurrentCoef[0] = 0.0;
4779 fCurrentCoef2[0] = 0.0;
55a288e5 4780 TLine *line = new TLine();
4781 TF1 * polynome = 0x0;
4782 TF1 * polynomea = 0x0;
4783 TF1 * polynomeb = 0x0;
3b0c1edc 4784 Double_t c0 = 0.0;
4785 Double_t c1 = 0.0;
4786 Double_t c2 = 0.0;
4787 Double_t c3 = 0.0;
4788 Double_t c4 = 0.0;
55a288e5 4789
4790 // Some variables
4791 TAxis *xpph = projPH->GetXaxis();
4792 Int_t nbins = xpph->GetNbins();
4793 Double_t lowedge = xpph->GetBinLowEdge(1);
4794 Double_t upedge = xpph->GetBinUpEdge(xpph->GetNbins());
4795 Double_t widbins = (upedge - lowedge) / nbins;
4796 Double_t limit = upedge + 0.5 * widbins;
4797
4798
4799 Bool_t put = kTRUE;
4800
4801 // Beginning of the signal
4802 TH1D *pentea = new TH1D("pentea","pentea",projPH->GetNbinsX(),0,(Float_t) limit);
4803 for (Int_t k = 1; k < projPH->GetNbinsX(); k++) {
4804 pentea->SetBinContent(k,(Double_t) (projPH->GetBinContent(k+1) - projPH->GetBinContent(k)));
4805 }
4806
4807 binmax = (Int_t) pentea->GetMaximumBin();
55a288e5 4808
4809 Double_t minnn = 0.0;
4810 Double_t maxxx = 0.0;
4811
3a0f6479 4812 Int_t kase = nbins-binmax;
4813
4814 switch(kase)
4815 {
4816 case 0:
4817 put = kFALSE;
4818 break;
4819 case 1:
4820 minnn = pentea->GetBinCenter(binmax-2);
4821 maxxx = pentea->GetBinCenter(binmax);
4822 x[0] = pentea->GetBinCenter(binmax-2);
4823 x[1] = pentea->GetBinCenter(binmax-1);
4824 x[2] = pentea->GetBinCenter(binmax);
4825 y[0] = pentea->GetBinContent(binmax-2);
4826 y[1] = pentea->GetBinContent(binmax-1);
4827 y[2] = pentea->GetBinContent(binmax);
3b0c1edc 4828 CalculPolynomeLagrange2(x,y,c0,c1,c2,c3,c4);
b2277aa2 4829 //AliInfo("At the limit for beginning!");
3a0f6479 4830 break;
4831 case 2:
4832 minnn = pentea->GetBinCenter(binmax-2);
4833 maxxx = pentea->GetBinCenter(binmax+1);
4834 x[0] = pentea->GetBinCenter(binmax-2);
4835 x[1] = pentea->GetBinCenter(binmax-1);
4836 x[2] = pentea->GetBinCenter(binmax);
4837 x[3] = pentea->GetBinCenter(binmax+1);
4838 y[0] = pentea->GetBinContent(binmax-2);
4839 y[1] = pentea->GetBinContent(binmax-1);
4840 y[2] = pentea->GetBinContent(binmax);
4841 y[3] = pentea->GetBinContent(binmax+1);
3b0c1edc 4842 CalculPolynomeLagrange3(x,y,c0,c1,c2,c3,c4);
3a0f6479 4843 break;
4844 default:
4845 switch(binmax){
4846 case 0:
4847 put = kFALSE;
4848 break;
4849 case 1:
4850 minnn = pentea->GetBinCenter(binmax);
4851 maxxx = pentea->GetBinCenter(binmax+2);
4852 x[0] = pentea->GetBinCenter(binmax);
4853 x[1] = pentea->GetBinCenter(binmax+1);
4854 x[2] = pentea->GetBinCenter(binmax+2);
4855 y[0] = pentea->GetBinContent(binmax);
4856 y[1] = pentea->GetBinContent(binmax+1);
4857 y[2] = pentea->GetBinContent(binmax+2);
3b0c1edc 4858 CalculPolynomeLagrange2(x,y,c0,c1,c2,c3,c4);
3a0f6479 4859 break;
4860 case 2:
4861 minnn = pentea->GetBinCenter(binmax-1);
4862 maxxx = pentea->GetBinCenter(binmax+2);
4863 x[0] = pentea->GetBinCenter(binmax-1);
4864 x[1] = pentea->GetBinCenter(binmax);
4865 x[2] = pentea->GetBinCenter(binmax+1);
4866 x[3] = pentea->GetBinCenter(binmax+2);
4867 y[0] = pentea->GetBinContent(binmax-1);
4868 y[1] = pentea->GetBinContent(binmax);
4869 y[2] = pentea->GetBinContent(binmax+1);
4870 y[3] = pentea->GetBinContent(binmax+2);
3b0c1edc 4871 CalculPolynomeLagrange3(x,y,c0,c1,c2,c3,c4);
3a0f6479 4872 break;
4873 default:
4874 minnn = pentea->GetBinCenter(binmax-2);
4875 maxxx = pentea->GetBinCenter(binmax+2);
4876 x[0] = pentea->GetBinCenter(binmax-2);
4877 x[1] = pentea->GetBinCenter(binmax-1);
4878 x[2] = pentea->GetBinCenter(binmax);
4879 x[3] = pentea->GetBinCenter(binmax+1);
4880 x[4] = pentea->GetBinCenter(binmax+2);
4881 y[0] = pentea->GetBinContent(binmax-2);
4882 y[1] = pentea->GetBinContent(binmax-1);
4883 y[2] = pentea->GetBinContent(binmax);
4884 y[3] = pentea->GetBinContent(binmax+1);
4885 y[4] = pentea->GetBinContent(binmax+2);
3b0c1edc 4886 CalculPolynomeLagrange4(x,y,c0,c1,c2,c3,c4);
3a0f6479 4887 break;
4888 }
4889 break;
55a288e5 4890 }
3a0f6479 4891
4892
55a288e5 4893 if(put) {
4894 polynomeb = new TF1("polb","[0]+[1]*x+[2]*x*x+[3]*x*x*x+[4]*x*x*x*x",minnn,maxxx);
3b0c1edc 4895 polynomeb->SetParameters(c0,c1,c2,c3,c4);
3a0f6479 4896
55a288e5 4897 Double_t step = (maxxx-minnn)/10000;
4898 Double_t l = minnn;
4899 Double_t maxvalue = 0.0;
4900 Double_t placemaximum = minnn;
4901 for(Int_t o = 0; o < 10000; o++){
4902 if(o == 0) maxvalue = polynomeb->Eval(l);
4903 if(maxvalue < (polynomeb->Eval(l))){
4904 maxvalue = polynomeb->Eval(l);
4905 placemaximum = l;
4906 }
4907 l += step;
4908 }
4909 fPhd[0] = placemaximum;
4910 }
55a288e5 4911
4912 // Amplification region
4913 binmax = 0;
4914 ju = 0;
4915 for (Int_t kbin = 1; kbin < projPH->GetNbinsX(); kbin ++) {
3a0f6479 4916 if (((projPH->GetBinContent(kbin+1) - projPH->GetBinContent(kbin)) <= 0.0) && (ju == 0) && (kbin > (fPhd[0]/widbins))) {
55a288e5 4917 binmax = kbin;
4918 ju = 1;
4919 }
4920 }
3a0f6479 4921
55a288e5 4922 Double_t minn = 0.0;
4923 Double_t maxx = 0.0;
3a0f6479 4924 x[0] = 0.0;
4925 x[1] = 0.0;
4926 x[2] = 0.0;
4927 x[3] = 0.0;
4928 x[4] = 0.0;
4929 y[0] = 0.0;
4930 y[1] = 0.0;
4931 y[2] = 0.0;
4932 y[3] = 0.0;
4933 y[4] = 0.0;
4934
4935 Int_t kase1 = nbins - binmax;
55a288e5 4936
4937 //Determination of minn and maxx
4938 //case binmax = nbins
4939 //pol2
3a0f6479 4940 switch(kase1)
4941 {
4942 case 0:
4943 minn = projPH->GetBinCenter(binmax-2);
4944 maxx = projPH->GetBinCenter(binmax);
4945 x[0] = projPH->GetBinCenter(binmax-2);
4946 x[1] = projPH->GetBinCenter(binmax-1);
4947 x[2] = projPH->GetBinCenter(binmax);
4948 y[0] = projPH->GetBinContent(binmax-2);
4949 y[1] = projPH->GetBinContent(binmax-1);
4950 y[2] = projPH->GetBinContent(binmax);
3b0c1edc 4951 CalculPolynomeLagrange2(x,y,c0,c1,c2,c3,c4);
3a0f6479 4952 //AliInfo("At the limit for the drift!");
4953 break;
4954 case 1:
4955 minn = projPH->GetBinCenter(binmax-2);
4956 maxx = projPH->GetBinCenter(binmax+1);
4957 x[0] = projPH->GetBinCenter(binmax-2);
4958 x[1] = projPH->GetBinCenter(binmax-1);
4959 x[2] = projPH->GetBinCenter(binmax);
4960 x[3] = projPH->GetBinCenter(binmax+1);
4961 y[0] = projPH->GetBinContent(binmax-2);
4962 y[1] = projPH->GetBinContent(binmax-1);
4963 y[2] = projPH->GetBinContent(binmax);
4964 y[3] = projPH->GetBinContent(binmax+1);
3b0c1edc 4965 CalculPolynomeLagrange3(x,y,c0,c1,c2,c3,c4);
3a0f6479 4966 break;
4967 default:
4968 switch(binmax)
4969 {
4970 case 0:
4971 put = kFALSE;
4972 break;
4973 case 1:
4974 minn = projPH->GetBinCenter(binmax);
4975 maxx = projPH->GetBinCenter(binmax+2);
4976 x[0] = projPH->GetBinCenter(binmax);
4977 x[1] = projPH->GetBinCenter(binmax+1);
4978 x[2] = projPH->GetBinCenter(binmax+2);
4979 y[0] = projPH->GetBinContent(binmax);
4980 y[1] = projPH->GetBinContent(binmax+1);
4981 y[2] = projPH->GetBinContent(binmax+2);
3b0c1edc 4982 CalculPolynomeLagrange2(x,y,c0,c1,c2,c3,c4);
3a0f6479 4983 break;
4984 case 2:
4985 minn = projPH->GetBinCenter(binmax-1);
4986 maxx = projPH->GetBinCenter(binmax+2);
4987 x[0] = projPH->GetBinCenter(binmax-1);
4988 x[1] = projPH->GetBinCenter(binmax);
4989 x[2] = projPH->GetBinCenter(binmax+1);
4990 x[3] = projPH->GetBinCenter(binmax+2);
4991 y[0] = projPH->GetBinContent(binmax-1);
4992 y[1] = projPH->GetBinContent(binmax);
4993 y[2] = projPH->GetBinContent(binmax+1);
4994 y[3] = projPH->GetBinContent(binmax+2);
3b0c1edc 4995 CalculPolynomeLagrange3(x,y,c0,c1,c2,c3,c4);
3a0f6479 4996 break;
4997 default:
4998 minn = projPH->GetBinCenter(binmax-2);
4999 maxx = projPH->GetBinCenter(binmax+2);
5000 x[0] = projPH->GetBinCenter(binmax-2);
5001 x[1] = projPH->GetBinCenter(binmax-1);
5002 x[2] = projPH->GetBinCenter(binmax);
5003 x[3] = projPH->GetBinCenter(binmax+1);
5004 x[4] = projPH->GetBinCenter(binmax+2);
5005 y[0] = projPH->GetBinContent(binmax-2);
5006 y[1] = projPH->GetBinContent(binmax-1);
5007 y[2] = projPH->GetBinContent(binmax);
5008 y[3] = projPH->GetBinContent(binmax+1);
5009 y[4] = projPH->GetBinContent(binmax+2);
3b0c1edc 5010 CalculPolynomeLagrange4(x,y,c0,c1,c2,c3,c4);
3a0f6479 5011 break;
5012 }
5013 break;
55a288e5 5014 }
3a0f6479 5015
55a288e5 5016 if(put) {
5017 polynomea = new TF1("pola","[0]+[1]*x+[2]*x*x+[3]*x*x*x+[4]*x*x*x*x",minn,maxx);
3b0c1edc 5018 polynomea->SetParameters(c0,c1,c2,c3,c4);
3a0f6479 5019
55a288e5 5020 Double_t step = (maxx-minn)/1000;
5021 Double_t l = minn;
5022 Double_t maxvalue = 0.0;
5023 Double_t placemaximum = minn;
5024 for(Int_t o = 0; o < 1000; o++){
5025 if(o == 0) maxvalue = polynomea->Eval(l);
5026 if(maxvalue < (polynomea->Eval(l))){
5027 maxvalue = polynomea->Eval(l);
5028 placemaximum = l;
5029 }
5030 l += step;
5031 }
5032 fPhd[1] = placemaximum;
5033 }
5034
55a288e5 5035 // Drift region
5036 TH1D *pente = new TH1D("pente","pente", projPH->GetNbinsX(),0,(Float_t) limit);
5037 for (Int_t k = TMath::Min(binmax+4, projPH->GetNbinsX()); k < projPH->GetNbinsX(); k++) {
5038 pente->SetBinContent(k,(Double_t) (projPH->GetBinContent(k+1) - projPH->GetBinContent(k)));
5039 }
5040 binmin = 0;
5041 if(pente->GetEntries() > 0) binmin = (Int_t) pente->GetMinimumBin();
5042
5043 //should not happen
5044 if (binmin <= 1) {
5045 binmin = 2;
5046 put = 1;
b2277aa2 5047 //AliInfo("Put the binmax from 1 to 2 to enable the fit");
55a288e5 5048 }
5049
5050 //check
64942b85 5051 if((projPH->GetBinContent(binmin)-projPH->GetBinError(binmin)) < (projPH->GetBinContent(binmin+1))) {
b2277aa2 5052 //AliInfo("Too many fluctuations at the end!");
64942b85 5053 put = kFALSE;
5054 }
5055 if((projPH->GetBinContent(binmin)+projPH->GetBinError(binmin)) > (projPH->GetBinContent(binmin-1))) {
b2277aa2 5056 //AliInfo("Too many fluctuations at the end!");
64942b85 5057 put = kFALSE;
5058 }
daa7dc79 5059 if(TMath::Abs(pente->GetBinContent(binmin+1)) <= 0.0000000000001){
b2277aa2 5060 //AliInfo("No entries for the next bin!");
64942b85 5061 pente->SetBinContent(binmin,0);
5062 if(pente->GetEntries() > 0) binmin = (Int_t) pente->GetMinimumBin();
5063 }
5064
3a0f6479 5065
5066 x[0] = 0.0;
5067 x[1] = 0.0;
5068 x[2] = 0.0;
5069 x[3] = 0.0;
5070 x[4] = 0.0;
5071 y[0] = 0.0;
5072 y[1] = 0.0;
5073 y[2] = 0.0;
5074 y[3] = 0.0;
5075 y[4] = 0.0;
55a288e5 5076 Double_t min = 0.0;
5077 Double_t max = 0.0;
5078 Bool_t case1 = kFALSE;
5079 Bool_t case2 = kFALSE;
5080 Bool_t case4 = kFALSE;
5081
5082 //Determination of min and max
5083 //case binmin <= nbins-3
5084 //pol4 case 3
5085 if((binmin <= (nbins-3)) && ((binmin-2) >= TMath::Min(binmax+4, projPH->GetNbinsX()))){
5086 min = pente->GetBinCenter(binmin-2);
5087 max = pente->GetBinCenter(binmin+2);
5088 x[0] = pente->GetBinCenter(binmin-2);
5089 x[1] = pente->GetBinCenter(binmin-1);
5090 x[2] = pente->GetBinCenter(binmin);
5091 x[3] = pente->GetBinCenter(binmin+1);
5092 x[4] = pente->GetBinCenter(binmin+2);
5093 y[0] = pente->GetBinContent(binmin-2);
5094 y[1] = pente->GetBinContent(binmin-1);
5095 y[2] = pente->GetBinContent(binmin);
5096 y[3] = pente->GetBinContent(binmin+1);
5097 y[4] = pente->GetBinContent(binmin+2);
5098 //Calcul the polynome de Lagrange
3b0c1edc 5099 CalculPolynomeLagrange4(x,y,c0,c1,c2,c3,c4);
55a288e5 5100 //richtung +/-
5101 if((pente->GetBinContent(binmin+2) <= pente->GetBinContent(binmin+1)) &&
64942b85 5102 (pente->GetBinContent(binmin-2) <= pente->GetBinContent(binmin-1))) {
5103 //AliInfo("polynome 4 false 1");
5104 put = kFALSE;
5105 }
55a288e5 5106 if(((binmin+3) <= (nbins-1)) &&
5107 (pente->GetBinContent(binmin+3) <= pente->GetBinContent(binmin+2)) &&
5108 ((binmin-3) >= TMath::Min(binmax+4, projPH->GetNbinsX())) &&
64942b85 5109 (pente->GetBinContent(binmin-3) <= pente->GetBinContent(binmin-2))) {
b2277aa2 5110 //AliInfo("polynome 4 false 2");
64942b85 5111 put = kFALSE;
5112 }
5113 // poly 3
55a288e5 5114 if((pente->GetBinContent(binmin+2) <= pente->GetBinContent(binmin+1)) &&
64942b85 5115 (pente->GetBinContent(binmin-2) > pente->GetBinContent(binmin-1))) {
5116 //AliInfo("polynome 4 case 1");
5117 case1 = kTRUE;
5118 }
55a288e5 5119 if((pente->GetBinContent(binmin+2) > pente->GetBinContent(binmin+1)) &&
64942b85 5120 (pente->GetBinContent(binmin-2) <= pente->GetBinContent(binmin-1))) {
5121 //AliInfo("polynome 4 case 4");
5122 case4 = kTRUE;
5123 }
5124
55a288e5 5125 }
5126 //case binmin = nbins-2
5127 //pol3 case 1
5128 if(((binmin == (nbins-2)) && ((binmin-2) >= TMath::Min(binmax+4, projPH->GetNbinsX()))) ||
5129 (case1)){
5130 min = pente->GetBinCenter(binmin-2);
5131 max = pente->GetBinCenter(binmin+1);
5132 x[0] = pente->GetBinCenter(binmin-2);
5133 x[1] = pente->GetBinCenter(binmin-1);
5134 x[2] = pente->GetBinCenter(binmin);
5135 x[3] = pente->GetBinCenter(binmin+1);
5136 y[0] = pente->GetBinContent(binmin-2);
5137 y[1] = pente->GetBinContent(binmin-1);
5138 y[2] = pente->GetBinContent(binmin);
5139 y[3] = pente->GetBinContent(binmin+1);
5140 //Calcul the polynome de Lagrange
3b0c1edc 5141 CalculPolynomeLagrange3(x,y,c0,c1,c2,c3,c4);
55a288e5 5142 //richtung +: nothing
5143 //richtung -
64942b85 5144 if((pente->GetBinContent(binmin-2) <= pente->GetBinContent(binmin-1))) {
5145 //AliInfo("polynome 3- case 2");
5146 case2 = kTRUE;
5147 }
55a288e5 5148 }
5149 //pol3 case 4
5150 if(((binmin <= (nbins-3)) && ((binmin-1) == TMath::Min(binmax+4, projPH->GetNbinsX()))) ||
5151 (case4)){
5152 min = pente->GetBinCenter(binmin-1);
5153 max = pente->GetBinCenter(binmin+2);
5154 x[0] = pente->GetBinCenter(binmin-1);
5155 x[1] = pente->GetBinCenter(binmin);
5156 x[2] = pente->GetBinCenter(binmin+1);
5157 x[3] = pente->GetBinCenter(binmin+2);
5158 y[0] = pente->GetBinContent(binmin-1);
5159 y[1] = pente->GetBinContent(binmin);
5160 y[2] = pente->GetBinContent(binmin+1);
5161 y[3] = pente->GetBinContent(binmin+2);
5162 //Calcul the polynome de Lagrange
3b0c1edc 5163 CalculPolynomeLagrange3(x,y,c0,c1,c2,c3,c4);
55a288e5 5164 //richtung +
64942b85 5165 if((pente->GetBinContent(binmin+2) <= pente->GetBinContent(binmin+1))) {
5166 //AliInfo("polynome 3+ case 2");
5167 case2 = kTRUE;
5168 }
55a288e5 5169 }
5170 //pol2 case 5
5171 if((binmin <= (nbins-3)) && (binmin == TMath::Min(binmax+4, projPH->GetNbinsX()))){
5172 min = pente->GetBinCenter(binmin);
5173 max = pente->GetBinCenter(binmin+2);
5174 x[0] = pente->GetBinCenter(binmin);
5175 x[1] = pente->GetBinCenter(binmin+1);
5176 x[2] = pente->GetBinCenter(binmin+2);
5177 y[0] = pente->GetBinContent(binmin);
5178 y[1] = pente->GetBinContent(binmin+1);
5179 y[2] = pente->GetBinContent(binmin+2);
5180 //Calcul the polynome de Lagrange
3b0c1edc 5181 CalculPolynomeLagrange2(x,y,c0,c1,c2,c3,c4);
55a288e5 5182 //richtung +
64942b85 5183 if((pente->GetBinContent(binmin+2) <= pente->GetBinContent(binmin+1))) {
5184 //AliInfo("polynome 2+ false");
5185 put = kFALSE;
5186 }
55a288e5 5187 }
5188 //pol2 case 2
5189 if(((binmin == (nbins-2)) && ((binmin-1) == TMath::Min(binmax+4, projPH->GetNbinsX()))) ||
5190 (case2)){
5191 min = pente->GetBinCenter(binmin-1);
5192 max = pente->GetBinCenter(binmin+1);
5193 x[0] = pente->GetBinCenter(binmin-1);
5194 x[1] = pente->GetBinCenter(binmin);
5195 x[2] = pente->GetBinCenter(binmin+1);
5196 y[0] = pente->GetBinContent(binmin-1);
5197 y[1] = pente->GetBinContent(binmin);
5198 y[2] = pente->GetBinContent(binmin+1);
5199 //Calcul the polynome de Lagrange
3b0c1edc 5200 CalculPolynomeLagrange2(x,y,c0,c1,c2,c3,c4);
55a288e5 5201 //richtung +: nothing
5202 //richtung -: nothing
5203 }
5204 //case binmin = nbins-1
5205 //pol2 case 0
5206 if((binmin == (nbins-1)) && ((binmin-2) >= TMath::Min(binmax+4, projPH->GetNbinsX()))){
5207 min = pente->GetBinCenter(binmin-2);
5208 max = pente->GetBinCenter(binmin);
5209 x[0] = pente->GetBinCenter(binmin-2);
5210 x[1] = pente->GetBinCenter(binmin-1);
5211 x[2] = pente->GetBinCenter(binmin);
5212 y[0] = pente->GetBinContent(binmin-2);
5213 y[1] = pente->GetBinContent(binmin-1);
5214 y[2] = pente->GetBinContent(binmin);
5215 //Calcul the polynome de Lagrange
3b0c1edc 5216 CalculPolynomeLagrange2(x,y,c0,c1,c2,c3,c4);
3a0f6479 5217 //AliInfo("At the limit for the drift!");
55a288e5 5218 //fluctuation too big!
5219 //richtung +: nothing
5220 //richtung -
64942b85 5221 if((pente->GetBinContent(binmin-2) <= pente->GetBinContent(binmin-1))) {
5222 //AliInfo("polynome 2- false ");
5223 put = kFALSE;
5224 }
55a288e5 5225 }
5226 if((binmin == (nbins-1)) && ((binmin-2) < TMath::Min(binmax+4, projPH->GetNbinsX()))) {
5227 put = kFALSE;
b2277aa2 5228 //AliInfo("At the limit for the drift and not usable!");
55a288e5 5229 }
5230
5231 //pass
5232 if((binmin == (nbins-2)) && ((binmin-1) < TMath::Min(binmax+4, projPH->GetNbinsX()))){
5233 put = kFALSE;
b2277aa2 5234 //AliInfo("For the drift...problem!");
55a288e5 5235 }
55a288e5 5236 //pass but should not happen
64942b85 5237 if((binmin <= (nbins-3)) && (binmin < TMath::Min(binmax+6, projPH->GetNbinsX()))){
55a288e5 5238 put = kFALSE;
b2277aa2 5239 //AliInfo("For the drift...problem!");
55a288e5 5240 }
3a0f6479 5241
55a288e5 5242 if(put) {
5243 polynome = new TF1("pol","[0]+[1]*x+[2]*x*x+[3]*x*x*x+[4]*x*x*x*x",min,max);
3b0c1edc 5244 polynome->SetParameters(c0,c1,c2,c3,c4);
55a288e5 5245 //AliInfo(Form("GetMinimum of the function %f",polynome->GetMinimumX()));
5246 Double_t step = (max-min)/1000;
5247 Double_t l = min;
5248 Double_t minvalue = 0.0;
5249 Double_t placeminimum = min;
5250 for(Int_t o = 0; o < 1000; o++){
5251 if(o == 0) minvalue = polynome->Eval(l);
5252 if(minvalue > (polynome->Eval(l))){
5253 minvalue = polynome->Eval(l);
5254 placeminimum = l;
5255 }
5256 l += step;
5257 }
5258 fPhd[2] = placeminimum;
5259 }
64942b85 5260 //printf("La fin %d\n",((Int_t)(fPhd[2]*10.0))+2);
5261 if((((Int_t)(fPhd[2]*10.0))+2) >= projPH->GetNbinsX()) fPhd[2] = 0.0;
5262 if(((((Int_t)(fPhd[2]*10.0))+2) < projPH->GetNbinsX()) && (projPH->GetBinContent(((Int_t)(fPhd[2]*10.0))+2)==0)) fPhd[2] = 0.0;
3a0f6479 5263
413153cb 5264 Float_t fPhdt0 = 0.0;
5265 Float_t t0Shift = 0.0;
5266 if(fTakeTheMaxPH) {
5267 fPhdt0 = fPhd[1];
5268 t0Shift = fT0Shift1;
5269 }
5270 else {
5271 fPhdt0 = fPhd[0];
5272 t0Shift = fT0Shift0;
5273 }
55a288e5 5274
5275 if ((fPhd[2] > fPhd[0]) &&
5276 (fPhd[2] > fPhd[1]) &&
5277 (fPhd[1] > fPhd[0]) &&
5278 (put)) {
3a0f6479 5279 fCurrentCoef[0] = (kDrWidth) / (fPhd[2]-fPhd[1]);
6210514c 5280 if(fCurrentCoef[0] > 2.5) fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
6aafa7ea 5281 else fNumberFitSuccess++;
55a288e5 5282 if (fPhdt0 >= 0.0) {
413153cb 5283 fCurrentCoef2[0] = (fPhdt0 - t0Shift) / widbins;
b88b6bcc 5284 //printf("Value of timeoffset %f\n",fCurrentCoef2[0]);
5285 if (fCurrentCoef2[0] < -3.0) {
64942b85 5286 fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
55a288e5 5287 }
5288 }
5289 else {
64942b85 5290 fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
55a288e5 5291 }
5292 }
5293 else {
b88b6bcc 5294 ////printf("Put default %f\n",-TMath::Abs(fCurrentCoef[1]));
6210514c 5295 fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
5296
64942b85 5297 if((fPhd[1] > fPhd[0]) &&
5298 (put)) {
5299 if (fPhdt0 >= 0.0) {
5300 fCurrentCoef2[0] = (fPhdt0 - t0Shift) / widbins;
b88b6bcc 5301 if (fCurrentCoef2[0] < -3.0) {
64942b85 5302 fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
5303 }
5304 }
5305 else {
5306 fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
5307 }
5308 }
5309 else{
64942b85 5310 fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
5311 //printf("Fit failed!\n");
5312 }
55a288e5 5313 }
5314
3a0f6479 5315 if (fDebugLevel == 1) {
55a288e5 5316 TCanvas *cpentei = new TCanvas("cpentei","cpentei",50,50,600,800);
5317 cpentei->cd();
5318 projPH->Draw();
5319 line->SetLineColor(2);
5320 line->DrawLine(fPhd[0],0,fPhd[0],projPH->GetMaximum());
5321 line->DrawLine(fPhd[1],0,fPhd[1],projPH->GetMaximum());
5322 line->DrawLine(fPhd[2],0,fPhd[2],projPH->GetMaximum());
5323 AliInfo(Form("fPhd[0] (beginning of the signal): %f" ,(Float_t) fPhd[0]));
5324 AliInfo(Form("fPhd[1] (end of the amplification region): %f" ,(Float_t) fPhd[1]));
5325 AliInfo(Form("fPhd[2] (end of the drift region): %f" ,(Float_t) fPhd[2]));
3a0f6479 5326 AliInfo(Form("fVriftCoef[3] (with only the drift region(default)): %f",(Float_t) fCurrentCoef[0]));
55a288e5 5327 TCanvas *cpentei2 = new TCanvas("cpentei2","cpentei2",50,50,600,800);
5328 cpentei2->cd();
5329 pentea->Draw();
5330 TCanvas *cpentei3 = new TCanvas("cpentei3","cpentei3",50,50,600,800);
5331 cpentei3->cd();
5332 pente->Draw();
5333 }
3a0f6479 5334 else {
a987273c 5335 delete pentea;
5336 delete pente;
1ca79a00 5337 if(polynome) delete polynome;
5338 if(polynomea) delete polynomea;
5339 if(polynomeb) delete polynomeb;
fdc15553 5340 //if(x) delete [] x;
5341 //if(y) delete [] y;
1ca79a00 5342 if(line) delete line;
5343
55a288e5 5344 }
64942b85 5345
5346 //Provisoire
5347 //if(fCurrentCoef[0] > 1.7) fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
5348 //if((fCurrentCoef2[0] > 2.6) || (fCurrentCoef2[0] < 2.1)) fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
b88b6bcc 5349 //printf("Value of timeoffset final %f\n",fCurrentCoef2[0]);
55a288e5 5350 projPH->SetDirectory(0);
5351
5352}
5353
5354//_____________________________________________________________________________
5355void AliTRDCalibraFit::FitPH(TH1* projPH, Int_t idect)
5356{
5357 //
5358 // Fit methode for the drift velocity
5359 //
5360
5361 // Constants
5362 const Float_t kDrWidth = AliTRDgeometry::DrThick();
5363
5364 // Some variables
5365 TAxis *xpph = projPH->GetXaxis();
5366 Double_t upedge = xpph->GetBinUpEdge(xpph->GetNbins());
5367
5368 TF1 *fPH = new TF1("fPH",AliTRDCalibraFit::PH,-0.05,3.2,6);
5369 fPH->SetParameter(0,0.469); // Scaling
5370 fPH->SetParameter(1,0.18); // Start
5371 fPH->SetParameter(2,0.0857325); // AR
5372 fPH->SetParameter(3,1.89); // DR
5373 fPH->SetParameter(4,0.08); // QA/QD
5374 fPH->SetParameter(5,0.0); // Baseline
5375
5376 TLine *line = new TLine();
5377
3a0f6479 5378 fCurrentCoef[0] = 0.0;
5379 fCurrentCoef2[0] = 0.0;
5380 fCurrentCoefE = 0.0;
5381 fCurrentCoefE2 = 0.0;
55a288e5 5382
5383 if (idect%fFitPHPeriode == 0) {
5384
3a0f6479 5385 AliInfo(Form("The detector %d will be fitted",idect));
55a288e5 5386 fPH->SetParameter(0,(projPH->Integral()-(projPH->GetBinContent(1)*projPH->GetNbinsX())) * 0.00028); // Scaling
5387 fPH->SetParameter(1,fPhd[0] - 0.1); // Start
5388 fPH->SetParameter(2,fPhd[1] - fPhd[0]); // AR
5389 fPH->SetParameter(3,fPhd[2] - fPhd[1]); // DR
5390 fPH->SetParameter(4,0.225); // QA/QD
5391 fPH->SetParameter(5,(Float_t) projPH->GetBinContent(1));
5392
3a0f6479 5393 if (fDebugLevel != 1) {
55a288e5 5394 projPH->Fit(fPH,"0M","",0.0,upedge);
5395 }
3a0f6479 5396 else {
55a288e5 5397 TCanvas *cpente = new TCanvas("cpente","cpente",50,50,600,800);
5398 cpente->cd();
5399 projPH->Fit(fPH,"M+","",0.0,upedge);
5400 projPH->Draw("E0");
5401 line->SetLineColor(4);
5402 line->DrawLine(fPH->GetParameter(1)
5403 ,0
5404 ,fPH->GetParameter(1)
5405 ,projPH->GetMaximum());
5406 line->DrawLine(fPH->GetParameter(1)+fPH->GetParameter(2)
5407 ,0
5408 ,fPH->GetParameter(1)+fPH->GetParameter(2)
5409 ,projPH->GetMaximum());
5410 line->DrawLine(fPH->GetParameter(1)+fPH->GetParameter(2)+fPH->GetParameter(3)
5411 ,0
5412 ,fPH->GetParameter(1)+fPH->GetParameter(2)+fPH->GetParameter(3)
5413 ,projPH->GetMaximum());
5414 }
5415
5416 if (fPH->GetParameter(3) != 0) {
3a0f6479 5417 fNumberFitSuccess++;
5418 fCurrentCoef[0] = kDrWidth / (fPH->GetParameter(3));
5419 fCurrentCoefE = (fPH->GetParError(3)/fPH->GetParameter(3))*fCurrentCoef[0];
5420 fCurrentCoef2[0] = fPH->GetParameter(1);
5421 fCurrentCoefE2 = fPH->GetParError(1);
55a288e5 5422 }
5423 else {
3a0f6479 5424 fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
64942b85 5425 fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
55a288e5 5426 }
3a0f6479 5427
55a288e5 5428 }
55a288e5 5429 else {
5430
3a0f6479 5431 // Put the default value
5432 fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
64942b85 5433 fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
55a288e5 5434 }
5435
3a0f6479 5436 if (fDebugLevel != 1) {
55a288e5 5437 delete fPH;
5438 }
5439
5440}
55a288e5 5441//_____________________________________________________________________________
3a0f6479 5442Bool_t AliTRDCalibraFit::FitPRFGausMI(Double_t *arraye, Double_t *arraym, Double_t *arrayme, Int_t nBins, Float_t xMin, Float_t xMax)
55a288e5 5443{
5444 //
5445 // Fit methode for the sigma of the pad response function
5446 //
3a0f6479 5447
5448 TVectorD param(3);
55a288e5 5449
3a0f6479 5450 fCurrentCoef[0] = 0.0;
5451 fCurrentCoefE = 0.0;
5452
5453 Double_t ret = FitGausMI(arraye, arraym, arrayme, nBins, xMin, xMax,&param);
5454
daa7dc79 5455 if(TMath::Abs(ret+4) <= 0.000000001){
3a0f6479 5456 fCurrentCoef[0] = -fCurrentCoef[1];
5457 return kFALSE;
5458 }
5459 else {
5460 fNumberFitSuccess++;
5461 fCurrentCoef[0] = param[2];
5462 fCurrentCoefE = ret;
5463 return kTRUE;
5464 }
5465}
5466//_____________________________________________________________________________
7bce990c 5467Double_t AliTRDCalibraFit::FitGausMI(Double_t *arraye, Double_t *arraym, Double_t *arrayme, Int_t nBins, Float_t xMin, Float_t xMax, TVectorD *param, Bool_t bError)
3a0f6479 5468{
5469 //
5470 // Fit methode for the sigma of the pad response function
5471 //
5472
5473 //We should have at least 3 points
5474 if(nBins <=3) return -4.0;
5475
5476 TLinearFitter fitter(3,"pol2");
5477 fitter.StoreData(kFALSE);
5478 fitter.ClearPoints();
5479 TVectorD par(3);
5480 Float_t binWidth = (xMax-xMin)/(Float_t)nBins;
5481 Float_t entries = 0;
5482 Int_t nbbinwithentries = 0;
5483 for (Int_t i=0; i<nBins; i++){
5484 entries+=arraye[i];
5485 if(arraye[i] > 15) nbbinwithentries++;
5486 //printf("entries for i %d: %f\n",i,arraye[i]);
5487 }
5488 if ((entries<700) || (nbbinwithentries < ((Int_t)(nBins/2)))) return -4;
5489 //printf("entries %f\n",entries);
5490 //printf("nbbinwithentries %d\n",nbbinwithentries);
5491
5492 Int_t npoints=0;
5493 Float_t errorm = 0.0;
5494 Float_t errorn = 0.0;
5495 Float_t error = 0.0;
5496
5497 //
5498 for (Int_t ibin=0;ibin<nBins; ibin++){
5499 Float_t entriesI = arraye[ibin];
5500 Float_t valueI = arraym[ibin];
5501 Double_t xcenter = 0.0;
5502 Float_t val = 0.0;
5503 if ((entriesI>15) && (valueI>0.0)){
5504 xcenter = xMin+(ibin+0.5)*binWidth;
5505 errorm = 0.0;
5506 errorn = 0.0;
5507 error = 0.0;
7bce990c 5508 if(!bError){
3a0f6479 5509 if((valueI + 0.01) > 0.0) errorm = TMath::Log((valueI + 0.01)/valueI);
5510 if((valueI - 0.01) > 0.0) errorn = TMath::Log((valueI - 0.01)/valueI);
5511 error = TMath::Max(TMath::Abs(errorm),TMath::Abs(errorn));
5512 }
5513 else{
5514 if((valueI + arrayme[ibin]) > 0.0) errorm = TMath::Log((valueI + arrayme[ibin])/valueI);
5515 if((valueI - arrayme[ibin]) > 0.0) errorn = TMath::Log((valueI - arrayme[ibin])/valueI);
5516 error = TMath::Max(TMath::Abs(errorm),TMath::Abs(errorn));
5517 }
daa7dc79 5518 if(TMath::Abs(error) < 0.000000001) continue;
3a0f6479 5519 val = TMath::Log(Float_t(valueI));
5520 fitter.AddPoint(&xcenter,val,error);
5521 npoints++;
5522 }
5523
5524 if(fDebugLevel > 1){
55a288e5 5525
3a0f6479 5526 if ( !fDebugStreamer ) {
5527 //debug stream
5528 TDirectory *backup = gDirectory;
4aad967c 5529 fDebugStreamer = new TTreeSRedirector("TRDDebugFitPRF.root");
3a0f6479 5530 if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
5531 }
5532
5533 Int_t detector = fCountDet;
053767a4 5534 Int_t layer = GetLayer(fCountDet);
3a0f6479 5535 Int_t group = ibin;
5536
5537 (* fDebugStreamer) << "FitGausMIFill"<<
5538 "detector="<<detector<<
053767a4 5539 "layer="<<layer<<
3a0f6479 5540 "nbins="<<nBins<<
5541 "group="<<group<<
5542 "entriesI="<<entriesI<<
5543 "valueI="<<valueI<<
5544 "val="<<val<<
5545 "xcenter="<<xcenter<<
5546 "errorm="<<errorm<<
5547 "errorn="<<errorn<<
5548 "error="<<error<<
7bce990c 5549 "bError="<<bError<<
3a0f6479 5550 "\n";
5551 }
5552
5553 }
5554
5555 if(npoints <=3) return -4.0;
5556
5557 Double_t chi2 = 0;
5558 if (npoints>3){
5559 fitter.Eval();
5560 fitter.GetParameters(par);
5561 chi2 = fitter.GetChisquare()/Float_t(npoints);
55a288e5 5562
3a0f6479 5563
5564 if (!param) param = new TVectorD(3);
daa7dc79 5565 if(TMath::Abs(par[2]) <= 0.000000001) return -4.0;
3a0f6479 5566 Double_t x = TMath::Sqrt(TMath::Abs(-2*par[2]));
5567 Double_t deltax = (fitter.GetParError(2))/x;
5568 Double_t errorparam2 = TMath::Abs(deltax)/(x*x);
5569 chi2 = errorparam2;
55a288e5 5570
3a0f6479 5571 (*param)[1] = par[1]/(-2.*par[2]);
5572 (*param)[2] = 1./TMath::Sqrt(TMath::Abs(-2.*par[2]));
5573 Double_t lnparam0 = par[0]+ par[1]* (*param)[1] + par[2]*(*param)[1]*(*param)[1];
5574 if ( lnparam0>307 ) return -4;
5575 (*param)[0] = TMath::Exp(lnparam0);
5576
5577 if(fDebugLevel > 1){
5578
5579 if ( !fDebugStreamer ) {
5580 //debug stream
5581 TDirectory *backup = gDirectory;
4aad967c 5582 fDebugStreamer = new TTreeSRedirector("TRDDebugFitPRF.root");
3a0f6479 5583 if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
5584 }
5585
5586 Int_t detector = fCountDet;
053767a4 5587 Int_t layer = GetLayer(fCountDet);
3a0f6479 5588
5589
5590 (* fDebugStreamer) << "FitGausMIFit"<<
5591 "detector="<<detector<<
053767a4 5592 "layer="<<layer<<
3a0f6479 5593 "nbins="<<nBins<<
5594 "errorsigma="<<chi2<<
5595 "mean="<<(*param)[1]<<
5596 "sigma="<<(*param)[2]<<
5597 "constant="<<(*param)[0]<<
5598 "\n";
5599 }
5600 }
5601
5602 if((chi2/(*param)[2]) > 0.1){
7bce990c 5603 if(bError){
3a0f6479 5604 chi2 = FitGausMI(arraye,arraym,arrayme,nBins,xMin,xMax,param,kFALSE);
5605 }
5606 else return -4.0;
55a288e5 5607 }
3a0f6479 5608
5609 if(fDebugLevel == 1){
5610 TString name("PRF");
5611 name += (Int_t)xMin;
5612 name += (Int_t)xMax;
5613 TCanvas *c1 = new TCanvas((const char *)name,(const char *)name,50,50,600,800);
5614 c1->cd();
5615 name += "histo";
5616 TH1F *histo = new TH1F((const char *)name,(const char *)name,nBins,xMin,xMax);
5617 for(Int_t k = 0; k < nBins; k++){
5618 histo->SetBinContent(k+1,arraym[k]);
5619 histo->SetBinError(k+1,arrayme[k]);
5620 }
5621 histo->Draw();
5622 name += "functionf";
5623 TF1 *f1= new TF1((const char*)name,"[0]*exp(-(x-[1])^2/(2*[2]*[2]))",xMin,xMax);
5624 f1->SetParameter(0, (*param)[0]);
5625 f1->SetParameter(1, (*param)[1]);
5626 f1->SetParameter(2, (*param)[2]);
5627 f1->Draw("same");
5628 }
5629
5630
5631 return chi2;
5632
5633}
5634//_____________________________________________________________________________
5635void AliTRDCalibraFit::FitPRF(TH1 *projPRF)
5636{
5637 //
5638 // Fit methode for the sigma of the pad response function
5639 //
55a288e5 5640
3a0f6479 5641 fCurrentCoef[0] = 0.0;
5642 fCurrentCoefE = 0.0;
5643
5644 if (fDebugLevel != 1) {
5645 projPRF->Fit("gaus","0M","",-fRangeFitPRF,fRangeFitPRF);
5646 }
5647 else {
55a288e5 5648 TCanvas *cfit = new TCanvas("cfit","cfit",50,50,600,800);
5649 cfit->cd();
5650 projPRF->Fit("gaus","M+","",-fRangeFitPRF,fRangeFitPRF);
5651 projPRF->Draw();
55a288e5 5652 }
3a0f6479 5653 fCurrentCoef[0] = projPRF->GetFunction("gaus")->GetParameter(2);
5654 fCurrentCoefE = projPRF->GetFunction("gaus")->GetParError(2);
5655 if(fCurrentCoef[0] <= 0.0) fCurrentCoef[0] = -fCurrentCoef[1];
55a288e5 5656 else {
3a0f6479 5657 fNumberFitSuccess++;
55a288e5 5658 }
3a0f6479 5659}
5660//_____________________________________________________________________________
5661void AliTRDCalibraFit::RmsPRF(TH1 *projPRF)
5662{
5663 //
5664 // Fit methode for the sigma of the pad response function
5665 //
5666 fCurrentCoef[0] = 0.0;
5667 fCurrentCoefE = 0.0;
5668 if (fDebugLevel == 1) {
5669 TCanvas *cfit = new TCanvas("cfit","cfit",50,50,600,800);
5670 cfit->cd();
5671 projPRF->Draw();
55a288e5 5672 }
3a0f6479 5673 fCurrentCoef[0] = projPRF->GetRMS();
5674 if(fCurrentCoef[0] <= 0.0) fCurrentCoef[0] = -fCurrentCoef[1];
5675 else {
5676 fNumberFitSuccess++;
55a288e5 5677 }
55a288e5 5678}
55a288e5 5679//_____________________________________________________________________________
3a0f6479 5680void AliTRDCalibraFit::FitTnpRange(Double_t *arraye, Double_t *arraym, Double_t *arrayme, Int_t nbg, Int_t nybins)
55a288e5 5681{
5682 //
3a0f6479 5683 // Fit methode for the sigma of the pad response function with 2*nbg tan bins
55a288e5 5684 //
5685
3a0f6479 5686 TLinearFitter linearfitter = TLinearFitter(3,"pol2");
55a288e5 5687
55a288e5 5688
3a0f6479 5689 Int_t nbins = (Int_t)(nybins/(2*nbg));
5690 Float_t lowedge = -3.0*nbg;
5691 Float_t upedge = lowedge + 3.0;
5692 Int_t offset = 0;
5693 Int_t npoints = 0;
5694 Double_t xvalues = -0.2*nbg+0.1;
5695 Double_t y = 0.0;
5696 Int_t total = 2*nbg;
55a288e5 5697
3a0f6479 5698
5699 for(Int_t k = 0; k < total; k++){
5700 if(FitPRFGausMI(arraye+offset, arraym+offset, arrayme+offset, nbins, lowedge, upedge)){
5701 npoints++;
5702 y = fCurrentCoef[0]*fCurrentCoef[0];
5703 linearfitter.AddPoint(&xvalues,y,2*fCurrentCoefE*fCurrentCoef[0]);
5704 }
5705
5706 if(fDebugLevel > 1){
5707
5708 if ( !fDebugStreamer ) {
5709 //debug stream
5710 TDirectory *backup = gDirectory;
4aad967c 5711 fDebugStreamer = new TTreeSRedirector("TRDDebugFitPRF.root");
3a0f6479 5712 if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
5713 }
5714
5715 Int_t detector = fCountDet;
053767a4 5716 Int_t layer = GetLayer(fCountDet);
3a0f6479 5717 Int_t nbtotal = total;
5718 Int_t group = k;
5719 Float_t low = lowedge;
5720 Float_t up = upedge;
5721 Float_t tnp = xvalues;
5722 Float_t wid = fCurrentCoef[0];
5723 Float_t widfE = fCurrentCoefE;
5724
413153cb 5725 (* fDebugStreamer) << "FitTnpRange0"<<
3a0f6479 5726 "detector="<<detector<<
053767a4 5727 "layer="<<layer<<
3a0f6479 5728 "nbtotal="<<nbtotal<<
5729 "group="<<group<<
5730 "low="<<low<<
5731 "up="<<up<<
5732 "offset="<<offset<<
5733 "tnp="<<tnp<<
5734 "wid="<<wid<<
5735 "widfE="<<widfE<<
5736 "\n";
5737 }
5738
5739 offset += nbins;
5740 lowedge += 3.0;
5741 upedge += 3.0;
5742 xvalues += 0.2;
5743
5744 }
5745
5746 fCurrentCoefE = 0.0;
5747 fCurrentCoef[0] = 0.0;
5748
5749 //printf("npoints\n",npoints);
5750
5751 if(npoints < 3){
5752 fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
5753 }
5754 else{
5755
5756 TVectorD pars0;
5757 linearfitter.Eval();
5758 linearfitter.GetParameters(pars0);
5759 Double_t pointError0 = TMath::Sqrt(linearfitter.GetChisquare()/npoints);
5760 Double_t errorsx0 = linearfitter.GetParError(2)*pointError0;
5761 Double_t min0 = 0.0;
5762 Double_t ermin0 = 0.0;
5763 //Double_t prfe0 = 0.0;
5764 Double_t prf0 = 0.0;
daa7dc79 5765 if((pars0[2] > 0.000000000001) && (TMath::Abs(pars0[1]) >= 0.000000000001)) {
3a0f6479 5766 min0 = -pars0[1]/(2*pars0[2]);
5767 ermin0 = TMath::Abs(min0*(errorsx0/pars0[2]+linearfitter.GetParError(1)*pointError0/pars0[1]));
5768 prf0 = pars0[0]+pars0[1]*min0+pars0[2]*min0*min0;
5769 if(prf0 > 0.0) {
5770 /*
5771 prfe0 = linearfitter->GetParError(0)*pointError0
5772 +(linearfitter->GetParError(1)*pointError0/pars0[1]+ermin0/min0)*pars0[1]*min0
5773 +(linearfitter->GetParError(2)*pointError0/pars0[2]+2*ermin0/min0)*pars0[2]*min0*min0;
5774 prfe0 = prfe0/(2*TMath::Sqrt(prf0));
5775 fCurrentCoefE = (Float_t) prfe0;
5776 */
5777 fCurrentCoef[0] = (Float_t) TMath::Sqrt(TMath::Abs(prf0));
5778 }
5779 else{
5780 fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
5781 }
5782 }
5783 else {
5784 fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
5785 }
55a288e5 5786
3a0f6479 5787 if(fDebugLevel > 1){
5788
5789 if ( !fDebugStreamer ) {
5790 //debug stream
5791 TDirectory *backup = gDirectory;
4aad967c 5792 fDebugStreamer = new TTreeSRedirector("TRDDebugFitPRF.root");
3a0f6479 5793 if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
5794 }
5795
5796 Int_t detector = fCountDet;
053767a4 5797 Int_t layer = GetLayer(fCountDet);
3a0f6479 5798 Int_t nbtotal = total;
5799 Double_t colsize[6] = {0.635,0.665,0.695,0.725,0.755,0.785};
053767a4 5800 Double_t sigmax = TMath::Sqrt(TMath::Abs(pars0[2]))*10000*colsize[layer];
3a0f6479 5801
413153cb 5802 (* fDebugStreamer) << "FitTnpRange1"<<
3a0f6479 5803 "detector="<<detector<<
053767a4 5804 "layer="<<layer<<
3a0f6479 5805 "nbtotal="<<nbtotal<<
5806 "par0="<<pars0[0]<<
5807 "par1="<<pars0[1]<<
5808 "par2="<<pars0[2]<<
5809 "npoints="<<npoints<<
5810 "sigmax="<<sigmax<<
5811 "tan="<<min0<<
5812 "sigmaprf="<<fCurrentCoef[0]<<
5813 "sigprf="<<fCurrentCoef[1]<<
5814 "\n";
5815 }
5816
55a288e5 5817 }
5818
5819}
55a288e5 5820//_____________________________________________________________________________
3a0f6479 5821void AliTRDCalibraFit::FitMean(TH1 *projch, Double_t nentries, Double_t mean)
55a288e5 5822{
5823 //
5824 // Only mean methode for the gain factor
5825 //
5826
3a0f6479 5827 fCurrentCoef[0] = mean;
5828 fCurrentCoefE = 0.0;
5829 if(nentries > 0) fCurrentCoefE = projch->GetRMS()/TMath::Sqrt(nentries);
5830 if (fDebugLevel == 1) {
55a288e5 5831 TCanvas *cpmean = new TCanvas("cpmean","cpmean",50,50,600,800);
5832 cpmean->cd();
5833 projch->Draw();
5834 }
3a0f6479 5835 CalculChargeCoefMean(kTRUE);
5836 fNumberFitSuccess++;
55a288e5 5837}
55a288e5 5838//_____________________________________________________________________________
3a0f6479 5839void AliTRDCalibraFit::FitMeanW(TH1 *projch, Double_t nentries)
55a288e5 5840{
5841 //
5842 // mean w methode for the gain factor
5843 //
5844
5845 //Number of bins
5846 Int_t nybins = projch->GetNbinsX();
5847
5848 //The weight function
5849 Double_t a = 0.00228515;
5850 Double_t b = -0.00231487;
5851 Double_t c = 0.00044298;
5852 Double_t d = -0.00379239;
5853 Double_t e = 0.00338349;
5854
3a0f6479 5855// 0 |0.00228515
5856// 1 |-0.00231487
5857// 2 |0.00044298
5858// 3 |-0.00379239
5859// 4 |0.00338349
5860
5861
55a288e5 5862
5863 //A arbitrary error for the moment
3a0f6479 5864 fCurrentCoefE = 0.0;
5865 fCurrentCoef[0] = 0.0;
55a288e5 5866
5867 //Calcul
5868 Double_t sumw = 0.0;
5869 Double_t sum = 0.0;
3a0f6479 5870 Float_t sumAll = (Float_t) nentries;
55a288e5 5871 Int_t sumCurrent = 0;
5872 for(Int_t k = 0; k <nybins; k++){
5873 Double_t fraction = Float_t(sumCurrent)/Float_t(sumAll);
5874 if (fraction>0.95) break;
5875 Double_t weight = a + b*fraction + c*fraction*fraction + d *fraction*fraction*fraction+
5876 e*fraction*fraction*fraction*fraction;
5877 sumw += weight*projch->GetBinContent(k+1)*projch->GetBinCenter(k+1);
5878 sum += weight*projch->GetBinContent(k+1);
5879 sumCurrent += (Int_t) projch->GetBinContent(k+1);
5880 //printf("fraction %f, weight %f, bincontent %f\n",fraction,weight,projch->GetBinContent(k+1));
5881 }
3a0f6479 5882 if(sum > 0.0) fCurrentCoef[0] = (sumw/sum);
55a288e5 5883
3a0f6479 5884 if (fDebugLevel == 1) {
55a288e5 5885 TCanvas *cpmeanw = new TCanvas("cpmeanw","cpmeanw",50,50,600,800);
5886 cpmeanw->cd();
5887 projch->Draw();
5888 }
3a0f6479 5889 fNumberFitSuccess++;
5890 CalculChargeCoefMean(kTRUE);
5891}
5892//_____________________________________________________________________________
5893void AliTRDCalibraFit::FitMeanWSm(TH1 *projch, Float_t sumAll)
5894{
5895 //
5896 // mean w methode for the gain factor
5897 //
5898
5899 //Number of bins
5900 Int_t nybins = projch->GetNbinsX();
5901
5902 //The weight function
5903 Double_t a = 0.00228515;
5904 Double_t b = -0.00231487;
5905 Double_t c = 0.00044298;
5906 Double_t d = -0.00379239;
5907 Double_t e = 0.00338349;
5908
5909// 0 |0.00228515
5910// 1 |-0.00231487
5911// 2 |0.00044298
5912// 3 |-0.00379239
5913// 4 |0.00338349
5914
5915
5916
5917 //A arbitrary error for the moment
5918 fCurrentCoefE = 0.0;
5919 fCurrentCoef[0] = 0.0;
55a288e5 5920
3a0f6479 5921 //Calcul
5922 Double_t sumw = 0.0;
5923 Double_t sum = 0.0;
5924 Int_t sumCurrent = 0;
5925 for(Int_t k = 0; k <nybins; k++){
5926 Double_t fraction = Float_t(sumCurrent)/Float_t(sumAll);
5927 if (fraction>0.95) break;
5928 Double_t weight = a + b*fraction + c*fraction*fraction + d *fraction*fraction*fraction+
5929 e*fraction*fraction*fraction*fraction;
5930 sumw += weight*projch->GetBinContent(k+1)*projch->GetBinCenter(k+1);
5931 sum += weight*projch->GetBinContent(k+1);
5932 sumCurrent += (Int_t) projch->GetBinContent(k+1);
5933 //printf("fraction %f, weight %f, bincontent %f\n",fraction,weight,projch->GetBinContent(k+1));
55a288e5 5934 }
3a0f6479 5935 if(sum > 0.0) fCurrentCoef[0] = (sumw/sum);
55a288e5 5936
3a0f6479 5937 if (fDebugLevel == 1) {
5938 TCanvas *cpmeanw = new TCanvas("cpmeanw","cpmeanw",50,50,600,800);
5939 cpmeanw->cd();
5940 projch->Draw();
5941 }
5942 fNumberFitSuccess++;
55a288e5 5943}
55a288e5 5944//_____________________________________________________________________________
3a0f6479 5945void AliTRDCalibraFit::FitCH(TH1 *projch, Double_t mean)
55a288e5 5946{
5947 //
5948 // Fit methode for the gain factor
5949 //
5950
3a0f6479 5951 fCurrentCoef[0] = 0.0;
5952 fCurrentCoefE = 0.0;
55a288e5 5953 Double_t chisqrl = 0.0;
5954 Double_t chisqrg = 0.0;
3a0f6479 5955 Double_t chisqr = 0.0;
55a288e5 5956 TF1 *fLandauGaus = new TF1("fLandauGaus",FuncLandauGaus,0,300,5);
5957
5958 projch->Fit("landau","0",""
3a0f6479 5959 ,(Double_t) mean/fBeginFitCharge
55a288e5 5960 ,projch->GetBinCenter(projch->GetNbinsX()));
5961 Double_t l3P0 = projch->GetFunction("landau")->GetParameter(0);
5962 Double_t l3P1 = projch->GetFunction("landau")->GetParameter(1);
5963 Double_t l3P2 = projch->GetFunction("landau")->GetParameter(2);
5964 chisqrl = projch->GetFunction("landau")->GetChisquare();
5965
5966 projch->Fit("gaus","0",""
3a0f6479 5967 ,(Double_t) mean/fBeginFitCharge
55a288e5 5968 ,projch->GetBinCenter(projch->GetNbinsX()));
5969 Double_t g3P0 = projch->GetFunction("gaus")->GetParameter(0);
5970 Double_t g3P2 = projch->GetFunction("gaus")->GetParameter(2);
5971 chisqrg = projch->GetFunction("gaus")->GetChisquare();
5972
5973 fLandauGaus->SetParameters(l3P0,l3P1,l3P2,g3P0,g3P2);
3a0f6479 5974 if (fDebugLevel != 1) {
55a288e5 5975 projch->Fit("fLandauGaus","0",""
3a0f6479 5976 ,(Double_t) mean/fBeginFitCharge
55a288e5 5977 ,projch->GetBinCenter(projch->GetNbinsX()));
5978 chisqr = projch->GetFunction("fLandauGaus")->GetChisquare();
3a0f6479 5979 }
5980 else {
55a288e5 5981 TCanvas *cp = new TCanvas("cp","cp",50,50,600,800);
5982 cp->cd();
5983 projch->Fit("fLandauGaus","+",""
3a0f6479 5984 ,(Double_t) mean/fBeginFitCharge
55a288e5 5985 ,projch->GetBinCenter(projch->GetNbinsX()));
5986 chisqr = projch->GetFunction("fLandauGaus")->GetChisquare();
5987 projch->Draw();
5988 fLandauGaus->Draw("same");
5989 }
5990
3a0f6479 5991 if ((projch->GetFunction("fLandauGaus")->GetParameter(1) > 0) && (projch->GetFunction("fLandauGaus")->GetParError(1) < (0.05*projch->GetFunction("fLandauGaus")->GetParameter(1))) && (chisqr < chisqrl) && (chisqr < chisqrg)) {
5992 //if ((projch->GetFunction("fLandauGaus")->GetParameter(1) > 0) && (chisqr < chisqrl) && (chisqr < chisqrg)) {
5993 fNumberFitSuccess++;
5994 CalculChargeCoefMean(kTRUE);
5995 fCurrentCoef[0] = projch->GetFunction("fLandauGaus")->GetParameter(1);
5996 fCurrentCoefE = projch->GetFunction("fLandauGaus")->GetParError(1);
55a288e5 5997 }
5998 else {
3a0f6479 5999 CalculChargeCoefMean(kFALSE);
6000 fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
55a288e5 6001 }
6002
3a0f6479 6003 if (fDebugLevel != 1) {
55a288e5 6004 delete fLandauGaus;
6005 }
6006
6007}
55a288e5 6008//_____________________________________________________________________________
3a0f6479 6009void AliTRDCalibraFit::FitBisCH(TH1* projch, Double_t mean)
55a288e5 6010{
6011 //
6012 // Fit methode for the gain factor more time consuming
6013 //
6014
3a0f6479 6015
55a288e5 6016 //Some parameters to initialise
e6381f8e 6017 Double_t widthLandau, widthGaus, mPV, integral;
55a288e5 6018 Double_t chisquarel = 0.0;
6019 Double_t chisquareg = 0.0;
55a288e5 6020 projch->Fit("landau","0M+",""
3a0f6479 6021 ,(Double_t) mean/6
55a288e5 6022 ,projch->GetBinCenter(projch->GetNbinsX()));
6023 widthLandau = projch->GetFunction("landau")->GetParameter(2);
6024 chisquarel = projch->GetFunction("landau")->GetChisquare();
55a288e5 6025 projch->Fit("gaus","0M+",""
3a0f6479 6026 ,(Double_t) mean/6
55a288e5 6027 ,projch->GetBinCenter(projch->GetNbinsX()));
6028 widthGaus = projch->GetFunction("gaus")->GetParameter(2);
6029 chisquareg = projch->GetFunction("gaus")->GetChisquare();
3a0f6479 6030
e6381f8e 6031 mPV = (projch->GetFunction("landau")->GetParameter(1))/2;
6032 integral = (projch->GetFunction("gaus")->Integral(0.3*mean,3*mean)+projch->GetFunction("landau")->Integral(0.3*mean,3*mean))/2;
3a0f6479 6033
55a288e5 6034 // Setting fit range and start values
6035 Double_t fr[2];
6036 //Double_t sv[4] = { l3P2, fChargeCoef[1], projch->Integral("width"), fG3P2 };
6037 //Double_t sv[4] = { fL3P2, fChargeCoef[1], fL3P0, fG3P2 };
e6381f8e 6038 Double_t sv[4] = { widthLandau, mPV, integral, widthGaus};
55a288e5 6039 Double_t pllo[4] = { 0.001, 0.001, projch->Integral()/3, 0.001};
6040 Double_t plhi[4] = { 300.0, 300.0, 30*projch->Integral(), 300.0};
6041 Double_t fp[4] = { 1.0, 1.0, 1.0, 1.0 };
6042 Double_t fpe[4] = { 1.0, 1.0, 1.0, 1.0 };
3a0f6479 6043 fr[0] = 0.3 * mean;
6044 fr[1] = 3.0 * mean;
6045 fCurrentCoef[0] = 0.0;
6046 fCurrentCoefE = 0.0;
55a288e5 6047
6048 Double_t chisqr;
6049 Int_t ndf;
6050 TF1 *fitsnr = LanGauFit(projch,&fr[0],&sv[0]
6051 ,&pllo[0],&plhi[0]
6052 ,&fp[0],&fpe[0]
6053 ,&chisqr,&ndf);
6054
6055 Double_t projchPeak;
6056 Double_t projchFWHM;
6057 LanGauPro(fp,projchPeak,projchFWHM);
6058
6059 if ((fp[1] > 0) && ((fpe[1] < (0.05*fp[1])) && (chisqr < chisquarel) && (chisqr < chisquareg))) {
6060 //if ((fp[1] > 0) && ((chisqr < chisquarel) && (chisqr < chisquareg))) {
3a0f6479 6061 fNumberFitSuccess++;
6062 CalculChargeCoefMean(kTRUE);
6063 fCurrentCoef[0] = fp[1];
6064 fCurrentCoefE = fpe[1];
55a288e5 6065 //chargeCoefE2 = chisqr;
6066 }
6067 else {
3a0f6479 6068 CalculChargeCoefMean(kFALSE);
6069 fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
55a288e5 6070 }
3a0f6479 6071 if (fDebugLevel == 1) {
6072 AliInfo(Form("fChargeCoef[0]: %f",(Float_t) fCurrentCoef[0]));
55a288e5 6073 TCanvas *cpy = new TCanvas("cpy","cpy",50,50,600,800);
6074 cpy->cd();
6075 projch->Draw();
6076 fitsnr->Draw("same");
6077 }
3a0f6479 6078 else {
55a288e5 6079 delete fitsnr;
6080 }
3a0f6479 6081}
55a288e5 6082//_____________________________________________________________________________
3b0c1edc 6083void AliTRDCalibraFit::CalculPolynomeLagrange2(const Double_t *x, const Double_t *y, Double_t &c0, Double_t &c1, Double_t &c2, Double_t &c3, Double_t &c4) const
55a288e5 6084{
6085 //
6086 // Calcul the coefficients of the polynome passant par ces trois points de degre 2
6087 //
55a288e5 6088 Double_t x0 = y[0]/((x[0]-x[1])*(x[0]-x[2]));
6089 Double_t x1 = y[1]/((x[1]-x[0])*(x[1]-x[2]));
6090 Double_t x2 = y[2]/((x[2]-x[0])*(x[2]-x[1]));
6091
3b0c1edc 6092 c4 = 0.0;
6093 c3 = 0.0;
6094 c2 = x0+x1+x2;
6095 c1 = -(x0*(x[1]+x[2])+x1*(x[0]+x[2])+x2*(x[0]+x[1]));
6096 c0 = x0*x[1]*x[2]+x1*x[0]*x[2]+x2*x[0]*x[1];
3a0f6479 6097
55a288e5 6098}
6099
6100//_____________________________________________________________________________
3b0c1edc 6101void AliTRDCalibraFit::CalculPolynomeLagrange3(const Double_t *x, const Double_t *y, Double_t &c0, Double_t &c1, Double_t &c2, Double_t &c3, Double_t &c4) const
55a288e5 6102{
6103 //
6104 // Calcul the coefficients of the polynome passant par ces quatre points de degre 3
6105 //
55a288e5 6106 Double_t x0 = y[0]/((x[0]-x[1])*(x[0]-x[2])*(x[0]-x[3]));
6107 Double_t x1 = y[1]/((x[1]-x[0])*(x[1]-x[2])*(x[1]-x[3]));
6108 Double_t x2 = y[2]/((x[2]-x[0])*(x[2]-x[1])*(x[2]-x[3]));
6109 Double_t x3 = y[3]/((x[3]-x[0])*(x[3]-x[1])*(x[3]-x[2]));
6110
3b0c1edc 6111 c4 = 0.0;
6112 c3 = x0+x1+x2+x3;
6113 c2 = -(x0*(x[1]+x[2]+x[3])
55a288e5 6114 +x1*(x[0]+x[2]+x[3])
6115 +x2*(x[0]+x[1]+x[3])
6116 +x3*(x[0]+x[1]+x[2]));
3b0c1edc 6117 c1 = (x0*(x[1]*x[2]+x[1]*x[3]+x[2]*x[3])
55a288e5 6118 +x1*(x[0]*x[2]+x[0]*x[3]+x[2]*x[3])
6119 +x2*(x[0]*x[1]+x[0]*x[3]+x[1]*x[3])
6120 +x3*(x[0]*x[1]+x[0]*x[2]+x[1]*x[2]));
6121
3b0c1edc 6122 c0 = -(x0*x[1]*x[2]*x[3]
55a288e5 6123 +x1*x[0]*x[2]*x[3]
6124 +x2*x[0]*x[1]*x[3]
6125 +x3*x[0]*x[1]*x[2]);
6126
3a0f6479 6127
55a288e5 6128}
6129
6130//_____________________________________________________________________________
3b0c1edc 6131void AliTRDCalibraFit::CalculPolynomeLagrange4(const Double_t *x, const Double_t *y, Double_t &c0, Double_t &c1, Double_t &c2, Double_t &c3, Double_t &c4) const
55a288e5 6132{
6133 //
6134 // Calcul the coefficients of the polynome passant par ces cinqs points de degre 4
6135 //
55a288e5 6136 Double_t x0 = y[0]/((x[0]-x[1])*(x[0]-x[2])*(x[0]-x[3])*(x[0]-x[4]));
6137 Double_t x1 = y[1]/((x[1]-x[0])*(x[1]-x[2])*(x[1]-x[3])*(x[1]-x[4]));
6138 Double_t x2 = y[2]/((x[2]-x[0])*(x[2]-x[1])*(x[2]-x[3])*(x[2]-x[4]));
6139 Double_t x3 = y[3]/((x[3]-x[0])*(x[3]-x[1])*(x[3]-x[2])*(x[3]-x[4]));
6140 Double_t x4 = y[4]/((x[4]-x[0])*(x[4]-x[1])*(x[4]-x[2])*(x[4]-x[3]));
3a0f6479 6141
55a288e5 6142
3b0c1edc 6143 c4 = x0+x1+x2+x3+x4;
6144 c3 = -(x0*(x[1]+x[2]+x[3]+x[4])
55a288e5 6145 +x1*(x[0]+x[2]+x[3]+x[4])
6146 +x2*(x[0]+x[1]+x[3]+x[4])
6147 +x3*(x[0]+x[1]+x[2]+x[4])
6148 +x4*(x[0]+x[1]+x[2]+x[3]));
3b0c1edc 6149 c2 = (x0*(x[1]*x[2]+x[1]*x[3]+x[1]*x[4]+x[2]*x[3]+x[2]*x[4]+x[3]*x[4])
55a288e5 6150 +x1*(x[0]*x[2]+x[0]*x[3]+x[0]*x[4]+x[2]*x[3]+x[2]*x[4]+x[3]*x[4])
6151 +x2*(x[0]*x[1]+x[0]*x[3]+x[0]*x[4]+x[1]*x[3]+x[1]*x[4]+x[3]*x[4])
6152 +x3*(x[0]*x[1]+x[0]*x[2]+x[0]*x[4]+x[1]*x[2]+x[1]*x[4]+x[2]*x[4])
6153 +x4*(x[0]*x[1]+x[0]*x[2]+x[0]*x[3]+x[1]*x[2]+x[1]*x[3]+x[2]*x[3]));
6154
3b0c1edc 6155 c1 = -(x0*(x[1]*x[2]*x[3]+x[1]*x[2]*x[4]+x[1]*x[3]*x[4]+x[2]*x[3]*x[4])
55a288e5 6156 +x1*(x[0]*x[2]*x[3]+x[0]*x[2]*x[4]+x[0]*x[3]*x[4]+x[2]*x[3]*x[4])
6157 +x2*(x[0]*x[1]*x[3]+x[0]*x[1]*x[4]+x[0]*x[3]*x[4]+x[1]*x[3]*x[4])
6158 +x3*(x[0]*x[1]*x[2]+x[0]*x[1]*x[4]+x[0]*x[2]*x[4]+x[1]*x[2]*x[4])
6159 +x4*(x[0]*x[1]*x[2]+x[0]*x[1]*x[3]+x[0]*x[2]*x[3]+x[1]*x[2]*x[3]));
6160
3b0c1edc 6161 c0 = (x0*x[1]*x[2]*x[3]*x[4]
55a288e5 6162 +x1*x[0]*x[2]*x[3]*x[4]
6163 +x2*x[0]*x[1]*x[3]*x[4]
6164 +x3*x[0]*x[1]*x[2]*x[4]
6165 +x4*x[0]*x[1]*x[2]*x[3]);
6166
55a288e5 6167}
55a288e5 6168//_____________________________________________________________________________
6169void AliTRDCalibraFit::NormierungCharge()
6170{
6171 //
6172 // Normalisation of the gain factor resulting for the fits
6173 //
6174
6175 // Calcul of the mean of choosen method by fFitChargeNDB
6176 Double_t sum = 0.0;
6177 //printf("total number of entries %d\n",fVectorFitCH->GetEntriesFast());
3a0f6479 6178 for (Int_t k = 0; k < (Int_t) fVectorFit.GetEntriesFast(); k++) {
55a288e5 6179 Int_t total = 0;
3a0f6479 6180 Int_t detector = ((AliTRDFitInfo *) fVectorFit.At(k))->GetDetector();
6181 Float_t *coef = ((AliTRDFitInfo *) fVectorFit.At(k))->GetCoef();
55a288e5 6182 //printf("detector %d coef[0] %f\n",detector,coef[0]);
053767a4 6183 if (GetStack(detector) == 2) {
55a288e5 6184 total = 1728;
6185 }
053767a4 6186 if (GetStack(detector) != 2) {
55a288e5 6187 total = 2304;
6188 }
6189 for (Int_t j = 0; j < total; j++) {
6190 if (coef[j] >= 0) {
6191 sum += coef[j];
6192 }
6193 }
6194 }
6195
6196 if (sum > 0) {
6197 fScaleFitFactor = fScaleFitFactor / sum;
6198 }
6199 else {
6200 fScaleFitFactor = 1.0;
3a0f6479 6201 }
55a288e5 6202
3a0f6479 6203 //methode de boeuf mais bon...
6204 Double_t scalefactor = fScaleFitFactor;
55a288e5 6205
3a0f6479 6206 if(fDebugLevel > 1){
6207
6208 if ( !fDebugStreamer ) {
6209 //debug stream
6210 TDirectory *backup = gDirectory;
4aad967c 6211 fDebugStreamer = new TTreeSRedirector("TRDDebugFitCH.root");
3a0f6479 6212 if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
6213 }
413153cb 6214 (* fDebugStreamer) << "NormierungCharge"<<
3a0f6479 6215 "scalefactor="<<scalefactor<<
6216 "\n";
6217 }
55a288e5 6218}
55a288e5 6219//_____________________________________________________________________________
979b168f 6220TH1I *AliTRDCalibraFit::ReBin(const TH1I *hist) const
55a288e5 6221{
6222 //
6223 // Rebin of the 1D histo for the gain calibration if needed.
6224 // you have to choose fRebin, divider of fNumberBinCharge
6225 //
6226
3a0f6479 6227 TAxis *xhist = hist->GetXaxis();
6228 TH1I *rehist = new TH1I("projrebin","",(Int_t) xhist->GetNbins()/fRebin
6229 ,xhist->GetBinLowEdge(1)
6230 ,xhist->GetBinUpEdge(xhist->GetNbins()));
55a288e5 6231
3a0f6479 6232 AliInfo(Form("fRebin: %d",fRebin));
6233 Int_t i = 1;
6234 for (Int_t k = 1; k <= (Int_t) xhist->GetNbins()/fRebin; k++) {
6235 Double_t sum = 0.0;
6236 for (Int_t ji = i; ji < i+fRebin; ji++) {
6237 sum += hist->GetBinContent(ji);
6238 }
6239 sum = sum / fRebin;
6240 rehist->SetBinContent(k,sum);
6241 i += fRebin;
6242 }
55a288e5 6243
3a0f6479 6244 return rehist;
55a288e5 6245
6246}
6247
6248//_____________________________________________________________________________
979b168f 6249TH1F *AliTRDCalibraFit::ReBin(const TH1F *hist) const
55a288e5 6250{
6251 //
6252 // Rebin of the 1D histo for the gain calibration if needed
6253 // you have to choose fRebin divider of fNumberBinCharge
6254 //
6255
6256 TAxis *xhist = hist->GetXaxis();
6257 TH1F *rehist = new TH1F("projrebin","",(Int_t) xhist->GetNbins()/fRebin
6258 ,xhist->GetBinLowEdge(1)
6259 ,xhist->GetBinUpEdge(xhist->GetNbins()));
6260
6261 AliInfo(Form("fRebin: %d",fRebin));
6262 Int_t i = 1;
6263 for (Int_t k = 1; k <= (Int_t) xhist->GetNbins()/fRebin; k++) {
6264 Double_t sum = 0.0;
6265 for (Int_t ji = i; ji < i+fRebin; ji++) {
6266 sum += hist->GetBinContent(ji);
6267 }
6268 sum = sum/fRebin;
6269 rehist->SetBinContent(k,sum);
6270 i += fRebin;
6271 }
6272
55a288e5 6273 return rehist;
6274
55a288e5 6275}
55a288e5 6276//
6277//____________Some basic geometry function_____________________________________
6278//
6279
6280//_____________________________________________________________________________
053767a4 6281Int_t AliTRDCalibraFit::GetLayer(Int_t d) const
55a288e5 6282{
6283 //
6284 // Reconstruct the plane number from the detector number
6285 //
6286
6287 return ((Int_t) (d % 6));
6288
6289}
6290
6291//_____________________________________________________________________________
053767a4 6292Int_t AliTRDCalibraFit::GetStack(Int_t d) const
55a288e5 6293{
6294 //
053767a4 6295 // Reconstruct the stack number from the detector number
55a288e5 6296 //
053767a4 6297 const Int_t kNlayer = 6;
55a288e5 6298
053767a4 6299 return ((Int_t) (d % 30) / kNlayer);
55a288e5 6300
6301}
6302
6303//_____________________________________________________________________________
6304Int_t AliTRDCalibraFit::GetSector(Int_t d) const
6305{
6306 //
6307 // Reconstruct the sector number from the detector number
6308 //
6309 Int_t fg = 30;
6310
6311 return ((Int_t) (d / fg));
6312
6313}
6314
6315//
6316//____________Fill and Init tree Gain, PRF, Vdrift and T0______________________
6317//
3a0f6479 6318//_______________________________________________________________________________
6319void AliTRDCalibraFit::ResetVectorFit()
55a288e5 6320{
e6381f8e 6321 //
6322 // Reset the VectorFits
6323 //
6324
3a0f6479 6325 fVectorFit.SetOwner();
6326 fVectorFit.Clear();
6327 fVectorFit2.SetOwner();
6328 fVectorFit2.Clear();
55a288e5 6329
55a288e5 6330}
55a288e5 6331//
6332//____________Private Functions________________________________________________
6333//
6334
6335//_____________________________________________________________________________
979b168f 6336Double_t AliTRDCalibraFit::PH(const Double_t *x, const Double_t *par)
55a288e5 6337{
6338 //
6339 // Function for the fit
6340 //
6341
6342 //TF1 *fAsymmGauss = new TF1("fAsymmGauss",AsymmGauss,0,4,6);
6343
6344 //PARAMETERS FOR FIT PH
6345 // PASAv.4
6346 //fAsymmGauss->SetParameter(0,0.113755);
6347 //fAsymmGauss->SetParameter(1,0.350706);
6348 //fAsymmGauss->SetParameter(2,0.0604244);
6349 //fAsymmGauss->SetParameter(3,7.65596);
6350 //fAsymmGauss->SetParameter(4,1.00124);
6351 //fAsymmGauss->SetParameter(5,0.870597); // No tail cancelation
6352
6353 Double_t xx = x[0];
6354
6355 if (xx < par[1]) {
6356 return par[5];
6357 }
6358
6359 Double_t dx = 0.005;
6360 Double_t xs = par[1];
6361 Double_t ss = 0.0;
6362 Double_t paras[2] = { 0.0, 0.0 };
6363
6364 while (xs < xx) {
6365 if ((xs >= par[1]) &&
6366 (xs < (par[1]+par[2]))) {
6367 //fAsymmGauss->SetParameter(0,par[0]);
6368 //fAsymmGauss->SetParameter(1,xs);
6369 //ss += fAsymmGauss->Eval(xx);
6370 paras[0] = par[0];
6371 paras[1] = xs;
6372 ss += AsymmGauss(&xx,paras);
6373 }
6374 if ((xs >= (par[1]+par[2])) &&
6375 (xs < (par[1]+par[2]+par[3]))) {
6376 //fAsymmGauss->SetParameter(0,par[0]*par[4]);
6377 //fAsymmGauss->SetParameter(1,xs);
6378 //ss += fAsymmGauss->Eval(xx);
6379 paras[0] = par[0]*par[4];
6380 paras[1] = xs;
6381 ss += AsymmGauss(&xx,paras);
6382 }
6383 xs += dx;
6384 }
6385
6386 return ss + par[5];
6387
6388}
6389
6390//_____________________________________________________________________________
979b168f 6391Double_t AliTRDCalibraFit::AsymmGauss(const Double_t *x, const Double_t *par)
55a288e5 6392{
6393 //
6394 // Function for the fit
6395 //
6396
6397 //par[0] = normalization
6398 //par[1] = mean
6399 //par[2] = sigma
6400 //norm0 = 1
6401 //par[3] = lambda0
6402 //par[4] = norm1
6403 //par[5] = lambda1
6404
6405 Double_t par1save = par[1];
6406 //Double_t par2save = par[2];
6407 Double_t par2save = 0.0604244;
6408 //Double_t par3save = par[3];
6409 Double_t par3save = 7.65596;
6410 //Double_t par5save = par[5];
6411 Double_t par5save = 0.870597;
6412 Double_t dx = x[0] - par1save;
6413
6414 Double_t sigma2 = par2save*par2save;
6415 Double_t sqrt2 = TMath::Sqrt(2.0);
6416 Double_t exp1 = par3save * TMath::Exp(-par3save * (dx - 0.5 * par3save * sigma2))
bb7e41dd 6417 * (1.0 - AliMathBase::ErfFast((par3save * sigma2 - dx) / (sqrt2 * par2save)));
55a288e5 6418 Double_t exp2 = par5save * TMath::Exp(-par5save * (dx - 0.5 * par5save * sigma2))
bb7e41dd 6419 * (1.0 - AliMathBase::ErfFast((par5save * sigma2 - dx) / (sqrt2 * par2save)));
55a288e5 6420
6421 //return par[0]*(exp1+par[4]*exp2);
6422 return par[0] * (exp1 + 1.00124 * exp2);
6423
6424}
6425
6426//_____________________________________________________________________________
979b168f 6427Double_t AliTRDCalibraFit::FuncLandauGaus(const Double_t *x, const Double_t *par)
55a288e5 6428{
6429 //
6430 // Sum Landau + Gaus with identical mean
6431 //
6432
6433 Double_t valLandau = par[0] * TMath::Landau(x[0],par[1],par[2]);
6434 //Double_t valGaus = par[3] * TMath::Gaus(x[0],par[4],par[5]);
6435 Double_t valGaus = par[3] * TMath::Gaus(x[0],par[1],par[4]);
6436 Double_t val = valLandau + valGaus;
6437
6438 return val;
6439
6440}
6441
6442//_____________________________________________________________________________
979b168f 6443Double_t AliTRDCalibraFit::LanGauFun(const Double_t *x, const Double_t *par)
55a288e5 6444{
6445 //
6446 // Function for the fit
6447 //
6448 // Fit parameters:
6449 // par[0]=Width (scale) parameter of Landau density
6450 // par[1]=Most Probable (MP, location) parameter of Landau density
6451 // par[2]=Total area (integral -inf to inf, normalization constant)
6452 // par[3]=Width (sigma) of convoluted Gaussian function
6453 //
6454 // In the Landau distribution (represented by the CERNLIB approximation),
6455 // the maximum is located at x=-0.22278298 with the location parameter=0.
6456 // This shift is corrected within this function, so that the actual
6457 // maximum is identical to the MP parameter.
6458 //
6459
6460 // Numeric constants
6461 Double_t invsq2pi = 0.3989422804014; // (2 pi)^(-1/2)
6462 Double_t mpshift = -0.22278298; // Landau maximum location
6463
6464 // Control constants
6465 Double_t np = 100.0; // Number of convolution steps
6466 Double_t sc = 5.0; // Convolution extends to +-sc Gaussian sigmas
6467
6468 // Variables
6469 Double_t xx;
6470 Double_t mpc;
6471 Double_t fland;
6472 Double_t sum = 0.0;
6473 Double_t xlow;
6474 Double_t xupp;
6475 Double_t step;
6476 Double_t i;
6477
6478 // MP shift correction
6479 mpc = par[1] - mpshift * par[0];
6480
6481 // Range of convolution integral
6482 xlow = x[0] - sc * par[3];
6483 xupp = x[0] + sc * par[3];
6484
6485 step = (xupp - xlow) / np;
6486
6487 // Convolution integral of Landau and Gaussian by sum
6488 for (i = 1.0; i <= np/2; i++) {
6489
6490 xx = xlow + (i-.5) * step;
6491 fland = TMath::Landau(xx,mpc,par[0]) / par[0];
6492 sum += fland * TMath::Gaus(x[0],xx,par[3]);
6493
6494 xx = xupp - (i-.5) * step;
6495 fland = TMath::Landau(xx,mpc,par[0]) / par[0];
6496 sum += fland * TMath::Gaus(x[0],xx,par[3]);
6497
6498 }
6499
6500 return (par[2] * step * sum * invsq2pi / par[3]);
6501
6502}
55a288e5 6503//_____________________________________________________________________________
979b168f 6504TF1 *AliTRDCalibraFit::LanGauFit(TH1 *his, const Double_t *fitrange, const Double_t *startvalues
6505 , const Double_t *parlimitslo, const Double_t *parlimitshi
55a288e5 6506 , Double_t *fitparams, Double_t *fiterrors
e6381f8e 6507 , Double_t *chiSqr, Int_t *ndf) const
55a288e5 6508{
6509 //
6510 // Function for the fit
6511 //
6512
6513 Int_t i;
6514 Char_t funname[100];
6515
6516 TF1 *ffitold = (TF1 *) gROOT->GetListOfFunctions()->FindObject(funname);
6517 if (ffitold) {
6518 delete ffitold;
6519 }
6520
6521 TF1 *ffit = new TF1(funname,LanGauFun,fitrange[0],fitrange[1],4);
6522 ffit->SetParameters(startvalues);
6523 ffit->SetParNames("Width","MP","Area","GSigma");
6524
6525 for (i = 0; i < 4; i++) {
6526 ffit->SetParLimits(i,parlimitslo[i],parlimitshi[i]);
6527 }
6528
6529 his->Fit(funname,"RB0"); // Fit within specified range, use ParLimits, do not plot
6530
6531 ffit->GetParameters(fitparams); // Obtain fit parameters
6532 for (i = 0; i < 4; i++) {
6533 fiterrors[i] = ffit->GetParError(i); // Obtain fit parameter errors
6534 }
6535 chiSqr[0] = ffit->GetChisquare(); // Obtain chi^2
6536 ndf[0] = ffit->GetNDF(); // Obtain ndf
6537
6538 return (ffit); // Return fit function
6539
6540}
6541
6542//_____________________________________________________________________________
979b168f 6543Int_t AliTRDCalibraFit::LanGauPro(const Double_t *params, Double_t &maxx, Double_t &fwhm)
55a288e5 6544{
6545 //
6546 // Function for the fit
6547 //
6548
6549 Double_t p;
6550 Double_t x;
6551 Double_t fy;
6552 Double_t fxr;
6553 Double_t fxl;
6554 Double_t step;
6555 Double_t l;
6556 Double_t lold;
6557
6558 Int_t i = 0;
6559 Int_t maxcalls = 10000;
6560
6561 // Search for maximum
6562 p = params[1] - 0.1 * params[0];
6563 step = 0.05 * params[0];
6564 lold = -2.0;
6565 l = -1.0;
6566
6567 while ((l != lold) && (i < maxcalls)) {
6568 i++;
6569 lold = l;
6570 x = p + step;
6571 l = LanGauFun(&x,params);
6572 if (l < lold) {
6573 step = -step / 10.0;
6574 }
6575 p += step;
6576 }
6577
6578 if (i == maxcalls) {
6579 return (-1);
6580 }
6581 maxx = x;
6582 fy = l / 2.0;
6583
6584 // Search for right x location of fy
6585 p = maxx + params[0];
6586 step = params[0];
6587 lold = -2.0;
6588 l = -1e300;
6589 i = 0;
6590
6591 while ( (l != lold) && (i < maxcalls) ) {
6592 i++;
6593
6594 lold = l;
6595 x = p + step;
6596 l = TMath::Abs(LanGauFun(&x,params) - fy);
6597
6598 if (l > lold)
6599 step = -step/10;
6600
6601 p += step;
6602 }
6603
6604 if (i == maxcalls)
6605 return (-2);
6606
6607 fxr = x;
6608
3a0f6479 6609
55a288e5 6610 // Search for left x location of fy
6611
6612 p = maxx - 0.5 * params[0];
6613 step = -params[0];
6614 lold = -2.0;
6615 l = -1.0e300;
6616 i = 0;
6617
6618 while ((l != lold) && (i < maxcalls)) {
6619 i++;
6620 lold = l;
6621 x = p + step;
6622 l = TMath::Abs(LanGauFun(&x,params) - fy);
6623 if (l > lold) {
6624 step = -step / 10.0;
6625 }
6626 p += step;
6627 }
6628
6629 if (i == maxcalls) {
6630 return (-3);
6631 }
6632
6633 fxl = x;
6634 fwhm = fxr - fxl;
6635
6636 return (0);
55a288e5 6637}
55a288e5 6638//_____________________________________________________________________________
979b168f 6639Double_t AliTRDCalibraFit::GausConstant(const Double_t *x, const Double_t *par)
55a288e5 6640{
6641 //
6642 // Gaus with identical mean
6643 //
6644
e6381f8e 6645 Double_t gauss = par[0] * TMath::Gaus(x[0],0.0,par[1])+par[2];
55a288e5 6646
e6381f8e 6647 return gauss;
55a288e5 6648
ef19f1da 6649}
4c865c34 6650
3b0c1edc 6651
6652