BPHRecoBuilder.h

Go to the documentation of this file.

#ifndef HeavyFlavorAnalysis_RecoDecay_BPHRecoBuilder_h
#define HeavyFlavorAnalysis_RecoDecay_BPHRecoBuilder_h

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


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

namespace edm {
  class EventSetup;
}

namespace reco {
  class RecoCandidate;
}

//---------------
// C++ Headers --
//---------------
#include <string>
#include <vector>
#include <map>
#include <set>

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

class BPHRecoBuilder {

  friend class BPHRecoSelect;

 public:

  BPHRecoBuilder( const edm::EventSetup& es );

  virtual ~BPHRecoBuilder();

  // common object to interface with edm collections
  class BPHGenericCollection {
   public:
    BPHGenericCollection( const std::string& list ): sList( list ) {}
    virtual ~BPHGenericCollection() {}
    virtual const reco::Candidate& get( int i ) const = 0;
    virtual int size() const = 0;
    const std::string& searchList() const { return sList; }
   private:
    std::string sList;
  };
  template <class T>
  static BPHGenericCollection* createCollection(
                               const edm::Handle<T>& collection,
                               const std::string& list = "cfhpmig" );
  static BPHGenericCollection* createCollection(
                               const std::vector<const reco::Candidate*>&
                               candList,
                               const std::string& list = "cfhpmig" );

  void add( const std::string& name,
            const BPHGenericCollection* collection,
            double mass = -1.0,
            double msig = -1.0 );
  template <class T>
  void add( const std::string& name,
            const edm::Handle<T>& collection,
            double mass = -1.0,
            double msig = -1.0 );
  void add( const std::string& name,
            const std::vector<BPHRecoConstCandPtr>& collection );
  template <class T>
  void add( const std::string& name,
            const std::vector<T>& collection );

  void filter( const std::string& name, const BPHRecoSelect    & sel ) const;
  void filter( const std::string& name, const BPHMomentumSelect& sel ) const;
  void filter( const std::string& name, const BPHVertexSelect  & sel ) const;
  void filter( const std::string& name, const BPHFitSelect     & sel ) const;

  void filter( const BPHMomentumSelect& sel );
  void filter( const BPHVertexSelect& sel );
  void filter( const BPHFitSelect& sel );
  // apply selection to reconstructed candidate
  bool accept( const BPHRecoCandidate& cand ) const;

  void setMinPDiffererence( double pMin );

  struct ComponentSet {
    std::map<std::string,BPHDecayMomentum::Component> daugMap;
    std::map<std::string,BPHRecoConstCandPtr        > compMap;
  };

  std::vector<ComponentSet> build() const;

  const edm::EventSetup* eventSetup() const;

  // compare two particles with their track reference and return 
  // true or false for same or different particles, including a
  // check with momentum difference
  static
  bool sameTrack( const reco::Candidate* lCand,
                  const reco::Candidate* rCand, double minPDifference );

 private:

  // private copy and assigment constructors
  BPHRecoBuilder           ( const BPHRecoBuilder& x );
  BPHRecoBuilder& operator=( const BPHRecoBuilder& x );

  // object to interface with a specific edm collection
  template <class T>
  class BPHSpecificCollection: public BPHGenericCollection {
   public:
    BPHSpecificCollection( const T& c, const std::string& list ):
                           BPHGenericCollection( list ), cPtr( &c ) {}
    virtual ~BPHSpecificCollection() {}
    virtual const reco::Candidate& get( int i ) const { return (*cPtr)[i]; }
    virtual int size() const { return cPtr->size(); }
   private:
    const T* cPtr;
  };

  // object to contain a list of simple particles
  // with their names, selections, masses and sigma
  struct BPHRecoSource {
    const std::string* name;
    const BPHGenericCollection* collection;
    std::vector<const BPHRecoSelect*> selector;
    double mass;
    double msig;
  };

  // object to contain a list of previously reconstructed particles
  // with their names and selections
  struct BPHCompSource {
    const std::string* name;
    const std::vector<BPHRecoConstCandPtr>* collection;
    std::vector<const BPHMomentumSelect*> momSelector;
    std::vector<const BPHVertexSelect*  > vtxSelector;
    std::vector<const BPHFitSelect*     > fitSelector;
  };

  // map of names to simple or previously recontructed particles
  // for currently tested combination 
  mutable std::map<std::string,const reco::Candidate*> daugMap;
  mutable std::map<std::string,BPHRecoConstCandPtr   > compMap;

  const edm::EventSetup* evSetup;
  double minPDiff;

  // list of simple and previously recontructed particles in the decay
  std::vector<BPHRecoSource*> sourceList;
  std::vector<BPHCompSource*> srCompList;

  // set of copies of previously reconstructed particles list
  // for bookkeeping and cleanup
  std::set<const std::vector<BPHRecoConstCandPtr>*> compCollectList;

  // list fo selections to reconstructed particle
  std::vector<const BPHMomentumSelect*> msList;
  std::vector<const BPHVertexSelect  *> vsList;
  std::vector<const BPHFitSelect     *> fsList;

  // map linking particles names to position in list position
  std::map<std::string,int> sourceId;
  std::map<std::string,int> srCompId;

  // recursive function to build particles combinations
  void build( std::vector<ComponentSet>& compList,
              ComponentSet& compSet,
              std::vector<BPHRecoSource*>::const_iterator r_iter,
              std::vector<BPHRecoSource*>::const_iterator r_iend,
              std::vector<BPHCompSource*>::const_iterator c_iter,
              std::vector<BPHCompSource*>::const_iterator c_iend ) const;

  // check for already used particles in a combination
  // previously recontructed particles are assumed to be included
  // after simple particles
  bool contained( ComponentSet& compSet,
                  const reco::Candidate* cand ) const;
  bool contained( ComponentSet& compSet,
                  BPHRecoConstCandPtr cand ) const;
  // compare two particles with their track reference and return 
  // true or false for same or different particles, including a
  // check with momentum difference
  bool sameTrack( const reco::Candidate* lCand,
                  const reco::Candidate* rCand ) const;

};


template <class T>
BPHRecoBuilder::BPHGenericCollection* BPHRecoBuilder::createCollection(
                                      const edm::Handle<T>& collection,
                                      const std::string& list ) {
  return new BPHSpecificCollection<T>( *collection, list );
}


template <class T>
void BPHRecoBuilder::add( const std::string& name,
                          const edm::Handle<T>& collection,
                          double mass,
                          double msig ) {
  // forward call after creating an interface to the collection
  add( name, new BPHSpecificCollection<T>( *collection,
                                           "cfhpmig" ), mass, msig );
  return;
}


template <class T>
void BPHRecoBuilder::add( const std::string& name,
                          const std::vector<T>& collection ) {
  // forward call after converting the list of pointer to a list
  // of pointer to base objects
  int i;
  int n = collection.size();
  std::vector<BPHRecoConstCandPtr>* compCandList =
       new std::vector<BPHRecoConstCandPtr>( n );
  for ( i = 0; i < n; ++i ) (*compCandList)[i] = collection[i];
  // save the converted list for cleanup
  compCollectList.insert( compCandList );
  add( name, *compCandList );
  return;
}


#endif