#include <L3MumuTrackingRegion.h>

Inheritance diagram for L3MumuTrackingRegion:

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

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

virtual	~L3MumuTrackingRegion ()

Public Member Functions inherited from TrackingRegionProducer
virtual	~TrackingRegionProducer ()

Private Attributes
RectangularEtaPhiTrackingRegion::UseMeasurementTracker	m_howToUseMeasurementTracker

bool	m_searchOpt

double	theDeltaEta

double	theDeltaPhi

edm::InputTag	theInputTrkTag

edm::EDGetTokenT< reco::TrackCollection >	theInputTrkToken

edm::EDGetTokenT< MeasurementTrackerEvent >	theMeasurementTrackerToken

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 17 of file L3MumuTrackingRegion.h.

Constructor & Destructor Documentation

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

inline

Definition at line 21 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.

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

virtual L3MumuTrackingRegion::~L3MumuTrackingRegion ( )

inlinevirtual

Definition at line 52 of file L3MumuTrackingRegion.h.

52 {}

Member Function Documentation

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

inlineoverridevirtual

Implements TrackingRegionProducer.

Definition at line 54 of file L3MumuTrackingRegion.h.

References edm::Event::getByToken(), edm::EDGetTokenT< T >::isUninitialized(), m_howToUseMeasurementTracker, m_searchOpt, MeasurementTrackerEventProducer_cfi::measurementTracker, edm::Handle< T >::product(), mps_fire::result, theDeltaEta, theDeltaPhi, theInputTrkToken, theMeasurementTrackerToken, theOriginHalfLength, theOriginRadius, theOriginZPos, thePtMin, theVertex, theVertexToken, useVtxTks, and primaryVertexAssociation_cfi::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();
     }
 
     // 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.size()>0) {
     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,
                                   m_howToUseMeasurementTracker,
                                   true,
                                   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,
                            m_howToUseMeasurementTracker,
                            true,
                            measurementTracker,
                            m_searchOpt) );
     }
     return result;
   }