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