STEER/ESD/AliESDVZERO.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 ESD VZERO data
  18 //     Author: Brigitte Cheynis & Cvetan Cheshkov
  19 //-------------------------------------------------------------------------
  20
  21 #include "AliESDVZERO.h"
  22 #include "AliLog.h"
  23
  24 ClassImp(AliESDVZERO)
  25
  26 //__________________________________________________________________________
  27 AliESDVZERO::AliESDVZERO()
  28   :AliVVZERO(),
  29    fBBtriggerV0A(0),
  30    fBGtriggerV0A(0),
  31    fBBtriggerV0C(0),
  32    fBGtriggerV0C(0),
  33    fV0ATime(-1024),
  34    fV0CTime(-1024),
  35    fV0ATimeError(0),
  36    fV0CTimeError(0),
  37    fV0ADecision(kV0Invalid),
  38    fV0CDecision(kV0Invalid),
  39    fTriggerChargeA(0),
  40    fTriggerChargeC(0),
  41    fTriggerBits(0)
  42 {
  43    // Default constructor
  44    for(Int_t j=0; j<64; j++){
  45       fMultiplicity[j] = 0.0;
  46       fAdc[j]   = 0.0;
  47       fTime[j]  = 0.0;
  48       fWidth[j] = 0.0;
  49       fBBFlag[j]= kFALSE;
  50       fBGFlag[j]= kFALSE;
  51    }
  52 }
  53
  54 //__________________________________________________________________________
  55 AliESDVZERO::AliESDVZERO(const AliESDVZERO &o)
  56   :AliVVZERO(o),
  57    fBBtriggerV0A(o.fBBtriggerV0A),
  58    fBGtriggerV0A(o.fBGtriggerV0A),
  59    fBBtriggerV0C(o.fBBtriggerV0C),
  60    fBGtriggerV0C(o.fBGtriggerV0C),
  61    fV0ATime(o.fV0ATime),
  62    fV0CTime(o.fV0CTime),
  63    fV0ATimeError(o.fV0ATimeError),
  64    fV0CTimeError(o.fV0CTimeError),
  65    fV0ADecision(o.fV0ADecision),
  66    fV0CDecision(o.fV0CDecision),
  67    fTriggerChargeA(o.fTriggerChargeA),
  68    fTriggerChargeC(o.fTriggerChargeC),
  69    fTriggerBits(o.fTriggerBits)
  70 {
  71    // Default constructor
  72    for(Int_t j=0; j<64; j++) {
  73        fMultiplicity[j] = o.fMultiplicity[j];
  74        fAdc[j]    = o.fAdc[j];
  75        fTime[j]   = o.fTime[j];
  76        fWidth[j]  = o.fWidth[j];
  77        fBBFlag[j] = o.fBBFlag[j];
  78        fBGFlag[j] = o.fBGFlag[j];
  79    }
  80 }
  81
  82 //__________________________________________________________________________
  83 AliESDVZERO::AliESDVZERO(UInt_t BBtriggerV0A, UInt_t BGtriggerV0A,
  84               UInt_t BBtriggerV0C, UInt_t BGtriggerV0C,
  85               Float_t *Multiplicity, Float_t *Adc,
  86               Float_t *Time, Float_t *Width, Bool_t *BBFlag, Bool_t *BGFlag)
  87   :AliVVZERO(),
  88    fBBtriggerV0A(BBtriggerV0A),
  89    fBGtriggerV0A(BGtriggerV0A),
  90    fBBtriggerV0C(BBtriggerV0C),
  91    fBGtriggerV0C(BGtriggerV0C),
  92    fV0ATime(-1024),
  93    fV0CTime(-1024),
  94    fV0ATimeError(0),
  95    fV0CTimeError(0),
  96    fV0ADecision(kV0Invalid),
  97    fV0CDecision(kV0Invalid),
  98    fTriggerChargeA(0),
  99    fTriggerChargeC(0),
 100    fTriggerBits(0)
 101 {
 102    // Constructor
 103    for(Int_t j=0; j<64; j++) {
 104        fMultiplicity[j] = Multiplicity[j];
 105        fAdc[j]    = Adc[j];
 106        fTime[j]   = Time[j];
 107        fWidth[j]  = Width[j];
 108        fBBFlag[j] = BBFlag[j];
 109        fBGFlag[j] = BGFlag[j];
 110    }
 111 }
 112
 113 //__________________________________________________________________________
 114 AliESDVZERO& AliESDVZERO::operator=(const AliESDVZERO& o)
 115 {
 116
 117   if(this==&o) return *this;
 118   AliVVZERO::operator=(o);
 119   // Assignment operator
 120   fBBtriggerV0A=o.fBBtriggerV0A;
 121   fBGtriggerV0A=o.fBGtriggerV0A;
 122   fBBtriggerV0C=o.fBBtriggerV0C;
 123   fBGtriggerV0C=o.fBGtriggerV0C;
 124
 125   fV0ATime = o.fV0ATime;
 126   fV0CTime = o.fV0CTime;
 127   fV0ATimeError = o.fV0ATimeError;
 128   fV0CTimeError = o.fV0CTimeError;
 129   fV0ADecision = o.fV0ADecision;
 130   fV0CDecision = o.fV0CDecision;
 131   fTriggerChargeA = o.fTriggerChargeA;
 132   fTriggerChargeC = o.fTriggerChargeC;
 133   fTriggerBits = o.fTriggerBits;
 134
 135    for(Int_t j=0; j<64; j++) {
 136        fMultiplicity[j] = o.fMultiplicity[j];
 137        fAdc[j]    = o.fAdc[j];
 138        fTime[j]   = o.fTime[j];
 139        fWidth[j]  = o.fWidth[j];
 140        fBBFlag[j] = o.fBBFlag[j];
 141        fBGFlag[j] = o.fBGFlag[j];
 142    }
 143   return *this;
 144 }
 145
 146 //______________________________________________________________________________
 147 void AliESDVZERO::Copy(TObject &obj) const {
 148
 149   // this overwrites the virtual TOBject::Copy()
 150   // to allow run time copying without casting
 151   // in AliESDEvent
 152
 153   if(this==&obj)return;
 154   AliESDVZERO *robj = dynamic_cast<AliESDVZERO*>(&obj);
 155   if(!robj)return; // not an AliESDVZERO
 156   *robj = *this;
 157
 158 }
 159
 160 //__________________________________________________________________________
 161 Short_t AliESDVZERO::GetNbPMV0A() const
 162 {
 163   // Returns the number of
 164   // fired PM in V0A
 165   Short_t n=0;
 166   for(Int_t i=32;i<64;i++)
 167     if (fMultiplicity[i]>0) n++;
 168   return n;
 169 }
 170
 171 //__________________________________________________________________________
 172 Short_t AliESDVZERO::GetNbPMV0C() const
 173 {
 174   // Returns the number of
 175   // fired PM in V0C
 176   Short_t n=0;
 177   for(Int_t i=0;i<32;i++)
 178     if (fMultiplicity[i]>0) n++;
 179   return n;
 180 }
 181
 182 //__________________________________________________________________________
 183 Float_t AliESDVZERO::GetMTotV0A() const
 184 {
 185   // returns total multiplicity
 186   // in V0A
 187   Float_t mul=0.0;
 188   for(Int_t i=32;i<64;i++)
 189     mul+=  fMultiplicity[i];
 190   return mul;
 191 }
 192
 193 //__________________________________________________________________________
 194 Float_t AliESDVZERO::GetMTotV0C() const
 195 {
 196   // returns total multiplicity
 197   // in V0C
 198   Float_t mul=0.0;
 199   for(Int_t i=0;i<32;i++)
 200     mul+=  fMultiplicity[i];
 201   return mul;
 202 }
 203
 204 //__________________________________________________________________________
 205 Float_t AliESDVZERO::GetMRingV0A(Int_t ring) const
 206 {
 207   // returns multiplicity in a
 208   // given ring of V0A
 209   if (OutOfRange(ring, "AliESDVZERO:::GetMRingV0A",4)) return -1;
 210   Float_t mul =0.0;
 211
 212   if (ring == 0) for(Int_t i=32;i<40;i++) mul +=  fMultiplicity[i];
 213   if (ring == 1) for(Int_t i=40;i<48;i++) mul +=  fMultiplicity[i];
 214   if (ring == 2) for(Int_t i=48;i<56;i++) mul +=  fMultiplicity[i];
 215   if (ring == 3) for(Int_t i=56;i<64;i++) mul +=  fMultiplicity[i];
 216   return mul ;
 217 }
 218
 219 //__________________________________________________________________________
 220 Float_t AliESDVZERO::GetMRingV0C(Int_t ring) const
 221 {
 222   // returns multiplicity in a
 223   // given ring of V0C
 224   if (OutOfRange(ring, "AliESDVZERO:::GetMRingV0C",4)) return -1;
 225   Float_t mul =0.0;
 226
 227   if (ring == 0) for(Int_t i=0;i<8;i++)   mul +=  fMultiplicity[i];
 228   if (ring == 1) for(Int_t i=8;i<16;i++)  mul +=  fMultiplicity[i];
 229   if (ring == 2) for(Int_t i=16;i<24;i++) mul +=  fMultiplicity[i];
 230   if (ring == 3) for(Int_t i=24;i<32;i++) mul +=  fMultiplicity[i];
 231   return mul ;
 232 }
 233
 234 //__________________________________________________________________________
 235 Float_t AliESDVZERO::GetMultiplicity(Int_t i) const
 236
 237 {
 238   // returns multiplicity in a
 239   // given cell of V0
 240   if (OutOfRange(i, "AliESDVZERO::GetMultiplicity:",64)) return -1;
 241   return fMultiplicity[i];
 242 }
 243
 244 //__________________________________________________________________________
 245 Float_t AliESDVZERO::GetMultiplicityV0A(Int_t i) const
 246
 247 {
 248   // returns multiplicity in a
 249   // given cell of V0A
 250   if (OutOfRange(i, "AliESDVZERO::GetMultiplicityV0A:",32)) return -1;
 251   return fMultiplicity[32+i];
 252 }
 253
 254 //__________________________________________________________________________
 255 Float_t AliESDVZERO::GetMultiplicityV0C(Int_t i) const
 256
 257 {
 258   // returns multiplicity in a
 259   // given cell of V0C
 260   if (OutOfRange(i, "AliESDVZERO::GetMultiplicityV0C:",32)) return -1;
 261   return fMultiplicity[i];
 262 }
 263
 264 //__________________________________________________________________________
 265 Float_t AliESDVZERO::GetAdc(Int_t i) const
 266
 267 {
 268   // returns ADC charge in a
 269   // given cell of V0
 270   if (OutOfRange(i, "AliESDVZERO::GetAdc:",64)) return -1;
 271   return fAdc[i];
 272 }
 273
 274 //__________________________________________________________________________
 275 Float_t AliESDVZERO::GetAdcV0A(Int_t i) const
 276
 277 {
 278   // returns ADC charge in a
 279   // given cell of V0A
 280   if (OutOfRange(i, "AliESDVZERO::GetAdcV0A:",32)) return -1;
 281   return fAdc[32+i];
 282 }
 283
 284 //__________________________________________________________________________
 285 Float_t AliESDVZERO::GetAdcV0C(Int_t i) const
 286
 287 {
 288   // returns ADC charge in a
 289   // given cell of V0C
 290   if (OutOfRange(i, "AliESDVZERO::GetAdcV0C:",32)) return -1;
 291   return fAdc[i];
 292 }
 293
 294 //__________________________________________________________________________
 295 Float_t AliESDVZERO::GetTime(Int_t i) const
 296
 297 {
 298   // returns leading time measured by TDC
 299   // in a given cell of V0
 300   if (OutOfRange(i, "AliESDVZERO::GetTime:",64)) return -1;
 301   return fTime[i];
 302 }
 303
 304 //__________________________________________________________________________
 305 Float_t AliESDVZERO::GetTimeV0A(Int_t i) const
 306
 307 {
 308   // returns leading time measured by TDC
 309   // in a given cell of V0A
 310   if (OutOfRange(i, "AliESDVZERO::GetTimeV0A:",32)) return -1;
 311   return fTime[32+i];
 312 }
 313
 314 //__________________________________________________________________________
 315 Float_t AliESDVZERO::GetTimeV0C(Int_t i) const
 316
 317 {
 318   // returns leading time measured by TDC
 319   // in a given cell of V0C
 320   if (OutOfRange(i, "AliESDVZERO::GetTimeV0C:",32)) return -1;
 321   return fTime[i];
 322 }
 323
 324 //__________________________________________________________________________
 325 Float_t AliESDVZERO::GetWidth(Int_t i) const
 326
 327 {
 328   // returns time signal width
 329   // in a given cell of V0
 330   if (OutOfRange(i, "AliESDVZERO::GetWidth:",64)) return -1;
 331   return fWidth[i];
 332 }
 333
 334 //__________________________________________________________________________
 335 Float_t AliESDVZERO::GetWidthV0A(Int_t i) const
 336
 337 {
 338   // returns time signal width
 339   // in a given cell of V0A
 340   if (OutOfRange(i, "AliESDVZERO::GetWidthV0A:",32)) return -1;
 341   return fWidth[32+i];
 342 }
 343
 344 //__________________________________________________________________________
 345 Float_t AliESDVZERO::GetWidthV0C(Int_t i) const
 346
 347 {
 348   // returns time signal width
 349   // in a given cell of V0C
 350   if (OutOfRange(i, "AliESDVZERO::GetWidthV0C:",32)) return -1;
 351   return fWidth[i];
 352 }
 353
 354 //__________________________________________________________________________
 355 Bool_t AliESDVZERO::BBTriggerV0A(Int_t i) const
 356 {
 357   // returns offline beam-beam flags in V0A
 358   // one bit per cell
 359   if (OutOfRange(i, "AliESDVZERO:::BBTriggerV0A",32)) return kFALSE;
 360   UInt_t test = 1;
 361   return ( fBBtriggerV0A & (test << i) ? kTRUE : kFALSE );
 362 }
 363
 364 //__________________________________________________________________________
 365 Bool_t AliESDVZERO::BGTriggerV0A(Int_t i) const
 366 {
 367   // returns offline beam-gas flags in V0A
 368   // one bit per cell
 369   if (OutOfRange(i, "AliESDVZERO:::BGTriggerV0A",32)) return kFALSE;
 370   UInt_t test = 1;
 371   return ( fBGtriggerV0A & (test << i) ? kTRUE : kFALSE );
 372 }
 373
 374 //__________________________________________________________________________
 375 Bool_t AliESDVZERO::BBTriggerV0C(Int_t i) const
 376 {
 377   // returns offline beam-beam flags in V0C
 378   // one bit per cell
 379   if (OutOfRange(i, "AliESDVZERO:::BBTriggerV0C",32)) return kFALSE;
 380   UInt_t test = 1;
 381   return ( fBBtriggerV0C & (test << i) ? kTRUE : kFALSE );
 382 }
 383
 384 //__________________________________________________________________________
 385 Bool_t AliESDVZERO::BGTriggerV0C(Int_t i) const
 386 {
 387   // returns offline beam-gasflags in V0C
 388   // one bit per cell
 389   if (OutOfRange(i, "AliESDVZERO:::BGTriggerV0C",32)) return kFALSE;
 390   UInt_t test = 1;
 391   return ( fBGtriggerV0C & (test << i) ? kTRUE : kFALSE );
 392 }
 393
 394 //__________________________________________________________________________
 395 Bool_t AliESDVZERO::GetBBFlag(Int_t i) const
 396
 397 {
 398   // returns online beam-beam flag in V0
 399   // one boolean per cell
 400   if (OutOfRange(i, "AliESDVZERO::GetBBFlag:",64)) return kFALSE;
 401   return fBBFlag[i];
 402 }
 403
 404 //__________________________________________________________________________
 405 Bool_t AliESDVZERO::GetBGFlag(Int_t i) const
 406
 407 {
 408   // returns online beam-gas flag in V0
 409   // one boolean per cell
 410   if (OutOfRange(i, "AliESDVZERO::GetBGFlag:",64)) return kFALSE;
 411   return fBGFlag[i];
 412 }