#include <TrackingRegionsFromSuperClustersProducer.h>

Inheritance diagram for TrackingRegionsFromSuperClustersProducer:

Public Types
enum	Charge { Charge::NEG = -1, Charge::POS = +1 }

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

	TrackingRegionsFromSuperClustersProducer (const edm::ParameterSet &cfg, edm::ConsumesCollector &&cc)

	~TrackingRegionsFromSuperClustersProducer () override

Public Member Functions inherited from TrackingRegionProducer
virtual	~TrackingRegionProducer ()

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

Private Member Functions
std::unique_ptr< TrackingRegion >	createTrackingRegion (const reco::SuperCluster &superCluster, const GlobalPoint &vtxPos, const double deltaZVertex, const Charge charge, const MeasurementTrackerEvent *measTrackerEvent, const MagneticField &magField) const

GlobalPoint	getVtxPos (const edm::Event &iEvent, double &deltaZVertex) const

void	validateConfigSettings () const

Private Attributes
edm::EDGetTokenT< reco::BeamSpot >	beamSpotToken_

double	defaultZ_

double	deltaEtaRegion_

double	deltaPhiRegion_

edm::EDGetTokenT< MeasurementTrackerEvent >	measTrackerEventToken_

double	minBSDeltaZ_

double	nrSigmaForBSDeltaZ_

double	originHalfLength_

double	originRadius_

bool	precise_

double	ptMin_

std::vector< edm::EDGetTokenT< std::vector< reco::SuperClusterRef > > >	superClustersTokens_

bool	useZInBeamspot_

bool	useZInVertex_

edm::EDGetTokenT< reco::VertexCollection >	verticesToken_

RectangularEtaPhiTrackingRegion::UseMeasurementTracker	whereToUseMeasTracker_

Detailed Description

Definition at line 87 of file TrackingRegionsFromSuperClustersProducer.h.

Member Enumeration Documentation

enum TrackingRegionsFromSuperClustersProducer::Charge

strong

Enumerator
NEG
POS

Definition at line 89 of file TrackingRegionsFromSuperClustersProducer.h.

89 { NEG = -1, POS = +1 };

Constructor & Destructor Documentation

TrackingRegionsFromSuperClustersProducer::TrackingRegionsFromSuperClustersProducer	(	const edm::ParameterSet &	cfg,
		edm::ConsumesCollector &&	cc
	)

Definition at line 149 of file TrackingRegionsFromSuperClustersProducer.h.

References AlignmentProducer_cff::beamSpotTag, beamSpotToken_, defaultZ_, deltaEtaRegion_, deltaPhiRegion_, edm::ParameterSet::getParameter(), RectangularEtaPhiTrackingRegion::kNever, measTrackerEventToken_, minBSDeltaZ_, nrSigmaForBSDeltaZ_, originHalfLength_, originRadius_, precise_, ptMin_, AlCaHLTBitMon_QueryRunRegistry::string, superClustersTokens_, GlobalPosition_Frontier_DevDB_cff::tag, useZInBeamspot_, useZInVertex_, validateConfigSettings(), verticesToken_, and whereToUseMeasTracker_.

                                                                                                               {
   edm::ParameterSet regionPSet = cfg.getParameter<edm::ParameterSet>("RegionPSet");
 
   ptMin_ = regionPSet.getParameter<double>("ptMin");
   originRadius_ = regionPSet.getParameter<double>("originRadius");
   originHalfLength_ = regionPSet.getParameter<double>("originHalfLength");
   deltaPhiRegion_ = regionPSet.getParameter<double>("deltaPhiRegion");
   deltaEtaRegion_ = regionPSet.getParameter<double>("deltaEtaRegion");
   useZInVertex_ = regionPSet.getParameter<bool>("useZInVertex");
   useZInBeamspot_ = regionPSet.getParameter<bool>("useZInBeamspot");
   nrSigmaForBSDeltaZ_ = regionPSet.getParameter<double>("nrSigmaForBSDeltaZ");
   defaultZ_ = regionPSet.getParameter<double>("defaultZ");
   minBSDeltaZ_ = regionPSet.getParameter<double>("minBSDeltaZ");
   precise_ = regionPSet.getParameter<bool>("precise");
   whereToUseMeasTracker_ = strToEnum<RectangularEtaPhiTrackingRegion::UseMeasurementTracker>(
       regionPSet.getParameter<std::string>("whereToUseMeasTracker"));
 
   validateConfigSettings();
 
   auto verticesTag = regionPSet.getParameter<edm::InputTag>("vertices");
   auto beamSpotTag = regionPSet.getParameter<edm::InputTag>("beamSpot");
   auto superClustersTags = regionPSet.getParameter<std::vector<edm::InputTag>>("superClusters");
   auto measTrackerEventTag = regionPSet.getParameter<edm::InputTag>("measurementTrackerEvent");
 
   if (useZInVertex_) {
     verticesToken_ = iC.consumes<reco::VertexCollection>(verticesTag);
   } else {
     beamSpotToken_ = iC.consumes<reco::BeamSpot>(beamSpotTag);
   }
   if (whereToUseMeasTracker_ != RectangularEtaPhiTrackingRegion::UseMeasurementTracker::kNever) {
     measTrackerEventToken_ = iC.consumes<MeasurementTrackerEvent>(measTrackerEventTag);
   }
   for (const auto& tag : superClustersTags) {
     superClustersTokens_.emplace_back(iC.consumes<std::vector<reco::SuperClusterRef>>(tag));
   }
 }

TrackingRegionsFromSuperClustersProducer::~TrackingRegionsFromSuperClustersProducer ( )

inlineoverride

Definition at line 94 of file TrackingRegionsFromSuperClustersProducer.h.

References ALCARECOTkAlJpsiMuMu_cff::charge, createTrackingRegion(), fillDescriptions(), getVtxPos(), iEvent, regions(), and validateConfigSettings().

94 {}

Member Function Documentation

std::unique_ptr< TrackingRegion > TrackingRegionsFromSuperClustersProducer::createTrackingRegion	(	const reco::SuperCluster &	superCluster,
		const GlobalPoint &	vtxPos,
		const double	deltaZVertex,
		const Charge	charge,
		const MeasurementTrackerEvent *	measTrackerEvent,
		const MagneticField &	magField
	)		const

private

Definition at line 281 of file TrackingRegionsFromSuperClustersProducer.h.

References deltaEtaRegion_, deltaPhiRegion_, HCALHighEnergyHPDFilter_cfi::energy, reco::CaloCluster::energy(), FTSFromVertexToPointFactory::get(), FreeTrajectoryState::momentum(), originRadius_, reco::CaloCluster::position(), precise_, ptMin_, and whereToUseMeasTracker_.

Referenced by regions(), and ~TrackingRegionsFromSuperClustersProducer().

                                          {
   const GlobalPoint clusterPos(superCluster.position().x(), superCluster.position().y(), superCluster.position().z());
   const double energy = superCluster.energy();
 
   FreeTrajectoryState freeTrajState =
       FTSFromVertexToPointFactory::get(magField, clusterPos, vtxPos, energy, static_cast<int>(charge));
   return std::make_unique<RectangularEtaPhiTrackingRegion>(freeTrajState.momentum(),
                                                            vtxPos,
                                                            ptMin_,
                                                            originRadius_,
                                                            deltaZVertex,
                                                            deltaEtaRegion_,
                                                            deltaPhiRegion_,
                                                            whereToUseMeasTracker_,
                                                            precise_,
                                                            measTrackerEvent);
 }

void TrackingRegionsFromSuperClustersProducer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 187 of file TrackingRegionsFromSuperClustersProducer.h.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), HLT_2018_cff::InputTag, edm::ParameterDescriptionNode::setComment(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by ~TrackingRegionsFromSuperClustersProducer().

                                                                                                           {
   edm::ParameterSetDescription desc;
 
   desc.add<double>("ptMin", 1.5);
   desc.add<double>("originRadius", 0.2);
   desc.add<double>("originHalfLength", 15.0)
       ->setComment("z range is +/- this value except when using the beamspot (useZInBeamspot=true)");
   desc.add<double>("deltaPhiRegion", 0.4);
   desc.add<double>("deltaEtaRegion", 0.1);
   desc.add<bool>("useZInVertex", false)
       ->setComment("use the leading vertex  position +/-orginHalfLength, mutually exclusive with useZInBeamspot");
   desc.add<bool>("useZInBeamspot", true)
       ->setComment(
           "use the beamspot  position +/- nrSigmaForBSDeltaZ* sigmaZ_{bs}, mutually exclusive with useZInVertex");
   desc.add<double>("nrSigmaForBSDeltaZ", 3.0)
       ->setComment("# of sigma to extend the z region when using the beamspot, only active if useZInBeamspot=true");
   desc.add<double>("minBSDeltaZ", 0.0)
       ->setComment("a minimum value of the beamspot sigma z to use, only active if useZInBeamspot=true");
   desc.add<double>("defaultZ", 0.)
       ->setComment("the default z position, only used if useZInVertex and useZInBeamspot are both false");
   desc.add<bool>("precise", true);
   desc.add<std::string>("whereToUseMeasTracker", "kNever");
   desc.add<edm::InputTag>("beamSpot", edm::InputTag("hltOnlineBeamSpot"))
       ->setComment("only used if useZInBeamspot is true");
   desc.add<edm::InputTag>("vertices", edm::InputTag())->setComment("only used if useZInVertex is true");
   desc.add<std::vector<edm::InputTag>>("superClusters",
                                        std::vector<edm::InputTag>{edm::InputTag{"hltEgammaSuperClustersToPixelMatch"}});
   desc.add<edm::InputTag>("measurementTrackerEvent", edm::InputTag());
 
   edm::ParameterSetDescription descRegion;
   descRegion.add<edm::ParameterSetDescription>("RegionPSet", desc);
 
   descriptions.add("trackingRegionsFromSuperClusters", descRegion);
 }

GlobalPoint TrackingRegionsFromSuperClustersProducer::getVtxPos	(	const edm::Event &	iEvent,
		double &	deltaZVertex
	)		const

private

Definition at line 249 of file TrackingRegionsFromSuperClustersProducer.h.

References beamSpotToken_, qcdUeDQM_cfi::bsPos, defaultZ_, SiStripPI::max, minBSDeltaZ_, nrSigmaForBSDeltaZ_, originHalfLength_, MetAnalyzer::pv(), fftjetvertexadder_cfi::sigmaZ, mathSSE::sqrt(), useZInBeamspot_, useZInVertex_, and verticesToken_.

Referenced by regions(), and ~TrackingRegionsFromSuperClustersProducer().

                                                                                                                   {
   if (useZInVertex_) {
     auto verticesHandle = getHandle(iEvent, verticesToken_);
     //we throw if the vertices are not there but if no vertex is
     //recoed in the event, we default to 0,0,defaultZ as the vertex
     if (!verticesHandle->empty()) {
       deltaZVertex = originHalfLength_;
       const auto& pv = verticesHandle->front();
       return GlobalPoint(pv.x(), pv.y(), pv.z());
     } else {
       deltaZVertex = originHalfLength_;
       return GlobalPoint(0, 0, defaultZ_);
     }
   } else {
     auto beamSpotHandle = getHandle(iEvent, beamSpotToken_);
     const reco::BeamSpot::Point& bsPos = beamSpotHandle->position();
 
     if (useZInBeamspot_) {
       //as this is what has been done traditionally for e/gamma, others just use sigmaZ
       const double bsSigmaZ = std::sqrt(beamSpotHandle->sigmaZ() * beamSpotHandle->sigmaZ() +
                                         beamSpotHandle->sigmaZ0Error() * beamSpotHandle->sigmaZ0Error());
       const double sigmaZ = std::max(bsSigmaZ, minBSDeltaZ_);
       deltaZVertex = nrSigmaForBSDeltaZ_ * sigmaZ;
 
       return GlobalPoint(bsPos.x(), bsPos.y(), bsPos.z());
     } else {
       deltaZVertex = originHalfLength_;
       return GlobalPoint(bsPos.x(), bsPos.y(), defaultZ_);
     }
   }
 }

std::vector< std::unique_ptr< TrackingRegion > > TrackingRegionsFromSuperClustersProducer::regions	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)		const

overridevirtual

Implements TrackingRegionProducer.

Definition at line 222 of file TrackingRegionsFromSuperClustersProducer.h.

References createTrackingRegion(), edm::EventSetup::get(), getVtxPos(), edm::EDGetTokenT< T >::isUninitialized(), measTrackerEventToken_, NEG, POS, superClustersTokens_, and hltSeeds_cff::trackingRegions.

Referenced by ~TrackingRegionsFromSuperClustersProducer().

                                                                {
   std::vector<std::unique_ptr<TrackingRegion>> trackingRegions;
 
   double deltaZVertex = 0;
   GlobalPoint vtxPos = getVtxPos(iEvent, deltaZVertex);
 
   const MeasurementTrackerEvent* measTrackerEvent = nullptr;
   if (!measTrackerEventToken_.isUninitialized()) {
     measTrackerEvent = getHandle(iEvent, measTrackerEventToken_).product();
   }
   edm::ESHandle<MagneticField> magFieldHandle;
   iSetup.get<IdealMagneticFieldRecord>().get(magFieldHandle);
 
   for (auto& superClustersToken : superClustersTokens_) {
     auto superClustersHandle = getHandle(iEvent, superClustersToken);
     for (auto& superClusterRef : *superClustersHandle) {
       //do both charge hypothesises
       trackingRegions.emplace_back(
           createTrackingRegion(*superClusterRef, vtxPos, deltaZVertex, Charge::POS, measTrackerEvent, *magFieldHandle));
       trackingRegions.emplace_back(
           createTrackingRegion(*superClusterRef, vtxPos, deltaZVertex, Charge::NEG, measTrackerEvent, *magFieldHandle));
     }
   }
   return trackingRegions;
 }

void TrackingRegionsFromSuperClustersProducer::validateConfigSettings ( ) const

private

Definition at line 305 of file TrackingRegionsFromSuperClustersProducer.h.

References Exception, useZInBeamspot_, and useZInVertex_.

Referenced by TrackingRegionsFromSuperClustersProducer(), and ~TrackingRegionsFromSuperClustersProducer().

                                                                             {
   if (useZInVertex_ && useZInBeamspot_) {
     throw cms::Exception("InvalidConfiguration")
         << " when constructing TrackingRegionsFromSuperClustersProducer both useZInVertex (" << useZInVertex_
         << ") and useZInBeamspot (" << useZInBeamspot_ << ") can not be true as they are mutually exclusive options"
         << std::endl;
   }
 }