[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;
}

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

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