ThinningDecisionBase.cxx

Go to the documentation of this file.

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

ThinningDecisionBase::ThinningDecisionBase (size_t sz /*= 0*/)
  : m_mask (sz)
{
}
 

void ThinningDecisionBase::resize (const size_t size)
{
  m_mask.resize (size);
}
 

size_t ThinningDecisionBase::thinnedSize() const
{
  return m_mask.size() - m_mask.count();
}
 

void ThinningDecisionBase::thinAll()
{
  m_mask.set();
}
 

void ThinningDecisionBase::keepAll()
{
  m_mask.reset();
}
 

void ThinningDecisionBase::thin (size_t ndx)
{
  if (ndx >= m_mask.size()) {
    throw std::out_of_range ("ThinningDecisionBase::thin");
  }
  m_mask.set (ndx, true);
}
 

void ThinningDecisionBase::keep (size_t ndx)
{
  if (ndx >= m_mask.size()) {
    throw std::out_of_range ("ThinningDecisionBase::thin");
  }
  m_mask.set (ndx, false);
}
 

void ThinningDecisionBase::thin (size_t ndx, bool flag, Op op /*= Op::Set*/)
{
  if (ndx >= m_mask.size()) {
    throw std::out_of_range ("ThinningDecisionBase::thin");
  }
  if (op == Op::And)
    flag &= m_mask[ndx];
  else if (op == Op::Or)
    flag |= m_mask[ndx];
  m_mask.set (ndx, flag);
}
 

void ThinningDecisionBase::keep (size_t ndx, bool flag, Op op /*= Op::Set*/)
{
  if (ndx >= m_mask.size()) {
    throw std::out_of_range ("ThinningDecisionBase::thin");
  }
  if (op == Op::And)
    flag &= !m_mask[ndx];
  else if (op == Op::Or)
    flag |= !m_mask[ndx];
  m_mask.set (ndx, !flag);
}
 

void ThinningDecisionBase::thin (const std::vector<bool>& v, Op op /*= Op::Set*/)
{
  size_t sz = m_mask.size();
  if (sz != v.size()) {
    throw std::out_of_range ("ThinningDecisionBase::thin(): inconsistent vector sizes.");
  }
  for (size_t i = 0; i < sz; i++) {
    bool flag = v[i];
    if (op == Op::And)
      flag &= m_mask[i];
    else if (op == Op::Or)
      flag |= m_mask[i];
    m_mask.set (i, flag);
  }
}
 

void ThinningDecisionBase::keep (const std::vector<bool>& v, Op op /*= Op::Set*/)
{
  size_t sz = m_mask.size();
  if (sz != v.size()) {
    throw std::out_of_range ("ThinningDecisionBase::keep(): inconsistent vector sizes.");
  }
  for (size_t i = 0; i < sz; i++) {
    bool flag = v[i];
    if (op == Op::And)
      flag &= !m_mask[i];
    else if (op == Op::Or)
      flag |= !m_mask[i];
    m_mask.set (i, !flag);
  }
}
 

void ThinningDecisionBase::thin (const ThinningDecisionBase& other, Op op /*= Op::Set*/)
{
  size_t sz = m_mask.size();
  if (sz != other.size()) {
    throw std::out_of_range ("ThinningDecisionBase::thin(): inconsistent vector sizes.");
  }
  if (op == Op::And)
    m_mask &= other.m_mask;
  else if (op == Op::Or)
    m_mask |= other.m_mask;
  else
    m_mask = other.m_mask;
}
 

void ThinningDecisionBase::keep (const ThinningDecisionBase& other, Op op /*= Op::Set*/)
{
  size_t sz = m_mask.size();
  if (sz != other.size()) {
    throw std::out_of_range ("ThinningDecisionBase::keep(): inconsistent vector sizes.");
  }
  if (op == Op::And)
    m_mask |= ~other.m_mask;
  else if (op == Op::Or)
    m_mask &= ~other.m_mask;
  else
    m_mask = ~other.m_mask;
}
 

void ThinningDecisionBase::buildIndexMap()
{
  assert (m_indexMap.empty());
  size_t sz = m_mask.size();
  m_indexMap.resize (sz);
  size_t pos = 0;
  for (size_t i = 0; i < sz; i++) {
    m_indexMap[i] = thinned(i) ? RemovedIdx : pos++ ;
  }
}
 
 
} // namespace SG