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
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 98 of file LHEReader.cc.

Member Typedef Documentation

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

Definition at line 100 of file LHEReader.cc.

Member Enumeration Documentation

enum lhef::LHEReader::XMLHandler::Object

Enumerator
kNone
kHeader
kInit
kComment
kEvent

Definition at line 109 of file LHEReader.cc.

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

Constructor & Destructor Documentation

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

inline

Definition at line 101 of file LHEReader.cc.

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

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

inlineoverride

Definition at line 105 of file LHEReader.cc.

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

Member Function Documentation

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

overrideprotected

Definition at line 407 of file LHEReader.cc.

References edmScanValgrind::buffer, data, Exception, lhef::XMLSimpleStr::isAllSpaces(), lhef::XMLSimpleStr::isSpace(), WDecay::kNone, ALCARECOPromptCalibProdSiPixelAli0T_cff::mode, PFRecoTauDiscriminationByIsolation_cfi::offset, and RecoTauValidation_cfi::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);
}

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

overrideprotected

Definition at line 440 of file LHEReader.cc.

References comment, data, lhef::fillHeader(), RecoTauValidation_cfi::header, 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);
}

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

overrideprotected

Definition at line 295 of file LHEReader.cc.

References edmScanValgrind::buffer, data, HTMLExport::elem(), Exception, lhef::fillHeader(), RecoTauValidation_cfi::header, WDecay::kNone, ALCARECOPromptCalibProdSiPixelAli0T_cff::mode, dataset::name, AlCaHLTBitMon_ParallelJobs::p, lumiQueryAPI::q, AlCaHLTBitMon_QueryRunRegistry::string, mps_merge::weight, and cscNeutronWriter_cfi::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;
  }
}

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

inline

Definition at line 117 of file LHEReader.cc.

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

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

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

overrideprotected

Definition at line 185 of file LHEReader.cc.

References lhef::attributesToDom(), edmScanValgrind::buffer, HTMLExport::elem(), Exception, WDecay::kNone, ALCARECOPromptCalibProdSiPixelAli0T_cff::mode, dataset::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);
      }
    }
    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();
}

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

inline

Definition at line 124 of file LHEReader.cc.

References comment.

{return weightsinevent;}

Friends And Related Function Documentation

friend class LHEReader

friend

Definition at line 140 of file LHEReader.cc.

Member Data Documentation

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

private

Definition at line 144 of file LHEReader.cc.

Object lhef::LHEReader::XMLHandler::gotObject

private

Definition at line 145 of file LHEReader.cc.

bool lhef::LHEReader::XMLHandler::headerOk

private

Definition at line 150 of file LHEReader.cc.

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

private

Definition at line 151 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().

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

private

Definition at line 143 of file LHEReader.cc.

Object lhef::LHEReader::XMLHandler::mode

private

Definition at line 146 of file LHEReader.cc.

int lhef::LHEReader::XMLHandler::npLO

private

Definition at line 153 of file LHEReader.cc.

int lhef::LHEReader::XMLHandler::npNLO

private

Definition at line 154 of file LHEReader.cc.

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

private

Definition at line 155 of file LHEReader.cc.

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

private

Definition at line 142 of file LHEReader.cc.

wgt_info lhef::LHEReader::XMLHandler::weightsinevent

private

Definition at line 152 of file LHEReader.cc.

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

private

Definition at line 148 of file LHEReader.cc.

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

private

Definition at line 149 of file LHEReader.cc.

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

private

Definition at line 147 of file LHEReader.cc.

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

private

Definition at line 149 of file LHEReader.cc.