SystematicsCache.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/

 
 
#ifndef PAT_INTERFACES__SYSTEMATICS_CACHE_H
#define PAT_INTERFACES__SYSTEMATICS_CACHE_H
 
#include <AsgMessaging/AsgMessagingForward.h>
#include <AsgMessaging/MessageCheck.h>
#include <CxxUtils/checker_macros.h>
#include <PATInterfaces/SystematicSet.h>
#include <functional>
#include <mutex>
#include <tbb/concurrent_unordered_map.h>
 
namespace CP
{
 
  template<typename CalibData>
  class SystematicsCache final : public asg::AsgMessagingForward
  {
 
  public:
 
    using asg::AsgMessagingForward::msg;
 
    template<typename T2>
    SystematicsCache (T2 *val_parent);

    void initialize (CP::SystematicSet val_affectingSystematics,
                     std::function<StatusCode (const CP::SystematicSet& sys, CalibData& result)> val_calc) noexcept;

    const CP::SystematicSet& affectingSystematics () const noexcept;
 

    bool isAffectedBySystematic(const SystematicVariation& systematic) const;
 

    StatusCode get (const CP::SystematicSet& sys, const CalibData*& result) const;
 

    StatusCode add (const CP::SystematicSet& sys, CalibData value);
    StatusCode add (const SystematicVariation& variation, CalibData value);
 

 
  private:

    CP::SystematicSet m_affectingSystematics;

    std::function<StatusCode (const CP::SystematicSet& sys, CalibData& result)> m_calc;

    mutable tbb::concurrent_unordered_map<CP::SystematicSet,std::shared_ptr<const CalibData>,SystematicSetHash> m_cache ATLAS_THREAD_SAFE;

    mutable std::mutex m_calcMutex;
  };
 
 

 
  template<typename CalibData> template<typename T2>
  SystematicsCache<CalibData> ::
  SystematicsCache (T2 *val_parent)
    : AsgMessagingForward (val_parent)
  {}
 
 
 
  template<typename CalibData> void SystematicsCache<CalibData> ::
  initialize (CP::SystematicSet val_affectingSystematics,
              std::function<StatusCode (const CP::SystematicSet& sys, CalibData& result)> val_calc) noexcept
  {
    m_calc = std::move (val_calc);
    m_affectingSystematics = std::move (val_affectingSystematics);
    m_cache.clear ();
  }
 
 
 
  template<typename CalibData>
  const CP::SystematicSet& SystematicsCache<CalibData> ::
  affectingSystematics () const noexcept
  {
    return m_affectingSystematics;
  }
 
 
 
  template<typename CalibData>
  bool SystematicsCache<CalibData> ::
  isAffectedBySystematic(const SystematicVariation& sys) const
  {
    // this is not technically correct, but what a lot of people do
    return m_affectingSystematics.find (sys) != m_affectingSystematics.end();
  }
 
 
 
  template<typename CalibData>
  StatusCode SystematicsCache<CalibData> ::
  get (const CP::SystematicSet& sys, const CalibData*& result) const
  {
    // fast-path, check if we already calculated this
    auto iter = m_cache.find (sys);
    if (iter != m_cache.end()) [[likely]]
    {
      result = iter->second.get();
      return StatusCode::SUCCESS;
    }
 
    // create a lock to prevent the concurrent (or duplicate)
    // execution of the \ref m_calc function.  if that function is
    // thread-safe this lock is not strictly necessary.  however,
    // given that it is hard to enforce that the function is indeed
    // thread-safe and there are essentially no performance gains to
    // be had, this seems safer (unless \ref m_calc acquires mutexes
    // in a way that causes a dead-lock).
    std::lock_guard<std::mutex> lock (m_calcMutex);
 
    // check if another thread already calculated this value while we
    // acquired the lock
    iter = m_cache.find (sys);
    if (iter != m_cache.end())
    {
      result = iter->second.get();
      return StatusCode::SUCCESS;
    }
 
    // we will only ever calculate the systematics for our set of
    // affecting systematics, any systematics that are not affecting
    // us will be ignored
    CP::SystematicSet mysys;
    ANA_CHECK (SystematicSet::filterForAffectingSystematics (sys, m_affectingSystematics, mysys));
 
    std::shared_ptr<const CalibData> mycalib;
    {
      // check if our affecting systematics are known already
      auto iter = m_cache.find (mysys);
      if (iter != m_cache.end())
        mycalib = iter->second;
      else
      {
        // this will now actually calculate the systematics.  note
        // that if this fails, nothing gets cached, but we should also
        // be aborting
        auto value = std::make_shared<CalibData> ();
        ANA_CHECK (m_calc (mysys, *value));
 
        // store for the affecting systematic
        auto emplace_result = m_cache.emplace (mysys, value);
        mycalib = emplace_result.first->second;
      }
    }
 
    // store for user requested systematics as well, which may or may
    // not be the same as the affecting systematics, but if it is
    // already there, this will do nothing.
    m_cache.emplace (sys, mycalib);
    result = mycalib.get();
    return StatusCode::SUCCESS;
  }
 
 
 
  template<typename CalibData>
  StatusCode SystematicsCache<CalibData> ::
  add (const CP::SystematicSet& sys, CalibData value)
  {
    auto emplace_result = m_cache.emplace (sys, std::make_shared<CalibData> (std::move (value)));
    if (emplace_result.second == false)
    {
      ANA_MSG_ERROR ("failed to add systematic, already present: " << sys.name());
      return StatusCode::FAILURE;
    }
 
    for (const auto& var : sys)
      m_affectingSystematics.insert (var);
 
    return StatusCode::SUCCESS;
  }
 
 
 
  template<typename CalibData>
  StatusCode SystematicsCache<CalibData> ::
  add (const SystematicVariation& variation, CalibData value)
  {
    SystematicSet sys;
    sys.insert (variation);
    return add (sys, std::move (value));
  }
}
 
#endif