code/dev/SimpleAnalysis_8hh_source.html

// -*- C++ -*-

#include "Rivet/Analysis.hh"

#include "Rivet/Projections/FinalState.hh"

#include "Rivet/Projections/FastJets.hh"

#include "Rivet/Projections/LeptonFinder.hh"

#include "Rivet/Projections/TauFinder.hh"

#include "Rivet/Projections/MissingMomentum.hh"

#include "Rivet/Projections/DirectFinalState.hh"

#include "Rivet/Projections/Smearing.hh"

#include "Rivet/Tools/Cutflow.hh"


namespace Rivet {


  class SimpleAnalysis : public Analysis {

  public:


    enum class IDClass { LOOSE, MEDIUM, TIGHT };


    SimpleAnalysis(const std::string& name)

      : Analysis(name)

    {    }


    virtual ~SimpleAnalysis()

    {    }


    void postInit() {


      // Electron projections

      FinalState es(_acut && _ecut && Cuts::abspid == PID::ELECTRON);

      LeptonFinder es_prompt(_acut && _ecut && Cuts::abspid == PID::ELECTRON, 0.1);

      for (const auto& classkv : _idclasses()) {

        const IDClass& idc = classkv.first;

        const string p = "Electrons";

        const string aname = _pckey(true, idc, p);

        if (!hasProjection(aname))

          declare(SmearedParticles(es, _effs_electron[idc], _smear_electron), aname);

        const string pname = _pckey(false, idc, p);

        if (!hasProjection(pname))

          declare(SmearedParticles(es_prompt, _effs_electron[idc], _smear_electron), pname);

      }


      // Muon projections

      FinalState ms(_acut && _mcut && Cuts::abspid == PID::MUON);

      LeptonFinder ms_prompt(_acut && _mcut && Cuts::abspid == PID::MUON, 0.1);

      for (const auto& classkv : _idclasses()) {

        const IDClass& idc = classkv.first;

        const string p = "Muons";

        const string aname = _pckey(true, idc, p);

        if (!hasProjection(aname))

          declare(SmearedParticles(ms, _effs_muon[idc], _smear_muon), aname);

        const string pname = _pckey(false, idc, p);

        if (!hasProjection(pname))

          declare(SmearedParticles(ms_prompt, _effs_muon[idc], _smear_muon), pname);

      }


      // Photon projections

      FinalState ys(_acut && _phocut && Cuts::abspid == PID::PHOTON);

      DirectFinalState ys_prompt(_acut && _phocut && Cuts::abspid == PID::PHOTON);

      for (const auto& classkv : _idclasses()) {

        const IDClass& idc = classkv.first;

        const string p = "Photons";

        const string aname = _pckey(true, idc, p);

        if (!hasProjection(aname))

          declare(SmearedParticles(ys, _effs_photon[idc], _smear_photon), aname);

        const string pname = _pckey(false, idc, p);

        if (!hasProjection(pname))

          declare(SmearedParticles(ys_prompt, _effs_photon[idc], _smear_photon), pname);

      }


      // Tau projections

      TauFinder ts(TauDecay::HADRONIC, LeptonOrigin::ANY, _acut && _tcut);

      TauFinder ts_prompt(TauDecay::HADRONIC, LeptonOrigin::NODECAY, _acut && _tcut);

      for (const auto& classkv : _idclasses()) {

        const IDClass& idc = classkv.first;

        const string p = "Taus";

        const string aname = _pckey(true, idc, p);

        if (!hasProjection(aname))

          declare(SmearedParticles(ts, _effs_tau[idc], _smear_tau), aname);

        const string pname = _pckey(false, idc, p);

        if (!hasProjection(pname))

          declare(SmearedParticles(ts_prompt, _effs_tau[idc], _smear_tau), pname);

      }


      // Track projection

      const FinalState trkfs(_acut && _trkcut && Cuts::abscharge > 0);

      if (!hasProjection("Tracks"))

        declare(SmearedParticles(trkfs, _eff_trk, _smear_trk), "Tracks");


      // Jet projections

      const FinalState allfs(_acut);

      declare(allfs, "AllParticles");

      for (const auto& jditem : _jdefs) {

        const JetScheme& jd = jditem.second;

        FastJets jetfs(allfs, jd.alg, jd.R, jd.muons, jd.invis);

        if (!hasProjection("Jets"+jditem.first))

          declare(SmearedJets(jetfs, _smears_jet[jditem.first], _effs_btag[jditem.first]), "Jets"+jditem.first);

      }


      // Missing momentum projection

      if (!hasProjection("MET"))

        declare(SmearedMET(MissingMomentum(allfs), _smearps_met, _smear_met), "MET");

    }


    void preAnalyze(const Event& event) {

      _electrons.clear();

      _muons.clear();

      _taus.clear();

      _photons.clear();

      _jets.clear();

      _bjets.clear();

    }


    void setElectronReco(const ParticleEffFn& eff, const ParticleSmearFn& smear=PARTICLE_SMEAR_IDENTITY, IDClass idc=IDClass::MEDIUM) {

      _effs_electron[idc] = eff;

      _smear_electron = smear;

    }


    void setMuonReco(const ParticleEffFn& eff, const ParticleSmearFn& smear=PARTICLE_SMEAR_IDENTITY, IDClass idc=IDClass::MEDIUM) {

      _effs_muon[idc] = eff;

      _smear_muon = smear;

    }


    void setPhotonReco(const ParticleEffFn& eff, const ParticleSmearFn& smear=PARTICLE_SMEAR_IDENTITY, IDClass idc=IDClass::MEDIUM) {

      _effs_photon[idc] = eff;

      _smear_photon = smear;

    }


    void setTauReco(const ParticleEffFn& eff, const ParticleSmearFn& smear=PARTICLE_SMEAR_IDENTITY, IDClass idc=IDClass::MEDIUM) {

      _effs_tau[idc] = eff;

      _smear_tau = smear;

    }


    void setTrkReco(const ParticleEffFn& eff, const ParticleSmearFn& smear=PARTICLE_SMEAR_IDENTITY) {

      _eff_trk = eff;

      _smear_trk = smear;

    }


    void setJetReco(const JetSmearFn& smear, const JetEffFn& btageff, const std::string& jetname="DEFAULT") {

      _smears_jet[jetname] = smear;

      _effs_btag[jetname] = btageff;

    }


    void setMETReco(const METSmearParamsFn& smearps) {

      _smearps_met = smearps;

    }


    void setMETReco(const METSmearParamsFn& smearps, const METSmearFn& smear) {

      _smearps_met = smearps;

      _smear_met = smear;

    }


    void setAccCut(const Cut& cut) { _acut = cut; }

    void setElectronCut(const Cut& cut) { _ecut = cut; }

    void setMuonCut(const Cut& cut) { _mcut = cut; }

    void setPhotonCut(const Cut& cut) { _phocut = cut; }

    void setTauCut(const Cut& cut) { _tcut = cut; }

    void setTrkCut(const Cut& cut) { _trkcut = cut; }

    void setJetDef(const JetScheme& jdef, const std::string& jetname="DEFAULT") { _jdefs[jetname] = jdef; }

    void setJetCut(const Cut& cut, const std::string& jetname="DEFAULT") { _jcuts[jetname] = cut; }


    const Particles& electrons(IDClass eclass=IDClass::MEDIUM, bool include_nonprompt=false) const {

      const std::string kpc = _pckey(include_nonprompt, eclass);

      if (_electrons.find(kpc) == _electrons.end()) { //< if not cached

        _electrons[kpc] = apply<ParticleFinder>(currentEvent(), "Electrons"+kpc).particlesByPt();

      }

      return _electrons.at(kpc);

    }


    Particles electrons(const Cut& cut, IDClass eclass=IDClass::MEDIUM, bool include_nonprompt=false) const {

      return select(electrons(eclass, include_nonprompt), cut);

    }


    const Particles& muons(IDClass muclass=IDClass::MEDIUM, bool include_nonprompt=false) const {

      const std::string kpc = _pckey(include_nonprompt, muclass);

      if (_muons.find(kpc) == _muons.end()) { //< if not cached

        _muons[kpc] = apply<ParticleFinder>(currentEvent(), "Muons"+kpc).particlesByPt();

      }

      return _muons.at(kpc);

    }


    Particles muons(const Cut& cut, IDClass muclass=IDClass::MEDIUM, bool include_nonprompt=false) const {

      return select(muons(muclass, include_nonprompt), cut);

    }


    const Particles& photons(IDClass phoclass=IDClass::MEDIUM, bool include_nonprompt=false, double dRiso=0.4, double isofrac=0.1) const {

      const std::string kpc = _pckey(include_nonprompt, phoclass);

      if (_photons.find(kpc) == _photons.end()) { //< if not cached

        Particles ystmp = apply<ParticleFinder>(currentEvent(), "Photons"+kpc).particlesByPt();

        const Particles& clusters = apply<ParticleFinder>(currentEvent(), "AllParticles").particles();

        _photons[kpc].reserve(ystmp.size());

        for (const Particle& y : ystmp) {

          double sumpt = 0;

          for (const Particle& cl : select(clusters, deltaRLess(y, dRiso))) {

            if (deltaR(cl, y) == 0.01) continue; //< irresolvably close

            sumpt += cl.pT();

          }

          if (sumpt/y.pT() < isofrac) _photons[kpc].push_back(y);

        }

      }

      return _photons.at(kpc);

    }


    Particles photons(const Cut& cut, IDClass phoclass=IDClass::MEDIUM, bool include_nonprompt=false) const {

      return select(photons(phoclass, include_nonprompt), cut);

    }


    const Particles& taus(IDClass tauclass=IDClass::MEDIUM, bool include_nonprompt=false) const {

      const std::string kpc = _pckey(include_nonprompt, tauclass);

      if (_taus.find(kpc) == _taus.end()) { //< if not cached

        _taus[kpc] = apply<ParticleFinder>(currentEvent(), "Taus"+kpc).particlesByPt();

      }

      return _taus.at(kpc);

    }


    Particles taus(const Cut& cut, IDClass tauclass=IDClass::MEDIUM, bool include_nonprompt=false) const {

      return select(taus(tauclass, include_nonprompt), cut);

    }


    const Particles tracks() const {

      return apply<ParticleFinder>(currentEvent(), "Tracks").particlesByPt();

    }


    Particles tracks(const Cut& cut) const {

      return apply<ParticleFinder>(currentEvent(), "Tracks").particlesByPt(cut);

    }


    const std::vector<std::string> jetnames() const {

      std::vector<std::string> rtn;

      rtn.reserve(_jets.size());

      for (const auto& kv : _jets) rtn.push_back(kv.first);

      return rtn;

    }


    const Jets& jets(const std::string& jetname="DEFAULT") const {

      if (_jets.find(jetname) == _jets.end()) { //< not cached

        _jets[jetname] = apply<JetFinder>(currentEvent(), "Jets"+jetname).jetsByPt(_jcuts.at(jetname));

      }

      return _jets.at(jetname);

    }


    Jets jets(const Cut& cut, const std::string& jetname="DEFAULT") const {

      return select(jets(jetname), cut);

    }


    const Jets& bjets(const std::string& jetname="DEFAULT") const {

      if (_bjets.find(jetname) == _bjets.end()) { //< not cached

        _bjets[jetname] = select(jets(jetname), hasBTag(_bcut, _bdeltaR));

      }

      return _bjets.at(jetname);

    }


    Jets bjets(const Cut& cut, const std::string& jetname="DEFAULT") const {

      return select(bjets(jetname), cut);

    }


    Vector3 vmet() const {

      return apply<METFinder>(currentEvent(), "MET").vectorMissingPt();

    }


    double met() const {

      return vmet().mod();

    }


    double set() const {

      return apply<METFinder>(currentEvent(), "MET").scalarEt();

    }


    double metSignf() const {

      return apply<SmearedMET>(currentEvent(), "MET").missingEtSignf();

    }


    void doSimpleOverlapRemoval(IDClass eclass=IDClass::MEDIUM, IDClass muclass=IDClass::MEDIUM,

                                IDClass phoclass=IDClass::MEDIUM, //IDClass tauclass=IDClass::MEDIUM,

                                bool include_nonprompt=false, const std::string& jetname="DEFAULT") {

      // Get non-const handles for filtering (and ensure objects exist)

      Jets& myjets = const_cast<Jets&>(jets(jetname));

      Jets& mybjets = const_cast<Jets&>(bjets(jetname));

      Particles& myes = const_cast<Particles&>(electrons(eclass, include_nonprompt));

      Particles& myms = const_cast<Particles&>(muons(muclass, include_nonprompt));

      //Particles& myts = const_cast<Particles&>(taus(tauclass, include_nonprompt));

      Particles& myys = const_cast<Particles&>(photons(phoclass, include_nonprompt));

      // Remove all jets within dR < 0.2 of a dressed lepton

      idiscardIfAnyDeltaRLess(myjets, myes, 0.2);

      idiscardIfAnyDeltaRLess(myjets, myms, 0.2);

      idiscardIfAnyDeltaRLess(mybjets, myes, 0.2);

      idiscardIfAnyDeltaRLess(mybjets, myms, 0.2);

      // Remove all isolated photons within dR < 0.2 of a dressed electron

      idiscardIfAnyDeltaRLess(myys, myes, 0.2);

      // Remove dressed leptons within the radius of a remaining jet

      idiscardIfAnyDeltaRLess(myes, myjets, _jdefs.at(jetname).R);

      idiscardIfAnyDeltaRLess(myms, myjets, _jdefs.at(jetname).R);

    }


    // void doJetRecluster(/* jet collection names (in and out), recluster-alg enum and dR */) {

    //   /// @todo ...

    // }


    template<typename T>


    void scaleToIntLumi(T& ao, double intlumi) {

      scale(ao, intlumi*crossSection()/sumOfWeights());

    }


    const ParticleFinder& electronsProj(IDClass eclass=IDClass::MEDIUM, bool include_nonprompt=false) {

      return getProjection<ParticleFinder>(_pckey(include_nonprompt, eclass, "Electrons"));

    }


    const ParticleFinder& muonsProj(IDClass muclass=IDClass::MEDIUM, bool include_nonprompt=false) {

      return getProjection<ParticleFinder>(_pckey(include_nonprompt, muclass, "Muons"));

    }


    const ParticleFinder& tausProj(IDClass tauclass=IDClass::MEDIUM, bool include_nonprompt=false) {

      return getProjection<ParticleFinder>(_pckey(include_nonprompt, tauclass, "Taus"));

    }


    const ParticleFinder& photonsProj(IDClass phoclass=IDClass::MEDIUM, bool include_nonprompt=false) {

      return getProjection<ParticleFinder>(_pckey(include_nonprompt, phoclass, "Photons"));

    }


    const ParticleFinder& tracksProj() {

      return getProjection<ParticleFinder>("Tracks");

    }


    const JetFinder& jetsProj(const std::string& jetname="DEFAULT") {

      return getProjection<JetFinder>("Jets_"+jetname);

    }


    const METFinder& metProj() { return getProjection<METFinder>("MET"); }


  private:


    std::map<IDClass, ParticleEffFn> _effs_electron{ { IDClass::LOOSE, PARTICLE_EFF_ONE }, { IDClass::MEDIUM, PARTICLE_EFF_ONE }, { IDClass::TIGHT, PARTICLE_EFF_ONE } };

    std::map<IDClass, ParticleEffFn> _effs_muon{ { IDClass::LOOSE, PARTICLE_EFF_ONE }, { IDClass::MEDIUM, PARTICLE_EFF_ONE }, { IDClass::TIGHT, PARTICLE_EFF_ONE } };

    std::map<IDClass, ParticleEffFn> _effs_photon{ { IDClass::LOOSE, PARTICLE_EFF_ONE }, { IDClass::MEDIUM, PARTICLE_EFF_ONE }, { IDClass::TIGHT, PARTICLE_EFF_ONE } };

    std::map<IDClass, ParticleEffFn> _effs_tau{ { IDClass::LOOSE, PARTICLE_EFF_ONE }, { IDClass::MEDIUM, PARTICLE_EFF_ONE }, { IDClass::TIGHT, PARTICLE_EFF_ONE } };

    ParticleSmearFn _smear_electron{PARTICLE_SMEAR_IDENTITY}, _smear_muon{PARTICLE_SMEAR_IDENTITY}, _smear_photon{PARTICLE_SMEAR_IDENTITY}, _smear_tau{PARTICLE_SMEAR_IDENTITY};

    ParticleEffFn _eff_trk{PARTICLE_EFF_ONE};

    ParticleSmearFn _smear_trk{PARTICLE_SMEAR_IDENTITY};

    std::map<std::string, JetSmearFn> _smears_jet{ { "DEFAULT", JET_SMEAR_IDENTITY } };

    std::map<std::string, JetEffFn> _effs_btag{ { "DEFAULT", JET_BTAG_IDENTITY } };

    METSmearParamsFn _smearps_met{MET_SMEARPARAMS_IDENTITY};

    METSmearFn _smear_met{MET_SMEAR_IDENTITY};


    Cut _acut = Cuts::abseta < 5.0; //< base acceptance, applied to all

    Cut _ecut = Cuts::pT > 10*GeV;

    Cut _mcut = Cuts::pT > 10*GeV;

    Cut _tcut = Cuts::pT > 10*GeV;

    Cut _trkcut = Cuts::abseta < 2.5;

    Cut _phocut = Cuts::pT > 10*GeV;

    std::map<std::string, Cut> _jcuts = {{ "DEFAULT",  Cuts::pT > 20*GeV && Cuts::abseta < 5.0 }};

    std::map<std::string, JetScheme> _jdefs = {{ "DEFAULT", JetScheme(JetAlg::ANTIKT, 0.4) }};


    Cut _bcut = Cuts::pT > 5*GeV && Cuts::abseta < 2.5;

    double _bdeltaR = 0.3;


    // Internal typedefs

    // using ParticlesMap = std::map<std::string, Particles>;

    // using JetsMap = std::map<std::string, Jets>;


    mutable std::map<std::string, Particles> _electrons, _muons, _taus, _photons;


    mutable std::map<std::string, Jets> _jets, _bjets;


    //

    const std::map<IDClass, std::string>& _idclasses() const {

      // static const std::vector<IDClass> _idclasses{ {IDClass::LOOSE, IDClass::MEDIUM, IDClass::TIGHT} };

      static const auto* map = new std::map<IDClass, std::string>{

        {IDClass::LOOSE, "Loose"}, {IDClass::MEDIUM, "Medium"}, {IDClass::TIGHT, "Tight"} };

      return *map;

    }

    const std::string& _idclassname(const IDClass& idc) const {

      return _idclasses().at(idc);

    }


    std::string _pckey(bool include_nonprompt, IDClass idc, const std::string& prefix="") const {

      return prefix + (include_nonprompt ? "All" : "Prompt") + _idclassname(idc);

    }


  };


}


#define RIVET_DEFAULT_SIMPLEANALYSIS_CTOR(clsname) clsname() : SimpleAnalysis(# clsname) {}


#define setDetSmearing(DET, BTAG) do {                                  \

  setElectronReco(ELECTRON_EFF_ ## DET ## _LOOSE, ELECTRON_SMEAR_ ## DET, IDClass::LOOSE) ; \

  setElectronReco(ELECTRON_EFF_ ## DET ## _MEDIUM, ELECTRON_SMEAR_ ## DET, IDClass::MEDIUM) ; \

  setElectronReco(ELECTRON_EFF_ ## DET ## _TIGHT, ELECTRON_SMEAR_ ## DET, IDClass::TIGHT) ; \

  setMuonReco(MUON_EFF_ ## DET ## _LOOSE, MUON_SMEAR_ ## DET, IDClass::LOOSE) ; \

  setMuonReco(MUON_EFF_ ## DET ## _MEDIUM, MUON_SMEAR_ ## DET, IDClass::MEDIUM) ; \

  setMuonReco(MUON_EFF_ ## DET ## _TIGHT, MUON_SMEAR_ ## DET, IDClass::TIGHT) ; \

  setPhotonReco(PHOTON_EFF_ ## DET ## _LOOSE, ELECTRON_SMEAR_ ## DET, IDClass::LOOSE) ; \

  setPhotonReco(PHOTON_EFF_ ## DET ## _MEDIUM, ELECTRON_SMEAR_ ## DET, IDClass::MEDIUM) ; \

  setPhotonReco(PHOTON_EFF_ ## DET ## _TIGHT, ELECTRON_SMEAR_ ## DET, IDClass::TIGHT) ; \

  setTauReco(TAU_EFF_ ## DET ## _LOOSE, TAU_SMEAR_ ## DET, IDClass::LOOSE) ; \

  setTauReco(TAU_EFF_ ## DET ## _MEDIUM, TAU_SMEAR_ ## DET, IDClass::MEDIUM) ; \

  setTauReco(TAU_EFF_ ## DET ## _TIGHT, TAU_SMEAR_ ## DET, IDClass::TIGHT) ; \

  setTrkReco(TRK_EFF_ ## DET, TRK_SMEAR_ ## DET) ;                      \

  for (const std::string& jname : jetnames())                           \

    setJetReco(JET_SMEAR_ ## DET, JET_BTAG_ ## DET ## _ ## BTAG, jname) ; \

  setMETReco(MET_SMEARPARAMS_ ## DET, MET_SMEAR_ ## DET) ;                                \

  } while (0)

Rivet::Analysis
This is the base class of all analysis classes in Rivet.
Definition Analysis.hh:70

Rivet::Analysis::crossSection
double crossSection() const
Get the process cross-section in pb. Throws if this hasn't been set.

Rivet::Analysis::currentEvent
const Event & currentEvent() const
Access the current event.
Definition Analysis.hh:425

Rivet::Analysis::scale
void scale(MultiplexPtr< Multiplexer< T > > &ao, CounterAdapter factor)
Multiplicatively scale the given AnalysisObject, ao, by factor factor.
Definition Analysis.hh:1271

Rivet::Analysis::sumOfWeights
double sumOfWeights() const
Alias.
Definition Analysis.hh:460

Rivet::Analysis::name
virtual std::string name() const
Get the name of the analysis.
Definition Analysis.hh:164

Rivet::Event
Representation of a HepMC event, and enabler of Projection caching.
Definition Event.hh:22

Rivet::FastJets
Find jets using jet algorithms via the FastJet package.
Definition FastJets.hh:30

Rivet::FinalState
Project out all final-state particles in an event. Probably the most important projection in Rivet!
Definition FinalState.hh:12

Rivet::JetFinder
Abstract base class for projections which can return a set of Jets.
Definition JetFinder.hh:41

Rivet::Jets
Specialised vector of Jet objects.
Definition Jet.hh:21

Rivet::LeptonFinder
Reconstruct leptons, generally including "dressing" with clustered photons.
Definition LeptonFinder.hh:29

Rivet::METFinder
Interface for projections that find missing transverse energy/momentum.
Definition METFinder.hh:11

Rivet::MissingMomentum
Calculate missing ,  etc. as complements to the total visible momentum.
Definition MissingMomentum.hh:22

Rivet::ParticleFinder
Base class for projections which return subsets of an event's particles.
Definition ParticleFinder.hh:11

Rivet::Particle
Particle representation, either from a HepMC::GenEvent or reconstructed.
Definition Particle.hh:45

Rivet::Particles
Specialised vector of Particle objects.
Definition Particle.hh:21

Rivet::ProjectionApplier::declare
const PROJ & declare(const PROJ &proj, const std::string &name) const
Register a contained projection (user-facing version)
Definition ProjectionApplier.hh:184

Rivet::ProjectionApplier::hasProjection
bool hasProjection(const std::string &name) const
Does this applier have a projection registered under the name name?
Definition ProjectionApplier.hh:55

Rivet::PromptFinalState
Find final state particles directly connected to the hard process.
Definition PromptFinalState.hh:25

Rivet::SimpleAnalysis
Simplified analysis API with predefined physics objects.
Definition SimpleAnalysis.hh:16

Rivet::SimpleAnalysis::photons
Particles photons(const Cut &cut, IDClass phoclass=IDClass::MEDIUM, bool include_nonprompt=false) const
Get the pT-ordered set of reconstructed prompt and isolated photons, with extra cuts.
Definition SimpleAnalysis.hh:251

Rivet::SimpleAnalysis::taus
const Particles & taus(IDClass tauclass=IDClass::MEDIUM, bool include_nonprompt=false) const
Get the pT-ordered set of reconstructed prompt (hadronic) taus.
Definition SimpleAnalysis.hh:257

Rivet::SimpleAnalysis::tracksProj
const ParticleFinder & tracksProj()
Direct access to the underlying projection.
Definition SimpleAnalysis.hh:429

Rivet::SimpleAnalysis::bjets
const Jets & bjets(const std::string &jetname="DEFAULT") const
Get a pT-ordered named set of reconstructed b-tagged jets.
Definition SimpleAnalysis.hh:309

Rivet::SimpleAnalysis::electronsProj
const ParticleFinder & electronsProj(IDClass eclass=IDClass::MEDIUM, bool include_nonprompt=false)
Direct access to the underlying projection.
Definition SimpleAnalysis.hh:413

Rivet::SimpleAnalysis::vmet
Vector3 vmet() const
Get the MET vector.
Definition SimpleAnalysis.hh:322

Rivet::SimpleAnalysis::photons
const Particles & photons(IDClass phoclass=IDClass::MEDIUM, bool include_nonprompt=false, double dRiso=0.4, double isofrac=0.1) const
Get the pT-ordered set of reconstructed prompt and isolated photons.
Definition SimpleAnalysis.hh:233

Rivet::SimpleAnalysis::setTauReco
void setTauReco(const ParticleEffFn &eff, const ParticleSmearFn &smear=PARTICLE_SMEAR_IDENTITY, IDClass idc=IDClass::MEDIUM)
Set the tau reco functions for a given ID class.
Definition SimpleAnalysis.hh:156

Rivet::SimpleAnalysis::electrons
Particles electrons(const Cut &cut, IDClass eclass=IDClass::MEDIUM, bool include_nonprompt=false) const
Get the pT-ordered set of reconstructed prompt electrons, with extra cuts.
Definition SimpleAnalysis.hh:213

Rivet::SimpleAnalysis::setPhotonReco
void setPhotonReco(const ParticleEffFn &eff, const ParticleSmearFn &smear=PARTICLE_SMEAR_IDENTITY, IDClass idc=IDClass::MEDIUM)
Set the photon reco functions for a given ID class.
Definition SimpleAnalysis.hh:151

Rivet::SimpleAnalysis::jets
const Jets & jets(const std::string &jetname="DEFAULT") const
Get a pT-ordered named set of reconstructed jets.
Definition SimpleAnalysis.hh:295

Rivet::SimpleAnalysis::muonsProj
const ParticleFinder & muonsProj(IDClass muclass=IDClass::MEDIUM, bool include_nonprompt=false)
Direct access to the underlying projection.
Definition SimpleAnalysis.hh:417

Rivet::SimpleAnalysis::metSignf
double metSignf() const
Get the MET significance.
Definition SimpleAnalysis.hh:337

Rivet::SimpleAnalysis::bjets
Jets bjets(const Cut &cut, const std::string &jetname="DEFAULT") const
Get a pT-ordered named set of reconstructed b-tagged jets, with extra cuts.
Definition SimpleAnalysis.hh:316

Rivet::SimpleAnalysis::photonsProj
const ParticleFinder & photonsProj(IDClass phoclass=IDClass::MEDIUM, bool include_nonprompt=false)
Direct access to the underlying projection.
Definition SimpleAnalysis.hh:425

Rivet::SimpleAnalysis::electrons
const Particles & electrons(IDClass eclass=IDClass::MEDIUM, bool include_nonprompt=false) const
Get the pT-ordered set of reconstructed prompt electrons.
Definition SimpleAnalysis.hh:205

Rivet::SimpleAnalysis::scaleToIntLumi
void scaleToIntLumi(T &ao, double intlumi)
Helper function to elide the xsec/sumW scalefactor.
Definition SimpleAnalysis.hh:402

Rivet::SimpleAnalysis::jetnames
const std::vector< std::string > jetnames() const
Get the set of jet-collection names (also usable for b-jets)
Definition SimpleAnalysis.hh:287

Rivet::SimpleAnalysis::jetsProj
const JetFinder & jetsProj(const std::string &jetname="DEFAULT")
Direct access to the underlying projection.
Definition SimpleAnalysis.hh:433

Rivet::SimpleAnalysis::jets
Jets jets(const Cut &cut, const std::string &jetname="DEFAULT") const
Get a pT-ordered named set of reconstructed jets, with extra cuts.
Definition SimpleAnalysis.hh:303

Rivet::SimpleAnalysis::metProj
const METFinder & metProj()
Direct access to the underlying projection.
Definition SimpleAnalysis.hh:437

Rivet::SimpleAnalysis::tausProj
const ParticleFinder & tausProj(IDClass tauclass=IDClass::MEDIUM, bool include_nonprompt=false)
Direct access to the underlying projection.
Definition SimpleAnalysis.hh:421

Rivet::SimpleAnalysis::set
double set() const
Get the SET scalar.
Definition SimpleAnalysis.hh:332

Rivet::SimpleAnalysis::setTrkReco
void setTrkReco(const ParticleEffFn &eff, const ParticleSmearFn &smear=PARTICLE_SMEAR_IDENTITY)
Set the track reco functions for a given jet name.
Definition SimpleAnalysis.hh:161

Rivet::SimpleAnalysis::IDClass
IDClass
Physics-object ID classes.
Definition SimpleAnalysis.hh:20

Rivet::SimpleAnalysis::taus
Particles taus(const Cut &cut, IDClass tauclass=IDClass::MEDIUM, bool include_nonprompt=false) const
Get the pT-ordered set of reconstructed prompt (hadronic) taus, with extra cuts.
Definition SimpleAnalysis.hh:265

Rivet::SimpleAnalysis::setElectronReco
void setElectronReco(const ParticleEffFn &eff, const ParticleSmearFn &smear=PARTICLE_SMEAR_IDENTITY, IDClass idc=IDClass::MEDIUM)
Set the electron reco functions for a given ID class.
Definition SimpleAnalysis.hh:141

Rivet::SimpleAnalysis::preAnalyze
void preAnalyze(const Event &event)
Reset per-event members, before the user analyze()
Definition SimpleAnalysis.hh:121

Rivet::SimpleAnalysis::tracks
Particles tracks(const Cut &cut) const
Definition SimpleAnalysis.hh:281

Rivet::SimpleAnalysis::~SimpleAnalysis
virtual ~SimpleAnalysis()
Destructor to support subclassing.
Definition SimpleAnalysis.hh:28

Rivet::SimpleAnalysis::setJetReco
void setJetReco(const JetSmearFn &smear, const JetEffFn &btageff, const std::string &jetname="DEFAULT")
Set the jet reco functions for a given jet name.
Definition SimpleAnalysis.hh:166

Rivet::SimpleAnalysis::muons
const Particles & muons(IDClass muclass=IDClass::MEDIUM, bool include_nonprompt=false) const
Get the pT-ordered set of reconstructed muons.
Definition SimpleAnalysis.hh:219

Rivet::SimpleAnalysis::doSimpleOverlapRemoval
void doSimpleOverlapRemoval(IDClass eclass=IDClass::MEDIUM, IDClass muclass=IDClass::MEDIUM, IDClass phoclass=IDClass::MEDIUM, bool include_nonprompt=false, const std::string &jetname="DEFAULT")
Perform a simple, in-place overlap removal between all physics objects.
Definition SimpleAnalysis.hh:364

Rivet::SimpleAnalysis::setMETReco
void setMETReco(const METSmearParamsFn &smearps, const METSmearFn &smear)
Set the MET reco functions.
Definition SimpleAnalysis.hh:175

Rivet::SimpleAnalysis::muons
Particles muons(const Cut &cut, IDClass muclass=IDClass::MEDIUM, bool include_nonprompt=false) const
Get the pT-ordered set of reconstructed muons, with extra cuts.
Definition SimpleAnalysis.hh:227

Rivet::SimpleAnalysis::tracks
const Particles tracks() const
Definition SimpleAnalysis.hh:274

Rivet::SimpleAnalysis::postInit
void postInit()
Definition SimpleAnalysis.hh:39

Rivet::SimpleAnalysis::SimpleAnalysis
SimpleAnalysis(const std::string &name)
Constructor, passing arg to base class and supporting subclassing.
Definition SimpleAnalysis.hh:23

Rivet::SimpleAnalysis::setMuonReco
void setMuonReco(const ParticleEffFn &eff, const ParticleSmearFn &smear=PARTICLE_SMEAR_IDENTITY, IDClass idc=IDClass::MEDIUM)
Set the muon reco functions for a given ID class.
Definition SimpleAnalysis.hh:146

Rivet::SimpleAnalysis::setMETReco
void setMETReco(const METSmearParamsFn &smearps)
Set the MET reco-params function.
Definition SimpleAnalysis.hh:171

Rivet::SimpleAnalysis::met
double met() const
Get the MET scalar.
Definition SimpleAnalysis.hh:327

Rivet::SmearedJets
Wrapper projection for smearing Jets with detector resolutions and efficiencies.
Definition SmearedJets.hh:19

Rivet::SmearedMET
Wrapper projection for smearing missing (transverse) energy/momentum with detector resolutions.
Definition SmearedMET.hh:15

Rivet::SmearedParticles
Wrapper projection for smearing Jets with detector resolutions and efficiencies.
Definition SmearedParticles.hh:14

Rivet::TauFinder
Convenience finder of unstable taus.
Definition TauFinder.hh:25

Rivet::Vector3
Three-dimensional specialisation of Vector.
Definition Vector3.hh:40

Rivet::Vector::mod
double mod() const
Calculate the modulus of a vector. .
Definition VectorN.hh:95

Rivet::select
Jets select(const Jets &jets, const Cut &c)
Filter a jet collection in-place to the subset that passes the supplied Cut.
Definition JetUtils.hh:157

Rivet::MET_SMEAR_IDENTITY
Vector3 MET_SMEAR_IDENTITY(const Vector3 &met, double)
Identity MET smearing just returns the input.
Definition MomentumSmearingFunctions.hh:177

Rivet::MET_SMEARPARAMS_IDENTITY
METSmearParams MET_SMEARPARAMS_IDENTITY(const Vector3 &met, double)
Identity resolution is 0 (perfect delta function, no offset)
Definition MomentumSmearingFunctions.hh:172

Rivet::METSmearFn
function< Vector3(const Vector3 &, double)> METSmearFn
Definition MomentumSmearingFunctions.hh:139

Rivet::METSmearParamsFn
function< METSmearParams(const Vector3 &, double)> METSmearParamsFn
Definition MomentumSmearingFunctions.hh:134

Rivet::PARTICLE_EFF_ONE
double PARTICLE_EFF_ONE(const Particle &)
Take a Particle and return 1.
Definition ParticleSmearingFunctions.hh:33

Rivet::ParticleSmearFn
function< Particle(const Particle &)> ParticleSmearFn
Typedef for Particle smearing functions/functors.
Definition ParticleSmearingFunctions.hh:19

Rivet::PARTICLE_SMEAR_IDENTITY
Particle PARTICLE_SMEAR_IDENTITY(const Particle &p)
Take a Particle and return it unmodified.
Definition ParticleSmearingFunctions.hh:50

Rivet::JET_BTAG_IDENTITY
double JET_BTAG_IDENTITY(const Jet &j)
Alias for JET_BTAG_PERFECT.
Definition JetSmearingFunctions.hh:58

Rivet::ParticleEffFn
function< double(const Particle &)> ParticleEffFn
Typedef for Particle efficiency functions/functors.
Definition ParticleSmearingFunctions.hh:22

Rivet::JET_SMEAR_IDENTITY
Jet JET_SMEAR_IDENTITY(const Jet &j)
Definition JetSmearingFunctions.hh:95

Rivet::JetSmearFn
function< Jet(const Jet &)> JetSmearFn
Typedef for Jet smearing functions/functors.
Definition JetSmearingFunctions.hh:20

Rivet::JetEffFn
function< double(const Jet &)> JetEffFn
Typedef for Jet efficiency functions/functors.
Definition JetSmearingFunctions.hh:23

Rivet
Definition MC_CENT_PPB_Projections.hh:10

Rivet::deltaR
double deltaR(double rap1, double phi1, double rap2, double phi2)
Definition MathUtils.hh:697

Rivet::DeltaRLess
(with respect to another 4-momentum, vec) less-than functor
Definition ParticleBaseUtils.hh:205

Rivet::HasBTag
B-tagging functor, with a tag selection cut as the stored state.
Definition JetUtils.hh:101

Rivet::JetScheme
Convenience container of params for simple jet definitions.
Definition JetFinder.hh:22

Rivet::JetScheme::alg
JetAlg alg
Params.
Definition JetFinder.hh:33