LHERunInfo.h

Go to the documentation of this file.

#ifndef GeneratorInterface_LHEInterface_LHERunInfo_h
#define GeneratorInterface_LHEInterface_LHERunInfo_h

#include <iostream>
#include <memory>
#include <vector>
#include <string>

#include "FWCore/ParameterSet/interface/ParameterSet.h"

#include "SimDataFormats/GeneratorProducts/interface/LesHouches.h"
#include "SimDataFormats/GeneratorProducts/interface/LHERunInfoProduct.h"

#ifndef XERCES_CPP_NAMESPACE_QUALIFIER
#   define UNDEF_XERCES_CPP_NAMESPACE_QUALIFIER
#   define XERCES_CPP_NAMESPACE_QUALIFIER dummy::
namespace dummy {
    class DOMNode;
    class DOMDocument;
}
#endif

namespace lhef {

class LHERunInfo {
    public:
    LHERunInfo(std::istream &in);
    LHERunInfo(const HEPRUP &heprup);
    LHERunInfo(const HEPRUP &heprup,
               const std::vector<LHERunInfoProduct::Header> &headers,
               const std::vector<std::string> &comments);
    LHERunInfo(const LHERunInfoProduct &product);
    ~LHERunInfo();

    class Header : public LHERunInfoProduct::Header {
        public:
        Header();
        Header(const std::string &tag);
        Header(const Header &orig);
        Header(const LHERunInfoProduct::Header &orig);
        ~Header();

#ifndef UNDEF_XERCES_CPP_NAMESPACE_QUALIFIER
        const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode
                            *getXMLNode() const;
#endif

        private:
        mutable XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument *xmlDoc;
    };

    const HEPRUP *getHEPRUP() const { return &heprup; } 

    bool operator == (const LHERunInfo &other) const;
    inline bool operator != (const LHERunInfo &other) const
    { return !(*this == other); }

    const std::vector<Header> &getHeaders() const { return headers; }
    const std::vector<std::string> &getComments() const { return comments; }

    std::vector<std::string> findHeader(const std::string &tag) const;

    void addHeader(const Header &header) { headers.push_back(header); }
    void addComment(const std::string &line) { comments.push_back(line); }

    enum CountMode {
        kTried = 0,
        kSelected,
        kKilled,
        kAccepted
    };

    struct XSec {
    public:
    XSec() : value_(0.0), error_(0.0) {}
    XSec(double v, double e): value_(v), error_(e){}
      double value(){return value_;}
      double error(){return error_;}
    private:
      double    value_;
      double    error_;
    };

    void count(int process, CountMode count, double eventWeight = 1.0,
               double brWeight = 1.0, double matchWeight = 1.0);
    XSec xsec() const;
    void statistics() const;

    std::pair<int, int> pdfSetTranslation() const;

    struct Counter {
    public:
    Counter() : n_(0), sum_(0.0), sum2_(0.0) {}
    Counter(unsigned int n1, double sum1, double sum21) 
    :n_(n1), sum_(sum1), sum2_(sum21) {}
      inline void add(double weight)
      {
        n_++;
        sum_ += weight;
        sum2_ += weight * weight;
      }
      unsigned int n() const {return n_;}
      double sum() const {return sum_;}
      double sum2() const {return sum2_;}
    private: 
      unsigned int  n_;
      double        sum_;
      double        sum2_;
    };

    struct Process {
    public:
    Process(): process_(-1), heprupIndex_(-1), nPassPos_(0), nPassNeg_(0), nTotalPos_(0), nTotalNeg_(0){}
    Process(int id): process_(id), heprupIndex_(-1), nPassPos_(0), nPassNeg_(0), nTotalPos_(0), nTotalNeg_(0){}
      // accessors
      int process() const {return process_;} 
      unsigned int heprupIndex() const {return heprupIndex_;}
          XSec  getLHEXSec() const {return lheXSec_;}

      unsigned int nPassPos() const {return nPassPos_;}
      unsigned int nPassNeg() const {return nPassNeg_;}
      unsigned int nTotalPos() const {return nTotalPos_;}
      unsigned int nTotalNeg() const {return nTotalNeg_;}

      Counter tried() const {return tried_;}
      Counter selected() const {return selected_;}
      Counter killed() const {return killed_;}
      Counter accepted() const {return accepted_;}
      Counter acceptedBr() const {return acceptedBr_;}          
      
      // setters
      void setProcess(int id) {process_ = id;}
      void setHepRupIndex(int id) {heprupIndex_ = id;}
          void setLHEXSec(double value, double error) {lheXSec_ = XSec(value,error);}

      void addNPassPos(unsigned int n=1) { nPassPos_ += n; }
      void addNPassNeg(unsigned int n=1) { nPassNeg_ += n; }
      void addNTotalPos(unsigned int n=1) { nTotalPos_ += n; }
      void addNTotalNeg(unsigned int n=1) { nTotalNeg_ += n; }

      void addTried(double w) {tried_.add(w);}
      void addSelected(double w) {selected_.add(w);}
      void addKilled(double w) {killed_.add(w);}
      void addAccepted(double w) {accepted_.add(w);}
      void addAcceptedBr(double w) {acceptedBr_.add(w);}            
      
    private:
      int               process_;
          XSec                  lheXSec_;
      unsigned int          heprupIndex_;
      unsigned int          nPassPos_;
      unsigned int          nPassNeg_;
      unsigned int          nTotalPos_;
      unsigned int          nTotalNeg_;
      Counter       tried_;
      Counter       selected_;
      Counter       killed_;
      Counter       accepted_;
      Counter       acceptedBr_;
    };
    
 private:
    void init();

    HEPRUP              heprup;
    std::vector<Process>        processes;
    std::vector<Header>     headers;
    std::vector<std::string>    comments;

 public:
    const std::vector<Process>& getLumiProcesses() const {return processesLumi;}
    const int getHEPIDWTUP() const {return heprup.IDWTUP;}
    void initLumi();
  private:
    std::vector<Process>        processesLumi;
};

} // namespace lhef

#ifdef UNDEF_XERCES_CPP_NAMESPACE_QUALIFIER
#   undef XERCES_CPP_NAMESPACE_QUALIFIER
#endif

#endif // GeneratorRunInfo_LHEInterface_LHERunInfo_h