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.

     : 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_2022v14_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.

Classes

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

template<typename LeptonCollection> class TtSemiLepKinFitProducer< LeptonCollection >

Constructor & Destructor Documentation

◆ TtSemiLepKinFitProducer()

Member Function Documentation

◆ constraint()

◆ constraints()

◆ doBTagging()

◆ param()

◆ produce()

Member Data Documentation

◆ bResolutions_

◆ bTagAlgo_

◆ constraints_

◆ fitter

◆ jetEnergyResolutionEtaBinning_

◆ jetEnergyResolutionScaleFactors_

◆ jetParam_

◆ jetsToken_

◆ lepParam_

◆ lepResolutions_

◆ lepsToken_

◆ matchToken_

◆ maxBTagValueNonBJet_

◆ maxDeltaS_

◆ maxF_

◆ maxNComb_

◆ maxNJets_

◆ maxNrIter_

◆ metParam_

◆ metResolutions_

◆ metsToken_

◆ minBTagValueBJet_

◆ mTop_

◆ mW_

◆ udscResolutions_

◆ useBTag_

◆ useOnlyMatch_

template<typename LeptonCollection>
class TtSemiLepKinFitProducer< LeptonCollection >