ANALYSIS/AliEventPoolManager.cxx

   1 #include "AliEventPoolManager.h"
   2
   3 using std::cout;
   4 using std::endl;
   5 ClassImp(AliEventPool)
   6
   7 void AliEventPool::PrintInfo() const
   8 {
   9   cout << Form("%20s: %d events", "Pool capacity", fMixDepth) << endl;
  10   cout << Form("%20s: %d events, %d tracks", "Current size",
  11                GetCurrentNEvents(), NTracksInPool()) << endl;
  12   cout << Form("%20s: %.1f to %.1f", "Sub-event mult.", fMultMin, fMultMax) << endl;
  13   cout << Form("%20s: %.1f to %.1f", "Z-vtx range", fZvtxMin, fZvtxMax) << endl;
  14
  15   return;
  16 }
  17
  18 Bool_t AliEventPool::EventMatchesBin(Int_t mult, Double_t zvtx) const
  19 {
  20   return EventMatchesBin((Double_t) mult, zvtx);
  21 }
  22
  23 Bool_t AliEventPool::EventMatchesBin(Double_t mult, Double_t zvtx) const
  24 {
  25   // Lower bin limit included; upper limit excluded.
  26
  27   Bool_t multOK = (mult >= fMultMin && mult < fMultMax);
  28   Bool_t zvtxOK = (zvtx >= fZvtxMin && zvtx < fZvtxMax);
  29   return (multOK && zvtxOK);
  30 }
  31
  32 Int_t AliEventPool::NTracksInPool() const
  33 {
  34   // Number of tracks for this cent, zvtx bin; possibly includes many
  35   // events.
  36
  37   Int_t ntrk=0;
  38   for (Int_t i=0; i<(Int_t)fEvents.size(); ++i) {
  39     ntrk += fNTracksInEvent.at(i);
  40   }
  41   return ntrk;
  42 }
  43
  44 Int_t AliEventPool::SetEventMultRange(Int_t multMin, Int_t multMax)
  45 {
  46   fMultMin = (Double_t)multMin;
  47   fMultMax = (Double_t)multMax;
  48   return 0;
  49 }
  50
  51 Int_t AliEventPool::SetEventMultRange(Double_t multMin, Double_t multMax)
  52 {
  53   fMultMin = multMin;
  54   fMultMax = multMax;
  55   return 0;
  56 }
  57
  58 Int_t AliEventPool::SetEventZvtxRange(Double_t zvtxMin, Double_t zvtxMax)
  59 {
  60   fZvtxMin = zvtxMin;
  61   fZvtxMax = zvtxMax;
  62   return 0;
  63 }
  64
  65 Int_t AliEventPool::GlobalEventIndex(Int_t j) const
  66 {
  67   // Index returned from passing local pool event index.
  68
  69   if (j < 0 || j >= (Int_t)fEventIndex.size()) {
  70     cout << "ERROR in AliEventPool::GlobalEventIndex(): "
  71          << " Invalid index " << j << endl;
  72     return -99;
  73   }
  74   return fEventIndex.at(j);
  75 }
  76
  77 Int_t AliEventPool::UpdatePool(TObjArray *trk)
  78 {
  79   // A rolling buffer (a double-ended queue) is updated by removing
  80   // the oldest event, and appending the newest.
  81   //
  82   // the ownership of <trk> is delegated to this class
  83
  84   static Int_t iEvent = -1;
  85   iEvent++;
  86
  87   Int_t mult = trk->GetEntries();
  88   Int_t nTrk = NTracksInPool();
  89
  90   if (nTrk < fTargetTrackDepth && ((nTrk + mult) >= fTargetTrackDepth))
  91     fNTimes++;
  92
  93   // remove 0th element before appending this event
  94   Bool_t removeFirstEvent = 0;
  95   if (nTrk>fTargetTrackDepth) {
  96     Int_t nTrksFirstEvent= fNTracksInEvent.front();
  97     Int_t diff = nTrk - nTrksFirstEvent + mult;
  98     if (diff>fTargetTrackDepth)
  99       removeFirstEvent = 1;
 100   }
 101   if (removeFirstEvent) {
 102     TObjArray *fa = fEvents.front();
 103     delete fa;
 104     fEvents.pop_front();         // remove first track array
 105     fNTracksInEvent.pop_front(); // remove first int
 106     fEventIndex.pop_front();
 107   }
 108
 109   fNTracksInEvent.push_back(mult);
 110   fEvents.push_back(trk);
 111   fEventIndex.push_back(iEvent);
 112
 113   if (fNTimes==1) {
 114     fFirstFilled = kTRUE;
 115     if (AliEventPool::fDebug) {
 116       cout << "\nPool " << MultBinIndex() << ", " << ZvtxBinIndex()
 117            << " ready at event "<< iEvent;
 118       PrintInfo();
 119       cout << endl;
 120     }
 121     fNTimes++; // See this message exactly once/pool
 122   } else {
 123     fFirstFilled = kFALSE;
 124   }
 125
 126   fWasUpdated = true;
 127
 128   if (AliEventPool::fDebug) {
 129     cout << " Event " << fEventIndex.back();
 130     cout << " PoolDepth = " << GetCurrentNEvents();
 131     cout << " NTracksInCurrentEvent = " << NTracksInCurrentEvent();
 132   }
 133
 134   return fEvents.size();
 135 }
 136
 137 TObject* AliEventPool::GetRandomTrack() const
 138 {
 139   // Get any random track from the pool, sampled with uniform probability.
 140
 141   UInt_t ranEvt = gRandom->Integer(fEvents.size());
 142   TObjArray *tca = fEvents.at(ranEvt);
 143   UInt_t ranTrk = gRandom->Integer(tca->GetEntries());
 144   TObject *trk = (TObject*)tca->At(ranTrk);
 145   return trk;
 146 }
 147
 148 TObjArray* AliEventPool::GetEvent(Int_t i) const
 149 {
 150   if (i<0 || i>=(Int_t)fEvents.size()) {
 151     cout << "AliEventPool::GetEvent("
 152          << i << "): Invalid index" << endl;
 153     return 0x0;
 154   }
 155
 156   TObjArray *tca = fEvents.at(i);
 157   return tca;
 158 }
 159
 160 TObjArray* AliEventPool::GetRandomEvent() const
 161 {
 162   UInt_t ranEvt = gRandom->Integer(fEvents.size());
 163   TObjArray *tca = fEvents.at(ranEvt);
 164   return tca;
 165 }
 166
 167 Int_t AliEventPool::NTracksInEvent(Int_t iEvent) const
 168 {
 169   // Return number of tracks in iEvent, which is the local pool index.
 170
 171   Int_t n = -1;
 172   Int_t curEvent = fEventIndex.back();
 173   Int_t offset = curEvent - iEvent;
 174   Int_t pos = fEventIndex.size() - offset - 1;
 175
 176   if (offset==0)
 177     n = fNTracksInEvent.back();
 178   else if (offset < 0 || iEvent < 0) {
 179     n = 0;
 180   }
 181   else if (offset > 0 && offset <= (int)fEventIndex.size()) {
 182     n = fNTracksInEvent.at(pos);
 183   }
 184   else
 185     cout << "Event info no longer in memory" << endl;
 186   return n;
 187 }
 188
 189 ClassImp(AliEventPoolManager)
 190
 191 AliEventPoolManager::AliEventPoolManager(Int_t depth,     Int_t minNTracks,
 192                                    Int_t nMultBins, Double_t *multbins,
 193                                    Int_t nZvtxBins, Double_t *zvtxbins) :
 194 fDebug(0), fNMultBins(0), fNZvtxBins(0), fEvPool(0), fTargetTrackDepth(minNTracks)
 195 {
 196   // Constructor.
 197
 198   InitEventPools(depth, nMultBins, multbins, nZvtxBins, zvtxbins);
 199   cout << "AliEventPoolManager initialized." << endl;
 200 }
 201
 202 Int_t AliEventPoolManager::InitEventPools(Int_t depth,
 203                                        Int_t nMultBins, Double_t *multbin,
 204                                        Int_t nZvtxBins, Double_t *zvtxbin)
 205 {
 206   // Assign AliEventPoolManager members.
 207
 208   fNMultBins = nMultBins;
 209   fNZvtxBins = nZvtxBins;
 210
 211   for (Int_t iM=0; iM<nMultBins; iM++) {
 212     std::vector<AliEventPool*> evp;
 213     for (Int_t iZ=0; iZ<nZvtxBins; iZ++) {
 214       evp.push_back(new AliEventPool(depth,
 215                                          multbin[iM], multbin[iM+1],
 216                                          zvtxbin[iZ], zvtxbin[iZ+1] ));
 217     }
 218     fEvPool.push_back(evp);
 219   }
 220
 221   for (Int_t iM=0; iM<nMultBins; iM++) {
 222     for (Int_t iZ=0; iZ<nZvtxBins; iZ++) {
 223       fEvPool.at(iM).at(iZ)->SetMultBinIndex(iM);
 224       fEvPool.at(iM).at(iZ)->SetZvtxBinIndex(iZ);
 225       fEvPool.at(iM).at(iZ)->SetTargetTrackDepth(fTargetTrackDepth);
 226     }
 227   }
 228
 229   if (0) {
 230     cout << "fEvPool outer size: " << fEvPool.size() << endl;
 231     for (Int_t iM=0; iM<nMultBins; iM++) {
 232       for (Int_t iZ=0; iZ<nZvtxBins; iZ++) {
 233         if(fEvPool.at(iM).at(iZ)) {
 234           cout << "multiplicity bin: " << iM;
 235           cout << ", z-vertex bin: " << iZ;
 236           fEvPool.at(iM).at(iZ)->PrintInfo();
 237         }
 238       }
 239     }
 240   }
 241
 242   return fEvPool.size();
 243 }
 244
 245 AliEventPool *AliEventPoolManager::GetEventPool(Int_t iMult, Int_t iZvtx) const
 246 {
 247   if (iMult < 0 || iMult >= fNMultBins)
 248     return 0x0;
 249   if (iZvtx < 0 || iZvtx >= fNZvtxBins)
 250     return 0x0;
 251   return fEvPool.at(iMult).at(iZvtx);
 252 }
 253
 254 AliEventPool *AliEventPoolManager::GetEventPool(Int_t centVal, Double_t zVtxVal) const
 255 {
 256   return GetEventPool((Double_t)centVal, zVtxVal);
 257 }
 258
 259 AliEventPool *AliEventPoolManager::GetEventPool(Double_t centVal, Double_t zVtxVal) const
 260 {
 261   // Return appropriate pool for this centrality and z-vertex value.
 262
 263   for (Int_t iM=0; iM<fNMultBins; iM++) {
 264     for (Int_t iZ=0; iZ<fNZvtxBins; iZ++) {
 265       AliEventPool* pool = GetEventPool(iM, iZ);
 266       if (pool->EventMatchesBin(centVal, zVtxVal))
 267         return pool;
 268     }
 269   }
 270   return 0x0;
 271 }
 272
 273 Int_t AliEventPoolManager::UpdatePools(TObjArray *trk)
 274 {
 275   // Call UpdatePool for all bins.
 276
 277   for (Int_t iM=0; iM<fNMultBins; iM++) {
 278     for (Int_t iZ=0; iZ<fNZvtxBins; iZ++) {
 279       if (fEvPool.at(iM).at(iZ)->UpdatePool(trk) > -1)
 280         break;
 281     }
 282   }
 283   return 0;
 284 }