TOF/AliTOFcalib.cxx

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