ConditionsManager.cpp

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation 
//--------------------------------------------------------------------------
// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
// All rights reserved.
//
// For the licensing terms see $DD4hepINSTALL/LICENSE.
// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
//
// Author     : M.Frank
//
//==========================================================================
 
// Framework include files
#include <DD4hep/Detector.h>
#include <DD4hep/Errors.h>
#include <DD4hep/Printout.h>
#include <DD4hep/InstanceCount.h>
#include <DD4hep/detail/Handle.inl>
#include <DD4hep/PluginCreators.h>
 
#include <DD4hep/ConditionsListener.h>
#include <DDCond/ConditionsManager.h>
#include <DDCond/ConditionsManagerObject.h>
 
using namespace dd4hep::cond;
 
DD4HEP_INSTANTIATE_HANDLE_NAMED(ConditionsManagerObject);
 
namespace dd4hep {
  
  namespace cond {
 
    template <> ConditionsManager ConditionsManager::from<Detector>(Detector& host)  {
      Object* obj = host.extension<Object>();
      if ( obj ) return ConditionsManager(obj);
      except("ConditionsManager","+++ Failed to access installed manager from Detector.");
      return ConditionsManager();
    }
  }
}
 
ConditionsManagerObject::ConditionsManagerObject(Detector& ref_description)
  : NamedObject(), m_detDesc(ref_description)
{
  InstanceCount::increment(this);
  declareProperty("LoadConditions",           m_doLoad);
  declareProperty("OutputUnloadedConditions", m_doOutputUnloaded);
}
 
ConditionsManagerObject::~ConditionsManagerObject()   {
  m_onRegister.clear();
  m_onRemove.clear();
  InstanceCount::decrement(this);
}
 
void ConditionsManagerObject::registerCallee(Listeners& listeners, const Listener& callee, bool add)  {
  if ( add )  {
    listeners.insert(callee);
    return;
  }
  Listeners::iterator i=listeners.find(callee);
  if ( i != listeners.end() ) listeners.erase(i);  
}
 
void ConditionsManagerObject::callOnRegister(const Listener& callee, bool add)  {
  registerCallee(m_onRegister, callee, add);
}
 
void ConditionsManagerObject::callOnRemove(const Listener& callee, bool add)  {
  registerCallee(m_onRemove, callee, add);
}
 
void ConditionsManagerObject::onRegister(Condition condition)    {
  for(const auto& listener : m_onRegister )
    listener.first->onRegisterCondition(condition, listener.second);
}
 
void ConditionsManagerObject::onRemove(Condition condition)   {
  for(const auto& listener : m_onRemove )
    listener.first->onRegisterCondition(condition, listener.second);
}
 
const std::vector<const dd4hep::IOVType*> ConditionsManagerObject::iovTypesUsed() const   {
  std::vector<const IOVType*> result;
  const auto& types = this->iovTypes();
  for ( const auto& i : types )  {
    if ( i.type != IOVType::UNKNOWN_IOV ) result.emplace_back(&i);
  }
  return result;
}
 
void ConditionsManagerObject::fromString(const std::string& data, IOV& iov)   {
  size_t id1 = data.find(',');
  size_t id2 = data.find('#');
  if ( id2 == std::string::npos )  {
    except("ConditionsManager","+++ Unknown IOV string representation: %s",data.c_str());
  }
  std::string iov_name = data.substr(id2+1);
  IOV::Key key;
  int nents = 0;
  long k1 = 0, k2 = 0;
  if ( id1 != std::string::npos )   {
    nents = ::sscanf(data.c_str(),"%ld,%ld#",&k1,&k2) == 2 ? 2 : 0;
    key.second = k2;
    key.first = k1;
  }
  else  {
    nents = ::sscanf(data.c_str(),"%ld#",&k1) == 1 ? 1 : 0;
    key.second = key.first = k1;
  }
  if ( nents == 0 )   {
    except("ConditionsManager",
           "+++ Failed to read keys from IOV string representation: %s",data.c_str());
  }
 
  // Check if this IOV type is known
  const IOVType* typ = iovType(iov_name);
  if ( !typ )  {
    // Severe: We have an unknown IOV type. This is not allowed, 
    // because we do not known hot to handle it.....
    except("ConditionsManager","+++ Unknown IOV type requested from data: %s. [%s]",
           data.c_str(),Errors::invalidArg().c_str());
  }
  iov.type    = typ->type;
  iov.iovType = typ;
  iov.set(key);
}
 
ConditionsPool* ConditionsManagerObject::registerIOV(const std::string& data)   {
  IOV iov(0);
  // Convert string to IOV
  fromString(data, iov);
  // IOV read and checked. Now register it.
  // The validity of iov->iovType is already ensured in 'fromString'
  return registerIOV(*iov.iovType, iov.keyData);
}
 
ConditionsManager::ConditionsManager(Detector& description, const std::string& factory)   {
  ConditionsManagerObject* obj = createPlugin<ConditionsManagerObject>(factory,description);
  if ( !obj )  {
    except("ConditionsManagerInstaller","Failed to create manager object of type %s",
           factory.c_str());
  }
  assign(obj, "ConditionsManager",factory);
}
 
ConditionsManager::ConditionsManager(Detector& description)  {
  assign(ConditionsManager::from(description).ptr(), "ConditionsManager","");
}
 
ConditionsManager& ConditionsManager::initialize()   {
  access()->initialize();
  return *this;
}
 
dd4hep::Detector& ConditionsManager::detectorDescription()  const   {
  return access()->detectorDescription();
}
 
dd4hep::PropertyManager& ConditionsManager::properties()  const   {
  return access()->properties();
}
 
dd4hep::Property& ConditionsManager::operator[](const std::string& property_name) const    {
  return access()->properties().property(property_name);
}
 
ConditionsDataLoader& ConditionsManager::loader()  const    {
  return *(access()->loader());
}
 
std::pair<bool, const dd4hep::IOVType*> 
ConditionsManager::registerIOVType(size_t iov_type, const std::string& iov_name)  const  {
  return access()->registerIOVType(iov_type, iov_name);
}
 
const dd4hep::IOVType* ConditionsManager::iovType (const std::string& iov_name) const   {
  return access()->iovType(iov_name);
}
 
ConditionsIOVPool* ConditionsManager::iovPool(const IOVType& iov_type)  const {
  return access()->iovPool(iov_type);
}
 
const std::vector<const dd4hep::IOVType*> ConditionsManager::iovTypesUsed() const  {
  Object* obj = access();
  std::vector<const IOVType*> result;
  const auto& types = obj->iovTypes();
  result.reserve(types.size());
  for(const auto& i : types )
    if ( i.type != IOVType::UNKNOWN_IOV ) result.emplace_back(&i);
  return result;
}
 
ConditionsPool* ConditionsManager::registerIOV(const std::string& iov_rep)  const   {
  IOV iov(0);
  Object* o = access();
  o->fromString(iov_rep, iov);
  if ( iov.iovType )
    return o->registerIOV(*iov.iovType, iov.key());
  except("ConditionsManager","Invalid IOV type registration requested by IOV:%s",iov_rep.c_str());
  return 0;
}
      
ConditionsPool* ConditionsManager::registerIOV(const IOV& iov) const   {
  if ( iov.iovType )
    return access()->registerIOV(*iov.iovType, iov.key());
  except("ConditionsManager","+++ Attempt to register invalid IOV [FAILED]");
  return 0;
}
 
ConditionsPool* ConditionsManager::registerIOV(const IOVType& typ, IOV::Key key)   const {
  return access()->registerIOV(typ, key);
}
 
void ConditionsManager::fromString(const std::string& iov_str, IOV& iov)  const  {
  access()->fromString(iov_str, iov);
}
      
std::size_t ConditionsManager::blockRegister(ConditionsPool& pool, const std::vector<Condition>& cond) const   {
  return access()->blockRegister(pool, cond);
}
 
bool ConditionsManager::registerUnlocked(ConditionsPool& pool, Condition cond)  const  {
  return access()->registerUnlocked(pool, cond);
}
 
void ConditionsManager::pushUpdates()  const {
}
 
void ConditionsManager::adoptCleanup(ConditionsCleanup* cleaner)  const   {
  access()->adoptCleanup(cleaner);
}
 
void ConditionsManager::clean(const IOVType* typ, int max_age)  const  {
  access()->clean(typ, max_age);
}
 
void ConditionsManager::clean(const ConditionsCleanup& cleaner)  const   {
  access()->clean(cleaner);  
}
 
void ConditionsManager::clear()  const  {
  access()->clear();
}
 
std::unique_ptr<UserPool> ConditionsManager::createUserPool(const IOVType* iovT)  const   {
  return access()->createUserPool(iovT);
}
 
ConditionsManager::Result
ConditionsManager::prepare(const IOV& req_iov, ConditionsSlice& slice, ConditionUpdateUserContext* ctx)  const  {
  return access()->prepare(req_iov, slice, ctx);
}
 
ConditionsManager::Result
ConditionsManager::load(const IOV& req_iov, ConditionsSlice& slice, ConditionUpdateUserContext* ctx)  const  {
  return access()->load(req_iov, slice, ctx);
}
 
ConditionsManager::Result
ConditionsManager::compute(const IOV& req_iov, ConditionsSlice& slice, ConditionUpdateUserContext* ctx)  const  {
  return access()->compute(req_iov, slice, ctx);
}