L1MuonSeededTrackingRegionsProducer Class Reference

#include <L1MuonSeededTrackingRegionsProducer.h>

Inheritance diagram for L1MuonSeededTrackingRegionsProducer:

Public Types
enum	Mode { BEAM_SPOT_FIXED, BEAM_SPOT_SIGMA, VERTICES_FIXED, VERTICES_SIGMA }

Public Member Functions
	L1MuonSeededTrackingRegionsProducer (const edm::ParameterSet &iConfig, edm::ConsumesCollector &&iC)
std::vector< std::unique_ptr< TrackingRegion > >	regions (const edm::Event &iEvent, const edm::EventSetup &iSetup) const override
	~L1MuonSeededTrackingRegionsProducer () override=default
Public Member Functions inherited from TrackingRegionProducer
virtual	~TrackingRegionProducer ()

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Attributes
const bool	centralBxOnly_
const double	l1MaxEta_
const double	l1MinPt_
const unsigned	l1MinQuality_
std::vector< double >	m_deltaEtas
std::vector< double >	m_deltaPhis
int	m_maxNRegions
int	m_maxNVertices
Mode	m_mode
float	m_nSigmaZBeamSpot
float	m_nSigmaZVertex
float	m_originRadius
bool	m_precise
float	m_ptMin
std::vector< double >	m_ptRanges
bool	m_searchOpt
RectangularEtaPhiTrackingRegion::UseMeasurementTracker	m_whereToUseMeasurementTracker
float	m_zErrorBeamSpot
float	m_zErrorVetex
const double	minPtBarrel_
const double	minPtEndcap_
const std::string	propagatorName_
std::unique_ptr< MuonServiceProxy >	service_
edm::EDGetTokenT< reco::BeamSpot >	token_beamSpot
const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	token_field
edm::EDGetTokenT< l1t::MuonBxCollection >	token_input
edm::EDGetTokenT< MeasurementTrackerEvent >	token_measurementTracker
edm::ESGetToken< MultipleScatteringParametrisationMaker, TrackerMultipleScatteringRecord >	token_msmaker
edm::EDGetTokenT< reco::VertexCollection >	token_vertex

Static Private Attributes
static constexpr int	l1MuonTF_link_EMTFN_f_ {71}
static constexpr int	l1MuonTF_link_EMTFN_i_ {66}
static constexpr int	l1MuonTF_link_EMTFP_f_ {41}
static constexpr int	l1MuonTF_link_EMTFP_i_ {36}
static constexpr double	sigma_lambda_ {0.05}
static constexpr double	sigma_phi_ {0.2}
static constexpr double	sigma_qbpt_barrel_ {0.25}
static constexpr double	sigma_qbpt_endcap_ {0.4}
static constexpr double	sigma_qbpt_invalid_charge_ {1.0}
static constexpr double	sigma_x_ {20.0}
static constexpr double	sigma_y_ {20.0}

Detailed Description

class L1MuonSeededTrackingRegionsProducer

eta-phi TrackingRegions producer in directions defined by L1 muon objects of interest from a collection defined by the "input" parameter.

Four operational modes are supported ("mode" parameter):

BeamSpotFixed: origin is defined by the beam spot z-half-length is defined by a fixed zErrorBeamSpot parameter BeamSpotSigma: origin is defined by the beam spot z-half-length is defined by nSigmaZBeamSpot * beamSpot.sigmaZ VerticesFixed: origins are defined by vertices from VertexCollection (use maximum MaxNVertices of them) z-half-length is defined by a fixed zErrorVetex parameter VerticesSigma: origins are defined by vertices from VertexCollection (use maximum MaxNVertices of them) z-half-length is defined by nSigmaZVertex * vetex.zError

If, while using one of the "Vertices" modes, there's no vertices in an event, we fall back into either BeamSpotSigma or BeamSpotFixed mode, depending on the positiveness of nSigmaZBeamSpot.

Author

M. Oh. based on RecoTracker/TkTrackingRegions/plugins/CandidateSeededTrackingRegionsProducer.h

Definition at line 55 of file L1MuonSeededTrackingRegionsProducer.h.

Member Enumeration Documentation

Mode

enum L1MuonSeededTrackingRegionsProducer::Mode

Enumerator
BEAM_SPOT_FIXED
BEAM_SPOT_SIGMA
VERTICES_FIXED
VERTICES_SIGMA

Definition at line 57 of file L1MuonSeededTrackingRegionsProducer.h.

{ BEAM_SPOT_FIXED, BEAM_SPOT_SIGMA, VERTICES_FIXED, VERTICES_SIGMA } Mode;

Constructor & Destructor Documentation

L1MuonSeededTrackingRegionsProducer()

L1MuonSeededTrackingRegionsProducer::L1MuonSeededTrackingRegionsProducer ( const edm::ParameterSet &  iConfig, edm::ConsumesCollector &&  iC  )

inlineexplicit

Definition at line 59 of file L1MuonSeededTrackingRegionsProducer.h.

References BEAM_SPOT_FIXED, BEAM_SPOT_SIGMA, edm::ParameterSet::getParameter(), RectangularEtaPhiTrackingRegion::kNever, m_deltaEtas, m_deltaPhis, m_maxNRegions, m_maxNVertices, m_mode, m_nSigmaZBeamSpot, m_nSigmaZVertex, m_originRadius, m_precise, m_ptMin, m_ptRanges, m_searchOpt, m_whereToUseMeasurementTracker, m_zErrorBeamSpot, m_zErrorVetex, eostools::move(), service_, AlCaHLTBitMon_QueryRunRegistry::string, RectangularEtaPhiTrackingRegion::stringToUseMeasurementTracker(), token_beamSpot, token_input, token_measurementTracker, token_msmaker, token_vertex, VERTICES_FIXED, and VERTICES_SIGMA.

      : token_field(iC.esConsumes()),
        l1MinPt_(iConfig.getParameter<double>("L1MinPt")),
        l1MaxEta_(iConfig.getParameter<double>("L1MaxEta")),
        l1MinQuality_(iConfig.getParameter<unsigned int>("L1MinQuality")),
        minPtBarrel_(iConfig.getParameter<double>("SetMinPtBarrelTo")),
        minPtEndcap_(iConfig.getParameter<double>("SetMinPtEndcapTo")),
        centralBxOnly_(iConfig.getParameter<bool>("CentralBxOnly")),
        propagatorName_(iConfig.getParameter<std::string>("Propagator")) {
    edm::ParameterSet regPSet = iConfig.getParameter<edm::ParameterSet>("RegionPSet");

    // operation mode
    std::string modeString = regPSet.getParameter<std::string>("mode");
    if (modeString == "BeamSpotFixed")
      m_mode = BEAM_SPOT_FIXED;
    else if (modeString == "BeamSpotSigma")
      m_mode = BEAM_SPOT_SIGMA;
    else if (modeString == "VerticesFixed")
      m_mode = VERTICES_FIXED;
    else if (modeString == "VerticesSigma")
      m_mode = VERTICES_SIGMA;
    else
      edm::LogError("L1MuonSeededTrackingRegionsProducer") << "Unknown mode string: " << modeString;

    // basic inputs
    token_input = iC.consumes<l1t::MuonBxCollection>(regPSet.getParameter<edm::InputTag>("input"));
    m_maxNRegions = regPSet.getParameter<int>("maxNRegions");
    token_beamSpot = iC.consumes<reco::BeamSpot>(regPSet.getParameter<edm::InputTag>("beamSpot"));
    m_maxNVertices = 1;
    if (m_mode == VERTICES_FIXED || m_mode == VERTICES_SIGMA) {
      token_vertex = iC.consumes<reco::VertexCollection>(regPSet.getParameter<edm::InputTag>("vertexCollection"));
      m_maxNVertices = regPSet.getParameter<int>("maxNVertices");
    }

    // RectangularEtaPhiTrackingRegion parameters:
    m_ptMin = regPSet.getParameter<double>("ptMin");
    m_originRadius = regPSet.getParameter<double>("originRadius");
    m_zErrorBeamSpot = regPSet.getParameter<double>("zErrorBeamSpot");
    m_ptRanges = regPSet.getParameter<std::vector<double>>("ptRanges");
    if (m_ptRanges.size() < 2) {
      edm::LogError("L1MuonSeededTrackingRegionsProducer") << "Size of ptRanges does not be less than 2" << std::endl;
    }
    m_deltaEtas = regPSet.getParameter<std::vector<double>>("deltaEtas");
    if (m_deltaEtas.size() != m_ptRanges.size() - 1) {
      edm::LogError("L1MuonSeededTrackingRegionsProducer")
          << "Size of deltaEtas does not match number of pt bins." << std::endl;
    }
    m_deltaPhis = regPSet.getParameter<std::vector<double>>("deltaPhis");
    if (m_deltaPhis.size() != m_ptRanges.size() - 1) {
      edm::LogError("L1MuonSeededTrackingRegionsProducer")
          << "Size of deltaPhis does not match number of pt bins." << std::endl;
    }

    m_precise = regPSet.getParameter<bool>("precise");
    m_whereToUseMeasurementTracker = RectangularEtaPhiTrackingRegion::stringToUseMeasurementTracker(
        regPSet.getParameter<std::string>("whereToUseMeasurementTracker"));
    if (m_whereToUseMeasurementTracker != RectangularEtaPhiTrackingRegion::UseMeasurementTracker::kNever) {
      token_measurementTracker =
          iC.consumes<MeasurementTrackerEvent>(regPSet.getParameter<edm::InputTag>("measurementTrackerName"));
    }

    m_searchOpt = regPSet.getParameter<bool>("searchOpt");

    // mode-dependent z-halflength of tracking regions
    if (m_mode == VERTICES_SIGMA)
      m_nSigmaZVertex = regPSet.getParameter<double>("nSigmaZVertex");
    if (m_mode == VERTICES_FIXED)
      m_zErrorVetex = regPSet.getParameter<double>("zErrorVetex");
    m_nSigmaZBeamSpot = -1.;
    if (m_mode == BEAM_SPOT_SIGMA) {
      m_nSigmaZBeamSpot = regPSet.getParameter<double>("nSigmaZBeamSpot");
      if (m_nSigmaZBeamSpot < 0.)
        edm::LogError("L1MuonSeededTrackingRegionsProducer")
            << "nSigmaZBeamSpot must be positive for BeamSpotSigma mode!";
    }
    if (m_precise) {
      token_msmaker = iC.esConsumes();
    }

    // MuonServiceProxy
    edm::ParameterSet serviceParameters = iConfig.getParameter<edm::ParameterSet>("ServiceParameters");
    service_ = std::make_unique<MuonServiceProxy>(serviceParameters, std::move(iC));
  }

~L1MuonSeededTrackingRegionsProducer()

L1MuonSeededTrackingRegionsProducer::~L1MuonSeededTrackingRegionsProducer ( )

overridedefault

Member Function Documentation

fillDescriptions()

static void L1MuonSeededTrackingRegionsProducer::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions )

inlinestatic

Definition at line 145 of file L1MuonSeededTrackingRegionsProducer.h.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addUntracked(), submitPVResolutionJobs::desc, ProducerED_cfi::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                           {
    edm::ParameterSetDescription desc;

    // L1 muon selection parameters
    desc.add<std::string>("Propagator", "");
    desc.add<double>("L1MinPt", -1.);
    desc.add<double>("L1MaxEta", 5.0);
    desc.add<unsigned int>("L1MinQuality", 0);
    desc.add<double>("SetMinPtBarrelTo", 3.5);
    desc.add<double>("SetMinPtEndcapTo", 1.0);
    desc.add<bool>("CentralBxOnly", true);

    // Tracking region parameters
    edm::ParameterSetDescription descRegion;
    descRegion.add<std::string>("mode", "BeamSpotSigma");
    descRegion.add<edm::InputTag>("input", edm::InputTag(""));
    descRegion.add<int>("maxNRegions", 10);
    descRegion.add<edm::InputTag>("beamSpot", edm::InputTag("hltOnlineBeamSpot"));
    descRegion.add<edm::InputTag>("vertexCollection", edm::InputTag("notUsed"));
    descRegion.add<int>("maxNVertices", 1);
    descRegion.add<double>("ptMin", 0.0);
    descRegion.add<double>("originRadius", 0.2);
    descRegion.add<double>("zErrorBeamSpot", 24.2);
    descRegion.add<std::vector<double>>("ptRanges", {0., 1.e9});
    descRegion.add<std::vector<double>>("deltaEtas", {0.35});
    descRegion.add<std::vector<double>>("deltaPhis", {0.2});
    descRegion.add<bool>("precise", true);
    descRegion.add<double>("nSigmaZVertex", 3.);
    descRegion.add<double>("zErrorVetex", 0.2);
    descRegion.add<double>("nSigmaZBeamSpot", 4.);
    descRegion.add<std::string>("whereToUseMeasurementTracker", "Never");
    descRegion.add<edm::InputTag>("measurementTrackerName", edm::InputTag(""));
    descRegion.add<bool>("searchOpt", false);
    desc.add<edm::ParameterSetDescription>("RegionPSet", descRegion);

    // MuonServiceProxy for the propagation
    edm::ParameterSetDescription psd0;
    psd0.addUntracked<std::vector<std::string>>("Propagators", {"SteppingHelixPropagatorAny"});
    psd0.add<bool>("RPCLayers", false);
    psd0.addUntracked<bool>("UseMuonNavigation", false);
    desc.add<edm::ParameterSetDescription>("ServiceParameters", psd0);

    descriptions.add("hltIterL3MuonPixelTracksTrackingRegions", desc);
  }

regions()

std::vector<std::unique_ptr<TrackingRegion> > L1MuonSeededTrackingRegionsProducer::regions ( const edm::Event &  iEvent, const edm::EventSetup &  iSetup  ) const

inlineoverridevirtual

Implements TrackingRegionProducer.

Definition at line 190 of file L1MuonSeededTrackingRegionsProducer.h.

References funct::abs(), Reference_intrackfit_cff::barrel, BEAM_SPOT_FIXED, BEAM_SPOT_SIGMA, BXVector< T >::begin(), cms::cuda::bs, centralBxOnly_, ALCARECOTkAlJpsiMuMu_cff::charge, funct::cos(), spr::deltaEta, SiPixelRawToDigiRegional_cfi::deltaPhi, BXVector< T >::end(), relativeConstraints::error, PVValHelper::eta, JetChargeProducer_cfi::exp, dqmdumpme::first, edm::EventSetup::getData(), BXVector< T >::getFirstBX(), BXVector< T >::getLastBX(), iEvent, createfilelist::int, edm::EDGetTokenT< T >::isUninitialized(), dqmiolumiharvest::j, l1MaxEta_, l1MinPt_, l1MinQuality_, l1MuonTF_link_EMTFN_f_, l1MuonTF_link_EMTFN_i_, l1MuonTF_link_EMTFP_f_, l1MuonTF_link_EMTFP_i_, m_deltaEtas, m_deltaPhis, m_maxNRegions, m_maxNVertices, m_mode, m_nSigmaZBeamSpot, m_nSigmaZVertex, m_originRadius, M_PI, m_precise, m_ptMin, m_ptRanges, m_searchOpt, m_whereToUseMeasurementTracker, m_zErrorBeamSpot, m_zErrorVetex, HLTSiStripMonitoring_cff::measurementTracker, minPtBarrel_, minPtEndcap_, FreeTrajectoryState::momentum(), phi, GeometricSearchDet::position(), propagatorName_, DiDispStaMuonMonitor_cfi::pt, quality, CosmicsPD_Skims::radius, mps_fire::result, edm::second(), service_, sigma_lambda_, sigma_phi_, sigma_qbpt_barrel_, sigma_qbpt_endcap_, sigma_qbpt_invalid_charge_, sigma_x_, sigma_y_, funct::sin(), BXVector< T >::size(), GeometricSearchDet::surface(), theta(), token_beamSpot, token_field, token_input, token_measurementTracker, token_msmaker, token_vertex, pfDeepBoostedJetPreprocessParams_cfi::upper_bound, findQualityFiles::v, AlignmentTracksFromVertexSelector_cfi::vertices, VERTICES_FIXED, VERTICES_SIGMA, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

                                                                                                   {
    std::vector<std::unique_ptr<TrackingRegion>> result;

    // pick up the candidate objects of interest
    edm::Handle<l1t::MuonBxCollection> muColl;
    iEvent.getByToken(token_input, muColl);
    if (muColl->size() == 0)
      return result;

    // always need the beam spot (as a fall back strategy for vertex modes)
    edm::Handle<reco::BeamSpot> bs;
    iEvent.getByToken(token_beamSpot, bs);
    if (!bs.isValid())
      return result;

    // this is a default origin for all modes
    GlobalPoint default_origin(bs->x0(), bs->y0(), bs->z0());

    // vector of origin & halfLength pairs:
    std::vector<std::pair<GlobalPoint, float>> origins;

    // fill the origins and halfLengths depending on the mode
    if (m_mode == BEAM_SPOT_FIXED || m_mode == BEAM_SPOT_SIGMA) {
      origins.push_back(std::make_pair(
          default_origin, (m_mode == BEAM_SPOT_FIXED) ? m_zErrorBeamSpot : m_nSigmaZBeamSpot * bs->sigmaZ()));
    } else if (m_mode == VERTICES_FIXED || m_mode == VERTICES_SIGMA) {
      edm::Handle<reco::VertexCollection> vertices;
      iEvent.getByToken(token_vertex, vertices);
      int n_vert = 0;
      for (reco::VertexCollection::const_iterator v = vertices->begin();
           v != vertices->end() && n_vert < m_maxNVertices;
           ++v) {
        if (v->isFake() || !v->isValid())
          continue;

        origins.push_back(std::make_pair(GlobalPoint(v->x(), v->y(), v->z()),
                                         (m_mode == VERTICES_FIXED) ? m_zErrorVetex : m_nSigmaZVertex * v->zError()));
        ++n_vert;
      }
      // no-vertex fall-back case:
      if (origins.empty()) {
        origins.push_back(std::make_pair(
            default_origin, (m_nSigmaZBeamSpot > 0.) ? m_nSigmaZBeamSpot * bs->z0Error() : m_zErrorBeamSpot));
      }
    }

    const MeasurementTrackerEvent* measurementTracker = nullptr;
    if (!token_measurementTracker.isUninitialized()) {
      measurementTracker = &iEvent.get(token_measurementTracker);
    }

    const auto& field = iSetup.getData(token_field);
    const MultipleScatteringParametrisationMaker* msmaker = nullptr;
    if (m_precise) {
      msmaker = &iSetup.getData(token_msmaker);
    }

    // create tracking regions (maximum MaxNRegions of them) in directions of the
    // objects of interest (we expect that the collection was sorted in decreasing pt order)
    int n_regions = 0;
    for (int ibx = muColl->getFirstBX(); ibx <= muColl->getLastBX() && n_regions < m_maxNRegions; ++ibx) {
      if (centralBxOnly_ && (ibx != 0))
        continue;

      for (auto it = muColl->begin(ibx); it != muColl->end(ibx) && n_regions < m_maxNRegions; it++) {
        unsigned int quality = it->hwQual();
        if (quality <= l1MinQuality_)
          continue;

        float pt = it->pt();
        float eta = it->eta();
        if (pt < l1MinPt_ || std::abs(eta) > l1MaxEta_)
          continue;

        float theta = 2 * atan(exp(-eta));
        float phi = it->phi();

        int valid_charge = it->hwChargeValid();
        int charge = it->charge();
        if (!valid_charge)
          charge = 0;

        int link = l1MuonTF_link_EMTFP_i_ + (int)(it->tfMuonIndex() / 3.);
        bool barrel = true;
        if ((link >= l1MuonTF_link_EMTFP_i_ && link <= l1MuonTF_link_EMTFP_f_) ||
            (link >= l1MuonTF_link_EMTFN_i_ && link <= l1MuonTF_link_EMTFN_f_))
          barrel = false;

        // propagate L1 FTS to BS
        service_->update(iSetup);
        const DetLayer* detLayer = nullptr;
        float radius = 0.;

        CLHEP::Hep3Vector vec(0., 1., 0.);
        vec.setTheta(theta);
        vec.setPhi(phi);

        DetId theid;
        // Get the det layer on which the state should be put
        if (barrel) {
          // MB2
          theid = DTChamberId(0, 2, 0);
          detLayer = service_->detLayerGeometry()->idToLayer(theid);

          const BoundSurface* sur = &(detLayer->surface());
          const BoundCylinder* bc = dynamic_cast<const BoundCylinder*>(sur);

          radius = std::abs(bc->radius() / sin(theta));

          if (pt < minPtBarrel_)
            pt = minPtBarrel_;
        } else {
          // ME2
          theid = theta < M_PI / 2. ? CSCDetId(1, 2, 0, 0, 0) : CSCDetId(2, 2, 0, 0, 0);

          detLayer = service_->detLayerGeometry()->idToLayer(theid);

          radius = std::abs(detLayer->position().z() / cos(theta));

          if (pt < minPtEndcap_)
            pt = minPtEndcap_;
        }
        vec.setMag(radius);
        GlobalPoint pos(vec.x(), vec.y(), vec.z());
        GlobalVector mom(pt * cos(phi), pt * sin(phi), pt * cos(theta) / sin(theta));
        GlobalTrajectoryParameters param(pos, mom, charge, &*service_->magneticField());

        AlgebraicSymMatrix55 mat;
        mat[0][0] = (sigma_qbpt_barrel_ / pt) * (sigma_qbpt_barrel_ / pt);  // sigma^2(charge/abs_momentum)
        if (!barrel)
          mat[0][0] = (sigma_qbpt_endcap_ / pt) * (sigma_qbpt_endcap_ / pt);

        //Assign q/pt = 0 +- 1/pt if charge has been declared invalid
        if (!valid_charge)
          mat[0][0] = (sigma_qbpt_invalid_charge_ / pt) * (sigma_qbpt_invalid_charge_ / pt);

        mat[1][1] = sigma_lambda_ * sigma_lambda_;  // sigma^2(lambda)
        mat[2][2] = sigma_phi_ * sigma_phi_;        // sigma^2(phi)
        mat[3][3] = sigma_x_ * sigma_x_;            // sigma^2(x_transverse))
        mat[4][4] = sigma_y_ * sigma_y_;            // sigma^2(y_transverse))

        CurvilinearTrajectoryError error(mat);

        const FreeTrajectoryState state(param, error);

        FreeTrajectoryState state_bs = service_->propagator(propagatorName_)->propagate(state, *bs.product());

        GlobalVector direction(state_bs.momentum().x(), state_bs.momentum().y(), state_bs.momentum().z());

        // set deltaEta and deltaPhi from L1 muon pt
        auto deltaEta = m_deltaEtas.at(0);
        auto deltaPhi = m_deltaPhis.at(0);
        if (it->pt() < m_ptRanges.back()) {
          auto lowEdge = std::upper_bound(m_ptRanges.begin(), m_ptRanges.end(), it->pt());
          deltaEta = m_deltaEtas.at(lowEdge - m_ptRanges.begin() - 1);
          deltaPhi = m_deltaPhis.at(lowEdge - m_ptRanges.begin() - 1);
        }

        for (size_t j = 0; j < origins.size() && n_regions < m_maxNRegions; ++j) {
          result.push_back(std::make_unique<RectangularEtaPhiTrackingRegion>(direction,
                                                                             origins[j].first,
                                                                             m_ptMin,
                                                                             m_originRadius,
                                                                             origins[j].second,
                                                                             deltaEta,
                                                                             deltaPhi,
                                                                             field,
                                                                             msmaker,
                                                                             m_precise,
                                                                             m_whereToUseMeasurementTracker,
                                                                             measurementTracker,
                                                                             m_searchOpt));
          ++n_regions;
        }
      }
    }
    edm::LogInfo("L1MuonSeededTrackingRegionsProducer") << "produced " << n_regions << " regions";

    return result;
  }

Member Data Documentation

centralBxOnly_

const bool L1MuonSeededTrackingRegionsProducer::centralBxOnly_

private

Definition at line 403 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by regions().

l1MaxEta_

const double L1MuonSeededTrackingRegionsProducer::l1MaxEta_

private

Definition at line 399 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by regions().

l1MinPt_

const double L1MuonSeededTrackingRegionsProducer::l1MinPt_

private

Definition at line 398 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by regions().

l1MinQuality_

const unsigned L1MuonSeededTrackingRegionsProducer::l1MinQuality_

private

Definition at line 400 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by regions().

l1MuonTF_link_EMTFN_f_

constexpr int L1MuonSeededTrackingRegionsProducer::l1MuonTF_link_EMTFN_f_ {71}

staticprivate

Definition at line 413 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by regions().

l1MuonTF_link_EMTFN_i_

constexpr int L1MuonSeededTrackingRegionsProducer::l1MuonTF_link_EMTFN_i_ {66}

staticprivate

Definition at line 412 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by regions().

l1MuonTF_link_EMTFP_f_

constexpr int L1MuonSeededTrackingRegionsProducer::l1MuonTF_link_EMTFP_f_ {41}

staticprivate

Definition at line 411 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by regions().

l1MuonTF_link_EMTFP_i_

constexpr int L1MuonSeededTrackingRegionsProducer::l1MuonTF_link_EMTFP_i_ {36}

staticprivate

Definition at line 410 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by regions().

m_deltaEtas

std::vector<double> L1MuonSeededTrackingRegionsProducer::m_deltaEtas

private

Definition at line 385 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by L1MuonSeededTrackingRegionsProducer(), and regions().

m_deltaPhis

std::vector<double> L1MuonSeededTrackingRegionsProducer::m_deltaPhis

private

Definition at line 386 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by L1MuonSeededTrackingRegionsProducer(), and regions().

m_maxNRegions

int L1MuonSeededTrackingRegionsProducer::m_maxNRegions

private

Definition at line 375 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by L1MuonSeededTrackingRegionsProducer(), and regions().

m_maxNVertices

int L1MuonSeededTrackingRegionsProducer::m_maxNVertices

private

Definition at line 379 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by L1MuonSeededTrackingRegionsProducer(), and regions().

m_mode

Mode L1MuonSeededTrackingRegionsProducer::m_mode

private

Definition at line 373 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by L1MuonSeededTrackingRegionsProducer(), and regions().

m_nSigmaZBeamSpot

float L1MuonSeededTrackingRegionsProducer::m_nSigmaZBeamSpot

private

Definition at line 396 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by L1MuonSeededTrackingRegionsProducer(), and regions().

m_nSigmaZVertex

float L1MuonSeededTrackingRegionsProducer::m_nSigmaZVertex

private

Definition at line 394 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by L1MuonSeededTrackingRegionsProducer(), and regions().

m_originRadius

float L1MuonSeededTrackingRegionsProducer::m_originRadius

private

Definition at line 382 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by L1MuonSeededTrackingRegionsProducer(), and regions().

m_precise

bool L1MuonSeededTrackingRegionsProducer::m_precise

private

Definition at line 387 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by L1MuonSeededTrackingRegionsProducer(), and regions().

m_ptMin

float L1MuonSeededTrackingRegionsProducer::m_ptMin

private

Definition at line 381 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by L1MuonSeededTrackingRegionsProducer(), and regions().

m_ptRanges

std::vector<double> L1MuonSeededTrackingRegionsProducer::m_ptRanges

private

Definition at line 384 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by L1MuonSeededTrackingRegionsProducer(), and regions().

m_searchOpt

bool L1MuonSeededTrackingRegionsProducer::m_searchOpt

private

Definition at line 392 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by L1MuonSeededTrackingRegionsProducer(), and regions().

m_whereToUseMeasurementTracker

RectangularEtaPhiTrackingRegion::UseMeasurementTracker L1MuonSeededTrackingRegionsProducer::m_whereToUseMeasurementTracker

private

Definition at line 389 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by L1MuonSeededTrackingRegionsProducer(), and regions().

m_zErrorBeamSpot

float L1MuonSeededTrackingRegionsProducer::m_zErrorBeamSpot

private

Definition at line 383 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by L1MuonSeededTrackingRegionsProducer(), and regions().

m_zErrorVetex

float L1MuonSeededTrackingRegionsProducer::m_zErrorVetex

private

Definition at line 395 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by L1MuonSeededTrackingRegionsProducer(), and regions().

minPtBarrel_

const double L1MuonSeededTrackingRegionsProducer::minPtBarrel_

private

Definition at line 401 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by regions().

minPtEndcap_

const double L1MuonSeededTrackingRegionsProducer::minPtEndcap_

private

Definition at line 402 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by regions().

propagatorName_

const std::string L1MuonSeededTrackingRegionsProducer::propagatorName_

private

Definition at line 405 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by regions().

service_

std::unique_ptr<MuonServiceProxy> L1MuonSeededTrackingRegionsProducer::service_

private

Definition at line 406 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by L1MuonSeededTrackingRegionsProducer(), and regions().

sigma_lambda_

constexpr double L1MuonSeededTrackingRegionsProducer::sigma_lambda_ {0.05}

staticprivate

Definition at line 419 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by regions().

sigma_phi_

constexpr double L1MuonSeededTrackingRegionsProducer::sigma_phi_ {0.2}

staticprivate

Definition at line 420 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by regions().

sigma_qbpt_barrel_

constexpr double L1MuonSeededTrackingRegionsProducer::sigma_qbpt_barrel_ {0.25}

staticprivate

Definition at line 416 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by regions().

sigma_qbpt_endcap_

constexpr double L1MuonSeededTrackingRegionsProducer::sigma_qbpt_endcap_ {0.4}

staticprivate

Definition at line 417 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by regions().

sigma_qbpt_invalid_charge_

constexpr double L1MuonSeededTrackingRegionsProducer::sigma_qbpt_invalid_charge_ {1.0}

staticprivate

Definition at line 418 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by regions().

sigma_x_

constexpr double L1MuonSeededTrackingRegionsProducer::sigma_x_ {20.0}

staticprivate

Definition at line 421 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by regions().

sigma_y_

constexpr double L1MuonSeededTrackingRegionsProducer::sigma_y_ {20.0}

staticprivate

Definition at line 422 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by regions().

token_beamSpot

edm::EDGetTokenT<reco::BeamSpot> L1MuonSeededTrackingRegionsProducer::token_beamSpot

private

Definition at line 377 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by L1MuonSeededTrackingRegionsProducer(), and regions().

token_field

const edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> L1MuonSeededTrackingRegionsProducer::token_field

private

Definition at line 390 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by regions().

token_input

edm::EDGetTokenT<l1t::MuonBxCollection> L1MuonSeededTrackingRegionsProducer::token_input

private

Definition at line 378 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by L1MuonSeededTrackingRegionsProducer(), and regions().

token_measurementTracker

edm::EDGetTokenT<MeasurementTrackerEvent> L1MuonSeededTrackingRegionsProducer::token_measurementTracker

private

Definition at line 388 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by L1MuonSeededTrackingRegionsProducer(), and regions().

token_msmaker

edm::ESGetToken<MultipleScatteringParametrisationMaker, TrackerMultipleScatteringRecord> L1MuonSeededTrackingRegionsProducer::token_msmaker

private

Definition at line 391 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by L1MuonSeededTrackingRegionsProducer(), and regions().

token_vertex

edm::EDGetTokenT<reco::VertexCollection> L1MuonSeededTrackingRegionsProducer::token_vertex

private

Definition at line 376 of file L1MuonSeededTrackingRegionsProducer.h.

Referenced by L1MuonSeededTrackingRegionsProducer(), and regions().