TtSemiLepHypothesis Class Reference

#include <TtSemiLepHypothesis.h>

Inheritance diagram for TtSemiLepHypothesis:

Public Member Functions
	TtSemiLepHypothesis (const edm::ParameterSet &)
	default constructor More...
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

Protected Member Functions
void	buildHypo (const edm::Handle< edm::View< reco::RecoCandidate > > &leps, const edm::Handle< std::vector< pat::MET > > &mets, const edm::Handle< std::vector< pat::Jet > > &jets, std::vector< int > &jetPartonAssociation)
	minimalistic build function for simple hypotheses More...
virtual void	buildHypo (edm::Event &event, const edm::Handle< edm::View< reco::RecoCandidate > > &lepton, const edm::Handle< std::vector< pat::MET > > &neutrino, const edm::Handle< std::vector< pat::Jet > > &jets, std::vector< int > &jetPartonAssociation, const unsigned int iComb)=0
	build event hypothesis from the reco objects of a semi-leptonic event More...
virtual void	buildKey ()=0
	build the event hypothesis key More...
reco::CompositeCandidate	hypo ()
	return event hypothesis More...
bool	isValid (const int &idx, const edm::Handle< std::vector< pat::Jet > > &jets)
	check if index is in valid range of selected jets More...
std::string	jetCorrectionLevel (const std::string &quarkType)
	helper function to construct the proper correction level string for corresponding quarkType More...
int	key () const
WDecay::LeptonType	leptonType (const reco::RecoCandidate *cand)
	determine lepton type of reco candidate and return a corresponding WDecay::LeptonType; the type is kNone if it is whether a muon nor an electron More...
template<typename C >
std::unique_ptr< reco::ShallowClonePtrCandidate >	makeCandidate (const edm::Handle< C > &handle, const int &idx)
	use one object in a collection to set a ShallowClonePtrCandidate More...
std::unique_ptr< reco::ShallowClonePtrCandidate >	makeCandidate (const edm::Handle< std::vector< pat::Jet > > &handle, const int &idx, const std::string &correctionLevel)
	use one object in a jet collection to set a ShallowClonePtrCandidate with proper jet corrections More...
void	produce (edm::Event &, const edm::EventSetup &) override
	produce the event hypothesis as CompositeCandidate and Key More...
void	resetCandidates ()
	reset candidate pointers before hypo build process More...
void	setNeutrino (const edm::Handle< std::vector< pat::MET > > &met, const edm::Handle< edm::View< reco::RecoCandidate > > &leps, const int &idx, const int &type)
	set neutrino, using mW = 80.4 to calculate the neutrino pz More...

Protected Attributes
bool	getMatch_
std::unique_ptr< reco::ShallowClonePtrCandidate >	hadronicB_
std::string	jetCorrectionLevel_
edm::EDGetTokenT< std::vector< pat::Jet > >	jetsToken_
	input label for all necessary collections More...
int	key_
	hypothesis key (to be set by the buildKey function) More...
edm::EDGetTokenT< edm::View< reco::RecoCandidate > >	lepsToken_
std::unique_ptr< reco::ShallowClonePtrCandidate >	lepton_
std::unique_ptr< reco::ShallowClonePtrCandidate >	leptonicB_
std::unique_ptr< reco::ShallowClonePtrCandidate >	lightQ_
std::unique_ptr< reco::ShallowClonePtrCandidate >	lightQBar_
edm::EDGetTokenT< std::vector< std::vector< int > > >	matchToken_
edm::EDGetTokenT< std::vector< pat::MET > >	metsToken_
std::unique_ptr< reco::ShallowClonePtrCandidate >	neutrino_
int	neutrinoSolutionType_
	algorithm used to calculate neutrino solutions (see cfi for further details) More...
edm::EDGetTokenT< int >	nJetsConsideredToken_
int	numberOfRealNeutrinoSolutions_

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

Definition at line 31 of file TtSemiLepHypothesis.h.

Constructor & Destructor Documentation

TtSemiLepHypothesis()

TtSemiLepHypothesis::TtSemiLepHypothesis ( const edm::ParameterSet &  cfg )

explicit

default constructor

Definition at line 10 of file TtSemiLepHypothesis.cc.

References looper::cfg, getMatch_, jetCorrectionLevel_, matchToken_, neutrinoSolutionType_, and AlCaHLTBitMon_QueryRunRegistry::string.

    : jetsToken_(consumes<std::vector<pat::Jet> >(cfg.getParameter<edm::InputTag>("jets"))),
      lepsToken_(consumes<edm::View<reco::RecoCandidate> >(cfg.getParameter<edm::InputTag>("leps"))),
      metsToken_(consumes<std::vector<pat::MET> >(cfg.getParameter<edm::InputTag>("mets"))),
      nJetsConsideredToken_(consumes<int>(cfg.getParameter<edm::InputTag>("nJetsConsidered"))),
      numberOfRealNeutrinoSolutions_(-1) {
  getMatch_ = false;
  if (cfg.exists("match")) {
    getMatch_ = true;
    matchToken_ = consumes<std::vector<std::vector<int> > >(cfg.getParameter<edm::InputTag>("match"));
  }
  if (cfg.exists("neutrinoSolutionType"))
    neutrinoSolutionType_ = cfg.getParameter<int>("neutrinoSolutionType");
  else
    neutrinoSolutionType_ = -1;
  if (cfg.exists("jetCorrectionLevel")) {
    jetCorrectionLevel_ = cfg.getParameter<std::string>("jetCorrectionLevel");
  }
  produces<std::vector<std::pair<reco::CompositeCandidate, std::vector<int> > > >();
  produces<int>("Key");
  produces<int>("NumberOfRealNeutrinoSolutions");
  produces<int>("NumberOfConsideredJets");
}

Member Function Documentation

buildHypo() [1/2]

void TtSemiLepHypothesis::buildHypo ( const edm::Handle< edm::View< reco::RecoCandidate > > &  leps, const edm::Handle< std::vector< pat::MET > > &  mets, const edm::Handle< std::vector< pat::Jet > > &  jets, std::vector< int > &  jetPartonAssociation  )

protected

minimalistic build function for simple hypotheses

return key minimalistic build function for simple hypotheses

Definition at line 225 of file TtSemiLepHypothesis.cc.

References TtSemiLepEvtPartons::HadB, hadronicB_, heavyIonCSV_trainingSettings::idx, isValid(), jetCorrectionLevel(), singleTopDQM_cfi::jets, TtSemiLepEvtPartons::LepB, TtSemiLepHitFitProducer_Electrons_cfi::leps, lepton_, leptonicB_, TtSemiLepEvtPartons::LightQ, lightQ_, TtSemiLepEvtPartons::LightQBar, lightQBar_, makeCandidate(), match(), singleTopDQM_cfi::mets, neutrino_, neutrinoSolutionType_, and setNeutrino().

Referenced by TtSemiLepHypGeom::buildHypo(), TtSemiLepHypMaxSumPtWMass::buildHypo(), TtSemiLepHypWMassMaxSumPt::buildHypo(), TtSemiLepHypWMassDeltaTopMass::buildHypo(), TtSemiLepHypMVADisc::buildHypo(), and produce().

                                                           {
  // -----------------------------------------------------
  // add jets
  // -----------------------------------------------------
  for (unsigned idx = 0; idx < match.size(); ++idx) {
    if (isValid(match[idx], jets)) {
      switch (idx) {
        case TtSemiLepEvtPartons::LightQ:
          lightQ_ = makeCandidate(jets, match[idx], jetCorrectionLevel("wQuarkMix"));
          break;
        case TtSemiLepEvtPartons::LightQBar:
          lightQBar_ = makeCandidate(jets, match[idx], jetCorrectionLevel("wQuarkMix"));
          break;
        case TtSemiLepEvtPartons::HadB:
          hadronicB_ = makeCandidate(jets, match[idx], jetCorrectionLevel("bQuark"));
          break;
        case TtSemiLepEvtPartons::LepB:
          leptonicB_ = makeCandidate(jets, match[idx], jetCorrectionLevel("bQuark"));
          break;
      }
    }
  }

  // -----------------------------------------------------
  // add lepton
  // -----------------------------------------------------
  if (leps->empty())
    return;
  lepton_ = makeCandidate(leps, 0);
  match.push_back(0);

  // -----------------------------------------------------
  // add neutrino
  // -----------------------------------------------------
  if (mets->empty())
    return;
  if (neutrinoSolutionType_ == -1)
    neutrino_ = makeCandidate(mets, 0);
  else
    setNeutrino(mets, leps, 0, neutrinoSolutionType_);
}

buildHypo() [2/2]

virtual void TtSemiLepHypothesis::buildHypo ( edm::Event &  event, const edm::Handle< edm::View< reco::RecoCandidate > > &  lepton, const edm::Handle< std::vector< pat::MET > > &  neutrino, const edm::Handle< std::vector< pat::Jet > > &  jets, std::vector< int > &  jetPartonAssociation, const unsigned int  iComb  )

protectedpure virtual

build event hypothesis from the reco objects of a semi-leptonic event

Implemented in TtSemiLepHypGenMatch, TtSemiLepHypHitFit, TtSemiLepHypKinFit, TtSemiLepHypGeom, TtSemiLepHypMaxSumPtWMass, TtSemiLepHypMVADisc, TtSemiLepHypWMassDeltaTopMass, and TtSemiLepHypWMassMaxSumPt.

buildKey()

virtual void TtSemiLepHypothesis::buildKey ( )

protectedpure virtual

build the event hypothesis key

Implemented in TtSemiLepHypGenMatch, TtSemiLepHypHitFit, TtSemiLepHypKinFit, TtSemiLepHypGeom, TtSemiLepHypMaxSumPtWMass, TtSemiLepHypMVADisc, TtSemiLepHypWMassDeltaTopMass, and TtSemiLepHypWMassMaxSumPt.

Referenced by produce().

hypo()

reco::CompositeCandidate TtSemiLepHypothesis::hypo ( )

protected

return event hypothesis

Definition at line 106 of file TtSemiLepHypothesis.cc.

References reco::CompositeCandidate::addDaughter(), TtSemiLepDaughter::HadB, TtSemiLepDaughter::HadP, TtSemiLepDaughter::HadQ, hadronicB_, TtSemiLepDaughter::HadTop, TtSemiLepDaughter::HadW, TtSemiLepDaughter::Lep, TtSemiLepDaughter::LepB, lepton_, leptonicB_, TtSemiLepDaughter::LepTop, TtSemiLepDaughter::LepW, lightQ_, lightQBar_, eostools::move(), neutrino_, TtSemiLepDaughter::Nu, and AddFourMomenta::set().

Referenced by produce().

                                                 {
  // check for sanity of the hypothesis
  if (!lightQ_ || !lightQBar_ || !hadronicB_ || !leptonicB_ || !neutrino_ || !lepton_)
    return reco::CompositeCandidate();

  // setup transient references
  reco::CompositeCandidate hyp, hadTop, hadW, lepTop, lepW;

  AddFourMomenta addFourMomenta;
  // build up the top branch that decays leptonically
  lepW.addDaughter(std::move(lepton_), TtSemiLepDaughter::Lep);
  lepW.addDaughter(std::move(neutrino_), TtSemiLepDaughter::Nu);
  addFourMomenta.set(lepW);
  lepTop.addDaughter(lepW, TtSemiLepDaughter::LepW);
  lepTop.addDaughter(std::move(leptonicB_), TtSemiLepDaughter::LepB);
  addFourMomenta.set(lepTop);

  // build up the top branch that decays hadronically
  hadW.addDaughter(std::move(lightQ_), TtSemiLepDaughter::HadP);
  hadW.addDaughter(std::move(lightQBar_), TtSemiLepDaughter::HadQ);
  addFourMomenta.set(hadW);
  hadTop.addDaughter(hadW, TtSemiLepDaughter::HadW);
  hadTop.addDaughter(std::move(hadronicB_), TtSemiLepDaughter::HadB);
  addFourMomenta.set(hadTop);

  // build ttbar hypotheses
  hyp.addDaughter(lepTop, TtSemiLepDaughter::LepTop);
  hyp.addDaughter(hadTop, TtSemiLepDaughter::HadTop);
  addFourMomenta.set(hyp);

  return hyp;
}

isValid()

bool TtSemiLepHypothesis::isValid ( const int &  idx, const edm::Handle< std::vector< pat::Jet > > &  jets  )

inlineprotected

check if index is in valid range of selected jets

Definition at line 66 of file TtSemiLepHypothesis.h.

References heavyIonCSV_trainingSettings::idx, and singleTopDQM_cfi::jets.

Referenced by ntupleDataFormat._Object::_checkIsValid(), TtSemiLepHypGenMatch::buildHypo(), buildHypo(), and core.AutoHandle.AutoHandle::ReallyLoad().

                                                                          {
    return (0 <= idx && idx < (int)jets->size());
  };

jetCorrectionLevel()

std::string TtSemiLepHypothesis::jetCorrectionLevel ( const std::string &  quarkType )

protected

helper function to construct the proper correction level string for corresponding quarkType

helper function to construct the proper correction level string for corresponding quarkType, for unknown quarkTypes an empty string is returned

Definition at line 152 of file TtSemiLepHypothesis.cc.

References jetCorrectionLevel_, personalPlayback::level, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by TtSemiLepHypGenMatch::buildHypo(), and buildHypo().

                                                                            {
  // jetCorrectionLevel was not configured
  if (jetCorrectionLevel_.empty())
    throw cms::Exception("Configuration")
        << "Unconfigured jetCorrectionLevel. Please use an appropriate, non-empty string.\n";

  // quarkType is unknown
  if (!(quarkType == "wQuarkMix" || quarkType == "udsQuark" || quarkType == "cQuark" || quarkType == "bQuark"))
    throw cms::Exception("Configuration") << quarkType << " is unknown as a quarkType for the jetCorrectionLevel.\n";

  // combine correction level; start with a ':' even if
  // there is no flavor tag to be added, as it is needed
  // by makeCandidate to disentangle the correction tag
  // from a potential flavor tag, which can be empty
  std::string level = jetCorrectionLevel_ + ":";
  if (level == "L5Flavor:" || level == "L6UE:" || level == "L7Parton:") {
    if (quarkType == "wQuarkMix") {
      level += "wMix";
    }
    if (quarkType == "udsQuark") {
      level += "uds";
    }
    if (quarkType == "cQuark") {
      level += "charm";
    }
    if (quarkType == "bQuark") {
      level += "bottom";
    }
  } else {
    level += "none";
  }
  return level;
}

key()

int TtSemiLepHypothesis::key ( ) const

inlineprotected

Definition at line 62 of file TtSemiLepHypothesis.h.

References key_.

Referenced by produce().

{ return key_; };

leptonType()

WDecay::LeptonType TtSemiLepHypothesis::leptonType ( const reco::RecoCandidate *  cand )

protected

determine lepton type of reco candidate and return a corresponding WDecay::LeptonType; the type is kNone if it is whether a muon nor an electron

Definition at line 140 of file TtSemiLepHypothesis.cc.

References WDecay::kElec, WDecay::kMuon, and WDecay::kNone.

Referenced by TtSemiLepHypGenMatch::findMatchingLepton(), and setNeutrino().

                                                                              {
  // check whetherwe are dealing with a reco muon or a reco electron
  WDecay::LeptonType type = WDecay::kNone;
  if (dynamic_cast<const reco::Muon*>(cand)) {
    type = WDecay::kMuon;
  } else if (dynamic_cast<const reco::GsfElectron*>(cand)) {
    type = WDecay::kElec;
  }
  return type;
}

makeCandidate() [1/2]

template<typename C >

std::unique_ptr< reco::ShallowClonePtrCandidate > TtSemiLepHypothesis::makeCandidate ( const edm::Handle< C > &  handle, const int &  idx  )

protected

use one object in a collection to set a ShallowClonePtrCandidate

Definition at line 120 of file TtSemiLepHypothesis.h.

References patZpeak::handle, and heavyIonCSV_trainingSettings::idx.

Referenced by TtSemiLepHypHitFit::buildHypo(), TtSemiLepHypKinFit::buildHypo(), TtSemiLepHypGenMatch::buildHypo(), and buildHypo().

                                                                                                   {
  typedef typename C::value_type O;
  edm::Ptr<O> ptr = edm::Ptr<O>(handle, idx);
  return std::make_unique<reco::ShallowClonePtrCandidate>(ptr, ptr->charge(), ptr->p4(), ptr->vertex());
}

makeCandidate() [2/2]

std::unique_ptr< reco::ShallowClonePtrCandidate > TtSemiLepHypothesis::makeCandidate ( const edm::Handle< std::vector< pat::Jet > > &  handle, const int &  idx, const std::string &  correctionLevel  )

protected

use one object in a jet collection to set a ShallowClonePtrCandidate with proper jet corrections

Definition at line 187 of file TtSemiLepHypothesis.cc.

References reco::LeafCandidate::charge(), patZpeak::handle, heavyIonCSV_trainingSettings::idx, pat::Jet::jecFactor(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                   {
  edm::Ptr<pat::Jet> ptr = edm::Ptr<pat::Jet>(handle, idx);
  // disentangle the correction from the potential flavor tag
  // by the separating ':'; the flavor tag can be empty though
  std::string step = correctionLevel.substr(0, correctionLevel.find(':'));
  std::string flavor = correctionLevel.substr(1 + correctionLevel.find(':'));
  float corrFactor = 1.;
  if (flavor == "wMix")
    corrFactor = 0.75 * ptr->jecFactor(step, "uds") + 0.25 * ptr->jecFactor(step, "charm");
  else
    corrFactor = ptr->jecFactor(step, flavor);
  return std::make_unique<reco::ShallowClonePtrCandidate>(ptr, ptr->charge(), ptr->p4() * corrFactor, ptr->vertex());
}

produce()

void TtSemiLepHypothesis::produce ( edm::Event &  evt, const edm::EventSetup &  setup  )

overrideprotected

produce the event hypothesis as CompositeCandidate and Key

Definition at line 35 of file TtSemiLepHypothesis.cc.

References buildHypo(), buildKey(), edm::Event::getByToken(), getMatch_, hypo(), mps_fire::i, singleTopDQM_cfi::jets, jetsToken_, key(), TtSemiLepHitFitProducer_Electrons_cfi::leps, lepsToken_, match(), matchToken_, singleTopDQM_cfi::mets, metsToken_, eostools::move(), TtSemiLepHypGenMatch_cfi::nJetsConsidered, nJetsConsideredToken_, numberOfRealNeutrinoSolutions_, edm::Event::put(), resetCandidates(), and trackerHitRTTI::vector.

                                                                           {
  edm::Handle<std::vector<pat::Jet> > jets;
  evt.getByToken(jetsToken_, jets);

  edm::Handle<edm::View<reco::RecoCandidate> > leps;
  evt.getByToken(lepsToken_, leps);

  edm::Handle<std::vector<pat::MET> > mets;
  evt.getByToken(metsToken_, mets);

  edm::Handle<int> nJetsConsidered;
  evt.getByToken(nJetsConsideredToken_, nJetsConsidered);

  std::vector<std::vector<int> > matchVec;
  if (getMatch_) {
    edm::Handle<std::vector<std::vector<int> > > matchHandle;
    evt.getByToken(matchToken_, matchHandle);
    matchVec = *matchHandle;
  } else {
    std::vector<int> dummyMatch;
    for (unsigned int i = 0; i < 4; ++i)
      dummyMatch.push_back(-1);
    matchVec.push_back(dummyMatch);
  }

  // declare unique_ptr for products
  std::unique_ptr<std::vector<std::pair<reco::CompositeCandidate, std::vector<int> > > > pOut(
      new std::vector<std::pair<reco::CompositeCandidate, std::vector<int> > >);
  std::unique_ptr<int> pKey(new int);
  std::unique_ptr<int> pNeutrinoSolutions(new int);
  std::unique_ptr<int> pJetsConsidered(new int);

  // go through given vector of jet combinations
  unsigned int idMatch = 0;
  typedef std::vector<std::vector<int> >::iterator MatchVecIterator;
  for (MatchVecIterator match = matchVec.begin(); match != matchVec.end(); ++match) {
    // reset pointers
    resetCandidates();
    // build hypothesis
    buildHypo(evt, leps, mets, jets, *match, idMatch++);
    pOut->push_back(std::make_pair(hypo(), *match));
  }
  // feed out hyps and matches
  evt.put(std::move(pOut));

  // build and feed out key
  buildKey();
  *pKey = key();
  evt.put(std::move(pKey), "Key");

  // feed out number of real neutrino solutions
  *pNeutrinoSolutions = numberOfRealNeutrinoSolutions_;
  evt.put(std::move(pNeutrinoSolutions), "NumberOfRealNeutrinoSolutions");

  // feed out number of considered jets
  *pJetsConsidered = *nJetsConsidered;
  evt.put(std::move(pJetsConsidered), "NumberOfConsideredJets");
}

resetCandidates()

void TtSemiLepHypothesis::resetCandidates ( )

protected

reset candidate pointers before hypo build process

Definition at line 95 of file TtSemiLepHypothesis.cc.

References hadronicB_, lepton_, leptonicB_, lightQ_, lightQBar_, neutrino_, and numberOfRealNeutrinoSolutions_.

Referenced by produce().

                                          {
  numberOfRealNeutrinoSolutions_ = -1;
  lightQ_.reset();
  lightQBar_.reset();
  hadronicB_.reset();
  leptonicB_.reset();
  neutrino_.reset();
  lepton_.reset();
}

setNeutrino()

void TtSemiLepHypothesis::setNeutrino ( const edm::Handle< std::vector< pat::MET > > &  met, const edm::Handle< edm::View< reco::RecoCandidate > > &  leps, const int &  idx, const int &  type  )

protected

set neutrino, using mW = 80.4 to calculate the neutrino pz

Definition at line 203 of file TtSemiLepHypothesis.cc.

References reco::LeafCandidate::charge(), Exception, heavyIonCSV_trainingSettings::idx, WDecay::kElec, WDecay::kMuon, TtSemiLepHitFitProducer_Electrons_cfi::leps, leptonType(), BTaggingMonitor_cfi::met, neutrino_, numberOfRealNeutrinoSolutions_, reco::LeafCandidate::px(), reco::LeafCandidate::py(), and mathSSE::sqrt().

Referenced by TtSemiLepHypGenMatch::buildHypo(), and buildHypo().

                                                       {
  edm::Ptr<pat::MET> ptr = edm::Ptr<pat::MET>(met, 0);
  MEzCalculator mez;
  mez.SetMET(*(met->begin()));
  if (leptonType(&(leps->front())) == WDecay::kMuon)
    mez.SetLepton((*leps)[idx], true);
  else if (leptonType(&(leps->front())) == WDecay::kElec)
    mez.SetLepton((*leps)[idx], false);
  else
    throw cms::Exception("UnimplementedFeature")
        << "Type of lepton given together with MET for solving neutrino kinematics is neither muon nor electron.\n";
  double pz = mez.Calculate(type);
  numberOfRealNeutrinoSolutions_ = mez.IsComplex() ? 0 : 2;
  const math::XYZTLorentzVector p4(
      ptr->px(), ptr->py(), pz, sqrt(ptr->px() * ptr->px() + ptr->py() * ptr->py() + pz * pz));
  neutrino_ = std::make_unique<reco::ShallowClonePtrCandidate>(ptr, ptr->charge(), p4, ptr->vertex());
}

Member Data Documentation

getMatch_

bool TtSemiLepHypothesis::getMatch_

protected

internal check whether the match information exists or not, if false a blind dummy match vector will be used internally

Definition at line 90 of file TtSemiLepHypothesis.h.

Referenced by produce(), and TtSemiLepHypothesis().

hadronicB_

std::unique_ptr<reco::ShallowClonePtrCandidate> TtSemiLepHypothesis::hadronicB_

protected

Definition at line 111 of file TtSemiLepHypothesis.h.

Referenced by TtSemiLepHypHitFit::buildHypo(), TtSemiLepHypKinFit::buildHypo(), TtSemiLepHypGenMatch::buildHypo(), buildHypo(), hypo(), and resetCandidates().

jetCorrectionLevel_

std::string TtSemiLepHypothesis::jetCorrectionLevel_

protected

specify the desired jet correction level (the default should be L3Absolute-'abs')

Definition at line 99 of file TtSemiLepHypothesis.h.

Referenced by jetCorrectionLevel(), and TtSemiLepHypothesis().

jetsToken_

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

protected

input label for all necessary collections

Definition at line 92 of file TtSemiLepHypothesis.h.

Referenced by produce().

key_

int TtSemiLepHypothesis::key_

protected

hypothesis key (to be set by the buildKey function)

Definition at line 101 of file TtSemiLepHypothesis.h.

Referenced by TtSemiLepHypGeom::buildKey(), TtSemiLepHypWMassDeltaTopMass::buildKey(), TtSemiLepHypWMassMaxSumPt::buildKey(), TtSemiLepHypMVADisc::buildKey(), TtSemiLepHypMaxSumPtWMass::buildKey(), TtSemiLepHypKinFit::buildKey(), TtSemiLepHypHitFit::buildKey(), TtSemiLepHypGenMatch::buildKey(), and key().

lepsToken_

edm::EDGetTokenT<edm::View<reco::RecoCandidate> > TtSemiLepHypothesis::lepsToken_

protected

Definition at line 93 of file TtSemiLepHypothesis.h.

Referenced by produce().

lepton_

std::unique_ptr<reco::ShallowClonePtrCandidate> TtSemiLepHypothesis::lepton_

protected

Definition at line 114 of file TtSemiLepHypothesis.h.

Referenced by TtSemiLepHypHitFit::buildHypo(), TtSemiLepHypKinFit::buildHypo(), TtSemiLepHypGenMatch::buildHypo(), buildHypo(), hypo(), and resetCandidates().

leptonicB_

std::unique_ptr<reco::ShallowClonePtrCandidate> TtSemiLepHypothesis::leptonicB_

protected

Definition at line 112 of file TtSemiLepHypothesis.h.

Referenced by TtSemiLepHypHitFit::buildHypo(), TtSemiLepHypKinFit::buildHypo(), TtSemiLepHypGenMatch::buildHypo(), buildHypo(), hypo(), and resetCandidates().

lightQ_

std::unique_ptr<reco::ShallowClonePtrCandidate> TtSemiLepHypothesis::lightQ_

protected

candidates for internal use for the creation of the hypothesis candidate

Definition at line 109 of file TtSemiLepHypothesis.h.

Referenced by TtSemiLepHypHitFit::buildHypo(), TtSemiLepHypKinFit::buildHypo(), TtSemiLepHypGenMatch::buildHypo(), buildHypo(), hypo(), and resetCandidates().

lightQBar_

std::unique_ptr<reco::ShallowClonePtrCandidate> TtSemiLepHypothesis::lightQBar_

protected

Definition at line 110 of file TtSemiLepHypothesis.h.

Referenced by TtSemiLepHypHitFit::buildHypo(), TtSemiLepHypKinFit::buildHypo(), TtSemiLepHypGenMatch::buildHypo(), buildHypo(), hypo(), and resetCandidates().

matchToken_

edm::EDGetTokenT<std::vector<std::vector<int> > > TtSemiLepHypothesis::matchToken_

protected

Definition at line 95 of file TtSemiLepHypothesis.h.

Referenced by produce(), and TtSemiLepHypothesis().

metsToken_

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

protected

Definition at line 94 of file TtSemiLepHypothesis.h.

Referenced by produce().

neutrino_

std::unique_ptr<reco::ShallowClonePtrCandidate> TtSemiLepHypothesis::neutrino_

protected

Definition at line 113 of file TtSemiLepHypothesis.h.

Referenced by TtSemiLepHypHitFit::buildHypo(), TtSemiLepHypKinFit::buildHypo(), TtSemiLepHypGenMatch::buildHypo(), buildHypo(), hypo(), resetCandidates(), and setNeutrino().

neutrinoSolutionType_

int TtSemiLepHypothesis::neutrinoSolutionType_

protected

algorithm used to calculate neutrino solutions (see cfi for further details)

Definition at line 103 of file TtSemiLepHypothesis.h.

Referenced by TtSemiLepHypGenMatch::buildHypo(), buildHypo(), and TtSemiLepHypothesis().

nJetsConsideredToken_

edm::EDGetTokenT<int> TtSemiLepHypothesis::nJetsConsideredToken_

protected

Definition at line 96 of file TtSemiLepHypothesis.h.

Referenced by produce().

numberOfRealNeutrinoSolutions_

int TtSemiLepHypothesis::numberOfRealNeutrinoSolutions_

protected

number of real neutrino solutions: -1 if not determined, 0 if only complex, 2 if two real solutions

Definition at line 106 of file TtSemiLepHypothesis.h.

Referenced by produce(), resetCandidates(), and setNeutrino().