Event.hh

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <cstddef>
#include <iosfwd>
#include <iterator>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include "boost/iterator/filter_iterator.hpp"
 
#include "fastjet/ClusterSequence.hh"
#include "fastjet/PseudoJet.hh"
 
#include "HEJ/Constants.hh"
#include "HEJ/Parameters.hh"
#include "HEJ/Particle.hh"
#include "HEJ/event_types.hh"
 
namespace LHEF {
  class HEPEUP;
  class HEPRUP;
}
 
namespace fastjet {
  class JetDefinition;
}
 
namespace HEJ {
  class EWConstants;
  struct RNG;
 
  size_t implemented_types(std::vector<Particle> const & bosons);
 
  class Event {
  public:
    class EventData;
 
    using ConstPartonIterator = boost::filter_iterator<
      bool (*)(Particle const &),
      std::vector<Particle>::const_iterator
      >;
    using ConstReversePartonIterator = std::reverse_iterator<
                                                ConstPartonIterator>;
    Event() = delete;
 
 
    std::array<Particle, 2> const &  incoming() const{
      return incoming_;
    }
    std::vector<Particle> const &  outgoing() const{
      return outgoing_;
    }
    ConstPartonIterator begin_partons() const;
    ConstPartonIterator cbegin_partons() const;
 
    ConstPartonIterator end_partons() const;
    ConstPartonIterator cend_partons() const;
 
    ConstReversePartonIterator rbegin_partons() const;
    ConstReversePartonIterator crbegin_partons() const;
    ConstReversePartonIterator rend_partons() const;
    ConstReversePartonIterator crend_partons() const;
 
 
    std::unordered_map<std::size_t, std::vector<Particle>> const & decays()
    const {
      return decays_;
    }
    std::vector<fastjet::PseudoJet> const & jets() const{
      return jets_;
    }
 
 
    Parameters<EventParameters> const & parameters() const{
      return parameters_;
    }
    Parameters<EventParameters> & parameters(){
      return parameters_;
    }
 
    EventParameters const & central() const{
      return parameters_.central;
    }
    EventParameters & central(){
      return parameters_.central;
    }
 
    std::vector<EventParameters> const & variations() const{
      return parameters_.variations;
    }
    std::vector<EventParameters> & variations(){
      return parameters_.variations;
    }
 
 
    EventParameters const & variations(std::size_t i) const{
      return parameters_.variations.at(i);
    }
 
    EventParameters & variations(std::size_t i){
      return parameters_.variations.at(i);
    }
 
 
    std::vector<int> particle_jet_indices(
        std::vector<fastjet::PseudoJet> const & jets
    ) const {
      return cs_.particle_jet_indices(jets);
    }
    std::vector<int> particle_jet_indices() const {
      return particle_jet_indices(jets());
    }
 
    fastjet::JetDefinition const & jet_def() const{
      return cs_.jet_def();
    }
 
    double min_jet_pt() const{
      return min_jet_pt_;
    }
 
    event_type::EventType type() const{
      return type_;
    }
 
 
    bool generate_colours(RNG & /*ran*/);
 
 
    bool is_leading_colour() const;
 
    bool valid_hej_state(double soft_pt_regulator = DEFAULT_SOFT_PT_REGULATOR) const;
 
 
    bool valid_incoming() const;
 
  private:
 
    Event(
      std::array<Particle, 2> && incoming,
      std::vector<Particle> && outgoing,
      std::unordered_map<std::size_t, std::vector<Particle>> && decays,
      Parameters<EventParameters> && parameters,
      fastjet::JetDefinition const & jet_def,
      double min_jet_pt
    );
 
    using PartonIterator = boost::filter_iterator<
      bool (*)(Particle const &),
      std::vector<Particle>::iterator
      >;
    using ReversePartonIterator = std::reverse_iterator<PartonIterator>;
 
    PartonIterator begin_partons();
    PartonIterator end_partons();
 
    ReversePartonIterator rbegin_partons();
    ReversePartonIterator rend_partons();
 
    std::array<Particle, 2> incoming_;
    std::vector<Particle> outgoing_;
    std::unordered_map<std::size_t, std::vector<Particle>> decays_;
    std::vector<fastjet::PseudoJet> jets_;
    Parameters<EventParameters> parameters_;
    fastjet::ClusterSequence cs_;
    double min_jet_pt_;
    event_type::EventType type_;
  }; // end class Event
 
 
  inline
  bool is_backward_g_to_h(Event const & ev) {
    return ev.outgoing().front().type == pid::higgs
      && ev.incoming().front().type == pid::gluon;
  }
 
  inline
  bool is_forward_g_to_h(Event const & ev) {
    return ev.outgoing().back().type == pid::higgs
      && ev.incoming().back().type == pid::gluon;
  }
 
  class Event::EventData {
  public:
    EventData() = default;
    EventData(LHEF::HEPEUP const & hepeup);
    EventData(
      std::array<Particle, 2> incoming,
      std::vector<Particle> outgoing,
      std::unordered_map<std::size_t, std::vector<Particle>> decays,
      Parameters<EventParameters> parameters
    ):
      incoming(std::move(incoming)), outgoing(std::move(outgoing)),
      decays(std::move(decays)), parameters(std::move(parameters))
    {}
 
 
    Event cluster(
      fastjet::JetDefinition const & jet_def, double min_jet_pt);
 
    Event operator()(
      fastjet::JetDefinition const & jet_def, double const min_jet_pt){
      return cluster(jet_def, min_jet_pt);
    }
 
    void sort();
 
 
    void reconstruct_intermediate(EWConstants const & /*ew_parameters*/);
 
 
    void repair_momenta(double tolerance);
 
    std::array<Particle, 2> incoming;
    std::vector<Particle> outgoing;
    std::unordered_map<std::size_t, std::vector<Particle>> decays;
    Parameters<EventParameters> parameters;
  }; // end class EventData
 
  std::ostream& operator<<(std::ostream & os, Event const & ev);
 
  std::string to_string(Event const & ev);
 
  double shat(Event const & ev);
 
  static constexpr double TOL = 1e-6;
 
  LHEF::HEPEUP to_HEPEUP(Event const & event, LHEF::HEPRUP * /*heprup*/);
 
} // namespace HEJ