MuonTrackingRegionBuilder Class Reference

#include <MuonTrackingRegionBuilder.h>

Inheritance diagram for MuonTrackingRegionBuilder:

Public Member Functions
	MuonTrackingRegionBuilder (const edm::ParameterSet &par, edm::ConsumesCollector &iC)
	Constructor. More...
	MuonTrackingRegionBuilder (const edm::ParameterSet &par, edm::ConsumesCollector &&iC)
std::unique_ptr< RectangularEtaPhiTrackingRegion >	region (const reco::TrackRef &) const
	Define tracking region. More...
std::unique_ptr< RectangularEtaPhiTrackingRegion >	region (const reco::Track &t) const
std::unique_ptr< RectangularEtaPhiTrackingRegion >	region (const reco::Track &, const edm::Event &) const
virtual std::vector< std::unique_ptr< TrackingRegion > >	regions (const edm::Event &, const edm::EventSetup &) const override
	Create Region of Interest. More...
virtual void	setEvent (const edm::Event &)
	Pass the Event to the algo at each event. More...
virtual	~MuonTrackingRegionBuilder ()
	Destructor. More...
Public Member Functions inherited from TrackingRegionProducer
virtual	~TrackingRegionProducer ()

Static Public Member Functions
static void	fillDescriptions (edm::ParameterSetDescription &descriptions)
	Add Fill Descriptions. More...
static void	fillDescriptionsOffline (edm::ParameterSetDescription &descriptions)

Private Member Functions
void	build (const edm::ParameterSet &, edm::ConsumesCollector &)

Private Attributes
edm::EDGetTokenT< reco::BeamSpot >	beamSpotToken
edm::EDGetTokenT< reco::TrackCollection >	inputCollectionToken
double	theDeltaEta
double	theDeltaPhi
double	theDeltaR
double	theEtaMin
double	theEtaRegionPar1
double	theEtaRegionPar2
const edm::Event *	theEvent
double	theHalfZ
int	theMaxRegions
edm::EDGetTokenT< MeasurementTrackerEvent >	theMeasurementTrackerToken
double	theNsigmaDz
double	theNsigmaEta
double	theNsigmaPhi
RectangularEtaPhiTrackingRegion::UseMeasurementTracker	theOnDemand
double	thePhiMin
double	thePhiRegionPar1
double	thePhiRegionPar2
bool	thePrecise
double	thePtMin
bool	useFixedEta
bool	useFixedPhi
bool	useFixedPt
bool	useFixedZ
bool	useVertex
edm::EDGetTokenT< reco::VertexCollection >	vertexCollectionToken

Detailed Description

Build a TrackingRegion around a standalone muon

Options: Beamspot : Origin is defined by primary vertex Vertex : Origin is defined by primary vertex (first valid vertex in the VertexCollection) if no vertex is found the beamspot is used instead DynamicZError DynamicEtaError DynamicphiError

Author

N. Neumeister Purdue University

A. Everett Purdue University

Definition at line 40 of file MuonTrackingRegionBuilder.h.

Constructor & Destructor Documentation

MuonTrackingRegionBuilder::MuonTrackingRegionBuilder ( const edm::ParameterSet &  par, edm::ConsumesCollector &  iC  )

inlineexplicit

Constructor.

Definition at line 45 of file MuonTrackingRegionBuilder.h.

{ build(par, iC); }

MuonTrackingRegionBuilder::MuonTrackingRegionBuilder ( const edm::ParameterSet &  par, edm::ConsumesCollector &&  iC  )

inlineexplicit

Definition at line 46 of file MuonTrackingRegionBuilder.h.

{ build(par, iC); }

virtual MuonTrackingRegionBuilder::~MuonTrackingRegionBuilder ( )

inlinevirtual

Destructor.

Definition at line 49 of file MuonTrackingRegionBuilder.h.

{}

Member Function Documentation

void MuonTrackingRegionBuilder::build ( const edm::ParameterSet &  par, edm::ConsumesCollector &  iC  )

private

Class: MuonTrackingRegionBuilder

Build a TrackingRegion around a standalone muon

Author

N. Neumeister Purdue University

A. Everett Purdue University

Definition at line 32 of file MuonTrackingRegionBuilder.cc.

References beamSpotToken, edm::ConsumesCollector::consumes(), edm::ParameterSet::getParameter(), inputCollectionToken, RectangularEtaPhiTrackingRegion::intToUseMeasurementTracker(), RectangularEtaPhiTrackingRegion::kNever, theDeltaEta, theDeltaPhi, theDeltaR, theEtaMin, theEtaRegionPar1, theEtaRegionPar2, theHalfZ, theMaxRegions, theMeasurementTrackerToken, theNsigmaDz, theNsigmaEta, theNsigmaPhi, theOnDemand, thePhiMin, thePhiRegionPar1, thePhiRegionPar2, thePrecise, thePtMin, useFixedEta, useFixedPhi, useFixedPt, useFixedZ, useVertex, and vertexCollectionToken.

                                                                                          {

  // Adjust errors on Eta, Phi, Z
  theNsigmaEta  = par.getParameter<double>("Rescale_eta");
  theNsigmaPhi  = par.getParameter<double>("Rescale_phi");
  theNsigmaDz   = par.getParameter<double>("Rescale_Dz");

  // Upper limits parameters
  theEtaRegionPar1 = par.getParameter<double>("EtaR_UpperLimit_Par1"); 
  theEtaRegionPar2 = par.getParameter<double>("EtaR_UpperLimit_Par2");
  thePhiRegionPar1 = par.getParameter<double>("PhiR_UpperLimit_Par1");
  thePhiRegionPar2 = par.getParameter<double>("PhiR_UpperLimit_Par2");

  // Flag to switch to use Vertices instead of BeamSpot
  useVertex = par.getParameter<bool>("UseVertex");

  // Flag to use fixed limits for Eta, Phi, Z, pT
  useFixedZ = par.getParameter<bool>("Z_fixed");
  useFixedPt = par.getParameter<bool>("Pt_fixed");
  useFixedPhi = par.getParameter<bool>("Phi_fixed");
  useFixedEta = par.getParameter<bool>("Eta_fixed");

  // Minimum value for pT
  thePtMin = par.getParameter<double>("Pt_min");

  // Minimum value for Phi
  thePhiMin = par.getParameter<double>("Phi_min");

  // Minimum value for Eta
  theEtaMin = par.getParameter<double>("Eta_min");

  // The static region size along the Z direction
  theHalfZ  = par.getParameter<double>("DeltaZ");

  // The transverse distance of the region from the BS/PV
  theDeltaR = par.getParameter<double>("DeltaR");

  // The static region size in Eta
  theDeltaEta = par.getParameter<double>("DeltaEta");

  // The static region size in Phi
  theDeltaPhi = par.getParameter<double>("DeltaPhi");

  // Maximum number of regions to build when looping over Muons
  theMaxRegions = par.getParameter<int>("maxRegions");

  // Flag to use precise??
  thePrecise = par.getParameter<bool>("precise"); 

  // perigee reference point ToDo: Check this
  theOnDemand = RectangularEtaPhiTrackingRegion::intToUseMeasurementTracker(par.getParameter<int>("OnDemand"));
  if (theOnDemand != RectangularEtaPhiTrackingRegion::UseMeasurementTracker::kNever) {
    theMeasurementTrackerToken = iC.consumes<MeasurementTrackerEvent>(par.getParameter<edm::InputTag>("MeasurementTrackerName"));
  }

  // Vertex collection and Beam Spot
  beamSpotToken = iC.consumes<reco::BeamSpot>(par.getParameter<edm::InputTag>("beamSpot"));
  vertexCollectionToken = iC.consumes<reco::VertexCollection>(par.getParameter<edm::InputTag>("vertexCollection"));

  // Input muon collection
  inputCollectionToken = iC.consumes<reco::TrackCollection>(par.getParameter<edm::InputTag>("input"));
}

void MuonTrackingRegionBuilder::fillDescriptions ( edm::ParameterSetDescription &  descriptions )

static

Add Fill Descriptions.

Definition at line 255 of file MuonTrackingRegionBuilder.cc.

References edm::ParameterSetDescription::add(), fillDescriptionsOffline(), and edm::ParameterSetDescription::setComment().

Referenced by L3MuonTrajectoryBuilder::fillDescriptions().

                                                                                         {
  {
    edm::ParameterSetDescription desc;
    fillDescriptionsOffline(desc);
    descriptions.add("MuonTrackingRegionBuilder",desc);
  }
  {
    edm::ParameterSetDescription desc;
    desc.add<double>("EtaR_UpperLimit_Par1",0.25);
    desc.add<double>("DeltaR",0.2);
    desc.add<edm::InputTag>("beamSpot",edm::InputTag("hltOnlineBeamSpot"));
    desc.add<int>("OnDemand",-1);
    desc.add<edm::InputTag>("vertexCollection",edm::InputTag("pixelVertices"));
    desc.add<double>("Rescale_phi",3.0);
    desc.add<bool>("Eta_fixed",false);
    desc.add<double>("Rescale_eta",3.0);
    desc.add<double>("PhiR_UpperLimit_Par2",0.2);
    desc.add<double>("Eta_min",0.05);
    desc.add<bool>("Phi_fixed",false);
    desc.add<double>("Phi_min",0.05);
    desc.add<double>("PhiR_UpperLimit_Par1",0.6);
    desc.add<double>("EtaR_UpperLimit_Par2",0.15);
    desc.add<edm::InputTag>("MeasurementTrackerName",edm::InputTag("hltESPMeasurementTracker"));
    desc.add<bool>("UseVertex",false);
    desc.add<double>("Rescale_Dz",3.0);
    desc.add<bool>("Pt_fixed",false);
    desc.add<bool>("Z_fixed",true);
    desc.add<double>("Pt_min",1.5);
    desc.add<double>("DeltaZ",15.9);
    desc.add<double>("DeltaEta",0.2);
    desc.add<double>("DeltaPhi",0.2);
    desc.add<int>("maxRegions",1);
    desc.add<bool>("precise",true);
    desc.add<edm::InputTag>("input",edm::InputTag("hltL2Muons","UpdatedAtVtx"));
    descriptions.add("hltMuonTrackingRegionBuilder",desc);
  }
  descriptions.setComment("Build a TrackingRegion around a standalone muon. Options to define region around beamspot or primary vertex and dynamic regions are included.");
}

void MuonTrackingRegionBuilder::fillDescriptionsOffline ( edm::ParameterSetDescription &  descriptions )

static

Definition at line 294 of file MuonTrackingRegionBuilder.cc.

References edm::ParameterSetDescription::add().

Referenced by HIMuonTrackingRegionProducer::fillDescriptions(), and fillDescriptions().

                                                                                        {
  desc.add<double>("EtaR_UpperLimit_Par1",0.25);
  desc.add<double>("DeltaR",0.2);
  desc.add<edm::InputTag>("beamSpot",edm::InputTag(""));
  desc.add<int>("OnDemand",-1);
  desc.add<edm::InputTag>("vertexCollection",edm::InputTag(""));
  desc.add<double>("Rescale_phi",3.0);
  desc.add<bool>("Eta_fixed",false);
  desc.add<double>("Rescale_eta",3.0);
  desc.add<double>("PhiR_UpperLimit_Par2",0.2);
  desc.add<double>("Eta_min",0.05);
  desc.add<bool>("Phi_fixed",false);
  desc.add<double>("Phi_min",0.05);
  desc.add<double>("PhiR_UpperLimit_Par1",0.6);
  desc.add<double>("EtaR_UpperLimit_Par2",0.15);
  desc.add<edm::InputTag>("MeasurementTrackerName",edm::InputTag(""));
  desc.add<bool>("UseVertex",false);
  desc.add<double>("Rescale_Dz",3.0);
  desc.add<bool>("Pt_fixed",false);
  desc.add<bool>("Z_fixed",true);
  desc.add<double>("Pt_min",1.5);
  desc.add<double>("DeltaZ",15.9);
  desc.add<double>("DeltaEta",0.2);
  desc.add<double>("DeltaPhi",0.2);
  desc.add<int>("maxRegions",1);
  desc.add<bool>("precise",true);
  desc.add<edm::InputTag>("input",edm::InputTag(""));
}

std::unique_ptr< RectangularEtaPhiTrackingRegion > MuonTrackingRegionBuilder::region

(

const reco::TrackRef &

track

)

const

Define tracking region.

Definition at line 120 of file MuonTrackingRegionBuilder.cc.

Referenced by GlobalTrajectoryBuilderBase::defineRegionOfInterest(), TSGFromL2Muon::produce(), FastTSGFromL2Muon::produce(), region(), regions(), and HIMuonTrackingRegionProducer::regions().

                                                                                                                {
  return region(*track);
}

std::unique_ptr<RectangularEtaPhiTrackingRegion> MuonTrackingRegionBuilder::region ( const reco::Track &  t ) const

inline

Definition at line 56 of file MuonTrackingRegionBuilder.h.

References region().

Referenced by region().

{ return region(t,*theEvent); }

std::unique_ptr< RectangularEtaPhiTrackingRegion > MuonTrackingRegionBuilder::region	(	const reco::Track &	staTrack,
		const edm::Event &	ev
	)		const

Definition at line 136 of file MuonTrackingRegionBuilder.cc.

References funct::abs(), beamSpotToken, deltaR(), stringResolutionProvider_cfi::eta, reco::TrackBase::etaError(), edm::Event::getByToken(), reco::Track::innerMomentum(), edm::EDGetTokenT< T >::isUninitialized(), edm::HandleBase::isValid(), LogDebug, hpstanc_transforms::max, MeasurementTrackerEventProducer_cfi::measurementTracker, min(), lostTracks_cfi::minPt, reco::TrackBase::momentum(), reco::TrackBase::p(), phi, reco::TrackBase::phiError(), edm::Handle< T >::product(), EnergyCorrector::pt, reco::TrackBase::pt(), region(), reco::BeamSpot::sigmaZ(), theDeltaEta, theDeltaPhi, theDeltaR, theEtaMin, theEtaRegionPar1, theEtaRegionPar2, theHalfZ, theMeasurementTrackerToken, theNsigmaDz, theNsigmaEta, theNsigmaPhi, theOnDemand, thePhiMin, thePhiRegionPar1, thePhiRegionPar2, thePrecise, thePtMin, useFixedEta, useFixedPhi, useFixedPt, useFixedZ, useVertex, particleFlowSuperClusterECAL_cfi::vertexCollection, vertexCollectionToken, reco::BeamSpot::x0(), reco::BeamSpot::y0(), and reco::BeamSpot::z0().

                                                                                                                                    {

  // get track momentum/direction at vertex
  const math::XYZVector& mom = staTrack.momentum();
  GlobalVector dirVector(mom.x(),mom.y(),mom.z());
  double pt = staTrack.pt();

  // Fix for StandAlone tracks with low momentum
  const math::XYZVector& innerMomentum = staTrack.innerMomentum();
  GlobalVector forSmallMomentum(innerMomentum.x(),innerMomentum.y(),innerMomentum.z());
  if ( staTrack.p() <= 1.5 ) {
    pt = std::abs(forSmallMomentum.perp());
  }

  // initial vertex position - in the following it is replaced with beamspot/vertexing
  GlobalPoint vertexPos(0.0,0.0,0.0);
  // standard 15.9, if useVertex than use error from  vertex
  double deltaZ = theHalfZ;

  // retrieve beam spot information
  edm::Handle<reco::BeamSpot> bs;
  bool bsHandleFlag = ev.getByToken(beamSpotToken, bs);

  // check the validity, otherwise vertexing
  if ( bsHandleFlag && bs.isValid() && !useVertex ) {
    vertexPos = GlobalPoint(bs->x0(), bs->y0(), bs->z0());
    deltaZ = useFixedZ ? theHalfZ : bs->sigmaZ() * theNsigmaDz;
  } else {
    // get originZPos from list of reconstructed vertices (first or all)
    edm::Handle<reco::VertexCollection> vertexCollection;
    bool vtxHandleFlag = ev.getByToken(vertexCollectionToken, vertexCollection);
    // check if there exists at least one reconstructed vertex
    if ( vtxHandleFlag && !vertexCollection->empty() ) {
      // use the first vertex in the collection and assume it is the primary event vertex 
      reco::VertexCollection::const_iterator vtx = vertexCollection->begin();
      if (!vtx->isFake() && vtx->isValid() ) {
        vertexPos = GlobalPoint(vtx->x(),vtx->y(),vtx->z());
        deltaZ = useFixedZ ? theHalfZ : vtx->zError() * theNsigmaDz;
      }
    }
  }

  // inizialize to the maximum possible value
  double deta = 0.4;
  double dphi = 0.6;

  // evaluate the dynamical region if possible
  deta = theNsigmaEta*(staTrack.etaError());
  dphi = theNsigmaPhi*(staTrack.phiError());

  // Region_Parametrizations to take into account possible L2 error matrix inconsistencies
  double region_dEta = 0;
  double region_dPhi = 0;
  double eta = 0;
  double phi = 0;

  // eta, pt parametrization from MC study (circa 2009?)
  if ( pt <= 10. ) {
     // angular coefficients
     float acoeff_Phi = (thePhiRegionPar2 - thePhiRegionPar1)/5;
     float acoeff_Eta = (theEtaRegionPar2 - theEtaRegionPar1)/5;

     eta = theEtaRegionPar1 + (acoeff_Eta)*(pt-5.);
     phi = thePhiRegionPar1 + (acoeff_Phi)*(pt-5.) ;
  }
  // parametrization 2nd bin in pt from MC study  
  if ( pt > 10. && pt < 100. ) {
     eta = theEtaRegionPar2;
     phi = thePhiRegionPar2;
  }
  // parametrization 3rd bin in pt from MC study
  if ( pt >= 100. ) {
     // angular coefficients
     float acoeff_Phi = (thePhiRegionPar1 - thePhiRegionPar2)/900;
     float acoeff_Eta = (theEtaRegionPar1 - theEtaRegionPar2)/900;

     eta = theEtaRegionPar2 + (acoeff_Eta)*(pt-100.);
     phi = thePhiRegionPar2 + (acoeff_Phi)*(pt-100.);
  }

  double region_dPhi1 = std::min(phi,dphi);
  double region_dEta1 = std::min(eta,deta);

  // decide to use either a parametrization or a dynamical region
  region_dPhi = useFixedPhi ? theDeltaPhi : std::max(thePhiMin,region_dPhi1);
  region_dEta = useFixedEta ? theDeltaEta : std::max(theEtaMin,region_dEta1);

  float deltaR = theDeltaR;
  double minPt = useFixedPt ? thePtMin : std::max(thePtMin,pt*0.6);


  const MeasurementTrackerEvent* measurementTracker = nullptr;
  if (!theMeasurementTrackerToken.isUninitialized()) {
    edm::Handle<MeasurementTrackerEvent> hmte;
    ev.getByToken(theMeasurementTrackerToken, hmte);
    measurementTracker = hmte.product();
  }

  auto region = std::make_unique<RectangularEtaPhiTrackingRegion>(dirVector, vertexPos,
                                               minPt, deltaR,
                                               deltaZ, region_dEta, region_dPhi,
                                               theOnDemand,
                                               thePrecise,
                                               measurementTracker);

  LogDebug("MuonTrackingRegionBuilder")<<"the region parameters are:\n"
                       <<"\n dirVector: "<<dirVector
                       <<"\n vertexPos: "<<vertexPos
                       <<"\n minPt: "<<minPt
                       <<"\n deltaR:"<<deltaR
                       <<"\n deltaZ:"<<deltaZ
                       <<"\n region_dEta:"<<region_dEta
                       <<"\n region_dPhi:"<<region_dPhi
                       <<"\n on demand parameter: "<<static_cast<int>(theOnDemand);
  
  return region;

}

std::vector< std::unique_ptr< TrackingRegion > > MuonTrackingRegionBuilder::regions ( const edm::Event &  ev, const edm::EventSetup &  es  ) const

overridevirtual

Create Region of Interest.

Implements TrackingRegionProducer.

Definition at line 99 of file MuonTrackingRegionBuilder.cc.

References edm::Event::getByToken(), inputCollectionToken, region(), mps_fire::result, theMaxRegions, and l1t::tracks.

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

  edm::Handle<reco::TrackCollection> tracks;
  ev.getByToken(inputCollectionToken, tracks);

  int nRegions = 0;
  for (auto it = tracks->cbegin(), ed = tracks->cend(); it != ed && nRegions < theMaxRegions; ++it) {
    result.push_back(region(*it,ev));
    nRegions++; 
  }

  return result;

}

void MuonTrackingRegionBuilder::setEvent ( const edm::Event &  event )

virtual

Pass the Event to the algo at each event.

Definition at line 128 of file MuonTrackingRegionBuilder.cc.

References event(), and theEvent.

Referenced by TSGFromL2Muon::produce(), FastTSGFromL2Muon::produce(), HIMuonTrackingRegionProducer::regions(), and GlobalTrajectoryBuilderBase::setEvent().

                                                              {
  theEvent = &event;
}

Member Data Documentation

edm::EDGetTokenT<reco::BeamSpot> MuonTrackingRegionBuilder::beamSpotToken

private

Definition at line 104 of file MuonTrackingRegionBuilder.h.

Referenced by build(), and region().

edm::EDGetTokenT<reco::TrackCollection> MuonTrackingRegionBuilder::inputCollectionToken

private

Definition at line 106 of file MuonTrackingRegionBuilder.h.

Referenced by build(), and regions().

double MuonTrackingRegionBuilder::theDeltaEta

private

Definition at line 100 of file MuonTrackingRegionBuilder.h.

Referenced by build(), and region().

double MuonTrackingRegionBuilder::theDeltaPhi

private

Definition at line 99 of file MuonTrackingRegionBuilder.h.

Referenced by build(), and region().

double MuonTrackingRegionBuilder::theDeltaR

private

Definition at line 97 of file MuonTrackingRegionBuilder.h.

Referenced by build(), and region().

double MuonTrackingRegionBuilder::theEtaMin

private

Definition at line 96 of file MuonTrackingRegionBuilder.h.

Referenced by build(), and region().

double MuonTrackingRegionBuilder::theEtaRegionPar1

private

Definition at line 89 of file MuonTrackingRegionBuilder.h.

Referenced by build(), and region().

double MuonTrackingRegionBuilder::theEtaRegionPar2

private

Definition at line 90 of file MuonTrackingRegionBuilder.h.

Referenced by build(), and region().

const edm::Event* MuonTrackingRegionBuilder::theEvent

private

Definition at line 74 of file MuonTrackingRegionBuilder.h.

Referenced by setEvent().

double MuonTrackingRegionBuilder::theHalfZ

private

Definition at line 98 of file MuonTrackingRegionBuilder.h.

Referenced by build(), and region().

int MuonTrackingRegionBuilder::theMaxRegions

private

Definition at line 83 of file MuonTrackingRegionBuilder.h.

Referenced by build(), and regions().

edm::EDGetTokenT<MeasurementTrackerEvent> MuonTrackingRegionBuilder::theMeasurementTrackerToken

private

Definition at line 103 of file MuonTrackingRegionBuilder.h.

Referenced by build(), and region().

double MuonTrackingRegionBuilder::theNsigmaDz

private

Definition at line 87 of file MuonTrackingRegionBuilder.h.

Referenced by build(), and region().

double MuonTrackingRegionBuilder::theNsigmaEta

private

Definition at line 85 of file MuonTrackingRegionBuilder.h.

Referenced by build(), and region().

double MuonTrackingRegionBuilder::theNsigmaPhi

private

Definition at line 86 of file MuonTrackingRegionBuilder.h.

Referenced by build(), and region().

RectangularEtaPhiTrackingRegion::UseMeasurementTracker MuonTrackingRegionBuilder::theOnDemand

private

Definition at line 102 of file MuonTrackingRegionBuilder.h.

Referenced by build(), and region().

double MuonTrackingRegionBuilder::thePhiMin

private

Definition at line 95 of file MuonTrackingRegionBuilder.h.

Referenced by build(), and region().

double MuonTrackingRegionBuilder::thePhiRegionPar1

private

Definition at line 91 of file MuonTrackingRegionBuilder.h.

Referenced by build(), and region().

double MuonTrackingRegionBuilder::thePhiRegionPar2

private

Definition at line 92 of file MuonTrackingRegionBuilder.h.

Referenced by build(), and region().

bool MuonTrackingRegionBuilder::thePrecise

private

Definition at line 81 of file MuonTrackingRegionBuilder.h.

Referenced by build(), and region().

double MuonTrackingRegionBuilder::thePtMin

private

Definition at line 94 of file MuonTrackingRegionBuilder.h.

Referenced by build(), and region().

bool MuonTrackingRegionBuilder::useFixedEta

private

Definition at line 80 of file MuonTrackingRegionBuilder.h.

Referenced by build(), and region().

bool MuonTrackingRegionBuilder::useFixedPhi

private

Definition at line 79 of file MuonTrackingRegionBuilder.h.

Referenced by build(), and region().

bool MuonTrackingRegionBuilder::useFixedPt

private

Definition at line 78 of file MuonTrackingRegionBuilder.h.

Referenced by build(), and region().

bool MuonTrackingRegionBuilder::useFixedZ

private

Definition at line 77 of file MuonTrackingRegionBuilder.h.

Referenced by build(), and region().

bool MuonTrackingRegionBuilder::useVertex

private

Definition at line 76 of file MuonTrackingRegionBuilder.h.

Referenced by build(), and region().

edm::EDGetTokenT<reco::VertexCollection> MuonTrackingRegionBuilder::vertexCollectionToken

private

Definition at line 105 of file MuonTrackingRegionBuilder.h.

Referenced by build(), and region().