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