TtSemiLepHitFitProducer< LeptonCollection > Class Template Reference

Inheritance diagram for TtSemiLepHitFitProducer< LeptonCollection >:

Classes
struct	FitResult

Public Member Functions
	TtSemiLepHitFitProducer (const edm::ParameterSet &)
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
	EDProducer (const EDProducer &)=delete
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final
const EDProducer &	operator= (const EDProducer &)=delete

Private Types
typedef hitfit::RunHitFit< pat::Electron, pat::Muon, pat::Jet, pat::MET >	PatHitFit

Private Member Functions
void	produce (edm::Event &, const edm::EventSetup &) override

Private Attributes
std::string	bTagAlgo_
	input tag for b-tagging algorithm More...
hitfit::LeptonTranslatorBase< pat::Electron >	electronTranslator_
std::unique_ptr< PatHitFit >	HitFit
edm::FileInPath	hitfitBJetResolution_
edm::FileInPath	hitfitDefault_
edm::FileInPath	hitfitElectronResolution_
edm::FileInPath	hitfitMETResolution_
edm::FileInPath	hitfitMuonResolution_
edm::FileInPath	hitfitUdscJetResolution_
double	jes_
	jet energy scale More...
double	jesB_
std::string	jetCorrectionLevel_
	jet correction level More...
edm::EDGetTokenT< std::vector< pat::Jet > >	jetsToken_
hitfit::JetTranslatorBase< pat::Jet >	jetTranslator_
edm::EDGetTokenT< LeptonCollection >	lepsToken_
double	maxBTagValueNonBJet_
	max value of bTag for a non-b-jet More...
double	maxEtaEle_
	maximum eta value for electrons, needed to limited range in which resolutions are provided More...
double	maxEtaJet_
	maximum eta value for jets, needed to limited range in which resolutions are provided More...
double	maxEtaMu_
	maximum eta value for muons, needed to limited range in which resolutions are provided More...
int	maxNComb_
	maximal number of combinations to be written to the event More...
int	maxNJets_
	maximal number of jets (-1 possible to indicate 'all') More...
edm::EDGetTokenT< std::vector< pat::MET > >	metsToken_
hitfit::METTranslatorBase< pat::MET >	metTranslator_
double	minBTagValueBJet_
	min value of bTag for a b-jet More...
double	mTop_
hitfit::LeptonTranslatorBase< pat::Muon >	muonTranslator_
double	mW_
	constraints More...
bool	useBTag_
	switch to tell whether to use b-tagging or not More...

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >
using	GlobalCache = typename CacheTypes::GlobalCache
using	HasAbility = AbilityChecker< T... >
using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
using	RunCache = typename CacheTypes::RunCache
using	RunContext = RunContextT< RunCache, GlobalCache >
using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

template<typename LeptonCollection>
class TtSemiLepHitFitProducer< LeptonCollection >

Definition at line 18 of file TtSemiLepHitFitProducer.cc.

Member Typedef Documentation

PatHitFit

template<typename LeptonCollection >

typedef hitfit::RunHitFit<pat::Electron, pat::Muon, pat::Jet, pat::MET> TtSemiLepHitFitProducer< LeptonCollection >::PatHitFit

private

Definition at line 78 of file TtSemiLepHitFitProducer.cc.

Constructor & Destructor Documentation

TtSemiLepHitFitProducer()

template<typename LeptonCollection >

TtSemiLepHitFitProducer< LeptonCollection >::TtSemiLepHitFitProducer ( const edm::ParameterSet &  cfg )

explicit

Definition at line 96 of file TtSemiLepHitFitProducer.cc.

References TtSemiLepHitFitProducer< LeptonCollection >::electronTranslator_, edm::FileInPath::fullPath(), TtSemiLepHitFitProducer< LeptonCollection >::HitFit, TtSemiLepHitFitProducer< LeptonCollection >::hitfitDefault_, TtSemiLepHitFitProducer< LeptonCollection >::jetTranslator_, TtSemiLepHitFitProducer< LeptonCollection >::maxEtaEle_, TtSemiLepHitFitProducer< LeptonCollection >::maxEtaJet_, TtSemiLepHitFitProducer< LeptonCollection >::maxEtaMu_, TtSemiLepHitFitProducer< LeptonCollection >::metTranslator_, TtSemiLepHitFitProducer< LeptonCollection >::mTop_, TtSemiLepHitFitProducer< LeptonCollection >::muonTranslator_, and TtSemiLepHitFitProducer< LeptonCollection >::mW_.

    : jetsToken_(consumes<std::vector<pat::Jet> >(cfg.getParameter<edm::InputTag>("jets"))),
      lepsToken_(consumes<LeptonCollection>(cfg.getParameter<edm::InputTag>("leps"))),
      metsToken_(consumes<std::vector<pat::MET> >(cfg.getParameter<edm::InputTag>("mets"))),
      maxNJets_(cfg.getParameter<int>("maxNJets")),
      maxNComb_(cfg.getParameter<int>("maxNComb")),
      bTagAlgo_(cfg.getParameter<std::string>("bTagAlgo")),
      minBTagValueBJet_(cfg.getParameter<double>("minBDiscBJets")),
      maxBTagValueNonBJet_(cfg.getParameter<double>("maxBDiscLightJets")),
      useBTag_(cfg.getParameter<bool>("useBTagging")),
      mW_(cfg.getParameter<double>("mW")),
      mTop_(cfg.getParameter<double>("mTop")),
      jetCorrectionLevel_(cfg.getParameter<std::string>("jetCorrectionLevel")),
      jes_(cfg.getParameter<double>("jes")),
      jesB_(cfg.getParameter<double>("jesB")),

      // The following five initializers read the config parameters for the
      // ASCII text files which contains the physics object resolutions.
      hitfitDefault_(cfg.getUntrackedParameter<edm::FileInPath>(
          std::string("hitfitDefault"),
          edm::FileInPath(std::string("TopQuarkAnalysis/TopHitFit/data/setting/RunHitFitConfiguration.txt")))),
      hitfitElectronResolution_(cfg.getUntrackedParameter<edm::FileInPath>(
          std::string("hitfitElectronResolution"),
          edm::FileInPath(std::string("TopQuarkAnalysis/TopHitFit/data/resolution/tqafElectronResolution.txt")))),
      hitfitMuonResolution_(cfg.getUntrackedParameter<edm::FileInPath>(
          std::string("hitfitMuonResolution"),
          edm::FileInPath(std::string("TopQuarkAnalysis/TopHitFit/data/resolution/tqafMuonResolution.txt")))),
      hitfitUdscJetResolution_(cfg.getUntrackedParameter<edm::FileInPath>(
          std::string("hitfitUdscJetResolution"),
          edm::FileInPath(std::string("TopQuarkAnalysis/TopHitFit/data/resolution/tqafUdscJetResolution.txt")))),
      hitfitBJetResolution_(cfg.getUntrackedParameter<edm::FileInPath>(
          std::string("hitfitBJetResolution"),
          edm::FileInPath(std::string("TopQuarkAnalysis/TopHitFit/data/resolution/tqafBJetResolution.txt")))),
      hitfitMETResolution_(cfg.getUntrackedParameter<edm::FileInPath>(
          std::string("hitfitMETResolution"),
          edm::FileInPath(std::string("TopQuarkAnalysis/TopHitFit/data/resolution/tqafKtResolution.txt")))),

      // The following four initializers instantiate the translator between PAT objects
      // and HitFit objects using the ASCII text files which contains the resolutions.
      electronTranslator_(hitfitElectronResolution_.fullPath()),
      muonTranslator_(hitfitMuonResolution_.fullPath()),
      jetTranslator_(
          hitfitUdscJetResolution_.fullPath(), hitfitBJetResolution_.fullPath(), jetCorrectionLevel_, jes_, jesB_),
      metTranslator_(hitfitMETResolution_.fullPath())

{
  // Create an instance of RunHitFit and initialize it.
  HitFit = std::make_unique<PatHitFit>(
      electronTranslator_, muonTranslator_, jetTranslator_, metTranslator_, hitfitDefault_.fullPath(), mW_, mW_, mTop_);

  maxEtaMu_ = 2.4;
  maxEtaEle_ = 2.5;
  maxEtaJet_ = 2.5;

  edm::LogVerbatim("TopHitFit") << "\n"
                                << "+++++++++++ TtSemiLepHitFitProducer ++++++++++++ \n"
                                << " Due to the eta ranges for which resolutions     \n"
                                << " are provided in                                 \n"
                                << " TopQuarkAnalysis/TopHitFit/data/resolution/     \n"
                                << " so far, the following cuts are currently        \n"
                                << " implemented in the TtSemiLepHitFitProducer:     \n"
                                << " |eta(muons    )| <= " << maxEtaMu_ << " \n"
                                << " |eta(electrons)| <= " << maxEtaEle_ << " \n"
                                << " |eta(jets     )| <= " << maxEtaJet_ << " \n"
                                << "++++++++++++++++++++++++++++++++++++++++++++++++ \n";

  produces<std::vector<pat::Particle> >("PartonsHadP");
  produces<std::vector<pat::Particle> >("PartonsHadQ");
  produces<std::vector<pat::Particle> >("PartonsHadB");
  produces<std::vector<pat::Particle> >("PartonsLepB");
  produces<std::vector<pat::Particle> >("Leptons");
  produces<std::vector<pat::Particle> >("Neutrinos");

  produces<std::vector<std::vector<int> > >();
  produces<std::vector<double> >("Chi2");
  produces<std::vector<double> >("Prob");
  produces<std::vector<double> >("MT");
  produces<std::vector<double> >("SigMT");
  produces<std::vector<int> >("Status");
  produces<int>("NumberOfConsideredJets");
}

Member Function Documentation

produce()

template<typename LeptonCollection >

void TtSemiLepHitFitProducer< LeptonCollection >::produce ( edm::Event &  evt, const edm::EventSetup &  setup  )

overrideprivate

Definition at line 179 of file TtSemiLepHitFitProducer.cc.

References funct::abs(), PVValHelper::eta, JetChargeProducer_cfi::exp, L1TowerCalibrationProducer_cfi::fit, edm::Event::getByToken(), TtSemiLepEvtPartons::HadB, mps_fire::i, createfilelist::int, metsig::jet, hitfit::Lepjets_Event::jet(), singleTopDQM_cfi::jets, hitfit::Lepjets_Event::lep(), TtSemiLepEvtPartons::LepB, TtSemiLepHitFitProducer_Electrons_cfi::leps, TtSemiLepEvtPartons::LightQ, TtSemiLepEvtPartons::LightQBar, hitfit::Lepjets_Event::met(), singleTopDQM_cfi::mets, eostools::move(), nPartons, hitfit::Lepjets_Event_Lep::p(), edm::Event::put(), mps_fire::result, hitfit::Lepjets_Event_Lep::type(), and trackerHitRTTI::vector.

                                                                                                 {
  std::unique_ptr<std::vector<pat::Particle> > pPartonsHadP(new std::vector<pat::Particle>);
  std::unique_ptr<std::vector<pat::Particle> > pPartonsHadQ(new std::vector<pat::Particle>);
  std::unique_ptr<std::vector<pat::Particle> > pPartonsHadB(new std::vector<pat::Particle>);
  std::unique_ptr<std::vector<pat::Particle> > pPartonsLepB(new std::vector<pat::Particle>);
  std::unique_ptr<std::vector<pat::Particle> > pLeptons(new std::vector<pat::Particle>);
  std::unique_ptr<std::vector<pat::Particle> > pNeutrinos(new std::vector<pat::Particle>);

  std::unique_ptr<std::vector<std::vector<int> > > pCombi(new std::vector<std::vector<int> >);
  std::unique_ptr<std::vector<double> > pChi2(new std::vector<double>);
  std::unique_ptr<std::vector<double> > pProb(new std::vector<double>);
  std::unique_ptr<std::vector<double> > pMT(new std::vector<double>);
  std::unique_ptr<std::vector<double> > pSigMT(new std::vector<double>);
  std::unique_ptr<std::vector<int> > pStatus(new std::vector<int>);
  std::unique_ptr<int> pJetsConsidered(new int);

  edm::Handle<std::vector<pat::Jet> > jets;
  evt.getByToken(jetsToken_, jets);

  edm::Handle<std::vector<pat::MET> > mets;
  evt.getByToken(metsToken_, mets);

  edm::Handle<LeptonCollection> leps;
  evt.getByToken(lepsToken_, leps);

  // -----------------------------------------------------
  // skip events with no appropriate lepton candidate in
  // or empty MET or less jets than partons
  // -----------------------------------------------------

  const unsigned int nPartons = 4;

  // Clear the internal state
  HitFit->clear();

  // Add lepton into HitFit
  bool foundLepton = false;
  if (!leps->empty()) {
    double maxEtaLep = maxEtaMu_;
    if (!dynamic_cast<const reco::Muon*>(&((*leps)[0])))  // assume electron if it is not a muon
      maxEtaLep = maxEtaEle_;
    for (unsigned iLep = 0; iLep < (*leps).size() && !foundLepton; ++iLep) {
      if (std::abs((*leps)[iLep].eta()) <= maxEtaLep) {
        HitFit->AddLepton((*leps)[iLep]);
        foundLepton = true;
      }
    }
  }

  // Add jets into HitFit
  unsigned int nJetsFound = 0;
  for (unsigned iJet = 0; iJet < (*jets).size() && (int)nJetsFound != maxNJets_; ++iJet) {
    double jet_eta = (*jets)[iJet].eta();
    if ((*jets)[iJet].isCaloJet()) {
      jet_eta = ((reco::CaloJet*)((*jets)[iJet]).originalObject())->detectorP4().eta();
    }
    if (std::abs(jet_eta) <= maxEtaJet_) {
      HitFit->AddJet((*jets)[iJet]);
      nJetsFound++;
    }
  }
  *pJetsConsidered = nJetsFound;

  // Add missing transverse energy into HitFit
  if (!mets->empty())
    HitFit->SetMet((*mets)[0]);

  if (!foundLepton || mets->empty() || nJetsFound < nPartons) {
    // the kinFit getters return empty objects here
    pPartonsHadP->push_back(pat::Particle());
    pPartonsHadQ->push_back(pat::Particle());
    pPartonsHadB->push_back(pat::Particle());
    pPartonsLepB->push_back(pat::Particle());
    pLeptons->push_back(pat::Particle());
    pNeutrinos->push_back(pat::Particle());
    // indices referring to the jet combination
    std::vector<int> invalidCombi;
    for (unsigned int i = 0; i < nPartons; ++i)
      invalidCombi.push_back(-1);
    pCombi->push_back(invalidCombi);
    // chi2
    pChi2->push_back(-1.);
    // chi2 probability
    pProb->push_back(-1.);
    // fitted top mass
    pMT->push_back(-1.);
    pSigMT->push_back(-1.);
    // status of the fitter
    pStatus->push_back(-1);
    // feed out all products
    evt.put(std::move(pCombi));
    evt.put(std::move(pPartonsHadP), "PartonsHadP");
    evt.put(std::move(pPartonsHadQ), "PartonsHadQ");
    evt.put(std::move(pPartonsHadB), "PartonsHadB");
    evt.put(std::move(pPartonsLepB), "PartonsLepB");
    evt.put(std::move(pLeptons), "Leptons");
    evt.put(std::move(pNeutrinos), "Neutrinos");
    evt.put(std::move(pChi2), "Chi2");
    evt.put(std::move(pProb), "Prob");
    evt.put(std::move(pMT), "MT");
    evt.put(std::move(pSigMT), "SigMT");
    evt.put(std::move(pStatus), "Status");
    evt.put(std::move(pJetsConsidered), "NumberOfConsideredJets");
    return;
  }

  std::list<FitResult> FitResultList;

  //
  // BEGIN DECLARATION OF VARIABLES FROM KINEMATIC FIT
  //

  // In this part are variables from the
  // kinematic fit procedure

  // Number of all permutations of the event
  size_t nHitFit = 0;

  // Number of jets in the event
  size_t nHitFitJet = 0;

  // Results of the fit for all jet permutations of the event
  std::vector<hitfit::Fit_Result> hitFitResult;

  //
  // R U N   H I T F I T
  //
  // Run the kinematic fit and get how many permutations are possible
  // in the fit

  nHitFit = HitFit->FitAllPermutation();

  //
  // BEGIN PART WHICH EXTRACTS INFORMATION FROM HITFIT
  //

  // Get the number of jets
  nHitFitJet = HitFit->GetUnfittedEvent()[0].njets();

  // Get the fit results for all permutations
  hitFitResult = HitFit->GetFitAllPermutation();

  // Loop over all permutations and extract the information
  for (size_t fit = 0; fit != nHitFit; ++fit) {
    // Get the event after the fit
    hitfit::Lepjets_Event fittedEvent = hitFitResult[fit].ev();

    /*
        Get jet permutation according to TQAF convention
        11 : leptonic b
        12 : hadronic b
        13 : hadronic W
        14 : hadronic W
      */
    std::vector<int> hitCombi(4);
    for (size_t jet = 0; jet != nHitFitJet; ++jet) {
      int jet_type = fittedEvent.jet(jet).type();

      switch (jet_type) {
        case 11:
          hitCombi[TtSemiLepEvtPartons::LepB] = jet;
          break;
        case 12:
          hitCombi[TtSemiLepEvtPartons::HadB] = jet;
          break;
        case 13:
          hitCombi[TtSemiLepEvtPartons::LightQ] = jet;
          break;
        case 14:
          hitCombi[TtSemiLepEvtPartons::LightQBar] = jet;
          break;
      }
    }

    // Store the kinematic quantities in the corresponding containers.

    hitfit::Lepjets_Event_Jet hadP_ = fittedEvent.jet(hitCombi[TtSemiLepEvtPartons::LightQ]);
    hitfit::Lepjets_Event_Jet hadQ_ = fittedEvent.jet(hitCombi[TtSemiLepEvtPartons::LightQBar]);
    hitfit::Lepjets_Event_Jet hadB_ = fittedEvent.jet(hitCombi[TtSemiLepEvtPartons::HadB]);
    hitfit::Lepjets_Event_Jet lepB_ = fittedEvent.jet(hitCombi[TtSemiLepEvtPartons::LepB]);
    hitfit::Lepjets_Event_Lep lepL_ = fittedEvent.lep(0);

    /*
  std::string bTagAlgo_;
  double minBTagValueBJet_;
  double maxBTagValueNonBJet_;
  bool useBTag_;
      */

    if (hitFitResult[fit].chisq() > 0  // only take into account converged fits
        && (!useBTag_ ||
            (useBTag_  // use btag information if chosen
             && jets->at(hitCombi[TtSemiLepEvtPartons::LightQ]).bDiscriminator(bTagAlgo_) < maxBTagValueNonBJet_ &&
             jets->at(hitCombi[TtSemiLepEvtPartons::LightQBar]).bDiscriminator(bTagAlgo_) < maxBTagValueNonBJet_ &&
             jets->at(hitCombi[TtSemiLepEvtPartons::HadB]).bDiscriminator(bTagAlgo_) > minBTagValueBJet_ &&
             jets->at(hitCombi[TtSemiLepEvtPartons::LepB]).bDiscriminator(bTagAlgo_) > minBTagValueBJet_))) {
      FitResult result;
      result.Status = 0;
      result.Chi2 = hitFitResult[fit].chisq();
      result.Prob = exp(-1.0 * (hitFitResult[fit].chisq()) / 2.0);
      result.MT = hitFitResult[fit].mt();
      result.SigMT = hitFitResult[fit].sigmt();
      result.HadB = pat::Particle(reco::LeafCandidate(
          0, math::XYZTLorentzVector(hadB_.p().x(), hadB_.p().y(), hadB_.p().z(), hadB_.p().t()), math::XYZPoint()));
      result.HadP = pat::Particle(reco::LeafCandidate(
          0, math::XYZTLorentzVector(hadP_.p().x(), hadP_.p().y(), hadP_.p().z(), hadP_.p().t()), math::XYZPoint()));
      result.HadQ = pat::Particle(reco::LeafCandidate(
          0, math::XYZTLorentzVector(hadQ_.p().x(), hadQ_.p().y(), hadQ_.p().z(), hadQ_.p().t()), math::XYZPoint()));
      result.LepB = pat::Particle(reco::LeafCandidate(
          0, math::XYZTLorentzVector(lepB_.p().x(), lepB_.p().y(), lepB_.p().z(), lepB_.p().t()), math::XYZPoint()));
      result.LepL = pat::Particle(reco::LeafCandidate(
          0, math::XYZTLorentzVector(lepL_.p().x(), lepL_.p().y(), lepL_.p().z(), lepL_.p().t()), math::XYZPoint()));
      result.LepN = pat::Particle(reco::LeafCandidate(
          0,
          math::XYZTLorentzVector(
              fittedEvent.met().x(), fittedEvent.met().y(), fittedEvent.met().z(), fittedEvent.met().t()),
          math::XYZPoint()));
      result.JetCombi = hitCombi;

      FitResultList.push_back(result);
    }
  }

  // sort results w.r.t. chi2 values
  FitResultList.sort();

  // -----------------------------------------------------
  // feed out result
  // starting with the JetComb having the smallest chi2
  // -----------------------------------------------------

  if (((unsigned)FitResultList.size()) < 1) {  // in case no fit results were stored in the list (all fits aborted)
    pPartonsHadP->push_back(pat::Particle());
    pPartonsHadQ->push_back(pat::Particle());
    pPartonsHadB->push_back(pat::Particle());
    pPartonsLepB->push_back(pat::Particle());
    pLeptons->push_back(pat::Particle());
    pNeutrinos->push_back(pat::Particle());
    // indices referring to the jet combination
    std::vector<int> invalidCombi;
    for (unsigned int i = 0; i < nPartons; ++i)
      invalidCombi.push_back(-1);
    pCombi->push_back(invalidCombi);
    // chi2
    pChi2->push_back(-1.);
    // chi2 probability
    pProb->push_back(-1.);
    // fitted top mass
    pMT->push_back(-1.);
    pSigMT->push_back(-1.);
    // status of the fitter
    pStatus->push_back(-1);
  } else {
    unsigned int iComb = 0;
    for (typename std::list<FitResult>::const_iterator result = FitResultList.begin(); result != FitResultList.end();
         ++result) {
      if (maxNComb_ >= 1 && iComb == (unsigned int)maxNComb_)
        break;
      iComb++;
      // partons
      pPartonsHadP->push_back(result->HadP);
      pPartonsHadQ->push_back(result->HadQ);
      pPartonsHadB->push_back(result->HadB);
      pPartonsLepB->push_back(result->LepB);
      // lepton
      pLeptons->push_back(result->LepL);
      // neutrino
      pNeutrinos->push_back(result->LepN);
      // indices referring to the jet combination
      pCombi->push_back(result->JetCombi);
      // chi2
      pChi2->push_back(result->Chi2);
      // chi2 probability
      pProb->push_back(result->Prob);
      // fitted top mass
      pMT->push_back(result->MT);
      pSigMT->push_back(result->SigMT);
      // status of the fitter
      pStatus->push_back(result->Status);
    }
  }
  evt.put(std::move(pCombi));
  evt.put(std::move(pPartonsHadP), "PartonsHadP");
  evt.put(std::move(pPartonsHadQ), "PartonsHadQ");
  evt.put(std::move(pPartonsHadB), "PartonsHadB");
  evt.put(std::move(pPartonsLepB), "PartonsLepB");
  evt.put(std::move(pLeptons), "Leptons");
  evt.put(std::move(pNeutrinos), "Neutrinos");
  evt.put(std::move(pChi2), "Chi2");
  evt.put(std::move(pProb), "Prob");
  evt.put(std::move(pMT), "MT");
  evt.put(std::move(pSigMT), "SigMT");
  evt.put(std::move(pStatus), "Status");
  evt.put(std::move(pJetsConsidered), "NumberOfConsideredJets");
}

Member Data Documentation

bTagAlgo_

template<typename LeptonCollection >

std::string TtSemiLepHitFitProducer< LeptonCollection >::bTagAlgo_

private

input tag for b-tagging algorithm

Definition at line 43 of file TtSemiLepHitFitProducer.cc.

electronTranslator_

template<typename LeptonCollection >

hitfit::LeptonTranslatorBase<pat::Electron> TtSemiLepHitFitProducer< LeptonCollection >::electronTranslator_

private

Definition at line 87 of file TtSemiLepHitFitProducer.cc.

Referenced by TtSemiLepHitFitProducer< LeptonCollection >::TtSemiLepHitFitProducer().

HitFit

template<typename LeptonCollection >

std::unique_ptr<PatHitFit> TtSemiLepHitFitProducer< LeptonCollection >::HitFit

private

Definition at line 92 of file TtSemiLepHitFitProducer.cc.

Referenced by TtSemiLepHitFitProducer< LeptonCollection >::TtSemiLepHitFitProducer().

hitfitBJetResolution_

template<typename LeptonCollection >

edm::FileInPath TtSemiLepHitFitProducer< LeptonCollection >::hitfitBJetResolution_

private

Definition at line 84 of file TtSemiLepHitFitProducer.cc.

hitfitDefault_

template<typename LeptonCollection >

edm::FileInPath TtSemiLepHitFitProducer< LeptonCollection >::hitfitDefault_

private

Definition at line 80 of file TtSemiLepHitFitProducer.cc.

Referenced by TtSemiLepHitFitProducer< LeptonCollection >::TtSemiLepHitFitProducer().

hitfitElectronResolution_

template<typename LeptonCollection >

edm::FileInPath TtSemiLepHitFitProducer< LeptonCollection >::hitfitElectronResolution_

private

Definition at line 81 of file TtSemiLepHitFitProducer.cc.

hitfitMETResolution_

template<typename LeptonCollection >

edm::FileInPath TtSemiLepHitFitProducer< LeptonCollection >::hitfitMETResolution_

private

Definition at line 85 of file TtSemiLepHitFitProducer.cc.

hitfitMuonResolution_

template<typename LeptonCollection >

edm::FileInPath TtSemiLepHitFitProducer< LeptonCollection >::hitfitMuonResolution_

private

Definition at line 82 of file TtSemiLepHitFitProducer.cc.

hitfitUdscJetResolution_

template<typename LeptonCollection >

edm::FileInPath TtSemiLepHitFitProducer< LeptonCollection >::hitfitUdscJetResolution_

private

Definition at line 83 of file TtSemiLepHitFitProducer.cc.

jes_

template<typename LeptonCollection >

double TtSemiLepHitFitProducer< LeptonCollection >::jes_

private

jet energy scale

Definition at line 59 of file TtSemiLepHitFitProducer.cc.

jesB_

template<typename LeptonCollection >

double TtSemiLepHitFitProducer< LeptonCollection >::jesB_

private

Definition at line 60 of file TtSemiLepHitFitProducer.cc.

jetCorrectionLevel_

template<typename LeptonCollection >

std::string TtSemiLepHitFitProducer< LeptonCollection >::jetCorrectionLevel_

private

jet correction level

Definition at line 56 of file TtSemiLepHitFitProducer.cc.

jetsToken_

template<typename LeptonCollection >

edm::EDGetTokenT<std::vector<pat::Jet> > TtSemiLepHitFitProducer< LeptonCollection >::jetsToken_

private

Definition at line 26 of file TtSemiLepHitFitProducer.cc.

jetTranslator_

template<typename LeptonCollection >

hitfit::JetTranslatorBase<pat::Jet> TtSemiLepHitFitProducer< LeptonCollection >::jetTranslator_

private

Definition at line 89 of file TtSemiLepHitFitProducer.cc.

Referenced by TtSemiLepHitFitProducer< LeptonCollection >::TtSemiLepHitFitProducer().

lepsToken_

template<typename LeptonCollection >

edm::EDGetTokenT<LeptonCollection> TtSemiLepHitFitProducer< LeptonCollection >::lepsToken_

private

Definition at line 27 of file TtSemiLepHitFitProducer.cc.

maxBTagValueNonBJet_

template<typename LeptonCollection >

double TtSemiLepHitFitProducer< LeptonCollection >::maxBTagValueNonBJet_

private

max value of bTag for a non-b-jet

Definition at line 47 of file TtSemiLepHitFitProducer.cc.

maxEtaEle_

template<typename LeptonCollection >

double TtSemiLepHitFitProducer< LeptonCollection >::maxEtaEle_

private

maximum eta value for electrons, needed to limited range in which resolutions are provided

Definition at line 38 of file TtSemiLepHitFitProducer.cc.

Referenced by TtSemiLepHitFitProducer< LeptonCollection >::TtSemiLepHitFitProducer().

maxEtaJet_

template<typename LeptonCollection >

double TtSemiLepHitFitProducer< LeptonCollection >::maxEtaJet_

private

maximum eta value for jets, needed to limited range in which resolutions are provided

Definition at line 40 of file TtSemiLepHitFitProducer.cc.

Referenced by TtSemiLepHitFitProducer< LeptonCollection >::TtSemiLepHitFitProducer().

maxEtaMu_

template<typename LeptonCollection >

double TtSemiLepHitFitProducer< LeptonCollection >::maxEtaMu_

private

maximum eta value for muons, needed to limited range in which resolutions are provided

Definition at line 36 of file TtSemiLepHitFitProducer.cc.

Referenced by TtSemiLepHitFitProducer< LeptonCollection >::TtSemiLepHitFitProducer().

maxNComb_

template<typename LeptonCollection >

int TtSemiLepHitFitProducer< LeptonCollection >::maxNComb_

private

maximal number of combinations to be written to the event

Definition at line 33 of file TtSemiLepHitFitProducer.cc.

maxNJets_

template<typename LeptonCollection >

int TtSemiLepHitFitProducer< LeptonCollection >::maxNJets_

private

maximal number of jets (-1 possible to indicate 'all')

Definition at line 31 of file TtSemiLepHitFitProducer.cc.

metsToken_

template<typename LeptonCollection >

edm::EDGetTokenT<std::vector<pat::MET> > TtSemiLepHitFitProducer< LeptonCollection >::metsToken_

private

Definition at line 28 of file TtSemiLepHitFitProducer.cc.

metTranslator_

template<typename LeptonCollection >

hitfit::METTranslatorBase<pat::MET> TtSemiLepHitFitProducer< LeptonCollection >::metTranslator_

private

Definition at line 90 of file TtSemiLepHitFitProducer.cc.

Referenced by TtSemiLepHitFitProducer< LeptonCollection >::TtSemiLepHitFitProducer().

minBTagValueBJet_

template<typename LeptonCollection >

double TtSemiLepHitFitProducer< LeptonCollection >::minBTagValueBJet_

private

min value of bTag for a b-jet

Definition at line 45 of file TtSemiLepHitFitProducer.cc.

mTop_

template<typename LeptonCollection >

double TtSemiLepHitFitProducer< LeptonCollection >::mTop_

private

Definition at line 53 of file TtSemiLepHitFitProducer.cc.

Referenced by TtSemiLepHitFitProducer< LeptonCollection >::TtSemiLepHitFitProducer().

muonTranslator_

template<typename LeptonCollection >

hitfit::LeptonTranslatorBase<pat::Muon> TtSemiLepHitFitProducer< LeptonCollection >::muonTranslator_

private

Definition at line 88 of file TtSemiLepHitFitProducer.cc.

Referenced by TtSemiLepHitFitProducer< LeptonCollection >::TtSemiLepHitFitProducer().

mW_

template<typename LeptonCollection >

double TtSemiLepHitFitProducer< LeptonCollection >::mW_

private

constraints

Definition at line 52 of file TtSemiLepHitFitProducer.cc.

Referenced by TtSemiLepHitFitProducer< LeptonCollection >::TtSemiLepHitFitProducer().

useBTag_

template<typename LeptonCollection >

bool TtSemiLepHitFitProducer< LeptonCollection >::useBTag_

private

switch to tell whether to use b-tagging or not

Definition at line 49 of file TtSemiLepHitFitProducer.cc.