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 //
  22 //
  23 //////////////////////////////////////////////////////////////////////////////
  24
  25 #include <stdlib.h>
  26
  27 #include <Riostream.h>
  28 #include <TObject.h>
  29 #include <TClass.h>
  30 #include <TArrayC.h>
  31 #include <TSystem.h>
  32 #include <TObjString.h>
  33 #include <TObjArray.h>
  34 #include <TSystem.h>
  35 #include <TFile.h>
  36
  37 #include "AliLog.h"
  38 #include "AliTimeStamp.h"
  39 #include "AliTriggerScalers.h"
  40 #include "AliTriggerScalersRecord.h"
  41 #include "AliTriggerRunScalers.h"
  42 #include "AliCDBEntry.h"
  43 #include "AliCDBManager.h"
  44 #include "AliCDBStorage.h"
  45
  46 ClassImp( AliTriggerRunScalers )
  47
  48 //_____________________________________________________________________________
  49 AliTriggerRunScalers::AliTriggerRunScalers():
  50   TObject(),
  51   fVersion(0),
  52   fRunNumber(0),
  53   fnClasses(0),
  54   fClassIndex(),
  55   fScalersRecord()
  56 {
  57   // Default constructor
  58 }
  59
  60 //_____________________________________________________________________________
  61 void AliTriggerRunScalers::AddTriggerScalers( AliTriggerScalersRecord* scaler )
  62 {
  63   //
  64   fScalersRecord.AddLast( scaler );
  65   if (!AliTriggerRunScalers::ConsistencyCheck()) AliErrorClass("Trigger counters not in the right order or decreasing!");
  66 //  fScalersRecord.Sort();
  67 }
  68
  69 //_____________________________________________________________________________
  70 AliTriggerRunScalers* AliTriggerRunScalers::ReadScalers( TString & filename )
  71 {
  72
  73   if( gSystem->AccessPathName( filename.Data() ) ) {
  74      AliErrorClass( Form( "file (%s) not found", filename.Data() ) );
  75      return NULL;
  76   }
  77
  78   ifstream *file = new ifstream ( filename.Data() );
  79   if (!*file) {
  80     AliErrorClass(Form("Error opening file (%s) !\n",filename.Data()));
  81     file->close();
  82     delete file;
  83     return NULL;
  84   }
  85
  86   AliTriggerRunScalers* rScaler = new AliTriggerRunScalers();
  87
  88   TString strLine;
  89   Bool_t verflag = kFALSE;
  90   Bool_t classflag = kFALSE;
  91   UChar_t nclass = 0;
  92   while (strLine.ReadLine(*file)) {
  93     if (strLine.BeginsWith("#")) continue;
  94
  95     TObjArray *tokens = strLine.Tokenize(" \t");
  96     Int_t ntokens = tokens->GetEntriesFast();
  97     // 1st line, version, it is one number,
  98     if (!verflag) {
  99       if (ntokens != 1) {
 100         AliErrorClass( Form( "Error reading version number from (%s), line :%s\n",
 101                               filename.Data() , strLine.Data() ) );
 102         return NULL;
 103       }
 104   //    cout << "Version "<< ((TObjString*)tokens->At(0))->String().Atoi() << endl;
 105       rScaler->SetVersion( ((TObjString*)tokens->At(0))->String().Atoi() );
 106       verflag = kTRUE;
 107       delete tokens;
 108       continue;
 109     }
 110
 111     // 2nd line, run number , number of classes, list of classes used in this partition
 112
 113     if (!classflag) {
 114       if ( !((TObjString*)tokens->At(1))->String().IsDigit() ) {
 115         AliErrorClass( Form( "Error reading Run number from (%s)\n", filename.Data() ));
 116       }
 117   //    cout << "Run Number " << ((TObjString*)tokens->At(0))->String().Atoi() << endl;
 118       rScaler->SetRunNumber( ((TObjString*)tokens->At(0))->String().Atoi() );
 119       nclass = (UChar_t)((TObjString*)tokens->At(1))->String().Atoi();
 120   //    cout << "Number of classes " << nclass << endl;
 121       rScaler->SetNumClasses( nclass );
 122       if ( nclass != ntokens - 2 ) {
 123         AliErrorClass( Form( "Error reading number of classes from (%s)\n", filename.Data() ));
 124       }
 125       for (UChar_t i=0; i<nclass; ++i) {
 126         rScaler->SetClass( i, (Char_t)((TObjString*)tokens->At(2+i))->String().Atoi() );
 127       }
 128       classflag = kTRUE;
 129       delete tokens;
 130       continue;
 131     }
 132
 133     // Records
 134     // Each record consists of 1+(number of classes in partition) lines
 135     //  1st line of record = time stamp (4 words)
 136     //                        1st word = ORBIT(24 bits)
 137     //                        2nd word = Period Counter (28 bit)
 138     //                        3rd word = seconds (32 bits) from epoch
 139     //                        4th word = microsecs (32 bits)
 140     //  other lines = 6 words of counters (L0 before,L0 after, ....)
 141     if (ntokens != 4) {
 142       AliErrorClass( Form( "Error reading timestamp from (%s): line (%s)",
 143                             filename.Data(), strLine.Data() ));
 144       return NULL;
 145     }
 146
 147     UInt_t orbit     = strtoul(((TObjString*)tokens->At(0))->String(), NULL, 10);
 148     UInt_t period    = strtoul(((TObjString*)tokens->At(1))->String(), NULL, 10);
 149     UInt_t seconds   = strtoul(((TObjString*)tokens->At(2))->String(), NULL, 10);
 150     UInt_t microSecs = strtoul(((TObjString*)tokens->At(3))->String(), NULL, 10);
 151
 152     AliTriggerScalersRecord * rec = new AliTriggerScalersRecord();
 153     rec->SetTimeStamp( orbit, period, seconds, microSecs );
 154     TString strLine1;
 155     for (Int_t i=0; i<nclass; ++i) {
 156       strLine1.ReadLine(*file);
 157       if (strLine1.BeginsWith("#")) continue;
 158       TObjArray *tokens1 = strLine1.Tokenize(" \t");
 159       Int_t ntokens1 = tokens1->GetEntriesFast();
 160       if( ntokens1 != 6 ) {
 161         AliErrorClass( Form( "Error reading scalers from (%s): line (%s)",
 162                              filename.Data(), strLine1.Data() ));
 163         delete rec;
 164         return rScaler;
 165       }
 166       UInt_t LOCB = strtoul(((TObjString*)tokens1->At(0))->String(), NULL, 10);
 167       UInt_t LOCA = strtoul(((TObjString*)tokens1->At(1))->String(), NULL, 10);
 168       UInt_t L1CB = strtoul(((TObjString*)tokens1->At(2))->String(), NULL, 10);
 169       UInt_t L1CA = strtoul(((TObjString*)tokens1->At(3))->String(), NULL, 10);
 170       UInt_t L2CB = strtoul(((TObjString*)tokens1->At(4))->String(), NULL, 10);
 171       UInt_t L2CA = strtoul(((TObjString*)tokens1->At(5))->String(), NULL, 10);
 172
 173       rScaler->GetClass(i);
 174       rec->AddTriggerScalers( rScaler->GetClass(i),
 175                               LOCB, LOCA, L1CB,
 176                               L1CA, L2CB, L2CA );
 177       delete tokens1;
 178     }
 179     rScaler->AddTriggerScalers( rec );
 180
 181     delete tokens;
 182   }
 183   file->close();
 184   delete file;
 185
 186   return  rScaler;
 187 }
 188
 189 //_____________________________________________________________________________
 190 Int_t  AliTriggerRunScalers::FindNearestScalersRecord( AliTimeStamp * stamp )
 191 {
 192    // Find Trigger scaler record with the closest timestamp <= "stamp"
 193    // using a binary search.
 194    // return the index in the array of records, if the timestamp
 195    // is out of range return -1
 196
 197    Int_t   base, position=-1, last, result = 0;
 198    AliTimeStamp *op2 = NULL;
 199
 200    fScalersRecord.Sort();
 201
 202    base = 0;
 203    last = fScalersRecord.GetEntriesFast();
 204
 205    while (last >= base) {
 206       position = (base+last) / 2;
 207       cout << "pos " <<   position<< " base " <<   base << "last " <<   last << endl;
 208       AliTriggerScalersRecord* rec = (AliTriggerScalersRecord*)fScalersRecord.At(position);
 209       if( rec ) op2 = rec->GetTimeStamp();
 210       if( op2 && (result = stamp->Compare(op2)) == 0  )
 211          return position;  // exact match
 212       cout << "result " <<   result << " op2 " << op2 << " rec "<< rec << endl;
 213       if (!op2 || result < 0)
 214          last = position-1;
 215       else
 216          base = position+1;
 217       op2 = NULL;
 218    }
 219    if( (position == 0 && result < 0) || position >= fScalersRecord.GetEntriesFast() )
 220     return -1;  // out of range
 221    else
 222     return (result < 0 ) ? position-1 : position; // nearst < stamp
 223 }
 224 //_____________________________________________________________________________
 225 Bool_t AliTriggerRunScalers::ConsistencyCheck()
 226 {
 227
 228 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;
 229 char *LOCBstat = "NULL", *LOCAstat = "NULL", *L1CBstat = "NULL", *L1CAstat = "NULL", *L2CBstat = "NULL", *L2CAstat = "NULL";
 230 Int_t position = fScalersRecord.GetEntriesFast()-1;
 231
 232 if (position == 0) return 1;
 233
 234 AliTriggerScalersRecord* Scalers2 = (AliTriggerScalersRecord*)fScalersRecord.At(position);
 235 AliTriggerScalersRecord* Scalers1 = (AliTriggerScalersRecord*)fScalersRecord.At(position-1);
 236 if (Scalers2->Compare((AliTriggerScalersRecord*)fScalersRecord.At(position-1)) == -1) return 0;
 237 else for( Int_t i=0; i<fnClasses; ++i ){
 238
 239 TObjArray* ScalersArray2 = (TObjArray*)Scalers2->GetTriggerScalers();
 240 AliTriggerScalers* counters2 = (AliTriggerScalers*)ScalersArray2->At(i);
 241         LOCB_2 = counters2->GetLOCB();
 242         LOCA_2 = counters2->GetLOCA();
 243         L1CB_2 = counters2->GetL1CB();
 244         L1CA_2 = counters2->GetL1CA();
 245         L2CB_2 = counters2->GetL2CB();
 246         L2CA_2 = counters2->GetL2CA();
 247
 248 TObjArray* ScalersArray1 = (TObjArray*)Scalers1->GetTriggerScalers();
 249 AliTriggerScalers* counters1 = (AliTriggerScalers*)ScalersArray1->At(i);
 250         LOCB_1 = counters1->GetLOCB();
 251         LOCA_1 = counters1->GetLOCA();
 252         L1CB_1 = counters1->GetL1CB();
 253         L1CA_1 = counters1->GetL1CA();
 254         L2CB_1 = counters1->GetL2CB();
 255         L2CA_1 = counters1->GetL2CA();
 256
 257 if ( LOCB_2 > LOCB_1 ) LOCBstat = "increase";
 258 else if ( LOCB_2 < LOCB_1 && (LOCB_1 - LOCB_2) > 1000000000) LOCBstat = "overflow";
 259 else return 0;
 260
 261 if ( LOCA_2 > LOCA_1 ) LOCAstat = "increase";
 262 else if ( LOCA_2 < LOCA_1 && (LOCA_1 - LOCA_2) > 1000000000) LOCAstat = "overflow";
 263 else return 0;
 264
 265 if ( L1CB_2 > L1CB_1 ) L1CBstat = "increase";
 266 else if ( L1CB_2 < L1CB_1 && (L1CB_1 - L1CB_2) > 1000000000) L1CBstat = "overflow";
 267 else return 0;
 268
 269 if ( L1CA_2 > L1CA_1 ) L1CAstat = "increase";
 270 else if ( L1CA_2 < L1CA_1 && (L1CA_1 - L1CA_2) > 1000000000) L1CAstat = "overflow";
 271 else return 0;
 272
 273 if ( L2CB_2 > L2CB_1 ) L2CBstat = "increase";
 274 else if ( L2CB_2 < L2CB_1 && (L2CB_1 - L2CB_2) > 1000000000) L2CBstat = "overflow";
 275 else return 0;
 276
 277 if ( L2CA_2 > L2CA_1 ) L2CAstat = "increase";
 278 else if ( L2CA_2 < L2CA_1 && (L2CA_1 - L2CA_2) > 1000000000) L2CAstat = "overflow";
 279 else return 0;
 280
 281
 282 if ( (LOCB_2 - LOCB_1) < (LOCA_2 - LOCA_1) && LOCBstat == "increase" && LOCAstat == "increase" ) return 0;
 283 else if ( (4294967295ul - LOCB_1 + LOCB_2 ) < (LOCA_2 - LOCA_1) && LOCBstat == "overflow" && LOCAstat == "increase" ) return 0;
 284 else if ( (LOCB_2 - LOCB_1) < (4294967295ul - LOCA_1 + LOCA_2) && LOCBstat == "increase" && LOCAstat == "overflow" ) return 0;
 285 else if ( (4294967295ul - LOCB_1 + LOCB_2 ) < (4294967295ul - LOCA_1 + LOCA_2) && LOCBstat == "overflow" && LOCAstat == "overflow" ) return 0;
 286
 287 if ( (LOCA_2 - LOCA_1) < (L1CB_2 - L1CB_1) && LOCAstat == "increase" && L1CBstat == "increase" ) return 0;
 288 else if ( (4294967295ul - LOCA_1 + LOCA_2 ) < (L1CB_2 - L1CB_1) && LOCAstat == "overflow" && L1CBstat == "increase" ) return 0;
 289 else if ( (LOCA_2 - LOCA_1) < (4294967295ul - L1CB_1 + L1CB_2) && LOCAstat == "increase" && L1CBstat == "overflow" ) return 0;
 290 else if ( (4294967295ul - LOCA_1 + LOCA_2 ) < (4294967295ul - L1CB_1 + L1CB_2) && LOCAstat == "overflow" && L1CBstat == "overflow" ) return 0;
 291
 292 if ( (L1CB_2 - L1CB_1) < (L1CA_2 - L1CA_1) && L1CBstat == "increase" && L1CAstat == "increase" ) return 0;
 293 else if ( (4294967295ul - L1CB_1 + L1CB_2 ) < (L1CA_2 - L1CA_1) && L1CBstat == "overflow" && L1CAstat == "increase" ) return 0;
 294 else if ( (L1CB_2 - L1CB_1) < (4294967295ul - L1CA_1 + L1CA_2) && L1CBstat == "increase" && L1CAstat == "overflow" ) return 0;
 295 else if ( (4294967295ul - L1CB_1 + L1CB_2 ) < (4294967295ul - L1CA_1 + L1CA_2) && L1CBstat == "overflow" && L1CAstat == "overflow" ) return 0;
 296
 297 if ( (L1CA_2 - L1CA_1) < (L2CB_2 - L2CB_1) && L1CAstat == "increase" && L2CBstat == "increase" ) return 0;
 298 else if ( (4294967295ul- L1CA_1 + L1CA_2 ) < (L2CB_2 - L2CB_1) && L1CAstat == "overflow" && L2CBstat == "increase" ) return 0;
 299 else if ( (L1CA_2 - L1CA_1) < (4294967295ul- L2CB_1 + L2CB_2) && L1CAstat == "increase" && L2CBstat == "overflow" ) return 0;
 300 else if ( (4294967295ul- L1CA_1 + L1CA_2 ) < (4294967295ul- L2CB_1 + L2CB_2) && L1CAstat == "overflow" && L2CBstat == "overflow" ) return 0;
 301
 302 if ( (L2CB_2 - L2CB_1) < (L2CA_2 - L2CA_1) && L2CBstat == "increase" && L2CAstat == "increase" ) return 0;
 303 else if ( (4294967295ul- L2CB_1 + L2CB_2 ) < (L2CA_2 - L2CA_1) && L2CBstat == "overflow" && L2CAstat == "increase" ) return 0;
 304 else if ( (L2CB_2 - L2CB_1) < (4294967295ul- L2CA_1 + L2CA_2) && L2CBstat == "increase" && L2CAstat == "overflow" ) return 0;
 305 else if ( (4294967295ul- L2CB_1 + L2CB_2 ) < (4294967295ul- L2CA_1 + L2CA_2) && L2CBstat == "overflow" && L2CAstat == "overflow" ) return 0;
 306
 307
 308
 309
 310 cout<<"LOCB_1 =" << LOCB_1 <<"  LOCB_2="<<LOCB_2<<endl;
 311 if ( L1CB_2 < L1CB_1 || L1CA_2 < L1CA_1 || L2CB_2 < L2CB_1 || L2CA_2 < L2CA_1) return 0;
 312 else if ( LOCB_2 < LOCB_1 && ((LOCB_1 - LOCB_2) < 1000000000) ) return 0;//verify this number with Roman!
 313
 314 }
 315
 316 return 1;
 317 }
 318 //_____________________________________________________________________________
 319 void AliTriggerRunScalers::Print( const Option_t* ) const
 320 {
 321    // Print
 322   cout << "Trigger Scalers Record per Run: " << endl;
 323   cout << "  File version :" <<  fVersion << endl;
 324   cout << "  Run Number :" <<  fRunNumber << endl;
 325   cout << "  Number of Classes :" <<  (Int_t)fnClasses << endl;
 326   cout << "    Classes ID:";
 327   for( Int_t i=0; i<fnClasses; ++i )
 328     cout << "  " << (Int_t)fClassIndex[i];
 329   cout << endl;
 330
 331   for( Int_t i=0; i<fScalersRecord.GetEntriesFast(); ++i )
 332      ((AliTriggerScalersRecord*)fScalersRecord.At(i))->Print();
 333 }
 334