BPHMultiSelect.h

Go to the documentation of this file.

#ifndef HeavyFlavorAnalysis_RecoDecay_BPHMultiSelect_h
#define HeavyFlavorAnalysis_RecoDecay_BPHMultiSelect_h

//----------------------
// Base Class Headers --
//----------------------


//------------------------------------
// Collaborating Class Declarations --
//------------------------------------
#include "HeavyFlavorAnalysis/RecoDecay/interface/BPHRecoSelect.h"
#include "HeavyFlavorAnalysis/RecoDecay/interface/BPHMomentumSelect.h"
#include "HeavyFlavorAnalysis/RecoDecay/interface/BPHVertexSelect.h"
#include "HeavyFlavorAnalysis/RecoDecay/interface/BPHFitSelect.h"
class BPHRecoBuilder;
class BPHDecayMomentum;
class BPHDecayVertex;

namespace reco {
  class Candidate;
}

//---------------
// C++ Headers --
//---------------
#include <vector>

//              ---------------------
//              -- Class Interface --
//              ---------------------

class BPHSelectOperation {
 public:
  enum mode { or_mode, and_mode };
};


//BPHMultiSelectBase has the implementation needed for accept
// but does not itself override accept
template<class T>
class BPHMultiSelectBase : public T {

 public:
  BPHMultiSelectBase( BPHSelectOperation::mode op ) {
    switch ( op ) {
    case BPHSelectOperation:: or_mode:
      breakValue =  true;
      finalValue = false;
      break;
    case BPHSelectOperation::and_mode:
      breakValue = false;
      finalValue =  true;
      break;
    }
  }

  ~BPHMultiSelectBase() override {}

  void include( T& s, bool m = true ) {
    SelectElement e;
    e.selector = &s;
    e.mode     = m;
    selectList.push_back( e );
    return;
  }

 protected:
  template<class Obj> bool select( const Obj& cand ) const {
    int i;
    int n = selectList.size();
    for ( i = 0; i < n; ++i ) {
      const SelectElement& e = selectList[i];
      if ( ( e.selector->accept( cand ) == e.mode ) == breakValue )
                                                return breakValue;
    }
    return finalValue;
  }
  template<class Obj> bool select( const Obj& cand,
                                   const BPHRecoBuilder* build ) const {
    int i;
    int n = selectList.size();
    for ( i = 0; i < n; ++i ) {
      const SelectElement& e = selectList[i];
      if ( ( e.selector->accept( cand, build ) == e.mode ) == breakValue )
                                                       return breakValue;
    }
    return finalValue;
  }

 private:

  // private copy and assigment constructors
  BPHMultiSelectBase<T>           ( const BPHMultiSelectBase<T>& x ) = delete;
  BPHMultiSelectBase<T>& operator=( const BPHMultiSelectBase<T>& x ) = delete;

  struct SelectElement {
    T* selector;
    bool mode;
  };

  bool breakValue;
  bool finalValue;
  std::vector<SelectElement> selectList;

};

template<class T>
class BPHMultiSelect: public BPHMultiSelectBase<T> {

 public:
  using Base = BPHMultiSelectBase<T>;

  BPHMultiSelect( BPHSelectOperation::mode op ):
  Base(op) {}

  ~BPHMultiSelect() override {}

  bool accept( const typename T::AcceptArg & cand ) const override;

 private:

  // private copy and assigment constructors
  BPHMultiSelect           ( const BPHMultiSelect<T>& x ) = delete;
  BPHMultiSelect& operator=( const BPHMultiSelect<T>& x ) = delete;
};

template<>
class BPHMultiSelect<BPHRecoSelect>: public BPHMultiSelectBase<BPHRecoSelect> {

 public:
  using Base = BPHMultiSelectBase<BPHRecoSelect>;

  BPHMultiSelect( BPHSelectOperation::mode op ):
  Base(op) {}

  ~BPHMultiSelect() override {}

  bool accept( const typename BPHRecoSelect::AcceptArg & cand ) const override;
  bool accept( const reco::Candidate & cand, //NOLINT
           const BPHRecoBuilder*  build ) const override; //NOLINT

 private:

  // private copy and assigment constructors
  BPHMultiSelect           ( const BPHMultiSelect<BPHRecoSelect>& x ) = delete;
  BPHMultiSelect& operator=( const BPHMultiSelect<BPHRecoSelect>& x ) = delete;
};

template<>
bool BPHMultiSelect<BPHMomentumSelect>::accept(
                                        const BPHDecayMomentum& cand ) const;
template<>
bool BPHMultiSelect<BPHVertexSelect  >::accept(
                                        const BPHDecayVertex  & cand ) const;
template<>
bool BPHMultiSelect<BPHFitSelect     >::accept(
                                        const BPHKinematicFit & cand ) const;

#endif