SysWriteHandle.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 <AsgMessaging/MessageCheck.h>
#include <SystematicsHandles/AthenaDependencyHelpers.h>
 
//
// method implementations
//
 
namespace CP
{
  template<typename T,typename Aux> template<typename T2> SysWriteHandle<T,Aux> ::
  SysWriteHandle (T2 *owner, const std::string& propertyName,
                 const std::string& propertyValue,
                 const std::string& propertyDescription)
    : SysWriteHandle (propertyValue, owner)
  {
    owner->declareProperty (propertyName, m_outputName, propertyDescription);
    owner->declareProperty (propertyName + "Type", m_outputType,
                            "an explicit type name for output dependencies");
  }
 
 
  template<typename T,typename Aux> template<typename T2> SysWriteHandle<T,Aux> ::
  SysWriteHandle (const std::string &outputName, T2 *owner)
    : AsgMessagingForward (owner), 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,typename Aux> bool SysWriteHandle<T,Aux> ::
  empty () const noexcept
  {
    return m_outputName.empty();
  }
 
 
 
  template<typename T,typename Aux> SysWriteHandle<T,Aux> ::
  operator bool () const noexcept
  {
    return !m_outputName.empty();
  }
 
 
 
  template<typename T,typename Aux> std::string SysWriteHandle<T,Aux> ::
  getNamePattern () const
  {
    return m_outputName;
  }
 
 
 
  template<typename T,typename Aux>
  StatusCode SysWriteHandle<T,Aux> ::
  initialize (SysListHandle& sysListHandle)
  {
    return sysListHandle.addHandle (*this);
  }
 
 
 
  template<typename T,typename Aux>
  StatusCode SysWriteHandle<T,Aux> ::
  initialize (SysListHandle& sysListHandle, SG::AllowEmptyEnum)
  {
    if (!empty())
      return initialize (sysListHandle);
    else
      return StatusCode::SUCCESS;
  }
 
 
 
  template<typename T,typename Aux>
  const std::string& SysWriteHandle<T,Aux> ::
  getName (const CP::SystematicSet& sys) const
  {
    auto cache = m_outputNameCache.find (sys);
    if (cache == m_outputNameCache.end())
    {
      if (m_outputName.empty())
        throw std::logic_error ("uninitialized SysWriteHandle(" + m_outputName + ")");
      else
        throw std::logic_error ("unknown systematic in SysWriteHandle(" + m_outputName + "): (" + sys.name() + ")");
    }
    return cache->second;
  }
 
 
 
  template<typename T,typename Aux>
  template<typename,typename>
  ::StatusCode SysWriteHandle<T,Aux> ::
  record (std::unique_ptr<T> object, const CP::SystematicSet& sys) const
  {
    const std::string& name = getName (sys);
    assert (m_evtStore);
    return m_evtStore->record (object.release(), name);
  }
 
 
 
  template<typename T,typename Aux>
  template<typename,typename>
  ::StatusCode SysWriteHandle<T,Aux> ::
  record (std::unique_ptr<T> object, std::unique_ptr<Aux> aux,
          const CP::SystematicSet& sys) const
  {
    auto cache = m_outputNameCache.find (sys);
    if (cache == m_outputNameCache.end())
    {
      if (m_outputName.empty())
        throw std::logic_error ("uninitialized SysWriteHandle(" + m_outputName + ")");
      else
        throw std::logic_error ("unknown systematic in SysWriteHandle(" + m_outputName + "): (" + sys.name() + ")");
    }
    assert (m_evtStore);
    if (m_evtStore->record (aux.release(), cache->second + "Aux.").isFailure())
      return StatusCode::FAILURE;
    if (m_evtStore->record (object.release(), cache->second).isFailure())
      return StatusCode::FAILURE;
    return StatusCode::SUCCESS;
  }
 
 
 
  template<typename T,typename Aux>
  CP::SystematicSet SysWriteHandle<T,Aux> ::
  getInputAffecting (const ISystematicsSvc& /*svc*/) const
  {
    return CP::SystematicSet ();
  }
 
 
 
  template<typename T,typename Aux>
  StatusCode SysWriteHandle<T,Aux> ::
  fillSystematics (const ISystematicsSvc& svc,
                   const CP::SystematicSet& fullAffecting,
                   const std::vector<CP::SystematicSet>& sysList)
  {
    if (!m_evtStore)
      m_evtStore = m_evtStoreGetter();
    for (auto& sys : sysList)
    {
      std::string newName;
      ANA_CHECK (svc.makeSystematicsName (newName, m_outputName, sys));
      ANA_MSG_DEBUG ("SysWriteHandle: " << newName << " (" << sys.name() << ")");
      m_outputNameCache.emplace (sys, newName);
    }
    ANA_CHECK (svc.setObjectSystematics (m_outputName, fullAffecting));
 
    ANA_CHECK (addDecorationDependency(svc, "", false));
 
    return StatusCode::SUCCESS;
  }
 
 
 
  template<typename T,typename Aux>
  StatusCode SysWriteHandle<T,Aux> ::
  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>(m_outputType, decoName, decoWrite);
    ANA_CHECK (detail::addSysDependency(msg(), svc, m_addAlgDependency, clid, m_outputName, Gaudi::DataHandle::Writer, decoName, decoWrite));
    return StatusCode::SUCCESS;
#endif
  }
}