/data/refman/pasoursint/CMSSW_5_3_0/src/DataFormats/HepMCCandidate/interface/FlavorHistoryEvent.h

Go to the documentation of this file.

#ifndef HepMCCandidate_FlavorHistoryEvent_h
#define HepMCCandidate_FlavorHistoryEvent_h

// -------------------------------------------------------------
// Identify the class of the event
// 
// Reports nb, nc, nlight genjets that are matched
// to partons.
// 
// -------------------------------------------------------------


#include "DataFormats/Common/interface/Ptr.h"
#include "DataFormats/Common/interface/OwnVector.h"
#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/Common/interface/View.h"
#include "DataFormats/HepMCCandidate/interface/FlavorHistory.h"

#include <fstream>

namespace reco {

  namespace helpers {
    // Helper class to decide which type of event this should be classified as.
    // 
    // Decision is based on a priority weighting of:
    //  1. flavor (5 > 4)
    //  2. type:
    //      2a. Flavor decay
    //      2b. Matrix element
    //      2c. Flavor excitation
    //      2d. Gluon splitting
    //  3. delta R (if applicable)
    //
    struct FlavorHistoryEventHelper{

      FlavorHistoryEventHelper( int iflavor,
                                FlavorHistory::FLAVOR_T iflavorSource,
                                double idR ) :
        flavor(iflavor), flavorSource(iflavorSource), dR(idR)
      {}
      ~FlavorHistoryEventHelper() {}


      // Data members
      int                     flavor;         // pdg id
      FlavorHistory::FLAVOR_T flavorSource;   // flavor source
      double                  dR;             // if there is a sister, dR

      // Comparison operators
      bool operator< ( FlavorHistoryEventHelper const & right) const {
        if ( flavor       > right.flavor       ) return false;
        if ( flavorSource > right.flavorSource ) return false;
        if ( dR           > right.dR           ) return false;
        return true;
      }

      bool operator== ( FlavorHistoryEventHelper const & right) const {
        return flavor == right.flavor &&
          flavorSource == right.flavorSource &&
          dR == right.dR;
      }

      friend std::ostream & operator<< ( std::ostream & out, 
                                         FlavorHistoryEventHelper helper ) {
        char buff[1000];
        sprintf(buff, "Flavor = %2d, type = %2d, dR = %6f",
                helper.flavor, helper.flavorSource, helper.dR );
        out << buff << std::endl;
        return out;
      }
    };
  }

class FlavorHistoryEvent {
public:

  // convenient typedefs
  typedef FlavorHistory                           value_type;
  typedef std::vector<value_type>                 collection_type;
  typedef collection_type::size_type              size_type;
  typedef collection_type::iterator               iterator;
  typedef collection_type::const_iterator         const_iterator;
  typedef collection_type::reverse_iterator       reverse_iterator;
  typedef collection_type::const_reverse_iterator const_reverse_iterator;
  typedef collection_type::pointer                pointer;
  typedef collection_type::const_pointer          const_pointer;
  typedef collection_type::reference              reference;
  typedef collection_type::const_reference        const_reference;
  typedef FlavorHistory::FLAVOR_T                 flavor_type;

  FlavorHistoryEvent() { clear(); }
  ~FlavorHistoryEvent(){}

  // Set up the heavy flavor content
  void                 cache();
  bool                 isCached() const { return cached_; }

  // Accessors to heavy flavor content
  unsigned int         nb() const { if ( isCached() ) return nb_; else return 0;}
  unsigned int         nc() const { if ( isCached() ) return nc_; else return 0;}

  // Accessor to maximum delta R between highest flavor constituents
  double               deltaR() const { if ( isCached() ) return dR_; else return -1.0; }
  unsigned int         highestFlavor() const { if ( isCached() ) return highestFlavor_; else return 0; }
  flavor_type          flavorSource() const { if ( isCached() ) return flavorSource_; else return FlavorHistory::FLAVOR_NULL; }

  // vector interface.. when mutable, make sure cache is set to false.
  // only allow const access via begin, end, rbegin, rend
  size_type               size()   const { return histories_.size(); }
  const_iterator          begin()  const { return histories_.begin(); }
  const_iterator          end()    const { return histories_.end(); }
  const_reverse_iterator  rbegin() const { return histories_.rbegin(); }
  const_reverse_iterator  rend()   const { return histories_.rend(); }
  // here is the proper mutable interface... this is done so that the cache is
  // set by us, not the user
  void                    push_back( value_type v ) { cached_ = false; histories_.push_back(v); }
  void                    resize( size_t n )        { cached_ = false; histories_.resize(n); }
  void                    clear() { cached_ = false; histories_.clear(); nb_ = nc_ = 0; dR_ = 0.0; highestFlavor_ = 0; flavorSource_ = FlavorHistory::FLAVOR_NULL; }

protected:
  collection_type         histories_;           // FlavorHistory vector
  bool                    cached_;              // cached flag
  unsigned int            nb_;                  // number of b quark partons with a matched jet
  unsigned int            nc_;                  // number of c quark partons with a matched jet
  double                  dR_;                  // maximum delta R between highest flavor constituents
  unsigned int            highestFlavor_;       // highest flavor, corresponds to dR
  flavor_type             flavorSource_;        // flavor source
};

}

#endif