XMLEventWriter Class Reference

#include <XMLEventWriter.h>

Inheritance diagram for XMLEventWriter:

Public Member Functions
void	addProcesorData (std::string key, boost::property_tree::ptree &procDataTree) override
void	endJob () override
void	observeEventBegin (const edm::Event &iEvent) override
void	observeEventEnd (const edm::Event &iEvent, std::unique_ptr< l1t::RegionalMuonCandBxCollection > &finalCandidates) override
void	observeProcesorBegin (unsigned int iProcessor, l1t::tftype mtfType) override
void	observeProcesorEmulation (unsigned int iProcessor, l1t::tftype mtfType, const std::shared_ptr< OMTFinput > &input, const AlgoMuons &algoCandidates, const AlgoMuons &gbCandidates, const std::vector< l1t::RegionalMuonCand > &candMuons) override
	XMLEventWriter (const OMTFConfiguration *aOMTFConfig, std::string fName)
	~XMLEventWriter () override
Public Member Functions inherited from IOMTFEmulationObserver
virtual void	beginRun (edm::EventSetup const &eventSetup)
	IOMTFEmulationObserver ()
virtual	~IOMTFEmulationObserver ()

Private Attributes
unsigned int	eventId = 0
unsigned int	eventNum = 0
boost::property_tree::ptree *	eventTree = nullptr
std::string	fName
const OMTFConfiguration *	omtfConfig
boost::property_tree::ptree	procTree
boost::property_tree::ptree	tree

Detailed Description

Definition at line 22 of file XMLEventWriter.h.

Constructor & Destructor Documentation

XMLEventWriter()

XMLEventWriter::XMLEventWriter	(	const OMTFConfiguration *	aOMTFConfig,
		std::string	fName
	)

Definition at line 21 of file XMLEventWriter.cc.

References eventNum, OMTFConfiguration::patternsVersion(), and BeamSplash_cfg::version.

    : omtfConfig(aOMTFConfig), fName(fName) {
  //std::string fName = "OMTF";
  eventNum = 0;

  unsigned int version = aOMTFConfig->patternsVersion();
  const unsigned int mask16bits = 0xFFFF;

  version &= mask16bits;

  std::ostringstream stringStr;
  stringStr.str("");
  stringStr << "0x" << std::hex << std::setfill('0') << std::setw(4) << version;

  tree.put("OMTF.<xmlattr>.version", stringStr.str());
};

~XMLEventWriter()

XMLEventWriter::~XMLEventWriter ( )

override

Definition at line 38 of file XMLEventWriter.cc.

{}

Member Function Documentation

addProcesorData()

void XMLEventWriter::addProcesorData ( std::string  key, boost::property_tree::ptree &  procDataTree  )

inlineoverridevirtual

Reimplemented from IOMTFEmulationObserver.

Definition at line 30 of file XMLEventWriter.h.

References submitPVResolutionJobs::key, and procTree.

                                                                                      {
    procTree.add_child(key, procDataTree);
  }

endJob()

void XMLEventWriter::endJob ( void  )

overridevirtual

Implements IOMTFEmulationObserver.

Definition at line 222 of file XMLEventWriter.cc.

References fName, and MCScenario_CRAFT1_22X::write_xml().

                            {
  edm::LogInfo("l1tOmtfEventPrint") << "XMLEventWriter::endJob() - writing the data to the xml - starting";
  boost::property_tree::write_xml(
      fName, tree, std::locale(), boost::property_tree::xml_parser::xml_writer_make_settings<std::string>(' ', 2));
  edm::LogInfo("l1tOmtfEventPrint") << "XMLEventWriter::endJob() - writing the data to the xml - done";
}

observeEventBegin()

void XMLEventWriter::observeEventBegin ( const edm::Event &  iEvent )

overridevirtual

Reimplemented from IOMTFEmulationObserver.

Definition at line 204 of file XMLEventWriter.cc.

References eventId, eventNum, eventTree, and iEvent.

                                                             {
  eventNum++;
  if (eventNum > 5000)
    //due to some bug if more events is written the memory consumption s very big and program crashes
    return;
  //currentElement = xmlWriter.writeEventHeader(iEvent.id().event());
  eventId = iEvent.id().event();

  eventTree = &(tree.add("OMTF.Event", ""));
  eventTree->add("<xmlattr>.iEvent", eventId);

  eventTree = &(eventTree->add("bx", ""));
  eventTree->add("<xmlattr>.iBx", 2 * eventId);
}

observeEventEnd()

void XMLEventWriter::observeEventEnd ( const edm::Event &  iEvent, std::unique_ptr< l1t::RegionalMuonCandBxCollection > &  finalCandidates  )

overridevirtual

Reimplemented from IOMTFEmulationObserver.

Definition at line 219 of file XMLEventWriter.cc.

                                                                                                      {}

observeProcesorBegin()

void XMLEventWriter::observeProcesorBegin ( unsigned int  iProcessor, l1t::tftype  mtfType  )

overridevirtual

Reimplemented from IOMTFEmulationObserver.

Definition at line 40 of file XMLEventWriter.cc.

References makeMuonMisalignmentScenario::endcap, eventNum, OmtfName::name(), l1t::omtf_neg, l1t::omtf_pos, omtfConfig, OmtfName::position(), and procTree.

                                                                                    {
  if (eventNum > 5000)
    return;

  procTree.clear();

  int endcap = (mtfType == l1t::omtf_neg) ? -1 : ((mtfType == l1t::omtf_pos) ? +1 : 0);
  OmtfName board(iProcessor, endcap, omtfConfig);
  procTree.add("<xmlattr>.board", board.name());
  procTree.add("<xmlattr>.iProcessor", iProcessor);

  std::ostringstream stringStr;
  stringStr << (board.position() == 1 ? "+" : "") << board.position();
  procTree.add("<xmlattr>.position", stringStr.str());
}

observeProcesorEmulation()

void XMLEventWriter::observeProcesorEmulation ( unsigned int  iProcessor, l1t::tftype  mtfType, const std::shared_ptr< OMTFinput > &  input, const AlgoMuons &  algoCandidates, const AlgoMuons &  gbCandidates, const std::vector< l1t::RegionalMuonCand > &  candMuons  )

overridevirtual

Dump only regions, where a candidate was found

Implements IOMTFEmulationObserver.

Definition at line 56 of file XMLEventWriter.cc.

References makeMuonMisalignmentScenario::endcap, eventNum, eventTree, input, OMTFConfiguration::nLayers(), OMTFConfiguration::nPhiBins(), l1t::omtf_neg, l1t::omtf_pos, omtfConfig, and procTree.

                                                                                               {
  if (eventNum > 5000)
    return;

  int endcap = (mtfType == l1t::omtf_neg) ? -1 : ((mtfType == l1t::omtf_pos) ? +1 : 0);
  OmtfName board(iProcessor, endcap, omtfConfig);

  if (candMuons.empty())
    return;

  for (unsigned int iLayer = 0; iLayer < omtfConfig->nLayers(); ++iLayer) {
    boost::property_tree::ptree layerTree;

    for (unsigned int iHit = 0; iHit < input->getMuonStubs()[iLayer].size(); ++iHit) {
      int hitPhi = input->getPhiHw(iLayer, iHit);
      if (hitPhi >= (int)omtfConfig->nPhiBins())
        continue;

      auto& hitTree = layerTree.add("Hit", "");

      hitTree.add("<xmlattr>.iInput", iHit);
      hitTree.add("<xmlattr>.iEta", input->getHitEta(iLayer, iHit));
      hitTree.add("<xmlattr>.iPhi", hitPhi);

      //in the firmware the hit quality is taken from link data only for the DT stubs
      //for the CSC and RPC 1 means the hit is valid, 0 - not.
      //in the input it is still worth to have the actual quality of the CSC and RPC
      //Because it might be used in the neural network
      if (iLayer >= 6)
        hitTree.add("<xmlattr>.iQual", 1);
      else
        hitTree.add("<xmlattr>.iQual", input->getHitQual(iLayer, iHit));
    }

    if (!layerTree.empty()) {
      layerTree.add("<xmlattr>.iLayer", iLayer);
      procTree.add_child("Layer", layerTree);
    }
  }

  for (auto& algoCand : algoCandidates) {
    if (algoCand->isValid()) {
      auto& algoMuonTree = procTree.add("AlgoMuon", "");
      algoMuonTree.add("<xmlattr>.charge", algoCand->getChargeConstr());
      algoMuonTree.add("<xmlattr>.disc", algoCand->getDisc());
      algoMuonTree.add("<xmlattr>.pdfSumConstr", algoCand->getGpResultConstr().getPdfSum());
      algoMuonTree.add("<xmlattr>.pdfSumUnconstr", algoCand->getGpResultUnconstr().getPdfSumUnconstr());
      algoMuonTree.add("<xmlattr>.etaCode", algoCand->getEtaHw());
      algoMuonTree.add("<xmlattr>.iRefHit", algoCand->getRefHitNumber());
      algoMuonTree.add("<xmlattr>.iRefLayer", algoCand->getRefLayer());

      //algoMuonTree.add("<xmlattr>.layers", std::bitset<18>(algoCand->getFiredLayerBits()));

      algoMuonTree.add("<xmlattr>.layersConstr", std::bitset<18>(algoCand->getGpResultConstr().getFiredLayerBits()));
      algoMuonTree.add("<xmlattr>.layersUnconstr",
                       std::bitset<18>(algoCand->getGpResultUnconstr().getFiredLayerBits()));

      algoMuonTree.add("<xmlattr>.nHits", algoCand->getQ());

      algoMuonTree.add("<xmlattr>.firedCntConstr", algoCand->getGpResultConstr().getFiredLayerCnt());
      algoMuonTree.add("<xmlattr>.firedCntUnconstr", algoCand->getGpResultUnconstr().getFiredLayerCnt());

      algoMuonTree.add("<xmlattr>.patNumConstr", algoCand->getHwPatternNumConstr());
      algoMuonTree.add("<xmlattr>.patNumUnconstr", algoCand->getHwPatternNumUnconstr());

      algoMuonTree.add("<xmlattr>.phiCode", algoCand->getPhi());

      algoMuonTree.add("<xmlattr>.phiConstr", algoCand->getGpResultConstr().getPhi());
      algoMuonTree.add("<xmlattr>.phiUnConstr", algoCand->getGpResultUnconstr().getPhi());

      algoMuonTree.add("<xmlattr>.phiRHit", algoCand->getPhiRHit());

      //in the firmware, the algoMuon has no pt nor upt yet,
      //only the pattern number, which is converted to the hwpt in the ghostbuster
      algoMuonTree.add("<xmlattr>.ptCodeConstr", algoCand->getPtConstr());
      algoMuonTree.add("<xmlattr>.ptCodeUnconstr", algoCand->getPtUnconstr());

      auto& gpResultTree = algoMuonTree.add("gpResultConstr", "");
      auto& gpResultConstr = algoCand->getGpResultConstr();

      gpResultTree.add("<xmlattr>.patNum", algoCand->getHwPatternNumConstr());
      gpResultTree.add("<xmlattr>.pdfSum", gpResultConstr.getPdfSum());

      for (unsigned int iLogicLayer = 0; iLogicLayer < gpResultConstr.getStubResults().size(); ++iLogicLayer) {
        auto& layerTree = gpResultTree.add("layer", "");
        layerTree.add("<xmlattr>.num", iLogicLayer);
        auto pdfBin = gpResultConstr.getStubResults()[iLogicLayer].getPdfBin();
        if (pdfBin == 5400)
          pdfBin = 0;
        layerTree.add("<xmlattr>.pdfBin", pdfBin);
        layerTree.add("<xmlattr>.pdfVal", gpResultConstr.getStubResults()[iLogicLayer].getPdfVal());
        layerTree.add("<xmlattr>.fired", gpResultConstr.isLayerFired(iLogicLayer));
      }

      if (algoCand->getGpResultUnconstr().isValid()) {
        auto& gpResultTree = algoMuonTree.add("gpResultUnconstr", "");
        auto& gpResult = algoCand->getGpResultUnconstr();

        gpResultTree.add("<xmlattr>.patNum", algoCand->getHwPatternNumUnconstr());
        gpResultTree.add("<xmlattr>.pdfSum", gpResult.getPdfSumUnconstr());

        for (unsigned int iLogicLayer = 0; iLogicLayer < gpResult.getStubResults().size(); ++iLogicLayer) {
          auto& layerTree = gpResultTree.add("layer", "");
          layerTree.add("<xmlattr>.num", iLogicLayer);
          auto pdfBin = gpResult.getStubResults()[iLogicLayer].getPdfBin();
          if (pdfBin == 5400)
            pdfBin = 0;
          layerTree.add("<xmlattr>.pdfBin", pdfBin);
          layerTree.add("<xmlattr>.pdfVal", gpResult.getStubResults()[iLogicLayer].getPdfVal());
          layerTree.add("<xmlattr>.fired", gpResult.isLayerFired(iLogicLayer));
        }
      }
    }
  }

  for (auto& candMuon : candMuons) {
    auto& candMuonTree = procTree.add("CandMuon", "");
    candMuonTree.add("<xmlattr>.hwEta", candMuon.hwEta());
    candMuonTree.add("<xmlattr>.hwPhi", candMuon.hwPhi());
    candMuonTree.add("<xmlattr>.hwPt", candMuon.hwPt());
    candMuonTree.add("<xmlattr>.hwUPt", candMuon.hwPtUnconstrained());
    candMuonTree.add("<xmlattr>.hwQual", candMuon.hwQual());
    candMuonTree.add("<xmlattr>.hwSign", candMuon.hwSign());
    candMuonTree.add("<xmlattr>.hwSignValid", candMuon.hwSignValid());
    candMuonTree.add("<xmlattr>.hwTrackAddress", std::bitset<29>(candMuon.trackAddress().at(0)));
    candMuonTree.add("<xmlattr>.link", candMuon.link());
    candMuonTree.add("<xmlattr>.processor", candMuon.processor());

    std::ostringstream stringStr;
    if (candMuon.trackFinderType() == l1t::omtf_neg)
      stringStr << "OMTF_NEG";
    else if (candMuon.trackFinderType() == l1t::omtf_pos)
      stringStr << "OMTF_POS";
    else
      stringStr << candMuon.trackFinderType();
    candMuonTree.add("<xmlattr>.trackFinderType", stringStr.str());
  }

  if (!procTree.empty())
    eventTree->add_child("Processor", procTree);
}

Member Data Documentation

eventId

unsigned int XMLEventWriter::eventId = 0

private

Definition at line 61 of file XMLEventWriter.h.

Referenced by ntupleDataFormat.Event::eventIdStr(), and observeEventBegin().

eventNum

unsigned int XMLEventWriter::eventNum = 0

private

Definition at line 59 of file XMLEventWriter.h.

Referenced by observeEventBegin(), observeProcesorBegin(), observeProcesorEmulation(), and XMLEventWriter().

eventTree

boost::property_tree::ptree* XMLEventWriter::eventTree = nullptr

private

Definition at line 53 of file XMLEventWriter.h.

Referenced by observeEventBegin(), and observeProcesorEmulation().

fName

std::string XMLEventWriter::fName

private

Definition at line 57 of file XMLEventWriter.h.

Referenced by endJob().

omtfConfig

const OMTFConfiguration* XMLEventWriter::omtfConfig

private

Definition at line 49 of file XMLEventWriter.h.

Referenced by observeProcesorBegin(), and observeProcesorEmulation().

procTree

boost::property_tree::ptree XMLEventWriter::procTree

private

Definition at line 55 of file XMLEventWriter.h.

Referenced by addProcesorData(), observeProcesorBegin(), and observeProcesorEmulation().

tree

boost::property_tree::ptree XMLEventWriter::tree

private

Definition at line 51 of file XMLEventWriter.h.

Referenced by eventstfile.Events::__iter__(), svgfig.SVG::__str__(), ZJetsTreeAnalyzer.ZJetsTreeAnalyzer::beginLoop(), tree.Tree::branch_(), MetTreeProducer.MetTreeProducer::declareVariables(), core.AutoFillTreeProducer.AutoFillTreeProducer::declareVariables(), core.AutoFillTreeProducer.AutoFillTreeProducer::fillTree(), SimpleTreeProducer.SimpleTreeProducer::process(), ZJetsTreeAnalyzer.ZJetsTreeAnalyzer::process(), MetTreeProducer.MetTreeProducer::process(), python.cmstools.EventTree::SetAlias(), eventstfile.Events::size(), eventstfile.Events::to(), tree.Tree::var(), and tree.Tree::vector().