#include <HITrackingRegionForPrimaryVtxProducer.h>

Inheritance diagram for HITrackingRegionForPrimaryVtxProducer:

Public Member Functions
int	estimateMultiplicity (const edm::Event &ev, const edm::EventSetup &es) const

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

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

	~HITrackingRegionForPrimaryVtxProducer () override

Public Member Functions inherited from TrackingRegionProducer
virtual	~TrackingRegionProducer ()

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

Private Attributes
bool	doVariablePtMin

edm::InputTag	theBeamSpotTag

edm::EDGetTokenT< reco::BeamSpot >	theBeamSpotToken

GlobalVector	theDirection

double	theFixedError

double	theNSigmaZ

double	theOriginRadius

bool	thePrecise

double	thePtMin

double	theSigmaZVertex

edm::InputTag	theSiPixelRecHits

edm::EDGetTokenT< SiPixelRecHitCollection >	theSiPixelRecHitsToken

bool	theUseFixedError

bool	theUseFoundVertices

edm::InputTag	vertexCollName

edm::EDGetTokenT< reco::VertexCollection >	vertexCollToken

Detailed Description

Definition at line 28 of file HITrackingRegionForPrimaryVtxProducer.h.

Constructor & Destructor Documentation

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

inline

Definition at line 32 of file HITrackingRegionForPrimaryVtxProducer.h.

References doVariablePtMin, edm::ParameterSet::getParameter(), theBeamSpotTag, theBeamSpotToken, theDirection, theFixedError, theNSigmaZ, theOriginRadius, thePrecise, thePtMin, theSigmaZVertex, theSiPixelRecHits, theSiPixelRecHitsToken, theUseFixedError, theUseFoundVertices, vertexCollName, and vertexCollToken.

                                                                                                 { 
     
     edm::ParameterSet regionPSet = cfg.getParameter<edm::ParameterSet>("RegionPSet");
     thePtMin            = regionPSet.getParameter<double>("ptMin");
     theOriginRadius     = regionPSet.getParameter<double>("originRadius");
     theNSigmaZ          = regionPSet.getParameter<double>("nSigmaZ");
     theBeamSpotTag      = regionPSet.getParameter<edm::InputTag>("beamSpot");
     theBeamSpotToken    = iC.consumes<reco::BeamSpot>(theBeamSpotTag); 
     thePrecise          = regionPSet.getParameter<bool>("precise"); 
     theSiPixelRecHits   = regionPSet.getParameter<edm::InputTag>("siPixelRecHits");
     theSiPixelRecHitsToken = iC.consumes<SiPixelRecHitCollection> (theSiPixelRecHits);     
     doVariablePtMin     = regionPSet.getParameter<bool>("doVariablePtMin"); 
     double xDir         = regionPSet.getParameter<double>("directionXCoord");
     double yDir         = regionPSet.getParameter<double>("directionYCoord");
     double zDir         = regionPSet.getParameter<double>("directionZCoord");
     theDirection = GlobalVector(xDir, yDir, zDir);
 
     // for using vertex instead of beamspot
     theSigmaZVertex     = regionPSet.getParameter<double>("sigmaZVertex");
     theFixedError       = regionPSet.getParameter<double>("fixedError");
     theUseFoundVertices = regionPSet.getParameter<bool>("useFoundVertices");
     theUseFixedError    = regionPSet.getParameter<bool>("useFixedError");
     vertexCollName      = regionPSet.getParameter<edm::InputTag>("VertexCollection");
     vertexCollToken     = iC.consumes<reco::VertexCollection>(vertexCollName);
   }   

HITrackingRegionForPrimaryVtxProducer::~HITrackingRegionForPrimaryVtxProducer ( )

inlineoverride

Definition at line 58 of file HITrackingRegionForPrimaryVtxProducer.h.

58 {}

Member Function Documentation

int HITrackingRegionForPrimaryVtxProducer::estimateMultiplicity	(	const edm::Event &	ev,
		const edm::EventSetup &	es
	)		const

inline

Definition at line 89 of file HITrackingRegionForPrimaryVtxProducer.h.

References edmNew::copyDetSetRange(), edm::EventSetup::get(), edm::Event::getByToken(), TrackerTopology::pxbDetIdLayerComparator(), and theSiPixelRecHitsToken.

Referenced by fillDescriptions(), and regions().

     {
       //rechits
       edm::Handle<SiPixelRecHitCollection> recHitColl;
       ev.getByToken(theSiPixelRecHitsToken, recHitColl);
 
       edm::ESHandle<TrackerTopology> httopo;
       es.get<TrackerTopologyRcd>().get(httopo);
       
       std::vector<const TrackingRecHit*> theChosenHits;      
       edmNew::copyDetSetRange(*recHitColl,theChosenHits, httopo->pxbDetIdLayerComparator(1));
       return theChosenHits.size();   
       
     }

static void HITrackingRegionForPrimaryVtxProducer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

inlinestatic

Definition at line 60 of file HITrackingRegionForPrimaryVtxProducer.h.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), and estimateMultiplicity().

                                                                            {
     edm::ParameterSetDescription desc;
 
     desc.add<double>("ptMin", 0.7);
     desc.add<bool>("doVariablePtMin", true);
     desc.add<double>("originRadius", 0.2);
     desc.add<double>("nSigmaZ", 3.0);
     desc.add<edm::InputTag>("beamSpot", edm::InputTag("offlineBeamSpot"));
     desc.add<bool>("precise", true);
     desc.add<bool>("useMultipleScattering", false);
     desc.add<bool>("useFakeVertices", false);
     desc.add<edm::InputTag>("siPixelRecHits", edm::InputTag("siPixelRecHits"));
     desc.add<double>("directionXCoord", 1.0);
     desc.add<double>("directionYCoord", 1.0);
     desc.add<double>("directionZCoord", 0.0);
     desc.add<bool>("useFoundVertices", true);
     desc.add<edm::InputTag>("VertexCollection", edm::InputTag("hiPixelClusterVertex"));
     desc.add<bool>("useFixedError", true);
     desc.add<double>("fixedError", 3.0);
     desc.add<double>("sigmaZVertex", 3.0);
 
     // Only for backwards-compatibility
     edm::ParameterSetDescription descRegion;
     descRegion.add<edm::ParameterSetDescription>("RegionPSet", desc);
 
     descriptions.add("hiTrackingRegionFromClusterVtx", descRegion);
   }

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

inlineoverridevirtual

Implements TrackingRegionProducer.

Definition at line 104 of file HITrackingRegionForPrimaryVtxProducer.h.

References doVariablePtMin, estimateMultiplicity(), edm::Event::getByToken(), edm::HandleBase::isValid(), RectangularEtaPhiTrackingRegion::kNever, LogTrace, HiEvtPlane_cfi::minpt, Pi, mps_fire::result, reco::BeamSpot::sigmaZ(), theBeamSpotToken, theDirection, theFixedError, theNSigmaZ, theOriginRadius, thePrecise, thePtMin, theSigmaZVertex, theUseFixedError, theUseFoundVertices, particleFlowSuperClusterECAL_cfi::vertexCollection, vertexCollToken, reco::BeamSpot::x0(), reco::BeamSpot::y0(), and reco::BeamSpot::z0().

                                                                                                                 {
     
     int estMult = estimateMultiplicity(ev, es);
     
     // from MC relating first layer pixel hits to "findable" sim tracks with pt>1 GeV
     float cc = -38.6447;
     float bb = 0.0581765;
     float aa = 1.34306e-06;
 
     float estTracks = aa*estMult*estMult+bb*estMult+cc;
     
     LogTrace("heavyIonHLTVertexing")<<"[HIVertexing]";
     LogTrace("heavyIonHLTVertexing")<<" [HIVertexing: hits in the 1. layer:" << estMult << "]";
     LogTrace("heavyIonHLTVertexing")<<" [HIVertexing: estimated number of tracks:" << estTracks << "]";
     
     float regTracking = 60.;  //if we have more tracks -> regional tracking
     float etaB = 10.;
     float phiB = TMath::Pi()/2.;
     
     float decEta = estTracks/90.;
     etaB = 2.5/decEta;
     
     if(estTracks>regTracking) {
       LogTrace("heavyIonHLTVertexing")<<" [HIVertexing: Regional Tracking]";
       LogTrace("heavyIonHLTVertexing")<<"  [Regional Tracking: eta range: -" << etaB << ", "<< etaB <<"]";
       LogTrace("heavyIonHLTVertexing")<<"  [Regional Tracking: phi range: -" << phiB << ", "<< phiB <<"]";
       LogTrace("heavyIonHLTVertexing")<<"  [Regional Tracking: factor of decrease: " << decEta*2. << "]";  // 2:from phi
     }
     
     float minpt = thePtMin;
     float varPtCutoff = 1500; //cutoff
     if(doVariablePtMin && estMult < varPtCutoff) {
       minpt = 0.075;
       if(estMult > 0) minpt += estMult * (thePtMin - 0.075)/varPtCutoff; // lower ptMin linearly with pixel hit multiplicity
     }
     
     // tracking region selection
     std::vector<std::unique_ptr<TrackingRegion> > result;
     double halflength;
     GlobalPoint origin;
     edm::Handle<reco::BeamSpot> bsHandle;
     ev.getByToken(theBeamSpotToken, bsHandle);
     if(bsHandle.isValid()) {
       const reco::BeamSpot & bs = *bsHandle; 
       origin=GlobalPoint(bs.x0(), bs.y0(), bs.z0()); 
       halflength=theNSigmaZ*bs.sigmaZ();
       
     if(theUseFoundVertices)
     {
       edm::Handle<reco::VertexCollection> vertexCollection;
       ev.getByToken(vertexCollToken,vertexCollection);
 
       for(reco::VertexCollection::const_iterator iV=vertexCollection->begin(); 
       iV != vertexCollection->end() ; iV++) {
           if (iV->isFake() || !iV->isValid()) continue;
       origin     = GlobalPoint(bs.x0(),bs.y0(),iV->z());
       halflength = (theUseFixedError ? theFixedError : (iV->zError())*theSigmaZVertex); 
       }
     }
 
       if(estTracks>regTracking) {  // regional tracking
         result.push_back( 
           std::make_unique<RectangularEtaPhiTrackingRegion>(theDirection, origin, thePtMin, theOriginRadius, halflength, etaB, phiB, RectangularEtaPhiTrackingRegion::UseMeasurementTracker::kNever, thePrecise) );
       }
       else {                       // global tracking
         LogTrace("heavyIonHLTVertexing")<<" [HIVertexing: Global Tracking]";
         result.push_back( 
           std::make_unique<GlobalTrackingRegion>(minpt, origin, theOriginRadius, halflength, thePrecise) );
       }
     } 
     return result;
   }