#include <EventSetupProvider.h>

Public Types
typedef std::pair< DataType, DataLabel >	DataKeyInfo

typedef std::string	DataLabel

typedef std::string	DataType

typedef std::map< ComponentDescription, RecordToDataMap >	PreferredProviderInfo

typedef std::string	RecordName

typedef std::multimap< RecordName, DataKeyInfo >	RecordToDataMap

Public Member Functions
void	add (std::shared_ptr< DataProxyProvider >)

void	add (std::shared_ptr< EventSetupRecordIntervalFinder >)

void	addRecord (const EventSetupRecordKey &iKey)
	Intended for use only in tests. More...

void	addRecordToEventSetup (EventSetupRecordImpl &iRecord)

void	checkESProducerSharing (EventSetupProvider &precedingESProvider, std::set< ParameterSetIDHolder > &sharingCheckDone, std::map< EventSetupRecordKey, std::vector< ComponentDescription const * >> &referencedESProducers, EventSetupsController &esController)

void	clearInitializationData ()

bool	doRecordsMatch (EventSetupProvider &precedingESProvider, EventSetupRecordKey const &eventSetupRecordKey, std::map< EventSetupRecordKey, bool > &allComponentsMatch, EventSetupsController const &esController)

EventSetupImpl const &	eventSetup () const

EventSetupImpl const &	eventSetupForInstance (IOVSyncValue const &)

	EventSetupProvider (ActivityRegistry , unsigned subProcessIndex=0U, PreferredProviderInfo const iInfo=0)

void	fillReferencedDataKeys (EventSetupRecordKey const &eventSetupRecordKey)

void	finishConfiguration ()

void	forceCacheClear ()
	Used when testing that all code properly updates on IOV changes of all Records. More...

bool	isWithinValidityInterval (IOVSyncValue const &) const

std::set< ComponentDescription >	proxyProviderDescriptions () const

ESRecordsToProxyIndices	recordsToProxyIndices () const

void	replaceExisting (std::shared_ptr< DataProxyProvider >)

void	resetRecordPlusDependentRecords (EventSetupRecordKey const &)
	Used when we need to force a Record to reset all its proxies. More...

void	resetRecordToProxyPointers ()

unsigned	subProcessIndex () const

virtual	~EventSetupProvider ()

Static Public Member Functions
static void	logInfoWhenSharing (ParameterSet const &iConfiguration)

Protected Member Functions
void	insert (std::unique_ptr< EventSetupRecordProvider > iRecordProvider)

Private Types
using	RecordKeys = std::vector< EventSetupRecordKey >

using	RecordProviders = std::vector< std::shared_ptr< EventSetupRecordProvider >>

Private Member Functions
void	determinePreferred ()

	EventSetupProvider (EventSetupProvider const &)=delete

void	insert (EventSetupRecordKey const &, std::unique_ptr< EventSetupRecordProvider >)

EventSetupProvider const &	operator= (EventSetupProvider const &)=delete

std::shared_ptr< EventSetupRecordProvider > &	recordProvider (const EventSetupRecordKey &iKey)

EventSetupRecordProvider *	tryToGetRecordProvider (const EventSetupRecordKey &iKey)

Private Attributes
std::unique_ptr< std::vector< std::shared_ptr< DataProxyProvider > > >	dataProviders_

EventSetupImpl	eventSetup_

std::unique_ptr< std::vector< std::shared_ptr< EventSetupRecordIntervalFinder > > >	finders_

bool	mustFinishConfiguration_

std::unique_ptr< PreferredProviderInfo >	preferredProviderInfo_

std::unique_ptr< std::map< ParameterSetIDHolder, std::set< EventSetupRecordKey > > >	psetIDToRecordKey_

RecordKeys	recordKeys_

RecordProviders	recordProviders_

std::unique_ptr< std::set< EventSetupRecordKey > >	recordsWithALooperProxy_

std::unique_ptr< std::map< EventSetupRecordKey, std::vector< std::shared_ptr< EventSetupRecordIntervalFinder > > > >	recordToFinders_

std::unique_ptr< std::map< EventSetupRecordKey, std::map< DataKey, ComponentDescription > > >	recordToPreferred_

std::unique_ptr< std::map< EventSetupRecordKey, std::map< DataKey, ComponentDescription const * > > >	referencedDataKeys_

unsigned	subProcessIndex_

Detailed Description

Definition at line 50 of file EventSetupProvider.h.

Member Typedef Documentation

typedef std::pair<DataType, DataLabel> edm::eventsetup::EventSetupProvider::DataKeyInfo

Definition at line 55 of file EventSetupProvider.h.

typedef std::string edm::eventsetup::EventSetupProvider::DataLabel

Definition at line 54 of file EventSetupProvider.h.

typedef std::string edm::eventsetup::EventSetupProvider::DataType

Definition at line 53 of file EventSetupProvider.h.

typedef std::map<ComponentDescription, RecordToDataMap> edm::eventsetup::EventSetupProvider::PreferredProviderInfo

Definition at line 57 of file EventSetupProvider.h.

using edm::eventsetup::EventSetupProvider::RecordKeys = std::vector<EventSetupRecordKey>

private

Definition at line 132 of file EventSetupProvider.h.

typedef std::string edm::eventsetup::EventSetupProvider::RecordName

Definition at line 52 of file EventSetupProvider.h.

using edm::eventsetup::EventSetupProvider::RecordProviders = std::vector<std::shared_ptr<EventSetupRecordProvider>>

private

Definition at line 135 of file EventSetupProvider.h.

typedef std::multimap<RecordName, DataKeyInfo> edm::eventsetup::EventSetupProvider::RecordToDataMap

Definition at line 56 of file EventSetupProvider.h.

Constructor & Destructor Documentation

edm::eventsetup::EventSetupProvider::EventSetupProvider	(	ActivityRegistry *	,
		unsigned	subProcessIndex = `0U`,
		PreferredProviderInfo const *	iInfo = `0`
	)

Referenced by subProcessIndex().

EventSetupProvider::~EventSetupProvider ( )

virtual

Definition at line 53 of file EventSetupProvider.cc.

53 { forceCacheClear(); }

edm::eventsetup::EventSetupProvider::forceCacheClear

void forceCacheClear()

Used when testing that all code properly updates on IOV changes of all Records.

Definition: EventSetupProvider.cc:387

edm::eventsetup::EventSetupProvider::EventSetupProvider ( EventSetupProvider const & )

privatedelete

Member Function Documentation

void EventSetupProvider::add ( std::shared_ptr< DataProxyProvider > iProvider )

Definition at line 86 of file EventSetupProvider.cc.

Referenced by edm::eventsetup::looper::addFinderTo(), edm::eventsetup::addProviderTo(), edm::eventsetup::looper::addProviderTo(), edm::eventsetup::ModuleMakerTraits::addTo(), edm::eventsetup::SourceMakerTraits::addTo(), eventSetup(), counter.Counter::register(), SequenceTypes.Task::remove(), and SequenceTypes.Task::replace().

                                                                            {
       assert(iProvider.get() != nullptr);
       dataProviders_->push_back(iProvider);
     }

void EventSetupProvider::add ( std::shared_ptr< EventSetupRecordIntervalFinder > iFinder )

Definition at line 99 of file EventSetupProvider.cc.

Referenced by counter.Counter::register(), SequenceTypes.Task::remove(), and SequenceTypes.Task::replace().

                                                                                       {
       assert(iFinder.get() != nullptr);
       finders_->push_back(iFinder);
     }

void EventSetupProvider::addRecord ( const EventSetupRecordKey & iKey )

Intended for use only in tests.

Definition at line 733 of file EventSetupProvider.cc.

References edm::EventSetupImpl::insert().

Referenced by subProcessIndex().

                                                                       {
       insert(iKey, std::unique_ptr<EventSetupRecordProvider>());
       eventSetup_.setKeyIters(recordKeys_.begin(), recordKeys_.end());
     }

void EventSetupProvider::addRecordToEventSetup ( EventSetupRecordImpl & iRecord )

Definition at line 654 of file EventSetupProvider.cc.

References edm::eventsetup::EventSetupRecordImpl::setEventSetup().

Referenced by edm::eventsetup::EventSetupRecordProvider::addRecordTo(), and eventSetup().

                                                                                 {
       iRecord.setEventSetup(&eventSetup_);
       eventSetup_.add(iRecord);
     }

void EventSetupProvider::checkESProducerSharing	(	EventSetupProvider &	precedingESProvider,
		std::set< ParameterSetIDHolder > &	sharingCheckDone,
		std::map< EventSetupRecordKey, std::vector< ComponentDescription const * >> &	referencedESProducers,
		EventSetupsController &	esController
	)

Definition at line 395 of file EventSetupProvider.cc.

References reco::get(), edm::eventsetup::EventSetupsController::getESProducerPSet(), edm::eventsetup::EventSetupsController::isFirstMatch(), edm::eventsetup::EventSetupsController::isLastMatch(), crabWrapper::key, edm::eventsetup::EventSetupsController::lookForMatches(), edm::match(), muonDTDigis_cfi::pset, psetIDToRecordKey_, recordProvider(), subProcessIndex(), and subProcessIndex_.

Referenced by eventSetup().

                                              {
       edm::LogVerbatim("EventSetupSharing")
           << "EventSetupProvider::checkESProducerSharing: Checking processes with SubProcess Indexes "
           << subProcessIndex() << " and " << precedingESProvider.subProcessIndex();
 
       if (referencedESProducers.empty()) {
         for (auto& recProvider : recordProviders_) {
           recProvider->getReferencedESProducers(referencedESProducers);
         }
       }
 
       // This records whether the configurations of all the DataProxyProviders
       // and finders matches for a particular pair of processes and
       // a particular record and also the records it depends on.
       std::map<EventSetupRecordKey, bool> allComponentsMatch;
 
       std::map<ParameterSetID, bool> candidateNotRejectedYet;
 
       // Loop over all the ESProducers which have a DataProxy
       // referenced by any EventSetupRecord in this EventSetupProvider
       for (auto const& iRecord : referencedESProducers) {
         for (auto const& iComponent : iRecord.second) {
           ParameterSetID const& psetID = iComponent->pid_;
           ParameterSetIDHolder psetIDHolder(psetID);
           if (sharingCheckDone.find(psetIDHolder) != sharingCheckDone.end())
             continue;
 
           bool firstProcessWithThisPSet = false;
           bool precedingHasMatchingPSet = false;
 
           esController.lookForMatches(psetID,
                                       subProcessIndex_,
                                       precedingESProvider.subProcessIndex_,
                                       firstProcessWithThisPSet,
                                       precedingHasMatchingPSet);
 
           if (firstProcessWithThisPSet) {
             sharingCheckDone.insert(psetIDHolder);
             allComponentsMatch[iRecord.first] = false;
             continue;
           }
 
           if (!precedingHasMatchingPSet) {
             allComponentsMatch[iRecord.first] = false;
             continue;
           }
 
           // An ESProducer that survives to this point is a candidate.
           // It was shared with some other process in the first pass where
           // ESProducers were constructed and one of three possibilities exists:
           //    1) It should not have been shared and a new ESProducer needs
           //    to be created and the proper pointers set.
           //    2) It should have been shared with a different preceding process
           //    in which case some pointers need to be modified.
           //    3) It was originally shared which the correct prior process
           //    in which case nothing needs to be done, but we do need to
           //    do some work to verify that.
           // Make an entry in a map for each of these ESProducers. We
           // will set the value to false if and when we determine
           // the ESProducer cannot be shared between this pair of processes.
           auto iCandidateNotRejectedYet = candidateNotRejectedYet.find(psetID);
           if (iCandidateNotRejectedYet == candidateNotRejectedYet.end()) {
             candidateNotRejectedYet[psetID] = true;
             iCandidateNotRejectedYet = candidateNotRejectedYet.find(psetID);
           }
 
           // At this point we know that the two processes both
           // have an ESProducer matching the type and label in
           // iComponent and also with exactly the same configuration.
           // And there was not an earlier preceding process
           // where the same instance of the ESProducer could
           // have been shared.  And this ESProducer was referenced
           // by the later process's EventSetupRecord (prefered or
           // or just the only thing that could have made the data).
           // To determine if sharing is allowed, now we need to
           // check if all the DataProxyProviders and all the
           // finders are the same for this record and also for
           // all records this record depends on. And even
           // if this is true, we have to wait until the loop
           // ends because some other DataProxy associated with
           // the ESProducer could write to a different record where
           // the same determination will need to be repeated. Only if
           // all of the the DataProxy's can be shared, can the ESProducer
           // instance be shared across processes.
 
           if (iCandidateNotRejectedYet->second == true) {
             auto iAllComponentsMatch = allComponentsMatch.find(iRecord.first);
             if (iAllComponentsMatch == allComponentsMatch.end()) {
               // We do not know the value in AllComponents yet and
               // we need it now so we have to do the difficult calculation
               // now.
               bool match = doRecordsMatch(precedingESProvider, iRecord.first, allComponentsMatch, esController);
               allComponentsMatch[iRecord.first] = match;
               iAllComponentsMatch = allComponentsMatch.find(iRecord.first);
             }
             if (!iAllComponentsMatch->second) {
               iCandidateNotRejectedYet->second = false;
             }
           }
         }  // end loop over components used by record
       }    // end loop over records
 
       // Loop over candidates
       for (auto const& candidate : candidateNotRejectedYet) {
         ParameterSetID const& psetID = candidate.first;
         bool canBeShared = candidate.second;
         if (canBeShared) {
           ParameterSet const& pset = *esController.getESProducerPSet(psetID, subProcessIndex_);
           logInfoWhenSharing(pset);
           ParameterSetIDHolder psetIDHolder(psetID);
           sharingCheckDone.insert(psetIDHolder);
           if (esController.isFirstMatch(psetID, subProcessIndex_, precedingESProvider.subProcessIndex_)) {
             continue;  // Proper sharing was already done. Nothing more to do.
           }
 
           // Need to reset the pointer from the EventSetupRecordProvider to the
           // the DataProxyProvider so these two processes share an ESProducer.
 
           std::shared_ptr<DataProxyProvider> dataProxyProvider;
           std::set<EventSetupRecordKey> const& keysForPSetID1 = (*precedingESProvider.psetIDToRecordKey_)[psetIDHolder];
           for (auto const& key : keysForPSetID1) {
             dataProxyProvider = precedingESProvider.recordProvider(key)->proxyProvider(psetIDHolder);
             assert(dataProxyProvider);
             break;
           }
 
           std::set<EventSetupRecordKey> const& keysForPSetID2 = (*psetIDToRecordKey_)[psetIDHolder];
           for (auto const& key : keysForPSetID2) {
             recordProvider(key)->resetProxyProvider(psetIDHolder, dataProxyProvider);
           }
         } else {
           if (esController.isLastMatch(psetID, subProcessIndex_, precedingESProvider.subProcessIndex_)) {
             ParameterSet const& pset = *esController.getESProducerPSet(psetID, subProcessIndex_);
             ModuleFactory::get()->addTo(esController, *this, pset, true);
           }
         }
       }
     }

void EventSetupProvider::clearInitializationData ( )

Definition at line 645 of file EventSetupProvider.cc.

Referenced by eventSetup().

                                                      {
       preferredProviderInfo_.reset();
       referencedDataKeys_.reset();
       recordToFinders_.reset();
       psetIDToRecordKey_.reset();
       recordToPreferred_.reset();
       recordsWithALooperProxy_.reset();
     }

void EventSetupProvider::determinePreferred ( )

private

Definition at line 158 of file EventSetupProvider.cc.

References makeMuonMisalignmentScenario::components, Exception, edm::eventsetup::heterocontainer::HCTypeTag::findType(), kp, edm::eventsetup::preferEverything(), edm::eventsetup::EventSetupRecordProvider::proxyProvider(), edm::eventsetup::EventSetupRecordProvider::proxyProviderDescriptions(), align_cfg::recordName, AlCaHLTBitMon_QueryRunRegistry::string, and edm::eventsetup::EventSetupRecordKey::type().

Referenced by subProcessIndex().

                                                 {
       using namespace edm::eventsetup;
       if (preferredProviderInfo_) {
         for (auto const& itInfo : *preferredProviderInfo_) {
           if (itInfo.second.empty()) {
             //want everything
             preferEverything(itInfo.first, recordProviders_, *recordToPreferred_);
           } else {
             for (EventSetupProvider::RecordToDataMap::const_iterator itRecData = itInfo.second.begin(),
                                                                      itRecDataEnd = itInfo.second.end();
                  itRecData != itRecDataEnd;
                  ++itRecData) {
               std::string recordName = itRecData->first;
               EventSetupRecordKey recordKey(eventsetup::EventSetupRecordKey::TypeTag::findType(recordName));
               if (recordKey.type() == eventsetup::EventSetupRecordKey::TypeTag()) {
                 throw cms::Exception("ESPreferUnknownRecord")
                     << "Unknown record \"" << recordName
                     << "\" used in es_prefer statement for type=" << itInfo.first.type_ << " label=\""
                     << itInfo.first.label_ << "\"\n Please check spelling.";
                 //record not found
               }
               //See if the ProxyProvider provides something for this Record
               EventSetupRecordProvider& recordProviderForKey = *recordProvider(recordKey);
 
               std::set<ComponentDescription> components = recordProviderForKey.proxyProviderDescriptions();
               std::set<ComponentDescription>::iterator itProxyProv = components.find(itInfo.first);
               if (itProxyProv == components.end()) {
                 throw cms::Exception("ESPreferWrongRecord")
                     << "The type=" << itInfo.first.type_ << " label=\"" << itInfo.first.label_
                     << "\" does not provide data for the Record " << recordName;
               }
               //Does it data type exist?
               eventsetup::TypeTag datumType = eventsetup::TypeTag::findType(itRecData->second.first);
               if (datumType == eventsetup::TypeTag()) {
                 //not found
                 throw cms::Exception("ESPreferWrongDataType")
                     << "The es_prefer statement for type=" << itInfo.first.type_ << " label=\"" << itInfo.first.label_
                     << "\" has the unknown data type \"" << itRecData->second.first << "\""
                     << "\n Please check spelling";
               }
               eventsetup::DataKey datumKey(datumType, itRecData->second.second.c_str());
 
               //Does the proxyprovider make this?
               std::shared_ptr<DataProxyProvider> proxyProv = recordProviderForKey.proxyProvider(*itProxyProv);
               const DataProxyProvider::KeyedProxies& keyedProxies = proxyProv->keyedProxies(recordKey);
               if (std::find_if(keyedProxies.begin(), keyedProxies.end(), [&datumKey](auto const& kp) {
                     return kp.first == datumKey;
                   }) == keyedProxies.end()) {
                 throw cms::Exception("ESPreferWrongData")
                     << "The es_prefer statement for type=" << itInfo.first.type_ << " label=\"" << itInfo.first.label_
                     << "\" specifies the data item \n"
                     << "  type=\"" << itRecData->second.first << "\" label=\"" << itRecData->second.second << "\""
                     << "  which is not provided.  Please check spelling.";
               }
 
               EventSetupRecordProvider::DataToPreferredProviderMap& dataToProviderMap =
                   (*recordToPreferred_)[recordKey];
               //has another provider already been specified?
               if (dataToProviderMap.end() != dataToProviderMap.find(datumKey)) {
                 EventSetupRecordProvider::DataToPreferredProviderMap::iterator itFind =
                     dataToProviderMap.find(datumKey);
                 throw cms::Exception("ESPreferConflict")
                     << "Two providers have been set to be preferred for\n"
                     << datumKey.type().name() << " \"" << datumKey.name().value() << "\""
                     << "\n the providers are "
                     << "\n 1) type=" << itFind->second.type_ << " label=\"" << itFind->second.label_ << "\""
                     << "\n 2) type=" << itProxyProv->type_ << " label=\"" << itProxyProv->label_ << "\""
                     << "\nPlease modify configuration so only one is preferred";
               }
               dataToProviderMap.insert(std::make_pair(datumKey, *itProxyProv));
             }
           }
         }
       }
     }

bool EventSetupProvider::doRecordsMatch	(	EventSetupProvider &	precedingESProvider,
		EventSetupRecordKey const &	eventSetupRecordKey,
		std::map< EventSetupRecordKey, bool > &	allComponentsMatch,
		EventSetupsController const &	esController
	)

Definition at line 538 of file EventSetupProvider.cc.

References edm::eventsetup::EventSetupRecordProvider::dependentRecords(), fillReferencedDataKeys(), ghostTrackVertexReco_cff::finder, edm::eventsetup::EventSetupsController::isMatchingESProducer(), edm::eventsetup::EventSetupsController::isMatchingESSource(), edm::match(), recordsWithALooperProxy_, recordToFinders_, referencedDataKeys_, findQualityFiles::size, and subProcessIndex_.

Referenced by eventSetup().

                                                                                        {
       // first check if this record matches. If not just return false
 
       // then find the directly dependent records and iterate over them
       // recursively call this function on them. If they return false
       // set allComponentsMatch to false for them and return false.
       // if they all return true then set allComponents to true
       // and return true.
 
       if (precedingESProvider.recordsWithALooperProxy_->find(eventSetupRecordKey) !=
           precedingESProvider.recordsWithALooperProxy_->end()) {
         return false;
       }
 
       if ((*recordToFinders_)[eventSetupRecordKey].size() !=
           (*precedingESProvider.recordToFinders_)[eventSetupRecordKey].size()) {
         return false;
       }
 
       for (auto const& finder : (*recordToFinders_)[eventSetupRecordKey]) {
         ParameterSetID const& psetID = finder->descriptionForFinder().pid_;
         bool itMatches =
             esController.isMatchingESSource(psetID, subProcessIndex_, precedingESProvider.subProcessIndex_);
         if (!itMatches) {
           return false;
         }
       }
 
       fillReferencedDataKeys(eventSetupRecordKey);
       precedingESProvider.fillReferencedDataKeys(eventSetupRecordKey);
 
       std::map<DataKey, ComponentDescription const*> const& dataItems = (*referencedDataKeys_)[eventSetupRecordKey];
 
       std::map<DataKey, ComponentDescription const*> const& precedingDataItems =
           (*precedingESProvider.referencedDataKeys_)[eventSetupRecordKey];
 
       if (dataItems.size() != precedingDataItems.size()) {
         return false;
       }
 
       for (auto const& dataItem : dataItems) {
         auto precedingDataItem = precedingDataItems.find(dataItem.first);
         if (precedingDataItem == precedingDataItems.end()) {
           return false;
         }
         if (dataItem.second->pid_ != precedingDataItem->second->pid_) {
           return false;
         }
         // Check that the configurations match exactly for the ESProducers
         // (We already checked the ESSources above and there should not be
         // any loopers)
         if (!dataItem.second->isSource_ && !dataItem.second->isLooper_) {
           bool itMatches = esController.isMatchingESProducer(
               dataItem.second->pid_, subProcessIndex_, precedingESProvider.subProcessIndex_);
           if (!itMatches) {
             return false;
           }
         }
       }
       EventSetupRecordProvider* recProvider = tryToGetRecordProvider(eventSetupRecordKey);
       if (recProvider != nullptr) {
         std::set<EventSetupRecordKey> dependentRecords = recProvider->dependentRecords();
         for (auto const& dependentRecord : dependentRecords) {
           auto iter = allComponentsMatch.find(dependentRecord);
           if (iter != allComponentsMatch.end()) {
             if (iter->second) {
               continue;
             } else {
               return false;
             }
           }
           bool match = doRecordsMatch(precedingESProvider, dependentRecord, allComponentsMatch, esController);
           allComponentsMatch[dependentRecord] = match;
           if (!match)
             return false;
         }
       }
       return true;
     }

EventSetupImpl const& edm::eventsetup::EventSetupProvider::eventSetup ( ) const

inline

Definition at line 74 of file EventSetupProvider.h.

References add(), addRecordToEventSetup(), checkESProducerSharing(), clearInitializationData(), doRecordsMatch(), eventSetup_, fillReferencedDataKeys(), finishConfiguration(), forceCacheClear(), genParticles_cff::map, replaceExisting(), resetRecordPlusDependentRecords(), and resetRecordToProxyPointers().

74 { return eventSetup_; }

edm::eventsetup::EventSetupProvider::eventSetup_

EventSetupImpl eventSetup_

Definition: EventSetupProvider.h:130

EventSetupImpl const & EventSetupProvider::eventSetupForInstance ( IOVSyncValue const & )

Definition at line 667 of file EventSetupProvider.cc.

References edm::EventSetupImpl::clear().

                                                                                               {
       eventSetup_.clear();
 
       // In a cmsRun job this does nothing because the EventSetupsController
       // will have already called finishConfiguration, but some tests will
       // call finishConfiguration here.
       if (mustFinishConfiguration_) {
         finishConfiguration();
       }
 
       for (auto const& recProvider : recordProviders_) {
         recProvider->addRecordToIfValid(*this, iValue);
       }
       return eventSetup_;
     }

void EventSetupProvider::fillReferencedDataKeys ( EventSetupRecordKey const & eventSetupRecordKey )

Definition at line 621 of file EventSetupProvider.cc.

References edm::eventsetup::EventSetupRecordProvider::fillReferencedDataKeys().

Referenced by doRecordsMatch(), and eventSetup().

                                                                                                   {
       if (referencedDataKeys_->find(eventSetupRecordKey) != referencedDataKeys_->end())
         return;
 
       EventSetupRecordProvider* recProvider = tryToGetRecordProvider(eventSetupRecordKey);
       if (recProvider == nullptr) {
         (*referencedDataKeys_)[eventSetupRecordKey];
         return;
       }
       recProvider->fillReferencedDataKeys((*referencedDataKeys_)[eventSetupRecordKey]);
     }

void EventSetupProvider::finishConfiguration ( )

Definition at line 234 of file EventSetupProvider.cc.

References edm::eventsetup::EventSetupRecordProvider::add(), edm::eventsetup::EventSetupRecordProvider::addFinder(), SoftLeptonByDistance_cfi::distance, edm::EventSetupImpl::insert(), crabWrapper::key, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by eventSetup().

                                                  {
       //we delayed adding finders to the system till here so that everything would be loaded first
       recordToFinders_->clear();
       for (std::vector<std::shared_ptr<EventSetupRecordIntervalFinder>>::iterator itFinder = finders_->begin(),
                                                                                   itEnd = finders_->end();
            itFinder != itEnd;
            ++itFinder) {
         typedef std::set<EventSetupRecordKey> Keys;
         const Keys recordsUsing = (*itFinder)->findingForRecords();
 
         for (auto const& key : recordsUsing) {
           (*recordToFinders_)[key].push_back(*itFinder);
 
           EventSetupRecordProvider* recProvider = tryToGetRecordProvider(key);
           if (recProvider == nullptr) {
             //create a provider for this record
             insert(key, std::make_unique<EventSetupRecordProvider>(key));
             recProvider = tryToGetRecordProvider(key);
           }
           recProvider->addFinder(*itFinder);
         }
       }
       //we've transfered our ownership so this is no longer needed
       finders_.reset();
 
       //Now handle providers since sources can also be finders and the sources can delay registering
       // their Records and therefore could delay setting up their Proxies
       psetIDToRecordKey_->clear();
       typedef std::set<EventSetupRecordKey> Keys;
       for (std::vector<std::shared_ptr<DataProxyProvider>>::iterator itProvider = dataProviders_->begin(),
                                                                      itEnd = dataProviders_->end();
            itProvider != itEnd;
            ++itProvider) {
         ParameterSetIDHolder psetID((*itProvider)->description().pid_);
 
         const Keys recordsUsing = (*itProvider)->usingRecords();
 
         for (auto const& key : recordsUsing) {
           if ((*itProvider)->description().isLooper_) {
             recordsWithALooperProxy_->insert(key);
           }
 
           (*psetIDToRecordKey_)[psetID].insert(key);
 
           EventSetupRecordProvider* recProvider = tryToGetRecordProvider(key);
           if (recProvider == nullptr) {
             //create a provider for this record
             insert(key, std::make_unique<EventSetupRecordProvider>(key));
             recProvider = tryToGetRecordProvider(key);
           }
           recProvider->add(*itProvider);
         }
       }
 
       eventSetup_.setKeyIters(recordKeys_.begin(), recordKeys_.end());
 
       //used for the case where no preferred Providers have been specified for the Record
       static const EventSetupRecordProvider::DataToPreferredProviderMap kEmptyMap;
 
       determinePreferred();
 
       //For each Provider, find all the Providers it depends on.  If a dependent Provider
       // can not be found pass in an empty list
       //CHANGE: now allow for missing Providers
       for (auto& itRecordProvider : recordProviders_) {
         const EventSetupRecordProvider::DataToPreferredProviderMap* preferredInfo = &kEmptyMap;
         RecordToPreferred::const_iterator itRecordFound = recordToPreferred_->find(itRecordProvider->key());
         if (itRecordFound != recordToPreferred_->end()) {
           preferredInfo = &(itRecordFound->second);
         }
         //Give it our list of preferred
         itRecordProvider->usePreferred(*preferredInfo);
 
         std::set<EventSetupRecordKey> records = itRecordProvider->dependentRecords();
         if (!records.empty()) {
           std::string missingRecords;
           std::vector<std::shared_ptr<EventSetupRecordProvider>> depProviders;
           depProviders.reserve(records.size());
           bool foundAllProviders = true;
           for (auto const& key : records) {
             auto lb = std::lower_bound(recordKeys_.begin(), recordKeys_.end(), key);
             if (lb == recordKeys_.end() || key != *lb) {
               foundAllProviders = false;
               if (missingRecords.empty()) {
                 missingRecords = key.name();
               } else {
                 missingRecords += ", ";
                 missingRecords += key.name();
               }
             } else {
               auto index = std::distance(recordKeys_.begin(), lb);
               depProviders.push_back(recordProviders_[index]);
             }
           }
 
           if (!foundAllProviders) {
             edm::LogInfo("EventSetupDependency")
                 << "The EventSetup record " << itRecordProvider->key().name() << " depends on at least one Record \n ("
                 << missingRecords
                 << ") which is not present in the job."
                    "\n This may lead to an exception begin thrown during event processing.\n If no exception occurs "
                    "during the job than it is usually safe to ignore this message.";
 
             //depProviders.clear();
             //NOTE: should provide a warning
           }
 
           itRecordProvider->setDependentProviders(depProviders);
         }
       }
 
       auto indices = recordsToProxyIndices();
       for (auto& provider : *dataProviders_) {
         provider->updateLookup(indices);
       }
       dataProviders_.reset();
 
       mustFinishConfiguration_ = false;
     }

void EventSetupProvider::forceCacheClear ( )

Used when testing that all code properly updates on IOV changes of all Records.

Definition at line 387 of file EventSetupProvider.cc.

Referenced by eventSetup().

                                              {
       for (auto& recProvider : recordProviders_) {
         if (recProvider) {
           recProvider->resetProxies();
         }
       }
     }

void EventSetupProvider::insert ( std::unique_ptr< EventSetupRecordProvider > iRecordProvider )

protected

Definition at line 659 of file EventSetupProvider.cc.

References edm::EventSetupImpl::insert(), crabWrapper::key, and eostools::move().

Referenced by subProcessIndex().

                                                                                            {
       auto key = iRecordProvider->key();
       insert(key, std::move(iRecordProvider));
     }

void edm::eventsetup::EventSetupProvider::insert	(	EventSetupRecordKey const &	,
		std::unique_ptr< EventSetupRecordProvider >
	)

private

bool EventSetupProvider::isWithinValidityInterval ( IOVSyncValue const & iSync ) const

Definition at line 700 of file EventSetupProvider.cc.

References edm::ValidityInterval::invalidInterval().

                                                                                      {
       for (auto const& recProvider : recordProviders_) {
         auto const& iov = recProvider->validityInterval();
         if ((iov != ValidityInterval::invalidInterval()) and (not recProvider->validityInterval().validFor(iSync))) {
           return false;
         }
       }
       return true;
     }

void EventSetupProvider::logInfoWhenSharing ( ParameterSet const & iConfiguration )

static

Definition at line 725 of file EventSetupProvider.cc.

References edm::ParameterSet::getParameter(), label, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by subProcessIndex().

                                                                                   {
       std::string edmtype = iConfiguration.getParameter<std::string>("@module_edm_type");
       std::string modtype = iConfiguration.getParameter<std::string>("@module_type");
       std::string label = iConfiguration.getParameter<std::string>("@module_label");
       edm::LogVerbatim("EventSetupSharing")
           << "Sharing " << edmtype << ": class=" << modtype << " label='" << label << "'";
     }

EventSetupProvider const& edm::eventsetup::EventSetupProvider::operator= ( EventSetupProvider const & )

privatedelete

Referenced by subProcessIndex().

std::set< ComponentDescription > EventSetupProvider::proxyProviderDescriptions ( ) const

Definition at line 683 of file EventSetupProvider.cc.

References edmIntegrityCheck::d, and AlCaHLTBitMon_ParallelJobs::p.

                                                                                      {
       typedef std::set<ComponentDescription> Set;
       Set descriptions;
 
       for (auto const& recProvider : recordProviders_) {
         auto const& d = recProvider->proxyProviderDescriptions();
         descriptions.insert(d.begin(), d.end());
       }
       if (dataProviders_.get()) {
         for (auto const& p : *dataProviders_) {
           descriptions.insert(p->description());
         }
       }
 
       return descriptions;
     }

std::shared_ptr< EventSetupRecordProvider > & EventSetupProvider::recordProvider ( const EventSetupRecordKey & iKey )

private

Definition at line 55 of file EventSetupProvider.cc.

References SoftLeptonByDistance_cfi::distance, and Exception.

Referenced by checkESProducerSharing(), and subProcessIndex().

                                                                                                                {
       auto lb = std::lower_bound(recordKeys_.begin(), recordKeys_.end(), iKey);
       if (lb == recordKeys_.end() || iKey != *lb) {
         throw cms::Exception("LogicError") << "EventSetupProvider::recordProvider Could not find key\n"
                                            << "Should be impossible. Please contact Framework developer.\n";
       }
       auto index = std::distance(recordKeys_.begin(), lb);
       return recordProviders_[index];
     }

ESRecordsToProxyIndices EventSetupProvider::recordsToProxyIndices ( ) const

Definition at line 710 of file EventSetupProvider.cc.

References edm::eventsetup::ESRecordsToProxyIndices::dataKeysInRecord().

                                                                             {
       ESRecordsToProxyIndices ret(recordKeys_);
 
       unsigned int index = 0;
       for (auto provider : recordProviders_) {
         index = ret.dataKeysInRecord(
             index, provider->key(), provider->registeredDataKeys(), provider->componentsForRegisteredDataKeys());
       }
 
       return ret;
     }

void EventSetupProvider::replaceExisting ( std::shared_ptr< DataProxyProvider > dataProxyProvider )

Definition at line 91 of file EventSetupProvider.cc.

References crabWrapper::key.

Referenced by eventSetup(), and edm::eventsetup::ModuleMakerTraits::replaceExisting().

                                                                                                {
       ParameterSetIDHolder psetID(dataProxyProvider->description().pid_);
       std::set<EventSetupRecordKey> const& keysForPSetID = (*psetIDToRecordKey_)[psetID];
       for (auto const& key : keysForPSetID) {
         recordProvider(key)->resetProxyProvider(psetID, dataProxyProvider);
       }
     }

void EventSetupProvider::resetRecordPlusDependentRecords ( EventSetupRecordKey const & )

Used when we need to force a Record to reset all its proxies.

Definition at line 370 of file EventSetupProvider.cc.

References edmIntegrityCheck::d, edm::eventsetup::findDependents(), edm::eventsetup::EventSetupRecordProvider::resetProxies(), and tier0::unique().

Referenced by eventSetup(), and edm::EDLooperBase::prepareForNextLoop().

                                                                                             {
       EventSetupRecordProvider* recProvider = tryToGetRecordProvider(iKey);
       if (recProvider == nullptr) {
         return;
       }
 
       std::vector<std::shared_ptr<EventSetupRecordProvider>> dependents;
       findDependents(iKey, recordProviders_.begin(), recordProviders_.end(), dependents);
 
       dependents.erase(std::unique(dependents.begin(), dependents.end()), dependents.end());
 
       recProvider->resetProxies();
       for (auto& d : dependents) {
         d->resetProxies();
       }
     }

void EventSetupProvider::resetRecordToProxyPointers ( )

Definition at line 633 of file EventSetupProvider.cc.

Referenced by eventSetup().

                                                         {
       for (auto const& recProvider : recordProviders_) {
         static const EventSetupRecordProvider::DataToPreferredProviderMap kEmptyMap;
         const EventSetupRecordProvider::DataToPreferredProviderMap* preferredInfo = &kEmptyMap;
         RecordToPreferred::const_iterator itRecordFound = recordToPreferred_->find(recProvider->key());
         if (itRecordFound != recordToPreferred_->end()) {
           preferredInfo = &(itRecordFound->second);
         }
         recProvider->resetRecordToProxyPointers(*preferredInfo);
       }
     }

unsigned edm::eventsetup::EventSetupProvider::subProcessIndex ( ) const

inline

Definition at line 108 of file EventSetupProvider.h.

References addRecord(), determinePreferred(), EventSetupProvider(), insert(), logInfoWhenSharing(), operator=(), recordProvider(), subProcessIndex_, and tryToGetRecordProvider().

Referenced by checkESProducerSharing().

108 { return subProcessIndex_; }

edm::eventsetup::EventSetupProvider::subProcessIndex_

unsigned subProcessIndex_

Definition: EventSetupProvider.h:139

EventSetupRecordProvider * EventSetupProvider::tryToGetRecordProvider ( const EventSetupRecordKey & iKey )

private

Definition at line 65 of file EventSetupProvider.cc.

References SoftLeptonByDistance_cfi::distance, edm::eventsetup::heterocontainer::insert(), and eostools::move().

Referenced by subProcessIndex().

                                                                                                         {
       auto lb = std::lower_bound(recordKeys_.begin(), recordKeys_.end(), iKey);
       if (lb == recordKeys_.end() || iKey != *lb) {
         return nullptr;
       }
       auto index = std::distance(recordKeys_.begin(), lb);
       return recordProviders_[index].get();
     }

Member Data Documentation

std::unique_ptr<std::vector<std::shared_ptr<DataProxyProvider> > > edm::eventsetup::EventSetupProvider::dataProviders_

private

Definition at line 145 of file EventSetupProvider.h.

EventSetupImpl edm::eventsetup::EventSetupProvider::eventSetup_

private

Definition at line 130 of file EventSetupProvider.h.

Referenced by eventSetup().

std::unique_ptr<std::vector<std::shared_ptr<EventSetupRecordIntervalFinder> > > edm::eventsetup::EventSetupProvider::finders_

private

Definition at line 144 of file EventSetupProvider.h.

bool edm::eventsetup::EventSetupProvider::mustFinishConfiguration_

private

Definition at line 138 of file EventSetupProvider.h.

std::unique_ptr<PreferredProviderInfo> edm::eventsetup::EventSetupProvider::preferredProviderInfo_

private

Definition at line 143 of file EventSetupProvider.h.

std::unique_ptr<std::map<ParameterSetIDHolder, std::set<EventSetupRecordKey> > > edm::eventsetup::EventSetupProvider::psetIDToRecordKey_

private

Definition at line 149 of file EventSetupProvider.h.

Referenced by checkESProducerSharing().

RecordKeys edm::eventsetup::EventSetupProvider::recordKeys_

private

Definition at line 133 of file EventSetupProvider.h.

RecordProviders edm::eventsetup::EventSetupProvider::recordProviders_

private

Definition at line 136 of file EventSetupProvider.h.

std::unique_ptr<std::set<EventSetupRecordKey> > edm::eventsetup::EventSetupProvider::recordsWithALooperProxy_

private

Definition at line 151 of file EventSetupProvider.h.

Referenced by doRecordsMatch().

std::unique_ptr<std::map<EventSetupRecordKey, std::vector<std::shared_ptr<EventSetupRecordIntervalFinder> > > > edm::eventsetup::EventSetupProvider::recordToFinders_

private

Definition at line 148 of file EventSetupProvider.h.

Referenced by doRecordsMatch().

std::unique_ptr<std::map<EventSetupRecordKey, std::map<DataKey, ComponentDescription> > > edm::eventsetup::EventSetupProvider::recordToPreferred_

private

Definition at line 150 of file EventSetupProvider.h.

std::unique_ptr<std::map<EventSetupRecordKey, std::map<DataKey, ComponentDescription const*> > > edm::eventsetup::EventSetupProvider::referencedDataKeys_

private

Definition at line 146 of file EventSetupProvider.h.

Referenced by doRecordsMatch().

unsigned edm::eventsetup::EventSetupProvider::subProcessIndex_

private

Definition at line 139 of file EventSetupProvider.h.

Referenced by checkESProducerSharing(), doRecordsMatch(), and subProcessIndex().