[u/mrichter/AliRoot.git] / PWGCF / Correlations / DPhi / FourierDecomposition / AliPool.cxx

#include "AliPool.h"

// ===================================================================
//                             AliEvtPool
// ===================================================================

using std::cout;
using std::endl;

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