PHOS/AliPHOSCalibrator.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 /* $Id$ */
  17
  18 /* History of cvs commits:
  19  *
  20  * $Log$
  21  */
  22
  23 //_________________________________________________________________________
  24 // Class to calculate calibration parameters  from beam tests etc.
  25 //  First pass - one should calcuate pedestals, in the second pass - gains.
  26 //
  27 //     To calculate pedestals we scan pedestals events and fill histos for each
  28 //     channel. Then in each histo we find maximum and fit it with Gaussian in the
  29 //     visinity of the maximum. Extracted mean and width of distribution are put into
  30 //     resulting histogram which cheks results for 'reasonability'.
  31 //
  32 //     To evaluate gains: scans beam events and calculate gain in the cristall with
  33 //     maximal energy deposition, assuming, that 90% of energy deposited in it.
  34 //     For each channel separate histogramm is filled. When scan is finished,
  35 //     these histograms are fitted with Gaussian and finds mean and width, which
  36 //     are put in final histogram. Finaly gains are checked for deviation from mean.
  37
  38 //     Finally fills database.
  39 //
  40 // Use Case:
  41 //       AliPHOSCalibrator * c = new AliPHOSCalibrator("path/galice.root") ;
  42 //       c->AddRun("path2/galice.root") ;
  43 //       c->ScanPedestals();
  44 //       c->CalculatePedestals();
  45 //       c->WritePedestals();
  46 //       c->ScanGains() ;
  47 //       c->CalculateGains() ;
  48 //       c->WriteGains() ;
  49 //
  50 //*-- Author : D.Peressounko  (RRC KI)
  51 //////////////////////////////////////////////////////////////////////////////
  52
  53 // --- ROOT system ---
  54 #include "TF1.h"
  55 #include "TFile.h"
  56 #include "TObjString.h"
  57 #include "TROOT.h"
  58 #include "TClonesArray.h"
  59
  60 // --- Standard library ---
  61
  62 // --- AliRoot header files ---
  63 #include "AliLog.h"
  64 #include "AliPHOSCalibrManager.h"
  65 #include "AliPHOSCalibrationData.h"
  66 #include "AliPHOSCalibrator.h"
  67 #include "AliPHOSConTableDB.h"
  68 #include "AliRawReaderDate.h"
  69 #include "AliPHOSRawStream.h"
  70 #include "AliPHOSDigit.h"
  71
  72 #ifdef ALI_DATE
  73 #include "event.h"
  74 #else
  75 #define PHYSICS_EVENT 7
  76 #endif
  77
  78 ClassImp(AliPHOSCalibrator)
  79
  80
  81 //____________________________________________________________________________
  82   AliPHOSCalibrator::AliPHOSCalibrator():TTask("AliPHOSCalibrator","Default")
  83 {
  84   //Default constuctor for root. Normally should not be used
  85   fRunList=0 ;
  86   fBeamEnergy = 0. ;
  87   fNch = 0 ;
  88   fPedHistos = 0 ;
  89   fGainHistos = 0 ;
  90   fhPedestals = 0 ;
  91   fhPedestalsWid = 0 ;
  92   fctdb = 0 ;
  93   fConTableDB = "Beamtest2002" ;
  94   fConTableDBFile = "ConTableDB.root" ;
  95 }
  96 //____________________________________________________________________________
  97 AliPHOSCalibrator::AliPHOSCalibrator(const char* file, const char* title):
  98   TTask("AliPHOSCalibrator",title)
  99 {
 100   //Constructor which should normally be used.
 101   //file: path/galice.root  - header file
 102   //title: branch name of PHOS reconstruction (e.g. "Default")
 103
 104
 105   fRunList = new TList() ;
 106   fRunList->SetOwner() ;
 107   fRunList->Add(new TObjString(file)) ;
 108   fNch = 0 ;
 109   fBeamEnergy = 10. ;
 110
 111   fNChan  = 100 ;
 112   fGainMax = 0.1 ;
 113   fNGainBins= 100 ;
 114   fAcceptCorr = 10 ;     //Maximal deviation from mean, considered as normal
 115
 116   fGainAcceptCorr = 5 ;  //Factor for gain deviation
 117   fPedHistos = 0 ;
 118   fGainHistos = 0 ;
 119   fhPedestals = 0 ;
 120   fhPedestalsWid = 0 ;
 121   fctdb = 0 ;
 122   fConTableDB = "Beamtest2002" ;
 123   fConTableDBFile = "ConTableDB.root" ;
 124 }
 125
 126 //____________________________________________________________________________
 127   AliPHOSCalibrator::~AliPHOSCalibrator()
 128 {
 129   // dtor
 130   if(fPedHistos)
 131     delete fPedHistos ;
 132   if(fGainHistos)
 133     delete fGainHistos ;
 134   if(fhPedestals)
 135     delete fhPedestals ;
 136   if(fhPedestalsWid)
 137     delete fhPedestalsWid ;
 138   if(fctdb)
 139     delete fctdb ;
 140   if(fRunList)
 141     delete fRunList ;
 142 }
 143 //____________________________________________________________________________
 144 void AliPHOSCalibrator::AddRun(const char * filename)
 145 {
 146   //Adds one more run to list of runs, which will be scanned in ScanXXX methods
 147
 148   TObjString * fn = new TObjString(filename) ;
 149   if(!fRunList){
 150     fRunList=new TList() ;
 151     fRunList->SetOwner() ;
 152     fRunList->Add(fn) ;
 153     return ;
 154   }
 155   else{
 156     TIter next(fRunList) ;
 157     TObjString * r ;
 158     while((r=(TObjString *)(next()))){
 159       if(fn->String().CompareTo(r->String())==0){
 160         AliError(Form("Run already in list: %s",filename)) ;
 161         return ;
 162       }
 163     }
 164     fRunList->Add(fn) ;
 165   }
 166
 167 }
 168 //____________________________________________________________________________
 169 void AliPHOSCalibrator::Exec(Option_t * option)
 170 {
 171   // reads parameters and does the calibration
 172   ScanPedestals(option);
 173   CalculatePedestals();
 174   WritePedestals();
 175   ScanGains(option) ;
 176   CalculateGains() ;
 177   WriteGains() ;
 178 }
 179 //____________________________________________________________________________
 180 void AliPHOSCalibrator::Init(void)
 181 {
 182   // intializes everything
 183
 184   //check if ConTableDB already read
 185   if(!fctdb){
 186     SetConTableDB(fConTableDBFile) ;
 187   }
 188
 189   fNch = fctdb->GetNchanels() ;
 190   fhPedestals   = new TH1F("hPedestals","Pedestals mean",fNch,0.,fNch) ;
 191   fhPedestalsWid= new TH1F("hPedestalsWid","Pedestals width",fNch,0.,fNch) ;
 192   fhGains       = new TH1F("hGains","Gains ",fNch,0.,fNch) ;
 193   fhGainsWid    = new TH1F("hGainsWid","Gains width",fNch,0.,fNch) ;
 194 }
 195 //____________________________________________________________________________
 196 void AliPHOSCalibrator::SetConTableDB(const char * file,const char * name)
 197 {
 198   //Reads Connection Table database with name "name" from file "file"
 199
 200   if(file==0 || name == 0){
 201     AliError(Form("Please, specify file with database and its title")) ;
 202     return ;
 203   }
 204   if(fctdb && strcmp(fctdb->GetTitle(),name)==0) //already read
 205     return ;
 206
 207   //else read new one
 208   if(fctdb){
 209     delete fctdb ;
 210     fctdb = 0;
 211   }
 212
 213   TFile * v = gROOT->GetFile(fConTableDBFile) ;
 214   if(!v)
 215     v = TFile::Open(fConTableDBFile) ;
 216   if(!v){
 217     AliError(Form("Can not open file with Connection Table DB: %s",fConTableDBFile.Data())) ;
 218     return ;
 219   }
 220   fctdb = new AliPHOSConTableDB(*(dynamic_cast<AliPHOSConTableDB *>(v->Get("AliPHOSConTableDB")))) ;
 221   v->Close() ;
 222
 223 }
 224 //____________________________________________________________________________
 225 void AliPHOSCalibrator::PlotPedestal(Int_t chanel)
 226 {
 227   //Plot histogram for a given channel, filled in Scan method
 228   if(fPedHistos && fPedHistos->GetEntriesFast()){
 229     static_cast<TH1F*>(fPedHistos->At(chanel))->Draw() ;
 230   }
 231   else{
 232     AliInfo(Form("Histograms not created yet! \n")) ;
 233   }
 234 }
 235 //____________________________________________________________________________
 236 void AliPHOSCalibrator::PlotPedestals(void)
 237 {
 238   // draws pedestals distribution
 239   fhPedestals->Draw() ;
 240 }
 241 //____________________________________________________________________________
 242 void AliPHOSCalibrator::PlotGain(Int_t chanel)
 243 {
 244   //Plot histogram for a given channel, filled in Scan method
 245   if(fGainHistos && fGainHistos->GetEntriesFast()){
 246     static_cast<TH1F*>(fGainHistos->At(chanel))->Draw() ;
 247   }
 248   else{
 249     AliInfo(Form("Histograms not created yet! \n")) ;
 250   }
 251 }
 252 //____________________________________________________________________________
 253 void AliPHOSCalibrator::PlotGains(void)
 254 {
 255   // draws gains distribution
 256   fhGains->Draw() ;
 257 }
 258 //____________________________________________________________________________
 259 void AliPHOSCalibrator::ScanPedestals(Option_t * option )
 260 {
 261   //scan all files in list fRunList and fill pedestal hisgrams
 262   //option: "clear" - clear pedestal histograms filled up to now
 263   //        "deb" - plot file name currently processed
 264
 265   if(!fctdb)
 266     Init() ;
 267
 268   if(fPedHistos && strstr(option,"clear"))
 269     fPedHistos->Delete() ;
 270   if(!fPedHistos)
 271     fPedHistos = new TObjArray(fNch) ;
 272
 273   //Create histos for each channel, fills them and extracts mean values.
 274   //First - prepare histos
 275   Int_t ich ;
 276   for(ich=0;ich<fNch ;ich++){
 277     TH1F * h = static_cast<TH1F *>(fPedHistos->At(ich)) ;
 278     if(!h ){
 279       TString n("hPed");
 280       n+=ich ;
 281       TString name("Pedestal for channel ") ;
 282       name += ich ;
 283       fPedHistos->AddAt(new TH1F(n,name,fNChan,0,fNChan),ich) ;
 284     }
 285   }
 286
 287   TIter next(fRunList) ;
 288   TObjString * file ;
 289   while((file = static_cast<TObjString *>(next()))){
 290     if(strstr(option,"deb"))
 291       printf("Processing file %s \n ",file->String().Data()) ;
 292
 293     //Now open data file
 294     AliRawReaderDate *rawReader = new AliRawReaderDate(file->String().Data()) ;
 295     AliPHOSRawStream     *rawStream = new AliPHOSRawStream(rawReader) ;
 296     rawStream->SetConTableDB(fctdb) ;
 297     TClonesArray * digits = new TClonesArray("AliPHOSDigit",300) ;
 298     Int_t nevents=0 ;
 299     //Scan all event in file
 300     while(rawReader->NextEvent()){
 301       //Is it PHYSICAL event
 302       if(rawReader->GetType() == PHYSICS_EVENT){
 303         nevents++ ;
 304         if(rawStream->ReadDigits(digits)){
 305           if(rawStream->IsPEDevent()){
 306             for(Int_t idigit = 0; idigit<digits->GetEntriesFast() ;  idigit++){
 307               AliPHOSDigit * digit = static_cast<AliPHOSDigit *>(digits->At(idigit) ) ;
 308               ich = fctdb->AbsId2Raw(digit->GetId());
 309               if(ich>=0){
 310                 Float_t amp = digit->GetAmp() ;
 311                 TH1F * hh = dynamic_cast<TH1F*>(fPedHistos->At(ich)) ;
 312                 hh->Fill(amp) ;
 313               }
 314             }
 315           }
 316         }
 317       }
 318     }
 319     if(strstr(option,"deb"))
 320       AliInfo(Form("   found %d events \n ",nevents)) ;
 321     delete rawStream ;
 322     delete rawReader ;
 323     delete digits ;
 324   }
 325 }
 326 //____________________________________________________________________________
 327 void AliPHOSCalibrator::CalculatePedestals()
 328 {
 329   //Fit histograms, filled in ScanPedestals method with Gaussian
 330   //find mean and width, check deviation from mean for each channel.
 331
 332   if(!fPedHistos || !fPedHistos->At(0)){
 333     AliError(Form("You should run ScanPedestals first!")) ;
 334     return ;
 335   }
 336
 337   //Now fit results with Gauss
 338   TF1 * gs = new TF1("gs","gaus",0.,10000.) ;
 339   Int_t ich ;
 340   for(ich=0;ich<fNch ;ich++){
 341     TH1F * h = static_cast<TH1F *>(fPedHistos->At(ich)) ;
 342     Int_t max = h->GetMaximumBin() ;
 343     Axis_t xmin = max/2. ;
 344     Axis_t xmax = max*3/2 ;
 345     gs->SetRange(xmin,xmax) ;
 346     Double_t par[3] ;
 347     par[0] = h->GetBinContent(max) ;
 348     par[1] = max ;
 349     par[2] = max/3 ;
 350     gs->SetParameters(par[0],par[1],par[2]) ;
 351     h->Fit("gs","QR") ;
 352     gs->GetParameters(par) ;
 353     fhPedestals->SetBinContent(ich,par[1]) ;
 354     fhPedestals->SetBinError(ich,par[2]) ;
 355     fhPedestalsWid->Fill(ich,par[2]) ;
 356   }
 357   delete gs ;
 358
 359   //now check reasonability of results
 360   TF1 * p0 = new TF1("p0","pol0",0.,fNch) ;
 361   fhPedestals->Fit("p0","Q") ;
 362   Double_t meanPed ;
 363   p0->GetParameters(&meanPed);
 364   for(ich=0;ich<fNch ;ich++){
 365     Float_t ped =  fhPedestals->GetBinContent(ich) ;
 366     if(ped < 0  || ped > meanPed+fAcceptCorr){
 367       TString out("Pedestal of channel ") ;
 368       out+=ich ;
 369       out+=" is ";
 370       out+= ped ;
 371       out+= "it is too far from mean " ;
 372       out+= meanPed ;
 373       AliError(Form("PHOSCalibrator %s",out.Data())) ;
 374     }
 375   }
 376   delete p0 ;
 377
 378 }
 379 //____________________________________________________________________________
 380 void AliPHOSCalibrator::ScanGains(Option_t * option)
 381 {
 382   //Scan all runs, listed in fRunList and fill histograms for all channels
 383   //options: "clear" - clean histograms, filled up to now
 384   //         "deb" - print current file name
 385   //         "narrow" - scan only narrow beam events
 386
 387   if(!fctdb)
 388     Init() ;
 389   if(fGainHistos && strstr(option,"clear"))
 390     fGainHistos->Delete() ;
 391   if(!fGainHistos){
 392     if(strstr(option,"deball"))
 393       AliInfo(Form("creating array for %d channels \n",fNch)) ;
 394     fGainHistos   = new TObjArray(fNch) ;
 395   }
 396
 397   //Create histos for each channel, fills them and extracts mean values.
 398   //First - prepare  histos
 399
 400   if(!fGainHistos->GetEntriesFast()){
 401     Int_t ich ;
 402     for(ich=0;ich<fNch ;ich++){
 403       TString n("hGain");
 404       n+=ich ;
 405       TString name("Gains for channel ") ;
 406       name += ich ;
 407       fGainHistos->AddAt(new TH1F(n,name,fNGainBins,0,fGainMax),ich) ;
 408       //      static_cast<TH1F*>(fGainHistos->At(ich))->Sumw2() ;
 409     }
 410   }
 411
 412   TIter next(fRunList) ;
 413   TObjString * file ;
 414   while((file = static_cast<TObjString *>(next()))){
 415     //Now open data file
 416     AliRawReaderDate *rawReader = new AliRawReaderDate(file->String().Data()) ;
 417     AliPHOSRawStream     *rawStream = new AliPHOSRawStream(rawReader) ;
 418     rawStream->SetConTableDB(fctdb) ;
 419
 420     TClonesArray * digits = new TClonesArray("AliPHOSDigit",300) ;
 421     Int_t nevents=0 ;
 422     //Scan all event in file
 423     while(rawReader->NextEvent()){
 424       //Is it PHYSICAL event
 425       if(rawReader->GetType() == PHYSICS_EVENT){
 426         if(rawStream->ReadDigits(digits)){
 427           //Test trigger
 428           if(rawStream->IsNELevent() || rawStream->IsWELevent()){
 429             nevents ++ ;
 430             AliPHOSDigit * digit ;
 431             Int_t max = 0 ;
 432             Int_t imax = 0;
 433             for(Int_t idigit = 0; idigit<digits->GetEntriesFast() ;  idigit++){
 434               digit = static_cast<AliPHOSDigit *>(digits->At(idigit) ) ;
 435               if(digit->GetAmp() > max){
 436                 imax = idigit ;
 437                 max = digit->GetAmp() ;
 438               }
 439             }
 440             digit = static_cast<AliPHOSDigit *>(digits->At(imax) ) ;
 441             Int_t ich = fctdb->AbsId2Raw(digit->GetId());
 442             if(ich>=0){
 443               Float_t pedestal = fhPedestals->GetBinContent(ich) ;
 444               const Float_t kshowerInCrystall = 0.9 ;
 445               Float_t gain = fBeamEnergy*kshowerInCrystall/
 446                 (digit->GetAmp() - pedestal) ;
 447               static_cast<TH1F*>(fGainHistos->At(ich))->Fill(gain) ;
 448             }
 449           }
 450         }
 451       }
 452     }
 453     delete rawReader ;
 454     delete rawStream ;
 455     delete digits ;
 456     if(strstr(option,"deb"))
 457       AliInfo(Form("   found %d events \n",nevents)) ;
 458   }
 459 }
 460 //____________________________________________________________________________
 461 void AliPHOSCalibrator::CalculateGains(void)
 462 {
 463   //calculates gain
 464
 465   if(!fGainHistos || !fGainHistos->GetEntriesFast()){
 466     AliError(Form("You should run ScanGains first!")) ;
 467     return ;
 468   }
 469
 470   //Fit results with Landau
 471   TF1 * gs = new TF1("gs","landau",0.,10000.) ;
 472   Int_t ich ;
 473   for(ich=0;ich<fNch ;ich++){
 474     TH1F * h = static_cast<TH1F *>(fGainHistos->At(ich)) ;
 475     Int_t bmax = h->GetMaximumBin() ;
 476     Axis_t center = h->GetBinCenter(bmax) ;
 477     Axis_t xmin = center - 0.01 ;
 478     Axis_t xmax = center + 0.02 ;
 479     gs->SetRange(xmin,xmax) ;
 480     Double_t par[3] ;
 481     par[0] = h->GetBinContent(bmax) ;
 482     par[1] = center ;
 483     par[2] = 0.001 ;
 484     gs->SetParameters(par[0],par[1],par[2]) ;
 485     h->Fit("gs","QR") ;
 486     gs->GetParameters(par) ;
 487     fhGains->SetBinContent(ich,par[1]) ;
 488     fhGains->SetBinError(ich,par[2]) ;
 489     fhGainsWid->Fill(ich,par[2]) ;
 490   }
 491   delete gs ;
 492
 493   //now check reasonability of results
 494   TF1 * p0 = new TF1("p0","pol0",0.,fNch) ;
 495   fhGains->Fit("p0","Q") ;
 496   Double_t meanGain ;
 497   p0->GetParameters(&meanGain);
 498   for(ich=0;ich<fNch ;ich++){
 499     Float_t gain =  fhGains->GetBinContent(ich) ;
 500     if(gain < meanGain/fGainAcceptCorr  || gain > meanGain*fGainAcceptCorr){
 501       TString out("Gain of channel ") ;
 502       out+=ich ;
 503       out+=" is ";
 504       out+= gain ;
 505       out+= "it is too far from mean " ;
 506       out+= meanGain ;
 507       AliError(Form("PHOSCalibrator %s",out.Data())) ;
 508     }
 509   }
 510   delete p0 ;
 511
 512 }
 513 //____________________________________________________________________________
 514 void AliPHOSCalibrator::ReadFromASCII(const char * filename){
 515 // We read pedestals and gains from *.dat file with following format:
 516 //      0       0       0       0       37.09   1972.   // next nmodrows*nmodcols*ncryrows*ncrycols lines
 517 //      0       0       0       1       28.53   2072.   // contains <RR CC r c ped peak>
 518 //      0       0       0       2       30.93   1938.   //
 519 // where module is an array of 8*8 crystals and RR and CC are module raw and column position
 520   FILE * file = fopen(filename, "r");
 521   if (!file) {
 522     Error("ReadFromASCII", "could not open file %s", filename);
 523     return;
 524   }
 525   if(!fctdb || !fhPedestals || !fhGains){
 526     Init() ;
 527   }
 528   else{
 529     //Clean Hitograms
 530     Reset() ;
 531   }
 532
 533   Int_t modRaw,modCol,raw,col;
 534   Float_t ped,pik;
 535   Int_t nread = 0 ;
 536   while(fscanf(file,"%d %d %d %d %f %f",&modRaw,&modCol,&raw,&col,&ped,&pik)==6){
 537     //Calculate plain crystal position:
 538     Int_t rawPosition = (modRaw*8+raw)*fctdb->GetNColumns()+modCol*8+col ;
 539     fhPedestals->SetBinContent(rawPosition,ped) ;
 540     if(pik!=0.)
 541       fhGains->SetBinContent(rawPosition,1./pik);
 542     else
 543       fhGains->SetBinContent(rawPosition,0.);
 544     nread++ ;
 545   }
 546   if(nread != fctdb->GetNColumns()*fctdb->GetNRaws()){
 547     Error("ReadFromASCII","Read %d parameters instead of %d\n",nread,fctdb->GetNColumns()*fctdb->GetNRaws()) ;
 548   }
 549   fclose(file) ;
 550 }
 551 //_____________________________________________________________________________
 552 void AliPHOSCalibrator::WritePedestals(const char * version)
 553 {
 554   //Write calculated data to file using AliPHOSCalibrManager
 555   //version and validitirange (begin-end) will be used to identify data
 556
 557   if(!fctdb){
 558     AliError(Form("\n           Please, supply Connection Table DB (use SetConTableDB()) \n" )) ;
 559     return ;
 560   }
 561   //fill data
 562   AliPHOSCalibrationData ped("Pedestals",version);
 563   for(Int_t i=0; i<fNch;i++){
 564     Int_t absid=fctdb->Raw2AbsId(i) ;
 565     ped.SetData(absid,fhPedestals->GetBinContent(i)) ;
 566     ped.SetDataCheck(absid,fhPedestalsWid->GetBinContent(i)) ;
 567   }
 568
 569 //   //evaluate validity range
 570 //   if(begin==0){
 571 //     TIter next(fRunList) ;
 572 //     Int_t ibegin=99999;
 573 //     Int_t iend=0 ;
 574 //     TObjString * file ;
 575 //     while((file=((TObjString*)next()))){
 576 //        TString s = file->GetString() ;
 577 //        TString ss = s(s.Last('_'),s.Last('.'));
 578 //        Int_t tmp ;
 579 //        if(sscanf(ss.Data(),"%d",&tmp)){
 580 //       if(ibegin<tmp)
 581 //         ibegin=tmp ;
 582 //          if(iend>tmp)
 583 //         iend=tmp ;
 584 //        }
 585 //     }
 586 //     ped.SetValidityRange(ibegin,iend) ;
 587 //   }
 588 //   else
 589 //     ped.SetValidityRange(begin,end) ;
 590
 591   //check, may be Manager instance already configured?
 592   AliPHOSCalibrManager * cmngr = AliPHOSCalibrManager::GetInstance() ;
 593   if(!cmngr){
 594     AliWarning(Form("Using database file 'PHOSBTCalibration.root'")) ;
 595     cmngr = AliPHOSCalibrManager::GetInstance("PHOSBTCalibration.root") ;
 596   }
 597   cmngr->WriteData(ped) ;
 598 }
 599 //_____________________________________________________________________________
 600 void AliPHOSCalibrator::ReadPedestals(const char * version)
 601 {
 602   //Read data from file using AliPHOSCalibrManager
 603   //version and range will be used to choose proper data
 604
 605   AliPHOSCalibrationData ped("Pedestals",version);
 606   AliPHOSCalibrManager * cmngr = AliPHOSCalibrManager::GetInstance() ;
 607   if(!cmngr){
 608    AliWarning(Form("Using database file 'PHOSBTCalibration.root'")) ;
 609    cmngr = AliPHOSCalibrManager::GetInstance("PHOSBTCalibration.root") ;
 610   }
 611   cmngr->GetParameters(ped) ;
 612   Int_t npeds=ped.NChannels() ;
 613   fNch = fctdb->GetNchanels() ;
 614   if(fhPedestals)
 615     delete fhPedestals ;
 616   fhPedestals   = new TH1F("hPedestals","Pedestals mean",fNch,0.,fNch) ;
 617   for(Int_t i=0;i<npeds;i++){
 618     Int_t raw =fctdb->AbsId2Raw(i) ;
 619     if(raw){
 620       fhPedestals->SetBinContent(raw-1,ped.Data(i)) ;
 621       fhPedestals->SetBinError(raw-1,ped.DataCheck(i)) ;
 622     }
 623   }
 624 }
 625 //_____________________________________________________________________________
 626 void AliPHOSCalibrator::ReadGains(const char * version)
 627 {
 628   //Read data from file using AliPHOSCalibrManager
 629   //version and range will be used to choose proper data
 630
 631   AliPHOSCalibrationData gains("Gains",version);
 632   AliPHOSCalibrManager * cmngr = AliPHOSCalibrManager::GetInstance() ;
 633   if(!cmngr){
 634     AliWarning(Form("Using database file 'PHOSBTCalibration.root'")) ;
 635     cmngr = AliPHOSCalibrManager::GetInstance("PHOSBTCalibration.root") ;
 636   }
 637   cmngr->GetParameters(gains) ;
 638   Int_t npeds=gains.NChannels() ;
 639   fNch = fctdb->GetNchanels() ;
 640   if(fhGains)
 641     delete fhGains ;
 642   fhGains   = new TH1F("hGainss","Gains mean",fNch,0.,fNch) ;
 643   for(Int_t i=0;i<npeds;i++){
 644     Int_t raw =fctdb->AbsId2Raw(i) ;
 645     if(raw){
 646       fhGains->SetBinContent(raw-1,gains.Data(i)) ;
 647       fhGains->SetBinError(raw-1,gains.DataCheck(i)) ;
 648     }
 649   }
 650 }
 651 //_____________________________________________________________________________
 652 void AliPHOSCalibrator::WriteGains(const char * version)
 653 {
 654   //Write gains through AliPHOSCalibrManager
 655   //version and validity range(begin-end) are used to identify data
 656
 657   if(!fctdb){
 658     AliError(Form("\n        Please, supply Connection Table DB (use SetConTableDB()) \n" )) ;
 659     return ;
 660   }
 661
 662   AliPHOSCalibrationData gains("Gains",version);
 663   for(Int_t i=0; i<fNch;i++){
 664     Int_t absid=fctdb->Raw2AbsId(i) ;
 665     gains.SetData(absid,fhGains->GetBinContent(i)) ;
 666     gains.SetDataCheck(absid,fhGainsWid->GetBinContent(i)) ;
 667   }
 668 //   if(begin==0){
 669 //     TIter next(fRunList) ;
 670 //     Int_t ibegin=99999;
 671 //     Int_t iend=0 ;
 672 //     TObjString * file ;
 673 //     while((file=((TObjString*)next()))){
 674 //        TString s = file->GetString() ;
 675 //        TSubString ss = s(s.Last('_'),s.Last('.'));
 676 //        Int_t tmp ;
 677 //        if(sscanf(ss.Data(),"%d",&tmp)){
 678 //       if(ibegin<tmp)
 679 //         ibegin=tmp ;
 680 //          if(iend>tmp)
 681 //         iend=tmp ;
 682 //        }
 683 //     }
 684 //     gains.SetValidityRange(ibegin,iend) ;
 685 //   }
 686 //   else
 687 //     gains.SetValidityRange(begin,end) ;
 688   AliPHOSCalibrManager * cmngr = AliPHOSCalibrManager::GetInstance() ;
 689   if(!cmngr){
 690     AliWarning(Form("Using database file 'PHOSBTCalibration.root'")) ;
 691     cmngr = AliPHOSCalibrManager::GetInstance("PHOSBTCalibration.root") ;
 692   }
 693   cmngr->WriteData(gains) ;
 694 }
 695 //_____________________________________________________________________________
 696 void AliPHOSCalibrator::Print(const Option_t *)const
 697 {
 698   // prints everything
 699   AliInfo(Form("--------------PHOS Calibrator-----------------\n")) ;
 700   printf("Files to handle:\n") ;
 701   TIter next(fRunList) ;
 702   TObjString * r ;
 703   while((r=(TObjString *)(next())))
 704       printf("                %s\n",r->GetName()) ;
 705
 706   printf("Name of ConTableDB:.....................%s\n",fConTableDB.Data()) ;
 707   printf("File of ConTableDB:.....................%s\n",fConTableDBFile.Data() ) ;
 708   printf("Maximal deviation from mean Gain (factor):.%f\n",fGainAcceptCorr) ;
 709   printf("Maximal deviation of Pedestal from mean:...%f\n",fAcceptCorr) ;
 710   printf("Range used in Gain histos:..............%f\n",fGainMax) ;
 711   printf("Number of bins in Gain histos:..........%d\n",fNGainBins) ;
 712   printf("Number of channels to calibrate:........%d\n",fNch) ;
 713   printf("Number of bins in pedestal histos:......%d\n",fNChan) ;
 714   printf("--------------------------------------------------\n") ;
 715 }