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

inlineexplicit

Definition at line 36 of file TauRegionalPixelSeedGenerator.h.

References edm::ParameterSet::exists(), edm::ParameterSet::existsAs(), edm::ParameterSet::getParameter(), RectangularEtaPhiTrackingRegion::kNever, m_deltaEta, m_deltaPhi, m_halfLength, m_howToUseMeasurementTracker, m_originRadius, m_ptMin, m_searchOpt, AlCaHLTBitMon_QueryRunRegistry::string, RectangularEtaPhiTrackingRegion::stringToUseMeasurementTracker(), GlobalPosition_Frontier_DevDB_cff::tag, 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) {
         // 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);
       }
     }

TauRegionalPixelSeedGenerator::~TauRegionalPixelSeedGenerator ( )

inlineoverride

Definition at line 70 of file TauRegionalPixelSeedGenerator.h.

70 {}

Member Function Documentation

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

inlinestatic

Definition at line 72 of file TauRegionalPixelSeedGenerator.h.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addNode(), and AlCaHLTBitMon_QueryRunRegistry::string.

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

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

inlineoverridevirtual

Implements TrackingRegionProducer.

Definition at line 98 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, edm::Handle< T >::product(), mps_fire::result, token_jet, token_measurementTracker, token_vertex, and electrons_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;
     }