Rivet  3.1.3
Percentile.hh
1 #ifndef PERCENTILE_HH
2 #define PERCENTILE_HH
3 
4 #include "Rivet/Event.hh"
5 #include "Rivet/Projections/CentralityProjection.hh"
6 #include "Rivet/ProjectionApplier.hh"
7 
8 namespace Rivet {
9 
10 
12  class Analysis;
13 
14 
20  public:
21 
27  PercentileBase(Analysis * ana, string projName)
28  : _ana(ana), _projName(projName) {}
29 
32 
38  void selectBins(const Event &);
39 
41  static bool inRange(double x, pair<float,float> range) {
42  return x >= range.first && ( x < range.second || ( x == 100.0 && x == range.second ) );
43  }
44 
46  void copyFrom(const PercentileBase & other) {
47  _ana = other._ana;
48  _projName = other._projName;
49  _cent = other._cent;
50  }
51 
53  bool compatible(const PercentileBase & other) const {
54  return ( _ana == other._ana &&
55  _projName == other._projName &&
56  _cent == other._cent );
57  }
58 
63  const vector< pair<float, float> > & centralities() const {
64  return _cent;
65  }
66 
67 
68  protected:
69 
71  Analysis* _ana;
72 
74  string _projName;
75 
78  vector<int> _activeBins;
79 
82  vector<pair<float, float> > _cent;
83 
84  };
85 
86 
87 
92  template<class T>
94  public:
95 
97  typedef rivet_shared_ptr<Wrapper<T>> TPtr;
98 
104  PercentileTBase(Analysis * ana, string projName)
105  : PercentileBase(ana, projName), _histos() {}
106 
109 
112 
122  void add(TPtr ao, CounterPtr cnt,
123  pair<float,float> cent = {0.0, 100.0} ) {
124  _cent.push_back(cent);
125  _histos.push_back( { ao, cnt } );
126  }
127 
133  bool add(const PercentileBase & other, const vector<TPtr> & tv) {
134  copyFrom(other);
135  if ( tv.size() != _cent.size() ) return false;
136  for ( auto t : tv )
137  _histos.push_back( { t, CounterPtr() } );
138  return true;
139  }
140 
144  bool init(const Event & event) {
145  selectBins(event);
146  for (const auto bin : _activeBins)
147  _histos[bin].second->fill();
148  return !_activeBins.empty();
149  }
150 
156  for (const auto &hist : _histos)
157  if ( hist.second->numEntries() > 0 && hist.first->numEntries() > 0)
158  hist.first->scaleW(1./hist.second->val());
159  }
160 
162  void scale(float scale) {
163  for (const auto hist : _histos)
164  hist.first->scaleW(scale);
165  }
166 
168  void exec(function<void(T&)> f) { for ( auto hist : _histos) f(hist); }
169 
176  const vector<pair<TPtr, CounterPtr > > &
178  return _histos;
179  }
180 
181 
182  protected:
183 
188  vector<pair<TPtr, CounterPtr > > _histos;
189 
190  };
191 
192 
193 
202  template<class T>
203  class Percentile : public PercentileTBase<T> {
204  public:
205 
211  Percentile(Analysis * ana, string projName)
212  : PercentileTBase<T>(ana, projName) {}
213 
216 
219 
222 
225 
228  template<typename... Args>
229  void fill(Args... args) {
230  for (const auto bin : _activeBins) {
231  _histos[bin].first->fill(args...);
232  }
233  }
234 
237  const int nCent = _histos.size();
238  for (int iCent = 0; iCent < nCent; ++iCent) {
239  *_histos[iCent].first -= *rhs._histos[iCent].first;
240  }
241  }
242 
245  const int nCent = _histos.size();
246  for (int iCent = 0; iCent < nCent; ++iCent) {
247  *_histos[iCent].first += *rhs._histos[iCent].first;
249  }
250  }
251 
253  Percentile<T> *operator->() { return this; }
254 
256  Percentile<T> &operator->*(function<void(T&)> f) { exec(f); return *this; }
257 
258  };
259 
260 
261 
276  template<class T>
277  class PercentileXaxis : public PercentileTBase<T> {
278  public:
279 
285  PercentileXaxis(Analysis * ana, string projName)
286  : PercentileTBase<T>(ana, projName) {}
287 
290 
293 
296 
299 
302  template<typename... Args>
303  void fill(Args... args) {
304  for (const auto bin : _activeBins) {
305  _histos[bin].first->fill(bin, args...);
306  }
307  }
308 
311  const int nCent = _histos.size();
312  for (int iCent = 0; iCent < nCent; ++iCent) {
313  *_histos[iCent].first -= *rhs._histos[iCent].first;
314  }
315  }
316 
319  const int nCent = this->_histos.size();
320  for (int iCent = 0; iCent < nCent; ++iCent) {
321  *_histos[iCent].first += *rhs._histos[iCent].first;
322  }
323  }
324 
326  PercentileXaxis<T> *operator->() { return this; }
327 
329  PercentileXaxis<T> &operator->*(function<void(T&)> f) { exec(f); return *this; }
330 
331  };
332 
333 
334 
338  // @{
339 
340  template <typename T>
342  divide(const Percentile<T> numer, const Percentile<T> denom) {
343  typedef typename ReferenceTraits<T>::RefT ScatT;
344  Percentile<ScatT> ret;
345  vector<typename ScatT::Ptr> scatters;
346  assert( numer.compatible(denom) );
347  for ( int i = 0, N = numer.analysisObjects().size(); i < N; ++i )
348  scatters.push_back(make_shared<ScatT>(divide(*numer.analysisObjects()[i].first,
349  *denom.analysisObjects()[i].first)));
350  ret.add(numer, scatters);
351  return ret;
352  }
353 
354  template <typename T>
356  divide(const Percentile<T> numer,
357  const Percentile<typename ReferenceTraits<T>::RefT> denom) {
358  typedef typename ReferenceTraits<T>::RefT ScatT;
359  Percentile<ScatT> ret;
360  vector<typename ScatT::Ptr> scatters;
361  assert( numer.compatible(denom) );
362  for ( int i = 0, N = numer.analysisObjects().size(); i < N; ++i )
363  scatters.push_back(make_shared<ScatT>(divide(*numer.analysisObjects()[i].first,
364  *denom.analysisObjects()[i].first)));
365  ret.add(numer, scatters);
366  return ret;
367  }
368 
369  template <typename T>
371  divide(const Percentile<typename ReferenceTraits<T>::RefT> numer,
372  const Percentile<T> denom) {
373  typedef typename ReferenceTraits<T>::RefT ScatT;
375  vector<typename ScatT::Ptr> scatters;
376  assert( numer.compatible(denom) );
377  for ( int i = 0, N = numer.analysisObjects().size(); i < N; ++i )
378  scatters.push_back(make_shared<ScatT>(divide(*numer.analysisObjects()[i].first,
379  *denom.analysisObjects()[i].first)));
380  ret.add(numer, scatters);
381  return ret;
382  }
383 
384  template <typename T>
385  Percentile<T> add(const Percentile<T> pctla, const Percentile<T> pctlb) {
386  Percentile<T> ret;
387  vector<typename T::Ptr> aos;
388  assert( pctla.compatible(pctlb) );
389  for ( int i = 0, N = pctla.analysisObjects().size(); i < N; ++i )
390  aos.push_back(make_shared<T>(add(*pctla.analysisObjects()[i].first,
391  *pctlb.analysisObjects()[i].first)));
392  ret.add(pctla, aos);
393  return ret;
394  }
395 
396  template <typename T>
398  add(const Percentile<T> pctla,
399  const Percentile<typename ReferenceTraits<T>::RefT> pctlb) {
400  typedef typename ReferenceTraits<T>::RefT ScatT;
401  Percentile<ScatT> ret;
402  vector<typename ScatT::Ptr> scatters;
403  assert( pctla.compatible(pctlb) );
404  for ( int i = 0, N = pctla.analysisObjects().size(); i < N; ++i )
405  scatters.push_back(make_shared<ScatT>(add(*pctla.analysisObjects()[i].first,
406  *pctlb.analysisObjects()[i].first)));
407  ret.add(pctla, scatters);
408  return ret;
409  }
410 
411  template <typename T>
413  add(const Percentile<typename ReferenceTraits<T>::RefT> pctla,
414  const Percentile<T> pctlb) {
415  typedef typename ReferenceTraits<T>::RefT ScatT;
416  Percentile<ScatT> ret;
417  vector<typename ScatT::Ptr> scatters;
418  assert( pctla.compatible(pctlb) );
419  for ( int i = 0, N = pctla.analysisObjects().size(); i < N; ++i )
420  scatters.push_back(make_shared<ScatT>(add(*pctla.analysisObjects()[i].first,
421  *pctlb.analysisObjects()[i].first)));
422  ret.add(pctla, scatters);
423  return ret;
424  }
425 
426  template <typename T>
427  Percentile<T> subtract(const Percentile<T> pctla, const Percentile<T> pctlb) {
428  Percentile<T> ret;
429  vector<typename T::Ptr> aos;
430  assert( pctla.compatible(pctlb) );
431  for ( int i = 0, N = pctla.analysisObjects().size(); i < N; ++i )
432  aos.push_back(make_shared<T>(subtract(*pctla.analysisObjects()[i].first,
433  *pctlb.analysisObjects()[i].first)));
434  ret.add(pctla, aos);
435  return ret;
436  }
437 
438  template <typename T>
440  subtract(const Percentile<T> pctla,
441  const Percentile<typename ReferenceTraits<T>::RefT> pctlb) {
442  typedef typename ReferenceTraits<T>::RefT ScatT;
443  Percentile<ScatT> ret;
444  vector<typename ScatT::Ptr> scatters;
445  assert( pctla.compatible(pctlb) );
446  for ( int i = 0, N = pctla.analysisObjects().size(); i < N; ++i )
447  scatters.push_back(make_shared<ScatT>(subtract(*pctla.analysisObjects()[i].first,
448  *pctlb.analysisObjects()[i].first)));
449  ret.add(pctla, scatters);
450  return ret;
451  }
452 
453  template <typename T>
455  subtract(const Percentile<typename ReferenceTraits<T>::RefT> pctla,
456  const Percentile<T> pctlb) {
457  typedef typename ReferenceTraits<T>::RefT ScatT;
458  Percentile<ScatT> ret;
459  vector<typename ScatT::Ptr> scatters;
460  assert( pctla.compatible(pctlb) );
461  for ( int i = 0, N = pctla.analysisObjects().size(); i < N; ++i )
462  scatters.push_back(make_shared<ScatT>(subtract(*pctla.analysisObjects()[i].first,
463  *pctlb.analysisObjects()[i].first)));
464  ret.add(pctla, scatters);
465  return ret;
466  }
467 
468  template <typename T>
470  multiply(const Percentile<T> pctla,
471  const Percentile<typename ReferenceTraits<T>::RefT> pctlb) {
472  typedef typename ReferenceTraits<T>::RefT ScatT;
473  Percentile<ScatT> ret;
474  vector<typename ScatT::Ptr> scatters;
475  assert( pctla.compatible(pctlb) );
476  for ( int i = 0, N = pctla.analysisObjects().size(); i < N; ++i )
477  scatters.push_back(make_shared<ScatT>(multiply(*pctla.analysisObjects()[i].first,
478  *pctlb.analysisObjects()[i].first)));
479  ret.add(pctla, scatters);
480  return ret;
481  }
482 
483  template <typename T>
485  multiply(const Percentile<typename ReferenceTraits<T>::RefT> pctla,
486  const Percentile<T> pctlb) {
487  typedef typename ReferenceTraits<T>::RefT ScatT;
488  Percentile<ScatT> ret;
489  vector<typename ScatT::Ptr> scatters;
490  assert( pctla.compatible(pctlb) );
491  for ( int i = 0, N = pctla.analysisObjects().size(); i < N; ++i )
492  scatters.push_back(make_shared<ScatT>(multiply(*pctla.analysisObjects()[i].first,
493  *pctlb.analysisObjects()[i].first)));
494  ret.add(pctla, scatters);
495  return ret;
496  }
497 
498 
499 
500  template <typename T>
502  divide(const PercentileXaxis<T> numer, const PercentileXaxis<T> denom) {
503  typedef typename ReferenceTraits<T>::RefT ScatT;
505  vector<typename ScatT::Ptr> scatters;
506  assert( numer.compatible(denom) );
507  for ( int i = 0, N = numer.analysisObjects().size(); i < N; ++i )
508  scatters.push_back(make_shared<ScatT>(divide(*numer.analysisObjects()[i].first,
509  *denom.analysisObjects()[i].first)));
510  ret.add(numer, scatters);
511  return ret;
512  }
513 
514  template <typename T>
516  divide(const PercentileXaxis<T> numer,
517  const PercentileXaxis<typename ReferenceTraits<T>::RefT> denom) {
518  typedef typename ReferenceTraits<T>::RefT ScatT;
520  vector<typename ScatT::Ptr> scatters;
521  assert( numer.compatible(denom) );
522  for ( int i = 0, N = numer.analysisObjects().size(); i < N; ++i )
523  scatters.push_back(make_shared<ScatT>(divide(*numer.analysisObjects()[i].first,
524  *denom.analysisObjects()[i].first)));
525  ret.add(numer, scatters);
526  return ret;
527  }
528 
529  template <typename T>
531  divide(const PercentileXaxis<typename ReferenceTraits<T>::RefT> numer,
532  const PercentileXaxis<T> denom) {
533  typedef typename ReferenceTraits<T>::RefT ScatT;
535  vector<typename ScatT::Ptr> scatters;
536  assert( numer.compatible(denom) );
537  for ( int i = 0, N = numer.analysisObjects().size(); i < N; ++i )
538  scatters.push_back(make_shared<ScatT>(divide(*numer.analysisObjects()[i].first,
539  *denom.analysisObjects()[i].first)));
540  ret.add(numer, scatters);
541  return ret;
542  }
543 
544  template <typename T>
545  PercentileXaxis<T> add(const PercentileXaxis<T> pctla, const PercentileXaxis<T> pctlb) {
546  PercentileXaxis<T> ret;
547  vector<typename T::Ptr> aos;
548  assert( pctla.compatible(pctlb) );
549  for ( int i = 0, N = pctla.analysisObjects().size(); i < N; ++i )
550  aos.push_back(make_shared<T>(add(*pctla.analysisObjects()[i].first,
551  *pctlb.analysisObjects()[i].first)));
552  ret.add(pctla, aos);
553  return ret;
554  }
555 
556  template <typename T>
558  add(const PercentileXaxis<T> pctla,
559  const PercentileXaxis<typename ReferenceTraits<T>::RefT> pctlb) {
560  typedef typename ReferenceTraits<T>::RefT ScatT;
562  vector<typename ScatT::Ptr> scatters;
563  assert( pctla.compatible(pctlb) );
564  for ( int i = 0, N = pctla.analysisObjects().size(); i < N; ++i )
565  scatters.push_back(make_shared<ScatT>(add(*pctla.analysisObjects()[i].first,
566  *pctlb.analysisObjects()[i].first)));
567  ret.add(pctla, scatters);
568  return ret;
569  }
570 
571  template <typename T>
573  add(const PercentileXaxis<typename ReferenceTraits<T>::RefT> pctla,
574  const PercentileXaxis<T> pctlb) {
575  typedef typename ReferenceTraits<T>::RefT ScatT;
577  vector<typename ScatT::Ptr> scatters;
578  assert( pctla.compatible(pctlb) );
579  for ( int i = 0, N = pctla.analysisObjects().size(); i < N; ++i )
580  scatters.push_back(make_shared<ScatT>(add(*pctla.analysisObjects()[i].first,
581  *pctlb.analysisObjects()[i].first)));
582  ret.add(pctla, scatters);
583  return ret;
584  }
585 
586  template <typename T>
587  PercentileXaxis<T> subtract(const PercentileXaxis<T> pctla, const PercentileXaxis<T> pctlb) {
588  PercentileXaxis<T> ret;
589  vector<typename T::Ptr> aos;
590  assert( pctla.compatible(pctlb) );
591  for ( int i = 0, N = pctla.analysisObjects().size(); i < N; ++i )
592  aos.push_back(make_shared<T>(subtract(*pctla.analysisObjects()[i].first,
593  *pctlb.analysisObjects()[i].first)));
594  ret.add(pctla, aos);
595  return ret;
596  }
597 
598  template <typename T>
600  subtract(const PercentileXaxis<T> pctla,
601  const PercentileXaxis<typename ReferenceTraits<T>::RefT> pctlb) {
602  typedef typename ReferenceTraits<T>::RefT ScatT;
604  vector<typename ScatT::Ptr> scatters;
605  assert( pctla.compatible(pctlb) );
606  for ( int i = 0, N = pctla.analysisObjects().size(); i < N; ++i )
607  scatters.push_back(make_shared<ScatT>(subtract(*pctla.analysisObjects()[i].first,
608  *pctlb.analysisObjects()[i].first)));
609  ret.add(pctla, scatters);
610  return ret;
611  }
612 
613  template <typename T>
615  subtract(const PercentileXaxis<typename ReferenceTraits<T>::RefT> pctla,
616  const PercentileXaxis<T> pctlb) {
617  typedef typename ReferenceTraits<T>::RefT ScatT;
619  vector<typename ScatT::Ptr> scatters;
620  assert( pctla.compatible(pctlb) );
621  for ( int i = 0, N = pctla.analysisObjects().size(); i < N; ++i )
622  scatters.push_back(make_shared<ScatT>(subtract(*pctla.analysisObjects()[i].first,
623  *pctlb.analysisObjects()[i].first)));
624  ret.add(pctla, scatters);
625  return ret;
626  }
627 
628  template <typename T>
630  multiply(const PercentileXaxis<T> pctla,
631  const PercentileXaxis<typename ReferenceTraits<T>::RefT> pctlb) {
632  typedef typename ReferenceTraits<T>::RefT ScatT;
634  vector<typename ScatT::Ptr> scatters;
635  assert( pctla.compatible(pctlb) );
636  for ( int i = 0, N = pctla.analysisObjects().size(); i < N; ++i )
637  scatters.push_back(make_shared<ScatT>(multiply(*pctla.analysisObjects()[i].first,
638  *pctlb.analysisObjects()[i].first)));
639  ret.add(pctla, scatters);
640  return ret;
641  }
642 
643  template <typename T>
645  multiply(const PercentileXaxis<typename ReferenceTraits<T>::RefT> pctla,
646  const PercentileXaxis<T> pctlb) {
647  typedef typename ReferenceTraits<T>::RefT ScatT;
649  vector<typename ScatT::Ptr> scatters;
650  assert( pctla.compatible(pctlb) );
651  for ( int i = 0, N = pctla.analysisObjects().size(); i < N; ++i )
652  scatters.push_back(make_shared<ScatT>(multiply(*pctla.analysisObjects()[i].first,
653  *pctlb.analysisObjects()[i].first)));
654  ret.add(pctla, scatters);
655  return ret;
656  }
657 
658  template <typename T>
660  operator+(const Percentile<T> pctla, const Percentile<T> pctlb) {
661  return add(pctla, pctlb);
662  }
663 
664  template <typename T>
666  operator-(const Percentile<T> pctla, const Percentile<T> pctlb) {
667  return subtract(pctla, pctlb);
668  }
669 
670  template <typename T>
672  operator/(const Percentile<T> numer, const Percentile<T> denom) {
673  return divide(numer, denom);
674  }
675 
676  template <typename T>
678  operator+(const PercentileXaxis<T> pctla, const PercentileXaxis<T> pctlb) {
679  return add(pctla, pctlb);
680  }
681 
682  template <typename T>
684  operator-(const PercentileXaxis<T> pctla, const PercentileXaxis<T> pctlb) {
685  return subtract(pctla, pctlb);
686  }
687 
688  template <typename T>
690  operator/(const PercentileXaxis<T> numer, const PercentileXaxis<T> denom) {
691  return divide(numer, denom);
692  }
693 
694 
695 }
696 
697 #endif
Definition: MC_Cent_pPb.hh:10
Percentile< T > & operator-=(const Percentile< T > &rhs)
Subtract the contents fro another Pecentile.
Definition: Percentile.hh:236
~Percentile()
Empty destructor.
Definition: Percentile.hh:218
void fill(Args... args)
Definition: Percentile.hh:303
bool add(const PercentileBase &other, const vector< TPtr > &tv)
Copy the information from an other Percentile object.
Definition: Percentile.hh:133
Percentile(Analysis *ana, string projName)
Main constructor.
Definition: Percentile.hh:211
void exec(function< void(T &)> f)
Execute a function for each AnalysisObject.
Definition: Percentile.hh:168
void copyFrom(const PercentileBase &other)
Copy information from other PercentileBase.
Definition: Percentile.hh:46
void scale(float scale)
Simple scaling of each AnalysisObject.
Definition: Percentile.hh:162
rivet_shared_ptr< Wrapper< T > > TPtr
Convenient typedef.
Definition: Percentile.hh:97
static bool inRange(double x, pair< float, float > range)
Helper function to check if x is within range.
Definition: Percentile.hh:41
PercentileTBase(Analysis *ana, string projName)
Main constructor.
Definition: Percentile.hh:104
void add(TPtr ao, CounterPtr cnt, pair< float, float > cent={0.0, 100.0})
Add a new percentile bin.
Definition: Percentile.hh:122
The Percentile class for centrality binning.
Definition: Percentile.hh:203
const vector< pair< float, float > > & centralities() const
return the list of centrality bins.
Definition: Percentile.hh:63
PercentileBase(Analysis *ana, string projName)
Constructor.
Definition: Percentile.hh:27
Percentile()
Default constructor.
Definition: Percentile.hh:215
~PercentileXaxis()
Empty destructor.
Definition: Percentile.hh:292
PercentileTBase is the base class of all Percentile classes.
Definition: Percentile.hh:93
This is the base class of all analysis classes in Rivet.
Definition: Analysis.hh:64
Representation of a HepMC event, and enabler of Projection caching.
Definition: Event.hh:22
PercentileBase()
Default constructor.
Definition: Percentile.hh:31
The PercentileXaxis class for centrality binning.
Definition: Percentile.hh:277
Percentile< T > & operator+=(const Percentile< T > &rhs)
Add the contents fro another Pecentile.
Definition: Percentile.hh:244
const vector< pair< TPtr, CounterPtr > > & analysisObjects() const
Access the underlyng AnalysisObjects.
Definition: Percentile.hh:177
~PercentileTBase()
Empty destructor.
Definition: Percentile.hh:111
bool compatible(const PercentileBase &other) const
check if other PercentileBase is compatible with this.
Definition: Percentile.hh:53
PercentileXaxis< T > & operator-=(const PercentileXaxis< T > &rhs)
Subtract the contents from another PercentileXaxis.
Definition: Percentile.hh:310
PercentileXaxis(Analysis *ana, string projName)
Main constructor.
Definition: Percentile.hh:285
Percentile< T > * operator->()
Make this object look like a pointer.
Definition: Percentile.hh:253
PercentileXaxis()
Default constructor.
Definition: Percentile.hh:289
void normalizePerEvent()
Normalize each AnalysisObject.
Definition: Percentile.hh:155
PercentileTBase()
Default constructor.
Definition: Percentile.hh:108
PercentileXaxis< T > * operator->()
Make this object look like a pointer.
Definition: Percentile.hh:326
void fill(Args... args)
Definition: Percentile.hh:229
PercentileXaxis< T > & operator+=(const PercentileXaxis< T > &rhs)
Add the contents from another PercentileXaxis.
Definition: Percentile.hh:318
PercentileBase is the base class of all Percentile classes.
Definition: Percentile.hh:19
bool init(const Event &event)
Initialize for a new event. Select which AnalysisObjects should be filled for this event...
Definition: Percentile.hh:144
void selectBins(const Event &)
Initialize the PercentileBase for a new event.