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