#include <GlobalTrackingRegionWithVerticesProducer.h>

Inheritance diagram for GlobalTrackingRegionWithVerticesProducer:

Public Member Functions
	GlobalTrackingRegionWithVerticesProducer (const edm::ParameterSet &cfg, edm::ConsumesCollector &&iC)

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

virtual	~GlobalTrackingRegionWithVerticesProducer ()

Public Member Functions inherited from TrackingRegionProducer
virtual	~TrackingRegionProducer ()

Private Attributes
edm::InputTag	theBeamSpotTag

double	theFixedError

double	theNSigmaZ

double	theOriginRadius

bool	thePrecise

double	thePtMin

double	theSigmaZVertex

bool	theUseFakeVertices

bool	theUseFixedError

bool	theUseFoundVertices

bool	theUseMS

edm::EDGetTokenT< reco::BeamSpot >	token_beamSpot

edm::EDGetTokenT < reco::VertexCollection >	token_vertex

Detailed Description

Definition at line 15 of file GlobalTrackingRegionWithVerticesProducer.h.

Constructor & Destructor Documentation

GlobalTrackingRegionWithVerticesProducer::GlobalTrackingRegionWithVerticesProducer	(	const edm::ParameterSet &	cfg,
		edm::ConsumesCollector &&	iC
	)

inline

Definition at line 19 of file GlobalTrackingRegionWithVerticesProducer.h.

References edm::ParameterSet::getParameter(), theFixedError, theNSigmaZ, theOriginRadius, thePrecise, thePtMin, theSigmaZVertex, theUseFakeVertices, theUseFixedError, theUseFoundVertices, theUseMS, token_beamSpot, and token_vertex.

   { 
     edm::ParameterSet regionPSet = cfg.getParameter<edm::ParameterSet>("RegionPSet");
 
     thePtMin            = regionPSet.getParameter<double>("ptMin");
     theOriginRadius     = regionPSet.getParameter<double>("originRadius");
     theNSigmaZ          = regionPSet.getParameter<double>("nSigmaZ");
     token_beamSpot      = iC.consumes<reco::BeamSpot>(regionPSet.getParameter<edm::InputTag>("beamSpot"));
     thePrecise          = regionPSet.getParameter<bool>("precise"); 
     theUseMS            = regionPSet.getParameter<bool>("useMultipleScattering");
 
     theSigmaZVertex     = regionPSet.getParameter<double>("sigmaZVertex");
     theFixedError       = regionPSet.getParameter<double>("fixedError");
 
     theUseFoundVertices = regionPSet.getParameter<bool>("useFoundVertices");
     theUseFakeVertices  = regionPSet.getParameter<bool>("useFakeVertices");
     theUseFixedError    = regionPSet.getParameter<bool>("useFixedError");
     token_vertex      = iC.consumes<reco::VertexCollection>(regionPSet.getParameter<edm::InputTag>("VertexCollection"));
   }   

virtual GlobalTrackingRegionWithVerticesProducer::~GlobalTrackingRegionWithVerticesProducer ( )

inlinevirtual

Definition at line 40 of file GlobalTrackingRegionWithVerticesProducer.h.

40 {}

Member Function Documentation

virtual std::vector<std::unique_ptr<TrackingRegion> > GlobalTrackingRegionWithVerticesProducer::regions	(	const edm::Event &	ev,
		const edm::EventSetup &
	)		const

inlineoverridevirtual

Implements TrackingRegionProducer.

Definition at line 43 of file GlobalTrackingRegionWithVerticesProducer.h.

References Exception, edm::Event::getByToken(), edm::HandleBase::isValid(), mps_fire::result, reco::BeamSpot::sigmaZ(), theFixedError, theNSigmaZ, theOriginRadius, thePrecise, thePtMin, theSigmaZVertex, theUseFakeVertices, theUseFixedError, theUseFoundVertices, theUseMS, token_beamSpot, token_vertex, GoodVertex_cfg::vertexCollection, reco::BeamSpot::x0(), reco::BeamSpot::y0(), and reco::BeamSpot::z0().

   {
     std::vector<std::unique_ptr<TrackingRegion> > result;
 
     GlobalPoint theOrigin;
     edm::Handle<reco::BeamSpot> bsHandle;
     ev.getByToken( token_beamSpot, bsHandle);
     double bsSigmaZ;
     if(bsHandle.isValid()) {
       const reco::BeamSpot & bs = *bsHandle; 
       bsSigmaZ = theNSigmaZ*bs.sigmaZ();
       theOrigin = GlobalPoint(bs.x0(), bs.y0(), bs.z0());
     }else{
       throw cms::Exception("Seeding") << "ERROR: input beamSpot is not valid in GlobalTrackingRegionWithVertices";
     }
 
     if(theUseFoundVertices)
     {
       edm::Handle<reco::VertexCollection> vertexCollection;
       ev.getByToken(token_vertex,vertexCollection);
 
       for(reco::VertexCollection::const_iterator iV=vertexCollection->begin(); iV != vertexCollection->end() ; iV++) {
           if (!iV->isValid()) continue;
           if (iV->isFake() && !(theUseFakeVertices && theUseFixedError)) continue;
       GlobalPoint theOrigin_       = GlobalPoint(iV->x(),iV->y(),iV->z());
       double theOriginHalfLength_ = (theUseFixedError ? theFixedError : (iV->zError())*theSigmaZVertex); 
       result.push_back( std::make_unique<GlobalTrackingRegion>(thePtMin, theOrigin_, theOriginRadius, theOriginHalfLength_, thePrecise, theUseMS) );
       }
       
       if (result.empty()) {
         result.push_back( std::make_unique<GlobalTrackingRegion>(thePtMin, theOrigin, theOriginRadius, bsSigmaZ, thePrecise, theUseMS) );
       }
     }
     else
     {
       result.push_back(
         std::make_unique<GlobalTrackingRegion>(thePtMin, theOrigin, theOriginRadius, bsSigmaZ, thePrecise, theUseMS) );
     }
 
     return result;
   }