Rivet: /Users/chrisg/software/rivet/include/Rivet/Tools/RivetYODA.hh Source File

| Rivet 3.1.9

RivetYODA.hh
1#ifndef RIVET_RIVETYODA_HH
2#define RIVET_RIVETYODA_HH
3
4#include "Rivet/Config/RivetCommon.hh"
5#include "YODA/AnalysisObject.h"
6#include "YODA/Counter.h"
7#include "YODA/Histo1D.h"
8#include "YODA/Histo2D.h"
9#include "YODA/Profile1D.h"
10#include "YODA/Profile2D.h"
11#include "YODA/Scatter1D.h"
12#include "YODA/Scatter2D.h"
13#include "YODA/Scatter3D.h"
14
15#include <map>
16#include <valarray>
17
18namespace YODA {
19
20 typedef std::shared_ptr<YODA::AnalysisObject> AnalysisObjectPtr;
21
22 typedef std::shared_ptr<YODA::Counter> CounterPtr;
23 typedef std::shared_ptr<YODA::Histo1D> Histo1DPtr;
24 typedef std::shared_ptr<YODA::Histo2D> Histo2DPtr;
25 typedef std::shared_ptr<YODA::Profile1D> Profile1DPtr;
26 typedef std::shared_ptr<YODA::Profile2D> Profile2DPtr;
27 typedef std::shared_ptr<YODA::Scatter1D> Scatter1DPtr;
28 typedef std::shared_ptr<YODA::Scatter2D> Scatter2DPtr;
29 typedef std::shared_ptr<YODA::Scatter3D> Scatter3DPtr;
30
31}
32
33
34namespace Rivet {
35
36
43
45 using Weight = double;
46
48 template <class T>
49 using Fill = pair<typename T::FillType, Weight>;
50
53 template <class T>
54 using Fills = multiset<Fill<T>>;
55
56
57
66 template <class T>
67 class TupleWrapper;
68
69
71 template <>
72 class TupleWrapper<YODA::Counter> : public YODA::Counter {
73 public:
74
76 typedef shared_ptr<TupleWrapper<YODA::Counter>> Ptr;
77
79 TupleWrapper(const YODA::Counter& h) : YODA::Counter(h) {}
80
84 void fill(double weight=1.0, double fraction=1.0) {
85 (void)fraction; //< ???
86 _fills.insert( { YODA::Counter::FillType(), weight } );
87 }
88
90 void reset() { _fills.clear(); }
91
93 const Fills<YODA::Counter>& fills() const { return _fills; }
94
96 using YODA::Counter::operator =;
97
98 private:
99
100 Fills<YODA::Counter> _fills;
101
102 };
103
104
106 template <>
107 class TupleWrapper<YODA::Histo1D> : public YODA::Histo1D {
108 public:
109
111 typedef shared_ptr<TupleWrapper<YODA::Histo1D>> Ptr;
112
114 TupleWrapper(const YODA::Histo1D& h) : YODA::Histo1D(h) {}
115
119 void fill( double x, double weight=1.0, double fraction=1.0 ) {
120 (void)fraction; //< ???
121 if ( std::isnan(x) ) throw YODA::RangeError("X is NaN"); //< efficient?
122 _fills.insert( { x, weight } );
123 }
124
126 void reset() { _fills.clear(); }
127
129 const Fills<YODA::Histo1D>& fills() const { return _fills; }
130
132 using YODA::Histo1D::operator =;
133
134 private:
135
136 Fills<YODA::Histo1D> _fills;
137
138 };
139
140
142 template <>
143 class TupleWrapper<YODA::Profile1D> : public YODA::Profile1D {
144 public:
145
147 typedef shared_ptr<TupleWrapper<YODA::Profile1D>> Ptr;
148
150 TupleWrapper(const YODA::Profile1D& h) : YODA::Profile1D(h) {}
151
155 void fill( double x, double y, double weight=1.0, double fraction=1.0 ) {
156 (void)fraction; //< ???
157 if ( std::isnan(x) ) throw YODA::RangeError("X is NaN"); //< efficient?
158 if ( std::isnan(y) ) throw YODA::RangeError("Y is NaN"); //< efficient?
159 _fills.insert( { YODA::Profile1D::FillType{x,y}, weight } );
160 }
161
163 void reset() { _fills.clear(); }
164
166 const Fills<YODA::Profile1D>& fills() const { return _fills; }
167
169 using YODA::Profile1D::operator =;
170
171 private:
172
173 Fills<YODA::Profile1D> _fills;
174
175 };
176
177
179 template <>
180 class TupleWrapper<YODA::Histo2D> : public YODA::Histo2D {
181 public:
182
184 typedef shared_ptr<TupleWrapper<YODA::Histo2D>> Ptr;
185
187 TupleWrapper(const YODA::Histo2D& h) : YODA::Histo2D(h) {}
188
192 void fill( double x, double y, double weight=1.0, double fraction=1.0 ) {
193 (void)fraction; //< ???
194 if ( std::isnan(x) ) throw YODA::RangeError("X is NaN"); //< efficient?
195 if ( std::isnan(y) ) throw YODA::RangeError("Y is NaN"); //< efficient?
196 _fills.insert( { YODA::Histo2D::FillType{x,y}, weight } );
197 }
198
200 void reset() { _fills.clear(); }
201
203 const Fills<YODA::Histo2D>& fills() const { return _fills; }
204
206 using YODA::Histo2D::operator =;
207
208 private:
209
210 Fills<YODA::Histo2D> _fills;
211
212 };
213
214
216 template <>
217 class TupleWrapper<YODA::Profile2D> : public YODA::Profile2D {
218 public:
219
221 typedef shared_ptr<TupleWrapper<YODA::Profile2D>> Ptr;
222
224 TupleWrapper(const YODA::Profile2D& h) : YODA::Profile2D(h) {}
225
229 void fill( double x, double y, double z, double weight=1.0, double fraction=1.0 ) {
230 (void)fraction; //< ???
231 if ( std::isnan(x) ) throw YODA::RangeError("X is NaN"); //< efficient?
232 if ( std::isnan(y) ) throw YODA::RangeError("Y is NaN"); //< efficient?
233 if ( std::isnan(z) ) throw YODA::RangeError("Z is NaN"); //< efficient?
234 _fills.insert( { YODA::Profile2D::FillType{x,y,z}, weight } );
235 }
236
238 void reset() { _fills.clear(); }
239
241 const Fills<YODA::Profile2D>& fills() const { return _fills; }
242
244 using YODA::Profile2D::operator =;
245
246 private:
247
248 Fills<YODA::Profile2D> _fills;
249
250 };
251
252
254 template <>
255 class TupleWrapper<YODA::Scatter1D> : public YODA::Scatter1D {
256 public:
257
259 typedef shared_ptr<TupleWrapper<YODA::Scatter1D>> Ptr;
260
262 TupleWrapper(const YODA::Scatter1D& h) : YODA::Scatter1D(h) {}
263
265 using YODA::Scatter1D::operator =;
266
267 };
268
269
271 template <>
272 class TupleWrapper<YODA::Scatter2D> : public YODA::Scatter2D {
273 public:
274
276 typedef shared_ptr<TupleWrapper<YODA::Scatter2D>> Ptr;
277
279 TupleWrapper(const YODA::Scatter2D& h) : YODA::Scatter2D(h) {}
280
282 using YODA::Scatter2D::operator =;
283
284 };
285
286
288 template <>
289 class TupleWrapper<YODA::Scatter3D> : public YODA::Scatter3D {
290 public:
291
293 typedef shared_ptr<TupleWrapper<YODA::Scatter3D>> Ptr;
294
296 TupleWrapper(const YODA::Scatter3D& h) : YODA::Scatter3D(h) {}
297
299 using YODA::Scatter3D::operator =;
300
301 };
302
304
305
306
307
308
318 class AnalysisObjectWrapper {
319 public:
320
321 virtual ~AnalysisObjectWrapper() {}
322
324 virtual YODA::AnalysisObject* operator -> () = 0;
326 virtual YODA::AnalysisObject* operator -> () const = 0;
328 virtual const YODA::AnalysisObject& operator * () const = 0;
329
331 virtual void setActiveWeightIdx(size_t iWeight) = 0;
332
334 virtual void setActiveFinalWeightIdx(size_t iWeight) = 0;
335
339 virtual void unsetActiveWeight() = 0;
340
342 bool operator == (const AnalysisObjectWrapper& p) { return (this == &p); }
344 bool operator != (const AnalysisObjectWrapper& p) { return (this != &p); }
345
346 };
347
348
349
353 /*
354 class Scatter1DPtr : public AnalysisObjectPtr {
355 public:
356 Scatter1DPtr() : _persistent() { }
357
358 Scatter1DPtr(size_t len_of_weightvec, const YODA::Scatter1D& p) {
359 for (size_t m = 0; m < len_of_weightvec; ++m)
360 _persistent.push_back(make_shared<YODA::Scatter1D>(p));
361 }
362
363 bool operator!() const { return !_persistent; }
364 explicit operator bool() const { return bool(_persistent); }
365
366 YODA::Scatter1D* operator->() { return _persistent.get(); }
367
368 YODA::Scatter1D* operator->() const { return _persistent.get(); }
369
370 YODA::Scatter1D & operator*() { return *_persistent; }
371
372 const YODA::Scatter1D & operator*() const { return *_persistent; }
373
374 protected:
375 vector<YODA::Scatter1DPtr> _persistent;
376 };
377
378 class Scatter2DPtr : public AnalysisObjectPtr {
379 public:
380 Scatter2DPtr(size_t len_of_weightvec, const YODA::Scatter2D& p) {
381 for (size_t m = 0; m < len_of_weightvec; ++m)
382 _persistent.push_back(make_shared<YODA::Scatter2D>(p));
383 }
384
385 Scatter2DPtr() : _persistent() { }
386
387 bool operator!() { return !_persistent; }
388 explicit operator bool() { return bool(_persistent); }
389
390 YODA::Scatter2D* operator->() { return _persistent.get(); }
391
392 YODA::Scatter2D* operator->() const { return _persistent.get(); }
393
394 YODA::Scatter2D & operator*() { return *_persistent; }
395
396 const YODA::Scatter2D & operator*() const { return *_persistent; }
397
398 protected:
399 vector<YODA::Scatter2DPtr> _persistent;
400 };
401
402 class Scatter3DPtr : public AnalysisObjectPtr {
403 public:
404 Scatter3DPtr(size_t len_of_weightvec, const YODA::Scatter3D& p) {
405 for (size_t m = 0; m < len_of_weightvec; ++m)
406 _persistent.push_back(make_shared<YODA::Scatter3D>(p));
407 }
408
409 Scatter3DPtr() : _persistent() { }
410
411 bool operator!() { return !_persistent; }
412 explicit operator bool() { return bool(_persistent); }
413
414 YODA::Scatter3D* operator->() { return _persistent.get(); }
415
416 YODA::Scatter3D* operator->() const { return _persistent.get(); }
417
418 YODA::Scatter3D & operator*() { return *_persistent; }
419
420 const YODA::Scatter3D & operator*() const { return *_persistent; }
421
422 protected:
423 vector<YODA::Scatter3DPtr> _persistent;
424 };
425 */
426
427
433 class MultiweightAOWrapper : public AnalysisObjectWrapper {
434 public:
435
437 using Inner = YODA::AnalysisObject;
438
440 virtual void newSubEvent() = 0;
441
443 virtual void pushToPersistent(const vector<std::valarray<double> >& weight, double nlowfrac=0.0) = 0;
444
446 virtual void pushToFinal() = 0;
447
449 virtual YODA::AnalysisObjectPtr activeYODAPtr() const = 0;
450
452 virtual string basePath() const = 0;
453
454 };
455
456
457
471 template <class T>
472 class Wrapper : public MultiweightAOWrapper {
473 public:
474
475 friend class Analysis;
476 friend class AnalysisHandler;
477
479 using Inner = T;
482 using TPtr = shared_ptr<T>;
483
484
485 Wrapper() = default;
486
487 Wrapper(const vector<string>& weightnames, const T& p);
488
489 ~Wrapper();
490
491
493 shared_ptr<T> active() const;
494
496 string basePath() const { return _basePath; }
497
499 string baseName() const { return _baseName; }
500
501
503 explicit operator bool() const { return static_cast<bool>(_active); } // Don't use active() here, assert will catch
504
506 bool operator ! () const { return !_active; } // Don't use active() here, assert will catch
507
508
510 T* operator -> () { return active().get(); }
511
513 T* operator -> () const { return active().get(); }
514
516 T& operator * () { return *active(); }
517
519 const T& operator * () const { return *active(); }
520
521
524 friend bool operator == (Wrapper a, Wrapper b){
525 if (a._persistent.size() != b._persistent.size())
526 return false;
527
528 for (size_t i = 0; i < a._persistent.size(); i++) {
529 if (a._persistent.at(i) != b._persistent.at(i)) {
530 return false;
531 }
532 }
533 return true;
534 }
535
537 friend bool operator != (Wrapper a, Wrapper b) {
538 return !(a == b);
539 }
540
542 friend bool operator < (Wrapper a, Wrapper b) {
543 if (a._persistent.size() >= b._persistent.size())
544 return false;
545 for (size_t i = 0; i < a._persistent.size(); i++) {
546 if (*(a._persistent.at(i)) >= *(b._persistent.at(i))) {
547 return false;
548 }
549 }
550 return true;
551 }
552
553
562 T* _getPersistent(size_t iWeight) { return _persistent.at(iWeight).get(); }
563
564
565
566 private:
567
580
582 void setActiveWeightIdx(size_t iWeight) {
583 _active = _persistent.at(iWeight);
584 }
585
587 void setActiveFinalWeightIdx(size_t iWeight) {
588 _active = _final.at(iWeight);
589 }
590
592 void unsetActiveWeight() { _active.reset(); }
593
595 void reset() { active()->reset(); }
596
597
602 void newSubEvent();
603
605 void pushToPersistent(const vector<std::valarray<double> >& weight, double nlowfrac=0.0);
606
608 void pushToFinal();
609
610
612 const vector<shared_ptr<T>>& persistent() const { return _persistent; }
613
615 const vector<shared_ptr<T>>& final() const { return _final; }
616
618 virtual YODA::AnalysisObjectPtr activeYODAPtr() const { return _active; }
619
621 // operator typename TPtr () { return _active; }
622
624
625
628
630 vector<shared_ptr<T>> _persistent;
631
633 vector<shared_ptr<T>> _final;
634
636 vector<shared_ptr<TupleWrapper<T>>> _evgroup;
637
639 shared_ptr<T> _active;
640
642 string _basePath;
643
645 string _baseName;
646
647 };
648
649
650
660 template <typename T>
661 class rivet_shared_ptr {
662 public:
663 typedef T value_type;
664
665 rivet_shared_ptr() = default;
666
667 rivet_shared_ptr(decltype(nullptr)) : _p(nullptr) {}
668
670 rivet_shared_ptr(const vector<string>& weightNames, const typename T::Inner& p)
671 : _p( make_shared<T>(weightNames, p) )
672 {}
673
675 template <typename U>
676 rivet_shared_ptr(const shared_ptr<U>& p)
677 : _p(p)
678 {}
679
681 template <typename U>
682 rivet_shared_ptr(const rivet_shared_ptr<U>& p)
683 : _p(p.get())
684 {}
685
687 T& operator -> () {
688 if (_p == nullptr) throw Error("Dereferencing null AnalysisObject pointer. Is there an unbooked histogram variable?");
689 return *_p;
690 }
691
693 const T& operator -> () const {
694 if (_p == nullptr) throw Error("Dereferencing null AnalysisObject pointer. Is there an unbooked histogram variable?");
695 return *_p;
696 }
697
699 typename T::Inner & operator * () { return **_p; }
700 const typename T::Inner & operator * () const { return **_p; }
701
703 explicit operator bool() const { return _p && bool(*_p); }
704
706 bool operator ! () const { return !_p || !(*_p); }
707
709 template <typename U>
710 bool operator == (const rivet_shared_ptr<U>& other) const {
711 return _p == other._p;
712 }
713
715 template <typename U>
716 bool operator != (const rivet_shared_ptr<U>& other) const {
717 return _p != other._p;
718 }
719
721 template <typename U>
722 bool operator < (const rivet_shared_ptr<U>& other) const {
723 return _p < other._p;
724 }
725
727 template <typename U>
728 bool operator > (const rivet_shared_ptr<U>& other) const {
729 return _p > other._p;
730 }
731
733 template <typename U>
734 bool operator <= (const rivet_shared_ptr<U> & other) const {
735 return _p <= other._p;
736 }
737
739 template <typename U>
740 bool operator >= (const rivet_shared_ptr<U> & other) const {
741 return _p >= other._p;
742 }
743
745 shared_ptr<T> get() const { return _p; }
746
747 private:
748
750 shared_ptr<T> _p;
751
752 };
753
754
761
762 using MultiweightAOPtr = rivet_shared_ptr<MultiweightAOWrapper>;
763
764 using Histo1DPtr = rivet_shared_ptr<Wrapper<YODA::Histo1D>>;
765 using Histo2DPtr = rivet_shared_ptr<Wrapper<YODA::Histo2D>>;
766 using Profile1DPtr = rivet_shared_ptr<Wrapper<YODA::Profile1D>>;
767 using Profile2DPtr = rivet_shared_ptr<Wrapper<YODA::Profile2D>>;
768 using CounterPtr = rivet_shared_ptr<Wrapper<YODA::Counter>>;
769 using Scatter1DPtr = rivet_shared_ptr<Wrapper<YODA::Scatter1D>>;
770 using Scatter2DPtr = rivet_shared_ptr<Wrapper<YODA::Scatter2D>>;
771 using Scatter3DPtr = rivet_shared_ptr<Wrapper<YODA::Scatter3D>>;
772
773 using YODA::Counter;
774 using YODA::Histo1D;
775 using YODA::HistoBin1D;
776 using YODA::Histo2D;
777 using YODA::HistoBin2D;
778 using YODA::Profile1D;
779 using YODA::ProfileBin1D;
780 using YODA::Profile2D;
781 using YODA::ProfileBin2D;
782 using YODA::Scatter1D;
783 using YODA::Point1D;
784 using YODA::Scatter2D;
785 using YODA::Point2D;
786 using YODA::Scatter3D;
787 using YODA::Point3D;
788
790
791
792
793
794
797
798 inline bool isTmpPath(const std::string& path) {
799 return path.find("/TMP/") != string::npos || path.find("/_") != string::npos;
800 }
801
804 map<string, YODA::AnalysisObjectPtr> getRefData(const string& papername);
805
807
809 string getDatafilePath(const string& papername);
810
811
813 template<typename T> struct ReferenceTraits {};
814 template <> struct ReferenceTraits<Counter> { typedef Counter RefT; };
815 template <> struct ReferenceTraits<Scatter1D> { typedef Scatter1D RefT; };
816 template <> struct ReferenceTraits<Histo1D> { typedef Scatter2D RefT; };
817 template <> struct ReferenceTraits<Profile1D> { typedef Scatter2D RefT; };
818 template <> struct ReferenceTraits<Scatter2D> { typedef Scatter2D RefT; };
819 template <> struct ReferenceTraits<Histo2D> { typedef Scatter3D RefT; };
820 template <> struct ReferenceTraits<Profile2D> { typedef Scatter3D RefT; };
821 template <> struct ReferenceTraits<Scatter3D> { typedef Scatter3D RefT; };
822
826 template <typename T>
827 inline bool aocopy(YODA::AnalysisObjectPtr src, YODA::AnalysisObjectPtr dst) {
828 shared_ptr<T> tsrc = dynamic_pointer_cast<T>(src);
829 if ( !tsrc ) return false;
830 shared_ptr<T> tdst = dynamic_pointer_cast<T>(dst);
831 if ( !tdst ) return false;
832 *tdst = *tsrc;
833 return true;
834 }
835
840 template <typename T>
841 inline bool aocopy(YODA::AnalysisObjectPtr src, YODA::AnalysisObjectPtr dst, double scale) {
842 if (!aocopy<T>(src, dst)) return false;
843 dynamic_pointer_cast<T>(dst)->scaleW(scale);
844 return true;
845 }
846
850 template <typename T>
851 inline bool aoadd(YODA::AnalysisObjectPtr dst, YODA::AnalysisObjectPtr src, double scale) {
852 shared_ptr<T> tsrc = dynamic_pointer_cast<T>(src);
853 if ( !tsrc ) return false;
854 shared_ptr<T> tdst = dynamic_pointer_cast<T>(dst);
855 if ( !tdst ) return false;
856 tsrc->scaleW(scale); //< note semi-accidental modification of the input
857 try {
858 *tdst += *tsrc;
859 } catch (YODA::LogicError&) {
860 return false;
861 }
862 return true;
863 }
864
867 bool copyao(YODA::AnalysisObjectPtr src, YODA::AnalysisObjectPtr dst, double scale=1.0);
868
872 bool addaos(YODA::AnalysisObjectPtr dst, YODA::AnalysisObjectPtr src, double scale);
873
876 template <typename TPtr>
877 inline bool bookingCompatible(TPtr a, TPtr b) {
878 return a->sameBinning(*b);
879 }
880 inline bool bookingCompatible(CounterPtr, CounterPtr) {
881 return true;
882 }
883 inline bool bookingCompatible(Scatter1DPtr a, Scatter1DPtr b) {
884 return a->numPoints() == b->numPoints();
885 }
886 inline bool bookingCompatible(Scatter2DPtr a, Scatter2DPtr b) {
887 return a->numPoints() == b->numPoints();
888 }
889 inline bool bookingCompatible(Scatter3DPtr a, Scatter3DPtr b) {
890 return a->numPoints() == b->numPoints();
891 }
892 inline bool bookingCompatible(YODA::CounterPtr, YODA::CounterPtr) {
893 return true;
894 }
895 inline bool bookingCompatible(YODA::Scatter1DPtr a, YODA::Scatter1DPtr b) {
896 return a->numPoints() == b->numPoints();
897 }
898 inline bool bookingCompatible(YODA::Scatter2DPtr a, YODA::Scatter2DPtr b) {
899 return a->numPoints() == b->numPoints();
900 }
901 inline bool bookingCompatible(YODA::Scatter3DPtr a, YODA::Scatter3DPtr b) {
902 return a->numPoints() == b->numPoints();
903 }
904
906
907
908
910 class AOPath {
911 public:
912
914 AOPath(string fullpath)
915 : _valid(false), _path(fullpath), _raw(false), _tmp(false), _ref(false) {
916 _valid = init(fullpath);
917 }
918
920 string path() const { return _path; }
921
923 string analysis() const { return _analysis; }
924
926 string analysisWithOptions() const { return _analysis + _optionstring; }
927
929 string name() const { return _name; }
930
932 string weight() const { return _weight; }
933
935 string weightComponent() const {
936 if (_weight == "") return _weight;
937 return "[" + _weight + "]";
938 }
939
941 bool isRaw() const { return _raw; }
942
943 // Is This a temporary (filling) object?
944 bool isTmp() const { return _tmp; }
945
947 bool isRef() const { return _ref; }
948
950 string optionString() const { return _optionstring; }
951
953 bool hasOptions() const { return !_options.empty(); }
954
956 void removeOption(string opt) { _options.erase(opt); fixOptionString(); }
957
959 void setOption(string opt, string val) { _options[opt] = val; fixOptionString();}
960
962 bool hasOption(string opt) const { return _options.find(opt) != _options.end(); }
963
965 string getOption(string opt) const {
966 auto it = _options.find(opt);
967 if ( it != _options.end() ) return it->second;
968 return "";
969 }
970
972 void fixOptionString();
973
975 string mkPath() const;
976 string setPath() { return _path = mkPath(); }
977
979 void debug() const;
980
982 bool operator<(const AOPath & other) const {
983 return _path < other._path;
984 }
985
987 bool valid() const { return _valid; };
988 bool operator!() const { return !valid(); }
989
990 private:
991
993 bool init(string fullpath);
994 bool chopweight(string & fullpath);
995 bool chopoptions(string & anal);
996
997 bool _valid;
998 string _path;
999 string _analysis;
1000 string _optionstring;
1001 string _name;
1002 string _weight;
1003 bool _raw;
1004 bool _tmp;
1005 bool _ref;
1006 map<string,string> _options;
1007
1008 };
1009
1010}
1011
1012#endif
Rivet::getRefData
map< string, YODA::AnalysisObjectPtr > getRefData(const string &papername)
Rivet::addaos
bool addaos(YODA::AnalysisObjectPtr dst, YODA::AnalysisObjectPtr src, double scale)
Rivet::bookingCompatible
bool bookingCompatible(TPtr a, TPtr b)
Definition RivetYODA.hh:877
Rivet::aoadd
bool aoadd(YODA::AnalysisObjectPtr dst, YODA::AnalysisObjectPtr src, double scale)
Definition RivetYODA.hh:851
Rivet::getDatafilePath
string getDatafilePath(const string &papername)
Get the file system path to the reference file for this paper.
Rivet::aocopy
bool aocopy(YODA::AnalysisObjectPtr src, YODA::AnalysisObjectPtr dst)
Definition RivetYODA.hh:827
Rivet::copyao
bool copyao(YODA::AnalysisObjectPtr src, YODA::AnalysisObjectPtr dst, double scale=1.0)
Rivet::Weight
double Weight
Typedef for weights.
Definition RivetYODA.hh:45
Rivet::Fills
multiset< Fill< T > > Fills
Definition RivetYODA.hh:54
Rivet::Fill
pair< typename T::FillType, Weight > Fill
A single fill is a (FillType, Weight) pair.
Definition RivetYODA.hh:49
Rivet::Kin::p
double p(const ParticleBase &p)
Unbound function access to p.
Definition ParticleBaseUtils.hh:684
Rivet
Definition MC_Cent_pPb.hh:10
Rivet::operator!
Cut operator!(const Cut &cptr)
Logical NOT operation on a cut.