1 #ifndef RIVET_RIVETYODA_HH 2 #define RIVET_RIVETYODA_HH 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" 20 typedef std::shared_ptr<YODA::AnalysisObject> AnalysisObjectPtr;
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;
37 class AnalysisObjectWrapper {
39 virtual ~AnalysisObjectWrapper() {}
41 virtual YODA::AnalysisObject* operator->() = 0;
42 virtual YODA::AnalysisObject* operator->()
const = 0;
43 virtual const YODA::AnalysisObject & operator*()
const = 0;
46 virtual void setActiveWeightIdx(
unsigned int iWeight) = 0;
49 virtual void setActiveFinalWeightIdx(
unsigned int iWeight) = 0;
51 virtual void unsetActiveWeight() = 0;
53 bool operator ==(
const AnalysisObjectWrapper& p) {
return (
this == &p); }
54 bool operator !=(
const AnalysisObjectWrapper& p) {
return (
this != &p); }
139 class MultiweightAOWrapper :
public AnalysisObjectWrapper {
142 using Inner = YODA::AnalysisObject;
144 virtual void newSubEvent() = 0;
146 virtual void pushToPersistent(
const vector<std::valarray<double> >& weight) = 0;
147 virtual void pushToFinal() = 0;
149 virtual YODA::AnalysisObjectPtr activeYODAPtr()
const = 0;
151 virtual string basePath()
const = 0;
155 using Weight = double;
158 using Fill = pair<typename T::FillType, Weight>;
161 using Fills = multiset<Fill<T>>;
175 class TupleWrapper<
YODA::Counter> :
public YODA::Counter {
177 typedef shared_ptr<TupleWrapper<YODA::Counter>> Ptr;
178 TupleWrapper(
const YODA::Counter & h) :
YODA::Counter(h) {}
180 void fill(
double weight=1.0,
double fraction=1.0 ) {
182 fills_.insert( {YODA::Counter::FillType(),weight} );
184 void reset() { fills_.clear(); }
185 const Fills<YODA::Counter> & fills()
const {
return fills_; }
188 Fills<YODA::Counter> fills_;
192 class TupleWrapper<
YODA::Histo1D> :
public YODA::Histo1D {
194 typedef shared_ptr<TupleWrapper<YODA::Histo1D>> Ptr;
195 TupleWrapper(
const YODA::Histo1D & h) :
YODA::Histo1D(h) {}
197 void fill(
double x,
double weight=1.0,
double fraction=1.0 ) {
199 if ( std::isnan(x) )
throw YODA::RangeError(
"X is NaN");
200 fills_.insert( { x , weight } );
202 void reset() { fills_.clear(); }
203 const Fills<YODA::Histo1D> & fills()
const {
return fills_; }
206 Fills<YODA::Histo1D> fills_;
210 class TupleWrapper<
YODA::Profile1D> :
public YODA::Profile1D {
212 typedef shared_ptr<TupleWrapper<YODA::Profile1D>> Ptr;
213 TupleWrapper(
const YODA::Profile1D & h) :
YODA::Profile1D(h) {}
215 void fill(
double x,
double y,
double weight=1.0,
double fraction=1.0 ) {
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 } );
221 void reset() { fills_.clear(); }
222 const Fills<YODA::Profile1D> & fills()
const {
return fills_; }
225 Fills<YODA::Profile1D> fills_;
230 class TupleWrapper<
YODA::Histo2D> :
public YODA::Histo2D {
232 typedef shared_ptr<TupleWrapper<YODA::Histo2D>> Ptr;
233 TupleWrapper(
const YODA::Histo2D & h) :
YODA::Histo2D(h) {}
235 void fill(
double x,
double y,
double weight=1.0,
double fraction=1.0 ) {
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 } );
241 void reset() { fills_.clear(); }
242 const Fills<YODA::Histo2D> & fills()
const {
return fills_; }
245 Fills<YODA::Histo2D> fills_;
249 class TupleWrapper<
YODA::Profile2D> :
public YODA::Profile2D {
251 typedef shared_ptr<TupleWrapper<YODA::Profile2D>> Ptr;
252 TupleWrapper(
const YODA::Profile2D & h) :
YODA::Profile2D(h) {}
254 void fill(
double x,
double y,
double z,
double weight=1.0,
double fraction=1.0 ) {
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 } );
261 void reset() { fills_.clear(); }
262 const Fills<YODA::Profile2D> & fills()
const {
return fills_; }
265 Fills<YODA::Profile2D> fills_;
269 class TupleWrapper<
YODA::Scatter1D> :
public YODA::Scatter1D {
271 typedef shared_ptr<TupleWrapper<YODA::Scatter1D>> Ptr;
272 TupleWrapper(
const YODA::Scatter1D & h) :
YODA::Scatter1D(h) {}
276 class TupleWrapper<
YODA::Scatter2D> :
public YODA::Scatter2D {
278 typedef shared_ptr<TupleWrapper<YODA::Scatter2D>> Ptr;
279 TupleWrapper(
const YODA::Scatter2D & h) :
YODA::Scatter2D(h) {}
283 class TupleWrapper<
YODA::Scatter3D> :
public YODA::Scatter3D {
285 typedef shared_ptr<TupleWrapper<YODA::Scatter3D>> Ptr;
286 TupleWrapper(
const YODA::Scatter3D & h) :
YODA::Scatter3D(h) {}
292 class Wrapper :
public MultiweightAOWrapper {
293 friend class Analysis;
306 Wrapper(
const vector<string>& weightnames,
const T & p);
310 typename T::Ptr active()
const;
313 bool operator!()
const {
return !_active; }
315 explicit operator bool()
const {
return static_cast<bool>(_active); }
317 T * operator->() {
return active().get(); }
319 T * operator->()
const {
return active().get(); }
321 T & operator*() {
return *active(); }
323 const T & operator*()
const {
return *active(); }
326 T * _getPersistent (
unsigned int iWeight) {
return _persistent.at(iWeight).get(); }
375 void setActiveWeightIdx(
unsigned int iWeight) {
376 _active = _persistent.at(iWeight);
379 void setActiveFinalWeightIdx(
unsigned int iWeight) {
380 _active = _final.at(iWeight);
385 void unsetActiveWeight() { _active.reset(); }
389 virtual YODA::AnalysisObjectPtr activeYODAPtr()
const {
return _active; }
391 const vector<typename T::Ptr> & persistent()
const {
return _persistent; }
393 const vector<typename T::Ptr> &
final()
const {
return _final; }
396 void pushToPersistent(
const vector<std::valarray<double> >& weight);
401 vector<typename T::Ptr> _persistent;
404 vector<typename T::Ptr> _final;
407 vector<typename TupleWrapper<T>::Ptr> _evgroup;
409 typename T::Ptr _active;
411 string basePath()
const {
return _basePath; }
420 friend class AnalysisHandler;
429 template <
typename T>
430 class rivet_shared_ptr {
432 typedef T value_type;
434 rivet_shared_ptr() =
default;
436 rivet_shared_ptr(decltype(
nullptr)) : _p(nullptr) {}
439 rivet_shared_ptr(
const vector<string>& weightNames,
const typename T::Inner & p)
440 : _p( make_shared<T>(weightNames, p) )
443 template <
typename U>
444 rivet_shared_ptr(
const shared_ptr<U> & p)
448 template <
typename U>
449 rivet_shared_ptr(
const rivet_shared_ptr<U> & p)
454 T & operator->() {
return *_p; }
455 const T & operator->()
const {
return *_p; }
458 typename T::Inner & operator*() {
return **_p; }
459 const typename T::Inner & operator*()
const {
return **_p; }
461 bool operator!()
const {
return !_p || !(*_p); }
462 explicit operator bool()
const {
return _p && bool(*_p); }
464 template <
typename U>
465 bool operator==(
const rivet_shared_ptr<U> & other)
const {
466 return _p == other._p;
469 template <
typename U>
470 bool operator!=(
const rivet_shared_ptr<U> & other)
const {
471 return _p != other._p;
474 template <
typename U>
475 bool operator<(const rivet_shared_ptr<U> & other)
const {
476 return _p < other._p;
479 template <
typename U>
480 bool operator>(
const rivet_shared_ptr<U> & other)
const {
481 return _p > other._p;
484 template <
typename U>
485 bool operator<=(const rivet_shared_ptr<U> & other)
const {
486 return _p <= other._p;
489 template <
typename U>
490 bool operator>=(
const rivet_shared_ptr<U> & other)
const {
491 return _p >= other._p;
494 shared_ptr<T>
get()
const {
return _p; }
506 using MultiweightAOPtr = rivet_shared_ptr<MultiweightAOWrapper>;
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>>;
519 using YODA::HistoBin1D;
521 using YODA::HistoBin2D;
522 using YODA::Profile1D;
523 using YODA::ProfileBin1D;
524 using YODA::Profile2D;
525 using YODA::ProfileBin2D;
526 using YODA::Scatter1D;
528 using YODA::Scatter2D;
530 using YODA::Scatter3D;
535 map<string, YODA::AnalysisObjectPtr>
getRefData(
const string& papername);
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; };
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;
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;
585 bool copyao(YODA::AnalysisObjectPtr src, YODA::AnalysisObjectPtr dst);
590 bool addaos(YODA::AnalysisObjectPtr dst, YODA::AnalysisObjectPtr src,
double scale);
594 template <
typename TPtr>
596 return a->sameBinning(*b);
602 return a->numPoints() == b->numPoints();
605 return a->numPoints() == b->numPoints();
608 return a->numPoints() == b->numPoints();
614 return a->numPoints() == b->numPoints();
617 return a->numPoints() == b->numPoints();
620 return a->numPoints() == b->numPoints();
629 AOPath(
string fullpath)
630 : _valid(
false), _path(fullpath), _raw(
false), _tmp(
false), _ref(
false) {
631 _valid = init(fullpath);
635 string path()
const {
return _path; }
638 string analysis()
const {
return _analysis; }
641 string analysisWithOptions()
const {
return _analysis + _optionstring; }
644 string name()
const {
return _name; }
647 string weight()
const {
return _weight; }
650 bool isRaw()
const {
return _raw; }
653 bool isTmp()
const {
return _tmp; }
656 bool isRef()
const {
return _ref; }
659 string optionString()
const {
return _optionstring; }
662 bool hasOptions()
const {
return !_options.empty(); }
665 void removeOption(
string opt) { _options.erase(opt); fixOptionString(); }
668 void setOption(
string opt,
string val) { _options[opt] = val; fixOptionString();}
671 bool hasOption(
string opt)
const {
return _options.find(opt) != _options.end(); }
674 string getOption(
string opt)
const {
675 auto it = _options.find(opt);
676 if ( it != _options.end() )
return it->second;
681 void fixOptionString();
684 string mkPath()
const;
685 string setPath() {
return _path = mkPath(); }
691 bool operator<(
const AOPath & other)
const {
692 return _path < other._path;
696 bool valid()
const {
return _valid; };
697 bool operator!()
const {
return !valid(); }
702 bool init(
string fullpath);
703 bool chopweight(
string & fullpath);
704 bool chopoptions(
string & anal);
709 string _optionstring;
715 map<string,string> _options;
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)