Rivet API documentation

Rivet 4.1.3
Percentile.hh
1#ifndef PERCENTILE_HH
2#define PERCENTILE_HH
3
4#include "Rivet/Event.hh"
5#include "Rivet/ProjectionApplier.hh"
6#include "Rivet/Projections/CentralityProjection.hh"
7
8namespace Rivet {
9
10
12 class Analysis;
13
14
19 class PercentileBase {
20 public:
21
27 PercentileBase(Analysis* ana, string projName)
28 : _ana(ana), _projName(projName) { }
29
31 PercentileBase() { }
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 && _projName == other._projName && _cent == other._cent);
55 }
56
61 const vector<pair<float, float>>& centralities() const {
62 return _cent;
63 }
64
65
66 protected:
67
69 Analysis* _ana;
70
72 string _projName;
73
76 vector<int> _activeBins;
77
80 vector<pair<float, float>> _cent;
81 };
82
83
88 template <class T>
89 class PercentileTBase : public PercentileBase {
90 public:
91
93 using TPtr = MultiplexPtr<Multiplexer<T>>;
94
100 PercentileTBase(Analysis* ana, string projName)
101 : PercentileBase(ana, projName), _histos() { }
102
104 PercentileTBase() { }
105
107 ~PercentileTBase() { }
108
118 void add(TPtr ao, CounterPtr cnt, pair<float, float> cent = {0.0, 100.0}) {
119 _cent.push_back(cent);
120 _histos.push_back({ao, cnt});
121 }
122
128 bool add(const PercentileBase& other, const vector<TPtr>& tv) {
129 copyFrom(other);
130 if (tv.size() != _cent.size()) return false;
131 for (auto t : tv) _histos.push_back({t, CounterPtr()});
132 return true;
133 }
134
138 bool init(const Event& event) {
139 selectBins(event);
140 for (const auto bin : _activeBins) _histos[bin].second->fill();
141 return !_activeBins.empty();
142 }
143
148 void normalizePerEvent() {
149 for (const auto& hist : _histos)
150 if (hist.second->numEntries() > 0 && hist.first->numEntries() > 0)
151 hist.first->scaleW(1. / hist.second->val());
152 }
153
155 void scale(float scale) {
156 for (const auto hist : _histos) hist.first->scaleW(scale);
157 }
158
160 void exec(function<void(T&)> f) {
161 for (auto hist : _histos) f(hist);
162 }
163
170 const vector<pair<TPtr, CounterPtr>>& analysisObjects() const {
171 return _histos;
172 }
173
174
175 protected:
176
181 vector<pair<TPtr, CounterPtr>> _histos;
182 };
183
184
193 template <class T>
194 class Percentile : public PercentileTBase<T> {
195 public:
196
202 Percentile(Analysis* ana, string projName)
203 : PercentileTBase<T>(ana, projName) { }
204
206 Percentile() { }
207
209 ~Percentile() { }
210
212 using PercentileTBase<T>::_histos;
213
215 using PercentileTBase<T>::_activeBins;
216
219 template <typename... Args>
220 void fill(Args... args) {
221 for (const auto bin : _activeBins) {
222 _histos[bin].first->fill(args...);
223 }
224 }
225
227 Percentile<T>& operator-=(const Percentile<T>& rhs) {
228 const int nCent = _histos.size();
229 for (int iCent = 0; iCent < nCent; ++iCent) {
230 *_histos[iCent].first -= *rhs._histos[iCent].first;
231 }
232 }
233
235 Percentile<T>& operator+=(const Percentile<T>& rhs) {
236 const int nCent = _histos.size();
237 for (int iCent = 0; iCent < nCent; ++iCent) {
238 *_histos[iCent].first += *rhs._histos[iCent].first;
240 }
241 }
242
244 Percentile<T>* operator->() {
245 return this;
246 }
247
249 Percentile<T>& operator->*(function<void(T&)> f) {
250 exec(f);
251 return *this;
252 }
253 };
254
255
270 template <class T>
271 class PercentileXaxis : public PercentileTBase<T> {
272 public:
273
279 PercentileXaxis(Analysis* ana, string projName)
280 : PercentileTBase<T>(ana, projName) { }
281
283 PercentileXaxis() { }
284
286 ~PercentileXaxis() { }
287
289 using PercentileTBase<T>::_histos;
290
292 using PercentileTBase<T>::_activeBins;
293
296 template <typename... Args>
297 void fill(Args... args) {
298 for (const auto bin : _activeBins) {
299 _histos[bin].first->fill(bin, args...);
300 }
301 }
302
304 PercentileXaxis<T>& operator-=(const PercentileXaxis<T>& rhs) {
305 const int nCent = _histos.size();
306 for (int iCent = 0; iCent < nCent; ++iCent) {
307 *_histos[iCent].first -= *rhs._histos[iCent].first;
308 }
309 }
310
312 PercentileXaxis<T>& operator+=(const PercentileXaxis<T>& rhs) {
313 const int nCent = this->_histos.size();
314 for (int iCent = 0; iCent < nCent; ++iCent) {
315 *_histos[iCent].first += *rhs._histos[iCent].first;
316 }
317 }
318
320 PercentileXaxis<T>* operator->() {
321 return this;
322 }
323
325 PercentileXaxis<T>& operator->*(function<void(T&)> f) {
326 exec(f);
327 return *this;
328 }
329 };
330
331
336
337 template <typename T>
338 Percentile<typename ReferenceTraits<T>::RefT> divide(const Percentile<T> numer, const Percentile<T> denom) {
339 typedef typename ReferenceTraits<T>::RefT ScatT;
340 Percentile<ScatT> ret;
341 vector<typename ScatT::Ptr> scatters;
342 assert(numer.compatible(denom));
343 for (int i = 0, N = numer.analysisObjects().size(); i < N; ++i)
344 scatters.push_back(
345 make_shared<ScatT>(divide(*numer.analysisObjects()[i].first, *denom.analysisObjects()[i].first)));
346 ret.add(numer, scatters);
347 return ret;
348 }
349
350 template <typename T>
351 Percentile<typename ReferenceTraits<T>::RefT> divide(
352 const Percentile<T> numer,
353 const Percentile<typename ReferenceTraits<T>::RefT> denom) {
354 typedef typename ReferenceTraits<T>::RefT ScatT;
355 Percentile<ScatT> ret;
356 vector<typename ScatT::Ptr> scatters;
357 assert(numer.compatible(denom));
358 for (int i = 0, N = numer.analysisObjects().size(); i < N; ++i)
359 scatters.push_back(
360 make_shared<ScatT>(divide(*numer.analysisObjects()[i].first, *denom.analysisObjects()[i].first)));
361 ret.add(numer, scatters);
362 return ret;
363 }
364
365 template <typename T>
366 Percentile<typename ReferenceTraits<T>::RefT> divide(
367 const Percentile<typename ReferenceTraits<T>::RefT> numer,
368 const Percentile<T> denom) {
369 typedef typename ReferenceTraits<T>::RefT ScatT;
370 Percentile<typename ReferenceTraits<T>::RefT> ret;
371 vector<typename ScatT::Ptr> scatters;
372 assert(numer.compatible(denom));
373 for (int i = 0, N = numer.analysisObjects().size(); i < N; ++i)
374 scatters.push_back(
375 make_shared<ScatT>(divide(*numer.analysisObjects()[i].first, *denom.analysisObjects()[i].first)));
376 ret.add(numer, scatters);
377 return ret;
378 }
379
380 template <typename T>
381 Percentile<T> add(const Percentile<T> pctla, const Percentile<T> pctlb) {
382 Percentile<T> ret;
383 vector<typename T::Ptr> aos;
384 assert(pctla.compatible(pctlb));
385 for (int i = 0, N = pctla.analysisObjects().size(); i < N; ++i)
386 aos.push_back(
387 make_shared<T>(add(*pctla.analysisObjects()[i].first, *pctlb.analysisObjects()[i].first)));
388 ret.add(pctla, aos);
389 return ret;
390 }
391
392 template <typename T>
393 Percentile<typename ReferenceTraits<T>::RefT> add(
394 const Percentile<T> pctla,
395 const Percentile<typename ReferenceTraits<T>::RefT> pctlb) {
396 typedef typename ReferenceTraits<T>::RefT ScatT;
397 Percentile<ScatT> ret;
398 vector<typename ScatT::Ptr> scatters;
399 assert(pctla.compatible(pctlb));
400 for (int i = 0, N = pctla.analysisObjects().size(); i < N; ++i)
401 scatters.push_back(
402 make_shared<ScatT>(add(*pctla.analysisObjects()[i].first, *pctlb.analysisObjects()[i].first)));
403 ret.add(pctla, scatters);
404 return ret;
405 }
406
407 template <typename T>
408 Percentile<typename ReferenceTraits<T>::RefT> add(const Percentile<typename ReferenceTraits<T>::RefT> pctla,
409 const Percentile<T> pctlb) {
410 typedef typename ReferenceTraits<T>::RefT ScatT;
411 Percentile<ScatT> ret;
412 vector<typename ScatT::Ptr> scatters;
413 assert(pctla.compatible(pctlb));
414 for (int i = 0, N = pctla.analysisObjects().size(); i < N; ++i)
415 scatters.push_back(
416 make_shared<ScatT>(add(*pctla.analysisObjects()[i].first, *pctlb.analysisObjects()[i].first)));
417 ret.add(pctla, scatters);
418 return ret;
419 }
420
421 template <typename T>
422 Percentile<T> subtract(const Percentile<T> pctla, const Percentile<T> pctlb) {
423 Percentile<T> ret;
424 vector<typename T::Ptr> aos;
425 assert(pctla.compatible(pctlb));
426 for (int i = 0, N = pctla.analysisObjects().size(); i < N; ++i)
427 aos.push_back(
428 make_shared<T>(subtract(*pctla.analysisObjects()[i].first, *pctlb.analysisObjects()[i].first)));
429 ret.add(pctla, aos);
430 return ret;
431 }
432
433 template <typename T>
434 Percentile<typename ReferenceTraits<T>::RefT> subtract(
435 const Percentile<T> pctla,
436 const Percentile<typename ReferenceTraits<T>::RefT> pctlb) {
437 typedef typename ReferenceTraits<T>::RefT ScatT;
438 Percentile<ScatT> ret;
439 vector<typename ScatT::Ptr> scatters;
440 assert(pctla.compatible(pctlb));
441 for (int i = 0, N = pctla.analysisObjects().size(); i < N; ++i)
442 scatters.push_back(
443 make_shared<ScatT>(subtract(*pctla.analysisObjects()[i].first, *pctlb.analysisObjects()[i].first)));
444 ret.add(pctla, scatters);
445 return ret;
446 }
447
448 template <typename T>
449 Percentile<typename ReferenceTraits<T>::RefT> subtract(
450 const Percentile<typename ReferenceTraits<T>::RefT> pctla,
451 const Percentile<T> pctlb) {
452 typedef typename ReferenceTraits<T>::RefT ScatT;
453 Percentile<ScatT> ret;
454 vector<typename ScatT::Ptr> scatters;
455 assert(pctla.compatible(pctlb));
456 for (int i = 0, N = pctla.analysisObjects().size(); i < N; ++i)
457 scatters.push_back(
458 make_shared<ScatT>(subtract(*pctla.analysisObjects()[i].first, *pctlb.analysisObjects()[i].first)));
459 ret.add(pctla, scatters);
460 return ret;
461 }
462
463 template <typename T>
464 Percentile<typename ReferenceTraits<T>::RefT> multiply(
465 const Percentile<T> pctla,
466 const Percentile<typename ReferenceTraits<T>::RefT> pctlb) {
467 typedef typename ReferenceTraits<T>::RefT ScatT;
468 Percentile<ScatT> ret;
469 vector<typename ScatT::Ptr> scatters;
470 assert(pctla.compatible(pctlb));
471 for (int i = 0, N = pctla.analysisObjects().size(); i < N; ++i)
472 scatters.push_back(
473 make_shared<ScatT>(multiply(*pctla.analysisObjects()[i].first, *pctlb.analysisObjects()[i].first)));
474 ret.add(pctla, scatters);
475 return ret;
476 }
477
478 template <typename T>
479 Percentile<typename ReferenceTraits<T>::RefT> multiply(
480 const Percentile<typename ReferenceTraits<T>::RefT> pctla,
481 const Percentile<T> pctlb) {
482 typedef typename ReferenceTraits<T>::RefT ScatT;
483 Percentile<ScatT> ret;
484 vector<typename ScatT::Ptr> scatters;
485 assert(pctla.compatible(pctlb));
486 for (int i = 0, N = pctla.analysisObjects().size(); i < N; ++i)
487 scatters.push_back(
488 make_shared<ScatT>(multiply(*pctla.analysisObjects()[i].first, *pctlb.analysisObjects()[i].first)));
489 ret.add(pctla, scatters);
490 return ret;
491 }
492
493
494 template <typename T>
495 PercentileXaxis<typename ReferenceTraits<T>::RefT> divide(const PercentileXaxis<T> numer,
496 const PercentileXaxis<T> denom) {
497 typedef typename ReferenceTraits<T>::RefT ScatT;
498 PercentileXaxis<ScatT> ret;
499 vector<typename ScatT::Ptr> scatters;
500 assert(numer.compatible(denom));
501 for (int i = 0, N = numer.analysisObjects().size(); i < N; ++i)
502 scatters.push_back(
503 make_shared<ScatT>(divide(*numer.analysisObjects()[i].first, *denom.analysisObjects()[i].first)));
504 ret.add(numer, scatters);
505 return ret;
506 }
507
508 template <typename T>
509 PercentileXaxis<typename ReferenceTraits<T>::RefT> divide(
510 const PercentileXaxis<T> numer,
511 const PercentileXaxis<typename ReferenceTraits<T>::RefT> denom) {
512 typedef typename ReferenceTraits<T>::RefT ScatT;
513 PercentileXaxis<ScatT> ret;
514 vector<typename ScatT::Ptr> scatters;
515 assert(numer.compatible(denom));
516 for (int i = 0, N = numer.analysisObjects().size(); i < N; ++i)
517 scatters.push_back(
518 make_shared<ScatT>(divide(*numer.analysisObjects()[i].first, *denom.analysisObjects()[i].first)));
519 ret.add(numer, scatters);
520 return ret;
521 }
522
523 template <typename T>
524 PercentileXaxis<typename ReferenceTraits<T>::RefT> divide(
525 const PercentileXaxis<typename ReferenceTraits<T>::RefT> numer,
526 const PercentileXaxis<T> denom) {
527 typedef typename ReferenceTraits<T>::RefT ScatT;
528 PercentileXaxis<typename ReferenceTraits<T>::RefT> ret;
529 vector<typename ScatT::Ptr> scatters;
530 assert(numer.compatible(denom));
531 for (int i = 0, N = numer.analysisObjects().size(); i < N; ++i)
532 scatters.push_back(
533 make_shared<ScatT>(divide(*numer.analysisObjects()[i].first, *denom.analysisObjects()[i].first)));
534 ret.add(numer, scatters);
535 return ret;
536 }
537
538 template <typename T>
539 PercentileXaxis<T> add(const PercentileXaxis<T> pctla, const PercentileXaxis<T> pctlb) {
540 PercentileXaxis<T> ret;
541 vector<typename T::Ptr> aos;
542 assert(pctla.compatible(pctlb));
543 for (int i = 0, N = pctla.analysisObjects().size(); i < N; ++i)
544 aos.push_back(
545 make_shared<T>(add(*pctla.analysisObjects()[i].first, *pctlb.analysisObjects()[i].first)));
546 ret.add(pctla, aos);
547 return ret;
548 }
549
550 template <typename T>
551 PercentileXaxis<typename ReferenceTraits<T>::RefT> add(
552 const PercentileXaxis<T> pctla,
553 const PercentileXaxis<typename ReferenceTraits<T>::RefT> pctlb) {
554 typedef typename ReferenceTraits<T>::RefT ScatT;
555 PercentileXaxis<ScatT> ret;
556 vector<typename ScatT::Ptr> scatters;
557 assert(pctla.compatible(pctlb));
558 for (int i = 0, N = pctla.analysisObjects().size(); i < N; ++i)
559 scatters.push_back(
560 make_shared<ScatT>(add(*pctla.analysisObjects()[i].first, *pctlb.analysisObjects()[i].first)));
561 ret.add(pctla, scatters);
562 return ret;
563 }
564
565 template <typename T>
566 PercentileXaxis<typename ReferenceTraits<T>::RefT> add(
567 const PercentileXaxis<typename ReferenceTraits<T>::RefT> pctla,
568 const PercentileXaxis<T> pctlb) {
569 typedef typename ReferenceTraits<T>::RefT ScatT;
570 PercentileXaxis<ScatT> ret;
571 vector<typename ScatT::Ptr> scatters;
572 assert(pctla.compatible(pctlb));
573 for (int i = 0, N = pctla.analysisObjects().size(); i < N; ++i)
574 scatters.push_back(
575 make_shared<ScatT>(add(*pctla.analysisObjects()[i].first, *pctlb.analysisObjects()[i].first)));
576 ret.add(pctla, scatters);
577 return ret;
578 }
579
580 template <typename T>
581 PercentileXaxis<T> subtract(const PercentileXaxis<T> pctla, const PercentileXaxis<T> pctlb) {
582 PercentileXaxis<T> ret;
583 vector<typename T::Ptr> aos;
584 assert(pctla.compatible(pctlb));
585 for (int i = 0, N = pctla.analysisObjects().size(); i < N; ++i)
586 aos.push_back(
587 make_shared<T>(subtract(*pctla.analysisObjects()[i].first, *pctlb.analysisObjects()[i].first)));
588 ret.add(pctla, aos);
589 return ret;
590 }
591
592 template <typename T>
593 PercentileXaxis<typename ReferenceTraits<T>::RefT> subtract(
594 const PercentileXaxis<T> pctla,
595 const PercentileXaxis<typename ReferenceTraits<T>::RefT> pctlb) {
596 typedef typename ReferenceTraits<T>::RefT ScatT;
597 PercentileXaxis<ScatT> ret;
598 vector<typename ScatT::Ptr> scatters;
599 assert(pctla.compatible(pctlb));
600 for (int i = 0, N = pctla.analysisObjects().size(); i < N; ++i)
601 scatters.push_back(
602 make_shared<ScatT>(subtract(*pctla.analysisObjects()[i].first, *pctlb.analysisObjects()[i].first)));
603 ret.add(pctla, scatters);
604 return ret;
605 }
606
607 template <typename T>
608 PercentileXaxis<typename ReferenceTraits<T>::RefT> subtract(
609 const PercentileXaxis<typename ReferenceTraits<T>::RefT> pctla,
610 const PercentileXaxis<T> pctlb) {
611 typedef typename ReferenceTraits<T>::RefT ScatT;
612 PercentileXaxis<ScatT> ret;
613 vector<typename ScatT::Ptr> scatters;
614 assert(pctla.compatible(pctlb));
615 for (int i = 0, N = pctla.analysisObjects().size(); i < N; ++i)
616 scatters.push_back(
617 make_shared<ScatT>(subtract(*pctla.analysisObjects()[i].first, *pctlb.analysisObjects()[i].first)));
618 ret.add(pctla, scatters);
619 return ret;
620 }
621
622 template <typename T>
623 PercentileXaxis<typename ReferenceTraits<T>::RefT> multiply(
624 const PercentileXaxis<T> pctla,
625 const PercentileXaxis<typename ReferenceTraits<T>::RefT> pctlb) {
626 typedef typename ReferenceTraits<T>::RefT ScatT;
627 PercentileXaxis<ScatT> ret;
628 vector<typename ScatT::Ptr> scatters;
629 assert(pctla.compatible(pctlb));
630 for (int i = 0, N = pctla.analysisObjects().size(); i < N; ++i)
631 scatters.push_back(
632 make_shared<ScatT>(multiply(*pctla.analysisObjects()[i].first, *pctlb.analysisObjects()[i].first)));
633 ret.add(pctla, scatters);
634 return ret;
635 }
636
637 template <typename T>
638 PercentileXaxis<typename ReferenceTraits<T>::RefT> multiply(
639 const PercentileXaxis<typename ReferenceTraits<T>::RefT> pctla,
640 const PercentileXaxis<T> pctlb) {
641 typedef typename ReferenceTraits<T>::RefT ScatT;
642 PercentileXaxis<ScatT> ret;
643 vector<typename ScatT::Ptr> scatters;
644 assert(pctla.compatible(pctlb));
645 for (int i = 0, N = pctla.analysisObjects().size(); i < N; ++i)
646 scatters.push_back(
647 make_shared<ScatT>(multiply(*pctla.analysisObjects()[i].first, *pctlb.analysisObjects()[i].first)));
648 ret.add(pctla, scatters);
649 return ret;
650 }
651
652 template <typename T>
653 Percentile<T> operator+(const Percentile<T> pctla, const Percentile<T> pctlb) {
654 return add(pctla, pctlb);
655 }
656
657 template <typename T>
658 Percentile<T> operator-(const Percentile<T> pctla, const Percentile<T> pctlb) {
659 return subtract(pctla, pctlb);
660 }
661
662 template <typename T>
663 Percentile<typename ReferenceTraits<T>::RefT> operator/(const Percentile<T> numer,
664 const Percentile<T> denom) {
665 return divide(numer, denom);
666 }
667
668 template <typename T>
669 PercentileXaxis<T> operator+(const PercentileXaxis<T> pctla, const PercentileXaxis<T> pctlb) {
670 return add(pctla, pctlb);
671 }
672
673 template <typename T>
674 PercentileXaxis<T> operator-(const PercentileXaxis<T> pctla, const PercentileXaxis<T> pctlb) {
675 return subtract(pctla, pctlb);
676 }
677
678 template <typename T>
679 PercentileXaxis<typename ReferenceTraits<T>::RefT> operator/(const PercentileXaxis<T> numer,
680 const PercentileXaxis<T> denom) {
681 return divide(numer, denom);
682 }
683
685
686
687}
688
689#endif
Rivet::Analysis
This is the base class of all analysis classes in Rivet.
Definition Analysis.hh:69
Rivet::Event
Representation of a HepMC event, and enabler of Projection caching.
Definition Event.hh:22
Rivet::MultiplexPtr
Definition RivetYODA.hh:1376
Rivet::PercentileBase::selectBins
void selectBins(const Event &)
Initialize the PercentileBase for a new event.
Rivet::PercentileBase::inRange
static bool inRange(double x, pair< float, float > range)
Helper function to check if x is within range.
Definition Percentile.hh:41
Rivet::PercentileBase::PercentileBase
PercentileBase(Analysis *ana, string projName)
Constructor.
Definition Percentile.hh:27
Rivet::PercentileBase::compatible
bool compatible(const PercentileBase &other) const
check if other PercentileBase is compatible with this.
Definition Percentile.hh:53
Rivet::PercentileBase::copyFrom
void copyFrom(const PercentileBase &other)
Copy information from other PercentileBase.
Definition Percentile.hh:46
Rivet::PercentileBase::centralities
const vector< pair< float, float > > & centralities() const
return the list of centrality bins.
Definition Percentile.hh:61
Rivet::PercentileBase::PercentileBase
PercentileBase()
Default constructor.
Definition Percentile.hh:31
Rivet::PercentileTBase
PercentileTBase is the base class of all Percentile classes.
Definition Percentile.hh:89
Rivet::PercentileTBase::analysisObjects
const vector< pair< TPtr, CounterPtr > > & analysisObjects() const
Access the underlyng AnalysisObjects.
Definition Percentile.hh:170
Rivet::PercentileTBase::normalizePerEvent
void normalizePerEvent()
Normalize each AnalysisObject.
Definition Percentile.hh:148
Rivet::PercentileTBase::init
bool init(const Event &event)
Initialize for a new event. Select which AnalysisObjects should be filled for this event....
Definition Percentile.hh:138
Rivet::PercentileTBase::add
bool add(const PercentileBase &other, const vector< TPtr > &tv)
Copy the information from an other Percentile object.
Definition Percentile.hh:128
Rivet::PercentileTBase::~PercentileTBase
~PercentileTBase()
Empty destructor.
Definition Percentile.hh:107
Rivet::PercentileTBase::TPtr
MultiplexPtr< Multiplexer< T > > TPtr
Convenient typedef.
Definition Percentile.hh:93
Rivet::PercentileTBase::scale
void scale(float scale)
Simple scaling of each AnalysisObject.
Definition Percentile.hh:155
Rivet::PercentileTBase::add
void add(TPtr ao, CounterPtr cnt, pair< float, float > cent={0.0, 100.0})
Add a new percentile bin.
Definition Percentile.hh:118
Rivet::PercentileTBase::exec
void exec(function< void(T &)> f)
Execute a function for each AnalysisObject.
Definition Percentile.hh:160
Rivet::PercentileTBase::PercentileTBase
PercentileTBase(Analysis *ana, string projName)
Main constructor.
Definition Percentile.hh:100
Rivet::PercentileTBase::PercentileTBase
PercentileTBase()
Default constructor.
Definition Percentile.hh:104
Rivet::PercentileXaxis
The PercentileXaxis class for centrality binning.
Definition Percentile.hh:271
Rivet::PercentileXaxis::operator-=
PercentileXaxis< T > & operator-=(const PercentileXaxis< T > &rhs)
Subtract the contents from another PercentileXaxis.
Definition Percentile.hh:304
Rivet::PercentileXaxis::fill
void fill(Args... args)
Definition Percentile.hh:297
Rivet::PercentileXaxis::operator+=
PercentileXaxis< T > & operator+=(const PercentileXaxis< T > &rhs)
Add the contents from another PercentileXaxis.
Definition Percentile.hh:312
Rivet::PercentileXaxis::PercentileXaxis
PercentileXaxis(Analysis *ana, string projName)
Main constructor.
Definition Percentile.hh:279
Rivet::PercentileXaxis::PercentileXaxis
PercentileXaxis()
Default constructor.
Definition Percentile.hh:283
Rivet::PercentileXaxis::operator->*
PercentileXaxis< T > & operator->*(function< void(T &)> f)
Pointer to member operator.
Definition Percentile.hh:325
Rivet::PercentileXaxis::~PercentileXaxis
~PercentileXaxis()
Empty destructor.
Definition Percentile.hh:286
Rivet::PercentileXaxis::operator->
PercentileXaxis< T > * operator->()
Make this object look like a pointer.
Definition Percentile.hh:320
Rivet::Percentile
The Percentile class for centrality binning.
Definition Percentile.hh:194
Rivet::Percentile::fill
void fill(Args... args)
Definition Percentile.hh:220
Rivet::Percentile::operator->*
Percentile< T > & operator->*(function< void(T &)> f)
Pointer to member operator.
Definition Percentile.hh:249
Rivet::Percentile::operator-=
Percentile< T > & operator-=(const Percentile< T > &rhs)
Subtract the contents fro another Pecentile.
Definition Percentile.hh:227
Rivet::Percentile::~Percentile
~Percentile()
Empty destructor.
Definition Percentile.hh:209
Rivet::Percentile::operator+=
Percentile< T > & operator+=(const Percentile< T > &rhs)
Add the contents fro another Pecentile.
Definition Percentile.hh:235
Rivet::Percentile::Percentile
Percentile(Analysis *ana, string projName)
Main constructor.
Definition Percentile.hh:202
Rivet::Percentile::Percentile
Percentile()
Default constructor.
Definition Percentile.hh:206
Rivet::Percentile::operator->
Percentile< T > * operator->()
Make this object look like a pointer.
Definition Percentile.hh:244
vector
STL class.
Rivet
Definition LHCbCommon.hh:9
Rivet::subtract
double subtract(double a, double b, double tolerance=1e-5)
Subtract two numbers with FP fuzziness.
Definition MathUtils.hh:242
Rivet::add
double add(double a, double b, double tolerance=1e-5)
Add two numbers with FP fuzziness.
Definition MathUtils.hh:248
Generated on for Rivet by doxygen 1.15.0