X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=STEER%2FAliTriggerRunScalers.cxx;h=a14e1009572bc99633e3c739530a35f181757850;hb=34e4662793403cc6a4966dda810c90813ee62fca;hp=ae7a29223c351a764c04d214aad05fffcbc94b28;hpb=5dd39685e4859884097aea8381fb2bd0b717b122;p=u%2Fmrichter%2FAliRoot.git diff --git a/STEER/AliTriggerRunScalers.cxx b/STEER/AliTriggerRunScalers.cxx index ae7a29223c3..a14e1009572 100644 --- a/STEER/AliTriggerRunScalers.cxx +++ b/STEER/AliTriggerRunScalers.cxx @@ -39,7 +39,9 @@ #include "AliLog.h" #include "AliTimeStamp.h" #include "AliTriggerScalers.h" +#include "AliTriggerScalersESD.h" #include "AliTriggerScalersRecord.h" +#include "AliTriggerScalersRecordESD.h" #include "AliTriggerRunScalers.h" ClassImp( AliTriggerRunScalers ) @@ -51,20 +53,82 @@ AliTriggerRunScalers::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(); + UInt_t* overflow[6]; + for(Int_t i=0; i<6; i++) { + overflow[i] = new UInt_t[fnClasses]; + for(Int_t j=0; jPrint(); + // 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 ) { @@ -206,12 +270,11 @@ Int_t AliTriggerRunScalers::FindNearestScalersRecord( const AliTimeStamp *stamp 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 @@ -224,94 +287,170 @@ Int_t AliTriggerRunScalers::FindNearestScalersRecord( const AliTimeStamp *stamp return (result < 0 ) ? position-1 : position; // nearst < stamp } //_____________________________________________________________________________ -Bool_t AliTriggerRunScalers::ConsistencyCheck() +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 - UInt_t lOCBtwo, lOCAtwo, l1CBtwo, l1CAtwo, l2CBtwo, l2CAtwo, lOCBone, lOCAone, l1CBone, l1CAone, l2CBone, l2CAone; - 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; + // 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]; + 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. 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; iGetTriggerScalers(); - AliTriggerScalers* counters2 = (AliTriggerScalers*)scalersArray2->At(i); - lOCBtwo = counters2->GetLOCB(); - lOCAtwo = counters2->GetLOCA(); - l1CBtwo = counters2->GetL1CB(); - l1CAtwo = counters2->GetL1CA(); - l2CBtwo = counters2->GetL2CB(); - l2CAtwo = counters2->GetL2CA(); - - TObjArray* scalersArray1 = (TObjArray*)scalers1->GetTriggerScalers(); - AliTriggerScalers* counters1 = (AliTriggerScalers*)scalersArray1->At(i); - lOCBone = counters1->GetLOCB(); - lOCAone = counters1->GetLOCA(); - l1CBone = counters1->GetL1CB(); - l1CAone = counters1->GetL1CA(); - l2CBone = counters1->GetL2CB(); - l2CAone = 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 ( lOCBtwo > lOCBone ) increase0B=1; - else if ( lOCBtwo < lOCBone && (lOCBone - lOCBtwo) > max2) overflow0B=1; - else return 0; - - if ( lOCAtwo > lOCAone ) increase0A=1; - else if ( lOCAtwo < lOCAone && (lOCAone - lOCAtwo) > max2) overflow0A=1; - else return 0; - - if ( l1CBtwo > l1CBone ) increase1B=1; - else if ( l1CBtwo < l1CBone && (l1CBone - l1CBtwo) > max2) overflow1B=1; - else return 0; - - if ( l1CAtwo > l1CAone ) increase1A=1; - else if ( l1CAtwo < l1CAone && (l1CAone - l1CAtwo) > max2) overflow1A=1; - else return 0; - - if ( l2CBtwo > l2CBone ) increase2B=1; - else if ( l2CBtwo < l2CBone && (l2CBone - l2CBtwo) > max2) overflow2B=1; - else return 0; - - if ( l2CAtwo > l2CAone ) increase2A=1; - else if ( l2CAtwo < l2CAone && (l2CAone - l2CAtwo) > max2) overflow2A=1; - else return 0; - - - if ( (lOCBtwo - lOCBone) < (lOCAtwo - lOCAone) && increase0B && increase0A ) return 0; - else if ( (max1 - lOCBone + lOCBtwo ) < (lOCAtwo - lOCAone) && overflow0B && increase0A ) return 0; - else if ( (lOCBtwo - lOCBone) < (max1 - lOCAone + lOCAtwo) && increase0B && overflow0A ) return 0; - else if ( (max1 - lOCBone + lOCBtwo ) < (max1 - lOCAone + lOCAtwo) && overflow0B && overflow0A ) return 0; - - if ( (lOCAtwo - lOCAone) < (l1CBtwo - l1CBone) && increase0A && increase1B ) return 0; - else if ( (max1 - lOCAone + lOCAtwo ) < (l1CBtwo - l1CBone) && overflow0A && increase1B ) return 0; - else if ( (lOCAtwo - lOCAone) < (max1 - l1CBone + l1CBtwo) && increase0A && overflow1B ) return 0; - else if ( (max1 - lOCAone + lOCAtwo ) < (max1 - l1CBone + l1CBtwo) && overflow0A && overflow1B ) return 0; - - if ( (l1CBtwo - l1CBone) < (l1CAtwo - l1CAone) && increase1B && increase1A ) return 0; - else if ( (max1 - l1CBone + l1CBtwo ) < (l1CAtwo - l1CAone) && overflow1B && increase1A ) return 0; - else if ( (l1CBtwo - l1CBone) < (max1 - l1CAone + l1CAtwo) && increase1B && overflow1A ) return 0; - else if ( (max1 - l1CBone + l1CBtwo ) < (max1 - l1CAone + l1CAtwo) && overflow1B && overflow1A ) return 0; - - if ( (l1CAtwo - l1CAone) < (l2CBtwo - l2CBone) && increase1A && increase2B ) return 0; - else if ( (max1 - l1CAone + l1CAtwo ) < (l2CBtwo - l2CBone) && overflow1A && increase2B ) return 0; - else if ( (l1CAtwo - l1CAone) < (max1 - l2CBone + l2CBtwo) && increase1A && overflow2B ) return 0; - else if ( (max1 - l1CAone + l1CAtwo ) < (max1 - l2CBone + l2CBtwo) && overflow1A && overflow2B ) return 0; - - if ( (l2CBtwo - l2CBone) < (l2CAtwo - l2CAone) && increase2B && increase2A ) return 0; - else if ( (max1 - l2CBone + l2CBtwo ) < (l2CAtwo - l2CAone) && overflow2B && increase2A ) return 0; - else if ( (l2CBtwo - l2CBone) < (max1 - l2CAone + l2CAtwo) && increase2B && overflow2A ) return 0; - else if ( (max1 - l2CBone + l2CBtwo ) < (max1 - l2CAone + l2CAtwo) && overflow2B && overflow2A ) return 0; - + if (scalers2->Compare((AliTriggerScalersRecord*)fScalersRecord.At(position-1)) == -1) return 1; + + AliTriggerScalersRecordESD* recESD = 0; + if(correctOverflow){ + recESD = new AliTriggerScalersRecordESD(); + recESD->SetTimeStamp(scalers2->GetTimeStamp()); } - - return 1; + for( Int_t ic=0; icGetTriggerScalers(); + 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<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] ) { + 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][ic]; } + AliTriggerScalersESD* s= new AliTriggerScalersESD(iclass,c64); + recESD->AddTriggerScalers(s); + } + + } + if(correctOverflow)fScalersRecordESD.AddLast(recESD); + return 0; +} +//____________________________________________________________________________ +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; icGetTriggerScalers(); + 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(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; jPrint(); + 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