[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() const
{
  // Returns the number of
  // fired PM in V0A
  Short_t n=0;
  for(Int_t i=32;i<64;i++) 
    if (fMultiplicity[i]>0) n++;
  return n;
}

//__________________________________________________________________________
Short_t AliESDVZERO::GetNbPMV0C() const
{
  // Returns the number of
  // fired PM in V0C
  Short_t n=0;
  for(Int_t i=0;i<32;i++) 
    if (fMultiplicity[i]>0) n++;
  return n;
}

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

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

//__________________________________________________________________________
Float_t* AliESDVZERO::GetMRingV0A() const
{
//  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() const
{
//  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) const
{ 
  // returns multiplicity in a
  // given ring of V0A
  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) const
{ 
  // returns multiplicity in a
  // given ring of V0C
  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) const

{
  // returns multiplicity in a
  // given cell of V0
  if (OutOfRange(i, "AliESDVZERO::GetMultiplicity:",64)) return -1;
  return fMultiplicity[i];
}

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

{
  // returns multiplicity in a
  // given cell of V0A
  if (OutOfRange(i, "AliESDVZERO::GetMultiplicityV0A:",32)) return -1;
  return fMultiplicity[32+i];
}

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

{
  // returns multiplicity in a
  // given cell of V0C
  if (OutOfRange(i, "AliESDVZERO::GetMultiplicityV0C:",32)) return -1;
  return fMultiplicity[i];
}

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

{
  // returns ADC charge in a
  // given cell of V0
  if (OutOfRange(i, "AliESDVZERO::GetAdc:",64)) return -1;
  return fAdc[i];
}

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

{
  // returns ADC charge in a
  // given cell of V0A
  if (OutOfRange(i, "AliESDVZERO::GetAdcV0A:",32)) return -1;
  return fAdc[32+i];
}

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

{
  // returns ADC charge in a
  // given cell of V0C
  if (OutOfRange(i, "AliESDVZERO::GetAdcV0C:",32)) return -1;
  return fAdc[i];
}

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

{
  // returns leading time measured by TDC
  // in a given cell of V0
  if (OutOfRange(i, "AliESDVZERO::GetTime:",64)) return -1;
  return fTime[i];
}

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

{
  // returns leading time measured by TDC
  // in a given cell of V0A
  if (OutOfRange(i, "AliESDVZERO::GetTimeV0A:",32)) return -1;
  return fTime[32+i];
}

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

{
  // returns leading time measured by TDC
  // in a given cell of V0C
  if (OutOfRange(i, "AliESDVZERO::GetTimeV0C:",32)) return -1;
  return fTime[i];
}

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

{
  // returns time signal width
  // in a given cell of V0
  if (OutOfRange(i, "AliESDVZERO::GetWidth:",64)) return -1;
  return fWidth[i];
}

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

{
  // returns time signal width
  // in a given cell of V0A
  if (OutOfRange(i, "AliESDVZERO::GetWidthV0A:",32)) return -1;
  return fWidth[32+i];
}

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

{
  // returns time signal width
  // in a given cell of V0C
  if (OutOfRange(i, "AliESDVZERO::GetWidthV0C:",32)) return -1;
  return fWidth[i];
}

//__________________________________________________________________________
Bool_t AliESDVZERO::BBTriggerV0A(Int_t i) const
{
  // returns offline beam-beam flags in V0A
  // one bit per cell
  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) const
{
  // returns offline beam-gas flags in V0A
  // one bit per cell
  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) const
{
  // returns offline beam-beam flags in V0C
  // one bit per cell
  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) const
{
  // returns offline beam-gasflags in V0C
  // one bit per cell
  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) const

{
  // returns online beam-beam flag in V0
  // one boolean per cell
  if (OutOfRange(i, "AliESDVZERO::GetBBFlag:",64)) return kFALSE;
  return fBBFlag[i];
}

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

{
  // returns online beam-gas flag in V0
  // one boolean per cell
  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	//__________________________________________________________________________
5fc205b9	115	Short_t AliESDVZERO::GetNbPMV0A() const
a055ee24	116	{
5fc205b9	117	// Returns the number of
5fc205b9	118	// fired PM in V0A
a055ee24	119	Short_t n=0;
	120	for(Int_t i=32;i<64;i++)
	121	if (fMultiplicity[i]>0) n++;
	122	return n;
	123	}
dd735cf0	124
d0502ab2	125	//__________________________________________________________________________
5fc205b9	126	Short_t AliESDVZERO::GetNbPMV0C() const
a055ee24	127	{
5fc205b9	128	// Returns the number of
5fc205b9	129	// fired PM in V0C
a055ee24	130	Short_t n=0;
	131	for(Int_t i=0;i<32;i++)
	132	if (fMultiplicity[i]>0) n++;
	133	return n;
	134	}
dd735cf0	135
d0502ab2	136	//__________________________________________________________________________
5fc205b9	137	Float_t AliESDVZERO::GetMTotV0A() const
a055ee24	138	{
5fc205b9	139	// returns total multiplicity
5fc205b9	140	// in V0A
6c6d6114	141	Float_t mul=0.0;
a055ee24	142	for(Int_t i=32;i<64;i++)
db0db003	143	mul+= fMultiplicity[i];
6c6d6114	144	return mul;
a055ee24	145	}
a055ee24	146
d0502ab2	147	//__________________________________________________________________________
5fc205b9	148	Float_t AliESDVZERO::GetMTotV0C() const
a055ee24	149	{
5fc205b9	150	// returns total multiplicity
5fc205b9	151	// in V0C
6c6d6114	152	Float_t mul=0.0;
a055ee24	153	for(Int_t i=0;i<32;i++)
db0db003	154	mul+= fMultiplicity[i];
6c6d6114	155	return mul;
a055ee24	156	}
a055ee24	157
d0502ab2	158	//__________________________________________________________________________
5fc205b9	159	Float_t* AliESDVZERO::GetMRingV0A() const
a055ee24	160	{
28fdf12c	161	// cout << "AliESDVZERO::GetMRingV0C() not supported any more" << endl;
	162	// cout << "use Int_t AliESDVZERO::GetMRingV0C(Int_t ring)" << endl;
	163	AliInfo("AliESDVZERO::GetMRingV0C() not supported any more");
6c6d6114	164	AliInfo("use Float_t AliESDVZERO::GetMRingV0C(Int_t ring)");
a055ee24	165	return 0x0;
	166	}
	167
d0502ab2	168	//__________________________________________________________________________
5fc205b9	169	Float_t* AliESDVZERO::GetMRingV0C() const
a055ee24	170	{
28fdf12c	171	// cout << "AliESDVZERO::GetMRingV0C() not supported any more" << endl;
	172	// cout << "use Int_t AliESDVZERO::GetMRingV0C(Int_t ring)" << endl;
	173	AliInfo("AliESDVZERO::GetMRingV0C() not supported any more");
6c6d6114	174	AliInfo("use Float_t AliESDVZERO::GetMRingV0C(Int_t ring)");
a055ee24	175	return 0x0;
dd735cf0	176	}
dd735cf0	177
d0502ab2	178	//__________________________________________________________________________
5fc205b9	179	Float_t AliESDVZERO::GetMRingV0A(Int_t ring) const
a055ee24	180	{
5fc205b9	181	// returns multiplicity in a
5fc205b9	182	// given ring of V0A
a055ee24	183	if (OutOfRange(ring, "AliESDVZERO:::GetMRingV0A",4)) return -1;
6c6d6114	184	Float_t mul =0.0;
732a24fe	185
db0db003	186	if (ring == 0) for(Int_t i=32;i<40;i++) mul += fMultiplicity[i];
	187	if (ring == 1) for(Int_t i=40;i<48;i++) mul += fMultiplicity[i];
	188	if (ring == 2) for(Int_t i=48;i<56;i++) mul += fMultiplicity[i];
	189	if (ring == 3) for(Int_t i=56;i<64;i++) mul += fMultiplicity[i];
6c6d6114	190	return mul ;
a055ee24	191	}
732a24fe	192
d0502ab2	193	//__________________________________________________________________________
5fc205b9	194	Float_t AliESDVZERO::GetMRingV0C(Int_t ring) const
a055ee24	195	{
5fc205b9	196	// returns multiplicity in a
5fc205b9	197	// given ring of V0C
a055ee24	198	if (OutOfRange(ring, "AliESDVZERO:::GetMRingV0C",4)) return -1;
6c6d6114	199	Float_t mul =0.0;
732a24fe	200
db0db003	201	if (ring == 0) for(Int_t i=0;i<8;i++) mul += fMultiplicity[i];
	202	if (ring == 1) for(Int_t i=8;i<16;i++) mul += fMultiplicity[i];
	203	if (ring == 2) for(Int_t i=16;i<24;i++) mul += fMultiplicity[i];
	204	if (ring == 3) for(Int_t i=24;i<32;i++) mul += fMultiplicity[i];
6c6d6114	205	return mul ;
732a24fe	206	}
732a24fe	207
d0502ab2	208	//__________________________________________________________________________
5fc205b9	209	Float_t AliESDVZERO::GetMultiplicity(Int_t i) const
a055ee24	210
a055ee24	211	{
5fc205b9	212	// returns multiplicity in a
5fc205b9	213	// given cell of V0
a055ee24	214	if (OutOfRange(i, "AliESDVZERO::GetMultiplicity:",64)) return -1;
	215	return fMultiplicity[i];
	216	}
	217
d0502ab2	218	//__________________________________________________________________________
5fc205b9	219	Float_t AliESDVZERO::GetMultiplicityV0A(Int_t i) const
28fdf12c	220
28fdf12c	221	{
5fc205b9	222	// returns multiplicity in a
5fc205b9	223	// given cell of V0A
28fdf12c	224	if (OutOfRange(i, "AliESDVZERO::GetMultiplicityV0A:",32)) return -1;
	225	return fMultiplicity[32+i];
	226	}
	227
d0502ab2	228	//__________________________________________________________________________
5fc205b9	229	Float_t AliESDVZERO::GetMultiplicityV0C(Int_t i) const
28fdf12c	230
28fdf12c	231	{
5fc205b9	232	// returns multiplicity in a
5fc205b9	233	// given cell of V0C
28fdf12c	234	if (OutOfRange(i, "AliESDVZERO::GetMultiplicityV0C:",32)) return -1;
	235	return fMultiplicity[i];
	236	}
	237
d0502ab2	238	//__________________________________________________________________________
5fc205b9	239	Float_t AliESDVZERO::GetAdc(Int_t i) const
28fdf12c	240
28fdf12c	241	{
5fc205b9	242	// returns ADC charge in a
5fc205b9	243	// given cell of V0
28fdf12c	244	if (OutOfRange(i, "AliESDVZERO::GetAdc:",64)) return -1;
	245	return fAdc[i];
	246	}
	247
d0502ab2	248	//__________________________________________________________________________
5fc205b9	249	Float_t AliESDVZERO::GetAdcV0A(Int_t i) const
28fdf12c	250
28fdf12c	251	{
5fc205b9	252	// returns ADC charge in a
5fc205b9	253	// given cell of V0A
d0502ab2	254	if (OutOfRange(i, "AliESDVZERO::GetAdcV0A:",32)) return -1;
d0502ab2	255	return fAdc[32+i];
28fdf12c	256	}
28fdf12c	257
d0502ab2	258	//__________________________________________________________________________
5fc205b9	259	Float_t AliESDVZERO::GetAdcV0C(Int_t i) const
28fdf12c	260
28fdf12c	261	{
5fc205b9	262	// returns ADC charge in a
5fc205b9	263	// given cell of V0C
d0502ab2	264	if (OutOfRange(i, "AliESDVZERO::GetAdcV0C:",32)) return -1;
d0502ab2	265	return fAdc[i];
28fdf12c	266	}
28fdf12c	267
d0502ab2	268	//__________________________________________________________________________
5fc205b9	269	Float_t AliESDVZERO::GetTime(Int_t i) const
28fdf12c	270
28fdf12c	271	{
5fc205b9	272	// returns leading time measured by TDC
5fc205b9	273	// in a given cell of V0
28fdf12c	274	if (OutOfRange(i, "AliESDVZERO::GetTime:",64)) return -1;
	275	return fTime[i];
	276	}
	277
d0502ab2	278	//__________________________________________________________________________
5fc205b9	279	Float_t AliESDVZERO::GetTimeV0A(Int_t i) const
d0502ab2	280
d0502ab2	281	{
5fc205b9	282	// returns leading time measured by TDC
5fc205b9	283	// in a given cell of V0A
d0502ab2	284	if (OutOfRange(i, "AliESDVZERO::GetTimeV0A:",32)) return -1;
	285	return fTime[32+i];
	286	}
	287
	288	//__________________________________________________________________________
5fc205b9	289	Float_t AliESDVZERO::GetTimeV0C(Int_t i) const
28fdf12c	290
28fdf12c	291	{
5fc205b9	292	// returns leading time measured by TDC
5fc205b9	293	// in a given cell of V0C
28fdf12c	294	if (OutOfRange(i, "AliESDVZERO::GetTimeV0C:",32)) return -1;
	295	return fTime[i];
	296	}
	297
d0502ab2	298	//__________________________________________________________________________
5fc205b9	299	Float_t AliESDVZERO::GetWidth(Int_t i) const
28fdf12c	300
28fdf12c	301	{
5fc205b9	302	// returns time signal width
5fc205b9	303	// in a given cell of V0
d0502ab2	304	if (OutOfRange(i, "AliESDVZERO::GetWidth:",64)) return -1;
	305	return fWidth[i];
	306	}
	307
	308	//__________________________________________________________________________
5fc205b9	309	Float_t AliESDVZERO::GetWidthV0A(Int_t i) const
d0502ab2	310
d0502ab2	311	{
5fc205b9	312	// returns time signal width
5fc205b9	313	// in a given cell of V0A
d0502ab2	314	if (OutOfRange(i, "AliESDVZERO::GetWidthV0A:",32)) return -1;
	315	return fWidth[32+i];
	316	}
	317
	318	//__________________________________________________________________________
5fc205b9	319	Float_t AliESDVZERO::GetWidthV0C(Int_t i) const
d0502ab2	320
d0502ab2	321	{
5fc205b9	322	// returns time signal width
5fc205b9	323	// in a given cell of V0C
d0502ab2	324	if (OutOfRange(i, "AliESDVZERO::GetWidthV0C:",32)) return -1;
d0502ab2	325	return fWidth[i];
28fdf12c	326	}
28fdf12c	327
d0502ab2	328	//__________________________________________________________________________
5fc205b9	329	Bool_t AliESDVZERO::BBTriggerV0A(Int_t i) const
a055ee24	330	{
5fc205b9	331	// returns offline beam-beam flags in V0A
5fc205b9	332	// one bit per cell
a055ee24	333	if (OutOfRange(i, "AliESDVZERO:::BBTriggerV0A",32)) return kFALSE;
	334	UInt_t test = 1;
	335	return ( fBBtriggerV0A & (test << i) ? kTRUE : kFALSE );
	336	}
	337
d0502ab2	338	//__________________________________________________________________________
5fc205b9	339	Bool_t AliESDVZERO::BGTriggerV0A(Int_t i) const
a055ee24	340	{
5fc205b9	341	// returns offline beam-gas flags in V0A
5fc205b9	342	// one bit per cell
a055ee24	343	if (OutOfRange(i, "AliESDVZERO:::BGTriggerV0A",32)) return kFALSE;
	344	UInt_t test = 1;
	345	return ( fBGtriggerV0A & (test << i) ? kTRUE : kFALSE );
	346	}
	347
d0502ab2	348	//__________________________________________________________________________
5fc205b9	349	Bool_t AliESDVZERO::BBTriggerV0C(Int_t i) const
a055ee24	350	{
5fc205b9	351	// returns offline beam-beam flags in V0C
5fc205b9	352	// one bit per cell
a055ee24	353	if (OutOfRange(i, "AliESDVZERO:::BBTriggerV0C",32)) return kFALSE;
	354	UInt_t test = 1;
	355	return ( fBBtriggerV0C & (test << i) ? kTRUE : kFALSE );
	356	}
	357
d0502ab2	358	//__________________________________________________________________________
5fc205b9	359	Bool_t AliESDVZERO::BGTriggerV0C(Int_t i) const
a055ee24	360	{
5fc205b9	361	// returns offline beam-gasflags in V0C
5fc205b9	362	// one bit per cell
a055ee24	363	if (OutOfRange(i, "AliESDVZERO:::BGTriggerV0C",32)) return kFALSE;
	364	UInt_t test = 1;
	365	return ( fBGtriggerV0C & (test << i) ? kTRUE : kFALSE );
	366	}
	367
d0502ab2	368	//__________________________________________________________________________
5fc205b9	369	Bool_t AliESDVZERO::GetBBFlag(Int_t i) const
d0502ab2	370
d0502ab2	371	{
5fc205b9	372	// returns online beam-beam flag in V0
5fc205b9	373	// one boolean per cell
d0502ab2	374	if (OutOfRange(i, "AliESDVZERO::GetBBFlag:",64)) return kFALSE;
	375	return fBBFlag[i];
	376	}
	377
	378	//__________________________________________________________________________
5fc205b9	379	Bool_t AliESDVZERO::GetBGFlag(Int_t i) const
d0502ab2	380
d0502ab2	381	{
5fc205b9	382	// returns online beam-gas flag in V0
5fc205b9	383	// one boolean per cell
d0502ab2	384	if (OutOfRange(i, "AliESDVZERO::GetBGFlag:",64)) return kFALSE;
	385	return fBGFlag[i];
	386	}
	387
	388	//__________________________________________________________________________
7cec0871	389	Bool_t AliESDVZERO::OutOfRange(Int_t i, const char* /s/, Int_t upper) const
a055ee24	390	{
5fc205b9	391	// checks if i is a valid index.
5fc205b9	392	// s = name of calling method
a055ee24	393	if (i > upper \|\| i < 0) {
28fdf12c	394	// cout << s << " Index " << i << " out of range" << endl;
	395	AliInfo(Form("Index %d out of range",i));
	396	return kTRUE;
a055ee24	397	}
	398	return kFALSE;
	399	}
732a24fe	400