/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/PATCore/PATCore/TAccept.h

// Dear emacs, this is -*-c++-*-

#ifndef __TACCEPT__
#define __TACCEPT__

#include <TString.h>
#include <map>
#include <bitset>


static const unsigned int m_nBits=32;



namespace Root {
  class TAccept
  {

  public: 
    TAccept(const char* name="TAccept");

    TAccept( const TAccept& parent );
  
    TAccept& operator= ( const TAccept& rhs );
  
    virtual ~TAccept();
  
  public:
    inline operator bool() const
    {
      return (m_accept.count() == m_cutMap.size()) ? true : false ;
    };


    inline const char* getName() const { return m_name; };


    inline void clear() { m_accept.reset(); }

    inline void clearPositive() 
    {
      for ( unsigned int i=0; i<m_cutMap.size(); ++i ) m_accept[i] = true;
    }


    inline unsigned int getNCuts() const { return m_cutMap.size(); };


    int addCut( const TString& cutName, const TString& cutDescription );


    inline unsigned int getCutPosition( const TString& cutName ) const 
    {
      std::map< TString, std::pair< TString, unsigned int > >::const_iterator it = m_cutMap.find(cutName);
      return (it != m_cutMap.end()) ? (it->second).second : 999999;
    }


    const TString& getCutName( unsigned int cutPosition ) const;


    inline const TString& getCutDescription( const TString& cutName ) const
    {
      std::map< TString, std::pair< TString, unsigned int > >::const_iterator it = m_cutMap.find(cutName);
      return (it != m_cutMap.end()) ? (it->second).first : m_emptyString;
    }

    const TString& getCutDescription( unsigned int cutPosition ) const;


    inline bool getCutResult( const TString& cutName ) const
    {
      unsigned int cutPosition = getCutPosition(cutName);
      return getCutResult(cutPosition);
    }

    inline bool getCutResult( unsigned int cutPosition ) const
    {
      return m_accept[cutPosition];
    }


    inline std::bitset<m_nBits> getCutResultBitSet() const
    {
      return m_accept;
    }

    inline std::bitset<m_nBits> getCutResultInvertedBitSet() const
    {
      std::bitset<m_nBits> inverted;
      // Iterate over the "active" bits and invert them.
      for ( std::size_t i=0; i<m_cutMap.size(); ++i )
      {
        inverted[i] = !(m_accept.test(i));
      }
      return inverted;
    }

    inline unsigned int getCutResultInverted() const
    {
      std::bitset<m_nBits> inverted;
      // Iterate over the "active" bits and invert them.
      for ( std::size_t i=0; i<m_cutMap.size(); ++i )
      {
        inverted[i] = !(m_accept.test(i));
      }
      return inverted.to_ulong();
    }



    inline void setCutResult( const TString& cutName, bool cutResult )
    {
      unsigned int cutPosition = getCutPosition(cutName);
      return setCutResult( cutPosition, cutResult );
    }

    inline void setCutResult( unsigned int cutPosition, bool cutResult )
    {
      m_accept[cutPosition] = cutResult;
      return;
    }


    inline void setCutDescription( const TString& cutName, const TString& cutDescription )
    {
      unsigned int cutPosition = getCutPosition(cutName);
      return setCutDescription( cutPosition, cutDescription );
    }

    void setCutDescription( unsigned int cutPosition, const TString& cutDescription );


#ifdef ROOTCORE

    ClassDef(TAccept,1);
#endif


    // Protected members
  protected:
    TString m_name;


    // Private members
  private:
    std::bitset<m_nBits> m_accept;

    std::map< TString, std::pair< TString, unsigned int > > m_cutMap;

    TString m_emptyString;


  }; // End: class definition

} // End: namespace Root


#endif

---