[u/mrichter/AliRoot.git] / STEER / AOD / AliAODVZERO.cxx

/**************************************************************************
 * Copyright(c) 1998-2007, 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.                  *
 **************************************************************************/

//-------------------------------------------------------------------------
//     Container class for AOD VZERO data
//     Author: Cvetan Cheshkov
//     cvetan.cheshkov@cern.ch 2/02/2011
//-------------------------------------------------------------------------

#include "AliAODVZERO.h"
#include "AliLog.h"

ClassImp(AliAODVZERO)

//__________________________________________________________________________
AliAODVZERO::AliAODVZERO()
  :AliVVZERO(),
   fBBtriggerV0A(0),
   fBGtriggerV0A(0),
   fBBtriggerV0C(0),
   fBGtriggerV0C(0),
   fV0ATime(-1024),
   fV0CTime(-1024),
   fV0ADecision(kV0Invalid),
   fV0CDecision(kV0Invalid),
   fTriggerChargeA(0),
   fTriggerChargeC(0),
   fTriggerBits(0)
{   
   // Default constructor 
   for(Int_t j=0; j<64; j++){ 
      fMultiplicity[j] = 0.0;   
      fBBFlag[j]= kFALSE;
      fBGFlag[j]= kFALSE;  
   }
}

//__________________________________________________________________________
AliAODVZERO::AliAODVZERO(const AliAODVZERO &source)
  :AliVVZERO(source),
   fBBtriggerV0A(source.fBBtriggerV0A),
   fBGtriggerV0A(source.fBGtriggerV0A),
   fBBtriggerV0C(source.fBBtriggerV0C),
   fBGtriggerV0C(source.fBGtriggerV0C),
   fV0ATime(source.fV0ATime),
   fV0CTime(source.fV0CTime),
   fV0ADecision(source.fV0ADecision),
   fV0CDecision(source.fV0CDecision),
   fTriggerChargeA(source.fTriggerChargeA),
   fTriggerChargeC(source.fTriggerChargeC),
   fTriggerBits(source.fTriggerBits)
{   
   // Default constructor 
   for(Int_t j=0; j<64; j++) {
       fMultiplicity[j] = source.fMultiplicity[j];
       fBBFlag[j] = source.fBBFlag[j];
       fBGFlag[j] = source.fBGFlag[j];
   }
}

//__________________________________________________________________________
AliAODVZERO::AliAODVZERO(const AliVVZERO &source)
  :AliVVZERO(source),
   fBBtriggerV0A(0),
   fBGtriggerV0A(0),
   fBBtriggerV0C(0),
   fBGtriggerV0C(0),
   fV0ATime(source.GetV0ATime()),
   fV0CTime(source.GetV0CTime()),
   fV0ADecision(source.GetV0ADecision()),
   fV0CDecision(source.GetV0CDecision()),
   fTriggerChargeA(source.GetTriggerChargeA()),
   fTriggerChargeC(source.GetTriggerChargeC()),
   fTriggerBits(source.GetTriggerBits())
{   
   // Default constructor 
   for(Int_t j=0; j<64; j++) {
     fMultiplicity[j] = source.GetMultiplicity(j);
     fBBFlag[j] = source.GetBBFlag(j);
     fBGFlag[j] = source.GetBGFlag(j);
   }

   for(Int_t j=0; j<32; j++) {
     if (source.BBTriggerV0A(j)) fBBtriggerV0A |= (1 << j);
     if (source.BGTriggerV0A(j)) fBGtriggerV0A |= (1 << j);
     if (source.BBTriggerV0C(j)) fBBtriggerV0C |= (1 << j);
     if (source.BGTriggerV0C(j)) fBGtriggerV0C |= (1 << j);
   }
}

//__________________________________________________________________________
AliAODVZERO& AliAODVZERO::operator=(const AliAODVZERO& source)
{
  // Assignment operator
  //
  if(this==&source) return *this;
  AliVVZERO::operator=(source);
  // Assignment operator
  fBBtriggerV0A=source.fBBtriggerV0A;
  fBGtriggerV0A=source.fBGtriggerV0A;
  fBBtriggerV0C=source.fBBtriggerV0C;
  fBGtriggerV0C=source.fBGtriggerV0C;

  fV0ATime = source.fV0ATime;
  fV0CTime = source.fV0CTime;
  fV0ADecision = source.fV0ADecision;
  fV0CDecision = source.fV0CDecision;
  fTriggerChargeA = source.fTriggerChargeA;
  fTriggerChargeC = source.fTriggerChargeC;
  fTriggerBits = source.fTriggerBits;

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

//__________________________________________________________________________
AliAODVZERO& AliAODVZERO::operator=(const AliVVZERO& source)
{
  // Assignment operator
  // used in esd->aod filter
  if(this==&source) return *this;
  AliVVZERO::operator=(source);

  fV0ATime = source.GetV0ATime();
  fV0CTime = source.GetV0CTime();
  fV0ADecision = source.GetV0ADecision();
  fV0CDecision = source.GetV0CDecision();
  fTriggerChargeA = source.GetTriggerChargeA();
  fTriggerChargeC = source.GetTriggerChargeC();
  fTriggerBits = source.GetTriggerBits();

  for(Int_t j=0; j<64; j++) {
    fMultiplicity[j] = source.GetMultiplicity(j);
    fBBFlag[j] = source.GetBBFlag(j);
    fBGFlag[j] = source.GetBGFlag(j);
  }

  fBBtriggerV0A = fBGtriggerV0A = fBBtriggerV0C = fBGtriggerV0C = 0;
  for(Int_t j=0; j<32; j++) {
    if (source.BBTriggerV0A(j)) fBBtriggerV0A |= (1 << j);
    if (source.BGTriggerV0A(j)) fBGtriggerV0A |= (1 << j);
    if (source.BBTriggerV0C(j)) fBBtriggerV0C |= (1 << j);
    if (source.BGTriggerV0C(j)) fBGtriggerV0C |= (1 << j);
  }

  return *this;

}

//__________________________________________________________________________
Short_t AliAODVZERO::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 AliAODVZERO::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 AliAODVZERO::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 AliAODVZERO::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 AliAODVZERO::GetMRingV0A(Int_t ring) const
{ 
  // returns multiplicity in a
  // given ring of V0A
  if (OutOfRange(ring, "AliAODVZERO:::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 AliAODVZERO::GetMRingV0C(Int_t ring) const
{ 
  // returns multiplicity in a
  // given ring of V0C
  if (OutOfRange(ring, "AliAODVZERO:::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 AliAODVZERO::GetMultiplicity(Int_t i) const

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

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

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

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

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

//__________________________________________________________________________
Bool_t AliAODVZERO::BBTriggerV0A(Int_t i) const
{
  // returns offline beam-beam flags in V0A
  // one bit per cell
  if (OutOfRange(i, "AliAODVZERO:::BBTriggerV0A",32)) return kFALSE;
  UInt_t test = 1;
  return ( fBBtriggerV0A & (test << i) ? kTRUE : kFALSE );
}

//__________________________________________________________________________
Bool_t AliAODVZERO::BGTriggerV0A(Int_t i) const
{
  // returns offline beam-gas flags in V0A
  // one bit per cell
  if (OutOfRange(i, "AliAODVZERO:::BGTriggerV0A",32)) return kFALSE;
  UInt_t test = 1;
  return ( fBGtriggerV0A & (test << i) ? kTRUE : kFALSE );
}

//__________________________________________________________________________
Bool_t AliAODVZERO::BBTriggerV0C(Int_t i) const
{
  // returns offline beam-beam flags in V0C
  // one bit per cell
  if (OutOfRange(i, "AliAODVZERO:::BBTriggerV0C",32)) return kFALSE;
  UInt_t test = 1;
  return ( fBBtriggerV0C & (test << i) ? kTRUE : kFALSE );
}

//__________________________________________________________________________
Bool_t AliAODVZERO::BGTriggerV0C(Int_t i) const
{
  // returns offline beam-gasflags in V0C
  // one bit per cell
  if (OutOfRange(i, "AliAODVZERO:::BGTriggerV0C",32)) return kFALSE;
  UInt_t test = 1;
  return ( fBGtriggerV0C & (test << i) ? kTRUE : kFALSE );
}

//__________________________________________________________________________
Bool_t AliAODVZERO::GetBBFlag(Int_t i) const

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

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

{
  // returns online beam-gas flag in V0
  // one boolean per cell
  if (OutOfRange(i, "AliAODVZERO::GetBGFlag:",64)) return kFALSE;
  return fBGFlag[i];
}
Commit	Line	Data
aa2494a4	1	/**************************************************************************
	2	* Copyright(c) 1998-2007, 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	// Container class for AOD VZERO data
	18	// Author: Cvetan Cheshkov
	19	// cvetan.cheshkov@cern.ch 2/02/2011
	20	//-------------------------------------------------------------------------
	21
	22	#include "AliAODVZERO.h"
	23	#include "AliLog.h"
	24
	25	ClassImp(AliAODVZERO)
	26
	27	//__________________________________________________________________________
	28	AliAODVZERO::AliAODVZERO()
	29	:AliVVZERO(),
	30	fBBtriggerV0A(0),
	31	fBGtriggerV0A(0),
	32	fBBtriggerV0C(0),
	33	fBGtriggerV0C(0),
	34	fV0ATime(-1024),
	35	fV0CTime(-1024),
	36	fV0ADecision(kV0Invalid),
18b2dabf	37	fV0CDecision(kV0Invalid),
	38	fTriggerChargeA(0),
	39	fTriggerChargeC(0),
	40	fTriggerBits(0)
aa2494a4	41	{
	42	// Default constructor
	43	for(Int_t j=0; j<64; j++){
	44	fMultiplicity[j] = 0.0;
	45	fBBFlag[j]= kFALSE;
	46	fBGFlag[j]= kFALSE;
	47	}
	48	}
	49
	50	//__________________________________________________________________________
	51	AliAODVZERO::AliAODVZERO(const AliAODVZERO &source)
	52	:AliVVZERO(source),
	53	fBBtriggerV0A(source.fBBtriggerV0A),
	54	fBGtriggerV0A(source.fBGtriggerV0A),
	55	fBBtriggerV0C(source.fBBtriggerV0C),
	56	fBGtriggerV0C(source.fBGtriggerV0C),
	57	fV0ATime(source.fV0ATime),
	58	fV0CTime(source.fV0CTime),
	59	fV0ADecision(source.fV0ADecision),
18b2dabf	60	fV0CDecision(source.fV0CDecision),
	61	fTriggerChargeA(source.fTriggerChargeA),
	62	fTriggerChargeC(source.fTriggerChargeC),
	63	fTriggerBits(source.fTriggerBits)
aa2494a4	64	{
	65	// Default constructor
	66	for(Int_t j=0; j<64; j++) {
	67	fMultiplicity[j] = source.fMultiplicity[j];
	68	fBBFlag[j] = source.fBBFlag[j];
	69	fBGFlag[j] = source.fBGFlag[j];
	70	}
	71	}
	72
	73	//__________________________________________________________________________
	74	AliAODVZERO::AliAODVZERO(const AliVVZERO &source)
	75	:AliVVZERO(source),
	76	fBBtriggerV0A(0),
	77	fBGtriggerV0A(0),
	78	fBBtriggerV0C(0),
	79	fBGtriggerV0C(0),
	80	fV0ATime(source.GetV0ATime()),
	81	fV0CTime(source.GetV0CTime()),
	82	fV0ADecision(source.GetV0ADecision()),
18b2dabf	83	fV0CDecision(source.GetV0CDecision()),
	84	fTriggerChargeA(source.GetTriggerChargeA()),
	85	fTriggerChargeC(source.GetTriggerChargeC()),
	86	fTriggerBits(source.GetTriggerBits())
aa2494a4	87	{
	88	// Default constructor
	89	for(Int_t j=0; j<64; j++) {
	90	fMultiplicity[j] = source.GetMultiplicity(j);
	91	fBBFlag[j] = source.GetBBFlag(j);
	92	fBGFlag[j] = source.GetBGFlag(j);
	93	}
	94
	95	for(Int_t j=0; j<32; j++) {
	96	if (source.BBTriggerV0A(j)) fBBtriggerV0A \|= (1 << j);
	97	if (source.BGTriggerV0A(j)) fBGtriggerV0A \|= (1 << j);
	98	if (source.BBTriggerV0C(j)) fBBtriggerV0C \|= (1 << j);
	99	if (source.BGTriggerV0C(j)) fBGtriggerV0C \|= (1 << j);
	100	}
	101	}
	102
	103	//__________________________________________________________________________
	104	AliAODVZERO& AliAODVZERO::operator=(const AliAODVZERO& source)
	105	{
	106	// Assignment operator
	107	//
	108	if(this==&source) return *this;
	109	AliVVZERO::operator=(source);
	110	// Assignment operator
	111	fBBtriggerV0A=source.fBBtriggerV0A;
	112	fBGtriggerV0A=source.fBGtriggerV0A;
	113	fBBtriggerV0C=source.fBBtriggerV0C;
	114	fBGtriggerV0C=source.fBGtriggerV0C;
	115
	116	fV0ATime = source.fV0ATime;
	117	fV0CTime = source.fV0CTime;
	118	fV0ADecision = source.fV0ADecision;
	119	fV0CDecision = source.fV0CDecision;
18b2dabf	120	fTriggerChargeA = source.fTriggerChargeA;
	121	fTriggerChargeC = source.fTriggerChargeC;
	122	fTriggerBits = source.fTriggerBits;
aa2494a4	123
	124	for(Int_t j=0; j<64; j++) {
	125	fMultiplicity[j] = source.fMultiplicity[j];
	126	fBBFlag[j] = source.fBBFlag[j];
	127	fBGFlag[j] = source.fBGFlag[j];
	128	}
	129	return *this;
	130	}
	131
ae2bccf1	132	//__________________________________________________________________________
	133	AliAODVZERO& AliAODVZERO::operator=(const AliVVZERO& source)
	134	{
	135	// Assignment operator
	136	// used in esd->aod filter
	137	if(this==&source) return *this;
	138	AliVVZERO::operator=(source);
	139
	140	fV0ATime = source.GetV0ATime();
	141	fV0CTime = source.GetV0CTime();
	142	fV0ADecision = source.GetV0ADecision();
	143	fV0CDecision = source.GetV0CDecision();
18b2dabf	144	fTriggerChargeA = source.GetTriggerChargeA();
	145	fTriggerChargeC = source.GetTriggerChargeC();
	146	fTriggerBits = source.GetTriggerBits();
ae2bccf1	147
	148	for(Int_t j=0; j<64; j++) {
	149	fMultiplicity[j] = source.GetMultiplicity(j);
	150	fBBFlag[j] = source.GetBBFlag(j);
	151	fBGFlag[j] = source.GetBGFlag(j);
	152	}
	153
	154	fBBtriggerV0A = fBGtriggerV0A = fBBtriggerV0C = fBGtriggerV0C = 0;
	155	for(Int_t j=0; j<32; j++) {
	156	if (source.BBTriggerV0A(j)) fBBtriggerV0A \|= (1 << j);
	157	if (source.BGTriggerV0A(j)) fBGtriggerV0A \|= (1 << j);
	158	if (source.BBTriggerV0C(j)) fBBtriggerV0C \|= (1 << j);
	159	if (source.BGTriggerV0C(j)) fBGtriggerV0C \|= (1 << j);
	160	}
	161
	162	return *this;
	163
	164	}
	165
aa2494a4	166	//__________________________________________________________________________
	167	Short_t AliAODVZERO::GetNbPMV0A() const
	168	{
	169	// Returns the number of
	170	// fired PM in V0A
	171	Short_t n=0;
	172	for(Int_t i=32;i<64;i++)
	173	if (fMultiplicity[i]>0) n++;
	174	return n;
	175	}
	176
	177	//__________________________________________________________________________
	178	Short_t AliAODVZERO::GetNbPMV0C() const
	179	{
	180	// Returns the number of
	181	// fired PM in V0C
	182	Short_t n=0;
	183	for(Int_t i=0;i<32;i++)
	184	if (fMultiplicity[i]>0) n++;
	185	return n;
	186	}
	187
	188	//__________________________________________________________________________
	189	Float_t AliAODVZERO::GetMTotV0A() const
	190	{
	191	// returns total multiplicity
	192	// in V0A
	193	Float_t mul=0.0;
	194	for(Int_t i=32;i<64;i++)
	195	mul+= fMultiplicity[i];
	196	return mul;
	197	}
	198
	199	//__________________________________________________________________________
	200	Float_t AliAODVZERO::GetMTotV0C() const
	201	{
	202	// returns total multiplicity
	203	// in V0C
	204	Float_t mul=0.0;
	205	for(Int_t i=0;i<32;i++)
	206	mul+= fMultiplicity[i];
	207	return mul;
	208	}
	209
	210	//__________________________________________________________________________
	211	Float_t AliAODVZERO::GetMRingV0A(Int_t ring) const
	212	{
	213	// returns multiplicity in a
	214	// given ring of V0A
	215	if (OutOfRange(ring, "AliAODVZERO:::GetMRingV0A",4)) return -1;
	216	Float_t mul =0.0;
	217
	218	if (ring == 0) for(Int_t i=32;i<40;i++) mul += fMultiplicity[i];
	219	if (ring == 1) for(Int_t i=40;i<48;i++) mul += fMultiplicity[i];
	220	if (ring == 2) for(Int_t i=48;i<56;i++) mul += fMultiplicity[i];
	221	if (ring == 3) for(Int_t i=56;i<64;i++) mul += fMultiplicity[i];
	222	return mul ;
	223	}
	224
	225	//__________________________________________________________________________
	226	Float_t AliAODVZERO::GetMRingV0C(Int_t ring) const
	227	{
	228	// returns multiplicity in a
	229	// given ring of V0C
230	if (OutOfRange(ring, "AliAODVZERO:::GetMRingV0C",4)) return -1;
231	Float_t mul =0.0;
232
233	if (ring == 0) for(Int_t i=0;i<8;i++) mul += fMultiplicity[i];
234	if (ring == 1) for(Int_t i=8;i<16;i++) mul += fMultiplicity[i];
235	if (ring == 2) for(Int_t i=16;i<24;i++) mul += fMultiplicity[i];
236	if (ring == 3) for(Int_t i=24;i<32;i++) mul += fMultiplicity[i];
237	return mul ;
238	}
239
240	//__________________________________________________________________________
241	Float_t AliAODVZERO::GetMultiplicity(Int_t i) const
242
243	{
244	// returns multiplicity in a
245	// given cell of V0
246	if (OutOfRange(i, "AliAODVZERO::GetMultiplicity:",64)) return -1;
247	return fMultiplicity[i];
248	}
249
250	//__________________________________________________________________________
251	Float_t AliAODVZERO::GetMultiplicityV0A(Int_t i) const
252
253	{
254	// returns multiplicity in a
255	// given cell of V0A
256	if (OutOfRange(i, "AliAODVZERO::GetMultiplicityV0A:",32)) return -1;
257	return fMultiplicity[32+i];
258	}
259
260	//__________________________________________________________________________
261	Float_t AliAODVZERO::GetMultiplicityV0C(Int_t i) const
262
263	{
264	// returns multiplicity in a
265	// given cell of V0C
266	if (OutOfRange(i, "AliAODVZERO::GetMultiplicityV0C:",32)) return -1;
267	return fMultiplicity[i];
268	}
269
270	//__________________________________________________________________________
271	Bool_t AliAODVZERO::BBTriggerV0A(Int_t i) const
272	{
273	// returns offline beam-beam flags in V0A
274	// one bit per cell
275	if (OutOfRange(i, "AliAODVZERO:::BBTriggerV0A",32)) return kFALSE;
276	UInt_t test = 1;
277	return ( fBBtriggerV0A & (test << i) ? kTRUE : kFALSE );
278	}
279
280	//__________________________________________________________________________
281	Bool_t AliAODVZERO::BGTriggerV0A(Int_t i) const
282	{
283	// returns offline beam-gas flags in V0A
284	// one bit per cell
285	if (OutOfRange(i, "AliAODVZERO:::BGTriggerV0A",32)) return kFALSE;
286	UInt_t test = 1;
287	return ( fBGtriggerV0A & (test << i) ? kTRUE : kFALSE );
288	}
289
290	//__________________________________________________________________________
291	Bool_t AliAODVZERO::BBTriggerV0C(Int_t i) const
292	{
293	// returns offline beam-beam flags in V0C
294	// one bit per cell
295	if (OutOfRange(i, "AliAODVZERO:::BBTriggerV0C",32)) return kFALSE;
296	UInt_t test = 1;
297	return ( fBBtriggerV0C & (test << i) ? kTRUE : kFALSE );
298	}
299
300	//__________________________________________________________________________
301	Bool_t AliAODVZERO::BGTriggerV0C(Int_t i) const
302	{
303	// returns offline beam-gasflags in V0C
304	// one bit per cell
305	if (OutOfRange(i, "AliAODVZERO:::BGTriggerV0C",32)) return kFALSE;
306	UInt_t test = 1;
307	return ( fBGtriggerV0C & (test << i) ? kTRUE : kFALSE );
308	}
309
310	//__________________________________________________________________________
311	Bool_t AliAODVZERO::GetBBFlag(Int_t i) const
312
313	{
314	// returns online beam-beam flag in V0
315	// one boolean per cell
316	if (OutOfRange(i, "AliAODVZERO::GetBBFlag:",64)) return kFALSE;
317	return fBBFlag[i];
318	}
319
320	//__________________________________________________________________________
321	Bool_t AliAODVZERO::GetBGFlag(Int_t i) const
322
323	{
324	// returns online beam-gas flag in V0
325	// one boolean per cell
326	if (OutOfRange(i, "AliAODVZERO::GetBGFlag:",64)) return kFALSE;
327	return fBGFlag[i];
328	}