SysCopyHandle.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 <SystematicsHandles/AthenaDependencyHelpers.h>
#include <SystematicsHandles/CopyHelpers.h>
 
//
// method implementations
//
 
namespace CP
{
  template<typename T> template<typename T2> SysCopyHandle<T> ::
  SysCopyHandle (T2 *owner, const std::string& propertyName,
                 const std::string& propertyValue,
                 const std::string& propertyDescription)
    : SysCopyHandle (propertyValue, "", owner)
  {
    owner->declareProperty (propertyName, m_inputName, propertyDescription);
    owner->declareProperty (propertyName + "Out", m_outputName, "the (optional) name of the copy we create of " + propertyName);
    owner->declareProperty (propertyName + "Type", m_typeName,
                            "an explicit type name for output dependencies");
  }
 
  template<typename T> template<typename T2> SysCopyHandle<T> ::
  SysCopyHandle (const std::string &inputName, const std::string &outputName, T2 *owner)
    : AsgMessagingForward (owner), m_inputName(inputName), m_outputName(outputName)
    , m_evtStoreGetter ([owner] () {return &*owner->evtStore();})
  {
#ifndef XAOD_STANDALONE
    m_addAlgDependency = [owner](const DataObjID& id, Gaudi::DataHandle::Mode mode) {
      owner->addDependency(id, mode);
    };
#endif
  }
 
 
 
  template<typename T> bool SysCopyHandle<T> ::
  empty () const noexcept
  {
    return m_inputName.empty();
  }
 
 
 
  template<typename T> SysCopyHandle<T> ::
  operator bool () const noexcept
  {
    return !m_inputName.empty();
  }
 
 
 
  template<typename T> std::string SysCopyHandle<T> ::
  getNamePattern () const
  {
    if (!m_outputName.empty())
      return m_outputName;
    else
      return m_inputName;
  }
 
 
 
  template<typename T> StatusCode SysCopyHandle<T> ::
  initialize (SysListHandle& sysListHandle)
  {
    if (!m_outputName.empty())
      ANA_CHECK (sysListHandle.service().registerCopy (m_inputName, m_outputName));
    return sysListHandle.addHandle (*this);
  }
 
 
 
  template<typename T> StatusCode SysCopyHandle<T> ::
  initialize (SysListHandle& sysListHandle, SG::AllowEmptyEnum)
  {
    if (!empty())
      return initialize (sysListHandle);
    else
      return StatusCode::SUCCESS;
  }
 
 
 
  template<typename T> ::StatusCode SysCopyHandle<T> ::
  getCopy (T*& object, const CP::SystematicSet& sys,
           const EventContext& ctx) const
  {
    auto cache = m_sysData.find (sys);
    if (cache == m_sysData.end())
    {
      if (m_sysData.empty())
        throw std::logic_error ("uninitialized SysCopyHandle (" + m_inputName + ")");
      else
        throw std::logic_error ("unsupported systematic in SysCopyHandle (" + m_inputName + "): (" + sys.name() + ")");
    }
    return cache->second.getCopy (msg(), object, ctx);
  }
 
 
 
  template<typename T> CP::SystematicSet SysCopyHandle<T> ::
  getInputAffecting (const ISystematicsSvc& svc) const
  {
    return svc.getObjectSystematics (m_inputName);
  }
 
 
 
  template<typename T> StatusCode SysCopyHandle<T> ::
  fillSystematics (const ISystematicsSvc& svc,
                   const CP::SystematicSet& fullAffecting,
                   const std::vector<CP::SystematicSet>& sysList)
  {
    using NC = std::remove_const_t<T>;
 
    const CP::SystematicSet affecting = svc.getObjectSystematics (m_inputName);
 
    if (!m_outputName.empty())
    {
      ANA_MSG_DEBUG ("SysCopyHandle: " << m_inputName << " make copy " << m_outputName);
      ANA_CHECK (svc.setObjectSystematics (m_outputName, fullAffecting));
    }
 
    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));
 
      SysData data;
      if (m_outputName.empty())
      {
        // if no output name is configured, act like an update handle
        // (or read handle if const qualified) by doing a plain retrieve
        // of the input through the event store.  We can not use a read
        // handle here, since the non-const (update) case needs a
        // non-const retrieve, and `SG::UpdateHandle` is restricted to a
        // small set of explicitly thread-safe types in Athena.
        data.getCopy = [this, inputName] (MsgStream&, T*& object, const EventContext&) -> StatusCode {
          return m_evtStore->retrieve (object, inputName);
        };
      } else
      {
        // if an output name is configured, retrieve the input object as
        // a const object, (shallow) copy it, record the copy and return
        // it.
        std::string outputName;
        ANA_CHECK (svc.makeSystematicsName (outputName, m_outputName, sys));
        ANA_MSG_DEBUG ("SysCopyHandle: " << inputName << " -> " << outputName << " (" << sys.name() << ")");
        SG::ReadHandleKey<NC> key (inputName);
        ANA_CHECK (key.initialize ());
        data.getCopy = [key, outputName] (MsgStream& msg, T*& object, const EventContext& ctx) -> StatusCode {
          SG::ReadHandle<NC> handle (key, ctx);
          const NC *inputObject = handle.cptr ();
          if (inputObject == nullptr)
            return StatusCode::FAILURE;
          // using an intermediate, since in the const version we can't
          // pass in our argument pointer
          NC *tmpObject = nullptr;
          if (detail::ShallowCopy<NC>::getCopy
              (msg, ctx, tmpObject, inputObject, outputName).isFailure())
            return StatusCode::FAILURE;
          object = tmpObject;
          return StatusCode::SUCCESS;
        };
      }
      m_sysData.emplace (sys, std::move (data));
    }
    if (!m_evtStore)
      m_evtStore = m_evtStoreGetter();
 
#ifndef XAOD_STANDALONE
    ANA_CHECK (addDecorationDependency(svc, "", false));
    if (!m_outputName.empty())
    {
      const CLID clidRead = detail::getClidForDependency<std::remove_const_t<T>>("", "deco", false);
      const CLID clidWrite = detail::getClidForDependency<std::remove_const_t<T>>(m_typeName, "deco", true);
      for (const auto& decoName : svc.getObjectDecorations(m_inputName))
      {
        ANA_CHECK (detail::addSysDependency(msg(), svc, m_addAlgDependency, clidRead, m_inputName, Gaudi::DataHandle::Reader, decoName, false));
        ANA_CHECK (detail::addSysDependency(msg(), svc, m_addAlgDependency, clidWrite, m_outputName, Gaudi::DataHandle::Writer, decoName, true));
      }
    }
#endif
 
    return StatusCode::SUCCESS;
  }
 
 
 
  template<typename T> StatusCode SysCopyHandle<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 clidRead = detail::getClidForDependency<std::remove_const_t<T>>("", decoName, decoWrite);
    const CLID clidWrite = detail::getClidForDependency<std::remove_const_t<T>>(m_typeName, decoName, decoWrite);
 
    // if no output name is given, we act like an update or read handle on the input name
    if (m_outputName.empty())
    {
      if (!std::is_const_v<T>)
        ANA_MSG_INFO ("SysCopyHandle acting as update handle for " << m_inputName << " this likely won't work in AthenaMT");
 
      // Both const (read) and non-const (update) use Reader mode for dependencies
      ANA_CHECK (detail::addSysDependency(msg(), svc, m_addAlgDependency, clidRead, m_inputName, Gaudi::DataHandle::Reader, decoName, decoWrite));
      return StatusCode::SUCCESS;
    }
 
    // otherwise we read the input name and write the output name
 
    // if this is for reading a decoration, we only declare it for the
    // input
    if (decoName.empty() || decoWrite == false)
    {
      ANA_CHECK (detail::addSysDependency(msg(), svc, m_addAlgDependency, clidRead, m_inputName, Gaudi::DataHandle::Reader, decoName, decoWrite));
    }
 
    // if this is for adding a decoration, we only declare it for the
    // output
    if (decoName.empty() || decoWrite == true)
    {
      ANA_CHECK (detail::addSysDependency(msg(), svc, m_addAlgDependency, clidWrite, m_outputName, Gaudi::DataHandle::Writer, decoName, decoWrite));
    }
    return StatusCode::SUCCESS;
#endif
  }
}