AnalysisHandler.hh

// -*- C++ -*-
#ifndef RIVET_RivetHandler_HH
#define RIVET_RivetHandler_HH

#include "Rivet/Config/RivetCommon.hh"
#include "Rivet/Particle.hh"
#include "Rivet/AnalysisLoader.hh"
#include "Rivet/Tools/RivetYODA.hh"

namespace Rivet {


  // Forward declaration and smart pointer for Analysis
  class Analysis;
  typedef std::shared_ptr<Analysis> AnaHandle;


  // Needed to make smart pointers compare equivalent in the STL set
  struct CmpAnaHandle {
    bool operator() (const AnaHandle& a, const AnaHandle& b) const {
      return a.get() < b.get();
    }
  };


  class AnalysisHandler {
  public:



    AnalysisHandler(const string& runname="");

    ~AnalysisHandler();



  private:

    Log& getLog() const;


  public:



    string runName() const { return _runname; }


    size_t numEvents() const { return _eventcounter.numEntries(); }

    double sumW() const { return _eventcounter.sumW(); }
    double sumW2() const { return _eventcounter.sumW2(); }

    double sumOfWeights() const { return sumW(); }

    void setSumOfWeights(const double& sum) {
      //_sumOfWeights = sum;
      throw Error("Can't set sum of weights independently, since it's now tracked by a Counter. "
                  "Please contact the Rivet authors if you need this.");
    }


    bool needCrossSection() const;
    bool hasCrossSection() const;

    double crossSection() const { return _xs; }

    AnalysisHandler& setCrossSection(double xs, double xserr=0);


    AnalysisHandler& setRunBeams(const ParticlePair& beams) {
      _beams = beams;
      MSG_DEBUG("Setting run beams = " << beams << " @ " << sqrtS()/GeV << " GeV");
      return *this;
    }

    const ParticlePair& beams() const { return _beams; }

    PdgIdPair beamIds() const;

    double sqrtS() const;

    void setIgnoreBeams(bool ignore=true);





    std::vector<std::string> analysisNames() const;

    const std::set<AnaHandle, CmpAnaHandle>& analyses() const {
      return _analyses;
    }

    const AnaHandle analysis(const std::string& analysisname) const;


    AnalysisHandler& addAnalysis(Analysis* analysis);

    AnalysisHandler& addAnalysis(const std::string& analysisname);

    AnalysisHandler& addAnalysis(const std::string& analysisname, std::map<string, string> pars);
    
    AnalysisHandler& addAnalyses(const std::vector<std::string>& analysisnames);


    AnalysisHandler& removeAnalysis(const std::string& analysisname);

    AnalysisHandler& removeAnalyses(const std::vector<std::string>& analysisnames);





    void init(const GenEvent& event);

    void analyze(const GenEvent& event);

    void analyze(const GenEvent* event);

    void finalize();





    void addData(const std::vector<AnalysisObjectPtr>& aos);

    void readData(const std::string& filename);

    std::vector<AnalysisObjectPtr> getData(bool includeorphans = false,
                                           bool includetmps = false) const;

    void writeData(const std::string& filename) const;

    void dump(string dumpfile, int period) {
      _dumpPeriod = period;
      _dumpFile = dumpfile;
    }

    void mergeYodas(const vector<string> & aofiles,
                    const vector<string> & delopts = vector<string>(),
                    bool equiv = false);

    void stripOptions(AnalysisObjectPtr ao,
                      const vector<string> & delopts) const;


  private:

    set<AnaHandle, CmpAnaHandle> _analyses;

    vector<AnalysisObjectPtr> _orphanedPreloads;

    vector<AnalysisObjectPtr> _finalizedAOs;



    std::string _runname;

    Counter _eventcounter;

    double _xs, _xserr;

    ParticlePair _beams;

    bool _initialised;

    bool _ignoreBeams;

    int _dumpPeriod;

    string _dumpFile;

    bool _dumping;



  private:

    AnalysisHandler& operator=(const AnalysisHandler&);

    AnalysisHandler(const AnalysisHandler&);

  };


}

#endif