Inheritance diagram for CTPPSGeometryESModule:

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

	~CTPPSGeometryESModule () override

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

template<typename REC , typename GEO >
std::unique_ptr< DetGeomDesc >	produceGD (const GEO &, const std::optional< REC > &, edm::ESGetToken< DetGeomDesc, GEO > const &, edm::ESGetToken< CTPPSRPAlignmentCorrectionsData, REC > const &, const char *name)

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

std::unique_ptr< DetGeomDesc >	produceIdealGDFromPreprocessedDB (const VeryForwardIdealGeometryRecord &)

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

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

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

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

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

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

Private Attributes
const bool	buildMisalignedGeometry_

edm::ESGetToken< PDetGeomDesc, VeryForwardIdealGeometryRecord >	dbToken_

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

edm::ESGetToken< DDCompactView, IdealGeometryRecord >	ddToken_

edm::ESGetToken< DetGeomDesc, VeryForwardMisalignedGeometryRecord >	dgdMisToken_

edm::ESGetToken< DetGeomDesc, VeryForwardRealGeometryRecord >	dgdRealToken_

const bool	fromDD4hep_

const bool	fromPreprocessedDB_

edm::ESGetToken< DetGeomDesc, VeryForwardIdealGeometryRecord >	idealDBGDToken2_

edm::ESGetToken< DetGeomDesc, VeryForwardIdealGeometryRecord >	idealDBGDToken_

edm::ESGetToken< DetGeomDesc, IdealGeometryRecord >	idealGDToken2_

edm::ESGetToken< DetGeomDesc, IdealGeometryRecord >	idealGDToken_

const bool	isRun2_

edm::ESGetToken< CTPPSRPAlignmentCorrectionsData, RPMisalignedAlignmentRecord >	misAlignmentToken_

edm::ESGetToken< CTPPSRPAlignmentCorrectionsData, RPRealAlignmentRecord >	realAlignmentToken_

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
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 52 of file CTPPSGeometryESModule.cc.

Constructor & Destructor Documentation

◆ CTPPSGeometryESModule()

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

Definition at line 99 of file CTPPSGeometryESModule.cc.

References buildMisalignedGeometry_, HltBtagPostValidation_cff::c, alignmentValidation::c1, dbToken_, dd4hepToken_, ddToken_, dgdMisToken_, dgdRealToken_, fromDD4hep_, fromPreprocessedDB_, edm::ParameterSet::getParameter(), idealDBGDToken2_, idealDBGDToken_, idealGDToken2_, idealGDToken_, misAlignmentToken_, produceIdealGD(), produceIdealGDFromPreprocessedDB(), produceMisalignedGD(), produceMisalignedGDFromPreprocessedDB(), produceMisalignedTG(), produceRealGD(), produceRealGDFromPreprocessedDB(), produceRealTG(), realAlignmentToken_, edm::ESProducer::setWhatProduced(), and AlCaHLTBitMon_QueryRunRegistry::string.

     : verbosity_(iConfig.getUntrackedParameter<unsigned int>("verbosity")),
       buildMisalignedGeometry_(iConfig.getParameter<bool>("buildMisalignedGeometry")),
       isRun2_(iConfig.getParameter<bool>("isRun2")),
       fromPreprocessedDB_(iConfig.getUntrackedParameter<bool>("fromPreprocessedDB", false)),
       fromDD4hep_(iConfig.getUntrackedParameter<bool>("fromDD4hep", false)) {
   if (fromPreprocessedDB_) {
     auto c = setWhatProduced(this, &CTPPSGeometryESModule::produceIdealGDFromPreprocessedDB);
     dbToken_ = c.consumes<PDetGeomDesc>(edm::ESInputTag("", iConfig.getParameter<std::string>("dbTag")));
 
     auto c1 = setWhatProduced(this, &CTPPSGeometryESModule::produceRealGDFromPreprocessedDB);
     idealDBGDToken_ = c1.consumesFrom<DetGeomDesc, VeryForwardIdealGeometryRecord>(edm::ESInputTag());
     realAlignmentToken_ = c1.consumesFrom<CTPPSRPAlignmentCorrectionsData, RPRealAlignmentRecord>(edm::ESInputTag());
 
     if (buildMisalignedGeometry_) {
       auto c2 = setWhatProduced(this, &CTPPSGeometryESModule::produceMisalignedGDFromPreprocessedDB);
       idealDBGDToken2_ = c2.consumesFrom<DetGeomDesc, VeryForwardIdealGeometryRecord>(edm::ESInputTag());
       misAlignmentToken_ =
           c2.consumesFrom<CTPPSRPAlignmentCorrectionsData, RPMisalignedAlignmentRecord>(edm::ESInputTag());
     }
   } else if (!fromDD4hep_) {
     auto c = setWhatProduced(this, &CTPPSGeometryESModule::produceIdealGD);
     ddToken_ = c.consumes<DDCompactView>(edm::ESInputTag("", iConfig.getParameter<std::string>("compactViewTag")));
 
     auto c1 = setWhatProduced(this, &CTPPSGeometryESModule::produceRealGD);
     idealGDToken_ = c1.consumesFrom<DetGeomDesc, IdealGeometryRecord>(edm::ESInputTag());
     realAlignmentToken_ = c1.consumesFrom<CTPPSRPAlignmentCorrectionsData, RPRealAlignmentRecord>(edm::ESInputTag());
 
     if (buildMisalignedGeometry_) {
       auto c2 = setWhatProduced(this, &CTPPSGeometryESModule::produceMisalignedGD);
       idealGDToken2_ = c2.consumesFrom<DetGeomDesc, IdealGeometryRecord>(edm::ESInputTag());
       misAlignmentToken_ =
           c2.consumesFrom<CTPPSRPAlignmentCorrectionsData, RPMisalignedAlignmentRecord>(edm::ESInputTag());
     }
   } else {
     auto c = setWhatProduced(this, &CTPPSGeometryESModule::produceIdealGD);
     dd4hepToken_ =
         c.consumes<cms::DDCompactView>(edm::ESInputTag("", iConfig.getParameter<std::string>("compactViewTag")));
 
     auto c1 = setWhatProduced(this, &CTPPSGeometryESModule::produceRealGD);
     idealGDToken_ = c1.consumesFrom<DetGeomDesc, IdealGeometryRecord>(edm::ESInputTag());
     realAlignmentToken_ = c1.consumesFrom<CTPPSRPAlignmentCorrectionsData, RPRealAlignmentRecord>(edm::ESInputTag());
 
     if (buildMisalignedGeometry_) {
       auto c2 = setWhatProduced(this, &CTPPSGeometryESModule::produceMisalignedGD);
       idealGDToken2_ = c2.consumesFrom<DetGeomDesc, IdealGeometryRecord>(edm::ESInputTag());
       misAlignmentToken_ =
           c2.consumesFrom<CTPPSRPAlignmentCorrectionsData, RPMisalignedAlignmentRecord>(edm::ESInputTag());
     }
   }
 
   auto c_RTG = setWhatProduced(this, &CTPPSGeometryESModule::produceRealTG);
   dgdRealToken_ = c_RTG.consumes<DetGeomDesc>(edm::ESInputTag());
 
   if (buildMisalignedGeometry_) {
     auto c_MTG = setWhatProduced(this, &CTPPSGeometryESModule::produceMisalignedTG);
     dgdMisToken_ = c_MTG.consumes<DetGeomDesc>(edm::ESInputTag());
   }
 }

◆ ~CTPPSGeometryESModule()

CTPPSGeometryESModule::~CTPPSGeometryESModule ( )

inlineoverride

Definition at line 55 of file CTPPSGeometryESModule.cc.

55 {}

Member Function Documentation

◆ fillCopyNos()

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

private

◆ fillDescriptions()

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

static

Definition at line 159 of file CTPPSGeometryESModule.cc.

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

                                                                                        {
   edm::ParameterSetDescription desc;
   desc.addUntracked<unsigned int>("verbosity", 1);
   desc.add<bool>("buildMisalignedGeometry", false)->setComment("switch if misaligned geometry shall be built");
   desc.add<bool>("isRun2", false)->setComment("Switch to legacy (2017-18) definition of diamond geometry");
   desc.add<std::string>("dbTag", std::string());
   desc.add<std::string>("compactViewTag", std::string());
   desc.addUntracked<bool>("fromPreprocessedDB", false);
   desc.addUntracked<bool>("fromDD4hep", false);
   descriptions.add("CTPPSGeometryESModule", desc);
 }

◆ produceGD()

template<typename REC , typename GEO >

std::unique_ptr< DetGeomDesc > CTPPSGeometryESModule::produceGD	(	const GEO &	iIdealRec,
		const std::optional< REC > &	iAlignRec,
		edm::ESGetToken< DetGeomDesc, GEO > const &	iGDToken,
		edm::ESGetToken< CTPPSRPAlignmentCorrectionsData, REC > const &	iAlignToken,
		const char *	name
	)

private

Definition at line 202 of file CTPPSGeometryESModule.cc.

References CTPPSGeometryESCommon::applyAlignments(), CTPPSRPAlignmentCorrectionsData::getRPMap(), CTPPSRPAlignmentCorrectionsData::getSensorMap(), Skims_PA_cff::name, and verbosity_.

Referenced by produceMisalignedGD(), produceMisalignedGDFromPreprocessedDB(), produceRealGD(), and produceRealGDFromPreprocessedDB().

                       {
   // get the input GeometricalDet
   auto const& idealGD = iIdealRec.get(iGDToken);
 
   // load alignments
   CTPPSRPAlignmentCorrectionsData const* alignments = nullptr;
   if (iAlignRec) {
     auto alignmentsHandle = iAlignRec->getHandle(iAlignToken);
     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 CTPPSGeometryESCommon::applyAlignments(idealGD, alignments);
 }

◆ produceIdealGD()

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

private

Definition at line 171 of file CTPPSGeometryESModule.cc.

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

Referenced by CTPPSGeometryESModule().

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

◆ produceIdealGDFromPreprocessedDB()

std::unique_ptr< DetGeomDesc > CTPPSGeometryESModule::produceIdealGDFromPreprocessedDB ( const VeryForwardIdealGeometryRecord & iRecord )

private

Definition at line 189 of file CTPPSGeometryESModule.cc.

References dbToken_, and edm::eventsetup::EventSetupRecordImplementation< T >::get().

Referenced by CTPPSGeometryESModule().

                                                    {
   // Get the PDetGeomDesc from EventSetup
   auto const& myDB = iRecord.get(dbToken_);
 
   edm::LogInfo("CTPPSGeometryESModule") << " myDB size = " << myDB.container_.size();
 
   // Build geo from PDetGeomDesc DB object.
   auto pdet = std::make_unique<DetGeomDesc>(myDB);
   return pdet;
 }

◆ produceMisalignedGD()

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

private

Definition at line 264 of file CTPPSGeometryESModule.cc.

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

Referenced by CTPPSGeometryESModule().

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

◆ produceMisalignedGDFromPreprocessedDB()

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

private

Definition at line 243 of file CTPPSGeometryESModule.cc.

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

Referenced by CTPPSGeometryESModule().

                                                         {
   return produceGD(iRecord.getRecord<VeryForwardIdealGeometryRecord>(),
                    iRecord.tryToGetRecord<RPMisalignedAlignmentRecord>(),
                    idealDBGDToken2_,
                    misAlignmentToken_,
                    "CTPPSGeometryESModule::produceMisalignedGDFromPreprocessedDB");
 }

◆ produceMisalignedTG()

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

private

Definition at line 283 of file CTPPSGeometryESModule.cc.

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

Referenced by CTPPSGeometryESModule().

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

◆ produceRealGD()

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

private

Definition at line 254 of file CTPPSGeometryESModule.cc.

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

Referenced by CTPPSGeometryESModule().

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

◆ produceRealGDFromPreprocessedDB()

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

private

Definition at line 232 of file CTPPSGeometryESModule.cc.

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

Referenced by CTPPSGeometryESModule().

                                                   {
   return produceGD(iRecord.getRecord<VeryForwardIdealGeometryRecord>(),
                    iRecord.tryToGetRecord<RPRealAlignmentRecord>(),
                    idealDBGDToken_,
                    realAlignmentToken_,
                    "CTPPSGeometryESModule::produceRealGDFromPreprocessedDB");
 }

◆ produceRealTG()

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

private

Definition at line 275 of file CTPPSGeometryESModule.cc.

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

Referenced by CTPPSGeometryESModule().

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