#include <HITRegionalPixelSeedGenerator.h>

Inheritance diagram for HITRegionalPixelSeedGenerator:

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

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

virtual	~HITRegionalPixelSeedGenerator ()

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

inlineexplicit

Definition at line 38 of file HITRegionalPixelSeedGenerator.h.

References 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_.

   {
     edm::LogInfo ("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"));
   }

virtual HITRegionalPixelSeedGenerator::~HITRegionalPixelSeedGenerator ( )

inlinevirtual

Definition at line 66 of file HITRegionalPixelSeedGenerator.h.

66 {}

Member Function Documentation

virtual 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.

References funct::cos(), deltaL1JetEta, deltaL1JetPhi, deltaTrackEta, deltaTrackPhi, etaCenter_, JetChargeProducer_cfi::exp, fixedReg_, edm::Event::getByToken(), trigger::TriggerRefsCollections::getObjects(), halflength, fwrapper::jets, originradius, AlCaHLTBitMon_ParallelJobs::p, phiCenter_, edm::Handle< T >::product(), ptmin, mps_fire::result, funct::sin(), token_isoTrack, token_l1jet, token_trks, token_vertex, HiIsolationCommonParameters_cff::track, l1t::tracks, trigger::TriggerTrack, useIsoTracks_, usejets_, usetracks_, and ecalDrivenElectronSeedsParameters_cff::vertices.

     {
       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.size() > 0) 
         {
           originz = ci->z();
         }
       else
         {
           deltaZVertex = 15.;
         }
       
       GlobalVector globalVector(0,0,1);
       if(tracks->size() == 0) 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.size() > 0) 
         {
           originz = ci->z();
         }
       else
         {
           deltaZVertex = 15.;
         }
       
           GlobalVector globalVector(0,0,1);
           if(isoPixTrackRefs.size() == 0) 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.size() > 0) 
         {
           originz = ci->z();
         }
       else
         {
           deltaZVertex = 15.;
         }
 
       GlobalVector globalVector(0,0,1);
       if(jets->size() == 0) 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.size() > 0) 
         {
           originz = ci->z();
         }
       else
         {
           deltaZVertex = 15.;
         }
       
       result.push_back(std::make_unique<RectangularEtaPhiTrackingRegion>( fixedVector,
                                                                               vertex,
                                                                               ptmin,
                                                                               originradius,
                                                                               deltaZVertex,
                                                                               deltaL1JetEta,
                                                                               deltaL1JetPhi ));
     }
       
       return result;
     }