EventCapture Class Reference

#include <EventCapture.h>

Inheritance diagram for EventCapture:

Public Member Functions
void	beginRun (edm::EventSetup const &eventSetup) override
void	endJob () override
	EventCapture (const edm::ParameterSet &edmCfg, const OMTFConfiguration *omtfConfig, CandidateSimMuonMatcher *candidateSimMuonMatcher, const MuonGeometryTokens &muonGeometryTokens, const GoldenPatternVec< GoldenPattern > *gps=nullptr)
void	observeEventBegin (const edm::Event &event) override
void	observeEventEnd (const edm::Event &event, std::unique_ptr< l1t::RegionalMuonCandBxCollection > &finalCandidates) override
void	observeProcesorEmulation (unsigned int iProcessor, l1t::tftype mtfType, const std::shared_ptr< OMTFinput > &, const AlgoMuons &algoCandidates, const AlgoMuons &gbCandidates, const std::vector< l1t::RegionalMuonCand > &candMuons) override
	~EventCapture () override
Public Member Functions inherited from IOMTFEmulationObserver
virtual void	addProcesorData (std::string key, boost::property_tree::ptree &procDataTree)
	IOMTFEmulationObserver ()
virtual void	observeProcesorBegin (unsigned int iProcessor, l1t::tftype mtfType)
virtual	~IOMTFEmulationObserver ()

Private Attributes
std::vector< AlgoMuons >	algoMuonsInProcs
CandidateSimMuonMatcher *	candidateSimMuonMatcher = nullptr
std::vector< AlgoMuons >	gbCandidatesInProcs
const GoldenPatternVec< GoldenPattern > *	goldenPatterns = nullptr
std::vector< std::shared_ptr< OMTFinput > >	inputInProcs
const OMTFConfiguration *	omtfConfig = nullptr
std::vector< edm::Ptr< SimTrack > >	simMuons
edm::InputTag	simTracksTag
std::unique_ptr< StubsSimHitsMatcher >	stubsSimHitsMatcher

Detailed Description

Definition at line 20 of file EventCapture.h.

Constructor & Destructor Documentation

EventCapture()

EventCapture::EventCapture	(	const edm::ParameterSet &	edmCfg,
		const OMTFConfiguration *	omtfConfig,
		CandidateSimMuonMatcher *	candidateSimMuonMatcher,
		const MuonGeometryTokens &	muonGeometryTokens,
		const GoldenPatternVec< GoldenPattern > *	gps = nullptr
	)

Definition at line 22 of file EventCapture.cc.

References edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), omtfConfig, simTracksTag, and stubsSimHitsMatcher.

    : omtfConfig(omtfConfig),
      goldenPatterns(gps),
      candidateSimMuonMatcher(candidateSimMuonMatcher),
      inputInProcs(omtfConfig->processorCnt()),
      algoMuonsInProcs(omtfConfig->processorCnt()),
      gbCandidatesInProcs(omtfConfig->processorCnt()) {
  if (edmCfg.exists("simTracksTag"))
    simTracksTag = edmCfg.getParameter<edm::InputTag>("simTracksTag");
  else
    edm::LogImportant("OMTFReconstruction")
        << "EventCapture::EventCapture: no InputTag simTracksTag found" << std::endl;

  //stubsSimHitsMatcher works only with the trackingParticle, because only them are stored in the pilup events
  if (this->candidateSimMuonMatcher && edmCfg.exists("trackingParticleTag"))
    stubsSimHitsMatcher = std::make_unique<StubsSimHitsMatcher>(edmCfg, omtfConfig, muonGeometryTokens);
}

~EventCapture()

EventCapture::~EventCapture ( )

override

Definition at line 44 of file EventCapture.cc.

                            {
  // TODO Auto-generated destructor stub
}

Member Function Documentation

beginRun()

void EventCapture::beginRun ( edm::EventSetup const &  eventSetup )

overridevirtual

Reimplemented from IOMTFEmulationObserver.

Definition at line 48 of file EventCapture.cc.

References options_cfi::eventSetup, and stubsSimHitsMatcher.

                                                           {
  if (stubsSimHitsMatcher)
    stubsSimHitsMatcher->beginRun(eventSetup);
}

endJob()

void EventCapture::endJob ( void  )

overridevirtual

Implements IOMTFEmulationObserver.

Definition at line 428 of file EventCapture.cc.

References stubsSimHitsMatcher.

                          {
  if (stubsSimHitsMatcher)
    stubsSimHitsMatcher->endJob();
}

observeEventBegin()

void EventCapture::observeEventBegin ( const edm::Event &  event )

overridevirtual

Reimplemented from IOMTFEmulationObserver.

Definition at line 53 of file EventCapture.cc.

References funct::abs(), algoMuonsInProcs, gbCandidatesInProcs, input, inputInProcs, edm::InputTag::label(), edm::Handle< T >::product(), simMuons, and simTracksTag.

                                                          {
  simMuons.clear();

  if (!simTracksTag.label().empty()) {
    edm::Handle<edm::SimTrackContainer> simTraksHandle;
    event.getByLabel(simTracksTag, simTraksHandle);

    for (unsigned int iSimTrack = 0; iSimTrack != simTraksHandle->size(); iSimTrack++) {
      if (std::abs((*simTraksHandle.product())[iSimTrack].type()) == 13)
        simMuons.emplace_back(simTraksHandle, iSimTrack);
    }
  }

  for (auto& input : inputInProcs)
    input.reset();

  for (auto& algoMuonsInProc : algoMuonsInProcs)
    algoMuonsInProc.clear();

  for (auto& gbCandidatesInProc : gbCandidatesInProcs)
    gbCandidatesInProc.clear();
}

observeEventEnd()

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

overridevirtual

!!!!!!!!!!!!!!!!!!!!!!! TODO dumps all events!!!!!!!!!!!!!!!!!!!!!!!!!!!!

printing

Reimplemented from IOMTFEmulationObserver.

Definition at line 93 of file EventCapture.cc.

References funct::abs(), algoMuonsInProcs, nano_mu_digi_cff::bx, candidateSimMuonMatcher, GCP_Ntuples_cfg::dump, gbCandidatesInProcs, CandidateSimMuonMatcher::getMatchingResults(), OMTFinputMaker::getProcessorPhiZero(), goldenPatterns, runTauDisplay::gp, OMTFConfiguration::hwPtToGev(), iEvent, inputInProcs, createfilelist::int, edm::InputTag::label(), nano_mu_digi_cff::layer, LogTrace, M_PI, OmtfName::name(), OMTFConfiguration::nProcessors(), l1t::omtf_neg, l1t::omtf_pos, omtfConfig, simMuonQualityAdjusterDigis_cfi::omtfInput, OMTFConfiguration::procHwPhiToGlobalPhi(), simMuons, simTracksTag, and stubsSimHitsMatcher.

                                                                                                    {
  std::ostringstream ostr;
  //filtering

  bool dump = false;

  if (candidateSimMuonMatcher) {
    std::vector<MatchingResult> matchingResults = candidateSimMuonMatcher->getMatchingResults();
    LogTrace("l1tOmtfEventPrint") << "matchingResults.size() " << matchingResults.size() << std::endl;

    //candidateSimMuonMatcher should use the  trackingParticles, because the simTracks are not stored for the pile-up events
    for (auto& matchingResult : matchingResults) {
      //TODO choose a condition, to print the desired candidates
      if (matchingResult.muonCand) {
        dump = true;

        bool runStubsSimHitsMatcher = false;
        if (matchingResult.trackingParticle) {
          auto trackingParticle = matchingResult.trackingParticle;
          ostr << "trackingParticle: eventId " << trackingParticle->eventId().event() << " pdgId " << std::setw(3)
               << trackingParticle->pdgId() << " trackId " << trackingParticle->g4Tracks().at(0).trackId() << " pt "
               << std::setw(9) << trackingParticle->pt()  //<<" Beta "<<simMuon->momentum().Beta()
               << " eta " << std::setw(9) << trackingParticle->momentum().eta() << " phi " << std::setw(9)
               << trackingParticle->momentum().phi() << std::endl;
        } else if (matchingResult.simTrack) {
          runStubsSimHitsMatcher = true;
          ostr << "SimMuon: eventId " << matchingResult.simTrack->eventId().event() << " pdgId " << std::setw(3)
               << matchingResult.simTrack->type() << " pt " << std::setw(9)
               << matchingResult.simTrack->momentum().pt()  //<<" Beta "<<simMuon->momentum().Beta()
               << " eta " << std::setw(9) << matchingResult.simTrack->momentum().eta() << " phi " << std::setw(9)
               << matchingResult.simTrack->momentum().phi() << std::endl;
        } else {
          ostr << "no simMuon ";
          runStubsSimHitsMatcher = true;
        }
        ostr << "matched to: " << std::endl;
        auto finalCandidate = matchingResult.muonCand;
        ostr << " hwPt " << finalCandidate->hwPt() << " hwUPt " << finalCandidate->hwPtUnconstrained() << " hwSign "
             << finalCandidate->hwSign() << " hwQual " << finalCandidate->hwQual() << " hwEta " << std::setw(4)
             << finalCandidate->hwEta() << std::setw(4) << " hwPhi " << finalCandidate->hwPhi() << "    eta "
             << std::setw(9) << (finalCandidate->hwEta() * 0.010875) << " phi " << std::endl;

        if (stubsSimHitsMatcher && runStubsSimHitsMatcher)
          stubsSimHitsMatcher->match(iEvent, matchingResult.muonCand, matchingResult.procMuon, ostr);
      }
    }
  } else if (!simTracksTag.label().empty()) {
    dump = false;
    bool wasSimMuInOmtfPos = false;
    bool wasSimMuInOmtfNeg = false;
    for (auto& simMuon : simMuons) {
      //TODO choose a condition, to print the desired events
      if (simMuon->eventId().event() == 0 && std::abs(simMuon->momentum().eta()) > 0.82 &&
          std::abs(simMuon->momentum().eta()) < 1.24 && simMuon->momentum().pt() >= 3.) {
        ostr << "SimMuon: eventId " << simMuon->eventId().event() << " pdgId " << std::setw(3) << simMuon->type()
             << " pt " << std::setw(9) << simMuon->momentum().pt()  //<<" Beta "<<simMuon->momentum().Beta()
             << " eta " << std::setw(9) << simMuon->momentum().eta() << " phi " << std::setw(9)
             << simMuon->momentum().phi() << std::endl;

        if (simMuon->momentum().eta() > 0)
          wasSimMuInOmtfPos = true;
        else
          wasSimMuInOmtfNeg = true;
      }
    }

    bool wasCandInNeg = false;
    bool wasCandInPos = false;

    for (auto& finalCandidate : *finalCandidates) {
      //TODO choose a condition, to print the desired candidates
      if (finalCandidate.trackFinderType() == l1t::tftype::omtf_neg && finalCandidate.hwQual() >= 12 &&
          finalCandidate.hwPt() > 20)
        wasCandInNeg = true;

      if (finalCandidate.trackFinderType() == l1t::tftype::omtf_pos && finalCandidate.hwQual() >= 12 &&
          finalCandidate.hwPt() > 20)
        wasCandInPos = true;
    }

    if ((wasSimMuInOmtfNeg && wasCandInNeg))  //TODO
      dump = true;

    if ((wasSimMuInOmtfPos && wasCandInPos))  //TODO
      dump = true;
  } else {
    //TODO choose a condition, to print the desired candidates
    // an example of a simple cut, only on the canidate pt
    /*
    for (auto& finalCandidate : *finalCandidates) {
      if (finalCandidate.hwPt() < 41) {  //  finalCandidate.hwQual() >= 1  41
        dump = true;
      }
    } */
    dump = true;  //<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  }

  if (!dump)
    return;


  edm::LogVerbatim("l1tOmtfEventPrint") << "##################### EventCapture::observeEventEnd - dump of event "
                                        << iEvent.id() << " #####################################################"
                                        << std::endl;

  edm::LogVerbatim("l1tOmtfEventPrint") << ostr.str() << endl;  //printing sim muons

  edm::LogVerbatim("l1tOmtfEventPrint") << "finalCandidates " << std::endl;
  for (int bx = finalCandidates->getFirstBX(); bx <= finalCandidates->getLastBX(); bx++) {
    for (auto finalCandidateIt = finalCandidates->begin(bx); finalCandidateIt != finalCandidates->end(bx);
         finalCandidateIt++) {
      auto& finalCandidate = *finalCandidateIt;
      int globHwPhi = (finalCandidate.processor()) * 96 + finalCandidate.hwPhi();
      // first processor starts at CMS phi = 15 degrees (24 in int)... Handle wrap-around with %. Add 576 to make sure the number is positive
      globHwPhi = (globHwPhi + 600) % 576;

      double globalPhi = globHwPhi * 2. * M_PI / 576;
      if (globalPhi > M_PI)
        globalPhi = globalPhi - (2. * M_PI);

      int layerHits = (int)finalCandidate.trackAddress().at(0);
      std::bitset<18> layerHitBits(layerHits);

      edm::LogVerbatim("l1tOmtfEventPrint")
          << " bx " << bx << " hwPt " << finalCandidate.hwPt() << " hwUPt " << finalCandidate.hwPtUnconstrained()
          << " hwSign " << finalCandidate.hwSign() << " hwQual " << finalCandidate.hwQual() << " hwEta " << std::setw(4)
          << finalCandidate.hwEta() << std::setw(4) << " hwPhi " << finalCandidate.hwPhi() << "    eta " << std::setw(9)
          << (finalCandidate.hwEta() * 0.010875) << " phi " << std::setw(9) << globalPhi << " " << layerHitBits
          << " processor " << OmtfName(finalCandidate.processor(), finalCandidate.trackFinderType(), omtfConfig)
          << std::endl;

      for (auto& trackAddr : finalCandidate.trackAddress()) {
        if (trackAddr.first >= 10)
          edm::LogVerbatim("l1tOmtfEventPrint")
              << "trackAddr first " << trackAddr.first << " second " << trackAddr.second << " ptGeV "
              << omtfConfig->hwPtToGev(trackAddr.second);
      }
    }
  }
  edm::LogVerbatim("l1tOmtfEventPrint") << std::endl;

  for (unsigned int iProc = 0; iProc < inputInProcs.size(); iProc++) {
    OmtfName board(iProc, omtfConfig);

    std::ostringstream ostrInput;
    if (inputInProcs[iProc]) {
      auto& omtfInput = *inputInProcs[iProc];
      int layersWithStubs = 0;
      for (auto& layer : omtfInput.getMuonStubs()) {
        for (auto& stub : layer) {
          bool layerFired = false;
          if (stub && (stub->type != MuonStub::Type::EMPTY)) {
            layerFired = true;

            auto globalPhiRad = omtfConfig->procHwPhiToGlobalPhi(
                stub->phiHw, OMTFinputMaker::getProcessorPhiZero(omtfConfig, iProc % omtfConfig->nProcessors()));
            ostrInput << (*stub) << " globalPhiRad " << globalPhiRad << std::endl;
          }
          if (layerFired)
            layersWithStubs++;
        }
      }

      if (layersWithStubs != 0) {
        edm::LogVerbatim("l1tOmtfEventPrint") << "\niProcessor " << iProc << " " << board.name()
                                              << " **************************************************" << std::endl;
        edm::LogVerbatim("l1tOmtfEventPrint") << ostrInput.str() << std::endl;
      }

      if (layersWithStubs < 2)
        continue;

      edm::LogVerbatim("l1tOmtfEventPrint") << *inputInProcs[iProc] << std::endl;

      edm::LogVerbatim("l1tOmtfEventPrint") << "algoMuons " << std::endl;
      //unsigned int procIndx = omtfConfig->getProcIndx(iProcessor, mtfType);
      for (auto& algoMuon : algoMuonsInProcs[iProc]) {
        if (algoMuon->isValid()) {
          edm::LogVerbatim("l1tOmtfEventPrint")
              << board.name() << " " << *algoMuon << " RefHitNum " << algoMuon->getRefHitNumber() << std::endl;
          edm::LogVerbatim("l1tOmtfEventPrint") << algoMuon->getGpResultConstr();
          if (algoMuon->getGpResultUnconstr().isValid())
            edm::LogVerbatim("l1tOmtfEventPrint")
                << "GpResultUnconstr " << algoMuon->getGoldenPaternUnconstr()->key() << "\n"
                << algoMuon->getGpResultUnconstr() << std::endl;

          if (goldenPatterns)  //watch out with the golden patterns
            for (auto& gp : *goldenPatterns) {
              if (gp->key().thePt == 0)
                continue;

              //printing GoldenPatternResult, uncomment if needed
              auto& gpResult = gp->getResults()[iProc][algoMuon->getRefHitNumber()];
              std::ostringstream ostr;
              ostr << " " << gp->key()
                   << "  "
                   //<< "  refLayer: " << gpResult.getRefLayer() << "\t"
                   << " Sum over layers: " << std::setw(5) << gpResult.getPdfSum()
                   << " Number of hits: " << std::setw(2) << gpResult.getFiredLayerCnt();

              for (unsigned int iLogicLayer = 0; iLogicLayer < gpResult.getStubResults().size(); ++iLogicLayer) {
                ostr << " l: " << std::setw(2) << iLogicLayer << " p: ";
                if (gpResult.getStubResults()[iLogicLayer].getMuonStub()) {
                  ostr << std::setw(2) << gpResult.getStubResults()[iLogicLayer].getPdfVal();
                } else {
                  ostr << "  ";
                }
              }
              edm::LogVerbatim("l1tOmtfEventPrint") << ostr.str() << std::endl;
            }
          edm::LogVerbatim("l1tOmtfEventPrint") << std::endl << std::endl;
        }
      }

      edm::LogVerbatim("l1tOmtfEventPrint") << "gbCandidates " << std::endl;
      for (auto& gbCandidate : gbCandidatesInProcs[iProc])
        if (gbCandidate->isValid())
          edm::LogVerbatim("l1tOmtfEventPrint")
              << board.name() << " iProc " << iProc << " " << *gbCandidate << std::endl;

      {
        edm::LogVerbatim("l1tOmtfEventPrint") << std::endl << std::endl << "\ngb_test " << board.name() << std::endl;
        for (auto& algoMuon : algoMuonsInProcs[iProc]) {
          edm::LogVerbatim("l1tOmtfEventPrint")
              << "     (" << std::setw(5) << algoMuon->getHwPatternNumConstr() << "," << std::setw(5)
              << algoMuon->getHwPatternNumUnconstr() << ","

              << std::setw(5) << algoMuon->getGpResultConstr().getFiredLayerCnt() << "," << std::setw(5)
              << algoMuon->getGpResultUnconstr().getFiredLayerCnt()
              << ","

              //in the FW there is LSB added for some reason, therefore we multiply by 2 here
              << std::setw(6) << algoMuon->getGpResultConstr().getFiredLayerBits() * 2 << "," << std::setw(6)
              << algoMuon->getGpResultUnconstr().getFiredLayerBits() * 2 << ","

              << std::setw(5) << algoMuon->getGpResultConstr().getPdfSum() << "," << std::setw(5)
              << algoMuon->getGpResultUnconstr().getPdfSumUnconstr() << ","

              << std::setw(5) << algoMuon->getGpResultConstr().getPhi() << "," << std::setw(5)
              << algoMuon->getGpResultUnconstr().getPhi()
              << ","

              //<<std::setw(5)<<OMTFConfiguration::eta2Bits(std::abs(algoMuon->getEtaHw()))<<", "
              << std::setw(5) << algoMuon->getEtaHw()
              << ", "

              //<<std::setw(5)<<omtfConfig->getRefToLogicNumber()[algoMuon->getRefLayer()]<<""
              << std::setw(5) << algoMuon->getRefLayer() << ""

              << "), " << std::endl;
        }
        edm::LogVerbatim("l1tOmtfEventPrint") << "\ngbCandidates" << std::endl;
        for (auto& gbCandidate : gbCandidatesInProcs[iProc])
          edm::LogVerbatim("l1tOmtfEventPrint")
              << "     (" << std::setw(5) << gbCandidate->getPtConstr() << "," << std::setw(5)
              << gbCandidate->getPtUnconstr() << ","

              << std::setw(5) << gbCandidate->getGpResultConstr().getFiredLayerCnt() << "," << std::setw(5)
              << gbCandidate->getGpResultUnconstr().getFiredLayerCnt()
              << ","

              //in the FW there is LSB added for some reason, therefore we multiply by 2 here
              << std::setw(6) << gbCandidate->getGpResultConstr().getFiredLayerBits() * 2 << "," << std::setw(6)
              << gbCandidate->getGpResultUnconstr().getFiredLayerBits() * 2 << ","

              << std::setw(5) << gbCandidate->getGpResultConstr().getPdfSum() << "," << std::setw(5)
              << gbCandidate->getGpResultUnconstr().getPdfSumUnconstr() << ","

              << std::setw(5) << gbCandidate->getGpResultConstr().getPhi() << "," << std::setw(5)
              << gbCandidate->getGpResultUnconstr().getPhi()
              << ","

              //<<std::setw(5)<<OMTFConfiguration::eta2Bits(std::abs(gbCandidate->getEtaHw()))<<", "
              << std::setw(5) << gbCandidate->getEtaHw()
              << ", "

              //<<std::setw(5)<<omtfConfig->getRefToLogicNumber()[gbCandidate->getRefLayer()]<<""
              << std::setw(5) << gbCandidate->getRefLayer() << ""

              << "), "
              << " -- getFiredLayerBits " << std::setw(5) << gbCandidate->getGpResultConstr().getFiredLayerBits()
              << std::endl;

        edm::LogVerbatim("l1tOmtfEventPrint") << "finalCandidates " << std::endl;

        std::ostringstream ostr;
        if (finalCandidates->size(0) > 0) {
          int iMu = 1;
          for (auto finalCandidateIt = finalCandidates->begin(0); finalCandidateIt != finalCandidates->end(0);
               finalCandidateIt++) {
            auto& finalCandidate = *finalCandidateIt;

            auto omtfName = OmtfName(finalCandidate.processor(), finalCandidate.trackFinderType(), omtfConfig);

            if (omtfName == board.name()) {
              int layerHits = (int)finalCandidate.trackAddress().at(0);
              std::bitset<18> layerHitBits(layerHits);

              unsigned int trackAddr = finalCandidate.trackAddress().at(0);
              unsigned int uPt = finalCandidate.hwPtUnconstrained();
              //if(uPt == 0) uPt = 5; //TODO remove when fixed in the FW
              trackAddr = (uPt << 18) + trackAddr;

              ostr << "M" << iMu << ":" << std::setw(4) << finalCandidate.hwPt() << "," << std::setw(4)
                   << finalCandidate.hwQual() << "," << std::setw(4) << finalCandidate.hwPhi() << "," << std::setw(4)
                   << std::abs(finalCandidate.hwEta())
                   << ","
                   //<<std::setw(10)<< finalCandidate.trackAddress().at(0)<<""
                   << std::setw(10) << trackAddr << "," << std::setw(4) << 0 << ","                 //Halo
                   << std::setw(4) << finalCandidate.hwSign() << "," << std::setw(4) << 1 << "; ";  //ChValid
              //<< " -- uPt " << std::setw(10) << uPt << " firedLayers " << finalCandidate.trackAddress().at(0);

              //<<std::setw(5)<< finalCandidate.hwPtUnconstrained()<<","

              //<<std::setw(9)<< layerHitBits<<","
              //<<std::setw(6)<< layerHits<<","
              iMu++;
            }
          }
          for (; iMu <= 3; iMu++)
            ostr << "M" << iMu << ":   0,   0,   0,   0,         0,   0,   0,   0; ";
          edm::LogVerbatim("l1tOmtfEventPrint") << ostr.str() << std::endl;
        }
      }

      edm::LogVerbatim("l1tOmtfEventPrint") << std::endl;
    }
  }

  edm::LogVerbatim("l1tOmtfEventPrint") << std::endl;
}

observeProcesorEmulation()

void EventCapture::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

Implements IOMTFEmulationObserver.

Definition at line 76 of file EventCapture.cc.

References algoMuonsInProcs, gbCandidatesInProcs, OMTFConfiguration::getProcIndx(), input, inputInProcs, and omtfConfig.

                                                                                             {
  unsigned int procIndx = omtfConfig->getProcIndx(iProcessor, mtfType);
  edm::LogImportant("l1tOmtfEventPrint") << "EventCapture::observeProcesorEmulation : iProcessor" << iProcessor
                                         << " mtfType " << mtfType << " procIndx " << procIndx << " OmtfName(procIndx) "
                                         << OmtfName(procIndx, omtfConfig) << " OmtfName(iProcessor, mtfType) "
                                         << OmtfName(iProcessor, mtfType, omtfConfig) << std::endl;
  inputInProcs[procIndx] = input;

  algoMuonsInProcs[procIndx] = algoCandidates;
  gbCandidatesInProcs[procIndx] = gbCandidates;
}

Member Data Documentation

algoMuonsInProcs

std::vector<AlgoMuons> EventCapture::algoMuonsInProcs

private

Definition at line 57 of file EventCapture.h.

Referenced by observeEventBegin(), observeEventEnd(), and observeProcesorEmulation().

candidateSimMuonMatcher

CandidateSimMuonMatcher* EventCapture::candidateSimMuonMatcher = nullptr

private

Definition at line 52 of file EventCapture.h.

Referenced by observeEventEnd().

gbCandidatesInProcs

std::vector<AlgoMuons> EventCapture::gbCandidatesInProcs

private

Definition at line 58 of file EventCapture.h.

Referenced by observeEventBegin(), observeEventEnd(), and observeProcesorEmulation().

goldenPatterns

const GoldenPatternVec<GoldenPattern>* EventCapture::goldenPatterns = nullptr

private

Definition at line 50 of file EventCapture.h.

Referenced by observeEventEnd().

inputInProcs

std::vector<std::shared_ptr<OMTFinput> > EventCapture::inputInProcs

private

Definition at line 56 of file EventCapture.h.

Referenced by observeEventBegin(), observeEventEnd(), and observeProcesorEmulation().

omtfConfig

const OMTFConfiguration* EventCapture::omtfConfig = nullptr

private

Definition at line 48 of file EventCapture.h.

Referenced by EventCapture(), observeEventEnd(), and observeProcesorEmulation().

simMuons

std::vector<edm::Ptr<SimTrack> > EventCapture::simMuons

private

Definition at line 54 of file EventCapture.h.

Referenced by observeEventBegin(), and observeEventEnd().

simTracksTag

edm::InputTag EventCapture::simTracksTag

private

Definition at line 47 of file EventCapture.h.

Referenced by EventCapture(), observeEventBegin(), and observeEventEnd().

stubsSimHitsMatcher

std::unique_ptr<StubsSimHitsMatcher> EventCapture::stubsSimHitsMatcher

private

Definition at line 60 of file EventCapture.h.

Referenced by beginRun(), endJob(), EventCapture(), and observeEventEnd().