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