PhaseSpacePoint.hh

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <cstddef>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include "fastjet/PseudoJet.hh"
 
#include "HEJ/Config.hh"
#include "HEJ/Event.hh"
#include "HEJ/Particle.hh"
#include "HEJ/StatusCode.hh"
 
namespace HEJ {
  struct RNG;
 
  class PhaseSpacePoint{
  public:
    PhaseSpacePoint() = delete;
 
 
    PhaseSpacePoint(
        Event const & ev,
        PhaseSpacePointConfig conf,
        RNG & ran
    );
 
    double weight() const{
      return weight_;
    }
 
    std::array<Particle, 2> const & incoming() const{
      return incoming_;
    }
 
    std::vector<Particle> const & outgoing() const{
      return outgoing_;
    }
 
 
    std::unordered_map<std::size_t, std::vector<Particle>> const &  decays()
    const{
      return decays_;
    }
 
    StatusCode status() const{
        return status_;
    }
 
    static constexpr int NG_MAX = 1000;    
 
  private:
    friend Event::EventData to_EventData(PhaseSpacePoint psp);
    std::vector<fastjet::PseudoJet> cluster_jets(
        std::vector<fastjet::PseudoJet> const & partons
    ) const;
    bool pass_resummation_cuts(
        std::vector<fastjet::PseudoJet> const & jets
    ) const;
    bool pass_extremal_cuts(
        fastjet::PseudoJet const & ext_parton,
        fastjet::PseudoJet const & jet
    ) const;
    double estimate_emission_rapidity_range(Event const & event) const;
    double estimate_ng_mean(Event const & event) const;
    int sample_ng(Event const & event, RNG & ran);
    int sample_ng_jets(Event const & event, int ng, RNG & ran);
    double probability_in_jet(Event const & event) const;
    std::vector<fastjet::PseudoJet> gen_non_jet(
        int ng_non_jet, double ptmin, double ptmax, RNG & ran
    );
    void rescale_qqbar_rapidities(
      std::vector<fastjet::PseudoJet> & out_partons,
      std::vector<fastjet::PseudoJet> const & jets,
      double ymin1, double ymax2,
      int qqbar_backjet
    );
    void rescale_rapidities(
      std::vector<fastjet::PseudoJet> & partons,
      double ymin, double ymax
    );
    std::pair< std::vector<fastjet::PseudoJet>,
               optional<fastjet::PseudoJet> >
    reshuffle(
        Event const & ev,
        fastjet::PseudoJet const & q
    );
    bool jets_ok(
        std::vector<fastjet::PseudoJet> const & Born_jets,
        std::vector<fastjet::PseudoJet> const & partons
    ) const;
    void reconstruct_incoming(std::array<Particle, 2> const & Born_incoming);
    std::vector<fastjet::PseudoJet> split(
      std::vector<fastjet::PseudoJet> const & jets,
      int ng_jets, std::size_t qqbar_backjet, RNG & ran
    );
    std::vector<int> distribute_jet_partons(
        int ng_jets, std::vector<fastjet::PseudoJet> const & jets, RNG & ran
    );
    std::vector<fastjet::PseudoJet> split(
        std::vector<fastjet::PseudoJet> const & jets,
        std::vector<int> const & np_in_jet,
        std::size_t qqbar_backjet,
        RNG & ran
    );
    bool split_preserved_jets(
        std::vector<fastjet::PseudoJet> const & jets,
        std::vector<fastjet::PseudoJet> const & jet_partons
    ) const;
    template<class Particle>
    Particle const & most_backward_FKL(
        std::vector<Particle> const & partons
    ) const;
    template<class Particle>
    Particle const & most_forward_FKL(
        std::vector<Particle> const & partons
    ) const;
    template<class Particle>
    Particle & most_backward_FKL(std::vector<Particle> & partons) const;
    template<class Particle>
    Particle & most_forward_FKL(std::vector<Particle> & partons) const;
    bool extremal_ok(
        std::vector<fastjet::PseudoJet> const & partons
    ) const;
    void label_quarks(Event const & event);
    void label_qqbar(Event const & event);
    void boost_AWZH_boson_from(
        fastjet::PseudoJet const & boosted_boson, Event const & event
    );
 
    bool momentum_conserved() const;
 
    bool contains_idx(
        fastjet::PseudoJet const & jet, fastjet::PseudoJet const & parton
    ) const;
 
    bool unob_, unof_, qqbarb_, qqbarf_, qqbar_mid_;
 
    double weight_;
 
    PhaseSpacePointConfig param_;
 
    std::array<Particle, 2> incoming_;
    std::vector<Particle> outgoing_;
    std::unordered_map<std::size_t, std::vector<Particle>> decays_;
 
    StatusCode status_;
  };
 
  Event::EventData to_EventData(PhaseSpacePoint psp);
 
} // namespace HEJ