utility.hh

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <memory>
#include <string>
 
#include "boost/core/demangle.hpp"
 
#include "fastjet/PseudoJet.hh"
 
namespace HEJ {
 
  inline
  std::string join(
      std::string const & /* delim */
  ){
    return "";
  }
 
  inline
  std::string join(
      std::string const & /* delim */, std::string const & str
  ){
    return str;
  }
 
 
  template<typename... Strings>
  std::string join(
      std::string const & delim,
      std::string const & first, std::string const & second,
      Strings&&... rest
  ){
    return join(delim, first + delim + second, std::forward<Strings>(rest)...);
  }
 
  template<typename T>
  std::string type_string(T&& /*unused*/){
    return boost::core::demangle(typeid(T).name());
  }
 
  template<typename... T>
  constexpr void ignore(T&&... /*unused*/) {}
 
  inline
  constexpr bool nearby_ep(double a, double b, double ep){
    assert(ep >= 0);
    return std::abs(a-b) < ep;
  }
 
  inline
  bool nearby_ep(
      fastjet::PseudoJet const & pa, fastjet::PseudoJet const & pb,
      double ep
  ){
    assert(ep >= 0);
    for(size_t i = 0; i < 4; ++i){
      if(!nearby_ep(pa[i], pb[i], ep)) return false;
    }
    return true;
  }
 
  inline
  bool nearby(
      fastjet::PseudoJet const & pa, fastjet::PseudoJet const & pb,
      double const norm = 1.
  ){
    return nearby_ep(pa, pb, 1e-7*norm);
  }
 
  namespace detail {
    template<typename T, std::size_t N, std::size_t... Ns>
    struct ArrayTag{
      using type = typename ArrayTag<std::array<T, N>, Ns...>::type;
    };
    template<typename T, std::size_t N>
    struct ArrayTag<T, N> {
      using type = std::array<T, N>;
    };
  }
  // helper for multidimensional std::array, for example
  // MultiArray<T, N1, N2> = std::array<std::array<T, N1>, N2>
  template<typename T, std::size_t N, std::size_t... Ns>
  using MultiArray = typename detail::ArrayTag<T, N, Ns...>::type;
 
  template <class Event>
  bool momentum_conserved(Event const &ev, const double tolerance = 1e-7) {
    fastjet::PseudoJet diff;
    for (auto const &in : ev.incoming()) diff += in.p;
    const double norm = diff.E();
    for (auto const &out : ev.outgoing()) diff -= out.p;
    return nearby_ep(diff, fastjet::PseudoJet{}, tolerance*norm);
  }
 
} // namespace HEJ