#include <DependentRecordIntervalFinder.h>

Inheritance diagram for edm::eventsetup::DependentRecordIntervalFinder:

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

	DependentRecordIntervalFinder (const EventSetupRecordKey &)

bool	haveProviders () const

void	setAlternateFinder (boost::shared_ptr< EventSetupRecordIntervalFinder >)

virtual	~DependentRecordIntervalFinder ()

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 ()

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

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

void	findingRecordWithKey (const eventsetup::EventSetupRecordKey &)

Private Types
typedef std::vector < boost::shared_ptr < EventSetupRecordProvider > >	Providers

Private Member Functions
	DependentRecordIntervalFinder (const DependentRecordIntervalFinder &)

const DependentRecordIntervalFinder &	operator= (const DependentRecordIntervalFinder &)

Private Attributes
boost::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< boost::shared_ptr<EventSetupRecordProvider> > edm::eventsetup::DependentRecordIntervalFinder::Providers

private

Definition at line 65 of file DependentRecordIntervalFinder.h.

Constructor & Destructor Documentation

DependentRecordIntervalFinder::DependentRecordIntervalFinder ( const EventSetupRecordKey & iKey )

Definition at line 32 of file DependentRecordIntervalFinder.cc.

References edm::EventSetupRecordIntervalFinder::findingRecordWithKey().

                                                                                             :
   providers_()
 {
    findingRecordWithKey(iKey);
 }

DependentRecordIntervalFinder::~DependentRecordIntervalFinder ( )

virtual

Definition at line 43 of file DependentRecordIntervalFinder.cc.

44 {

45 }

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

private

Member Function Documentation

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

Definition at line 63 of file DependentRecordIntervalFinder.cc.

References providers_.

Referenced by edm::eventsetup::EventSetupRecordProvider::setDependentProviders().

 {
    providers_.push_back(iProvider);
 }

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

inline

Definition at line 44 of file DependentRecordIntervalFinder.h.

References providers_.

                                  {
         return !providers_.empty();
       }

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

private

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

Definition at line 69 of file DependentRecordIntervalFinder.cc.

References alternate_.

 {
   alternate_ = iOther;
 }

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

protectedvirtual

Implements edm::EventSetupRecordIntervalFinder.

Definition at line 75 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(), run_regression::test, edm::IOVSyncValue::time(), tmp, edm::Timestamp::unixTime(), and edm::Timestamp::value().

 {
    //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_.size() == 0 && alternate_.get() == 0 ) {
       oInterval = ValidityInterval::invalidInterval();
       return;
    }
    bool haveAValidDependentRecord = false;
    bool allRecordsValid = true;
    ValidityInterval newInterval(IOVSyncValue::beginOfTime(), IOVSyncValue::endOfTime());
    
    if (alternate_.get() != 0) {
      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());
       }
    }
 }