Event.hh

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "HEJ/event_types.hh"
#include "HEJ/Particle.hh"
 
#include "fastjet/ClusterSequence.hh"
 
namespace LHEF{
  class HEPEUP;
  class HEPRUP;
}
 
namespace fastjet{
  class JetDefinition;
}
 
namespace HEJ{
 
 
  struct ParameterDescription;
 
  struct EventParameters{
    double mur;              
    double muf;              
    double weight;           
    std::shared_ptr<ParameterDescription> description = nullptr;
  };
 
  struct ParameterDescription {
    std::string scale_name;
    double mur_factor;
    double muf_factor;
 
    ParameterDescription() = default;
    ParameterDescription(
        std::string scale_name, double mur_factor, double muf_factor
    ):
      scale_name{scale_name}, mur_factor{mur_factor}, muf_factor{muf_factor}
    {};
  };
 
  struct UnclusteredEvent{
    UnclusteredEvent() = default;
    UnclusteredEvent(LHEF::HEPEUP const & hepeup);
 
    std::array<Particle, 2> incoming;          
    std::vector<Particle> outgoing;            
    std::unordered_map<size_t, std::vector<Particle>> decays;
    EventParameters central;
    std::vector<EventParameters> variations;    
  };
 
  class Event{
  public:
    Event() = default;
    Event(
        UnclusteredEvent ev,
        fastjet::JetDefinition const & jet_def, double min_jet_pt
    );
 
    std::vector<fastjet::PseudoJet> jets() const;
 
    UnclusteredEvent const & unclustered() const {
      return ev_;
    }
 
    EventParameters const & central() const{
      return ev_.central;
    }
 
    EventParameters & central(){
      return ev_.central;
    }
 
    std::array<Particle, 2> const &  incoming() const{
      return ev_.incoming;
    }
 
    std::vector<Particle> const &  outgoing() const{
      return ev_.outgoing;
    }
 
 
    std::unordered_map<size_t, std::vector<Particle>> const &  decays() const{
      return ev_.decays;
    }
 
    std::vector<EventParameters> const & variations() const{
      return ev_.variations;
    }
 
    std::vector<EventParameters> & variations(){
      return ev_.variations;
    }
 
 
    EventParameters const & variations(size_t i) const{
      return ev_.variations[i];
    }
 
 
    EventParameters & variations(size_t i){
      return ev_.variations[i];
    }
 
 
    std::vector<int> particle_jet_indices(
        std::vector<fastjet::PseudoJet> const & jets
    ) const{
      return cs_.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_;
    }
 
  private:
    UnclusteredEvent ev_;
    fastjet::ClusterSequence cs_;
    double min_jet_pt_;
    event_type::EventType type_;
  };
 
  double shat(Event const & ev);
 
  LHEF::HEPEUP to_HEPEUP(Event const & event, LHEF::HEPRUP *);
 
}