STEER/AliESDVZERO.cxx

   1 #include "AliESDVZERO.h"
   2 #include "AliLog.h"
   3
   4 ClassImp(AliESDVZERO)
   5
   6 //__________________________________________________________________________
   7 AliESDVZERO::AliESDVZERO()
   8   :TObject(),
   9    fBBtriggerV0A(0),
  10    fBGtriggerV0A(0),
  11    fBBtriggerV0C(0),
  12    fBGtriggerV0C(0),
  13    fV0ATime(-1024),
  14    fV0CTime(-1024),
  15    fV0ATimeError(0),
  16    fV0CTimeError(0),
  17    fV0ADecision(kV0Invalid),
  18    fV0CDecision(kV0Invalid)
  19 {
  20    // Default constructor
  21    for(Int_t j=0; j<64; j++){
  22       fMultiplicity[j] = 0.0;
  23       fAdc[j]   = 0.0;
  24       fTime[j]  = 0.0;
  25       fWidth[j] = 0.0;
  26       fBBFlag[j]= kFALSE;
  27       fBGFlag[j]= kFALSE;
  28    }
  29 }
  30
  31 //__________________________________________________________________________
  32 AliESDVZERO::AliESDVZERO(const AliESDVZERO &o)
  33   :TObject(o),
  34    fBBtriggerV0A(o.fBBtriggerV0A),
  35    fBGtriggerV0A(o.fBGtriggerV0A),
  36    fBBtriggerV0C(o.fBBtriggerV0C),
  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)
  44 {
  45    // Default constructor
  46    for(Int_t j=0; j<64; j++) {
  47        fMultiplicity[j] = o.fMultiplicity[j];
  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];
  53    }
  54 }
  55
  56 //__________________________________________________________________________
  57 AliESDVZERO::AliESDVZERO(UInt_t BBtriggerV0A, UInt_t BGtriggerV0A,
  58               UInt_t BBtriggerV0C, UInt_t BGtriggerV0C,
  59               Float_t *Multiplicity, Float_t *Adc,
  60               Float_t *Time, Float_t *Width, Bool_t *BBFlag, Bool_t *BGFlag)
  61   :TObject(),
  62    fBBtriggerV0A(BBtriggerV0A),
  63    fBGtriggerV0A(BGtriggerV0A),
  64    fBBtriggerV0C(BBtriggerV0C),
  65    fBGtriggerV0C(BGtriggerV0C),
  66    fV0ATime(-1024),
  67    fV0CTime(-1024),
  68    fV0ATimeError(0),
  69    fV0CTimeError(0),
  70    fV0ADecision(kV0Invalid),
  71    fV0CDecision(kV0Invalid)
  72 {
  73    // Constructor
  74    for(Int_t j=0; j<64; j++) {
  75        fMultiplicity[j] = Multiplicity[j];
  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];
  81    }
  82 }
  83
  84 //__________________________________________________________________________
  85 AliESDVZERO& AliESDVZERO::operator=(const AliESDVZERO& o)
  86 {
  87
  88   if(this==&o) return *this;
  89   TObject::operator=(o);
  90   // Assignment operator
  91   fBBtriggerV0A=o.fBBtriggerV0A;
  92   fBGtriggerV0A=o.fBGtriggerV0A;
  93   fBBtriggerV0C=o.fBBtriggerV0C;
  94   fBGtriggerV0C=o.fBGtriggerV0C;
  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
 103    for(Int_t j=0; j<64; j++) {
 104        fMultiplicity[j] = o.fMultiplicity[j];
 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];
 110    }
 111   return *this;
 112 }
 113
 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
 128 //__________________________________________________________________________
 129 Short_t AliESDVZERO::GetNbPMV0A() const
 130 {
 131   // Returns the number of
 132   // fired PM in V0A
 133   Short_t n=0;
 134   for(Int_t i=32;i<64;i++)
 135     if (fMultiplicity[i]>0) n++;
 136   return n;
 137 }
 138
 139 //__________________________________________________________________________
 140 Short_t AliESDVZERO::GetNbPMV0C() const
 141 {
 142   // Returns the number of
 143   // fired PM in V0C
 144   Short_t n=0;
 145   for(Int_t i=0;i<32;i++)
 146     if (fMultiplicity[i]>0) n++;
 147   return n;
 148 }
 149
 150 //__________________________________________________________________________
 151 Float_t AliESDVZERO::GetMTotV0A() const
 152 {
 153   // returns total multiplicity
 154   // in V0A
 155   Float_t mul=0.0;
 156   for(Int_t i=32;i<64;i++)
 157     mul+=  fMultiplicity[i];
 158   return mul;
 159 }
 160
 161 //__________________________________________________________________________
 162 Float_t AliESDVZERO::GetMTotV0C() const
 163 {
 164   // returns total multiplicity
 165   // in V0C
 166   Float_t mul=0.0;
 167   for(Int_t i=0;i<32;i++)
 168     mul+=  fMultiplicity[i];
 169   return mul;
 170 }
 171
 172 //__________________________________________________________________________
 173 Float_t* AliESDVZERO::GetMRingV0A() const
 174 {
 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");
 178   AliInfo("use Float_t AliESDVZERO::GetMRingV0C(Int_t ring)");
 179   return 0x0;
 180 }
 181
 182 //__________________________________________________________________________
 183 Float_t* AliESDVZERO::GetMRingV0C() const
 184 {
 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");
 188   AliInfo("use Float_t AliESDVZERO::GetMRingV0C(Int_t ring)");
 189   return 0x0;
 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 }
 401
 402 //__________________________________________________________________________
 403 Bool_t AliESDVZERO::OutOfRange(Int_t i, const char* /*s*/, Int_t upper) const
 404 {
 405   // checks if i is a valid index.
 406   // s = name of calling method
 407   if (i > upper || i < 0) {
 408 //    cout << s << " Index " << i << " out of range" << endl;
 409      AliInfo(Form("Index %d out of range",i));
 410      return kTRUE;
 411   }
 412   return kFALSE;
 413 }
 414