#include <HITRegionalPixelSeedGenerator.h>

Inheritance diagram for HITRegionalPixelSeedGenerator:

Public Member Functions
	HITRegionalPixelSeedGenerator (const edm::ParameterSet &conf_, edm::ConsumesCollector &&iC)

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

	~HITRegionalPixelSeedGenerator () override

Public Member Functions inherited from TrackingRegionProducer
virtual	~TrackingRegionProducer ()

Private Attributes
edm::ParameterSet	conf_

float	deltaL1JetEta

float	deltaL1JetPhi

float	deltaTrackEta

float	deltaTrackPhi

double	etaCenter_

bool	fixedReg_

float	halflength

float	originradius

double	phiCenter_

float	ptmin

edm::EDGetTokenT< trigger::TriggerFilterObjectWithRefs >	token_isoTrack

edm::EDGetTokenT< l1extra::L1JetParticleCollection >	token_l1jet

edm::EDGetTokenT< reco::TrackCollection >	token_trks

edm::EDGetTokenT< reco::VertexCollection >	token_vertex

bool	useIsoTracks_

bool	usejets_

bool	usetracks_

Detailed Description

Definition at line 35 of file HITRegionalPixelSeedGenerator.h.

Constructor & Destructor Documentation

◆ HITRegionalPixelSeedGenerator()

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

inlineexplicit

Definition at line 37 of file HITRegionalPixelSeedGenerator.h.

                                                                                                   {
     edm::LogVerbatim("HITRegionalPixelSeedGenerator") << "Enter the HITRegionalPixelSeedGenerator";
  
     edm::ParameterSet regionPSet = conf_.getParameter<edm::ParameterSet>("RegionPSet");
  
     ptmin = regionPSet.getParameter<double>("ptMin");
     originradius = regionPSet.getParameter<double>("originRadius");
     halflength = regionPSet.getParameter<double>("originHalfLength");
     etaCenter_ = regionPSet.getParameter<double>("etaCenter");
     phiCenter_ = regionPSet.getParameter<double>("phiCenter");
     deltaTrackEta = regionPSet.getParameter<double>("deltaEtaTrackRegion");
     deltaTrackPhi = regionPSet.getParameter<double>("deltaPhiTrackRegion");
     deltaL1JetEta = regionPSet.getParameter<double>("deltaEtaL1JetRegion");
     deltaL1JetPhi = regionPSet.getParameter<double>("deltaPhiL1JetRegion");
     usejets_ = regionPSet.getParameter<bool>("useL1Jets");
     usetracks_ = regionPSet.getParameter<bool>("useTracks");
     useIsoTracks_ = regionPSet.getParameter<bool>("useIsoTracks");
     fixedReg_ = regionPSet.getParameter<bool>("fixedReg");
  
     if (usetracks_)
       token_trks = iC.consumes<reco::TrackCollection>(regionPSet.getParameter<edm::InputTag>("trackSrc"));
     if (usetracks_ || useIsoTracks_ || fixedReg_ || usejets_)
       token_vertex = iC.consumes<reco::VertexCollection>(regionPSet.getParameter<edm::InputTag>("vertexSrc"));
     if (useIsoTracks_)
       token_isoTrack =
           iC.consumes<trigger::TriggerFilterObjectWithRefs>(regionPSet.getParameter<edm::InputTag>("isoTrackSrc"));
     if (usejets_)
       token_l1jet = iC.consumes<l1extra::L1JetParticleCollection>(regionPSet.getParameter<edm::InputTag>("l1tjetSrc"));
   }

References conf_, deltaL1JetEta, deltaL1JetPhi, deltaTrackEta, deltaTrackPhi, etaCenter_, fixedReg_, edm::ParameterSet::getParameter(), halflength, originradius, phiCenter_, ptmin, token_isoTrack, token_l1jet, token_trks, token_vertex, useIsoTracks_, usejets_, and usetracks_.

◆ ~HITRegionalPixelSeedGenerator()

HITRegionalPixelSeedGenerator::~HITRegionalPixelSeedGenerator ( )

inlineoverride

Definition at line 67 of file HITRegionalPixelSeedGenerator.h.

67 {}

Member Function Documentation

◆ regions()

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

inlineoverridevirtual

Implements TrackingRegionProducer.

Definition at line 69 of file HITRegionalPixelSeedGenerator.h.

                                                                                                                {
     std::vector<std::unique_ptr<TrackingRegion> > result;
     float originz = 0.;
  
     double deltaZVertex = halflength;
  
     if (usetracks_) {
       edm::Handle<reco::TrackCollection> tracks;
       e.getByToken(token_trks, tracks);
  
       edm::Handle<reco::VertexCollection> vertices;
       e.getByToken(token_vertex, vertices);
       const reco::VertexCollection vertCollection = *(vertices.product());
       reco::VertexCollection::const_iterator ci = vertCollection.begin();
  
       if (!vertCollection.empty()) {
         originz = ci->z();
       } else {
         deltaZVertex = 15.;
       }
  
       GlobalVector globalVector(0, 0, 1);
       if (tracks->empty())
         return result;
  
       reco::TrackCollection::const_iterator itr = tracks->begin();
       for (; itr != tracks->end(); itr++) {
         GlobalVector ptrVec((itr)->px(), (itr)->py(), (itr)->pz());
         globalVector = ptrVec;
  
         result.push_back(std::make_unique<RectangularEtaPhiTrackingRegion>(
             globalVector, GlobalPoint(0, 0, originz), ptmin, originradius, deltaZVertex, deltaTrackEta, deltaTrackPhi));
       }
     }
  
     if (useIsoTracks_) {
       edm::Handle<trigger::TriggerFilterObjectWithRefs> isotracks;
       e.getByToken(token_isoTrack, isotracks);
  
       std::vector<edm::Ref<reco::IsolatedPixelTrackCandidateCollection> > isoPixTrackRefs;
  
       isotracks->getObjects(trigger::TriggerTrack, isoPixTrackRefs);
  
       edm::Handle<reco::VertexCollection> vertices;
       e.getByToken(token_vertex, vertices);
       const reco::VertexCollection vertCollection = *(vertices.product());
       reco::VertexCollection::const_iterator ci = vertCollection.begin();
  
       if (!vertCollection.empty()) {
         originz = ci->z();
       } else {
         deltaZVertex = 15.;
       }
  
       GlobalVector globalVector(0, 0, 1);
       if (isoPixTrackRefs.empty())
         return result;
  
       for (uint32_t p = 0; p < isoPixTrackRefs.size(); p++) {
         GlobalVector ptrVec((isoPixTrackRefs[p]->track())->px(),
                             (isoPixTrackRefs[p]->track())->py(),
                             (isoPixTrackRefs[p]->track())->pz());
         globalVector = ptrVec;
  
         result.push_back(std::make_unique<RectangularEtaPhiTrackingRegion>(
             globalVector, GlobalPoint(0, 0, originz), ptmin, originradius, deltaZVertex, deltaTrackEta, deltaTrackPhi));
       }
     }
  
     if (usejets_) {
       edm::Handle<l1extra::L1JetParticleCollection> jets;
       e.getByToken(token_l1jet, jets);
  
       edm::Handle<reco::VertexCollection> vertices;
       e.getByToken(token_vertex, vertices);
       const reco::VertexCollection vertCollection = *(vertices.product());
       reco::VertexCollection::const_iterator ci = vertCollection.begin();
       if (!vertCollection.empty()) {
         originz = ci->z();
       } else {
         deltaZVertex = 15.;
       }
  
       GlobalVector globalVector(0, 0, 1);
       if (jets->empty())
         return result;
  
       for (l1extra::L1JetParticleCollection::const_iterator iJet = jets->begin(); iJet != jets->end(); iJet++) {
         GlobalVector jetVector(iJet->p4().x(), iJet->p4().y(), iJet->p4().z());
         GlobalPoint vertex(0, 0, originz);
  
         result.push_back(std::make_unique<RectangularEtaPhiTrackingRegion>(
             jetVector, vertex, ptmin, originradius, deltaZVertex, deltaL1JetEta, deltaL1JetPhi));
       }
     }
     if (fixedReg_) {
       GlobalVector fixedVector(cos(phiCenter_) * sin(2 * atan(exp(-etaCenter_))),
                                sin(phiCenter_) * sin(2 * atan(exp(-etaCenter_))),
                                cos(2 * atan(exp(-etaCenter_))));
       GlobalPoint vertex(0, 0, originz);
  
       edm::Handle<reco::VertexCollection> vertices;
       e.getByToken(token_vertex, vertices);
       const reco::VertexCollection vertCollection = *(vertices.product());
       reco::VertexCollection::const_iterator ci = vertCollection.begin();
       if (!vertCollection.empty()) {
         originz = ci->z();
       } else {
         deltaZVertex = 15.;
       }
  
       result.push_back(std::make_unique<RectangularEtaPhiTrackingRegion>(
           fixedVector, vertex, ptmin, originradius, deltaZVertex, deltaL1JetEta, deltaL1JetPhi));
     }
  
     return result;
   }