[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 <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"

ClassImp( AliTriggerRunScalers )

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

//_____________________________________________________________________________
void AliTriggerRunScalers::AddTriggerScalers( AliTriggerScalersRecord* scaler ) 
{ 
  //
  fScalersRecord.AddLast( scaler ); 
  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     = ((TObjString*)tokens->At(0))->String().Atoi();
    UInt_t period    = ((TObjString*)tokens->At(1))->String().Atoi();
    UInt_t seconds   = ((TObjString*)tokens->At(2))->String().Atoi();
    UInt_t microSecs = ((TObjString*)tokens->At(3))->String().Atoi();
    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 = ((TObjString*)tokens1->At(0))->String().Atoi();
      UInt_t LOCA = ((TObjString*)tokens1->At(1))->String().Atoi();
      UInt_t L1CB = ((TObjString*)tokens1->At(2))->String().Atoi();
      UInt_t L1CA = ((TObjString*)tokens1->At(3))->String().Atoi();
      UInt_t L2CB = ((TObjString*)tokens1->At(4))->String().Atoi();
      UInt_t L2CA = ((TObjString*)tokens1->At(5))->String().Atoi();
      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   
}

//_____________________________________________________________________________
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
d7dd8a54	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	/* $Id: AliTriggerRunScalers.cxx 22322 2007-11-22 11:43:14Z cvetan $ */
	17
	18	///////////////////////////////////////////////////////////////////////////////
	19	//
	20	// Class to define the ALICE Trigger Scalers Record per Run.
	21	//
	22	//
	23	//////////////////////////////////////////////////////////////////////////////
	24
	25	#include <Riostream.h>
	26	#include <TObject.h>
	27	#include <TClass.h>
	28	#include <TArrayC.h>
	29	#include <TSystem.h>
	30	#include <TObjString.h>
	31	#include <TObjArray.h>
	32	#include <TSystem.h>
	33	#include <TFile.h>
	34
	35	#include "AliLog.h"
	36	#include "AliTimeStamp.h"
	37	#include "AliTriggerScalers.h"
	38	#include "AliTriggerScalersRecord.h"
	39	#include "AliTriggerRunScalers.h"
	40
	41	ClassImp( AliTriggerRunScalers )
	42
	43	//_____________________________________________________________________________
	44	AliTriggerRunScalers::AliTriggerRunScalers():
	45	TObject(),
	46	fVersion(0),
	47	fRunNumber(0),
	48	fnClasses(0),
	49	fClassIndex(),
	50	fScalersRecord()
	51	{
	52	// Default constructor
	53	}
	54
	55	//_____________________________________________________________________________
	56	void AliTriggerRunScalers::AddTriggerScalers( AliTriggerScalersRecord* scaler )
	57	{
	58	//
	59	fScalersRecord.AddLast( scaler );
	60	fScalersRecord.Sort();
	61	}
	62
	63	//_____________________________________________________________________________
	64	AliTriggerRunScalers* AliTriggerRunScalers::ReadScalers( TString & filename )
65	{
66
67	if( gSystem->AccessPathName( filename.Data() ) ) {
68	AliErrorClass( Form( "file (%s) not found", filename.Data() ) );
69	return NULL;
70	}
71
72	ifstream *file = new ifstream ( filename.Data() );
73	if (!*file) {
74	AliErrorClass(Form("Error opening file (%s) !\n",filename.Data()));
75	file->close();
76	delete file;
77	return NULL;
78	}
79
80	AliTriggerRunScalers* rScaler = new AliTriggerRunScalers();
81
82	TString strLine;
83	Bool_t verflag = kFALSE;
84	Bool_t classflag = kFALSE;
85	UChar_t nclass = 0;
86	while (strLine.ReadLine(*file)) {
87	if (strLine.BeginsWith("#")) continue;
88
89	TObjArray *tokens = strLine.Tokenize(" \t");
90	Int_t ntokens = tokens->GetEntriesFast();
91	// 1st line, version, it is one number,
92	if (!verflag) {
93	if (ntokens != 1) {
94	AliErrorClass( Form( "Error reading version number from (%s), line :%s\n",
95	filename.Data() , strLine.Data() ) );
96	return NULL;
97	}
98	// cout << "Version "<< ((TObjString*)tokens->At(0))->String().Atoi() << endl;
99	rScaler->SetVersion( ((TObjString*)tokens->At(0))->String().Atoi() );
100	verflag = kTRUE;
101	delete tokens;
102	continue;
103	}
104
105	// 2nd line, run number , number of classes, list of classes used in this partition
106
107	if (!classflag) {
108	if ( !((TObjString*)tokens->At(1))->String().IsDigit() ) {
109	AliErrorClass( Form( "Error reading Run number from (%s)\n", filename.Data() ));
110	}
111	// cout << "Run Number " << ((TObjString*)tokens->At(0))->String().Atoi() << endl;
112	rScaler->SetRunNumber( ((TObjString*)tokens->At(0))->String().Atoi() );
113	nclass = (UChar_t)((TObjString*)tokens->At(1))->String().Atoi();
114	// cout << "Number of classes " << nclass << endl;
115	rScaler->SetNumClasses( nclass );
116	if ( nclass != ntokens - 2 ) {
117	AliErrorClass( Form( "Error reading number of classes from (%s)\n", filename.Data() ));
118	}
119	for (UChar_t i=0; i<nclass; ++i) {
120	rScaler->SetClass( i, (Char_t)((TObjString*)tokens->At(2+i))->String().Atoi() );
121	}
122	classflag = kTRUE;
123	delete tokens;
124	continue;
125	}
126
127	// Records
128	// Each record consists of 1+(number of classes in partition) lines
129	// 1st line of record = time stamp (4 words)
130	// 1st word = ORBIT(24 bits)
131	// 2nd word = Period Counter (28 bit)
132	// 3rd word = seconds (32 bits) from epoch
133	// 4th word = microsecs (32 bits)
134	// other lines = 6 words of counters (L0 before,L0 after, ....)
135	if (ntokens != 4) {
136	AliErrorClass( Form( "Error reading timestamp from (%s): line (%s)",
137	filename.Data(), strLine.Data() ));
138	return NULL;
139	}
140	UInt_t orbit = ((TObjString*)tokens->At(0))->String().Atoi();
141	UInt_t period = ((TObjString*)tokens->At(1))->String().Atoi();
142	UInt_t seconds = ((TObjString*)tokens->At(2))->String().Atoi();
143	UInt_t microSecs = ((TObjString*)tokens->At(3))->String().Atoi();
144	AliTriggerScalersRecord * rec = new AliTriggerScalersRecord();
145	rec->SetTimeStamp( orbit, period, seconds, microSecs );
146
147	TString strLine1;
148	for (Int_t i=0; i<nclass; ++i) {
149	strLine1.ReadLine(*file);
150	if (strLine1.BeginsWith("#")) continue;
151	TObjArray *tokens1 = strLine1.Tokenize(" \t");
152	Int_t ntokens1 = tokens1->GetEntriesFast();
153	if( ntokens1 != 6 ) {
29bdda4f	154	AliErrorClass( Form( "Error reading scalers from (%s): line (%s)",
	155	filename.Data(), strLine1.Data() ));
	156	delete rec;
	157	return rScaler;
d7dd8a54	158	}
	159	UInt_t LOCB = ((TObjString*)tokens1->At(0))->String().Atoi();
	160	UInt_t LOCA = ((TObjString*)tokens1->At(1))->String().Atoi();
	161	UInt_t L1CB = ((TObjString*)tokens1->At(2))->String().Atoi();
	162	UInt_t L1CA = ((TObjString*)tokens1->At(3))->String().Atoi();
	163	UInt_t L2CB = ((TObjString*)tokens1->At(4))->String().Atoi();
	164	UInt_t L2CA = ((TObjString*)tokens1->At(5))->String().Atoi();
	165	rScaler->GetClass(i);
	166	rec->AddTriggerScalers( rScaler->GetClass(i),
	167	LOCB, LOCA, L1CB,
	168	L1CA, L2CB, L2CA );
	169	delete tokens1;
	170	}
	171	rScaler->AddTriggerScalers( rec );
	172
	173	delete tokens;
	174	}
	175	file->close();
	176	delete file;
	177
	178	return rScaler;
	179	}
	180
	181	//_____________________________________________________________________________
	182	Int_t AliTriggerRunScalers::FindNearestScalersRecord( AliTimeStamp * stamp )
	183	{
	184	// Find Trigger scaler record with the closest timestamp <= "stamp"
	185	// using a binary search.
	186	// return the index in the array of records, if the timestamp
	187	// is out of range return -1
	188
	189	Int_t base, position=-1, last, result = 0;
	190	AliTimeStamp *op2 = NULL;
	191
	192	fScalersRecord.Sort();
	193
	194	base = 0;
	195	last = fScalersRecord.GetEntriesFast();
	196
	197	while (last >= base) {
	198	position = (base+last) / 2;
	199	cout << "pos " << position<< " base " << base << "last " << last << endl;
	200	AliTriggerScalersRecord* rec = (AliTriggerScalersRecord*)fScalersRecord.At(position);
	201	if( rec ) op2 = rec->GetTimeStamp();
	202	if( op2 && (result = stamp->Compare(op2)) == 0 )
	203	return position; // exact match
	204	cout << "result " << result << " op2 " << op2 << " rec "<< rec << endl;
	205	if (!op2 \|\| result < 0)
	206	last = position-1;
	207	else
	208	base = position+1;
	209	op2 = NULL;
	210	}
	211	if( (position == 0 && result < 0) \|\| position >= fScalersRecord.GetEntriesFast() )
	212	return -1; // out of range
	213	else
	214	return (result < 0 ) ? position-1 : position; // nearst < stamp
	215	}
	216
	217	//_____________________________________________________________________________
	218	void AliTriggerRunScalers::Print( const Option_t* ) const
	219	{
	220	// Print
	221	cout << "Trigger Scalers Record per Run: " << endl;
222	cout << " File version :" << fVersion << endl;
223	cout << " Run Number :" << fRunNumber << endl;
224	cout << " Number of Classes :" << (Int_t)fnClasses << endl;
225	cout << " Classes ID:";
226	for( Int_t i=0; i<fnClasses; ++i )
227	cout << " " << (Int_t)fClassIndex[i];
228	cout << endl;
229
230	for( Int_t i=0; i<fScalersRecord.GetEntriesFast(); ++i )
231	((AliTriggerScalersRecord*)fScalersRecord.At(i))->Print();
232	}
233