src/Omtf/XMLEventWriter.cc

0001 /*
0002  * XMLEventWriter.cc
0003  *
0004  *  Created on: Oct 12, 2017
0005  *      Author: kbunkow
0006  */
0007
0008 #include "DataFormats/Provenance/interface/EventID.h"
0009 #include "FWCore/Common/interface/EventBase.h"
0010 #include "FWCore/Framework/interface/Event.h"
0011 #include "L1Trigger/L1TMuonOverlapPhase1/interface/Omtf/OmtfName.h"
0012 #include "L1Trigger/L1TMuonOverlapPhase1/interface/Omtf/OMTFinput.h"
0013 #include "L1Trigger/L1TMuonOverlapPhase1/interface/Omtf/XMLEventWriter.h"
0014
0015 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0016
0017 #include <boost/property_tree/xml_parser.hpp>
0018
0019 #include <bitset>
0020
0021 XMLEventWriter::XMLEventWriter(const OMTFConfiguration* aOMTFConfig, std::string fName)
0022     : omtfConfig(aOMTFConfig), fName(fName) {
0023   //std::string fName = "OMTF";
0024   eventNum = 0;
0025
0026   unsigned int version = aOMTFConfig->patternsVersion();
0027   const unsigned int mask16bits = 0xFFFF;
0028
0029   version &= mask16bits;
0030
0031   std::ostringstream stringStr;
0032   stringStr.str("");
0033   stringStr << "0x" << std::hex << std::setfill('0') << std::setw(4) << version;
0034
0035   tree.put("OMTF.<xmlattr>.version", stringStr.str());
0036 };
0037
0038 XMLEventWriter::~XMLEventWriter() {}
0039
0040 void XMLEventWriter::observeProcesorBegin(unsigned int iProcessor, l1t::tftype mtfType) {
0041   procTree.clear();
0042
0043   int endcap = (mtfType == l1t::omtf_neg) ? -1 : ((mtfType == l1t::omtf_pos) ? +1 : 0);
0044   OmtfName board(iProcessor, endcap, omtfConfig);
0045   procTree.add("<xmlattr>.board", board.name());
0046   procTree.add("<xmlattr>.iProcessor", iProcessor);
0047
0048   std::ostringstream stringStr;
0049   stringStr << (board.position() == 1 ? "+" : "") << board.position();
0050   procTree.add("<xmlattr>.position", stringStr.str());
0051 }
0052
0053 void XMLEventWriter::observeProcesorEmulation(unsigned int iProcessor,
0054                                               l1t::tftype mtfType,
0055                                               const std::shared_ptr<OMTFinput>& input,
0056                                               const AlgoMuons& algoCandidates,
0057                                               const AlgoMuons& gbCandidates,
0058                                               const std::vector<l1t::RegionalMuonCand>& candMuons) {
0059   int endcap = (mtfType == l1t::omtf_neg) ? -1 : ((mtfType == l1t::omtf_pos) ? +1 : 0);
0060   OmtfName board(iProcessor, endcap, omtfConfig);
0061
0062   if (candMuons.empty())
0063     return;
0064
0065   for (unsigned int iLayer = 0; iLayer < omtfConfig->nLayers(); ++iLayer) {
0066     boost::property_tree::ptree layerTree;
0067
0068     for (unsigned int iHit = 0; iHit < input->getMuonStubs()[iLayer].size(); ++iHit) {
0069       int hitPhi = input->getPhiHw(iLayer, iHit);
0070       if (hitPhi >= (int)omtfConfig->nPhiBins())
0071         continue;
0072
0073       auto& hitTree = layerTree.add("Hit", "");
0074
0075       hitTree.add("<xmlattr>.iInput", iHit);
0076       hitTree.add("<xmlattr>.iEta", input->getHitEta(iLayer, iHit));
0077       hitTree.add("<xmlattr>.iPhi", hitPhi);
0078
0079       //in the firmware the hit quality is taken from link data only for the DT stubs
0080       //for the CSC and RPC 1 means the hit is valid, 0 - not.
0081       //in the input it is still worth to have the actual quality of the CSC and RPC
0082       //Because it might be used in the neural network
0083       if (iLayer >= 6)
0084         hitTree.add("<xmlattr>.iQual", 1);
0085       else
0086         hitTree.add("<xmlattr>.iQual", input->getHitQual(iLayer, iHit));
0087     }
0088
0089     if (!layerTree.empty()) {
0090       layerTree.add("<xmlattr>.iLayer", iLayer);
0091       procTree.add_child("Layer", layerTree);
0092     }
0093   }
0094
0095   for (auto& algoCand : algoCandidates) {
0096     ///Dump only regions, where a candidate was found
0097     if (algoCand->isValid()) {
0098       auto& algoMuonTree = procTree.add("AlgoMuon", "");
0099       algoMuonTree.add("<xmlattr>.charge", algoCand->getChargeConstr());
0100       algoMuonTree.add("<xmlattr>.disc", algoCand->getDisc());
0101       algoMuonTree.add("<xmlattr>.pdfSumConstr", algoCand->getGpResultConstr().getPdfSum());
0102       algoMuonTree.add("<xmlattr>.pdfSumUnconstr", algoCand->getGpResultUnconstr().getPdfSumUnconstr());
0103       algoMuonTree.add("<xmlattr>.etaCode", algoCand->getEtaHw());
0104       algoMuonTree.add("<xmlattr>.iRefHit", algoCand->getRefHitNumber());
0105       algoMuonTree.add("<xmlattr>.iRefLayer", algoCand->getRefLayer());
0106
0107       //algoMuonTree.add("<xmlattr>.layers", std::bitset<18>(algoCand->getFiredLayerBits()));
0108
0109       algoMuonTree.add("<xmlattr>.layersConstr", std::bitset<18>(algoCand->getGpResultConstr().getFiredLayerBits()));
0110       algoMuonTree.add("<xmlattr>.layersUnconstr",
0111                        std::bitset<18>(algoCand->getGpResultUnconstr().getFiredLayerBits()));
0112
0113       algoMuonTree.add("<xmlattr>.nHits", algoCand->getQ());
0114
0115       algoMuonTree.add("<xmlattr>.firedCntConstr", algoCand->getGpResultConstr().getFiredLayerCnt());
0116       algoMuonTree.add("<xmlattr>.firedCntUnconstr", algoCand->getGpResultUnconstr().getFiredLayerCnt());
0117
0118       algoMuonTree.add("<xmlattr>.patNumConstr", algoCand->getHwPatternNumConstr());
0119       algoMuonTree.add("<xmlattr>.patNumUnconstr", algoCand->getHwPatternNumUnconstr());
0120
0121       algoMuonTree.add("<xmlattr>.phiCode", algoCand->getPhi());
0122
0123       algoMuonTree.add("<xmlattr>.phiConstr", algoCand->getGpResultConstr().getPhi());
0124       algoMuonTree.add("<xmlattr>.phiUnConstr", algoCand->getGpResultUnconstr().getPhi());
0125
0126       algoMuonTree.add("<xmlattr>.phiRHit", algoCand->getPhiRHit());
0127
0128       //in the firmware, the algoMuon has no pt nor upt yet,
0129       //only the pattern number, which is converted to the hwpt in the ghostbuster
0130       algoMuonTree.add("<xmlattr>.ptCodeConstr", algoCand->getPtConstr());
0131       algoMuonTree.add("<xmlattr>.ptCodeUnconstr", algoCand->getPtUnconstr());
0132
0133       auto& gpResultTree = algoMuonTree.add("gpResultConstr", "");
0134       auto& gpResultConstr = algoCand->getGpResultConstr();
0135
0136       gpResultTree.add("<xmlattr>.patNum", algoCand->getHwPatternNumConstr());
0137       gpResultTree.add("<xmlattr>.pdfSum", gpResultConstr.getPdfSum());
0138
0139       for (unsigned int iLogicLayer = 0; iLogicLayer < gpResultConstr.getStubResults().size(); ++iLogicLayer) {
0140         auto& layerTree = gpResultTree.add("layer", "");
0141         layerTree.add("<xmlattr>.num", iLogicLayer);
0142         auto pdfBin = gpResultConstr.getStubResults()[iLogicLayer].getPdfBin();
0143         if (pdfBin == 5400)
0144           pdfBin = 0;
0145         layerTree.add("<xmlattr>.pdfBin", pdfBin);
0146         layerTree.add("<xmlattr>.pdfVal", gpResultConstr.getStubResults()[iLogicLayer].getPdfVal());
0147         layerTree.add("<xmlattr>.fired", gpResultConstr.isLayerFired(iLogicLayer));
0148       }
0149
0150       if (algoCand->getGpResultUnconstr().isValid()) {
0151         auto& gpResultTree = algoMuonTree.add("gpResultUnconstr", "");
0152         auto& gpResult = algoCand->getGpResultUnconstr();
0153
0154         gpResultTree.add("<xmlattr>.patNum", algoCand->getHwPatternNumUnconstr());
0155         gpResultTree.add("<xmlattr>.pdfSum", gpResult.getPdfSumUnconstr());
0156
0157         for (unsigned int iLogicLayer = 0; iLogicLayer < gpResult.getStubResults().size(); ++iLogicLayer) {
0158           auto& layerTree = gpResultTree.add("layer", "");
0159           layerTree.add("<xmlattr>.num", iLogicLayer);
0160           auto pdfBin = gpResult.getStubResults()[iLogicLayer].getPdfBin();
0161           if (pdfBin == 5400)
0162             pdfBin = 0;
0163           layerTree.add("<xmlattr>.pdfBin", pdfBin);
0164           layerTree.add("<xmlattr>.pdfVal", gpResult.getStubResults()[iLogicLayer].getPdfVal());
0165           layerTree.add("<xmlattr>.fired", gpResult.isLayerFired(iLogicLayer));
0166         }
0167       }
0168     }
0169   }
0170
0171   for (auto& candMuon : candMuons) {
0172     auto& candMuonTree = procTree.add("CandMuon", "");
0173     candMuonTree.add("<xmlattr>.hwEta", candMuon.hwEta());
0174     candMuonTree.add("<xmlattr>.hwPhi", candMuon.hwPhi());
0175     candMuonTree.add("<xmlattr>.hwPt", candMuon.hwPt());
0176     candMuonTree.add("<xmlattr>.hwUPt", candMuon.hwPtUnconstrained());
0177     candMuonTree.add("<xmlattr>.hwQual", candMuon.hwQual());
0178     candMuonTree.add("<xmlattr>.hwSign", candMuon.hwSign());
0179     candMuonTree.add("<xmlattr>.hwSignValid", candMuon.hwSignValid());
0180     candMuonTree.add("<xmlattr>.hwTrackAddress", std::bitset<29>(candMuon.trackAddress().at(0)));
0181     candMuonTree.add("<xmlattr>.link", candMuon.link());
0182     candMuonTree.add("<xmlattr>.processor", candMuon.processor());
0183
0184     std::ostringstream stringStr;
0185     if (candMuon.trackFinderType() == l1t::omtf_neg)
0186       stringStr << "OMTF_NEG";
0187     else if (candMuon.trackFinderType() == l1t::omtf_pos)
0188       stringStr << "OMTF_POS";
0189     else
0190       stringStr << candMuon.trackFinderType();
0191     candMuonTree.add("<xmlattr>.trackFinderType", stringStr.str());
0192   }
0193
0194   if (!procTree.empty())
0195     eventTree->add_child("Processor", procTree);
0196 }
0197
0198 void XMLEventWriter::observeEventBegin(const edm::Event& iEvent) {
0199   eventNum++;
0200   eventId = iEvent.id().event();
0201
0202   eventTree = &(tree.add("OMTF.Event", ""));
0203   eventTree->add("<xmlattr>.iEvent", eventId);
0204
0205   eventTree = &(eventTree->add("bx", ""));
0206   eventTree->add("<xmlattr>.iBx", 2 * eventId);
0207 }
0208
0209 void XMLEventWriter::observeEventEnd(const edm::Event& iEvent,
0210                                      std::unique_ptr<l1t::RegionalMuonCandBxCollection>& finalCandidates) {}
0211
0212 void XMLEventWriter::endJob() {
0213   edm::LogInfo("l1tOmtfEventPrint") << "XMLEventWriter::endJob() - writing the data to the xml - starting";
0214   boost::property_tree::write_xml(
0215       fName, tree, std::locale(), boost::property_tree::xml_parser::xml_writer_make_settings<std::string>(' ', 2));
0216   edm::LogInfo("l1tOmtfEventPrint") << "XMLEventWriter::endJob() - writing the data to the xml - done";
0217 }