Jet.hh

// -*- C++ -*-
#ifndef RIVET_Jet_HH
#define RIVET_Jet_HH
 
#include "Rivet/Jet.fhh"
#include "Rivet/Particle.hh"
#include "Rivet/Config/RivetCommon.hh"
#include "Rivet/Math/LorentzTrans.hh"
#include "Rivet/Tools/Cuts.hh"
#include "Rivet/Tools/RivetFastJet.hh"
#include "Rivet/Tools/Utils.hh"
#include <numeric>
 
namespace Rivet {
 

  class Jets : public std::vector<Jet> {
  public:
 
    using base = std::vector<Jet>; //< using-declarations don't like template syntax
    using base::base;              //< import base-class constructors
    Jets();
    Jets(const std::vector<Jet>& vjs);
    FourMomenta moms() const;
    PseudoJets pseudojets() const;
    operator FourMomenta() const {
      return moms();
    }
    operator PseudoJets() const {
      return pseudojets();
    }
    Jets& operator+=(const Jet& j);
    Jets& operator+=(const Jets& js);
  };
 
  Jets operator+(const Jets& a, const Jets& b);
 

 

  class Jet : public ParticleBase {
  public:


    Jet(const fastjet::PseudoJet& pj,
        const Particles& particles = Particles(),
        const Particles& tags = Particles()) {
      setState(pj, particles, tags);
    }

    Jet(const FourMomentum& pjet,
        const Particles& particles = Particles(),
        const Particles& tags = Particles()) {
      setState(pjet, particles, tags);
    }

    Jet() {
      clear();
    }

 


    size_t size() const {
      return _particles.size();
    }

    Particles& particles() {
      return _particles;
    }

    const Particles& particles() const {
      return _particles;
    }

    const Particles particles(const Cut& c) const {
      return select(_particles, c);
    }

    const Particles particles(const ParticleSelector& s) const {
      return select(_particles, s);
    }

    Particles& constituents() {
      return particles();
    }

    const Particles& constituents() const {
      return particles();
    }

    const Particles constituents(const Cut& c) const {
      return particles(c);
    }

    const Particles constituents(const ParticleSelector& s) const {
      return particles(s);
    }

    bool containsParticle(const Particle& particle) const;
    bool containsPID(const Particle& particle) const {
      return containsParticle(particle);
    }

    bool containsParticleId(PdgId pid) const;
    bool containsPID(PdgId pid) const {
      return containsParticleId(pid);
    }

    bool containsParticleId(const vector<PdgId>& pids) const;
    bool containsPID(const vector<PdgId>& pids) const {
      return containsParticleId(pids);
    }

 


    Particles& tags() {
      return _tags;
    }

    const Particles& tags() const {
      return _tags;
    }

    Particles tags(const ParticleSelector& f, double dRmax = -1) const {
      const Particles filttags = select(tags(), f);
      // Return, via dR filter if requested
      return dRmax < 0 ? filttags : select(filttags, deltaRLess(this->mom(), dRmax));
    }

    Particles tags(const Cut& c, double dRmax = -1) const;
 

    Particles bTags(const Cut& c = Cuts::open(), double dRmax = -1) const;

    Particles bTags(const ParticleSelector& f, double dRmax = -1) const {
      return select(bTags(), f);
    }

    bool bTagged(const Cut& c = Cuts::open(), double dRmax = -1) const {
      return !bTags(c).empty();
    }

    bool bTagged(const ParticleSelector& f, double dRmax = -1) const {
      return !bTags(f).empty();
    }
 

    Particles cTags(const Cut& c = Cuts::open(), double dRmax = -1) const;

    Particles cTags(const ParticleSelector& f, double dRmax = -1) const {
      return select(cTags(), f);
    }

    bool cTagged(const Cut& c = Cuts::open(), double dRmax = -1) const {
      return !cTags(c).empty();
    }

    bool cTagged(const ParticleSelector& f, double dRmax = -1) const {
      return !cTags(f).empty();
    }
 

    Particles tauTags(const Cut& c = Cuts::open(), double dRmax = -1) const;

    Particles tauTags(const ParticleSelector& f, double dRmax = -1) const {
      return select(tauTags(), f);
    }

    bool tauTagged(const Cut& c = Cuts::open(), double dRmax = -1) const {
      return !tauTags(c).empty();
    }

    bool tauTagged(const ParticleSelector& f, double dRmax = -1) const {
      return !tauTags(f).empty();
    }
 


 


    const FourMomentum& momentum() const {
      return _momentum;
    }

    Jet& transformBy(const LorentzTransform& lt);

    double totalEnergy() const {
      return momentum().E();
    }

    double neutralEnergy() const;

    double hadronicEnergy() const;

 


    const fastjet::PseudoJet& pseudojet() const {
      return _pseudojet;
    }

    operator const fastjet::PseudoJet&() const {
      return pseudojet();
    }

 


    Jet& setState(const fastjet::PseudoJet& pj,
                  const Particles& particles = Particles(),
                  const Particles& tags = Particles());

    Jet& setState(const FourMomentum& mom, const Particles& particles, const Particles& tags = Particles());

    Jet& setParticles(const Particles& particles);
    Jet& setConstituents(const Particles& particles) {
      return setParticles(particles);
    }

    Jet& clear();

 
 
  private:

    fastjet::PseudoJet _pseudojet;

    Particles _particles;

    Particles _tags;

    mutable FourMomentum _momentum;
 
    // /// Provide but hide the equality operators, to avoid implicit comparison via fastjet::PseudoJet
    // bool operator == (const Jet&) const;
    // bool operator != (const Jet&) const;
  };
 


  std::ostream& operator<<(std::ostream& os, const Jet& j);

 
 
}
 
 
#include "Rivet/Tools/JetUtils.hh"
 
#endif