Inheritance diagram for GEMGeometryESModule:

Public Member Functions
	GEMGeometryESModule (const edm::ParameterSet &p)
	Constructor. More...

std::unique_ptr< GEMGeometry >	produce (const MuonGeometryRecord &record)
	Produce GEMGeometry. More...

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 &)
	Define the cfi file. More...

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

Private Attributes
edm::ESGetToken < AlignmentErrorsExtended, GEMAlignmentErrorExtendedRcd >	alignmentErrorsToken_

const std::string	alignmentsLabel_

edm::ESGetToken< Alignments, GEMAlignmentRcd >	alignmentsToken_

bool	applyAlignment_

edm::ESGetToken< DDCompactView, IdealGeometryRecord >	cpvToken_

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

const bool	fromDD4hep_

const bool	fromDDD_

edm::ESGetToken< Alignments, GlobalPositionRcd >	globalPositionToken_

edm::ESGetToken < MuonGeometryConstants, IdealGeometryRecord >	mdcToken_

edm::ESGetToken < RecoIdealGeometry, GEMRecoGeometryRcd >	riggemToken_

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 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 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 40 of file GEMGeometryESModule.cc.

Constructor & Destructor Documentation

GEMGeometryESModule::GEMGeometryESModule ( const edm::ParameterSet & p )

Constructor.

Definition at line 66 of file GEMGeometryESModule.cc.

References alignmentErrorsToken_, alignmentsLabel_, alignmentsToken_, applyAlignment_, cpvToken_, dd4hepcpvToken_, fromDD4hep_, fromDDD_, edm::ParameterSet::getParameter(), globalPositionToken_, mdcToken_, riggemToken_, edm::ESProducer::setWhatProduced(), and AlCaHLTBitMon_QueryRunRegistry::string.

     : fromDDD_{p.getParameter<bool>("fromDDD")},
       fromDD4hep_{p.getParameter<bool>("fromDD4hep")},
       applyAlignment_(p.getParameter<bool>("applyAlignment")),
       alignmentsLabel_(p.getParameter<std::string>("alignmentsLabel")) {
   auto cc = setWhatProduced(this);
   if (fromDDD_) {
     cpvToken_ = cc.consumes();
     mdcToken_ = cc.consumes();
   } else if (fromDD4hep_) {
     dd4hepcpvToken_ = cc.consumes();
     mdcToken_ = cc.consumes();
   } else {
     riggemToken_ = cc.consumes();
   }
   if (applyAlignment_) {
     globalPositionToken_ = cc.consumes(edm::ESInputTag{"", alignmentsLabel_});
     alignmentsToken_ = cc.consumes(edm::ESInputTag{"", alignmentsLabel_});
     alignmentErrorsToken_ = cc.consumes(edm::ESInputTag{"", alignmentsLabel_});
   }
   edm::LogVerbatim("GEMGeometry") << "GEMGeometryESModule::initailized with flags " << fromDDD_ << ":" << fromDD4hep_;
 }

Member Function Documentation

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

static

Define the cfi file.

Definition at line 89 of file GEMGeometryESModule.cc.

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

                                                                                      {
   edm::ParameterSetDescription desc;
   desc.add<bool>("fromDDD", true);
   desc.add<bool>("fromDD4hep", false);
   desc.add<bool>("applyAlignment", false);
   desc.add<std::string>("alignmentsLabel", "");
   descriptions.add("gemGeometry", desc);
 }

std::unique_ptr< GEMGeometry > GEMGeometryESModule::produce ( const MuonGeometryRecord & record )

Produce GEMGeometry.

Definition at line 98 of file GEMGeometryESModule.cc.

References alignmentErrorsToken_, alignmentsLabel_, alignmentsToken_, applyAlignment_, GeometryAligner::applyAlignments(), GEMGeometryBuilderFromCondDB::build(), GEMGeometryBuilder::build(), cpvToken_, dd4hepcpvToken_, align::DetectorGlobalPosition(), fromDD4hep_, fromDDD_, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getTransientHandle(), globalPositionToken_, mdcToken_, DetId::Muon, edm::ESTransientHandle< T >::product(), and riggemToken_.

                                                                                         {
   auto gemGeometry = std::make_unique<GEMGeometry>();
 
   if (fromDDD_) {
     edm::LogVerbatim("GEMGeometry") << "GEMGeometryESModule::produce :: GEMGeometryBuilder builder ddd";
     auto cpv = record.getTransientHandle(cpvToken_);
     const auto& mdc = record.get(mdcToken_);
     GEMGeometryBuilder builder;
     builder.build(*gemGeometry, cpv.product(), mdc);
   } else if (fromDD4hep_) {
     edm::LogVerbatim("GEMGeometry") << "GEMGeometryESModule::produce :: GEMGeometryBuilder builder dd4hep";
     edm::ESTransientHandle<cms::DDCompactView> cpv = record.getTransientHandle(dd4hepcpvToken_);
     const auto& mdc = record.get(mdcToken_);
     GEMGeometryBuilder builder;
     builder.build(*gemGeometry, cpv.product(), mdc);
   } else {
     edm::LogVerbatim("GEMGeometry") << "GEMGeometryESModule::produce :: GEMGeometryBuilder builder db";
     const auto& riggem = record.get(riggemToken_);
     GEMGeometryBuilderFromCondDB builder;
     builder.build(*gemGeometry, riggem);
   }
 
   if (applyAlignment_) {
     const auto& globalPosition = record.get(globalPositionToken_);
     const auto& alignments = record.get(alignmentsToken_);
     const auto& alignmentErrors = record.get(alignmentErrorsToken_);
 
     // No alignment records, assume ideal geometry is wanted
     if (alignments.empty() && alignmentErrors.empty() && globalPosition.empty()) {
       edm::LogInfo("Config") << "@SUB=GEMGeometryRecord::produce"
                              << "Alignment(Error)s and global position (label '" << alignmentsLabel_
                              << "') empty: it is assumed fake and will not apply.";
     } else {
       GeometryAligner aligner;
       aligner.applyAlignments<GEMGeometry>(gemGeometry.get(),
                                            &alignments,
                                            &alignmentErrors,
                                            align::DetectorGlobalPosition(globalPosition, DetId(DetId::Muon)));
     }
   }
 
   return gemGeometry;
 }