SysReadHandle.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
*/
 
/// @author Nils Krumnack
 
 
//
// includes
//
 
#include <AsgDataHandles/ReadHandle.h>
#include <AsgMessaging/MessageCheck.h>
#include <AsgMessaging/StatusCode.h>
#include <SystematicsHandles/AthenaDependencyHelpers.h>
#include <SystematicsHandles/ISystematicsSvc.h>
#include <SystematicsHandles/SysListHandle.h>
 
//
// method implementations
//
 
namespace CP
{
  template<typename T> template<typename T2> SysReadHandle<T> ::
  SysReadHandle (T2 *owner, const std::string& propertyName,
                 const std::string& propertyValue,
                 const std::string& propertyDescription)
    : SysReadHandle (propertyValue, owner)
  {
    owner->declareProperty (propertyName, m_inputName, propertyDescription);
  }
 
  template<typename T> template<typename T2> SysReadHandle<T> ::
  SysReadHandle (const std::string &inputName, T2 *owner)
    : AsgMessagingForward (owner), m_inputName(inputName)
  {
#ifndef XAOD_STANDALONE
    m_addAlgDependency = [owner](const DataObjID& id, Gaudi::DataHandle::Mode mode) {
      owner->addDependency(id, mode);
    };
#endif
  }
 
 
  template<typename T> bool SysReadHandle<T> ::
  empty () const noexcept
  {
    return m_inputName.empty();
  }
 
 
 
  template<typename T> SysReadHandle<T> ::
  operator bool () const noexcept
  {
    return !m_inputName.empty();
  }
 
 
 
  template<typename T> std::string SysReadHandle<T> ::
  getNamePattern () const
  {
    return m_inputName;
  }
 
 
 
  template<typename T> StatusCode SysReadHandle<T> ::
  initialize (SysListHandle& sysListHandle)
  {
    return sysListHandle.addHandle (*this);
  }
 
 
 
  template<typename T> StatusCode SysReadHandle<T> ::
  initialize (SysListHandle& sysListHandle, SG::AllowEmptyEnum)
  {
    if (!empty())
      return initialize (sysListHandle);
    else
      return StatusCode::SUCCESS;
  }
 
 
 
  template<typename T> const std::string& SysReadHandle<T> ::
  getName (const CP::SystematicSet& sys) const
  {
    return getReadHandle (sys).key();
  }
 
 
 
  template<typename T> ::StatusCode SysReadHandle<T> ::
  retrieve (const T*& object, const CP::SystematicSet& sys,
            const EventContext& ctx) const
  {
    SG::ReadHandle<T> handle (getReadHandle (sys), ctx);
    object = handle.cptr();
    if (object == nullptr)
      return StatusCode::FAILURE;
    return StatusCode::SUCCESS;
  }
 
 
 
  template<typename T> bool SysReadHandle<T> ::
  isValid (const CP::SystematicSet& sys, const EventContext& ctx) const
  {
    SG::ReadHandle<T> handle (getReadHandle (sys), ctx);
    return handle.isPresent();
  }
 
 
 
  template<typename T> CP::SystematicSet SysReadHandle<T> ::
  getInputAffecting (const ISystematicsSvc& svc) const
  {
    return svc.getObjectSystematics (m_inputName);
  }
 
 
 
  template<typename T> StatusCode SysReadHandle<T> ::
  fillSystematics (const ISystematicsSvc& svc,
                   const CP::SystematicSet& /*fullAffecting*/,
                   const std::vector<CP::SystematicSet>& sysList)
  {
    const CP::SystematicSet affecting = svc.getObjectSystematics (m_inputName);
    for (auto& sys : sysList)
    {
      CP::SystematicSet inputSys;
      ANA_CHECK (SystematicSet::filterForAffectingSystematics (sys, affecting, inputSys));
      std::string inputName;
      ANA_CHECK (svc.makeSystematicsName (inputName, m_inputName, inputSys));
      SG::ReadHandleKey<T> readHandle (inputName);
      ANA_CHECK (readHandle.initialize ());
      m_sysData.emplace (sys, SysData{std::move (readHandle)});
    }
 
    ANA_CHECK (addDecorationDependency(svc, "", false));
 
    return StatusCode::SUCCESS;
  }
 
 
 
  template<typename T> StatusCode SysReadHandle<T> ::
  addDecorationDependency (const ISystematicsSvc& svc, const std::string& decoName, bool decoWrite)
  {
#ifdef XAOD_STANDALONE
    (void) svc;
    (void) decoName;
    (void) decoWrite;
    return StatusCode::SUCCESS;
#else
    const CLID clid = detail::getClidForDependency<T>("", decoName, decoWrite);
    ANA_CHECK (detail::addSysDependency(msg(), svc, m_addAlgDependency, clid, m_inputName, Gaudi::DataHandle::Reader, decoName, decoWrite));
    return StatusCode::SUCCESS;
#endif
  }
 
 
 
  template<typename T> const SG::ReadHandleKey<T>& SysReadHandle<T> ::
  getReadHandle (const CP::SystematicSet& sys) const
  {
    auto cache = m_sysData.find (sys);
    if (cache == m_sysData.end())
    {
      if (m_sysData.empty())
        throw std::logic_error ("uninitialized SysReadHandle (" + m_inputName + ")");
      else
        throw std::logic_error ("unsupported systematic in SysReadHandle (" + m_inputName + "): (" + sys.name() + ")");
    }
    return cache->second.readHandle;
  }
}