#include <TauRegionalPixelSeedGenerator.h>

Inheritance diagram for TauRegionalPixelSeedGenerator:

Public Member Functions
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)

	~TauRegionalPixelSeedGenerator () override

Public Member Functions inherited from TrackingRegionProducer
virtual	~TrackingRegionProducer ()

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

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::TauRegionalPixelSeedGenerator	(	const edm::ParameterSet &	conf_,
		edm::ConsumesCollector &&	iC
	)

inlineexplicit

Definition at line 35 of file TauRegionalPixelSeedGenerator.h.

                                                                                                   {
     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) {
       // temporary until everything migrated to InputTag
       edm::InputTag tag;
       if (regionPSet.existsAs<edm::InputTag>("measurementTrackerName")) {
         tag = regionPSet.getParameter<edm::InputTag>("measurementTrackerName");
       } else {
         tag = edm::InputTag(regionPSet.getParameter<std::string>("measurementTrackerName"));
       }
  
       token_measurementTracker = iC.consumes<MeasurementTrackerEvent>(tag);
     }
   }

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

◆ ~TauRegionalPixelSeedGenerator()

TauRegionalPixelSeedGenerator::~TauRegionalPixelSeedGenerator ( )

inlineoverride

Definition at line 67 of file TauRegionalPixelSeedGenerator.h.

67 {}

Member Function Documentation

◆ fillDescriptions()

static void TauRegionalPixelSeedGenerator::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

inlinestatic

Definition at line 69 of file TauRegionalPixelSeedGenerator.h.

                                                                            {
     edm::ParameterSetDescription desc;
  
     desc.add<double>("ptMin", 5.0);
     desc.add<double>("originHalfLength", 0.2);
     desc.add<double>("originRadius", 0.2);
     desc.add<double>("deltaEtaRegion", 0.1);
     desc.add<double>("deltaPhiRegion", 0.1);
     desc.add<edm::InputTag>("JetSrc", edm::InputTag("icone5Tau1"));
     desc.add<edm::InputTag>("vertexSrc", edm::InputTag("pixelVertices"));
     desc.add<bool>("searchOpt", false);
  
     desc.add<std::string>("howToUseMeasurementTracker", "ForSiStrips");
  
     // allow both InputTag and string for the moment, use InputTag as the default
     desc.addNode(edm::ParameterDescription<edm::InputTag>(
                      "measurementTrackerName", edm::InputTag("MeasurementTrackerEvent"), true) xor
                  edm::ParameterDescription<std::string>("measurementTrackerName", "MeasurementTrackerEvent", true));
  
     // Only for backwards-compatibility
     edm::ParameterSetDescription descRegion;
     descRegion.add<edm::ParameterSetDescription>("RegionPSet", desc);
  
     descriptions.add("tauRegionalPixelSeedTrackingRegions", descRegion);
   }

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), submitPVResolutionJobs::desc, HLT_FULL_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

◆ regions()

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

inlineoverridevirtual

Implements TrackingRegionProducer.

Definition at line 95 of file TauRegionalPixelSeedGenerator.h.

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