]> 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
branches
[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//_____________________________________________________________________________
24d1e16e 279void AliTOFcalib::CreateCalObjects(){
280
281 // creating arrays for online/offline calibration objs
282
283 fTOFCalOffline = new TObjArray(fNChannels);
284 fTOFCalOffline->SetOwner();
285 for (Int_t iarray = 0; iarray<fNChannels; iarray++){
286 AliTOFChannelOffline * calChOffline = new AliTOFChannelOffline();
287 fTOFCalOffline->AddAt(calChOffline,iarray);
288 }
289 fCal = new AliTOFChannelOnlineArray(fNChannels);
290 fStatus = new AliTOFChannelOnlineStatusArray(fNChannels);
291}
292//_____________________________________________________________________________
17149e6b 293void AliTOFcalib::WriteConfigMapOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun)
294{
295 //Write calibration parameters to the CDB
296 SetFirstRun(minrun);
297 SetLastRun(maxrun);
298 AliCDBManager *man = AliCDBManager::Instance();
299 Char_t *sel1 = "Config" ; // to be consistent with TOFPreprocessor
300 Char_t out[100];
301 sprintf(out,"%s/%s",sel,sel1);
302 AliDebug(2,Form("Writing TOF configuration map for online calib on CDB with run range [%i, %i] ",fFirstRun,fLastRun));
303 AliCDBId id(out,fFirstRun,fLastRun);
304 AliCDBMetaData *md = new AliCDBMetaData();
305 md->SetResponsible("Chiara Zampolli");
306 if (!fConfigMap) {
307 // deve uscire!!
308 }
309 man->Put(fConfigMap,id,md);
310 delete md;
311}
312//_____________________________________________________________________________
313
314void AliTOFcalib::WriteConfigMapOnCDB(Char_t *sel)
315{
316 //Write calibration parameters to the CDB with infinite validity
317 AliCDBManager *man = AliCDBManager::Instance();
318 Char_t *sel1 = "Config" ; // to be consistent with TOFPreprocessor
319 Char_t out[100];
320 sprintf(out,"%s/%s",sel,sel1);
321 AliCDBRunRange runrange(fFirstRun,fLastRun);
322 AliDebug(2,Form("Writing TOF config map for online calib on CDB with run range [%i, %i] ",runrange.GetFirstRun(),runrange.GetLastRun()));
323 AliCDBId id(out,runrange);
324 AliCDBMetaData *md = new AliCDBMetaData();
325 md->SetResponsible("Chiara Zampolli");
326 if (!fConfigMap) {
327 // deve uscire!!
328 }
329 man->Put(fConfigMap,id,md);
330 delete md;
331}
332//_____________________________________________________________________________
333void AliTOFcalib::WriteParOnlineDelayOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun)
334{
335 //Write calibration parameters to the CDB -------> new calib objs!!!!!
336 SetFirstRun(minrun);
337 SetLastRun(maxrun);
338 AliCDBManager *man = AliCDBManager::Instance();
339 Char_t *sel1 = "ParOnlineDelay" ; // to be consistent with TOFPreprocessor
340 Char_t out[100];
341 sprintf(out,"%s/%s",sel,sel1);
342 AliDebug(2,Form("Writing TOF online calib obj on CDB with run range [%i, %i] ",fFirstRun,fLastRun));
343 AliCDBId id(out,fFirstRun,fLastRun);
344 AliCDBMetaData *md = new AliCDBMetaData();
345 md->SetResponsible("Chiara Zampolli");
346 if (!fCal) {
347 // deve uscire!!
348 }
349 man->Put(fCal,id,md);
350 delete md;
351}
352//_____________________________________________________________________________
353void AliTOFcalib::WriteParOnlineStatusOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun)
354{
355 //Write calibration parameters to the CDB -------> new calib objs!!!!!
356 SetFirstRun(minrun);
357 SetLastRun(maxrun);
358 AliCDBManager *man = AliCDBManager::Instance();
359 Char_t *sel1 = "Status" ; // to be consistent with TOFPreprocessor
360 Char_t out[100];
361 sprintf(out,"%s/%s",sel,sel1);
362 AliDebug(2,Form("Writing TOF online status calib obj on CDB with run range [%i, %i] ",fFirstRun,fLastRun));
363 AliCDBId id(out,fFirstRun,fLastRun);
364 AliCDBMetaData *md = new AliCDBMetaData();
365 md->SetResponsible("Chiara Zampolli");
366 if (!fStatus) {
367 // deve uscire!!
368 }
369 man->Put(fStatus,id,md);
370 delete md;
371}
372//_____________________________________________________________________________
373
374void AliTOFcalib::WriteParOnlineDelayOnCDB(Char_t *sel)
375{
376 //Write calibration parameters to the CDB with infinite validity -------> new calib objs!!!!!
377 AliCDBManager *man = AliCDBManager::Instance();
378 Char_t *sel1 = "ParOnlineDelay" ; // to be consistent with TOFPreprocessor
379 Char_t out[100];
380 sprintf(out,"%s/%s",sel,sel1);
381 AliCDBRunRange runrange(fFirstRun,fLastRun);
382 AliDebug(2,Form("Writing TOF online calib obj on CDB with run range [%i, %i] ",runrange.GetFirstRun(),runrange.GetLastRun()));
383 AliCDBId id(out,runrange);
384 AliCDBMetaData *md = new AliCDBMetaData();
385 md->SetResponsible("Chiara Zampolli");
386 if (!fCal) {
387 // deve uscire!!
388 }
389 man->Put(fCal,id,md);
390 delete md;
391}
392//_____________________________________________________________________________
393
394void AliTOFcalib::WriteParOnlineStatusOnCDB(Char_t *sel)
395{
396 //Write calibration parameters to the CDB with infinite validity -------> new calib objs!!!!!
397 AliCDBManager *man = AliCDBManager::Instance();
398 Char_t *sel1 = "Status" ; // to be consistent with TOFPreprocessor
399 Char_t out[100];
400 sprintf(out,"%s/%s",sel,sel1);
401 AliCDBRunRange runrange(fFirstRun,fLastRun);
402 AliDebug(2,Form("Writing TOF online status calib obj on CDB with run range [%i, %i] ",runrange.GetFirstRun(),runrange.GetLastRun()));
403 AliCDBId id(out,runrange);
404 AliCDBMetaData *md = new AliCDBMetaData();
405 md->SetResponsible("Chiara Zampolli");
406 if (!fStatus) {
407 // deve uscire!!
408 }
409 man->Put(fStatus,id,md);
410 delete md;
6dc9348d 411}
412//_____________________________________________________________________________
0a749fa5 413void AliTOFcalib::WriteParOnlineOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun)
340693af 414{
415 //Write calibration parameters to the CDB
0cb9d099 416 SetFirstRun(minrun);
417 SetLastRun(maxrun);
6dc9348d 418 AliCDBManager *man = AliCDBManager::Instance();
a7e9db2a 419 Char_t *sel1 = "ParOnline" ; // to be consistent with TOFPreprocessor
d4ad0d6b 420 Char_t out[100];
421 sprintf(out,"%s/%s",sel,sel1);
0cb9d099 422 AliDebug(2,Form("Writing TOF online calib obj on CDB with run range [%i, %i] ",fFirstRun,fLastRun));
423 AliCDBId id(out,fFirstRun,fLastRun);
424 AliCDBMetaData *md = new AliCDBMetaData();
425 md->SetResponsible("Chiara Zampolli");
426 if (!fTOFCalOnline) {
427 // deve uscire!!
428 }
429 man->Put(fTOFCalOnline,id,md);
430 delete md;
431}
432//_____________________________________________________________________________
7fffa85b 433void AliTOFcalib::WriteParOnlinePulserOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun)
434{
435 //Write calibration parameters from pulser to the CDB
436 SetFirstRun(minrun);
437 SetLastRun(maxrun);
438 AliCDBManager *man = AliCDBManager::Instance();
439 Char_t *sel1 = "Pulser" ; // to be consistent with TOFPreprocessor
440 Char_t out[100];
441 sprintf(out,"%s/%s",sel,sel1);
442 AliDebug(2,Form("Writing TOF online calib obj from pulser on CDB with run range [%i, %i] ",fFirstRun,fLastRun));
443 AliCDBId id(out,fFirstRun,fLastRun);
444 AliCDBMetaData *md = new AliCDBMetaData();
445 md->SetResponsible("Chiara Zampolli");
446 if (!fTOFCalOnlinePulser) {
447 // deve uscire!!
448 }
449 man->Put(fTOFCalOnlinePulser,id,md);
450 delete md;
451}
452//_____________________________________________________________________________
453void AliTOFcalib::WriteParOnlineNoiseOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun)
454{
455 //Write calibration parameters from noise to the CDB
456 SetFirstRun(minrun);
457 SetLastRun(maxrun);
458 AliCDBManager *man = AliCDBManager::Instance();
459 Char_t *sel1 = "Noise" ; // to be consistent with TOFPreprocessor
460 Char_t out[100];
461 sprintf(out,"%s/%s",sel,sel1);
462 AliDebug(2,Form("Writing TOF online calib obj from noise on CDB with run range [%i, %i] ",fFirstRun,fLastRun));
463 AliCDBId id(out,fFirstRun,fLastRun);
464 AliCDBMetaData *md = new AliCDBMetaData();
465 md->SetResponsible("Chiara Zampolli");
466 if (!fTOFCalOnlineNoise) {
467 // deve uscire!!
468 }
469 man->Put(fTOFCalOnlineNoise,id,md);
470 delete md;
471}
472//_____________________________________________________________________________
473void AliTOFcalib::WriteParOnlineHWOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun)
474{
475 //Write calibration parameters from hardware to the CDB
476 SetFirstRun(minrun);
477 SetLastRun(maxrun);
478 AliCDBManager *man = AliCDBManager::Instance();
479 Char_t *sel1 = "HW" ; // to be consistent with TOFPreprocessor
480 Char_t out[100];
481 sprintf(out,"%s/%s",sel,sel1);
482 AliDebug(2,Form("Writing TOF online calib obj from hardware on CDB with run range [%i, %i] ",fFirstRun,fLastRun));
483 AliCDBId id(out,fFirstRun,fLastRun);
484 AliCDBMetaData *md = new AliCDBMetaData();
485 md->SetResponsible("Chiara Zampolli");
486 if (!fTOFCalOnlineHW) {
487 // deve uscire!!
488 }
489 man->Put(fTOFCalOnlineHW,id,md);
490 delete md;
491}
492//_____________________________________________________________________________
0cb9d099 493
494void AliTOFcalib::WriteParOnlineOnCDB(Char_t *sel)
495{
496 //Write calibration parameters to the CDB with infinite validity
497 AliCDBManager *man = AliCDBManager::Instance();
a7e9db2a 498 Char_t *sel1 = "ParOnline" ; // to be consistent with TOFPreprocessor
0cb9d099 499 Char_t out[100];
500 sprintf(out,"%s/%s",sel,sel1);
501 AliCDBRunRange runrange(fFirstRun,fLastRun);
502 AliDebug(2,Form("Writing TOF online calib obj on CDB with run range [%i, %i] ",runrange.GetFirstRun(),runrange.GetLastRun()));
503 AliCDBId id(out,runrange);
6dc9348d 504 AliCDBMetaData *md = new AliCDBMetaData();
d4ad0d6b 505 md->SetResponsible("Chiara Zampolli");
0a749fa5 506 if (!fTOFCalOnline) {
507 // deve uscire!!
85fc78e3 508 }
0a749fa5 509 man->Put(fTOFCalOnline,id,md);
5eaae242 510 delete md;
6dc9348d 511}
512//_____________________________________________________________________________
513
7fffa85b 514void AliTOFcalib::WriteParOnlinePulserOnCDB(Char_t *sel)
515{
516 //Write calibration parameters from pulser to the CDB with infinite validity
517 AliCDBManager *man = AliCDBManager::Instance();
518 Char_t *sel1 = "Pulser" ; // to be consistent with TOFPreprocessor
519 Char_t out[100];
520 sprintf(out,"%s/%s",sel,sel1);
521 AliCDBRunRange runrange(fFirstRun,fLastRun);
522 AliDebug(2,Form("Writing TOF online calib obj from pulser on CDB with run range [%i, %i] ",runrange.GetFirstRun(),runrange.GetLastRun()));
523 AliCDBId id(out,runrange);
524 AliCDBMetaData *md = new AliCDBMetaData();
525 md->SetResponsible("Chiara Zampolli");
526 if (!fTOFCalOnlinePulser) {
527 // deve uscire!!
528 }
529 man->Put(fTOFCalOnlinePulser,id,md);
530 delete md;
531}
532//_____________________________________________________________________________
533
534void AliTOFcalib::WriteParOnlineNoiseOnCDB(Char_t *sel)
535{
536 //Write calibration parameters from noise to the CDB with infinite validity
537 AliCDBManager *man = AliCDBManager::Instance();
538 Char_t *sel1 = "Noise" ; // to be consistent with TOFPreprocessor
539 Char_t out[100];
540 sprintf(out,"%s/%s",sel,sel1);
541 AliCDBRunRange runrange(fFirstRun,fLastRun);
542 AliDebug(2,Form("Writing TOF online calib obj from noise on CDB with run range [%i, %i] ",runrange.GetFirstRun(),runrange.GetLastRun()));
543 AliCDBId id(out,runrange);
544 AliCDBMetaData *md = new AliCDBMetaData();
545 md->SetResponsible("Chiara Zampolli");
546 if (!fTOFCalOnlineNoise) {
547 // deve uscire!!
548 }
549 man->Put(fTOFCalOnlineNoise,id,md);
550 delete md;
551}
552//_____________________________________________________________________________
553
554void AliTOFcalib::WriteParOnlineHWOnCDB(Char_t *sel)
555{
556 //Write calibration parameters from hardware to the CDB with infinite validity
557 AliCDBManager *man = AliCDBManager::Instance();
558 Char_t *sel1 = "HW" ; // to be consistent with TOFPreprocessor
559 Char_t out[100];
560 sprintf(out,"%s/%s",sel,sel1);
561 AliCDBRunRange runrange(fFirstRun,fLastRun);
562 AliDebug(2,Form("Writing TOF online calib obj from harware on CDB with run range [%i, %i] ",runrange.GetFirstRun(),runrange.GetLastRun()));
563 AliCDBId id(out,runrange);
564 AliCDBMetaData *md = new AliCDBMetaData();
565 md->SetResponsible("Chiara Zampolli");
566 if (!fTOFCalOnlineHW) {
567 // deve uscire!!
568 }
569 man->Put(fTOFCalOnlineHW,id,md);
570 delete md;
571}
572//_____________________________________________________________________________
573
0a749fa5 574void AliTOFcalib::WriteParOfflineOnCDB(Char_t *sel, const Char_t *validity, Int_t minrun, Int_t maxrun)
575{
340693af 576 //Write calibration parameters to the CDB
0cb9d099 577 SetFirstRun(minrun);
578 SetLastRun(maxrun);
6dc9348d 579 AliCDBManager *man = AliCDBManager::Instance();
0a749fa5 580 Char_t *sel1 = "ParOffline" ;
d4ad0d6b 581 Char_t out[100];
582 sprintf(out,"%s/%s",sel,sel1);
0cb9d099 583 AliDebug(2,Form("Writing TOF offline calib obj on CDB with run range [%i, %i] ",fFirstRun,fLastRun));
584 AliCDBId id(out,fFirstRun,fLastRun);
585 AliCDBMetaData *md = new AliCDBMetaData();
586 md->SetResponsible("Chiara Zampolli");
587 md->SetComment(validity);
588 man->Put(fTOFCalOffline,id,md);
589 delete md;
590}
591//_____________________________________________________________________________
592
593void AliTOFcalib::WriteParOfflineOnCDB(Char_t *sel, const Char_t *validity)
594{
595 //Write calibration parameters to the CDB with infinite validity
596 AliCDBManager *man = AliCDBManager::Instance();
597 Char_t *sel1 = "ParOffline" ;
598 Char_t out[100];
599 sprintf(out,"%s/%s",sel,sel1);
600 AliCDBRunRange runrange(fFirstRun,fLastRun);
601 AliDebug(2,Form("Writing TOF offline calib obj on CDB with run range [%i, %i] ",runrange.GetFirstRun(),runrange.GetLastRun()));
602 AliCDBId id(out,runrange);
d4ad0d6b 603 AliCDBMetaData *md = new AliCDBMetaData();
604 md->SetResponsible("Chiara Zampolli");
0a749fa5 605 md->SetComment(validity);
606 man->Put(fTOFCalOffline,id,md);
5eaae242 607 delete md;
d4ad0d6b 608}
609//_____________________________________________________________________________
610
17149e6b 611Bool_t AliTOFcalib::ReadConfigMapFromCDB(Char_t *sel, Int_t nrun)
612{
613 //Read calibration parameters from the CDB
614 AliCDBManager *man = AliCDBManager::Instance();
615 Char_t *sel1 = "Config" ;
616 Char_t out[100];
617 sprintf(out,"%s/%s",sel,sel1);
618 AliCDBEntry *entry = man->Get(out,nrun);
619 if (!entry) {
620 AliFatal("Exiting, no CDB object (ConfigMap) found!!!");
621 exit(0);
622 }
623 if(!entry->GetObject()){
624 AliFatal("Exiting, no CDB object (ConfigMap) found!!!");
625 exit(0);
626 }
627
628 fConfigMap =(TMap*)entry->GetObject();
629
630 return kTRUE;
631
632}
633//_____________________________________________________________________________
634
635Bool_t AliTOFcalib::ReadParOnlineDelayFromCDB(Char_t *sel, Int_t nrun)
636{
637 //Read calibration parameters from the CDB -------> new calib objs!!!!!
638 AliCDBManager *man = AliCDBManager::Instance();
639 Char_t *sel1 = "ParOnlineDelay" ;
640 Char_t out[100];
641 sprintf(out,"%s/%s",sel,sel1);
642 AliCDBEntry *entry = man->Get(out,nrun);
643 if (!entry) {
644 AliFatal("Exiting, no CDB object (ParOnlineDelay) found!!!");
645 exit(0);
646 }
647 if(!entry->GetObject()){
648 AliFatal("Exiting, no CDB object (ParOnlineDelay) found!!!");
649 exit(0);
650 }
651
652 fCal =(AliTOFChannelOnlineArray*)entry->GetObject();
653
654 return kTRUE;
655
656}
657//_____________________________________________________________________________
658
659Bool_t AliTOFcalib::ReadParOnlineStatusFromCDB(Char_t *sel, Int_t nrun)
660{
661 //Read calibration parameters from the CDB -------> new calib objs!!!!!
662 AliCDBManager *man = AliCDBManager::Instance();
663 Char_t *sel1 = "Status" ;
664 Char_t out[100];
665 sprintf(out,"%s/%s",sel,sel1);
666 AliCDBEntry *entry = man->Get(out,nrun);
667 if (!entry) {
668 AliFatal("Exiting, no CDB object (Status) found!!!");
669 exit(0);
670 }
671 if(!entry->GetObject()){
672 AliFatal("Exiting, no CDB object (Status) found!!!");
673 exit(0);
674 }
675
676 fStatus =(AliTOFChannelOnlineStatusArray*)entry->GetObject();
677
678 return kTRUE;
679
680}
681//_____________________________________________________________________________
682
0a749fa5 683Bool_t AliTOFcalib::ReadParOnlineFromCDB(Char_t *sel, Int_t nrun)
340693af 684{
685 //Read calibration parameters from the CDB
d4ad0d6b 686 AliCDBManager *man = AliCDBManager::Instance();
a7e9db2a 687 Char_t *sel1 = "ParOnline" ;
d4ad0d6b 688 Char_t out[100];
689 sprintf(out,"%s/%s",sel,sel1);
7a4f634e 690 AliCDBEntry *entry = man->Get(out,nrun);
c30c0a38 691 if (!entry) {
692 AliFatal("Exiting, no CDB object (ParOnline) found!!!");
693 exit(0);
694 }
7a4f634e 695 if(!entry->GetObject()){
c30c0a38 696 AliFatal("Exiting, no CDB object (ParOnline) found!!!");
697 exit(0);
7a4f634e 698 }
699
0a749fa5 700 fTOFCalOnline =(TObjArray*)entry->GetObject();
7fffa85b 701
702 return kTRUE;
703
704}
705//_____________________________________________________________________________
706
707Bool_t AliTOFcalib::ReadParOnlinePulserFromCDB(Char_t *sel, Int_t nrun)
708{
709 //Read calibration parameters from pulser from the CDB
710 AliCDBManager *man = AliCDBManager::Instance();
711 Char_t *sel1 = "Pulser" ;
712 Char_t out[100];
713 sprintf(out,"%s/%s",sel,sel1);
7fffa85b 714 AliCDBEntry *entry = man->Get(out,nrun);
c30c0a38 715 if (!entry) {
716 AliFatal("Exiting, no CDB object (Pulser) found!!!");
717 exit(0);
718 }
7fffa85b 719 if(!entry->GetObject()){
c30c0a38 720 AliFatal("Exiting, no CDB object (Pulser) found!!!");
721 exit(0);
7fffa85b 722 }
723
724 fTOFCalOnlinePulser =(TObjArray*)entry->GetObject();
725
726 return kTRUE;
727
728}
729//_____________________________________________________________________________
730
731Bool_t AliTOFcalib::ReadParOnlineNoiseFromCDB(Char_t *sel, Int_t nrun)
732{
733 //Read calibration parameters from noise from the CDB
734 AliCDBManager *man = AliCDBManager::Instance();
735 Char_t *sel1 = "Noise" ;
736 Char_t out[100];
737 sprintf(out,"%s/%s",sel,sel1);
7fffa85b 738 AliCDBEntry *entry = man->Get(out,nrun);
c30c0a38 739 if (!entry) {
740 AliFatal("Exiting, no CDB object (Noise) found!!!");
741 exit(0);
742 }
7fffa85b 743 if(!entry->GetObject()){
c30c0a38 744 AliFatal("Exiting, no CDB object (Noise) found!!!");
745 exit(0);
7fffa85b 746 }
747
748 fTOFCalOnlineNoise =(TObjArray*)entry->GetObject();
749
750 return kTRUE;
751
752}
753//_____________________________________________________________________________
754
755Bool_t AliTOFcalib::ReadParOnlineHWFromCDB(Char_t *sel, Int_t nrun)
756{
757 //Read calibration parameters from hardware from the CDB
758 AliCDBManager *man = AliCDBManager::Instance();
759 Char_t *sel1 = "HW" ;
760 Char_t out[100];
761 sprintf(out,"%s/%s",sel,sel1);
7fffa85b 762 AliCDBEntry *entry = man->Get(out,nrun);
c30c0a38 763 if (!entry) {
764 AliFatal("Exiting, no CDB object (HW map) found!!!");
765 exit(0);
766 }
7fffa85b 767 if(!entry->GetObject()){
c30c0a38 768 AliFatal("Exiting, no CDB object (HW map) found!!!");
769 exit(0);
7fffa85b 770 }
771
772 fTOFCalOnlineHW =(TObjArray*)entry->GetObject();
0a749fa5 773
1b20c168 774 return kTRUE;
7a4f634e 775
6dc9348d 776}
777//_____________________________________________________________________________
d4ad0d6b 778
0a749fa5 779Bool_t AliTOFcalib::ReadParOfflineFromCDB(Char_t *sel, Int_t nrun)
780{
781 //Read calibration parameters from the CDB
782 AliCDBManager *man = AliCDBManager::Instance();
783 Char_t *sel1 = "ParOffline" ;
784 Char_t out[100];
785 sprintf(out,"%s/%s",sel,sel1);
0a749fa5 786 AliCDBEntry *entry = man->Get(out,nrun);
c30c0a38 787 if (!entry) {
788 AliFatal("Exiting, no CDB object (ParOffline) found!!!");
789 exit(0);
790 }
0a749fa5 791 if(!entry->GetObject()){
c30c0a38 792 AliFatal("Exiting, no CDB object (ParOffline) found!!!");
793 exit(0);
0a749fa5 794 }
795 AliCDBMetaData * md = entry->GetMetaData();
796 fkValidity = md->GetComment();
797 fTOFCalOffline =(TObjArray*)entry->GetObject();
d4ad0d6b 798
0a749fa5 799 return kTRUE;
800
801}
802//_____________________________________________________________________________
40212801 803void AliTOFcalib::WriteSimHistoOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun, TH1F *histo){
340693af 804 //Write Sim miscalibration parameters to the CDB
d4ad0d6b 805
d4ad0d6b 806 fTOFSimToT=histo;
d4ad0d6b 807 AliCDBManager *man = AliCDBManager::Instance();
40212801 808 Char_t *sel1 = "SimHisto" ;
d4ad0d6b 809 Char_t out[100];
810 sprintf(out,"%s/%s",sel,sel1);
0a749fa5 811 AliCDBMetaData *mdhisto = new AliCDBMetaData();
812 mdhisto->SetResponsible("Chiara Zampolli");
40212801 813 AliCDBId id(out,minrun,maxrun);
814 man->Put(fTOFSimToT,id,mdhisto);
0a749fa5 815 delete mdhisto;
816}
817//_____________________________________________________________________________
40212801 818Bool_t AliTOFcalib::ReadSimHistoFromCDB(Char_t *sel, Int_t nrun)
0a749fa5 819{
820 //Read miscalibration parameters from the CDB
821 AliCDBManager *man = AliCDBManager::Instance();
822
40212801 823 // The Tot Histo
7a4f634e 824
40212801 825 Char_t *sel1 = "SimHisto" ;
d4ad0d6b 826 Char_t out[100];
827 sprintf(out,"%s/%s",sel,sel1);
c30c0a38 828 AliCDBEntry *entry = man->Get(out,nrun);
829 if (!entry) {
7a4f634e 830 AliFatal("Exiting, no CDB object (SimHisto) found!!!");
831 exit(0);
832 }
40212801 833 if(!entry->GetObject()){
7a4f634e 834 AliFatal("Exiting, no CDB object (SimHisto) found!!!");
835 exit(0);
836 }
40212801 837 TH1F *histo =(TH1F*)entry->GetObject();
d4ad0d6b 838 fTOFSimToT=histo;
52be7fb0 839 return kTRUE;
d4ad0d6b 840}
7037bd93 841//_____________________________________________________________________________
842void AliTOFcalib::WriteRecParOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun, AliTOFRecoParam *param){
843 //Write reconstruction parameters to the CDB
844
845 AliCDBManager *man = AliCDBManager::Instance();
7037bd93 846 AliCDBMetaData *md = new AliCDBMetaData();
847 md->SetResponsible("Silvia Arcelli");
848 Char_t *sel1 = "RecPar" ;
849 Char_t out[100];
850 sprintf(out,"%s/%s",sel,sel1);
851 AliCDBId id(out,minrun,maxrun);
852 man->Put(param,id,md);
853 delete md;
854}
855//_____________________________________________________________________________
856AliTOFRecoParam * AliTOFcalib::ReadRecParFromCDB(Char_t *sel, Int_t nrun)
857{
858 //Read reconstruction parameters from the CDB
859 AliCDBManager *man = AliCDBManager::Instance();
7037bd93 860 Char_t *sel1 = "RecPar" ;
861 Char_t out[100];
862 sprintf(out,"%s/%s",sel,sel1);
c30c0a38 863 AliCDBEntry *entry = man->Get(out,nrun);
864 if (!entry) {
7a4f634e 865 AliFatal("Exiting, no CDB object (RecPar) found!!!");
866 exit(0);
867 }
7a4f634e 868 if(!entry->GetObject()){
869 AliFatal("Exiting, no CDB object (RecPar) found!!!");
870 exit(0);
871 }
872
7037bd93 873 AliTOFRecoParam *param=(AliTOFRecoParam*)entry->GetObject();
874 return param;
875}
0a749fa5 876//-----------------------------------------------------------------------------
877// Calibration methods
878//-----------------------------------------------------------------------------
879void AliTOFcalib::CreateTreeFromCDB(Int_t minrun, Int_t maxrun){
880
881 // creating the chain with the trees for calibration
882 // collecting them from reference data
883 // from minrun to maxrun
884
885 Float_t p[CHENTRIESSMALL];
886 Int_t nentries;
887 fTree = new TTree("TOFCalib","Tree for TOF Calibration");
888 fTree->Branch("nentries",&nentries,"nentries/I");
889 fTree->Branch("TOFentries",p,"TOFentries[nentries]/F");
890 AliCDBManager *man = AliCDBManager::Instance();
891 AliCDBStorage *aStorage = man->GetStorage("local://$ALICE_ROOT");
892 for (Int_t irun = minrun;irun<=maxrun;irun++){
893 AliCDBEntry *entry = aStorage->Get("TOF/RefData/TreeForCalib",irun);
894 if (!entry){
895 AliInfo(Form("No entry found for run %i",irun));
896 }
897 else{
898 TTree *tree = new TTree();
899 tree = (TTree*)entry->GetObject();
900 tree->SetBranchAddress("nentries",&nentries);
901 tree->SetBranchAddress("TOFentries",p);
902 fTree->CopyEntries(tree);
903 delete tree;
904 fNruns++;
905 }
906 }
907 AliInfo(Form("Number of runs being analyzed %i",fNruns));
908}
909//-----------------------------------------------------------------------------
910void AliTOFcalib::CreateTreeFromGrid(Int_t minrun, Int_t maxrun){
911
912 // creating the chain with the trees for calibration
913 // collecting them from the Grid
914 // from minrun to maxrun
915
916 Float_t p[CHENTRIESSMALL];
917 Int_t nentries;
918 fTree = new TTree("TOFCalib","Tree for TOF Calibration");
919 fTree->SetDirectory(0);
920 fTree->Branch("nentries",&nentries,"nentries/I");
921 fTree->Branch("TOFentries",p,"TOFentries[nentries]/F");
922 AliInfo("connected to alien");
923 TGrid::Connect("alien://");
924
925 Char_t filename[100];
926 for (Int_t irun = minrun;irun<=maxrun;irun++){
927 sprintf(filename,"alien:///alice/cern.ch/user/c/czampolli/TOFCalibReference_%i.root",irun);
928 TFile *filegrid = TFile::Open(filename,"READ");
929 TTree *tree = (TTree*)filegrid->Get("T");
930 tree->SetBranchAddress("nentries",&nentries);
931 tree->SetBranchAddress("TOFentries",p);
932 fTree->CopyEntries(tree);
933 delete tree;
934 fNruns++;
935 }
936
937 AliInfo(Form("Number of runs being analyzed %i",fNruns));
938}
939//-----------------------------------------------------------------------------
940void AliTOFcalib::CreateTreeFromFile(Int_t minrun, Int_t maxrun){
941
942 // creating the tree with the trees for calibration
943 // collecting them from reference data (from file)
944 // from minrun to maxrun
945
946 Float_t p[CHENTRIESSMALL];
947 Int_t nentries;
948 fTree = new TTree("TOFCalib","Tree for TOF Calibration");
949 fTree->SetDirectory(0);
950 fTree->Branch("nentries",&nentries,"nentries/I");
951 fTree->Branch("TOFentries",p,"TOFentries[nentries]/F");
952 Char_t filename[100];
953 for (Int_t irun = minrun;irun<=maxrun;irun++){
954 sprintf(filename,"$ALICE_ROOT/TOF/RefData/TreeForCalib/fileout_%i.root",irun);
955 TFile *file = new TFile(filename,"READ");
956 TTree *tree = (TTree*)file->Get("T");
957 tree->SetBranchAddress("nentries",&nentries);
958 tree->SetBranchAddress("TOFentries",p);
959 fTree->CopyEntries(tree);
960 delete tree;
961 delete file;
962 file = 0x0;
963 fNruns++;
964 }
965
966 AliInfo(Form("Number of runs being analyzed %i",fNruns));
967}
968//-----------------------------------------------------------------------------
296591ad 969void AliTOFcalib::CreateChainFromGrid(Int_t minrun, Int_t maxrun){
970
971 // creating the chain with the trees for calibration
972 // collecting them from the Grid
973 // from minrun to maxrun
974
975 fChain = new TChain("T");
976 AliInfo("connected to alien");
977 TGrid::Connect("alien://");
978
979 Char_t filename[100];
980 for (Int_t irun = minrun;irun<=maxrun;irun++){
981 sprintf(filename,"alien:///alice/cern.ch/user/c/czampolli/TOFCalibReference_%i.root",irun);
982 fChain->Add(filename);
983 fNruns++;
984 }
985
986 AliInfo(Form("Number of runs being analyzed %i",fNruns));
987}
988//-----------------------------------------------------------------------------
0a749fa5 989Int_t AliTOFcalib::Calibrate(Int_t ichmin, Int_t ichmax, Option_t *optionSave, Option_t *optionFit){
7037bd93 990
0a749fa5 991 // calibrating summing more than one channels
992 // computing calibration parameters
993 // Returning codes:
994 // 0 -> everything was ok
995 // 1 -> no tree for calibration found
996 // 2 -> not enough statistics to perform calibration
997 // 3 -> problems with arrays
998
999 TH1::AddDirectory(0);
1000
1001 AliInfo(Form("*** Calibrating Histograms %s, summing more channels, from channel %i, to channel %i, storing Calib Pars in channel %i", GetName(),ichmin,ichmax,ichmin)) ;
1002 AliInfo(Form("Option for Saving histos = %s",optionSave )) ;
1003 AliInfo(Form("Option for Fitting Profile histos = %s",optionFit )) ;
1004
1005 Float_t p[CHENTRIESSMALL];
1006 Int_t nentries;
296591ad 1007 //fTree->SetBranchAddress("nentries",&nentries);
1008 //fTree->SetBranchAddress("TOFentries",p);
1009 fChain->SetBranchAddress("nentries",&nentries);
1010 fChain->SetBranchAddress("TOFentries",p);
0a749fa5 1011
1012 Float_t ntracksTotalmean =0;
1013 for (Int_t i=ichmin; i<ichmax; i++){
1014 Int_t ientry = -1;
1015 for (Int_t irun=0;irun<fNruns;irun++){
1016 ientry = i+irun*fNChannels;
296591ad 1017 //fTree->GetEntry(ientry);
1018 fChain->GetEntry(ientry);
0a749fa5 1019 Int_t ntracksRun=nentries/3;
1020 ntracksTotalmean+=ntracksRun;
1021 }
1022 }
1023
1024 if (ntracksTotalmean < MEANENTRIES) {
1025 AliInfo(Form(" Too small mean number of entires per channel (mean number = %f) not calibrating and exiting.....",ntracksTotalmean));
1026 return 2;
1027 }
1028
1029 //filling ToT and Time arrays
1030
1031 Int_t nbinToT = 100; // ToT bin width in Profile = 48.8 ps
1032 Float_t minToT = 0; // ns
1033 Float_t maxToT = 4.88; // ns
1034
1035 TH1F *hToT = new TH1F("htot","htot",nbinToT, minToT, maxToT);
1036 TH1F *hdeltaTime = new TH1F("hdeltaTime","hdeltaTime",200,2,4);
1037 Int_t ntracksTotal = 0;
1038 Int_t ntracksRun = 0;
1039 Double_t binsProfile[101]; // sized larger than necessary, the correct
1040 // dim being set in the booking of the profile
1041 Int_t nusefulbins=0;
1042 Float_t meantime=0;
1043 for (Int_t i = ichmin;i<ichmax;i++){
1044 Int_t ientry = -1;
1045 for (Int_t irun=0;irun<fNruns;irun++){
1046 ientry = i+irun*fNChannels;
296591ad 1047 //fTree->GetEntry(ientry);
1048 fChain->GetEntry(ientry);
0a749fa5 1049 ntracksTotal+=nentries/3;
1050 ntracksRun=nentries/3;
1051 AliDebug(2,Form("run %i, channel %i, nentries = %i, ntracks = %i",irun,i,nentries, ntracksRun));
1052 for (Int_t j=0;j<ntracksRun;j++){
1053 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
1054 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
1055 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
1056 Float_t tot = p[idxexToT];
1057 hdeltaTime->Fill(p[idxexTime]-p[idxexExTime]);
1058 meantime+=p[idxexTime]-p[idxexExTime];
1059 hToT->Fill(tot);
1060 }
1061 }
1062 }
1063 nusefulbins = FindBins(hToT,&binsProfile[0]);
1064 meantime/=ntracksTotal;
1065 AliDebug(2, Form("meantime = %f",meantime));
1066
1067 for (Int_t j=1;j<=nusefulbins;j++) {
1068 AliDebug(2,Form(" summing channels from %i to %i, nusefulbins = %i, bin %i = %f",ichmin,ichmax,nusefulbins,j,binsProfile[j]));
1069 }
1070
1071 TProfile* hSlewingProf = new TProfile("hSlewingProf", "hSlewingProf",nusefulbins, binsProfile, "G"); // CHECK THE BUILD OPTION, PLEASE!!!!!!
1072 TH2F * htimetot = new TH2F("htimetot","htimetot",nbinToT, minToT, maxToT,600,-5,10);
1073
1074 for (Int_t irun=0;irun<fNruns;irun++){
1075 Int_t ientry = -1;
1076 for (Int_t i=ichmin; i<ichmax; i++){
1077 ientry = i+irun*fNChannels;
296591ad 1078 //fTree->GetEntry(ientry);
1079 fChain->GetEntry(ientry);
0a749fa5 1080 ntracksRun=nentries/3;
1081 for (Int_t j=0;j<ntracksRun;j++){
1082 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
1083 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
1084 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
1085 Float_t tot = p[idxexToT];
1086 Float_t time = p[idxexTime]-p[idxexExTime];
1087 AliDebug (2, Form("track = %i, time = %f, tot = %f, time-meantime = %f",j,time, tot, time-meantime));
1088 hSlewingProf->Fill(tot,time); // if meantime is not used, the fill may be moved in the loop above
1089 htimetot->Fill(tot,time-meantime); // if meantime is not used, the fill may be moved in the loop above
1090 }
1091 }
1092 }
1093
1094 hSlewingProf->Fit("pol5",optionFit,"",0,4);
1095 TF1 * calibfunc = (TF1*)hSlewingProf->GetFunction("pol5");
1096 Float_t par[6];
1097 for(Int_t kk=0;kk<6;kk++){
1098 par[kk]=calibfunc->GetParameter(kk);
1099 AliDebug(2,Form("parameter %i = %f",kk,par[kk]));
1100 }
1101
1102 if(strstr(optionSave,"save")){
1103 TFile * fileProf = new TFile("TOFCalibSave.root","recreate");
1104 fileProf->cd();
1105 TString profName=Form("Profile%06i_%06i",ichmin,ichmax);
1106 TString timeTotName=Form("TimeTot%06i_%06i",ichmin,ichmax);
1107 TString totName=Form("Tot%06i_%06i",ichmin,ichmax);
1108 TString deltaName=Form("Delta%06i_%06i",ichmin,ichmax);
1109 hSlewingProf->Write(profName);
1110 htimetot->Write(timeTotName);
1111 hToT->Write(totName);
1112 hdeltaTime->Write(deltaName);
1113 fileProf->Close();
1114 delete fileProf;
1115 fileProf=0x0;
1116 }
1117
1118 delete hToT;
1119 hToT=0x0;
1120 delete hSlewingProf;
1121 hSlewingProf=0x0;
1122 delete htimetot;
1123 htimetot=0x0;
1124 delete hdeltaTime;
1125 hdeltaTime=0x0;
1126
1127 AliTOFChannelOffline * calChannel = (AliTOFChannelOffline*)fTOFCalOffline->At(ichmin);
1128 calChannel->SetSlewPar(par);
0cb9d099 1129 WriteParOfflineOnCDB("TOF/Calib","valid");
0a749fa5 1130 return 0;
1131}
1132//----------------------------------------------------------------------------
1133Int_t AliTOFcalib::Calibrate(Int_t i, Option_t *optionSave, Option_t *optionFit){
1134
1135 // computing calibration parameters for channel i
1136 // Returning codes:
1137 // 0 -> everything was ok
1138 // 1 -> no tree for calibration found
1139 // 2 -> not enough statistics to perform calibration
1140 // 3 -> problems with arrays
1141
1142 TH1::AddDirectory(0);
1143
1144 AliInfo(Form("*** Calibrating Histograms (one channel) %s", GetName())) ;
1145 AliInfo(Form("Option for Saving histos = %s",optionSave )) ;
1146 AliInfo(Form("Option for Fitting Profile histos = %s",optionFit )) ;
1147
1148 Float_t p[MAXCHENTRIESSMALL];
1149 Int_t nentries;
296591ad 1150 //fTree->SetBranchAddress("nentries",&nentries);
1151 //fTree->SetBranchAddress("TOFentries",p);
1152 fChain->SetBranchAddress("nentries",&nentries);
1153 fChain->SetBranchAddress("TOFentries",p);
0a749fa5 1154
1155 Float_t ntracksTotal =0;
1156 for (Int_t irun=0;irun<fNruns;irun++){
1157 Int_t ientry = -1;
1158 ientry = i+irun*fNChannels;
296591ad 1159 //fTree->GetEntry(ientry);
1160 fChain->GetEntry(ientry);
0a749fa5 1161 ntracksTotal+=nentries/3;
1162 }
1163
1164 if (ntracksTotal < MEANENTRIES) {
1165 AliInfo(Form(" Too small mean number of entires per channel (mean number = %f) not calibrating and exiting.....",ntracksTotal));
1166 return 2;
1167 }
1168
1169 //filling ToT and Time arrays
1170
1171 Int_t nbinToT = 100; // ToT bin width in Profile = 48.8 ps
1172 Float_t minToT = 0; // ns
1173 Float_t maxToT = 4.88; // ns
1174
1175 TH1F *hToT = new TH1F("htot","htot",nbinToT, minToT, maxToT);
1176 TH1F *hdeltaTime = new TH1F("hdeltaTime","hdeltaTime",200,2,4);
1177 Int_t ntracksRun = 0;
1178 Double_t binsProfile[101]; // sized larger than necessary, the correct
1179 // dim being set in the booking of the profile
1180 Int_t nusefulbins=0;
1181 Float_t meantime=0;
1182 for (Int_t irun=0;irun<fNruns;irun++){
1183 Int_t ientry = -1;
1184 ientry = i+irun*fNChannels;
296591ad 1185 //fTree->GetEntry(ientry);
1186 fChain->GetEntry(ientry);
0a749fa5 1187 ntracksRun=nentries/3;
1188 AliDebug(2,Form("run %i, channel %i, nentries = %i, ntracksRun = %i",irun, i ,nentries, ntracksRun));
1189 for (Int_t j=0;j<ntracksRun;j++){
1190 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
1191 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
1192 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
1193 Float_t tot = p[idxexToT];
1194 meantime+=p[idxexTime]-p[idxexExTime];
1195 hdeltaTime->Fill(p[idxexTime]-p[idxexExTime]);
1196 hToT->Fill(tot);
1197 }
1198 }
1199
1200 nusefulbins = FindBins(hToT,&binsProfile[0]);
1201 meantime/=ntracksTotal;
1202 AliDebug(2,Form("meantime = %f",meantime));
1203
1204 for (Int_t j=1;j<=nusefulbins;j++) {
1205 AliDebug(2,Form(" channel %i, nusefulbins = %i, bin %i = %f",i,nusefulbins,j,binsProfile[j]));
1206 }
1207
1208 TProfile* hSlewingProf = new TProfile("hSlewingProf", "hSlewingProf",nusefulbins, binsProfile, "G"); // CHECK THE BUILD OPTION, PLEASE!!!!!!
1209 TH2F * htimetot = new TH2F("htimetot","htimetot",nbinToT, minToT, maxToT,600,-5,10);
1210 for (Int_t irun=0;irun<fNruns;irun++){
1211 Int_t ientry = -1;
1212 ientry = i+irun*fNChannels;
296591ad 1213 //fTree->GetEntry(ientry);
1214 fChain->GetEntry(ientry);
0a749fa5 1215 ntracksRun=nentries/3;
1216 for (Int_t j=0;j<ntracksRun;j++){
1217 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
1218 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
1219 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
1220 Float_t tot = p[idxexToT];
1221 Float_t time = p[idxexTime]-p[idxexExTime];
1222 AliDebug (2,Form("track = %i, time = %f, tot = %f, time-meantime = %f",j,time, tot, time-meantime));
1223 hSlewingProf->Fill(tot,time); // if meantime is not used, the fill may be moved in the loop above
1224 htimetot->Fill(tot,time-meantime); // if meantime is not used, the fill may be moved in the loop above
1225 }
1226 }
1227
1228 hSlewingProf->Fit("pol5",optionFit,"",0,4);
1229 TF1 * calibfunc = (TF1*)hSlewingProf->GetFunction("pol5");
1230 Float_t par[6];
1231 for(Int_t kk=0;kk<6;kk++){
1232 par[kk]=calibfunc->GetParameter(kk);
1233 AliDebug(2,Form("parameter %i = %f",kk,par[kk]));
1234 }
1235
1236
1237 if(strstr(optionSave,"save")){
1238 TFile * fileProf = new TFile("TOFCalibSave.root","recreate");
1239 fileProf->cd();
1240 TString profName=Form("Profile%06i",i);
1241 TString timeTotName=Form("TimeTot%06i",i);
1242 TString totName=Form("Tot%06i",i);
1243 TString deltaName=Form("Delta%06i",i);
1244 hSlewingProf->Write(profName);
1245 htimetot->Write(timeTotName);
1246 hToT->Write(totName);
1247 hdeltaTime->Write(deltaName);
1248 fileProf->Close();
1249 delete fileProf;
1250 fileProf=0x0;
1251 }
1252
1253 delete hToT;
1254 hToT=0x0;
1255 delete hSlewingProf;
1256 hSlewingProf=0x0;
1257 delete htimetot;
1258 htimetot=0x0;
1259 delete hdeltaTime;
1260 hdeltaTime=0x0;
1261
1262 AliTOFChannelOffline * calChannel = (AliTOFChannelOffline*)fTOFCalOffline->At(i);
1263 calChannel->SetSlewPar(par);
0cb9d099 1264 WriteParOfflineOnCDB("TOF/Calib","valid");
0a749fa5 1265 return 0;
1266}
1267//----------------------------------------------------------------------------
1268Int_t AliTOFcalib::Calibrate(Int_t nch, Int_t *ch, Option_t *optionSave, Option_t *optionFit){
1269
1270 // calibrating an array of channels
1271 // computing calibration parameters
1272 // Returning codes:
1273 // 0 -> everything was ok
1274 // 1 -> no tree for calibration found
1275 // 2 -> not enough statistics to perform calibration
1276 // 3 -> problems with arrays
1277
1278 TH1::AddDirectory(0);
1279
1280 AliInfo(Form("*** Calibrating Histograms %s, number of channels = %i", GetName(),nch)) ;
1281 AliInfo(Form("Option for Saving histos = %s",optionSave )) ;
1282 AliInfo(Form("Option for Fitting Profile histos = %s",optionFit )) ;
1283 for (Int_t ich=0; ich<nch; ich++){
1284 Int_t i = ch[ich];
1285 AliInfo(Form("Calibrating channel = %i",i )) ;
1286 }
1287 Float_t p[MAXCHENTRIESSMALL];
1288 Int_t nentries;
296591ad 1289 //fTree->SetBranchAddress("nentries",&nentries);
1290 //fTree->SetBranchAddress("TOFentries",p);
1291 fChain->SetBranchAddress("nentries",&nentries);
1292 fChain->SetBranchAddress("TOFentries",p);
0a749fa5 1293
1294 Float_t ntracksTotalmean =0;
1295 for (Int_t ich=0; ich<nch; ich++){
1296 Int_t ientry = -1;
1297 Int_t i = ch[ich];
1298 for (Int_t irun=0;irun<fNruns;irun++){
1299 ientry = i+irun*fNChannels;
296591ad 1300 //fTree->GetEntry(ientry);
1301 fChain->GetEntry(ientry);
0a749fa5 1302 ntracksTotalmean+=nentries/3;
1303 }
1304 }
1305
1306 ntracksTotalmean/=nch;
1307 if (ntracksTotalmean < MEANENTRIES) {
1308 AliInfo(Form(" Too small mean number of entires per channel (mean number = %f) not calibrating and exiting.....",ntracksTotalmean));
1309 return 2;
1310 }
1311
1312 //filling ToT and Time arrays
1313
1314 Int_t nbinToT = 100; // ToT bin width in Profile = 48.8 ps
1315 Float_t minToT = 0; // ns
1316 Float_t maxToT = 4.88; // ns
1317 TFile * fileProf=0x0;
1318 if(strstr(optionSave,"save")){
1319 fileProf = new TFile("TOFCalibSave.root","recreate");
1320 }
1321 for (Int_t ich=0; ich<nch; ich++) {
1322 TH1F *hToT = new TH1F("htot","htot",nbinToT, minToT, maxToT);
1323 TH1F *hdeltaTime = new TH1F("hdeltaTime","hdeltaTime",200,2,4);
1324 Double_t binsProfile[101]; // sized larger than necessary, the correct
1325 // dim being set in the booking of the profile
1326 TH2F * htimetot = new TH2F("htimetot","htimetot",nbinToT, minToT, maxToT,600,-5,10);
1327 Int_t ntracksTotal = 0;
1328 Int_t ntracksRun = 0;
1329 Int_t nusefulbins=0;
1330 Float_t meantime=0;
1331 Int_t i=-1;
1332 for (Int_t irun=0;irun<fNruns;irun++){
1333 i = ch[ich]+irun*fNChannels;
1334 AliDebug(2,Form("Calibrating channel %i",i));
296591ad 1335 //fTree->GetEntry(i);
1336 fChain->GetEntry(i);
0a749fa5 1337 ntracksTotal+=nentries/3;
1338 }
1339 if (ntracksTotal < MEANENTRIES) {
1340 AliInfo(Form(" Too small mean number of entires in channel %i (number of tracks = %f), not calibrating channel and continuing.....",i,ntracksTotal));
1341 continue;
1342 }
1343
1344 for (Int_t irun=0;irun<fNruns;irun++){
3c609b5c 1345 i = ch[ich]+irun*fNChannels;
296591ad 1346 //fTree->GetEntry(i);
1347 fChain->GetEntry(i);
0a749fa5 1348 ntracksRun=nentries/3;
1349 for (Int_t j=0;j<ntracksRun;j++){
1350 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
1351 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
1352 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
1353 Float_t tot = p[idxexToT];
1354 hdeltaTime->Fill(p[idxexTime]-p[idxexExTime]);
1355 meantime+=p[idxexTime]-p[idxexExTime];
1356 hToT->Fill(tot);
1357 }
1358 }
1359
1360 nusefulbins = FindBins(hToT,&binsProfile[0]);
1361 meantime/=ntracksTotal;
1362 for (Int_t j=1;j<=nusefulbins;j++) {
1363 AliDebug(2,Form(" channel %i, nusefulbins = %i, bin %i = %f",i,nusefulbins,j,binsProfile[j]));
1364 }
1365
1366 TProfile* hSlewingProf = new TProfile("hSlewingProf", "hSlewingProf",nusefulbins, binsProfile, "G"); // CHECK THE BUILD OPTION, PLEASE!!!!!!
1367 for (Int_t irun=0;irun<fNruns;irun++){
3c609b5c 1368 i = ch[ich]+irun*fNChannels;
296591ad 1369 //fTree->GetEntry(i);
1370 fChain->GetEntry(i);
0a749fa5 1371 ntracksRun=nentries/3;
1372 for (Int_t j=0;j<ntracksRun;j++){
1373 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
1374 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
1375 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
1376 Float_t tot = p[idxexToT];
1377 Float_t time = p[idxexTime]-p[idxexExTime];
1378 AliDebug(2,Form("track = %i, time = %f, tot = %f, time-meantime = %f",j,time, tot, time-meantime));
1379 hSlewingProf->Fill(tot,time); // if meantime is not used, the fill may be moved in the loop above
1380 htimetot->Fill(tot,time-meantime); // if meantime is not used, the fill may be moved in the loop above
1381 }
1382 }
1383
1384 hSlewingProf->Fit("pol5",optionFit,"",1,4);
1385 TF1 * calibfunc = (TF1*)hSlewingProf->GetFunction("pol5");
1386 Float_t par[6];
1387 for(Int_t kk=0;kk<6;kk++){
1388 par[kk]=calibfunc->GetParameter(kk);
1389 AliDebug(2,Form("parameter %i = %f",kk,par[kk]));
1390 }
1391
1392 if(strstr(optionSave,"save") && fileProf){
1393 TString profName=Form("Profile%06i",i);
1394 TString timeTotName=Form("TimeTot%06i",i);
1395 TString totName=Form("Tot%06i",i);
1396 TString deltaName=Form("Delta%06i",i);
1397 fileProf->cd();
1398 hSlewingProf->Write(profName);
1399 htimetot->Write(timeTotName);
1400 hToT->Write(totName);
1401 hdeltaTime->Write(deltaName);
1402 }
1403
1404 AliTOFChannelOffline * calChannel = (AliTOFChannelOffline*)fTOFCalOffline->At(i);
1405 calChannel->SetSlewPar(par);
1406 delete hToT;
1407 hToT=0x0;
1408 delete hSlewingProf;
1409 hSlewingProf=0x0;
1410 delete htimetot;
1411 htimetot=0x0;
1412 delete hdeltaTime;
1413 hdeltaTime=0x0;
1414 }
1415
1416 if(strstr(optionSave,"save") && fileProf){
1417 fileProf->Close();
1418 delete fileProf;
1419 fileProf=0x0;
1420 }
0cb9d099 1421 WriteParOfflineOnCDB("TOF/Calib","valid");
0a749fa5 1422
1423 return 0;
1424}
1425//----------------------------------------------------------------------------
1426Int_t AliTOFcalib::CalibrateFromProfile(Int_t ich, Option_t *optionSave, Option_t *optionFit){
1427
1428 // computing calibration parameters using the old profiling algo
1429 // Returning codes:
1430 // 0 -> everything was ok
1431 // 1 -> no tree for calibration found
1432 // 2 -> not enough statistics to perform calibration
1433 // 3 -> problems with arrays
1434
1435 TH1::AddDirectory(0);
1436
1437 AliInfo(Form("*** Calibrating Histograms From Profile %s", GetName())) ;
1438 AliInfo(Form("Option for Saving histos = %s",optionSave )) ;
1439 AliInfo(Form("Option for Fitting Profile histos = %s",optionFit )) ;
1440 Float_t p[MAXCHENTRIESSMALL];
1441 Int_t nentries;
1442 Int_t ntracksTotal=0;
296591ad 1443 //fTree->SetBranchAddress("nentries",&nentries);
1444 //fTree->SetBranchAddress("TOFentries",p);
1445 fChain->SetBranchAddress("nentries",&nentries);
1446 fChain->SetBranchAddress("TOFentries",p);
0a749fa5 1447
1448 for (Int_t irun=0;irun<fNruns;irun++){
1449 Int_t i = ich+irun*fNChannels;
296591ad 1450 //fTree->GetEntry(i);
1451 fChain->GetEntry(i);
0a749fa5 1452 ntracksTotal+=nentries/3;
1453 }
1454
1455 if (ntracksTotal < MEANENTRIES) {
1456 AliInfo(Form(" Too small mean number of entires per channel (mean number = %f) not calibrating and exiting.....",ntracksTotal));
1457 return 2;
1458 }
1459
1460 TH1F * hProf = new TH1F();
1461 hProf = Profile(ich);
1462 hProf->Fit("pol5",optionFit,"",0,4);
1463 TF1 * calibfunc = (TF1*)hProf->GetFunction("pol5");
1464 Float_t par[6];
1465 for(Int_t kk=0;kk<6;kk++){
1466 par[kk]=calibfunc->GetParameter(kk);
1467 AliDebug(2,Form("parameter %i = %f",kk,par[kk]));
1468 }
1469
1470 if(strstr(optionSave,"save")){
1471 TFile * fileProf = new TFile("TOFCalibSave.root","recreate");
1472 fileProf->cd();
1473 TString profName=Form("Profile%06i",ich);
1474 hProf->Write(profName);
1475 fileProf->Close();
1476 delete fileProf;
1477 fileProf=0x0;
1478 }
1479
1480 delete hProf;
1481 hProf=0x0;
1482 AliTOFChannelOffline * calChannel = (AliTOFChannelOffline*)fTOFCalOffline->At(ich);
1483 calChannel->SetSlewPar(par);
0cb9d099 1484 WriteParOfflineOnCDB("TOF/Calib","valid");
0a749fa5 1485 return 0;
1486}
1487//----------------------------------------------------------------------------
1488Int_t AliTOFcalib::Calibrate(Option_t *optionSave, Option_t *optionFit){
1489
1490 // calibrating the whole TOF
1491 // computing calibration parameters
1492 // Returning codes:
1493 // 0 -> everything was ok
1494 // 1 -> no tree for calibration found
1495 // 2 -> not enough statistics to perform calibration
1496 // 3 -> problems with arrays
1497
1498 TH1::AddDirectory(0);
1499
1500 AliInfo(Form("*** Calibrating Histograms %s, all channels", GetName())) ;
1501 AliInfo(Form("Option for Saving histos = %s",optionSave )) ;
1502 AliInfo(Form("Option for Fitting Profile histos = %s",optionFit )) ;
1503
1504 TFile * fileProf=0x0;
1505 if(strstr(optionSave,"save")){
1506 fileProf = new TFile("TOFCalibSave.root","recreate");
1507 }
1508
1509 Float_t p[MAXCHENTRIESSMALL];
1510 Int_t nentries;
296591ad 1511 //fTree->SetBranchAddress("nentries",&nentries);
1512 //fTree->SetBranchAddress("TOFentries",p);
1513 fChain->SetBranchAddress("nentries",&nentries);
1514 fChain->SetBranchAddress("TOFentries",p);
0a749fa5 1515
1516 Float_t ntracksTotalmean =0;
1517 for (Int_t ii=0; ii<fNChannels; ii++){
1518 for (Int_t irun=0;irun<fNruns;irun++){
1519 Int_t i = ii+irun*fNChannels;
296591ad 1520 //fTree->GetEntry(i);
1521 fChain->GetEntry(i);
0a749fa5 1522 ntracksTotalmean+=nentries/3;
1523 }
1524 }
1525
1526 ntracksTotalmean/=fNChannels;
1527 if (ntracksTotalmean < MEANENTRIES) {
1528 AliInfo(Form(" Too small mean number of entires per channel (mean number = %f) not calibrating and exiting.....",ntracksTotalmean));
1529 return 2;
1530 }
1531
1532 //filling ToT and Time arrays
1533
1534 Int_t nbinToT = 100; // ToT bin width in Profile = 50.0 ps
1535 Float_t minToT = 0; // ns
1536 Float_t maxToT = 4.88;// ns
1537 for (Int_t ii=0; ii<fNChannels; ii++) {
1538 TH1F *hToT = new TH1F("htot","htot",nbinToT, minToT, maxToT);
1539 TH1F *hdeltaTime = new TH1F("hdeltaTime","hdeltaTime",200,2,4);
1540 TH2F * htimetot = new TH2F("htimetot","htimetot",nbinToT, minToT, maxToT,600,-5,10);
1541 if (ii%1000 == 0) AliDebug(1,Form("Calibrating channel %i ",ii));
1542 //Int_t i = 3;
1543 Int_t nusefulbins=0;
1544 Double_t binsProfile[101]; // sized larger than necessary, the correct
1545 // dim being set in the booking of the profile
1546 Int_t ntracksRun = 0;
1547 Int_t ntracksTotal = 0;
1548 for (Int_t irun=0;irun<fNruns;irun++){
1549 Int_t i = ii+irun*fNChannels;
296591ad 1550 //fTree->GetEntry(i);
1551 fChain->GetEntry(i);
0a749fa5 1552 ntracksTotal+=nentries/3;
1553 }
1554 if (ntracksTotal < MEANENTRIES) {
1555 AliInfo(Form(" Too small mean number of entires in channel %i (number of tracks = %f), not calibrating channel and continuing.....",ii,ntracksTotal));
1556 continue;
1557 }
1558 Float_t meantime=0;
1559 for (Int_t irun=0;irun<fNruns;irun++){
1560 Int_t i = ii+irun*fNChannels;
296591ad 1561 //fTree->GetEntry(i);
1562 fChain->GetEntry(i);
0a749fa5 1563 ntracksRun=nentries/3;
1564 for (Int_t j=0;j<ntracksRun;j++){
1565 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
1566 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
1567 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
1568 Float_t tot = p[idxexToT];
1569 hdeltaTime->Fill(p[idxexTime]-p[idxexExTime]);
1570 meantime+=p[idxexTime]-p[idxexExTime];
1571 hToT->Fill(tot);
1572 }
1573 }
1574 nusefulbins = FindBins(hToT,&binsProfile[0]);
1575 meantime/=ntracksTotal;
1576 for (Int_t j=0;j<nusefulbins;j++) {
1577 AliDebug(2,Form(" channel %i, usefulbin = %i, low edge = %f",ii,j,binsProfile[j]));
1578 }
1579 TProfile* hSlewingProf = new TProfile("hSlewingProf", "hSlewingProf",nusefulbins, binsProfile, "G"); // CHECK THE BUILD OPTION, PLEASE!!!!!!
1580 for (Int_t irun=0;irun<fNruns;irun++){
1581 Int_t i = ii+irun*fNChannels;
296591ad 1582 //fTree->GetEntry(i);
1583 fChain->GetEntry(i);
0a749fa5 1584 ntracksRun=nentries/3;
1585 for (Int_t j=0;j<ntracksRun;j++){
1586 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
1587 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
1588 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
1589 Float_t tot = p[idxexToT];
1590 Float_t time = p[idxexTime]-p[idxexExTime];
1591 AliDebug (2,Form("track = %i, time = %f, tot = %f, time-meantime = %f",j,time, tot, time-meantime));
1592 hSlewingProf->Fill(tot,time); // if meantime is not used, the fill may be moved in the loop above
1593 htimetot->Fill(tot,time-meantime); // if meantime is not used, the fill may be moved in the loop above
1594 }
1595 }
1596 hSlewingProf->Fit("pol5",optionFit,"",1,4);
1597 TF1 * calibfunc = (TF1*)hSlewingProf->GetFunction("pol5");
1598 Float_t par[6];
1599 for(Int_t kk=0;kk<6;kk++){
1600 par[kk]=calibfunc->GetParameter(kk);
1601 AliDebug(2,Form("parameter %i = %f",kk,par[kk]));
1602 }
1603
1604 if(strstr(optionSave,"save") && fileProf){
1605 TString profName=Form("Profile%06i",ii);
1606 TString timeTotName=Form("TimeTot%06i",ii);
1607 TString totName=Form("Tot%06i",ii);
1608 TString deltaName=Form("Delta%06i",ii);
1609 fileProf->cd();
1610 hSlewingProf->Write(profName);
1611 htimetot->Write(timeTotName);
1612 hToT->Write(totName);
1613 hdeltaTime->Write(deltaName);
1614 }
1615 AliTOFChannelOffline * calChannel = (AliTOFChannelOffline*)fTOFCalOffline->At(ii);
1616 calChannel->SetSlewPar(par);
1617
1618 delete hToT;
1619 hToT=0x0;
1620 delete hSlewingProf;
1621 hSlewingProf=0x0;
1622 delete htimetot;
1623 htimetot=0x0;
1624 delete hdeltaTime;
1625 hdeltaTime=0x0;
1626 }
1627
1628 if(strstr(optionSave,"save")){
1629 fileProf->Close();
1630 delete fileProf;
1631 fileProf=0x0;
1632 }
0cb9d099 1633 WriteParOfflineOnCDB("TOF/Calib","valid");
0a749fa5 1634 return 0;
1635}
1636
1637//-----------------------------------------------------------------------
1638TH1F* AliTOFcalib::Profile(Int_t ich)
340693af 1639{
0a749fa5 1640 // profiling algo
1641
1642 Float_t p[MAXCHENTRIESSMALL];
1643 Int_t nentries;
296591ad 1644 //fTree->SetBranchAddress("nentries",&nentries);
1645 //fTree->SetBranchAddress("TOFentries",p);
1646 fChain->SetBranchAddress("nentries",&nentries);
1647 fChain->SetBranchAddress("TOFentries",p);
0a749fa5 1648
1649 //Prepare histograms for Slewing Correction
1650 const Int_t knbinToT = 100;
1651 Int_t nbinTime = 200;
1652 Float_t minTime = -5.5; //ns
1653 Float_t maxTime = 5.5; //ns
1654 Float_t minToT = 0; //ns
1655 Float_t maxToT = 5.; //ns
1656 Float_t deltaToT = (maxToT-minToT)/knbinToT;
1657 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];
1658 Int_t n[knbinToT+1], nentrx[knbinToT+1];
1659 Double_t sigmaToT[knbinToT+1];
1660 for (Int_t i = 0; i < knbinToT+1 ; i++){
1661 mTime[i]=0;
1662 mToT[i]=0;
1663 n[i]=0;
1664 meanTime[i]=0;
1665 meanTime2[i]=0;
1666 vToT[i]=0;
1667 vToT2[i]=0;
1668 meanToT[i]=0;
1669 meanToT2[i]=0;
1670 vTime[i]=0;
1671 vTime2[i]=0;
1672 xlow[i]=0;
1673 sigmaTime[i]=0;
1674 sigmaToT[i]=0;
1675 n[i]=0;
1676 nentrx[i]=0;
1677 }
1678 TH2F* hSlewing = new TH2F("hSlewing", "hSlewing", knbinToT, minToT, maxToT, nbinTime, minTime, maxTime);
1679 Int_t ntracksRun = 0;
1680 TH1F *histo = new TH1F("histo", "1D Time vs ToT", knbinToT, minToT, maxToT);
1681 for (Int_t irun=0;irun<fNruns;irun++){
1682 Int_t i = ich+irun*fNChannels;
296591ad 1683 //fTree->GetEntry(i);
1684 fChain->GetEntry(i);
0a749fa5 1685 ntracksRun=nentries/3;
1686 for (Int_t j=0;j<ntracksRun;j++){
1687 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
1688 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
1689 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
1690 Float_t tot = p[idxexToT];
1691 Float_t time = p[idxexTime]-p[idxexExTime];
1692 Int_t nx = (Int_t)((tot-minToT)/deltaToT)+1;
1693 if ((tot != 0) && ( time!= 0)){
1694 vTime[nx]+=time;
1695 vTime2[nx]+=time*time;
1696 vToT[nx]+=tot;
1697 vToT2[nx]+=tot*tot;
1698 nentrx[nx]++;
1699 hSlewing->Fill(tot,time);
1700 }
1701 }
1702 }
1703 Int_t nbinsToT=hSlewing->GetNbinsX();
1704 if (nbinsToT != knbinToT) {
1705 AliError("Profile :: incompatible numbers of bins");
1706 return 0x0;
1707 }
1708
1709 Int_t usefulBins=0;
1710 for (Int_t i=1;i<=nbinsToT;i++){
1711 if (nentrx[i]!=0){
1712 n[usefulBins]+=nentrx[i];
1713 if (n[usefulBins]==0 && i == nbinsToT) {
1714 break;
1715 }
1716 meanTime[usefulBins]+=vTime[i];
1717 meanTime2[usefulBins]+=vTime2[i];
1718 meanToT[usefulBins]+=vToT[i];
1719 meanToT2[usefulBins]+=vToT2[i];
1720 if (n[usefulBins]<10 && i!=nbinsToT) continue;
1721 mTime[usefulBins]=meanTime[usefulBins]/n[usefulBins];
1722 mToT[usefulBins]=meanToT[usefulBins]/n[usefulBins];
1723 sigmaTime[usefulBins]=TMath::Sqrt(1./n[usefulBins]/n[usefulBins]
1724 *(meanTime2[usefulBins]-meanTime[usefulBins]
1725 *meanTime[usefulBins]/n[usefulBins]));
1726 if ((1./n[usefulBins]/n[usefulBins]
1727 *(meanToT2[usefulBins]-meanToT[usefulBins]
1728 *meanToT[usefulBins]/n[usefulBins]))< 0) {
1729 AliError(" too small radical" );
1730 sigmaToT[usefulBins]=0;
1731 }
1732 else{
1733 sigmaToT[usefulBins]=TMath::Sqrt(1./n[usefulBins]/n[usefulBins]
1734 *(meanToT2[usefulBins]-meanToT[usefulBins]
1735 *meanToT[usefulBins]/n[usefulBins]));
1736 }
1737 usefulBins++;
1738 }
1739 }
1740 for (Int_t i=0;i<usefulBins;i++){
1741 Int_t binN = (Int_t)((mToT[i]-minToT)/deltaToT)+1;
1742 histo->Fill(mToT[i],mTime[i]);
1743 histo->SetBinError(binN,sigmaTime[i]);
1744 }
1745 delete hSlewing;
1746 hSlewing=0x0;
1747
1748 return histo;
6dc9348d 1749}
0a749fa5 1750//----------------------------------------------------------------------------
1751Int_t AliTOFcalib::FindBins(TH1F* h, Double_t *binsProfile) const{
6dc9348d 1752
0a749fa5 1753 // to determine the bins for ToT histo
1754
1755 Int_t cont = 0;
1756 Int_t startBin = 1;
1757 Int_t nbin = h->GetNbinsX();
1758 Int_t nentries = (Int_t)h->GetEntries();
1759 Float_t max = h->GetBinLowEdge(nbin);
1760 Int_t nusefulbins=0;
1761 Int_t maxcont=0;
1762 // setting maxvalue of entries per bin
1763 if (nentries <= 60) maxcont = 2;
1764 else if (nentries <= 100) maxcont = 5;
1765 else if (nentries <= 500) maxcont = 10;
1766 else maxcont = 20;
1767 for (Int_t j=1;j<=nbin;j++) {
1768 cont += (Int_t)h->GetBinContent(j);
1769 if (j<nbin){
1770 if (cont>=maxcont){
1771 nusefulbins++;
1772 binsProfile[nusefulbins-1]=h->GetBinLowEdge(startBin);
1773 cont=0;
1774 startBin=j+1;
1775 continue;
1776 }
1777 }
1778 else{
1779 if (cont>=maxcont){
1780 nusefulbins++;
1781 binsProfile[nusefulbins-1]=h->GetBinLowEdge(startBin);
1782 binsProfile[nusefulbins]=max;
1783 }
1784 else {
1785 binsProfile[nusefulbins]=h->GetBinLowEdge(startBin);
1786 }
1787 }
1788 }
1789 return nusefulbins;
1790}