#include <TtSemiEvtSolutionMaker.h>

Inheritance diagram for TtSemiEvtSolutionMaker:

Public Member Functions
TtSemiLepKinFitter::Constraint	constraint (unsigned)

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

TtSemiLepKinFitter::Param	param (unsigned)

void	produce (edm::Event &iEvent, const edm::EventSetup &iSetup) override

	TtSemiEvtSolutionMaker (const edm::ParameterSet &iConfig)
	constructor More...

	~TtSemiEvtSolutionMaker () override
	destructor More...

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

std::vector< bool > const &	recordProvenanceList () 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)

TypeLabelList const &	typeLabelList () const
	used by the fwk to register the list of products of this module More...

	~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 &&)=default

	EDConsumerBase (EDConsumerBase const &)=delete

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

std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (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::array< std::vector< ModuleDescription const * > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const > const &labelsToDesc, std::string const &processName) const

EDConsumerBase &	operator= (EDConsumerBase &&)=default

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

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 Attributes
bool	addLRJetComb_

bool	addLRSignalSel_

std::vector< unsigned >	constraints_

bool	doKinFit_

edm::EDGetTokenT< std::vector< pat::Electron > >	electronSrcToken_

edm::EDGetTokenT< TtGenEvent >	genEvtToken_

int	jetCorrScheme_

int	jetParam_

edm::EDGetTokenT< std::vector< pat::Jet > >	jetSrcToken_

int	lepParam_

std::string	leptonFlavour_

std::string	lrJetCombFile_

std::vector< int >	lrJetCombObs_

std::string	lrSignalSelFile_

std::vector< int >	lrSignalSelObs_

int	matchingAlgo_

bool	matchToGenEvt_

double	maxDeltaS_

double	maxDist_

double	maxF_

int	maxNrIter_

int	metParam_

edm::EDGetTokenT< std::vector< pat::MET > >	metSrcToken_

edm::EDGetTokenT< std::vector< pat::Muon > >	muonSrcToken_

TtSemiLepKinFitter *	myKinFitter

TtSemiLRJetCombCalc *	myLRJetCombCalc

TtSemiLRJetCombObservables *	myLRJetCombObservables

TtSemiLRSignalSelCalc *	myLRSignalSelCalc

TtSemiLRSignalSelObservables *	myLRSignalSelObservables

TtSemiSimpleBestJetComb *	mySimpleBestJetComb

unsigned int	nrCombJets_

bool	useDeltaR_

bool	useMaxDist_

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	wantsInputProcessBlocks ()

static bool	wantsProcessBlocks ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

Protected Member Functions inherited from edm::ProducerBase
template<class ProductType >
BranchAliasSetterT< ProductType >	produces ()
	declare what type of product will make and with which optional label More...

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces ()

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces ()

BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<BranchType B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<Transition B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<class ProductType >
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

ProducesCollector	producesCollector ()

Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

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

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

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<Transition Tr = Transition::Event>
constexpr auto	esConsumes () noexcept

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

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag) noexcept

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

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

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

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

Detailed Description

Definition at line 23 of file TtSemiEvtSolutionMaker.h.

Constructor & Destructor Documentation

◆ TtSemiEvtSolutionMaker()

TtSemiEvtSolutionMaker::TtSemiEvtSolutionMaker ( const edm::ParameterSet & iConfig )

explicit

constructor

Definition at line 21 of file TtSemiEvtSolutionMaker.cc.

                                                                              {
   // configurables
   electronSrcToken_ = mayConsume<std::vector<pat::Electron> >(iConfig.getParameter<edm::InputTag>("electronSource"));
   muonSrcToken_ = mayConsume<std::vector<pat::Muon> >(iConfig.getParameter<edm::InputTag>("muonSource"));
   metSrcToken_ = consumes<std::vector<pat::MET> >(iConfig.getParameter<edm::InputTag>("metSource"));
   jetSrcToken_ = consumes<std::vector<pat::Jet> >(iConfig.getParameter<edm::InputTag>("jetSource"));
   leptonFlavour_ = iConfig.getParameter<std::string>("leptonFlavour");
   jetCorrScheme_ = iConfig.getParameter<int>("jetCorrectionScheme");
   nrCombJets_ = iConfig.getParameter<unsigned int>("nrCombJets");
   doKinFit_ = iConfig.getParameter<bool>("doKinFit");
   addLRSignalSel_ = iConfig.getParameter<bool>("addLRSignalSel");
   lrSignalSelObs_ = iConfig.getParameter<std::vector<int> >("lrSignalSelObs");
   lrSignalSelFile_ = iConfig.getParameter<std::string>("lrSignalSelFile");
   addLRJetComb_ = iConfig.getParameter<bool>("addLRJetComb");
   lrJetCombObs_ = iConfig.getParameter<std::vector<int> >("lrJetCombObs");
   lrJetCombFile_ = iConfig.getParameter<std::string>("lrJetCombFile");
   maxNrIter_ = iConfig.getParameter<int>("maxNrIter");
   maxDeltaS_ = iConfig.getParameter<double>("maxDeltaS");
   maxF_ = iConfig.getParameter<double>("maxF");
   jetParam_ = iConfig.getParameter<int>("jetParametrisation");
   lepParam_ = iConfig.getParameter<int>("lepParametrisation");
   metParam_ = iConfig.getParameter<int>("metParametrisation");
   constraints_ = iConfig.getParameter<std::vector<unsigned> >("constraints");
   matchToGenEvt_ = iConfig.getParameter<bool>("matchToGenEvt");
   matchingAlgo_ = iConfig.getParameter<int>("matchingAlgorithm");
   useMaxDist_ = iConfig.getParameter<bool>("useMaximalDistance");
   useDeltaR_ = iConfig.getParameter<bool>("useDeltaR");
   maxDist_ = iConfig.getParameter<double>("maximalDistance");
   genEvtToken_ = mayConsume<TtGenEvent>(edm::InputTag("genEvt"));
  
   // define kinfitter
   if (doKinFit_) {
     myKinFitter = new TtSemiLepKinFitter(
         param(jetParam_), param(lepParam_), param(metParam_), maxNrIter_, maxDeltaS_, maxF_, constraints(constraints_));
   }
  
   // define jet combinations related calculators
   mySimpleBestJetComb = new TtSemiSimpleBestJetComb();
   myLRSignalSelObservables = new TtSemiLRSignalSelObservables();
   myLRJetCombObservables = new TtSemiLRJetCombObservables(consumesCollector(), jetSrcToken_);
   if (addLRJetComb_)
     myLRJetCombCalc = new TtSemiLRJetCombCalc(edm::FileInPath(lrJetCombFile_).fullPath(), lrJetCombObs_);
  
   // instantiate signal selection calculator
   if (addLRSignalSel_)
     myLRSignalSelCalc = new TtSemiLRSignalSelCalc(edm::FileInPath(lrSignalSelFile_).fullPath(), lrSignalSelObs_);
  
   // define what will be produced
   produces<std::vector<TtSemiEvtSolution> >();
 }

References addLRJetComb_, addLRSignalSel_, constraints(), constraints_, edm::EDConsumerBase::consumesCollector(), doKinFit_, electronSrcToken_, contentValuesFiles::fullPath, genEvtToken_, edm::ParameterSet::getParameter(), jetCorrScheme_, jetParam_, jetSrcToken_, lepParam_, leptonFlavour_, lrJetCombFile_, lrJetCombObs_, lrSignalSelFile_, lrSignalSelObs_, matchingAlgo_, matchToGenEvt_, maxDeltaS_, maxDist_, maxF_, maxNrIter_, metParam_, metSrcToken_, muonSrcToken_, myKinFitter, myLRJetCombCalc, myLRJetCombObservables, myLRSignalSelCalc, myLRSignalSelObservables, mySimpleBestJetComb, nrCombJets_, param(), AlCaHLTBitMon_QueryRunRegistry::string, useDeltaR_, and useMaxDist_.

◆ ~TtSemiEvtSolutionMaker()

TtSemiEvtSolutionMaker::~TtSemiEvtSolutionMaker ( )

override

destructor

Definition at line 73 of file TtSemiEvtSolutionMaker.cc.

                                                 {
   if (doKinFit_)
     delete myKinFitter;
   delete mySimpleBestJetComb;
   delete myLRSignalSelObservables;
   delete myLRJetCombObservables;
   if (addLRSignalSel_)
     delete myLRSignalSelCalc;
   if (addLRJetComb_)
     delete myLRJetCombCalc;
 }

References addLRJetComb_, addLRSignalSel_, doKinFit_, myKinFitter, myLRJetCombCalc, myLRJetCombObservables, myLRSignalSelCalc, myLRSignalSelObservables, and mySimpleBestJetComb.

Member Function Documentation

◆ constraint()

TtSemiLepKinFitter::Constraint TtSemiEvtSolutionMaker::constraint ( unsigned val )

Definition at line 307 of file TtSemiEvtSolutionMaker.cc.

                                                                             {
   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;
     default:
       throw cms::Exception("WrongConfig") << "Chosen fit constraint is not supported: " << val << "\n";
       break;
   }
   return result;
 }

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

Referenced by constraints().

◆ constraints()

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

Definition at line 332 of file TtSemiEvtSolutionMaker.cc.

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

References constraint(), mps_fire::i, mps_fire::result, and heppy_batch::val.

Referenced by TtSemiEvtSolutionMaker().

◆ param()

TtSemiLepKinFitter::Param TtSemiEvtSolutionMaker::param ( unsigned val )

Definition at line 288 of file TtSemiEvtSolutionMaker.cc.

                                                                   {
   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("WrongConfig") << "Chosen jet parametrization is not supported: " << val << "\n";
       break;
   }
   return result;
 }

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

Referenced by TtSemiEvtSolutionMaker().

◆ produce()

void TtSemiEvtSolutionMaker::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overridevirtual

Implements edm::EDProducer.

Definition at line 85 of file TtSemiEvtSolutionMaker.cc.

                                                                                   {
   //
   //  TopObject Selection
   //
  
   // select lepton (the TtLepton vectors are, for the moment, sorted on pT)
   bool leptonFound = false;
   edm::Handle<std::vector<pat::Muon> > muons;
   if (leptonFlavour_ == "muon") {
     iEvent.getByToken(muonSrcToken_, muons);
     if (!muons->empty())
       leptonFound = true;
   }
   edm::Handle<std::vector<pat::Electron> > electrons;
   if (leptonFlavour_ == "electron") {
     iEvent.getByToken(electronSrcToken_, electrons);
     if (!electrons->empty())
       leptonFound = true;
   }
  
   // select MET (TopMET vector is sorted on ET)
   bool metFound = false;
   edm::Handle<std::vector<pat::MET> > mets;
   iEvent.getByToken(metSrcToken_, mets);
   if (!mets->empty())
     metFound = true;
  
   // select Jets
   bool jetsFound = false;
   edm::Handle<std::vector<pat::Jet> > jets;
   iEvent.getByToken(jetSrcToken_, jets);
   if (jets->size() >= 4)
     jetsFound = true;
  
   //
   // Build Event solutions according to the ambiguity in the jet combination
   //
   std::vector<TtSemiEvtSolution>* evtsols = new std::vector<TtSemiEvtSolution>();
   if (leptonFound && metFound && jetsFound) {
     // protect against reading beyond array boundaries
     unsigned int nrCombJets = nrCombJets_;  // do not overwrite nrCombJets_
     if (jets->size() < nrCombJets)
       nrCombJets = jets->size();
     // loop over all jets
     for (unsigned int p = 0; p < nrCombJets; p++) {
       for (unsigned int q = 0; q < nrCombJets; q++) {
         for (unsigned int bh = 0; bh < nrCombJets; bh++) {
           if (q > p && !(bh == p || bh == q)) {
             for (unsigned int bl = 0; bl < nrCombJets; bl++) {
               if (!(bl == p || bl == q || bl == bh)) {
                 TtSemiEvtSolution asol;
                 asol.setJetCorrectionScheme(jetCorrScheme_);
                 if (leptonFlavour_ == "muon")
                   asol.setMuon(muons, 0);
                 if (leptonFlavour_ == "electron")
                   asol.setElectron(electrons, 0);
                 asol.setNeutrino(mets, 0);
                 asol.setHadp(jets, p);
                 asol.setHadq(jets, q);
                 asol.setHadb(jets, bh);
                 asol.setLepb(jets, bl);
                 if (doKinFit_) {
                   asol = myKinFitter->addKinFitInfo(&asol);
                   // just to keep a record in the event (drop? -> present in provenance anyway...)
                   asol.setJetParametrisation(jetParam_);
                   asol.setLeptonParametrisation(lepParam_);
                   asol.setNeutrinoParametrisation(metParam_);
                 }
                 if (matchToGenEvt_) {
                   edm::Handle<TtGenEvent> genEvt;
                   iEvent.getByToken(genEvtToken_, genEvt);
                   if (genEvt->numberOfBQuarks() ==
                           2 &&  // FIXME: in rare cases W->bc decay, resulting in a wrong filled genEvt leading to a segmentation fault
                       genEvt->numberOfLeptons() ==
                           1) {  // FIXME: temporary solution to avoid crash in JetPartonMatching for non semi-leptonic events
                     asol.setGenEvt(genEvt);
                   }
                 }
                 // these lines calculate the observables to be used in the TtSemiSignalSelection LR
                 (*myLRSignalSelObservables)(asol, *jets);
  
                 // if asked for, calculate with these observable values the LRvalue and
                 // (depending on the configuration) probability this event is signal
                 // FIXME: DO WE NEED TO DO THIS FOR EACH SOLUTION??? (S.L.20/8/07)
                 if (addLRSignalSel_)
                   (*myLRSignalSelCalc)(asol);
  
                 // these lines calculate the observables to be used in the TtSemiJetCombination LR
                 //(*myLRJetCombObservables)(asol);
  
                 (*myLRJetCombObservables)(asol, iEvent);
  
                 // if asked for, calculate with these observable values the LRvalue and
                 // (depending on the configuration) probability a jet combination is correct
                 if (addLRJetComb_)
                   (*myLRJetCombCalc)(asol);
  
                 //std::cout<<"SignalSelLRval = "<<asol.getLRSignalEvtLRval()<<"  JetCombProb = "<<asol.getLRSignalEvtProb()<<std::endl;
                 //std::cout<<"JetCombLRval = "<<asol.getLRJetCombLRval()<<"  JetCombProb = "<<asol.getLRJetCombProb()<<std::endl;
  
                 // fill solution to vector
                 asol.setupHyp();
                 evtsols->push_back(asol);
               }
             }
           }
         }
       }
     }
  
     // if asked for, match the event solutions to the gen Event
     if (matchToGenEvt_) {
       int bestSolution = -999;
       int bestSolutionChangeWQ = -999;
       edm::Handle<TtGenEvent> genEvt;
       iEvent.getByToken(genEvtToken_, genEvt);
       if (genEvt->numberOfBQuarks() ==
               2 &&  // FIXME: in rare cases W->bc decay, resulting in a wrong filled genEvt leading to a segmentation fault
           genEvt->numberOfLeptons() ==
               1) {  // FIXME: temporary solution to avoid crash in JetPartonMatching for non semi-leptonic events
         std::vector<const reco::Candidate*> quarks;
         const reco::Candidate& genp = *(genEvt->hadronicDecayQuark());
         const reco::Candidate& genq = *(genEvt->hadronicDecayQuarkBar());
         const reco::Candidate& genbh = *(genEvt->hadronicDecayB());
         const reco::Candidate& genbl = *(genEvt->leptonicDecayB());
         quarks.push_back(&genp);
         quarks.push_back(&genq);
         quarks.push_back(&genbh);
         quarks.push_back(&genbl);
         std::vector<const reco::Candidate*> recjets;
         for (size_t s = 0; s < evtsols->size(); s++) {
           recjets.clear();
           const reco::Candidate& jetp = (*evtsols)[s].getRecHadp();
           const reco::Candidate& jetq = (*evtsols)[s].getRecHadq();
           const reco::Candidate& jetbh = (*evtsols)[s].getRecHadb();
           const reco::Candidate& jetbl = (*evtsols)[s].getRecLepb();
           recjets.push_back(&jetp);
           recjets.push_back(&jetq);
           recjets.push_back(&jetbh);
           recjets.push_back(&jetbl);
           JetPartonMatching aMatch(quarks, recjets, matchingAlgo_, useMaxDist_, useDeltaR_, maxDist_);
           (*evtsols)[s].setGenEvt(genEvt);
           (*evtsols)[s].setMCBestSumAngles(aMatch.getSumDistances());
           (*evtsols)[s].setMCBestAngleHadp(aMatch.getDistanceForParton(0));
           (*evtsols)[s].setMCBestAngleHadq(aMatch.getDistanceForParton(1));
           (*evtsols)[s].setMCBestAngleHadb(aMatch.getDistanceForParton(2));
           (*evtsols)[s].setMCBestAngleLepb(aMatch.getDistanceForParton(3));
           if (aMatch.getMatchForParton(2) == 2 && aMatch.getMatchForParton(3) == 3) {
             if (aMatch.getMatchForParton(0) == 0 && aMatch.getMatchForParton(1) == 1) {
               bestSolution = s;
               bestSolutionChangeWQ = 0;
             } else if (aMatch.getMatchForParton(0) == 1 && aMatch.getMatchForParton(1) == 0) {
               bestSolution = s;
               bestSolutionChangeWQ = 1;
             }
           }
         }
       }
       for (size_t s = 0; s < evtsols->size(); s++) {
         (*evtsols)[s].setMCBestJetComb(bestSolution);
         (*evtsols)[s].setMCChangeWQ(bestSolutionChangeWQ);
       }
     }
  
     // add TtSemiSimpleBestJetComb to solutions
     int simpleBestJetComb = (*mySimpleBestJetComb)(*evtsols);
     for (size_t s = 0; s < evtsols->size(); s++)
       (*evtsols)[s].setSimpleBestJetComb(simpleBestJetComb);
  
     // choose the best jet combination according to LR value
     if (addLRJetComb_ && !evtsols->empty()) {
       float bestLRVal = -1000000;
       int bestSol = (*evtsols)[0].getLRBestJetComb();  // duplicate the default
       for (size_t s = 0; s < evtsols->size(); s++) {
         if ((*evtsols)[s].getLRJetCombLRval() > bestLRVal) {
           bestLRVal = (*evtsols)[s].getLRJetCombLRval();
           bestSol = s;
         }
       }
       for (size_t s = 0; s < evtsols->size(); s++) {
         (*evtsols)[s].setLRBestJetComb(bestSol);
       }
     }
  
     //store the vector of solutions to the event
     std::unique_ptr<std::vector<TtSemiEvtSolution> > pOut(evtsols);
     iEvent.put(std::move(pOut));
  
   } else {
     /*
     std::cout<<"No calibrated solutions built, because:  ";
     if(jets->size()<4)                            std::cout<<"nr sel jets < 4"<<std::endl;
     if(leptonFlavour_ == "muon" && muons->size() == 0)        std::cout<<"no good muon candidate"<<std::endl;
     if(leptonFlavour_ == "electron" && electrons->size() == 0)   std::cout<<"no good electron candidate"<<std::endl;
     if(mets->size() == 0)                         std::cout<<"no MET reconstruction"<<std::endl;
     */
     //    TtSemiEvtSolution asol;
     //    evtsols->push_back(asol);
     std::unique_ptr<std::vector<TtSemiEvtSolution> > pOut(evtsols);
     iEvent.put(std::move(pOut));
   }
 }