lhef::LHEReader::XMLHandler Class Reference

Inheritance diagram for lhef::LHEReader::XMLHandler:

Public Types
enum	Object {   kNone = 0, kHeader, kInit, kComment,   kEvent }
typedef std::vector< std::pair< std::string, std::string > >	wgt_info

Public Member Functions
void	reset ()
const wgt_info &	weightInfo () const
	XMLHandler ()
	~XMLHandler () override

Protected Member Functions
void	characters (const XMLCh *const chars, const XMLSize_t length) override
void	comment (const XMLCh *const chars, const XMLSize_t length) override
void	endElement (const XMLCh *const uri, const XMLCh *const localname, const XMLCh *const qname) override
void	startElement (const XMLCh *const uri, const XMLCh *const localname, const XMLCh *const qname, const Attributes &attributes) override

Private Attributes
std::string	buffer
int	evtnum = -1
Object	gotObject
bool	headerOk
std::vector< LHERunInfo::Header >	headers
std::unique_ptr< DOMImplementation >	impl
Object	mode
int	npLO
int	npNLO
std::vector< float >	scales
bool	skipEvent = false
wgt_info	weightsinevent
DOMDocument *	xmlEvent
std::vector< DOMElement * >	xmlEventNodes
DOMDocument *	xmlHeader
std::vector< DOMElement * >	xmlNodes

Friends
class	LHEReader

Detailed Description

Definition at line 86 of file LHEReader.cc.

Member Typedef Documentation

wgt_info

typedef std::vector<std::pair<std::string, std::string> > lhef::LHEReader::XMLHandler::wgt_info

Definition at line 88 of file LHEReader.cc.

Member Enumeration Documentation

Object

enum lhef::LHEReader::XMLHandler::Object

Enumerator
kNone
kHeader
kInit
kComment
kEvent

Definition at line 105 of file LHEReader.cc.

{ kNone = 0, kHeader, kInit, kComment, kEvent };

Constructor & Destructor Documentation

XMLHandler()

lhef::LHEReader::XMLHandler::XMLHandler ( )

inline

Definition at line 89 of file LHEReader.cc.

        : impl(nullptr),
          gotObject(kNone),
          mode(kNone),
          xmlHeader(nullptr),
          xmlEvent(nullptr),
          headerOk(false),
          npLO(-99),
          npNLO(-99) {}

~XMLHandler()

lhef::LHEReader::XMLHandler::~XMLHandler ( )

inlineoverride

Definition at line 98 of file LHEReader.cc.

                           {
      if (xmlHeader)
        xmlHeader->release();
      if (xmlEvent)
        xmlEvent->release();
    }

Member Function Documentation

characters()

void lhef::LHEReader::XMLHandler::characters ( const XMLCh *const  chars, const XMLSize_t  length  )

overrideprotected

Definition at line 376 of file LHEReader.cc.

References edmScanValgrind::buffer, data, Exception, lhef::XMLSimpleStr::isAllSpaces(), lhef::XMLSimpleStr::isSpace(), WDecay::kNone, ALCARECOPromptCalibProdSiPixelAli0T_cff::mode, hltrates_dqm_sourceclient-live_cfg::offset, and submitPVValidationJobs::text.

                                                                                       {
    if (mode == kHeader) {
      DOMText *text = xmlHeader->createTextNode(data_);
      xmlNodes.back()->appendChild(text);
      return;
    }

    if (XMLSimpleStr::isAllSpaces(data_, length))
      return;

    unsigned int offset = 0;
    while (offset < length && XMLSimpleStr::isSpace(data_[offset]))
      offset++;

    if (mode == kEvent) {
      if (!skipEvent) {
        DOMText *text = xmlEvent->createTextNode(data_ + offset);
        xmlEventNodes.back()->appendChild(text);
      }
      return;
    }

    if (mode == kNone)
      throw cms::Exception("InvalidFormat") << "LHE file has invalid format" << std::endl;

    XMLSimpleStr data(data_ + offset);
    buffer.append(data);
  }

comment()

void lhef::LHEReader::XMLHandler::comment ( const XMLCh *const  chars, const XMLSize_t  length  )

overrideprotected

Definition at line 405 of file LHEReader.cc.

References data, lhef::fillHeader(), RecoTauValidation_cfi::header, getRunAppsInfo::headers, and ALCARECOPromptCalibProdSiPixelAli0T_cff::mode.

                                                                                    {
    if (mode == kHeader) {
      DOMComment *comment = xmlHeader->createComment(data_);
      xmlNodes.back()->appendChild(comment);
      return;
    }

    XMLSimpleStr data(data_);

    LHERunInfo::Header header;
    fillHeader(header, data);
    headers.push_back(header);
  }

endElement()

void lhef::LHEReader::XMLHandler::endElement ( const XMLCh *const  uri, const XMLCh *const  localname, const XMLCh *const  qname  )

overrideprotected

Definition at line 279 of file LHEReader.cc.

References cms::cuda::assert(), edmScanValgrind::buffer, data, Exception, lhef::fillHeader(), RecoTauValidation_cfi::header, getRunAppsInfo::headers, WDecay::kNone, ALCARECOPromptCalibProdSiPixelAli0T_cff::mode, Skims_PA_cff::name, AlCaHLTBitMon_ParallelJobs::p, submitPVResolutionJobs::q, AlCaHLTBitMon_QueryRunRegistry::string, mps_merge::weight, and convertToRaw::writer.

                                                                   {
    std::string name((const char *)XMLSimpleStr(qname));

    if (mode) {
      if (mode == kHeader && xmlNodes.size() > 1) {
        xmlNodes.resize(xmlNodes.size() - 1);
        return;
      } else if (mode == kHeader) {
        std::unique_ptr<DOMLSSerializer> writer(impl->createLSSerializer());
        std::unique_ptr<DOMLSOutput> outputDesc(impl->createLSOutput());
        assert(outputDesc.get());
        outputDesc->setEncoding(XMLUniStr("UTF-8"));

        for (DOMNode *node = xmlNodes[0]->getFirstChild(); node; node = node->getNextSibling()) {
          XMLSimpleStr buffer(writer->writeToString(node));

          std::string type;
          const char *p, *q;
          DOMElement *elem;

          switch (node->getNodeType()) {
            case DOMNode::ELEMENT_NODE:
              elem = static_cast<DOMElement *>(node);
              type = (const char *)XMLSimpleStr(elem->getTagName());
              p = std::strchr((const char *)buffer, '>') + 1;
              q = std::strrchr(p, '<');
              break;
            case DOMNode::COMMENT_NODE:
              type = "";
              p = buffer + 4;
              q = buffer + strlen(buffer) - 3;
              break;
            default:
              type = "<>";
              p = buffer + std::strspn(buffer, " \t\r\n");
              if (!*p)
                continue;
              q = p + strlen(p);
          }
          LHERunInfo::Header header(type);
          fillHeader(header, p, q - p);
          headers.push_back(header);
        }

        xmlHeader->release();
        xmlHeader = nullptr;
      } else if (name == "event" && mode == kEvent &&
                 (skipEvent || (!xmlEventNodes.empty()))) {  // handling of weights in LHE file

        if (skipEvent) {
          gotObject = mode;
          mode = kNone;
          return;
        }

        for (DOMNode *node = xmlEventNodes[0]->getFirstChild(); node; node = node->getNextSibling()) {
          switch (node->getNodeType()) {
            case DOMNode::ELEMENT_NODE:  // rwgt
              for (DOMNode *rwgt = xmlEventNodes[1]->getFirstChild(); rwgt; rwgt = rwgt->getNextSibling()) {
                DOMNode *attr = rwgt->getAttributes()->item(0);
                XMLSimpleStr atname(attr->getNodeValue());
                XMLSimpleStr weight(rwgt->getFirstChild()->getNodeValue());
                switch (rwgt->getNodeType()) {
                  case DOMNode::ELEMENT_NODE:
                    weightsinevent.push_back(std::make_pair((const char *)atname, (const char *)weight));
                    break;
                  default:
                    break;
                }
              }
              break;
            case DOMNode::TEXT_NODE:  // event information
            {
              XMLSimpleStr data(node->getNodeValue());
              buffer.append(data);
            } break;
            default:
              break;
          }
        }
      } else if (mode == kEvent) {
        //skip unknown tags
        return;
      }

      if (gotObject != kNone)
        throw cms::Exception("InvalidState") << "Unexpected pileup in"
                                                " LHEReader::XMLHandler::endElement"
                                             << std::endl;

      gotObject = mode;
      mode = kNone;
    }
  }

reset()

void lhef::LHEReader::XMLHandler::reset ( void  )

inline

Definition at line 107 of file LHEReader.cc.

References WDecay::kNone, and ALCARECOPromptCalibProdSiPixelAli0T_cff::mode.

                 {
      headerOk = false;
      weightsinevent.clear();
      gotObject = kNone;
      mode = kNone;
    }

startElement()

void lhef::LHEReader::XMLHandler::startElement ( const XMLCh *const  uri, const XMLCh *const  localname, const XMLCh *const  qname, const Attributes &  attributes  )

overrideprotected

Definition at line 171 of file LHEReader.cc.

References lhef::attributesToDom(), edmScanValgrind::buffer, Exception, WDecay::kNone, ALCARECOPromptCalibProdSiPixelAli0T_cff::mode, Skims_PA_cff::name, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                         {
    std::string name((const char *)XMLSimpleStr(qname));

    if (!headerOk) {
      if (name != "LesHouchesEvents")
        throw cms::Exception("InvalidFormat") << "LHE file has invalid header" << std::endl;
      headerOk = true;
      return;
    }

    if (mode == kHeader) {
      DOMElement *elem = xmlHeader->createElement(qname);
      attributesToDom(elem, attributes);
      xmlNodes.back()->appendChild(elem);
      xmlNodes.push_back(elem);
      return;
    } else if (mode == kEvent) {
      if (skipEvent) {
        return;
      }

      DOMElement *elem = xmlEvent->createElement(qname);
      attributesToDom(elem, attributes);

      //TODO this is a hack (even more than the rest of this class)
      if (name == "rwgt") {
        xmlEventNodes[0]->appendChild(elem);
      } else if (name == "wgt") {
        xmlEventNodes[1]->appendChild(elem);
      } else if (name == "scales") {
        for (XMLSize_t iscale = 0; iscale < attributes.getLength(); ++iscale) {
          int ipart = 0;
          const char *scalename = XMLSimpleStr(attributes.getQName(iscale));
          int nmatch = sscanf(scalename, "pt_clust_%d", &ipart);

          if (nmatch != 1) {
            edm::LogError("Generator|LHEInterface") << "invalid attribute in <scales> tag" << std::endl;
          }

          float scaleval;
          const char *scalevalstr = XMLSimpleStr(attributes.getValue(iscale));
          sscanf(scalevalstr, "%e", &scaleval);

          scales.push_back(scaleval);
        }
      } else if (name == "event_num") {
        const char *evtnumstr = XMLSimpleStr(attributes.getValue(XMLString::transcode("num")));
        sscanf(evtnumstr, "%d", &evtnum);
      }
      xmlEventNodes.push_back(elem);
      return;
    } else if (mode == kInit) {
      //skip unknown tags in init block as well
      return;
    } else if (mode != kNone) {
      throw cms::Exception("InvalidFormat") << "LHE file has invalid format" << std::endl;
    }

    if (name == "header") {
      if (!impl)
        impl.reset(DOMImplementationRegistry::getDOMImplementation(XMLUniStr("Core")));

      xmlHeader = impl->createDocument(nullptr, qname, nullptr);
      xmlNodes.resize(1);
      xmlNodes[0] = xmlHeader->getDocumentElement();
      mode = kHeader;
    }
    if (name == "init") {
      mode = kInit;
    } else if (name == "event") {
      if (!skipEvent) {
        if (!impl)
          impl.reset(DOMImplementationRegistry::getDOMImplementation(XMLUniStr("Core")));

        if (xmlEvent)
          xmlEvent->release();
        xmlEvent = impl->createDocument(nullptr, qname, nullptr);
        weightsinevent.resize(0);
        scales.clear();

        npLO = -99;
        npNLO = -99;
        const XMLCh *npLOval = attributes.getValue(XMLString::transcode("npLO"));
        if (npLOval) {
          const char *npLOs = XMLSimpleStr(npLOval);
          sscanf(npLOs, "%d", &npLO);
        }
        const XMLCh *npNLOval = attributes.getValue(XMLString::transcode("npNLO"));
        if (npNLOval) {
          const char *npNLOs = XMLSimpleStr(npNLOval);
          sscanf(npNLOs, "%d", &npNLO);
        }

        xmlEventNodes.resize(1);
        xmlEventNodes[0] = xmlEvent->getDocumentElement();
      }
      mode = kEvent;
    }

    if (mode == kNone)
      throw cms::Exception("InvalidFormat") << "LHE file has invalid format" << std::endl;

    buffer.clear();
  }

weightInfo()

const wgt_info& lhef::LHEReader::XMLHandler::weightInfo ( ) const

inline

Definition at line 114 of file LHEReader.cc.

{ return weightsinevent; }

Friends And Related Function Documentation

LHEReader

friend class LHEReader

friend

Definition at line 128 of file LHEReader.cc.

Member Data Documentation

buffer

std::string lhef::LHEReader::XMLHandler::buffer

private

Definition at line 132 of file LHEReader.cc.

evtnum

int lhef::LHEReader::XMLHandler::evtnum = -1

private

Definition at line 144 of file LHEReader.cc.

gotObject

Object lhef::LHEReader::XMLHandler::gotObject

private

Definition at line 133 of file LHEReader.cc.

headerOk

bool lhef::LHEReader::XMLHandler::headerOk

private

Definition at line 138 of file LHEReader.cc.

headers

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

private

Definition at line 139 of file LHEReader.cc.

Referenced by 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().

impl

std::unique_ptr<DOMImplementation> lhef::LHEReader::XMLHandler::impl

private

Definition at line 131 of file LHEReader.cc.

mode

Object lhef::LHEReader::XMLHandler::mode

private

Definition at line 134 of file LHEReader.cc.

npLO

int lhef::LHEReader::XMLHandler::npLO

private

Definition at line 141 of file LHEReader.cc.

npNLO

int lhef::LHEReader::XMLHandler::npNLO

private

Definition at line 142 of file LHEReader.cc.

scales

std::vector<float> lhef::LHEReader::XMLHandler::scales

private

Definition at line 143 of file LHEReader.cc.

skipEvent

bool lhef::LHEReader::XMLHandler::skipEvent = false

private

Definition at line 130 of file LHEReader.cc.

weightsinevent

wgt_info lhef::LHEReader::XMLHandler::weightsinevent

private

Definition at line 140 of file LHEReader.cc.

xmlEvent

DOMDocument* lhef::LHEReader::XMLHandler::xmlEvent

private

Definition at line 136 of file LHEReader.cc.

xmlEventNodes

std::vector<DOMElement *> lhef::LHEReader::XMLHandler::xmlEventNodes

private

Definition at line 137 of file LHEReader.cc.

xmlHeader

DOMDocument* lhef::LHEReader::XMLHandler::xmlHeader

private

Definition at line 135 of file LHEReader.cc.

xmlNodes

std::vector<DOMElement *> lhef::LHEReader::XMLHandler::xmlNodes

private

Definition at line 137 of file LHEReader.cc.