C++ API

struct AlphaSGrid

Public Functions

AlphaSGrid(const std::string &file)

std::size_t q_count() const

void initialize_coefficients(Tensor tensor) const

void initialize_logq2(Tensor tensor) const

std::vector<std::size_t> coefficients_shape(bool batch_dim = false) const

std::vector<std::size_t> logq2_shape(bool batch_dim = false) const

void initialize_globals(ContextPtr context, const std::string &prefix = "") const

Public Members

std::vector<double> q

std::vector<double> logq2

std::vector<double> values

std::vector<std::size_t> region_sizes

class BatchCatInstruction : public madevent::Instruction

Public Functions

inline BatchCatInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

class BatchGatherInstruction : public madevent::Instruction

Public Functions

inline BatchGatherInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

class BatchScatterInstruction : public madevent::Instruction

Public Functions

inline BatchScatterInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

class BatchSize

Public Types

using Named = std::string

using Unnamed = std::shared_ptr<UnnamedBody>

using One = std::monostate

using Compound = std::unordered_map<std::variant<Named, Unnamed, One>, int>

Public Functions

inline BatchSize(const std::string &name)

inline BatchSize(One value)

inline BatchSize()

inline BatchSize operator+(const BatchSize &other) const

inline BatchSize operator-(const BatchSize &other) const

inline bool operator==(const BatchSize &other) const

inline bool operator!=(const BatchSize &other) const

Public Static Attributes

static const BatchSize zero

static const BatchSize one

Private Functions

inline BatchSize(Compound value)

inline BatchSize(Unnamed value)

BatchSize add(const BatchSize &other, int factor) const

Private Members

std::variant<Named, Unnamed, One, Compound> value

Friends

friend std::ostream &operator<<(std::ostream &out, const BatchSize &batch_size)

friend void to_json(nlohmann::json &j, const BatchSize &batch_size)

friend void from_json(const nlohmann::json &j, BatchSize &batch_size)

class BatchSizeInstruction : public madevent::Instruction

Public Functions

inline BatchSizeInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

class BatchSplitInstruction : public madevent::Instruction

Public Functions

inline BatchSplitInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

class CatInstruction : public madevent::Instruction

Public Functions

inline CatInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

struct ChannelArgs

Public Members

Value r

Value batch_size

bool has_permutations

bool has_multi_flavor

bool has_mirror

bool has_pdf_prior

Value max_weight

struct ChannelResult

Public Functions

inline Value &r()

inline Value &latent()

inline Value &momenta()

inline Value &momenta_mirror()

inline Value &momenta_acc()

inline Value &x1()

inline Value &x1_acc()

inline Value &x2()

inline Value &x2_acc()

inline Value &pdf_prior()

inline Value &chan_index()

inline Value &chan_index_in_group()

inline Value &flavor_id()

inline Value &mirror_id()

inline Value &indices_acc()

inline Value &weight_before_cuts()

inline Value &weight_after_cuts()

inline Value &adaptive_prob()

inline Value &pdf1_cache()

inline Value &pdf2_cache()

inline Value &scale_cache()

Public Members

std::array<Value, 21> values

struct ChannelState

Public Members

std::size_t index

RuntimePtr runtime

EventFile event_file

EventFile weight_file

std::optional<VegasGridOptimizer> vegas_optimizer

RuntimePtr vegas_histogram

std::optional<DiscreteOptimizer> discrete_optimizer

RuntimePtr discrete_histogram

RuntimePtr observable_histograms

std::size_t batch_size

std::string name

std::size_t subprocess_index

RunningIntegral cross_section

bool needs_optimization = true

double max_weight = 0.

double eff_count = 0.

double integral_fraction = 1.

std::size_t total_sample_count = 0

std::size_t total_sample_count_opt = 0

std::size_t total_sample_count_after_cuts = 0

std::size_t total_sample_count_after_cuts_opt = 0

std::size_t iterations = 0

std::size_t iters_without_improvement = 0

double best_rsd = std::numeric_limits<double>::max()

std::vector<double> large_weights

std::size_t job_count = 0

nested_vector2<std::pair<double, double>> histograms

class ChannelWeightNetwork : public madevent::FunctionGenerator

Public Functions

ChannelWeightNetwork(std::size_t channel_count, std::size_t particle_count, std::size_t hidden_dim = 32, std::size_t layers = 3, MLP::Activation activation = MLP::leaky_relu, const std::string &prefix = "")

inline const MLP &mlp() const

inline const MomentumPreprocessing &preprocessing() const

void initialize_globals(ContextPtr context) const

inline const std::string &mask_name() const

Private Functions

virtual ValueVec build_function_impl(FunctionBuilder &fb, const ValueVec &args) const override

Private Members

MomentumPreprocessing _preprocessing

MLP _mlp

std::size_t _channel_count

std::string _mask_name

class ChiliMapping : public madevent::Mapping

Public Functions

ChiliMapping(std::size_t _n_particles, const std::vector<double> &_y_max, const std::vector<double> &_pt_min)

inline std::size_t random_dim() const

Private Functions

virtual Result build_forward_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions) const override

virtual Result build_inverse_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions) const override

Private Members

std::size_t n_particles

std::vector<double> y_max

std::vector<double> pt_min

struct CombineChannelData

Public Members

std::size_t cum_count

EventBuffer event_buffer

EventBuffer weight_buffer

std::size_t buffer_index

struct Config

Public Members

std::size_t target_count = 10000

double vegas_damping = 0.2

double max_overweight_truncation = 0.01

std::size_t freeze_max_weight_after = 10000

std::size_t start_batch_size = 1000

std::size_t max_batch_size = 64000

std::size_t survey_min_iters = 3

std::size_t survey_max_iters = 4

double survey_target_precision = 0.1

std::size_t optimization_patience = 3

double optimization_threshold = 0.99

std::size_t batch_size = 1000

Verbosity verbosity = silent

bool write_live_data = false

class Context

Public Functions

inline Context()

Contains global variables and matrix elements

inline Context(DevicePtr device)

Context(Context&&) = default

Context &operator=(Context&&) = default

Context(const Context&) = delete

Context &operator=(const Context&) = delete

const MatrixElementApi &load_matrix_element(const std::string &file, const std::string &param_card)

Tensor define_global(const std::string &name, DataType dtype, const SizeVec &shape, bool requires_grad = false)

Tensor global(const std::string &name)

bool global_requires_grad(const std::string &name)

bool global_exists(const std::string &name)

std::vector<std::string> global_names() const

void delete_global(const std::string &name)

const MatrixElementApi &matrix_element(std::size_t index) const

void save(const std::string &file) const

void load(const std::string &file)

inline DevicePtr device()

Private Members

DevicePtr _device

std::unordered_map<std::string, std::tuple<Tensor, bool>> _globals

std::vector<MatrixElementApi> _matrix_elements

std::vector<std::string> _param_card_paths

Private Static Attributes

static ThreadPool &thread_pool_ref = default_thread_pool()

struct CouplingBlock

Public Members

MLP subnet1

MLP subnet2

std::vector<me_int_t> indices1

std::vector<me_int_t> indices2

struct CutItem

Public Members

Observable observable

double min = -std::numeric_limits<double>::infinity()

double max = std::numeric_limits<double>::infinity()

CutMode mode = CutMode::all

class Cuts : public madevent::FunctionGenerator

Public Types

enum CutMode

Values:

enumerator any

enumerator all

Public Functions

Cuts(const std::vector<CutItem> &cut_data)

Cuts(std::size_t particle_count)

double sqrt_s_min() const

std::vector<double> eta_max() const

std::vector<double> pt_min() const

Private Functions

virtual ValueVec build_function_impl(FunctionBuilder &fb, const ValueVec &args) const override

Private Members

std::vector<CutItem> _cut_data

struct DataLayout

Public Members

std::span<const FieldLayout> event_fields

std::span<const FieldLayout> particle_fields

std::size_t event_size

std::size_t particle_size

Public Static Functions

template<typename E, typename P>
static inline DataLayout of()

struct Decay

Public Members

std::size_t index

std::size_t parent_index

std::vector<std::size_t> child_indices

double mass

double width

double e_min

double e_max

int pdg_id

bool on_shell

class Device

Public Functions

virtual ~Device() = default

virtual void *allocate(std::size_t size) const = 0

virtual void free(void *ptr) const = 0

virtual void memcpy(void *to, void *from, std::size_t size) const = 0

virtual void tensor_copy(const Tensor &source, Tensor &target) const = 0

virtual void tensor_zero(Tensor &tensor) const = 0

virtual void tensor_add(const Tensor &source, Tensor &target) const = 0

virtual void tensor_cpu(const Tensor &source, Tensor &target) const = 0

virtual const Device *device_ptr() const = 0

inline virtual void sync_barrier() const

virtual DeviceType device_type() const = 0

class Diagram

Public Types

enum LineType

Values:

enumerator incoming

enumerator outgoing

enumerator propagator

using Vertex = std::vector<LineRef>

Public Functions

Diagram(const std::vector<double> &incoming_masses, const std::vector<double> &outgoing_masses, const std::vector<Propagator> &propagators, const std::vector<Vertex> &vertices)

inline const std::vector<double> &incoming_masses() const

inline const std::vector<double> &outgoing_masses() const

inline const std::vector<Propagator> &propagators() const

inline const std::vector<Vertex> &vertices() const

inline const std::array<int, 2> &incoming_vertices() const

inline const std::vector<int> &outgoing_vertices() const

inline const std::vector<std::vector<std::size_t>> &propagator_vertices() const

Private Members

std::vector<double> _incoming_masses

std::vector<double> _outgoing_masses

std::vector<Propagator> _propagators

std::vector<Vertex> _vertices

std::array<int, 2> _incoming_vertices

std::vector<int> _outgoing_vertices

std::vector<std::vector<std::size_t>> _propagator_vertices

class DifferentialCrossSection : public madevent::FunctionGenerator

Public Functions

DifferentialCrossSection(const MatrixElement &matrix_element, double cm_energy, const RunningCoupling &running_coupling, const EnergyScale &energy_scale, const nested_vector2<me_int_t> &pid_options = {}, bool has_pdf1 = false, bool has_pdf2 = false, const std::optional<PdfGrid> &pdf_grid1 = std::nullopt, const std::optional<PdfGrid> &pdf_grid2 = std::nullopt, bool has_mirror = false, bool input_momentum_fraction = true)

inline const nested_vector2<me_int_t> &pid_options() const

inline bool has_mirror() const

inline const MatrixElement &matrix_element() const

Private Functions

virtual ValueVec build_function_impl(FunctionBuilder &fb, const ValueVec &args) const override

Private Members

nested_vector2<me_int_t> _pid_options

MatrixElement _matrix_element

std::array<std::optional<PartonDensity>, 2> _pdfs

std::array<std::vector<me_int_t>, 2> _pdf_indices

RunningCoupling _running_coupling

double _e_cm

EnergyScale _energy_scale

bool _has_mirror

bool _input_momentum_fraction

class DiscreteFlow : public madevent::Mapping

Public Functions

DiscreteFlow(const std::vector<std::size_t> &option_counts, const std::string &prefix = "", const std::vector<std::size_t> &dims_with_prior = {}, std::size_t condition_dim = 0, std::size_t subnet_hidden_dim = 32, std::size_t subnet_layers = 3, MLP::Activation subnet_activation = MLP::leaky_relu)

inline const std::vector<std::size_t> &option_counts() const

inline std::size_t condition_dim() const

void initialize_globals(ContextPtr context) const

Private Functions

virtual Result build_forward_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions) const override

virtual Result build_inverse_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions) const override

Result build_transform(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions, bool inverse) const

Private Members

std::vector<std::size_t> _option_counts

std::size_t _condition_dim

std::optional<std::string> _first_prob_name

std::vector<MLP> _subnets

std::vector<bool> _dim_has_prior

class DiscreteHistogram : public madevent::FunctionGenerator

Public Functions

DiscreteHistogram(const std::vector<std::size_t> &option_counts)

Private Functions

virtual ValueVec build_function_impl(FunctionBuilder &fb, const ValueVec &args) const override

Private Members

std::vector<std::size_t> _option_counts

class DiscreteOptimizer

Public Functions

inline DiscreteOptimizer(ContextPtr context, const std::vector<std::string> &prob_names)

void add_data(const std::vector<Tensor> &values_and_counts)

void optimize()

Private Members

ContextPtr _context

std::vector<std::string> _prob_names

double _damping

std::size_t _sample_count

std::vector<std::tuple<std::vector<std::size_t>, std::vector<double>>> _data

class DiscreteSampler : public madevent::Mapping

Public Functions

DiscreteSampler(const std::vector<std::size_t> &option_counts, const std::string &prefix = "", const std::vector<std::size_t> &dims_with_prior = {})

inline const std::vector<std::size_t> &option_counts() const

inline const std::vector<std::string> &prob_names() const

void initialize_globals(ContextPtr context) const

Private Functions

virtual Result build_forward_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions) const override

virtual Result build_inverse_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions) const override

Result build_transform(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions, bool inverse) const

Private Members

std::vector<std::size_t> _option_counts

std::vector<bool> _dim_has_prior

std::vector<std::string> _prob_names

struct EmptyParticleRecord

Public Static Attributes

static constexpr std::size_t size = 0

static constexpr std::array<FieldLayout, 0> layout = {}

class EnergyScale : public madevent::FunctionGenerator

Public Types

enum DynamicalScaleType

Values:

enumerator transverse_energy

enumerator transverse_mass

enumerator half_transverse_mass

enumerator partonic_energy

Public Functions

inline EnergyScale(std::size_t particle_count)

inline EnergyScale(std::size_t particle_count, DynamicalScaleType type)

inline EnergyScale(std::size_t particle_count, double fixed_scale)

EnergyScale(std::size_t particle_count, DynamicalScaleType dynamical_scale_type, bool ren_scale_fixed, bool fact_scale_fixed, double ren_scale, double fact_scale1, double fact_scale2)

Private Functions

virtual ValueVec build_function_impl(FunctionBuilder &fb, const ValueVec &args) const override

Private Members

DynamicalScaleType _dynamical_scale_type

bool _ren_scale_fixed

bool _fact_scale_fixed

double _ren_scale

double _fact_scale1

double _fact_scale2

class EventBuffer

Public Functions

inline EventBuffer(std::size_t event_count, std::size_t particle_count, DataLayout layout)

inline char *data()

inline const char *data() const

inline std::size_t size() const

inline std::size_t event_count() const

inline std::size_t particle_count() const

inline const DataLayout &layout() const

inline std::size_t event_size() const

inline std::size_t event_offset(std::size_t event_index) const

inline std::size_t particle_offset(std::size_t event_index, std::size_t particle_index) const

template<typename T>
inline T particle(std::size_t event_index, std::size_t particle_index)

template<typename T>
inline T event(std::size_t event_index)

inline void resize(std::size_t event_count)

inline void copy_and_pad(EventBuffer &buffer)

Private Members

std::size_t _event_count

std::size_t _particle_count

DataLayout _layout

std::vector<char> _data

class EventFile

Public Types

enum Mode

Values:

enumerator create

enumerator append

enumerator load

Public Functions

EventFile(const std::string &file_name, DataLayout layout, std::size_t particle_count = 0, Mode mode = create, bool delete_on_close = false)

EventFile(EventFile &&other) noexcept = default

EventFile &operator=(EventFile &&other) noexcept = default

void seek(std::size_t index)

void clear()

inline std::size_t particle_count() const

inline std::size_t event_count() const

~EventFile()

inline void write(EventBuffer &buffer)

inline bool read(EventBuffer &buffer, std::size_t count)

Private Members

std::string _file_name

std::size_t _event_count

std::size_t _current_event

std::size_t _capacity

std::size_t _particle_count

std::size_t _shape_pos

std::fstream _file_stream

std::size_t _header_size

std::size_t _event_size

Mode _mode

bool _delete_on_close

class EventGenerator

Public Types

enum Verbosity

Values:

enumerator silent

enumerator log

enumerator pretty

Public Functions

EventGenerator(ContextPtr context, const std::vector<Integrand> &channels, const std::string &temp_file_prefix, const std::string &status_file = "", const Config &config = default_config, const std::vector<std::size_t> &channel_subprocesses = {}, const std::vector<std::string> &channel_names = {}, const std::vector<ObservableHistograms> &channel_histograms = {})

void survey()

void generate()

void combine_to_compact_npy(const std::string &file_name)

void combine_to_lhe_npy(const std::string &file_name, LHECompleter &lhe_completer)

void combine_to_lhe(const std::string &file_name, LHECompleter &lhe_completer)

inline Status status() const

std::vector<Status> channel_status() const

std::vector<Histogram> histograms() const

Public Static Functions

static inline void set_abort_check_function(std::function<void(void)> func)

Public Static Attributes

static const int integrand_flags = Integrand::sample | Integrand::return_momenta | Integrand::return_indices | Integrand::return_random | Integrand::return_discrete

static const Config default_config

Private Functions

void reset_start_time()

void add_timing_data(const std::string &key)

std::string format_run_time(const std::string &key) const

void unweight_all()

void unweight_channel(ChannelState &channel, std::mt19937 rand_gen)

std::tuple<Tensor, std::vector<Tensor>> integrate_and_optimize(ChannelState &channel, TensorVec &events, bool always_optimize)

double channel_weight_sum(ChannelState &channel, std::size_t event_count)

void start_job(ChannelState &channel, std::size_t batch_size, std::size_t vegas_job_count = 0)

void start_vegas_jobs(ChannelState &channel)

void clear_channel(ChannelState &channel)

void update_max_weight(ChannelState &channel, Tensor weights)

void unweight_and_write(ChannelState &channel, const std::vector<Tensor> &momenta)

std::size_t max_particle_count()

std::tuple<std::vector<CombineChannelData>, std::size_t, double> init_combine()

void read_and_combine(std::vector<CombineChannelData> &channel_data, EventBuffer &buffer, double norm_factor)

void fill_lhe_event(LHECompleter &lhe_completer, LHEEvent &lhe_event, EventBuffer &buffer, std::size_t event_index)

void init_status(const std::string &status)

void write_status(const std::string &status, bool force_write)

void print_survey_init()

void print_survey_update(bool done, std::size_t done_job_count, std::size_t total_job_count, std::size_t iter)

void print_survey_update_pretty(bool done, std::size_t done_job_count, std::size_t total_job_count, std::size_t iter)

void print_survey_update_log(bool done, std::size_t done_job_count, std::size_t total_job_count, std::size_t iter)

void print_gen_init()

void print_gen_update(bool done)

void print_gen_update_pretty(bool done)

void print_gen_update_log(bool done)

void print_combine_init()

void print_combine_update(std::size_t count)

void print_combine_update_pretty(std::size_t count)

void print_combine_update_log(std::size_t count)

Private Members

ContextPtr _context

Config _config

std::vector<ChannelState> _channels

RuntimePtr _unweighter

Status _status_all

std::unordered_map<std::size_t, RunningJob> _running_jobs

std::size_t _job_id

std::chrono::time_point<std::chrono::steady_clock> _start_time

std::size_t _start_cpu_microsec

std::chrono::time_point<std::chrono::steady_clock> _last_print_time

std::chrono::time_point<std::chrono::steady_clock> _last_status_time

PrettyBox _pretty_box_upper

PrettyBox _pretty_box_lower

std::string _status_file

std::unordered_map<std::string, TimingData> _timing_data

std::vector<Histogram> _empty_histograms

Private Static Attributes

static std::function<void(void)> _abort_check_function = [] {}

Friends

friend void to_json(nlohmann::json &j, const EventGenerator::TimingData &timing_data)

template<int fields>
struct EventRecord

Public Functions

inline UnalignedRef<double> weight()

inline UnalignedRef<int> subprocess_index()

inline UnalignedRef<int> diagram_index()

inline UnalignedRef<int> color_index()

inline UnalignedRef<int> flavor_index()

inline UnalignedRef<int> helicity_index()

Public Members

char *data

Public Static Attributes

static constexpr std::size_t size = (fields & record_weight ? 8 : 0) + (fields & record_subproc_index ? 4 : 0) + (fields & record_indices ? 16 : 0)

static constexpr std::size_t subproc_index_offset = fields & record_weight ? 8 : 0

static constexpr std::size_t indices_offset = subproc_index_offset + (fields & record_subproc_index ? 4 : 0)

static constexpr std::size_t field_count = (fields & record_weight ? 1 : 0) + (fields & record_subproc_index ? 1 : 0) + (fields & record_indices ? 4 : 0)

static constexpr std::array<FieldLayout, field_count> layout = [] {std::array<FieldLayout, field_count> layout;std::size_t offset = 0;if (fields & record_weight) {layout[0] = {"weight", "<f8"};offset += 1;}if (fields & record_subproc_index) {layout[offset] = {"subprocess_index", "<i4"};offset += 1;}if (fields & record_indices) {layout[offset + 0] = {"diagram_index", "<i4"};layout[offset + 1] = {"color_index", "<i4"};layout[offset + 2] = {"flavor_index", "<i4"};layout[offset + 3] = {"helicity_index", "<i4"};offset += 4;}return layout;}()

class FastRamboMapping : public madevent::Mapping

Public Functions

FastRamboMapping(std::size_t _n_particles, bool _massless, bool _com = true)

inline std::size_t random_dim() const

Private Functions

virtual Result build_forward_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions) const override

virtual Result build_inverse_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions) const override

Private Members

std::size_t n_particles

bool massless

double com

class Flow : public madevent::Mapping

Public Functions

Flow(std::size_t input_dim, std::size_t condition_dim = 0, const std::string &prefix = "", std::size_t bin_count = 10, std::size_t subnet_hidden_dim = 32, std::size_t subnet_layers = 3, MLP::Activation subnet_activation = MLP::leaky_relu, bool invert_spline = true)

inline std::size_t input_dim() const

inline std::size_t condition_dim() const

void initialize_globals(ContextPtr context) const

void initialize_from_vegas(ContextPtr context, const std::string &grid_name) const

Private Functions

virtual Result build_forward_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions) const override

virtual Result build_inverse_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions) const override

Result build_transform(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions, bool inverse) const

Private Members

std::vector<CouplingBlock> _coupling_blocks

std::size_t _input_dim

std::size_t _condition_dim

std::size_t _bin_count

bool _invert_spline

class FullInstruction : public madevent::Instruction

Public Functions

inline FullInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

class Function

Public Functions

Function() = default

inline const ValueVec &inputs() const

inline const ValueVec &outputs() const

inline const ValueVec &locals() const

inline const std::unordered_map<std::string, Value> &globals() const

inline const std::vector<InstructionCall> &instructions() const

void save(const std::string &file) const

Public Static Functions

static Function load(const std::string &file)

Private Functions

inline Function(const ValueVec &inputs, const ValueVec &outputs, const ValueVec &locals, const std::unordered_map<std::string, Value> &globals, const std::vector<InstructionCall> &instructions)

Private Members

ValueVec _inputs

ValueVec _outputs

ValueVec _locals

std::unordered_map<std::string, Value> _globals

std::vector<InstructionCall> _instructions

Friends

friend class FunctionBuilder

class FunctionBuilder

Public Functions

FunctionBuilder(const std::vector<Type> _input_types, const std::vector<Type> _output_types)

FunctionBuilder(const Function &function)

Value input(int index) const

ValueVec input_range(int start_index, int end_index) const

void output(int index, Value value)

void output_range(int start_index, const ValueVec &values)

Value global(const std::string &name, DataType dtype, const std::vector<int> &shape)

ValueVec instruction(const std::string &name, const ValueVec &args)

ValueVec instruction(InstructionPtr instruction, const ValueVec &args)

Function function()

Value sum(const ValueVec &values)

Value product(const ValueVec &values)

Private Functions

void register_local(Value &val)

Private Members

std::vector<Type> output_types

ValueVec inputs

std::vector<std::optional<Value>> outputs

std::map<LiteralValue, Value> literals

ValueVec locals

std::unordered_map<std::string, Value> globals

std::vector<InstructionCall> instructions

std::map<std::vector<std::size_t>, std::vector<std::size_t>> instruction_cache

std::vector<int> local_sources

std::vector<bool> instruction_used

class FunctionGenerator

Subclassed by madevent::ChannelWeightNetwork, madevent::Cuts, madevent::DifferentialCrossSection, madevent::DiscreteHistogram, madevent::EnergyScale, madevent::Integrand, madevent::IntegrandProbability, madevent::MLP, madevent::MatrixElement, madevent::MomentumPreprocessing, madevent::MultiChannelFunction, madevent::MultiChannelIntegrand, madevent::Observable, madevent::ObservableHistograms, madevent::PartonDensity, madevent::PropagatorChannelWeights, madevent::RunningCoupling, madevent::SubchannelWeights, madevent::Unweighter, madevent::VegasHistogram

Public Functions

inline FunctionGenerator(const std::string &name, const TypeVec &arg_types, const TypeVec &return_types)

virtual ~FunctionGenerator() = default

ValueVec build_function(FunctionBuilder &fb, const ValueVec &args) const

Function function() const

inline const TypeVec &arg_types() const

inline const TypeVec &return_types() const

inline const std::string &name() const

Protected Functions

virtual ValueVec build_function_impl(FunctionBuilder &fb, const ValueVec &args) const = 0

Private Members

std::string _name

TypeVec _arg_types

TypeVec _return_types

struct HistItem

Public Members

Observable observable

double min

double max

std::size_t bin_count

struct Histogram

Public Members

std::string name

double min

double max

std::vector<double> bin_values

std::vector<double> bin_errors

class Instruction

Subclassed by madevent::BatchCatInstruction, madevent::BatchGatherInstruction, madevent::BatchScatterInstruction, madevent::BatchSizeInstruction, madevent::BatchSplitInstruction, madevent::CatInstruction, madevent::FullInstruction, madevent::MatrixElementInstruction, madevent::NonzeroInstruction, madevent::OffsetIndicesInstruction, madevent::RandomInstruction, madevent::RqsReshapeInstruction, madevent::SimpleInstruction, madevent::SqueezeInstruction, madevent::StackInstruction, madevent::UnsqueezeInstruction, madevent::UnstackInstruction, madevent::UnstackSizesInstruction, madevent::UnweightInstruction

Public Functions

inline Instruction(const std::string &name, int opcode, bool differentiable)

virtual ~Instruction() = default

virtual TypeVec signature(const ValueVec &args) const = 0

inline const std::string &name() const

inline int opcode() const

inline bool differentiable() const

Protected Functions

void check_arg_count(const ValueVec &args, std::size_t count) const

me_int_t int_literal_arg(const ValueVec &args, std::size_t index, bool check_non_negative = true) const

Private Members

std::string _name

int _opcode

bool _differentiable

struct InstructionCall

Public Members

InstructionPtr instruction

ValueVec inputs

ValueVec outputs

class InstructionDependencies

Public Functions

InstructionDependencies(const Function &function)

inline bool depends(std::size_t test_index, std::size_t dependency_index)

Private Members

std::size_t size

std::vector<bool> matrix

std::vector<int> ranks

class Integrand : public madevent::FunctionGenerator

Public Types

using AdaptiveMapping = std::variant<std::monostate, VegasMapping, Flow>

using AdaptiveDiscrete = std::variant<std::monostate, DiscreteSampler, DiscreteFlow>

Public Functions

Integrand(const PhaseSpaceMapping &mapping, const DifferentialCrossSection &diff_xs, const AdaptiveMapping &adaptive_map = std::monostate{}, const AdaptiveDiscrete &discrete_before = std::monostate{}, const AdaptiveDiscrete &discrete_after = std::monostate{}, const std::optional<PdfGrid> &pdf_grid = std::nullopt, const std::optional<EnergyScale> &energy_scale = std::nullopt, const std::optional<PropagatorChannelWeights> &prop_chan_weights = std::nullopt, const std::optional<SubchannelWeights> &subchan_weights = std::nullopt, const std::optional<ChannelWeightNetwork> &chan_weight_net = std::nullopt, const std::vector<me_int_t> &chan_weight_remap = {}, std::size_t remapped_chan_count = 0, int flags = 0, const std::vector<std::size_t> &channel_indices = {}, const std::vector<std::size_t> &active_flavors = {})

inline std::size_t particle_count() const

inline int flags() const

inline std::optional<std::string> vegas_grid_name() const

inline std::size_t vegas_dimension() const

inline std::size_t vegas_bin_count() const

inline const PhaseSpaceMapping &mapping() const

inline const DifferentialCrossSection &diff_xs() const

inline const AdaptiveMapping &adaptive_map() const

inline const AdaptiveDiscrete &discrete_before() const

inline const AdaptiveDiscrete &discrete_after() const

inline const std::optional<EnergyScale> &energy_scale() const

inline const std::optional<PropagatorChannelWeights> &prop_chan_weights() const

inline const std::optional<ChannelWeightNetwork> &chan_weight_net() const

inline const std::size_t random_dim() const

std::tuple<std::vector<std::size_t>, std::vector<bool>> latent_dims() const

Public Static Attributes

static const int sample = 1

static const int unweight = 2

static const int return_momenta = 4

static const int return_x1_x2 = 8

static const int return_indices = 16

static const int return_random = 32

static const int return_latent = 64

static const int return_channel = 128

static const int return_chan_weights = 256

static const int return_cwnet_input = 512

static const int return_discrete = 1024

static const int return_discrete_latent = 2048

static const std::vector<MatrixElement::MatrixElementInput> matrix_element_inputs = {MatrixElement::momenta_in, MatrixElement::alpha_s_in, MatrixElement::flavor_in, MatrixElement::random_color_in, MatrixElement::random_helicity_in, MatrixElement::random_diagram_in,}

static const std::vector<MatrixElement::MatrixElementOutput> matrix_element_outputs = {MatrixElement::matrix_element_out, MatrixElement::diagram_amp2_out, MatrixElement::color_index_out, MatrixElement::helicity_index_out, MatrixElement::diagram_index_out,}

Private Functions

virtual ValueVec build_function_impl(FunctionBuilder &fb, const ValueVec &args) const override

ChannelResult build_channel_part(FunctionBuilder &fb, const ChannelArgs &args) const

ValueVec build_common_part(FunctionBuilder &fb, const ChannelArgs &args, ChannelResult &result) const

Private Members

PhaseSpaceMapping _mapping

DifferentialCrossSection _diff_xs

AdaptiveMapping _adaptive_map

AdaptiveDiscrete _discrete_before

AdaptiveDiscrete _discrete_after

std::optional<PartonDensity> _pdf1

std::optional<PartonDensity> _pdf2

std::vector<me_int_t> _pdf_indices1

std::vector<me_int_t> _pdf_indices2

std::optional<EnergyScale> _energy_scale

std::optional<PropagatorChannelWeights> _prop_chan_weights

std::optional<SubchannelWeights> _subchan_weights

std::optional<ChannelWeightNetwork> _chan_weight_net

std::vector<me_int_t> _chan_weight_remap

me_int_t _remapped_chan_count

int _flags

std::vector<me_int_t> _channel_indices

me_int_t _random_dim

std::size_t _latent_dim

std::vector<double> _active_flavors

Friends

friend class IntegrandProbability

friend class MultiChannelIntegrand

class IntegrandProbability : public madevent::FunctionGenerator

Public Functions

IntegrandProbability(const Integrand &integrand)

Private Functions

virtual ValueVec build_function_impl(FunctionBuilder &fb, const ValueVec &args) const override

Private Members

Integrand::AdaptiveMapping _adaptive_map

Integrand::AdaptiveDiscrete _discrete_before

Integrand::AdaptiveDiscrete _discrete_after

std::size_t _permutation_count

std::size_t _flavor_count

bool _has_pdf_prior

class Invariant : public madevent::Mapping

Public Functions

inline Invariant(double power = 0, double mass = 0, double width = 0)

Private Functions

virtual Result build_forward_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions) const override

virtual Result build_inverse_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions) const override

Private Members

double _power

double _mass

double _width

class LastUseOfLocals

Public Functions

LastUseOfLocals(const Function &function)

inline std::vector<int> &local_indices(std::size_t index)

Private Members

std::vector<std::vector<int>> last_used

class LHECompleter

Public Functions

LHECompleter(const std::vector<SubprocArgs> &subproc_args, double bw_cutoff)

void complete_event_data(LHEEvent &event, int subprocess_index, int diagram_index, int color_index, int flavor_index, int helicity_index)

inline std::size_t max_particle_count() const

Private Members

std::vector<SubprocData> _subproc_data

std::vector<int> _process_indices

std::vector<double> _masses

std::vector<std::tuple<int, int>> _colors

std::vector<double> _helicities

std::vector<std::array<std::size_t, 3>> _pdg_id_index_and_count

std::vector<int> _pdg_ids

std::unordered_map<std::size_t, std::array<std::size_t, 3>> _propagator_index_and_count

std::vector<PropagatorData> _propagators

std::vector<std::tuple<int, int>> _propagator_colors

double _bw_cutoff

std::size_t _max_particle_count

ThreadResource<std::mt19937> _rand_gens

struct LHEEvent

Public Functions

void format_to(std::string &buffer) const

Public Members

int process_id

double weight

double scale

double alpha_qed

double alpha_qcd

std::vector<LHEParticle> particles

class LHEFileWriter

Public Functions

LHEFileWriter(const std::string &file_name, const LHEMeta &meta)

void write(const LHEEvent &event)

void write_string(const std::string &str)

~LHEFileWriter()

Private Members

std::ofstream _file_stream

std::string _buffer

struct LHEHeader

Public Members

std::string name

std::string content

bool escape_content

struct LHEMeta

Public Members

int beam1_pdg_id

int beam2_pdg_id

double beam1_energy

double beam2_energy

int beam1_pdf_authors

int beam2_pdf_authors

int beam1_pdf_id

int beam2_pdf_id

int weight_mode

std::vector<LHEProcess> processes

std::vector<LHEHeader> headers

struct LHEParticle

Public Members

int pdg_id

int status_code

int mother1

int mother2

int color

int anti_color

double px

double py

double pz

double energy

double mass

double lifetime

double spin

Public Static Attributes

static const int status_incoming = -1

static const int status_outgoing = 1

static const int status_intermediate_resonance = 2

struct LHEProcess

Public Members

double cross_section

double cross_section_error

double max_weight

int process_id

class LineRef

Public Functions

inline LineRef(LineType type, std::size_t index)

LineRef(std::string str)

inline LineType type() const

inline std::size_t index() const

Private Members

LineType _type

std::size_t _index

class Logger

Public Types

enum LogLevel

Values:

enumerator level_debug

enumerator level_info

enumerator level_warning

enumerator level_error

using LogHandlerFunc = std::function<void(LogLevel level, const std::string &message)>

Public Static Functions

static inline void log(LogLevel level, const std::string &message)

static inline void debug(const std::string &message)

static inline void info(const std::string &message)

static inline void warning(const std::string &message)

static inline void error(const std::string &message)

static inline void set_log_handler(LogHandlerFunc func)

Private Static Attributes

static std::optional<LogHandlerFunc> _log_handler = std::nullopt

class Luminosity : public madevent::Mapping

Public Functions

inline Luminosity(double s_lab, double s_hat_min, double s_hat_max = 0, double invariant_power = 1, double mass = 0, double width = 0)

Private Functions

virtual Result build_forward_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions) const override

virtual Result build_inverse_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions) const override

Private Members

double _s_lab

double _s_hat_min

double _s_hat_max

Invariant _invariant

class Mapping

Subclassed by madevent::ChiliMapping, madevent::DiscreteFlow, madevent::DiscreteSampler, madevent::FastRamboMapping, madevent::Flow, madevent::Invariant, madevent::Luminosity, madevent::MultiChannelMapping, madevent::PhaseSpaceMapping, madevent::TPropagatorMapping, madevent::ThreeBodyDecay, madevent::TwoBodyDecay, madevent::TwoToThreeParticleScattering, madevent::TwoToTwoParticleScattering, madevent::VegasMapping

Public Types

using Result = std::tuple<ValueVec, Value>

Public Functions

inline Mapping(const std::string &name, const TypeVec &input_types, const TypeVec &output_types, const TypeVec &condition_types)

virtual ~Mapping() = default

Result build_forward(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions = {}) const

Result build_inverse(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions = {}) const

Function forward_function() const

Function inverse_function() const

inline const TypeVec &input_types() const

inline const TypeVec &output_types() const

inline const TypeVec &condition_types() const

inline const std::string &name() const

Protected Functions

virtual Result build_forward_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions) const = 0

virtual Result build_inverse_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions) const = 0

Private Members

std::string _name

TypeVec _input_types

TypeVec _output_types

TypeVec _condition_types

class MatrixElement : public madevent::FunctionGenerator

Public Types

enum MatrixElementInput

Values:

enumerator momenta_in

enumerator alpha_s_in

enumerator flavor_in

enumerator random_color_in

enumerator random_helicity_in

enumerator random_diagram_in

enumerator helicity_in

enumerator diagram_in

enum MatrixElementOutput

Values:

enumerator matrix_element_out

enumerator diagram_amp2_out

enumerator color_index_out

enumerator helicity_index_out

enumerator diagram_index_out

Public Functions

MatrixElement(std::size_t matrix_element_index, std::size_t particle_count, const std::vector<MatrixElementInput> &inputs = {momenta_in}, const std::vector<MatrixElementOutput> &outputs = {matrix_element_out}, std::size_t diagram_count = 1, bool sample_random_inputs = false)

inline MatrixElement(const MatrixElementApi &matrix_element_api, const std::vector<MatrixElementInput> &inputs = {momenta_in}, const std::vector<MatrixElementOutput> &outputs = {matrix_element_out}, bool sample_random_inputs = false)

inline std::size_t matrix_element_index() const

inline std::size_t diagram_count() const

inline std::size_t particle_count() const

inline const std::vector<MatrixElementInput> &inputs() const

inline const std::vector<MatrixElementOutput> &outputs() const

std::vector<MatrixElementInput> external_inputs() const

Private Functions

virtual ValueVec build_function_impl(FunctionBuilder &fb, const ValueVec &args) const override

Private Members

std::size_t _matrix_element_index

std::size_t _particle_count

std::size_t _diagram_count

std::vector<MatrixElementInput> _inputs

std::vector<MatrixElementOutput> _outputs

bool _sample_random_inputs

class MatrixElementApi

Public Functions

MatrixElementApi(const std::string &file, const std::string &param_card, std::size_t index = 0)

MatrixElementApi(MatrixElementApi&&) noexcept = default

MatrixElementApi &operator=(MatrixElementApi&&) noexcept = default

MatrixElementApi(const MatrixElementApi&) = delete

MatrixElementApi &operator=(const MatrixElementApi&) = delete

inline DevicePtr device() const

inline std::size_t particle_count() const

inline std::size_t diagram_count() const

inline std::size_t helicity_count() const

inline std::size_t index() const

inline const std::string &file_name() const

inline void call(UmamiHandle handle, size_t count, size_t stride, size_t offset, size_t input_count, UmamiInputKey const *input_keys, void const *const *inputs, size_t output_count, UmamiOutputKey const *output_keys, void *const *outputs) const

inline void *process_instance(std::size_t index) const

Private Types

using InstanceType = std::unique_ptr<void, std::function<void(void*)>>

Private Functions

void check_umami_status(UmamiStatus status) const

void throw_error(const std::string &message) const

Private Members

std::unique_ptr<void, std::function<void(void*)>> _shared_lib

decltype(&umami_get_meta) _get_meta

decltype(&umami_initialize) _initialize

decltype(&umami_matrix_element) _matrix_element

decltype(&umami_free) _free

ThreadResource<InstanceType> _instances

std::string _file_name

std::size_t _index

class MatrixElementInstruction : public madevent::Instruction

Public Functions

inline MatrixElementInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

class MLP : public madevent::FunctionGenerator

Public Types

enum Activation

Values:

enumerator relu

enumerator leaky_relu

enumerator elu

enumerator gelu

enumerator sigmoid

enumerator softplus

enumerator linear

Public Functions

MLP(std::size_t input_dim, std::size_t output_dim, std::size_t hidden_dim = 32, std::size_t layers = 3, Activation activation = leaky_relu, const std::string &prefix = "")

inline std::size_t input_dim() const

inline std::size_t output_dim() const

void initialize_globals(ContextPtr context) const

inline std::string last_layer_bias_name() const

Private Functions

virtual ValueVec build_function_impl(FunctionBuilder &fb, const ValueVec &args) const override

Private Members

std::size_t _input_dim

std::size_t _output_dim

std::size_t _hidden_dim

std::size_t _layers

Activation _activation

std::string _prefix

class MomentumPreprocessing : public madevent::FunctionGenerator

Public Functions

MomentumPreprocessing(std::size_t particle_count)

inline std::size_t output_dim() const

Private Functions

virtual ValueVec build_function_impl(FunctionBuilder &fb, const ValueVec &args) const override

Private Members

std::size_t _output_dim

class MultiChannelFunction : public madevent::FunctionGenerator

Public Functions

MultiChannelFunction(const std::vector<std::shared_ptr<FunctionGenerator>> &functions)

Private Functions

virtual ValueVec build_function_impl(FunctionBuilder &fb, const ValueVec &args) const override

Private Members

std::vector<std::shared_ptr<FunctionGenerator>> _functions

class MultiChannelIntegrand : public madevent::FunctionGenerator

Public Functions

MultiChannelIntegrand(const std::vector<std::shared_ptr<Integrand>> &integrands)

Private Functions

virtual ValueVec build_function_impl(FunctionBuilder &fb, const ValueVec &args) const override

Private Members

std::vector<std::shared_ptr<Integrand>> _integrands

class MultiChannelMapping : public madevent::Mapping

Public Functions

MultiChannelMapping(const std::vector<std::shared_ptr<Mapping>> &mappings)

Private Functions

Result build_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions, bool inverse) const

inline virtual Result build_forward_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions) const override

inline virtual Result build_inverse_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions) const override

Private Members

std::vector<std::shared_ptr<Mapping>> _mappings

class NonzeroInstruction : public madevent::Instruction

Public Functions

inline NonzeroInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

class Observable : public madevent::FunctionGenerator

Public Types

enum ObservableOption

Values:

enumerator obs_e

enumerator obs_px

enumerator obs_py

enumerator obs_pz

enumerator obs_mass

enumerator obs_pt

enumerator obs_p_mag

enumerator obs_phi

enumerator obs_theta

enumerator obs_y

enumerator obs_y_abs

enumerator obs_eta

enumerator obs_eta_abs

enumerator obs_delta_eta

enumerator obs_delta_phi

enumerator obs_delta_r

enumerator obs_sqrt_s

Public Functions

Observable(const std::vector<int> &pids, ObservableOption observable, const nested_vector2<int> &select_pids, bool sum_momenta = false, bool sum_observable = false, const std::optional<ObservableOption> &order_observable = std::nullopt, const std::vector<int> &order_indices = {}, bool ignore_incoming = true, const std::string &name = "")

inline ObservableOption observable() const

inline std::vector<std::size_t> simple_observable_indices() const

inline std::string name() const

bool not_found() const

Public Static Attributes

static const std::vector<int> jet_pids

static const std::vector<int> bottom_pids

static const std::vector<int> lepton_pids

static const std::vector<int> missing_pids

static const std::vector<int> photon_pids

Private Functions

Observable(std::tuple<nested_vector2<me_int_t>, nested_vector2<me_int_t>, Type> indices_and_type, const std::vector<int> &pids, ObservableOption observable, bool sum_momenta, bool sum_observable, const std::optional<ObservableOption> &order_observable, bool ignore_incoming, const std::string &name)

virtual ValueVec build_function_impl(FunctionBuilder &fb, const ValueVec &args) const override

Private Members

ObservableOption _observable

nested_vector2<me_int_t> _indices

std::optional<ObservableOption> _order_observable

nested_vector2<me_int_t> _order_indices

bool _sum_momenta

bool _sum_observable

std::string _name

class ObservableHistograms : public madevent::FunctionGenerator

Public Functions

ObservableHistograms(const std::vector<HistItem> &observables)

inline const std::vector<HistItem> &observables() const

Private Functions

virtual ValueVec build_function_impl(FunctionBuilder &fb, const ValueVec &args) const override

Private Members

std::vector<HistItem> _observables

class OffsetIndicesInstruction : public madevent::Instruction

Public Functions

inline OffsetIndicesInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

template<class ...Ts>
struct Overloaded : public madevent::Ts

struct PackedLHEEvent

Public Functions

inline void from_lhe_event(const LHEEvent &event)

inline UnalignedRef<int> process_id()

inline UnalignedRef<double> weight()

inline UnalignedRef<double> scale()

inline UnalignedRef<double> alpha_qed()

inline UnalignedRef<double> alpha_qcd()

Public Members

char *data

Public Static Attributes

static constexpr std::size_t size = 1 * sizeof(int) + 4 * sizeof(double)

static constexpr std::array<FieldLayout, 5> layout = {{{"process_id", "<i4"}, {"weight", "<f8"}, {"scale", "<f8"}, {"alpha_qed", "<f8"}, {"alpha_qcd", "<f8"},}}

struct PackedLHEParticle

Public Functions

inline void from_lhe_particle(const LHEParticle &particle)

inline UnalignedRef<int> pdg_id()

inline UnalignedRef<int> status_code()

inline UnalignedRef<int> mother1()

inline UnalignedRef<int> mother2()

inline UnalignedRef<int> color()

inline UnalignedRef<int> anti_color()

inline UnalignedRef<double> px()

inline UnalignedRef<double> py()

inline UnalignedRef<double> pz()

inline UnalignedRef<double> energy()

inline UnalignedRef<double> mass()

inline UnalignedRef<double> lifetime()

inline UnalignedRef<double> spin()

Public Members

char *data

Public Static Attributes

static constexpr std::size_t size = 6 * sizeof(int) + 7 * sizeof(double)

static constexpr std::array<FieldLayout, 13> layout = {{{"pdg_id", "<i4"}, {"status_code", "<i4"}, {"mother1", "<i4"}, {"mother2", "<i4"}, {"color", "<i4"}, {"anti_color", "<i4"}, {"px", "<f8"}, {"py", "<f8"}, {"pz", "<f8"}, {"energy", "<f8"}, {"mass", "<f8"}, {"lifetime", "<f8"}, {"spin", "<f8"},}}

template<ScalarType T, int _dim>
struct PackedTensorView

Public Types

using DType = T

Public Members

T *data

Sizes stride

Sizes shape

Public Static Attributes

static const int dim = _dim

struct ParticleRecord

Public Functions

inline UnalignedRef<double> energy()

inline UnalignedRef<double> px()

inline UnalignedRef<double> py()

inline UnalignedRef<double> pz()

Public Members

char *data

Public Static Attributes

static constexpr std::size_t size = 32

static constexpr std::array<FieldLayout, 4> layout = {{{"energy", "<f8"}, {"px", "<f8"}, {"py", "<f8"}, {"pz", "<f8"}}}

class PartonDensity : public madevent::FunctionGenerator

Public Functions

PartonDensity(const PdfGrid &grid, const std::vector<int> &pids, bool dynamic_pid = false, const std::string &prefix = "")

Private Functions

virtual ValueVec build_function_impl(FunctionBuilder &fb, const ValueVec &args) const override

Private Members

std::vector<me_int_t> _pid_indices

bool _dynamic_pid

std::string _prefix

std::vector<std::size_t> _logx_shape

std::vector<std::size_t> _logq2_shape

std::vector<std::size_t> _coeffs_shape

struct PdfGrid

Public Functions

PdfGrid(const std::string &file)

std::size_t grid_point_count() const

std::size_t q_count() const

void initialize_coefficients(Tensor tensor) const

void initialize_logx(Tensor tensor) const

void initialize_logq2(Tensor tensor) const

std::vector<std::size_t> coefficients_shape(bool batch_dim = false) const

std::vector<std::size_t> logx_shape(bool batch_dim = false) const

std::vector<std::size_t> logq2_shape(bool batch_dim = false) const

void initialize_globals(ContextPtr context, const std::string &prefix = "") const

Public Members

std::vector<double> x

std::vector<double> logx

std::vector<double> q

std::vector<double> logq2

std::vector<int> pids

std::vector<std::vector<double>> values

std::vector<std::size_t> region_sizes

class PhaseSpaceMapping : public madevent::Mapping

Public Types

enum TChannelMode

Values:

enumerator propagator

enumerator rambo

enumerator chili

Public Functions

PhaseSpaceMapping(const Topology &topology, double cm_energy, bool leptonic = false, double invariant_power = 0.8, TChannelMode t_channel_mode = propagator, const std::optional<Cuts> &cuts = std::nullopt, const std::vector<std::vector<std::size_t>> &permutations = {})

PhaseSpaceMapping(const std::vector<double> &external_masses, double cm_energy, bool leptonic = false, double invariant_power = 0.8, TChannelMode mode = rambo, const std::optional<Cuts> &cuts = std::nullopt)

inline std::size_t random_dim() const

inline std::size_t particle_count() const

inline std::size_t channel_count() const

Private Functions

virtual Result build_forward_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions) const override

virtual Result build_inverse_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions) const override

Private Members

Topology _topology

Cuts _cuts

double _pi_factors

double _s_lab

bool _leptonic

bool _map_luminosity

std::vector<Invariant> _s_invariants

std::variant<TPropagatorMapping, FastRamboMapping, ChiliMapping, std::monostate> _t_mapping

std::vector<std::variant<TwoBodyDecay, ThreeBodyDecay, FastRamboMapping>> _s_decays

std::vector<std::vector<me_int_t>> _permutations

class PrettyBox

Public Functions

PrettyBox() = default

PrettyBox(const std::string &title, std::size_t rows, const std::vector<std::size_t> &column_sizes, std::size_t offset = 0, std::size_t box_width = 91)

void print_first() const

void print_update() const

inline std::size_t line_count() const

inline void set_row(std::size_t row, const std::vector<std::string> &values)

inline void set_column(std::size_t column, const std::vector<std::string> &values)

inline void set_cell(std::size_t row, std::size_t column, std::string value)

Private Members

std::string _header

std::string _footer

std::size_t _rows

std::size_t _columns

std::size_t _offset

std::vector<std::size_t> _column_ends

std::vector<std::string> _content

struct Propagator

Public Members

double mass

double width

int integration_order

double e_min

double e_max

int pdg_id

class PropagatorChannelWeights : public madevent::FunctionGenerator

Public Functions

PropagatorChannelWeights(const std::vector<Topology> &topologies, const nested_vector3<std::size_t> &permutations, const nested_vector2<std::size_t> &channel_indices)

Private Functions

virtual ValueVec build_function_impl(FunctionBuilder &fb, const ValueVec &args) const override

Private Members

nested_vector2<double> _momentum_factors

nested_vector2<me_int_t> _invariant_indices

nested_vector2<double> _masses

nested_vector2<double> _widths

struct PropagatorData

Public Members

int pdg_id

int momentum_mask

int child_prop_mask

double mass

double width

class RandomInstruction : public madevent::Instruction

Public Functions

inline RandomInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

class RqsReshapeInstruction : public madevent::Instruction

Public Functions

inline RqsReshapeInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

class RunningCoupling : public madevent::FunctionGenerator

Public Functions

RunningCoupling(const AlphaSGrid &grid, const std::string &prefix = "")

Private Functions

virtual ValueVec build_function_impl(FunctionBuilder &fb, const ValueVec &args) const override

Private Members

std::string _prefix

std::vector<std::size_t> _logq2_shape

std::vector<std::size_t> _coeffs_shape

class RunningIntegral

Public Functions

inline RunningIntegral()

inline double mean() const

inline double variance() const

inline double error() const

inline double rel_error() const

inline double rel_std_dev() const

inline std::size_t count() const

inline void reset()

inline void push(double value)

Private Members

double _mean

double _var_sum

std::size_t _count

struct RunningJob

Public Members

std::size_t channel_index

TensorVec events

std::size_t vegas_job_count

class Runtime

Public Functions

virtual ~Runtime() = default

virtual TensorVec run(const TensorVec &inputs) const = 0

virtual std::tuple<TensorVec, TensorVec, std::vector<bool>> run_with_grad(const TensorVec &inputs, const std::vector<bool> &input_requires_grad) const = 0

virtual std::tuple<TensorVec, std::vector<std::tuple<std::string, madevent::Tensor>>> run_backward(const TensorVec &output_grads, const TensorVec &stored_locals, const std::vector<bool> &eval_grad) const = 0

Private Members

std::shared_ptr<void> shared_lib

Friends

friend std::unique_ptr<Runtime> build_runtime(const Function &function, ContextPtr context, bool concurrent)

class ShapeExpr

Public Functions

ShapeExpr(const char *expr)

bool check_and_update(std::map<char, int> &variables, int value) const

std::optional<int> evaluate(const std::map<char, int> &variables) const

inline char first_var_name() const

Private Members

std::vector<std::tuple<char, int>> terms

class SimpleInstruction : public madevent::Instruction

Public Types

using DynShape = std::vector<std::variant<int, ShapeExpr, std::monostate>>

using SigType = std::tuple<DataType, bool, DynShape, bool>

Public Functions

inline SimpleInstruction(std::string name, int opcode, bool differentiable, std::initializer_list<SigType> _inputs, std::initializer_list<SigType> _outputs)

virtual TypeVec signature(const ValueVec &args) const override

Private Members

const std::vector<SigType> inputs

const std::vector<SigType> outputs

class Sizes

Public Functions

inline Sizes()

inline Sizes(std::size_t size)

inline Sizes(std::size_t size, std::size_t value)

inline Sizes(std::initializer_list<std::size_t> values)

inline Sizes(const SizeVec &values)

inline std::size_t &operator[](std::size_t index)

inline const std::size_t &operator[](std::size_t index) const

inline std::size_t size() const

inline std::size_t *begin()

inline std::size_t *end()

inline const std::size_t *begin() const

inline const std::size_t *end() const

inline void push_back(std::size_t item)

inline std::size_t *data()

inline const std::size_t *data() const

inline std::size_t &back()

inline const std::size_t &back() const

Public Static Attributes

static constexpr std::size_t max_size = 4

Private Members

std::size_t _values[max_size]

std::size_t _size

class SqueezeInstruction : public madevent::Instruction

Public Functions

inline SqueezeInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

class StackInstruction : public madevent::Instruction

Public Functions

inline StackInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

struct Status

Public Members

std::size_t index

std::size_t subprocess

std::string name

double mean

double error

double rel_std_dev

std::size_t count

std::size_t count_opt

std::size_t count_after_cuts

std::size_t count_after_cuts_opt

double count_unweighted

double count_target

std::size_t iterations

bool optimized

bool done

class SubchannelWeights : public madevent::FunctionGenerator

Public Functions

SubchannelWeights(const nested_vector2<Topology> &topologies, const nested_vector3<std::size_t> &permutations, const nested_vector2<std::size_t> &channel_indices)

inline std::size_t channel_count() const

Private Functions

virtual ValueVec build_function_impl(FunctionBuilder &fb, const ValueVec &args) const override

Private Members

nested_vector2<double> _momentum_factors

nested_vector2<double> _masses

nested_vector2<double> _widths

nested_vector2<me_int_t> _invariant_indices

nested_vector2<me_int_t> _on_shell

std::vector<me_int_t> _group_sizes

std::vector<me_int_t> _channel_indices

std::vector<me_int_t> _subchannel_indices

struct SubprocArgs

Public Members

int process_id

std::vector<Topology> topologies

nested_vector3<std::size_t> permutations

nested_vector2<std::size_t> diagram_indices

nested_vector3<std::size_t> diagram_color_indices

nested_vector3<std::tuple<int, int>> color_flows

std::unordered_map<int, int> pdg_color_types

nested_vector2<double> helicities

nested_vector3<int> pdg_ids

std::vector<std::size_t> matrix_flavor_indices

struct SubprocData

Public Members

int process_id

std::size_t color_offset

std::size_t pdg_id_offset

std::size_t helicity_offset

std::size_t mass_offset

std::size_t particle_count

std::size_t color_count

std::size_t flavor_count

std::size_t matrix_flavor_count

std::size_t diagram_count

std::size_t helicity_count

class Tensor

Public Functions

inline Tensor()

inline Tensor(const Tensor &other)

inline Tensor(Tensor &&other) noexcept

inline Tensor(DataType dtype, const Sizes &shape)

inline Tensor(DataType dtype, const Sizes &shape, DevicePtr device)

template<typename D>
inline Tensor(DataType dtype, const Sizes &shape, const D &device)

inline Tensor(DataType dtype, const Sizes &shape, void *data, std::function<void()> external_reset)

inline Tensor(DataType dtype, const Sizes &shape, DevicePtr device, void *data, std::function<void()> external_reset)

inline Tensor(DataType dtype, const Sizes &shape, const Sizes &stride, DevicePtr device, void *data, std::function<void()> external_reset)

inline Tensor(const SizeVec &batch_sizes)

template<ScalarType T>
inline Tensor(T value, DevicePtr device)

inline Tensor(TensorValue value, DevicePtr device)

inline ~Tensor()

inline Tensor &operator=(const Tensor &other)

inline Tensor &operator=(Tensor &&other) noexcept

inline operator bool() const

template<class T, int dim>
inline TensorView<T, dim> view()

template<class T, int dim>
inline const TensorView<T, dim> view() const

template<class T, int dim>
inline PackedTensorView<T, dim> flat_view(std::size_t flatten_count) const

inline void *data()

inline void *data() const

inline const Sizes &shape() const

inline const Sizes &stride() const

inline std::size_t size(std::size_t i) const

inline std::size_t offset() const

inline DataType dtype() const

inline const SizeVec &batch_sizes() const

inline DevicePtr device() const

inline std::size_t index_value() const

inline std::size_t dtype_size() const

inline std::size_t byte_size() const

inline void reset()

template<typename D>
inline void reset(const D &device)

Tensor select(std::size_t axis, std::size_t index) const

Tensor slice(std::size_t axis, std::size_t start, std::size_t stop) const

std::vector<Tensor> split(std::size_t axis, const SizeVec &sizes) const

std::vector<Tensor> unstack(std::size_t axis) const

Tensor unsqueeze(std::size_t axis) const

Tensor expand(const Sizes &shape) const

Tensor factor_dim(std::size_t axis, std::size_t factor)

template<typename D>
inline Tensor cpu(const D &device) const

inline Tensor cpu() const

template<typename D>
inline void zero(const D &device)

inline void zero()

template<typename D>
inline void copy_from(const Tensor &source, const D &device)

inline void copy_from(const Tensor &source)

template<typename D>
inline void add(const Tensor &source, const D &device)

inline void add(const Tensor &source)

template<typename D>
inline Tensor copy(const D &device) const

inline Tensor copy() const

inline bool is_contiguous() const

inline std::size_t contiguous_dims() const

template<typename D>
inline Tensor contiguous(const D &device) const

inline Tensor contiguous() const

template<typename D>
inline Tensor contiguous(std::size_t batch_size, const D &device) const

inline Tensor contiguous(std::size_t batch_size) const

Private Functions

inline Tensor(TensorImpl *_impl)

std::size_t init_stride()

inline void check_impl() const

Private Members

TensorImpl *impl

struct TensorImpl

Public Functions

template<typename D>
inline void reset(const D &device)

inline void incref()

Public Members

DataType dtype

Sizes shape

DevicePtr device

void *data

bool owns_data = true

std::optional<std::function<void()>> external_reset = std::nullopt

TensorImpl *data_owner

std::atomic<int> ref_count = 1

Sizes stride

std::size_t offset

std::size_t contiguous_dims

SizeVec batch_sizes

template<ScalarType T, int _dim>
class TensorView

Public Types

using DType = T

Public Functions

inline TensorView(T *data, std::size_t *stride, std::size_t *shape)

inline TensorView(PackedTensorView<T, _dim> &packed_view)

inline TensorView(T &value)

inline virtual const TensorView<T, _dim - 1> operator[](std::size_t index) const
requires (_dim != 0)

inline virtual TensorView<T, _dim - 1> operator[](std::size_t index)
requires (_dim != 0)

template<typename... I> const TensorView< T, _dim - sizeof...(I)> get (I... index) const requires(_dim >

const TensorView< T, _dim - sizeof...(I)> _dim sizeof (I)> get(I... index) requires(_dim >

const TensorView< T, _dim - sizeof...(I)> _dim _dim & operator= (TensorView< T, _dim > &value)=delete

inline std::size_t size(std::size_t index = 0) const

inline T *data() const

inline std::size_t *stride() const

inline std::size_t *shape() const

T gather (me_int_t index) const requires(_dim

Public Members

std::size_t *_stride

std::size_t *_shape

Public Static Attributes

static const int dim = _dim

class ThreadPool

Public Types

using JobFunc = std::function<std::size_t()>

Public Functions

ThreadPool(int thread_count = -1)

~ThreadPool()

ThreadPool(const ThreadPool&) = delete

ThreadPool &operator=(const ThreadPool&) = delete

void set_thread_count(int new_count)

inline std::size_t thread_count() const

void submit(JobFunc job)

void submit(std::vector<JobFunc> &jobs)

std::optional<std::size_t> wait()

std::vector<std::size_t> wait_multiple()

std::size_t add_listener(std::function<void(std::size_t)> listener)

void remove_listener(std::size_t id)

Public Static Functions

static inline std::size_t thread_index()

Private Functions

void thread_loop(std::size_t index)

bool fill_done_cache()

Private Members

std::mutex _mutex

std::condition_variable _cv_run

std::condition_variable _cv_done

std::size_t _thread_count

std::vector<std::thread> _threads

std::deque<JobFunc> _job_queue

std::deque<std::size_t> _done_queue

std::vector<std::size_t> _done_buffer

std::size_t _busy_threads

std::size_t _listener_id = 0

std::unordered_map<std::size_t, std::function<void(std::size_t)>> _listeners

bool _buffer_submit

Private Static Attributes

static thread_local std::size_t _thread_index = 0

static const std::size_t QUEUE_SIZE_PER_THREAD = 16384

template<typename T>
class ThreadResource

Public Functions

ThreadResource() = default

inline ThreadResource(ThreadPool &pool, std::function<T()> constructor)

inline ~ThreadResource()

inline ThreadResource(ThreadResource &&other) noexcept

inline ThreadResource &operator=(ThreadResource &&other) noexcept

ThreadResource(const ThreadResource&) = delete

ThreadResource &operator=(const ThreadResource&) = delete

inline T &get(std::size_t thread_id)

inline const T &get(std::size_t thread_id) const

Private Members

ThreadPool *_pool = nullptr

std::vector<T> _resources

std::size_t _listener_id

class ThreeBodyDecay : public madevent::Mapping

Public Functions

inline ThreeBodyDecay(bool com)

inline std::size_t random_dim() const

Private Functions

virtual Result build_forward_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions) const override

virtual Result build_inverse_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions) const override

Private Members

bool _com

struct TimingData

Public Members

double wall_time_sec

double cpu_time_sec

class Topology

Public Functions

Topology(const Diagram &diagram)

inline std::size_t t_propagator_count() const

inline const std::vector<std::size_t> &t_integration_order() const

inline const std::vector<double> &t_propagator_masses() const

inline const std::vector<double> &t_propagator_widths() const

inline const std::vector<Decay> &decays() const

inline const std::vector<std::size_t> &decay_integration_order() const

inline const std::vector<std::size_t> &outgoing_indices() const

inline const std::vector<double> &incoming_masses() const

inline const std::vector<double> &outgoing_masses() const

std::vector<std::tuple<std::vector<int>, double, double>> propagator_momentum_terms(bool only_decays = false) const

Public Static Functions

static std::vector<Topology> topologies(const Diagram &diagram)

Private Functions

Topology() = default

Private Members

std::vector<std::size_t> _t_integration_order

std::vector<double> _t_propagator_masses

std::vector<double> _t_propagator_widths

std::vector<Decay> _decays

std::vector<std::size_t> _decay_integration_order

std::vector<std::size_t> _outgoing_indices

std::vector<double> _incoming_masses

std::vector<double> _outgoing_masses

class TPropagatorMapping : public madevent::Mapping

Public Functions

TPropagatorMapping(const std::vector<std::size_t> &integration_order, double invariant_power = 0.8)

inline std::size_t random_dim() const

Private Functions

virtual Result build_forward_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions) const override

virtual Result build_inverse_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions) const override

Private Members

std::vector<std::size_t> _integration_order

std::vector<bool> _sample_sides

Invariant _uniform_invariant

TwoToTwoParticleScattering _com_scattering

TwoToTwoParticleScattering _lab_scattering

class TwoBodyDecay : public madevent::Mapping

Public Functions

inline TwoBodyDecay(bool com)

inline std::size_t random_dim() const

Private Functions

virtual Result build_forward_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions) const override

virtual Result build_inverse_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions) const override

Private Members

bool _com

class TwoToThreeParticleScattering : public madevent::Mapping

Public Functions

inline TwoToThreeParticleScattering(double t_invariant_power = 0, double t_mass = 0, double t_width = 0, double s_invariant_power = 0, double s_mass = 0, double s_width = 0)

Private Functions

virtual Result build_forward_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions) const override

virtual Result build_inverse_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions) const override

Private Members

Invariant _t_invariant

Invariant _s_invariant

class TwoToTwoParticleScattering : public madevent::Mapping

Public Functions

inline TwoToTwoParticleScattering(bool com, double invariant_power = 0, double mass = 0, double width = 0)

Private Functions

virtual Result build_forward_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions) const override

virtual Result build_inverse_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions) const override

Private Members

bool _com

Invariant _invariant

struct Type

Public Functions

inline Type(DataType dtype, BatchSize batch_size, const std::vector<int> &shape)

inline Type(const std::vector<BatchSize> &batch_size_list)

Public Members

DataType dtype

BatchSize batch_size

std::vector<int> shape

std::vector<BatchSize> batch_size_list

template<typename T>
class UnalignedRef

Public Functions

inline UnalignedRef(void *ptr)

inline T value() const

inline operator T() const

inline UnalignedRef<T> operator=(const T &value)

inline UnalignedRef<T> operator=(const UnalignedRef<T> &value)

Private Members

void *_ptr

class UnnamedBody

Public Functions

inline UnnamedBody()

inline bool operator==(const UnnamedBody &other) const

inline bool operator!=(const UnnamedBody &other) const

Private Members

std::size_t id

Private Static Attributes

static std::size_t counter

Friends

friend std::ostream &operator<<(std::ostream &out, const BatchSize &batch_size)

friend void to_json(nlohmann::json &j, const BatchSize &batch_size)

class UnsqueezeInstruction : public madevent::Instruction

Public Functions

inline UnsqueezeInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

class UnstackInstruction : public madevent::Instruction

Public Functions

inline UnstackInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

class UnstackSizesInstruction : public madevent::Instruction

Public Functions

inline UnstackSizesInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

class Unweighter : public madevent::FunctionGenerator

Public Functions

Unweighter(const TypeVec &types)

Private Functions

virtual ValueVec build_function_impl(FunctionBuilder &fb, const ValueVec &args) const override

class UnweightInstruction : public madevent::Instruction

Public Functions

inline UnweightInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

struct Value

Public Functions

inline Value()

inline Value(me_int_t value)

inline Value(double value)

template<ScalarType T>
inline Value(const std::vector<std::vector<T>> &values)

template<ScalarType T>
inline Value(const std::vector<T> &values, const std::vector<int> &shape = {})

inline Value(Type _type, int _local_index)

inline Value(Type _type, LiteralValue _literal_value, int _local_index = -1)

inline operator bool()

Public Members

Type type

LiteralValue literal_value

int local_index = -1

class VegasGridOptimizer

Public Functions

inline VegasGridOptimizer(ContextPtr context, const std::string &grid_name, double damping)

void add_data(Tensor weights, Tensor inputs)

void optimize()

std::size_t input_dim() const

Private Members

ContextPtr _context

std::string _grid_name

double _damping

std::vector<std::tuple<std::vector<std::size_t>, std::vector<double>>> _data

class VegasHistogram : public madevent::FunctionGenerator

Public Functions

VegasHistogram(std::size_t dimension, std::size_t bin_count)

Private Functions

virtual ValueVec build_function_impl(FunctionBuilder &fb, const ValueVec &args) const override

Private Members

std::size_t _bin_count

class VegasMapping : public madevent::Mapping

Public Functions

inline VegasMapping(std::size_t dimension, std::size_t bin_count, const std::string &prefix = "")

inline const std::string &grid_name() const

void initialize_globals(ContextPtr context) const

inline std::size_t dimension() const

inline std::size_t bin_count() const

Private Functions

virtual Result build_forward_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions) const override

virtual Result build_inverse_impl(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions) const override

Private Members

std::size_t _dimension

std::size_t _bin_count

std::string _grid_name

template<std::ranges::viewable_range... Rng>
class zip_iterator

Public Types

using value_type = std::tuple<std::ranges::range_reference_t<Rng>...>

Public Functions

zip_iterator() = delete

inline zip_iterator(std::ranges::iterator_t<Rng>&&... iters)

inline zip_iterator &operator++()

inline zip_iterator operator++(int)

inline bool operator!=(const zip_iterator &other) const

inline bool operator==(const zip_iterator &other) const

inline value_type operator*()

Private Members

std::tuple<std::ranges::iterator_t<Rng>...> _iters

template<std::ranges::viewable_range... T>
class zipper

Public Types

using zip_type = zip_iterator<T...>

Public Functions

template<typename ...Args>
inline zipper(Args&&... args)

inline zip_type begin()

inline zip_type end()

Private Members

std::tuple<T...> _args

namespace madevent

Typedefs

using InstructionOwner = std::unique_ptr<const Instruction>

using InstructionPtr = Instruction const*

using me_int_t = int

using TypeVec = std::vector<Type>

using TensorValue = std::tuple<std::vector<int>, std::variant<std::vector<me_int_t>, std::vector<double>>>

using LiteralValue = std::variant<me_int_t, double, TensorValue, std::monostate>

using ValueVec = std::vector<Value>

using ContextPtr = std::shared_ptr<Context>

using FieldLayout = std::pair<const char*, const char*>

using EventWeightRecord = EventRecord<record_weight>

using EventIndicesRecord = EventRecord<record_indices>

using EventFullRecord = EventRecord<record_weight | record_subproc_index | record_indices>

using RuntimePtr = std::unique_ptr<Runtime>

using SizeVec = std::vector<std::size_t>

using DevicePtr = const Device*

using TensorVec = std::vector<Tensor>

template<typename T>
using nested_vector2 = std::vector<std::vector<T>>

template<typename T>
using nested_vector3 = std::vector<std::vector<std::vector<T>>>

template<typename T>
using nested_vector4 = std::vector<std::vector<std::vector<std::vector<T>>>>

Enums

enum class DataType

Values:

enumerator dt_int

enumerator dt_float

enumerator batch_sizes

enum class DeviceType

Values:

enumerator cpu

enumerator cuda

enumerator hip

Functions

std::ostream &operator<<(std::ostream &out, const Value &value)

std::ostream &operator<<(std::ostream &out, const ValueVec &list)

std::ostream &operator<<(std::ostream &out, const InstructionCall &call)

std::ostream &operator<<(std::ostream &out, const Function &func)

void to_json(nlohmann::json &j, const InstructionCall &call)

void to_json(nlohmann::json &j, const Function &call)

void from_json(const nlohmann::json &j, Function &call)

const std::unordered_map<std::string, InstructionOwner> build_instruction_set()

void to_json(nlohmann::json &j, const BatchSize &batch_size)

void from_json(const nlohmann::json &j, BatchSize &batch_size)

std::ostream &operator<<(std::ostream &out, const BatchSize &batch_size)

std::ostream &operator<<(std::ostream &out, const DataType &dtype)

std::ostream &operator<<(std::ostream &out, const Type &type)

inline bool operator==(const Type &lhs, const Type &rhs)

inline bool operator!=(const Type &lhs, const Type &rhs)

inline Type single_float_array(int count)

inline Type single_int_array(int count)

inline Type single_float_array_2d(int count1, int count2)

inline Type single_int_array_2d(int count1, int count2)

Type multichannel_batch_size(int count)

inline Type batch_float_array(int count)

inline Type batch_four_vec_array(int count)

void to_json(nlohmann::json &j, const DataType &dtype)

void to_json(nlohmann::json &j, const Value &value)

void from_json(const nlohmann::json &j, DataType &dtype)

void from_json(const nlohmann::json &j, Value &dtype)

void initialize_uniform_probs(ContextPtr context, const std::string &name, std::size_t option_count)

std::ostream &operator<<(std::ostream &out, const Diagram::LineRef &value)

void initialize_vegas_grid(ContextPtr context, const std::string &grid_name)

ContextPtr default_context()

ContextPtr default_cuda_context()

ContextPtr default_hip_context()

ContextPtr default_device_context(DevicePtr device)

inline std::string prefixed_name(const std::string &prefix, const std::string &name)

void to_json(nlohmann::json &j, const EventGenerator::TimingData &timing_data)

void to_json(nlohmann::json &j, const EventGenerator::Status &status)

void to_json(nlohmann::json &j, const EventGenerator::Histogram &hist)

std::string format_si_prefix(double value)

std::string format_with_error(double value, double error)

std::string format_progress(double progress, int width)

Tensor load_tensor(const std::string &file)

void save_tensor(const std::string &file, Tensor tensor)

RuntimePtr build_runtime(const Function &function, ContextPtr context, bool concurrent = true)

DevicePtr cpu_device()

DevicePtr cuda_device()

DevicePtr hip_device()

void set_lib_path(const std::string &lib_path)

void set_simd_vector_size(int vector_size)

inline bool operator==(const Sizes &a, const Sizes &b)

inline bool operator!=(const Sizes &a, const Sizes &b)

inline ThreadPool &default_thread_pool()

template<class ...Ts>
Overloaded(Ts...) -> Overloaded<Ts...>

template<std::ranges::viewable_range... T>
auto zip(T&&... t)

template<typename ...Args>
inline void print(std::format_string<Args...> fmt, Args&&... args)

template<typename ...Args>
inline void print(std::FILE *stream, std::format_string<Args...> fmt, Args&&... args)

template<typename ...Args>
inline void println(std::format_string<Args...> fmt, Args&&... args)

template<typename ...Args>
inline void println(std::FILE *stream, std::format_string<Args...> fmt, Args&&... args)

Variables

constexpr double PI = 3.14159265358979323846

constexpr double LOG_TWO = 0.69314718055994530942

constexpr double SQRT_HALF = 0.70710678118654752440

constexpr double TWO_DIV_SQRT_PI = 1.12837916709551257390

constexpr double MIN_BIN_SIZE = 1e-3

constexpr double MIN_DERIVATIVE = 1e-3

const std::unordered_map<std::string, InstructionOwner> instruction_set = build_instruction_set()

template<typename T> concept ScalarType   = std::same_as<T, me_int_t> || std::same_as<T, double>

const Type single_float = {DataType::dt_float, BatchSize::One{}, {}}

const Type single_int = {DataType::dt_int, BatchSize::One{}, {}}

const BatchSize batch_size = BatchSize("batch_size")

const Type batch_float = {DataType::dt_float, batch_size, {}}

const Type batch_int = {DataType::dt_int, batch_size, {}}

const Type batch_four_vec = {DataType::dt_float, batch_size, {4}}

constexpr int record_weight = 1

constexpr int record_subproc_index = 2

constexpr int record_indices = 4

namespace detail

Functions

inline void print_impl(std::FILE *stream, bool new_line, std::string_view fmt, std::format_args args)

template<typename ...Args, std::size_t... Index>
bool any_match_impl(const std::tuple<Args...> &lhs, const std::tuple<Args...> &rhs, std::index_sequence<Index...>)

template<typename ...Args>
bool any_match(const std::tuple<Args...> &lhs, const std::tuple<Args...> &rhs)

namespace opcodes

Enums

enum Opcode

Values:

file constants.h

file madcode.h

#include “madcode/function.h”

#include “madcode/instruction.h”

#include “madcode/optimizer.h”

#include “madcode/type.h”

file function.h

#include <iostream>

#include <map>

#include <optional>

#include <string>

#include <vector>

#include <nlohmann/json.hpp>

#include “instruction.h”

#include “function_builder_mixin.h”

file instruction.h

#include <initializer_list>

#include <map>

#include <memory>

#include <string>

#include <tuple>

#include <unordered_map>

#include <variant>

#include <vector>

#include “type.h”

#include “opcode_mixin.h”

file optimizer.h

#include “madevent/madcode/function.h”

#include <vector>

file type.h

#include <iostream>

#include <string>

#include <unordered_map>

#include <variant>

#include <vector>

#include <nlohmann/json.hpp>

file base.h

#include “madevent/madcode.h”

file channel_weight_network.h

#include “madevent/phasespace/base.h”

#include “madevent/phasespace/mlp.h”

file channel_weights.h

#include “madevent/phasespace/base.h”

#include “madevent/phasespace/topology.h”

#include “madevent/util.h”

file chili.h

#include “madevent/phasespace/base.h”

#include <vector>

file cross_section.h

#include “madevent/phasespace/matrix_element.h”

#include “madevent/phasespace/pdf.h”

#include “madevent/phasespace/scale.h”

file cuts.h

#include “madevent/madcode.h”

#include “madevent/phasespace/base.h”

#include “madevent/phasespace/observable.h”

#include <vector>

file discrete_flow.h

#include “madevent/phasespace/base.h”

#include “madevent/phasespace/mlp.h”

file discrete_sampler.h

#include “madevent/phasespace/base.h”

#include “madevent/runtime/context.h”

file flow.h

#include “madevent/phasespace/base.h”

#include “madevent/phasespace/mlp.h”

file histograms.h

#include “madevent/phasespace/base.h”

#include “madevent/phasespace/observable.h”

file integrand.h

#include “madevent/phasespace/channel_weight_network.h”

#include “madevent/phasespace/channel_weights.h”

#include “madevent/phasespace/cross_section.h”

#include “madevent/phasespace/discrete_flow.h”

#include “madevent/phasespace/discrete_sampler.h”

#include “madevent/phasespace/flow.h”

#include “madevent/phasespace/matrix_element.h”

#include “madevent/phasespace/pdf.h”

#include “madevent/phasespace/phasespace.h”

#include “madevent/phasespace/vegas.h”

#include “madevent/util.h”

file invariants.h

#include “madevent/phasespace/base.h”

file luminosity.h

#include “madevent/phasespace/base.h”

#include “madevent/phasespace/invariants.h”

file matrix_element.h

#include “madevent/phasespace/base.h”

#include “madevent/runtime/context.h”

file mlp.h

#include “madevent/phasespace/base.h”

#include “madevent/runtime/context.h”

file multichannel.h

#include <format>

#include <vector>

#include “madevent/phasespace/base.h”

#include “madevent/phasespace/phasespace.h”

file observable.h

#include “madevent/madcode.h”

#include “madevent/phasespace/base.h”

#include “madevent/util.h”

#include <vector>

file pdf.h

#include “madevent/phasespace/base.h”

#include “madevent/runtime/context.h”

file phasespace.h

#include “madevent/phasespace/base.h”

#include “madevent/phasespace/chili.h”

#include “madevent/phasespace/cuts.h”

#include “madevent/phasespace/invariants.h”

#include “madevent/phasespace/luminosity.h”

#include “madevent/phasespace/rambo.h”

#include “madevent/phasespace/t_propagator_mapping.h”

#include “madevent/phasespace/three_particle.h”

#include “madevent/phasespace/topology.h”

file phasespace.h

#include “phasespace/base.h”

#include “phasespace/channel_weight_network.h”

#include “phasespace/channel_weights.h”

#include “phasespace/cross_section.h”

#include “phasespace/cuts.h”

#include “phasespace/discrete_flow.h”

#include “phasespace/discrete_sampler.h”

#include “phasespace/flow.h”

#include “phasespace/histograms.h”

#include “phasespace/integrand.h”

#include “phasespace/invariants.h”

#include “phasespace/luminosity.h”

#include “phasespace/matrix_element.h”

#include “phasespace/mlp.h”

#include “phasespace/multichannel.h”

#include “phasespace/observable.h”

#include “phasespace/pdf.h”

#include “phasespace/phasespace.h”

#include “phasespace/rambo.h”

#include “phasespace/scale.h”

#include “phasespace/t_propagator_mapping.h”

#include “phasespace/three_particle.h”

#include “phasespace/topology.h”

#include “phasespace/two_particle.h”

#include “phasespace/vegas.h”

file rambo.h

#include “madevent/phasespace/base.h”

file scale.h

#include “madevent/phasespace/base.h”

file t_propagator_mapping.h

#include <vector>

#include “madevent/phasespace/base.h”

#include “madevent/phasespace/invariants.h”

#include “madevent/phasespace/topology.h”

#include “madevent/phasespace/two_particle.h”

file three_particle.h

#include “madevent/phasespace/base.h”

#include “madevent/phasespace/invariants.h”

file topology.h

#include <array>

#include <ostream>

#include <string>

#include <vector>

file two_particle.h

#include “madevent/phasespace/base.h”

#include “madevent/phasespace/invariants.h”

file vegas.h

#include “madevent/phasespace/base.h”

#include “madevent/runtime/context.h”

file runtime.h

#include “runtime/context.h”

#include “runtime/discrete_optimizer.h”

#include “runtime/event_generator.h”

#include “runtime/format.h”

#include “runtime/io.h”

#include “runtime/lhe_output.h”

#include “runtime/logger.h”

#include “runtime/tensor.h”

#include “runtime/thread_pool.h”

#include “runtime/vegas_optimizer.h”

file context.h

#include <stdint.h>

#include <unordered_map>

#include “madevent/madcode.h”

#include “madevent/runtime/tensor.h”

#include “madevent/runtime/thread_pool.h”

#include “madevent/umami.h”

file discrete_optimizer.h

#include “madevent/madcode.h”

#include “madevent/runtime/context.h”

#include “madevent/runtime/tensor.h”

file event_generator.h

#include <chrono>

#include <optional>

#include <random>

#include <vector>

#include <nlohmann/json.hpp>

#include “madevent/madcode.h”

#include “madevent/phasespace.h”

#include “madevent/runtime/discrete_optimizer.h”

#include “madevent/runtime/format.h”

#include “madevent/runtime/io.h”

#include “madevent/runtime/runtime_base.h”

#include “madevent/runtime/vegas_optimizer.h”

file format.h

#include <stdexcept>

#include <string>

#include <vector>

file io.h

#include <cstring>

#include <fstream>

#include “madevent/runtime/lhe_output.h”

#include “madevent/runtime/tensor.h”

file lhe_output.h

#include <fstream>

#include <random>

#include <string>

#include <unordered_map>

#include <vector>

#include “madevent/phasespace/topology.h”

#include “madevent/runtime/thread_pool.h”

#include “madevent/util.h”

file logger.h

#include <functional>

#include <string>

#include “madevent/util.h”

file runtime_base.h

#include “madevent/madcode.h”

#include “madevent/runtime/context.h”

#include “madevent/runtime/tensor.h”

file tensor.h

#include “madevent/madcode/type.h”

#include “madevent/util.h”

#include <algorithm>

#include <atomic>

#include <concepts>

#include <cstdint>

#include <functional>

#include <initializer_list>

#include <vector>

file thread_pool.h

#include <condition_variable>

#include <deque>

#include <functional>

#include <mutex>

#include <optional>

#include <thread>

#include <vector>

file vegas_optimizer.h

#include “madevent/madcode.h”

#include “madevent/runtime/context.h”

#include “madevent/runtime/tensor.h”

file umami.h

#include <stddef.h>

Typedefs

typedef void *UmamiHandle

Enums

enum UmamiStatus

Values:

enumerator UMAMI_SUCCESS

enumerator UMAMI_ERROR

enumerator UMAMI_ERROR_NOT_IMPLEMENTED

enumerator UMAMI_ERROR_UNSUPPORTED_INPUT

enumerator UMAMI_ERROR_UNSUPPORTED_OUTPUT

enumerator UMAMI_ERROR_UNSUPPORTED_META

enumerator UMAMI_ERROR_MISSING_INPUT

enum UmamiDevice

Values:

enumerator UMAMI_DEVICE_CPU

enumerator UMAMI_DEVICE_CUDA

enumerator UMAMI_DEVICE_HIP

enum UmamiMetaKey

Values:

enumerator UMAMI_META_DEVICE

enumerator UMAMI_META_PARTICLE_COUNT

enumerator UMAMI_META_DIAGRAM_COUNT

enumerator UMAMI_META_HELICITY_COUNT

enumerator UMAMI_META_COLOR_COUNT

enum UmamiInputKey

Values:

enumerator UMAMI_IN_MOMENTA

enumerator UMAMI_IN_ALPHA_S

enumerator UMAMI_IN_FLAVOR_INDEX

enumerator UMAMI_IN_RANDOM_COLOR

enumerator UMAMI_IN_RANDOM_HELICITY

enumerator UMAMI_IN_RANDOM_DIAGRAM

enumerator UMAMI_IN_HELICITY_INDEX

enumerator UMAMI_IN_DIAGRAM_INDEX

enumerator UMAMI_IN_GPU_STREAM

enum UmamiOutputKey

Values:

enumerator UMAMI_OUT_MATRIX_ELEMENT

enumerator UMAMI_OUT_DIAGRAM_AMP2

enumerator UMAMI_OUT_COLOR_INDEX

enumerator UMAMI_OUT_HELICITY_INDEX

enumerator UMAMI_OUT_DIAGRAM_INDEX

Functions

UmamiStatus umami_get_meta(UmamiMetaKey meta_key, void *result)

Creates an instance of the matrix element. Each instance is independent, so thread safety can be achieved by creating a separate one for every thread.

Parameters:

• meta_key – path to the parameter file

• handle – pointer to an instance of the subprocess. Has to be cleaned up by the caller with free_subprocess.

Returns:

UMAMI_SUCCESS on success, error code otherwise

UmamiStatus umami_initialize(UmamiHandle *handle, char const *param_card_path)

Creates an instance of the matrix element. Each instance is independent, so thread safety can be achieved by creating a separate one for every thread.

Parameters:

• param_card_path – path to the parameter file

• handle – pointer to an instance of the subprocess. Has to be cleaned up by the caller with free_subprocess.

Returns:

UMAMI_SUCCESS on success, error code otherwise

UmamiStatus umami_set_parameter(UmamiHandle handle, char const *name, double parameter_real, double parameter_imag)

Sets the value of a model parameter

Parameters:

• handle – handle of a matrix element instance

• name – name of the parameter

• parameter_real – real part of the parameter value

• parameter_imag – imaginary part of the parameter value. Ignored for real valued parameters.

Returns:

UMAMI_SUCCESS on success, error code otherwise

UmamiStatus umami_get_parameter(UmamiHandle handle, char const *name, double *parameter_real, double *parameter_imag)

Retrieves the value of a model parameter

Parameters:

• handle – handle of a matrix element instance

• name – name of the parameter

• parameter_real – pointer to double to return real part of the parameter value

• parameter_imag – pointer to double to return imaginary part of the parameter value. Ignored for real-valued parameters (i.e. you may pass a null pointer)

Returns:

UMAMI_SUCCESS on success, error code otherwise

UmamiStatus umami_matrix_element(UmamiHandle handle, size_t count, size_t stride, size_t offset, size_t input_count, UmamiInputKey const *input_keys, void const *const *inputs, size_t output_count, UmamiOutputKey const *output_keys, void *const *outputs)

Evaluates the matrix element as a function of the given inputs, filling the requested outputs.

Parameters:

• handle – handle of a matrix element instance

• count – number of events to evaluate the matrix element for

• stride – stride of the batch dimension of the input and output arrays, see memory layout

• offset – offset of the event index

• input_count – number of inputs to the matrix element

• input_keys – pointer to an array of input keys, length input_count

• inputs – pointer to an array of void pointers to the inputs. The type of the inputs depends on the input key

• output_count – number of outputs to the matrix element

• output_keys – pointer to an array of output keys, length output_count

• outputs – pointer to an array of void pointers to the outputs. The type of the outputs depends on the output key. The caller is responsible for allocating memory for the outputs.

Returns:

UMAMI_SUCCESS on success, error code otherwise

UmamiStatus umami_free(UmamiHandle handle)

Frees matrix element instance

Parameters:

handle – handle of a matrix element instance

Variables

const int UMAMI_MAJOR_VERSION = 1

Major version number of the UMAMI interface. If the major version is the same between caller and implementation, binary compatibility is ensured.

const int UMAMI_MINOR_VERSION = 0

Minor version number of the UMAMI interface. Between minor versions, new keys for errors, devices, metadata, inputs and outputs can be added.

file util.h

#include <cstdio>

#include <format>

#include <ranges>

#include <tuple>

#include <vector>

dir /home/docs/checkouts/readthedocs.org/user_builds/madevent7/checkouts/stable/include

dir /home/docs/checkouts/readthedocs.org/user_builds/madevent7/checkouts/stable/include/madevent/madcode

dir /home/docs/checkouts/readthedocs.org/user_builds/madevent7/checkouts/stable/include/madevent

dir /home/docs/checkouts/readthedocs.org/user_builds/madevent7/checkouts/stable/include/madevent/phasespace

dir /home/docs/checkouts/readthedocs.org/user_builds/madevent7/checkouts/stable/include/madevent/runtime