BPHDecayMomentum.h

Go to the documentation of this file.

#ifndef HeavyFlavorAnalysis_RecoDecay_BPHDecayMomentum_h
#define HeavyFlavorAnalysis_RecoDecay_BPHDecayMomentum_h
 
//----------------------
// Base Class Headers --
//----------------------
 
//------------------------------------
// Collaborating Class Declarations --
//------------------------------------
#include "HeavyFlavorAnalysis/RecoDecay/interface/BPHRecoCandidatePtr.h"
#include "DataFormats/PatCandidates/interface/CompositeCandidate.h"
class BPHRecoBuilder;
 
//---------------
// C++ Headers --
//---------------
#include <vector>
#include <map>
#include <string>
 
//              ---------------------
//              -- Class Interface --
//              ---------------------
 
class BPHDecayMomentum {
  friend class BPHRecoBuilder;
 
public:
  // deleted copy constructor and assignment operator
  BPHDecayMomentum(const BPHDecayMomentum& x) = delete;
  BPHDecayMomentum& operator=(const BPHDecayMomentum& x) = delete;
 
  virtual ~BPHDecayMomentum();
 
  virtual const pat::CompositeCandidate& composite() const;
 
  virtual const std::vector<std::string>& daugNames() const;
 
  virtual const std::vector<std::string>& compNames() const;
 
  virtual const std::vector<const reco::Candidate*>& daughters() const;
 
  virtual const std::vector<const reco::Candidate*>& daughFull() const;
 
  virtual const reco::Candidate* originalReco(const reco::Candidate* daug) const;
 
  virtual const std::vector<BPHRecoConstCandPtr>& daughComp() const;
 
  virtual const reco::Candidate* getDaug(const std::string& name) const;
 
  virtual BPHRecoConstCandPtr getComp(const std::string& name) const;
 
protected:
  struct Component {
    const reco::Candidate* cand;
    double mass;
    double msig;
    std::string searchList;
  };
 
  // constructors
  BPHDecayMomentum();
  BPHDecayMomentum(const std::map<std::string, Component>& daugMap);
  BPHDecayMomentum(const std::map<std::string, Component>& daugMap,
                   const std::map<std::string, BPHRecoConstCandPtr> compMap);
 
  // get an object filled in the constructor
  // to be used in the creation of other bases of BPHRecoCandidate
  const std::vector<Component>& componentList() const;
 
  virtual void addP(const std::string& name, const reco::Candidate* daug, double mass = -1.0);
  virtual void addP(const std::string& name, const BPHRecoConstCandPtr& comp);
 
  // utility function used to cash reconstruction results
  virtual void setNotUpdated() const;
 
  // function doing the job to clone reconstructed decays:
  // copy stable particles and clone cascade decays up to chosen level
  virtual void fill(BPHRecoCandidate* ptr, int level) const = 0;
 
private:
  // object filled in the constructor
  // to be used in the creation of other bases of BPHRecoCandidate
  std::vector<Component> compList;
 
  // names used for simple and previously reconstructed particles
  std::vector<std::string> nList;
  std::vector<std::string> nComp;
 
  // pointers to simple and previously reconstructed particles
  // (clones stored for simple particles)
  std::vector<const reco::Candidate*> dList;
  std::vector<BPHRecoConstCandPtr> cList;
 
  // maps linking names to decay products
  // (simple and previously reconstructed particles)
  std::map<std::string, const reco::Candidate*> dMap;
  std::map<std::string, BPHRecoConstCandPtr> cMap;
 
  // map linking cloned particles to original ones
  std::map<const reco::Candidate*, const reco::Candidate*> clonesMap;
 
  // reconstruction results cache
  mutable bool oldMom;
  mutable std::vector<const reco::Candidate*> dFull;
  mutable pat::CompositeCandidate compCand;
 
  // create clones of simple particles, store them and their names
  void clonesList(const std::map<std::string, Component>& daugMap);
 
  // fill lists of previously reconstructed particles and their names
  // and retrieve cascade decay products
  void dCompList();
 
  // compute the total momentum of simple particles, produced
  // directly or in cascade decays
  virtual void sumMomentum(const std::vector<const reco::Candidate*> dl) const;
 
  // recursively fill the list of simple particles, produced
  // directly or in cascade decays
  virtual void fillDaug(std::vector<const reco::Candidate*>& ad) const;
 
  // compute the total momentum and cache it
  virtual void computeMomentum() const;
};
 
#endif