#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	addRecordToEventSetup (EventSetupRecord &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)

EventSetup const &	eventSetup () const

EventSetup 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

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
template<typename T >
void	insert (std::unique_ptr< T > iRecordProvider)

Private Types
typedef std::map< EventSetupRecordKey, std::shared_ptr< EventSetupRecordProvider > >	Providers

Private Member Functions
	EventSetupProvider (EventSetupProvider const &)=delete

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

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

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

EventSetup	eventSetup_

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

std::unique_ptr< EventSetupKnownRecordsSupplier >	knownRecordsSupplier_

bool	mustFinishConfiguration_

std::unique_ptr< PreferredProviderInfo >	preferredProviderInfo_

Providers	providers_

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

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 51 of file EventSetupProvider.h.

Member Typedef Documentation

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

Definition at line 57 of file EventSetupProvider.h.

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

Definition at line 56 of file EventSetupProvider.h.

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

Definition at line 55 of file EventSetupProvider.h.

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

Definition at line 59 of file EventSetupProvider.h.

typedef std::map<EventSetupRecordKey, std::shared_ptr<EventSetupRecordProvider> > edm::eventsetup::EventSetupProvider::Providers

private

Definition at line 130 of file EventSetupProvider.h.

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

Definition at line 54 of file EventSetupProvider.h.

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

Definition at line 58 of file EventSetupProvider.h.

Constructor & Destructor Documentation

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

Referenced by insert().

EventSetupProvider::~EventSetupProvider ( )

virtual

Definition at line 89 of file EventSetupProvider.cc.

References edm::eventsetup::heterocontainer::insert(), and groupFilesInBlocks::temp.

90 {

91 }

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

privatedelete

Member Function Documentation

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

Definition at line 117 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 135 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::addRecordToEventSetup ( EventSetupRecord & iRecord )

Definition at line 737 of file EventSetupProvider.cc.

References edm::eventsetup::EventSetupRecord::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 454 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(), match(), providers_, muonDTDigis_cfi::pset, psetIDToRecordKey_, 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 const& recordProvider : providers_) {
          recordProvider.second->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) {
             std::shared_ptr<EventSetupRecordProvider> const& recordProvider = precedingESProvider.providers_[key];
             dataProxyProvider = recordProvider->proxyProvider(psetIDHolder);
             assert(dataProxyProvider);
             break;
          }
 
          std::set<EventSetupRecordKey> const& keysForPSetID2 = (*psetIDToRecordKey_)[psetIDHolder];
          for (auto const& key : keysForPSetID2) {
             std::shared_ptr<EventSetupRecordProvider> const& recordProvider = providers_[key];
             recordProvider->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 727 of file EventSetupProvider.cc.

Referenced by eventSetup().

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

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

Definition at line 614 of file EventSetupProvider.cc.

References fillReferencedDataKeys(), ghostTrackVertexReco_cff::finder, edm::eventsetup::EventSetupsController::isMatchingESProducer(), edm::eventsetup::EventSetupsController::isMatchingESSource(), 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;
          }
       }
    }
    Providers::iterator itFound = providers_.find(eventSetupRecordKey);
    if (itFound != providers_.end()) {
       std::set<EventSetupRecordKey> dependentRecords = itFound->second->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;
 }

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

inline

Definition at line 73 of file EventSetupProvider.h.

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

73 {return eventSetup_;}

edm::eventsetup::EventSetupProvider::eventSetup_

EventSetup eventSetup_

Definition: EventSetupProvider.h:129

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

Definition at line 746 of file EventSetupProvider.cc.

References edm::EventSetup::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(Providers::iterator itProvider = providers_.begin(), itProviderEnd = providers_.end();
         itProvider != itProviderEnd;
         ++itProvider) {
       itProvider->second->addRecordToIfValid(*this, iValue);
    }   
    return eventSetup_;
 }

void EventSetupProvider::fillReferencedDataKeys ( EventSetupRecordKey const & eventSetupRecordKey )

Definition at line 699 of file EventSetupProvider.cc.

Referenced by doRecordsMatch(), and eventSetup().

                                                                                          {
 
    if (referencedDataKeys_->find(eventSetupRecordKey) != referencedDataKeys_->end()) return;
 
    auto recordProvider = providers_.find(eventSetupRecordKey);
    if (recordProvider == providers_.end()) {
       (*referencedDataKeys_)[eventSetupRecordKey];
       return;
    }
    if (recordProvider->second) {
       recordProvider->second->fillReferencedDataKeys((*referencedDataKeys_)[eventSetupRecordKey]);
    }
 }

void EventSetupProvider::finishConfiguration ( )

Definition at line 283 of file EventSetupProvider.cc.

References edm::eventsetup::determinePreferred(), edm::eventsetup::heterocontainer::insert(), instance, 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(Keys::const_iterator itKey = recordsUsing.begin(), itKeyEnd = recordsUsing.end();
           itKey != itKeyEnd;
           ++itKey) {
         (*recordToFinders_)[*itKey].push_back(*itFinder);
          Providers::iterator itFound = providers_.find(*itKey);
          if(providers_.end() == itFound) {
             //create a provider for this record
             insert(*itKey, EventSetupRecordProviderFactoryManager::instance().makeRecordProvider(*itKey));
             itFound = providers_.find(*itKey);
          }
          itFound->second->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(Keys::const_iterator itKey = recordsUsing.begin(), itKeyEnd = recordsUsing.end();
           itKey != itKeyEnd;
           ++itKey) {
 
          if ((*itProvider)->description().isLooper_) {
             recordsWithALooperProxy_->insert(*itKey);
          }
 
          (*psetIDToRecordKey_)[psetID].insert(*itKey);
 
          Providers::iterator itFound = providers_.find(*itKey);
          if(providers_.end() == itFound) {
             //create a provider for this record
             insert(*itKey, EventSetupRecordProviderFactoryManager::instance().makeRecordProvider(*itKey));
             itFound = providers_.find(*itKey);
          }
          itFound->second->add(*itProvider);
       }
    }
    dataProviders_.reset();
    
    //used for the case where no preferred Providers have been specified for the Record
    static const EventSetupRecordProvider::DataToPreferredProviderMap kEmptyMap;
    
    *recordToPreferred_ = determinePreferred(preferredProviderInfo_.get(),providers_);
    //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(Providers::iterator itProvider = providers_.begin(), itProviderEnd = providers_.end();
         itProvider != itProviderEnd;
         ++itProvider) {
       const EventSetupRecordProvider::DataToPreferredProviderMap* preferredInfo = &kEmptyMap;
       RecordToPreferred::const_iterator itRecordFound = recordToPreferred_->find(itProvider->first);
       if(itRecordFound != recordToPreferred_->end()) {
          preferredInfo = &(itRecordFound->second);
       }
       //Give it our list of preferred 
       itProvider->second->usePreferred(*preferredInfo);
       
       std::set<EventSetupRecordKey> records = itProvider->second->dependentRecords();
       if(!records.empty()) {
          std::string missingRecords;
          std::vector<std::shared_ptr<EventSetupRecordProvider> > depProviders;
          depProviders.reserve(records.size());
          bool foundAllProviders = true;
          for(std::set<EventSetupRecordKey>::iterator itRecord = records.begin(),
               itRecordEnd = records.end();
               itRecord != itRecordEnd;
               ++itRecord) {
             Providers::iterator itFound = providers_.find(*itRecord);
             if(itFound == providers_.end()) {
                foundAllProviders = false;
                if(missingRecords.empty()) {
                  missingRecords = itRecord->name();
                } else {
                  missingRecords += ", ";
                  missingRecords += itRecord->name();
                }
                //break;
             } else {
                depProviders.push_back(itFound->second);
             }
          }
          
          if(!foundAllProviders) {
             edm::LogInfo("EventSetupDependency")<<"The EventSetup record "<<itProvider->second->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
          }
           
          itProvider->second->setDependentProviders(depProviders);
       }
    }
    mustFinishConfiguration_ = false;
 }

void EventSetupProvider::forceCacheClear ( )

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

Definition at line 444 of file EventSetupProvider.cc.

Referenced by eventSetup().

 {
    for(Providers::iterator it=providers_.begin(), itEnd = providers_.end();
        it != itEnd;
        ++it) {
       it->second->resetProxies();
    }
 }

template<typename T >

void edm::eventsetup::EventSetupProvider::insert ( std::unique_ptr< T > iRecordProvider )

inlineprotected

Definition at line 113 of file EventSetupProvider.h.

References EventSetupProvider(), edm::eventsetup::heterocontainer::makeKey(), eostools::move(), operator=(), and groupFilesInBlocks::temp.

                                                        {
             std::unique_ptr<EventSetupRecordProvider> temp(iRecordProvider.release());
             insert(eventsetup::heterocontainer::makeKey<
                     typename T::RecordType,
                        eventsetup::EventSetupRecordKey>(),
                     std::move(temp));
          }

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

private

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

Definition at line 785 of file EventSetupProvider.cc.

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

void EventSetupProvider::logInfoWhenSharing ( ParameterSet const & iConfiguration )

static

Definition at line 798 of file EventSetupProvider.cc.

References edm::ParameterSet::getParameter(), diffTwoXMLs::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 insert().

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

Definition at line 766 of file EventSetupProvider.cc.

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

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

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

Definition at line 124 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) {
       std::shared_ptr<EventSetupRecordProvider> const& recordProvider = providers_[key];
       recordProvider->resetProxyProvider(psetID, dataProxyProvider);
    }
 }

void EventSetupProvider::resetRecordPlusDependentRecords ( EventSetupRecordKey const & )

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

Definition at line 424 of file EventSetupProvider.cc.

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

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

 {
   Providers::iterator itFind = providers_.find(iKey);
   if(itFind == providers_.end()) {
     return;
   }
 
   
   std::vector<std::shared_ptr<EventSetupRecordProvider> > dependents;
   findDependents(iKey, providers_.begin(), providers_.end(), dependents);
 
   dependents.erase(std::unique(dependents.begin(),dependents.end()), dependents.end());
   
   itFind->second->resetProxies();
   for(auto& d: dependents) {
     d->resetProxies();
   }
 }

void EventSetupProvider::resetRecordToProxyPointers ( )

Definition at line 714 of file EventSetupProvider.cc.

Referenced by eventSetup().

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

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

inline

Definition at line 106 of file EventSetupProvider.h.

References logInfoWhenSharing(), and subProcessIndex_.

Referenced by checkESProducerSharing().

106 { return subProcessIndex_; }

edm::eventsetup::EventSetupProvider::subProcessIndex_

unsigned subProcessIndex_

Definition: EventSetupProvider.h:134

Member Data Documentation

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

private

Definition at line 140 of file EventSetupProvider.h.

EventSetup edm::eventsetup::EventSetupProvider::eventSetup_

private

Definition at line 129 of file EventSetupProvider.h.

Referenced by eventSetup().

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

private

Definition at line 139 of file EventSetupProvider.h.

std::unique_ptr<EventSetupKnownRecordsSupplier> edm::eventsetup::EventSetupProvider::knownRecordsSupplier_

private

Definition at line 132 of file EventSetupProvider.h.

bool edm::eventsetup::EventSetupProvider::mustFinishConfiguration_

private

Definition at line 133 of file EventSetupProvider.h.

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

private

Definition at line 138 of file EventSetupProvider.h.

Providers edm::eventsetup::EventSetupProvider::providers_

private

Definition at line 131 of file EventSetupProvider.h.

Referenced by checkESProducerSharing().

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

private

Definition at line 143 of file EventSetupProvider.h.

Referenced by checkESProducerSharing().

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

private

Definition at line 145 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 142 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 144 of file EventSetupProvider.h.

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

private

Definition at line 141 of file EventSetupProvider.h.

Referenced by doRecordsMatch().

unsigned edm::eventsetup::EventSetupProvider::subProcessIndex_

private

Definition at line 134 of file EventSetupProvider.h.

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