///////////////////////////////////////////////////////////////////////////////
//
// Class to define the ALICE Trigger Scalers Record per Run.
-//
+// ReadScalers(): read the txt file (rXXXX.cnt) provided by CTP and creates array of records.
+// ConsistencyCheck(): checks if the last scaler added to record is consistent,
+// i.e. time increases and valued are not decreasing in time.
+//
//
//////////////////////////////////////////////////////////////////////////////
#include <stdlib.h>
-
#include <Riostream.h>
-#include <TObject.h>
+
+//#include <TObject.h>
+//#include <TArrayC.h>
+//#include <TFile.h>
#include <TClass.h>
-#include <TArrayC.h>
#include <TSystem.h>
#include <TObjString.h>
#include <TObjArray.h>
-#include <TSystem.h>
-#include <TFile.h>
#include "AliLog.h"
#include "AliTimeStamp.h"
#include "AliTriggerScalers.h"
+#include "AliTriggerScalersESD.h"
#include "AliTriggerScalersRecord.h"
+#include "AliTriggerScalersRecordESD.h"
#include "AliTriggerRunScalers.h"
-#include "AliCDBEntry.h"
-#include "AliCDBManager.h"
-#include "AliCDBStorage.h"
ClassImp( AliTriggerRunScalers )
fRunNumber(0),
fnClasses(0),
fClassIndex(),
- fScalersRecord()
+ fScalersRecord(),
+ fScalersRecordESD()
{
// Default constructor
}
-
+//______________________________________________________________________________
+AliTriggerRunScalers::~AliTriggerRunScalers()
+{
+ // Destructor
+ fScalersRecord.SetOwner();
+ fScalersRecord.Delete();
+ fScalersRecordESD.SetOwner();
+ fScalersRecordESD.Delete();
+}
//_____________________________________________________________________________
void AliTriggerRunScalers::AddTriggerScalers( AliTriggerScalersRecord* scaler )
{
- //
+ // Add scaler and check consistency
fScalersRecord.AddLast( scaler );
- if (!AliTriggerRunScalers::ConsistencyCheck()) AliErrorClass("Trigger counters not in the right order or decreasing!");
-// fScalersRecord.Sort();
+ if (AliTriggerRunScalers::ConsistencyCheck(fScalersRecord.GetEntriesFast()-1,kFALSE)){
+ AliErrorClass("Trigger counters not in the right order or decreasing!");
+ // scaler->Print();
+ // fScalersRecord.Sort();
+ }
}
+//_____________________________________________________________________________
+AliTriggerRunScalers::AliTriggerRunScalers(const AliTriggerRunScalers &run) :
+ TObject(),
+ fVersion(run.fVersion),
+ fRunNumber(run.fRunNumber),
+ fnClasses(run.fnClasses),
+ fClassIndex(),
+ fScalersRecord(),
+ fScalersRecordESD()
+{
+// copy constructor
+ fClassIndex.Set(run.fClassIndex.GetSize());
+for (Int_t i = 0; i < run.fClassIndex.GetSize(); i++) {
+ if (run.fClassIndex[i]) fClassIndex.AddAt(run.fClassIndex[i], i);
+ }
+for (Int_t i = 0; i < run.fScalersRecord.GetEntriesFast(); i++) {
+ if (run.fScalersRecord[i]) fScalersRecord.Add(run.fScalersRecord[i]->Clone());
+ }
+for (Int_t i = 0; i < run.fScalersRecordESD.GetEntriesFast(); i++) {
+ if (run.fScalersRecordESD[i]) fScalersRecordESD.Add(run.fScalersRecordESD[i]->Clone());
+ }
+
+}
+//_____________________________________________________________________________
+AliTriggerRunScalers &AliTriggerRunScalers::operator=(const AliTriggerRunScalers& run)
+{
+// assignment operator
+if(&run == this) return *this;
+((TObject *)this)->operator=(run);
+
+fVersion = run.fVersion;
+fRunNumber = run.fRunNumber;
+fnClasses = run.fnClasses;
+
+for (Int_t i = 0; i < run.fClassIndex.GetSize(); i++) {
+ if (run.fClassIndex[i]) fClassIndex.AddAt(run.fClassIndex[i], i);
+ }
+for (Int_t i = 0; i < run.fScalersRecord.GetEntriesFast(); i++) {
+ if (run.fScalersRecord[i]) fScalersRecord.Add(run.fScalersRecord[i]->Clone());
+ }
+for (Int_t i = 0; i < run.fScalersRecordESD.GetEntriesFast(); i++) {
+ if (run.fScalersRecordESD[i]) fScalersRecordESD.Add(run.fScalersRecordESD[i]->Clone());
+ }
+return *this;
+}
//_____________________________________________________________________________
AliTriggerRunScalers* AliTriggerRunScalers::ReadScalers( TString & filename )
{
-
+ // Read scalers from text file(.cnt) provided by CTP
+ // for given run and convert it to root format
if( gSystem->AccessPathName( filename.Data() ) ) {
AliErrorClass( Form( "file (%s) not found", filename.Data() ) );
return NULL;
delete rec;
return rScaler;
}
- UInt_t LOCB = strtoul(((TObjString*)tokens1->At(0))->String(), NULL, 10);
- UInt_t LOCA = strtoul(((TObjString*)tokens1->At(1))->String(), NULL, 10);
- UInt_t L1CB = strtoul(((TObjString*)tokens1->At(2))->String(), NULL, 10);
- UInt_t L1CA = strtoul(((TObjString*)tokens1->At(3))->String(), NULL, 10);
- UInt_t L2CB = strtoul(((TObjString*)tokens1->At(4))->String(), NULL, 10);
- UInt_t L2CA = strtoul(((TObjString*)tokens1->At(5))->String(), NULL, 10);
+
+ UInt_t lOCB = strtoul(((TObjString*)tokens1->At(0))->String(), NULL, 10);
+ UInt_t lOCA = strtoul(((TObjString*)tokens1->At(1))->String(), NULL, 10);
+ UInt_t l1CB = strtoul(((TObjString*)tokens1->At(2))->String(), NULL, 10);
+ UInt_t l1CA = strtoul(((TObjString*)tokens1->At(3))->String(), NULL, 10);
+ UInt_t l2CB = strtoul(((TObjString*)tokens1->At(4))->String(), NULL, 10);
+ UInt_t l2CA = strtoul(((TObjString*)tokens1->At(5))->String(), NULL, 10);
rScaler->GetClass(i);
rec->AddTriggerScalers( rScaler->GetClass(i),
- LOCB, LOCA, L1CB,
- L1CA, L2CB, L2CA );
+ lOCB, lOCA, l1CB,
+ l1CA, l2CB, l2CA );
+
delete tokens1;
}
rScaler->AddTriggerScalers( rec );
}
//_____________________________________________________________________________
-Int_t AliTriggerRunScalers::FindNearestScalersRecord( AliTimeStamp * stamp )
+Int_t AliTriggerRunScalers::FindNearestScalersRecord( const AliTimeStamp *stamp ) const
{
// Find Trigger scaler record with the closest timestamp <= "stamp"
// using a binary search.
// is out of range return -1
Int_t base, position=-1, last, result = 0;
- AliTimeStamp *op2 = NULL;
+ Int_t op2 = 0;
- fScalersRecord.Sort();
+ //fScalersRecord.Sort();
base = 0;
last = fScalersRecord.GetEntriesFast();
while (last >= base) {
position = (base+last) / 2;
- cout << "pos " << position<< " base " << base << "last " << last << endl;
+ AliDebug(1, Form("position= %d base= %d last= %d ",position,base,last));
AliTriggerScalersRecord* rec = (AliTriggerScalersRecord*)fScalersRecord.At(position);
- if( rec ) op2 = rec->GetTimeStamp();
- if( op2 && (result = stamp->Compare(op2)) == 0 )
- return position; // exact match
- cout << "result " << result << " op2 " << op2 << " rec "<< rec << endl;
+ if( rec && rec->GetTimeStamp()) op2 = 1;
+ if( op2 && (result = stamp->Compare(rec->GetTimeStamp())) == 0 )
+ return position; // exact match
if (!op2 || result < 0)
last = position-1;
else
base = position+1;
- op2 = NULL;
+ op2 = 0;
}
if( (position == 0 && result < 0) || position >= fScalersRecord.GetEntriesFast() )
return -1; // out of range
return (result < 0 ) ? position-1 : position; // nearst < stamp
}
//_____________________________________________________________________________
-Bool_t AliTriggerRunScalers::ConsistencyCheck()
+Int_t AliTriggerRunScalers::ConsistencyCheck(Int_t position,Bool_t correctOverflow)
{
-
-UInt_t LOCB_2, LOCA_2, L1CB_2, L1CA_2, L2CB_2, L2CA_2, LOCB_1, LOCA_1, L1CB_1, L1CA_1, L2CB_1, L2CA_1;
-Bool_t increase0B=0, increase0A=0, increase1B=0, increase1A=0, increase2B=0, increase2A=0;
-Bool_t overflow0B=0, overflow0A=0, overflow1B=0, overflow1A=0, overflow2B=0, overflow2A=0;
-Int_t position = fScalersRecord.GetEntriesFast()-1;
-if (position == 0) return 1;
-
-AliTriggerScalersRecord* Scalers2 = (AliTriggerScalersRecord*)fScalersRecord.At(position);
-AliTriggerScalersRecord* Scalers1 = (AliTriggerScalersRecord*)fScalersRecord.At(position-1);
-if (Scalers2->Compare((AliTriggerScalersRecord*)fScalersRecord.At(position-1)) == -1) return 0;
-else for( Int_t i=0; i<fnClasses; ++i ){
-
-TObjArray* ScalersArray2 = (TObjArray*)Scalers2->GetTriggerScalers();
-AliTriggerScalers* counters2 = (AliTriggerScalers*)ScalersArray2->At(i);
- LOCB_2 = counters2->GetLOCB();
- LOCA_2 = counters2->GetLOCA();
- L1CB_2 = counters2->GetL1CB();
- L1CA_2 = counters2->GetL1CA();
- L2CB_2 = counters2->GetL2CB();
- L2CA_2 = counters2->GetL2CA();
-
-TObjArray* ScalersArray1 = (TObjArray*)Scalers1->GetTriggerScalers();
-AliTriggerScalers* counters1 = (AliTriggerScalers*)ScalersArray1->At(i);
- LOCB_1 = counters1->GetLOCB();
- LOCA_1 = counters1->GetLOCA();
- L1CB_1 = counters1->GetL1CB();
- L1CA_1 = counters1->GetL1CA();
- L2CB_1 = counters1->GetL2CB();
- L2CA_1 = counters1->GetL2CA();
-
-UInt_t const max1 = 4294967295ul; //32bit counters overflow after 4294967295
-UInt_t const max2 = 1000000000ul; //when counters overflow they seem to be decreasing. Assume decrease cannot be smaller than max2.
-
-if ( LOCB_2 > LOCB_1 ) increase0B=1;
-else if ( LOCB_2 < LOCB_1 && (LOCB_1 - LOCB_2) > max2) overflow0B=1;
-else return 0;
-
-if ( LOCA_2 > LOCA_1 ) increase0A=1;
-else if ( LOCA_2 < LOCA_1 && (LOCA_1 - LOCA_2) > max2) overflow0A=1;
-else return 0;
-
-if ( L1CB_2 > L1CB_1 ) increase1B=1;
-else if ( L1CB_2 < L1CB_1 && (L1CB_1 - L1CB_2) > max2) overflow1B=1;
-else return 0;
-
-if ( L1CA_2 > L1CA_1 ) increase1A=1;
-else if ( L1CA_2 < L1CA_1 && (L1CA_1 - L1CA_2) > max2) overflow1A=1;
-else return 0;
-
-if ( L2CB_2 > L2CB_1 ) increase2B=1;
-else if ( L2CB_2 < L2CB_1 && (L2CB_1 - L2CB_2) > max2) overflow2B=1;
-else return 0;
-
-if ( L2CA_2 > L2CA_1 ) increase2A=1;
-else if ( L2CA_2 < L2CA_1 && (L2CA_1 - L2CA_2) > max2) overflow2A=1;
-else return 0;
-
-
-if ( (LOCB_2 - LOCB_1) < (LOCA_2 - LOCA_1) && increase0B && increase0A ) return 0;
-else if ( (max1 - LOCB_1 + LOCB_2 ) < (LOCA_2 - LOCA_1) && overflow0B && increase0A ) return 0;
-else if ( (LOCB_2 - LOCB_1) < (max1 - LOCA_1 + LOCA_2) && increase0B && overflow0A ) return 0;
-else if ( (max1 - LOCB_1 + LOCB_2 ) < (max1 - LOCA_1 + LOCA_2) && overflow0B && overflow0A ) return 0;
-
-if ( (LOCA_2 - LOCA_1) < (L1CB_2 - L1CB_1) && increase0A && increase1B ) return 0;
-else if ( (max1 - LOCA_1 + LOCA_2 ) < (L1CB_2 - L1CB_1) && overflow0A && increase1B ) return 0;
-else if ( (LOCA_2 - LOCA_1) < (max1 - L1CB_1 + L1CB_2) && increase0A && overflow1B ) return 0;
-else if ( (max1 - LOCA_1 + LOCA_2 ) < (max1 - L1CB_1 + L1CB_2) && overflow0A && overflow1B ) return 0;
-
-if ( (L1CB_2 - L1CB_1) < (L1CA_2 - L1CA_1) && increase1B && increase1A ) return 0;
-else if ( (max1 - L1CB_1 + L1CB_2 ) < (L1CA_2 - L1CA_1) && overflow1B && increase1A ) return 0;
-else if ( (L1CB_2 - L1CB_1) < (max1 - L1CA_1 + L1CA_2) && increase1B && overflow1A ) return 0;
-else if ( (max1 - L1CB_1 + L1CB_2 ) < (max1 - L1CA_1 + L1CA_2) && overflow1B && overflow1A ) return 0;
-
-if ( (L1CA_2 - L1CA_1) < (L2CB_2 - L2CB_1) && increase1A && increase2B ) return 0;
-else if ( (max1 - L1CA_1 + L1CA_2 ) < (L2CB_2 - L2CB_1) && overflow1A && increase2B ) return 0;
-else if ( (L1CA_2 - L1CA_1) < (max1 - L2CB_1 + L2CB_2) && increase1A && overflow2B ) return 0;
-else if ( (max1 - L1CA_1 + L1CA_2 ) < (max1 - L2CB_1 + L2CB_2) && overflow1A && overflow2B ) return 0;
-
-if ( (L2CB_2 - L2CB_1) < (L2CA_2 - L2CA_1) && increase2B && increase2A ) return 0;
-else if ( (max1 - L2CB_1 + L2CB_2 ) < (L2CA_2 - L2CA_1) && overflow2B && increase2A ) return 0;
-else if ( (L2CB_2 - L2CB_1) < (max1 - L2CA_1 + L2CA_2) && increase2B && overflow2A ) return 0;
-else if ( (max1 - L2CB_1 + L2CB_2 ) < (max1 - L2CA_1 + L2CA_2) && overflow2B && overflow2A ) return 0;
-
+ //Check if counters are consistent(increase). Example: lOCB(n) < lOCB(n+1) and lOCB > lOCA
+ // scalers coding 0,1,2,3,4,5=0b,0a,1b,1a,2b,2a
+ // returns:
+ // 1 = decresing time
+ // 2 = too big jump in scalers, looks like some readings are missing
+ // 3 = (level+1) > (level)
+ if (position == 0){
+ if(correctOverflow){
+ AliErrorClass("position=0\n");
+ return 1;
+ }else return 0; // to work correctlu in AddScalers
+ };
+ UInt_t c2[6], c1[6];
+ ULong64_t c64[6];
+ Bool_t increase[6], overflow[6];
+ for(Int_t i=0;i<6;i++){increase[i]=0;overflow[i]=0;}
+ ULong64_t const max1 = 4294967295ul; //32bit counters overflow after 4294967295
+ ULong64_t const max2 = 1000000000ul; //when counters overflow they seem to be decreasing. Assume decrease cannot be smaller than max2.
+
+ AliTriggerScalersRecord* scalers2 = (AliTriggerScalersRecord*)fScalersRecord.At(position);
+ AliTriggerScalersRecord* scalers1 = (AliTriggerScalersRecord*)fScalersRecord.At(position-1);
+ if (scalers2->Compare((AliTriggerScalersRecord*)fScalersRecord.At(position-1)) == -1) return 1;
+
+ AliTriggerScalersRecordESD* recESD = 0;
+ if(correctOverflow){
+ recESD = new AliTriggerScalersRecordESD();
+ recESD->SetTimeStamp(scalers2->GetTimeStamp());
+ }
+ for( Int_t ic=0; ic<fnClasses; ++ic ){
+ TObjArray* scalersArray2 = (TObjArray*)scalers2->GetTriggerScalers();
+ AliTriggerScalers* counters2 = (AliTriggerScalers*)scalersArray2->At(ic);
+ counters2->GetAllScalers(c2);
+ TObjArray* scalersArray1 = (TObjArray*)scalers1->GetTriggerScalers();
+ AliTriggerScalers* counters1 = (AliTriggerScalers*)scalersArray1->At(ic);
+ counters1->GetAllScalers(c1);
+ for(Int_t i=0;i<5;i++){
+ if ( c2[i] >= c1[i] ) increase[i]=1;
+ else if ( c2[i] < c1[i] && (c1[i] - c2[i]) > max2) overflow[i]=1;
+ else return 2;
+ }
+ for(Int_t i=0;i<5;i++){
+ if ((c2[i] - c1[i]) < (c2[i+1] - c1[i+1]) && increase[i] && increase[i+1] ) {
+ if ( ((c2[i+1] - c1[i+1]) - (c2[i] - c1[i])) < 16 ) {AliWarningClass("Trigger scaler Level[i+1] > Level[i]. Diff < 16!");}
+ else return 3; }
+ else if ( (max1 - c1[i]+c2[i]) < (c2[i+1] - c1[i+1]) && overflow[i] && increase[i+1] ) {
+ if ( ((c2[i+1] - c1[i+1]) - (max1 - c1[i]+c2[i])) < 16 ) {AliWarningClass("Trigger scaler Level[i+1] > Level[i]. Diff < 16!");}
+ else return 3; }
+ else if ( (c2[i] - c1[i]) < (max1 - c1[i+1] + c2[i+1]) && increase[i] && overflow[i+1] ) {
+ if ( ((max1 - c1[i+1] + c2[i+1]) - (c2[i] - c1[i])) < 16 ) {AliWarningClass("Trigger scaler Level[i+1] > Level[i]. Diff < 16!");}
+ else return 3; }
+ else if ( (max1 - c1[i] + c2[i] ) < (max1 - c1[i+1] + c2[i+1]) && overflow[i] && overflow[i+1] ) {
+ if ( ((max1 - c1[i+1] + c2[i+1]) - (max1 - c1[i] + c2[i] )) < 16 ) {AliWarningClass("Trigger scaler Level[i+1] > Level[i]. Diff < 16!");}
+ else return 3; }
+ }
+ if(correctOverflow){
+ for(Int_t i=0;i<6;i++){ c64[i]=c2[i]+max1*overflow[i]; }
+ AliTriggerScalersESD* s= new AliTriggerScalersESD(fClassIndex[ic],c64);
+ recESD->AddTriggerScalers(s);
+ }
+
+ }
+ if(correctOverflow)fScalersRecordESD.AddLast(recESD);
+ return 0;
}
-
-return 1;
+//____________________________________________________________________________
+Int_t AliTriggerRunScalers::CorrectScalersOverflow()
+{
+ // Run over fScalersRecord, check overflow using CheckConsistency methos
+ // and save corrected result in fScalersRecordESD.
+
+ // Temporary fix for the OCDB entries written with v4-16-Release
+ // where the wrong sorting was used
+ fScalersRecord.Sort();
+ UInt_t c1[6];
+ ULong64_t c64[6];
+ AliTriggerScalersRecordESD* recESD = new AliTriggerScalersRecordESD();
+ // add 0
+ AliTriggerScalersRecord* scalers = (AliTriggerScalersRecord*)fScalersRecord.At(0);
+ for( Int_t ic=0; ic<fnClasses; ++ic ){
+ TObjArray* scalersArray = (TObjArray*)scalers->GetTriggerScalers();
+ AliTriggerScalers* counters = (AliTriggerScalers*)scalersArray->At(ic);
+ counters->GetAllScalers(c1);
+ for(Int_t i=0; i<6; i++)c64[i]=c1[i];
+ AliTriggerScalersESD* s= new AliTriggerScalersESD(fClassIndex[ic],c64);
+ recESD->AddTriggerScalers(s);
+ }
+ fScalersRecordESD.AddLast(recESD);
+ for(Int_t i=1;i<fScalersRecord.GetEntriesFast(); i++){
+ if(ConsistencyCheck(i,kTRUE)){
+ fScalersRecord.At(i)->Print();
+ fScalersRecord.At(i-1)->Print();
+ fScalersRecordESD.SetOwner();
+ fScalersRecordESD.Delete();
+ AliErrorClass("Inconsistent scalers, they will not be provided.\n");
+ return 1;
+ }
+ }
+ if(fScalersRecordESD.GetEntriesFast() != fScalersRecord.GetEntriesFast()){
+ AliErrorClass("Internal error: #scalers ESD != #scalers \n");
+ return 1;
+ }
+ return 0;
+}
+//_____________________________________________________________________________
+AliTriggerScalersESD* AliTriggerRunScalers::GetScalersForEventClass(const AliTimeStamp* stamp,const Int_t classIndex) const
+{
+ // Find scalers for event for class in fScalersRecordESD
+ // Assumes that fScalerRecord = fScalerRecordESD
+ Int_t position = FindNearestScalersRecord(stamp);
+ if ( position == -1 ) {
+ AliErrorClass("Event AliTimeStamp out of range!");
+ return 0;
+ }
+ // check also position=max
+ AliTriggerScalersRecordESD* scalrec1 = (AliTriggerScalersRecordESD*)fScalersRecordESD.At(position);
+ AliTriggerScalersRecordESD* scalrec2 = (AliTriggerScalersRecordESD*)fScalersRecordESD.At(position+1);
+ TObjArray* scalers1 = (TObjArray*)scalrec1->GetTriggerScalers();
+ TObjArray* scalers2 = (TObjArray*)scalrec2->GetTriggerScalers();
+
+ if(scalers1->GetEntriesFast() != fnClasses){
+ AliErrorClass("Internal error: #classes in RecordESD != fnClasses\n");
+ return 0;
+ }
+
+ AliTriggerScalersESD *s1,*s2;
+ for ( Int_t ic=0; ic < (Int_t)fnClasses; ++ic ){
+
+ s1 = (AliTriggerScalersESD*)scalers1->At(ic);
+ s2 = (AliTriggerScalersESD*)scalers2->At(ic);
+
+ Bool_t classfound = (s1->GetClassIndex() == classIndex) && (s2->GetClassIndex() == classIndex);
+ if(classfound){
+ ULong64_t max = 4294967295ul;
+ AliTriggerScalersRecordESD* scalrec0 = (AliTriggerScalersRecordESD*)fScalersRecordESD.At(0);
+ TObjArray* scalers0 = (TObjArray*)scalrec0->GetTriggerScalers();
+ AliTriggerScalersESD *s0 = (AliTriggerScalersESD*)scalers0->At(ic);
+ ULong64_t base[6],c1[6],c2[6],cint[6];
+ ULong64_t orbit = max*(stamp->GetPeriod()) + stamp->GetOrbit();
+ s0->GetAllScalers(base);
+ s1->GetAllScalers(c1);
+ s2->GetAllScalers(c2);
+ ULong64_t orbit1 = max*(scalrec1->GetTimeStamp()->GetPeriod())+scalrec1->GetTimeStamp()->GetOrbit();
+ ULong64_t orbit2 = max*(scalrec2->GetTimeStamp()->GetPeriod())+scalrec2->GetTimeStamp()->GetOrbit();
+ for(Int_t i=0;i<6;i++){
+ Double_t slope=Double_t(c2[i]-c1[i])/Double_t(orbit2-orbit1);
+ cint[i]=ULong64_t(slope*(orbit-orbit1)) +c1[i] -base[i];
+ }
+ AliTriggerScalersESD* result = new AliTriggerScalersESD(classIndex,cint);
+ return result;
+ }
+ }
+ AliErrorClass(Form("Classindex %i not found.\n",classIndex));
+ return 0;
}
//_____________________________________________________________________________
void AliTriggerRunScalers::Print( const Option_t* ) const
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff