#include <MuonTrackingRegionBuilder.h>

Inheritance diagram for MuonTrackingRegionBuilder:

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

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

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

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

std::unique_ptr< RectangularEtaPhiTrackingRegion >	region (const reco::TrackRef &) const
	Define tracking region. More...

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...

	~MuonTrackingRegionBuilder () override
	Destructor. More...

Public Member Functions inherited from TrackingRegionProducer
virtual	~TrackingRegionProducer ()

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

static void	fillDescriptionsHLT (edm::ParameterSetDescription &descriptions)

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 43 of file MuonTrackingRegionBuilder.h.

Constructor & Destructor Documentation

◆ MuonTrackingRegionBuilder() [1/2]

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

inlineexplicit

Constructor.

Definition at line 46 of file MuonTrackingRegionBuilder.h.

46 { build(par, iC); }

References build().

◆ MuonTrackingRegionBuilder() [2/2]

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

inlineexplicit

Definition at line 47 of file MuonTrackingRegionBuilder.h.

47 { build(par, iC); }

References build().

◆ ~MuonTrackingRegionBuilder()

MuonTrackingRegionBuilder::~MuonTrackingRegionBuilder ( )

inlineoverride

Destructor.

Definition at line 50 of file MuonTrackingRegionBuilder.h.

50 {}

Member Function Documentation

◆ build()

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.

                                                                                           {
   // 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"));
 }

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.

Referenced by MuonTrackingRegionBuilder().

◆ fillDescriptions()

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

static

Add Fill Descriptions.

Definition at line 238 of file MuonTrackingRegionBuilder.cc.

                                                                                            {
   {
     edm::ParameterSetDescription desc;
     fillDescriptionsOffline(desc);
     descriptions.add("MuonTrackingRegionBuilder", desc);
   }
   {
     edm::ParameterSetDescription desc;
     fillDescriptionsHLT(desc);
     descriptions.add("MuonTrackingRegionBuilderHLT", desc);
   }
   descriptions.setComment(
       "Build a TrackingRegion around a standalone muon. Options to define region around beamspot or primary vertex and "
       "dynamic regions are included.");
 }

References edm::ConfigurationDescriptions::add(), fillDescriptionsHLT(), fillDescriptionsOffline(), and edm::ConfigurationDescriptions::setComment().

◆ fillDescriptionsHLT()

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

static

Definition at line 253 of file MuonTrackingRegionBuilder.cc.

                                                                                     {
   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"));
 }

References edm::ParameterSetDescription::add(), and HLT_2018_cff::InputTag.

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

◆ fillDescriptionsOffline()

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

static

Definition at line 282 of file MuonTrackingRegionBuilder.cc.

                                                                                         {
   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(""));
 }

References edm::ParameterSetDescription::add(), and HLT_2018_cff::InputTag.

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

◆ region() [1/3]

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

Definition at line 129 of file MuonTrackingRegionBuilder.cc.

                                                                                                              {
   // 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;
 }

References funct::abs(), beamSpotToken, cms::cuda::bs, PbPb_ZMuSkimMuonDPG_cff::deltaR, PVValHelper::eta, reco::TrackBase::etaError(), ev, reco::Track::innerMomentum(), edm::EDGetTokenT< T >::isUninitialized(), LogDebug, SiStripPI::max, HLTSiStripMonitoring_cff::measurementTracker, min(), beam_dqm_sourceclient-live_cfg::minPt, reco::TrackBase::momentum(), reco::TrackBase::p(), phi, reco::TrackBase::phiError(), edm::Handle< T >::product(), DiDispStaMuonMonitor_cfi::pt, reco::TrackBase::pt(), region(), theDeltaEta, theDeltaPhi, theDeltaR, theEtaMin, theEtaRegionPar1, theEtaRegionPar2, theHalfZ, theMeasurementTrackerToken, theNsigmaDz, theNsigmaEta, theNsigmaPhi, theOnDemand, thePhiMin, thePhiRegionPar1, thePhiRegionPar2, thePrecise, thePtMin, useFixedEta, useFixedPhi, useFixedPt, useFixedZ, useVertex, spclusmultinvestigator_cfi::vertexCollection, vertexCollectionToken, and badGlobalMuonTaggersAOD_cff::vtx.

◆ region() [2/3]

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

inline

Definition at line 57 of file MuonTrackingRegionBuilder.h.

57 { return region(t, *theEvent); }

References region(), OrderedSet::t, and theEvent.

Referenced by region().

◆ region() [3/3]

std::unique_ptr< RectangularEtaPhiTrackingRegion > MuonTrackingRegionBuilder::region ( const reco::TrackRef & track ) const

Define tracking region.

Definition at line 117 of file MuonTrackingRegionBuilder.cc.

                                                                                                                 {
   return region(*track);
 }

References HLT_2018_cff::track.

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

◆ regions()

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 98 of file MuonTrackingRegionBuilder.cc.

                                                                                                                {
   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;
 }