{
// Add scaler and check consistency
fScalersRecord.AddLast( scaler );
- if (AliTriggerRunScalers::ConsistencyCheck(fScalersRecord.GetEntriesFast()-1,kFALSE)) AliErrorClass("Trigger counters not in the right order or decreasing!");
-// fScalersRecord.Sort();
+ UInt_t* overflow[6];
+ for(Int_t i=0; i<6; i++) {
+ overflow[i] = new UInt_t[fnClasses];
+ for(Int_t j=0; j<fnClasses; j++) overflow[i][j] = 0;
+ }
+ if (AliTriggerRunScalers::ConsistencyCheck(fScalersRecord.GetEntriesFast()-1,kFALSE,overflow)){
+ AliErrorClass("Trigger counters not in the right order or decreasing!");
+ // scaler->Print();
+ // fScalersRecord.Sort();
+ }
}
//_____________________________________________________________________________
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);
}
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 && rec->GetTimeStamp()) op2 = 1;
if( op2 && (result = stamp->Compare(rec->GetTimeStamp())) == 0 )
- return position; // exact match
- cout << "result " << result << " op2 " << op2 << " rec "<< rec << endl;
+ return position; // exact match
if (!op2 || result < 0)
last = position-1;
else
return (result < 0 ) ? position-1 : position; // nearst < stamp
}
//_____________________________________________________________________________
-Int_t AliTriggerRunScalers::ConsistencyCheck(Int_t position,Bool_t correctOverflow)
+Int_t AliTriggerRunScalers::ConsistencyCheck(Int_t position,Bool_t correctOverflow, UInt_t** overflow)
{
//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
// 2 = too big jump in scalers, looks like some readings are missing
// 3 = (level+1) > (level)
if (position == 0){
- AliErrorClass("position=0\n");
- return 1;
- }
+ 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;}
+ Bool_t increase[6];
+ for(Int_t i=0;i<6;i++){increase[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.
AliTriggerScalersRecordESD* recESD = 0;
if(correctOverflow){
recESD = new AliTriggerScalersRecordESD();
- AliTimeStamp stamp(*scalers2->GetTimeStamp());
- recESD->SetTimeStamp(stamp);
+ recESD->SetTimeStamp(scalers2->GetTimeStamp());
}
for( Int_t ic=0; ic<fnClasses; ++ic ){
TObjArray* scalersArray2 = (TObjArray*)scalers2->GetTriggerScalers();
AliTriggerScalers* counters2 = (AliTriggerScalers*)scalersArray2->At(ic);
+ UChar_t iclass = counters2->GetClassIndex();
counters2->GetAllScalers(c2);
TObjArray* scalersArray1 = (TObjArray*)scalers1->GetTriggerScalers();
AliTriggerScalers* counters1 = (AliTriggerScalers*)scalersArray1->At(ic);
counters1->GetAllScalers(c1);
-
- for(Int_t i=0;i<6;i++){
- if ( c2[i] > c1[i] ) increase[i]=1;
- else if ( c2[i] < c1[i] && (c1[i] - c2[i]) > max2) overflow[i]=1;
+ 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][ic]++;
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] ) return 3;
- else if ( (max1 - c1[i]+c2[i] ) < (c2[i+1] - c1[i+1]) && overflow[i] && increase[i+1] ) return 3;
- else if ( (c2[i] - c1[i]) < (max1 - c1[i+1] + c2[i+1]) && increase[i] && overflow[i+1] ) return 3;
- else if ( (max1 - c1[i] + c2[i] ) < (max1 - c1[i+1] + c2[i+1]) && overflow[i] && overflow[i+1] ) return 3;
+ 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][ic] && 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][ic] ) {
+ 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][ic] && overflow[i+1][ic] ) {
+ 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(ic,c64);
+ if(correctOverflow){
+ for(Int_t i=0;i<6;i++){ c64[i]=c2[i]+max1*overflow[i][ic]; }
+ AliTriggerScalersESD* s= new AliTriggerScalersESD(iclass,c64);
recESD->AddTriggerScalers(s);
- }
+ }
+
}
if(correctOverflow)fScalersRecordESD.AddLast(recESD);
return 0;
{
// 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();
TObjArray* scalersArray = (TObjArray*)scalers->GetTriggerScalers();
AliTriggerScalers* counters = (AliTriggerScalers*)scalersArray->At(ic);
counters->GetAllScalers(c1);
+ UChar_t iclass = counters->GetClassIndex();
for(Int_t i=0; i<6; i++)c64[i]=c1[i];
- AliTriggerScalersESD* s= new AliTriggerScalersESD(ic,c64);
+ AliTriggerScalersESD* s= new AliTriggerScalersESD(iclass,c64);
recESD->AddTriggerScalers(s);
}
fScalersRecordESD.AddLast(recESD);
+
+ UInt_t* overflow[6];
+ for(Int_t i=0; i<6; i++) {
+ overflow[i] = new UInt_t[fnClasses];
+ for(Int_t j=0; j<fnClasses; j++) overflow[i][j] = 0;
+ }
+
for(Int_t i=1;i<fScalersRecord.GetEntriesFast(); i++){
- if(ConsistencyCheck(i,kTRUE)){
+ if(ConsistencyCheck(i,kTRUE,overflow)){
+ fScalersRecord.At(i)->Print();
+ fScalersRecord.At(i-1)->Print();
fScalersRecordESD.SetOwner();
fScalersRecordESD.Delete();
AliErrorClass("Inconsistent scalers, they will not be provided.\n");
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 < fnClasses; ++ic ){
+ 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;
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff