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=default

Public Member Functions inherited from TrackingRegionProducer
virtual	~TrackingRegionProducer ()

Private Attributes
const float	deltaL1JetEta

const float	deltaL1JetPhi

const float	deltaTrackEta

const float	deltaTrackPhi

const double	etaCenter_

const bool	fixedReg_

const float	halflength

const edm::ParameterSet	m_regionPSet

const float	originradius

const double	phiCenter_

const float	ptmin

const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	token_bfield

edm::EDGetTokenT< trigger::TriggerFilterObjectWithRefs >	token_isoTrack

edm::EDGetTokenT< l1extra::L1JetParticleCollection >	token_l1jet

const edm::ESGetToken< MultipleScatteringParametrisationMaker, TrackerMultipleScatteringRecord >	token_msmaker

edm::EDGetTokenT< reco::TrackCollection >	token_trks

edm::EDGetTokenT< reco::VertexCollection >	token_vertex

const bool	useIsoTracks_

const bool	usejets_

const bool	usetracks_

Detailed Description

Definition at line 34 of file HITRegionalPixelSeedGenerator.cc.

Constructor & Destructor Documentation

◆ HITRegionalPixelSeedGenerator()

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

inlineexplicit

Definition at line 36 of file HITRegionalPixelSeedGenerator.cc.

References fixedReg_, edm::ParameterSet::getParameter(), m_regionPSet, token_isoTrack, token_l1jet, token_trks, token_vertex, useIsoTracks_, usejets_, and usetracks_.

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

◆ ~HITRegionalPixelSeedGenerator()

HITRegionalPixelSeedGenerator::~HITRegionalPixelSeedGenerator ( )

overridedefault

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

References funct::cos(), deltaL1JetEta, deltaL1JetPhi, deltaTrackEta, deltaTrackPhi, MillePedeFileConverter_cfg::e, etaCenter_, JetChargeProducer_cfi::exp, fixedReg_, edm::EventSetup::getData(), trigger::TriggerRefsCollections::getObjects(), halflength, PDWG_EXODelayedJetMET_cff::jets, originradius, AlCaHLTBitMon_ParallelJobs::p, phiCenter_, ptmin, multPhiCorr_741_25nsDY_cfi::px, multPhiCorr_741_25nsDY_cfi::py, mps_fire::result, funct::sin(), token_bfield, token_isoTrack, token_l1jet, token_msmaker, token_trks, token_vertex, HLT_2023v12_cff::track, DiMuonV_cfg::tracks, trigger::TriggerTrack, useIsoTracks_, usejets_, usetracks_, and bphysicsOniaDQM_cfi::vertex.

                                                                                                                {
     std::vector<std::unique_ptr<TrackingRegion> > result;
     float originz = 0.;
 
     double deltaZVertex = halflength;
 
     auto const& bfield = es.getData(token_bfield);
     auto const& msmaker = es.getData(token_msmaker);
 
     if (usetracks_) {
       const edm::Handle<reco::TrackCollection>& tracks = e.getHandle(token_trks);
 
       const reco::VertexCollection& vertCollection = e.get(token_vertex);
       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,
                                                                            bfield,
                                                                            &msmaker));
       }
     }
 
     if (useIsoTracks_) {
       const edm::Handle<trigger::TriggerFilterObjectWithRefs>& isotracks = e.getHandle(token_isoTrack);
 
       std::vector<edm::Ref<reco::IsolatedPixelTrackCandidateCollection> > isoPixTrackRefs;
 
       isotracks->getObjects(trigger::TriggerTrack, isoPixTrackRefs);
 
       const reco::VertexCollection& vertCollection = e.get(token_vertex);
       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,
                                                                            bfield,
                                                                            &msmaker));
       }
     }
 
     if (usejets_) {
       const edm::Handle<l1extra::L1JetParticleCollection>& jets = e.getHandle(token_l1jet);
       const reco::VertexCollection& vertCollection = e.get(token_vertex);
       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, bfield, &msmaker));
       }
     }
     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);
 
       const reco::VertexCollection& vertCollection = e.get(token_vertex);
       if (!vertCollection.empty()) {
         //      reco::VertexCollection::const_iterator ci = vertCollection.begin();
         //      originz = ci->z();
       } else {
         deltaZVertex = 15.;
       }
 
       result.push_back(std::make_unique<RectangularEtaPhiTrackingRegion>(
           fixedVector, vertex, ptmin, originradius, deltaZVertex, deltaL1JetEta, deltaL1JetPhi, bfield, &msmaker));
     }
 
     return result;
   }