/data/refman/pasoursint/CMSSW_5_3_0/src/GeneratorInterface/LHEInterface/interface/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 {
                XSec() : value(0.0), error(0.0) {}

                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;

    private:
        struct Counter {
                Counter() : n(0), sum(0.0), sum2(0.0) {}

                inline void add(double weight)
                {
                        n++;
                        sum += weight;
                        sum2 += weight * weight;
                }

                unsigned int    n;
                double          sum;
                double          sum2;
        };

        struct Process {
                int             process;
                unsigned int    heprupIndex;
                Counter         tried;
                Counter         selected;
                Counter         killed;
                Counter         accepted;
                Counter         acceptedBr;

                inline bool operator < (const Process &other) const
                { return process < other.process; }
                inline bool operator < (int process) const
                { return this->process < process; }
                inline bool operator == (int process) const
                { return this->process == process; }
        };

        void init();

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

} // namespace lhef

#ifdef UNDEF_XERCES_CPP_NAMESPACE_QUALIFIER
#       undef XERCES_CPP_NAMESPACE_QUALIFIER
#endif

#endif // GeneratorRunInfo_LHEInterface_LHERunInfo_h