#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)

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

virtual	~HITrackingRegionForPrimaryVtxProducer ()

Public Member Functions inherited from TrackingRegionProducer
virtual	~TrackingRegionProducer ()

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

Constructor & Destructor Documentation

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

inline

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

virtual HITrackingRegionForPrimaryVtxProducer::~HITrackingRegionForPrimaryVtxProducer ( )

inlinevirtual

Definition at line 57 of file HITrackingRegionForPrimaryVtxProducer.h.

57 {}

Member Function Documentation

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

inline

Definition at line 60 of file HITrackingRegionForPrimaryVtxProducer.h.

References edmNew::copyDetSetRange(), edm::Event::getByToken(), TrackerLayerIdAccessor::pixelBarrelLayer(), and theSiPixelRecHitsToken.

Referenced by regions().

     {
       //rechits
       edm::Handle<SiPixelRecHitCollection> recHitColl;
       ev.getByToken(theSiPixelRecHitsToken, recHitColl);
       
       std::vector<const TrackingRecHit*> theChosenHits;      
       TrackerLayerIdAccessor acc;    
       edmNew::copyDetSetRange(*recHitColl,theChosenHits,acc.pixelBarrelLayer(1));    
       return theChosenHits.size();   
       
     }

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

inlinevirtual

Implements TrackingRegionProducer.

Definition at line 73 of file HITrackingRegionForPrimaryVtxProducer.h.

References doVariablePtMin, estimateMultiplicity(), edm::Event::getByToken(), edm::HandleBase::isValid(), LogTrace, Pi, query::result, reco::BeamSpot::sigmaZ(), theBeamSpotToken, theDirection, theFixedError, theNSigmaZ, theOriginRadius, thePrecise, thePtMin, theSigmaZVertex, theUseFixedError, theUseFoundVertices, GoodVertex_cfg::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<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( 
       new RectangularEtaPhiTrackingRegion(theDirection, origin, thePtMin, theOriginRadius, halflength, etaB, phiB, RectangularEtaPhiTrackingRegion::UseMeasurementTracker::kNever, thePrecise) );
       }
       else {                       // global tracking
         LogTrace("heavyIonHLTVertexing")<<" [HIVertexing: Global Tracking]";
         result.push_back( 
       new GlobalTrackingRegion(minpt, origin, theOriginRadius, halflength, thePrecise) );
       }
     } 
     return result;
   }