]> 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
Major fixes in the digits and raw-data reco. Now both are equivalent. To be propagate...
[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"
17149e6b 96#include "TMap.h"
0e46b9ae 97
98#include "AliCDBEntry.h"
0cb9d099 99#include "AliCDBRunRange.h"
0e46b9ae 100#include "AliCDBId.h"
6dc9348d 101#include "AliCDBManager.h"
0a749fa5 102#include "AliCDBStorage.h"
6dc9348d 103#include "AliCDBMetaData.h"
5c7c93fa 104//#include "AliESDtrack.h"
105//#include "AliESD.h"
0e46b9ae 106#include "AliLog.h"
107
0e46b9ae 108#include "AliTOFcalib.h"
17149e6b 109#include "AliTOFChannelOnlineArray.h"
0a749fa5 110#include "AliTOFChannelOnline.h"
7fffa85b 111#include "AliTOFChannelOnlineStatus.h"
17149e6b 112#include "AliTOFChannelOnlineStatusArray.h"
0a749fa5 113#include "AliTOFChannelOffline.h"
0e46b9ae 114#include "AliTOFGeometry.h"
7037bd93 115#include "AliTOFRecoParam.h"
2bf4d9d6 116#include "AliTOFDeltaBCOffset.h"
117#include "AliTOFCTPLatency.h"
118#include "AliTOFT0Fill.h"
f04b3a69 119#include "AliTOFRunParams.h"
6dc9348d 120
5c7c93fa 121class TROOT;
122class TStyle;
123
6dc9348d 124extern TROOT *gROOT;
125extern TStyle *gStyle;
126
127ClassImp(AliTOFcalib)
128
6dc9348d 129//_______________________________________________________________________
655e379f 130AliTOFcalib::AliTOFcalib():
131 TTask("AliTOFcalib",""),
132 fNChannels(-1),
0a749fa5 133 fTOFCalOnline(0x0),
7fffa85b 134 fTOFCalOnlinePulser(0x0),
135 fTOFCalOnlineNoise(0x0),
136 fTOFCalOnlineHW(0x0),
0a749fa5 137 fTOFCalOffline(0x0),
17149e6b 138 fCal(0x0),
139 fStatus(0x0),
0a749fa5 140 fTOFSimToT(0x0),
141 fkValidity(0x0),
142 fTree(0x0),
296591ad 143 fChain(0x0),
0cb9d099 144 fNruns(0),
145 fFirstRun(0),
17149e6b 146 fLastRun(AliCDBRunRange::Infinity()),
2bf4d9d6 147 fConfigMap(new TMap),
148 fDeltaBCOffset(NULL),
149 fCTPLatency(NULL),
f04b3a69 150 fT0Fill(NULL),
151 fRunParams(NULL)
655e379f 152{
340693af 153 //TOF Calibration Class ctor
0a749fa5 154 fNChannels = AliTOFGeometry::NSectors()*(2*(AliTOFGeometry::NStripC()+AliTOFGeometry::NStripB())+AliTOFGeometry::NStripA())*AliTOFGeometry::NpadZ()*AliTOFGeometry::NpadX();
6dc9348d 155}
156//____________________________________________________________________________
157
655e379f 158AliTOFcalib::AliTOFcalib(const AliTOFcalib & calib):
8a190ba2 159 TTask(calib),
0a749fa5 160 fNChannels(calib.fNChannels),
161 fTOFCalOnline(0x0),
7fffa85b 162 fTOFCalOnlinePulser(0x0),
163 fTOFCalOnlineNoise(0x0),
164 fTOFCalOnlineHW(0x0),
0a749fa5 165 fTOFCalOffline(0x0),
17149e6b 166 fCal(calib.fCal),
167 fStatus(calib.fStatus),
0a749fa5 168 fTOFSimToT(calib.fTOFSimToT),
169 fkValidity(calib.fkValidity),
170 fTree(calib.fTree),
296591ad 171 fChain(calib.fChain),
0cb9d099 172 fNruns(calib.fNruns),
173 fFirstRun(calib.fFirstRun),
17149e6b 174 fLastRun(calib.fLastRun),
2bf4d9d6 175 fConfigMap(calib.fConfigMap),
176 fDeltaBCOffset(NULL),
177 fCTPLatency(NULL),
f04b3a69 178 fT0Fill(NULL),
179 fRunParams(NULL)
6dc9348d 180{
340693af 181 //TOF Calibration Class copy ctor
0a749fa5 182 for (Int_t iarray = 0; iarray<fNChannels; iarray++){
183 AliTOFChannelOnline * calChOnline = (AliTOFChannelOnline*)calib.fTOFCalOnline->At(iarray);
7fffa85b 184 AliTOFChannelOnlineStatus * calChOnlineStPulser = (AliTOFChannelOnlineStatus*)calib.fTOFCalOnlinePulser->At(iarray);
185 AliTOFChannelOnlineStatus * calChOnlineStNoise = (AliTOFChannelOnlineStatus*)calib.fTOFCalOnlineNoise->At(iarray);
186 AliTOFChannelOnlineStatus * calChOnlineStHW = (AliTOFChannelOnlineStatus*)calib.fTOFCalOnlineHW->At(iarray);
0a749fa5 187 AliTOFChannelOffline * calChOffline = (AliTOFChannelOffline*)calib.fTOFCalOffline->At(iarray);
188 fTOFCalOnline->AddAt(calChOnline,iarray);
7fffa85b 189 fTOFCalOnlinePulser->AddAt(calChOnlineStPulser,iarray);
190 fTOFCalOnlineNoise->AddAt(calChOnlineStNoise,iarray);
191 fTOFCalOnlineHW->AddAt(calChOnlineStHW,iarray);
0a749fa5 192 fTOFCalOffline->AddAt(calChOffline,iarray);
0a749fa5 193 }
2bf4d9d6 194
195 if (calib.fDeltaBCOffset) fDeltaBCOffset = new AliTOFDeltaBCOffset(*calib.fDeltaBCOffset);
196 if (calib.fCTPLatency) fCTPLatency = new AliTOFCTPLatency(*calib.fCTPLatency);
197 if (calib.fT0Fill) fT0Fill = new AliTOFT0Fill(*calib.fT0Fill);
f04b3a69 198 if (calib.fRunParams) fRunParams = new AliTOFRunParams(*calib.fRunParams);
6dc9348d 199}
200
201//____________________________________________________________________________
7aeeaf38 202
203AliTOFcalib& AliTOFcalib::operator=(const AliTOFcalib &calib)
204{
205 //TOF Calibration Class assignment operator
8a190ba2 206
207 if (this == &calib)
208 return *this;
209
210 TTask::operator=(calib);
211 fNChannels = calib.fNChannels;
212 fCal = calib.fCal;
213 fStatus = calib.fStatus;
214 fTOFSimToT = calib.fTOFSimToT;
215 fkValidity = calib.fkValidity;
216 fTree = calib.fTree;
217 fChain = calib.fChain;
218 fNruns = calib.fNruns;
219 fFirstRun = calib.fFirstRun;
220 fLastRun = calib.fLastRun;
0a749fa5 221 for (Int_t iarray = 0; iarray<fNChannels; iarray++){
222 AliTOFChannelOnline * calChOnline = (AliTOFChannelOnline*)calib.fTOFCalOnline->At(iarray);
223 AliTOFChannelOffline * calChOffline = (AliTOFChannelOffline*)calib.fTOFCalOffline->At(iarray);
7fffa85b 224 AliTOFChannelOnlineStatus * calChOnlineStPulser = (AliTOFChannelOnlineStatus*)calib.fTOFCalOnlinePulser->At(iarray);
225 AliTOFChannelOnlineStatus * calChOnlineStNoise = (AliTOFChannelOnlineStatus*)calib.fTOFCalOnlineNoise->At(iarray);
226 AliTOFChannelOnlineStatus * calChOnlineStHW = (AliTOFChannelOnlineStatus*)calib.fTOFCalOnlineHW->At(iarray);
8a190ba2 227 fTOFCalOnline->AddAt(calChOnline,iarray);
228 fTOFCalOnlinePulser->AddAt(calChOnlineStPulser,iarray);
229 fTOFCalOnlineNoise->AddAt(calChOnlineStNoise,iarray);
230 fTOFCalOnlineHW->AddAt(calChOnlineStHW,iarray);
231 fTOFCalOffline->AddAt(calChOffline,iarray);
0a749fa5 232 }
2bf4d9d6 233
234 if (calib.fDeltaBCOffset) {
235 if (fDeltaBCOffset) *fDeltaBCOffset = *calib.fDeltaBCOffset;
236 else fDeltaBCOffset = new AliTOFDeltaBCOffset(*calib.fDeltaBCOffset);
237 }
238
239 if (calib.fCTPLatency) {
240 if (fCTPLatency) *fCTPLatency = *calib.fCTPLatency;
241 else fCTPLatency = new AliTOFCTPLatency(*calib.fCTPLatency);
242 }
243
244 if (calib.fT0Fill) {
245 if (fT0Fill) *fT0Fill = *calib.fT0Fill;
246 else fT0Fill = new AliTOFT0Fill(*calib.fT0Fill);
247 }
f04b3a69 248 if (calib.fRunParams) {
249 if (fRunParams) *fRunParams = *calib.fRunParams;
250 else fRunParams = new AliTOFRunParams(*calib.fRunParams);
251 }
2bf4d9d6 252
7aeeaf38 253 return *this;
254}
255
256//____________________________________________________________________________
6dc9348d 257
258AliTOFcalib::~AliTOFcalib()
259{
340693af 260 //TOF Calibration Class dtor
5eaae242 261 if(!(AliCDBManager::Instance()->GetCacheFlag())){ // CDB objects must NOT be deleted if cache is active!
0a749fa5 262 if (fTOFCalOnline){
0a749fa5 263 delete fTOFCalOnline;
6dc9348d 264 }
7fffa85b 265 if (fTOFCalOnlinePulser){
266 delete fTOFCalOnlinePulser;
267 }
268 if (fTOFCalOnlineNoise){
269 delete fTOFCalOnlineNoise;
270 }
271 if (fTOFCalOnlineHW){
272 delete fTOFCalOnlineHW;
273 }
0a749fa5 274 if (fTOFCalOffline){
0a749fa5 275 delete fTOFCalOffline;
6dc9348d 276 }
17149e6b 277 if (fCal){
278 delete fCal;
279 }
280 if (fStatus){
281 delete fStatus;
282 }
283 if (fConfigMap){
284 delete fConfigMap;
285 }
2bf4d9d6 286 if (fDeltaBCOffset) delete fDeltaBCOffset;
287 if (fCTPLatency) delete fCTPLatency;
288 if (fT0Fill) delete fT0Fill;
f04b3a69 289 if (fRunParams) delete fRunParams;
6dc9348d 290 }
0a749fa5 291 if (fTree!=0x0) delete fTree;
296591ad 292 if (fChain!=0x0) delete fChain;
2bf4d9d6 293
6dc9348d 294}
295//_____________________________________________________________________________
0a749fa5 296void AliTOFcalib::CreateCalArrays(){
6dc9348d 297
0a749fa5 298 // creating arrays for online/offline calibration objs
6dc9348d 299
0a749fa5 300 fTOFCalOnline = new TObjArray(fNChannels);
7fffa85b 301 fTOFCalOnlinePulser = new TObjArray(fNChannels);
302 fTOFCalOnlineNoise = new TObjArray(fNChannels);
303 fTOFCalOnlineHW = new TObjArray(fNChannels);
0a749fa5 304 fTOFCalOffline = new TObjArray(fNChannels);
305 fTOFCalOnline->SetOwner();
7fffa85b 306 fTOFCalOnlinePulser->SetOwner();
307 fTOFCalOnlineNoise->SetOwner();
308 fTOFCalOnlineHW->SetOwner();
0a749fa5 309 fTOFCalOffline->SetOwner();
310 for (Int_t iarray = 0; iarray<fNChannels; iarray++){
311 AliTOFChannelOnline * calChOnline = new AliTOFChannelOnline();
7fffa85b 312 AliTOFChannelOnlineStatus * calChOnlineStPulser = new AliTOFChannelOnlineStatus();
313 AliTOFChannelOnlineStatus * calChOnlineStNoise = new AliTOFChannelOnlineStatus();
314 AliTOFChannelOnlineStatus * calChOnlineStHW = new AliTOFChannelOnlineStatus();
0a749fa5 315 AliTOFChannelOffline * calChOffline = new AliTOFChannelOffline();
316 fTOFCalOnline->AddAt(calChOnline,iarray);
7fffa85b 317 fTOFCalOnlinePulser->AddAt(calChOnlineStPulser,iarray);
318 fTOFCalOnlineNoise->AddAt(calChOnlineStNoise,iarray);
319 fTOFCalOnlineHW->AddAt(calChOnlineStHW,iarray);
0a749fa5 320 fTOFCalOffline->AddAt(calChOffline,iarray);
6dc9348d 321 }
17149e6b 322 fCal = new AliTOFChannelOnlineArray(fNChannels);
323 fStatus = new AliTOFChannelOnlineStatusArray(fNChannels);
324}
325//_____________________________________________________________________________
24d1e16e 326void AliTOFcalib::CreateCalObjects(){
327
328 // creating arrays for online/offline calibration objs
329
330 fTOFCalOffline = new TObjArray(fNChannels);
331 fTOFCalOffline->SetOwner();
332 for (Int_t iarray = 0; iarray<fNChannels; iarray++){
333 AliTOFChannelOffline * calChOffline = new AliTOFChannelOffline();
334 fTOFCalOffline->AddAt(calChOffline,iarray);
335 }
336 fCal = new AliTOFChannelOnlineArray(fNChannels);
337 fStatus = new AliTOFChannelOnlineStatusArray(fNChannels);
338}
339//_____________________________________________________________________________
a6e0ebfe 340void AliTOFcalib::WriteConfigMapOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun)
17149e6b 341{
342 //Write calibration parameters to the CDB
343 SetFirstRun(minrun);
344 SetLastRun(maxrun);
345 AliCDBManager *man = AliCDBManager::Instance();
a6e0ebfe 346 const Char_t *sel1 = "Config" ; // to be consistent with TOFPreprocessor
17149e6b 347 Char_t out[100];
348 sprintf(out,"%s/%s",sel,sel1);
349 AliDebug(2,Form("Writing TOF configuration map for online calib on CDB with run range [%i, %i] ",fFirstRun,fLastRun));
350 AliCDBId id(out,fFirstRun,fLastRun);
351 AliCDBMetaData *md = new AliCDBMetaData();
352 md->SetResponsible("Chiara Zampolli");
353 if (!fConfigMap) {
354 // deve uscire!!
355 }
356 man->Put(fConfigMap,id,md);
357 delete md;
358}
359//_____________________________________________________________________________
360
a6e0ebfe 361void AliTOFcalib::WriteConfigMapOnCDB(const Char_t *sel)
17149e6b 362{
363 //Write calibration parameters to the CDB with infinite validity
364 AliCDBManager *man = AliCDBManager::Instance();
a6e0ebfe 365 const Char_t *sel1 = "Config" ; // to be consistent with TOFPreprocessor
17149e6b 366 Char_t out[100];
367 sprintf(out,"%s/%s",sel,sel1);
368 AliCDBRunRange runrange(fFirstRun,fLastRun);
369 AliDebug(2,Form("Writing TOF config map for online calib on CDB with run range [%i, %i] ",runrange.GetFirstRun(),runrange.GetLastRun()));
370 AliCDBId id(out,runrange);
371 AliCDBMetaData *md = new AliCDBMetaData();
372 md->SetResponsible("Chiara Zampolli");
373 if (!fConfigMap) {
374 // deve uscire!!
375 }
376 man->Put(fConfigMap,id,md);
377 delete md;
378}
379//_____________________________________________________________________________
a6e0ebfe 380void AliTOFcalib::WriteParOnlineDelayOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun)
17149e6b 381{
382 //Write calibration parameters to the CDB -------> new calib objs!!!!!
383 SetFirstRun(minrun);
384 SetLastRun(maxrun);
385 AliCDBManager *man = AliCDBManager::Instance();
a6e0ebfe 386 const Char_t *sel1 = "ParOnlineDelay" ; // to be consistent with TOFPreprocessor
17149e6b 387 Char_t out[100];
388 sprintf(out,"%s/%s",sel,sel1);
389 AliDebug(2,Form("Writing TOF online calib obj on CDB with run range [%i, %i] ",fFirstRun,fLastRun));
390 AliCDBId id(out,fFirstRun,fLastRun);
391 AliCDBMetaData *md = new AliCDBMetaData();
392 md->SetResponsible("Chiara Zampolli");
393 if (!fCal) {
394 // deve uscire!!
395 }
396 man->Put(fCal,id,md);
397 delete md;
398}
399//_____________________________________________________________________________
a6e0ebfe 400void AliTOFcalib::WriteParOnlineStatusOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun)
17149e6b 401{
402 //Write calibration parameters to the CDB -------> new calib objs!!!!!
403 SetFirstRun(minrun);
404 SetLastRun(maxrun);
405 AliCDBManager *man = AliCDBManager::Instance();
a6e0ebfe 406 const Char_t *sel1 = "Status" ; // to be consistent with TOFPreprocessor
17149e6b 407 Char_t out[100];
408 sprintf(out,"%s/%s",sel,sel1);
409 AliDebug(2,Form("Writing TOF online status calib obj on CDB with run range [%i, %i] ",fFirstRun,fLastRun));
410 AliCDBId id(out,fFirstRun,fLastRun);
411 AliCDBMetaData *md = new AliCDBMetaData();
412 md->SetResponsible("Chiara Zampolli");
413 if (!fStatus) {
414 // deve uscire!!
415 }
416 man->Put(fStatus,id,md);
417 delete md;
418}
419//_____________________________________________________________________________
420
a6e0ebfe 421void AliTOFcalib::WriteParOnlineDelayOnCDB(const Char_t *sel)
17149e6b 422{
423 //Write calibration parameters to the CDB with infinite validity -------> new calib objs!!!!!
424 AliCDBManager *man = AliCDBManager::Instance();
a6e0ebfe 425 const Char_t *sel1 = "ParOnlineDelay" ; // to be consistent with TOFPreprocessor
17149e6b 426 Char_t out[100];
427 sprintf(out,"%s/%s",sel,sel1);
428 AliCDBRunRange runrange(fFirstRun,fLastRun);
429 AliDebug(2,Form("Writing TOF online calib obj on CDB with run range [%i, %i] ",runrange.GetFirstRun(),runrange.GetLastRun()));
430 AliCDBId id(out,runrange);
431 AliCDBMetaData *md = new AliCDBMetaData();
432 md->SetResponsible("Chiara Zampolli");
433 if (!fCal) {
434 // deve uscire!!
435 }
436 man->Put(fCal,id,md);
437 delete md;
438}
439//_____________________________________________________________________________
440
a6e0ebfe 441void AliTOFcalib::WriteParOnlineStatusOnCDB(const Char_t *sel)
17149e6b 442{
443 //Write calibration parameters to the CDB with infinite validity -------> new calib objs!!!!!
444 AliCDBManager *man = AliCDBManager::Instance();
a6e0ebfe 445 const Char_t *sel1 = "Status" ; // to be consistent with TOFPreprocessor
17149e6b 446 Char_t out[100];
447 sprintf(out,"%s/%s",sel,sel1);
448 AliCDBRunRange runrange(fFirstRun,fLastRun);
449 AliDebug(2,Form("Writing TOF online status calib obj on CDB with run range [%i, %i] ",runrange.GetFirstRun(),runrange.GetLastRun()));
450 AliCDBId id(out,runrange);
451 AliCDBMetaData *md = new AliCDBMetaData();
452 md->SetResponsible("Chiara Zampolli");
453 if (!fStatus) {
454 // deve uscire!!
455 }
456 man->Put(fStatus,id,md);
457 delete md;
6dc9348d 458}
459//_____________________________________________________________________________
a6e0ebfe 460void AliTOFcalib::WriteParOnlineOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun)
340693af 461{
462 //Write calibration parameters to the CDB
0cb9d099 463 SetFirstRun(minrun);
464 SetLastRun(maxrun);
6dc9348d 465 AliCDBManager *man = AliCDBManager::Instance();
a6e0ebfe 466 const Char_t *sel1 = "ParOnline" ; // to be consistent with TOFPreprocessor
d4ad0d6b 467 Char_t out[100];
468 sprintf(out,"%s/%s",sel,sel1);
0cb9d099 469 AliDebug(2,Form("Writing TOF online calib obj on CDB with run range [%i, %i] ",fFirstRun,fLastRun));
470 AliCDBId id(out,fFirstRun,fLastRun);
471 AliCDBMetaData *md = new AliCDBMetaData();
472 md->SetResponsible("Chiara Zampolli");
473 if (!fTOFCalOnline) {
474 // deve uscire!!
475 }
476 man->Put(fTOFCalOnline,id,md);
477 delete md;
478}
479//_____________________________________________________________________________
a6e0ebfe 480void AliTOFcalib::WriteParOnlinePulserOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun)
7fffa85b 481{
482 //Write calibration parameters from pulser to the CDB
483 SetFirstRun(minrun);
484 SetLastRun(maxrun);
485 AliCDBManager *man = AliCDBManager::Instance();
a6e0ebfe 486 const Char_t *sel1 = "Pulser" ; // to be consistent with TOFPreprocessor
7fffa85b 487 Char_t out[100];
488 sprintf(out,"%s/%s",sel,sel1);
489 AliDebug(2,Form("Writing TOF online calib obj from pulser on CDB with run range [%i, %i] ",fFirstRun,fLastRun));
490 AliCDBId id(out,fFirstRun,fLastRun);
491 AliCDBMetaData *md = new AliCDBMetaData();
492 md->SetResponsible("Chiara Zampolli");
493 if (!fTOFCalOnlinePulser) {
494 // deve uscire!!
495 }
496 man->Put(fTOFCalOnlinePulser,id,md);
497 delete md;
498}
499//_____________________________________________________________________________
a6e0ebfe 500void AliTOFcalib::WriteParOnlineNoiseOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun)
7fffa85b 501{
502 //Write calibration parameters from noise to the CDB
503 SetFirstRun(minrun);
504 SetLastRun(maxrun);
505 AliCDBManager *man = AliCDBManager::Instance();
a6e0ebfe 506 const Char_t *sel1 = "Noise" ; // to be consistent with TOFPreprocessor
7fffa85b 507 Char_t out[100];
508 sprintf(out,"%s/%s",sel,sel1);
509 AliDebug(2,Form("Writing TOF online calib obj from noise on CDB with run range [%i, %i] ",fFirstRun,fLastRun));
510 AliCDBId id(out,fFirstRun,fLastRun);
511 AliCDBMetaData *md = new AliCDBMetaData();
512 md->SetResponsible("Chiara Zampolli");
513 if (!fTOFCalOnlineNoise) {
514 // deve uscire!!
515 }
516 man->Put(fTOFCalOnlineNoise,id,md);
517 delete md;
518}
519//_____________________________________________________________________________
a6e0ebfe 520void AliTOFcalib::WriteParOnlineHWOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun)
7fffa85b 521{
522 //Write calibration parameters from hardware to the CDB
523 SetFirstRun(minrun);
524 SetLastRun(maxrun);
525 AliCDBManager *man = AliCDBManager::Instance();
a6e0ebfe 526 const Char_t *sel1 = "HW" ; // to be consistent with TOFPreprocessor
7fffa85b 527 Char_t out[100];
528 sprintf(out,"%s/%s",sel,sel1);
529 AliDebug(2,Form("Writing TOF online calib obj from hardware on CDB with run range [%i, %i] ",fFirstRun,fLastRun));
530 AliCDBId id(out,fFirstRun,fLastRun);
531 AliCDBMetaData *md = new AliCDBMetaData();
532 md->SetResponsible("Chiara Zampolli");
533 if (!fTOFCalOnlineHW) {
534 // deve uscire!!
535 }
536 man->Put(fTOFCalOnlineHW,id,md);
537 delete md;
538}
539//_____________________________________________________________________________
0cb9d099 540
a6e0ebfe 541void AliTOFcalib::WriteParOnlineOnCDB(const Char_t *sel)
0cb9d099 542{
543 //Write calibration parameters to the CDB with infinite validity
544 AliCDBManager *man = AliCDBManager::Instance();
a6e0ebfe 545 const Char_t *sel1 = "ParOnline" ; // to be consistent with TOFPreprocessor
0cb9d099 546 Char_t out[100];
547 sprintf(out,"%s/%s",sel,sel1);
548 AliCDBRunRange runrange(fFirstRun,fLastRun);
549 AliDebug(2,Form("Writing TOF online calib obj on CDB with run range [%i, %i] ",runrange.GetFirstRun(),runrange.GetLastRun()));
550 AliCDBId id(out,runrange);
6dc9348d 551 AliCDBMetaData *md = new AliCDBMetaData();
d4ad0d6b 552 md->SetResponsible("Chiara Zampolli");
0a749fa5 553 if (!fTOFCalOnline) {
554 // deve uscire!!
85fc78e3 555 }
0a749fa5 556 man->Put(fTOFCalOnline,id,md);
5eaae242 557 delete md;
6dc9348d 558}
559//_____________________________________________________________________________
560
a6e0ebfe 561void AliTOFcalib::WriteParOnlinePulserOnCDB(const Char_t *sel)
7fffa85b 562{
563 //Write calibration parameters from pulser to the CDB with infinite validity
564 AliCDBManager *man = AliCDBManager::Instance();
a6e0ebfe 565 const Char_t *sel1 = "Pulser" ; // to be consistent with TOFPreprocessor
7fffa85b 566 Char_t out[100];
567 sprintf(out,"%s/%s",sel,sel1);
568 AliCDBRunRange runrange(fFirstRun,fLastRun);
569 AliDebug(2,Form("Writing TOF online calib obj from pulser on CDB with run range [%i, %i] ",runrange.GetFirstRun(),runrange.GetLastRun()));
570 AliCDBId id(out,runrange);
571 AliCDBMetaData *md = new AliCDBMetaData();
572 md->SetResponsible("Chiara Zampolli");
573 if (!fTOFCalOnlinePulser) {
574 // deve uscire!!
575 }
576 man->Put(fTOFCalOnlinePulser,id,md);
577 delete md;
578}
579//_____________________________________________________________________________
580
a6e0ebfe 581void AliTOFcalib::WriteParOnlineNoiseOnCDB(const Char_t *sel)
7fffa85b 582{
583 //Write calibration parameters from noise to the CDB with infinite validity
584 AliCDBManager *man = AliCDBManager::Instance();
a6e0ebfe 585 const Char_t *sel1 = "Noise" ; // to be consistent with TOFPreprocessor
7fffa85b 586 Char_t out[100];
587 sprintf(out,"%s/%s",sel,sel1);
588 AliCDBRunRange runrange(fFirstRun,fLastRun);
589 AliDebug(2,Form("Writing TOF online calib obj from noise on CDB with run range [%i, %i] ",runrange.GetFirstRun(),runrange.GetLastRun()));
590 AliCDBId id(out,runrange);
591 AliCDBMetaData *md = new AliCDBMetaData();
592 md->SetResponsible("Chiara Zampolli");
593 if (!fTOFCalOnlineNoise) {
594 // deve uscire!!
595 }
596 man->Put(fTOFCalOnlineNoise,id,md);
597 delete md;
598}
599//_____________________________________________________________________________
600
a6e0ebfe 601void AliTOFcalib::WriteParOnlineHWOnCDB(const Char_t *sel)
7fffa85b 602{
603 //Write calibration parameters from hardware to the CDB with infinite validity
604 AliCDBManager *man = AliCDBManager::Instance();
a6e0ebfe 605 const Char_t *sel1 = "HW" ; // to be consistent with TOFPreprocessor
7fffa85b 606 Char_t out[100];
607 sprintf(out,"%s/%s",sel,sel1);
608 AliCDBRunRange runrange(fFirstRun,fLastRun);
609 AliDebug(2,Form("Writing TOF online calib obj from harware on CDB with run range [%i, %i] ",runrange.GetFirstRun(),runrange.GetLastRun()));
610 AliCDBId id(out,runrange);
611 AliCDBMetaData *md = new AliCDBMetaData();
612 md->SetResponsible("Chiara Zampolli");
613 if (!fTOFCalOnlineHW) {
614 // deve uscire!!
615 }
616 man->Put(fTOFCalOnlineHW,id,md);
617 delete md;
618}
619//_____________________________________________________________________________
620
a6e0ebfe 621void AliTOFcalib::WriteParOfflineOnCDB(const Char_t *sel, const Char_t *validity, Int_t minrun, Int_t maxrun)
0a749fa5 622{
340693af 623 //Write calibration parameters to the CDB
0cb9d099 624 SetFirstRun(minrun);
625 SetLastRun(maxrun);
6dc9348d 626 AliCDBManager *man = AliCDBManager::Instance();
a6e0ebfe 627 const Char_t *sel1 = "ParOffline" ;
d4ad0d6b 628 Char_t out[100];
629 sprintf(out,"%s/%s",sel,sel1);
0cb9d099 630 AliDebug(2,Form("Writing TOF offline calib obj on CDB with run range [%i, %i] ",fFirstRun,fLastRun));
631 AliCDBId id(out,fFirstRun,fLastRun);
632 AliCDBMetaData *md = new AliCDBMetaData();
633 md->SetResponsible("Chiara Zampolli");
634 md->SetComment(validity);
635 man->Put(fTOFCalOffline,id,md);
636 delete md;
637}
638//_____________________________________________________________________________
639
a6e0ebfe 640void AliTOFcalib::WriteParOfflineOnCDB(const Char_t *sel, const Char_t *validity)
0cb9d099 641{
642 //Write calibration parameters to the CDB with infinite validity
643 AliCDBManager *man = AliCDBManager::Instance();
a6e0ebfe 644 const Char_t *sel1 = "ParOffline" ;
0cb9d099 645 Char_t out[100];
646 sprintf(out,"%s/%s",sel,sel1);
647 AliCDBRunRange runrange(fFirstRun,fLastRun);
648 AliDebug(2,Form("Writing TOF offline calib obj on CDB with run range [%i, %i] ",runrange.GetFirstRun(),runrange.GetLastRun()));
649 AliCDBId id(out,runrange);
d4ad0d6b 650 AliCDBMetaData *md = new AliCDBMetaData();
651 md->SetResponsible("Chiara Zampolli");
0a749fa5 652 md->SetComment(validity);
653 man->Put(fTOFCalOffline,id,md);
5eaae242 654 delete md;
d4ad0d6b 655}
656//_____________________________________________________________________________
657
a6e0ebfe 658Bool_t AliTOFcalib::ReadConfigMapFromCDB(const Char_t *sel, Int_t nrun)
17149e6b 659{
660 //Read calibration parameters from the CDB
661 AliCDBManager *man = AliCDBManager::Instance();
a6e0ebfe 662 const Char_t *sel1 = "Config" ;
17149e6b 663 Char_t out[100];
664 sprintf(out,"%s/%s",sel,sel1);
665 AliCDBEntry *entry = man->Get(out,nrun);
666 if (!entry) {
667 AliFatal("Exiting, no CDB object (ConfigMap) found!!!");
668 exit(0);
669 }
670 if(!entry->GetObject()){
671 AliFatal("Exiting, no CDB object (ConfigMap) found!!!");
672 exit(0);
673 }
674
675 fConfigMap =(TMap*)entry->GetObject();
676
677 return kTRUE;
678
679}
680//_____________________________________________________________________________
681
a6e0ebfe 682Bool_t AliTOFcalib::ReadParOnlineDelayFromCDB(const Char_t *sel, Int_t nrun)
17149e6b 683{
684 //Read calibration parameters from the CDB -------> new calib objs!!!!!
685 AliCDBManager *man = AliCDBManager::Instance();
a6e0ebfe 686 const Char_t *sel1 = "ParOnlineDelay" ;
17149e6b 687 Char_t out[100];
688 sprintf(out,"%s/%s",sel,sel1);
689 AliCDBEntry *entry = man->Get(out,nrun);
690 if (!entry) {
691 AliFatal("Exiting, no CDB object (ParOnlineDelay) found!!!");
692 exit(0);
693 }
694 if(!entry->GetObject()){
695 AliFatal("Exiting, no CDB object (ParOnlineDelay) found!!!");
696 exit(0);
697 }
698
699 fCal =(AliTOFChannelOnlineArray*)entry->GetObject();
700
701 return kTRUE;
702
703}
704//_____________________________________________________________________________
705
a6e0ebfe 706Bool_t AliTOFcalib::ReadParOnlineStatusFromCDB(const Char_t *sel, Int_t nrun)
17149e6b 707{
708 //Read calibration parameters from the CDB -------> new calib objs!!!!!
709 AliCDBManager *man = AliCDBManager::Instance();
a6e0ebfe 710 const Char_t *sel1 = "Status" ;
17149e6b 711 Char_t out[100];
712 sprintf(out,"%s/%s",sel,sel1);
713 AliCDBEntry *entry = man->Get(out,nrun);
714 if (!entry) {
715 AliFatal("Exiting, no CDB object (Status) found!!!");
716 exit(0);
717 }
718 if(!entry->GetObject()){
719 AliFatal("Exiting, no CDB object (Status) found!!!");
720 exit(0);
721 }
722
723 fStatus =(AliTOFChannelOnlineStatusArray*)entry->GetObject();
724
725 return kTRUE;
726
727}
728//_____________________________________________________________________________
729
a6e0ebfe 730Bool_t AliTOFcalib::ReadParOnlineFromCDB(const Char_t *sel, Int_t nrun)
340693af 731{
732 //Read calibration parameters from the CDB
d4ad0d6b 733 AliCDBManager *man = AliCDBManager::Instance();
a6e0ebfe 734 const Char_t *sel1 = "ParOnline" ;
d4ad0d6b 735 Char_t out[100];
736 sprintf(out,"%s/%s",sel,sel1);
7a4f634e 737 AliCDBEntry *entry = man->Get(out,nrun);
c30c0a38 738 if (!entry) {
739 AliFatal("Exiting, no CDB object (ParOnline) found!!!");
740 exit(0);
741 }
7a4f634e 742 if(!entry->GetObject()){
c30c0a38 743 AliFatal("Exiting, no CDB object (ParOnline) found!!!");
744 exit(0);
7a4f634e 745 }
746
0a749fa5 747 fTOFCalOnline =(TObjArray*)entry->GetObject();
7fffa85b 748
749 return kTRUE;
750
751}
752//_____________________________________________________________________________
753
a6e0ebfe 754Bool_t AliTOFcalib::ReadParOnlinePulserFromCDB(const Char_t *sel, Int_t nrun)
7fffa85b 755{
756 //Read calibration parameters from pulser from the CDB
757 AliCDBManager *man = AliCDBManager::Instance();
a6e0ebfe 758 const Char_t *sel1 = "Pulser" ;
7fffa85b 759 Char_t out[100];
760 sprintf(out,"%s/%s",sel,sel1);
7fffa85b 761 AliCDBEntry *entry = man->Get(out,nrun);
c30c0a38 762 if (!entry) {
763 AliFatal("Exiting, no CDB object (Pulser) found!!!");
764 exit(0);
765 }
7fffa85b 766 if(!entry->GetObject()){
c30c0a38 767 AliFatal("Exiting, no CDB object (Pulser) found!!!");
768 exit(0);
7fffa85b 769 }
770
771 fTOFCalOnlinePulser =(TObjArray*)entry->GetObject();
772
773 return kTRUE;
774
775}
776//_____________________________________________________________________________
777
a6e0ebfe 778Bool_t AliTOFcalib::ReadParOnlineNoiseFromCDB(const Char_t *sel, Int_t nrun)
7fffa85b 779{
780 //Read calibration parameters from noise from the CDB
781 AliCDBManager *man = AliCDBManager::Instance();
a6e0ebfe 782 const Char_t *sel1 = "Noise" ;
7fffa85b 783 Char_t out[100];
784 sprintf(out,"%s/%s",sel,sel1);
7fffa85b 785 AliCDBEntry *entry = man->Get(out,nrun);
c30c0a38 786 if (!entry) {
787 AliFatal("Exiting, no CDB object (Noise) found!!!");
788 exit(0);
789 }
7fffa85b 790 if(!entry->GetObject()){
c30c0a38 791 AliFatal("Exiting, no CDB object (Noise) found!!!");
792 exit(0);
7fffa85b 793 }
794
795 fTOFCalOnlineNoise =(TObjArray*)entry->GetObject();
796
797 return kTRUE;
798
799}
800//_____________________________________________________________________________
801
a6e0ebfe 802Bool_t AliTOFcalib::ReadParOnlineHWFromCDB(const Char_t *sel, Int_t nrun)
7fffa85b 803{
804 //Read calibration parameters from hardware from the CDB
805 AliCDBManager *man = AliCDBManager::Instance();
a6e0ebfe 806 const Char_t *sel1 = "HW" ;
7fffa85b 807 Char_t out[100];
808 sprintf(out,"%s/%s",sel,sel1);
7fffa85b 809 AliCDBEntry *entry = man->Get(out,nrun);
c30c0a38 810 if (!entry) {
811 AliFatal("Exiting, no CDB object (HW map) found!!!");
812 exit(0);
813 }
7fffa85b 814 if(!entry->GetObject()){
c30c0a38 815 AliFatal("Exiting, no CDB object (HW map) found!!!");
816 exit(0);
7fffa85b 817 }
818
819 fTOFCalOnlineHW =(TObjArray*)entry->GetObject();
0a749fa5 820
1b20c168 821 return kTRUE;
7a4f634e 822
6dc9348d 823}
824//_____________________________________________________________________________
d4ad0d6b 825
a6e0ebfe 826Bool_t AliTOFcalib::ReadParOfflineFromCDB(const Char_t *sel, Int_t nrun)
0a749fa5 827{
828 //Read calibration parameters from the CDB
829 AliCDBManager *man = AliCDBManager::Instance();
a6e0ebfe 830 const Char_t *sel1 = "ParOffline" ;
0a749fa5 831 Char_t out[100];
832 sprintf(out,"%s/%s",sel,sel1);
0a749fa5 833 AliCDBEntry *entry = man->Get(out,nrun);
c30c0a38 834 if (!entry) {
835 AliFatal("Exiting, no CDB object (ParOffline) found!!!");
836 exit(0);
837 }
0a749fa5 838 if(!entry->GetObject()){
c30c0a38 839 AliFatal("Exiting, no CDB object (ParOffline) found!!!");
840 exit(0);
0a749fa5 841 }
842 AliCDBMetaData * md = entry->GetMetaData();
843 fkValidity = md->GetComment();
844 fTOFCalOffline =(TObjArray*)entry->GetObject();
d4ad0d6b 845
0a749fa5 846 return kTRUE;
847
848}
849//_____________________________________________________________________________
a6e0ebfe 850void AliTOFcalib::WriteSimHistoOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun, TH1F *histo){
340693af 851 //Write Sim miscalibration parameters to the CDB
d4ad0d6b 852
d4ad0d6b 853 fTOFSimToT=histo;
d4ad0d6b 854 AliCDBManager *man = AliCDBManager::Instance();
a6e0ebfe 855 const Char_t *sel1 = "SimHisto" ;
d4ad0d6b 856 Char_t out[100];
857 sprintf(out,"%s/%s",sel,sel1);
0a749fa5 858 AliCDBMetaData *mdhisto = new AliCDBMetaData();
859 mdhisto->SetResponsible("Chiara Zampolli");
40212801 860 AliCDBId id(out,minrun,maxrun);
861 man->Put(fTOFSimToT,id,mdhisto);
0a749fa5 862 delete mdhisto;
863}
864//_____________________________________________________________________________
a6e0ebfe 865Bool_t AliTOFcalib::ReadSimHistoFromCDB(const Char_t *sel, Int_t nrun)
0a749fa5 866{
867 //Read miscalibration parameters from the CDB
868 AliCDBManager *man = AliCDBManager::Instance();
869
40212801 870 // The Tot Histo
7a4f634e 871
a6e0ebfe 872 const Char_t *sel1 = "SimHisto" ;
d4ad0d6b 873 Char_t out[100];
874 sprintf(out,"%s/%s",sel,sel1);
c30c0a38 875 AliCDBEntry *entry = man->Get(out,nrun);
876 if (!entry) {
7a4f634e 877 AliFatal("Exiting, no CDB object (SimHisto) found!!!");
878 exit(0);
879 }
40212801 880 if(!entry->GetObject()){
7a4f634e 881 AliFatal("Exiting, no CDB object (SimHisto) found!!!");
882 exit(0);
883 }
40212801 884 TH1F *histo =(TH1F*)entry->GetObject();
d4ad0d6b 885 fTOFSimToT=histo;
52be7fb0 886 return kTRUE;
d4ad0d6b 887}
7037bd93 888//_____________________________________________________________________________
a6e0ebfe 889void AliTOFcalib::WriteRecParOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun, AliTOFRecoParam *param){
7037bd93 890 //Write reconstruction parameters to the CDB
891
892 AliCDBManager *man = AliCDBManager::Instance();
7037bd93 893 AliCDBMetaData *md = new AliCDBMetaData();
894 md->SetResponsible("Silvia Arcelli");
641168d2 895 const Char_t *sel1 = "RecoParam" ;
7037bd93 896 Char_t out[100];
897 sprintf(out,"%s/%s",sel,sel1);
898 AliCDBId id(out,minrun,maxrun);
899 man->Put(param,id,md);
900 delete md;
901}
902//_____________________________________________________________________________
a6e0ebfe 903AliTOFRecoParam * AliTOFcalib::ReadRecParFromCDB(const Char_t *sel, Int_t nrun)
7037bd93 904{
905 //Read reconstruction parameters from the CDB
906 AliCDBManager *man = AliCDBManager::Instance();
641168d2 907 const Char_t *sel1 = "RecoParam" ;
7037bd93 908 Char_t out[100];
909 sprintf(out,"%s/%s",sel,sel1);
c30c0a38 910 AliCDBEntry *entry = man->Get(out,nrun);
911 if (!entry) {
641168d2 912 AliFatal("Exiting, no CDB object (RecoParam) found!!!");
7a4f634e 913 exit(0);
914 }
7a4f634e 915 if(!entry->GetObject()){
641168d2 916 AliFatal("Exiting, no CDB object (RecoParam) found!!!");
7a4f634e 917 exit(0);
918 }
919
7037bd93 920 AliTOFRecoParam *param=(AliTOFRecoParam*)entry->GetObject();
921 return param;
922}
0a749fa5 923//-----------------------------------------------------------------------------
924// Calibration methods
925//-----------------------------------------------------------------------------
926void AliTOFcalib::CreateTreeFromCDB(Int_t minrun, Int_t maxrun){
927
928 // creating the chain with the trees for calibration
929 // collecting them from reference data
930 // from minrun to maxrun
931
932 Float_t p[CHENTRIESSMALL];
933 Int_t nentries;
934 fTree = new TTree("TOFCalib","Tree for TOF Calibration");
935 fTree->Branch("nentries",&nentries,"nentries/I");
936 fTree->Branch("TOFentries",p,"TOFentries[nentries]/F");
937 AliCDBManager *man = AliCDBManager::Instance();
162637e4 938 AliCDBStorage *aStorage = man->GetStorage("local://$ALICE_ROOT/OCDB");
0a749fa5 939 for (Int_t irun = minrun;irun<=maxrun;irun++){
940 AliCDBEntry *entry = aStorage->Get("TOF/RefData/TreeForCalib",irun);
941 if (!entry){
942 AliInfo(Form("No entry found for run %i",irun));
943 }
944 else{
945 TTree *tree = new TTree();
946 tree = (TTree*)entry->GetObject();
947 tree->SetBranchAddress("nentries",&nentries);
948 tree->SetBranchAddress("TOFentries",p);
949 fTree->CopyEntries(tree);
950 delete tree;
951 fNruns++;
952 }
953 }
954 AliInfo(Form("Number of runs being analyzed %i",fNruns));
955}
956//-----------------------------------------------------------------------------
957void AliTOFcalib::CreateTreeFromGrid(Int_t minrun, Int_t maxrun){
958
959 // creating the chain with the trees for calibration
960 // collecting them from the Grid
961 // from minrun to maxrun
962
963 Float_t p[CHENTRIESSMALL];
964 Int_t nentries;
965 fTree = new TTree("TOFCalib","Tree for TOF Calibration");
966 fTree->SetDirectory(0);
967 fTree->Branch("nentries",&nentries,"nentries/I");
968 fTree->Branch("TOFentries",p,"TOFentries[nentries]/F");
969 AliInfo("connected to alien");
970 TGrid::Connect("alien://");
971
972 Char_t filename[100];
973 for (Int_t irun = minrun;irun<=maxrun;irun++){
974 sprintf(filename,"alien:///alice/cern.ch/user/c/czampolli/TOFCalibReference_%i.root",irun);
975 TFile *filegrid = TFile::Open(filename,"READ");
976 TTree *tree = (TTree*)filegrid->Get("T");
977 tree->SetBranchAddress("nentries",&nentries);
978 tree->SetBranchAddress("TOFentries",p);
979 fTree->CopyEntries(tree);
980 delete tree;
981 fNruns++;
982 }
983
984 AliInfo(Form("Number of runs being analyzed %i",fNruns));
985}
986//-----------------------------------------------------------------------------
987void AliTOFcalib::CreateTreeFromFile(Int_t minrun, Int_t maxrun){
988
989 // creating the tree with the trees for calibration
990 // collecting them from reference data (from file)
991 // from minrun to maxrun
992
993 Float_t p[CHENTRIESSMALL];
994 Int_t nentries;
995 fTree = new TTree("TOFCalib","Tree for TOF Calibration");
996 fTree->SetDirectory(0);
997 fTree->Branch("nentries",&nentries,"nentries/I");
998 fTree->Branch("TOFentries",p,"TOFentries[nentries]/F");
999 Char_t filename[100];
1000 for (Int_t irun = minrun;irun<=maxrun;irun++){
1001 sprintf(filename,"$ALICE_ROOT/TOF/RefData/TreeForCalib/fileout_%i.root",irun);
1002 TFile *file = new TFile(filename,"READ");
1003 TTree *tree = (TTree*)file->Get("T");
1004 tree->SetBranchAddress("nentries",&nentries);
1005 tree->SetBranchAddress("TOFentries",p);
1006 fTree->CopyEntries(tree);
1007 delete tree;
1008 delete file;
1009 file = 0x0;
1010 fNruns++;
1011 }
1012
1013 AliInfo(Form("Number of runs being analyzed %i",fNruns));
1014}
1015//-----------------------------------------------------------------------------
296591ad 1016void AliTOFcalib::CreateChainFromGrid(Int_t minrun, Int_t maxrun){
1017
1018 // creating the chain with the trees for calibration
1019 // collecting them from the Grid
1020 // from minrun to maxrun
1021
1022 fChain = new TChain("T");
1023 AliInfo("connected to alien");
1024 TGrid::Connect("alien://");
1025
1026 Char_t filename[100];
1027 for (Int_t irun = minrun;irun<=maxrun;irun++){
1028 sprintf(filename,"alien:///alice/cern.ch/user/c/czampolli/TOFCalibReference_%i.root",irun);
1029 fChain->Add(filename);
1030 fNruns++;
1031 }
1032
1033 AliInfo(Form("Number of runs being analyzed %i",fNruns));
1034}
1035//-----------------------------------------------------------------------------
0a749fa5 1036Int_t AliTOFcalib::Calibrate(Int_t ichmin, Int_t ichmax, Option_t *optionSave, Option_t *optionFit){
7037bd93 1037
0a749fa5 1038 // calibrating summing more than one channels
1039 // computing calibration parameters
1040 // Returning codes:
1041 // 0 -> everything was ok
1042 // 1 -> no tree for calibration found
1043 // 2 -> not enough statistics to perform calibration
1044 // 3 -> problems with arrays
1045
1046 TH1::AddDirectory(0);
1047
1048 AliInfo(Form("*** Calibrating Histograms %s, summing more channels, from channel %i, to channel %i, storing Calib Pars in channel %i", GetName(),ichmin,ichmax,ichmin)) ;
1049 AliInfo(Form("Option for Saving histos = %s",optionSave )) ;
1050 AliInfo(Form("Option for Fitting Profile histos = %s",optionFit )) ;
1051
1052 Float_t p[CHENTRIESSMALL];
1053 Int_t nentries;
296591ad 1054 //fTree->SetBranchAddress("nentries",&nentries);
1055 //fTree->SetBranchAddress("TOFentries",p);
1056 fChain->SetBranchAddress("nentries",&nentries);
1057 fChain->SetBranchAddress("TOFentries",p);
0a749fa5 1058
1059 Float_t ntracksTotalmean =0;
1060 for (Int_t i=ichmin; i<ichmax; i++){
1061 Int_t ientry = -1;
1062 for (Int_t irun=0;irun<fNruns;irun++){
1063 ientry = i+irun*fNChannels;
296591ad 1064 //fTree->GetEntry(ientry);
1065 fChain->GetEntry(ientry);
0a749fa5 1066 Int_t ntracksRun=nentries/3;
1067 ntracksTotalmean+=ntracksRun;
1068 }
1069 }
1070
1071 if (ntracksTotalmean < MEANENTRIES) {
1072 AliInfo(Form(" Too small mean number of entires per channel (mean number = %f) not calibrating and exiting.....",ntracksTotalmean));
1073 return 2;
1074 }
1075
1076 //filling ToT and Time arrays
1077
1078 Int_t nbinToT = 100; // ToT bin width in Profile = 48.8 ps
1079 Float_t minToT = 0; // ns
1080 Float_t maxToT = 4.88; // ns
1081
1082 TH1F *hToT = new TH1F("htot","htot",nbinToT, minToT, maxToT);
1083 TH1F *hdeltaTime = new TH1F("hdeltaTime","hdeltaTime",200,2,4);
1084 Int_t ntracksTotal = 0;
1085 Int_t ntracksRun = 0;
1086 Double_t binsProfile[101]; // sized larger than necessary, the correct
1087 // dim being set in the booking of the profile
1088 Int_t nusefulbins=0;
1089 Float_t meantime=0;
1090 for (Int_t i = ichmin;i<ichmax;i++){
1091 Int_t ientry = -1;
1092 for (Int_t irun=0;irun<fNruns;irun++){
1093 ientry = i+irun*fNChannels;
296591ad 1094 //fTree->GetEntry(ientry);
1095 fChain->GetEntry(ientry);
0a749fa5 1096 ntracksTotal+=nentries/3;
1097 ntracksRun=nentries/3;
1098 AliDebug(2,Form("run %i, channel %i, nentries = %i, ntracks = %i",irun,i,nentries, ntracksRun));
1099 for (Int_t j=0;j<ntracksRun;j++){
1100 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
1101 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
1102 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
1103 Float_t tot = p[idxexToT];
1104 hdeltaTime->Fill(p[idxexTime]-p[idxexExTime]);
1105 meantime+=p[idxexTime]-p[idxexExTime];
1106 hToT->Fill(tot);
1107 }
1108 }
1109 }
1110 nusefulbins = FindBins(hToT,&binsProfile[0]);
1111 meantime/=ntracksTotal;
1112 AliDebug(2, Form("meantime = %f",meantime));
1113
1114 for (Int_t j=1;j<=nusefulbins;j++) {
1115 AliDebug(2,Form(" summing channels from %i to %i, nusefulbins = %i, bin %i = %f",ichmin,ichmax,nusefulbins,j,binsProfile[j]));
1116 }
1117
1118 TProfile* hSlewingProf = new TProfile("hSlewingProf", "hSlewingProf",nusefulbins, binsProfile, "G"); // CHECK THE BUILD OPTION, PLEASE!!!!!!
1119 TH2F * htimetot = new TH2F("htimetot","htimetot",nbinToT, minToT, maxToT,600,-5,10);
1120
1121 for (Int_t irun=0;irun<fNruns;irun++){
1122 Int_t ientry = -1;
1123 for (Int_t i=ichmin; i<ichmax; i++){
1124 ientry = i+irun*fNChannels;
296591ad 1125 //fTree->GetEntry(ientry);
1126 fChain->GetEntry(ientry);
0a749fa5 1127 ntracksRun=nentries/3;
1128 for (Int_t j=0;j<ntracksRun;j++){
1129 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
1130 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
1131 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
1132 Float_t tot = p[idxexToT];
1133 Float_t time = p[idxexTime]-p[idxexExTime];
1134 AliDebug (2, Form("track = %i, time = %f, tot = %f, time-meantime = %f",j,time, tot, time-meantime));
1135 hSlewingProf->Fill(tot,time); // if meantime is not used, the fill may be moved in the loop above
1136 htimetot->Fill(tot,time-meantime); // if meantime is not used, the fill may be moved in the loop above
1137 }
1138 }
1139 }
1140
1141 hSlewingProf->Fit("pol5",optionFit,"",0,4);
1142 TF1 * calibfunc = (TF1*)hSlewingProf->GetFunction("pol5");
1143 Float_t par[6];
1144 for(Int_t kk=0;kk<6;kk++){
1145 par[kk]=calibfunc->GetParameter(kk);
1146 AliDebug(2,Form("parameter %i = %f",kk,par[kk]));
1147 }
1148
1149 if(strstr(optionSave,"save")){
1150 TFile * fileProf = new TFile("TOFCalibSave.root","recreate");
1151 fileProf->cd();
1152 TString profName=Form("Profile%06i_%06i",ichmin,ichmax);
1153 TString timeTotName=Form("TimeTot%06i_%06i",ichmin,ichmax);
1154 TString totName=Form("Tot%06i_%06i",ichmin,ichmax);
1155 TString deltaName=Form("Delta%06i_%06i",ichmin,ichmax);
1156 hSlewingProf->Write(profName);
1157 htimetot->Write(timeTotName);
1158 hToT->Write(totName);
1159 hdeltaTime->Write(deltaName);
1160 fileProf->Close();
1161 delete fileProf;
1162 fileProf=0x0;
1163 }
1164
1165 delete hToT;
1166 hToT=0x0;
1167 delete hSlewingProf;
1168 hSlewingProf=0x0;
1169 delete htimetot;
1170 htimetot=0x0;
1171 delete hdeltaTime;
1172 hdeltaTime=0x0;
1173
1174 AliTOFChannelOffline * calChannel = (AliTOFChannelOffline*)fTOFCalOffline->At(ichmin);
1175 calChannel->SetSlewPar(par);
0cb9d099 1176 WriteParOfflineOnCDB("TOF/Calib","valid");
0a749fa5 1177 return 0;
1178}
1179//----------------------------------------------------------------------------
1180Int_t AliTOFcalib::Calibrate(Int_t i, Option_t *optionSave, Option_t *optionFit){
1181
1182 // computing calibration parameters for channel i
1183 // Returning codes:
1184 // 0 -> everything was ok
1185 // 1 -> no tree for calibration found
1186 // 2 -> not enough statistics to perform calibration
1187 // 3 -> problems with arrays
1188
1189 TH1::AddDirectory(0);
1190
1191 AliInfo(Form("*** Calibrating Histograms (one channel) %s", GetName())) ;
1192 AliInfo(Form("Option for Saving histos = %s",optionSave )) ;
1193 AliInfo(Form("Option for Fitting Profile histos = %s",optionFit )) ;
1194
1195 Float_t p[MAXCHENTRIESSMALL];
1196 Int_t nentries;
296591ad 1197 //fTree->SetBranchAddress("nentries",&nentries);
1198 //fTree->SetBranchAddress("TOFentries",p);
1199 fChain->SetBranchAddress("nentries",&nentries);
1200 fChain->SetBranchAddress("TOFentries",p);
0a749fa5 1201
1202 Float_t ntracksTotal =0;
1203 for (Int_t irun=0;irun<fNruns;irun++){
1204 Int_t ientry = -1;
1205 ientry = i+irun*fNChannels;
296591ad 1206 //fTree->GetEntry(ientry);
1207 fChain->GetEntry(ientry);
0a749fa5 1208 ntracksTotal+=nentries/3;
1209 }
1210
1211 if (ntracksTotal < MEANENTRIES) {
1212 AliInfo(Form(" Too small mean number of entires per channel (mean number = %f) not calibrating and exiting.....",ntracksTotal));
1213 return 2;
1214 }
1215
1216 //filling ToT and Time arrays
1217
1218 Int_t nbinToT = 100; // ToT bin width in Profile = 48.8 ps
1219 Float_t minToT = 0; // ns
1220 Float_t maxToT = 4.88; // ns
1221
1222 TH1F *hToT = new TH1F("htot","htot",nbinToT, minToT, maxToT);
1223 TH1F *hdeltaTime = new TH1F("hdeltaTime","hdeltaTime",200,2,4);
1224 Int_t ntracksRun = 0;
1225 Double_t binsProfile[101]; // sized larger than necessary, the correct
1226 // dim being set in the booking of the profile
1227 Int_t nusefulbins=0;
1228 Float_t meantime=0;
1229 for (Int_t irun=0;irun<fNruns;irun++){
1230 Int_t ientry = -1;
1231 ientry = i+irun*fNChannels;
296591ad 1232 //fTree->GetEntry(ientry);
1233 fChain->GetEntry(ientry);
0a749fa5 1234 ntracksRun=nentries/3;
1235 AliDebug(2,Form("run %i, channel %i, nentries = %i, ntracksRun = %i",irun, i ,nentries, ntracksRun));
1236 for (Int_t j=0;j<ntracksRun;j++){
1237 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
1238 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
1239 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
1240 Float_t tot = p[idxexToT];
1241 meantime+=p[idxexTime]-p[idxexExTime];
1242 hdeltaTime->Fill(p[idxexTime]-p[idxexExTime]);
1243 hToT->Fill(tot);
1244 }
1245 }
1246
1247 nusefulbins = FindBins(hToT,&binsProfile[0]);
1248 meantime/=ntracksTotal;
1249 AliDebug(2,Form("meantime = %f",meantime));
1250
1251 for (Int_t j=1;j<=nusefulbins;j++) {
1252 AliDebug(2,Form(" channel %i, nusefulbins = %i, bin %i = %f",i,nusefulbins,j,binsProfile[j]));
1253 }
1254
1255 TProfile* hSlewingProf = new TProfile("hSlewingProf", "hSlewingProf",nusefulbins, binsProfile, "G"); // CHECK THE BUILD OPTION, PLEASE!!!!!!
1256 TH2F * htimetot = new TH2F("htimetot","htimetot",nbinToT, minToT, maxToT,600,-5,10);
1257 for (Int_t irun=0;irun<fNruns;irun++){
1258 Int_t ientry = -1;
1259 ientry = i+irun*fNChannels;
296591ad 1260 //fTree->GetEntry(ientry);
1261 fChain->GetEntry(ientry);
0a749fa5 1262 ntracksRun=nentries/3;
1263 for (Int_t j=0;j<ntracksRun;j++){
1264 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
1265 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
1266 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
1267 Float_t tot = p[idxexToT];
1268 Float_t time = p[idxexTime]-p[idxexExTime];
1269 AliDebug (2,Form("track = %i, time = %f, tot = %f, time-meantime = %f",j,time, tot, time-meantime));
1270 hSlewingProf->Fill(tot,time); // if meantime is not used, the fill may be moved in the loop above
1271 htimetot->Fill(tot,time-meantime); // if meantime is not used, the fill may be moved in the loop above
1272 }
1273 }
1274
1275 hSlewingProf->Fit("pol5",optionFit,"",0,4);
1276 TF1 * calibfunc = (TF1*)hSlewingProf->GetFunction("pol5");
1277 Float_t par[6];
1278 for(Int_t kk=0;kk<6;kk++){
1279 par[kk]=calibfunc->GetParameter(kk);
1280 AliDebug(2,Form("parameter %i = %f",kk,par[kk]));
1281 }
1282
1283
1284 if(strstr(optionSave,"save")){
1285 TFile * fileProf = new TFile("TOFCalibSave.root","recreate");
1286 fileProf->cd();
1287 TString profName=Form("Profile%06i",i);
1288 TString timeTotName=Form("TimeTot%06i",i);
1289 TString totName=Form("Tot%06i",i);
1290 TString deltaName=Form("Delta%06i",i);
1291 hSlewingProf->Write(profName);
1292 htimetot->Write(timeTotName);
1293 hToT->Write(totName);
1294 hdeltaTime->Write(deltaName);
1295 fileProf->Close();
1296 delete fileProf;
1297 fileProf=0x0;
1298 }
1299
1300 delete hToT;
1301 hToT=0x0;
1302 delete hSlewingProf;
1303 hSlewingProf=0x0;
1304 delete htimetot;
1305 htimetot=0x0;
1306 delete hdeltaTime;
1307 hdeltaTime=0x0;
1308
1309 AliTOFChannelOffline * calChannel = (AliTOFChannelOffline*)fTOFCalOffline->At(i);
1310 calChannel->SetSlewPar(par);
0cb9d099 1311 WriteParOfflineOnCDB("TOF/Calib","valid");
0a749fa5 1312 return 0;
1313}
1314//----------------------------------------------------------------------------
1315Int_t AliTOFcalib::Calibrate(Int_t nch, Int_t *ch, Option_t *optionSave, Option_t *optionFit){
1316
1317 // calibrating an array of channels
1318 // computing calibration parameters
1319 // Returning codes:
1320 // 0 -> everything was ok
1321 // 1 -> no tree for calibration found
1322 // 2 -> not enough statistics to perform calibration
1323 // 3 -> problems with arrays
1324
1325 TH1::AddDirectory(0);
1326
1327 AliInfo(Form("*** Calibrating Histograms %s, number of channels = %i", GetName(),nch)) ;
1328 AliInfo(Form("Option for Saving histos = %s",optionSave )) ;
1329 AliInfo(Form("Option for Fitting Profile histos = %s",optionFit )) ;
1330 for (Int_t ich=0; ich<nch; ich++){
1331 Int_t i = ch[ich];
1332 AliInfo(Form("Calibrating channel = %i",i )) ;
1333 }
1334 Float_t p[MAXCHENTRIESSMALL];
1335 Int_t nentries;
296591ad 1336 //fTree->SetBranchAddress("nentries",&nentries);
1337 //fTree->SetBranchAddress("TOFentries",p);
1338 fChain->SetBranchAddress("nentries",&nentries);
1339 fChain->SetBranchAddress("TOFentries",p);
0a749fa5 1340
1341 Float_t ntracksTotalmean =0;
1342 for (Int_t ich=0; ich<nch; ich++){
1343 Int_t ientry = -1;
1344 Int_t i = ch[ich];
1345 for (Int_t irun=0;irun<fNruns;irun++){
1346 ientry = i+irun*fNChannels;
296591ad 1347 //fTree->GetEntry(ientry);
1348 fChain->GetEntry(ientry);
0a749fa5 1349 ntracksTotalmean+=nentries/3;
1350 }
1351 }
1352
1353 ntracksTotalmean/=nch;
1354 if (ntracksTotalmean < MEANENTRIES) {
1355 AliInfo(Form(" Too small mean number of entires per channel (mean number = %f) not calibrating and exiting.....",ntracksTotalmean));
1356 return 2;
1357 }
1358
1359 //filling ToT and Time arrays
1360
1361 Int_t nbinToT = 100; // ToT bin width in Profile = 48.8 ps
1362 Float_t minToT = 0; // ns
1363 Float_t maxToT = 4.88; // ns
1364 TFile * fileProf=0x0;
1365 if(strstr(optionSave,"save")){
1366 fileProf = new TFile("TOFCalibSave.root","recreate");
1367 }
1368 for (Int_t ich=0; ich<nch; ich++) {
1369 TH1F *hToT = new TH1F("htot","htot",nbinToT, minToT, maxToT);
1370 TH1F *hdeltaTime = new TH1F("hdeltaTime","hdeltaTime",200,2,4);
1371 Double_t binsProfile[101]; // sized larger than necessary, the correct
1372 // dim being set in the booking of the profile
1373 TH2F * htimetot = new TH2F("htimetot","htimetot",nbinToT, minToT, maxToT,600,-5,10);
1374 Int_t ntracksTotal = 0;
1375 Int_t ntracksRun = 0;
1376 Int_t nusefulbins=0;
1377 Float_t meantime=0;
1378 Int_t i=-1;
1379 for (Int_t irun=0;irun<fNruns;irun++){
1380 i = ch[ich]+irun*fNChannels;
1381 AliDebug(2,Form("Calibrating channel %i",i));
296591ad 1382 //fTree->GetEntry(i);
1383 fChain->GetEntry(i);
0a749fa5 1384 ntracksTotal+=nentries/3;
1385 }
1386 if (ntracksTotal < MEANENTRIES) {
1387 AliInfo(Form(" Too small mean number of entires in channel %i (number of tracks = %f), not calibrating channel and continuing.....",i,ntracksTotal));
1388 continue;
1389 }
1390
1391 for (Int_t irun=0;irun<fNruns;irun++){
3c609b5c 1392 i = ch[ich]+irun*fNChannels;
296591ad 1393 //fTree->GetEntry(i);
1394 fChain->GetEntry(i);
0a749fa5 1395 ntracksRun=nentries/3;
1396 for (Int_t j=0;j<ntracksRun;j++){
1397 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
1398 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
1399 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
1400 Float_t tot = p[idxexToT];
1401 hdeltaTime->Fill(p[idxexTime]-p[idxexExTime]);
1402 meantime+=p[idxexTime]-p[idxexExTime];
1403 hToT->Fill(tot);
1404 }
1405 }
1406
1407 nusefulbins = FindBins(hToT,&binsProfile[0]);
1408 meantime/=ntracksTotal;
1409 for (Int_t j=1;j<=nusefulbins;j++) {
1410 AliDebug(2,Form(" channel %i, nusefulbins = %i, bin %i = %f",i,nusefulbins,j,binsProfile[j]));
1411 }
1412
1413 TProfile* hSlewingProf = new TProfile("hSlewingProf", "hSlewingProf",nusefulbins, binsProfile, "G"); // CHECK THE BUILD OPTION, PLEASE!!!!!!
1414 for (Int_t irun=0;irun<fNruns;irun++){
3c609b5c 1415 i = ch[ich]+irun*fNChannels;
296591ad 1416 //fTree->GetEntry(i);
1417 fChain->GetEntry(i);
0a749fa5 1418 ntracksRun=nentries/3;
1419 for (Int_t j=0;j<ntracksRun;j++){
1420 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
1421 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
1422 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
1423 Float_t tot = p[idxexToT];
1424 Float_t time = p[idxexTime]-p[idxexExTime];
1425 AliDebug(2,Form("track = %i, time = %f, tot = %f, time-meantime = %f",j,time, tot, time-meantime));
1426 hSlewingProf->Fill(tot,time); // if meantime is not used, the fill may be moved in the loop above
1427 htimetot->Fill(tot,time-meantime); // if meantime is not used, the fill may be moved in the loop above
1428 }
1429 }
1430
1431 hSlewingProf->Fit("pol5",optionFit,"",1,4);
1432 TF1 * calibfunc = (TF1*)hSlewingProf->GetFunction("pol5");
1433 Float_t par[6];
1434 for(Int_t kk=0;kk<6;kk++){
1435 par[kk]=calibfunc->GetParameter(kk);
1436 AliDebug(2,Form("parameter %i = %f",kk,par[kk]));
1437 }
1438
1439 if(strstr(optionSave,"save") && fileProf){
1440 TString profName=Form("Profile%06i",i);
1441 TString timeTotName=Form("TimeTot%06i",i);
1442 TString totName=Form("Tot%06i",i);
1443 TString deltaName=Form("Delta%06i",i);
1444 fileProf->cd();
1445 hSlewingProf->Write(profName);
1446 htimetot->Write(timeTotName);
1447 hToT->Write(totName);
1448 hdeltaTime->Write(deltaName);
1449 }
1450
1451 AliTOFChannelOffline * calChannel = (AliTOFChannelOffline*)fTOFCalOffline->At(i);
1452 calChannel->SetSlewPar(par);
1453 delete hToT;
1454 hToT=0x0;
1455 delete hSlewingProf;
1456 hSlewingProf=0x0;
1457 delete htimetot;
1458 htimetot=0x0;
1459 delete hdeltaTime;
1460 hdeltaTime=0x0;
1461 }
1462
1463 if(strstr(optionSave,"save") && fileProf){
1464 fileProf->Close();
1465 delete fileProf;
1466 fileProf=0x0;
1467 }
0cb9d099 1468 WriteParOfflineOnCDB("TOF/Calib","valid");
0a749fa5 1469
1470 return 0;
1471}
1472//----------------------------------------------------------------------------
1473Int_t AliTOFcalib::CalibrateFromProfile(Int_t ich, Option_t *optionSave, Option_t *optionFit){
1474
1475 // computing calibration parameters using the old profiling algo
1476 // Returning codes:
1477 // 0 -> everything was ok
1478 // 1 -> no tree for calibration found
1479 // 2 -> not enough statistics to perform calibration
1480 // 3 -> problems with arrays
1481
1482 TH1::AddDirectory(0);
1483
1484 AliInfo(Form("*** Calibrating Histograms From Profile %s", GetName())) ;
1485 AliInfo(Form("Option for Saving histos = %s",optionSave )) ;
1486 AliInfo(Form("Option for Fitting Profile histos = %s",optionFit )) ;
1487 Float_t p[MAXCHENTRIESSMALL];
1488 Int_t nentries;
1489 Int_t ntracksTotal=0;
296591ad 1490 //fTree->SetBranchAddress("nentries",&nentries);
1491 //fTree->SetBranchAddress("TOFentries",p);
1492 fChain->SetBranchAddress("nentries",&nentries);
1493 fChain->SetBranchAddress("TOFentries",p);
0a749fa5 1494
1495 for (Int_t irun=0;irun<fNruns;irun++){
1496 Int_t i = ich+irun*fNChannels;
296591ad 1497 //fTree->GetEntry(i);
1498 fChain->GetEntry(i);
0a749fa5 1499 ntracksTotal+=nentries/3;
1500 }
1501
1502 if (ntracksTotal < MEANENTRIES) {
1503 AliInfo(Form(" Too small mean number of entires per channel (mean number = %f) not calibrating and exiting.....",ntracksTotal));
1504 return 2;
1505 }
1506
1507 TH1F * hProf = new TH1F();
1508 hProf = Profile(ich);
1509 hProf->Fit("pol5",optionFit,"",0,4);
1510 TF1 * calibfunc = (TF1*)hProf->GetFunction("pol5");
1511 Float_t par[6];
1512 for(Int_t kk=0;kk<6;kk++){
1513 par[kk]=calibfunc->GetParameter(kk);
1514 AliDebug(2,Form("parameter %i = %f",kk,par[kk]));
1515 }
1516
1517 if(strstr(optionSave,"save")){
1518 TFile * fileProf = new TFile("TOFCalibSave.root","recreate");
1519 fileProf->cd();
1520 TString profName=Form("Profile%06i",ich);
1521 hProf->Write(profName);
1522 fileProf->Close();
1523 delete fileProf;
1524 fileProf=0x0;
1525 }
1526
1527 delete hProf;
1528 hProf=0x0;
1529 AliTOFChannelOffline * calChannel = (AliTOFChannelOffline*)fTOFCalOffline->At(ich);
1530 calChannel->SetSlewPar(par);
0cb9d099 1531 WriteParOfflineOnCDB("TOF/Calib","valid");
0a749fa5 1532 return 0;
1533}
1534//----------------------------------------------------------------------------
1535Int_t AliTOFcalib::Calibrate(Option_t *optionSave, Option_t *optionFit){
1536
1537 // calibrating the whole TOF
1538 // computing calibration parameters
1539 // Returning codes:
1540 // 0 -> everything was ok
1541 // 1 -> no tree for calibration found
1542 // 2 -> not enough statistics to perform calibration
1543 // 3 -> problems with arrays
1544
1545 TH1::AddDirectory(0);
1546
1547 AliInfo(Form("*** Calibrating Histograms %s, all channels", GetName())) ;
1548 AliInfo(Form("Option for Saving histos = %s",optionSave )) ;
1549 AliInfo(Form("Option for Fitting Profile histos = %s",optionFit )) ;
1550
1551 TFile * fileProf=0x0;
1552 if(strstr(optionSave,"save")){
1553 fileProf = new TFile("TOFCalibSave.root","recreate");
1554 }
1555
1556 Float_t p[MAXCHENTRIESSMALL];
1557 Int_t nentries;
296591ad 1558 //fTree->SetBranchAddress("nentries",&nentries);
1559 //fTree->SetBranchAddress("TOFentries",p);
1560 fChain->SetBranchAddress("nentries",&nentries);
1561 fChain->SetBranchAddress("TOFentries",p);
0a749fa5 1562
1563 Float_t ntracksTotalmean =0;
1564 for (Int_t ii=0; ii<fNChannels; ii++){
1565 for (Int_t irun=0;irun<fNruns;irun++){
1566 Int_t i = ii+irun*fNChannels;
296591ad 1567 //fTree->GetEntry(i);
1568 fChain->GetEntry(i);
0a749fa5 1569 ntracksTotalmean+=nentries/3;
1570 }
1571 }
1572
1573 ntracksTotalmean/=fNChannels;
1574 if (ntracksTotalmean < MEANENTRIES) {
1575 AliInfo(Form(" Too small mean number of entires per channel (mean number = %f) not calibrating and exiting.....",ntracksTotalmean));
1576 return 2;
1577 }
1578
1579 //filling ToT and Time arrays
1580
1581 Int_t nbinToT = 100; // ToT bin width in Profile = 50.0 ps
1582 Float_t minToT = 0; // ns
1583 Float_t maxToT = 4.88;// ns
1584 for (Int_t ii=0; ii<fNChannels; ii++) {
1585 TH1F *hToT = new TH1F("htot","htot",nbinToT, minToT, maxToT);
1586 TH1F *hdeltaTime = new TH1F("hdeltaTime","hdeltaTime",200,2,4);
1587 TH2F * htimetot = new TH2F("htimetot","htimetot",nbinToT, minToT, maxToT,600,-5,10);
1588 if (ii%1000 == 0) AliDebug(1,Form("Calibrating channel %i ",ii));
1589 //Int_t i = 3;
1590 Int_t nusefulbins=0;
1591 Double_t binsProfile[101]; // sized larger than necessary, the correct
1592 // dim being set in the booking of the profile
1593 Int_t ntracksRun = 0;
1594 Int_t ntracksTotal = 0;
1595 for (Int_t irun=0;irun<fNruns;irun++){
1596 Int_t i = ii+irun*fNChannels;
296591ad 1597 //fTree->GetEntry(i);
1598 fChain->GetEntry(i);
0a749fa5 1599 ntracksTotal+=nentries/3;
1600 }
1601 if (ntracksTotal < MEANENTRIES) {
1602 AliInfo(Form(" Too small mean number of entires in channel %i (number of tracks = %f), not calibrating channel and continuing.....",ii,ntracksTotal));
1603 continue;
1604 }
1605 Float_t meantime=0;
1606 for (Int_t irun=0;irun<fNruns;irun++){
1607 Int_t i = ii+irun*fNChannels;
296591ad 1608 //fTree->GetEntry(i);
1609 fChain->GetEntry(i);
0a749fa5 1610 ntracksRun=nentries/3;
1611 for (Int_t j=0;j<ntracksRun;j++){
1612 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
1613 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
1614 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
1615 Float_t tot = p[idxexToT];
1616 hdeltaTime->Fill(p[idxexTime]-p[idxexExTime]);
1617 meantime+=p[idxexTime]-p[idxexExTime];
1618 hToT->Fill(tot);
1619 }
1620 }
1621 nusefulbins = FindBins(hToT,&binsProfile[0]);
1622 meantime/=ntracksTotal;
1623 for (Int_t j=0;j<nusefulbins;j++) {
1624 AliDebug(2,Form(" channel %i, usefulbin = %i, low edge = %f",ii,j,binsProfile[j]));
1625 }
1626 TProfile* hSlewingProf = new TProfile("hSlewingProf", "hSlewingProf",nusefulbins, binsProfile, "G"); // CHECK THE BUILD OPTION, PLEASE!!!!!!
1627 for (Int_t irun=0;irun<fNruns;irun++){
1628 Int_t i = ii+irun*fNChannels;
296591ad 1629 //fTree->GetEntry(i);
1630 fChain->GetEntry(i);
0a749fa5 1631 ntracksRun=nentries/3;
1632 for (Int_t j=0;j<ntracksRun;j++){
1633 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
1634 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
1635 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
1636 Float_t tot = p[idxexToT];
1637 Float_t time = p[idxexTime]-p[idxexExTime];
1638 AliDebug (2,Form("track = %i, time = %f, tot = %f, time-meantime = %f",j,time, tot, time-meantime));
1639 hSlewingProf->Fill(tot,time); // if meantime is not used, the fill may be moved in the loop above
1640 htimetot->Fill(tot,time-meantime); // if meantime is not used, the fill may be moved in the loop above
1641 }
1642 }
1643 hSlewingProf->Fit("pol5",optionFit,"",1,4);
1644 TF1 * calibfunc = (TF1*)hSlewingProf->GetFunction("pol5");
1645 Float_t par[6];
1646 for(Int_t kk=0;kk<6;kk++){
1647 par[kk]=calibfunc->GetParameter(kk);
1648 AliDebug(2,Form("parameter %i = %f",kk,par[kk]));
1649 }
1650
1651 if(strstr(optionSave,"save") && fileProf){
1652 TString profName=Form("Profile%06i",ii);
1653 TString timeTotName=Form("TimeTot%06i",ii);
1654 TString totName=Form("Tot%06i",ii);
1655 TString deltaName=Form("Delta%06i",ii);
1656 fileProf->cd();
1657 hSlewingProf->Write(profName);
1658 htimetot->Write(timeTotName);
1659 hToT->Write(totName);
1660 hdeltaTime->Write(deltaName);
1661 }
1662 AliTOFChannelOffline * calChannel = (AliTOFChannelOffline*)fTOFCalOffline->At(ii);
1663 calChannel->SetSlewPar(par);
1664
1665 delete hToT;
1666 hToT=0x0;
1667 delete hSlewingProf;
1668 hSlewingProf=0x0;
1669 delete htimetot;
1670 htimetot=0x0;
1671 delete hdeltaTime;
1672 hdeltaTime=0x0;
1673 }
1674
1675 if(strstr(optionSave,"save")){
1676 fileProf->Close();
1677 delete fileProf;
1678 fileProf=0x0;
1679 }
0cb9d099 1680 WriteParOfflineOnCDB("TOF/Calib","valid");
0a749fa5 1681 return 0;
1682}
1683
1684//-----------------------------------------------------------------------
1685TH1F* AliTOFcalib::Profile(Int_t ich)
340693af 1686{
0a749fa5 1687 // profiling algo
1688
1689 Float_t p[MAXCHENTRIESSMALL];
1690 Int_t nentries;
296591ad 1691 //fTree->SetBranchAddress("nentries",&nentries);
1692 //fTree->SetBranchAddress("TOFentries",p);
1693 fChain->SetBranchAddress("nentries",&nentries);
1694 fChain->SetBranchAddress("TOFentries",p);
0a749fa5 1695
1696 //Prepare histograms for Slewing Correction
1697 const Int_t knbinToT = 100;
1698 Int_t nbinTime = 200;
1699 Float_t minTime = -5.5; //ns
1700 Float_t maxTime = 5.5; //ns
1701 Float_t minToT = 0; //ns
1702 Float_t maxToT = 5.; //ns
1703 Float_t deltaToT = (maxToT-minToT)/knbinToT;
1704 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];
1705 Int_t n[knbinToT+1], nentrx[knbinToT+1];
1706 Double_t sigmaToT[knbinToT+1];
1707 for (Int_t i = 0; i < knbinToT+1 ; i++){
1708 mTime[i]=0;
1709 mToT[i]=0;
1710 n[i]=0;
1711 meanTime[i]=0;
1712 meanTime2[i]=0;
1713 vToT[i]=0;
1714 vToT2[i]=0;
1715 meanToT[i]=0;
1716 meanToT2[i]=0;
1717 vTime[i]=0;
1718 vTime2[i]=0;
1719 xlow[i]=0;
1720 sigmaTime[i]=0;
1721 sigmaToT[i]=0;
1722 n[i]=0;
1723 nentrx[i]=0;
1724 }
1725 TH2F* hSlewing = new TH2F("hSlewing", "hSlewing", knbinToT, minToT, maxToT, nbinTime, minTime, maxTime);
1726 Int_t ntracksRun = 0;
1727 TH1F *histo = new TH1F("histo", "1D Time vs ToT", knbinToT, minToT, maxToT);
1728 for (Int_t irun=0;irun<fNruns;irun++){
1729 Int_t i = ich+irun*fNChannels;
296591ad 1730 //fTree->GetEntry(i);
1731 fChain->GetEntry(i);
0a749fa5 1732 ntracksRun=nentries/3;
1733 for (Int_t j=0;j<ntracksRun;j++){
1734 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
1735 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
1736 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
1737 Float_t tot = p[idxexToT];
1738 Float_t time = p[idxexTime]-p[idxexExTime];
1739 Int_t nx = (Int_t)((tot-minToT)/deltaToT)+1;
1740 if ((tot != 0) && ( time!= 0)){
1741 vTime[nx]+=time;
1742 vTime2[nx]+=time*time;
1743 vToT[nx]+=tot;
1744 vToT2[nx]+=tot*tot;
1745 nentrx[nx]++;
1746 hSlewing->Fill(tot,time);
1747 }
1748 }
1749 }
1750 Int_t nbinsToT=hSlewing->GetNbinsX();
1751 if (nbinsToT != knbinToT) {
1752 AliError("Profile :: incompatible numbers of bins");
1753 return 0x0;
1754 }
1755
1756 Int_t usefulBins=0;
1757 for (Int_t i=1;i<=nbinsToT;i++){
1758 if (nentrx[i]!=0){
1759 n[usefulBins]+=nentrx[i];
1760 if (n[usefulBins]==0 && i == nbinsToT) {
1761 break;
1762 }
1763 meanTime[usefulBins]+=vTime[i];
1764 meanTime2[usefulBins]+=vTime2[i];
1765 meanToT[usefulBins]+=vToT[i];
1766 meanToT2[usefulBins]+=vToT2[i];
1767 if (n[usefulBins]<10 && i!=nbinsToT) continue;
1768 mTime[usefulBins]=meanTime[usefulBins]/n[usefulBins];
1769 mToT[usefulBins]=meanToT[usefulBins]/n[usefulBins];
1770 sigmaTime[usefulBins]=TMath::Sqrt(1./n[usefulBins]/n[usefulBins]
1771 *(meanTime2[usefulBins]-meanTime[usefulBins]
1772 *meanTime[usefulBins]/n[usefulBins]));
1773 if ((1./n[usefulBins]/n[usefulBins]
1774 *(meanToT2[usefulBins]-meanToT[usefulBins]
1775 *meanToT[usefulBins]/n[usefulBins]))< 0) {
1776 AliError(" too small radical" );
1777 sigmaToT[usefulBins]=0;
1778 }
1779 else{
1780 sigmaToT[usefulBins]=TMath::Sqrt(1./n[usefulBins]/n[usefulBins]
1781 *(meanToT2[usefulBins]-meanToT[usefulBins]
1782 *meanToT[usefulBins]/n[usefulBins]));
1783 }
1784 usefulBins++;
1785 }
1786 }
1787 for (Int_t i=0;i<usefulBins;i++){
1788 Int_t binN = (Int_t)((mToT[i]-minToT)/deltaToT)+1;
1789 histo->Fill(mToT[i],mTime[i]);
1790 histo->SetBinError(binN,sigmaTime[i]);
1791 }
1792 delete hSlewing;
1793 hSlewing=0x0;
1794
1795 return histo;
6dc9348d 1796}
0a749fa5 1797//----------------------------------------------------------------------------
1798Int_t AliTOFcalib::FindBins(TH1F* h, Double_t *binsProfile) const{
6dc9348d 1799
0a749fa5 1800 // to determine the bins for ToT histo
1801
1802 Int_t cont = 0;
1803 Int_t startBin = 1;
1804 Int_t nbin = h->GetNbinsX();
1805 Int_t nentries = (Int_t)h->GetEntries();
1806 Float_t max = h->GetBinLowEdge(nbin);
1807 Int_t nusefulbins=0;
1808 Int_t maxcont=0;
1809 // setting maxvalue of entries per bin
1810 if (nentries <= 60) maxcont = 2;
1811 else if (nentries <= 100) maxcont = 5;
1812 else if (nentries <= 500) maxcont = 10;
1813 else maxcont = 20;
1814 for (Int_t j=1;j<=nbin;j++) {
1815 cont += (Int_t)h->GetBinContent(j);
1816 if (j<nbin){
1817 if (cont>=maxcont){
1818 nusefulbins++;
1819 binsProfile[nusefulbins-1]=h->GetBinLowEdge(startBin);
1820 cont=0;
1821 startBin=j+1;
1822 continue;
1823 }
1824 }
1825 else{
1826 if (cont>=maxcont){
1827 nusefulbins++;
1828 binsProfile[nusefulbins-1]=h->GetBinLowEdge(startBin);
1829 binsProfile[nusefulbins]=max;
1830 }
1831 else {
1832 binsProfile[nusefulbins]=h->GetBinLowEdge(startBin);
1833 }
1834 }
1835 }
1836 return nusefulbins;
1837}
2bf4d9d6 1838
1839
1840//----------------------------------------------------------------------------
1841
1842void
1843AliTOFcalib::CreateDeltaBCOffset()
1844{
1845 /*
1846 * create deltaBC offset
1847 */
1848
1849 if (fDeltaBCOffset) {
1850 AliWarning("DeltaBCOffset object already defined, cannot create a new one");
1851 return;
1852 }
1853 fDeltaBCOffset = new AliTOFDeltaBCOffset();
1854}
1855
1856//----------------------------------------------------------------------------
1857
1858void
1859AliTOFcalib::CreateCTPLatency()
1860{
1861 /*
1862 * create CTP latency
1863 */
1864
1865 if (fCTPLatency) {
1866 AliWarning("CTPLatency object already defined, cannot create a new one");
1867 return;
1868 }
1869 fCTPLatency = new AliTOFCTPLatency();
1870}
1871
1872//----------------------------------------------------------------------------
1873
1874void
1875AliTOFcalib::CreateT0Fill()
1876{
1877 /*
1878 * create event-time
1879 */
1880
1881 if (fT0Fill) {
1882 AliWarning("T0Fill object already defined, cannot create a new one");
1883 return;
1884 }
1885 fT0Fill = new AliTOFT0Fill();
1886}
1887
1888//----------------------------------------------------------------------------
1889
f04b3a69 1890void
1891AliTOFcalib::CreateRunParams()
1892{
1893 /*
1894 * create run params
1895 */
1896
1897 if (fRunParams) {
1898 AliWarning("RunParams object already defined, cannot create a new one");
1899 return;
1900 }
1901 fRunParams = new AliTOFRunParams();
1902}
1903
1904//----------------------------------------------------------------------------
1905
2bf4d9d6 1906void
1907AliTOFcalib::WriteDeltaBCOffsetOnCDB(const Char_t *sel , Int_t minrun, Int_t maxrun)
1908{
1909 /*
1910 * deltaBC offset on CDB
1911 */
1912
1913 if (!fDeltaBCOffset) return;
1914 AliCDBId id(Form("%s/DeltaBCOffset", sel), minrun, maxrun);
1915 AliCDBMetaData *md = new AliCDBMetaData();
1916 md->SetResponsible("Roberto Preghenella");
1917 AliCDBManager *man = AliCDBManager::Instance();
1918 man->Put(fDeltaBCOffset, id, md);
1919 AliDebug(2,Form("DeltaBCOffset written on CDB with run range [%i, %i] ",minrun ,maxrun));
1920 delete md;
1921}
1922
1923//----------------------------------------------------------------------------
1924
1925void
1926AliTOFcalib::WriteCTPLatencyOnCDB(const Char_t *sel , Int_t minrun, Int_t maxrun)
1927{
1928 /*
1929 * write CTP latency on CDB
1930 */
1931
1932 if (!fCTPLatency) return;
1933 AliCDBId id(Form("%s/CTPLatency", sel), minrun, maxrun);
1934 AliCDBMetaData *md = new AliCDBMetaData();
1935 md->SetResponsible("Roberto Preghenella");
1936 AliCDBManager *man = AliCDBManager::Instance();
1937 man->Put(fCTPLatency, id, md);
1938 AliDebug(2,Form("CTPLatency written on CDB with run range [%i, %i] ",minrun ,maxrun));
1939 delete md;
1940}
1941
1942//----------------------------------------------------------------------------
1943
1944void
1945AliTOFcalib::WriteT0FillOnCDB(const Char_t *sel , Int_t minrun, Int_t maxrun)
1946{
1947 /*
1948 * write event-time on CDB
1949 */
1950
1951 if (!fT0Fill) return;
1952 AliCDBId id(Form("%s/T0Fill", sel), minrun, maxrun);
1953 AliCDBMetaData *md = new AliCDBMetaData();
1954 md->SetResponsible("Roberto Preghenella");
1955 AliCDBManager *man = AliCDBManager::Instance();
1956 man->Put(fT0Fill, id, md);
1957 AliDebug(2,Form("T0Fill written on CDB with run range [%i, %i] ",minrun ,maxrun));
1958 delete md;
1959}
1960
1961//----------------------------------------------------------------------------
1962
f04b3a69 1963void
1964AliTOFcalib::WriteRunParamsOnCDB(const Char_t *sel , Int_t minrun, Int_t maxrun)
1965{
1966 /*
1967 * write run params on CDB
1968 */
1969
1970 if (!fRunParams) return;
1971 AliCDBId id(Form("%s/RunParams", sel), minrun, maxrun);
1972 AliCDBMetaData *md = new AliCDBMetaData();
1973 md->SetResponsible("Roberto Preghenella");
1974 AliCDBManager *man = AliCDBManager::Instance();
1975 man->Put(fRunParams, id, md);
1976 AliDebug(2,Form("RunParams written on CDB with run range [%i, %i] ",minrun ,maxrun));
1977 delete md;
1978}
1979
1980//----------------------------------------------------------------------------
1981
2bf4d9d6 1982Bool_t
1983AliTOFcalib::ReadDeltaBCOffsetFromCDB(const Char_t *sel , Int_t nrun)
1984{
1985 /*
1986 * read deltaBC offset from CDB
1987 */
1988
1989 AliCDBManager *man = AliCDBManager::Instance();
1990 AliCDBEntry *entry = man->Get(Form("%s/DeltaBCOffset", sel),nrun);
1991 if (!entry) {
1992 AliFatal("No DeltaBCOffset entry found in CDB");
1993 exit(0);
1994 }
1995 fDeltaBCOffset =(AliTOFDeltaBCOffset *)entry->GetObject();
1996 if(!fDeltaBCOffset){
1997 AliFatal("No DeltaBCOffset object found in CDB entry");
1998 exit(0);
1999 }
2000 return kTRUE;
2001}
2002
2003//----------------------------------------------------------------------------
2004
2005Bool_t
2006AliTOFcalib::ReadCTPLatencyFromCDB(const Char_t *sel , Int_t nrun)
2007{
2008 /*
2009 * read CTP latency from CDB
2010 */
2011
2012 AliCDBManager *man = AliCDBManager::Instance();
2013 AliCDBEntry *entry = man->Get(Form("%s/CTPLatency", sel),nrun);
2014 if (!entry) {
2015 AliFatal("No CTPLatency entry found in CDB");
2016 exit(0);
2017 }
2018 fCTPLatency =(AliTOFCTPLatency *)entry->GetObject();
2019 if(!fCTPLatency){
2020 AliFatal("No CTPLatency object found in CDB entry");
2021 exit(0);
2022 }
2023 return kTRUE;
2024}
2025
2026//----------------------------------------------------------------------------
2027
2028Bool_t
2029AliTOFcalib::ReadT0FillFromCDB(const Char_t *sel , Int_t nrun)
2030{
2031 /*
2032 * read event-time from CDB
2033 */
2034
2035 AliCDBManager *man = AliCDBManager::Instance();
2036 AliCDBEntry *entry = man->Get(Form("%s/T0Fill", sel),nrun);
2037 if (!entry) {
2038 AliFatal("No T0Fill entry found in CDB");
2039 exit(0);
2040 }
2041 fT0Fill =(AliTOFT0Fill *)entry->GetObject();
2042 if(!fT0Fill){
2043 AliFatal("No T0Fill object found in CDB entry");
2044 exit(0);
2045 }
2046 return kTRUE;
2047}
2048
f04b3a69 2049//----------------------------------------------------------------------------
2050
2051Bool_t
2052AliTOFcalib::ReadRunParamsFromCDB(const Char_t *sel , Int_t nrun)
2053{
2054 /*
2055 * read run params from CDB
2056 */
2057
2058 AliCDBManager *man = AliCDBManager::Instance();
2059 AliCDBEntry *entry = man->Get(Form("%s/RunParams", sel),nrun);
2060 if (!entry) {
2061 AliFatal("No RunParams entry found in CDB");
2062 exit(0);
2063 }
2064 fRunParams =(AliTOFRunParams *)entry->GetObject();
2065 if(!fRunParams){
2066 AliFatal("No RunParams object found in CDB entry");
2067 exit(0);
2068 }
2069 return kTRUE;
2070}
2071