GenericMVAComputer.h

Go to the documentation of this file.

#ifndef RecoBTau_BTauComputer_GenericMVAComputer_h
#define RecoBTau_BTauComputer_GenericMVAComputer_h
 
#include <iterator>
#include <vector>
 
#include "DataFormats/BTauReco/interface/TaggingVariable.h"
#include "PhysicsTools/MVAComputer/interface/AtomicId.h"
#include "PhysicsTools/MVAComputer/interface/Calibration.h"
#include "PhysicsTools/MVAComputer/interface/MVAComputer.h"
 
// overload MVAComputer and replace eval() methods to work on TaggingVariable
class GenericMVAComputer : public PhysicsTools::MVAComputer {
public:
  // forward declarations;
  template <typename Iter_t>
  class TaggingVariableIterator;
  class TaggingVariableMapping;
 
  GenericMVAComputer(const PhysicsTools::Calibration::MVAComputer *calib) : PhysicsTools::MVAComputer(calib) {}
 
  // create wrapping iterator
  template <typename Iter_t>
  inline TaggingVariableIterator<Iter_t> iterator(Iter_t iter) const {
    return TaggingVariableIterator<Iter_t>(&mapping, iter);
  }
 
  // overload eval method to work on containers of TaggingVariable
  template <typename Iter_t>
  inline double eval(Iter_t first, Iter_t last) const {
    typedef TaggingVariableIterator<Iter_t> Wrapped_t;
    return PhysicsTools::MVAComputer::template eval<Wrapped_t>(iterator<Iter_t>(first), iterator<Iter_t>(last));
  }
 
  template <typename Container_t>
  inline double eval(const Container_t &values) const {
    typedef typename Container_t::const_iterator Iter_t;
    return this->template eval<Iter_t>(values.begin(), values.end());
  }
 
  // iterator wrapper with on-the-fly TaggingVariableName -> AtomicId mapping
  //
  // Notice that this tells the computer to completely inline it
  // this is reasonable since inlining it means that the optimizer
  // will not produce any additional code for the wrapper
  // (it is entirely optimized away), except for the actual mapping
  // which is no more than a simple array lookup.
  //
  // The result will be inlined into the eval() template of MVAComputer
  // which will be instantiated as one single tightly-integrated
  // function.
  template <typename Iter_t>
  class TaggingVariableIterator {
  public:
    // class implementing MVAComputer::Variable::Value interface
    struct Value {
    public:
      // the actual operator doing the mapping
      inline PhysicsTools::AtomicId getName() const { return mapping->getAtomicId(iter->first); }
 
      inline double getValue() const { return iter->second; }
 
      operator PhysicsTools::Variable::Value() const { return PhysicsTools::Variable::Value(getName(), getValue()); }
 
    protected:
      friend class TaggingVariableIterator;
 
      inline Value(TaggingVariableMapping const *mapping, const Iter_t &iter) : mapping(mapping), iter(iter) {}
 
    private:
      // pointer to the current mapping
      TaggingVariableMapping const *mapping;
      // iterator to reco::TaggingVariable in orig. container
      Iter_t iter;
    };
 
    typedef std::forward_iterator_tag iterator_category;
    typedef Value value_type;
    typedef typename std::iterator_traits<Iter_t>::difference_type difference_type;
    typedef const Value *pointer;
    typedef const Value &reference;
 
    inline ~TaggingVariableIterator() {}
 
    // methods to make class a standard forward iterator
 
    inline const Value &operator*() const { return value; }
    inline Value &operator*() { return value; }
 
    inline const Value *operator->() const { return &value; }
    inline Value *operator->() { return &value; }
 
    inline bool operator==(const TaggingVariableIterator &other) const { return value.iter == other.value.iter; }
    inline bool operator!=(const TaggingVariableIterator &other) const { return value.iter != other.value.iter; }
    inline bool operator<(const TaggingVariableIterator &other) const { return value.iter < other.value.iter; }
 
    inline TaggingVariableIterator &operator++() {
      ++value.iter;
      return *this;
    }
 
    inline TaggingVariableIterator operator++(int dummy) {
      TaggingVariableIterator orig = *this;
      ++value.iter;
      return orig;
    }
 
  protected:
    friend class GenericMVAComputer;
    inline TaggingVariableIterator(TaggingVariableMapping const *mapping, const Iter_t &iter) : value(mapping, iter) {}
 
  private:
    // holds the current "value"
    // it's really only an iterator that points the original
    // current TaggingVariable plus required methods
    Value value;
  };
 
  // TaggingVariableName -> PhysicsTools::AtomicId mapping
  class TaggingVariableMapping {
  public:
    typedef PhysicsTools::AtomicId AtomicId;
    typedef reco::TaggingVariableName TaggingName;
 
    TaggingVariableMapping();
    ~TaggingVariableMapping() {}
 
    inline AtomicId getAtomicId(TaggingName taggingName) const { return taggingVarToAtomicId[taggingName]; }
 
  private:
    std::vector<AtomicId> taggingVarToAtomicId;
  };
 
private:
  static const TaggingVariableMapping mapping;
};
 
#endif  // RecoBTau_BTauComputer_GenericMVAComputer_h