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