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 {
  14    // Default constructor
  15    for(Int_t j=0; j<64; j++){
  16       fMultiplicity[j] = 0.0;
  17       fAdc[j]   = 0.0;
  18       fTime[j]  = 0.0;
  19       fWidth[j] = 0.0;
  20       fBBFlag[j]= kFALSE;
  21       fBGFlag[j]= kFALSE;
  22    }
  23 }
  24
  25 //__________________________________________________________________________
  26 AliESDVZERO::AliESDVZERO(const AliESDVZERO &o)
  27   :TObject(o),
  28    fBBtriggerV0A(o.fBBtriggerV0A),
  29    fBGtriggerV0A(o.fBGtriggerV0A),
  30    fBBtriggerV0C(o.fBBtriggerV0C),
  31    fBGtriggerV0C(o.fBGtriggerV0C)
  32 {
  33    // Default constructor
  34    for(Int_t j=0; j<64; j++) {
  35        fMultiplicity[j] = o.fMultiplicity[j];
  36        fAdc[j]    = o.fAdc[j];
  37        fTime[j]   = o.fTime[j];
  38        fWidth[j]  = o.fWidth[j];
  39        fBBFlag[j] = o.fBBFlag[j];
  40        fBGFlag[j] = o.fBGFlag[j];
  41    }
  42 }
  43
  44 //__________________________________________________________________________
  45 AliESDVZERO::AliESDVZERO(UInt_t BBtriggerV0A, UInt_t BGtriggerV0A,
  46               UInt_t BBtriggerV0C, UInt_t BGtriggerV0C,
  47               Float_t *Multiplicity, Float_t *Adc,
  48               Float_t *Time, Float_t *Width, Bool_t *BBFlag, Bool_t *BGFlag)
  49   :TObject(),
  50    fBBtriggerV0A(BBtriggerV0A),
  51    fBGtriggerV0A(BGtriggerV0A),
  52    fBBtriggerV0C(BBtriggerV0C),
  53    fBGtriggerV0C(BGtriggerV0C)
  54
  55 {
  56    // Constructor
  57    for(Int_t j=0; j<64; j++) {
  58        fMultiplicity[j] = Multiplicity[j];
  59        fAdc[j]    = Adc[j];
  60        fTime[j]   = Time[j];
  61        fWidth[j]  = Width[j];
  62        fBBFlag[j] = BBFlag[j];
  63        fBGFlag[j] = BGFlag[j];
  64    }
  65 }
  66
  67 //__________________________________________________________________________
  68 AliESDVZERO& AliESDVZERO::operator=(const AliESDVZERO& o)
  69 {
  70
  71   if(this==&o) return *this;
  72   TObject::operator=(o);
  73   // Assignment operator
  74   fBBtriggerV0A=o.fBBtriggerV0A;
  75   fBGtriggerV0A=o.fBGtriggerV0A;
  76   fBBtriggerV0C=o.fBBtriggerV0C;
  77   fBGtriggerV0C=o.fBGtriggerV0C;
  78    for(Int_t j=0; j<64; j++) {
  79        fMultiplicity[j] = o.fMultiplicity[j];
  80        fAdc[j]    = o.fAdc[j];
  81        fTime[j]   = o.fTime[j];
  82        fWidth[j]  = o.fWidth[j];
  83        fBBFlag[j] = o.fBBFlag[j];
  84        fBGFlag[j] = o.fBGFlag[j];
  85    }
  86   return *this;
  87 }
  88
  89 //__________________________________________________________________________
  90 Short_t AliESDVZERO::GetNbPMV0A()
  91 {
  92   Short_t n=0;
  93   for(Int_t i=32;i<64;i++)
  94     if (fMultiplicity[i]>0) n++;
  95   return n;
  96 }
  97
  98 //__________________________________________________________________________
  99 Short_t AliESDVZERO::GetNbPMV0C()
 100 {
 101   Short_t n=0;
 102   for(Int_t i=0;i<32;i++)
 103     if (fMultiplicity[i]>0) n++;
 104   return n;
 105 }
 106
 107 //__________________________________________________________________________
 108 Float_t AliESDVZERO::GetMTotV0A()
 109 {
 110   Float_t mul=0.0;
 111   for(Int_t i=32;i<64;i++)
 112     mul+=  fMultiplicity[i];
 113   return mul;
 114 }
 115
 116 //__________________________________________________________________________
 117 Float_t AliESDVZERO::GetMTotV0C()
 118 {
 119   Float_t mul=0.0;
 120   for(Int_t i=0;i<32;i++)
 121     mul+=  fMultiplicity[i];
 122   return mul;
 123 }
 124
 125 //__________________________________________________________________________
 126 Float_t* AliESDVZERO::GetMRingV0A()
 127 {
 128 //  cout << "AliESDVZERO::GetMRingV0C() not supported any more" << endl;
 129 //  cout << "use Int_t AliESDVZERO::GetMRingV0C(Int_t ring)" << endl;
 130   AliInfo("AliESDVZERO::GetMRingV0C() not supported any more");
 131   AliInfo("use Float_t AliESDVZERO::GetMRingV0C(Int_t ring)");
 132   return 0x0;
 133 }
 134
 135 //__________________________________________________________________________
 136 Float_t* AliESDVZERO::GetMRingV0C()
 137 {
 138 //  cout << "AliESDVZERO::GetMRingV0C() not supported any more" << endl;
 139 //  cout << "use Int_t AliESDVZERO::GetMRingV0C(Int_t ring)" << endl;
 140   AliInfo("AliESDVZERO::GetMRingV0C() not supported any more");
 141   AliInfo("use Float_t AliESDVZERO::GetMRingV0C(Int_t ring)");
 142   return 0x0;
 143 }
 144
 145 //__________________________________________________________________________
 146 Float_t AliESDVZERO::GetMRingV0A(Int_t ring)
 147 {
 148   if (OutOfRange(ring, "AliESDVZERO:::GetMRingV0A",4)) return -1;
 149   Float_t mul =0.0;
 150
 151   if (ring == 0) for(Int_t i=32;i<40;i++) mul +=  fMultiplicity[i];
 152   if (ring == 1) for(Int_t i=40;i<48;i++) mul +=  fMultiplicity[i];
 153   if (ring == 2) for(Int_t i=48;i<56;i++) mul +=  fMultiplicity[i];
 154   if (ring == 3) for(Int_t i=56;i<64;i++) mul +=  fMultiplicity[i];
 155   return mul ;
 156 }
 157
 158 //__________________________________________________________________________
 159 Float_t AliESDVZERO::GetMRingV0C(Int_t ring)
 160 {
 161   if (OutOfRange(ring, "AliESDVZERO:::GetMRingV0C",4)) return -1;
 162   Float_t mul =0.0;
 163
 164   if (ring == 0) for(Int_t i=0;i<8;i++)   mul +=  fMultiplicity[i];
 165   if (ring == 1) for(Int_t i=8;i<16;i++)  mul +=  fMultiplicity[i];
 166   if (ring == 2) for(Int_t i=16;i<24;i++) mul +=  fMultiplicity[i];
 167   if (ring == 3) for(Int_t i=24;i<32;i++) mul +=  fMultiplicity[i];
 168   return mul ;
 169 }
 170
 171 //__________________________________________________________________________
 172 Float_t AliESDVZERO::GetMultiplicity(Int_t i)
 173
 174 {
 175   if (OutOfRange(i, "AliESDVZERO::GetMultiplicity:",64)) return -1;
 176   return fMultiplicity[i];
 177 }
 178
 179 //__________________________________________________________________________
 180 Float_t AliESDVZERO::GetMultiplicityV0A(Int_t i)
 181
 182 {
 183   if (OutOfRange(i, "AliESDVZERO::GetMultiplicityV0A:",32)) return -1;
 184   return fMultiplicity[32+i];
 185 }
 186
 187 //__________________________________________________________________________
 188 Float_t AliESDVZERO::GetMultiplicityV0C(Int_t i)
 189
 190 {
 191   if (OutOfRange(i, "AliESDVZERO::GetMultiplicityV0C:",32)) return -1;
 192   return fMultiplicity[i];
 193 }
 194
 195 //__________________________________________________________________________
 196 Float_t AliESDVZERO::GetAdc(Int_t i)
 197
 198 {
 199   if (OutOfRange(i, "AliESDVZERO::GetAdc:",64)) return -1;
 200   return fAdc[i];
 201 }
 202
 203 //__________________________________________________________________________
 204 Float_t AliESDVZERO::GetAdcV0A(Int_t i)
 205
 206 {
 207   if (OutOfRange(i, "AliESDVZERO::GetAdcV0A:",32)) return -1;
 208   return fAdc[32+i];
 209 }
 210
 211 //__________________________________________________________________________
 212 Float_t AliESDVZERO::GetAdcV0C(Int_t i)
 213
 214 {
 215   if (OutOfRange(i, "AliESDVZERO::GetAdcV0C:",32)) return -1;
 216   return fAdc[i];
 217 }
 218
 219 //__________________________________________________________________________
 220 Float_t AliESDVZERO::GetTime(Int_t i)
 221
 222 {
 223   if (OutOfRange(i, "AliESDVZERO::GetTime:",64)) return -1;
 224   return fTime[i];
 225 }
 226
 227 //__________________________________________________________________________
 228 Float_t AliESDVZERO::GetTimeV0A(Int_t i)
 229
 230 {
 231   if (OutOfRange(i, "AliESDVZERO::GetTimeV0A:",32)) return -1;
 232   return fTime[32+i];
 233 }
 234
 235 //__________________________________________________________________________
 236 Float_t AliESDVZERO::GetTimeV0C(Int_t i)
 237
 238 {
 239   if (OutOfRange(i, "AliESDVZERO::GetTimeV0C:",32)) return -1;
 240   return fTime[i];
 241 }
 242
 243 //__________________________________________________________________________
 244 Float_t AliESDVZERO::GetWidth(Int_t i)
 245
 246 {
 247   if (OutOfRange(i, "AliESDVZERO::GetWidth:",64)) return -1;
 248   return fWidth[i];
 249 }
 250
 251 //__________________________________________________________________________
 252 Float_t AliESDVZERO::GetWidthV0A(Int_t i)
 253
 254 {
 255   if (OutOfRange(i, "AliESDVZERO::GetWidthV0A:",32)) return -1;
 256   return fWidth[32+i];
 257 }
 258
 259 //__________________________________________________________________________
 260 Float_t AliESDVZERO::GetWidthV0C(Int_t i)
 261
 262 {
 263   if (OutOfRange(i, "AliESDVZERO::GetWidthV0C:",32)) return -1;
 264   return fWidth[i];
 265 }
 266
 267 //__________________________________________________________________________
 268 Bool_t AliESDVZERO::BBTriggerV0A(Int_t i)
 269 {
 270   if (OutOfRange(i, "AliESDVZERO:::BBTriggerV0A",32)) return kFALSE;
 271   UInt_t test = 1;
 272   return ( fBBtriggerV0A & (test << i) ? kTRUE : kFALSE );
 273 }
 274
 275 //__________________________________________________________________________
 276 Bool_t AliESDVZERO::BGTriggerV0A(Int_t i)
 277 {
 278   if (OutOfRange(i, "AliESDVZERO:::BGTriggerV0A",32)) return kFALSE;
 279   UInt_t test = 1;
 280   return ( fBGtriggerV0A & (test << i) ? kTRUE : kFALSE );
 281 }
 282
 283 //__________________________________________________________________________
 284 Bool_t AliESDVZERO::BBTriggerV0C(Int_t i)
 285 {
 286   if (OutOfRange(i, "AliESDVZERO:::BBTriggerV0C",32)) return kFALSE;
 287   UInt_t test = 1;
 288   return ( fBBtriggerV0C & (test << i) ? kTRUE : kFALSE );
 289 }
 290
 291 //__________________________________________________________________________
 292 Bool_t AliESDVZERO::BGTriggerV0C(Int_t i)
 293 {
 294   if (OutOfRange(i, "AliESDVZERO:::BGTriggerV0C",32)) return kFALSE;
 295   UInt_t test = 1;
 296   return ( fBGtriggerV0C & (test << i) ? kTRUE : kFALSE );
 297 }
 298
 299 //__________________________________________________________________________
 300 Bool_t AliESDVZERO::GetBBFlag(Int_t i)
 301
 302 {
 303   if (OutOfRange(i, "AliESDVZERO::GetBBFlag:",64)) return kFALSE;
 304   return fBBFlag[i];
 305 }
 306
 307 //__________________________________________________________________________
 308 Bool_t AliESDVZERO::GetBGFlag(Int_t i)
 309
 310 {
 311   if (OutOfRange(i, "AliESDVZERO::GetBGFlag:",64)) return kFALSE;
 312   return fBGFlag[i];
 313 }
 314
 315 //__________________________________________________________________________
 316 Bool_t AliESDVZERO::OutOfRange(Int_t i, const char* /*s*/, Int_t upper) const
 317 {
 318   // checks if i is a valid index. s = name of calling method
 319   if (i > upper || i < 0) {
 320 //    cout << s << " Index " << i << " out of range" << endl;
 321      AliInfo(Form("Index %d out of range",i));
 322      return kTRUE;
 323   }
 324   return kFALSE;
 325 }
 326