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_

const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	magFieldToken_

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 84 of file TrackingRegionsFromSuperClustersProducer.cc.

Member Enumeration Documentation

◆ Charge

enum TrackingRegionsFromSuperClustersProducer::Charge

strong

Enumerator
NEG
POS

Definition at line 86 of file TrackingRegionsFromSuperClustersProducer.cc.

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

Constructor & Destructor Documentation

◆ TrackingRegionsFromSuperClustersProducer()

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

Definition at line 148 of file TrackingRegionsFromSuperClustersProducer.cc.

     : magFieldToken_{iC.esConsumes()} {
   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(verticesTag);
   } else {
     beamSpotToken_ = iC.consumes(beamSpotTag);
   }
   if (whereToUseMeasTracker_ != RectangularEtaPhiTrackingRegion::UseMeasurementTracker::kNever) {
     measTrackerEventToken_ = iC.consumes(measTrackerEventTag);
   }
   for (const auto& tag : superClustersTags) {
     superClustersTokens_.emplace_back(iC.consumes(tag));
   }
 }

◆ ~TrackingRegionsFromSuperClustersProducer()

TrackingRegionsFromSuperClustersProducer::~TrackingRegionsFromSuperClustersProducer ( )

inlineoverride

Definition at line 91 of file TrackingRegionsFromSuperClustersProducer.cc.

91 {}

Member Function Documentation

◆ createTrackingRegion()

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 280 of file TrackingRegionsFromSuperClustersProducer.cc.

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

References ALCARECOTkAlJpsiMuMu_cff::charge, deltaEtaRegion_, deltaPhiRegion_, HCALHighEnergyHPDFilter_cfi::energy, reco::CaloCluster::energy(), trackingTools::ftsFromVertexToPoint(), originRadius_, reco::CaloCluster::position(), precise_, ptMin_, and whereToUseMeasTracker_.

Referenced by regions().

◆ fillDescriptions()

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

static

Definition at line 187 of file TrackingRegionsFromSuperClustersProducer.cc.

                                                                                                           {
   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);
 }

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

◆ getVtxPos()

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

private

Definition at line 248 of file TrackingRegionsFromSuperClustersProducer.cc.

                                                                                                                   {
   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_);
     }
   }
 }

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

Referenced by regions().

◆ regions()

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

                                                                {
   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();
   }
   auto const& magField = iSetup.getData(magFieldToken_);
  
   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, magField));
       trackingRegions.emplace_back(
           createTrackingRegion(*superClusterRef, vtxPos, deltaZVertex, Charge::NEG, measTrackerEvent, magField));
     }
   }
   return trackingRegions;
 }

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

◆ validateConfigSettings()

void TrackingRegionsFromSuperClustersProducer::validateConfigSettings ( ) const

private

Definition at line 303 of file TrackingRegionsFromSuperClustersProducer.cc.

                                                                             {
   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;
   }
 }