]> git.uio.no Git - u/mrichter/AliRoot.git/blob - STEER/AliTriggerRunScalers.cxx
Additional comment.
[u/mrichter/AliRoot.git] / 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) { 
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     rec->SetTimeStamp( orbit, period, seconds, microSecs );
223     TString strLine1;
224     for (Int_t i=0; i<nclass; ++i) {
225       strLine1.ReadLine(*file);
226       if (strLine1.BeginsWith("#")) continue;
227       TObjArray *tokens1 = strLine1.Tokenize(" \t");
228       Int_t ntokens1 = tokens1->GetEntriesFast();
229       if( ntokens1 != 6 ) {
230         AliErrorClass( Form( "Error reading scalers from (%s): line (%s)", 
231                              filename.Data(), strLine1.Data() ));
232         delete rec;
233         return rScaler;
234       }
235
236       UInt_t lOCB = strtoul(((TObjString*)tokens1->At(0))->String(), NULL, 10);
237       UInt_t lOCA = strtoul(((TObjString*)tokens1->At(1))->String(), NULL, 10);
238       UInt_t l1CB = strtoul(((TObjString*)tokens1->At(2))->String(), NULL, 10);
239       UInt_t l1CA = strtoul(((TObjString*)tokens1->At(3))->String(), NULL, 10);
240       UInt_t l2CB = strtoul(((TObjString*)tokens1->At(4))->String(), NULL, 10);
241       UInt_t l2CA = strtoul(((TObjString*)tokens1->At(5))->String(), NULL, 10);
242
243       rScaler->GetClass(i);
244       rec->AddTriggerScalers( rScaler->GetClass(i),
245                               lOCB, lOCA, l1CB,
246                               l1CA, l2CB, l2CA );
247
248       delete tokens1;
249     } 
250     rScaler->AddTriggerScalers( rec );
251     
252     delete tokens;     
253   }
254   file->close();
255   delete file;
256
257   return  rScaler; 
258 }
259   
260 //_____________________________________________________________________________
261 Int_t  AliTriggerRunScalers::FindNearestScalersRecord( const AliTimeStamp *stamp ) const
262 {
263    // Find Trigger scaler record with the closest timestamp <= "stamp"
264    // using a binary search. 
265    // return the index in the array of records, if the timestamp 
266    // is out of range return -1
267
268    Int_t   base, position=-1, last, result = 0;
269    Int_t op2 = 0;
270    
271    //fScalersRecord.Sort();
272
273    base = 0;
274    last = fScalersRecord.GetEntriesFast();
275
276    while (last >= base) {
277       position = (base+last) / 2;
278       AliDebug(1, Form("position= %d   base= %d    last= %d  ",position,base,last));
279       AliTriggerScalersRecord* rec = (AliTriggerScalersRecord*)fScalersRecord.At(position);
280       if( rec && rec->GetTimeStamp()) op2 = 1;
281       if( op2 && (result = stamp->Compare(rec->GetTimeStamp())) == 0  )
282          return position;  // exact match 
283       if (!op2 || result < 0)
284          last = position-1;
285       else
286          base = position+1;
287       op2 = 0;  
288    }
289    if( (position == 0 && result < 0) || position >= fScalersRecord.GetEntriesFast() ) 
290     return -1;  // out of range
291    else 
292     return (result < 0 ) ? position-1 : position; // nearst < stamp   
293 }
294 //_____________________________________________________________________________
295 Int_t AliTriggerRunScalers::ConsistencyCheck(Int_t position,Bool_t correctOverflow, UInt_t** overflow)
296 {
297    //Check if counters are consistent(increase). Example: lOCB(n) < lOCB(n+1) and lOCB > lOCA
298    // scalers coding 0,1,2,3,4,5=0b,0a,1b,1a,2b,2a
299    // returns: 
300    //         1 = decresing time 
301    //         2 = too big jump in scalers, looks like some readings are missing
302    //         3 = (level+1) > (level)
303    if (position == 0){
304       if(correctOverflow){
305         AliErrorClass("position=0\n");
306         return 1;
307       }else return 0; // to work correctly in AddScalers
308    };
309    UInt_t c2[6], c1[6];
310    ULong64_t c64[6]; 
311    Bool_t increase[6];  
312    for(Int_t i=0;i<6;i++){increase[i]=0;}
313    ULong64_t const max1 = 4294967295ul;  //32bit counters overflow after 4294967295
314    ULong64_t const max2 = 1000000000ul;  //when counters overflow they seem to be decreasing. Assume decrease cannot be smaller than max2.
315
316    AliTriggerScalersRecord* scalers2 = (AliTriggerScalersRecord*)fScalersRecord.At(position);
317    AliTriggerScalersRecord* scalers1 = (AliTriggerScalersRecord*)fScalersRecord.At(position-1);
318    if (scalers2->Compare((AliTriggerScalersRecord*)fScalersRecord.At(position-1)) == -1) return 1;
319    
320    AliTriggerScalersRecordESD* recESD = 0;
321    if(correctOverflow){
322      recESD = new AliTriggerScalersRecordESD();
323      recESD->SetTimeStamp(scalers2->GetTimeStamp());
324    }
325    for( Int_t ic=0; ic<fnClasses; ++ic ){
326       TObjArray* scalersArray2 = (TObjArray*)scalers2->GetTriggerScalers();
327       AliTriggerScalers* counters2 = (AliTriggerScalers*)scalersArray2->At(ic);
328       UChar_t iclass = counters2->GetClassIndex();
329       counters2->GetAllScalers(c2);
330       TObjArray* scalersArray1 = (TObjArray*)scalers1->GetTriggerScalers();
331       AliTriggerScalers* counters1 = (AliTriggerScalers*)scalersArray1->At(ic);
332       counters1->GetAllScalers(c1);
333       for(Int_t i=0;i<5;i++){
334          if ( c2[i] >= c1[i] ) increase[i]=1;
335          else if ( c2[i] < c1[i] && (c1[i] - c2[i]) > max2) overflow[i][ic]++;
336          else return 2;
337       }
338       for(Int_t i=0;i<5;i++){
339          if ((c2[i] - c1[i]) < (c2[i+1] - c1[i+1]) && increase[i] && increase[i+1] ) {
340                  if ( ((c2[i+1] - c1[i+1]) - (c2[i] - c1[i])) < 16 ) {AliWarningClass("Trigger scaler Level[i+1] > Level[i]. Diff < 16!");}
341                  else return 3; }
342          else if ( (max1 - c1[i]+c2[i]) < (c2[i+1] - c1[i+1]) && overflow[i][ic] && increase[i+1] ) {
343                  if ( ((c2[i+1] - c1[i+1]) - (max1 - c1[i]+c2[i])) < 16 ) {AliWarningClass("Trigger scaler Level[i+1] > Level[i]. Diff < 16!");}
344                  else return 3; }
345          else if ( (c2[i] - c1[i]) < (max1 - c1[i+1] + c2[i+1]) && increase[i] && overflow[i+1][ic] ) {
346                  if ( ((max1 - c1[i+1] + c2[i+1]) - (c2[i] - c1[i])) < 16 ) {AliWarningClass("Trigger scaler Level[i+1] > Level[i]. Diff < 16!");}
347                  else return 3; }
348          else if ( (max1 - c1[i] + c2[i] ) < (max1 - c1[i+1] + c2[i+1]) && overflow[i][ic] && overflow[i+1][ic] ) {
349                  if ( ((max1 - c1[i+1] + c2[i+1]) - (max1 - c1[i] + c2[i] )) < 16 ) {AliWarningClass("Trigger scaler Level[i+1] > Level[i]. Diff < 16!");}
350                  else return 3; }
351       }
352       if(correctOverflow){ 
353         for(Int_t i=0;i<6;i++){ c64[i]=c2[i]+max1*overflow[i][ic]; }
354         AliTriggerScalersESD* s= new AliTriggerScalersESD(iclass,c64);
355         recESD->AddTriggerScalers(s);
356          }
357
358  }
359  if(correctOverflow)fScalersRecordESD.AddLast(recESD);
360  return 0;
361 }
362 //____________________________________________________________________________
363 Int_t AliTriggerRunScalers::CorrectScalersOverflow()
364 {
365  // Run over fScalersRecord, check overflow using CheckConsistency methos
366  // and save corrected result in fScalersRecordESD.
367
368  // Temporary fix for the OCDB entries written with v4-16-Release
369  // where the wrong sorting was used
370  fScalersRecord.Sort();
371  UInt_t c1[6];
372  ULong64_t c64[6];
373  AliTriggerScalersRecordESD* recESD = new AliTriggerScalersRecordESD();
374  // add 0
375  AliTriggerScalersRecord* scalers = (AliTriggerScalersRecord*)fScalersRecord.At(0);
376  recESD->SetTimeStamp(scalers->GetTimeStamp());
377  for( Int_t ic=0; ic<fnClasses; ++ic ){
378     TObjArray* scalersArray = (TObjArray*)scalers->GetTriggerScalers();
379     AliTriggerScalers* counters = (AliTriggerScalers*)scalersArray->At(ic);
380     counters->GetAllScalers(c1);
381     UChar_t iclass = counters->GetClassIndex();
382     for(Int_t i=0; i<6; i++)c64[i]=c1[i];
383     AliTriggerScalersESD* s= new AliTriggerScalersESD(iclass,c64);
384     recESD->AddTriggerScalers(s);
385  }
386  fScalersRecordESD.AddLast(recESD);
387
388  UInt_t* overflow[6];
389  for(Int_t i=0; i<6; i++) {
390     overflow[i] = new UInt_t[fnClasses];
391     for(Int_t j=0; j<fnClasses; j++) overflow[i][j] = 0;
392  }
393
394  for(Int_t i=1;i<fScalersRecord.GetEntriesFast(); i++){
395   if(ConsistencyCheck(i,kTRUE,overflow)){
396     fScalersRecord.At(i)->Print();
397     fScalersRecord.At(i-1)->Print();
398     fScalersRecordESD.SetOwner(); 
399     fScalersRecordESD.Delete(); 
400     AliErrorClass("Inconsistent scalers, they will not be provided.\n");
401     return 1;
402   }
403  }
404  if(fScalersRecordESD.GetEntriesFast() != fScalersRecord.GetEntriesFast()){
405     AliErrorClass("Internal error: #scalers ESD != #scalers \n");
406     return 1;
407  }
408  return 0;
409 }
410 //_____________________________________________________________________________
411 AliTriggerScalersESD* AliTriggerRunScalers::GetScalersForEventClass(const AliTimeStamp* stamp,const Int_t classIndex) const
412 {
413  // Find scalers for event for class in fScalersRecordESD
414  // Assumes that fScalerRecord = fScalerRecordESD
415  Int_t position = FindNearestScalersRecord(stamp);
416  if ( position == -1 ) { 
417   AliErrorClass("Event AliTimeStamp out of range!");
418   return 0; 
419  }
420  // check also position=max
421  AliTriggerScalersRecordESD* scalrec1 = (AliTriggerScalersRecordESD*)fScalersRecordESD.At(position);
422  AliTriggerScalersRecordESD* scalrec2 = (AliTriggerScalersRecordESD*)fScalersRecordESD.At(position+1);
423  TObjArray* scalers1 = (TObjArray*)scalrec1->GetTriggerScalers();
424  TObjArray* scalers2 = (TObjArray*)scalrec2->GetTriggerScalers();
425
426  if(scalers1->GetEntriesFast() != fnClasses){
427   AliErrorClass("Internal error: #classes in RecordESD != fnClasses\n");
428   return 0; 
429  }
430
431  AliTriggerScalersESD *s1,*s2;
432  for ( Int_t ic=0; ic < (Int_t)fnClasses; ++ic ){
433
434       s1 = (AliTriggerScalersESD*)scalers1->At(ic);
435       s2 = (AliTriggerScalersESD*)scalers2->At(ic);
436
437       Bool_t classfound = (s1->GetClassIndex() == classIndex) && (s2->GetClassIndex() == classIndex);
438       if(classfound){
439         ULong64_t max = 16777216ul;
440         AliTriggerScalersRecordESD* scalrec0 = (AliTriggerScalersRecordESD*)fScalersRecordESD.At(0);
441         TObjArray* scalers0 = (TObjArray*)scalrec0->GetTriggerScalers();
442         AliTriggerScalersESD *s0 = (AliTriggerScalersESD*)scalers0->At(ic);
443         ULong64_t base[6],c1[6],c2[6],cint[6];
444         ULong64_t orbit = max*(stamp->GetPeriod()) + stamp->GetOrbit();
445         s0->GetAllScalers(base);
446         s1->GetAllScalers(c1);
447         s2->GetAllScalers(c2);
448         ULong64_t orbit1 = max*(scalrec1->GetTimeStamp()->GetPeriod())+scalrec1->GetTimeStamp()->GetOrbit();
449         ULong64_t orbit2 = max*(scalrec2->GetTimeStamp()->GetPeriod())+scalrec2->GetTimeStamp()->GetOrbit();
450         for(Int_t i=0;i<6;i++){
451            Double_t slope=Double_t(c2[i]-c1[i])/Double_t(orbit2-orbit1);
452            cint[i]=ULong64_t(slope*(orbit-orbit1)) +c1[i] -base[i];
453         }
454         AliTriggerScalersESD* result = new AliTriggerScalersESD(classIndex,cint);
455         return result;
456       }
457  }
458  AliErrorClass(Form("Classindex %i not found.\n",classIndex));
459  return 0;
460 }
461
462 //_____________________________________________________________________________
463 const AliTriggerScalersRecordESD* AliTriggerRunScalers::GetScalersDeltaForEvent(const AliTimeStamp* stamp) const
464 {
465  // Find scalers for event for class in fScalersRecordESD
466  // Assumes that fScalerRecord = fScalerRecordESD
467  Int_t position = FindNearestScalersRecord(stamp);
468  if ( position == -1 ) { 
469   AliErrorClass("Event AliTimeStamp out of range!");
470   return 0; 
471  }
472  // check also position=max
473  AliTriggerScalersRecordESD* scalrec1 = (AliTriggerScalersRecordESD*)fScalersRecordESD.At(position);
474  AliTriggerScalersRecordESD* scalrec2 = (AliTriggerScalersRecordESD*)fScalersRecordESD.At(position+1);
475  TObjArray* scalers1 = (TObjArray*)scalrec1->GetTriggerScalers();
476  TObjArray* scalers2 = (TObjArray*)scalrec2->GetTriggerScalers();
477
478  if(scalers1->GetEntriesFast() != fnClasses){
479   AliErrorClass("Internal error: #classes in RecordESD != fnClasses\n");
480   return 0; 
481  }
482  AliTriggerScalersRecordESD *scalrec = new AliTriggerScalersRecordESD();
483  AliTriggerScalersESD *s1,*s2;
484  for ( Int_t ic=0; ic < (Int_t)fnClasses; ++ic ){
485
486   s1 = (AliTriggerScalersESD*)scalers1->At(ic);
487   s2 = (AliTriggerScalersESD*)scalers2->At(ic);
488
489   ULong64_t c1[6],c2[6],cint[6];
490   s1->GetAllScalers(c1);
491   s2->GetAllScalers(c2);
492   for(Int_t i=0;i<6;i++){
493      cint[i]=c2[i]-c1[i];
494   }
495   AliTriggerScalersESD* result = new AliTriggerScalersESD(s1->GetClassIndex(),cint);
496   scalrec->AddTriggerScalers(result);
497  }
498  UInt_t max = 16777216ul;
499  UInt_t orbit, period;
500  
501  if (scalrec2->GetTimeStamp()->GetOrbit() > scalrec1->GetTimeStamp()->GetOrbit()) {
502   orbit = scalrec2->GetTimeStamp()->GetOrbit() - scalrec1->GetTimeStamp()->GetOrbit();
503   period = scalrec2->GetTimeStamp()->GetPeriod() - scalrec1->GetTimeStamp()->GetPeriod();
504  }
505  else {
506   orbit = max - (scalrec1->GetTimeStamp()->GetOrbit() - scalrec2->GetTimeStamp()->GetOrbit());
507   period = scalrec2->GetTimeStamp()->GetPeriod() - scalrec1->GetTimeStamp()->GetPeriod() - 1;
508  }
509  
510  AliTimeStamp *timestamp = new AliTimeStamp(orbit, period, 0);
511  scalrec->SetTimeStamp(timestamp);
512  delete timestamp;
513  return scalrec;
514 }
515 //_____________________________________________________________________________
516 const AliTriggerScalersRecordESD* AliTriggerRunScalers::GetScalersDeltaForRun() const
517 {
518  // Find scalers for event for class in fScalersRecordESD
519  // Assumes that fScalerRecord = fScalerRecordESD
520  AliTriggerScalersRecordESD* scalrec1 = (AliTriggerScalersRecordESD*)fScalersRecordESD.At(0);
521  AliTriggerScalersRecordESD* scalrec2 = (AliTriggerScalersRecordESD*)fScalersRecordESD.At(fScalersRecord.GetEntriesFast()-1);
522  TObjArray* scalers1 = (TObjArray*)scalrec1->GetTriggerScalers();
523  TObjArray* scalers2 = (TObjArray*)scalrec2->GetTriggerScalers();
524
525  if(scalers1->GetEntriesFast() != fnClasses){
526   AliErrorClass("Internal error: #classes in RecordESD != fnClasses\n");
527   return 0; 
528  }
529  AliTriggerScalersESD *s1,*s2;
530  AliTriggerScalersRecordESD *scalrec = new AliTriggerScalersRecordESD();
531  for ( Int_t ic=0; ic < (Int_t)fnClasses; ++ic ){
532
533   s1 = (AliTriggerScalersESD*)scalers1->At(ic);
534   s2 = (AliTriggerScalersESD*)scalers2->At(ic);
535
536   ULong64_t c1[6],c2[6],cint[6];
537   s1->GetAllScalers(c1);
538   s2->GetAllScalers(c2);
539   for(Int_t i=0;i<6;i++){
540      cint[i]=c2[i]-c1[i];
541   }
542   AliTriggerScalersESD* result = new AliTriggerScalersESD(s1->GetClassIndex(),cint);
543   scalrec->AddTriggerScalers(result);
544  }
545  UInt_t max = 16777216ul;
546  UInt_t orbit, period;
547  
548  if (scalrec2->GetTimeStamp()->GetOrbit() > scalrec1->GetTimeStamp()->GetOrbit()) {
549   orbit = scalrec2->GetTimeStamp()->GetOrbit() - scalrec1->GetTimeStamp()->GetOrbit();
550   period = scalrec2->GetTimeStamp()->GetPeriod() - scalrec1->GetTimeStamp()->GetPeriod();
551  }
552  else {
553   orbit = max - (scalrec1->GetTimeStamp()->GetOrbit() - scalrec2->GetTimeStamp()->GetOrbit());
554   period = scalrec2->GetTimeStamp()->GetPeriod() - scalrec1->GetTimeStamp()->GetPeriod() - 1;
555  }
556  
557  AliTimeStamp *timestamp = new AliTimeStamp(orbit, period, 0);
558  scalrec->SetTimeStamp(timestamp);
559  delete timestamp;
560  return scalrec;
561 }
562 //_____________________________________________________________________________
563 Double_t AliTriggerRunScalers::CalculateMu(ULong64_t countsB, ULong64_t countsAC, ULong64_t countsE, UShort_t nB, UShort_t nAC, UShort_t nE, UInt_t orbits, Bool_t bkgCorr, Double_t triggerEff) 
564 {
565  
566    if (nB!=0 && orbits!=0)  {
567       ULong64_t beamB = (ULong64_t)orbits*nB;
568       if (!bkgCorr || nAC==0 || nE==0) return (log(beamB) - log(beamB-countsB))/triggerEff;
569       else 
570       {
571          Double_t noBG = (2.*countsAC/nAC - countsE/nE)/orbits;  // noBG = exp(-muBG)
572          if (noBG<0.) noBG = (Double_t)(countsE/nE)/orbits;
573          return (log(beamB) + log(1-noBG) - log(beamB-countsB))/triggerEff;
574       }
575    }
576    return 0.;
577 }
578 //_____________________________________________________________________________
579 Double_t AliTriggerRunScalers::CalculateMu(ULong64_t countsB, ULong64_t countsAC, ULong64_t countsE, ULong64_t beamB, UShort_t nB, UShort_t nAC, UShort_t nE, Bool_t bkgCorr, Double_t triggerEff) 
580 {
581
582    if (beamB!=0)  {
583       if (!bkgCorr || nAC==0 || nE==0 || nB==0) return (log(beamB) - log(beamB-countsB))/triggerEff;
584       else 
585       {
586          Double_t noBG = (2.*countsAC/nAC - countsE/nE)/(beamB/nB);  // noBG = exp(-muBG)
587          if (noBG<0.) noBG = (Double_t)(countsE/nE)/(beamB/nB);
588          return (log(beamB) + log(1-noBG) - log(beamB-countsB))/triggerEff;
589       }
590    }
591    return 0.;
592 }
593 //_____________________________________________________________________________
594 Double_t AliTriggerRunScalers::CalculateMuError(/*ULong64_t countsB, ULong64_t countsAC, ULong64_t countsE, UShort_t nB, UShort_t nAC, UShort_t nE, UInt_t orbits, Bool_t bkgCorr, Double_t triggerEff, Double_t errorEff*/) 
595
596    // method for mu error to be added
597    return 0.;
598 }
599 //_____________________________________________________________________________
600 /*Double_t AliTriggerRunScalers::CalculateMuError(ULong64_t countsB, ULong64_t countsAC, ULong64_t countsE, ULong64_t beamB, UShort_t nB, UShort_t nAC, UShort_t nE, Bool_t bkgCorr, Double_t triggerEff, Double_t errorEff) 
601 {
602    // method for mu error to be added
603    return 0.;
604 }*/
605 //_____________________________________________________________________________
606 ULong64_t AliTriggerRunScalers::GetDeltaScaler(const AliTriggerScalersRecordESD* scalRec1, const AliTriggerScalersRecordESD* scalRec2, Int_t classIndex, Int_t level)
607 {
608   // level=0 -> L0CB, 1->L0CA, 2->L1CB, 3->L1CA, 4->L2CB, 5->L2CA
609   if (level < 0 || level > 5) return 0;
610   
611   const AliTriggerScalersESD* scalers1 = scalRec1->GetTriggerScalersForClass(classIndex);
612   const AliTriggerScalersESD* scalers2 = scalRec2->GetTriggerScalersForClass(classIndex);
613   ULong64_t s1=0;
614   ULong64_t s2=0;
615   if (level==0) {s1=scalers1->GetLOCB(); s2=scalers2->GetLOCB();}
616   if (level==1) {s1=scalers1->GetLOCA(); s2=scalers2->GetLOCA();}
617   if (level==2) {s1=scalers1->GetL1CB(); s2=scalers2->GetL1CB();}
618   if (level==3) {s1=scalers1->GetL1CA(); s2=scalers2->GetL1CA();}
619   if (level==4) {s1=scalers1->GetL2CB(); s2=scalers2->GetL2CB();}
620   if (level==5) {s1=scalers1->GetL2CA(); s2=scalers2->GetL2CA();}
621   return s2-s1;
622 }
623 //_____________________________________________________________________________
624 Double_t AliTriggerRunScalers::GetDeltaTime(const AliTriggerScalersRecordESD* scalRec1, const AliTriggerScalersRecordESD* scalRec2)
625 {
626   const AliTimeStamp* stamp1 = scalRec1->GetTimeStamp();
627   const AliTimeStamp* stamp2 = scalRec2->GetTimeStamp();
628   UInt_t orbit1 = stamp1->GetOrbit();
629   UInt_t orbit2 = stamp2->GetOrbit();
630   UInt_t period1 = stamp1->GetPeriod();
631   UInt_t period2 = stamp2->GetPeriod();
632   UInt_t max = 16777216;  // The period counter increases when 24 bit orbit counter overflow
633   Double_t orbitSec = 89.1*1.e-6; // Length of 1 orbit in seconds
634   return ((period2 - period1)*max + (orbit2-orbit1))*orbitSec;
635 }
636 //_____________________________________________________________________________
637 UInt_t AliTriggerRunScalers::GetDeltaOrbits(const AliTriggerScalersRecordESD* scalRec1, const AliTriggerScalersRecordESD* scalRec2)
638 {
639   const AliTimeStamp* stamp1 = scalRec1->GetTimeStamp();
640   const AliTimeStamp* stamp2 = scalRec2->GetTimeStamp();
641   UInt_t orbit1 = stamp1->GetOrbit();
642   UInt_t orbit2 = stamp2->GetOrbit();
643   UInt_t period1 = stamp1->GetPeriod();
644   UInt_t period2 = stamp2->GetPeriod();
645   UInt_t max = 16777216;  // The period counter increases when 24 bit orbit counter overflow
646   return (period2 - period1)*max + (orbit2-orbit1);
647 }
648 //_____________________________________________________________________________
649 Double_t AliTriggerRunScalers::GetScalerRate(const AliTriggerScalersRecordESD* scalRec1, const AliTriggerScalersRecordESD* scalRec2, Int_t classIndex, Int_t level)
650 {
651   // level=0 -> L0CB, 1->L0CA, 2->L1CB, 3->L1CA, 4->L2CB, 5->L2CA
652   if (level < 0 || level > 5) return 0;
653  
654   ULong64_t scaler = GetDeltaScaler(scalRec1, scalRec2, classIndex, level);
655   Double_t time = GetDeltaTime(scalRec1, scalRec2 );
656   if (time==0.) return 0.;
657   return (Double_t)scaler/time;
658 }
659 //_____________________________________________________________________________
660 Double_t AliTriggerRunScalers::GetScalerRateError(const AliTriggerScalersRecordESD* scalRec1, const AliTriggerScalersRecordESD* scalRec2, Int_t classIndex, Int_t level)
661 {
662   // level=0 -> L0CB, 1->L0CA, 2->L1CB, 3->L1CA, 4->L2CB, 5->L2CA
663   if (level < 0 || level > 5) return 0;
664   ULong64_t scaler = GetDeltaScaler(scalRec1, scalRec2, classIndex, level);
665   Double_t time = GetDeltaTime(scalRec1, scalRec2 );
666   if (time!=0.) return (Double_t)sqrt(scaler)/time;
667   return 0.;
668 }
669 //_____________________________________________________________________________
670 Double_t AliTriggerRunScalers::GetClassL2L0(const AliTriggerScalersRecordESD* scalRec1, const AliTriggerScalersRecordESD* scalRec2, Int_t classIndex)
671 {
672   ULong64_t l0 = GetDeltaScaler(scalRec1, scalRec2, classIndex, 0);
673   ULong64_t l2 = GetDeltaScaler(scalRec1, scalRec2, classIndex, 5);
674   if (l0!=0) return l2/l0;
675   return 0.;
676 }
677 //_____________________________________________________________________________
678 Double_t AliTriggerRunScalers::GetClassL2L0Error(const AliTriggerScalersRecordESD* scalRec1, const AliTriggerScalersRecordESD* scalRec2, Int_t classIndex)
679 {
680   ULong64_t l0 = GetDeltaScaler(scalRec1, scalRec2, classIndex, 0);
681   ULong64_t l2 = GetDeltaScaler(scalRec1, scalRec2, classIndex, 5);
682   if (l0 > 0) return (Double_t)sqrt(l2-l2*l2/l0)/l0;
683   return 0.;
684 }
685 //_____________________________________________________________________________
686 Bool_t AliTriggerRunScalers::GetMuFromMinBiasTrg(Double_t &mu, Double_t &muerr, const AliTriggerScalersRecordESD* scalRec1, const AliTriggerScalersRecordESD* scalRec2, AliTriggerConfiguration* cfg, Bool_t colBCsFromFillScheme, Bool_t bkgCorr, Double_t triggerEff/*, Double_t errorEff*/)
687 {
688   // colBCsFromFillScheme=kTRUE - use filling scheme and orbit counter
689   // colBCsFromFillScheme=kFALSE - use cbeamb scaler to get number of colliding BCs
690   // One can also switch background correction ON or OFF with bkgCorr
691   TObjArray cint1bNames;
692   cint1bNames.Add(new TNamed("CINT1B-ABCE-NOPF-ALL",NULL));
693   cint1bNames.Add(new TNamed("CINT1-B-NOPF-ALLNOTRD",NULL));
694   cint1bNames.Add(new TNamed("CINT1-B-NOPF-ALL",NULL));
695   Int_t cint1bIndex=-1;
696   for (Int_t i=0; i<cint1bNames.GetEntriesFast(); i++ ) {
697      if (cfg->GetClassIndexFromName(cint1bNames.At(i)->GetName()) != -1) cint1bIndex = cfg->GetClassIndexFromName(cint1bNames.At(i)->GetName());
698   }
699   //
700   TObjArray cint1aNames;
701   cint1aNames.Add(new TNamed("CINT1A-ABCE-NOPF-ALL",NULL));
702   cint1aNames.Add(new TNamed("CINT1-A-NOPF-ALLNOTRD",NULL));
703   cint1aNames.Add(new TNamed("CINT1-A-NOPF-ALL",NULL));
704   Int_t cint1aIndex=-1;
705   for (Int_t i=0; i<cint1aNames.GetEntriesFast(); i++ ) {
706      if (cfg->GetClassIndexFromName(cint1aNames.At(i)->GetName()) != -1) cint1aIndex = cfg->GetClassIndexFromName(cint1aNames.At(i)->GetName());
707   }
708   //
709   TObjArray cint1cNames;
710   cint1cNames.Add(new TNamed("CINT1C-ABCE-NOPF-ALL",NULL));
711   cint1cNames.Add(new TNamed("CINT1-C-NOPF-ALLNOTRD",NULL));
712   cint1cNames.Add(new TNamed("CINT1-C-NOPF-ALL",NULL));
713   Int_t cint1cIndex=-1;
714   for (Int_t i=0; i<cint1cNames.GetEntriesFast(); i++ ) {
715      if (cfg->GetClassIndexFromName(cint1cNames.At(i)->GetName()) != -1) cint1cIndex = cfg->GetClassIndexFromName(cint1cNames.At(i)->GetName());
716   }
717   //
718   TObjArray cint1acNames;
719   cint1acNames.Add(new TNamed("CINT1-AC-NOPF-ALLNOTRD",NULL));
720   cint1acNames.Add(new TNamed("CINT1-AC-NOPF-ALL",NULL));
721   Int_t cint1acIndex=-1;
722   for (Int_t i=0; i<cint1acNames.GetEntriesFast(); i++ ) {
723      if (cfg->GetClassIndexFromName(cint1acNames.At(i)->GetName()) != -1) cint1acIndex = cfg->GetClassIndexFromName(cint1acNames.At(i)->GetName());
724   }
725   //
726   TObjArray cint1eNames;
727   cint1eNames.Add(new TNamed("CINT1E-ABCE-NOPF-ALL",NULL));
728   cint1eNames.Add(new TNamed("CINT1-E-NOPF-ALLNOTRD",NULL));
729   cint1eNames.Add(new TNamed("CINT1-E-NOPF-ALL",NULL));
730   Int_t cint1eIndex=-1;
731   for (Int_t i=0; i<cint1eNames.GetEntriesFast(); i++ ) {
732      if (cfg->GetClassIndexFromName(cint1eNames.At(i)->GetName()) != -1) cint1eIndex = cfg->GetClassIndexFromName(cint1eNames.At(i)->GetName());
733   }
734   //
735   TObjArray cbeambNames;
736   cbeambNames.Add(new TNamed("CBEAMB-ABCE-NOPF-ALL",NULL));
737   cbeambNames.Add(new TNamed("CBEAMB-B-NOPF-ALLNOTRD",NULL));
738   cbeambNames.Add(new TNamed("CBEAMB-B-NOPF-ALL",NULL));
739   cbeambNames.Add(new TNamed("CTRUE-B-NOPF-ALL",NULL));
740   Int_t cbeambIndex=-1;
741   for (Int_t i=0; i<cbeambNames.GetEntriesFast(); i++ ) {
742      if (cfg->GetClassIndexFromName(cbeambNames.At(i)->GetName()) != -1) cbeambIndex = cfg->GetClassIndexFromName(cbeambNames.At(i)->GetName());
743   }
744   //
745   ULong64_t cint1b = 0;
746   UShort_t nB=0;
747   if (cint1bIndex!=-1) {
748      cint1b=GetDeltaScaler(scalRec1, scalRec2, cint1bIndex, 0);
749      const AliTriggerClass* cint1bClass = cfg->GetTriggerClass(cint1bIndex);
750      AliTriggerBCMask* cint1bBCMask = new AliTriggerBCMask();
751      if (cint1bClass) cint1bBCMask = (AliTriggerBCMask*)cint1bClass->GetBCMask();
752      if (TString(cint1bBCMask->GetName()).CompareTo("NONE")!=0){
753         nB = (UShort_t)cint1bBCMask->GetNUnmaskedBCs();
754      }
755   } else return kFALSE;
756   ULong64_t cint1ac = 0;
757   UShort_t nAC=0;
758   if (cint1acIndex!=-1) {
759      cint1ac=GetDeltaScaler(scalRec1, scalRec2, cint1acIndex, 0);
760      AliTriggerClass* cint1acClass = cfg->GetTriggerClass(cint1acIndex);
761      AliTriggerBCMask* cint1acBCMask = new AliTriggerBCMask();
762      if (cint1acClass) cint1acBCMask = (AliTriggerBCMask*)cint1acClass->GetBCMask();
763      if (TString(cint1acBCMask->GetName()).CompareTo("NONE")!=0){
764         nAC = (UShort_t)cint1acBCMask->GetNUnmaskedBCs();
765      }
766   }
767   ULong64_t cint1e = 0;
768   UShort_t nE=0;
769   if (cint1eIndex!=-1) {
770      cint1e=GetDeltaScaler(scalRec1, scalRec2, cint1eIndex, 0);
771      AliTriggerClass* cint1eClass = cfg->GetTriggerClass(cint1eIndex);
772      AliTriggerBCMask* cint1eBCMask = new AliTriggerBCMask();
773      if (cint1eClass) cint1eBCMask = (AliTriggerBCMask*)cint1eClass->GetBCMask();
774      if (TString(cint1eBCMask->GetName()).CompareTo("NONE")!=0){
775         nE = (UShort_t)cint1eBCMask->GetNUnmaskedBCs();
776      }
777   }
778   ULong64_t cbeamb = 0;
779   if (cbeambIndex!=-1) cbeamb=GetDeltaScaler(scalRec1, scalRec2, cbeambIndex, 0);
780   UInt_t orbits = GetDeltaOrbits(scalRec1, scalRec2);
781   //
782   if (bkgCorr && (nB==0 || nAC==0 || nE==0 )) return kFALSE;
783   //
784   if (colBCsFromFillScheme) {
785      mu = CalculateMu(cint1b, cint1ac, cint1e, nB, nAC, nE, orbits, bkgCorr, triggerEff);
786      muerr = CalculateMuError(/*cint1b, cint1ac, cint1e, nB, nAC, nE, orbits, bkgCorr, triggerEff, errorEff*/);
787   }
788   else {
789      if (cint1b!=0 && cbeamb==0) return kFALSE;
790      mu = CalculateMu(cint1b, cint1ac, cint1e, cbeamb, nB, nAC, nE, bkgCorr, triggerEff);
791      muerr = CalculateMuError(/*cint1b, cint1ac, cint1e, cbeamb, nB, nAC, nE, bkgCorr, triggerEff, errorEff*/);
792   }
793   //
794   return kTRUE;
795 }
796 //_____________________________________________________________________________
797 ULong64_t AliTriggerRunScalers::GetDeltaScalerForRun(Int_t classIndex, Int_t level)
798 {
799   if (fScalersRecordESD.GetEntriesFast()==0) {
800      if (CorrectScalersOverflow()==1) return 0;
801   }
802   // level=0 -> L0CB, 1->L0CA, 2->L1CB, 3->L1CA, 4->L2CB, 5->L2CA
803   if (level < 0 || level > 5) return 0;
804   if (fScalersRecordESD.GetEntriesFast()>1) { 
805      const AliTriggerScalersRecordESD* scalRec1 = (AliTriggerScalersRecordESD*)fScalersRecordESD.At(0);
806      const AliTriggerScalersRecordESD* scalRec2 = (AliTriggerScalersRecordESD*)fScalersRecordESD.At(fScalersRecordESD.GetEntriesFast()-1);
807      return GetDeltaScaler(scalRec1, scalRec2, classIndex, level);
808   }
809   return 0;
810 }
811 //_____________________________________________________________________________
812 Double_t AliTriggerRunScalers::GetScalerRateForRun(Int_t classIndex, Int_t level)
813 {
814   // level=0 -> L0CB, 1->L0CA, 2->L1CB, 3->L1CA, 4->L2CB, 5->L2CA
815   if (fScalersRecordESD.GetEntriesFast()==0) {
816      if (CorrectScalersOverflow()==1) return 0;
817   }
818   if (fScalersRecordESD.GetEntriesFast()>=4) {
819      if (level < 0 || level > 5) return 0;
820      const AliTriggerScalersRecordESD* scalRec1 = (AliTriggerScalersRecordESD*)fScalersRecordESD.At(0);
821      const AliTriggerScalersRecordESD* scalRec2 = (AliTriggerScalersRecordESD*)fScalersRecordESD.At(fScalersRecordESD.GetEntriesFast()-1);
822      return GetScalerRate(scalRec1, scalRec2, classIndex, level);
823   }
824   return 0;
825 }
826 //_____________________________________________________________________________
827 Double_t AliTriggerRunScalers::GetClassL2L0ForRun(Int_t classIndex)
828 {
829   if (fScalersRecordESD.GetEntriesFast()==0) {
830      if (CorrectScalersOverflow()==1) return 0;
831   }
832   if (fScalersRecordESD.GetEntriesFast()>=4) {
833      const AliTriggerScalersRecordESD* scalRec1 = (AliTriggerScalersRecordESD*)fScalersRecordESD.At(0);
834      const AliTriggerScalersRecordESD* scalRec2 = (AliTriggerScalersRecordESD*)fScalersRecordESD.At(fScalersRecordESD.GetEntriesFast()-1);  // Skip the first and last scaler readings for timing reasons
835      return GetClassL2L0(scalRec1, scalRec2, classIndex);
836   }
837   return 0;
838 }
839 //_____________________________________________________________________________
840 TGraphErrors* AliTriggerRunScalers::GetGraphScalerRate(const char* className, Int_t level, AliTriggerConfiguration* cfg)
841 {
842   Int_t classIndex = cfg->GetClassIndexFromName(className);
843   if (classIndex == -1) return 0;
844   if (fScalersRecordESD.GetEntriesFast()==0) {
845      if (CorrectScalersOverflow()==1) return 0;
846   }
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      rate[i] = GetScalerRate((AliTriggerScalersRecordESD*)fScalersRecordESD.At(i), (AliTriggerScalersRecordESD*)fScalersRecordESD.At(i+1),  classIndex, level);
857      erate[i] = GetScalerRateError((AliTriggerScalersRecordESD*)fScalersRecordESD.At(i), (AliTriggerScalersRecordESD*)fScalersRecordESD.At(i+1),  classIndex, level);
858   }
859   TGraphErrors* graph = new TGraphErrors(nent-1, time, rate, etime, erate);  
860   return graph;
861 }
862 //_____________________________________________________________________________
863 TGraphErrors* AliTriggerRunScalers::GetGraphScalerL2L0Ratio(const char* className, AliTriggerConfiguration* cfg)
864 {
865   Int_t classIndex = cfg->GetClassIndexFromName(className);
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     ratio[i] = GetClassL2L0((AliTriggerScalersRecordESD*)fScalersRecordESD.At(i), (AliTriggerScalersRecordESD*)fScalersRecordESD.At(i+1),  classIndex);
880     eratio[i] = GetClassL2L0Error((AliTriggerScalersRecordESD*)fScalersRecordESD.At(i), (AliTriggerScalersRecordESD*)fScalersRecordESD.At(i+1),  classIndex);
881   }
882   TGraphErrors* graph = new TGraphErrors(nent-1, time, ratio, etime, eratio);  
883   return graph;
884 }
885 //_____________________________________________________________________________
886 TGraphErrors* AliTriggerRunScalers::GetGraphMu(AliTriggerConfiguration* cfg, Bool_t colBCsFromFillScheme, Bool_t bkgCorr, Double_t triggerEff/*, Double_t errorEff*/)
887 {
888   if (fScalersRecordESD.GetEntriesFast()==0) {
889      if (CorrectScalersOverflow()==1) return 0;
890   }
891   Int_t nent = fScalersRecordESD.GetEntriesFast();
892   Double_t* time = new Double_t[nent];
893   Double_t* etime = new Double_t[nent];
894   Double_t* mu = new Double_t[nent];
895   Double_t* emu = new Double_t[nent];
896   
897   for (Int_t i=0;i<nent-1;i++) {
898      Double_t m=0.;
899      Double_t err=0.;
900      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.;
901      else time[0] = GetDeltaTime((AliTriggerScalersRecordESD*)fScalersRecordESD.At(0), (AliTriggerScalersRecordESD*)fScalersRecordESD.At(1))/2.;
902      etime[i] = GetDeltaTime((AliTriggerScalersRecordESD*)fScalersRecordESD.At(i), (AliTriggerScalersRecordESD*)fScalersRecordESD.At(i+1))/2.;
903      if (GetMuFromMinBiasTrg( m,err, (AliTriggerScalersRecordESD*)fScalersRecordESD.At(i), (AliTriggerScalersRecordESD*)fScalersRecordESD.At(i+1), cfg, colBCsFromFillScheme, bkgCorr, triggerEff/*, errorEff*/)!=kFALSE) {mu[i]=m; emu[i]=err;}
904      else {mu[i]=-1.; emu[i]=0.;}
905   }
906   TGraphErrors* graph = new TGraphErrors(nent-1, time, mu, etime, emu);  
907   return graph;
908 }
909 //_____________________________________________________________________________
910 void AliTriggerRunScalers::Print( const Option_t* ) const
911 {
912    // Print
913   cout << "Trigger Scalers Record per Run: " << endl;
914   cout << "  File version :" <<  fVersion << endl;            
915   cout << "  Run Number :" <<  fRunNumber << endl;          
916   cout << "  Number of Classes :" <<  (Int_t)fnClasses << endl;          
917   cout << "    Classes ID:";
918   for( Int_t i=0; i<fnClasses; ++i ) 
919     cout << "  " << (Int_t)fClassIndex[i];       
920   cout << endl; 
921     
922   for( Int_t i=0; i<fScalersRecord.GetEntriesFast(); ++i ) 
923      ((AliTriggerScalersRecord*)fScalersRecord.At(i))->Print();
924 }
925