[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.
//
//
//////////////////////////////////////////////////////////////////////////////

#include <stdlib.h>

#include <Riostream.h>
#include <TObject.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 "AliTriggerScalersRecord.h"
#include "AliTriggerRunScalers.h"
#include "AliCDBEntry.h"
#include "AliCDBManager.h"
#include "AliCDBStorage.h"

ClassImp( AliTriggerRunScalers )

//_____________________________________________________________________________
AliTriggerRunScalers::AliTriggerRunScalers():
  TObject(),
  fVersion(0),
  fRunNumber(0),
  fnClasses(0),
  fClassIndex(),                    
  fScalersRecord()
{
  // Default constructor
}

//_____________________________________________________________________________
void AliTriggerRunScalers::AddTriggerScalers( AliTriggerScalersRecord* scaler ) 
{ 
  //
  fScalersRecord.AddLast( scaler );
  if (!AliTriggerRunScalers::ConsistencyCheck()) AliErrorClass("Trigger counters not in the right order or decreasing!");
//  fScalersRecord.Sort(); 
}

//_____________________________________________________________________________
AliTriggerRunScalers* AliTriggerRunScalers::ReadScalers( TString & filename )
{
  
  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( AliTimeStamp * stamp )
{
   // 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;
   AliTimeStamp *op2 = NULL;
   
   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 ) op2 = rec->GetTimeStamp();
      if( op2 && (result = stamp->Compare(op2)) == 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 = NULL;  
   }
   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()
{

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;

}

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.
	21	//
	22	//
	23	//////////////////////////////////////////////////////////////////////////////
	24
c180f65d	25	#include <stdlib.h>
c180f65d	26
d7dd8a54	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"
e39e51f6	42	#include "AliCDBEntry.h"
	43	#include "AliCDBManager.h"
	44	#include "AliCDBStorage.h"
d7dd8a54	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	//
e39e51f6	64	fScalersRecord.AddLast( scaler );
	65	if (!AliTriggerRunScalers::ConsistencyCheck()) AliErrorClass("Trigger counters not in the right order or decreasing!");
	66	// fScalersRecord.Sort();
d7dd8a54	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	}
e39e51f6	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
d7dd8a54	152	AliTriggerScalersRecord * rec = new AliTriggerScalersRecord();
d7dd8a54	153	rec->SetTimeStamp( orbit, period, seconds, microSecs );
d7dd8a54	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 ) {
29bdda4f	161	AliErrorClass( Form( "Error reading scalers from (%s): line (%s)",
	162	filename.Data(), strLine1.Data() ));
	163	delete rec;
	164	return rScaler;
d7dd8a54	165	}
e39e51f6	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
d7dd8a54	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	}
e39e51f6	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;
35d1f53b	229	Bool_t increase0B=0, increase0A=0, increase1B=0, increase1A=0, increase2B=0, increase2A=0;
35d1f53b	230	Bool_t overflow0B=0, overflow0A=0, overflow1B=0, overflow1A=0, overflow2B=0, overflow2A=0;
e39e51f6	231	Int_t position = fScalersRecord.GetEntriesFast()-1;
e39e51f6	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
35d1f53b	257	UInt_t const max1 = 4294967295ul; //32bit counters overflow after 4294967295
35d1f53b	258	UInt_t const max2 = 1000000000ul; //when counters overflow they seem to be decreasing. Assume decrease cannot be smaller than max2.
e39e51f6	259
35d1f53b	260	if ( LOCB_2 > LOCB_1 ) increase0B=1;
35d1f53b	261	else if ( LOCB_2 < LOCB_1 && (LOCB_1 - LOCB_2) > max2) overflow0B=1;
e39e51f6	262	else return 0;
e39e51f6	263
35d1f53b	264	if ( LOCA_2 > LOCA_1 ) increase0A=1;
35d1f53b	265	else if ( LOCA_2 < LOCA_1 && (LOCA_1 - LOCA_2) > max2) overflow0A=1;
e39e51f6	266	else return 0;
e39e51f6	267
35d1f53b	268	if ( L1CB_2 > L1CB_1 ) increase1B=1;
35d1f53b	269	else if ( L1CB_2 < L1CB_1 && (L1CB_1 - L1CB_2) > max2) overflow1B=1;
e39e51f6	270	else return 0;
d7dd8a54	271
35d1f53b	272	if ( L1CA_2 > L1CA_1 ) increase1A=1;
35d1f53b	273	else if ( L1CA_2 < L1CA_1 && (L1CA_1 - L1CA_2) > max2) overflow1A=1;
e39e51f6	274	else return 0;
e39e51f6	275
35d1f53b	276	if ( L2CB_2 > L2CB_1 ) increase2B=1;
35d1f53b	277	else if ( L2CB_2 < L2CB_1 && (L2CB_1 - L2CB_2) > max2) overflow2B=1;
e39e51f6	278	else return 0;
e39e51f6	279
35d1f53b	280	if ( L2CA_2 > L2CA_1 ) increase2A=1;
	281	else if ( L2CA_2 < L2CA_1 && (L2CA_1 - L2CA_2) > max2) overflow2A=1;
	282	else return 0;
e39e51f6	283
e39e51f6	284
35d1f53b	285	if ( (LOCB_2 - LOCB_1) < (LOCA_2 - LOCA_1) && increase0B && increase0A ) return 0;
	286	else if ( (max1 - LOCB_1 + LOCB_2 ) < (LOCA_2 - LOCA_1) && overflow0B && increase0A ) return 0;
	287	else if ( (LOCB_2 - LOCB_1) < (max1 - LOCA_1 + LOCA_2) && increase0B && overflow0A ) return 0;
	288	else if ( (max1 - LOCB_1 + LOCB_2 ) < (max1 - LOCA_1 + LOCA_2) && overflow0B && overflow0A ) return 0;
e39e51f6	289
35d1f53b	290	if ( (LOCA_2 - LOCA_1) < (L1CB_2 - L1CB_1) && increase0A && increase1B ) return 0;
	291	else if ( (max1 - LOCA_1 + LOCA_2 ) < (L1CB_2 - L1CB_1) && overflow0A && increase1B ) return 0;
	292	else if ( (LOCA_2 - LOCA_1) < (max1 - L1CB_1 + L1CB_2) && increase0A && overflow1B ) return 0;
	293	else if ( (max1 - LOCA_1 + LOCA_2 ) < (max1 - L1CB_1 + L1CB_2) && overflow0A && overflow1B ) return 0;
e39e51f6	294
35d1f53b	295	if ( (L1CB_2 - L1CB_1) < (L1CA_2 - L1CA_1) && increase1B && increase1A ) return 0;
	296	else if ( (max1 - L1CB_1 + L1CB_2 ) < (L1CA_2 - L1CA_1) && overflow1B && increase1A ) return 0;
	297	else if ( (L1CB_2 - L1CB_1) < (max1 - L1CA_1 + L1CA_2) && increase1B && overflow1A ) return 0;
	298	else if ( (max1 - L1CB_1 + L1CB_2 ) < (max1 - L1CA_1 + L1CA_2) && overflow1B && overflow1A ) return 0;
e39e51f6	299
35d1f53b	300	if ( (L1CA_2 - L1CA_1) < (L2CB_2 - L2CB_1) && increase1A && increase2B ) return 0;
	301	else if ( (max1 - L1CA_1 + L1CA_2 ) < (L2CB_2 - L2CB_1) && overflow1A && increase2B ) return 0;
	302	else if ( (L1CA_2 - L1CA_1) < (max1 - L2CB_1 + L2CB_2) && increase1A && overflow2B ) return 0;
	303	else if ( (max1 - L1CA_1 + L1CA_2 ) < (max1 - L2CB_1 + L2CB_2) && overflow1A && overflow2B ) return 0;
e39e51f6	304
35d1f53b	305	if ( (L2CB_2 - L2CB_1) < (L2CA_2 - L2CA_1) && increase2B && increase2A ) return 0;
	306	else if ( (max1 - L2CB_1 + L2CB_2 ) < (L2CA_2 - L2CA_1) && overflow2B && increase2A ) return 0;
	307	else if ( (L2CB_2 - L2CB_1) < (max1 - L2CA_1 + L2CA_2) && increase2B && overflow2A ) return 0;
	308	else if ( (max1 - L2CB_1 + L2CB_2 ) < (max1 - L2CA_1 + L2CA_2) && overflow2B && overflow2A ) return 0;
e39e51f6	309
e39e51f6	310	}
	311
	312	return 1;
	313	}
d7dd8a54	314	//_____________________________________________________________________________
	315	void AliTriggerRunScalers::Print( const Option_t* ) const
	316	{
	317	// Print
	318	cout << "Trigger Scalers Record per Run: " << endl;
	319	cout << " File version :" << fVersion << endl;
	320	cout << " Run Number :" << fRunNumber << endl;
	321	cout << " Number of Classes :" << (Int_t)fnClasses << endl;
	322	cout << " Classes ID:";
	323	for( Int_t i=0; i<fnClasses; ++i )
	324	cout << " " << (Int_t)fClassIndex[i];
	325	cout << endl;
	326
	327	for( Int_t i=0; i<fScalersRecord.GetEntriesFast(); ++i )
	328	((AliTriggerScalersRecord*)fScalersRecord.At(i))->Print();
	329	}
	330