Python API

class madspace.AdamOptimizer(self: madspace._madspace_py.AdamOptimizer, function: madspace._madspace_py.Function, context: madspace._madspace_py.Context, learning_rate: SupportsFloat, schedule: madspace._madspace_py.AdamOptimizer.LRSchedule = <LRSchedule.none: 0>, step_count: SupportsInt = 0, beta1: SupportsFloat = 0.9, beta2: SupportsFloat = 0.999, eps: SupportsFloat = 1e-08)

Bases: pybind11_object

class LRSchedule(*args, **kwargs)

Bases: pybind11_object

Members:

none

cosine

Overloaded function.

1. __init__(self: madspace._madspace_py.AdamOptimizer.LRSchedule, value: typing.SupportsInt) -> None

2. __init__(self: madspace._madspace_py.AdamOptimizer.LRSchedule, name: str) -> None

cosine = <LRSchedule.cosine: 1>

AdamOptimizer.LRSchedule.name -> str

none = <LRSchedule.none: 0>

property value

context(self: madspace._madspace_py.AdamOptimizer) → madspace._madspace_py.Context

cosine = <LRSchedule.cosine: 1>

input_types(self: madspace._madspace_py.AdamOptimizer) → list[madspace._madspace_py.Type]

learning_rate(self: madspace._madspace_py.AdamOptimizer) → float

none = <LRSchedule.none: 0>

step(self: madspace._madspace_py.AdamOptimizer, inputs: collections.abc.Sequence[object]) → list[madspace._madspace_py.Tensor]

class madspace.AlphaSGrid(self: madspace._madspace_py.AlphaSGrid, file: str)

Bases: pybind11_object

coefficients_shape(self: madspace._madspace_py.AlphaSGrid, batch_dim: bool = False) → list[int]

initialize_globals(self: madspace._madspace_py.AlphaSGrid, context: madspace._madspace_py.Context, prefix: str = '') → None

property logq2

logq2_shape(self: madspace._madspace_py.AlphaSGrid, batch_dim: bool = False) → list[int]

property q

property q_count

property region_sizes

property values

class madspace.BatchSize(*args, **kwargs)

Bases: pybind11_object

Overloaded function.

1. __init__(self: madspace._madspace_py.BatchSize) -> None

2. __init__(self: madspace._madspace_py.BatchSize, name: str) -> None

one = 1

class madspace.ChannelEventGenerator(self: madspace._madspace_py.ChannelEventGenerator, contexts: collections.abc.Sequence[madspace._madspace_py.Context], integrand: madspace._madspace_py.Integrand, event_file: str, weight_file: str, config: madspace._madspace_py.GeneratorConfig, subprocess_index: SupportsInt, name: str, histograms: madspace._madspace_py.ObservableHistograms | None)

Bases: pybind11_object

integrand_flags = 1077

static load(channel_file: str, contexts: collections.abc.Sequence[madspace._madspace_py.Context], event_file: str, weight_file: str, config: madspace._madspace_py.GeneratorConfig) → madspace._madspace_py.ChannelEventGenerator

save(self: madspace._madspace_py.ChannelEventGenerator, save: str) → None

status(self: madspace._madspace_py.ChannelEventGenerator) → madspace._madspace_py.GeneratorStatus

class madspace.ChannelWeightNetwork(self: madspace._madspace_py.ChannelWeightNetwork, channel_count: SupportsInt, particle_count: SupportsInt, hidden_dim: SupportsInt = 32, layers: SupportsInt = 3, activation: madspace._madspace_py.MLP.Activation = <Activation.leaky_relu: 1>, prefix: str = '', include_preprocessing: bool = True)

Bases: FunctionGenerator

initialize_globals(self: madspace._madspace_py.ChannelWeightNetwork, context: madspace._madspace_py.Context) → None

mask_name(self: madspace._madspace_py.ChannelWeightNetwork) → str

mlp(self: madspace._madspace_py.ChannelWeightNetwork) → madspace._madspace_py.MLP

preprocessing(self: madspace._madspace_py.ChannelWeightNetwork) → madspace._madspace_py.MomentumPreprocessing

class madspace.Context(*args, **kwargs)

Bases: pybind11_object

Overloaded function.

1. __init__(self: madspace._madspace_py.Context, thread_count: typing.SupportsInt = -1) -> None

2. __init__(self: madspace._madspace_py.Context, device: madspace._madspace_py.Device, thread_count: typing.SupportsInt = -1) -> None

copy_globals_from(self: madspace._madspace_py.Context, context: madspace._madspace_py.Context) → None

define_global(self: madspace._madspace_py.Context, name: str, dtype: madspace._madspace_py.DataType, shape: collections.abc.Sequence[SupportsInt], requires_grad: bool = False) → madspace._madspace_py.Tensor

delete_global(self: madspace._madspace_py.Context, name: str) → None

device(self: madspace._madspace_py.Context) → madspace._madspace_py.Device

get_global(self: madspace._madspace_py.Context, name: str) → madspace._madspace_py.Tensor

global_exists(self: madspace._madspace_py.Context, name: str) → bool

global_names(self: madspace._madspace_py.Context) → list[str]

global_requires_grad(self: madspace._madspace_py.Context, name: str) → bool

load_globals(self: madspace._madspace_py.Context, dir: str) → None

load_matrix_element(self: madspace._madspace_py.Context, file: str, param_card: str) → madspace._madspace_py.MatrixElementApi

matrix_element(self: madspace._madspace_py.Context, index: SupportsInt) → madspace._madspace_py.MatrixElementApi

save_globals(self: madspace._madspace_py.Context, dir: str) → None

class madspace.CutItem(self: madspace._madspace_py.CutItem, observable: madspace._madspace_py.Observable, min: SupportsFloat = -inf, max: SupportsFloat = inf, mode: madspace._madspace_py.Cuts.CutMode = <CutMode.all: 1>)

Bases: pybind11_object

property max

property min

property mode

property observable

class madspace.Cuts(*args, **kwargs)

Bases: FunctionGenerator

Overloaded function.

1. __init__(self: madspace._madspace_py.Cuts, cut_data: collections.abc.Sequence[madspace._madspace_py.CutItem]) -> None

2. __init__(self: madspace._madspace_py.Cuts, particle_count: typing.SupportsInt) -> None

class CutMode(*args, **kwargs)

Bases: pybind11_object

Members:

any

all

Overloaded function.

1. __init__(self: madspace._madspace_py.Cuts.CutMode, value: typing.SupportsInt) -> None

2. __init__(self: madspace._madspace_py.Cuts.CutMode, name: str) -> None

all = <CutMode.all: 1>

any = <CutMode.any: 0>

Cuts.CutMode.name -> str

property value

all = <CutMode.all: 1>

any = <CutMode.any: 0>

eta_max(self: madspace._madspace_py.Cuts) → list[float]

pt_min(self: madspace._madspace_py.Cuts) → list[float]

sqrt_s_min(self: madspace._madspace_py.Cuts) → float

class madspace.DataType(*args, **kwargs)

Bases: pybind11_object

Members:

int

float

batch_sizes

Overloaded function.

1. __init__(self: madspace._madspace_py.DataType, value: typing.SupportsInt) -> None

2. __init__(self: madspace._madspace_py.DataType, name: str) -> None

batch_sizes = <DataType.batch_sizes: 2>

float = <DataType.float: 1>

int = <DataType.int: 0>

DataType.name -> str

property value

class madspace.Decay

Bases: pybind11_object

property child_indices

property e_max

property e_min

property index

property mass

property on_shell

property parent_index

property pdg_id

property width

class madspace.Device

Bases: pybind11_object

class madspace.Diagram(self: madspace._madspace_py.Diagram, incoming_masses: collections.abc.Sequence[SupportsFloat], outgoing_masses: collections.abc.Sequence[SupportsFloat], propagators: collections.abc.Sequence[madspace._madspace_py.Propagator], vertices: collections.abc.Sequence[collections.abc.Sequence[madspace._madspace_py.LineRef]])

Bases: pybind11_object

property incoming_masses

property incoming_vertices

property outgoing_masses

property outgoing_vertices

property propagator_vertices

property propagators

property vertices

class madspace.DifferentialCrossSection(self: madspace._madspace_py.DifferentialCrossSection, matrix_element: madspace._madspace_py.MatrixElement, cm_energy: SupportsFloat, running_coupling: madspace._madspace_py.RunningCoupling, energy_scale: madspace._madspace_py.EnergyScale, pid_options: collections.abc.Sequence[collections.abc.Sequence[SupportsInt]] = [], has_pdf1: bool = False, has_pdf2: bool = False, pdf_grid1: madspace._madspace_py.PdfGrid | None = None, pdf_grid2: madspace._madspace_py.PdfGrid | None = None, has_mirror: bool = False, input_momentum_fraction: bool = True)

Bases: FunctionGenerator

has_mirror(self: madspace._madspace_py.DifferentialCrossSection) → bool

matrix_element(self: madspace._madspace_py.DifferentialCrossSection) → madspace._madspace_py.MatrixElement

pid_options(self: madspace._madspace_py.DifferentialCrossSection) → list[list[int]]

class madspace.DiscreteFlow(self: madspace._madspace_py.DiscreteFlow, option_counts: collections.abc.Sequence[typing.SupportsInt], prefix: str = '', dims_with_prior: collections.abc.Sequence[typing.SupportsInt] = [], condition_dim: typing.SupportsInt = 0, subnet_hidden_dim: typing.SupportsInt = 32, subnet_layers: typing.SupportsInt = 3, subnet_activation: madspace._madspace_py.MLP.Activation = <Activation.leaky_relu: 1>)

Bases: Mapping

condition_dim(self: madspace._madspace_py.DiscreteFlow) → int

initialize_globals(self: madspace._madspace_py.DiscreteFlow, context: madspace._madspace_py.Context) → None

option_counts(self: madspace._madspace_py.DiscreteFlow) → list[int]

class madspace.DiscreteHistogram(self: madspace._madspace_py.DiscreteHistogram, option_counts: collections.abc.Sequence[SupportsInt])

Bases: FunctionGenerator

class madspace.DiscreteOptimizer(self: madspace._madspace_py.DiscreteOptimizer, contexts: collections.abc.Sequence[madspace._madspace_py.Context], prob_names: collections.abc.Sequence[str])

Bases: pybind11_object

add_data(self: madspace._madspace_py.DiscreteOptimizer, values_and_counts: collections.abc.Sequence[object]) → None

optimize(self: madspace._madspace_py.DiscreteOptimizer) → None

class madspace.DiscreteSampler(self: madspace._madspace_py.DiscreteSampler, option_counts: collections.abc.Sequence[SupportsInt], prefix: str = '', dims_with_prior: collections.abc.Sequence[SupportsInt] = [])

Bases: Mapping

initialize_globals(self: madspace._madspace_py.DiscreteSampler, context: madspace._madspace_py.Context) → None

option_counts(self: madspace._madspace_py.DiscreteSampler) → list[int]

prob_names(self: madspace._madspace_py.DiscreteSampler) → list[str]

class madspace.EnergyScale(*args, **kwargs)

Bases: FunctionGenerator

Overloaded function.

1. __init__(self: madspace._madspace_py.EnergyScale, particle_count: typing.SupportsInt) -> None

2. __init__(self: madspace._madspace_py.EnergyScale, particle_count: typing.SupportsInt, type: madspace._madspace_py.EnergyScale.DynamicalScaleType) -> None

3. __init__(self: madspace._madspace_py.EnergyScale, particle_count: typing.SupportsInt, fixed_scale: typing.SupportsFloat) -> None

4. __init__(self: madspace._madspace_py.EnergyScale, particle_count: typing.SupportsInt, dynamical_scale_type: madspace._madspace_py.EnergyScale.DynamicalScaleType, ren_scale_fixed: bool, fact_scale_fixed: bool, ren_scale: typing.SupportsFloat, fact_scale1: typing.SupportsFloat, fact_scale2: typing.SupportsFloat) -> None

class DynamicalScaleType(*args, **kwargs)

Bases: pybind11_object

Members:

transverse_energy

transverse_mass

half_transverse_mass

partonic_energy

Overloaded function.

1. __init__(self: madspace._madspace_py.EnergyScale.DynamicalScaleType, value: typing.SupportsInt) -> None

2. __init__(self: madspace._madspace_py.EnergyScale.DynamicalScaleType, name: str) -> None

half_transverse_mass = <DynamicalScaleType.half_transverse_mass: 2>

EnergyScale.DynamicalScaleType.name -> str

partonic_energy = <DynamicalScaleType.partonic_energy: 3>

transverse_energy = <DynamicalScaleType.transverse_energy: 0>

transverse_mass = <DynamicalScaleType.transverse_mass: 1>

property value

half_transverse_mass = <DynamicalScaleType.half_transverse_mass: 2>

partonic_energy = <DynamicalScaleType.partonic_energy: 3>

transverse_energy = <DynamicalScaleType.transverse_energy: 0>

transverse_mass = <DynamicalScaleType.transverse_mass: 1>

class madspace.EventGenerator(self: madspace._madspace_py.EventGenerator, contexts: collections.abc.Sequence[madspace._madspace_py.Context], channels: collections.abc.Sequence[madspace._madspace_py.ChannelEventGenerator], status_file: str = '', config: madspace._madspace_py.GeneratorConfig = EventGenerator.default_config)

Bases: pybind11_object

channel_status(self: madspace._madspace_py.EventGenerator) → list[madspace._madspace_py.GeneratorStatus]

channels(self: madspace._madspace_py.EventGenerator) → list[madspace._madspace_py.ChannelEventGenerator]

combine_to_compact_npy(self: madspace._madspace_py.EventGenerator, file_name: str) → None

combine_to_lhe(self: madspace._madspace_py.EventGenerator, file_name: str, lhe_completer: madspace::LHECompleter) → None

combine_to_lhe_npy(self: madspace._madspace_py.EventGenerator, file_name: str, lhe_completer: madspace::LHECompleter) → None

default_config = <madspace._madspace_py.GeneratorConfig object>

generate(self: madspace._madspace_py.EventGenerator) → None

histograms(self: madspace._madspace_py.EventGenerator) → list[madspace._madspace_py.Histogram]

status(self: madspace._madspace_py.EventGenerator) → madspace._madspace_py.GeneratorStatus

survey(self: madspace._madspace_py.EventGenerator) → None

used_globals(self: madspace._madspace_py.EventGenerator) → set[str]

class madspace.FastRamboMapping(self: madspace._madspace_py.FastRamboMapping, n_particles: SupportsInt, massless: bool)

Bases: Mapping

class madspace.Flow(self: madspace._madspace_py.Flow, input_dim: SupportsInt, condition_dim: SupportsInt = 0, prefix: str = '', bin_count: SupportsInt = 10, subnet_hidden_dim: SupportsInt = 32, subnet_layers: SupportsInt = 3, subnet_activation: madspace._madspace_py.MLP.Activation = <Activation.leaky_relu: 1>, invert_spline: bool = True)

Bases: Mapping

condition_dim(self: madspace._madspace_py.Flow) → int

initialize_from_vegas(self: madspace._madspace_py.Flow, context: madspace._madspace_py.Context, grid_name: str) → None

initialize_globals(self: madspace._madspace_py.Flow, context: madspace._madspace_py.Context) → None

input_dim(self: madspace._madspace_py.Flow) → int

class madspace.Function

Bases: pybind11_object

property globals

property inputs

property instructions

static load(file: str) → madspace._madspace_py.Function

property locals

property outputs

save(self: madspace._madspace_py.Function, file: str) → None

class madspace.FunctionBuilder(self: madspace._madspace_py.FunctionBuilder, input_types: madspace._madspace_py.NamedTypes, output_types: madspace._madspace_py.NamedTypes)

Bases: pybind11_object

accept_norm(self: madspace._madspace_py.FunctionBuilder, accepted_batch: madspace._madspace_py.Value, full_batch: madspace._madspace_py.Value) → madspace._madspace_py.Value

add(self: madspace._madspace_py.FunctionBuilder, in1: madspace._madspace_py.Value, in2: madspace._madspace_py.Value) → madspace._madspace_py.Value

add_int(self: madspace._madspace_py.FunctionBuilder, in1: madspace._madspace_py.Value, in2: madspace._madspace_py.Value) → madspace._madspace_py.Value

apply_subchannel_weights(self: madspace._madspace_py.FunctionBuilder, channel_weights_in: madspace._madspace_py.Value, subchannel_weights: madspace._madspace_py.Value, channel_indices: madspace._madspace_py.Value, subchannel_indices: madspace._madspace_py.Value) → madspace._madspace_py.Value

argsort(self: madspace._madspace_py.FunctionBuilder, input: madspace._madspace_py.Value) → madspace._madspace_py.Value

batch_cat(self: madspace._madspace_py.FunctionBuilder, args: collections.abc.Sequence[madspace._madspace_py.Value]) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

batch_gather(self: madspace._madspace_py.FunctionBuilder, indices: madspace._madspace_py.Value, values: madspace._madspace_py.Value) → madspace._madspace_py.Value

batch_reduce_mean(self: madspace._madspace_py.FunctionBuilder, in: madspace._madspace_py.Value) → madspace._madspace_py.Value

batch_reduce_mean_keepdim(self: madspace._madspace_py.FunctionBuilder, in: madspace._madspace_py.Value) → madspace._madspace_py.Value

batch_scatter(self: madspace._madspace_py.FunctionBuilder, indices: madspace._madspace_py.Value, target: madspace._madspace_py.Value, source: madspace._madspace_py.Value) → madspace._madspace_py.Value

batch_size(self: madspace._madspace_py.FunctionBuilder, args: collections.abc.Sequence[madspace._madspace_py.Value]) → madspace._madspace_py.Value

batch_split(self: madspace._madspace_py.FunctionBuilder, in1: madspace._madspace_py.Value, counts: madspace._madspace_py.Value) → list[madspace._madspace_py.Value]

boost_beam(self: madspace._madspace_py.FunctionBuilder, p1: madspace._madspace_py.Value, x1: madspace._madspace_py.Value, x2: madspace._madspace_py.Value) → madspace._madspace_py.Value

boost_beam_inverse(self: madspace._madspace_py.FunctionBuilder, p1: madspace._madspace_py.Value, x1: madspace._madspace_py.Value, x2: madspace._madspace_py.Value) → madspace._madspace_py.Value

breit_wigner_invariant(self: madspace._madspace_py.FunctionBuilder, r: madspace._madspace_py.Value, mass: madspace._madspace_py.Value, width: madspace._madspace_py.Value, s_min: madspace._madspace_py.Value, s_max: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

breit_wigner_invariant_inverse(self: madspace._madspace_py.FunctionBuilder, s: madspace._madspace_py.Value, mass: madspace._madspace_py.Value, width: madspace._madspace_py.Value, s_min: madspace._madspace_py.Value, s_max: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

cat(self: madspace._madspace_py.FunctionBuilder, args: collections.abc.Sequence[madspace._madspace_py.Value]) → madspace._madspace_py.Value

chili_forward(self: madspace._madspace_py.FunctionBuilder, r: madspace._madspace_py.Value, e_cm: madspace._madspace_py.Value, m_out: madspace._madspace_py.Value, pt_min: madspace._madspace_py.Value, y_max: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

chili_inverse(self: madspace._madspace_py.FunctionBuilder, p_ext: madspace._madspace_py.Value, e_cm: madspace._madspace_py.Value, m_out: madspace._madspace_py.Value, pt_min: madspace._madspace_py.Value, y_max: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

collect_channel_weights(self: madspace._madspace_py.FunctionBuilder, amp2: madspace._madspace_py.Value, channel_indices: madspace._madspace_py.Value, channel_count: madspace._madspace_py.Value) → madspace._madspace_py.Value

com_p_in(self: madspace._madspace_py.FunctionBuilder, e_cm: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

current_stream(self: madspace._madspace_py.FunctionBuilder) → int

cut_all(self: madspace._madspace_py.FunctionBuilder, obs: madspace._madspace_py.Value, min: madspace._madspace_py.Value, max: madspace._madspace_py.Value) → madspace._madspace_py.Value

cut_any(self: madspace._madspace_py.FunctionBuilder, obs: madspace._madspace_py.Value, min: madspace._madspace_py.Value, max: madspace._madspace_py.Value) → madspace._madspace_py.Value

cut_one(self: madspace._madspace_py.FunctionBuilder, obs: madspace._madspace_py.Value, min: madspace._madspace_py.Value, max: madspace._madspace_py.Value) → madspace._madspace_py.Value

cut_unphysical(self: madspace._madspace_py.FunctionBuilder, w_in: madspace._madspace_py.Value, p: madspace._madspace_py.Value, x1: madspace._madspace_py.Value, x2: madspace._madspace_py.Value) → madspace._madspace_py.Value

diff_cross_section(self: madspace._madspace_py.FunctionBuilder, x1: madspace._madspace_py.Value, x2: madspace._madspace_py.Value, pdf1: madspace._madspace_py.Value, pdf2: madspace._madspace_py.Value, matrix_element: madspace._madspace_py.Value, e_cm2: madspace._madspace_py.Value) → madspace._madspace_py.Value

discrete_histogram(self: madspace._madspace_py.FunctionBuilder, input: madspace._madspace_py.Value, weights: madspace._madspace_py.Value, option_count: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

div(self: madspace._madspace_py.FunctionBuilder, in1: madspace._madspace_py.Value, in2: madspace._madspace_py.Value) → madspace._madspace_py.Value

elu(self: madspace._madspace_py.FunctionBuilder, in1: madspace._madspace_py.Value) → madspace._madspace_py.Value

fast_rambo_massive(self: madspace._madspace_py.FunctionBuilder, r: madspace._madspace_py.Value, e_cm: madspace._madspace_py.Value, masses: madspace._madspace_py.Value, p0: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

fast_rambo_massive_com(self: madspace._madspace_py.FunctionBuilder, r: madspace._madspace_py.Value, e_cm: madspace._madspace_py.Value, masses: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

fast_rambo_massive_inverse(self: madspace._madspace_py.FunctionBuilder, p_out: madspace._madspace_py.Value, e_cm: madspace._madspace_py.Value, masses: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(3)']

fast_rambo_massless(self: madspace._madspace_py.FunctionBuilder, r: madspace._madspace_py.Value, e_cm: madspace._madspace_py.Value, p0: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

fast_rambo_massless_com(self: madspace._madspace_py.FunctionBuilder, r: madspace._madspace_py.Value, e_cm: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

fast_rambo_massless_inverse(self: madspace._madspace_py.FunctionBuilder, p_out: madspace._madspace_py.Value, e_cm: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(3)']

full(self: madspace._madspace_py.FunctionBuilder, args: collections.abc.Sequence[madspace._madspace_py.Value]) → madspace._madspace_py.Value

function(self: madspace._madspace_py.FunctionBuilder) → madspace._madspace_py.Function

gather(self: madspace._madspace_py.FunctionBuilder, index: madspace._madspace_py.Value, choices: madspace._madspace_py.Value) → madspace._madspace_py.Value

gather_int(self: madspace._madspace_py.FunctionBuilder, index: madspace._madspace_py.Value, choices: madspace._madspace_py.Value) → madspace._madspace_py.Value

gelu(self: madspace._madspace_py.FunctionBuilder, in1: madspace._madspace_py.Value) → madspace._madspace_py.Value

get_global(self: madspace._madspace_py.FunctionBuilder, name: str, dtype: madspace._madspace_py.DataType, shape: collections.abc.Sequence[SupportsInt]) → madspace._madspace_py.Value

histogram(self: madspace._madspace_py.FunctionBuilder, input: madspace._madspace_py.Value, weights: madspace._madspace_py.Value, min: madspace._madspace_py.Value, max: madspace._madspace_py.Value, bin_count: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

input(self: madspace._madspace_py.FunctionBuilder, index: SupportsInt) → madspace._madspace_py.Value

input_range(self: madspace._madspace_py.FunctionBuilder, start_index: SupportsInt, end_index: SupportsInt) → list[madspace._madspace_py.Value]

interpolate_alpha_s(self: madspace._madspace_py.FunctionBuilder, q2: madspace._madspace_py.Value, grid_logq2: madspace._madspace_py.Value, grid_coeffs: madspace._madspace_py.Value) → madspace._madspace_py.Value

interpolate_pdf(self: madspace._madspace_py.FunctionBuilder, x: madspace._madspace_py.Value, q2: madspace._madspace_py.Value, pid_indices: madspace._madspace_py.Value, grid_logx: madspace._madspace_py.Value, grid_logq2: madspace._madspace_py.Value, grid_coeffs: madspace._madspace_py.Value) → madspace._madspace_py.Value

invariants_from_momenta(self: madspace._madspace_py.FunctionBuilder, p_ext: madspace._madspace_py.Value, factors: madspace._madspace_py.Value) → madspace._madspace_py.Value

leaky_relu(self: madspace._madspace_py.FunctionBuilder, in1: madspace._madspace_py.Value) → madspace._madspace_py.Value

madnis_abs_weight(self: madspace._madspace_py.FunctionBuilder, f: madspace._madspace_py.Value, q: madspace._madspace_py.Value) → madspace._madspace_py.Value

madnis_multi_channel_variance(self: madspace._madspace_py.FunctionBuilder, vars: madspace._madspace_py.Value, abs_means: madspace._madspace_py.Value) → madspace._madspace_py.Value

madnis_single_channel_variance(self: madspace._madspace_py.FunctionBuilder, var: madspace._madspace_py.Value, abs_mean: madspace._madspace_py.Value) → madspace._madspace_py.Value

madnis_softclip(self: madspace._madspace_py.FunctionBuilder, f: madspace._madspace_py.Value, q: madspace._madspace_py.Value, norm: madspace._madspace_py.Value, threshold: madspace._madspace_py.Value) → madspace._madspace_py.Value

madnis_variance(self: madspace._madspace_py.FunctionBuilder, f: madspace._madspace_py.Value, g: madspace._madspace_py.Value, q: madspace._madspace_py.Value, mean: madspace._madspace_py.Value) → madspace._madspace_py.Value

matmul(self: madspace._madspace_py.FunctionBuilder, x: madspace._madspace_py.Value, weight: madspace._madspace_py.Value, bias: madspace._madspace_py.Value) → madspace._madspace_py.Value

matrix_element(self: madspace._madspace_py.FunctionBuilder, args: collections.abc.Sequence[madspace._madspace_py.Value]) → list[madspace._madspace_py.Value]

max(self: madspace._madspace_py.FunctionBuilder, in1: madspace._madspace_py.Value, in2: madspace._madspace_py.Value) → madspace._madspace_py.Value

min(self: madspace._madspace_py.FunctionBuilder, in1: madspace._madspace_py.Value, in2: madspace._madspace_py.Value) → madspace._madspace_py.Value

mirror_momenta(self: madspace._madspace_py.FunctionBuilder, p_ext: madspace._madspace_py.Value, mirror: madspace._madspace_py.Value) → madspace._madspace_py.Value

momenta_to_x1x2(self: madspace._madspace_py.FunctionBuilder, p_ext: madspace._madspace_py.Value, e_cm: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

mul(self: madspace._madspace_py.FunctionBuilder, in1: madspace._madspace_py.Value, in2: madspace._madspace_py.Value) → madspace._madspace_py.Value

nonzero(self: madspace._madspace_py.FunctionBuilder, input: madspace._madspace_py.Value) → madspace._madspace_py.Value

obs_delta_eta(self: madspace._madspace_py.FunctionBuilder, p1: madspace._madspace_py.Value, p2: madspace._madspace_py.Value) → madspace._madspace_py.Value

obs_delta_phi(self: madspace._madspace_py.FunctionBuilder, p1: madspace._madspace_py.Value, p2: madspace._madspace_py.Value) → madspace._madspace_py.Value

obs_delta_r(self: madspace._madspace_py.FunctionBuilder, p1: madspace._madspace_py.Value, p2: madspace._madspace_py.Value) → madspace._madspace_py.Value

obs_e(self: madspace._madspace_py.FunctionBuilder, p: madspace._madspace_py.Value) → madspace._madspace_py.Value

obs_eta(self: madspace._madspace_py.FunctionBuilder, p: madspace._madspace_py.Value) → madspace._madspace_py.Value

obs_eta_abs(self: madspace._madspace_py.FunctionBuilder, p: madspace._madspace_py.Value) → madspace._madspace_py.Value

obs_mass(self: madspace._madspace_py.FunctionBuilder, p: madspace._madspace_py.Value) → madspace._madspace_py.Value

obs_p_mag(self: madspace._madspace_py.FunctionBuilder, p: madspace._madspace_py.Value) → madspace._madspace_py.Value

obs_phi(self: madspace._madspace_py.FunctionBuilder, p: madspace._madspace_py.Value) → madspace._madspace_py.Value

obs_pt(self: madspace._madspace_py.FunctionBuilder, p: madspace._madspace_py.Value) → madspace._madspace_py.Value

obs_px(self: madspace._madspace_py.FunctionBuilder, p: madspace._madspace_py.Value) → madspace._madspace_py.Value

obs_py(self: madspace._madspace_py.FunctionBuilder, p: madspace._madspace_py.Value) → madspace._madspace_py.Value

obs_pz(self: madspace._madspace_py.FunctionBuilder, p: madspace._madspace_py.Value) → madspace._madspace_py.Value

obs_sqrt_s(self: madspace._madspace_py.FunctionBuilder, p_ext: madspace._madspace_py.Value) → madspace._madspace_py.Value

obs_theta(self: madspace._madspace_py.FunctionBuilder, p: madspace._madspace_py.Value) → madspace._madspace_py.Value

obs_y(self: madspace._madspace_py.FunctionBuilder, p: madspace._madspace_py.Value) → madspace._madspace_py.Value

obs_y_abs(self: madspace._madspace_py.FunctionBuilder, p: madspace._madspace_py.Value) → madspace._madspace_py.Value

offset_indices(self: madspace._madspace_py.FunctionBuilder, batch_sizes_offset: madspace._madspace_py.Value, batch_sizes_out: madspace._madspace_py.Value) → madspace._madspace_py.Value

one_hot(self: madspace._madspace_py.FunctionBuilder, index: madspace._madspace_py.Value, option_count: madspace._madspace_py.Value) → madspace._madspace_py.Value

output(self: madspace._madspace_py.FunctionBuilder, index: SupportsInt, value: madspace._madspace_py.Value) → None

output_range(self: madspace._madspace_py.FunctionBuilder, start_index: SupportsInt, values: collections.abc.Sequence[madspace._madspace_py.Value]) → None

permute_momenta(self: madspace._madspace_py.FunctionBuilder, momenta: madspace._madspace_py.Value, permutations: madspace._madspace_py.Value, index: madspace._madspace_py.Value) → madspace._madspace_py.Value

pop(self: madspace._madspace_py.FunctionBuilder, in1: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

product(self: madspace._madspace_py.FunctionBuilder, values: collections.abc.Sequence[madspace._madspace_py.Value]) → madspace._madspace_py.Value

pt_eta_phi_x(self: madspace._madspace_py.FunctionBuilder, p_ext: madspace._madspace_py.Value, x1: madspace._madspace_py.Value, x2: madspace._madspace_py.Value) → madspace._madspace_py.Value

r_to_x1x2(self: madspace._madspace_py.FunctionBuilder, r: madspace._madspace_py.Value, s_hat: madspace._madspace_py.Value, s_lab: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(3)']

random(self: madspace._madspace_py.FunctionBuilder, batch_size: madspace._madspace_py.Value, count: madspace._madspace_py.Value) → madspace._madspace_py.Value

reduce_product(self: madspace._madspace_py.FunctionBuilder, in1: madspace._madspace_py.Value) → madspace._madspace_py.Value

reduce_sum(self: madspace._madspace_py.FunctionBuilder, in1: madspace._madspace_py.Value) → madspace._madspace_py.Value

reduce_sum_vector(self: madspace._madspace_py.FunctionBuilder, in1: madspace._madspace_py.Value) → madspace._madspace_py.Value

relu(self: madspace._madspace_py.FunctionBuilder, in1: madspace._madspace_py.Value) → madspace._madspace_py.Value

rqs_find_bin(self: madspace._madspace_py.FunctionBuilder, input: madspace._madspace_py.Value, in_sizes: madspace._madspace_py.Value, out_sizes: madspace._madspace_py.Value, derivatives: madspace._madspace_py.Value) → madspace._madspace_py.Value

rqs_forward(self: madspace._madspace_py.FunctionBuilder, input: madspace._madspace_py.Value, condition: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

rqs_inverse(self: madspace._madspace_py.FunctionBuilder, input: madspace._madspace_py.Value, condition: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

rqs_reshape(self: madspace._madspace_py.FunctionBuilder, input: madspace._madspace_py.Value, bin_count: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(3)']

s23_min_max(self: madspace._madspace_py.FunctionBuilder, pa: madspace._madspace_py.Value, pb: madspace._madspace_py.Value, p3: madspace._madspace_py.Value, t1_abs: madspace._madspace_py.Value, m1: madspace._madspace_py.Value, m2: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

s23_value_and_min_max(self: madspace._madspace_py.FunctionBuilder, pa: madspace._madspace_py.Value, pb: madspace._madspace_py.Value, p3: madspace._madspace_py.Value, t1_abs: madspace._madspace_py.Value, p1: madspace._madspace_py.Value, p2: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(3)']

sample_discrete(self: madspace._madspace_py.FunctionBuilder, r: madspace._madspace_py.Value, option_count: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

sample_discrete_inverse(self: madspace._madspace_py.FunctionBuilder, index: madspace._madspace_py.Value, option_count: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

sample_discrete_probs(self: madspace._madspace_py.FunctionBuilder, r: madspace._madspace_py.Value, probs: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

sample_discrete_probs_inverse(self: madspace._madspace_py.FunctionBuilder, index: madspace._madspace_py.Value, probs: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

scale_half_transverse_mass(self: madspace._madspace_py.FunctionBuilder, momenta: madspace._madspace_py.Value) → madspace._madspace_py.Value

scale_partonic_energy(self: madspace._madspace_py.FunctionBuilder, momenta: madspace._madspace_py.Value) → madspace._madspace_py.Value

scale_transverse_energy(self: madspace._madspace_py.FunctionBuilder, momenta: madspace._madspace_py.Value) → madspace._madspace_py.Value

scale_transverse_mass(self: madspace._madspace_py.FunctionBuilder, momenta: madspace._madspace_py.Value) → madspace._madspace_py.Value

sde2_channel_weights(self: madspace._madspace_py.FunctionBuilder, invariants: madspace._madspace_py.Value, masses: madspace._madspace_py.Value, widths: madspace._madspace_py.Value, indices: madspace._madspace_py.Value) → madspace._madspace_py.Value

select(self: madspace._madspace_py.FunctionBuilder, input: madspace._madspace_py.Value, indices: madspace._madspace_py.Value) → madspace._madspace_py.Value

select_int(self: madspace._madspace_py.FunctionBuilder, input: madspace._madspace_py.Value, indices: madspace._madspace_py.Value) → madspace._madspace_py.Value

select_vector(self: madspace._madspace_py.FunctionBuilder, input: madspace._madspace_py.Value, indices: madspace._madspace_py.Value) → madspace._madspace_py.Value

set_current_stream(self: madspace._madspace_py.FunctionBuilder, arg0: SupportsInt) → None

sigmoid(self: madspace._madspace_py.FunctionBuilder, in1: madspace._madspace_py.Value) → madspace._madspace_py.Value

softmax(self: madspace._madspace_py.FunctionBuilder, input: madspace._madspace_py.Value) → madspace._madspace_py.Value

softmax_prior(self: madspace._madspace_py.FunctionBuilder, input: madspace._madspace_py.Value, prior: madspace._madspace_py.Value) → madspace._madspace_py.Value

softplus(self: madspace._madspace_py.FunctionBuilder, in1: madspace._madspace_py.Value) → madspace._madspace_py.Value

sqrt(self: madspace._madspace_py.FunctionBuilder, in1: madspace._madspace_py.Value) → madspace._madspace_py.Value

square(self: madspace._madspace_py.FunctionBuilder, in1: madspace._madspace_py.Value) → madspace._madspace_py.Value

squeeze(self: madspace._madspace_py.FunctionBuilder, input: madspace._madspace_py.Value) → madspace._madspace_py.Value

stable_invariant(self: madspace._madspace_py.FunctionBuilder, r: madspace._madspace_py.Value, mass: madspace._madspace_py.Value, s_min: madspace._madspace_py.Value, s_max: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

stable_invariant_inverse(self: madspace._madspace_py.FunctionBuilder, s: madspace._madspace_py.Value, mass: madspace._madspace_py.Value, s_min: madspace._madspace_py.Value, s_max: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

stable_invariant_nu(self: madspace._madspace_py.FunctionBuilder, r: madspace._madspace_py.Value, mass: madspace._madspace_py.Value, nu: madspace._madspace_py.Value, s_min: madspace._madspace_py.Value, s_max: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

stable_invariant_nu_inverse(self: madspace._madspace_py.FunctionBuilder, s: madspace._madspace_py.Value, mass: madspace._madspace_py.Value, nu: madspace._madspace_py.Value, s_min: madspace._madspace_py.Value, s_max: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

stack(self: madspace._madspace_py.FunctionBuilder, args: collections.abc.Sequence[madspace._madspace_py.Value]) → madspace._madspace_py.Value

stack_sizes(self: madspace._madspace_py.FunctionBuilder, args: collections.abc.Sequence[madspace._madspace_py.Value]) → madspace._madspace_py.Value

sub(self: madspace._madspace_py.FunctionBuilder, in1: madspace._madspace_py.Value, in2: madspace._madspace_py.Value) → madspace._madspace_py.Value

subchannel_weights(self: madspace._madspace_py.FunctionBuilder, invariants: madspace._madspace_py.Value, masses: madspace._madspace_py.Value, widths: madspace._madspace_py.Value, indices: madspace._madspace_py.Value, on_shell: madspace._madspace_py.Value, group_sizes: madspace._madspace_py.Value) → madspace._madspace_py.Value

t_inv_min_max(self: madspace._madspace_py.FunctionBuilder, pa: madspace._madspace_py.Value, pb: madspace._madspace_py.Value, m1: madspace._madspace_py.Value, m2: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

t_inv_value_and_min_max(self: madspace._madspace_py.FunctionBuilder, pa: madspace._madspace_py.Value, pb: madspace._madspace_py.Value, p1: madspace._madspace_py.Value, p2: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(3)']

three_body_decay(self: madspace._madspace_py.FunctionBuilder, r_e1: madspace._madspace_py.Value, r_e2: madspace._madspace_py.Value, r_phi: madspace._madspace_py.Value, r_cos_theta: madspace._madspace_py.Value, r_beta: madspace._madspace_py.Value, m0: madspace._madspace_py.Value, m1: madspace._madspace_py.Value, m2: madspace._madspace_py.Value, m3: madspace._madspace_py.Value, p0: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(4)']

three_body_decay_com(self: madspace._madspace_py.FunctionBuilder, r_e1: madspace._madspace_py.Value, r_e2: madspace._madspace_py.Value, r_phi: madspace._madspace_py.Value, r_cos_theta: madspace._madspace_py.Value, r_beta: madspace._madspace_py.Value, m0: madspace._madspace_py.Value, m1: madspace._madspace_py.Value, m2: madspace._madspace_py.Value, m3: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(4)']

three_body_decay_com_inverse(self: madspace._madspace_py.FunctionBuilder, p1: madspace._madspace_py.Value, p2: madspace._madspace_py.Value, p3: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(10)']

three_body_decay_inverse(self: madspace._madspace_py.FunctionBuilder, p1: madspace._madspace_py.Value, p2: madspace._madspace_py.Value, p3: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(11)']

two_body_decay(self: madspace._madspace_py.FunctionBuilder, r_phi: madspace._madspace_py.Value, r_cos_theta: madspace._madspace_py.Value, m0: madspace._madspace_py.Value, m1: madspace._madspace_py.Value, m2: madspace._madspace_py.Value, p0: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(3)']

two_body_decay_com(self: madspace._madspace_py.FunctionBuilder, r_phi: madspace._madspace_py.Value, r_cos_theta: madspace._madspace_py.Value, m0: madspace._madspace_py.Value, m1: madspace._madspace_py.Value, m2: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(3)']

two_body_decay_com_inverse(self: madspace._madspace_py.FunctionBuilder, p1: madspace._madspace_py.Value, p2: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(6)']

two_body_decay_inverse(self: madspace._madspace_py.FunctionBuilder, p1: madspace._madspace_py.Value, p2: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(7)']

two_to_three_particle_scattering(self: madspace._madspace_py.FunctionBuilder, phi_choice: madspace._madspace_py.Value, pa: madspace._madspace_py.Value, pb: madspace._madspace_py.Value, p3: madspace._madspace_py.Value, s23: madspace._madspace_py.Value, t1_abs: madspace._madspace_py.Value, m1: madspace._madspace_py.Value, m2: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(3)']

two_to_three_particle_scattering_inverse(self: madspace._madspace_py.FunctionBuilder, p1: madspace._madspace_py.Value, p2: madspace._madspace_py.Value, p3: madspace._madspace_py.Value, pa: madspace._madspace_py.Value, pb: madspace._madspace_py.Value, t1_abs: madspace._madspace_py.Value, s23: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(4)']

two_to_two_particle_scattering(self: madspace._madspace_py.FunctionBuilder, r_phi: madspace._madspace_py.Value, pa: madspace._madspace_py.Value, pb: madspace._madspace_py.Value, t_abs: madspace._madspace_py.Value, m1: madspace._madspace_py.Value, m2: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(3)']

two_to_two_particle_scattering_com(self: madspace._madspace_py.FunctionBuilder, r_phi: madspace._madspace_py.Value, pa: madspace._madspace_py.Value, pb: madspace._madspace_py.Value, t_abs: madspace._madspace_py.Value, m1: madspace._madspace_py.Value, m2: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(3)']

two_to_two_particle_scattering_com_inverse(self: madspace._madspace_py.FunctionBuilder, p1: madspace._madspace_py.Value, p2: madspace._madspace_py.Value, pa: madspace._madspace_py.Value, pb: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(4)']

two_to_two_particle_scattering_inverse(self: madspace._madspace_py.FunctionBuilder, p1: madspace._madspace_py.Value, p2: madspace._madspace_py.Value, pa: madspace._madspace_py.Value, pb: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(4)']

uniform_invariant(self: madspace._madspace_py.FunctionBuilder, r: madspace._madspace_py.Value, s_min: madspace._madspace_py.Value, s_max: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

uniform_invariant_inverse(self: madspace._madspace_py.FunctionBuilder, s: madspace._madspace_py.Value, s_min: madspace._madspace_py.Value, s_max: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

unsqueeze(self: madspace._madspace_py.FunctionBuilder, input: madspace._madspace_py.Value) → madspace._madspace_py.Value

unstack(self: madspace._madspace_py.FunctionBuilder, in1: madspace._madspace_py.Value) → list[madspace._madspace_py.Value]

unstack_sizes(self: madspace._madspace_py.FunctionBuilder, in1: madspace._madspace_py.Value) → list[madspace._madspace_py.Value]

unweight(self: madspace._madspace_py.FunctionBuilder, weights: madspace._madspace_py.Value, max_weight: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

vegas_forward(self: madspace._madspace_py.FunctionBuilder, input: madspace._madspace_py.Value, grid: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

vegas_histogram(self: madspace._madspace_py.FunctionBuilder, input: madspace._madspace_py.Value, weights: madspace._madspace_py.Value, bin_count: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

vegas_inverse(self: madspace._madspace_py.FunctionBuilder, input: madspace._madspace_py.Value, grid: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

x1x2_to_r(self: madspace._madspace_py.FunctionBuilder, x1: madspace._madspace_py.Value, x2: madspace._madspace_py.Value, s_lab: madspace._madspace_py.Value) → Annotated[list[madspace._madspace_py.Value], 'FixedSize(2)']

class madspace.FunctionGenerator(self: madspace._madspace_py.FunctionGenerator, name: str, arg_types: madspace._madspace_py.NamedTypes, return_types: madspace._madspace_py.NamedTypes)

Bases: pybind11_object

build_function(*args, **kwargs)

Overloaded function.

1. build_function(self: madspace._madspace_py.FunctionGenerator, builder: madspace._madspace_py.FunctionBuilder, args: collections.abc.Sequence[madspace._madspace_py.Value]) -> madspace._madspace_py.NamedValues

2. build_function(self: madspace._madspace_py.FunctionGenerator, builder: madspace._madspace_py.FunctionBuilder, args: madspace._madspace_py.NamedValues) -> madspace._madspace_py.NamedValues

function(self: madspace._madspace_py.FunctionGenerator) → madspace._madspace_py.Function

class madspace.FunctionRuntime(*args, **kwargs)

Bases: pybind11_object

Overloaded function.

1. __init__(self: madspace._madspace_py.FunctionRuntime, function: madspace._madspace_py.Function) -> None

2. __init__(self: madspace._madspace_py.FunctionRuntime, function: madspace._madspace_py.Function, context: madspace._madspace_py.Context) -> None

call(self: madspace._madspace_py.FunctionRuntime, arg0: collections.abc.Sequence[object]) → list[madspace._madspace_py.Tensor]

call_backward(self: madspace._madspace_py.FunctionRuntime, arg0: collections.abc.Sequence[object], arg1: collections.abc.Sequence[object], arg2: collections.abc.Sequence[bool]) → tuple[list[madspace._madspace_py.Tensor | None], list[tuple[str, madspace._madspace_py.Tensor | None]]]

call_with_grad(self: madspace._madspace_py.FunctionRuntime, arg0: collections.abc.Sequence[object], arg1: collections.abc.Sequence[bool]) → tuple[list[madspace._madspace_py.Tensor], list[madspace._madspace_py.Tensor | None], list[bool]]

class madspace.GeneratorConfig(self: madspace._madspace_py.GeneratorConfig)

Bases: pybind11_object

property combine_thread_count

property cpu_batch_size

property freeze_max_weight_after

property gpu_batch_size

property max_batch_size

property max_overweight_truncation

property optimization_patience

property optimization_threshold

property start_batch_size

property survey_max_iters

property survey_min_iters

property survey_target_precision

property target_count

property vegas_damping

property verbosity

property write_live_data

class madspace.GeneratorStatus(self: madspace._madspace_py.GeneratorStatus)

Bases: pybind11_object

property count

property count_after_cuts

property count_after_cuts_opt

property count_opt

property count_target

property count_unweighted

property done

property error

property iterations

property mean

property name

property optimized

property rel_std_dev

property subprocess

class madspace.HistItem(self: madspace._madspace_py.HistItem, observable: madspace._madspace_py.Observable, min: SupportsFloat, max: SupportsFloat, bin_count: SupportsInt)

Bases: pybind11_object

property bin_count

property max

property min

property observable

class madspace.Histogram

Bases: pybind11_object

property bin_errors

property bin_values

property max

property min

property name

class madspace.Instruction

Bases: pybind11_object

property name

property opcode

class madspace.InstructionCall

Bases: pybind11_object

property inputs

property instruction

property outputs

class madspace.Integrand(self: madspace._madspace_py.Integrand, mapping: madspace._madspace_py.PhaseSpaceMapping, diff_xs: madspace._madspace_py.DifferentialCrossSection, adaptive_map: None | madspace._madspace_py.VegasMapping | madspace._madspace_py.Flow = None, discrete_before: None | madspace._madspace_py.DiscreteSampler | madspace._madspace_py.DiscreteFlow = None, discrete_after: None | madspace._madspace_py.DiscreteSampler | madspace._madspace_py.DiscreteFlow = None, pdf_grid: madspace._madspace_py.PdfGrid | None = None, energy_scale: madspace._madspace_py.EnergyScale | None = None, prop_chan_weights: madspace._madspace_py.PropagatorChannelWeights | None = None, subchan_weights: madspace._madspace_py.SubchannelWeights | None = None, chan_weight_net: madspace._madspace_py.ChannelWeightNetwork | None = None, chan_weight_remap: collections.abc.Sequence[SupportsInt] = [], remapped_chan_count: SupportsInt = 0, flags: SupportsInt = 0, channel_indices: collections.abc.Sequence[SupportsInt] = [], active_flavors: collections.abc.Sequence[SupportsInt] = [], flavor_remap: collections.abc.Sequence[SupportsInt] = [], flavor_factors: collections.abc.Sequence[SupportsFloat] = [])

Bases: FunctionGenerator

adaptive_map(self: madspace._madspace_py.Integrand) → None | madspace._madspace_py.VegasMapping | madspace._madspace_py.Flow

chan_weight_net(self: madspace._madspace_py.Integrand) → madspace._madspace_py.ChannelWeightNetwork | None

diff_xs(self: madspace._madspace_py.Integrand) → madspace._madspace_py.DifferentialCrossSection

discrete_after(self: madspace._madspace_py.Integrand) → None | madspace._madspace_py.DiscreteSampler | madspace._madspace_py.DiscreteFlow

discrete_before(self: madspace._madspace_py.Integrand) → None | madspace._madspace_py.DiscreteSampler | madspace._madspace_py.DiscreteFlow

drop_cuts_and_rescale = 8192

energy_scale(self: madspace._madspace_py.Integrand) → madspace._madspace_py.EnergyScale | None

exclude_adaptive_and_chan_weight = 4096

flags(self: madspace._madspace_py.Integrand) → int

latent_dims(self: madspace._madspace_py.Integrand) → tuple[list[int], list[bool]]

mapping(self: madspace._madspace_py.Integrand) → madspace._madspace_py.PhaseSpaceMapping

matrix_element_inputs = [<MatrixElementInput.momenta_in: 0>, <MatrixElementInput.alpha_s_in: 1>, <MatrixElementInput.flavor_in: 2>, <MatrixElementInput.random_color_in: 3>, <MatrixElementInput.random_helicity_in: 4>, <MatrixElementInput.random_diagram_in: 5>]

matrix_element_outputs = [<MatrixElementOutput.matrix_element_out: 0>, <MatrixElementOutput.diagram_amp2_out: 1>, <MatrixElementOutput.color_index_out: 2>, <MatrixElementOutput.helicity_index_out: 3>, <MatrixElementOutput.diagram_index_out: 4>]

particle_count(self: madspace._madspace_py.Integrand) → int

prop_chan_weights(self: madspace._madspace_py.Integrand) → madspace._madspace_py.PropagatorChannelWeights | None

random_dim(self: madspace._madspace_py.Integrand) → int

return_chan_weights = 256

return_channel = 128

return_cwnet_input = 512

return_discrete = 1024

return_discrete_latent = 2048

return_indices = 16

return_latent = 64

return_momenta = 4

return_random = 32

return_x1_x2 = 8

sample = 1

unweight = 2

vegas_grid_name(self: madspace._madspace_py.Integrand) → str | None

class madspace.IntegrandProbability(self: madspace._madspace_py.IntegrandProbability, integrand: madspace._madspace_py.Integrand)

Bases: FunctionGenerator

class madspace.Invariant(self: madspace._madspace_py.Invariant, power: SupportsFloat = 0.0, mass: SupportsFloat = 0.0, width: SupportsFloat = 0.0)

Bases: Mapping

class madspace.LHECompleter(self: madspace._madspace_py.LHECompleter, subproc_args: collections.abc.Sequence[madspace._madspace_py.SubprocArgs], bw_cutoff: SupportsFloat)

Bases: pybind11_object

static load(file: str) → madspace._madspace_py.LHECompleter

property max_particle_count

save(self: madspace._madspace_py.LHECompleter, file: str) → None

class madspace.LHEEvent(self: madspace._madspace_py.LHEEvent, process_id: SupportsInt = 0, weight: SupportsFloat = 0.0, scale: SupportsFloat = 0.0, alpha_qed: SupportsFloat = 0.0, alpha_qcd: SupportsFloat = 0.0, particles: collections.abc.Sequence[madspace._madspace_py.LHEParticle] = [])

Bases: pybind11_object

property alpha_qcd

property alpha_qed

property particles

property process_id

property scale

property weight

class madspace.LHEFileWriter(self: madspace._madspace_py.LHEFileWriter, file_name: str, meta: madspace._madspace_py.LHEMeta)

Bases: pybind11_object

write(self: madspace._madspace_py.LHEFileWriter, event: madspace._madspace_py.LHEEvent) → None

write_string(self: madspace._madspace_py.LHEFileWriter, str: str) → None

class madspace.LHEHeader(self: madspace._madspace_py.LHEHeader, name: str = '', content: str = '', escape_content: bool = False)

Bases: pybind11_object

property content

property escape_content

property name

class madspace.LHEMeta(self: madspace._madspace_py.LHEMeta, beam1_pdg_id: SupportsInt = 0, beam2_pdg_id: SupportsInt = 0, beam1_energy: SupportsFloat = 0.0, beam2_energy: SupportsFloat = 0.0, beam1_pdf_authors: SupportsInt = 0, beam2_pdf_authors: SupportsInt = 0, beam1_pdf_id: SupportsInt = 0, beam2_pdf_id: SupportsInt = 0, weight_mode: SupportsInt = 0, processes: collections.abc.Sequence[madspace._madspace_py.LHEProcess] = [], headers: collections.abc.Sequence[madspace._madspace_py.LHEHeader] = [])

Bases: pybind11_object

property beam1_energy

property beam1_pdf_authors

property beam1_pdf_id

property beam1_pdg_id

property beam2_energy

property beam2_pdf_authors

property beam2_pdf_id

property beam2_pdg_id

property headers

property processes

property weight_mode

class madspace.LHEParticle(self: madspace._madspace_py.LHEParticle, pdg_id: SupportsInt = 0, status_code: SupportsInt = 0, mother1: SupportsInt = 0, mother2: SupportsInt = 0, color: SupportsInt = 0, anti_color: SupportsInt = 0, p_x: SupportsFloat = 0.0, p_y: SupportsFloat = 0.0, p_z: SupportsFloat = 0.0, energy: SupportsFloat = 0.0, mass: SupportsFloat = 0.0, lifetime: SupportsFloat = 0.0, spin: SupportsFloat = 0.0)

Bases: pybind11_object

property anti_color

property color

property energy

property lifetime

property mass

property mother1

property mother2

property pdg_id

property px

property py

property pz

property spin

property status_code

status_incoming = -1

status_intermediate_resonance = 2

status_outgoing = 1

class madspace.LHEProcess(self: madspace._madspace_py.LHEProcess, cross_section: SupportsFloat = 0.0, cross_section_error: SupportsFloat = 0.0, max-weight: SupportsFloat = 0.0, process_id: SupportsInt = 0)

Bases: pybind11_object

property cross_section

property cross_section_error

property max_weight

property process_id

class madspace.LineRef(self: madspace._madspace_py.LineRef, str: str)

Bases: pybind11_object

class madspace.Logger

Bases: pybind11_object

class LogLevel(*args, **kwargs)

Bases: pybind11_object

Members:

level_debug

level_info

level_warning

level_error

Overloaded function.

1. __init__(self: madspace._madspace_py.Logger.LogLevel, value: typing.SupportsInt) -> None

2. __init__(self: madspace._madspace_py.Logger.LogLevel, name: str) -> None

level_debug = <LogLevel.level_debug: 0>

level_error = <LogLevel.level_error: 3>

level_info = <LogLevel.level_info: 1>

level_warning = <LogLevel.level_warning: 2>

Logger.LogLevel.name -> str

property value

static debug(message: str) → None

static error(message: str) → None

static info(message: str) → None

level_debug = <LogLevel.level_debug: 0>

level_error = <LogLevel.level_error: 3>

level_info = <LogLevel.level_info: 1>

level_warning = <LogLevel.level_warning: 2>

static log(level: madspace._madspace_py.Logger.LogLevel, message: str) → None

static set_log_handler(func: collections.abc.Callable[[madspace._madspace_py.Logger.LogLevel, str], None]) → None

static warning(message: str) → None

class madspace.Luminosity(self: madspace._madspace_py.Luminosity, s_lab: SupportsFloat, s_hat_min: SupportsFloat, s_hat_max: SupportsFloat = 0.0, invariant_power: SupportsFloat = 0.0, mass: SupportsFloat = 0.0, width: SupportsFloat = 0.0)

Bases: Mapping

class madspace.MLP(self: madspace._madspace_py.MLP, input_dim: SupportsInt, output_dim: SupportsInt, hidden_dim: SupportsInt = 32, layers: SupportsInt = 3, activation: madspace._madspace_py.MLP.Activation = <Activation.leaky_relu: 1>, prefix: str = '')

Bases: FunctionGenerator

class Activation(*args, **kwargs)

Bases: pybind11_object

Members:

relu

leaky_relu

elu

gelu

sigmoid

softplus

linear

Overloaded function.

1. __init__(self: madspace._madspace_py.MLP.Activation, value: typing.SupportsInt) -> None

2. __init__(self: madspace._madspace_py.MLP.Activation, name: str) -> None

elu = <Activation.elu: 2>

gelu = <Activation.gelu: 3>

leaky_relu = <Activation.leaky_relu: 1>

linear = <Activation.linear: 6>

MLP.Activation.name -> str

relu = <Activation.relu: 0>

sigmoid = <Activation.sigmoid: 4>

softplus = <Activation.softplus: 5>

property value

elu = <Activation.elu: 2>

gelu = <Activation.gelu: 3>

initialize_globals(self: madspace._madspace_py.MLP, context: madspace._madspace_py.Context) → None

input_dim(self: madspace._madspace_py.MLP) → int

leaky_relu = <Activation.leaky_relu: 1>

linear = <Activation.linear: 6>

output_dim(self: madspace._madspace_py.MLP) → int

relu = <Activation.relu: 0>

sigmoid = <Activation.sigmoid: 4>

softplus = <Activation.softplus: 5>

class madspace.MadnisConfig(self: madspace._madspace_py.MadnisConfig)

Bases: pybind11_object

property adam_beta1

property adam_beta2

property adam_eps

property batch_size_offset

property batch_size_per_channel

property batches

property buffer_capacity

property buffer_unweighting_quantile

property buffered_steps

property channel_dropping_interval

property channel_dropping_threshold

property cpu_generator_batch_size

property fixed_cwnet_fraction

property generator_target_size_factor

property gpu_generator_batch_granularity

property gpu_generator_batch_size

property integration_history_length

property learning_rate

property log_interval

property lr_schedule

property minimum_buffer_size

property softclip_threshold

property uniform_channel_ratio

property verbosity

class madspace.MadnisLoss(self: madspace._madspace_py.MadnisLoss, functions: collections.abc.Sequence[madspace._madspace_py.FunctionGenerator], cwnet: madspace._madspace_py.ChannelWeightNetwork | None, softclip_threshold: SupportsFloat = 0.0)

Bases: FunctionGenerator

class madspace.MadnisTraining(self: madspace._madspace_py.MadnisTraining, generator_context: madspace._madspace_py.Context, optimizer_context: madspace._madspace_py.Context, config: madspace._madspace_py.MadnisConfig, integrands: collections.abc.Sequence[madspace._madspace_py.Integrand], cwnet: madspace._madspace_py.ChannelWeightNetwork | None)

Bases: pybind11_object

active_channel_count(self: madspace._madspace_py.MadnisTraining) → int

active_channels(self: madspace._madspace_py.MadnisTraining) → list[int]

train_step(self: madspace._madspace_py.MadnisTraining, batch_index: SupportsInt) → None

class madspace.Mapping(self: madspace._madspace_py.Mapping, name: str, input_types: madspace._madspace_py.NamedTypes, output_types: madspace._madspace_py.NamedTypes, condition_types: madspace._madspace_py.NamedTypes)

Bases: pybind11_object

build_forward(*args, **kwargs)

Overloaded function.

1. build_forward(self: madspace._madspace_py.Mapping, builder: madspace._madspace_py.FunctionBuilder, inputs: collections.abc.Sequence[madspace._madspace_py.Value], conditions: collections.abc.Sequence[madspace._madspace_py.Value]) -> madspace._madspace_py.NamedValues

2. build_forward(self: madspace._madspace_py.Mapping, builder: madspace._madspace_py.FunctionBuilder, inputs: madspace._madspace_py.NamedValues, conditions: madspace._madspace_py.NamedValues) -> madspace._madspace_py.NamedValues

build_inverse(*args, **kwargs)

Overloaded function.

1. build_inverse(self: madspace._madspace_py.Mapping, builder: madspace._madspace_py.FunctionBuilder, inputs: collections.abc.Sequence[madspace._madspace_py.Value], conditions: collections.abc.Sequence[madspace._madspace_py.Value]) -> madspace._madspace_py.NamedValues

2. build_inverse(self: madspace._madspace_py.Mapping, builder: madspace._madspace_py.FunctionBuilder, inputs: madspace._madspace_py.NamedValues, conditions: madspace._madspace_py.NamedValues) -> madspace._madspace_py.NamedValues

forward_function(self: madspace._madspace_py.Mapping) → madspace._madspace_py.Function

inverse_function(self: madspace._madspace_py.Mapping) → madspace._madspace_py.Function

map_forward(inputs=[], conditions=[], **kwargs)

map_inverse(inputs=[], conditions=[], **kwargs)

class madspace.MatrixElement(*args, **kwargs)

Bases: FunctionGenerator

Overloaded function.

1. __init__(self: madspace._madspace_py.MatrixElement, matrix_element_index: typing.SupportsInt, particle_count: typing.SupportsInt, inputs: collections.abc.Sequence[madspace._madspace_py.MatrixElement.MatrixElementInput], outputs: collections.abc.Sequence[madspace._madspace_py.MatrixElement.MatrixElementOutput], diagram_count: typing.SupportsInt = 1, sample_random_inputs: bool = False) -> None

2. __init__(self: madspace._madspace_py.MatrixElement, matrix_element_api: madspace._madspace_py.MatrixElementApi, inputs: collections.abc.Sequence[madspace._madspace_py.MatrixElement.MatrixElementInput], outputs: collections.abc.Sequence[madspace._madspace_py.MatrixElement.MatrixElementOutput], sample_random_inputs: bool = False) -> None

class MatrixElementInput(*args, **kwargs)

Bases: pybind11_object

Members:

momenta_in

alpha_s_in

flavor_in

random_color_in

random_helicity_in

random_diagram_in

helicity_in

diagram_in

Overloaded function.

1. __init__(self: madspace._madspace_py.MatrixElement.MatrixElementInput, value: typing.SupportsInt) -> None

2. __init__(self: madspace._madspace_py.MatrixElement.MatrixElementInput, name: str) -> None

alpha_s_in = <MatrixElementInput.alpha_s_in: 1>

diagram_in = <MatrixElementInput.diagram_in: 7>

flavor_in = <MatrixElementInput.flavor_in: 2>

helicity_in = <MatrixElementInput.helicity_in: 6>

momenta_in = <MatrixElementInput.momenta_in: 0>

MatrixElement.MatrixElementInput.name -> str

random_color_in = <MatrixElementInput.random_color_in: 3>

random_diagram_in = <MatrixElementInput.random_diagram_in: 5>

random_helicity_in = <MatrixElementInput.random_helicity_in: 4>

property value

class MatrixElementOutput(*args, **kwargs)

Bases: pybind11_object

Members:

matrix_element_out

diagram_amp2_out

color_index_out

helicity_index_out

diagram_index_out

Overloaded function.

1. __init__(self: madspace._madspace_py.MatrixElement.MatrixElementOutput, value: typing.SupportsInt) -> None

2. __init__(self: madspace._madspace_py.MatrixElement.MatrixElementOutput, name: str) -> None

color_index_out = <MatrixElementOutput.color_index_out: 2>

diagram_amp2_out = <MatrixElementOutput.diagram_amp2_out: 1>

diagram_index_out = <MatrixElementOutput.diagram_index_out: 4>

helicity_index_out = <MatrixElementOutput.helicity_index_out: 3>

matrix_element_out = <MatrixElementOutput.matrix_element_out: 0>

MatrixElement.MatrixElementOutput.name -> str

property value

alpha_s_in = <MatrixElementInput.alpha_s_in: 1>

color_index_out = <MatrixElementOutput.color_index_out: 2>

diagram_amp2_out = <MatrixElementOutput.diagram_amp2_out: 1>

diagram_count(self: madspace._madspace_py.MatrixElement) → int

diagram_in = <MatrixElementInput.diagram_in: 7>

diagram_index_out = <MatrixElementOutput.diagram_index_out: 4>

flavor_in = <MatrixElementInput.flavor_in: 2>

helicity_in = <MatrixElementInput.helicity_in: 6>

helicity_index_out = <MatrixElementOutput.helicity_index_out: 3>

matrix_element_index(self: madspace._madspace_py.MatrixElement) → int

matrix_element_out = <MatrixElementOutput.matrix_element_out: 0>

momenta_in = <MatrixElementInput.momenta_in: 0>

particle_count(self: madspace._madspace_py.MatrixElement) → int

random_color_in = <MatrixElementInput.random_color_in: 3>

random_diagram_in = <MatrixElementInput.random_diagram_in: 5>

random_helicity_in = <MatrixElementInput.random_helicity_in: 4>

class madspace.MatrixElementApi

Bases: pybind11_object

diagram_count(self: madspace._madspace_py.MatrixElementApi) → int

helicity_count(self: madspace._madspace_py.MatrixElementApi) → int

index(self: madspace._madspace_py.MatrixElementApi) → int

particle_count(self: madspace._madspace_py.MatrixElementApi) → int

class madspace.MomentumPreprocessing(self: madspace._madspace_py.MomentumPreprocessing, particle_count: SupportsInt)

Bases: FunctionGenerator

output_dim(self: madspace._madspace_py.MomentumPreprocessing) → int

class madspace.MultiChannelFunction(self: madspace._madspace_py.MultiChannelFunction, functions: collections.abc.Sequence[madspace._madspace_py.FunctionGenerator])

Bases: FunctionGenerator

class madspace.MultiChannelIntegrand(self: madspace._madspace_py.MultiChannelIntegrand, integrands: collections.abc.Sequence[madspace._madspace_py.Integrand], return_sizes: bool = False)

Bases: FunctionGenerator

class madspace.MultiChannelMapping(self: madspace._madspace_py.MultiChannelMapping, mappings: collections.abc.Sequence[madspace._madspace_py.Mapping])

Bases: Mapping

class madspace.MultiMadnisTraining(self: madspace._madspace_py.MultiMadnisTraining, generator_context: madspace._madspace_py.Context, optimizer_context: madspace._madspace_py.Context, config: madspace._madspace_py.MadnisConfig, integrands: collections.abc.Sequence[collections.abc.Sequence[madspace._madspace_py.Integrand]], cwnets: collections.abc.Sequence[madspace._madspace_py.ChannelWeightNetwork | None])

Bases: pybind11_object

active_channels(self: madspace._madspace_py.MultiMadnisTraining) → list[list[int]]

train(self: madspace._madspace_py.MultiMadnisTraining) → None

class madspace.NamedTypes(*args, **kwargs)

Bases: pybind11_object

Overloaded function.

1. __init__(self: madspace._madspace_py.NamedTypes) -> None

2. __init__(self: madspace._madspace_py.NamedTypes, keys: collections.abc.Sequence[str], values: collections.abc.Sequence[madspace._madspace_py.Type]) -> None

3. __init__(self: madspace._madspace_py.NamedTypes, items: collections.abc.Sequence[tuple[str, madspace._madspace_py.Type]]) -> None

index_map(self: madspace._madspace_py.NamedTypes) → dict[str, int]

keys(self: madspace._madspace_py.NamedTypes) → list[str]

push_back(self: madspace._madspace_py.NamedTypes, name: str, item: madspace._madspace_py.Type) → None

values(self: madspace._madspace_py.NamedTypes) → list[madspace._madspace_py.Type]

class madspace.NamedValues(*args, **kwargs)

Bases: pybind11_object

Overloaded function.

1. __init__(self: madspace._madspace_py.NamedValues) -> None

2. __init__(self: madspace._madspace_py.NamedValues, keys: collections.abc.Sequence[str], values: collections.abc.Sequence[madspace._madspace_py.Value]) -> None

3. __init__(self: madspace._madspace_py.NamedValues, items: collections.abc.Sequence[tuple[str, madspace._madspace_py.Value]]) -> None

index_map(self: madspace._madspace_py.NamedValues) → dict[str, int]

keys(self: madspace._madspace_py.NamedValues) → list[str]

push_back(self: madspace._madspace_py.NamedValues, name: str, item: madspace._madspace_py.Value) → None

values(self: madspace._madspace_py.NamedValues) → list[madspace._madspace_py.Value]

class madspace.Observable(self: madspace._madspace_py.Observable, pids: collections.abc.Sequence[SupportsInt], observable: madspace._madspace_py.Observable.ObservableOption, select_pids: collections.abc.Sequence[collections.abc.Sequence[SupportsInt]], sum_momenta: bool = False, sum_observable: bool = False, order_observable: madspace._madspace_py.Observable.ObservableOption | None = None, order_indices: collections.abc.Sequence[SupportsInt] = [], ignore_incoming: bool = True, name: str = '')

Bases: FunctionGenerator

class ObservableOption(*args, **kwargs)

Bases: pybind11_object

Members:

obs_e

obs_px

obs_py

obs_pz

obs_mass

obs_pt

obs_p_mag

obs_phi

obs_theta

obs_y

obs_y_abs

obs_eta

obs_eta_abs

obs_delta_eta

obs_delta_phi

obs_delta_r

obs_sqrt_s

Overloaded function.

1. __init__(self: madspace._madspace_py.Observable.ObservableOption, value: typing.SupportsInt) -> None

2. __init__(self: madspace._madspace_py.Observable.ObservableOption, name: str) -> None

Observable.ObservableOption.name -> str

obs_delta_eta = <ObservableOption.obs_delta_eta: 13>

obs_delta_phi = <ObservableOption.obs_delta_phi: 14>

obs_delta_r = <ObservableOption.obs_delta_r: 15>

obs_e = <ObservableOption.obs_e: 0>

obs_eta = <ObservableOption.obs_eta: 11>

obs_eta_abs = <ObservableOption.obs_eta_abs: 12>

obs_mass = <ObservableOption.obs_mass: 4>

obs_p_mag = <ObservableOption.obs_p_mag: 6>

obs_phi = <ObservableOption.obs_phi: 7>

obs_pt = <ObservableOption.obs_pt: 5>

obs_px = <ObservableOption.obs_px: 1>

obs_py = <ObservableOption.obs_py: 2>

obs_pz = <ObservableOption.obs_pz: 3>

obs_sqrt_s = <ObservableOption.obs_sqrt_s: 16>

obs_theta = <ObservableOption.obs_theta: 8>

obs_y = <ObservableOption.obs_y: 9>

obs_y_abs = <ObservableOption.obs_y_abs: 10>

property value

bottom_pids = [-5, 5]

jet_pids = [1, 2, 3, 4, -1, -2, -3, -4, 21]

lepton_pids = [11, 13, 15, -11, -13, -15]

missing_pids = [12, 14, 16, -12, -14, -16]

obs_delta_eta = <ObservableOption.obs_delta_eta: 13>

obs_delta_phi = <ObservableOption.obs_delta_phi: 14>

obs_delta_r = <ObservableOption.obs_delta_r: 15>

obs_e = <ObservableOption.obs_e: 0>

obs_eta = <ObservableOption.obs_eta: 11>

obs_eta_abs = <ObservableOption.obs_eta_abs: 12>

obs_mass = <ObservableOption.obs_mass: 4>

obs_p_mag = <ObservableOption.obs_p_mag: 6>

obs_phi = <ObservableOption.obs_phi: 7>

obs_pt = <ObservableOption.obs_pt: 5>

obs_px = <ObservableOption.obs_px: 1>

obs_py = <ObservableOption.obs_py: 2>

obs_pz = <ObservableOption.obs_pz: 3>

obs_sqrt_s = <ObservableOption.obs_sqrt_s: 16>

obs_theta = <ObservableOption.obs_theta: 8>

obs_y = <ObservableOption.obs_y: 9>

obs_y_abs = <ObservableOption.obs_y_abs: 10>

photon_pids = [22]

class madspace.ObservableHistograms(self: madspace._madspace_py.ObservableHistograms, observables: collections.abc.Sequence[madspace._madspace_py.HistItem])

Bases: FunctionGenerator

class madspace.PartonDensity(self: madspace._madspace_py.PartonDensity, grid: madspace._madspace_py.PdfGrid, pids: collections.abc.Sequence[SupportsInt], dynamic_pid: bool = False, prefix: str = '')

Bases: FunctionGenerator

class madspace.PdfGrid(self: madspace._madspace_py.PdfGrid, file: str)

Bases: pybind11_object

coefficients_shape(self: madspace._madspace_py.PdfGrid, batch_dim: bool = False) → list[int]

property grid_point_count

initialize_globals(self: madspace._madspace_py.PdfGrid, context: madspace._madspace_py.Context, prefix: str = '') → None

property logq2

logq2_shape(self: madspace._madspace_py.PdfGrid, batch_dim: bool = False) → list[int]

property logx

logx_shape(self: madspace._madspace_py.PdfGrid, batch_dim: bool = False) → list[int]

property pids

property q

property q_count

property region_sizes

property values

property x

class madspace.PhaseSpaceMapping(*args, **kwargs)

Bases: Mapping

Overloaded function.

1. __init__(self: madspace._madspace_py.PhaseSpaceMapping, topology: madspace._madspace_py.Topology, cm_energy: typing.SupportsFloat, leptonic: bool = False, invariant_power: typing.SupportsFloat = 0.8, t_channel_mode: madspace._madspace_py.PhaseSpaceMapping.TChannelMode = <TChannelMode.propagator: 0>, cuts: madspace._madspace_py.Cuts | None = None, permutations: collections.abc.Sequence[collections.abc.Sequence[typing.SupportsInt]] = []) -> None

2. __init__(self: madspace._madspace_py.PhaseSpaceMapping, masses: collections.abc.Sequence[typing.SupportsFloat], cm_energy: typing.SupportsFloat, leptonic: bool = False, invariant_power: typing.SupportsFloat = 0.8, mode: madspace._madspace_py.PhaseSpaceMapping.TChannelMode = <TChannelMode.rambo: 1>, cuts: madspace._madspace_py.Cuts | None = None) -> None

class TChannelMode(*args, **kwargs)

Bases: pybind11_object

Members:

propagator

rambo

chili

Overloaded function.

1. __init__(self: madspace._madspace_py.PhaseSpaceMapping.TChannelMode, value: typing.SupportsInt) -> None

2. __init__(self: madspace._madspace_py.PhaseSpaceMapping.TChannelMode, name: str) -> None

chili = <TChannelMode.chili: 2>

PhaseSpaceMapping.TChannelMode.name -> str

propagator = <TChannelMode.propagator: 0>

rambo = <TChannelMode.rambo: 1>

property value

channel_count(self: madspace._madspace_py.PhaseSpaceMapping) → int

chili = <TChannelMode.chili: 2>

particle_count(self: madspace._madspace_py.PhaseSpaceMapping) → int

propagator = <TChannelMode.propagator: 0>

rambo = <TChannelMode.rambo: 1>

random_dim(self: madspace._madspace_py.PhaseSpaceMapping) → int

class madspace.PrettyBox(self: madspace._madspace_py.PrettyBox, title: str, rows: SupportsInt, columns: collections.abc.Sequence[SupportsInt], offset: SupportsInt = 0, box_width: SupportsInt = 91)

Bases: pybind11_object

property line_count

print_first(self: madspace._madspace_py.PrettyBox) → None

print_update(self: madspace._madspace_py.PrettyBox) → None

set_cell(self: madspace._madspace_py.PrettyBox, row: SupportsInt, column: SupportsInt, value: str) → None

set_column(self: madspace._madspace_py.PrettyBox, column: SupportsInt, values: collections.abc.Sequence[str]) → None

set_row(self: madspace._madspace_py.PrettyBox, row: SupportsInt, values: collections.abc.Sequence[str]) → None

class madspace.Propagator(self: madspace._madspace_py.Propagator, mass: SupportsFloat = 0.0, width: SupportsFloat = 0.0, integration_order: SupportsInt = 0, e_min: SupportsFloat = 0.0, e_max: SupportsFloat = 0.0, pdg_id: SupportsInt = 0)

Bases: pybind11_object

property e_max

property e_min

property integration_order

property mass

property pdg_id

property width

class madspace.PropagatorChannelWeights(self: madspace._madspace_py.PropagatorChannelWeights, topologies: collections.abc.Sequence[madspace._madspace_py.Topology], permutations: collections.abc.Sequence[collections.abc.Sequence[collections.abc.Sequence[SupportsInt]]], channel_indices: collections.abc.Sequence[collections.abc.Sequence[SupportsInt]])

Bases: FunctionGenerator

class madspace.RunningCoupling(self: madspace._madspace_py.RunningCoupling, grid: madspace._madspace_py.AlphaSGrid, prefix: str = '')

Bases: FunctionGenerator

class madspace.SubchannelWeights(self: madspace._madspace_py.SubchannelWeights, topologies: collections.abc.Sequence[collections.abc.Sequence[madspace._madspace_py.Topology]], permutations: collections.abc.Sequence[collections.abc.Sequence[collections.abc.Sequence[SupportsInt]]], channel_indices: collections.abc.Sequence[collections.abc.Sequence[SupportsInt]])

Bases: FunctionGenerator

channel_count(self: madspace._madspace_py.SubchannelWeights) → int

class madspace.SubprocArgs(self: madspace._madspace_py.SubprocArgs, process_id: SupportsInt = 0, topologies: collections.abc.Sequence[madspace._madspace_py.Topology] = [], permutations: collections.abc.Sequence[collections.abc.Sequence[collections.abc.Sequence[SupportsInt]]] = [], diagram_indices: collections.abc.Sequence[collections.abc.Sequence[SupportsInt]] = [], diagram_color_indices: collections.abc.Sequence[collections.abc.Sequence[collections.abc.Sequence[SupportsInt]]] = [], color_flows: collections.abc.Sequence[collections.abc.Sequence[collections.abc.Sequence[tuple[SupportsInt, SupportsInt]]]] = [], pdg_color_types: collections.abc.Mapping[SupportsInt, SupportsInt] = {}, helicities: collections.abc.Sequence[collections.abc.Sequence[SupportsFloat]] = [], pdg_ids: collections.abc.Sequence[collections.abc.Sequence[collections.abc.Sequence[SupportsInt]]] = [], matrix_flavor_indices: collections.abc.Sequence[SupportsInt] = [])

Bases: pybind11_object

property color_flows

property diagram_color_indices

property diagram_indices

property helicities

property matrix_flavor_indices

property pdg_color_types

property pdg_ids

property permutations

property process_id

property topologies

class madspace.TPropagatorMapping(self: madspace._madspace_py.TPropagatorMapping, integration_order: collections.abc.Sequence[SupportsInt], invariant_power: SupportsFloat = 0.0)

Bases: Mapping

class madspace.Tensor

Bases: pybind11_object

numpy()

torch()

class madspace.ThreeBodyDecay(self: madspace._madspace_py.ThreeBodyDecay, com: bool)

Bases: Mapping

class madspace.Topology(self: madspace._madspace_py.Topology, diagram: madspace._madspace_py.Diagram)

Bases: pybind11_object

property decay_integration_order

property decays

property incoming_masses

property outgoing_indices

property outgoing_masses

propagator_momentum_terms(self: madspace._madspace_py.Topology, arg0: bool) → list[tuple[list[int], float, float]]

property t_integration_order

property t_propagator_count

property t_propagator_masses

property t_propagator_widths

static topologies(diagram: madspace._madspace_py.Diagram) → list[madspace._madspace_py.Topology]

class madspace.TwoBodyDecay(self: madspace._madspace_py.TwoBodyDecay, com: bool)

Bases: Mapping

class madspace.TwoToThreeParticleScattering(self: madspace._madspace_py.TwoToThreeParticleScattering, t_invariant_power: SupportsFloat = 0.0, t_mass: SupportsFloat = 0.0, t_width: SupportsFloat = 0.0, s_invariant_power: SupportsFloat = 0.0, s_mass: SupportsFloat = 0.0, s_width: SupportsFloat = 0.0)

Bases: Mapping

class madspace.TwoToTwoParticleScattering(self: madspace._madspace_py.TwoToTwoParticleScattering, com: bool, invariant_power: SupportsFloat = 0.0, mass: SupportsFloat = 0.0, width: SupportsFloat = 0.0)

Bases: Mapping

class madspace.Type(*args, **kwargs)

Bases: pybind11_object

Overloaded function.

1. __init__(self: madspace._madspace_py.Type, dtype: madspace._madspace_py.DataType, batch_size: madspace._madspace_py.BatchSize, shape: collections.abc.Sequence[typing.SupportsInt]) -> None

2. __init__(self: madspace._madspace_py.Type, batch_size_list: collections.abc.Sequence[madspace._madspace_py.BatchSize]) -> None

property batch_size

property dtype

property shape

class madspace.Unweighter(self: madspace._madspace_py.Unweighter, types: madspace._madspace_py.NamedTypes)

Bases: FunctionGenerator

class madspace.Value(*args, **kwargs)

Bases: pybind11_object

Overloaded function.

1. __init__(self: madspace._madspace_py.Value, value: typing.SupportsInt) -> None

2. __init__(self: madspace._madspace_py.Value, value: typing.SupportsFloat) -> None

property literal_value

property local_index

property type

class madspace.VegasGridOptimizer(self: madspace._madspace_py.VegasGridOptimizer, contexts: collections.abc.Sequence[madspace._madspace_py.Context], grid_name: str, damping: SupportsFloat)

Bases: pybind11_object

add_data(self: madspace._madspace_py.VegasGridOptimizer, values: object, counts: object) → None

optimize(self: madspace._madspace_py.VegasGridOptimizer) → None

class madspace.VegasHistogram(self: madspace._madspace_py.VegasHistogram, dimension: SupportsInt, bin_count: SupportsInt)

Bases: FunctionGenerator

class madspace.VegasMapping(self: madspace._madspace_py.VegasMapping, dimension: SupportsInt, bin_count: SupportsInt, prefix: str = '')

Bases: Mapping

grid_name(self: madspace._madspace_py.VegasMapping) → str

initialize_globals(self: madspace._madspace_py.VegasMapping, context: madspace._madspace_py.Context) → None

class madspace.Verbosity(*args, **kwargs)

Bases: pybind11_object

Members:

silent

log

pretty

Overloaded function.

1. __init__(self: madspace._madspace_py.Verbosity, value: typing.SupportsInt) -> None

2. __init__(self: madspace._madspace_py.Verbosity, name: str) -> None

log = <Verbosity.log: 1>

Verbosity.name -> str

pretty = <Verbosity.pretty: 2>

silent = <Verbosity.silent: 0>

property value

madspace.batch_float_array(count: SupportsInt) → madspace._madspace_py.Type

madspace.batch_four_vec_array(count: SupportsInt) → madspace._madspace_py.Type

madspace.cpu_device() → madspace._madspace_py.Device

madspace.cuda_device(index: SupportsInt = 0) → madspace._madspace_py.Device

madspace.default_context() → madspace._madspace_py.Context

madspace.default_cuda_context(index: SupportsInt = 0) → madspace._madspace_py.Context

madspace.default_hip_context(index: SupportsInt = 0) → madspace._madspace_py.Context

madspace.format_progress(progress: SupportsFloat, width: SupportsInt) → str

madspace.format_si_prefix(value: SupportsFloat) → str

madspace.format_with_error(value: SupportsFloat, error: SupportsFloat) → str

madspace.hip_device(index: SupportsInt = 0) → madspace._madspace_py.Device

madspace.initialize_vegas_grid(context: madspace._madspace_py.Context, grid_name: str) → None

madspace.multichannel_batch_size(count: SupportsInt) → madspace._madspace_py.Type

madspace.namedtuple(typename, field_names, *, rename=False, defaults=None, module=None)

Returns a new subclass of tuple with named fields.

>>> Point = namedtuple('Point', ['x', 'y'])
>>> Point.__doc__                   # docstring for the new class
'Point(x, y)'
>>> p = Point(11, y=22)             # instantiate with positional args or keywords
>>> p[0] + p[1]                     # indexable like a plain tuple
33
>>> x, y = p                        # unpack like a regular tuple
>>> x, y
(11, 22)
>>> p.x + p.y                       # fields also accessible by name
33
>>> d = p._asdict()                 # convert to a dictionary
>>> d['x']
11
>>> Point(**d)                      # convert from a dictionary
Point(x=11, y=22)
>>> p._replace(x=100)               # _replace() is like str.replace() but targets named fields
Point(x=100, y=22)

madspace.set_lib_path(lib_path: str) → None

madspace.set_simd_vector_size(vector_size: SupportsInt) → None