Inheritance diagram for CTPPSGeometryESModule:

Classes
struct	GDTokens

Public Member Functions
	CTPPSGeometryESModule (const edm::ParameterSet &)

	~CTPPSGeometryESModule () override

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

	ESProducer (const 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 const &	operator= (const 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 Member Functions
std::vector< int >	fillCopyNos (TGeoIterator &it)

template<typename REC >
std::unique_ptr< DetGeomDesc >	produceGD (IdealGeometryRecord const &, const std::optional< REC > &, GDTokens< REC > const &, const char *name)

std::unique_ptr< DetGeomDesc >	produceIdealGD (const IdealGeometryRecord &)

std::unique_ptr< DetGeomDesc >	produceMisalignedGD (const VeryForwardMisalignedGeometryRecord &)

std::unique_ptr< CTPPSGeometry >	produceMisalignedTG (const VeryForwardMisalignedGeometryRecord &)

std::unique_ptr< DetGeomDesc >	produceRealGD (const VeryForwardRealGeometryRecord &)

std::unique_ptr< CTPPSGeometry >	produceRealTG (const VeryForwardRealGeometryRecord &)

Static Private Member Functions
static std::unique_ptr< DetGeomDesc >	applyAlignments (const DetGeomDesc &, const CTPPSRPAlignmentCorrectionsData *)

Private Attributes
edm::ESGetToken< cms::DDCompactView, IdealGeometryRecord >	dd4hepToken_

edm::ESGetToken< DDCompactView, IdealGeometryRecord >	ddToken_

const edm::ESGetToken< DetGeomDesc, VeryForwardMisalignedGeometryRecord >	dgdMisToken_

const edm::ESGetToken< DetGeomDesc, VeryForwardRealGeometryRecord >	dgdRealToken_

const bool	fromDD4hep_

const GDTokens< RPMisalignedAlignmentRecord >	gdMisTokens_

const GDTokens< RPRealAlignmentRecord >	gdRealTokens_

const unsigned int	verbosity_

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
template<typename T >
auto	setWhatProduced (T iThis, const char iLabel)

template<typename T >
auto	setWhatProduced (T *iThis, const es::Label &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 TArg >
ESConsumesCollectorT< TRecord >	setWhatProduced (T iThis, TReturn(T ::iMethod)(const TRecord &), const TArg &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 46 of file CTPPSGeometryESModule.cc.

Constructor & Destructor Documentation

◆ CTPPSGeometryESModule()

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

Definition at line 93 of file CTPPSGeometryESModule.cc.

     : verbosity_(iConfig.getUntrackedParameter<unsigned int>("verbosity")),
       fromDD4hep_(iConfig.getUntrackedParameter<bool>("fromDD4hep", false)),
       gdRealTokens_{setWhatProduced(this, &CTPPSGeometryESModule::produceRealGD)},
       gdMisTokens_{setWhatProduced(this, &CTPPSGeometryESModule::produceMisalignedGD)},
       dgdRealToken_{
           setWhatProduced(this, &CTPPSGeometryESModule::produceRealTG).consumes<DetGeomDesc>(edm::ESInputTag())},
       dgdMisToken_{
           setWhatProduced(this, &CTPPSGeometryESModule::produceMisalignedTG).consumes<DetGeomDesc>(edm::ESInputTag())} {
   auto c = setWhatProduced(this, &CTPPSGeometryESModule::produceIdealGD);
  
   if (!fromDD4hep_) {
     ddToken_ = c.consumes<DDCompactView>(edm::ESInputTag("", iConfig.getParameter<std::string>("compactViewTag")));
   } else {
     dd4hepToken_ =
         c.consumes<cms::DDCompactView>(edm::ESInputTag("", iConfig.getParameter<std::string>("compactViewTag")));
   }

References produceRealGD(), and edm::ESProducer::setWhatProduced().

◆ ~CTPPSGeometryESModule()

CTPPSGeometryESModule::~CTPPSGeometryESModule ( )

inlineoverride

Definition at line 49 of file CTPPSGeometryESModule.cc.

50 {}

Member Function Documentation

◆ applyAlignments()

std::unique_ptr< DetGeomDesc > CTPPSGeometryESModule::applyAlignments	(	const DetGeomDesc &	idealDetRoot,
		const CTPPSRPAlignmentCorrectionsData *	alignments
	)

staticprivate

Definition at line 124 of file CTPPSGeometryESModule.cc.

                                                                                                                        {
   std::deque<const DetGeomDesc*> bufferIdealGeo;
   bufferIdealGeo.emplace_back(&idealDetRoot);
  
   std::deque<DetGeomDesc*> bufferAlignedGeo;
   DetGeomDesc* alignedDetRoot = new DetGeomDesc(idealDetRoot, DetGeomDesc::cmWithoutChildren);
   bufferAlignedGeo.emplace_back(alignedDetRoot);
  
   while (!bufferIdealGeo.empty()) {
     const DetGeomDesc* idealDet = bufferIdealGeo.front();
     DetGeomDesc* alignedDet = bufferAlignedGeo.front();
     bufferIdealGeo.pop_front();
     bufferAlignedGeo.pop_front();
  
     const std::string name = alignedDet->name();
  
     // Is it sensor? If yes, apply full sensor alignments
     if (name == DDD_TOTEM_RP_SENSOR_NAME || name == DDD_CTPPS_DIAMONDS_SEGMENT_NAME ||
         name == DDD_CTPPS_UFSD_SEGMENT_NAME || name == DDD_CTPPS_PIXELS_SENSOR_NAME ||
         name == DDD_CTPPS_PIXELS_SENSOR_NAME_2x2 || std::regex_match(name, std::regex(DDD_TOTEM_TIMING_SENSOR_TMPL))) {
       unsigned int plId = alignedDet->geographicalID();
  
       if (alignments) {
         const auto& ac = alignments->getFullSensorCorrection(plId);
         alignedDet->applyAlignment(ac);
       }
     }
  
     // Is it RP box? If yes, apply RP alignments
     if (name == DDD_TOTEM_RP_RP_NAME || name == DDD_CTPPS_DIAMONDS_RP_NAME || name == DDD_CTPPS_PIXELS_RP_NAME ||
         name == DDD_TOTEM_TIMING_RP_NAME) {
       unsigned int rpId = alignedDet->geographicalID();
  
       if (alignments) {
         const auto& ac = alignments->getRPCorrection(rpId);
         alignedDet->applyAlignment(ac);
       }
     }
  
     // create and add children
     const auto& idealDetChildren = idealDet->components();
     for (unsigned int i = 0; i < idealDetChildren.size(); i++) {
       const DetGeomDesc* idealDetChild = idealDetChildren[i];
       bufferIdealGeo.emplace_back(idealDetChild);
  
       // create new node with the same information as in idealDetChild and add it as a child of alignedDet
       DetGeomDesc* alignedDetChild = new DetGeomDesc(*idealDetChild, DetGeomDesc::cmWithoutChildren);
       alignedDet->addComponent(alignedDetChild);
  
       bufferAlignedGeo.emplace_back(alignedDetChild);
     }
   }
   return std::unique_ptr<DetGeomDesc>(alignedDetRoot);

References DetGeomDesc::addComponent(), DetGeomDesc::applyAlignment(), DetGeomDesc::cmWithoutChildren, DetGeomDesc::components(), DDD_CTPPS_DIAMONDS_RP_NAME, DDD_CTPPS_DIAMONDS_SEGMENT_NAME, DDD_CTPPS_PIXELS_RP_NAME, DDD_CTPPS_PIXELS_SENSOR_NAME, DDD_CTPPS_PIXELS_SENSOR_NAME_2x2, DDD_CTPPS_UFSD_SEGMENT_NAME, DDD_TOTEM_RP_RP_NAME, DDD_TOTEM_RP_SENSOR_NAME, DDD_TOTEM_TIMING_RP_NAME, DDD_TOTEM_TIMING_SENSOR_TMPL, DetGeomDesc::geographicalID(), CTPPSRPAlignmentCorrectionsData::getFullSensorCorrection(), CTPPSRPAlignmentCorrectionsData::getRPCorrection(), mps_fire::i, Skims_PA_cff::name, DetGeomDesc::name(), year_2016_postTS2_cff::rpId, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by produceGD().

◆ fillCopyNos()

std::vector<int> CTPPSGeometryESModule::fillCopyNos ( TGeoIterator & it )

private

◆ fillDescriptions()

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

static

Definition at line 112 of file CTPPSGeometryESModule.cc.

                                                                                        {
   edm::ParameterSetDescription desc;
   desc.addUntracked<unsigned int>("verbosity", 1);
   desc.add<std::string>("compactViewTag", std::string());
   desc.addUntracked<bool>("fromDD4hep", false);
   descriptions.add("CTPPSGeometryESModule", desc);

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, and AlCaHLTBitMon_QueryRunRegistry::string.

◆ produceGD()

template<typename REC >

std::unique_ptr< DetGeomDesc > CTPPSGeometryESModule::produceGD	(	IdealGeometryRecord const &	iIdealRec,
		const std::optional< REC > &	iAlignRec,
		GDTokens< REC > const &	iTokens,
		const char *	name
	)

private

Definition at line 199 of file CTPPSGeometryESModule.cc.

                                                                                 {
   // get the input GeometricalDet
   auto const& idealGD = iIdealRec.get(iTokens.idealGDToken_);
  
   // load alignments
   CTPPSRPAlignmentCorrectionsData const* alignments = nullptr;
   if (iAlignRec) {
     auto alignmentsHandle = iAlignRec->getHandle(iTokens.alignmentToken_);
     if (alignmentsHandle.isValid()) {
       alignments = alignmentsHandle.product();
     }
   }
  
   if (verbosity_) {
     if (alignments) {
       edm::LogVerbatim(name) << ">> " << name << " > Real geometry: " << alignments->getRPMap().size() << " RP and "
                              << alignments->getSensorMap().size() << " sensor alignments applied.";
     } else {
       edm::LogVerbatim(name) << ">> " << name << " > Real geometry: No alignment applied.";
     }
   }
  
   return applyAlignments(idealGD, alignments);

References CTPPSGeometryESModule::GDTokens< ALIGNMENT_REC >::alignmentToken_, applyAlignments(), edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), CTPPSRPAlignmentCorrectionsData::getRPMap(), CTPPSRPAlignmentCorrectionsData::getSensorMap(), CTPPSGeometryESModule::GDTokens< ALIGNMENT_REC >::idealGDToken_, Skims_PA_cff::name, and verbosity_.

Referenced by produceMisalignedGD(), and produceRealGD().

◆ produceIdealGD()

std::unique_ptr< DetGeomDesc > CTPPSGeometryESModule::produceIdealGD ( const IdealGeometryRecord & iRecord )

private

Definition at line 180 of file CTPPSGeometryESModule.cc.

                                                                                                    {
   if (!fromDD4hep_) {
     // Get the DDCompactView from EventSetup
     auto const& myCompactView = iRecord.get(ddToken_);
  
     // Build geo from compact view.
     return detgeomdescbuilder::buildDetGeomDescFromCompactView(myCompactView);
   }
  
   else {
     // Get the DDCompactView from EventSetup
     auto const& myCompactView = iRecord.get(dd4hepToken_);
  
     // Build geo from compact view.
     return detgeomdescbuilder::buildDetGeomDescFromCompactView(myCompactView);
   }

References detgeomdescbuilder::buildDetGeomDescFromCompactView(), dd4hepToken_, ddToken_, fromDD4hep_, and edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get().

◆ produceMisalignedGD()

std::unique_ptr< DetGeomDesc > CTPPSGeometryESModule::produceMisalignedGD ( const VeryForwardMisalignedGeometryRecord & iRecord )

private

Definition at line 236 of file CTPPSGeometryESModule.cc.

                                                         {
   return produceGD(iRecord.getRecord<IdealGeometryRecord>(),
                    iRecord.tryToGetRecord<RPMisalignedAlignmentRecord>(),
                    gdMisTokens_,
                    "CTPPSGeometryESModule::produceMisalignedGD");

References gdMisTokens_, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), produceGD(), and edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::tryToGetRecord().

◆ produceMisalignedTG()

std::unique_ptr< CTPPSGeometry > CTPPSGeometryESModule::produceMisalignedTG ( const VeryForwardMisalignedGeometryRecord & iRecord )

private

Definition at line 254 of file CTPPSGeometryESModule.cc.

                                                         {
   auto const& gD = iRecord.get(dgdMisToken_);
  
   return std::make_unique<CTPPSGeometry>(&gD, verbosity_);

References dgdMisToken_, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), and verbosity_.

◆ produceRealGD()

std::unique_ptr< DetGeomDesc > CTPPSGeometryESModule::produceRealGD ( const VeryForwardRealGeometryRecord & iRecord )

private

Definition at line 227 of file CTPPSGeometryESModule.cc.

                                                                                                             {
   return produceGD(iRecord.getRecord<IdealGeometryRecord>(),
                    iRecord.tryToGetRecord<RPRealAlignmentRecord>(),
                    gdRealTokens_,
                    "CTPPSGeometryESModule::produceRealGD");

References gdRealTokens_, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), produceGD(), and edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::tryToGetRecord().

Referenced by CTPPSGeometryESModule().

◆ produceRealTG()

std::unique_ptr< CTPPSGeometry > CTPPSGeometryESModule::produceRealTG ( const VeryForwardRealGeometryRecord & iRecord )

private

Definition at line 246 of file CTPPSGeometryESModule.cc.

                                                                                                               {
   auto const& gD = iRecord.get(dgdRealToken_);
  
   return std::make_unique<CTPPSGeometry>(&gD, verbosity_);