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 Short_t AliESDVZERO::GetNbPMV0A() const
 116 {
 117   // Returns the number of
 118   // fired PM in V0A
 119   Short_t n=0;
 120   for(Int_t i=32;i<64;i++)
 121     if (fMultiplicity[i]>0) n++;
 122   return n;
 123 }
 124
 125 //__________________________________________________________________________
 126 Short_t AliESDVZERO::GetNbPMV0C() const
 127 {
 128   // Returns the number of
 129   // fired PM in V0C
 130   Short_t n=0;
 131   for(Int_t i=0;i<32;i++)
 132     if (fMultiplicity[i]>0) n++;
 133   return n;
 134 }
 135
 136 //__________________________________________________________________________
 137 Float_t AliESDVZERO::GetMTotV0A() const
 138 {
 139   // returns total multiplicity
 140   // in V0A
 141   Float_t mul=0.0;
 142   for(Int_t i=32;i<64;i++)
 143     mul+=  fMultiplicity[i];
 144   return mul;
 145 }
 146
 147 //__________________________________________________________________________
 148 Float_t AliESDVZERO::GetMTotV0C() const
 149 {
 150   // returns total multiplicity
 151   // in V0C
 152   Float_t mul=0.0;
 153   for(Int_t i=0;i<32;i++)
 154     mul+=  fMultiplicity[i];
 155   return mul;
 156 }
 157
 158 //__________________________________________________________________________
 159 Float_t* AliESDVZERO::GetMRingV0A() const
 160 {
 161 //  cout << "AliESDVZERO::GetMRingV0C() not supported any more" << endl;
 162 //  cout << "use Int_t AliESDVZERO::GetMRingV0C(Int_t ring)" << endl;
 163   AliInfo("AliESDVZERO::GetMRingV0C() not supported any more");
 164   AliInfo("use Float_t AliESDVZERO::GetMRingV0C(Int_t ring)");
 165   return 0x0;
 166 }
 167
 168 //__________________________________________________________________________
 169 Float_t* AliESDVZERO::GetMRingV0C() const
 170 {
 171 //  cout << "AliESDVZERO::GetMRingV0C() not supported any more" << endl;
 172 //  cout << "use Int_t AliESDVZERO::GetMRingV0C(Int_t ring)" << endl;
 173   AliInfo("AliESDVZERO::GetMRingV0C() not supported any more");
 174   AliInfo("use Float_t AliESDVZERO::GetMRingV0C(Int_t ring)");
 175   return 0x0;
 176 }
 177
 178 //__________________________________________________________________________
 179 Float_t AliESDVZERO::GetMRingV0A(Int_t ring) const
 180 {
 181   // returns multiplicity in a
 182   // given ring of V0A
 183   if (OutOfRange(ring, "AliESDVZERO:::GetMRingV0A",4)) return -1;
 184   Float_t mul =0.0;
 185
 186   if (ring == 0) for(Int_t i=32;i<40;i++) mul +=  fMultiplicity[i];
 187   if (ring == 1) for(Int_t i=40;i<48;i++) mul +=  fMultiplicity[i];
 188   if (ring == 2) for(Int_t i=48;i<56;i++) mul +=  fMultiplicity[i];
 189   if (ring == 3) for(Int_t i=56;i<64;i++) mul +=  fMultiplicity[i];
 190   return mul ;
 191 }
 192
 193 //__________________________________________________________________________
 194 Float_t AliESDVZERO::GetMRingV0C(Int_t ring) const
 195 {
 196   // returns multiplicity in a
 197   // given ring of V0C
 198   if (OutOfRange(ring, "AliESDVZERO:::GetMRingV0C",4)) return -1;
 199   Float_t mul =0.0;
 200
 201   if (ring == 0) for(Int_t i=0;i<8;i++)   mul +=  fMultiplicity[i];
 202   if (ring == 1) for(Int_t i=8;i<16;i++)  mul +=  fMultiplicity[i];
 203   if (ring == 2) for(Int_t i=16;i<24;i++) mul +=  fMultiplicity[i];
 204   if (ring == 3) for(Int_t i=24;i<32;i++) mul +=  fMultiplicity[i];
 205   return mul ;
 206 }
 207
 208 //__________________________________________________________________________
 209 Float_t AliESDVZERO::GetMultiplicity(Int_t i) const
 210
 211 {
 212   // returns multiplicity in a
 213   // given cell of V0
 214   if (OutOfRange(i, "AliESDVZERO::GetMultiplicity:",64)) return -1;
 215   return fMultiplicity[i];
 216 }
 217
 218 //__________________________________________________________________________
 219 Float_t AliESDVZERO::GetMultiplicityV0A(Int_t i) const
 220
 221 {
 222   // returns multiplicity in a
 223   // given cell of V0A
 224   if (OutOfRange(i, "AliESDVZERO::GetMultiplicityV0A:",32)) return -1;
 225   return fMultiplicity[32+i];
 226 }
 227
 228 //__________________________________________________________________________
 229 Float_t AliESDVZERO::GetMultiplicityV0C(Int_t i) const
 230
 231 {
 232   // returns multiplicity in a
 233   // given cell of V0C
 234   if (OutOfRange(i, "AliESDVZERO::GetMultiplicityV0C:",32)) return -1;
 235   return fMultiplicity[i];
 236 }
 237
 238 //__________________________________________________________________________
 239 Float_t AliESDVZERO::GetAdc(Int_t i) const
 240
 241 {
 242   // returns ADC charge in a
 243   // given cell of V0
 244   if (OutOfRange(i, "AliESDVZERO::GetAdc:",64)) return -1;
 245   return fAdc[i];
 246 }
 247
 248 //__________________________________________________________________________
 249 Float_t AliESDVZERO::GetAdcV0A(Int_t i) const
 250
 251 {
 252   // returns ADC charge in a
 253   // given cell of V0A
 254   if (OutOfRange(i, "AliESDVZERO::GetAdcV0A:",32)) return -1;
 255   return fAdc[32+i];
 256 }
 257
 258 //__________________________________________________________________________
 259 Float_t AliESDVZERO::GetAdcV0C(Int_t i) const
 260
 261 {
 262   // returns ADC charge in a
 263   // given cell of V0C
 264   if (OutOfRange(i, "AliESDVZERO::GetAdcV0C:",32)) return -1;
 265   return fAdc[i];
 266 }
 267
 268 //__________________________________________________________________________
 269 Float_t AliESDVZERO::GetTime(Int_t i) const
 270
 271 {
 272   // returns leading time measured by TDC
 273   // in a given cell of V0
 274   if (OutOfRange(i, "AliESDVZERO::GetTime:",64)) return -1;
 275   return fTime[i];
 276 }
 277
 278 //__________________________________________________________________________
 279 Float_t AliESDVZERO::GetTimeV0A(Int_t i) const
 280
 281 {
 282   // returns leading time measured by TDC
 283   // in a given cell of V0A
 284   if (OutOfRange(i, "AliESDVZERO::GetTimeV0A:",32)) return -1;
 285   return fTime[32+i];
 286 }
 287
 288 //__________________________________________________________________________
 289 Float_t AliESDVZERO::GetTimeV0C(Int_t i) const
 290
 291 {
 292   // returns leading time measured by TDC
 293   // in a given cell of V0C
 294   if (OutOfRange(i, "AliESDVZERO::GetTimeV0C:",32)) return -1;
 295   return fTime[i];
 296 }
 297
 298 //__________________________________________________________________________
 299 Float_t AliESDVZERO::GetWidth(Int_t i) const
 300
 301 {
 302   // returns time signal width
 303   // in a given cell of V0
 304   if (OutOfRange(i, "AliESDVZERO::GetWidth:",64)) return -1;
 305   return fWidth[i];
 306 }
 307
 308 //__________________________________________________________________________
 309 Float_t AliESDVZERO::GetWidthV0A(Int_t i) const
 310
 311 {
 312   // returns time signal width
 313   // in a given cell of V0A
 314   if (OutOfRange(i, "AliESDVZERO::GetWidthV0A:",32)) return -1;
 315   return fWidth[32+i];
 316 }
 317
 318 //__________________________________________________________________________
 319 Float_t AliESDVZERO::GetWidthV0C(Int_t i) const
 320
 321 {
 322   // returns time signal width
 323   // in a given cell of V0C
 324   if (OutOfRange(i, "AliESDVZERO::GetWidthV0C:",32)) return -1;
 325   return fWidth[i];
 326 }
 327
 328 //__________________________________________________________________________
 329 Bool_t AliESDVZERO::BBTriggerV0A(Int_t i) const
 330 {
 331   // returns offline beam-beam flags in V0A
 332   // one bit per cell
 333   if (OutOfRange(i, "AliESDVZERO:::BBTriggerV0A",32)) return kFALSE;
 334   UInt_t test = 1;
 335   return ( fBBtriggerV0A & (test << i) ? kTRUE : kFALSE );
 336 }
 337
 338 //__________________________________________________________________________
 339 Bool_t AliESDVZERO::BGTriggerV0A(Int_t i) const
 340 {
 341   // returns offline beam-gas flags in V0A
 342   // one bit per cell
 343   if (OutOfRange(i, "AliESDVZERO:::BGTriggerV0A",32)) return kFALSE;
 344   UInt_t test = 1;
 345   return ( fBGtriggerV0A & (test << i) ? kTRUE : kFALSE );
 346 }
 347
 348 //__________________________________________________________________________
 349 Bool_t AliESDVZERO::BBTriggerV0C(Int_t i) const
 350 {
 351   // returns offline beam-beam flags in V0C
 352   // one bit per cell
 353   if (OutOfRange(i, "AliESDVZERO:::BBTriggerV0C",32)) return kFALSE;
 354   UInt_t test = 1;
 355   return ( fBBtriggerV0C & (test << i) ? kTRUE : kFALSE );
 356 }
 357
 358 //__________________________________________________________________________
 359 Bool_t AliESDVZERO::BGTriggerV0C(Int_t i) const
 360 {
 361   // returns offline beam-gasflags in V0C
 362   // one bit per cell
 363   if (OutOfRange(i, "AliESDVZERO:::BGTriggerV0C",32)) return kFALSE;
 364   UInt_t test = 1;
 365   return ( fBGtriggerV0C & (test << i) ? kTRUE : kFALSE );
 366 }
 367
 368 //__________________________________________________________________________
 369 Bool_t AliESDVZERO::GetBBFlag(Int_t i) const
 370
 371 {
 372   // returns online beam-beam flag in V0
 373   // one boolean per cell
 374   if (OutOfRange(i, "AliESDVZERO::GetBBFlag:",64)) return kFALSE;
 375   return fBBFlag[i];
 376 }
 377
 378 //__________________________________________________________________________
 379 Bool_t AliESDVZERO::GetBGFlag(Int_t i) const
 380
 381 {
 382   // returns online beam-gas flag in V0
 383   // one boolean per cell
 384   if (OutOfRange(i, "AliESDVZERO::GetBGFlag:",64)) return kFALSE;
 385   return fBGFlag[i];
 386 }
 387
 388 //__________________________________________________________________________
 389 Bool_t AliESDVZERO::OutOfRange(Int_t i, const char* /*s*/, Int_t upper) const
 390 {
 391   // checks if i is a valid index.
 392   // s = name of calling method
 393   if (i > upper || i < 0) {
 394 //    cout << s << " Index " << i << " out of range" << endl;
 395      AliInfo(Form("Index %d out of range",i));
 396      return kTRUE;
 397   }
 398   return kFALSE;
 399 }
 400