Inheritance diagram for MkFitGeometryESProducer:

Classes
struct	GapCollector

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

ESProxyIndex 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< ESProxyIndex > >	updateFromMayConsumes (unsigned int iIndex, const Record &iRecord) const

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &) final

	~ESProducer () noexcept(false) override

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

	ESProxyFactoryProducer (const ESProxyFactoryProducer &)=delete

const ESProxyFactoryProducer &	operator= (const ESProxyFactoryProducer &)=delete

	~ESProxyFactoryProducer () noexcept(false) override

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

	DataProxyProvider ()

	DataProxyProvider (const DataProxyProvider &)=delete

const ComponentDescription &	description () const

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

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

bool	isUsingRecord (const EventSetupRecordKey &key) const

KeyedProxies &	keyedProxies (const EventSetupRecordKey &iRecordKey, unsigned int iovIndex=0)

const DataProxyProvider &	operator= (const DataProxyProvider &)=delete

void	setAppendToDataLabel (const edm::ParameterSet &)

void	setDescription (const ComponentDescription &iDescription)

std::set< EventSetupRecordKey >	usingRecords () const

virtual	~DataProxyProvider () noexcept(false)

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

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

Private Types
typedef std::unordered_map< int, GapCollector >	layer_gap_map_t

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

void	addPixEGeometry (mkfit::TrackerInfo &trk_info)

void	addTECGeometry (mkfit::TrackerInfo &trk_info)

void	addTIBGeometry (mkfit::TrackerInfo &trk_info)

void	addTIDGeometry (mkfit::TrackerInfo &trk_info)

void	addTOBGeometry (mkfit::TrackerInfo &trk_info)

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

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

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

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::ESProxyFactoryProducer
using	EventSetupRecordKey = eventsetup::EventSetupRecordKey

Protected Types inherited from edm::eventsetup::DataProxyProvider
using	KeyedProxiesVector = std::vector< std::pair< DataKey, std::shared_ptr< DataProxy > >>

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::ESProxyFactoryProducer
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::ProxyFactoryBase > iFactory, const std::string &iLabel=std::string())

KeyedProxiesVector	registerProxies (const EventSetupRecordKey &, unsigned int iovIndex) override

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

void	usingRecordWithKey (const EventSetupRecordKey &key)

Detailed Description

Definition at line 28 of file MkFitGeometryESProducer.cc.

Member Typedef Documentation

◆ layer_gap_map_t

typedef std::unordered_map<int, GapCollector> MkFitGeometryESProducer::layer_gap_map_t

private

Definition at line 58 of file MkFitGeometryESProducer.cc.

Constructor & Destructor Documentation

◆ MkFitGeometryESProducer()

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

Definition at line 78 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 )

private

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

◆ addPixEGeometry()

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

private

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

◆ addTECGeometry()

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

private

Definition at line 323 of file MkFitGeometryESProducer.cc.

References TrackerGeometry::detsTEC(), fillShapeAndPlacement(), pixelTopology::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, &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 )

private

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

◆ addTIDGeometry()

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

private

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

◆ addTOBGeometry()

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

private

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

◆ considerPoint()

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

private

Definition at line 169 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 85 of file MkFitGeometryESProducer.cc.

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

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

◆ fillShapeAndPlacement()

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

private

Definition at line 175 of file MkFitGeometryESProducer.cc.

References b, b2, considerPoint(), mkfit::LayerNumberConverter::convertLayerNumber(), PVValHelper::dx, PVValHelper::dy, PVValHelper::dz, Exception, GeomDet::geographicalId(), mps_fire::i, TrackerTopology::isStereo(), TrackerTopology::layer(), mkfit::TrackerInfo::layer_nc(), layerNrConv_, AlCaHLTBitMon_ParallelJobs::p, PV3DBase< T, PVType, FrameType >::perp2(), PosEndcap, GeomDet::position(), DetId::rawId(), GeomDet::rotation(), TrackerTopology::side(), DetId::subdetId(), GeomDet::surface(), Surface::toGlobal(), trackerTopo_, useMatched, x, TkRotation< T >::x(), geometryCSVtoXML::xy, z, and TkRotation< T >::z().

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

                                                                               {
   DetId detid = det->geographicalId();
 
   float xy[4][2];
   float dz;
   const Bounds *b = &((det->surface()).bounds());
 
   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];
 
 #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
 
 #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));
 #ifdef DUMP_MKF_GEO
   printf("  subdet=%d layer=%d side=%d is_stereo=%d --> mkflayer=%d\n",
          detid.subdetId(),
          trackerTopo_->layer(detid),
          trackerTopo_->side(detid),
          trackerTopo_->isStereo(detid),
          lay);
 #endif
 
   mkfit::LayerInfo &layer_info = trk_info.layer_nc(lay);
   if (lgc_map) {
     (*lgc_map)[lay].reset_current();
   }
   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);
     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();
   }
   // 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()});
   // 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));
 }

◆ produce()

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

Definition at line 373 of file MkFitGeometryESProducer.cc.

References addPixBGeometry(), addPixEGeometry(), addTECGeometry(), addTIBGeometry(), addTIDGeometry(), addTOBGeometry(), cms::cuda::assert(), Exception, geomToken_, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), mps_fire::i, TrackerGeometry::isThere(), layerNrConv_, SiStripPI::max, eostools::move(), GeomDetEnumerators::P1PXB, GeomDetEnumerators::P1PXEC, GeomDetEnumerators::P2OTB, GeomDetEnumerators::P2OTEC, GeomDetEnumerators::P2PXB, GeomDetEnumerators::P2PXEC, mkfit::phase2, mkfit::LayerNumberConverter::reset(), mathSSE::sqrt(), trackerGeom_, trackerToken_, trackerTopo_, and ttopoToken_.

                                                                                                       {
   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;
   } else if (trackerGeom_->isThere(GeomDetEnumerators::P2PXB) || trackerGeom_->isThere(GeomDetEnumerators::P2PXEC) ||
              trackerGeom_->isThere(GeomDetEnumerators::P2OTB) || trackerGeom_->isThere(GeomDetEnumerators::P2OTEC)) {
     edm::LogInfo("MkFitGeometryESProducer") << "Extracting PhaseII geometry";
     layerNrConv_.reset(mkfit::TkLayout::phase2);
     trackerInfo->create_layers(16, 22, 22);
     qBinDefaults = phase2QBins;
   } else {
     throw cms::Exception("UnimplementedFeature") << "unsupported / unknowen geometry version";
   }
 
   // Prepare layer boundaries for bounding-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);
   }
   // This is sort of CMS-phase1 specific ... but fireworks code uses it for PhaseII as well.
   addPixBGeometry(*trackerInfo);
   addPixEGeometry(*trackerInfo);
   addTIBGeometry(*trackerInfo);
   addTIDGeometry(*trackerInfo);
   addTOBGeometry(*trackerInfo);
   addTECGeometry(*trackerInfo);
 
   // r_in/out kept as squares until here, root them
   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);
   }
 #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_);
 }