#include <PointSeededTrackingRegionsProducer.h>

Inheritance diagram for PointSeededTrackingRegionsProducer:

Public Types
enum	Mode { BEAM_SPOT_FIXED, BEAM_SPOT_SIGMA, VERTICES_FIXED, VERTICES_SIGMA }

Public Member Functions
	PointSeededTrackingRegionsProducer (const edm::ParameterSet &conf, edm::ConsumesCollector &&iC)

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

	~PointSeededTrackingRegionsProducer () override

Public Member Functions inherited from TrackingRegionProducer
virtual	~TrackingRegionProducer ()

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

Private Attributes
std::vector< double >	etaPoints

float	m_deltaEta

float	m_deltaPhi

int	m_maxNRegions

int	m_maxNVertices

Mode	m_mode

float	m_nSigmaZBeamSpot

float	m_nSigmaZVertex

float	m_originRadius

bool	m_precise

float	m_ptMin

bool	m_searchOpt

RectangularEtaPhiTrackingRegion::UseMeasurementTracker	m_whereToUseMeasurementTracker

float	m_zErrorBeamSpot

float	m_zErrorVetex

std::vector< double >	phiPoints

edm::EDGetTokenT< reco::BeamSpot >	token_beamSpot

edm::EDGetTokenT< MeasurementTrackerEvent >	token_measurementTracker

edm::EDGetTokenT< reco::VertexCollection >	token_vertex

Detailed Description

class PointSeededTrackingRegionsProducer

eta-phi TrackingRegions producer in directions defined by Point-based objects of interest from the "input" parameters.

Four operational modes are supported ("mode" parameter):

BeamSpotFixed: origin is defined by the beam spot z-half-length is defined by a fixed zErrorBeamSpot parameter BeamSpotSigma: origin is defined by the beam spot z-half-length is defined by nSigmaZBeamSpot * beamSpot.sigmaZ VerticesFixed: origins are defined by vertices from VertexCollection (use maximum MaxNVertices of them) z-half-length is defined by a fixed zErrorVetex parameter VerticesSigma: origins are defined by vertices from VertexCollection (use maximum MaxNVertices of them) z-half-length is defined by nSigmaZVertex * vetex.zError

If, while using one of the "Vertices" modes, there's no vertices in an event, we fall back into either BeamSpotSigma or BeamSpotFixed mode, depending on the positiveness of nSigmaZBeamSpot.

Definition at line 48 of file PointSeededTrackingRegionsProducer.h.

Member Enumeration Documentation

◆ Mode

enum PointSeededTrackingRegionsProducer::Mode

Enumerator
BEAM_SPOT_FIXED
BEAM_SPOT_SIGMA
VERTICES_FIXED
VERTICES_SIGMA

Definition at line 50 of file PointSeededTrackingRegionsProducer.h.

50 { BEAM_SPOT_FIXED, BEAM_SPOT_SIGMA, VERTICES_FIXED, VERTICES_SIGMA } Mode;

Constructor & Destructor Documentation

◆ PointSeededTrackingRegionsProducer()

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

inlineexplicit

Definition at line 52 of file PointSeededTrackingRegionsProducer.h.

                                                                                                       {
     edm::ParameterSet regPSet = conf.getParameter<edm::ParameterSet>("RegionPSet");
  
     // operation mode
     std::string modeString = regPSet.getParameter<std::string>("mode");
     if (modeString == "BeamSpotFixed")
       m_mode = BEAM_SPOT_FIXED;
     else if (modeString == "BeamSpotSigma")
       m_mode = BEAM_SPOT_SIGMA;
     else if (modeString == "VerticesFixed")
       m_mode = VERTICES_FIXED;
     else if (modeString == "VerticesSigma")
       m_mode = VERTICES_SIGMA;
     else
       edm::LogError("PointSeededTrackingRegionsProducer") << "Unknown mode string: " << modeString;
  
     // basic inputsi
     edm::ParameterSet points = regPSet.getParameter<edm::ParameterSet>("points");
     etaPoints = points.getParameter<std::vector<double>>("eta");
     phiPoints = points.getParameter<std::vector<double>>("phi");
     if (!(etaPoints.size() == phiPoints.size()))
       throw edm::Exception(edm::errors::Configuration) << "The parameters 'eta' and 'phi' must have the same size";
     ;
     m_maxNRegions = regPSet.getParameter<int>("maxNRegions");
     token_beamSpot = iC.consumes<reco::BeamSpot>(regPSet.getParameter<edm::InputTag>("beamSpot"));
     m_maxNVertices = 1;
     if (m_mode == VERTICES_FIXED || m_mode == VERTICES_SIGMA) {
       token_vertex = iC.consumes<reco::VertexCollection>(regPSet.getParameter<edm::InputTag>("vertexCollection"));
       m_maxNVertices = regPSet.getParameter<int>("maxNVertices");
     }
  
     // RectangularEtaPhiTrackingRegion parameters:
     m_ptMin = regPSet.getParameter<double>("ptMin");
     m_originRadius = regPSet.getParameter<double>("originRadius");
     m_zErrorBeamSpot = regPSet.getParameter<double>("zErrorBeamSpot");
     m_deltaEta = regPSet.getParameter<double>("deltaEta");
     m_deltaPhi = regPSet.getParameter<double>("deltaPhi");
     m_precise = regPSet.getParameter<bool>("precise");
     m_whereToUseMeasurementTracker = RectangularEtaPhiTrackingRegion::stringToUseMeasurementTracker(
         regPSet.getParameter<std::string>("whereToUseMeasurementTracker"));
     if (m_whereToUseMeasurementTracker != RectangularEtaPhiTrackingRegion::UseMeasurementTracker::kNever) {
       token_measurementTracker =
           iC.consumes<MeasurementTrackerEvent>(regPSet.getParameter<edm::InputTag>("measurementTrackerName"));
     }
     m_searchOpt = false;
     if (regPSet.exists("searchOpt"))
       m_searchOpt = regPSet.getParameter<bool>("searchOpt");
  
     // mode-dependent z-halflength of tracking regions
     if (m_mode == VERTICES_SIGMA)
       m_nSigmaZVertex = regPSet.getParameter<double>("nSigmaZVertex");
     if (m_mode == VERTICES_FIXED)
       m_zErrorVetex = regPSet.getParameter<double>("zErrorVetex");
     m_nSigmaZBeamSpot = -1.;
     if (m_mode == BEAM_SPOT_SIGMA) {
       m_nSigmaZBeamSpot = regPSet.getParameter<double>("nSigmaZBeamSpot");
       if (m_nSigmaZBeamSpot < 0.)
         edm::LogError("PointSeededTrackingRegionsProducer")
             << "nSigmaZBeamSpot must be positive for BeamSpotSigma mode!";
     }
   }

References BEAM_SPOT_FIXED, BEAM_SPOT_SIGMA, edm::errors::Configuration, etaPoints, Exception, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), RectangularEtaPhiTrackingRegion::kNever, m_deltaEta, m_deltaPhi, m_maxNRegions, m_maxNVertices, m_mode, m_nSigmaZBeamSpot, m_nSigmaZVertex, m_originRadius, m_precise, m_ptMin, m_searchOpt, m_whereToUseMeasurementTracker, m_zErrorBeamSpot, m_zErrorVetex, phiPoints, HLT_FULL_cff::points, AlCaHLTBitMon_QueryRunRegistry::string, RectangularEtaPhiTrackingRegion::stringToUseMeasurementTracker(), token_beamSpot, token_measurementTracker, token_vertex, VERTICES_FIXED, and VERTICES_SIGMA.

◆ ~PointSeededTrackingRegionsProducer()

PointSeededTrackingRegionsProducer::~PointSeededTrackingRegionsProducer ( )

inlineoverride

Definition at line 114 of file PointSeededTrackingRegionsProducer.h.

114 {}

Member Function Documentation

◆ fillDescriptions()

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

inlinestatic

Definition at line 116 of file PointSeededTrackingRegionsProducer.h.

                                                                            {
     edm::ParameterSetDescription desc;
  
     edm::ParameterSetDescription descPoints;
     descPoints.add<std::vector<double>>("eta", {0.});
     descPoints.add<std::vector<double>>("phi", {0.});
     desc.add<edm::ParameterSetDescription>("points", descPoints);
  
     desc.add<std::string>("mode", "BeamSpotFixed");
     desc.add<int>("maxNRegions", 10);
     desc.add<edm::InputTag>("beamSpot", edm::InputTag("hltOnlineBeamSpot"));
     desc.add<edm::InputTag>("vertexCollection", edm::InputTag("hltPixelVertices"));
     desc.add<int>("maxNVertices", 1);
  
     desc.add<double>("ptMin", 0.9);
     desc.add<double>("originRadius", 0.2);
     desc.add<double>("zErrorBeamSpot", 24.2);
     desc.add<double>("deltaEta", 0.5);
     desc.add<double>("deltaPhi", 0.5);
     desc.add<bool>("precise", true);
  
     desc.add<double>("nSigmaZVertex", 3.);
     desc.add<double>("zErrorVetex", 0.2);
     desc.add<double>("nSigmaZBeamSpot", 4.);
  
     desc.add<std::string>("whereToUseMeasurementTracker", "ForSiStrips");
     desc.add<edm::InputTag>("measurementTrackerName", edm::InputTag(""));
  
     desc.add<bool>("searchOpt", false);
  
     // Only for backwards-compatibility
     edm::ParameterSetDescription descRegion;
     descRegion.add<edm::ParameterSetDescription>("RegionPSet", desc);
     //edm::ParameterSetDescription descPoint;
     //descPoint.add<edm::ParameterSetDescription>("point_input", desc);
  
     descriptions.add("pointSeededTrackingRegion", descRegion);
   }

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

◆ regions()

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

inlineoverridevirtual

Implements TrackingRegionProducer.

Definition at line 155 of file PointSeededTrackingRegionsProducer.h.

                                                                                                               {
     std::vector<std::unique_ptr<TrackingRegion>> result;
  
     // always need the beam spot (as a fall back strategy for vertex modes)
     edm::Handle<reco::BeamSpot> bs;
     e.getByToken(token_beamSpot, bs);
     if (!bs.isValid())
       return result;
  
     // this is a default origin for all modes
     GlobalPoint default_origin(bs->x0(), bs->y0(), bs->z0());
  
     // vector of origin & halfLength pairs:
     std::vector<std::pair<GlobalPoint, float>> origins;
  
     // fill the origins and halfLengths depending on the mode
     if (m_mode == BEAM_SPOT_FIXED || m_mode == BEAM_SPOT_SIGMA) {
       origins.push_back(std::make_pair(
           default_origin, (m_mode == BEAM_SPOT_FIXED) ? m_zErrorBeamSpot : m_nSigmaZBeamSpot * bs->sigmaZ()));
     } else if (m_mode == VERTICES_FIXED || m_mode == VERTICES_SIGMA) {
       edm::Handle<reco::VertexCollection> vertices;
       e.getByToken(token_vertex, vertices);
       int n_vert = 0;
       for (reco::VertexCollection::const_iterator iv = vertices->begin(), ev = vertices->end();
            iv != ev && n_vert < m_maxNVertices;
            ++iv) {
         if (iv->isFake() || !iv->isValid())
           continue;
  
         origins.push_back(std::make_pair(GlobalPoint(iv->x(), iv->y(), iv->z()),
                                          (m_mode == VERTICES_FIXED) ? m_zErrorVetex : m_nSigmaZVertex * iv->zError()));
         ++n_vert;
       }
       // no-vertex fall-back case:
       if (origins.empty()) {
         origins.push_back(std::make_pair(
             default_origin, (m_nSigmaZBeamSpot > 0.) ? m_nSigmaZBeamSpot * bs->z0Error() : m_zErrorBeamSpot));
       }
     }
  
     const MeasurementTrackerEvent* measurementTracker = nullptr;
     if (!token_measurementTracker.isUninitialized()) {
       edm::Handle<MeasurementTrackerEvent> hmte;
       e.getByToken(token_measurementTracker, hmte);
       measurementTracker = hmte.product();
     }
  
     // create tracking regions (maximum MaxNRegions of them) in directions of the
     // points of interest
     size_t n_points = etaPoints.size();
     int n_regions = 0;
     for (size_t i = 0; i < n_points && n_regions < m_maxNRegions; ++i) {
       double x = std::cos(phiPoints[i]);
       double y = std::sin(phiPoints[i]);
       double theta = 2 * std::atan(std::exp(-etaPoints[i]));
       double z = 1. / std::tan(theta);
  
       GlobalVector direction(x, y, z);
  
       for (size_t j = 0; j < origins.size() && n_regions < m_maxNRegions; ++j) {
         result.push_back(std::make_unique<RectangularEtaPhiTrackingRegion>(direction,         // GlobalVector
                                                                            origins[j].first,  // GlobalPoint
                                                                            m_ptMin,
                                                                            m_originRadius,
                                                                            origins[j].second,
                                                                            m_deltaEta,
                                                                            m_deltaPhi,
                                                                            m_whereToUseMeasurementTracker,
                                                                            m_precise,
                                                                            measurementTracker,
                                                                            m_searchOpt));
         ++n_regions;
       }
     }
     edm::LogInfo("PointSeededTrackingRegionsProducer") << "produced " << n_regions << " regions";
  
     return result;
   }