[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 "AliTriggerScalersESD.h"
#include "AliTriggerScalersRecord.h"
#include "AliTriggerScalersRecordESD.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(fScalersRecord.GetEntriesFast()-1,kFALSE)) 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   
}
//_____________________________________________________________________________
Int_t AliTriggerRunScalers::ConsistencyCheck(Int_t position,Bool_t correctOverflow)
{
   //Check if counters are consistent(increase). Example: lOCB(n) < lOCB(n+1) and lOCB > lOCA
   // scalers coding 0,1,2,3,4,5=0b,0a,1b,1a,2b,2a
   // returns: 
   //         1 = decresing time 
   //         2 = too big jump in scalers, looks like some readings are missing
   //         3 = (level+1) > (level)
   if (position == 0){
      AliErrorClass("position=0\n");
      return 1;
   }
   UInt_t c2[6], c1[6];
   ULong64_t c64[6]; 
   Bool_t increase[6], overflow[6];  
   for(Int_t i=0;i<6;i++){increase[i]=0;overflow[i]=0;}
   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 1;
   
   AliTriggerScalersRecordESD* recESD = 0;
   if(correctOverflow){
     recESD = new AliTriggerScalersRecordESD();
     recESD->SetTimeStamp(scalers2->GetTimeStamp());
   }
   for( Int_t ic=0; ic<fnClasses; ++ic ){
      TObjArray* scalersArray2 = (TObjArray*)scalers2->GetTriggerScalers();
      AliTriggerScalers* counters2 = (AliTriggerScalers*)scalersArray2->At(ic);
      counters2->GetAllScalers(c2);
      TObjArray* scalersArray1 = (TObjArray*)scalers1->GetTriggerScalers();
      AliTriggerScalers* counters1 = (AliTriggerScalers*)scalersArray1->At(ic);
      counters1->GetAllScalers(c1);

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