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