TtSemiLepHypGenMatch Class Reference

Inheritance diagram for TtSemiLepHypGenMatch:

Public Member Functions
	TtSemiLepHypGenMatch (const edm::ParameterSet &)
Public Member Functions inherited from TtSemiLepHypothesis
	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 Attributes
edm::EDGetTokenT< TtGenEvent >	genEvtToken_
Protected Attributes inherited from TtSemiLepHypothesis
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_

Private Member Functions
void	buildHypo (edm::Event &, const edm::Handle< edm::View< reco::RecoCandidate > > &, const edm::Handle< std::vector< pat::MET > > &, const edm::Handle< std::vector< pat::Jet > > &, std::vector< int > &, const unsigned int iComb) override
	build event hypothesis from the reco objects of a semi-leptonic event More...
void	buildKey () override
	build the event hypothesis key More...
int	findMatchingLepton (const edm::Handle< TtGenEvent > &genEvt, const edm::Handle< edm::View< reco::RecoCandidate > > &)
	find index of the candidate nearest to the singleLepton of the generator event in the collection; return -1 if this fails More...

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >
using	GlobalCache = typename CacheTypes::GlobalCache
using	HasAbility = AbilityChecker< T... >
using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
using	RunCache = typename CacheTypes::RunCache
using	RunContext = RunContextT< RunCache, GlobalCache >
using	RunSummaryCache = typename CacheTypes::RunSummaryCache
Protected Member Functions inherited from TtSemiLepHypothesis
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...
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...

Detailed Description

Definition at line 6 of file TtSemiLepHypGenMatch.cc.

Constructor & Destructor Documentation

TtSemiLepHypGenMatch()

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

explicit

Definition at line 27 of file TtSemiLepHypGenMatch.cc.

    : TtSemiLepHypothesis(cfg), genEvtToken_(consumes<TtGenEvent>(edm::InputTag("genEvt"))) {}

Member Function Documentation

buildHypo()

void TtSemiLepHypGenMatch::buildHypo ( edm::Event &  evt, 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 > &  match, const unsigned int  iComb  )

overrideprivatevirtual

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

Implements TtSemiLepHypothesis.

Definition at line 30 of file TtSemiLepHypGenMatch.cc.

References funct::abs(), findMatchingLepton(), TtGenEvtProducer_cfi::genEvt, genEvtToken_, edm::Event::getByToken(), TtSemiLepEvtPartons::HadB, TtSemiLepHypothesis::hadronicB_, heavyIonCSV_trainingSettings::idx, TtSemiLepHypothesis::isValid(), TtSemiLepHypothesis::jetCorrectionLevel(), PDWG_EXODelayedJetMET_cff::jets, TtSemiLepEvtPartons::LepB, TtSemiLepHitFitProducer_Electrons_cfi::leps, TtSemiLepHypothesis::lepton_, TtSemiLepHypothesis::leptonicB_, TtSemiLepEvtPartons::LightQ, TtSemiLepHypothesis::lightQ_, TtSemiLepEvtPartons::LightQBar, TtSemiLepHypothesis::lightQBar_, TtSemiLepHypothesis::makeCandidate(), match(), singleTopDQM_cfi::mets, TtSemiLepHypothesis::neutrino_, TtSemiLepHypothesis::neutrinoSolutionType_, and TtSemiLepHypothesis::setNeutrino().

                                                               {
  // -----------------------------------------------------
  // get genEvent (to distinguish between uds and c quarks
  // and for the lepton matching)
  // -----------------------------------------------------
  edm::Handle<TtGenEvent> genEvt;
  evt.getByToken(genEvtToken_, genEvt);

  // -----------------------------------------------------
  // add jets
  // -----------------------------------------------------
  for (unsigned idx = 0; idx < match.size(); ++idx) {
    if (isValid(match[idx], jets)) {
      switch (idx) {
        case TtSemiLepEvtPartons::LightQ:
          if (std::abs(genEvt->hadronicDecayQuark()->pdgId()) == 4)
            lightQ_ = makeCandidate(jets, match[idx], jetCorrectionLevel("cQuark"));
          else
            lightQ_ = makeCandidate(jets, match[idx], jetCorrectionLevel("udsQuark"));
          break;
        case TtSemiLepEvtPartons::LightQBar:
          if (std::abs(genEvt->hadronicDecayQuarkBar()->pdgId()) == 4)
            lightQBar_ = makeCandidate(jets, match[idx], jetCorrectionLevel("cQuark"));
          else
            lightQBar_ = makeCandidate(jets, match[idx], jetCorrectionLevel("udsQuark"));
          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
  // -----------------------------------------------------
  int iLepton = findMatchingLepton(genEvt, leps);
  if (iLepton < 0)
    return;
  lepton_ = makeCandidate(leps, iLepton);
  match.push_back(iLepton);

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

buildKey()

void TtSemiLepHypGenMatch::buildKey ( )

inlineoverrideprivatevirtual

build the event hypothesis key

Implements TtSemiLepHypothesis.

Definition at line 12 of file TtSemiLepHypGenMatch.cc.

References TtSemiLepHypothesis::key_, and TtEvent::kGenMatch.

{ key_ = TtSemiLeptonicEvent::kGenMatch; };

findMatchingLepton()

int TtSemiLepHypGenMatch::findMatchingLepton ( const edm::Handle< TtGenEvent > &  genEvt, const edm::Handle< edm::View< reco::RecoCandidate > > &  leps  )

private

find index of the candidate nearest to the singleLepton of the generator event in the collection; return -1 if this fails

Definition at line 92 of file TtSemiLepHypGenMatch.cc.

References PbPb_ZMuSkimMuonDPG_cff::deltaR, HGC3DClusterGenMatchSelector_cfi::dR, TtGenEvtProducer_cfi::genEvt, mps_fire::i, TtSemiLepHitFitProducer_Electrons_cfi::leps, TtSemiLepHypothesis::leptonType(), and HLT_2024v11_cff::minDR.

Referenced by buildHypo().

                                                                                                 {
  int genIdx = -1;

  // jump out with -1 when the collection is empty
  if (leps->empty())
    return genIdx;

  if (genEvt->isTtBar() && genEvt->isSemiLeptonic(leptonType(&(leps->front()))) && genEvt->singleLepton()) {
    double minDR = -1;
    for (unsigned i = 0; i < leps->size(); ++i) {
      double dR =
          deltaR(genEvt->singleLepton()->eta(), genEvt->singleLepton()->phi(), (*leps)[i].eta(), (*leps)[i].phi());
      if (minDR < 0 || dR < minDR) {
        minDR = dR;
        genIdx = i;
      }
    }
  }
  return genIdx;
}

Member Data Documentation

genEvtToken_

edm::EDGetTokenT<TtGenEvent> TtSemiLepHypGenMatch::genEvtToken_

protected

Definition at line 24 of file TtSemiLepHypGenMatch.cc.

Referenced by buildHypo().