C++ API

class AcceptNormInstruction : public madspace::Instruction

Public Functions

inline AcceptNormInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

class AdamOptimizer

Public Types

enum LRSchedule

Values:

enumerator none

enumerator cosine

Public Functions

AdamOptimizer(const Function &function, ContextPtr context, double learning_rate, LRSchedule schedule = LRSchedule::none, std::size_t step_count = 0, double beta1 = 0.9, double beta2 = 0.999, double eps = 1e-8)

TensorVec step(const TensorVec &inputs)

void replace_function(const Function &function)

double learning_rate() const

inline const TypeVec &input_types() const

inline ContextPtr context() const

inline Tensor parameters() const

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

Private Members

ContextPtr _context

RuntimePtr _runtime

LRSchedule _schedule

double _learning_rate

std::size_t _step

std::size_t _step_count

double _beta1

double _beta2

double _eps

Tensor _one

Tensor _parameter

Tensor _exp_avg

Tensor _exp_avg_sq

TypeVec _input_types

std::vector<std::string> _param_names

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 madspace::Instruction

Public Functions

inline BatchCatInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

class BatchGatherInstruction : public madspace::Instruction

Public Functions

inline BatchGatherInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

class BatchScatterInstruction : public madspace::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::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

std::string to_string() 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 madspace::Instruction

Public Functions

inline BatchSizeInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

class BatchSplitInstruction : public madspace::Instruction

Public Functions

inline BatchSplitInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

class CatInstruction : public madspace::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 ChannelData

Public Members

std::size_t index

std::vector<std::unique_ptr<SampleBatch>> sample_batches

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

std::size_t history_index = 0

std::size_t sample_count = 0

std::shared_ptr<Integrand> integrand

std::shared_ptr<IntegrandProbability> integrand_prob

RuntimePtr generator_runtime

SampleBatch buffer

class ChannelEventGenerator

Public Functions

ChannelEventGenerator(const std::vector<ContextPtr> &contexts, const Integrand &integrand, const std::string &event_file, const std::string &weight_file, const GeneratorConfig &config, std::size_t subprocess_index, const std::string &name, const std::optional<ObservableHistograms> &histograms)

inline const GeneratorStatus &status() const

inline const RunningIntegral &cross_section() const

inline const std::vector<Histogram> &histograms() const

inline EventFile &event_file()

inline EventFile &weight_file()

inline std::size_t max_weight() const

inline std::size_t batch_size() const

inline bool needs_optimization() const

inline void set_target_count(double target_count)

inline const std::unordered_set<std::string> &used_globals() const

void unweight_file(std::mt19937 &rand_gen)

void integrate(const GeneratorBatchJob &job)

void optimize_vegas(const GeneratorBatchJob &job)

double channel_weight_sum(std::size_t event_count)

void start_job(GeneratorBatchJob &job, ResultQueue &result_queue)

void start_unweight_job(GeneratorBatchJob &job, ResultQueue &result_queue)

std::size_t next_vegas_batch_size()

void clear_events()

void update_max_weight(Tensor weights)

void write_events(const TensorVec &unweighted_events, double job_max_weight)

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

Public Static Functions

static ChannelEventGenerator load(const std::string &channel_file, const std::vector<ContextPtr> &contexts, const std::string &event_file, const std::string &weight_file, const GeneratorConfig &config)

Public Static Attributes

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

Private Functions

ChannelEventGenerator(const std::vector<ContextPtr> &contexts, std::size_t particle_count, const Function &integrand_function, const Function &unweighter_function, const std::optional<Function> &histogram_function, const std::string &event_file, const std::string &weight_file, std::size_t subprocess_index, const std::string &name, const GeneratorConfig &config, const std::vector<Histogram> &histograms)

Private Members

GeneratorStatus _status

GeneratorConfig _config

std::vector<ContextPtr> _contexts

std::vector<ContextRuntimes> _runtimes

EventFile _event_file

EventFile _weight_file

std::optional<VegasGridOptimizer> _vegas_optimizer

std::optional<DiscreteOptimizer> _discrete_optimizer

std::size_t _batch_size

std::size_t _particle_count

Function _integrand_function

Function _unweighter_function

std::optional<Function> _histogram_function

RunningIntegral _cross_section

double _max_weight = 0.

std::size_t _unweighted_count = 0

std::size_t _iters_without_improvement = 0

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

std::vector<double> _large_weights

std::vector<Histogram> _histograms

std::unordered_set<std::string> _used_globals

Friends

friend void to_json(nlohmann::json &j, const ChannelEventGenerator &channel)

struct ChannelResult

Public Functions

inline Value &r()

inline Value &latent()

inline Value &momenta()

inline Value &momenta_mirror()

inline Value &momenta_acc()

inline Value &x(std::size_t pdf_index)

inline Value &x_acc(std::size_t pdf_index)

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 &pdf_cache(std::size_t pdf_index)

inline Value &scale_cache()

Public Members

std::array<Value, 21> values

class ChannelWeightNetwork : public madspace::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 = "", bool include_preprocessing = true)

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 NamedVector<Value> build_function_impl(FunctionBuilder &fb, const NamedVector<Value> &args) const override

Private Members

MomentumPreprocessing _preprocessing

MLP _mlp

std::size_t _channel_count

std::string _mask_name

class ChiliMapping : public madspace::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 NamedVector<Value> &inputs, const NamedVector<Value> &conditions) const override

virtual Result build_inverse_impl(FunctionBuilder &fb, const NamedVector<Value> &inputs, const NamedVector<Value> &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

Verbosity verbosity = Verbosity::log

double learning_rate = 1e-3

std::size_t batches = 1000

std::size_t log_interval = 100

std::size_t integration_history_length = 1000

std::size_t channel_dropping_interval = 100

double channel_dropping_threshold = 0.01

std::size_t cpu_generator_batch_size = 1000

std::size_t gpu_generator_batch_size = 64000

std::size_t gpu_generator_batch_granularity = 1000

std::size_t generator_target_size_factor = 32

std::size_t batch_size_offset = 512

std::size_t batch_size_per_channel = 128

double uniform_channel_ratio = 0.1

AdamOptimizer::LRSchedule lr_schedule = AdamOptimizer::none

double adam_beta1 = 0.9

double adam_beta2 = 0.999

double adam_eps = 1e-8

std::size_t buffer_capacity = 0

std::size_t minimum_buffer_size = 10000

std::size_t buffered_steps = 0

double buffer_unweighting_quantile = 0.99

double fixed_cwnet_fraction = 0.33

double softclip_threshold = 0.0

class Context

Public Functions

inline Context(int thread_count = -1)

Contains global variables and matrix elements

inline Context(DevicePtr device, int thread_count = -1)

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)

void set_global_requires_grad(const std::string &name, bool value)

bool global_exists(const std::string &name)

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

void delete_global(const std::string &name)

void copy_globals_from(Context &context)

Tensor reallocate_globals_contiguously(const std::vector<std::string> &names)

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

void save_globals(const std::string &dir) const

void load_globals(const std::string &dir)

inline DevicePtr device()

inline ThreadPool &thread_pool()

Private Members

DevicePtr _device

std::unique_ptr<ThreadPool> _thread_pool

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

std::vector<std::unique_ptr<MatrixElementApi>> _matrix_elements

std::vector<std::string> _param_card_paths

struct ContextRuntimes

Public Members

RuntimePtr integrand = nullptr

RuntimePtr unweighter = nullptr

RuntimePtr vegas_histogram = nullptr

RuntimePtr discrete_histogram = nullptr

RuntimePtr observable_histograms = nullptr

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 madspace::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 NamedVector<Value> build_function_impl(FunctionBuilder &fb, const NamedVector<Value> &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 std::pair<void*, Tensor> allocate(std::size_t size, AllocHint hint) 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

virtual void activate() const = 0

virtual void adam_step(const Tensor &gradient, Tensor &parameter, Tensor &exp_avg, Tensor &exp_avg_sq, double step_size, double beta1, double beta2, double eps, double bias_corr2_sqrt) 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 madspace::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 bool has_pdf(std::size_t pdf_index) const

inline const MatrixElement &matrix_element() const

Private Functions

virtual NamedVector<Value> build_function_impl(FunctionBuilder &fb, const NamedVector<Value> &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 madspace::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 NamedVector<Value> &inputs, const NamedVector<Value> &conditions) const override

virtual Result build_inverse_impl(FunctionBuilder &fb, const NamedVector<Value> &inputs, const NamedVector<Value> &conditions) const override

Result build_transform(FunctionBuilder &fb, const NamedVector<Value> &inputs, const NamedVector<Value> &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 madspace::FunctionGenerator

Public Functions

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

Private Functions

virtual NamedVector<Value> build_function_impl(FunctionBuilder &fb, const NamedVector<Value> &args) const override

Private Members

std::vector<std::size_t> _option_counts

class DiscreteOptimizer

Public Functions

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

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

void optimize()

Private Members

std::vector<ContextPtr> _contexts

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 madspace::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 NamedVector<Value> &inputs, const NamedVector<Value> &conditions) const override

virtual Result build_inverse_impl(FunctionBuilder &fb, const NamedVector<Value> &inputs, const NamedVector<Value> &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 madspace::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 NamedVector<Value> build_function_impl(FunctionBuilder &fb, const NamedVector<Value> &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 Functions

EventGenerator(const std::vector<ContextPtr> &contexts, const std::vector<std::shared_ptr<ChannelEventGenerator>> &channels, const std::string &status_file = "", const GeneratorConfig &config = default_config)

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 GeneratorStatus status() const

std::vector<GeneratorStatus> channel_status() const

std::vector<Histogram> histograms() const

std::unordered_set<std::string> used_globals() const

inline const std::vector<std::shared_ptr<ChannelEventGenerator>> &channels() const

Public Static Functions

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

Public Static Attributes

static const GeneratorConfig default_config

Private Functions

bool start_jobs()

void update_integral()

void update_counts()

void reset_start_time()

void add_timing_data(const std::string &key)

void unweight_all()

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, std::mt19937 &rand_gen)

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_event_count, std::size_t total_event_count, std::size_t iter)

void print_survey_update_pretty(bool done, std::size_t done_event_count, std::size_t total_event_count, std::size_t iter)

void print_survey_update_log(bool done, std::size_t done_event_count, std::size_t total_event_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

GeneratorConfig _config

std::vector<std::shared_ptr<ChannelEventGenerator>> _channels

GeneratorStatus _status

std::vector<ContextPtr> _contexts

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

std::vector<GeneratorBatchJob> _ready_jobs

std::size_t _job_id

std::vector<std::size_t> _channel_job_counts

std::vector<bool> _channel_optimizing

std::vector<double> _channel_integral_fractions

std::vector<std::size_t> _context_job_counts

ResultQueue _result_queue

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

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 madspace::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 NamedVector<Value> &inputs, const NamedVector<Value> &conditions) const override

virtual Result build_inverse_impl(FunctionBuilder &fb, const NamedVector<Value> &inputs, const NamedVector<Value> &conditions) const override

Private Members

std::size_t _n_particles

bool _massless

double _com

class Flow : public madspace::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 NamedVector<Value> &inputs, const NamedVector<Value> &conditions) const override

virtual Result build_inverse_impl(FunctionBuilder &fb, const NamedVector<Value> &inputs, const NamedVector<Value> &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 madspace::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 NamedVector<Value> &inputs() const

inline const NamedVector<Value> &outputs() const

inline const ValueVec &locals() const

inline const std::vector<std::pair<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 NamedVector<Value> &inputs, const NamedVector<Value> &outputs, const ValueVec &locals, const std::vector<std::pair<std::string, Value>> &globals, const std::vector<InstructionCall> &instructions)

Private Members

NamedVector<Value> _inputs

NamedVector<Value> _outputs

ValueVec _locals

std::vector<std::pair<std::string, Value>> _globals

std::vector<InstructionCall> _instructions

Friends

friend class FunctionBuilder

friend Function sort_breadth_first(const Function &function)

class FunctionBuilder

Public Functions

FunctionBuilder(const NamedVector<Type> &_input_types, const NamedVector<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)

inline std::size_t current_stream() const

inline void set_current_stream(std::size_t stream_index)

Function function()

Value sum(const ValueVec &values)

Value product(const ValueVec &values)

Private Functions

void register_local(Value &val)

Private Members

NamedVector<Type> _output_types

NamedVector<Value> _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<std::size_t> _instruction_use_count

std::size_t _current_stream

class FunctionGenerator

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

Public Functions

inline FunctionGenerator(const std::string &name, const NamedVector<Type> &arg_types, const NamedVector<Type> &return_types)

virtual ~FunctionGenerator() = default

NamedVector<Value> build_function(FunctionBuilder &fb, const NamedVector<Value> &args) const

inline NamedVector<Value> build_function(FunctionBuilder &fb, const ValueVec &args) const

Function function() const

inline const NamedVector<Type> &arg_types() const

inline const NamedVector<Type> &return_types() const

inline const std::string &name() const

Protected Functions

virtual NamedVector<Value> build_function_impl(FunctionBuilder &fb, const NamedVector<Value> &args) const = 0

Private Members

std::string _name

NamedVector<Type> _arg_types

NamedVector<Type> _return_types

struct GeneratorBatchJob

Public Members

std::size_t channel_index

bool unweight

std::size_t vegas_batch_size

std::size_t split_job_count

Tensor weights

TensorVec events

TensorVec unweighted_events

TensorVec hists

TensorVec vegas_hist

TensorVec discrete_hist

std::size_t context_index

std::size_t job_id

double max_weight

struct GeneratorConfig

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 cpu_batch_size = 1000

std::size_t gpu_batch_size = 64000

Verbosity verbosity = Verbosity::silent

bool write_live_data = false

int combine_thread_count = -1

struct GeneratorStatus

Public Members

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

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 madspace::AcceptNormInstruction, madspace::BatchCatInstruction, madspace::BatchGatherInstruction, madspace::BatchScatterInstruction, madspace::BatchSizeInstruction, madspace::BatchSplitInstruction, madspace::CatInstruction, madspace::FullInstruction, madspace::MatrixElementInstruction, madspace::NonzeroInstruction, madspace::OffsetIndicesInstruction, madspace::RandomInstruction, madspace::RqsReshapeInstruction, madspace::SimpleInstruction, madspace::SqueezeInstruction, madspace::StackInstruction, madspace::StackSizesInstruction, madspace::UnsqueezeInstruction, madspace::UnstackInstruction, madspace::UnstackSizesInstruction, madspace::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

std::size_t stream_index

class InstructionDependencies

Public Functions

InstructionDependencies(const Function &function)

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

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

Private Members

std::size_t _size

std::vector<bool> _matrix

std::vector<int> _ranks

class Integrand : public madspace::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 = {}, const std::vector<std::size_t> &flavor_remap = {}, const std::vector<double> &flavor_factors = {})

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

inline const std::vector<me_int_t> &channel_indices() 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 int exclude_adaptive_and_chan_weight = 4096

static const int drop_cuts_and_rescale = 8192

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 NamedVector<Value> build_function_impl(FunctionBuilder &fb, const NamedVector<Value> &args) const override

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

Value scatter_or_drop(FunctionBuilder &fb, ChannelResult &result, Value default_value, Value value) const

Value optional_cut(FunctionBuilder &fb, ChannelResult &result, Value value) const

NamedVector<Value> 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::array<std::optional<PartonDensity>, 2> _pdfs

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

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

std::vector<me_int_t> _flavor_remap

std::vector<double> _flavor_factors

Friends

friend class IntegrandProbability

friend class MultiChannelIntegrand

class IntegrandProbability : public madspace::FunctionGenerator

Public Functions

IntegrandProbability(const Integrand &integrand)

Private Functions

virtual NamedVector<Value> build_function_impl(FunctionBuilder &fb, const NamedVector<Value> &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 madspace::Mapping

Public Functions

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

Private Functions

virtual Result build_forward_impl(FunctionBuilder &fb, const NamedVector<Value> &inputs, const NamedVector<Value> &conditions) const override

virtual Result build_inverse_impl(FunctionBuilder &fb, const NamedVector<Value> &inputs, const NamedVector<Value> &conditions) const override

Private Members

double _power

double _mass

double _width

class LastUseOfLocals

Public Functions

LastUseOfLocals(const Function &function)

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

Private Members

std::vector<std::vector<std::size_t>> _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, std::mt19937 &rand_gen)

inline std::size_t max_particle_count() const

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

Public Static Functions

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

Private Functions

LHECompleter() = default

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

Friends

friend void to_json(nlohmann::json &j, const LHECompleter &lhe_completer)

friend void from_json(const nlohmann::json &j, LHECompleter &lhe_completer)

friend void to_json(nlohmann::json &j, const LHECompleter::SubprocData &subproc_data)

friend void from_json(const nlohmann::json &j, LHECompleter::SubprocData &subproc_data)

friend void to_json(nlohmann::json &j, const LHECompleter::PropagatorData &prop_data)

friend void from_json(const nlohmann::json &j, LHECompleter::PropagatorData &prop_data)

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 madspace::Mapping

Public Functions

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 NamedVector<Value> &inputs, const NamedVector<Value> &conditions) const override

virtual Result build_inverse_impl(FunctionBuilder &fb, const NamedVector<Value> &inputs, const NamedVector<Value> &conditions) const override

Private Members

double _s_lab

double _s_hat_min

double _s_hat_max

Invariant _invariant

class MadnisLoss : public madspace::FunctionGenerator

Public Functions

MadnisLoss(const std::vector<std::shared_ptr<FunctionGenerator>> &functions, const std::optional<ChannelWeightNetwork> &cwnet, double softclip_threshold = 0.0)

Private Functions

virtual NamedVector<Value> build_function_impl(FunctionBuilder &fb, const NamedVector<Value> &args) const override

Private Members

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

std::optional<ChannelWeightNetwork> _cwnet

double _softclip_threshold

class MadnisTraining

Public Functions

MadnisTraining(ContextPtr generator_context, ContextPtr optimizer_context, const Config &config, const std::vector<std::shared_ptr<Integrand>> &integrands, const std::optional<ChannelWeightNetwork> &cwnet)

void train_step(std::size_t batch_index)

std::vector<std::size_t> active_channels() const

inline std::size_t active_channel_count() const

double average_loss() const

Public Static Functions

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

Private Functions

void build_runtimes_and_optimizer()

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

void start_generator_jobs(const std::vector<std::size_t> &channel_fractions)

TensorVec permute_tensors(const TensorVec &tensors) const

void start_single_job(std::size_t channel_index, std::size_t batch_size)

void start_multi_job(const std::vector<std::size_t> batch_sizes)

bool check_training_batch(const std::vector<std::size_t> &channel_sizes)

TensorVec build_online_training_batch(const std::vector<size_t> &counts)

TensorVec build_buffered_training_batch(const std::vector<size_t> &counts)

void process_job_results(const std::vector<std::size_t> &job_ids)

void update_history(const TensorVec &results, const std::vector<std::size_t> &counts)

void drop_channels()

void freeze_cwnet()

Private Members

ContextPtr _generator_context

ContextPtr _optimizer_context

std::optional<ChannelWeightNetwork> _cwnet

Config _config

RuntimePtr _multi_channel_generator

std::optional<AdamOptimizer> _optimizer

std::vector<ChannelData> _channels

std::unordered_map<std::size_t, std::unique_ptr<SampleBatch>> _running_jobs

std::vector<double> _loss_history

std::size_t _loss_history_index = 0

std::size_t _job_id = 0

Tensor _generator_params

std::vector<std::size_t> _arg_permutation

bool _buffer_ready = false

Private Static Attributes

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

class Mapping

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

Public Types

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

Public Functions

inline Mapping(const std::string &name, const NamedVector<Type> &input_types, const NamedVector<Type> &output_types, const NamedVector<Type> &condition_types)

virtual ~Mapping() = default

NamedVector<Value> build_forward(FunctionBuilder &fb, const NamedVector<Value> &inputs, const NamedVector<Value> &conditions = {}) const

inline NamedVector<Value> build_forward(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions = {}) const

inline NamedVector<Value> build_inverse(FunctionBuilder &fb, const ValueVec &inputs, const ValueVec &conditions = {}) const

NamedVector<Value> build_inverse(FunctionBuilder &fb, const NamedVector<Value> &inputs, const NamedVector<Value> &conditions = {}) const

Function forward_function() const

Function inverse_function() const

inline const NamedVector<Type> &input_types() const

inline const NamedVector<Type> &output_types() const

inline const NamedVector<Type> &condition_types() const

inline const std::string &name() const

Protected Functions

virtual Result build_forward_impl(FunctionBuilder &fb, const NamedVector<Value> &inputs, const NamedVector<Value> &conditions) const = 0

virtual Result build_inverse_impl(FunctionBuilder &fb, const NamedVector<Value> &inputs, const NamedVector<Value> &conditions) const = 0

Private Members

std::string _name

NamedVector<Type> _input_types

NamedVector<Type> _output_types

NamedVector<Type> _condition_types

class MatrixElement : public madspace::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 NamedVector<Value> build_function_impl(FunctionBuilder &fb, const NamedVector<Value> &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(MatrixElementApi&&) noexcept = default

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

MatrixElementApi(const MatrixElementApi&) = delete

MatrixElementApi &operator=(const MatrixElementApi&) = delete

inline DeviceType device_type() 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() const

Private Types

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

Private Functions

MatrixElementApi(const std::string &file, const std::string &param_card, ThreadPool &thread_pool, DevicePtr device, std::size_t index = 0)

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

Friends

friend class Context

class MatrixElementInstruction : public madspace::Instruction

Public Functions

inline MatrixElementInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

class MLP : public madspace::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

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

Private Functions

virtual NamedVector<Value> build_function_impl(FunctionBuilder &fb, const NamedVector<Value> &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 madspace::FunctionGenerator

Public Functions

MomentumPreprocessing(std::size_t particle_count)

inline std::size_t output_dim() const

Private Functions

virtual NamedVector<Value> build_function_impl(FunctionBuilder &fb, const NamedVector<Value> &args) const override

Private Members

std::size_t _output_dim

class MultiChannelFunction : public madspace::FunctionGenerator

Public Functions

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

Private Functions

virtual NamedVector<Value> build_function_impl(FunctionBuilder &fb, const NamedVector<Value> &args) const override

Private Members

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

class MultiChannelIntegrand : public madspace::FunctionGenerator

Public Functions

MultiChannelIntegrand(const std::vector<std::shared_ptr<Integrand>> &integrands, bool return_sizes = false)

Private Functions

virtual NamedVector<Value> build_function_impl(FunctionBuilder &fb, const NamedVector<Value> &args) const override

Private Members

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

bool _return_sizes

class MultiChannelMapping : public madspace::Mapping

Public Functions

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

Private Functions

Result build_impl(FunctionBuilder &fb, const NamedVector<Value> &inputs, const NamedVector<Value> &conditions, bool inverse) const

inline virtual Result build_forward_impl(FunctionBuilder &fb, const NamedVector<Value> &inputs, const NamedVector<Value> &conditions) const override

inline virtual Result build_inverse_impl(FunctionBuilder &fb, const NamedVector<Value> &inputs, const NamedVector<Value> &conditions) const override

Private Members

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

class MultiMadnisTraining

Public Functions

MultiMadnisTraining(ContextPtr generator_context, ContextPtr optimizer_context, const MadnisTraining::Config &config, const nested_vector2<std::shared_ptr<Integrand>> &integrands, const std::vector<std::optional<ChannelWeightNetwork>> &cwnets)

void train()

nested_vector2<std::size_t> active_channels() const

Private Functions

void print_progress_init()

void print_progress_update(std::size_t subproc_index, std::size_t batch_index, double loss, std::size_t chan_count)

Private Members

MadnisTraining::Config _config

std::vector<MadnisTraining> _subprocesses

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

PrettyBox _pretty_box_upper

PrettyBox _pretty_box_lower

template<typename T>
class NamedVector

Public Functions

NamedVector() = default

inline NamedVector(const std::vector<std::string> &keys, const std::vector<T> &values)

inline NamedVector(const std::initializer_list<std::pair<std::string, T>> &items)

inline NamedVector(const std::vector<std::pair<std::string, T>> &items)

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

inline const std::unordered_map<std::string, std::size_t> &index_map() const

inline std::vector<std::string> keys() const

inline decltype(auto) begin()

inline decltype(auto) begin() const

inline decltype(auto) rbegin()

inline decltype(auto) rbegin() const

inline decltype(auto) end()

inline decltype(auto) end() const

inline decltype(auto) rend()

inline decltype(auto) rend() const

inline decltype(auto) front()

inline decltype(auto) front() const

inline decltype(auto) back()

inline decltype(auto) back() const

inline T &at(std::size_t index)

inline const T &at(std::size_t index) const

inline T &at(const std::string &key)

inline const T &at(const std::string &key) const

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

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

inline T &operator[](const std::string &key)

inline const T &operator[](const std::string &key) const

inline bool empty() const

inline std::size_t size() const

inline void reserve(std::size_t capacity)

inline void push_back(const std::string &key, const T &value)

inline void insert_back(const NamedVector<T> &other)

inline NamedVector<T> sort_like(const std::unordered_map<std::string, std::size_t> &index_map) const

Private Members

std::vector<T> _values

std::unordered_map<std::string, std::size_t> _index_map

class NonzeroInstruction : public madspace::Instruction

Public Functions

inline NonzeroInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

class Observable : public madspace::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 NamedVector<Value> build_function_impl(FunctionBuilder &fb, const NamedVector<Value> &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 madspace::FunctionGenerator

Public Functions

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

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

Private Functions

virtual NamedVector<Value> build_function_impl(FunctionBuilder &fb, const NamedVector<Value> &args) const override

Private Members

std::vector<HistItem> _observables

class OffsetIndicesInstruction : public madspace::Instruction

Public Functions

inline OffsetIndicesInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

template<class ...Ts>
struct Overloaded : public madspace::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 madspace::FunctionGenerator

Public Functions

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

Private Functions

virtual NamedVector<Value> build_function_impl(FunctionBuilder &fb, const NamedVector<Value> &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 madspace::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 NamedVector<Value> &inputs, const NamedVector<Value> &conditions) const override

virtual Result build_inverse_impl(FunctionBuilder &fb, const NamedVector<Value> &inputs, const NamedVector<Value> &conditions) const override

Private Members

Topology _topology

Cuts _cuts

double _pi_factors

double _sqrt_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

nested_vector2<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 madspace::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 NamedVector<Value> build_function_impl(FunctionBuilder &fb, const NamedVector<Value> &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 madspace::Instruction

Public Functions

inline RandomInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

class ResultQueue

Public Functions

void push(std::size_t result)

std::size_t wait()

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

Private Functions

void fill_done_cache()

Private Members

std::mutex _mutex

std::condition_variable _cv

std::deque<std::size_t> _queue

std::vector<std::size_t> _buffer

class RqsReshapeInstruction : public madspace::Instruction

Public Functions

inline RqsReshapeInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

class RunningCoupling : public madspace::FunctionGenerator

Public Functions

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

Private Functions

virtual NamedVector<Value> build_function_impl(FunctionBuilder &fb, const NamedVector<Value> &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

class Runtime

Public Functions

virtual ~Runtime() = default

virtual TensorVec run(const TensorVec &inputs) = 0

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

virtual std::pair<TensorVec, TensorVec> run_backward(const TensorVec &output_grads, const TensorVec &stored_locals, const std::vector<bool> &eval_grad, bool return_contiguous_grads = false) = 0

Private Members

std::shared_ptr<void> shared_lib

Friends

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

struct SampleBatch

Public Members

std::vector<std::size_t> channel_sizes

TensorVec tensors

std::size_t consumed_count = 0

std::size_t size = 0

std::size_t channel_index = 0

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 madspace::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 explicit 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

inline std::size_t product() 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 madspace::Instruction

Public Functions

inline SqueezeInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

class StackInstruction : public madspace::Instruction

Public Functions

inline StackInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

class StackSizesInstruction : public madspace::Instruction

Public Functions

inline StackSizesInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

class SubchannelWeights : public madspace::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 NamedVector<Value> build_function_impl(FunctionBuilder &fb, const NamedVector<Value> &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, AllocHint hint = AllocHint::normal)

inline Tensor(DataType dtype, const Sizes &shape, DevicePtr device, AllocHint hint = AllocHint::normal)

template<typename D>
inline Tensor(DataType dtype, const Sizes &shape, const D &device, AllocHint hint = AllocHint::normal)

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, AllocHint hint = AllocHint::normal)

template<ScalarType T, typename D>
inline Tensor(T value, const D &device, AllocHint hint = AllocHint::normal)

inline Tensor(TensorValue value, DevicePtr device, AllocHint hint = AllocHint::normal)

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 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 reshape(const Sizes &shape) const

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

std::vector<Tensor> split_and_reshape(const std::vector<Sizes> &shapes) const

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, AllocHint hint = AllocHint::normal) const

inline Tensor copy(AllocHint hint = AllocHint::normal) const

inline bool is_contiguous() const

inline std::size_t contiguous_dims() const

template<typename D>
inline Tensor contiguous(const D &device, AllocHint hint = AllocHint::normal) const

inline Tensor contiguous(AllocHint hint = AllocHint::normal) const

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

inline Tensor contiguous(std::size_t batch_size) const

inline bool is_only_reference() const

Private Functions

inline Tensor(TensorImpl *_impl)

std::size_t init_stride()

inline void check_impl() const

template<typename D>
inline void allocate(std::size_t size, const D &device, AllocHint hint)

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 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

static constexpr bool is_scalar_view = false

class ThreadPool

Public Types

using JobFunc = std::function<std::optional<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 = 0

std::size_t _listener_id = 0

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

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, std::optional<std::function<void(T&)>> destructor = std::nullopt)

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()

inline const T &get() const

Private Members

ThreadPool *_pool = nullptr

std::vector<T> _resources

std::size_t _listener_id

std::optional<std::function<void(T&)>> _destructor

class ThreeBodyDecay : public madspace::Mapping

Public Functions

ThreeBodyDecay(bool com)

inline std::size_t random_dim() const

Private Functions

virtual Result build_forward_impl(FunctionBuilder &fb, const NamedVector<Value> &inputs, const NamedVector<Value> &conditions) const override

virtual Result build_inverse_impl(FunctionBuilder &fb, const NamedVector<Value> &inputs, const NamedVector<Value> &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 madspace::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 NamedVector<Value> &inputs, const NamedVector<Value> &conditions) const override

virtual Result build_inverse_impl(FunctionBuilder &fb, const NamedVector<Value> &inputs, const NamedVector<Value> &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 madspace::Mapping

Public Functions

TwoBodyDecay(bool com)

inline std::size_t random_dim() const

Private Functions

virtual Result build_forward_impl(FunctionBuilder &fb, const NamedVector<Value> &inputs, const NamedVector<Value> &conditions) const override

virtual Result build_inverse_impl(FunctionBuilder &fb, const NamedVector<Value> &inputs, const NamedVector<Value> &conditions) const override

Private Members

bool _com

class TwoToThreeParticleScattering : public madspace::Mapping

Public Functions

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 NamedVector<Value> &inputs, const NamedVector<Value> &conditions) const override

virtual Result build_inverse_impl(FunctionBuilder &fb, const NamedVector<Value> &inputs, const NamedVector<Value> &conditions) const override

Private Members

Invariant _t_invariant

Invariant _s_invariant

class TwoToTwoParticleScattering : public madspace::Mapping

Public Functions

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

Private Functions

virtual Result build_forward_impl(FunctionBuilder &fb, const NamedVector<Value> &inputs, const NamedVector<Value> &conditions) const override

virtual Result build_inverse_impl(FunctionBuilder &fb, const NamedVector<Value> &inputs, const NamedVector<Value> &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 madspace::Instruction

Public Functions

inline UnsqueezeInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

class UnstackInstruction : public madspace::Instruction

Public Functions

inline UnstackInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

class UnstackSizesInstruction : public madspace::Instruction

Public Functions

inline UnstackSizesInstruction(int opcode, bool differentiable)

virtual TypeVec signature(const ValueVec &args) const override

class Unweighter : public madspace::FunctionGenerator

Public Functions

Unweighter(const NamedVector<Type> &types)

Private Functions

virtual NamedVector<Value> build_function_impl(FunctionBuilder &fb, const NamedVector<Value> &args) const override

class UnweightInstruction : public madspace::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(const std::vector<ContextPtr> &contexts, const std::string &grid_name, double damping)

void add_data(Tensor weights, Tensor inputs)

void optimize()

std::size_t input_dim() const

Private Members

std::vector<ContextPtr> _contexts

std::string _grid_name

double _damping

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

class VegasHistogram : public madspace::FunctionGenerator

Public Functions

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

Private Functions

virtual NamedVector<Value> build_function_impl(FunctionBuilder &fb, const NamedVector<Value> &args) const override

Private Members

std::size_t _bin_count

class VegasMapping : public madspace::Mapping

Public Functions

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 NamedVector<Value> &inputs, const NamedVector<Value> &conditions) const override

virtual Result build_inverse_impl(FunctionBuilder &fb, const NamedVector<Value> &inputs, const NamedVector<Value> &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 madspace

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 RuntimePtr = std::unique_ptr<Runtime>

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 SizeVec = std::vector<std::size_t>

using TensorVec = std::vector<Tensor>

using DevicePtr = const Device*

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 Verbosity

Values:

enumerator silent

enumerator log

enumerator pretty

enum class DeviceType

Values:

enumerator cpu

enumerator cuda

enumerator hip

enum class AllocHint

Values:

enumerator normal

enumerator output

enumerator local

enumerator temporary

enumerator input_grad

enumerator local_grad

enumerator global_grad

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()

Function sort_breadth_first(const Function &function)

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)

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

DevicePtr cpu_device()

DevicePtr cuda_device(std::size_t index = 0)

DevicePtr hip_device(std::size_t index = 0)

void set_lib_path(const std::string &lib_path)

void set_simd_vector_size(int vector_size)

void to_json(nlohmann::json &j, const ChannelEventGenerator &channel)

ContextPtr default_context()

ContextPtr default_cuda_context(std::size_t index = 0)

ContextPtr default_hip_context(std::size_t index = 0)

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)

std::size_t cpu_time_microsec()

std::string format_run_time(double wall_time_sec, double cpu_time_sec)

std::string format_si_prefix(double value)

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

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

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

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

Tensor load_tensor(const std::string &file)

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

void to_json(nlohmann::json &j, const LHECompleter &lhe_completer)

void from_json(const nlohmann::json &j, LHECompleter &lhe_completer)

void to_json(nlohmann::json &j, const LHECompleter::SubprocData &subproc_data)

void from_json(const nlohmann::json &j, LHECompleter::SubprocData &subproc_data)

void to_json(nlohmann::json &j, const LHECompleter::PropagatorData &prop_data)

void from_json(const nlohmann::json &j, LHECompleter::PropagatorData &prop_data)

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

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

inline bool needs_zero_init(AllocHint hint)

inline ThreadPool &default_thread_pool()

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)

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

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 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

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 compgraphs.hpp

#include “compgraphs/function.hpp”

#include “compgraphs/instruction.hpp”

#include “compgraphs/optimizer.hpp”

#include “compgraphs/type.hpp”

file function.hpp

#include <iostream>

#include <map>

#include <optional>

#include <string>

#include <vector>

#include <nlohmann/json.hpp>

#include “instruction.hpp”

#include “madspace/util.hpp”

#include “function_builder_mixin.inc”

file instruction.hpp

#include <initializer_list>

#include <map>

#include <memory>

#include <string>

#include <tuple>

#include <unordered_map>

#include <variant>

#include <vector>

#include “type.hpp”

#include “opcode_mixin.inc”

file optimizer.hpp

#include “madspace/compgraphs/function.hpp”

#include <vector>

file type.hpp

#include <iostream>

#include <string>

#include <unordered_map>

#include <variant>

#include <vector>

#include <nlohmann/json.hpp>

file constants.hpp

file driver.hpp

#include “driver/adam_optimizer.hpp”

#include “driver/backend.hpp”

#include “driver/context.hpp”

#include “driver/discrete_optimizer.hpp”

#include “driver/event_generator.hpp”

#include “driver/format.hpp”

#include “driver/io.hpp”

#include “driver/lhe_output.hpp”

#include “driver/logger.hpp”

#include “driver/madnis_training.hpp”

#include “driver/tensor.hpp”

#include “driver/thread_pool.hpp”

#include “driver/vegas_optimizer.hpp”

file adam_optimizer.hpp

#include “madspace/driver/backend.hpp”

#include “madspace/driver/context.hpp”

file backend.hpp

#include “madspace/compgraphs.hpp”

#include “madspace/driver/context.hpp”

#include “madspace/driver/tensor.hpp”

file channel_generator.hpp

#include <random>

#include <unordered_set>

#include <vector>

#include <nlohmann/json.hpp>

#include “madspace/driver/generator_data.hpp”

#include “madspace/compgraphs.hpp”

#include “madspace/driver/backend.hpp”

#include “madspace/driver/discrete_optimizer.hpp”

#include “madspace/driver/io.hpp”

#include “madspace/driver/vegas_optimizer.hpp”

#include “madspace/phasespace.hpp”

file context.hpp

#include <stdint.h>

#include <unordered_map>

#include “madspace/compgraphs.hpp”

#include “madspace/driver/tensor.hpp”

#include “madspace/driver/thread_pool.hpp”

#include “madspace/umami.h”

file discrete_optimizer.hpp

#include “madspace/compgraphs.hpp”

#include “madspace/driver/context.hpp”

#include “madspace/driver/tensor.hpp”

file event_generator.hpp

#include <chrono>

#include <optional>

#include <random>

#include <vector>

#include <nlohmann/json.hpp>

#include “madspace/compgraphs.hpp”

#include “madspace/driver/backend.hpp”

#include “madspace/driver/channel_generator.hpp”

#include “madspace/driver/discrete_optimizer.hpp”

#include “madspace/driver/format.hpp”

#include “madspace/driver/generator_data.hpp”

#include “madspace/driver/io.hpp”

#include “madspace/driver/vegas_optimizer.hpp”

#include “madspace/phasespace.hpp”

file format.hpp

#include <stdexcept>

#include <string>

#include <vector>

file generator_data.hpp

#include <cmath>

#include <cstddef>

#include <string>

#include <vector>

#include <nlohmann/json.hpp>

#include “madspace/driver/logger.hpp”

#include “madspace/driver/tensor.hpp”

file io.hpp

#include <cstring>

#include <fstream>

#include “madspace/driver/lhe_output.hpp”

#include “madspace/driver/tensor.hpp”

file lhe_output.hpp

#include <fstream>

#include <random>

#include <string>

#include <unordered_map>

#include <vector>

#include <nlohmann/json.hpp>

#include “madspace/driver/thread_pool.hpp”

#include “madspace/phasespace/topology.hpp”

#include “madspace/util.hpp”

file logger.hpp

#include <functional>

#include <string>

#include “madspace/util.hpp”

file madnis_training.hpp

#include <chrono>

#include “madspace/compgraphs.hpp”

#include “madspace/driver/adam_optimizer.hpp”

#include “madspace/driver/format.hpp”

#include “madspace/driver/logger.hpp”

#include “madspace/phasespace.hpp”

file tensor.hpp

#include “madspace/compgraphs/type.hpp”

#include “madspace/util.hpp”

#include <algorithm>

#include <atomic>

#include <concepts>

#include <cstdint>

#include <functional>

#include <initializer_list>

#include <vector>

file thread_pool.hpp

#include <condition_variable>

#include <deque>

#include <functional>

#include <mutex>

#include <optional>

#include <thread>

#include <vector>

file vegas_optimizer.hpp

#include “madspace/compgraphs.hpp”

#include “madspace/driver/context.hpp”

#include “madspace/driver/tensor.hpp”

file base.hpp

#include “madspace/compgraphs.hpp”

#include “madspace/util.hpp”

file channel_weight_network.hpp

#include “madspace/phasespace/base.hpp”

#include “madspace/phasespace/mlp.hpp”

file channel_weights.hpp

#include “madspace/phasespace/base.hpp”

#include “madspace/phasespace/topology.hpp”

#include “madspace/util.hpp”

file chili.hpp

#include “madspace/phasespace/base.hpp”

#include <vector>

file cross_section.hpp

#include “madspace/phasespace/matrix_element.hpp”

#include “madspace/phasespace/pdf.hpp”

#include “madspace/phasespace/scale.hpp”

file cuts.hpp

#include “madspace/compgraphs.hpp”

#include “madspace/phasespace/base.hpp”

#include “madspace/phasespace/observable.hpp”

#include <vector>

file discrete_flow.hpp

#include “madspace/phasespace/base.hpp”

#include “madspace/phasespace/mlp.hpp”

file discrete_sampler.hpp

#include “madspace/driver/context.hpp”

#include “madspace/phasespace/base.hpp”

file flow.hpp

#include “madspace/phasespace/base.hpp”

#include “madspace/phasespace/mlp.hpp”

file histograms.hpp

#include “madspace/phasespace/base.hpp”

#include “madspace/phasespace/observable.hpp”

file integrand.hpp

#include “madspace/phasespace/channel_weight_network.hpp”

#include “madspace/phasespace/channel_weights.hpp”

#include “madspace/phasespace/cross_section.hpp”

#include “madspace/phasespace/discrete_flow.hpp”

#include “madspace/phasespace/discrete_sampler.hpp”

#include “madspace/phasespace/flow.hpp”

#include “madspace/phasespace/matrix_element.hpp”

#include “madspace/phasespace/pdf.hpp”

#include “madspace/phasespace/phasespace.hpp”

#include “madspace/phasespace/vegas.hpp”

#include “madspace/util.hpp”

file invariants.hpp

#include “madspace/phasespace/base.hpp”

file luminosity.hpp

#include “madspace/phasespace/base.hpp”

#include “madspace/phasespace/invariants.hpp”

file madnis.hpp

#include <vector>

#include “madspace/phasespace/base.hpp”

#include “madspace/phasespace/channel_weight_network.hpp”

file matrix_element.hpp

#include “madspace/driver/context.hpp”

#include “madspace/phasespace/base.hpp”

file mlp.hpp

#include “madspace/driver/context.hpp”

#include “madspace/phasespace/base.hpp”

file multichannel.hpp

#include <format>

#include <vector>

#include “madspace/phasespace/base.hpp”

#include “madspace/phasespace/phasespace.hpp”

file observable.hpp

#include “madspace/compgraphs.hpp”

#include “madspace/phasespace/base.hpp”

#include “madspace/util.hpp”

#include <vector>

file pdf.hpp

#include “madspace/driver/context.hpp”

#include “madspace/phasespace/base.hpp”

file phasespace.hpp

#include “madspace/phasespace/base.hpp”

#include “madspace/phasespace/chili.hpp”

#include “madspace/phasespace/cuts.hpp”

#include “madspace/phasespace/invariants.hpp”

#include “madspace/phasespace/luminosity.hpp”

#include “madspace/phasespace/rambo.hpp”

#include “madspace/phasespace/t_propagator_mapping.hpp”

#include “madspace/phasespace/three_particle.hpp”

#include “madspace/phasespace/topology.hpp”

file phasespace.hpp

#include “phasespace/base.hpp”

#include “phasespace/channel_weight_network.hpp”

#include “phasespace/channel_weights.hpp”

#include “phasespace/cross_section.hpp”

#include “phasespace/cuts.hpp”

#include “phasespace/discrete_flow.hpp”

#include “phasespace/discrete_sampler.hpp”

#include “phasespace/flow.hpp”

#include “phasespace/histograms.hpp”

#include “phasespace/integrand.hpp”

#include “phasespace/invariants.hpp”

#include “phasespace/luminosity.hpp”

#include “phasespace/madnis.hpp”

#include “phasespace/matrix_element.hpp”

#include “phasespace/mlp.hpp”

#include “phasespace/multichannel.hpp”

#include “phasespace/observable.hpp”

#include “phasespace/pdf.hpp”

#include “phasespace/phasespace.hpp”

#include “phasespace/rambo.hpp”

#include “phasespace/scale.hpp”

#include “phasespace/t_propagator_mapping.hpp”

#include “phasespace/three_particle.hpp”

#include “phasespace/topology.hpp”

#include “phasespace/two_particle.hpp”

#include “phasespace/vegas.hpp”

file rambo.hpp

#include “madspace/phasespace/base.hpp”

file scale.hpp

#include “madspace/phasespace/base.hpp”

file t_propagator_mapping.hpp

#include <vector>

#include “madspace/phasespace/base.hpp”

#include “madspace/phasespace/invariants.hpp”

#include “madspace/phasespace/topology.hpp”

#include “madspace/phasespace/two_particle.hpp”

file three_particle.hpp

#include “madspace/phasespace/base.hpp”

#include “madspace/phasespace/invariants.hpp”

file topology.hpp

#include <array>

#include <ostream>

#include <string>

#include <vector>

file two_particle.hpp

#include “madspace/phasespace/base.hpp”

#include “madspace/phasespace/invariants.hpp”

file vegas.hpp

#include “madspace/driver/context.hpp”

#include “madspace/phasespace/base.hpp”

file umami.h

#include <stddef.h>

Typedefs

typedef void *UmamiHandle

Implementation-defined pointer to a matrix element instance

Enums

enum UmamiStatus

Values:

enumerator UMAMI_SUCCESS

operation was executed successfully

enumerator UMAMI_ERROR

an unspecified error

enumerator UMAMI_ERROR_NOT_IMPLEMENTED

operation not implemented

enumerator UMAMI_ERROR_UNSUPPORTED_INPUT

the provided input key is not supported by this matrix element implementation

enumerator UMAMI_ERROR_UNSUPPORTED_OUTPUT

the provided output key is not supported by this matrix element implementation

enumerator UMAMI_ERROR_UNSUPPORTED_META

the provided metadata key is not supported by this matrix element implementation

enumerator UMAMI_ERROR_MISSING_INPUT

a mandatory matrix element input was not provided

enum UmamiDevice

Values:

enumerator UMAMI_DEVICE_CPU

enumerator UMAMI_DEVICE_CUDA

enumerator UMAMI_DEVICE_HIP

enum UmamiMetaKey

Values:

enumerator UMAMI_META_DEVICE

UmamiDevice specifying the type of device

enumerator UMAMI_META_PARTICLE_COUNT

int specifying the number of external particles

enumerator UMAMI_META_DIAGRAM_COUNT

int specifying the number of Feynman diagrams

enumerator UMAMI_META_HELICITY_COUNT

int specifying the number of helicities

enumerator UMAMI_META_COLOR_COUNT

int specifying the number of colors

enum UmamiInputKey

Values:

enumerator UMAMI_IN_MOMENTA

momenta of the external legs, type: double, shape: (particle count, 4)

enumerator UMAMI_IN_ALPHA_S

value for the strong coupling, type: double, shape: ()

enumerator UMAMI_IN_FLAVOR_INDEX

flavor index, type: int, shape: ()

enumerator UMAMI_IN_RANDOM_COLOR

random number for color selection, type: double, shape: ()

enumerator UMAMI_IN_RANDOM_HELICITY

random number for helicity selection, type: double, shape: ()

enumerator UMAMI_IN_RANDOM_DIAGRAM

random number for diagram selection, type: double, shape: ()

enumerator UMAMI_IN_HELICITY_INDEX

externally selected helicity index, type: int, shape: ()

enumerator UMAMI_IN_DIAGRAM_INDEX

externally selected diagram index, type: int, shape: ()

enum UmamiOutputKey

Values:

enumerator UMAMI_OUT_MATRIX_ELEMENT

value of the matrix element, type: double, shape: ()

enumerator UMAMI_OUT_DIAGRAM_AMP2

selected color index, type: double, shape: (diagram count)

enumerator UMAMI_OUT_COLOR_INDEX

selected color index, type: int, shape: ()

enumerator UMAMI_OUT_HELICITY_INDEX

selected helicity index, type: int, shape: ()

enumerator UMAMI_OUT_DIAGRAM_INDEX

selected diagram index, type: int, shape: ()

enumerator UMAMI_OUT_GPU_STREAM

CUDA or HIP stream for asynchronous execution. Listed as an output as it is a mutable pointer

Functions

UmamiStatus umami_get_meta(UmamiMetaKey meta_key, void *result)

Retrieve metadata about the implemented matrix element

Parameters:

• meta_key – key specifying the type of metadata to be retrieved

• result – pointer to store the result. It’s type depends on the metadata key

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:

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

• param_card_path – path to the parameter file

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. Unless otherwise specified, all inputs and outputs have a column-major memory layout and have a batch dimension that is contiguous in memory.

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 to simplify parallel execution on CPUs, 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.hpp

#include <cstdio>

#include <format>

#include <ranges>

#include <tuple>

#include <unordered_map>

#include <vector>

dir /home/docs/checkouts/readthedocs.org/user_builds/madgraph7/checkouts/stable/madspace/include/madspace/compgraphs

dir /home/docs/checkouts/readthedocs.org/user_builds/madgraph7/checkouts/stable/madspace/include/madspace/driver

dir /home/docs/checkouts/readthedocs.org/user_builds/madgraph7/checkouts/stable/madspace/include

dir /home/docs/checkouts/readthedocs.org/user_builds/madgraph7/checkouts/stable/madspace

dir /home/docs/checkouts/readthedocs.org/user_builds/madgraph7/checkouts/stable/madspace/include/madspace

dir /home/docs/checkouts/readthedocs.org/user_builds/madgraph7/checkouts/stable/madspace/include/madspace/phasespace