/data/doxygen/doxygen-1.7.3/gen/CMSSW_4_2_8/src/PhysicsTools/SelectorUtils/interface/Selector.h

Go to the documentation of this file.

#ifndef PhysicsTools_SelectorUtils_Selector_h
#define PhysicsTools_SelectorUtils_Selector_h

#include "PhysicsTools/SelectorUtils/interface/strbitset.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Common/interface/EventBase.h"
#include <fstream>
#include <functional>

template<class T>
class Selector : public std::binary_function<T, pat::strbitset, bool>  {
  
 public:
  typedef T                                            data_type;
  typedef std::binary_function<T,pat::strbitset,bool>  base_type;
  typedef pat::strbitset::index_type                   index_type;
  typedef std::pair<index_type, size_t>                cut_flow_item;
  typedef std::vector<cut_flow_item>                   cut_flow_map;
  typedef std::map<index_type, int>                    int_map;
  typedef std::map<index_type, double>                 double_map;

  Selector( ) { 
    bits_.clear(); 
    intCuts_.clear(); 
    doubleCuts_.clear();
    cutFlow_.clear();
    retInternal_ = getBitTemplate();
  }
  virtual ~Selector() {}

  virtual void push_back( std::string const & s) {
    bits_.push_back(s);
    index_type i(&bits_,s);    
    // don't need to check to see if the key is already there,
    // bits_ does that.
    cutFlow_.push_back( cut_flow_item(i, 0) );
  }


  virtual void push_back( std::string const & s, int cut) {
    bits_.push_back(s);
    index_type i(&bits_,s);
    intCuts_[i] = cut;
    // don't need to check to see if the key is already there,
    // bits_ does that.
    cutFlow_.push_back( cut_flow_item(i,0) );
  }

  virtual void push_back( std::string const & s, double cut) {
    bits_.push_back(s);
    index_type i(&bits_,s);
    doubleCuts_[i] = cut;
    // don't need to check to see if the key is already there,
    // bits_ does that.
    cutFlow_.push_back( cut_flow_item(i,0) );
  }

  virtual bool operator()( T const & t, pat::strbitset & ret ) = 0;

  virtual bool operator()( T const & t )
  {
    retInternal_.set(false);
    operator()(t, retInternal_);
    setIgnored(retInternal_);
    return (bool)retInternal_;
  }
  

  virtual bool operator()( T const & t, edm::EventBase const & e, pat::strbitset & ret)
  {
    return operator()(t, ret);
  }

  virtual bool operator()( T const & t, edm::EventBase const & e)
  {
    retInternal_.set(false);
    operator()(t, e, retInternal_);
    setIgnored(retInternal_);
    return (bool)retInternal_;
  }


  void set(std::string const & s, bool val = true) {
    set( index_type(&bits_,s), val);
  }
  void set(index_type const & i, bool val = true) {
    bits_[i] = val;
  }

  void set(std::string const & s, int cut, bool val = true) {
    set( index_type(&bits_,s), cut);
  }
  void set(index_type const & i, int cut, bool val = true) {
    bits_[i] = val;
    intCuts_[i] = cut;
  }

  void set(std::string const & s, double cut, bool val = true) {
    set( index_type(&bits_,s), cut);
  }
  void set(index_type const & i, double cut, bool val = true) {
    bits_[i] = val;
    doubleCuts_[i] = cut;
  }

  void clear(std::string const & s) {
    clear(index_type(&bits_,s));
  }

  void clear(index_type const & i) {
    bits_[i] = false;
  }

  bool operator[] ( std::string const & s ) const {
    return bits_[s];
  }

  bool operator[] ( index_type const & i ) const {
    return bits_[i];
  }

  bool considerCut( std::string const & s ) const {
    return bits_[s] == true;
  }
  bool considerCut( index_type const & i  ) const {
    return bits_[i] == true;
  }

  bool ignoreCut( std::string const & s ) const {
    return bits_[s] == false;
  }
  bool ignoreCut( index_type const & i ) const {
    return bits_[i] == false;
  }

  void setIgnoredCuts( std::vector<std::string> const & bitsToIgnore ) {
    for ( std::vector<std::string>::const_iterator ignoreBegin = bitsToIgnore.begin(),
            ignoreEnd = bitsToIgnore.end(), ibit = ignoreBegin;
          ibit != ignoreEnd; ++ibit ) {
      set(*ibit, false );
    }
  }

  void passCut( pat::strbitset & ret, std::string const & s ) {
    passCut( ret, index_type(&bits_,s));
  }

  void passCut( pat::strbitset & ret, index_type const & i ) {
    ret[i] = true;
    cut_flow_map::iterator found = cutFlow_.end();
    for ( cut_flow_map::iterator cutsBegin = cutFlow_.begin(),
            cutsEnd = cutFlow_.end(), icut = cutsBegin;
          icut != cutsEnd && found == cutsEnd; ++icut ) {
      if ( icut->first == i ) {
        found = icut;
      }
    }
    ++(found->second);
  }

  int cut( index_type const & i, int val ) const {
    return intCuts_.find( i )->second;
  };
  double cut( index_type const & i, double val ) const {
    return doubleCuts_.find( i )->second;
  };

  int cut( std::string s, int val ) const {
    return cut( index_type(&bits_,s), val);
  };
  double cut( std::string s, double val ) const {
    return cut( index_type(&bits_,s), val);
  };

  pat::strbitset getBitTemplate() const { 
    pat::strbitset ret = bits_; 
    ret.set(false);
    for ( cut_flow_map::const_iterator cutsBegin = cutFlow_.begin(),
            cutsEnd = cutFlow_.end(), icut = cutsBegin;
          icut != cutsEnd; ++icut ) {
      if ( ignoreCut(icut->first) ) ret[icut->first] = true;
    }     
    return ret;
  }

  void setIgnored( pat::strbitset & ret ) {
    for ( cut_flow_map::const_iterator cutsBegin = cutFlow_.begin(),
            cutsEnd = cutFlow_.end(), icut = cutsBegin;
          icut != cutsEnd; ++icut ) {
      if ( ignoreCut(icut->first) ) ret[icut->first] = true;
    } 
  }

  void print(std::ostream & out) const { 
    for ( cut_flow_map::const_iterator cutsBegin = cutFlow_.begin(),
            cutsEnd = cutFlow_.end(), icut = cutsBegin;
          icut != cutsEnd; ++icut ) {
      char buff[1000];
      if ( considerCut( icut->first ) ) {
        sprintf(buff, "%6lu : %20s %10lu", 
                static_cast<unsigned long>(icut - cutsBegin),
                icut->first.str().c_str(),
                static_cast<unsigned long>(icut->second) );
      } else {
        sprintf(buff, "%6lu : %20s %10s", 
                static_cast<unsigned long>(icut - cutsBegin),
                icut->first.str().c_str(),
                "off" );
      }
      out << buff << std::endl;
    } 
  }

  void printActiveCuts(std::ostream & out) const { 
    bool already_printed_one = false;
    for ( cut_flow_map::const_iterator cutsBegin = cutFlow_.begin(),
            cutsEnd = cutFlow_.end(), icut = cutsBegin;
          icut != cutsEnd; ++icut ) {
      if ( considerCut( icut->first ) ) {
        if( already_printed_one ) out << ", ";
        out << icut->first;
        already_printed_one = true;
      }
    } 
    out << std::endl;
  }

  double getPasses( std::string const & s ) const {
    return getPasses( index_type(&bits_,s) );
  }
  double getPasses( index_type const &i ) const {
    cut_flow_map::iterator found = cutFlow_.end();
    for ( cut_flow_map::iterator cutsBegin = cutFlow_.begin(),
            cutsEnd = cutFlow_.end(), icut = cutsBegin;
          icut != cutsEnd && found == cutsEnd; ++icut ) {
      if ( icut->first == i ) {
        found = icut;
      }
    }
    return found->second;
  }


 protected:
  pat::strbitset bits_;        
  pat::strbitset retInternal_; 
  int_map        intCuts_;     
  double_map     doubleCuts_;  
  cut_flow_map   cutFlow_;     
};

#endif