STEER/AliAODVZERO.cxx

   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),
  37    fV0CDecision(kV0Invalid)
  38 {
  39    // Default constructor
  40    for(Int_t j=0; j<64; j++){
  41       fMultiplicity[j] = 0.0;
  42       fBBFlag[j]= kFALSE;
  43       fBGFlag[j]= kFALSE;
  44    }
  45 }
  46
  47 //__________________________________________________________________________
  48 AliAODVZERO::AliAODVZERO(const AliAODVZERO &source)
  49   :AliVVZERO(source),
  50    fBBtriggerV0A(source.fBBtriggerV0A),
  51    fBGtriggerV0A(source.fBGtriggerV0A),
  52    fBBtriggerV0C(source.fBBtriggerV0C),
  53    fBGtriggerV0C(source.fBGtriggerV0C),
  54    fV0ATime(source.fV0ATime),
  55    fV0CTime(source.fV0CTime),
  56    fV0ADecision(source.fV0ADecision),
  57    fV0CDecision(source.fV0CDecision)
  58 {
  59    // Default constructor
  60    for(Int_t j=0; j<64; j++) {
  61        fMultiplicity[j] = source.fMultiplicity[j];
  62        fBBFlag[j] = source.fBBFlag[j];
  63        fBGFlag[j] = source.fBGFlag[j];
  64    }
  65 }
  66
  67 //__________________________________________________________________________
  68 AliAODVZERO::AliAODVZERO(const AliVVZERO &source)
  69   :AliVVZERO(source),
  70    fBBtriggerV0A(0),
  71    fBGtriggerV0A(0),
  72    fBBtriggerV0C(0),
  73    fBGtriggerV0C(0),
  74    fV0ATime(source.GetV0ATime()),
  75    fV0CTime(source.GetV0CTime()),
  76    fV0ADecision(source.GetV0ADecision()),
  77    fV0CDecision(source.GetV0CDecision())
  78 {
  79    // Default constructor
  80    for(Int_t j=0; j<64; j++) {
  81      fMultiplicity[j] = source.GetMultiplicity(j);
  82      fBBFlag[j] = source.GetBBFlag(j);
  83      fBGFlag[j] = source.GetBGFlag(j);
  84    }
  85
  86    for(Int_t j=0; j<32; j++) {
  87      if (source.BBTriggerV0A(j)) fBBtriggerV0A |= (1 << j);
  88      if (source.BGTriggerV0A(j)) fBGtriggerV0A |= (1 << j);
  89      if (source.BBTriggerV0C(j)) fBBtriggerV0C |= (1 << j);
  90      if (source.BGTriggerV0C(j)) fBGtriggerV0C |= (1 << j);
  91    }
  92 }
  93
  94 //__________________________________________________________________________
  95 AliAODVZERO& AliAODVZERO::operator=(const AliAODVZERO& source)
  96 {
  97   // Assignment operator
  98   //
  99   if(this==&source) return *this;
 100   AliVVZERO::operator=(source);
 101   // Assignment operator
 102   fBBtriggerV0A=source.fBBtriggerV0A;
 103   fBGtriggerV0A=source.fBGtriggerV0A;
 104   fBBtriggerV0C=source.fBBtriggerV0C;
 105   fBGtriggerV0C=source.fBGtriggerV0C;
 106
 107   fV0ATime = source.fV0ATime;
 108   fV0CTime = source.fV0CTime;
 109   fV0ADecision = source.fV0ADecision;
 110   fV0CDecision = source.fV0CDecision;
 111
 112    for(Int_t j=0; j<64; j++) {
 113        fMultiplicity[j] = source.fMultiplicity[j];
 114        fBBFlag[j] = source.fBBFlag[j];
 115        fBGFlag[j] = source.fBGFlag[j];
 116    }
 117   return *this;
 118 }
 119
 120 //__________________________________________________________________________
 121 Short_t AliAODVZERO::GetNbPMV0A() const
 122 {
 123   // Returns the number of
 124   // fired PM in V0A
 125   Short_t n=0;
 126   for(Int_t i=32;i<64;i++)
 127     if (fMultiplicity[i]>0) n++;
 128   return n;
 129 }
 130
 131 //__________________________________________________________________________
 132 Short_t AliAODVZERO::GetNbPMV0C() const
 133 {
 134   // Returns the number of
 135   // fired PM in V0C
 136   Short_t n=0;
 137   for(Int_t i=0;i<32;i++)
 138     if (fMultiplicity[i]>0) n++;
 139   return n;
 140 }
 141
 142 //__________________________________________________________________________
 143 Float_t AliAODVZERO::GetMTotV0A() const
 144 {
 145   // returns total multiplicity
 146   // in V0A
 147   Float_t mul=0.0;
 148   for(Int_t i=32;i<64;i++)
 149     mul+=  fMultiplicity[i];
 150   return mul;
 151 }
 152
 153 //__________________________________________________________________________
 154 Float_t AliAODVZERO::GetMTotV0C() const
 155 {
 156   // returns total multiplicity
 157   // in V0C
 158   Float_t mul=0.0;
 159   for(Int_t i=0;i<32;i++)
 160     mul+=  fMultiplicity[i];
 161   return mul;
 162 }
 163
 164 //__________________________________________________________________________
 165 Float_t AliAODVZERO::GetMRingV0A(Int_t ring) const
 166 {
 167   // returns multiplicity in a
 168   // given ring of V0A
 169   if (OutOfRange(ring, "AliAODVZERO:::GetMRingV0A",4)) return -1;
 170   Float_t mul =0.0;
 171
 172   if (ring == 0) for(Int_t i=32;i<40;i++) mul +=  fMultiplicity[i];
 173   if (ring == 1) for(Int_t i=40;i<48;i++) mul +=  fMultiplicity[i];
 174   if (ring == 2) for(Int_t i=48;i<56;i++) mul +=  fMultiplicity[i];
 175   if (ring == 3) for(Int_t i=56;i<64;i++) mul +=  fMultiplicity[i];
 176   return mul ;
 177 }
 178
 179 //__________________________________________________________________________
 180 Float_t AliAODVZERO::GetMRingV0C(Int_t ring) const
 181 {
 182   // returns multiplicity in a
 183   // given ring of V0C
 184   if (OutOfRange(ring, "AliAODVZERO:::GetMRingV0C",4)) return -1;
 185   Float_t mul =0.0;
 186
 187   if (ring == 0) for(Int_t i=0;i<8;i++)   mul +=  fMultiplicity[i];
 188   if (ring == 1) for(Int_t i=8;i<16;i++)  mul +=  fMultiplicity[i];
 189   if (ring == 2) for(Int_t i=16;i<24;i++) mul +=  fMultiplicity[i];
 190   if (ring == 3) for(Int_t i=24;i<32;i++) mul +=  fMultiplicity[i];
 191   return mul ;
 192 }
 193
 194 //__________________________________________________________________________
 195 Float_t AliAODVZERO::GetMultiplicity(Int_t i) const
 196
 197 {
 198   // returns multiplicity in a
 199   // given cell of V0
 200   if (OutOfRange(i, "AliAODVZERO::GetMultiplicity:",64)) return -1;
 201   return fMultiplicity[i];
 202 }
 203
 204 //__________________________________________________________________________
 205 Float_t AliAODVZERO::GetMultiplicityV0A(Int_t i) const
 206
 207 {
 208   // returns multiplicity in a
 209   // given cell of V0A
 210   if (OutOfRange(i, "AliAODVZERO::GetMultiplicityV0A:",32)) return -1;
 211   return fMultiplicity[32+i];
 212 }
 213
 214 //__________________________________________________________________________
 215 Float_t AliAODVZERO::GetMultiplicityV0C(Int_t i) const
 216
 217 {
 218   // returns multiplicity in a
 219   // given cell of V0C
 220   if (OutOfRange(i, "AliAODVZERO::GetMultiplicityV0C:",32)) return -1;
 221   return fMultiplicity[i];
 222 }
 223
 224 //__________________________________________________________________________
 225 Bool_t AliAODVZERO::BBTriggerV0A(Int_t i) const
 226 {
 227   // returns offline beam-beam flags in V0A
 228   // one bit per cell
 229   if (OutOfRange(i, "AliAODVZERO:::BBTriggerV0A",32)) return kFALSE;
 230   UInt_t test = 1;
 231   return ( fBBtriggerV0A & (test << i) ? kTRUE : kFALSE );
 232 }
 233
 234 //__________________________________________________________________________
 235 Bool_t AliAODVZERO::BGTriggerV0A(Int_t i) const
 236 {
 237   // returns offline beam-gas flags in V0A
 238   // one bit per cell
 239   if (OutOfRange(i, "AliAODVZERO:::BGTriggerV0A",32)) return kFALSE;
 240   UInt_t test = 1;
 241   return ( fBGtriggerV0A & (test << i) ? kTRUE : kFALSE );
 242 }
 243
 244 //__________________________________________________________________________
 245 Bool_t AliAODVZERO::BBTriggerV0C(Int_t i) const
 246 {
 247   // returns offline beam-beam flags in V0C
 248   // one bit per cell
 249   if (OutOfRange(i, "AliAODVZERO:::BBTriggerV0C",32)) return kFALSE;
 250   UInt_t test = 1;
 251   return ( fBBtriggerV0C & (test << i) ? kTRUE : kFALSE );
 252 }
 253
 254 //__________________________________________________________________________
 255 Bool_t AliAODVZERO::BGTriggerV0C(Int_t i) const
 256 {
 257   // returns offline beam-gasflags in V0C
 258   // one bit per cell
 259   if (OutOfRange(i, "AliAODVZERO:::BGTriggerV0C",32)) return kFALSE;
 260   UInt_t test = 1;
 261   return ( fBGtriggerV0C & (test << i) ? kTRUE : kFALSE );
 262 }
 263
 264 //__________________________________________________________________________
 265 Bool_t AliAODVZERO::GetBBFlag(Int_t i) const
 266
 267 {
 268   // returns online beam-beam flag in V0
 269   // one boolean per cell
 270   if (OutOfRange(i, "AliAODVZERO::GetBBFlag:",64)) return kFALSE;
 271   return fBBFlag[i];
 272 }
 273
 274 //__________________________________________________________________________
 275 Bool_t AliAODVZERO::GetBGFlag(Int_t i) const
 276
 277 {
 278   // returns online beam-gas flag in V0
 279   // one boolean per cell
 280   if (OutOfRange(i, "AliAODVZERO::GetBGFlag:",64)) return kFALSE;
 281   return fBGFlag[i];
 282 }