#include <OMTFReconstruction.h>

Public Member Functions
virtual void	addObservers (const MuonGeometryTokens &muonGeometryTokens, const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord > &magneticFieldEsToken, const edm::ESGetToken< Propagator, TrackingComponentsRecord > &propagatorEsToken)

void	beginJob ()

void	beginJob ()

void	beginRun (edm::Run const &, edm::EventSetup const &)

void	beginRun (edm::Run const &run, edm::EventSetup const &iSetup, edm::ESGetToken< L1TMuonOverlapParams, L1TMuonOverlapParamsRcd > &omtfParamsEsToken, const MuonGeometryTokens &muonGeometryTokens, const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord > &magneticFieldEsToken, const edm::ESGetToken< Propagator, TrackingComponentsRecord > &propagatorEsToken)

void	endJob ()

void	endJob ()

	OMTFReconstruction (const edm::ParameterSet &, MuStubsInputTokens &muStubsInputTokens)

	OMTFReconstruction (const edm::ParameterSet &, edm::ConsumesCollector &&)

std::unique_ptr < l1t::RegionalMuonCandBxCollection >	reconstruct (const edm::Event &, const edm::EventSetup &)

std::unique_ptr < l1t::RegionalMuonCandBxCollection >	reconstruct (const edm::Event &, const edm::EventSetup &)

void	setInputMaker (unique_ptr< OMTFinputMaker > inputMaker)

	~OMTFReconstruction ()

virtual	~OMTFReconstruction ()

Protected Attributes
edm::ParameterSet	edmParameterSet

unique_ptr< OMTFinputMaker >	inputMaker

MuStubsInputTokens &	muStubsInputTokens

std::vector< std::unique_ptr < IOMTFEmulationObserver > >	observers

unique_ptr< OMTFConfiguration >	omtfConfig
	OMTF objects. More...

edm::ESWatcher < L1TMuonOverlapParamsRcd >	omtfParamsRecordWatcher

unique_ptr< IProcessorEmulator >	omtfProc

Private Member Functions
void	getProcessorCandidates (unsigned int iProcessor, l1t::tftype mtfType, int bx, l1t::RegionalMuonCandBxCollection &myCandidates)

void	loadAndFilterDigis (const edm::Event &)

void	writeResultToXML (unsigned int iProcessor, l1t::tftype mtfType, const OMTFinput &myInput, const std::vector< OMTFProcessor::resultsMap > &myResults, const std::vector< l1t::RegionalMuonCand > &candMuons)

Private Attributes
xercesc::DOMElement *	aTopElement

int	bxMax

int	bxMin

edm::Handle < CSCCorrelatedLCTDigiCollection >	cscDigis

edm::Handle < L1MuDTChambPhContainer >	dtPhDigis

edm::Handle < L1MuDTChambThContainer >	dtThDigis

bool	dumpDetailedResultToXML

bool	dumpResultToXML

edm::ESGetToken < L1TMuonOverlapParams, L1TMuonOverlapParamsRcd >	l1TMuonOverlapParamsToken_

edm::ParameterSet	m_Config

std::unique_ptr< IGhostBuster >	m_GhostBuster

OMTFinputMaker	m_InputMaker

OMTFProcessor *	m_OMTF

OMTFConfiguration *	m_OMTFConfig
	OMTF objects. More...

OMTFConfigMaker *	m_OMTFConfigMaker

OMTFSorter	m_Sorter

XMLConfigWriter *	m_Writer

edm::Handle< RPCDigiCollection >	rpcDigis

Detailed Description

Definition at line 37 of file OMTFReconstruction.h.

Constructor & Destructor Documentation

OMTFReconstruction::OMTFReconstruction	(	const edm::ParameterSet &	theConfig,
		edm::ConsumesCollector &&	iC
	)

Definition at line 21 of file OMTFReconstruction.cc.

References bxMax, bxMin, dumpDetailedResultToXML, dumpResultToXML, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), and m_Config.

     : m_Config(theConfig),
       l1TMuonOverlapParamsToken_(
           iC.esConsumes<L1TMuonOverlapParams, L1TMuonOverlapParamsRcd, edm::Transition::BeginRun>()),
       m_OMTFConfig(nullptr),
       m_InputMaker(iC, false),
       m_OMTF(nullptr),
       aTopElement(nullptr),
       m_OMTFConfigMaker(nullptr),
       m_Writer(nullptr) {
   dumpResultToXML = m_Config.getParameter<bool>("dumpResultToXML");
   dumpDetailedResultToXML = m_Config.getParameter<bool>("dumpDetailedResultToXML");
   //m_Config.getParameter<std::string>("XMLDumpFileName");
   bxMin = m_Config.exists("bxMin") ? m_Config.getParameter<int>("bxMin") : 0;
   bxMax = m_Config.exists("bxMax") ? m_Config.getParameter<int>("bxMax") : 0;
 }

OMTFReconstruction::~OMTFReconstruction ( )

Definition at line 39 of file OMTFReconstruction.cc.

References m_OMTF, m_OMTFConfig, and m_Writer.

                                         {
   delete m_OMTFConfig;
   delete m_OMTF;
 
   if (m_Writer)
     delete m_Writer;
 }

OMTFReconstruction::OMTFReconstruction	(	const edm::ParameterSet &	parameterSet,
		MuStubsInputTokens &	muStubsInputTokens
	)

Definition at line 29 of file OMTFReconstruction.cc.

References bxMax, bxMin, edmParameterSet, edm::ParameterSet::exists(), and edm::ParameterSet::getParameter().

     : edmParameterSet(parameterSet),
       muStubsInputTokens(muStubsInputTokens),
       omtfConfig(new OMTFConfiguration()),
       omtfProc(nullptr),
       m_OMTFConfigMaker(nullptr) {
   bxMin = edmParameterSet.exists("bxMin") ? edmParameterSet.getParameter<int>("bxMin") : 0;
   bxMax = edmParameterSet.exists("bxMax") ? edmParameterSet.getParameter<int>("bxMax") : 0;
 
   edm::LogVerbatim("OMTFReconstruction") << "running emulation for the bxMin " << bxMin << " - bxMax " << bxMax
                                          << std::endl;
 }

virtual OMTFReconstruction::~OMTFReconstruction ( )

virtual

Member Function Documentation

void OMTFReconstruction::addObservers	(	const MuonGeometryTokens &	muonGeometryTokens,
		const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord > &	magneticFieldEsToken,
		const edm::ESGetToken< Propagator, TrackingComponentsRecord > &	propagatorEsToken
	)

virtual

Definition at line 182 of file OMTFReconstruction.cc.

References edmParameterSet, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), magneticFieldEsToken(), omtfConfig, omtfProc, propagatorEsToken(), dtT0Analyzer_cfg::rootFileName, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by beginRun().

                                                                                   {
   if (!observers.empty())  //assuring it is done only at the first run
     return;
 
   edm::LogVerbatim("OMTFReconstruction") << "OMTFReconstruction::addObservers " << std::endl;
 
   //omtfConfig is created at constructor, and is not re-created at the the start of the run, so this is OK
   if (edmParameterSet.exists("dumpResultToXML")) {
     if (edmParameterSet.getParameter<bool>("dumpResultToXML"))
       observers.emplace_back(std::make_unique<XMLEventWriter>(
           omtfConfig.get(), edmParameterSet.getParameter<std::string>("XMLDumpFileName")));
   }
 
   CandidateSimMuonMatcher* candidateSimMuonMatcher = nullptr;
 
   if (edmParameterSet.exists("candidateSimMuonMatcher")) {
     if (edmParameterSet.getParameter<bool>("candidateSimMuonMatcher")) {
       observers.emplace_back(std::make_unique<CandidateSimMuonMatcher>(
           edmParameterSet, omtfConfig.get(), magneticFieldEsToken, propagatorEsToken));
       candidateSimMuonMatcher = static_cast<CandidateSimMuonMatcher*>(observers.back().get());
     }
   }
 
   auto omtfProcGoldenPat = dynamic_cast<OMTFProcessor<GoldenPattern>*>(omtfProc.get());
   if (omtfProcGoldenPat) {
     if (edmParameterSet.exists("eventCaptureDebug"))
       if (edmParameterSet.getParameter<bool>("eventCaptureDebug")) {
         observers.emplace_back(std::make_unique<EventCapture>(
             edmParameterSet, omtfConfig.get(), candidateSimMuonMatcher, muonGeometryTokens
             //&(omtfProcGoldenPat->getPatterns() ),
             //watch out, will crash if the proc is re-constructed from the DB after L1TMuonOverlapParamsRcd change
             ));
       }
 
     if (edmParameterSet.exists("dumpHitsToROOT") && edmParameterSet.getParameter<bool>("dumpHitsToROOT")) {
       std::string rootFileName = edmParameterSet.getParameter<std::string>("dumpHitsFileName");
       observers.emplace_back(std::make_unique<DataROOTDumper2>(edmParameterSet, omtfConfig.get(), rootFileName));
     }
   }
 }

void OMTFReconstruction::beginJob ( )

void OMTFReconstruction::beginJob ( void )

Definition at line 49 of file OMTFReconstruction.cc.

References m_OMTF, and m_OMTFConfig.

Referenced by L1TMuonOverlapPhase1TrackProducer::beginJob(), and L1TMuonOverlapTrackProducer::beginJob().

                                   {
   m_OMTFConfig = new OMTFConfiguration();
   m_OMTF = new OMTFProcessor();
 }

void OMTFReconstruction::beginRun	(	edm::Run const &	run,
		edm::EventSetup const &	iSetup,
		edm::ESGetToken< L1TMuonOverlapParams, L1TMuonOverlapParamsRcd > &	omtfParamsEsToken,
		const MuonGeometryTokens &	muonGeometryTokens,
		const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord > &	magneticFieldEsToken,
		const edm::ESGetToken< Propagator, TrackingComponentsRecord > &	propagatorEsToken
	)

Definition at line 61 of file OMTFReconstruction.cc.

References addObservers(), edm::ESWatcher< T >::check(), edmParameterSet, Exception, edm::ParameterSet::exists(), edm::FileInPath::fullPath(), edm::EventSetup::getData(), edm::ParameterSet::getParameter(), edm::RunBase::id(), inputMaker, omtfConfig, fakeOmtfParams_cff::omtfParams, omtfParamsRecordWatcher, omtfProc, XMLConfigReader::readPatterns(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                                 {
   const L1TMuonOverlapParams* omtfParams = nullptr;
 
   std::string processorType = "OMTFProcessor";  //GoldenPatternWithStat GoldenPattern
   if (edmParameterSet.exists("processorType")) {
     processorType = edmParameterSet.getParameter<std::string>("processorType");
   }
 
   bool buildPatternsFromXml = (edmParameterSet.exists("patternsXMLFile") || edmParameterSet.exists("patternsXMLFiles"));
 
   edm::LogVerbatim("OMTFReconstruction") << "OMTFReconstruction::beginRun " << run.id()
                                          << " buildPatternsFromXml: " << buildPatternsFromXml << std::endl;
 
   //if the buildPatternsFromXml == false - we are making the omtfConfig and omtfProc for every run,
   //as the configuration my change between the runs,
   //if buildPatternsFromXml == true - we assume the the entire configuration comes from phyton,
   //so we do it only for the first run
   if (omtfProc == nullptr || buildPatternsFromXml == false) {
     if (omtfParamsRecordWatcher.check(eventSetup)) {
       edm::LogVerbatim("OMTFReconstruction") << "retrieving omtfParams from EventSetup" << std::endl;
 
       omtfParams = &(eventSetup.getData(omtfParamsEsToken));
       if (!omtfParams) {
         edm::LogError("OMTFReconstruction") << "Could not retrieve parameters from Event Setup" << std::endl;
       }
       omtfConfig->configure(omtfParams);
 
       //the parameters can be overwritten from the python config
       omtfConfig->configureFromEdmParameterSet(edmParameterSet);
 
       inputMaker->initialize(edmParameterSet, eventSetup, muonGeometryTokens);
 
       //patterns from the edm::EventSetup are reloaded every beginRun
       if (buildPatternsFromXml == false) {
         edm::LogVerbatim("OMTFReconstruction") << "getting patterns from EventSetup" << std::endl;
         if (processorType == "OMTFProcessor") {
           omtfProc = std::make_unique<OMTFProcessor<GoldenPattern> >(
               omtfConfig.get(), edmParameterSet, eventSetup, omtfParams);
           omtfProc->printInfo();
         }
       }
     }
   }
 
   //if we read the patterns directly from the xml, we do it only once, at the beginning of the first run, not every run
   if (omtfProc == nullptr && buildPatternsFromXml) {
     std::vector<std::string> patternsXMLFiles;
 
     if (edmParameterSet.exists("patternsXMLFile")) {
       patternsXMLFiles.push_back(edmParameterSet.getParameter<edm::FileInPath>("patternsXMLFile").fullPath());
     } else if (edmParameterSet.exists("patternsXMLFiles")) {
       for (const auto& it : edmParameterSet.getParameter<std::vector<edm::ParameterSet> >("patternsXMLFiles")) {
         patternsXMLFiles.push_back(it.getParameter<edm::FileInPath>("patternsXMLFile").fullPath());
       }
     }
 
     for (auto& patternsXMLFile : patternsXMLFiles)
       edm::LogVerbatim("OMTFReconstruction") << "reading patterns from " << patternsXMLFile << std::endl;
 
     XMLConfigReader xmlReader;
 
     std::string patternType = "GoldenPattern";  //GoldenPatternWithStat GoldenPattern
     if (edmParameterSet.exists("patternType")) {
       patternType = edmParameterSet.getParameter<std::string>("patternType");
     }
 
     if (patternType == "GoldenPattern") {
       if (processorType == "OMTFProcessor") {
         if (omtfParams) {
           omtfProc = std::make_unique<OMTFProcessor<GoldenPattern> >(
               omtfConfig.get(),
               edmParameterSet,
               eventSetup,
               xmlReader.readPatterns<GoldenPattern>(*omtfParams, patternsXMLFiles, false));
         } else {  //in principle should not happen
           throw cms::Exception("OMTFReconstruction::beginRun: omtfParams is nullptr");
         }
       }
 
       edm::LogVerbatim("OMTFReconstruction") << "OMTFProcessor constructed. processorType " << processorType
                                              << ". GoldenPattern type: " << patternType << std::endl;
     } else if (patternType == "GoldenPatternWithStat") {
       //pattern generation is only possible if the processor is constructed only once per job
       //PatternGenerator modifies the patterns!!!
       if (processorType == "OMTFProcessor") {
         if (omtfParams) {
           omtfProc = std::make_unique<OMTFProcessor<GoldenPatternWithStat> >(
               omtfConfig.get(),
               edmParameterSet,
               eventSetup,
               xmlReader.readPatterns<GoldenPatternWithStat>(*omtfParams, patternsXMLFiles, false));
         } else {  //in principle should not happen
           throw cms::Exception("OMTFReconstruction::beginRun: omtfParams is nullptr");
         }
         auto omtfProcGoldenPat = dynamic_cast<OMTFProcessor<GoldenPatternWithStat>*>(omtfProc.get());
 
         if (edmParameterSet.exists("generatePatterns") && edmParameterSet.getParameter<bool>("generatePatterns")) {
           observers.emplace_back(
               std::make_unique<PatternGenerator>(edmParameterSet, omtfConfig.get(), omtfProcGoldenPat->getPatterns()));
           edm::LogVerbatim("OMTFReconstruction") << "generatePatterns: true " << std::endl;
         }
       }
     } else {
       throw cms::Exception("OMTFReconstruction::beginRun: unknown GoldenPattern type: " + patternType);
     }
 
     omtfProc->printInfo();
   }
 
   addObservers(muonGeometryTokens, magneticFieldEsToken, propagatorEsToken);
 
   for (auto& obs : observers) {
     obs->beginRun(eventSetup);
   }
 }

void OMTFReconstruction::beginRun	(	edm::Run const &	,
		edm::EventSetup const &	iSetup
	)

Definition at line 63 of file OMTFReconstruction.cc.

References OMTFProcessor< GoldenPatternType >::configure(), OMTFConfiguration::configure(), dumpResultToXML, isotrackTrainRegressor::fName, OMTFConfiguration::fwVersion(), edm::EventSetup::getData(), XMLConfigWriter::initialiseXMLDocument(), OMTFSorter< GoldenPatternType >::initialize(), OMTFinputMaker::initialize(), l1TMuonOverlapParamsToken_, m_GhostBuster, m_InputMaker, m_OMTF, m_OMTFConfig, m_Sorter, m_Writer, OMTFConfiguration::nPhiBins(), fakeOmtfParams_cff::omtfParams, OMTFSorter< GoldenPatternType >::setNphiBins(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by L1TMuonOverlapPhase1TrackProducer::beginRun(), and L1TMuonOverlapTrackProducer::beginRun().

                                                                             {
   const L1TMuonOverlapParams* omtfParams = &iSetup.getData(l1TMuonOverlapParamsToken_);
 
   if (!omtfParams) {
     edm::LogError("L1TMuonOverlapTrackProducer") << "Could not retrieve parameters from Event Setup" << std::endl;
   }
 
   m_OMTFConfig->configure(omtfParams);
   m_OMTF->configure(m_OMTFConfig, omtfParams);
   //m_GhostBuster.setNphiBins(m_OMTFConfig->nPhiBins());
 
   if (m_OMTFConfig->fwVersion() >= 5) {
     //  if(m_Config.exists("ghostBusterType") ) {
     //    if(m_Config.getParameter<std::string>("ghostBusterType") == "GhostBusterPreferRefDt")
     m_GhostBuster = std::make_unique<GhostBusterPreferRefDt>(m_OMTFConfig);
   } else {
     m_GhostBuster = std::make_unique<GhostBuster>();
   }
 
   m_Sorter.initialize(m_OMTFConfig);
   m_Sorter.setNphiBins(m_OMTFConfig->nPhiBins());
 
   m_InputMaker.initialize(iSetup, m_OMTFConfig);
 
   if (dumpResultToXML) {
     m_Writer = new XMLConfigWriter(m_OMTFConfig);
     std::string fName = "OMTF";
     m_Writer->initialiseXMLDocument(fName);
   }
 }

void OMTFReconstruction::endJob ( void )

Definition at line 55 of file OMTFReconstruction.cc.

References dumpResultToXML, XMLConfigWriter::finaliseXMLDocument(), isotrackTrainRegressor::fName, edm::ParameterSet::getParameter(), m_Config, m_Writer, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by L1TMuonOverlapPhase1TrackProducer::endJob(), and L1TMuonOverlapTrackProducer::endJob().

                                 {
   if (dumpResultToXML) {
     std::string fName = m_Config.getParameter<std::string>("XMLDumpFileName");
     m_Writer->finaliseXMLDocument(fName);
   }
 }

void OMTFReconstruction::endJob ( )

void OMTFReconstruction::getProcessorCandidates	(	unsigned int	iProcessor,
		l1t::tftype	mtfType,
		int	bx,
		l1t::RegionalMuonCandBxCollection &	myCandidates
	)

private

Definition at line 137 of file OMTFReconstruction.cc.

References OMTFinputMaker::buildInputForProcessor(), makePileupJSON::bx, OMTFSorter< GoldenPatternType >::candidates(), cscDigis, dtPhDigis, dtThDigis, OMTFinputMaker::getFlag(), input, m_GhostBuster, m_InputMaker, m_OMTF, m_Sorter, OMTFProcessor< GoldenPatternType >::processInput(), edm::Handle< T >::product(), BXVector< T >::push_back(), bookConverter::results, rpcDigis, OMTFinputMaker::setFlag(), OMTFSorter< GoldenPatternType >::sortRefHitResults(), and writeResultToXML().

Referenced by reconstruct().

                                                                                                  {
   m_InputMaker.setFlag(0);
   OMTFinput input = m_InputMaker.buildInputForProcessor(
       dtPhDigis.product(), dtThDigis.product(), cscDigis.product(), rpcDigis.product(), iProcessor, mtfType, bx);
   int flag = m_InputMaker.getFlag();
 
   const std::vector<OMTFProcessor::resultsMap>& results = m_OMTF->processInput(iProcessor, input);
 
   std::vector<AlgoMuon> algoCandidates;
 
   m_Sorter.sortRefHitResults(results, algoCandidates);
 
   // perform GB
   std::vector<AlgoMuon> gbCandidates = m_GhostBuster->select(algoCandidates);
 
   // fill RegionalMuonCand colleciton
   std::vector<l1t::RegionalMuonCand> candMuons = m_Sorter.candidates(iProcessor, mtfType, gbCandidates);
 
   //fill outgoing collection
   for (auto& candMuon : candMuons) {
     candMuon.setHwQual(candMuon.hwQual() | flag);  //FIXME temporary debug fix
     omtfCandidates.push_back(bx, candMuon);
   }
 
   //dump to XML
   if (bx == 0)
     writeResultToXML(iProcessor, mtfType, input, results, candMuons);
 }

void OMTFReconstruction::loadAndFilterDigis ( const edm::Event & iEvent )

private

Definition at line 123 of file OMTFReconstruction.cc.

References cscDigis, dtPhDigis, dtThDigis, edm::Event::getByLabel(), edm::ParameterSet::getParameter(), m_Config, and rpcDigis.

Referenced by reconstruct().

                                                                   {
   // Filter digis by dropping digis from selected (by cfg.py) subsystems
   if (!m_Config.getParameter<bool>("dropDTPrimitives")) {
     iEvent.getByLabel(m_Config.getParameter<edm::InputTag>("srcDTPh"), dtPhDigis);
     iEvent.getByLabel(m_Config.getParameter<edm::InputTag>("srcDTTh"), dtThDigis);
   }
   if (!m_Config.getParameter<bool>("dropRPCPrimitives"))
     iEvent.getByLabel(m_Config.getParameter<edm::InputTag>("srcRPC"), rpcDigis);
   if (!m_Config.getParameter<bool>("dropCSCPrimitives"))
     iEvent.getByLabel(m_Config.getParameter<edm::InputTag>("srcCSC"), cscDigis);
 }

std::unique_ptr< l1t::RegionalMuonCandBxCollection > OMTFReconstruction::reconstruct	(	const edm::Event &	iEvent,
		const edm::EventSetup &	evSetup
	)

The order is important: first put omtf_pos candidates, then omtf_neg.

Definition at line 95 of file OMTFReconstruction.cc.

References aTopElement, makePileupJSON::bx, bxMax, bxMin, HLT_FULL_cff::candidates, dumpResultToXML, edm::EventID::event(), getProcessorCandidates(), edm::EventBase::id(), loadAndFilterDigis(), m_OMTFConfig, m_Writer, OMTFConfiguration::nProcessors(), l1t::omtf_neg, l1t::omtf_pos, and XMLConfigWriter::writeEventHeader().

Referenced by L1TMuonOverlapPhase1TrackProducer::produce(), and L1TMuonOverlapTrackProducer::produce().

                                                                                                          {
   loadAndFilterDigis(iEvent);
 
   if (dumpResultToXML)
     aTopElement = m_Writer->writeEventHeader(iEvent.id().event());
 
   std::unique_ptr<l1t::RegionalMuonCandBxCollection> candidates(new l1t::RegionalMuonCandBxCollection);
   candidates->setBXRange(bxMin, bxMax);
 
   for (int bx = bxMin; bx <= bxMax; bx++) {
     for (unsigned int iProcessor = 0; iProcessor < m_OMTFConfig->nProcessors(); ++iProcessor)
       getProcessorCandidates(iProcessor, l1t::tftype::omtf_pos, bx, *candidates);
 
     for (unsigned int iProcessor = 0; iProcessor < m_OMTFConfig->nProcessors(); ++iProcessor)
       getProcessorCandidates(iProcessor, l1t::tftype::omtf_neg, bx, *candidates);
 
     edm::LogInfo("OMTFReconstruction") << "OMTF:  Number of candidates in BX=" << bx << ": " << candidates->size(bx)
                                        << std::endl;
     ;
   }
 
   return candidates;
 }

std::unique_ptr<l1t::RegionalMuonCandBxCollection> OMTFReconstruction::reconstruct	(	const edm::Event &	,
		const edm::EventSetup &
	)

void OMTFReconstruction::setInputMaker ( unique_ptr< OMTFinputMaker > inputMaker )

inline

Definition at line 57 of file OMTFReconstruction.h.

References eostools::move().

57 { this->inputMaker = std::move(inputMaker); }

OMTFReconstruction::inputMaker

unique_ptr< OMTFinputMaker > inputMaker

Definition: OMTFReconstruction.h:73

eostools.move

def move

Definition: eostools.py:511

void OMTFReconstruction::writeResultToXML	(	unsigned int	iProcessor,
		l1t::tftype	mtfType,
		const OMTFinput &	myInput,
		const std::vector< OMTFProcessor::resultsMap > &	myResults,
		const std::vector< l1t::RegionalMuonCand > &	candMuons
	)

private

Dump only regions, where a candidate was found

Definition at line 170 of file OMTFReconstruction.cc.

References aTopElement, dumpDetailedResultToXML, dumpResultToXML, Reference_intrackfit_cff::endcap, AlgoMuon::getPt(), m_OMTFConfig, m_Sorter, m_Writer, OMTFConfiguration::nTestRefHits(), l1t::omtf_neg, l1t::omtf_pos, OMTFSorter< GoldenPatternType >::sortRefHitResults(), XMLConfigWriter::writeAlgoMuon(), XMLConfigWriter::writeCandMuon(), XMLConfigWriter::writeEventData(), and XMLConfigWriter::writeResultsData().

Referenced by getProcessorCandidates().

                                                                                            {
   int endcap = (mtfType == l1t::omtf_neg) ? -1 : ((mtfType == l1t::omtf_pos) ? +1 : 0);
   OmtfName board(iProcessor, endcap);
 
   //Write data to XML file
   if (dumpResultToXML) {
     xercesc::DOMElement* aProcElement = m_Writer->writeEventData(aTopElement, board, input);
     for (unsigned int iRefHit = 0; iRefHit < m_OMTFConfig->nTestRefHits(); ++iRefHit) {
       AlgoMuon algoMuon = m_Sorter.sortRefHitResults(results[iRefHit], 0);  //charge=0 means ignore charge
       if (algoMuon.getPt()) {
         m_Writer->writeAlgoMuon(aProcElement, iRefHit, algoMuon);
         if (dumpDetailedResultToXML) {
           for (auto& itKey : results[iRefHit])
             m_Writer->writeResultsData(aProcElement, iRefHit, itKey.first, itKey.second);
         }
       }
     }
     for (auto& candMuon : candMuons)
       m_Writer->writeCandMuon(aProcElement, candMuon);
   }
 }