ThinningCache.cxx

Go to the documentation of this file.

/*
 * Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration.
 */
 
 
#include "AthenaKernel/ThinningCache.h"
#include "AthenaKernel/ThinningDecisionBase.h"
 
 
namespace SG {
 

bool ThinningCache::empty() const
{
  return m_map.empty();
}
 

const ThinningDecisionBase*
ThinningCache::thinning (const std::string& key) const
{
  auto it = m_map.find (key);
  if (it != m_map.end()) {
    return it->second.m_decision;
  }
  return nullptr;
}
 

const ThinningDecisionBase*
ThinningCache::thinning (const sgkey_t sgkey) const
{
  auto it = m_sgmap.find (sgkey);
  if (it != m_sgmap.end()) {
    return it->second.m_decision;
  }
  return nullptr;
}
 

void ThinningCache::addThinning (const std::string& key,
                                 const std::vector<sgkey_t>& sgkeys,
                                 const ThinningDecisionBase* thinning,
                                 bool unique /*= false*/)
{
  if (!thinning) return;
 
  {
    ThinningInfo& info = m_map[key];
    if (info.m_decision) {
      if (!unique) {
        merge (info, sgkeys, *thinning);
        return;
      }
      throw std::runtime_error ("Duplicated thinning definition");
    }
    else {
      info.m_decision = thinning;
    }
  }
 
  for (sgkey_t sgkey : sgkeys) {
    ThinningInfo& info = m_sgmap[sgkey];
    if (info.m_decision) {
      throw std::runtime_error ("Duplicated thinning definition");
    }
    info.m_decision = thinning;
  }
}
 

const ITrigNavigationThinningSvc*
ThinningCache::trigNavigationThinningSvc() const
{
  return m_trigNavigationThinningSvc;
}
 

void ThinningCache::setTrigNavigationThinningSvc (const ITrigNavigationThinningSvc* thinning)
{
  m_trigNavigationThinningSvc = thinning;
}
 

void ThinningCache::lockOwned()
{
  for (const std::unique_ptr<ThinningDecisionBase>& dec : m_owned) {
    dec->buildIndexMap();
  }
}
 

void ThinningCache::setVetoed (const std::string& key,
                               const CxxUtils::ConcurrentBitset& vetoed)
{
  m_map[key].m_vetoed = vetoed;
}

void ThinningCache::setCompression(const std::string& key,
                                   const ThinningInfo::compression_map_t& compression)
{
  m_map[key].m_compression = compression;
}

const ThinningInfo*
ThinningCache::thinningInfo (const std::string& key) const
{
  auto it = m_map.find (key);
  if (it != m_map.end()) {
    return &it->second;
  }
  return nullptr;
}
 

void ThinningCache::clear()
{
  m_map.clear();
  m_sgmap.clear();
  m_owned.clear();
  m_trigNavigationThinningSvc = nullptr;
}
 

void ThinningCache::merge (ThinningInfo& info,
                           const std::vector<sgkey_t>& sgkeys,
                           const ThinningDecisionBase& thinning)
{
  // The existing thinning object.
  ThinningDecisionBase* oldThinning = nullptr;
 
  // Look for the existing object in our list of owned decision objects.
  // If we don't find it, then we'll need to make a copy of the existing
  // decision so that we can modify it.
  // We expect this to be relatively rare and the number of such objects
  // to be small, so just use a linear search.
  auto ownedIt = std::find_if (m_owned.begin(), m_owned.end(),
                               [old = info.m_decision]
                               (const std::unique_ptr<SG::ThinningDecisionBase>& p)
                               { return p.get() == old; });
 
  if (ownedIt != m_owned.end()) {
    // We already own the existing decision.  We can just use it.
    oldThinning = ownedIt->get();
  }
  else {
    // We need to make a copy of the existing decision and enter it into the maps.
    m_owned.push_back (std::make_unique<SG::ThinningDecisionBase> (info.m_decision->size()));
    oldThinning = m_owned.back().get();
    oldThinning->thin (*info.m_decision);
    info.m_decision = oldThinning;
 
    for (sgkey_t sgkey : sgkeys) {
      m_sgmap[sgkey].m_decision = oldThinning;
    }
  }
 
  // Merge the decisions.
  oldThinning->thin (thinning, SG::ThinningDecisionBase::Op::And);
}
 
 
} // namespace SG