#include <TrackingRegionsFromSuperClustersProducer.h>

Inheritance diagram for TrackingRegionsFromSuperClustersProducer:

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

Public Member Functions
virtual 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)

virtual	~TrackingRegionsFromSuperClustersProducer ()

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

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

double	deltaEtaRegion_

double	deltaPhiRegion_

edm::EDGetTokenT< MeasurementTrackerEvent >	measTrackerEventToken_

double	originHalfLength_

double	originRadius_

bool	precise_

double	ptMin_

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

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

References AlignmentProducer_cff::beamSpotTag, beamSpotToken_, deltaEtaRegion_, deltaPhiRegion_, fillDescriptions(), edm::ParameterSet::getParameter(), RectangularEtaPhiTrackingRegion::kNever, measTrackerEventToken_, originHalfLength_, originRadius_, precise_, ptMin_, AlCaHLTBitMon_QueryRunRegistry::string, superClustersTokens_, GlobalPosition_Frontier_DevDB_cff::tag, useZInVertex_, 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");
   precise_               = regionPSet.getParameter<bool>("precise");
   whereToUseMeasTracker_ = strToEnum<RectangularEtaPhiTrackingRegion::UseMeasurementTracker>(regionPSet.getParameter<std::string>("whereToUseMeasTracker"));
   
   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));
   }
 }   

virtual TrackingRegionsFromSuperClustersProducer::~TrackingRegionsFromSuperClustersProducer ( )

inlinevirtual

Definition at line 92 of file TrackingRegionsFromSuperClustersProducer.h.

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

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

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), regions(), 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);
   desc.add<double>("deltaPhiRegion",0.4);
   desc.add<double>("deltaEtaRegion",0.1);
   desc.add<bool>("useZInVertex", false);
   desc.add<bool>("precise", true);
   desc.add<std::string>("whereToUseMeasTracker","kNever");
   desc.add<edm::InputTag>("beamSpot", edm::InputTag("hltOnlineBeamSpot"));
   desc.add<edm::InputTag>("vertices", edm::InputTag());
   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 227 of file TrackingRegionsFromSuperClustersProducer.h.

References beamSpotToken_, createTrackingRegion(), originHalfLength_, MetAnalyzer::pv(), fftjetvertexadder_cfi::sigmaZ, mathSSE::sqrt(), useZInVertex_, and verticesToken_.

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

 {
   if(useZInVertex_){
     auto verticesHandle = getHandle(iEvent,verticesToken_);   
     if(!verticesHandle->empty()){
       deltaZVertex = originHalfLength_;
       const auto& pv = verticesHandle->front();
       return GlobalPoint(pv.x(),pv.y(),pv.z());
     }
   }
   
   //if the vertex collection is empty or we dont want to use the z in the vertex 
   //we fall back to beamspot mode
   auto beamSpotHandle = getHandle(iEvent,beamSpotToken_);
   const reco::BeamSpot::Point& bsPos = beamSpotHandle->position();
   //SH: this is what SeedFilter did, no idea what its trying to achieve....
   const double sigmaZ = beamSpotHandle->sigmaZ();
   const double sigmaZ0Error = beamSpotHandle->sigmaZ0Error();
   deltaZVertex = 3*std::sqrt(sigmaZ*sigmaZ+sigmaZ0Error*sigmaZ0Error);
   //  std::cout <<"z "<<bsPos.z()<<" deltaZ "<<deltaZVertex<<std::endl;
   //deltaZVertex = 30.;
   return GlobalPoint(bsPos.x(),bsPos.y(),bsPos.z());
   //return GlobalPoint(bsPos.x(),bsPos.y(),0);
 }

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

overridevirtual

Implements TrackingRegionProducer.

Definition at line 201 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;
 }