#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 80 of file TrackingRegionsFromSuperClustersProducer.h.

Member Enumeration Documentation

enum TrackingRegionsFromSuperClustersProducer::Charge

strong

Enumerator
NEG
POS

Definition at line 83 of file TrackingRegionsFromSuperClustersProducer.h.

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

Constructor & Destructor Documentation

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

Definition at line 151 of file TrackingRegionsFromSuperClustersProducer.h.

References AlignmentProducer_cff::beamSpotTag, beamSpotToken_, defaultZ_, deltaEtaRegion_, deltaPhiRegion_, fillDescriptions(), 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 92 of file TrackingRegionsFromSuperClustersProducer.h.

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

92 {}

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 286 of file TrackingRegionsFromSuperClustersProducer.h.

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

Referenced by getVtxPos(), 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 192 of file TrackingRegionsFromSuperClustersProducer.h.

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

Referenced by TrackingRegionsFromSuperClustersProducer(), and ~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_, createTrackingRegion(), 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 223 of file TrackingRegionsFromSuperClustersProducer.h.

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

Referenced by fillDescriptions(), and ~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 307 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;
   }
 }