[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
  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;
    delete fCTPConfig;
    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++) {
      delete fIRArray[i];
       if(header.fIRArray[i])fIRArray[i] = new AliTriggerIR(*header.fIRArray[i]);
       else fIRArray[i]=0;
    }

    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
c47cda51	93	for(Int_t i = 0; i<kNMaxIR ; i++) {
	94	if(header.fIRArray[i])fIRArray[i] = new AliTriggerIR(*header.fIRArray[i]);
	95	else fIRArray[i]=0;
	96	}
6ef9caeb	97	for(Int_t i = 0; i < kNTriggerInputs; i++) {
	98	TNamed str = (TNamed )((header.fTriggerInputsNames).At(i));
	99	if (str) fTriggerInputsNames.AddAt(new TNamed(*str),i);
	100	}
96bf4ffc	101
	102	for(Int_t i = 0; i < (header.fIRBufferArray).GetEntries(); ++i) {
	103	AliTriggerIR ir = (AliTriggerIR)((header.fIRBufferArray).At(i));
	104	if (ir) fIRBufferArray.Add(new AliTriggerIR(*ir));
	105	}
d5ebf00e	106	}
	107
	108	AliESDHeader& AliESDHeader::operator=(const AliESDHeader &header)
	109	{
	110	// assigment operator
	111	if(this!=&header) {
9ae2e5e6	112	AliVHeader::operator=(header);
d5ebf00e	113	fTriggerMask = header.fTriggerMask;
	114	fOrbitNumber = header.fOrbitNumber;
	115	fTimeStamp = header.fTimeStamp;
	116	fEventType = header.fEventType;
fd2e2210	117	fEventSpecie = header.fEventSpecie;
4f036e6e	118	fPeriodNumber = header.fPeriodNumber;
d5ebf00e	119	fEventNumberInFile = header.fEventNumberInFile;
	120	fBunchCrossNumber = header.fBunchCrossNumber;
	121	fTriggerCluster = header.fTriggerCluster;
53eef471	122	fL0TriggerInputs = header.fL0TriggerInputs;
	123	fL1TriggerInputs = header.fL1TriggerInputs;
	124	fL2TriggerInputs = header.fL2TriggerInputs;
bf1f98c4	125	fTriggerScalers = header.fTriggerScalers;
d789992f	126	fTriggerScalersDeltaEvent = header.fTriggerScalersDeltaEvent;
d789992f	127	fTriggerScalersDeltaRun = header.fTriggerScalersDeltaRun;
481acdb5	128	delete fCTPConfig;
d789992f	129	fCTPConfig = header.fCTPConfig;
d789992f	130
6ef9caeb	131	fTriggerInputsNames.Clear();
	132	for(Int_t i = 0; i < kNTriggerInputs; i++) {
	133	TNamed str = (TNamed )((header.fTriggerInputsNames).At(i));
	134	if (str) fTriggerInputsNames.AddAt(new TNamed(*str),i);
	135	}
c47cda51	136	for(Int_t i = 0; i<kNMaxIR ; i++) {
481acdb5	137	delete fIRArray[i];
c47cda51	138	if(header.fIRArray[i])fIRArray[i] = new AliTriggerIR(*header.fIRArray[i]);
	139	else fIRArray[i]=0;
	140	}
96bf4ffc	141
	142	fIRBufferArray.Delete();
	143	for(Int_t i = 0; i < (header.fIRBufferArray).GetEntries(); ++i) {
	144	AliTriggerIR ir = (AliTriggerIR)((header.fIRBufferArray).At(i));
	145	if (ir) fIRBufferArray.Add(new AliTriggerIR(*ir));
	146	}
d789992f	147	}
d5ebf00e	148	return *this;
	149	}
	150
bf1f98c4	151	void AliESDHeader::Copy(TObject &obj) const
bf1f98c4	152	{
732a24fe	153	// this overwrites the virtual TOBject::Copy()
	154	// to allow run time copying without casting
	155	// in AliESDEvent
	156
	157	if(this==&obj)return;
	158	AliESDHeader robj = dynamic_cast<AliESDHeader>(&obj);
	159	if(!robj)return; // not an AliESDHeader
	160	robj = this;
	161
	162	}
d5ebf00e	163	//______________________________________________________________________________
	164	void AliESDHeader::Reset()
	165	{
	166	// reset all data members
	167	fTriggerMask = 0;
	168	fOrbitNumber = 0;
	169	fTimeStamp = 0;
	170	fEventType = 0;
fd2e2210	171	fEventSpecie = 0;
4f036e6e	172	fPeriodNumber = 0;
d5ebf00e	173	fEventNumberInFile = 0;
	174	fBunchCrossNumber = 0;
	175	fTriggerCluster = 0;
53eef471	176	fL0TriggerInputs = 0;
	177	fL1TriggerInputs = 0;
	178	fL2TriggerInputs = 0;
bf1f98c4	179	fTriggerScalers.Reset();
d789992f	180	fTriggerScalersDeltaEvent.Reset();
d789992f	181	fTriggerScalersDeltaRun.Reset();
6ef9caeb	182	fTriggerInputsNames.Clear();
d789992f	183	delete fCTPConfig;
d789992f	184	fCTPConfig = 0;
c47cda51	185	for(Int_t i=0;i<kNMaxIR;i++)if(fIRArray[i]){
	186	delete fIRArray[i];
	187	fIRArray[i]=0;
	188	}
96bf4ffc	189
96bf4ffc	190	fIRBufferArray.Delete();
d5ebf00e	191	}
76a7c65b	192	//______________________________________________________________________________
c47cda51	193	Bool_t AliESDHeader::AddTriggerIR(const AliTriggerIR* ir)
76a7c65b	194	{
96bf4ffc	195	// Add an IR object into the array
	196	// of IRs in the ESD header
	197
	198	fIRBufferArray.Add(new AliTriggerIR(*ir));
	199
	200	return kTRUE;
76a7c65b	201	}
d5ebf00e	202	//______________________________________________________________________________
	203	void AliESDHeader::Print(const Option_t *) const
	204	{
	205	// Print some data members
	206	printf("Event # %d in file Bunch crossing # %d Orbit # %d Trigger %lld \n",
	207	GetEventNumberInFile(),
	208	GetBunchCrossNumber(),
	209	GetOrbitNumber(),
	210	GetTriggerMask());
6ef9caeb	211	printf("List of the active trigger inputs: ");
	212	for(Int_t i = 0; i < kNTriggerInputs; i++) {
	213	TNamed str = (TNamed )((fTriggerInputsNames).At(i));
	214	if (str) printf("%s ",str->GetName());
	215	}
	216	printf("\n");
	217	}
	218
6ef9caeb	219	//______________________________________________________________________________
	220	void AliESDHeader::SetActiveTriggerInputs(const char*name, Int_t index)
	221	{
	222	// Fill the active trigger inputs names
	223	// into the corresponding fTriggerInputsNames (TObjArray of TNamed)
	224	if (index >= kNTriggerInputs \|\| index < 0) {
	225	AliError(Form("Index (%d) is outside the allowed range (0,59)!",index));
	226	return;
	227	}
	228
	229	fTriggerInputsNames.AddAt(new TNamed(name,NULL),index);
	230	}
	231	//______________________________________________________________________________
	232	const char* AliESDHeader::GetTriggerInputName(Int_t index, Int_t trglevel) const
	233	{
	234	// Get the trigger input name
	235	// at the specified position in the trigger mask and trigger level (0,1,2)
	236	TNamed *trginput = 0;
	237	if (trglevel == 0) trginput = (TNamed *)fTriggerInputsNames.At(index);
	238	if (trglevel == 1) trginput = (TNamed *)fTriggerInputsNames.At(index+24);
	239	if (trglevel == 2) trginput = (TNamed *)fTriggerInputsNames.At(index+48);
	240	if (trginput) return trginput->GetName();
	241	else return "";
d5ebf00e	242	}
6ef9caeb	243	//______________________________________________________________________________
	244	TString AliESDHeader::GetActiveTriggerInputs() const
	245	{
	246	// Returns the list with the names of the active trigger inputs
	247	TString trginputs;
	248	for(Int_t i = 0; i < kNTriggerInputs; i++) {
	249	TNamed str = (TNamed )((fTriggerInputsNames).At(i));
	250	if (str) {
	251	trginputs += " ";
	252	trginputs += str->GetName();
	253	trginputs += " ";
	254	}
	255	}
	256
	257	return trginputs;
	258	}
	259	//______________________________________________________________________________
	260	TString AliESDHeader::GetFiredTriggerInputs() const
	261	{
	262	// Returns the list with the names of the fired trigger inputs
	263	TString trginputs;
	264	for(Int_t i = 0; i < kNTriggerInputs; i++) {
	265	TNamed str = (TNamed )((fTriggerInputsNames.At(i)));
	266	if (i < 24 && (fL0TriggerInputs & (1 << i))) {
	267	if (str) {
	268	trginputs += " ";
	269	trginputs += str->GetName();
	270	trginputs += " ";
	271	}
	272	}
d999f2e6	273	if (i >= 24 && i < 48 && (fL1TriggerInputs & (1 << (i-24)))) {
6ef9caeb	274	if (str) {
	275	trginputs += " ";
	276	trginputs += str->GetName();
	277	trginputs += " ";
	278	}
	279	}
d999f2e6	280	if (i >= 48 && (fL2TriggerInputs & (1 << (i-48)))) {
6ef9caeb	281	if (str) {
	282	trginputs += " ";
	283	trginputs += str->GetName();
	284	trginputs += " ";
	285	}
	286	}
d5ebf00e	287
6ef9caeb	288	}
	289	return trginputs;
	290	}
	291	//______________________________________________________________________________
	292	Bool_t AliESDHeader::IsTriggerInputFired(const char *name) const
	293	{
	294	// Checks if the trigger input is fired
	295
	296	TNamed trginput = (TNamed )fTriggerInputsNames.FindObject(name);
	297	if (!trginput) return kFALSE;
	298
	299	Int_t inputIndex = fTriggerInputsNames.IndexOf(trginput);
	300	if (inputIndex < 0) return kFALSE;
	301
	302	if (fL0TriggerInputs & (1 << inputIndex)) return kTRUE;
	303	else if (fL1TriggerInputs & (1 << (inputIndex-24))) return kTRUE;
	304	else if (fL2TriggerInputs & (1 << (inputIndex-48))) return kTRUE;
	305	else return kFALSE;
	306	}