#include <NumberOfConcurrentIOVs.h>

Public Member Functions
void	clear ()

void	fillRecordsNotAllowingConcurrentIOVs (EventSetupProvider const &)

	NumberOfConcurrentIOVs ()

unsigned int	numberOfConcurrentIOVs (EventSetupRecordKey const &, bool printInfoMsg=false) const

void	readConfigurationParameters (ParameterSet const *eventSetupPset)

void	setMaxConcurrentIOVs (unsigned int nStreams, unsigned int nConcurrentLumis)

Private Attributes
std::vector< std::pair< EventSetupRecordKey, unsigned int > >	forceNumberOfConcurrentIOVs_

unsigned int	maxConcurrentIOVs_ = 1

unsigned int	numberConcurrentIOVs_

std::set< EventSetupRecordKey >	recordsNotAllowingConcurrentIOVs_

Detailed Description

Description: Calculates and holds the number of concurrent intervals of validity allowed for each record in the EventSetup.

Usage: Used internally by the Framework

Definition at line 35 of file NumberOfConcurrentIOVs.h.

Constructor & Destructor Documentation

edm::eventsetup::NumberOfConcurrentIOVs::NumberOfConcurrentIOVs ( )

Definition at line 17 of file NumberOfConcurrentIOVs.cc.

17 : numberConcurrentIOVs_(1) {}

edm::eventsetup::NumberOfConcurrentIOVs::numberConcurrentIOVs_

unsigned int numberConcurrentIOVs_

Definition: NumberOfConcurrentIOVs.h:57

Member Function Documentation

void edm::eventsetup::NumberOfConcurrentIOVs::clear ( void )

Definition at line 75 of file NumberOfConcurrentIOVs.cc.

References forceNumberOfConcurrentIOVs_, numberConcurrentIOVs_, recordsNotAllowingConcurrentIOVs_, and edm::eventsetup::swap().

Referenced by Vispa.Views.WidgetView.WidgetView::closeEvent(), Vispa.Views.BoxDecayView.BoxDecayView::closeEvent(), Vispa.Share.FindAlgorithm.FindAlgorithm::findUsingFindDialog(), edm::eventsetup::EventSetupsController::finishConfiguration(), Vispa.Views.LineDecayView.LineDecayView::setDataObjects(), Vispa.Views.WidgetView.WidgetView::setDataObjects(), Vispa.Views.TreeView.TreeView::updateContent(), Vispa.Views.TableView.TableView::updateContent(), Vispa.Views.BoxDecayView.BoxDecayView::updateContent(), and Vispa.Views.PropertyView.PropertyView::updateContent().

                                        {
       // Mark this as invalid
       numberConcurrentIOVs_ = 0;
 
       // Free up memory
       recordsNotAllowingConcurrentIOVs_.clear();
       std::vector<std::pair<EventSetupRecordKey, unsigned int>>().swap(forceNumberOfConcurrentIOVs_);
     }

void edm::eventsetup::NumberOfConcurrentIOVs::fillRecordsNotAllowingConcurrentIOVs ( EventSetupProvider const & eventSetupProvider )

Definition at line 43 of file NumberOfConcurrentIOVs.cc.

References edm::eventsetup::EventSetupProvider::fillRecordsNotAllowingConcurrentIOVs(), and recordsNotAllowingConcurrentIOVs_.

Referenced by edm::eventsetup::EventSetupsController::finishConfiguration().

                                                                                                                   {
       eventSetupProvider.fillRecordsNotAllowingConcurrentIOVs(recordsNotAllowingConcurrentIOVs_);
     }

unsigned int edm::eventsetup::NumberOfConcurrentIOVs::numberOfConcurrentIOVs	(	EventSetupRecordKey const &	eventSetupKey,
		bool	printInfoMsg = `false`
	)		const

Definition at line 47 of file NumberOfConcurrentIOVs.cc.

References forceNumberOfConcurrentIOVs_, maxConcurrentIOVs_, min(), edm::eventsetup::EventSetupRecordKey::name(), numberConcurrentIOVs_, and recordsNotAllowingConcurrentIOVs_.

Referenced by edm::eventsetup::EventSetupProvider::finishConfiguration(), and edm::eventsetup::EventSetupsController::initializeEventSetupRecordIOVQueues().

                                                                                          {
       assert(numberConcurrentIOVs_ != 0);
       auto iter = std::lower_bound(forceNumberOfConcurrentIOVs_.begin(),
                                    forceNumberOfConcurrentIOVs_.end(),
                                    std::make_pair(eventSetupKey, 0u),
                                    [](auto const& left, auto const& right) { return left.first < right.first; });
       if (iter != forceNumberOfConcurrentIOVs_.end() && iter->first == eventSetupKey) {
         if (printInfoMsg && iter->second > maxConcurrentIOVs_) {
           LogInfo("Configuration") << "For record " << eventSetupKey.name() << " you have configured " << iter->second
                                    << " concurrent IOVs.\n"
                                    << "But you cannot have more concurrent IOVs than lumis or streams.\n"
                                    << "There will not be more than " << maxConcurrentIOVs_ << " concurrent IOVs.\n";
         }
         return std::min(iter->second, maxConcurrentIOVs_);
       }
       if (recordsNotAllowingConcurrentIOVs_.find(eventSetupKey) != recordsNotAllowingConcurrentIOVs_.end()) {
         return 1;
       }
       if (printInfoMsg && numberConcurrentIOVs_ > maxConcurrentIOVs_) {
         LogInfo("Configuration") << "For record " << eventSetupKey.name() << " you have configured "
                                  << numberConcurrentIOVs_ << " concurrent IOVs.\n"
                                  << "But you cannot have more concurrent IOVs than lumis or streams.\n"
                                  << "There will not be more than " << maxConcurrentIOVs_ << " concurrent IOVs.\n";
       }
       return std::min(numberConcurrentIOVs_, maxConcurrentIOVs_);
     }

void edm::eventsetup::NumberOfConcurrentIOVs::readConfigurationParameters ( ParameterSet const * eventSetupPset )

Definition at line 19 of file NumberOfConcurrentIOVs.cc.

References edm::eventsetup::heterocontainer::HCTypeTag::findType(), forceNumberOfConcurrentIOVs_, edm::ParameterSet::getUntrackedParameter(), edm::ParameterSet::getUntrackedParameterSet(), numberConcurrentIOVs_, muonDTDigis_cfi::pset, and align_cfg::recordName.

Referenced by edm::eventsetup::EventSetupsController::makeProvider().

                                                                                                {
       if (eventSetupPset) {  // this condition is false for SubProcesses
         numberConcurrentIOVs_ = eventSetupPset->getUntrackedParameter<unsigned int>("numberOfConcurrentIOVs");
         if (numberConcurrentIOVs_ == 0) {
           numberConcurrentIOVs_ = 1;
         }
 
         ParameterSet const& pset(eventSetupPset->getUntrackedParameterSet("forceNumberOfConcurrentIOVs"));
         std::vector<std::string> recordNames = pset.getParameterNames();
         forceNumberOfConcurrentIOVs_.reserve(recordNames.size());
         for (auto const& recordName : recordNames) {
           EventSetupRecordKey recordKey(eventsetup::EventSetupRecordKey::TypeTag::findType(recordName));
           forceNumberOfConcurrentIOVs_.emplace_back(recordKey, pset.getUntrackedParameter<unsigned int>(recordName));
         }
         std::sort(forceNumberOfConcurrentIOVs_.begin(),
                   forceNumberOfConcurrentIOVs_.end(),
                   [](auto const& left, auto const& right) { return left.first < right.first; });
       }
     }

void edm::eventsetup::NumberOfConcurrentIOVs::setMaxConcurrentIOVs	(	unsigned int	nStreams,
		unsigned int	nConcurrentLumis
	)

Definition at line 39 of file NumberOfConcurrentIOVs.cc.

References maxConcurrentIOVs_, and min().

Referenced by edm::eventsetup::EventSetupsController::setMaxConcurrentIOVs().

                                                                                                           {
       maxConcurrentIOVs_ = std::min(nStreams, nConcurrentLumis);
     }