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