AcceptData.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
 
// Dear emacs, this is -*-c++-*-
 
#ifndef PATCORE_ACCEPT_DATA_H
#define PATCORE_ACCEPT_DATA_H
 
#include <string>
#include <map>
#include <bitset>
#include <cassert>
#include <PATCore/AcceptInfo.h>
 
 
namespace asg {
  class AcceptData final
  {
 
  public: 
    static const unsigned int NBITS=AcceptInfo::NBITS;
 
    inline explicit AcceptData(const AcceptInfo* val_info)
      : m_info (val_info)
    {}
  
  public:
    explicit inline operator bool() const
    {
      return m_accept == m_info->getCutMask();
    };
 
 
    inline const char* getName() const { return m_info->getName(); };
 
 
    inline void clear() { m_accept.reset(); }
 
    inline void clearPositive() 
    {
      m_accept = m_info->getCutMask();
    }
 
 
    inline unsigned int getNCuts() const { return m_info->getNCuts(); };
 
    inline std::bitset<NBITS> getCutMask() const { return m_info->getCutMask(); };
 
 
    inline unsigned int getCutPosition( const std::string& cutName ) const 
    {
      return m_info->getCutPosition(cutName);
    }
 
 
    const std::string& getCutName( unsigned int cutPosition ) const
    {
      return m_info->getCutName (cutPosition);
    };
 
 
    inline const std::string& getCutDescription( const std::string& cutName ) const
    {
      return m_info->getCutDescription (cutName);
    }
 
    const std::string& getCutDescription( unsigned int cutPosition ) const
    {
      return m_info->getCutDescription (cutPosition);
    }
 
 
    inline bool getCutResult( const std::string& cutName ) const
    {
      unsigned int cutPosition = getCutPosition(cutName);
      return getCutResult(cutPosition);
    }
 
    inline bool getCutResult( unsigned int cutPosition ) const
    {
      return m_accept[cutPosition];
    }
 
 
    inline std::bitset<NBITS> getCutResultBitSet() const
    {
      return m_accept;
    }
 
    inline std::bitset<NBITS> getCutResultInvertedBitSet() const
    {
      return m_accept ^ m_info->getCutMask();
    }
 
    inline unsigned int getCutResultInverted() const
    {
      return getCutResultInvertedBitSet().to_ulong();
    }
 
 
 
    inline void setCutResult( const std::string& cutName, bool cutResult )
    {
      unsigned int cutPosition = getCutPosition(cutName);
      return setCutResult( cutPosition, cutResult );
    }
 
    inline void setCutResult( unsigned int cutPosition, bool cutResult )
    {
      m_accept[cutPosition] = cutResult;
    }
 
    AcceptData& operator|= (const AcceptData& other)
    {
      assert (m_info == other.m_info);
      m_accept |= other.m_accept;
      return *this;
    }
 
 
    // Private members
  private:
    const AcceptInfo *m_info = nullptr;
 
    std::bitset<NBITS> m_accept;
 
  }; // End: class definition
 
} // End: namespace asg
 
 
#endif