TtFullHadKinFitter.h

Go to the documentation of this file.

#ifndef TtFullHadKinFitter_h
#define TtFullHadKinFitter_h

#include <vector>

#include "TLorentzVector.h"

#include "AnalysisDataFormats/TopObjects/interface/TtHadEvtSolution.h"

#include "TopQuarkAnalysis/TopKinFitter/interface/CovarianceMatrix.h"
#include "TopQuarkAnalysis/TopKinFitter/interface/TopKinFitter.h"

#include "PhysicsTools/JetMCUtils/interface/combination.h"

#include "FWCore/ParameterSet/interface/ParameterSet.h"

class TAbsFitParticle;
class TFitConstraintM;

/*
  \class   TtFullHadKinFitter TtFullHadKinFitter.h "TopQuarkAnalysis/TopKinFitter/interface/TtFullHadKinFitter.h"
  
  \brief   one line description to be added here...

  text to be added here...
  
**/

class TtFullHadKinFitter : public TopKinFitter {
public:
  enum Constraint { kWPlusMass = 1, kWMinusMass, kTopMass, kTopBarMass, kEqualTopMasses };

public:
  TtFullHadKinFitter();
  std::vector<TtFullHadKinFitter::Constraint> intToConstraint(const std::vector<unsigned int>& constraints);
  TtFullHadKinFitter(int jetParam,
                     int maxNrIter,
                     double maxDeltaS,
                     double maxF,
                     const std::vector<unsigned int>& constraints,
                     double mW = 80.4,
                     double mTop = 173.,
                     const std::vector<edm::ParameterSet>* udscResolutions = nullptr,
                     const std::vector<edm::ParameterSet>* bResolutions = nullptr,
                     const std::vector<double>* jetEnergyResolutionScaleFactors = nullptr,
                     const std::vector<double>* jetEnergyResolutionEtaBinning = nullptr);
  TtFullHadKinFitter(Param jetParam,
                     int maxNrIter,
                     double maxDeltaS,
                     double maxF,
                     const std::vector<Constraint>& constraints,
                     double mW = 80.4,
                     double mTop = 173.,
                     const std::vector<edm::ParameterSet>* udscResolutions = nullptr,
                     const std::vector<edm::ParameterSet>* bResolutions = nullptr,
                     const std::vector<double>* jetEnergyResolutionScaleFactors = nullptr,
                     const std::vector<double>* jetEnergyResolutionEtaBinning = nullptr);
  ~TtFullHadKinFitter();

  int fit(const std::vector<pat::Jet>& jets);
  const pat::Particle fittedB() const { return (fitter_->getStatus() == 0 ? fittedB_ : pat::Particle()); };
  const pat::Particle fittedBBar() const { return (fitter_->getStatus() == 0 ? fittedBBar_ : pat::Particle()); };
  const pat::Particle fittedLightQ() const { return (fitter_->getStatus() == 0 ? fittedLightQ_ : pat::Particle()); };
  const pat::Particle fittedLightQBar() const {
    return (fitter_->getStatus() == 0 ? fittedLightQBar_ : pat::Particle());
  };
  const pat::Particle fittedLightP() const { return (fitter_->getStatus() == 0 ? fittedLightP_ : pat::Particle()); };
  const pat::Particle fittedLightPBar() const {
    return (fitter_->getStatus() == 0 ? fittedLightPBar_ : pat::Particle());
  };
  TtHadEvtSolution addKinFitInfo(TtHadEvtSolution* asol);

private:
  void printSetup() const;
  void setupFitter();
  void setupJets();
  void setupConstraints();

private:
  TAbsFitParticle* b_;
  TAbsFitParticle* bBar_;
  TAbsFitParticle* lightQ_;
  TAbsFitParticle* lightQBar_;
  TAbsFitParticle* lightP_;
  TAbsFitParticle* lightPBar_;
  const std::vector<edm::ParameterSet>* udscResolutions_;
  const std::vector<edm::ParameterSet>* bResolutions_;
  const std::vector<double>* jetEnergyResolutionScaleFactors_;
  const std::vector<double>* jetEnergyResolutionEtaBinning_;
  std::map<Constraint, TFitConstraintM*> massConstr_;
  pat::Particle fittedB_;
  pat::Particle fittedBBar_;
  pat::Particle fittedLightQ_;
  pat::Particle fittedLightQBar_;
  pat::Particle fittedLightP_;
  pat::Particle fittedLightPBar_;
  Param jetParam_;
  std::vector<Constraint> constraints_;

  CovarianceMatrix* covM_;

public:
  struct KinFitResult {
    int Status;
    double Chi2;
    double Prob;
    pat::Particle B;
    pat::Particle BBar;
    pat::Particle LightQ;
    pat::Particle LightQBar;
    pat::Particle LightP;
    pat::Particle LightPBar;
    std::vector<int> JetCombi;
    bool operator<(const KinFitResult& rhs) { return Chi2 < rhs.Chi2; };
  };

  class KinFit {
  public:
    KinFit();
    KinFit(bool useBTagging,
           unsigned int bTags,
           std::string bTagAlgo,
           double minBTagValueBJet,
           double maxBTagValueNonBJet,
           const std::vector<edm::ParameterSet>& udscResolutions,
           const std::vector<edm::ParameterSet>& bResolutions,
           const std::vector<double>& jetEnergyResolutionScaleFactors,
           const std::vector<double>& jetEnergyResolutionEtaBinning,
           std::string jetCorrectionLevel,
           int maxNJets,
           int maxNComb,
           unsigned int maxNrIter,
           double maxDeltaS,
           double maxF,
           unsigned int jetParam,
           const std::vector<unsigned>& constraints,
           double mW,
           double mTop);
    ~KinFit();

    void setBTagging(bool useBTagging,
                     unsigned int bTags,
                     std::string bTagAlgo,
                     double minBTagValueBJet,
                     double maxBTagValueNonBJet) {
      useBTagging_ = useBTagging;
      bTags_ = bTags;
      bTagAlgo_ = bTagAlgo;
      minBTagValueBJet_ = minBTagValueBJet;
      maxBTagValueNonBJet_ = maxBTagValueNonBJet;
    }
    void setResolutions(const std::vector<edm::ParameterSet>& udscResolutions,
                        const std::vector<edm::ParameterSet>& bResolutions,
                        const std::vector<double>& jetEnergyResolutionScaleFactors,
                        const std::vector<double>& jetEnergyResolutionEtaBinning) {
      udscResolutions_ = udscResolutions;
      bResolutions_ = bResolutions;
      jetEnergyResolutionScaleFactors_ = jetEnergyResolutionScaleFactors;
      jetEnergyResolutionEtaBinning_ = jetEnergyResolutionEtaBinning;
    }
    void setFitter(int maxNJets,
                   unsigned int maxNrIter,
                   double maxDeltaS,
                   double maxF,
                   unsigned int jetParam,
                   const std::vector<unsigned>& constraints,
                   double mW,
                   double mTop) {
      maxNJets_ = maxNJets;
      maxNrIter_ = maxNrIter;
      maxDeltaS_ = maxDeltaS;
      maxF_ = maxF;
      jetParam_ = jetParam;
      constraints_ = constraints;
      mW_ = mW;
      mTop_ = mTop;
    }
    void setJEC(std::string jetCorrectionLevel) { jetCorrectionLevel_ = jetCorrectionLevel; }
    void setUseOnlyMatch(bool useOnlyMatch) { useOnlyMatch_ = useOnlyMatch; }
    void setMatch(const std::vector<int>& match) { match_ = match; }
    void setMatchInvalidity(bool invalidMatch) { invalidMatch_ = invalidMatch; }
    void setOutput(int maxNComb) { maxNComb_ = maxNComb; }

    std::list<TtFullHadKinFitter::KinFitResult> fit(const std::vector<pat::Jet>& jets);

  private:
    // helper function for b-tagging
    bool doBTagging(const std::vector<pat::Jet>& jets, const unsigned int& bJetCounter, std::vector<int>& combi);
    pat::Jet corJet(const pat::Jet& jet, const std::string& quarkType);

    // convert unsigned to Param
    TtFullHadKinFitter::Param param(unsigned int configParameter);
    // convert unsigned int to Constraint
    TtFullHadKinFitter::Constraint constraint(unsigned int configParameter);
    // convert vector of unsigned int's to vector of Contraint's
    std::vector<TtFullHadKinFitter::Constraint> constraints(const std::vector<unsigned int>& configParameters);

    bool useBTagging_;
    unsigned int bTags_;
    std::string bTagAlgo_;
    double minBTagValueBJet_;
    double maxBTagValueNonBJet_;
    std::vector<edm::ParameterSet> udscResolutions_, bResolutions_;
    std::vector<double> jetEnergyResolutionScaleFactors_;
    std::vector<double> jetEnergyResolutionEtaBinning_;
    std::string jetCorrectionLevel_;
    int maxNJets_;
    int maxNComb_;
    unsigned int maxNrIter_;
    double maxDeltaS_;
    double maxF_;
    unsigned int jetParam_;
    std::vector<unsigned> constraints_;
    double mW_;
    double mTop_;
    bool useOnlyMatch_;
    std::vector<int> match_;
    bool invalidMatch_;

    TtFullHadKinFitter* fitter;
  };
};

#endif