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