lightweight event mixing classes (AliEvtPool and AliEvtPoolManager)
authoraadare <aadare@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 2 Mar 2012 19:51:12 +0000 (19:51 +0000)
committeraadare <aadare@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 2 Mar 2012 19:51:12 +0000 (19:51 +0000)
PWGCF/Correlations/DPhi/FourierDecomposition/AliPool.cxx [new file with mode: 0644]
PWGCF/Correlations/DPhi/FourierDecomposition/AliPool.h [new file with mode: 0644]

diff --git a/PWGCF/Correlations/DPhi/FourierDecomposition/AliPool.cxx b/PWGCF/Correlations/DPhi/FourierDecomposition/AliPool.cxx
new file mode 100644 (file)
index 0000000..dddb5e7
--- /dev/null
@@ -0,0 +1,306 @@
+#include "AliPool.h"
+
+// ===================================================================
+//                             AliEvtPool
+// ===================================================================
+
+ClassImp(AliEvtPool)
+
+AliEvtPool::~AliEvtPool()
+{
+  while (!fEvents.empty()) {
+    MiniEvent* fe= fEvents.front();
+    delete fe;
+    fe = 0;
+    fEvents.pop_front();
+  }
+}
+
+void 
+AliEvtPool::PrintInfo() const
+{
+  cout << Form("%20s: %d events", "Pool capacity", fMixDepth) << endl;
+  cout << Form("%20s: %d events, %d tracks", "Current size", 
+              GetCurrentNEvents(), NTracksInPool()) << endl;
+  cout << Form("%20s: %.1f to %.1f", "Sub-event mult.", fMultMin, fMultMax) << endl;
+  cout << Form("%20s: %.1f to %.1f", "Z-vtx range", fZvtxMin, fZvtxMax) << endl;
+
+  return;
+}
+
+Bool_t 
+AliEvtPool::EventMatchesBin(Int_t mult, Double_t zvtx) const
+{
+  return EventMatchesBin((Double_t) mult, zvtx);
+}
+
+Bool_t 
+AliEvtPool::EventMatchesBin(Double_t mult, Double_t zvtx) const
+{
+  // Lower bin limit included; upper limit excluded.
+
+  Bool_t multOK = (mult >= fMultMin && mult < fMultMax);
+  Bool_t zvtxOK = (zvtx >= fZvtxMin && zvtx < fZvtxMax);
+  return (multOK && zvtxOK);
+}
+
+Int_t 
+AliEvtPool::NTracksInPool() const
+{
+  // Number of tracks for this cent, zvtx bin; possibly includes many events.
+
+  Int_t ntrk=0;
+  for (Int_t i=0; i<(Int_t)fEvents.size(); ++i) {
+    ntrk += fNTracksInEvent.at(i);
+  }
+  return ntrk;
+}
+
+Int_t
+AliEvtPool::SetEventMultRange(Int_t multMin, Int_t multMax)
+{
+  fMultMin = (Double_t)multMin;
+  fMultMax = (Double_t)multMax;
+  return 0;
+}
+
+Int_t
+AliEvtPool::SetEventMultRange(Double_t multMin, Double_t multMax)
+{
+  fMultMin = multMin;
+  fMultMax = multMax;
+  return 0;
+}
+
+Int_t
+AliEvtPool::SetEventZvtxRange(Double_t zvtxMin, Double_t zvtxMax)
+{
+  fZvtxMin = zvtxMin;
+  fZvtxMax = zvtxMax;
+  return 0;
+}
+
+Int_t
+AliEvtPool::GlobalEventIndex(Int_t j) const
+{
+  // Index returned from passing local pool event index.
+
+  if (j < 0 || j >= (Int_t)fEventIndex.size()) {
+    cout << "ERROR in AliEvtPool::GlobalEventIndex(): "
+        << " Invalid index " << j << endl;
+    return -99;
+  }
+  return fEventIndex.at(j);
+}
+
+Int_t
+AliEvtPool::UpdatePool(MiniEvent* miniEvt)
+{
+  // A rolling buffer (a double-ended queue) is updated by removing
+  // the oldest event, and appending the newest.
+
+  static Int_t iEvent = -1; 
+  iEvent++;
+
+  Int_t mult = miniEvt->size(); // # tracks in this (mini) event
+  Int_t nTrk = NTracksInPool();
+
+  if (nTrk < fTargetTrackDepth && ((nTrk + mult) >= fTargetTrackDepth)) 
+    fNTimes++;
+
+  // remove 0th element before appending this event
+  Bool_t removeFirstEvent = 0;
+  if (nTrk>fTargetTrackDepth) {
+    Int_t nTrksFirstEvent= fNTracksInEvent.front();
+    Int_t diff = nTrk - nTrksFirstEvent + mult;
+    if (diff>fTargetTrackDepth)
+      removeFirstEvent = 1;
+  }
+  if (removeFirstEvent) {
+    MiniEvent* oldestEvent = fEvents.front();
+    delete oldestEvent;
+    fEvents.pop_front();         // remove first track array 
+    fNTracksInEvent.pop_front(); // remove first int
+    fEventIndex.pop_front();
+  }
+
+  fNTracksInEvent.push_back(mult);
+  fEvents.push_back(miniEvt);
+  fEventIndex.push_back(iEvent);
+
+  if (fNTimes==1) {
+    fFirstFilled = kTRUE;
+    if (AliEvtPool::fDebug) {
+      cout << "\nPool " << MultBinIndex() << ", " << ZvtxBinIndex() 
+           << " ready at event "<< iEvent;
+      PrintInfo();
+      cout << endl;
+    }
+    fNTimes++; // See this message exactly once/pool
+  } else {
+    fFirstFilled = kFALSE;
+  }
+
+  fWasUpdated = true;
+
+  if (AliEvtPool::fDebug) {
+    cout << " Event " << fEventIndex.back();
+    cout << " PoolDepth = " << GetCurrentNEvents(); 
+    cout << " NTracksInCurrentEvent = " << " " << mult << endl;
+  }
+
+  return fEvents.size();
+}
+
+MiniEvent* 
+AliEvtPool::GetEvent(Int_t i) const
+{
+  if (i<0 || i>=(Int_t)fEvents.size()) {
+    cout << "AliEvtPool::GetEvent(" 
+        << i << "): Invalid index" << endl;
+    return 0x0;
+  }
+
+  MiniEvent* ev = fEvents.at(i);
+  return ev;
+}
+
+Int_t
+AliEvtPool::NTracksInEvent(Int_t iEvent) const
+{
+  // Return number of tracks in iEvent, which is the local pool index.
+
+  Int_t n = -1;
+  Int_t curEvent = fEventIndex.back();
+  Int_t offset = curEvent - iEvent;
+  Int_t pos = fEventIndex.size() - offset - 1;
+
+  if (offset==0)
+    n = fNTracksInEvent.back();
+  else if (offset < 0 || iEvent < 0) {
+    n = 0;
+  }
+  else if (offset > 0 && offset <= (int)fEventIndex.size()) {
+    n = fNTracksInEvent.at(pos);
+  }
+  else
+    cout << "Event info no longer in memory" << endl;
+  return n;
+}
+
+// ===================================================================
+//                          AliEvtPoolManager
+// ===================================================================
+
+
+ClassImp(AliEvtPoolManager)
+
+AliEvtPoolManager::AliEvtPoolManager(Int_t depth,     Int_t minNTracks,
+                                    Int_t nMultBins, Double_t *multbins,
+                                    Int_t nZvtxBins, Double_t *zvtxbins) 
+: fDebug(0), fNMultBins(0), fNZvtxBins(0), fEvPool(0), fTargetTrackDepth(minNTracks) 
+{
+  // Constructor.
+
+  InitEventPools(depth, nMultBins, multbins, nZvtxBins, zvtxbins);
+  cout << "AliEvtPoolManager initialized." << endl;
+}
+
+AliEvtPoolManager::~AliEvtPoolManager()
+{
+  for (Int_t iM=0; iM<fNMultBins; iM++) {
+    for (Int_t iZ=0; iZ<fNZvtxBins; iZ++) {
+      AliEvtPool* pool = fEvPool.at(iM).at(iZ);
+      delete pool;
+    }
+  }
+}
+
+Int_t AliEvtPoolManager::InitEventPools(Int_t depth, 
+                                       Int_t nMultBins, Double_t *multbin, 
+                                       Int_t nZvtxBins, Double_t *zvtxbin)
+{
+  // Assign AliEvtPoolManager members.
+
+  fNMultBins = nMultBins;
+  fNZvtxBins = nZvtxBins;
+
+  for (Int_t iM=0; iM<fNMultBins; iM++) {
+    std::vector<AliEvtPool*> evp;
+    for (Int_t iZ=0; iZ<fNZvtxBins; iZ++) {
+      evp.push_back(new AliEvtPool(depth, 
+                                  multbin[iM], multbin[iM+1], 
+                                  zvtxbin[iZ], zvtxbin[iZ+1] ));
+    }
+    fEvPool.push_back(evp);
+  }
+  
+  for (Int_t iM=0; iM<nMultBins; iM++) {
+    for (Int_t iZ=0; iZ<nZvtxBins; iZ++) {
+      fEvPool.at(iM).at(iZ)->SetMultBinIndex(iM);
+      fEvPool.at(iM).at(iZ)->SetZvtxBinIndex(iZ);
+      fEvPool.at(iM).at(iZ)->SetTargetTrackDepth(fTargetTrackDepth);
+      fEvPool.at(iM).at(iZ)->SetDebug(fDebug);
+    }
+  }
+  
+  if (fDebug) {
+    cout << "fEvPool outer size: " << fEvPool.size() << endl;
+    for (Int_t iM=0; iM<nMultBins; iM++) {
+      for (Int_t iZ=0; iZ<nZvtxBins; iZ++) {
+       if(fEvPool.at(iM).at(iZ)) {
+         cout << "multiplicity bin: " << iM;
+         cout << ", z-vertex bin: " << iZ;
+         fEvPool.at(iM).at(iZ)->PrintInfo();
+       }
+      }
+    }
+  }
+  
+  return fEvPool.size();
+}
+
+AliEvtPool*
+AliEvtPoolManager::GetEventPool(Int_t iMult, Int_t iZvtx) const
+{
+  if (iMult < 0 || iMult >= fNMultBins) 
+    return 0x0;
+  if (iZvtx < 0 || iZvtx >= fNZvtxBins) 
+    return 0x0;
+  return fEvPool.at(iMult).at(iZvtx);
+}
+
+AliEvtPool*
+AliEvtPoolManager::GetEventPool(Int_t centVal, Double_t zVtxVal) const
+{
+  return GetEventPool((Double_t)centVal, zVtxVal);
+}
+
+AliEvtPool*
+AliEvtPoolManager::GetEventPool(Double_t centVal, Double_t zVtxVal) const
+{
+  // Return appropriate pool for this centrality and z-vertex value.
+
+  for (Int_t iM=0; iM<fNMultBins; iM++) {
+    for (Int_t iZ=0; iZ<fNZvtxBins; iZ++) {
+      AliEvtPool* pool = GetEventPool(iM, iZ);
+      if (pool->EventMatchesBin(centVal, zVtxVal))
+       return pool;
+    }
+  }
+  return 0x0;
+}
+
+Int_t
+AliEvtPoolManager::UpdatePools(MiniEvent* miniEvt)
+{
+  // Call UpdatePool for all bins.
+
+  for (Int_t iM=0; iM<fNMultBins; iM++) {
+    for (Int_t iZ=0; iZ<fNZvtxBins; iZ++) {
+      if (fEvPool.at(iM).at(iZ)->UpdatePool(miniEvt) > -1)
+        break;
+    }
+  }
+  return 0;
+}
diff --git a/PWGCF/Correlations/DPhi/FourierDecomposition/AliPool.h b/PWGCF/Correlations/DPhi/FourierDecomposition/AliPool.h
new file mode 100644 (file)
index 0000000..0d346cc
--- /dev/null
@@ -0,0 +1,171 @@
+#ifndef AliPool_h
+#define AliPool_h
+
+#include <vector>
+#include <deque>
+#include <Rtypes.h>
+#include <Riostream.h>
+#include <TObject.h>
+#include <TFile.h>
+#include <TMath.h>
+#include <TSystem.h>
+
+class AliMiniTrack;
+
+// Low-memory event mixing classes:
+// - AliEvtPoolManager: Maintain 2D vector (z,cent) of AliEvtPools.
+// - AliEvtPool: collections of sub-events in z and mult/cent bins.
+// - AliMiniTrack: super-lightweight track "struct" class.
+//
+// Stores a buffer of tracks that updates continuously. The track type
+// contained by the pools can be anything (no inheritance from
+// AliVParticle, or even TObject, required). To use a track type other
+// than AliMiniTrack, just redefine the MiniEvent typedef (for example,
+// using AliESDTracks, or TLorenzVectors).
+// Pools are updated based on maintaining a minimum fixed
+// number of tracks. Multiplicity/centrality and z-vertex bins must be
+// passed in at initialization. For example of implementation, see
+// $ALICE_ROOT/PWGCF/Correlations/DPhi/FourierDecomposition/AliDhcTask.cxx
+//
+// Authors: A. Adare and C. Loizides
+
+typedef std::vector< AliMiniTrack > MiniEvent;
+
+class AliMiniTrack
+{
+ public:
+  AliMiniTrack() : fPt(0), fEta(0), fPhi(0), fSign(0) {};
+  AliMiniTrack(Double_t pt, Double_t eta, Double_t phi, Int_t sign) :
+   fPt(pt), fEta(eta), fPhi(phi), fSign(sign>=0?1:0) {};
+  Float_t Eta()  const { return fEta; }
+  Float_t Phi()  const { return fPhi; }
+  Float_t Pt()   const { return fPt;  }
+  Int_t   Sign() const { if (fSign) return 1; return -1; }
+
+ protected: 
+  Float_t fPt;
+  Float_t fEta;
+  Float_t fPhi;
+  Bool_t  fSign;
+};
+
+class AliEvtPool : public TObject
+{
+ public:
+ AliEvtPool(Int_t d) : 
+   fEvents(0),
+   fNTracksInEvent(0),
+   fEventIndex(0),
+   fMixDepth(d), 
+   fMultMin(-999), 
+   fMultMax(+999), 
+   fZvtxMin(-999), 
+   fZvtxMax(+999), 
+   fWasUpdated(0), 
+   fMultBinIndex(0), 
+    fZvtxBinIndex(0), 
+   fDebug(0), 
+   fTargetTrackDepth(0),
+   fFirstFilled(0),
+   fNTimes(0) {;}
+  
+ AliEvtPool(Int_t d, Double_t multMin, Double_t multMax, 
+           Double_t zvtxMin, Double_t zvtxMax) : 
+   fEvents(0),
+   fNTracksInEvent(0),
+   fEventIndex(0),
+   fMixDepth(d), 
+   fMultMin(multMin), 
+   fMultMax(multMax), 
+   fZvtxMin(zvtxMin),
+   fZvtxMax(zvtxMax),
+   fWasUpdated(0),
+    fMultBinIndex(0), 
+   fZvtxBinIndex(0),
+   fDebug(0),
+   fTargetTrackDepth(0),
+   fFirstFilled(0),
+   fNTimes(0) {;}
+  ~AliEvtPool();
+  
+  Bool_t      EventMatchesBin(Int_t mult,    Double_t zvtx) const;
+  Bool_t      EventMatchesBin(Double_t mult, Double_t zvtx) const;
+  Bool_t      IsReady()                    const { return NTracksInPool() >= fTargetTrackDepth; }
+  Bool_t      IsFirstReady()               const { return fFirstFilled;   }
+  Int_t       GetNTimes()                  const { return fNTimes;        }
+  Int_t       GetCurrentNEvents()          const { return fEvents.size(); }
+  Int_t       GlobalEventIndex(Int_t j)    const;
+  MiniEvent*  GetEvent(Int_t i)            const;
+  Int_t       MultBinIndex()               const { return fMultBinIndex; }
+  Int_t       NTracksInEvent(Int_t iEvent) const;
+  Int_t       NTracksInCurrentEvent()      const { if (fNTracksInEvent.empty()) return 0;  
+                                                   return fNTracksInEvent.back(); }
+  void        PrintInfo()                  const;
+  Int_t       NTracksInPool()              const;
+  Bool_t      WasUpdated()                 const { return fWasUpdated; }
+  Int_t       ZvtxBinIndex()               const { return fZvtxBinIndex; }
+  void        SetDebug(Bool_t b)                 { fDebug = b; }
+  void        SetTargetTrackDepth(Int_t d)       { fTargetTrackDepth = d; }
+  Int_t       SetEventMultRange(Int_t    multMin, Int_t multMax);
+  Int_t       SetEventMultRange(Double_t multMin, Double_t multMax);
+  Int_t       SetEventZvtxRange(Double_t zvtxMin, Double_t zvtxMax);
+  void        SetMultBinIndex(Int_t iM)          { fMultBinIndex = iM; }
+  void        SetZvtxBinIndex(Int_t iZ)          { fZvtxBinIndex = iZ; }
+  Int_t       UpdatePool(MiniEvent* miniEvt);
+  
+protected:
+  deque< MiniEvent* >   fEvents;              //Pool of events storing Minitracks
+  deque<int>            fNTracksInEvent;      //Tracks in event
+  deque<int>            fEventIndex;          //Original event index
+  Int_t                 fMixDepth;            //Number of evts. to mix with
+  Double_t              fMultMin, fMultMax;   //Track multiplicity bin range
+  Double_t              fZvtxMin, fZvtxMax;   //Event z-vertex bin range
+  Bool_t                fWasUpdated;          //Evt. succesfully passed selection?
+  Int_t                 fMultBinIndex;        //Multiplicity bin
+  Int_t                 fZvtxBinIndex;        //Zvertex bin
+  Int_t                 fDebug;               //If 1 then debug on
+  Int_t                 fTargetTrackDepth;    //Number of tracks, once full
+  Bool_t                fFirstFilled;         //Init to false
+  Int_t                 fNTimes;              //Number of times init. condition reached
+
+  ClassDef(AliEvtPool,1) // Event pool class
+};
+
+class AliEvtPoolManager : public TObject
+{
+public:
+  AliEvtPoolManager() : 
+    fDebug(0),
+    fNMultBins(0), 
+    fNZvtxBins(0),
+    fEvPool(0),
+    fTargetTrackDepth(0) {;}
+  AliEvtPoolManager(Int_t maxEvts, Int_t minNTracks,
+                   Int_t nMultBins, Double_t *multbins,
+                   Int_t nZvtxBins, Double_t *zvtxbins);
+
+  ~AliEvtPoolManager();
+  
+  // First uses bin indices, second uses the variables themselves.
+  AliEvtPool *GetEventPool(Int_t iMult, Int_t iZvtx) const;
+  AliEvtPool *GetEventPool(Int_t    centVal, Double_t zvtxVal) const;
+  AliEvtPool *GetEventPool(Double_t centVal, Double_t zvtxVal) const;
+
+  Int_t       InitEventPools(Int_t depth, 
+                            Int_t nmultbins, Double_t *multbins, 
+                            Int_t nzvtxbins, Double_t *zvtxbins);
+  void        SetTargetTrackDepth(Int_t d) { fTargetTrackDepth = d;}
+  Int_t       UpdatePools(MiniEvent*);
+  void        SetDebug(Bool_t b) { fDebug = b; }
+
+protected:
+  Int_t      fDebug;                         // If 1 then debug on
+  Int_t      fNMultBins;                     // number mult bins
+  Int_t      fNZvtxBins;                     // number vertex bins
+  vector< vector<AliEvtPool*> > fEvPool;     // pool in bins of [fMultBin][fZvtxBin]
+  Int_t      fTargetTrackDepth;              // Required track size, same for all pools.
+
+  ClassDef(AliEvtPoolManager,1)
+};
+#endif