TtFullLepKinSolutionProducer Class Reference

#include <TtFullLepKinSolutionProducer.h>

Inheritance diagram for TtFullLepKinSolutionProducer:

Classes
struct	Compare

Public Member Functions
void	beginJob () override
void	endJob () override
void	produce (edm::Event &evt, const edm::EventSetup &iSetup) override
	TtFullLepKinSolutionProducer (const edm::ParameterSet &iConfig)
	~TtFullLepKinSolutionProducer () 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
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
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 &	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 Member Functions
bool	HasPositiveCharge (const reco::Candidate *) const
bool	LepDiffCharge (const reco::Candidate *, const reco::Candidate *) const
bool	PTComp (const reco::Candidate *, const reco::Candidate *) const

Private Attributes
bool	eeChannel_
edm::EDGetTokenT< std::vector< pat::Electron > >	electronsToken_
bool	emuChannel_
std::string	jetCorrLevel_
edm::EDGetTokenT< std::vector< pat::Jet > >	jetsToken_
int	maxNComb_
int	maxNJets_
edm::EDGetTokenT< std::vector< pat::MET > >	metsToken_
bool	mumuChannel_
edm::EDGetTokenT< std::vector< pat::Muon > >	muonsToken_
std::vector< double >	nupars_
bool	searchWrongCharge_
TtFullLepKinSolver *	solver
double	tmassbegin_
double	tmassend_
double	tmassstep_

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
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>
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)
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 19 of file TtFullLepKinSolutionProducer.h.

Constructor & Destructor Documentation

TtFullLepKinSolutionProducer()

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

explicit

Definition at line 64 of file TtFullLepKinSolutionProducer.h.

                                                                                         {
  // configurables
  jetsToken_ = consumes<std::vector<pat::Jet> >(iConfig.getParameter<edm::InputTag>("jets"));
  electronsToken_ = consumes<std::vector<pat::Electron> >(iConfig.getParameter<edm::InputTag>("electrons"));
  muonsToken_ = consumes<std::vector<pat::Muon> >(iConfig.getParameter<edm::InputTag>("muons"));
  metsToken_ = consumes<std::vector<pat::MET> >(iConfig.getParameter<edm::InputTag>("mets"));
  jetCorrLevel_ = iConfig.getParameter<std::string>("jetCorrectionLevel");
  maxNJets_ = iConfig.getParameter<int>("maxNJets");
  maxNComb_ = iConfig.getParameter<int>("maxNComb");
  eeChannel_ = iConfig.getParameter<bool>("eeChannel");
  emuChannel_ = iConfig.getParameter<bool>("emuChannel");
  mumuChannel_ = iConfig.getParameter<bool>("mumuChannel");
  searchWrongCharge_ = iConfig.getParameter<bool>("searchWrongCharge");
  tmassbegin_ = iConfig.getParameter<double>("tmassbegin");
  tmassend_ = iConfig.getParameter<double>("tmassend");
  tmassstep_ = iConfig.getParameter<double>("tmassstep");
  nupars_ = iConfig.getParameter<std::vector<double> >("neutrino_parameters");
 
  // define what will be produced
  produces<std::vector<std::vector<int> > >();  // vector of the particle inices (b, bbar, e1, e2, mu1, mu2)
  produces<std::vector<reco::LeafCandidate> >("fullLepNeutrinos");
  produces<std::vector<reco::LeafCandidate> >("fullLepNeutrinoBars");
  produces<std::vector<double> >("solWeight");  //weight for a specific kin solution
  produces<bool>("isWrongCharge");              //true if leptons have the same charge
}

References eeChannel_, electronsToken_, emuChannel_, edm::ParameterSet::getParameter(), jetCorrLevel_, jetsToken_, maxNComb_, maxNJets_, metsToken_, mumuChannel_, muonsToken_, nupars_, searchWrongCharge_, AlCaHLTBitMon_QueryRunRegistry::string, tmassbegin_, tmassend_, and tmassstep_.

~TtFullLepKinSolutionProducer()

TtFullLepKinSolutionProducer::~TtFullLepKinSolutionProducer ( )

override

Definition at line 90 of file TtFullLepKinSolutionProducer.h.

{}

Member Function Documentation

beginJob()

void TtFullLepKinSolutionProducer::beginJob ( void  )

overridevirtual

Reimplemented from edm::EDProducer.

Definition at line 92 of file TtFullLepKinSolutionProducer.h.

                                            {
  solver = new TtFullLepKinSolver(tmassbegin_, tmassend_, tmassstep_, nupars_);
}

References nupars_, solver, tmassbegin_, tmassend_, and tmassstep_.

endJob()

void TtFullLepKinSolutionProducer::endJob ( void  )

overridevirtual

Reimplemented from edm::EDProducer.

Definition at line 96 of file TtFullLepKinSolutionProducer.h.

{ delete solver; }

References solver.

HasPositiveCharge()

bool TtFullLepKinSolutionProducer::HasPositiveCharge ( const reco::Candidate *  l ) const

inlineprivate

Definition at line 60 of file TtFullLepKinSolutionProducer.h.

                                                                                        {
  return (l->charge() > 0);
}

References cmsLHEtoEOSManager::l.

Referenced by produce().

LepDiffCharge()

bool TtFullLepKinSolutionProducer::LepDiffCharge ( const reco::Candidate *  l1, const reco::Candidate *  l2  ) const

inlineprivate

Definition at line 56 of file TtFullLepKinSolutionProducer.h.

                                                                                                              {
  return (l1->charge() != l2->charge());
}

References reco::Candidate::charge().

Referenced by produce().

produce()

void TtFullLepKinSolutionProducer::produce ( edm::Event &  evt, const edm::EventSetup &  iSetup  )

overridevirtual

Implements edm::EDProducer.

Definition at line 98 of file TtFullLepKinSolutionProducer.h.

                                                                                     {
  //create vectors fo runsorted output
  std::vector<std::vector<int> > idcsV;
  std::vector<reco::LeafCandidate> nusV;
  std::vector<reco::LeafCandidate> nuBarsV;
  std::vector<std::pair<double, int> > weightsV;
 
  //create pointer for products
  std::unique_ptr<std::vector<std::vector<int> > > pIdcs(new std::vector<std::vector<int> >);
  std::unique_ptr<std::vector<reco::LeafCandidate> > pNus(new std::vector<reco::LeafCandidate>);
  std::unique_ptr<std::vector<reco::LeafCandidate> > pNuBars(new std::vector<reco::LeafCandidate>);
  std::unique_ptr<std::vector<double> > pWeight(new std::vector<double>);
  std::unique_ptr<bool> pWrongCharge(new bool);
 
  edm::Handle<std::vector<pat::Jet> > jets;
  evt.getByToken(jetsToken_, jets);
  edm::Handle<std::vector<pat::Electron> > electrons;
  evt.getByToken(electronsToken_, electrons);
  edm::Handle<std::vector<pat::Muon> > muons;
  evt.getByToken(muonsToken_, muons);
  edm::Handle<std::vector<pat::MET> > mets;
  evt.getByToken(metsToken_, mets);
 
  int selMuon1 = -1, selMuon2 = -1;
  int selElectron1 = -1, selElectron2 = -1;
  bool ee = false;
  bool emu = false;
  bool mumu = false;
  bool isWrongCharge = false;
  bool jetsFound = false;
  bool METFound = false;
  bool electronsFound = false;
  bool electronMuonFound = false;
  bool muonsFound = false;
 
  //select Jets (TopJet vector is sorted on ET)
  if (jets->size() >= 2) {
    jetsFound = true;
  }
 
  //select MET (TopMET vector is sorted on ET)
  if (!mets->empty()) {
    METFound = true;
  }
 
  // If we have electrons and muons available,
  // build a solutions with electrons and muons.
  if (muons->size() + electrons->size() >= 2) {
    // select leptons
    if (electrons->empty())
      mumu = true;
    else if (muons->empty())
      ee = true;
    else if (electrons->size() == 1) {
      if (muons->size() == 1)
        emu = true;
      else if (PTComp(&(*electrons)[0], &(*muons)[1]))
        emu = true;
      else
        mumu = true;
    } else if (electrons->size() > 1) {
      if (PTComp(&(*electrons)[1], &(*muons)[0]))
        ee = true;
      else if (muons->size() == 1)
        emu = true;
      else if (PTComp(&(*electrons)[0], &(*muons)[1]))
        emu = true;
      else
        mumu = true;
    }
    if (ee && eeChannel_) {
      if (LepDiffCharge(&(*electrons)[0], &(*electrons)[1]) || searchWrongCharge_) {
        if (HasPositiveCharge(&(*electrons)[0]) || !LepDiffCharge(&(*electrons)[0], &(*electrons)[1])) {
          selElectron1 = 0;
          selElectron2 = 1;
        } else {
          selElectron1 = 1;
          selElectron2 = 0;
        }
        electronsFound = true;
        if (!LepDiffCharge(&(*electrons)[0], &(*electrons)[1]))
          isWrongCharge = true;
      }
    } else if (emu && emuChannel_) {
      if (LepDiffCharge(&(*electrons)[0], &(*muons)[0]) || searchWrongCharge_) {
        selElectron1 = 0;
        selMuon1 = 0;
        electronMuonFound = true;
        if (!LepDiffCharge(&(*electrons)[0], &(*muons)[0]))
          isWrongCharge = true;
      }
    } else if (mumu && mumuChannel_) {
      if (LepDiffCharge(&(*muons)[0], &(*muons)[1]) || searchWrongCharge_) {
        if (HasPositiveCharge(&(*muons)[0]) || !LepDiffCharge(&(*muons)[0], &(*muons)[1])) {
          selMuon1 = 0;
          selMuon2 = 1;
        } else {
          selMuon1 = 1;
          selMuon2 = 0;
        }
        muonsFound = true;
        if (!LepDiffCharge(&(*muons)[0], &(*muons)[1]))
          isWrongCharge = true;
      }
    }
  }
 
  *pWrongCharge = isWrongCharge;
 
  // Check that the above work makes sense
  if (int(ee) + int(emu) + int(mumu) > 1) {
    edm::LogWarning("TtFullLepKinSolutionProducer") << "Lepton selection criteria uncorrectly defined";
  }
 
  // Check if the leptons for the required Channel are available
  bool correctLeptons =
      ((electronsFound && eeChannel_) || (muonsFound && mumuChannel_) || (electronMuonFound && emuChannel_));
  // Check for equally charged leptons if for wrong charge combinations is searched
  if (isWrongCharge) {
    correctLeptons = correctLeptons && searchWrongCharge_;
  }
 
  if (correctLeptons && METFound && jetsFound) {
    // run over all jets if input parameter maxNJets is -1 or
    // adapt maxNJets if number of present jets is smaller than selected
    // number of jets
    int stop = maxNJets_;
    if (jets->size() < static_cast<unsigned int>(stop) || stop < 0)
      stop = jets->size();
 
    // counter for number of found kinematic solutions
    int nSol = 0;
 
    // consider all permutations
    for (int ib = 0; ib < stop; ib++) {
      // second loop of the permutations
      for (int ibbar = 0; ibbar < stop; ibbar++) {
        // avoid the diagonal: b and bbar must be distinct jets
        if (ib == ibbar)
          continue;
 
        std::vector<int> idcs;
 
        // push back the indices of the jets
        idcs.push_back(ib);
        idcs.push_back(ibbar);
 
        TLorentzVector LV_l1;
        TLorentzVector LV_l2;
        TLorentzVector LV_b = TLorentzVector((*jets)[ib].correctedJet(jetCorrLevel_, "bottom").px(),
                                             (*jets)[ib].correctedJet(jetCorrLevel_, "bottom").py(),
                                             (*jets)[ib].correctedJet(jetCorrLevel_, "bottom").pz(),
                                             (*jets)[ib].correctedJet(jetCorrLevel_, "bottom").energy());
        TLorentzVector LV_bbar = TLorentzVector((*jets)[ibbar].correctedJet(jetCorrLevel_, "bottom").px(),
                                                (*jets)[ibbar].correctedJet(jetCorrLevel_, "bottom").py(),
                                                (*jets)[ibbar].correctedJet(jetCorrLevel_, "bottom").pz(),
                                                (*jets)[ibbar].correctedJet(jetCorrLevel_, "bottom").energy());
 
        double xconstraint = 0, yconstraint = 0;
 
        if (ee) {
          idcs.push_back(selElectron1);
          LV_l1.SetXYZT((*electrons)[selElectron1].px(),
                        (*electrons)[selElectron1].py(),
                        (*electrons)[selElectron1].pz(),
                        (*electrons)[selElectron1].energy());
          xconstraint += (*electrons)[selElectron1].px();
          yconstraint += (*electrons)[selElectron1].py();
 
          idcs.push_back(selElectron2);
          LV_l2.SetXYZT((*electrons)[selElectron2].px(),
                        (*electrons)[selElectron2].py(),
                        (*electrons)[selElectron2].pz(),
                        (*electrons)[selElectron2].energy());
          xconstraint += (*electrons)[selElectron2].px();
          yconstraint += (*electrons)[selElectron2].py();
 
          idcs.push_back(-1);
          idcs.push_back(-1);
        }
 
        else if (emu) {
          if (!isWrongCharge) {
            if (HasPositiveCharge(&(*electrons)[selElectron1])) {
              idcs.push_back(selElectron1);
              LV_l1.SetXYZT((*electrons)[selElectron1].px(),
                            (*electrons)[selElectron1].py(),
                            (*electrons)[selElectron1].pz(),
                            (*electrons)[selElectron1].energy());
              xconstraint += (*electrons)[selElectron1].px();
              yconstraint += (*electrons)[selElectron1].py();
 
              idcs.push_back(-1);
              idcs.push_back(-1);
 
              idcs.push_back(selMuon1);
              LV_l2.SetXYZT((*muons)[selMuon1].px(),
                            (*muons)[selMuon1].py(),
                            (*muons)[selMuon1].pz(),
                            (*muons)[selMuon1].energy());
              xconstraint += (*muons)[selMuon1].px();
              yconstraint += (*muons)[selMuon1].py();
            } else {
              idcs.push_back(-1);
 
              idcs.push_back(selMuon1);
              LV_l1.SetXYZT((*muons)[selMuon1].px(),
                            (*muons)[selMuon1].py(),
                            (*muons)[selMuon1].pz(),
                            (*muons)[selMuon1].energy());
              xconstraint += (*muons)[selMuon1].px();
              yconstraint += (*muons)[selMuon1].py();
 
              idcs.push_back(selElectron1);
              LV_l2.SetXYZT((*electrons)[selElectron1].px(),
                            (*electrons)[selElectron1].py(),
                            (*electrons)[selElectron1].pz(),
                            (*electrons)[selElectron1].energy());
              xconstraint += (*electrons)[selElectron1].px();
              yconstraint += (*electrons)[selElectron1].py();
 
              idcs.push_back(-1);
            }
          } else {                                                 // means "if wrong charge"
            if (HasPositiveCharge(&(*electrons)[selElectron1])) {  // both leps positive
              idcs.push_back(selElectron1);
              LV_l1.SetXYZT((*electrons)[selElectron1].px(),
                            (*electrons)[selElectron1].py(),
                            (*electrons)[selElectron1].pz(),
                            (*electrons)[selElectron1].energy());
              xconstraint += (*electrons)[selElectron1].px();
              yconstraint += (*electrons)[selElectron1].py();
 
              idcs.push_back(-1);
 
              idcs.push_back(selMuon1);
              LV_l2.SetXYZT((*muons)[selMuon1].px(),
                            (*muons)[selMuon1].py(),
                            (*muons)[selMuon1].pz(),
                            (*muons)[selMuon1].energy());
              xconstraint += (*muons)[selMuon1].px();
              yconstraint += (*muons)[selMuon1].py();
 
              idcs.push_back(-1);
            } else {  // both leps negative
              idcs.push_back(-1);
 
              idcs.push_back(selElectron1);
              LV_l2.SetXYZT((*electrons)[selElectron1].px(),
                            (*electrons)[selElectron1].py(),
                            (*electrons)[selElectron1].pz(),
                            (*electrons)[selElectron1].energy());
              xconstraint += (*electrons)[selElectron1].px();
              yconstraint += (*electrons)[selElectron1].py();
 
              idcs.push_back(-1);
 
              idcs.push_back(selMuon1);
              LV_l1.SetXYZT((*muons)[selMuon1].px(),
                            (*muons)[selMuon1].py(),
                            (*muons)[selMuon1].pz(),
                            (*muons)[selMuon1].energy());
              xconstraint += (*muons)[selMuon1].px();
              yconstraint += (*muons)[selMuon1].py();
            }
          }
        }
 
        else if (mumu) {
          idcs.push_back(-1);
          idcs.push_back(-1);
 
          idcs.push_back(selMuon1);
          LV_l1.SetXYZT(
              (*muons)[selMuon1].px(), (*muons)[selMuon1].py(), (*muons)[selMuon1].pz(), (*muons)[selMuon1].energy());
          xconstraint += (*muons)[selMuon1].px();
          yconstraint += (*muons)[selMuon1].py();
 
          idcs.push_back(selMuon2);
          LV_l2.SetXYZT(
              (*muons)[selMuon2].px(), (*muons)[selMuon2].py(), (*muons)[selMuon2].pz(), (*muons)[selMuon2].energy());
          xconstraint += (*muons)[selMuon2].px();
          yconstraint += (*muons)[selMuon2].py();
        }
 
        xconstraint += (*jets)[ib].px() + (*jets)[ibbar].px() + (*mets)[0].px();
        yconstraint += (*jets)[ib].py() + (*jets)[ibbar].py() + (*mets)[0].py();
 
        // calculate neutrino momenta and eventweight
        solver->SetConstraints(xconstraint, yconstraint);
        TtFullLepKinSolver::NeutrinoSolution nuSol = solver->getNuSolution(LV_l1, LV_l2, LV_b, LV_bbar);
 
        // add solution to the vectors of solutions if solution exists
        if (nuSol.weight > 0) {
          // add the leptons and jets indices to the vector of combinations
          idcsV.push_back(idcs);
 
          // add the neutrinos
          nusV.push_back(nuSol.neutrino);
          nuBarsV.push_back(nuSol.neutrinoBar);
 
          // add the solution weight
          weightsV.push_back(std::make_pair(nuSol.weight, nSol));
 
          nSol++;
        }
      }
    }
  }
 
  if (weightsV.empty()) {
    //create dmummy vector
    std::vector<int> idcs;
    for (int i = 0; i < 6; ++i)
      idcs.push_back(-1);
 
    idcsV.push_back(idcs);
    weightsV.push_back(std::make_pair(-1, 0));
    reco::LeafCandidate nu;
    nusV.push_back(nu);
    reco::LeafCandidate nuBar;
    nuBarsV.push_back(nuBar);
  }
 
  // check if all vectors have correct length
  int weightL = weightsV.size();
  int nuL = nusV.size();
  int nuBarL = nuBarsV.size();
  int idxL = idcsV.size();
 
  if (weightL != nuL || weightL != nuBarL || weightL != idxL) {
    edm::LogWarning("TtFullLepKinSolutionProducer")
        << "Output vectors are of different length:"
        << "\n weight: " << weightL << "\n     nu: " << nuL << "\n  nubar: " << nuBarL << "\n   idcs: " << idxL;
  }
 
  // sort vectors by weight in decreasing order
  if (weightsV.size() > 1) {
    sort(weightsV.begin(), weightsV.end(), Compare());
  }
 
  // determine the number of solutions which is written in the event
  int stop = weightL;
  if (maxNComb_ > 0 && maxNComb_ < stop)
    stop = maxNComb_;
 
  for (int i = 0; i < stop; ++i) {
    pWeight->push_back(weightsV[i].first);
    pNus->push_back(nusV[weightsV[i].second]);
    pNuBars->push_back(nuBarsV[weightsV[i].second]);
    pIdcs->push_back(idcsV[weightsV[i].second]);
  }
 
  // put the results in the event
  evt.put(std::move(pIdcs));
  evt.put(std::move(pNus), "fullLepNeutrinos");
  evt.put(std::move(pNuBars), "fullLepNeutrinoBars");
  evt.put(std::move(pWeight), "solWeight");
  evt.put(std::move(pWrongCharge), "isWrongCharge");
}

References eeChannel_, pwdgSkimBPark_cfi::electrons, electronsToken_, emuChannel_, HCALHighEnergyHPDFilter_cfi::energy, dqmdumpme::first, edm::Event::getByToken(), TtFullLepKinSolver::getNuSolution(), HasPositiveCharge(), mps_fire::i, cuy::ib, createfilelist::int, jetCorrLevel_, singleTopDQM_cfi::jets, jetsToken_, LepDiffCharge(), maxNComb_, maxNJets_, singleTopDQM_cfi::mets, metsToken_, eostools::move(), mumuChannel_, PDWG_BPHSkim_cff::muons, muonsToken_, TtFullLepKinSolver::NeutrinoSolution::neutrino, TtFullLepKinSolver::NeutrinoSolution::neutrinoBar, PTComp(), edm::Event::put(), multPhiCorr_741_25nsDY_cfi::px, multPhiCorr_741_25nsDY_cfi::py, searchWrongCharge_, edm::second(), TtFullLepKinSolver::SetConstraints(), reco::Candidate::size, solver, and TtFullLepKinSolver::NeutrinoSolution::weight.

PTComp()

bool TtFullLepKinSolutionProducer::PTComp ( const reco::Candidate *  l1, const reco::Candidate *  l2  ) const

inlineprivate

Definition at line 52 of file TtFullLepKinSolutionProducer.h.

                                                                                                       {
  return (l1->pt() > l2->pt());
}

References reco::Candidate::pt().

Referenced by produce().

Member Data Documentation

eeChannel_

bool TtFullLepKinSolutionProducer::eeChannel_

private

Definition at line 45 of file TtFullLepKinSolutionProducer.h.

Referenced by produce(), and TtFullLepKinSolutionProducer().

electronsToken_

edm::EDGetTokenT<std::vector<pat::Electron> > TtFullLepKinSolutionProducer::electronsToken_

private

Definition at line 39 of file TtFullLepKinSolutionProducer.h.

Referenced by produce(), and TtFullLepKinSolutionProducer().

emuChannel_

bool TtFullLepKinSolutionProducer::emuChannel_

private

Definition at line 45 of file TtFullLepKinSolutionProducer.h.

Referenced by produce(), and TtFullLepKinSolutionProducer().

jetCorrLevel_

std::string TtFullLepKinSolutionProducer::jetCorrLevel_

private

Definition at line 43 of file TtFullLepKinSolutionProducer.h.

Referenced by produce(), and TtFullLepKinSolutionProducer().

jetsToken_

edm::EDGetTokenT<std::vector<pat::Jet> > TtFullLepKinSolutionProducer::jetsToken_

private

Definition at line 38 of file TtFullLepKinSolutionProducer.h.

Referenced by produce(), and TtFullLepKinSolutionProducer().

maxNComb_

int TtFullLepKinSolutionProducer::maxNComb_

private

Definition at line 44 of file TtFullLepKinSolutionProducer.h.

Referenced by produce(), and TtFullLepKinSolutionProducer().

maxNJets_

int TtFullLepKinSolutionProducer::maxNJets_

private

Definition at line 44 of file TtFullLepKinSolutionProducer.h.

Referenced by produce(), and TtFullLepKinSolutionProducer().

metsToken_

edm::EDGetTokenT<std::vector<pat::MET> > TtFullLepKinSolutionProducer::metsToken_

private

Definition at line 41 of file TtFullLepKinSolutionProducer.h.

Referenced by produce(), and TtFullLepKinSolutionProducer().

mumuChannel_

bool TtFullLepKinSolutionProducer::mumuChannel_

private

Definition at line 45 of file TtFullLepKinSolutionProducer.h.

Referenced by produce(), and TtFullLepKinSolutionProducer().

muonsToken_

edm::EDGetTokenT<std::vector<pat::Muon> > TtFullLepKinSolutionProducer::muonsToken_

private

Definition at line 40 of file TtFullLepKinSolutionProducer.h.

Referenced by produce(), and TtFullLepKinSolutionProducer().

nupars_

std::vector<double> TtFullLepKinSolutionProducer::nupars_

private

Definition at line 47 of file TtFullLepKinSolutionProducer.h.

Referenced by beginJob(), and TtFullLepKinSolutionProducer().

searchWrongCharge_

bool TtFullLepKinSolutionProducer::searchWrongCharge_

private

Definition at line 45 of file TtFullLepKinSolutionProducer.h.

Referenced by produce(), and TtFullLepKinSolutionProducer().

solver

TtFullLepKinSolver* TtFullLepKinSolutionProducer::solver

private

Definition at line 49 of file TtFullLepKinSolutionProducer.h.

Referenced by beginJob(), endJob(), and produce().

tmassbegin_

double TtFullLepKinSolutionProducer::tmassbegin_

private

Definition at line 46 of file TtFullLepKinSolutionProducer.h.

Referenced by beginJob(), and TtFullLepKinSolutionProducer().

tmassend_

double TtFullLepKinSolutionProducer::tmassend_

private

Definition at line 46 of file TtFullLepKinSolutionProducer.h.

Referenced by beginJob(), and TtFullLepKinSolutionProducer().

tmassstep_

double TtFullLepKinSolutionProducer::tmassstep_

private

Definition at line 46 of file TtFullLepKinSolutionProducer.h.

Referenced by beginJob(), and TtFullLepKinSolutionProducer().