#include <BoostedTopProducer.cc>

Inheritance diagram for BoostedTopProducer:

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

	~BoostedTopProducer () 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

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)

virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
void	produce (edm::Event &, const edm::EventSetup &) override

double	Psi (const TLorentzVector &p1, const TLorentzVector &p2, double mass)

Private Attributes
double	caloIsoCut_

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

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

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

double	mTop_

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

edm::EDGetTokenT< TtSemiLeptonicEvent >	solToken_

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::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 ESProduct , Transition Tr = Transition::Event>
auto	esConsumes (eventsetup::EventSetupRecordKey const &, 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

Description: Class to examine boosted ttbar pairs in multiple mass regions.

This will produce a ttbar solution, which will take one of two forms: a) lv jj jj Full reconstruction.

ttbar-> (hadt -> (hadW -> hadp + hadq) + hadb) + (lept -> (lepW -> lepton + neutrino) + lepb)

b) lv jj (j) Partial reconstruction, associate at least 1 jet to the lepton hemisphere, and at least one jet in the opposite hemisphere.

ttbar-> (hadt -> (hadJet1 [+ hadJet2] ) ) + (lept -> (lepW -> lepton + neutrino) + lepJet1 )

There will also be two subcategories of (b) that will correspond to physics cases:

b1) Lepton is isolated: Moderate ttbar mass. b2) Lepton is nonisolated: High ttbar mass.

Implementation: To implement this, we use the NamedCompositeCandidate structures from the Candidate model. This provides flexibility in the definition of the output objects and allows automatic plotting in the Starter Kit. We use the PAT objects to construct the ttbar solutions in the different ranges as follows: a) Full reconstruction: We use TtSemiEventSolutions made upstream of this module. b) Partial reconstruction: Association of variables using the "Psi" variable, which is a more rapidity-invariant version of deltaR.

Definition at line 83 of file BoostedTopProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 23 of file BoostedTopProducer.cc.

                                                                      :
   eleToken_   (consumes<std::vector<pat::Electron> >(iConfig.getParameter<edm::InputTag>  ("electronLabel"))),
   muoToken_   (consumes<std::vector<pat::Muon> >(iConfig.getParameter<edm::InputTag>  ("muonLabel"))),
   jetToken_   (consumes<std::vector<pat::Jet> >(iConfig.getParameter<edm::InputTag>  ("jetLabel"))),
   metToken_   (consumes<std::vector<pat::MET> >(iConfig.getParameter<edm::InputTag>  ("metLabel"))),
   solToken_   (mayConsume<TtSemiLeptonicEvent>(iConfig.getParameter<edm::InputTag>  ("solLabel"))),
   caloIsoCut_ (iConfig.getParameter<double>         ("caloIsoCut") ),
   mTop_       (iConfig.getParameter<double>         ("mTop") )
 {
   //register products
   produces<std::vector<reco::CompositeCandidate> > ();
 }

BoostedTopProducer::~BoostedTopProducer ( )

override

Definition at line 37 of file BoostedTopProducer.cc.

38 {

39 }

Member Function Documentation

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

overrideprivate

Definition at line 48 of file BoostedTopProducer.cc.

References reco::CompositeCandidate::addDaughter(), METzCalculator::Calculate(), caloIsoCut_, gather_cfg::cout, debug, metsig::electron, electrons_cff::electrons, eleToken_, reco::LeafCandidate::energy(), TtEvent::eventHypo(), edm::Event::getByToken(), cuy::ii, reco::isMuon(), edm::HandleBase::isValid(), fwrapper::jets, jetToken_, TtEvent::kMVADisc, TtSemiLepSignalSelMVAComputer_cfi::mets, metToken_, eostools::move(), mTop_, extraflags_cff::muons, muoToken_, reco::CompositeCandidate::numberOfDaughters(), Pi, electronCleaner_cfi::preselection, Psi(), EnergyCorrector::pt, edm::Event::put(), reco::LeafCandidate::px(), reco::LeafCandidate::py(), reco::LeafCandidate::pz(), alignCSCRings::s, AddFourMomenta::set(), METzCalculator::SetMET(), METzCalculator::SetMuon(), reco::LeafCandidate::setPz(), solToken_, AlCaHLTBitMon_QueryRunRegistry::string, and TriggerAnalyzer::write().

 {
 
   using namespace edm;
 
   bool debug = false;
 
   // -----------------------------------------------------
   // get the bare PAT objects
   // -----------------------------------------------------
    edm::Handle<std::vector<pat::Muon> > muonHandle;
    iEvent.getByToken(muoToken_,muonHandle);
    std::vector<pat::Muon> const & muons = *muonHandle;
 
    edm::Handle<std::vector<pat::Jet> > jetHandle;
    iEvent.getByToken(jetToken_,jetHandle);
    std::vector<pat::Jet> const & jets = *jetHandle;
 
    edm::Handle<std::vector<pat::Electron> > electronHandle;
    iEvent.getByToken(eleToken_,electronHandle);
    std::vector<pat::Electron> const & electrons = *electronHandle;
 
    edm::Handle<std::vector<pat::MET> > metHandle;
    iEvent.getByToken(metToken_,metHandle);
    std::vector<pat::MET> const & mets = *metHandle;
 
    // -----------------------------------------------------
    // Event Preselection:
    //    <= 1 isolated electron or muon
    //    >= 1 electron or muon
    //    >= 2 jets
    //    >= 1 missing et
    //
    // To explain:
    //    We want to look at leptons within "top jets" in some
    //    cases. This means the isolation will kill those events.
    //    However, if there IS an isolated lepton, we want only
    //    one of them.
    //
    //    So to select the prompt W lepton, the logic is:
    //    1. If there is an isolated lepton, accept it as the W lepton.
    //    2. Else, take the highest Pt lepton (possibly non-isolated)
    //
    // -----------------------------------------------------
    bool preselection = true;
 
    // This will hold the prompt W lepton candidate, and a
    // maximum pt decision variable
    double maxWLeptonPt = -1;
    //reco::Candidate const * Wlepton = 0;
 
    // ----------------------
    // Find isolated muons, and highest pt lepton
    // ----------------------
    std::vector<pat::Muon>::const_iterator isolatedMuon     = muons.end();
    std::vector<pat::Muon>::const_iterator muon = muons.end();
    unsigned int nIsolatedMuons = 0;
    std::vector<pat::Muon>::const_iterator muonIt = muons.begin(),
      muonEnd = muons.end();
    for (; muonIt != muonEnd; ++muonIt ) {
 
      // Find highest pt lepton
      double pt = muonIt->pt();
      if ( pt > maxWLeptonPt ) {
        maxWLeptonPt = pt;
        muon = muonIt;
      }
 
      // Find any isolated muons
      double caloIso = muonIt->caloIso();
      if ( caloIso >= 0 && caloIso < caloIsoCut_ ) {
        nIsolatedMuons++;
        isolatedMuon = muonIt;
      }
    }
 
    // ----------------------
    // Find isolated electrons, and highest pt lepton
    // ----------------------
    std::vector<pat::Electron>::const_iterator isolatedElectron     = electrons.end();
    std::vector<pat::Electron>::const_iterator electron = electrons.end();
    unsigned int nIsolatedElectrons = 0;
    std::vector<pat::Electron>::const_iterator electronIt = electrons.begin(),
      electronEnd = electrons.end();
    for (; electronIt != electronEnd; ++electronIt ) {
 
      // Find highest pt lepton
      double pt = electronIt->pt();
      if ( pt > maxWLeptonPt ) {
        maxWLeptonPt = pt;
        electron = electronIt;
      }
 
      // Find any isolated electrons
      double caloIso = electronIt->caloIso();
      if ( caloIso >= 0 && caloIso < caloIsoCut_ ) {
        nIsolatedElectrons++;
        isolatedElectron = electronIt;
      }
    }
 
 
    // ----------------------
    // Now decide on the "prompt" lepton from the W:
    // Choose isolated leptons over all, and if no isolated,
    // then take highest pt lepton.
    // ----------------------
    bool isMuon = true;
    if      ( isolatedMuon     != muonEnd     ) { muon     = isolatedMuon;     isMuon = true; }
    else if ( isolatedElectron != electronEnd ) { electron = isolatedElectron; isMuon = false; }
    else {
      // Set to the highest pt lepton
      if      ( muon != muonEnd && electron == electronEnd ) isMuon = true;
      else if ( muon == muonEnd && electron != electronEnd ) isMuon = false;
      else if ( muon != muonEnd && electron != electronEnd ) {
        isMuon =  muon->pt() > electron->pt();
      }
    }
 
    // ----------------------
    // Veto events that have more than one isolated lepton
    // ----------------------
    int nIsolatedLeptons = nIsolatedMuons + nIsolatedElectrons;
    if ( nIsolatedLeptons > 1 ) {
      preselection = false;
    }
 
    // ----------------------
    // Veto events that have no prompt lepton candidates
    // ----------------------
    if ( muon == muonEnd && electron == electronEnd ) {
      preselection = false;
    }
 
    // ----------------------
    // Veto events with < 2 jets or no missing et
    // ----------------------
    if ( jets.size() < 2 ||
     mets.empty() ) {
      preselection = false;
    }
 
    bool write = false;
 
 
 
    // -----------------------------------------------------
    //
    // CompositeCandidates to store the event solution.
    // This will take one of two forms:
    //    a) lv jj jj   Full reconstruction.
    //
    //   ttbar->
    //       (hadt -> (hadW -> hadp + hadq) + hadb) +
    //       (lept -> (lepW -> lepton + neutrino) + lepb)
    //
    //    b) lv jj (j)  Partial reconstruction, associate
    //                  at least 1 jet to the lepton
    //                  hemisphere, and at least one jet in
    //                  the opposite hemisphere.
    //
    //    ttbar->
    //        (hadt -> (hadJet1 [+ hadJet2] ) ) +
    //        (lept -> (lepW -> lepton + neutrino) + lepJet1 )
    //
    // There will also be two subcategories of (b) that
    // will correspond to physics cases:
    //
    //    b1)           Lepton is isolated: Moderate ttbar mass.
    //    b2)           Lepton is nonisolated: High ttbar mass.
    //
    // -----------------------------------------------------
    reco::CompositeCandidate ttbar("ttbar");
    AddFourMomenta addFourMomenta;
 
 
    // Main decisions after preselection
    if ( preselection ) {
 
      if ( debug ) cout << "Preselection is satisfied" << endl;
 
      if ( debug ) cout << "Jets.size() = " << jets.size() << endl;
 
      // This will be modified for the z solution, so make a copy
      pat::MET              neutrino( mets[0] );
 
 
      // 1. First examine the low mass case with 4 jets and widely separated
      //    products. We take out the TtSemiLeptonicEvent from the TQAF and
      //    form the ttbar invariant mass.
      if ( jets.size() >= 4 ) {
 
        if ( debug ) cout << "Getting ttbar semileptonic solution" << endl;
 
        // get the ttbar semileptonic event solution if there are more than 3 jets
        edm::Handle< TtSemiLeptonicEvent > eSol;
        iEvent.getByToken(solToken_, eSol);
 
        // Have solution, continue
        if ( eSol.isValid() ) {
      if ( debug ) cout << "Got a nonzero size solution vector" << endl;
      // Just set the ttbar solution to the best ttbar solution from
      // TtSemiEvtSolutionMaker
      ttbar = eSol->eventHypo(TtSemiLeptonicEvent::kMVADisc);
      write = true;
        }
        // No ttbar solution with 4 jets, something is weird, print a warning
        else {
      edm::LogWarning("DataNotFound") << "BoostedTopProducer: Cannot find TtSemiEvtSolution\n";
        }
      }
      // 2. With 2 or 3 jets, we decide based on the separation between
      // the lepton and the closest jet in that hemisphere whether to
      // consider it "moderate" or "high" mass.
      else if ( jets.size() == 2 || jets.size() == 3 ) {
 
        // ------------------------------------------------------------------
        // First create a leptonic W candidate
        // ------------------------------------------------------------------
        reco::CompositeCandidate lepW("lepW");
 
        if ( isMuon ) {
      if ( debug ) cout << "Adding muon as daughter" << endl;
      lepW.addDaughter(  *muon,     "muon" );
        } else {
      if ( debug ) cout << "Adding electron as daughter" << endl;
      lepW.addDaughter( *electron, "electron" );
        }
        if ( debug ) cout << "Adding neutrino as daughter" << endl;
        lepW.addDaughter  ( neutrino, "neutrino");
        addFourMomenta.set( lepW );
 
        //bool nuzHasComplex = false;
        METzCalculator zcalculator;
 
        zcalculator.SetMET( neutrino );
        if ( isMuon )
      zcalculator.SetMuon( *muon );
        else
      zcalculator.SetMuon( *electron ); // This name is misleading, should be setLepton
        double neutrinoPz = zcalculator.Calculate(1);// closest to the lepton Pz
        //if (zcalculator.IsComplex()) nuzHasComplex = true;
        // Set the neutrino pz
        neutrino.setPz( neutrinoPz );
 
        if ( debug ) cout << "Set neutrino pz to " << neutrinoPz << endl;
 
        // ------------------------------------------------------------------
        // Next ensure that there is a jet within the hemisphere of the
        // leptonic W, and one in the opposite hemisphere
        // ------------------------------------------------------------------
        reco::CompositeCandidate hadt("hadt");
        reco::CompositeCandidate lept("lept");
        if ( debug ) cout << "Adding lepW as daughter" << endl;
        lept.addDaughter( lepW, "lepW" );
 
        std::string hadName("hadJet");
        std::string lepName("lepJet");
 
        // Get the W momentum
        TLorentzVector p4_W (lepW.px(), lepW.py(), lepW.pz(), lepW.energy() );
 
        // Loop over the jets
        std::vector<pat::Jet>::const_iterator jetit = jets.begin(),
      jetend = jets.end();
        unsigned long ii = 1; // Count by 1 for naming histograms
        for ( ; jetit != jetend; ++jetit, ++ii ) {
      // Get this jet's momentum
      TLorentzVector p4_jet (jetit->px(), jetit->py(), jetit->pz(), jetit->energy() );
 
      // Calculate psi (like DeltaR, only more invariant under Rapidity)
      double psi = Psi( p4_W, p4_jet, mTop_ );
 
      // Get jets that are in the leptonic hemisphere
      if ( psi < TMath::Pi() ) {
        // Add this jet to the leptonic top
        std::stringstream s;
        s << lepName << ii;
        if ( debug ) cout << "Adding daughter " << s.str() << endl;
        lept.addDaughter( *jetit, s.str() );
      }
      // Get jets that are in the hadronic hemisphere
      if ( psi > TMath::Pi() ) {
        // Add this jet to the hadronic top. We don't
        // make any W hypotheses in this case, since
        // we cannot determine which of the three
        // jets are merged.
        std::stringstream s;
        s << hadName << ii;
        if ( debug ) cout << "Adding daughter " << s.str() << endl;
        hadt.addDaughter( *jetit, s.str() );
 
      }
        } // end loop over jets
 
        addFourMomenta.set( lept );
        addFourMomenta.set( hadt );
 
        bool lepWHasJet = lept.numberOfDaughters() >= 2; // W and >= 1 jet
        bool hadWHasJet = hadt.numberOfDaughters() >= 1; // >= 1 jet
        if ( lepWHasJet && hadWHasJet ) {
      if ( debug ) cout << "Adding daughters lept and hadt" << endl;
      ttbar.addDaughter( lept, "lept");
      ttbar.addDaughter( hadt, "hadt");
      addFourMomenta.set( ttbar );
      write = true;
        } // end of hadronic jet and leptonic jet
 
 
      } // end if there are 2 or 3 jets
 
    } // end if preselection is satisfied
 
    // Write the solution to the event record
    std::vector<reco::CompositeCandidate> ttbarList;
    if ( write ) {
      if ( debug ) cout << "Writing out" << endl;
      ttbarList.push_back( ttbar );
    }
    std::unique_ptr<std::vector<reco::CompositeCandidate> > pTtbar ( new std::vector<reco::CompositeCandidate>(ttbarList) );
    iEvent.put(std::move(pTtbar));
 
 
 }

double BoostedTopProducer::Psi	(	const TLorentzVector &	p1,
		const TLorentzVector &	p2,
		double	mass
	)

private

Definition at line 374 of file BoostedTopProducer.cc.

References Abs(), DEFINE_FWK_MODULE, p2, and Pi.

Referenced by produce().

                                                                                        {
 
     TLorentzVector ptot = p1 + p2;
     Double_t theta1 = TMath::ACos( (p1.Vect().Dot(ptot.Vect()))/(p1.P()*ptot.P()) );
     Double_t theta2 = TMath::ACos( (p2.Vect().Dot(ptot.Vect()))/(p2.P()*ptot.P()) );
     //Double_t sign = 1.;
     //if ( (theta1+theta2) > (TMath::Pi()/2) ) sign = -1.;
     double th1th2 = theta1 + theta2;
     double psi = (p1.P()+p2.P())*TMath::Abs(TMath::Sin(th1th2))/(2.* mass );
     if ( th1th2 > (TMath::Pi()/2) )
         psi = (p1.P()+p2.P())*( 1. + TMath::Abs(TMath::Cos(th1th2)))/(2.* mass );
 
     return psi;
 }

Member Data Documentation

double BoostedTopProducer::caloIsoCut_

private

Definition at line 101 of file BoostedTopProducer.h.

Referenced by produce().

edm::EDGetTokenT<std::vector<pat::Electron> > BoostedTopProducer::eleToken_

private

Definition at line 94 of file BoostedTopProducer.h.

Referenced by produce().

edm::EDGetTokenT<std::vector<pat::Jet> > BoostedTopProducer::jetToken_

private

Definition at line 96 of file BoostedTopProducer.h.

Referenced by produce().

edm::EDGetTokenT<std::vector<pat::MET> > BoostedTopProducer::metToken_

private

Definition at line 97 of file BoostedTopProducer.h.

Referenced by produce().

double BoostedTopProducer::mTop_

private

Definition at line 102 of file BoostedTopProducer.h.

Referenced by produce().

edm::EDGetTokenT<std::vector<pat::Muon> > BoostedTopProducer::muoToken_

private

Definition at line 95 of file BoostedTopProducer.h.

Referenced by produce().

edm::EDGetTokenT<TtSemiLeptonicEvent> BoostedTopProducer::solToken_

private

Definition at line 98 of file BoostedTopProducer.h.

Referenced by produce().

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation