Repository: Joshuaalbert/jaxns (language: python)

Issue:
save_results TypeError from toy model.
**Describe the bug**
Trying to run a toy model based on the multivariate likelihood example (https://jaxns.readthedocs.io/en/latest/examples/mvn_data_mvn_prior.html). The sampler runs fine, and I can convert the `state` into a `results`, make diagnostic plots etc. However, when running the save_results function, I get the following error:

```    raise TypeError(f'Object of type {o.__class__.__name__} '
TypeError: Object of type ArrayImpl is not JSON serializable
```

**Expected behavior**
That the results should be saved to a .json or .npz file.

**Observed behavior**
Full traceback:
```
Traceback (most recent call last):
  File "/Users/nasedkin/python-packages/petitRADTRANS/petitRADTRANS/retrieval/jax_toy_example.py", line 72, in <module>
    save_results(results,'jaxns_toy_model_results.npz')
  File "/Users/nasedkin/anaconda3/envs/prt3python312/lib/python3.12/site-packages/jaxns/utils.py", line 543, in save_results
    save_pytree(results, save_file)
  File "/Users/nasedkin/anaconda3/envs/prt3python312/lib/python3.12/site-packages/jaxns/utils.py", line 529, in save_pytree
    json.dump(serialise_namedtuple(pytree), fp, indent=2)
  File "/Users/nasedkin/anaconda3/envs/prt3python312/lib/python3.12/json/__init__.py", line 179, in dump
    for chunk in iterable:
  File "/Users/nasedkin/anaconda3/envs/prt3python312/lib/python3.12/json/encoder.py", line 432, in _iterencode
    yield from _iterencode_dict(o, _current_indent_level)
  File "/Users/nasedkin/anaconda3/envs/prt3python312/lib/python3.12/json/encoder.py", line 406, in _iterencode_dict
    yield from chunks
  File "/Users/nasedkin/anaconda3/envs/prt3python312/lib/python3.12/json/encoder.py", line 406, in _iterencode_dict
    yield from chunks
  File "/Users/nasedkin/anaconda3/envs/prt3python312/lib/python3.12/json/encoder.py", line 439, in _iterencode
    o = _default(o)
        ^^^^^^^^^^^
  File "/Users/nasedkin/anaconda3/envs/prt3python312/lib/python3.12/json/encoder.py", line 180, in default
    raise TypeError(f'Object of type {o.__class__.__name__} '
TypeError: Object of type ArrayImpl is not JSON serializable
```

**Minimal Verifiable Complete Example**
`log_likelihood` and `prior_model` are as in the multivariate likelihood example.

```python
model = Model(prior_model=prior_model,
              log_likelihood=log_likelihood)
ns = DefaultNestedSampler(
    model=model,
    max_samples=1e8,
    num_live_points = 400,
    parameter_estimation = True,
    verbose=True)

termination_reason, state = jax.jit(ns)(random.PRNGKey(42654))
results = ns.to_results(termination_reason=termination_reason, state=state)
save_results(results,'jaxns_toy_model_results.npz') #or .json
```

**JAXNS version**
Output of `pip freeze | grep jaxns`: jaxns==2.5.0

save_results TypeError from toy model.
**Describe the bug**
Trying to run a toy model based on the multivariate likelihood example (https://jaxns.readthedocs.io/en/latest/examples/mvn_data_mvn_prior.html). The sampler runs fine, and I can convert the `state` into a `results`, make diagnostic plots etc. However, when running the save_results function, I get the following error:

```    raise TypeError(f'Object of type {o.__class__.__name__} '
TypeError: Object of type ArrayImpl is not JSON serializable
```

**Expected behavior**
That the results should be saved to a .json or .npz file.

**Observed behavior**
Full traceback:
```
Traceback (most recent call last):
  File "/Users/nasedkin/python-packages/petitRADTRANS/petitRADTRANS/retrieval/jax_toy_example.py", line 72, in <module>
    save_results(results,'jaxns_toy_model_results.npz')
  File "/Users/nasedkin/anaconda3/envs/prt3python312/lib/python3.12/site-packages/jaxns/utils.py", line 543, in save_results
    save_pytree(results, save_file)
  File "/Users/nasedkin/anaconda3/envs/prt3python312/lib/python3.12/site-packages/jaxns/utils.py", line 529, in save_pytree
    json.dump(serialise_namedtuple(pytree), fp, indent=2)
  File "/Users/nasedkin/anaconda3/envs/prt3python312/lib/python3.12/json/__init__.py", line 179, in dump
    for chunk in iterable:
  File "/Users/nasedkin/anaconda3/envs/prt3python312/lib/python3.12/json/encoder.py", line 432, in _iterencode
    yield from _iterencode_dict(o, _current_indent_level)
  File "/Users/nasedkin/anaconda3/envs/prt3python312/lib/python3.12/json/encoder.py", line 406, in _iterencode_dict
    yield from chunks
  File "/Users/nasedkin/anaconda3/envs/prt3python312/lib/python3.12/json/encoder.py", line 406, in _iterencode_dict
    yield from chunks
  File "/Users/nasedkin/anaconda3/envs/prt3python312/lib/python3.12/json/encoder.py", line 439, in _iterencode
    o = _default(o)
        ^^^^^^^^^^^
  File "/Users/nasedkin/anaconda3/envs/prt3python312/lib/python3.12/json/encoder.py", line 180, in default
    raise TypeError(f'Object of type {o.__class__.__name__} '
TypeError: Object of type ArrayImpl is not JSON serializable
```

**Minimal Verifiable Complete Example**
`log_likelihood` and `prior_model` are as in the multivariate likelihood example.

```python
model = Model(prior_model=prior_model,
              log_likelihood=log_likelihood)
ns = DefaultNestedSampler(
    model=model,
    max_samples=1e8,
    num_live_points = 400,
    parameter_estimation = True,
    verbose=True)

termination_reason, state = jax.jit(ns)(random.PRNGKey(42654))
results = ns.to_results(termination_reason=termination_reason, state=state)
save_results(results,'jaxns_toy_model_results.npz') #or .json
```

**JAXNS version**
Output of `pip freeze | grep jaxns`: jaxns==2.5.0



Discussion / hints:

Fix patch:
diff --git a/README.md b/README.md
index 02b981b8..d49841b8 100644
--- a/README.md
+++ b/README.md
@@ -363,6 +363,8 @@ is the best way to achieve speed up.
 
 # Change Log
 
+23 Jul, 2024 -- JAXNS 2.5.2 released. Added explicit density prior. Sped up parametrisation. Scan associative implemented.
+
 27 May, 2024 -- JAXS 2.5.1 released. Fixed minor accuracy degradation introduced in 2.4.13.
 
 15 May, 2024 -- JAXNS 2.5.0 released. Added ability to handle non-JAX likelihoods, e.g. if you have a simulation
diff --git a/benchmarks/difficult_problems/main.py b/benchmarks/difficult_problems/main.py
new file mode 100644
index 00000000..7050f727
--- /dev/null
+++ b/benchmarks/difficult_problems/main.py
@@ -0,0 +1,173 @@
+from time import monotonic_ns
+from typing import Dict
+
+import jax
+import jax.numpy as jnp
+import tensorflow_probability.substrates.jax as tfp
+
+from jaxns import Model, Prior, DefaultNestedSampler
+
+tfpd = tfp.distributions
+
+
+def build_eggbox_model(ndim: int) -> Model:
+    """
+    Builds the eggbox model.
+
+    Args:
+        ndim:  The number of dimensions of the eggbox function.
+
+    Returns:
+        model: The eggbox model.
+    """
+
+    def prior_model():
+        z = yield Prior(tfpd.Uniform(low=jnp.zeros(ndim), high=10. * jnp.pi * jnp.ones(ndim)), name='z')
+        return z
+
+    def log_likelihood(z):
+        y = 1
+        for i in range(ndim):
+            y *= jnp.cos(z[i] / 2)
+        y = jnp.power(2. + y, 5)
+        return y
+
+    model = Model(prior_model=prior_model,
+                  log_likelihood=log_likelihood)
+    return model
+
+
+def build_rastrigin_model(ndim: int) -> Model:
+    """
+    Builds the Rastrigin model.
+
+    Args:
+        ndim:  The number of dimensions of the rastrigin function.
+
+    Returns:
+        model: The rastrigin model.
+    """
+
+    def prior_model():
+        x_min = -5.12
+        x_max = 5.12
+        z = yield Prior(tfpd.Uniform(low=x_min * jnp.ones(ndim), high=x_max * jnp.ones(ndim)), name='z')
+        return z
+
+    def log_likelihood(z):
+        a = jnp.asarray(10.)
+        y = a * ndim
+        for i in range(ndim):
+            y += jnp.power(z[i], 2) - a * jnp.cos(2 * jnp.pi * z[i])
+        return -y
+
+    model = Model(prior_model=prior_model,
+                  log_likelihood=log_likelihood)
+    return model
+
+
+def build_rosenbrock_model(ndim: int) -> Model:
+    """
+    Builds the Rosenbrock model.
+
+    Args:
+        ndim: Number of input dimensions the function should take.
+
+    Returns:
+        model: The Rosenbrock model.
+    """
+
+    def prior_model():
+        z = yield Prior(tfpd.Uniform(low=-5 * jnp.ones(ndim), high=5 * jnp.ones(ndim)), name='z')
+        return z
+
+    def log_likelihood(z):
+        y = 0.
+        for i in range(ndim - 1):
+            y += (100. * jnp.power(z[i + 1] - jnp.power(z[i], 2), 2) + jnp.power(1 - z[i], 2))
+        return -y
+
+    model = Model(prior_model=prior_model, log_likelihood=log_likelihood)
+
+    return model
+
+
+def build_spikeslab_model(ndim: int) -> Model:
+    """
+    Builds the SpokeSlab model.
+
+    Args:
+        ndim: Number of input dimensions the function should take.
+
+    Returns:
+        model: The SpokeSlab model.
+    """
+
+    def prior_model():
+        z = yield Prior(tfpd.Uniform(low=-4. * jnp.ones(ndim), high=8. * jnp.ones(ndim)), name='z')
+        return z
+
+    def log_likelihood(z):
+        mean_1 = jnp.array([6., 6.])
+        mean_2 = jnp.array([2.5, 2.5])
+        for i in range(ndim - 2):
+            mean_1 = jnp.append(mean_1, 0.)
+            mean_2 = jnp.append(mean_2, 0.)
+        cov_1 = 0.08 * jnp.eye(ndim)
+        cov_2 = 0.8 * jnp.eye(ndim)
+        gauss_1 = tfp.distributions.MultivariateNormalFullCovariance(loc=mean_1, covariance_matrix=cov_1).log_prob(z)
+        gauss_2 = tfp.distributions.MultivariateNormalFullCovariance(loc=mean_2, covariance_matrix=cov_2).log_prob(z)
+        y = jnp.logaddexp(gauss_1, gauss_2)
+        return y
+
+    model = Model(prior_model=prior_model, log_likelihood=log_likelihood)
+
+    return model
+
+
+def all_models() -> Dict[str, Model]:
+    """
+    Return all the models
+
+    Returns:
+        A dictionary of models
+    """
+    return dict(
+        eggbox=build_eggbox_model(ndim=10),
+        rastrigin=build_rastrigin_model(ndim=10),
+        rosenbrock=build_rosenbrock_model(ndim=10),
+        spikeslab=build_spikeslab_model(ndim=10)
+    )
+
+
+class Timer:
+    def __enter__(self):
+        self.t0 = monotonic_ns()
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        print(f"Time to execute: {(monotonic_ns() - self.t0) / 1e9} seconds.")
+
+
+def main():
+    for model_name, model in all_models().items():
+        print(f"Testing model {model_name}")
+        model.sanity_check(jax.random.PRNGKey(0), 1000)
+        ns = DefaultNestedSampler(model=model,
+                                  max_samples=1000000,
+                                  verbose=True,
+                                  difficult_model=True,
+                                  parameter_estimation=True
+                                  )
+        ns_jit = jax.jit(lambda key: ns(key))
+        ns_compiled = ns_jit.lower(jax.random.PRNGKey(42)).compile()
+        with Timer():
+            termination_reason, state = ns_compiled(jax.random.PRNGKey(42))
+            termination_reason.block_until_ready()
+        results = ns.to_results(termination_reason=termination_reason, state=state)
+        ns.plot_diagnostics(results)
+        ns.summary(results)
+        ns.plot_cornerplot(results)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/benchmarks/parallel_problems/main.py b/benchmarks/parallel_problems/main.py
new file mode 100644
index 00000000..b869e5f4
--- /dev/null
+++ b/benchmarks/parallel_problems/main.py
@@ -0,0 +1,95 @@
+import os
+import time
+
+# Force 2 jax  hosts
+os.environ["XLA_FLAGS"] = f"--xla_force_host_platform_device_count={os.cpu_count()}"
+
+import jax
+import jax.numpy as jnp
+import numpy as np
+import pkg_resources
+import tensorflow_probability.substrates.jax as tfp
+from jax._src.scipy.linalg import solve_triangular
+
+from jaxns import Model, Prior, DefaultNestedSampler
+
+tfpd = tfp.distributions
+
+
+def run_model(key):
+    def log_normal(x, mean, cov):
+        L = jnp.linalg.cholesky(cov)
+        dx = x - mean
+        dx = solve_triangular(L, dx, lower=True)
+        return -0.5 * x.size * jnp.log(2. * jnp.pi) - jnp.sum(jnp.log(jnp.diag(L))) \
+            - 0.5 * dx @ dx
+
+    ndims = 8
+    prior_mu = 15 * jnp.ones(ndims)
+    prior_cov = jnp.diag(jnp.ones(ndims)) ** 2
+
+    data_mu = jnp.zeros(ndims)
+    data_cov = jnp.diag(jnp.ones(ndims)) ** 2
+    data_cov = jnp.where(data_cov == 0., 0.99, data_cov)
+
+    log_Z_true = log_normal(data_mu, prior_mu, prior_cov + data_cov)
+    # not super happy with this being 1.58 and being off by like 0.1. Probably related to the ESS.
+    post_mu = prior_cov @ jnp.linalg.inv(prior_cov + data_cov) @ data_mu + data_cov @ jnp.linalg.inv(
+        prior_cov + data_cov) @ prior_mu
+
+    # print(f"True post mu:{post_mu}")
+    # print(f"True log Z: {log_Z_true}")
+
+    def prior_model():
+        x = yield Prior(
+            tfpd.MultivariateNormalTriL(loc=prior_mu, scale_tril=jnp.linalg.cholesky(prior_cov)),
+            name='x')
+        return x
+
+    def log_likelihood(x):
+        return tfpd.MultivariateNormalTriL(loc=data_mu, scale_tril=jnp.linalg.cholesky(data_cov)).log_prob(x)
+
+    model = Model(prior_model=prior_model, log_likelihood=log_likelihood)
+
+    ns = DefaultNestedSampler(model=model, max_samples=100000, verbose=False, num_parallel_workers=len(jax.devices()))
+
+    termination_reason, state = ns(key)
+    results = ns.to_results(termination_reason=termination_reason, state=state, trim=False)
+    return results.log_Z_mean - log_Z_true, results.log_Z_uncert
+
+
+def main():
+    num_devices = len(jax.devices())
+    jaxns_version = pkg_resources.get_distribution("jaxns").version
+    m = 1
+    run_model_aot = jax.jit(run_model).lower(jax.random.PRNGKey(0)).compile()
+    dt = []
+
+    errors = []
+    uncerts = []
+
+    for i in range(m):
+        t0 = time.time()
+        log_Z_error, log_Z_uncert = run_model_aot(jax.random.PRNGKey(i))
+        log_Z_error.block_until_ready()
+        t1 = time.time()
+        dt.append(t1 - t0)
+        errors.append(log_Z_error)
+        uncerts.append(log_Z_uncert)
+    total_time = sum(dt)
+    best_3 = sum(sorted(dt)[:min(3, m)]) / 3.
+    # print(f"Errors: {errors}")
+    # print(f"Uncerts: {uncerts}")
+    print(f"JAXNS {jaxns_version}\n"
+          f"num_devices: {num_devices}\n"
+          f"\tMean error: {np.mean(errors)}\n"
+          f"\tMean uncert: {np.mean(uncerts)}\n"
+          f"Avg. time taken: {total_time / m:.5f} seconds.\n"
+          f"The best 3 of {m} runs took {best_3:.5f} seconds.")
+
+    with open('results', 'a') as fp:
+        fp.write(f"{jaxns_version},{num_devices},{np.mean(errors)},{np.mean(uncerts)},{total_time / m},{best_3}\n")
+
+
+if __name__ == '__main__':
+    main()
diff --git a/benchmarks/parallel_problems/results b/benchmarks/parallel_problems/results
new file mode 100644
index 00000000..54342079
--- /dev/null
+++ b/benchmarks/parallel_problems/results
@@ -0,0 +1,2 @@
+2.5.1,12,-0.8741127252578735,0.0003452669479884207,95.40295028686523,77.15287351608276
+2.5.1,12,-1.30291748046875,0.32637646794319153,102.9092493057251,34.30308310190836
diff --git a/debug/scan_associative_weirdness.py b/debug/scan_associative_weirdness.py
new file mode 100644
index 00000000..a7554c1b
--- /dev/null
+++ b/debug/scan_associative_weirdness.py
@@ -0,0 +1,34 @@
+import jax
+import numpy as np
+import tensorflow_probability.substrates.jax as tfp
+from jax import numpy as jnp
+
+
+def explicit_verify_associative(op, elems):
+    output_1 = op(op(elems[0], elems[1]), elems[2])
+    output_2 = op(elems[0], op(elems[1], elems[2]))
+    print(output_1, output_2)
+    assert output_1 == output_2
+
+
+def main():
+    elems = jax.random.normal(jax.random.PRNGKey(0), shape=(3,))
+
+    elem_shape = jax.tree.map(lambda x: np.shape(x[0]), elems)  # ()
+
+    def per_elem_op(x) -> jax.Array:
+        return jnp.sum(x)
+
+    def associative_op(x, y):
+        print(f"x.shape={np.shape(x)}, y.shape={np.shape(y)}")
+        assert np.shape(x) == elem_shape
+        assert np.shape(y) == elem_shape
+        return per_elem_op(x) + per_elem_op(y)
+
+    explicit_verify_associative(associative_op, elems)
+
+    _ = tfp.math.scan_associative(associative_op, elems)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/docs/conf.py b/docs/conf.py
index c956b808..8ec55df6 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -12,7 +12,7 @@
 project = "jaxns"
 copyright = "2022, Joshua G. Albert"
 author = "Joshua G. Albert"
-release = "2.5.1"
+release = "2.5.2"
 
 # -- General configuration ---------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
diff --git a/docs/examples/Lennard_Jones_potential.ipynb b/docs/examples/Lennard_Jones_potential.ipynb
index 82617dcf..b0ebc0d9 100644
--- a/docs/examples/Lennard_Jones_potential.ipynb
+++ b/docs/examples/Lennard_Jones_potential.ipynb
@@ -38,7 +38,7 @@
    "source": [
     "\n",
     "\n",
-    "from jax.config import config\n",
+    "from jax import config\n",
     "\n",
     "# config.update(\"jax_enable_x64\", True)\n",
     "\n",
diff --git a/docs/examples/dark_matter_model.ipynb b/docs/examples/dark_matter_model.ipynb
new file mode 100644
index 00000000..9b90d056
--- /dev/null
+++ b/docs/examples/dark_matter_model.ipynb
@@ -0,0 +1,517 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "813bc56bc8e3f4b3",
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-03-05T13:46:01.218002947Z",
+     "start_time": "2024-03-05T13:45:43.619586087Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "-364074180.0 nan\n",
+      "-364074180.0 nan\n",
+      "-364074180.0 nan\n",
+      "-364074180.0 nan\n",
+      "Traced<ShapedArray(float32[])>with<BatchTrace(level=2/0)> with\n",
+      "  val = Traced<ShapedArray(float32[1000])>with<DynamicJaxprTrace(level=1/0)>\n",
+      "  batch_dim = 0 Traced<ShapedArray(float32[])>with<BatchTrace(level=2/0)> with\n",
+      "  val = Traced<ShapedArray(float32[1000])>with<DynamicJaxprTrace(level=1/0)>\n",
+      "  batch_dim = 0\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO[2024-03-05 14:45:54,932]: Sanity check...\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "5073.8296 14536.662\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO[2024-03-05 14:45:55,980]: Found bad point: [0.00658643 0.615165   0.65633774 0.5147824  0.825768   0.98090184\n",
+      " 0.46996582 0.3895197  0.6139971  0.8687408  0.9155092  0.9991051\n",
+      " 0.1941179  0.05444241 0.93784034] -> {'signal_rate': Array(13.172865, dtype=float32), 'bg_rate': Array(1230.33, dtype=float32), 'iodine_rate': Array(1312.6755, dtype=float32), 'categorical_dist_for_E': Array(2, dtype=int32), 'E_component_distributions_0': Array(73.49829, dtype=float32), 'E_component_distributions_1': Array(64.121765, dtype=float32), 'E_component_distributions_2': Array(67.488686, dtype=float32), 'Nq_scaled': Array(1.0324882, dtype=float32), 'Ni': Array(0.85527396, dtype=float32), 'Ne': Array(14536.662, dtype=float32), 'Nph_det': Array(nan, dtype=float32), 'Nph_det_dpe': Array(nan, dtype=float32), 'Ne_det': Array(0.5063825, dtype=float32)}\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "6374.5996 8940.412\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO[2024-03-05 14:45:56,999]: Found bad point: [0.9353961  0.7511554  0.5853338  0.94716334 0.85100925 0.39135242\n",
+      " 0.78641284 0.6188415  0.27138674 0.17762768 0.10887718 0.9982023\n",
+      " 0.4394921  0.9360069  0.7860557 ] -> {'signal_rate': Array(1870.7921, dtype=float32), 'bg_rate': Array(1502.3108, dtype=float32), 'iodine_rate': Array(1170.6676, dtype=float32), 'categorical_dist_for_E': Array(0, dtype=int32), 'E_component_distributions_0': Array(89.32064, dtype=float32), 'E_component_distributions_1': Array(64.49748, dtype=float32), 'E_component_distributions_2': Array(66.86774, dtype=float32), 'Nq_scaled': Array(0.98012453, dtype=float32), 'Ni': Array(0.8428392, dtype=float32), 'Ne': Array(8940.412, dtype=float32), 'Nph_det': Array(nan, dtype=float32), 'Nph_det_dpe': Array(nan, dtype=float32), 'Ne_det': Array(0.50418836, dtype=float32)}\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "4376.9453 7933.252\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO[2024-03-05 14:45:57,995]: Found bad point: [0.73486686 0.01864588 0.14880204 0.3777262  0.6433649  0.6921903\n",
+      " 0.68583894 0.0933305  0.6851871  0.11016905 0.561115   0.9982666\n",
+      " 0.03954649 0.8049656  0.63736415] -> {'signal_rate': Array(1469.7338, dtype=float32), 'bg_rate': Array(37.291763, dtype=float32), 'iodine_rate': Array(297.6041, dtype=float32), 'categorical_dist_for_E': Array(1, dtype=int32), 'E_component_distributions_0': Array(84.29195, dtype=float32), 'E_component_distributions_1': Array(62.684967, dtype=float32), 'E_component_distributions_2': Array(67.63041, dtype=float32), 'Nq_scaled': Array(0.9589321, dtype=float32), 'Ni': Array(0.8492298, dtype=float32), 'Ne': Array(7933.252, dtype=float32), 'Nph_det': Array(nan, dtype=float32), 'Nph_det_dpe': Array(nan, dtype=float32), 'Ne_det': Array(0.5019986, dtype=float32)}\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "4896.732 6125.5044\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO[2024-03-05 14:45:59,017]: Found bad point: [0.53153217 0.21612597 0.8912518  0.12068129 0.7840611  0.99708676\n",
+      " 0.5106522  0.56216013 0.4200827  0.5251063  0.43208838 0.997453\n",
+      " 0.47975826 0.46095204 0.43860602] -> {'signal_rate': Array(1063.0643, dtype=float32), 'bg_rate': Array(432.25192, dtype=float32), 'iodine_rate': Array(1782.5037, dtype=float32), 'categorical_dist_for_E': Array(2, dtype=int32), 'E_component_distributions_0': Array(75.53261, dtype=float32), 'E_component_distributions_1': Array(64.4006, dtype=float32), 'E_component_distributions_2': Array(67.173996, dtype=float32), 'Nq_scaled': Array(1.0011181, dtype=float32), 'Ni': Array(0.84756106, dtype=float32), 'Ne': Array(6125.5044, dtype=float32), 'Nph_det': Array(nan, dtype=float32), 'Nph_det_dpe': Array(nan, dtype=float32), 'Ne_det': Array(0.49897572, dtype=float32)}\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "-47406.883 nan\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO[2024-03-05 14:46:00,147]: Found bad point: [7.0854235e-01 8.4835613e-01 6.0063398e-01 6.6411400e-01 3.2021821e-01\n",
+      " 4.7820663e-01 7.4464083e-01 5.2524757e-01 4.6370864e-01 4.7206879e-04\n",
+      " 4.2859972e-01 1.5435648e-01 6.6739655e-01 1.7577899e-01 5.0672293e-03] -> {'signal_rate': Array(1417.0847, dtype=float32), 'bg_rate': Array(1696.7123, dtype=float32), 'iodine_rate': Array(1201.268, dtype=float32), 'categorical_dist_for_E': Array(0, dtype=int32), 'E_component_distributions_0': Array(87.23204, dtype=float32), 'E_component_distributions_1': Array(64.34154, dtype=float32), 'E_component_distributions_2': Array(67.244705, dtype=float32), 'Nq_scaled': Array(-7.4635515, dtype=float32), 'Ni': Array(nan, dtype=float32), 'Ne': Array(nan, dtype=float32), 'Nph_det': Array(nan, dtype=float32), 'Nph_det_dpe': Array(nan, dtype=float32), 'Ne_det': Array(nan, dtype=float32)}\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "-182.88918 nan\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO[2024-03-05 14:46:01,148]: Found bad point: [0.95632267 0.5956876  0.39256895 0.567359   0.8192885  0.08967352\n",
+      " 0.31124794 0.37546933 0.84953964 0.00448561 0.21437812 0.49151063\n",
+      " 0.0371505  0.75123656 0.11409247] -> {'signal_rate': Array(1912.6454, dtype=float32), 'bg_rate': Array(1191.3752, dtype=float32), 'iodine_rate': Array(785.1379, dtype=float32), 'categorical_dist_for_E': Array(1, dtype=int32), 'E_component_distributions_0': Array(65.56239, dtype=float32), 'E_component_distributions_1': Array(64.09654, dtype=float32), 'E_component_distributions_2': Array(68.279976, dtype=float32), 'Nq_scaled': Array(-0.03918624, dtype=float32), 'Ni': Array(nan, dtype=float32), 'Ne': Array(nan, dtype=float32), 'Nph_det': Array(nan, dtype=float32), 'Nph_det_dpe': Array(nan, dtype=float32), 'Ne_det': Array(nan, dtype=float32)}\n"
+     ]
+    },
+    {
+     "ename": "AssertionError",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m",
+      "\u001B[0;31mAssertionError\u001B[0m                            Traceback (most recent call last)",
+      "Cell \u001B[0;32mIn[8], line 335\u001B[0m\n\u001B[1;32m    324\u001B[0m         \u001B[38;5;28;01mreturn\u001B[39;00m Model(prior_model\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mprior_model, log_likelihood\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mlog_likelihood)\n\u001B[1;32m    327\u001B[0m model \u001B[38;5;241m=\u001B[39m XenonModel(\n\u001B[1;32m    328\u001B[0m     data_S1\u001B[38;5;241m=\u001B[39mjnp\u001B[38;5;241m.\u001B[39marray([\u001B[38;5;241m1.\u001B[39m, \u001B[38;5;241m2.\u001B[39m, \u001B[38;5;241m3.\u001B[39m]),\n\u001B[1;32m    329\u001B[0m     data_S2\u001B[38;5;241m=\u001B[39mjnp\u001B[38;5;241m.\u001B[39marray([\u001B[38;5;241m1.\u001B[39m, \u001B[38;5;241m2.\u001B[39m, \u001B[38;5;241m3.\u001B[39m]),\n\u001B[0;32m   (...)\u001B[0m\n\u001B[1;32m    332\u001B[0m     density\u001B[38;5;241m=\u001B[39mjnp\u001B[38;5;241m.\u001B[39masarray(\u001B[38;5;241m2.8\u001B[39m)\n\u001B[1;32m    333\u001B[0m )\u001B[38;5;241m.\u001B[39mbuild_model()\n\u001B[0;32m--> 335\u001B[0m \u001B[43mmodel\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43msanity_check\u001B[49m\u001B[43m(\u001B[49m\u001B[43mjax\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mrandom\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mPRNGKey\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;241;43m42\u001B[39;49m\u001B[43m)\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mS\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;241;43m1000\u001B[39;49m\u001B[43m)\u001B[49m\n",
+      "File \u001B[0;32m~/git/jaxns/jaxns/framework/model.py:183\u001B[0m, in \u001B[0;36mModel.sanity_check\u001B[0;34m(self, key, S)\u001B[0m\n\u001B[1;32m    181\u001B[0m     \u001B[38;5;28;01mif\u001B[39;00m jnp\u001B[38;5;241m.\u001B[39misnan(_log_L):\n\u001B[1;32m    182\u001B[0m         logger\u001B[38;5;241m.\u001B[39minfo(\u001B[38;5;124mf\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mFound bad point: \u001B[39m\u001B[38;5;132;01m{\u001B[39;00m_U\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m -> \u001B[39m\u001B[38;5;132;01m{\u001B[39;00m\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mtransform(_U)\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m\"\u001B[39m)\n\u001B[0;32m--> 183\u001B[0m \u001B[38;5;28;01massert\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;28many\u001B[39m(np\u001B[38;5;241m.\u001B[39misnan(log_L))\n\u001B[1;32m    184\u001B[0m logger\u001B[38;5;241m.\u001B[39minfo(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mSanity check passed\u001B[39m\u001B[38;5;124m\"\u001B[39m)\n\u001B[1;32m    185\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;124m'\u001B[39m\u001B[38;5;124mparsed_prior\u001B[39m\u001B[38;5;124m'\u001B[39m \u001B[38;5;129;01min\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m\u001B[38;5;18m__dict__\u001B[39m:\n",
+      "\u001B[0;31mAssertionError\u001B[0m: "
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "import dataclasses\n",
+    "\n",
+    "# import NEST\n",
+    "import tensorflow_probability.substrates.jax as tfp\n",
+    "\n",
+    "from jaxns import Categorical\n",
+    "from jaxns import Prior, Model\n",
+    "\n",
+    "tfpd = tfp.distributions\n",
+    "\n",
+    "import numpy as np\n",
+    "\n",
+    "# JAX imports\n",
+    "import jax\n",
+    "import jax.numpy as jnp\n",
+    "from jax.scipy.special import erf\n",
+    "\n",
+    "\n",
+    "@dataclasses.dataclass(eq=False)\n",
+    "class NEST:\n",
+    "    def __post_init__(self):\n",
+    "        # Global vars\n",
+    "        self.sqrt2 = np.sqrt(2)\n",
+    "        self.inv_sqrt2_PI = 1 / np.sqrt(2 * jnp.pi)\n",
+    "\n",
+    "    def fano_ER(self, mean_N_q, E_field, density):\n",
+    "        \"\"\"\n",
+    "        Calculates the a Fano-like factor to determine the variance of quanta generation.\n",
+    "    \n",
+    "        Parameters\n",
+    "        ----------\n",
+    "        mean_N_q : scalar or array\n",
+    "            Mean number of quanta produced per event.\n",
+    "        E_field : scalar or array\n",
+    "            Electric field strength in the detector.\n",
+    "        density : scalar or array\n",
+    "            Density of the detector material.\n",
+    "    \n",
+    "        Returns\n",
+    "        -------\n",
+    "        Fano factor : scalar or array\n",
+    "            The calculated Fano factor based on the input parameters.\n",
+    "        \n",
+    "        \"\"\"\n",
+    "\n",
+    "        return (0.13 - 0.030 * density - 0.0057 * density ** 2 + 0.0016 * density ** 3 + 0.0015 * jnp.sqrt(\n",
+    "            mean_N_q * E_field))\n",
+    "\n",
+    "    def workfunction(self, density, molar_mass=131.293, avo=6.0221409e+23, atom_num=54.0, old_13eV=1.1716263232):\n",
+    "        alpha = 0.067366 + density * 0.039693\n",
+    "        eDensity = (density / molar_mass) * avo * atom_num\n",
+    "        return old_13eV * (18.7263 - 1.01e-23 * eDensity), alpha\n",
+    "\n",
+    "    def calculate_yield_parameters(self, E_field):\n",
+    "        m01 = 30.66 + (6.1978 - 30.66) / (1. + (E_field / 73.855) ** 2.0318) ** 0.41883\n",
+    "        m02 = 77.2931084\n",
+    "        m03 = jnp.log10(E_field) * 0.13946236 + 0.52561312\n",
+    "        m04 = 1.82217496 + (2.82528809 - 1.82217496) / (1. + (E_field / 144.65029656) ** -2.80532006)\n",
+    "        # m05 = Nq / energy / (1. + alpha * erf(0.05 * E)) - m01\n",
+    "        m07 = 7.02921301 + (98.27936794 - 7.02921301) / (1. + (E_field / 256.48156448) ** 1.29119251)\n",
+    "        m08 = 4.285781736\n",
+    "        m09 = 0.3344049589\n",
+    "        m10 = 0.0508273937 + (0.1166087199 - 0.0508273937) / (1. + (E_field / 1.39260460e+02) ** -0.65763592)\n",
+    "        return m01, m02, m03, m04, m07, m08, m09, m10\n",
+    "\n",
+    "    def get_yields_beta(self, E, density, exciton_ion_ratio, W, m01=7.096208, m02=77.2931084, m03=0.7155229,\n",
+    "                        m04=1.8279102,\n",
+    "                        m07=94.39740941928082, m08=4.285781736, m09=0.3344049589, m10=0.06623858):\n",
+    "        \"\"\"\n",
+    "        Calculates the yields of quanta, electrons and photons for beta radiation in a detector.\n",
+    "    \n",
+    "        Parameters\n",
+    "        ----------\n",
+    "        E : scalar or array\n",
+    "            Energy of the incident beta radiation.\n",
+    "        density : scalar or array\n",
+    "            Density of the detector material.\n",
+    "        exciton_ion_ratio : scalar\n",
+    "            Ratio of excitons to ions produced in the detector.\n",
+    "        W : scalar\n",
+    "            Average energy required to produce an electron-ion pair.\n",
+    "        m01, m02, m03, m04, m07, m08, m09, m10 : scalars\n",
+    "            Parameter values used in the empirical formula for calculating yields.\n",
+    "    \n",
+    "        Returns\n",
+    "        -------\n",
+    "        mean_N_q : scalar or array\n",
+    "            Mean number of quanta produced per event.\n",
+    "        Ne : scalar or array\n",
+    "            Number of electrons produced.\n",
+    "        Nph : scalar or array\n",
+    "            Number of photons produced.\n",
+    "    \n",
+    "        Notes\n",
+    "        -----\n",
+    "        This function calculates the yields of quanta, electrons and photons produced by beta radiation \n",
+    "        in LXe based on the energy of the incident radiation, the density of the detector material, \n",
+    "        and the ratio of excitons to ions produced.\n",
+    "        \"\"\"\n",
+    "        DENSITY = 2.9\n",
+    "        mean_N_q = E / W * 1e3\n",
+    "        m05 = mean_N_q / E / (1 + exciton_ion_ratio) - m01\n",
+    "        Qy = m01 + (m02 - m01) / ((1. + (E / m03) ** m04)) ** m09 + m05 + (0.0 - m05) / ((1. + (E / m07) ** m08)) ** m10\n",
+    "        coeff_TI = (1. / DENSITY) ** 0.3\n",
+    "        coeff_Ni = (1. / DENSITY) ** 1.4\n",
+    "        coeff_OL = (1. / DENSITY) ** -1.7 / jnp.log(1. + coeff_TI * coeff_Ni * (DENSITY ** 1.7))\n",
+    "        Qy *= coeff_OL * jnp.log(1. + coeff_TI * coeff_Ni * (density ** 1.7)) * (density ** -1.7)\n",
+    "        Ly = mean_N_q / E - Qy\n",
+    "        Ne = Qy * E\n",
+    "        Nph = Ly * E\n",
+    "        return mean_N_q, Ne, Nph\n",
+    "\n",
+    "    def Nei_ratio(self, E, density, alpha):\n",
+    "        \"\"\"\n",
+    "        Calculates the ratio of the number of electrons to ions for a given energy and material density.\n",
+    "    \n",
+    "        Parameters\n",
+    "        ----------\n",
+    "        E : scalar or array\n",
+    "            Energy of the incident radiation.\n",
+    "        density : scalar or array\n",
+    "            Density of the detector material.\n",
+    "    \n",
+    "        Returns\n",
+    "        -------\n",
+    "        Nei_ratio : scalar or array\n",
+    "            The ratio of the number of electrons to ions.\n",
+    "    \n",
+    "        Notes\n",
+    "        -----\n",
+    "        This function calculates the ratio of the number of electrons to ions produced by \n",
+    "        ERs.\n",
+    "        \"\"\"\n",
+    "\n",
+    "        return alpha * erf(0.05 * E)\n",
+    "\n",
+    "    def recom_omega_ER(self, E_field, elecFrac, width_param_7=0.046452, width_param_8=0.205, width_param_9=0.45,\n",
+    "                       width_param_10=-0.2):\n",
+    "        '''\n",
+    "        This function calculates the omega parameter for electron recoil (ER) events based on certain input parameters.\n",
+    "        \n",
+    "        Parameters\n",
+    "        ----------\n",
+    "        E_field : float \n",
+    "            The electric field value.\n",
+    "        elecFrac : float \n",
+    "            The fraction of energy deposited by electrons.\n",
+    "        width_param_7 : float, optional \n",
+    "            Parameter A from Table VI of https://arxiv.org/pdf/2211.10726.pdf; default is 0.046452.\n",
+    "        width_param_8 : float, optional \n",
+    "            Omega parameter from Table VI of https://arxiv.org/pdf/2211.10726.pdf; default is 0.205.\n",
+    "        width_param_9 : float, optional \n",
+    "            Xi parameter from Table VI of https://arxiv.org/pdf/2211.10726.pdf; default is 0.45.\n",
+    "        width_param_10 : float, optional \n",
+    "            Skewness parameter; default is -0.2.\n",
+    "    \n",
+    "        Returns\n",
+    "        -------\n",
+    "        omega : float \n",
+    "            The calculated omega parameter for ER events.\n",
+    "        width_param_10 : float \n",
+    "            The skewness parameter.\n",
+    "    \n",
+    "        Notes\n",
+    "        -----\n",
+    "        The function uses the provided parameters to calculate the value of omega for ER events. It also returns the skewness parameter.\n",
+    "        '''\n",
+    "        A = 0.086036 + (width_param_7 - 0.086036) / (1 + (E_field / 295.2) ** 251.6) ** 0.0069114\n",
+    "        wide = width_param_8\n",
+    "        cntr = width_param_9\n",
+    "        skew = width_param_10\n",
+    "        mode = cntr + 2 * (self.inv_sqrt2_PI) * skew * wide / jnp.sqrt(1. + skew * skew)\n",
+    "        norm = 1. / (jnp.exp(-0.5 * (mode - cntr) ** 2 / (wide * wide)) * (\n",
+    "                1. + erf(skew * (mode - cntr) / (wide * self.sqrt2))))\n",
+    "        omega = norm * A * jnp.exp(-0.5 * (elecFrac - cntr) ** 2 / (wide * wide)) * (\n",
+    "                1. + erf(skew * (elecFrac - cntr) / (wide * self.sqrt2)))\n",
+    "        return omega, width_param_10\n",
+    "\n",
+    "    def ER_skew(self, E, E_field, alpha0=1.39, cc0=4.0, cc1=22.1, E0=7.7, E1=54., E2=26.7, E3=6.4, F0=225., F1=71.):\n",
+    "        \"\"\"\n",
+    "        LUX ER Skewness model for computing the recombination skewness. Default parameters from NEST 2.3.12. \n",
+    "        \n",
+    "        Parameters:\n",
+    "        E (float): Energy in keV.\n",
+    "        E_field (float): Electric field strength in V/cm.\n",
+    "        alpha0 (float): Baseline scale factor for the ER response. Default value is 1.39.\n",
+    "        cc0 (float): Scale factor for the first exponential term. Default value is 4.0.\n",
+    "        cc1 (float): Scale factor for the second exponential term. Default value is 22.1.\n",
+    "        E0 (float): Decay constant for the first exponential term. Default value is 7.7.\n",
+    "        E1 (float): Decay constant for the second exponential term. Default value is 54.\n",
+    "        E2 (float): Inflection point for the sigmoid function. Default value is 26.7.\n",
+    "        E3 (float): Scale factor for the sigmoid function. Default value is 6.4.\n",
+    "        F0 (float): Decay constant for the field dependence of the first exponential term. Default value is 225.\n",
+    "        F1 (float): Decay constant for the field dependence of the second exponential term. Default value is 71.\n",
+    "    \n",
+    "        Returns:\n",
+    "        float: The ER response given the input parameters. If E_field is less than 50 or greater than 1e4, it returns 0.0.\n",
+    "        \"\"\"\n",
+    "        mask = jnp.bitwise_or(E_field < 50, E_field > 1e4)\n",
+    "        return jnp.where(mask,\n",
+    "                         0.,\n",
+    "                         1. / (1. + jnp.exp((E - E2) / E3)) * (\n",
+    "                                 alpha0 + cc0 * jnp.exp(-1. * E_field / F0) * (1. - jnp.exp(-1. * E / E0))) + 1. / (\n",
+    "                                 1. + jnp.exp(-1. * (E - E2) / E3)) * cc1 * jnp.exp(-1. * E / E1) * jnp.exp(\n",
+    "                             -1. * jnp.sqrt(E_field) / jnp.sqrt(F1)))\n",
+    "\n",
+    "\n",
+    "@dataclasses.dataclass(eq=False)\n",
+    "class XenonModel:\n",
+    "    data_S1: jax.Array\n",
+    "    data_S2: jax.Array\n",
+    "    e_survival_prob: jax.Array\n",
+    "    relative_LCE: jax.Array\n",
+    "    density: jax.Array\n",
+    "\n",
+    "    E_field = 60.\n",
+    "    S2_sigma: float = 8.\n",
+    "    g1: float = 0.105\n",
+    "    g2: float = 17.3\n",
+    "    SE_gain: float = 31.8\n",
+    "    PMT_sigma: float = 0.35\n",
+    "    p_dpe: float = 0.2\n",
+    "\n",
+    "    def prior_model(self):\n",
+    "        nest = NEST()\n",
+    "        W, alpha = nest.workfunction(self.density)\n",
+    "        m01, m02, m03, m04, m07, m08, m09, m10 = nest.calculate_yield_parameters(\n",
+    "            self.E_field)\n",
+    "\n",
+    "        signal_rate = yield Prior(tfpd.Uniform(0.0, 2000.), name='signal_rate')\n",
+    "        bg_rate = yield Prior(tfpd.Uniform(0.0, 2000.), name='bg_rate')\n",
+    "        iodine_rate = yield Prior(tfpd.Uniform(0.0, 2000.), name='iodine_rate')\n",
+    "        total_rate = signal_rate + bg_rate + iodine_rate\n",
+    "\n",
+    "        categorical_dist_for_E = yield Categorical(\n",
+    "            parametrisation='gumbel_max',\n",
+    "            probs=jnp.array([jnp.abs(bg_rate), jnp.abs(signal_rate), jnp.abs(iodine_rate)]) / (\n",
+    "                    jnp.abs(bg_rate) + jnp.abs(signal_rate) + jnp.abs(iodine_rate)),\n",
+    "            name='categorical_dist_for_E'\n",
+    "        )\n",
+    "\n",
+    "        E_component_distributions = [\n",
+    "            (yield Prior(tfpd.Uniform(50., 100.), name='E_component_distributions_0')),\n",
+    "            (yield Prior(tfpd.TruncatedCauchy(64.3, 0.5, low=0., high=2000.), name='E_component_distributions_1')),\n",
+    "            (yield Prior(tfpd.TruncatedCauchy(67.3, 0.5, low=0., high=2000.), name='E_component_distributions_2'))\n",
+    "        ]\n",
+    "\n",
+    "        E_component_distributions = jnp.stack(E_component_distributions, axis=0)\n",
+    "\n",
+    "        E = E_component_distributions[categorical_dist_for_E]\n",
+    "        exciton_ion_ratio = nest.Nei_ratio(E, self.density, alpha)\n",
+    "        mean_N_q, mean_Ne, mean_Nph = nest.get_yields_beta(E,\n",
+    "                                                           self.density,\n",
+    "                                                           exciton_ion_ratio,\n",
+    "                                                           W,\n",
+    "                                                           m01=m01,\n",
+    "                                                           m02=m02,\n",
+    "                                                           m03=m03,\n",
+    "                                                           m04=m04,\n",
+    "                                                           m07=m07,\n",
+    "                                                           m08=m08,\n",
+    "                                                           m09=m09,\n",
+    "                                                           m10=m10)\n",
+    "\n",
+    "        fano_factor = 1.\n",
+    "        Nq_scaled = yield Prior(tfpd.TruncatedCauchy(\n",
+    "            1.0, jnp.sqrt(fano_factor / mean_N_q), low=-1e5, high=10), name='Nq_scaled')\n",
+    "        Nq = Nq_scaled * mean_N_q\n",
+    "        alf = 1 / (1 + exciton_ion_ratio)\n",
+    "        # probs = alpha / total_count = alf\n",
+    "        alpha = Nq * alf + 1\n",
+    "        # beta + alpha = total_count\n",
+    "        beta = Nq - Nq * alf + 1\n",
+    "        Ni = Nq * (yield Prior(tfpd.Beta(concentration1=alpha, concentration0=beta), name='Ni'))\n",
+    "        e_frac = mean_Ne / mean_N_q\n",
+    "        recombProb = 1. - (exciton_ion_ratio + 1.) * e_frac\n",
+    "        recomb_omega, _ = nest.recom_omega_ER(E, self.E_field, e_frac)\n",
+    "        skewness = nest.ER_skew(E, self.E_field)\n",
+    "\n",
+    "        recomb_variance = recombProb * (1 - recombProb) * Ni + (recomb_omega * Ni) ** 2\n",
+    "        widthCorrection = jnp.sqrt(1. - (2. / jnp.pi) * skewness * skewness / (1. + skewness * skewness))\n",
+    "        muCorrection = (jnp.sqrt(recomb_variance) / widthCorrection) * (\n",
+    "                skewness / jnp.sqrt(1. + skewness * skewness)) * 2. * nest.inv_sqrt2_PI\n",
+    "        Ne_mu = (1. - recombProb) * Ni - muCorrection\n",
+    "        Ne_sigma = jnp.sqrt(recomb_variance) / widthCorrection\n",
+    "        Ne = yield Prior(tfpd.TruncatedCauchy(Ne_mu, Ne_sigma, low=0., high=1e5), name='Ne')\n",
+    "\n",
+    "        print(Nq, Ne)\n",
+    "        Nph = Nq - Ne\n",
+    "        probs = self.g1 * self.relative_LCE / (1 + self.p_dpe)\n",
+    "        # Nph_det = yield Prior(tfpd.Binomial(total_count=Nph, probs=self.g1 * self.relative_LCE / (1 + self.p_dpe)),\n",
+    "        #                       name='Nph_det')\n",
+    "        # Use Beta\n",
+    "        alpha = Nph * probs + 1\n",
+    "        beta = Nph - Nph * probs + 1\n",
+    "        Nph_det = Nph * (yield Prior(tfpd.Beta(concentration1=alpha, concentration0=beta), name='Nph_det'))\n",
+    "\n",
+    "        # Nph_det_dpe = yield Prior(tfpd.Binomial(total_count=Nph_det, probs=self.p_dpe), name='Nph_det_dpe')\n",
+    "        # use Beta\n",
+    "        alpha = Nph_det * self.p_dpe + 1\n",
+    "        beta = Nph_det - Nph_det * self.p_dpe + 1\n",
+    "        Nph_det_dpe = Nph_det * (yield Prior(tfpd.Beta(concentration1=alpha, concentration0=beta), name='Nph_det_dpe'))\n",
+    "\n",
+    "        # Ne_det = yield Prior(tfpd.Binomial(total_count=Ne, probs=self.e_survival_prob), name='Ne_det')\n",
+    "        # use Beta\n",
+    "        alpha = Ne * self.e_survival_prob + 1\n",
+    "        beta = Ne - Ne * self.e_survival_prob + 1\n",
+    "        Ne_det = Ne * (yield Prior(tfpd.Beta(concentration1=alpha, concentration0=beta), name='Ne_det'))\n",
+    "\n",
+    "        return Nph_det, Nph_det_dpe, Ne_det, total_rate\n",
+    "\n",
+    "    def log_likelihood(self, Nph_det, Nph_det_dpe, Ne_det, total_rate):\n",
+    "        count = self.data_S1.shape[0]\n",
+    "        log_prob_count = tfpd.Poisson(total_rate).log_prob(count).sum()\n",
+    "        log_prob_S1 = tfpd.Normal(jnp.abs(Nph_det + Nph_det_dpe),\n",
+    "                                  jnp.sqrt(Nph_det + Nph_det_dpe) * self.PMT_sigma).log_prob(self.data_S1).sum()\n",
+    "\n",
+    "        log_prob_S2 = tfpd.Normal(jnp.abs(Ne_det) * self.SE_gain, jnp.sqrt(Ne_det) * self.S2_sigma).log_prob(\n",
+    "            self.data_S2).sum()\n",
+    "\n",
+    "        return log_prob_count + log_prob_S1 + log_prob_S2\n",
+    "\n",
+    "    def build_model(self) -> Model:\n",
+    "        return Model(prior_model=self.prior_model, log_likelihood=self.log_likelihood)\n",
+    "\n",
+    "\n",
+    "model = XenonModel(\n",
+    "    data_S1=jnp.array([1., 2., 3.]),\n",
+    "    data_S2=jnp.array([1., 2., 3.]),\n",
+    "    e_survival_prob=jnp.asarray(0.5),\n",
+    "    relative_LCE=jnp.asarray(1.),\n",
+    "    density=jnp.asarray(2.8)\n",
+    ").build_model()\n",
+    "\n",
+    "model.sanity_check(jax.random.PRNGKey(42), S=1000)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "89931398d241ad2b",
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/examples/dual_moon.ipynb b/docs/examples/dual_moon.ipynb
index 953634f2..298d8a36 100644
--- a/docs/examples/dual_moon.ipynb
+++ b/docs/examples/dual_moon.ipynb
@@ -37,7 +37,7 @@
     "import os\n",
     "\n",
     "os.environ[\"XLA_FLAGS\"] = \"--xla_force_host_platform_device_count=6\"\n",
-    "from jax.config import config\n",
+    "from jax import config\n",
     "\n",
     "config.update(\"jax_enable_x64\", True)\n",
     "\n",
diff --git a/docs/examples/egg_box.ipynb b/docs/examples/egg_box.ipynb
index 75aa827d..7fe8ec41 100644
--- a/docs/examples/egg_box.ipynb
+++ b/docs/examples/egg_box.ipynb
@@ -51,7 +51,7 @@
     "from jax import random, numpy as jnp\n",
     "from jax import vmap\n",
     "\n",
-    "from jax.config import config\n",
+    "from jax import config\n",
     "\n",
     "# Needed because otherwise likelihoods hit numerical plateau\n",
     "config.update(\"jax_enable_x64\", True)\n",
diff --git a/docs/examples/evidence_maximisation.ipynb b/docs/examples/evidence_maximisation.ipynb
index 88afcdb0..6bd5b3f5 100644
--- a/docs/examples/evidence_maximisation.ipynb
+++ b/docs/examples/evidence_maximisation.ipynb
@@ -46,8 +46,8 @@
      "shell.execute_reply": "2023-12-21T11:21:40.041552Z"
     },
     "ExecuteTime": {
-     "end_time": "2024-01-31T15:53:57.797252416Z",
-     "start_time": "2024-01-31T15:53:56.437361568Z"
+     "end_time": "2024-07-01T22:43:14.510542015Z",
+     "start_time": "2024-07-01T22:43:13.004191375Z"
     }
    },
    "outputs": [
@@ -55,19 +55,18 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/tmp/ipykernel_17589/1886966611.py:2: DeprecationWarning: Accessing jax.config via the jax.config submodule is deprecated.\n",
-      "  from jax.config import config\n",
-      "INFO[2024-01-31 21:23:57,648]: Unable to initialize backend 'cuda': \n",
-      "INFO[2024-01-31 21:23:57,649]: Unable to initialize backend 'rocm': module 'jaxlib.xla_extension' has no attribute 'GpuAllocatorConfig'\n",
-      "INFO[2024-01-31 21:23:57,650]: Unable to initialize backend 'tpu': INTERNAL: Failed to open libtpu.so: libtpu.so: cannot open shared object file: No such file or directory\n",
-      "WARNING[2024-01-31 21:23:57,650]: An NVIDIA GPU may be present on this machine, but a CUDA-enabled jaxlib is not installed. Falling back to cpu.\n"
+      "INFO:jax._src.xla_bridge:Unable to initialize backend 'cuda': \n",
+      "INFO:jax._src.xla_bridge:Unable to initialize backend 'rocm': module 'jaxlib.xla_extension' has no attribute 'GpuAllocatorConfig'\n",
+      "INFO:jax._src.xla_bridge:Unable to initialize backend 'tpu': INTERNAL: Failed to open libtpu.so: libtpu.so: cannot open shared object file: No such file or directory\n",
+      "WARNING:jax._src.xla_bridge:An NVIDIA GPU may be present on this machine, but a CUDA-enabled jaxlib is not installed. Falling back to cpu.\n"
      ]
     }
    ],
    "source": [
+    "%matplotlib inline\n",
     "\n",
     "# for Gaussian processes 64bit is important\n",
-    "from jax.config import config\n",
+    "from jax import config\n",
     "\n",
     "config.update(\"jax_enable_x64\", True)\n",
     "\n",
@@ -113,8 +112,8 @@
      "shell.execute_reply": "2023-12-21T11:21:41.218410Z"
     },
     "ExecuteTime": {
-     "end_time": "2024-01-31T15:53:58.935985172Z",
-     "start_time": "2024-01-31T15:53:57.811745664Z"
+     "end_time": "2024-07-01T22:43:15.689216157Z",
+     "start_time": "2024-07-01T22:43:14.524967909Z"
     }
    },
    "outputs": [
@@ -179,8 +178,8 @@
      "shell.execute_reply": "2023-12-21T11:21:42.817018Z"
     },
     "ExecuteTime": {
-     "end_time": "2024-01-31T15:54:00.468393048Z",
-     "start_time": "2024-01-31T15:53:58.941106604Z"
+     "end_time": "2024-07-01T22:43:18.784665305Z",
+     "start_time": "2024-07-01T22:43:15.690734345Z"
     }
    },
    "outputs": [
@@ -188,12 +187,14 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "INFO[2024-01-31 21:24:00,070]: Sanity check...\n",
-      "INFO[2024-01-31 21:24:00,459]: Sanity check passed\n"
+      "INFO:jaxns:Sanity check...\n",
+      "INFO:jaxns:Sanity check passed\n"
      ]
     }
    ],
    "source": [
+    "\n",
+    "from jaxns.framework.special_priors import ExplicitDensityPrior\n",
     "\n",
     "kernel = tfpk.ExponentiatedQuadratic\n",
     "\n",
@@ -228,11 +229,26 @@
     "\n",
     "\n",
     "def prior_model():\n",
-    "    # Throw in a heirarchical prior for the length scale upper bound to show that we can do that.\n",
-    "    upper_l = yield Prior(tfpd.Uniform(0., 1.), name='upper_l')\n",
-    "    l = yield Prior(tfpd.Uniform(0., upper_l), name='l').parametrised()\n",
-    "    uncert = yield Prior(tfpd.Uniform(0., 2.), name='uncert')\n",
-    "    sigma = yield Prior(tfpd.Uniform(0., 2.), name='sigma')\n",
+    "    # l, sigma\n",
+    "    resolution = 100\n",
+    "    hyperparams_density = yield Prior(\n",
+    "        tfpd.Uniform(jnp.zeros([resolution] * 2),\n",
+    "                     jnp.ones([resolution] * 2)),\n",
+    "        name='hyper_params_density'\n",
+    "    ).parametrised()\n",
+    "    axes = (\n",
+    "        jnp.linspace(0., 1., resolution),\n",
+    "        jnp.linspace(0., 2., resolution),\n",
+    "    )\n",
+    "    hyper_parameters = yield ExplicitDensityPrior(\n",
+    "        axes=axes,\n",
+    "        density=hyperparams_density,\n",
+    "        regular_grid=True\n",
+    "    )\n",
+    "    l, sigma = hyper_parameters\n",
+    "    l = yield Prior(l, name='l')\n",
+    "    sigma = yield Prior(sigma, name='sigma')\n",
+    "    uncert = yield Prior(tfpd.Uniform(0., 1.), name='uncert')\n",
     "    return uncert, l, sigma\n",
     "\n",
     "\n",
@@ -252,8 +268,8 @@
     },
     "scrolled": false,
     "ExecuteTime": {
-     "end_time": "2024-01-31T15:54:22.418751460Z",
-     "start_time": "2024-01-31T15:54:00.466155111Z"
+     "end_time": "2024-07-01T22:51:21.444324079Z",
+     "start_time": "2024-07-01T22:43:18.805064619Z"
     }
    },
    "outputs": [
@@ -261,7 +277,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Convergence achieved at step 1.:  10%|█         | 1/10 [00:13<02:01, 13.50s/it]                                                                                                                      \n"
+      "Running M-step (1170 samples padded to 2048)... Step 99: log Z = -69.7307 +- 0.1916: : : Epoch 0: log_Z=-69.73068241271774, l_oo={'~': {'hyper_params_density_param': 0.0}}: 100%|██████████| 100/100 [07:53<00:00,  4.74s/it]\n"
      ]
     },
     {
@@ -272,27 +288,24 @@
       "Termination Conditions:\n",
       "Small remaining evidence\n",
       "--------\n",
-      "likelihood evals: 51196\n",
+      "likelihood evals: 46763\n",
       "samples: 1170\n",
       "phantom samples: 0\n",
-      "likelihood evals / sample: 43.8\n",
+      "likelihood evals / sample: 40.0\n",
       "phantom fraction (%): 0.0%\n",
       "--------\n",
-      "logZ=-69.84 +- 0.2\n",
-      "H=-3.49\n",
-      "ESS=199\n",
+      "logZ=-69.73 +- 0.19\n",
+      "H=-3.25\n",
+      "ESS=203\n",
       "--------\n",
       "l: mean +- std.dev. | 10%ile / 50%ile / 90%ile | MAP est. | max(L) est.\n",
-      "l: 0.213 +- 0.049 | 0.16 / 0.211 / 0.284 | 0.178 | 0.184\n",
+      "l: 0.209 +- 0.04 | 0.157 / 0.206 / 0.26 | 0.185 | 0.185\n",
       "--------\n",
       "sigma: mean +- std.dev. | 10%ile / 50%ile / 90%ile | MAP est. | max(L) est.\n",
-      "sigma: 1.33 +- 0.27 | 1.02 / 1.34 / 1.7 | 1.18 | 1.18\n",
+      "sigma: 1.33 +- 0.28 | 0.97 / 1.29 / 1.69 | 1.19 | 1.19\n",
       "--------\n",
       "uncert: mean +- std.dev. | 10%ile / 50%ile / 90%ile | MAP est. | max(L) est.\n",
-      "uncert: 0.63 +- 0.096 | 0.518 / 0.629 / 0.755 | 0.567 | 0.57\n",
-      "--------\n",
-      "upper_l: mean +- std.dev. | 10%ile / 50%ile / 90%ile | MAP est. | max(L) est.\n",
-      "upper_l: 0.378 +- 0.088 | 0.283 / 0.374 / 0.504 | 0.316 | 0.327\n",
+      "uncert: 0.622 +- 0.092 | 0.51 / 0.62 / 0.752 | 0.574 | 0.574\n",
       "--------\n"
      ]
     },
@@ -300,22 +313,24 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/home/albert/git/jaxns/jaxns/plotting.py:47: RuntimeWarning: divide by zero encountered in divide\n",
-      "  efficiency = 1. / num_likelihood_evaluations_per_sample\n"
+      "/home/albert/git/jaxns/jaxns/plotting.py:47: UserWarning: Found samples with zero likelihood evaluations.\n",
+      "  warnings.warn(\"Found samples with zero likelihood evaluations.\")\n",
+      "/home/albert/git/jaxns/jaxns/plotting.py:51: RuntimeWarning: divide by zero encountered in divide\n",
+      "  1. / num_likelihood_evaluations_per_sample\n"
      ]
     },
     {
      "data": {
       "text/plain": "<Figure size 800x1200 with 5 Axes>",
-      "image/png": "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"
+      "image/png": "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"
      },
      "metadata": {},
      "output_type": "display_data"
     },
     {
      "data": {
-      "text/plain": "<Figure size 800x800 with 10 Axes>",
-      "image/png": "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"
+      "text/plain": "<Figure size 600x600 with 6 Axes>",
+      "image/png": "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"
      },
      "metadata": {},
      "output_type": "display_data"
@@ -326,26 +341,109 @@
     "\n",
     "results, params = EvidenceMaximisation(\n",
     "    model=model,\n",
-    "    ns_kwargs=dict(max_samples=1e6)\n",
-    ").train(10)\n",
-    "\n",
-    "summary(results, with_parametrised=True)\n",
+    "    ns_kwargs=dict(max_samples=1e6),\n",
+    "    verbose=False,\n",
+    "    gtol=1e-3,\n",
+    "    log_Z_ftol=0.001,\n",
+    "    batch_size=None\n",
+    ").train(100)\n",
+    "\n",
+    "summary(results, with_parametrised=False)\n",
     "plot_diagnostics(results)\n",
-    "plot_cornerplot(results, with_parametrised=True)"
+    "plot_cornerplot(results, with_parametrised=False)"
    ]
   },
   {
    "cell_type": "code",
    "outputs": [],
-   "source": [],
+   "source": [
+    "param_transformed = model(params).transform_parametrised(U=results.U_samples[0])"
+   ],
    "metadata": {
     "collapsed": false,
     "ExecuteTime": {
-     "end_time": "2024-01-31T15:54:22.427987735Z",
-     "start_time": "2024-01-31T15:54:22.420527142Z"
+     "end_time": "2024-07-01T22:59:07.180554810Z",
+     "start_time": "2024-07-01T22:59:07.126455731Z"
     }
    },
-   "execution_count": 4
+   "execution_count": 13
+  },
+  {
+   "cell_type": "code",
+   "outputs": [],
+   "source": [
+    "prior_density = param_transformed['hyper_params_density']"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-07-01T22:59:07.573951379Z",
+     "start_time": "2024-07-01T22:59:07.566341098Z"
+    }
+   },
+   "execution_count": 14
+  },
+  {
+   "cell_type": "code",
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 640x480 with 2 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import pylab as plt\n",
+    "\n",
+    "plt.imshow(prior_density, extent=(0, 2, 0, 1), origin='lower', aspect='auto', cmap='bone',\n",
+    "           interpolation='nearest')\n",
+    "plt.colorbar()\n",
+    "plt.xlabel('sigma')\n",
+    "plt.ylabel('l')\n",
+    "plt.show()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-07-01T22:59:08.151653551Z",
+     "start_time": "2024-07-01T22:59:07.974621908Z"
+    }
+   },
+   "execution_count": 15
+  },
+  {
+   "cell_type": "code",
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 640x480 with 1 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot surface plot of prior_density\n",
+    "# How to\n",
+    "\n",
+    "fig = plt.figure()\n",
+    "ax = fig.add_subplot(111, projection='3d')\n",
+    "X_, Y_ = jnp.meshgrid(jnp.linspace(0, 2, prior_density.shape[0]), jnp.linspace(0, 1, prior_density.shape[1]))\n",
+    "ax.plot_surface(X_, Y_, prior_density, cmap='bone')\n",
+    "plt.show()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-07-01T22:59:09.036410052Z",
+     "start_time": "2024-07-01T22:59:08.500923766Z"
+    }
+   },
+   "execution_count": 16
   },
   {
    "cell_type": "code",
@@ -354,11 +452,19 @@
    "metadata": {
     "collapsed": false,
     "ExecuteTime": {
-     "end_time": "2024-01-31T15:54:22.428256579Z",
-     "start_time": "2024-01-31T15:54:22.422911519Z"
+     "end_time": "2024-07-01T22:59:09.099552424Z",
+     "start_time": "2024-07-01T22:59:09.039842540Z"
     }
    },
-   "execution_count": 4
+   "execution_count": 16
+  },
+  {
+   "cell_type": "code",
+   "outputs": [],
+   "source": [],
+   "metadata": {
+    "collapsed": false
+   }
   }
  ],
  "metadata": {
diff --git a/docs/examples/gaussian_process_marginalisation.ipynb b/docs/examples/gaussian_process_marginalisation.ipynb
index c6c6ebea..3be0d644 100644
--- a/docs/examples/gaussian_process_marginalisation.ipynb
+++ b/docs/examples/gaussian_process_marginalisation.ipynb
@@ -93,7 +93,7 @@
    ],
    "source": [
     "# for Gaussian processes this is important\n",
-    "from jax.config import config\n",
+    "from jax import config\n",
     "\n",
     "config.update(\"jax_enable_x64\", True)\n",
     "\n",
diff --git a/docs/examples/gaussian_process_marginalisation_spectral.ipynb b/docs/examples/gaussian_process_marginalisation_spectral.ipynb
index e08f4685..6f89b568 100644
--- a/docs/examples/gaussian_process_marginalisation_spectral.ipynb
+++ b/docs/examples/gaussian_process_marginalisation_spectral.ipynb
@@ -93,7 +93,7 @@
    ],
    "source": [
     "# For Gaussian processes 64bit is important\n",
-    "from jax.config import config\n",
+    "from jax import config\n",
     "\n",
     "config.update(\"jax_enable_x64\", True)\n",
     "\n",
diff --git a/docs/examples/gaussian_shells.ipynb b/docs/examples/gaussian_shells.ipynb
index 5ef455d7..4258214b 100644
--- a/docs/examples/gaussian_shells.ipynb
+++ b/docs/examples/gaussian_shells.ipynb
@@ -45,7 +45,7 @@
     }
    ],
    "source": [
-    "from jax.config import config\n",
+    "from jax import config\n",
     "\n",
     "config.update(\"jax_enable_x64\", True)\n",
     "\n",
diff --git a/docs/examples/placebo_effect.ipynb b/docs/examples/placebo_effect.ipynb
index a427efed..f3fd4aea 100644
--- a/docs/examples/placebo_effect.ipynb
+++ b/docs/examples/placebo_effect.ipynb
@@ -23,7 +23,7 @@
      "output_type": "stream",
      "text": [
       "/tmp/ipykernel_24225/661831631.py:6: DeprecationWarning: Accessing jax.config via the jax.config submodule is deprecated.\n",
-      "  from jax.config import config\n",
+      "  from jax import config\n",
       "INFO[2024-01-31 23:12:36,070]: Unable to initialize backend 'cuda': \n",
       "INFO[2024-01-31 23:12:36,070]: Unable to initialize backend 'rocm': module 'jaxlib.xla_extension' has no attribute 'GpuAllocatorConfig'\n",
       "INFO[2024-01-31 23:12:36,072]: Unable to initialize backend 'tpu': INTERNAL: Failed to open libtpu.so: libtpu.so: cannot open shared object file: No such file or directory\n",
@@ -38,7 +38,7 @@
     "import jax.random\n",
     "\n",
     "os.environ[\"XLA_FLAGS\"] = \"--xla_force_host_platform_device_count=6\"\n",
-    "from jax.config import config\n",
+    "from jax import config\n",
     "\n",
     "config.update(\"jax_enable_x64\", True)\n",
     "import numpy as np\n",
@@ -92,7 +92,7 @@
     "\n",
     "\n",
     "class Params(NamedTuple):\n",
-    "    mean_hunger: jnp.ndarray  # mean hunger(t)\n",
+    "    mean_hunger: jax.Array  # mean hunger(t)\n",
     "\n",
     "\n",
     "def prior_model():\n",
diff --git a/docs/papers/phantom-powered-nested-sampling/run_ablation.py b/docs/papers/phantom-powered-nested-sampling/run_ablation.py
index f1cea4ba..49feb212 100644
--- a/docs/papers/phantom-powered-nested-sampling/run_ablation.py
+++ b/docs/papers/phantom-powered-nested-sampling/run_ablation.py
@@ -6,7 +6,7 @@
 
 
 def run(ndims, ensemble_size, input_queue: Queue, output_queue: Queue):
-    # from jax.config import config
+    # from jax import config
     # config.update("jax_enable_x64", True)
 
     from jaxns import Prior, Model
diff --git a/docs/papers/phantom-powered-nested-sampling/run_experiment.py b/docs/papers/phantom-powered-nested-sampling/run_experiment.py
index 466cf5bb..eeb8455d 100644
--- a/docs/papers/phantom-powered-nested-sampling/run_experiment.py
+++ b/docs/papers/phantom-powered-nested-sampling/run_experiment.py
@@ -6,7 +6,7 @@
 
 
 def run(ndims, ensemble_size, input_queue: Queue, output_queue: Queue):
-    # from jax.config import config
+    # from jax import config
     # config.update("jax_enable_x64", True)
 
     from jaxns import Prior, Model
diff --git a/jaxns/experimental/evidence_maximisation.py b/jaxns/experimental/evidence_maximisation.py
index 299ed811..a566834a 100644
--- a/jaxns/experimental/evidence_maximisation.py
+++ b/jaxns/experimental/evidence_maximisation.py
@@ -9,7 +9,7 @@
 import tensorflow_probability.substrates.jax as tfp
 from jax import numpy as jnp, random
 from jax._src.scipy.special import logsumexp
-from jaxopt import NonlinearCG, ArmijoSGD
+from jaxopt import ArmijoSGD, BFGS
 from tqdm import tqdm
 
 from jaxns.internals.cumulative_ops import cumulative_op_static
@@ -41,11 +41,11 @@
 
 
 class MStepData(NamedTuple):
-    U_samples: jnp.ndarray
-    log_weights: jnp.ndarray
-    # log_dp_mean: jnp.ndarray
-    # log_L_samples: jnp.ndarray
-    # log_Z_mean: jnp.ndarray
+    U_samples: jax.Array
+    log_weights: jax.Array
+    # log_dp_mean: jax.Array
+    # log_L_samples: jax.Array
+    # log_Z_mean: jax.Array
 
 
 def next_power_2(x: int) -> int:
@@ -95,6 +95,7 @@ def __post_init__(self):
         if 'max_samples' not in self.ns_kwargs:
             raise ValueError("ns_kwargs must contain 'max_samples'.")
         self._e_step = self._create_e_step()
+        # self._m_step = self._create_m_step()
         self._m_step = self._create_m_step_stochastic()
 
     def _create_e_step(self):
@@ -146,11 +147,15 @@ def e_step(self, key: PRNGKey, params: hk.MutableParams, p_bar: tqdm) -> NestedS
     def _m_step_iterator(self, key: PRNGKey, data: MStepData):
         num_samples = int(data.U_samples.shape[0])
         permutation = jax.random.permutation(key, num_samples)
-        num_batches = num_samples // self.batch_size
+        if self.batch_size is None:
+            batch_size = num_samples
+        else:
+            batch_size = self.batch_size
+        num_batches = num_samples // batch_size
         if num_batches == 0:
             raise RuntimeError("Batch size is too large for number of samples.")
         for i in range(num_batches):
-            perm = permutation[i * self.batch_size:(i + 1) * self.batch_size]
+            perm = permutation[i * batch_size:(i + 1) * batch_size]
             batch = MStepData(
                 U_samples=data.U_samples[perm],
                 log_weights=data.log_weights[perm]
@@ -253,16 +258,16 @@ def loss(params: hk.MutableParams, data: MStepData):
                 jax.debug.print("log_Z={log_Z}", log_Z=log_Z)
             return (obj, aux), grad
 
-        solver = NonlinearCG(
+        solver = BFGS(
             fun=loss,
             has_aux=True,
             value_and_grad=True,
             jit=True,
             unroll=False,
-            verbose=self.verbose
+            verbose=False
         )
 
-        @partial(jax.jit, static_argnums=(0,))
+        @partial(jax.jit)
         def _m_step(key: PRNGKey, params: hk.MutableParams, data: MStepData) -> Tuple[hk.MutableParams, Any]:
             """
             The M-step is just evidence maximisation.
@@ -316,7 +321,7 @@ def _pad_to_n(x, fill_value, dtype):
         log_Z = None
         while epoch < self.max_num_epochs:
             params, (log_Z,) = self._m_step(key=key, params=params, data=data)
-            l_oo = jax.tree.map(lambda x, y: jnp.max(jnp.abs(x - y)) if np.size(x) > 0 else 0.,
+            l_oo = jax.tree.map(lambda x, y: float(jnp.max(jnp.abs(x - y))) if np.size(x) > 0 else 0.,
                                 last_params, params)
             last_params = params
             p_bar.set_description(f"{desc}: Epoch {epoch}: log_Z={log_Z}, l_oo={l_oo}")
@@ -349,7 +354,7 @@ def train(self, num_steps: int = 10, params: Optional[hk.MutableParams] = None)
 
         ns_results = None
         for step in p_bar:
-            key_e_stek, key_m_step = random.split(random.PRNGKey(step), 2)
+            key_e_step, key_m_step = random.split(random.PRNGKey(step), 2)
 
             # Execute the e_step
             if ns_results is None:
@@ -358,13 +363,25 @@ def train(self, num_steps: int = 10, params: Optional[hk.MutableParams] = None)
                 p_bar.set_description(
                     f"Step {step}: log Z = {ns_results.log_Z_mean:.4f} +- {ns_results.log_Z_uncert:.4f}"
                 )
-            ns_results = self.e_step(key=key_e_stek, params=params, p_bar=p_bar)
+            ns_results = self.e_step(key=key_e_step, params=params, p_bar=p_bar)
             # Update progress bar description
 
             # Check termination condition
             log_Z_change = jnp.abs(ns_results.log_Z_mean - log_Z)
-            if log_Z_change < max(float(self.log_Z_ftol * ns_results.log_Z_uncert), self.log_Z_atol):
-                p_bar.set_description(f"Convergence achieved at step {step}.")
+
+            if log_Z_change < self.log_Z_atol:
+                p_bar.set_description(
+                    f"Convergence achieved at step {step}, "
+                    f"due to delta log_Z {log_Z_change} < log_Z_atol {self.log_Z_atol}."
+                )
+                break
+
+            relative_atol = float(self.log_Z_ftol * ns_results.log_Z_uncert)
+            if log_Z_change < relative_atol:
+                p_bar.set_description(
+                    f"Convergence achieved at step {step}, "
+                    f"due to log_Z {log_Z_change} < log_Z_ftol * log_Z_uncert {relative_atol}."
+                )
                 break
 
             # Update log_Z and log_Z_uncert values
diff --git a/jaxns/experimental/global_optimisation.py b/jaxns/experimental/global_optimisation.py
index acef4d11..ac814e06 100644
--- a/jaxns/experimental/global_optimisation.py
+++ b/jaxns/experimental/global_optimisation.py
@@ -11,6 +11,7 @@
 from jaxopt import NonlinearCG
 
 from jaxns.framework.bases import BaseAbstractModel
+from jaxns.internals.constraint_bijections import quick_unit, quick_unit_inverse
 from jaxns.internals.logging import logger
 from jaxns.internals.maps import remove_chunk_dim
 from jaxns.internals.types import PRNGKey, StaticStandardNestedSamplerState, BoolArray, StaticStandardSampleCollection, \
@@ -170,7 +171,7 @@ def _set_done_bit(bit_done, bit_reason, done, termination_reason):
 
 def gradient_based_optimisation(model: BaseAbstractModel, init_U_point: UType) -> Tuple[UType, FloatArray, IntArray]:
     def loss(U_unconstrained: UType):
-        U = jax.nn.sigmoid(U_unconstrained)
+        U = quick_unit(U_unconstrained)
         return -model.log_prob_likelihood(U, allow_nan=False)
 
     solver = NonlinearCG(
@@ -180,8 +181,8 @@ def loss(U_unconstrained: UType):
         verbose=False
     )
 
-    results = solver.run(init_params=logit(init_U_point))
-    return jax.nn.sigmoid(results.params), -results.state.value, results.state.num_fun_eval
+    results = solver.run(init_params=quick_unit_inverse(init_U_point))
+    return quick_unit(results.params), -results.state.value, results.state.num_fun_eval
 
 
 def _single_thread_global_optimisation(init_state: GlobalOptimisationState,
diff --git a/jaxns/framework/prior.py b/jaxns/framework/prior.py
index 0e808da5..b66e27e4 100644
--- a/jaxns/framework/prior.py
+++ b/jaxns/framework/prior.py
@@ -8,6 +8,7 @@
 
 from jaxns.framework.bases import BaseAbstractPrior, BaseAbstractDistribution
 from jaxns.framework.wrapped_tfp_distribution import WrappedTFPDistribution
+from jaxns.internals.constraint_bijections import quick_unit
 from jaxns.internals.types import FloatArray, IntArray, BoolArray, XType, UType, float_type
 
 tfpd = tfp.distributions
@@ -33,7 +34,7 @@ class SingularPrior(BaseAbstractPrior):
         (at the singular value).
     """
 
-    def __init__(self, value: jnp.ndarray, base_prior: BaseAbstractPrior, name: Optional[str] = None):
+    def __init__(self, value: jax.Array, base_prior: BaseAbstractPrior, name: Optional[str] = None):
         super().__init__(name=name)
         self.value = value
         self.base_prior = base_prior
@@ -88,7 +89,7 @@ def dist(self) -> BaseAbstractDistribution:
         return self._dist
 
     @property
-    def value(self) -> jnp.ndarray:
+    def value(self) -> jax.Array:
         if self._type != 'value':
             raise ValueError(f"Wrong type, got {self._type}")
         return self._value
@@ -191,8 +192,6 @@ def prior_to_parametrised_singular(prior: BaseAbstractPrior, random_init: bool =
         init=hk.initializers.Constant(init_value)
     )
     # transform [-inf, inf] -> [0,1]
-    # Sigmoid is faster than ndtr to save FLOPs
-    # U_base_param = ndtr(norm_U_base_param)
-    U_base_param = jax.nn.sigmoid(norm_U_base_param)
+    U_base_param = quick_unit(norm_U_base_param)
     param = prior.forward(U_base_param)
     return SingularPrior(value=param, base_prior=prior, name=prior.name)
diff --git a/jaxns/framework/special_priors.py b/jaxns/framework/special_priors.py
index 91b632ea..fe7d0938 100644
--- a/jaxns/framework/special_priors.py
+++ b/jaxns/framework/special_priors.py
@@ -9,6 +9,7 @@
 
 from jaxns.framework.bases import BaseAbstractPrior
 from jaxns.framework.prior import SingularPrior, prior_to_parametrised_singular
+from jaxns.internals.interp_utils import InterpolatedArray
 from jaxns.internals.log_semiring import cumulative_logsumexp
 from jaxns.internals.types import FloatArray, IntArray, BoolArray, float_type, int_type, UType, RandomVariableType, \
     MeasureType
@@ -540,3 +541,117 @@ def _shape(self) -> Tuple[int, ...]:
 
     def _dtype(self) -> jnp.dtype:
         return self.prior._dtype()
+
+
+class ExplicitDensityPrior(SpecialPrior):
+    def __init__(self, *, axes: Tuple[jax.Array, ...], density: jax.Array, regular_grid: bool = False,
+                 name: Optional[str] = None):
+        super(ExplicitDensityPrior, self).__init__(name=name)
+        self._num_dims = num_dims = len(np.shape(density))
+        for i in range(num_dims):
+            if len(np.shape(axes[i])) != 1:
+                raise ValueError(f"Each axis must be 1D, got {np.shape(axes[i])}")
+            if np.shape(density)[i] < 2:
+                raise ValueError(f"Each dimension of density must have at least 2 elements, got {np.shape(density)}")
+            if np.shape(density)[i] != np.size(axes[i]):
+                raise ValueError(
+                    f"Each dimension of density must have the same number of elements as the corresponding axis, "
+                    f"got {np.shape(density)} and {np.shape(axes[i])}"
+                )
+
+        norm = density
+        for i in range(num_dims)[::-1]:
+            axis = axes[i]
+            d = axis[1:] - axis[:-1]
+            norm = 0.5 * jnp.sum((norm[..., :-1] + norm[..., 1:]) * d, axis=-1)
+
+        self._density = density / norm
+        self._axes = axes
+        self._regular_grid = regular_grid
+
+    def _dtype(self):
+        return self._density.dtype
+
+    def _base_shape(self) -> Tuple[int, ...]:
+        return (self._num_dims,)
+
+    def _shape(self) -> Tuple[int, ...]:
+        return (self._num_dims,)
+
+    def _forward(self, U) -> Union[FloatArray, IntArray, BoolArray]:
+        return self._quantile(U)
+
+    def _inverse(self, X) -> FloatArray:
+        return self._cdf(X)
+
+    def _cdf(self, X) -> FloatArray:
+        U = []
+        for i in range(self._num_dims):
+            # Marginalise the last dims
+            density = self._density
+            for j in range(i + 1, self._num_dims)[::-1]:
+                axis = self._axes[j]
+                d = axis[1:] - axis[:-1]
+                density = 0.5 * jnp.sum((density[..., :-1] + density[..., 1:]) * d, axis=-1)
+
+            # Now we have P(X_0, ..., X_i), interpolate to get norm * P(X_i | X_0, ...)
+
+            for j in range(i):
+                P = InterpolatedArray(
+                    x=self._axes[j],
+                    values=density,
+                    axis=0,
+                    regular_grid=self._regular_grid
+                )
+                density = P(X[j])  # P(X_1, ..., X_i)   [N1, ..., Ni]
+            # Now we have P(X_i | X_0, ...), and we compute percentiles
+            d = self._axes[i][1:] - self._axes[i][:-1]
+            norm = 0.5 * jnp.sum((density[1:] + density[:-1]) * d)
+            density /= norm
+            percentiles = jnp.concatenate([jnp.asarray([0.]), jnp.cumsum(0.5 * (density[1:] + density[:-1]) * d)])
+            u_i = jnp.interp(X[i], self._axes[i], percentiles)
+            U.append(u_i)
+        return jnp.stack(U, axis=-1)
+
+    def _log_prob(self, X) -> FloatArray:
+        density = self._density
+        for i in range(self._num_dims):
+            P = InterpolatedArray(
+                x=self._axes[i],
+                values=density,
+                axis=0,
+                regular_grid=self._regular_grid
+            )
+            density = P(X[i])
+        return jnp.log(density)
+
+    def _quantile(self, U):
+        # Sequentially sample from: P(X_0), P(X_1 | X_0), P(X_2 | X_0, X_1), ...
+        # P(A| B) = P(A, B) / sum_A P(B, A)
+        X = []
+        for i in range(self._num_dims):
+            # Marginalise the last dims
+            density = self._density
+            for j in range(i + 1, self._num_dims)[::-1]:
+                axis = self._axes[j]
+                d = axis[1:] - axis[:-1]
+                density = 0.5 * jnp.sum((density[..., :-1] + density[..., 1:]) * d, axis=-1)
+
+            # Now we have P(X_0, ..., X_i), interpolate to get norm * P(X_i | X_0, ...)
+
+            for j in range(i):
+                P = InterpolatedArray(
+                    x=self._axes[j],
+                    values=density,
+                    axis=0,
+                    regular_grid=self._regular_grid
+                )
+                density = P(X[j])  # P(X_1, ..., X_i)   [N1, ..., Ni]
+            # Now we have P(X_i | X_0, ...), and we compute percentiles
+            d = self._axes[i][1:] - self._axes[i][:-1]
+            norm = 0.5 * jnp.sum((density[1:] + density[:-1]) * d)
+            density /= norm
+            percentiles = jnp.concatenate([jnp.asarray([0.]), jnp.cumsum(0.5 * (density[1:] + density[:-1]) * d)])
+            x_i = jnp.interp(U[i], percentiles, self._axes[i])
+            X.append(x_i)
+        return jnp.stack(X, axis=-1)
diff --git a/jaxns/internals/constraint_bijections.py b/jaxns/internals/constraint_bijections.py
new file mode 100644
index 00000000..cd98ba95
--- /dev/null
+++ b/jaxns/internals/constraint_bijections.py
@@ -0,0 +1,35 @@
+import jax
+import jax.numpy as jnp
+from jax import lax
+
+
+def quick_unit(x: jax.Array) -> jax.Array:
+    """
+    Quick approximation to the sigmoid.
+
+    Args:
+        x: jax.Array value in (-inf, inf) open interval
+
+    Returns:
+        value in (0, 1) in open interval
+    """
+    return 0.5 * (x / (1 + lax.abs(x)) + 1)
+
+
+def quick_unit_inverse(y: jax.Array) -> jax.Array:
+    """
+    Inverse of quick_unit.
+
+    Args:
+        y: jax.Array value in (0, 1) open interval
+
+    Returns:
+        value in (-inf, inf) in open interval
+    """
+    twoy = y + y
+
+    return jnp.where(
+        y >= 0.5,
+        (1 - twoy) / (twoy - 2),
+        1 - lax.reciprocal(twoy)
+    )
diff --git a/jaxns/internals/cumulative_ops.py b/jaxns/internals/cumulative_ops.py
index c202b09a..9615d7f7 100644
--- a/jaxns/internals/cumulative_ops.py
+++ b/jaxns/internals/cumulative_ops.py
@@ -2,8 +2,8 @@
 
 import jax
 from jax import lax, numpy as jnp, tree_util
-from tensorflow_probability.substrates.jax import math as tfp_math
 
+from jaxns.internals.prefix_sum import scan_associative
 from jaxns.internals.types import IntArray, int_type
 
 X = TypeVar('X')
@@ -31,7 +31,9 @@ def associative_op(a, b):
     full_input = jax.tree.map(lambda x, y: jnp.concatenate([x[None], y], axis=0), init, xs)
 
     # Apply the operation to accumulate results using scan_associative
-    scanned_results = tfp_math.scan_associative(associative_op, full_input)
+    scanned_results = scan_associative(
+        associative_op, full_input
+    )
 
     # The final accumulated value is the last element in the results
     final_accumulate = jax.tree.map(lambda x: x[-1], scanned_results)
diff --git a/jaxns/internals/interp_utils.py b/jaxns/internals/interp_utils.py
new file mode 100644
index 00000000..757ba347
--- /dev/null
+++ b/jaxns/internals/interp_utils.py
@@ -0,0 +1,137 @@
+import dataclasses
+from typing import Union, Tuple
+
+import jax
+import jax.numpy as jnp
+import numpy as np
+from jax import lax
+
+
+def apply_interp(x: jax.Array, i0: jax.Array, alpha0: jax.Array, i1: jax.Array, alpha1: jax, axis: int = 0):
+    """
+    Apply interpolation alpha given axis.
+
+    Args:
+        x: nd-array
+        i0: [N] or scalar
+        alpha0: [N] or scalar
+        i1: [N] or scalar
+        alpha1: [N] or scalar
+        axis: axis to take along
+
+    Returns:
+        [N] or scalar interpolated along axis
+    """
+
+    def take(i):
+        num_dims = len(np.shape(x))
+        # [0] [1] [2 3 4], num_dims=5, axis=1
+        slices = [slice(None)] * axis + [i] + [slice(None)] * (num_dims - axis - 1)
+        # return jnp.take(x, i, axis=axis)
+        return x[tuple(slices)]
+
+    return left_broadcast_multiply(take(i0), alpha0, axis=axis) + left_broadcast_multiply(
+        take(i1), alpha1, axis=axis)
+
+
+def left_broadcast_multiply(x, y, axis: int = 0):
+    """
+    Left broadcast multiply of two arrays.
+    Equivalent to right-padding before multiply
+
+    Args:
+        x: [..., a,b,c,...]
+        y: [a, b]
+
+    Returns:
+        [..., a, b, c, ...]
+    """
+    needed_length = len(np.shape(x)[axis:])
+    len_y = len(np.shape(y))
+    extra = needed_length - len_y
+    if extra < 0:
+        raise ValueError(f"Shape mismatch {np.shape(x)} x {np.shape(y)}.")
+    y = lax.reshape(y, np.shape(y) + (1,) * extra)
+    return x * y
+
+
+def get_interp_indices_and_weights(x, xp, regular_grid: bool = False) -> Tuple[
+    Tuple[Union[int, jax.Array, float, jax.Array]], Tuple[Union[int, jax.Array, float, jax.Array]]]:
+    """
+    One-dimensional linear interpolation. Outside bounds is also linear from nearest two points.
+
+    Args:
+        x: the x-coordinates at which to evaluate the interpolated values
+        xp: the x-coordinates of the data points, must be increasing
+
+    Returns:
+        the interpolated values, same shape as `x`
+    """
+
+    x = jnp.asarray(x, dtype=jnp.float_)
+    xp = jnp.asarray(xp, dtype=jnp.float_)
+    if len(np.shape(xp)) == 0:
+        xp = jnp.reshape(xp, (-1,))
+    if np.shape(xp)[0] == 0:
+        raise ValueError("xp must be non-empty")
+    if np.shape(xp)[0] == 1:
+        return (jnp.zeros_like(x, dtype=jnp.int32), jnp.ones_like(x)), (
+            jnp.zeros_like(x, dtype=jnp.int32), jnp.zeros_like(x))
+
+    # Find xp[i1-1] < x <= xp[i1]
+    if regular_grid:
+        # Use faster index determination
+        delta_x = xp[1] - xp[0]
+        i1 = jnp.clip((jnp.ceil((x - xp[0]) / delta_x)).astype(jnp.int64), 1, len(xp) - 1)
+        i0 = i1 - 1
+    else:
+        i1 = jnp.clip(jnp.searchsorted(xp, x, side='right'), 1, len(xp) - 1)
+        i0 = i1 - 1
+
+    dx = xp[i1] - xp[i0]
+    delta = x - xp[i0]
+
+    epsilon = np.spacing(np.finfo(xp.dtype).eps)
+    dx0 = jnp.abs(dx) <= epsilon  # Prevent NaN gradients when `dx` is small.
+    dx = jnp.where(dx0, 1, dx)
+    alpha = delta / dx
+    return (i0, (1. - alpha)), (i1, alpha)
+
+
+@dataclasses.dataclass(eq=False)
+class InterpolatedArray:
+    x: jax.Array  # [N]
+    values: jax.Array  # [..., N, ...] `axis` has N elements
+
+    axis: int = 0
+    regular_grid: bool = False
+
+    def __post_init__(self):
+
+        if len(np.shape(self.x)) != 1:
+            raise ValueError(f"Times must be 1D, got {np.shape(self.x)}.")
+
+        def _assert_shape(x):
+            if np.shape(x)[self.axis] != np.size(self.x):
+                raise ValueError(f"Input values must have time length on `axis` dimension, got {np.shape(x)}.")
+
+        jax.tree.map(_assert_shape, self.values)
+
+        self.x, self.values = jax.tree.map(jnp.asarray, (self.x, self.values))
+
+    @property
+    def shape(self):
+        return jax.tree.map(lambda x: np.shape(x)[:self.axis] + np.shape(x)[self.axis + 1:], self.values)
+
+    def __call__(self, time: jax.Array) -> jax.Array:
+        """
+        Interpolate at time based on input times.
+
+        Args:
+            time: time to evaluate at.
+
+        Returns:
+            value at given time
+        """
+        (i0, alpha0), (i1, alpha1) = get_interp_indices_and_weights(time, self.x, regular_grid=self.regular_grid)
+        return jax.tree.map(lambda x: apply_interp(x, i0, alpha0, i1, alpha1, axis=self.axis), self.values)
diff --git a/jaxns/internals/log_semiring.py b/jaxns/internals/log_semiring.py
index 5164bc09..7d18b4f0 100644
--- a/jaxns/internals/log_semiring.py
+++ b/jaxns/internals/log_semiring.py
@@ -1,5 +1,6 @@
 from typing import Union, Literal
 
+import jax
 from jax import numpy as jnp, lax
 from jax.scipy.special import logsumexp
 
@@ -91,7 +92,7 @@ def body(state, X):
 
 
 class LogSpace(object):
-    def __init__(self, log_abs_val: Union[jnp.ndarray, float], sign: Union[jnp.ndarray, float] = None):
+    def __init__(self, log_abs_val: Union[jax.Array, float], sign: Union[jax.Array, float] = None):
         self._log_abs_val = jnp.asarray(log_abs_val, float_type)
         if sign is None:
             self._sign = jnp.asarray(1., float_type)
@@ -316,7 +317,7 @@ def __pow__(self, n):
         Returns:
              LogSpace
         """
-        if not isinstance(n, (int, float, jnp.ndarray)):
+        if not isinstance(n, (int, float, jax.Array)):
             raise NotImplementedError("Not implemented for non-int powers.")
         n = jnp.asarray(n, float_type)
         if self._naked:
diff --git a/jaxns/internals/maps.py b/jaxns/internals/maps.py
index 38ccee9c..6890e8f9 100644
--- a/jaxns/internals/maps.py
+++ b/jaxns/internals/maps.py
@@ -1,6 +1,6 @@
 import inspect
 import warnings
-from typing import TypeVar, Callable, Optional
+from typing import TypeVar, Callable, Optional, Tuple, List
 
 import jax
 from jax import pmap, numpy as jnp, lax
@@ -268,3 +268,46 @@ def body(state, X):
     _f.__doc__ = f.__doc__
     _f.__annotations__ = f.__annotations__
     return _f
+
+
+PT = TypeVar('PT')
+
+
+def pytree_unravel(example_tree: PT) -> Tuple[Callable[[PT], jax.Array], Callable[[jax.Array], PT]]:
+    """
+    Returns functions to ravel and unravel a pytree.
+    """
+    leaf_list, tree_def = jax.tree.flatten(example_tree)
+
+    sizes = [leaf.size for leaf in leaf_list]
+    shapes = [leaf.shape for leaf in leaf_list]
+
+    def ravel_fun(pytree: PT) -> jax.Array:
+        leaf_list, tree_def = jax.tree.flatten(pytree)
+        return jnp.concatenate([lax.reshape(leaf, (size,)) for leaf, size in zip(leaf_list, sizes)])
+
+    def unravel_fun(flat_array: jax.Array) -> PT:
+        leaf_list = []
+        start = 0
+        for size, shape in zip(sizes, shapes):
+            leaf_list.append(lax.reshape(flat_array[start:start + size], shape))
+            start += size
+        return jax.tree.unflatten(tree_def, leaf_list)
+
+    return ravel_fun, unravel_fun
+
+
+def pytree_unpack(example_tree: PT) -> Tuple[Callable[[PT], List[jax.Array]], Callable[[List[jax.Array]], PT]]:
+    """
+    Returns functions to ravel and unravel a pytree.
+    """
+    leaf_list, tree_def = jax.tree.flatten(example_tree)
+
+    def pack_fun(pytree: PT) -> List[jax.Array]:
+        leaf_list, tree_def = jax.tree.flatten(pytree)
+        return leaf_list
+
+    def unpack_fun(leaf_list: List[jax.Array]) -> PT:
+        return jax.tree.unflatten(tree_def, leaf_list)
+
+    return pack_fun, unpack_fun
diff --git a/jaxns/internals/namedtuple_utils.py b/jaxns/internals/namedtuple_utils.py
index 0f0d2384..20c50332 100644
--- a/jaxns/internals/namedtuple_utils.py
+++ b/jaxns/internals/namedtuple_utils.py
@@ -1,5 +1,7 @@
 import importlib
 
+import jax
+import jax.numpy as jnp
 import numpy as np
 
 
@@ -35,6 +37,8 @@ def serialise_namedtuple(obj):
                 '__data__': {k: serialise_namedtuple(v) for k, v in obj._asdict().items()}}
     elif isinstance(obj, np.ndarray):
         return serialise_ndarray(obj)
+    elif isinstance(obj, jax.Array):
+        return serialise_jax_ndarray(obj)
     elif isinstance(obj, (list, tuple)):
         return [serialise_namedtuple(v) for v in obj]
     elif isinstance(obj, dict):
@@ -52,8 +56,12 @@ def deserialise_namedtuple(obj):
         return class_(**{k: deserialise_namedtuple(v) for k, v in obj['__data__'].items()})
     elif isinstance(obj, dict) and 'type' in obj and obj['type'] == '__ndarray__':
         return deserialise_ndarray(obj)
-    elif isinstance(obj, (list, tuple)):
+    elif isinstance(obj, dict) and 'type' in obj and obj['type'] == '__jax_ndarray__':
+        return deserialise_jax_ndarray(obj)
+    elif isinstance(obj, list):
         return [deserialise_namedtuple(v) for v in obj]
+    elif isinstance(obj, tuple):
+        return tuple(deserialise_namedtuple(v) for v in obj)
     elif isinstance(obj, dict):
         return {k: deserialise_namedtuple(v) for k, v in obj.items()}
     return obj
@@ -69,3 +77,15 @@ def deserialise_ndarray(obj):
     if isinstance(obj, dict) and obj.get('type') == '__ndarray__':
         return np.array(obj['__data__'], dtype=obj['__dtype__'])
     return obj
+
+
+def serialise_jax_ndarray(obj):
+    if isinstance(obj, jax.Array):
+        return {'type': '__jax_ndarray__', '__dtype__': str(obj.dtype), '__data__': np.asarray(obj).tolist()}
+    return obj
+
+
+def deserialise_jax_ndarray(obj):
+    if isinstance(obj, dict) and obj.get('type') == '__jax_ndarray__':
+        return jnp.array(np.array(obj['__data__'], dtype=obj['__dtype__']))
+    return obj
diff --git a/jaxns/internals/prefix_sum.py b/jaxns/internals/prefix_sum.py
new file mode 100644
index 00000000..e97ce8f3
--- /dev/null
+++ b/jaxns/internals/prefix_sum.py
@@ -0,0 +1,180 @@
+import functools
+from typing import TypeVar, Callable
+
+import jax
+import jax.numpy as jnp
+import numpy as np
+from jax import lax
+
+
+def _slice_along_axis(x, start=0, stop=None, step=1, axis=0):
+    """Slices a Tensor along the given axis."""
+
+    def _slice(x):
+        if axis >= 0:
+            slices = [slice(None)] * axis + [slice(start, stop, step)]
+        else:
+            slices = [Ellipsis, slice(start, stop, step)] + [slice(None)] * (-1 - axis)
+        return x[tuple(slices)]
+
+    return jax.tree.map(_slice, x)
+
+
+def _interleave(a, b, axis):
+    """Interleaves two `Tensor`s along the given axis."""
+
+    # [a b c ...] [d e f ...] -> [a d b e c f ...]
+
+    def _op(a, b):
+        if np.shape(a) != np.shape(b):
+            raise ValueError('`a` and `b` must have the same shape.')
+
+        stacked = jnp.stack([a, b], axis=axis + 1)
+
+        output_shape = np.shape(a)[:axis] + (2 * np.shape(a)[axis],) + np.shape(a)[axis + 1:]
+        return lax.reshape(stacked, output_shape)
+
+    return jax.tree.map(_op, a, b)
+
+
+X = TypeVar('X')
+
+
+def scan_associative(fn: Callable[[X, X], X], elems: X, axis: int = 0) -> X:
+    """
+    Perform a scan with an associative binary operation, in parallel.
+
+    Suitable for fn: (X, X) -> X where (f o f) o f == f o (f o f)
+
+    The associative scan operation computes the cumulative sum, or
+    [all-prefix sum](https://en.wikipedia.org/wiki/Prefix_sum), of a set of
+    elements under an associative binary operation [1]. For example, using the
+    ordinary addition operator `fn = lambda a, b: a + b`, this is equivalent to
+    the ordinary cumulative sum.
+
+    The associative structure allows the computation to be decomposed
+    and executed by parallel reduction. Where a naive sequential
+    implementation would loop over all `N` elements, this method requires
+    only a logarithmic number (`2 * ceil(log_2 N)`) of sequential steps, and
+    can thus yield substantial performance speedups from hardware-accelerated
+    vectorization. The total number of invocations of the binary operation
+    (including those performed in parallel) is
+    `2 * (N / 2 + N / 4 + ... + 1) = 2N - 2`
+    --- i.e., approximately twice as many as a naive approach.
+
+    [1] Blelloch, Guy E.
+        [Prefix sums and their applications](
+        https://www.cs.cmu.edu/~guyb/papers/Ble93.pdf)
+        Technical Report CMU-CS-90-190,
+        School of Computer Science,
+        Carnegie Mellon University, 1990.
+
+    Args:
+        fn: the associative binary operation to perform.
+        elems: [..., N, ...] the input elements to scan over.
+        axis: the axis to scan over.
+
+    Returns:
+        [..., N, ...] cumulative operation applied on input.
+    """
+
+    # This is a rewrite of tfp.math.scan_associative, which relies on broadcasting, to better handle vectorisation.
+    # This tends to be more performant for smaller ops,
+    # and TFP's version tends to be more performant for larger ops by about 10%.
+    # Equivalent performance for 100 matmuls of 100x100 matrices
+    # (See test_performance for more on performance.)
+
+    _num_elements = np.shape(jax.tree.leaves(elems)[0])[axis]
+    if _num_elements < 2:
+        raise ValueError(f"Must be at least 2 elements, got {_num_elements}.")
+
+    odd_slice = functools.partial(_slice_along_axis, start=1, stop=None, step=2, axis=axis)
+    even_slice = functools.partial(_slice_along_axis, start=0, stop=None, step=2, axis=axis)
+    trim_slice = functools.partial(_slice_along_axis, start=0, stop=-1, step=1, axis=axis)
+    pretrim_slice = functools.partial(_slice_along_axis, start=1, stop=None, step=1, axis=axis)
+    zero_slice = functools.partial(_slice_along_axis, start=0, stop=1, step=1, axis=axis)
+    last_slice = functools.partial(_slice_along_axis, start=-1, stop=None, step=1, axis=axis)
+
+    # The basic idea of the algorithm is as follows, using "sum" to represent the associative operation:
+    # 1. The cumulative sum is: y0=x0, y1=x0+x1, y2=x0+x1+x2, y3=x0+x1+x2+x3
+    # 2. Thus odd indices are equivalent to a two part process:
+    #       a. Sum even+odd inputs: (x0+x1), (x2+x3)
+    #       b. recursively apply `_scan` on the result to give: y1=x0+x1, y3=x0+x1+x2+x3
+    # 3. The even indices are then found by:
+    #       a. adding even indices (ignoring x0 in this step): y2=y1+x2
+    #       b. preconcatenating x0: y0=x0
+    # 4. The result of a single `_scan` is then interleaving the above: _interleave([y0, y1, y2], [y1, y2, y3])
+
+    # TODO: If the associative identity, `id`, was provided then we could combine 3b into 3a via: y0=id+x0
+
+    def _scan(elems):
+        """Perform scan on `elems`."""
+        # Compute _scan(op(elem_odds, elem_evens)) -> odd indicies
+        num_elements = np.shape(jax.tree.leaves(elems)[0])[axis]
+        if num_elements == 0:
+            raise RuntimeError(f"Got zero length `elems`")
+        elif num_elements == 1:
+            return elems
+        elif num_elements == 2:
+            elems_0 = jax.tree.map(zero_slice, elems)
+            elems_1 = jax.tree.map(last_slice, elems)
+            consecutive_sum = jax.vmap(fn, in_axes=axis, out_axes=axis)(
+                elems_0,
+                elems_1
+            )  # x0+x1
+            _results = [
+                elems_0,  # x0
+                consecutive_sum  # x0+x1
+            ]
+            results = jax.tree.map(
+                lambda *x: jnp.concatenate(x, axis=axis),
+                *_results
+            )
+            return results
+
+        is_even = num_elements % 2 == 0
+        if is_even:
+            # Want odd number of elements
+            last_elem = jax.tree.map(last_slice, elems)
+            elems = jax.tree.map(lambda *x: jnp.concatenate(x, axis=axis), elems, last_elem)
+            # elems = jax.tree.map(trim_slice, elems)  # x0, x1, x2, x3, x4, x5, x6 (+ x7)
+        elems_odd = jax.tree.map(odd_slice, elems)  # x1, x3, x5
+        elems_even = jax.tree.map(even_slice, elems)  # x0, x2, x4, x6
+        consecutive_sum = jax.vmap(fn, in_axes=axis, out_axes=axis)(
+            jax.tree.map(trim_slice, elems_even),  # x0, x2, x4
+            elems_odd  # x1, x3, x5
+        )  # x0+x1, x2+x3, x4+x5
+        result_odd = _scan(consecutive_sum)  # x0+x1, x0+x1+x2+x3, x0+x1+x2+x3+x4+x5
+
+        result_even = jax.vmap(fn, in_axes=axis, out_axes=axis)(
+            result_odd,
+            jax.tree.map(pretrim_slice, elems_even)
+        )  # x0+x1+x2, x0+x1+x2+x3+x4, x0+x1+x2+x3+x4+x5+x6
+
+        partial_results = _interleave(
+            result_odd,
+            result_even,
+            axis=axis
+        )
+        # x0+x1, x0+x1+x2,
+        # x0+x1+x2+x3, x0+x1+x2+x3+x4,
+        # x0+x1+x2+x3+x4+x5, x0+x1+x2+x3+x4+x5+x6
+
+        _results = [
+            jax.tree.map(zero_slice, elems),  # x0
+            partial_results
+        ]
+
+        results = jax.tree.map(
+            lambda *x: jnp.concatenate(x, axis=axis),
+            *_results
+        )
+
+        if is_even:
+            results = jax.tree.map(trim_slice, results)
+
+        return results
+
+    result = _scan(elems)
+
+    return result
diff --git a/jaxns/internals/shapes.py b/jaxns/internals/shapes.py
index c4ad7286..546e8563 100644
--- a/jaxns/internals/shapes.py
+++ b/jaxns/internals/shapes.py
@@ -22,13 +22,13 @@ def broadcast_dtypes(*dtypes):
 
 def convert_to_array(v):
     """
-    If necessary convert v to a jnp.ndarray.
+    If necessary convert v to a jax.Array.
     Passes through Prior.
 
     Args:
         v: array-like or scalar
 
-    Returns: jnp.ndarray
+    Returns: jax.Array
     """
     if isinstance(v, (list, tuple, np.ndarray, float, int, bool, complex)):
         return jnp.asarray(v)
diff --git a/jaxns/internals/tree_structure.py b/jaxns/internals/tree_structure.py
index bda36c8e..db013f7d 100644
--- a/jaxns/internals/tree_structure.py
+++ b/jaxns/internals/tree_structure.py
@@ -29,7 +29,7 @@ class SampleLivePointCounts(NamedTuple):
 
 def count_crossed_edges(sample_tree: SampleTreeGraph, num_samples: Optional[IntArray] = None) -> SampleLivePointCounts:
     def _argsort(
-            a: jnp.ndarray
+            a: jax.Array
     ):
         arr = jnp.asarray(a)
         axis_num = 0
@@ -149,8 +149,8 @@ def count_intervals_naive(S: SampleTreeGraph) -> SampleLivePointCounts:
     )
 
 
-def fast_perfect_live_point_computation_jax(log_L_constraints: jnp.ndarray, log_L_samples: jnp.ndarray,
-                                            num_samples: Union[jnp.ndarray, None] = None):
+def fast_perfect_live_point_computation_jax(log_L_constraints: jax.Array, log_L_samples: jax.Array,
+                                            num_samples: Union[jax.Array, None] = None):
     # log_L_constraints has shape [N]
     # log_L_samples has shape [N]
     sort_idx = jnp.lexsort((log_L_constraints, log_L_samples))
diff --git a/jaxns/internals/types.py b/jaxns/internals/types.py
index fc9f67c6..2cebd60f 100644
--- a/jaxns/internals/types.py
+++ b/jaxns/internals/types.py
@@ -129,8 +129,8 @@ class SignedLog(NamedTuple):
     """
     Represents a signed value in log-space
     """
-    log_abs_val: jnp.ndarray
-    sign: Union[jnp.ndarray, Any]
+    log_abs_val: jax.Array
+    sign: Union[jax.Array, Any]
 
 
 class Sample(NamedTuple):
diff --git a/jaxns/nested_sampler/standard_static.py b/jaxns/nested_sampler/standard_static.py
index 14ae6d33..80a250e3 100644
--- a/jaxns/nested_sampler/standard_static.py
+++ b/jaxns/nested_sampler/standard_static.py
@@ -1,9 +1,11 @@
+import dataclasses
 import warnings
-from typing import Tuple, NamedTuple, Any, Union
+from typing import Tuple, NamedTuple, Any, Union, List, Optional
 
 import jax
-from jax import random, pmap, numpy as jnp, lax, core, vmap
+from jax import random, numpy as jnp, lax, core, vmap, pmap
 from jax._src.lax import parallel
+from jaxlib import xla_client
 
 from jaxns.framework.bases import BaseAbstractModel
 from jaxns.internals.cumulative_ops import cumulative_op_static
@@ -581,49 +583,51 @@ def _repeat(a):
     )
 
 
+@dataclasses.dataclass(eq=False)
 class StandardStaticNestedSampler(BaseAbstractNestedSampler):
     """
     A static nested sampler that uses a fixed number of live points. This uses a uniform sampler to generate the
     initial set of samples down to an efficiency threshold, then uses a provided sampler to generate the rest of the
     samples until the termination condition is met.
-    """
 
-    def __init__(self, init_efficiency_threshold: float, sampler: BaseAbstractSampler, num_live_points: int,
-                 model: BaseAbstractModel, max_samples: int, num_parallel_workers: int = 1, verbose: bool = False):
-        """
-        Initialise the static nested sampler.
-
-        Args:
-            init_efficiency_threshold: the efficiency threshold to use for the initial uniform sampling. If 0 then
-                turns it off.
-            sampler: the sampler to use after the initial uniform sampling.
-            num_live_points: the number of live points to use.
-            model: the model to use.
-            max_samples: the maximum number of samples to take.
-            num_parallel_workers: number of parallel workers to use. Defaults to 1. Experimental feature.
-            verbose: whether to log as we go.
-        """
-        self.init_efficiency_threshold = init_efficiency_threshold
-        self.sampler = sampler
-        self.num_live_points = int(num_live_points)
-        self.num_parallel_workers = int(num_parallel_workers)
-        self.verbose = bool(verbose)
-        remainder = max_samples % self.num_live_points
-        extra = (max_samples - remainder) % self.num_live_points
+    Args:
+        init_efficiency_threshold: the efficiency threshold to use for the initial uniform sampling. If 0 then
+            turns it off.
+        sampler: the sampler to use after the initial uniform sampling.
+        num_live_points: the number of live points to use.
+        model: the model to use.
+        max_samples: the maximum number of samples to take.
+        devices: the devices to use, default is 1.
+        verbose: whether to log as we go.
+    """
+    init_efficiency_threshold: float
+    sampler: BaseAbstractSampler
+    num_live_points: int
+    model: BaseAbstractModel
+    max_samples: int
+    devices: Optional[List[xla_client.Device]] = None
+    verbose: bool = False
+
+    def __post_init__(self):
+        if self.devices is None:
+            self.devices = jax.devices()[:1]
+
+        remainder = self.max_samples % self.num_live_points
+        extra = (self.max_samples - remainder) % self.num_live_points
         if extra > 0:
             warnings.warn(
-                f"Increasing max_samples ({max_samples}) by {extra} to closest multiple of "
+                f"Increasing max_samples ({self.max_samples}) by {extra} to closest multiple of "
                 f"num_live_points {self.num_live_points}."
             )
-        max_samples = int(max_samples + extra)
-        if self.num_parallel_workers > 1:
-            logger.info(f"Using {self.num_parallel_workers} parallel workers, each running identical samplers.")
-        super().__init__(model=model, max_samples=max_samples)
+        self.max_samples = int(self.max_samples + extra)
+        if len(self.devices) > 1:
+            logger.info(f"Using {len(self.devices)} parallel workers, each running identical samplers.")
+        BaseAbstractNestedSampler.__init__(self, model=self.model, max_samples=self.max_samples)
 
     def __repr__(self):
         return f"StandardStaticNestedSampler(init_efficiency_threshold={self.init_efficiency_threshold}, " \
                f"sampler={self.sampler}, num_live_points={self.num_live_points}, model={self.model}, " \
-               f"max_samples={self.max_samples}, num_parallel_workers={self.num_parallel_workers})"
+               f"max_samples={self.max_samples}, devices={self.devices})"
 
     def _to_results(self, termination_reason: IntArray, state: StaticStandardNestedSamplerState,
                     trim: bool) -> NestedSamplerResults:
@@ -772,10 +776,10 @@ def replica(key: PRNGKey) -> Tuple[StaticStandardNestedSamplerState, IntArray]:
                 num_samples_per_sync=self.num_live_points,
                 verbose=self.verbose
             )
-            if self.num_parallel_workers > 1:
+            if len(self.devices) > 1:
                 # We need to do a final sampling run to make all the chains consistent,
                 #  to a likelihood contour (i.e. standardise on L(X)). Would mean that some workers are idle.
-                target_log_L_contour = parallel.pmax(termination_register.log_L_contour, 'i')
+                target_log_L_contour = parallel.pmax(termination_register.log_L_contour, 'markov_chain')
 
                 termination_cond = TerminationCondition(
                     dlogZ=jnp.asarray(0., float_type),
@@ -793,10 +797,10 @@ def replica(key: PRNGKey) -> Tuple[StaticStandardNestedSamplerState, IntArray]:
 
             return state, termination_reason
 
-        if self.num_parallel_workers > 1:
-            parallel_ns = pmap(replica, axis_name='i')
+        if len(self.devices) > 1:
+            parallel_ns = pmap(replica, axis_name='markov_chain')
 
-            keys = random.split(key, self.num_parallel_workers)
+            keys = random.split(key, len(self.devices))
             batched_state, termination_reason = parallel_ns(keys)
             state = unbatch_state(batched_state=batched_state)
         else:
diff --git a/jaxns/public.py b/jaxns/public.py
index 0c44648e..8da37a45 100644
--- a/jaxns/public.py
+++ b/jaxns/public.py
@@ -5,6 +5,7 @@
 import jax.numpy as jnp
 import tensorflow_probability.substrates.jax as tfp
 from jax import core
+from jaxlib import xla_client
 
 from jaxns.framework.bases import BaseAbstractModel
 from jaxns.internals.logging import logger
@@ -38,7 +39,8 @@ def __init__(self, model: BaseAbstractModel,
                  s: Optional[int] = None,
                  k: Optional[int] = None,
                  c: Optional[int] = None,
-                 num_parallel_workers: int = 1,
+                 num_parallel_workers: Optional[int] = None,
+                 devices: Optional[xla_client.Device] = None,
                  difficult_model: bool = False,
                  parameter_estimation: bool = False,
                  init_efficiency_threshold: float = 0.1,
@@ -79,7 +81,7 @@ def __init__(self, model: BaseAbstractModel,
             logger.info(f"Number of parallel Markov-chains set to: {self._c}")
         else:
             if difficult_model:
-                self._c = 50 * model.U_ndims if c is None else int(c)
+                self._c = 100 * model.U_ndims if c is None else int(c)
             else:
                 self._c = 30 * model.U_ndims if c is None else int(c)
         if self._c <= 0:
@@ -87,6 +89,12 @@ def __init__(self, model: BaseAbstractModel,
         # Sanity check for max_samples (should be able to at least do one shrinkage)
         if max_samples < self._c * (self._k + 1):
             warnings.warn(f"max_samples={max_samples} is likely too small!")
+        if num_parallel_workers is not None:
+            warnings.warn("`num_parallel_workers` is depreciated. Use `devices` instead.")
+            if devices is None:
+                devices = jax.devices()[:num_parallel_workers]
+            else:
+                devices = devices[:num_parallel_workers]
         self._nested_sampler = StandardStaticNestedSampler(
             model=model,
             num_live_points=self._c,
@@ -99,7 +107,7 @@ def __init__(self, model: BaseAbstractModel,
                 perfect=True
             ),
             init_efficiency_threshold=init_efficiency_threshold,
-            num_parallel_workers=num_parallel_workers,
+            devices=devices,
             verbose=verbose
         )
 
@@ -111,7 +119,7 @@ def __init__(self, model: BaseAbstractModel,
         self.load_results = load_results
 
     def __repr__(self):
-        return f"DefaultNestedSampler(s={self._s}, c={self._c},  k={self._k})"
+        return f"DefaultNestedSampler(s={self._s}, c={self._c}, k={self._k}, devices={self._nested_sampler.devices})"
 
     @property
     def num_live_points(self) -> int:
diff --git a/jaxns/samplers/multi_ellipsoid/em_gmm.py b/jaxns/samplers/multi_ellipsoid/em_gmm.py
index 582749f1..c5951b2d 100644
--- a/jaxns/samplers/multi_ellipsoid/em_gmm.py
+++ b/jaxns/samplers/multi_ellipsoid/em_gmm.py
@@ -1,5 +1,6 @@
 from typing import Union
 
+import jax
 import jax.numpy as jnp
 from jax import random, vmap, lax
 from jax._src.scipy.special import logsumexp
@@ -91,7 +92,7 @@ def m_step(data, log_responsibilities):
 
 
 # No invariance under jit...
-def em_gmm(key, data, n_components, mask: Union[jnp.ndarray, None] = None, n_iters=10, tol=1e-6):
+def em_gmm(key, data, n_components, mask: Union[jax.Array, None] = None, n_iters=10, tol=1e-6):
     """
     Fit a Gaussian Mixture Model to the data using the Expectation-Maximization algorithm.
 
diff --git a/jaxns/samplers/multi_ellipsoid/multi_ellipsoid_utils.py b/jaxns/samplers/multi_ellipsoid/multi_ellipsoid_utils.py
index d760579c..013f2bc5 100644
--- a/jaxns/samplers/multi_ellipsoid/multi_ellipsoid_utils.py
+++ b/jaxns/samplers/multi_ellipsoid/multi_ellipsoid_utils.py
@@ -51,7 +51,7 @@ def bounding_ellipsoid(points: UType, mask: FloatArray) -> Tuple[FloatArray, Flo
     return mu, cov
 
 
-def covariance_to_rotational(cov: jnp.ndarray) -> Tuple[jnp.ndarray, jnp.ndarray]:
+def covariance_to_rotational(cov: jax.Array) -> Tuple[jax.Array, jax.Array]:
     """
     (x - mu)^T inv(cov) (x - mu) = (x - mu)^T J @ J.T (x - mu)
 
diff --git a/jaxns/utils.py b/jaxns/utils.py
index d849f5b6..26890cba 100644
--- a/jaxns/utils.py
+++ b/jaxns/utils.py
@@ -38,7 +38,7 @@
 ]
 
 
-def resample(key: PRNGKey, samples: Union[XType, UType], log_weights: jnp.ndarray, S: int = None,
+def resample(key: PRNGKey, samples: Union[XType, UType], log_weights: jax.Array, S: int = None,
              replace: bool = True) -> XType:
     """
     Resample the weighted samples into uniformly weighted samples.
@@ -76,7 +76,7 @@ def evaluate_map_estimate_from_U(results: NestedSamplerResults, model: BaseAbstr
     return fun(*V)
 
 
-def marginalise_static_from_U(key: PRNGKey, U_samples: UType, model: BaseAbstractModel, log_weights: jnp.ndarray,
+def marginalise_static_from_U(key: PRNGKey, U_samples: UType, model: BaseAbstractModel, log_weights: jax.Array,
                               ESS: int,
                               fun: Callable[..., _V]) -> _V:
     """
@@ -103,8 +103,8 @@ def _eval(U):
     return marginalised
 
 
-def marginalise_dynamic_from_U(key: PRNGKey, U_samples: UType, model: BaseAbstractModel, log_weights: jnp.ndarray,
-                               ESS: jnp.ndarray,
+def marginalise_dynamic_from_U(key: PRNGKey, U_samples: UType, model: BaseAbstractModel, log_weights: jax.Array,
+                               ESS: jax.Array,
                                fun: Callable[..., _V]) -> _V:
     """
     Marginalises function over posterior samples, where ESS can be dynamic.
@@ -148,7 +148,7 @@ def body(state):
     return marginalised
 
 
-def marginalise_static(key: PRNGKey, samples: XType, log_weights: jnp.ndarray, ESS: int, fun: Callable[..., _V]) -> _V:
+def marginalise_static(key: PRNGKey, samples: XType, log_weights: jax.Array, ESS: int, fun: Callable[..., _V]) -> _V:
     """
     Marginalises function over posterior samples, where ESS is static.
 
@@ -168,7 +168,7 @@ def marginalise_static(key: PRNGKey, samples: XType, log_weights: jnp.ndarray, E
     return marginalised
 
 
-def marginalise_dynamic(key: PRNGKey, samples: XType, log_weights: jnp.ndarray, ESS: jnp.ndarray,
+def marginalise_dynamic(key: PRNGKey, samples: XType, log_weights: jax.Array, ESS: jax.Array,
                         fun: Callable[..., _V]) -> _V:
     """
     Marginalises function over posterior samples, where ESS can be dynamic.
@@ -452,7 +452,7 @@ def single_log_Z_sample(key: PRNGKey) -> FloatArray:
     return log_Z_samples
 
 
-def bruteforce_posterior_samples(model: BaseAbstractModel, S: int = 60) -> Tuple[XType, jnp.ndarray]:
+def bruteforce_posterior_samples(model: BaseAbstractModel, S: int = 60) -> Tuple[XType, jax.Array]:
     """
     Compute the posterior with brute-force over a regular grid.
 
diff --git a/requirements.txt b/requirements.txt
index da0a6bb4..3e4ddd0e 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,7 +1,7 @@
 jax>=0.4.25
 jaxlib
 matplotlib
-numpy
+numpy<2
 scipy
 tensorflow_probability
 tqdm
diff --git a/setup.py b/setup.py
index 82412585..dfaa6ef6 100755
--- a/setup.py
+++ b/setup.py
@@ -7,7 +7,7 @@
     'jax>=0.4.25',
     'jaxlib',
     'matplotlib',
-    'numpy',
+    'numpy<2',
     'scipy',
     'tensorflow_probability',
     'tqdm',
@@ -20,7 +20,7 @@
     long_description = fh.read()
 
 setup(name='jaxns',
-      version='2.5.1',
+      version='2.5.2',
       description='Nested Sampling in JAX',
       long_description=long_description,
       long_description_content_type="text/markdown",


Test patch:
diff --git a/jaxns/framework/tests/test_jaxify.py b/jaxns/framework/tests/test_jaxify.py
index b124c5f7..044e9dca 100644
--- a/jaxns/framework/tests/test_jaxify.py
+++ b/jaxns/framework/tests/test_jaxify.py
@@ -16,8 +16,10 @@ def log_likelihood(x, y):
 
     vmaped_wrapped_ll = jax.vmap(jaxify_likelihood(log_likelihood, vectorised=True))
 
-    np.testing.assert_allclose(vmaped_wrapped_ll(np.array([[1, 2], [2, 2]]), np.array([[3, 4], [4, 4]])),
-                               np.array([10, 12]))
+    np.testing.assert_allclose(
+        vmaped_wrapped_ll(np.array([[1, 2], [2, 2]]), np.array([[3, 4], [4, 4]])),
+        np.array([10, 12])
+    )
 
 
 def test_jaxify():
diff --git a/jaxns/framework/tests/test_model.py b/jaxns/framework/tests/test_model.py
index 22dcce23..d71b103d 100644
--- a/jaxns/framework/tests/test_model.py
+++ b/jaxns/framework/tests/test_model.py
@@ -13,8 +13,8 @@
 
 def test_gh144():
     class Output(NamedTuple):
-        x: jnp.ndarray
-        y: jnp.ndarray
+        x: jax.Array
+        y: jax.Array
 
     def prior_model():
         x = yield Prior(dist_or_value=jnp.asarray(0.))
diff --git a/jaxns/framework/tests/test_prior.py b/jaxns/framework/tests/test_prior.py
index caced1b1..1e8a9a6f 100644
--- a/jaxns/framework/tests/test_prior.py
+++ b/jaxns/framework/tests/test_prior.py
@@ -11,7 +11,8 @@
 from jaxns.framework.ops import parse_prior, prepare_input, compute_log_likelihood
 from jaxns.framework.prior import Prior, InvalidPriorName
 from jaxns.framework.special_priors import Bernoulli, Categorical, Poisson, Beta, ForcedIdentifiability, \
-    UnnormalisedDirichlet, _poisson_quantile_bisection, _poisson_quantile, Empirical, TruncationWrapper
+    UnnormalisedDirichlet, _poisson_quantile_bisection, _poisson_quantile, Empirical, TruncationWrapper, \
+    ExplicitDensityPrior
 from jaxns.framework.wrapped_tfp_distribution import InvalidDistribution, distribution_chain
 from jaxns.internals.types import float_type
 
@@ -344,6 +345,7 @@ def test_empirical():
     assert jnp.allclose(u, u_input)
     assert u.shape[1:] == prior.base_shape
 
+
 def test_truncation_wrapper():
     prior = Prior(tfpd.Normal(loc=jnp.zeros(5), scale=jnp.ones(5)))
     trancated_prior = TruncationWrapper(prior=prior, low=0., high=1.)
@@ -360,7 +362,8 @@ def test_truncation_wrapper():
     assert jnp.all(x <= 1.)
     assert x.shape == (5,)
 
-    u_input = vmap(lambda key: random.uniform(key, shape=trancated_prior.base_shape))(random.split(random.PRNGKey(42), 1000))
+    u_input = vmap(lambda key: random.uniform(key, shape=trancated_prior.base_shape))(
+        random.split(random.PRNGKey(42), 1000))
     x = vmap(lambda u: trancated_prior.forward(u))(u_input)
     assert jnp.all(jnp.bitwise_not(jnp.isnan(x)))
     assert jnp.all(x >= 0.)
@@ -394,7 +397,7 @@ def test_truncation_wrapper():
     u = vmap(lambda x: trancated_prior.inverse(x))(x)
     np.testing.assert_allclose(u, u_input, atol=5e-7)
 
-    prior = Prior(tfpd.Normal(loc=jnp.zeros(5), scale=0.01*jnp.ones(5)))
+    prior = Prior(tfpd.Normal(loc=jnp.zeros(5), scale=0.01 * jnp.ones(5)))
     trancated_prior = TruncationWrapper(prior=prior, low=0., high=1.)
 
     x = trancated_prior.forward(jnp.ones(trancated_prior.base_shape, float_type))
@@ -418,3 +421,31 @@ def test_truncation_wrapper():
 
     u = vmap(lambda x: trancated_prior.inverse(x))(x)
     np.testing.assert_allclose(u, u_input, atol=5e-7)
+
+
+def test_explicit_density_prior():
+    resolution = 10
+    density = jnp.ones((resolution + 1, resolution))
+    axes = (jnp.linspace(0, 1, resolution + 1), jnp.linspace(0, 1, resolution))
+    prior = ExplicitDensityPrior(axes=axes, density=density, regular_grid=True)
+
+    x = prior.forward(jnp.ones(prior.base_shape, float_type))
+    assert jnp.all(jnp.bitwise_not(jnp.isnan(x)))
+    assert jnp.all(x == 1.)
+    assert x.shape == (2,)
+
+    x = prior.forward(jnp.zeros(prior.base_shape, float_type))
+    assert jnp.all(jnp.bitwise_not(jnp.isnan(x)))
+    assert jnp.all(x == 0.)
+    assert x.shape == (2,)
+
+    u_input = vmap(lambda key: random.uniform(key, shape=prior.base_shape))(random.split(random.PRNGKey(42), 1000))
+    x = vmap(lambda u: prior.forward(u))(u_input)
+    assert jnp.all(jnp.bitwise_not(jnp.isnan(x)))
+    assert jnp.all(x >= 0.)
+    assert jnp.all(x <= 1.)
+
+    u = vmap(lambda x: prior.inverse(x))(x)
+    np.testing.assert_allclose(u, u_input, atol=5e-7)
+
+    assert jnp.all(jnp.isfinite(jax.vmap(prior.log_prob)(x)))
diff --git a/jaxns/internals/tests/test_constraint_bijections.py b/jaxns/internals/tests/test_constraint_bijections.py
new file mode 100644
index 00000000..4a9bf811
--- /dev/null
+++ b/jaxns/internals/tests/test_constraint_bijections.py
@@ -0,0 +1,39 @@
+import jax
+import numpy as np
+from jax import numpy as jnp
+from jax._src.scipy.special import logit
+
+from jaxns.internals.constraint_bijections import quick_unit, quick_unit_inverse
+
+
+def test_quick_unit():
+    x = jnp.linspace(-10, 10, 1000000)
+    y = quick_unit(x)
+    assert np.all(y <= 1)
+    assert np.all(y >= 0)
+    x_reconstructed = quick_unit_inverse(y)
+    np.testing.assert_allclose(x, x_reconstructed, atol=2e-5)
+
+    g = jax.grad(quick_unit)
+    assert np.all(np.isfinite(jax.vmap(g)(x)))
+    assert np.isfinite(g(0.))
+
+    h = jax.grad(quick_unit_inverse)
+    assert np.all(np.isfinite(jax.vmap(h)(y)))
+    assert np.isfinite(h(0.5))
+
+    # Test performance against sigmoid and logit
+    import time
+    for f in [quick_unit, jax.nn.sigmoid]:
+        g = jax.jit(f).lower(x).compile()
+        t0 = time.time()
+        for _ in range(1000):
+            g(x).block_until_ready()
+        print(f"{f.__name__} {time.time() - t0}s")
+
+    for f in [quick_unit_inverse, logit]:
+        g = jax.jit(f).lower(y).compile()
+        t0 = time.time()
+        for _ in range(1000):
+            g(y).block_until_ready()
+        print(f"{f.__name__} {time.time() - t0}s")
diff --git a/jaxns/internals/tests/test_cumulative_ops.py b/jaxns/internals/tests/test_cumulative_ops.py
index 6214b37d..6b214cb6 100644
--- a/jaxns/internals/tests/test_cumulative_ops.py
+++ b/jaxns/internals/tests/test_cumulative_ops.py
@@ -22,6 +22,24 @@ def op(accumulate, y):
     assert all(result == jnp.asarray([0, 1, 3], float_type))
 
 
+def test_scan_associative_cumulative_op_likelihoods():
+    def log_likelihood(x) -> jax.Array:
+        return jnp.sum(x)
+
+    def add_log_probs(x, y):
+        print(x, y)
+        return log_likelihood(x) + log_likelihood(y)
+
+    init = jnp.asarray(0, float_type)
+    xs = jnp.arange(1, 11, dtype=float_type)
+    final_accumulate, result = scan_associative_cumulative_op(op=add_log_probs, init=init, xs=xs)
+    final_accumulate_expected, result_expected = cumulative_op_static(op=add_log_probs, init=init, xs=xs)
+    # print(final_accumulate, final_accumulate_expected)
+    # print(result, result_expected)
+    assert final_accumulate == final_accumulate_expected
+    np.testing.assert_allclose(result, result_expected)
+
+
 @pytest.mark.parametrize("binary_op", [jnp.add, jnp.multiply, jnp.minimum, jnp.maximum])
 def test_scan_associative_cumulative_op(binary_op):
     def op(accumulate, y):
@@ -41,7 +59,7 @@ def op(accumulate, y):
 
 
 @pytest.mark.parametrize("binary_op", [jnp.subtract, jnp.true_divide])
-def test_scan_associative_cumulative_op(binary_op):
+def test_scan_associative_cumulative_not_associative_op(binary_op):
     def op(accumulate, y):
         return binary_op(accumulate, y)
 
diff --git a/jaxns/internals/tests/test_interp_utils.py b/jaxns/internals/tests/test_interp_utils.py
new file mode 100644
index 00000000..2934cdb3
--- /dev/null
+++ b/jaxns/internals/tests/test_interp_utils.py
@@ -0,0 +1,194 @@
+import jax.random
+import numpy as np
+import pytest
+from jax import numpy as jnp
+
+from jaxns.internals.interp_utils import get_interp_indices_and_weights, apply_interp, left_broadcast_multiply, \
+    InterpolatedArray
+
+
+def test_get_interp_indices_and_weights():
+    xp = [0, 1, 2, 3]
+    x = 1.5
+    (i0, alpha0), (i1, alpha1) = get_interp_indices_and_weights(x, xp)
+    print(i0, alpha0, i1, alpha1)
+    assert i0 == 1
+    assert alpha0 == 0.5
+    assert i1 == 2
+    assert alpha1 == 0.5
+
+    x = 0
+    (i0, alpha0), (i1, alpha1) = get_interp_indices_and_weights(x, xp)
+    print(i0, alpha0, i1, alpha1)
+    assert i0 == 0
+    assert alpha0 == 1
+    assert i1 == 1
+    assert alpha1 == 0
+
+    x = 3
+    (i0, alpha0), (i1, alpha1) = get_interp_indices_and_weights(x, xp)
+    print(i0, alpha0, i1, alpha1)
+    assert i0 == 2
+    assert alpha0 == 0
+    assert i1 == 3
+    assert alpha1 == 1
+
+    x = -1
+    (i0, alpha0), (i1, alpha1) = get_interp_indices_and_weights(x, xp)
+    print(i0, alpha0, i1, alpha1)
+    assert xp[i0] * alpha0 + xp[i1] * alpha1 == -1
+
+    x = 4
+    (i0, alpha0), (i1, alpha1) = get_interp_indices_and_weights(x, xp)
+    print(i0, alpha0, i1, alpha1)
+    assert xp[i0] * alpha0 + xp[i1] * alpha1 == 4
+
+    x = 5
+    (i0, alpha0), (i1, alpha1) = get_interp_indices_and_weights(x, xp)
+    print(i0, alpha0, i1, alpha1)
+    assert xp[i0] * alpha0 + xp[i1] * alpha1 == 5
+
+    xp = [0., 0.]
+    x = 0.
+    (i0, alpha0), (i1, alpha1) = get_interp_indices_and_weights(x, xp)
+    print(i0, alpha0, i1, alpha1)
+    assert i0 == 0
+    assert alpha0 == 1
+    assert i1 == 1
+    assert alpha1 == 0.
+
+    xp = [0., 0.]
+    x = -1
+    (i0, alpha0), (i1, alpha1) = get_interp_indices_and_weights(x, xp)
+    print(i0, alpha0, i1, alpha1)
+    assert i0 == 0
+    assert alpha0 == 2.
+    assert i1 == 1
+    assert alpha1 == -1.
+
+    xp = [0.]
+    x = 0.5
+    (i0, alpha0), (i1, alpha1) = get_interp_indices_and_weights(x, xp)
+    print(i0, alpha0, i1, alpha1)
+    assert i0 == 0
+    assert alpha0 == 1.
+    assert i1 == 0
+    assert alpha1 == 0.
+
+    # Vector ops
+    xp = [0, 1, 2, 3]
+    x = [1.5, 1.5]
+    (i0, alpha0), (i1, alpha1) = get_interp_indices_and_weights(x, xp)
+    print(i0, alpha0, i1, alpha1)
+    np.testing.assert_array_equal(i0, jnp.asarray([1, 1]))
+    np.testing.assert_array_equal(alpha0, jnp.asarray([0.5, 0.5]))
+    np.testing.assert_array_equal(i1, jnp.asarray([2, 2]))
+    np.testing.assert_array_equal(alpha1, jnp.asarray([0.5, 0.5]))
+
+    xp = [0, 1, 2, 3]
+    x = [1.5, 2.5]
+    (i0, alpha0), (i1, alpha1) = get_interp_indices_and_weights(x, xp)
+    print(i0, alpha0, i1, alpha1)
+    np.testing.assert_array_equal(i0, jnp.asarray([1, 2]))
+    np.testing.assert_array_equal(alpha0, jnp.asarray([0.5, 0.5]))
+    np.testing.assert_array_equal(i1, jnp.asarray([2, 3]))
+    np.testing.assert_array_equal(alpha1, jnp.asarray([0.5, 0.5]))
+
+    # xp = [0, 1, 2, 3]
+    # x = [-0.5, 3.5]
+    # (i0, alpha0), (i1, alpha1) = get_interp_indices_and_weights(x, xp)
+    # print(i0, alpha0, i1, alpha1)
+    # np.testing.assert_array_equal(i0, jnp.asarray([1, 2]))
+    # np.testing.assert_array_equal(alpha0, jnp.asarray([0.5, 0.5]))
+    # np.testing.assert_array_equal(i1, jnp.asarray([2, 3]))
+    # np.testing.assert_array_equal(alpha1, jnp.asarray([0.5, 0.5]))
+
+
+@pytest.mark.parametrize('regular_grid', [True, False])
+def test_apply_interp(regular_grid):
+    xp = jnp.linspace(0., 1., 10)
+    x = jnp.linspace(-0.1, 1.1, 10)
+    (i0, alpha0), (i1, alpha1) = get_interp_indices_and_weights(x, xp, regular_grid=regular_grid)
+    np.testing.assert_allclose(apply_interp(xp, i0, alpha0, i1, alpha1), x, atol=1e-6)
+
+    x = jnp.linspace(-0.1, 1.1, 10)
+    (i0, alpha0), (i1, alpha1) = get_interp_indices_and_weights(x, xp, regular_grid=regular_grid)
+    assert apply_interp(jnp.zeros((4, 5, 10, 6)), i0, alpha0, i1, alpha1, axis=2).shape == (4, 5, 10, 6)
+
+    x = 0.
+    (i0, alpha0), (i1, alpha1) = get_interp_indices_and_weights(x, xp, regular_grid=regular_grid)
+    assert apply_interp(jnp.zeros((4, 5, 10, 6)), i0, alpha0, i1, alpha1, axis=2).shape == (4, 5, 6)
+
+    print(
+        jax.jit(lambda x: apply_interp(x, i0, alpha0, i1, alpha1, axis=2)).lower(
+            jnp.zeros((4, 5, 10, 6))).compile().cost_analysis()
+    )
+    # [{'bytes accessed': 1440.0, 'utilization1{}': 2.0, 'bytes accessed0{}': 960.0, 'bytes accessedout{}': 480.0, 'bytes accessed1{}': 960.0}]
+    # [{'bytes accessed1{}': 960.0,  'utilization1{}': 2.0, 'bytes accessedout{}': 480.0, 'bytes accessed0{}': 960.0, 'bytes accessed': 1440.0}]
+
+
+def test_regular_grid():
+    # Inside bounds
+    xp = jnp.linspace(0., 1., 10)
+    fp = jax.random.normal(jax.random.PRNGKey(0), (10, 15))
+    x = jnp.linspace(0., 1., 100)
+    (i0, alpha0), (i1, alpha1) = get_interp_indices_and_weights(x, xp, regular_grid=False)
+    f_no = apply_interp(fp, i0, alpha0, i1, alpha1)
+
+    (i0, alpha0), (i1, alpha1) = get_interp_indices_and_weights(x, xp, regular_grid=True)
+    f_yes = apply_interp(fp, i0, alpha0, i1, alpha1)
+    np.testing.assert_allclose(
+        f_yes, f_no,
+        atol=1e-6
+    )
+
+    # Outside bounds
+    x = jnp.linspace(-0.1, 1.1, 100)
+    xp = jnp.linspace(0., 1., 10)
+    fp = jax.random.normal(jax.random.PRNGKey(0), (10, 15))
+    (i0, alpha0), (i1, alpha1) = get_interp_indices_and_weights(x, xp, regular_grid=False)
+    f_no = apply_interp(fp, i0, alpha0, i1, alpha1)
+
+    (i0, alpha0), (i1, alpha1) = get_interp_indices_and_weights(x, xp, regular_grid=True)
+    f_yes = apply_interp(fp, i0, alpha0, i1, alpha1)
+    np.testing.assert_allclose(
+        f_yes, f_no,
+        atol=1e-6
+    )
+
+
+def test_left_broadcast_multiply():
+    assert np.all(left_broadcast_multiply(np.ones((2, 3)), np.ones((2,))) == np.ones((2, 3)))
+    assert np.all(left_broadcast_multiply(np.ones((2, 3)), np.ones((2, 3))) == np.ones((2, 3)))
+    assert np.all(
+        left_broadcast_multiply(np.ones((1, 2, 3, 4, 5)), np.ones((3, 4)), axis=2) == np.ones((1, 2, 3, 4, 5)))
+    assert np.all(
+        left_broadcast_multiply(np.ones((1, 2, 3, 4, 5)), np.ones((3, 4)), axis=-3) == np.ones((1, 2, 3, 4, 5)))
+
+
+@pytest.mark.parametrize('regular_grid', [True, False])
+def test_interpolated_array(regular_grid: bool):
+    # scalar time
+    times = jnp.linspace(0, 10, 100)
+    values = jnp.sin(times)
+    interp = InterpolatedArray(times, values, regular_grid=regular_grid)
+    assert interp(5.).shape == ()
+    np.testing.assert_allclose(interp(5.), jnp.sin(5), atol=2e-3)
+
+    # vector time
+    assert interp(jnp.array([5., 6.])).shape == (2,)
+    np.testing.assert_allclose(interp(jnp.array([5., 6.])), jnp.sin(jnp.array([5., 6.])), atol=2e-3)
+
+    # Now with axis = 1
+    times = jnp.linspace(0, 10, 100)
+    values = jnp.stack([jnp.sin(times), jnp.cos(times)], axis=0)  # [2, 100]
+    interp = InterpolatedArray(times, values, axis=1, regular_grid=regular_grid)
+    assert interp(5.).shape == (2,)
+    np.testing.assert_allclose(interp(5.), jnp.array([jnp.sin(5), jnp.cos(5)]), atol=2e-3)
+
+    # Vector
+    assert interp(jnp.array([5., 6., 7.])).shape == (2, 3)
+    np.testing.assert_allclose(interp(jnp.array([5., 6., 7.])),
+                               jnp.stack([jnp.sin(jnp.array([5., 6., 7.])), jnp.cos(jnp.array([5., 6., 7.]))],
+                                         axis=0),
+                               atol=2e-3)
diff --git a/jaxns/internals/tests/test_namedtuple_utils.py b/jaxns/internals/tests/test_namedtuple_utils.py
index 2fc52d6e..f9532ff7 100644
--- a/jaxns/internals/tests/test_namedtuple_utils.py
+++ b/jaxns/internals/tests/test_namedtuple_utils.py
@@ -1,15 +1,15 @@
-import json
 from typing import NamedTuple
 
+import jax.numpy as jnp
 import numpy as np
 
-from jaxns.internals.namedtuple_utils import issubclass_namedtuple, serialise_namedtuple, deserialise_namedtuple
+from jaxns.internals.namedtuple_utils import serialise_namedtuple, \
+    deserialise_namedtuple, issubclass_namedtuple, serialise_ndarray
 
 
-# Example NamedTuple
 class MockAge(NamedTuple):
     years: int
-    months: np.ndarray
+    months: int
 
 
 class MockPerson(NamedTuple):
@@ -19,7 +19,7 @@ class MockPerson(NamedTuple):
 
 def test_isinstance_namedtuple():
     # Example NamedTuple
-    data = MockPerson('Alice', MockAge(25, np.asarray(6)))
+    data = MockPerson('Alice', MockAge(25, 6))
     assert isinstance(data, MockPerson)
 
     data = ()
@@ -44,16 +44,8 @@ class C:
 
 
 def test_serialise_namedtuple():
-    class MockAge(NamedTuple):
-        years: int
-        months: np.ndarray
-
-    class MockPerson(NamedTuple):
-        name: str
-        age: MockAge
-
     # Example NamedTuple
-    data = MockPerson('Alice', MockAge(25, np.array(6)))
+    data = MockPerson('Alice', MockAge(25, 6))
     # Serialise
     serialized_data = serialise_namedtuple(data)
     print(serialized_data)
@@ -65,18 +57,21 @@ class MockPerson(NamedTuple):
     assert data == restored_data
 
 
-def test_to_json():
-    class MockAge(NamedTuple):
-        years: int
-        months: np.ndarray
+def test_serialise_ndarray():
+    array = np.array([1, 2, 3])
+    serialized_data = serialise_ndarray(array)
+    print(serialized_data)
+    restored_data = deserialise_namedtuple(serialized_data)
+    print(restored_data)
+
+    np.testing.assert_allclose(array, restored_data)
 
-    class MockPerson(NamedTuple):
-        name: str
-        age: MockAge
 
-    data = MockPerson('Alice', MockAge(25, np.array(6)))
-    s = json.dumps(serialise_namedtuple(data), indent=2)
-    print(s)
-    restored_data = deserialise_namedtuple(json.loads(s))
+def test_serialise_jax_ndarray():
+    array = jnp.array([1, 2, 3])
+    serialized_data = serialise_ndarray(array)
+    print(serialized_data)
+    restored_data = deserialise_namedtuple(serialized_data)
     print(restored_data)
-    assert data == restored_data
+
+    np.testing.assert_allclose(array, restored_data)
diff --git a/jaxns/internals/tests/test_prefix_sum.py b/jaxns/internals/tests/test_prefix_sum.py
new file mode 100644
index 00000000..9960acb8
--- /dev/null
+++ b/jaxns/internals/tests/test_prefix_sum.py
@@ -0,0 +1,158 @@
+import time
+from functools import partial
+from typing import NamedTuple
+
+import jax
+import numpy as np
+import pytest
+from jax import numpy as jnp
+from tensorflow_probability.substrates import jax as tfp
+
+from jaxns.internals.prefix_sum import _slice_along_axis, _interleave, scan_associative
+
+
+def test__slice_along_axis():
+    a = jnp.arange(5)
+    np.testing.assert_allclose(
+        _slice_along_axis(a, stop=-1),
+        a[:-1]
+    )
+
+
+def test__interleave():
+    # even
+    a = jnp.asarray([0, 1, 2, 3])
+    b = jnp.asarray([4, 5, 6, 7])
+    expected_interleaved = jnp.asarray([0, 4, 1, 5, 2, 6, 3, 7])
+    np.testing.assert_allclose(_interleave(a, b, axis=0), expected_interleaved)
+
+    # odd
+    a = jnp.asarray([0, 1, 2])
+    b = jnp.asarray([3, 4, 5])
+    expected_interleaved = jnp.asarray([0, 3, 1, 4, 2, 5])
+    np.testing.assert_allclose(_interleave(a, b, axis=0), expected_interleaved)
+
+    # multi-dim
+    a = jnp.asarray(
+        [
+            [0, 1, 2],
+            [0, 1, 2]
+        ]
+    )
+    b = jnp.asarray(
+        [
+            [3, 4, 5],
+            [3, 4, 5]
+        ]
+    )
+    expected_interleaved_1 = jnp.asarray(
+        [
+            [0, 3, 1, 4, 2, 5],
+            [0, 3, 1, 4, 2, 5]
+        ]
+    )
+    expected_interleaved_0 = jnp.asarray(
+        [
+            [0, 1, 2],
+            [3, 4, 5],
+            [0, 1, 2],
+            [3, 4, 5]
+        ]
+    )
+    np.testing.assert_allclose(_interleave(a, b, axis=1), expected_interleaved_1)
+    np.testing.assert_allclose(_interleave(a, b, axis=0), expected_interleaved_0)
+
+
+@pytest.mark.parametrize('num_elems', [10, 11])
+@pytest.mark.parametrize('op', [jnp.add, jnp.multiply, jnp.minimum, jnp.maximum])
+def test_scan_associative(num_elems, op):
+    elems = jnp.arange(num_elems)
+    results = scan_associative(
+        op,
+        elems,
+        axis=0
+    )
+    np.testing.assert_allclose(
+        results,
+        tfp.math.scan_associative(
+            op,
+            elems
+        )
+    )
+
+
+@pytest.mark.parametrize('num_elems', [10, 11])
+def test_scan_associative_pytee(num_elems):
+    class MockClass(NamedTuple):
+        x: jax.Array
+        y: jax.Array
+
+    def op(x: MockClass, y: MockClass) -> MockClass:
+        return MockClass(
+            x=x.x + y.x,
+            y=x.y + y.y
+        )
+
+    elems = MockClass(
+        x=jnp.arange(num_elems),
+        y=jnp.arange(num_elems)
+    )
+    results = scan_associative(
+        op,
+        elems,
+        axis=0
+    )
+    np.testing.assert_allclose(
+        results,
+        tfp.math.scan_associative(
+            op,
+            elems
+        )
+    )
+
+
+def test_scan_associative_rank_reducing():
+    def per_elem_op(x) -> jax.Array:
+        return jnp.sum(x)
+
+    def associative_op(x, y):
+        print(x.shape, y.shape)
+        assert np.shape(x) == np.shape(x)
+        assert np.shape(x) == ()
+        return per_elem_op(x) + per_elem_op(y)
+
+    xs = jnp.arange(10)
+    _ = scan_associative(associative_op, xs)
+
+
+@pytest.mark.parametrize('N', [32, 128, 512])
+@pytest.mark.parametrize('M', [32, 128, 512])
+def test_performance(N: int, M: int):
+    import tensorflow_probability.substrates.jax as tfp
+    inputs = jnp.ones((N, M, M))
+    op = jnp.linalg.matmul
+
+    fn_compiled = jax.jit(partial(tfp.math.scan_associative, fn=op)).lower(elems=inputs).compile()
+
+    m = 3
+
+    t0 = time.time()
+    for _ in range(m):
+        fn_compiled(elems=inputs).block_until_ready()
+    t1 = time.time()
+    tfp_runtime = (t1 - t0) / m
+
+    fn_compiled = jax.jit(partial(scan_associative, fn=op)).lower(elems=inputs).compile()
+
+    t0 = time.time()
+    for _ in range(m):
+        fn_compiled(elems=inputs).block_until_ready()
+    t1 = time.time()
+    internal_runtime = (t1 - t0) / m
+    print(f"sequence length {N}, matrix mul {M}x{M} @ {M}x{M}:")
+    print(f"\tRun time tfp.math.scan_associative {tfp_runtime}")
+    print(f"\tRun time internal scan_associative {internal_runtime}")
+    if internal_runtime < tfp_runtime:
+        print(f"Internal faster by {100. * (1. - internal_runtime / tfp_runtime)} %")
+    else:
+        print(f"tfp.math.scan_associative faster by {100. * (1. - tfp_runtime / internal_runtime)} %")
diff --git a/jaxns/tests/conftest.py b/jaxns/tests/conftest.py
index b6f1af55..eabf3760 100644
--- a/jaxns/tests/conftest.py
+++ b/jaxns/tests/conftest.py
@@ -1,11 +1,6 @@
-import os
 from time import monotonic_ns
 
 import jax
-
-# Force 2 jax  hosts
-os.environ["XLA_FLAGS"] = "--xla_force_host_platform_device_count=2"
-
 import pytest
 from jax import numpy as jnp, random
 from jax._src.scipy.linalg import solve_triangular
@@ -14,10 +9,10 @@
 from jaxns.framework.bases import PriorModelGen
 from jaxns.framework.model import Model
 from jaxns.framework.prior import Prior
+from jaxns.internals.types import TerminationCondition
 from jaxns.nested_sampler.standard_static import StandardStaticNestedSampler
 from jaxns.public import DefaultNestedSampler
 from jaxns.samplers.multi_ellipsoidal_samplers import MultiEllipsoidalSampler
-from jaxns.internals.types import TerminationCondition
 from jaxns.utils import bruteforce_evidence, summary
 
 # from jaxns.nested_sampler import ApproximateNestedSampler, ExactNestedSampler
@@ -301,7 +296,7 @@ def multiellipsoidal_mvn_run_results(basic_mvn_model):
         init_efficiency_threshold=0.1,
         model=model,
         num_live_points=model.U_ndims * 20,
-        num_parallel_workers=1,
+        devices=None,
         max_samples=50000,
         sampler=MultiEllipsoidalSampler(model=model, depth=0, expansion_factor=2.0),
         verbose=True
diff --git a/jaxns/tests/test_nested_sampler.py b/jaxns/tests/test_nested_sampler.py
index abf974ed..23d032ad 100644
--- a/jaxns/tests/test_nested_sampler.py
+++ b/jaxns/tests/test_nested_sampler.py
@@ -1,14 +1,9 @@
-import os
-
 import jax
+import numpy as np
 from jax import random, numpy as jnp
 
-# Force 2 jax  hosts
-os.environ["XLA_FLAGS"] = "--xla_force_host_platform_device_count=2"
-
 from jaxns import TerminationCondition
 from jaxns.utils import sample_evidence
-import numpy as np
 
 
 def test_nested_sampling_run_results(all_run_results):
diff --git a/jaxns/tests/test_utils.py b/jaxns/tests/test_utils.py
index dc12f1fd..6ea84c08 100644
--- a/jaxns/tests/test_utils.py
+++ b/jaxns/tests/test_utils.py
@@ -1,8 +1,11 @@
+from typing import NamedTuple
+
+import jax
 import numpy as np
 from jax import random, numpy as jnp
 
 from jaxns.plotting import weighted_percentile
-from jaxns.utils import resample, _bit_mask
+from jaxns.utils import resample, _bit_mask, save_pytree, load_pytree
 
 
 def test_resample():
@@ -24,3 +27,14 @@ def test_weighted_percentile():
     log_weights = np.asarray([0, 0, 0, 0, 0])
     percentiles = [50]
     assert np.allclose(weighted_percentile(samples, log_weights, percentiles), 3.0)
+
+
+class MockPyTree171(NamedTuple):
+    x: jax.Array
+
+
+def test_gh171(tmp_path):
+    pytree = MockPyTree171(jnp.array([1., 2., 3.]))
+    save_pytree(pytree, str(tmp_path / "results.json"))
+    loaded_pytree = load_pytree(str(tmp_path / "results.json"))
+    np.testing.assert_allclose(loaded_pytree.x, pytree.x)