[u/mrichter/AliRoot.git] / STEER / ESD / AliESDHeader.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.                  *
 **************************************************************************/

//-------------------------------------------------------------------------
//                      Implementation of   Class AliESDHeader
//   Header data
//   for the ESD   
//   Origin: Christian Klein-Boesing, CERN, Christian.Klein-Boesing@cern.ch 
//-------------------------------------------------------------------------

#include "AliESDHeader.h"
#include "AliTriggerScalersESD.h"
#include "AliTriggerScalersRecordESD.h"
#include "AliTriggerIR.h"
#include "AliTriggerConfiguration.h"
#include "AliLog.h" 

ClassImp(AliESDHeader)

//______________________________________________________________________________
AliESDHeader::AliESDHeader() :
  AliVHeader(),
  fTriggerMask(0),
  fOrbitNumber(0),
  fTimeStamp(0),
  fEventType(0),
  fEventSpecie(0),
  fPeriodNumber(0),
  fEventNumberInFile(0),
  fBunchCrossNumber(0),
  fTriggerCluster(0),
  fL0TriggerInputs(0),
  fL1TriggerInputs(0),
  fL2TriggerInputs(0),
  fTriggerScalers(),
  fTriggerScalersDeltaEvent(),
  fTriggerScalersDeltaRun(),
  fTriggerInputsNames(kNTriggerInputs),
  fCTPConfig(NULL),
  fIRBufferArray()
{
  // default constructor

  SetName("AliESDHeader");
  for(Int_t i = 0; i<kNMaxIR ; i++) fIRArray[i] = 0;
  fTriggerInputsNames.SetOwner(kTRUE);
}

AliESDHeader::~AliESDHeader() 
{
  // destructor
  for(Int_t i=0;i<kNMaxIR;i++)if(fIRArray[i])delete fIRArray[i];
  delete fCTPConfig;

  fIRBufferArray.Delete();
}


AliESDHeader::AliESDHeader(const AliESDHeader &header) :
  AliVHeader(header),
  fTriggerMask(header.fTriggerMask),
  fOrbitNumber(header.fOrbitNumber),
  fTimeStamp(header.fTimeStamp),
  fEventType(header.fEventType),
  fEventSpecie(header.fEventSpecie),
  fPeriodNumber(header.fPeriodNumber),
  fEventNumberInFile(header.fEventNumberInFile),
  fBunchCrossNumber(header.fBunchCrossNumber),
  fTriggerCluster(header.fTriggerCluster),
  fL0TriggerInputs(header.fL0TriggerInputs),
  fL1TriggerInputs(header.fL1TriggerInputs),
  fL2TriggerInputs(header.fL2TriggerInputs),
  fTriggerScalers(header.fTriggerScalers),
  fTriggerScalersDeltaEvent(header.fTriggerScalersDeltaEvent),
  fTriggerScalersDeltaRun(header.fTriggerScalersDeltaRun),
  fTriggerInputsNames(TObjArray(kNTriggerInputs)),
  fCTPConfig(header.fCTPConfig),
  fIRBufferArray()
{
  // copy constructor
  SetName(header.fName);
  SetTitle(header.fTitle);
  for(Int_t i = 0; i<kNMaxIR ; i++) {
    if(header.fIRArray[i])fIRArray[i] = new AliTriggerIR(*header.fIRArray[i]);
    else fIRArray[i]=0;
  }
  for(Int_t i = 0; i < kNTriggerInputs; i++) {
    TNamed *str = (TNamed *)((header.fTriggerInputsNames).At(i));
    if (str) fTriggerInputsNames.AddAt(new TNamed(*str),i);
  }

  for(Int_t i = 0; i < (header.fIRBufferArray).GetEntries(); ++i) {
    AliTriggerIR *ir = (AliTriggerIR*)((header.fIRBufferArray).At(i));
    if (ir) fIRBufferArray.Add(new AliTriggerIR(*ir));
  }
}

AliESDHeader& AliESDHeader::operator=(const AliESDHeader &header)
{ 
  // assigment operator
  if(this!=&header) {
    AliVHeader::operator=(header);
    fTriggerMask = header.fTriggerMask;
    fOrbitNumber = header.fOrbitNumber;
    fTimeStamp = header.fTimeStamp;
    fEventType = header.fEventType;
    fEventSpecie = header.fEventSpecie;
    fPeriodNumber = header.fPeriodNumber;
    fEventNumberInFile = header.fEventNumberInFile;
    fBunchCrossNumber = header.fBunchCrossNumber;
    fTriggerCluster = header.fTriggerCluster;
    fL0TriggerInputs = header.fL0TriggerInputs;
    fL1TriggerInputs = header.fL1TriggerInputs;
    fL2TriggerInputs = header.fL2TriggerInputs;
    fTriggerScalers = header.fTriggerScalers;
    fTriggerScalersDeltaEvent = header.fTriggerScalersDeltaEvent;
    fTriggerScalersDeltaRun = header.fTriggerScalersDeltaRun;
    fCTPConfig = header.fCTPConfig;

    fTriggerInputsNames.Clear();
    for(Int_t i = 0; i < kNTriggerInputs; i++) {
      TNamed *str = (TNamed *)((header.fTriggerInputsNames).At(i));
      if (str) fTriggerInputsNames.AddAt(new TNamed(*str),i);
    }
    for(Int_t i = 0; i<kNMaxIR ; i++) {
       if(header.fIRArray[i])fIRArray[i] = new AliTriggerIR(*header.fIRArray[i]);
       else fIRArray[i]=0;
    }
    SetName(header.fName);
    SetTitle(header.fTitle);

    fIRBufferArray.Delete();
    for(Int_t i = 0; i < (header.fIRBufferArray).GetEntries(); ++i) {
      AliTriggerIR *ir = (AliTriggerIR*)((header.fIRBufferArray).At(i));
      if (ir) fIRBufferArray.Add(new AliTriggerIR(*ir));
    }
  }
  return *this;
}

void AliESDHeader::Copy(TObject &obj) const 
{  
  // this overwrites the virtual TOBject::Copy()
  // to allow run time copying without casting
  // in AliESDEvent

  if(this==&obj)return;
  AliESDHeader *robj = dynamic_cast<AliESDHeader*>(&obj);
  if(!robj)return; // not an AliESDHeader
  *robj = *this;

}
//______________________________________________________________________________
void AliESDHeader::Reset()
{
  // reset all data members
  fTriggerMask       = 0;
  fOrbitNumber       = 0;
  fTimeStamp         = 0;
  fEventType         = 0;
  fEventSpecie       = 0;
  fPeriodNumber      = 0;
  fEventNumberInFile = 0;
  fBunchCrossNumber  = 0;
  fTriggerCluster    = 0;
  fL0TriggerInputs   = 0;
  fL1TriggerInputs   = 0;
  fL2TriggerInputs   = 0;
  fTriggerScalers.Reset();
  fTriggerScalersDeltaEvent.Reset();
  fTriggerScalersDeltaRun.Reset();
  fTriggerInputsNames.Clear();
  delete fCTPConfig;
  fCTPConfig = 0;
  for(Int_t i=0;i<kNMaxIR;i++)if(fIRArray[i]){
   delete fIRArray[i];
   fIRArray[i]=0;
  }

  fIRBufferArray.Delete();
}
//______________________________________________________________________________
Bool_t AliESDHeader::AddTriggerIR(const AliTriggerIR* ir)
{
  // Add an IR object into the array
  // of IRs in the ESD header

 fIRBufferArray.Add(new AliTriggerIR(*ir));

 return kTRUE;
}
//______________________________________________________________________________
void AliESDHeader::Print(const Option_t *) const
{
  // Print some data members
  printf("Event # %d in file Bunch crossing # %d Orbit # %d Trigger %lld \n",
	 GetEventNumberInFile(),
	 GetBunchCrossNumber(),
	 GetOrbitNumber(),
	 GetTriggerMask());
         printf("List of the active trigger inputs: ");
  	 for(Int_t i = 0; i < kNTriggerInputs; i++) {
    	   TNamed *str = (TNamed *)((fTriggerInputsNames).At(i));
    	   if (str) printf("%s ",str->GetName());
         }
         printf("\n");
}

//______________________________________________________________________________
void AliESDHeader::SetActiveTriggerInputs(const char*name, Int_t index)
{
  // Fill the active trigger inputs names
  // into the corresponding fTriggerInputsNames (TObjArray of TNamed)
  if (index >= kNTriggerInputs || index < 0) {
    AliError(Form("Index (%d) is outside the allowed range (0,59)!",index));
    return;
  }

  fTriggerInputsNames.AddAt(new TNamed(name,NULL),index);
}
//______________________________________________________________________________
const char* AliESDHeader::GetTriggerInputName(Int_t index, Int_t trglevel) const
{
  // Get the trigger input name
  // at the specified position in the trigger mask and trigger level (0,1,2)
  TNamed *trginput = 0;
  if (trglevel == 0) trginput = (TNamed *)fTriggerInputsNames.At(index);
  if (trglevel == 1) trginput = (TNamed *)fTriggerInputsNames.At(index+24);  
  if (trglevel == 2) trginput = (TNamed *)fTriggerInputsNames.At(index+48); 
  if (trginput) return trginput->GetName();
  else return "";
}
//______________________________________________________________________________
TString AliESDHeader::GetActiveTriggerInputs() const
{
  // Returns the list with the names of the active trigger inputs
  TString trginputs;
  for(Int_t i = 0; i < kNTriggerInputs; i++) {
    TNamed *str = (TNamed *)((fTriggerInputsNames).At(i));
    if (str) {
      trginputs += " ";
      trginputs += str->GetName();
      trginputs += " ";
    }
  }

  return trginputs;
}
//______________________________________________________________________________
TString AliESDHeader::GetFiredTriggerInputs() const
{
  // Returns the list with the names of the fired trigger inputs
  TString trginputs;
  for(Int_t i = 0; i < kNTriggerInputs; i++) {
      TNamed *str = (TNamed *)((fTriggerInputsNames.At(i)));
      if (i < 24 && (fL0TriggerInputs & (1 << i))) {
        if (str) {
	  trginputs += " ";
	  trginputs += str->GetName();
          trginputs += " ";
        }
      }
      if (i >= 24 && i < 48 && (fL1TriggerInputs & (1 << (i-24)))) {
        if (str) {
	  trginputs += " ";
	  trginputs += str->GetName();
          trginputs += " ";
        }
      }
      if (i >= 48 && (fL2TriggerInputs & (1 << (i-48)))) {
        if (str) {
	  trginputs += " ";
	  trginputs += str->GetName();
          trginputs += " ";
        }
      }

  }
  return trginputs;
}
//______________________________________________________________________________
Bool_t AliESDHeader::IsTriggerInputFired(const char *name) const
{
  // Checks if the trigger input is fired 
 
  TNamed *trginput = (TNamed *)fTriggerInputsNames.FindObject(name);
  if (!trginput) return kFALSE;

  Int_t inputIndex = fTriggerInputsNames.IndexOf(trginput);
  if (inputIndex < 0) return kFALSE;
  
  if (fL0TriggerInputs & (1 << inputIndex)) return kTRUE;
  else if (fL1TriggerInputs & (1 << (inputIndex-24))) return kTRUE;
  else if (fL2TriggerInputs & (1 << (inputIndex-48))) return kTRUE;
  else return kFALSE;
}
Commit	Line	Data
d5ebf00e	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	//-------------------------------------------------------------------------
	17	// Implementation of Class AliESDHeader
	18	// Header data
	19	// for the ESD
	20	// Origin: Christian Klein-Boesing, CERN, Christian.Klein-Boesing@cern.ch
	21	//-------------------------------------------------------------------------
	22
	23	#include "AliESDHeader.h"
bf1f98c4	24	#include "AliTriggerScalersESD.h"
bf1f98c4	25	#include "AliTriggerScalersRecordESD.h"
8258ca76	26	#include "AliTriggerIR.h"
5aef203e	27	#include "AliTriggerConfiguration.h"
b7b66e38	28	#include "AliLog.h"
d5ebf00e	29
	30	ClassImp(AliESDHeader)
	31
	32	//______________________________________________________________________________
	33	AliESDHeader::AliESDHeader() :
9ae2e5e6	34	AliVHeader(),
d5ebf00e	35	fTriggerMask(0),
	36	fOrbitNumber(0),
	37	fTimeStamp(0),
	38	fEventType(0),
fd2e2210	39	fEventSpecie(0),
4f036e6e	40	fPeriodNumber(0),
d5ebf00e	41	fEventNumberInFile(0),
d5ebf00e	42	fBunchCrossNumber(0),
53eef471	43	fTriggerCluster(0),
	44	fL0TriggerInputs(0),
	45	fL1TriggerInputs(0),
bf1f98c4	46	fL2TriggerInputs(0),
6ef9caeb	47	fTriggerScalers(),
d789992f	48	fTriggerScalersDeltaEvent(),
	49	fTriggerScalersDeltaRun(),
	50	fTriggerInputsNames(kNTriggerInputs),
96bf4ffc	51	fCTPConfig(NULL),
96bf4ffc	52	fIRBufferArray()
d5ebf00e	53	{
9ae2e5e6	54	// default constructor
	55
	56	SetName("AliESDHeader");
c47cda51	57	for(Int_t i = 0; i<kNMaxIR ; i++) fIRArray[i] = 0;
6ef9caeb	58	fTriggerInputsNames.SetOwner(kTRUE);
9ae2e5e6	59	}
d789992f	60
9ae2e5e6	61	AliESDHeader::~AliESDHeader()
	62	{
	63	// destructor
c47cda51	64	for(Int_t i=0;i<kNMaxIR;i++)if(fIRArray[i])delete fIRArray[i];
d789992f	65	delete fCTPConfig;
96bf4ffc	66
96bf4ffc	67	fIRBufferArray.Delete();
d5ebf00e	68	}
	69
	70
	71	AliESDHeader::AliESDHeader(const AliESDHeader &header) :
9ae2e5e6	72	AliVHeader(header),
d5ebf00e	73	fTriggerMask(header.fTriggerMask),
	74	fOrbitNumber(header.fOrbitNumber),
	75	fTimeStamp(header.fTimeStamp),
	76	fEventType(header.fEventType),
fd2e2210	77	fEventSpecie(header.fEventSpecie),
4f036e6e	78	fPeriodNumber(header.fPeriodNumber),
d5ebf00e	79	fEventNumberInFile(header.fEventNumberInFile),
d5ebf00e	80	fBunchCrossNumber(header.fBunchCrossNumber),
53eef471	81	fTriggerCluster(header.fTriggerCluster),
	82	fL0TriggerInputs(header.fL0TriggerInputs),
	83	fL1TriggerInputs(header.fL1TriggerInputs),
bf1f98c4	84	fL2TriggerInputs(header.fL2TriggerInputs),
6ef9caeb	85	fTriggerScalers(header.fTriggerScalers),
d789992f	86	fTriggerScalersDeltaEvent(header.fTriggerScalersDeltaEvent),
	87	fTriggerScalersDeltaRun(header.fTriggerScalersDeltaRun),
	88	fTriggerInputsNames(TObjArray(kNTriggerInputs)),
96bf4ffc	89	fCTPConfig(header.fCTPConfig),
96bf4ffc	90	fIRBufferArray()
d5ebf00e	91	{
d5ebf00e	92	// copy constructor
9ae2e5e6	93	SetName(header.fName);
9ae2e5e6	94	SetTitle(header.fTitle);
c47cda51	95	for(Int_t i = 0; i<kNMaxIR ; i++) {
	96	if(header.fIRArray[i])fIRArray[i] = new AliTriggerIR(*header.fIRArray[i]);
	97	else fIRArray[i]=0;
	98	}
6ef9caeb	99	for(Int_t i = 0; i < kNTriggerInputs; i++) {
	100	TNamed str = (TNamed )((header.fTriggerInputsNames).At(i));
	101	if (str) fTriggerInputsNames.AddAt(new TNamed(*str),i);
	102	}
96bf4ffc	103
	104	for(Int_t i = 0; i < (header.fIRBufferArray).GetEntries(); ++i) {
	105	AliTriggerIR ir = (AliTriggerIR)((header.fIRBufferArray).At(i));
	106	if (ir) fIRBufferArray.Add(new AliTriggerIR(*ir));
	107	}
d5ebf00e	108	}
	109
	110	AliESDHeader& AliESDHeader::operator=(const AliESDHeader &header)
	111	{
	112	// assigment operator
	113	if(this!=&header) {
9ae2e5e6	114	AliVHeader::operator=(header);
d5ebf00e	115	fTriggerMask = header.fTriggerMask;
	116	fOrbitNumber = header.fOrbitNumber;
	117	fTimeStamp = header.fTimeStamp;
	118	fEventType = header.fEventType;
fd2e2210	119	fEventSpecie = header.fEventSpecie;
4f036e6e	120	fPeriodNumber = header.fPeriodNumber;
d5ebf00e	121	fEventNumberInFile = header.fEventNumberInFile;
	122	fBunchCrossNumber = header.fBunchCrossNumber;
	123	fTriggerCluster = header.fTriggerCluster;
53eef471	124	fL0TriggerInputs = header.fL0TriggerInputs;
	125	fL1TriggerInputs = header.fL1TriggerInputs;
	126	fL2TriggerInputs = header.fL2TriggerInputs;
bf1f98c4	127	fTriggerScalers = header.fTriggerScalers;
d789992f	128	fTriggerScalersDeltaEvent = header.fTriggerScalersDeltaEvent;
	129	fTriggerScalersDeltaRun = header.fTriggerScalersDeltaRun;
	130	fCTPConfig = header.fCTPConfig;
	131
6ef9caeb	132	fTriggerInputsNames.Clear();
	133	for(Int_t i = 0; i < kNTriggerInputs; i++) {
	134	TNamed str = (TNamed )((header.fTriggerInputsNames).At(i));
	135	if (str) fTriggerInputsNames.AddAt(new TNamed(*str),i);
	136	}
c47cda51	137	for(Int_t i = 0; i<kNMaxIR ; i++) {
	138	if(header.fIRArray[i])fIRArray[i] = new AliTriggerIR(*header.fIRArray[i]);
	139	else fIRArray[i]=0;
	140	}
4f036e6e	141	SetName(header.fName);
4f036e6e	142	SetTitle(header.fTitle);
96bf4ffc	143
	144	fIRBufferArray.Delete();
	145	for(Int_t i = 0; i < (header.fIRBufferArray).GetEntries(); ++i) {
	146	AliTriggerIR ir = (AliTriggerIR)((header.fIRBufferArray).At(i));
	147	if (ir) fIRBufferArray.Add(new AliTriggerIR(*ir));
	148	}
d789992f	149	}
d5ebf00e	150	return *this;
	151	}
	152
bf1f98c4	153	void AliESDHeader::Copy(TObject &obj) const
bf1f98c4	154	{
732a24fe	155	// this overwrites the virtual TOBject::Copy()
	156	// to allow run time copying without casting
	157	// in AliESDEvent
	158
	159	if(this==&obj)return;
	160	AliESDHeader robj = dynamic_cast<AliESDHeader>(&obj);
	161	if(!robj)return; // not an AliESDHeader
	162	robj = this;
	163
	164	}
d5ebf00e	165	//______________________________________________________________________________
	166	void AliESDHeader::Reset()
	167	{
	168	// reset all data members
	169	fTriggerMask = 0;
	170	fOrbitNumber = 0;
	171	fTimeStamp = 0;
	172	fEventType = 0;
fd2e2210	173	fEventSpecie = 0;
4f036e6e	174	fPeriodNumber = 0;
d5ebf00e	175	fEventNumberInFile = 0;
	176	fBunchCrossNumber = 0;
	177	fTriggerCluster = 0;
53eef471	178	fL0TriggerInputs = 0;
	179	fL1TriggerInputs = 0;
	180	fL2TriggerInputs = 0;
bf1f98c4	181	fTriggerScalers.Reset();
d789992f	182	fTriggerScalersDeltaEvent.Reset();
d789992f	183	fTriggerScalersDeltaRun.Reset();
6ef9caeb	184	fTriggerInputsNames.Clear();
d789992f	185	delete fCTPConfig;
d789992f	186	fCTPConfig = 0;
c47cda51	187	for(Int_t i=0;i<kNMaxIR;i++)if(fIRArray[i]){
	188	delete fIRArray[i];
	189	fIRArray[i]=0;
	190	}
96bf4ffc	191
96bf4ffc	192	fIRBufferArray.Delete();
d5ebf00e	193	}
76a7c65b	194	//______________________________________________________________________________
c47cda51	195	Bool_t AliESDHeader::AddTriggerIR(const AliTriggerIR* ir)
76a7c65b	196	{
96bf4ffc	197	// Add an IR object into the array
	198	// of IRs in the ESD header
	199
	200	fIRBufferArray.Add(new AliTriggerIR(*ir));
	201
	202	return kTRUE;
76a7c65b	203	}
d5ebf00e	204	//______________________________________________________________________________
	205	void AliESDHeader::Print(const Option_t *) const
	206	{
	207	// Print some data members
	208	printf("Event # %d in file Bunch crossing # %d Orbit # %d Trigger %lld \n",
	209	GetEventNumberInFile(),
	210	GetBunchCrossNumber(),
	211	GetOrbitNumber(),
	212	GetTriggerMask());
6ef9caeb	213	printf("List of the active trigger inputs: ");
	214	for(Int_t i = 0; i < kNTriggerInputs; i++) {
	215	TNamed str = (TNamed )((fTriggerInputsNames).At(i));
	216	if (str) printf("%s ",str->GetName());
	217	}
	218	printf("\n");
	219	}
	220
6ef9caeb	221	//______________________________________________________________________________
	222	void AliESDHeader::SetActiveTriggerInputs(const char*name, Int_t index)
	223	{
	224	// Fill the active trigger inputs names
	225	// into the corresponding fTriggerInputsNames (TObjArray of TNamed)
	226	if (index >= kNTriggerInputs \|\| index < 0) {
	227	AliError(Form("Index (%d) is outside the allowed range (0,59)!",index));
	228	return;
	229	}
	230
	231	fTriggerInputsNames.AddAt(new TNamed(name,NULL),index);
	232	}
	233	//______________________________________________________________________________
	234	const char* AliESDHeader::GetTriggerInputName(Int_t index, Int_t trglevel) const
	235	{
	236	// Get the trigger input name
	237	// at the specified position in the trigger mask and trigger level (0,1,2)
	238	TNamed *trginput = 0;
	239	if (trglevel == 0) trginput = (TNamed *)fTriggerInputsNames.At(index);
	240	if (trglevel == 1) trginput = (TNamed *)fTriggerInputsNames.At(index+24);
	241	if (trglevel == 2) trginput = (TNamed *)fTriggerInputsNames.At(index+48);
	242	if (trginput) return trginput->GetName();
	243	else return "";
d5ebf00e	244	}
6ef9caeb	245	//______________________________________________________________________________
	246	TString AliESDHeader::GetActiveTriggerInputs() const
	247	{
	248	// Returns the list with the names of the active trigger inputs
	249	TString trginputs;
	250	for(Int_t i = 0; i < kNTriggerInputs; i++) {
	251	TNamed str = (TNamed )((fTriggerInputsNames).At(i));
	252	if (str) {
	253	trginputs += " ";
	254	trginputs += str->GetName();
	255	trginputs += " ";
	256	}
	257	}
	258
	259	return trginputs;
	260	}
	261	//______________________________________________________________________________
	262	TString AliESDHeader::GetFiredTriggerInputs() const
	263	{
	264	// Returns the list with the names of the fired trigger inputs
	265	TString trginputs;
	266	for(Int_t i = 0; i < kNTriggerInputs; i++) {
	267	TNamed str = (TNamed )((fTriggerInputsNames.At(i)));
	268	if (i < 24 && (fL0TriggerInputs & (1 << i))) {
	269	if (str) {
	270	trginputs += " ";
	271	trginputs += str->GetName();
	272	trginputs += " ";
	273	}
	274	}
d999f2e6	275	if (i >= 24 && i < 48 && (fL1TriggerInputs & (1 << (i-24)))) {
6ef9caeb	276	if (str) {
	277	trginputs += " ";
	278	trginputs += str->GetName();
	279	trginputs += " ";
	280	}
	281	}
d999f2e6	282	if (i >= 48 && (fL2TriggerInputs & (1 << (i-48)))) {
6ef9caeb	283	if (str) {
	284	trginputs += " ";
	285	trginputs += str->GetName();
	286	trginputs += " ";
	287	}
	288	}
d5ebf00e	289
6ef9caeb	290	}
	291	return trginputs;
	292	}
	293	//______________________________________________________________________________
	294	Bool_t AliESDHeader::IsTriggerInputFired(const char *name) const
	295	{
	296	// Checks if the trigger input is fired
	297
	298	TNamed trginput = (TNamed )fTriggerInputsNames.FindObject(name);
	299	if (!trginput) return kFALSE;
	300
	301	Int_t inputIndex = fTriggerInputsNames.IndexOf(trginput);
	302	if (inputIndex < 0) return kFALSE;
	303
	304	if (fL0TriggerInputs & (1 << inputIndex)) return kTRUE;
	305	else if (fL1TriggerInputs & (1 << (inputIndex-24))) return kTRUE;
	306	else if (fL2TriggerInputs & (1 << (inputIndex-48))) return kTRUE;
	307	else return kFALSE;
	308	}