Inheritance diagram for CSCGeometryESModule:

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

std::shared_ptr< CSCGeometry >	produce (const MuonGeometryRecord &record)
	Produce CSCGeometry. More...

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 &)
	Creation of configuration file. More...

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

Private Types
using	HostType = edm::ESProductHost< CSCGeometry, IdealGeometryRecord, CSCRecoGeometryRcd, CSCRecoDigiParametersRcd >

Private Member Functions
void	initCSCGeometry_ (const MuonGeometryRecord &, std::shared_ptr< HostType > &host)

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

const std::string	alignmentsLabel_

edm::ESGetToken< Alignments, CSCAlignmentRcd >	alignmentsToken_

bool	applyAlignment_

edm::ESGetToken< DDCompactView, IdealGeometryRecord >	cpvToken_

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

bool	debugV_

bool	fromDD4hep_

bool	fromDDD_

edm::ESGetToken< Alignments, GlobalPositionRcd >	globalPositionToken_

edm::ReusableObjectHolder< HostType >	holder_

edm::ESGetToken< MuonGeometryConstants, IdealGeometryRecord >	mdcToken_

const std::string	myLabel_

edm::ESGetToken< CSCRecoDigiParameters, CSCRecoDigiParametersRcd >	rdpToken_

edm::ESGetToken< RecoIdealGeometry, CSCRecoGeometryRcd >	rigToken_

bool	useCentreTIOffsets_

bool	useGangedStripsInME1a_

bool	useOnlyWiresInME1a_

bool	useRealWireGeometry_

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 49 of file CSCGeometryESModule.cc.

Member Typedef Documentation

◆ HostType

using CSCGeometryESModule::HostType = edm::ESProductHost<CSCGeometry, IdealGeometryRecord, CSCRecoGeometryRcd, CSCRecoDigiParametersRcd>

private

Definition at line 61 of file CSCGeometryESModule.cc.

Constructor & Destructor Documentation

◆ CSCGeometryESModule()

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

Constructor.

Definition at line 94 of file CSCGeometryESModule.cc.

References alignmentErrorsToken_, alignmentsLabel_, alignmentsToken_, applyAlignment_, gpuPixelDoublets::cc, cpvToken_, cpvTokendd4hep_, debugV_, fromDD4hep_, fromDDD_, globalPositionToken_, mdcToken_, myLabel_, AlCaHLTBitMon_ParallelJobs::p, rdpToken_, rigToken_, edm::ESProducer::setWhatProduced(), useCentreTIOffsets_, useGangedStripsInME1a_, useOnlyWiresInME1a_, and useRealWireGeometry_.

     : fromDDD_(p.getParameter<bool>("fromDDD")),
       fromDD4hep_(p.getParameter<bool>("fromDD4hep")),
       alignmentsLabel_(p.getParameter<std::string>("alignmentsLabel")),
       myLabel_(p.getParameter<std::string>("appendToDataLabel")) {
   auto cc = setWhatProduced(this);
 
   // Choose wire geometry modelling
   // We now _require_ some wire geometry specification in the CSCOrcaSpec.xml file
   // in the DDD Geometry.
   // Default as of transition to CMSSW is to use real values.
   // Alternative is to use pseudo-values which match reasonably closely
   // the calculated geometry values used up to and including ORCA_8_8_1.
   // (This was the default in ORCA.)
 
   useRealWireGeometry_ = p.getParameter<bool>("useRealWireGeometry");
 
   // Suppress strips altogether in ME1a region of ME11?
 
   useOnlyWiresInME1a_ = p.getParameter<bool>("useOnlyWiresInME1a");
 
   // Allow strips in ME1a region of ME11 but gang them?
   // Default is now to treat ME1a with ganged strips (e.g. in clusterizer)
 
   useGangedStripsInME1a_ = p.getParameter<bool>("useGangedStripsInME1a");
 
   if (useGangedStripsInME1a_)
     useOnlyWiresInME1a_ = false;  // override possible inconsistentcy
 
   // Use the backed-out offsets that correct the CTI
   useCentreTIOffsets_ = p.getParameter<bool>("useCentreTIOffsets");
 
   // Debug printout etc. in CSCGeometry etc.
 
   debugV_ = p.getUntrackedParameter<bool>("debugV", false);
 
   if (fromDDD_) {
     cpvToken_ = cc.consumes();
     mdcToken_ = cc.consumes();
   } else if (fromDD4hep_) {
     cpvTokendd4hep_ = cc.consumes();
     mdcToken_ = cc.consumes();
   } else {
     rigToken_ = cc.consumesFrom<RecoIdealGeometry, CSCRecoGeometryRcd>(edm::ESInputTag{});
     rdpToken_ = cc.consumesFrom<CSCRecoDigiParameters, CSCRecoDigiParametersRcd>(edm::ESInputTag{});
   }
 
   // Feed these value to where I need them
   applyAlignment_ = p.getParameter<bool>("applyAlignment");
   if (applyAlignment_) {
     globalPositionToken_ = cc.consumesFrom<Alignments, GlobalPositionRcd>(edm::ESInputTag{"", alignmentsLabel_});
     alignmentsToken_ = cc.consumesFrom<Alignments, CSCAlignmentRcd>(edm::ESInputTag{"", alignmentsLabel_});
     alignmentErrorsToken_ =
         cc.consumesFrom<AlignmentErrorsExtended, CSCAlignmentErrorExtendedRcd>(edm::ESInputTag{"", alignmentsLabel_});
   }
 
   edm::LogVerbatim("Geometry") << "@SUB=CSCGeometryESModule Label '" << myLabel_ << "' "
                                << (applyAlignment_ ? "looking for" : "IGNORING") << " alignment labels '"
                                << alignmentsLabel_ << "'.";
 }

Member Function Documentation

◆ fillDescriptions()

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

static

Creation of configuration file.

Definition at line 155 of file CSCGeometryESModule.cc.

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

                                                                                      {
   //
   // This cfi should be included to build the CSC geometry model.
   //
   // modelling flags (for completeness - internal defaults are already sane)
   // GF would like to have a shorter name (e.g. CSCGeometry), but since originally
   // there was no name, replace statements in other configs would not work anymore...
   edm::ParameterSetDescription desc;
   desc.add<bool>("fromDDD", true);
   desc.add<bool>("fromDD4hep", false);
   desc.add<std::string>("alignmentsLabel", "");
   desc.add<std::string>("appendToDataLabel", "");
   desc.add<bool>("useRealWireGeometry", true);
   desc.add<bool>("useOnlyWiresInME1a", false);
   desc.add<bool>("useGangedStripsInME1a", true);
   desc.add<bool>("useCentreTIOffsets", false);
   desc.add<bool>("applyAlignment", true);  //GF: to be abandoned
   desc.addUntracked<bool>("debugV", false);
   descriptions.add("CSCGeometryESModule", desc);
 }

◆ initCSCGeometry_()

void CSCGeometryESModule::initCSCGeometry_	(	const MuonGeometryRecord &	record,
		std::shared_ptr< HostType > &	host
	)

private

Definition at line 206 of file CSCGeometryESModule.cc.

References CSCGeometryBuilder::build(), CSCGeometryBuilderFromDDD::build(), query::host, edm::ESTransientHandle< T >::product(), and AlCaHarvesting_cff::record.

                                                                                                           {
   if (fromDDD_) {
     edm::LogVerbatim("CSCGeoemtryESModule") << "(0) CSCGeometryESModule  - DDD ";
     host->ifRecordChanges<IdealGeometryRecord>(record, [&host, &record, this](auto const& rec) {
       host->clear();
       edm::ESTransientHandle<DDCompactView> cpv = record.getTransientHandle(cpvToken_);
       const auto& mdc = rec.get(mdcToken_);
       CSCGeometryBuilderFromDDD builder;
       builder.build(*host, cpv.product(), mdc);
     });
   } else if (fromDD4hep_) {
     edm::LogVerbatim("CSCGeoemtryESModule") << "(0) CSCGeometryESModule  - DD4hep ";
     host->ifRecordChanges<IdealGeometryRecord>(record, [&host, &record, this](auto const& rec) {
       host->clear();
       edm::ESTransientHandle<cms::DDCompactView> cpv = record.getTransientHandle(cpvTokendd4hep_);
       const auto& mdc = rec.get(mdcToken_);
       CSCGeometryBuilderFromDDD builder;
       builder.build(*host, cpv.product(), mdc);
     });
   } else {
     bool recreateGeometry = false;
 
     host->ifRecordChanges<CSCRecoGeometryRcd>(record,
                                               [&recreateGeometry](auto const& rec) { recreateGeometry = true; });
 
     host->ifRecordChanges<CSCRecoDigiParametersRcd>(record,
                                                     [&recreateGeometry](auto const& rec) { recreateGeometry = true; });
     edm::LogVerbatim("CSCGeoemtryESModule") << "(0) CSCGeometryESModule  - DB recreateGeometry=false ";
     if (recreateGeometry) {
       edm::LogVerbatim("CSCGeoemtryESModule") << "(0) CSCGeometryESModule  - DB recreateGeometry=true ";
       host->clear();
       const auto& rig = record.get(rigToken_);
       const auto& rdp = record.get(rdpToken_);
       CSCGeometryBuilder cscgb;
       cscgb.build(*host, rig, rdp);
     }
   }
 }

◆ produce()

std::shared_ptr< CSCGeometry > CSCGeometryESModule::produce ( const MuonGeometryRecord & record )

Produce CSCGeometry.

Definition at line 176 of file CSCGeometryESModule.cc.

References GeometryAligner::applyAlignments(), align::DetectorGlobalPosition(), query::host, DetId::Muon, and AlCaHarvesting_cff::record.

                                                                                         {
   auto host = holder_.makeOrGet([this]() {
     return new HostType(
         debugV_, useGangedStripsInME1a_, useOnlyWiresInME1a_, useRealWireGeometry_, useCentreTIOffsets_);
   });
 
   initCSCGeometry_(record, host);
 
   // Called whenever the alignments or alignment errors change
 
   if (applyAlignment_) {
     // applyAlignment_ is scheduled for removal.
     // Ideal geometry obtained by using 'fake alignment' (with applyAlignment_ = true)
     const auto& globalPosition = record.get(globalPositionToken_);
     const auto& alignments = record.get(alignmentsToken_);
     const auto& alignmentErrors = record.get(alignmentErrorsToken_);
     // Only apply alignment if values exist
     if (alignments.empty() && alignmentErrors.empty() && globalPosition.empty()) {
       edm::LogVerbatim("Config") << "@SUB=CSCGeometryRecord::produce Alignment(Error)s and global position (label '"
                                  << alignmentsLabel_ << "') empty: Geometry producer (label "
                                  << "'" << myLabel_ << "') assumes fake and does not apply.";
     } else {
       GeometryAligner aligner;
       aligner.applyAlignments<CSCGeometry>(
           &(*host), &alignments, &alignmentErrors, align::DetectorGlobalPosition(globalPosition, DetId(DetId::Muon)));
     }
   }
   return host;  // automatically converts to std::shared_ptr<CSCGeometry>
 }