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