CutFlow Class Reference

#include <CutFlow.h>

Collaboration diagram for CutFlow:

Public Types
enum	CutMode { ALL , UNTIL_FAIL }
enum	EReservedCuts { kAll , kIsValidParticle , kNReserved }

Public Member Functions
	CutFlow ()
	CutFlow (unsigned int n_cuts, CutMode cut_mode=UNTIL_FAIL)
std::vector< unsigned int > &	counter ()
const std::vector< unsigned int > &	counter () const
void	update (unsigned int missing_cuts)
void	merge (CutFlow &&a_cutflow)
void	clear ()
std::string	report (const std::vector< std::string > &names)
	Produce a formatted string report of the results.

Private Member Functions
void	update (bool)

Private Attributes
std::vector< unsigned int >	m_counter
bool	m_integrated = false
bool	m_accumulateIntegrated = false

Detailed Description

Definition at line 165 of file CutFlow.h.

Member Enumeration Documentation

CutMode

enum CutFlow::CutMode

Enumerator
ALL
UNTIL_FAIL

Definition at line 169 of file CutFlow.h.

               {
    ALL, UNTIL_FAIL
  };

EReservedCuts

enum CutFlow::EReservedCuts

Enumerator
kAll
kIsValidParticle
kNReserved

Definition at line 173 of file CutFlow.h.

                     {
    kAll,
    kIsValidParticle,
    kNReserved
  };

Constructor & Destructor Documentation

CutFlow() [1/2]

CutFlow::CutFlow ( )

inline

Definition at line 179 of file CutFlow.h.

{}

CutFlow() [2/2]

CutFlow::CutFlow ( unsigned int n_cuts, CutMode cut_mode = UNTIL_FAIL )

inline

Definition at line 181 of file CutFlow.h.

    : m_counter(n_cuts+kNReserved,0) ,
      m_integrated( cut_mode == ALL ),
      m_accumulateIntegrated( cut_mode == ALL )
  {}

Member Function Documentation

clear()

void CutFlow::clear ( )

inline

Definition at line 219 of file CutFlow.h.

               {
    for(unsigned int &count : m_counter)  {count=0; }
  }

counter() [1/2]

std::vector< unsigned int > & CutFlow::counter ( )

inline

Definition at line 187 of file CutFlow.h.

{return m_counter; }

counter() [2/2]

const std::vector< unsigned int > & CutFlow::counter ( ) const

inline

Definition at line 188 of file CutFlow.h.

{return m_counter; }

merge()

void CutFlow::merge ( CutFlow && a_cutflow )

inline

Definition at line 202 of file CutFlow.h.

                                  {
    if (m_counter.empty()) {
      m_counter              = std::move(a_cutflow.m_counter);
      m_integrated           = a_cutflow.m_integrated;
      m_accumulateIntegrated = a_cutflow.m_accumulateIntegrated;
    }
    else {
      if (m_counter.size() != a_cutflow.m_counter.size() || m_integrated != a_cutflow.m_integrated) {
         throw std::logic_error("Tried to merge non matching cut_flows.");
      }
      std::vector<unsigned int>::iterator iter=m_counter.begin();
      for(unsigned int count : a_cutflow.m_counter)  {
        *(iter++)  += count;
      }
    }
  }

report()

std::string CutFlow::report ( const std::vector< std::string > & names )

inline

Produce a formatted string report of the results.

Definition at line 225 of file CutFlow.h.

                                            {
    if (not m_integrated) {
      unsigned int sum=0;
      for(std::vector<unsigned int>::reverse_iterator iter = m_counter.rbegin();
          iter != m_counter.rend();
          ++iter)  {
        *iter += sum;
        sum    = *iter;
      };
      m_integrated=true;
    }
 
    std::string op = "\nCutList Report; Total processed: " + std::to_string(m_counter[kIsValidParticle]);
    op += "\nTotal passed: " + std::to_string(m_counter[m_counter.size()-1]);
    std::string modeString = (m_accumulateIntegrated) ? "\nAll cuts were applied\n" : "\nCuts were applied until one fails\n";
    op += modeString;
    for (unsigned int idx=0; idx<names.size(); ++idx) {
      op += names[idx] + ": " + std::to_string( idx+kNReserved<m_counter.size() ? m_counter[idx+kNReserved] : -1) + " passed\n";
    }
    if (names.size()+kNReserved != m_counter.size()) {
      throw std::logic_error(std::string( "Number of cuts and counters do not match. Resulting report:\n") + op );
    }
    return op;
  }

update() [1/2]

void CutFlow::update ( bool )

inlineprivate

Definition at line 192 of file CutFlow.h.

                    {
  }

update() [2/2]

void CutFlow::update ( unsigned int missing_cuts )

inline

Definition at line 197 of file CutFlow.h.

                                         {
    assert( m_integrated == false);
    ++(m_counter.at(m_counter.size()-missing_cuts-1) );
  }

Member Data Documentation

m_accumulateIntegrated

bool CutFlow::m_accumulateIntegrated = false

private

Definition at line 253 of file CutFlow.h.

m_counter

std::vector<unsigned int> CutFlow::m_counter

private

Definition at line 251 of file CutFlow.h.

m_integrated

bool CutFlow::m_integrated = false

private

Definition at line 252 of file CutFlow.h.

---

The documentation for this class was generated from the following file:

• CutFlow.h