]> 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
Save the volume ID of alignable volume in AliTRDcluster
[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));
bb9cc02b 3436 if(!fAccCDB) {
3437 AliInfo(Form("It is not normal because we didn't choose a reference database!"));
3438 }
55a288e5 3439 }
3440 scale = fScaleFitFactor;
3441 }
3442 for(Int_t l = 0; l < nbins; l++){
3443 if(fCoefCharge[0][l] > 0){
3444 fCoefCharge[0][l]=fCoefCharge[0][l]*scale;
3445 fCoefChargeE[0][l]=fCoefChargeE[0][l]*scale;
3446 }
3447 }
3448 }
3449
3450 if(fFitMeanWOn){
3451 sum = 0.0;
3452 for(Int_t l = 0; l < nbins; l++){
3453 if(fCoefCharge[4][l] > 0){
3454 sum += fCoefCharge[4][l];
3455 xValuesFittedMeanW[counter[3]]= l;
3456 counter[3]++;
3457 }
3458 }
3459 scale = 1.0;
3460 if(sum > 0.0) scale = counter[3]/sum;
3461 if(fFitChargeNDB == 4){
3462 if(scale != fScaleFitFactor){
3463 AliInfo(Form("The normalisation is different from a nomalisation to one."));
3464 AliInfo(Form("For one we have %f and here %f",scale,fScaleFitFactor));
bb9cc02b 3465 if(!fAccCDB) {
3466 AliInfo(Form("It is not normal because we didn't choose a reference database!"));
3467 }
55a288e5 3468 }
3469 scale = fScaleFitFactor;
3470 }
3471 for(Int_t l = 0; l < nbins; l++){
3472 if(fCoefCharge[4][l] > 0){
3473 fCoefCharge[4][l]=fCoefCharge[4][l]*scale;
3474 fCoefChargeE[3][l]=fCoefChargeE[3][l]*scale;
3475 }
3476 }
3477 }
3478
3479 if(fMeanChargeOn){
3480 sum = 0.0;
3481 for(Int_t l = 0; l < nbins; l++){
3482 if(fCoefCharge[1][l] > 0){
3483 sum += fCoefCharge[1][l];
3484 xValuesFittedMean[counter[1]]= l;
3485 counter[1]++;
3486 }
3487 }
3488 scale = 1.0;
3489 if(sum > 0.0) scale = counter[1]/sum;
3490 if(fFitChargeNDB == 1){
3491 if(scale != fScaleFitFactor){
3492 AliInfo(Form("The normalisation is different from a nomalisation to one."));
3493 AliInfo(Form("For one we have %f and here %f",scale,fScaleFitFactor));
bb9cc02b 3494 if(!fAccCDB) {
3495 AliInfo(Form("It is not normal because we didn't choose a reference database!"));
3496 }
55a288e5 3497 }
3498 scale = fScaleFitFactor;
3499 }
3500 for(Int_t l = 0; l < nbins; l++){
3501 if(fCoefCharge[1][l] > 0){
3502 fCoefCharge[1][l]=fCoefCharge[1][l]*scale;
3503 fCoefChargeE[1][l]=fCoefChargeE[1][l]*scale;
3504 }
3505 }
3506 }
3507
3508 if(fFitChargeBisOn){
3509 sum = 0.0;
3510 for(Int_t l = 0; l < nbins; l++){
3511 if(fCoefCharge[2][l] > 0){
3512 sum += fCoefCharge[2][l];
3513 xValuesFittedBis[counter[2]]= l;
3514 counter[2]++;
3515 }
3516 }
3517 scale = 1.0;
3518 if(sum > 0.0) scale = counter[2]/sum;
3519 if(fFitChargeNDB == 0){
3520 if(scale != fScaleFitFactor){
3521 AliInfo(Form("The normalisation is different from a nomalisation to one."));
3522 AliInfo(Form("For one we have %f and here %f",scale,fScaleFitFactor));
bb9cc02b 3523 if(!fAccCDB) {
3524 AliInfo(Form("It is not normal because we didn't choose a reference database!"));
3525 }
55a288e5 3526 }
3527 scale = fScaleFitFactor;
3528 }
3529 for(Int_t l = 0; l < nbins; l++){
3530 if(fCoefCharge[2][l] > 0){
3531 fCoefCharge[2][l]=fCoefCharge[2][l]*scale;
3532 fCoefChargeE[2][l]=fCoefChargeE[2][l]*scale;
3533 }
3534 }
3535 }
3536
3537 // Create the X and Xerror
3538 Double_t *xValues = new Double_t[nbins];
3539 Double_t *xValuesE = new Double_t[nbins];
3540 for(Int_t k = 0; k < nbins; k ++){
3541 xValues[k] = k;
3542 xValuesE[k] = 0.0;
3543 }
3544
3545 // Create the graph erros and plot them
3546 TCanvas *cch1 = new TCanvas("cch1","",50,50,600,800);
3547 cch1->cd();
3548 TLegend *legch1 = new TLegend(0.4,0.6,0.89,0.89);
3549
3550 TGraph *graphCharge3 = new TGraph(nbins,xValues,fCoefCharge[3]);
3551 graphCharge3->SetName("coefcharge3");
3552 graphCharge3->SetTitle("");
3553 graphCharge3->GetXaxis()->SetTitle("Det/Pad groups");
3554 graphCharge3->GetYaxis()->SetTitle("gain factor");
3555 graphCharge3->SetLineColor(4);
3556 graphCharge3->SetMarkerStyle(25);
3557 graphCharge3->SetMarkerColor(4);
3558 listofgraphs->Add((TObject *)graphCharge3);
3559 legch1->AddEntry(graphCharge3,"f_{g} simulated","p");
3560 graphCharge3->Draw("AP");
3561
3562 if (fFitChargeOn) {
3563 TGraphErrors *graphCharge0 = new TGraphErrors(nbins,xValues,fCoefCharge[0],xValuesE,fCoefChargeE[0]);
3564 graphCharge0->SetName("coefcharge0");
3565 graphCharge0->SetTitle("");
3566 graphCharge0->GetXaxis()->SetTitle("Det/Pad groups");
3567 graphCharge0->GetYaxis()->SetTitle("gain factor");
3568 graphCharge0->SetMarkerColor(6);
3569 graphCharge0->SetLineColor(6);
3570 graphCharge0->SetMarkerStyle(26);
3571 listofgraphs->Add((TObject *)graphCharge0);
3572 legch1->AddEntry(graphCharge0,"f_{g} fit","p");
3573 graphCharge0->Draw("P");
3574 }
3575 if (fFitMeanWOn) {
3576 TGraphErrors *graphCharge4 = new TGraphErrors(nbins,xValues,fCoefCharge[4],xValuesE,fCoefChargeE[3]);
3577 graphCharge4->SetName("coefcharge4");
3578 graphCharge4->SetTitle("");
3579 graphCharge4->GetXaxis()->SetTitle("Det/Pad groups");
3580 graphCharge4->GetYaxis()->SetTitle("gain factor");
3581 graphCharge4->SetMarkerColor(1);
3582 graphCharge4->SetLineColor(1);
3583 graphCharge4->SetMarkerStyle(30);
3584 listofgraphs->Add((TObject *)graphCharge4);
3585 legch1->AddEntry(graphCharge4,"f_{g} Mean W","p");
3586 graphCharge4->Draw("P");
3587 }
3588 if (fMeanChargeOn) {
3589 TGraphErrors *graphCharge1 = new TGraphErrors(nbins,xValues,fCoefCharge[1],xValuesE,fCoefChargeE[1]);
3590 graphCharge1->SetName("coefcharge1");
3591 graphCharge1->GetXaxis()->SetTitle("Det/Pad groups");
3592 graphCharge1->GetYaxis()->SetTitle("gain factor");
3593 graphCharge1->SetTitle("");
3594 graphCharge1->SetMarkerColor(2);
3595 graphCharge1->SetLineColor(2);
3596 graphCharge1->SetMarkerStyle(24);
3597 legch1->AddEntry(graphCharge1,"f_{g} mean","p");
3598 graphCharge1->Draw("P");
3599 listofgraphs->Add((TObject *)graphCharge1);
3600 }
3601 if (fFitChargeBisOn ) {
3602 TGraphErrors *graphCharge2 = new TGraphErrors(nbins,xValues,fCoefCharge[2],xValuesE,fCoefChargeE[2]);
3603 graphCharge2->SetName("coefcharge2");
3604 graphCharge2->SetTitle("");
3605 graphCharge2->GetXaxis()->SetTitle("Det/Pad groups");
3606 graphCharge2->GetYaxis()->SetTitle("gain factor");
3607 graphCharge2->SetMarkerColor(8);
3608 graphCharge2->SetLineColor(8);
3609 graphCharge2->SetMarkerStyle(25);
3610 legch1->AddEntry(graphCharge2,"f_{g} fitbis","p");
3611 graphCharge2->Draw("P");
3612 listofgraphs->Add((TObject *)graphCharge2);
3613 }
3614 legch1->Draw("same");
3615
3616 //Create the arrays and the graphs for the delta
3617 Int_t thefirst = 0;
3618 TCanvas *cch2 = new TCanvas("cch2","",50,50,600,800);
3619 cch2->Divide(2,1);
3620 TLegend *legch3 = new TLegend(0.4,0.6,0.89,0.89);
3621 TLegend *legch2 = new TLegend(0.4,0.6,0.89,0.89);
3622
3623 if(fFitChargeOn){
3624 cch2->cd(2);
3625 Double_t *yValuesDelta = new Double_t[counter[0]];
3626 for(Int_t k = 0; k < counter[0]; k++){
3627 if (fCoefCharge[3][(Int_t)(xValuesFitted[k])] > 0.0) {
3628 yValuesDelta[k] = (fCoefCharge[0][(Int_t)xValuesFitted[k]]-fCoefCharge[3][(Int_t)xValuesFitted[k]])
3629 / fCoefCharge[3][(Int_t)xValuesFitted[k]];
3630 }
3631 else {
3632 yValuesDelta[k] = 0.0;
3633 }
3634 }
3635 TGraph *graphDeltaCharge0 = new TGraph(counter[0],&xValuesFitted[0],yValuesDelta);
3636 graphDeltaCharge0->SetName("deltacharge0");
3637 graphDeltaCharge0->GetXaxis()->SetTitle("Det/Pad groups");
3638 graphDeltaCharge0->GetYaxis()->SetTitle("#Deltag/g_{sim}");
3639 graphDeltaCharge0->SetMarkerColor(6);
3640 graphDeltaCharge0->SetTitle("");
3641 graphDeltaCharge0->SetLineColor(6);
3642 graphDeltaCharge0->SetMarkerStyle(26);
3643 listofgraphs->Add((TObject *)graphDeltaCharge0);
3644 legch3->AddEntry(graphDeltaCharge0,"fit","p");
3645 graphDeltaCharge0->Draw("AP");
3646
3647 cch2->cd(1);
3648 TH1I *histoErrorCharge0 = new TH1I("errorcharge0","",100 ,-0.10,0.10);
3649 histoErrorCharge0->SetXTitle("#Deltag/g_{sim}");
3650 histoErrorCharge0->SetYTitle("counts");
3651 histoErrorCharge0->SetLineColor(6);
3652 histoErrorCharge0->SetLineStyle(1);
3653 histoErrorCharge0->SetStats(0);
3654 Double_t maxvalue = 0.0;
3655 for(Int_t k = 0; k < counter[0]; k++){
3656 histoErrorCharge0->Fill(yValuesDelta[k]);
3657 if(k == 0) maxvalue = TMath::Abs(yValuesDelta[k]);
3658 if(maxvalue < (TMath::Abs(yValuesDelta[k]))) maxvalue = TMath::Abs(yValuesDelta[k]);
3659 }
3660 AliInfo(Form("The maximum deviation found dor the fit method is %f",maxvalue));
3661 legch2->AddEntry(histoErrorCharge0,"f_{g} fit","l");
3662 histoErrorCharge0->Draw();
3663 listofgraphs->Add((TObject *)histoErrorCharge0);
3664 thefirst =1;
3665 }
3666
3667 if(fFitMeanWOn){
3668 cch2->cd(2);
3669 Double_t *yValuesDelta = new Double_t[counter[3]];
3670 for(Int_t k = 0; k < counter[3]; k++){
3671 if (fCoefCharge[3][(Int_t)(xValuesFittedMeanW[k])] > 0.0) {
3672 yValuesDelta[k] = (fCoefCharge[4][(Int_t)xValuesFittedMeanW[k]]-fCoefCharge[3][(Int_t)xValuesFittedMeanW[k]])
3673 / fCoefCharge[3][(Int_t)xValuesFittedMeanW[k]];
3674 }
3675 else {
3676 yValuesDelta[k] = 0.0;
3677 }
3678 }
3679 TGraph *graphDeltaCharge4 = new TGraph(counter[3],&xValuesFittedMeanW[0],yValuesDelta);
3680 graphDeltaCharge4->SetName("deltacharge4");
3681 graphDeltaCharge4->GetXaxis()->SetTitle("Det/Pad groups");
3682 graphDeltaCharge4->GetYaxis()->SetTitle("#Deltag/g_{sim}");
3683 graphDeltaCharge4->SetMarkerColor(1);
3684 graphDeltaCharge4->SetTitle("");
3685 graphDeltaCharge4->SetLineColor(1);
3686 graphDeltaCharge4->SetMarkerStyle(30);
3687 listofgraphs->Add((TObject *)graphDeltaCharge4);
3688 legch3->AddEntry(graphDeltaCharge4,"Mean W","p");
3689 if(thefirst == 0){
3690 graphDeltaCharge4->Draw("AP");
3691 }
3692 else {
3693 graphDeltaCharge4->Draw("P");
3694 }
3695
3696 cch2->cd(1);
3697 TH1I *histoErrorCharge4 = new TH1I("errorcharge4","",100 ,-0.10,0.10);
3698 histoErrorCharge4->SetXTitle("#Deltag/g_{sim}");
3699 histoErrorCharge4->SetYTitle("counts");
3700 histoErrorCharge4->SetLineColor(1);
3701 histoErrorCharge4->SetLineStyle(1);
3702 histoErrorCharge4->SetStats(0);
3703 Double_t maxvalue = 0.0;
3704 for(Int_t k = 0; k < counter[3]; k++){
3705 histoErrorCharge4->Fill(yValuesDelta[k]);
3706 if(k == 0) maxvalue = yValuesDelta[k];
3707 if(maxvalue < (TMath::Abs(yValuesDelta[k]))) maxvalue = TMath::Abs(yValuesDelta[k]);
3708 }
3709 AliInfo(Form("The maximum deviation found for the meanW method is %f",maxvalue));
3710 legch2->AddEntry(histoErrorCharge4,"f_{g} Mean W","l");
3711 if(thefirst == 0){
3712 histoErrorCharge4->Draw();
3713 }
3714 else {
3715 histoErrorCharge4->Draw("same");
3716 }
3717 listofgraphs->Add((TObject *)histoErrorCharge4);
3718 thefirst =1;
3719 }
3720
3721 if (fMeanChargeOn) {
3722 cch2->cd(2);
3723 Double_t *yValuesDeltaMean = new Double_t[counter[1]];
3724 for (Int_t k = 0; k < counter[1]; k++){
3725 if (fCoefCharge[3][(Int_t)xValuesFittedMean[k]] > 0.0) {
3726 yValuesDeltaMean[k] = (fCoefCharge[1][(Int_t)xValuesFittedMean[k]]-fCoefCharge[3][(Int_t)xValuesFittedMean[k]])
3727 / fCoefCharge[3][(Int_t)xValuesFittedMean[k]];
3728 }
3729 else {
3730 yValuesDeltaMean[k] = 0.0;
3731 }
3732 }
3733 TGraph *graphDeltaCharge1 = new TGraph(counter[1],&xValuesFittedMean[0],yValuesDeltaMean);
3734 graphDeltaCharge1->SetName("deltacharge1");
3735 graphDeltaCharge1->GetXaxis()->SetTitle("Det/Pad groups");
3736 graphDeltaCharge1->GetYaxis()->SetTitle("#Deltag/g_{sim}");
3737 graphDeltaCharge1->SetMarkerColor(2);
3738 graphDeltaCharge1->SetMarkerStyle(24);
3739 graphDeltaCharge1->SetLineColor(2);
3740 graphDeltaCharge1->SetTitle("");
3741 legch3->AddEntry(graphDeltaCharge1,"mean","p");
3742 if(thefirst == 0){
3743 graphDeltaCharge1->Draw("AP");
3744 }
3745 else {
3746 graphDeltaCharge1->Draw("P");
3747 }
3748 listofgraphs->Add((TObject *)graphDeltaCharge1);
3749
3750 cch2->cd(1);
3751 TH1I *histoErrorCharge1 = new TH1I("errorcharge1","",100 ,-0.10,0.10);
3752 histoErrorCharge1->SetXTitle("#Deltag/g_{sim}");
3753 histoErrorCharge1->SetYTitle("counts");
3754 histoErrorCharge1->SetLineColor(2);
3755 histoErrorCharge1->SetLineStyle(2);
3756 histoErrorCharge1->SetStats(0);
3757 Double_t maxvalue = 0.0;
3758 for(Int_t k = 0; k < counter[1]; k++){
3759 histoErrorCharge1->Fill(yValuesDeltaMean[k]);
3760 if(k == 0) maxvalue = TMath::Abs(yValuesDeltaMean[k]);
3761 if(maxvalue < (TMath::Abs(yValuesDeltaMean[k]))) maxvalue = TMath::Abs(yValuesDeltaMean[k]);
3762 }
3763 AliInfo(Form("The maximum deviation found for the mean method is %f",maxvalue));
3764 legch2->AddEntry(histoErrorCharge1,"f_{g} mean","l");
3765 if(thefirst == 0){
3766 histoErrorCharge1->Draw();
3767 }
3768 else {
3769 histoErrorCharge1->Draw("same");
3770 }
3771 listofgraphs->Add((TObject *)histoErrorCharge1);
3772 thefirst = 1;
3773 }
3774
3775 if (fFitChargeBisOn) {
3776 cch2->cd(2);
3777 Double_t *yValuesDeltaBis = new Double_t[counter[2]];
3778 for(Int_t k = 0; k < counter[2]; k++){
3779 if (fCoefCharge[3][(Int_t)xValuesFittedBis[k]] > 0.0) {
3780 yValuesDeltaBis[k] = (fCoefCharge[2][(Int_t)xValuesFittedBis[k]]-fCoefCharge[3][(Int_t)xValuesFittedBis[k]])
3781 / fCoefCharge[3][(Int_t)xValuesFittedBis[k]];
3782 }
3783 else {
3784 yValuesDeltaBis[k] = 0.0;
3785 }
3786 }
3787 TGraph *graphDeltaCharge2 = new TGraph(counter[2],&xValuesFittedBis[0],yValuesDeltaBis);
3788 graphDeltaCharge2->SetName("deltacharge2");
3789 graphDeltaCharge2->GetXaxis()->SetTitle("Det/Pad groups");
3790 graphDeltaCharge2->GetYaxis()->SetTitle("#Deltag/g_{sim}");
3791 graphDeltaCharge2->SetMarkerColor(8);
3792 graphDeltaCharge2->SetLineColor(8);
3793 graphDeltaCharge2->SetMarkerStyle(25);
3794 legch3->AddEntry(graphDeltaCharge2,"fit","p");
3795 graphDeltaCharge2->SetTitle("");
3796 if(thefirst == 0){
3797 graphDeltaCharge2->Draw("AP");
3798 }
3799 else {
3800 graphDeltaCharge2->Draw("P");
3801 }
3802 listofgraphs->Add((TObject *)graphDeltaCharge2);
3803
3804 cch2->cd(1);
3805 TH1I *histoErrorCharge2 = new TH1I("errorcharge2","",100 ,-0.10, 0.10);
3806 histoErrorCharge2->SetXTitle("#Deltag/g_{sim}");
3807 histoErrorCharge2->SetYTitle("counts");
3808 histoErrorCharge2->SetLineColor(8);
3809 histoErrorCharge2->SetLineStyle(5);
3810 histoErrorCharge2->SetLineWidth(3);
3811 histoErrorCharge2->SetStats(0);
3812 Double_t maxvalue = 0.0;
3813 for(Int_t k = 0; k < counter[2]; k++){
3814 histoErrorCharge2->Fill(yValuesDeltaBis[k]);
3815 if(k == 0) maxvalue = TMath::Abs(yValuesDeltaBis[k]);
3816 if(maxvalue < (TMath::Abs(yValuesDeltaBis[k]))) maxvalue = TMath::Abs(yValuesDeltaBis[k]);
3817 }
3818 AliInfo(Form("The maximum deviation found for the fit bis method is %f",maxvalue));
3819 legch2->AddEntry(histoErrorCharge2,"f_{g} fitbis","l");
3820 if(thefirst == 0){
3821 histoErrorCharge2->Draw();
3822 }
3823 else {
3824 histoErrorCharge2->Draw("same");
3825 }
3826 listofgraphs->Add((TObject *)histoErrorCharge2);
3827 //it doesn't matter anymore but...
3828 thefirst = 1;
3829 }
3830
3831 cch2->cd(2);
3832 legch3->Draw("same");
3833 cch2->cd(1);
3834 legch2->Draw("same");
3835
3836 //Write if wanted
3837 if (fWriteCoef[0]){
3838 TFile *fout = TFile::Open(fWriteNameCoef,"UPDATE");
3839 // Check if the file could be opened
3840 if (!fout || !fout->IsOpen()) {
3841 AliInfo("No File found!");
3842 }
3843
3844 else{
3845 for(Int_t k = 0; k < listofgraphs->GetEntriesFast(); k++){
3846 fout->WriteTObject((TObject *) listofgraphs->At(k),((TObject *)listofgraphs->At(k))->GetName()
3847 ,(Option_t *) "OverWrite");
3848 }
3849 }
3850 fout->Close();
3851 }
3852
3853}
3854
3855//_____________________________________________________________________________
3856void AliTRDCalibraFit::PlotWritePH()
3857{
3858 //
3859 // create the graph errors and write them if wanted
3860 //
3861
3862 //TObjArray of the grapherrors and so on
3863 TObjArray *listofgraphs = new TObjArray();
3864
3865 Int_t nbins = fDect2[1]-fDect1[1];
3866
3867 //See the number of fitted for delta
3868
3869 //counter
3870 Int_t counter[3];
3871 counter[0] = 0;
3872 counter[1] = 0;
3873 counter[2] = 0;
3874
3875 Double_t *xValuesFitted = new Double_t[nbins];
3876 Double_t *xValuesFittedPH = new Double_t[nbins];
3877 Double_t *xValuesFittedLP = new Double_t[nbins];
3878 for(Int_t k = 0; k < nbins; k ++){
3879 xValuesFitted[k] = -1;
3880 xValuesFittedPH[k] = -1;
3881 xValuesFittedLP[k] = -1;
3882 }
3883
3884 if(fFitPol2On){
3885 for(Int_t l = 0; l < nbins; l++){
3886 if(fCoefVdrift[1][l] > 0){
3887 xValuesFitted[counter[1]]=l;
3888 counter[1]++;
3889 }
3890 }
3891 }
3892 if(fFitLagrPolOn){
3893 for(Int_t l = 0; l < nbins; l++){
3894 if(fCoefVdrift[3][l] > 0){
3895 xValuesFittedLP[counter[2]]=l;
3896 counter[2]++;
3897 }
3898 }
3899 }
3900 if(fFitPHOn){
3901 for(Int_t l = 0; l < nbins; l++){
3902 if(fCoefVdrift[0][l] > 0){
3903 xValuesFittedPH[counter[0]]= l;
3904 counter[0]++;
3905 }
3906 }
3907 }
3908
3909 //Create the X and Xerror
3910 Double_t *xValues = new Double_t[nbins];
3911 Double_t *xValuesE = new Double_t[nbins];
3912 for(Int_t k = 0; k < nbins; k ++){
3913 xValues[k] = k;
3914 xValuesE[k] = 0.0;
3915 }
3916
3917 //Create the graph erros and plot them
3918 TCanvas *cph1 = new TCanvas("cph1","",50,50,600,800);
3919 cph1->cd();
3920
3921 TGraph *graphVdrift2 = new TGraph(nbins,xValues,fCoefVdrift[2]);
3922 graphVdrift2->SetName("coefvdrift2");
3923 graphVdrift2->SetTitle("");
3924 graphVdrift2->GetXaxis()->SetTitle("Det/Pad groups");
3925 graphVdrift2->GetYaxis()->SetTitle("Vdrift [cm/#mus]");
3926 graphVdrift2->SetLineColor(4);
3927 listofgraphs->Add((TObject *)graphVdrift2);
3928 TLegend *legph1 = new TLegend(0.4,0.6,0.89,0.89);
3929 legph1->AddEntry(graphVdrift2,"Vdrift simulated","l");
3930 graphVdrift2->Draw("AL");
3931
3932 if(fFitPol2On){
3933 TGraphErrors *graphVdrift1 = new TGraphErrors(nbins,xValues,fCoefVdrift[1],xValuesE,fCoefVdriftE[1]);
3934 graphVdrift1->SetName("coefvdrift1");
3935 graphVdrift1->SetTitle("");
3936 graphVdrift1->GetXaxis()->SetTitle("Det/Pad groups");
3937 graphVdrift1->GetYaxis()->SetTitle("Vdrift [cm/#mus]");
3938 graphVdrift1->SetMarkerColor(6);
3939 graphVdrift1->SetLineColor(6);
3940 graphVdrift1->SetMarkerStyle(26);
3941 listofgraphs->Add((TObject *)graphVdrift1);
3942 legph1->AddEntry(graphVdrift1,"Vdrift fit","p");
3943 graphVdrift1->Draw("P");
3944 }
3945 if (fFitPHOn) {
3946 TGraphErrors *graphVdrift0 = new TGraphErrors(nbins,xValues,fCoefVdrift[0],xValuesE,fCoefVdriftE[0]);
3947 graphVdrift0->SetName("coefVdrift0");
3948 graphVdrift0->GetXaxis()->SetTitle("Det/Pad groups");
3949 graphVdrift0->GetYaxis()->SetTitle("Vdrift [cm/#mus]");
3950 graphVdrift0->SetTitle("");
3951 graphVdrift0->SetMarkerColor(2);
3952 graphVdrift0->SetLineColor(2);
3953 graphVdrift0->SetMarkerStyle(24);
3954 legph1->AddEntry(graphVdrift0,"v_{fit PH}","p");
3955 graphVdrift0->Draw("P");
3956 listofgraphs->Add((TObject *)graphVdrift0);
3957 }
3958 if (fFitLagrPolOn) {
3959 TGraphErrors *graphVdrift3 = new TGraphErrors(nbins,xValues,fCoefVdrift[3],xValuesE,fCoefVdriftE[2]);
3960 graphVdrift3->SetName("coefVdrift3");
3961 graphVdrift3->GetXaxis()->SetTitle("Det/Pad groups");
3962 graphVdrift3->GetYaxis()->SetTitle("Vdrift [cm/#mus]");
3963 graphVdrift3->SetTitle("");
3964 graphVdrift3->SetMarkerColor(1);
3965 graphVdrift3->SetLineColor(1);
3966 graphVdrift3->SetMarkerStyle(28);
3967 legph1->AddEntry(graphVdrift3,"v_{LagrPol}","p");
3968 graphVdrift3->Draw("P");
3969 listofgraphs->Add((TObject *)graphVdrift3);
3970 }
3971 legph1->Draw("same");
3972
3973 //Create the arrays and the graphs for the delta
3974 TCanvas *cph2 = new TCanvas("cph2","",50,50,600,800);
3975 cph2->Divide(2,1);
3976 TLegend *legph3 = new TLegend(0.4,0.6,0.89,0.89);
3977 TLegend *legph2 = new TLegend(0.4,0.6,0.89,0.89);
3978 Int_t first = 0;
3979
3980 if(fFitPol2On){
3981 cph2->cd(2);
3982 Double_t *yValuesDelta = new Double_t[counter[1]];
3983 for (Int_t k = 0; k < counter[1]; k++){
3984 if (fCoefVdrift[2][(Int_t)(xValuesFitted[k])] > 0.0) {
3985 yValuesDelta[k] = (fCoefVdrift[1][(Int_t)xValuesFitted[k]]-fCoefVdrift[2][(Int_t)xValuesFitted[k]])
3986 / fCoefVdrift[2][(Int_t)xValuesFitted[k]];
3987 }
3988 else {
3989 yValuesDelta[k] = 0.0;
3990 }
3991 }
3992 TGraph *graphDeltaVdrift1 = new TGraph(counter[1],&xValuesFitted[0],yValuesDelta);
3993 graphDeltaVdrift1->SetName("deltavdrift1");
3994 graphDeltaVdrift1->GetXaxis()->SetTitle("Det/Pad groups");
3995 graphDeltaVdrift1->GetYaxis()->SetTitle("#Deltav/v_{sim}");
3996 graphDeltaVdrift1->SetMarkerColor(6);
3997 graphDeltaVdrift1->SetTitle("");
3998 graphDeltaVdrift1->SetLineColor(6);
3999 graphDeltaVdrift1->SetMarkerStyle(26);
4000 listofgraphs->Add((TObject *)graphDeltaVdrift1);
4001 legph3->AddEntry(graphDeltaVdrift1,"v_{slope method}","p");
4002 graphDeltaVdrift1->Draw("AP");
4003
4004 cph2->cd(1);
4005 TH1I *histoErrorVdrift1 = new TH1I("errorvdrift1","",100 ,-0.2,0.2);
4006 histoErrorVdrift1->SetXTitle("#Deltav/v_{sim}");
4007 histoErrorVdrift1->SetYTitle("counts");
4008 histoErrorVdrift1->SetLineColor(6);
4009 histoErrorVdrift1->SetLineStyle(1);
4010 histoErrorVdrift1->SetStats(0);
4011 Double_t maxvalue = 0.0;
4012 for(Int_t k = 0; k < counter[1]; k++){
4013 histoErrorVdrift1->Fill(yValuesDelta[k]);
4014 if(k == 0) maxvalue = yValuesDelta[k];
4015 if(maxvalue < (TMath::Abs(yValuesDelta[k]))) maxvalue = TMath::Abs(yValuesDelta[k]);
4016 }
4017 AliInfo(Form("The maximum deviation found for the Pol2 method is %f",maxvalue));
4018 legph2->AddEntry(histoErrorVdrift1,"v_{slope method}","l");
4019 histoErrorVdrift1->Draw();
4020 listofgraphs->Add((TObject *)histoErrorVdrift1);
4021 first = 1;
4022 }
4023
4024 if (fFitPHOn) {
4025 cph2->cd(2);
4026 Double_t *yValuesDeltaPH = new Double_t[counter[0]];
4027 for(Int_t k = 0; k < counter[0]; k++){
4028 if(fCoefVdrift[2][(Int_t)xValuesFittedPH[k]] > 0.0) {
4029 yValuesDeltaPH[k] = (fCoefVdrift[0][(Int_t)xValuesFittedPH[k]]-fCoefVdrift[2][(Int_t)xValuesFittedPH[k]])/fCoefVdrift[2][(Int_t)xValuesFittedPH[k]];
4030 }
4031 else yValuesDeltaPH[k] = 0.0;
4032 }
4033 TGraph *graphDeltaVdrift0 = new TGraph(counter[0],&xValuesFittedPH[0],yValuesDeltaPH);
4034 graphDeltaVdrift0->SetName("deltavdrift0");
4035 graphDeltaVdrift0->GetXaxis()->SetTitle("Det/Pad groups");
4036 graphDeltaVdrift0->GetYaxis()->SetTitle("#Deltav/v_{sim}");
4037 graphDeltaVdrift0->SetMarkerColor(2);
4038 graphDeltaVdrift0->SetMarkerStyle(24);
4039 graphDeltaVdrift0->SetLineColor(2);
4040 graphDeltaVdrift0->SetTitle("");
4041 legph3->AddEntry(graphDeltaVdrift0,"v_{fit PH}","p");
4042 if(first){
4043 graphDeltaVdrift0->Draw("P");
4044 }
4045 else {
4046 graphDeltaVdrift0->Draw("AP");
4047 }
4048 listofgraphs->Add((TObject *)graphDeltaVdrift0);
4049 cph2->cd(1);
4050 TH1I *histoErrorVdrift0 = new TH1I("errorvdrift0","",100 ,-0.2,0.2);
4051 histoErrorVdrift0->SetXTitle("#Deltav/v_{sim}");
4052 histoErrorVdrift0->SetYTitle("counts");
4053 histoErrorVdrift0->SetLineColor(2);
4054 histoErrorVdrift0->SetLineStyle(2);
4055 histoErrorVdrift0->SetStats(0);
4056 Double_t maxvalue = 0.0;
4057 for(Int_t k = 0; k < counter[0]; k++){
4058 histoErrorVdrift0->Fill(yValuesDeltaPH[k]);
4059 if(k == 0) maxvalue = yValuesDeltaPH[k];
4060 if(maxvalue < (TMath::Abs(yValuesDeltaPH[k]))) maxvalue = TMath::Abs(yValuesDeltaPH[k]);
4061 }
4062 AliInfo(Form("The maximum deviation found for the fit method is %f",maxvalue));
4063 legph2->AddEntry(histoErrorVdrift0,"v_{fit PH}","l");
4064 if(first){
4065 histoErrorVdrift0->Draw("same");
4066 }
4067 else {
4068 histoErrorVdrift0->Draw();
4069 }
4070 listofgraphs->Add((TObject *)histoErrorVdrift0);
4071 first = 1;
4072 }
4073
4074 if (fFitLagrPolOn) {
4075 cph2->cd(2);
4076 Double_t *yValuesDeltaPH = new Double_t[counter[2]];
4077 for (Int_t k = 0; k < counter[2]; k++){
4078 if (fCoefVdrift[2][(Int_t)xValuesFittedLP[k]] > 0.0) {
4079 yValuesDeltaPH[k] = (fCoefVdrift[3][(Int_t)xValuesFittedLP[k]]-fCoefVdrift[2][(Int_t)xValuesFittedLP[k]])
4080 / fCoefVdrift[2][(Int_t)xValuesFittedLP[k]];
4081 }
4082 else {
4083 yValuesDeltaPH[k] = 0.0;
4084 }
4085 }
4086 TGraph *graphDeltaVdrift3 = new TGraph(counter[2],&xValuesFittedLP[0],yValuesDeltaPH);
4087 graphDeltaVdrift3->SetName("deltavdrift3");
4088 graphDeltaVdrift3->GetXaxis()->SetTitle("Det/Pad groups");
4089 graphDeltaVdrift3->GetYaxis()->SetTitle("#Deltav/v_{sim}");
4090 graphDeltaVdrift3->SetMarkerColor(1);
4091 graphDeltaVdrift3->SetMarkerStyle(28);
4092 graphDeltaVdrift3->SetLineColor(1);
4093 graphDeltaVdrift3->SetTitle("");
4094 legph3->AddEntry(graphDeltaVdrift3,"v_{LagrPol}","p");
4095 if(first){
4096 graphDeltaVdrift3->Draw("P");
4097 }
4098 else {
4099 graphDeltaVdrift3->Draw("AP");
4100 }
4101 listofgraphs->Add((TObject *)graphDeltaVdrift3);
4102 cph2->cd(1);
4103 TH1I *histoErrorVdrift3 = new TH1I("errorvdrift3","",100 ,-0.2,0.2);
4104 histoErrorVdrift3->SetXTitle("#Deltav/v_{sim}");
4105 histoErrorVdrift3->SetYTitle("counts");
4106 histoErrorVdrift3->SetLineColor(1);
4107 histoErrorVdrift3->SetLineStyle(1);
4108 histoErrorVdrift3->SetStats(0);
4109 Double_t maxvalue = 0.0;
4110 for(Int_t k = 0; k < counter[2]; k++){
4111 histoErrorVdrift3->Fill(yValuesDeltaPH[k]);
4112 if(k == 0) maxvalue = yValuesDeltaPH[k];
4113 if(maxvalue < (TMath::Abs(yValuesDeltaPH[k]))) maxvalue = TMath::Abs(yValuesDeltaPH[k]);
4114 }
4115 AliInfo(Form("The maximum deviation found for the LagrPol method is %f",maxvalue));
4116 legph2->AddEntry(histoErrorVdrift3,"v_{LagrPol}","l");
4117 if(first){
4118 histoErrorVdrift3->Draw("same");
4119 }
4120 else {
4121 histoErrorVdrift3->Draw();
4122 }
4123 listofgraphs->Add((TObject *)histoErrorVdrift3);
4124 first = 1;
4125 }
4126 cph2->cd(2);
4127 legph3->Draw("same");
4128 cph2->cd(1);
4129 legph2->Draw("same");
4130
4131 //Write if wanted
4132 if (fWriteCoef[1]){
4133 TFile *fout = TFile::Open(fWriteNameCoef,"UPDATE");
4134 // Check if the file could be opened
4135 if (!fout || !fout->IsOpen()) {
4136 AliInfo("No File found!");
4137 }
4138
4139 else{
4140 for(Int_t k = 0; k < listofgraphs->GetEntriesFast(); k++){
4141 fout->WriteTObject((TObject *) listofgraphs->At(k),((TObject *)listofgraphs->At(k))->GetName()
4142 ,(Option_t *) "OverWrite");
4143 }
4144 }
4145 fout->Close();
4146 }
4147
4148}
4149
4150//_____________________________________________________________________________
4151void AliTRDCalibraFit::PlotWriteT0()
4152{
4153 //
4154 // create the graph errors and write them if wanted
4155 //
4156
4157 //TObjArray of the grapherrors and so on
4158 TObjArray *listofgraphs = new TObjArray();
4159
4160 Int_t nbins = fDect2[1]-fDect1[1];
4161
4162 //See the number of fitted for delta: here T0 can be negative, we don't use the sign but the error
4163 //and the grapherrors of the coefficients contained the no fitted with error 0.0
4164
4165 //counter
4166 Int_t counter[3];
4167 counter[0] = 0;
4168 counter[1] = 0;
4169 counter[2] = 0;
4170
4171 Double_t *xValuesFitted = new Double_t[nbins];
4172 Double_t *xValuesFittedPH = new Double_t[nbins];
4173 Double_t *xValuesFittedLP = new Double_t[nbins];
4174 for(Int_t k = 0; k < nbins; k ++){
4175 xValuesFitted[k] = -1;
4176 xValuesFittedPH[k] = -1;
4177 xValuesFittedLP[k] = -1;
4178 }
4179
4180 if(fFitPol2On){
4181 for(Int_t l = 0; l < nbins; l++){
4182 if(fCoefT0E[1][l] != 0.0){
4183 xValuesFitted[counter[1]]=l;
4184 counter[1]++;
4185 }
4186 }
4187 }
4188
4189 if(fFitPHOn){
4190 for(Int_t l = 0; l < nbins; l++){
4191 if(fCoefT0E[0][l] != 0.0){
4192 xValuesFittedPH[counter[0]]= l;
4193 counter[0]++;
4194 }
4195 }
4196 }
4197
4198 if(fFitLagrPolOn){
4199 for(Int_t l = 0; l < nbins; l++){
4200 if(fCoefT0E[2][l] == 1.0){
4201 xValuesFittedLP[counter[2]]= l;
4202 counter[2]++;
4203 }
4204 }
4205 }
4206
4207 //Create the X and Xerror
4208 Double_t *xValues = new Double_t[nbins];
4209 Double_t *xValuesE = new Double_t[nbins];
4210 for(Int_t k = 0; k < nbins; k ++){
4211 xValues[k] = k;
4212 xValuesE[k] = 0.0;
4213 }
4214
4215 //Create the graph erros and plot them
4216 TCanvas *ct01 = new TCanvas("ct01","",50,50,600,800);
4217 ct01->cd();
4218 TLegend *legt01 = new TLegend(0.4,0.6,0.89,0.89);
4219
4220 TGraph *graphT02 = new TGraph(nbins,xValues,fCoefT0[2]);
4221 graphT02->SetName("coeft02");
4222 graphT02->SetTitle("");
4223 graphT02->GetXaxis()->SetTitle("Det/Pad groups");
4224 graphT02->GetYaxis()->SetTitle("T0 [time bins]");
4225 graphT02->SetLineColor(4);
4226 listofgraphs->Add((TObject *)graphT02);
4227 legt01->AddEntry(graphT02,"T0 simulated","l");
4228 graphT02->Draw("AL");
4229
4230 if(fFitPol2On){
4231 TGraphErrors *graphT01 = new TGraphErrors(nbins,xValues,fCoefT0[1],xValuesE,fCoefT0E[1]);
4232 graphT01->SetName("coeft01");
4233 graphT01->SetTitle("");
4234 graphT01->GetXaxis()->SetTitle("Det/Pad groups");
4235 graphT01->GetYaxis()->SetTitle("T0 [time bins]");
4236 graphT01->SetMarkerColor(6);
4237 graphT01->SetLineColor(6);
4238 graphT01->SetMarkerStyle(26);
4239 listofgraphs->Add((TObject *)graphT01);
4240 legt01->AddEntry(graphT01,"T0 slope method","p");
4241 graphT01->Draw("P");
4242 }
4243 if (fFitPHOn) {
4244 TGraphErrors *graphT00 = new TGraphErrors(nbins,xValues,fCoefT0[0],xValuesE,fCoefT0E[0]);
4245 graphT00->SetName("coeft00");
4246 graphT00->GetXaxis()->SetTitle("Det/Pad groups");
4247 graphT00->GetYaxis()->SetTitle("T0 [time bins]");
4248 graphT00->SetTitle("");
4249 graphT00->SetMarkerColor(2);
4250 graphT00->SetLineColor(2);
4251 graphT00->SetMarkerStyle(24);
4252 legt01->AddEntry(graphT00,"T0 fit","p");
4253 graphT00->Draw("P");
4254 listofgraphs->Add((TObject *)graphT00);
4255 }
4256 if (fFitLagrPolOn) {
4257 TGraphErrors *graphT03 = new TGraphErrors(nbins,xValues,fCoefT0[3],xValuesE,xValuesE);
4258 graphT03->SetName("coeft03");
4259 graphT03->GetXaxis()->SetTitle("Det/Pad groups");
4260 graphT03->GetYaxis()->SetTitle("T0 [time bins]");
4261 graphT03->SetTitle("");
4262 graphT03->SetMarkerColor(1);
4263 graphT03->SetLineColor(1);
4264 graphT03->SetMarkerStyle(28);
4265 legt01->AddEntry(graphT03,"T0 LagrPol","p");
4266 graphT03->Draw("P");
4267 listofgraphs->Add((TObject *)graphT03);
4268 }
4269 legt01->Draw("same");
4270
4271 //Create the arrays and the graphs for the delta
4272 TCanvas *ct02 = new TCanvas("ct02","",50,50,600,800);
4273 ct02->Divide(2,1);
4274 TLegend *legt03 = new TLegend(0.4,0.6,0.89,0.89);
4275 TLegend *legt02 = new TLegend(0.4,0.6,0.89,0.89);
4276 Int_t first = 0;
4277
4278 if(fFitPol2On){
4279 ct02->cd(2);
4280 Double_t *yValuesDelta = new Double_t[counter[1]];
4281 for(Int_t k = 0; k < counter[1]; k++){
4282 yValuesDelta[k] = (fCoefT0[1][(Int_t)xValuesFitted[k]]-fCoefT0[2][(Int_t)xValuesFitted[k]]);
4283 }
4284 TGraph *graphDeltaT01 = new TGraph(counter[1],&xValuesFitted[0],yValuesDelta);
4285 graphDeltaT01->SetName("deltat01");
4286 graphDeltaT01->GetXaxis()->SetTitle("Det/Pad groups");
4287 graphDeltaT01->GetYaxis()->SetTitle("#Deltat0 [time bins]");
4288 graphDeltaT01->SetMarkerColor(6);
4289 graphDeltaT01->SetTitle("");
4290 graphDeltaT01->SetLineColor(6);
4291 graphDeltaT01->SetMarkerStyle(26);
4292 listofgraphs->Add((TObject *)graphDeltaT01);
4293 legt03->AddEntry(graphDeltaT01,"T0_{slope method}","p");
4294 graphDeltaT01->Draw("AP");
4295
4296 ct02->cd(1);
4297 TH1I *histoErrorT01 = new TH1I("errort01","",100 ,-0.2,0.2);
4298 histoErrorT01->SetXTitle("#Deltat0 [time bins]");
4299 histoErrorT01->SetYTitle("counts");
4300 histoErrorT01->SetLineColor(6);
4301 histoErrorT01->SetLineStyle(1);
4302 histoErrorT01->SetStats(0);
4303 Double_t maxvalue = 0.0;
4304 for(Int_t k = 0; k < counter[1]; k++){
4305 histoErrorT01->Fill(yValuesDelta[k]);
4306 if(k == 0) maxvalue = yValuesDelta[k];
4307 if(maxvalue < (TMath::Abs(yValuesDelta[k]))) maxvalue = (TMath::Abs(yValuesDelta[k]));
4308 }
4309 AliInfo(Form("The maximum deviation found for the Pol2 method is %f",maxvalue));
4310 legt02->AddEntry(histoErrorT01,"T0_{slope method}","l");
4311 histoErrorT01->Draw();
4312 listofgraphs->Add((TObject *)histoErrorT01);
4313 first = 1;
4314 }
4315 if (fFitPHOn) {
4316 ct02->cd(2);
4317 Double_t *yValuesDeltaPH = new Double_t[counter[0]];
4318 for(Int_t k = 0; k < counter[0]; k++){
4319 yValuesDeltaPH[k] = (fCoefT0[0][(Int_t)xValuesFittedPH[k]]-fCoefT0[2][(Int_t)xValuesFittedPH[k]]);
4320 }
4321 TGraph *graphDeltaT00 = new TGraph(counter[0],&xValuesFittedPH[0],yValuesDeltaPH);
4322 graphDeltaT00->SetName("deltat00");
4323 graphDeltaT00->GetXaxis()->SetTitle("Det/Pad groups");
4324 graphDeltaT00->GetYaxis()->SetTitle("#Deltat0 [time bins]");
4325 graphDeltaT00->SetMarkerColor(2);
4326 graphDeltaT00->SetMarkerStyle(24);
4327 graphDeltaT00->SetLineColor(2);
4328 graphDeltaT00->SetTitle("");
4329 legt03->AddEntry(graphDeltaT00,"T0_{fit PH}","p");
4330 if(first) {
4331 graphDeltaT00->Draw("P");
4332 }
4333 else{
4334 graphDeltaT00->Draw("AP");
4335 }
4336 listofgraphs->Add((TObject *)graphDeltaT00);
4337 ct02->cd(1);
4338 TH1I *histoErrorT00 = new TH1I("errort00","",100 ,-0.2,0.2);
4339 histoErrorT00->SetXTitle("#Deltat0 [time bins]");
4340 histoErrorT00->SetYTitle("counts");
4341 histoErrorT00->SetLineColor(2);
4342 histoErrorT00->SetLineStyle(2);
4343 histoErrorT00->SetStats(0);
4344 Double_t maxvalue = 0.0;
4345 for(Int_t k = 0; k < counter[0]; k++){
4346 histoErrorT00->Fill(yValuesDeltaPH[k]);
4347 if(k == 0) maxvalue = yValuesDeltaPH[k];
4348 if(maxvalue < (TMath::Abs(yValuesDeltaPH[k]))) maxvalue = (TMath::Abs(yValuesDeltaPH[k]));
4349 }
4350 AliInfo(Form("The maximum deviation found for the fit method is %f",maxvalue));
4351 legt02->AddEntry(histoErrorT00,"T0_{fit PH}","l");
4352 if(first){
4353 histoErrorT00->Draw("same");
4354 }
4355 else{
4356 histoErrorT00->Draw();
4357 }
4358 listofgraphs->Add((TObject *)histoErrorT00);
4359 first = 1;
4360 }
4361
4362 if (fFitLagrPolOn) {
4363 ct02->cd(2);
4364 Double_t *yValuesDeltaPH = new Double_t[counter[2]];
4365 for(Int_t k = 0; k < counter[2]; k++){
4366 yValuesDeltaPH[k] = (fCoefT0[3][(Int_t)xValuesFittedLP[k]]-fCoefT0[2][(Int_t)xValuesFittedLP[k]]);
4367 }
4368 TGraph *graphDeltaT03 = new TGraph(counter[2],&xValuesFittedLP[0],yValuesDeltaPH);
4369 graphDeltaT03->SetName("deltat03");
4370 graphDeltaT03->GetXaxis()->SetTitle("Det/Pad groups");
4371 graphDeltaT03->GetYaxis()->SetTitle("#Deltat0 [time bins]");
4372 graphDeltaT03->SetMarkerColor(1);
4373 graphDeltaT03->SetMarkerStyle(28);
4374 graphDeltaT03->SetLineColor(1);
4375 graphDeltaT03->SetTitle("");
4376 legt03->AddEntry(graphDeltaT03,"T0_{LagrPol}","p");
4377 if(first) {
4378 graphDeltaT03->Draw("P");
4379 }
4380 else{
4381 graphDeltaT03->Draw("AP");
4382 }
4383 listofgraphs->Add((TObject *)graphDeltaT03);
4384 ct02->cd(1);
4385 TH1I *histoErrorT03 = new TH1I("errort03","",100 ,-0.2,0.2);
4386 histoErrorT03->SetXTitle("#Deltat0 [time bins]");
4387 histoErrorT03->SetYTitle("counts");
4388 histoErrorT03->SetLineColor(1);
4389 histoErrorT03->SetLineStyle(1);
4390 histoErrorT03->SetStats(0);
4391 Double_t maxvalue = 0.0;
4392 for(Int_t k = 0; k < counter[2]; k++){
4393 histoErrorT03->Fill(yValuesDeltaPH[k]);
4394 if(k == 0) maxvalue = yValuesDeltaPH[k];
4395 if(maxvalue < (TMath::Abs(yValuesDeltaPH[k]))) maxvalue = (TMath::Abs(yValuesDeltaPH[k]));
4396 }
4397 AliInfo(Form("The maximum deviation found for the LagrPol method is %f",maxvalue));
4398 legt02->AddEntry(histoErrorT03,"T0_{LagrPol}","l");
4399 if(first){
4400 histoErrorT03->Draw("same");
4401 }
4402 else{
4403 histoErrorT03->Draw();
4404 }
4405 listofgraphs->Add((TObject *)histoErrorT03);
4406 first = 1;
4407 }
4408
4409 ct02->cd(2);
4410 legt03->Draw("same");
4411 ct02->cd(1);
4412 legt02->Draw("same");
4413
4414 //Write if wanted
4415 if (fWriteCoef[1]){
4416 TFile *fout = TFile::Open(fWriteNameCoef,"UPDATE");
4417 // Check if the file could be opened
4418 if (!fout || !fout->IsOpen()) {
4419 AliInfo("No File found!");
4420 }
4421
4422 else{
4423 for(Int_t k = 0; k < listofgraphs->GetEntriesFast(); k++){
4424 fout->WriteTObject((TObject *) listofgraphs->At(k),((TObject *)listofgraphs->At(k))->GetName()
4425 ,(Option_t *) "OverWrite");
4426 }
4427 }
4428 fout->Close();
4429 }
4430
4431}
4432
4433//_____________________________________________________________________________
4434void AliTRDCalibraFit::PlotWritePRF()
4435{
4436 //
4437 // create the graph errors and write them if wanted
4438 //
4439
4440 //TObjArray of the grapherrors and so on
4441 TObjArray *listofgraphs = new TObjArray();
4442
4443 Int_t nbins = fDect2[2]-fDect1[2];
4444
4445 //See the number of fitted for delta
4446
4447 //counter
4448 Int_t counter[2];
4449 counter[0] = 0;
4450 counter[1] = 0;
4451
4452 Double_t *xValuesFitted = new Double_t[nbins];
4453 for(Int_t k = 0; k < nbins; k ++){
4454 xValuesFitted[k] = -1;
4455 }
4456 Double_t *xValuesRMS = new Double_t[nbins];
4457 for(Int_t k = 0; k < nbins; k ++){
4458 xValuesRMS[k] = -1;
4459 }
4460
4461 if(fFitPRFOn){
4462 for(Int_t l = 0; l < nbins; l++){
4463 if(fCoefPRF[0][l] > 0){
4464 xValuesFitted[counter[0]]=l;
4465 counter[0]++;
4466 }
4467 }
4468 }
4469 if(fRMSPRFOn){
4470 for(Int_t l = 0; l < nbins; l++){
4471 if(fCoefPRF[2][l] > 0){
4472 xValuesRMS[counter[1]]=l;
4473 counter[1]++;
4474 }
4475 }
4476 }
4477
4478
4479 //Create the X and Xerror
4480 Double_t *xValues = new Double_t[nbins];
4481 Double_t *xValuesE = new Double_t[nbins];
4482 for(Int_t k = 0; k < nbins; k ++){
4483 xValues[k] = k;
4484 xValuesE[k] = 0.0;
4485 }
4486
4487 //Create the graph erros and plot them
4488 TCanvas *cprf1 = new TCanvas("cprf1","",50,50,600,800);
4489 cprf1->cd();
4490 TLegend *legprf1 = new TLegend(0.4,0.6,0.89,0.89);
4491
4492 TGraph *graphPRF1 = new TGraph(nbins,xValues,fCoefPRF[1]);
4493 graphPRF1->SetName("coefprf1");
4494 graphPRF1->SetTitle("");
4495 graphPRF1->GetXaxis()->SetTitle("Det/Pad groups");
4496 graphPRF1->GetYaxis()->SetTitle("PRF width [p.u]");
4497 graphPRF1->SetLineColor(4);
4498 graphPRF1->SetMarkerColor(4);
4499 graphPRF1->SetMarkerStyle(25);
4500 graphPRF1->SetMarkerSize(0.7);
4501 listofgraphs->Add((TObject *)graphPRF1);
4502 legprf1->AddEntry(graphPRF1,"PRF width simulated","p");
4503 graphPRF1->Draw("AP");
4504
4505 if(fFitPRFOn){
4506 TGraphErrors *graphPRF0 = new TGraphErrors(nbins,xValues,fCoefPRF[0],xValuesE,fCoefPRFE[0]);
4507 graphPRF0->SetName("coefprf0");
4508 graphPRF0->SetTitle("");
4509 graphPRF0->GetXaxis()->SetTitle("Det/Pad groups");
4510 graphPRF0->GetYaxis()->SetTitle("PRF Width [p.u]");
4511 graphPRF0->SetMarkerColor(6);
4512 graphPRF0->SetLineColor(6);
4513 graphPRF0->SetMarkerStyle(26);
4514 listofgraphs->Add((TObject *)graphPRF0);
4515 legprf1->AddEntry(graphPRF0,"PRF fit","p");
4516 graphPRF0->Draw("P");
4517 }
4518 if(fRMSPRFOn){
4519 TGraphErrors *graphPRF2 = new TGraphErrors(nbins,xValues,fCoefPRF[2],xValuesE,fCoefPRFE[1]);
4520 graphPRF2->SetName("coefprf2");
4521 graphPRF2->SetTitle("");
4522 graphPRF2->GetXaxis()->SetTitle("Det/Pad groups");
4523 graphPRF2->GetYaxis()->SetTitle("PRF Width [p.u]");
4524 graphPRF2->SetMarkerColor(1);
4525 graphPRF2->SetLineColor(1);
4526 graphPRF2->SetMarkerStyle(28);
4527 listofgraphs->Add((TObject *)graphPRF2);
4528 legprf1->AddEntry(graphPRF2,"PRF Rms","p");
4529 graphPRF2->Draw("P");
4530 }
4531 legprf1->Draw("same");
4532
4533
4534 //Create the arrays and the graphs for the delta
4535 TCanvas *cprf2 = new TCanvas("cprf2","",50,50,600,800);
4536 cprf2->Divide(2,1);
4537 Int_t first = 0;
4538 TLegend *legprf3 = new TLegend(0.4,0.6,0.89,0.89);
4539 TLegend *legprf2 = new TLegend(0.4,0.6,0.89,0.89);
4540
4541 if(fFitPRFOn){
4542 cprf2->cd(2);
4543 Double_t *yValuesDelta = new Double_t[counter[0]];
4544 for(Int_t k = 0; k < counter[0]; k++){
4545 if(fCoefPRF[1][(Int_t)xValuesFitted[k]] > 0.0){
4546 yValuesDelta[k] = (fCoefPRF[0][(Int_t)xValuesFitted[k]]-fCoefPRF[1][(Int_t)xValuesFitted[k]])
4547 / (fCoefPRF[1][(Int_t)xValuesFitted[k]]);
4548 }
4549 }
4550 TGraph *graphDeltaPRF0 = new TGraph(counter[0],&xValuesFitted[0],yValuesDelta);
4551 graphDeltaPRF0->SetName("deltaprf0");
4552 graphDeltaPRF0->GetXaxis()->SetTitle("Det/Pad groups");
4553 graphDeltaPRF0->GetYaxis()->SetTitle("#Delta#sigma/#sigma_{sim}");
4554 graphDeltaPRF0->SetMarkerColor(6);
4555 graphDeltaPRF0->SetTitle("");
4556 graphDeltaPRF0->SetLineColor(6);
4557 graphDeltaPRF0->SetMarkerStyle(26);
4558 listofgraphs->Add((TObject *)graphDeltaPRF0);
4559 legprf3->AddEntry(graphDeltaPRF0,"#sigma_{fit}","p");
4560 graphDeltaPRF0->Draw("AP");
4561
4562 cprf2->cd(1);
4563 TH1I *histoErrorPRF0 = new TH1I("errorprf10","",100 ,-0.1,0.2);
4564 histoErrorPRF0->SetXTitle("#Delta#sigma/#sigma_{sim}");
4565 histoErrorPRF0->SetYTitle("counts");
4566 histoErrorPRF0->SetLineColor(6);
4567 histoErrorPRF0->SetLineStyle(1);
4568 histoErrorPRF0->SetStats(0);
4569 Double_t maxvalue = 0.0;
4570 for(Int_t k = 0; k < counter[0]; k++){
4571 histoErrorPRF0->Fill(yValuesDelta[k]);
4572 if(k == 0) maxvalue = yValuesDelta[k];
4573 if(maxvalue < (TMath::Abs(yValuesDelta[k]))) maxvalue = (TMath::Abs(yValuesDelta[k]));
4574 }
4575 AliInfo(Form("The maximum deviation for the fit method is %f",maxvalue));
4576 legprf2->AddEntry(histoErrorPRF0,"#sigma_{fit}","l");
4577 histoErrorPRF0->Draw();
4578 listofgraphs->Add((TObject *)histoErrorPRF0);
4579 first = 1;
4580 }
4581
4582 if(fRMSPRFOn){
4583 cprf2->cd(2);
4584 Double_t *yValuesDelta = new Double_t[counter[1]];
4585 for(Int_t k = 0; k < counter[1]; k++){
4586 if(fCoefPRF[1][(Int_t)xValuesRMS[k]] > 0.0){
4587 yValuesDelta[k] = (fCoefPRF[2][(Int_t)xValuesRMS[k]]-fCoefPRF[1][(Int_t)xValuesRMS[k]])
4588 / (fCoefPRF[1][(Int_t)xValuesRMS[k]]);
4589 }
4590 }
4591 TGraph *graphDeltaPRF2 = new TGraph(counter[1],&xValuesRMS[0],yValuesDelta);
4592 graphDeltaPRF2->SetName("deltaprf2");
4593 graphDeltaPRF2->GetXaxis()->SetTitle("Det/Pad groups");
4594 graphDeltaPRF2->GetYaxis()->SetTitle("#Delta#sigma/#sigma_{sim}");
4595 graphDeltaPRF2->SetMarkerColor(1);
4596 graphDeltaPRF2->SetTitle("");
4597 graphDeltaPRF2->SetLineColor(1);
4598 graphDeltaPRF2->SetMarkerStyle(28);
4599 listofgraphs->Add((TObject *)graphDeltaPRF2);
4600 legprf3->AddEntry(graphDeltaPRF2,"#sigma_{rms}","p");
4601 if(first){
4602 graphDeltaPRF2->Draw("P");
4603 }
4604 else {
4605 graphDeltaPRF2->Draw("AP");
4606 }
4607
4608 cprf2->cd(1);
4609 TH1I *histoErrorPRF2 = new TH1I("errorprf12","",100 ,-0.1,0.2);
4610 histoErrorPRF2->SetXTitle("#Delta#sigma/#sigma_{sim}");
4611 histoErrorPRF2->SetYTitle("counts");
4612 histoErrorPRF2->SetLineColor(1);
4613 histoErrorPRF2->SetLineStyle(1);
4614 histoErrorPRF2->SetStats(0);
4615 Double_t maxvalue = 0.0;
4616 for(Int_t k = 0; k < counter[1]; k++){
4617 histoErrorPRF2->Fill(yValuesDelta[k]);
4618 if(k == 0) maxvalue = yValuesDelta[k];
4619 if(maxvalue < TMath::Abs(yValuesDelta[k])) maxvalue = TMath::Abs(yValuesDelta[k]);
4620 }
4621 AliInfo(Form("The maximum deviation for the rms is %f",maxvalue));
4622 legprf2->AddEntry(histoErrorPRF2,"#sigma_{rms}","l");
4623 if(first){
4624 histoErrorPRF2->Draw("same");
4625 }
4626 else {
4627 histoErrorPRF2->Draw();
4628 }
4629 listofgraphs->Add((TObject *)histoErrorPRF2);
4630 first = 1;
4631 }
4632
4633 cprf2->cd(2);
4634 legprf3->Draw("same");
4635 cprf2->cd(1);
4636 legprf2->Draw("same");
4637
4638
4639 //Write if wanted
4640 if (fWriteCoef[2]){
4641 TFile *fout = TFile::Open(fWriteNameCoef,"UPDATE");
4642 // Check if the file could be opened
4643 if (!fout || !fout->IsOpen()) {
4644 AliInfo("No File found!");
4645 }
4646
4647 else{
4648 for(Int_t k = 0; k < listofgraphs->GetEntriesFast(); k++){
4649 fout->WriteTObject((TObject *) listofgraphs->At(k),((TObject *)listofgraphs->At(k))->GetName()
4650 ,(Option_t *) "OverWrite");
4651 }
4652 }
4653 fout->Close();
4654 }
4655
4656}
4657
4658//
4659//____________Plot histos DB___________________________________________________
4660//
4661
4662//_____________________________________________________________________________
4663void AliTRDCalibraFit::PlotCHDB()
4664{
4665 //
4666 // Plot the histos for fDebug = 3 and fDebug = 4 to visualise the detector
4667 //
4668
4669 TCanvas *cchdb = new TCanvas("cchdb","",50,50,600,800);
4670 Int_t nb = 0;
4671 if(fFitChargeOn) nb++;
4672 if(fFitChargeBisOn) nb++;
4673 if(fMeanChargeOn) nb++;
4674 if(fFitMeanWOn) nb++;
4675 if(nb > 0){
4676 cchdb->Divide(nb,1);
4677 nb = 0;
4678 if(fMeanChargeOn){
4679 cchdb->cd(nb);
4680 fCoefChargeDB[1]->Draw("LEGO");
4681 nb++;
4682 }
4683 if(fFitChargeOn){
4684 cchdb->cd(nb);
4685 fCoefChargeDB[0]->Draw("LEGO");
4686 nb++;
4687 }
4688 if(fFitMeanWOn){
4689 cchdb->cd(nb);
4690 fCoefChargeDB[3]->Draw("LEGO");
4691 nb++;
4692 }
4693 if(fFitChargeBisOn){
4694 cchdb->cd(nb);
4695 fCoefChargeDB[2]->Draw("LEGO");
4696 //it doesn't matter anymore but....
4697 nb++;
4698 }
4699 }
4700}
4701
4702//_____________________________________________________________________________
4703void AliTRDCalibraFit::PlotPHDB()
4704{
4705 //
4706 // Plot the histos for fDebug = 3 and fDebug = 4 to visualise the detector
4707 //
4708
4709 TCanvas *cphdb = new TCanvas("cphdb","",50,50,600,800);
4710 Int_t nb = 0;
4711 if(fFitPol2On) nb++;
4712 if(fFitPHOn) nb++;
4713 if(fFitLagrPolOn) nb++;
4714 if(nb > 0){
4715 cphdb->Divide(nb,1);
4716 nb = 0;
4717 if(fFitPHOn){
4718 cphdb->cd(nb);
4719 fCoefVdriftDB[0]->Draw("LEGO");
4720 nb++;
4721 }
4722 if(fFitPol2On){
4723 cphdb->cd(nb);
4724 fCoefVdriftDB[1]->Draw("LEGO");
4725 nb++;
4726 }
4727 if(fFitLagrPolOn){
4728 cphdb->cd(nb);
4729 fCoefVdriftDB[2]->Draw("LEGO");
4730 nb++;
4731 }
4732 }
4733}
4734
4735//_____________________________________________________________________________
4736void AliTRDCalibraFit::PlotT0DB()
4737{
4738 //
4739 // Plot the histos for fDebug = 3 and fDebug = 4 to visualise the detector
4740 //
4741 TCanvas *ct0db = new TCanvas("ct0db","",50,50,600,800);
4742 Int_t nb = 0;
4743 if(fFitPol2On) nb++;
4744 if(fFitPHOn) nb++;
4745 if(fFitLagrPolOn) nb++;
4746 if(nb > 0){
4747 ct0db->Divide(nb,1);
4748 nb = 0;
4749 if(fFitPHOn){
4750 ct0db->cd(nb);
4751 fCoefT0DB[0]->Draw("LEGO");
4752 nb++;
4753 }
4754 if(fFitPol2On){
4755 ct0db->cd(nb);
4756 fCoefT0DB[1]->Draw("LEGO");
4757 nb++;
4758 }
4759 if(fFitLagrPolOn){
4760 ct0db->cd(nb);
4761 fCoefT0DB[2]->Draw("LEGO");
4762 nb++;
4763 }
4764 }
4765}
4766
4767//_____________________________________________________________________________
4768void AliTRDCalibraFit::PlotPRFDB()
4769{
4770 //
4771 // Plot the histos for fDebug = 3 and fDebug = 4 to visualise the detector
4772 //
4773
4774 TCanvas *cprfdb = new TCanvas("cprfdb","",50,50,600,800);
4775 Int_t nb = 0;
4776 if(fFitPRFOn) nb++;
4777 if(fRMSPRFOn) nb++;
4778 if(nb > 0){
4779 cprfdb->Divide(nb,1);
4780 nb = 0;
4781 if(fFitPRFOn){
4782 cprfdb->cd(nb);
4783 fCoefPRFDB[0]->Draw("LEGO");
4784 nb++;
4785 }
4786 if(fRMSPRFOn){
4787 cprfdb->cd(nb);
4788 fCoefPRFDB[1]->Draw("LEGO");
4789 nb++;
4790 }
4791 }
4792}
4793
4794//
4795//____________Write DB Histos__________________________________________________
4796//
4797
4798//_____________________________________________________________________________
4799void AliTRDCalibraFit::WriteCHDB(TFile *fout)
4800{
4801 //
4802 // If wanted, write the debug histos for fDebug = 3 and fDebug = 4
4803 //
4804 if(fFitChargeOn){
4805 fout->WriteTObject(fCoefChargeDB[0],fCoefChargeDB[0]->GetName(),(Option_t *) "OverWrite");
4806 }
4807 if(fFitMeanWOn){
4808 fout->WriteTObject(fCoefChargeDB[3],fCoefChargeDB[0]->GetName(),(Option_t *) "OverWrite");
4809 }
4810 if (fMeanChargeOn) {
4811 fout->WriteTObject(fCoefChargeDB[1],fCoefChargeDB[1]->GetName(),(Option_t *) "OverWrite");
4812 }
4813 if (fFitChargeBisOn ) {
4814 fout->WriteTObject(fCoefChargeDB[2],fCoefChargeDB[2]->GetName(),(Option_t *) "OverWrite");
4815 }
4816
4817}
4818
4819//_____________________________________________________________________________
4820void AliTRDCalibraFit::WritePHDB(TFile *fout)
4821{
4822 //
4823 // If wanted, write the debug histos for fDebug = 3 and fDebug = 4
4824 //
4825
4826 if (fFitPHOn) {
4827 fout->WriteTObject(fCoefVdriftDB[0],fCoefVdriftDB[0]->GetName(),(Option_t *) "OverWrite");
4828 }
4829 if(fFitPol2On){
4830 fout->WriteTObject(fCoefVdriftDB[1],fCoefVdriftDB[1]->GetName(),(Option_t *) "OverWrite");
4831 }
4832 if(fFitLagrPolOn){
4833 fout->WriteTObject(fCoefVdriftDB[2],fCoefVdriftDB[2]->GetName(),(Option_t *) "OverWrite");
4834 }
4835
4836}
4837
4838//_____________________________________________________________________________
4839void AliTRDCalibraFit::WriteT0DB(TFile *fout)
4840{
4841 //
4842 // If wanted, write the debug histos for fDebug = 3 and fDebug = 4
4843 //
4844
4845 if (fFitPHOn) {
4846 fout->WriteTObject(fCoefT0DB[0],fCoefT0DB[0]->GetName(),(Option_t *) "OverWrite");
4847 }
4848 if(fFitPol2On){
4849 fout->WriteTObject(fCoefT0DB[1],fCoefT0DB[1]->GetName(),(Option_t *) "OverWrite");
4850 }
4851 if(fFitLagrPolOn){
4852 fout->WriteTObject(fCoefT0DB[2],fCoefT0DB[2]->GetName(),(Option_t *) "OverWrite");
4853 }
4854
4855}
4856
4857//_____________________________________________________________________________
4858void AliTRDCalibraFit::WritePRFDB(TFile *fout)
4859{
4860 //
4861 // If wanted, write the debug histos for fDebug = 3 and fDebug = 4
4862 //
4863 if(fFitPRFOn){
4864 fout->WriteTObject(fCoefPRFDB[0],fCoefPRFDB[0]->GetName(),(Option_t *) "OverWrite");
4865 }
4866 if(fRMSPRFOn){
4867 fout->WriteTObject(fCoefPRFDB[1],fCoefPRFDB[1]->GetName(),(Option_t *) "OverWrite");
4868 }
4869
4870}
4871
4872//
4873//____________Calcul Coef Mean_________________________________________________
4874//
4875
4876//_____________________________________________________________________________
4877Bool_t AliTRDCalibraFit::CalculT0CoefMean(Int_t dect, Int_t idect)
4878{
4879 //
4880 // For the detector Dect calcul the mean time 0
4881 // for the calibration group idect from the choosen database
4882 //
4883
4884 AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
4885 if (!cal) {
4886 AliInfo("Could not get calibDB Manager");
4887 return kFALSE;
4888 }
4889
4890 fT0Coef[2] = 0.0;
4891
4892 if ((fDebug != 2) && fAccCDB) {
4893
4894 for (Int_t row = fCalibraMode->GetRowMin(1); row < fCalibraMode->GetRowMax(1); row++) {
4895 for (Int_t col = fCalibraMode->GetColMin(1); col < fCalibraMode->GetColMax(1); col++) {
4896 // Groups of pads
4897 if ((fCalibraMode->GetNz(1) > 0) ||
4898 (fCalibraMode->GetNrphi(1) > 0)) {
4899 fT0Coef[2] += (Float_t) cal->GetT0(dect,col,row);
4900 }
4901 // Per detectors
4902 else {
4903 fT0Coef[2] += (Float_t) cal->GetT0Average(dect);
4904 }
4905 }
4906 }
4907
4908 fT0Coef[2] = fT0Coef[2] / ((fCalibraMode->GetColMax(1)-fCalibraMode->GetColMin(1))
4909 * (fCalibraMode->GetRowMax(1)-fCalibraMode->GetRowMin(1)));
4910 if ((fDebug == 1) ||
4911 (fDebug == 4)) {
4912 fCoefT0[2][idect] = fT0Coef[2];
4913 }
4914
4915 }
4916
4917 return kTRUE;
4918
4919}
4920
4921//_____________________________________________________________________________
4922Bool_t AliTRDCalibraFit::CalculChargeCoefMean(Int_t dect, Int_t idect, Bool_t vrai)
4923{
4924 //
4925 // For the detector Dect calcul the mean gain factor
4926 // for the calibration group idect from the choosen database
4927 //
4928
4929 AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
4930 if (!cal) {
4931 AliInfo("Could not get calibDB Manager");
4932 return kFALSE;
4933 }
4934 AliTRDCommonParam *parCom = AliTRDCommonParam::Instance();
4935 if (!parCom) {
4936 AliInfo("Could not get CommonParam Manager");
4937 return kFALSE;
4938 }
4939
4940 fChargeCoef[3] = 0.0;
4941
4942 if (fDebug != 2) {
4943
4944 for (Int_t row = fCalibraMode->GetRowMin(0); row < fCalibraMode->GetRowMax(0); row++) {
4945 for (Int_t col = fCalibraMode->GetColMin(0); col < fCalibraMode->GetColMax(0); col++) {
4946 // Groups of pads
4947 if ((fCalibraMode->GetNz(0) > 0) ||
4948 (fCalibraMode->GetNrphi(0) > 0)) {
4949 if (fAccCDB) {
4950 fChargeCoef[3] += (Float_t) cal->GetGainFactor(dect,col,row);
4951 }
4952 if (vrai && fAccCDB) {
4953 fScaleFitFactor += (Float_t) cal->GetGainFactor(dect,col,row);
4954 }
4955 if (!fAccCDB) {
4956 fChargeCoef[3] += 1.0;
4957 }
4958 if (vrai && (!fAccCDB)) {
4959 fScaleFitFactor += 1.0;
4960 }
4961 }
4962 // Per detectors
4963 else {
4964 if (fAccCDB) {
4965 fChargeCoef[3] += (Float_t) cal->GetGainFactorAverage(dect);
4966 }
4967 if (vrai && fAccCDB) {
4968 fScaleFitFactor += ((Float_t) cal->GetGainFactorAverage(dect));
4969 }
4970 if (!fAccCDB) {
4971 fChargeCoef[3] += 1.0;
4972 }
4973 if (vrai && (!fAccCDB)) {
4974 fScaleFitFactor += 1.0;
4975 }
4976 }
4977 }
4978 }
4979
4980 fChargeCoef[3] = fChargeCoef[3] / ((fCalibraMode->GetColMax(0)-fCalibraMode->GetColMin(0))
4981 * (fCalibraMode->GetRowMax(0)-fCalibraMode->GetRowMin(0)));
4982 if ((fDebug == 1) ||
4983 (fDebug == 4)) {
4984 fCoefCharge[3][idect]=fChargeCoef[3];
4985 }
4986
4987 }
4988
4989 return kTRUE;
4990
4991}
4992
4993//_____________________________________________________________________________
4994Bool_t AliTRDCalibraFit::CalculPRFCoefMean(Int_t dect, Int_t idect)
4995{
4996 //
4997 // For the detector Dect calcul the mean sigma of pad response
4998 // function for the calibration group idect from the choosen database
4999 //
5000
5001 AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
5002 if (!cal) {
5003 AliInfo("Could not get calibDB Manager");
5004 return kFALSE;
5005 }
5006
5007 AliTRDCommonParam *parCom = AliTRDCommonParam::Instance();
5008 if (!parCom) {
5009 AliInfo("Could not get CommonParam Manager");
5010 return kFALSE;
5011 }
5012
5013 fPRFCoef[1] = 0.0;
5014 Int_t cot = 0;
5015
5016 if (fDebug != 2) {
5017
5018 for (Int_t row = fCalibraMode->GetRowMin(2); row < fCalibraMode->GetRowMax(2); row++) {
5019 for (Int_t col = fCalibraMode->GetColMin(2); col < fCalibraMode->GetColMax(2); col++) {
5020 if ((parCom->GetColMax(GetPlane(dect)) != (col+1)) && (col != 0)) {
5021 cot++;
5022 if (fAccCDB) {
5023 fPRFCoef[1] += (Float_t) cal->GetPRFWidth(dect,col,row);
5024 }
5025 if (!fAccCDB) {
5026 fPRFCoef[1] += GetPRFDefault(GetPlane(dect));
5027 }
5028 }
5029 }
5030 }
5031
5032 if (cot > 0) {
5033 fPRFCoef[1] = fPRFCoef[1]/cot;
5034 if ((fDebug == 1) ||
5035 (fDebug == 4)) {
5036 fCoefPRF[1][idect] = fPRFCoef[1];
5037 }
5038 }
5039 if (cot <= 0) {
5040 if ((fDebug == 1) ||
5041 (fDebug == 4)) {
5042 if (fAccCDB) {
5043 fCoefPRF[1][idect] = cal->GetPRFWidth(dect,fCalibraMode->GetColMin(2),fCalibraMode->GetRowMin(2));
5044 }
5045 if (!fAccCDB) {
5046 fCoefPRF[1][idect] = GetPRFDefault(GetPlane(dect));
5047 }
5048 }
5049 }
5050
5051 }
5052
5053 return kTRUE;
5054
5055}
5056
5057//_____________________________________________________________________________
5058Bool_t AliTRDCalibraFit::CalculVdriftCoefMean(Int_t dect, Int_t idect)
5059{
5060 //
5061 // For the detector dect calcul the mean drift velocity for the
5062 // calibration group idect from the choosen database
5063 //
5064
5065 AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
5066 if (!cal) {
5067 AliInfo("Could not get calibDB Manager");
5068 return kFALSE;
5069 }
5070
5071 fVdriftCoef[2] = 0.0;
5072
5073 if (fDebug != 2) {
5074 for (Int_t row = fCalibraMode->GetRowMin(1); row < fCalibraMode->GetRowMax(1); row++) {
5075 for (Int_t col = fCalibraMode->GetColMin(1); col < fCalibraMode->GetColMax(1); col++) {
5076 // Groups of pads
5077 if ((fCalibraMode->GetNz(1) > 0) ||
5078 (fCalibraMode->GetNrphi(1) > 0)) {
5079 if (fAccCDB) {
5080 fVdriftCoef[2] += (Float_t) cal->GetVdrift(dect,col,row);
5081 }
5082 if (!fAccCDB) {
5083 fVdriftCoef[2] += 1.5;
5084 }
5085 }
5086 // Per detectors
5087 else {
5088 if (fAccCDB) {
5089 fVdriftCoef[2] += (Float_t) cal->GetVdriftAverage(dect);
5090 }
5091 if (!fAccCDB) {
5092 fVdriftCoef[2] += 1.5;
5093 }
5094 }
5095 }
5096 }
5097 fVdriftCoef[2] = fVdriftCoef[2] / ((fCalibraMode->GetColMax(1)-fCalibraMode->GetColMin(1))
5098 * (fCalibraMode->GetRowMax(1)-fCalibraMode->GetRowMin(1)));
5099 if ((fDebug == 1) ||
5100 (fDebug == 4)) {
5101 fCoefVdrift[2][idect] = fVdriftCoef[2];
5102 }
5103 }
5104
5105 return kTRUE;
5106
5107}
5108
5109//_____________________________________________________________________________
5110Float_t AliTRDCalibraFit::GetPRFDefault(Int_t plane) const
5111{
5112 //
5113 // Default width of the PRF if there is no database as reference
5114 //
5115
5116 if (plane == 0) {
5117 return 0.515;
5118 }
5119 if (plane == 1) {
5120 return 0.502;
5121 }
5122 if (plane == 2) {
5123 return 0.491;
5124 }
5125 if (plane == 3) {
5126 return 0.481;
5127 }
5128 if (plane == 4) {
5129 return 0.471;
5130 }
5131 if (plane == 5) {
5132 return 0.463;
5133 }
5134 else {
5135 return 0.0;
5136 }
5137
5138}
5139
5140//____________Fit Methods______________________________________________________
5141
5142//_____________________________________________________________________________
5143void AliTRDCalibraFit::FitPente(TH1* projPH, Int_t idect)
5144{
5145 //
5146 // Slope methode for the drift velocity
5147 //
5148
5149 // Constants
5150 const Float_t kDrWidth = AliTRDgeometry::DrThick();
5151 Int_t binmax = 0;
5152 Int_t binmin = 0;
5153 fPhd[0] = 0.0;
5154 fPhd[1] = 0.0;
5155 fPhd[2] = 0.0;
5156 Int_t ju = 0;
5157 Double_t vdriftCoefE = 0.0;
5158 Double_t t0CoefE = 0.0;
5159 fVdriftCoef[1] = 0.0;
5160 fT0Coef[1] = 0.0;
5161 TLine *line = new TLine();
5162
5163 // Some variables
5164 TAxis *xpph = projPH->GetXaxis();
5165 Int_t nbins = xpph->GetNbins();
5166 Double_t lowedge = xpph->GetBinLowEdge(1);
5167 Double_t upedge = xpph->GetBinUpEdge(xpph->GetNbins());
5168 Double_t widbins = (upedge - lowedge) / nbins;
5169 Double_t limit = upedge + 0.5 * widbins;
5170 Bool_t put = kTRUE;
5171
5172 // Beginning of the signal
5173 TH1D *pentea = new TH1D("pentea","pentea",projPH->GetNbinsX(),0,(Float_t) limit);
5174 for (Int_t k = 1; k < projPH->GetNbinsX(); k++) {
5175 pentea->SetBinContent(k,(Double_t) (projPH->GetBinContent(k+1) - projPH->GetBinContent(k)));
5176 }
5177
5178 binmax = (Int_t) pentea->GetMaximumBin();
5179 if(fDebug == 2) AliInfo(Form("maximum positive bin for the positive slope %d",binmax));
5180 if (binmax <= 1) {
5181 binmax = 2;
5182 AliInfo("Put the binmax from 1 to 2 to enable the fit");
5183 }
5184 if (binmax >= nbins) {
5185 binmax = nbins-1;
5186 put = kFALSE;
5187 AliInfo("Put the binmax from nbins-1 to nbins-2 to enable the fit");
5188 }
5189 pentea->Fit("pol2","0MR","",TMath::Max(pentea->GetBinCenter(binmax-1),0.0),pentea->GetBinCenter(binmax+1));
5190 Float_t l3P1am = pentea->GetFunction("pol2")->GetParameter(1);
5191 Float_t l3P2am = pentea->GetFunction("pol2")->GetParameter(2);
5192 Float_t l3P1amE = pentea->GetFunction("pol2")->GetParError(1);
5193 Float_t l3P2amE = pentea->GetFunction("pol2")->GetParError(2);
5194 if (l3P2am != 0) {
5195 fPhd[0] = -(l3P1am / (2 * l3P2am));
5196 }
5197 if(!fTakeTheMaxPH){
5198 if((l3P1am != 0.0) && (l3P2am != 0.0)){
5199 t0CoefE = (l3P1amE/l3P1am + l3P2amE/l3P2am)*fPhd[0];
5200 }
5201 }
5202 if(fDebug == 2) AliInfo(Form("maximum extrapolated positive bin for the positive slope %f",fPhd[0]));
5203
5204 // Amplification region
5205 binmax = 0;
5206 ju = 0;
5207 for (Int_t kbin = 1; kbin < projPH->GetNbinsX(); kbin ++) {
5208 if (((projPH->GetBinContent(kbin+1) - projPH->GetBinContent(kbin)) <= 0.0) &&
5209 (ju == 0) &&
5210 (kbin > (fPhd[0]/widbins))) {
5211 binmax = kbin;
5212 ju = 1;
5213 }
5214 }
5215 if(fDebug == 2) AliInfo(Form("For the amplification region binmax %d",binmax));
5216 if (binmax <= 1) {
5217 binmax = 2;
5218 AliInfo("Put the binmax from 1 to 2 to enable the fit");
5219 }
5220 if (binmax >= nbins) {
5221 binmax = nbins-1;
5222 put = kFALSE;
5223 AliInfo("Put the binmax from nbins-1 to nbins-2 to enable the fit");
5224 }
5225 projPH->Fit("pol2","0MR","",TMath::Max(projPH->GetBinCenter(binmax-1),0.0),projPH->GetBinCenter(binmax+1));
5226 Float_t l3P1amf = projPH->GetFunction("pol2")->GetParameter(1);
5227 Float_t l3P2amf = projPH->GetFunction("pol2")->GetParameter(2);
5228 Float_t l3P1amfE = projPH->GetFunction("pol2")->GetParError(1);
5229 Float_t l3P2amfE = projPH->GetFunction("pol2")->GetParError(2);
5230
5231 if (l3P2amf != 0) {
5232 fPhd[1] = -(l3P1amf / (2 * l3P2amf));
5233 }
5234 if((l3P1amf != 0.0) && (l3P2amf != 0.0)){
5235 vdriftCoefE = (l3P1amfE/l3P1amf + l3P2amfE/l3P2amf)*fPhd[1];
5236 }
5237 if(fTakeTheMaxPH){
5238 t0CoefE = vdriftCoefE;
5239 }
5240 if(fDebug == 2) AliInfo(Form("For the amplification region extrapolated binmax %f",fPhd[1]));
5241
5242 // Drift region
5243 TH1D *pente = new TH1D("pente","pente",projPH->GetNbinsX(),0,(Float_t) limit);
5244 for (Int_t k = TMath::Min(binmax+4,projPH->GetNbinsX()); k < projPH->GetNbinsX(); k++) {
5245 pente->SetBinContent(k,(Double_t) (projPH->GetBinContent(k+1) - projPH->GetBinContent(k)));
5246 }
5247 binmin = 0;
5248 if(pente->GetEntries() > 0) binmin = (Int_t) pente->GetMinimumBin();
5249 if (binmin <= 1) {
5250 binmin = 2;
5251 AliInfo("Put the binmax from 1 to 2 to enable the fit");
5252 }
5253 if (binmin >= nbins) {
5254 binmin = nbins-1;
5255 put = kFALSE;
5256 AliInfo("Put the binmax from nbins-1 to nbins-2 to enable the fit");
5257 }
5258 if(fDebug == 2) AliInfo(Form("For the drift region binmin %d",binmin));
5259 pente->Fit("pol2"
5260 ,"0MR"
5261 ,""
5262 ,TMath::Max(pente->GetBinCenter(binmin-1), 0.0)
5263 ,TMath::Min(pente->GetBinCenter(binmin+1),(Double_t) limit));
5264 Float_t l3P1dr = pente->GetFunction("pol2")->GetParameter(1);
5265 Float_t l3P2dr = pente->GetFunction("pol2")->GetParameter(2);
5266 Float_t l3P1drE = pente->GetFunction("pol2")->GetParError(1);
5267 Float_t l3P2drE = pente->GetFunction("pol2")->GetParError(2);
5268 if (l3P2dr != 0) {
5269 fPhd[2] = -(l3P1dr / (2 * l3P2dr));
5270 }
5271 if((l3P1dr != 0.0) && (l3P2dr != 0.0)){
5272 vdriftCoefE += (l3P1drE/l3P1dr + l3P2drE/l3P2dr)*fPhd[2];
5273 }
5274 if(fDebug == 2) AliInfo(Form("For the drift region extrapolated binmax %f",fPhd[2]));
5275
5276 Float_t fPhdt0 = 0.0;
5277 if(fTakeTheMaxPH) fPhdt0 = fPhd[1];
5278 else fPhdt0 = fPhd[0];
5279
5280 if ((fPhd[2] > fPhd[0]) &&
5281 (fPhd[2] > fPhd[1]) &&
5282 (fPhd[1] > fPhd[0]) &&
5283 (put)) {
5284 fVdriftCoef[1] = (kDrWidth) / (fPhd[2]-fPhd[1]);
5285 if(fFitPHNDB == 1) fNumberFitSuccess++;
5286 if (fPhdt0 >= 0.0) {
5287 fT0Coef[1] = (fPhdt0 - fT0Shift) / widbins;
5288 if (fT0Coef[1] < -1.0) {
5289 fT0Coef[1] = fT0Coef[2];
5290 }
5291 }
5292 else {
5293 fT0Coef[1] = fT0Coef[2];
5294 }
5295 }
5296 else {
5297 fVdriftCoef[1] = -TMath::Abs(fVdriftCoef[2]);
5298 fT0Coef[1] = fT0Coef[2];
5299 }
5300
5301 if ((fDebug == 1) ||
5302 (fDebug == 4)) {
5303 fCoefVdrift[1][idect] = fVdriftCoef[1];
5304 fCoefVdriftE[1] [idect] = vdriftCoefE;
5305 fCoefT0[1][idect] = fT0Coef[1];
5306 fCoefT0E[1][idect] = t0CoefE;
5307 }
5308
5309 if (fDebug == 2) {
5310 TCanvas *cpentei = new TCanvas("cpentei","cpentei",50,50,600,800);
5311 cpentei->cd();
5312 projPH->Draw();
5313 line->SetLineColor(2);
5314 line->DrawLine(fPhd[0],0,fPhd[0],projPH->GetMaximum());
5315 line->DrawLine(fPhd[1],0,fPhd[1],projPH->GetMaximum());
5316 line->DrawLine(fPhd[2],0,fPhd[2],projPH->GetMaximum());
5317 AliInfo(Form("fPhd[0] (beginning of the signal): %f" ,(Float_t) fPhd[0]));
5318 AliInfo(Form("fPhd[1] (end of the amplification region): %f" ,(Float_t) fPhd[1]));
5319 AliInfo(Form("fPhd[2] (end of the drift region): %f" ,(Float_t) fPhd[2]));
5320 AliInfo(Form("fVriftCoef[1] (with only the drift region(default)): %f",(Float_t) fVdriftCoef[1]));
5321 TCanvas *cpentei2 = new TCanvas("cpentei2","cpentei2",50,50,600,800);
5322 cpentei2->cd();
5323 pentea->Draw();
5324 TCanvas *cpentei3 = new TCanvas("cpentei3","cpentei3",50,50,600,800);
5325 cpentei3->cd();
5326 pente->Draw();
5327 }
5328
5329 if (fDebug != 2) {
5330 delete pentea;
5331 }
5332 if (fDebug != 2) {
5333 delete pente;
5334 }
5335
5336}
5337
5338//_____________________________________________________________________________
5339void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH, Int_t idect)
5340{
5341 //
5342 // Slope methode but with polynomes de Lagrange
5343 //
5344
5345 // Constants
5346 const Float_t kDrWidth = AliTRDgeometry::DrThick();
5347 Int_t binmax = 0;
5348 Int_t binmin = 0;
5349 Double_t *x = new Double_t[5];
5350 Double_t *y = new Double_t[5];
5351 x[0] = 0.0;
5352 x[1] = 0.0;
5353 x[2] = 0.0;
5354 x[3] = 0.0;
5355 x[4] = 0.0;
5356 y[0] = 0.0;
5357 y[1] = 0.0;
5358 y[2] = 0.0;
5359 y[3] = 0.0;
5360 y[4] = 0.0;
5361 fPhd[0] = 0.0;
5362 fPhd[1] = 0.0;
5363 fPhd[2] = 0.0;
5364 Int_t ju = 0;
5365 Double_t vdriftCoefE = 0.0;
5366 Double_t t0CoefE = 1.0;
5367 fVdriftCoef[3] = 0.0;
5368 fT0Coef[3] = 0.0;
5369 TLine *line = new TLine();
5370 TF1 * polynome = 0x0;
5371 TF1 * polynomea = 0x0;
5372 TF1 * polynomeb = 0x0;
5373 Double_t *c = 0x0;
5374
5375 // Some variables
5376 TAxis *xpph = projPH->GetXaxis();
5377 Int_t nbins = xpph->GetNbins();
5378 Double_t lowedge = xpph->GetBinLowEdge(1);
5379 Double_t upedge = xpph->GetBinUpEdge(xpph->GetNbins());
5380 Double_t widbins = (upedge - lowedge) / nbins;
5381 Double_t limit = upedge + 0.5 * widbins;
5382
5383
5384 Bool_t put = kTRUE;
5385
5386 // Beginning of the signal
5387 TH1D *pentea = new TH1D("pentea","pentea",projPH->GetNbinsX(),0,(Float_t) limit);
5388 for (Int_t k = 1; k < projPH->GetNbinsX(); k++) {
5389 pentea->SetBinContent(k,(Double_t) (projPH->GetBinContent(k+1) - projPH->GetBinContent(k)));
5390 }
5391
5392 binmax = (Int_t) pentea->GetMaximumBin();
5393 if(fDebug == 2) AliInfo(Form("maximum positive bin for the positive slope %d",binmax));
5394
5395
5396 Double_t minnn = 0.0;
5397 Double_t maxxx = 0.0;
5398
5399 //Determination of minnn and maxxx
5400 //case binmax = nbins -1
5401 //pol2
5402 if(binmax == (nbins-1)){
5403 minnn = pentea->GetBinCenter(binmax-2);
5404 maxxx = pentea->GetBinCenter(binmax);
5405 x[0] = pentea->GetBinCenter(binmax-2);
5406 x[1] = pentea->GetBinCenter(binmax-1);
5407 x[2] = pentea->GetBinCenter(binmax);
5408 y[0] = pentea->GetBinContent(binmax-2);
5409 y[1] = pentea->GetBinContent(binmax-1);
5410 y[2] = pentea->GetBinContent(binmax);
5411 //Calcul the polynome de Lagrange
5412 c = CalculPolynomeLagrange2(x,y);
5413 AliInfo("At the limit for beginning!");
5414 }
5415 //case binmax = nbins-2
5416 //pol3
5417 if(binmax == (nbins-2)){
5418 minnn = pentea->GetBinCenter(binmax-2);
5419 maxxx = pentea->GetBinCenter(binmax+1);
5420 x[0] = pentea->GetBinCenter(binmax-2);
5421 x[1] = pentea->GetBinCenter(binmax-1);
5422 x[2] = pentea->GetBinCenter(binmax);
5423 x[3] = pentea->GetBinCenter(binmax+1);
5424 y[0] = pentea->GetBinContent(binmax-2);
5425 y[1] = pentea->GetBinContent(binmax-1);
5426 y[2] = pentea->GetBinContent(binmax);
5427 y[3] = pentea->GetBinContent(binmax+1);
5428 //Calcul the polynome de Lagrange
5429 c = CalculPolynomeLagrange3(x,y);
5430 }
5431 //case binmax <= nbins-3
5432 //pol4
5433 if(binmax <= (nbins-3)){
5434 if((binmax-2) >= 1){
5435 minnn = pentea->GetBinCenter(binmax-2);
5436 maxxx = pentea->GetBinCenter(binmax+2);
5437 x[0] = pentea->GetBinCenter(binmax-2);
5438 x[1] = pentea->GetBinCenter(binmax-1);
5439 x[2] = pentea->GetBinCenter(binmax);
5440 x[3] = pentea->GetBinCenter(binmax+1);
5441 x[4] = pentea->GetBinCenter(binmax+2);
5442 y[0] = pentea->GetBinContent(binmax-2);
5443 y[1] = pentea->GetBinContent(binmax-1);
5444 y[2] = pentea->GetBinContent(binmax);
5445 y[3] = pentea->GetBinContent(binmax+1);
5446 y[4] = pentea->GetBinContent(binmax+2);
5447 //Calcul the polynome de Lagrange
5448 c = CalculPolynomeLagrange4(x,y);
5449 }
5450 //pol3
5451 if((binmax-1) == 1){
5452 minnn = pentea->GetBinCenter(binmax-1);
5453 maxxx = pentea->GetBinCenter(binmax+2);
5454 x[0] = pentea->GetBinCenter(binmax-1);
5455 x[1] = pentea->GetBinCenter(binmax);
5456 x[2] = pentea->GetBinCenter(binmax+1);
5457 x[3] = pentea->GetBinCenter(binmax+2);
5458 y[0] = pentea->GetBinContent(binmax-1);
5459 y[1] = pentea->GetBinContent(binmax);
5460 y[2] = pentea->GetBinContent(binmax+1);
5461 y[3] = pentea->GetBinContent(binmax+2);
5462 //Calcul the polynome de Lagrange
5463 c = CalculPolynomeLagrange3(x,y);
5464 }
5465 //pol2
5466 if(binmax == 1){
5467 minnn = pentea->GetBinCenter(binmax);
5468 maxxx = pentea->GetBinCenter(binmax+2);
5469 x[0] = pentea->GetBinCenter(binmax);
5470 x[1] = pentea->GetBinCenter(binmax+1);
5471 x[2] = pentea->GetBinCenter(binmax+2);
5472 y[0] = pentea->GetBinContent(binmax);
5473 y[1] = pentea->GetBinContent(binmax+1);
5474 y[2] = pentea->GetBinContent(binmax+2);
5475 //Calcul the polynome de Lagrange
5476 c = CalculPolynomeLagrange2(x,y);
5477 }
5478 }
5479 //pass but should not happen
5480 if((binmax <= (nbins-3)) && (binmax < 1)){
5481 put = kFALSE;
5482 }
5483
5484 if(fDebug == 2) AliInfo(Form("For the beginning region binmax %d",binmax));
5485
5486 if(put) {
5487 polynomeb = new TF1("polb","[0]+[1]*x+[2]*x*x+[3]*x*x*x+[4]*x*x*x*x",minnn,maxxx);
5488 polynomeb->SetParameters(c[0],c[1],c[2],c[3],c[4]);
5489 if(fDebug == 2) {
5490 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]));
5491 }
5492
5493 Double_t step = (maxxx-minnn)/10000;
5494 Double_t l = minnn;
5495 Double_t maxvalue = 0.0;
5496 Double_t placemaximum = minnn;
5497 for(Int_t o = 0; o < 10000; o++){
5498 if(o == 0) maxvalue = polynomeb->Eval(l);
5499 if(maxvalue < (polynomeb->Eval(l))){
5500 maxvalue = polynomeb->Eval(l);
5501 placemaximum = l;
5502 }
5503 l += step;
5504 }
5505 fPhd[0] = placemaximum;
5506 }
5507
5508 if(fDebug == 2) AliInfo(Form("maximum extrapolated positive bin for the positive slope %f",fPhd[0]));
5509
5510 // Amplification region
5511 binmax = 0;
5512 ju = 0;
5513 for (Int_t kbin = 1; kbin < projPH->GetNbinsX(); kbin ++) {
5514 if (((projPH->GetBinContent(kbin+1) - projPH->GetBinContent(kbin)) <= 0.0) &&
5515 (ju == 0) &&
5516 (kbin > (fPhd[0]/widbins))) {
5517 binmax = kbin;
5518 ju = 1;
5519 }
5520 }
5521 if(fDebug == 2) AliInfo(Form("For the amplification region binmax %d",binmax));
5522
5523 Double_t minn = 0.0;
5524 Double_t maxx = 0.0;
5525
5526 //Determination of minn and maxx
5527 //case binmax = nbins
5528 //pol2
5529 if(binmax == nbins){
5530 minn = projPH->GetBinCenter(binmax-2);
5531 maxx = projPH->GetBinCenter(binmax);
5532 x[0] = projPH->GetBinCenter(binmax-2);
5533 x[1] = projPH->GetBinCenter(binmax-1);
5534 x[2] = projPH->GetBinCenter(binmax);
5535 y[0] = projPH->GetBinContent(binmax-2);
5536 y[1] = projPH->GetBinContent(binmax-1);
5537 y[2] = projPH->GetBinContent(binmax);
5538 //Calcul the polynome de Lagrange
5539 c = CalculPolynomeLagrange2(x,y);
5540 AliInfo("At the limit for the drift!");
5541 }
5542 //case binmax = nbins-1
5543 //pol3
5544 if(binmax == (nbins-1)){
5545 minn = projPH->GetBinCenter(binmax-2);
5546 maxx = projPH->GetBinCenter(binmax+1);
5547 x[0] = projPH->GetBinCenter(binmax-2);
5548 x[1] = projPH->GetBinCenter(binmax-1);
5549 x[2] = projPH->GetBinCenter(binmax);
5550 x[3] = projPH->GetBinCenter(binmax+1);
5551 y[0] = projPH->GetBinContent(binmax-2);
5552 y[1] = projPH->GetBinContent(binmax-1);
5553 y[2] = projPH->GetBinContent(binmax);
5554 y[3] = projPH->GetBinContent(binmax+1);
5555 //Calcul the polynome de Lagrange
5556 c = CalculPolynomeLagrange3(x,y);
5557 }
5558 //case binmax <= nbins-2
5559 //pol4
5560 if(binmax <= (nbins-2)){
5561 if((binmax-2) >= 1){
5562 minn = projPH->GetBinCenter(binmax-2);
5563 maxx = projPH->GetBinCenter(binmax+2);
5564 x[0] = projPH->GetBinCenter(binmax-2);
5565 x[1] = projPH->GetBinCenter(binmax-1);
5566 x[2] = projPH->GetBinCenter(binmax);
5567 x[3] = projPH->GetBinCenter(binmax+1);
5568 x[4] = projPH->GetBinCenter(binmax+2);
5569 y[0] = projPH->GetBinContent(binmax-2);
5570 y[1] = projPH->GetBinContent(binmax-1);
5571 y[2] = projPH->GetBinContent(binmax);
5572 y[3] = projPH->GetBinContent(binmax+1);
5573 y[4] = projPH->GetBinContent(binmax+2);
5574 //Calcul the polynome de Lagrange
5575 c = CalculPolynomeLagrange4(x,y);
5576 }
5577 //pol3
5578 if((binmax-1) == 1){
5579 minn = projPH->GetBinCenter(binmax-1);
5580 maxx = projPH->GetBinCenter(binmax+2);
5581 x[0] = projPH->GetBinCenter(binmax-1);
5582 x[1] = projPH->GetBinCenter(binmax);
5583 x[2] = projPH->GetBinCenter(binmax+1);
5584 x[3] = projPH->GetBinCenter(binmax+2);
5585 y[0] = projPH->GetBinContent(binmax-1);
5586 y[1] = projPH->GetBinContent(binmax);
5587 y[2] = projPH->GetBinContent(binmax+1);
5588 y[3] = projPH->GetBinContent(binmax+2);
5589 //Calcul the polynome de Lagrange
5590 c = CalculPolynomeLagrange3(x,y);
5591 }
5592 //pol2
5593 if(binmax == 1){
5594 minn = projPH->GetBinCenter(binmax);
5595 maxx = projPH->GetBinCenter(binmax+2);
5596 x[0] = projPH->GetBinCenter(binmax);
5597 x[1] = projPH->GetBinCenter(binmax+1);
5598 x[2] = projPH->GetBinCenter(binmax+2);
5599 y[0] = projPH->GetBinContent(binmax);
5600 y[1] = projPH->GetBinContent(binmax+1);
5601 y[2] = projPH->GetBinContent(binmax+2);
5602 //Calcul the polynome de Lagrange
5603 c = CalculPolynomeLagrange2(x,y);
5604 }
5605 }
5606 //pass but should not happen
5607 if((binmax <= (nbins-2)) && (binmax < 1)){
5608 put = kFALSE;
5609 }
5610
5611 if(fDebug == 2) AliInfo(Form("For the amplification region binmax %d",binmax));
5612
5613 if(put) {
5614 polynomea = new TF1("pola","[0]+[1]*x+[2]*x*x+[3]*x*x*x+[4]*x*x*x*x",minn,maxx);
5615 polynomea->SetParameters(c[0],c[1],c[2],c[3],c[4]);
5616 if(fDebug == 2) {
5617 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]));
5618 }
5619
5620 Double_t step = (maxx-minn)/1000;
5621 Double_t l = minn;
5622 Double_t maxvalue = 0.0;
5623 Double_t placemaximum = minn;
5624 for(Int_t o = 0; o < 1000; o++){
5625 if(o == 0) maxvalue = polynomea->Eval(l);
5626 if(maxvalue < (polynomea->Eval(l))){
5627 maxvalue = polynomea->Eval(l);
5628 placemaximum = l;
5629 }
5630 l += step;
5631 }
5632 fPhd[1] = placemaximum;
5633 }
5634
5635 if(fDebug == 2) AliInfo(Form("For the amplification region extrapolated binmax %f",fPhd[1]));
5636
5637 // Drift region
5638 TH1D *pente = new TH1D("pente","pente", projPH->GetNbinsX(),0,(Float_t) limit);
5639 for (Int_t k = TMath::Min(binmax+4, projPH->GetNbinsX()); k < projPH->GetNbinsX(); k++) {
5640 pente->SetBinContent(k,(Double_t) (projPH->GetBinContent(k+1) - projPH->GetBinContent(k)));
5641 }
5642 binmin = 0;
5643 if(pente->GetEntries() > 0) binmin = (Int_t) pente->GetMinimumBin();
5644
5645 //should not happen
5646 if (binmin <= 1) {
5647 binmin = 2;
5648 put = 1;
5649 AliInfo("Put the binmax from 1 to 2 to enable the fit");
5650 }
5651
5652 //check
5653 if((projPH->GetBinContent(binmin)-projPH->GetBinError(binmin)) < (projPH->GetBinContent(binmin+1))) put = kFALSE;
5654 if((projPH->GetBinContent(binmin)+projPH->GetBinError(binmin)) > (projPH->GetBinContent(binmin-1))) put = kFALSE;
5655
5656 if(fDebug == 2) {
5657 AliInfo(Form("binmin %d BinContent %f BinError %f",binmin
5658 ,projPH->GetBinContent(binmin)
5659 ,projPH->GetBinError(binmin)));
5660 AliInfo(Form("binmin-1 %d BinContent %f BinError %f",binmin-1
5661 ,projPH->GetBinContent(binmin-1)
5662 ,projPH->GetBinError(binmin-1)));
5663 AliInfo(Form("binmin+1 %d BinContent %f BinError %f",binmin+1
5664 ,projPH->GetBinContent(binmin+1)
5665 ,projPH->GetBinError(binmin+1)));
5666 }
5667
5668 Double_t min = 0.0;
5669 Double_t max = 0.0;
5670 Bool_t case1 = kFALSE;
5671 Bool_t case2 = kFALSE;
5672 Bool_t case4 = kFALSE;
5673
5674 //Determination of min and max
5675 //case binmin <= nbins-3
5676 //pol4 case 3
5677 if((binmin <= (nbins-3)) && ((binmin-2) >= TMath::Min(binmax+4, projPH->GetNbinsX()))){
5678 min = pente->GetBinCenter(binmin-2);
5679 max = pente->GetBinCenter(binmin+2);
5680 x[0] = pente->GetBinCenter(binmin-2);
5681 x[1] = pente->GetBinCenter(binmin-1);
5682 x[2] = pente->GetBinCenter(binmin);
5683 x[3] = pente->GetBinCenter(binmin+1);
5684 x[4] = pente->GetBinCenter(binmin+2);
5685 y[0] = pente->GetBinContent(binmin-2);
5686 y[1] = pente->GetBinContent(binmin-1);
5687 y[2] = pente->GetBinContent(binmin);
5688 y[3] = pente->GetBinContent(binmin+1);
5689 y[4] = pente->GetBinContent(binmin+2);
5690 //Calcul the polynome de Lagrange
5691 c = CalculPolynomeLagrange4(x,y);
5692 //richtung +/-
5693 if((pente->GetBinContent(binmin+2) <= pente->GetBinContent(binmin+1)) &&
5694 (pente->GetBinContent(binmin-2) <= pente->GetBinContent(binmin-1))) put = kFALSE;
5695 if(((binmin+3) <= (nbins-1)) &&
5696 (pente->GetBinContent(binmin+3) <= pente->GetBinContent(binmin+2)) &&
5697 ((binmin-3) >= TMath::Min(binmax+4, projPH->GetNbinsX())) &&
5698 (pente->GetBinContent(binmin-3) <= pente->GetBinContent(binmin-2))) put = kFALSE;
5699 if((pente->GetBinContent(binmin+2) <= pente->GetBinContent(binmin+1)) &&
5700 (pente->GetBinContent(binmin-2) > pente->GetBinContent(binmin-1))) case1 = kTRUE;
5701 if((pente->GetBinContent(binmin+2) > pente->GetBinContent(binmin+1)) &&
5702 (pente->GetBinContent(binmin-2) <= pente->GetBinContent(binmin-1))) case4 = kTRUE;
5703 }
5704 //case binmin = nbins-2
5705 //pol3 case 1
5706 if(((binmin == (nbins-2)) && ((binmin-2) >= TMath::Min(binmax+4, projPH->GetNbinsX()))) ||
5707 (case1)){
5708 min = pente->GetBinCenter(binmin-2);
5709 max = pente->GetBinCenter(binmin+1);
5710 x[0] = pente->GetBinCenter(binmin-2);
5711 x[1] = pente->GetBinCenter(binmin-1);
5712 x[2] = pente->GetBinCenter(binmin);
5713 x[3] = pente->GetBinCenter(binmin+1);
5714 y[0] = pente->GetBinContent(binmin-2);
5715 y[1] = pente->GetBinContent(binmin-1);
5716 y[2] = pente->GetBinContent(binmin);
5717 y[3] = pente->GetBinContent(binmin+1);
5718 //Calcul the polynome de Lagrange
5719 c = CalculPolynomeLagrange3(x,y);
5720 //richtung +: nothing
5721 //richtung -
5722 if((pente->GetBinContent(binmin-2) <= pente->GetBinContent(binmin-1))) case2 = kTRUE;
5723 }
5724 //pol3 case 4
5725 if(((binmin <= (nbins-3)) && ((binmin-1) == TMath::Min(binmax+4, projPH->GetNbinsX()))) ||
5726 (case4)){
5727 min = pente->GetBinCenter(binmin-1);
5728 max = pente->GetBinCenter(binmin+2);
5729 x[0] = pente->GetBinCenter(binmin-1);
5730 x[1] = pente->GetBinCenter(binmin);
5731 x[2] = pente->GetBinCenter(binmin+1);
5732 x[3] = pente->GetBinCenter(binmin+2);
5733 y[0] = pente->GetBinContent(binmin-1);
5734 y[1] = pente->GetBinContent(binmin);
5735 y[2] = pente->GetBinContent(binmin+1);
5736 y[3] = pente->GetBinContent(binmin+2);
5737 //Calcul the polynome de Lagrange
5738 c = CalculPolynomeLagrange3(x,y);
5739 //richtung +
5740 if((pente->GetBinContent(binmin+2) <= pente->GetBinContent(binmin+1))) case2 = kTRUE;
5741 }
5742 //pol2 case 5
5743 if((binmin <= (nbins-3)) && (binmin == TMath::Min(binmax+4, projPH->GetNbinsX()))){
5744 min = pente->GetBinCenter(binmin);
5745 max = pente->GetBinCenter(binmin+2);
5746 x[0] = pente->GetBinCenter(binmin);
5747 x[1] = pente->GetBinCenter(binmin+1);
5748 x[2] = pente->GetBinCenter(binmin+2);
5749 y[0] = pente->GetBinContent(binmin);
5750 y[1] = pente->GetBinContent(binmin+1);
5751 y[2] = pente->GetBinContent(binmin+2);
5752 //Calcul the polynome de Lagrange
5753 c = CalculPolynomeLagrange2(x,y);
5754 //richtung +
5755 if((pente->GetBinContent(binmin+2) <= pente->GetBinContent(binmin+1))) put = kFALSE;
5756 }
5757 //pol2 case 2
5758 if(((binmin == (nbins-2)) && ((binmin-1) == TMath::Min(binmax+4, projPH->GetNbinsX()))) ||
5759 (case2)){
5760 min = pente->GetBinCenter(binmin-1);
5761 max = pente->GetBinCenter(binmin+1);
5762 x[0] = pente->GetBinCenter(binmin-1);
5763 x[1] = pente->GetBinCenter(binmin);
5764 x[2] = pente->GetBinCenter(binmin+1);
5765 y[0] = pente->GetBinContent(binmin-1);
5766 y[1] = pente->GetBinContent(binmin);
5767 y[2] = pente->GetBinContent(binmin+1);
5768 //Calcul the polynome de Lagrange
5769 c = CalculPolynomeLagrange2(x,y);
5770 //richtung +: nothing
5771 //richtung -: nothing
5772 }
5773 //case binmin = nbins-1
5774 //pol2 case 0
5775 if((binmin == (nbins-1)) && ((binmin-2) >= TMath::Min(binmax+4, projPH->GetNbinsX()))){
5776 min = pente->GetBinCenter(binmin-2);
5777 max = pente->GetBinCenter(binmin);
5778 x[0] = pente->GetBinCenter(binmin-2);
5779 x[1] = pente->GetBinCenter(binmin-1);
5780 x[2] = pente->GetBinCenter(binmin);
5781 y[0] = pente->GetBinContent(binmin-2);
5782 y[1] = pente->GetBinContent(binmin-1);
5783 y[2] = pente->GetBinContent(binmin);
5784 //Calcul the polynome de Lagrange
5785 c = CalculPolynomeLagrange2(x,y);
5786 AliInfo("At the limit for the drift!");
5787 //fluctuation too big!
5788 //richtung +: nothing
5789 //richtung -
5790 if((pente->GetBinContent(binmin-2) <= pente->GetBinContent(binmin-1))) put = kFALSE;
5791 }
5792 if((binmin == (nbins-1)) && ((binmin-2) < TMath::Min(binmax+4, projPH->GetNbinsX()))) {
5793 put = kFALSE;
5794 AliInfo("At the limit for the drift and not usable!");
5795 }
5796
5797 //pass
5798 if((binmin == (nbins-2)) && ((binmin-1) < TMath::Min(binmax+4, projPH->GetNbinsX()))){
5799 put = kFALSE;
5800 AliInfo("For the drift...problem!");
5801 }
5802
5803 //pass but should not happen
5804 if((binmin <= (nbins-3)) && (binmin < TMath::Min(binmax+4, projPH->GetNbinsX()))){
5805 put = kFALSE;
5806 AliInfo("For the drift...problem!");
5807 }
5808
5809 if(fDebug == 2) AliInfo(Form("For the drift region binmax %d",binmin));
5810
5811 if(put) {
5812 polynome = new TF1("pol","[0]+[1]*x+[2]*x*x+[3]*x*x*x+[4]*x*x*x*x",min,max);
5813 polynome->SetParameters(c[0],c[1],c[2],c[3],c[4]);
5814 if(fDebug == 2) {
5815 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]));
5816 }
5817 //AliInfo(Form("GetMinimum of the function %f",polynome->GetMinimumX()));
5818 Double_t step = (max-min)/1000;
5819 Double_t l = min;
5820 Double_t minvalue = 0.0;
5821 Double_t placeminimum = min;
5822 for(Int_t o = 0; o < 1000; o++){
5823 if(o == 0) minvalue = polynome->Eval(l);
5824 if(minvalue > (polynome->Eval(l))){
5825 minvalue = polynome->Eval(l);
5826 placeminimum = l;
5827 }
5828 l += step;
5829 }
5830 fPhd[2] = placeminimum;
5831 }
5832
5833 if(fDebug == 2) AliInfo(Form("For the drift region extrapolated binmax %f",fPhd[2]));
5834
5835 Float_t fPhdt0 = 0.0;
5836 if(fTakeTheMaxPH) fPhdt0 = fPhd[1];
5837 else fPhdt0 = fPhd[0];
5838
5839 if ((fPhd[2] > fPhd[0]) &&
5840 (fPhd[2] > fPhd[1]) &&
5841 (fPhd[1] > fPhd[0]) &&
5842 (put)) {
5843 fVdriftCoef[3] = (kDrWidth) / (fPhd[2]-fPhd[1]);
5844 if(fFitPHNDB == 3) fNumberFitSuccess++;
5845 if (fPhdt0 >= 0.0) {
5846 fT0Coef[3] = (fPhdt0 - fT0Shift) / widbins;
5847 if (fT0Coef[3] < -1.0) {
5848 fT0Coef[3] = fT0Coef[2];
5849 }
5850 }
5851 else {
5852 fT0Coef[3] = fT0Coef[2];
5853 }
5854 }
5855 else {
5856 fVdriftCoef[3] = -TMath::Abs(fVdriftCoef[2]);
5857 fT0Coef[3] = fT0Coef[2];
5858 }
5859
5860 if ((fDebug == 1) ||
5861 (fDebug == 4)) {
5862 fCoefVdrift[3][idect] = fVdriftCoef[3];
5863 fCoefVdriftE[2] [idect] = vdriftCoefE;
5864 fCoefT0[3][idect] = fT0Coef[3];
5865 fCoefT0E[2][idect] = t0CoefE;
5866 }
5867
5868 if (fDebug == 2) {
5869 TCanvas *cpentei = new TCanvas("cpentei","cpentei",50,50,600,800);
5870 cpentei->cd();
5871 projPH->Draw();
5872 line->SetLineColor(2);
5873 line->DrawLine(fPhd[0],0,fPhd[0],projPH->GetMaximum());
5874 line->DrawLine(fPhd[1],0,fPhd[1],projPH->GetMaximum());
5875 line->DrawLine(fPhd[2],0,fPhd[2],projPH->GetMaximum());
5876 AliInfo(Form("fPhd[0] (beginning of the signal): %f" ,(Float_t) fPhd[0]));
5877 AliInfo(Form("fPhd[1] (end of the amplification region): %f" ,(Float_t) fPhd[1]));
5878 AliInfo(Form("fPhd[2] (end of the drift region): %f" ,(Float_t) fPhd[2]));
5879 AliInfo(Form("fVriftCoef[3] (with only the drift region(default)): %f",(Float_t) fVdriftCoef[3]));
5880 TCanvas *cpentei2 = new TCanvas("cpentei2","cpentei2",50,50,600,800);
5881 cpentei2->cd();
5882 pentea->Draw();
5883 TCanvas *cpentei3 = new TCanvas("cpentei3","cpentei3",50,50,600,800);
5884 cpentei3->cd();
5885 pente->Draw();
5886 }
5887
5888 if (fDebug != 2) {
5889 delete pentea;
5890 delete pente;
5891 delete polynome;
5892 delete polynomea;
5893 delete polynomeb;
5894 }
5895
5896 projPH->SetDirectory(0);
5897
5898}
5899
5900//_____________________________________________________________________________
5901void AliTRDCalibraFit::FitPH(TH1* projPH, Int_t idect)
5902{
5903 //
5904 // Fit methode for the drift velocity
5905 //
5906
5907 // Constants
5908 const Float_t kDrWidth = AliTRDgeometry::DrThick();
5909
5910 // Some variables
5911 TAxis *xpph = projPH->GetXaxis();
5912 Double_t upedge = xpph->GetBinUpEdge(xpph->GetNbins());
5913
5914 TF1 *fPH = new TF1("fPH",AliTRDCalibraFit::PH,-0.05,3.2,6);
5915 fPH->SetParameter(0,0.469); // Scaling
5916 fPH->SetParameter(1,0.18); // Start
5917 fPH->SetParameter(2,0.0857325); // AR
5918 fPH->SetParameter(3,1.89); // DR
5919 fPH->SetParameter(4,0.08); // QA/QD
5920 fPH->SetParameter(5,0.0); // Baseline
5921
5922 TLine *line = new TLine();
5923
5924 fVdriftCoef[0] = 0.0;
5925 fT0Coef[0] = 0.0;
5926 Double_t vdriftCoefE = 0.0;
5927 Double_t t0CoefE = 0.0;
5928
5929 if (idect%fFitPHPeriode == 0) {
5930
5931 AliInfo(Form("<AliTRDCalibraFit::FitPH> The detector %d will be fitted",idect));
5932 fPH->SetParameter(0,(projPH->Integral()-(projPH->GetBinContent(1)*projPH->GetNbinsX())) * 0.00028); // Scaling
5933 fPH->SetParameter(1,fPhd[0] - 0.1); // Start
5934 fPH->SetParameter(2,fPhd[1] - fPhd[0]); // AR
5935 fPH->SetParameter(3,fPhd[2] - fPhd[1]); // DR
5936 fPH->SetParameter(4,0.225); // QA/QD
5937 fPH->SetParameter(5,(Float_t) projPH->GetBinContent(1));
5938
5939 if (fDebug != 2) {
5940 projPH->Fit(fPH,"0M","",0.0,upedge);
5941 }
5942
5943 if (fDebug == 2) {
5944 TCanvas *cpente = new TCanvas("cpente","cpente",50,50,600,800);
5945 cpente->cd();
5946 projPH->Fit(fPH,"M+","",0.0,upedge);
5947 projPH->Draw("E0");
5948 line->SetLineColor(4);
5949 line->DrawLine(fPH->GetParameter(1)
5950 ,0
5951 ,fPH->GetParameter(1)
5952 ,projPH->GetMaximum());
5953 line->DrawLine(fPH->GetParameter(1)+fPH->GetParameter(2)
5954 ,0
5955 ,fPH->GetParameter(1)+fPH->GetParameter(2)
5956 ,projPH->GetMaximum());
5957 line->DrawLine(fPH->GetParameter(1)+fPH->GetParameter(2)+fPH->GetParameter(3)
5958 ,0
5959 ,fPH->GetParameter(1)+fPH->GetParameter(2)+fPH->GetParameter(3)
5960 ,projPH->GetMaximum());
5961 }
5962
5963 if (fPH->GetParameter(3) != 0) {
5964 if(fFitPHNDB == 0) fNumberFitSuccess++;
5965 fVdriftCoef[0] = kDrWidth / (fPH->GetParameter(3));
5966 vdriftCoefE = (fPH->GetParError(3)/fPH->GetParameter(3))*fVdriftCoef[0];
5967 fT0Coef[0] = fPH->GetParameter(1);
5968 t0CoefE = fPH->GetParError(1);
5969 }
5970 else {
5971 fVdriftCoef[0] = -TMath::Abs(fVdriftCoef[2]);
5972 fT0Coef[0] = fT0Coef[2];
5973 }
5974
5975 if ((fDebug == 1) ||
5976 (fDebug == 4)) {
5977 fCoefVdrift[0][idect] = fVdriftCoef[0];
5978 fCoefVdriftE[0][idect] = vdriftCoefE;
5979 fCoefT0[0][idect] = fT0Coef[0];
5980 fCoefT0E[0][idect] = t0CoefE;
5981 }
5982 if (fDebug == 2) {
5983 AliInfo(Form("fVdriftCoef[0]: %f",(Float_t) fVdriftCoef[0]));
5984 }
5985
5986 }
5987
5988 else {
5989
5990 // Put the default value
5991 if ((fDebug <= 1) ||
5992 (fDebug == 4)) {
5993 fCoefVdrift[0][idect] = -TMath::Abs(fVdriftCoef[2]);
5994 fCoefT0[0][idect] = -TMath::Abs(fT0Coef[2]);
5995 }
5996
5997 }
5998
5999 if (fDebug != 2) {
6000 delete fPH;
6001 }
6002
6003}
6004
6005//_____________________________________________________________________________
6006void AliTRDCalibraFit::FitPRF(TH1 *projPRF, Int_t idect)
6007{
6008 //
6009 // Fit methode for the sigma of the pad response function
6010 //
6011
6012 fPRFCoef[0] = 0.0;
6013 Double_t prfCoefE = 0.0;
6014
6015 if (fDebug != 2) {
6016
6017 projPRF->Fit("gaus","0M","",-fRangeFitPRF,fRangeFitPRF);
6018
6019 }
6020
6021 if (fDebug == 2) {
6022 TCanvas *cfit = new TCanvas("cfit","cfit",50,50,600,800);
6023 cfit->cd();
6024 projPRF->Fit("gaus","M+","",-fRangeFitPRF,fRangeFitPRF);
6025 projPRF->Draw();
6026
6027 }
6028
6029 fPRFCoef[0] = projPRF->GetFunction("gaus")->GetParameter(2);
6030 prfCoefE = projPRF->GetFunction("gaus")->GetParError(2);
6031
6032 if(fPRFCoef[0] <= 0.0) fPRFCoef[0] = -fPRFCoef[1];
6033 else {
6034 if(fFitPRFNDB == 0) fNumberFitSuccess++;
6035 }
6036
6037 if ((fDebug == 1) ||
6038 (fDebug == 4)) {
6039 fCoefPRF[0][idect] = fPRFCoef[0];
6040 fCoefPRFE[0][idect] = prfCoefE;
6041 }
6042 if (fDebug == 2) {
6043 AliInfo(Form("fPRFCoef[0]: %f",(Float_t) fPRFCoef[0]));
6044 }
6045
6046}
6047
6048//_____________________________________________________________________________
6049void AliTRDCalibraFit::RmsPRF(TH1 *projPRF, Int_t idect)
6050{
6051 //
6052 // Fit methode for the sigma of the pad response function
6053 //
6054
6055 fPRFCoef[2] = 0.0;
6056 Double_t prfCoefE = 0.0;
6057
6058
6059 if (fDebug == 2) {
6060 TCanvas *cfit = new TCanvas("cfit","cfit",50,50,600,800);
6061 cfit->cd();
6062 projPRF->Draw();
6063
6064 }
6065
6066 fPRFCoef[2] = projPRF->GetRMS();
6067
6068 if(fPRFCoef[2] <= 0.0) fPRFCoef[2] = -fPRFCoef[1];
6069 else {
6070 if(fFitPRFNDB == 2) fNumberFitSuccess++;
6071 }
6072
6073 if ((fDebug == 1) ||
6074 (fDebug == 4)) {
6075 fCoefPRF[2][idect] = fPRFCoef[2];
6076 fCoefPRFE[1][idect] = prfCoefE;
6077 }
6078 if (fDebug == 2) {
6079 AliInfo(Form("fPRFCoef[2]: %f",(Float_t) fPRFCoef[2]));
6080 }
6081
6082}
6083
6084//_____________________________________________________________________________
6085void AliTRDCalibraFit::FitMean(TH1 *projch, Int_t idect, Double_t nentries)
6086{
6087 //
6088 // Only mean methode for the gain factor
6089 //
6090
6091 Double_t chargeCoefE1 = 0.0;
6092 if(nentries > 0) chargeCoefE1 = projch->GetRMS()/TMath::Sqrt(nentries);
6093
6094 if (fDebug == 2) {
6095 TCanvas *cpmean = new TCanvas("cpmean","cpmean",50,50,600,800);
6096 cpmean->cd();
6097 projch->Draw();
6098 }
6099
6100 if(fFitChargeNDB == 1){
6101 CalculChargeCoefMean(fCountDet[0],(Int_t) idect,kTRUE);
6102 fNumberFitSuccess++;
6103 }
6104 if ((fDebug == 1) ||
6105 (fDebug == 4)) {
6106 fCoefCharge[1][idect]= fChargeCoef[1];
6107 fCoefChargeE[1][idect]= chargeCoefE1;
6108 }
6109}
6110
6111//_____________________________________________________________________________
6112void AliTRDCalibraFit::FitMeanW(TH1 *projch, Int_t idect)
6113{
6114 //
6115 // mean w methode for the gain factor
6116 //
6117
6118 //Number of bins
6119 Int_t nybins = projch->GetNbinsX();
6120
6121 //The weight function
6122 Double_t a = 0.00228515;
6123 Double_t b = -0.00231487;
6124 Double_t c = 0.00044298;
6125 Double_t d = -0.00379239;
6126 Double_t e = 0.00338349;
6127
6128 // 0 |0.00228515
6129 // 1 |-0.00231487
6130 // 2 |0.00044298
6131 // 3 |-0.00379239
6132 // 4 |0.00338349
6133
6134 //A arbitrary error for the moment
6135 Double_t chargeCoefE4 = 0.0;
6136 fChargeCoef[4] = 0.0;
6137
6138 //Calcul
6139 Double_t sumw = 0.0;
6140 Double_t sum = 0.0;
6141 Int_t sumAll = (Int_t) projch->GetEntries();
6142 Int_t sumCurrent = 0;
6143 for(Int_t k = 0; k <nybins; k++){
6144 Double_t fraction = Float_t(sumCurrent)/Float_t(sumAll);
6145 if (fraction>0.95) break;
6146 Double_t weight = a + b*fraction + c*fraction*fraction + d *fraction*fraction*fraction+
6147 e*fraction*fraction*fraction*fraction;
6148 sumw += weight*projch->GetBinContent(k+1)*projch->GetBinCenter(k+1);
6149 sum += weight*projch->GetBinContent(k+1);
6150 sumCurrent += (Int_t) projch->GetBinContent(k+1);
6151 //printf("fraction %f, weight %f, bincontent %f\n",fraction,weight,projch->GetBinContent(k+1));
6152 }
6153 if(sum > 0.0) fChargeCoef[4] = (sumw/sum);
6154
6155 if (fDebug == 2) {
6156 AliInfo(Form("fChargeCoef[4] is %f for the dect %d",fChargeCoef[4],idect));
6157 TCanvas *cpmeanw = new TCanvas("cpmeanw","cpmeanw",50,50,600,800);
6158 cpmeanw->cd();
6159 projch->Draw();
6160 }
6161
6162 if(fFitChargeNDB == 4){
6163 fNumberFitSuccess++;
6164 CalculChargeCoefMean(fCountDet[0],(Int_t) idect,kTRUE);
6165 }
6166 if ((fDebug == 1) ||
6167 (fDebug == 4)) {
6168 fCoefCharge[4][idect]= fChargeCoef[4];
6169 fCoefChargeE[3][idect]= chargeCoefE4;
6170 }
6171
6172}
6173
6174//_____________________________________________________________________________
6175void AliTRDCalibraFit::FitCH(TH1 *projch, Int_t idect)
6176{
6177 //
6178 // Fit methode for the gain factor
6179 //
6180
6181 fChargeCoef[0] = 0.0;
6182 Double_t chargeCoefE0 = 0.0;
6183 Double_t chisqrl = 0.0;
6184 Double_t chisqrg = 0.0;
6185 Double_t chisqr = 0.0;
6186 TF1 *fLandauGaus = new TF1("fLandauGaus",FuncLandauGaus,0,300,5);
6187
6188 projch->Fit("landau","0",""
6189 ,(Float_t) fChargeCoef[1]/fBeginFitCharge
6190 ,projch->GetBinCenter(projch->GetNbinsX()));
6191 Double_t l3P0 = projch->GetFunction("landau")->GetParameter(0);
6192 Double_t l3P1 = projch->GetFunction("landau")->GetParameter(1);
6193 Double_t l3P2 = projch->GetFunction("landau")->GetParameter(2);
6194 chisqrl = projch->GetFunction("landau")->GetChisquare();
6195
6196 projch->Fit("gaus","0",""
6197 ,(Float_t) fChargeCoef[1]/fBeginFitCharge
6198 ,projch->GetBinCenter(projch->GetNbinsX()));
6199 Double_t g3P0 = projch->GetFunction("gaus")->GetParameter(0);
6200 Double_t g3P2 = projch->GetFunction("gaus")->GetParameter(2);
6201 chisqrg = projch->GetFunction("gaus")->GetChisquare();
6202
6203 fLandauGaus->SetParameters(l3P0,l3P1,l3P2,g3P0,g3P2);
6204 if ((fDebug <= 1) ||
6205 (fDebug >= 3)) {
6206 projch->Fit("fLandauGaus","0",""
6207 ,(Float_t) fChargeCoef[1]/fBeginFitCharge
6208 ,projch->GetBinCenter(projch->GetNbinsX()));
6209 chisqr = projch->GetFunction("fLandauGaus")->GetChisquare();
6210 }
6211
6212 if (fDebug == 2) {
6213 TCanvas *cp = new TCanvas("cp","cp",50,50,600,800);
6214 cp->cd();
6215 projch->Fit("fLandauGaus","+",""
6216 ,(Float_t) fChargeCoef[1]/fBeginFitCharge
6217 ,projch->GetBinCenter(projch->GetNbinsX()));
6218 chisqr = projch->GetFunction("fLandauGaus")->GetChisquare();
6219 projch->Draw();
6220 fLandauGaus->Draw("same");
6221 }
6222
6223 if ((projch->GetFunction("fLandauGaus")->GetParameter(1) > 0) &&
6224 (projch->GetFunction("fLandauGaus")->GetParError(1) <
6225 (0.05*projch->GetFunction("fLandauGaus")->GetParameter(1))) &&
6226 (chisqr < chisqrl) &&
6227 (chisqr < chisqrg)) {
6228 // Calcul of "real" coef
6229 if(fFitChargeNDB == 0){
6230 fNumberFitSuccess++;
6231 CalculChargeCoefMean(fCountDet[0],(Int_t) idect,kTRUE);
6232 }
6233 else {
6234 CalculChargeCoefMean(fCountDet[0],(Int_t) idect,kFALSE);
6235 }
6236 fChargeCoef[0] = projch->GetFunction("fLandauGaus")->GetParameter(1);
6237 chargeCoefE0 = projch->GetFunction("fLandauGaus")->GetParError(1);
6238 }
6239 else {
6240 // Calcul of "real" coef
6241 CalculChargeCoefMean(fCountDet[0],(Int_t) idect,kFALSE);
6242 fChargeCoef[0] = -TMath::Abs(fChargeCoef[3]);
6243 }
6244
6245 if (fDebug == 2) {
6246 AliInfo(Form("fChargeCoef[0]: %f",(Float_t) fChargeCoef[0]));
6247 AliInfo(Form("fChargeCoef[1]: %f",(Float_t) fChargeCoef[1]));
6248 }
6249
6250 if ((fDebug == 1) ||
6251 (fDebug == 4)) {
6252 if (fChargeCoef[0] > 0.0) {
6253 fCoefCharge[0][idect]= fChargeCoef[0];
6254 fCoefChargeE[0][idect]= chargeCoefE0;
6255 }
6256 }
6257
6258 if (fDebug != 2) {
6259 delete fLandauGaus;
6260 }
6261
6262}
6263
6264//_____________________________________________________________________________
6265void AliTRDCalibraFit::FitBisCH(TH1* projch, Int_t idect)
6266{
6267 //
6268 // Fit methode for the gain factor more time consuming
6269 //
6270
6271 //Some parameters to initialise
6272 Double_t widthLandau, widthGaus, MPV, Integral;
6273 Double_t chisquarel = 0.0;
6274 Double_t chisquareg = 0.0;
6275
6276 projch->Fit("landau","0M+",""
6277 ,(Float_t) fChargeCoef[1]/6
6278 ,projch->GetBinCenter(projch->GetNbinsX()));
6279 widthLandau = projch->GetFunction("landau")->GetParameter(2);
6280 chisquarel = projch->GetFunction("landau")->GetChisquare();
6281
6282 projch->Fit("gaus","0M+",""
6283 ,(Float_t) fChargeCoef[1]/6
6284 ,projch->GetBinCenter(projch->GetNbinsX()));
6285 widthGaus = projch->GetFunction("gaus")->GetParameter(2);
6286 chisquareg = projch->GetFunction("gaus")->GetChisquare();
6287
6288 MPV = (projch->GetFunction("landau")->GetParameter(1))/2;
6289 Integral = (projch->GetFunction("gaus")->Integral(0.3*fChargeCoef[1],3*fChargeCoef[1])
6290 + projch->GetFunction("landau")->Integral(0.3*fChargeCoef[1],3*fChargeCoef[1]))/2;
6291
6292 // Setting fit range and start values
6293 Double_t fr[2];
6294 //Double_t sv[4] = { l3P2, fChargeCoef[1], projch->Integral("width"), fG3P2 };
6295 //Double_t sv[4] = { fL3P2, fChargeCoef[1], fL3P0, fG3P2 };
6296 Double_t sv[4] = { widthLandau, MPV, Integral, widthGaus};
6297 Double_t pllo[4] = { 0.001, 0.001, projch->Integral()/3, 0.001};
6298 Double_t plhi[4] = { 300.0, 300.0, 30*projch->Integral(), 300.0};
6299 Double_t fp[4] = { 1.0, 1.0, 1.0, 1.0 };
6300 Double_t fpe[4] = { 1.0, 1.0, 1.0, 1.0 };
6301 fr[0] = 0.3 * fChargeCoef[1];
6302 fr[1] = 3.0 * fChargeCoef[1];
6303 fChargeCoef[2] = 0.0;
6304 Double_t chargeCoefE2 = 0.0;
6305
6306 Double_t chisqr;
6307 Int_t ndf;
6308 TF1 *fitsnr = LanGauFit(projch,&fr[0],&sv[0]
6309 ,&pllo[0],&plhi[0]
6310 ,&fp[0],&fpe[0]
6311 ,&chisqr,&ndf);
6312
6313 Double_t projchPeak;
6314 Double_t projchFWHM;
6315 LanGauPro(fp,projchPeak,projchFWHM);
6316
6317 if ((fp[1] > 0) && ((fpe[1] < (0.05*fp[1])) && (chisqr < chisquarel) && (chisqr < chisquareg))) {
6318 //if ((fp[1] > 0) && ((chisqr < chisquarel) && (chisqr < chisquareg))) {
6319 if(fFitChargeNDB == 2){
6320 fNumberFitSuccess++;
6321 CalculChargeCoefMean(fCountDet[0],(Int_t) idect,kTRUE);
6322 }
6323 else {
6324 CalculChargeCoefMean(fCountDet[0],(Int_t) idect,kFALSE);
6325 }
6326 fChargeCoef[2] = fp[1];
6327 chargeCoefE2 = fpe[1];
6328 //chargeCoefE2 = chisqr;
6329 }
6330 else {
6331 CalculChargeCoefMean(fCountDet[0],(Int_t) idect,kFALSE);
6332 fChargeCoef[2] = -TMath::Abs(fChargeCoef[3]);
6333 }
6334
6335 if (fDebug == 2) {
6336 AliInfo(Form("fChargeCoef[2]: %f",(Float_t) fChargeCoef[2]));
6337 TCanvas *cpy = new TCanvas("cpy","cpy",50,50,600,800);
6338 cpy->cd();
6339 projch->Draw();
6340 fitsnr->Draw("same");
6341 }
6342
6343 if ((fDebug == 1) ||
6344 (fDebug == 4)) {
6345 if (fChargeCoef[2] > 0.0) {
6346 fCoefCharge[2][idect]= fChargeCoef[2];
6347 fCoefChargeE[2][idect]= chargeCoefE2;
6348 }
6349 }
6350
6351 if (fDebug != 2) {
6352 delete fitsnr;
6353 }
6354
6355}
6356
6357//_____________________________________________________________________________
6358Double_t *AliTRDCalibraFit::CalculPolynomeLagrange2(Double_t *x, Double_t *y)
6359{
6360 //
6361 // Calcul the coefficients of the polynome passant par ces trois points de degre 2
6362 //
6363
6364 Double_t *c = new Double_t[5];
6365 Double_t x0 = y[0]/((x[0]-x[1])*(x[0]-x[2]));
6366 Double_t x1 = y[1]/((x[1]-x[0])*(x[1]-x[2]));
6367 Double_t x2 = y[2]/((x[2]-x[0])*(x[2]-x[1]));
6368
6369 c[4] = 0.0;
6370 c[3] = 0.0;
6371 c[2] = x0+x1+x2;
6372 c[1] = -(x0*(x[1]+x[2])+x1*(x[0]+x[2])+x2*(x[0]+x[1]));
6373 c[0] = x0*x[1]*x[2]+x1*x[0]*x[2]+x2*x[0]*x[1];
6374
6375 return c;
6376
6377}
6378
6379//_____________________________________________________________________________
6380Double_t *AliTRDCalibraFit::CalculPolynomeLagrange3(Double_t *x, Double_t *y)
6381{
6382 //
6383 // Calcul the coefficients of the polynome passant par ces quatre points de degre 3
6384 //
6385
6386 Double_t *c = new Double_t[5];
6387 Double_t x0 = y[0]/((x[0]-x[1])*(x[0]-x[2])*(x[0]-x[3]));
6388 Double_t x1 = y[1]/((x[1]-x[0])*(x[1]-x[2])*(x[1]-x[3]));
6389 Double_t x2 = y[2]/((x[2]-x[0])*(x[2]-x[1])*(x[2]-x[3]));
6390 Double_t x3 = y[3]/((x[3]-x[0])*(x[3]-x[1])*(x[3]-x[2]));
6391
6392 c[4] = 0.0;
6393 c[3] = x0+x1+x2+x3;
6394 c[2] = -(x0*(x[1]+x[2]+x[3])
6395 +x1*(x[0]+x[2]+x[3])
6396 +x2*(x[0]+x[1]+x[3])
6397 +x3*(x[0]+x[1]+x[2]));
6398 c[1] = (x0*(x[1]*x[2]+x[1]*x[3]+x[2]*x[3])
6399 +x1*(x[0]*x[2]+x[0]*x[3]+x[2]*x[3])
6400 +x2*(x[0]*x[1]+x[0]*x[3]+x[1]*x[3])
6401 +x3*(x[0]*x[1]+x[0]*x[2]+x[1]*x[2]));
6402
6403 c[0] = -(x0*x[1]*x[2]*x[3]
6404 +x1*x[0]*x[2]*x[3]
6405 +x2*x[0]*x[1]*x[3]
6406 +x3*x[0]*x[1]*x[2]);
6407
6408 return c;
6409
6410}
6411
6412//_____________________________________________________________________________
6413Double_t *AliTRDCalibraFit::CalculPolynomeLagrange4(Double_t *x, Double_t *y)
6414{
6415 //
6416 // Calcul the coefficients of the polynome passant par ces cinqs points de degre 4
6417 //
6418
6419 Double_t *c = new Double_t[5];
6420 Double_t x0 = y[0]/((x[0]-x[1])*(x[0]-x[2])*(x[0]-x[3])*(x[0]-x[4]));
6421 Double_t x1 = y[1]/((x[1]-x[0])*(x[1]-x[2])*(x[1]-x[3])*(x[1]-x[4]));
6422 Double_t x2 = y[2]/((x[2]-x[0])*(x[2]-x[1])*(x[2]-x[3])*(x[2]-x[4]));
6423 Double_t x3 = y[3]/((x[3]-x[0])*(x[3]-x[1])*(x[3]-x[2])*(x[3]-x[4]));
6424 Double_t x4 = y[4]/((x[4]-x[0])*(x[4]-x[1])*(x[4]-x[2])*(x[4]-x[3]));
6425
6426 c[4] = x0+x1+x2+x3+x4;
6427 c[3] = -(x0*(x[1]+x[2]+x[3]+x[4])
6428 +x1*(x[0]+x[2]+x[3]+x[4])
6429 +x2*(x[0]+x[1]+x[3]+x[4])
6430 +x3*(x[0]+x[1]+x[2]+x[4])
6431 +x4*(x[0]+x[1]+x[2]+x[3]));
6432 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])
6433 +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])
6434 +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])
6435 +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])
6436 +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]));
6437
6438 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])
6439 +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])
6440 +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])
6441 +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])
6442 +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]));
6443
6444 c[0] = (x0*x[1]*x[2]*x[3]*x[4]
6445 +x1*x[0]*x[2]*x[3]*x[4]
6446 +x2*x[0]*x[1]*x[3]*x[4]
6447 +x3*x[0]*x[1]*x[2]*x[4]
6448 +x4*x[0]*x[1]*x[2]*x[3]);
6449
6450 return c;
6451
6452}
6453
6454//_____________________________________________________________________________
6455void AliTRDCalibraFit::NormierungCharge()
6456{
6457 //
6458 // Normalisation of the gain factor resulting for the fits
6459 //
6460
6461 // Calcul of the mean of choosen method by fFitChargeNDB
6462 Double_t sum = 0.0;
6463 //printf("total number of entries %d\n",fVectorFitCH->GetEntriesFast());
6464 for (Int_t k = 0; k < (Int_t) fVectorFitCH->GetEntriesFast(); k++) {
6465 Int_t total = 0;
6466 Int_t detector = ((AliTRDFitCHInfo *) fVectorFitCH->At(k))->GetDetector();
6467 Float_t *coef = ((AliTRDFitCHInfo *) fVectorFitCH->At(k))->GetCoef();
6468 //printf("detector %d coef[0] %f\n",detector,coef[0]);
6469 if (GetChamber(detector) == 2) {
6470 total = 1728;
6471 }
6472 if (GetChamber(detector) != 2) {
6473 total = 2304;
6474 }
6475 for (Int_t j = 0; j < total; j++) {
6476 if (coef[j] >= 0) {
6477 sum += coef[j];
6478 }
6479 }
6480 }
6481
6482 if (sum > 0) {
6483 fScaleFitFactor = fScaleFitFactor / sum;
6484 }
6485 else {
6486 fScaleFitFactor = 1.0;
6487 }
6488
6489 if ((fDebug == 3) ||
6490 (fDebug == 4)) {
6491 if ((fFitChargeOn) &&
6492 (fCoefChargeDB[0]->GetEntries() > 0.0) &&
6493 (fCoefChargeDB[0]->GetSumOfWeights() > 0.0)) {
6494 fCoefChargeDB[0]->Scale(fCoefChargeDB[0]->GetEntries() / fCoefChargeDB[0]->GetSumOfWeights());
6495 }
6496 if ((fMeanChargeOn) &&
6497 (fCoefChargeDB[1]->GetEntries() > 0.0) &&
6498 (fCoefChargeDB[1]->GetSumOfWeights() > 0.0)) {
6499 fCoefChargeDB[1]->Scale(fCoefChargeDB[1]->GetEntries() / fCoefChargeDB[1]->GetSumOfWeights());
6500 }
6501 if ((fFitChargeBisOn) &&
6502 (fCoefChargeDB[2]->GetEntries() > 0.0) &&
6503 (fCoefChargeDB[2]->GetSumOfWeights() > 0.0)) {
6504 fCoefChargeDB[2]->Scale(fCoefChargeDB[2]->GetEntries() / fCoefChargeDB[2]->GetSumOfWeights());
6505 }
6506 if ((fFitMeanWOn) &&
6507 (fCoefChargeDB[3]->GetEntries() > 0.0) &&
6508 (fCoefChargeDB[3]->GetSumOfWeights() > 0.0)) {
6509 fCoefChargeDB[3]->Scale(fCoefChargeDB[3]->GetEntries() / fCoefChargeDB[3]->GetSumOfWeights());
6510 }
6511 }
6512
6513}
6514
6515//_____________________________________________________________________________
6516TH1I *AliTRDCalibraFit::ReBin(TH1I *hist) const
6517{
6518 //
6519 // Rebin of the 1D histo for the gain calibration if needed.
6520 // you have to choose fRebin, divider of fNumberBinCharge
6521 //
6522
6523 TAxis *xhist = hist->GetXaxis();
6524 TH1I *rehist = new TH1I("projrebin","",(Int_t) xhist->GetNbins()/fRebin
6525 ,xhist->GetBinLowEdge(1)
6526 ,xhist->GetBinUpEdge(xhist->GetNbins()));
6527
6528 AliInfo(Form("fRebin: %d",fRebin));
6529 Int_t i = 1;
6530 for (Int_t k = 1; k <= (Int_t) xhist->GetNbins()/fRebin; k++) {
6531 Double_t sum = 0.0;
6532 for (Int_t ji = i; ji < i+fRebin; ji++) {
6533 sum += hist->GetBinContent(ji);
6534 }
6535 sum = sum / fRebin;
6536 rehist->SetBinContent(k,sum);
6537 i += fRebin;
6538 }
6539
6540 if (fDebug == 2) {
6541 TCanvas *crebin = new TCanvas("crebin","",50,50,600,800);
6542 crebin->cd();
6543 rehist->Draw();
6544 }
6545
6546 return rehist;
6547
6548}
6549
6550//_____________________________________________________________________________
6551TH1F *AliTRDCalibraFit::ReBin(TH1F *hist) const
6552{
6553 //
6554 // Rebin of the 1D histo for the gain calibration if needed
6555 // you have to choose fRebin divider of fNumberBinCharge
6556 //
6557
6558 TAxis *xhist = hist->GetXaxis();
6559 TH1F *rehist = new TH1F("projrebin","",(Int_t) xhist->GetNbins()/fRebin
6560 ,xhist->GetBinLowEdge(1)
6561 ,xhist->GetBinUpEdge(xhist->GetNbins()));
6562
6563 AliInfo(Form("fRebin: %d",fRebin));
6564 Int_t i = 1;
6565 for (Int_t k = 1; k <= (Int_t) xhist->GetNbins()/fRebin; k++) {
6566 Double_t sum = 0.0;
6567 for (Int_t ji = i; ji < i+fRebin; ji++) {
6568 sum += hist->GetBinContent(ji);
6569 }
6570 sum = sum/fRebin;
6571 rehist->SetBinContent(k,sum);
6572 i += fRebin;
6573 }
6574
6575 if (fDebug == 2) {
6576 TCanvas *crebin = new TCanvas("crebin","",50,50,600,800);
6577 crebin->cd();
6578 rehist->Draw();
6579 }
6580
6581 return rehist;
6582
6583}
6584
6585//_____________________________________________________________________________
6586TH1F *AliTRDCalibraFit::CorrectTheError(TGraphErrors *hist)
6587{
6588 //
6589 // In the case of the vectors method the trees contains TGraphErrors for PH and PRF
6590 // to be able to add them after
6591 // We convert it to a TH1F to be able to applied the same fit function method
6592 // After having called this function you can not add the statistics anymore
6593 //
6594
6595 TH1F *rehist = 0x0;
6596
6597 Int_t nbins = hist->GetN();
6598 Double_t *x = hist->GetX();
6599 Double_t *entries = hist->GetEX();
6600 Double_t *mean = hist->GetY();
6601 Double_t *square = hist->GetEY();
6602 fEntriesCurrent = 0;
6603
6604 if (nbins < 2) {
6605 return rehist;
6606 }
6607
6608 Double_t step = x[1] - x[0];
6609 Double_t minvalue = x[0] - step/2;
6610 Double_t maxvalue = x[(nbins-1)] + step/2;
6611
6612 rehist = new TH1F("projcorrecterror","",nbins,minvalue,maxvalue);
6613
6614 for (Int_t k = 0; k < nbins; k++) {
6615 rehist->SetBinContent(k+1,mean[k]);
6616 if (entries[k] > 0.0) {
6617 fEntriesCurrent += (Int_t) entries[k];
6618 Double_t d = TMath::Abs(square[k] - (mean[k]*mean[k]));
6619 rehist->SetBinError(k+1,TMath::Sqrt(d/entries[k]));
6620 }
6621 else {
6622 rehist->SetBinError(k+1,0.0);
6623 }
6624 }
6625
6626 return rehist;
6627
6628}
6629
6630//
6631//____________Some basic geometry function_____________________________________
6632//
6633
6634//_____________________________________________________________________________
6635Int_t AliTRDCalibraFit::GetPlane(Int_t d) const
6636{
6637 //
6638 // Reconstruct the plane number from the detector number
6639 //
6640
6641 return ((Int_t) (d % 6));
6642
6643}
6644
6645//_____________________________________________________________________________
6646Int_t AliTRDCalibraFit::GetChamber(Int_t d) const
6647{
6648 //
6649 // Reconstruct the chamber number from the detector number
6650 //
6651 Int_t fgkNplan = 6;
6652
6653 return ((Int_t) (d % 30) / fgkNplan);
6654
6655}
6656
6657//_____________________________________________________________________________
6658Int_t AliTRDCalibraFit::GetSector(Int_t d) const
6659{
6660 //
6661 // Reconstruct the sector number from the detector number
6662 //
6663 Int_t fg = 30;
6664
6665 return ((Int_t) (d / fg));
6666
6667}
6668
6669//
6670//____________Fill and Init tree Gain, PRF, Vdrift and T0______________________
6671//
6672
6673//_____________________________________________________________________________
6674void AliTRDCalibraFit::InitTreePRF()
6675{
6676 //
6677 // Init the tree where the coefficients from the fit methods can be stored
6678 //
6679
6680 gDirectory = gROOT;
6681 fPRFPad = new Float_t[2304];
6682 fPRF = new TTree("PRF","PRF");
6683 fPRF->Branch("detector",&fPRFDetector,"detector/I");
6684 fPRF->Branch("width" ,fPRFPad ,"width[2304]/F");
6685
6686 // Set to default value for the plane 0 supposed to be the first one
6687 for (Int_t k = 0; k < 2304; k++) {
6688 fPRFPad[k] = 0.515;
6689 }
6690 fPRFDetector = -1;
6691
6692}
6693
6694//_____________________________________________________________________________
6695void AliTRDCalibraFit::FillTreePRF(Int_t countdet)
6696{
6697 //
6698 // Fill the tree with the sigma of the pad response function for the detector countdet
6699 //
6700
6701 Int_t numberofgroup = 0;
6702 fPRFDetector = countdet;
6703 fPRF->Fill();
6704
6705 if (GetChamber((Int_t)(countdet+1)) == 2) {
6706 numberofgroup = 1728;
6707 }
6708 else {
6709 numberofgroup = 2304;
6710 }
6711
6712 // Reset to default value for the next
6713 for (Int_t k = 0; k < numberofgroup; k++) {
6714 if (GetPlane((Int_t) (countdet+1)) == 0) {
6715 fPRFPad[k] = 0.515;
6716 }
6717 if (GetPlane((Int_t) (countdet+1)) == 1) {
6718 fPRFPad[k] = 0.502;
6719 }
6720 if (GetPlane((Int_t) (countdet+1)) == 2) {
6721 fPRFPad[k] = 0.491;
6722 }
6723 if (GetPlane((Int_t) (countdet+1)) == 3) {
6724 fPRFPad[k] = 0.481;
6725 }
6726 if (GetPlane((Int_t) (countdet+1)) == 4) {
6727 fPRFPad[k] = 0.471;
6728 }
6729 if (GetPlane((Int_t) (countdet+1)) == 5) {
6730 fPRFPad[k] = 0.463;
6731 }
6732 }
6733
6734 fPRFDetector = -1;
6735
6736}
6737
6738//_____________________________________________________________________________
6739void AliTRDCalibraFit::ConvertVectorFitCHTree()
6740{
6741 //
6742 // Convert the vector stuff to a tree of 1D histos if the user
6743 // want to write it after the fill functions
6744 //
6745
6746 Int_t detector = -1;
6747 Int_t numberofgroup = 1;
6748 Float_t gainPad[2304];
6749
6750 fGain = new TTree("Gain","Gain");
6751 fGain->Branch("detector",&detector,"detector/I");
6752 fGain->Branch("gainPad" ,gainPad ,"gainPad[2304]/F");
6753
6754 Int_t loop = (Int_t) fVectorFitCH->GetEntriesFast();
6755 for (Int_t k = 0; k < loop; k++) {
6756 detector = ((AliTRDFitCHInfo *) fVectorFitCH->At(k))->GetDetector();
6757 if (GetChamber((Int_t) ((AliTRDFitCHInfo *) fVectorFitCH->At(k))->GetDetector()) == 2) {
6758 numberofgroup = 1728;
6759 }
6760 else {
6761 numberofgroup = 2304;
6762 }
6763 for (Int_t i = 0; i < numberofgroup; i++) {
6764 if (((AliTRDFitCHInfo *) fVectorFitCH->At(k))->GetCoef()[i] >= 0) {
6765 gainPad[i] = ((AliTRDFitCHInfo *) fVectorFitCH->At(k))->GetCoef()[i] * fScaleFitFactor;
6766 }
6767 else {
6768 gainPad[i] = (Float_t) ((AliTRDFitCHInfo *) fVectorFitCH->At(k))->GetCoef()[i];
6769 }
6770 }
6771 //Finish the vector
6772 if(numberofgroup < 2304){
6773 for(Int_t i = numberofgroup; i < 2304; i++){
6774 gainPad[i] = -100.0;
6775 }
6776 }
6777 fGain->Fill();
6778 }
6779
6780}
6781
6782//_____________________________________________________________________________
6783void AliTRDCalibraFit::FillTreeVdrift(Int_t countdet)
6784{
6785 //
6786 // Fill the tree with the drift velocities for the detector countdet
6787 //
6788
6789 Int_t numberofgroup = 0;
6790 fVdriftDetector = countdet;
6791
6792 fVdrift->Fill();
6793 if (GetChamber((Int_t)(countdet+1)) == 2) {
6794 numberofgroup = 1728;
6795 }
6796 else {
6797 numberofgroup = 2304;
6798 }
6799 // Reset to default value the gain coef
6800 for (Int_t k = 0; k < numberofgroup; k++) {
6801 fVdriftPad[k] = -1.5;
6802 }
6803 fVdriftDetector = -1;
6804
6805}
6806
6807//_____________________________________________________________________________
6808void AliTRDCalibraFit::InitTreePH()
6809{
6810 //
6811 // Init the tree where the coefficients from the fit methods can be stored
6812 //
6813
6814 gDirectory = gROOT;
6815 fVdriftPad = new Float_t[2304];
6816 fVdrift = new TTree("Vdrift","Vdrift");
6817 fVdrift->Branch("detector",&fVdriftDetector,"detector/I");
6818 fVdrift->Branch("vdrift" ,fVdriftPad ,"vdrift[2304]/F");
6819 // Set to default value for the plane 0 supposed to be the first one
6820 for (Int_t k = 0; k < 2304; k++) {
6821 fVdriftPad[k] = -1.5;
6822 }
6823 fVdriftDetector = -1;
6824
6825}
6826
6827//_____________________________________________________________________________
6828void AliTRDCalibraFit::FillTreeT0(Int_t countdet)
6829{
6830 //
6831 // Fill the tree with the t0 value for the detector countdet
6832 //
6833
6834 Int_t numberofgroup = 0;
6835
6836 fT0Detector = countdet;
6837
6838 fT0->Fill();
6839 if (GetChamber((Int_t) (countdet+1)) == 2) {
6840 numberofgroup = 1728;
6841 }
6842 else {
6843 numberofgroup = 2304;
6844 }
6845 // Reset to default value
6846 for (Int_t k = 0; k < numberofgroup; k++) {
6847 fT0Pad[k] = 0.0;
6848 }
6849 fT0Detector = -1;
6850
6851}
6852
6853//_____________________________________________________________________________
6854void AliTRDCalibraFit::InitTreeT0()
6855{
6856 //
6857 // Init the tree where the coefficients from the fit methods can be stored
6858 //
6859
6860 gDirectory = gROOT;
6861 fT0Pad = new Float_t[2304];
6862 fT0 = new TTree("T0","T0");
6863 fT0->Branch("detector",&fT0Detector,"detector/I");
6864 fT0->Branch("t0",fT0Pad,"t0[2304]/F");
6865 //Set to default value for the plane 0 supposed to be the first one
6866 for(Int_t k = 0; k < 2304; k++){
6867 fT0Pad[k] = 0.0;
6868 }
6869 fT0Detector = -1;
6870
6871}
6872
6873//
6874//____________Private Functions________________________________________________
6875//
6876
6877//_____________________________________________________________________________
6878Double_t AliTRDCalibraFit::PH(Double_t *x, Double_t *par)
6879{
6880 //
6881 // Function for the fit
6882 //
6883
6884 //TF1 *fAsymmGauss = new TF1("fAsymmGauss",AsymmGauss,0,4,6);
6885
6886 //PARAMETERS FOR FIT PH
6887 // PASAv.4
6888 //fAsymmGauss->SetParameter(0,0.113755);
6889 //fAsymmGauss->SetParameter(1,0.350706);
6890 //fAsymmGauss->SetParameter(2,0.0604244);
6891 //fAsymmGauss->SetParameter(3,7.65596);
6892 //fAsymmGauss->SetParameter(4,1.00124);
6893 //fAsymmGauss->SetParameter(5,0.870597); // No tail cancelation
6894
6895 Double_t xx = x[0];
6896
6897 if (xx < par[1]) {
6898 return par[5];
6899 }
6900
6901 Double_t dx = 0.005;
6902 Double_t xs = par[1];
6903 Double_t ss = 0.0;
6904 Double_t paras[2] = { 0.0, 0.0 };
6905
6906 while (xs < xx) {
6907 if ((xs >= par[1]) &&
6908 (xs < (par[1]+par[2]))) {
6909 //fAsymmGauss->SetParameter(0,par[0]);
6910 //fAsymmGauss->SetParameter(1,xs);
6911 //ss += fAsymmGauss->Eval(xx);
6912 paras[0] = par[0];
6913 paras[1] = xs;
6914 ss += AsymmGauss(&xx,paras);
6915 }
6916 if ((xs >= (par[1]+par[2])) &&
6917 (xs < (par[1]+par[2]+par[3]))) {
6918 //fAsymmGauss->SetParameter(0,par[0]*par[4]);
6919 //fAsymmGauss->SetParameter(1,xs);
6920 //ss += fAsymmGauss->Eval(xx);
6921 paras[0] = par[0]*par[4];
6922 paras[1] = xs;
6923 ss += AsymmGauss(&xx,paras);
6924 }
6925 xs += dx;
6926 }
6927
6928 return ss + par[5];
6929
6930}
6931
6932//_____________________________________________________________________________
6933Double_t AliTRDCalibraFit::AsymmGauss(Double_t *x, Double_t *par)
6934{
6935 //
6936 // Function for the fit
6937 //
6938
6939 //par[0] = normalization
6940 //par[1] = mean
6941 //par[2] = sigma
6942 //norm0 = 1
6943 //par[3] = lambda0
6944 //par[4] = norm1
6945 //par[5] = lambda1
6946
6947 Double_t par1save = par[1];
6948 //Double_t par2save = par[2];
6949 Double_t par2save = 0.0604244;
6950 //Double_t par3save = par[3];
6951 Double_t par3save = 7.65596;
6952 //Double_t par5save = par[5];
6953 Double_t par5save = 0.870597;
6954 Double_t dx = x[0] - par1save;
6955
6956 Double_t sigma2 = par2save*par2save;
6957 Double_t sqrt2 = TMath::Sqrt(2.0);
6958 Double_t exp1 = par3save * TMath::Exp(-par3save * (dx - 0.5 * par3save * sigma2))
6959 * (1.0 - TMath::Erf((par3save * sigma2 - dx) / (sqrt2 * par2save)));
6960 Double_t exp2 = par5save * TMath::Exp(-par5save * (dx - 0.5 * par5save * sigma2))
6961 * (1.0 - TMath::Erf((par5save * sigma2 - dx) / (sqrt2 * par2save)));
6962
6963 //return par[0]*(exp1+par[4]*exp2);
6964 return par[0] * (exp1 + 1.00124 * exp2);
6965
6966}
6967
6968//_____________________________________________________________________________
6969Double_t AliTRDCalibraFit::FuncLandauGaus(Double_t *x, Double_t *par)
6970{
6971 //
6972 // Sum Landau + Gaus with identical mean
6973 //
6974
6975 Double_t valLandau = par[0] * TMath::Landau(x[0],par[1],par[2]);
6976 //Double_t valGaus = par[3] * TMath::Gaus(x[0],par[4],par[5]);
6977 Double_t valGaus = par[3] * TMath::Gaus(x[0],par[1],par[4]);
6978 Double_t val = valLandau + valGaus;
6979
6980 return val;
6981
6982}
6983
6984//_____________________________________________________________________________
6985Double_t AliTRDCalibraFit::LanGauFun(Double_t *x, Double_t *par)
6986{
6987 //
6988 // Function for the fit
6989 //
6990 // Fit parameters:
6991 // par[0]=Width (scale) parameter of Landau density
6992 // par[1]=Most Probable (MP, location) parameter of Landau density
6993 // par[2]=Total area (integral -inf to inf, normalization constant)
6994 // par[3]=Width (sigma) of convoluted Gaussian function
6995 //
6996 // In the Landau distribution (represented by the CERNLIB approximation),
6997 // the maximum is located at x=-0.22278298 with the location parameter=0.
6998 // This shift is corrected within this function, so that the actual
6999 // maximum is identical to the MP parameter.
7000 //
7001
7002 // Numeric constants
7003 Double_t invsq2pi = 0.3989422804014; // (2 pi)^(-1/2)
7004 Double_t mpshift = -0.22278298; // Landau maximum location
7005
7006 // Control constants
7007 Double_t np = 100.0; // Number of convolution steps
7008 Double_t sc = 5.0; // Convolution extends to +-sc Gaussian sigmas
7009
7010 // Variables
7011 Double_t xx;
7012 Double_t mpc;
7013 Double_t fland;
7014 Double_t sum = 0.0;
7015 Double_t xlow;
7016 Double_t xupp;
7017 Double_t step;
7018 Double_t i;
7019
7020 // MP shift correction
7021 mpc = par[1] - mpshift * par[0];
7022
7023 // Range of convolution integral
7024 xlow = x[0] - sc * par[3];
7025 xupp = x[0] + sc * par[3];
7026
7027 step = (xupp - xlow) / np;
7028
7029 // Convolution integral of Landau and Gaussian by sum
7030 for (i = 1.0; i <= np/2; i++) {
7031
7032 xx = xlow + (i-.5) * step;
7033 fland = TMath::Landau(xx,mpc,par[0]) / par[0];
7034 sum += fland * TMath::Gaus(x[0],xx,par[3]);
7035
7036 xx = xupp - (i-.5) * step;
7037 fland = TMath::Landau(xx,mpc,par[0]) / par[0];
7038 sum += fland * TMath::Gaus(x[0],xx,par[3]);
7039
7040 }
7041
7042 return (par[2] * step * sum * invsq2pi / par[3]);
7043
7044}
7045
7046//_____________________________________________________________________________
7047TF1 *AliTRDCalibraFit::LanGauFit(TH1 *his, Double_t *fitrange, Double_t *startvalues
7048 , Double_t *parlimitslo, Double_t *parlimitshi
7049 , Double_t *fitparams, Double_t *fiterrors
7050 , Double_t *chiSqr, Int_t *ndf)
7051{
7052 //
7053 // Function for the fit
7054 //
7055
7056 Int_t i;
7057 Char_t funname[100];
7058
7059 TF1 *ffitold = (TF1 *) gROOT->GetListOfFunctions()->FindObject(funname);
7060 if (ffitold) {
7061 delete ffitold;
7062 }
7063
7064 TF1 *ffit = new TF1(funname,LanGauFun,fitrange[0],fitrange[1],4);
7065 ffit->SetParameters(startvalues);
7066 ffit->SetParNames("Width","MP","Area","GSigma");
7067
7068 for (i = 0; i < 4; i++) {
7069 ffit->SetParLimits(i,parlimitslo[i],parlimitshi[i]);
7070 }
7071
7072 his->Fit(funname,"RB0"); // Fit within specified range, use ParLimits, do not plot
7073
7074 ffit->GetParameters(fitparams); // Obtain fit parameters
7075 for (i = 0; i < 4; i++) {
7076 fiterrors[i] = ffit->GetParError(i); // Obtain fit parameter errors
7077 }
7078 chiSqr[0] = ffit->GetChisquare(); // Obtain chi^2
7079 ndf[0] = ffit->GetNDF(); // Obtain ndf
7080
7081 return (ffit); // Return fit function
7082
7083}
7084
7085//_____________________________________________________________________________
7086Int_t AliTRDCalibraFit::LanGauPro(Double_t *params, Double_t &maxx, Double_t &fwhm)
7087{
7088 //
7089 // Function for the fit
7090 //
7091
7092 Double_t p;
7093 Double_t x;
7094 Double_t fy;
7095 Double_t fxr;
7096 Double_t fxl;
7097 Double_t step;
7098 Double_t l;
7099 Double_t lold;
7100
7101 Int_t i = 0;
7102 Int_t maxcalls = 10000;
7103
7104 // Search for maximum
7105 p = params[1] - 0.1 * params[0];
7106 step = 0.05 * params[0];
7107 lold = -2.0;
7108 l = -1.0;
7109
7110 while ((l != lold) && (i < maxcalls)) {
7111 i++;
7112 lold = l;
7113 x = p + step;
7114 l = LanGauFun(&x,params);
7115 if (l < lold) {
7116 step = -step / 10.0;
7117 }
7118 p += step;
7119 }
7120
7121 if (i == maxcalls) {
7122 return (-1);
7123 }
7124 maxx = x;
7125 fy = l / 2.0;
7126
7127 // Search for right x location of fy
7128 p = maxx + params[0];
7129 step = params[0];
7130 lold = -2.0;
7131 l = -1e300;
7132 i = 0;
7133
7134 while ( (l != lold) && (i < maxcalls) ) {
7135 i++;
7136
7137 lold = l;
7138 x = p + step;
7139 l = TMath::Abs(LanGauFun(&x,params) - fy);
7140
7141 if (l > lold)
7142 step = -step/10;
7143
7144 p += step;
7145 }
7146
7147 if (i == maxcalls)
7148 return (-2);
7149
7150 fxr = x;
7151
7152 // Search for left x location of fy
7153
7154 p = maxx - 0.5 * params[0];
7155 step = -params[0];
7156 lold = -2.0;
7157 l = -1.0e300;
7158 i = 0;
7159
7160 while ((l != lold) && (i < maxcalls)) {
7161 i++;
7162 lold = l;
7163 x = p + step;
7164 l = TMath::Abs(LanGauFun(&x,params) - fy);
7165 if (l > lold) {
7166 step = -step / 10.0;
7167 }
7168 p += step;
7169 }
7170
7171 if (i == maxcalls) {
7172 return (-3);
7173 }
7174
7175 fxl = x;
7176 fwhm = fxr - fxl;
7177
7178 return (0);
7179
7180}
7181
7182//_____________________________________________________________________________
7183Double_t AliTRDCalibraFit::GausConstant(Double_t *x, Double_t *par)
7184{
7185 //
7186 // Gaus with identical mean
7187 //
7188
7189 Double_t gauss = par[0] * TMath::Gaus(x[0],0.0,par[1])+par[2];
7190
7191 return gauss;
7192
7193}