CandidateSimMuonMatcher Class Reference

#include <CandidateSimMuonMatcher.h>

Inheritance diagram for CandidateSimMuonMatcher:

Public Member Functions
TrajectoryStateOnSurface	atStation2 (const FreeTrajectoryState &ftsStart) const
void	beginRun (edm::EventSetup const &eventSetup) override
	CandidateSimMuonMatcher (const edm::ParameterSet &edmCfg, const OMTFConfiguration *omtfConfig, const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord > &magneticFieldEsToken, const edm::ESGetToken< Propagator, TrackingComponentsRecord > &propagatorEsToken)
std::vector< MatchingResult >	cleanMatching (std::vector< MatchingResult > matchingResults, std::vector< const l1t::RegionalMuonCand *> &muonCands, AlgoMuons &ghostBustedProcMuons)
void	endJob () override
std::vector< MatchingResult >	getMatchingResults ()
std::vector< const l1t::RegionalMuonCand * >	ghostBust (const l1t::RegionalMuonCandBxCollection *mtfCands, const AlgoMuons &gbCandidates, AlgoMuons &ghostBustedProcMuons)
MatchingResult	match (const l1t::RegionalMuonCand *omtfCand, const AlgoMuonPtr &procMuon, const SimTrack &simTrack, TrajectoryStateOnSurface &tsof)
MatchingResult	match (const l1t::RegionalMuonCand *omtfCand, const AlgoMuonPtr &procMuon, const TrackingParticle &trackingParticle, TrajectoryStateOnSurface &tsof)
std::vector< MatchingResult >	match (std::vector< const l1t::RegionalMuonCand *> &muonCands, AlgoMuons &ghostBustedProcMuons, const edm::SimTrackContainer *simTracks, const edm::SimVertexContainer *simVertices, std::function< bool(const SimTrack &)> const &simTrackFilter)
std::vector< MatchingResult >	match (std::vector< const l1t::RegionalMuonCand *> &muonCands, AlgoMuons &ghostBustedProcMuons, const TrackingParticleCollection *trackingParticles, std::function< bool(const TrackingParticle &)> const &simTrackFilter)
std::vector< MatchingResult >	matchSimple (std::vector< const l1t::RegionalMuonCand *> &muonCands, AlgoMuons &ghostBustedProcMuons, const edm::SimTrackContainer *simTracks, const edm::SimVertexContainer *simVertices, std::function< bool(const SimTrack &)> const &simTrackFilter)
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
TrajectoryStateOnSurface	propagate (const SimTrack &simTrack, const edm::SimVertexContainer *simVertices)
TrajectoryStateOnSurface	propagate (const TrackingParticle &trackingParticle)
FreeTrajectoryState	simTrackToFts (const SimTrack &simTrack, const SimVertex &simVertex)
FreeTrajectoryState	simTrackToFts (const TrackingParticle &trackingParticle)
	~CandidateSimMuonMatcher () 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
TH1D *	deltaPhiPropCandMean = nullptr
TH1D *	deltaPhiPropCandStdDev = nullptr
const edm::ParameterSet &	edmCfg
AlgoMuons	gbCandidates
edm::ESHandle< MagneticField >	magField
const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord > &	magneticFieldEsToken
std::vector< MatchingResult >	matchingResults
const OMTFConfiguration *	omtfConfig
edm::ESHandle< Propagator >	propagator
const edm::ESGetToken< Propagator, TrackingComponentsRecord > &	propagatorEsToken
bool	usePropagation = false

Detailed Description

Definition at line 97 of file CandidateSimMuonMatcher.h.

Constructor & Destructor Documentation

CandidateSimMuonMatcher()

CandidateSimMuonMatcher::CandidateSimMuonMatcher	(	const edm::ParameterSet &	edmCfg,
		const OMTFConfiguration *	omtfConfig,
		const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord > &	magneticFieldEsToken,
		const edm::ESGetToken< Propagator, TrackingComponentsRecord > &	propagatorEsToken
	)

Definition at line 42 of file CandidateSimMuonMatcher.cc.

References deltaPhiPropCandMean, deltaPhiPropCandStdDev, edmCfg, edm::ParameterSet::exists(), contentValuesFiles::fullPath, edm::ParameterSet::getParameter(), testHGCalDigi_cfg::inFile, AlCaHLTBitMon_QueryRunRegistry::string, and usePropagation.

    : omtfConfig(omtfConfig),
      edmCfg(edmCfg),
      magneticFieldEsToken(magneticFieldEsToken),
      propagatorEsToken(propagatorEsToken) {
  std::string muonMatcherFileName = edmCfg.getParameter<edm::FileInPath>("muonMatcherFile").fullPath();
  TFile inFile(muonMatcherFileName.c_str());
  edm::LogImportant("l1tOmtfEventPrint") << " CandidateSimMuonMatcher: using muonMatcherFileName "
                                         << muonMatcherFileName << std::endl;

  if (edmCfg.exists("candidateSimMuonMatcherType")) {
    if (edmCfg.getParameter<std::string>("candidateSimMuonMatcherType") == "propagation")
      usePropagation = true;
    else if (edmCfg.getParameter<std::string>("candidateSimMuonMatcherType") == "matchSimple")
      usePropagation = false;

    edm::LogImportant("l1tOmtfEventPrint")
        << " CandidateSimMuonMatcher: candidateSimMuonMatcherType "
        << edmCfg.getParameter<std::string>("candidateSimMuonMatcherType") << std::endl;
  }

  edm::LogImportant("l1tOmtfEventPrint") << " CandidateSimMuonMatcher: usePropagation " << usePropagation << std::endl;

  deltaPhiPropCandMean = (TH1D*)inFile.Get("deltaPhiPropCandMean");
  deltaPhiPropCandStdDev = (TH1D*)inFile.Get("deltaPhiPropCandStdDev");
}

~CandidateSimMuonMatcher()

CandidateSimMuonMatcher::~CandidateSimMuonMatcher ( )

override

Definition at line 73 of file CandidateSimMuonMatcher.cc.

{}

Member Function Documentation

atStation2()

TrajectoryStateOnSurface CandidateSimMuonMatcher::atStation2

(

const FreeTrajectoryState &

ftsStart

)

const

Definition at line 342 of file CandidateSimMuonMatcher.cc.

References Propagator::propagate(), propagator, and omtf::DataWord64::rpc.

Referenced by propagate().

                                                                                                      {
  // propagate to MB1, which defines the OMTF region (W+-2 MB1 is connected only to the OMTF)
  // 415 cm is R of RB1in, 660.5cm is |z| of the edge of MB2 (B field on)
  ReferenceCountingPointer<Surface> rpc = ReferenceCountingPointer<Surface>(
      new BoundCylinder(GlobalPoint(0., 0., 0.), TkRotation<float>(), SimpleCylinderBounds(415., 415., -660.5, 660.5)));
  TrajectoryStateOnSurface trackAtRPC = propagator->propagate(ftsStart, *rpc);

  return trackAtRPC;
}

beginRun()

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

overridevirtual

Reimplemented from IOMTFEmulationObserver.

Definition at line 75 of file CandidateSimMuonMatcher.cc.

References options_cfi::eventSetup, magField, magneticFieldEsToken, propagator, and propagatorEsToken.

                                                                      {
  //TODO use edm::ESWatcher<MagneticField> magneticFieldRecordWatcher;
  magField = eventSetup.getHandle(magneticFieldEsToken);
  propagator = eventSetup.getHandle(propagatorEsToken);
}

cleanMatching()

std::vector< MatchingResult > CandidateSimMuonMatcher::cleanMatching	(	std::vector< MatchingResult >	matchingResults,
		std::vector< const l1t::RegionalMuonCand *> &	muonCands,
		AlgoMuons &	ghostBustedProcMuons
	)

Definition at line 539 of file CandidateSimMuonMatcher.cc.

References a, b, MatchingResult::duplicate, testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, trackerHitRTTI::isMatched(), LogTrace, MatchingResult::matched, matchingResults, mps_fire::result, and jetUpdater_cfi::sort.

Referenced by match(), and matchSimple().

                                                                                                    {
  //Cleaning the matching
  std::sort(
      matchingResults.begin(), matchingResults.end(), [](const MatchingResult& a, const MatchingResult& b) -> bool {
        return a.matchingLikelihood > b.matchingLikelihood;
      });

  for (unsigned int i1 = 0; i1 < matchingResults.size(); i1++) {
    if (matchingResults[i1].result == MatchingResult::ResultType::matched) {
      for (unsigned int i2 = i1 + 1; i2 < matchingResults.size(); i2++) {
        if ((matchingResults[i1].trackingParticle &&
             matchingResults[i1].trackingParticle == matchingResults[i2].trackingParticle) ||
            (matchingResults[i1].simTrack && matchingResults[i1].simTrack == matchingResults[i2].simTrack) ||
            (matchingResults[i1].muonCand == matchingResults[i2].muonCand)) {
          //if matchingResults[i1].muonCand == false, then it is also OK here
          matchingResults[i2].result = MatchingResult::ResultType::duplicate;
        }
      }
    }
  }

  std::vector<MatchingResult> cleanedMatchingResults;
  for (auto& matchingResult : matchingResults) {
    if (matchingResult.result == MatchingResult::ResultType::matched || matchingResult.muonCand == nullptr)
      //adding also the simTracks that are not matched at all, before it is assured that they are not duplicates
      cleanedMatchingResults.push_back(matchingResult);
    if (matchingResult.result == MatchingResult::ResultType::matched) {
      /* TODO fix if filling of the deltaPhiPropCandMean and deltaPhiPropCandStdDev is needed
      if(fillMean) {
      double ptGen  = matchingResult.genPt;
        deltaPhiPropCandMean->Fill(ptGen, matchingResult.deltaPhi); //filling overflow is ok here
        deltaPhiPropCandStdDev->Fill(ptGen, matchingResult.deltaPhi * matchingResult.deltaPhi);
      }*/
    }
  }

  //adding the muonCand-s that were not matched, i.e. in order to analyze them later
  unsigned int iCand = 0;
  for (auto& muonCand : muonCands) {
    bool isMatched = false;
    for (auto& matchingResult : cleanedMatchingResults) {
      if (matchingResult.muonCand == muonCand) {
        isMatched = true;
        break;
      }
    }

    if (!isMatched) {
      MatchingResult result;
      result.muonCand = muonCand;
      result.procMuon = ghostBustedProcMuons.at(iCand);
      cleanedMatchingResults.push_back(result);
    }
    iCand++;
  }

  LogTrace("l1tOmtfEventPrint") << "CandidateSimMuonMatcher::cleanMatching:" << __LINE__
                                << " cleanedMatchingResults:" << std::endl;
  for (auto& result : cleanedMatchingResults) {
    if (result.trackingParticle || result.simTrack)
      LogTrace("l1tOmtfEventPrint") << "CandidateSimMuonMatcher::cleanMatching:" << __LINE__ << " simTrack type "
                                    << result.pdgId << " pt " << std::setw(8) << result.genPt << " eta " << std::setw(8)
                                    << result.genEta << " phi " << std::setw(8) << result.genPhi;
    else
      LogTrace("l1tOmtfEventPrint") << "no matched track ";

    if (result.muonCand) {
      LogTrace("l1tOmtfEventPrint") << " muonCand pt " << std::setw(8) << result.muonCand->hwPt() << " hwQual "
                                    << result.muonCand->hwQual() << " hwEta " << result.muonCand->hwEta()
                                    << " deltaEta " << std::setw(8) << result.deltaEta << " deltaPhi " << std::setw(8)
                                    << result.deltaPhi << " Likelihood " << std::setw(8) << result.matchingLikelihood
                                    << " result " << (short)result.result;
      LogTrace("l1tOmtfEventPrint") << " procMuon " << *(result.procMuon) << std::endl;
    } else
      LogTrace("l1tOmtfEventPrint") << " no muonCand "
                                    << " result " << (short)result.result << std::endl;
  }
  LogTrace("l1tOmtfEventPrint") << " " << std::endl;

  return cleanedMatchingResults;
}

endJob()

void CandidateSimMuonMatcher::endJob ( void  )

overridevirtual

Implements IOMTFEmulationObserver.

Definition at line 259 of file CandidateSimMuonMatcher.cc.

{}

getMatchingResults()

std::vector<MatchingResult> CandidateSimMuonMatcher::getMatchingResults ( )

inline

Definition at line 176 of file CandidateSimMuonMatcher.h.

References matchingResults.

Referenced by EventCapture::observeEventEnd(), DataROOTDumper2::observeEventEnd(), and PatternGenerator::updateStatUsingMatcher2().

{ return matchingResults; }

ghostBust()

std::vector< const l1t::RegionalMuonCand * > CandidateSimMuonMatcher::ghostBust	(	const l1t::RegionalMuonCandBxCollection *	mtfCands,
		const AlgoMuons &	gbCandidates,
		AlgoMuons &	ghostBustedProcMuons
	)

Definition at line 261 of file CandidateSimMuonMatcher.cc.

References funct::abs(), BXVector< T >::at(), OMTFConfiguration::calcGlobalPhi(), srCondWrite_cfg::deltaPhi, gbCandidates, hwGmtPhiToGlobalPhi(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, LogTrace, omtfConfig, and BXVector< T >::size().

Referenced by observeEventEnd().

                                                                                                                     {
  if (gbCandidates.size() != mtfCands->size(0)) {
    edm::LogError("l1tOmtfEventPrint") << "CandidateSimMuonMatcher::ghostBust(): gbCandidates.size() "
                                       << gbCandidates.size() << " != mtfCands.size() " << mtfCands->size();
  }

  boost::dynamic_bitset<> isKilled(mtfCands->size(0), false);

  for (unsigned int i1 = 0; i1 < mtfCands->size(0); ++i1) {
    if (mtfCands->at(0, i1).hwPt() == 0)
      continue;
    LogTrace("l1tOmtfEventPrint") << "\nCandidateSimMuonMatcher::ghostBust regionalCand pt " << std::setw(3)
                                  << mtfCands->at(0, i1).hwPt() << " qual " << std::setw(2)
                                  << mtfCands->at(0, i1).hwQual() << " proc " << std::setw(2)
                                  << mtfCands->at(0, i1).processor();
    for (unsigned int i2 = i1 + 1; i2 < mtfCands->size(0); ++i2) {
      auto& mtfCand1 = mtfCands->at(0, i1);
      auto& mtfCand2 = mtfCands->at(0, i2);
      if (mtfCand2.hwPt() == 0)
        continue;

      if (std::abs(mtfCand1.hwEta() - mtfCand2.hwEta()) < (0.3 / 0.010875)) {
        int gloablHwPhi1 = omtfConfig->calcGlobalPhi(mtfCand1.hwPhi(), mtfCand1.processor());
        int gloablHwPhi2 = omtfConfig->calcGlobalPhi(mtfCand2.hwPhi(), mtfCand2.processor());

        //folding phi
        int deltaPhi = std::abs(gloablHwPhi1 - gloablHwPhi2);
        if (deltaPhi > 576 / 2)
          deltaPhi = std::abs(deltaPhi - 576);

        //one can use the phi in radians like that:
        //double globalPhi1 = hwGmtPhiToGlobalPhi(omtfConfig->calcGlobalPhi( mtfCand1.hwPhi(), mtfCand1.processor() ) );
        //double globalPhi2 = hwGmtPhiToGlobalPhi(omtfConfig->calcGlobalPhi( mtfCand2.hwPhi(), mtfCand2.processor() ) );

        //0.0872664626 = 5 deg, i.e. the same window as in the OMTF ghost buster
        if (deltaPhi < 8) {
          //if (mtfCand1.hwQual() > mtfCand2.hwQual()) //TODO this is used in the uGMT
          //but this should be better - but probably the difference is not big
          if (gbCandidates[i1]->getFiredLayerCnt() > gbCandidates[i2]->getFiredLayerCnt()) {
            isKilled[i2] = true;
          } else
            isKilled[i1] = true;
        }
      }
    }
  }

  std::vector<const l1t::RegionalMuonCand*> resultCands;

  for (unsigned int i1 = 0; i1 < mtfCands->size(0); ++i1) {
    //dropping candidates with quality 0 !!!!!!!!!!!!!!!!!!!! fixme if not needed
    if (!isKilled[i1] && mtfCands->at(0, i1).hwPt()) {
      resultCands.push_back(&(mtfCands->at(0, i1)));
      ghostBustedProcMuons.push_back(gbCandidates.at(i1));
    }

    if (mtfCands->at(0, i1).hwPt()) {
      LogTrace("l1tOmtfEventPrint") << "CandidateSimMuonMatcher::ghostBust\n  regionalCand pt " << std::setw(3)
                                    << mtfCands->at(0, i1).hwPt() << " qual " << std::setw(2)
                                    << mtfCands->at(0, i1).hwQual() << " proc " << std::setw(2)
                                    << mtfCands->at(0, i1).processor() << " eta " << std::setw(4)
                                    << mtfCands->at(0, i1).hwEta() << " gloablEta " << std::setw(8)
                                    << mtfCands->at(0, i1).hwEta() * 0.010875 << " hwPhi " << std::setw(3)
                                    << mtfCands->at(0, i1).hwPhi() << " globalPhi " << std::setw(8)
                                    << hwGmtPhiToGlobalPhi(omtfConfig->calcGlobalPhi(mtfCands->at(0, i1).hwPhi(),
                                                                                     mtfCands->at(0, i1).processor()))
                                    << " fireadLayers " << std::bitset<18>(mtfCands->at(0, i1).trackAddress().at(0))
                                    << " gb isKilled " << isKilled.test(i1) << std::endl;

      LogTrace("l1tOmtfEventPrint") << *(gbCandidates.at(i1)) << std::endl;
    }
  }

  if (resultCands.size() >= 3)
    LogTrace("l1tOmtfEventPrint") << " ghost !!!!!! " << std::endl;
  LogTrace("l1tOmtfEventPrint") << std::endl;

  return resultCands;
}

match() [1/4]

MatchingResult CandidateSimMuonMatcher::match	(	const l1t::RegionalMuonCand *	omtfCand,
		const AlgoMuonPtr &	procMuon,
		const SimTrack &	simTrack,
		TrajectoryStateOnSurface &	tsof
	)

Definition at line 410 of file CandidateSimMuonMatcher.cc.

References funct::abs(), OMTFConfiguration::calcGlobalPhi(), deltaPhiPropCandMean, deltaPhiPropCandStdDev, PV3DBase< T, PVType, FrameType >::eta(), foldPhi(), TrajectoryStateOnSurface::globalPosition(), l1t::RegionalMuonCand::hwEta(), hwGmtPhiToGlobalPhi(), l1t::RegionalMuonCand::hwPhi(), l1t::RegionalMuonCand::hwPt(), l1t::RegionalMuonCand::hwQual(), LogTrace, M_PI, MatchingResult::matched, SiStripPI::mean, normal_pdf(), omtfConfig, PV3DBase< T, PVType, FrameType >::phi(), l1t::RegionalMuonCand::processor(), muonRecoAnalyzer_cfi::ptBin, mps_fire::result, and cscDigiValidation_cfi::simTrack.

Referenced by match(), and observeEventEnd().

                                                                              {
  MatchingResult result(simTrack);

  double candGloablEta = muonCand->hwEta() * 0.010875;
  //if (std::abs(simTrack.momentum().eta() - candGloablEta) < 0.3) //has no sense for displaced muons
  {
    double candGlobalPhi = omtfConfig->calcGlobalPhi(muonCand->hwPhi(), muonCand->processor());
    candGlobalPhi = hwGmtPhiToGlobalPhi(candGlobalPhi);

    if (candGlobalPhi > M_PI)
      candGlobalPhi = candGlobalPhi - (2. * M_PI);

    result.deltaPhi = foldPhi(tsof.globalPosition().phi() - candGlobalPhi);
    result.deltaEta = tsof.globalPosition().eta() - candGloablEta;

    result.propagatedPhi = tsof.globalPosition().phi();
    result.propagatedEta = tsof.globalPosition().eta();

    double mean = 0;
    double sigma = 1;
    //if(!fillMean)
    {
      auto ptBin = deltaPhiPropCandMean->FindBin(simTrack.momentum().pt());
      mean = deltaPhiPropCandMean->GetBinContent(ptBin);
      sigma = deltaPhiPropCandStdDev->GetBinContent(ptBin);
    }
    result.matchingLikelihood = normal_pdf(result.deltaPhi, mean, sigma);  //TODO temporary solution

    result.muonCand = muonCand;
    result.procMuon = procMuon;

    double treshold = 6. * sigma;
    if (simTrack.momentum().pt() > 20)
      treshold = 7. * sigma;
    if (simTrack.momentum().pt() > 100)
      treshold = 20. * sigma;

    //for displaced muons in H2ll
    treshold = 0.15;  //pt > 30
    if (simTrack.momentum().pt() <
        10)  //TODO!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! tune the threshold!!!!!!
      treshold = 0.3;
    else if (simTrack.momentum().pt() <
             30)  //TODO!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! tune the threshold!!!!!!
      treshold = 0.22;

    if (std::abs(result.deltaPhi - mean) < treshold && std::abs(result.deltaEta) < 0.3)
      result.result = MatchingResult::ResultType::matched;

    LogTrace("l1tOmtfEventPrint") << "CandidateSimMuonMatcher::match: simTrack type " << simTrack.type() << " pt "
                                  << std::setw(8) << simTrack.momentum().pt() << " eta " << std::setw(8)
                                  << simTrack.momentum().eta() << " phi " << std::setw(8) << simTrack.momentum().phi()
                                  << " propagation eta " << std::setw(8) << tsof.globalPosition().eta() << " phi "
                                  << tsof.globalPosition().phi() << "\n             muonCand pt " << std::setw(8)
                                  << muonCand->hwPt() << " candGloablEta " << std::setw(8) << candGloablEta
                                  << " candGlobalPhi " << std::setw(8) << candGlobalPhi << " hwQual "
                                  << muonCand->hwQual() << " deltaEta " << std::setw(8) << result.deltaEta
                                  << " deltaPhi " << std::setw(8) << result.deltaPhi << " sigma " << std::setw(8)
                                  << sigma << " Likelihood " << std::setw(8) << result.matchingLikelihood << " result "
                                  << (short)result.result << std::endl;
  }

  return result;
}

match() [2/4]

MatchingResult CandidateSimMuonMatcher::match	(	const l1t::RegionalMuonCand *	omtfCand,
		const AlgoMuonPtr &	procMuon,
		const TrackingParticle &	trackingParticle,
		TrajectoryStateOnSurface &	tsof
	)

Definition at line 478 of file CandidateSimMuonMatcher.cc.

References funct::abs(), OMTFConfiguration::calcGlobalPhi(), deltaPhiPropCandMean, deltaPhiPropCandStdDev, PV3DBase< T, PVType, FrameType >::eta(), foldPhi(), TrajectoryStateOnSurface::globalPosition(), l1t::RegionalMuonCand::hwEta(), hwGmtPhiToGlobalPhi(), l1t::RegionalMuonCand::hwPhi(), l1t::RegionalMuonCand::hwPt(), l1t::RegionalMuonCand::hwQual(), LogTrace, M_PI, MatchingResult::matched, SiStripPI::mean, TrackingParticle::momentum(), normal_pdf(), omtfConfig, TrackingParticle::pdgId(), PV3DBase< T, PVType, FrameType >::phi(), l1t::RegionalMuonCand::processor(), TrackingParticle::pt(), muonRecoAnalyzer_cfi::ptBin, and mps_fire::result.

                                                                              {
  MatchingResult result(trackingParticle);

  double candGloablEta = muonCand->hwEta() * 0.010875;
  //if (std::abs(trackingParticle.momentum().eta() - candGloablEta) < 0.3)  //has no sense for displaced muons
  {
    double candGlobalPhi = omtfConfig->calcGlobalPhi(muonCand->hwPhi(), muonCand->processor());
    candGlobalPhi = hwGmtPhiToGlobalPhi(candGlobalPhi);

    if (candGlobalPhi > M_PI)
      candGlobalPhi = candGlobalPhi - (2. * M_PI);

    result.deltaPhi = foldPhi(tsof.globalPosition().phi() - candGlobalPhi);
    result.deltaEta = tsof.globalPosition().eta() - candGloablEta;

    result.propagatedPhi = tsof.globalPosition().phi();
    result.propagatedEta = tsof.globalPosition().eta();

    double mean = 0;
    double sigma = 1;
    //if(!fillMean)
    {
      auto ptBin = deltaPhiPropCandMean->FindBin(trackingParticle.pt());

      mean = deltaPhiPropCandMean->GetBinContent(ptBin);
      sigma = deltaPhiPropCandStdDev->GetBinContent(ptBin);
    }

    result.matchingLikelihood = normal_pdf(result.deltaPhi, mean, sigma);  //TODO temporary solution

    result.muonCand = muonCand;
    result.procMuon = procMuon;

    double treshold = 6. * sigma;
    if (trackingParticle.pt() > 20)
      treshold = 7. * sigma;
    if (trackingParticle.pt() > 100)
      treshold = 20. * sigma;

    if (std::abs(result.deltaPhi - mean) < treshold && std::abs(result.deltaEta) < 0.3)
      result.result = MatchingResult::ResultType::matched;

    LogTrace("l1tOmtfEventPrint") << "CandidateSimMuonMatcher::match: trackingParticle type "
                                  << trackingParticle.pdgId() << " pt " << std::setw(8) << trackingParticle.pt()
                                  << " eta " << std::setw(8) << trackingParticle.momentum().eta() << " phi "
                                  << std::setw(8) << trackingParticle.momentum().phi() << " propagation eta "
                                  << std::setw(8) << tsof.globalPosition().eta() << " phi "
                                  << tsof.globalPosition().phi() << " muonCand pt " << std::setw(8) << muonCand->hwPt()
                                  << " candGloablEta " << std::setw(8) << candGloablEta << " candGlobalPhi "
                                  << std::setw(8) << candGlobalPhi << " hwQual " << muonCand->hwQual() << " deltaEta "
                                  << std::setw(8) << result.deltaEta << " deltaPhi " << std::setw(8) << result.deltaPhi
                                  << " Likelihood " << std::setw(8) << result.matchingLikelihood << " result "
                                  << (short)result.result << std::endl;
  }

  return result;
}

match() [3/4]

std::vector< MatchingResult > CandidateSimMuonMatcher::match	(	std::vector< const l1t::RegionalMuonCand *> &	muonCands,
		AlgoMuons &	ghostBustedProcMuons,
		const edm::SimTrackContainer *	simTracks,
		const edm::SimVertexContainer *	simVertices,
		std::function< bool(const SimTrack &)> const &	simTrackFilter
	)

Definition at line 623 of file CandidateSimMuonMatcher.cc.

References funct::abs(), cleanMatching(), PV3DBase< T, PVType, FrameType >::eta(), TrajectoryStateOnSurface::globalPosition(), TrajectoryStateOnSurface::isValid(), LogTrace, match(), MatchingResult::matched, muonTagProbeFilters_cff::matched, matchingResults, propagate(), MatchingResult::propagationFailed, mps_fire::result, cscDigiValidation_cfi::simTrack, TrackCandidateProducer_cfi::simTracks, HGCalValidator_cfi::simVertices, and run3scouting_cff::vtxInd.

                                                                                                                     {
  std::vector<MatchingResult> matchingResults;

  for (auto& simTrack : *simTracks) {
    if (!simTrackFilter(simTrack))
      continue;

    LogTrace("l1tOmtfEventPrint") << "CandidateSimMuonMatcher::match, simTrack type " << std::setw(3) << simTrack.type()
                                  << " pt " << std::setw(9) << simTrack.momentum().pt() << " eta " << std::setw(9)
                                  << simTrack.momentum().eta() << " phi " << std::setw(9) << simTrack.momentum().phi()
                                  << std::endl;

    bool matched = false;

    TrajectoryStateOnSurface tsof = propagate(simTrack, simVertices);
    if (!tsof.isValid()) {  //no sense to do matching
      MatchingResult result(simTrack);
      result.result = MatchingResult::ResultType::propagationFailed;
      LogTrace("l1tOmtfEventPrint") << __FUNCTION__ << ":" << __LINE__ << " propagation failed: genPt " << result.genPt
                                    << " genEta " << result.genEta << " eventId " << simTrack.eventId().event()
                                    << std::endl;

      matchingResults.push_back(result);
    } else {
      //checking if the propagated track is inside the OMTF range, TODO - tune the range!!!!!!!!!!!!!!!!!
      //eta 0.7 is the beginning of the MB2,
      //the eta range wider than the nominal OMTF region is needed, as in any case muons outside this region are seen by the OMTF
      //so it better to train the nn suich that is able to measure its pt, as it may affect the rate
      if ((std::abs(tsof.globalPosition().eta()) >= 0.7) && (std::abs(tsof.globalPosition().eta()) <= 1.31)) {
        LogTrace("l1tOmtfEventPrint")
            << "CandidateSimMuonMatcher::match simTrack IS in OMTF region, matching to the omtfCands";
      } else {
        LogTrace("l1tOmtfEventPrint") << "simTrack NOT in OMTF region ";
        continue;
      }

      /* TODO fix if filling of the deltaPhiPropCandMean and deltaPhiPropCandStdDev is needed
    double ptGen = simTrack.momentum().pt();
    if(ptGen >= deltaPhiVertexProp->GetXaxis()->GetXmax())
      ptGen = deltaPhiVertexProp->GetXaxis()->GetXmax() - 0.01;

    deltaPhiVertexProp->Fill(ptGen, simTrack.momentum().phi() - tsof.globalPosition().phi());*/

      unsigned int iCand = 0;
      for (auto& muonCand : muonCands) {
        //dropping very low quality candidates, as they are fakes usually - but it has no sense, then the results are not conclusive
        //if(muonCand->hwQual() > 1)
        {
          MatchingResult result;
          if (tsof.isValid()) {
            result = match(muonCand, ghostBustedProcMuons.at(iCand), simTrack, tsof);
          }
          int vtxInd = simTrack.vertIndex();
          if (vtxInd >= 0) {
            result.simVertex = &(simVertices->at(
                vtxInd));  //TODO ?????? something strange is here, was commented in the previous version
          }
          if (result.result == MatchingResult::ResultType::matched) {
            matchingResults.push_back(result);
            matched = true;
          }
        }
        iCand++;
      }

      if (!matched) {  //we are adding also if it was not matching to any candidate
        MatchingResult result(simTrack);
        matchingResults.push_back(result);
        LogTrace("l1tOmtfEventPrint") << __FUNCTION__ << ":" << __LINE__ << " no matching candidate found" << std::endl;
      }
    }
  }

  return cleanMatching(matchingResults, muonCands, ghostBustedProcMuons);
}

match() [4/4]

std::vector< MatchingResult > CandidateSimMuonMatcher::match	(	std::vector< const l1t::RegionalMuonCand *> &	muonCands,
		AlgoMuons &	ghostBustedProcMuons,
		const TrackingParticleCollection *	trackingParticles,
		std::function< bool(const TrackingParticle &)> const &	simTrackFilter
	)

Definition at line 703 of file CandidateSimMuonMatcher.cc.

References funct::abs(), cleanMatching(), PV3DBase< T, PVType, FrameType >::eta(), TrajectoryStateOnSurface::globalPosition(), TrajectoryStateOnSurface::isValid(), LogTrace, match(), MatchingResult::matched, muonTagProbeFilters_cff::matched, matchingResults, propagate(), MatchingResult::propagationFailed, mps_fire::result, and muonClassificationByHits_cfi::trackingParticles.

                                                                      {
  std::vector<MatchingResult> matchingResults;
  LogTrace("l1tOmtfEventPrint") << "CandidateSimMuonMatcher::match trackingParticles->size() "
                                << trackingParticles->size() << std::endl;

  for (auto& trackingParticle : *trackingParticles) {
    //LogTrace("l1tOmtfEventPrint") <<"CandidateSimMuonMatcher::match:"<<__LINE__<<" trackingParticle type "<<std::setw(3)<<trackingParticle.pdgId()<<" pt "<<std::setw(9)<<trackingParticle.pt()<<" eta "<<std::setw(9)<<trackingParticle.momentum().eta()<<" phi "<<std::setw(9)<<trackingParticle.momentum().phi()<<std::endl;

    if (simTrackFilter(trackingParticle) == false)
      continue;

    LogTrace("l1tOmtfEventPrint") << "CandidateSimMuonMatcher::match, trackingParticle type " << std::setw(3)
                                  << trackingParticle.pdgId() << " pt " << std::setw(9) << trackingParticle.pt()
                                  << " eta " << std::setw(9) << trackingParticle.momentum().eta() << " phi "
                                  << std::setw(9) << trackingParticle.momentum().phi() << std::endl;

    bool matched = false;

    TrajectoryStateOnSurface tsof = propagate(trackingParticle);
    if (!tsof.isValid()) {
      LogTrace("l1tOmtfEventPrint") << "CandidateSimMuonMatcher::match:" << __LINE__ << " propagation failed"
                                    << std::endl;
      MatchingResult result;
      result.result = MatchingResult::ResultType::propagationFailed;
      continue;  //no sense to do matching
    }

    LogTrace("l1tOmtfEventPrint") << "CandidateSimMuonMatcher::match, tsof.globalPosition().eta() "
                                  << tsof.globalPosition().eta();

    //checking if the propagated track is inside the OMTF range, TODO - tune the range!!!!!!!!!!!!!!!!!
    //eta 0.7 is the beginning of the MB2, while 1.31 is mid of RE2 + some margin
    if ((std::abs(tsof.globalPosition().eta()) >= 0.7) && (std::abs(tsof.globalPosition().eta()) <= 1.31)) {
      LogTrace("l1tOmtfEventPrint")
          << "CandidateSimMuonMatcher::match trackingParticle IS in OMTF region, matching to the omtfCands";
    } else {
      LogTrace("l1tOmtfEventPrint") << "trackingParticle NOT in OMTF region ";
      continue;
    }

    /* TODO fix if filling of the deltaPhiPropCandMean and deltaPhiPropCandStdDev is needed
    double ptGen = trackingParticle.pt();
    if(ptGen >= deltaPhiVertexProp->GetXaxis()->GetXmax())
      ptGen = deltaPhiVertexProp->GetXaxis()->GetXmax() - 0.01;

    deltaPhiVertexProp->Fill(ptGen, trackingParticle.momentum().phi() - tsof.globalPosition().phi());
     */

    unsigned int iCand = 0;
    for (auto& muonCand : muonCands) {
      //dropping very low quality candidates, as they are fakes usually - but it has no sense, then the results are not conclusive then
      /*if(muonCand->hwQual() <= 1)
        continue; */

      MatchingResult result;
      if (tsof.isValid()) {
        result = match(muonCand, ghostBustedProcMuons.at(iCand), trackingParticle, tsof);
      }
      iCand++;

      if (result.result == MatchingResult::ResultType::matched) {
        matchingResults.push_back(result);
        matched = true;
      }
    }

    if (!matched) {  //we are adding result also if it there was no matching to any candidate
      MatchingResult result(trackingParticle);
      matchingResults.push_back(result);
      LogTrace("l1tOmtfEventPrint") << __FUNCTION__ << ":" << __LINE__ << " no matching candidate found" << std::endl;
    }
  }

  return cleanMatching(matchingResults, muonCands, ghostBustedProcMuons);
}

matchSimple()

std::vector< MatchingResult > CandidateSimMuonMatcher::matchSimple	(	std::vector< const l1t::RegionalMuonCand *> &	muonCands,
		AlgoMuons &	ghostBustedProcMuons,
		const edm::SimTrackContainer *	simTracks,
		const edm::SimVertexContainer *	simVertices,
		std::function< bool(const SimTrack &)> const &	simTrackFilter
	)

Definition at line 783 of file CandidateSimMuonMatcher.cc.

References funct::abs(), OMTFConfiguration::calcGlobalPhi(), cleanMatching(), foldPhi(), hwGmtPhiToGlobalPhi(), LogTrace, M_PI, MatchingResult::matched, muonTagProbeFilters_cff::matched, matchingResults, omtfConfig, mps_fire::result, cscDigiValidation_cfi::simTrack, TrackCandidateProducer_cfi::simTracks, HGCalValidator_cfi::simVertices, and run3scouting_cff::vtxInd.

Referenced by observeEventEnd().

                                                              {
  std::vector<MatchingResult> matchingResults;

  for (auto& simTrack : *simTracks) {
    if (!simTrackFilter(simTrack))
      continue;

    LogTrace("l1tOmtfEventPrint") << "CandidateSimMuonMatcher::matchSimple: simTrack type " << std::setw(3)
                                  << simTrack.type() << " pt " << std::setw(9) << simTrack.momentum().pt() << " eta "
                                  << std::setw(9) << simTrack.momentum().eta() << " phi " << std::setw(9)
                                  << simTrack.momentum().phi() << std::endl;

    bool matched = false;

    unsigned int iCand = 0;
    for (auto& muonCand : muonCands) {
      //dropping very low quality candidates, as they are fakes usually - but it has no sense, then the results are not conclusive
      //if(muonCand->hwQual() > 1)
      {
        MatchingResult result(simTrack);

        double candGloablEta = muonCand->hwEta() * 0.010875;
        double candGlobalPhi = omtfConfig->calcGlobalPhi(muonCand->hwPhi(), muonCand->processor());
        candGlobalPhi = hwGmtPhiToGlobalPhi(candGlobalPhi);

        if (candGlobalPhi > M_PI)
          candGlobalPhi = candGlobalPhi - (2. * M_PI);

        result.deltaPhi = foldPhi(result.genPhi - candGlobalPhi);
        result.deltaEta = result.genEta - candGloablEta;

        result.propagatedPhi = 0;
        result.propagatedEta = 0;

        result.muonCand = muonCand;
        result.procMuon = ghostBustedProcMuons.at(iCand);

        //TODO histogram can be used, like in the usercode/L1MuonAnalyzer  MuonMatcher::matchWithoutPorpagation
        //for prompt muons
        /*double treshold = 0.3;
        if (simTrack.momentum().pt() < 5)
          treshold = 1.5;
        else if (simTrack.momentum().pt() < 8)
          treshold = 0.8;
        else if (simTrack.momentum().pt() < 10)
          treshold = 0.6;
        else if (simTrack.momentum().pt() < 20)
          treshold = 0.5;*/

        //for displaced muons
        double treshold = 0.7;
        if (simTrack.momentum().pt() < 5)
          treshold = 1.5;
        else if (simTrack.momentum().pt() < 10)
          treshold = 1.0;
        else if (simTrack.momentum().pt() < 20)
          treshold = 0.7;

        if (std::abs(result.deltaPhi) < treshold && std::abs(result.deltaEta) < 0.5) {
          result.result = MatchingResult::ResultType::matched;
          //matchingLikelihood is needed in the cleanMatching, so we put something
          if (std::abs(result.deltaPhi) < 0.001)
            result.matchingLikelihood = 1. / 0.001;
          else
            result.matchingLikelihood = 1. / std::abs(result.deltaPhi);
        }

        LogTrace("l1tOmtfEventPrint") << "CandidateSimMuonMatcher::matchSimple: simTrack type " << simTrack.type()
                                      << " pt " << std::setw(8) << simTrack.momentum().pt() << " eta " << std::setw(8)
                                      << simTrack.momentum().eta() << " phi " << std::setw(8)
                                      << simTrack.momentum().phi() << "\n             muonCand pt " << std::setw(8)
                                      << muonCand->hwPt() << " candGloablEta " << std::setw(8) << candGloablEta
                                      << " candGlobalPhi " << std::setw(8) << candGlobalPhi << " hwQual "
                                      << muonCand->hwQual() << " deltaEta " << std::setw(8) << result.deltaEta
                                      << " deltaPhi " << std::setw(8) << result.deltaPhi << " matchingLikelihood "
                                      << result.matchingLikelihood << " result " << (short)result.result << std::endl;

        int vtxInd = simTrack.vertIndex();
        if (vtxInd >= 0) {
          result.simVertex = &(
              simVertices->at(vtxInd));  //TODO ?????? something strange is here, was commented in the previous version
        }
        if (result.result == MatchingResult::ResultType::matched) {
          matchingResults.push_back(result);
          matched = true;
        }
      }
      iCand++;
    }

    if (!matched) {  //we are adding also if it was not matched to any candidate
      MatchingResult result(simTrack);
      matchingResults.push_back(result);
      LogTrace("l1tOmtfEventPrint") << __FUNCTION__ << ":" << __LINE__ << " no matching candidate found" << std::endl;
    }
  }

  return cleanMatching(matchingResults, muonCands, ghostBustedProcMuons);
}

observeEventBegin()

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

overridevirtual

Reimplemented from IOMTFEmulationObserver.

Definition at line 81 of file CandidateSimMuonMatcher.cc.

References gbCandidates.

{ gbCandidates.clear(); }

observeEventEnd()

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

overridevirtual

Reimplemented from IOMTFEmulationObserver.

Definition at line 205 of file CandidateSimMuonMatcher.cc.

References edmCfg, edm::ParameterSet::exists(), gbCandidates, edm::ParameterSet::getParameter(), ghostBust(), LogTrace, match(), matchingResults, matchSimple(), edm::Handle< T >::product(), simTrackIsMuonInBx0(), simTrackIsMuonInOmtfBx0(), HGCalValidator_cfi::simVertices, trackingParticleIsMuonInBx0(), and usePropagation.

                                                                                                               {
  LogTrace("l1tOmtfEventPrint") << "\nCandidateSimMuonMatcher::observeEventEnd" << std::endl;
  AlgoMuons ghostBustedProcMuons;
  std::vector<const l1t::RegionalMuonCand*> ghostBustedRegionalCands =
      CandidateSimMuonMatcher::ghostBust(finalCandidates.get(), gbCandidates, ghostBustedProcMuons);

  matchingResults.clear();
  if (edmCfg.exists("simTracksTag")) {
    edm::Handle<edm::SimTrackContainer> simTraksHandle;
    event.getByLabel(edmCfg.getParameter<edm::InputTag>("simTracksTag"), simTraksHandle);

    edm::Handle<edm::SimVertexContainer> simVertices;
    event.getByLabel(edmCfg.getParameter<edm::InputTag>("simVertexesTag"), simVertices);

    LogTrace("l1tOmtfEventPrint") << "simTraksHandle size " << simTraksHandle.product()->size() << std::endl;
    LogTrace("l1tOmtfEventPrint") << "simVertices size " << simVertices.product()->size() << std::endl;

    if (usePropagation) {
      //TODO  use other simTrackFilter if needed  <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
      //we dont want to check the eta of the generated muon, as it is on the vertex,
      //instead inside match, we check the eta of the propagated track to the second muons station
      std::function<bool(const SimTrack&)> const& simTrackFilter = simTrackIsMuonInBx0;  //simTrackIsMuonInOmtfBx0;

      matchingResults = match(ghostBustedRegionalCands,
                              ghostBustedProcMuons,
                              simTraksHandle.product(),
                              simVertices.product(),
                              simTrackFilter);
    } else {
      std::function<bool(const SimTrack&)> const& simTrackFilter = simTrackIsMuonInOmtfBx0;
      //simTrackIsMuonInOmtfBx0 provides appropriate eta cut

      matchingResults = matchSimple(ghostBustedRegionalCands,
                                    ghostBustedProcMuons,
                                    simTraksHandle.product(),
                                    simVertices.product(),
                                    simTrackFilter);
    }

  } else if (edmCfg.exists("trackingParticleTag")) {
    edm::Handle<TrackingParticleCollection> trackingParticleHandle;
    event.getByLabel(edmCfg.getParameter<edm::InputTag>("trackingParticleTag"), trackingParticleHandle);
    LogTrace("l1tOmtfEventPrint") << "\nCandidateSimMuonMatcher::observeEventEnd trackingParticleHandle size "
                                  << trackingParticleHandle.product()->size() << std::endl;

    //TODO use other trackParticleFilter if needed <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
    std::function<bool(const TrackingParticle&)> trackParticleFilter =
        trackingParticleIsMuonInBx0;  //trackingParticleIsMuonInOmtfBx0;
    matchingResults =
        match(ghostBustedRegionalCands, ghostBustedProcMuons, trackingParticleHandle.product(), trackParticleFilter);
  }
}

observeProcesorEmulation()

void CandidateSimMuonMatcher::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 83 of file CandidateSimMuonMatcher.cc.

References gbCandidates, OMTFConfiguration::getProcIndx(), LogTrace, and omtfConfig.

                                                                                                        {
  //debug
  unsigned int procIndx = omtfConfig->getProcIndx(iProcessor, mtfType);
  for (auto& gbCandidate : gbCandidates) {
    if (gbCandidate->getPtConstr() > 0) {
      LogTrace("l1tOmtfEventPrint") << "CandidateSimMuonMatcher::observeProcesorEmulation procIndx" << procIndx << " "
                                    << *gbCandidate << std::endl;
      this->gbCandidates.emplace_back(gbCandidate);
    }
  }
}

propagate() [1/2]

TrajectoryStateOnSurface CandidateSimMuonMatcher::propagate	(	const SimTrack &	simTrack,
		const edm::SimVertexContainer *	simVertices
	)

Definition at line 374 of file CandidateSimMuonMatcher.cc.

References atStation2(), cscDigiValidation_cfi::simTrack, simTrackToFts(), hltEcalDetailedTimeRecHit_cfi::simVertex, HGCalValidator_cfi::simVertices, and run3scouting_cff::vtxInd.

Referenced by match().

                                                                                                      {
  SimVertex simVertex;
  int vtxInd = simTrack.vertIndex();
  if (vtxInd < 0) {
    edm::LogImportant("l1tOmtfEventPrint") << "Track with no vertex, defaulting to (0,0,0)";
  } else {
    simVertex = simVertices->at(vtxInd);
    if (((int)simVertex.vertexId()) != vtxInd) {
      edm::LogImportant("l1tOmtfEventPrint") << "simVertex.vertexId() != vtxInd. simVertex.vertexId() "
                                             << simVertex.vertexId() << " vtxInd " << vtxInd << " !!!!!!!!!!!!!!!!!";
    }
  }

  FreeTrajectoryState ftsTrack = simTrackToFts(simTrack, simVertex);

  TrajectoryStateOnSurface tsof = atStation2(ftsTrack);  //propagation

  return tsof;
}

propagate() [2/2]

TrajectoryStateOnSurface CandidateSimMuonMatcher::propagate

(

const TrackingParticle &

trackingParticle

)

Definition at line 395 of file CandidateSimMuonMatcher.cc.

References atStation2(), and simTrackToFts().

                                                                                                    {
  FreeTrajectoryState ftsTrack = simTrackToFts(trackingParticle);

  TrajectoryStateOnSurface tsof = atStation2(ftsTrack);  //propagation

  return tsof;
}

simTrackToFts() [1/2]

FreeTrajectoryState CandidateSimMuonMatcher::simTrackToFts	(	const SimTrack &	simTrack,
		const SimVertex &	simVertex
	)

Definition at line 352 of file CandidateSimMuonMatcher.cc.

References ALCARECOTkAlJpsiMuMu_cff::charge, magField, CoreSimTrack::momentum(), hltEcalDetailedTimeRecHit_cfi::simVertex, and CoreSimTrack::type().

Referenced by propagate().

                                                                                                                  {
  int charge = simTrackPtr.type() > 0 ? -1 : 1;  //works for muons

  GlobalVector p3GV(simTrackPtr.momentum().x(), simTrackPtr.momentum().y(), simTrackPtr.momentum().z());
  GlobalPoint r3GP(simVertex.position().x(), simVertex.position().y(), simVertex.position().z());

  GlobalTrajectoryParameters tPars(r3GP, p3GV, charge, &*magField);

  return FreeTrajectoryState(tPars);
}

simTrackToFts() [2/2]

FreeTrajectoryState CandidateSimMuonMatcher::simTrackToFts

(

const TrackingParticle &

trackingParticle

)

Definition at line 363 of file CandidateSimMuonMatcher.cc.

References ALCARECOTkAlJpsiMuMu_cff::charge, magField, TrackingParticle::momentum(), TrackingParticle::pdgId(), TrackingParticle::vx(), TrackingParticle::vy(), and TrackingParticle::vz().

                                                                                                   {
  int charge = trackingParticle.pdgId() > 0 ? -1 : 1;  //works for muons

  GlobalVector p3GV(trackingParticle.momentum().x(), trackingParticle.momentum().y(), trackingParticle.momentum().z());
  GlobalPoint r3GP(trackingParticle.vx(), trackingParticle.vy(), trackingParticle.vz());

  GlobalTrajectoryParameters tPars(r3GP, p3GV, charge, &*magField);

  return FreeTrajectoryState(tPars);
}

Member Data Documentation

deltaPhiPropCandMean

TH1D* CandidateSimMuonMatcher::deltaPhiPropCandMean = nullptr

private

Definition at line 192 of file CandidateSimMuonMatcher.h.

Referenced by CandidateSimMuonMatcher(), and match().

deltaPhiPropCandStdDev

TH1D* CandidateSimMuonMatcher::deltaPhiPropCandStdDev = nullptr

private

Definition at line 193 of file CandidateSimMuonMatcher.h.

Referenced by CandidateSimMuonMatcher(), and match().

edmCfg

const edm::ParameterSet& CandidateSimMuonMatcher::edmCfg

private

Definition at line 181 of file CandidateSimMuonMatcher.h.

Referenced by CandidateSimMuonMatcher(), and observeEventEnd().

gbCandidates

AlgoMuons CandidateSimMuonMatcher::gbCandidates

private

Definition at line 183 of file CandidateSimMuonMatcher.h.

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

magField

edm::ESHandle<MagneticField> CandidateSimMuonMatcher::magField

private

Definition at line 189 of file CandidateSimMuonMatcher.h.

Referenced by beginRun(), and simTrackToFts().

magneticFieldEsToken

const edm::ESGetToken<MagneticField, IdealMagneticFieldRecord>& CandidateSimMuonMatcher::magneticFieldEsToken

private

Definition at line 186 of file CandidateSimMuonMatcher.h.

Referenced by beginRun().

matchingResults

std::vector<MatchingResult> CandidateSimMuonMatcher::matchingResults

private

Definition at line 184 of file CandidateSimMuonMatcher.h.

Referenced by cleanMatching(), getMatchingResults(), match(), matchSimple(), and observeEventEnd().

omtfConfig

const OMTFConfiguration* CandidateSimMuonMatcher::omtfConfig

private

Definition at line 179 of file CandidateSimMuonMatcher.h.

Referenced by ghostBust(), match(), matchSimple(), and observeProcesorEmulation().

propagator

edm::ESHandle<Propagator> CandidateSimMuonMatcher::propagator

private

Definition at line 190 of file CandidateSimMuonMatcher.h.

Referenced by atStation2(), and beginRun().

propagatorEsToken

const edm::ESGetToken<Propagator, TrackingComponentsRecord>& CandidateSimMuonMatcher::propagatorEsToken

private

Definition at line 187 of file CandidateSimMuonMatcher.h.

Referenced by beginRun().

usePropagation

bool CandidateSimMuonMatcher::usePropagation = false

private

Definition at line 195 of file CandidateSimMuonMatcher.h.

Referenced by CandidateSimMuonMatcher(), and observeEventEnd().