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