lhef::LH5Reader Class Reference

#include <LH5Reader.h>

Classes
class	FileSource
class	Source
class	StringSource

Public Member Functions
	LH5Reader (const edm::ParameterSet &params)
	LH5Reader (const std::vector< std::string > &fileNames, unsigned int skip=0, int maxEvents=-1)
	LH5Reader (const std::string &inputs, unsigned int skip=0, int maxEvents=-1)
std::shared_ptr< LHEEvent >	next (bool *newFileOpened=nullptr)
	~LH5Reader ()

Private Attributes
bool	curDoc
unsigned int	curIndex
std::shared_ptr< LHERunInfo >	curRunInfo
std::unique_ptr< Source >	curSource
const std::vector< std::string >	fileURLs
unsigned int	firstEvent
int	maxEvents
const std::string	strName
std::vector< std::string >	weightsinconfig

Detailed Description

Definition at line 40 of file LH5Reader.h.

Constructor & Destructor Documentation

lhef::LH5Reader::LH5Reader

(

const edm::ParameterSet &

params

)

Definition at line 165 of file LH5Reader.cc.

      : fileURLs(params.getUntrackedParameter<std::vector<std::string> >("fileNames")),
        strName(""),
        firstEvent(params.getUntrackedParameter<unsigned int>("skipEvents", 0)),
        maxEvents(params.getUntrackedParameter<int>("limitEvents", -1)) {}

lhef::LH5Reader::LH5Reader	(	const std::vector< std::string > &	fileNames,
		unsigned int	skip = 0,
		int	maxEvents = -1
	)

Definition at line 171 of file LH5Reader.cc.

      : fileURLs(fileNames), strName(""), firstEvent(firstEvent), maxEvents(maxEvents), curIndex(0), curDoc(false) {}

lhef::LH5Reader::LH5Reader	(	const std::string &	inputs,
		unsigned int	skip = 0,
		int	maxEvents = -1
	)

Definition at line 174 of file LH5Reader.cc.

      : strName(inputs), firstEvent(firstEvent), maxEvents(maxEvents), curIndex(0) {}

lhef::LH5Reader::~LH5Reader

(

)

Definition at line 177 of file LH5Reader.cc.

References curSource.

{ curSource.release(); }

Member Function Documentation

std::shared_ptr< LHEEvent > lhef::LH5Reader::next

(

bool *

newFileOpened = nullptr

)

Definition at line 179 of file LH5Reader.cc.

References lheh5::EventHeader::aqcd, lhef::HEPEUP::AQCDUP, lheh5::EventHeader::aqed, lhef::HEPEUP::AQEDUP, curDoc, curIndex, curRunInfo, curSource, lhef::HEPRUP::EBMUP, relativeConstraints::error, fileURLs, firstEvent, lhef::HEPEUP::ICOLUP, lhef::HEPRUP::IDBMUP, lhef::HEPEUP::IDPRUP, lhef::HEPEUP::IDUP, lhef::HEPRUP::IDWTUP, lhef::HEPEUP::ISTUP, lhef::logFileAction(), lhef::HEPRUP::LPRUP, maxEvents, lhef::HEPEUP::MOTHUP, lheh5::EventHeader::nparticles, lhef::HEPRUP::NPRUP, lhef::HEPRUP::PDFGUP, lhef::HEPRUP::PDFSUP, lheh5::EventHeader::pid, lhef::HEPEUP::PUP, lhef::HEPEUP::resize(), lheh5::EventHeader::scale, lhef::HEPEUP::SCALUP, lhef::HEPEUP::SPINUP, strName, createJobs::tmp, lhef::HEPEUP::VTIMUP, lheh5::EventHeader::weight, lhef::HEPRUP::XERRUP, lhef::HEPRUP::XMAXUP, lhef::HEPRUP::XSECUP, and lhef::HEPEUP::XWGTUP.

Referenced by BeautifulSoup.PageElement::_invert().

                                                             {
    while (curDoc || curIndex < fileURLs.size() || (fileURLs.empty() && !strName.empty())) {
      if (!curDoc) {
        if (!fileURLs.empty()) {
          logFileAction("  Initiating request to open LHE file ", fileURLs[curIndex]);
          curSource = std::make_unique<FileSource>(fileURLs[curIndex]);
          logFileAction("  Successfully opened LHE file ", fileURLs[curIndex]);
          if (newFileOpened != nullptr)
            *newFileOpened = true;
          ++curIndex;
        } else if (!strName.empty()) {
          curSource = std::make_unique<StringSource>(strName);
        }
        // New "doc" has been opened.    This is the same as a new source.
        curDoc = true;
        // Set maxEvents and firstEvent
        curSource->handler->counter(firstEvent, maxEvents);
        curSource->handler->readBlock();

        curRunInfo.reset();
        HEPRUP tmprup;
        int beamA, beamB;
        curSource->handler->_init.getDataSet("beamA").read(beamA);
        curSource->handler->_init.getDataSet("beamB").read(beamB);
        tmprup.IDBMUP = std::make_pair(beamA, beamB);
        double energyA, energyB;
        curSource->handler->_init.getDataSet("energyA").read(energyA);
        curSource->handler->_init.getDataSet("energyB").read(energyB);
        tmprup.EBMUP = std::make_pair(energyA, energyB);
        int PDFsetA, PDFsetB;
        curSource->handler->_init.getDataSet("PDFsetA").read(PDFsetA);
        curSource->handler->_init.getDataSet("PDFsetB").read(PDFsetB);
        tmprup.PDFSUP = std::make_pair(PDFsetA, PDFsetB);
        int PDFgroupA, PDFgroupB;
        curSource->handler->_init.getDataSet("PDFgroupA").read(PDFgroupA);
        curSource->handler->_init.getDataSet("PDFgroupB").read(PDFgroupB);
        tmprup.PDFGUP = std::make_pair(PDFgroupA, PDFgroupB);
        std::vector<int> procId;         // NOTE: C++17 allows int[numProcesses]
        std::vector<double> xSection;    // NOTE: C++17 allows double[numProcesses]
        std::vector<double> error;       // NOTE: C++17 allows double[numProcesses]
        std::vector<double> unitWeight;  // NOTE: C++17 allows double[numProcesses]

        curSource->handler->_procInfo.getDataSet("procId").read(procId);
        curSource->handler->_procInfo.getDataSet("xSection").read(xSection);
        curSource->handler->_procInfo.getDataSet("error").read(error);
        curSource->handler->_procInfo.getDataSet("unitWeight").read(unitWeight);

        tmprup.LPRUP = procId;
        tmprup.XSECUP = xSection;
        tmprup.XERRUP = error;
        tmprup.XMAXUP = unitWeight;
        tmprup.IDWTUP = 3;
        size_t numProcesses = procId.size();
        tmprup.NPRUP = numProcesses;
        // Use temporary process info block to define const HEPRUP
        const HEPRUP heprup(tmprup);

        curRunInfo.reset(new LHERunInfo(heprup));
        // Run info has now been set when a new file is encountered
      }
      // Handler should be modified to have these capabilities
      // Maybe this is set event by event??
      int npLO = curSource->handler->npLO;
      int npNLO = curSource->handler->npNLO;

      // Event-loop here
      std::pair<EventHeader, std::vector<Particle> > evp = curSource->handler->getEventProperties();
      EventHeader hd = evp.first;
      if (hd.nparticles < 0) {
        curDoc = false;
        logFileAction("  Closed LHE file ", fileURLs[curIndex - 1]);
        return std::shared_ptr<LHEEvent>();
      }
      HEPEUP tmp;
      tmp.resize(hd.nparticles);
      //Particle loop
      unsigned int ip = 0;
      //      for (auto part: curSource->handler->_events1.mkEvent(i)) {
      for (auto part : evp.second) {
        tmp.IDUP[ip] = part.id;
        tmp.ISTUP[ip] = part.status;
        tmp.MOTHUP[ip] = std::make_pair(part.mother1, part.mother2);
        tmp.ICOLUP[ip] = std::make_pair(part.color1, part.color2);
        tmp.VTIMUP[ip] = part.lifetime;
        tmp.SPINUP[ip] = part.spin;
        tmp.PUP[ip][0] = part.px;
        tmp.PUP[ip][1] = part.py;
        tmp.PUP[ip][2] = part.pz;
        tmp.PUP[ip][3] = part.e;
        tmp.PUP[ip][4] = part.m;
        ip++;
      }
      tmp.IDPRUP = hd.pid;
      tmp.XWGTUP = hd.weight;
      tmp.SCALUP = hd.scale;
      tmp.AQEDUP = hd.aqed;
      tmp.AQCDUP = hd.aqcd;
      std::shared_ptr<LHEEvent> lheevent;
      // Use temporary event to construct const HEPEUP;
      const HEPEUP hepeup(tmp);

      lheevent.reset(new LHEEvent(curRunInfo, hepeup));
      // Might have to add this capability later
      /*          const XMLHandler::wgt_info &info = handler->weightsinevent;
          for (size_t i = 0; i < info.size(); ++i) {
            double num = -1.0;
            sscanf(info[i].second.c_str(), "%le", &num);
            lheevent->addWeight(gen::WeightsInfo(info[i].first, num));
            }*/
      // Currently these are set just at the beginning?
      // might be an event property
      lheevent->setNpLO(npLO);
      lheevent->setNpNLO(npNLO);
      //fill scales
      /*          if (!handler->scales.empty()) {
            lheevent->setScales(handler->scales);
            }*/
      return lheevent;
    }
    return std::shared_ptr<LHEEvent>();
  }

Member Data Documentation

bool lhef::LH5Reader::curDoc

private

Definition at line 62 of file LH5Reader.h.

Referenced by next().

unsigned int lhef::LH5Reader::curIndex

private

Definition at line 58 of file LH5Reader.h.

Referenced by next().

std::shared_ptr<LHERunInfo> lhef::LH5Reader::curRunInfo

private

Definition at line 63 of file LH5Reader.h.

Referenced by next().

std::unique_ptr<Source> lhef::LH5Reader::curSource

private

Definition at line 61 of file LH5Reader.h.

Referenced by next(), and ~LH5Reader().

const std::vector<std::string> lhef::LH5Reader::fileURLs

private

Definition at line 52 of file LH5Reader.h.

Referenced by next().

unsigned int lhef::LH5Reader::firstEvent

private

Definition at line 56 of file LH5Reader.h.

Referenced by looper.Looper::loop(), next(), and Printer.Printer::process().

int lhef::LH5Reader::maxEvents

private

Definition at line 57 of file LH5Reader.h.

Referenced by next().

const std::string lhef::LH5Reader::strName

private

Definition at line 55 of file LH5Reader.h.

Referenced by next().

std::vector<std::string> lhef::LH5Reader::weightsinconfig

private

Definition at line 59 of file LH5Reader.h.