STEER/STEER/AliTriggerRunScalers.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: AliTriggerRunScalers.cxx 22322 2007-11-22 11:43:14Z cvetan $ */
  17
  18 ///////////////////////////////////////////////////////////////////////////////
  19 //
  20 // Class to define the ALICE Trigger Scalers Record per Run.
  21 // ReadScalers(): read the txt file (rXXXX.cnt) provided by CTP and creates array of records.
  22 // ConsistencyCheck(): checks if the last scaler added to record is consistent,
  23 // i.e. time increases and valued are not decreasing in time.
  24 //
  25 //
  26 //////////////////////////////////////////////////////////////////////////////
  27
  28 #include <stdlib.h>
  29 #include <Riostream.h>
  30
  31 //#include <TObject.h>
  32 //#include <TArrayC.h>
  33 //#include <TFile.h>
  34 #include <TClass.h>
  35 #include <TSystem.h>
  36 #include <TObjString.h>
  37 #include <TObjArray.h>
  38 #include <TMath.h>
  39 #include <TGraphErrors.h>
  40
  41 #include "AliLog.h"
  42 #include "AliTimeStamp.h"
  43 #include "AliTriggerScalers.h"
  44 #include "AliTriggerScalersESD.h"
  45 #include "AliTriggerScalersRecord.h"
  46 #include "AliTriggerScalersRecordESD.h"
  47 #include "AliTriggerRunScalers.h"
  48 #include "AliTriggerConfiguration.h"
  49 #include "AliTriggerClass.h"
  50 #include "AliTriggerBCMask.h"
  51
  52 using std::endl;
  53 using std::cout;
  54 using std::ifstream;
  55 ClassImp( AliTriggerRunScalers )
  56
  57 //_____________________________________________________________________________
  58 AliTriggerRunScalers::AliTriggerRunScalers():
  59   TObject(),
  60   fVersion(0),
  61   fRunNumber(0),
  62   fnClasses(0),
  63   fClassIndex(),
  64   fScalersRecord(),
  65   fScalersRecordESD()
  66 {
  67   // Default constructor
  68 }
  69 //______________________________________________________________________________
  70 AliTriggerRunScalers::~AliTriggerRunScalers()
  71 {
  72  // Destructor
  73  fScalersRecord.SetOwner();
  74  fScalersRecord.Delete();
  75  fScalersRecordESD.SetOwner();
  76  fScalersRecordESD.Delete();
  77 }
  78 //_____________________________________________________________________________
  79 void AliTriggerRunScalers::AddTriggerScalers( AliTriggerScalersRecord* scaler )
  80 {
  81   // Add scaler and check consistency
  82   fScalersRecord.AddLast( scaler );
  83   UInt_t* overflow[6];
  84   for(Int_t i=0; i<6; i++) {
  85      overflow[i] = new UInt_t[fnClasses];
  86      for(Int_t j=0; j<fnClasses; j++) overflow[i][j] = 0;
  87   }
  88   if (AliTriggerRunScalers::ConsistencyCheck(fScalersRecord.GetEntriesFast()-1,kFALSE,overflow)){
  89    AliErrorClass("Trigger counters not in the right order or decreasing!");
  90   //  scaler->Print();
  91   //  fScalersRecord.Sort();
  92  }
  93 }
  94 //_____________________________________________________________________________
  95
  96 AliTriggerRunScalers::AliTriggerRunScalers(const AliTriggerRunScalers &run) :
  97  TObject(),
  98  fVersion(run.fVersion),
  99  fRunNumber(run.fRunNumber),
 100  fnClasses(run.fnClasses),
 101  fClassIndex(),
 102  fScalersRecord(),
 103  fScalersRecordESD()
 104 {
 105 // copy constructor
 106   fClassIndex.Set(run.fClassIndex.GetSize());
 107 for (Int_t i = 0; i < run.fClassIndex.GetSize(); i++) {
 108     if (run.fClassIndex[i]) fClassIndex.AddAt(run.fClassIndex[i], i);
 109   }
 110 for (Int_t i = 0; i < run.fScalersRecord.GetEntriesFast(); i++) {
 111     if (run.fScalersRecord[i]) fScalersRecord.Add(run.fScalersRecord[i]->Clone());
 112   }
 113 for (Int_t i = 0; i < run.fScalersRecordESD.GetEntriesFast(); i++) {
 114     if (run.fScalersRecordESD[i]) fScalersRecordESD.Add(run.fScalersRecordESD[i]->Clone());
 115   }
 116
 117 }
 118 //_____________________________________________________________________________
 119 AliTriggerRunScalers &AliTriggerRunScalers::operator=(const AliTriggerRunScalers& run)
 120 {
 121 // assignment operator
 122 if(&run == this) return *this;
 123 ((TObject *)this)->operator=(run);
 124
 125 fVersion = run.fVersion;
 126 fRunNumber = run.fRunNumber;
 127 fnClasses = run.fnClasses;
 128
 129 for (Int_t i = 0; i < run.fClassIndex.GetSize(); i++) {
 130     if (run.fClassIndex[i]) fClassIndex.AddAt(run.fClassIndex[i], i);
 131   }
 132 for (Int_t i = 0; i < run.fScalersRecord.GetEntriesFast(); i++) {
 133     if (run.fScalersRecord[i]) fScalersRecord.Add(run.fScalersRecord[i]->Clone());
 134   }
 135 for (Int_t i = 0; i < run.fScalersRecordESD.GetEntriesFast(); i++) {
 136     if (run.fScalersRecordESD[i]) fScalersRecordESD.Add(run.fScalersRecordESD[i]->Clone());
 137   }
 138 return *this;
 139 }
 140 //_____________________________________________________________________________
 141 AliTriggerRunScalers* AliTriggerRunScalers::ReadScalers( TString & filename )
 142 {
 143   // Read scalers from text file(.cnt) provided by CTP
 144   // for given run and convert it to root format
 145   if( gSystem->AccessPathName( filename.Data() ) ) {
 146      AliErrorClass( Form( "file (%s) not found", filename.Data() ) );
 147      return NULL;
 148   }
 149
 150   ifstream *file = new ifstream ( filename.Data() );
 151   if (!*file) {
 152     AliErrorClass(Form("Error opening file (%s) !\n",filename.Data()));
 153     file->close();
 154     delete file;
 155     return NULL;
 156   }
 157
 158   AliTriggerRunScalers* rScaler = new AliTriggerRunScalers();
 159
 160   TString strLine;
 161   Bool_t verflag = kFALSE;
 162   Bool_t classflag = kFALSE;
 163   UChar_t nclass = 0;
 164   while (strLine.ReadLine(*file)) {
 165     if (strLine.BeginsWith("#")) continue;
 166
 167     TObjArray *tokens = strLine.Tokenize(" \t");
 168     Int_t ntokens = tokens->GetEntriesFast();
 169     // 1st line, version, it is one number,
 170     if (!verflag) {
 171       if (ntokens != 1) {
 172         AliErrorClass( Form( "Error reading version number from (%s), line :%s\n",
 173                               filename.Data() , strLine.Data() ) );
 174         delete tokens;
 175         return NULL;
 176       }
 177   //    cout << "Version "<< ((TObjString*)tokens->At(0))->String().Atoi() << endl;
 178       rScaler->SetVersion( ((TObjString*)tokens->At(0))->String().Atoi() );
 179       verflag = kTRUE;
 180       delete tokens;
 181       continue;
 182     }
 183
 184     // 2nd line, run number , number of classes, list of classes used in this partition
 185
 186     if (!classflag) {
 187       if ( !((TObjString*)tokens->At(1))->String().IsDigit() ) {
 188         AliErrorClass( Form( "Error reading Run number from (%s)\n", filename.Data() ));
 189       }
 190   //    cout << "Run Number " << ((TObjString*)tokens->At(0))->String().Atoi() << endl;
 191       rScaler->SetRunNumber( ((TObjString*)tokens->At(0))->String().Atoi() );
 192       nclass = (UChar_t)((TObjString*)tokens->At(1))->String().Atoi();
 193   //    cout << "Number of classes " << nclass << endl;
 194       rScaler->SetNumClasses( nclass );
 195       if ( nclass != ntokens - 2 ) {
 196         AliErrorClass( Form( "Error reading number of classes from (%s)\n", filename.Data() ));
 197       }
 198       for (UChar_t i=0; i<nclass; ++i) {
 199         rScaler->SetClass( i, (Char_t)((TObjString*)tokens->At(2+i))->String().Atoi() );
 200       }
 201       classflag = kTRUE;
 202       delete tokens;
 203       continue;
 204     }
 205
 206     // Records
 207     // Each record consists of 1+(number of classes in partition) lines
 208     //  1st line of record = time stamp (4 words)
 209     //                        1st word = ORBIT(24 bits)
 210     //                        2nd word = Period Counter (28 bit)
 211     //                        3rd word = seconds (32 bits) from epoch
 212     //                        4th word = microsecs (32 bits)
 213     //  other lines = 6 words of counters (L0 before,L0 after, ....)
 214     if (ntokens != 4 && ntokens !=5) {
 215       AliErrorClass( Form( "Error reading timestamp from (%s): line (%s)",
 216                             filename.Data(), strLine.Data() ));
 217       return NULL;
 218     }
 219
 220     UInt_t orbit     = strtoul(((TObjString*)tokens->At(0))->String(), NULL, 10);
 221     UInt_t period    = strtoul(((TObjString*)tokens->At(1))->String(), NULL, 10);
 222     UInt_t seconds   = strtoul(((TObjString*)tokens->At(2))->String(), NULL, 10);
 223     UInt_t microSecs = strtoul(((TObjString*)tokens->At(3))->String(), NULL, 10);
 224
 225     AliTriggerScalersRecord * rec = new AliTriggerScalersRecord();
 226     if(ntokens==5){
 227       UInt_t tgroup=strtoul(((TObjString*)tokens->At(4))->String(), NULL, 10);
 228       rec->SetTimeGroup(tgroup);
 229     }
 230     rec->SetTimeStamp( orbit, period, seconds, microSecs );
 231     TString strLine1;
 232     for (Int_t i=0; i<nclass; ++i) {
 233       strLine1.ReadLine(*file);
 234       if (strLine1.BeginsWith("#")) continue;
 235       TObjArray *tokens1 = strLine1.Tokenize(" \t");
 236       Int_t ntokens1 = tokens1->GetEntriesFast();
 237       if( ntokens1 != 6 ) {
 238         AliErrorClass( Form( "Error reading scalers from (%s): line (%s)",
 239                              filename.Data(), strLine1.Data() ));
 240         delete rec;
 241         delete tokens1;
 242         return rScaler;
 243       }
 244
 245       UInt_t lOCB = strtoul(((TObjString*)tokens1->At(0))->String(), NULL, 10);
 246       UInt_t lOCA = strtoul(((TObjString*)tokens1->At(1))->String(), NULL, 10);
 247       UInt_t l1CB = strtoul(((TObjString*)tokens1->At(2))->String(), NULL, 10);
 248       UInt_t l1CA = strtoul(((TObjString*)tokens1->At(3))->String(), NULL, 10);
 249       UInt_t l2CB = strtoul(((TObjString*)tokens1->At(4))->String(), NULL, 10);
 250       UInt_t l2CA = strtoul(((TObjString*)tokens1->At(5))->String(), NULL, 10);
 251
 252       rScaler->GetClass(i);
 253       rec->AddTriggerScalers( rScaler->GetClass(i),
 254                               lOCB, lOCA, l1CB,
 255                               l1CA, l2CB, l2CA );
 256
 257       delete tokens1;
 258     }
 259     rScaler->AddTriggerScalers( rec );
 260
 261     delete tokens;
 262   }
 263   file->close();
 264   delete file;
 265
 266   return  rScaler;
 267 }
 268
 269 //_____________________________________________________________________________
 270 Int_t  AliTriggerRunScalers::FindNearestScalersRecord( const AliTimeStamp *stamp ) const
 271 {
 272    // Find Trigger scaler record with the closest timestamp <= "stamp"
 273    // using a binary search.
 274    // return the index in the array of records, if the timestamp
 275    // is out of range return -1
 276
 277    Int_t   base, position=-1, last, result = 0;
 278    Int_t op2 = 0;
 279
 280    //fScalersRecord.Sort();
 281
 282    base = 0;
 283    last = fScalersRecord.GetEntriesFast();
 284
 285    while (last >= base) {
 286       position = (base+last) / 2;
 287       AliDebug(1, Form("position= %d   base= %d    last= %d  ",position,base,last));
 288       AliTriggerScalersRecord* rec = (AliTriggerScalersRecord*)fScalersRecord.At(position);
 289       if( rec && rec->GetTimeStamp()) op2 = 1;
 290       if( op2 && (result = stamp->Compare(rec->GetTimeStamp())) == 0  )
 291          return position;  // exact match
 292       if (!op2 || result < 0)
 293          last = position-1;
 294       else
 295          base = position+1;
 296       op2 = 0;
 297    }
 298    if( (position == 0 && result < 0) || position >= fScalersRecord.GetEntriesFast() )
 299     return -1;  // out of range
 300    else
 301     return (result < 0 ) ? position-1 : position; // nearst < stamp
 302 }
 303 //_____________________________________________________________________________
 304 Int_t AliTriggerRunScalers::ConsistencyCheck(Int_t position,Bool_t correctOverflow, UInt_t** overflow)
 305 {
 306    //Check if counters are consistent(increase). Example: lOCB(n) < lOCB(n+1) and lOCB > lOCA
 307    // scalers coding 0,1,2,3,4,5=0b,0a,1b,1a,2b,2a
 308    // returns:
 309    //         1 = decresing time
 310    //         2 = too big jump in scalers, looks like some readings are missing
 311    //         3 = (level+1) > (level)
 312    if (position == 0){
 313       if(correctOverflow){
 314         AliErrorClass("position=0\n");
 315         return 1;
 316       }else return 0; // to work correctly in AddScalers
 317    };
 318    UInt_t c2[6], c1[6];
 319    ULong64_t c64[6];
 320    Bool_t increase[6];
 321    for(Int_t i=0;i<6;i++){increase[i]=0;}
 322    ULong64_t const max1 = 4294967295ul;  //32bit counters overflow after 4294967295
 323    ULong64_t const max2 = 1000000000ul;  //when counters overflow they seem to be decreasing. Assume decrease cannot be smaller than max2.
 324
 325    AliTriggerScalersRecord* scalers2 = (AliTriggerScalersRecord*)fScalersRecord.At(position);
 326    AliTriggerScalersRecord* scalers1 = (AliTriggerScalersRecord*)fScalersRecord.At(position-1);
 327    if (scalers2->Compare((AliTriggerScalersRecord*)fScalersRecord.At(position-1)) == -1) return 1;
 328
 329    AliTriggerScalersRecordESD* recESD = 0;
 330    if(correctOverflow){
 331      recESD = new AliTriggerScalersRecordESD();
 332      recESD->SetTimeStamp(scalers2->GetTimeStamp());
 333      recESD->SetTimeGroup(scalers2->GetTimeGroup());
 334    }
 335    for( Int_t ic=0; ic<fnClasses; ++ic ){
 336       TObjArray* scalersArray2 = (TObjArray*)scalers2->GetTriggerScalers();
 337       AliTriggerScalers* counters2 = (AliTriggerScalers*)scalersArray2->At(ic);
 338       UChar_t iclass = counters2->GetClassIndex();
 339       counters2->GetAllScalers(c2);
 340       TObjArray* scalersArray1 = (TObjArray*)scalers1->GetTriggerScalers();
 341       AliTriggerScalers* counters1 = (AliTriggerScalers*)scalersArray1->At(ic);
 342       counters1->GetAllScalers(c1);
 343       for(Int_t i=0;i<5;i++){
 344          if ( c2[i] >= c1[i] ) increase[i]=1;
 345          else if ( c2[i] < c1[i] && (c1[i] - c2[i]) > max2) overflow[i][ic]++;
 346          else return 2;
 347       }
 348       for(Int_t i=0;i<5;i++){
 349          if ((c2[i] - c1[i]) < (c2[i+1] - c1[i+1]) && increase[i] && increase[i+1] ) {
 350                  if ( ((c2[i+1] - c1[i+1]) - (c2[i] - c1[i])) < 16 ) {AliWarningClass("Trigger scaler Level[i+1] > Level[i]. Diff < 16!");}
 351                  else {
 352                     cout << " 1 pos= " << position << "i= "<< i << endl;
 353                     return 3;
 354                  }
 355          }
 356          else if ( (max1 - c1[i]+c2[i]) < (c2[i+1] - c1[i+1]) && overflow[i][ic] && increase[i+1] ) {
 357                  if ( ((c2[i+1] - c1[i+1]) - (max1 - c1[i]+c2[i])) < 16 ) {AliWarningClass("Trigger scaler Level[i+1] > Level[i]. Diff < 16!");}
 358                  else{
 359                     cout << " 2 pos= " << position << "i= "<< i << endl;
 360                     return 3;
 361                  }
 362          }
 363          else if ( (c2[i] - c1[i]) < (max1 - c1[i+1] + c2[i+1]) && increase[i] && overflow[i+1][ic] ) {
 364                  if ( ((max1 - c1[i+1] + c2[i+1]) - (c2[i] - c1[i])) < 16 ) {AliWarningClass("Trigger scaler Level[i+1] > Level[i]. Diff < 16!");}
 365                  else{
 366                     cout << " 3 pos= " << position << "i= "<< i << endl;
 367                     return 3;
 368                     }
 369          }
 370          else if ( (max1 - c1[i] + c2[i] ) < (max1 - c1[i+1] + c2[i+1]) && overflow[i][ic] && overflow[i+1][ic] ) {
 371                  if ( ((max1 - c1[i+1] + c2[i+1]) - (max1 - c1[i] + c2[i] )) < 16 ) {AliWarningClass("Trigger scaler Level[i+1] > Level[i]. Diff < 16!");}
 372                  else{
 373                     cout << " 4 pos= " << position << "i= "<< i << endl;
 374                     return 3;
 375                     }
 376        }
 377       }
 378       if(correctOverflow){
 379         for(Int_t i=0;i<6;i++){ c64[i]=c2[i]+max1*overflow[i][ic]; }
 380         AliTriggerScalersESD* s= new AliTriggerScalersESD(iclass,c64);
 381         recESD->AddTriggerScalers(s);
 382          }
 383
 384  }
 385  if(correctOverflow)fScalersRecordESD.AddLast(recESD);
 386  return 0;
 387 }
 388 //____________________________________________________________________________
 389 Int_t AliTriggerRunScalers::CorrectScalersOverflow()
 390 {
 391  // Run over fScalersRecord, check overflow using CheckConsistency methos
 392  // and save corrected result in fScalersRecordESD.
 393
 394  // Temporary fix for the OCDB entries written with v4-16-Release
 395  // where the wrong sorting was used
 396  fScalersRecord.Sort();
 397  UInt_t c1[6];
 398  ULong64_t c64[6];
 399  AliTriggerScalersRecordESD* recESD = new AliTriggerScalersRecordESD();
 400  // add 0
 401  AliTriggerScalersRecord* scalers = (AliTriggerScalersRecord*)fScalersRecord.At(0);
 402  recESD->SetTimeStamp(scalers->GetTimeStamp());
 403  recESD->SetTimeGroup(scalers->GetTimeGroup());
 404  for( Int_t ic=0; ic<fnClasses; ++ic ){
 405     TObjArray* scalersArray = (TObjArray*)scalers->GetTriggerScalers();
 406     AliTriggerScalers* counters = (AliTriggerScalers*)scalersArray->At(ic);
 407     counters->GetAllScalers(c1);
 408     UChar_t iclass = counters->GetClassIndex();
 409     for(Int_t i=0; i<6; i++)c64[i]=c1[i];
 410     AliTriggerScalersESD* s= new AliTriggerScalersESD(iclass,c64);
 411     recESD->AddTriggerScalers(s);
 412  }
 413  fScalersRecordESD.AddLast(recESD);
 414
 415  UInt_t* overflow[6];
 416  for(Int_t i=0; i<6; i++) {
 417     overflow[i] = new UInt_t[fnClasses];
 418     for(Int_t j=0; j<fnClasses; j++) overflow[i][j] = 0;
 419  }
 420
 421  for(Int_t i=1;i<fScalersRecord.GetEntriesFast(); i++){
 422   if(ConsistencyCheck(i,kTRUE,overflow)){
 423     fScalersRecord.At(i)->Print();
 424     fScalersRecord.At(i-1)->Print();
 425     fScalersRecordESD.SetOwner();
 426     fScalersRecordESD.Delete();
 427     AliErrorClass("Inconsistent scalers, they will not be provided.\n");
 428     return 1;
 429   }
 430  }
 431  if(fScalersRecordESD.GetEntriesFast() != fScalersRecord.GetEntriesFast()){
 432     AliErrorClass("Internal error: #scalers ESD != #scalers \n");
 433     return 1;
 434  }
 435  return 0;
 436 }
 437 //_____________________________________________________________________________
 438 AliTriggerScalersESD* AliTriggerRunScalers::GetScalersForEventClass(const AliTimeStamp* stamp,const Int_t classIndex) const
 439 {
 440  // Find scalers for event for class in fScalersRecordESD
 441  // Assumes that fScalerRecord = fScalerRecordESD
 442  Int_t position = FindNearestScalersRecord(stamp);
 443  if ( position == -1 ) {
 444   AliErrorClass("Event AliTimeStamp out of range!");
 445   return 0;
 446  }
 447  // check also position=max
 448  AliTriggerScalersRecordESD* scalrec1 = (AliTriggerScalersRecordESD*)fScalersRecordESD.At(position);
 449  AliTriggerScalersRecordESD* scalrec2 = (AliTriggerScalersRecordESD*)fScalersRecordESD.At(position+1);
 450  TObjArray* scalers1 = (TObjArray*)scalrec1->GetTriggerScalers();
 451  TObjArray* scalers2 = (TObjArray*)scalrec2->GetTriggerScalers();
 452
 453  if(scalers1->GetEntriesFast() != fnClasses){
 454   AliErrorClass("Internal error: #classes in RecordESD != fnClasses\n");
 455   return 0;
 456  }
 457
 458  AliTriggerScalersESD *s1,*s2;
 459  for ( Int_t ic=0; ic < (Int_t)fnClasses; ++ic ){
 460
 461       s1 = (AliTriggerScalersESD*)scalers1->At(ic);
 462       s2 = (AliTriggerScalersESD*)scalers2->At(ic);
 463
 464       Bool_t classfound = (s1->GetClassIndex() == classIndex) && (s2->GetClassIndex() == classIndex);
 465       if(classfound){
 466         ULong64_t max = 16777216ul;
 467         AliTriggerScalersRecordESD* scalrec0 = (AliTriggerScalersRecordESD*)fScalersRecordESD.At(0);
 468         TObjArray* scalers0 = (TObjArray*)scalrec0->GetTriggerScalers();
 469         AliTriggerScalersESD *s0 = (AliTriggerScalersESD*)scalers0->At(ic);
 470         ULong64_t base[6],c1[6],c2[6],cint[6];
 471         ULong64_t orbit = max*(stamp->GetPeriod()) + stamp->GetOrbit();
 472         s0->GetAllScalers(base);
 473         s1->GetAllScalers(c1);
 474         s2->GetAllScalers(c2);
 475         ULong64_t orbit1 = max*(scalrec1->GetTimeStamp()->GetPeriod())+scalrec1->GetTimeStamp()->GetOrbit();
 476         ULong64_t orbit2 = max*(scalrec2->GetTimeStamp()->GetPeriod())+scalrec2->GetTimeStamp()->GetOrbit();
 477         for(Int_t i=0;i<6;i++){
 478            Double_t slope=Double_t(c2[i]-c1[i])/Double_t(orbit2-orbit1);
 479            cint[i]=ULong64_t(slope*(orbit-orbit1)) +c1[i] -base[i];
 480         }
 481         AliTriggerScalersESD* result = new AliTriggerScalersESD(classIndex,cint);
 482         return result;
 483       }
 484  }
 485  AliErrorClass(Form("Classindex %i not found.\n",classIndex));
 486  return 0;
 487 }
 488
 489 //_____________________________________________________________________________
 490 const AliTriggerScalersRecordESD* AliTriggerRunScalers::GetScalersDeltaForEvent(const AliTimeStamp* stamp) const
 491 {
 492  // Find scalers for event for class in fScalersRecordESD
 493  // Assumes that fScalerRecord = fScalerRecordESD
 494  Int_t position = FindNearestScalersRecord(stamp);
 495  if ( position == -1 ) {
 496   AliErrorClass("Event AliTimeStamp out of range!");
 497   return 0;
 498  }
 499  // check also position=max
 500  if (fScalersRecordESD.GetEntriesFast()<2) return 0;
 501
 502  AliTriggerScalersRecordESD* scalrec1 = (AliTriggerScalersRecordESD*)fScalersRecordESD.At(position);
 503  AliTriggerScalersRecordESD* scalrec2 = (AliTriggerScalersRecordESD*)fScalersRecordESD.At(position+1);
 504  TObjArray* scalers1 = (TObjArray*)scalrec1->GetTriggerScalers();
 505  TObjArray* scalers2 = (TObjArray*)scalrec2->GetTriggerScalers();
 506
 507  if(scalers1->GetEntriesFast() != fnClasses){
 508   AliErrorClass("Internal error: #classes in RecordESD != fnClasses\n");
 509   return 0;
 510  }
 511  AliTriggerScalersRecordESD *scalrec = new AliTriggerScalersRecordESD();
 512  AliTriggerScalersESD *s1,*s2;
 513  for ( Int_t ic=0; ic < (Int_t)fnClasses; ++ic ){
 514
 515   s1 = (AliTriggerScalersESD*)scalers1->At(ic);
 516   s2 = (AliTriggerScalersESD*)scalers2->At(ic);
 517
 518   ULong64_t c1[6],c2[6],cint[6];
 519   s1->GetAllScalers(c1);
 520   s2->GetAllScalers(c2);
 521   for(Int_t i=0;i<6;i++){
 522      cint[i]=c2[i]-c1[i];
 523   }
 524   AliTriggerScalersESD* result = new AliTriggerScalersESD(s1->GetClassIndex(),cint);
 525   scalrec->AddTriggerScalers(result);
 526  }
 527  UInt_t max = 16777216ul;
 528  UInt_t orbit, period;
 529
 530  if (scalrec2->GetTimeStamp()->GetOrbit() > scalrec1->GetTimeStamp()->GetOrbit()) {
 531   orbit = scalrec2->GetTimeStamp()->GetOrbit() - scalrec1->GetTimeStamp()->GetOrbit();
 532   period = scalrec2->GetTimeStamp()->GetPeriod() - scalrec1->GetTimeStamp()->GetPeriod();
 533  }
 534  else {
 535   orbit = max - (scalrec1->GetTimeStamp()->GetOrbit() - scalrec2->GetTimeStamp()->GetOrbit());
 536   period = scalrec2->GetTimeStamp()->GetPeriod() - scalrec1->GetTimeStamp()->GetPeriod() - 1;
 537  }
 538
 539  AliTimeStamp *timestamp = new AliTimeStamp(orbit, period, 0);
 540  scalrec->SetTimeStamp(timestamp);
 541  delete timestamp;
 542  return scalrec;
 543 }
 544 //_____________________________________________________________________________
 545 const AliTriggerScalersRecordESD* AliTriggerRunScalers::GetScalersDeltaForRun() const
 546 {
 547  // Find scalers for event for class in fScalersRecordESD
 548  // Assumes that fScalerRecord = fScalerRecordESD
 549  if (fScalersRecordESD.GetEntriesFast()<2) return 0;
 550
 551  AliTriggerScalersRecordESD* scalrec1 = (AliTriggerScalersRecordESD*)fScalersRecordESD.At(0);
 552  AliTriggerScalersRecordESD* scalrec2 = (AliTriggerScalersRecordESD*)fScalersRecordESD.At(fScalersRecord.GetEntriesFast()-1);
 553  TObjArray* scalers1 = (TObjArray*)scalrec1->GetTriggerScalers();
 554  TObjArray* scalers2 = (TObjArray*)scalrec2->GetTriggerScalers();
 555
 556  if(scalers1->GetEntriesFast() != fnClasses){
 557   AliErrorClass("Internal error: #classes in RecordESD != fnClasses\n");
 558   return 0;
 559  }
 560  AliTriggerScalersESD *s1,*s2;
 561  AliTriggerScalersRecordESD *scalrec = new AliTriggerScalersRecordESD();
 562  for ( Int_t ic=0; ic < (Int_t)fnClasses; ++ic ){
 563
 564   s1 = (AliTriggerScalersESD*)scalers1->At(ic);
 565   s2 = (AliTriggerScalersESD*)scalers2->At(ic);
 566
 567   ULong64_t c1[6],c2[6],cint[6];
 568   s1->GetAllScalers(c1);
 569   s2->GetAllScalers(c2);
 570   for(Int_t i=0;i<6;i++){
 571      cint[i]=c2[i]-c1[i];
 572   }
 573   AliTriggerScalersESD* result = new AliTriggerScalersESD(s1->GetClassIndex(),cint);
 574   scalrec->AddTriggerScalers(result);
 575  }
 576  UInt_t max = 16777216ul;
 577  UInt_t orbit, period;
 578
 579  if (scalrec2->GetTimeStamp()->GetOrbit() > scalrec1->GetTimeStamp()->GetOrbit()) {
 580   orbit = scalrec2->GetTimeStamp()->GetOrbit() - scalrec1->GetTimeStamp()->GetOrbit();
 581   period = scalrec2->GetTimeStamp()->GetPeriod() - scalrec1->GetTimeStamp()->GetPeriod();
 582  }
 583  else {
 584   orbit = max - (scalrec1->GetTimeStamp()->GetOrbit() - scalrec2->GetTimeStamp()->GetOrbit());
 585   period = scalrec2->GetTimeStamp()->GetPeriod() - scalrec1->GetTimeStamp()->GetPeriod() - 1;
 586  }
 587
 588  AliTimeStamp *timestamp = new AliTimeStamp(orbit, period, 0);
 589  scalrec->SetTimeStamp(timestamp);
 590  delete timestamp;
 591  return scalrec;
 592 }
 593 //_____________________________________________________________________________
 594 Bool_t AliTriggerRunScalers::CalculateMu(Double_t &mu, Double_t &errmu, ULong64_t countsB, ULong64_t countsAC, UShort_t nB, UShort_t nAC, UInt_t orbits, Bool_t bkgCorr, Double_t triggerEff, Double_t errorEff)
 595 {
 596
 597    if (nB!=0 && orbits!=0)  {
 598       Double_t pB = (Double_t)countsB/((ULong64_t)nB*orbits); // probability for B trigger
 599       if (!bkgCorr || nAC==0 ) {
 600          mu = -log(1-pB)/triggerEff;
 601          errmu = TMath::Sqrt(pB/((1-pB)*nB*orbits) + mu*mu*errorEff*errorEff/(triggerEff*triggerEff)); //
 602          return kTRUE;
 603       }
 604       else
 605       {
 606          Double_t pAC = (Double_t)countsAC/((ULong64_t)nAC*orbits); // probability for AC trigger (background)
 607          mu = ( log(1.-pAC) - log(1.-pB) )/triggerEff;
 608          // error
 609          errmu =  TMath::Sqrt(pB/((1.-pB)*nB*orbits) + pAC/((1.-pAC)*nAC*orbits) /*- 2*TMath::Sqrt(pB*pAC/(nB*nAC*(1.-pB)*(1.-pAC)))/orbits*/ + mu*mu*errorEff*errorEff/(triggerEff*triggerEff)); // assume no correlation between B and AC rates, hence no cov term in error
 610          return kTRUE;
 611       }
 612    }
 613    return kFALSE;
 614 }
 615 //_____________________________________________________________________________
 616 Bool_t AliTriggerRunScalers::CalculateMu(Double_t &mu, Double_t &errmu, ULong64_t countsB, ULong64_t countsAC, ULong64_t beamB, UShort_t nB, UShort_t nAC, Bool_t bkgCorr, Double_t triggerEff, Double_t errorEff)
 617 {
 618
 619    if (beamB!=0)  {
 620       Double_t pB = (Double_t)countsB/beamB; // probability for B trigger
 621       if (!bkgCorr || nAC==0 || nB==0) {
 622          mu = -log(1-pB)/triggerEff;
 623          errmu = TMath::Sqrt(pB/((1-pB)*beamB) + mu*mu*errorEff*errorEff/(triggerEff*triggerEff)); //
 624          return kTRUE;
 625       }
 626       else
 627       {
 628          Double_t pAC = (Double_t)countsAC/((ULong64_t)nAC*beamB/(Double_t)nB); // probability for AC trigger (background)
 629          mu = ( log(1-pAC) - log(1-pB) )/triggerEff;
 630          // error
 631          errmu =  TMath::Sqrt(pB/((1-pB)*beamB) + pAC/((1-pAC)*nAC*beamB/nB) + mu*mu*errorEff*errorEff/(triggerEff*triggerEff));
 632          return kTRUE;
 633       }
 634    }
 635    return kFALSE;
 636 }
 637 //_____________________________________________________________________________
 638 ULong64_t AliTriggerRunScalers::GetDeltaScaler(const AliTriggerScalersRecordESD* scalRec1, const AliTriggerScalersRecordESD* scalRec2, Int_t classIndex, TString level)
 639 {
 640   const AliTriggerScalersESD* scalers1 = scalRec1->GetTriggerScalersForClass(classIndex);
 641   const AliTriggerScalersESD* scalers2 = scalRec2->GetTriggerScalersForClass(classIndex);
 642   ULong64_t s1=0;
 643   ULong64_t s2=0;
 644
 645   if (level == "l0b") {s1=scalers1->GetLOCB(); s2=scalers2->GetLOCB();}
 646   else if (level == "l0a") {s1=scalers1->GetLOCA(); s2=scalers2->GetLOCA();}
 647   else if (level == "l1b") {s1=scalers1->GetL1CB(); s2=scalers2->GetL1CB();}
 648   else if (level == "l1a") {s1=scalers1->GetL1CA(); s2=scalers2->GetL1CA();}
 649   else if (level == "l2b") {s1=scalers1->GetL2CB(); s2=scalers2->GetL2CB();}
 650   else if (level == "l2a") {s1=scalers1->GetL2CA(); s2=scalers2->GetL2CA();}
 651   else return 0;
 652
 653   return s2-s1;
 654 }
 655 //_____________________________________________________________________________
 656 Double_t AliTriggerRunScalers::GetDeltaTime(const AliTriggerScalersRecordESD* scalRec1, const AliTriggerScalersRecordESD* scalRec2)
 657 {
 658   const AliTimeStamp* stamp1 = scalRec1->GetTimeStamp();
 659   const AliTimeStamp* stamp2 = scalRec2->GetTimeStamp();
 660   UInt_t orbit1 = stamp1->GetOrbit();
 661   UInt_t orbit2 = stamp2->GetOrbit();
 662   UInt_t period1 = stamp1->GetPeriod();
 663   UInt_t period2 = stamp2->GetPeriod();
 664   UInt_t max = 16777216;  // The period counter increases when 24 bit orbit counter overflow
 665   Double_t orbitSec = 89.1*1.e-6; // Length of 1 orbit in seconds
 666   return ((period2 - period1)*max + (orbit2-orbit1))*orbitSec;
 667 }
 668 //_____________________________________________________________________________
 669 UInt_t AliTriggerRunScalers::GetDeltaOrbits(const AliTriggerScalersRecordESD* scalRec1, const AliTriggerScalersRecordESD* scalRec2)
 670 {
 671   const AliTimeStamp* stamp1 = scalRec1->GetTimeStamp();
 672   const AliTimeStamp* stamp2 = scalRec2->GetTimeStamp();
 673   UInt_t orbit1 = stamp1->GetOrbit();
 674   UInt_t orbit2 = stamp2->GetOrbit();
 675   UInt_t period1 = stamp1->GetPeriod();
 676   UInt_t period2 = stamp2->GetPeriod();
 677   UInt_t max = 16777216;  // The period counter increases when 24 bit orbit counter overflow
 678   return (period2 - period1)*max + (orbit2-orbit1);
 679 }
 680 //_____________________________________________________________________________
 681 Bool_t AliTriggerRunScalers::GetScalerRate(Double_t &rate, Double_t &error, const AliTriggerScalersRecordESD* scalRec1, const AliTriggerScalersRecordESD* scalRec2, Int_t classIndex, TString level)
 682 {
 683   if (level != "l0b" && level != "l0a" && level != "l1b" && level != "l1a" && level != "l2b" && level != "l2a") return kFALSE;
 684
 685   ULong64_t scaler = GetDeltaScaler(scalRec1, scalRec2, classIndex, level);
 686   Double_t time = GetDeltaTime(scalRec1, scalRec2 );
 687   if (time==0.) return kFALSE;
 688   rate = (Double_t)scaler/time;
 689   error = (Double_t)sqrt(scaler)/time;
 690   return kTRUE;
 691 }
 692 //_____________________________________________________________________________
 693 Bool_t AliTriggerRunScalers::GetScalerRatePerBC(Double_t &rate, Double_t &error, const AliTriggerScalersRecordESD* scalRec1, const AliTriggerScalersRecordESD* scalRec2, AliTriggerConfiguration* cfg, Int_t classIndex, TString level)
 694 {
 695   if (level != "l0b" && level != "l0a" && level != "l1b" && level != "l1a" && level != "l2b" && level != "l2a") return kFALSE;
 696   const AliTriggerClass* trgclass = cfg->GetTriggerClass(classIndex);
 697   AliTriggerBCMask* bcMask = new AliTriggerBCMask();
 698   if (trgclass) bcMask = (AliTriggerBCMask*)trgclass->GetBCMask();
 699   Int_t nBC=0;
 700   if (TString(bcMask->GetName()).CompareTo("NONE")!=0){
 701      nBC = (UShort_t)bcMask->GetNUnmaskedBCs();
 702   }
 703   if (nBC<1) return kFALSE;
 704   ULong64_t scaler = GetDeltaScaler(scalRec1, scalRec2, classIndex, level);
 705   Double_t time = GetDeltaTime(scalRec1, scalRec2 );
 706   if (time==0.) return kFALSE;
 707   rate = (Double_t)scaler/time/nBC;
 708   error = (Double_t)sqrt(scaler)/time/nBC;
 709   return kTRUE;
 710 }
 711 //_____________________________________________________________________________
 712 Bool_t AliTriggerRunScalers::GetClassL2L0(Double_t &l2l0, Double_t &error, const AliTriggerScalersRecordESD* scalRec1, const AliTriggerScalersRecordESD* scalRec2, Int_t classIndex)
 713 {
 714   ULong64_t l0 = GetDeltaScaler(scalRec1, scalRec2, classIndex, "l0b");
 715   ULong64_t l2 = GetDeltaScaler(scalRec1, scalRec2, classIndex, "l2a");
 716   if (l0!=0) {
 717     l2l0 = (Double_t)l2/l0;
 718     error = (Double_t)sqrt(l2-l2*l2/l0)/l0;
 719     return kTRUE;
 720   }
 721   return kFALSE;
 722 }
 723 //_____________________________________________________________________________
 724 Bool_t AliTriggerRunScalers::GetMuFromClassScaler(Double_t &mu, Double_t &errmu, const char* className, const AliTriggerScalersRecordESD* scalRec1, const AliTriggerScalersRecordESD* scalRec2, AliTriggerConfiguration* cfg, Bool_t colBCsFromFillScheme, Bool_t bkgCorr, Double_t triggerEff, Double_t errorEff)
 725 {
 726   // className = the first part of the class name. For example CINT1 for the class CINT1-B-NOPF-ALL
 727   // colBCsFromFillScheme=kTRUE - use filling scheme and orbit counter
 728   // colBCsFromFillScheme=kFALSE - use cbeamb scaler to get number of colliding BCs
 729   // One can also switch background correction ON or OFF with bkgCorr
 730   TObjArray cint1bNames;
 731   TObjArray cint1acNames;
 732   TObjArray cbeambNames;
 733   //
 734   cint1bNames.Add(new TNamed(Form("%s-ABCE",className),NULL));
 735   cint1bNames.Add(new TNamed(Form("%s-B",className),NULL));
 736   cint1acNames.Add(new TNamed(Form("%s-AC",className),NULL));
 737   cbeambNames.Add(new TNamed("CBEAMB",NULL));
 738   cbeambNames.Add(new TNamed("CTRUE",NULL));
 739   //
 740   Int_t cint1bIndex=-1, cint1acIndex=-1, cbeambIndex=-1;
 741   TString nameString;
 742   //
 743   for (Int_t i=0; i<cfg->GetClasses().GetEntriesFast(); i++ ) {
 744      nameString = cfg->GetClassNameFromIndex(i);
 745      for (Int_t j=0; j<cint1bNames.GetEntriesFast(); j++ ) {
 746        if (nameString.BeginsWith(cint1bNames.At(j)->GetName())) cint1bIndex = i;
 747      }
 748      for (Int_t j=0; j<cint1acNames.GetEntriesFast(); j++ ) {
 749        if (nameString.BeginsWith(cint1acNames.At(j)->GetName())) cint1acIndex = i;
 750      }
 751      for (Int_t j=0; j<cbeambNames.GetEntriesFast(); j++ ) {
 752        if (nameString.BeginsWith(cbeambNames.At(j)->GetName())) cbeambIndex = i;
 753      }
 754      nameString.Clear();
 755   }
 756   //
 757   ULong64_t cint1b = 0;
 758   UShort_t nB=0;
 759   if (cint1bIndex!=-1) {
 760      cint1b=GetDeltaScaler(scalRec1, scalRec2, cint1bIndex, "l0b");
 761      const AliTriggerClass* cint1bClass = cfg->GetTriggerClass(cint1bIndex);
 762      AliTriggerBCMask* cint1bBCMask = new AliTriggerBCMask();
 763      if (cint1bClass) cint1bBCMask = (AliTriggerBCMask*)cint1bClass->GetBCMask();
 764      if (TString(cint1bBCMask->GetName()).CompareTo("NONE")!=0){
 765         nB = (UShort_t)cint1bBCMask->GetNUnmaskedBCs();
 766      }
 767   } else return kFALSE;
 768   ULong64_t cint1ac = 0;
 769   UShort_t nAC=0;
 770   if (cint1acIndex!=-1) {
 771      cint1ac=GetDeltaScaler(scalRec1, scalRec2, cint1acIndex, "l0b");
 772      AliTriggerClass* cint1acClass = cfg->GetTriggerClass(cint1acIndex);
 773      AliTriggerBCMask* cint1acBCMask = new AliTriggerBCMask();
 774      if (cint1acClass) cint1acBCMask = (AliTriggerBCMask*)cint1acClass->GetBCMask();
 775      if (TString(cint1acBCMask->GetName()).CompareTo("NONE")!=0){
 776         nAC = (UShort_t)cint1acBCMask->GetNUnmaskedBCs();
 777      }
 778   }
 779   ULong64_t cbeamb = 0;
 780   if (cbeambIndex!=-1) cbeamb=GetDeltaScaler(scalRec1, scalRec2, cbeambIndex, "l0b");
 781   UInt_t orbits = GetDeltaOrbits(scalRec1, scalRec2);
 782   //
 783   if (bkgCorr && (nB==0 || nAC==0 )) return kFALSE;
 784   //
 785   if (colBCsFromFillScheme) {
 786      if (CalculateMu(mu, errmu, cint1b, cint1ac, nB, nAC, orbits, bkgCorr, triggerEff, errorEff)) return kTRUE;
 787   }
 788   else {
 789      if (cint1b!=0 && cbeamb==0) return kFALSE;
 790      if (CalculateMu(mu, errmu, cint1b, cint1ac, cbeamb, nB, nAC, bkgCorr, triggerEff, errorEff)) return kTRUE;
 791   }
 792   //
 793   return kFALSE;
 794 }
 795 //_____________________________________________________________________________
 796 ULong64_t AliTriggerRunScalers::GetDeltaScalerForRun(Int_t classIndex, TString level)
 797 {
 798   if (fScalersRecordESD.GetEntriesFast()==0) {
 799      if (CorrectScalersOverflow()==1) return 0;
 800   }
 801   if (level != "l0b" && level != "l0a" && level != "l1b" && level != "l1a" && level != "l2b" && level != "l2a") return 0;
 802
 803   if (fScalersRecordESD.GetEntriesFast()>1) {
 804      const AliTriggerScalersRecordESD* scalRec1 = (AliTriggerScalersRecordESD*)fScalersRecordESD.At(0);
 805      const AliTriggerScalersRecordESD* scalRec2 = (AliTriggerScalersRecordESD*)fScalersRecordESD.At(fScalersRecordESD.GetEntriesFast()-1);
 806      return GetDeltaScaler(scalRec1, scalRec2, classIndex, level);
 807   }
 808   return 0;
 809 }
 810 //_____________________________________________________________________________
 811 Bool_t AliTriggerRunScalers::GetScalerRateForRun(Double_t &rate, Double_t &error, Int_t classIndex, TString level)
 812 {
 813   if (level != "l0b" && level != "l0a" && level != "l1b" && level != "l1a" && level != "l2b" && level != "l2a") return 0;
 814   if (fScalersRecordESD.GetEntriesFast()==0) {
 815      if (CorrectScalersOverflow()==1) return kFALSE;
 816   }
 817   if (fScalersRecordESD.GetEntriesFast()>=4) {
 818      const AliTriggerScalersRecordESD* scalRec1 = (AliTriggerScalersRecordESD*)fScalersRecordESD.At(0);
 819      const AliTriggerScalersRecordESD* scalRec2 = (AliTriggerScalersRecordESD*)fScalersRecordESD.At(fScalersRecordESD.GetEntriesFast()-1);
 820      if (GetScalerRate(rate, error, scalRec1, scalRec2, classIndex, level)) return kTRUE;
 821   }
 822   return kFALSE;
 823 }
 824 //_____________________________________________________________________________
 825 Bool_t AliTriggerRunScalers::GetClassL2L0ForRun(Double_t &l2l0, Double_t &error, Int_t classIndex)
 826 {
 827   if (fScalersRecordESD.GetEntriesFast()==0) {
 828      if (CorrectScalersOverflow()==1) return kFALSE;
 829   }
 830   if (fScalersRecordESD.GetEntriesFast()>=4) {
 831      const AliTriggerScalersRecordESD* scalRec1 = (AliTriggerScalersRecordESD*)fScalersRecordESD.At(0);
 832      const AliTriggerScalersRecordESD* scalRec2 = (AliTriggerScalersRecordESD*)fScalersRecordESD.At(fScalersRecordESD.GetEntriesFast()-1);  // Skip the first and last scaler readings for timing reasons
 833
 834      if ( GetClassL2L0(l2l0, error, scalRec1, scalRec2, classIndex)) return kTRUE;
 835   }
 836   return kFALSE;
 837 }
 838 //_____________________________________________________________________________
 839 TGraphErrors* AliTriggerRunScalers::GetGraphScalerRate(const char* className, TString level, AliTriggerConfiguration* cfg)
 840 {
 841   Int_t classIndex = cfg->GetClassIndexFromName(className);
 842   if (classIndex == -1) return 0;
 843   if (fScalersRecordESD.GetEntriesFast()==0) {
 844      if (CorrectScalersOverflow()==1) return 0;
 845   }
 846   if (level != "l0b" && level != "l0a" && level != "l1b" && level != "l1a" && level != "l2b" && level != "l2a") return 0;
 847   Int_t nent = fScalersRecordESD.GetEntriesFast();
 848   Double_t* time = new Double_t[nent];
 849   Double_t* etime = new Double_t[nent];
 850   Double_t* rate = new Double_t[nent];
 851   Double_t* erate = new Double_t[nent];
 852   for (Int_t i=0;i<nent-1;i++) {
 853      if (i>0) time[i] = time[i-1]+GetDeltaTime((AliTriggerScalersRecordESD*)fScalersRecordESD.At(i-1), (AliTriggerScalersRecordESD*)fScalersRecordESD.At(i))/2.+GetDeltaTime((AliTriggerScalersRecordESD*)fScalersRecordESD.At(i), (AliTriggerScalersRecordESD*)fScalersRecordESD.At(i+1))/2.;
 854      else time[0] = GetDeltaTime((AliTriggerScalersRecordESD*)fScalersRecordESD.At(0), (AliTriggerScalersRecordESD*)fScalersRecordESD.At(1))/2.;
 855      etime[i] = GetDeltaTime((AliTriggerScalersRecordESD*)fScalersRecordESD.At(i), (AliTriggerScalersRecordESD*)fScalersRecordESD.At(i+1))/2.;
 856      if (!GetScalerRate( rate[i], erate[i], (AliTriggerScalersRecordESD*)fScalersRecordESD.At(i), (AliTriggerScalersRecordESD*)fScalersRecordESD.At(i+1),  classIndex, level)) {rate[i]=-1; erate[i]=0.;}
 857   }
 858   TGraphErrors* graph = new TGraphErrors(nent-1, time, rate, etime, erate);
 859   return graph;
 860 }
 861 //_____________________________________________________________________________
 862 TGraphErrors* AliTriggerRunScalers::GetGraphScalerL2L0Ratio(const char* className, AliTriggerConfiguration* cfg)
 863 {
 864   Int_t classIndex = cfg->GetClassIndexFromName(className);
 865   if (classIndex == -1) return 0;
 866   if (fScalersRecordESD.GetEntriesFast()==0) {
 867      if (CorrectScalersOverflow()==1) return 0;
 868   }
 869   Int_t nent = fScalersRecordESD.GetEntriesFast();
 870   Double_t* time = new Double_t[nent];
 871   Double_t* etime = new Double_t[nent];
 872   Double_t* ratio = new Double_t[nent];
 873   Double_t* eratio = new Double_t[nent];
 874
 875   for (Int_t i=0;i<nent-1;i++) {
 876      if (i>0) time[i] = time[i-1]+GetDeltaTime((AliTriggerScalersRecordESD*)fScalersRecordESD.At(i-1), (AliTriggerScalersRecordESD*)fScalersRecordESD.At(i))/2.+GetDeltaTime((AliTriggerScalersRecordESD*)fScalersRecordESD.At(i), (AliTriggerScalersRecordESD*)fScalersRecordESD.At(i+1))/2.;
 877      else time[0] = GetDeltaTime((AliTriggerScalersRecordESD*)fScalersRecordESD.At(0), (AliTriggerScalersRecordESD*)fScalersRecordESD.At(1))/2.;
 878      etime[i] = GetDeltaTime((AliTriggerScalersRecordESD*)fScalersRecordESD.At(i), (AliTriggerScalersRecordESD*)fScalersRecordESD.At(i+1))/2.;
 879      if (!GetClassL2L0(ratio[i], eratio[i], (AliTriggerScalersRecordESD*)fScalersRecordESD.At(i), (AliTriggerScalersRecordESD*)fScalersRecordESD.At(i+1),  classIndex)) {ratio[i]=-1; eratio[i]=0.;}
 880   }
 881   TGraphErrors* graph = new TGraphErrors(nent-1, time, ratio, etime, eratio);
 882   return graph;
 883 }
 884 //_____________________________________________________________________________
 885 TGraphErrors* AliTriggerRunScalers::GetGraphMu(AliTriggerConfiguration* cfg, const char* className, Bool_t colBCsFromFillScheme, Bool_t bkgCorr, Double_t triggerEff, Double_t errorEff)
 886 {
 887   if (fScalersRecordESD.GetEntriesFast()==0) {
 888      if (CorrectScalersOverflow()==1) return 0;
 889   }
 890   Int_t nent = fScalersRecordESD.GetEntriesFast();
 891   Double_t* time = new Double_t[nent];
 892   Double_t* etime = new Double_t[nent];
 893   Double_t* mu = new Double_t[nent];
 894   Double_t* emu = new Double_t[nent];
 895
 896   for (Int_t i=0;i<nent-1;i++) {
 897      Double_t m=0.;
 898      Double_t err=0.;
 899      if (i!=0) time[i] = time[i-1]+GetDeltaTime((AliTriggerScalersRecordESD*)fScalersRecordESD.At(i-1), (AliTriggerScalersRecordESD*)fScalersRecordESD.At(i))/2.+GetDeltaTime((AliTriggerScalersRecordESD*)fScalersRecordESD.At(i), (AliTriggerScalersRecordESD*)fScalersRecordESD.At(i+1))/2.;
 900      else time[0] = GetDeltaTime((AliTriggerScalersRecordESD*)fScalersRecordESD.At(0), (AliTriggerScalersRecordESD*)fScalersRecordESD.At(1))/2.;
 901      etime[i] = GetDeltaTime((AliTriggerScalersRecordESD*)fScalersRecordESD.At(i), (AliTriggerScalersRecordESD*)fScalersRecordESD.At(i+1))/2.;
 902      if (GetMuFromClassScaler( m,err, className, (AliTriggerScalersRecordESD*)fScalersRecordESD.At(i), (AliTriggerScalersRecordESD*)fScalersRecordESD.At(i+1), cfg, colBCsFromFillScheme, bkgCorr, triggerEff, errorEff)!=kFALSE) {mu[i]=m; emu[i]=err;}
 903      else {mu[i]=-1.; emu[i]=0.;}
 904   }
 905   TGraphErrors* graph = new TGraphErrors(nent-1, time, mu, etime, emu);
 906   return graph;
 907 }
 908 //_____________________________________________________________________________
 909 void AliTriggerRunScalers::Print( const Option_t* ) const
 910 {
 911    // Print
 912   cout << "Trigger Scalers Record per Run: " << endl;
 913   cout << "  File version :" <<  fVersion << endl;
 914   cout << "  Run Number :" <<  fRunNumber << endl;
 915   cout << "  Number of Classes :" <<  (Int_t)fnClasses << endl;
 916   cout << "    Classes ID:";
 917   for( Int_t i=0; i<fnClasses; ++i )
 918     cout << "  " << (Int_t)fClassIndex[i];
 919   cout << endl;
 920
 921   for( Int_t i=0; i<fScalersRecord.GetEntriesFast(); ++i )
 922      ((AliTriggerScalersRecord*)fScalersRecord.At(i))->Print();
 923 }
 924