RivetYODA.hh

#ifndef RIVET_RIVETYODA_HH
#define RIVET_RIVETYODA_HH

#include "Rivet/Config/RivetCommon.hh"
#include "YODA/AnalysisObject.h"
#include "YODA/Counter.h"
#include "YODA/Histo1D.h"
#include "YODA/Histo2D.h"
#include "YODA/Profile1D.h"
#include "YODA/Profile2D.h"
#include "YODA/Scatter1D.h"
#include "YODA/Scatter2D.h"
#include "YODA/Scatter3D.h"

namespace Rivet {

  typedef std::shared_ptr<YODA::AnalysisObject> AnalysisObjectPtr;
  typedef std::shared_ptr<YODA::Counter> CounterPtr;
  typedef std::shared_ptr<YODA::Histo1D> Histo1DPtr;
  typedef std::shared_ptr<YODA::Histo2D> Histo2DPtr;
  typedef std::shared_ptr<YODA::Profile1D> Profile1DPtr;
  typedef std::shared_ptr<YODA::Profile2D> Profile2DPtr;
  typedef std::shared_ptr<YODA::Scatter1D> Scatter1DPtr;
  typedef std::shared_ptr<YODA::Scatter2D> Scatter2DPtr;
  typedef std::shared_ptr<YODA::Scatter3D> Scatter3DPtr;

  using YODA::AnalysisObject;
  using YODA::Counter;
  using YODA::Histo1D;
  using YODA::HistoBin1D;
  using YODA::Histo2D;
  using YODA::HistoBin2D;
  using YODA::Profile1D;
  using YODA::ProfileBin1D;
  using YODA::Profile2D;
  using YODA::ProfileBin2D;
  using YODA::Scatter1D;
  using YODA::Point1D;
  using YODA::Scatter2D;
  using YODA::Point2D;
  using YODA::Scatter3D;
  using YODA::Point3D;


  map<string, AnalysisObjectPtr> getRefData(const string& papername);

  string getDatafilePath(const string& papername);


  template<typename T> struct ReferenceTraits {};
  template<> struct ReferenceTraits<Counter> { typedef Counter RefT; };
  template<> struct ReferenceTraits<Scatter1D> { typedef Scatter1D RefT; };
  template<> struct ReferenceTraits<Histo1D> { typedef Scatter2D RefT; };
  template<> struct ReferenceTraits<Profile1D> { typedef Scatter2D RefT; };
  template<> struct ReferenceTraits<Scatter2D> { typedef Scatter2D RefT; };
  template<> struct ReferenceTraits<Histo2D> { typedef Scatter3D RefT; };
  template<> struct ReferenceTraits<Profile2D> { typedef Scatter3D RefT; };
  template<> struct ReferenceTraits<Scatter3D> { typedef Scatter3D RefT; };


  template <typename T>
  inline bool aocopy(AnalysisObjectPtr src, AnalysisObjectPtr dst) {
    shared_ptr<T> tsrc = dynamic_pointer_cast<T>(src);
    if ( !tsrc ) return false;
    shared_ptr<T> tdst = dynamic_pointer_cast<T>(dst);
    if ( !tdst ) return false;
    *tdst = *tsrc;
    return true;
  }

  template <typename T>
  inline bool aoadd(AnalysisObjectPtr dst, AnalysisObjectPtr src, double scale) {
    shared_ptr<T> tsrc = dynamic_pointer_cast<T>(src);
    if ( !tsrc ) return false;
    shared_ptr<T> tdst = dynamic_pointer_cast<T>(dst);
    if ( !tdst ) return false;
    tsrc->scaleW(scale);
    *tdst += *tsrc;
    return true;
  }

  bool copyao(AnalysisObjectPtr src, AnalysisObjectPtr dst);

  bool addaos(AnalysisObjectPtr dst, AnalysisObjectPtr src, double scale);

  // inline bool bookingCompatible(CounterPtr, CounterPtr) {
  //   return true;
  // }
  template <typename TPtr>
  inline bool bookingCompatible(TPtr a, TPtr b) {
    return a->sameBinning(*b);
  }
  inline bool bookingCompatible(CounterPtr, CounterPtr) {
    return true;
  }
  inline bool bookingCompatible(Scatter1DPtr a, Scatter1DPtr b) {
    return a->numPoints() == b->numPoints();
  }
  inline bool bookingCompatible(Scatter2DPtr a, Scatter2DPtr b) {
    return a->numPoints() == b->numPoints();
  }
  inline bool bookingCompatible(Scatter3DPtr a, Scatter3DPtr b) {
    return a->numPoints() == b->numPoints();
  }

}

#endif