[u/mrichter/AliRoot.git] / STEER / AliESDVZERO.cxx

#include "AliESDVZERO.h"
#include "AliLog.h"

ClassImp(AliESDVZERO)

//__________________________________________________________________________
AliESDVZERO::AliESDVZERO()
  :TObject(),
   fBBtriggerV0A(0),
   fBGtriggerV0A(0),
   fBBtriggerV0C(0),
   fBGtriggerV0C(0),
   fV0ATime(-1024),
   fV0CTime(-1024),
   fV0ATimeError(0),
   fV0CTimeError(0),
   fV0ADecision(kV0Invalid),
   fV0CDecision(kV0Invalid)
{   
   // Default constructor 
   for(Int_t j=0; j<64; j++){ 
      fMultiplicity[j] = 0.0;   
      fAdc[j]   = 0.0;   
      fTime[j]  = 0.0; 
      fWidth[j] = 0.0; 
      fBBFlag[j]= kFALSE;
      fBGFlag[j]= kFALSE;  
   }
}

//__________________________________________________________________________
AliESDVZERO::AliESDVZERO(const AliESDVZERO &o)
  :TObject(o),
   fBBtriggerV0A(o.fBBtriggerV0A),
   fBGtriggerV0A(o.fBGtriggerV0A),
   fBBtriggerV0C(o.fBBtriggerV0C),
   fBGtriggerV0C(o.fBGtriggerV0C),
   fV0ATime(o.fV0ATime),
   fV0CTime(o.fV0CTime),
   fV0ATimeError(o.fV0ATimeError),
   fV0CTimeError(o.fV0CTimeError),
   fV0ADecision(o.fV0ADecision),
   fV0CDecision(o.fV0CDecision)
{   
   // Default constructor 
   for(Int_t j=0; j<64; j++) {
       fMultiplicity[j] = o.fMultiplicity[j];
       fAdc[j]    = o.fAdc[j];
       fTime[j]   = o.fTime[j];
       fWidth[j]  = o.fWidth[j];
       fBBFlag[j] = o.fBBFlag[j];
       fBGFlag[j] = o.fBGFlag[j];
   }
}

//__________________________________________________________________________
AliESDVZERO::AliESDVZERO(UInt_t BBtriggerV0A, UInt_t BGtriggerV0A,
	      UInt_t BBtriggerV0C, UInt_t BGtriggerV0C,
	      Float_t *Multiplicity, Float_t *Adc, 
	      Float_t *Time, Float_t *Width, Bool_t *BBFlag, Bool_t *BGFlag)
  :TObject(),
   fBBtriggerV0A(BBtriggerV0A),
   fBGtriggerV0A(BGtriggerV0A),
   fBBtriggerV0C(BBtriggerV0C),
   fBGtriggerV0C(BGtriggerV0C),
   fV0ATime(-1024),
   fV0CTime(-1024),
   fV0ATimeError(0),
   fV0CTimeError(0),
   fV0ADecision(kV0Invalid),
   fV0CDecision(kV0Invalid)
{
   // Constructor
   for(Int_t j=0; j<64; j++) {
       fMultiplicity[j] = Multiplicity[j];
       fAdc[j]    = Adc[j];
       fTime[j]   = Time[j];
       fWidth[j]  = Width[j];
       fBBFlag[j] = BBFlag[j];
       fBGFlag[j] = BGFlag[j];
   }
}

//__________________________________________________________________________
AliESDVZERO& AliESDVZERO::operator=(const AliESDVZERO& o)
{

  if(this==&o) return *this;
  TObject::operator=(o);
  // Assignment operator
  fBBtriggerV0A=o.fBBtriggerV0A;
  fBGtriggerV0A=o.fBGtriggerV0A;
  fBBtriggerV0C=o.fBBtriggerV0C;
  fBGtriggerV0C=o.fBGtriggerV0C;

  fV0ATime = o.fV0ATime;
  fV0CTime = o.fV0CTime;
  fV0ATimeError = o.fV0ATimeError;
  fV0CTimeError = o.fV0CTimeError;
  fV0ADecision = o.fV0ADecision;
  fV0CDecision = o.fV0CDecision;

   for(Int_t j=0; j<64; j++) {
       fMultiplicity[j] = o.fMultiplicity[j];
       fAdc[j]    = o.fAdc[j];
       fTime[j]   = o.fTime[j];
       fWidth[j]  = o.fWidth[j];
       fBBFlag[j] = o.fBBFlag[j];
       fBGFlag[j] = o.fBGFlag[j];
   }
  return *this;
}

//__________________________________________________________________________
Short_t AliESDVZERO::GetNbPMV0A()
{
  Short_t n=0;
  for(Int_t i=32;i<64;i++) 
    if (fMultiplicity[i]>0) n++;
  return n;
}

//__________________________________________________________________________
Short_t AliESDVZERO::GetNbPMV0C()
{
  Short_t n=0;
  for(Int_t i=0;i<32;i++) 
    if (fMultiplicity[i]>0) n++;
  return n;
}

//__________________________________________________________________________
Float_t AliESDVZERO::GetMTotV0A()
{
  Float_t mul=0.0;
  for(Int_t i=32;i<64;i++) 
    mul+=  fMultiplicity[i];
  return mul;
}

//__________________________________________________________________________
Float_t AliESDVZERO::GetMTotV0C()
{
  Float_t mul=0.0;
  for(Int_t i=0;i<32;i++) 
    mul+=  fMultiplicity[i];
  return mul;
}

//__________________________________________________________________________
Float_t* AliESDVZERO::GetMRingV0A()
{
//  cout << "AliESDVZERO::GetMRingV0C() not supported any more" << endl;
//  cout << "use Int_t AliESDVZERO::GetMRingV0C(Int_t ring)" << endl;
  AliInfo("AliESDVZERO::GetMRingV0C() not supported any more");
  AliInfo("use Float_t AliESDVZERO::GetMRingV0C(Int_t ring)");
  return 0x0;
}

//__________________________________________________________________________
Float_t* AliESDVZERO::GetMRingV0C()
{
//  cout << "AliESDVZERO::GetMRingV0C() not supported any more" << endl;
//  cout << "use Int_t AliESDVZERO::GetMRingV0C(Int_t ring)" << endl;
  AliInfo("AliESDVZERO::GetMRingV0C() not supported any more");
  AliInfo("use Float_t AliESDVZERO::GetMRingV0C(Int_t ring)"); 
  return 0x0;
}

//__________________________________________________________________________
Float_t AliESDVZERO::GetMRingV0A(Int_t ring)
{ 
  if (OutOfRange(ring, "AliESDVZERO:::GetMRingV0A",4)) return -1;
  Float_t mul =0.0;

  if (ring == 0) for(Int_t i=32;i<40;i++) mul +=  fMultiplicity[i];
  if (ring == 1) for(Int_t i=40;i<48;i++) mul +=  fMultiplicity[i];
  if (ring == 2) for(Int_t i=48;i<56;i++) mul +=  fMultiplicity[i];
  if (ring == 3) for(Int_t i=56;i<64;i++) mul +=  fMultiplicity[i];
  return mul ;
}

//__________________________________________________________________________
Float_t AliESDVZERO::GetMRingV0C(Int_t ring)
{ 
  if (OutOfRange(ring, "AliESDVZERO:::GetMRingV0C",4)) return -1;
  Float_t mul =0.0;

  if (ring == 0) for(Int_t i=0;i<8;i++)   mul +=  fMultiplicity[i];
  if (ring == 1) for(Int_t i=8;i<16;i++)  mul +=  fMultiplicity[i];
  if (ring == 2) for(Int_t i=16;i<24;i++) mul +=  fMultiplicity[i];
  if (ring == 3) for(Int_t i=24;i<32;i++) mul +=  fMultiplicity[i];
  return mul ;
}

//__________________________________________________________________________
Float_t AliESDVZERO::GetMultiplicity(Int_t i)

{
  if (OutOfRange(i, "AliESDVZERO::GetMultiplicity:",64)) return -1;
  return fMultiplicity[i];
}

//__________________________________________________________________________
Float_t AliESDVZERO::GetMultiplicityV0A(Int_t i)

{
  if (OutOfRange(i, "AliESDVZERO::GetMultiplicityV0A:",32)) return -1;
  return fMultiplicity[32+i];
}

//__________________________________________________________________________
Float_t AliESDVZERO::GetMultiplicityV0C(Int_t i)

{
  if (OutOfRange(i, "AliESDVZERO::GetMultiplicityV0C:",32)) return -1;
  return fMultiplicity[i];
}

//__________________________________________________________________________
Float_t AliESDVZERO::GetAdc(Int_t i)

{
  if (OutOfRange(i, "AliESDVZERO::GetAdc:",64)) return -1;
  return fAdc[i];
}

//__________________________________________________________________________
Float_t AliESDVZERO::GetAdcV0A(Int_t i)

{
  if (OutOfRange(i, "AliESDVZERO::GetAdcV0A:",32)) return -1;
  return fAdc[32+i];
}

//__________________________________________________________________________
Float_t AliESDVZERO::GetAdcV0C(Int_t i)

{
  if (OutOfRange(i, "AliESDVZERO::GetAdcV0C:",32)) return -1;
  return fAdc[i];
}

//__________________________________________________________________________
Float_t AliESDVZERO::GetTime(Int_t i)

{
  if (OutOfRange(i, "AliESDVZERO::GetTime:",64)) return -1;
  return fTime[i];
}

//__________________________________________________________________________
Float_t AliESDVZERO::GetTimeV0A(Int_t i)

{
  if (OutOfRange(i, "AliESDVZERO::GetTimeV0A:",32)) return -1;
  return fTime[32+i];
}

//__________________________________________________________________________
Float_t AliESDVZERO::GetTimeV0C(Int_t i)

{
  if (OutOfRange(i, "AliESDVZERO::GetTimeV0C:",32)) return -1;
  return fTime[i];
}

//__________________________________________________________________________
Float_t AliESDVZERO::GetWidth(Int_t i)

{
  if (OutOfRange(i, "AliESDVZERO::GetWidth:",64)) return -1;
  return fWidth[i];
}

//__________________________________________________________________________
Float_t AliESDVZERO::GetWidthV0A(Int_t i)

{
  if (OutOfRange(i, "AliESDVZERO::GetWidthV0A:",32)) return -1;
  return fWidth[32+i];
}

//__________________________________________________________________________
Float_t AliESDVZERO::GetWidthV0C(Int_t i)

{
  if (OutOfRange(i, "AliESDVZERO::GetWidthV0C:",32)) return -1;
  return fWidth[i];
}

//__________________________________________________________________________
Bool_t AliESDVZERO::BBTriggerV0A(Int_t i)
{
  if (OutOfRange(i, "AliESDVZERO:::BBTriggerV0A",32)) return kFALSE;
  UInt_t test = 1;
  return ( fBBtriggerV0A & (test << i) ? kTRUE : kFALSE );
}

//__________________________________________________________________________
Bool_t AliESDVZERO::BGTriggerV0A(Int_t i)
{
  if (OutOfRange(i, "AliESDVZERO:::BGTriggerV0A",32)) return kFALSE;
  UInt_t test = 1;
  return ( fBGtriggerV0A & (test << i) ? kTRUE : kFALSE );
}

//__________________________________________________________________________
Bool_t AliESDVZERO::BBTriggerV0C(Int_t i)
{
  if (OutOfRange(i, "AliESDVZERO:::BBTriggerV0C",32)) return kFALSE;
  UInt_t test = 1;
  return ( fBBtriggerV0C & (test << i) ? kTRUE : kFALSE );
}

//__________________________________________________________________________
Bool_t AliESDVZERO::BGTriggerV0C(Int_t i)
{
  if (OutOfRange(i, "AliESDVZERO:::BGTriggerV0C",32)) return kFALSE;
  UInt_t test = 1;
  return ( fBGtriggerV0C & (test << i) ? kTRUE : kFALSE );
}

//__________________________________________________________________________
Bool_t AliESDVZERO::GetBBFlag(Int_t i)

{
  if (OutOfRange(i, "AliESDVZERO::GetBBFlag:",64)) return kFALSE;
  return fBBFlag[i];
}

//__________________________________________________________________________
Bool_t AliESDVZERO::GetBGFlag(Int_t i)

{
  if (OutOfRange(i, "AliESDVZERO::GetBGFlag:",64)) return kFALSE;
  return fBGFlag[i];
}

//__________________________________________________________________________
Bool_t AliESDVZERO::OutOfRange(Int_t i, const char* /*s*/, Int_t upper) const
{
  // checks if i is a valid index. s = name of calling method
  if (i > upper || i < 0) {
//    cout << s << " Index " << i << " out of range" << endl;
     AliInfo(Form("Index %d out of range",i));
     return kTRUE;
  }
  return kFALSE;
}
Commit	Line	Data
dd735cf0	1	#include "AliESDVZERO.h"
28fdf12c	2	#include "AliLog.h"
dd735cf0	3
	4	ClassImp(AliESDVZERO)
	5
d0502ab2	6	//__________________________________________________________________________
a055ee24	7	AliESDVZERO::AliESDVZERO()
	8	:TObject(),
	9	fBBtriggerV0A(0),
	10	fBGtriggerV0A(0),
	11	fBBtriggerV0C(0),
b44c933e	12	fBGtriggerV0C(0),
	13	fV0ATime(-1024),
	14	fV0CTime(-1024),
	15	fV0ATimeError(0),
	16	fV0CTimeError(0),
	17	fV0ADecision(kV0Invalid),
	18	fV0CDecision(kV0Invalid)
dd735cf0	19	{
dd735cf0	20	// Default constructor
a055ee24	21	for(Int_t j=0; j<64; j++){
6c6d6114	22	fMultiplicity[j] = 0.0;
db0db003	23	fAdc[j] = 0.0;
	24	fTime[j] = 0.0;
	25	fWidth[j] = 0.0;
d0502ab2	26	fBBFlag[j]= kFALSE;
d0502ab2	27	fBGFlag[j]= kFALSE;
cd888a89	28	}
dd735cf0	29	}
dd735cf0	30
d0502ab2	31	//__________________________________________________________________________
cd888a89	32	AliESDVZERO::AliESDVZERO(const AliESDVZERO &o)
cd888a89	33	:TObject(o),
a055ee24	34	fBBtriggerV0A(o.fBBtriggerV0A),
	35	fBGtriggerV0A(o.fBGtriggerV0A),
	36	fBBtriggerV0C(o.fBBtriggerV0C),
b44c933e	37	fBGtriggerV0C(o.fBGtriggerV0C),
	38	fV0ATime(o.fV0ATime),
	39	fV0CTime(o.fV0CTime),
	40	fV0ATimeError(o.fV0ATimeError),
	41	fV0CTimeError(o.fV0CTimeError),
	42	fV0ADecision(o.fV0ADecision),
	43	fV0CDecision(o.fV0CDecision)
dd735cf0	44	{
dd735cf0	45	// Default constructor
28fdf12c	46	for(Int_t j=0; j<64; j++) {
a055ee24	47	fMultiplicity[j] = o.fMultiplicity[j];
d0502ab2	48	fAdc[j] = o.fAdc[j];
	49	fTime[j] = o.fTime[j];
	50	fWidth[j] = o.fWidth[j];
	51	fBBFlag[j] = o.fBBFlag[j];
	52	fBGFlag[j] = o.fBGFlag[j];
28fdf12c	53	}
dd735cf0	54	}
dd735cf0	55
d0502ab2	56	//__________________________________________________________________________
a055ee24	57	AliESDVZERO::AliESDVZERO(UInt_t BBtriggerV0A, UInt_t BGtriggerV0A,
a055ee24	58	UInt_t BBtriggerV0C, UInt_t BGtriggerV0C,
db0db003	59	Float_t Multiplicity, Float_t Adc,
db0db003	60	Float_t Time, Float_t Width, Bool_t BBFlag, Bool_t BGFlag)
cd888a89	61	:TObject(),
a055ee24	62	fBBtriggerV0A(BBtriggerV0A),
	63	fBGtriggerV0A(BGtriggerV0A),
	64	fBBtriggerV0C(BBtriggerV0C),
b44c933e	65	fBGtriggerV0C(BGtriggerV0C),
	66	fV0ATime(-1024),
	67	fV0CTime(-1024),
	68	fV0ATimeError(0),
	69	fV0CTimeError(0),
	70	fV0ADecision(kV0Invalid),
	71	fV0CDecision(kV0Invalid)
dd735cf0	72	{
dd735cf0	73	// Constructor
28fdf12c	74	for(Int_t j=0; j<64; j++) {
a055ee24	75	fMultiplicity[j] = Multiplicity[j];
d0502ab2	76	fAdc[j] = Adc[j];
	77	fTime[j] = Time[j];
	78	fWidth[j] = Width[j];
	79	fBBFlag[j] = BBFlag[j];
	80	fBGFlag[j] = BGFlag[j];
28fdf12c	81	}
dd735cf0	82	}
dd735cf0	83
d0502ab2	84	//__________________________________________________________________________
dd735cf0	85	AliESDVZERO& AliESDVZERO::operator=(const AliESDVZERO& o)
dd735cf0	86	{
cd888a89	87
a055ee24	88	if(this==&o) return *this;
cd888a89	89	TObject::operator=(o);
dd735cf0	90	// Assignment operator
a055ee24	91	fBBtriggerV0A=o.fBBtriggerV0A;
	92	fBGtriggerV0A=o.fBGtriggerV0A;
	93	fBBtriggerV0C=o.fBBtriggerV0C;
	94	fBGtriggerV0C=o.fBGtriggerV0C;
b44c933e	95
	96	fV0ATime = o.fV0ATime;
	97	fV0CTime = o.fV0CTime;
	98	fV0ATimeError = o.fV0ATimeError;
	99	fV0CTimeError = o.fV0CTimeError;
	100	fV0ADecision = o.fV0ADecision;
	101	fV0CDecision = o.fV0CDecision;
	102
28fdf12c	103	for(Int_t j=0; j<64; j++) {
a055ee24	104	fMultiplicity[j] = o.fMultiplicity[j];
d0502ab2	105	fAdc[j] = o.fAdc[j];
	106	fTime[j] = o.fTime[j];
	107	fWidth[j] = o.fWidth[j];
	108	fBBFlag[j] = o.fBBFlag[j];
	109	fBGFlag[j] = o.fBGFlag[j];
28fdf12c	110	}
a055ee24	111	return *this;
a055ee24	112	}
cd888a89	113
d0502ab2	114	//__________________________________________________________________________
a055ee24	115	Short_t AliESDVZERO::GetNbPMV0A()
	116	{
	117	Short_t n=0;
	118	for(Int_t i=32;i<64;i++)
	119	if (fMultiplicity[i]>0) n++;
	120	return n;
	121	}
dd735cf0	122
d0502ab2	123	//__________________________________________________________________________
a055ee24	124	Short_t AliESDVZERO::GetNbPMV0C()
	125	{
	126	Short_t n=0;
	127	for(Int_t i=0;i<32;i++)
	128	if (fMultiplicity[i]>0) n++;
	129	return n;
	130	}
dd735cf0	131
d0502ab2	132	//__________________________________________________________________________
6c6d6114	133	Float_t AliESDVZERO::GetMTotV0A()
a055ee24	134	{
6c6d6114	135	Float_t mul=0.0;
a055ee24	136	for(Int_t i=32;i<64;i++)
db0db003	137	mul+= fMultiplicity[i];
6c6d6114	138	return mul;
a055ee24	139	}
a055ee24	140
d0502ab2	141	//__________________________________________________________________________
6c6d6114	142	Float_t AliESDVZERO::GetMTotV0C()
a055ee24	143	{
6c6d6114	144	Float_t mul=0.0;
a055ee24	145	for(Int_t i=0;i<32;i++)
db0db003	146	mul+= fMultiplicity[i];
6c6d6114	147	return mul;
a055ee24	148	}
a055ee24	149
d0502ab2	150	//__________________________________________________________________________
6c6d6114	151	Float_t* AliESDVZERO::GetMRingV0A()
a055ee24	152	{
28fdf12c	153	// cout << "AliESDVZERO::GetMRingV0C() not supported any more" << endl;
	154	// cout << "use Int_t AliESDVZERO::GetMRingV0C(Int_t ring)" << endl;
	155	AliInfo("AliESDVZERO::GetMRingV0C() not supported any more");
6c6d6114	156	AliInfo("use Float_t AliESDVZERO::GetMRingV0C(Int_t ring)");
a055ee24	157	return 0x0;
	158	}
	159
d0502ab2	160	//__________________________________________________________________________
6c6d6114	161	Float_t* AliESDVZERO::GetMRingV0C()
a055ee24	162	{
28fdf12c	163	// cout << "AliESDVZERO::GetMRingV0C() not supported any more" << endl;
	164	// cout << "use Int_t AliESDVZERO::GetMRingV0C(Int_t ring)" << endl;
	165	AliInfo("AliESDVZERO::GetMRingV0C() not supported any more");
6c6d6114	166	AliInfo("use Float_t AliESDVZERO::GetMRingV0C(Int_t ring)");
a055ee24	167	return 0x0;
dd735cf0	168	}
dd735cf0	169
d0502ab2	170	//__________________________________________________________________________
6c6d6114	171	Float_t AliESDVZERO::GetMRingV0A(Int_t ring)
a055ee24	172	{
a055ee24	173	if (OutOfRange(ring, "AliESDVZERO:::GetMRingV0A",4)) return -1;
6c6d6114	174	Float_t mul =0.0;
732a24fe	175
db0db003	176	if (ring == 0) for(Int_t i=32;i<40;i++) mul += fMultiplicity[i];
	177	if (ring == 1) for(Int_t i=40;i<48;i++) mul += fMultiplicity[i];
	178	if (ring == 2) for(Int_t i=48;i<56;i++) mul += fMultiplicity[i];
	179	if (ring == 3) for(Int_t i=56;i<64;i++) mul += fMultiplicity[i];
6c6d6114	180	return mul ;
a055ee24	181	}
732a24fe	182
d0502ab2	183	//__________________________________________________________________________
6c6d6114	184	Float_t AliESDVZERO::GetMRingV0C(Int_t ring)
a055ee24	185	{
a055ee24	186	if (OutOfRange(ring, "AliESDVZERO:::GetMRingV0C",4)) return -1;
6c6d6114	187	Float_t mul =0.0;
732a24fe	188
db0db003	189	if (ring == 0) for(Int_t i=0;i<8;i++) mul += fMultiplicity[i];
	190	if (ring == 1) for(Int_t i=8;i<16;i++) mul += fMultiplicity[i];
	191	if (ring == 2) for(Int_t i=16;i<24;i++) mul += fMultiplicity[i];
	192	if (ring == 3) for(Int_t i=24;i<32;i++) mul += fMultiplicity[i];
6c6d6114	193	return mul ;
732a24fe	194	}
732a24fe	195
d0502ab2	196	//__________________________________________________________________________
6c6d6114	197	Float_t AliESDVZERO::GetMultiplicity(Int_t i)
a055ee24	198
	199	{
	200	if (OutOfRange(i, "AliESDVZERO::GetMultiplicity:",64)) return -1;
	201	return fMultiplicity[i];
	202	}
	203
d0502ab2	204	//__________________________________________________________________________
6c6d6114	205	Float_t AliESDVZERO::GetMultiplicityV0A(Int_t i)
28fdf12c	206
	207	{
	208	if (OutOfRange(i, "AliESDVZERO::GetMultiplicityV0A:",32)) return -1;
	209	return fMultiplicity[32+i];
	210	}
	211
d0502ab2	212	//__________________________________________________________________________
6c6d6114	213	Float_t AliESDVZERO::GetMultiplicityV0C(Int_t i)
28fdf12c	214
	215	{
	216	if (OutOfRange(i, "AliESDVZERO::GetMultiplicityV0C:",32)) return -1;
	217	return fMultiplicity[i];
	218	}
	219
d0502ab2	220	//__________________________________________________________________________
db0db003	221	Float_t AliESDVZERO::GetAdc(Int_t i)
28fdf12c	222
	223	{
	224	if (OutOfRange(i, "AliESDVZERO::GetAdc:",64)) return -1;
	225	return fAdc[i];
	226	}
	227
d0502ab2	228	//__________________________________________________________________________
db0db003	229	Float_t AliESDVZERO::GetAdcV0A(Int_t i)
28fdf12c	230
28fdf12c	231	{
d0502ab2	232	if (OutOfRange(i, "AliESDVZERO::GetAdcV0A:",32)) return -1;
d0502ab2	233	return fAdc[32+i];
28fdf12c	234	}
28fdf12c	235
d0502ab2	236	//__________________________________________________________________________
db0db003	237	Float_t AliESDVZERO::GetAdcV0C(Int_t i)
28fdf12c	238
28fdf12c	239	{
d0502ab2	240	if (OutOfRange(i, "AliESDVZERO::GetAdcV0C:",32)) return -1;
d0502ab2	241	return fAdc[i];
28fdf12c	242	}
28fdf12c	243
d0502ab2	244	//__________________________________________________________________________
db0db003	245	Float_t AliESDVZERO::GetTime(Int_t i)
28fdf12c	246
	247	{
	248	if (OutOfRange(i, "AliESDVZERO::GetTime:",64)) return -1;
	249	return fTime[i];
	250	}
	251
d0502ab2	252	//__________________________________________________________________________
db0db003	253	Float_t AliESDVZERO::GetTimeV0A(Int_t i)
d0502ab2	254
	255	{
	256	if (OutOfRange(i, "AliESDVZERO::GetTimeV0A:",32)) return -1;
	257	return fTime[32+i];
	258	}
	259
	260	//__________________________________________________________________________
db0db003	261	Float_t AliESDVZERO::GetTimeV0C(Int_t i)
28fdf12c	262
	263	{
	264	if (OutOfRange(i, "AliESDVZERO::GetTimeV0C:",32)) return -1;
	265	return fTime[i];
	266	}
	267
d0502ab2	268	//__________________________________________________________________________
db0db003	269	Float_t AliESDVZERO::GetWidth(Int_t i)
28fdf12c	270
28fdf12c	271	{
d0502ab2	272	if (OutOfRange(i, "AliESDVZERO::GetWidth:",64)) return -1;
	273	return fWidth[i];
	274	}
	275
	276	//__________________________________________________________________________
db0db003	277	Float_t AliESDVZERO::GetWidthV0A(Int_t i)
d0502ab2	278
	279	{
	280	if (OutOfRange(i, "AliESDVZERO::GetWidthV0A:",32)) return -1;
	281	return fWidth[32+i];
	282	}
	283
	284	//__________________________________________________________________________
db0db003	285	Float_t AliESDVZERO::GetWidthV0C(Int_t i)
d0502ab2	286
	287	{
	288	if (OutOfRange(i, "AliESDVZERO::GetWidthV0C:",32)) return -1;
	289	return fWidth[i];
28fdf12c	290	}
28fdf12c	291
d0502ab2	292	//__________________________________________________________________________
a055ee24	293	Bool_t AliESDVZERO::BBTriggerV0A(Int_t i)
	294	{
	295	if (OutOfRange(i, "AliESDVZERO:::BBTriggerV0A",32)) return kFALSE;
	296	UInt_t test = 1;
	297	return ( fBBtriggerV0A & (test << i) ? kTRUE : kFALSE );
	298	}
	299
d0502ab2	300	//__________________________________________________________________________
a055ee24	301	Bool_t AliESDVZERO::BGTriggerV0A(Int_t i)
	302	{
	303	if (OutOfRange(i, "AliESDVZERO:::BGTriggerV0A",32)) return kFALSE;
	304	UInt_t test = 1;
	305	return ( fBGtriggerV0A & (test << i) ? kTRUE : kFALSE );
	306	}
	307
d0502ab2	308	//__________________________________________________________________________
a055ee24	309	Bool_t AliESDVZERO::BBTriggerV0C(Int_t i)
	310	{
	311	if (OutOfRange(i, "AliESDVZERO:::BBTriggerV0C",32)) return kFALSE;
	312	UInt_t test = 1;
	313	return ( fBBtriggerV0C & (test << i) ? kTRUE : kFALSE );
	314	}
	315
d0502ab2	316	//__________________________________________________________________________
a055ee24	317	Bool_t AliESDVZERO::BGTriggerV0C(Int_t i)
	318	{
	319	if (OutOfRange(i, "AliESDVZERO:::BGTriggerV0C",32)) return kFALSE;
	320	UInt_t test = 1;
	321	return ( fBGtriggerV0C & (test << i) ? kTRUE : kFALSE );
	322	}
	323
d0502ab2	324	//__________________________________________________________________________
	325	Bool_t AliESDVZERO::GetBBFlag(Int_t i)
	326
	327	{
	328	if (OutOfRange(i, "AliESDVZERO::GetBBFlag:",64)) return kFALSE;
	329	return fBBFlag[i];
	330	}
	331
	332	//__________________________________________________________________________
	333	Bool_t AliESDVZERO::GetBGFlag(Int_t i)
	334
	335	{
	336	if (OutOfRange(i, "AliESDVZERO::GetBGFlag:",64)) return kFALSE;
	337	return fBGFlag[i];
	338	}
	339
	340	//__________________________________________________________________________
7cec0871	341	Bool_t AliESDVZERO::OutOfRange(Int_t i, const char* /s/, Int_t upper) const
a055ee24	342	{
	343	// checks if i is a valid index. s = name of calling method
	344	if (i > upper \|\| i < 0) {
28fdf12c	345	// cout << s << " Index " << i << " out of range" << endl;
	346	AliInfo(Form("Index %d out of range",i));
	347	return kTRUE;
a055ee24	348	}
	349	return kFALSE;
	350	}
732a24fe	351