/afs/cern.ch/work/a/aaltunda/public/www/CMSSW_5_3_14/src/TopQuarkAnalysis/TopKinFitter/interface/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(std::vector<unsigned int> constraints);
  TtFullHadKinFitter(int jetParam, int maxNrIter, double maxDeltaS, double maxF, std::vector<unsigned int> constraints,
                     double mW=80.4, double mTop=173.,
                     const std::vector<edm::ParameterSet>* udscResolutions=0, 
                     const std::vector<edm::ParameterSet>* bResolutions   =0,
                     const std::vector<double>* jetEnergyResolutionScaleFactors=0,
                     const std::vector<double>* jetEnergyResolutionEtaBinning  =0);
  TtFullHadKinFitter(Param jetParam, int maxNrIter, double maxDeltaS, double maxF, std::vector<Constraint> constraints,
                     double mW=80.4, double mTop=173.,
                     const std::vector<edm::ParameterSet>* udscResolutions=0, 
                     const std::vector<edm::ParameterSet>* bResolutions   =0,
                     const std::vector<double>* jetEnergyResolutionScaleFactors=0,
                     const std::vector<double>* jetEnergyResolutionEtaBinning  =0);
  ~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,
           std::vector<edm::ParameterSet> udscResolutions, std::vector<edm::ParameterSet> 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);
    ~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(std::vector<edm::ParameterSet> udscResolutions, std::vector<edm::ParameterSet> bResolutions,
                        std::vector<double> jetEnergyResolutionScaleFactors, 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, 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(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(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