]> git.uio.no Git - u/mrichter/AliRoot.git/blame - TOF/AliTOFcalib.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Test suite for event-embedding (Adam).
[u/mrichter/AliRoot.git] / TOF / AliTOFcalib.cxx
CommitLineData
6dc9348d 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
762446e0 16/*
7fffa85b 17$Log: AliTOFcalib.cxx,v $
18Revision 1.21 2007/11/02 15:41:49 hristov
19Provide return value if the function is not void
20
52be7fb0 21Revision 1.20 2007/10/26 15:13:50 zampolli
22Using a TChain instead of a TTree
23
296591ad 24Revision 1.19 2007/10/23 15:27:38 zampolli
25Rearrangement of Calibration objects for simulation
26
a7e9db2a 27Revision 1.16 2007/10/08 10:13:26 zampolli
28First Run and Last Run members added, infinite validity of calib obj implemented.
29
0cb9d099 30Revision 1.15 2007/10/04 13:23:28 zampolli
31Updates to handle functionalities in TOF online/offline calibration according to the latest schema
32
0a749fa5 33Revision 1.14 2007/06/06 16:26:30 arcelli
34remove fall-back call to local CDB storage
35
03705065 36Revision 1.13 2007/04/20 13:59:40 arcelli
37make protections agains failed retrieval of the CDB object in a proper way
38
7a4f634e 39Revision 1.12 2007/03/23 11:31:16 arcelli
40CDB Entry for TOF Reconstruction Parameters
41
7037bd93 42Revision 1.11 2007/02/28 18:08:26 arcelli
43Add protection against failed retrieval of the CDB cal object
44
1b20c168 45Revision 1.10 2006/08/22 13:30:49 arcelli
46removal of effective c++ warnings (C.Zampolli)
47
655e379f 48Revision 1.9 2006/04/20 22:30:50 hristov
49Coding conventions (Annalisa)
50
0e46b9ae 51Revision 1.8 2006/04/16 22:29:05 hristov
52Coding conventions (Annalisa)
53
7aeeaf38 54Revision 1.7 2006/04/16 20:12:46 hristov
55Removing memory leak in case of cached CDB entries
56
85fc78e3 57Revision 1.6 2006/04/11 15:28:32 hristov
58Checks on cache status before deleting calibration objects (A.Colla)
59
5eaae242 60Revision 1.5 2006/04/05 08:35:38 hristov
61Coding conventions (S.Arcelli, C.Zampolli)
62
340693af 63Revision 1.4 2006/03/31 11:26:46 arcelli
64 changing CDB Ids according to standard convention
65
28dd10b6 66Revision 1.3 2006/03/28 14:57:02 arcelli
67updates to handle new V5 geometry & some re-arrangements
68
d4ad0d6b 69Revision 1.2 2006/02/13 17:22:26 arcelli
70just Fixing Log info
71
762446e0 72Revision 1.1 2006/02/13 16:10:48 arcelli
73Add classes for TOF Calibration (C.Zampolli)
74
6dc9348d 75author: Chiara Zampolli, zampolli@bo.infn.it
762446e0 76*/
6dc9348d 77
78///////////////////////////////////////////////////////////////////////////////
79// //
80// class for TOF calibration //
81// //
82///////////////////////////////////////////////////////////////////////////////
83
6dc9348d 84#include "TF1.h"
0e46b9ae 85#include "TFile.h"
6dc9348d 86#include "TH1F.h"
87#include "TH2F.h"
5c7c93fa 88//#include "TList.h"
89//#include "TROOT.h"
90//#include "TStyle.h"
0a749fa5 91#include "TTree.h"
296591ad 92#include "TChain.h"
0a749fa5 93#include "TProfile.h"
94#include "TGrid.h"
5c7c93fa 95#include "TMath.h"
0e46b9ae 96
97#include "AliCDBEntry.h"
0cb9d099 98#include "AliCDBRunRange.h"
0e46b9ae 99#include "AliCDBId.h"
6dc9348d 100#include "AliCDBManager.h"
0a749fa5 101#include "AliCDBStorage.h"
6dc9348d 102#include "AliCDBMetaData.h"
5c7c93fa 103//#include "AliESDtrack.h"
104//#include "AliESD.h"
0e46b9ae 105#include "AliLog.h"
106
0e46b9ae 107#include "AliTOFcalib.h"
0a749fa5 108#include "AliTOFChannelOnline.h"
7fffa85b 109#include "AliTOFChannelOnlineStatus.h"
0a749fa5 110#include "AliTOFChannelOffline.h"
0e46b9ae 111#include "AliTOFGeometry.h"
7037bd93 112#include "AliTOFRecoParam.h"
6dc9348d 113
5c7c93fa 114class TROOT;
115class TStyle;
116
6dc9348d 117extern TROOT *gROOT;
118extern TStyle *gStyle;
119
120ClassImp(AliTOFcalib)
121
6dc9348d 122//_______________________________________________________________________
655e379f 123AliTOFcalib::AliTOFcalib():
124 TTask("AliTOFcalib",""),
125 fNChannels(-1),
0a749fa5 126 fTOFCalOnline(0x0),
7fffa85b 127 fTOFCalOnlinePulser(0x0),
128 fTOFCalOnlineNoise(0x0),
129 fTOFCalOnlineHW(0x0),
0a749fa5 130 fTOFCalOffline(0x0),
0a749fa5 131 fTOFSimToT(0x0),
132 fkValidity(0x0),
133 fTree(0x0),
296591ad 134 fChain(0x0),
0cb9d099 135 fNruns(0),
136 fFirstRun(0),
137 fLastRun(AliCDBRunRange::Infinity())
655e379f 138{
340693af 139 //TOF Calibration Class ctor
0a749fa5 140 fNChannels = AliTOFGeometry::NSectors()*(2*(AliTOFGeometry::NStripC()+AliTOFGeometry::NStripB())+AliTOFGeometry::NStripA())*AliTOFGeometry::NpadZ()*AliTOFGeometry::NpadX();
6dc9348d 141}
142//____________________________________________________________________________
143
655e379f 144AliTOFcalib::AliTOFcalib(const AliTOFcalib & calib):
145 TTask("AliTOFcalib",""),
0a749fa5 146 fNChannels(calib.fNChannels),
147 fTOFCalOnline(0x0),
7fffa85b 148 fTOFCalOnlinePulser(0x0),
149 fTOFCalOnlineNoise(0x0),
150 fTOFCalOnlineHW(0x0),
0a749fa5 151 fTOFCalOffline(0x0),
0a749fa5 152 fTOFSimToT(calib.fTOFSimToT),
153 fkValidity(calib.fkValidity),
154 fTree(calib.fTree),
296591ad 155 fChain(calib.fChain),
0cb9d099 156 fNruns(calib.fNruns),
157 fFirstRun(calib.fFirstRun),
158 fLastRun(calib.fLastRun)
6dc9348d 159{
340693af 160 //TOF Calibration Class copy ctor
0a749fa5 161 for (Int_t iarray = 0; iarray<fNChannels; iarray++){
162 AliTOFChannelOnline * calChOnline = (AliTOFChannelOnline*)calib.fTOFCalOnline->At(iarray);
7fffa85b 163 AliTOFChannelOnlineStatus * calChOnlineStPulser = (AliTOFChannelOnlineStatus*)calib.fTOFCalOnlinePulser->At(iarray);
164 AliTOFChannelOnlineStatus * calChOnlineStNoise = (AliTOFChannelOnlineStatus*)calib.fTOFCalOnlineNoise->At(iarray);
165 AliTOFChannelOnlineStatus * calChOnlineStHW = (AliTOFChannelOnlineStatus*)calib.fTOFCalOnlineHW->At(iarray);
0a749fa5 166 AliTOFChannelOffline * calChOffline = (AliTOFChannelOffline*)calib.fTOFCalOffline->At(iarray);
167 fTOFCalOnline->AddAt(calChOnline,iarray);
7fffa85b 168 fTOFCalOnlinePulser->AddAt(calChOnlineStPulser,iarray);
169 fTOFCalOnlineNoise->AddAt(calChOnlineStNoise,iarray);
170 fTOFCalOnlineHW->AddAt(calChOnlineStHW,iarray);
0a749fa5 171 fTOFCalOffline->AddAt(calChOffline,iarray);
172
0a749fa5 173 }
6dc9348d 174}
175
176//____________________________________________________________________________
7aeeaf38 177
178AliTOFcalib& AliTOFcalib::operator=(const AliTOFcalib &calib)
179{
180 //TOF Calibration Class assignment operator
7aeeaf38 181 this->fNChannels = calib.fNChannels;
0a749fa5 182 this->fTOFSimToT = calib.fTOFSimToT;
183 this->fkValidity = calib.fkValidity;
184 this->fTree = calib.fTree;
296591ad 185 this->fChain = calib.fChain;
0a749fa5 186 this->fNruns = calib.fNruns;
0cb9d099 187 this->fFirstRun = calib.fFirstRun;
188 this->fLastRun = calib.fLastRun;
0a749fa5 189 for (Int_t iarray = 0; iarray<fNChannels; iarray++){
190 AliTOFChannelOnline * calChOnline = (AliTOFChannelOnline*)calib.fTOFCalOnline->At(iarray);
191 AliTOFChannelOffline * calChOffline = (AliTOFChannelOffline*)calib.fTOFCalOffline->At(iarray);
7fffa85b 192 AliTOFChannelOnlineStatus * calChOnlineStPulser = (AliTOFChannelOnlineStatus*)calib.fTOFCalOnlinePulser->At(iarray);
193 AliTOFChannelOnlineStatus * calChOnlineStNoise = (AliTOFChannelOnlineStatus*)calib.fTOFCalOnlineNoise->At(iarray);
194 AliTOFChannelOnlineStatus * calChOnlineStHW = (AliTOFChannelOnlineStatus*)calib.fTOFCalOnlineHW->At(iarray);
0a749fa5 195 this->fTOFCalOnline->AddAt(calChOnline,iarray);
7fffa85b 196 this->fTOFCalOnlinePulser->AddAt(calChOnlineStPulser,iarray);
197 this->fTOFCalOnlineNoise->AddAt(calChOnlineStNoise,iarray);
198 this->fTOFCalOnlineHW->AddAt(calChOnlineStHW,iarray);
0a749fa5 199 this->fTOFCalOffline->AddAt(calChOffline,iarray);
0a749fa5 200 }
7aeeaf38 201 return *this;
202}
203
204//____________________________________________________________________________
6dc9348d 205
206AliTOFcalib::~AliTOFcalib()
207{
340693af 208 //TOF Calibration Class dtor
5eaae242 209 if(!(AliCDBManager::Instance()->GetCacheFlag())){ // CDB objects must NOT be deleted if cache is active!
0a749fa5 210 if (fTOFCalOnline){
0a749fa5 211 delete fTOFCalOnline;
6dc9348d 212 }
7fffa85b 213 if (fTOFCalOnlinePulser){
214 delete fTOFCalOnlinePulser;
215 }
216 if (fTOFCalOnlineNoise){
217 delete fTOFCalOnlineNoise;
218 }
219 if (fTOFCalOnlineHW){
220 delete fTOFCalOnlineHW;
221 }
0a749fa5 222 if (fTOFCalOffline){
0a749fa5 223 delete fTOFCalOffline;
6dc9348d 224 }
6dc9348d 225 }
0a749fa5 226 if (fTree!=0x0) delete fTree;
296591ad 227 if (fChain!=0x0) delete fChain;
6dc9348d 228}
229//_____________________________________________________________________________
0a749fa5 230void AliTOFcalib::CreateCalArrays(){
6dc9348d 231
0a749fa5 232 // creating arrays for online/offline calibration objs
6dc9348d 233
0a749fa5 234 fTOFCalOnline = new TObjArray(fNChannels);
7fffa85b 235 fTOFCalOnlinePulser = new TObjArray(fNChannels);
236 fTOFCalOnlineNoise = new TObjArray(fNChannels);
237 fTOFCalOnlineHW = new TObjArray(fNChannels);
0a749fa5 238 fTOFCalOffline = new TObjArray(fNChannels);
239 fTOFCalOnline->SetOwner();
7fffa85b 240 fTOFCalOnlinePulser->SetOwner();
241 fTOFCalOnlineNoise->SetOwner();
242 fTOFCalOnlineHW->SetOwner();
0a749fa5 243 fTOFCalOffline->SetOwner();
244 for (Int_t iarray = 0; iarray<fNChannels; iarray++){
245 AliTOFChannelOnline * calChOnline = new AliTOFChannelOnline();
7fffa85b 246 AliTOFChannelOnlineStatus * calChOnlineStPulser = new AliTOFChannelOnlineStatus();
247 AliTOFChannelOnlineStatus * calChOnlineStNoise = new AliTOFChannelOnlineStatus();
248 AliTOFChannelOnlineStatus * calChOnlineStHW = new AliTOFChannelOnlineStatus();
0a749fa5 249 AliTOFChannelOffline * calChOffline = new AliTOFChannelOffline();
250 fTOFCalOnline->AddAt(calChOnline,iarray);
7fffa85b 251 fTOFCalOnlinePulser->AddAt(calChOnlineStPulser,iarray);
252 fTOFCalOnlineNoise->AddAt(calChOnlineStNoise,iarray);
253 fTOFCalOnlineHW->AddAt(calChOnlineStHW,iarray);
0a749fa5 254 fTOFCalOffline->AddAt(calChOffline,iarray);
6dc9348d 255 }
256}
257//_____________________________________________________________________________
0a749fa5 258void AliTOFcalib::WriteParOnlineOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun)
340693af 259{
260 //Write calibration parameters to the CDB
0cb9d099 261 SetFirstRun(minrun);
262 SetLastRun(maxrun);
6dc9348d 263 AliCDBManager *man = AliCDBManager::Instance();
a7e9db2a 264 Char_t *sel1 = "ParOnline" ; // to be consistent with TOFPreprocessor
d4ad0d6b 265 Char_t out[100];
266 sprintf(out,"%s/%s",sel,sel1);
0cb9d099 267 AliDebug(2,Form("Writing TOF online calib obj on CDB with run range [%i, %i] ",fFirstRun,fLastRun));
268 AliCDBId id(out,fFirstRun,fLastRun);
269 AliCDBMetaData *md = new AliCDBMetaData();
270 md->SetResponsible("Chiara Zampolli");
271 if (!fTOFCalOnline) {
272 // deve uscire!!
273 }
274 man->Put(fTOFCalOnline,id,md);
275 delete md;
276}
277//_____________________________________________________________________________
7fffa85b 278void AliTOFcalib::WriteParOnlinePulserOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun)
279{
280 //Write calibration parameters from pulser to the CDB
281 SetFirstRun(minrun);
282 SetLastRun(maxrun);
283 AliCDBManager *man = AliCDBManager::Instance();
284 Char_t *sel1 = "Pulser" ; // to be consistent with TOFPreprocessor
285 Char_t out[100];
286 sprintf(out,"%s/%s",sel,sel1);
287 AliDebug(2,Form("Writing TOF online calib obj from pulser on CDB with run range [%i, %i] ",fFirstRun,fLastRun));
288 AliCDBId id(out,fFirstRun,fLastRun);
289 AliCDBMetaData *md = new AliCDBMetaData();
290 md->SetResponsible("Chiara Zampolli");
291 if (!fTOFCalOnlinePulser) {
292 // deve uscire!!
293 }
294 man->Put(fTOFCalOnlinePulser,id,md);
295 delete md;
296}
297//_____________________________________________________________________________
298void AliTOFcalib::WriteParOnlineNoiseOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun)
299{
300 //Write calibration parameters from noise to the CDB
301 SetFirstRun(minrun);
302 SetLastRun(maxrun);
303 AliCDBManager *man = AliCDBManager::Instance();
304 Char_t *sel1 = "Noise" ; // to be consistent with TOFPreprocessor
305 Char_t out[100];
306 sprintf(out,"%s/%s",sel,sel1);
307 AliDebug(2,Form("Writing TOF online calib obj from noise on CDB with run range [%i, %i] ",fFirstRun,fLastRun));
308 AliCDBId id(out,fFirstRun,fLastRun);
309 AliCDBMetaData *md = new AliCDBMetaData();
310 md->SetResponsible("Chiara Zampolli");
311 if (!fTOFCalOnlineNoise) {
312 // deve uscire!!
313 }
314 man->Put(fTOFCalOnlineNoise,id,md);
315 delete md;
316}
317//_____________________________________________________________________________
318void AliTOFcalib::WriteParOnlineHWOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun)
319{
320 //Write calibration parameters from hardware to the CDB
321 SetFirstRun(minrun);
322 SetLastRun(maxrun);
323 AliCDBManager *man = AliCDBManager::Instance();
324 Char_t *sel1 = "HW" ; // to be consistent with TOFPreprocessor
325 Char_t out[100];
326 sprintf(out,"%s/%s",sel,sel1);
327 AliDebug(2,Form("Writing TOF online calib obj from hardware on CDB with run range [%i, %i] ",fFirstRun,fLastRun));
328 AliCDBId id(out,fFirstRun,fLastRun);
329 AliCDBMetaData *md = new AliCDBMetaData();
330 md->SetResponsible("Chiara Zampolli");
331 if (!fTOFCalOnlineHW) {
332 // deve uscire!!
333 }
334 man->Put(fTOFCalOnlineHW,id,md);
335 delete md;
336}
337//_____________________________________________________________________________
0cb9d099 338
339void AliTOFcalib::WriteParOnlineOnCDB(Char_t *sel)
340{
341 //Write calibration parameters to the CDB with infinite validity
342 AliCDBManager *man = AliCDBManager::Instance();
a7e9db2a 343 Char_t *sel1 = "ParOnline" ; // to be consistent with TOFPreprocessor
0cb9d099 344 Char_t out[100];
345 sprintf(out,"%s/%s",sel,sel1);
346 AliCDBRunRange runrange(fFirstRun,fLastRun);
347 AliDebug(2,Form("Writing TOF online calib obj on CDB with run range [%i, %i] ",runrange.GetFirstRun(),runrange.GetLastRun()));
348 AliCDBId id(out,runrange);
6dc9348d 349 AliCDBMetaData *md = new AliCDBMetaData();
d4ad0d6b 350 md->SetResponsible("Chiara Zampolli");
0a749fa5 351 if (!fTOFCalOnline) {
352 // deve uscire!!
85fc78e3 353 }
0a749fa5 354 man->Put(fTOFCalOnline,id,md);
5eaae242 355 delete md;
6dc9348d 356}
357//_____________________________________________________________________________
358
7fffa85b 359void AliTOFcalib::WriteParOnlinePulserOnCDB(Char_t *sel)
360{
361 //Write calibration parameters from pulser to the CDB with infinite validity
362 AliCDBManager *man = AliCDBManager::Instance();
363 Char_t *sel1 = "Pulser" ; // to be consistent with TOFPreprocessor
364 Char_t out[100];
365 sprintf(out,"%s/%s",sel,sel1);
366 AliCDBRunRange runrange(fFirstRun,fLastRun);
367 AliDebug(2,Form("Writing TOF online calib obj from pulser on CDB with run range [%i, %i] ",runrange.GetFirstRun(),runrange.GetLastRun()));
368 AliCDBId id(out,runrange);
369 AliCDBMetaData *md = new AliCDBMetaData();
370 md->SetResponsible("Chiara Zampolli");
371 if (!fTOFCalOnlinePulser) {
372 // deve uscire!!
373 }
374 man->Put(fTOFCalOnlinePulser,id,md);
375 delete md;
376}
377//_____________________________________________________________________________
378
379void AliTOFcalib::WriteParOnlineNoiseOnCDB(Char_t *sel)
380{
381 //Write calibration parameters from noise to the CDB with infinite validity
382 AliCDBManager *man = AliCDBManager::Instance();
383 Char_t *sel1 = "Noise" ; // to be consistent with TOFPreprocessor
384 Char_t out[100];
385 sprintf(out,"%s/%s",sel,sel1);
386 AliCDBRunRange runrange(fFirstRun,fLastRun);
387 AliDebug(2,Form("Writing TOF online calib obj from noise on CDB with run range [%i, %i] ",runrange.GetFirstRun(),runrange.GetLastRun()));
388 AliCDBId id(out,runrange);
389 AliCDBMetaData *md = new AliCDBMetaData();
390 md->SetResponsible("Chiara Zampolli");
391 if (!fTOFCalOnlineNoise) {
392 // deve uscire!!
393 }
394 man->Put(fTOFCalOnlineNoise,id,md);
395 delete md;
396}
397//_____________________________________________________________________________
398
399void AliTOFcalib::WriteParOnlineHWOnCDB(Char_t *sel)
400{
401 //Write calibration parameters from hardware to the CDB with infinite validity
402 AliCDBManager *man = AliCDBManager::Instance();
403 Char_t *sel1 = "HW" ; // to be consistent with TOFPreprocessor
404 Char_t out[100];
405 sprintf(out,"%s/%s",sel,sel1);
406 AliCDBRunRange runrange(fFirstRun,fLastRun);
407 AliDebug(2,Form("Writing TOF online calib obj from harware on CDB with run range [%i, %i] ",runrange.GetFirstRun(),runrange.GetLastRun()));
408 AliCDBId id(out,runrange);
409 AliCDBMetaData *md = new AliCDBMetaData();
410 md->SetResponsible("Chiara Zampolli");
411 if (!fTOFCalOnlineHW) {
412 // deve uscire!!
413 }
414 man->Put(fTOFCalOnlineHW,id,md);
415 delete md;
416}
417//_____________________________________________________________________________
418
0a749fa5 419void AliTOFcalib::WriteParOfflineOnCDB(Char_t *sel, const Char_t *validity, Int_t minrun, Int_t maxrun)
420{
340693af 421 //Write calibration parameters to the CDB
0cb9d099 422 SetFirstRun(minrun);
423 SetLastRun(maxrun);
6dc9348d 424 AliCDBManager *man = AliCDBManager::Instance();
0a749fa5 425 Char_t *sel1 = "ParOffline" ;
d4ad0d6b 426 Char_t out[100];
427 sprintf(out,"%s/%s",sel,sel1);
0cb9d099 428 AliDebug(2,Form("Writing TOF offline calib obj on CDB with run range [%i, %i] ",fFirstRun,fLastRun));
429 AliCDBId id(out,fFirstRun,fLastRun);
430 AliCDBMetaData *md = new AliCDBMetaData();
431 md->SetResponsible("Chiara Zampolli");
432 md->SetComment(validity);
433 man->Put(fTOFCalOffline,id,md);
434 delete md;
435}
436//_____________________________________________________________________________
437
438void AliTOFcalib::WriteParOfflineOnCDB(Char_t *sel, const Char_t *validity)
439{
440 //Write calibration parameters to the CDB with infinite validity
441 AliCDBManager *man = AliCDBManager::Instance();
442 Char_t *sel1 = "ParOffline" ;
443 Char_t out[100];
444 sprintf(out,"%s/%s",sel,sel1);
445 AliCDBRunRange runrange(fFirstRun,fLastRun);
446 AliDebug(2,Form("Writing TOF offline calib obj on CDB with run range [%i, %i] ",runrange.GetFirstRun(),runrange.GetLastRun()));
447 AliCDBId id(out,runrange);
d4ad0d6b 448 AliCDBMetaData *md = new AliCDBMetaData();
449 md->SetResponsible("Chiara Zampolli");
0a749fa5 450 md->SetComment(validity);
451 man->Put(fTOFCalOffline,id,md);
5eaae242 452 delete md;
d4ad0d6b 453}
454//_____________________________________________________________________________
455
0a749fa5 456Bool_t AliTOFcalib::ReadParOnlineFromCDB(Char_t *sel, Int_t nrun)
340693af 457{
458 //Read calibration parameters from the CDB
d4ad0d6b 459 AliCDBManager *man = AliCDBManager::Instance();
a7e9db2a 460 Char_t *sel1 = "ParOnline" ;
d4ad0d6b 461 Char_t out[100];
462 sprintf(out,"%s/%s",sel,sel1);
7a4f634e 463 AliCDBEntry *entry = man->Get(out,nrun);
c30c0a38 464 if (!entry) {
465 AliFatal("Exiting, no CDB object (ParOnline) found!!!");
466 exit(0);
467 }
7a4f634e 468 if(!entry->GetObject()){
c30c0a38 469 AliFatal("Exiting, no CDB object (ParOnline) found!!!");
470 exit(0);
7a4f634e 471 }
472
0a749fa5 473 fTOFCalOnline =(TObjArray*)entry->GetObject();
7fffa85b 474
475 return kTRUE;
476
477}
478//_____________________________________________________________________________
479
480Bool_t AliTOFcalib::ReadParOnlinePulserFromCDB(Char_t *sel, Int_t nrun)
481{
482 //Read calibration parameters from pulser from the CDB
483 AliCDBManager *man = AliCDBManager::Instance();
484 Char_t *sel1 = "Pulser" ;
485 Char_t out[100];
486 sprintf(out,"%s/%s",sel,sel1);
7fffa85b 487 AliCDBEntry *entry = man->Get(out,nrun);
c30c0a38 488 if (!entry) {
489 AliFatal("Exiting, no CDB object (Pulser) found!!!");
490 exit(0);
491 }
7fffa85b 492 if(!entry->GetObject()){
c30c0a38 493 AliFatal("Exiting, no CDB object (Pulser) found!!!");
494 exit(0);
7fffa85b 495 }
496
497 fTOFCalOnlinePulser =(TObjArray*)entry->GetObject();
498
499 return kTRUE;
500
501}
502//_____________________________________________________________________________
503
504Bool_t AliTOFcalib::ReadParOnlineNoiseFromCDB(Char_t *sel, Int_t nrun)
505{
506 //Read calibration parameters from noise from the CDB
507 AliCDBManager *man = AliCDBManager::Instance();
508 Char_t *sel1 = "Noise" ;
509 Char_t out[100];
510 sprintf(out,"%s/%s",sel,sel1);
7fffa85b 511 AliCDBEntry *entry = man->Get(out,nrun);
c30c0a38 512 if (!entry) {
513 AliFatal("Exiting, no CDB object (Noise) found!!!");
514 exit(0);
515 }
7fffa85b 516 if(!entry->GetObject()){
c30c0a38 517 AliFatal("Exiting, no CDB object (Noise) found!!!");
518 exit(0);
7fffa85b 519 }
520
521 fTOFCalOnlineNoise =(TObjArray*)entry->GetObject();
522
523 return kTRUE;
524
525}
526//_____________________________________________________________________________
527
528Bool_t AliTOFcalib::ReadParOnlineHWFromCDB(Char_t *sel, Int_t nrun)
529{
530 //Read calibration parameters from hardware from the CDB
531 AliCDBManager *man = AliCDBManager::Instance();
532 Char_t *sel1 = "HW" ;
533 Char_t out[100];
534 sprintf(out,"%s/%s",sel,sel1);
7fffa85b 535 AliCDBEntry *entry = man->Get(out,nrun);
c30c0a38 536 if (!entry) {
537 AliFatal("Exiting, no CDB object (HW map) found!!!");
538 exit(0);
539 }
7fffa85b 540 if(!entry->GetObject()){
c30c0a38 541 AliFatal("Exiting, no CDB object (HW map) found!!!");
542 exit(0);
7fffa85b 543 }
544
545 fTOFCalOnlineHW =(TObjArray*)entry->GetObject();
0a749fa5 546
1b20c168 547 return kTRUE;
7a4f634e 548
6dc9348d 549}
550//_____________________________________________________________________________
d4ad0d6b 551
0a749fa5 552Bool_t AliTOFcalib::ReadParOfflineFromCDB(Char_t *sel, Int_t nrun)
553{
554 //Read calibration parameters from the CDB
555 AliCDBManager *man = AliCDBManager::Instance();
556 Char_t *sel1 = "ParOffline" ;
557 Char_t out[100];
558 sprintf(out,"%s/%s",sel,sel1);
0a749fa5 559 AliCDBEntry *entry = man->Get(out,nrun);
c30c0a38 560 if (!entry) {
561 AliFatal("Exiting, no CDB object (ParOffline) found!!!");
562 exit(0);
563 }
0a749fa5 564 if(!entry->GetObject()){
c30c0a38 565 AliFatal("Exiting, no CDB object (ParOffline) found!!!");
566 exit(0);
0a749fa5 567 }
568 AliCDBMetaData * md = entry->GetMetaData();
569 fkValidity = md->GetComment();
570 fTOFCalOffline =(TObjArray*)entry->GetObject();
d4ad0d6b 571
0a749fa5 572 return kTRUE;
573
574}
575//_____________________________________________________________________________
40212801 576void AliTOFcalib::WriteSimHistoOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun, TH1F *histo){
340693af 577 //Write Sim miscalibration parameters to the CDB
d4ad0d6b 578
d4ad0d6b 579 fTOFSimToT=histo;
d4ad0d6b 580 AliCDBManager *man = AliCDBManager::Instance();
40212801 581 Char_t *sel1 = "SimHisto" ;
d4ad0d6b 582 Char_t out[100];
583 sprintf(out,"%s/%s",sel,sel1);
0a749fa5 584 AliCDBMetaData *mdhisto = new AliCDBMetaData();
585 mdhisto->SetResponsible("Chiara Zampolli");
40212801 586 AliCDBId id(out,minrun,maxrun);
587 man->Put(fTOFSimToT,id,mdhisto);
0a749fa5 588 delete mdhisto;
589}
590//_____________________________________________________________________________
40212801 591Bool_t AliTOFcalib::ReadSimHistoFromCDB(Char_t *sel, Int_t nrun)
0a749fa5 592{
593 //Read miscalibration parameters from the CDB
594 AliCDBManager *man = AliCDBManager::Instance();
595
40212801 596 // The Tot Histo
7a4f634e 597
40212801 598 Char_t *sel1 = "SimHisto" ;
d4ad0d6b 599 Char_t out[100];
600 sprintf(out,"%s/%s",sel,sel1);
c30c0a38 601 AliCDBEntry *entry = man->Get(out,nrun);
602 if (!entry) {
7a4f634e 603 AliFatal("Exiting, no CDB object (SimHisto) found!!!");
604 exit(0);
605 }
40212801 606 if(!entry->GetObject()){
7a4f634e 607 AliFatal("Exiting, no CDB object (SimHisto) found!!!");
608 exit(0);
609 }
40212801 610 TH1F *histo =(TH1F*)entry->GetObject();
d4ad0d6b 611 fTOFSimToT=histo;
52be7fb0 612 return kTRUE;
d4ad0d6b 613}
7037bd93 614//_____________________________________________________________________________
615void AliTOFcalib::WriteRecParOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun, AliTOFRecoParam *param){
616 //Write reconstruction parameters to the CDB
617
618 AliCDBManager *man = AliCDBManager::Instance();
7037bd93 619 AliCDBMetaData *md = new AliCDBMetaData();
620 md->SetResponsible("Silvia Arcelli");
621 Char_t *sel1 = "RecPar" ;
622 Char_t out[100];
623 sprintf(out,"%s/%s",sel,sel1);
624 AliCDBId id(out,minrun,maxrun);
625 man->Put(param,id,md);
626 delete md;
627}
628//_____________________________________________________________________________
629AliTOFRecoParam * AliTOFcalib::ReadRecParFromCDB(Char_t *sel, Int_t nrun)
630{
631 //Read reconstruction parameters from the CDB
632 AliCDBManager *man = AliCDBManager::Instance();
7037bd93 633 Char_t *sel1 = "RecPar" ;
634 Char_t out[100];
635 sprintf(out,"%s/%s",sel,sel1);
c30c0a38 636 AliCDBEntry *entry = man->Get(out,nrun);
637 if (!entry) {
7a4f634e 638 AliFatal("Exiting, no CDB object (RecPar) found!!!");
639 exit(0);
640 }
7a4f634e 641 if(!entry->GetObject()){
642 AliFatal("Exiting, no CDB object (RecPar) found!!!");
643 exit(0);
644 }
645
7037bd93 646 AliTOFRecoParam *param=(AliTOFRecoParam*)entry->GetObject();
647 return param;
648}
0a749fa5 649//-----------------------------------------------------------------------------
650// Calibration methods
651//-----------------------------------------------------------------------------
652void AliTOFcalib::CreateTreeFromCDB(Int_t minrun, Int_t maxrun){
653
654 // creating the chain with the trees for calibration
655 // collecting them from reference data
656 // from minrun to maxrun
657
658 Float_t p[CHENTRIESSMALL];
659 Int_t nentries;
660 fTree = new TTree("TOFCalib","Tree for TOF Calibration");
661 fTree->Branch("nentries",&nentries,"nentries/I");
662 fTree->Branch("TOFentries",p,"TOFentries[nentries]/F");
663 AliCDBManager *man = AliCDBManager::Instance();
664 AliCDBStorage *aStorage = man->GetStorage("local://$ALICE_ROOT");
665 for (Int_t irun = minrun;irun<=maxrun;irun++){
666 AliCDBEntry *entry = aStorage->Get("TOF/RefData/TreeForCalib",irun);
667 if (!entry){
668 AliInfo(Form("No entry found for run %i",irun));
669 }
670 else{
671 TTree *tree = new TTree();
672 tree = (TTree*)entry->GetObject();
673 tree->SetBranchAddress("nentries",&nentries);
674 tree->SetBranchAddress("TOFentries",p);
675 fTree->CopyEntries(tree);
676 delete tree;
677 fNruns++;
678 }
679 }
680 AliInfo(Form("Number of runs being analyzed %i",fNruns));
681}
682//-----------------------------------------------------------------------------
683void AliTOFcalib::CreateTreeFromGrid(Int_t minrun, Int_t maxrun){
684
685 // creating the chain with the trees for calibration
686 // collecting them from the Grid
687 // from minrun to maxrun
688
689 Float_t p[CHENTRIESSMALL];
690 Int_t nentries;
691 fTree = new TTree("TOFCalib","Tree for TOF Calibration");
692 fTree->SetDirectory(0);
693 fTree->Branch("nentries",&nentries,"nentries/I");
694 fTree->Branch("TOFentries",p,"TOFentries[nentries]/F");
695 AliInfo("connected to alien");
696 TGrid::Connect("alien://");
697
698 Char_t filename[100];
699 for (Int_t irun = minrun;irun<=maxrun;irun++){
700 sprintf(filename,"alien:///alice/cern.ch/user/c/czampolli/TOFCalibReference_%i.root",irun);
701 TFile *filegrid = TFile::Open(filename,"READ");
702 TTree *tree = (TTree*)filegrid->Get("T");
703 tree->SetBranchAddress("nentries",&nentries);
704 tree->SetBranchAddress("TOFentries",p);
705 fTree->CopyEntries(tree);
706 delete tree;
707 fNruns++;
708 }
709
710 AliInfo(Form("Number of runs being analyzed %i",fNruns));
711}
712//-----------------------------------------------------------------------------
713void AliTOFcalib::CreateTreeFromFile(Int_t minrun, Int_t maxrun){
714
715 // creating the tree with the trees for calibration
716 // collecting them from reference data (from file)
717 // from minrun to maxrun
718
719 Float_t p[CHENTRIESSMALL];
720 Int_t nentries;
721 fTree = new TTree("TOFCalib","Tree for TOF Calibration");
722 fTree->SetDirectory(0);
723 fTree->Branch("nentries",&nentries,"nentries/I");
724 fTree->Branch("TOFentries",p,"TOFentries[nentries]/F");
725 Char_t filename[100];
726 for (Int_t irun = minrun;irun<=maxrun;irun++){
727 sprintf(filename,"$ALICE_ROOT/TOF/RefData/TreeForCalib/fileout_%i.root",irun);
728 TFile *file = new TFile(filename,"READ");
729 TTree *tree = (TTree*)file->Get("T");
730 tree->SetBranchAddress("nentries",&nentries);
731 tree->SetBranchAddress("TOFentries",p);
732 fTree->CopyEntries(tree);
733 delete tree;
734 delete file;
735 file = 0x0;
736 fNruns++;
737 }
738
739 AliInfo(Form("Number of runs being analyzed %i",fNruns));
740}
741//-----------------------------------------------------------------------------
296591ad 742void AliTOFcalib::CreateChainFromGrid(Int_t minrun, Int_t maxrun){
743
744 // creating the chain with the trees for calibration
745 // collecting them from the Grid
746 // from minrun to maxrun
747
748 fChain = new TChain("T");
749 AliInfo("connected to alien");
750 TGrid::Connect("alien://");
751
752 Char_t filename[100];
753 for (Int_t irun = minrun;irun<=maxrun;irun++){
754 sprintf(filename,"alien:///alice/cern.ch/user/c/czampolli/TOFCalibReference_%i.root",irun);
755 fChain->Add(filename);
756 fNruns++;
757 }
758
759 AliInfo(Form("Number of runs being analyzed %i",fNruns));
760}
761//-----------------------------------------------------------------------------
0a749fa5 762Int_t AliTOFcalib::Calibrate(Int_t ichmin, Int_t ichmax, Option_t *optionSave, Option_t *optionFit){
7037bd93 763
0a749fa5 764 // calibrating summing more than one channels
765 // computing calibration parameters
766 // Returning codes:
767 // 0 -> everything was ok
768 // 1 -> no tree for calibration found
769 // 2 -> not enough statistics to perform calibration
770 // 3 -> problems with arrays
771
772 TH1::AddDirectory(0);
773
774 AliInfo(Form("*** Calibrating Histograms %s, summing more channels, from channel %i, to channel %i, storing Calib Pars in channel %i", GetName(),ichmin,ichmax,ichmin)) ;
775 AliInfo(Form("Option for Saving histos = %s",optionSave )) ;
776 AliInfo(Form("Option for Fitting Profile histos = %s",optionFit )) ;
777
778 Float_t p[CHENTRIESSMALL];
779 Int_t nentries;
296591ad 780 //fTree->SetBranchAddress("nentries",&nentries);
781 //fTree->SetBranchAddress("TOFentries",p);
782 fChain->SetBranchAddress("nentries",&nentries);
783 fChain->SetBranchAddress("TOFentries",p);
0a749fa5 784
785 Float_t ntracksTotalmean =0;
786 for (Int_t i=ichmin; i<ichmax; i++){
787 Int_t ientry = -1;
788 for (Int_t irun=0;irun<fNruns;irun++){
789 ientry = i+irun*fNChannels;
296591ad 790 //fTree->GetEntry(ientry);
791 fChain->GetEntry(ientry);
0a749fa5 792 Int_t ntracksRun=nentries/3;
793 ntracksTotalmean+=ntracksRun;
794 }
795 }
796
797 if (ntracksTotalmean < MEANENTRIES) {
798 AliInfo(Form(" Too small mean number of entires per channel (mean number = %f) not calibrating and exiting.....",ntracksTotalmean));
799 return 2;
800 }
801
802 //filling ToT and Time arrays
803
804 Int_t nbinToT = 100; // ToT bin width in Profile = 48.8 ps
805 Float_t minToT = 0; // ns
806 Float_t maxToT = 4.88; // ns
807
808 TH1F *hToT = new TH1F("htot","htot",nbinToT, minToT, maxToT);
809 TH1F *hdeltaTime = new TH1F("hdeltaTime","hdeltaTime",200,2,4);
810 Int_t ntracksTotal = 0;
811 Int_t ntracksRun = 0;
812 Double_t binsProfile[101]; // sized larger than necessary, the correct
813 // dim being set in the booking of the profile
814 Int_t nusefulbins=0;
815 Float_t meantime=0;
816 for (Int_t i = ichmin;i<ichmax;i++){
817 Int_t ientry = -1;
818 for (Int_t irun=0;irun<fNruns;irun++){
819 ientry = i+irun*fNChannels;
296591ad 820 //fTree->GetEntry(ientry);
821 fChain->GetEntry(ientry);
0a749fa5 822 ntracksTotal+=nentries/3;
823 ntracksRun=nentries/3;
824 AliDebug(2,Form("run %i, channel %i, nentries = %i, ntracks = %i",irun,i,nentries, ntracksRun));
825 for (Int_t j=0;j<ntracksRun;j++){
826 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
827 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
828 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
829 Float_t tot = p[idxexToT];
830 hdeltaTime->Fill(p[idxexTime]-p[idxexExTime]);
831 meantime+=p[idxexTime]-p[idxexExTime];
832 hToT->Fill(tot);
833 }
834 }
835 }
836 nusefulbins = FindBins(hToT,&binsProfile[0]);
837 meantime/=ntracksTotal;
838 AliDebug(2, Form("meantime = %f",meantime));
839
840 for (Int_t j=1;j<=nusefulbins;j++) {
841 AliDebug(2,Form(" summing channels from %i to %i, nusefulbins = %i, bin %i = %f",ichmin,ichmax,nusefulbins,j,binsProfile[j]));
842 }
843
844 TProfile* hSlewingProf = new TProfile("hSlewingProf", "hSlewingProf",nusefulbins, binsProfile, "G"); // CHECK THE BUILD OPTION, PLEASE!!!!!!
845 TH2F * htimetot = new TH2F("htimetot","htimetot",nbinToT, minToT, maxToT,600,-5,10);
846
847 for (Int_t irun=0;irun<fNruns;irun++){
848 Int_t ientry = -1;
849 for (Int_t i=ichmin; i<ichmax; i++){
850 ientry = i+irun*fNChannels;
296591ad 851 //fTree->GetEntry(ientry);
852 fChain->GetEntry(ientry);
0a749fa5 853 ntracksRun=nentries/3;
854 for (Int_t j=0;j<ntracksRun;j++){
855 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
856 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
857 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
858 Float_t tot = p[idxexToT];
859 Float_t time = p[idxexTime]-p[idxexExTime];
860 AliDebug (2, Form("track = %i, time = %f, tot = %f, time-meantime = %f",j,time, tot, time-meantime));
861 hSlewingProf->Fill(tot,time); // if meantime is not used, the fill may be moved in the loop above
862 htimetot->Fill(tot,time-meantime); // if meantime is not used, the fill may be moved in the loop above
863 }
864 }
865 }
866
867 hSlewingProf->Fit("pol5",optionFit,"",0,4);
868 TF1 * calibfunc = (TF1*)hSlewingProf->GetFunction("pol5");
869 Float_t par[6];
870 for(Int_t kk=0;kk<6;kk++){
871 par[kk]=calibfunc->GetParameter(kk);
872 AliDebug(2,Form("parameter %i = %f",kk,par[kk]));
873 }
874
875 if(strstr(optionSave,"save")){
876 TFile * fileProf = new TFile("TOFCalibSave.root","recreate");
877 fileProf->cd();
878 TString profName=Form("Profile%06i_%06i",ichmin,ichmax);
879 TString timeTotName=Form("TimeTot%06i_%06i",ichmin,ichmax);
880 TString totName=Form("Tot%06i_%06i",ichmin,ichmax);
881 TString deltaName=Form("Delta%06i_%06i",ichmin,ichmax);
882 hSlewingProf->Write(profName);
883 htimetot->Write(timeTotName);
884 hToT->Write(totName);
885 hdeltaTime->Write(deltaName);
886 fileProf->Close();
887 delete fileProf;
888 fileProf=0x0;
889 }
890
891 delete hToT;
892 hToT=0x0;
893 delete hSlewingProf;
894 hSlewingProf=0x0;
895 delete htimetot;
896 htimetot=0x0;
897 delete hdeltaTime;
898 hdeltaTime=0x0;
899
900 AliTOFChannelOffline * calChannel = (AliTOFChannelOffline*)fTOFCalOffline->At(ichmin);
901 calChannel->SetSlewPar(par);
0cb9d099 902 WriteParOfflineOnCDB("TOF/Calib","valid");
0a749fa5 903 return 0;
904}
905//----------------------------------------------------------------------------
906Int_t AliTOFcalib::Calibrate(Int_t i, Option_t *optionSave, Option_t *optionFit){
907
908 // computing calibration parameters for channel i
909 // Returning codes:
910 // 0 -> everything was ok
911 // 1 -> no tree for calibration found
912 // 2 -> not enough statistics to perform calibration
913 // 3 -> problems with arrays
914
915 TH1::AddDirectory(0);
916
917 AliInfo(Form("*** Calibrating Histograms (one channel) %s", GetName())) ;
918 AliInfo(Form("Option for Saving histos = %s",optionSave )) ;
919 AliInfo(Form("Option for Fitting Profile histos = %s",optionFit )) ;
920
921 Float_t p[MAXCHENTRIESSMALL];
922 Int_t nentries;
296591ad 923 //fTree->SetBranchAddress("nentries",&nentries);
924 //fTree->SetBranchAddress("TOFentries",p);
925 fChain->SetBranchAddress("nentries",&nentries);
926 fChain->SetBranchAddress("TOFentries",p);
0a749fa5 927
928 Float_t ntracksTotal =0;
929 for (Int_t irun=0;irun<fNruns;irun++){
930 Int_t ientry = -1;
931 ientry = i+irun*fNChannels;
296591ad 932 //fTree->GetEntry(ientry);
933 fChain->GetEntry(ientry);
0a749fa5 934 ntracksTotal+=nentries/3;
935 }
936
937 if (ntracksTotal < MEANENTRIES) {
938 AliInfo(Form(" Too small mean number of entires per channel (mean number = %f) not calibrating and exiting.....",ntracksTotal));
939 return 2;
940 }
941
942 //filling ToT and Time arrays
943
944 Int_t nbinToT = 100; // ToT bin width in Profile = 48.8 ps
945 Float_t minToT = 0; // ns
946 Float_t maxToT = 4.88; // ns
947
948 TH1F *hToT = new TH1F("htot","htot",nbinToT, minToT, maxToT);
949 TH1F *hdeltaTime = new TH1F("hdeltaTime","hdeltaTime",200,2,4);
950 Int_t ntracksRun = 0;
951 Double_t binsProfile[101]; // sized larger than necessary, the correct
952 // dim being set in the booking of the profile
953 Int_t nusefulbins=0;
954 Float_t meantime=0;
955 for (Int_t irun=0;irun<fNruns;irun++){
956 Int_t ientry = -1;
957 ientry = i+irun*fNChannels;
296591ad 958 //fTree->GetEntry(ientry);
959 fChain->GetEntry(ientry);
0a749fa5 960 ntracksRun=nentries/3;
961 AliDebug(2,Form("run %i, channel %i, nentries = %i, ntracksRun = %i",irun, i ,nentries, ntracksRun));
962 for (Int_t j=0;j<ntracksRun;j++){
963 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
964 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
965 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
966 Float_t tot = p[idxexToT];
967 meantime+=p[idxexTime]-p[idxexExTime];
968 hdeltaTime->Fill(p[idxexTime]-p[idxexExTime]);
969 hToT->Fill(tot);
970 }
971 }
972
973 nusefulbins = FindBins(hToT,&binsProfile[0]);
974 meantime/=ntracksTotal;
975 AliDebug(2,Form("meantime = %f",meantime));
976
977 for (Int_t j=1;j<=nusefulbins;j++) {
978 AliDebug(2,Form(" channel %i, nusefulbins = %i, bin %i = %f",i,nusefulbins,j,binsProfile[j]));
979 }
980
981 TProfile* hSlewingProf = new TProfile("hSlewingProf", "hSlewingProf",nusefulbins, binsProfile, "G"); // CHECK THE BUILD OPTION, PLEASE!!!!!!
982 TH2F * htimetot = new TH2F("htimetot","htimetot",nbinToT, minToT, maxToT,600,-5,10);
983 for (Int_t irun=0;irun<fNruns;irun++){
984 Int_t ientry = -1;
985 ientry = i+irun*fNChannels;
296591ad 986 //fTree->GetEntry(ientry);
987 fChain->GetEntry(ientry);
0a749fa5 988 ntracksRun=nentries/3;
989 for (Int_t j=0;j<ntracksRun;j++){
990 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
991 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
992 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
993 Float_t tot = p[idxexToT];
994 Float_t time = p[idxexTime]-p[idxexExTime];
995 AliDebug (2,Form("track = %i, time = %f, tot = %f, time-meantime = %f",j,time, tot, time-meantime));
996 hSlewingProf->Fill(tot,time); // if meantime is not used, the fill may be moved in the loop above
997 htimetot->Fill(tot,time-meantime); // if meantime is not used, the fill may be moved in the loop above
998 }
999 }
1000
1001 hSlewingProf->Fit("pol5",optionFit,"",0,4);
1002 TF1 * calibfunc = (TF1*)hSlewingProf->GetFunction("pol5");
1003 Float_t par[6];
1004 for(Int_t kk=0;kk<6;kk++){
1005 par[kk]=calibfunc->GetParameter(kk);
1006 AliDebug(2,Form("parameter %i = %f",kk,par[kk]));
1007 }
1008
1009
1010 if(strstr(optionSave,"save")){
1011 TFile * fileProf = new TFile("TOFCalibSave.root","recreate");
1012 fileProf->cd();
1013 TString profName=Form("Profile%06i",i);
1014 TString timeTotName=Form("TimeTot%06i",i);
1015 TString totName=Form("Tot%06i",i);
1016 TString deltaName=Form("Delta%06i",i);
1017 hSlewingProf->Write(profName);
1018 htimetot->Write(timeTotName);
1019 hToT->Write(totName);
1020 hdeltaTime->Write(deltaName);
1021 fileProf->Close();
1022 delete fileProf;
1023 fileProf=0x0;
1024 }
1025
1026 delete hToT;
1027 hToT=0x0;
1028 delete hSlewingProf;
1029 hSlewingProf=0x0;
1030 delete htimetot;
1031 htimetot=0x0;
1032 delete hdeltaTime;
1033 hdeltaTime=0x0;
1034
1035 AliTOFChannelOffline * calChannel = (AliTOFChannelOffline*)fTOFCalOffline->At(i);
1036 calChannel->SetSlewPar(par);
0cb9d099 1037 WriteParOfflineOnCDB("TOF/Calib","valid");
0a749fa5 1038 return 0;
1039}
1040//----------------------------------------------------------------------------
1041Int_t AliTOFcalib::Calibrate(Int_t nch, Int_t *ch, Option_t *optionSave, Option_t *optionFit){
1042
1043 // calibrating an array of channels
1044 // computing calibration parameters
1045 // Returning codes:
1046 // 0 -> everything was ok
1047 // 1 -> no tree for calibration found
1048 // 2 -> not enough statistics to perform calibration
1049 // 3 -> problems with arrays
1050
1051 TH1::AddDirectory(0);
1052
1053 AliInfo(Form("*** Calibrating Histograms %s, number of channels = %i", GetName(),nch)) ;
1054 AliInfo(Form("Option for Saving histos = %s",optionSave )) ;
1055 AliInfo(Form("Option for Fitting Profile histos = %s",optionFit )) ;
1056 for (Int_t ich=0; ich<nch; ich++){
1057 Int_t i = ch[ich];
1058 AliInfo(Form("Calibrating channel = %i",i )) ;
1059 }
1060 Float_t p[MAXCHENTRIESSMALL];
1061 Int_t nentries;
296591ad 1062 //fTree->SetBranchAddress("nentries",&nentries);
1063 //fTree->SetBranchAddress("TOFentries",p);
1064 fChain->SetBranchAddress("nentries",&nentries);
1065 fChain->SetBranchAddress("TOFentries",p);
0a749fa5 1066
1067 Float_t ntracksTotalmean =0;
1068 for (Int_t ich=0; ich<nch; ich++){
1069 Int_t ientry = -1;
1070 Int_t i = ch[ich];
1071 for (Int_t irun=0;irun<fNruns;irun++){
1072 ientry = i+irun*fNChannels;
296591ad 1073 //fTree->GetEntry(ientry);
1074 fChain->GetEntry(ientry);
0a749fa5 1075 ntracksTotalmean+=nentries/3;
1076 }
1077 }
1078
1079 ntracksTotalmean/=nch;
1080 if (ntracksTotalmean < MEANENTRIES) {
1081 AliInfo(Form(" Too small mean number of entires per channel (mean number = %f) not calibrating and exiting.....",ntracksTotalmean));
1082 return 2;
1083 }
1084
1085 //filling ToT and Time arrays
1086
1087 Int_t nbinToT = 100; // ToT bin width in Profile = 48.8 ps
1088 Float_t minToT = 0; // ns
1089 Float_t maxToT = 4.88; // ns
1090 TFile * fileProf=0x0;
1091 if(strstr(optionSave,"save")){
1092 fileProf = new TFile("TOFCalibSave.root","recreate");
1093 }
1094 for (Int_t ich=0; ich<nch; ich++) {
1095 TH1F *hToT = new TH1F("htot","htot",nbinToT, minToT, maxToT);
1096 TH1F *hdeltaTime = new TH1F("hdeltaTime","hdeltaTime",200,2,4);
1097 Double_t binsProfile[101]; // sized larger than necessary, the correct
1098 // dim being set in the booking of the profile
1099 TH2F * htimetot = new TH2F("htimetot","htimetot",nbinToT, minToT, maxToT,600,-5,10);
1100 Int_t ntracksTotal = 0;
1101 Int_t ntracksRun = 0;
1102 Int_t nusefulbins=0;
1103 Float_t meantime=0;
1104 Int_t i=-1;
1105 for (Int_t irun=0;irun<fNruns;irun++){
1106 i = ch[ich]+irun*fNChannels;
1107 AliDebug(2,Form("Calibrating channel %i",i));
296591ad 1108 //fTree->GetEntry(i);
1109 fChain->GetEntry(i);
0a749fa5 1110 ntracksTotal+=nentries/3;
1111 }
1112 if (ntracksTotal < MEANENTRIES) {
1113 AliInfo(Form(" Too small mean number of entires in channel %i (number of tracks = %f), not calibrating channel and continuing.....",i,ntracksTotal));
1114 continue;
1115 }
1116
1117 for (Int_t irun=0;irun<fNruns;irun++){
3c609b5c 1118 i = ch[ich]+irun*fNChannels;
296591ad 1119 //fTree->GetEntry(i);
1120 fChain->GetEntry(i);
0a749fa5 1121 ntracksRun=nentries/3;
1122 for (Int_t j=0;j<ntracksRun;j++){
1123 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
1124 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
1125 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
1126 Float_t tot = p[idxexToT];
1127 hdeltaTime->Fill(p[idxexTime]-p[idxexExTime]);
1128 meantime+=p[idxexTime]-p[idxexExTime];
1129 hToT->Fill(tot);
1130 }
1131 }
1132
1133 nusefulbins = FindBins(hToT,&binsProfile[0]);
1134 meantime/=ntracksTotal;
1135 for (Int_t j=1;j<=nusefulbins;j++) {
1136 AliDebug(2,Form(" channel %i, nusefulbins = %i, bin %i = %f",i,nusefulbins,j,binsProfile[j]));
1137 }
1138
1139 TProfile* hSlewingProf = new TProfile("hSlewingProf", "hSlewingProf",nusefulbins, binsProfile, "G"); // CHECK THE BUILD OPTION, PLEASE!!!!!!
1140 for (Int_t irun=0;irun<fNruns;irun++){
3c609b5c 1141 i = ch[ich]+irun*fNChannels;
296591ad 1142 //fTree->GetEntry(i);
1143 fChain->GetEntry(i);
0a749fa5 1144 ntracksRun=nentries/3;
1145 for (Int_t j=0;j<ntracksRun;j++){
1146 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
1147 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
1148 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
1149 Float_t tot = p[idxexToT];
1150 Float_t time = p[idxexTime]-p[idxexExTime];
1151 AliDebug(2,Form("track = %i, time = %f, tot = %f, time-meantime = %f",j,time, tot, time-meantime));
1152 hSlewingProf->Fill(tot,time); // if meantime is not used, the fill may be moved in the loop above
1153 htimetot->Fill(tot,time-meantime); // if meantime is not used, the fill may be moved in the loop above
1154 }
1155 }
1156
1157 hSlewingProf->Fit("pol5",optionFit,"",1,4);
1158 TF1 * calibfunc = (TF1*)hSlewingProf->GetFunction("pol5");
1159 Float_t par[6];
1160 for(Int_t kk=0;kk<6;kk++){
1161 par[kk]=calibfunc->GetParameter(kk);
1162 AliDebug(2,Form("parameter %i = %f",kk,par[kk]));
1163 }
1164
1165 if(strstr(optionSave,"save") && fileProf){
1166 TString profName=Form("Profile%06i",i);
1167 TString timeTotName=Form("TimeTot%06i",i);
1168 TString totName=Form("Tot%06i",i);
1169 TString deltaName=Form("Delta%06i",i);
1170 fileProf->cd();
1171 hSlewingProf->Write(profName);
1172 htimetot->Write(timeTotName);
1173 hToT->Write(totName);
1174 hdeltaTime->Write(deltaName);
1175 }
1176
1177 AliTOFChannelOffline * calChannel = (AliTOFChannelOffline*)fTOFCalOffline->At(i);
1178 calChannel->SetSlewPar(par);
1179 delete hToT;
1180 hToT=0x0;
1181 delete hSlewingProf;
1182 hSlewingProf=0x0;
1183 delete htimetot;
1184 htimetot=0x0;
1185 delete hdeltaTime;
1186 hdeltaTime=0x0;
1187 }
1188
1189 if(strstr(optionSave,"save") && fileProf){
1190 fileProf->Close();
1191 delete fileProf;
1192 fileProf=0x0;
1193 }
0cb9d099 1194 WriteParOfflineOnCDB("TOF/Calib","valid");
0a749fa5 1195
1196 return 0;
1197}
1198//----------------------------------------------------------------------------
1199Int_t AliTOFcalib::CalibrateFromProfile(Int_t ich, Option_t *optionSave, Option_t *optionFit){
1200
1201 // computing calibration parameters using the old profiling algo
1202 // Returning codes:
1203 // 0 -> everything was ok
1204 // 1 -> no tree for calibration found
1205 // 2 -> not enough statistics to perform calibration
1206 // 3 -> problems with arrays
1207
1208 TH1::AddDirectory(0);
1209
1210 AliInfo(Form("*** Calibrating Histograms From Profile %s", GetName())) ;
1211 AliInfo(Form("Option for Saving histos = %s",optionSave )) ;
1212 AliInfo(Form("Option for Fitting Profile histos = %s",optionFit )) ;
1213 Float_t p[MAXCHENTRIESSMALL];
1214 Int_t nentries;
1215 Int_t ntracksTotal=0;
296591ad 1216 //fTree->SetBranchAddress("nentries",&nentries);
1217 //fTree->SetBranchAddress("TOFentries",p);
1218 fChain->SetBranchAddress("nentries",&nentries);
1219 fChain->SetBranchAddress("TOFentries",p);
0a749fa5 1220
1221 for (Int_t irun=0;irun<fNruns;irun++){
1222 Int_t i = ich+irun*fNChannels;
296591ad 1223 //fTree->GetEntry(i);
1224 fChain->GetEntry(i);
0a749fa5 1225 ntracksTotal+=nentries/3;
1226 }
1227
1228 if (ntracksTotal < MEANENTRIES) {
1229 AliInfo(Form(" Too small mean number of entires per channel (mean number = %f) not calibrating and exiting.....",ntracksTotal));
1230 return 2;
1231 }
1232
1233 TH1F * hProf = new TH1F();
1234 hProf = Profile(ich);
1235 hProf->Fit("pol5",optionFit,"",0,4);
1236 TF1 * calibfunc = (TF1*)hProf->GetFunction("pol5");
1237 Float_t par[6];
1238 for(Int_t kk=0;kk<6;kk++){
1239 par[kk]=calibfunc->GetParameter(kk);
1240 AliDebug(2,Form("parameter %i = %f",kk,par[kk]));
1241 }
1242
1243 if(strstr(optionSave,"save")){
1244 TFile * fileProf = new TFile("TOFCalibSave.root","recreate");
1245 fileProf->cd();
1246 TString profName=Form("Profile%06i",ich);
1247 hProf->Write(profName);
1248 fileProf->Close();
1249 delete fileProf;
1250 fileProf=0x0;
1251 }
1252
1253 delete hProf;
1254 hProf=0x0;
1255 AliTOFChannelOffline * calChannel = (AliTOFChannelOffline*)fTOFCalOffline->At(ich);
1256 calChannel->SetSlewPar(par);
0cb9d099 1257 WriteParOfflineOnCDB("TOF/Calib","valid");
0a749fa5 1258 return 0;
1259}
1260//----------------------------------------------------------------------------
1261Int_t AliTOFcalib::Calibrate(Option_t *optionSave, Option_t *optionFit){
1262
1263 // calibrating the whole TOF
1264 // computing calibration parameters
1265 // Returning codes:
1266 // 0 -> everything was ok
1267 // 1 -> no tree for calibration found
1268 // 2 -> not enough statistics to perform calibration
1269 // 3 -> problems with arrays
1270
1271 TH1::AddDirectory(0);
1272
1273 AliInfo(Form("*** Calibrating Histograms %s, all channels", GetName())) ;
1274 AliInfo(Form("Option for Saving histos = %s",optionSave )) ;
1275 AliInfo(Form("Option for Fitting Profile histos = %s",optionFit )) ;
1276
1277 TFile * fileProf=0x0;
1278 if(strstr(optionSave,"save")){
1279 fileProf = new TFile("TOFCalibSave.root","recreate");
1280 }
1281
1282 Float_t p[MAXCHENTRIESSMALL];
1283 Int_t nentries;
296591ad 1284 //fTree->SetBranchAddress("nentries",&nentries);
1285 //fTree->SetBranchAddress("TOFentries",p);
1286 fChain->SetBranchAddress("nentries",&nentries);
1287 fChain->SetBranchAddress("TOFentries",p);
0a749fa5 1288
1289 Float_t ntracksTotalmean =0;
1290 for (Int_t ii=0; ii<fNChannels; ii++){
1291 for (Int_t irun=0;irun<fNruns;irun++){
1292 Int_t i = ii+irun*fNChannels;
296591ad 1293 //fTree->GetEntry(i);
1294 fChain->GetEntry(i);
0a749fa5 1295 ntracksTotalmean+=nentries/3;
1296 }
1297 }
1298
1299 ntracksTotalmean/=fNChannels;
1300 if (ntracksTotalmean < MEANENTRIES) {
1301 AliInfo(Form(" Too small mean number of entires per channel (mean number = %f) not calibrating and exiting.....",ntracksTotalmean));
1302 return 2;
1303 }
1304
1305 //filling ToT and Time arrays
1306
1307 Int_t nbinToT = 100; // ToT bin width in Profile = 50.0 ps
1308 Float_t minToT = 0; // ns
1309 Float_t maxToT = 4.88;// ns
1310 for (Int_t ii=0; ii<fNChannels; ii++) {
1311 TH1F *hToT = new TH1F("htot","htot",nbinToT, minToT, maxToT);
1312 TH1F *hdeltaTime = new TH1F("hdeltaTime","hdeltaTime",200,2,4);
1313 TH2F * htimetot = new TH2F("htimetot","htimetot",nbinToT, minToT, maxToT,600,-5,10);
1314 if (ii%1000 == 0) AliDebug(1,Form("Calibrating channel %i ",ii));
1315 //Int_t i = 3;
1316 Int_t nusefulbins=0;
1317 Double_t binsProfile[101]; // sized larger than necessary, the correct
1318 // dim being set in the booking of the profile
1319 Int_t ntracksRun = 0;
1320 Int_t ntracksTotal = 0;
1321 for (Int_t irun=0;irun<fNruns;irun++){
1322 Int_t i = ii+irun*fNChannels;
296591ad 1323 //fTree->GetEntry(i);
1324 fChain->GetEntry(i);
0a749fa5 1325 ntracksTotal+=nentries/3;
1326 }
1327 if (ntracksTotal < MEANENTRIES) {
1328 AliInfo(Form(" Too small mean number of entires in channel %i (number of tracks = %f), not calibrating channel and continuing.....",ii,ntracksTotal));
1329 continue;
1330 }
1331 Float_t meantime=0;
1332 for (Int_t irun=0;irun<fNruns;irun++){
1333 Int_t i = ii+irun*fNChannels;
296591ad 1334 //fTree->GetEntry(i);
1335 fChain->GetEntry(i);
0a749fa5 1336 ntracksRun=nentries/3;
1337 for (Int_t j=0;j<ntracksRun;j++){
1338 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
1339 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
1340 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
1341 Float_t tot = p[idxexToT];
1342 hdeltaTime->Fill(p[idxexTime]-p[idxexExTime]);
1343 meantime+=p[idxexTime]-p[idxexExTime];
1344 hToT->Fill(tot);
1345 }
1346 }
1347 nusefulbins = FindBins(hToT,&binsProfile[0]);
1348 meantime/=ntracksTotal;
1349 for (Int_t j=0;j<nusefulbins;j++) {
1350 AliDebug(2,Form(" channel %i, usefulbin = %i, low edge = %f",ii,j,binsProfile[j]));
1351 }
1352 TProfile* hSlewingProf = new TProfile("hSlewingProf", "hSlewingProf",nusefulbins, binsProfile, "G"); // CHECK THE BUILD OPTION, PLEASE!!!!!!
1353 for (Int_t irun=0;irun<fNruns;irun++){
1354 Int_t i = ii+irun*fNChannels;
296591ad 1355 //fTree->GetEntry(i);
1356 fChain->GetEntry(i);
0a749fa5 1357 ntracksRun=nentries/3;
1358 for (Int_t j=0;j<ntracksRun;j++){
1359 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
1360 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
1361 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
1362 Float_t tot = p[idxexToT];
1363 Float_t time = p[idxexTime]-p[idxexExTime];
1364 AliDebug (2,Form("track = %i, time = %f, tot = %f, time-meantime = %f",j,time, tot, time-meantime));
1365 hSlewingProf->Fill(tot,time); // if meantime is not used, the fill may be moved in the loop above
1366 htimetot->Fill(tot,time-meantime); // if meantime is not used, the fill may be moved in the loop above
1367 }
1368 }
1369 hSlewingProf->Fit("pol5",optionFit,"",1,4);
1370 TF1 * calibfunc = (TF1*)hSlewingProf->GetFunction("pol5");
1371 Float_t par[6];
1372 for(Int_t kk=0;kk<6;kk++){
1373 par[kk]=calibfunc->GetParameter(kk);
1374 AliDebug(2,Form("parameter %i = %f",kk,par[kk]));
1375 }
1376
1377 if(strstr(optionSave,"save") && fileProf){
1378 TString profName=Form("Profile%06i",ii);
1379 TString timeTotName=Form("TimeTot%06i",ii);
1380 TString totName=Form("Tot%06i",ii);
1381 TString deltaName=Form("Delta%06i",ii);
1382 fileProf->cd();
1383 hSlewingProf->Write(profName);
1384 htimetot->Write(timeTotName);
1385 hToT->Write(totName);
1386 hdeltaTime->Write(deltaName);
1387 }
1388 AliTOFChannelOffline * calChannel = (AliTOFChannelOffline*)fTOFCalOffline->At(ii);
1389 calChannel->SetSlewPar(par);
1390
1391 delete hToT;
1392 hToT=0x0;
1393 delete hSlewingProf;
1394 hSlewingProf=0x0;
1395 delete htimetot;
1396 htimetot=0x0;
1397 delete hdeltaTime;
1398 hdeltaTime=0x0;
1399 }
1400
1401 if(strstr(optionSave,"save")){
1402 fileProf->Close();
1403 delete fileProf;
1404 fileProf=0x0;
1405 }
0cb9d099 1406 WriteParOfflineOnCDB("TOF/Calib","valid");
0a749fa5 1407 return 0;
1408}
1409
1410//-----------------------------------------------------------------------
1411TH1F* AliTOFcalib::Profile(Int_t ich)
340693af 1412{
0a749fa5 1413 // profiling algo
1414
1415 Float_t p[MAXCHENTRIESSMALL];
1416 Int_t nentries;
296591ad 1417 //fTree->SetBranchAddress("nentries",&nentries);
1418 //fTree->SetBranchAddress("TOFentries",p);
1419 fChain->SetBranchAddress("nentries",&nentries);
1420 fChain->SetBranchAddress("TOFentries",p);
0a749fa5 1421
1422 //Prepare histograms for Slewing Correction
1423 const Int_t knbinToT = 100;
1424 Int_t nbinTime = 200;
1425 Float_t minTime = -5.5; //ns
1426 Float_t maxTime = 5.5; //ns
1427 Float_t minToT = 0; //ns
1428 Float_t maxToT = 5.; //ns
1429 Float_t deltaToT = (maxToT-minToT)/knbinToT;
1430 Double_t mTime[knbinToT+1],mToT[knbinToT+1],meanTime[knbinToT+1], meanTime2[knbinToT+1],vToT[knbinToT+1], vToT2[knbinToT+1],meanToT[knbinToT+1],meanToT2[knbinToT+1],vTime[knbinToT+1],vTime2[knbinToT+1],xlow[knbinToT+1],sigmaTime[knbinToT+1];
1431 Int_t n[knbinToT+1], nentrx[knbinToT+1];
1432 Double_t sigmaToT[knbinToT+1];
1433 for (Int_t i = 0; i < knbinToT+1 ; i++){
1434 mTime[i]=0;
1435 mToT[i]=0;
1436 n[i]=0;
1437 meanTime[i]=0;
1438 meanTime2[i]=0;
1439 vToT[i]=0;
1440 vToT2[i]=0;
1441 meanToT[i]=0;
1442 meanToT2[i]=0;
1443 vTime[i]=0;
1444 vTime2[i]=0;
1445 xlow[i]=0;
1446 sigmaTime[i]=0;
1447 sigmaToT[i]=0;
1448 n[i]=0;
1449 nentrx[i]=0;
1450 }
1451 TH2F* hSlewing = new TH2F("hSlewing", "hSlewing", knbinToT, minToT, maxToT, nbinTime, minTime, maxTime);
1452 Int_t ntracksRun = 0;
1453 TH1F *histo = new TH1F("histo", "1D Time vs ToT", knbinToT, minToT, maxToT);
1454 for (Int_t irun=0;irun<fNruns;irun++){
1455 Int_t i = ich+irun*fNChannels;
296591ad 1456 //fTree->GetEntry(i);
1457 fChain->GetEntry(i);
0a749fa5 1458 ntracksRun=nentries/3;
1459 for (Int_t j=0;j<ntracksRun;j++){
1460 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
1461 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
1462 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
1463 Float_t tot = p[idxexToT];
1464 Float_t time = p[idxexTime]-p[idxexExTime];
1465 Int_t nx = (Int_t)((tot-minToT)/deltaToT)+1;
1466 if ((tot != 0) && ( time!= 0)){
1467 vTime[nx]+=time;
1468 vTime2[nx]+=time*time;
1469 vToT[nx]+=tot;
1470 vToT2[nx]+=tot*tot;
1471 nentrx[nx]++;
1472 hSlewing->Fill(tot,time);
1473 }
1474 }
1475 }
1476 Int_t nbinsToT=hSlewing->GetNbinsX();
1477 if (nbinsToT != knbinToT) {
1478 AliError("Profile :: incompatible numbers of bins");
1479 return 0x0;
1480 }
1481
1482 Int_t usefulBins=0;
1483 for (Int_t i=1;i<=nbinsToT;i++){
1484 if (nentrx[i]!=0){
1485 n[usefulBins]+=nentrx[i];
1486 if (n[usefulBins]==0 && i == nbinsToT) {
1487 break;
1488 }
1489 meanTime[usefulBins]+=vTime[i];
1490 meanTime2[usefulBins]+=vTime2[i];
1491 meanToT[usefulBins]+=vToT[i];
1492 meanToT2[usefulBins]+=vToT2[i];
1493 if (n[usefulBins]<10 && i!=nbinsToT) continue;
1494 mTime[usefulBins]=meanTime[usefulBins]/n[usefulBins];
1495 mToT[usefulBins]=meanToT[usefulBins]/n[usefulBins];
1496 sigmaTime[usefulBins]=TMath::Sqrt(1./n[usefulBins]/n[usefulBins]
1497 *(meanTime2[usefulBins]-meanTime[usefulBins]
1498 *meanTime[usefulBins]/n[usefulBins]));
1499 if ((1./n[usefulBins]/n[usefulBins]
1500 *(meanToT2[usefulBins]-meanToT[usefulBins]
1501 *meanToT[usefulBins]/n[usefulBins]))< 0) {
1502 AliError(" too small radical" );
1503 sigmaToT[usefulBins]=0;
1504 }
1505 else{
1506 sigmaToT[usefulBins]=TMath::Sqrt(1./n[usefulBins]/n[usefulBins]
1507 *(meanToT2[usefulBins]-meanToT[usefulBins]
1508 *meanToT[usefulBins]/n[usefulBins]));
1509 }
1510 usefulBins++;
1511 }
1512 }
1513 for (Int_t i=0;i<usefulBins;i++){
1514 Int_t binN = (Int_t)((mToT[i]-minToT)/deltaToT)+1;
1515 histo->Fill(mToT[i],mTime[i]);
1516 histo->SetBinError(binN,sigmaTime[i]);
1517 }
1518 delete hSlewing;
1519 hSlewing=0x0;
1520
1521 return histo;
6dc9348d 1522}
0a749fa5 1523//----------------------------------------------------------------------------
1524Int_t AliTOFcalib::FindBins(TH1F* h, Double_t *binsProfile) const{
6dc9348d 1525
0a749fa5 1526 // to determine the bins for ToT histo
1527
1528 Int_t cont = 0;
1529 Int_t startBin = 1;
1530 Int_t nbin = h->GetNbinsX();
1531 Int_t nentries = (Int_t)h->GetEntries();
1532 Float_t max = h->GetBinLowEdge(nbin);
1533 Int_t nusefulbins=0;
1534 Int_t maxcont=0;
1535 // setting maxvalue of entries per bin
1536 if (nentries <= 60) maxcont = 2;
1537 else if (nentries <= 100) maxcont = 5;
1538 else if (nentries <= 500) maxcont = 10;
1539 else maxcont = 20;
1540 for (Int_t j=1;j<=nbin;j++) {
1541 cont += (Int_t)h->GetBinContent(j);
1542 if (j<nbin){
1543 if (cont>=maxcont){
1544 nusefulbins++;
1545 binsProfile[nusefulbins-1]=h->GetBinLowEdge(startBin);
1546 cont=0;
1547 startBin=j+1;
1548 continue;
1549 }
1550 }
1551 else{
1552 if (cont>=maxcont){
1553 nusefulbins++;
1554 binsProfile[nusefulbins-1]=h->GetBinLowEdge(startBin);
1555 binsProfile[nusefulbins]=max;
1556 }
1557 else {
1558 binsProfile[nusefulbins]=h->GetBinLowEdge(startBin);
1559 }
1560 }
1561 }
1562 return nusefulbins;
1563}