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