Event.hh

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <cstddef>
#include <iosfwd>
#include <iterator>
#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 {
  struct RNG;
  struct UnclusteredEvent;
 
  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;
    [[deprecated("UnclusteredEvent got superseded by EventData")]]
    Event(
      UnclusteredEvent const & ev,
      fastjet::JetDefinition const & jet_def, double min_jet_pt
    );
 
 
    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,
      double min_pt = 0.
    ) 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
 
  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();
 
    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);
 
  double shat(Event const & ev);
 
  LHEF::HEPEUP to_HEPEUP(Event const & event, LHEF::HEPRUP * /*heprup*/);
 
  // put deprecated warning at the end, so don't get the warning inside Event.hh,
  // additionally doxygen can not identify [[deprecated]] correctly
  struct [[deprecated("UnclusteredEvent will be replaced by EventData")]]
    UnclusteredEvent;
  struct UnclusteredEvent{
    UnclusteredEvent() = default;
    UnclusteredEvent(LHEF::HEPEUP const & hepeup);
 
    std::array<Particle, 2> incoming;          
    std::vector<Particle> outgoing;            
    std::unordered_map<std::size_t, std::vector<Particle>> decays;
    EventParameters central;
    std::vector<EventParameters> variations;    
  };
 
} // namespace HEJ