#include <TauRegionalPixelSeedGenerator.h>

Inheritance diagram for TauRegionalPixelSeedGenerator:

Public Member Functions
virtual std::vector < std::unique_ptr < TrackingRegion > >	regions (const edm::Event &e, const edm::EventSetup &es) const override

	TauRegionalPixelSeedGenerator (const edm::ParameterSet &conf_, edm::ConsumesCollector &&iC)

virtual	~TauRegionalPixelSeedGenerator ()

Public Member Functions inherited from TrackingRegionProducer
virtual	~TrackingRegionProducer ()

Private Attributes
edm::ParameterSet	conf_

float	m_deltaEta

float	m_deltaPhi

float	m_halfLength

RectangularEtaPhiTrackingRegion::UseMeasurementTracker	m_howToUseMeasurementTracker

float	m_originRadius

float	m_ptMin

bool	m_searchOpt

edm::EDGetTokenT < reco::CandidateView >	token_jet

edm::EDGetTokenT < MeasurementTrackerEvent >	token_measurementTracker

edm::EDGetTokenT < reco::VertexCollection >	token_vertex

Detailed Description

Definition at line 33 of file TauRegionalPixelSeedGenerator.h.

Constructor & Destructor Documentation

TauRegionalPixelSeedGenerator::TauRegionalPixelSeedGenerator	(	const edm::ParameterSet &	conf_,
		edm::ConsumesCollector &&	iC
	)

inlineexplicit

Definition at line 36 of file TauRegionalPixelSeedGenerator.h.

References edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), RectangularEtaPhiTrackingRegion::kNever, m_deltaEta, m_deltaPhi, m_halfLength, m_howToUseMeasurementTracker, m_originRadius, m_ptMin, m_searchOpt, AlCaHLTBitMon_QueryRunRegistry::string, RectangularEtaPhiTrackingRegion::stringToUseMeasurementTracker(), token_jet, token_measurementTracker, and token_vertex.

                                {
       edm::LogInfo ("TauRegionalPixelSeedGenerator") << "Enter the TauRegionalPixelSeedGenerator";
 
       edm::ParameterSet regionPSet = conf_.getParameter<edm::ParameterSet>("RegionPSet");
 
       m_ptMin        = regionPSet.getParameter<double>("ptMin");
       m_originRadius = regionPSet.getParameter<double>("originRadius");
       m_halfLength   = regionPSet.getParameter<double>("originHalfLength");
       m_deltaEta     = regionPSet.getParameter<double>("deltaEtaRegion");
       m_deltaPhi     = regionPSet.getParameter<double>("deltaPhiRegion");
       token_jet      = iC.consumes<reco::CandidateView>(regionPSet.getParameter<edm::InputTag>("JetSrc"));
       token_vertex   = iC.consumes<reco::VertexCollection>(regionPSet.getParameter<edm::InputTag>("vertexSrc"));
       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) {
         token_measurementTracker = iC.consumes<MeasurementTrackerEvent>(regionPSet.getParameter<std::string>("measurementTrackerName"));
       }
     }

virtual TauRegionalPixelSeedGenerator::~TauRegionalPixelSeedGenerator ( )

inlinevirtual

Definition at line 61 of file TauRegionalPixelSeedGenerator.h.

61 {}

Member Function Documentation

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

inlineoverridevirtual

Implements TrackingRegionProducer.

Definition at line 64 of file TauRegionalPixelSeedGenerator.h.

References edm::Event::getByToken(), edm::EDGetTokenT< T >::isUninitialized(), m_deltaEta, m_deltaPhi, m_halfLength, m_howToUseMeasurementTracker, m_originRadius, m_ptMin, m_searchOpt, HLT_FULL_cff::measurementTracker, edm::Handle< T >::product(), query::result, token_jet, token_measurementTracker, token_vertex, and HLT_FULL_cff::vertices.

                                                                                                                          {
       std::vector<std::unique_ptr<TrackingRegion> > result;
 
       //      double originZ;
       double deltaZVertex, deltaRho;
         GlobalPoint vertex;
       // get the primary vertex
       edm::Handle<reco::VertexCollection> h_vertices;
       e.getByToken(token_vertex, h_vertices);
       const reco::VertexCollection & vertices = * h_vertices;
       if (not vertices.empty()) {
 //        originZ      = vertices.front().z();
     GlobalPoint myTmp(vertices.at(0).position().x(),vertices.at(0).position().y(), vertices.at(0).position().z());
           vertex = myTmp;
           deltaZVertex = m_halfLength;
           deltaRho = m_originRadius;
       } else {
   //      originZ      =  0.;
           GlobalPoint myTmp(0.,0.,0.);
           vertex = myTmp;
           deltaRho = 1.;
          deltaZVertex = 15.;
       }
       
       // get the jet direction
       edm::Handle<edm::View<reco::Candidate> > h_jets;
       e.getByToken(token_jet, h_jets);
       
       const MeasurementTrackerEvent *measurementTracker = nullptr;
       if(!token_measurementTracker.isUninitialized()) {
         edm::Handle<MeasurementTrackerEvent> hmte;
         e.getByToken(token_measurementTracker, hmte);
         measurementTracker = hmte.product();
       }
 
       for(const reco::Candidate& myJet: *h_jets)
     {
           GlobalVector jetVector(myJet.momentum().x(),myJet.momentum().y(),myJet.momentum().z());
 //          GlobalPoint  vertex(0, 0, originZ);
           result.push_back(std::make_unique<RectangularEtaPhiTrackingRegion>( jetVector,
                                                                               vertex,
                                                                               m_ptMin,
                                                                               deltaRho,
                                                                               deltaZVertex,
                                                                               m_deltaEta,
                                                                               m_deltaPhi,
                                                                               m_howToUseMeasurementTracker,
                                                                               true,
                                                                               measurementTracker,
                                                                               m_searchOpt));
       }
 
       return result;
     }