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