Particle.hh

Go to the documentation of this file.

 
#pragma once
 
#include <optional>
#include <utility>
#include <vector>
 
#include "boost/rational.hpp"
#include "fastjet/PseudoJet.hh"
 
#include "HEJ/PDG_codes.hh"
 
namespace HEJ {
 
  using Colour = std::pair<int,int>;
 
  struct Particle {
    ParticleID type = pid::unspecified;
    fastjet::PseudoJet p;
    std::optional<Colour> colour;
 
    double rapidity() const{
      return p.rapidity();
    }
    double perp() const{
      return p.perp();
    }
    double pt() const{
      return perp();
    }
    double px() const{
      return p.px();
    }
    double py() const{
      return p.py();
    }
    double pz() const{
      return p.pz();
    }
    double E() const{
      return p.E();
    }
    double m() const{
      return p.m();
    }
  };
 
 
  struct rapidity_less{
    template<class FourVector>
    bool operator()(FourVector const & p1, FourVector const & p2){
      return p1.rapidity() < p2.rapidity();
    }
  };
 
 
  struct pz_less{
    template<class FourVector>
    bool operator()(FourVector const & p1, FourVector const & p2){
      return p1.pz() < p2.pz();
    }
  };
 
  inline
  std::vector<fastjet::PseudoJet> to_PseudoJet(
      std::vector<Particle> const & v
  ){
    std::vector<fastjet::PseudoJet> result;
    result.reserve(v.size());
    for(auto && sp: v) result.emplace_back(sp.p);
    return result;
  }
 
 
  struct type_less{
    template<class Particle>
    bool operator()(Particle const & p1, Particle const & p2){
      return p1.type < p2.type;
    }
  };
 
  inline
  constexpr bool is_antiparticle(Particle const & p){
    return is_antiparticle(p.type);
  }
 
  inline
  constexpr bool is_parton(Particle const & p){
    return is_parton(p.type);
  }
 
  inline
  constexpr bool is_quark(Particle const & p){
    return is_quark(p.type);
  }
 
  inline
  constexpr bool is_antiquark(Particle const & p){
    return is_antiquark(p.type);
  }
 
  inline
  constexpr bool is_anyquark(Particle const & p){
    return is_anyquark(p.type);
  }
 
  inline
  constexpr bool is_lepton(Particle const & p){
    return is_lepton(p.type);
  }
 
  inline
  constexpr bool is_antilepton(Particle const & p){
    return is_antilepton(p.type);
  }
 
  inline
  constexpr bool is_anylepton(Particle const & p){
    return is_anylepton(p.type);
  }
 
  inline
  constexpr bool is_neutrino(Particle const & p){
    return is_neutrino(p.type);
  }
 
  inline
  constexpr bool is_antineutrino(Particle const & p){
    return is_antineutrino(p.type);
  }
 
  inline
  constexpr bool is_anyneutrino(Particle const & p){
    return is_anyneutrino(p.type);
  }
 
  inline
  constexpr bool is_massless(Particle const & p){
    return is_massless(p.type);
  }
 
  inline
  constexpr bool is_massive(Particle const & p){
    return is_massive(p.type);
  }
 
  inline
  constexpr bool is_charged_lepton(Particle const & p){
    return is_charged_lepton(p.type);
  }
 
  inline
  constexpr bool is_charged_antilepton(Particle const & p){
    return is_charged_antilepton(p.type);
  }
 
  inline
  constexpr bool is_charged_anylepton(Particle const & p){
    return is_charged_anylepton(p.type);
  }
 
  inline
  constexpr bool is_AWZ_boson(Particle const & particle){
    return is_AWZ_boson(particle.type);
  }
 
  inline
  constexpr bool is_AWZH_boson(Particle const & particle){
    return is_AWZH_boson(particle.type);
  }
 
  inline
  std::vector<Particle> filter_partons(
      std::vector<Particle> const & v
  ){
    std::vector<Particle> result;
    result.reserve(v.size());
    std::copy_if(
        begin(v), end(v), std::back_inserter(result),
        [](Particle const & p){ return is_parton(p); }
    );
    return result;
  }
 
  inline
  std::vector<Particle> filter_AWZH_bosons(
      std::vector<Particle> const & v
  ){
    std::vector<Particle> result;
    std::copy_if(
        begin(v), end(v), std::back_inserter(result),
        [](Particle const & p){ return is_AWZH_boson(p); }
    );
    return result;
  }
 
  boost::rational<int> charge(Particle const & p);
 
} // namespace HEJ