CutFlow.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef _IDPVM_CutFlow_h_
#define _IDPVM_CutFlow_h_
#include <functional>
#include <algorithm>
#include <string>
#include <vector>
 
 
template<class A>
class Accept {
public:
  Accept() : m_predicate([](A) {
    return false;
  }), m_name {}, m_desc {} {
    // nop
  }
  Accept(const std::function<bool(const A&)>& predicate, const std::string& name = "",
         const std::string& description = "") : m_predicate(predicate), m_name(name), m_desc(description)
  {
    // nop
  }
 
  bool
  operator () (const A& i) const {
    return pass(i);
  }
 
  bool
  pass(const A& i) const {
    const bool passed = m_predicate(i);
    return passed;
  }
 
 
  const std::string&
  name() const {
    return m_name;
  }
 
  const std::string&
  description() const {
    return m_desc;
  }
 
  typedef A value_type;
  typedef const std::function<bool (const A&)> func_type;
private:
  // std::function<bool(A)> m_predicate;
  func_type m_predicate;
  std::string m_name;
  std::string m_desc;
};
 
template<class A>
class CutList {
public:
 
  CutList(const std::vector<Accept<A> >& cuts) : m_cuts(cuts) {
    // nop
  }
 
  CutList() : m_cuts{} {
    // nop
  }
 
 
  void
  add(const Accept<A>& newCut) {
    m_cuts.push_back(newCut);
  }
 
  unsigned int
  accept(const A& value) const {
    unsigned int missing_cuts = m_cuts.size();
 
    for (auto& thisCut:m_cuts) {
      if (not thisCut.pass(value)) {
        break;
      }
      --missing_cuts;
    }
    return missing_cuts;
  }
 
  unsigned int
  testAllCuts(const A& value, std::vector<unsigned int> &counter) const {
    unsigned int idx          = 0;
    ++(counter[idx++]);
    if (counter.size() != m_cuts.size()+2 /* CutFlow::kNReserved */) {
      throw std::logic_error("Number of cuts and counters do not match." );
    }
    unsigned int missing_cuts = 0;
    ++(counter[idx++]);
    for (auto& thisCut:m_cuts) {
      if (!thisCut.pass(value)) { ++missing_cuts;   }
      else                      { ++(counter[idx]); }
      ++idx;
    }
    return missing_cuts;
  }
 
  unsigned int
  size() const {
    return m_cuts.size();
  }
 
  std::vector<std::string>
  names() const {
    std::vector<std::string> result(m_cuts.size());
    unsigned int idx(0);
    for (const auto& i:m_cuts) {
      result[idx++] = i.name();
    }
    return result; // return-value-optimisation is invoked
  }
 
private:
  std::vector<Accept<A> > m_cuts;
};
 
class CutFlow
{
public:
 
  enum CutMode {
    ALL, UNTIL_FAIL
  };
 
  enum EReservedCuts {
    kAll,
    kIsValidParticle,
    kNReserved
  };
 
  CutFlow() {}
 
  CutFlow(unsigned int n_cuts, CutMode cut_mode = UNTIL_FAIL)
    : m_counter(n_cuts+kNReserved,0) ,
      m_integrated( cut_mode == ALL ),
      m_accumulateIntegrated( cut_mode == ALL )
  {}
 
  std::vector<unsigned int>       &counter()       {return m_counter; }
  const std::vector<unsigned int> &counter() const {return m_counter; }
 
 private:
  // disallow implicit conversion of CutResult
  void update(bool) {
  }
 
 public:
  //@TODO event weights ?
  void update(unsigned int missing_cuts) {
    assert( m_integrated == false);
    ++(m_counter.at(m_counter.size()-missing_cuts-1) );
  }
 
  void merge(CutFlow &&a_cutflow) {
    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;
      }
    }
  }
 
  void clear() {
    for(unsigned int &count : m_counter)  {count=0; }
  }
 
  std::string
  report(const std::vector<std::string> &names) {
    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;
  }
 
private:
  std::vector<unsigned int> m_counter;
  bool                      m_integrated           = false;
  bool                      m_accumulateIntegrated = false;
};
#endif