MuonsGrabber Class Reference

#include <L1Trigger/RPCTrigger/interface/MuonsGrabber.h>

Public Member Functions
void	addMuon (RPCTBMuon &mu, int lvl, int region, int hs, int index)
void	setRPCBasicTrigConfig (RPCBasicTrigConfig *c)
void	startNewEvent (int event, int bx)
void	writeDataForRelativeBX (int bx)

Static Public Member Functions
static MuonsGrabber &	Instance ()

Private Member Functions
std::string	IntToString (int i)
	MuonsGrabber ()
	MuonsGrabber (const MuonsGrabber &)=delete
const MuonsGrabber &	operator= (const MuonsGrabber &)=delete
virtual	~MuonsGrabber ()

Private Attributes
int	m_currentBX
int	m_currentEvent
XERCES_CPP_NAMESPACE::DOMElement *	m_currEvent
XERCES_CPP_NAMESPACE::DOMDocument *	m_doc
XERCES_CPP_NAMESPACE::DOMImplementation *	m_dom
std::vector< RPCMuonExtraStruct >	m_muons
XERCES_CPP_NAMESPACE::DOMElement *	m_rootElem
RPCBasicTrigConfig *	m_trigConfig

Detailed Description

Description: <one line="" class="" summary>="">

Usage: <usage>

Definition at line 50 of file MuonsGrabber.h.

Constructor & Destructor Documentation

MuonsGrabber() [1/2]

MuonsGrabber::MuonsGrabber ( )

private

Definition at line 56 of file MuonsGrabber.cc.

                           {
  try {
    cms::concurrency::xercesInitialize();
  } catch (const XMLException& toCatch) {
    throw std::string("Error during Xerces-c Initialization: " +
                      std::string(XMLString::transcode(toCatch.getMessage())));
  }
 
  m_dom = DOMImplementationRegistry::getDOMImplementation(X("Core"));
  if (m_dom == nullptr)
    throw cms::Exception("RPCMuonsGrabber") << "Cannot get DOM" << std::endl;
 
  m_doc = m_dom->createDocument(nullptr,              // root element namespace URI.
                                X("rpctDataStream"),  // root element name
                                nullptr);             // document type object (DTD).
 
  m_rootElem = m_doc->getDocumentElement();
 
  m_currEvent = nullptr;
}

References Exception, m_currEvent, m_doc, m_dom, m_rootElem, AlCaHLTBitMon_QueryRunRegistry::string, X, and cms::concurrency::xercesInitialize().

~MuonsGrabber()

MuonsGrabber::~MuonsGrabber ( )

privatevirtual

Definition at line 82 of file MuonsGrabber.cc.

                            {
  // save xmlfile
  XMLCh tempStr[100];
  XMLString::transcode("LS", tempStr, 99);
  DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(tempStr);
  DOMLSSerializer* theSerializer = ((DOMImplementationLS*)impl)->createLSSerializer();
  DOMConfiguration* dc = theSerializer->getDomConfig();
  dc->setParameter(XMLUni::fgDOMWRTFormatPrettyPrint, true);
  DOMLSOutput* outputDesc = ((DOMImplementationLS*)impl)->createLSOutput();
  outputDesc->setEncoding(X("UTF-8"));
 
  XMLFormatTarget* myFormTarget = new LocalFileFormatTarget(X("testpulses.xml"));
  outputDesc->setByteStream(myFormTarget);
  DOMNode* xmlstylesheet =
      m_doc->createProcessingInstruction(X("xml-stylesheet"), X("type=\"text/xsl\"href=\"default.xsl\""));
 
  m_doc->insertBefore(xmlstylesheet, m_rootElem);
  theSerializer->write(m_doc, outputDesc);
 
  delete theSerializer;
  delete myFormTarget;
  m_doc->release();
  cms::concurrency::xercesTerminate();
}

References m_doc, m_rootElem, X, and cms::concurrency::xercesTerminate().

MuonsGrabber() [2/2]

MuonsGrabber::MuonsGrabber ( const MuonsGrabber &  )

privatedelete

Member Function Documentation

addMuon()

void MuonsGrabber::addMuon	(	RPCTBMuon &	mu,
		int	lvl,
		int	region,
		int	hs,
		int	index
	)

Definition at line 118 of file MuonsGrabber.cc.

                                                                                {
  if (mu.getPtCode() > 0)
    m_muons.push_back(RPCMuonExtraStruct(lvl, region, hs, index, mu));
}

References m_muons, amptDefaultParameters_cff::mu, and HLT_2018_cff::region.

Referenced by RPCHalfSorter::run(), RPCFinalSorter::run(), RPCTriggerBoard::runCone(), RPCPacTrigger::runEvent(), and RPCTriggerCrate::runTCGBSorter().

Instance()

MuonsGrabber & MuonsGrabber::Instance ( )

static

Definition at line 48 of file MuonsGrabber.cc.

                                     {
  static MuonsGrabber grabber;
  return grabber;
}

Referenced by RPCTrigger::produce(), RPCHalfSorter::run(), RPCFinalSorter::run(), RPCTriggerBoard::runCone(), RPCPacTrigger::runEvent(), and RPCTriggerCrate::runTCGBSorter().

IntToString()

std::string MuonsGrabber::IntToString ( int  i )

private

Definition at line 277 of file MuonsGrabber.cc.

                                         {
  std::stringstream ss;
  ss << i;
 
  return ss.str();
}

References mps_fire::i, and contentValuesCheck::ss.

Referenced by startNewEvent(), and writeDataForRelativeBX().

operator=()

const MuonsGrabber& MuonsGrabber::operator= ( const MuonsGrabber &  )

privatedelete

setRPCBasicTrigConfig()

void MuonsGrabber::setRPCBasicTrigConfig ( RPCBasicTrigConfig *  c )

inline

Definition at line 57 of file MuonsGrabber.h.

{ m_trigConfig = c; };

References HltBtagPostValidation_cff::c, and m_trigConfig.

Referenced by RPCTrigger::produce().

startNewEvent()

void MuonsGrabber::startNewEvent	(	int	event,
		int	bx
	)

Definition at line 107 of file MuonsGrabber.cc.

                                                  {
  //<event bx="0" num="0">
  m_currEvent = m_doc->createElement(X("event"));
  m_currEvent->setAttribute(X("num"), X(IntToString(event).c_str()));
  m_currEvent->setAttribute(X("bx"), X(IntToString(bx).c_str()));
  m_rootElem->appendChild(m_currEvent);
 
  m_currentEvent = event;
  m_currentBX = bx;
}

References l1GtPatternGenerator_cfi::bx, event(), IntToString(), m_currentBX, m_currentEvent, m_currEvent, m_doc, m_rootElem, and X.

Referenced by RPCTrigger::produce().

writeDataForRelativeBX()

void MuonsGrabber::writeDataForRelativeBX

(

int

bx

)

Definition at line 123 of file MuonsGrabber.cc.

                                                {
  if (m_muons.empty())
    return;
 
  //<bxData num="11">
  DOMElement* currRelBx = m_doc->createElement(X("bxData"));
  currRelBx->setAttribute(X("num"), X(IntToString(bx).c_str()));
  m_currEvent->appendChild(currRelBx);
 
  //std::cout << "Writing out for relBx "   << bx << std::endl;
 
  //   <hs num="1" be="0">
  // levels
  // 0 - PAC
  // 1 - tbgs
  // 2 - tcgs
  // 3 - hs
  // 4 fs
 
  std::sort(m_muons.begin(), m_muons.end(), RPCMuonExtraStruct::lvlCompare);
  for (int tcNum = 0; tcNum <= 11; ++tcNum) {
    DOMElement* tc = nullptr;
    DOMElement* tcgs = nullptr;
    for (int tbNum = 0; tbNum <= 10; ++tbNum) {  // check actual range, probably till 9 total
      DOMElement* tb = nullptr;
      DOMElement* tbgs = nullptr;
      for (int PAC = 0; PAC <= 4; ++PAC) {  // same here
 
        DOMElement* pac = nullptr;
        // for (int segment = 0; segment <= 11; ++segment ) {
        std::vector<RPCMuonExtraStruct>::iterator it = m_muons.begin();
        while (it != m_muons.end()) {
          int muSegment = it->_mu.getLogSegment();
          //if
 
          int muTBno = m_trigConfig->getTBNum(it->_mu.getConeCrdnts());
          int muPACChipNo = m_trigConfig->getTowerNumOnTb(it->_mu.getConeCrdnts());
          int muTC = m_trigConfig->getTCNum(it->_mu.getConeCrdnts());
 
          if (!((int(it->_level) == 0 && tbNum == muTBno && muTC == tcNum && PAC == muPACChipNo) ||
                (int(it->_level) == 1 && tbNum == muTBno && muTC == tcNum) || (int(it->_level) == 2 && muTC == tcNum)))
 
          {
            ++it;
            continue;
          }
          // std::cout << int(it->_level) << int(it->_region) << int(it->_hsHalf)
          //         << " " << int(it->_index)
          //       << " " << it->_mu.printDebugInfo(2) << std::endl;
 
          if (tc == nullptr) {
            tc = m_doc->createElement(X("tc"));
            currRelBx->appendChild(tc);
            tc->setAttribute(X("num"), X(IntToString(tcNum).c_str()));
 
            tcgs = m_doc->createElement(X("tcgs"));
            tc->appendChild(tcgs);
          }
          if (tb == nullptr && int(it->_level) <= 1) {
            tb = m_doc->createElement(X("tb"));
            tc->appendChild(tb);
            tb->setAttribute(X("num"), X(IntToString(tbNum).c_str()));
 
            tbgs = m_doc->createElement(X("tbgs"));
            tb->appendChild(tbgs);
          }
 
          if (pac == nullptr && int(it->_level) == 0) {
            pac = m_doc->createElement(X("pac"));
            tb->appendChild(pac);
            pac->setAttribute(X("num"), X(IntToString(muPACChipNo).c_str()));
          }
 
          DOMElement* mu = m_doc->createElement(X("mu"));
          mu->setAttribute(X("pt"), X(IntToString(int(it->_mu.getPtCode())).c_str()));
          mu->setAttribute(X("qual"), X(IntToString(int(it->_mu.getQuality())).c_str()));
          mu->setAttribute(X("sign"), X(IntToString(int(it->_mu.getSign())).c_str()));
 
          if (int(it->_level) == 0) {
            mu->setAttribute(X("num"), X(IntToString(muSegment).c_str()));
            pac->appendChild(mu);
          } else {
            mu->setAttribute(X("num"), X(IntToString(int(it->_index)).c_str()));
            mu->setAttribute(X("phi"), X(IntToString(int(it->_mu.getPhiAddr())).c_str()));
            mu->setAttribute(X("eta"), X(IntToString(int(it->_mu.getEtaAddr())).c_str()));
            mu->setAttribute(X("gbD"), X(IntToString(int(it->_mu.getGBData())).c_str()));
            if (int(it->_level) == 1) {
              tbgs->appendChild(mu);
            } else if (int(it->_level) == 2) {
              tcgs->appendChild(mu);
            } else {
              throw cms::Exception("RPCMuonsGrabber") << "xx Unexpected level" << std::endl;
            }
          }
 
          it = m_muons.erase(it);
 
        }  // muons iter
        // } // segment
      }  // PAC
    }    // TB
  }      // TC
 
  for (int level = 3; level <= 4; ++level) {
    for (int half = 0; half <= 1; ++half) {
      for (int be = 0; be <= 1; ++be) {  // brl/endcap
 
        std::vector<RPCMuonExtraStruct>::iterator it = m_muons.begin();
        DOMElement* hs = nullptr;
        while (it != m_muons.end()) {
          if ((int(it->_level) != level) || int(it->_hsHalf) != half || int(it->_region) != be) {
            ++it;
            continue;
          }
 
          if (hs == nullptr) {
            if (level == 3) {
              hs = m_doc->createElement(X("hs"));
              hs->setAttribute(X("num"), X(IntToString(half).c_str()));
            } else if (level == 4) {
              hs = m_doc->createElement(X("fs"));
            } else {  // shoudlnt get here
              throw cms::Exception("RPCMuonsGrabber") << "Problem writing out muons - lvl " << level << std::endl;
            }
            hs->setAttribute(X("be"), X(IntToString(be).c_str()));
            currRelBx->appendChild(hs);
          }
 
          DOMElement* mu = m_doc->createElement(X("mu"));
          hs->appendChild(mu);
          mu->setAttribute(X("num"), X(IntToString(int(it->_index)).c_str()));
          mu->setAttribute(X("pt"), X(IntToString(int(it->_mu.getPtCode())).c_str()));
          mu->setAttribute(X("qual"), X(IntToString(int(it->_mu.getQuality())).c_str()));
          mu->setAttribute(X("sign"), X(IntToString(int(it->_mu.getSign())).c_str()));
          mu->setAttribute(X("phi"), X(IntToString(int(it->_mu.getPhiAddr())).c_str()));
          mu->setAttribute(X("eta"), X(IntToString(int(it->_mu.getEtaAddr())).c_str()));
          mu->setAttribute(X("gbD"), X(IntToString(int(it->_mu.getGBData())).c_str()));
 
          //std::cout << int(it->_level) << int(it->_region) << int(it->_hsHalf)
          //   << " " << int(it->_index)
          //   << " " << it->_mu.printDebugInfo(2) << std::endl;
 
          it = m_muons.erase(it);
 
        }  // muons iter
      }    // be iter
    }      //half iteration
  }        // lvl iteration
 
  if (!m_muons.empty()) {
    throw cms::Exception("RPCMuonsGrabber") << " There are still some muons in muons vec" << std::endl;
  }
}

References cms::cuda::be, l1GtPatternGenerator_cfi::bx, Exception, RPCBasicTrigConfig::getTBNum(), RPCBasicTrigConfig::getTCNum(), RPCBasicTrigConfig::getTowerNumOnTb(), createfilelist::int, IntToString(), personalPlayback::level, RPCMuonExtraStruct::lvlCompare(), m_currEvent, m_doc, m_muons, m_trigConfig, amptDefaultParameters_cff::mu, and X.

Referenced by RPCTrigger::produce().

Member Data Documentation

m_currentBX

int MuonsGrabber::m_currentBX

private

Definition at line 75 of file MuonsGrabber.h.

Referenced by startNewEvent().

m_currentEvent

int MuonsGrabber::m_currentEvent

private

Definition at line 74 of file MuonsGrabber.h.

Referenced by startNewEvent().

m_currEvent

XERCES_CPP_NAMESPACE::DOMElement* MuonsGrabber::m_currEvent

private

Definition at line 79 of file MuonsGrabber.h.

Referenced by MuonsGrabber(), startNewEvent(), and writeDataForRelativeBX().

m_doc

XERCES_CPP_NAMESPACE::DOMDocument* MuonsGrabber::m_doc

private

Definition at line 77 of file MuonsGrabber.h.

Referenced by MuonsGrabber(), startNewEvent(), writeDataForRelativeBX(), and ~MuonsGrabber().

m_dom

XERCES_CPP_NAMESPACE::DOMImplementation* MuonsGrabber::m_dom

private

Definition at line 76 of file MuonsGrabber.h.

Referenced by MuonsGrabber().

m_muons

std::vector<RPCMuonExtraStruct> MuonsGrabber::m_muons

private

Definition at line 71 of file MuonsGrabber.h.

Referenced by addMuon(), and writeDataForRelativeBX().

m_rootElem

XERCES_CPP_NAMESPACE::DOMElement* MuonsGrabber::m_rootElem

private

Definition at line 78 of file MuonsGrabber.h.

Referenced by MuonsGrabber(), startNewEvent(), and ~MuonsGrabber().

m_trigConfig

RPCBasicTrigConfig* MuonsGrabber::m_trigConfig

private

Definition at line 72 of file MuonsGrabber.h.

Referenced by setRPCBasicTrigConfig(), and writeDataForRelativeBX().