#include <HIPixelClusterVtxProducer.h>

Inheritance diagram for HIPixelClusterVtxProducer:

Classes
struct	VertexHit

Public Member Functions
	HIPixelClusterVtxProducer (const edm::ParameterSet &ps)

	~HIPixelClusterVtxProducer () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Private Member Functions
int	getContainedHits (const std::vector< VertexHit > &hits, double z0, double &chi)

void	produce (edm::Event &ev, const edm::EventSetup &es) override

Private Attributes
double	maxZ_

double	minZ_

edm::EDGetTokenT< SiPixelRecHitCollection >	srcPixels_

std::string	srcPixelsString_

double	zStep_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Definition at line 17 of file HIPixelClusterVtxProducer.h.

Constructor & Destructor Documentation

◆ HIPixelClusterVtxProducer()

HIPixelClusterVtxProducer::HIPixelClusterVtxProducer ( const edm::ParameterSet & ps )

explicit

Definition at line 28 of file HIPixelClusterVtxProducer.cc.

     : srcPixelsString_(ps.getParameter<std::string>("pixelRecHits")),
       minZ_(ps.getParameter<double>("minZ")),
       maxZ_(ps.getParameter<double>("maxZ")),
       zStep_(ps.getParameter<double>("zStep"))
  
 {
   // Constructor
   produces<reco::VertexCollection>();
   srcPixels_ = (consumes<SiPixelRecHitCollection>(srcPixelsString_));
 }

References srcPixels_, and srcPixelsString_.

◆ ~HIPixelClusterVtxProducer()

HIPixelClusterVtxProducer::~HIPixelClusterVtxProducer ( )

override

Definition at line 41 of file HIPixelClusterVtxProducer.cc.

                                                       {
   // Destructor
 }

Member Function Documentation

◆ getContainedHits()

int HIPixelClusterVtxProducer::getContainedHits	(	const std::vector< VertexHit > &	hits,
		double	z0,
		double &	chi
	)

private

Definition at line 130 of file HIPixelClusterVtxProducer.cc.

                                                                                                         {
   // Calculate number of hits contained in v-shaped window in cluster y-width vs. z-position.
   int n = 0;
   chi = 0.;
  
   for (std::vector<VertexHit>::const_iterator hit = hits.begin(); hit != hits.end(); hit++) {
     double p = 2 * fabs(hit->z - z0) / hit->r + 0.5;  // FIXME
     if (TMath::Abs(p - hit->w) <= 1.) {
       chi += fabs(p - hit->w);
       n++;
     }
   }
   return n;
 }

References Abs(), hfClusterShapes_cfi::hits, dqmiodumpmetadata::n, AlCaHLTBitMon_ParallelJobs::p, hit::z, and HLTMuonOfflineAnalyzer_cfi::z0.

Referenced by produce().

◆ produce()

void HIPixelClusterVtxProducer::produce	(	edm::Event &	ev,
		const edm::EventSetup &	es
	)

overrideprivate

Definition at line 46 of file HIPixelClusterVtxProducer.cc.

                                                                              {
   // new vertex collection
   auto vertices = std::make_unique<reco::VertexCollection>();
  
   // get pixel rechits
   edm::Handle<SiPixelRecHitCollection> hRecHits;
   ev.getByToken(srcPixels_, hRecHits);
  
   // get tracker geometry
   if (hRecHits.isValid()) {
     edm::ESHandle<TrackerGeometry> trackerHandle;
     es.get<TrackerDigiGeometryRecord>().get(trackerHandle);
     const TrackerGeometry *tgeo = trackerHandle.product();
     const SiPixelRecHitCollection *hits = hRecHits.product();
  
     // loop over pixel rechits
     std::vector<VertexHit> vhits;
     for (SiPixelRecHitCollection::DataContainer::const_iterator hit = hits->data().begin(), end = hits->data().end();
          hit != end;
          ++hit) {
       if (!hit->isValid())
         continue;
       DetId id(hit->geographicalId());
       if (id.subdetId() != int(PixelSubdetector::PixelBarrel))
         continue;
       const PixelGeomDetUnit *pgdu = static_cast<const PixelGeomDetUnit *>(tgeo->idToDet(id));
       if (true) {
         const PixelTopology *pixTopo = &(pgdu->specificTopology());
         std::vector<SiPixelCluster::Pixel> pixels(hit->cluster()->pixels());
         bool pixelOnEdge = false;
         for (std::vector<SiPixelCluster::Pixel>::const_iterator pixel = pixels.begin(); pixel != pixels.end();
              ++pixel) {
           int pixelX = pixel->x;
           int pixelY = pixel->y;
           if (pixTopo->isItEdgePixelInX(pixelX) || pixTopo->isItEdgePixelInY(pixelY)) {
             pixelOnEdge = true;
             break;
           }
         }
         if (pixelOnEdge)
           continue;
       }
  
       LocalPoint lpos = LocalPoint(hit->localPosition().x(), hit->localPosition().y(), hit->localPosition().z());
       GlobalPoint gpos = pgdu->toGlobal(lpos);
       VertexHit vh;
       vh.z = gpos.z();
       vh.r = gpos.perp();
       vh.w = hit->cluster()->sizeY();
       vhits.push_back(vh);
     }
  
     // estimate z-position from cluster lengths
     double zest = 0.0;
     int nhits = 0, nhits_max = 0;
     double chi = 0, chi_max = 1e+9;
     for (double z0 = minZ_; z0 <= maxZ_; z0 += zStep_) {
       nhits = getContainedHits(vhits, z0, chi);
       if (nhits == 0)
         continue;
       if (nhits > nhits_max) {
         chi_max = 1e+9;
         nhits_max = nhits;
       }
       if (nhits >= nhits_max && chi < chi_max) {
         chi_max = chi;
         zest = z0;
       }
     }
  
     LogTrace("MinBiasTracking") << "  [vertex position] estimated = " << zest
                                 << " | pixel barrel hits = " << vhits.size();
  
     // put 1-d vertex and dummy errors into collection
     reco::Vertex::Error err;
     err(2, 2) = 0.6 * 0.6;
     reco::Vertex ver(reco::Vertex::Point(0, 0, zest), err, 0, 1, 1);
     vertices->push_back(ver);
   }
  
   ev.put(std::move(vertices));
 }