---

LHERunInfo.cc

Go to the documentation of this file.

#include <algorithm>
#include <iostream>
#include <iomanip>
#include <string>
#include <cctype>
#include <vector>
#include <memory>
#include <cmath>

#include <boost/bind.hpp>

#include <xercesc/dom/DOM.hpp>
#include <xercesc/parsers/XercesDOMParser.hpp>
#include <xercesc/sax/HandlerBase.hpp>

#include "FWCore/Utilities/interface/Exception.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"

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

#include "GeneratorInterface/LHEInterface/interface/LHERunInfo.h"

#include "XMLUtils.h"

XERCES_CPP_NAMESPACE_USE

static int skipWhitespace(std::istream &in)
{
        int ch;
        do {
                ch = in.get();
        } while(std::isspace(ch));
        if (ch != std::istream::traits_type::eof())
                in.putback(ch);
        return ch;
}

namespace lhef {

LHERunInfo::LHERunInfo(std::istream &in)
{
        in >> heprup.IDBMUP.first >> heprup.IDBMUP.second
           >> heprup.EBMUP.first >> heprup.EBMUP.second
           >> heprup.PDFGUP.first >> heprup.PDFGUP.second
           >> heprup.PDFSUP.first >> heprup.PDFSUP.second
           >> heprup.IDWTUP >> heprup.NPRUP;
        if (!in.good())
                throw cms::Exception("InvalidFormat")
                        << "Les Houches file contained invalid"
                           " header in init section." << std::endl;

        heprup.resize();

        for(int i = 0; i < heprup.NPRUP; i++) {
                in >> heprup.XSECUP[i] >> heprup.XERRUP[i]
                   >> heprup.XMAXUP[i] >> heprup.LPRUP[i];
                if (!in.good())
                        throw cms::Exception("InvalidFormat")
                                << "Les Houches file contained invalid data"
                                   " in header payload line " << (i + 1)
                                << "." << std::endl;
        }

        while(skipWhitespace(in) == '#') {
                std::string line;
                std::getline(in, line);
                comments.push_back(line + "\n");
        }

        if (!in.eof())
                edm::LogWarning("Generator|LHEInterface")
                        << "Les Houches file contained spurious"
                           " content after the regular data." << std::endl;

        init();
}

LHERunInfo::LHERunInfo(const HEPRUP &heprup) :
        heprup(heprup)
{
        init();
}

LHERunInfo::LHERunInfo(const HEPRUP &heprup,
                       const std::vector<LHERunInfoProduct::Header> &headers,  
                       const std::vector<std::string> &comments) :
        heprup(heprup)
{
        std::copy(headers.begin(), headers.end(),
                  std::back_inserter(this->headers));
        std::copy(comments.begin(), comments.end(),
                  std::back_inserter(this->comments));

        init();
}
                                                      
LHERunInfo::LHERunInfo(const LHERunInfoProduct &product) :
        heprup(product.heprup())
{
        std::copy(product.headers_begin(), product.headers_end(),
                  std::back_inserter(headers));
        std::copy(product.comments_begin(), product.comments_end(),
                  std::back_inserter(comments));

        init();
}
                                                      
LHERunInfo::~LHERunInfo()
{
}

void LHERunInfo::init()
{
        for(int i = 0; i < heprup.NPRUP; i++) {
                Process proc;

                proc.process = heprup.LPRUP[i];
                proc.heprupIndex = (unsigned int)i;

                processes.push_back(proc);
        }

        std::sort(processes.begin(), processes.end());
}

bool LHERunInfo::operator == (const LHERunInfo &other) const
{
        return heprup == other.heprup;
}

void LHERunInfo::count(int process, CountMode mode, double eventWeight,
                       double brWeight, double matchWeight)
{
        std::vector<Process>::iterator proc =
                std::lower_bound(processes.begin(), processes.end(), process);
        if (proc == processes.end() || proc->process != process)
                return;

        switch(mode) {
            case kAccepted:
                proc->acceptedBr.add(eventWeight * brWeight * matchWeight);
                proc->accepted.add(eventWeight * matchWeight);
            case kKilled:
                proc->killed.add(eventWeight * matchWeight);
            case kSelected:
                proc->selected.add(eventWeight);
            case kTried:
                proc->tried.add(eventWeight);
        }
}

LHERunInfo::XSec LHERunInfo::xsec() const
{
        double sigSelSum = 0.0;
        double sigSum = 0.0;
        double sigBrSum = 0.0;
        double err2Sum = 0.0;
        double errBr2Sum = 0.0;

        for(std::vector<Process>::const_iterator proc = processes.begin();
            proc != processes.end(); ++proc) {
                unsigned int idx = proc->heprupIndex;

                double sigmaSum, sigma2Sum, sigma2Err;
                if (std::abs(heprup.IDWTUP) == 3) {
                        sigmaSum = proc->tried.n * heprup.XSECUP[idx];
                        sigma2Sum = sigmaSum * heprup.XSECUP[idx];
                        sigma2Err = proc->tried.n * heprup.XERRUP[idx]
                                                  * heprup.XERRUP[idx];
                } else {
                        sigmaSum = proc->tried.sum;
                        sigma2Sum = proc->tried.sum2;
                        sigma2Err = 0.0;
                }

                if (!proc->killed.n)
                        continue;

                double sigmaAvg = sigmaSum / proc->tried.sum;
                double fracAcc = proc->killed.sum / proc->selected.sum;
                double fracBr = proc->accepted.sum > 0.0 ?
                                proc->acceptedBr.sum / proc->accepted.sum : 1;
                double sigmaFin = sigmaAvg * fracAcc * fracBr;
                double sigmaFinBr = sigmaFin * fracBr;

                double relErr = 1.0;
                if (proc->killed.n > 1) {
                        double sigmaAvg2 = sigmaAvg * sigmaAvg;
                        double delta2Sig =
                                (sigma2Sum / proc->tried.n - sigmaAvg2) /
                                (proc->tried.n * sigmaAvg2);
                        double delta2Veto =
                                ((double)proc->selected.n - proc->killed.n) /
                                ((double)proc->selected.n * proc->killed.n);
                        double delta2Sum = delta2Sig + delta2Veto
                                           + sigma2Err / sigma2Sum;
                        relErr = (delta2Sum > 0.0 ?
                                        std::sqrt(delta2Sum) : 0.0);
                }
                double deltaFin = sigmaFin * relErr;
                double deltaFinBr = sigmaFinBr * relErr;

                sigSelSum += sigmaAvg;
                sigSum += sigmaFin;
                sigBrSum += sigmaFinBr;
                err2Sum += deltaFin * deltaFin;
                errBr2Sum += deltaFinBr * deltaFinBr;
        }

        XSec result;
        result.value = 1.0e-9 * sigBrSum;
        result.error = 1.0e-9 * std::sqrt(errBr2Sum);

        return result;
}

void LHERunInfo::statistics() const
{
        double sigSelSum = 0.0;
        double sigSum = 0.0;
        double sigBrSum = 0.0;
        double err2Sum = 0.0;
        double errBr2Sum = 0.0;
        unsigned long nAccepted = 0;
        unsigned long nTried = 0;

        std::cout << std::endl;
        std::cout << "Process and cross-section statistics" << std::endl;
        std::cout << "------------------------------------" << std::endl;
        std::cout << "Process\tevents\ttried\txsec [pb]\t\taccepted [%]"
                  << std::endl;

        for(std::vector<Process>::const_iterator proc = processes.begin();
            proc != processes.end(); ++proc) {
                unsigned int idx = proc->heprupIndex;

                double sigmaSum, sigma2Sum, sigma2Err;
                if (std::abs(heprup.IDWTUP) == 3) {
                        sigmaSum = proc->tried.n * heprup.XSECUP[idx];
                        sigma2Sum = sigmaSum * heprup.XSECUP[idx];
                        sigma2Err = proc->tried.n * heprup.XERRUP[idx]
                                                  * heprup.XERRUP[idx];
                } else {
                        sigmaSum = proc->tried.sum;
                        sigma2Sum = proc->tried.sum2;
                        sigma2Err = 0.0;
                }

                if (!proc->selected.n) {
                        std::cout << proc->process << "\t0\t0\tn/a\t\t\tn/a"
                                  << std::endl;
                        continue;
                }

                double sigmaAvg = sigmaSum / proc->tried.sum;
                double fracAcc = proc->killed.sum / proc->selected.sum;
                double fracBr = proc->accepted.sum > 0.0 ?
                                proc->acceptedBr.sum / proc->accepted.sum : 1;
                double sigmaFin = sigmaAvg * fracAcc;
                double sigmaFinBr = sigmaFin * fracBr;

                double relErr = 1.0;
                if (proc->killed.n > 1) {
                        double sigmaAvg2 = sigmaAvg * sigmaAvg;
                        double delta2Sig =
                                (sigma2Sum / proc->tried.n - sigmaAvg2) /
                                (proc->tried.n * sigmaAvg2);
                        double delta2Veto =
                                ((double)proc->selected.n - proc->killed.n) /
                                ((double)proc->selected.n * proc->killed.n);
                        double delta2Sum = delta2Sig + delta2Veto
                                           + sigma2Err / sigma2Sum;
                        relErr = (delta2Sum > 0.0 ?
                                        std::sqrt(delta2Sum) : 0.0);
                }
                double deltaFin = sigmaFin * relErr;
                double deltaFinBr = sigmaFinBr * relErr;

                std::cout << proc->process << "\t"
                          << proc->accepted.n << "\t"
                          << proc->tried.n << "\t"
                          << std::scientific << std::setprecision(3)
                          << sigmaFinBr << " +/- "
                          << deltaFinBr << "\t"
                          << std::fixed << std::setprecision(1)
                          << (fracAcc * 100) << std::endl;

                nAccepted += proc->accepted.n;
                nTried += proc->tried.n;
                sigSelSum += sigmaAvg;
                sigSum += sigmaFin;
                sigBrSum += sigmaFinBr;
                err2Sum += deltaFin * deltaFin;
                errBr2Sum += deltaFinBr * deltaFinBr;
        }

        std::cout << "Total\t"
                  << nAccepted << "\t"
                  << nTried << "\t"
                  << std::scientific << std::setprecision(3)
                  << sigBrSum << " +/- "
                  << std::sqrt(errBr2Sum) << "\t"
                  << std::fixed << std::setprecision(1)
                  << (sigSum / sigSelSum * 100) << std::endl;
}

LHERunInfo::Header::Header() :
        xmlDoc(0)
{
}

LHERunInfo::Header::Header(const std::string &tag) :
        LHERunInfoProduct::Header(tag), xmlDoc(0)
{
}

LHERunInfo::Header::Header(const Header &orig) :
        LHERunInfoProduct::Header(orig), xmlDoc(0)
{
}

LHERunInfo::Header::Header(const LHERunInfoProduct::Header &orig) :
        LHERunInfoProduct::Header(orig), xmlDoc(0)
{
}

LHERunInfo::Header::~Header()
{
        if (xmlDoc)
                xmlDoc->release();
}

static void fillLines(std::vector<std::string> &lines, const char *data,
                      int len = -1)
{
        const char *end = len >= 0 ? (data + len) : 0;
        while(*data && (!end || data < end)) {
                std::size_t len = std::strcspn(data, "\r\n");
                if (end && data + len > end)
                        len = end - data;
                if (data[len] == '\r' && data[len + 1] == '\n')
                        len += 2;
                else if (data[len])
                        len++;
                lines.push_back(std::string(data, len));
                data += len;
        }
}

static std::vector<std::string> domToLines(const DOMNode *node)
{
        std::vector<std::string> result;
        DOMImplementation *impl =
                DOMImplementationRegistry::getDOMImplementation(
                                                        XMLUniStr("Core"));
        std::auto_ptr<DOMWriter> writer(
                static_cast<DOMImplementationLS*>(impl)->createDOMWriter());

        writer->setEncoding(XMLUniStr("UTF-8"));
        XMLSimpleStr buffer(writer->writeToString(*node));

        const char *p = std::strchr((const char*)buffer, '>') + 1;
        const char *q = std::strrchr(p, '<');
        fillLines(result, p, q - p);

        return result;
}

std::vector<std::string> LHERunInfo::findHeader(const std::string &tag) const
{
        const LHERunInfo::Header *header = 0;
        for(std::vector<Header>::const_iterator iter = headers.begin();
            iter != headers.end(); ++iter) {
                if (iter->tag() == tag)
                        return std::vector<std::string>(iter->begin(),
                                                        iter->end());
                if (iter->tag() == "header")
                        header = &*iter;
        }

        if (!header)
                return std::vector<std::string>();

        const DOMNode *root = header->getXMLNode();
        if (!root)
                return std::vector<std::string>();

        for(const DOMNode *iter = root->getFirstChild();
            iter; iter = iter->getNextSibling()) {
                if (iter->getNodeType() != DOMNode::ELEMENT_NODE)
                        continue;
                if (tag == (const char*)XMLSimpleStr(iter->getNodeName()))
                        return domToLines(iter);
        }

        return std::vector<std::string>();
}

namespace {
        class HeaderReader : public CBInputStream::Reader {
            public:
                HeaderReader(const LHERunInfo::Header *header) :
                        header(header), mode(kHeader),
                        iter(header->begin())
                {
                }

                const std::string &data()
                {
                        switch(mode) {
                            case kHeader:
                                tmp = "<" + header->tag() + ">";
                                mode = kBody;
                                break;
                            case kBody:
                                if (iter != header->end())
                                        return *iter++;
                                tmp = "</" + header->tag() + ">";
                                mode = kFooter;
                                break;
                            case kFooter:
                                tmp.clear();
                        }

                        return tmp;
                }

            private:
                enum Mode {
                        kHeader,
                        kBody,
                        kFooter
                };

                const LHERunInfo::Header                *header;
                Mode                                    mode;
                LHERunInfo::Header::const_iterator      iter;
                std::string                             tmp;
        };
} // anonymous namespace

const DOMNode *LHERunInfo::Header::getXMLNode() const
{
        if (tag().empty())
                return 0;

        if (!xmlDoc) {
                XercesDOMParser parser;
                parser.setValidationScheme(XercesDOMParser::Val_Auto);
                parser.setDoNamespaces(false);
                parser.setDoSchema(false);
                parser.setValidationSchemaFullChecking(false);

                HandlerBase errHandler;
                parser.setErrorHandler(&errHandler);
                parser.setCreateEntityReferenceNodes(false);

                try {
                        std::auto_ptr<CBInputStream::Reader> reader(
                                                new HeaderReader(this));
                        CBInputSource source(reader);
                        parser.parse(source);
                        xmlDoc = parser.adoptDocument();
                } catch(const XMLException &e) {
                        throw cms::Exception("Generator|LHEInterface")
                                << "XML parser reported DOM error no. "
                                << (unsigned long)e.getCode()
                                << ": " << XMLSimpleStr(e.getMessage()) << "."
                                << std::endl;
                } catch(const SAXException &e) {
                        throw cms::Exception("Generator|LHEInterface")
                                << "XML parser reported: "
                                << XMLSimpleStr(e.getMessage()) << "."
                                << std::endl;
                }
        }

        return xmlDoc->getDocumentElement();
}

} // namespace lhef

---