ConditionsManager.cpp

Go to the documentation of this file.

// $Id$
//==========================================================================
//  AIDA Detector description implementation for LCD
//--------------------------------------------------------------------------
// 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/LCDD.h"
#include "DD4hep/Printout.h"
#include "DDCond/ConditionsInterna.h"
#include "DDCond/ConditionsManager.h"

using namespace std;
using namespace DD4hep;
using namespace DD4hep::Conditions;


namespace DD4hep {
  namespace Conditions {

    template <> ConditionsManager ConditionsManager::from<LCDD>(LCDD& host)  {
      Object* obj = host.extension<Object>();
      if ( obj ) return ConditionsManager(obj);
      except("ConditionsManager","+++ Failed to access manager from LCDD.");
      return ConditionsManager();
    }
  }
}

ConditionsManager::ConditionsManager(LCDD& lcdd)  {
  assign(new Object(lcdd), "ConditionsManager","");
}

ConditionsManager& ConditionsManager::initialize()   {
  access()->initialize();
  return *this;
}

PropertyManager& ConditionsManager::properties()  const   {
  return access()->properties();
}

Property& ConditionsManager::operator[](const std::string& property_name) const    {
  return access()->properties().property(property_name);
}

Handle<ConditionsManager::Loader> ConditionsManager::loader()  const    {
  return access()->loader();
}

pair<bool, const IOVType*> 
ConditionsManager::registerIOVType(size_t iov_type, const string& iov_name)   {
  return access()->registerIOVType(iov_type, iov_name);
}

const IOVType* ConditionsManager::iovType (const string& iov_name) const   {
  return access()->iovType(iov_name);
}

ConditionsIOVPool* ConditionsManager::iovPool(const IOVType& iov_type)  const   {
  return access()->m_rawPool[iov_type.type];
}

const vector<const IOVType*> ConditionsManager::iovTypesUsed() const  {
  Object* obj = access();
  vector<const IOVType*> result;
  const IOVTypes& types = obj->iovTypes();
  for(IOVTypes::const_iterator i=types.begin(); i!=types.end(); ++i)
    if ( int((*i).type) != IOVType::UNKNOWN_IOV ) result.push_back(&(*i));
  return result;
}

ConditionsPool* ConditionsManager::registerIOV(const IOVType& typ, IOV::Key key)   {
  return access()->registerIOV(typ, key);
}

void ConditionsManager::fromString(const string& iov_str, IOV& iov)  {
  access()->fromString(iov_str, iov);
}

bool ConditionsManager::registerUnlocked(ConditionsPool* pool, Condition cond)   {
  return access()->registerUnlocked(pool, cond);
}

void ConditionsManager::clean(const IOVType* typ, int max_age)   {
  access()->clean(typ, max_age);
}

void ConditionsManager::clear()   {
  access()->clear();
}

long ConditionsManager::prepare(const IOV& required_validity,
                                const ConditionKeys& keys,
                                dd4hep_ptr<UserPool>& user_pool)  {
  return access()->prepare(required_validity, keys, user_pool);
}


long ConditionsManager::prepare(const IOV& required_validity,
                                const ConditionKeys&  keys,
                                dd4hep_ptr<UserPool>& user_pool,
                                const Dependencies&   dependencies,
                                bool                  verify_dependencies)  {
  return access()->prepare(required_validity, keys, user_pool, dependencies, verify_dependencies);
}

long ConditionsManager::prepare(const IOV& required_validity, dd4hep_ptr<UserPool>& user_pool)   {
  return access()->prepare(required_validity, user_pool);
}

long ConditionsManager::prepare(const IOV& required_validity,
                                dd4hep_ptr<UserPool>& user_pool,
                                const Dependencies& dependencies,
                                bool verify_dependencies)  {
  return access()->prepare(required_validity, user_pool, dependencies, verify_dependencies);
}