ToolWithConstants.cxx

Go to the documentation of this file.

/*
 * Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration.
 */
 
 
#include "CaloUtils/ToolWithConstants.h"
 
 
namespace CaloUtils {
 

ToolWithConstantsImpl::ToolWithConstantsImpl
  (const std::string& toolName,
   const std::string& prefix,
   SG::ReadCondHandleKey<CaloRec::ToolConstants>& DBHandle)
  : m_toolName (toolName),
    m_prefix (prefix),
    m_DBHandle (DBHandle)
{
}
 

StatusCode ToolWithConstantsImpl::initialize()
{
  ATH_CHECK( m_DBHandle.initialize (SG::AllowEmpty) );
  return StatusCode::SUCCESS;
}
 

ToolWithConstantsImpl::Context
ToolWithConstantsImpl::context (const EventContext& ctx) const
{
  const CaloRec::ToolConstants* constants = nullptr;
  if (!m_DBHandle.empty()) {
    SG::ReadCondHandle<CaloRec::ToolConstants> consts (m_DBHandle, ctx);
    constants = consts.retrieve();
  }
  return Context (constants, ctx);
}
 

void ToolWithConstantsImpl::addConstant (IToolConstant* c)
{
  m_declaredConstants.push_back (c);
}
 

void ToolWithConstantsImpl::writeConstants (std::ostream& stream,
                                            const std::string& name,
                                            const EventContext& ctx) const
{
  stream << "Member: m_constants" << std::endl;
  m_constants.writeConstants (stream,name);
  if (!m_DBHandle.empty()) {
    SG::ReadCondHandle<CaloRec::ToolConstants> consts (m_DBHandle, ctx);
    stream << "Member: m_DBconstants" << std::endl;
    consts->writeConstants (stream,name);
  }
}
 

StatusCode
ToolWithConstantsImpl::mergeConstants (const std::string& typeName,
                                       int toolVersion,
                                       Context& myctx,
                                       bool isDummy,
                                       CaloRec::ToolConstants& out) const
{
  if (out.clsname().empty()) {
    out.clsname (typeName);
    out.version (toolVersion);
  }
  else if (out.clsname() != typeName) {
    REPORT_ERROR_WITH_CONTEXT(StatusCode::FAILURE, m_toolName)
      << "Trying to write to ToolConstants for tools of differing types: "
      << out.clsname() << " and " << typeName;
    return StatusCode::FAILURE;
  }
  else if (out.version() != toolVersion) {
    REPORT_ERROR_WITH_CONTEXT(StatusCode::FAILURE, m_toolName)
      << "Trying to write to ToolConstants for differing versions of tool "
      << out.clsname() << ": " << out.version() << " and " << toolVersion;
    return StatusCode::FAILURE;
  }
 
  for (IToolConstant* c : m_declaredConstants) {
    std::string cname = c->name();
    std::string prefname = this->m_prefix + cname;
    const CaloRec::Arrayrep* rep = nullptr;
    if (m_constants.hasrep (cname)) {
      rep = &m_constants.getrep (m_toolName, cname);
    }
    if (!c->setFromJO() &&
        myctx.m_constants &&
        myctx.m_constants->hasrep (prefname))
    {
      rep = &myctx.m_constants->getrep (m_toolName, prefname);
    }
    if (!rep) {
      throw ExcConstantNotSet (m_toolName, cname);
    }
 
    if (!isDummy || cname == "isDummy")
      out.setrep (this->m_prefix + cname, *rep);
  }
  return StatusCode::SUCCESS;
}
 
 
} // namespace CaloUtils