ConditionsSlice.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 <DDCond/ConditionsSlice.h>
#include <DDCond/ConditionsIOVPool.h>
#include <DD4hep/InstanceCount.h>
#include <DD4hep/Printout.h>
 
using namespace dd4hep::cond;
 
ConditionsSlice::ConditionsSlice(ConditionsManager mgr) : manager(mgr)
{
  InstanceCount::increment(this);  
}
 
ConditionsSlice::ConditionsSlice(ConditionsManager mgr,
                                 const std::shared_ptr<ConditionsContent>& cont)
  : manager(mgr), content(cont)
{
  InstanceCount::increment(this);  
}
 
ConditionsSlice::ConditionsSlice(const ConditionsSlice& copy)
  : manager(copy.manager), content(copy.content)
{
  InstanceCount::increment(this);  
}
 
ConditionsSlice::~ConditionsSlice()   {
  reset();
  InstanceCount::decrement(this);  
}
 
void ConditionsSlice::derefPools()     {
  used_pools.clear(); // Drop all refs possibly pending
  this->flags &= ~REF_POOLS;
}
 
const dd4hep::IOV& ConditionsSlice::iov()  const    {
  if ( pool.get() ) return pool->validity();
  except("ConditionsSlice",
         "pool-iov: Failed to access validity of non-existing pool.");
  return pool->validity();
}
 
void ConditionsSlice::reset()   {
  derefPools();
  if ( pool.get() ) pool->clear();
}
 
bool ConditionsSlice::manage(ConditionsPool* p, Condition condition, ManageFlag flg)   {
  if ( condition.isValid() )  {
    bool ret = false;
    if ( flg&REGISTER_MANAGER )  {
      if ( !p )   {
        except("ConditionsSlice",
               "manage_condition: Cannot access conditions pool according to IOV:%s.",
               pool->validity().str().c_str());
      }
      ret = manager.registerUnlocked(*p,condition);
      if ( !ret )  {
        except("ConditionsSlice",
               "manage_condition: Failed to register condition %016llx according to IOV:%s.",
               condition->hash, pool->validity().str().c_str());
      }
    }
    if ( flg&REGISTER_POOL )  {
      ret = pool->insert(condition);
      if ( !ret )  {
        except("ConditionsSlice",
               "manage_condition: Failed to register condition %016llx to user pool with IOV:%s.",
               condition->hash, pool->validity().str().c_str());
      }
    }
    return ret;
  }
  except("ConditionsSlice",
         "manage_condition: Cannot manage invalid condition!");
  return false;
}
 
bool ConditionsSlice::manage(Condition condition, ManageFlag flg)    {
  ConditionsPool* p = (flg&REGISTER_MANAGER) ? manager.registerIOV(pool->validity()) : 0;
  return manage(p, condition, flg);
}
 
std::vector<dd4hep::Condition> ConditionsSlice::get(DetElement detector)  const  {
  return pool->get(detector,FIRST_ITEM,LAST_ITEM);
}
 
std::vector<dd4hep::Condition> ConditionsSlice::get(DetElement detector,
                                                    Condition::itemkey_type lower,
                                                    Condition::itemkey_type upper)  const  {
  return pool->get(detector, lower, upper);
}
 
bool ConditionsSlice::insert(DetElement detector, Condition::itemkey_type key, Condition condition)   {
  if ( condition.isValid() )  {
    ConditionsPool* p = manager.registerIOV(pool->validity());
    if ( !p )   {
      except("ConditionsSlice",
             "manage_condition: Cannot access conditions pool according to IOV:%s.",
             pool->validity().str().c_str());
    }
    bool ret = manager.registerUnlocked(*p,condition);
    if ( !ret )  {
      except("ConditionsSlice",
             "manage_condition: Failed to register condition %016llx according to IOV:%s.",
             condition->hash, pool->validity().str().c_str());
    }
    return pool->insert(detector, key, condition);
  }
  except("ConditionsSlice",
         "insert_condition: Cannot insert invalid condition to the user pool!");
  return false;
}
 
dd4hep::Condition ConditionsSlice::get(DetElement detector, Condition::itemkey_type key)  const   {
  return pool->get(detector, key);
}
 
void ConditionsSlice::scan(const Condition::Processor& processor) const   {
  pool->scan(processor);
}
 
void ConditionsSlice::scan(DetElement         detector,
                           Condition::itemkey_type       lower,
                           Condition::itemkey_type       upper,
                           const Condition::Processor&   processor) const  {
  pool->scan(detector, lower, upper, processor);
}
 
namespace  {
  
  struct SliceOper  : public dd4hep::ConditionsSelect  {
    ConditionsContent& content;
    SliceOper(ConditionsContent& c) : content(c) {}
    void operator()(const ConditionsIOVPool::Elements::value_type& v)    {
      v.second->select_all(*this);
    }
    bool operator()(dd4hep::Condition::Object* c)  const  {
      if ( 0 == (c->flags&dd4hep::Condition::DERIVED) )   {
#if !defined(DD4HEP_MINIMAL_CONDITIONS)
        content.addLocation(c->hash,c->address);
#endif
        return true;
      }
      return true;
    }
    virtual size_t size()  const { return content.conditions().size(); }
  };
}
 
void dd4hep::cond::fill_content(ConditionsManager mgr,
                                ConditionsContent& content,
                                const IOVType& typ)
{
  ConditionsIOVPool* iovPool = mgr.iovPool(typ);
  ConditionsIOVPool::Elements& pools = iovPool->elements;
  for_each(begin(pools),end(pools),SliceOper(content));
}