Rivet  3.1.0
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 
18 namespace 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 
34 namespace Rivet {
35 
36 
37  class AnalysisObjectWrapper {
38  public:
39  virtual ~AnalysisObjectWrapper() {}
40 
41  virtual YODA::AnalysisObject* operator->() = 0;
42  virtual YODA::AnalysisObject* operator->() const = 0;
43  virtual const YODA::AnalysisObject & operator*() const = 0;
44 
46  virtual void setActiveWeightIdx(unsigned int iWeight) = 0;
47 
49  virtual void setActiveFinalWeightIdx(unsigned int iWeight) = 0;
50 
51  virtual void unsetActiveWeight() = 0;
52 
53  bool operator ==(const AnalysisObjectWrapper& p) { return (this == &p); }
54  bool operator !=(const AnalysisObjectWrapper& p) { return (this != &p); }
55 
56  protected:
58  // virtual void reset() = 0;
59  };
60 
64  /*
65  class Scatter1DPtr : public AnalysisObjectPtr {
66  public:
67  Scatter1DPtr() : _persistent() { }
68 
69  Scatter1DPtr(size_t len_of_weightvec, const YODA::Scatter1D& p) {
70  for (size_t m = 0; m < len_of_weightvec; ++m)
71  _persistent.push_back(make_shared<YODA::Scatter1D>(p));
72  }
73 
74  bool operator!() const { return !_persistent; }
75  explicit operator bool() const { return bool(_persistent); }
76 
77  YODA::Scatter1D* operator->() { return _persistent.get(); }
78 
79  YODA::Scatter1D* operator->() const { return _persistent.get(); }
80 
81  YODA::Scatter1D & operator*() { return *_persistent; }
82 
83  const YODA::Scatter1D & operator*() const { return *_persistent; }
84 
85  protected:
86  vector<YODA::Scatter1DPtr> _persistent;
87  };
88 
89  class Scatter2DPtr : public AnalysisObjectPtr {
90  public:
91  Scatter2DPtr(size_t len_of_weightvec, const YODA::Scatter2D& p) {
92  for (size_t m = 0; m < len_of_weightvec; ++m)
93  _persistent.push_back(make_shared<YODA::Scatter2D>(p));
94  }
95 
96  Scatter2DPtr() : _persistent() { }
97 
98  bool operator!() { return !_persistent; }
99  explicit operator bool() { return bool(_persistent); }
100 
101  YODA::Scatter2D* operator->() { return _persistent.get(); }
102 
103  YODA::Scatter2D* operator->() const { return _persistent.get(); }
104 
105  YODA::Scatter2D & operator*() { return *_persistent; }
106 
107  const YODA::Scatter2D & operator*() const { return *_persistent; }
108 
109  protected:
110  vector<YODA::Scatter2DPtr> _persistent;
111  };
112 
113  class Scatter3DPtr : public AnalysisObjectPtr {
114  public:
115  Scatter3DPtr(size_t len_of_weightvec, const YODA::Scatter3D& p) {
116  for (size_t m = 0; m < len_of_weightvec; ++m)
117  _persistent.push_back(make_shared<YODA::Scatter3D>(p));
118  }
119 
120  Scatter3DPtr() : _persistent() { }
121 
122  bool operator!() { return !_persistent; }
123  explicit operator bool() { return bool(_persistent); }
124 
125  YODA::Scatter3D* operator->() { return _persistent.get(); }
126 
127  YODA::Scatter3D* operator->() const { return _persistent.get(); }
128 
129  YODA::Scatter3D & operator*() { return *_persistent; }
130 
131  const YODA::Scatter3D & operator*() const { return *_persistent; }
132 
133  protected:
134  vector<YODA::Scatter3DPtr> _persistent;
135  };
136  */
137 
138 
139  class MultiweightAOWrapper : public AnalysisObjectWrapper {
140 
141  public:
142  using Inner = YODA::AnalysisObject;
143 
144  virtual void newSubEvent() = 0;
145 
146  virtual void pushToPersistent(const vector<std::valarray<double> >& weight) = 0;
147  virtual void pushToFinal() = 0;
148 
149  virtual YODA::AnalysisObjectPtr activeYODAPtr() const = 0;
150 
151  virtual string basePath() const = 0;
152  };
153 
154 
155  using Weight = double;
156 
157  template <class T>
158  using Fill = pair<typename T::FillType, Weight>;
159 
160  template <class T>
161  using Fills = multiset<Fill<T>>;
162 
163 
164  // TODO TODO TODO
165  // need to override the old fill method too!
166  // otherwise we can't intercept existing fill calls in analysis code
167  // TODO TODO TODO
168 
169 
171  template <class T>
172  class TupleWrapper;
173 
174  template<>
175  class TupleWrapper<YODA::Counter> : public YODA::Counter {
176  public:
177  typedef shared_ptr<TupleWrapper<YODA::Counter>> Ptr;
178  TupleWrapper(const YODA::Counter & h) : YODA::Counter(h) {}
179  // todo: do we need to deal with users using fractions directly?
180  void fill( double weight=1.0, double fraction=1.0 ) {
181  (void)fraction;
182  fills_.insert( {YODA::Counter::FillType(),weight} );
183  }
184  void reset() { fills_.clear(); }
185  const Fills<YODA::Counter> & fills() const { return fills_; }
186  private:
187  // x / weight pairs
188  Fills<YODA::Counter> fills_;
189  };
190 
191  template<>
192  class TupleWrapper<YODA::Histo1D> : public YODA::Histo1D {
193  public:
194  typedef shared_ptr<TupleWrapper<YODA::Histo1D>> Ptr;
195  TupleWrapper(const YODA::Histo1D & h) : YODA::Histo1D(h) {}
196  // todo: do we need to deal with users using fractions directly?
197  void fill( double x, double weight=1.0, double fraction=1.0 ) {
198  (void)fraction;
199  if ( std::isnan(x) ) throw YODA::RangeError("X is NaN");
200  fills_.insert( { x , weight } );
201  }
202  void reset() { fills_.clear(); }
203  const Fills<YODA::Histo1D> & fills() const { return fills_; }
204  private:
205  // x / weight pairs
206  Fills<YODA::Histo1D> fills_;
207  };
208 
209  template<>
210  class TupleWrapper<YODA::Profile1D> : public YODA::Profile1D {
211  public:
212  typedef shared_ptr<TupleWrapper<YODA::Profile1D>> Ptr;
213  TupleWrapper(const YODA::Profile1D & h) : YODA::Profile1D(h) {}
214  // todo: do we need to deal with users using fractions directly?
215  void fill( double x, double y, double weight=1.0, double fraction=1.0 ) {
216  (void)fraction;
217  if ( std::isnan(x) ) throw YODA::RangeError("X is NaN");
218  if ( std::isnan(y) ) throw YODA::RangeError("Y is NaN");
219  fills_.insert( { YODA::Profile1D::FillType{x,y}, weight } );
220  }
221  void reset() { fills_.clear(); }
222  const Fills<YODA::Profile1D> & fills() const { return fills_; }
223  private:
224  // x / weight pairs
225  Fills<YODA::Profile1D> fills_;
226  };
227 
228 
229  template<>
230  class TupleWrapper<YODA::Histo2D> : public YODA::Histo2D {
231  public:
232  typedef shared_ptr<TupleWrapper<YODA::Histo2D>> Ptr;
233  TupleWrapper(const YODA::Histo2D & h) : YODA::Histo2D(h) {}
234  // todo: do we need to deal with users using fractions directly?
235  void fill( double x, double y, double weight=1.0, double fraction=1.0 ) {
236  (void)fraction;
237  if ( std::isnan(x) ) throw YODA::RangeError("X is NaN");
238  if ( std::isnan(y) ) throw YODA::RangeError("Y is NaN");
239  fills_.insert( { YODA::Histo2D::FillType{x,y}, weight } );
240  }
241  void reset() { fills_.clear(); }
242  const Fills<YODA::Histo2D> & fills() const { return fills_; }
243  private:
244  // x / weight pairs
245  Fills<YODA::Histo2D> fills_;
246  };
247 
248  template<>
249  class TupleWrapper<YODA::Profile2D> : public YODA::Profile2D {
250  public:
251  typedef shared_ptr<TupleWrapper<YODA::Profile2D>> Ptr;
252  TupleWrapper(const YODA::Profile2D & h) : YODA::Profile2D(h) {}
253  // todo: do we need to deal with users using fractions directly?
254  void fill( double x, double y, double z, double weight=1.0, double fraction=1.0 ) {
255  (void)fraction;
256  if ( std::isnan(x) ) throw YODA::RangeError("X is NaN");
257  if ( std::isnan(y) ) throw YODA::RangeError("Y is NaN");
258  if ( std::isnan(z) ) throw YODA::RangeError("Z is NaN");
259  fills_.insert( { YODA::Profile2D::FillType{x,y,z}, weight } );
260  }
261  void reset() { fills_.clear(); }
262  const Fills<YODA::Profile2D> & fills() const { return fills_; }
263  private:
264  // x / weight pairs
265  Fills<YODA::Profile2D> fills_;
266  };
267 
268  template<>
269  class TupleWrapper<YODA::Scatter1D> : public YODA::Scatter1D {
270  public:
271  typedef shared_ptr<TupleWrapper<YODA::Scatter1D>> Ptr;
272  TupleWrapper(const YODA::Scatter1D & h) : YODA::Scatter1D(h) {}
273  };
274 
275  template<>
276  class TupleWrapper<YODA::Scatter2D> : public YODA::Scatter2D {
277  public:
278  typedef shared_ptr<TupleWrapper<YODA::Scatter2D>> Ptr;
279  TupleWrapper(const YODA::Scatter2D & h) : YODA::Scatter2D(h) {}
280  };
281 
282  template<>
283  class TupleWrapper<YODA::Scatter3D> : public YODA::Scatter3D {
284  public:
285  typedef shared_ptr<TupleWrapper<YODA::Scatter3D>> Ptr;
286  TupleWrapper(const YODA::Scatter3D & h) : YODA::Scatter3D(h) {}
287  };
288 
289 
290 
291  template <class T>
292  class Wrapper : public MultiweightAOWrapper {
293  friend class Analysis;
294 
295  public:
296 
297  using Inner = T;
298  /* @todo
299  * some things are not really well-defined here
300  * for instance: fill() in the finalize() method and integral() in
301  * the analyze() method.
302  */
303 
304  Wrapper() = default;
305 
306  Wrapper(const vector<string>& weightnames, const T & p);
307 
308  ~Wrapper();
309 
310  typename T::Ptr active() const;
311 
312  /* @todo this probably need to loop over all? */
313  bool operator!() const { return !_active; } // Don't use active() here, assert will catch
314 
315  explicit operator bool() const { return static_cast<bool>(_active); } // Don't use active() here, assert will catch
316 
317  T * operator->() { return active().get(); }
318 
319  T * operator->() const { return active().get(); }
320 
321  T & operator*() { return *active(); }
322 
323  const T & operator*() const { return *active(); }
324 
325  // can be useful for weight analysis (see e.g. MC_WEIGHTS for use)
326  T * _getPersistent (unsigned int iWeight) { return _persistent.at(iWeight).get(); }
327 
328 
329  /* @todo
330  * these need to be re-thought out.
331 
332  void reset() { active()->reset(); }
333  */
334 
335  /* @todo
336  * these probably need to loop over all?
337  * do we even want to provide equality?
338  */
339  /* @todo
340  * how about no.
341  friend bool operator==(Wrapper a, Wrapper b){
342  if (a._persistent.size() != b._persistent.size())
343  return false;
344 
345  for (size_t i = 0; i < a._persistent.size(); i++) {
346  if (a._persistent.at(i) != b._persistent.at(i)) {
347  return false;
348  }
349  }
350 
351  return true;
352  }
353 
354  friend bool operator!=(Wrapper a, Wrapper b){
355  return !(a == b);
356  }
357 
358 
359  friend bool operator<(Wrapper a, Wrapper b){
360  if (a._persistent.size() >= b._persistent.size())
361  return false;
362 
363  for (size_t i = 0; i < a._persistent.size(); i++) {
364  if (*(a._persistent.at(i)) >= *(b._persistent.at(i))) {
365  return false;
366  }
367  }
368 
369  return true;
370  }
371  */
372 
373 
374  private:
375  void setActiveWeightIdx(unsigned int iWeight) {
376  _active = _persistent.at(iWeight);
377  }
378 
379  void setActiveFinalWeightIdx(unsigned int iWeight) {
380  _active = _final.at(iWeight);
381  }
382 
383 
384  /* this is for dev only---we shouldn't need this in real runs. */
385  void unsetActiveWeight() { _active.reset(); }
386 
387  void newSubEvent();
388 
389  virtual YODA::AnalysisObjectPtr activeYODAPtr() const { return _active; }
390 
391  const vector<typename T::Ptr> & persistent() const { return _persistent; }
392 
393  const vector<typename T::Ptr> & final() const { return _final; }
394 
395  /* to be implemented for each type */
396  void pushToPersistent(const vector<std::valarray<double> >& weight);
397  void pushToFinal();
398 
399 
400  /* M of these, one for each weight */
401  vector<typename T::Ptr> _persistent;
402 
403  /* This is the copy of _persistent that will be passed to finalize(). */
404  vector<typename T::Ptr> _final;
405 
406  /* N of these, one for each event in evgroup */
407  vector<typename TupleWrapper<T>::Ptr> _evgroup;
408 
409  typename T::Ptr _active;
410 
411  string basePath() const { return _basePath; }
412 
413  string _basePath;
414 
415  // do we need implicit cast?
416  // operator typename T::Ptr () {
417  // return _active;
418  // }
419 
420  friend class AnalysisHandler;
421  };
422 
423 
429  template <typename T>
430  class rivet_shared_ptr {
431  public:
432  typedef T value_type;
433 
434  rivet_shared_ptr() = default;
435 
436  rivet_shared_ptr(decltype(nullptr)) : _p(nullptr) {}
437 
439  rivet_shared_ptr(const vector<string>& weightNames, const typename T::Inner & p)
440  : _p( make_shared<T>(weightNames, p) )
441  {}
442 
443  template <typename U>
444  rivet_shared_ptr(const shared_ptr<U> & p)
445  : _p(p)
446  {}
447 
448  template <typename U>
449  rivet_shared_ptr(const rivet_shared_ptr<U> & p)
450  : _p(p.get())
451  {}
452 
453  // Goes right through to the active Wrapper<YODA> object's members
454  T & operator->() { return *_p; }
455  const T & operator->() const { return *_p; }
456 
457  // The active YODA object
458  typename T::Inner & operator*() { return **_p; }
459  const typename T::Inner & operator*() const { return **_p; }
460 
461  bool operator!() const { return !_p || !(*_p); }
462  explicit operator bool() const { return _p && bool(*_p); }
463 
464  template <typename U>
465  bool operator==(const rivet_shared_ptr<U> & other) const {
466  return _p == other._p;
467  }
468 
469  template <typename U>
470  bool operator!=(const rivet_shared_ptr<U> & other) const {
471  return _p != other._p;
472  }
473 
474  template <typename U>
475  bool operator<(const rivet_shared_ptr<U> & other) const {
476  return _p < other._p;
477  }
478 
479  template <typename U>
480  bool operator>(const rivet_shared_ptr<U> & other) const {
481  return _p > other._p;
482  }
483 
484  template <typename U>
485  bool operator<=(const rivet_shared_ptr<U> & other) const {
486  return _p <= other._p;
487  }
488 
489  template <typename U>
490  bool operator>=(const rivet_shared_ptr<U> & other) const {
491  return _p >= other._p;
492  }
493 
494  shared_ptr<T> get() const { return _p; }
495 
496  private:
497  shared_ptr<T> _p;
498 
499  };
500 
501 
502 
503  // every object listed here needs a virtual fill method in YODA,
504  // otherwise the Tuple fakery won't work.
505 
506  using MultiweightAOPtr = rivet_shared_ptr<MultiweightAOWrapper>;
507 
508  using Histo1DPtr = rivet_shared_ptr<Wrapper<YODA::Histo1D>>;
509  using Histo2DPtr = rivet_shared_ptr<Wrapper<YODA::Histo2D>>;
510  using Profile1DPtr = rivet_shared_ptr<Wrapper<YODA::Profile1D>>;
511  using Profile2DPtr = rivet_shared_ptr<Wrapper<YODA::Profile2D>>;
512  using CounterPtr = rivet_shared_ptr<Wrapper<YODA::Counter>>;
513  using Scatter1DPtr = rivet_shared_ptr<Wrapper<YODA::Scatter1D>>;
514  using Scatter2DPtr = rivet_shared_ptr<Wrapper<YODA::Scatter2D>>;
515  using Scatter3DPtr = rivet_shared_ptr<Wrapper<YODA::Scatter3D>>;
516 
517  using YODA::Counter;
518  using YODA::Histo1D;
519  using YODA::HistoBin1D;
520  using YODA::Histo2D;
521  using YODA::HistoBin2D;
522  using YODA::Profile1D;
523  using YODA::ProfileBin1D;
524  using YODA::Profile2D;
525  using YODA::ProfileBin2D;
526  using YODA::Scatter1D;
527  using YODA::Point1D;
528  using YODA::Scatter2D;
529  using YODA::Point2D;
530  using YODA::Scatter3D;
531  using YODA::Point3D;
532 
535  map<string, YODA::AnalysisObjectPtr> getRefData(const string& papername);
536 
538 
540  string getDatafilePath(const string& papername);
541 
542 
545  template<typename T> struct ReferenceTraits {};
546  template<> struct ReferenceTraits<Counter> { typedef Counter RefT; };
547  template<> struct ReferenceTraits<Scatter1D> { typedef Scatter1D RefT; };
548  template<> struct ReferenceTraits<Histo1D> { typedef Scatter2D RefT; };
549  template<> struct ReferenceTraits<Profile1D> { typedef Scatter2D RefT; };
550  template<> struct ReferenceTraits<Scatter2D> { typedef Scatter2D RefT; };
551  template<> struct ReferenceTraits<Histo2D> { typedef Scatter3D RefT; };
552  template<> struct ReferenceTraits<Profile2D> { typedef Scatter3D RefT; };
553  template<> struct ReferenceTraits<Scatter3D> { typedef Scatter3D RefT; };
554 
555 
559  template <typename T>
560  inline bool aocopy(YODA::AnalysisObjectPtr src, YODA::AnalysisObjectPtr dst) {
561  shared_ptr<T> tsrc = dynamic_pointer_cast<T>(src);
562  if ( !tsrc ) return false;
563  shared_ptr<T> tdst = dynamic_pointer_cast<T>(dst);
564  if ( !tdst ) return false;
565  *tdst = *tsrc;
566  return true;
567  }
568 
572  template <typename T>
573  inline bool aoadd(YODA::AnalysisObjectPtr dst, YODA::AnalysisObjectPtr src, double scale) {
574  shared_ptr<T> tsrc = dynamic_pointer_cast<T>(src);
575  if ( !tsrc ) return false;
576  shared_ptr<T> tdst = dynamic_pointer_cast<T>(dst);
577  if ( !tdst ) return false;
578  tsrc->scaleW(scale);
579  *tdst += *tsrc;
580  return true;
581  }
582 
585  bool copyao(YODA::AnalysisObjectPtr src, YODA::AnalysisObjectPtr dst);
586 
590  bool addaos(YODA::AnalysisObjectPtr dst, YODA::AnalysisObjectPtr src, double scale);
591 
594  template <typename TPtr>
595  inline bool bookingCompatible(TPtr a, TPtr b) {
596  return a->sameBinning(*b);
597  }
598  inline bool bookingCompatible(CounterPtr, CounterPtr) {
599  return true;
600  }
601  inline bool bookingCompatible(Scatter1DPtr a, Scatter1DPtr b) {
602  return a->numPoints() == b->numPoints();
603  }
604  inline bool bookingCompatible(Scatter2DPtr a, Scatter2DPtr b) {
605  return a->numPoints() == b->numPoints();
606  }
607  inline bool bookingCompatible(Scatter3DPtr a, Scatter3DPtr b) {
608  return a->numPoints() == b->numPoints();
609  }
610  inline bool bookingCompatible(YODA::CounterPtr, YODA::CounterPtr) {
611  return true;
612  }
613  inline bool bookingCompatible(YODA::Scatter1DPtr a, YODA::Scatter1DPtr b) {
614  return a->numPoints() == b->numPoints();
615  }
616  inline bool bookingCompatible(YODA::Scatter2DPtr a, YODA::Scatter2DPtr b) {
617  return a->numPoints() == b->numPoints();
618  }
619  inline bool bookingCompatible(YODA::Scatter3DPtr a, YODA::Scatter3DPtr b) {
620  return a->numPoints() == b->numPoints();
621  }
622 
624 class AOPath {
625 
626  public:
627 
629  AOPath(string fullpath)
630  : _valid(false), _path(fullpath), _raw(false), _tmp(false), _ref(false) {
631  _valid = init(fullpath);
632  }
633 
635  string path() const { return _path; }
636 
638  string analysis() const { return _analysis; }
639 
641  string analysisWithOptions() const { return _analysis + _optionstring; }
642 
644  string name() const { return _name; }
645 
647  string weight() const { return _weight; }
648 
650  bool isRaw() const { return _raw; }
651 
652  // Is This a temporary (filling) object?
653  bool isTmp() const { return _tmp; }
654 
656  bool isRef() const { return _ref; }
657 
659  string optionString() const { return _optionstring; }
660 
662  bool hasOptions() const { return !_options.empty(); }
663 
665  void removeOption(string opt) { _options.erase(opt); fixOptionString(); }
666 
668  void setOption(string opt, string val) { _options[opt] = val; fixOptionString();}
669 
671  bool hasOption(string opt) const { return _options.find(opt) != _options.end(); }
672 
674  string getOption(string opt) const {
675  auto it = _options.find(opt);
676  if ( it != _options.end() ) return it->second;
677  return "";
678  }
679 
681  void fixOptionString();
682 
684  string mkPath() const;
685  string setPath() { return _path = mkPath(); }
686 
688  void debug() const;
689 
691  bool operator<(const AOPath & other) const {
692  return _path < other._path;
693  }
694 
696  bool valid() const { return _valid; };
697  bool operator!() const { return !valid(); }
698 
699  private:
700 
702  bool init(string fullpath);
703  bool chopweight(string & fullpath);
704  bool chopoptions(string & anal);
705 
706  bool _valid;
707  string _path;
708  string _analysis;
709  string _optionstring;
710  string _name;
711  string _weight;
712  bool _raw;
713  bool _tmp;
714  bool _ref;
715  map<string,string> _options;
716 
717  };
718 
719 }
720 
721 #endif
Definition: MC_Cent_pPb.hh:10
bool bookingCompatible(TPtr a, TPtr b)
Definition: RivetYODA.hh:595
bool operator==(const Cut &a, const Cut &b)
Compare two cuts for equality, forwards to the cut-specific implementation.
Definition: Cuts.hh:41
map< string, YODA::AnalysisObjectPtr > getRefData(const string &papername)
string getDatafilePath(const string &papername)
Get the file system path to the reference file for this paper.
bool addaos(YODA::AnalysisObjectPtr dst, YODA::AnalysisObjectPtr src, double scale)
Definition: RivetYODA.hh:18
bool aoadd(YODA::AnalysisObjectPtr dst, YODA::AnalysisObjectPtr src, double scale)
Definition: RivetYODA.hh:573
bool aocopy(YODA::AnalysisObjectPtr src, YODA::AnalysisObjectPtr dst)
Definition: RivetYODA.hh:560
BoolJetNOT operator!(const JetSelector &a)
Operator syntactic sugar for NOT construction.
Definition: JetUtils.hh:97
bool copyao(YODA::AnalysisObjectPtr src, YODA::AnalysisObjectPtr dst)