#include <L3MumuTrackingRegion.h>

Inheritance diagram for L3MumuTrackingRegion:

Public Member Functions
	L3MumuTrackingRegion (const edm::ParameterSet &cfg, edm::ConsumesCollector &&iC)

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

	~L3MumuTrackingRegion () override=default

Public Member Functions inherited from TrackingRegionProducer
virtual	~TrackingRegionProducer ()

Private Attributes
RectangularEtaPhiTrackingRegion::UseMeasurementTracker	m_howToUseMeasurementTracker

bool	m_searchOpt

double	theDeltaEta

double	theDeltaPhi

edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	theFieldToken

edm::InputTag	theInputTrkTag

edm::EDGetTokenT < reco::TrackCollection >	theInputTrkToken

edm::EDGetTokenT < MeasurementTrackerEvent >	theMeasurementTrackerToken

edm::ESGetToken < MultipleScatteringParametrisationMaker, TrackerMultipleScatteringRecord >	theMSMakerToken

double	theOriginHalfLength

double	theOriginRadius

double	theOriginZPos

double	thePtMin

bool	theVertex

edm::InputTag	theVertexTag

edm::EDGetTokenT < reco::VertexCollection >	theVertexToken

bool	useVtxTks

Detailed Description

Definition at line 21 of file L3MumuTrackingRegion.h.

Constructor & Destructor Documentation

L3MumuTrackingRegion::L3MumuTrackingRegion	(	const edm::ParameterSet &	cfg,
		edm::ConsumesCollector &&	iC
	)

inline

Definition at line 23 of file L3MumuTrackingRegion.h.

References edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), RectangularEtaPhiTrackingRegion::kNever, m_howToUseMeasurementTracker, m_searchOpt, AlCaHLTBitMon_QueryRunRegistry::string, RectangularEtaPhiTrackingRegion::stringToUseMeasurementTracker(), theDeltaEta, theDeltaPhi, theInputTrkTag, theInputTrkToken, theMeasurementTrackerToken, theOriginHalfLength, theOriginRadius, theOriginZPos, thePtMin, theVertex, theVertexTag, theVertexToken, and useVtxTks.

       : theFieldToken(iC.esConsumes()), theMSMakerToken(iC.esConsumes()) {
     edm::ParameterSet regionPSet = cfg.getParameter<edm::ParameterSet>("RegionPSet");
 
     theVertexTag = regionPSet.getParameter<edm::InputTag>("vertexSrc");
     theVertex = (theVertexTag.label().length() > 1);
     theInputTrkTag = regionPSet.getParameter<edm::InputTag>("TrkSrc");
     useVtxTks = regionPSet.getParameter<bool>("UseVtxTks");
 
     if (theVertex)
       theVertexToken = iC.consumes<reco::VertexCollection>(theVertexTag);
     if (!(theVertex && useVtxTks))
       theInputTrkToken = iC.consumes<reco::TrackCollection>(theInputTrkTag);
 
     thePtMin = regionPSet.getParameter<double>("ptMin");
     theOriginRadius = regionPSet.getParameter<double>("originRadius");
     theOriginHalfLength = regionPSet.getParameter<double>("originHalfLength");
     theOriginZPos = regionPSet.getParameter<double>("vertexZDefault");
 
     theDeltaEta = regionPSet.getParameter<double>("deltaEtaRegion");
     theDeltaPhi = regionPSet.getParameter<double>("deltaPhiRegion");
     if (regionPSet.exists("searchOpt")) {
       m_searchOpt = regionPSet.getParameter<bool>("searchOpt");
     } else {
       m_searchOpt = false;
     }
     m_howToUseMeasurementTracker = RectangularEtaPhiTrackingRegion::stringToUseMeasurementTracker(
         regionPSet.getParameter<std::string>("howToUseMeasurementTracker"));
     if (m_howToUseMeasurementTracker != RectangularEtaPhiTrackingRegion::UseMeasurementTracker::kNever) {
       theMeasurementTrackerToken =
           iC.consumes<MeasurementTrackerEvent>(regionPSet.getParameter<edm::InputTag>("measurementTrackerName"));
     }
   }

L3MumuTrackingRegion::~L3MumuTrackingRegion ( )

overridedefault

Member Function Documentation

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

inlineoverridevirtual

Implements TrackingRegionProducer.

Definition at line 59 of file L3MumuTrackingRegion.h.

References edm::Event::getByToken(), edm::EventSetup::getData(), edm::EDGetTokenT< T >::isUninitialized(), m_howToUseMeasurementTracker, m_searchOpt, HLT_FULL_cff::measurementTracker, edm::Handle< T >::product(), mps_fire::result, theDeltaEta, theDeltaPhi, theFieldToken, theInputTrkToken, theMeasurementTrackerToken, theMSMakerToken, theOriginHalfLength, theOriginRadius, theOriginZPos, thePtMin, theVertex, theVertexToken, useVtxTks, and beam_dqm_sourceclient-live_cfg::vertices.

                                                                                                 {
     std::vector<std::unique_ptr<TrackingRegion> > result;
 
     const MeasurementTrackerEvent* measurementTracker = nullptr;
     if (!theMeasurementTrackerToken.isUninitialized()) {
       edm::Handle<MeasurementTrackerEvent> hmte;
       ev.getByToken(theMeasurementTrackerToken, hmte);
       measurementTracker = hmte.product();
     }
     const auto& field = es.getData(theFieldToken);
     const auto& msmaker = es.getData(theMSMakerToken);
 
     // optional constraint for vertex
     // get highest Pt pixel vertex (if existing)
     double deltaZVertex = theOriginHalfLength;
     double originz = theOriginZPos;
     if (theVertex) {
       edm::Handle<reco::VertexCollection> vertices;
       ev.getByToken(theVertexToken, vertices);
       const reco::VertexCollection vertCollection = *(vertices.product());
       reco::VertexCollection::const_iterator ci = vertCollection.begin();
       if (!vertCollection.empty()) {
         originz = ci->z();
       } else {
         originz = theOriginZPos;
         deltaZVertex = 15.;
       }
       if (useVtxTks) {
         for (ci = vertCollection.begin(); ci != vertCollection.end(); ci++)
           for (reco::Vertex::trackRef_iterator trackIt = ci->tracks_begin(); trackIt != ci->tracks_end(); trackIt++) {
             reco::TrackRef iTrk = (*trackIt).castTo<reco::TrackRef>();
             GlobalVector dirVector((iTrk)->px(), (iTrk)->py(), (iTrk)->pz());
             result.push_back(std::make_unique<RectangularEtaPhiTrackingRegion>(dirVector,
                                                                                GlobalPoint(0, 0, float(ci->z())),
                                                                                thePtMin,
                                                                                theOriginRadius,
                                                                                deltaZVertex,
                                                                                theDeltaEta,
                                                                                theDeltaPhi,
                                                                                field,
                                                                                &msmaker,
                                                                                true,
                                                                                m_howToUseMeasurementTracker,
                                                                                measurementTracker,
                                                                                m_searchOpt));
           }
         return result;
       }
     }
 
     edm::Handle<reco::TrackCollection> trks;
     if (!theInputTrkToken.isUninitialized())
       ev.getByToken(theInputTrkToken, trks);
     for (reco::TrackCollection::const_iterator iTrk = trks->begin(); iTrk != trks->end(); iTrk++) {
       GlobalVector dirVector((iTrk)->px(), (iTrk)->py(), (iTrk)->pz());
       result.push_back(std::make_unique<RectangularEtaPhiTrackingRegion>(dirVector,
                                                                          GlobalPoint(0, 0, float(originz)),
                                                                          thePtMin,
                                                                          theOriginRadius,
                                                                          deltaZVertex,
                                                                          theDeltaEta,
                                                                          theDeltaPhi,
                                                                          field,
                                                                          &msmaker,
                                                                          true,
                                                                          m_howToUseMeasurementTracker,
                                                                          measurementTracker,
                                                                          m_searchOpt));
     }
     return result;
   }