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