#include <TrackingRegionsFromBeamSpotAndL2Tau.h>

Inheritance diagram for TrackingRegionsFromBeamSpotAndL2Tau:

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

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

	~TrackingRegionsFromBeamSpotAndL2Tau () override

Public Member Functions inherited from TrackingRegionProducer
virtual	~TrackingRegionProducer ()

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Attributes
float	m_deltaEta

float	m_deltaPhi

float	m_jetMaxEta

int	m_jetMaxN

float	m_jetMinPt

float	m_originHalfLength

float	m_originRadius

bool	m_precise

float	m_ptMin

bool	m_searchOpt

RectangularEtaPhiTrackingRegion::UseMeasurementTracker	m_whereToUseMeasurementTracker

edm::EDGetTokenT< reco::BeamSpot >	token_beamSpot

edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	token_field

edm::EDGetTokenT< reco::CandidateView >	token_jet

edm::EDGetTokenT< MeasurementTrackerEvent >	token_measurementTracker

edm::ESGetToken< MultipleScatteringParametrisationMaker, TrackerMultipleScatteringRecord >	token_msmaker

Detailed Description

class TrackingRegionsFromBeamSpotAndL2Tau plugin for creating eta-phi TrackingRegions in directions of L2 taus

Definition at line 25 of file TrackingRegionsFromBeamSpotAndL2Tau.h.

Constructor & Destructor Documentation

◆ TrackingRegionsFromBeamSpotAndL2Tau()

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

inlineexplicit

Definition at line 27 of file TrackingRegionsFromBeamSpotAndL2Tau.h.

References edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), RectangularEtaPhiTrackingRegion::kNever, m_deltaEta, m_deltaPhi, m_jetMaxEta, m_jetMaxN, m_jetMinPt, m_originHalfLength, m_originRadius, m_precise, m_ptMin, m_searchOpt, m_whereToUseMeasurementTracker, AlCaHLTBitMon_QueryRunRegistry::string, RectangularEtaPhiTrackingRegion::stringToUseMeasurementTracker(), token_beamSpot, token_field, token_jet, token_measurementTracker, and token_msmaker.

                                                                                                        {
     edm::LogInfo("TrackingRegionsFromBeamSpotAndL2Tau") << "Enter the TrackingRegionsFromBeamSpotAndL2Tau";
 
     edm::ParameterSet regionPSet = conf.getParameter<edm::ParameterSet>("RegionPSet");
 
     m_ptMin = regionPSet.getParameter<double>("ptMin");
     m_originRadius = regionPSet.getParameter<double>("originRadius");
     m_originHalfLength = regionPSet.getParameter<double>("originHalfLength");
     m_deltaEta = regionPSet.getParameter<double>("deltaEta");
     m_deltaPhi = regionPSet.getParameter<double>("deltaPhi");
     token_jet = iC.consumes<reco::CandidateView>(regionPSet.getParameter<edm::InputTag>("JetSrc"));
     m_jetMinPt = regionPSet.getParameter<double>("JetMinPt");
     m_jetMaxEta = regionPSet.getParameter<double>("JetMaxEta");
     m_jetMaxN = regionPSet.getParameter<int>("JetMaxN");
     token_beamSpot = iC.consumes<reco::BeamSpot>(regionPSet.getParameter<edm::InputTag>("beamSpot"));
     m_precise = regionPSet.getParameter<bool>("precise");
 
     if (regionPSet.exists("searchOpt"))
       m_searchOpt = regionPSet.getParameter<bool>("searchOpt");
     else
       m_searchOpt = false;
 
     m_whereToUseMeasurementTracker = RectangularEtaPhiTrackingRegion::stringToUseMeasurementTracker(
         regionPSet.getParameter<std::string>("whereToUseMeasurementTracker"));
     if (m_whereToUseMeasurementTracker != RectangularEtaPhiTrackingRegion::UseMeasurementTracker::kNever) {
       token_measurementTracker =
           iC.consumes<MeasurementTrackerEvent>(regionPSet.getParameter<edm::InputTag>("measurementTrackerName"));
     }
     token_field = iC.esConsumes();
     if (m_precise) {
       token_msmaker = iC.esConsumes();
     }
   }

◆ ~TrackingRegionsFromBeamSpotAndL2Tau()

TrackingRegionsFromBeamSpotAndL2Tau::~TrackingRegionsFromBeamSpotAndL2Tau ( )

inlineoverride

Definition at line 61 of file TrackingRegionsFromBeamSpotAndL2Tau.h.

61 {}

Member Function Documentation

◆ fillDescriptions()

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

inlinestatic

Definition at line 63 of file TrackingRegionsFromBeamSpotAndL2Tau.h.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), submitPVResolutionJobs::desc, HLT_2022v12_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                            {
     edm::ParameterSetDescription desc;
 
     desc.add<double>("ptMin", 5.0);
     desc.add<double>("originRadius", 0.2);
     desc.add<double>("originHalfLength", 24.0);
     desc.add<double>("deltaEta", 0.3);
     desc.add<double>("deltaPhi", 0.3);
     desc.add<edm::InputTag>("JetSrc", edm::InputTag("hltFilterL2EtCutDoublePFIsoTau25Trk5"));
     desc.add<double>("JetMinPt", 25.0);
     desc.add<double>("JetMaxEta", 2.1);
     desc.add<int>("JetMaxN", 10);
     desc.add<edm::InputTag>("beamSpot", edm::InputTag("hltOnlineBeamSpot"));
     desc.add<bool>("precise", true);
     desc.add<std::string>("howToUseMeasurementTracker", "Never");
     desc.add<edm::InputTag>("measurementTrackerName", edm::InputTag("MeasurementTrackerEvent"));
 
     // Only for backwards-compatibility
     edm::ParameterSetDescription descRegion;
     descRegion.add<edm::ParameterSetDescription>("RegionPSet", desc);
 
     descriptions.add("trackingRegionsFromBeamSpotAndL2Tau", descRegion);
   }

◆ regions()

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

inlineoverridevirtual

Implements TrackingRegionProducer.

Definition at line 87 of file TrackingRegionsFromBeamSpotAndL2Tau.h.

References funct::abs(), cms::cuda::bs, MillePedeFileConverter_cfg::e, edm::EventSetup::getData(), mps_fire::i, edm::EDGetTokenT< T >::isUninitialized(), edm::HandleBase::isValid(), metsig::jet, m_deltaEta, m_deltaPhi, m_jetMaxEta, m_jetMaxN, m_jetMinPt, m_originHalfLength, m_originRadius, m_precise, m_ptMin, m_searchOpt, m_whereToUseMeasurementTracker, HLTSiStripMonitoring_cff::measurementTracker, L1TPhase2Offline_cfi::objects, edm::Handle< T >::product(), mps_fire::result, token_beamSpot, token_field, token_jet, token_measurementTracker, and token_msmaker.

                                                                                                                {
     std::vector<std::unique_ptr<TrackingRegion> > result;
 
     // use beam spot to pick up the origin
     edm::Handle<reco::BeamSpot> bsHandle;
     e.getByToken(token_beamSpot, bsHandle);
     if (!bsHandle.isValid())
       return result;
     const reco::BeamSpot& bs = *bsHandle;
     GlobalPoint origin(bs.x0(), bs.y0(), bs.z0());
 
     // pick up the candidate objects of interest
     edm::Handle<reco::CandidateView> objects;
     e.getByToken(token_jet, objects);
     size_t n_objects = objects->size();
     if (n_objects == 0)
       return result;
 
     const MeasurementTrackerEvent* measurementTracker = nullptr;
     if (!token_measurementTracker.isUninitialized()) {
       edm::Handle<MeasurementTrackerEvent> hmte;
       e.getByToken(token_measurementTracker, hmte);
       measurementTracker = hmte.product();
     }
 
     const auto& field = es.getData(token_field);
     const MultipleScatteringParametrisationMaker* msmaker = nullptr;
     if (m_precise) {
       msmaker = &es.getData(token_msmaker);
     }
 
     // create maximum JetMaxN tracking regions in directions of
     // highest pt jets that are above threshold and are within allowed eta
     // (we expect that jet collection was sorted in decreasing pt order)
     int n_regions = 0;
     for (size_t i = 0; i < n_objects && n_regions < m_jetMaxN; ++i) {
       const reco::Candidate& jet = (*objects)[i];
       if (jet.pt() < m_jetMinPt || std::abs(jet.eta()) > m_jetMaxEta)
         continue;
 
       GlobalVector direction(jet.momentum().x(), jet.momentum().y(), jet.momentum().z());
 
       result.push_back(std::make_unique<RectangularEtaPhiTrackingRegion>(direction,
                                                                          origin,
                                                                          m_ptMin,
                                                                          m_originRadius,
                                                                          m_originHalfLength,
                                                                          m_deltaEta,
                                                                          m_deltaPhi,
                                                                          field,
                                                                          msmaker,
                                                                          m_precise,
                                                                          m_whereToUseMeasurementTracker,
                                                                          measurementTracker,
                                                                          m_searchOpt));
       ++n_regions;
     }
     //std::cout<<"nregions = "<<n_regions<<std::endl;
     return result;
   }