#include <DependentRecordIntervalFinder.h>

Inheritance diagram for edm::eventsetup::DependentRecordIntervalFinder:

Public Member Functions
void	addProviderWeAreDependentOn (std::shared_ptr< EventSetupRecordProvider >)

	DependentRecordIntervalFinder (const EventSetupRecordKey &)

bool	haveProviders () const

void	setAlternateFinder (std::shared_ptr< EventSetupRecordIntervalFinder >)

	~DependentRecordIntervalFinder () override

Public Member Functions inherited from edm::EventSetupRecordIntervalFinder
const eventsetup::ComponentDescription &	descriptionForFinder () const

	EventSetupRecordIntervalFinder ()

std::set< eventsetup::EventSetupRecordKey >	findingForRecords () const

const ValidityInterval &	findIntervalFor (const eventsetup::EventSetupRecordKey &, const IOVSyncValue &)

void	setDescriptionForFinder (const eventsetup::ComponentDescription &iDescription)

virtual	~EventSetupRecordIntervalFinder () noexcept(false)

Protected Member Functions
void	setIntervalFor (const EventSetupRecordKey &, const IOVSyncValue &, ValidityInterval &) override

Protected Member Functions inherited from edm::EventSetupRecordIntervalFinder
template<class T >
void	findingRecord ()

void	findingRecordWithKey (const eventsetup::EventSetupRecordKey &)

Private Types
typedef std::vector< edm::propagate_const< std::shared_ptr< EventSetupRecordProvider > > >	Providers

Private Member Functions
	DependentRecordIntervalFinder (const DependentRecordIntervalFinder &)=delete

const DependentRecordIntervalFinder &	operator= (const DependentRecordIntervalFinder &)=delete

Private Attributes
edm::propagate_const< std::shared_ptr< EventSetupRecordIntervalFinder > >	alternate_

std::vector< ValidityInterval >	previousIOVs_

Providers	providers_

Detailed Description

Definition at line 36 of file DependentRecordIntervalFinder.h.

Member Typedef Documentation

typedef std::vector<edm::propagate_const<std::shared_ptr<EventSetupRecordProvider> > > edm::eventsetup::DependentRecordIntervalFinder::Providers

private

Definition at line 60 of file DependentRecordIntervalFinder.h.

Constructor & Destructor Documentation

DependentRecordIntervalFinder::DependentRecordIntervalFinder ( const EventSetupRecordKey & iKey )

Definition at line 32 of file DependentRecordIntervalFinder.cc.

References edm::EventSetupRecordIntervalFinder::findingRecordWithKey().

Referenced by haveProviders().

                                                                                                 : providers_() {
       findingRecordWithKey(iKey);
     }

DependentRecordIntervalFinder::~DependentRecordIntervalFinder ( )

override

Definition at line 41 of file DependentRecordIntervalFinder.cc.

41 {}

edm::eventsetup::DependentRecordIntervalFinder::DependentRecordIntervalFinder ( const DependentRecordIntervalFinder & )

privatedelete

Member Function Documentation

void DependentRecordIntervalFinder::addProviderWeAreDependentOn ( std::shared_ptr< EventSetupRecordProvider > iProvider )

Definition at line 58 of file DependentRecordIntervalFinder.cc.

References providers_.

Referenced by haveProviders().

                                                            {
       providers_.push_back(iProvider);
     }

bool edm::eventsetup::DependentRecordIntervalFinder::haveProviders ( ) const

inline

Definition at line 42 of file DependentRecordIntervalFinder.h.

References addProviderWeAreDependentOn(), DependentRecordIntervalFinder(), operator=(), providers_, setAlternateFinder(), and setIntervalFor().

42 { return !providers_.empty(); }

edm::eventsetup::DependentRecordIntervalFinder::providers_

Providers providers_

Definition: DependentRecordIntervalFinder.h:61

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

privatedelete

Referenced by haveProviders().

void DependentRecordIntervalFinder::setAlternateFinder ( std::shared_ptr< EventSetupRecordIntervalFinder > iOther )

Definition at line 63 of file DependentRecordIntervalFinder.cc.

References alternate_.

Referenced by haveProviders().

                                                                                                                {
       alternate_ = iOther;
     }

void DependentRecordIntervalFinder::setIntervalFor	(	const EventSetupRecordKey &	iKey,
		const IOVSyncValue &	iTime,
		ValidityInterval &	oInterval
	)

overrideprotectedvirtual

Implements edm::EventSetupRecordIntervalFinder.

Definition at line 67 of file DependentRecordIntervalFinder.cc.

References alternate_, edm::IOVSyncValue::beginOfTime(), edm::IOVSyncValue::comparable(), edm::IOVSyncValue::endOfTime(), edm::IOVSyncValue::eventID(), edm::ValidityInterval::first(), edm::ValidityInterval::invalidInterval(), edm::IOVSyncValue::invalidIOVSyncValue(), edm::ValidityInterval::last(), edm::EventID::luminosityBlock(), previousIOVs_, providers_, edm::EventID::run(), edm::ValidityInterval::setFirst(), edm::ValidityInterval::setLast(), PFTauMVAInputDiscriminatorTranslator_cfi::test, edm::IOVSyncValue::time(), tmp, edm::Timestamp::unixTime(), and edm::Timestamp::value().

Referenced by haveProviders().

                                                                                     {
       //NOTE: oInterval is the last value that was used so if nothing changed do not modify oInterval
 
       //I am assuming that an invalidTime is always less then the first valid time
       assert(IOVSyncValue::invalidIOVSyncValue() < IOVSyncValue::beginOfTime());
       if (providers_.empty() && alternate_.get() == nullptr) {
         oInterval = ValidityInterval::invalidInterval();
         return;
       }
       bool haveAValidDependentRecord = false;
       bool allRecordsValid = true;
       ValidityInterval newInterval(IOVSyncValue::beginOfTime(), IOVSyncValue::endOfTime());
 
       if (alternate_.get() != nullptr) {
         ValidityInterval test = alternate_->findIntervalFor(iKey, iTime);
         if (test != ValidityInterval::invalidInterval()) {
           haveAValidDependentRecord = true;
           newInterval = test;
         }
       }
       bool intervalsWereComparible = true;
       for (Providers::iterator itProvider = providers_.begin(), itProviderEnd = providers_.end();
            itProvider != itProviderEnd;
            ++itProvider) {
         if ((*itProvider)->setValidityIntervalFor(iTime)) {
           haveAValidDependentRecord = true;
           ValidityInterval providerInterval = (*itProvider)->validityInterval();
           if ((!newInterval.first().comparable(providerInterval.first())) ||
               (!newInterval.last().comparable(providerInterval.last()))) {
             intervalsWereComparible = false;
             break;
           }
           if (newInterval.first() < providerInterval.first()) {
             newInterval.setFirst(providerInterval.first());
           }
           if (newInterval.last() > providerInterval.last()) {
             newInterval.setLast(providerInterval.last());
           }
         } else {
           allRecordsValid = false;
         }
       }
       if (intervalsWereComparible) {
         if (!haveAValidDependentRecord) {
           //If no Finder has no valid time, then this record is also invalid for this time
           newInterval = ValidityInterval::invalidInterval();
         }
         if (!allRecordsValid) {
           //since some of the dependent providers do not have a valid IOV for this syncvalue
           // we do not know what the true end IOV is.  Therefore we must make it open ended
           // so that we can check each time to see if those providers become valid.
           newInterval.setLast(IOVSyncValue::invalidIOVSyncValue());
         }
         oInterval = newInterval;
         return;
       }
       //handle the case where some providers use time and others use run/lumi/event
       // in this case all we can do is find an IOV which changed since last time
       // and use its start time to do the synching and use an 'invalid' end time
       // so the system always checks back to see if something has changed
       if (previousIOVs_.empty()) {
         std::vector<ValidityInterval> tmp(providers_.size(), ValidityInterval());
         previousIOVs_.swap(tmp);
       }
 
       //I'm using an heuristic to pick a reasonable starting point for the IOV. The idea is to
       // assume that lumi sections are 23 seconds long and therefore if we take a difference between
       // iTime and the beginning of a changed IOV we can pick the changed IOV with the start time
       // closest to iTime. This doesn't have to be perfect, we just want to reduce the dependency
       // on provider order to make the jobs more deterministic
 
       bool hadChangedIOV = false;
       //both start at the smallest value
       EventID closestID;
       Timestamp closestTimeStamp(0);
       std::vector<ValidityInterval>::iterator itIOVs = previousIOVs_.begin();
       for (Providers::iterator itProvider = providers_.begin(), itProviderEnd = providers_.end();
            itProvider != itProviderEnd;
            ++itProvider, ++itIOVs) {
         if ((*itProvider)->setValidityIntervalFor(iTime)) {
           ValidityInterval providerInterval = (*itProvider)->validityInterval();
           if (*itIOVs != providerInterval) {
             hadChangedIOV = true;
             if (providerInterval.first().time().value() == 0) {
               //this is a run/lumi based one
               if (closestID < providerInterval.first().eventID()) {
                 closestID = providerInterval.first().eventID();
               }
             } else {
               if (closestTimeStamp < providerInterval.first().time()) {
                 closestTimeStamp = providerInterval.first().time();
               }
             }
             *itIOVs = providerInterval;
           }
         }
       }
       if (hadChangedIOV) {
         if (closestID.run() != 0) {
           if (closestTimeStamp.value() == 0) {
             //no time
             oInterval = ValidityInterval(IOVSyncValue(closestID), IOVSyncValue::invalidIOVSyncValue());
           } else {
             if (closestID.run() == iTime.eventID().run()) {
               //can compare time to lumi
               const unsigned long long kLumiTimeLength = 23;
 
               if ((iTime.eventID().luminosityBlock() - closestID.luminosityBlock()) * kLumiTimeLength <
                   iTime.time().unixTime() - closestTimeStamp.unixTime()) {
                 //closestID was closer
                 oInterval = ValidityInterval(IOVSyncValue(closestID), IOVSyncValue::invalidIOVSyncValue());
               } else {
                 oInterval = ValidityInterval(IOVSyncValue(closestTimeStamp), IOVSyncValue::invalidIOVSyncValue());
               }
             } else {
               //since we don't know how to change run # into time we can't compare
               // so if we have a time just use it
               oInterval = ValidityInterval(IOVSyncValue(closestTimeStamp), IOVSyncValue::invalidIOVSyncValue());
             }
           }
         } else {
           oInterval = ValidityInterval(IOVSyncValue(closestTimeStamp), IOVSyncValue::invalidIOVSyncValue());
         }
       }
     }