]> git.uio.no Git - u/mrichter/AliRoot.git/blame - STEER/AliTriggerRunScalers.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Update VZERO reco in order to deal with high lumi data. Weighted mean on V0 A and...
[u/mrichter/AliRoot.git] / STEER / AliTriggerRunScalers.cxx
CommitLineData
e39e51f6 1/**************************************************************************
d7dd8a54 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.
d07a9211 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//
d7dd8a54 25//
26//////////////////////////////////////////////////////////////////////////////
27
c180f65d 28#include <stdlib.h>
d7dd8a54 29#include <Riostream.h>
d07a9211 30
31//#include <TObject.h>
32//#include <TArrayC.h>
33//#include <TFile.h>
d7dd8a54 34#include <TClass.h>
d7dd8a54 35#include <TSystem.h>
36#include <TObjString.h>
37#include <TObjArray.h>
7f66b913 38#include <TMath.h>
39#include <TGraphErrors.h>
d7dd8a54 40
41#include "AliLog.h"
42#include "AliTimeStamp.h"
43#include "AliTriggerScalers.h"
6441c2a8 44#include "AliTriggerScalersESD.h"
d7dd8a54 45#include "AliTriggerScalersRecord.h"
6441c2a8 46#include "AliTriggerScalersRecordESD.h"
d7dd8a54 47#include "AliTriggerRunScalers.h"
7f66b913 48#include "AliTriggerConfiguration.h"
49#include "AliTriggerClass.h"
50#include "AliTriggerBCMask.h"
d7dd8a54 51
52ClassImp( AliTriggerRunScalers )
53
54//_____________________________________________________________________________
55AliTriggerRunScalers::AliTriggerRunScalers():
56 TObject(),
57 fVersion(0),
58 fRunNumber(0),
59 fnClasses(0),
60 fClassIndex(),
bf7443cc 61 fScalersRecord(),
62 fScalersRecordESD()
d7dd8a54 63{
64 // Default constructor
65}
7eaf72df 66//______________________________________________________________________________
67AliTriggerRunScalers::~AliTriggerRunScalers()
68{
69 // Destructor
70 fScalersRecord.SetOwner();
71 fScalersRecord.Delete();
72 fScalersRecordESD.SetOwner();
73 fScalersRecordESD.Delete();
74}
d7dd8a54 75//_____________________________________________________________________________
76void AliTriggerRunScalers::AddTriggerScalers( AliTriggerScalersRecord* scaler )
77{
d07a9211 78 // Add scaler and check consistency
e39e51f6 79 fScalersRecord.AddLast( scaler );
74135182 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)){
a93ccff3 86 AliErrorClass("Trigger counters not in the right order or decreasing!");
87 // scaler->Print();
88 // fScalersRecord.Sort();
89 }
d7dd8a54 90}
bf7443cc 91//_____________________________________________________________________________
92
93AliTriggerRunScalers::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
f379aa89 103 fClassIndex.Set(run.fClassIndex.GetSize());
bf7443cc 104for (Int_t i = 0; i < run.fClassIndex.GetSize(); i++) {
105 if (run.fClassIndex[i]) fClassIndex.AddAt(run.fClassIndex[i], i);
106 }
107for (Int_t i = 0; i < run.fScalersRecord.GetEntriesFast(); i++) {
108 if (run.fScalersRecord[i]) fScalersRecord.Add(run.fScalersRecord[i]->Clone());
109 }
110for (Int_t i = 0; i < run.fScalersRecordESD.GetEntriesFast(); i++) {
111 if (run.fScalersRecordESD[i]) fScalersRecordESD.Add(run.fScalersRecordESD[i]->Clone());
112 }
113
114}
115//_____________________________________________________________________________
116AliTriggerRunScalers &AliTriggerRunScalers::operator=(const AliTriggerRunScalers& run)
117{
118// assignment operator
119if(&run == this) return *this;
120((TObject *)this)->operator=(run);
121
122fVersion = run.fVersion;
123fRunNumber = run.fRunNumber;
124fnClasses = run.fnClasses;
d7dd8a54 125
bf7443cc 126for (Int_t i = 0; i < run.fClassIndex.GetSize(); i++) {
127 if (run.fClassIndex[i]) fClassIndex.AddAt(run.fClassIndex[i], i);
128 }
129for (Int_t i = 0; i < run.fScalersRecord.GetEntriesFast(); i++) {
130 if (run.fScalersRecord[i]) fScalersRecord.Add(run.fScalersRecord[i]->Clone());
131 }
132for (Int_t i = 0; i < run.fScalersRecordESD.GetEntriesFast(); i++) {
133 if (run.fScalersRecordESD[i]) fScalersRecordESD.Add(run.fScalersRecordESD[i]->Clone());
134 }
135return *this;
136}
d7dd8a54 137//_____________________________________________________________________________
138AliTriggerRunScalers* AliTriggerRunScalers::ReadScalers( TString & filename )
139{
d07a9211 140 // Read scalers from text file(.cnt) provided by CTP
141 // for given run and convert it to root format
d7dd8a54 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 }
e39e51f6 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
d7dd8a54 221 AliTriggerScalersRecord * rec = new AliTriggerScalersRecord();
222 rec->SetTimeStamp( orbit, period, seconds, microSecs );
d7dd8a54 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 ) {
29bdda4f 230 AliErrorClass( Form( "Error reading scalers from (%s): line (%s)",
231 filename.Data(), strLine1.Data() ));
232 delete rec;
233 return rScaler;
d7dd8a54 234 }
d5aaf775 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);
e39e51f6 242
d7dd8a54 243 rScaler->GetClass(i);
244 rec->AddTriggerScalers( rScaler->GetClass(i),
d5aaf775 245 lOCB, lOCA, l1CB,
246 l1CA, l2CB, l2CA );
247
d7dd8a54 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//_____________________________________________________________________________
033d0f8e 261Int_t AliTriggerRunScalers::FindNearestScalersRecord( const AliTimeStamp *stamp ) const
d7dd8a54 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;
5dd39685 269 Int_t op2 = 0;
d7dd8a54 270
033d0f8e 271 //fScalersRecord.Sort();
d7dd8a54 272
273 base = 0;
274 last = fScalersRecord.GetEntriesFast();
275
276 while (last >= base) {
277 position = (base+last) / 2;
767e5649 278 AliDebug(1, Form("position= %d base= %d last= %d ",position,base,last));
d7dd8a54 279 AliTriggerScalersRecord* rec = (AliTriggerScalersRecord*)fScalersRecord.At(position);
5dd39685 280 if( rec && rec->GetTimeStamp()) op2 = 1;
281 if( op2 && (result = stamp->Compare(rec->GetTimeStamp())) == 0 )
0367cade 282 return position; // exact match
d7dd8a54 283 if (!op2 || result < 0)
284 last = position-1;
285 else
286 base = position+1;
5dd39685 287 op2 = 0;
d7dd8a54 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}
e39e51f6 294//_____________________________________________________________________________
74135182 295Int_t AliTriggerRunScalers::ConsistencyCheck(Int_t position,Bool_t correctOverflow, UInt_t** overflow)
e39e51f6 296{
d07a9211 297 //Check if counters are consistent(increase). Example: lOCB(n) < lOCB(n+1) and lOCB > lOCA
6441c2a8 298 // scalers coding 0,1,2,3,4,5=0b,0a,1b,1a,2b,2a
47fde2cb 299 // returns:
300 // 1 = decresing time
301 // 2 = too big jump in scalers, looks like some readings are missing
302 // 3 = (level+1) > (level)
6441c2a8 303 if (position == 0){
a93ccff3 304 if(correctOverflow){
305 AliErrorClass("position=0\n");
306 return 1;
7f66b913 307 }else return 0; // to work correctly in AddScalers
a93ccff3 308 };
47fde2cb 309 UInt_t c2[6], c1[6];
6441c2a8 310 ULong64_t c64[6];
74135182 311 Bool_t increase[6];
312 for(Int_t i=0;i<6;i++){increase[i]=0;}
6441c2a8 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.
d07a9211 315
316 AliTriggerScalersRecord* scalers2 = (AliTriggerScalersRecord*)fScalersRecord.At(position);
317 AliTriggerScalersRecord* scalers1 = (AliTriggerScalersRecord*)fScalersRecord.At(position-1);
47fde2cb 318 if (scalers2->Compare((AliTriggerScalersRecord*)fScalersRecord.At(position-1)) == -1) return 1;
6441c2a8 319
320 AliTriggerScalersRecordESD* recESD = 0;
321 if(correctOverflow){
322 recESD = new AliTriggerScalersRecordESD();
268381f3 323 recESD->SetTimeStamp(scalers2->GetTimeStamp());
d07a9211 324 }
6441c2a8 325 for( Int_t ic=0; ic<fnClasses; ++ic ){
326 TObjArray* scalersArray2 = (TObjArray*)scalers2->GetTriggerScalers();
327 AliTriggerScalers* counters2 = (AliTriggerScalers*)scalersArray2->At(ic);
d9db8747 328 UChar_t iclass = counters2->GetClassIndex();
6441c2a8 329 counters2->GetAllScalers(c2);
330 TObjArray* scalersArray1 = (TObjArray*)scalers1->GetTriggerScalers();
331 AliTriggerScalers* counters1 = (AliTriggerScalers*)scalersArray1->At(ic);
332 counters1->GetAllScalers(c1);
a93ccff3 333 for(Int_t i=0;i<5;i++){
334 if ( c2[i] >= c1[i] ) increase[i]=1;
74135182 335 else if ( c2[i] < c1[i] && (c1[i] - c2[i]) > max2) overflow[i][ic]++;
6441c2a8 336 else return 2;
337 }
338 for(Int_t i=0;i<5;i++){
a93ccff3 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; }
74135182 342 else if ( (max1 - c1[i]+c2[i]) < (c2[i+1] - c1[i+1]) && overflow[i][ic] && increase[i+1] ) {
a93ccff3 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; }
74135182 345 else if ( (c2[i] - c1[i]) < (max1 - c1[i+1] + c2[i+1]) && increase[i] && overflow[i+1][ic] ) {
a93ccff3 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; }
74135182 348 else if ( (max1 - c1[i] + c2[i] ) < (max1 - c1[i+1] + c2[i+1]) && overflow[i][ic] && overflow[i+1][ic] ) {
a93ccff3 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; }
6441c2a8 351 }
a93ccff3 352 if(correctOverflow){
74135182 353 for(Int_t i=0;i<6;i++){ c64[i]=c2[i]+max1*overflow[i][ic]; }
d9db8747 354 AliTriggerScalersESD* s= new AliTriggerScalersESD(iclass,c64);
6441c2a8 355 recESD->AddTriggerScalers(s);
a93ccff3 356 }
357
6441c2a8 358 }
359 if(correctOverflow)fScalersRecordESD.AddLast(recESD);
360 return 0;
361}
362//____________________________________________________________________________
363Int_t AliTriggerRunScalers::CorrectScalersOverflow()
364{
365 // Run over fScalersRecord, check overflow using CheckConsistency methos
366 // and save corrected result in fScalersRecordESD.
ab26241b 367
368 // Temporary fix for the OCDB entries written with v4-16-Release
369 // where the wrong sorting was used
370 fScalersRecord.Sort();
6441c2a8 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);
7f66b913 376 recESD->SetTimeStamp(scalers->GetTimeStamp());
6441c2a8 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);
d9db8747 381 UChar_t iclass = counters->GetClassIndex();
6441c2a8 382 for(Int_t i=0; i<6; i++)c64[i]=c1[i];
d9db8747 383 AliTriggerScalersESD* s= new AliTriggerScalersESD(iclass,c64);
6441c2a8 384 recESD->AddTriggerScalers(s);
385 }
386 fScalersRecordESD.AddLast(recESD);
74135182 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
6441c2a8 394 for(Int_t i=1;i<fScalersRecord.GetEntriesFast(); i++){
74135182 395 if(ConsistencyCheck(i,kTRUE,overflow)){
a93ccff3 396 fScalersRecord.At(i)->Print();
397 fScalersRecord.At(i-1)->Print();
6441c2a8 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//_____________________________________________________________________________
411AliTriggerScalersESD* 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();
0367cade 425
6441c2a8 426 if(scalers1->GetEntriesFast() != fnClasses){
427 AliErrorClass("Internal error: #classes in RecordESD != fnClasses\n");
428 return 0;
429 }
a93ccff3 430
6441c2a8 431 AliTriggerScalersESD *s1,*s2;
a93ccff3 432 for ( Int_t ic=0; ic < (Int_t)fnClasses; ++ic ){
433
6441c2a8 434 s1 = (AliTriggerScalersESD*)scalers1->At(ic);
435 s2 = (AliTriggerScalersESD*)scalers2->At(ic);
a93ccff3 436
6441c2a8 437 Bool_t classfound = (s1->GetClassIndex() == classIndex) && (s2->GetClassIndex() == classIndex);
438 if(classfound){
7f66b913 439 ULong64_t max = 16777216ul;
6441c2a8 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 }
47fde2cb 457 }
6441c2a8 458 AliErrorClass(Form("Classindex %i not found.\n",classIndex));
47fde2cb 459 return 0;
e39e51f6 460}
7f66b913 461
462//_____________________________________________________________________________
463const 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//_____________________________________________________________________________
516const 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//_____________________________________________________________________________
563Double_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//_____________________________________________________________________________
579Double_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//_____________________________________________________________________________
2696a238 594Double_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*/)
7f66b913 595{
2696a238 596 // method for mu error to be added
7f66b913 597 return 0.;
598}
599//_____________________________________________________________________________
2696a238 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)
7f66b913 601{
2696a238 602 // method for mu error to be added
7f66b913 603 return 0.;
2696a238 604}*/
7f66b913 605//_____________________________________________________________________________
606ULong64_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
2696a238 609 if (level < 0 || level > 5) return 0;
7f66b913 610
611 const AliTriggerScalersESD* scalers1 = scalRec1->GetTriggerScalersForClass(classIndex);
612 const AliTriggerScalersESD* scalers2 = scalRec2->GetTriggerScalersForClass(classIndex);
2696a238 613 ULong64_t s1=0;
614 ULong64_t s2=0;
7f66b913 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//_____________________________________________________________________________
624Double_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//_____________________________________________________________________________
637UInt_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//_____________________________________________________________________________
649Double_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
2696a238 652 if (level < 0 || level > 5) return 0;
653
7f66b913 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//_____________________________________________________________________________
660Double_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
2696a238 663 if (level < 0 || level > 5) return 0;
7f66b913 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//_____________________________________________________________________________
670Double_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//_____________________________________________________________________________
678Double_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//_____________________________________________________________________________
2696a238 686Bool_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*/)
7f66b913 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));
2696a238 740 Int_t cbeambIndex=-1;
7f66b913 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);
2696a238 750 AliTriggerBCMask* cint1bBCMask = new AliTriggerBCMask();
7f66b913 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);
2696a238 761 AliTriggerBCMask* cint1acBCMask = new AliTriggerBCMask();
7f66b913 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);
2696a238 772 AliTriggerBCMask* cint1eBCMask = new AliTriggerBCMask();
7f66b913 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);
2696a238 786 muerr = CalculateMuError(/*cint1b, cint1ac, cint1e, nB, nAC, nE, orbits, bkgCorr, triggerEff, errorEff*/);
7f66b913 787 }
788 else {
789 if (cint1b!=0 && cbeamb==0) return kFALSE;
790 mu = CalculateMu(cint1b, cint1ac, cint1e, cbeamb, nB, nAC, nE, bkgCorr, triggerEff);
2696a238 791 muerr = CalculateMuError(/*cint1b, cint1ac, cint1e, cbeamb, nB, nAC, nE, bkgCorr, triggerEff, errorEff*/);
7f66b913 792 }
793 //
794 return kTRUE;
795}
796//_____________________________________________________________________________
797ULong64_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
2696a238 803 if (level < 0 || level > 5) return 0;
7f66b913 804 if (fScalersRecordESD.GetEntriesFast()>1) {
805 const AliTriggerScalersRecordESD* scalRec1 = (AliTriggerScalersRecordESD*)fScalersRecordESD.At(0);
806 const AliTriggerScalersRecordESD* scalRec2 = (AliTriggerScalersRecordESD*)fScalersRecordESD.At(fScalersRecordESD.GetEntriesFast()-1);
7f66b913 807 return GetDeltaScaler(scalRec1, scalRec2, classIndex, level);
808 }
809 return 0;
810}
811//_____________________________________________________________________________
812Double_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) {
2696a238 819 if (level < 0 || level > 5) return 0;
7f66b913 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//_____________________________________________________________________________
827Double_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//_____________________________________________________________________________
840TGraphErrors* 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//_____________________________________________________________________________
863TGraphErrors* 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];
7f66b913 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//_____________________________________________________________________________
2696a238 886TGraphErrors* AliTriggerRunScalers::GetGraphMu(AliTriggerConfiguration* cfg, Bool_t colBCsFromFillScheme, Bool_t bkgCorr, Double_t triggerEff/*, Double_t errorEff*/)
7f66b913 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.;
2696a238 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;}
7f66b913 904 else {mu[i]=-1.; emu[i]=0.;}
905 }
906 TGraphErrors* graph = new TGraphErrors(nent-1, time, mu, etime, emu);
907 return graph;
908}
d7dd8a54 909//_____________________________________________________________________________
910void 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