[u/mrichter/AliRoot.git] / STEER / AliTriggerRunScalers.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id: AliTriggerRunScalers.cxx 22322 2007-11-22 11:43:14Z cvetan $ */

///////////////////////////////////////////////////////////////////////////////
//
// 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 <TArrayC.h>
//#include <TFile.h>
#include <TClass.h>
#include <TSystem.h>
#include <TObjString.h>
#include <TObjArray.h>

#include "AliLog.h"  
#include "AliTimeStamp.h"
#include "AliTriggerScalers.h"
#include "AliTriggerScalersRecord.h"
#include "AliTriggerRunScalers.h"

ClassImp( AliTriggerRunScalers )

//_____________________________________________________________________________
AliTriggerRunScalers::AliTriggerRunScalers():
  TObject(),
  fVersion(0),
  fRunNumber(0),
  fnClasses(0),
  fClassIndex(),                    
  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(); 
}
//_____________________________________________________________________________

AliTriggerRunScalers::AliTriggerRunScalers(const AliTriggerRunScalers &run) :
 TObject(),
 fVersion(run.fVersion),
 fRunNumber(run.fRunNumber),
 fnClasses(run.fnClasses),
 fClassIndex(),                    
 fScalersRecord(),
 fScalersRecordESD()
{
// copy constructor
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;
  }

  ifstream *file = new ifstream ( filename.Data() );
  if (!*file) {
    AliErrorClass(Form("Error opening file (%s) !\n",filename.Data()));
    file->close();
    delete file;
    return NULL;
  }
  
  AliTriggerRunScalers* rScaler = new AliTriggerRunScalers();
  
  TString strLine;
  Bool_t verflag = kFALSE;
  Bool_t classflag = kFALSE;
  UChar_t nclass = 0;
  while (strLine.ReadLine(*file)) {
    if (strLine.BeginsWith("#")) continue;
    
    TObjArray *tokens = strLine.Tokenize(" \t");
    Int_t ntokens = tokens->GetEntriesFast();
    // 1st line, version, it is one number, 
    if (!verflag) {
      if (ntokens != 1) { 
        AliErrorClass( Form( "Error reading version number from (%s), line :%s\n", 
                              filename.Data() , strLine.Data() ) );  
        return NULL;
      }
  //    cout << "Version "<< ((TObjString*)tokens->At(0))->String().Atoi() << endl;
      rScaler->SetVersion( ((TObjString*)tokens->At(0))->String().Atoi() );
      verflag = kTRUE;
      delete tokens;
      continue;
    }
   
    // 2nd line, run number , number of classes, list of classes used in this partition

    if (!classflag) {
      if ( !((TObjString*)tokens->At(1))->String().IsDigit() ) {
        AliErrorClass( Form( "Error reading Run number from (%s)\n", filename.Data() )); 
      }
  //    cout << "Run Number " << ((TObjString*)tokens->At(0))->String().Atoi() << endl;
      rScaler->SetRunNumber( ((TObjString*)tokens->At(0))->String().Atoi() );
      nclass = (UChar_t)((TObjString*)tokens->At(1))->String().Atoi();
  //    cout << "Number of classes " << nclass << endl;
      rScaler->SetNumClasses( nclass );
      if ( nclass != ntokens - 2 ) {
        AliErrorClass( Form( "Error reading number of classes from (%s)\n", filename.Data() )); 
      }
      for (UChar_t i=0; i<nclass; ++i) {
        rScaler->SetClass( i, (Char_t)((TObjString*)tokens->At(2+i))->String().Atoi() );
      }
      classflag = kTRUE;
      delete tokens;
      continue;
    }
    
    // Records
    // Each record consists of 1+(number of classes in partition) lines
    //  1st line of record = time stamp (4 words)
    //                        1st word = ORBIT(24 bits)
    //                        2nd word = Period Counter (28 bit)
    //                        3rd word = seconds (32 bits) from epoch
    //                        4th word = microsecs (32 bits)
    //  other lines = 6 words of counters (L0 before,L0 after, ....)
    if (ntokens != 4) { 
      AliErrorClass( Form( "Error reading timestamp from (%s): line (%s)", 
                            filename.Data(), strLine.Data() )); 
      return NULL;
    }

    UInt_t orbit     = strtoul(((TObjString*)tokens->At(0))->String(), NULL, 10);
    UInt_t period    = strtoul(((TObjString*)tokens->At(1))->String(), NULL, 10);
    UInt_t seconds   = strtoul(((TObjString*)tokens->At(2))->String(), NULL, 10);
    UInt_t microSecs = strtoul(((TObjString*)tokens->At(3))->String(), NULL, 10);

    AliTriggerScalersRecord * rec = new AliTriggerScalersRecord();
    rec->SetTimeStamp( orbit, period, seconds, microSecs );
    TString strLine1;
    for (Int_t i=0; i<nclass; ++i) {
      strLine1.ReadLine(*file);
      if (strLine1.BeginsWith("#")) continue;
      TObjArray *tokens1 = strLine1.Tokenize(" \t");
      Int_t ntokens1 = tokens1->GetEntriesFast();
      if( ntokens1 != 6 ) {
        AliErrorClass( Form( "Error reading scalers from (%s): line (%s)", 
			     filename.Data(), strLine1.Data() ));
	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);

      rScaler->GetClass(i);
      rec->AddTriggerScalers( rScaler->GetClass(i),
                              lOCB, lOCA, l1CB,
                              l1CA, l2CB, l2CA );

      delete tokens1;
    } 
    rScaler->AddTriggerScalers( rec );
    
    delete tokens;     
  }
  file->close();
  delete file;

  return  rScaler; 
}
  
//_____________________________________________________________________________
Int_t  AliTriggerRunScalers::FindNearestScalersRecord( const AliTimeStamp *stamp ) const
{
   // Find Trigger scaler record with the closest timestamp <= "stamp"
   // using a binary search. 
   // return the index in the array of records, if the timestamp 
   // is out of range return -1

   Int_t   base, position=-1, last, result = 0;
   Int_t op2 = 0;
   
   //fScalersRecord.Sort();

   base = 0;
   last = fScalersRecord.GetEntriesFast();

   while (last >= base) {
      position = (base+last) / 2;
      cout << "pos " <<   position<< " base " <<   base << "last " <<   last << endl;
      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;
      if (!op2 || result < 0)
         last = position-1;
      else
         base = position+1;
      op2 = 0;  
   }
   if( (position == 0 && result < 0) || position >= fScalersRecord.GetEntriesFast() ) 
    return -1;  // out of range
   else 
    return (result < 0 ) ? position-1 : position; // nearst < stamp   
}
//_____________________________________________________________________________
Bool_t AliTriggerRunScalers::ConsistencyCheck() const
{
   //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;

   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);
	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;

   }

   return 1;
}
//_____________________________________________________________________________
void AliTriggerRunScalers::Print( const Option_t* ) const
{
   // Print
  cout << "Trigger Scalers Record per Run: " << endl;
  cout << "  File version :" <<  fVersion << endl;            
  cout << "  Run Number :" <<  fRunNumber << endl;          
  cout << "  Number of Classes :" <<  (Int_t)fnClasses << endl;          
  cout << "    Classes ID:";
  for( Int_t i=0; i<fnClasses; ++i ) 
    cout << "  " << (Int_t)fClassIndex[i];       
  cout << endl; 
    
  for( Int_t i=0; i<fScalersRecord.GetEntriesFast(); ++i ) 
     ((AliTriggerScalersRecord*)fScalersRecord.At(i))->Print();
}
Commit	Line	Data
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>
d7dd8a54	38
	39	#include "AliLog.h"
	40	#include "AliTimeStamp.h"
	41	#include "AliTriggerScalers.h"
	42	#include "AliTriggerScalersRecord.h"
	43	#include "AliTriggerRunScalers.h"
	44
	45	ClassImp( AliTriggerRunScalers )
	46
	47	//_____________________________________________________________________________
	48	AliTriggerRunScalers::AliTriggerRunScalers():
	49	TObject(),
	50	fVersion(0),
	51	fRunNumber(0),
	52	fnClasses(0),
	53	fClassIndex(),
bf7443cc	54	fScalersRecord(),
bf7443cc	55	fScalersRecordESD()
d7dd8a54	56	{
	57	// Default constructor
	58	}
7eaf72df	59	//______________________________________________________________________________
	60	AliTriggerRunScalers::~AliTriggerRunScalers()
	61	{
	62	// Destructor
	63	fScalersRecord.SetOwner();
	64	fScalersRecord.Delete();
	65	fScalersRecordESD.SetOwner();
	66	fScalersRecordESD.Delete();
	67	}
d7dd8a54	68	//_____________________________________________________________________________
	69	void AliTriggerRunScalers::AddTriggerScalers( AliTriggerScalersRecord* scaler )
	70	{
d07a9211	71	// Add scaler and check consistency
e39e51f6	72	fScalersRecord.AddLast( scaler );
	73	if (!AliTriggerRunScalers::ConsistencyCheck()) AliErrorClass("Trigger counters not in the right order or decreasing!");
	74	// fScalersRecord.Sort();
d7dd8a54	75	}
bf7443cc	76	//_____________________________________________________________________________
	77
	78	AliTriggerRunScalers::AliTriggerRunScalers(const AliTriggerRunScalers &run) :
	79	TObject(),
	80	fVersion(run.fVersion),
	81	fRunNumber(run.fRunNumber),
	82	fnClasses(run.fnClasses),
	83	fClassIndex(),
	84	fScalersRecord(),
	85	fScalersRecordESD()
	86	{
	87	// copy constructor
	88	for (Int_t i = 0; i < run.fClassIndex.GetSize(); i++) {
	89	if (run.fClassIndex[i]) fClassIndex.AddAt(run.fClassIndex[i], i);
	90	}
	91	for (Int_t i = 0; i < run.fScalersRecord.GetEntriesFast(); i++) {
	92	if (run.fScalersRecord[i]) fScalersRecord.Add(run.fScalersRecord[i]->Clone());
	93	}
	94	for (Int_t i = 0; i < run.fScalersRecordESD.GetEntriesFast(); i++) {
	95	if (run.fScalersRecordESD[i]) fScalersRecordESD.Add(run.fScalersRecordESD[i]->Clone());
	96	}
	97
	98	}
	99	//_____________________________________________________________________________
	100	AliTriggerRunScalers &AliTriggerRunScalers::operator=(const AliTriggerRunScalers& run)
	101	{
	102	// assignment operator
	103	if(&run == this) return *this;
	104	((TObject *)this)->operator=(run);
	105
	106	fVersion = run.fVersion;
	107	fRunNumber = run.fRunNumber;
	108	fnClasses = run.fnClasses;
d7dd8a54	109
bf7443cc	110	for (Int_t i = 0; i < run.fClassIndex.GetSize(); i++) {
	111	if (run.fClassIndex[i]) fClassIndex.AddAt(run.fClassIndex[i], i);
	112	}
	113	for (Int_t i = 0; i < run.fScalersRecord.GetEntriesFast(); i++) {
	114	if (run.fScalersRecord[i]) fScalersRecord.Add(run.fScalersRecord[i]->Clone());
	115	}
	116	for (Int_t i = 0; i < run.fScalersRecordESD.GetEntriesFast(); i++) {
	117	if (run.fScalersRecordESD[i]) fScalersRecordESD.Add(run.fScalersRecordESD[i]->Clone());
	118	}
	119	return *this;
	120	}
d7dd8a54	121	//_____________________________________________________________________________
	122	AliTriggerRunScalers* AliTriggerRunScalers::ReadScalers( TString & filename )
	123	{
d07a9211	124	// Read scalers from text file(.cnt) provided by CTP
d07a9211	125	// for given run and convert it to root format
d7dd8a54	126	if( gSystem->AccessPathName( filename.Data() ) ) {
	127	AliErrorClass( Form( "file (%s) not found", filename.Data() ) );
	128	return NULL;
	129	}
	130
	131	ifstream *file = new ifstream ( filename.Data() );
	132	if (!*file) {
	133	AliErrorClass(Form("Error opening file (%s) !\n",filename.Data()));
	134	file->close();
	135	delete file;
	136	return NULL;
	137	}
	138
	139	AliTriggerRunScalers* rScaler = new AliTriggerRunScalers();
	140
	141	TString strLine;
	142	Bool_t verflag = kFALSE;
	143	Bool_t classflag = kFALSE;
	144	UChar_t nclass = 0;
	145	while (strLine.ReadLine(*file)) {
	146	if (strLine.BeginsWith("#")) continue;
	147
	148	TObjArray *tokens = strLine.Tokenize(" \t");
	149	Int_t ntokens = tokens->GetEntriesFast();
	150	// 1st line, version, it is one number,
	151	if (!verflag) {
	152	if (ntokens != 1) {
	153	AliErrorClass( Form( "Error reading version number from (%s), line :%s\n",
	154	filename.Data() , strLine.Data() ) );
	155	return NULL;
	156	}
	157	// cout << "Version "<< ((TObjString*)tokens->At(0))->String().Atoi() << endl;
	158	rScaler->SetVersion( ((TObjString*)tokens->At(0))->String().Atoi() );
	159	verflag = kTRUE;
	160	delete tokens;
	161	continue;
	162	}
	163
	164	// 2nd line, run number , number of classes, list of classes used in this partition
	165
	166	if (!classflag) {
	167	if ( !((TObjString*)tokens->At(1))->String().IsDigit() ) {
	168	AliErrorClass( Form( "Error reading Run number from (%s)\n", filename.Data() ));
	169	}
	170	// cout << "Run Number " << ((TObjString*)tokens->At(0))->String().Atoi() << endl;
	171	rScaler->SetRunNumber( ((TObjString*)tokens->At(0))->String().Atoi() );
	172	nclass = (UChar_t)((TObjString*)tokens->At(1))->String().Atoi();
	173	// cout << "Number of classes " << nclass << endl;
	174	rScaler->SetNumClasses( nclass );
	175	if ( nclass != ntokens - 2 ) {
	176	AliErrorClass( Form( "Error reading number of classes from (%s)\n", filename.Data() ));
	177	}
	178	for (UChar_t i=0; i<nclass; ++i) {
	179	rScaler->SetClass( i, (Char_t)((TObjString*)tokens->At(2+i))->String().Atoi() );
	180	}
	181	classflag = kTRUE;
	182	delete tokens;
	183	continue;
	184	}
	185
	186	// Records
	187	// Each record consists of 1+(number of classes in partition) lines
	188	// 1st line of record = time stamp (4 words)
	189	// 1st word = ORBIT(24 bits)
190	// 2nd word = Period Counter (28 bit)
191	// 3rd word = seconds (32 bits) from epoch
192	// 4th word = microsecs (32 bits)
193	// other lines = 6 words of counters (L0 before,L0 after, ....)
194	if (ntokens != 4) {
195	AliErrorClass( Form( "Error reading timestamp from (%s): line (%s)",
196	filename.Data(), strLine.Data() ));
197	return NULL;
198	}
e39e51f6	199
	200	UInt_t orbit = strtoul(((TObjString*)tokens->At(0))->String(), NULL, 10);
	201	UInt_t period = strtoul(((TObjString*)tokens->At(1))->String(), NULL, 10);
	202	UInt_t seconds = strtoul(((TObjString*)tokens->At(2))->String(), NULL, 10);
	203	UInt_t microSecs = strtoul(((TObjString*)tokens->At(3))->String(), NULL, 10);
	204
d7dd8a54	205	AliTriggerScalersRecord * rec = new AliTriggerScalersRecord();
d7dd8a54	206	rec->SetTimeStamp( orbit, period, seconds, microSecs );
d7dd8a54	207	TString strLine1;
	208	for (Int_t i=0; i<nclass; ++i) {
	209	strLine1.ReadLine(*file);
	210	if (strLine1.BeginsWith("#")) continue;
	211	TObjArray *tokens1 = strLine1.Tokenize(" \t");
	212	Int_t ntokens1 = tokens1->GetEntriesFast();
	213	if( ntokens1 != 6 ) {
29bdda4f	214	AliErrorClass( Form( "Error reading scalers from (%s): line (%s)",
	215	filename.Data(), strLine1.Data() ));
	216	delete rec;
	217	return rScaler;
d7dd8a54	218	}
d5aaf775	219
	220	UInt_t lOCB = strtoul(((TObjString*)tokens1->At(0))->String(), NULL, 10);
	221	UInt_t lOCA = strtoul(((TObjString*)tokens1->At(1))->String(), NULL, 10);
	222	UInt_t l1CB = strtoul(((TObjString*)tokens1->At(2))->String(), NULL, 10);
	223	UInt_t l1CA = strtoul(((TObjString*)tokens1->At(3))->String(), NULL, 10);
	224	UInt_t l2CB = strtoul(((TObjString*)tokens1->At(4))->String(), NULL, 10);
	225	UInt_t l2CA = strtoul(((TObjString*)tokens1->At(5))->String(), NULL, 10);
e39e51f6	226
d7dd8a54	227	rScaler->GetClass(i);
d7dd8a54	228	rec->AddTriggerScalers( rScaler->GetClass(i),
d5aaf775	229	lOCB, lOCA, l1CB,
	230	l1CA, l2CB, l2CA );
	231
d7dd8a54	232	delete tokens1;
	233	}
	234	rScaler->AddTriggerScalers( rec );
	235
	236	delete tokens;
	237	}
	238	file->close();
	239	delete file;
	240
	241	return rScaler;
	242	}
	243
	244	//_____________________________________________________________________________
033d0f8e	245	Int_t AliTriggerRunScalers::FindNearestScalersRecord( const AliTimeStamp *stamp ) const
d7dd8a54	246	{
	247	// Find Trigger scaler record with the closest timestamp <= "stamp"
	248	// using a binary search.
	249	// return the index in the array of records, if the timestamp
	250	// is out of range return -1
	251
	252	Int_t base, position=-1, last, result = 0;
5dd39685	253	Int_t op2 = 0;
d7dd8a54	254
033d0f8e	255	//fScalersRecord.Sort();
d7dd8a54	256
	257	base = 0;
	258	last = fScalersRecord.GetEntriesFast();
	259
	260	while (last >= base) {
	261	position = (base+last) / 2;
	262	cout << "pos " << position<< " base " << base << "last " << last << endl;
	263	AliTriggerScalersRecord* rec = (AliTriggerScalersRecord*)fScalersRecord.At(position);
5dd39685	264	if( rec && rec->GetTimeStamp()) op2 = 1;
5dd39685	265	if( op2 && (result = stamp->Compare(rec->GetTimeStamp())) == 0 )
d7dd8a54	266	return position; // exact match
	267	cout << "result " << result << " op2 " << op2 << " rec "<< rec << endl;
	268	if (!op2 \|\| result < 0)
	269	last = position-1;
	270	else
	271	base = position+1;
5dd39685	272	op2 = 0;
d7dd8a54	273	}
	274	if( (position == 0 && result < 0) \|\| position >= fScalersRecord.GetEntriesFast() )
	275	return -1; // out of range
	276	else
	277	return (result < 0 ) ? position-1 : position; // nearst < stamp
	278	}
e39e51f6	279	//_____________________________________________________________________________
bf7443cc	280	Bool_t AliTriggerRunScalers::ConsistencyCheck() const
e39e51f6	281	{
d07a9211	282	//Check if counters are consistent(increase). Example: lOCB(n) < lOCB(n+1) and lOCB > lOCA
	283	UInt_t lOCBtwo, lOCAtwo, l1CBtwo, l1CAtwo, l2CBtwo, l2CAtwo, lOCBone, lOCAone, l1CBone, l1CAone, l2CBone, l2CAone;
	284	Bool_t increase0B=0, increase0A=0, increase1B=0, increase1A=0, increase2B=0, increase2A=0;
	285	Bool_t overflow0B=0, overflow0A=0, overflow1B=0, overflow1A=0, overflow2B=0, overflow2A=0;
	286	Int_t position = fScalersRecord.GetEntriesFast()-1;
	287	if (position == 0) return 1;
	288
	289	AliTriggerScalersRecord* scalers2 = (AliTriggerScalersRecord*)fScalersRecord.At(position);
	290	AliTriggerScalersRecord* scalers1 = (AliTriggerScalersRecord*)fScalersRecord.At(position-1);
	291	if (scalers2->Compare((AliTriggerScalersRecord*)fScalersRecord.At(position-1)) == -1) return 0;
	292	else for( Int_t i=0; i<fnClasses; ++i ){
	293
	294	TObjArray* scalersArray2 = (TObjArray*)scalers2->GetTriggerScalers();
	295	AliTriggerScalers* counters2 = (AliTriggerScalers*)scalersArray2->At(i);
d5aaf775	296	lOCBtwo = counters2->GetLOCB();
	297	lOCAtwo = counters2->GetLOCA();
	298	l1CBtwo = counters2->GetL1CB();
	299	l1CAtwo = counters2->GetL1CA();
	300	l2CBtwo = counters2->GetL2CB();
	301	l2CAtwo = counters2->GetL2CA();
	302
d07a9211	303	TObjArray* scalersArray1 = (TObjArray*)scalers1->GetTriggerScalers();
d07a9211	304	AliTriggerScalers* counters1 = (AliTriggerScalers*)scalersArray1->At(i);
d5aaf775	305	lOCBone = counters1->GetLOCB();
	306	lOCAone = counters1->GetLOCA();
	307	l1CBone = counters1->GetL1CB();
	308	l1CAone = counters1->GetL1CA();
	309	l2CBone = counters1->GetL2CB();
	310	l2CAone = counters1->GetL2CA();
e39e51f6	311
d07a9211	312	UInt_t const max1 = 4294967295ul; //32bit counters overflow after 4294967295
d07a9211	313	UInt_t const max2 = 1000000000ul; //when counters overflow they seem to be decreasing. Assume decrease cannot be smaller than max2.
e39e51f6	314
d07a9211	315	if ( lOCBtwo > lOCBone ) increase0B=1;
	316	else if ( lOCBtwo < lOCBone && (lOCBone - lOCBtwo) > max2) overflow0B=1;
	317	else return 0;
e39e51f6	318
d07a9211	319	if ( lOCAtwo > lOCAone ) increase0A=1;
	320	else if ( lOCAtwo < lOCAone && (lOCAone - lOCAtwo) > max2) overflow0A=1;
	321	else return 0;
e39e51f6	322
d07a9211	323	if ( l1CBtwo > l1CBone ) increase1B=1;
	324	else if ( l1CBtwo < l1CBone && (l1CBone - l1CBtwo) > max2) overflow1B=1;
	325	else return 0;
d7dd8a54	326
d07a9211	327	if ( l1CAtwo > l1CAone ) increase1A=1;
	328	else if ( l1CAtwo < l1CAone && (l1CAone - l1CAtwo) > max2) overflow1A=1;
	329	else return 0;
e39e51f6	330
d07a9211	331	if ( l2CBtwo > l2CBone ) increase2B=1;
	332	else if ( l2CBtwo < l2CBone && (l2CBone - l2CBtwo) > max2) overflow2B=1;
	333	else return 0;
e39e51f6	334
d07a9211	335	if ( l2CAtwo > l2CAone ) increase2A=1;
	336	else if ( l2CAtwo < l2CAone && (l2CAone - l2CAtwo) > max2) overflow2A=1;
	337	else return 0;
e39e51f6	338
e39e51f6	339
d07a9211	340	if ( (lOCBtwo - lOCBone) < (lOCAtwo - lOCAone) && increase0B && increase0A ) return 0;
	341	else if ( (max1 - lOCBone + lOCBtwo ) < (lOCAtwo - lOCAone) && overflow0B && increase0A ) return 0;
	342	else if ( (lOCBtwo - lOCBone) < (max1 - lOCAone + lOCAtwo) && increase0B && overflow0A ) return 0;
	343	else if ( (max1 - lOCBone + lOCBtwo ) < (max1 - lOCAone + lOCAtwo) && overflow0B && overflow0A ) return 0;
	344
	345	if ( (lOCAtwo - lOCAone) < (l1CBtwo - l1CBone) && increase0A && increase1B ) return 0;
	346	else if ( (max1 - lOCAone + lOCAtwo ) < (l1CBtwo - l1CBone) && overflow0A && increase1B ) return 0;
	347	else if ( (lOCAtwo - lOCAone) < (max1 - l1CBone + l1CBtwo) && increase0A && overflow1B ) return 0;
	348	else if ( (max1 - lOCAone + lOCAtwo ) < (max1 - l1CBone + l1CBtwo) && overflow0A && overflow1B ) return 0;
e39e51f6	349
d07a9211	350	if ( (l1CBtwo - l1CBone) < (l1CAtwo - l1CAone) && increase1B && increase1A ) return 0;
	351	else if ( (max1 - l1CBone + l1CBtwo ) < (l1CAtwo - l1CAone) && overflow1B && increase1A ) return 0;
	352	else if ( (l1CBtwo - l1CBone) < (max1 - l1CAone + l1CAtwo) && increase1B && overflow1A ) return 0;
	353	else if ( (max1 - l1CBone + l1CBtwo ) < (max1 - l1CAone + l1CAtwo) && overflow1B && overflow1A ) return 0;
e39e51f6	354
d07a9211	355	if ( (l1CAtwo - l1CAone) < (l2CBtwo - l2CBone) && increase1A && increase2B ) return 0;
	356	else if ( (max1 - l1CAone + l1CAtwo ) < (l2CBtwo - l2CBone) && overflow1A && increase2B ) return 0;
	357	else if ( (l1CAtwo - l1CAone) < (max1 - l2CBone + l2CBtwo) && increase1A && overflow2B ) return 0;
	358	else if ( (max1 - l1CAone + l1CAtwo ) < (max1 - l2CBone + l2CBtwo) && overflow1A && overflow2B ) return 0;
e39e51f6	359
d07a9211	360	if ( (l2CBtwo - l2CBone) < (l2CAtwo - l2CAone) && increase2B && increase2A ) return 0;
	361	else if ( (max1 - l2CBone + l2CBtwo ) < (l2CAtwo - l2CAone) && overflow2B && increase2A ) return 0;
	362	else if ( (l2CBtwo - l2CBone) < (max1 - l2CAone + l2CAtwo) && increase2B && overflow2A ) return 0;
	363	else if ( (max1 - l2CBone + l2CBtwo ) < (max1 - l2CAone + l2CAtwo) && overflow2B && overflow2A ) return 0;
e39e51f6	364
d07a9211	365	}
e39e51f6	366
d07a9211	367	return 1;
e39e51f6	368	}
d7dd8a54	369	//_____________________________________________________________________________
	370	void AliTriggerRunScalers::Print( const Option_t* ) const
	371	{
	372	// Print
	373	cout << "Trigger Scalers Record per Run: " << endl;
	374	cout << " File version :" << fVersion << endl;
	375	cout << " Run Number :" << fRunNumber << endl;
	376	cout << " Number of Classes :" << (Int_t)fnClasses << endl;
	377	cout << " Classes ID:";
	378	for( Int_t i=0; i<fnClasses; ++i )
	379	cout << " " << (Int_t)fClassIndex[i];
	380	cout << endl;
	381
	382	for( Int_t i=0; i<fScalersRecord.GetEntriesFast(); ++i )
	383	((AliTriggerScalersRecord*)fScalersRecord.At(i))->Print();
	384	}
	385