#include <TauRegionalPixelSeedGenerator.h>

Inheritance diagram for TauRegionalPixelSeedGenerator:

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

	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

double	m_howToUseMeasurementTracker

std::string	m_measurementTracker

float	m_originRadius

float	m_ptMin

bool	m_searchOpt

edm::EDGetTokenT < reco::CandidateView >	token_jet

edm::EDGetTokenT < reco::VertexCollection >	token_vertex

Detailed Description

Definition at line 32 of file TauRegionalPixelSeedGenerator.h.

Constructor & Destructor Documentation

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

inlineexplicit

Definition at line 35 of file TauRegionalPixelSeedGenerator.h.

References edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), m_deltaEta, m_deltaPhi, m_halfLength, m_howToUseMeasurementTracker, m_measurementTracker, m_originRadius, m_ptMin, m_searchOpt, AlCaHLTBitMon_QueryRunRegistry::string, token_jet, 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_measurementTracker ="";
       m_howToUseMeasurementTracker=0;
       if (regionPSet.exists("measurementTrackerName")){
     m_measurementTracker = regionPSet.getParameter<std::string>("measurementTrackerName");
     if (regionPSet.exists("howToUseMeasurementTracker")){
       m_howToUseMeasurementTracker = regionPSet.getParameter<double>("howToUseMeasurementTracker");
     }
       }
     }

virtual TauRegionalPixelSeedGenerator::~TauRegionalPixelSeedGenerator ( )

inlinevirtual

Definition at line 64 of file TauRegionalPixelSeedGenerator.h.

64 {}

Member Function Documentation

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

inlinevirtual

Implements TrackingRegionProducer.

Definition at line 67 of file TauRegionalPixelSeedGenerator.h.

References edm::Event::getByToken(), m_deltaEta, m_deltaPhi, m_halfLength, m_howToUseMeasurementTracker, m_measurementTracker, m_originRadius, m_ptMin, m_searchOpt, reco::Candidate::momentum(), query::result, token_jet, and token_vertex.

                                                                                                   {
       std::vector<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);
       
       for (unsigned int iJet =0; iJet < h_jets->size(); ++iJet)
     {
       const reco::Candidate & myJet = (*h_jets)[iJet];
           GlobalVector jetVector(myJet.momentum().x(),myJet.momentum().y(),myJet.momentum().z());
 //          GlobalPoint  vertex(0, 0, originZ);
           RectangularEtaPhiTrackingRegion* etaphiRegion = new RectangularEtaPhiTrackingRegion( jetVector,
                                                                                                vertex,
                                                                                                m_ptMin,
                                                                                                deltaRho,
                                                                                                deltaZVertex,
                                                                                                m_deltaEta,
                                                                                                m_deltaPhi,
                                                    m_howToUseMeasurementTracker,
                                                    true,
                                                    m_measurementTracker,
                                                    m_searchOpt);
           result.push_back(etaphiRegion);
       }
 
       return result;
     }