lhef::LHERunInfo Class Reference

#include <LHERunInfo.h>

Classes
struct	Counter
class	Header
struct	Process
struct	XSec

Public Types
enum	CountMode { kTried = 0, kSelected, kKilled, kAccepted }

Public Member Functions
void	addComment (const std::string &line)
void	addHeader (const Header &header)
void	count (int process, CountMode count, double eventWeight=1.0, double brWeight=1.0, double matchWeight=1.0)
std::vector< std::string >	findHeader (const std::string &tag) const
const std::vector< std::string > &	getComments () const
const std::vector< Header > &	getHeaders () const
const int	getHEPIDWTUP () const
const HEPRUP *	getHEPRUP () const
const std::vector< Process > &	getLumiProcesses () const
void	initLumi ()
	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)
bool	operator!= (const LHERunInfo &other) const
bool	operator== (const LHERunInfo &other) const
std::pair< int, int >	pdfSetTranslation () const
void	statistics () const
XSec	xsec () const
	~LHERunInfo ()

Private Member Functions
void	init ()

Private Attributes
std::vector< std::string >	comments
std::vector< Header >	headers
HEPRUP	heprup
std::vector< Process >	processes
std::vector< Process >	processesLumi

Detailed Description

Definition at line 25 of file LHERunInfo.h.

Member Enumeration Documentation

enum lhef::LHERunInfo::CountMode

Enumerator
kTried
kSelected
kKilled
kAccepted

Definition at line 64 of file LHERunInfo.h.

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

Constructor & Destructor Documentation

lhef::LHERunInfo::LHERunInfo

(

std::istream &

in

)

Definition at line 38 of file LHERunInfo.cc.

References comments, lhef::HEPRUP::EBMUP, heprup, mps_fire::i, lhef::HEPRUP::IDBMUP, lhef::HEPRUP::IDWTUP, init(), geometryCSVtoXML::line, lhef::HEPRUP::LPRUP, lhef::HEPRUP::NPRUP, lhef::HEPRUP::PDFGUP, lhef::HEPRUP::PDFSUP, lhef::HEPRUP::resize(), skipWhitespace(), AlCaHLTBitMon_QueryRunRegistry::string, lhef::HEPRUP::XERRUP, lhef::HEPRUP::XMAXUP, and lhef::HEPRUP::XSECUP.

                                       {
    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::LogInfo("Generator|LHEInterface")
          << "Les Houches file contained spurious"
             " content after the regular data (this is normal for LHEv3 files for now)."
          << std::endl;

    init();
  }

lhef::LHERunInfo::LHERunInfo

(

const HEPRUP &

heprup

)

Definition at line 72 of file LHERunInfo.cc.

References init().

: heprup(heprup) { init(); }

lhef::LHERunInfo::LHERunInfo	(	const HEPRUP &	heprup,
		const std::vector< LHERunInfoProduct::Header > &	headers,
		const std::vector< std::string > &	comments
	)

Definition at line 74 of file LHERunInfo.cc.

References filterCSVwithJSON::copy, and init().

      : 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();
  }

lhef::LHERunInfo::LHERunInfo

(

const LHERunInfoProduct &

product

)

Definition at line 84 of file LHERunInfo.cc.

References comments, LHERunInfoProduct::comments_begin(), LHERunInfoProduct::comments_end(), filterCSVwithJSON::copy, headers, LHERunInfoProduct::headers_begin(), LHERunInfoProduct::headers_end(), and init().

                                                         : 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();
  }

lhef::LHERunInfo::~LHERunInfo

(

)

Definition at line 91 of file LHERunInfo.cc.

{}

Member Function Documentation

void lhef::LHERunInfo::addComment ( const std::string &  line )

inline

Definition at line 62 of file LHERunInfo.h.

{ comments.push_back(line); }

void lhef::LHERunInfo::addHeader ( const Header &  header )

inline

Definition at line 61 of file LHERunInfo.h.

Referenced by lhef::LHEReader::next().

{ headers.push_back(header); }

void lhef::LHERunInfo::count	(	int	process,
		CountMode	count,
		double	eventWeight = 1.0,
		double	brWeight = 1.0,
		double	matchWeight = 1.0
	)

Definition at line 119 of file LHERunInfo.cc.

References kAccepted, kKilled, kSelected, kTried, cuda_std::lower_bound(), ValidateTausOnZEEFastSim_cff::proc, LaserDQM_cfg::process, processes, and processesLumi.

                                                                                                             {
    std::vector<Process>::iterator proc = std::lower_bound(processes.begin(), processes.end(), process);
    if (proc == processes.end() || proc->process() != process)
      return;

    std::vector<Process>::iterator procLumi = std::lower_bound(processesLumi.begin(), processesLumi.end(), process);
    if (procLumi == processesLumi.end() || procLumi->process() != process)
      return;

    switch (mode) {
      case kAccepted:
        proc->addAcceptedBr(eventWeight * brWeight * matchWeight);
        proc->addAccepted(eventWeight * matchWeight);
        procLumi->addAcceptedBr(eventWeight * brWeight * matchWeight);
        procLumi->addAccepted(eventWeight * matchWeight);
        [[fallthrough]];
      case kKilled:
        proc->addKilled(eventWeight * matchWeight);
        procLumi->addKilled(eventWeight * matchWeight);
        if (eventWeight > 0) {
          proc->addNPassPos();
          procLumi->addNPassPos();
        } else {
          proc->addNPassNeg();
          procLumi->addNPassNeg();
        }
        [[fallthrough]];
      case kSelected:
        proc->addSelected(eventWeight);
        procLumi->addSelected(eventWeight);
        if (eventWeight > 0) {
          proc->addNTotalPos();
          procLumi->addNTotalPos();
        } else {
          proc->addNTotalNeg();
          procLumi->addNTotalNeg();
        }
        [[fallthrough]];
      case kTried:
        proc->addTried(eventWeight);
        procLumi->addTried(eventWeight);
    }
  }

std::vector< std::string > lhef::LHERunInfo::findHeader

(

const std::string &

tag

)

const

Definition at line 434 of file LHERunInfo.cc.

References lhef::domToLines(), headers, and GlobalPosition_Frontier_DevDB_cff::tag.

Referenced by gen::JetMatchingMadgraph::init(), gen::JetMatchingAlpgen::init(), gen::JetMatchingMGFastJet::init(), Herwig6Hadronizer::initialize(), gen::Pythia6Hadronizer::initializeForExternalPartons(), and Herwig6Hadronizer::readSettings().

                                                                        {
    const LHERunInfo::Header *header = nullptr;
    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>();
  }

const std::vector<std::string>& lhef::LHERunInfo::getComments ( ) const

inline

Definition at line 57 of file LHERunInfo.h.

References comments.

Referenced by LH5Source::fillRunInfoProduct(), and LHESource::fillRunInfoProduct().

{ return comments; }

const std::vector<Header>& lhef::LHERunInfo::getHeaders ( ) const

inline

Definition at line 56 of file LHERunInfo.h.

References headers.

Referenced by LH5Source::fillRunInfoProduct(), LHESource::fillRunInfoProduct(), edm::LHEProvenanceHelper::lheAugment(), and Herwig6Hadronizer::upInit().

{ return headers; }

const int lhef::LHERunInfo::getHEPIDWTUP ( ) const

inline

Definition at line 164 of file LHERunInfo.h.

References lhef::HEPRUP::IDWTUP.

{ return heprup.IDWTUP; }

const HEPRUP* lhef::LHERunInfo::getHEPRUP ( ) const

inline

Definition at line 51 of file LHERunInfo.h.

References heprup.

Referenced by edm::HadronizerFilter< HAD, DEC >::endLuminosityBlockProduce(), gen::FortranCallback::fillHeader(), edm::LHEProvenanceHelper::lheAugment(), Herwig6Hadronizer::readSettings(), JetMatchingHook::setLHERunInfo(), and edm::ConcurrentHadronizerFilter< HAD, DEC >::streamEndLuminosityBlockSummary().

{ return &heprup; }

const std::vector<Process>& lhef::LHERunInfo::getLumiProcesses ( ) const

inline

Definition at line 163 of file LHERunInfo.h.

References processesLumi.

Referenced by edm::HadronizerFilter< HAD, DEC >::endLuminosityBlockProduce(), and edm::ConcurrentHadronizerFilter< HAD, DEC >::streamEndLuminosityBlockSummary().

{ return processesLumi; }

void lhef::LHERunInfo::init ( void  )

private

Definition at line 93 of file LHERunInfo.cc.

References heprup, mps_fire::i, lhef::HEPRUP::LPRUP, lhef::HEPRUP::NPRUP, ValidateTausOnZEEFastSim_cff::proc, processes, lhef::LHERunInfo::Process::setHepRupIndex(), and lhef::LHERunInfo::Process::setProcess().

Referenced by LHERunInfo().

                        {
    for (int i = 0; i < heprup.NPRUP; i++) {
      Process proc;
      proc.setProcess(heprup.LPRUP[i]);
      proc.setHepRupIndex((unsigned int)i);
      processes.push_back(proc);
    }

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

void lhef::LHERunInfo::initLumi

(

)

Definition at line 104 of file LHERunInfo.cc.

References heprup, mps_fire::i, lhef::HEPRUP::LPRUP, lhef::HEPRUP::NPRUP, ValidateTausOnZEEFastSim_cff::proc, processesLumi, lhef::LHERunInfo::Process::setHepRupIndex(), lhef::LHERunInfo::Process::setLHEXSec(), lhef::LHERunInfo::Process::setProcess(), lhef::HEPRUP::XERRUP, and lhef::HEPRUP::XSECUP.

Referenced by edm::HadronizerFilter< HAD, DEC >::beginLuminosityBlockProduce(), edm::HadronizerFilter< HAD, DEC >::beginRun(), edm::ConcurrentHadronizerFilter< HAD, DEC >::initLumi(), and edm::ConcurrentHadronizerFilter< HAD, DEC >::streamBeginRun().

                            {
    processesLumi.clear();
    for (int i = 0; i < heprup.NPRUP; i++) {
      Process proc;
      proc.setProcess(heprup.LPRUP[i]);
      proc.setHepRupIndex((unsigned int)i);
      proc.setLHEXSec(heprup.XSECUP[i], heprup.XERRUP[i]);
      processesLumi.push_back(proc);
    }

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

bool lhef::LHERunInfo::operator!= ( const LHERunInfo &  other ) const

inline

Definition at line 54 of file LHERunInfo.h.

{ return !(*this == other); }

bool lhef::LHERunInfo::operator==

(

const LHERunInfo &

other

)

const

Definition at line 117 of file LHERunInfo.cc.

References heprup.

{ return heprup == other.heprup; }

std::pair< int, int > lhef::LHERunInfo::pdfSetTranslation

(

)

const

Definition at line 527 of file LHERunInfo.cc.

References heprup, lhef::HEPRUP::PDFGUP, and lhef::HEPRUP::PDFSUP.

Referenced by Herwig6Hadronizer::initialize(), and Herwig6Hadronizer::readSettings().

                                                        {
    int pdfA = -1, pdfB = -1;

    if (heprup.PDFGUP.first >= 0) {
      pdfA = heprup.PDFSUP.first;
    }

    if (heprup.PDFGUP.second >= 0) {
      pdfB = heprup.PDFSUP.second;
    }

    return std::make_pair(pdfA, pdfB);
  }

void lhef::LHERunInfo::statistics

(

)

const

Definition at line 252 of file LHERunInfo.cc.

References cuy::denominator, heprup, lhef::HEPRUP::IDWTUP, LogDebug, groupFilesInBlocks::ntotal, cuy::numerator, funct::pow(), ValidateTausOnZEEFastSim_cff::proc, processes, mathSSE::sqrt(), lhef::HEPRUP::XERRUP, and lhef::HEPRUP::XSECUP.

Referenced by edm::HadronizerFilter< HAD, DEC >::endRunProduce(), and edm::ConcurrentHadronizerFilter< HAD, DEC >::streamEndRun().

                                    {
    double sigSelSum = 0.0;
    double sigSum = 0.0;
    double sigBrSum = 0.0;
    double errSel2Sum = 0.0;
    double err2Sum = 0.0;
    double errBr2Sum = 0.0;
    double errMatch2Sum = 0.0;
    unsigned long nAccepted = 0;
    unsigned long nTried = 0;
    unsigned long nAccepted_pos = 0;
    unsigned long nTried_pos = 0;
    unsigned long nAccepted_neg = 0;
    unsigned long nTried_neg = 0;
    int idwtup = heprup.IDWTUP;

    LogDebug("LHERunInfo") << " statistics";
    LogDebug("LHERunInfo") << "Process and cross-section statistics";
    LogDebug("LHERunInfo") << "------------------------------------";
    LogDebug("LHERunInfo") << "Process\t\txsec_before [pb]\t\tpassed\tnposw\tnnegw\ttried\tnposw\tnnegw \txsec_match "
                              "[pb]\t\t\taccepted [%]\t event_eff [%]";

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

      if (!proc->selected().n()) {
        LogDebug("LHERunInfo") << proc->process() << "\t0\t0\tn/a\t\t\tn/a";
        continue;
      }

      double sigma2Sum, sigma2Err;
      sigma2Sum = heprup.XSECUP[idx] * heprup.XSECUP[idx];
      sigma2Err = heprup.XERRUP[idx] * heprup.XERRUP[idx];

      double sigmaAvg = heprup.XSECUP[idx];

      double fracAcc = 0;
      double ntotal = proc->nTotalPos() - proc->nTotalNeg();
      double npass = proc->nPassPos() - proc->nPassNeg();
      switch (idwtup) {
        case 3:
        case -3:
          fracAcc = ntotal > 0 ? npass / ntotal : -1;
          break;
        default:
          fracAcc = proc->selected().sum() > 0 ? proc->killed().sum() / proc->selected().sum() : -1;
          break;
      }

      double fracBr = proc->accepted().sum() > 0.0 ? proc->acceptedBr().sum() / proc->accepted().sum() : 1;
      double sigmaFin = fracAcc > 0 ? sigmaAvg * fracAcc : 0;
      double sigmaFinBr = sigmaFin * fracBr;

      double relErr = 1.0;
      double relAccErr = 1.0;
      double efferr2 = 0;

      if (proc->killed().n() > 0 && fracAcc > 0) {
        switch (idwtup) {
          case 3:
          case -3: {
            double ntotal_pos = proc->nTotalPos();
            double effp = ntotal_pos > 0 ? (double)proc->nPassPos() / ntotal_pos : 0;
            double effp_err2 = ntotal_pos > 0 ? (1 - effp) * effp / ntotal_pos : 0;

            double ntotal_neg = proc->nTotalNeg();
            double effn = ntotal_neg > 0 ? (double)proc->nPassNeg() / ntotal_neg : 0;
            double effn_err2 = ntotal_neg > 0 ? (1 - effn) * effn / ntotal_neg : 0;

            efferr2 = ntotal > 0 ? (ntotal_pos * ntotal_pos * effp_err2 + ntotal_neg * ntotal_neg * effn_err2) /
                                       ntotal / ntotal
                                 : 0;
            break;
          }
          default: {
            double denominator = pow(proc->selected().sum(), 4);
            double passw = proc->killed().sum();
            double passw2 = proc->killed().sum2();
            double failw = proc->selected().sum() - passw;
            double failw2 = proc->selected().sum2() - passw2;
            double numerator = (passw2 * failw * failw + failw2 * passw * passw);

            efferr2 = denominator > 0 ? numerator / denominator : 0;
            break;
          }
        }
        double delta2Veto = efferr2 / fracAcc / fracAcc;
        double delta2Sum = delta2Veto + sigma2Err / sigma2Sum;
        relErr = (delta2Sum > 0.0 ? std::sqrt(delta2Sum) : 0.0);
        relAccErr = (delta2Veto > 0.0 ? std::sqrt(delta2Veto) : 0.0);
      }
      double deltaFin = sigmaFin * relErr;
      double deltaFinBr = sigmaFinBr * relErr;

      double ntotal_proc = proc->nTotalPos() + proc->nTotalNeg();
      double event_eff_proc = ntotal_proc > 0 ? (double)(proc->nPassPos() + proc->nPassNeg()) / ntotal_proc : -1;
      double event_eff_err_proc = ntotal_proc > 0 ? std::sqrt((1 - event_eff_proc) * event_eff_proc / ntotal_proc) : -1;

      LogDebug("LHERunInfo") << proc->process() << "\t\t" << std::scientific << std::setprecision(3)
                             << heprup.XSECUP[proc->heprupIndex()] << " +/- " << heprup.XERRUP[proc->heprupIndex()]
                             << "\t\t" << proc->accepted().n() << "\t" << proc->nPassPos() << "\t" << proc->nPassNeg()
                             << "\t" << proc->tried().n() << "\t" << proc->nTotalPos() << "\t" << proc->nTotalNeg()
                             << "\t" << std::scientific << std::setprecision(3) << sigmaFinBr << " +/- " << deltaFinBr
                             << "\t\t" << std::fixed << std::setprecision(1) << (fracAcc * 100) << " +/- "
                             << (std::sqrt(efferr2) * 100) << "\t" << std::fixed << std::setprecision(1)
                             << (event_eff_proc * 100) << " +/- " << (event_eff_err_proc * 100);

      nAccepted += proc->accepted().n();
      nTried += proc->tried().n();
      nAccepted_pos += proc->nPassPos();
      nTried_pos += proc->nTotalPos();
      nAccepted_neg += proc->nPassNeg();
      nTried_neg += proc->nTotalNeg();
      sigSelSum += sigmaAvg;
      sigSum += sigmaFin;
      sigBrSum += sigmaFinBr;
      errSel2Sum += sigma2Err;
      err2Sum += deltaFin * deltaFin;
      errBr2Sum += deltaFinBr * deltaFinBr;
      errMatch2Sum += sigmaFin * relAccErr * sigmaFin * relAccErr;
    }

    double ntotal_all = (nTried_pos + nTried_neg);
    double event_eff_all = ntotal_all > 0 ? (double)(nAccepted_pos + nAccepted_neg) / ntotal_all : -1;
    double event_eff_err_all = ntotal_all > 0 ? std::sqrt((1 - event_eff_all) * event_eff_all / ntotal_all) : -1;

    LogDebug("LHERunInfo") << "Total\t\t" << std::scientific << std::setprecision(3) << sigSelSum << " +/- "
                           << std::sqrt(errSel2Sum) << "\t\t" << nAccepted << "\t" << nAccepted_pos << "\t"
                           << nAccepted_neg << "\t" << nTried << "\t" << nTried_pos << "\t" << nTried_neg << "\t"
                           << std::scientific << std::setprecision(3) << sigBrSum << " +/- " << std::sqrt(errBr2Sum)
                           << "\t\t" << std::fixed << std::setprecision(1) << (sigSum / sigSelSum * 100) << " +/- "
                           << (std::sqrt(errMatch2Sum) / sigSelSum * 100) << "\t" << std::fixed << std::setprecision(1)
                           << (event_eff_all * 100) << " +/- " << (event_eff_err_all * 100);
  }

LHERunInfo::XSec lhef::LHERunInfo::xsec

(

)

const

Definition at line 163 of file LHERunInfo.cc.

References cuy::denominator, heprup, lhef::HEPRUP::IDWTUP, groupFilesInBlocks::ntotal, cuy::numerator, funct::pow(), ValidateTausOnZEEFastSim_cff::proc, processes, mps_fire::result, mathSSE::sqrt(), lhef::HEPRUP::XERRUP, and lhef::HEPRUP::XSECUP.

Referenced by edm::HadronizerFilter< HAD, DEC >::endRunProduce(), and edm::ConcurrentHadronizerFilter< HAD, DEC >::streamEndRun().

                                        {
    double sigSelSum = 0.0;
    double sigSum = 0.0;
    double sigBrSum = 0.0;
    double err2Sum = 0.0;
    double errBr2Sum = 0.0;
    int idwtup = heprup.IDWTUP;
    for (std::vector<Process>::const_iterator proc = processes.begin(); proc != processes.end(); ++proc) {
      unsigned int idx = proc->heprupIndex();

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

      double sigma2Sum, sigma2Err;
      sigma2Sum = heprup.XSECUP[idx] * heprup.XSECUP[idx];
      sigma2Err = heprup.XERRUP[idx] * heprup.XERRUP[idx];

      double sigmaAvg = heprup.XSECUP[idx];

      double fracAcc = 0;
      double ntotal = proc->nTotalPos() - proc->nTotalNeg();
      double npass = proc->nPassPos() - proc->nPassNeg();
      switch (idwtup) {
        case 3:
        case -3:
          fracAcc = ntotal > 0 ? npass / ntotal : -1;
          break;
        default:
          fracAcc = proc->selected().sum() > 0 ? proc->killed().sum() / proc->selected().sum() : -1;
          break;
      }

      if (fracAcc <= 0)
        continue;

      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;

      double efferr2 = 0;
      switch (idwtup) {
        case 3:
        case -3: {
          double ntotal_pos = proc->nTotalPos();
          double effp = ntotal_pos > 0 ? (double)proc->nPassPos() / ntotal_pos : 0;
          double effp_err2 = ntotal_pos > 0 ? (1 - effp) * effp / ntotal_pos : 0;

          double ntotal_neg = proc->nTotalNeg();
          double effn = ntotal_neg > 0 ? (double)proc->nPassNeg() / ntotal_neg : 0;
          double effn_err2 = ntotal_neg > 0 ? (1 - effn) * effn / ntotal_neg : 0;

          efferr2 = ntotal > 0
                        ? (ntotal_pos * ntotal_pos * effp_err2 + ntotal_neg * ntotal_neg * effn_err2) / ntotal / ntotal
                        : 0;
          break;
        }
        default: {
          double denominator = pow(proc->selected().sum(), 4);
          double passw = proc->killed().sum();
          double passw2 = proc->killed().sum2();
          double failw = proc->selected().sum() - passw;
          double failw2 = proc->selected().sum2() - passw2;
          double numerator = (passw2 * failw * failw + failw2 * passw * passw);

          efferr2 = denominator > 0 ? numerator / denominator : 0;
          break;
        }
      }
      double delta2Veto = efferr2 / fracAcc / fracAcc;
      double delta2Sum = 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(sigBrSum, std::sqrt(errBr2Sum));

    return result;
  }

Member Data Documentation

std::vector<std::string> lhef::LHERunInfo::comments

private

Definition at line 160 of file LHERunInfo.h.

Referenced by getComments(), and LHERunInfo().

std::vector<Header> lhef::LHERunInfo::headers

private

Definition at line 159 of file LHERunInfo.h.

Referenced by findHeader(), getHeaders(), LHERunInfo(), Formatter.SimpleHTMLFormatter::showLine(), Formatter.SimpleHTMLFormatter::write(), Formatter.SimpleHTMLFormatter::writeAnchor(), Formatter.SimpleHTMLFormatter::writeB(), Formatter.SimpleHTMLFormatter::writeBr(), Formatter.SimpleHTMLFormatter::writeH1(), Formatter.SimpleHTMLFormatter::writeH2(), and Formatter.SimpleHTMLFormatter::writeH3().

HEPRUP lhef::LHERunInfo::heprup

private

Definition at line 157 of file LHERunInfo.h.

Referenced by getHEPRUP(), init(), initLumi(), LHERunInfo(), operator==(), pdfSetTranslation(), statistics(), and xsec().

std::vector<Process> lhef::LHERunInfo::processes

private

Definition at line 158 of file LHERunInfo.h.

Referenced by count(), init(), statistics(), and xsec().

std::vector<Process> lhef::LHERunInfo::processesLumi

private

Definition at line 168 of file LHERunInfo.h.

Referenced by count(), getLumiProcesses(), and initLumi().