Inheritance diagram for MkFitGeometryESProducer:

Classes
struct	GapCollector

struct	MatHistBin

struct	ModuleShape_hash

Public Member Functions
	MkFitGeometryESProducer (const edm::ParameterSet &iConfig)

std::unique_ptr< MkFitGeometry >	produce (const TrackerRecoGeometryRecord &iRecord)

Public Member Functions inherited from edm::ESProducer
	ESProducer ()

	ESProducer (const ESProducer &)=delete

	ESProducer (ESProducer &&)=delete

ESResolverIndex const *	getTokenIndices (unsigned int iIndex) const

ESRecordIndex const *	getTokenRecordIndices (unsigned int iIndex) const

bool	hasMayConsumes () const noexcept

size_t	numberOfTokenIndices (unsigned int iIndex) const

ESProducer &	operator= (const ESProducer &)=delete

ESProducer &	operator= (ESProducer &&)=delete

SerialTaskQueueChain &	queue ()

template<typename Record >
std::optional< std::vector< ESResolverIndex > >	updateFromMayConsumes (unsigned int iIndex, const Record &iRecord) const

void	updateLookup (eventsetup::ESRecordsToProductResolverIndices const &) final

	~ESProducer () noexcept(false) override

Public Member Functions inherited from edm::ESProductResolverFactoryProducer
	ESProductResolverFactoryProducer ()

	ESProductResolverFactoryProducer (const ESProductResolverFactoryProducer &)=delete

const ESProductResolverFactoryProducer &	operator= (const ESProductResolverFactoryProducer &)=delete

	~ESProductResolverFactoryProducer () noexcept(false) override

Public Member Functions inherited from edm::eventsetup::ESProductResolverProvider
void	createKeyedResolvers (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)

const ComponentDescription &	description () const

	ESProductResolverProvider ()

	ESProductResolverProvider (const ESProductResolverProvider &)=delete

void	fillRecordsNotAllowingConcurrentIOVs (std::set< EventSetupRecordKey > &recordsNotAllowingConcurrentIOVs) const

virtual void	initConcurrentIOVs (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)

bool	isUsingRecord (const EventSetupRecordKey &key) const

KeyedResolvers &	keyedResolvers (const EventSetupRecordKey &iRecordKey, unsigned int iovIndex=0)

const ESProductResolverProvider &	operator= (const ESProductResolverProvider &)=delete

void	setAppendToDataLabel (const edm::ParameterSet &)

void	setDescription (const ComponentDescription &iDescription)

std::set< EventSetupRecordKey >	usingRecords () const

virtual	~ESProductResolverProvider () noexcept(false)

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

Static Public Member Functions inherited from edm::eventsetup::ESProductResolverProvider
static void	prevalidate (ConfigurationDescriptions &)

Private Types
using	layer_gap_map_t = std::unordered_map< int, GapCollector >

using	layer_module_shape_vec_t = std::vector< module_shape_hmap_t >

using	MaterialHistogram = mkfit::rectvec< MatHistBin >

using	module_shape_hmap_t = std::unordered_map< mkfit::ModuleShape, unsigned short, ModuleShape_hash >

Private Member Functions
void	addPixBGeometry (mkfit::TrackerInfo &trk_info, MaterialHistogram &material_histogram)

void	addPixEGeometry (mkfit::TrackerInfo &trk_info, MaterialHistogram &material_histogram)

void	addTECGeometry (mkfit::TrackerInfo &trk_info, MaterialHistogram &material_histogram)

void	addTIBGeometry (mkfit::TrackerInfo &trk_info, MaterialHistogram &material_histogram)

void	addTIDGeometry (mkfit::TrackerInfo &trk_info, MaterialHistogram &material_histogram)

void	addTOBGeometry (mkfit::TrackerInfo &trk_info, MaterialHistogram &material_histogram)

void	aggregateMaterialInfo (mkfit::TrackerInfo &trk_info, MaterialHistogram &material_histogram)

void	considerPoint (const GlobalPoint &gp, mkfit::LayerInfo &lay_info)

void	fillLayers (mkfit::TrackerInfo &trk_info)

void	fillShapeAndPlacement (const GeomDet det, mkfit::TrackerInfo &trk_info, MaterialHistogram &material_histogram, layer_gap_map_t lgc_map=nullptr)

void	findRZBox (const GlobalPoint &gp, float &rmin, float &rmax, float &zmin, float &zmax)

Private Attributes
edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord >	geomToken_

layer_module_shape_vec_t	layerModuleShapeVec_

mkfit::LayerNumberConverter	layerNrConv_ = {mkfit::TkLayout::phase1}

const TrackerGeometry *	trackerGeom_ = nullptr

edm::ESGetToken< GeometricSearchTracker, TrackerRecoGeometryRecord >	trackerToken_

const TrackerTopology *	trackerTopo_ = nullptr

edm::ESGetToken< TrackerTopology, TrackerTopologyRcd >	ttopoToken_

Additional Inherited Members
Protected Types inherited from edm::ESProductResolverFactoryProducer
using	EventSetupRecordKey = eventsetup::EventSetupRecordKey

Protected Types inherited from edm::eventsetup::ESProductResolverProvider
using	KeyedResolversVector = std::vector< std::pair< DataKey, std::shared_ptr< ESProductResolver > >>

Protected Member Functions inherited from edm::ESProducer
ESConsumesInfo *	consumesInfoPushBackNew ()

unsigned int	consumesInfoSize () const

template<typename CallbackT , typename TList , typename TRecord >
void	registerProducts (std::shared_ptr< std::pair< unsigned int, std::shared_ptr< CallbackT >>> iCallback, const TList , const TRecord iRecord, const es::Label &iLabel)

template<typename CallbackT , typename TRecord >
void	registerProducts (std::shared_ptr< std::pair< unsigned int, std::shared_ptr< CallbackT >>>, const eventsetup::produce::Null , const TRecord , const es::Label &)

template<typename T >
auto	setWhatProduced (T *iThis, const es::Label &iLabel={})

template<typename T >
auto	setWhatProduced (T iThis, const char iLabel)

template<typename T >
auto	setWhatProduced (T *iThis, const std::string &iLabel)

template<typename T , typename TDecorator >
auto	setWhatProduced (T *iThis, const TDecorator &iDec, const es::Label &iLabel={})

template<typename T , typename TReturn , typename TRecord >
auto	setWhatProduced (T iThis, TReturn(T::iMethod)(const TRecord &), const es::Label &iLabel={})

template<typename T , typename TReturn , typename TRecord , typename TDecorator >
auto	setWhatProduced (T iThis, TReturn(T ::iMethod)(const TRecord &), const TDecorator &iDec, const es::Label &iLabel={})

template<typename TFunc >
auto	setWhatProduced (TFunc &&func, const es::Label &iLabel={})

template<typename TReturn , typename TRecord , typename TFunc , typename TDecorator >
ESConsumesCollectorT< TRecord >	setWhatProduced (TFunc &&func, TDecorator &&iDec, const es::Label &iLabel={})

void	usesResources (std::vector< std::string > const &)

Protected Member Functions inherited from edm::ESProductResolverFactoryProducer
template<class TFactory >
void	registerFactory (std::unique_ptr< TFactory > iFactory, const std::string &iLabel=std::string())

virtual void	registerFactoryWithKey (const EventSetupRecordKey &iRecord, std::unique_ptr< eventsetup::ESProductResolverFactoryBase > iFactory, const std::string &iLabel=std::string())

KeyedResolversVector	registerResolvers (const EventSetupRecordKey &, unsigned int iovIndex) override

Protected Member Functions inherited from edm::eventsetup::ESProductResolverProvider
template<class T >
void	usingRecord ()

void	usingRecordWithKey (const EventSetupRecordKey &key)

Detailed Description

Definition at line 33 of file MkFitGeometryESProducer.cc.

Member Typedef Documentation

◆ layer_gap_map_t

using MkFitGeometryESProducer::layer_gap_map_t = std::unordered_map<int, GapCollector>

private

Definition at line 63 of file MkFitGeometryESProducer.cc.

◆ layer_module_shape_vec_t

using MkFitGeometryESProducer::layer_module_shape_vec_t = std::vector<module_shape_hmap_t>

private

Definition at line 71 of file MkFitGeometryESProducer.cc.

◆ MaterialHistogram

using MkFitGeometryESProducer::MaterialHistogram = mkfit::rectvec<MatHistBin>

private

Definition at line 81 of file MkFitGeometryESProducer.cc.

◆ module_shape_hmap_t

using MkFitGeometryESProducer::module_shape_hmap_t = std::unordered_map<mkfit::ModuleShape, unsigned short, ModuleShape_hash>

private

Definition at line 70 of file MkFitGeometryESProducer.cc.

Constructor & Destructor Documentation

◆ MkFitGeometryESProducer()

MkFitGeometryESProducer::MkFitGeometryESProducer ( const edm::ParameterSet & iConfig )

Definition at line 109 of file MkFitGeometryESProducer.cc.

References gpuPixelDoublets::cc, geomToken_, edm::ESProducer::setWhatProduced(), trackerToken_, and ttopoToken_.

                                                                                {
   auto cc = setWhatProduced(this);
   geomToken_ = cc.consumes();
   ttopoToken_ = cc.consumes();
   trackerToken_ = cc.consumes();
 }

Member Function Documentation

◆ addPixBGeometry()

void MkFitGeometryESProducer::addPixBGeometry	(	mkfit::TrackerInfo &	trk_info,
		MaterialHistogram &	material_histogram
	)

private

Definition at line 374 of file MkFitGeometryESProducer.cc.

References TrackerGeometry::detsPXB(), fillShapeAndPlacement(), and trackerGeom_.

Referenced by produce().

                                                                                                                {
 #ifdef DUMP_MKF_GEO
   printf("\n*** addPixBGeometry\n\n");
 #endif
   for (auto &det : trackerGeom_->detsPXB()) {
     fillShapeAndPlacement(det, trk_info, material_histogram);
   }
 }

◆ addPixEGeometry()

void MkFitGeometryESProducer::addPixEGeometry	(	mkfit::TrackerInfo &	trk_info,
		MaterialHistogram &	material_histogram
	)

private

Definition at line 383 of file MkFitGeometryESProducer.cc.

References TrackerGeometry::detsPXF(), fillShapeAndPlacement(), and trackerGeom_.

Referenced by produce().

                                                                                                                {
 #ifdef DUMP_MKF_GEO
   printf("\n*** addPixEGeometry\n\n");
 #endif
   for (auto &det : trackerGeom_->detsPXF()) {
     fillShapeAndPlacement(det, trk_info, material_histogram);
   }
 }

◆ addTECGeometry()

void MkFitGeometryESProducer::addTECGeometry	(	mkfit::TrackerInfo &	trk_info,
		MaterialHistogram &	material_histogram
	)

private

Definition at line 419 of file MkFitGeometryESProducer.cc.

References TrackerGeometry::detsTEC(), fillShapeAndPlacement(), nano_mu_digi_cff::layer, mkfit::TrackerInfo::layer_nc(), mkfit::LayerInfo::set_r_hole_range(), trackerGeom_, MkFitGeometryESProducer::GapCollector::Interval::x, and MkFitGeometryESProducer::GapCollector::Interval::y.

Referenced by produce().

                                                                                                               {
 #ifdef DUMP_MKF_GEO
   printf("\n*** addTECGeometry\n\n");
 #endif
   // For TEC we also need to discover hole in radial extents.
   layer_gap_map_t lgc_map;
   for (auto &det : trackerGeom_->detsTEC()) {
     fillShapeAndPlacement(det, trk_info, material_histogram, &lgc_map);
   }
   // Now loop over the GapCollectors and see if there is a coverage gap.
   std::ostringstream ostr;
   ostr << "addTECGeometry() gap report:\n";
   GapCollector::Interval itvl;
   for (auto &[layer, gcol] : lgc_map) {
     gcol.sqrt_elements();
     if (gcol.find_gap(itvl, 0.5)) {
       ostr << "  layer: " << layer << ", gap: " << itvl.x << " -> " << itvl.y << " width = " << itvl.y - itvl.x << "\n";
       ostr << "    all gaps: ";
       gcol.print_gaps(ostr);
       ostr << "\n";
       trk_info.layer_nc(layer).set_r_hole_range(itvl.x, itvl.y);
     }
   }
   edm::LogVerbatim("MkFitGeometryESProducer") << ostr.str();
 }

◆ addTIBGeometry()

void MkFitGeometryESProducer::addTIBGeometry	(	mkfit::TrackerInfo &	trk_info,
		MaterialHistogram &	material_histogram
	)

private

Definition at line 392 of file MkFitGeometryESProducer.cc.

References TrackerGeometry::detsTIB(), fillShapeAndPlacement(), and trackerGeom_.

Referenced by produce().

                                                                                                               {
 #ifdef DUMP_MKF_GEO
   printf("\n*** addTIBGeometry\n\n");
 #endif
   for (auto &det : trackerGeom_->detsTIB()) {
     fillShapeAndPlacement(det, trk_info, material_histogram);
   }
 }

◆ addTIDGeometry()

void MkFitGeometryESProducer::addTIDGeometry	(	mkfit::TrackerInfo &	trk_info,
		MaterialHistogram &	material_histogram
	)

private

Definition at line 410 of file MkFitGeometryESProducer.cc.

References TrackerGeometry::detsTID(), fillShapeAndPlacement(), and trackerGeom_.

Referenced by produce().

                                                                                                               {
 #ifdef DUMP_MKF_GEO
   printf("\n*** addTIDGeometry\n\n");
 #endif
   for (auto &det : trackerGeom_->detsTID()) {
     fillShapeAndPlacement(det, trk_info, material_histogram);
   }
 }

◆ addTOBGeometry()

void MkFitGeometryESProducer::addTOBGeometry	(	mkfit::TrackerInfo &	trk_info,
		MaterialHistogram &	material_histogram
	)

private

Definition at line 401 of file MkFitGeometryESProducer.cc.

References TrackerGeometry::detsTOB(), fillShapeAndPlacement(), and trackerGeom_.

Referenced by produce().

                                                                                                               {
 #ifdef DUMP_MKF_GEO
   printf("\n*** addTOBGeometry\n\n");
 #endif
   for (auto &det : trackerGeom_->detsTOB()) {
     fillShapeAndPlacement(det, trk_info, material_histogram);
   }
 }

◆ aggregateMaterialInfo()

void MkFitGeometryESProducer::aggregateMaterialInfo	(	mkfit::TrackerInfo &	trk_info,
		MaterialHistogram &	material_histogram
	)

private

Definition at line 453 of file MkFitGeometryESProducer.cc.

References mps_fire::i, dqmiolumiharvest::j, mkfit::TrackerInfo::mat_nbins_r(), mkfit::TrackerInfo::mat_nbins_z(), mkfit::TrackerInfo::material_bbxi(), mkfit::TrackerInfo::material_radl(), MkFitGeometryESProducer::MatHistBin::rl, MkFitGeometryESProducer::MatHistBin::weight, and MkFitGeometryESProducer::MatHistBin::xi.

Referenced by produce().

                                                                                            {
   //from histogram (vector of tuples) to grid
   for (int i = 0; i < trk_info.mat_nbins_z(); i++) {
     for (int j = 0; j < trk_info.mat_nbins_r(); j++) {
       const MatHistBin &mhb = material_histogram(i, j);
       if (mhb.weight > 0) {
         trk_info.material_bbxi(i, j) = mhb.xi / mhb.weight;
         trk_info.material_radl(i, j) = mhb.rl / mhb.weight;
       }
     }
   }
 }

◆ considerPoint()

void MkFitGeometryESProducer::considerPoint	(	const GlobalPoint &	gp,
		mkfit::LayerInfo &	lay_info
	)

private

Definition at line 200 of file MkFitGeometryESProducer.cc.

References mkfit::LayerInfo::extend_limits(), runTauDisplay::gp, alignCSCRings::r, and z.

Referenced by fillShapeAndPlacement().

                                                                                      {
   // Use radius squared during bounding-region search.
   float r = gp.perp2(), z = gp.z();
   li.extend_limits(r, z);
 }

◆ fillDescriptions()

void MkFitGeometryESProducer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 116 of file MkFitGeometryESProducer.cc.

References edm::ConfigurationDescriptions::addWithDefaultLabel(), and submitPVResolutionJobs::desc.

                                                                                          {
   edm::ParameterSetDescription desc;
   descriptions.addWithDefaultLabel(desc);
 }

◆ fillLayers()

void MkFitGeometryESProducer::fillLayers ( mkfit::TrackerInfo & trk_info )

private

Definition at line 467 of file MkFitGeometryESProducer.cc.

References funct::abs(), mps_fire::i, testProducerWithPsetDescEmpty_cfi::i2, mkfit::LayerInfo::is_barrel(), dqmiolumiharvest::j, mkfit::TrackerInfo::layer(), mkfit::TrackerInfo::mat_bin_r(), mkfit::TrackerInfo::mat_bin_z(), mkfit::TrackerInfo::mat_nbins_r(), mkfit::TrackerInfo::mat_nbins_z(), mkfit::TrackerInfo::material_bbxi(), mkfit::TrackerInfo::material_radl(), WZElectronSkims53X_cff::max, mkfit::TrackerInfo::n_layers(), mkfit::LayerInfo::rin(), mkfit::LayerInfo::rout(), mkfit::LayerInfo::zmax(), SiStripMonitorCluster_cfi::zmax, mkfit::LayerInfo::zmin(), and SiStripMonitorCluster_cfi::zmin.

Referenced by produce().

                                                                    {
   mkfit::rectvec<int> rneighbor_map(trk_info.mat_nbins_z(), trk_info.mat_nbins_r());
   mkfit::rectvec<int> zneighbor_map(trk_info.mat_nbins_z(), trk_info.mat_nbins_r());
 
   for (int im = 0; im < trk_info.n_layers(); ++im) {
     const mkfit::LayerInfo &li = trk_info.layer(im);
     if (!li.is_barrel() && li.zmax() < 0)
       continue;  // neg endcap covered by pos
     int rin, rout, zmin, zmax;
     rin = trk_info.mat_bin_r(li.rin());
     rout = trk_info.mat_bin_r(li.rout()) + 1;
     if (li.is_barrel()) {
       zmin = 0;
       zmax = trk_info.mat_bin_z(std::max(std::abs(li.zmax()), std::abs(li.zmin()))) + 1;
     } else {
       zmin = trk_info.mat_bin_z(li.zmin());
       zmax = trk_info.mat_bin_z(li.zmax()) + 1;
     }
     for (int i = zmin; i < zmax; i++) {
       for (int j = rin; j < rout; j++) {
         if (trk_info.material_bbxi(i, j) == 0) {
           float distancesqmin = 100000;
           for (int i2 = zmin; i2 < zmax; i2++) {
             for (int j2 = rin; j2 < rout; j2++) {
               if (j == j2 && i == i2)
                 continue;
               auto mydistsq = (i - i2) * (i - i2) + (j - j2) * (j - j2);
               if (mydistsq < distancesqmin && trk_info.material_radl(i2, j2) > 0) {
                 distancesqmin = mydistsq;
                 zneighbor_map(i, j) = i2;
                 rneighbor_map(i, j) = j2;
               }
             }
           }  // can work on speedup here
         }
       }
     }
     for (int i = zmin; i < zmax; i++) {
       for (int j = rin; j < rout; j++) {
         if (trk_info.material_bbxi(i, j) == 0) {
           int iN = zneighbor_map(i, j);
           int jN = rneighbor_map(i, j);
           trk_info.material_bbxi(i, j) = trk_info.material_bbxi(iN, jN);
           trk_info.material_radl(i, j) = trk_info.material_radl(iN, jN);
         }
       }
     }
   }  //module loop
 }

◆ fillShapeAndPlacement()

void MkFitGeometryESProducer::fillShapeAndPlacement	(	const GeomDet *	det,
		mkfit::TrackerInfo &	trk_info,
		MaterialHistogram &	material_histogram,
		layer_gap_map_t *	lgc_map = `nullptr`
	)

private

Definition at line 206 of file MkFitGeometryESProducer.cc.

References b, b2, reco::ceil(), considerPoint(), mkfit::LayerNumberConverter::convertLayerNumber(), ALCARECOPPSCalTrackBasedSel_cff::detid, PVValHelper::dx, PVValHelper::dy, PVValHelper::dz, Exception, f, findRZBox(), dqmdumpme::first, GeomDet::geographicalId(), mps_fire::i, mkfit::LayerNumberConverter::isPhase2(), TrackerTopology::isStereo(), dqmiolumiharvest::j, TrackerTopology::layer(), mkfit::TrackerInfo::layer_nc(), layerModuleShapeVec_, layerNrConv_, mkfit::TrackerInfo::mat_nbins_r(), mkfit::TrackerInfo::mat_nbins_z(), mkfit::TrackerInfo::mat_range_r(), mkfit::TrackerInfo::mat_range_z(), WZElectronSkims53X_cff::max, Surface::mediumProperties(), SiStripPI::min, hltL1SingleMuFiltered5_cfi::overlap, AlCaHLTBitMon_ParallelJobs::p, PV3DBase< T, PVType, FrameType >::perp2(), PosEndcap, GeomDet::position(), MediumProperties::radLen(), GeomDet::rotation(), mkfit::ModuleShape::round_assign(), TrackerTopology::side(), GeomDet::surface(), SiStripSubdetector::TEC, TrackerTopology::tecIsDoubleSide(), SiStripSubdetector::TIB, TrackerTopology::tibIsDoubleSide(), SiStripSubdetector::TID, TrackerTopology::tidIsDoubleSide(), SiStripSubdetector::TOB, TrackerTopology::tobIsDoubleSide(), Surface::toGlobal(), trackerTopo_, useMatched, x, TkRotation< T >::x(), MediumProperties::xi(), geometryCSVtoXML::xy, z, and TkRotation< T >::z().

Referenced by addPixBGeometry(), addPixEGeometry(), addTECGeometry(), addTIBGeometry(), addTIDGeometry(), and addTOBGeometry().

                                                                               {
   const DetId detid = det->geographicalId();
 
   bool doubleSide = false;  //double modules have double material
   if (detid.subdetId() == SiStripSubdetector::TIB)
     doubleSide = trackerTopo_->tibIsDoubleSide(detid);
   else if (detid.subdetId() == SiStripSubdetector::TID)
     doubleSide = trackerTopo_->tidIsDoubleSide(detid);
   else if (detid.subdetId() == SiStripSubdetector::TOB)
     doubleSide = trackerTopo_->tobIsDoubleSide(detid);
   else if (detid.subdetId() == SiStripSubdetector::TEC)
     doubleSide = trackerTopo_->tecIsDoubleSide(detid);
 
   float xy[4][2];
   float dz;
   const Bounds *b = &((det->surface()).bounds());
   mkfit::ModuleShape ms;
 
   if (const TrapezoidalPlaneBounds *b2 = dynamic_cast<const TrapezoidalPlaneBounds *>(b)) {
     // See sec. "TrapezoidalPlaneBounds parameters" in doc/reco-geom-notes.txt
     std::array<const float, 4> const &par = b2->parameters();
     xy[0][0] = -par[0];
     xy[0][1] = -par[3];
     xy[1][0] = -par[1];
     xy[1][1] = par[3];
     xy[2][0] = par[1];
     xy[2][1] = par[3];
     xy[3][0] = par[0];
     xy[3][1] = -par[3];
     dz = par[2];
     ms.round_assign(par[0], par[1], par[3], par[2]);
 
 #ifdef DUMP_MKF_GEO
     printf("TRAP 0x%x %f %f %f %f  ", detid.rawId(), par[0], par[1], par[2], par[3]);
 #endif
   } else if (const RectangularPlaneBounds *b2 = dynamic_cast<const RectangularPlaneBounds *>(b)) {
     // Rectangular
     float dx = b2->width() * 0.5;   // half width
     float dy = b2->length() * 0.5;  // half length
     xy[0][0] = -dx;
     xy[0][1] = -dy;
     xy[1][0] = -dx;
     xy[1][1] = dy;
     xy[2][0] = dx;
     xy[2][1] = dy;
     xy[3][0] = dx;
     xy[3][1] = -dy;
     dz = b2->thickness() * 0.5;  // half thickness
     ms.round_assign(dx, 0.0f, dy, dz);
 
 #ifdef DUMP_MKF_GEO
     printf("RECT 0x%x %f %f %f           ", detid.rawId(), dx, dy, dz);
 #endif
   } else {
     throw cms::Exception("UnimplementedFeature") << "unsupported Bounds class";
   }
 
   const bool useMatched = false;
   int lay =
       layerNrConv_.convertLayerNumber(detid.subdetId(),
                                       trackerTopo_->layer(detid),
                                       useMatched,
                                       trackerTopo_->isStereo(detid),
                                       trackerTopo_->side(detid) == static_cast<unsigned>(TrackerDetSide::PosEndcap));
 
   unsigned short shape_id = 9999;
   if (!doubleSide) {
     module_shape_hmap_t &bhm = layerModuleShapeVec_[lay];
     auto bhmi = bhm.find(ms);
     if (bhmi == bhm.end()) {
       bhmi = bhm.insert({ms, (unsigned short)bhm.size()}).first;
     }
     shape_id = bhmi->second;
   }
 
 #ifdef DUMP_MKF_GEO
   printf("  subdet=%d layer=%d side=%d is_stereo=%d is_double_side=%d --> mkflayer=%d; unique shape id=%hu\n",
          detid.subdetId(),
          trackerTopo_->layer(detid),
          trackerTopo_->side(detid),
          trackerTopo_->isStereo(detid),
          doubleSide,
          lay,
          shape_id);
 #endif
 
   mkfit::LayerInfo &layer_info = trk_info.layer_nc(lay);
   if (lgc_map) {
     (*lgc_map)[lay].reset_current();
   }
   float zbox_min = 1000, zbox_max = 0, rbox_min = 1000, rbox_max = 0;
   for (int i = 0; i < 4; ++i) {
     Local3DPoint lp1(xy[i][0], xy[i][1], -dz);
     Local3DPoint lp2(xy[i][0], xy[i][1], dz);
     GlobalPoint gp1 = det->surface().toGlobal(lp1);
     GlobalPoint gp2 = det->surface().toGlobal(lp2);
     considerPoint(gp1, layer_info);
     considerPoint(gp2, layer_info);
     findRZBox(gp1, rbox_min, rbox_max, zbox_min, zbox_max);
     findRZBox(gp2, rbox_min, rbox_max, zbox_min, zbox_max);
     if (lgc_map) {
       (*lgc_map)[lay].extend_current(gp1.perp2());
       (*lgc_map)[lay].extend_current(gp2.perp2());
     }
   }
   if (lgc_map) {
     (*lgc_map)[lay].add_current();
   }
 
   // Double-sided module (join of two modules) information is not used in mkFit and
   // also not needed for the material calculation.
   // NOTE: This check should actually be performed even before the bounding box calculation
   // as double-side module bounding box is a box-shaped union of bounding shapes of the
   // constituent modules -- thus extending the layer bounding box unnecessarily.
   // The 'if' is here as mkFit layer hit/miss logic has been tuned with this extended
   // bounding boxes. To be moved higher up once this detection is improved through usage of
   // the thin-thick layer concept (expected towards the end of 2024).
   if (doubleSide)
     return;
 
   // Module information
   const auto &p = det->position();
   auto z = det->rotation().z();
   auto x = det->rotation().x();
   layer_info.register_module(
       {{p.x(), p.y(), p.z()}, {z.x(), z.y(), z.z()}, {x.x(), x.y(), x.z()}, detid.rawId(), shape_id});
   // Set some layer parameters (repeatedly, would require hard-coding otherwise)
   layer_info.set_subdet(detid.subdetId());
   layer_info.set_is_pixel(detid.subdetId() <= 2);
   layer_info.set_is_stereo(trackerTopo_->isStereo(detid));
   if (layerNrConv_.isPhase2() && !layer_info.is_pixel())
     layer_info.set_has_charge(false);
 
   // Fill material
   {
     // module material
     const float bbxi = det->surface().mediumProperties().xi();
     const float radL = det->surface().mediumProperties().radLen();
     // loop over bins to fill histogram with bbxi, radL and their weight, which the overlap surface in r-z with the cmsquare of a bin
     const float iBin = trk_info.mat_range_z() / trk_info.mat_nbins_z();
     const float jBin = trk_info.mat_range_r() / trk_info.mat_nbins_r();
     for (int i = std::floor(zbox_min / iBin); i < std::ceil(zbox_max / iBin); i++) {
       for (int j = std::floor(rbox_min / jBin); j < std::ceil(rbox_max / jBin); j++) {
         const float iF = i * iBin;
         const float jF = j * jBin;
         float overlap = std::max(0.f, std::min(jF + jBin, rbox_max) - std::max(jF, rbox_min)) *
                         std::max(0.f, std::min(iF + iBin, zbox_max) - std::max(iF, zbox_min));
         if (overlap > 0)
           material_histogram(i, j).add(overlap, bbxi, radL);
       }
     }
   }
 }

◆ findRZBox()

void MkFitGeometryESProducer::findRZBox	(	const GlobalPoint &	gp,
		float &	rmin,
		float &	rmax,
		float &	zmin,
		float &	zmax
	)

private

Definition at line 445 of file MkFitGeometryESProducer.cc.

References funct::abs(), runTauDisplay::gp, WZElectronSkims53X_cff::max, SiStripPI::min, alignCSCRings::r, z, SiStripMonitorCluster_cfi::zmax, and SiStripMonitorCluster_cfi::zmin.

Referenced by fillShapeAndPlacement().

                                                                                                                  {
   float r = gp.perp(), z = std::abs(gp.z());
   rmax = std::max(r, rmax);
   rmin = std::min(r, rmin);
   zmax = std::max(z, zmax);
   zmin = std::min(z, zmin);
 }

◆ produce()

std::unique_ptr< MkFitGeometry > MkFitGeometryESProducer::produce ( const TrackerRecoGeometryRecord & iRecord )

Definition at line 541 of file MkFitGeometryESProducer.cc.

                                                                                                       {
   auto trackerInfo = std::make_unique<mkfit::TrackerInfo>();
 
   trackerGeom_ = &iRecord.get(geomToken_);
   trackerTopo_ = &iRecord.get(ttopoToken_);
 
   const float *qBinDefaults = nullptr;
 
   // std::string path = "Geometry/TrackerCommonData/data/";
   if (trackerGeom_->isThere(GeomDetEnumerators::P1PXB) || trackerGeom_->isThere(GeomDetEnumerators::P1PXEC)) {
     edm::LogInfo("MkFitGeometryESProducer") << "Extracting PhaseI geometry";
     trackerInfo->create_layers(18, 27, 27);
     qBinDefaults = phase1QBins;
     trackerInfo->create_material(300, 300.0f, 120, 120.0f);
   } else if (trackerGeom_->isThere(GeomDetEnumerators::P2PXB) || trackerGeom_->isThere(GeomDetEnumerators::P2PXEC) ||
              trackerGeom_->isThere(GeomDetEnumerators::P2OTB) || trackerGeom_->isThere(GeomDetEnumerators::P2OTEC)) {
     edm::LogInfo("MkFitGeometryESProducer") << "Extracting PhaseII geometry";
 #if !defined(MKFIT_PHASE2CUSTOMFLAGS)
     // In Phase2, by default use prop-to-plane and pT-dependent MS.
     // Option is kept to use custom flags, for R&D/test purposes.
     using namespace mkfit;
     Config::usePropToPlane = true;
     Config::usePtMultScat = true;
 #endif
     layerNrConv_.reset(mkfit::TkLayout::phase2);
     trackerInfo->create_layers(16, 22, 22);
     qBinDefaults = phase2QBins;
     trackerInfo->create_material(300, 300.0f, 120, 120.0f);
   } else {
     throw cms::Exception("UnimplementedFeature") << "unsupported / unknowen geometry version";
   }
 
   // Prepare layer boundaries for bounding-rz-box search
   for (int i = 0; i < trackerInfo->n_layers(); ++i) {
     auto &li = trackerInfo->layer_nc(i);
     li.set_limits(
         std::numeric_limits<float>::max(), 0, std::numeric_limits<float>::max(), -std::numeric_limits<float>::max());
     li.reserve_modules(256);
   }
   // Resize the module bounds collector vector
   layerModuleShapeVec_.resize(trackerInfo->n_layers());
 
   MaterialHistogram material_histogram(trackerInfo->mat_nbins_z(), trackerInfo->mat_nbins_r());
 
   // This works for both Phase1 and Phase2.
   // Phase2 TrackerGeometry returns empty det-vectors for TIB and TEC.
   addPixBGeometry(*trackerInfo, material_histogram);
   addPixEGeometry(*trackerInfo, material_histogram);
   addTIBGeometry(*trackerInfo, material_histogram);
   addTIDGeometry(*trackerInfo, material_histogram);
   addTOBGeometry(*trackerInfo, material_histogram);
   addTECGeometry(*trackerInfo, material_histogram);
 
   // r_in/out kept as squares until here, root them; fill ModuleShape vectors of layers
   unsigned int n_mod = 0;
   for (int i = 0; i < trackerInfo->n_layers(); ++i) {
     auto &li = trackerInfo->layer_nc(i);
     li.set_r_in_out(std::sqrt(li.rin()), std::sqrt(li.rout()));
     li.set_propagate_to(li.is_barrel() ? li.r_mean() : li.z_mean());
     li.set_q_bin(qBinDefaults[i]);
     unsigned int maxsid = li.shrink_modules();
 
     n_mod += maxsid;
 
     // Make sure the short id fits in the 14 bits...
     assert(maxsid < 1u << 13);
     assert(n_mod > 0);
 
     // Fill ModuleShape vectors
     int n_shapes = layerModuleShapeVec_[i].size();
     li.resize_shapes(n_shapes);
     for (auto &[shape, id] : layerModuleShapeVec_[i]) {
       li.register_shape(shape, id);
     }
   }
 
   // Material grid
   aggregateMaterialInfo(*trackerInfo, material_histogram);
   fillLayers(*trackerInfo);
 
   // Propagation configuration
   {
     using namespace mkfit;
     PropagationConfig &pconf = trackerInfo->prop_config_nc();
     pconf.backward_fit_to_pca = false;
     pconf.finding_requires_propagation_to_hit_pos = true;
     pconf.finding_inter_layer_pflags = PropagationFlags(PF_use_param_b_field | PF_apply_material);
     if (Config::usePropToPlane)
       pconf.finding_intra_layer_pflags = PropagationFlags(PF_use_param_b_field | PF_apply_material);
     else
       pconf.finding_intra_layer_pflags = PropagationFlags(PF_none);
     pconf.backward_fit_pflags = PropagationFlags(PF_use_param_b_field | PF_apply_material);
     pconf.forward_fit_pflags = PropagationFlags(PF_use_param_b_field | PF_apply_material);
     pconf.seed_fit_pflags = PropagationFlags(PF_none);
     pconf.pca_prop_pflags = PropagationFlags(PF_none);
     pconf.apply_tracker_info(trackerInfo.get());
   }
 
 #ifdef DUMP_MKF_GEO
   printf("Total number of modules %u, 14-bits fit up to %u modules\n", n_mod, 1u << 13);
 #endif
 
   return std::make_unique<MkFitGeometry>(iRecord.get(geomToken_),
                                          iRecord.get(trackerToken_),
                                          iRecord.get(ttopoToken_),
                                          std::move(trackerInfo),
                                          layerNrConv_);
 }