Inheritance diagram for magneticfield::DD4hep_VolumeBasedMagneticFieldESProducerFromDB:

Public Member Functions
std::shared_ptr< MagFieldConfig const >	chooseConfigAtRuntime (const IdealMagneticFieldRecord &iRecord)

std::shared_ptr< MagFieldConfig const >	chooseConfigViaParameter (const IdealMagneticFieldRecord &iRecord)

	DD4hep_VolumeBasedMagneticFieldESProducerFromDB (const edm::ParameterSet &iConfig)

	DD4hep_VolumeBasedMagneticFieldESProducerFromDB (const DD4hep_VolumeBasedMagneticFieldESProducerFromDB &)=delete

const DD4hep_VolumeBasedMagneticFieldESProducerFromDB &	operator= (const DD4hep_VolumeBasedMagneticFieldESProducerFromDB &)=delete

std::unique_ptr< MagneticField >	produce (const IdealMagneticFieldRecord &iRecord)

	~DD4hep_VolumeBasedMagneticFieldESProducerFromDB () override

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 &descriptions)

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

Static Private Member Functions
static std::string_view	closerNominalLabel (float current)

Private Attributes
int	cachedGeometryVersion_ {-1}

edm::ESGetToken< MagFieldConfig, IdealMagneticFieldRecord >	chosenConfigToken_

const bool	debug_

cms::DDDetector *	detector_ {nullptr}

edm::ESGetToken< MagFieldConfig, MagFieldConfigRcd >	knownFromParamConfigToken_

edm::ESGetToken< FileBlob, MFGeometryFileRcd >	mayConsumeBlobToken_

edm::ESGetToken< MagFieldConfig, MagFieldConfigRcd >	mayGetConfigToken_

const bool	useMergeFileIfAvailable_

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 50 of file DD4hep_VolumeBasedMagneticFieldESProducerFromDB.cc.

Constructor & Destructor Documentation

◆ DD4hep_VolumeBasedMagneticFieldESProducerFromDB() [1/2]

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

Definition at line 85 of file DD4hep_VolumeBasedMagneticFieldESProducerFromDB.cc.

References gpuPixelDoublets::cc, chooseConfigAtRuntime(), chooseConfigViaParameter(), chosenConfigToken_, closerNominalLabel(), MagFieldConfig::geometryVersion, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), edm::ESSharedResourceNames::kDD4hep, knownFromParamConfigToken_, label, RunInfo::m_avg_current, mayConsumeBlobToken_, mayGetConfigToken_, alignCSCRings::s, edm::ESProducer::setWhatProduced(), AlCaHLTBitMon_QueryRunRegistry::string, to_string(), edm::ESProducer::usesResources(), and MagFieldConfig::version.

     : debug_(iConfig.getUntrackedParameter<bool>("debugBuilder")),
       useMergeFileIfAvailable_(iConfig.getParameter<bool>("useMergeFileIfAvailable")) {
   std::string const myConfigLabel = "VBMFESChoice";
   usesResources({edm::ESSharedResourceNames::kDD4hep});
 
   //Based on configuration, pick algorithm to produce the proper MagFieldConfig with a specific label
   const int current = iConfig.getParameter<int>("valueOverride");
   if (current < 0) {
     //We do not know what to get until we first read RunInfo
     setWhatProduced(
         this, &DD4hep_VolumeBasedMagneticFieldESProducerFromDB::chooseConfigAtRuntime, edm::es::Label(myConfigLabel))
         .setMayConsume(
             mayGetConfigToken_,
             [](auto const& iGet, edm::ESTransientHandle<RunInfo> iHandle) {
               auto const label = closerNominalLabel(iHandle->m_avg_current);
               edm::LogInfo("MagneticField") << "Current :" << iHandle->m_avg_current
                                             << " (from RunInfo DB); using map configuration with label: " << label;
               return iGet("", label);
             },
             edm::ESProductTag<RunInfo, RunInfoRcd>("", ""));
 
   } else {
     //we know exactly what we are going to get
     auto const label = closerNominalLabel(current);
     edm::LogInfo("MagneticField") << "Current :" << current
                                   << " (from valueOverride card); using map configuration with label: " << label;
     auto cc = setWhatProduced(this,
                               &DD4hep_VolumeBasedMagneticFieldESProducerFromDB::chooseConfigViaParameter,
                               edm::es::Label(myConfigLabel));
 
     knownFromParamConfigToken_ = cc.consumes(edm::ESInputTag(""s, std::string(label)));
   }
 
   auto const label = iConfig.getUntrackedParameter<std::string>("label");
   auto const myConfigTag = edm::ESInputTag(iConfig.getParameter<std::string>("@module_label"), myConfigLabel);
 
   //We use the MagFieldConfig created above to decide which FileBlob to use
   auto cc = setWhatProduced(this, label);
   cc.setMayConsume(
       mayConsumeBlobToken_,
       [](auto const& iGet, edm::ESTransientHandle<MagFieldConfig> iConfig) {
         if (iConfig->version == "parametrizedMagneticField") {
           return iGet.nothing();
         }
         return iGet("", std::to_string(iConfig->geometryVersion));
       },
       edm::ESProductTag<MagFieldConfig, IdealMagneticFieldRecord>(myConfigTag));
   chosenConfigToken_ = cc.consumes(myConfigTag);  //Use same tag as the choice
 }

◆ ~DD4hep_VolumeBasedMagneticFieldESProducerFromDB()

DD4hep_VolumeBasedMagneticFieldESProducerFromDB::~DD4hep_VolumeBasedMagneticFieldESProducerFromDB ( )

override

Definition at line 137 of file DD4hep_VolumeBasedMagneticFieldESProducerFromDB.cc.

References detector_.

                                                                                                   {
   delete detector_;
 }

◆ DD4hep_VolumeBasedMagneticFieldESProducerFromDB() [2/2]

magneticfield::DD4hep_VolumeBasedMagneticFieldESProducerFromDB::DD4hep_VolumeBasedMagneticFieldESProducerFromDB ( const DD4hep_VolumeBasedMagneticFieldESProducerFromDB & )

delete

Member Function Documentation

◆ chooseConfigAtRuntime()

std::shared_ptr< MagFieldConfig const > DD4hep_VolumeBasedMagneticFieldESProducerFromDB::chooseConfigAtRuntime ( const IdealMagneticFieldRecord & iRecord )

Definition at line 141 of file DD4hep_VolumeBasedMagneticFieldESProducerFromDB.cc.

References edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getHandle(), and mayGetConfigToken_.

Referenced by DD4hep_VolumeBasedMagneticFieldESProducerFromDB().

                                           {
   edm::ESHandle<MagFieldConfig> config = iRcd.getHandle(mayGetConfigToken_);
 
   //just forward what we just got but do not take ownership
   return std::shared_ptr<MagFieldConfig const>(config.product(), [](auto*) {});
 }

◆ chooseConfigViaParameter()

std::shared_ptr< MagFieldConfig const > DD4hep_VolumeBasedMagneticFieldESProducerFromDB::chooseConfigViaParameter ( const IdealMagneticFieldRecord & iRecord )

Definition at line 149 of file DD4hep_VolumeBasedMagneticFieldESProducerFromDB.cc.

References edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getHandle(), and knownFromParamConfigToken_.

Referenced by DD4hep_VolumeBasedMagneticFieldESProducerFromDB().

                                              {
   auto config = iRecord.getHandle(knownFromParamConfigToken_);
 
   //just forward what we just got but do not take ownership
   return std::shared_ptr<MagFieldConfig const>(config.product(), [](auto*) {});
 }

◆ closerNominalLabel()

std::string_view DD4hep_VolumeBasedMagneticFieldESProducerFromDB::closerNominalLabel ( float current )

staticprivate

Definition at line 222 of file DD4hep_VolumeBasedMagneticFieldESProducerFromDB.cc.

References ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), mps_fire::i, createfilelist::int, and RunInfoPI::nominalCurrents.

Referenced by DD4hep_VolumeBasedMagneticFieldESProducerFromDB().

                                                                                                 {
   constexpr std::array<int, 7> nominalCurrents = {{-1, 0, 9558, 14416, 16819, 18268, 19262}};
   constexpr std::array<std::string_view, 7> nominalLabels = {{"3.8T", "0T", "2T", "3T", "3.5T", "3.8T", "4T"}};
 
   int i = 0;
   for (; i < (int)nominalLabels.size() - 1; i++) {
     if (2 * current < nominalCurrents[i] + nominalCurrents[i + 1])
       return nominalLabels[i];
   }
   return nominalLabels[i];
 }

◆ fillDescriptions()

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

static

Definition at line 234 of file DD4hep_VolumeBasedMagneticFieldESProducerFromDB.cc.

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

                                                                                                                  {
   edm::ParameterSetDescription desc;
   desc.addUntracked<bool>("debugBuilder", false);
   desc.add<bool>("useMergeFileIfAvailable", true);
   desc.add<int>("valueOverride", -1)->setComment("Force value of current (in A); take the value from DB if < 0.");
   desc.addUntracked<std::string>("label", "");
 
   descriptions.addDefault(desc);
 }

◆ operator=()

const DD4hep_VolumeBasedMagneticFieldESProducerFromDB& magneticfield::DD4hep_VolumeBasedMagneticFieldESProducerFromDB::operator= ( const DD4hep_VolumeBasedMagneticFieldESProducerFromDB & )

delete

◆ produce()

std::unique_ptr< MagneticField > DD4hep_VolumeBasedMagneticFieldESProducerFromDB::produce ( const IdealMagneticFieldRecord & iRecord )

Definition at line 158 of file DD4hep_VolumeBasedMagneticFieldESProducerFromDB.cc.

                                              {
   auto const& conf = iRecord.getTransientHandle(chosenConfigToken_);
 
   std::unique_ptr<MagneticField> paramField =
       ParametrizedMagneticFieldFactory::get(conf->slaveFieldVersion, conf->slaveFieldParameters);
 
   edm::LogInfo("MagneticField") << "(DD4hep) Version: " << conf->version
                                 << " geometryVersion: " << conf->geometryVersion
                                 << " slaveFieldVersion: " << conf->slaveFieldVersion;
 
   if (conf->version == "parametrizedMagneticField") {
     // The map consist of only the parametrization in this case
     return paramField;
   }
 
   // Full VolumeBased map + parametrization
   MagGeoBuilder builder(conf->version, conf->geometryVersion, debug_, useMergeFileIfAvailable_);
 
   // Set scaling factors
   if (!conf->keys.empty()) {
     builder.setScaling(conf->keys, conf->values);
   }
 
   // Set specification for the grid tables to be used.
   if (!conf->gridFiles.empty()) {
     builder.setGridFiles(conf->gridFiles);
   }
 
   // Build the geometry from the DB blob and cache it
   if (cachedGeometryVersion_ != conf->geometryVersion) {
     if (nullptr != detector_) {
       edm::LogError("MagneticField") << "MF Geometry needs to be re-created since current changed (cached: "
                                      << cachedGeometryVersion_ << " requested: " << conf->geometryVersion
                                      << "), which is not supported by dd4hep" << endl;
     }
 
     auto const& blob = iRecord.getTransientHandle(mayConsumeBlobToken_);
     std::unique_ptr<std::vector<unsigned char> > tb = blob->getUncompressedBlob();
 
     string sblob(tb->begin(), tb->end());
     sblob.insert(sblob.rfind("</DDDefinition>"),
                  "<MaterialSection label=\"materials.xml\"><ElementaryMaterial name=\"materials:Vacuum\" "
                  "density=\"1e-13*mg/cm3\" "
                  "symbol=\" \" atomicWeight=\"1*g/mole\" atomicNumber=\"1\"/></MaterialSection>");
 
     detector_ = new cms::DDDetector("cmsMagneticField:MAGF", sblob, true);
     cachedGeometryVersion_ = conf->geometryVersion;
   }
 
   builder.build(detector_);
 
   // Build the VB map. Ownership of the parametrization is transferred to it
   return std::make_unique<VolumeBasedMagneticField>(conf->geometryVersion,
                                                     builder.barrelLayers(),
                                                     builder.endcapSectors(),
                                                     builder.barrelVolumes(),
                                                     builder.endcapVolumes(),
                                                     builder.maxR(),
                                                     builder.maxZ(),
                                                     paramField.release(),
                                                     true);
 }