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 66 of file LHERunInfo.h.

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

Constructor & Destructor Documentation

lhef::LHERunInfo::LHERunInfo

(

std::istream &

in

)

Definition at line 41 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 79 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 85 of file LHERunInfo.cc.

References popcon2dropbox::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 98 of file LHERunInfo.cc.

References comments, LHERunInfoProduct::comments_begin(), LHERunInfoProduct::comments_end(), popcon2dropbox::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 109 of file LHERunInfo.cc.

{
}

Member Function Documentation

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

inline

Definition at line 64 of file LHERunInfo.h.

{ comments.push_back(line); }

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

inline

Definition at line 63 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 147 of file LHERunInfo.cc.

References kAccepted, kKilled, kSelected, kTried, 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);
        case kKilled:
          proc->addKilled(eventWeight * matchWeight);
          procLumi->addKilled(eventWeight * matchWeight);
          if(eventWeight>0)
        {
          proc->addNPassPos();
          procLumi->addNPassPos();
        }
          else
        {
          proc->addNPassNeg();
          procLumi->addNPassNeg();
        }
        case kSelected:
          proc->addSelected(eventWeight);
          procLumi->addSelected(eventWeight);
          if(eventWeight>0)
        {
          proc->addNTotalPos();
          procLumi->addNTotalPos();
        }
          else
        {
          proc->addNTotalNeg();
          procLumi->addNTotalNeg();
        }
        case kTried:
          proc->addTried(eventWeight);
          procLumi->addTried(eventWeight);
    }
}

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

(

const std::string &

tag

)

const

Definition at line 525 of file LHERunInfo.cc.

References LHERunInfoProduct::Header::begin(), data, lhef::domToLines(), MillePedeFileConverter_cfg::e, relativeConstraints::empty, LHERunInfoProduct::Header::end(), Exception, RecoTauValidation_cfi::header, headers, ALCARECOPromptCalibProdSiPixelAli0T_cff::mode, createfilelist::parser, matplotRender::reader, source, AlCaHLTBitMon_QueryRunRegistry::string, LHERunInfoProduct::Header::tag(), tmp, and lhef::LHERunInfo::Header::xmlDoc.

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 59 of file LHERunInfo.h.

References indexGen::comments, AlCaHLTBitMon_QueryRunRegistry::string, and GlobalPosition_Frontier_DevDB_cff::tag.

Referenced by LHESource::fillRunInfoProduct().

{ return comments; }

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

inline

Definition at line 58 of file LHERunInfo.h.

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

{ return headers; }

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

inline

Definition at line 172 of file LHERunInfo.h.

References lhef::HEPRUP::IDWTUP.

{return heprup.IDWTUP;}

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

inline

Definition at line 52 of file LHERunInfo.h.

References operator==(), and trackingPlots::other.

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

{ return &heprup; } 

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

inline

Definition at line 171 of file LHERunInfo.h.

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

{return processesLumi;}

void lhef::LHERunInfo::init ( void  )

private

Definition at line 113 of file LHERunInfo.cc.

References heprup, mps_fire::i, lhef::HEPRUP::LPRUP, lhef::HEPRUP::NPRUP, 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 125 of file LHERunInfo.cc.

References heprup, mps_fire::i, lhef::HEPRUP::LPRUP, lhef::HEPRUP::NPRUP, 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(), and edm::HadronizerFilter< HAD, DEC >::beginRun().

{
  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 55 of file LHERunInfo.h.

References trackingPlots::other.

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

bool lhef::LHERunInfo::operator==

(

const LHERunInfo &

other

)

const

Definition at line 142 of file LHERunInfo.cc.

References heprup.

{
    return heprup == other.heprup;
}

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

(

)

const

Definition at line 637 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 297 of file LHERunInfo.cc.

References pfDeepCMVADiscriminatorsJetTags_cfi::denominator, alignBH_cfg::fixed, heprup, lhef::HEPRUP::IDWTUP, training_settings::idx, LogDebug, groupFilesInBlocks::ntotal, pfDeepCMVADiscriminatorsJetTags_cfi::numerator, funct::pow(), proc, processes, mathSSE::sqrt(), lhef::HEPRUP::XERRUP, and lhef::HEPRUP::XSECUP.

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

{
    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 199 of file LHERunInfo.cc.

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

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

{
    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 168 of file LHERunInfo.h.

Referenced by LHERunInfo().

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

private

Definition at line 167 of file LHERunInfo.h.

Referenced by findHeader(), 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 165 of file LHERunInfo.h.

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

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

private

Definition at line 166 of file LHERunInfo.h.

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

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

private

Definition at line 175 of file LHERunInfo.h.

Referenced by count(), and initLumi().