]> 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
coding convention - RN17 violation: suppressed
[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/*
17$Log$
0a749fa5 18Revision 1.14 2007/06/06 16:26:30 arcelli
19remove fall-back call to local CDB storage
20
03705065 21Revision 1.13 2007/04/20 13:59:40 arcelli
22make protections agains failed retrieval of the CDB object in a proper way
23
7a4f634e 24Revision 1.12 2007/03/23 11:31:16 arcelli
25CDB Entry for TOF Reconstruction Parameters
26
7037bd93 27Revision 1.11 2007/02/28 18:08:26 arcelli
28Add protection against failed retrieval of the CDB cal object
29
1b20c168 30Revision 1.10 2006/08/22 13:30:49 arcelli
31removal of effective c++ warnings (C.Zampolli)
32
655e379f 33Revision 1.9 2006/04/20 22:30:50 hristov
34Coding conventions (Annalisa)
35
0e46b9ae 36Revision 1.8 2006/04/16 22:29:05 hristov
37Coding conventions (Annalisa)
38
7aeeaf38 39Revision 1.7 2006/04/16 20:12:46 hristov
40Removing memory leak in case of cached CDB entries
41
85fc78e3 42Revision 1.6 2006/04/11 15:28:32 hristov
43Checks on cache status before deleting calibration objects (A.Colla)
44
5eaae242 45Revision 1.5 2006/04/05 08:35:38 hristov
46Coding conventions (S.Arcelli, C.Zampolli)
47
340693af 48Revision 1.4 2006/03/31 11:26:46 arcelli
49 changing CDB Ids according to standard convention
50
28dd10b6 51Revision 1.3 2006/03/28 14:57:02 arcelli
52updates to handle new V5 geometry & some re-arrangements
53
d4ad0d6b 54Revision 1.2 2006/02/13 17:22:26 arcelli
55just Fixing Log info
56
762446e0 57Revision 1.1 2006/02/13 16:10:48 arcelli
58Add classes for TOF Calibration (C.Zampolli)
59
6dc9348d 60author: Chiara Zampolli, zampolli@bo.infn.it
762446e0 61*/
6dc9348d 62
63///////////////////////////////////////////////////////////////////////////////
64// //
65// class for TOF calibration //
66// //
67///////////////////////////////////////////////////////////////////////////////
68
6dc9348d 69#include "TF1.h"
0e46b9ae 70#include "TFile.h"
6dc9348d 71#include "TH1F.h"
72#include "TH2F.h"
6dc9348d 73#include "TList.h"
0e46b9ae 74#include "TROOT.h"
75#include "TStyle.h"
0a749fa5 76#include "TTree.h"
77#include "TProfile.h"
78#include "TGrid.h"
0e46b9ae 79
80#include "AliCDBEntry.h"
81#include "AliCDBId.h"
6dc9348d 82#include "AliCDBManager.h"
0a749fa5 83#include "AliCDBStorage.h"
6dc9348d 84#include "AliCDBMetaData.h"
0e46b9ae 85#include "AliESDtrack.h"
86#include "AliESD.h"
87#include "AliLog.h"
88
0e46b9ae 89#include "AliTOFcalib.h"
0a749fa5 90#include "AliTOFChannelOnline.h"
91#include "AliTOFChannelOffline.h"
0e46b9ae 92#include "AliTOFGeometry.h"
7037bd93 93#include "AliTOFRecoParam.h"
6dc9348d 94
95extern TROOT *gROOT;
96extern TStyle *gStyle;
97
98ClassImp(AliTOFcalib)
99
6dc9348d 100//_______________________________________________________________________
655e379f 101AliTOFcalib::AliTOFcalib():
102 TTask("AliTOFcalib",""),
103 fNChannels(-1),
0a749fa5 104 fTOFCalOnline(0x0),
105 fTOFCalOffline(0x0),
106 fTOFSimCalOnline(0x0),
107 fTOFSimCalOffline(0x0),
108 fTOFSimToT(0x0),
109 fkValidity(0x0),
110 fTree(0x0),
111 fNruns(0)
655e379f 112{
340693af 113 //TOF Calibration Class ctor
0a749fa5 114 fNChannels = AliTOFGeometry::NSectors()*(2*(AliTOFGeometry::NStripC()+AliTOFGeometry::NStripB())+AliTOFGeometry::NStripA())*AliTOFGeometry::NpadZ()*AliTOFGeometry::NpadX();
6dc9348d 115}
116//____________________________________________________________________________
117
655e379f 118AliTOFcalib::AliTOFcalib(const AliTOFcalib & calib):
119 TTask("AliTOFcalib",""),
0a749fa5 120 fNChannels(calib.fNChannels),
121 fTOFCalOnline(0x0),
122 fTOFCalOffline(0x0),
123 fTOFSimCalOnline(0x0),
124 fTOFSimCalOffline(0x0),
125 fTOFSimToT(calib.fTOFSimToT),
126 fkValidity(calib.fkValidity),
127 fTree(calib.fTree),
128 fNruns(calib.fNruns)
6dc9348d 129{
340693af 130 //TOF Calibration Class copy ctor
0a749fa5 131 for (Int_t iarray = 0; iarray<fNChannels; iarray++){
132 AliTOFChannelOnline * calChOnline = (AliTOFChannelOnline*)calib.fTOFCalOnline->At(iarray);
133 AliTOFChannelOffline * calChOffline = (AliTOFChannelOffline*)calib.fTOFCalOffline->At(iarray);
134 fTOFCalOnline->AddAt(calChOnline,iarray);
135 fTOFCalOffline->AddAt(calChOffline,iarray);
136
137 AliTOFChannelOnline * simCalChOnline = (AliTOFChannelOnline*)calib.fTOFSimCalOnline->At(iarray);
138 AliTOFChannelOffline * simCalChOffline = (AliTOFChannelOffline*)calib.fTOFSimCalOffline->At(iarray);
139 fTOFSimCalOnline->AddAt(simCalChOnline,iarray);
140 fTOFSimCalOffline->AddAt(simCalChOffline,iarray);
141 }
6dc9348d 142}
143
144//____________________________________________________________________________
7aeeaf38 145
146AliTOFcalib& AliTOFcalib::operator=(const AliTOFcalib &calib)
147{
148 //TOF Calibration Class assignment operator
7aeeaf38 149 this->fNChannels = calib.fNChannels;
0a749fa5 150 this->fTOFSimToT = calib.fTOFSimToT;
151 this->fkValidity = calib.fkValidity;
152 this->fTree = calib.fTree;
153 this->fNruns = calib.fNruns;
154 for (Int_t iarray = 0; iarray<fNChannels; iarray++){
155 AliTOFChannelOnline * calChOnline = (AliTOFChannelOnline*)calib.fTOFCalOnline->At(iarray);
156 AliTOFChannelOffline * calChOffline = (AliTOFChannelOffline*)calib.fTOFCalOffline->At(iarray);
157 this->fTOFCalOnline->AddAt(calChOnline,iarray);
158 this->fTOFCalOffline->AddAt(calChOffline,iarray);
159 AliTOFChannelOnline * simCalChOnline = (AliTOFChannelOnline*)calib.fTOFSimCalOnline->At(iarray);
160 AliTOFChannelOffline * simCalChOffline = (AliTOFChannelOffline*)calib.fTOFSimCalOffline->At(iarray);
161 this->fTOFSimCalOnline->AddAt(simCalChOnline,iarray);
162 this->fTOFSimCalOffline->AddAt(simCalChOffline,iarray);
163 }
7aeeaf38 164 return *this;
165}
166
167//____________________________________________________________________________
6dc9348d 168
169AliTOFcalib::~AliTOFcalib()
170{
340693af 171 //TOF Calibration Class dtor
5eaae242 172 if(!(AliCDBManager::Instance()->GetCacheFlag())){ // CDB objects must NOT be deleted if cache is active!
0a749fa5 173 if (fTOFCalOnline){
174 fTOFCalOnline->Clear();
175 delete fTOFCalOnline;
6dc9348d 176 }
0a749fa5 177 if (fTOFCalOffline){
178 fTOFCalOffline->Clear();
179 delete fTOFCalOffline;
6dc9348d 180 }
0a749fa5 181 if (fTOFSimCalOnline){
182 fTOFSimCalOnline->Clear();
183 delete fTOFSimCalOnline;
6dc9348d 184 }
0a749fa5 185 if (fTOFSimCalOffline){
186 fTOFSimCalOffline->Clear();
187 delete fTOFSimCalOffline;
6dc9348d 188 }
189 }
0a749fa5 190 if (fTree!=0x0) delete fTree;
6dc9348d 191}
192//_____________________________________________________________________________
0a749fa5 193void AliTOFcalib::CreateCalArrays(){
6dc9348d 194
0a749fa5 195 // creating arrays for online/offline calibration objs
6dc9348d 196
0a749fa5 197 fTOFCalOnline = new TObjArray(fNChannels);
198 fTOFCalOffline = new TObjArray(fNChannels);
199 fTOFCalOnline->SetOwner();
200 fTOFCalOffline->SetOwner();
201 for (Int_t iarray = 0; iarray<fNChannels; iarray++){
202 AliTOFChannelOnline * calChOnline = new AliTOFChannelOnline();
203 AliTOFChannelOffline * calChOffline = new AliTOFChannelOffline();
204 fTOFCalOnline->AddAt(calChOnline,iarray);
205 fTOFCalOffline->AddAt(calChOffline,iarray);
6dc9348d 206 }
207}
208//_____________________________________________________________________________
0a749fa5 209void AliTOFcalib::CreateSimCalArrays(){
6dc9348d 210
0a749fa5 211 // creating arrays for simulation online/offline calibration objs
d4ad0d6b 212
0a749fa5 213 fTOFSimCalOnline = new TObjArray(fNChannels);
214 fTOFSimCalOffline = new TObjArray(fNChannels);
215 fTOFSimCalOnline->SetOwner();
216 fTOFSimCalOffline->SetOwner();
217 for (Int_t iarray = 0; iarray<fNChannels; iarray++){
218 AliTOFChannelOnline * simCalChOnline = new AliTOFChannelOnline();
219 AliTOFChannelOffline * simCalChOffline = new AliTOFChannelOffline();
220 fTOFSimCalOnline->AddAt(simCalChOnline,iarray);
221 fTOFSimCalOffline->AddAt(simCalChOffline,iarray);
6dc9348d 222 }
223}
224//_____________________________________________________________________________
225
0a749fa5 226void AliTOFcalib::WriteParOnlineOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun)
340693af 227{
228 //Write calibration parameters to the CDB
6dc9348d 229 AliCDBManager *man = AliCDBManager::Instance();
0a749fa5 230 Char_t *sel1 = "OnlineDelay" ; // to be consistent with TOFPreprocessor
d4ad0d6b 231 Char_t out[100];
232 sprintf(out,"%s/%s",sel,sel1);
233 AliCDBId id(out,minrun,maxrun);
6dc9348d 234 AliCDBMetaData *md = new AliCDBMetaData();
d4ad0d6b 235 md->SetResponsible("Chiara Zampolli");
0a749fa5 236 if (!fTOFCalOnline) {
237 // deve uscire!!
85fc78e3 238 }
0a749fa5 239 man->Put(fTOFCalOnline,id,md);
5eaae242 240 delete md;
6dc9348d 241}
242//_____________________________________________________________________________
243
0a749fa5 244void AliTOFcalib::WriteParOfflineOnCDB(Char_t *sel, const Char_t *validity, Int_t minrun, Int_t maxrun)
245{
340693af 246 //Write calibration parameters to the CDB
6dc9348d 247 AliCDBManager *man = AliCDBManager::Instance();
0a749fa5 248 Char_t *sel1 = "ParOffline" ;
d4ad0d6b 249 Char_t out[100];
250 sprintf(out,"%s/%s",sel,sel1);
251 AliCDBId id(out,minrun,maxrun);
252 AliCDBMetaData *md = new AliCDBMetaData();
253 md->SetResponsible("Chiara Zampolli");
0a749fa5 254 md->SetComment(validity);
255 man->Put(fTOFCalOffline,id,md);
5eaae242 256 delete md;
d4ad0d6b 257}
258//_____________________________________________________________________________
259
0a749fa5 260Bool_t AliTOFcalib::ReadParOnlineFromCDB(Char_t *sel, Int_t nrun)
340693af 261{
262 //Read calibration parameters from the CDB
d4ad0d6b 263 AliCDBManager *man = AliCDBManager::Instance();
0a749fa5 264 Char_t *sel1 = "OnlineDelay" ;
d4ad0d6b 265 Char_t out[100];
266 sprintf(out,"%s/%s",sel,sel1);
7a4f634e 267 if (!man->Get(out,nrun)) {
268 return kFALSE;
1b20c168 269 }
7a4f634e 270 AliCDBEntry *entry = man->Get(out,nrun);
271 if(!entry->GetObject()){
272 return kFALSE;
273 }
274
0a749fa5 275 fTOFCalOnline =(TObjArray*)entry->GetObject();
276
1b20c168 277 return kTRUE;
7a4f634e 278
6dc9348d 279}
280//_____________________________________________________________________________
d4ad0d6b 281
0a749fa5 282Bool_t AliTOFcalib::ReadParOfflineFromCDB(Char_t *sel, Int_t nrun)
283{
284 //Read calibration parameters from the CDB
285 AliCDBManager *man = AliCDBManager::Instance();
286 Char_t *sel1 = "ParOffline" ;
287 Char_t out[100];
288 sprintf(out,"%s/%s",sel,sel1);
289 if (!man->Get(out,nrun)) {
290 return kFALSE;
d4ad0d6b 291 }
0a749fa5 292 AliCDBEntry *entry = man->Get(out,nrun);
293 if(!entry->GetObject()){
294 return kFALSE;
295 }
296 AliCDBMetaData * md = entry->GetMetaData();
297 fkValidity = md->GetComment();
298 fTOFCalOffline =(TObjArray*)entry->GetObject();
d4ad0d6b 299
0a749fa5 300 return kTRUE;
301
302}
303//_____________________________________________________________________________
304void AliTOFcalib::WriteSimParOnlineOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun, TObjArray *calOnline){
305 //Write Sim miscalibration parameters to the CDB
d4ad0d6b 306
0a749fa5 307 fTOFSimCalOnline=calOnline;
d4ad0d6b 308 AliCDBManager *man = AliCDBManager::Instance();
d4ad0d6b 309 AliCDBMetaData *md = new AliCDBMetaData();
310 md->SetResponsible("Chiara Zampolli");
0a749fa5 311 Char_t *sel1 = "SimParOnline" ;
d4ad0d6b 312 Char_t out[100];
313 sprintf(out,"%s/%s",sel,sel1);
314 AliCDBId id1(out,minrun,maxrun);
0a749fa5 315 man->Put(fTOFSimCalOnline,id1,md);
5eaae242 316 delete md;
d4ad0d6b 317}
d4ad0d6b 318//_____________________________________________________________________________
0a749fa5 319void AliTOFcalib::WriteSimParOfflineOnCDB(Char_t *sel, const Char_t *validity, Int_t minrun, Int_t maxrun, TObjArray *calOffline, TH1F *histo){
340693af 320 //Write Sim miscalibration parameters to the CDB
d4ad0d6b 321
d4ad0d6b 322 fTOFSimToT=histo;
0a749fa5 323 fTOFSimCalOffline=calOffline;
d4ad0d6b 324 AliCDBManager *man = AliCDBManager::Instance();
d4ad0d6b 325 AliCDBMetaData *md = new AliCDBMetaData();
326 md->SetResponsible("Chiara Zampolli");
0a749fa5 327 md->SetComment(validity);
328 Char_t *sel1 = "SimParOffline" ;
d4ad0d6b 329 Char_t out[100];
330 sprintf(out,"%s/%s",sel,sel1);
331 AliCDBId id1(out,minrun,maxrun);
0a749fa5 332 man->Put(fTOFSimCalOffline,id1,md);
28dd10b6 333 Char_t *sel2 = "SimHisto" ;
d4ad0d6b 334 sprintf(out,"%s/%s",sel,sel2);
0a749fa5 335 AliCDBMetaData *mdhisto = new AliCDBMetaData();
336 mdhisto->SetResponsible("Chiara Zampolli");
d4ad0d6b 337 AliCDBId id2(out,minrun,maxrun);
0a749fa5 338 man->Put(fTOFSimToT,id2,mdhisto);
5eaae242 339 delete md;
0a749fa5 340 delete mdhisto;
341}
342//_____________________________________________________________________________
343void AliTOFcalib::ReadSimParOnlineFromCDB(Char_t *sel, Int_t nrun)
344{
345 //Read miscalibration parameters from the CDB
346 AliCDBManager *man = AliCDBManager::Instance();
347
348 // The Slewing Pars
349
350 Char_t *sel1 = "SimParOnline" ;
351 Char_t out[100];
352 sprintf(out,"%s/%s",sel,sel1);
353 if (!man->Get(out,nrun)) {
354 AliFatal("Exiting, no CDB object (SimPar) found!!!");
355 exit(0);
356 }
357 AliCDBEntry *entry1 = man->Get(out,nrun);
358 if(!entry1->GetObject()){
359 AliFatal("Exiting, no CDB object (SimPar) found!!!");
360 exit(0);
361 }
362 TObjArray *cal =(TObjArray*)entry1->GetObject();
363 fTOFSimCalOnline=cal;
364
d4ad0d6b 365}
366//_____________________________________________________________________________
0a749fa5 367void AliTOFcalib::ReadSimParOfflineFromCDB(Char_t *sel, Int_t nrun)
340693af 368{
369 //Read miscalibration parameters from the CDB
d4ad0d6b 370 AliCDBManager *man = AliCDBManager::Instance();
7a4f634e 371
372 // The Slewing Pars
373
0a749fa5 374 Char_t *sel1 = "SimParOffline" ;
d4ad0d6b 375 Char_t out[100];
376 sprintf(out,"%s/%s",sel,sel1);
7a4f634e 377 if (!man->Get(out,nrun)) {
378 AliFatal("Exiting, no CDB object (SimPar) found!!!");
379 exit(0);
380 }
d4ad0d6b 381 AliCDBEntry *entry1 = man->Get(out,nrun);
7a4f634e 382 if(!entry1->GetObject()){
383 AliFatal("Exiting, no CDB object (SimPar) found!!!");
384 exit(0);
385 }
0a749fa5 386 TObjArray *cal =(TObjArray*)entry1->GetObject();
387 AliCDBMetaData *md = (AliCDBMetaData*)entry1->GetMetaData();
388 fkValidity = md->GetComment();
389 fTOFSimCalOffline=cal;
7a4f634e 390
391 // The Tot Histo
392
28dd10b6 393 Char_t *sel2 = "SimHisto" ;
d4ad0d6b 394 sprintf(out,"%s/%s",sel,sel2);
7a4f634e 395 if (!man->Get(out,nrun)) {
396 AliFatal("Exiting, no CDB object (SimHisto) found!!!");
397 exit(0);
398 }
d4ad0d6b 399 AliCDBEntry *entry2 = man->Get(out,nrun);
7a4f634e 400 if(!entry2->GetObject()){
401 AliFatal("Exiting, no CDB object (SimHisto) found!!!");
402 exit(0);
403 }
d4ad0d6b 404 TH1F *histo =(TH1F*)entry2->GetObject();
405 fTOFSimToT=histo;
406}
7037bd93 407//_____________________________________________________________________________
408void AliTOFcalib::WriteRecParOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun, AliTOFRecoParam *param){
409 //Write reconstruction parameters to the CDB
410
411 AliCDBManager *man = AliCDBManager::Instance();
7037bd93 412 AliCDBMetaData *md = new AliCDBMetaData();
413 md->SetResponsible("Silvia Arcelli");
414 Char_t *sel1 = "RecPar" ;
415 Char_t out[100];
416 sprintf(out,"%s/%s",sel,sel1);
417 AliCDBId id(out,minrun,maxrun);
418 man->Put(param,id,md);
419 delete md;
420}
421//_____________________________________________________________________________
422AliTOFRecoParam * AliTOFcalib::ReadRecParFromCDB(Char_t *sel, Int_t nrun)
423{
424 //Read reconstruction parameters from the CDB
425 AliCDBManager *man = AliCDBManager::Instance();
7037bd93 426 Char_t *sel1 = "RecPar" ;
427 Char_t out[100];
428 sprintf(out,"%s/%s",sel,sel1);
7a4f634e 429 if (!man->Get(out,nrun)) {
430 AliFatal("Exiting, no CDB object (RecPar) found!!!");
431 exit(0);
432 }
7037bd93 433 AliCDBEntry *entry = man->Get(out,nrun);
7a4f634e 434 if(!entry->GetObject()){
435 AliFatal("Exiting, no CDB object (RecPar) found!!!");
436 exit(0);
437 }
438
7037bd93 439 AliTOFRecoParam *param=(AliTOFRecoParam*)entry->GetObject();
440 return param;
441}
0a749fa5 442//-----------------------------------------------------------------------------
443// Calibration methods
444//-----------------------------------------------------------------------------
445void AliTOFcalib::CreateTreeFromCDB(Int_t minrun, Int_t maxrun){
446
447 // creating the chain with the trees for calibration
448 // collecting them from reference data
449 // from minrun to maxrun
450
451 Float_t p[CHENTRIESSMALL];
452 Int_t nentries;
453 fTree = new TTree("TOFCalib","Tree for TOF Calibration");
454 fTree->Branch("nentries",&nentries,"nentries/I");
455 fTree->Branch("TOFentries",p,"TOFentries[nentries]/F");
456 AliCDBManager *man = AliCDBManager::Instance();
457 AliCDBStorage *aStorage = man->GetStorage("local://$ALICE_ROOT");
458 for (Int_t irun = minrun;irun<=maxrun;irun++){
459 AliCDBEntry *entry = aStorage->Get("TOF/RefData/TreeForCalib",irun);
460 if (!entry){
461 AliInfo(Form("No entry found for run %i",irun));
462 }
463 else{
464 TTree *tree = new TTree();
465 tree = (TTree*)entry->GetObject();
466 tree->SetBranchAddress("nentries",&nentries);
467 tree->SetBranchAddress("TOFentries",p);
468 fTree->CopyEntries(tree);
469 delete tree;
470 fNruns++;
471 }
472 }
473 AliInfo(Form("Number of runs being analyzed %i",fNruns));
474}
475//-----------------------------------------------------------------------------
476void AliTOFcalib::CreateTreeFromGrid(Int_t minrun, Int_t maxrun){
477
478 // creating the chain with the trees for calibration
479 // collecting them from the Grid
480 // from minrun to maxrun
481
482 Float_t p[CHENTRIESSMALL];
483 Int_t nentries;
484 fTree = new TTree("TOFCalib","Tree for TOF Calibration");
485 fTree->SetDirectory(0);
486 fTree->Branch("nentries",&nentries,"nentries/I");
487 fTree->Branch("TOFentries",p,"TOFentries[nentries]/F");
488 AliInfo("connected to alien");
489 TGrid::Connect("alien://");
490
491 Char_t filename[100];
492 for (Int_t irun = minrun;irun<=maxrun;irun++){
493 sprintf(filename,"alien:///alice/cern.ch/user/c/czampolli/TOFCalibReference_%i.root",irun);
494 TFile *filegrid = TFile::Open(filename,"READ");
495 TTree *tree = (TTree*)filegrid->Get("T");
496 tree->SetBranchAddress("nentries",&nentries);
497 tree->SetBranchAddress("TOFentries",p);
498 fTree->CopyEntries(tree);
499 delete tree;
500 fNruns++;
501 }
502
503 AliInfo(Form("Number of runs being analyzed %i",fNruns));
504}
505//-----------------------------------------------------------------------------
506void AliTOFcalib::CreateTreeFromFile(Int_t minrun, Int_t maxrun){
507
508 // creating the tree with the trees for calibration
509 // collecting them from reference data (from file)
510 // from minrun to maxrun
511
512 Float_t p[CHENTRIESSMALL];
513 Int_t nentries;
514 fTree = new TTree("TOFCalib","Tree for TOF Calibration");
515 fTree->SetDirectory(0);
516 fTree->Branch("nentries",&nentries,"nentries/I");
517 fTree->Branch("TOFentries",p,"TOFentries[nentries]/F");
518 Char_t filename[100];
519 for (Int_t irun = minrun;irun<=maxrun;irun++){
520 sprintf(filename,"$ALICE_ROOT/TOF/RefData/TreeForCalib/fileout_%i.root",irun);
521 TFile *file = new TFile(filename,"READ");
522 TTree *tree = (TTree*)file->Get("T");
523 tree->SetBranchAddress("nentries",&nentries);
524 tree->SetBranchAddress("TOFentries",p);
525 fTree->CopyEntries(tree);
526 delete tree;
527 delete file;
528 file = 0x0;
529 fNruns++;
530 }
531
532 AliInfo(Form("Number of runs being analyzed %i",fNruns));
533}
534//-----------------------------------------------------------------------------
535Int_t AliTOFcalib::Calibrate(Int_t ichmin, Int_t ichmax, Option_t *optionSave, Option_t *optionFit){
7037bd93 536
0a749fa5 537 // calibrating summing more than one channels
538 // computing calibration parameters
539 // Returning codes:
540 // 0 -> everything was ok
541 // 1 -> no tree for calibration found
542 // 2 -> not enough statistics to perform calibration
543 // 3 -> problems with arrays
544
545 TH1::AddDirectory(0);
546
547 AliInfo(Form("*** Calibrating Histograms %s, summing more channels, from channel %i, to channel %i, storing Calib Pars in channel %i", GetName(),ichmin,ichmax,ichmin)) ;
548 AliInfo(Form("Option for Saving histos = %s",optionSave )) ;
549 AliInfo(Form("Option for Fitting Profile histos = %s",optionFit )) ;
550
551 Float_t p[CHENTRIESSMALL];
552 Int_t nentries;
553 fTree->SetBranchAddress("nentries",&nentries);
554 fTree->SetBranchAddress("TOFentries",p);
555
556 Float_t ntracksTotalmean =0;
557 for (Int_t i=ichmin; i<ichmax; i++){
558 Int_t ientry = -1;
559 for (Int_t irun=0;irun<fNruns;irun++){
560 ientry = i+irun*fNChannels;
561 fTree->GetEntry(ientry);
562 Int_t ntracksRun=nentries/3;
563 ntracksTotalmean+=ntracksRun;
564 }
565 }
566
567 if (ntracksTotalmean < MEANENTRIES) {
568 AliInfo(Form(" Too small mean number of entires per channel (mean number = %f) not calibrating and exiting.....",ntracksTotalmean));
569 return 2;
570 }
571
572 //filling ToT and Time arrays
573
574 Int_t nbinToT = 100; // ToT bin width in Profile = 48.8 ps
575 Float_t minToT = 0; // ns
576 Float_t maxToT = 4.88; // ns
577
578 TH1F *hToT = new TH1F("htot","htot",nbinToT, minToT, maxToT);
579 TH1F *hdeltaTime = new TH1F("hdeltaTime","hdeltaTime",200,2,4);
580 Int_t ntracksTotal = 0;
581 Int_t ntracksRun = 0;
582 Double_t binsProfile[101]; // sized larger than necessary, the correct
583 // dim being set in the booking of the profile
584 Int_t nusefulbins=0;
585 Float_t meantime=0;
586 for (Int_t i = ichmin;i<ichmax;i++){
587 Int_t ientry = -1;
588 for (Int_t irun=0;irun<fNruns;irun++){
589 ientry = i+irun*fNChannels;
590 fTree->GetEntry(ientry);
591 ntracksTotal+=nentries/3;
592 ntracksRun=nentries/3;
593 AliDebug(2,Form("run %i, channel %i, nentries = %i, ntracks = %i",irun,i,nentries, ntracksRun));
594 for (Int_t j=0;j<ntracksRun;j++){
595 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
596 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
597 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
598 Float_t tot = p[idxexToT];
599 hdeltaTime->Fill(p[idxexTime]-p[idxexExTime]);
600 meantime+=p[idxexTime]-p[idxexExTime];
601 hToT->Fill(tot);
602 }
603 }
604 }
605 nusefulbins = FindBins(hToT,&binsProfile[0]);
606 meantime/=ntracksTotal;
607 AliDebug(2, Form("meantime = %f",meantime));
608
609 for (Int_t j=1;j<=nusefulbins;j++) {
610 AliDebug(2,Form(" summing channels from %i to %i, nusefulbins = %i, bin %i = %f",ichmin,ichmax,nusefulbins,j,binsProfile[j]));
611 }
612
613 TProfile* hSlewingProf = new TProfile("hSlewingProf", "hSlewingProf",nusefulbins, binsProfile, "G"); // CHECK THE BUILD OPTION, PLEASE!!!!!!
614 TH2F * htimetot = new TH2F("htimetot","htimetot",nbinToT, minToT, maxToT,600,-5,10);
615
616 for (Int_t irun=0;irun<fNruns;irun++){
617 Int_t ientry = -1;
618 for (Int_t i=ichmin; i<ichmax; i++){
619 ientry = i+irun*fNChannels;
620 fTree->GetEntry(ientry);
621 ntracksRun=nentries/3;
622 for (Int_t j=0;j<ntracksRun;j++){
623 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
624 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
625 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
626 Float_t tot = p[idxexToT];
627 Float_t time = p[idxexTime]-p[idxexExTime];
628 AliDebug (2, Form("track = %i, time = %f, tot = %f, time-meantime = %f",j,time, tot, time-meantime));
629 hSlewingProf->Fill(tot,time); // if meantime is not used, the fill may be moved in the loop above
630 htimetot->Fill(tot,time-meantime); // if meantime is not used, the fill may be moved in the loop above
631 }
632 }
633 }
634
635 hSlewingProf->Fit("pol5",optionFit,"",0,4);
636 TF1 * calibfunc = (TF1*)hSlewingProf->GetFunction("pol5");
637 Float_t par[6];
638 for(Int_t kk=0;kk<6;kk++){
639 par[kk]=calibfunc->GetParameter(kk);
640 AliDebug(2,Form("parameter %i = %f",kk,par[kk]));
641 }
642
643 if(strstr(optionSave,"save")){
644 TFile * fileProf = new TFile("TOFCalibSave.root","recreate");
645 fileProf->cd();
646 TString profName=Form("Profile%06i_%06i",ichmin,ichmax);
647 TString timeTotName=Form("TimeTot%06i_%06i",ichmin,ichmax);
648 TString totName=Form("Tot%06i_%06i",ichmin,ichmax);
649 TString deltaName=Form("Delta%06i_%06i",ichmin,ichmax);
650 hSlewingProf->Write(profName);
651 htimetot->Write(timeTotName);
652 hToT->Write(totName);
653 hdeltaTime->Write(deltaName);
654 fileProf->Close();
655 delete fileProf;
656 fileProf=0x0;
657 }
658
659 delete hToT;
660 hToT=0x0;
661 delete hSlewingProf;
662 hSlewingProf=0x0;
663 delete htimetot;
664 htimetot=0x0;
665 delete hdeltaTime;
666 hdeltaTime=0x0;
667
668 AliTOFChannelOffline * calChannel = (AliTOFChannelOffline*)fTOFCalOffline->At(ichmin);
669 calChannel->SetSlewPar(par);
670 WriteParOfflineOnCDB("TOF/Calib","valid",0,0);
671 return 0;
672}
673//----------------------------------------------------------------------------
674Int_t AliTOFcalib::Calibrate(Int_t i, Option_t *optionSave, Option_t *optionFit){
675
676 // computing calibration parameters for channel i
677 // Returning codes:
678 // 0 -> everything was ok
679 // 1 -> no tree for calibration found
680 // 2 -> not enough statistics to perform calibration
681 // 3 -> problems with arrays
682
683 TH1::AddDirectory(0);
684
685 AliInfo(Form("*** Calibrating Histograms (one channel) %s", GetName())) ;
686 AliInfo(Form("Option for Saving histos = %s",optionSave )) ;
687 AliInfo(Form("Option for Fitting Profile histos = %s",optionFit )) ;
688
689 Float_t p[MAXCHENTRIESSMALL];
690 Int_t nentries;
691 fTree->SetBranchAddress("nentries",&nentries);
692 fTree->SetBranchAddress("TOFentries",p);
693
694 Float_t ntracksTotal =0;
695 for (Int_t irun=0;irun<fNruns;irun++){
696 Int_t ientry = -1;
697 ientry = i+irun*fNChannels;
698 fTree->GetEntry(ientry);
699 ntracksTotal+=nentries/3;
700 }
701
702 if (ntracksTotal < MEANENTRIES) {
703 AliInfo(Form(" Too small mean number of entires per channel (mean number = %f) not calibrating and exiting.....",ntracksTotal));
704 return 2;
705 }
706
707 //filling ToT and Time arrays
708
709 Int_t nbinToT = 100; // ToT bin width in Profile = 48.8 ps
710 Float_t minToT = 0; // ns
711 Float_t maxToT = 4.88; // ns
712
713 TH1F *hToT = new TH1F("htot","htot",nbinToT, minToT, maxToT);
714 TH1F *hdeltaTime = new TH1F("hdeltaTime","hdeltaTime",200,2,4);
715 Int_t ntracksRun = 0;
716 Double_t binsProfile[101]; // sized larger than necessary, the correct
717 // dim being set in the booking of the profile
718 Int_t nusefulbins=0;
719 Float_t meantime=0;
720 for (Int_t irun=0;irun<fNruns;irun++){
721 Int_t ientry = -1;
722 ientry = i+irun*fNChannels;
723 fTree->GetEntry(ientry);
724 ntracksRun=nentries/3;
725 AliDebug(2,Form("run %i, channel %i, nentries = %i, ntracksRun = %i",irun, i ,nentries, ntracksRun));
726 for (Int_t j=0;j<ntracksRun;j++){
727 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
728 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
729 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
730 Float_t tot = p[idxexToT];
731 meantime+=p[idxexTime]-p[idxexExTime];
732 hdeltaTime->Fill(p[idxexTime]-p[idxexExTime]);
733 hToT->Fill(tot);
734 }
735 }
736
737 nusefulbins = FindBins(hToT,&binsProfile[0]);
738 meantime/=ntracksTotal;
739 AliDebug(2,Form("meantime = %f",meantime));
740
741 for (Int_t j=1;j<=nusefulbins;j++) {
742 AliDebug(2,Form(" channel %i, nusefulbins = %i, bin %i = %f",i,nusefulbins,j,binsProfile[j]));
743 }
744
745 TProfile* hSlewingProf = new TProfile("hSlewingProf", "hSlewingProf",nusefulbins, binsProfile, "G"); // CHECK THE BUILD OPTION, PLEASE!!!!!!
746 TH2F * htimetot = new TH2F("htimetot","htimetot",nbinToT, minToT, maxToT,600,-5,10);
747 for (Int_t irun=0;irun<fNruns;irun++){
748 Int_t ientry = -1;
749 ientry = i+irun*fNChannels;
750 fTree->GetEntry(ientry);
751 ntracksRun=nentries/3;
752 for (Int_t j=0;j<ntracksRun;j++){
753 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
754 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
755 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
756 Float_t tot = p[idxexToT];
757 Float_t time = p[idxexTime]-p[idxexExTime];
758 AliDebug (2,Form("track = %i, time = %f, tot = %f, time-meantime = %f",j,time, tot, time-meantime));
759 hSlewingProf->Fill(tot,time); // if meantime is not used, the fill may be moved in the loop above
760 htimetot->Fill(tot,time-meantime); // if meantime is not used, the fill may be moved in the loop above
761 }
762 }
763
764 hSlewingProf->Fit("pol5",optionFit,"",0,4);
765 TF1 * calibfunc = (TF1*)hSlewingProf->GetFunction("pol5");
766 Float_t par[6];
767 for(Int_t kk=0;kk<6;kk++){
768 par[kk]=calibfunc->GetParameter(kk);
769 AliDebug(2,Form("parameter %i = %f",kk,par[kk]));
770 }
771
772
773 if(strstr(optionSave,"save")){
774 TFile * fileProf = new TFile("TOFCalibSave.root","recreate");
775 fileProf->cd();
776 TString profName=Form("Profile%06i",i);
777 TString timeTotName=Form("TimeTot%06i",i);
778 TString totName=Form("Tot%06i",i);
779 TString deltaName=Form("Delta%06i",i);
780 hSlewingProf->Write(profName);
781 htimetot->Write(timeTotName);
782 hToT->Write(totName);
783 hdeltaTime->Write(deltaName);
784 fileProf->Close();
785 delete fileProf;
786 fileProf=0x0;
787 }
788
789 delete hToT;
790 hToT=0x0;
791 delete hSlewingProf;
792 hSlewingProf=0x0;
793 delete htimetot;
794 htimetot=0x0;
795 delete hdeltaTime;
796 hdeltaTime=0x0;
797
798 AliTOFChannelOffline * calChannel = (AliTOFChannelOffline*)fTOFCalOffline->At(i);
799 calChannel->SetSlewPar(par);
800 WriteParOfflineOnCDB("TOF/Calib","valid",0,0);
801 return 0;
802}
803//----------------------------------------------------------------------------
804Int_t AliTOFcalib::Calibrate(Int_t nch, Int_t *ch, Option_t *optionSave, Option_t *optionFit){
805
806 // calibrating an array of channels
807 // computing calibration parameters
808 // Returning codes:
809 // 0 -> everything was ok
810 // 1 -> no tree for calibration found
811 // 2 -> not enough statistics to perform calibration
812 // 3 -> problems with arrays
813
814 TH1::AddDirectory(0);
815
816 AliInfo(Form("*** Calibrating Histograms %s, number of channels = %i", GetName(),nch)) ;
817 AliInfo(Form("Option for Saving histos = %s",optionSave )) ;
818 AliInfo(Form("Option for Fitting Profile histos = %s",optionFit )) ;
819 for (Int_t ich=0; ich<nch; ich++){
820 Int_t i = ch[ich];
821 AliInfo(Form("Calibrating channel = %i",i )) ;
822 }
823 Float_t p[MAXCHENTRIESSMALL];
824 Int_t nentries;
825 fTree->SetBranchAddress("nentries",&nentries);
826 fTree->SetBranchAddress("TOFentries",p);
827
828 Float_t ntracksTotalmean =0;
829 for (Int_t ich=0; ich<nch; ich++){
830 Int_t ientry = -1;
831 Int_t i = ch[ich];
832 for (Int_t irun=0;irun<fNruns;irun++){
833 ientry = i+irun*fNChannels;
834 fTree->GetEntry(ientry);
835 ntracksTotalmean+=nentries/3;
836 }
837 }
838
839 ntracksTotalmean/=nch;
840 if (ntracksTotalmean < MEANENTRIES) {
841 AliInfo(Form(" Too small mean number of entires per channel (mean number = %f) not calibrating and exiting.....",ntracksTotalmean));
842 return 2;
843 }
844
845 //filling ToT and Time arrays
846
847 Int_t nbinToT = 100; // ToT bin width in Profile = 48.8 ps
848 Float_t minToT = 0; // ns
849 Float_t maxToT = 4.88; // ns
850 TFile * fileProf=0x0;
851 if(strstr(optionSave,"save")){
852 fileProf = new TFile("TOFCalibSave.root","recreate");
853 }
854 for (Int_t ich=0; ich<nch; ich++) {
855 TH1F *hToT = new TH1F("htot","htot",nbinToT, minToT, maxToT);
856 TH1F *hdeltaTime = new TH1F("hdeltaTime","hdeltaTime",200,2,4);
857 Double_t binsProfile[101]; // sized larger than necessary, the correct
858 // dim being set in the booking of the profile
859 TH2F * htimetot = new TH2F("htimetot","htimetot",nbinToT, minToT, maxToT,600,-5,10);
860 Int_t ntracksTotal = 0;
861 Int_t ntracksRun = 0;
862 Int_t nusefulbins=0;
863 Float_t meantime=0;
864 Int_t i=-1;
865 for (Int_t irun=0;irun<fNruns;irun++){
866 i = ch[ich]+irun*fNChannels;
867 AliDebug(2,Form("Calibrating channel %i",i));
868 fTree->GetEntry(i);
869 ntracksTotal+=nentries/3;
870 }
871 if (ntracksTotal < MEANENTRIES) {
872 AliInfo(Form(" Too small mean number of entires in channel %i (number of tracks = %f), not calibrating channel and continuing.....",i,ntracksTotal));
873 continue;
874 }
875
876 for (Int_t irun=0;irun<fNruns;irun++){
877 Int_t i = ch[ich]+irun*fNChannels;
878 fTree->GetEntry(i);
879 ntracksRun=nentries/3;
880 for (Int_t j=0;j<ntracksRun;j++){
881 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
882 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
883 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
884 Float_t tot = p[idxexToT];
885 hdeltaTime->Fill(p[idxexTime]-p[idxexExTime]);
886 meantime+=p[idxexTime]-p[idxexExTime];
887 hToT->Fill(tot);
888 }
889 }
890
891 nusefulbins = FindBins(hToT,&binsProfile[0]);
892 meantime/=ntracksTotal;
893 for (Int_t j=1;j<=nusefulbins;j++) {
894 AliDebug(2,Form(" channel %i, nusefulbins = %i, bin %i = %f",i,nusefulbins,j,binsProfile[j]));
895 }
896
897 TProfile* hSlewingProf = new TProfile("hSlewingProf", "hSlewingProf",nusefulbins, binsProfile, "G"); // CHECK THE BUILD OPTION, PLEASE!!!!!!
898 for (Int_t irun=0;irun<fNruns;irun++){
899 Int_t i = ch[ich]+irun*fNChannels;
900 fTree->GetEntry(i);
901 ntracksRun=nentries/3;
902 for (Int_t j=0;j<ntracksRun;j++){
903 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
904 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
905 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
906 Float_t tot = p[idxexToT];
907 Float_t time = p[idxexTime]-p[idxexExTime];
908 AliDebug(2,Form("track = %i, time = %f, tot = %f, time-meantime = %f",j,time, tot, time-meantime));
909 hSlewingProf->Fill(tot,time); // if meantime is not used, the fill may be moved in the loop above
910 htimetot->Fill(tot,time-meantime); // if meantime is not used, the fill may be moved in the loop above
911 }
912 }
913
914 hSlewingProf->Fit("pol5",optionFit,"",1,4);
915 TF1 * calibfunc = (TF1*)hSlewingProf->GetFunction("pol5");
916 Float_t par[6];
917 for(Int_t kk=0;kk<6;kk++){
918 par[kk]=calibfunc->GetParameter(kk);
919 AliDebug(2,Form("parameter %i = %f",kk,par[kk]));
920 }
921
922 if(strstr(optionSave,"save") && fileProf){
923 TString profName=Form("Profile%06i",i);
924 TString timeTotName=Form("TimeTot%06i",i);
925 TString totName=Form("Tot%06i",i);
926 TString deltaName=Form("Delta%06i",i);
927 fileProf->cd();
928 hSlewingProf->Write(profName);
929 htimetot->Write(timeTotName);
930 hToT->Write(totName);
931 hdeltaTime->Write(deltaName);
932 }
933
934 AliTOFChannelOffline * calChannel = (AliTOFChannelOffline*)fTOFCalOffline->At(i);
935 calChannel->SetSlewPar(par);
936 delete hToT;
937 hToT=0x0;
938 delete hSlewingProf;
939 hSlewingProf=0x0;
940 delete htimetot;
941 htimetot=0x0;
942 delete hdeltaTime;
943 hdeltaTime=0x0;
944 }
945
946 if(strstr(optionSave,"save") && fileProf){
947 fileProf->Close();
948 delete fileProf;
949 fileProf=0x0;
950 }
951 WriteParOfflineOnCDB("TOF/Calib","valid",0,0);
952
953 return 0;
954}
955//----------------------------------------------------------------------------
956Int_t AliTOFcalib::CalibrateFromProfile(Int_t ich, Option_t *optionSave, Option_t *optionFit){
957
958 // computing calibration parameters using the old profiling algo
959 // Returning codes:
960 // 0 -> everything was ok
961 // 1 -> no tree for calibration found
962 // 2 -> not enough statistics to perform calibration
963 // 3 -> problems with arrays
964
965 TH1::AddDirectory(0);
966
967 AliInfo(Form("*** Calibrating Histograms From Profile %s", GetName())) ;
968 AliInfo(Form("Option for Saving histos = %s",optionSave )) ;
969 AliInfo(Form("Option for Fitting Profile histos = %s",optionFit )) ;
970 Float_t p[MAXCHENTRIESSMALL];
971 Int_t nentries;
972 Int_t ntracksTotal=0;
973 fTree->SetBranchAddress("nentries",&nentries);
974 fTree->SetBranchAddress("TOFentries",p);
975
976 for (Int_t irun=0;irun<fNruns;irun++){
977 Int_t i = ich+irun*fNChannels;
978 fTree->GetEntry(i);
979 ntracksTotal+=nentries/3;
980 }
981
982 if (ntracksTotal < MEANENTRIES) {
983 AliInfo(Form(" Too small mean number of entires per channel (mean number = %f) not calibrating and exiting.....",ntracksTotal));
984 return 2;
985 }
986
987 TH1F * hProf = new TH1F();
988 hProf = Profile(ich);
989 hProf->Fit("pol5",optionFit,"",0,4);
990 TF1 * calibfunc = (TF1*)hProf->GetFunction("pol5");
991 Float_t par[6];
992 for(Int_t kk=0;kk<6;kk++){
993 par[kk]=calibfunc->GetParameter(kk);
994 AliDebug(2,Form("parameter %i = %f",kk,par[kk]));
995 }
996
997 if(strstr(optionSave,"save")){
998 TFile * fileProf = new TFile("TOFCalibSave.root","recreate");
999 fileProf->cd();
1000 TString profName=Form("Profile%06i",ich);
1001 hProf->Write(profName);
1002 fileProf->Close();
1003 delete fileProf;
1004 fileProf=0x0;
1005 }
1006
1007 delete hProf;
1008 hProf=0x0;
1009 AliTOFChannelOffline * calChannel = (AliTOFChannelOffline*)fTOFCalOffline->At(ich);
1010 calChannel->SetSlewPar(par);
1011 WriteParOfflineOnCDB("TOF/Calib","valid",0,0);
1012 return 0;
1013}
1014//----------------------------------------------------------------------------
1015Int_t AliTOFcalib::Calibrate(Option_t *optionSave, Option_t *optionFit){
1016
1017 // calibrating the whole TOF
1018 // computing calibration parameters
1019 // Returning codes:
1020 // 0 -> everything was ok
1021 // 1 -> no tree for calibration found
1022 // 2 -> not enough statistics to perform calibration
1023 // 3 -> problems with arrays
1024
1025 TH1::AddDirectory(0);
1026
1027 AliInfo(Form("*** Calibrating Histograms %s, all channels", GetName())) ;
1028 AliInfo(Form("Option for Saving histos = %s",optionSave )) ;
1029 AliInfo(Form("Option for Fitting Profile histos = %s",optionFit )) ;
1030
1031 TFile * fileProf=0x0;
1032 if(strstr(optionSave,"save")){
1033 fileProf = new TFile("TOFCalibSave.root","recreate");
1034 }
1035
1036 Float_t p[MAXCHENTRIESSMALL];
1037 Int_t nentries;
1038 fTree->SetBranchAddress("nentries",&nentries);
1039 fTree->SetBranchAddress("TOFentries",p);
1040
1041 Float_t ntracksTotalmean =0;
1042 for (Int_t ii=0; ii<fNChannels; ii++){
1043 for (Int_t irun=0;irun<fNruns;irun++){
1044 Int_t i = ii+irun*fNChannels;
1045 fTree->GetEntry(i);
1046 ntracksTotalmean+=nentries/3;
1047 }
1048 }
1049
1050 ntracksTotalmean/=fNChannels;
1051 if (ntracksTotalmean < MEANENTRIES) {
1052 AliInfo(Form(" Too small mean number of entires per channel (mean number = %f) not calibrating and exiting.....",ntracksTotalmean));
1053 return 2;
1054 }
1055
1056 //filling ToT and Time arrays
1057
1058 Int_t nbinToT = 100; // ToT bin width in Profile = 50.0 ps
1059 Float_t minToT = 0; // ns
1060 Float_t maxToT = 4.88;// ns
1061 for (Int_t ii=0; ii<fNChannels; ii++) {
1062 TH1F *hToT = new TH1F("htot","htot",nbinToT, minToT, maxToT);
1063 TH1F *hdeltaTime = new TH1F("hdeltaTime","hdeltaTime",200,2,4);
1064 TH2F * htimetot = new TH2F("htimetot","htimetot",nbinToT, minToT, maxToT,600,-5,10);
1065 if (ii%1000 == 0) AliDebug(1,Form("Calibrating channel %i ",ii));
1066 //Int_t i = 3;
1067 Int_t nusefulbins=0;
1068 Double_t binsProfile[101]; // sized larger than necessary, the correct
1069 // dim being set in the booking of the profile
1070 Int_t ntracksRun = 0;
1071 Int_t ntracksTotal = 0;
1072 for (Int_t irun=0;irun<fNruns;irun++){
1073 Int_t i = ii+irun*fNChannels;
1074 fTree->GetEntry(i);
1075 ntracksTotal+=nentries/3;
1076 }
1077 if (ntracksTotal < MEANENTRIES) {
1078 AliInfo(Form(" Too small mean number of entires in channel %i (number of tracks = %f), not calibrating channel and continuing.....",ii,ntracksTotal));
1079 continue;
1080 }
1081 Float_t meantime=0;
1082 for (Int_t irun=0;irun<fNruns;irun++){
1083 Int_t i = ii+irun*fNChannels;
1084 fTree->GetEntry(i);
1085 ntracksRun=nentries/3;
1086 for (Int_t j=0;j<ntracksRun;j++){
1087 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
1088 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
1089 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
1090 Float_t tot = p[idxexToT];
1091 hdeltaTime->Fill(p[idxexTime]-p[idxexExTime]);
1092 meantime+=p[idxexTime]-p[idxexExTime];
1093 hToT->Fill(tot);
1094 }
1095 }
1096 nusefulbins = FindBins(hToT,&binsProfile[0]);
1097 meantime/=ntracksTotal;
1098 for (Int_t j=0;j<nusefulbins;j++) {
1099 AliDebug(2,Form(" channel %i, usefulbin = %i, low edge = %f",ii,j,binsProfile[j]));
1100 }
1101 TProfile* hSlewingProf = new TProfile("hSlewingProf", "hSlewingProf",nusefulbins, binsProfile, "G"); // CHECK THE BUILD OPTION, PLEASE!!!!!!
1102 for (Int_t irun=0;irun<fNruns;irun++){
1103 Int_t i = ii+irun*fNChannels;
1104 fTree->GetEntry(i);
1105 ntracksRun=nentries/3;
1106 for (Int_t j=0;j<ntracksRun;j++){
1107 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
1108 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
1109 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
1110 Float_t tot = p[idxexToT];
1111 Float_t time = p[idxexTime]-p[idxexExTime];
1112 AliDebug (2,Form("track = %i, time = %f, tot = %f, time-meantime = %f",j,time, tot, time-meantime));
1113 hSlewingProf->Fill(tot,time); // if meantime is not used, the fill may be moved in the loop above
1114 htimetot->Fill(tot,time-meantime); // if meantime is not used, the fill may be moved in the loop above
1115 }
1116 }
1117 hSlewingProf->Fit("pol5",optionFit,"",1,4);
1118 TF1 * calibfunc = (TF1*)hSlewingProf->GetFunction("pol5");
1119 Float_t par[6];
1120 for(Int_t kk=0;kk<6;kk++){
1121 par[kk]=calibfunc->GetParameter(kk);
1122 AliDebug(2,Form("parameter %i = %f",kk,par[kk]));
1123 }
1124
1125 if(strstr(optionSave,"save") && fileProf){
1126 TString profName=Form("Profile%06i",ii);
1127 TString timeTotName=Form("TimeTot%06i",ii);
1128 TString totName=Form("Tot%06i",ii);
1129 TString deltaName=Form("Delta%06i",ii);
1130 fileProf->cd();
1131 hSlewingProf->Write(profName);
1132 htimetot->Write(timeTotName);
1133 hToT->Write(totName);
1134 hdeltaTime->Write(deltaName);
1135 }
1136 AliTOFChannelOffline * calChannel = (AliTOFChannelOffline*)fTOFCalOffline->At(ii);
1137 calChannel->SetSlewPar(par);
1138
1139 delete hToT;
1140 hToT=0x0;
1141 delete hSlewingProf;
1142 hSlewingProf=0x0;
1143 delete htimetot;
1144 htimetot=0x0;
1145 delete hdeltaTime;
1146 hdeltaTime=0x0;
1147 }
1148
1149 if(strstr(optionSave,"save")){
1150 fileProf->Close();
1151 delete fileProf;
1152 fileProf=0x0;
1153 }
1154 WriteParOfflineOnCDB("TOF/Calib","valid",0,0);
1155 return 0;
1156}
1157
1158//-----------------------------------------------------------------------
1159TH1F* AliTOFcalib::Profile(Int_t ich)
340693af 1160{
0a749fa5 1161 // profiling algo
1162
1163 Float_t p[MAXCHENTRIESSMALL];
1164 Int_t nentries;
1165 fTree->SetBranchAddress("nentries",&nentries);
1166 fTree->SetBranchAddress("TOFentries",p);
1167
1168 //Prepare histograms for Slewing Correction
1169 const Int_t knbinToT = 100;
1170 Int_t nbinTime = 200;
1171 Float_t minTime = -5.5; //ns
1172 Float_t maxTime = 5.5; //ns
1173 Float_t minToT = 0; //ns
1174 Float_t maxToT = 5.; //ns
1175 Float_t deltaToT = (maxToT-minToT)/knbinToT;
1176 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];
1177 Int_t n[knbinToT+1], nentrx[knbinToT+1];
1178 Double_t sigmaToT[knbinToT+1];
1179 for (Int_t i = 0; i < knbinToT+1 ; i++){
1180 mTime[i]=0;
1181 mToT[i]=0;
1182 n[i]=0;
1183 meanTime[i]=0;
1184 meanTime2[i]=0;
1185 vToT[i]=0;
1186 vToT2[i]=0;
1187 meanToT[i]=0;
1188 meanToT2[i]=0;
1189 vTime[i]=0;
1190 vTime2[i]=0;
1191 xlow[i]=0;
1192 sigmaTime[i]=0;
1193 sigmaToT[i]=0;
1194 n[i]=0;
1195 nentrx[i]=0;
1196 }
1197 TH2F* hSlewing = new TH2F("hSlewing", "hSlewing", knbinToT, minToT, maxToT, nbinTime, minTime, maxTime);
1198 Int_t ntracksRun = 0;
1199 TH1F *histo = new TH1F("histo", "1D Time vs ToT", knbinToT, minToT, maxToT);
1200 for (Int_t irun=0;irun<fNruns;irun++){
1201 Int_t i = ich+irun*fNChannels;
1202 fTree->GetEntry(i);
1203 ntracksRun=nentries/3;
1204 for (Int_t j=0;j<ntracksRun;j++){
1205 Int_t idxexToT = (j* NIDXSMALL)+DELTAIDXTOT;
1206 Int_t idxexTime = (j* NIDXSMALL)+DELTAIDXTIME;
1207 Int_t idxexExTime = (j* NIDXSMALL)+DELTAIDXPID;
1208 Float_t tot = p[idxexToT];
1209 Float_t time = p[idxexTime]-p[idxexExTime];
1210 Int_t nx = (Int_t)((tot-minToT)/deltaToT)+1;
1211 if ((tot != 0) && ( time!= 0)){
1212 vTime[nx]+=time;
1213 vTime2[nx]+=time*time;
1214 vToT[nx]+=tot;
1215 vToT2[nx]+=tot*tot;
1216 nentrx[nx]++;
1217 hSlewing->Fill(tot,time);
1218 }
1219 }
1220 }
1221 Int_t nbinsToT=hSlewing->GetNbinsX();
1222 if (nbinsToT != knbinToT) {
1223 AliError("Profile :: incompatible numbers of bins");
1224 return 0x0;
1225 }
1226
1227 Int_t usefulBins=0;
1228 for (Int_t i=1;i<=nbinsToT;i++){
1229 if (nentrx[i]!=0){
1230 n[usefulBins]+=nentrx[i];
1231 if (n[usefulBins]==0 && i == nbinsToT) {
1232 break;
1233 }
1234 meanTime[usefulBins]+=vTime[i];
1235 meanTime2[usefulBins]+=vTime2[i];
1236 meanToT[usefulBins]+=vToT[i];
1237 meanToT2[usefulBins]+=vToT2[i];
1238 if (n[usefulBins]<10 && i!=nbinsToT) continue;
1239 mTime[usefulBins]=meanTime[usefulBins]/n[usefulBins];
1240 mToT[usefulBins]=meanToT[usefulBins]/n[usefulBins];
1241 sigmaTime[usefulBins]=TMath::Sqrt(1./n[usefulBins]/n[usefulBins]
1242 *(meanTime2[usefulBins]-meanTime[usefulBins]
1243 *meanTime[usefulBins]/n[usefulBins]));
1244 if ((1./n[usefulBins]/n[usefulBins]
1245 *(meanToT2[usefulBins]-meanToT[usefulBins]
1246 *meanToT[usefulBins]/n[usefulBins]))< 0) {
1247 AliError(" too small radical" );
1248 sigmaToT[usefulBins]=0;
1249 }
1250 else{
1251 sigmaToT[usefulBins]=TMath::Sqrt(1./n[usefulBins]/n[usefulBins]
1252 *(meanToT2[usefulBins]-meanToT[usefulBins]
1253 *meanToT[usefulBins]/n[usefulBins]));
1254 }
1255 usefulBins++;
1256 }
1257 }
1258 for (Int_t i=0;i<usefulBins;i++){
1259 Int_t binN = (Int_t)((mToT[i]-minToT)/deltaToT)+1;
1260 histo->Fill(mToT[i],mTime[i]);
1261 histo->SetBinError(binN,sigmaTime[i]);
1262 }
1263 delete hSlewing;
1264 hSlewing=0x0;
1265
1266 return histo;
6dc9348d 1267}
0a749fa5 1268//----------------------------------------------------------------------------
1269Int_t AliTOFcalib::FindBins(TH1F* h, Double_t *binsProfile) const{
6dc9348d 1270
0a749fa5 1271 // to determine the bins for ToT histo
1272
1273 Int_t cont = 0;
1274 Int_t startBin = 1;
1275 Int_t nbin = h->GetNbinsX();
1276 Int_t nentries = (Int_t)h->GetEntries();
1277 Float_t max = h->GetBinLowEdge(nbin);
1278 Int_t nusefulbins=0;
1279 Int_t maxcont=0;
1280 // setting maxvalue of entries per bin
1281 if (nentries <= 60) maxcont = 2;
1282 else if (nentries <= 100) maxcont = 5;
1283 else if (nentries <= 500) maxcont = 10;
1284 else maxcont = 20;
1285 for (Int_t j=1;j<=nbin;j++) {
1286 cont += (Int_t)h->GetBinContent(j);
1287 if (j<nbin){
1288 if (cont>=maxcont){
1289 nusefulbins++;
1290 binsProfile[nusefulbins-1]=h->GetBinLowEdge(startBin);
1291 cont=0;
1292 startBin=j+1;
1293 continue;
1294 }
1295 }
1296 else{
1297 if (cont>=maxcont){
1298 nusefulbins++;
1299 binsProfile[nusefulbins-1]=h->GetBinLowEdge(startBin);
1300 binsProfile[nusefulbins]=max;
1301 }
1302 else {
1303 binsProfile[nusefulbins]=h->GetBinLowEdge(startBin);
1304 }
1305 }
1306 }
1307 return nusefulbins;
1308}