#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 29 of file HITrackingRegionForPrimaryVtxProducer.h.

Constructor & Destructor Documentation

◆ HITrackingRegionForPrimaryVtxProducer()

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

inline

Definition at line 31 of file HITrackingRegionForPrimaryVtxProducer.h.

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

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

◆ ~HITrackingRegionForPrimaryVtxProducer()

HITrackingRegionForPrimaryVtxProducer::~HITrackingRegionForPrimaryVtxProducer ( )

inlineoverride

Definition at line 56 of file HITrackingRegionForPrimaryVtxProducer.h.

56 {}

Member Function Documentation

◆ estimateMultiplicity()

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

inline

Definition at line 86 of file HITrackingRegionForPrimaryVtxProducer.h.

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

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

Referenced by regions().

◆ fillDescriptions()

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

inlinestatic

Definition at line 58 of file HITrackingRegionForPrimaryVtxProducer.h.

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

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

◆ regions()

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

inlineoverridevirtual

Implements TrackingRegionProducer.

Definition at line 99 of file HITrackingRegionForPrimaryVtxProducer.h.

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