#include <PixelUnpackingRegions.h>

Classes
struct	Module

struct	Region

Public Member Functions
bool	mayUnpackFED (unsigned int fed_n) const
	check whether a FED has to be unpacked More...

bool	mayUnpackModule (unsigned int id) const
	check whether a module has to be unpacked More...

const std::set< unsigned int > *	modulesToUnpack () const
	full set of module ids to unpack More...

unsigned int	nBarrelModules () const

unsigned int	nFEDs () const
	various informational accessors: More...

unsigned int	nForwardModules () const

unsigned int	nModules () const

unsigned int	nRegions () const

	PixelUnpackingRegions (const edm::ParameterSet &, edm::ConsumesCollector &&iC)

void	run (const edm::Event &e, const edm::EventSetup &es)
	has to be run during each event More...

	~PixelUnpackingRegions ()

Private Member Functions
void	addRegion (Region &r)

void	addRegionLocal (Region &r, std::vector< Module > &container, const Module &lo, const Module &hi)

void	gatherFromRange (Region &r, std::vector< Module >::const_iterator, std::vector< Module >::const_iterator)

void	initialize (const edm::EventSetup &es)
	run by the run method: (re)initialize the cabling data when it's necessary More...

Private Attributes
math::XYZPoint	beamSpot_

edm::InputTag	beamSpotTag_

std::unique_ptr< SiPixelFedCablingTree >	cabling_

edm::ESGetToken< SiPixelFedCablingMap, SiPixelFedCablingMapRcd >	cablingMapToken_

std::vector< double >	dPhi_

std::set< unsigned int >	feds_

std::vector< edm::InputTag >	inputs_

std::vector< double >	maxZ_

std::set< unsigned int >	modules_

unsigned int	nreg_

std::vector< Module >	phiBPIX_

std::vector< Module >	phiFPIXm_

std::vector< Module >	phiFPIXp_

edm::EDGetTokenT< reco::BeamSpot >	tBeamSpot

std::vector< edm::EDGetTokenT< reco::CandidateView > >	tCandidateView

edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord >	trackerGeomToken_

edm::ESWatcher< SiPixelFedCablingMapRcd >	watcherSiPixelFedCablingMap_

Detailed Description

Input: One or several collections of Candidate-based seeds with their objects defining the directions of unpacking regions; separate deltaPhi and maxZ tolerances could be given to each input collection. Output: FED ids and module detIds that need to be unpacked

Definition at line 32 of file PixelUnpackingRegions.h.

Constructor & Destructor Documentation

◆ PixelUnpackingRegions()

PixelUnpackingRegions::PixelUnpackingRegions	(	const edm::ParameterSet &	conf,
		edm::ConsumesCollector &&	iC
	)

Definition at line 28 of file PixelUnpackingRegions.cc.

                                                                                                    {
   edm::ParameterSet regPSet = conf.getParameter<edm::ParameterSet>("Regions");
   beamSpotTag_ = regPSet.getParameter<edm::InputTag>("beamSpot");
   inputs_ = regPSet.getParameter<std::vector<edm::InputTag> >("inputs");
   dPhi_ = regPSet.getParameter<std::vector<double> >("deltaPhi");
   maxZ_ = regPSet.getParameter<std::vector<double> >("maxZ");
   trackerGeomToken_ = iC.esConsumes<TrackerGeometry, TrackerDigiGeometryRecord>();
   cablingMapToken_ = iC.esConsumes<SiPixelFedCablingMap, SiPixelFedCablingMapRcd>();
  
   tBeamSpot = iC.consumes<reco::BeamSpot>(beamSpotTag_);
   for (unsigned int t = 0; t < inputs_.size(); t++)
     tCandidateView.push_back(iC.consumes<reco::CandidateView>(inputs_[t]));
  
   if (inputs_.size() != dPhi_.size() || dPhi_.size() != maxZ_.size()) {
     edm::LogError("PixelUnpackingRegions")
         << "Not the same size of config parameters vectors!\n"
         << "   inputs " << inputs_.size() << "  deltaPhi " << dPhi_.size() << "  maxZ " << maxZ_.size();
   }
 }

References beamSpotTag_, cablingMapToken_, dPhi_, edm::ParameterSet::getParameter(), inputs_, maxZ_, submitPVValidationJobs::t, tBeamSpot, tCandidateView, and trackerGeomToken_.

◆ ~PixelUnpackingRegions()

PixelUnpackingRegions::~PixelUnpackingRegions ( )

inline

Definition at line 51 of file PixelUnpackingRegions.h.

51 {}

Member Function Documentation

◆ addRegion()

void PixelUnpackingRegions::addRegion ( Region & r )

private

Definition at line 139 of file PixelUnpackingRegions.cc.

                                                {
   ++nreg_;
  
   float phi = r.v.phi();
  
   Module lo(phi - r.dPhi);
   Module hi(phi + r.dPhi);
  
   addRegionLocal(r, phiBPIX_, lo, hi);
   if (r.v.eta() > 1.) {
     addRegionLocal(r, phiFPIXp_, lo, hi);
   }
   if (r.v.eta() < -1.) {
     addRegionLocal(r, phiFPIXm_, lo, hi);
   }
 }

References addRegionLocal(), nreg_, phi, phiBPIX_, phiFPIXm_, phiFPIXp_, and alignCSCRings::r.

Referenced by run().

◆ addRegionLocal()

void PixelUnpackingRegions::addRegionLocal	(	Region &	r,
		std::vector< Module > &	container,
		const Module &	lo,
		const Module &	hi
	)

private

Definition at line 156 of file PixelUnpackingRegions.cc.

                                                               {
   Module lo = _lo;
   Module hi = _hi;
   Module pi_m(-M_PI);
   Module pi_p(M_PI);
  
   std::vector<Module>::const_iterator a, b;
  
   if (lo.phi >= -M_PI && hi.phi <= M_PI)  // interval doesn't cross the +-pi overlap
   {
     a = lower_bound(container.begin(), container.end(), lo);
     b = upper_bound(container.begin(), container.end(), hi);
     gatherFromRange(r, a, b);
   } else  // interval is torn by the +-pi overlap
   {
     if (hi.phi > M_PI)
       hi.phi -= 2. * M_PI;
     a = lower_bound(container.begin(), container.end(), pi_m);
     b = upper_bound(container.begin(), container.end(), hi);
     gatherFromRange(r, a, b);
  
     if (lo.phi < -M_PI)
       lo.phi += 2. * M_PI;
     a = lower_bound(container.begin(), container.end(), lo);
     b = upper_bound(container.begin(), container.end(), pi_p);
     gatherFromRange(r, a, b);
   }
 }

References a, b, gatherFromRange(), pfDeepBoostedJetPreprocessParams_cfi::lower_bound, M_PI, PixelUnpackingRegions::Module::phi, alignCSCRings::r, and pfDeepBoostedJetPreprocessParams_cfi::upper_bound.

Referenced by addRegion().

◆ gatherFromRange()

void PixelUnpackingRegions::gatherFromRange	(	Region &	r,
		std::vector< Module >::const_iterator	a,
		std::vector< Module >::const_iterator	b
	)

private

Definition at line 188 of file PixelUnpackingRegions.cc.

                                                                                {
   for (; a != b; ++a) {
     // projection in r's direction onto beam's z
     float zmodule = a->z - ((a->x - beamSpot_.x()) * r.cosphi + (a->y - beamSpot_.y()) * r.sinphi) * r.atantheta;
  
     // do not include modules that project too far in z
     if (std::abs(zmodule) > r.maxZ)
       continue;
  
     feds_.insert(a->fed);
     modules_.insert(a->id);
   }
 }

References a, funct::abs(), b, beamSpot_, feds_, modules_, and alignCSCRings::r.

Referenced by addRegionLocal().

◆ initialize()

void PixelUnpackingRegions::initialize ( const edm::EventSetup & es )

private

run by the run method: (re)initialize the cabling data when it's necessary

Definition at line 76 of file PixelUnpackingRegions.cc.

                                                               {
   // initialize cabling map or update it if necessary
   // and re-cache modules information
   if (watcherSiPixelFedCablingMap_.check(es)) {
     edm::ESHandle<SiPixelFedCablingMap> cablingMap = es.getHandle(cablingMapToken_);
     cabling_ = cablingMap->cablingTree();
  
     // get the TrackerGeom
     edm::ESHandle<TrackerGeometry> geom = es.getHandle(trackerGeomToken_);
  
     // switch on the phase1
     unsigned int fedMin = FEDNumbering::MINSiPixelFEDID;  // phase0
     unsigned int fedMax = FEDNumbering::MAXSiPixelFEDID;
     if ((geom->isThere(GeomDetEnumerators::P1PXB)) && (geom->isThere(GeomDetEnumerators::P1PXEC))) {
       fedMin = FEDNumbering::MINSiPixeluTCAFEDID;  // phase1
       fedMax = FEDNumbering::MAXSiPixeluTCAFEDID;
     }
  
     phiBPIX_.clear();
     phiFPIXp_.clear();
     phiFPIXm_.clear();
  
     phiBPIX_.reserve(1024);
     phiFPIXp_.reserve(512);
     phiFPIXm_.reserve(512);
  
     auto it = geom->dets().begin();
     for (; it != geom->dets().end(); ++it) {
       int subdet = (*it)->geographicalId().subdetId();
       if (!(subdet == PixelSubdetector::PixelBarrel || subdet == PixelSubdetector::PixelEndcap))
         continue;
  
       Module m;
  
       m.x = (*it)->position().x();
       m.y = (*it)->position().y();
       m.z = (*it)->position().z();
  
       m.phi = (*it)->position().phi();
  
       m.id = (*it)->geographicalId().rawId();
       const std::vector<sipixelobjects::CablingPathToDetUnit> path2det = cabling_->pathToDetUnit(m.id);
  
       m.fed = path2det[0].fed;
       assert((m.fed <= fedMax) && (m.fed >= fedMin));
  
       if (subdet == PixelSubdetector::PixelBarrel) {
         phiBPIX_.push_back(m);
       } else if (subdet == PixelSubdetector::PixelEndcap) {
         if (m.z > 0.)
           phiFPIXp_.push_back(m);
         else
           phiFPIXm_.push_back(m);
       }
     }
  
     // pre-sort by phi
     std::sort(phiBPIX_.begin(), phiBPIX_.end());
     std::sort(phiFPIXp_.begin(), phiFPIXp_.end());
     std::sort(phiFPIXm_.begin(), phiFPIXm_.end());
   }
 }

References cms::cuda::assert(), cabling_, cablingMapToken_, SiPixelFedCablingMap::cablingTree(), edm::ESWatcher< T >::check(), relativeConstraints::geom, edm::EventSetup::getHandle(), visualization-live-secondInstance_cfg::m, FEDNumbering::MAXSiPixelFEDID, FEDNumbering::MAXSiPixeluTCAFEDID, FEDNumbering::MINSiPixelFEDID, FEDNumbering::MINSiPixeluTCAFEDID, GeomDetEnumerators::P1PXB, GeomDetEnumerators::P1PXEC, phiBPIX_, phiFPIXm_, phiFPIXp_, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, trackerGeomToken_, and watcherSiPixelFedCablingMap_.

Referenced by run().

◆ mayUnpackFED()

bool PixelUnpackingRegions::mayUnpackFED ( unsigned int fed_n ) const

check whether a FED has to be unpacked

Definition at line 204 of file PixelUnpackingRegions.cc.

                                                                  {
   if (feds_.count(fed_n))
     return true;
   return false;
 }

References feds_.

Referenced by SiPixelRawToDigi::produce().

◆ mayUnpackModule()

bool PixelUnpackingRegions::mayUnpackModule ( unsigned int id ) const

check whether a module has to be unpacked

Definition at line 210 of file PixelUnpackingRegions.cc.

                                                                  {
   if (modules_.count(id))
     return true;
   return false;
 }

References modules_.

◆ modulesToUnpack()

const std::set<unsigned int>* PixelUnpackingRegions::modulesToUnpack ( ) const

inline

full set of module ids to unpack

Definition at line 63 of file PixelUnpackingRegions.h.

63 { return &modules_; }

References modules_.

Referenced by SiPixelRawToDigi::produce().

◆ nBarrelModules()

unsigned int PixelUnpackingRegions::nBarrelModules ( ) const

Definition at line 216 of file PixelUnpackingRegions.cc.

                                                          {
   return std::count_if(modules_.begin(), modules_.end(), isBPIXModule);
 }

References modules_.

Referenced by SiPixelRawToDigi::produce().

◆ nFEDs()

unsigned int PixelUnpackingRegions::nFEDs ( ) const

inline

various informational accessors:

Definition at line 66 of file PixelUnpackingRegions.h.

66 { return feds_.size(); }

References feds_.

Referenced by SiPixelRawToDigi::produce().

◆ nForwardModules()

unsigned int PixelUnpackingRegions::nForwardModules ( ) const

Definition at line 220 of file PixelUnpackingRegions.cc.

                                                           {
   return std::count_if(modules_.begin(), modules_.end(), isFPIXModule);
 }

References modules_.

Referenced by SiPixelRawToDigi::produce().

◆ nModules()

unsigned int PixelUnpackingRegions::nModules ( ) const

inline

Definition at line 67 of file PixelUnpackingRegions.h.

67 { return modules_.size(); }

References modules_.

Referenced by SiPixelRawToDigi::produce().

◆ nRegions()

unsigned int PixelUnpackingRegions::nRegions ( ) const

inline

Definition at line 70 of file PixelUnpackingRegions.h.

70 { return nreg_; }

References nreg_.

◆ run()

void PixelUnpackingRegions::run	(	const edm::Event &	e,
		const edm::EventSetup &	es
	)

has to be run during each event

Definition at line 48 of file PixelUnpackingRegions.cc.

                                                                           {
   feds_.clear();
   modules_.clear();
   nreg_ = 0;
  
   initialize(es);
  
   edm::Handle<reco::BeamSpot> beamSpot;
   e.getByToken(tBeamSpot, beamSpot);
   beamSpot_ = beamSpot->position();
   //beamSpot_ = math::XYZPoint(0.,0.,0.);
  
   size_t ninputs = inputs_.size();
   for (size_t input = 0; input < ninputs; ++input) {
     edm::Handle<reco::CandidateView> h;
     e.getByToken(tCandidateView[input], h);
  
     size_t n = h->size();
     for (size_t i = 0; i < n; ++i) {
       const reco::Candidate& c = (*h)[i];
  
       // different input collections can have different dPhi and maxZ
       Region r(c.momentum(), dPhi_[input], maxZ_[input]);
       addRegion(r);
     }
   }
 }