API Reference

class Generator

#include <generator.h>

Monte-Carlo event generator class.

This class has the high-level control over the generation of Monte-Carlo events. This includes all warm-up phases necessary for optimising the event generation (and unweighting), and the write-out of the events.

Public Functions

Generator(Settings&, const SM_parameters&)

~Generator()

void find_active_helicity_configurations()

void optimise_event_generation()

void setup_and_optimise_event_unweighting()

MC_result generate_batches()

inline const Event_handle &event_data() const

inline const BG_recursion &bg_recursion() const

inline Process &process_group()

inline Helicity_configurations &helicity_configurations()

std::vector<Pepper::Vec4> generate_momenta()

generate a phase-space point and return external momenta

std::vector<Pepper::Vec4> momenta()

return external momenta

double me2(const std::vector<Pepper::Vec4>&)

return |ME|^2 for the given set of external momenta

double me2(const std::vector<Pepper::Vec4>&, int fixed_external_current_idx, const Pepper::CVec4 &fixed_external_current)

return |ME|^2 for the given set of external momenta, with one external polarization vector fixed

double me2(const std::vector<Pepper::Random_number_sets> &included_random_number_sets, const std::vector<double> &random_numbers)

return |ME|^2 for the given random numbers, to be used as specified in the random number sets

void precalculate_all_external_states(const std::vector<Pepper::Vec4>&)

precalculates all external currents (for a physical process group, the resulting currents will correspond to the last flavour process group only, if process summing is enabled, and to a random flavour process group otherwise, hence this function probably makes sense only when a single partonic channel is used)

Pepper::CVec4 external_state(int ptcl_idx, Helicity hel)

inline Pepper::Helicity_treatment helicity_treatment()

return helicity treatment (i.e. whether we use sampling, summing, …)

void fill_momenta_and_apply_cuts(Event_handle&)

Private Functions

void initialise_event_output(const Settings&, const SM_parameters&)

void print_integration_info(double elapsed_s) const

double rescaled_n_nonzero_min(double n_nonzero_min) const

void evaluate_points(Event_handle&)

void perform_colour_sum(Event_handle&, Helicity_configurations&)

double prefactor() const

void fill_random_numbers(Event_handle&)

void report_run_statistics(const MC_batch_stepper&, const Progress::Event_generation_observer&, const MC_result&) const

void reset_timing() const

Private Members

MC_targets mc_targets

Process proc

Event_reader event_reader

Rng rng

Cuts cuts

Chili_outlier_filter chili_outlier_filter

Helicity_configurations hel_conf

bool should_precalculate_all_external_states

Event_handle evt

BG_recursion bg

bool me2_only

std::unique_ptr<Event_writer> event_writer

std::unique_ptr<Scale_setter> scale_setter

Pdf_and_alpha_s pdf_and_alpha_s

Phase_space_settings ps_settings

mutable double write_events_duration = {0.0}

mutable double evaluate_points_duration = {0.0}

mutable double recursion_duration = {0.0}

mutable double phase_space_duration = {0.0}

mutable double fill_momenta_and_weights_duration = {0.0}

mutable double phase_space_weights_duration = {0.0}

mutable double me2_update_duration = {0.0}

bool diagnostic_output_enabled

namespace Pepper

file generator.h

#include “pepper/config.h”

#include “pepper/process.h”

#include “chili_outlier_filter.h”

#include “cuts.h”

#include “event_handle.h”

#include “event_reader.h”

#include “event_writer.h”

#include “helicity_configurations.h”

#include “monte_carlo.h”

#include “pdf_and_alpha_s.h”

#include “process.h”

#include “progress.h”

#include “recursion.h”

#include “rng.h”

#include “scale_setter.h”

#include <memory>

Include dependency graph for generator.h:

dir /builds/spice-mc/pepper/src