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