#include <TtSemiLepKinFitProducer.h>

Inheritance diagram for TtSemiLepKinFitProducer< LeptonCollection >:

Classes
struct	KinFitResult

Public Member Functions
	TtSemiLepKinFitProducer (const edm::ParameterSet &)

	~TtSemiLepKinFitProducer () override

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

	~EDProducer () override

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

	~ProducerBase () noexcept(false) override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
TtSemiLepKinFitter::Constraint	constraint (unsigned)

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

bool	doBTagging (bool &useBTag_, edm::Handle< std::vector< pat::Jet >> &jets, 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...

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::EDProducer
typedef EDProducer	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::EDProducer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

Protected Member Functions inherited from edm::ProducerBase
ProducesCollector	producesCollector ()

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

template<typename LeptonCollection>
class TtSemiLepKinFitProducer< LeptonCollection >

Definition at line 13 of file TtSemiLepKinFitProducer.h.

Constructor & Destructor Documentation

template<typename LeptonCollection >

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

explicit

Definition at line 96 of file TtSemiLepKinFitProducer.h.

     : 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 = new 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");
 }

template<typename LeptonCollection >

TtSemiLepKinFitProducer< LeptonCollection >::~TtSemiLepKinFitProducer ( )

override

Definition at line 167 of file TtSemiLepKinFitProducer.h.

References TtSemiLepKinFitProducer< LeptonCollection >::fitter.

                                                                     {
   delete fitter;
 }

Member Function Documentation

template<typename LeptonCollection >

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

private

Definition at line 431 of file TtSemiLepKinFitProducer.h.

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

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

                                                                                                {
   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;
 }

template<typename LeptonCollection >

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

private

Definition at line 463 of file TtSemiLepKinFitProducer.h.

References TtSemiLepKinFitProducer< LeptonCollection >::constraint(), mps_fire::i, and mps_fire::result.

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;
 }

template<typename LeptonCollection >

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

private

Definition at line 172 of file TtSemiLepKinFitProducer.h.

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

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

                                                                                          {
   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;
   }
 }

template<typename LeptonCollection >

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

private

Definition at line 411 of file TtSemiLepKinFitProducer.h.

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

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;
 }

template<typename LeptonCollection >

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

overrideprivate

Definition at line 192 of file TtSemiLepKinFitProducer.h.

                                                                                                  {
   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);
 
   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);
 
   const unsigned int nPartons = 4;
 
   std::vector<int> match;
   bool invalidMatch = false;
   if (useOnlyMatch_) {
     *pJetsConsidered = nPartons;
     edm::Handle<std::vector<std::vector<int>>> matchHandle;
     evt.getByToken(matchToken_, matchHandle);
     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");
 }