Coverity stuff once more ...
[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 }
1947 object->SetValue(detector,mean);
55a288e5 1948 }
3a0f6479 1949
1950 return object;
1951}
1952//_____________________________________________________________________________
979b168f 1953AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectT0(const TObjArray *vectorFit, Bool_t perdetector)
3a0f6479 1954{
1955 //
1956 // It creates the AliTRDCalDet object from the AliTRDFitInfo2
1957 // It takes the min value of the coefficients per detector
1958 // This object has to be written in the database
1959 //
55a288e5 1960
3a0f6479 1961 // Create the DetObject
1962 AliTRDCalDet *object = new AliTRDCalDet("ChamberT0","T0 (detector value)");
55a288e5 1963
3a0f6479 1964 Int_t loop = (Int_t) vectorFit->GetEntriesFast();
1965 if(loop != 540) AliInfo("The Vector Fit is not complete!");
1966 Int_t detector = -1;
1967 Float_t value = 0.0;
1968
1969 for (Int_t k = 0; k < loop; k++) {
1970 detector = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
1971 Float_t min = 100.0;
1972 if(perdetector){
64942b85 1973 value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[0];
1974 // check successful
1975 if(value > 70.0) value = value-100.0;
1976 //
1977 min = value;
55a288e5 1978 }
3a0f6479 1979 else{
053767a4 1980 Int_t rowMax = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
1981 Int_t colMax = fGeo->GetColMax(GetLayer(detector));
3a0f6479 1982 for (Int_t row = 0; row < rowMax; row++) {
1983 for (Int_t col = 0; col < colMax; col++) {
1984 value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
64942b85 1985 // check successful
1986 if(value > 70.0) value = value-100.0;
1987 //
3a0f6479 1988 if(min > value) min = value;
1989 } // Col
1990 } // Row
1991 }
1992 object->SetValue(detector,min);
55a288e5 1993 }
1994
1995 return object;
1996
1997}
55a288e5 1998//_____________________________________________________________________________
979b168f 1999AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectLorentzAngle(const TObjArray *vectorFit)
55a288e5 2000{
2001 //
3a0f6479 2002 // It creates the AliTRDCalDet object from the AliTRDFitInfo2
2003 // It takes the min value of the coefficients per detector
55a288e5 2004 // This object has to be written in the database
2005 //
2006
2007 // Create the DetObject
3a0f6479 2008 AliTRDCalDet *object = new AliTRDCalDet("tan(lorentzangle)","tan(lorentzangle) (detector value)");
2009
2010
2011 Int_t loop = (Int_t) vectorFit->GetEntriesFast();
2012 if(loop != 540) AliInfo("The Vector Fit is not complete!");
2013 Int_t detector = -1;
2014 Float_t value = 0.0;
55a288e5 2015
3a0f6479 2016 for (Int_t k = 0; k < loop; k++) {
2017 detector = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
2018 /*
053767a4 2019 Int_t rowMax = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
2020 Int_t colMax = fGeo->GetColMax(GetLayer(detector));
3a0f6479 2021 Float_t min = 100.0;
2022 for (Int_t row = 0; row < rowMax; row++) {
2023 for (Int_t col = 0; col < colMax; col++) {
2024 value = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
2025 mean += -TMath::Abs(value);
2026 count++;
55a288e5 2027 } // Col
3a0f6479 2028 } // Row
2029 if(count > 0) mean = mean/count;
2030 */
2031 value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[0];
2032 object->SetValue(detector,-TMath::Abs(value));
55a288e5 2033 }
2034
2035 return object;
3a0f6479 2036
55a288e5 2037}
55a288e5 2038//_____________________________________________________________________________
979b168f 2039TObject *AliTRDCalibraFit::CreatePadObjectGain(const TObjArray *vectorFit, Double_t scaleFitFactor, const AliTRDCalDet *detobject)
3a0f6479 2040{
55a288e5 2041 //
3a0f6479 2042 // It Creates the AliTRDCalPad object from AliTRDFitInfo
2043 // You need first to create the object for the detectors,
2044 // where the mean value is put.
2045 // This object has to be written in the database
55a288e5 2046 //
3a0f6479 2047
2048 // Create the DetObject
2049 AliTRDCalPad *object = new AliTRDCalPad("GainFactor","GainFactor (local variations)");
2050
2051 if(!vectorFit){
2052 for(Int_t k = 0; k < 540; k++){
2053 AliTRDCalROC *calROC = object->GetCalROC(k);
2054 Int_t nchannels = calROC->GetNchannels();
2055 for(Int_t ch = 0; ch < nchannels; ch++){
2056 calROC->SetValue(ch,1.0);
2057 }
2058 }
55a288e5 2059 }
3a0f6479 2060 else{
2061
2062 Int_t loop = (Int_t) vectorFit->GetEntriesFast();
2063 if(loop != 540) AliInfo("The Vector Fit is not complete!");
2064 Int_t detector = -1;
2065 Float_t value = 0.0;
2066
2067 for (Int_t k = 0; k < loop; k++) {
2068 detector = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
2069 AliTRDCalROC *calROC = object->GetCalROC(detector);
2070 Float_t mean = detobject->GetValue(detector);
daa7dc79 2071 if(TMath::Abs(mean) <= 0.0000000001) continue;
3a0f6479 2072 Int_t rowMax = calROC->GetNrows();
2073 Int_t colMax = calROC->GetNcols();
2074 for (Int_t row = 0; row < rowMax; row++) {
2075 for (Int_t col = 0; col < colMax; col++) {
2076 value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
2077 if(value > 0) value = value*scaleFitFactor;
2078 calROC->SetValue(col,row,TMath::Abs(value)/mean);
2079 } // Col
2080 } // Row
2081 }
55a288e5 2082 }
2083
3a0f6479 2084 return object;
55a288e5 2085}
55a288e5 2086//_____________________________________________________________________________
979b168f 2087TObject *AliTRDCalibraFit::CreatePadObjectVdrift(const TObjArray *vectorFit, const AliTRDCalDet *detobject)
3a0f6479 2088{
55a288e5 2089 //
3a0f6479 2090 // It Creates the AliTRDCalPad object from AliTRDFitInfo
2091 // You need first to create the object for the detectors,
2092 // where the mean value is put.
2093 // This object has to be written in the database
55a288e5 2094 //
2095
3a0f6479 2096 // Create the DetObject
2097 AliTRDCalPad *object = new AliTRDCalPad("LocalVdrift","TRD drift velocities (local variations)");
2098
2099 if(!vectorFit){
2100 for(Int_t k = 0; k < 540; k++){
2101 AliTRDCalROC *calROC = object->GetCalROC(k);
2102 Int_t nchannels = calROC->GetNchannels();
2103 for(Int_t ch = 0; ch < nchannels; ch++){
2104 calROC->SetValue(ch,1.0);
2105 }
2106 }
55a288e5 2107 }
2108 else {
3a0f6479 2109
2110 Int_t loop = (Int_t) vectorFit->GetEntriesFast();
2111 if(loop != 540) AliInfo("The Vector Fit is not complete!");
2112 Int_t detector = -1;
2113 Float_t value = 0.0;
2114
2115 for (Int_t k = 0; k < loop; k++) {
2116 detector = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
2117 AliTRDCalROC *calROC = object->GetCalROC(detector);
2118 Float_t mean = detobject->GetValue(detector);
2119 if(mean == 0) continue;
2120 Int_t rowMax = calROC->GetNrows();
2121 Int_t colMax = calROC->GetNcols();
2122 for (Int_t row = 0; row < rowMax; row++) {
2123 for (Int_t col = 0; col < colMax; col++) {
2124 value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
2125 calROC->SetValue(col,row,TMath::Abs(value)/mean);
2126 } // Col
2127 } // Row
2128 }
55a288e5 2129 }
3a0f6479 2130 return object;
55a288e5 2131
2132}
55a288e5 2133//_____________________________________________________________________________
979b168f 2134TObject *AliTRDCalibraFit::CreatePadObjectT0(const TObjArray *vectorFit, const AliTRDCalDet *detobject)
3a0f6479 2135{
55a288e5 2136 //
3a0f6479 2137 // It Creates the AliTRDCalPad object from AliTRDFitInfo2
2138 // You need first to create the object for the detectors,
2139 // where the mean value is put.
2140 // This object has to be written in the database
55a288e5 2141 //
3a0f6479 2142
2143 // Create the DetObject
2144 AliTRDCalPad *object = new AliTRDCalPad("LocalT0","T0 (local variations)");
2145
2146 if(!vectorFit){
2147 for(Int_t k = 0; k < 540; k++){
2148 AliTRDCalROC *calROC = object->GetCalROC(k);
2149 Int_t nchannels = calROC->GetNchannels();
2150 for(Int_t ch = 0; ch < nchannels; ch++){
2151 calROC->SetValue(ch,0.0);
2152 }
2153 }
55a288e5 2154 }
2155 else {
3a0f6479 2156
2157 Int_t loop = (Int_t) vectorFit->GetEntriesFast();
2158 if(loop != 540) AliInfo("The Vector Fit is not complete!");
2159 Int_t detector = -1;
2160 Float_t value = 0.0;
2161
2162 for (Int_t k = 0; k < loop; k++) {
2163 detector = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
2164 AliTRDCalROC *calROC = object->GetCalROC(detector);
2165 Float_t min = detobject->GetValue(detector);
2166 Int_t rowMax = calROC->GetNrows();
2167 Int_t colMax = calROC->GetNcols();
2168 for (Int_t row = 0; row < rowMax; row++) {
2169 for (Int_t col = 0; col < colMax; col++) {
2170 value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
64942b85 2171 // check successful
2172 if(value > 70.0) value = value - 100.0;
2173 //
3a0f6479 2174 calROC->SetValue(col,row,value-min);
2175 } // Col
2176 } // Row
2177 }
55a288e5 2178 }
3a0f6479 2179 return object;
55a288e5 2180
2181}
3a0f6479 2182//_____________________________________________________________________________
979b168f 2183TObject *AliTRDCalibraFit::CreatePadObjectPRF(const TObjArray *vectorFit)
3a0f6479 2184{
2185 //
2186 // It Creates the AliTRDCalPad object from AliTRDFitInfo
2187 // This object has to be written in the database
2188 //
2189
2190 // Create the DetObject
2191 AliTRDCalPad *object = new AliTRDCalPad("PRFWidth","PRFWidth");
2192
2193 Int_t loop = (Int_t) vectorFit->GetEntriesFast();
2194 if(loop != 540) AliInfo("The Vector Fit is not complete!");
2195 Int_t detector = -1;
2196 Float_t value = 0.0;
2197
2198 for (Int_t k = 0; k < loop; k++) {
2199 detector = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
2200 AliTRDCalROC *calROC = object->GetCalROC(detector);
2201 Int_t rowMax = calROC->GetNrows();
2202 Int_t colMax = calROC->GetNcols();
2203 for (Int_t row = 0; row < rowMax; row++) {
2204 for (Int_t col = 0; col < colMax; col++) {
2205 value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
2206 calROC->SetValue(col,row,TMath::Abs(value));
2207 } // Col
2208 } // Row
2209 }
55a288e5 2210
3a0f6479 2211 return object;
2212
2213}
55a288e5 2214//_____________________________________________________________________________
979b168f 2215AliTRDCalDet *AliTRDCalibraFit::MakeOutliersStatDet(const TObjArray *vectorFit, const char *name, Double_t &mean)
3a0f6479 2216{
2217 //
2218 // It Creates the AliTRDCalDet object from AliTRDFitInfo
2219 // 0 successful fit 1 not successful fit
2220 // mean is the mean value over the successful fit
2221 // do not use it for t0: no meaning
2222 //
2223
2224 // Create the CalObject
2225 AliTRDCalDet *object = new AliTRDCalDet(name,name);
2226 mean = 0.0;
2227 Int_t count = 0;
2228
2229 Int_t loop = (Int_t) vectorFit->GetEntriesFast();
2230 if(loop != 540) {
2231 AliInfo("The Vector Fit is not complete! We initialise all outliers");
2232 for(Int_t k = 0; k < 540; k++){
2233 object->SetValue(k,1.0);
2234 }
2235 }
2236 Int_t detector = -1;
2237 Float_t value = 0.0;
2238
2239 for (Int_t k = 0; k < loop; k++) {
2240 detector = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
2241 value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[0];
2242 if(value <= 0) object->SetValue(detector,1.0);
2243 else {
2244 object->SetValue(detector,0.0);
2245 mean += value;
2246 count++;
2247 }
2248 }
2249 if(count > 0) mean /= count;
2250 return object;
2251}
2252//_____________________________________________________________________________
979b168f 2253TObject *AliTRDCalibraFit::MakeOutliersStatPad(const TObjArray *vectorFit, const char *name, Double_t &mean)
3a0f6479 2254{
2255 //
2256 // It Creates the AliTRDCalPad object from AliTRDFitInfo
2257 // 0 not successful fit 1 successful fit
2258 // mean mean value over the successful fit
2259 //
2260
2261 // Create the CalObject
2262 AliTRDCalPad *object = new AliTRDCalPad(name,name);
2263 mean = 0.0;
2264 Int_t count = 0;
2265
2266 Int_t loop = (Int_t) vectorFit->GetEntriesFast();
2267 if(loop != 540) {
2268 AliInfo("The Vector Fit is not complete! We initialise all outliers");
2269 for(Int_t k = 0; k < 540; k++){
2270 AliTRDCalROC *calROC = object->GetCalROC(k);
2271 Int_t nchannels = calROC->GetNchannels();
2272 for(Int_t ch = 0; ch < nchannels; ch++){
2273 calROC->SetValue(ch,1.0);
2274 }
2275 }
2276 }
2277 Int_t detector = -1;
2278 Float_t value = 0.0;
2279
2280 for (Int_t k = 0; k < loop; k++) {
2281 detector = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
2282 AliTRDCalROC *calROC = object->GetCalROC(detector);
2283 Int_t nchannels = calROC->GetNchannels();
2284 for (Int_t ch = 0; ch < nchannels; ch++) {
2285 value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[ch];
2286 if(value <= 0) calROC->SetValue(ch,1.0);
2287 else {
2288 calROC->SetValue(ch,0.0);
2289 mean += value;
2290 count++;
2291 }
2292 } // channels
2293 }
2294 if(count > 0) mean /= count;
2295 return object;
2296}
2297//_____________________________________________________________________________
2298void AliTRDCalibraFit::SetPeriodeFitPH(Int_t periodeFitPH)
55a288e5 2299{
2300 //
3a0f6479 2301 // Set FitPH if 1 then each detector will be fitted
55a288e5 2302 //
2303
3a0f6479 2304 if (periodeFitPH > 0) {
2305 fFitPHPeriode = periodeFitPH;
55a288e5 2306 }
2307 else {
3a0f6479 2308 AliInfo("periodeFitPH must be higher than 0!");
55a288e5 2309 }
2310
2311}
55a288e5 2312//_____________________________________________________________________________
2313void AliTRDCalibraFit::SetBeginFitCharge(Float_t beginFitCharge)
2314{
2315 //
2316 // The fit of the deposited charge distribution begins at
2317 // histo->Mean()/beginFitCharge
2318 // You can here set beginFitCharge
2319 //
2320
2321 if (beginFitCharge > 0) {
2322 fBeginFitCharge = beginFitCharge;
2323 }
2324 else {
2325 AliInfo("beginFitCharge must be strict positif!");
2326 }
2327
2328}
2329
2330//_____________________________________________________________________________
413153cb 2331void AliTRDCalibraFit::SetT0Shift0(Float_t t0Shift)
2332{
2333 //
2334 // The t0 calculated with the maximum positif slope is shift from t0Shift0
2335 // You can here set t0Shift0
2336 //
2337
2338 if (t0Shift > 0) {
2339 fT0Shift0 = t0Shift;
2340 }
2341 else {
2342 AliInfo("t0Shift0 must be strict positif!");
2343 }
2344
2345}
2346
2347//_____________________________________________________________________________
2348void AliTRDCalibraFit::SetT0Shift1(Float_t t0Shift)
55a288e5 2349{
2350 //
413153cb 2351 // The t0 calculated with the maximum of the amplification region is shift from t0Shift1
2352 // You can here set t0Shift1
55a288e5 2353 //
2354
2355 if (t0Shift > 0) {
413153cb 2356 fT0Shift1 = t0Shift;
55a288e5 2357 }
2358 else {
2359 AliInfo("t0Shift must be strict positif!");
2360 }
2361
2362}
2363
2364//_____________________________________________________________________________
2365void AliTRDCalibraFit::SetRangeFitPRF(Float_t rangeFitPRF)
2366{
2367 //
2368 // The fit of the PRF is from -rangeFitPRF to rangeFitPRF
2369 // You can here set rangeFitPRF
2370 //
2371
2372 if ((rangeFitPRF > 0) &&
2373 (rangeFitPRF <= 1.5)) {
2374 fRangeFitPRF = rangeFitPRF;
2375 }
2376 else {
2377 AliInfo("rangeFitPRF must be between 0 and 1.0");
2378 }
2379
2380}
2381
2382//_____________________________________________________________________________
3a0f6479 2383void AliTRDCalibraFit::SetMinEntries(Int_t minEntries)
55a288e5 2384{
2385 //
3a0f6479 2386 // Minimum entries for fitting
55a288e5 2387 //
2388
3a0f6479 2389 if (minEntries > 0) {
2390 fMinEntries = minEntries;
55a288e5 2391 }
2392 else {
3a0f6479 2393 AliInfo("fMinEntries must be >= 0.");
55a288e5 2394 }
2395
2396}
2397
55a288e5 2398//_____________________________________________________________________________
3a0f6479 2399void AliTRDCalibraFit::SetRebin(Short_t rebin)
2400{
55a288e5 2401 //
3a0f6479 2402 // Rebin with rebin time less bins the Ch histo
2403 // You can set here rebin that should divide the number of bins of CH histo
55a288e5 2404 //
55a288e5 2405
3a0f6479 2406 if (rebin > 0) {
2407 fRebin = rebin;
2408 AliInfo("You have to be sure that fRebin divides fNumberBinCharge used!");
2409 }
2410 else {
2411 AliInfo("You have to choose a positiv value!");
55a288e5 2412 }
2413
2414}
55a288e5 2415//_____________________________________________________________________________
3a0f6479 2416Bool_t AliTRDCalibraFit::FillVectorFit()
55a288e5 2417{
2418 //
3a0f6479 2419 // For the Fit functions fill the vector Fit
55a288e5 2420 //
2421
3a0f6479 2422 AliTRDFitInfo *fitInfo = new AliTRDFitInfo();
55a288e5 2423
3a0f6479 2424 Int_t ntotal = 1;
053767a4 2425 if (GetStack(fCountDet) == 2) {
3a0f6479 2426 ntotal = 1728;
55a288e5 2427 }
3a0f6479 2428 else {
2429 ntotal = 2304;
55a288e5 2430 }
2431
3a0f6479 2432 //printf("For the detector %d , ntotal %d and fCoefCH[0] %f\n",countdet,ntotal,fCoefCH[0]);
2433 Float_t *coef = new Float_t[ntotal];
2434 for (Int_t i = 0; i < ntotal; i++) {
2435 coef[i] = fCurrentCoefDetector[i];
55a288e5 2436 }
55a288e5 2437
3a0f6479 2438 Int_t detector = fCountDet;
2439 // Set
2440 fitInfo->SetCoef(coef);
2441 fitInfo->SetDetector(detector);
2442 fVectorFit.Add((TObject *) fitInfo);
55a288e5 2443
3a0f6479 2444 return kTRUE;
55a288e5 2445
55a288e5 2446}
55a288e5 2447//_____________________________________________________________________________
3a0f6479 2448Bool_t AliTRDCalibraFit::FillVectorFit2()
55a288e5 2449{
2450 //
3a0f6479 2451 // For the Fit functions fill the vector Fit
55a288e5 2452 //
2453
3a0f6479 2454 AliTRDFitInfo *fitInfo = new AliTRDFitInfo();
55a288e5 2455
2456 Int_t ntotal = 1;
053767a4 2457 if (GetStack(fCountDet) == 2) {
55a288e5 2458 ntotal = 1728;
2459 }
2460 else {
2461 ntotal = 2304;
2462 }
2463
2464 //printf("For the detector %d , ntotal %d and fCoefCH[0] %f\n",countdet,ntotal,fCoefCH[0]);
2465 Float_t *coef = new Float_t[ntotal];
2466 for (Int_t i = 0; i < ntotal; i++) {
3a0f6479 2467 coef[i] = fCurrentCoefDetector2[i];
55a288e5 2468 }
2469
3a0f6479 2470 Int_t detector = fCountDet;
55a288e5 2471 // Set
3a0f6479 2472 fitInfo->SetCoef(coef);
2473 fitInfo->SetDetector(detector);
2474 fVectorFit2.Add((TObject *) fitInfo);
55a288e5 2475
2476 return kTRUE;
2477
2478}
55a288e5 2479//____________Functions for initialising the AliTRDCalibraFit in the code_________
2480Bool_t AliTRDCalibraFit::InitFit(Int_t nbins, Int_t i)
2481{
2482 //
3a0f6479 2483 // Init the number of expected bins and fDect1[i] fDect2[i]
55a288e5 2484 //
2485
2486 gStyle->SetPalette(1);
2487 gStyle->SetOptStat(1111);
2488 gStyle->SetPadBorderMode(0);
2489 gStyle->SetCanvasColor(10);
2490 gStyle->SetPadLeftMargin(0.13);
2491 gStyle->SetPadRightMargin(0.01);
3a0f6479 2492
55a288e5 2493 // Mode groups of pads: the total number of bins!
3a0f6479 2494 CalculNumberOfBinsExpected(i);
55a288e5 2495
3a0f6479 2496 // Quick verification that we have the good pad calibration mode!
2497 if (fNumberOfBinsExpected != nbins) {
64942b85 2498 AliInfo(Form("It doesn't correspond to the mode of pad group calibration: expected %d and seen %d!",fNumberOfBinsExpected,nbins));
3a0f6479 2499 return kFALSE;
55a288e5 2500 }
3a0f6479 2501
55a288e5 2502 // Security for fDebug 3 and 4
3a0f6479 2503 if ((fDebugLevel >= 3) &&
55a288e5 2504 ((fDet[0] > 5) ||
2505 (fDet[1] > 4) ||
2506 (fDet[2] > 17))) {
2507 AliInfo("This detector doesn't exit!");
2508 return kFALSE;
2509 }
2510
3a0f6479 2511 // Determine fDet1 and fDet2 and set the fNfragZ and fNfragRphi for debug 3 and 4
2512 CalculDect1Dect2(i);
55a288e5 2513
3a0f6479 2514
2515 return kTRUE;
2516}
2517//____________Functions for initialising the AliTRDCalibraFit in the code_________
2518Bool_t AliTRDCalibraFit::InitFitCH()
2519{
2520 //
2521 // Init the fVectorFitCH for normalisation
2522 // Init the histo for debugging
2523 //
55a288e5 2524
3a0f6479 2525 gDirectory = gROOT;
2526
2527 fScaleFitFactor = 0.0;
2528 fCurrentCoefDetector = new Float_t[2304];
2529 for (Int_t k = 0; k < 2304; k++) {
2530 fCurrentCoefDetector[k] = 0.0;
55a288e5 2531 }
3a0f6479 2532 fVectorFit.SetName("gainfactorscoefficients");
55a288e5 2533
3a0f6479 2534 // fDebug == 0 nothing
2535 // fDebug == 1 and fFitVoir no histo
2536 if (fDebugLevel == 1) {
2537 if(!CheckFitVoir()) return kFALSE;
2538 }
2539 //Get the CalDet object
2540 if(fAccCDB){
2541 AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
2542 if (!cal) {
2543 AliInfo("Could not get calibDB");
2544 return kFALSE;
55a288e5 2545 }
3a0f6479 2546 if(fCalDet) delete fCalDet;
2547 fCalDet = new AliTRDCalDet(*(cal->GetGainFactorDet()));
55a288e5 2548 }
3a0f6479 2549 else{
2550 Float_t devalue = 1.0;
2551 if(fCalDet) delete fCalDet;
2552 fCalDet = new AliTRDCalDet("ChamberGainFactor","GainFactor (detector value)");
2553 for(Int_t k = 0; k < 540; k++){
2554 fCalDet->SetValue(k,devalue);
55a288e5 2555 }
3a0f6479 2556 }
2557 return kTRUE;
2558
2559}
2560//____________Functions for initialising the AliTRDCalibraFit in the code_________
2561Bool_t AliTRDCalibraFit::InitFitPH()
2562{
2563 //
2564 // Init the arrays of results
2565 // Init the histos for debugging
2566 //
55a288e5 2567
3a0f6479 2568 gDirectory = gROOT;
2569 fVectorFit.SetName("driftvelocitycoefficients");
2570 fVectorFit2.SetName("t0coefficients");
55a288e5 2571
3a0f6479 2572 fCurrentCoefDetector = new Float_t[2304];
2573 for (Int_t k = 0; k < 2304; k++) {
2574 fCurrentCoefDetector[k] = 0.0;
2575 }
55a288e5 2576
3a0f6479 2577 fCurrentCoefDetector2 = new Float_t[2304];
2578 for (Int_t k = 0; k < 2304; k++) {
2579 fCurrentCoefDetector2[k] = 0.0;
2580 }
2581
2582 //fDebug == 0 nothing
2583 // fDebug == 1 and fFitVoir no histo
2584 if (fDebugLevel == 1) {
2585 if(!CheckFitVoir()) return kFALSE;
2586 }
2587 //Get the CalDet object
2588 if(fAccCDB){
2589 AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
2590 if (!cal) {
2591 AliInfo("Could not get calibDB");
2592 return kFALSE;
55a288e5 2593 }
3a0f6479 2594 if(fCalDet) delete fCalDet;
2595 if(fCalDet2) delete fCalDet2;
2596 fCalDet = new AliTRDCalDet(*(cal->GetVdriftDet()));
2597 fCalDet2 = new AliTRDCalDet(*(cal->GetT0Det()));
2598 }
2599 else{
2600 Float_t devalue = 1.5;
2601 Float_t devalue2 = 0.0;
2602 if(fCalDet) delete fCalDet;
2603 if(fCalDet2) delete fCalDet2;
2604 fCalDet = new AliTRDCalDet("ChamberVdrift","TRD drift velocities (detector value)");
2605 fCalDet2 = new AliTRDCalDet("ChamberT0","T0 (detector value)");
2606 for(Int_t k = 0; k < 540; k++){
2607 fCalDet->SetValue(k,devalue);
2608 fCalDet2->SetValue(k,devalue2);
55a288e5 2609 }
55a288e5 2610 }
55a288e5 2611 return kTRUE;
3a0f6479 2612}
2613//____________Functions for initialising the AliTRDCalibraFit in the code_________
2614Bool_t AliTRDCalibraFit::InitFitPRF()
2615{
2616 //
2617 // Init the calibration mode (Nz, Nrphi), the histograms for
2618 // debugging the fit methods if fDebug > 0,
2619 //
55a288e5 2620
3a0f6479 2621 gDirectory = gROOT;
2622 fVectorFit.SetName("prfwidthcoefficients");
2623
2624 fCurrentCoefDetector = new Float_t[2304];
2625 for (Int_t k = 0; k < 2304; k++) {
2626 fCurrentCoefDetector[k] = 0.0;
2627 }
2628
2629 // fDebug == 0 nothing
2630 // fDebug == 1 and fFitVoir no histo
2631 if (fDebugLevel == 1) {
2632 if(!CheckFitVoir()) return kFALSE;
2633 }
2634 return kTRUE;
2635}
2636//____________Functions for initialising the AliTRDCalibraFit in the code_________
2637Bool_t AliTRDCalibraFit::InitFitLinearFitter()
2638{
2639 //
2640 // Init the fCalDet, fVectorFit fCurrentCoefDetector
2641 //
2642
2643 gDirectory = gROOT;
2644
2645 fCurrentCoefDetector = new Float_t[2304];
2646 fCurrentCoefDetector2 = new Float_t[2304];
2647 for (Int_t k = 0; k < 2304; k++) {
2648 fCurrentCoefDetector[k] = 0.0;
2649 fCurrentCoefDetector2[k] = 0.0;
2650 }
2651
2652 //printf("test0\n");
2653
2654 AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
2655 if (!cal) {
2656 AliInfo("Could not get calibDB");
2657 return kFALSE;
2658 }
2659
2660 //Get the CalDet object
2661 if(fAccCDB){
2662 if(fCalDet) delete fCalDet;
2663 if(fCalDet2) delete fCalDet2;
2664 fCalDet = new AliTRDCalDet(*(cal->GetVdriftDet()));
2665 //printf("test1\n");
2666 fCalDet2 = new AliTRDCalDet("lorentz angle tan","lorentz angle tan (detector value)");
2667 //printf("test2\n");
2668 for(Int_t k = 0; k < 540; k++){
a076fc2f 2669 fCalDet2->SetValue(k,AliTRDCommonParam::Instance()->GetOmegaTau(fCalDet->GetValue(k)));
3a0f6479 2670 }
2671 //printf("test3\n");
2672 }
2673 else{
2674 Float_t devalue = 1.5;
a076fc2f 2675 Float_t devalue2 = AliTRDCommonParam::Instance()->GetOmegaTau(1.5);
3a0f6479 2676 if(fCalDet) delete fCalDet;
2677 if(fCalDet2) delete fCalDet2;
2678 //printf("test1\n");
2679 fCalDet = new AliTRDCalDet("ChamberVdrift","TRD drift velocities (detector value)");
2680 fCalDet2 = new AliTRDCalDet("lorentz angle tan","lorentz angle tan (detector value)");
2681 //printf("test2\n");
2682 for(Int_t k = 0; k < 540; k++){
2683 fCalDet->SetValue(k,devalue);
2684 fCalDet2->SetValue(k,devalue2);
2685 }
2686 //printf("test3\n");
2687 }
2688 return kTRUE;
55a288e5 2689}
2690
2691//____________Functions for initialising the AliTRDCalibraFit in the code_________
2692void AliTRDCalibraFit::InitfCountDetAndfCount(Int_t i)
2693{
2694 //
2695 // Init the current detector where we are fCountDet and the
2696 // next fCount for the functions Fit...
2697 //
3a0f6479 2698
55a288e5 2699 // Loop on the Xbins of ch!!
3a0f6479 2700 fCountDet = -1; // Current detector
2701 fCount = 0; // To find the next detector
55a288e5 2702
2703 // If fDebug >= 3
3a0f6479 2704 if (fDebugLevel >= 3) {
55a288e5 2705 // Set countdet to the detector
3a0f6479 2706 fCountDet = AliTRDgeometry::GetDetector(fDet[0],fDet[1],fDet[2]);
55a288e5 2707 // Set counter to write at the end of the detector
3a0f6479 2708 fCount = fDect2;
2709 // Get the right calib objects
2710 SetCalROC(i);
2711 }
2712 if(fDebugLevel == 1) {
2713 fCountDet = 0;
2714 fCalibraMode->CalculXBins(fCountDet,i);
6aafa7ea 2715 if((fCalibraMode->GetNz(i)!=100) && (fCalibraMode->GetNrphi(i)!=100)){
2716 while(fCalibraMode->GetXbins(i) <=fFitVoir){
2717 fCountDet++;
2718 fCalibraMode->CalculXBins(fCountDet,i);
2719 //printf("GetXBins %d\n",fCalibraMode->GetXbins(i));
2720 }
2721 }
2722 else {
3a0f6479 2723 fCountDet++;
6aafa7ea 2724 }
3a0f6479 2725 fCount = fCalibraMode->GetXbins(i);
2726 fCountDet--;
2727 // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
053767a4 2728 fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),i);
2729 fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
2730 ,(Int_t) GetStack(fCountDet)
2731 ,(Int_t) GetSector(fCountDet),i);
55a288e5 2732 }
55a288e5 2733}
3a0f6479 2734//_______________________________________________________________________________
2735void AliTRDCalibraFit::CalculNumberOfBinsExpected(Int_t i)
2736{
2737 //
2738 // Calculate the number of bins expected (calibration groups)
2739 //
2740
2741 fNumberOfBinsExpected = 0;
64942b85 2742 // All
2743 if((fCalibraMode->GetNz(i) == 100) && (fCalibraMode->GetNrphi(i) == 100)){
2744 fNumberOfBinsExpected = 1;
2745 return;
2746 }
2747 // Per supermodule
2748 if((fCalibraMode->GetNz(i) == 10) && (fCalibraMode->GetNrphi(i) == 10)){
2749 fNumberOfBinsExpected = 18;
2750 return;
2751 }
2752 // More
3a0f6479 2753 fCalibraMode->ModePadCalibration(2,i);
2754 fCalibraMode->ModePadFragmentation(0,2,0,i);
2755 fCalibraMode->SetDetChamb2(i);
2756 if (fDebugLevel > 1) {
2757 AliInfo(Form("For the chamber 2: %d",fCalibraMode->GetDetChamb2(i)));
2758 }
2759 fNumberOfBinsExpected += 6 * 18 * fCalibraMode->GetDetChamb2(i);
2760 fCalibraMode->ModePadCalibration(0,i);
2761 fCalibraMode->ModePadFragmentation(0,0,0,i);
2762 fCalibraMode->SetDetChamb0(i);
2763 if (fDebugLevel > 1) {
2764 AliInfo(Form("For the other chamber 0: %d",fCalibraMode->GetDetChamb0(i)));
2765 }
2766 fNumberOfBinsExpected += 6 * 4 * 18 * fCalibraMode->GetDetChamb0(i);
2767
2768}
2769//_______________________________________________________________________________
2770void AliTRDCalibraFit::CalculDect1Dect2(Int_t i)
2771{
2772 //
2773 // Calculate the range of fits
2774 //
2775
2776 fDect1 = -1;
2777 fDect2 = -1;
2778 if (fDebugLevel == 1) {
2779 fDect1 = fFitVoir;
2780 fDect2 = fDect1 +1;
2781 }
2782 if ((fDebugLevel == 2) || (fDebugLevel == 0)) {
2783 fDect1 = 0;
2784 fDect2 = fNumberOfBinsExpected;
2785 }
2786 if (fDebugLevel >= 3) {
2787 fCountDet = AliTRDgeometry::GetDetector(fDet[0],fDet[1],fDet[2]);
2788 fCalibraMode->CalculXBins(fCountDet,i);
2789 fDect1 = fCalibraMode->GetXbins(i);
2790 // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
053767a4 2791 fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),i);
2792 fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
2793 ,(Int_t) GetStack(fCountDet)
2794 ,(Int_t) GetSector(fCountDet),i);
3a0f6479 2795 // Set for the next detector
2796 fDect2 = fDect1 + fCalibraMode->GetNfragZ(i)*fCalibraMode->GetNfragRphi(i);
2797 }
2798}
2799//_______________________________________________________________________________
2800Bool_t AliTRDCalibraFit::CheckFitVoir()
2801{
2802 //
2803 // Check if fFitVoir is in the range
2804 //
2805
2806 if (fFitVoir < fNumberOfBinsExpected) {
2807 AliInfo(Form("We will see the fit of the object %d",fFitVoir));
2808 }
2809 else {
2810 AliInfo("fFitVoir is out of range of the histo!");
2811 return kFALSE;
2812 }
2813 return kTRUE;
2814}
55a288e5 2815//____________Functions for initialising the AliTRDCalibraFit in the code_________
2816void AliTRDCalibraFit::UpdatefCountDetAndfCount(Int_t idect, Int_t i)
2817{
2818 //
2819 // See if we are in a new detector and update the
2820 // variables fNfragZ and fNfragRphi if yes
3a0f6479 2821 // Will never happen for only one detector (3 and 4)
2822 // Doesn't matter for 2
2823 //
2824 if (fCount == idect) {
64942b85 2825 // On en est au detector (or first detector in the group)
2826 fCountDet += 1;
2827 AliDebug(2,Form("We are at the detector %d\n",fCountDet));
2828 // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
2829 fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),i);
2830 fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
053767a4 2831 ,(Int_t) GetStack(fCountDet)
2832 ,(Int_t) GetSector(fCountDet),i);
64942b85 2833 // Set for the next detector
2834 fCount += fCalibraMode->GetNfragZ(i)*fCalibraMode->GetNfragRphi(i);
2835 // calib objects
2836 SetCalROC(i);
2837 }
55a288e5 2838}
55a288e5 2839//____________Functions for initialising the AliTRDCalibraFit in the code_________
2840void AliTRDCalibraFit::ReconstructFitRowMinRowMax(Int_t idect, Int_t i)
2841{
2842 //
2843 // Reconstruct the min pad row, max pad row, min pad col and
2844 // max pad col of the calibration group for the Fit functions
64942b85 2845 // idect is the calibration group inside the detector
55a288e5 2846 //
3a0f6479 2847 if (fDebugLevel != 1) {
2848 fCalibraMode->ReconstructionRowPadGroup((Int_t) (idect-(fCount-(fCalibraMode->GetNfragZ(i)*fCalibraMode->GetNfragRphi(i)))),i);
55a288e5 2849 }
64942b85 2850 AliDebug(2,Form("AliTRDCalibraFit::ReconstructFitRowMinRowMax: the local calibration group is %d",idect-(fCount-(fCalibraMode->GetNfragZ(i)*fCalibraMode->GetNfragRphi(i)))));
2851 AliDebug(2,Form("AliTRDCalibraFit::ReconstructFitRowMinRowMax: the number of group per detector is %d",fCalibraMode->GetNfragZ(i)*fCalibraMode->GetNfragRphi(i)));
55a288e5 2852}
55a288e5 2853//____________Functions for initialising the AliTRDCalibraFit in the code_________
3a0f6479 2854Bool_t AliTRDCalibraFit::NotEnoughStatisticCH(Int_t idect)
55a288e5 2855{
2856 //
2857 // For the case where there are not enough entries in the histograms
2858 // of the calibration group, the value present in the choosen database
2859 // will be put. A negativ sign enables to know that a fit was not possible.
2860 //
3a0f6479 2861
2862 if (fDebugLevel == 1) {
55a288e5 2863 AliInfo("The element has not enough statistic to be fitted");
2864 }
64942b85 2865 else if (fNbDet > 0){
2866 Int_t firstdetector = fCountDet;
2867 Int_t lastdetector = fCountDet+fNbDet;
2868 AliInfo(Form("The element %d containing the detectors %d to %d has not enough statistic to be fitted"
2869 ,idect,firstdetector,lastdetector));
2870 // loop over detectors
2871 for(Int_t det = firstdetector; det < lastdetector; det++){
2872
2873 //Set the calibration object again
2874 fCountDet = det;
2875 SetCalROC(0);
2876
2877 // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
2878 // Put them at 1
2879 fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),0);
2880 fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
2881 ,(Int_t) GetStack(fCountDet)
2882 ,(Int_t) GetSector(fCountDet),0);
2883 // Reconstruct row min row max
2884 ReconstructFitRowMinRowMax(idect,0);
2885
2886 // Calcul the coef from the database choosen for the detector
2887 CalculChargeCoefMean(kFALSE);
2888
2889 //stack 2, not stack 2
2890 Int_t factor = 0;
2891 if(GetStack(fCountDet) == 2) factor = 12;
2892 else factor = 16;
2893
2894 // Fill the fCurrentCoefDetector with negative value to say: not fitted
2895 for (Int_t k = fCalibraMode->GetRowMin(0); k < fCalibraMode->GetRowMax(0); k++) {
2896 for (Int_t j = fCalibraMode->GetColMin(0); j < fCalibraMode->GetColMax(0); j++) {
2897 fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
2898 }
2899 }
2900
2901 //Put default value negative
2902 fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
2903 fCurrentCoefE = 0.0;
2904
2905 // Fill the stuff
2906 FillVectorFit();
2907 // Debug
2908 if(fDebugLevel > 1){
2909
2910 if ( !fDebugStreamer ) {
2911 //debug stream
2912 TDirectory *backup = gDirectory;
2913 fDebugStreamer = new TTreeSRedirector("TRDDebugFitCH.root");
2914 if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
2915 }
2916
2917 Int_t detector = fCountDet;
2918 Int_t caligroup = idect;
2919 Short_t rowmin = fCalibraMode->GetRowMin(0);
2920 Short_t rowmax = fCalibraMode->GetRowMax(0);
2921 Short_t colmin = fCalibraMode->GetColMin(0);
2922 Short_t colmax = fCalibraMode->GetColMax(0);
2923 Float_t gf = fCurrentCoef[0];
2924 Float_t gfs = fCurrentCoef[1];
2925 Float_t gfE = fCurrentCoefE;
2926
2927 (*fDebugStreamer) << "FillFillCH" <<
2928 "detector=" << detector <<
2929 "caligroup=" << caligroup <<
2930 "rowmin=" << rowmin <<
2931 "rowmax=" << rowmax <<
2932 "colmin=" << colmin <<
2933 "colmax=" << colmax <<
2934 "gf=" << gf <<
2935 "gfs=" << gfs <<
2936 "gfE=" << gfE <<
2937 "\n";
2938
2939 }
2940 // Reset
2941 for (Int_t k = 0; k < 2304; k++) {
2942 fCurrentCoefDetector[k] = 0.0;
2943 }
2944
2945 }// loop detector
2946 AliDebug(2,Form("Check the count now: fCountDet %d",fCountDet));
2947 }
3a0f6479 2948 else {
55a288e5 2949
3a0f6479 2950 AliInfo(Form("The element %d in this detector %d has not enough statistic to be fitted"
2951 ,idect-(fCount-(fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0))),fCountDet));
55a288e5 2952
2953 // Calcul the coef from the database choosen
3a0f6479 2954 CalculChargeCoefMean(kFALSE);
2955
053767a4 2956 //stack 2, not stack 2
3a0f6479 2957 Int_t factor = 0;
053767a4 2958 if(GetStack(fCountDet) == 2) factor = 12;
3a0f6479 2959 else factor = 16;
55a288e5 2960
3a0f6479 2961 // Fill the fCurrentCoefDetector with negative value to say: not fitted
55a288e5 2962 for (Int_t k = fCalibraMode->GetRowMin(0); k < fCalibraMode->GetRowMax(0); k++) {
2963 for (Int_t j = fCalibraMode->GetColMin(0); j < fCalibraMode->GetColMax(0); j++) {
3a0f6479 2964 fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
55a288e5 2965 }
55a288e5 2966 }
2967
3a0f6479 2968 //Put default value negative
2969 fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
2970 fCurrentCoefE = 0.0;
2971
2972 FillFillCH(idect);
55a288e5 2973 }
2974
2975 return kTRUE;
55a288e5 2976}
2977
3a0f6479 2978
55a288e5 2979//____________Functions for initialising the AliTRDCalibraFit in the code_________
64942b85 2980Bool_t AliTRDCalibraFit::NotEnoughStatisticPH(Int_t idect,Double_t nentries)
55a288e5 2981{
2982 //
3a0f6479 2983 // For the case where there are not enough entries in the histograms
2984 // of the calibration group, the value present in the choosen database
2985 // will be put. A negativ sign enables to know that a fit was not possible.
55a288e5 2986 //
3a0f6479 2987 if (fDebugLevel == 1) {
2988 AliInfo("The element has not enough statistic to be fitted");
55a288e5 2989 }
64942b85 2990 else if (fNbDet > 0) {
2991
2992 Int_t firstdetector = fCountDet;
2993 Int_t lastdetector = fCountDet+fNbDet;
2994 AliInfo(Form("The element %d containing the detectors %d to %d has not enough statistic to be fitted"
2995 ,idect,firstdetector,lastdetector));
2996 // loop over detectors
2997 for(Int_t det = firstdetector; det < lastdetector; det++){
2998
2999 //Set the calibration object again
3000 fCountDet = det;
3001 SetCalROC(1);
3002
3003 // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
3004 // Put them at 1
3005 fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),1);
3006 fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
3007 ,(Int_t) GetStack(fCountDet)
3008 ,(Int_t) GetSector(fCountDet),1);
3009 // Reconstruct row min row max
3010 ReconstructFitRowMinRowMax(idect,1);
3011
3012 // Calcul the coef from the database choosen for the detector
3013 CalculVdriftCoefMean();
3014 CalculT0CoefMean();
3015
3016 //stack 2, not stack 2
3017 Int_t factor = 0;
3018 if(GetStack(fCountDet) == 2) factor = 12;
3019 else factor = 16;
3020
3021 // Fill the fCurrentCoefDetector with negative value to say: not fitted
3022 for (Int_t k = fCalibraMode->GetRowMin(1); k < fCalibraMode->GetRowMax(1); k++) {
3023 for (Int_t j = fCalibraMode->GetColMin(1); j < fCalibraMode->GetColMax(1); j++) {
3024 fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
3025 fCurrentCoefDetector2[(Int_t)(j*factor+k)] = fCurrentCoef2[1] + 100.0;
3026 }
3027 }
3028
3029 //Put default value negative
3030 fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
3031 fCurrentCoefE = 0.0;
3032 fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
3033 fCurrentCoefE2 = 0.0;
3034
3035 // Fill the stuff
3036 FillVectorFit();
3037 FillVectorFit2();
3038 // Debug
3039 if(fDebugLevel > 1){
3040
3041 if ( !fDebugStreamer ) {
3042 //debug stream
3043 TDirectory *backup = gDirectory;
3044 fDebugStreamer = new TTreeSRedirector("TRDDebugFitPH.root");
3045 if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
3046 }
3047
3048
3049 Int_t detector = fCountDet;
3050 Int_t caligroup = idect;
3051 Short_t rowmin = fCalibraMode->GetRowMin(1);
3052 Short_t rowmax = fCalibraMode->GetRowMax(1);
3053 Short_t colmin = fCalibraMode->GetColMin(1);
3054 Short_t colmax = fCalibraMode->GetColMax(1);
3055 Float_t vf = fCurrentCoef[0];
3056 Float_t vs = fCurrentCoef[1];
3057 Float_t vfE = fCurrentCoefE;
3058 Float_t t0f = fCurrentCoef2[0];
3059 Float_t t0s = fCurrentCoef2[1];
3060 Float_t t0E = fCurrentCoefE2;
3061
3062
3063
3064 (* fDebugStreamer) << "FillFillPH"<<
3065 "detector="<<detector<<
3066 "nentries="<<nentries<<
3067 "caligroup="<<caligroup<<
3068 "rowmin="<<rowmin<<
3069 "rowmax="<<rowmax<<
3070 "colmin="<<colmin<<
3071 "colmax="<<colmax<<
3072 "vf="<<vf<<
3073 "vs="<<vs<<
3074 "vfE="<<vfE<<
3075 "t0f="<<t0f<<
3076 "t0s="<<t0s<<
3077 "t0E="<<t0E<<
3078 "\n";
3079 }
3080 // Reset
3081 for (Int_t k = 0; k < 2304; k++) {
3082 fCurrentCoefDetector[k] = 0.0;
3083 fCurrentCoefDetector2[k] = 0.0;
3084 }
3085
3086 }// loop detector
3087 AliDebug(2,Form("Check the count now: fCountDet %d",fCountDet));
3088 }
3a0f6479 3089 else {
55a288e5 3090
3a0f6479 3091 AliInfo(Form("The element %d in this detector %d has not enough statistic to be fitted"
3092 ,idect-(fCount-(fCalibraMode->GetNfragZ(1)*fCalibraMode->GetNfragRphi(1))),fCountDet));
55a288e5 3093
3a0f6479 3094 CalculVdriftCoefMean();
3095 CalculT0CoefMean();
3096
053767a4 3097 //stack 2 and not stack 2
3a0f6479 3098 Int_t factor = 0;
053767a4 3099 if(GetStack(fCountDet) == 2) factor = 12;
3a0f6479 3100 else factor = 16;
55a288e5 3101
55a288e5 3102
3a0f6479 3103 // Fill the fCurrentCoefDetector 2
55a288e5 3104 for (Int_t k = fCalibraMode->GetRowMin(1); k < fCalibraMode->GetRowMax(1); k++) {
3105 for (Int_t j = fCalibraMode->GetColMin(1); j < fCalibraMode->GetColMax(1); j++) {
3a0f6479 3106 fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
64942b85 3107 fCurrentCoefDetector2[(Int_t)(j*factor+k)] = fCurrentCoef2[1] + 100.0;
55a288e5 3108 }
55a288e5 3109 }
3110
3a0f6479 3111 // Put the default value
3112 fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
3113 fCurrentCoefE = 0.0;
64942b85 3114 fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
3a0f6479 3115 fCurrentCoefE2 = 0.0;
3116
64942b85 3117 FillFillPH(idect,nentries);
3a0f6479 3118
55a288e5 3119 }
3a0f6479 3120
55a288e5 3121 return kTRUE;
64942b85 3122
55a288e5 3123}
3124
3a0f6479 3125
55a288e5 3126//____________Functions for initialising the AliTRDCalibraFit in the code_________
3a0f6479 3127Bool_t AliTRDCalibraFit::NotEnoughStatisticPRF(Int_t idect)
55a288e5 3128{
3129 //
3a0f6479 3130 // For the case where there are not enough entries in the histograms
3131 // of the calibration group, the value present in the choosen database
3132 // will be put. A negativ sign enables to know that a fit was not possible.
55a288e5 3133 //
3a0f6479 3134
3135 if (fDebugLevel == 1) {
3136 AliInfo("The element has not enough statistic to be fitted");
55a288e5 3137 }
64942b85 3138 else if (fNbDet > 0){
3139
3140 Int_t firstdetector = fCountDet;
3141 Int_t lastdetector = fCountDet+fNbDet;
3142 AliInfo(Form("The element %d containing the detectors %d to %d has not enough statistic to be fitted"
3143 ,idect,firstdetector,lastdetector));
3144
3145 // loop over detectors
3146 for(Int_t det = firstdetector; det < lastdetector; det++){
3147
3148 //Set the calibration object again
3149 fCountDet = det;
3150 SetCalROC(2);
3151
3152 // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
3153 // Put them at 1
3154 fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),2);
3155 fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
3156 ,(Int_t) GetStack(fCountDet)
3157 ,(Int_t) GetSector(fCountDet),2);
3158 // Reconstruct row min row max
3159 ReconstructFitRowMinRowMax(idect,2);
3160
3161 // Calcul the coef from the database choosen for the detector
3162 CalculPRFCoefMean();
3163
3164 //stack 2, not stack 2
3165 Int_t factor = 0;
3166 if(GetStack(fCountDet) == 2) factor = 12;
3167 else factor = 16;
3168
3169 // Fill the fCurrentCoefDetector with negative value to say: not fitted
3170 for (Int_t k = fCalibraMode->GetRowMin(2); k < fCalibraMode->GetRowMax(2); k++) {
3171 for (Int_t j = fCalibraMode->GetColMin(2); j < fCalibraMode->GetColMax(2); j++) {
3172 fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
3173 }
3174 }
3175
3176 //Put default value negative
3177 fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
3178 fCurrentCoefE = 0.0;
3179
3180 // Fill the stuff
3181 FillVectorFit();
3182 // Debug
3183 if(fDebugLevel > 1){
3184
3185 if ( !fDebugStreamer ) {
3186 //debug stream
3187 TDirectory *backup = gDirectory;
3188 fDebugStreamer = new TTreeSRedirector("TRDDebugFitPRF.root");
3189 if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
3190 }
3191
3192 Int_t detector = fCountDet;
3193 Int_t layer = GetLayer(fCountDet);
3194 Int_t caligroup = idect;
3195 Short_t rowmin = fCalibraMode->GetRowMin(2);
3196 Short_t rowmax = fCalibraMode->GetRowMax(2);
3197 Short_t colmin = fCalibraMode->GetColMin(2);
3198 Short_t colmax = fCalibraMode->GetColMax(2);
3199 Float_t widf = fCurrentCoef[0];
3200 Float_t wids = fCurrentCoef[1];
3201 Float_t widfE = fCurrentCoefE;
3202
3203 (* fDebugStreamer) << "FillFillPRF"<<
3204 "detector="<<detector<<
3205 "layer="<<layer<<
3206 "caligroup="<<caligroup<<
3207 "rowmin="<<rowmin<<
3208 "rowmax="<<rowmax<<
3209 "colmin="<<colmin<<
3210 "colmax="<<colmax<<
3211 "widf="<<widf<<
3212 "wids="<<wids<<
3213 "widfE="<<widfE<<
3214 "\n";
3215 }
3216 // Reset
3217 for (Int_t k = 0; k < 2304; k++) {
3218 fCurrentCoefDetector[k] = 0.0;
3219 }
3220
3221 }// loop detector
3222 AliDebug(2,Form("Check the count now: fCountDet %d",fCountDet));