madspace 0.3.1__cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl

madspace/madnis/interface.py

@@ -0,0 +1,191 @@
+from collections.abc import Callable
+
+import torch
+import torch.nn as nn
+
+from .. import _madspace_py_loader as ms
+from ..torch import FunctionModule
+from .channel_grouping import ChannelGrouping
+from .distribution import Distribution
+from .integrand import Integrand
+
+MADNIS_INTEGRAND_FLAGS = (
+    ms.Integrand.sample
+    | ms.Integrand.return_latent
+    | ms.Integrand.return_channel
+    | ms.Integrand.return_chan_weights
+    | ms.Integrand.return_cwnet_input
+    | ms.Integrand.return_discrete_latent
+)
+
+
+class IntegrandDistribution(nn.Module, Distribution):
+    def __init__(
+        self,
+        channels: list[ms.Integrand],
+        channel_remap_function: Callable[[torch.Tensor], torch.Tensor],
+        context: ms.Context,
+    ):
+        super().__init__()
+        self.channel_count = len(channels)
+        self.channels = channels
+        self.context = context
+        self.channel_remap_function = channel_remap_function
+        self.latent_dims, self.latent_float = channels[0].latent_dims()
+        self.integrand_prob = None
+        self.update_channel_mask(torch.ones(self.channel_count, dtype=torch.bool))
+
+    def update_channel_mask(self, mask: torch.Tensor) -> None:
+        self.channel_mask = mask
+        multi_prob = ms.MultiChannelFunction(
+            [
+                ms.IntegrandProbability(chan)
+                for chan, active in zip(self.channels, mask)
+                if active
+            ]
+        )
+        func = multi_prob.function()
+        if self.integrand_prob is None:
+            self.integrand_prob = FunctionModule(func, self.context)
+        else:
+            self.integrand_prob.runtime = ms.FunctionRuntime(func, self.context)
+
+    def sample(
+        self,
+        n: int,
+        c: torch.Tensor | None = None,
+        channel: torch.Tensor | list[int] | int | None = None,
+        return_log_prob: bool = False,
+        return_prob: bool = False,
+        device: torch.device | None = None,
+        dtype: torch.dtype | None = None,
+    ) -> torch.Tensor | tuple[torch.Tensor, ...]:
+        raise NotImplementedError(
+            "IntegrandDistribution does not support sampling directly. "
+            "Use the underlying ms.Integrand object instead."
+        )
+
+    def prob(
+        self,
+        x: torch.Tensor,
+        c: torch.Tensor | None = None,
+        channel: torch.Tensor | list[int] | int | None = None,
+    ) -> torch.Tensor:
+        channel_perm = None
+        if isinstance(channel, torch.Tensor):
+            channel = self.channel_remap_function(channel)
+            channel_perm = torch.argsort(channel)
+            x = x[channel_perm]
+            channel = channel.bincount(minlength=self.channel_count).to(torch.int32)
+        elif channel is None:
+            channel = torch.tensor([len(x)], dtype=torch.int32)
+        else:
+            raise NotImplementedError("channel argument type not supported")
+        channel = channel[self.channel_mask]
+
+        prob_args = [
+            xi if is_float else xi[:, 0].to(torch.int32)
+            for xi, is_float in zip(x.split(self.latent_dims, dim=1), self.latent_float)
+        ]
+        prob = self.integrand_prob(*prob_args, channel.cpu())
+        if channel_perm is None:
+            return prob
+        else:
+            channel_perm_inv = torch.argsort(channel_perm)
+            return prob[channel_perm_inv]
+
+
+class IntegrandFunction:
+    def __init__(self, channels: list[ms.Integrand], context: ms.Context):
+        self.channel_count = len(channels)
+        self.channels = channels
+        self.context = context
+        self.update_channel_mask(torch.ones(self.channel_count, dtype=torch.bool))
+
+    def update_channel_mask(self, mask: torch.Tensor) -> None:
+        self.channel_mask = mask.cpu()
+        multi_integrand = ms.MultiChannelIntegrand(
+            [chan for chan, active in zip(self.channels, mask) if active]
+        )
+        self.multi_runtime = ms.FunctionRuntime(
+            multi_integrand.function(), self.context
+        )
+
+    def __call__(self, channels: torch.Tensor) -> tuple[torch.Tensor, ...]:
+        channel_perm = torch.argsort(channels)
+        channels = channels.bincount(minlength=self.channel_count).cpu().to(torch.int32)
+        channels = channels[self.channel_mask]
+        (
+            full_weight,
+            latent,
+            inv_prob,
+            chan_index,
+            alphas_prior,
+            alpha_selected,
+            y,
+            *rest,
+        ) = self.multi_runtime(channels)
+
+        x_parts = [latent, *rest]
+        x = torch.cat(
+            [xi.double().reshape(latent.shape[0], -1) for xi in x_parts], dim=1
+        )
+        prob = 1 / inv_prob
+        weight = torch.where(
+            alpha_selected == 0.0, 0.0, full_weight * prob / alpha_selected
+        )
+        channel_perm_inv = torch.argsort(channel_perm)
+        return (
+            x[channel_perm_inv],
+            prob[channel_perm_inv],
+            weight[channel_perm_inv],
+            y[channel_perm_inv],
+            alphas_prior[channel_perm_inv],
+            chan_index[channel_perm_inv].to(torch.int64),
+        )
+
+
+def build_madnis_integrand(
+    channels: list[ms.Integrand],
+    cwnet: ms.ChannelWeightNetwork | None = None,
+    channel_grouping: ChannelGrouping | None = None,
+    context: ms.Context = ms.default_context(),
+) -> tuple[Integrand, Distribution, nn.Module | None]:
+    device = torch.device("cpu" if context.device() == ms.cpu_device() else "cuda:0")
+    if channel_grouping is None:
+        remap_channels = lambda channels: channels
+        group_indices = torch.arange(len(channels))
+    else:
+        channel_id_map = torch.tensor(
+            [channel.group.group_index for channel in channel_grouping.channels],
+            device=device,
+        )
+        remap_channels = lambda channels: channel_id_map[channels]
+        group_indices = torch.tensor(
+            [group.target_index for group in channel_grouping.groups], device=device
+        )
+
+    integrand_function = IntegrandFunction(channels, context)
+    flow = IntegrandDistribution(channels, remap_channels, context)
+
+    def update_mask(mask: torch.Tensor) -> None:
+        context.get_global(cwnet.mask_name()).torch()[0, :] = mask.double()
+        group_mask = mask[group_indices]
+        if torch.any(group_mask.cpu() != integrand_function.channel_mask):
+            integrand_function.update_channel_mask(group_mask)
+            flow.update_channel_mask(group_mask)
+
+    integrand = Integrand(
+        function=integrand_function,
+        input_dim=sum(channels[0].latent_dims()[0]),
+        channel_count=len(channel_grouping.channels),
+        remapped_dim=cwnet.preprocessing().output_dim(),
+        has_channel_weight_prior=cwnet is not None,
+        channel_grouping=channel_grouping,
+        function_includes_sampling=True,
+        update_active_channels_mask=update_mask,
+    )
+    cwnet_module = (
+        None if cwnet is None else FunctionModule(cwnet.mlp().function(), context)
+    )
+    return integrand, flow, cwnet_module

madspace/madnis/losses.py

@@ -0,0 +1,186 @@
+"""Implementation of multi-channel loss functions"""
+
+from collections.abc import Callable
+from functools import wraps
+
+import torch
+
+
+def dtype_epsilon(tensor: torch.Tensor) -> float:
+    return torch.finfo(tensor.dtype).eps
+
+
+SingleChannelLoss = Callable[[torch.Tensor, torch.Tensor, torch.Tensor], torch.Tensor]
+MultiChannelLoss = Callable[
+    [torch.Tensor, torch.Tensor, torch.Tensor | None, torch.Tensor | None], torch.Tensor
+]
+
+
+def multi_channel_loss(loss: SingleChannelLoss) -> MultiChannelLoss:
+    """
+    Turns a single-channel loss function into a multi-channel loss function by evaluating it for
+    each channel separately and then adding them weighted by TODO weighted by what?
+
+    Args:
+        loss: single-channel loss function, that expects the integrand value, test probability and
+            sampling probability as arguments
+    Returns:
+        multi-channel loss function, that expects the integrand value, test probability and,
+        optionally, sampling probability and channel indices as arguments.
+    """
+
+    # TODO: this unfortunately does not yield the correct signature (with the extra channels argument),
+    # so it does not show up in the documentation
+    @wraps(loss)
+    def wrapped_multi(
+        f_true: torch.Tensor,
+        q_test: torch.Tensor,
+        q_sample: torch.Tensor | None = None,
+        channels: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        if q_sample is None:
+            q_sample = q_test
+        if channels is None:
+            return loss(f_true, q_test, q_sample)
+
+        loss_tot = 0
+        for channel in channels.unique():
+            mask = channels == channel
+            fi, qti, qsi = f_true[mask], q_test[mask], q_sample[mask]
+            ni = mask.count_nonzero()
+            # loss_tot += ni / q_sample.shape[0] * loss(fi, qti, qsi) if ni > 0 else 0.0
+            loss_tot += loss(fi, qti, qsi) if ni > 0 else 0.0
+        return loss_tot
+
+    return wrapped_multi
+
+
+def stratified_variance(
+    f_true: torch.Tensor,
+    q_test: torch.Tensor,
+    q_sample: torch.Tensor | None = None,
+    channels: torch.Tensor | None = None,
+):
+    """
+    Computes the stratified variance as introduced in [2311.01548] for two given sets of
+    probabilities, ``f_true`` and ``q_test``. It uses importance sampling with a sampling
+    probability specified by ``q_sample``.
+
+    Args:
+        f_true: normalized integrand values
+        q_test: estimated function/probability
+        q_sample: sampling probability
+        channels: channel indices or None in the single-channel case
+    Returns:
+        computed stratified variance
+    """
+    if q_sample is None:
+        q_sample = q_test
+    if channels is None:
+        abs_integral = torch.mean(f_true.detach().abs() / q_sample)
+        return _variance(f_true, q_test, q_sample) / abs_integral.square()
+
+    stddev_sum = 0
+    abs_integral = 0
+    for i in channels.unique():
+        mask = channels == i
+        fi, qti, qsi = f_true[mask], q_test[mask], q_sample[mask]
+        stddev_sum += torch.sqrt(_variance(fi, qti, qsi) + dtype_epsilon(f_true))
+        abs_integral += torch.mean(fi.detach().abs() / qsi)
+    return (stddev_sum / abs_integral) ** 2
+
+    # variances = []
+    # abs_integrals = []
+    # for i in channels.unique():
+    #    mask = channels == i
+    #    fi, qti, qsi = f_true[mask], q_test[mask], q_sample[mask]
+    #    variances.append(_variance(fi, qti, qsi) + dtype_epsilon(f_true))
+    #    abs_integrals.append(torch.mean(fi.abs() / qsi))
+    # abs_integral_tot = sum(abs_integrals)
+    # return sum(
+    #    abs_integral / abs_integral_tot * variance
+    #    for abs_integral, variance in zip(abs_integrals, variances)
+    # ) / abs_integral_tot.detach().square()
+
+
+@multi_channel_loss
+def variance(
+    f_true: torch.Tensor, q_test: torch.Tensor, q_sample: torch.Tensor
+) -> torch.Tensor:
+    abs_integral = torch.mean(f_true.detach().abs() / q_sample) + dtype_epsilon(f_true)
+    return _variance(f_true, q_test, q_sample) / abs_integral.square()
+
+
+def _variance(
+    f_true: torch.Tensor,
+    q_test: torch.Tensor,
+    q_sample: torch.Tensor,
+) -> torch.Tensor:
+    """
+    Computes the variance for two given sets of probabilities, ``f_true`` and ``q_test``. It uses
+    importance sampling with a sampling probability specified by ``q_sample``.
+
+    Args:
+        f_true: normalized integrand values
+        q_test: estimated function/probability
+        q_sample: sampling probability
+    Returns:
+        computed variance
+    """
+    ratio = q_test / q_sample
+    mean = torch.mean(f_true / q_sample)
+    sq = (f_true / q_test - mean) ** 2
+    return (
+        torch.mean(sq * ratio)
+        if len(f_true) > 0
+        else torch.tensor(0.0, device=f_true.device, dtype=f_true.dtype)
+    )
+
+
+@multi_channel_loss
+def kl_divergence(
+    f_true: torch.Tensor, q_test: torch.Tensor, q_sample: torch.Tensor
+) -> torch.Tensor:
+    """
+    Computes the Kullback-Leibler divergence for two given sets of probabilities, ``f_true`` and
+    ``q_test``. It uses importance sampling, i.e. the estimator is divided by an additional factor
+    of ``q_sample``.
+
+    Args:
+        f_true: normalized integrand values
+        q_test: estimated function/probability
+        q_sample: sampling probability
+        channels: channel indices or None in the single-channel case
+    Returns:
+        computed KL divergence
+    """
+    f_true = f_true.detach().abs()
+    f_true /= torch.mean(f_true / q_sample)
+    log_q = torch.log(q_test)
+    log_f = torch.log(f_true + dtype_epsilon(f_true))
+    return torch.mean(f_true / q_sample * (log_f - log_q))
+
+
+@multi_channel_loss
+def rkl_divergence(
+    f_true: torch.Tensor, q_test: torch.Tensor, q_sample: torch.Tensor
+) -> torch.Tensor:
+    """
+    Computes the reverse Kullback-Leibler divergence for two given sets of probabilities, ``f_true``
+    and ``q_test``. It uses importance sampling, i.e. the estimator is divided by an additional
+    factor of ``q_sample``.
+
+    Args:
+        f_true: normalized integrand values
+        q_test: estimated function/probability
+        q_sample: sampling probability
+        channels: channel indices or None in the single-channel case
+    Returns:
+        computed KL divergence
+    """
+    f_true = f_true.detach().abs()
+    f_true /= torch.mean(f_true / q_sample)
+    ratio = q_test / q_sample
+    log_q = torch.log(q_test)
+    log_f = torch.log(f_true + dtype_epsilon(f_true))
+    return torch.mean(ratio * (log_q - log_f))

madspace/torch.py

@@ -0,0 +1,82 @@
+import torch
+import torch.nn as nn
+from torch.autograd.function import FunctionCtx, once_differentiable
+
+from . import _madspace_py_loader as me
+
+
+class FunctionModule(nn.Module):
+    def __init__(
+        self,
+        function: me.Function,
+        context: me.Context = me.default_context(),
+    ):
+        super().__init__()
+        self.global_params = nn.ParameterDict(
+            {
+                name.replace(".", ":"): nn.Parameter(
+                    context.get_global(name).torch(),
+                    context.global_requires_grad(name),
+                )
+                for name in function.globals
+            }
+        )
+        self.runtime = me.FunctionRuntime(function, context)
+        self.dummy = torch.zeros(
+            1,
+            requires_grad=any(
+                glob.requires_grad for glob in self.global_params.values()
+            ),
+        )
+
+    def forward(self, *args: torch.Tensor) -> list[torch.Tensor]:
+        if torch.is_grad_enabled():
+            return AutogradWrapper.apply(self, self.dummy, *args)
+        else:
+            outputs = self.runtime.call(args)
+            if len(outputs) == 1:
+                return torch.from_dlpack(outputs[0])
+            else:
+                return tuple(torch.from_dlpack(out) for out in outputs)
+
+
+class AutogradWrapper(torch.autograd.Function):
+    @staticmethod
+    def forward(
+        ctx: FunctionCtx,
+        module: FunctionModule,
+        dummy: torch.Tensor,
+        *args: torch.Tensor,
+    ) -> list[torch.Tensor]:
+        outputs, local_grads, eval_grad = module.runtime.call_with_grad(
+            [arg.detach() for arg in args], [arg.requires_grad for arg in args]
+        )
+        ctx.module = module
+        ctx.eval_grad = eval_grad
+        ctx.save_for_backward(
+            *(None if grad is None else torch.from_dlpack(grad) for grad in local_grads)
+        )
+        if len(outputs) == 1:
+            return torch.from_dlpack(outputs[0])
+        else:
+            return tuple(torch.from_dlpack(out) for out in outputs)
+
+    @staticmethod
+    @once_differentiable
+    def backward(ctx: FunctionCtx, *output_grads: torch.Tensor):
+        input_grads, global_grads = ctx.module.runtime.call_backward(
+            output_grads, ctx.saved_tensors, ctx.eval_grad
+        )
+        for name, grad in global_grads:
+            if grad is None:
+                continue
+            param = ctx.module.global_params[name.replace(".", ":")]
+            grad_torch = torch.from_dlpack(grad)
+            if param.grad is None:
+                param.grad = grad_torch
+            else:
+                param.grad += grad_torch
+        input_grads_opt = (
+            None if grad is None else torch.from_dlpack(grad) for grad in input_grads
+        )
+        return None, None, *input_grads_opt

madspace-0.3.1.dist-info/METADATA

@@ -0,0 +1,71 @@
+Metadata-Version: 2.1
+Name: madspace
+Version: 0.3.1
+Summary: Fast and flexible phase space mappings
+Author-Email: Theo Heimel <theo.heimel@uclouvain.be>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/madgraph-ml/madevent7/refs/heads/dev/docs/source/_static/logo-light-madspace.png" width="500", alt="MadSpace">
+</p>
+
+### Installation
+
+#### Package
+
+Packages on PyPI are available for Linux and MacOS X (with Apple silicon),
+for Python 3.11 to 3.14.
+
+```sh
+pip install madspace
+```
+
+#### Build
+
+First install `scikit_build_core` with
+
+```sh
+pip install scikit_build_core
+```
+
+The pre-installed version of `cmake` under MacOS is outdated, so you might need to install a
+newer version, for example with
+
+```sh
+brew install cmake
+```
+
+Then check out the `madspace` repository and build and install it with
+
+```sh
+git clone git@github.com:madgraph-ml/madspace.git
+cd madspace
+pip install .
+```
+
+For a development version allowing for incremental build, use the following command instead:
+
+```sh
+pip install --no-build-isolation -Cbuild-dir=build -Ccmake.build-type=RelWithDebInfo .
+```
+
+This will create a directory `build` where you can run make directly to make development
+easier. To update the python module itself, make sure to also run the `pip install` command
+above again. This will not happen automatically, even if you make the installation editable!
+Build type `RelWithDebInfo` generates optimized code but includes debug symbols, so you
+can use `lldb` or `gdb` to debug the code.
+
+### Tests
+
+To run the tests, you need to have the `pytest`, `numpy` and `torch` packages installed.
+One test optionally requires the `lhapdf` package (can be installed via conda or built from
+source) and the `NNPDF40_nlo_as_01180` PDF set.
+
+To run the tests, go to the root directory of the repository and run
+```sh
+pytest tests
+```

madspace-0.3.1.dist-info/RECORD

@@ -0,0 +1,75 @@
+madspace/__init__.py,sha256=_TJn7-SPJOLeE-6jzggKLKTL9hKfSYj-SM9ikcXbCd0,35
+madspace/_madspace_py.cpython-311-x86_64-linux-gnu.so,sha256=cfm94vkyWohw1_1xUwyfFXsqsN9MMziKm8WJoBBmI-0,1926064
+madspace/_madspace_py.pyi,sha256=Ghgma25kyma__8vdX4wgfajHT0ilnYuQSoqMiNTGNYc,79564
+madspace/_madspace_py_loader.py,sha256=vLGrMuowLhDZWwEs2_ZKAwQo8GQZ1smG9Izdw3vkdiI,3398
+madspace/torch.py,sha256=nJmAtTtOX_40GN6HNxPTx0BR16XaD6DtpSjMewm4rH0,2796
+madspace/include/madspace/constants.h,sha256=2SEY6x7ODAyDy0TwSlMRDZNxb71ULadBh_HXd7u3XmA,443
+madspace/include/madspace/madcode.h,sha256=O7BI2AuMTlpDh2xUfycaIxkpqLvYwenSC-AyxLvbCnM,134
+madspace/include/madspace/phasespace.h,sha256=K-rnXoaVqzj5PWkkqLBXlQubPg9HAWyVZYjqbw7ZNZk,890
+madspace/include/madspace/runtime.h,sha256=k6gmivKqEcBJvFXcnWdyFx_W1B44G7cE_T79K8Dhnao,330
+madspace/include/madspace/umami.h,sha256=mIJ4mxUHsBRl-lRJkI5EHCEWzGOq5aV1dqXZaF_ste4,5601
+madspace/include/madspace/util.h,sha256=WbzL0LsMACHiEgGfooC3nVbrr_ucBGqUNMKNYDRAsQc,3927
+madspace/include/madspace/madcode/function.h,sha256=gbr1z5saZLZp4BdBbHEFAhbxu6GgeoBghweVFRaPA0w,3114
+madspace/include/madspace/madcode/function_builder_mixin.h,sha256=gLbJY8IlaIoLV6APSKDpIyHLqVyYd7QguUukI1QjvcI,21303
+madspace/include/madspace/madcode/instruction.h,sha256=Ib0v0RjXbxZvePHtYFHwYcupDbIvHRQUxLpzNw6VC1Y,6664
+madspace/include/madspace/madcode/opcode_mixin.h,sha256=Esvkw3qI2iO4GdLNGCBrmc7YwiSZq-LcSROs5m3tawA,2841
+madspace/include/madspace/madcode/optimizer.h,sha256=x5gb3o76boojMoe2n_Yq9uyp3esAV6ptANkZ7grggNE,670
+madspace/include/madspace/madcode/type.h,sha256=eAIiMQxDKnJOOBWnjlJa_c9yi-FqBM87sFuyVJzwq5w,7323
+madspace/include/madspace/phasespace/base.h,sha256=qr0W7_E7sTp6N0HCC8uWKzkI0VvxLxoLIL8IWo6ziLw,2286
+madspace/include/madspace/phasespace/channel_weight_network.h,sha256=5P7vanQIOX0dZVq2syT8UPePM1S_PxCCaZ_gbao1Vnc,1259
+madspace/include/madspace/phasespace/channel_weights.h,sha256=niMLyoIRtZzxuMJOEsrOgDrfAvzTZKkpZ5tNAWuNg80,1499
+madspace/include/madspace/phasespace/chili.h,sha256=PZkKp2-Yd8dk-bfVL8wu29Biq0qJLwfrJ3LsKmkJ1ww,751
+madspace/include/madspace/phasespace/cross_section.h,sha256=hoj0vxgHKDYRX9zD3Kh1zz_tl_skAkmXxpffNbfOYoY,1536
+madspace/include/madspace/phasespace/cuts.h,sha256=c373HlSJCNHKH8WU9tLb1MTbgy9QNJRxTeB4XRAbJEw,838
+madspace/include/madspace/phasespace/discrete_flow.h,sha256=CV3Tr0ad6tVW8qTmCiTU2zeyAlcmaR02DJ9xZ8Fh-rM,1386
+madspace/include/madspace/phasespace/discrete_sampler.h,sha256=g2MkMm4FyDwyCtq_4OhftB08NzwDA35hlQKok1RhKak,1550
+madspace/include/madspace/phasespace/flow.h,sha256=8WwQwW4SKvk7Y7V2BsZNF4S_X342FewgnxsNvI3oIK4,1539
+madspace/include/madspace/phasespace/histograms.h,sha256=hgWqwFKxWn1VqN64lr-nkIX0fh-VmL-vhhebWOG44kk,635
+madspace/include/madspace/phasespace/integrand.h,sha256=FUM9OzLj5ucQv0vD2CaH0gDhxE3Tzeuw8wDs8T8XqY4,8020
+madspace/include/madspace/phasespace/invariants.h,sha256=W2Y45eAN3hZvzNONyqzqogkKdkJDuBtyybeL_j6qKx8,683
+madspace/include/madspace/phasespace/luminosity.h,sha256=YVARtY5x57wA7WMeZHjdTDplB3bXpnrzxFPQwP3V334,1049
+madspace/include/madspace/phasespace/matrix_element.h,sha256=dRmR-bRcUp8K0L72xqSwjvCXZtSbcYgC3LWJyGZviPA,2207
+madspace/include/madspace/phasespace/mlp.h,sha256=xncDnGM0UIlIcKPaIYZuZChg-F3VdmK-TKSsheYBNzI,1058
+madspace/include/madspace/phasespace/multichannel.h,sha256=PK9KKsmJfXuINf3YGK4vyCJ68hpxZO6cYfEIkSHstMw,1275
+madspace/include/madspace/phasespace/observable.h,sha256=hq80DwuSM1ngWEKXxKj8Q4ZxFbJRaLprTURRQY_RhOg,2373
+madspace/include/madspace/phasespace/pdf.h,sha256=B615sw5L5p62LVs50HMPeiflLk9y-wXhy6_ngMuRQfo,2444
+madspace/include/madspace/phasespace/phasespace.h,sha256=jTEHePcsW14RpfSbXqv0GvHXDK-mQNBYPW_AGmq3GEs,2144
+madspace/include/madspace/phasespace/rambo.h,sha256=kcplgg0LUvWMEGXJQ90J6VwsU3etULsIAefhCTeB6Jo,645
+madspace/include/madspace/phasespace/scale.h,sha256=LMmhwVS_edfShbleAXJlUkx_pr9xa6q5Xdc4hVpW308,1381
+madspace/include/madspace/phasespace/t_propagator_mapping.h,sha256=IGQarmhcTGxP5jNjQP-hZbxh57TWi_EiTvDNNydMR00,999
+madspace/include/madspace/phasespace/three_particle.h,sha256=mAzC9BYBSCu7luLRWTGqR8KWoSXEoI9AJogwuDRawgU,1954
+madspace/include/madspace/phasespace/topology.h,sha256=b1GCgWnv5XDyAj3c72BI7ws57WGgHiQVA2bWp3GTPhc,3728
+madspace/include/madspace/phasespace/two_particle.h,sha256=E4nhlcY-inIpRu_RrqU8H1nzx0_otQfxUi_xZkHin1c,1730
+madspace/include/madspace/phasespace/vegas.h,sha256=t65pvX7B9RtbIL5AMywyEdAGsiOYLnjrO7Q914B9hNc,1514
+madspace/include/madspace/runtime/context.h,sha256=oHD6xaTzt-T9VgxFLuh355CiDHHfAVmwySOcgivB73E,4705
+madspace/include/madspace/runtime/discrete_optimizer.h,sha256=UJWGw0te5xXpQmxXQV_C_M7xmD9WT8mW0b2UmqB_I-A,664
+madspace/include/madspace/runtime/event_generator.h,sha256=E0lwslt25ogaaY3bojnzMmpsGA-bTUxUOuFLXvwSsMw,8789
+madspace/include/madspace/runtime/format.h,sha256=BgSKfcaCXxk7b83GJy0ZJYHZzJjq4wZhQbqGX3lPjNc,1901
+madspace/include/madspace/runtime/io.h,sha256=o_zf4EFnVJy-s352U6lKdkBS6a-qtXupTbewoTE6FU4,11231
+madspace/include/madspace/runtime/lhe_output.h,sha256=KsqaOPuctdinPKip8M1YQLxDwJBbpIHdgjQfaDkXICc,3654
+madspace/include/madspace/runtime/logger.h,sha256=BOzfJM1Nx68Z1a-6yqnVTyi2vu7uhW5HrMs7D_U1010,1396
+madspace/include/madspace/runtime/runtime_base.h,sha256=pW4obFKqgWcIiZF8sRHO1ly7JmmdwnjJz7ta-dcQ-Gc,1213
+madspace/include/madspace/runtime/tensor.h,sha256=9E4zrohNRCvbEa5UEpfgEYyv5oiyqDqw6g9EmphFH7Y,17464
+madspace/include/madspace/runtime/thread_pool.h,sha256=986mqqluJFRfkxIObJ_T2E8bKvxOrtOeHE0mgxwayUY,3150
+madspace/include/madspace/runtime/vegas_optimizer.h,sha256=Ot2hg4kWOxQQhT27ua5iYNwxYYTEp_H_PObrisCWhO4,653
+madspace/lib/libmadspace.so,sha256=SuUAsi62bHVy3g9pe2Tg5TSMERntD_CqFI3LZ_yLJ0M,2107984
+madspace/lib/libmadspace_cpu.so,sha256=9bP4J8q09jfiZxvXGE8XhSUjjyCWpxGd0gRgZpqW9c4,3250889
+madspace/lib/libmadspace_cpu_avx2.so,sha256=fdWbPP2u2iqTPdQmaVPuCruoHIFeufyLUXNqc23tMKQ,3787513
+madspace/lib/libmadspace_cpu_avx512.so,sha256=BfgTapVD2J6qntfDHmcrLP0Zw64-LXY-2IUQVt3IiFU,3782633
+madspace/lib/libmadspace_cuda.so,sha256=-tWaKvtSb4Jm3EIxkFgo1I68lIAc61bZLPVieGelhxM,43864960
+madspace/lib/libmadspace_hip.so,sha256=qQW8mYq7lXcZHJbV-Q1x03Rs3J3swPkx1JMbgZvounA,20934944
+madspace/madnis/__init__.py,sha256=fqraYGuiFlLs9r8uTTl_1mnx4YOBuTjxv1eOkMCGeSI,1060
+madspace/madnis/buffer.py,sha256=ri2TlFkQCp7G_fBa0yTb4f78Ddsv_Bknrp508yoZQdY,6287
+madspace/madnis/channel_grouping.py,sha256=ub7qkPH9q5hvTovn8NIKvnrMq4GP3yfufNGNH2szQp8,2791
+madspace/madnis/distribution.py,sha256=NjBaGswHZqLpXnFzGI9RPI5_MNp1x-NyzaB561Vbwtg,4381
+madspace/madnis/integrand.py,sha256=TU9YVAK0cKdXTuu9PpZqKOIkihyMh_3UEGg5o2-wG_8,7201
+madspace/madnis/integrator.py,sha256=UKIQX0C1z-zV0VJqB1jLo7GBBDZDC-Yf0872SALvoTw,40896
+madspace/madnis/interface.py,sha256=poRCZDCAZpbtIS9K24aqNJgBfuy00bHjACpvkj1rnlM,7008
+madspace/madnis/losses.py,sha256=xln1jvqO28bb6y8mCa-d7VQljIzRXS0H7AfUXftubb0,6477
+madspace.libs/libgfortran-83c28eba.so.5.0.0,sha256=5VSHn-5-2oAFW2yhQHpU0ABQh0-DDMhrK_P1DfXHuys,2714697
+madspace.libs/libopenblas-r0-11edc3fa.3.15.so,sha256=ttQfy1lpKahm326QdidnjmHyTJTDXtYE5oeghyitWbg,37105401
+madspace.libs/libquadmath-2284e583.so.0.0.0,sha256=qTB7uqNTYj-gFOi2gtUMRin15cfWHaqahlL30WXNQho,272193
+madspace-0.3.1.dist-info/METADATA,sha256=aP0fzUEbcUrZLsAbFuKdOHEmhKzdYCIC9_Oa9mVfvw8,2050
+madspace-0.3.1.dist-info/WHEEL,sha256=ySegkulW2pNmB05QoI2fb4eLl_ZQeVpF0irxyte32ls,157
+madspace-0.3.1.dist-info/RECORD,,
+madspace-0.3.1.dist-info/licenses/LICENSE,sha256=kKZDz5i69Frn0LWZ9xbuk1g1W1Jco18Dk777rNHG-zw,1074

madspace-0.3.1.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: scikit-build-core 0.11.6
+Root-Is-Purelib: false
+Tag: cp311-cp311-manylinux_2_27_x86_64
+Tag: cp311-cp311-manylinux_2_28_x86_64
+

madspace-0.3.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 The MadGraph Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.