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¶

class ColorOrderedMapping : public madspace::Mapping ¶

Public Functions

ColorOrderedMapping(const std::vector<std::size_t> &color_order, double t_invariant_power = 0.8, double s_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> _set1¶

std::vector<std::size_t> _set2¶

std::size_t _n_out¶

std::size_t _random_dim¶

bool _use_double_t¶

Invariant _uniform_invariant¶

TwoToTwoParticleScattering _com_scattering¶

TwoToTwoParticleScattering _lab_scattering¶

TwoToThreeParticleScattering _two_to_three¶

DoubleT _double_t¶

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¶

class DoubleT : public madspace::Mapping ¶

Public Functions

DoubleT(double t1_invariant_power = 0, double t1_mass = 0, double t1_width = 0, double t2_invariant_power = 0, double t2_mass = 0, double t2_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 _t1_invariant¶

Invariant _t2_invariant¶

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¶

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::ColorOrderedMapping, madspace::DiscreteFlow, madspace::DiscreteSampler, madspace::DoubleT, 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 channel_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 color_ordered_mapping.hpp: #include <vector>

#include “madspace/phasespace/base.hpp”

#include “madspace/phasespace/invariants.hpp”

#include “madspace/phasespace/three_particle.hpp”

#include “madspace/phasespace/topology.hpp”

#include “madspace/phasespace/two_particle.hpp”

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

Defines

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

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

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: unsigned int, shape: ()

enumerator UMAMI_IN_CHANNEL_INDEX¶: externally selected channel index, type: unsigned 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: