TtSemiLepKinFitProducer< LeptonCollection > Class Template Reference

Inheritance diagram for TtSemiLepKinFitProducer< LeptonCollection >:

Classes
struct	KinFitResult

Public Member Functions
	TtSemiLepKinFitProducer (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 Member Functions
TtSemiLepKinFitter::Constraint	constraint (unsigned)
std::vector< TtSemiLepKinFitter::Constraint >	constraints (std::vector< unsigned > &)
bool	doBTagging (bool &useBTag_, const edm::Handle< std::vector< pat::Jet >> &jets, const std::vector< int > &combi, std::string &bTagAlgo_, double &minBTagValueBJets_, double &maxBTagValueNonBJets_)
TtSemiLepKinFitter::Param	param (unsigned)
void	produce (edm::Event &, const edm::EventSetup &) override

Private Attributes
std::vector< edm::ParameterSet >	bResolutions_
std::string	bTagAlgo_
	input tag for b-tagging algorithm More...
std::vector< unsigned >	constraints_
	constrains More...
std::unique_ptr< TtSemiLepKinFitter >	fitter
std::vector< double >	jetEnergyResolutionEtaBinning_
std::vector< double >	jetEnergyResolutionScaleFactors_
	scale factors for jet energy resolution More...
unsigned int	jetParam_
edm::EDGetTokenT< std::vector< pat::Jet > >	jetsToken_
unsigned int	lepParam_
std::vector< edm::ParameterSet >	lepResolutions_
edm::EDGetTokenT< LeptonCollection >	lepsToken_
edm::EDGetTokenT< std::vector< std::vector< int > > >	matchToken_
double	maxBTagValueNonBJet_
	max value of bTag for a non-b-jet More...
double	maxDeltaS_
	maximal chi2 equivalent More...
double	maxF_
	maximal deviation for contstraints 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...
unsigned int	maxNrIter_
	maximal number of iterations to be performed for the fit More...
unsigned int	metParam_
std::vector< edm::ParameterSet >	metResolutions_
edm::EDGetTokenT< std::vector< pat::MET > >	metsToken_
double	minBTagValueBJet_
	min value of bTag for a b-jet More...
double	mTop_
double	mW_
std::vector< edm::ParameterSet >	udscResolutions_
	config-file-based object resolutions More...
bool	useBTag_
	switch to tell whether to use b-tagging or not More...
bool	useOnlyMatch_
	switch to use only a combination given by another hypothesis 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 TtSemiLepKinFitProducer< LeptonCollection >

Definition at line 10 of file TtSemiLepKinFitProducer.cc.

Constructor & Destructor Documentation

TtSemiLepKinFitProducer()

template<typename LeptonCollection >

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

explicit

Definition at line 92 of file TtSemiLepKinFitProducer.cc.

References TtSemiLepKinFitProducer< LeptonCollection >::bResolutions_, looper::cfg, TtSemiLepKinFitProducer< LeptonCollection >::constraints(), TtSemiLepKinFitProducer< LeptonCollection >::constraints_, Exception, TtSemiLepKinFitProducer< LeptonCollection >::fitter, TtSemiLepKinFitProducer< LeptonCollection >::jetEnergyResolutionEtaBinning_, TtSemiLepKinFitProducer< LeptonCollection >::jetEnergyResolutionScaleFactors_, TtSemiLepKinFitProducer< LeptonCollection >::jetParam_, TtSemiLepKinFitProducer< LeptonCollection >::lepParam_, TtSemiLepKinFitProducer< LeptonCollection >::lepResolutions_, TtSemiLepKinFitProducer< LeptonCollection >::maxDeltaS_, TtSemiLepKinFitProducer< LeptonCollection >::maxF_, TtSemiLepKinFitProducer< LeptonCollection >::maxNrIter_, TtSemiLepKinFitProducer< LeptonCollection >::metParam_, TtSemiLepKinFitProducer< LeptonCollection >::metResolutions_, TtSemiLepKinFitProducer< LeptonCollection >::mTop_, TtSemiLepKinFitProducer< LeptonCollection >::mW_, TtSemiLepKinFitProducer< LeptonCollection >::param(), and TtSemiLepKinFitProducer< LeptonCollection >::udscResolutions_.

    : 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"))),
      matchToken_(mayConsume<std::vector<std::vector<int>>>(cfg.getParameter<edm::InputTag>("match"))),
      useOnlyMatch_(cfg.getParameter<bool>("useOnlyMatch")),
      bTagAlgo_(cfg.getParameter<std::string>("bTagAlgo")),
      minBTagValueBJet_(cfg.getParameter<double>("minBDiscBJets")),
      maxBTagValueNonBJet_(cfg.getParameter<double>("maxBDiscLightJets")),
      useBTag_(cfg.getParameter<bool>("useBTagging")),
      maxNJets_(cfg.getParameter<int>("maxNJets")),
      maxNComb_(cfg.getParameter<int>("maxNComb")),
      maxNrIter_(cfg.getParameter<unsigned>("maxNrIter")),
      maxDeltaS_(cfg.getParameter<double>("maxDeltaS")),
      maxF_(cfg.getParameter<double>("maxF")),
      jetParam_(cfg.getParameter<unsigned>("jetParametrisation")),
      lepParam_(cfg.getParameter<unsigned>("lepParametrisation")),
      metParam_(cfg.getParameter<unsigned>("metParametrisation")),
      constraints_(cfg.getParameter<std::vector<unsigned>>("constraints")),
      mW_(cfg.getParameter<double>("mW")),
      mTop_(cfg.getParameter<double>("mTop")),
      jetEnergyResolutionScaleFactors_(cfg.getParameter<std::vector<double>>("jetEnergyResolutionScaleFactors")),
      jetEnergyResolutionEtaBinning_(cfg.getParameter<std::vector<double>>("jetEnergyResolutionEtaBinning")),
      udscResolutions_(0),
      bResolutions_(0),
      lepResolutions_(0),
      metResolutions_(0) {
  if (cfg.exists("udscResolutions") && cfg.exists("bResolutions") && cfg.exists("lepResolutions") &&
      cfg.exists("metResolutions")) {
    udscResolutions_ = cfg.getParameter<std::vector<edm::ParameterSet>>("udscResolutions");
    bResolutions_ = cfg.getParameter<std::vector<edm::ParameterSet>>("bResolutions");
    lepResolutions_ = cfg.getParameter<std::vector<edm::ParameterSet>>("lepResolutions");
    metResolutions_ = cfg.getParameter<std::vector<edm::ParameterSet>>("metResolutions");
  } else if (cfg.exists("udscResolutions") || cfg.exists("bResolutions") || cfg.exists("lepResolutions") ||
             cfg.exists("metResolutions")) {
    throw cms::Exception("Configuration") << "Parameters 'udscResolutions', 'bResolutions', 'lepResolutions', "
                                             "'metResolutions' should be used together.\n";
  }

  fitter = std::make_unique<TtSemiLepKinFitter>(param(jetParam_),
                                                param(lepParam_),
                                                param(metParam_),
                                                maxNrIter_,
                                                maxDeltaS_,
                                                maxF_,
                                                constraints(constraints_),
                                                mW_,
                                                mTop_,
                                                &udscResolutions_,
                                                &bResolutions_,
                                                &lepResolutions_,
                                                &metResolutions_,
                                                &jetEnergyResolutionScaleFactors_,
                                                &jetEnergyResolutionEtaBinning_);

  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<int>>("Status");

  produces<int>("NumberOfConsideredJets");
}

Member Function Documentation

constraint()

template<typename LeptonCollection >

TtSemiLepKinFitter::Constraint TtSemiLepKinFitProducer< LeptonCollection >::constraint ( unsigned  val )

private

Definition at line 418 of file TtSemiLepKinFitProducer.cc.

References Exception, TtSemiLepKinFitter::kEqualTopMasses, TtSemiLepKinFitter::kNeutrinoMass, TtSemiLepKinFitter::kSumPt, TtSemiLepKinFitter::kTopHadMass, TtSemiLepKinFitter::kTopLepMass, TtSemiLepKinFitter::kWHadMass, TtSemiLepKinFitter::kWLepMass, mps_fire::result, and heppy_batch::val.

                                                                                               {
  TtSemiLepKinFitter::Constraint result;
  switch (val) {
    case TtSemiLepKinFitter::kWHadMass:
      result = TtSemiLepKinFitter::kWHadMass;
      break;
    case TtSemiLepKinFitter::kWLepMass:
      result = TtSemiLepKinFitter::kWLepMass;
      break;
    case TtSemiLepKinFitter::kTopHadMass:
      result = TtSemiLepKinFitter::kTopHadMass;
      break;
    case TtSemiLepKinFitter::kTopLepMass:
      result = TtSemiLepKinFitter::kTopLepMass;
      break;
    case TtSemiLepKinFitter::kNeutrinoMass:
      result = TtSemiLepKinFitter::kNeutrinoMass;
      break;
    case TtSemiLepKinFitter::kEqualTopMasses:
      result = TtSemiLepKinFitter::kEqualTopMasses;
      break;
    case TtSemiLepKinFitter::kSumPt:
      result = TtSemiLepKinFitter::kSumPt;
      break;
    default:
      throw cms::Exception("Configuration") << "Chosen fit constraint is not supported: " << val << "\n";
      break;
  }
  return result;
}

constraints()

template<typename LeptonCollection >

std::vector< TtSemiLepKinFitter::Constraint > TtSemiLepKinFitProducer< LeptonCollection >::constraints ( std::vector< unsigned > &  val )

private

Definition at line 450 of file TtSemiLepKinFitProducer.cc.

References HLT_2023v12_cff::constraint, mps_fire::i, mps_fire::result, and heppy_batch::val.

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

                              {
  std::vector<TtSemiLepKinFitter::Constraint> result;
  for (unsigned i = 0; i < val.size(); ++i) {
    result.push_back(constraint(val[i]));
  }
  return result;
}

doBTagging()

template<typename LeptonCollection >

bool TtSemiLepKinFitProducer< LeptonCollection >::doBTagging ( bool &  useBTag_, const edm::Handle< std::vector< pat::Jet >> &  jets, const std::vector< int > &  combi, std::string &  bTagAlgo_, double &  minBTagValueBJets_, double &  maxBTagValueNonBJets_  )

private

Definition at line 163 of file TtSemiLepKinFitProducer.cc.

References TtSemiLepEvtPartons::HadB, PDWG_EXODelayedJetMET_cff::jets, TtSemiLepEvtPartons::LepB, TtSemiLepEvtPartons::LightQ, and TtSemiLepEvtPartons::LightQBar.

                                                                                         {
  if (!useBTag_) {
    return true;
  }
  if (useBTag_ && (*jets)[combi[TtSemiLepEvtPartons::HadB]].bDiscriminator(bTagAlgo_) >= minBTagValueBJet_ &&
      (*jets)[combi[TtSemiLepEvtPartons::LepB]].bDiscriminator(bTagAlgo_) >= minBTagValueBJet_ &&
      (*jets)[combi[TtSemiLepEvtPartons::LightQ]].bDiscriminator(bTagAlgo_) < maxBTagValueNonBJet_ &&
      (*jets)[combi[TtSemiLepEvtPartons::LightQBar]].bDiscriminator(bTagAlgo_) < maxBTagValueNonBJet_) {
    return true;
  } else {
    return false;
  }
}

param()

template<typename LeptonCollection >

TtSemiLepKinFitter::Param TtSemiLepKinFitProducer< LeptonCollection >::param ( unsigned  val )

private

Definition at line 398 of file TtSemiLepKinFitProducer.cc.

References Exception, TopKinFitter::kEMom, TopKinFitter::kEtEtaPhi, TopKinFitter::kEtThetaPhi, mps_fire::result, and heppy_batch::val.

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

                                                                                     {
  TtSemiLepKinFitter::Param result;
  switch (val) {
    case TtSemiLepKinFitter::kEMom:
      result = TtSemiLepKinFitter::kEMom;
      break;
    case TtSemiLepKinFitter::kEtEtaPhi:
      result = TtSemiLepKinFitter::kEtEtaPhi;
      break;
    case TtSemiLepKinFitter::kEtThetaPhi:
      result = TtSemiLepKinFitter::kEtThetaPhi;
      break;
    default:
      throw cms::Exception("Configuration") << "Chosen jet parametrization is not supported: " << val << "\n";
      break;
  }
  return result;
}

produce()

template<typename LeptonCollection >

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

overrideprivate

Definition at line 183 of file TtSemiLepKinFitProducer.cc.

References edm::Event::getHandle(), TtSemiLepEvtPartons::HadB, mps_fire::i, heavyIonCSV_trainingSettings::idx, createfilelist::int, PDWG_EXODelayedJetMET_cff::jets, TtSemiLepEvtPartons::LepB, TtSemiLepHitFitProducer_Electrons_cfi::leps, TtSemiLepEvtPartons::LightQ, TtSemiLepEvtPartons::LightQBar, match(), singleTopDQM_cfi::mets, eostools::move(), stdcomb::next_combination(), nPartons, edm::Event::put(), mps_fire::result, mps_update::status, 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<int>> pStatus(new std::vector<int>);

  std::unique_ptr<int> pJetsConsidered(new int);

  const edm::Handle<std::vector<pat::Jet>>& jets = evt.getHandle(jetsToken_);

  const edm::Handle<std::vector<pat::MET>>& mets = evt.getHandle(metsToken_);

  const edm::Handle<LeptonCollection>& leps = evt.getHandle(lepsToken_);

  const unsigned int nPartons = 4;

  std::vector<int> match;
  bool invalidMatch = false;
  if (useOnlyMatch_) {
    *pJetsConsidered = nPartons;
    const edm::Handle<std::vector<std::vector<int>>>& matchHandle = evt.getHandle(matchToken_);
    match = *(matchHandle->begin());
    // check if match is valid
    if (match.size() != nPartons)
      invalidMatch = true;
    else {
      for (unsigned int idx = 0; idx < match.size(); ++idx) {
        if (match[idx] < 0 || match[idx] >= (int)jets->size()) {
          invalidMatch = true;
          break;
        }
      }
    }
  }

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

  if (leps->empty() || mets->empty() || jets->size() < nPartons || invalidMatch) {
    // the kinFit getters return empty objects here
    pPartonsHadP->push_back(fitter->fittedHadP());
    pPartonsHadQ->push_back(fitter->fittedHadQ());
    pPartonsHadB->push_back(fitter->fittedHadB());
    pPartonsLepB->push_back(fitter->fittedLepB());
    pLeptons->push_back(fitter->fittedLepton());
    pNeutrinos->push_back(fitter->fittedNeutrino());
    // 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.);
    // status of the fitter
    pStatus->push_back(-1);
    // number of jets
    *pJetsConsidered = jets->size();
    // 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(pStatus), "Status");
    evt.put(std::move(pJetsConsidered), "NumberOfConsideredJets");
    return;
  }

  // -----------------------------------------------------
  // analyze different jet combinations using the KinFitter
  // (or only a given jet combination if useOnlyMatch=true)
  // -----------------------------------------------------

  std::vector<int> jetIndices;
  if (!useOnlyMatch_) {
    for (unsigned int i = 0; i < jets->size(); ++i) {
      if (maxNJets_ >= (int)nPartons && maxNJets_ == (int)i) {
        *pJetsConsidered = i;
        break;
      }
      jetIndices.push_back(i);
    }
  }

  std::vector<int> combi;
  for (unsigned int i = 0; i < nPartons; ++i) {
    if (useOnlyMatch_)
      combi.push_back(match[i]);
    else
      combi.push_back(i);
  }

  std::list<KinFitResult> FitResultList;

  do {
    for (int cnt = 0; cnt < TMath::Factorial(combi.size()); ++cnt) {
      // take into account indistinguishability of the two jets from the hadr. W decay,
      // reduces combinatorics by a factor of 2
      if ((combi[TtSemiLepEvtPartons::LightQ] < combi[TtSemiLepEvtPartons::LightQBar] || useOnlyMatch_) &&
          doBTagging(useBTag_, jets, combi, bTagAlgo_, minBTagValueBJet_, maxBTagValueNonBJet_)) {
        std::vector<pat::Jet> jetCombi;
        jetCombi.resize(nPartons);
        jetCombi[TtSemiLepEvtPartons::LightQ] = (*jets)[combi[TtSemiLepEvtPartons::LightQ]];
        jetCombi[TtSemiLepEvtPartons::LightQBar] = (*jets)[combi[TtSemiLepEvtPartons::LightQBar]];
        jetCombi[TtSemiLepEvtPartons::HadB] = (*jets)[combi[TtSemiLepEvtPartons::HadB]];
        jetCombi[TtSemiLepEvtPartons::LepB] = (*jets)[combi[TtSemiLepEvtPartons::LepB]];

        // do the kinematic fit
        const int status = fitter->fit(jetCombi, (*leps)[0], (*mets)[0]);

        if (status == 0) {  // only take into account converged fits
          KinFitResult result;
          result.Status = status;
          result.Chi2 = fitter->fitS();
          result.Prob = fitter->fitProb();
          result.HadB = fitter->fittedHadB();
          result.HadP = fitter->fittedHadP();
          result.HadQ = fitter->fittedHadQ();
          result.LepB = fitter->fittedLepB();
          result.LepL = fitter->fittedLepton();
          result.LepN = fitter->fittedNeutrino();
          result.JetCombi = combi;

          FitResultList.push_back(result);
        }
      }
      if (useOnlyMatch_)
        break;  // don't go through combinatorics if useOnlyMatch was chosen
      next_permutation(combi.begin(), combi.end());
    }
    if (useOnlyMatch_)
      break;  // don't go through combinatorics if useOnlyMatch was chosen
  } while (stdcomb::next_combination(jetIndices.begin(), jetIndices.end(), combi.begin(), combi.end()));

  // 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(fitter->fittedHadP());
    pPartonsHadQ->push_back(fitter->fittedHadQ());
    pPartonsHadB->push_back(fitter->fittedHadB());
    pPartonsLepB->push_back(fitter->fittedLepB());
    pLeptons->push_back(fitter->fittedLepton());
    pNeutrinos->push_back(fitter->fittedNeutrino());
    // 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.);
    // status of the fitter
    pStatus->push_back(-1);
  } else {
    unsigned int iComb = 0;
    for (typename std::list<KinFitResult>::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);
      // 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(pStatus), "Status");
  evt.put(std::move(pJetsConsidered), "NumberOfConsideredJets");
}

Member Data Documentation

bResolutions_

template<typename LeptonCollection >

std::vector<edm::ParameterSet> TtSemiLepKinFitProducer< LeptonCollection >::bResolutions_

private

Definition at line 70 of file TtSemiLepKinFitProducer.cc.

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

bTagAlgo_

template<typename LeptonCollection >

std::string TtSemiLepKinFitProducer< LeptonCollection >::bTagAlgo_

private

input tag for b-tagging algorithm

Definition at line 40 of file TtSemiLepKinFitProducer.cc.

constraints_

template<typename LeptonCollection >

std::vector<unsigned> TtSemiLepKinFitProducer< LeptonCollection >::constraints_

private

constrains

Definition at line 62 of file TtSemiLepKinFitProducer.cc.

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

fitter

template<typename LeptonCollection >

std::unique_ptr<TtSemiLepKinFitter> TtSemiLepKinFitProducer< LeptonCollection >::fitter

private

Definition at line 74 of file TtSemiLepKinFitProducer.cc.

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

jetEnergyResolutionEtaBinning_

template<typename LeptonCollection >

std::vector<double> TtSemiLepKinFitProducer< LeptonCollection >::jetEnergyResolutionEtaBinning_

private

Definition at line 67 of file TtSemiLepKinFitProducer.cc.

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

jetEnergyResolutionScaleFactors_

template<typename LeptonCollection >

std::vector<double> TtSemiLepKinFitProducer< LeptonCollection >::jetEnergyResolutionScaleFactors_

private

scale factors for jet energy resolution

Definition at line 66 of file TtSemiLepKinFitProducer.cc.

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

jetParam_

template<typename LeptonCollection >

unsigned int TtSemiLepKinFitProducer< LeptonCollection >::jetParam_

private

Definition at line 58 of file TtSemiLepKinFitProducer.cc.

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

jetsToken_

template<typename LeptonCollection >

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

private

Definition at line 32 of file TtSemiLepKinFitProducer.cc.

lepParam_

template<typename LeptonCollection >

unsigned int TtSemiLepKinFitProducer< LeptonCollection >::lepParam_

private

Definition at line 59 of file TtSemiLepKinFitProducer.cc.

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

lepResolutions_

template<typename LeptonCollection >

std::vector<edm::ParameterSet> TtSemiLepKinFitProducer< LeptonCollection >::lepResolutions_

private

Definition at line 71 of file TtSemiLepKinFitProducer.cc.

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

lepsToken_

template<typename LeptonCollection >

edm::EDGetTokenT<LeptonCollection> TtSemiLepKinFitProducer< LeptonCollection >::lepsToken_

private

Definition at line 33 of file TtSemiLepKinFitProducer.cc.

matchToken_

template<typename LeptonCollection >

edm::EDGetTokenT<std::vector<std::vector<int> > > TtSemiLepKinFitProducer< LeptonCollection >::matchToken_

private

Definition at line 36 of file TtSemiLepKinFitProducer.cc.

maxBTagValueNonBJet_

template<typename LeptonCollection >

double TtSemiLepKinFitProducer< LeptonCollection >::maxBTagValueNonBJet_

private

max value of bTag for a non-b-jet

Definition at line 44 of file TtSemiLepKinFitProducer.cc.

maxDeltaS_

template<typename LeptonCollection >

double TtSemiLepKinFitProducer< LeptonCollection >::maxDeltaS_

private

maximal chi2 equivalent

Definition at line 55 of file TtSemiLepKinFitProducer.cc.

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

maxF_

template<typename LeptonCollection >

double TtSemiLepKinFitProducer< LeptonCollection >::maxF_

private

maximal deviation for contstraints

Definition at line 57 of file TtSemiLepKinFitProducer.cc.

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

maxNComb_

template<typename LeptonCollection >

int TtSemiLepKinFitProducer< LeptonCollection >::maxNComb_

private

maximal number of combinations to be written to the event

Definition at line 50 of file TtSemiLepKinFitProducer.cc.

maxNJets_

template<typename LeptonCollection >

int TtSemiLepKinFitProducer< LeptonCollection >::maxNJets_

private

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

Definition at line 48 of file TtSemiLepKinFitProducer.cc.

maxNrIter_

template<typename LeptonCollection >

unsigned int TtSemiLepKinFitProducer< LeptonCollection >::maxNrIter_

private

maximal number of iterations to be performed for the fit

Definition at line 53 of file TtSemiLepKinFitProducer.cc.

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

metParam_

template<typename LeptonCollection >

unsigned int TtSemiLepKinFitProducer< LeptonCollection >::metParam_

private

Definition at line 60 of file TtSemiLepKinFitProducer.cc.

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

metResolutions_

template<typename LeptonCollection >

std::vector<edm::ParameterSet> TtSemiLepKinFitProducer< LeptonCollection >::metResolutions_

private

Definition at line 72 of file TtSemiLepKinFitProducer.cc.

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

metsToken_

template<typename LeptonCollection >

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

private

Definition at line 34 of file TtSemiLepKinFitProducer.cc.

minBTagValueBJet_

template<typename LeptonCollection >

double TtSemiLepKinFitProducer< LeptonCollection >::minBTagValueBJet_

private

min value of bTag for a b-jet

Definition at line 42 of file TtSemiLepKinFitProducer.cc.

mTop_

template<typename LeptonCollection >

double TtSemiLepKinFitProducer< LeptonCollection >::mTop_

private

Definition at line 64 of file TtSemiLepKinFitProducer.cc.

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

mW_

template<typename LeptonCollection >

double TtSemiLepKinFitProducer< LeptonCollection >::mW_

private

Definition at line 63 of file TtSemiLepKinFitProducer.cc.

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

udscResolutions_

template<typename LeptonCollection >

std::vector<edm::ParameterSet> TtSemiLepKinFitProducer< LeptonCollection >::udscResolutions_

private

config-file-based object resolutions

Definition at line 69 of file TtSemiLepKinFitProducer.cc.

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

useBTag_

template<typename LeptonCollection >

bool TtSemiLepKinFitProducer< LeptonCollection >::useBTag_

private

switch to tell whether to use b-tagging or not

Definition at line 46 of file TtSemiLepKinFitProducer.cc.

useOnlyMatch_

template<typename LeptonCollection >

bool TtSemiLepKinFitProducer< LeptonCollection >::useOnlyMatch_

private

switch to use only a combination given by another hypothesis

Definition at line 38 of file TtSemiLepKinFitProducer.cc.