diff --git a/.copier-answers.yml b/.copier-answers.yml
new file mode 100644
index 00000000..4256caa8
--- /dev/null
+++ b/.copier-answers.yml
@@ -0,0 +1,12 @@
+# Changes here will be overwritten by Copier; NEVER EDIT MANUALLY
+_commit: 2023.10.27
+_src_path: gh:scientific-python/cookie
+backend: hatch
+email: nstarman@users.noreply.github.com
+full_name: Nathaniel Starkman
+license: BSD
+org: nstarman
+project_name: galdynamix
+project_short_description: Galactic Dynamix in Jax
+url: https://github.com/nstarman/galdynamix
+vcs: true
diff --git a/.git_archival.txt b/.git_archival.txt
new file mode 100644
index 00000000..8fb235d7
--- /dev/null
+++ b/.git_archival.txt
@@ -0,0 +1,4 @@
+node: $Format:%H$
+node-date: $Format:%cI$
+describe-name: $Format:%(describe:tags=true,match=*[0-9]*)$
+ref-names: $Format:%D$
diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 00000000..00a7b00c
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1 @@
+.git_archival.txt  export-subst
diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md
new file mode 100644
index 00000000..73de9c63
--- /dev/null
+++ b/.github/CONTRIBUTING.md
@@ -0,0 +1,101 @@
+See the [Scientific Python Developer Guide][spc-dev-intro] for a detailed
+description of best practices for developing scientific packages.
+
+[spc-dev-intro]: https://learn.scientific-python.org/development/
+
+# Quick development
+
+The fastest way to start with development is to use nox. If you don't have nox,
+you can use `pipx run nox` to run it without installing, or `pipx install nox`.
+If you don't have pipx (pip for applications), then you can install with
+`pip install pipx` (the only case were installing an application with regular
+pip is reasonable). If you use macOS, then pipx and nox are both in brew, use
+`brew install pipx nox`.
+
+To use, run `nox`. This will lint and test using every installed version of
+Python on your system, skipping ones that are not installed. You can also run
+specific jobs:
+
+```console
+$ nox -s lint  # Lint only
+$ nox -s tests  # Python tests
+$ nox -s docs -- serve  # Build and serve the docs
+$ nox -s build  # Make an SDist and wheel
+```
+
+Nox handles everything for you, including setting up an temporary virtual
+environment for each run.
+
+# Setting up a development environment manually
+
+You can set up a development environment by running:
+
+```bash
+python3 -m venv .venv
+source ./.venv/bin/activate
+pip install -v -e .[dev]
+```
+
+If you have the
+[Python Launcher for Unix](https://github.com/brettcannon/python-launcher), you
+can instead do:
+
+```bash
+py -m venv .venv
+py -m install -v -e .[dev]
+```
+
+# Post setup
+
+You should prepare pre-commit, which will help you by checking that commits pass
+required checks:
+
+```bash
+pip install pre-commit # or brew install pre-commit on macOS
+pre-commit install # Will install a pre-commit hook into the git repo
+```
+
+You can also/alternatively run `pre-commit run` (changes only) or
+`pre-commit run --all-files` to check even without installing the hook.
+
+# Testing
+
+Use pytest to run the unit checks:
+
+```bash
+pytest
+```
+
+# Coverage
+
+Use pytest-cov to generate coverage reports:
+
+```bash
+pytest --cov=galdynamix
+```
+
+# Building docs
+
+You can build the docs using:
+
+```bash
+nox -s docs
+```
+
+You can see a preview with:
+
+```bash
+nox -s docs -- serve
+```
+
+# Pre-commit
+
+This project uses pre-commit for all style checking. While you can run it with
+nox, this is such an important tool that it deserves to be installed on its own.
+Install pre-commit and run:
+
+```bash
+pre-commit run -a
+```
+
+to check all files.
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 00000000..6fddca0d
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,7 @@
+version: 2
+updates:
+  # Maintain dependencies for GitHub Actions
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
diff --git a/.github/matchers/pylint.json b/.github/matchers/pylint.json
new file mode 100644
index 00000000..e3a6bd16
--- /dev/null
+++ b/.github/matchers/pylint.json
@@ -0,0 +1,32 @@
+{
+  "problemMatcher": [
+    {
+      "severity": "warning",
+      "pattern": [
+        {
+          "regexp": "^([^:]+):(\\d+):(\\d+): ([A-DF-Z]\\d+): \\033\\[[\\d;]+m([^\\033]+).*$",
+          "file": 1,
+          "line": 2,
+          "column": 3,
+          "code": 4,
+          "message": 5
+        }
+      ],
+      "owner": "pylint-warning"
+    },
+    {
+      "severity": "error",
+      "pattern": [
+        {
+          "regexp": "^([^:]+):(\\d+):(\\d+): (E\\d+): \\033\\[[\\d;]+m([^\\033]+).*$",
+          "file": 1,
+          "line": 2,
+          "column": 3,
+          "code": 4,
+          "message": 5
+        }
+      ],
+      "owner": "pylint-error"
+    }
+  ]
+}
diff --git a/.github/workflows/cd.yml b/.github/workflows/cd.yml
new file mode 100644
index 00000000..5100345d
--- /dev/null
+++ b/.github/workflows/cd.yml
@@ -0,0 +1,60 @@
+name: CD
+
+on:
+  workflow_dispatch:
+  pull_request:
+  push:
+    branches:
+      - main
+  release:
+    types:
+      - published
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  FORCE_COLOR: 3
+
+jobs:
+  dist:
+    name: Distribution build
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Build sdist and wheel
+        run: pipx run build
+
+      - uses: actions/upload-artifact@v3
+        with:
+          path: dist
+
+      - name: Check products
+        run: pipx run twine check dist/*
+
+  publish:
+    needs: [dist]
+    name: Publish to PyPI
+    environment: pypi
+    permissions:
+      id-token: write
+    runs-on: ubuntu-latest
+    if: github.event_name == 'release' && github.event.action == 'published'
+
+    steps:
+      - uses: actions/download-artifact@v3
+        with:
+          name: artifact
+          path: dist
+
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        if: github.event_name == 'release' && github.event.action == 'published'
+        with:
+          # Remember to tell (test-)pypi about this repo before publishing
+          # Remove this line to publish to PyPI
+          repository-url: https://test.pypi.org/legacy/
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 00000000..36abf675
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,69 @@
+name: CI
+
+on:
+  workflow_dispatch:
+  pull_request:
+  push:
+    branches:
+      - main
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  FORCE_COLOR: 3
+
+jobs:
+  pre-commit:
+    name: Format
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-python@v4
+        with:
+          python-version: "3.x"
+      - uses: pre-commit/action@v3.0.0
+        with:
+          extra_args: --hook-stage manual --all-files
+      - name: Run PyLint
+        run: |
+          echo "::add-matcher::$GITHUB_WORKSPACE/.github/matchers/pylint.json"
+          pipx run nox -s pylint
+
+  checks:
+    name: Check Python ${{ matrix.python-version }} on ${{ matrix.runs-on }}
+    runs-on: ${{ matrix.runs-on }}
+    needs: [pre-commit]
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.8", "3.12"]
+        runs-on: [ubuntu-latest, macos-latest, windows-latest]
+
+        include:
+          - python-version: pypy-3.10
+            runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+          allow-prereleases: true
+
+      - name: Install package
+        run: python -m pip install .[test]
+
+      - name: Test package
+        run: >-
+          python -m pytest -ra --cov --cov-report=xml --cov-report=term
+          --durations=20
+
+      - name: Upload coverage report
+        uses: codecov/codecov-action@v3.1.4
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 00000000..7f43fbaa
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,159 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# setuptools_scm
+src/*/_version.py
+
+
+# ruff
+.ruff_cache/
+
+# OS specific stuff
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Common editor files
+*~
+*.swp
+/scratch
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 00000000..ecba3594
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,90 @@
+ci:
+  autoupdate_commit_msg: "chore: update pre-commit hooks"
+  autofix_commit_msg: "style: pre-commit fixes"
+
+repos:
+  - repo: https://github.com/psf/black-pre-commit-mirror
+    rev: "23.10.1"
+    hooks:
+      - id: black-jupyter
+
+  - repo: https://github.com/adamchainz/blacken-docs
+    rev: "1.16.0"
+    hooks:
+      - id: blacken-docs
+        additional_dependencies: [black==23.*]
+
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: "v4.5.0"
+    hooks:
+      - id: check-added-large-files
+      - id: check-case-conflict
+      - id: check-merge-conflict
+      - id: check-symlinks
+      - id: check-yaml
+      - id: debug-statements
+      - id: end-of-file-fixer
+      - id: mixed-line-ending
+      - id: name-tests-test
+        args: ["--pytest-test-first"]
+      - id: requirements-txt-fixer
+      - id: trailing-whitespace
+
+  - repo: https://github.com/pre-commit/pygrep-hooks
+    rev: "v1.10.0"
+    hooks:
+      - id: rst-backticks
+      - id: rst-directive-colons
+      - id: rst-inline-touching-normal
+
+  - repo: https://github.com/pre-commit/mirrors-prettier
+    rev: "v3.0.3"
+    hooks:
+      - id: prettier
+        types_or: [yaml, markdown, html, css, scss, javascript, json]
+        args: [--prose-wrap=always]
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: "v0.1.3"
+    hooks:
+      - id: ruff
+        args: ["--fix", "--show-fixes"]
+
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: "v1.6.1"
+    hooks:
+      - id: mypy
+        files: src|tests
+        args: []
+        additional_dependencies:
+          - pytest
+
+  - repo: https://github.com/codespell-project/codespell
+    rev: "v2.2.6"
+    hooks:
+      - id: codespell
+
+  - repo: https://github.com/shellcheck-py/shellcheck-py
+    rev: "v0.9.0.6"
+    hooks:
+      - id: shellcheck
+
+  - repo: local
+    hooks:
+      - id: disallow-caps
+        name: Disallow improper capitalization
+        language: pygrep
+        entry: PyBind|Numpy|Cmake|CCache|Github|PyTest
+        exclude: .pre-commit-config.yaml
+
+  - repo: https://github.com/abravalheri/validate-pyproject
+    rev: v0.15
+    hooks:
+      - id: validate-pyproject
+
+  - repo: https://github.com/python-jsonschema/check-jsonschema
+    rev: 0.27.0
+    hooks:
+      - id: check-dependabot
+      - id: check-github-workflows
+      - id: check-readthedocs
diff --git a/.readthedocs.yml b/.readthedocs.yml
new file mode 100644
index 00000000..7e496574
--- /dev/null
+++ b/.readthedocs.yml
@@ -0,0 +1,18 @@
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+version: 2
+
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.11"
+sphinx:
+  configuration: docs/conf.py
+
+python:
+  install:
+    - method: pip
+      path: .
+      extra_requirements:
+        - docs
diff --git a/FurtherTuned_jaxvgala_mockstream_Samemasses.pdf b/FurtherTuned_jaxvgala_mockstream_Samemasses.pdf
deleted file mode 100644
index 3db33a99..00000000
Binary files a/FurtherTuned_jaxvgala_mockstream_Samemasses.pdf and /dev/null differ
diff --git a/JaxStreams.py b/JaxStreams.py
deleted file mode 100644
index c53779de..00000000
--- a/JaxStreams.py
+++ /dev/null
@@ -1,515 +0,0 @@
-from functools import partial
-from astropy.constants import G
-import astropy.coordinates as coord
-import astropy.units as u
-# gala
-import gala.coordinates as gc
-import gala.dynamics as gd
-import gala.potential as gp
-from gala.units import dimensionless, galactic, UnitSystem
-
-import jax
-import jax.numpy as jnp
-
-from jax.config import config
-config.update("jax_enable_x64", True)
-import jax.random as random 
-from jax_cosmo.scipy.interpolate import InterpolatedUnivariateSpline
-usys = UnitSystem(u.kpc, u.Myr, u.Msun, u.radian)
-
-class Potential:
-    
-    def __init__(self, units, params):
-        if units is None:
-            units = dimensionless
-        self.units = UnitSystem(units)
-        
-        if self.units == dimensionless:
-            self._G = 1
-        else:
-            self._G = G.decompose(self.units).value
-        
-        for name, param in params.items():
-            if hasattr(param, 'unit'):
-                param = param.decompose(self.units).value
-            setattr(self, name, param)
-    
-    @partial(jax.jit, static_argnums=(0,))
-    def gradient(self, xyz, t):
-        grad_func = jax.grad(self.potential)
-        return grad_func(xyz, t)
-    
-    @partial(jax.jit, static_argnums=(0,))
-    def density(self, xyz, t):
-        lap = jnp.trace(jax.hessian(self.potential)(xyz, t))
-        return lap / (4 * jnp.pi * self._G)
-    
-    @partial(jax.jit, static_argnums=(0,))
-    def acceleration(self, xyz, t):
-        return -self.gradient(xyz, t)
-    
-   
-    @partial(jax.jit,static_argnums=(0,))
-    def jacobian_force_mw(self, xyz, t):
-        jacobian_force_mw = jax.jacfwd(self.gradient)
-        return jacobian_force_mw(xyz, t)
-    
-    @partial(jax.jit,static_argnums=(0,))
-    def d2phidr2_mw(self, x, t):
-        """
-        Computes the second derivative of the Milky Way potential at a position x (in the simulation frame)
-        Args:
-          x: 3d position (x, y, z) in [kpc]
-        Returns:
-          Second derivative of force (per unit mass) in [1/Myr^2]
-        Examples
-        --------
-        >>> d2phidr2_mw(x=jnp.array([8.0, 0.0, 0.0]))
-        """
-        rad = jnp.linalg.norm(x)
-        r_hat = x/rad
-        dphi_dr_func = lambda x: jnp.sum(self.gradient(x,t)*r_hat)
-        return jnp.sum(jax.grad(dphi_dr_func)(x)*r_hat)
-        
-        ##return jnp.matmul(jnp.transpose(x), jnp.matmul(self.jacobian_force_mw(x, t), x)) / rad**2
-
-
-    @partial(jax.jit,static_argnums=(0,))
-    def omega(self, x,v):
-        """
-        Computes the magnitude of the angular momentum in the simulation frame
-        Args:
-          x: 3d position (x, y, z) in [kpc]
-          v: 3d velocity (v_x, v_y, v_z) in [kpc/Myr]
-        Returns:
-          Magnitude of angular momentum in [rad/Myr]
-        Examples
-        --------
-        >>> omega(x=jnp.array([8.0, 0.0, 0.0]), v=jnp.array([8.0, 0.0, 0.0]))
-        """
-        rad = jnp.sqrt(x[0] ** 2 + x[1] ** 2 + x[2] ** 2)
-        omega_vec = jnp.cross(x, v) / (rad**2)
-        return jnp.linalg.norm(omega_vec)
-
-    @partial(jax.jit,static_argnums=(0,))
-    def tidalr_mw(self, x, v, Msat, t):
-        """
-        Computes the tidal radius of a cluster in the potential
-        Args:
-          x: 3d position (x, y, z) in [kpc]
-          v: 3d velocity (v_x, v_y, v_z) in [kpc/Myr]
-          Msat: Cluster mass in [Msol]
-        Returns:
-          Tidal radius of the cluster in [kpc]
-        Examples
-        --------
-        >>> tidalr_mw(x=jnp.array([8.0, 0.0, 0.0]), v=jnp.array([8.0, 0.0, 0.0]), Msat=1e4)
-        """
-        return (self._G * Msat / ( self.omega(x, v) ** 2 - self.d2phidr2_mw(x, t)) ) ** (1.0 / 3.0)
-    
-    @partial(jax.jit,static_argnums=(0,))
-    def lagrange_pts(self,x,v,Msat, t):
-        r_tidal = self.tidalr_mw(x,v,Msat, t)
-        r_hat = x/jnp.linalg.norm(x)
-        L_close = x - r_hat*r_tidal
-        L_far = x + r_hat*r_tidal
-        return L_close, L_far
-    
-    @partial(jax.jit,static_argnums=(0,))
-    def release_model(self, x, v, Msat,i, t):
-        """
-        Simplification of particle spray: just release particles in gaussian blob at each lagrange point.
-        User sets the spatial and velocity dispersion for the "leaking" of particles
-        TODO: change random key handling... need to do all of the sampling up front...
-        """
-        keya = jax.random.PRNGKey(i*13)
-        keyb = jax.random.PRNGKey(i*23)
-        
-        keyc = jax.random.PRNGKey(i*27)
-        keyd = jax.random.PRNGKey(i*3)
-        keye = jax.random.PRNGKey(i*17)
-        
-        L_close, L_far = self.lagrange_pts(x,v,Msat, t) # each is an xyz array
-        
-        omega_val = self.omega(x,v)
-        
-        
-        r = jnp.linalg.norm(x)
-        r_hat = x/r
-        r_tidal = self.tidalr_mw(x,v,Msat, t)
-        rel_v = omega_val*r_tidal #relative velocity
-        
-        #circlar_velocity
-        dphi_dr = jnp.sum(self.gradient(x, t)*r_hat)
-        v_circ = rel_v##jnp.sqrt( r*dphi_dr )
-        
-        L_vec = jnp.cross(x,v)
-        z_hat = L_vec / jnp.linalg.norm(L_vec)
-        
-        phi_vec = v - jnp.sum(v*r_hat)*r_hat
-        phi_hat = phi_vec/jnp.linalg.norm(phi_vec)
-        vt_sat = jnp.sum(v*phi_hat)
-        
-        
-        kr_bar = 2.0
-        kvphi_bar = 0.3
-        ####################kvt_bar = 0.3 ## FROM GALA
-        
-        kz_bar = 0.0
-        kvz_bar = 0.0
-        
-        sigma_kr = 0.5
-        sigma_kvphi = 0.5
-        sigma_kz = 0.5
-        sigma_kvz = 0.5
-        ##############sigma_kvt = 0.5 ##FROM GALA
-        
-        kr_samp =  kr_bar + jax.random.normal(keya,shape=(1,))*sigma_kr
-        kvphi_samp = kr_samp*(kvphi_bar  + jax.random.normal(keyb,shape=(1,))*sigma_kvphi)
-        kz_samp = kz_bar + jax.random.normal(keyc,shape=(1,))*sigma_kz
-        kvz_samp = kvz_bar + jax.random.normal(keyd,shape=(1,))*sigma_kvz
-        ########kvt_samp = kvt_bar + jax.random.normal(keye,shape=(1,))*sigma_kvt
-        
-        ## Trailing arm
-        pos_trail = x + kr_samp*r_hat*(r_tidal) #nudge out
-        pos_trail  = pos_trail + z_hat*kz_samp*(r_tidal/1.0)#r #nudge above/below orbital plane
-        v_trail = v + (0.0 + kvphi_samp*v_circ*(1.0))*phi_hat#v + (0.0 + kvphi_samp*v_circ*(-r_tidal/r))*phi_hat #nudge velocity along tangential direction
-        v_trail = v_trail + (kvz_samp*v_circ*(1.0))*z_hat#v_trail + (kvz_samp*v_circ*(-r_tidal/r))*z_hat #nudge velocity along vertical direction
-        
-        ## Leading arm
-        pos_lead = x + kr_samp*r_hat*(-r_tidal) #nudge in
-        pos_lead  = pos_lead + z_hat*kz_samp*(-r_tidal/1.0)#r #nudge above/below orbital plane
-        v_lead = v + (0.0 + kvphi_samp*v_circ*(-1.0))*phi_hat#v + (0.0 + kvphi_samp*v_circ*(r_tidal/r))*phi_hat #nudge velocity along tangential direction
-        v_lead = v_lead + (kvz_samp*v_circ*(-1.0))*z_hat#v_lead + (kvz_samp*v_circ*(r_tidal/r))*z_hat #nudge velocity against vertical direction
-        
-    
-        
-        
-        return pos_lead, pos_trail, v_lead, v_trail
-    
-    @partial(jax.jit,static_argnums=(0,))
-    def gen_stream_ics(self, ts, prog_w0, Msat):
-        ws_jax = leapfrog_run(prog_w0, ts, self.gradient)
-        
-        def scan_fun(carry, t):
-            i, pos_close, pos_far, vel_close, vel_far = carry
-            pos_close_new, pos_far_new, vel_close_new, vel_far_new = self.release_model(ws_jax[i,:3], ws_jax[i,3:], Msat,i, t)
-            return [i+1, pos_close_new, pos_far_new, vel_close_new, vel_far_new], [pos_close_new, pos_far_new, vel_close_new, vel_far_new]#[i+1, pos_close_new, pos_far_new, vel_close_new, vel_far_new]
-            
-            
-        #init_carry = [0, 0, 0, 0, 0]
-        init_carry = [0, jnp.array([0.0,0.0,0.]), jnp.array([0.0,0.0,0.]), jnp.array([0.0,0.0,0.]), jnp.array([0.0,0.0,0.])] 
-        final_state, all_states = jax.lax.scan(scan_fun, init_carry, ts[1:])
-        pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr = all_states
-        return pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr
-    
-    @partial(jax.jit,static_argnums=(0,))
-    def gen_stream(self, ts, prog_w0, Msat):
-        pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr = self.gen_stream_ics(ts, prog_w0, Msat)
-        
-        def scan_fun(carry, particle_idx):
-            i, pos_close_curr, pos_far_curr, vel_close_curr, vel_far_curr = carry
-            curr_particle_w0_close = jnp.hstack([pos_close_curr,vel_close_curr])
-            curr_particle_w0_far = jnp.hstack([pos_far_curr,vel_far_curr])
-            #print(curr_particle_w0_close.shape)
-            #indices = jnp.arange(i,len(ts))
-            #t_particle = jnp.take(ts, indices)
-            #################t_particle = jax.lax.slice(ts,(i,),(len(ts),))
-            w_particle_close = leapfrog_run(curr_particle_w0_close, ts, self.gradient)
-            w_particle_far = leapfrog_run(curr_particle_w0_far, ts, self.gradient)
-            
-            ###ts_update = jax.lax.dynamic_slice(ts_curr,(i+1,),(len(ts_curr)-1,))
-            
-            return [i+1, pos_close_arr[i+1,:], pos_far_arr[i+1,:], vel_close_arr[i+1,:], vel_far_arr[i+1,:]], [w_particle_close, w_particle_far]
-        init_carry = [0, pos_close_arr[0,:], pos_far_arr[0,:], vel_close_arr[0,:], vel_far_arr[0,:]]
-        particle_ids = jnp.arange(len(pos_close_arr))
-        final_state, all_states = jax.lax.scan(scan_fun, init_carry, particle_ids)
-        lead_arm, trail_arm = all_states
-        return lead_arm, trail_arm
-            
-    @partial(jax.jit,static_argnums=(0,))
-    def gen_stream_final(self, ts, prog_w0, Msat):
-        pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr = self.gen_stream_ics(ts, prog_w0, Msat,)
-        
-        def scan_fun(carry, particle_idx):
-            i, pos_close_curr, pos_far_curr, vel_close_curr, vel_far_curr = carry
-            curr_particle_w0_close = jnp.hstack([pos_close_curr,vel_close_curr])
-            curr_particle_w0_far = jnp.hstack([pos_far_curr,vel_far_curr])
-            #print(curr_particle_w0_close.shape)
-            #indices = jnp.arange(i,len(ts))
-            #t_particle = jnp.take(ts, indices)
-            
-            #######t_particle = jax.lax.slice(ts,(i,),(len(ts),))
-            minval, maxval =  ts[i],ts[-1]#jnp.min(jax.lax.dynamic_slice(ts,(i,),(len(ts)-i,))), jnp.max(jax.lax.dynamic_slice(ts,(i,),(len(ts)-i,)))
-            ###t_particle = ts.at[:i].set( jnp.nan )
-            #######################t_particle = jnp.linspace(minval,maxval,len(ts))#jax.lax.dynamic_slice(ts,minval,(len(ts)-i,))##jax.lax.dynamic_slice(ts,(i+1,),(len(ts)-1,))
-            t_particle = jax.vmap(ts_func,in_axes=(0,None),)(ts,ts[i])
-            ###################################t_particle = get_t_arr(ts,ts[i]) OLD
-            ##print(t_particle)
-            w_particle_close = leapfrog_run(curr_particle_w0_close, t_particle, self.gradient)
-            w_particle_far = leapfrog_run(curr_particle_w0_far, t_particle, self.gradient)
-            
-            w_particle_close = w_particle_close[-1,:]#w_particle_close[-1,:]
-            w_particle_far = w_particle_far[-1,:]#w_particle_far[-1,:]
-            
-            
-            return [i+1, pos_close_arr[i+1,:], pos_far_arr[i+1,:], vel_close_arr[i+1,:], vel_far_arr[i+1,:]], [w_particle_close, w_particle_far]
-        init_carry = [0, pos_close_arr[0,:], pos_far_arr[0,:], vel_close_arr[0,:], vel_far_arr[0,:]]
-        particle_ids = jnp.arange(len(pos_close_arr))
-        #print(len(particle_ids))
-        final_state, all_states = jax.lax.scan(scan_fun, init_carry, particle_ids)
-        #print(final_state)
-        lead_arm, trail_arm = all_states
-        return lead_arm, trail_arm##lead_arm, trail_arm
-    
-    @partial(jax.jit,static_argnums=(0,))
-    def gen_stream_vmapped(self, ts, prog_w0, Msat):
-        pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr = self.gen_stream_ics(ts, prog_w0, Msat)
-        @jax.jit
-        def single_particle_integrate(particle_number,pos_close_curr,pos_far_curr,vel_close_curr,vel_far_curr):
-            curr_particle_w0_close = jnp.hstack([pos_close_curr,vel_close_curr])
-            curr_particle_w0_far = jnp.hstack([pos_far_curr,vel_far_curr])
-            t_particle = jax.vmap(ts_func,in_axes=(0,None),)(ts,ts[particle_number])
-            w_particle_close = leapfrog_run(curr_particle_w0_close, t_particle, self.gradient)
-            w_particle_far = leapfrog_run(curr_particle_w0_far, t_particle, self.gradient)
-            
-            w_particle_close = w_particle_close[-1,:]
-            w_particle_far = w_particle_far[-1,:]
-            
-            
-            return w_particle_close, w_particle_far
-        particle_ids = jnp.arange(len(pos_close_arr))
-        
-        return jax.vmap(single_particle_integrate,in_axes=(0,0,0,0,0,))(particle_ids,pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr)
-
-    
-
-class Isochrone(Potential):
-    
-    def __init__(self, m, a, units=None):
-        super().__init__(units, {'m': m, 'a': a})
-    
-    @partial(jax.jit, static_argnums=(0,))
-    def potential(self, xyz, t):
-        r = jnp.linalg.norm(xyz, axis=0)
-        return - self._G * self.m / (self.a + jnp.sqrt(r**2 + self.a**2))
-    
-
-    
-class Isochrone_centered(Potential):
-    
-    def __init__(self, m, a, spline_eval_func, splines, t_min, t_max, m_ext, a_ext, units=None):
-        super().__init__(units, {'m': m, 'a': a, 'spline_eval_func': spline_eval_func, 'splines': splines, 't_min': t_min, 't_max': t_max,
-                                'm_ext': m_ext, 'a_ext': a_ext})
-    
-    @partial(jax.jit, static_argnums=(0,))
-    def potential(self, xyz, t):
-        is_cond_met = (t > self.t_min) & (t < self.t_max) # True if yes, False if no
-        pot_ext = Isochrone(m=self.m_ext, a=self.a_ext, units=self.units) 
-        
-        def true_func(xyz_t):
-            xyz_, t = xyz_t[:3], xyz_t[-1]
-            xyz = xyz_ - self.spline_eval_func(t,self.splines)
-            r = jnp.linalg.norm(xyz, axis=0)
-            return - self._G * self.m / (self.a + jnp.sqrt(r**2 + self.a**2))  + pot_ext.potential(xyz_,t)#+ self.pot_ext.potential(xyz_,t)
-        def false_func(xyz_t):
-            xyz, t = xyz_t[:3], xyz_t[-1]
-            return pot_ext.potential(xyz,t)#0.#self.pot_ext.potential(xyz,t)
-        xyz_t = jnp.hstack([xyz,t])
-        return jax.lax.cond(pred=is_cond_met, true_fun=true_func, false_fun=false_func,operand=xyz_t)
-    
-class MiyamotoNagaiDisk(Potential):
-    def __init__(self, m, a, b, units=None):
-        super().__init__(units, {'m': m, 'a': a, 'b': b,})
-    @partial(jax.jit,static_argnums=(0,))
-    def potential(self,xyz,t):
-        R2 = xyz[0]**2 + xyz[1]**2
-        return -self._G*self.m / jnp.sqrt(R2 + jnp.square(jnp.sqrt(xyz[2]**2 + self.b**2) + self.a))
-    
-class NFWPotential_holder(Potential):
-    """
-    Flattening in potential, not density
-    Form from http://gala.adrian.pw/en/v0.1.2/api/gala.potential.FlattenedNFWPotential.html
-    """
-    def __init__(self, v_c, r_s, q, units=None):
-        super().__init__(units, {'v_c': v_c, 'r_s': r_s, 'q': q})
-    @partial(jax.jit,static_argnums=(0,))
-    def potential(self,xyz,t):
-        m = jnp.sqrt(xyz[0]**2 + xyz[1]**2 + (xyz[2]/self.q)**2)
-        return -((self.v_c**2)/jnp.sqrt(jnp.log(2.0)-0.5) )*jnp.log(1.0 + m/self.r_s)/(m/self.r_s)
-    
-class NFWPotential(Potential):
-    """
-    standard def see spherical model @ https://github.com/adrn/gala/blob/main/gala/potential/potential/builtin/builtin_potentials.c
-    """
-    def __init__(self, m, r_s, units=None):
-        super().__init__(units, {'m': m, 'r_s': r_s})
-    @partial(jax.jit,static_argnums=(0,))
-    def potential(self,xyz,t):
-        v_h2 = -self._G*self.m/self.r_s
-        m = jnp.sqrt(xyz[0]**2 + xyz[1]**2 + xyz[2]**2 + .001)/self.r_s ##added softening!
-        return v_h2*jnp.log(1.0+ m) / m#-((self.v_c**2)/jnp.sqrt(jnp.log(2.0)-0.5) )*jnp.log(1.0 + m/self.r_s)/(m/self.r_s)
-    
-    
-class BarPotential(Potential):
-    """
-    Rotating bar potentil, with hard-coded rotation.
-    Eq 8a in https://articles.adsabs.harvard.edu/pdf/1992ApJ...397...44L
-    Rz according to https://en.wikipedia.org/wiki/Rotation_matrix
-    """
-    def __init__(self, m, a, b, c, Omega, units=None):
-        super().__init__(units, {'m': m, 'a': a, 'b': b, 'c': c, 'Omega': Omega})
-    @partial(jax.jit,static_argnums=(0,))
-    def potential(self,xyz,t):
-        ## First take the simulation frame coordinates and rotate them by Omega*t
-        ang = -self.Omega*t
-        Rot_mat = jnp.array([[jnp.cos(ang), -jnp.sin(ang), 0], [jnp.sin(ang), jnp.cos(ang), 0.], [0.0, 0.0, 1.0] ])
-        Rot_inv = jnp.linalg.inv(Rot_mat)
-        xyz_corot = jnp.matmul(Rot_mat,xyz)
-        
-        T_plus = jnp.sqrt( (self.a + xyz_corot[0])**2 + xyz_corot[1]**2 + ( self.b + jnp.sqrt(self.c**2 + xyz_corot[2]**2) )**2 )
-        T_minus = jnp.sqrt( (self.a - xyz_corot[0])**2 + xyz_corot[1]**2 + ( self.b + jnp.sqrt(self.c**2 + xyz_corot[2]**2) )**2 )
-        
-        pot_corot_frame = (self._G*self.m/(2.0*self.a))*jnp.log( (xyz_corot[0] - self.a + T_minus)/(xyz_corot[0] + self.a + T_plus) )
-        return pot_corot_frame
-    
-    
-class Potential_Combine(Potential):
-    def __init__(self, potential_list, units=None):
-        super().__init__(units, {'potential_list': potential_list })
-    
-    @partial(jax.jit,static_argnums=(0,))
-    def potential(self, xyz, t,):
-        output = []
-        for i in range(len(self.potential_list)):
-            output.append(self.potential_list[i].potential(xyz,t))
-        return jnp.sum(jnp.array(output))
-    
-    
-def leapfrog_step(func, y0, t0, dt, a0):
-    ndim = y0.shape[0] // 2
-    tf = t0 + dt
-    
-    x0 = y0[:ndim]
-    v0 = y0[ndim:]
-    
-    v1_2 = v0 + a0 * dt / 2.
-    xf = x0 + v1_2 * dt
-    af = - func(xf, tf)
-    
-    vf = v1_2 + af * dt / 2
-    
-    return tf, jnp.concatenate((xf, vf)), af
-
-@partial(jax.jit, static_argnames=['potential_gradient', 'args'])
-def leapfrog_run(w0, ts, potential_gradient, args=()):
-    func_ = lambda y, t: potential_gradient(y, t, *args)
-    
-    def scan_fun(carry, t):
-        i, y0, t0, dt, a0 = carry
-        tf, yf, af = leapfrog_step(func_, y0, t0, dt, a0)
-        dt_new = ts[i+1] - ts[i]
-        is_cond_met = dt_new > 0.
-        
-        def true_func(dt_new):
-            return ts[-1]-ts[-2] #dt_base !!!ASSUMING dt = 0.5 Myr by default!!!!
-        def false_func(dt_new):
-            return 0.0
-        dt_new = jax.lax.cond(pred=is_cond_met, true_fun=true_func, false_fun=false_func,operand=dt_new)
-        
-        ###tf = tf + dt_new
-        return [i + 1, yf, tf, dt_new, af], yf
-    
-    ndim = w0.shape[0] // 2
-    a0 = func_(w0[:ndim], ts[0])
-    dt = ts[1]-ts[0] ## I ADDED THIS
-    init_carry = [0, w0, ts[0], dt, a0]
-    _, ws = jax.lax.scan(scan_fun, init_carry, ts[1:])
-    res_ws = jnp.concatenate((w0[None], ws))
-    
-    return res_ws
-
-def compute_orbit_and_gradients(params,w0,dt,n_steps,units):
-    pot = Hernquist(m=params['m'], a=params['a'],units=units,)  # Create the potential with the given parameters
-    
-    # Example Orbit:
-    #w0 = jnp.array([10, 0, 0, 0, .204, 0])
-    t0 = 0
-    #dt = 0.1
-    #n_steps = 10000
-    ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)
-    
-    ### Compute the orbit with the provided potential
-    ws_jax = leapfrog_run(w0, ts, pot.gradient)
-    
-    # Compute the gradient of the final position with respect to the potential parameters
-    def gradient_fn(params):
-        pot_with_params = Hernquist(m=params['m'], a=params['a'],units=units)
-        ws_with_params = leapfrog_run(w0, ts, pot_with_params.gradient)
-        final_position = ws_with_params[-1, :]  # Extract final position
-        return final_position
-    
-    # Compute the gradient using JAX's autodiff
-    gradient = jax.jacfwd(gradient_fn)(params)
-    
-    return ws_jax, gradient
-
-def get_stripping_time_arr(ts):
-    """
-    assuming a particle is released for index in the ts array
-    TODO: Custom release
-    """
-    t_release_arr = []
-    for i in range(len(ts)):
-        t_release_arr.append( ts[i:] )
-    return t_release_arr
-
-#def get_spl_funcs(ts,ws):
-#    return [InterpolatedUnivariateSpline(ts,ws[:,i],k=3) for i in range(3)]
-
-#def eval_spl_funcs(ts, spl_funcs):
-#    return jnp.array([spl_funcs[i](ts) for i in range(3)])
-
-@jax.jit
-def get_t_arr(ts,t_min):
-    def scan_fun(carry, t):
-        i, ts_curr = carry
-        
-        def true_func(ts_curr):
-            return ts_curr
-        def false_func(ts_curr):
-            return 0.0
-        is_cond_met = ts_curr > t_min
-        val_fill = jax.lax.cond(pred=is_cond_met, true_fun=true_func, false_fun=false_func,operand=ts_curr)
-        
-        return [i + 1,ts[i+1]], val_fill
-    init_carry = [0,ts[0]]
-    __, t_particle = jax.lax.scan(scan_fun, init_carry, ts)
-    return t_particle
-
-@jax.jit
-def ts_func(t,t_min):
-    def true_func(ts_curr):
-        return ts_curr
-    def false_func(ts_curr):
-        return 0.0
-    is_cond_met = t > t_min
-    return jax.lax.cond(pred=is_cond_met, true_fun=true_func, false_fun=false_func,operand=t)
-
-
-
-@jax.jit
-def get_rot_mat(n_hat):
-    """
-    Get rotation matrix that transforms from INERTIAL coordinates to SATELLITE coordinates
-    https://math.stackexchange.com/questions/1956699/getting-a-transformation-matrix-from-a-normal-vector
-    """
-    nx,ny,nz = n_hat
-    nx_ny = jnp.sqrt(nx**2 + ny**2)
-    return jnp.array([[ny/nx_ny, -nx/nx_ny, 0], [nx*nz/nx_ny, ny*nz/nx_ny, -nx_ny], [nx,ny,nz]])
-
-def get_spl_funcs(ts,ws):
-    return [InterpolatedUnivariateSpline(ts,ws[:,0],k=3),InterpolatedUnivariateSpline(ts,ws[:,1],k=3), InterpolatedUnivariateSpline(ts,ws[:,2],k=3)]
-
-def eval_spl_funcs(ts, spl_funcs):
-    return jnp.array([spl_funcs[0](ts),spl_funcs[1](ts),spl_funcs[2](ts)])
\ No newline at end of file
diff --git a/JaxStreamsDemo.ipynb b/JaxStreamsDemo.ipynb
deleted file mode 100644
index 8cf0aeac..00000000
--- a/JaxStreamsDemo.ipynb
+++ /dev/null
@@ -1,439 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "1b444d9d-3a14-419f-a35c-a2da4302160a",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u001b[91mA new version of galpy (1.9.0) is available, please upgrade using pip/conda/... to get the latest features and bug fixes!\u001b[0m\n"
-     ]
-    }
-   ],
-   "source": [
-    "from functools import partial\n",
-    "\n",
-    "from astropy.constants import G\n",
-    "import astropy.coordinates as coord\n",
-    "import astropy.units as u\n",
-    "import matplotlib as mpl\n",
-    "import matplotlib.pyplot as plt\n",
-    "%matplotlib inline\n",
-    "import numpy as np\n",
-    "\n",
-    "# gala\n",
-    "import gala.coordinates as gc\n",
-    "import gala.dynamics as gd\n",
-    "import gala.potential as gp\n",
-    "from gala.units import dimensionless, galactic, UnitSystem\n",
-    "\n",
-    "import jax\n",
-    "import jax.numpy as jnp\n",
-    "\n",
-    "from jax.config import config\n",
-    "config.update(\"jax_enable_x64\", True)\n",
-    "\n",
-    "import scienceplots\n",
-    "import cmasher as cmr\n",
-    "plt.style.use('science')\n",
-    "import jax.random as random \n",
-    "from matplotlib.patches import Ellipse\n",
-    "\n",
-    "usys = UnitSystem(u.kpc, u.Myr, u.Msun, u.radian)\n",
-    "\n",
-    "import JaxStreams"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "15c0512f-48f8-4223-b575-346b5c252d2e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "## Define a MW Potential Model\n",
-    "params_global_potential = {'m_disk':5.0e10, 'a_disk': 3.0, 'b_disk': 0.25, 'm_NFW': 1.0e12,\n",
-    "                          'r_s_NFW': 15.0, }\n",
-    "pot_disk = JaxStreams.MiyamotoNagaiDisk(m=params_global_potential['m_disk'], a=params_global_potential['a_disk'],\n",
-    "                                       b=params_global_potential['b_disk'],units=usys)\n",
-    "pot_NFW = JaxStreams.NFWPotential(m=params_global_potential['m_NFW'], r_s=params_global_potential['r_s_NFW'],units=usys)\n",
-    "\n",
-    "## Combine potentials\n",
-    "potential_list = [pot_disk,pot_NFW]\n",
-    "pot = JaxStreams.Potential_Combine(potential_list=potential_list,units=usys)\n",
-    "\n",
-    "\n",
-    "## Gala equivalent\n",
-    "pot_gala_disk = gp.MiyamotoNagaiPotential(m=params_global_potential['m_disk'],a=params_global_potential['a_disk'],\n",
-    "                         b=params_global_potential['b_disk'],units=usys)\n",
-    "\n",
-    "pot_gala_NFW = gp.NFWPotential(m=params_global_potential['m_NFW'],r_s=params_global_potential['r_s_NFW'],units=usys)\n",
-    "\n",
-    "pot_gala = pot_gala_disk + pot_gala_NFW\n",
-    "H = gp.Hamiltonian(pot_gala)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "342e34b3-8f6f-4ba5-927b-5c071432a9ee",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "## Integrate an orbit\n",
-    "t0 = 0.\n",
-    "dt = 0.5\n",
-    "n_steps = 8_000#8_000\n",
-    "w0 = jnp.array([30., 10., 20, (10*u.km/u.s).to(u.kpc/u.Myr).value, (-150*u.km/u.s).to(u.kpc/u.Myr).value, (-20*u.km/u.s).to(u.kpc/u.Myr).value])\n",
-    "\n",
-    "ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "ws_jax = JaxStreams.leapfrog_run(w0, ts, pot.gradient)\n",
-    "\n",
-    "\n",
-    "w0_gala = gd.PhaseSpacePosition(pos=w0[:3].T*u.kpc,vel=w0[3:].T*u.kpc/u.Myr)\n",
-    "o_gala = H.integrate_orbit(w0=w0_gala,t=np.array(ts))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "8935d99d-4526-42af-864f-66d722272fbd",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.legend.Legend at 0x7fc082293490>"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 864x468 with 6 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig, ax = plt.subplots(2,3)\n",
-    "fig.set_size_inches(12,6.5)\n",
-    "lw=3\n",
-    "ax[0,0].plot(ws_jax[:,0],ws_jax[:,1],color='k',lw=lw,rasterized=True)\n",
-    "ax[0,1].plot(ws_jax[:,0],ws_jax[:,2],color='k',lw=lw,rasterized=True)\n",
-    "ax[0,2].plot(ws_jax[:,1],ws_jax[:,2],color='k',lw=lw,rasterized=True,label='Jax')\n",
-    "\n",
-    "ax[1,0].plot(ws_jax[:,3],ws_jax[:,4],color='k',lw=lw,rasterized=True)\n",
-    "ax[1,1].plot(ws_jax[:,3],ws_jax[:,5],color='k',lw=lw,rasterized=True)\n",
-    "ax[1,2].plot(ws_jax[:,4],ws_jax[:,5],color='k',lw=lw,rasterized=True)\n",
-    "\n",
-    "\n",
-    "ax[0,0].plot(o_gala.x,o_gala.y,color='r',ls='--',lw=2,rasterized=True)\n",
-    "ax[0,1].plot(o_gala.x,o_gala.z,color='r',ls='--',lw=2,rasterized=True)\n",
-    "ax[0,2].plot(o_gala.y,o_gala.z,color='r',ls='--',lw=2,rasterized=True,label='Gala')\n",
-    "\n",
-    "ax[1,0].plot(o_gala.v_x,o_gala.v_y,color='r',ls='--',lw=2,rasterized=True)\n",
-    "ax[1,1].plot(o_gala.v_x,o_gala.v_z,color='r',ls='--',lw=2,rasterized=True)\n",
-    "ax[1,2].plot(o_gala.v_y,o_gala.v_z,color='r',ls='--',lw=2,rasterized=True)\n",
-    "\n",
-    "ax[0,1].set_title('Positions [kpc]',fontsize=20)\n",
-    "ax[1,1].set_title('Velocities [kpc/Myr]',fontsize=20)\n",
-    "\n",
-    "ax[0,2].legend(fontsize=20)\n",
-    "####plt.savefig('DiskNfw_JaxGalaOrbitInt.pdf',bbox_inches='tight')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "49975dae-78c2-4388-b86f-cae27279906f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "## Now generate a mock stream along the above orbit\n",
-    "M_sat = 1.0e4 #progenitor mass\n",
-    "\n",
-    "lead_arm, trail_arm = pot.gen_stream_final(ts, w0, M_sat, None, None)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "622f683f-d788-48ed-a78c-6be3e1303306",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7fed58ba55b0>"
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.scatter(lead_arm[:,0],lead_arm[:,1],s=0.5,rasterized=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "f89de4bc-2b3b-4e24-9c52-365c32622e0a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "jax_stream_model = np.vstack([lead_arm,trail_arm])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "223c00ad-0d5e-45fa-bddd-ce5a8e638012",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "## now in gala\n",
-    "from gala.dynamics import mockstream as ms\n",
-    "df = ms.FardalStreamDF()\n",
-    "prog_mass = M_sat * u.Msun\n",
-    "gen = ms.MockStreamGenerator(df, H)\n",
-    "stream, prog = gen.run(w0_gala, prog_mass,\n",
-    "                        t=np.array(ts)*u.Myr,release_every=1,n_particles=1)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "ab22b334-ad93-45b1-a906-6a6ea943be30",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 864x468 with 6 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig, ax = plt.subplots(2,3)\n",
-    "fig.set_size_inches(12,6.5)\n",
-    "s=0.5\n",
-    "#ax[0,0].scatter(jax_stream_model[:,0],jax_stream_model[:,1],s=s,rasterized=True,color='k')\n",
-    "ax[0,0].scatter(stream.x,stream.y,s=0.5,rasterized=True,color='r')\n",
-    "ax[0,0].scatter(jax_stream_model[:,0],jax_stream_model[:,1],s=s,rasterized=True,color='k')\n",
-    "\n",
-    "ax[0,1].scatter(stream.x,stream.z,s=0.5,rasterized=True,color='r')\n",
-    "ax[0,1].scatter(jax_stream_model[:,0],jax_stream_model[:,2],s=s,rasterized=True,color='k')\n",
-    "\n",
-    "ax[0,2].scatter(stream.y,stream.z,s=0.5,rasterized=True,color='r',label='Gala')\n",
-    "ax[0,2].scatter(jax_stream_model[:,1],jax_stream_model[:,2],s=s,rasterized=True,color='k',label='Jax')\n",
-    "\n",
-    "\n",
-    "ax[1,0].scatter(stream.v_x,stream.v_y,s=0.5,rasterized=True,color='r')\n",
-    "ax[1,0].scatter(jax_stream_model[:,3],jax_stream_model[:,4],s=s,rasterized=True,color='k')\n",
-    "\n",
-    "ax[1,1].scatter(stream.v_x,stream.v_z,s=0.5,rasterized=True,color='r')\n",
-    "ax[1,1].scatter(jax_stream_model[:,3],jax_stream_model[:,5],s=s,rasterized=True,color='k')\n",
-    "\n",
-    "ax[1,2].scatter(stream.v_y,stream.v_z,s=0.5,rasterized=True,color='r',label='Gala')\n",
-    "ax[1,2].scatter(jax_stream_model[:,4],jax_stream_model[:,5],s=s,rasterized=True,color='k',label='Jax')\n",
-    "\n",
-    "\n",
-    "ax[0,1].set_title('Positions [kpc]',fontsize=20)\n",
-    "ax[1,1].set_title('Velocities [kpc/Myr]',fontsize=20)\n",
-    "\n",
-    "lgnd=ax[1,2].legend(fontsize=20,frameon=True)\n",
-    "lgnd.legendHandles[0]._sizes = [30]\n",
-    "lgnd.legendHandles[1]._sizes = [30]\n",
-    "##plt.savefig('DiskSphericalNFW_jax_Gala_Stream.pdf',bbox_inches='tight')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "45958c5f-8da6-4948-8758-5c85ec4ab19e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "lead_arm_obs, trail_arm_obs = pot.gen_stream_final(ts, w0, M_sat, None, None)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "id": "26d1f8b0-ea95-4a98-85e2-e7802bd627dc",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(8000, 6)"
-      ]
-     },
-     "execution_count": 17,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "lead_arm_obs.shape"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "id": "55a62d61-a51f-4fc7-bc20-49b745db959e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def stream_gradients_kde(params,):\n",
-    "    @jax.jit\n",
-    "    def gradient_fn(params):\n",
-    "        ## Define a MW Potential Model\n",
-    "        pot_disk = JaxStreams.MiyamotoNagaiDisk(m=params['m_disk'], a=params['a_disk'],\n",
-    "                                               b=params['b_disk'],units=usys)\n",
-    "        pot_NFW = JaxStreams.NFWPotential(m=params['m_NFW'], r_s=params['r_s_NFW'],units=usys)\n",
-    "\n",
-    "        ## Combine potentials\n",
-    "        potential_list = [pot_disk,pot_NFW]\n",
-    "        pot_with_params = JaxStreams.Potential_Combine(potential_list=potential_list,units=usys)\n",
-    "\n",
-    "        lead_arm, trail_arm = pot_with_params.gen_stream_final(ts, w0, M_sat, None, None)\n",
-    "        return -jnp.sum( (lead_arm-lead_arm_obs)**2 + (trail_arm-trail_arm_obs)**2 )\n",
-    "    # Compute the gradient using JAX's autodiff\n",
-    "    #################gradient_eval = jax.jacfwd(gradient_fn)(params)\n",
-    "    \n",
-    "    #grad_eval_func = lambda params: jax.jacfwd(gradient_fn)(params)\n",
-    "    #second_grad_eval = jax.jacfwd(grad_eval_func)(params)\n",
-    "    \n",
-    "    \n",
-    "    second_grad_eval = jax.jacfwd(jax.jacfwd(gradient_fn))(params)\n",
-    "    return None, second_grad_eval\n",
-    "    \n",
-    "\n",
-    "    \n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "id": "9239c932-bbfd-4f70-8e73-934201597230",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "gradient_eval, second_gradient = stream_gradients_kde(params_global_potential)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "id": "b923ed3b-f6c8-409e-bb98-4563e35866d7",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'a_disk': Array(-960809.93865192, dtype=float64),\n",
-       " 'b_disk': Array(-60130.04079099, dtype=float64),\n",
-       " 'm_NFW': Array(5.04852062e-05, dtype=float64),\n",
-       " 'm_disk': Array(0.00018494, dtype=float64),\n",
-       " 'r_s_NFW': Array(-4242788.31080788, dtype=float64)}"
-      ]
-     },
-     "execution_count": 22,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "second_gradient['a_disk']"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "id": "9ed1aa30-63c8-40a1-bad1-eb660dbe4373",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'a_disk': Array(0.00018494, dtype=float64),\n",
-       " 'b_disk': Array(2.18070099e-05, dtype=float64),\n",
-       " 'm_NFW': Array(-1.632562e-14, dtype=float64),\n",
-       " 'm_disk': Array(-6.32118524e-14, dtype=float64),\n",
-       " 'r_s_NFW': Array(0.00133388, dtype=float64)}"
-      ]
-     },
-     "execution_count": 23,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "second_gradient['m_disk']"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "e4294a6e-b141-4122-aee5-d53a42bd1ebf",
-   "metadata": {},
-   "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.8.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/JaxStreamsDemo_diffrax.ipynb b/JaxStreamsDemo_diffrax.ipynb
deleted file mode 100644
index 523b47e1..00000000
--- a/JaxStreamsDemo_diffrax.ipynb
+++ /dev/null
@@ -1,816 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "1b444d9d-3a14-419f-a35c-a2da4302160a",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u001b[91mA new version of galpy (1.9.0) is available, please upgrade using pip/conda/... to get the latest features and bug fixes!\u001b[0m\n"
-     ]
-    }
-   ],
-   "source": [
-    "from functools import partial\n",
-    "\n",
-    "from astropy.constants import G\n",
-    "import astropy.coordinates as coord\n",
-    "import astropy.units as u\n",
-    "import matplotlib as mpl\n",
-    "import matplotlib.pyplot as plt\n",
-    "%matplotlib inline\n",
-    "import numpy as np\n",
-    "\n",
-    "# gala\n",
-    "import gala.coordinates as gc\n",
-    "import gala.dynamics as gd\n",
-    "import gala.potential as gp\n",
-    "from gala.units import dimensionless, galactic, UnitSystem\n",
-    "\n",
-    "import jax\n",
-    "import jax.numpy as jnp\n",
-    "\n",
-    "from jax.config import config\n",
-    "config.update(\"jax_enable_x64\", True)\n",
-    "\n",
-    "import scienceplots\n",
-    "import cmasher as cmr\n",
-    "plt.style.use('science')\n",
-    "import jax.random as random \n",
-    "from matplotlib.patches import Ellipse\n",
-    "import time\n",
-    "\n",
-    "usys = UnitSystem(u.kpc, u.Myr, u.Msun, u.radian)\n",
-    "\n",
-    "import JaxStreams_diffrax as JaxStreams"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "15c0512f-48f8-4223-b575-346b5c252d2e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "## Define a MW Potential Model\n",
-    "params_global_potential = {'m_disk':5.0e10, 'a_disk': 3.0, 'b_disk': 0.25, 'm_NFW': 1.0e12,\n",
-    "                          'r_s_NFW': 15.0, }\n",
-    "pot_disk = JaxStreams.MiyamotoNagaiDisk(m=params_global_potential['m_disk'], a=params_global_potential['a_disk'],\n",
-    "                                       b=params_global_potential['b_disk'],units=usys)\n",
-    "pot_NFW = JaxStreams.NFWPotential(m=params_global_potential['m_NFW'], r_s=params_global_potential['r_s_NFW'],units=usys)\n",
-    "\n",
-    "## Combine potentials\n",
-    "potential_list = [pot_disk,pot_NFW]\n",
-    "pot = JaxStreams.Potential_Combine(potential_list=potential_list,units=usys)\n",
-    "\n",
-    "\n",
-    "## Gala equivalent\n",
-    "pot_gala_disk = gp.MiyamotoNagaiPotential(m=params_global_potential['m_disk'],a=params_global_potential['a_disk'],\n",
-    "                         b=params_global_potential['b_disk'],units=usys)\n",
-    "\n",
-    "pot_gala_NFW = gp.NFWPotential(m=params_global_potential['m_NFW'],r_s=params_global_potential['r_s_NFW'],units=usys)\n",
-    "\n",
-    "pot_gala =pot_gala_disk + pot_gala_NFW\n",
-    "H = gp.Hamiltonian(pot_gala)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "342e34b3-8f6f-4ba5-927b-5c071432a9ee",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "## Integrate an orbit\n",
-    "t0 = 0.\n",
-    "dt = 0.5\n",
-    "n_steps = 8_000#8_000#8_000\n",
-    "w0 = jnp.array([30., 10., 20, (10*u.km/u.s).to(u.kpc/u.Myr).value, (-150*u.km/u.s).to(u.kpc/u.Myr).value, (-20*u.km/u.s).to(u.kpc/u.Myr).value])\n",
-    "\n",
-    "ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "ws_jax = pot.orbit_integrator_run(w0,t0,jnp.max(ts),ts)#JaxStreams.leapfrog_run(w0, ts, pot.gradient)\n",
-    "\n",
-    "\n",
-    "w0_gala = gd.PhaseSpacePosition(pos=w0[:3].T*u.kpc,vel=w0[3:].T*u.kpc/u.Myr)\n",
-    "o_gala = H.integrate_orbit(w0=w0_gala,t=np.array(ts))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "d2e2a076-7f53-478c-8add-82bc0b90e960",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(Array([0.0000e+00, 5.0000e-01, 1.0000e+00, ..., 3.9990e+03, 3.9995e+03,\n",
-       "        4.0000e+03], dtype=float64),\n",
-       " <Quantity [0.0000e+00, 5.0000e-01, 1.0000e+00, ..., 3.9990e+03, 3.9995e+03,\n",
-       "            4.0000e+03] Myr>)"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "ts, o_gala.t"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "8935d99d-4526-42af-864f-66d722272fbd",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.legend.Legend at 0x7fd11aabd8e0>"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 864x468 with 6 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig, ax = plt.subplots(2,3)\n",
-    "fig.set_size_inches(12,6.5)\n",
-    "lw=3\n",
-    "ax[0,0].plot(ws_jax[:,0],ws_jax[:,1],color='k',lw=lw,rasterized=True)\n",
-    "ax[0,1].plot(ws_jax[:,0],ws_jax[:,2],color='k',lw=lw,rasterized=True)\n",
-    "ax[0,2].plot(ws_jax[:,1],ws_jax[:,2],color='k',lw=lw,rasterized=True,label='Jax')\n",
-    "\n",
-    "ax[1,0].plot(ws_jax[:,3],ws_jax[:,4],color='k',lw=lw,rasterized=True)\n",
-    "ax[1,1].plot(ws_jax[:,3],ws_jax[:,5],color='k',lw=lw,rasterized=True)\n",
-    "ax[1,2].plot(ws_jax[:,4],ws_jax[:,5],color='k',lw=lw,rasterized=True)\n",
-    "\n",
-    "\n",
-    "ax[0,0].plot(o_gala.x,o_gala.y,color='r',ls='--',lw=2,rasterized=True)\n",
-    "ax[0,1].plot(o_gala.x,o_gala.z,color='r',ls='--',lw=2,rasterized=True)\n",
-    "ax[0,2].plot(o_gala.y,o_gala.z,color='r',ls='--',lw=2,rasterized=True,label='Gala')\n",
-    "\n",
-    "ax[1,0].plot(o_gala.v_x,o_gala.v_y,color='r',ls='--',lw=2,rasterized=True)\n",
-    "ax[1,1].plot(o_gala.v_x,o_gala.v_z,color='r',ls='--',lw=2,rasterized=True)\n",
-    "ax[1,2].plot(o_gala.v_y,o_gala.v_z,color='r',ls='--',lw=2,rasterized=True)\n",
-    "\n",
-    "ax[0,1].set_title('Positions [kpc]',fontsize=20)\n",
-    "ax[1,1].set_title('Velocities [kpc/Myr]',fontsize=20)\n",
-    "\n",
-    "ax[0,2].legend(fontsize=20)\n",
-    "####plt.savefig('DiskNfw_JaxGalaOrbitInt.pdf',bbox_inches='tight')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 160,
-   "id": "353267ad-90f7-4e5e-8357-fcb48a1c1766",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(8000, 6)"
-      ]
-     },
-     "execution_count": 160,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "lead_arm.shape"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "49975dae-78c2-4388-b86f-cae27279906f",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "2.220020294189453\n"
-     ]
-    }
-   ],
-   "source": [
-    "## Now generate a mock stream along the above orbit\n",
-    "M_sat = 1.0e4 #progenitor mass\n",
-    "start = time.time()\n",
-    "lead_arm, trail_arm = pot.gen_stream_final(ts, w0, M_sat,)\n",
-    "end = time.time()\n",
-    "print(end-start)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 157,
-   "id": "622f683f-d788-48ed-a78c-6be3e1303306",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7f8dcce2a760>"
-      ]
-     },
-     "execution_count": 157,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.scatter(lead_arm[:,0],lead_arm[:,1],s=0.5,rasterized=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "f89de4bc-2b3b-4e24-9c52-365c32622e0a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "jax_stream_model = np.vstack([lead_arm,trail_arm])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "223c00ad-0d5e-45fa-bddd-ce5a8e638012",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "13.206675052642822\n"
-     ]
-    }
-   ],
-   "source": [
-    "## now in gala\n",
-    "from gala.dynamics import mockstream as ms\n",
-    "df = ms.FardalStreamDF()\n",
-    "prog_mass = M_sat * u.Msun\n",
-    "gen = ms.MockStreamGenerator(df, H)\n",
-    "start = time.time()\n",
-    "\n",
-    "stream, prog = gen.run(w0_gala, prog_mass,\n",
-    "                        t=np.array(ts)*u.Myr,release_every=1,n_particles=1)\n",
-    "end = time.time()\n",
-    "\n",
-    "print(end-start)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "ab22b334-ad93-45b1-a906-6a6ea943be30",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 864x468 with 6 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig, ax = plt.subplots(2,3)\n",
-    "fig.set_size_inches(12,6.5)\n",
-    "s=0.5\n",
-    "#ax[0,0].scatter(jax_stream_model[:,0],jax_stream_model[:,1],s=s,rasterized=True,color='k')\n",
-    "ax[0,0].scatter(stream.x,stream.y,s=0.5,rasterized=True,color='r')\n",
-    "ax[0,0].scatter(jax_stream_model[:,0],jax_stream_model[:,1],s=s,rasterized=True,color='k')\n",
-    "\n",
-    "ax[0,1].scatter(stream.x,stream.z,s=0.5,rasterized=True,color='r')\n",
-    "ax[0,1].scatter(jax_stream_model[:,0],jax_stream_model[:,2],s=s,rasterized=True,color='k')\n",
-    "\n",
-    "ax[0,2].scatter(stream.y,stream.z,s=0.5,rasterized=True,color='r',label='Gala')\n",
-    "ax[0,2].scatter(jax_stream_model[:,1],jax_stream_model[:,2],s=s,rasterized=True,color='k',label='Jax')\n",
-    "\n",
-    "\n",
-    "ax[1,0].scatter(stream.v_x,stream.v_y,s=0.5,rasterized=True,color='r')\n",
-    "ax[1,0].scatter(jax_stream_model[:,3],jax_stream_model[:,4],s=s,rasterized=True,color='k')\n",
-    "\n",
-    "ax[1,1].scatter(stream.v_x,stream.v_z,s=0.5,rasterized=True,color='r')\n",
-    "ax[1,1].scatter(jax_stream_model[:,3],jax_stream_model[:,5],s=s,rasterized=True,color='k')\n",
-    "\n",
-    "ax[1,2].scatter(stream.v_y,stream.v_z,s=0.5,rasterized=True,color='r',label='Gala')\n",
-    "ax[1,2].scatter(jax_stream_model[:,4],jax_stream_model[:,5],s=s,rasterized=True,color='k',label='Jax')\n",
-    "\n",
-    "\n",
-    "ax[0,1].set_title('Positions [kpc]',fontsize=20)\n",
-    "ax[1,1].set_title('Velocities [kpc/Myr]',fontsize=20)\n",
-    "\n",
-    "lgnd=ax[1,2].legend(fontsize=20,frameon=True)\n",
-    "lgnd.legendHandles[0]._sizes = [30]\n",
-    "lgnd.legendHandles[1]._sizes = [30]\n",
-    "##plt.savefig('DiskSphericalNFW_jax_Gala_Stream.pdf',bbox_inches='tight')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "abd0b017-f23a-44d3-b896-43e5e9efc457",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "0.6241137981414795\n",
-      "1.096452236175537\n",
-      "2.049682855606079\n",
-      "4.160857915878296\n",
-      "13.783693075180054\n"
-     ]
-    }
-   ],
-   "source": [
-    "## Benchmar\n",
-    "n_release = [2000,4000,8000,16000,16000*2]\n",
-    "t_jax = []\n",
-    "for i in range(len(n_release)):\n",
-    "    ts = jnp.linspace(t0, 4000., n_release[i])\n",
-    "    start = time.time()\n",
-    "    lead_arm, trail_arm = pot.gen_stream_final(ts, w0, M_sat,)\n",
-    "    end = time.time()\n",
-    "    t_jax.append(end-start)\n",
-    "    print(end-start)\n",
-    "    \n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "cae15cac-7b8b-47ff-9372-61dd765bc88a",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "iteration 0\n",
-      "3.297973871231079\n",
-      "4000\n",
-      "iteration 1\n",
-      "6.6168622970581055\n",
-      "8000\n",
-      "iteration 2\n",
-      "13.64174485206604\n",
-      "16000\n",
-      "iteration 3\n",
-      "24.98160982131958\n",
-      "32000\n",
-      "iteration 4\n",
-      "50.23093605041504\n",
-      "64000\n"
-     ]
-    }
-   ],
-   "source": [
-    "## now in gala\n",
-    "from gala.dynamics import mockstream as ms\n",
-    "df = ms.FardalStreamDF()\n",
-    "prog_mass = M_sat * u.Msun\n",
-    "gen = ms.MockStreamGenerator(df, H)\n",
-    "#start = time.time()\n",
-    "t_gala = []\n",
-    "for i in range(len(n_release)):\n",
-    "    print('iteration ' + str( i ))\n",
-    "    ts = np.linspace(t0, 4000., n_release[i])\n",
-    "    start = time.time()\n",
-    "    stream, prog = gen.run(w0_gala, prog_mass,\n",
-    "                        t=ts*u.Myr,release_every=1,n_particles=1)\n",
-    "    end = time.time()\n",
-    "    t_gala.append(end-start)\n",
-    "    print(end-start)\n",
-    "    print(len(stream.x))\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "19bf2124-5a58-46de-8db2-158c62ffc281",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[3.297973871231079,\n",
-       " 6.6168622970581055,\n",
-       " 13.64174485206604,\n",
-       " 24.98160982131958,\n",
-       " 50.23093605041504]"
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "t_gala"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "5dfdc8da-6988-4841-a629-7ba82684eab1",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.legend.Legend at 0x7fd11f6ddc10>"
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 504x432 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig, ax = plt.subplots(1,1)\n",
-    "fig.set_size_inches(7,6)\n",
-    "ax.plot(2*np.array(n_release),t_gala,color='tab:blue',marker='o',lw=2,label='Gala FardalDf',rasterized=True)\n",
-    "ax.plot(2*np.array(n_release),t_jax,color='k',marker='o',lw=2,label='JaxStreams FardalDf',rasterized=True)\n",
-    "ax.set_xlabel(r'$N_{\\mathrm{particles}}$',fontsize=20)\n",
-    "ax.set_ylabel(r'Wall-Clock Time [seconds]',fontsize=20)\n",
-    "ax.tick_params(axis='both', labelsize=20)\n",
-    "\n",
-    "ax.legend(fontsize=20)\n",
-    "######plt.savefig('Gala_versus_JaxStream_aftercompile.pdf',bbox_inches='tight')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "d3b68f10-48e9-45ba-9b36-47e601fff68a",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "41dcf2c7-b7bd-4237-ac8a-cb3aca4da86c",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "efc3ceb6-1828-47c3-8100-00134e39af90",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "ts = jnp.linspace(t0, 4000., n_steps)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "3b8fa771-f484-445a-af62-82e368a779a6",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "id": "45958c5f-8da6-4948-8758-5c85ec4ab19e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "lead_arm_obs, trail_arm_obs = pot.gen_stream_final(ts, w0, M_sat,)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "id": "26d1f8b0-ea95-4a98-85e2-e7802bd627dc",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array(-191477.1942843, dtype=float64)"
-      ]
-     },
-     "execution_count": 23,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "lead_arm_obs.sum()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "id": "787b4cb7-301d-4ce4-8c87-9fec969df055",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array(-191477.1942843, dtype=float64)"
-      ]
-     },
-     "execution_count": 27,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "lead_arm_obs.sum()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 29,
-   "id": "47add5c1-4f20-44a9-beb1-3cfdb61dfa5d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pot_disk = JaxStreams.MiyamotoNagaiDisk(m=params_global_potential['m_disk'], a=params_global_potential['a_disk'],\n",
-    "                                               b=params_global_potential['b_disk'],units=usys)\n",
-    "pot_NFW = JaxStreams.NFWPotential(m=params_global_potential['m_NFW'], r_s=params_global_potential['r_s_NFW'],units=usys)\n",
-    "\n",
-    "## Combine potentials\n",
-    "potential_list = [pot_disk,pot_NFW]\n",
-    "pot_with_params = JaxStreams.Potential_Combine(potential_list=potential_list,units=usys)\n",
-    "lead_arm_obs__, trail_arm_obs__ = pot_with_params.gen_stream_final(ts, w0, M_sat,)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 32,
-   "id": "dc49b17c-237f-4ff2-a021-2fe9b55bf5cb",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array(0., dtype=float64)"
-      ]
-     },
-     "execution_count": 32,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "jnp.sum((lead_arm_obs-lead_arm_obs__)**2 + (trail_arm_obs-trail_arm_obs__)**2)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 71,
-   "id": "300af0e0-e966-41f1-a775-ca82851ca70f",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array([ 3.00000000e+01,  1.00000000e+01,  2.00000000e+01,  1.02271217e-02,\n",
-       "       -1.53406825e-01, -2.04542433e-02], dtype=float64)"
-      ]
-     },
-     "execution_count": 71,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "w0"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 136,
-   "id": "a730d8e7-3ed6-4f1d-8bae-64701302cb45",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "@jax.jit\n",
-    "def gen_observed_stream(params,ts,w0,M_sat):\n",
-    "    pot_disk = JaxStreams.MiyamotoNagaiDisk(m=params['m_disk'], a=params['a_disk'],\n",
-    "                                               b=params['b_disk'],units=usys)\n",
-    "    pot_NFW = JaxStreams.NFWPotential(m=params['m_NFW'], r_s=params['r_s_NFW'],units=usys)\n",
-    "    ## Combine potentials\n",
-    "    potential_list = [pot_disk,pot_NFW]\n",
-    "    pot = JaxStreams.Potential_Combine(potential_list=potential_list,units=usys)\n",
-    "    \n",
-    "    ## Generate a stream. This will be the \"observed\" stream, i.e., the DATA\n",
-    "    lead_arm, trail_arm = pot.gen_stream_final(ts, w0, M_sat,) \n",
-    "    \n",
-    "    return lead_arm, trail_arm #jnp.sum(lead_arm_obs**2 + trail_arm_obs**2)\n",
-    "@jax.jit\n",
-    "def compare_streams(params,ts,w0,M_sat):\n",
-    "    ## first generate data stream (no grad tracking)\n",
-    "    lead_arm, trail_arm = gen_observed_stream(params,ts,w0,M_sat)\n",
-    "    lead_arm_obs, trail_arm_obs = jax.lax.stop_gradient(lead_arm), jax.lax.stop_gradient(trail_arm)\n",
-    "    return -jnp.sum( (lead_arm-lead_arm_obs)**2 + (trail_arm-trail_arm_obs)**2 )\n",
-    "    \n",
-    "    \n",
-    "\n",
-    "func_params = lambda params: compare_streams(params,ts,w0,M_sat) \n",
-    "out_test = func_params(params_global_potential)\n",
-    "#@partial(jax.jit,static_argnums=(1,2,))\n",
-    "#@jax.jit\n",
-    "#def get_gradients(params,lead_arm_obs,trail_arm_obs,):\n",
-    "#    return lead_arm_obs\n",
-    "    \n",
-    "#lead_obs_trail_obs = gen_observed_stream(params_global_potential,ts,w0,M_sat)\n",
-    "\n",
-    "\n",
-    "#test_grad_fn = lambda params: gen_observed_stream(params,ts,w0,M_sat)\n",
-    "#jacc = jax.jacfwd(test_grad_fn)(params_global_potential)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 147,
-   "id": "aa062c82-49cd-4ac2-bde4-91444fb59322",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "first_deriv = jax.jacfwd(compare_streams,argnums=0)(params_global_potential,ts,w0,M_sat)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 148,
-   "id": "45fe546e-f89a-4ae3-9f75-3edf503a3214",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'a_disk': Array(-0., dtype=float64),\n",
-       " 'b_disk': Array(-0., dtype=float64),\n",
-       " 'm_NFW': Array(-0., dtype=float64),\n",
-       " 'm_disk': Array(-0., dtype=float64),\n",
-       " 'r_s_NFW': Array(-0., dtype=float64)}"
-      ]
-     },
-     "execution_count": 148,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "first_deriv"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 149,
-   "id": "5136ebd9-073d-4058-abc0-2eec4de15c05",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "second_deriv = jax.jacfwd(jax.jacfwd(compare_streams,argnums=0))(params_global_potential,ts,w0,M_sat) #default is argnums=0..."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 150,
-   "id": "c6f1a2be-c01e-46ef-8e4f-a411b8c08def",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'a_disk': {'a_disk': Array(-968705.97968917, dtype=float64),\n",
-       "  'b_disk': Array(-63931.34940796, dtype=float64),\n",
-       "  'm_NFW': Array(5.05321794e-05, dtype=float64),\n",
-       "  'm_disk': Array(0.00018556, dtype=float64),\n",
-       "  'r_s_NFW': Array(-4252344.14698589, dtype=float64)},\n",
-       " 'b_disk': {'a_disk': Array(-63931.34940796, dtype=float64),\n",
-       "  'b_disk': Array(-9206.85919985, dtype=float64),\n",
-       "  'm_NFW': Array(5.2091054e-06, dtype=float64),\n",
-       "  'm_disk': Array(2.31089285e-05, dtype=float64),\n",
-       "  'r_s_NFW': Array(-445669.11021175, dtype=float64)},\n",
-       " 'm_NFW': {'a_disk': Array(5.05321794e-05, dtype=float64),\n",
-       "  'b_disk': Array(5.2091054e-06, dtype=float64),\n",
-       "  'm_NFW': Array(-4.86812594e-15, dtype=float64),\n",
-       "  'm_disk': Array(-1.63155041e-14, dtype=float64),\n",
-       "  'r_s_NFW': Array(0.00038021, dtype=float64)},\n",
-       " 'm_disk': {'a_disk': Array(0.00018556, dtype=float64),\n",
-       "  'b_disk': Array(2.31089285e-05, dtype=float64),\n",
-       "  'm_NFW': Array(-1.63155041e-14, dtype=float64),\n",
-       "  'm_disk': Array(-6.34760023e-14, dtype=float64),\n",
-       "  'r_s_NFW': Array(0.00133511, dtype=float64)},\n",
-       " 'r_s_NFW': {'a_disk': Array(-4252344.14698589, dtype=float64),\n",
-       "  'b_disk': Array(-445669.11021175, dtype=float64),\n",
-       "  'm_NFW': Array(0.00038021, dtype=float64),\n",
-       "  'm_disk': Array(0.00133511, dtype=float64),\n",
-       "  'r_s_NFW': Array(-30206480.71537469, dtype=float64)}}"
-      ]
-     },
-     "execution_count": 150,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "second_deriv"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "dde58607-8b85-4c3e-9abf-f0c37489f2a4",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "8d08d450-4fa4-439c-8a8d-34b3a871cd10",
-   "metadata": {},
-   "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.8.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/JaxStreams_diffrax.py b/JaxStreams_diffrax.py
deleted file mode 100644
index 692bde08..00000000
--- a/JaxStreams_diffrax.py
+++ /dev/null
@@ -1,578 +0,0 @@
-from functools import partial
-from astropy.constants import G
-import astropy.coordinates as coord
-import astropy.units as u
-# gala
-import gala.coordinates as gc
-import gala.dynamics as gd
-import gala.potential as gp
-from gala.units import dimensionless, galactic, UnitSystem
-
-import jax
-import jax.numpy as jnp
-
-from jax.config import config
-config.update("jax_enable_x64", True)
-import jax.random as random 
-from jax_cosmo.scipy.interpolate import InterpolatedUnivariateSpline
-from diffrax import diffeqsolve, ODETerm, Dopri5,SaveAt,PIDController,DiscreteTerminatingEvent
-
-usys = UnitSystem(u.kpc, u.Myr, u.Msun, u.radian)
-
-class Potential:
-    
-    def __init__(self, units, params):
-        if units is None:
-            units = dimensionless
-        self.units = UnitSystem(units)
-        
-        if self.units == dimensionless:
-            self._G = 1
-        else:
-            self._G = G.decompose(self.units).value
-        
-        for name, param in params.items():
-            if hasattr(param, 'unit'):
-                param = param.decompose(self.units).value
-            setattr(self, name, param)
-    
-    @partial(jax.jit, static_argnums=(0,))
-    def gradient(self, xyz, t):
-        grad_func = jax.grad(self.potential)
-        return grad_func(xyz, t)
-    
-    @partial(jax.jit, static_argnums=(0,))
-    def density(self, xyz, t):
-        lap = jnp.trace(jax.hessian(self.potential)(xyz, t))
-        return lap / (4 * jnp.pi * self._G)
-    
-    @partial(jax.jit, static_argnums=(0,))
-    def acceleration(self, xyz, t):
-        return -self.gradient(xyz, t)
-    
-   
-    @partial(jax.jit,static_argnums=(0,))
-    def jacobian_force_mw(self, xyz, t):
-        jacobian_force_mw = jax.jacfwd(self.gradient)
-        return jacobian_force_mw(xyz, t)
-    
-    @partial(jax.jit,static_argnums=(0,))
-    def d2phidr2_mw(self, x, t):
-        """
-        Computes the second derivative of the Milky Way potential at a position x (in the simulation frame)
-        Args:
-          x: 3d position (x, y, z) in [kpc]
-        Returns:
-          Second derivative of force (per unit mass) in [1/Myr^2]
-        Examples
-        --------
-        >>> d2phidr2_mw(x=jnp.array([8.0, 0.0, 0.0]))
-        """
-        rad = jnp.linalg.norm(x)
-        r_hat = x/rad
-        dphi_dr_func = lambda x: jnp.sum(self.gradient(x,t)*r_hat)
-        return jnp.sum(jax.grad(dphi_dr_func)(x)*r_hat)
-        
-        ##return jnp.matmul(jnp.transpose(x), jnp.matmul(self.jacobian_force_mw(x, t), x)) / rad**2
-
-
-    @partial(jax.jit,static_argnums=(0,))
-    def omega(self, x,v):
-        """
-        Computes the magnitude of the angular momentum in the simulation frame
-        Args:
-          x: 3d position (x, y, z) in [kpc]
-          v: 3d velocity (v_x, v_y, v_z) in [kpc/Myr]
-        Returns:
-          Magnitude of angular momentum in [rad/Myr]
-        Examples
-        --------
-        >>> omega(x=jnp.array([8.0, 0.0, 0.0]), v=jnp.array([8.0, 0.0, 0.0]))
-        """
-        rad = jnp.sqrt(x[0] ** 2 + x[1] ** 2 + x[2] ** 2)
-        omega_vec = jnp.cross(x, v) / (rad**2)
-        return jnp.linalg.norm(omega_vec)
-
-    @partial(jax.jit,static_argnums=(0,))
-    def tidalr_mw(self, x, v, Msat, t):
-        """
-        Computes the tidal radius of a cluster in the potential
-        Args:
-          x: 3d position (x, y, z) in [kpc]
-          v: 3d velocity (v_x, v_y, v_z) in [kpc/Myr]
-          Msat: Cluster mass in [Msol]
-        Returns:
-          Tidal radius of the cluster in [kpc]
-        Examples
-        --------
-        >>> tidalr_mw(x=jnp.array([8.0, 0.0, 0.0]), v=jnp.array([8.0, 0.0, 0.0]), Msat=1e4)
-        """
-        return (self._G * Msat / ( self.omega(x, v) ** 2 - self.d2phidr2_mw(x, t)) ) ** (1.0 / 3.0)
-    
-    @partial(jax.jit,static_argnums=(0,))
-    def lagrange_pts(self,x,v,Msat, t):
-        r_tidal = self.tidalr_mw(x,v,Msat, t)
-        r_hat = x/jnp.linalg.norm(x)
-        L_close = x - r_hat*r_tidal
-        L_far = x + r_hat*r_tidal
-        return L_close, L_far
-    
-    @partial(jax.jit,static_argnums=(0,))
-    def velocity_acceleration(self,t,xv,args):
-        x, v = xv[:3], xv[3:]
-        acceleration = -self.gradient(x,t)
-        return jnp.hstack([v,acceleration])
-    
-    @partial(jax.jit,static_argnums=(0,))
-    def orbit_integrator_run(self,w0,t0,t1,ts):
-        term = ODETerm(self.velocity_acceleration)
-        solver = Dopri5()
-        saveat = SaveAt(t0=False, t1=True, ts=ts, dense=False)
-        rtol: float = 1e-7
-        atol: float = 1e-7
-        stepsize_controller = PIDController(rtol=rtol, atol=atol)
-        max_steps: int = 16**3
-        t0 = t0#0.0
-        t1 = t1#4000.
-        dense = False
-        #y0= w_init
-
-        solution = diffeqsolve(
-            terms=term,
-            solver=solver,
-            t0=t0,
-            t1=t1,
-            y0=w0,
-            dt0=None,
-            saveat=saveat,
-            stepsize_controller=stepsize_controller,
-            discrete_terminating_event=None,
-            max_steps=(max_steps if dense else None),
-        )
-        return solution.ys 
-    
-
-    
-    
-    @partial(jax.jit,static_argnums=(0,))
-    def release_model(self, x, v, Msat,i, t):
-        """
-        Simplification of particle spray: just release particles in gaussian blob at each lagrange point.
-        User sets the spatial and velocity dispersion for the "leaking" of particles
-        TODO: change random key handling... need to do all of the sampling up front...
-        """
-        keya = jax.random.PRNGKey(i*13)
-        keyb = jax.random.PRNGKey(i*23)
-        
-        keyc = jax.random.PRNGKey(i*27)
-        keyd = jax.random.PRNGKey(i*3)
-        keye = jax.random.PRNGKey(i*17)
-        
-        L_close, L_far = self.lagrange_pts(x,v,Msat, t) # each is an xyz array
-        
-        omega_val = self.omega(x,v)
-        
-        
-        r = jnp.linalg.norm(x)
-        r_hat = x/r
-        r_tidal = self.tidalr_mw(x,v,Msat, t)
-        rel_v = omega_val*r_tidal #relative velocity
-        
-        #circlar_velocity
-        dphi_dr = jnp.sum(self.gradient(x, t)*r_hat)
-        v_circ = rel_v##jnp.sqrt( r*dphi_dr )
-        
-        L_vec = jnp.cross(x,v)
-        z_hat = L_vec / jnp.linalg.norm(L_vec)
-        
-        phi_vec = v - jnp.sum(v*r_hat)*r_hat
-        phi_hat = phi_vec/jnp.linalg.norm(phi_vec)
-        vt_sat = jnp.sum(v*phi_hat)
-        
-        
-        kr_bar = 2.0
-        kvphi_bar = 0.3
-        ####################kvt_bar = 0.3 ## FROM GALA
-        
-        kz_bar = 0.0
-        kvz_bar = 0.0
-        
-        sigma_kr = 0.5
-        sigma_kvphi = 0.5
-        sigma_kz = 0.5
-        sigma_kvz = 0.5
-        ##############sigma_kvt = 0.5 ##FROM GALA
-        
-        kr_samp =  kr_bar + jax.random.normal(keya,shape=(1,))*sigma_kr
-        kvphi_samp = kr_samp*(kvphi_bar  + jax.random.normal(keyb,shape=(1,))*sigma_kvphi)
-        kz_samp = kz_bar + jax.random.normal(keyc,shape=(1,))*sigma_kz
-        kvz_samp = kvz_bar + jax.random.normal(keyd,shape=(1,))*sigma_kvz
-        ########kvt_samp = kvt_bar + jax.random.normal(keye,shape=(1,))*sigma_kvt
-        
-        ## Trailing arm
-        pos_trail = x + kr_samp*r_hat*(r_tidal) #nudge out
-        pos_trail  = pos_trail + z_hat*kz_samp*(r_tidal/1.0)#r #nudge above/below orbital plane
-        v_trail = v + (0.0 + kvphi_samp*v_circ*(1.0))*phi_hat#v + (0.0 + kvphi_samp*v_circ*(-r_tidal/r))*phi_hat #nudge velocity along tangential direction
-        v_trail = v_trail + (kvz_samp*v_circ*(1.0))*z_hat#v_trail + (kvz_samp*v_circ*(-r_tidal/r))*z_hat #nudge velocity along vertical direction
-        
-        ## Leading arm
-        pos_lead = x + kr_samp*r_hat*(-r_tidal) #nudge in
-        pos_lead  = pos_lead + z_hat*kz_samp*(-r_tidal/1.0)#r #nudge above/below orbital plane
-        v_lead = v + (0.0 + kvphi_samp*v_circ*(-1.0))*phi_hat#v + (0.0 + kvphi_samp*v_circ*(r_tidal/r))*phi_hat #nudge velocity along tangential direction
-        v_lead = v_lead + (kvz_samp*v_circ*(-1.0))*z_hat#v_lead + (kvz_samp*v_circ*(r_tidal/r))*z_hat #nudge velocity against vertical direction
-        
-    
-        
-        
-        return pos_lead, pos_trail, v_lead, v_trail
-    
-    @partial(jax.jit,static_argnums=(0,))
-    def gen_stream_ics(self, ts, prog_w0, Msat):
-        ws_jax = self.orbit_integrator_run(prog_w0,jnp.min(ts),jnp.max(ts),ts)
-        
-        def scan_fun(carry, t):
-            i, pos_close, pos_far, vel_close, vel_far = carry
-            pos_close_new, pos_far_new, vel_close_new, vel_far_new = self.release_model(ws_jax[i,:3], ws_jax[i,3:], Msat,i, t)
-            return [i+1, pos_close_new, pos_far_new, vel_close_new, vel_far_new], [pos_close_new, pos_far_new, vel_close_new, vel_far_new]#[i+1, pos_close_new, pos_far_new, vel_close_new, vel_far_new]
-            
-            
-        #init_carry = [0, 0, 0, 0, 0]
-        init_carry = [0, jnp.array([0.0,0.0,0.]), jnp.array([0.0,0.0,0.]), jnp.array([0.0,0.0,0.]), jnp.array([0.0,0.0,0.])] 
-        final_state, all_states = jax.lax.scan(scan_fun, init_carry, ts[1:])
-        pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr = all_states
-        return pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr
-    
-    @partial(jax.jit,static_argnums=(0,))
-    def gen_stream(self, ts, prog_w0, Msat):
-        pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr = self.gen_stream_ics(ts, prog_w0, Msat)
-        
-        def scan_fun(carry, particle_idx):
-            i, pos_close_curr, pos_far_curr, vel_close_curr, vel_far_curr = carry
-            curr_particle_w0_close = jnp.hstack([pos_close_curr,vel_close_curr])
-            curr_particle_w0_far = jnp.hstack([pos_far_curr,vel_far_curr])
-            #print(curr_particle_w0_close.shape)
-            #indices = jnp.arange(i,len(ts))
-            #t_particle = jnp.take(ts, indices)
-            #################t_particle = jax.lax.slice(ts,(i,),(len(ts),))
-            w_particle_close = leapfrog_run(curr_particle_w0_close, ts, self.gradient)
-            w_particle_far = leapfrog_run(curr_particle_w0_far, ts, self.gradient)
-            
-            ###ts_update = jax.lax.dynamic_slice(ts_curr,(i+1,),(len(ts_curr)-1,))
-            
-            return [i+1, pos_close_arr[i+1,:], pos_far_arr[i+1,:], vel_close_arr[i+1,:], vel_far_arr[i+1,:]], [w_particle_close, w_particle_far]
-        init_carry = [0, pos_close_arr[0,:], pos_far_arr[0,:], vel_close_arr[0,:], vel_far_arr[0,:]]
-        particle_ids = jnp.arange(len(pos_close_arr))
-        final_state, all_states = jax.lax.scan(scan_fun, init_carry, particle_ids)
-        lead_arm, trail_arm = all_states
-        return lead_arm, trail_arm
-            
-    @partial(jax.jit,static_argnums=(0,))
-    def gen_stream_final(self, ts, prog_w0, Msat):
-        pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr = self.gen_stream_ics(ts, prog_w0, Msat,)
-        @jax.jit
-        def scan_fun(carry, particle_idx):
-            i, pos_close_curr, pos_far_curr, vel_close_curr, vel_far_curr = carry
-            curr_particle_w0_close = jnp.hstack([pos_close_curr,vel_close_curr])
-            curr_particle_w0_far = jnp.hstack([pos_far_curr,vel_far_curr])
-            w0_lead_trail = jnp.vstack([curr_particle_w0_close,curr_particle_w0_far])
-            #print(curr_particle_w0_close.shape)
-            #indices = jnp.arange(i,len(ts))
-            #t_particle = jnp.take(ts, indices)
-            
-            #######t_particle = jax.lax.slice(ts,(i,),(len(ts),))
-            minval, maxval =  ts[i],ts[-1]#jnp.min(jax.lax.dynamic_slice(ts,(i,),(len(ts)-i,))), jnp.max(jax.lax.dynamic_slice(ts,(i,),(len(ts)-i,)))
-            ###t_particle = ts.at[:i].set( jnp.nan )
-            #######################t_particle = jnp.linspace(minval,maxval,len(ts))#jax.lax.dynamic_slice(ts,minval,(len(ts)-i,))##jax.lax.dynamic_slice(ts,(i+1,),(len(ts)-1,))
-            
-            integrate_different_ics = lambda ics:  self.orbit_integrator_run(ics,minval,maxval,None)[0]
-            w_particle_close, w_particle_far = jax.vmap(integrate_different_ics,in_axes=(0,))(w0_lead_trail) #vmap over leading and trailing arm
-            #####w_particle_close = self.orbit_integrator_run(curr_particle_w0_close,minval,maxval,None)[0]
-            #####w_particle_far = self.orbit_integrator_run(curr_particle_w0_far,minval,maxval,None)[0]
-            
-            
-            ##t_particle = jax.vmap(ts_func,in_axes=(0,None),)(ts,ts[i])
-            ###################################t_particle = get_t_arr(ts,ts[i]) OLD
-            ##print(t_particle)
-            ##w_particle_close = leapfrog_run(curr_particle_w0_close, t_particle, self.gradient)
-            ##w_particle_far = leapfrog_run(curr_particle_w0_far, t_particle, self.gradient)
-            
-            ####w_particle_close = w_particle_close[-1,:]#w_particle_close[-1,:]
-            ####w_particle_far = w_particle_far[-1,:]#w_particle_far[-1,:]
-            
-            
-            return [i+1, pos_close_arr[i+1,:], pos_far_arr[i+1,:], vel_close_arr[i+1,:], vel_far_arr[i+1,:]], [w_particle_close, w_particle_far]
-        init_carry = [0, pos_close_arr[0,:], pos_far_arr[0,:], vel_close_arr[0,:], vel_far_arr[0,:]]
-        particle_ids = jnp.arange(len(pos_close_arr))
-        #print(len(particle_ids))
-        final_state, all_states = jax.lax.scan(scan_fun, init_carry, particle_ids)
-        #print(final_state)
-        lead_arm, trail_arm = all_states
-        return lead_arm, trail_arm##lead_arm, trail_arm
-    
-    @partial(jax.jit,static_argnums=(0,))
-    def gen_stream_vmapped(self, ts, prog_w0, Msat):
-        pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr = self.gen_stream_ics(ts, prog_w0, Msat)
-        @jax.jit
-        def single_particle_integrate(particle_number,pos_close_curr,pos_far_curr,vel_close_curr,vel_far_curr):
-            curr_particle_w0_close = jnp.hstack([pos_close_curr,vel_close_curr])
-            curr_particle_w0_far = jnp.hstack([pos_far_curr,vel_far_curr])
-            t_release = ts[particle_number]
-            t_final = ts[-1] + .01
-            
-            w_particle_close = self.orbit_integrator_run(curr_particle_w0_close,t_release,t_final,None)[0]
-            w_particle_far = self.orbit_integrator_run(curr_particle_w0_far,t_release,t_final,None)[0]
-
-            #t_particle = jax.vmap(ts_func,in_axes=(0,None),)(ts,ts[particle_number])
-            #w_particle_close = leapfrog_run(curr_particle_w0_close, t_particle, self.gradient)
-            #w_particle_far = leapfrog_run(curr_particle_w0_far, t_particle, self.gradient)
-            
-            #w_particle_close = w_particle_close[-1,:]
-            #w_particle_far = w_particle_far[-1,:]
-            
-            
-            return w_particle_close, w_particle_far
-        particle_ids = jnp.arange(len(pos_close_arr))
-        
-        return jax.vmap(single_particle_integrate,in_axes=(0,0,0,0,0,))(particle_ids,pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr)
-
-    
-
-class Isochrone(Potential):
-    
-    def __init__(self, m, a, units=None):
-        super().__init__(units, {'m': m, 'a': a})
-    
-    @partial(jax.jit, static_argnums=(0,))
-    def potential(self, xyz, t):
-        r = jnp.linalg.norm(xyz, axis=0)
-        return - self._G * self.m / (self.a + jnp.sqrt(r**2 + self.a**2))
-    
-
-    
-class Isochrone_centered(Potential):
-    
-    def __init__(self, m, a, spline_eval_func, splines, t_min, t_max, m_ext, a_ext, units=None):
-        super().__init__(units, {'m': m, 'a': a, 'spline_eval_func': spline_eval_func, 'splines': splines, 't_min': t_min, 't_max': t_max,
-                                'm_ext': m_ext, 'a_ext': a_ext})
-    
-    @partial(jax.jit, static_argnums=(0,))
-    def potential(self, xyz, t):
-        is_cond_met = (t > self.t_min) & (t < self.t_max) # True if yes, False if no
-        pot_ext = Isochrone(m=self.m_ext, a=self.a_ext, units=self.units) 
-        
-        def true_func(xyz_t):
-            xyz_, t = xyz_t[:3], xyz_t[-1]
-            xyz = xyz_ - self.spline_eval_func(t,self.splines)
-            r = jnp.linalg.norm(xyz, axis=0)
-            return - self._G * self.m / (self.a + jnp.sqrt(r**2 + self.a**2))  + pot_ext.potential(xyz_,t)#+ self.pot_ext.potential(xyz_,t)
-        def false_func(xyz_t):
-            xyz, t = xyz_t[:3], xyz_t[-1]
-            return pot_ext.potential(xyz,t)#0.#self.pot_ext.potential(xyz,t)
-        xyz_t = jnp.hstack([xyz,t])
-        return jax.lax.cond(pred=is_cond_met, true_fun=true_func, false_fun=false_func,operand=xyz_t)
-    
-class MiyamotoNagaiDisk(Potential):
-    def __init__(self, m, a, b, units=None):
-        super().__init__(units, {'m': m, 'a': a, 'b': b,})
-    @partial(jax.jit,static_argnums=(0,))
-    def potential(self,xyz,t):
-        R2 = xyz[0]**2 + xyz[1]**2
-        return -self._G*self.m / jnp.sqrt(R2 + jnp.square(jnp.sqrt(xyz[2]**2 + self.b**2) + self.a))
-    
-class NFWPotential_holder(Potential):
-    """
-    Flattening in potential, not density
-    Form from http://gala.adrian.pw/en/v0.1.2/api/gala.potential.FlattenedNFWPotential.html
-    """
-    def __init__(self, v_c, r_s, q, units=None):
-        super().__init__(units, {'v_c': v_c, 'r_s': r_s, 'q': q})
-    @partial(jax.jit,static_argnums=(0,))
-    def potential(self,xyz,t):
-        m = jnp.sqrt(xyz[0]**2 + xyz[1]**2 + (xyz[2]/self.q)**2)
-        return -((self.v_c**2)/jnp.sqrt(jnp.log(2.0)-0.5) )*jnp.log(1.0 + m/self.r_s)/(m/self.r_s)
-    
-class NFWPotential(Potential):
-    """
-    standard def see spherical model @ https://github.com/adrn/gala/blob/main/gala/potential/potential/builtin/builtin_potentials.c
-    """
-    def __init__(self, m, r_s, units=None):
-        super().__init__(units, {'m': m, 'r_s': r_s})
-    @partial(jax.jit,static_argnums=(0,))
-    def potential(self,xyz,t):
-        v_h2 = -self._G*self.m/self.r_s
-        m = jnp.sqrt(xyz[0]**2 + xyz[1]**2 + xyz[2]**2 + .001)/self.r_s ##added softening!
-        return v_h2*jnp.log(1.0+ m) / m#-((self.v_c**2)/jnp.sqrt(jnp.log(2.0)-0.5) )*jnp.log(1.0 + m/self.r_s)/(m/self.r_s)
-    
-    
-class BarPotential(Potential):
-    """
-    Rotating bar potentil, with hard-coded rotation.
-    Eq 8a in https://articles.adsabs.harvard.edu/pdf/1992ApJ...397...44L
-    Rz according to https://en.wikipedia.org/wiki/Rotation_matrix
-    """
-    def __init__(self, m, a, b, c, Omega, units=None):
-        super().__init__(units, {'m': m, 'a': a, 'b': b, 'c': c, 'Omega': Omega})
-    @partial(jax.jit,static_argnums=(0,))
-    def potential(self,xyz,t):
-        ## First take the simulation frame coordinates and rotate them by Omega*t
-        ang = -self.Omega*t
-        Rot_mat = jnp.array([[jnp.cos(ang), -jnp.sin(ang), 0], [jnp.sin(ang), jnp.cos(ang), 0.], [0.0, 0.0, 1.0] ])
-        Rot_inv = jnp.linalg.inv(Rot_mat)
-        xyz_corot = jnp.matmul(Rot_mat,xyz)
-        
-        T_plus = jnp.sqrt( (self.a + xyz_corot[0])**2 + xyz_corot[1]**2 + ( self.b + jnp.sqrt(self.c**2 + xyz_corot[2]**2) )**2 )
-        T_minus = jnp.sqrt( (self.a - xyz_corot[0])**2 + xyz_corot[1]**2 + ( self.b + jnp.sqrt(self.c**2 + xyz_corot[2]**2) )**2 )
-        
-        pot_corot_frame = (self._G*self.m/(2.0*self.a))*jnp.log( (xyz_corot[0] - self.a + T_minus)/(xyz_corot[0] + self.a + T_plus) )
-        return pot_corot_frame
-    
-    
-class Potential_Combine(Potential):
-    def __init__(self, potential_list, units=None):
-        super().__init__(units, {'potential_list': potential_list })
-    
-    @partial(jax.jit,static_argnums=(0,))
-    def potential(self, xyz, t,):
-        output = []
-        for i in range(len(self.potential_list)):
-            output.append(self.potential_list[i].potential(xyz,t))
-        return jnp.sum(jnp.array(output))
-    
-    
-def leapfrog_step(func, y0, t0, dt, a0):
-    ndim = y0.shape[0] // 2
-    tf = t0 + dt
-    
-    x0 = y0[:ndim]
-    v0 = y0[ndim:]
-    
-    v1_2 = v0 + a0 * dt / 2.
-    xf = x0 + v1_2 * dt
-    af = - func(xf, tf)
-    
-    vf = v1_2 + af * dt / 2
-    
-    return tf, jnp.concatenate((xf, vf)), af
-
-@partial(jax.jit, static_argnames=['potential_gradient', 'args'])
-def leapfrog_run(w0, ts, potential_gradient, args=()):
-    func_ = lambda y, t: potential_gradient(y, t, *args)
-    
-    def scan_fun(carry, t):
-        i, y0, t0, dt, a0 = carry
-        tf, yf, af = leapfrog_step(func_, y0, t0, dt, a0)
-        dt_new = ts[i+1] - ts[i]
-        is_cond_met = jnp.abs(dt_new) > 0.  ### !!! ADDED jnp.abs AFTER derivs worked. Note for future debugging efforts!
-        
-        def true_func(dt_new):
-            return ts[-1]-ts[-2] #dt_base !!!ASSUMING dt = 0.5 Myr by default!!!!
-        def false_func(dt_new):
-            return 0.0
-        dt_new = jax.lax.cond(pred=is_cond_met, true_fun=true_func, false_fun=false_func,operand=dt_new)
-        
-        ###tf = tf + dt_new
-        return [i + 1, yf, tf, dt_new, af], yf
-    
-    ndim = w0.shape[0] // 2
-    a0 = -func_(w0[:ndim], ts[0]) ##### SHOULD THIS BE NEGATIVE??? TODO
-    dt = ts[1]-ts[0] ## I ADDED THIS
-    init_carry = [0, w0, ts[0], dt, a0]
-    _, ws = jax.lax.scan(scan_fun, init_carry, ts[1:])
-    res_ws = jnp.concatenate((w0[None], ws))
-    
-    return res_ws
-
-    
-
-
-    
-    
-
-
-
-
-
-def compute_orbit_and_gradients(params,w0,dt,n_steps,units):
-    pot = Hernquist(m=params['m'], a=params['a'],units=units,)  # Create the potential with the given parameters
-    
-    # Example Orbit:
-    #w0 = jnp.array([10, 0, 0, 0, .204, 0])
-    t0 = 0
-    #dt = 0.1
-    #n_steps = 10000
-    ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)
-    
-    ### Compute the orbit with the provided potential
-    ws_jax = leapfrog_run(w0, ts, pot.gradient)
-    
-    # Compute the gradient of the final position with respect to the potential parameters
-    def gradient_fn(params):
-        pot_with_params = Hernquist(m=params['m'], a=params['a'],units=units)
-        ws_with_params = leapfrog_run(w0, ts, pot_with_params.gradient)
-        final_position = ws_with_params[-1, :]  # Extract final position
-        return final_position
-    
-    # Compute the gradient using JAX's autodiff
-    gradient = jax.jacfwd(gradient_fn)(params)
-    
-    return ws_jax, gradient
-
-def get_stripping_time_arr(ts):
-    """
-    assuming a particle is released for index in the ts array
-    TODO: Custom release
-    """
-    t_release_arr = []
-    for i in range(len(ts)):
-        t_release_arr.append( ts[i:] )
-    return t_release_arr
-
-#def get_spl_funcs(ts,ws):
-#    return [InterpolatedUnivariateSpline(ts,ws[:,i],k=3) for i in range(3)]
-
-#def eval_spl_funcs(ts, spl_funcs):
-#    return jnp.array([spl_funcs[i](ts) for i in range(3)])
-
-@jax.jit
-def get_t_arr(ts,t_min):
-    def scan_fun(carry, t):
-        i, ts_curr = carry
-        
-        def true_func(ts_curr):
-            return ts_curr
-        def false_func(ts_curr):
-            return 0.0
-        is_cond_met = ts_curr > t_min
-        val_fill = jax.lax.cond(pred=is_cond_met, true_fun=true_func, false_fun=false_func,operand=ts_curr)
-        
-        return [i + 1,ts[i+1]], val_fill
-    init_carry = [0,ts[0]]
-    __, t_particle = jax.lax.scan(scan_fun, init_carry, ts)
-    return t_particle
-
-@jax.jit
-def ts_func(t,t_min):
-    def true_func(ts_curr):
-        return ts_curr
-    def false_func(ts_curr):
-        return 0.0
-    is_cond_met = t > t_min
-    return jax.lax.cond(pred=is_cond_met, true_fun=true_func, false_fun=false_func,operand=t)
-
-
-
-@jax.jit
-def get_rot_mat(n_hat):
-    """
-    Get rotation matrix that transforms from INERTIAL coordinates to SATELLITE coordinates
-    https://math.stackexchange.com/questions/1956699/getting-a-transformation-matrix-from-a-normal-vector
-    """
-    nx,ny,nz = n_hat
-    nx_ny = jnp.sqrt(nx**2 + ny**2)
-    return jnp.array([[ny/nx_ny, -nx/nx_ny, 0], [nx*nz/nx_ny, ny*nz/nx_ny, -nx_ny], [nx,ny,nz]])
-
-def get_spl_funcs(ts,ws):
-    return [InterpolatedUnivariateSpline(ts,ws[:,0],k=3),InterpolatedUnivariateSpline(ts,ws[:,1],k=3), InterpolatedUnivariateSpline(ts,ws[:,2],k=3)]
-
-def eval_spl_funcs(ts, spl_funcs):
-    return jnp.array([spl_funcs[0](ts),spl_funcs[1](ts),spl_funcs[2](ts)])
\ No newline at end of file
diff --git a/JaxStreams_diffrax_refactored.py b/JaxStreams_diffrax_refactored.py
deleted file mode 100644
index ff2d979e..00000000
--- a/JaxStreams_diffrax_refactored.py
+++ /dev/null
@@ -1,495 +0,0 @@
-from functools import partial
-from astropy.constants import G
-import astropy.coordinates as coord
-import astropy.units as u
-# gala
-import gala.coordinates as gc
-import gala.dynamics as gd
-import gala.potential as gp
-from gala.units import dimensionless, galactic, UnitSystem
-
-import jax
-import jax.numpy as jnp
-
-from jax.config import config
-config.update("jax_enable_x64", True)
-import jax.random as random 
-from jax_cosmo.scipy.interpolate import InterpolatedUnivariateSpline
-from diffrax import diffeqsolve, ODETerm, Dopri5,SaveAt,PIDController,DiscreteTerminatingEvent
-
-usys = UnitSystem(u.kpc, u.Myr, u.Msun, u.radian)
-
-class Potential:
-    
-    def __init__(self, units, params):
-        if units is None:
-            units = dimensionless
-        self.units = UnitSystem(units)
-        
-        if self.units == dimensionless:
-            self._G = 1
-        else:
-            self._G = G.decompose(self.units).value
-        
-        for name, param in params.items():
-            if hasattr(param, 'unit'):
-                param = param.decompose(self.units).value
-            setattr(self, name, param)
-    
-    @partial(jax.jit, static_argnums=(0,))
-    def gradient(self, xyz, t):
-        grad_func = jax.grad(self.potential)
-        return grad_func(xyz, t)
-    
-    @partial(jax.jit, static_argnums=(0,))
-    def density(self, xyz, t):
-        lap = jnp.trace(jax.hessian(self.potential)(xyz, t))
-        return lap / (4 * jnp.pi * self._G)
-    
-    @partial(jax.jit, static_argnums=(0,))
-    def acceleration(self, xyz, t):
-        return -self.gradient(xyz, t)
-    
-   
-    @partial(jax.jit,static_argnums=(0,))
-    def jacobian_force_mw(self, xyz, t):
-        jacobian_force_mw = jax.jacfwd(self.gradient)
-        return jacobian_force_mw(xyz, t)
-    
-    @partial(jax.jit,static_argnums=(0,))
-    def d2phidr2_mw(self, x, t):
-        """
-        Computes the second derivative of the Milky Way potential at a position x (in the simulation frame)
-        Args:
-          x: 3d position (x, y, z) in [kpc]
-        Returns:
-          Second derivative of force (per unit mass) in [1/Myr^2]
-        Examples
-        --------
-        >>> d2phidr2_mw(x=jnp.array([8.0, 0.0, 0.0]))
-        """
-        rad = jnp.linalg.norm(x)
-        r_hat = x/rad
-        dphi_dr_func = lambda x: jnp.sum(self.gradient(x,t)*r_hat)
-        return jnp.sum(jax.grad(dphi_dr_func)(x)*r_hat)
-        
-        ##return jnp.matmul(jnp.transpose(x), jnp.matmul(self.jacobian_force_mw(x, t), x)) / rad**2
-
-
-    @partial(jax.jit,static_argnums=(0,))
-    def omega(self, x,v):
-        """
-        Computes the magnitude of the angular momentum in the simulation frame
-        Args:
-          x: 3d position (x, y, z) in [kpc]
-          v: 3d velocity (v_x, v_y, v_z) in [kpc/Myr]
-        Returns:
-          Magnitude of angular momentum in [rad/Myr]
-        Examples
-        --------
-        >>> omega(x=jnp.array([8.0, 0.0, 0.0]), v=jnp.array([8.0, 0.0, 0.0]))
-        """
-        rad = jnp.sqrt(x[0] ** 2 + x[1] ** 2 + x[2] ** 2)
-        omega_vec = jnp.cross(x, v) / (rad**2)
-        return jnp.linalg.norm(omega_vec)
-
-    @partial(jax.jit,static_argnums=(0,))
-    def tidalr_mw(self, x, v, Msat, t):
-        """
-        Computes the tidal radius of a cluster in the potential
-        Args:
-          x: 3d position (x, y, z) in [kpc]
-          v: 3d velocity (v_x, v_y, v_z) in [kpc/Myr]
-          Msat: Cluster mass in [Msol]
-        Returns:
-          Tidal radius of the cluster in [kpc]
-        Examples
-        --------
-        >>> tidalr_mw(x=jnp.array([8.0, 0.0, 0.0]), v=jnp.array([8.0, 0.0, 0.0]), Msat=1e4)
-        """
-        return (self._G * Msat / ( self.omega(x, v) ** 2 - self.d2phidr2_mw(x, t)) ) ** (1.0 / 3.0)
-    
-    @partial(jax.jit,static_argnums=(0,))
-    def lagrange_pts(self,x,v,Msat, t):
-        r_tidal = self.tidalr_mw(x,v,Msat, t)
-        r_hat = x/jnp.linalg.norm(x)
-        L_close = x - r_hat*r_tidal
-        L_far = x + r_hat*r_tidal
-        return L_close, L_far
-    
-    @partial(jax.jit,static_argnums=(0,))
-    def velocity_acceleration(self,t,xv,args):
-        x, v = xv[:3], xv[3:]
-        acceleration = -self.gradient(x,t)
-        return jnp.hstack([v,acceleration])
-    
-    @partial(jax.jit,static_argnums=(0,))
-    def orbit_integrator_run(self,w0,t0,t1,ts):
-        term = ODETerm(self.velocity_acceleration)
-        solver = Dopri5()
-        saveat = SaveAt(t0=False, t1=True, ts=ts, dense=False)
-        rtol: float = 1e-7
-        atol: float = 1e-7
-        stepsize_controller = PIDController(rtol=rtol, atol=atol)
-        max_steps: int = 16**3
-        t0 = t0#0.0
-        t1 = t1#4000.
-        dense = False
-        #y0= w_init
-
-        solution = diffeqsolve(
-            terms=term,
-            solver=solver,
-            t0=t0,
-            t1=t1,
-            y0=w0,
-            dt0=None,
-            saveat=saveat,
-            stepsize_controller=stepsize_controller,
-            discrete_terminating_event=None,
-            max_steps=(max_steps if dense else None),
-        )
-        return solution.ys 
-    
-
-    
-    
-    @partial(jax.jit,static_argnums=(0,))
-    def release_model(self, x, v, Msat,i, t, seed_num):
-        """
-        Simplification of particle spray: just release particles in gaussian blob at each lagrange point.
-        User sets the spatial and velocity dispersion for the "leaking" of particles
-        TODO: change random key handling... need to do all of the sampling up front...
-        """
-        key_master = jax.random.PRNGKey(seed_num)
-        random_ints = jax.random.randint(key=key_master,shape=(5,),minval=0,maxval=1000)
-
-        keya = jax.random.PRNGKey(i*random_ints[0])#jax.random.PRNGKey(i*13)
-        keyb = jax.random.PRNGKey(i*random_ints[1])#jax.random.PRNGKey(i*23)
-        
-        keyc = jax.random.PRNGKey(i*random_ints[2])#jax.random.PRNGKey(i*27)
-        keyd = jax.random.PRNGKey(i*random_ints[3])#jax.random.PRNGKey(i*3)
-        keye = jax.random.PRNGKey(i*random_ints[4])#jax.random.PRNGKey(i*17)
-        
-        L_close, L_far = self.lagrange_pts(x,v,Msat, t) # each is an xyz array
-        
-        omega_val = self.omega(x,v)
-        
-        
-        r = jnp.linalg.norm(x)
-        r_hat = x/r
-        r_tidal = self.tidalr_mw(x,v,Msat, t)
-        rel_v = omega_val*r_tidal #relative velocity
-        
-        #circlar_velocity
-        dphi_dr = jnp.sum(self.gradient(x, t)*r_hat)
-        v_circ = rel_v##jnp.sqrt( r*dphi_dr )
-        
-        L_vec = jnp.cross(x,v)
-        z_hat = L_vec / jnp.linalg.norm(L_vec)
-        
-        phi_vec = v - jnp.sum(v*r_hat)*r_hat
-        phi_hat = phi_vec/jnp.linalg.norm(phi_vec)
-        vt_sat = jnp.sum(v*phi_hat)
-        
-        
-        kr_bar = 2.0
-        kvphi_bar = 0.3
-        ####################kvt_bar = 0.3 ## FROM GALA
-        
-        kz_bar = 0.0
-        kvz_bar = 0.0
-        
-        sigma_kr = 0.5
-        sigma_kvphi = 0.5
-        sigma_kz = 0.5
-        sigma_kvz = 0.5
-        ##############sigma_kvt = 0.5 ##FROM GALA
-        
-        kr_samp =  kr_bar + jax.random.normal(keya,shape=(1,))*sigma_kr
-        kvphi_samp = kr_samp*(kvphi_bar  + jax.random.normal(keyb,shape=(1,))*sigma_kvphi)
-        kz_samp = kz_bar + jax.random.normal(keyc,shape=(1,))*sigma_kz
-        kvz_samp = kvz_bar + jax.random.normal(keyd,shape=(1,))*sigma_kvz
-        ########kvt_samp = kvt_bar + jax.random.normal(keye,shape=(1,))*sigma_kvt
-        
-        ## Trailing arm
-        pos_trail = x + kr_samp*r_hat*(r_tidal) #nudge out
-        pos_trail  = pos_trail + z_hat*kz_samp*(r_tidal/1.0)#r #nudge above/below orbital plane
-        v_trail = v + (0.0 + kvphi_samp*v_circ*(1.0))*phi_hat#v + (0.0 + kvphi_samp*v_circ*(-r_tidal/r))*phi_hat #nudge velocity along tangential direction
-        v_trail = v_trail + (kvz_samp*v_circ*(1.0))*z_hat#v_trail + (kvz_samp*v_circ*(-r_tidal/r))*z_hat #nudge velocity along vertical direction
-        
-        ## Leading arm
-        pos_lead = x + kr_samp*r_hat*(-r_tidal) #nudge in
-        pos_lead  = pos_lead + z_hat*kz_samp*(-r_tidal/1.0)#r #nudge above/below orbital plane
-        v_lead = v + (0.0 + kvphi_samp*v_circ*(-1.0))*phi_hat#v + (0.0 + kvphi_samp*v_circ*(r_tidal/r))*phi_hat #nudge velocity along tangential direction
-        v_lead = v_lead + (kvz_samp*v_circ*(-1.0))*z_hat#v_lead + (kvz_samp*v_circ*(r_tidal/r))*z_hat #nudge velocity against vertical direction
-        
-    
-        
-        
-        return pos_lead, pos_trail, v_lead, v_trail
-    
-    @partial(jax.jit,static_argnums=(0,))
-    def gen_stream_ics(self, ts, prog_w0, Msat, seed_num):
-        ws_jax = self.orbit_integrator_run(prog_w0,jnp.min(ts),jnp.max(ts),ts)
-        
-        def scan_fun(carry, t):
-            i, pos_close, pos_far, vel_close, vel_far = carry
-            pos_close_new, pos_far_new, vel_close_new, vel_far_new = self.release_model(ws_jax[i,:3], ws_jax[i,3:], Msat,i, t, seed_num)
-            return [i+1, pos_close_new, pos_far_new, vel_close_new, vel_far_new], [pos_close_new, pos_far_new, vel_close_new, vel_far_new]#[i+1, pos_close_new, pos_far_new, vel_close_new, vel_far_new]
-            
-            
-        #init_carry = [0, 0, 0, 0, 0]
-        init_carry = [0, jnp.array([0.0,0.0,0.]), jnp.array([0.0,0.0,0.]), jnp.array([0.0,0.0,0.]), jnp.array([0.0,0.0,0.])] 
-        final_state, all_states = jax.lax.scan(scan_fun, init_carry, ts[1:])
-        pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr = all_states
-        return pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr
-    
-            
-    @partial(jax.jit,static_argnums=(0,))
-    def gen_stream_scan(self, ts, prog_w0, Msat, seed_num):
-        """
-        Generate stellar stream by scanning over the release model/integration. Better for CPU usage.
-        """
-        pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr = self.gen_stream_ics(ts, prog_w0, Msat, seed_num)
-        @jax.jit
-        def scan_fun(carry, particle_idx):
-            i, pos_close_curr, pos_far_curr, vel_close_curr, vel_far_curr = carry
-            curr_particle_w0_close = jnp.hstack([pos_close_curr,vel_close_curr])
-            curr_particle_w0_far = jnp.hstack([pos_far_curr,vel_far_curr])
-            w0_lead_trail = jnp.vstack([curr_particle_w0_close,curr_particle_w0_far])
-            
-            minval, maxval =  ts[i],ts[-1]
-            integrate_different_ics = lambda ics:  self.orbit_integrator_run(ics,minval,maxval,None)[0]
-            w_particle_close, w_particle_far = jax.vmap(integrate_different_ics,in_axes=(0,))(w0_lead_trail) #vmap over leading and trailing arm
-            
-            
-            
-            return [i+1, pos_close_arr[i+1,:], pos_far_arr[i+1,:], vel_close_arr[i+1,:], vel_far_arr[i+1,:]], [w_particle_close, w_particle_far]
-        init_carry = [0, pos_close_arr[0,:], pos_far_arr[0,:], vel_close_arr[0,:], vel_far_arr[0,:]]
-        particle_ids = jnp.arange(len(pos_close_arr))
-        final_state, all_states = jax.lax.scan(scan_fun, init_carry, particle_ids)
-        lead_arm, trail_arm = all_states
-        return lead_arm, trail_arm
-    
-    @partial(jax.jit,static_argnums=(0,))
-    def gen_stream_vmapped(self, ts, prog_w0, Msat, seed_num):
-        """
-        Generate stellar stream by vmapping over the release model/integration. Better for GPU usage.
-        """
-        pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr = self.gen_stream_ics(ts, prog_w0, Msat, seed_num)
-        @jax.jit
-        def single_particle_integrate(particle_number,pos_close_curr,pos_far_curr,vel_close_curr,vel_far_curr):
-            curr_particle_w0_close = jnp.hstack([pos_close_curr,vel_close_curr])
-            curr_particle_w0_far = jnp.hstack([pos_far_curr,vel_far_curr])
-            t_release = ts[particle_number]
-            t_final = ts[-1] + .01
-            
-            w_particle_close = self.orbit_integrator_run(curr_particle_w0_close,t_release,t_final,None)[0]
-            w_particle_far = self.orbit_integrator_run(curr_particle_w0_far,t_release,t_final,None)[0]
-            
-            return w_particle_close, w_particle_far
-        particle_ids = jnp.arange(len(pos_close_arr))
-        
-        return jax.vmap(single_particle_integrate,in_axes=(0,0,0,0,0,))(particle_ids,pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr)
-
-
-@jax.jit
-def get_splines(x_eval,x,y):
-    return InterpolatedUnivariateSpline(x,y,k=3)(x_eval)
-
-@jax.jit
-def map_splines(x_eval,x,y_fit):
-    return jax.vmap(get_splines,in_axes=((None,None,1,)))(x_eval,x,y_fit)
-
-
-@jax.jit
-def interp_func(x_eval,x_fit,y_fit):
-    return jnp.interp(x_eval,x_fit,y_fit)
-    
-@jax.jit
-def single_subhalo_potential(dct,xyz,t):
-    """
-    Potential for a single subhalo
-    TODO: custom unit specification/subhalo potential specficiation. 
-    Currently supports units kpc, Myr, Msun, rad.
-    """
-    pot_single = Isochrone(m=dct['m'],a=dct['a'],units=usys)
-    return pot_single.potential(xyz,t)
-
-class SubHaloPopulation(Potential):
-    def __init__(self, m, a, txyz_subhalo_arr, t_orbit, units=None):
-        """
-        m has length n_subhalo
-        a has length n_subhalo
-        txyz_subhalo_arr has shape t_orbit x n_subhalo x 3
-        t_orbit is the array of times the subhalos are integrated over
-        """
-        super().__init__(units, {'m': m, 'a': a, 'txyz_subhalo_arr': txyz_subhalo_arr, 't_orbit': t_orbit})
-        self.dct = {'m': self.m, 'a': self.a,}    
-        
-    @partial(jax.jit, static_argnums=(0,))
-    def potential(self, xyz, t):
-            
-        x_at_t_eval = get_splines(t, self.t_orbit,self.txyz_subhalo_arr[:,:,0]) # expect n_subhalo x-positions
-        y_at_t_eval = get_splines(t, self.t_orbit,self.txyz_subhalo_arr[:,:,1]) # expect n_subhalo y-positions
-        z_at_t_eval = get_splines(t, self.t_orbit,self.txyz_subhalo_arr[:,:,2]) # expect n_subhalo z-positions
-            
-        subhalo_locations = jnp.vstack([x_at_t_eval,y_at_t_eval,z_at_t_eval]).T # n_subhalo x 3: the position of all subhalos at time t
-        
-        delta_position = xyz - subhalo_locations # n_subhalo x 3
-        # sum over potential due to all subhalos in the field by vmapping over m, a, and delta_position
-        ##dct = {'m': self.m, 'a': self.a,}
-        pot_total = jnp.sum( jax.vmap(single_subhalo_potential,in_axes=( ({'m':0,'a':0,},0,None) ) )(self.dct,delta_position,t) ) 
-        return pot_total
-        
-    
-    
-class Isochrone(Potential):
-    
-    def __init__(self, m, a, units=None):
-        super().__init__(units, {'m': m, 'a': a})
-    
-    @partial(jax.jit, static_argnums=(0,))
-    def potential(self, xyz, t):
-        r = jnp.linalg.norm(xyz, axis=0)
-        return - self._G * self.m / (self.a + jnp.sqrt(r**2 + self.a**2))
-    
-
-    
-class Isochrone_centered(Potential):
-    
-    def __init__(self, m, a, spline_eval_func, splines, t_min, t_max, m_ext, a_ext, units=None):
-        super().__init__(units, {'m': m, 'a': a, 'spline_eval_func': spline_eval_func, 'splines': splines, 't_min': t_min, 't_max': t_max,
-                                'm_ext': m_ext, 'a_ext': a_ext})
-    
-    @partial(jax.jit, static_argnums=(0,))
-    def potential(self, xyz, t):
-        is_cond_met = (t > self.t_min) & (t < self.t_max) # True if yes, False if no
-        pot_ext = Isochrone(m=self.m_ext, a=self.a_ext, units=self.units) 
-        
-        def true_func(xyz_t):
-            xyz_, t = xyz_t[:3], xyz_t[-1]
-            xyz = xyz_ - self.spline_eval_func(t,self.splines)
-            r = jnp.linalg.norm(xyz, axis=0)
-            return - self._G * self.m / (self.a + jnp.sqrt(r**2 + self.a**2))  + pot_ext.potential(xyz_,t)#+ self.pot_ext.potential(xyz_,t)
-        def false_func(xyz_t):
-            xyz, t = xyz_t[:3], xyz_t[-1]
-            return pot_ext.potential(xyz,t)#0.#self.pot_ext.potential(xyz,t)
-        xyz_t = jnp.hstack([xyz,t])
-        return jax.lax.cond(pred=is_cond_met, true_fun=true_func, false_fun=false_func,operand=xyz_t)
-    
-class MiyamotoNagaiDisk(Potential):
-    def __init__(self, m, a, b, units=None):
-        super().__init__(units, {'m': m, 'a': a, 'b': b,})
-    @partial(jax.jit,static_argnums=(0,))
-    def potential(self,xyz,t):
-        R2 = xyz[0]**2 + xyz[1]**2
-        return -self._G*self.m / jnp.sqrt(R2 + jnp.square(jnp.sqrt(xyz[2]**2 + self.b**2) + self.a))
-    
-class NFWPotential_holder(Potential):
-    """
-    Flattening in potential, not density
-    Form from http://gala.adrian.pw/en/v0.1.2/api/gala.potential.FlattenedNFWPotential.html
-    """
-    def __init__(self, v_c, r_s, q, units=None):
-        super().__init__(units, {'v_c': v_c, 'r_s': r_s, 'q': q})
-    @partial(jax.jit,static_argnums=(0,))
-    def potential(self,xyz,t):
-        m = jnp.sqrt(xyz[0]**2 + xyz[1]**2 + (xyz[2]/self.q)**2)
-        return -((self.v_c**2)/jnp.sqrt(jnp.log(2.0)-0.5) )*jnp.log(1.0 + m/self.r_s)/(m/self.r_s)
-    
-class NFWPotential(Potential):
-    """
-    standard def see spherical model @ https://github.com/adrn/gala/blob/main/gala/potential/potential/builtin/builtin_potentials.c
-    """
-    def __init__(self, m, r_s, units=None):
-        super().__init__(units, {'m': m, 'r_s': r_s})
-    @partial(jax.jit,static_argnums=(0,))
-    def potential(self,xyz,t):
-        v_h2 = -self._G*self.m/self.r_s
-        m = jnp.sqrt(xyz[0]**2 + xyz[1]**2 + xyz[2]**2 + .001)/self.r_s ##added softening!
-        return v_h2*jnp.log(1.0+ m) / m#-((self.v_c**2)/jnp.sqrt(jnp.log(2.0)-0.5) )*jnp.log(1.0 + m/self.r_s)/(m/self.r_s)
-    
-    
-class BarPotential(Potential):
-    """
-    Rotating bar potentil, with hard-coded rotation.
-    Eq 8a in https://articles.adsabs.harvard.edu/pdf/1992ApJ...397...44L
-    Rz according to https://en.wikipedia.org/wiki/Rotation_matrix
-    """
-    def __init__(self, m, a, b, c, Omega, units=None):
-        super().__init__(units, {'m': m, 'a': a, 'b': b, 'c': c, 'Omega': Omega})
-    @partial(jax.jit,static_argnums=(0,))
-    def potential(self,xyz,t):
-        ## First take the simulation frame coordinates and rotate them by Omega*t
-        ang = -self.Omega*t
-        Rot_mat = jnp.array([[jnp.cos(ang), -jnp.sin(ang), 0], [jnp.sin(ang), jnp.cos(ang), 0.], [0.0, 0.0, 1.0] ])
-        Rot_inv = jnp.linalg.inv(Rot_mat)
-        xyz_corot = jnp.matmul(Rot_mat,xyz)
-        
-        T_plus = jnp.sqrt( (self.a + xyz_corot[0])**2 + xyz_corot[1]**2 + ( self.b + jnp.sqrt(self.c**2 + xyz_corot[2]**2) )**2 )
-        T_minus = jnp.sqrt( (self.a - xyz_corot[0])**2 + xyz_corot[1]**2 + ( self.b + jnp.sqrt(self.c**2 + xyz_corot[2]**2) )**2 )
-        
-        pot_corot_frame = (self._G*self.m/(2.0*self.a))*jnp.log( (xyz_corot[0] - self.a + T_minus)/(xyz_corot[0] + self.a + T_plus) )
-        return pot_corot_frame
-    
-    
-class Potential_Combine(Potential):
-    def __init__(self, potential_list, units=None):
-        super().__init__(units, {'potential_list': potential_list })
-    
-    @partial(jax.jit,static_argnums=(0,))
-    def potential(self, xyz, t,):
-        output = []
-        for i in range(len(self.potential_list)):
-            output.append(self.potential_list[i].potential(xyz,t))
-        return jnp.sum(jnp.array(output))
-    
-    
-def leapfrog_step(func, y0, t0, dt, a0):
-    ndim = y0.shape[0] // 2
-    tf = t0 + dt
-    
-    x0 = y0[:ndim]
-    v0 = y0[ndim:]
-    
-    v1_2 = v0 + a0 * dt / 2.
-    xf = x0 + v1_2 * dt
-    af = - func(xf, tf)
-    
-    vf = v1_2 + af * dt / 2
-    
-    return tf, jnp.concatenate((xf, vf)), af
-
-@partial(jax.jit, static_argnames=['potential_gradient', 'args'])
-def leapfrog_run(w0, ts, potential_gradient, args=()):
-    func_ = lambda y, t: potential_gradient(y, t, *args)
-    
-    def scan_fun(carry, t):
-        i, y0, t0, dt, a0 = carry
-        tf, yf, af = leapfrog_step(func_, y0, t0, dt, a0)
-        dt_new = ts[i+1] - ts[i]
-        is_cond_met = jnp.abs(dt_new) > 0.  ### !!! ADDED jnp.abs AFTER derivs worked. Note for future debugging efforts!
-        
-        def true_func(dt_new):
-            return ts[-1]-ts[-2] #dt_base !!!ASSUMING dt = 0.5 Myr by default!!!!
-        def false_func(dt_new):
-            return 0.0
-        dt_new = jax.lax.cond(pred=is_cond_met, true_fun=true_func, false_fun=false_func,operand=dt_new)
-        
-        ###tf = tf + dt_new
-        return [i + 1, yf, tf, dt_new, af], yf
-    
-    ndim = w0.shape[0] // 2
-    a0 = -func_(w0[:ndim], ts[0]) ##### SHOULD THIS BE NEGATIVE??? TODO
-    dt = ts[1]-ts[0] ## I ADDED THIS
-    init_carry = [0, w0, ts[0], dt, a0]
-    _, ws = jax.lax.scan(scan_fun, init_carry, ts[1:])
-    res_ws = jnp.concatenate((w0[None], ws))
-    
-    return res_ws
-
-    
-
-
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 00000000..48f9efbc
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2023, Nathaniel Starkman.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the vector package developers nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/Pal5Diffrax.ipynb b/Pal5Diffrax.ipynb
deleted file mode 100644
index 8f3706cc..00000000
--- a/Pal5Diffrax.ipynb
+++ /dev/null
@@ -1,1563 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 31,
-   "id": "ce20e732-c3cf-4890-8b5e-11fabbb32e25",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from functools import partial\n",
-    "\n",
-    "from astropy.constants import G\n",
-    "import astropy.coordinates as coord\n",
-    "import astropy.units as u\n",
-    "import matplotlib as mpl\n",
-    "import matplotlib.pyplot as plt\n",
-    "%matplotlib inline\n",
-    "import numpy as np\n",
-    "\n",
-    "# gala\n",
-    "import gala.coordinates as gc\n",
-    "import gala.dynamics as gd\n",
-    "import gala.potential as gp\n",
-    "from gala.units import dimensionless, galactic, UnitSystem\n",
-    "import time\n",
-    "\n",
-    "import jax\n",
-    "import jax.numpy as jnp\n",
-    "\n",
-    "from jax.config import config\n",
-    "config.update(\"jax_enable_x64\", True)\n",
-    "\n",
-    "import scienceplots\n",
-    "import cmasher as cmr\n",
-    "plt.style.use('science')\n",
-    "import jax.random as random \n",
-    "from matplotlib.patches import Ellipse\n",
-    "import jax.scipy.stats as statsjax\n",
-    "\n",
-    "usys = UnitSystem(u.kpc, u.Myr, u.Msun, u.radian)\n",
-    "\n",
-    "import JaxStreams_diffrax as JaxStreams"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 32,
-   "id": "86db6a76-819c-4da9-958b-c8b80e457b77",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "bar_pattern = ((-60.0*u.km/u.s)/u.kpc).to(1.0/u.Myr).value #in rad / Myr\n",
-    "\n",
-    "params_global_potential = {'m_disk':5.0e10, 'a_disk': 3.0, 'b_disk': 0.25, 'm_NFW': 1.0e12,\n",
-    "                          'r_s_NFW': 15.0, 'bar_m':1.0e10, 'bar_a':1.0, 'bar_b':1.0, 'bar_c':0.5, 'bar_Omega': bar_pattern}\n",
-    "\n",
-    "pot_disk = JaxStreams.MiyamotoNagaiDisk(m=params_global_potential['m_disk'], a=params_global_potential['a_disk'],\n",
-    "                                       b=params_global_potential['b_disk'],units=usys)\n",
-    "pot_NFW = JaxStreams.NFWPotential(m=params_global_potential['m_NFW'], r_s=params_global_potential['r_s_NFW'],units=usys)\n",
-    "\n",
-    "pot_Bar = JaxStreams.BarPotential(m=params_global_potential['bar_m'], a=params_global_potential['bar_a'],\n",
-    "                                 b=params_global_potential['bar_b'], c=params_global_potential['bar_c'],Omega=params_global_potential['bar_Omega'],units=usys)\n",
-    "\n",
-    "## Combine potentials\n",
-    "potential_list = [pot_disk,pot_NFW,pot_Bar]\n",
-    "pot = JaxStreams.Potential_Combine(potential_list=potential_list,units=usys)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 33,
-   "id": "5846c218-d148-4d67-9850-b15d87a84884",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pal5_c = coord.SkyCoord(ra=229.018*u.degree, dec=-0.124*u.degree,\n",
-    "                         distance=22.9*u.kpc,\n",
-    "                         pm_ra_cosdec=-2.296*u.mas/u.yr,\n",
-    "                         pm_dec=-2.257*u.mas/u.yr,\n",
-    "                         radial_velocity=-58.7*u.km/u.s)\n",
-    "rep = pal5_c.transform_to(coord.Galactocentric).data\n",
-    "pal5_w0 = gd.PhaseSpacePosition(rep)\n",
-    "\n",
-    "wf = jnp.hstack([pal5_w0.pos.xyz.T.value,pal5_w0.vel.d_xyz.to(u.kpc/u.Myr).value])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 34,
-   "id": "81e2b9fd-afc2-4905-aedf-03dee87e8655",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "t0 = 0.\n",
-    "dt = .5\n",
-    "n_steps = 4_000 #this is really how many particles you will have in one arm of the stream\n",
-    "ts = jnp.linspace(0,4000.,n_steps)###jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "t_back = -ts\n",
-    "w_back = pot.orbit_integrator_run(wf,t0=0.0,t1=t_back.min(),ts=None)[0]\n",
-    "ts_forward = jnp.linspace(t_back.min(),0,len(ts))\n",
-    "w_forward = pot.orbit_integrator_run(w_back,t0=t_back.min(),t1=0.0,ts=None)[0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "id": "37180156-3a42-4d30-b1c4-8e3bca760dc4",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array([-4.00000000e+03, -3.99899975e+03, -3.99799950e+03, ...,\n",
-       "       -2.00050013e+00, -1.00025006e+00,  0.00000000e+00], dtype=float64)"
-      ]
-     },
-     "execution_count": 35,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "ts_forward"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "id": "1c881f25-4b64-4622-a14f-91b320d91839",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "PERCENT error in position: [ 0.00812824  0.64895071  0.00157637 -0.05170073 -0.00079924 -0.30019444]\n"
-     ]
-    }
-   ],
-   "source": [
-    "print('PERCENT error in position:',100*(w_forward-wf)/wf)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 37,
-   "id": "345c2df3-e286-491b-ae3d-571f3620551d",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "13.093166828155518\n"
-     ]
-    }
-   ],
-   "source": [
-    "## Now generate a mock stream along the above orbit\n",
-    "M_sat = 2.5e4 #progenitor mass\n",
-    "start = time.time()\n",
-    "lead_arm, trail_arm = pot.gen_stream_final(ts_forward, w_back, M_sat,)\n",
-    "end = time.time()\n",
-    "print(end-start)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 38,
-   "id": "abbd15b3-46f0-4009-a60a-29718f8f9b00",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.scatter(lead_arm[:,0],lead_arm[:,1],s=0.1,rasterized=True)\n",
-    "plt.scatter(trail_arm[:,0],trail_arm[:,1],s=0.1,rasterized=True)\n",
-    "stream = jnp.vstack([lead_arm,trail_arm])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 39,
-   "id": "90fa0652-757f-4250-94a0-1ae6ed048283",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7faff33a40d0>"
-      ]
-     },
-     "execution_count": 39,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "kde = statsjax.gaussian_kde(stream[:,:3].T,bw_method=jnp.sqrt(.001**2 + .1**2))\n",
-    "key = jax.random.PRNGKey(3)\n",
-    "samps = kde.resample(key,[len(stream)]).T\n",
-    "plt.scatter(samps[:,0],samps[:,1],s=.4)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 40,
-   "id": "339decf3-003b-4002-bf8f-2028d4384697",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "@jax.jit\n",
-    "def gen_observed_stream(params,ts,w0,M_sat):\n",
-    "    pot_disk = JaxStreams.MiyamotoNagaiDisk(m=params['m_disk'], a=params['a_disk'],\n",
-    "                                               b=params['b_disk'],units=usys)\n",
-    "    pot_NFW = JaxStreams.NFWPotential(m=params['m_NFW'], r_s=params['r_s_NFW'],units=usys)\n",
-    "    \n",
-    "    pot_Bar = JaxStreams.BarPotential(m=params['bar_m'], a=params['bar_a'],\n",
-    "                                 b=params['bar_b'], c=params['bar_c'],Omega=params['bar_Omega'],units=usys)\n",
-    "\n",
-    "    ## Combine potentials\n",
-    "    potential_list = [pot_disk,pot_NFW,pot_Bar]\n",
-    "    pot = JaxStreams.Potential_Combine(potential_list=potential_list,units=usys)\n",
-    "    \n",
-    "    ## Generate a stream. This will be the \"observed\" stream, i.e., the DATA\n",
-    "    lead_arm, trail_arm = pot.gen_stream_final(ts, w0, M_sat,) \n",
-    "    \n",
-    "    return lead_arm, trail_arm #jnp.sum(lead_arm_obs**2 + trail_arm_obs**2)\n",
-    "@jax.jit\n",
-    "def compare_streams(params,ts,w0,M_sat):\n",
-    "    ## first generate data stream (no grad tracking)\n",
-    "    lead_arm, trail_arm = gen_observed_stream(params,ts,w0,M_sat)\n",
-    "    lead_arm_obs, trail_arm_obs = jax.lax.stop_gradient(lead_arm), jax.lax.stop_gradient(trail_arm)\n",
-    "    \n",
-    "    stream_obs = jnp.vstack([lead_arm_obs,trail_arm_obs])\n",
-    "    stream = jnp.vstack([lead_arm,trail_arm])\n",
-    "    \n",
-    "    #kde = statsjax.gaussian_kde(stream_obs[:,:3].T,bw_method=jnp.sqrt(.001**2 + .1**2))\n",
-    "    #log_like = jnp.sum(kde.logpdf(stream[:,:3].T)) \n",
-    "    return -jnp.sum(jnp.square(stream-stream_obs))#log_like#-jnp.sum( (lead_arm-lead_arm_obs)**2 + (trail_arm-trail_arm_obs)**2 )\n",
-    "    \n",
-    "    \n",
-    "@jax.jit\n",
-    "def first_deriv_func(params,ts,w0,M_sat):\n",
-    "    return jax.jacfwd(compare_streams,argnums=0)(params,ts,w0,M_sat)\n",
-    "\n",
-    "    \n",
-    "@jax.jit\n",
-    "def second_deriv_func(params,ts,w0,M_sat):\n",
-    "    return jax.jacfwd(first_deriv_func)(params,ts,w0,M_sat)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 41,
-   "id": "a86b96e0-38c2-407a-a4d0-0e876ddc0556",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array(-0., dtype=float64)"
-      ]
-     },
-     "execution_count": 41,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "compare_streams(params_global_potential,ts_forward,w_back,M_sat)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 42,
-   "id": "7abab1a0-2312-49b1-88a0-2095ca696c6c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "first_deriv = first_deriv_func(params_global_potential,ts_forward,w_back,M_sat)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 43,
-   "id": "b4bc74bb-1d91-4079-ada7-929008d2e112",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'a_disk': Array(-0., dtype=float64),\n",
-       " 'b_disk': Array(-0., dtype=float64),\n",
-       " 'bar_Omega': Array(-0., dtype=float64),\n",
-       " 'bar_a': Array(-0., dtype=float64),\n",
-       " 'bar_b': Array(-0., dtype=float64),\n",
-       " 'bar_c': Array(-0., dtype=float64),\n",
-       " 'bar_m': Array(-0., dtype=float64),\n",
-       " 'm_NFW': Array(-0., dtype=float64),\n",
-       " 'm_disk': Array(-0., dtype=float64),\n",
-       " 'r_s_NFW': Array(-0., dtype=float64)}"
-      ]
-     },
-     "execution_count": 43,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "first_deriv"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "id": "24e45ea2-587b-48c0-80de-ea67b459d96c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "###params_global_potential['a_disk'] = 14.0\n",
-    "###params_global_potential"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "ab6e6320-ad06-403e-8e72-30f66275d19e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "s = time.time()\n",
-    "second_deriv = second_deriv_func(params_global_potential,ts_forward,w_back,M_sat)\n",
-    "e = time.time()\n",
-    "print(e-s)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 30,
-   "id": "be73ed3e-c701-46aa-a882-a24f523a936d",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'a_disk': {'a_disk': Array(-3029.94913587, dtype=float64),\n",
-       "  'b_disk': Array(-298.45281684, dtype=float64),\n",
-       "  'bar_Omega': Array(703263.92155581, dtype=float64),\n",
-       "  'bar_a': Array(-659.85490716, dtype=float64),\n",
-       "  'bar_b': Array(-4736.47612287, dtype=float64),\n",
-       "  'bar_c': Array(-724.55080498, dtype=float64),\n",
-       "  'bar_m': Array(3.14989768e-06, dtype=float64),\n",
-       "  'm_NFW': Array(4.84871163e-07, dtype=float64),\n",
-       "  'm_disk': Array(7.28304136e-07, dtype=float64),\n",
-       "  'r_s_NFW': Array(-42780.35516641, dtype=float64)},\n",
-       " 'b_disk': {'a_disk': Array(-298.45281684, dtype=float64),\n",
-       "  'b_disk': Array(-29.62533055, dtype=float64),\n",
-       "  'bar_Omega': Array(68927.81470011, dtype=float64),\n",
-       "  'bar_a': Array(-64.84152151, dtype=float64),\n",
-       "  'bar_b': Array(-467.36814539, dtype=float64),\n",
-       "  'bar_c': Array(-71.90133027, dtype=float64),\n",
-       "  'bar_m': Array(3.10570425e-07, dtype=float64),\n",
-       "  'm_NFW': Array(4.76791881e-08, dtype=float64),\n",
-       "  'm_disk': Array(7.17690729e-08, dtype=float64),\n",
-       "  'r_s_NFW': Array(-4208.49060255, dtype=float64)},\n",
-       " 'bar_Omega': {'a_disk': Array(703263.92155581, dtype=float64),\n",
-       "  'b_disk': Array(68927.81470011, dtype=float64),\n",
-       "  'bar_Omega': Array(-1.8495671e+08, dtype=float64),\n",
-       "  'bar_a': Array(153978.86939486, dtype=float64),\n",
-       "  'bar_b': Array(1098492.47850197, dtype=float64),\n",
-       "  'bar_c': Array(167931.05841435, dtype=float64),\n",
-       "  'bar_m': Array(-0.00073086, dtype=float64),\n",
-       "  'm_NFW': Array(-0.00011254, dtype=float64),\n",
-       "  'm_disk': Array(-0.00016899, dtype=float64),\n",
-       "  'r_s_NFW': Array(9929504.34309076, dtype=float64)},\n",
-       " 'bar_a': {'a_disk': Array(-659.85490716, dtype=float64),\n",
-       "  'b_disk': Array(-64.84152151, dtype=float64),\n",
-       "  'bar_Omega': Array(153978.86939486, dtype=float64),\n",
-       "  'bar_a': Array(-144.65639243, dtype=float64),\n",
-       "  'bar_b': Array(-1033.2025, dtype=float64),\n",
-       "  'bar_c': Array(-157.95427227, dtype=float64),\n",
-       "  'bar_m': Array(6.86364661e-07, dtype=float64),\n",
-       "  'm_NFW': Array(1.05629166e-07, dtype=float64),\n",
-       "  'm_disk': Array(1.58480952e-07, dtype=float64),\n",
-       "  'r_s_NFW': Array(-9320.41602173, dtype=float64)},\n",
-       " 'bar_b': {'a_disk': Array(-4736.47612287, dtype=float64),\n",
-       "  'b_disk': Array(-467.36814539, dtype=float64),\n",
-       "  'bar_Omega': Array(1098492.47850197, dtype=float64),\n",
-       "  'bar_a': Array(-1033.2025, dtype=float64),\n",
-       "  'bar_b': Array(-7439.60066195, dtype=float64),\n",
-       "  'bar_c': Array(-1141.33249117, dtype=float64),\n",
-       "  'bar_m': Array(4.93307825e-06, dtype=float64),\n",
-       "  'm_NFW': Array(7.57681456e-07, dtype=float64),\n",
-       "  'm_disk': Array(1.13710648e-06, dtype=float64),\n",
-       "  'r_s_NFW': Array(-66877.22363868, dtype=float64)},\n",
-       " 'bar_c': {'a_disk': Array(-724.55080498, dtype=float64),\n",
-       "  'b_disk': Array(-71.90133027, dtype=float64),\n",
-       "  'bar_Omega': Array(167931.05841435, dtype=float64),\n",
-       "  'bar_a': Array(-157.95427227, dtype=float64),\n",
-       "  'bar_b': Array(-1141.33249117, dtype=float64),\n",
-       "  'bar_c': Array(-176.02465374, dtype=float64),\n",
-       "  'bar_m': Array(7.55644699e-07, dtype=float64),\n",
-       "  'm_NFW': Array(1.15736712e-07, dtype=float64),\n",
-       "  'm_disk': Array(1.73936162e-07, dtype=float64),\n",
-       "  'r_s_NFW': Array(-10220.19625323, dtype=float64)},\n",
-       " 'bar_m': {'a_disk': Array(3.14989768e-06, dtype=float64),\n",
-       "  'b_disk': Array(3.10570425e-07, dtype=float64),\n",
-       "  'bar_Omega': Array(-0.00073086, dtype=float64),\n",
-       "  'bar_a': Array(6.86364661e-07, dtype=float64),\n",
-       "  'bar_b': Array(4.93307825e-06, dtype=float64),\n",
-       "  'bar_c': Array(7.55644699e-07, dtype=float64),\n",
-       "  'bar_m': Array(-3.27698096e-15, dtype=float64),\n",
-       "  'm_NFW': Array(-5.0395413e-16, dtype=float64),\n",
-       "  'm_disk': Array(-7.56813513e-16, dtype=float64),\n",
-       "  'r_s_NFW': Array(4.4471526e-05, dtype=float64)},\n",
-       " 'm_NFW': {'a_disk': Array(4.84871163e-07, dtype=float64),\n",
-       "  'b_disk': Array(4.76791881e-08, dtype=float64),\n",
-       "  'bar_Omega': Array(-0.00011254, dtype=float64),\n",
-       "  'bar_a': Array(1.05629166e-07, dtype=float64),\n",
-       "  'bar_b': Array(7.57681456e-07, dtype=float64),\n",
-       "  'bar_c': Array(1.15736712e-07, dtype=float64),\n",
-       "  'bar_m': Array(-5.0395413e-16, dtype=float64),\n",
-       "  'm_NFW': Array(-7.76265952e-17, dtype=float64),\n",
-       "  'm_disk': Array(-1.16532191e-16, dtype=float64),\n",
-       "  'r_s_NFW': Array(6.84832074e-06, dtype=float64)},\n",
-       " 'm_disk': {'a_disk': Array(7.28304136e-07, dtype=float64),\n",
-       "  'b_disk': Array(7.17690729e-08, dtype=float64),\n",
-       "  'bar_Omega': Array(-0.00016899, dtype=float64),\n",
-       "  'bar_a': Array(1.58480952e-07, dtype=float64),\n",
-       "  'bar_b': Array(1.13710648e-06, dtype=float64),\n",
-       "  'bar_c': Array(1.73936162e-07, dtype=float64),\n",
-       "  'bar_m': Array(-7.56813513e-16, dtype=float64),\n",
-       "  'm_NFW': Array(-1.16532191e-16, dtype=float64),\n",
-       "  'm_disk': Array(-1.75141662e-16, dtype=float64),\n",
-       "  'r_s_NFW': Array(1.0281026e-05, dtype=float64)},\n",
-       " 'r_s_NFW': {'a_disk': Array(-42780.35516641, dtype=float64),\n",
-       "  'b_disk': Array(-4208.49060255, dtype=float64),\n",
-       "  'bar_Omega': Array(9929504.34309076, dtype=float64),\n",
-       "  'bar_a': Array(-9320.41602173, dtype=float64),\n",
-       "  'bar_b': Array(-66877.22363868, dtype=float64),\n",
-       "  'bar_c': Array(-10220.19625323, dtype=float64),\n",
-       "  'bar_m': Array(4.4471526e-05, dtype=float64),\n",
-       "  'm_NFW': Array(6.84832074e-06, dtype=float64),\n",
-       "  'm_disk': Array(1.0281026e-05, dtype=float64),\n",
-       "  'r_s_NFW': Array(-604195.54944939, dtype=float64)}}"
-      ]
-     },
-     "execution_count": 30,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "second_deriv"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "id": "5eb01423-695a-4105-b46e-437087335af9",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'a_disk': {'a_disk': Array(-17724.24106433, dtype=float64),\n",
-       "  'b_disk': Array(-2477.25436233, dtype=float64),\n",
-       "  'bar_Omega': Array(2483334.5678001, dtype=float64),\n",
-       "  'bar_a': Array(1442.86764641, dtype=float64),\n",
-       "  'bar_b': Array(-7304.4447894, dtype=float64),\n",
-       "  'bar_c': Array(-1655.24154756, dtype=float64),\n",
-       "  'bar_m': Array(3.65679369e-06, dtype=float64),\n",
-       "  'm_NFW': Array(3.63601213e-07, dtype=float64),\n",
-       "  'm_disk': Array(2.08379471e-06, dtype=float64),\n",
-       "  'r_s_NFW': Array(-35030.7216627, dtype=float64)},\n",
-       " 'b_disk': {'a_disk': Array(-2477.25436233, dtype=float64),\n",
-       "  'b_disk': Array(-377.38437309, dtype=float64),\n",
-       "  'bar_Omega': Array(342189.94552824, dtype=float64),\n",
-       "  'bar_a': Array(185.96090977, dtype=float64),\n",
-       "  'bar_b': Array(-1022.61723488, dtype=float64),\n",
-       "  'bar_c': Array(-243.16347456, dtype=float64),\n",
-       "  'bar_m': Array(5.04098662e-07, dtype=float64),\n",
-       "  'm_NFW': Array(4.64655382e-08, dtype=float64),\n",
-       "  'm_disk': Array(2.84201031e-07, dtype=float64),\n",
-       "  'r_s_NFW': Array(-4544.50088627, dtype=float64)},\n",
-       " 'bar_Omega': {'a_disk': Array(2483334.5678001, dtype=float64),\n",
-       "  'b_disk': Array(342189.94552824, dtype=float64),\n",
-       "  'bar_Omega': Array(-5.8750683e+08, dtype=float64),\n",
-       "  'bar_a': Array(-174325.46294391, dtype=float64),\n",
-       "  'bar_b': Array(1012097.75108284, dtype=float64),\n",
-       "  'bar_c': Array(226293.48687455, dtype=float64),\n",
-       "  'bar_m': Array(-0.00051431, dtype=float64),\n",
-       "  'm_NFW': Array(-5.21427842e-05, dtype=float64),\n",
-       "  'm_disk': Array(-0.00029577, dtype=float64),\n",
-       "  'r_s_NFW': Array(5006050.79923726, dtype=float64)},\n",
-       " 'bar_a': {'a_disk': Array(1442.86764641, dtype=float64),\n",
-       "  'b_disk': Array(185.96090977, dtype=float64),\n",
-       "  'bar_Omega': Array(-174325.46294391, dtype=float64),\n",
-       "  'bar_a': Array(-137.41322351, dtype=float64),\n",
-       "  'bar_b': Array(592.43623564, dtype=float64),\n",
-       "  'bar_c': Array(129.53659413, dtype=float64),\n",
-       "  'bar_m': Array(-3.03683876e-07, dtype=float64),\n",
-       "  'm_NFW': Array(-3.22217972e-08, dtype=float64),\n",
-       "  'm_disk': Array(-1.75583274e-07, dtype=float64),\n",
-       "  'r_s_NFW': Array(3064.69891993, dtype=float64)},\n",
-       " 'bar_b': {'a_disk': Array(-7304.4447894, dtype=float64),\n",
-       "  'b_disk': Array(-1022.61723488, dtype=float64),\n",
-       "  'bar_Omega': Array(1012097.75108284, dtype=float64),\n",
-       "  'bar_a': Array(592.43623564, dtype=float64),\n",
-       "  'bar_b': Array(-3037.56474289, dtype=float64),\n",
-       "  'bar_c': Array(-685.86666074, dtype=float64),\n",
-       "  'bar_m': Array(1.49469655e-06, dtype=float64),\n",
-       "  'm_NFW': Array(1.46895311e-07, dtype=float64),\n",
-       "  'm_disk': Array(8.43291501e-07, dtype=float64),\n",
-       "  'r_s_NFW': Array(-14191.63579566, dtype=float64)},\n",
-       " 'bar_c': {'a_disk': Array(-1655.24154756, dtype=float64),\n",
-       "  'b_disk': Array(-243.16347456, dtype=float64),\n",
-       "  'bar_Omega': Array(226293.48687455, dtype=float64),\n",
-       "  'bar_a': Array(129.53659413, dtype=float64),\n",
-       "  'bar_b': Array(-685.86666074, dtype=float64),\n",
-       "  'bar_c': Array(-159.47771772, dtype=float64),\n",
-       "  'bar_m': Array(3.37639778e-07, dtype=float64),\n",
-       "  'm_NFW': Array(3.20202299e-08, dtype=float64),\n",
-       "  'm_disk': Array(1.90350662e-07, dtype=float64),\n",
-       "  'r_s_NFW': Array(-3114.41099967, dtype=float64)},\n",
-       " 'bar_m': {'a_disk': Array(3.65679369e-06, dtype=float64),\n",
-       "  'b_disk': Array(5.04098662e-07, dtype=float64),\n",
-       "  'bar_Omega': Array(-0.00051431, dtype=float64),\n",
-       "  'bar_a': Array(-3.03683876e-07, dtype=float64),\n",
-       "  'bar_b': Array(1.49469655e-06, dtype=float64),\n",
-       "  'bar_c': Array(3.37639778e-07, dtype=float64),\n",
-       "  'bar_m': Array(-7.61576198e-16, dtype=float64),\n",
-       "  'm_NFW': Array(-7.72341372e-17, dtype=float64),\n",
-       "  'm_disk': Array(-4.38397188e-16, dtype=float64),\n",
-       "  'r_s_NFW': Array(7.40959947e-06, dtype=float64)},\n",
-       " 'm_NFW': {'a_disk': Array(3.63601213e-07, dtype=float64),\n",
-       "  'b_disk': Array(4.64655382e-08, dtype=float64),\n",
-       "  'bar_Omega': Array(-5.21427842e-05, dtype=float64),\n",
-       "  'bar_a': Array(-3.22217972e-08, dtype=float64),\n",
-       "  'bar_b': Array(1.46895311e-07, dtype=float64),\n",
-       "  'bar_c': Array(3.20202299e-08, dtype=float64),\n",
-       "  'bar_m': Array(-7.72341372e-17, dtype=float64),\n",
-       "  'm_NFW': Array(-8.34575608e-18, dtype=float64),\n",
-       "  'm_disk': Array(-4.52795299e-17, dtype=float64),\n",
-       "  'r_s_NFW': Array(7.90944734e-07, dtype=float64)},\n",
-       " 'm_disk': {'a_disk': Array(2.08379471e-06, dtype=float64),\n",
-       "  'b_disk': Array(2.84201031e-07, dtype=float64),\n",
-       "  'bar_Omega': Array(-0.00029577, dtype=float64),\n",
-       "  'bar_a': Array(-1.75583274e-07, dtype=float64),\n",
-       "  'bar_b': Array(8.43291501e-07, dtype=float64),\n",
-       "  'bar_c': Array(1.90350662e-07, dtype=float64),\n",
-       "  'bar_m': Array(-4.38397188e-16, dtype=float64),\n",
-       "  'm_NFW': Array(-4.52795299e-17, dtype=float64),\n",
-       "  'm_disk': Array(-2.55187345e-16, dtype=float64),\n",
-       "  'r_s_NFW': Array(4.32684108e-06, dtype=float64)},\n",
-       " 'r_s_NFW': {'a_disk': Array(-35030.7216627, dtype=float64),\n",
-       "  'b_disk': Array(-4544.50088627, dtype=float64),\n",
-       "  'bar_Omega': Array(5006050.79923724, dtype=float64),\n",
-       "  'bar_a': Array(3064.69891993, dtype=float64),\n",
-       "  'bar_b': Array(-14191.63579566, dtype=float64),\n",
-       "  'bar_c': Array(-3114.41099967, dtype=float64),\n",
-       "  'bar_m': Array(7.40959947e-06, dtype=float64),\n",
-       "  'm_NFW': Array(7.90944734e-07, dtype=float64),\n",
-       "  'm_disk': Array(4.32684108e-06, dtype=float64),\n",
-       "  'r_s_NFW': Array(-75134.11704657, dtype=float64)}}"
-      ]
-     },
-     "execution_count": 26,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "second_deriv"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "f822bc80-0909-4e3b-afcf-802458e88aaa",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "id": "e8ff7084-8e12-4c3c-8c76-979a2cb3b262",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "start = time.time()\n",
-    "second_deriv = jax.jacfwd(first_deriv_func)(params_global_potential,ts_forward,w_back,M_sat)\n",
-    "end = time.time()\n",
-    "print(end-start)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 29,
-   "id": "a3c986bd-1c20-4e3f-90f5-fd26f027b97a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#second_deriv"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 30,
-   "id": "f3494321-f2e9-4858-adbe-1acb409ac51e",
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "RuntimeError",
-     "evalue": "Cannot reverse-mode autodifferentiate when using `diffeqsolve(..., max_steps=None, adjoint=RecursiveCheckpointAdjoint(checkpoints=None))`. This is because JAX needs to know how much memory to allocate for saving the forward pass. You should either put a bound on the maximum number of steps, or explicitly specify how many checkpoints to use.",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mJaxStackTraceBeforeTransformation\u001b[0m         Traceback (most recent call last)",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/runpy.py\u001b[0m in \u001b[0;36m_run_module_as_main\u001b[0;34m()\u001b[0m\n\u001b[1;32m    193\u001b[0m         \u001b[0msys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margv\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmod_spec\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0morigin\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 194\u001b[0;31m     return _run_code(code, main_globals, None,\n\u001b[0m\u001b[1;32m    195\u001b[0m                      \"__main__\", mod_spec)\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/runpy.py\u001b[0m in \u001b[0;36m_run_code\u001b[0;34m()\u001b[0m\n\u001b[1;32m     86\u001b[0m                        __spec__ = mod_spec)\n\u001b[0;32m---> 87\u001b[0;31m     \u001b[0mexec\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcode\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrun_globals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     88\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mrun_globals\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/ipykernel_launcher.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     15\u001b[0m     \u001b[0;32mfrom\u001b[0m \u001b[0mipykernel\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mkernelapp\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mapp\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 16\u001b[0;31m     \u001b[0mapp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlaunch_new_instance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/traitlets/config/application.py\u001b[0m in \u001b[0;36mlaunch_instance\u001b[0;34m()\u001b[0m\n\u001b[1;32m    845\u001b[0m         \u001b[0mapp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minitialize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 846\u001b[0;31m         \u001b[0mapp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstart\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    847\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/ipykernel/kernelapp.py\u001b[0m in \u001b[0;36mstart\u001b[0;34m()\u001b[0m\n\u001b[1;32m    676\u001b[0m             \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 677\u001b[0;31m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mio_loop\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstart\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    678\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mKeyboardInterrupt\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/tornado/platform/asyncio.py\u001b[0m in \u001b[0;36mstart\u001b[0;34m()\u001b[0m\n\u001b[1;32m    198\u001b[0m             \u001b[0masyncio\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_event_loop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masyncio_loop\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 199\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masyncio_loop\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_forever\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    200\u001b[0m         \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/asyncio/base_events.py\u001b[0m in \u001b[0;36mrun_forever\u001b[0;34m()\u001b[0m\n\u001b[1;32m    569\u001b[0m             \u001b[0;32mwhile\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 570\u001b[0;31m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_run_once\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    571\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_stopping\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/asyncio/base_events.py\u001b[0m in \u001b[0;36m_run_once\u001b[0;34m()\u001b[0m\n\u001b[1;32m   1858\u001b[0m             \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1859\u001b[0;31m                 \u001b[0mhandle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_run\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1860\u001b[0m         \u001b[0mhandle\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m  \u001b[0;31m# Needed to break cycles when an exception occurs.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/asyncio/events.py\u001b[0m in \u001b[0;36m_run\u001b[0;34m()\u001b[0m\n\u001b[1;32m     80\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 81\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_context\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_callback\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_args\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     82\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mSystemExit\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mKeyboardInterrupt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/ipykernel/kernelbase.py\u001b[0m in \u001b[0;36mdispatch_queue\u001b[0;34m()\u001b[0m\n\u001b[1;32m    456\u001b[0m             \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 457\u001b[0;31m                 \u001b[0;32mawait\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_one\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    458\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/ipykernel/kernelbase.py\u001b[0m in \u001b[0;36mprocess_one\u001b[0;34m()\u001b[0m\n\u001b[1;32m    445\u001b[0m                 \u001b[0;32mreturn\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 446\u001b[0;31m         \u001b[0;32mawait\u001b[0m \u001b[0mdispatch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    447\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/ipykernel/kernelbase.py\u001b[0m in \u001b[0;36mdispatch_shell\u001b[0;34m()\u001b[0m\n\u001b[1;32m    352\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0minspect\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0misawaitable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 353\u001b[0;31m                     \u001b[0;32mawait\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    354\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/ipykernel/kernelbase.py\u001b[0m in \u001b[0;36mexecute_request\u001b[0;34m()\u001b[0m\n\u001b[1;32m    647\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0minspect\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0misawaitable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreply_content\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 648\u001b[0;31m             \u001b[0mreply_content\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mawait\u001b[0m \u001b[0mreply_content\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    649\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/ipykernel/ipkernel.py\u001b[0m in \u001b[0;36mdo_execute\u001b[0;34m()\u001b[0m\n\u001b[1;32m    352\u001b[0m                 \u001b[0;31m# letting shell dispatch to loop runners\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 353\u001b[0;31m                 \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mshell\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_cell\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcode\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstore_history\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mstore_history\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msilent\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msilent\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    354\u001b[0m         \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/ipykernel/zmqshell.py\u001b[0m in \u001b[0;36mrun_cell\u001b[0;34m()\u001b[0m\n\u001b[1;32m    532\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_last_traceback\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 533\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mZMQInteractiveShell\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_cell\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    534\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/IPython/core/interactiveshell.py\u001b[0m in \u001b[0;36mrun_cell\u001b[0;34m()\u001b[0m\n\u001b[1;32m   2897\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2898\u001b[0;31m             result = self._run_cell(\n\u001b[0m\u001b[1;32m   2899\u001b[0m                 raw_cell, store_history, silent, shell_futures)\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/IPython/core/interactiveshell.py\u001b[0m in \u001b[0;36m_run_cell\u001b[0;34m()\u001b[0m\n\u001b[1;32m   2943\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2944\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mrunner\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcoro\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2945\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0mBaseException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/IPython/core/async_helpers.py\u001b[0m in \u001b[0;36m_pseudo_sync_runner\u001b[0;34m()\u001b[0m\n\u001b[1;32m     67\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 68\u001b[0;31m         \u001b[0mcoro\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     69\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mStopIteration\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mexc\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/IPython/core/interactiveshell.py\u001b[0m in \u001b[0;36mrun_cell_async\u001b[0;34m()\u001b[0m\n\u001b[1;32m   3168\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3169\u001b[0;31m                 has_raised = await self.run_ast_nodes(code_ast.body, cell_name,\n\u001b[0m\u001b[1;32m   3170\u001b[0m                        interactivity=interactivity, compiler=compiler, result=result)\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/IPython/core/interactiveshell.py\u001b[0m in \u001b[0;36mrun_ast_nodes\u001b[0;34m()\u001b[0m\n\u001b[1;32m   3360\u001b[0m                         \u001b[0masy\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcompare\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3361\u001b[0;31m                     \u001b[0;32mif\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;32mawait\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_code\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcode\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m,\u001b[0m  \u001b[0masync_\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0masy\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   3362\u001b[0m                         \u001b[0;32mreturn\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/IPython/core/interactiveshell.py\u001b[0m in \u001b[0;36mrun_code\u001b[0;34m()\u001b[0m\n\u001b[1;32m   3440\u001b[0m                 \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3441\u001b[0;31m                     \u001b[0mexec\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcode_obj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0muser_global_ns\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0muser_ns\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   3442\u001b[0m             \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_73122/1417532103.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mcompare_streams\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mparams_global_potential\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mts_forward\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mw_back\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mM_sat\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_73122/1337006448.py\u001b[0m in \u001b[0;36mcompare_streams\u001b[0;34m()\u001b[0m\n\u001b[1;32m     20\u001b[0m     \u001b[0;31m## first generate data stream (no grad tracking)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 21\u001b[0;31m     \u001b[0mlead_arm\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrail_arm\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgen_observed_stream\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mw0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mM_sat\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     22\u001b[0m     \u001b[0mlead_arm_obs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrail_arm_obs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstop_gradient\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlead_arm\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstop_gradient\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrail_arm\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_73122/1337006448.py\u001b[0m in \u001b[0;36mgen_observed_stream\u001b[0;34m()\u001b[0m\n\u001b[1;32m     14\u001b[0m     \u001b[0;31m## Generate a stream. This will be the \"observed\" stream, i.e., the DATA\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 15\u001b[0;31m     \u001b[0mlead_arm\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrail_arm\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpot\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgen_stream_final\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mw0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mM_sat\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     16\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/Desktop/Projects/JaxStreams/JaxStreams_diffrax.py\u001b[0m in \u001b[0;36mgen_stream_final\u001b[0;34m()\u001b[0m\n\u001b[1;32m    306\u001b[0m         \u001b[0;31m#print(len(particle_ids))\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 307\u001b[0;31m         \u001b[0mfinal_state\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mall_states\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscan\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mscan_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minit_carry\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparticle_ids\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    308\u001b[0m         \u001b[0;31m#print(final_state)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/Desktop/Projects/JaxStreams/JaxStreams_diffrax.py\u001b[0m in \u001b[0;36mscan_fun\u001b[0;34m()\u001b[0m\n\u001b[1;32m    287\u001b[0m             \u001b[0mintegrate_different_ics\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mics\u001b[0m\u001b[0;34m:\u001b[0m  \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0morbit_integrator_run\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mics\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mminval\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmaxval\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 288\u001b[0;31m             \u001b[0mw_particle_close\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mw_particle_far\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mintegrate_different_ics\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0min_axes\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mw0_lead_trail\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m#vmap over leading and trailing arm\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    289\u001b[0m             \u001b[0;31m#####w_particle_close = self.orbit_integrator_run(curr_particle_w0_close,minval,maxval,None)[0]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/Desktop/Projects/JaxStreams/JaxStreams_diffrax.py\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m()\u001b[0m\n\u001b[1;32m    286\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 287\u001b[0;31m             \u001b[0mintegrate_different_ics\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mics\u001b[0m\u001b[0;34m:\u001b[0m  \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0morbit_integrator_run\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mics\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mminval\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmaxval\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    288\u001b[0m             \u001b[0mw_particle_close\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mw_particle_far\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mintegrate_different_ics\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0min_axes\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mw0_lead_trail\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m#vmap over leading and trailing arm\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/Desktop/Projects/JaxStreams/JaxStreams_diffrax.py\u001b[0m in \u001b[0;36morbit_integrator_run\u001b[0;34m()\u001b[0m\n\u001b[1;32m    139\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 140\u001b[0;31m         solution = diffeqsolve(\n\u001b[0m\u001b[1;32m    141\u001b[0m             \u001b[0mterms\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mterm\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/equinox/_jit.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m()\u001b[0m\n\u001b[1;32m     74\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 75\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_fun_wrapper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     76\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/equinox/_jit.py\u001b[0m in \u001b[0;36m_fun_wrapper\u001b[0;34m()\u001b[0m\n\u001b[1;32m     63\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 64\u001b[0;31m             \u001b[0mdynamic_out\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstatic_out\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_cached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdynamic\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstatic\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     65\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mcombine\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdynamic_out\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstatic_out\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/equinox/_jit.py\u001b[0m in \u001b[0;36mfun_wrapped\u001b[0;34m()\u001b[0m\n\u001b[1;32m     34\u001b[0m         \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mhashable_combine\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdynamic_spec\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstatic_spec\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 35\u001b[0;31m         \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     36\u001b[0m         \u001b[0mdynamic_out\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstatic_out\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpartition\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mis_array\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/diffrax/integrate.py\u001b[0m in \u001b[0;36mdiffeqsolve\u001b[0;34m()\u001b[0m\n\u001b[1;32m    751\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 752\u001b[0;31m     final_state, aux_stats = adjoint.loop(\n\u001b[0m\u001b[1;32m    753\u001b[0m         \u001b[0margs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/diffrax/adjoint.py\u001b[0m in \u001b[0;36mloop\u001b[0;34m()\u001b[0m\n\u001b[1;32m    295\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mmsg\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 296\u001b[0;31m             final_state = eqxi.nondifferentiable_backward(\n\u001b[0m\u001b[1;32m    297\u001b[0m                 \u001b[0mfinal_state\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmsg\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmsg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msymbolic\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/equinox/internal/_nontraceable.py\u001b[0m in \u001b[0;36mnondifferentiable_backward\u001b[0;34m()\u001b[0m\n\u001b[1;32m    121\u001b[0m     \u001b[0mflat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbind\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mflat\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 122\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mcombine\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjtu\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtree_unflatten\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtreedef\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mflat\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstatic\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    123\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mJaxStackTraceBeforeTransformation\u001b[0m: RuntimeError: Cannot reverse-mode autodifferentiate when using `diffeqsolve(..., max_steps=None, adjoint=RecursiveCheckpointAdjoint(checkpoints=None))`. This is because JAX needs to know how much memory to allocate for saving the forward pass. You should either put a bound on the maximum number of steps, or explicitly specify how many checkpoints to use.\n\nThe preceding stack trace is the source of the JAX operation that, once transformed by JAX, triggered the following exception.\n\n--------------------",
-      "\nThe above exception was the direct cause of the following exception:\n",
-      "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_73122/2009254448.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mstart\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0msecond_deriv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjacrev\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfirst_deriv_func\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mparams_global_potential\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mts_forward\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mw_back\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mM_sat\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0mend\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mend\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mstart\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/api.py\u001b[0m in \u001b[0;36mjacfun\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    931\u001b[0m       \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpullback\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maux\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_vjp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf_partial\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mdyn_args\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhas_aux\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    932\u001b[0m     \u001b[0mtree_map\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpartial\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_check_output_dtype_jacrev\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mholomorphic\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 933\u001b[0;31m     \u001b[0mjac\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpullback\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_std_basis\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    934\u001b[0m     \u001b[0mjac\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjac\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margnums\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mjac\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    935\u001b[0m     \u001b[0mexample_args\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdyn_args\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margnums\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mdyn_args\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "    \u001b[0;31m[... skipping hidden 80 frame]\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/equinox/internal/_nontraceable.py\u001b[0m in \u001b[0;36m_nondifferentiable_backward_transpose\u001b[0;34m(cts_in, _, msg, symbolic)\u001b[0m\n\u001b[1;32m     74\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     75\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0msymbolic\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 76\u001b[0;31m             \u001b[0;32mraise\u001b[0m \u001b[0mRuntimeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmsg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     77\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     78\u001b[0m             \u001b[0;31m# Unfortunately there are legitimate cases where we get all-zero\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mRuntimeError\u001b[0m: Cannot reverse-mode autodifferentiate when using `diffeqsolve(..., max_steps=None, adjoint=RecursiveCheckpointAdjoint(checkpoints=None))`. This is because JAX needs to know how much memory to allocate for saving the forward pass. You should either put a bound on the maximum number of steps, or explicitly specify how many checkpoints to use."
-     ]
-    }
-   ],
-   "source": [
-    "start = time.time()\n",
-    "second_deriv = jax.jacrev(first_deriv_func)(params_global_potential,ts_forward,w_back,M_sat)\n",
-    "end = time.time()\n",
-    "print(end-start)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "ae0ddb93-2b84-464c-b422-04886de9a2f6",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "569888f6-a61d-4a27-9990-4d7c7fd124df",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "109d3837-5400-4236-a978-28038ce461a6",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "8019823c-7a1c-440a-be10-98104753f78f",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "23.090246200561523\n"
-     ]
-    }
-   ],
-   "source": [
-    "start = time.time()\n",
-    "first_deriv = jax.jacfwd(compare_streams,argnums=0)(params_global_potential,ts_forward,w_back,M_sat)\n",
-    "end = time.time()\n",
-    "print(end-start)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 50,
-   "id": "07970677-75d1-46b5-9a2e-13756696fc15",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'a_disk': Array(-0., dtype=float64),\n",
-       " 'b_disk': Array(-0., dtype=float64),\n",
-       " 'bar_Omega': Array(-0., dtype=float64),\n",
-       " 'bar_a': Array(-0., dtype=float64),\n",
-       " 'bar_b': Array(-0., dtype=float64),\n",
-       " 'bar_c': Array(-0., dtype=float64),\n",
-       " 'bar_m': Array(-0., dtype=float64),\n",
-       " 'm_NFW': Array(-0., dtype=float64),\n",
-       " 'm_disk': Array(-0., dtype=float64),\n",
-       " 'r_s_NFW': Array(-0., dtype=float64)}"
-      ]
-     },
-     "execution_count": 50,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "first_deriv"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 63,
-   "id": "d78dfee1-3abf-4b07-8f9b-705aaccfa1a7",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "1929.748643875122\n"
-     ]
-    }
-   ],
-   "source": [
-    "start = time.time()\n",
-    "second_deriv = jax.jacfwd(jax.jacfwd(compare_streams,argnums=0))(params_global_potential,ts_forward,w_back,M_sat)\n",
-    "end = time.time()\n",
-    "print(end-start)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 66,
-   "id": "6656c91c-ed5d-4d5e-a30c-868490021571",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#####np.save('second_deriv_dict',second_deriv)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 64,
-   "id": "74f4a153-52f4-42d3-9b49-84a8b3161380",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'a_disk': Array(-21073694.68893389, dtype=float64),\n",
-       " 'b_disk': Array(-2827903.44343206, dtype=float64),\n",
-       " 'bar_Omega': Array(-1.86418352e+08, dtype=float64),\n",
-       " 'bar_a': Array(-476275.21654258, dtype=float64),\n",
-       " 'bar_b': Array(-6428367.47136351, dtype=float64),\n",
-       " 'bar_c': Array(-1350812.18178627, dtype=float64),\n",
-       " 'bar_m': Array(0.00327751, dtype=float64),\n",
-       " 'm_NFW': Array(0.00032497, dtype=float64),\n",
-       " 'm_disk': Array(0.00226223, dtype=float64),\n",
-       " 'r_s_NFW': Array(-31568017.74693523, dtype=float64)}"
-      ]
-     },
-     "execution_count": 64,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "second_deriv['bar_b']"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "70818eef-a35d-4da3-9e63-992040c8fda1",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "c8ee7bd0-ea24-4d43-bd15-df1de4abee7c",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "abe050da-3360-4afb-8e4e-a7cef0265990",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "835b017e-eb9c-43f6-86d5-8fd1679acde2",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 67,
-   "id": "380ceaa1-9474-4e38-a5a9-5e6f060e9a33",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7fa751d8a070>"
-      ]
-     },
-     "execution_count": 67,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.scatter(lead_arm[:,0],lead_arm[:,1],s=0.01,rasterized=True)\n",
-    "plt.scatter(trail_arm[:,0],trail_arm[:,1],s=0.01,rasterized=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 74,
-   "id": "3a652d95-5e6d-45c1-9c70-0bb968ba569c",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7fa756cfd910>"
-      ]
-     },
-     "execution_count": 74,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.scatter(lead_arm[:,0],lead_arm[:,1],s=0.01,rasterized=True)\n",
-    "plt.scatter(trail_arm[:,0],trail_arm[:,1],s=0.01,rasterized=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "0d7b1672-e59d-4847-9811-f0512cdb608e",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "b7430132-0018-4fc0-8da2-d1c16307902d",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "76a0755c-88fd-45ea-aec5-faae985d8a4e",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "8260900d-2a4a-484d-9c9a-f5e0981551a9",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "72a23f74-4290-4313-bf18-d2274794ffd8",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "6adc6f54-636e-4e84-abbf-f2c321b712f4",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "cbed7e98-1821-4dc4-ab13-7e23a5139140",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "t0 = 0.\n",
-    "dt = 0.5\n",
-    "n_steps = 8_000#*1000\n",
-    "ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "out = pot.orbit_integrator_run(wf,t0,jnp.max(ts),ts)\n",
-    "#output = JaxStreams.orbit_integrator_run(w0=wf,t0=t0,t1=jnp.max(ts),ts=ts,potential_obj=pot)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "61297b9c-0847-4bc9-bda4-6dba76c62e63",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "Msat = 1.0e4\n",
-    "pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr = pot.gen_stream_ics(ts,wf,Msat)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "17864712-9d7e-4e7e-9bcc-8b8c6d649656",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "lead,trail = pot.gen_stream_vmapped(ts,wf,Msat)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "da79f5ba-85d0-424e-bf89-082ee6d0ef97",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "lead,trail = pot.gen_stream_final(ts,wf,Msat)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "3121c4ec-5b9e-4ca9-a9c8-ec4e942bce3a",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "['__annotations__',\n",
-       " '__call__',\n",
-       " '__class__',\n",
-       " '__delattr__',\n",
-       " '__dir__',\n",
-       " '__doc__',\n",
-       " '__eq__',\n",
-       " '__format__',\n",
-       " '__func__',\n",
-       " '__ge__',\n",
-       " '__get__',\n",
-       " '__getattribute__',\n",
-       " '__gt__',\n",
-       " '__hash__',\n",
-       " '__init__',\n",
-       " '__init_subclass__',\n",
-       " '__le__',\n",
-       " '__lt__',\n",
-       " '__module__',\n",
-       " '__name__',\n",
-       " '__ne__',\n",
-       " '__new__',\n",
-       " '__qualname__',\n",
-       " '__reduce__',\n",
-       " '__reduce_ex__',\n",
-       " '__repr__',\n",
-       " '__self__',\n",
-       " '__setattr__',\n",
-       " '__sizeof__',\n",
-       " '__str__',\n",
-       " '__subclasshook__',\n",
-       " '__wrapped__',\n",
-       " '_fun',\n",
-       " 'lower']"
-      ]
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "dir(pot.gen_stream_final)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "eecbb328-5376-4720-b55d-344fe6745be8",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(8000, 6)"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "lead.shape"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "47631647-47b8-4b80-8f08-aa8257d92f5b",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7fcc917722e0>"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.scatter(lead[:,0],lead[:,1])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 38,
-   "id": "a2d1e892-3e66-4c13-b7b1-49eb0045f612",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(Array([ 7.86771862e+00,  2.32269577e-01,  1.64124381e+01, -4.32708085e-02,\n",
-       "        -1.06060675e-01, -1.57716157e-02], dtype=float64),\n",
-       " Array([ 7.95668113e+00,  4.40895726e-01,  1.64494958e+01, -4.03870510e-02,\n",
-       "        -1.05849603e-01, -9.50204493e-03], dtype=float64))"
-      ]
-     },
-     "execution_count": 38,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "t0 = 0.\n",
-    "dt = 0.25\n",
-    "n_steps = 16_000#*1000\n",
-    "ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "ws_jax_backward = JaxStreams.leapfrog_run(wf, -ts, pot.gradient)\n",
-    "\n",
-    "ts = jnp.flip(-ts)\n",
-    "ws_forward_ag = JaxStreams.leapfrog_run(ws_jax_backward[-1,:],ts,pot.gradient)\n",
-    "\n",
-    "w_init = ws_jax_backward[-1,:]\n",
-    "wf, ws_forward_ag[-1,:]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 39,
-   "id": "9b3d7adb-034a-4dca-b544-f4f6de7e4911",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "39.72716283798218\n"
-     ]
-    }
-   ],
-   "source": [
-    "## Now generate a mock stream along the above orbit\n",
-    "M_sat = 2.5e4 #progenitor mass\n",
-    "start = time.time()\n",
-    "lead_arm, trail_arm = pot.gen_stream_final(ts, w_init, M_sat,)\n",
-    "end = time.time()\n",
-    "print(end-start)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 40,
-   "id": "6f2b2c3d-4dc3-4c02-9433-d4520579673c",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7f8ecc079ca0>"
-      ]
-     },
-     "execution_count": 40,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.scatter(lead_arm[:,0],lead_arm[:,1],s=0.01,rasterized=True)\n",
-    "plt.scatter(trail_arm[:,0],trail_arm[:,1],s=0.01,rasterized=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 54,
-   "id": "b1b90fb2-da0c-4d44-ab0e-453b11301d6a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from diffrax import diffeqsolve, ODETerm, Dopri5,SaveAt,PIDController,DiscreteTerminatingEvent\n",
-    "def f(t, y, args):\n",
-    "    return -y\n",
-    "\n",
-    "term = ODETerm(f)\n",
-    "solver = Dopri5()\n",
-    "y0 = jnp.array([2., 3.])\n",
-    "solution = diffeqsolve(term, solver, t0=0, t1=1, dt0=0.1, y0=y0)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 45,
-   "id": "05b7742f-fb43-4518-b07d-90db67006cf3",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "solution = diffeqsolve(term, solver, t0=0, t1=1, dt0=0.1, y0=y0)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 66,
-   "id": "3bbad6f2-f1f5-4419-bae9-be31c7406fbe",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "@jax.jit\n",
-    "def velocity_acceleration(t,xv,args):\n",
-    "    x, v = xv[:3], xv[3:]\n",
-    "    acceleration = -pot.gradient(x,t)\n",
-    "    return jnp.hstack([v,acceleration])\n",
-    "\n",
-    "    "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 87,
-   "id": "1b61e11f-7d11-465a-ae50-a9c37eb5ea34",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array([0.00000e+00, 2.50000e-01, 5.00000e-01, ..., 3.99950e+03,\n",
-       "       3.99975e+03, 4.00000e+03], dtype=float64)"
-      ]
-     },
-     "execution_count": 87,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "ts"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 96,
-   "id": "98356498-3b9e-447a-b48e-52eff88d4c32",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "term = ODETerm(velocity_acceleration)\n",
-    "solver = Dopri5()\n",
-    "saveat = SaveAt(t0=True, t1=True, ts=None, dense=False)\n",
-    "rtol: float = 1e-7\n",
-    "atol: float = 1e-7\n",
-    "stepsize_controller = PIDController(rtol=rtol, atol=atol)\n",
-    "max_steps: int = 16**3\n",
-    "t0 = 0.0\n",
-    "t1 = 4000.\n",
-    "dense = False\n",
-    "y0= w_init\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 97,
-   "id": "44b8d825-d0c2-4cb5-a37e-d34ffa5ad40d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "solution = diffeqsolve(\n",
-    "        terms=term,\n",
-    "        solver=solver,\n",
-    "        t0=t0,\n",
-    "        t1=t1,\n",
-    "        y0=y0,\n",
-    "        dt0=None,\n",
-    "        saveat=saveat,\n",
-    "        stepsize_controller=stepsize_controller,\n",
-    "        discrete_terminating_event=None,\n",
-    "        max_steps=(max_steps if dense else None),\n",
-    "    )"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 100,
-   "id": "fe6ed2af-f457-4393-9f17-b6f1d13cc96f",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(2, 6)"
-      ]
-     },
-     "execution_count": 100,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "solution.ys.shape"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 78,
-   "id": "89642834-47ee-496f-9283-ec7967c157e2",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array([ 7.86744457,  0.23100803, 16.41273869, -0.04367866, -0.10606968,\n",
-       "       -0.01664439], dtype=float64, weak_type=True)"
-      ]
-     },
-     "execution_count": 78,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "solution.ys[0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 71,
-   "id": "470915fb-0bcf-465d-92d9-f38078790804",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Help on Solution in module diffrax.solution object:\n",
-      "\n",
-      "class Solution(diffrax.path.AbstractPath)\n",
-      " |  Solution(*args, **kwargs)\n",
-      " |  \n",
-      " |  The solution to a differential equation.\n",
-      " |  \n",
-      " |  **Attributes:**\n",
-      " |  \n",
-      " |  - `t0`: The start of the interval that the differential equation was solved over.\n",
-      " |  - `t1`: The end of the interval that the differential equation was solved over.\n",
-      " |  - `ts`: Some ordered collection of times. Might be `None` if no values were saved.\n",
-      " |      (i.e. just `diffeqsolve(..., saveat=SaveAt(dense=True))` is used.)\n",
-      " |  - `ys`: The value of the solution at each of the times in `ts`. Might `None` if no\n",
-      " |      values were saved.\n",
-      " |  - `stats`: Statistics for the solve (number of steps etc.).\n",
-      " |  - `result`: Integer specifying the success or cause of failure of the solve. A\n",
-      " |      value of `0` corresponds to a successful solve. Any other value is a failure.\n",
-      " |      A human-readable message can be obtained by looking up messages via\n",
-      " |      `diffrax.RESULTS[<integer>]`.\n",
-      " |  - `solver_state`: If saved, the final internal state of the numerical solver.\n",
-      " |  - `controller_state`: If saved, the final internal state for the step size\n",
-      " |      controller.\n",
-      " |  - `made_jump`: If saved, the final internal state for the jump tracker.\n",
-      " |  \n",
-      " |  !!! note\n",
-      " |  \n",
-      " |      If `diffeqsolve(..., saveat=SaveAt(steps=True))` is set, then the `ts` and `ys`\n",
-      " |      in the solution object will be padded with `NaN`s, out to the value of\n",
-      " |      `max_steps` passed to [`diffrax.diffeqsolve`][].\n",
-      " |  \n",
-      " |      This is because JAX demands that shapes be known statically ahead-of-time. As\n",
-      " |      we do not know how many steps we will take until the solve is performed, we\n",
-      " |      must allocate enough space for the maximum possible number of steps.\n",
-      " |  \n",
-      " |  Method resolution order:\n",
-      " |      Solution\n",
-      " |      diffrax.path.AbstractPath\n",
-      " |      equinox._module.Module\n",
-      " |      builtins.object\n",
-      " |  \n",
-      " |  Methods defined here:\n",
-      " |  \n",
-      " |  __delattr__(self, name)\n",
-      " |  \n",
-      " |  __init__(self, t0: Union[int, float, diffrax.custom_types.Array], t1: Union[int, float, diffrax.custom_types.Array], ts: Union[diffrax.custom_types.Array, NoneType], ys: Union[diffrax.custom_types.PyTree, NoneType], interpolation: Union[diffrax.global_interpolation.DenseInterpolation, NoneType], stats: Dict[str, Any], result: diffrax.solution.RESULTS, solver_state: Union[diffrax.custom_types.PyTree, NoneType], controller_state: Union[diffrax.custom_types.PyTree, NoneType], made_jump: Union[bool, diffrax.custom_types.Array, NoneType]) -> None\n",
-      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
-      " |  \n",
-      " |  __setattr__(self, name, value)\n",
-      " |  \n",
-      " |  derivative(self, t: Union[int, float, diffrax.custom_types.Array], left: bool = True) -> diffrax.custom_types.PyTree\n",
-      " |      If dense output was saved, then calculate an **approximation** to the\n",
-      " |      derivative of the solution at any point in the region of integration `self.t0`\n",
-      " |      to `self.t1`.\n",
-      " |      \n",
-      " |      That is, letting $y$ denote the solution over the interval `[t0, t1]`, then\n",
-      " |      this calculates an approximation to $\\frac{\\mathrm{d}y}{\\mathrm{d}t}$.\n",
-      " |      \n",
-      " |      (This is *not* backpropagating through the differential equation -- that\n",
-      " |      typically corresponds to e.g. $\\frac{\\mathrm{d}y(t_1)}{\\mathrm{d}y(t_0)}$.)\n",
-      " |      \n",
-      " |      !!! example\n",
-      " |      \n",
-      " |          For an ODE satisfying\n",
-      " |      \n",
-      " |          $\\frac{\\mathrm{d}y}{\\mathrm{d}t} = f(t, y(t))$\n",
-      " |      \n",
-      " |          then this value is approximately equal to $f(t, y(t))$.\n",
-      " |      \n",
-      " |      !!! warning\n",
-      " |      \n",
-      " |          This value is generally not very accurate. Differential equation solvers\n",
-      " |          are usually designed to produce splines whose value is close to the true\n",
-      " |          solution; not to produce splines whose derivative is close to the\n",
-      " |          derivative of the true solution.\n",
-      " |      \n",
-      " |          If you need accurate derivatives for the solution of an ODE, it is usually\n",
-      " |          best to calculate `vector_field(t, sol.evaluate(t), args)`. That is, to\n",
-      " |          pay the extra computational cost of another vector field evaluation, in\n",
-      " |          order to get a more accurate value.\n",
-      " |      \n",
-      " |          Put precisely: this `derivative` method returns the *derivative of the\n",
-      " |          numerical solution*, and *not* an approximation to the derivative of the\n",
-      " |          true solution.\n",
-      " |      \n",
-      " |      **Arguments:**\n",
-      " |      \n",
-      " |      - `t`: The point to calculate the derivative of the solution at.\n",
-      " |      - `left`: When evaluating at a jump in the solution, whether to return the\n",
-      " |          left-limit or the right-limit at that point.\n",
-      " |  \n",
-      " |  evaluate(self, t0: Union[int, float, diffrax.custom_types.Array], t1: Union[int, float, diffrax.custom_types.Array, NoneType] = None, left: bool = True) -> diffrax.custom_types.PyTree\n",
-      " |      If dense output was saved, then evaluate the solution at any point in the\n",
-      " |      region of integration `self.t0` to `self.t1`.\n",
-      " |      \n",
-      " |      **Arguments:**\n",
-      " |      \n",
-      " |      - `t0`: The point to evaluate the solution at.\n",
-      " |      - `t1`: If passed, then the increment from `t0` to `t1` is returned.\n",
-      " |          (`=evaluate(t1) - evaluate(t0)`)\n",
-      " |      - `left`: When evaluating at a jump in the solution, whether to return the\n",
-      " |          left-limit or the right-limit at that point.\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Data and other attributes defined here:\n",
-      " |  \n",
-      " |  __abstractmethods__ = frozenset()\n",
-      " |  \n",
-      " |  __annotations__ = {'controller_state': typing.Union[diffrax.custom_typ...\n",
-      " |  \n",
-      " |  __dataclass_fields__ = {'controller_state': Field(name='controller_sta...\n",
-      " |  \n",
-      " |  __dataclass_params__ = _DataclassParams(init=True,repr=False,eq=False,...\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Methods inherited from equinox._module.Module:\n",
-      " |  \n",
-      " |  __eq__(self, other)\n",
-      " |      Return self==value.\n",
-      " |  \n",
-      " |  __hash__(self)\n",
-      " |      Return hash(self).\n",
-      " |  \n",
-      " |  __repr__(self)\n",
-      " |      Return repr(self).\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Data descriptors inherited from equinox._module.Module:\n",
-      " |  \n",
-      " |  __dict__\n",
-      " |      dictionary for instance variables (if defined)\n",
-      " |  \n",
-      " |  __weakref__\n",
-      " |      list of weak references to the object (if defined)\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Data and other attributes inherited from equinox._module.Module:\n",
-      " |  \n",
-      " |  __dataclass_transform__ = {'eq_default': True, 'field_specifiers': (<f...\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "help(solution)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "8125dd2a-f3c9-49f2-8d99-c56348013e1b",
-   "metadata": {},
-   "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.8.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/README.md b/README.md
index 27252bbc..faad22d3 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,27 @@
-# JaxStreams
-Implementation of Fardal particle spray in jax, using diffrax. Inspired by https://ui.adsabs.harvard.edu/abs/2023ascl.soft06008A/abstract
-Demo notebook in JaxStreamsDemo_diffrax.ipynb
+# galdynamix
+
+[![Actions Status][actions-badge]][actions-link]
+[![Documentation Status][rtd-badge]][rtd-link]
+
+[![PyPI version][pypi-version]][pypi-link]
+[![Conda-Forge][conda-badge]][conda-link]
+[![PyPI platforms][pypi-platforms]][pypi-link]
+
+[![GitHub Discussion][github-discussions-badge]][github-discussions-link]
+
+<!-- SPHINX-START -->
+
+<!-- prettier-ignore-start -->
+[actions-badge]:            https://github.com/nstarman/galdynamix/workflows/CI/badge.svg
+[actions-link]:             https://github.com/nstarman/galdynamix/actions
+[conda-badge]:              https://img.shields.io/conda/vn/conda-forge/galdynamix
+[conda-link]:               https://github.com/conda-forge/galdynamix-feedstock
+[github-discussions-badge]: https://img.shields.io/static/v1?label=Discussions&message=Ask&color=blue&logo=github
+[github-discussions-link]:  https://github.com/nstarman/galdynamix/discussions
+[pypi-link]:                https://pypi.org/project/galdynamix/
+[pypi-platforms]:           https://img.shields.io/pypi/pyversions/galdynamix
+[pypi-version]:             https://img.shields.io/pypi/v/galdynamix
+[rtd-badge]:                https://readthedocs.org/projects/galdynamix/badge/?version=latest
+[rtd-link]:                 https://galdynamix.readthedocs.io/en/latest/?badge=latest
+
+<!-- prettier-ignore-end -->
diff --git a/TaylorExpansion_PotentialFinalSnap.pdf b/TaylorExpansion_PotentialFinalSnap.pdf
deleted file mode 100644
index 703d9ba1..00000000
Binary files a/TaylorExpansion_PotentialFinalSnap.pdf and /dev/null differ
diff --git a/TaylorExpansion_PotentialFinalSnap_MASS.pdf b/TaylorExpansion_PotentialFinalSnap_MASS.pdf
deleted file mode 100644
index 561edf59..00000000
Binary files a/TaylorExpansion_PotentialFinalSnap_MASS.pdf and /dev/null differ
diff --git a/Untitled.ipynb b/Untitled.ipynb
deleted file mode 100644
index e7a78579..00000000
--- a/Untitled.ipynb
+++ /dev/null
@@ -1,704 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "191dd893-4908-4890-80d0-19b206db2361",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import jax \n",
-    "import sstrax \n",
-    "import matplotlib.pyplot as plt"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "f94064a8-daea-4922-aa9b-b4d97b3ec712",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Help on class Parameters in module sstrax.constants:\n",
-      "\n",
-      "class Parameters(collections.abc.Mapping)\n",
-      " |  Parameters(xc: float = 12.4, yc: float = 1.5, zc: float = 7.1, vxc: float = 107.0, vyc: float = -243.0, vzc: float = -105.0, age: float = 1000.0, msat: float = 10000.0, xi0: float = 0.001, alpha: float = 14.9, rh: float = 0.001, mbar: float = 2.0, sigv: float = 0.5, lrelease: float = 1.9, lmatch: float = 1.0, stripnear: float = 0.5) -> None\n",
-      " |  \n",
-      " |  Dataclass for the full set of parameters defining the stream simulation model\n",
-      " |  Args:\n",
-      " |    xc, yc, zc: current cluster location in [kpc]\n",
-      " |    vxc, vyc, vzc: current cluster velocity in [km/s]\n",
-      " |    age: (disruption) age of the stream in [Myr]\n",
-      " |    msat: initial mass of the cluster in [Msol]\n",
-      " |    xi0: dimensionless mass loss prefactor\n",
-      " |    alpha: tidal strippping mass loss power law\n",
-      " |    mbar: average stellar mass in [Msol]\n",
-      " |    sigv: internal velocity dispersion of cluster in [km/s]\n",
-      " |    lrelease, lmatch: dimensionless tidal position and velocity matching\n",
-      " |    stripnear: probability of stripping from the innermost Lagrange point\n",
-      " |  Returns:\n",
-      " |    Stream parameters data class\n",
-      " |  Examples\n",
-      " |  --------\n",
-      " |  >>> Parameters(xc=12.4, yc=1.5)\n",
-      " |  \n",
-      " |  Method resolution order:\n",
-      " |      Parameters\n",
-      " |      collections.abc.Mapping\n",
-      " |      collections.abc.Collection\n",
-      " |      collections.abc.Sized\n",
-      " |      collections.abc.Iterable\n",
-      " |      collections.abc.Container\n",
-      " |      builtins.object\n",
-      " |  \n",
-      " |  Methods defined here:\n",
-      " |  \n",
-      " |  __eq__(self, other)\n",
-      " |  \n",
-      " |  __getitem__ lambda self, x\n",
-      " |      # Define methods for compatibility with `collections.abc.Mapping`.\n",
-      " |  \n",
-      " |  __getstate__ = _getstate(self)\n",
-      " |  \n",
-      " |  __init__(self, xc: float = 12.4, yc: float = 1.5, zc: float = 7.1, vxc: float = 107.0, vyc: float = -243.0, vzc: float = -105.0, age: float = 1000.0, msat: float = 10000.0, xi0: float = 0.001, alpha: float = 14.9, rh: float = 0.001, mbar: float = 2.0, sigv: float = 0.5, lrelease: float = 1.9, lmatch: float = 1.0, stripnear: float = 0.5) -> None\n",
-      " |      # Patch object's __init__ such that the class is registered on creation if\n",
-      " |      # it is not registered on deserialization.\n",
-      " |  \n",
-      " |  __iter__ lambda self\n",
-      " |  \n",
-      " |  __len__ lambda self\n",
-      " |  \n",
-      " |  __repr__(self)\n",
-      " |  \n",
-      " |  __setstate__ = _setstate(self, state)\n",
-      " |      # Patch __setstate__ to register the object on deserialization.\n",
-      " |  \n",
-      " |  from_tuple = _from_tuple(args)\n",
-      " |  \n",
-      " |  replace = _replace(self, **kwargs)\n",
-      " |  \n",
-      " |  to_tuple = _to_tuple(self)\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Class methods defined here:\n",
-      " |  \n",
-      " |  from_values(values, names=None) from abc.ABCMeta\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Readonly properties defined here:\n",
-      " |  \n",
-      " |  cluster_final\n",
-      " |  \n",
-      " |  cluster_pos_final\n",
-      " |  \n",
-      " |  cluster_vel_final\n",
-      " |  \n",
-      " |  mass_args\n",
-      " |  \n",
-      " |  sigv_kpcMyr\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Data descriptors defined here:\n",
-      " |  \n",
-      " |  __dict__\n",
-      " |      dictionary for instance variables (if defined)\n",
-      " |  \n",
-      " |  __weakref__\n",
-      " |      list of weak references to the object (if defined)\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Data and other attributes defined here:\n",
-      " |  \n",
-      " |  __abstractmethods__ = frozenset()\n",
-      " |  \n",
-      " |  __annotations__ = {'age': <class 'float'>, 'alpha': <class 'float'>, '...\n",
-      " |  \n",
-      " |  __dataclass_fields__ = {'age': Field(name='age',type=<class 'float'>,d...\n",
-      " |  \n",
-      " |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...\n",
-      " |  \n",
-      " |  __hash__ = None\n",
-      " |  \n",
-      " |  age = 1000.0\n",
-      " |  \n",
-      " |  alpha = 14.9\n",
-      " |  \n",
-      " |  lmatch = 1.0\n",
-      " |  \n",
-      " |  lrelease = 1.9\n",
-      " |  \n",
-      " |  mbar = 2.0\n",
-      " |  \n",
-      " |  msat = 10000.0\n",
-      " |  \n",
-      " |  rh = 0.001\n",
-      " |  \n",
-      " |  sigv = 0.5\n",
-      " |  \n",
-      " |  stripnear = 0.5\n",
-      " |  \n",
-      " |  vxc = 107.0\n",
-      " |  \n",
-      " |  vyc = -243.0\n",
-      " |  \n",
-      " |  vzc = -105.0\n",
-      " |  \n",
-      " |  xc = 12.4\n",
-      " |  \n",
-      " |  xi0 = 0.001\n",
-      " |  \n",
-      " |  yc = 1.5\n",
-      " |  \n",
-      " |  zc = 7.1\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Methods inherited from collections.abc.Mapping:\n",
-      " |  \n",
-      " |  __contains__(self, key)\n",
-      " |  \n",
-      " |  get(self, key, default=None)\n",
-      " |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.\n",
-      " |  \n",
-      " |  items(self)\n",
-      " |      D.items() -> a set-like object providing a view on D's items\n",
-      " |  \n",
-      " |  keys(self)\n",
-      " |      D.keys() -> a set-like object providing a view on D's keys\n",
-      " |  \n",
-      " |  values(self)\n",
-      " |      D.values() -> an object providing a view on D's values\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Data and other attributes inherited from collections.abc.Mapping:\n",
-      " |  \n",
-      " |  __reversed__ = None\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Class methods inherited from collections.abc.Collection:\n",
-      " |  \n",
-      " |  __subclasshook__(C) from abc.ABCMeta\n",
-      " |      Abstract classes can override this to customize issubclass().\n",
-      " |      \n",
-      " |      This is invoked early on by abc.ABCMeta.__subclasscheck__().\n",
-      " |      It should return True, False or NotImplemented.  If it returns\n",
-      " |      NotImplemented, the normal algorithm is used.  Otherwise, it\n",
-      " |      overrides the normal algorithm (and the outcome is cached).\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "import time\n",
-    "help(sstrax.Parameters)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "dd0e1b6a-0f02-4730-9f32-05603a236dca",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/latex": [
-       "$0.22499668 \\; \\mathrm{\\frac{kpc}{Myr}}$"
-      ],
-      "text/plain": [
-       "<Quantity 0.22499668 kpc / Myr>"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from astropy import units as u\n",
-    "(220*u.km/u.s).to(u.kpc/u.Myr)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 37,
-   "id": "52ba5bc6-d8e7-4a25-93af-aa3104c92897",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "params = sstrax.Parameters(xc=8,yc=4,zc=8,vxc=30,vyc=251.,vzc=40.,age=8000.0,msat=1e4)\n",
-    "stream = sstrax.simulate_stream(jax.random.PRNGKey(0), params)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 38,
-   "id": "bd185f00-de8e-43c5-99a6-cea4b28347c5",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7ffa6d801280>"
-      ]
-     },
-     "execution_count": 38,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.scatter(stream[:,3],stream[:,4],s=0.5)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 34,
-   "id": "84d5547f-e0f4-4795-8419-51c55ea12abe",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(1059, 6)"
-      ]
-     },
-     "execution_count": 34,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "stream.shape"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 41,
-   "id": "6b94cf2b-a955-435a-9514-25ed557cb568",
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "NameError",
-     "evalue": "name 'jnp' is not defined",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_3672/4218221744.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstream\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-      "\u001b[0;31mNameError\u001b[0m: name 'jnp' is not defined"
-     ]
-    }
-   ],
-   "source": [
-    "jnp.sum(stream)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "ad3ddd0f-1ee1-4d53-b46b-5ba3aeee5188",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 65,
-   "id": "8e31dd54-7984-4b9c-bfdf-c43761d66119",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "['__abstractmethods__',\n",
-       " '__annotations__',\n",
-       " '__class__',\n",
-       " '__contains__',\n",
-       " '__dataclass_fields__',\n",
-       " '__dataclass_params__',\n",
-       " '__delattr__',\n",
-       " '__dict__',\n",
-       " '__dir__',\n",
-       " '__doc__',\n",
-       " '__eq__',\n",
-       " '__format__',\n",
-       " '__ge__',\n",
-       " '__getattribute__',\n",
-       " '__getitem__',\n",
-       " '__getstate__',\n",
-       " '__gt__',\n",
-       " '__hash__',\n",
-       " '__init__',\n",
-       " '__init_subclass__',\n",
-       " '__iter__',\n",
-       " '__le__',\n",
-       " '__len__',\n",
-       " '__lt__',\n",
-       " '__module__',\n",
-       " '__ne__',\n",
-       " '__new__',\n",
-       " '__reduce__',\n",
-       " '__reduce_ex__',\n",
-       " '__repr__',\n",
-       " '__reversed__',\n",
-       " '__setattr__',\n",
-       " '__setstate__',\n",
-       " '__sizeof__',\n",
-       " '__slots__',\n",
-       " '__str__',\n",
-       " '__subclasshook__',\n",
-       " '__weakref__',\n",
-       " '_abc_impl',\n",
-       " 'age',\n",
-       " 'alpha',\n",
-       " 'cluster_final',\n",
-       " 'cluster_pos_final',\n",
-       " 'cluster_vel_final',\n",
-       " 'from_tuple',\n",
-       " 'from_values',\n",
-       " 'get',\n",
-       " 'items',\n",
-       " 'keys',\n",
-       " 'lmatch',\n",
-       " 'lrelease',\n",
-       " 'mass_args',\n",
-       " 'mbar',\n",
-       " 'msat',\n",
-       " 'replace',\n",
-       " 'rh',\n",
-       " 'sigv',\n",
-       " 'sigv_kpcMyr',\n",
-       " 'stripnear',\n",
-       " 'to_tuple',\n",
-       " 'values',\n",
-       " 'vxc',\n",
-       " 'vyc',\n",
-       " 'vzc',\n",
-       " 'xc',\n",
-       " 'xi0',\n",
-       " 'yc',\n",
-       " 'zc']"
-      ]
-     },
-     "execution_count": 65,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "dir(sstrax.Parameters())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 84,
-   "id": "27bbb7fb-d0e9-417f-9cb8-b1ad459415b7",
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "TypeError",
-     "evalue": "iteration over a 0-d array",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_3672/867813607.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     64\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     65\u001b[0m \u001b[0;31m# Call the function with step_array as an argument\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 66\u001b[0;31m \u001b[0mpositions\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvy\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mleapfrog_integration\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvx0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvy0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvz0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mM\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msteps\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstep_array\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     67\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     68\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "    \u001b[0;31m[... skipping hidden 12 frame]\u001b[0m\n",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_3672/867813607.py\u001b[0m in \u001b[0;36mleapfrog_integration\u001b[0;34m(x0, y0, z0, vx0, vy0, vz0, M, rs, dt, steps, step_array)\u001b[0m\n\u001b[1;32m     45\u001b[0m     \u001b[0minitial_state\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mx0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvx0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvy0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvz0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mx0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     46\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 47\u001b[0;31m     \u001b[0mfinal_state\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscan\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbody_fn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minitial_state\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstep_array\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     48\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     49\u001b[0m     \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvy\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvz\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpositions\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfinal_state\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "    \u001b[0;31m[... skipping hidden 9 frame]\u001b[0m\n",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_3672/867813607.py\u001b[0m in \u001b[0;36mbody_fn\u001b[0;34m(i, state)\u001b[0m\n\u001b[1;32m     24\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mleapfrog_integration\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvx0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvy0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvz0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mM\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msteps\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstep_array\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     25\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mbody_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 26\u001b[0;31m         \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvy\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvz\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpositions\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mstate\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     27\u001b[0m         \u001b[0mforce_x\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mforce_y\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mforce_z\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcompute_force\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mM\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     28\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "    \u001b[0;31m[... skipping hidden 1 frame]\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/lax/lax.py\u001b[0m in \u001b[0;36m_iter\u001b[0;34m(tracer)\u001b[0m\n\u001b[1;32m   1457\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_iter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtracer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1458\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0mtracer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1459\u001b[0;31m     \u001b[0;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"iteration over a 0-d array\"\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# same as numpy error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1460\u001b[0m   \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1461\u001b[0m     \u001b[0mn\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtracer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mTypeError\u001b[0m: iteration over a 0-d array"
-     ]
-    }
-   ],
-   "source": [
-    "import jax\n",
-    "import jax.numpy as jnp\n",
-    "from jax import jit, grad, lax\n",
-    "\n",
-    "\n",
-    "# Define the potential function for a spherical NFW halo\n",
-    "def nfw_potential(x, y, z, M, rs):\n",
-    "    r = jnp.sqrt(x**2 + y**2 + z**2)\n",
-    "    x = r / rs\n",
-    "    return -M * jnp.log(1 + x) / x\n",
-    "\n",
-    "# Define the force calculation using automatic differentiation\n",
-    "@jit\n",
-    "def compute_force(x, y, z, M, rs):\n",
-    "    potential_fn = lambda x, y, z: nfw_potential(x, y, z, M, rs)\n",
-    "    force_fn = jit(grad(potential_fn))\n",
-    "    force_x = -force_fn(x, y, z)\n",
-    "    force_y = -force_fn(y, x, z)  # Swap y and x for jax.autograd compatibility\n",
-    "    force_z = -force_fn(z, x, y)  # Swap z and x for jax.autograd compatibility\n",
-    "    return force_x, force_y, force_z\n",
-    "\n",
-    "# Leapfrog integrator\n",
-    "@jit\n",
-    "def leapfrog_integration(x0, y0, z0, vx0, vy0, vz0, M, rs, dt, steps, step_array):\n",
-    "    def body_fn(i, state):\n",
-    "        x, y, z, vx, vy, vz, positions = state\n",
-    "        force_x, force_y, force_z = compute_force(x, y, z, M, rs)\n",
-    "\n",
-    "        vx += force_x * dt / 2.0\n",
-    "        vy += force_y * dt / 2.0\n",
-    "        vz += force_z * dt / 2.0\n",
-    "\n",
-    "        x += vx * dt\n",
-    "        y += vy * dt\n",
-    "        z += vz * dt\n",
-    "\n",
-    "        vx += force_x * dt / 2.0\n",
-    "        vy += force_y * dt / 2.0\n",
-    "        vz += force_z * dt / 2.0\n",
-    "\n",
-    "        positions = jnp.vstack((positions, jnp.array((x, y, z))))\n",
-    "\n",
-    "        return (x, y, z, vx, vy, vz, positions)\n",
-    "\n",
-    "    initial_state = (x0, y0, z0, vx0, vy0, vz0, jnp.array([[x0, y0, z0]]))\n",
-    "\n",
-    "    final_state = lax.scan(body_fn, initial_state, step_array)[1]\n",
-    "\n",
-    "    x, y, z, vx, vy, vz, positions = final_state\n",
-    "\n",
-    "    return positions, x, y, z, vx, vy, vz\n",
-    "\n",
-    "# Initial conditions\n",
-    "x0, y0, z0 = 1.0, 0.0, 0.0\n",
-    "vx0, vy0, vz0 = 0.0, 1.0, 0.0\n",
-    "M = 1e12  # Mass of the NFW halo\n",
-    "rs = 10.0  # Scale radius of the NFW halo\n",
-    "dt = 0.01  # Time step\n",
-    "steps = 1000  # Number of integration steps\n",
-    "\n",
-    "\n",
-    "# Generate the step array outside of the JIT-compiled function\n",
-    "step_array = jnp.arange(steps)\n",
-    "\n",
-    "# Call the function with step_array as an argument\n",
-    "positions, x, y, z, vx, vy, vz = leapfrog_integration(x0, y0, z0, vx0, vy0, vz0, M, rs, dt, steps, step_array)\n",
-    "\n",
-    "    \n",
-    "\n",
-    "\n",
-    "# Perform the integration\n",
-    "#aa = leapfrog_integration(x0, y0, z0, vx0, vy0, vz0, M, rs, dt, steps)\n",
-    "\n",
-    "# Access the final position and velocity\n",
-    "#final_position = positions[-1]\n",
-    "#final_velocity = velocities[-1]\n",
-    "\n",
-    "#print(\"Final Position:\", final_position)\n",
-    "#print(\"Final Velocity:\", final_velocity)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 85,
-   "id": "9131d393-b257-40d1-b403-3b8e56bab247",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array([  0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,\n",
-       "        13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,\n",
-       "        26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,\n",
-       "        39,  40,  41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51,\n",
-       "        52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,  64,\n",
-       "        65,  66,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,\n",
-       "        78,  79,  80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  90,\n",
-       "        91,  92,  93,  94,  95,  96,  97,  98,  99, 100, 101, 102, 103,\n",
-       "       104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,\n",
-       "       117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,\n",
-       "       130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,\n",
-       "       143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155,\n",
-       "       156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168,\n",
-       "       169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181,\n",
-       "       182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194,\n",
-       "       195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,\n",
-       "       208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220,\n",
-       "       221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233,\n",
-       "       234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246,\n",
-       "       247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259,\n",
-       "       260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272,\n",
-       "       273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285,\n",
-       "       286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298,\n",
-       "       299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311,\n",
-       "       312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,\n",
-       "       325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337,\n",
-       "       338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350,\n",
-       "       351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363,\n",
-       "       364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376,\n",
-       "       377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389,\n",
-       "       390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402,\n",
-       "       403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415,\n",
-       "       416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428,\n",
-       "       429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441,\n",
-       "       442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454,\n",
-       "       455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467,\n",
-       "       468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480,\n",
-       "       481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493,\n",
-       "       494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506,\n",
-       "       507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519,\n",
-       "       520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532,\n",
-       "       533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545,\n",
-       "       546, 547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558,\n",
-       "       559, 560, 561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 571,\n",
-       "       572, 573, 574, 575, 576, 577, 578, 579, 580, 581, 582, 583, 584,\n",
-       "       585, 586, 587, 588, 589, 590, 591, 592, 593, 594, 595, 596, 597,\n",
-       "       598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608, 609, 610,\n",
-       "       611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623,\n",
-       "       624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636,\n",
-       "       637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649,\n",
-       "       650, 651, 652, 653, 654, 655, 656, 657, 658, 659, 660, 661, 662,\n",
-       "       663, 664, 665, 666, 667, 668, 669, 670, 671, 672, 673, 674, 675,\n",
-       "       676, 677, 678, 679, 680, 681, 682, 683, 684, 685, 686, 687, 688,\n",
-       "       689, 690, 691, 692, 693, 694, 695, 696, 697, 698, 699, 700, 701,\n",
-       "       702, 703, 704, 705, 706, 707, 708, 709, 710, 711, 712, 713, 714,\n",
-       "       715, 716, 717, 718, 719, 720, 721, 722, 723, 724, 725, 726, 727,\n",
-       "       728, 729, 730, 731, 732, 733, 734, 735, 736, 737, 738, 739, 740,\n",
-       "       741, 742, 743, 744, 745, 746, 747, 748, 749, 750, 751, 752, 753,\n",
-       "       754, 755, 756, 757, 758, 759, 760, 761, 762, 763, 764, 765, 766,\n",
-       "       767, 768, 769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779,\n",
-       "       780, 781, 782, 783, 784, 785, 786, 787, 788, 789, 790, 791, 792,\n",
-       "       793, 794, 795, 796, 797, 798, 799, 800, 801, 802, 803, 804, 805,\n",
-       "       806, 807, 808, 809, 810, 811, 812, 813, 814, 815, 816, 817, 818,\n",
-       "       819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831,\n",
-       "       832, 833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 844,\n",
-       "       845, 846, 847, 848, 849, 850, 851, 852, 853, 854, 855, 856, 857,\n",
-       "       858, 859, 860, 861, 862, 863, 864, 865, 866, 867, 868, 869, 870,\n",
-       "       871, 872, 873, 874, 875, 876, 877, 878, 879, 880, 881, 882, 883,\n",
-       "       884, 885, 886, 887, 888, 889, 890, 891, 892, 893, 894, 895, 896,\n",
-       "       897, 898, 899, 900, 901, 902, 903, 904, 905, 906, 907, 908, 909,\n",
-       "       910, 911, 912, 913, 914, 915, 916, 917, 918, 919, 920, 921, 922,\n",
-       "       923, 924, 925, 926, 927, 928, 929, 930, 931, 932, 933, 934, 935,\n",
-       "       936, 937, 938, 939, 940, 941, 942, 943, 944, 945, 946, 947, 948,\n",
-       "       949, 950, 951, 952, 953, 954, 955, 956, 957, 958, 959, 960, 961,\n",
-       "       962, 963, 964, 965, 966, 967, 968, 969, 970, 971, 972, 973, 974,\n",
-       "       975, 976, 977, 978, 979, 980, 981, 982, 983, 984, 985, 986, 987,\n",
-       "       988, 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999],      dtype=int32)"
-      ]
-     },
-     "execution_count": 85,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "step_array"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "a019bb7f-e11b-4b65-a89e-ca61b3dd072d",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "e7c17d56-9f83-44f4-9031-3ef3c9072539",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "5b7620fb-2bdc-48fb-b9d6-1924974ab52c",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "d0312378-0cca-4d30-be8e-582c45de7e33",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "32a818e0-06ee-4a46-b611-00d992429809",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7ff24459ff70>"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.scatter(stream[:,0],stream[:,1],s=.1)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "857594f4-7521-4fb6-a546-b4ba6e5cdc10",
-   "metadata": {},
-   "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.8.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/Untitled1.ipynb b/Untitled1.ipynb
deleted file mode 100644
index f3ae5b9b..00000000
--- a/Untitled1.ipynb
+++ /dev/null
@@ -1,415 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "6e2f5ed4-ccaf-468d-b0b5-4e8844d1a984",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u001b[91mA new version of galpy (1.9.0) is available, please upgrade using pip/conda/... to get the latest features and bug fixes!\u001b[0m\n"
-     ]
-    }
-   ],
-   "source": [
-    "from functools import partial\n",
-    "\n",
-    "from astropy.constants import G\n",
-    "import astropy.coordinates as coord\n",
-    "import astropy.units as u\n",
-    "import matplotlib as mpl\n",
-    "import matplotlib.pyplot as plt\n",
-    "%matplotlib inline\n",
-    "import numpy as np\n",
-    "\n",
-    "# gala\n",
-    "import gala.coordinates as gc\n",
-    "import gala.dynamics as gd\n",
-    "import gala.potential as gp\n",
-    "from gala.units import dimensionless, galactic, UnitSystem\n",
-    "\n",
-    "import jax\n",
-    "import jax.numpy as jnp\n",
-    "\n",
-    "from jax.config import config\n",
-    "config.update(\"jax_enable_x64\", True)\n",
-    "\n",
-    "import scienceplots\n",
-    "import cmasher as cmr\n",
-    "plt.style.use('science')\n",
-    "import jax.random as random \n",
-    "from matplotlib.patches import Ellipse\n",
-    "import jax.scipy.stats as jaxstats\n",
-    "usys = UnitSystem(u.kpc, u.Myr, u.Msun, u.radian)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "fe543250-982d-431f-8408-228af384cfcb",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "4.498502151469553e-12"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "usys.get_constant('G')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "1a544fc6-bb0e-4442-904c-999bc88eddf0",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import agama\n",
-    "agama.setUnits(mass=1.0,length=1,time=1.)\n",
-    "# stellar potential\n",
-    "potstars = agama.Potential(type='Sersic', sersicIndex=4, axisRatioZ=0.6, scaleRadius=1, mass=1e10)\n",
-    "# construct initial conditions for the orbit library:\n",
-    "# use the anisotropic Jeans eqs to set the (approximate) shape of the velocity ellipsoid and the mean v_phi;\n",
-    "beta  = 0.0   # velocity anisotropy in R/z plane: >0 - sigma_R>sigma_z, <0 - reverse.\n",
-    "kappa = 0.8   # sets the amount of rotation v_phi vs. dispersion sigma_phi; 1 is rather fast rotation, 0 - no rot.\n",
-    "initcond, mass = potstars.sample(10000, potential=potstars, beta=beta, kappa=kappa)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "d5c2954f-5b5e-4590-b0cb-6cf440b15df5",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# stellar potential\n",
-    "potstars = agama.Potential(type='Sersic', sersicIndex=4, axisRatioZ=0.2, scaleRadius=1, mass=1e10)\n",
-    "# construct initial conditions for the orbit library:\n",
-    "# use the anisotropic Jeans eqs to set the (approximate) shape of the velocity ellipsoid and the mean v_phi;\n",
-    "beta  = 0.0   # velocity anisotropy in R/z plane: >0 - sigma_R>sigma_z, <0 - reverse.\n",
-    "kappa = 0.8   # sets the amount of rotation v_phi vs. dispersion sigma_phi; 1 is rather fast rotation, 0 - no rot.\n",
-    "initcond, mass = potstars.sample(10000, potential=potstars, beta=beta, kappa=kappa)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "a1c3d806-20d6-43ae-933e-e7e9e40b2ca1",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(-10.0, 10.0)"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOQAAAClCAYAAABMU1FEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAArW0lEQVR4nO2deVQUV9r/v9W0BOPCKoK4IIjS4gpiXJkZg0YBfZ0cc96ZJC7JJJqIgiTO5MyMeXXM+c3vmF8MLjEmmSyOCWYyiRkXQKK+hrhEI7K4ArKDCCKbAaNgd9/fH9W3qC6qm6a76QXu5xwOvVRX3br1PPdZ7q2nOEIIGAyGY6CwdwMYDEYHTCEZDAeCKSSD4UB0WyE5jlvGcdwJmc+iOY5bbb2mMRh9j24rJCHkG/F7juOW6T4/qXsfbZ2mMRh9D6UV9hEJ4Cvd61IA4QBOijeYMWMGcXNzAwAEBgYiMDBQdkfl5eUGv+vONvbajrWtZ7dz1raVl5ejvLwcAPDDDz9cIITMNLgjQki3/wCcEL3+EEC47nU0gG3S7X/1q18RU9i8ebNVtrHXdqxtPbtdb2gbgExiRLeskdRpBuBlhf3g17/+tVW26Ynt7HFMdg7mYY+2Wa39xrTV0B/0LeQyAMt0r1cDiJZuv3LlSpNGD0fm+++/t3cTLMLZ209I7zgHAPuINS2kLmkzTZTM+QZAkO5zD6JL7ogxxU93dKw5gtsDZ28/0DvOAUC5sS+7ndTRKZyn5LO3dS87KaMtaFdrcPJqDaIn+sNV6WKPJjAYVqFXLAw4ebUGz+86g5NXa+zdlD5Bu1qD9NxbaFdr7N2UXodNFLK8vBxbtmxBZmZmj+w/eqI/vkiYi+iJ/j2yf4Y+bAA0D538BxrbhiM2uNtjy5YtZMuWLT1+HIZtYCGC+XAc9zdCyBZD31tjYQCjj+GqdEHM1OH2bkavpFfEkAxGb4EpJIPhQDCFZDAcCKaQDIYDwRSSwXAgesU8JIPhDJgyD2mTaY/AwECweUhGX0e3Frfc2DbMZWUwHAimkAyGA8EUksFwIJhCMhgOBFNIBsOBYNMeDIaNYNMeDIYDwaY9GA4Pqz6gD1PIXoAzCzWrPqAPU8hegDMLNSu/og+rGNALcGahZtUH9GEWshdAhdqW9W2c2U12ZNi0B8MsnNlNthds2oPRYzizm2wvTJn2YDEkwyxY7NczsBiSwXAgrKKQHMc1cRx3guO4P1ljfyxhYDqsr3oX1rKQzxBC5oseumMRLGFgOqyvehfWUkgPjuOCrLQvljDoBqyvehfWSup4AWjkOO5DQsga6Zd02gPgM01dPeePJQxMh/WV45OZmSme8gs0urGxp7l29w/ANuiepiz+M/X565bS9khN0nKqSNsjda88Xm+ir/YdgC3Emk9QlsJx3GqO48It3Y81sHU8xeI382F9J481Ysh/A4DkEed2wdbxFIvfzIf1nTwWKyQhpJkQkkMI+YYQ8oY1GmUu0jWdPT0lYI81pL0FQ33X16dxevXCAOYWOR99/Zr1aoVkbpHz0devmcPd7WFNl8XWLqW47X3d9TKX3hwGmHK3h00Ukt7t0dX8I+DcLou47c58HoyewSnv9nBml0XadlucR7tag5NXaxA90b9XWpW+hsPFkLZyWXrCpRS33VbnYaolZi60c+BwCmkrLBFkRxJuUz0K5kI7B31WIS0RZEcSblMtsTOHAn2JPquQlgiyMwq3M2Qv7eF5OJK3AzjQtIejdQxFTpB7Urht2Q+O1uf28DxseUxTpj2sereHoT9T7vZIy6kinqsOkLScKrNW0feWuwfk+sHcc5P+jr5vedBG0nKqyOGsCuK56gA5nFXhEH1nj2toyjGt2S709N0e5iA3MlvqBsqNdI5mAUxBrh/MHcWlv6Pvk1Pz8fyuMwD4qRm1Rotnd55GRl610f31xrXB4mMaOj+bWm5j2mqtP6mFtNQayiE3ivXEcSxpj6331ZWFpJ8fzqog7isPkIMXymSPQ39HLao9+lOuPda2pIbkxZYW0i4KaSvXxJ5ubHcGA3u7210pHD0XR3Fte2qg7e51MOe6OaRC9sSJ2gtDbRV/3tX5WEPArNFnppyLI2Dv9ljiMXSlkA457UF99oy8arvFgO1qDY5cqsSRS5VGj5+RVy0bf4ljk65iEEviZxr3ZORVWxznGIqnHG3KxJ43DQC8fD638zRyShuwL362Vae/HGbaQwwVUABdCpm0s6yReGhXa/D3b69g+e6zWL77bKfjdz4Gh5zSBoPH7Erh2tUaZJcY/r0xqLJbWziskcgwdC1MuUamDIi2StpJ+yJ6oj9eiwvDrmMFULooZAcGubZlZmYCnMJ4dUZj5tNaf91xWbvj6hHS2d2zhvuXllNFBq9IIYNWpJBNX2Z3Or74GG2P1GTr13nEY2VKt44pPretX+eRgctTyIrdZ2TP1Vg/tD1Sk81f5ZDBK1KEpIw0adNd2h6pyeGsCnI4q8Iit9DQtTDlGqXlVBH3lQeIu5F+lV6HnnK35fZhShjisTKFbP06T28bxZCxB4gzxZDdVShDmURLLwAV8sNZFZ2+kwqrXBsMCbRc/NHyoI2s2H2GuK+QFz5jWVBxWzd/lUM8Vx0gK3af0etDU/vE2tlUQ4J8OKuCHLxQZlThuxoU2h6pycELZWTzVznCAGRI+eUUw5JzMPV3W7/O69QmKFzeIs6kkNYK2M2d8JWbGhBf/IMXykwe3Qev4K1ey4M2ve/EGUt6HKlVE7ftcFYFGbwihTy/64dOlpjub+vXeaTlQRvZ+nUecdcp5+GsCtLyoI1s/iqHuK/sPLhI4RU/xeD0h7Rd5lglcXtNnWIwNKXlvjKFuK/s2kIaOpYc0v0YMxBdGQO5NsEZs6zWgI6MVDDlhINaHvr94awKwcpIhX7wihQycDm/v64uArUAz+/6gQxczo/OFKnCU2skHcFl3eJVB/TOR87aSK3c1q/zBPf72R2ZeoODGGpp3Vfyx2hoeSAoufgcab9u+jKbPL/rB1mrbooQG3KrxdfE0P5MtbKUmqb7ZP7W70hN032j28n1uzErbU645JAKaW6M0p0RmQrx4BUpsq4nIYQcvFCmF3tRqyZVDmohN32ZTQ5eKDOoOITou5dil0qK2FLSGFR8XGrtGloekLScKkFBqIXe9GU2eXZHpqBAcsvtqND+OeUSGbicH1D+nHJJ6HuxdaZtWLH7DPFYmULmb/1OGIDE7ru4X6Vxr1TZWh60dfs6y1lp2j46OMhZPEOK3vZILZzLit1nupQZcXu7UjBzwqWuFNIuFQNOXq3BivfOAuBwIHGuyaXwM/KqseK9c9i/bjaWTBsJgM9mbTt0DclpN/BFQse+XJUueGPpBGi0WuxIzxf20a7WICOvGmqNFrlljQAApYsC0RP9sX/dbADAwikBnTJnbq5KRI7xwao95/BFghLRE/1x8moNolS+2Bc/G2qNFq0P25FVXA+tluDg+Uqk591CSmIUAOCtby4jfuE4XCiqR/REf73M68IpAQCA7UevC1k5jZZgz3eF0Gi12HWsAAmLQrEjvQCfvjoTSbHj8f+OXAcBwOm2pRnW1ofteOfIdYwf7o4bt+5h17ECxD81TjiPots/Y893hSAEWBwRgKPZ1UiMCcV7GQVIjFFhrP8gVDW24nxRPZZOG4FJozzx4t7zIARQa7RoV2ug0Wqx96XpuFnTgoQYFVKzq3ClogmTRnnipQ/OI2FRKCaN8sS2Q9ew61gBAODz9XOgdFEgSuWL45dvI7esEVNHe2HB5GE4nV8nVDyYN8EPr8eFAQCe23kar8WFIWyEO7an3sDkQE8oXRR4N/U6EmNUQnvEU0tJseORnHYD++JnQ+migFqjxcWSeswM8cG258ORnntLuHbP7zqjJzNi+XJVuiBK5Yuk2PGIUvnKyqP0MQ7i99JKDvQ9FC5G52rsopC88M8RXosxVJKiXa1BTmkDCCFQa7R6HSt3gQC+gxJiVCiru485ob6C8r5z9DoAgOOAjYvDBIWgiinuwCiVL5JT8/Fu6nV8uHoGFkeMwIwQH2EuigrMC+//iCXThuNI1i0AQGruLWxcHIYolS/iP76Iby9Wori2BUezqwRFVGu0SM2ugtJFgfiF41Bc24Kd6QUgunPmALSrtYh/ahza1Vp+BHVRIClOhXa1Bg/a1cgubcDO9AK8FqfCnFBf/C75NM4X1Qu/fy1OBY2WCP14t6UNWgKEDB2II9n83OnN2z8jMUaFSaM8sWrPj8Lxf/vECMRFjMCa6Hq8f/wmmu4/wpK3TyGruBEbYkLx5rLJ+Pu3V7A9lR/wXo9TISl2PN4+cl04noIDkmJVACAozDtHr0NL+O+WTBuOo9nV+PTVmXBzVeJhuxrbU2/g01dn4rW4MCSn3UD8U+NACEFWcT3eWDoBKYlReNiuxor3zmFDTCj+8vQkQXlejg4BwA8eq/acw7742TiQGNVJCQ0rW0dfnbpWi+2pNxA2wh1urspulUmRKjx9r/AODjb2O5soJJ2HpA/acVW66Fk4qlzikU48cgH86LUjPR9JsSooXRTCNtET/UUX6Cz2r5sj7BsA9mQU4tuLlRjjNwgRwd5ITruBpFhe+ABeCen+V7x3Fp++OgtKFwVyShuwMz0fiTEq7EgvwPqFoTiafQuHsm5htO8ATBrlibiI4cJgAABHs6sROcYbWaUNiJsagLAR7jh1rRaHsyrx9PSR2PZ8OMb4DcKMEB9sO3QN21NvQKMlguIcya5CZLAXLpY0guOAaYFe2J1RCIAX3vinxiGruB4Xbt7F+8dvYvSQx1F85z4AYHtqPv6TVYnSO/fhO/gx3P25DX+YF4wz+XeQXdaEiEBPKBQcskp5r6DoTqvQR+l5t/HdlRqsXTAWY4YOFL572K7GtkPXUFx9DwCwO/06Sup+AQCU3mnRXRPeAsZMGYaNS3jLlnm9BhdL+OPEhQcInyfFjkf8wnEIHjoQn5wqwrRgH+w9fhMcB1ypaMKuYwWIDQ8AAREs6MevzBQ8mR3pBThfdBernwyB0kUBQgiS0/IxPWQIACA57Ybw/4OX+cFz+hgf5Oh+L1bC0/l1SE67gYhgb0HOFk4JwIHEKESpfJGeewtqDT8IHrxQgbTc29i/bjYWTgnoZPnoohCxZ0U9ILqvKJUv/jRLiT//s1htTFdsopC06pwcUgWUTqK3PmxHcmo+xg0bDIBDeJA3Fk4JMDDRzkGt0eLIpUoAfAclxfHKkhSngqvSBfviO9xSeux98bORVVwPQoDcskbszigAwOH1uDCMGzaID7YBHL10C0sjh0OjJXjh/R/BcRz+a9pIvDgvBCW1rRjm5Ya9x4sEVzA1pxqfrZ2F9YtCeRc0owC7jxWguLYFh7MqsWhqAFJzqkEA3PvlEaaO8sTFkkZMCXRHXvk9ZOkECQAIAX4srEN2WZPwGVXGIYP64W7LI5Tq3tf93AYAOPRTGervawEA2eX874YO6oc7LY/0em3yKA+4KCAov8fjLmj+RYOPThQhu7wJQwc/BgDQaDm88OtgZORV40h2NUYNGYgg3wEoqm3FzZp72HboGqaO9kJWSUe7U3OqcSSrEu8cvYHi2laEjXBHyZ1WXCxpxFzVUHyRMAdqDd/G+KfGYWd6AaaN8cKO9AK4KDhsiAnFzvQCRAZ7Qa3V4qeiBvxU1ICUhDn4bO0s5JY14mG7GgsmDxMUYHKgJ74+X45DOm/laHYV9sXPxuXyJkEJjbmjp67VCtZ14+IwwaOSk1c+/DoHgOBAYpReyBQzdTjSc28J27/2wtP461/HGNU5jgpbT/Lm//wPeWvrVtnvqMIlxakw0M210/dvfXMZbx+5jtfjVJgeMkQY3egIRU9YHDPQDtq/riNuOXWtVogbd2cUYnFEAHa+MB1nC+qQU9qA5DTe7frHmhm4ceuezgKO0LOc1KV6ce+PWBM9FpdK6nGxpBGeA/qh6f4jxIUHIC2nGrHhAUjPrcbLT4bg1LUaFNe2Co7Q1EAP5JY3I2K0Fwi0yClr7rL/FAC0JvY1B7HT1X1cOEAj2kH/fhwePOr4wL2/C+490F8ZIz5m3NRhGOM/GO1qDT44UYRpQV7QaIkwkKxfOA4bl4Rh/Sc/Ybj3AEQEeSOvvBF7vitE/FPjsOe7QlAPO2bKMAC8BQeApyb74/jlGry6YCxmh/KKRHMRr8eNxxtLJwgy8ezO05ge7IP96+cgp6wRao0Wy3edxRMhPvhXUhQuFNV38sSkskQHfJpzULooMG+CH07n1wlySGULkM89iEOwk1drsHRlgrb9yrcG/V6bKORza14jKR++K/vdkUuVQiywcUlYp5OjCksTIjQ2oB0pPmGA77yH7WrcuHUP44e7Y/VHF7AhRoUd6fngs8odwrMhJhSV9b/g0MVKJMXxbuyViibBVQ0P8sacUF/sySgUBgza3sURAcIITBnp8zgq638BByAxJhTnCuv0rIUcri5Au2Tll1QJnJHhXm641fgQABA2YhCuV7UA0CkZIUi/3HlJXtzUYQDHITVH/r7Ml+cF40plMyKCvPDhiSJsiO24ZjvS8oX3QIcLLJaTP+w9h0NZvJez9+UZeopF5Ueav6AuaU5pg97+xJZPHFoZK8vZrtag/7DxX2rqCp811G9WcVl1T75qBhBECPlI+n3Q0IGdGkb9buqnJ6flw0WhENyDz9bOEuK7N5ZO0HMvxe6qOLOVnnsLq/acw+KIETiaXYWERaEAOEwa5YlPX+Xdm4kjPaDWaHEs7zY0WoJvL1ZiaeRwhAd5AwB2pufrYsN8EAARo72QW96IsBHu+HWYH746V4a1C8bilQV85jJytAf+fugG7rdrUVnPx1cEQHFtC56bG9RJIVUjByK/siN+kyojAKdXRgCCMgIQlNH9caVg7eRIzb0tWEUx8yf5o38/BfLKm5BV2oiLJQ2YPsZbyDqHB3lj7VPj8G5aPjjwybr96+YILiwNYRZHDMfhrFs4ml2NZ2bWQumiENxTqlhS5fr7t1fwri5p9cclYYLcGVqfbCgHQhVV21BSYqzfLFZI0WPoTuqeFRlNCDkp3sZFob+G/eTVGizffRYA8I81M4Uky4LJw3TTFAX8qJdeAOqbU59/3gQ/DHRzFZJB4hEuSuWL2PAAfHuxEq/HqbBxSZjg5ian5uO97wqRqIvnjmZXY9eqCMwM8cGiKcOw8r2zSIxR4ZNXZ+FSSYNgRbN1cdxPRfV4/3ghfipqAAfeEhfVtqL9kRb32zs7lGk51bjT/KDT57UNbR19B8vcS2fj3i8d+Yz+SmCoxwCU198XPouZ7I9jMgobOmww9nzHx7ch/gMxf6I/9h4vAsd1xPxPTfQHIUD4aE8kxKgEDys995ZeCLMvfhauVDTpZWG/SJiLGSE+eOuby4InRDPyO9ILwOkyxdQlNkb0RH9hGkyc8Tc1y2qNuz0iAZTqXpcC6PLhrdET/ZEUqwLHATduNWPXsQJcr7oHV6UL/vL0JBxInIuEGBU2xITio9UzoNZocepaLZLTbuB0fh0A/XIUz+08jZc/OI/jl2/jaHY1FBwQHuSNgW6uiJk6HKfz6/Bu6nUsiRiB5LR87EgvgEbLW+XzRfW4VnUPS6aNxE5dO+jFnxroiSDfAQCASyX1+KmoAQAw1MMNRbW8lSu8fU/2HAkgZDTFNN1/pLdNX+WBGnrKCAA/Ft8FAbBggh/G+Op7Va/MHwstAYprWtHfVYl98bPw+fo5UAUMhkYL1N7jLXJueRPcXJV62c7962Zj/7o5WDglAEoXBZLT8pFb1oh98XzWNGbqcOzJKMTbR64jWWcN6XTa+oXjkBSrQkKMCiev1gjzxMZuu1O6KLBqzzm9O2WoRe3KQlpDIT0k772lG9BpD3oLVofiRWHjkjAkxY7Hu6nXcfJqDVyVLoie6I89GYXYmZ6PwtstWLXnHAD90vzRE/3x8Ssz0a7WIGYqbxWvVDRh/7rZ+Hz9HGFukW6bkhiFPS9Nx2drZ2FJRAA4riNLeeHmXRy6WInERaEYN2wwYqYMAwcgr7wJpXX3MT2YzxxGBnuBA1Db/BB+Hm6YP8kfZXc7hGqQm0PeXurQKEVd1nyft6Cld1tQXNcKz8f7AQDeyyhEVgk/GE4b44XktHwoXRRYMm0krlXxA2JOeROWRg7HZ2tnCVMNVHmULgpBHvi57I6M8smrNWh92I6wEe78PKouK09lJnKMD3YdK8CejEKZ29E44ZX4divplMeJ//1fvLX1b0j54F2AkFFG+8PcjhTRDMDL2AbSaQ9p4PvG0gmICPbWC6yT027gtbgwJMWphDT16fw6vd9er7qHHekF2BATij8tCdPL1ErnN6k/7+aqRHpuNRIXhaK45mek5t5GVmkjlkby36/+6AK0WgJwwLTRXrhU2ohpwT64WNKIrJJGhI/2QE5ZM2qbH2LGGCXAAUE+/VF69wEiRnvjcmWznhWkjPIZgAqJRWAAapn0MR0om355hDFDB6Ck7j6ySxvw9PSRiA0PwOrSCwD4a1xxl/dUlkQE4JNXZ6NdrUH8xxdxJLsKKbp7aukCjsmBnth1jF9EQXMG4tU9XyTMFeSHykzrw3Zh/lQso/Mm+GFDTKjgmspN34lXkM387Tjs2XUGCh/j0x7WGNKz0GElgwCc6OoH0hs+pXeA03iRKhh1O8UV0zLyqkWj2nhEBHvr+ffSY4hjzpTEKLy5bDJ+PzcIHIClkcPx2+kjsTM9H2sXjMW0YG8Qwruc6xaOw60GXkA4AM2tvLL5uT+G//PsVGyMC0PpXT5WzMy/i6b7j+DxeOc+XzhlGJZEdFhtlz5sTPu7cnrv6bupgZ5YOEk/SVJ85z4I4RcYbHs+HHnljVg02R8tDx7hrW8u42hONZZGDseHa2bCVemC5NR8fHuxEpFB/CBObyamiwa+SJiLjUvChCmMLxLmIilOpWfRxI8TPH75Nran3sDZgjo9GT2dX4cd6QV4ce+Pwoou8bwmdXmTYscL+Y2k2PHQNpaXGesbazzS/BsAQRzHRQPwkCZ05OjqDnq6ioLGi+Lf0M5Ta7R4ce95hAd5C3NKUp9dHFxTn//UtVqhYxdOCcC/kqKw9+UZACCsuMkqaUCI3yAAQMXdVhzNrkZceACmBXuhVOei1t5rwwfHCzE50BN7XpyGEP+OmKf5F/3FGOGBnsgpbdBL52tMnVh0QoZ79e/0mZtojHrQzkfPwzzdAEBYkzt9jA8yrnRcw7ipfOjAgV8F9cfPL2F3RiFSc2/j1X/8hJ3pBeAABA8dJKyaCRvhjiURAfipuB7v6JbwvbF0Ar5ImCvEi3Rwp8lA8f/ndp7GtkPXhJIoVyqaIBfti2PTKJUv3jlyHe8cvS5M21GX942lEwAAyan5SE67AYVX4GhjfWeVcZoQ8jYh5CQh5G1Ttu+qJoqcwsr/hhjdvnNwrT8y032ezq/Di3vPY0d6PlwUHBQcsHHxeLwep8KoIQPBccAYv0HILm1ExOgO7/xmzc9Yvvss/plZhqKaVgQP5RNAk0d5CNvEhQfARckvWaMT3v4ej2FNdAhiJncekHwHKjtZ2KGDXDHM4zHZvnJEbjXyHsP8iX6YONIdAPBQN0YNFZ1H/368+EUG8X16SjSgcgB++8RIJMaEYtFkfxAAi6YMw4aYUEFRE2NCkRSrws70fOGZnC99cB4h/oNBCJCclo+MvOpOtYLUGq2wGF/sSRmypgcSozBvgl+nkhw0NqXWki7ABzrXVKLW0hZJHatDEzs0q0Xdh9aH7dh26Bqe23kaShcFDiRGCeltsbKK3dN98bPxsF0NtUaLT1+dCYBfHSTu3CiVr5DRnTraC5+vn4NlMwMRHuSN94/fRFKsClNHe4HjOMwVLbXqp+CgJcDF0gbMDPFBWR1vPSPH+CAy2AtrF4zFMzNHIae0EU+M8cHOlRGIDPJCTXMbqhvuY+SQAcK+pgd7Yf3CcahrVaP5F7WeUt5paUd4kI9sXz05wc+6nW+ANdEhwoCzUDKQTB7lgcf7dQx2o30HQMEBIf6DcLXyHjiOVzoFB9y91yZkrn813h9LI4fjpSdDwHFASV0rIoO8EDNlGD5+ZQbcXJXYnVEoLCK4VnUPby6bjD0vz8DS6SORFDcef3l6ElJ0i8epVzRplCcSY0LB6Y+/wlTGyvf4KbeTV2swI8QHCYtC8bBdjXa1BpMDPfWyr9KQSVp0mq7iWb9wHDiuY220GGotk+JUjrG43FSky4xokAzoB9+vxYUJiihN3gAdnZUUOx6TAz3x4t4fQQiwNHIkjlyqFEZB8XK7XccK9IJ7AMLdJXT97IFEJaJUvpg62gtXKprwfFQw7rQ8RESgF6aO9oL3oMeQllONy+VNyNIlgVyVCmyI4edET+fXCfOaqbkd820hfgORXcav7aRQt3fBpKFw66fE9pWR+O30kfi//7mC4jv34efxGGqb29C/nwIcgNXRIahp+gXDvQfg/eM3ETx0IErutGKUT39U1D/A0MGuWDxtJLJLG5Bb3rEeVkp/JfD7OcH4NJMfyBdO9MPvo4KgdFHgw5NFfHv9B6Pp/iP8VFyPsX4DkfHXaLSrtVi2PRNZJY3CwFSu+0/j8SW6Nb5ldffBAfgsswQKBYdnZgbi8/X83T80FHkuKgjzJvhh/cJxOFdQh6zSRryXUYgZY4fgcnmTcMPAm8sm663YAoA/7P0RiTEqYaqDIk4WUplaHDEChy5WAhyQsCgUuzMKsH/dnE7em9QLo+/F85lfboiSDcPE61pd/ML+G0DPrtTpCundHoYQK6Hc04jpwmFDv6GZVH6ek59K+ee6Odi/bg5/98axAr3MrVqj1Vv9E6XyFTJpJ6/WYNexAr3bswAIFyo5LR9nbvCCcqmkUQgzXotT4ZUF4/DH/dkY4fM4dmUUAASCUn+2dhZ+KqpH5d1WBHg/jo9OFqOothVrF4yFRkvwySszodZo8MmpYlwsacTxK3eg4ID/nj0aA/v3Q6lOyGub27B02giM8HkcCgWHqPFDsXBKADLyqhER5IW88iZU3G0VbrG683M7PsssxvqFoZ0UcklEAHzd3fDxqRI8UAOzQ4fgenUzLpU0Iky3YOPUtVqsiQ7BhyeLMGGEOzYuCcMz2zP5Nl6+jaefCMSRN+bhnSPXUXj7Z6TmVCPYbxA2xISiuLYF6bnVCBo6CPviZ0GtIbha2QRVwGDcrGnBPJ2V528iGATamaeu1Qr3Uz4xxgdZJfxtZeIbBqRysC9+tt6AK87mS2WKykhc+HCk5t6CRktACD8QS9elGrr3sV2tEfZpqPocbUO/xkKoKy58b1ABYCOFHDFyJKb/10uYpesIQ+v9xB0m7QD6mt56Ra1blMpXNn4UT6XQBM70kCF6+6adSadUxMcUzyWlZlfhPxcrkZpTjZSEucgtaxRc1SfGeOOF34xBQfU97M4oRHiQN/w8HsfnCXPR+rAdVfW/4MilKqFdTz8RCDdXJZ7fdYZf2qdbrpNVUo+skka8HqeCi0KBnDJ+KuZQ1i0Qwt8K5eaqxGdrZ+FhuxrH8m5jcUQA1nx0Aa/HhWHeBD9sO3QN76bdQLDvQBTWtEDBAZFjvJBV3IiYKcOgGu6OhBgV2tVavH/8JgD+Hsa/PD0JAPCbCXwfZhXziyCeCPHGznR+SWNy2g3EhvMDU1pONdxclfDz4JM3VyqaEBcxAsmp+dh1rAAfvPwElC4cJoxwx80a/jatpZEj8V5GgXDD9p7vCpEUOx67jhVgesgQZJc0CDcR0PsX6aR7UmyHh0Gvszir3vqwHReL7uLjV2YKyk3v6hEP1lKZojLysF2NtLxqTAv2xsbFvDJPDxkie+O8VHal+5SiZzCefBLk55qzBjcGbFPC49nVSVYr1ShXGa07hbEMFUwytC9xPZ35W78jLQ/ayMELZWTQ8hTyu+2ZQvEoQ/ulZTFo+QlxLZiWB21k05fZZNDyFPLF6WKy+ascsunLbOKhq4XT0PKAr1ujK9NBy3xs/iqnU30feqyIPx0hA5enkCe3ZpCDF8pITdN9smL3GfLVuRLhHGmZEXHFNnEZik1fZgvlPmgpksNZFUJtmkHL+bIog5Z3nFtaThVx1xX1OnihTCiHQkuiyNXoER9bXKbD2LWSkx9aRnPr13l6VeYMFRAzJhNdyZKlVRHhCDV1Nr35psHaI+ZUmRPXPqEX0hTlFIpFSSq3SYs4iTucKs3vkjPJIJ0S0AtMBc9QNTdp/Rdat0dca1R8LoezKvRq60iFi+7r4IUyPeEVF+hyX6E/ANDCVeIaNYbOl7bXfQU/+NB90f6i2276MrtTfSHxudJzERehMkWQTZUF6XZd1dyxVInMaaMhHEIhxUWuLCmzRxH/RmqF5PYnV4nN2GgpV+iIFnqiCigt5mTKBTRUJY6WaZSWXzS1iJK4YJb4WHJFvuTaIz3XFbvPEA/Rf9pfdBt+IOpcmNnUfjCEOZ6ToWJVhs7RFGihra7KZpqDwymkXEk/QxdKTtCkv5FaPWMuqbH9yB1XXApQ7LpJCwl3V5CkAwot03jwQpneduZaDHoMWq5RXPlOemy5a9GVglGXl9aJ7U7d0+6eh/g7OcXqqu/NUXK5UpTWwmEU0lCZPmPIxYvGtuvOhSTE9OcBdjWIyMU/ppyX2ELKlao0R5ik5y0tEWlOuCA9P3Gb5eJQ6XFMaasp1lNcGNnU35obElkSUhnbp0NULl+5ciV5dnUSGfjUJrOFy9xOMccl7u52piq2oc8NuV2mFAM2lgyRxqTmIk6aULqyIlIvw5z+EyMdWK2lKF1B22ZpHx7OqiADntpEuMHDThF7K6TYQlpyUuaMhra4cKa6vtRDoC62sQegijOhxoRVTlkMuejm0p0MqNxvulJOU2NlMZZ4D91BGhKZC41LFb7j/kUcQSGtQU/EC5Yi597IxWDikZb+N+aK0wu46ctssy1kT1sPKeLjGlLCrq6RMRfe0LHMaZ+552UuDuWyWksheyJesPS4ckkScfrfkLJ25XZZa2Tu7vlYgiluqinuK53DtEZSpTuDgS1wmKSOM2PI9TSkYNIH6ZgrAD2hOFTRe0IwrWVJrPFsSkp3Yllb0KsU0pFcMVOEWs4qWrs93SUtx7LnJTo65sSjtsQpFNLUTnMEl8McJbN2uy2dDnEkAbU2PdU31uo3h1DIlStXks2bN5Pvv/9etpGmdqKzCpO1292d/TlLn1mrnZZ6D4bk0Boy+v333xMA+4i9FdJaFpLRfUyd47N3/9vb6ncVu1rLi+vKQjpExYCuSnpYG3HJPnv83pZ0Vb8IMFwQTFpZoafOW1pWo7tI228OJ6/WYNWec1C6KGTl0FQZNaW/jWJMW63152hZVksTG44Qy1oT6ehvKHHVU+dt6X5tsejEWsARYkhHU0hLU/+O4OJZgqnzuXL3Stp6ntcRsaS9vU4hHSH4d3Z6m4W3NZb0X1cKadMY0hoxiDXiBcD2casjYXGc08fpyf6zyfMhV61aRQIDA+EWEIa3f1R3elRXdzD2/D0GoysskR9LZS8zMxO/+c1v/kkIWWVwI2Pm01p/1GXty26iHKw/bI8l7qY1XP2uFpfb1GXty24iRey2W8v9ZpiOJe6mNVxVWzwfss/TndhYWrqexXK2xRKjYA2D4pSPEnA2umPp5GrP9mWPoc+h1Rgdta2mkBzHNXEcd4LjuD9Za5/OQncsHVPCnsWZVlHJYU0L+QwhZD4x8QlYvQmmZI6Ds8fl1nyUgAfHcUGEkFLpF/TZHgC6fL4Hg2EJjhiXZ2ZmIjMzk74NNLat1eYhOY5bDeDfALYRQtaIv9uyZQsRP9KcweircBz3N0LIFkPfm2whOY5bBsBL8nEp0T0xmRDykW67Zo7jlhH+ycoMBqMbmKyQxhRMZx0vEUJyrNIqBqOPYq2kzr8BwYoaVV4Gg2EYqygkIaSZEJJDCPmGEPKGNfbZ23D2dDzDNrCFATbCUdPxbKBwLJhC2ghHTMcDjjtQ9FVsopB0HlI0FyNLbx6tHXXxgKMOFL0RnfwHGtvGJgoZGBiILVu2dLkggI3WtsdRB4reiE7+y41t41AuKxutGX0day6dsxg6WjMYfRWHspAMRl+HKSTDYnpzMs7WMIVkWAxLxlkPh5r2YDgnLBlnGqZMe9gkqUOnPRi9E5aMMw2nm/ZgMPo6TCEZDAeCKSSD4UAwhWQwHAimkAynpLfOfbJpD4ZT4oxzn2zag9Frcca5T1OmPRxqcTmDYSq9de6TxZAMhgPBFJJhE3prEsbaMIVk2ARnTMLYA6aQDJvgjEkYe8CmPRg2gdXuYdMeDIZDwe72YDCcDKaQDIYDYZZCchy3jOO4EzKfReuehKVHeXm5mc1zHJw9/nX29gO94xzQE4WSpU+3Ej316qTufbT4e6aQ9sfZ2w/0jnOAjSqXRwKgjzIvBRBuzk5M6XBTL4q1t7PHMdk5mIc92mat9pv9SHOO404QQubrXn8I4ENCSI7OOs4XP5aO47jzANp0b8thONMUaOS77mxjr+3scUxTt7PHMa29nT2Oaep2xrYJRIdlfIwQMtPQTmSnPbp6fLkMzTLbCxhrAIPB6EBWIc14AnIWAA/d6yAAJwxvymAwDGFuljUawDTJI8yDdJ97GLGkDAbDCGbHkN06CK+4a2jMKfqsGUAQIeSjHm+EleA4rgnAJQAnCCFv27s9puCsfS3GGfsd6L7s22RhQHenSRycZwgh851FKJy8r8U4Vb9Tuiv79lqpY5VpEjvhwXFckL0b0Q2cua/FOFu/G8Lo9bCXQnpI3nvboxFm4gWgUTfV4wx4SN47U1+LcbZ+N4SH5L3e9bDK3R7WniaxJ12dC/X5OY5r5jhumRkZaVvTDAft6+7ghP1uiGYYuR5WUcjeNE1i7Fx063QvEUJybNgkS3HYvjYVJ+13Qxi9HjZxWXvRNMm/Ab3A3OFHaSfuazFO1++U7sq+TaY9GAyGabD7IRkMB4IpJIPhQDCFZDAcCKaQDIYD8f8B/QxRYcoPZTsAAAAASUVORK5CYII=\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.scatter(initcond[:,0],initcond[:,2],s=0.5)\n",
-    "plt.xlim(-10,10)\n",
-    "plt.ylim(-10,10)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "42da137b-f549-4c2b-b0b7-e6df896a3b6c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "num_gaussians = 5  # Number of Gaussians in each dimension\n",
-    "grid_range = 5.0   # Range for each dimension\n",
-    "def create_grid(num_gaussians, grid_range):\n",
-    "    # Create evenly spaced grid points in each dimension\n",
-    "    grid_points = jnp.linspace(-grid_range, grid_range, num_gaussians)\n",
-    "    grid = jnp.meshgrid(*[grid_points] * 6)\n",
-    "    grid = jnp.stack(grid, axis=-1)\n",
-    "    return grid\n",
-    "\n",
-    "def gaussian_pdf(x, mu, sigma):\n",
-    "    # Compute the Gaussian probability density function\n",
-    "    return jnp.exp(-0.5 * ((x - mu) / sigma) ** 2) / jnp.sqrt(2.0 * jnp.pi * sigma**2)\n",
-    "\n",
-    "def create_gaussian_grid(grid, grid_range):\n",
-    "    # Calculate the standard deviation for the Gaussians\n",
-    "    sigma = grid_range / (2.0 * num_gaussians)\n",
-    "\n",
-    "    # Evaluate the Gaussian at each grid point\n",
-    "    gaussians = gaussian_pdf(grid, 0.0, sigma)\n",
-    "\n",
-    "    # Normalize to make them equally weighted\n",
-    "    gaussians /= jnp.sum(gaussians)\n",
-    "\n",
-    "    return gaussians\n",
-    "def visualize_grid(grid, values):\n",
-    "    # Flatten the grid and values for plotting\n",
-    "    flat_grid = grid.reshape(-1, 6)\n",
-    "    flat_values = values.flatten()\n",
-    "\n",
-    "    # Create a scatter plot\n",
-    "    fig = plt.figure(figsize=(8, 6))\n",
-    "    ax = fig.add_subplot(111, projection='3d')\n",
-    "    ax.scatter(flat_grid[:, 0], flat_grid[:, 1], flat_grid[:, 2], c=flat_values, cmap='viridis')\n",
-    "    ax.set_xlabel('X')\n",
-    "    ax.set_ylabel('Y')\n",
-    "    ax.set_zlabel('Z')\n",
-    "    plt.title('6D Gaussian Grid')\n",
-    "    plt.show()\n",
-    "\n",
-    "# Create the grid and Gaussian values\n",
-    "grid = create_grid(num_gaussians, grid_range)\n",
-    "gaussians = create_gaussian_grid(grid, grid_range)\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "b804eb1d-0ba7-4a2e-bb43-f2c3637d55ab",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "## lean f(x,t) and f(x,v,t)/f(x,t)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "0ca65638-38a1-4afd-b494-c6c96be06b36",
-   "metadata": {},
-   "source": [
-    "$$f(x,v | t) = f_1(v | x, t) f_2(x | t)$$\n",
-    "\n",
-    "So for kde method we can learn $f_2(x,t)$ and learn $f(x,v,t)/f_2(x,t) = f_1(v|x,t)$\n",
-    "\n",
-    "That is, just learn $f_2(x,t)$ with $f(x,v,t)$. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "e1ea9ba0-ceb6-4dd3-82e1-886e6b29881d",
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "ModuleNotFoundError",
-     "evalue": "No module named 'flowMC'",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_31499/4189560395.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mflowMC\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnfmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrealNVP\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mRealNVP\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mflowMC\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnfmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrqSpline\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mMaskedCouplingRQSpline\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mflowMC\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnfmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mutils\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mmake_training_loop\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'flowMC'"
-     ]
-    }
-   ],
-   "source": [
-    "\n",
-    "from flowMC.nfmodel.realNVP import RealNVP\n",
-    "from flowMC.nfmodel.rqSpline import MaskedCouplingRQSpline\n",
-    "from flowMC.nfmodel.utils import make_training_loop"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "959869c6-243b-4d6b-ae24-f4cb2d8da6a2",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "e2b4e353-f220-4509-bf02-b81879358813",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "0998db7a-8677-4f28-9206-8e6cd7c0e10c",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 43,
-   "id": "3a836de8-4cf8-4fe5-b5e4-c12b02a62710",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "time_arr = np.zeros(len(initcond))\n",
-    "ics = jnp.hstack([initcond, time_arr[:,None]])\n",
-    "\n",
-    "kde = jaxstats.gaussian_kde(ics.T,bw_method=0.1)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 83,
-   "id": "45b75197-edc3-4ad6-965f-0b7f3239120a",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array([[ 1.08795719e-01, -3.39449136e-05, -1.24706105e-03,\n",
-       "        -3.88938839e-06,  6.87778248e-04, -2.07770638e-06,\n",
-       "         0.00000000e+00],\n",
-       "       [-3.39449136e-05,  1.08365069e-01, -8.90011412e-04,\n",
-       "        -6.65240274e-04,  6.62761112e-06,  3.49740666e-06,\n",
-       "         0.00000000e+00],\n",
-       "       [-1.24706105e-03, -8.90011412e-04,  4.70807555e-03,\n",
-       "        -1.89159793e-06, -2.39904157e-07, -1.15623389e-06,\n",
-       "         0.00000000e+00],\n",
-       "       [-3.88938839e-06, -6.65240274e-04, -1.89159793e-06,\n",
-       "         8.12506251e-05,  1.74011915e-07, -1.40707402e-07,\n",
-       "         0.00000000e+00],\n",
-       "       [ 6.87778248e-04,  6.62761112e-06, -2.39904157e-07,\n",
-       "         1.74011915e-07,  8.43770771e-05, -7.25596689e-09,\n",
-       "         0.00000000e+00],\n",
-       "       [-2.07770638e-06,  3.49740666e-06, -1.15623389e-06,\n",
-       "        -1.40707402e-07, -7.25596689e-09,  2.25392343e-05,\n",
-       "         0.00000000e+00],\n",
-       "       [ 0.00000000e+00,  0.00000000e+00,  0.00000000e+00,\n",
-       "         0.00000000e+00,  0.00000000e+00,  0.00000000e+00,\n",
-       "         0.00000000e+00]], dtype=float64)"
-      ]
-     },
-     "execution_count": 83,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "kde.covariance"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 56,
-   "id": "a0d22114-5eea-4d3d-88ab-7309ad9e1687",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "cc = jnp.eye(7)*.000000010000000"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 60,
-   "id": "d9399e99-8063-43e0-84a8-ce123cc509b3",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<bound method gaussian_kde.integrate_kde of gaussian_kde(neff=Array(10000., dtype=float64), dataset=Array([[ 0.49225886, -0.00733685, -0.21742962, ...,  1.79766804,\n",
-       "        -0.02119263, -0.7557257 ],\n",
-       "       [ 0.85610141, -0.22638977,  0.98555841, ...,  0.30446151,\n",
-       "         0.32341598,  0.83642072],\n",
-       "       [ 0.1825324 ,  0.01226333, -0.93267224, ...,  0.60627381,\n",
-       "        -0.19870105, -0.18082222],\n",
-       "       ...,\n",
-       "       [ 0.14969925, -0.01343064, -0.06125901, ...,  0.14501373,\n",
-       "         0.05227103, -0.08297316],\n",
-       "       [ 0.00360584, -0.00973185, -0.02295155, ..., -0.02740964,\n",
-       "        -0.06258291,  0.01623288],\n",
-       "       [ 0.        ,  0.        ,  0.        , ...,  0.        ,\n",
-       "         0.        ,  0.        ]], dtype=float64), weights=Array([0.0001, 0.0001, 0.0001, ..., 0.0001, 0.0001, 0.0001], dtype=float64), covariance=Array([[ 1.08795719e-01, -3.39449136e-05, -1.24706105e-03,\n",
-       "        -3.88938839e-06,  6.87778248e-04, -2.07770638e-06,\n",
-       "         0.00000000e+00],\n",
-       "       [-3.39449136e-05,  1.08365069e-01, -8.90011412e-04,\n",
-       "        -6.65240274e-04,  6.62761112e-06,  3.49740666e-06,\n",
-       "         0.00000000e+00],\n",
-       "       [-1.24706105e-03, -8.90011412e-04,  4.70807555e-03,\n",
-       "        -1.89159793e-06, -2.39904157e-07, -1.15623389e-06,\n",
-       "         0.00000000e+00],\n",
-       "       [-3.88938839e-06, -6.65240274e-04, -1.89159793e-06,\n",
-       "         8.12506251e-05,  1.74011915e-07, -1.40707402e-07,\n",
-       "         0.00000000e+00],\n",
-       "       [ 6.87778248e-04,  6.62761112e-06, -2.39904157e-07,\n",
-       "         1.74011915e-07,  8.43770771e-05, -7.25596689e-09,\n",
-       "         0.00000000e+00],\n",
-       "       [-2.07770638e-06,  3.49740666e-06, -1.15623389e-06,\n",
-       "        -1.40707402e-07, -7.25596689e-09,  2.25392343e-05,\n",
-       "         0.00000000e+00],\n",
-       "       [ 0.00000000e+00,  0.00000000e+00,  0.00000000e+00,\n",
-       "         0.00000000e+00,  0.00000000e+00,  0.00000000e+00,\n",
-       "         0.00000000e+00]], dtype=float64), inv_cov=Array([[nan, nan, nan, nan, nan, nan, nan],\n",
-       "       [nan, nan, nan, nan, nan, nan, nan],\n",
-       "       [nan, nan, nan, nan, nan, nan, nan],\n",
-       "       [nan, nan, nan, nan, nan, nan, nan],\n",
-       "       [nan, nan, nan, nan, nan, nan, nan],\n",
-       "       [nan, nan, nan, nan, nan, nan, nan],\n",
-       "       [nan, nan, nan, nan, nan, nan, inf]], dtype=float64))>"
-      ]
-     },
-     "execution_count": 60,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "kde.integrate_kde"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "b8af3109-dd28-44d3-84af-9d28a6b649d1",
-   "metadata": {},
-   "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.8.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/Untitled2.ipynb b/Untitled2.ipynb
deleted file mode 100644
index 096ae5a9..00000000
--- a/Untitled2.ipynb
+++ /dev/null
@@ -1,102 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "id": "4742b8b8-7144-42d8-90b1-db1043558a1f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import astropy.units as u\n",
-    ">>> import numpy as np\n",
-    ">>> import gala.potential as gp\n",
-    ">>> import gala.dynamics as gd\n",
-    ">>> from gala.dynamics import mockstream as ms\n",
-    ">>> from gala.units import galactic\n",
-    "import matplotlib.pyplot as plt"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "id": "c76c04cd-49e5-4cd0-9907-e59e2ac88d6d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pot = gp.IsochronePotential(m=1.0e12*u.Msun,b=10*u.kpc,\n",
-    "                                              units=galactic)\n",
-    "H = gp.Hamiltonian(pot)\n",
-    "prog_w0 = gd.PhaseSpacePosition(pos=[50, 0, 0.] * u.kpc,\n",
-    "                                 vel=[0, 150, 0.] * u.km/u.s)\n",
-    "\n",
-    "df = ms.FardalStreamDF()\n",
-    "prog_mass = 2.5E4 * u.Msun\n",
-    "gen = ms.MockStreamGenerator(df, H)\n",
-    "stream, prog = gen.run(prog_w0, prog_mass,\n",
-    "                        dt=.5 * u.Myr, n_steps=2000)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 29,
-   "id": "1eaebf93-e881-466b-a0a9-10dc901fcf38",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7fcd5bcb2460>"
-      ]
-     },
-     "execution_count": 29,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.scatter(stream.x,stream.y,s=0.0905)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "0d41b39b-241a-4c3e-98be-f6754ba1467a",
-   "metadata": {},
-   "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.8.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/custom_integrator.ipynb b/custom_integrator.ipynb
deleted file mode 100644
index 7d2289bb..00000000
--- a/custom_integrator.ipynb
+++ /dev/null
@@ -1,824 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "43740e1a-57e7-4df0-9db5-1b9fb8370c9d",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u001b[91mA new version of galpy (1.9.0) is available, please upgrade using pip/conda/... to get the latest features and bug fixes!\u001b[0m\n"
-     ]
-    }
-   ],
-   "source": [
-    "from functools import partial\n",
-    "\n",
-    "from astropy.constants import G\n",
-    "import astropy.coordinates as coord\n",
-    "import astropy.units as u\n",
-    "import matplotlib as mpl\n",
-    "import matplotlib.pyplot as plt\n",
-    "%matplotlib inline\n",
-    "import numpy as np\n",
-    "\n",
-    "# gala\n",
-    "import gala.coordinates as gc\n",
-    "import gala.dynamics as gd\n",
-    "import gala.potential as gp\n",
-    "from gala.units import dimensionless, galactic, UnitSystem\n",
-    "\n",
-    "import jax\n",
-    "import jax.numpy as jnp\n",
-    "\n",
-    "from jax.config import config\n",
-    "config.update(\"jax_enable_x64\", True)\n",
-    "\n",
-    "import scienceplots\n",
-    "import cmasher as cmr\n",
-    "plt.style.use('science')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "18f9af43-0d30-4388-88ab-39f460449bf2",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "usys = UnitSystem(u.kpc, u.Myr, u.Msun, u.radian)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "66f49743-835f-4cda-b32f-44110a4f8d58",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class Potential:\n",
-    "    \n",
-    "    def __init__(self, units, params):\n",
-    "        if units is None:\n",
-    "            units = dimensionless\n",
-    "        self.units = UnitSystem(units)\n",
-    "        \n",
-    "        if self.units == dimensionless:\n",
-    "            self._G = 1\n",
-    "        else:\n",
-    "            self._G = G.decompose(self.units).value\n",
-    "        \n",
-    "        for name, param in params.items():\n",
-    "            if hasattr(param, 'unit'):\n",
-    "                param = param.decompose(self.units).value\n",
-    "            setattr(self, name, param)\n",
-    "    \n",
-    "    @partial(jax.jit, static_argnums=(0,))\n",
-    "    def gradient(self, xyz):\n",
-    "        grad_func = jax.grad(self.potential)\n",
-    "        return grad_func(xyz)\n",
-    "    \n",
-    "    @partial(jax.jit, static_argnums=(0,))\n",
-    "    def density(self, xyz):\n",
-    "        lap = jnp.trace(jax.hessian(self.potential)(xyz))\n",
-    "        return lap / (4 * jnp.pi * self._G)\n",
-    "    \n",
-    "    @partial(jax.jit, static_argnums=(0,))\n",
-    "    def acceleration(self, xyz):\n",
-    "        return -self.gradient(xyz)\n",
-    "    \n",
-    "\n",
-    "class Kepler(Potential):\n",
-    "    \n",
-    "    def __init__(self, m, units=None):\n",
-    "        super().__init__(units, {'m': m})\n",
-    "    \n",
-    "    @partial(jax.jit, static_argnums=(0,))\n",
-    "    def potential(self, xyz):\n",
-    "        r = jnp.linalg.norm(xyz, axis=0)\n",
-    "        return - self._G * self.m / r\n",
-    "    \n",
-    "    \n",
-    "class Hernquist(Potential):\n",
-    "    \n",
-    "    def __init__(self, m, a, units=None):\n",
-    "        super().__init__(units, {'m': m, 'a': a})\n",
-    "        \n",
-    "    @partial(jax.jit, static_argnums=(0,))\n",
-    "    def potential(self, xyz):\n",
-    "        r = jnp.linalg.norm(xyz, axis=0)\n",
-    "        return - self._G * self.m / (r + self.a)\n",
-    "    \n",
-    "    \n",
-    "class Isochrone(Potential):\n",
-    "    \n",
-    "    def __init__(self, m, a, units=None):\n",
-    "        super().__init__(units, {'m': m, 'a': a})\n",
-    "    \n",
-    "    @partial(jax.jit, static_argnums=(0,))\n",
-    "    def potential(self, xyz):\n",
-    "        r = jnp.linalg.norm(xyz, axis=0)\n",
-    "        return - self._G * self.m / (self.a + jnp.sqrt(r**2 + self.a**2))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "b5c8d063-8929-49f8-a93d-dd8e31bbe4b0",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array([-0.0134369 , -0.02687381, -0.        ], dtype=float64)"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "pot = Hernquist(m=1e12, a=10,units=usys)\n",
-    "xyz = jnp.array([1., 2., 0.])\n",
-    "\n",
-    "pot.gradient(xyz)\n",
-    "pot.acceleration(xyz)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "154dd43f-e89c-4c74-b3bc-ca11eedf185b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def leapfrog_step(func, y0, t0, dt, a0):\n",
-    "    ndim = y0.shape[0] // 2\n",
-    "    tf = t0 + dt\n",
-    "    \n",
-    "    x0 = y0[:ndim]\n",
-    "    v0 = y0[ndim:]\n",
-    "    \n",
-    "    v1_2 = v0 + a0 * dt / 2.\n",
-    "    xf = x0 + v1_2 * dt\n",
-    "    af = - func(xf, tf)\n",
-    "    \n",
-    "    vf = v1_2 + af * dt / 2\n",
-    "    \n",
-    "    return tf, jnp.concatenate((xf, vf)), af\n",
-    "\n",
-    "@partial(jax.jit, static_argnames=['potential_gradient', 'args'])\n",
-    "def leapfrog_run(w0, ts, potential_gradient, args=()):\n",
-    "    func_ = lambda y, t: potential_gradient(y, *args)\n",
-    "    \n",
-    "    def scan_fun(carry, t):\n",
-    "        i, y0, t0, dt, a0 = carry\n",
-    "        tf, yf, af = leapfrog_step(func_, y0, t0, dt, a0)\n",
-    "        return [i + 1, yf, tf, dt, af], yf\n",
-    "    \n",
-    "    ndim = w0.shape[0] // 2\n",
-    "    a0 = func_(w0[:ndim], ts[0])\n",
-    "    init_carry = [0, w0, t0, dt, a0]\n",
-    "    _, ws = jax.lax.scan(scan_fun, init_carry, ts[1:])\n",
-    "    res_ws = jnp.concatenate((w0[None], ws))\n",
-    "    \n",
-    "    return res_ws\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "794a5c12-1713-4dad-8d4e-32c6eb122269",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/latex": [
-       "$0.20454243 \\; \\mathrm{\\frac{kpc}{Myr}}$"
-      ],
-      "text/plain": [
-       "<Quantity 0.20454243 kpc / Myr>"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "(200*u.km/u.s).to(u.kpc/u.Myr)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "07bc10b1-0c01-44e2-84c1-c8c14a550675",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "w0 = jnp.array([10, 0, 0, 0, .204, 0])\n",
-    "t0 = 0\n",
-    "dt = 0.1\n",
-    "n_steps = 10000\n",
-    "ts = np.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "ws_jax = leapfrog_run(w0, ts, pot.gradient)\n",
-    "\n",
-    "\n",
-    "    "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "92ded815-3719-434e-ba5f-9e6fa5063fa8",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "run_grad = jax.jacfwd(leapfrog_run)\n",
-    "Jac = run_grad(w0, ts, potential_gradient=pot.gradient)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "1ead0aa1-3795-439a-a8e9-b7629a4fb875",
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "NameError",
-     "evalue": "name 'ts' is not defined",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_19938/2144211927.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mw0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m     \u001b[0mwcurr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mw0\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m     \u001b[0mws_jax\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mleapfrog_run\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwcurr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpot\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgradient\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     11\u001b[0m     \u001b[0morbs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mws_jax\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mNameError\u001b[0m: name 'ts' is not defined"
-     ]
-    }
-   ],
-   "source": [
-    "import jax.random as random \n",
-    "key = random.PRNGKey(0)  # Initialize a random key\n",
-    "num_orbits = 6000\n",
-    "ndim = 3\n",
-    "w0 = random.uniform(key, (num_orbits, 2 * ndim))  # Generate random initial positions and velocities\n",
-    "orbs = []#jnp.array([])\n",
-    "final_snap = jnp.zeros((num_orbits,6))\n",
-    "for i in range(len(w0)):\n",
-    "    wcurr = w0[i]\n",
-    "    ws_jax = leapfrog_run(wcurr, ts, pot.gradient)\n",
-    "    orbs.append(ws_jax)\n",
-    "    \n",
-    "    final_snap = final_snap.at[i].set(ws_jax[-1,:])\n",
-    "    \n",
-    "    "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "ddf8f189-f5d1-4d06-b526-20e2998fe97b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def compute_orbit_and_gradients(params,w0,dt,n_steps,units):\n",
-    "    pot = Hernquist(m=params['m'], a=params['a'],units=units,)  # Create the potential with the given parameters\n",
-    "    \n",
-    "    # Example Orbit:\n",
-    "    #w0 = jnp.array([10, 0, 0, 0, .204, 0])\n",
-    "    t0 = 0\n",
-    "    #dt = 0.1\n",
-    "    #n_steps = 10000\n",
-    "    ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "    \n",
-    "    ### Compute the orbit with the provided potential\n",
-    "    ws_jax = leapfrog_run(w0, ts, pot.gradient)\n",
-    "    \n",
-    "    # Compute the gradient of the final position with respect to the potential parameters\n",
-    "    def gradient_fn(params):\n",
-    "        pot_with_params = Hernquist(m=params['m'], a=params['a'],units=units)\n",
-    "        ws_with_params = leapfrog_run(w0, ts, pot_with_params.gradient)\n",
-    "        final_position = ws_with_params[-1, :]  # Extract final position\n",
-    "        return final_position\n",
-    "    \n",
-    "    # Compute the gradient using JAX's autodiff\n",
-    "    gradient = jax.jacfwd(gradient_fn)(params)\n",
-    "    \n",
-    "    return ws_jax, gradient"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "62ab3c14-52fb-4391-8f0d-c1ddf15fb826",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Example parameter values\n",
-    "params = {'m': 1e10, 'a': 10.}\n",
-    "w0 = jnp.array([15., 0., 0, 0, .204, 0])\n",
-    "dt = 0.1\n",
-    "n_steps = 10_000\n",
-    "result_ws, param_gradients = compute_orbit_and_gradients(params,w0,dt,n_steps,usys)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "282a8abf-4795-46f8-8161-043a801b315d",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(Array([ 9.06855039e+00,  1.97839565e+02,  0.00000000e+00, -6.48383078e-03,\n",
-       "         1.95978592e-01,  0.00000000e+00], dtype=float64),\n",
-       " Array([3.92064633e-01, 3.16509740e-01, 0.00000000e+00, 4.15890756e-04,\n",
-       "        3.73949068e-04, 0.00000000e+00], dtype=float64))"
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "result_ws[-1,:], param_gradients['a']"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "7c4b684c-d64d-4105-9835-64978fdc9925",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array([ 9.16656655e+00,  1.97918693e+02,  0.00000000e+00, -6.37985809e-03,\n",
-       "        1.96072079e-01,  0.00000000e+00], dtype=float64)"
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "result_ws[-1,:] + param_gradients['a']*0.25"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "654e7974-c0a4-4a36-885d-eaaa630976f4",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array([ 9.16529728e+00,  1.97917817e+02,  0.00000000e+00, -6.38118505e-03,\n",
-       "        1.96071085e-01,  0.00000000e+00], dtype=float64)"
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Example parameter values\n",
-    "params = {'m': 1e10, 'a': 10.25}\n",
-    "result_ws, param_gradients = compute_orbit_and_gradients(params,w0,dt,n_steps,usys)\n",
-    "result_ws[-1]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "e7c60362-1b0a-4baa-88fa-ca0dc3778ff8",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/latex": [
-       "$101.69039 \\; \\mathrm{\\frac{km}{s}}$"
-      ],
-      "text/plain": [
-       "<Quantity 101.69039105 km / s>"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "(.104*u.kpc/u.Myr).to(u.km/u.s)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 28,
-   "id": "dd785998-8341-48be-87eb-c1155f89093e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "a_arr = jnp.linspace(10,11,30)\n",
-    "w0 = jnp.array([25., 0., 0, 0.01, .104, -0.004])\n",
-    "dt = 0.1\n",
-    "t0 = 0.\n",
-    "n_steps = 30_000\n",
-    "Delta_a = jnp.diff(a_arr)[0]\n",
-    "predicted_wf = jnp.zeros((len(a_arr),6))\n",
-    "true_wf = jnp.zeros((len(a_arr)-1,6))\n",
-    "for i in range(len(a_arr)):\n",
-    "    params = {'m': 5e11, 'a': a_arr[i]}\n",
-    "    result_ws, param_gradients = compute_orbit_and_gradients(params,w0,dt,n_steps,usys)\n",
-    "    pred = result_ws[-1] + param_gradients['a']*Delta_a \n",
-    "    predicted_wf = predicted_wf.at[i,:].set( pred )\n",
-    "    if i > 0:\n",
-    "        true_wf = true_wf.at[i-1,:].set(result_ws[-1])\n",
-    "    \n",
-    "    \n",
-    "\n",
-    "    \n",
-    "\n",
-    "    \n",
-    "    "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 29,
-   "id": "3170a98b-21ce-405f-b108-b1c4db75ad5a",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array(0.03448276, dtype=float64)"
-      ]
-     },
-     "execution_count": 29,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "Delta_a"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 85,
-   "id": "febdf9e0-eb4f-4788-a2ed-68273522ca4a",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(29, 6)"
-      ]
-     },
-     "execution_count": 85,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "true_wf.shape"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 128,
-   "id": "93d5a1d8-6dad-4dd1-8289-fba6cbae5c9c",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 792x504 with 7 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig, ax = plt.subplots(2,3)\n",
-    "ax_flat = ax.flatten()\n",
-    "fig.set_size_inches(11,7)\n",
-    "for dim in range(6):\n",
-    "    xx = np.linspace(true_wf[:,dim].min(),true_wf[:,dim].max(),50)\n",
-    "    ax_flat[dim].plot(xx,xx,color='k',ls='--',zorder=0)\n",
-    "\n",
-    "    ax_flat[dim].scatter(true_wf[:,dim], predicted_wf[:-1,dim],c=a_arr[1:],s=20,cmap=cmr.guppy)\n",
-    "    ax_flat[dim].set_aspect('equal')\n",
-    "fig.subplots_adjust(hspace=0.1,wspace=.35)\n",
-    "ax_flat[0].set_xlabel(r'True $x$ [kpc]',fontsize=15)\n",
-    "ax_flat[0].set_ylabel(r'Predicted $x$',fontsize=15)\n",
-    "\n",
-    "ax_flat[1].set_xlabel(r'True $y$ [kpc]',fontsize=15)\n",
-    "ax_flat[1].set_ylabel(r'Predicted $y$',fontsize=15)\n",
-    "\n",
-    "ax_flat[2].set_xlabel(r'True $z$ [kpc]',fontsize=15)\n",
-    "ax_flat[2].set_ylabel(r'Predicted $z$',fontsize=15)\n",
-    "\n",
-    "ax_flat[3].set_xlabel(r'True $v_x$ [kpc/Myr]',fontsize=15)\n",
-    "ax_flat[3].set_ylabel(r'Predicted $v_x$',fontsize=15)\n",
-    "\n",
-    "ax_flat[4].set_xlabel(r'True $v_y$ [kpc/Myr]',fontsize=15)\n",
-    "ax_flat[4].set_ylabel(r'Predicted $v_y$',fontsize=15)\n",
-    "\n",
-    "ax_flat[5].set_xlabel(r'True $v_z$ [kpc/Myr]',fontsize=15)\n",
-    "ax_flat[5].set_ylabel(r'Predicted $v_z$',fontsize=15)\n",
-    "\n",
-    "# Add a colorbar on the right of the subplots\n",
-    "cax = fig.add_axes([0.91, 0.14, 0.02, 0.73])  # Adjust the position and size of the colorbar\n",
-    "cbar = plt.colorbar(ax_flat[dim].scatter(true_wf[:,dim], predicted_wf[:-1,dim],c=a_arr[1:],s=20,cmap=cmr.guppy), cax=cax, orientation='vertical')\n",
-    "cbar.set_label('$\\Phi$ Scale Radius [kpc]',fontsize=20)  # Set the label for the colorbar\n",
-    "##plt.savefig('TaylorExpansion_PotentialFinalSnap.pdf',bbox_inches='tight')\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "a3bfa3f6-415a-4dee-b4fd-2ca019b53e3c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "mass_arr = 10**jnp.linspace(np.log10(1e11),np.log10(5e11),100)\n",
-    "w0 = jnp.array([25., 0., 0, 0.01, .104, -0.004])\n",
-    "dt = 0.05\n",
-    "t0 = 0\n",
-    "n_steps = 30_000\n",
-    "Delta_a = jnp.diff(mass_arr)[0]\n",
-    "predicted_wf = jnp.zeros((len(mass_arr),6))\n",
-    "true_wf = jnp.zeros((len(mass_arr)-1,6))\n",
-    "for i in range(len(mass_arr)):\n",
-    "    params = {'m': mass_arr[i], 'a': 10.}\n",
-    "    result_ws, param_gradients = compute_orbit_and_gradients(params,w0,dt,n_steps,usys)\n",
-    "    pred = result_ws[-1] + param_gradients['m']*Delta_a \n",
-    "    predicted_wf = predicted_wf.at[i,:].set( pred )\n",
-    "    if i > 0:\n",
-    "        true_wf = true_wf.at[i-1,:].set(result_ws[-1])\n",
-    "    \n",
-    "    \n",
-    "\n",
-    "    \n",
-    "\n",
-    "    \n",
-    "    "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "edcaf357-b4f3-4dcf-b1e8-346304260734",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 792x504 with 7 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig, ax = plt.subplots(2,3)\n",
-    "ax_flat = ax.flatten()\n",
-    "fig.set_size_inches(11,7)\n",
-    "for dim in range(6):\n",
-    "    xx = np.linspace(true_wf[:,dim].min(),true_wf[:,dim].max(),50)\n",
-    "    ax_flat[dim].plot(xx,xx,color='k',ls='--',zorder=0)\n",
-    "\n",
-    "    ax_flat[dim].scatter(true_wf[:,dim], predicted_wf[:-1,dim],c=np.log10(mass_arr[1:]),s=20,cmap=cmr.guppy)\n",
-    "    ax_flat[dim].set_aspect('equal')\n",
-    "fig.subplots_adjust(hspace=0.1,wspace=.45)\n",
-    "ax_flat[0].set_xlabel(r'True $x$ [kpc]',fontsize=15)\n",
-    "ax_flat[0].set_ylabel(r'Predicted $x$',fontsize=15)\n",
-    "\n",
-    "ax_flat[1].set_xlabel(r'True $y$ [kpc]',fontsize=15)\n",
-    "ax_flat[1].set_ylabel(r'Predicted $y$',fontsize=15)\n",
-    "\n",
-    "ax_flat[2].set_xlabel(r'True $z$ [kpc]',fontsize=15)\n",
-    "ax_flat[2].set_ylabel(r'Predicted $z$',fontsize=15)\n",
-    "\n",
-    "ax_flat[3].set_xlabel(r'True $v_x$ [kpc/Myr]',fontsize=15)\n",
-    "ax_flat[3].set_ylabel(r'Predicted $v_x$',fontsize=15)\n",
-    "\n",
-    "ax_flat[4].set_xlabel(r'True $v_y$ [kpc/Myr]',fontsize=15)\n",
-    "ax_flat[4].set_ylabel(r'Predicted $v_y$',fontsize=15)\n",
-    "\n",
-    "ax_flat[5].set_xlabel(r'True $v_z$ [kpc/Myr]',fontsize=15)\n",
-    "ax_flat[5].set_ylabel(r'Predicted $v_z$',fontsize=15)\n",
-    "\n",
-    "# Add a colorbar on the right of the subplots\n",
-    "cax = fig.add_axes([0.91, 0.14, 0.02, 0.73])  # Adjust the position and size of the colorbar\n",
-    "cbar = plt.colorbar(ax_flat[dim].scatter(true_wf[:,dim], predicted_wf[:-1,dim],c=np.log10(mass_arr[1:]),s=20,cmap=cmr.guppy), cax=cax, orientation='vertical')\n",
-    "cbar.set_label(r'$\\log_{10}\\left(M_{\\mathrm{Halo}} / M_{\\odot}\\right)$',fontsize=20)  # Set the label for the colorbar\n",
-    "###plt.savefig('TaylorExpansion_PotentialFinalSnap_MASS.pdf',bbox_inches='tight')\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 333,
-   "id": "40195f14-ad0b-45ae-aa14-7a7b55d2dbd3",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(9, 6)"
-      ]
-     },
-     "execution_count": 333,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "true_wf.shape"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 70,
-   "id": "6c913347-8f56-4324-9d52-3db62db062be",
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "AttributeError",
-     "evalue": "module 'jax.numpy' has no attribute 'concatonate'",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_8833/3291797012.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconcatonate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0morbs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/deprecations.py\u001b[0m in \u001b[0;36mgetattr\u001b[0;34m(name)\u001b[0m\n\u001b[1;32m     51\u001b[0m       \u001b[0mwarnings\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwarn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmessage\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mDeprecationWarning\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     52\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 53\u001b[0;31m     \u001b[0;32mraise\u001b[0m \u001b[0mAttributeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"module {module!r} has no attribute {name!r}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     54\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     55\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mgetattr\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mAttributeError\u001b[0m: module 'jax.numpy' has no attribute 'concatonate'"
-     ]
-    }
-   ],
-   "source": [
-    "jnp.concatonate(orbs)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "id": "7d8919f3-c3c1-4547-9f72-42d8d696ca90",
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "TypeError",
-     "evalue": "Gradient only defined for scalar-output functions. Output had shape: (3,).",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_8833/3838431128.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     46\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     47\u001b[0m \u001b[0;31m# Integrate multiple orbits\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 48\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mleapfrog_run\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mw0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpot\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgradient\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-      "    \u001b[0;31m[... skipping hidden 12 frame]\u001b[0m\n",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_8833/3838431128.py\u001b[0m in \u001b[0;36mleapfrog_run\u001b[0;34m(w0, ts, potential_gradient, args)\u001b[0m\n\u001b[1;32m     24\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0myf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maf\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0myf\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     25\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 26\u001b[0;31m     \u001b[0ma0\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfunc_\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mw0\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0mndim\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mts\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     27\u001b[0m     \u001b[0minit_carry\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mw0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mt0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ma0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     28\u001b[0m     \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mws\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscan\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mscan_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minit_carry\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mts\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_8833/3838431128.py\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(y, t)\u001b[0m\n\u001b[1;32m     17\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mleapfrog_run\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mw0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpotential_gradient\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     18\u001b[0m     \u001b[0mnum_orbits\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mndim\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mw0\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mw0\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m//\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 19\u001b[0;31m     \u001b[0mfunc_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mpotential_gradient\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     20\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     21\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mscan_fun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcarry\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "    \u001b[0;31m[... skipping hidden 12 frame]\u001b[0m\n",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_8833/3765345578.py\u001b[0m in \u001b[0;36mgradient\u001b[0;34m(self, xyz)\u001b[0m\n\u001b[1;32m     19\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mgradient\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mxyz\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     20\u001b[0m         \u001b[0mgrad_func\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgrad\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpotential\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 21\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mgrad_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mxyz\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     22\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     23\u001b[0m     \u001b[0;34m@\u001b[0m\u001b[0mpartial\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjit\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstatic_argnums\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "    \u001b[0;31m[... skipping hidden 4 frame]\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/api.py\u001b[0m in \u001b[0;36m_check_scalar\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m    757\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maval\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mShapedArray\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    758\u001b[0m       \u001b[0;32mif\u001b[0m \u001b[0maval\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 759\u001b[0;31m         \u001b[0;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmsg\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"had shape: {aval.shape}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    760\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    761\u001b[0m       \u001b[0;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmsg\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"had abstract value {aval}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mTypeError\u001b[0m: Gradient only defined for scalar-output functions. Output had shape: (3,)."
-     ]
-    }
-   ],
-   "source": [
-    "def leapfrog_step(func, y0, t0, dt, a0):\n",
-    "    num_orbits, ndim = y0.shape[0] // 2, y0.shape[1] // 2\n",
-    "    tf = t0 + dt\n",
-    "    \n",
-    "    x0 = y0[:, :ndim]\n",
-    "    v0 = y0[:, ndim:]\n",
-    "    \n",
-    "    v1_2 = v0 + a0 * dt / 2.0\n",
-    "    xf = x0 + v1_2 * dt\n",
-    "    af = -func(xf, tf)\n",
-    "    \n",
-    "    vf = v1_2 + af * dt / 2.0\n",
-    "    \n",
-    "    return tf, jnp.concatenate((xf, vf), axis=1), af\n",
-    "\n",
-    "@partial(jax.jit, static_argnames=['potential_gradient', 'args'])\n",
-    "def leapfrog_run(w0, ts, potential_gradient, args=()):\n",
-    "    num_orbits, ndim = w0.shape[0], w0.shape[1] // 2\n",
-    "    func_ = lambda y, t: potential_gradient(y, *args)\n",
-    "    \n",
-    "    def scan_fun(carry, t):\n",
-    "        i, y0, t0, dt, a0 = carry\n",
-    "        tf, yf, af = leapfrog_step(func_, y0, t0, dt, a0)\n",
-    "        return [i + 1, yf, tf, dt, af], yf\n",
-    "    \n",
-    "    a0 = func_(w0[:, :ndim], ts[0])\n",
-    "    init_carry = [0, w0, t0, dt, a0]\n",
-    "    _, ws = jax.lax.scan(scan_fun, init_carry, ts[1:])\n",
-    "    res_ws = jnp.concatenate((w0[:, None], ws), axis=1)\n",
-    "    \n",
-    "    return res_ws\n",
-    "\n",
-    "# Define initial conditions for multiple orbits (batched)\n",
-    "num_orbits = 5  # Number of orbits\n",
-    "ndim = 3  # Number of dimensions\n",
-    "\n",
-    "import jax.random as random \n",
-    "key = random.PRNGKey(0)  # Initialize a random key\n",
-    "w0 = random.uniform(key, (num_orbits, 2 * ndim))  # Generate random initial positions and velocities\n",
-    "\n",
-    "# Define time steps\n",
-    "t0 = 0.0\n",
-    "dt = 0.01\n",
-    "n_steps = 1000\n",
-    "ts = jnp.arange(t0, t0 + n_steps * dt, dt)\n",
-    "\n",
-    "# Integrate multiple orbits\n",
-    "result = leapfrog_run(w0, ts, pot.gradient)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 42,
-   "id": "931c6553-e930-4c1f-95d5-3aa4aa7ce0e2",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import jax.random as random \n",
-    "key = random.PRNGKey(0)  # Initialize a random key\n",
-    "w0 = random.uniform(key, (num_orbits, 2 * ndim))  # Generate random initial positions and velocities\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 34,
-   "id": "61de4d00-a936-44ab-96aa-9c50bf4c464e",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(5, 6)"
-      ]
-     },
-     "execution_count": 34,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "w0.shape"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "78a349a8-2da8-498e-b4b9-c41f6a31237d",
-   "metadata": {},
-   "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.8.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/docs/conf.py b/docs/conf.py
new file mode 100644
index 00000000..d6fc8bc8
--- /dev/null
+++ b/docs/conf.py
@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import importlib.metadata
+
+project = "galdynamix"
+copyright = "2023, Nathaniel Starkman"
+author = "Nathaniel Starkman"
+version = release = importlib.metadata.version("galdynamix")
+
+extensions = [
+    "myst_parser",
+    "sphinx.ext.autodoc",
+    "sphinx.ext.intersphinx",
+    "sphinx.ext.mathjax",
+    "sphinx.ext.napoleon",
+    "sphinx_autodoc_typehints",
+    "sphinx_copybutton",
+]
+
+source_suffix = [".rst", ".md"]
+exclude_patterns = [
+    "_build",
+    "**.ipynb_checkpoints",
+    "Thumbs.db",
+    ".DS_Store",
+    ".env",
+    ".venv",
+]
+
+html_theme = "furo"
+
+myst_enable_extensions = [
+    "colon_fence",
+]
+
+intersphinx_mapping = {
+    "python": ("https://docs.python.org/3", None),
+}
+
+nitpick_ignore = [
+    ("py:class", "_io.StringIO"),
+    ("py:class", "_io.BytesIO"),
+]
+
+always_document_param_types = True
diff --git a/docs/index.md b/docs/index.md
new file mode 100644
index 00000000..4be0aa88
--- /dev/null
+++ b/docs/index.md
@@ -0,0 +1,17 @@
+# galdynamix
+
+```{toctree}
+:maxdepth: 2
+:hidden:
+
+```
+
+```{include} ../README.md
+:start-after: <!-- SPHINX-START -->
+```
+
+## Indices and tables
+
+- {ref}`genindex`
+- {ref}`modindex`
+- {ref}`search`
diff --git a/jaxvgala_mockstream_Samemasses.pdf b/jaxvgala_mockstream_Samemasses.pdf
deleted file mode 100644
index f5f94f12..00000000
Binary files a/jaxvgala_mockstream_Samemasses.pdf and /dev/null differ
diff --git a/jaxvgala_mockstream_differingmasses.pdf b/jaxvgala_mockstream_differingmasses.pdf
deleted file mode 100644
index 2c17b125..00000000
Binary files a/jaxvgala_mockstream_differingmasses.pdf and /dev/null differ
diff --git a/noxfile.py b/noxfile.py
new file mode 100644
index 00000000..55da512d
--- /dev/null
+++ b/noxfile.py
@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+import argparse
+import shutil
+from pathlib import Path
+
+import nox
+
+DIR = Path(__file__).parent.resolve()
+
+nox.options.sessions = ["lint", "pylint", "tests"]
+
+
+@nox.session
+def lint(session: nox.Session) -> None:
+    """
+    Run the linter.
+    """
+    session.install("pre-commit")
+    session.run(
+        "pre-commit", "run", "--all-files", "--show-diff-on-failure", *session.posargs
+    )
+
+
+@nox.session
+def pylint(session: nox.Session) -> None:
+    """
+    Run PyLint.
+    """
+    # This needs to be installed into the package environment, and is slower
+    # than a pre-commit check
+    session.install(".", "pylint")
+    session.run("pylint", "galdynamix", *session.posargs)
+
+
+@nox.session
+def tests(session: nox.Session) -> None:
+    """
+    Run the unit and regular tests.
+    """
+    session.install(".[test]")
+    session.run("pytest", *session.posargs)
+
+
+@nox.session(reuse_venv=True)
+def docs(session: nox.Session) -> None:
+    """
+    Build the docs. Pass "--serve" to serve. Pass "-b linkcheck" to check links.
+    """
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--serve", action="store_true", help="Serve after building")
+    parser.add_argument(
+        "-b", dest="builder", default="html", help="Build target (default: html)"
+    )
+    args, posargs = parser.parse_known_args(session.posargs)
+
+    if args.builder != "html" and args.serve:
+        session.error("Must not specify non-HTML builder with --serve")
+
+    extra_installs = ["sphinx-autobuild"] if args.serve else []
+
+    session.install("-e.[docs]", *extra_installs)
+    session.chdir("docs")
+
+    if args.builder == "linkcheck":
+        session.run(
+            "sphinx-build", "-b", "linkcheck", ".", "_build/linkcheck", *posargs
+        )
+        return
+
+    shared_args = (
+        "-n",  # nitpicky mode
+        "-T",  # full tracebacks
+        f"-b={args.builder}",
+        ".",
+        f"_build/{args.builder}",
+        *posargs,
+    )
+
+    if args.serve:
+        session.run("sphinx-autobuild", *shared_args)
+    else:
+        session.run("sphinx-build", "--keep-going", *shared_args)
+
+
+@nox.session
+def build_api_docs(session: nox.Session) -> None:
+    """
+    Build (regenerate) API docs.
+    """
+
+    session.install("sphinx")
+    session.chdir("docs")
+    session.run(
+        "sphinx-apidoc",
+        "-o",
+        "api/",
+        "--module-first",
+        "--no-toc",
+        "--force",
+        "../src/galdynamix",
+    )
+
+
+@nox.session
+def build(session: nox.Session) -> None:
+    """
+    Build an SDist and wheel.
+    """
+
+    build_path = DIR.joinpath("build")
+    if build_path.exists():
+        shutil.rmtree(build_path)
+
+    session.install("build")
+    session.run("python", "-m", "build")
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 00000000..b4769630
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,171 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+
+[project]
+name = "galdynamix"
+authors = [
+  { name = "Nathaniel Starkman", email = "nstarman@users.noreply.github.com" },
+]
+description = "Galactic Dynamix in Jax"
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+  "Development Status :: 1 - Planning",
+  "Intended Audience :: Science/Research",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: BSD License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.8",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Scientific/Engineering",
+  "Typing :: Typed",
+]
+dynamic = ["version"]
+dependencies = [
+  "astropy >= 5.3",
+  "diffrax",
+  "equinox",
+  "gala >= 1.7",
+  "jax",
+  "jax_cosmo",
+  "typing_extensions",
+]
+
+[project.optional-dependencies]
+test = [
+  "pytest >=6",
+  "pytest-cov >=3",
+]
+dev = [
+  "pytest >=6",
+  "pytest-cov >=3",
+]
+docs = [
+  "sphinx>=7.0",
+  "myst_parser>=0.13",
+  "sphinx_copybutton",
+  "sphinx_autodoc_typehints",
+  "furo>=2023.08.17",
+]
+
+[project.urls]
+Homepage = "https://github.com/nstarman/galdynamix"
+"Bug Tracker" = "https://github.com/nstarman/galdynamix/issues"
+Discussions = "https://github.com/nstarman/galdynamix/discussions"
+Changelog = "https://github.com/nstarman/galdynamix/releases"
+
+
+[tool.hatch]
+version.source = "vcs"
+build.hooks.vcs.version-file = "src/galdynamix/_version.py"
+envs.default.dependencies = [
+  "pytest",
+  "pytest-cov",
+]
+
+
+[tool.pytest.ini_options]
+minversion = "6.0"
+addopts = ["-ra", "--showlocals", "--strict-markers", "--strict-config"]
+xfail_strict = true
+filterwarnings = [
+  "error",
+]
+log_cli_level = "INFO"
+testpaths = [
+  "tests",
+]
+
+
+[tool.coverage]
+run.source = ["galdynamix"]
+port.exclude_lines = [
+  'pragma: no cover',
+  '\.\.\.',
+  'if typing.TYPE_CHECKING:',
+]
+
+[tool.mypy]
+files = ["src", "tests"]
+python_version = "3.11"
+warn_unused_configs = true
+strict = true
+show_error_codes = true
+enable_error_code = ["ignore-without-code", "redundant-expr", "truthy-bool"]
+warn_unreachable = true
+disallow_untyped_defs = false
+disallow_incomplete_defs = false
+
+[[tool.mypy.overrides]]
+module = "galdynamix.*"
+disallow_untyped_defs = true
+disallow_incomplete_defs = true
+
+[[tool.mypy.overrides]]
+module = ["astropy.*", "diffrax.*", "equinox.*", "gala.*", "jax.*", "jax_cosmo.*"]
+ignore_missing_imports = true
+
+
+[tool.ruff]
+src = ["src"]
+
+[tool.ruff.lint]
+extend-select = [
+  "B",           # flake8-bugbear
+  "I",           # isort
+  "ARG",         # flake8-unused-arguments
+  "C4",          # flake8-comprehensions
+  "EM",          # flake8-errmsg
+  "ICN",         # flake8-import-conventions
+  "G",           # flake8-logging-format
+  "PGH",         # pygrep-hooks
+  "PIE",         # flake8-pie
+  "PL",          # pylint
+  "PT",          # flake8-pytest-style
+  "PTH",         # flake8-use-pathlib
+  "RET",         # flake8-return
+  "RUF",         # Ruff-specific
+  "SIM",         # flake8-simplify
+  "T20",         # flake8-print
+  "UP",          # pyupgrade
+  "YTT",         # flake8-2020
+  "EXE",         # flake8-executable
+  "NPY",         # NumPy specific rules
+  "PD",          # pandas-vet
+]
+ignore = [
+  "PLR",    # Design related pylint codes
+  # TODO! fix these
+  "ARG001",
+  "ARG002",
+  "F841",
+]
+isort.required-imports = ["from __future__ import annotations"]
+# Uncomment if using a _compat.typing backport
+# typing-modules = ["galdynamix._compat.typing"]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**" = ["T20"]
+"noxfile.py" = ["T20"]
+
+
+[tool.pylint]
+py-version = "3.8"
+ignore-paths = [".*/_version.py"]
+reports.output-format = "colorized"
+similarities.ignore-imports = "yes"
+messages_control.disable = [
+  "design",
+  "fixme",
+  "line-too-long",
+  "missing-module-docstring",
+  "wrong-import-position",
+]
diff --git a/sample_stream.pdf b/sample_stream.pdf
deleted file mode 100644
index 52af3f5c..00000000
Binary files a/sample_stream.pdf and /dev/null differ
diff --git a/src/galdynamix/__init__.py b/src/galdynamix/__init__.py
new file mode 100644
index 00000000..ca39e568
--- /dev/null
+++ b/src/galdynamix/__init__.py
@@ -0,0 +1,10 @@
+"""galdynamix: Galactic Dynamix in Jax"""
+from __future__ import annotations
+
+__all__ = ["__version__"]
+
+from jax.config import config
+
+from ._version import version as __version__
+
+config.update("jax_enable_x64", True)
diff --git a/src/galdynamix/_version.pyi b/src/galdynamix/_version.pyi
new file mode 100644
index 00000000..91744f98
--- /dev/null
+++ b/src/galdynamix/_version.pyi
@@ -0,0 +1,4 @@
+from __future__ import annotations
+
+version: str
+version_tuple: tuple[int, int, int] | tuple[int, int, int, str, str]
diff --git a/src/galdynamix/dynamics/__init__.py b/src/galdynamix/dynamics/__init__.py
new file mode 100644
index 00000000..ee82316e
--- /dev/null
+++ b/src/galdynamix/dynamics/__init__.py
@@ -0,0 +1,10 @@
+"""galdynamix: Galactic Dynamix in Jax"""
+# ruff: noqa: F403
+
+from __future__ import annotations
+
+from . import mockstream
+from .mockstream import *
+
+__all__: list[str] = []
+__all__ += mockstream.__all__
diff --git a/src/galdynamix/dynamics/mockstream/__init__.py b/src/galdynamix/dynamics/mockstream/__init__.py
new file mode 100644
index 00000000..554c7e41
--- /dev/null
+++ b/src/galdynamix/dynamics/mockstream/__init__.py
@@ -0,0 +1,12 @@
+"""galdynamix: Galactic Dynamix in Jax"""
+# ruff: noqa: F403
+
+from __future__ import annotations
+
+from . import _df, _mockstream
+from ._df import *
+from ._mockstream import *
+
+__all__: list[str] = []
+__all__ += _df.__all__
+__all__ += _mockstream.__all__
diff --git a/src/galdynamix/dynamics/mockstream/_df.py b/src/galdynamix/dynamics/mockstream/_df.py
new file mode 100644
index 00000000..05f717d7
--- /dev/null
+++ b/src/galdynamix/dynamics/mockstream/_df.py
@@ -0,0 +1,241 @@
+"""galdynamix: Galactic Dynamix in Jax"""
+# ruff: noqa: F403
+
+from __future__ import annotations
+
+__all__ = ["BaseStreamDF", "FardalStreamDF"]
+
+import abc
+
+import equinox as eqx
+import jax
+import jax.numpy as xp
+import jax.typing as jt
+
+from galdynamix.potential._potential.base import PotentialBase
+from galdynamix.utils import jit_method
+
+
+class BaseStreamDF(eqx.Module):
+    lead: bool = eqx.field(default=True, static=True)
+    trail: bool = eqx.field(default=True, static=True)
+
+    def __post_init__(self) -> None:
+        if not self.lead and not self.trail:
+            msg = "You must generate either leading or trailing tails (or both!)"
+            raise ValueError(msg)
+
+    @abc.abstractmethod
+    def sample(
+        self,
+        potential: PotentialBase,
+        x: jt.Array,
+        v: jt.Array,
+        prog_mass: jt.Array,
+        i: int,
+        t: jt.Array,
+        *,
+        seed_num: int,
+    ) -> tuple[jt.Array, jt.Array, jt.Array, jt.Array]:
+        """Sample the DF."""
+        raise NotImplementedError
+
+
+# ==========================================================================
+
+
+class FardalStreamDF(BaseStreamDF):
+    @jit_method(static_argnames=("seed_num",))
+    def sample(
+        self,
+        potential: PotentialBase,
+        x: jt.Array,
+        v: jt.Array,
+        prog_mass: jt.Array,
+        i: int,
+        t: jt.Array,
+        *,
+        seed_num: int,
+    ) -> tuple[jt.Array, jt.Array, jt.Array, jt.Array]:
+        """
+        Simplification of particle spray: just release particles in gaussian blob at each lagrange point.
+        User sets the spatial and velocity dispersion for the "leaking" of particles
+        TODO: change random key handling... need to do all of the sampling up front...
+        """
+        key_master = jax.random.PRNGKey(seed_num)
+        random_ints = jax.random.randint(
+            key=key_master, shape=(5,), minval=0, maxval=1000
+        )
+
+        keya = jax.random.PRNGKey(i * random_ints[0])  # jax.random.PRNGKey(i*13)
+        keyb = jax.random.PRNGKey(i * random_ints[1])  # jax.random.PRNGKey(i*23)
+
+        keyc = jax.random.PRNGKey(i * random_ints[2])  # jax.random.PRNGKey(i*27)
+        keyd = jax.random.PRNGKey(i * random_ints[3])  # jax.random.PRNGKey(i*3)
+        keye = jax.random.PRNGKey(i * random_ints[4])  # jax.random.PRNGKey(i*17)
+
+        # each is an xyz array
+        L_close, L_far = self._lagrange_pts(potential, x, v, prog_mass, t)
+
+        omega_val = self._omega(x, v)
+
+        r = xp.linalg.norm(x)
+        r_hat = x / r
+        r_tidal = self._tidalr_mw(potential, x, v, prog_mass, t)
+        rel_v = omega_val * r_tidal  # relative velocity
+
+        # circlar_velocity
+        dphi_dr = xp.sum(potential.gradient(x, t) * r_hat)
+        v_circ = rel_v  ##xp.sqrt( r*dphi_dr )
+
+        L_vec = xp.cross(x, v)
+        z_hat = L_vec / xp.linalg.norm(L_vec)
+
+        phi_vec = v - xp.sum(v * r_hat) * r_hat
+        phi_hat = phi_vec / xp.linalg.norm(phi_vec)
+        vt_sat = xp.sum(v * phi_hat)
+
+        kr_bar = 2.0
+        kvphi_bar = 0.3
+        ####################kvt_bar = 0.3 ## FROM GALA
+
+        kz_bar = 0.0
+        kvz_bar = 0.0
+
+        sigma_kr = 0.5
+        sigma_kvphi = 0.5
+        sigma_kz = 0.5
+        sigma_kvz = 0.5
+        ##############sigma_kvt = 0.5 ##FROM GALA
+
+        kr_samp = kr_bar + jax.random.normal(keya, shape=(1,)) * sigma_kr
+        kvphi_samp = kr_samp * (
+            kvphi_bar + jax.random.normal(keyb, shape=(1,)) * sigma_kvphi
+        )
+        kz_samp = kz_bar + jax.random.normal(keyc, shape=(1,)) * sigma_kz
+        kvz_samp = kvz_bar + jax.random.normal(keyd, shape=(1,)) * sigma_kvz
+        ########kvt_samp = kvt_bar + jax.random.normal(keye,shape=(1,))*sigma_kvt
+
+        ## Trailing arm
+        pos_trail = x + kr_samp * r_hat * (r_tidal)  # nudge out
+        pos_trail = pos_trail + z_hat * kz_samp * (
+            r_tidal / 1.0
+        )  # r #nudge above/below orbital plane
+        v_trail = (
+            v + (0.0 + kvphi_samp * v_circ * (1.0)) * phi_hat
+        )  # v + (0.0 + kvphi_samp*v_circ*(-r_tidal/r))*phi_hat #nudge velocity along tangential direction
+        v_trail = (
+            v_trail + (kvz_samp * v_circ * (1.0)) * z_hat
+        )  # v_trail + (kvz_samp*v_circ*(-r_tidal/r))*z_hat #nudge velocity along vertical direction
+
+        ## Leading arm
+        pos_lead = x + kr_samp * r_hat * (-r_tidal)  # nudge in
+        pos_lead = pos_lead + z_hat * kz_samp * (
+            -r_tidal / 1.0
+        )  # r #nudge above/below orbital plane
+        v_lead = (
+            v + (0.0 + kvphi_samp * v_circ * (-1.0)) * phi_hat
+        )  # v + (0.0 + kvphi_samp*v_circ*(r_tidal/r))*phi_hat #nudge velocity along tangential direction
+        v_lead = (
+            v_lead + (kvz_samp * v_circ * (-1.0)) * z_hat
+        )  # v_lead + (kvz_samp*v_circ*(r_tidal/r))*z_hat #nudge velocity against vertical direction
+
+        return pos_lead, pos_trail, v_lead, v_trail
+
+    @jit_method()
+    def _lagrange_pts(
+        self,
+        potential: PotentialBase,
+        x: jt.Array,
+        v: jt.Array,
+        Msat: jt.Array,
+        t: jt.Array,
+    ) -> tuple[jt.Array, jt.Array]:
+        r_tidal = self._tidalr_mw(potential, x, v, Msat, t)
+        r_hat = x / xp.linalg.norm(x)
+        L_close = x - r_hat * r_tidal
+        L_far = x + r_hat * r_tidal
+        return L_close, L_far
+
+    @jit_method()
+    def _d2phidr2_mw(
+        self, potential: PotentialBase, x: jt.Array, /, t: jt.Array
+    ) -> jt.Array:
+        """
+        Computes the second derivative of the potential at a position x (in the simulation frame)
+
+        Parameters
+        ----------
+          x: 3d position (x, y, z) in [kpc]
+
+        Returns
+        -------
+        Array:
+          Second derivative of force (per unit mass) in [1/Myr^2]
+
+        Examples
+        --------
+        >>> _d2phidr2_mw(x=xp.array([8.0, 0.0, 0.0]))
+        """
+        rad = xp.linalg.norm(x)
+        r_hat = x / rad
+        dphi_dr_func = lambda x: xp.sum(potential.gradient(x, t) * r_hat)  # noqa: E731
+        return xp.sum(jax.grad(dphi_dr_func)(x) * r_hat)
+
+    @jit_method()
+    def _omega(self, x: jt.Array, v: jt.Array) -> jt.Array:
+        """
+        Computes the magnitude of the angular momentum in the simulation frame
+
+        Arguments
+        ---------
+        Array
+            3d position (x, y, z) in [kpc]
+        Array
+            3d velocity (v_x, v_y, v_z) in [kpc/Myr]
+
+        Returns
+        -------
+        Array
+            Magnitude of angular momentum in [rad/Myr]
+
+        Examples
+        --------
+        >>> _omega(x=xp.array([8.0, 0.0, 0.0]), v=xp.array([8.0, 0.0, 0.0]))
+        """
+        rad = xp.sqrt(x[0] ** 2 + x[1] ** 2 + x[2] ** 2)
+        omega_vec = xp.cross(x, v) / (rad**2)
+        return xp.linalg.norm(omega_vec)
+
+    @jit_method()
+    def _tidalr_mw(
+        self,
+        potential: PotentialBase,
+        x: jt.Array,
+        v: jt.Array,
+        /,
+        Msat: jt.Array,
+        t: jt.Array,
+    ) -> jt.Array:
+        """Computes the tidal radius of a cluster in the potential.
+
+        Parameters
+        ----------
+          x: 3d position (x, y, z) in [kpc]
+          v: 3d velocity (v_x, v_y, v_z) in [kpc/Myr]
+          Msat: Cluster mass in [Msol]
+
+        Returns
+        -------
+        Array:
+          Tidal radius of the cluster in [kpc]
+
+        Examples
+        --------
+        >>> _tidalr_mw(x=xp.array([8.0, 0.0, 0.0]), v=xp.array([8.0, 0.0, 0.0]), Msat=1e4)
+        """
+        return (
+            potential._G
+            * Msat
+            / (self._omega(x, v) ** 2 - self._d2phidr2_mw(potential, x, t))
+        ) ** (1.0 / 3.0)
diff --git a/src/galdynamix/dynamics/mockstream/_mockstream.py b/src/galdynamix/dynamics/mockstream/_mockstream.py
new file mode 100644
index 00000000..6ad329b5
--- /dev/null
+++ b/src/galdynamix/dynamics/mockstream/_mockstream.py
@@ -0,0 +1,167 @@
+"""galdynamix: Galactic Dynamix in Jax"""
+# ruff: noqa: F403
+
+from __future__ import annotations
+
+__all__ = ["MockStreamGenerator"]
+
+from typing import Any
+
+import equinox as eqx
+import jax
+import jax.numpy as xp
+import jax.typing as jt
+
+from galdynamix.potential._potential.base import PotentialBase
+from galdynamix.utils import jit_method
+
+from ._df import BaseStreamDF
+
+
+class MockStreamGenerator(eqx.Module):
+    df: BaseStreamDF
+    potential: PotentialBase
+    progenitor_potential: PotentialBase | None = None
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "self_gravity", self.progenitor_potential is not None)
+
+    # ==========================================================================
+
+    @jit_method(static_argnames=("seed_num",))
+    def _gen_stream_ics(
+        self, ts: jt.Array, prog_w0: jt.Array, prog_mass: jt.Array, *, seed_num: int
+    ) -> jt.Array:
+        ws_jax = self.potential.integrate_orbit(
+            prog_w0, t0=xp.min(ts), t1=xp.max(ts), ts=ts
+        )
+
+        def scan_fun(carry: Any, t: Any) -> Any:
+            i, pos_close, pos_far, vel_close, vel_far = carry
+            sample_outputs = self.df.sample(
+                self.potential,
+                ws_jax[i, :3],
+                ws_jax[i, 3:],
+                prog_mass,
+                i,
+                t,
+                seed_num=seed_num,
+            )
+            return [i + 1, *sample_outputs], list(sample_outputs)
+
+        init_carry = [
+            0,
+            xp.array([0.0, 0.0, 0.0]),
+            xp.array([0.0, 0.0, 0.0]),
+            xp.array([0.0, 0.0, 0.0]),
+            xp.array([0.0, 0.0, 0.0]),
+        ]
+        # final_state, all_states = jax.lax.scan(scan_fun, init_carry, ts[1:])
+        # pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr = all_states
+        return jax.lax.scan(scan_fun, init_carry, ts[1:])[1]
+
+    @jit_method(static_argnames=("seed_num",))
+    def _run_scan(
+        self, ts: jt.Array, prog_w0: jt.Array, prog_mass: jt.Array, *, seed_num: int
+    ) -> tuple[jt.Array, jt.Array]:
+        """
+        Generate stellar stream by scanning over the release model/integration. Better for CPU usage.
+        """
+        pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr = self._gen_stream_ics(
+            ts, prog_w0, prog_mass, seed_num=seed_num
+        )
+
+        @jax.jit  # type: ignore[misc]
+        def scan_fun(carry: Any, particle_idx: Any) -> Any:
+            i, pos_close_curr, pos_far_curr, vel_close_curr, vel_far_curr = carry
+            curr_particle_w0_close = xp.hstack([pos_close_curr, vel_close_curr])
+            curr_particle_w0_far = xp.hstack([pos_far_curr, vel_far_curr])
+            w0_lead_trail = xp.vstack([curr_particle_w0_close, curr_particle_w0_far])
+
+            minval, maxval = ts[i], ts[-1]
+
+            def integrate_different_ics(ics: jt.Array) -> jt.Array:
+                return self.potential.integrate_orbit(ics, minval, maxval, None)[0]
+
+            w_particle_close, w_particle_far = jax.vmap(
+                integrate_different_ics, in_axes=(0,)
+            )(
+                w0_lead_trail
+            )  # vmap over leading and trailing arm
+
+            return [
+                i + 1,
+                pos_close_arr[i + 1, :],
+                pos_far_arr[i + 1, :],
+                vel_close_arr[i + 1, :],
+                vel_far_arr[i + 1, :],
+            ], [w_particle_close, w_particle_far]
+
+        init_carry = [
+            0,
+            pos_close_arr[0, :],
+            pos_far_arr[0, :],
+            vel_close_arr[0, :],
+            vel_far_arr[0, :],
+        ]
+        particle_ids = xp.arange(len(pos_close_arr))
+        final_state, all_states = jax.lax.scan(scan_fun, init_carry, particle_ids)
+        lead_arm, trail_arm = all_states
+        return lead_arm, trail_arm
+
+    @jit_method(static_argnames=("seed_num",))
+    def _run_vmap(
+        self, ts: jt.Array, prog_w0: jt.Array, prog_mass: jt.Array, *, seed_num: int
+    ) -> tuple[jt.Array, jt.Array]:
+        """
+        Generate stellar stream by vmapping over the release model/integration. Better for GPU usage.
+        """
+        pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr = self._gen_stream_ics(
+            ts, prog_w0, prog_mass, seed_num
+        )
+
+        @jax.jit  # type: ignore[misc]
+        def single_particle_integrate(
+            particle_number: int,
+            pos_close_curr: jt.Array,
+            pos_far_curr: jt.Array,
+            vel_close_curr: jt.Array,
+            vel_far_curr: jt.Array,
+        ) -> tuple[jt.Array, jt.Array]:
+            curr_particle_w0_close = xp.hstack([pos_close_curr, vel_close_curr])
+            curr_particle_w0_far = xp.hstack([pos_far_curr, vel_far_curr])
+            t_release = ts[particle_number]
+            t_final = ts[-1] + 0.01
+
+            w_particle_close = self.integrate_orbit(
+                curr_particle_w0_close, t_release, t_final, None
+            )[0]
+            w_particle_far = self.integrate_orbit(
+                curr_particle_w0_far, t_release, t_final, None
+            )[0]
+
+            return w_particle_close, w_particle_far
+
+        particle_ids = xp.arange(len(pos_close_arr))
+
+        return jax.vmap(
+            single_particle_integrate,
+            in_axes=(0, 0, 0, 0, 0),
+        )(particle_ids, pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr)
+
+    @jit_method(static_argnames=("seed_num", "vmapped"))
+    def run(
+        self,
+        ts: jt.Array,
+        prog_w0: jt.Array,
+        prog_mass: jt.Array,
+        *,
+        seed_num: int,
+        vmapped: bool = False,
+    ) -> tuple[jt.Array, jt.Array]:
+        if vmapped:
+            return self._run_vmap(ts, prog_w0, prog_mass, seed_num=seed_num)
+        else:
+            return self._run_scan(ts, prog_w0, prog_mass, seed_num=seed_num)
+
+    # ==========================================================================
diff --git a/src/galdynamix/integrate/__init__.py b/src/galdynamix/integrate/__init__.py
new file mode 100644
index 00000000..6878ebbd
--- /dev/null
+++ b/src/galdynamix/integrate/__init__.py
@@ -0,0 +1,12 @@
+"""galdynamix: Galactic Dynamix in Jax"""
+# ruff: noqa: F403
+
+from __future__ import annotations
+
+from galdynamix.integrate import _base, _builtin
+from galdynamix.integrate._base import *
+from galdynamix.integrate._builtin import *
+
+__all__: list[str] = []
+__all__ += _base.__all__
+__all__ += _builtin.__all__
diff --git a/src/galdynamix/integrate/_base.py b/src/galdynamix/integrate/_base.py
new file mode 100644
index 00000000..ec5d89c4
--- /dev/null
+++ b/src/galdynamix/integrate/_base.py
@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+__all__ = ["Integrator"]
+
+import abc
+from typing import Any, Protocol
+
+import equinox as eqx
+import jax.typing as jt
+
+
+class FCallable(Protocol):
+    def __call__(self, t: jt.Array, xv: jt.Array, args: Any) -> jt.Array:
+        ...
+
+
+class Integrator(eqx.Module):  # type: ignore[misc]
+    F: FCallable
+
+    @abc.abstractmethod
+    def run(
+        self, w0: jt.Array, t0: jt.Array, t1: jt.Array, ts: jt.Array | None
+    ) -> jt.Array:
+        ...
diff --git a/src/galdynamix/integrate/_builtin.py b/src/galdynamix/integrate/_builtin.py
new file mode 100644
index 00000000..ab6dcf51
--- /dev/null
+++ b/src/galdynamix/integrate/_builtin.py
@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+__all__ = ["DiffraxIntegrator"]
+
+from dataclasses import KW_ONLY
+
+import equinox as eqx
+import jax.typing as jt
+from diffrax import (
+    AbstractSolver,
+    AbstractStepSizeController,
+    Dopri5,
+    ODETerm,
+    PIDController,
+    diffeqsolve,
+)
+from diffrax import SaveAt as DiffraxSaveAt
+
+from galdynamix.integrate._base import Integrator
+
+
+class DiffraxIntegrator(Integrator):
+    _: KW_ONLY
+    Solver: AbstractSolver = eqx.field(default=Dopri5, static=True)
+    SaveAt: DiffraxSaveAt = eqx.field(default=DiffraxSaveAt, static=True)
+    stepsize_controller: AbstractStepSizeController = eqx.field(
+        default=PIDController(rtol=1e-7, atol=1e-7), static=True
+    )
+
+    def run(
+        self, w0: jt.Array, t0: jt.Array, t1: jt.Array, ts: jt.Array | None
+    ) -> jt.Array:
+        solution = diffeqsolve(
+            terms=ODETerm(self.F),
+            solver=self.Solver(),
+            t0=t0,
+            t1=t1,
+            y0=w0,
+            dt0=None,
+            saveat=self.SaveAt(t0=False, t1=True, ts=ts, dense=False),
+            stepsize_controller=self.stepsize_controller,
+            discrete_terminating_event=None,
+            max_steps=None,
+        )
+        return solution.ys
diff --git a/src/galdynamix/potential/__init__.py b/src/galdynamix/potential/__init__.py
new file mode 100644
index 00000000..2ecdc19e
--- /dev/null
+++ b/src/galdynamix/potential/__init__.py
@@ -0,0 +1,10 @@
+"""galdynamix: Galactic Dynamix in Jax"""
+# ruff: noqa: F403
+
+from __future__ import annotations
+
+from . import _potential
+from ._potential import *
+
+__all__: list[str] = []
+__all__ += _potential.__all__
diff --git a/src/galdynamix/potential/_potential/__init__.py b/src/galdynamix/potential/_potential/__init__.py
new file mode 100644
index 00000000..ae97f890
--- /dev/null
+++ b/src/galdynamix/potential/_potential/__init__.py
@@ -0,0 +1,14 @@
+"""galdynamix: Galactic Dynamix in Jax"""
+# ruff: noqa: F403
+
+from __future__ import annotations
+
+from . import base, builtin, composite
+from .base import *
+from .builtin import *
+from .composite import *
+
+__all__: list[str] = []
+__all__ += base.__all__
+__all__ += composite.__all__
+__all__ += builtin.__all__
diff --git a/src/galdynamix/potential/_potential/base.py b/src/galdynamix/potential/_potential/base.py
new file mode 100644
index 00000000..e630371e
--- /dev/null
+++ b/src/galdynamix/potential/_potential/base.py
@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+__all__ = ["PotentialBase"]
+
+import abc
+from dataclasses import KW_ONLY, fields
+from typing import Any
+
+import equinox as eqx
+import jax
+import jax.numpy as xp
+import jax.typing as jt
+from astropy.constants import G as apy_G
+from gala.units import UnitSystem, dimensionless
+
+from galdynamix.utils import jit_method
+
+
+class PotentialBase(eqx.Module):  # type: ignore[misc]
+    """Potential Class."""
+
+    _: KW_ONLY
+    units: UnitSystem = eqx.field(default=None, static=True)
+    _G: float = eqx.field(init=False, static=True)
+
+    def __post_init__(self) -> None:
+        units = dimensionless if self.units is None else self.units
+        object.__setattr__(self, "units", UnitSystem(units))
+
+        G = 1 if self.units == dimensionless else apy_G.decompose(self.units).value
+        object.__setattr__(self, "_G", G)
+
+        for f in fields(self):
+            param = getattr(self, f.name)
+            if hasattr(param, "unit"):
+                param = xp.asarray(param.decompose(self.units).value)
+                object.__setattr__(self, f.name, param)
+
+    ###########################################################################
+    # Abstract methods that must be implemented by subclasses
+
+    @abc.abstractmethod
+    def energy(self, q: jt.Array, /, t: jt.Array) -> jt.Array:
+        """Compute the potential energy at the given position(s)."""
+        raise NotImplementedError
+
+    ###########################################################################
+    # Core methods that use the above implemented functions
+
+    @jit_method()
+    def gradient(self, q: jt.Array, /, t: jt.Array) -> jt.Array:
+        """Compute the gradient."""
+        return jax.grad(self.energy)(q, t)
+
+    @jit_method()
+    def density(self, q: jt.Array, /, t: jt.Array) -> jt.Array:
+        lap = xp.trace(jax.hessian(self.energy)(q, t))
+        return lap / (4 * xp.pi * self._G)
+
+    @jit_method()
+    def hessian(self, q: jt.Array, /, t: jt.Array) -> jt.Array:
+        return jax.hessian(self.energy)(q, t)
+
+    @jit_method()
+    def acceleration(self, q: jt.Array, /, t: jt.Array) -> jt.Array:
+        return -self.gradient(q, t)
+
+    ###########################################################################
+
+    @jit_method()
+    def _vel_acc(self, t: jt.Array, xv: jt.Array, args: Any) -> jt.Array:
+        return xp.hstack([xv[3:], -self.gradient(xv[:3], t)])
+
+    @jit_method()
+    def integrate_orbit(
+        self, w0: jt.Array, t0: jt.Array, t1: jt.Array, ts: jt.Array | None
+    ) -> jt.Array:
+        from galdynamix.integrate._builtin.diffrax import (
+            DiffraxIntegrator as Integrator,
+        )
+
+        return Integrator(self._vel_acc).run(w0, t0, t1, ts)
diff --git a/src/galdynamix/potential/_potential/builtin/__init__.py b/src/galdynamix/potential/_potential/builtin/__init__.py
new file mode 100644
index 00000000..e2b0ca54
--- /dev/null
+++ b/src/galdynamix/potential/_potential/builtin/__init__.py
@@ -0,0 +1,18 @@
+"""galdynamix: Galactic Dynamix in Jax"""
+# ruff: noqa: F403
+
+from __future__ import annotations
+
+from . import bar, isochrone, miyamoto_nagai, nfw, subhalos
+from .bar import *
+from .isochrone import *
+from .miyamoto_nagai import *
+from .nfw import *
+from .subhalos import *
+
+__all__: list[str] = []
+__all__ += bar.__all__
+__all__ += isochrone.__all__
+__all__ += miyamoto_nagai.__all__
+__all__ += nfw.__all__
+__all__ += subhalos.__all__
diff --git a/src/galdynamix/potential/_potential/builtin/bar.py b/src/galdynamix/potential/_potential/builtin/bar.py
new file mode 100644
index 00000000..2753b86e
--- /dev/null
+++ b/src/galdynamix/potential/_potential/builtin/bar.py
@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+__all__ = ["BarPotential"]
+
+import jax.numpy as xp
+import jax.typing as jt
+
+from galdynamix.potential._potential.base import PotentialBase
+from galdynamix.utils import jit_method
+
+
+class BarPotential(PotentialBase):
+    """
+    Rotating bar potentil, with hard-coded rotation.
+    Eq 8a in https://articles.adsabs.harvard.edu/pdf/1992ApJ...397...44L
+    Rz according to https://en.wikipedia.org/wiki/Rotation_matrix
+    """
+
+    m: jt.Array
+    a: jt.Array
+    b: jt.Array
+    c: jt.Array
+    Omega: jt.Array
+
+    @jit_method()
+    def energy(self, q: jt.Array, /, t: jt.Array) -> jt.Array:
+        ## First take the simulation frame coordinates and rotate them by Omega*t
+        ang = -self.Omega * t
+        Rot_mat = xp.array(
+            [
+                [xp.cos(ang), -xp.sin(ang), 0],
+                [xp.sin(ang), xp.cos(ang), 0.0],
+                [0.0, 0.0, 1.0],
+            ]
+        )
+        # Rot_inv = xp.linalg.inv(Rot_mat)
+        q_corot = xp.matmul(Rot_mat, q)
+
+        T_plus = xp.sqrt(
+            (self.a + q_corot[0]) ** 2
+            + q_corot[1] ** 2
+            + (self.b + xp.sqrt(self.c**2 + q_corot[2] ** 2)) ** 2
+        )
+        T_minus = xp.sqrt(
+            (self.a - q_corot[0]) ** 2
+            + q_corot[1] ** 2
+            + (self.b + xp.sqrt(self.c**2 + q_corot[2] ** 2)) ** 2
+        )
+
+        # potential in a corotating frame
+        return (self._G * self.m / (2.0 * self.a)) * xp.log(
+            (q_corot[0] - self.a + T_minus) / (q_corot[0] + self.a + T_plus)
+        )
diff --git a/src/galdynamix/potential/_potential/builtin/isochrone.py b/src/galdynamix/potential/_potential/builtin/isochrone.py
new file mode 100644
index 00000000..ad049126
--- /dev/null
+++ b/src/galdynamix/potential/_potential/builtin/isochrone.py
@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+__all__ = ["Isochrone", "Isochrone_centered"]
+
+from typing import Any, Callable
+
+import jax
+import jax.numpy as xp
+import jax.typing as jt
+
+from galdynamix.potential._potential.base import PotentialBase
+from galdynamix.utils import jit_method
+
+
+class Isochrone(PotentialBase):
+    m: jt.Array
+    a: jt.Array
+
+    @jit_method()
+    def energy(self, q: jt.Array, /, t: jt.Array) -> jt.Array:
+        r = xp.linalg.norm(q, axis=0)
+        return -self._G * self.m / (self.a + xp.sqrt(r**2 + self.a**2))
+
+
+class Isochrone_centered(PotentialBase):
+    m: jt.Array
+    a: jt.Array
+    spline_eval_func: Callable[[jt.Array, Any], jt.Array]
+    splines: Any
+    t_min: jt.Array
+    t_max: jt.Array
+    m_ext: jt.Array
+    a_ext: jt.Array
+
+    @jit_method()
+    def energy(self, q: jt.Array, /, t: jt.Array) -> jt.Array:
+        is_cond_met = (t > self.t_min) & (t < self.t_max)  # True if yes, False if no
+        pot_ext = Isochrone(m=self.m_ext, a=self.a_ext, units=self.units)
+
+        def true_func(q_t: jt.Array) -> jt.Array:
+            q_, t = q_t[:3], q_t[-1]
+            q = q_ - self.spline_eval_func(t, self.splines)
+            r = xp.linalg.norm(q, axis=0)
+            return -self._G * self.m / (
+                self.a + xp.sqrt(r**2 + self.a**2)
+            ) + pot_ext.energy(
+                q_, t
+            )  # + self.pot_ext.energy(q_,t)
+
+        def false_func(q_t: jt.Array) -> jt.Array:
+            q, t = q_t[:3], q_t[-1]
+            return pot_ext.energy(q, t)  # 0.#self.pot_ext.energy(q,t)
+
+        q_t = xp.hstack([q, t])
+        return jax.lax.cond(
+            pred=is_cond_met, true_fun=true_func, false_fun=false_func, operand=q_t
+        )
diff --git a/src/galdynamix/potential/_potential/builtin/miyamoto_nagai.py b/src/galdynamix/potential/_potential/builtin/miyamoto_nagai.py
new file mode 100644
index 00000000..6cae79f1
--- /dev/null
+++ b/src/galdynamix/potential/_potential/builtin/miyamoto_nagai.py
@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+__all__ = ["MiyamotoNagaiDisk"]
+
+
+import jax.numpy as xp
+import jax.typing as jt
+
+from galdynamix.potential._potential.base import PotentialBase
+from galdynamix.utils import jit_method
+
+
+class MiyamotoNagaiDisk(PotentialBase):
+    m: jt.Array
+    a: jt.Array
+    b: jt.Array
+
+    @jit_method()
+    def energy(self, q: jt.Array, /, t: jt.Array) -> jt.Array:
+        R2 = q[0] ** 2 + q[1] ** 2
+        return (
+            -self._G
+            * self.m
+            / xp.sqrt(R2 + xp.square(xp.sqrt(q[2] ** 2 + self.b**2) + self.a))
+        )
diff --git a/src/galdynamix/potential/_potential/builtin/nfw.py b/src/galdynamix/potential/_potential/builtin/nfw.py
new file mode 100644
index 00000000..c9b635bc
--- /dev/null
+++ b/src/galdynamix/potential/_potential/builtin/nfw.py
@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+__all__ = ["NFWPotential", "NFWPotential_holder"]
+
+
+import jax.numpy as xp
+import jax.typing as jt
+
+from galdynamix.potential._potential.base import PotentialBase
+from galdynamix.utils import jit_method
+
+
+class NFWPotential_holder(PotentialBase):
+    """
+    Flattening in potential, not density
+    Form from http://gala.adrian.pw/en/v0.1.2/api/gala.potential.FlattenedNFWPotential.html
+    """
+
+    v_c: jt.Array
+    r_s: jt.Array
+    q: jt.Array
+
+    @jit_method()
+    def energy(self, q: jt.Array, /, t: jt.Array) -> jt.Array:
+        m = xp.sqrt(q[0] ** 2 + q[1] ** 2 + (q[2] / self.q) ** 2)
+        return (
+            -((self.v_c**2) / xp.sqrt(xp.log(2.0) - 0.5))
+            * xp.log(1.0 + m / self.r_s)
+            / (m / self.r_s)
+        )
+
+
+class NFWPotential(PotentialBase):
+    """
+    standard def see spherical model @ https://github.com/adrn/gala/blob/main/gala/potential/potential/builtin/builtin_potentials.c
+    """
+
+    m: jt.Array
+    r_s: jt.Array
+
+    @jit_method()
+    def energy(self, q: jt.Array, /, t: jt.Array) -> jt.Array:
+        v_h2 = -self._G * self.m / self.r_s
+        m = (
+            xp.sqrt(q[0] ** 2 + q[1] ** 2 + q[2] ** 2 + 0.001) / self.r_s
+        )  ##added softening!
+        return (
+            v_h2 * xp.log(1.0 + m) / m
+        )  # -((self.v_c**2)/xp.sqrt(xp.log(2.0)-0.5) )*xp.log(1.0 + m/self.r_s)/(m/self.r_s)
diff --git a/src/galdynamix/potential/_potential/builtin/subhalos.py b/src/galdynamix/potential/_potential/builtin/subhalos.py
new file mode 100644
index 00000000..533632e3
--- /dev/null
+++ b/src/galdynamix/potential/_potential/builtin/subhalos.py
@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+__all__ = ["SubHaloPopulation"]
+
+
+from typing import Any
+
+import astropy.units as u
+import jax
+import jax.numpy as xp
+import jax.typing as jt
+from gala.units import UnitSystem
+from jax_cosmo.scipy.interpolate import InterpolatedUnivariateSpline
+
+from galdynamix.potential._potential.base import PotentialBase
+from galdynamix.utils import jit_method
+
+from .isochrone import Isochrone
+
+usys = UnitSystem(u.kpc, u.Myr, u.Msun, u.radian)
+
+
+@jax.jit  # type: ignore[misc]
+def get_splines(x_eval: jt.Array, x: jt.Array, y: jt.Array) -> Any:
+    return InterpolatedUnivariateSpline(x, y, k=3)(x_eval)
+
+
+@jax.jit  # type: ignore[misc]
+def single_subhalo_potential(
+    params: dict[str, jt.Array], q: jt.Array, /, t: jt.Array
+) -> jt.Array:
+    """
+    Potential for a single subhalo
+    TODO: custom unit specification/subhalo potential specficiation.
+    Currently supports units kpc, Myr, Msun, rad.
+    """
+    pot_single = Isochrone(m=params["m"], a=params["a"], units=usys)
+    return pot_single.energy(q, t)
+
+
+class SubHaloPopulation(PotentialBase):
+    """
+    m has length n_subhalo
+    a has length n_subhalo
+    tq_subhalo_arr has shape t_orbit x n_subhalo x 3
+    t_orbit is the array of times the subhalos are integrated over
+    """
+
+    m: jt.Array
+    a: jt.Array
+    tq_subhalo_arr: jt.Array
+    t_orbit: jt.Array
+
+    @jit_method()
+    def energy(self, q: jt.Array, /, t: jt.Array) -> jt.Array:
+        x_at_t_eval = get_splines(
+            t, self.t_orbit, self.tq_subhalo_arr[:, :, 0]
+        )  # expect n_subhalo x-positions
+        y_at_t_eval = get_splines(
+            t, self.t_orbit, self.tq_subhalo_arr[:, :, 1]
+        )  # expect n_subhalo y-positions
+        z_at_t_eval = get_splines(
+            t, self.t_orbit, self.tq_subhalo_arr[:, :, 2]
+        )  # expect n_subhalo z-positions
+
+        subhalo_locations = xp.vstack(
+            [x_at_t_eval, y_at_t_eval, z_at_t_eval]
+        ).T  # n_subhalo x 3: the position of all subhalos at time t
+
+        delta_position = q - subhalo_locations  # n_subhalo x 3
+        # sum over potential due to all subhalos in the field by vmapping over m, a, and delta_position
+        ##dct = {'m': self.m, 'a': self.a,}
+        return xp.sum(
+            jax.vmap(
+                single_subhalo_potential,
+                in_axes=(({"m": 0, "a": 0}, 0, None)),
+            )({"m": self.m, "a": self.a}, delta_position, t)
+        )
diff --git a/src/galdynamix/potential/_potential/composite.py b/src/galdynamix/potential/_potential/composite.py
new file mode 100644
index 00000000..a4cc37a3
--- /dev/null
+++ b/src/galdynamix/potential/_potential/composite.py
@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+__all__ = ["CompositePotential"]
+
+
+from collections.abc import Mapping
+from typing import TypeVar
+
+import equinox as eqx
+import jax.numpy as xp
+import jax.typing as jt
+
+from galdynamix.utils import jit_method
+
+from .base import PotentialBase
+
+V = TypeVar("V")
+
+
+class FrozenDict(Mapping[str, V]):
+    def __init__(self, *args: V, **kwargs: V) -> None:
+        self._data: dict[str, V] = dict(*args, **kwargs)
+
+    def __getitem__(self, key: str) -> V:
+        return self._data[key]
+
+    def __iter__(self) -> iter[str]:
+        return iter(self._data)
+
+    def __len__(self) -> int:
+        return len(self._data)
+
+    def __hash__(self) -> int:
+        return hash(tuple(self._data.items()))
+
+    def keys(self) -> iter[str]:
+        return self._data.keys()
+
+    def values(self) -> iter[V]:
+        return self._data.values()
+
+    def items(self) -> iter[tuple[str, V]]:
+        return self._data.items()
+
+
+class CompositePotential(PotentialBase):
+    """Composite Potential."""
+
+    # potentials: FrozenDict[str, PotentialBase] = eqx.field(converter=FrozenDict)
+
+    potentials: tuple[PotentialBase] = eqx.field(converter=tuple)
+
+    # def __post_init__(self) -> None:
+    #     super().__post_init__()
+    #     self._potentials: dict[str, PotentialBase]
+    #     object.__setattr__(self, "_potentials", list(self.potentials.values()))
+
+    # === Mapping ===
+
+    def __getitem__(self, key: str) -> PotentialBase:
+        return self.potentials[key]
+
+    def __iter__(self) -> iter[str]:
+        return iter(self.potentials)
+
+    def __len__(self) -> int:
+        return len(self.potentials)
+
+    # === Potential ===
+
+    @jit_method()
+    def energy(
+        self,
+        q: jt.Array,
+        t: jt.Array,
+    ) -> jt.Array:
+        output = []
+        for p in self.potentials:
+            output.append(p.energy(q, t))
+        return xp.sum(xp.array(output))
diff --git a/src/galdynamix/py.typed b/src/galdynamix/py.typed
new file mode 100644
index 00000000..e69de29b
diff --git a/src/galdynamix/utils.py b/src/galdynamix/utils.py
new file mode 100644
index 00000000..f1d5ce15
--- /dev/null
+++ b/src/galdynamix/utils.py
@@ -0,0 +1,20 @@
+"""galdynamix: Galactic Dynamix in Jax"""
+
+from __future__ import annotations
+
+__all__: list[str] = ["jit_method"]
+
+from functools import partial
+from typing import Any, Callable, TypeVar
+
+import jax
+from typing_extensions import ParamSpec
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+def jit_method(
+    **kwargs: Any,
+) -> Callable[[Callable[P, R]], Callable[P, R]]:
+    return partial(jax.jit, **kwargs)
diff --git a/stream_integrator_static.ipynb b/stream_integrator_static.ipynb
deleted file mode 100644
index fb2689c6..00000000
--- a/stream_integrator_static.ipynb
+++ /dev/null
@@ -1,1738 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "1852a7c2-779f-4ceb-98c6-8916dbdee6a6",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u001b[91mA new version of galpy (1.9.0) is available, please upgrade using pip/conda/... to get the latest features and bug fixes!\u001b[0m\n"
-     ]
-    }
-   ],
-   "source": [
-    "from functools import partial\n",
-    "\n",
-    "from astropy.constants import G\n",
-    "import astropy.coordinates as coord\n",
-    "import astropy.units as u\n",
-    "import matplotlib as mpl\n",
-    "import matplotlib.pyplot as plt\n",
-    "%matplotlib inline\n",
-    "import numpy as np\n",
-    "\n",
-    "# gala\n",
-    "import gala.coordinates as gc\n",
-    "import gala.dynamics as gd\n",
-    "import gala.potential as gp\n",
-    "from gala.units import dimensionless, galactic, UnitSystem\n",
-    "\n",
-    "import jax\n",
-    "import jax.numpy as jnp\n",
-    "\n",
-    "from jax.config import config\n",
-    "config.update(\"jax_enable_x64\", True)\n",
-    "\n",
-    "import scienceplots\n",
-    "import cmasher as cmr\n",
-    "plt.style.use('science')\n",
-    "import jax.random as random \n",
-    "\n",
-    "usys = UnitSystem(u.kpc, u.Myr, u.Msun, u.radian)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "be2a7229-dedd-49d5-b868-83497bb67b39",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class Potential:\n",
-    "    \n",
-    "    def __init__(self, units, params):\n",
-    "        if units is None:\n",
-    "            units = dimensionless\n",
-    "        self.units = UnitSystem(units)\n",
-    "        \n",
-    "        if self.units == dimensionless:\n",
-    "            self._G = 1\n",
-    "        else:\n",
-    "            self._G = G.decompose(self.units).value\n",
-    "        \n",
-    "        for name, param in params.items():\n",
-    "            if hasattr(param, 'unit'):\n",
-    "                param = param.decompose(self.units).value\n",
-    "            setattr(self, name, param)\n",
-    "    \n",
-    "    @partial(jax.jit, static_argnums=(0,))\n",
-    "    def gradient(self, xyz):\n",
-    "        grad_func = jax.grad(self.potential)\n",
-    "        return grad_func(xyz)\n",
-    "    \n",
-    "    @partial(jax.jit, static_argnums=(0,))\n",
-    "    def density(self, xyz):\n",
-    "        lap = jnp.trace(jax.hessian(self.potential)(xyz))\n",
-    "        return lap / (4 * jnp.pi * self._G)\n",
-    "    \n",
-    "    @partial(jax.jit, static_argnums=(0,))\n",
-    "    def acceleration(self, xyz):\n",
-    "        return -self.gradient(xyz)\n",
-    "    \n",
-    "   \n",
-    "    @partial(jax.jit,static_argnums=(0,))\n",
-    "    def jacobian_force_mw(self, xyz):\n",
-    "        jacobian_force_mw = jax.jacfwd(self.gradient)\n",
-    "        return jacobian_force_mw(xyz)\n",
-    "    \n",
-    "    @partial(jax.jit,static_argnums=(0,))\n",
-    "    def d2phidr2_mw(self, x):\n",
-    "        \"\"\"\n",
-    "        Computes the second derivative of the Milky Way potential at a position x (in the simulation frame)\n",
-    "        Args:\n",
-    "          x: 3d position (x, y, z) in [kpc]\n",
-    "        Returns:\n",
-    "          Second derivative of force (per unit mass) in [1/Myr^2]\n",
-    "        Examples\n",
-    "        --------\n",
-    "        >>> d2phidr2_mw(x=jnp.array([8.0, 0.0, 0.0]))\n",
-    "        \"\"\"\n",
-    "        rad = jnp.linalg.norm(x)\n",
-    "        return jnp.matmul(jnp.transpose(x), jnp.matmul(self.jacobian_force_mw(x), x)) / rad**2\n",
-    "\n",
-    "\n",
-    "    @partial(jax.jit,static_argnums=(0,))\n",
-    "    def omega(self, x,v):\n",
-    "        \"\"\"\n",
-    "        Computes the magnitude of the angular momentum in the simulation frame\n",
-    "        Args:\n",
-    "          x: 3d position (x, y, z) in [kpc]\n",
-    "          v: 3d velocity (v_x, v_y, v_z) in [kpc/Myr]\n",
-    "        Returns:\n",
-    "          Magnitude of angular momentum in [rad/Myr]\n",
-    "        Examples\n",
-    "        --------\n",
-    "        >>> omega(x=jnp.array([8.0, 0.0, 0.0]), v=jnp.array([8.0, 0.0, 0.0]))\n",
-    "        \"\"\"\n",
-    "        rad = jnp.sqrt(x[0] ** 2 + x[1] ** 2 + x[2] ** 2)\n",
-    "        omega_vec = jnp.cross(x, v) / rad**2\n",
-    "        return jnp.linalg.norm(omega_vec)\n",
-    "\n",
-    "    @partial(jax.jit,static_argnums=(0,))\n",
-    "    def tidalr_mw(self, x, v, Msat):\n",
-    "        \"\"\"\n",
-    "        Computes the tidal radius of a clsuter in the Milky Way potential\n",
-    "        Args:\n",
-    "          x: 3d position (x, y, z) in [kpc]\n",
-    "          v: 3d velocity (v_x, v_y, v_z) in [kpc/Myr]\n",
-    "          Msat: Cluster mass in [Msol]\n",
-    "        Returns:\n",
-    "          Tidal radius of the cluster in [kpc]\n",
-    "        Examples\n",
-    "        --------\n",
-    "        >>> tidalr_mw(x=jnp.array([8.0, 0.0, 0.0]), v=jnp.array([8.0, 0.0, 0.0]), Msat=1e4)\n",
-    "        \"\"\"\n",
-    "        return (self._G * Msat / ( self.omega(x, v) ** 2 - self.d2phidr2_mw(x)) ) ** (1.0 / 3.0)\n",
-    "    \n",
-    "    @partial(jax.jit,static_argnums=(0,))\n",
-    "    def lagrange_pts(self,x,v,Msat):\n",
-    "        r_tidal = self.tidalr_mw(x,v,Msat)\n",
-    "        r_hat = x/jnp.linalg.norm(x)\n",
-    "        L_close = x - r_hat*r_tidal\n",
-    "        L_far = x + r_hat*r_tidal\n",
-    "        return L_close, L_far\n",
-    "    \n",
-    "    @partial(jax.jit,static_argnums=(0,))\n",
-    "    def release_model(self, x, v, Msat, pos_disp, vel_disp,i):\n",
-    "        \"\"\"\n",
-    "        Simplification of particle spray: just release particles in gaussian blob at each lagrange point.\n",
-    "        User sets the spatial and velocity dispersion for the \"leaking\" of particles\n",
-    "        TODO: change random key handling... need to do all of the sampling up front...\n",
-    "        \"\"\"\n",
-    "        keya = jax.random.PRNGKey(i*3)\n",
-    "        keyb = jax.random.PRNGKey(i*5)\n",
-    "        \n",
-    "        keyc = jax.random.PRNGKey(i*7)\n",
-    "        keyd = jax.random.PRNGKey(i*11)\n",
-    "        \n",
-    "        L_close, L_far = self.lagrange_pts(x,v,Msat) # each is an xyz array\n",
-    "        ###print(L_close, L_far)\n",
-    "        pos_release_close = L_close + jax.random.normal(keya,shape=(3,))*pos_disp\n",
-    "        pos_release_far = L_far + jax.random.normal(keyb,shape=(3,))*pos_disp\n",
-    "        \n",
-    "        #DeltaR_r = jnp.sqrt(jnp.sum((L_far - L_close)**2))/jnp.linalg.norm(x)\n",
-    "        \n",
-    "        vel_release_close = v + jax.random.normal(keyc,shape=(3,))*vel_disp\n",
-    "        vel_release_far = v  + jax.random.normal(keyd,shape=(3,))*vel_disp\n",
-    "        \n",
-    "        return pos_release_close, pos_release_far, vel_release_close, vel_release_far\n",
-    "    \n",
-    "    @partial(jax.jit,static_argnums=(0,))\n",
-    "    def gen_stream_ics(self, ts, prog_w0, Msat, pos_disp, vel_disp):\n",
-    "        ws_jax = leapfrog_run(prog_w0, ts, self.gradient)\n",
-    "        \n",
-    "        def scan_fun(carry, t):\n",
-    "            i, pos_close, pos_far, vel_close, vel_far = carry\n",
-    "            pos_close_new, pos_far_new, vel_close_new, vel_far_new = self.release_model(ws_jax[i,:3], ws_jax[i,3:], M_sat, pos_disp, vel_disp,i)\n",
-    "            return [i+1, pos_close_new, pos_far_new, vel_close_new, vel_far_new], [pos_close_new, pos_far_new, vel_close_new, vel_far_new]#[i+1, pos_close_new, pos_far_new, vel_close_new, vel_far_new]\n",
-    "            \n",
-    "            \n",
-    "        #init_carry = [0, 0, 0, 0, 0]\n",
-    "        init_carry = [0, jnp.array([0.0,0.0,0.]), jnp.array([0.0,0.0,0.]), jnp.array([0.0,0.0,0.]), jnp.array([0.0,0.0,0.])] \n",
-    "        final_state, all_states = jax.lax.scan(scan_fun, init_carry, ts[1:])\n",
-    "        pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr = all_states\n",
-    "        return pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr\n",
-    "    \n",
-    "    @partial(jax.jit,static_argnums=(0,))\n",
-    "    def gen_stream(self, ts, prog_w0, Msat, pos_disp, vel_disp):\n",
-    "        pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr = self.gen_stream_ics(ts, prog_w0, Msat, pos_disp, vel_disp)\n",
-    "        \n",
-    "        def scan_fun(carry, particle_idx):\n",
-    "            i, pos_close_curr, pos_far_curr, vel_close_curr, vel_far_curr = carry\n",
-    "            curr_particle_w0_close = jnp.hstack([pos_close_curr,vel_close_curr])\n",
-    "            curr_particle_w0_far = jnp.hstack([pos_far_curr,vel_far_curr])\n",
-    "            #print(curr_particle_w0_close.shape)\n",
-    "            #indices = jnp.arange(i,len(ts))\n",
-    "            #t_particle = jnp.take(ts, indices)\n",
-    "            #################t_particle = jax.lax.slice(ts,(i,),(len(ts),))\n",
-    "            w_particle_close = leapfrog_run(curr_particle_w0_close, ts, self.gradient)\n",
-    "            w_particle_far = leapfrog_run(curr_particle_w0_far, ts, self.gradient)\n",
-    "            \n",
-    "            ###ts_update = jax.lax.dynamic_slice(ts_curr,(i+1,),(len(ts_curr)-1,))\n",
-    "            \n",
-    "            return [i+1, pos_close_arr[i+1,:], pos_far_arr[i+1,:], vel_close_arr[i+1,:], vel_far_arr[i+1,:]], [w_particle_close, w_particle_far]\n",
-    "        init_carry = [0, pos_close_arr[0,:], pos_far_arr[0,:], vel_close_arr[0,:], vel_far_arr[0,:]]\n",
-    "        particle_ids = jnp.arange(len(pos_close_arr))\n",
-    "        final_state, all_states = jax.lax.scan(scan_fun, init_carry, particle_ids)\n",
-    "        lead_arm, trail_arm = all_states\n",
-    "        return lead_arm, trail_arm\n",
-    "            \n",
-    "    @partial(jax.jit,static_argnums=(0,))\n",
-    "    def gen_stream_final(self, ts, prog_w0, Msat, pos_disp, vel_disp):\n",
-    "        pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr = self.gen_stream_ics(ts, prog_w0, Msat, pos_disp, vel_disp)\n",
-    "        \n",
-    "        def scan_fun(carry, particle_idx):\n",
-    "            i, pos_close_curr, pos_far_curr, vel_close_curr, vel_far_curr = carry\n",
-    "            curr_particle_w0_close = jnp.hstack([pos_close_curr,vel_close_curr])\n",
-    "            curr_particle_w0_far = jnp.hstack([pos_far_curr,vel_far_curr])\n",
-    "            #print(curr_particle_w0_close.shape)\n",
-    "            #indices = jnp.arange(i,len(ts))\n",
-    "            #t_particle = jnp.take(ts, indices)\n",
-    "            \n",
-    "            #######t_particle = jax.lax.slice(ts,(i,),(len(ts),))\n",
-    "            t_particle = jax.lax.dynamic_slice(ts,(i+1,),(len(ts)-1,))\n",
-    "            w_particle_close = leapfrog_run(curr_particle_w0_close, t_particle, self.gradient)\n",
-    "            w_particle_far = leapfrog_run(curr_particle_w0_far, t_particle, self.gradient)\n",
-    "            \n",
-    "            w_particle_close = w_particle_close[-1,:]\n",
-    "            w_particle_far = w_particle_far[-1,:]\n",
-    "            \n",
-    "            \n",
-    "            \n",
-    "            return [i+1, pos_close_arr[i+1,:], pos_far_arr[i+1,:], vel_close_arr[i+1,:], vel_far_arr[i+1,:]], [w_particle_close, w_particle_far]\n",
-    "        init_carry = [0, pos_close_arr[0,:], pos_far_arr[0,:], vel_close_arr[0,:], vel_far_arr[0,:]]\n",
-    "        particle_ids = jnp.arange(len(pos_close_arr))\n",
-    "        final_state, all_states = jax.lax.scan(scan_fun, init_carry, particle_ids)\n",
-    "        lead_arm, trail_arm = all_states\n",
-    "        return lead_arm, trail_arm\n",
-    "        \n",
-    "    \n",
-    "        \n",
-    "class Kepler(Potential):\n",
-    "    \n",
-    "    def __init__(self, m, units=None):\n",
-    "        super().__init__(units, {'m': m})\n",
-    "    \n",
-    "    @partial(jax.jit, static_argnums=(0,))\n",
-    "    def potential(self, xyz):\n",
-    "        r = jnp.linalg.norm(xyz, axis=0)\n",
-    "        return - self._G * self.m / r\n",
-    "    \n",
-    "    \n",
-    "class Hernquist(Potential):\n",
-    "    \n",
-    "    def __init__(self, m, a, units=None):\n",
-    "        super().__init__(units, {'m': m, 'a': a})\n",
-    "        \n",
-    "    @partial(jax.jit, static_argnums=(0,))\n",
-    "    def potential(self, xyz):\n",
-    "        r = jnp.linalg.norm(xyz, axis=0)\n",
-    "        return - self._G * self.m / (r + self.a)\n",
-    "    \n",
-    "    \n",
-    "class Isochrone(Potential):\n",
-    "    \n",
-    "    def __init__(self, m, a, units=None):\n",
-    "        super().__init__(units, {'m': m, 'a': a})\n",
-    "    \n",
-    "    @partial(jax.jit, static_argnums=(0,))\n",
-    "    def potential(self, xyz):\n",
-    "        r = jnp.linalg.norm(xyz, axis=0)\n",
-    "        return - self._G * self.m / (self.a + jnp.sqrt(r**2 + self.a**2))\n",
-    "    \n",
-    "\n",
-    "\n",
-    "    \n",
-    "class Isochrone_centered(Potential):\n",
-    "    \n",
-    "    def __init__(self, m, a, spline_eval_func, splines, t_min, t_max, units=None):\n",
-    "        super().__init__(units, {'m': m, 'a': a, 'spline_eval_func': spline_eval_func, 'splines': splines, 't_min': t_min, 't_max': t_max})\n",
-    "    \n",
-    "    @partial(jax.jit, static_argnums=(0,))\n",
-    "    def potential(self, xyz, t):\n",
-    "        is_cond_met = (t > t_min) & (t < t_max) # True if yes, False if no\n",
-    "        \n",
-    "        def true_func():\n",
-    "            xyz = xyz - spline_eval_func(t,splines)\n",
-    "            r = jnp.linalg.norm(xyz, axis=0)\n",
-    "            return - self._G * self.m / (self.a + jnp.sqrt(r**2 + self.a**2))\n",
-    "        def false_func():\n",
-    "            return 0.0\n",
-    "            \n",
-    "        return jax.lax.cond(is_cond_met, true_func, false_func)\n",
-    "    \n",
-    "        \n",
-    "\n",
-    "    \n",
-    "    \n",
-    "    \n",
-    "def leapfrog_step(func, y0, t0, dt, a0):\n",
-    "    ndim = y0.shape[0] // 2\n",
-    "    tf = t0 + dt\n",
-    "    \n",
-    "    x0 = y0[:ndim]\n",
-    "    v0 = y0[ndim:]\n",
-    "    \n",
-    "    v1_2 = v0 + a0 * dt / 2.\n",
-    "    xf = x0 + v1_2 * dt\n",
-    "    af = - func(xf, tf)\n",
-    "    \n",
-    "    vf = v1_2 + af * dt / 2\n",
-    "    \n",
-    "    return tf, jnp.concatenate((xf, vf)), af\n",
-    "\n",
-    "@partial(jax.jit, static_argnames=['potential_gradient', 'args'])\n",
-    "def leapfrog_run(w0, ts, potential_gradient, args=()):\n",
-    "    func_ = lambda y, t: potential_gradient(y, *args)\n",
-    "    \n",
-    "    def scan_fun(carry, t):\n",
-    "        i, y0, t0, dt, a0 = carry\n",
-    "        tf, yf, af = leapfrog_step(func_, y0, t0, dt, a0)\n",
-    "        return [i + 1, yf, tf, dt, af], yf\n",
-    "    \n",
-    "    ndim = w0.shape[0] // 2\n",
-    "    a0 = func_(w0[:ndim], ts[0])\n",
-    "    init_carry = [0, w0, t0, dt, a0]\n",
-    "    _, ws = jax.lax.scan(scan_fun, init_carry, ts[1:])\n",
-    "    res_ws = jnp.concatenate((w0[None], ws))\n",
-    "    \n",
-    "    return res_ws\n",
-    "\n",
-    "def compute_orbit_and_gradients(params,w0,dt,n_steps,units):\n",
-    "    pot = Hernquist(m=params['m'], a=params['a'],units=units,)  # Create the potential with the given parameters\n",
-    "    \n",
-    "    # Example Orbit:\n",
-    "    #w0 = jnp.array([10, 0, 0, 0, .204, 0])\n",
-    "    t0 = 0\n",
-    "    #dt = 0.1\n",
-    "    #n_steps = 10000\n",
-    "    ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "    \n",
-    "    ### Compute the orbit with the provided potential\n",
-    "    ws_jax = leapfrog_run(w0, ts, pot.gradient)\n",
-    "    \n",
-    "    # Compute the gradient of the final position with respect to the potential parameters\n",
-    "    def gradient_fn(params):\n",
-    "        pot_with_params = Hernquist(m=params['m'], a=params['a'],units=units)\n",
-    "        ws_with_params = leapfrog_run(w0, ts, pot_with_params.gradient)\n",
-    "        final_position = ws_with_params[-1, :]  # Extract final position\n",
-    "        return final_position\n",
-    "    \n",
-    "    # Compute the gradient using JAX's autodiff\n",
-    "    gradient = jax.jacfwd(gradient_fn)(params)\n",
-    "    \n",
-    "    return ws_jax, gradient\n",
-    "\n",
-    "def get_stripping_time_arr(ts):\n",
-    "    \"\"\"\n",
-    "    assuming a particle is released for index in the ts array\n",
-    "    TODO: Custom release\n",
-    "    \"\"\"\n",
-    "    t_release_arr = []\n",
-    "    for i in range(len(ts)):\n",
-    "        t_release_arr.append( ts[i:] )\n",
-    "    return t_release_arr"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "822edcf2-0f72-4118-894a-2723167a9a0f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "params = {'m': 1.0e12, 'a': 10.}\n",
-    "pot = Isochrone(m=params['m'], a=params['a'],units=usys,)  \n",
-    "t0 = 0\n",
-    "dt = 0.5\n",
-    "n_steps = 4_000\n",
-    "w0 = jnp.array([50., 0., 0, (30*u.km/u.s).to(u.kpc/u.Myr).value, (300*u.km/u.s).to(u.kpc/u.Myr).value, (30*u.km/u.s).to(u.kpc/u.Myr).value])\n",
-    "\n",
-    "ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "### Compute the orbit with the provided potential\n",
-    "ws_jax = leapfrog_run(w0, ts, pot.gradient)\n",
-    "\n",
-    "M_sat = 1.0e4 # TODO: mass loss rate\n",
-    "pos_disp = .00\n",
-    "vel_disp = (5*u.km/u.s).to(u.kpc/u.Myr).value\n",
-    "\n",
-    "\n",
-    "\n",
-    "#lead_ics = jnp.zeros((len(ws_jax),6))\n",
-    "#trail_ics = jnp.zeros((len(ws_jax),6))\n",
-    "\n",
-    "#for i in range(len(ws_jax)):\n",
-    "#    pos_close, pos_far, vel_close, vel_far = pot.release_model(ws_jax[i,:3], ws_jax[i,3:], M_sat, pos_disp, vel_disp)\n",
-    "    "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "91b79ed3-f678-43a8-9113-3f7d19a42991",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from jax_cosmo.scipy.interpolate import InterpolatedUnivariateSpline\n",
-    "def get_spl_funcs(ts,ws):\n",
-    "    return [InterpolatedUnivariateSpline(ts,ws_jax[:,i],k=3) for i in range(3)]\n",
-    "\n",
-    "def eval_spl_funcs(ts, spl_funcs):\n",
-    "    return jnp.array([spl_funcs[i](ts) for i in range(3)])\n",
-    "#spl_x = InterpolatedUnivariateSpline(ts,ws_jax[:,0],k=3)\n",
-    "#spl_y = InterpolatedUnivariateSpline(ts,ws_jax[:,1],k=3)\n",
-    "\n",
-    "splines = get_spl_funcs(ts, ws_jax)\n",
-    "spline_evals = eval_spl_funcs(ts[3], splines)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "076a08a7-a9b0-4db0-874b-6ff22d9f726d",
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "NameError",
-     "evalue": "name 'spline_evals' is not defined",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_13797/4127923809.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mspline_evals\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-      "\u001b[0;31mNameError\u001b[0m: name 'spline_evals' is not defined"
-     ]
-    }
-   ],
-   "source": [
-    "spline_evals"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "da7aebe5-7ec7-40f9-a125-254d2eab581f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "params = {'m': 1e8, 'a': 4.0, 'spline_eval_func': eval_spl_funcs, 'splines': splines, 't_min': 0., 't_max': 2000.}\n",
-    "\n",
-    "pot = Isochrone_centered(m=params['m'], a=params['a'],\n",
-    "                         spline_eval_func=params['spline_eval_func'],\n",
-    "                         splines=params['splines'],\n",
-    "                         t_min=params['t_min'],\n",
-    "                         t_max = params['t_max'],\n",
-    "                         units=usys,)  \n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "37cb9e7b-767e-4e73-9d29-d31313d5912f",
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "NameError",
-     "evalue": "name 'spl_x' is not defined",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_37030/2671119943.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mspl_x\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mspl_y\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mws_jax\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mws_jax\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mNameError\u001b[0m: name 'spl_x' is not defined"
-     ]
-    }
-   ],
-   "source": [
-    "plt.plot(spl_x(ts),spl_y(ts))\n",
-    "plt.plot(ws_jax[:,0],ws_jax[:,1])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "53c83e0e-5dc8-4cfc-aea7-b2179e0eb07f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "#params = {'m': 1e8, 'a': 4.0, 'xyz_center': xyz_center, 't_min': t_min, 't_max': t_max}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "9bdf1e52-9a4a-4d76-98cf-1e882824eeb0",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "gala_pot = gp.IsochronePotential(m=params['m'],b=params['a'],units=usys)\n",
-    "H = gp.Hamiltonian(gala_pot)\n",
-    "w0_gala  =gd.PhaseSpacePosition(pos=w0[:3],vel=w0[3:])\n",
-    "t0 = 0#25_000*0.5\n",
-    "dt = 0.5\n",
-    "n_steps = 2*5_000\n",
-    "tss = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "gala_orb = H.integrate_orbit(w0=w0_gala,t=np.array(tss))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "b1e0935f-22ec-4678-b5dc-7335a5406f29",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array([0.0000e+00, 5.0000e-01, 1.0000e+00, ..., 1.9990e+03, 1.9995e+03,\n",
-       "       2.0000e+03], dtype=float64)"
-      ]
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "ts"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "id": "fa2aad7f-469e-47e8-abf4-a05dc401e101",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "lead_arm, trail_arm = pot.gen_stream_final(ts, w0, M_sat, pos_disp, vel_disp)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "bb9d756f-4a5a-4311-a247-1519dbfd68f8",
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "NameError",
-     "evalue": "name 'lead_arm' is not defined",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_37030/484101367.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgala_orb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgala_orb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcolor\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'r'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscatter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlead_arm\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlead_arm\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m.4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mzorder\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;31m#plt.xlim(-70,-40)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m#plt.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mNameError\u001b[0m: name 'lead_arm' is not defined"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.plot(gala_orb.x,gala_orb.y,color='r')\n",
-    "plt.scatter(lead_arm[:,0],lead_arm[:,1],s=.4,zorder=2)\n",
-    "\n",
-    "#plt.xlim(-70,-40)\n",
-    "#plt.\n",
-    "#plt.scatter(trail_arm[:,0],trail_arm[:,1],s=0.05)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "id": "6ae4cb8f-82ee-4feb-9a4e-d167c915be9a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def stream_gradients(params,ts,w0,Msat, pos_disp, vel_disp,units):\n",
-    "    pot = Isochrone(m=params['m'], a=params['a'],units=units)\n",
-    "    #lead_arm, trail_arm = pot.gen_stream_final(ts, w0, Msat, pos_disp, vel_disp)\n",
-    "    \n",
-    "    # Compute the gradient of the final position with respect to the potential parameters\n",
-    "    def gradient_fn(params):\n",
-    "        pot_with_params = Isochrone(m=params['m'], a=params['a'],units=units)\n",
-    "        lead_arm, trail_arm = pot_with_params.gen_stream_final(ts, w0, Msat, pos_disp, vel_disp)\n",
-    "        return jnp.sum(lead_arm**2) \n",
-    "    # Compute the gradient using JAX's autodiff\n",
-    "    gradient_eval = jax.jacfwd(gradient_fn)(params)\n",
-    "    \n",
-    "    return gradient_eval\n",
-    "    \n",
-    "    \n",
-    "gradient_eval = stream_gradients(params,ts,w0,M_sat,pos_disp,vel_disp,usys)\n",
-    "    \n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "id": "329b8c08-ecf5-4514-9669-e7628153dc7c",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7f91b15a0160>"
-      ]
-     },
-     "execution_count": 20,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import jax.scipy.stats as statsjax\n",
-    "kde = statsjax.gaussian_kde(lead_arm[:,:].T,bw_method=.04)\n",
-    "key = jax.random.PRNGKey(3)\n",
-    "samps = kde.resample(key,[len(lead_arm)]).T\n",
-    "ll = kde.logpdf(lead_arm[:,:].T)\n",
-    "plt.scatter(samps[:,0],samps[:,1],s=.4)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "id": "20bb92f2-0b88-4968-8c92-02f615ece584",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "lead_arm_data, trail_arm_data = pot.gen_stream_final(ts, w0, M_sat, pos_disp, vel_disp)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 29,
-   "id": "383bb9f9-06b3-4855-9b50-8564c35f2ffb",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#@partial(jax.jit, static_argnums=(1,))\n",
-    "def cost_func(stream_particles_data=None,stream_particles_model=None):\n",
-    "    return -jnp.mean(jnp.square(stream_particles_data[:] - stream_particles_model[:]))\n",
-    "from functools import partial\n",
-    "test_func = partial(cost_func,stream_particles_data=lead_arm_data)\n",
-    "#test_func(stream_particles_model=lead_arm_data)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "id": "d0cdad0d-aad3-4078-9db6-fd375faed875",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import jax.scipy.stats as statsjax\n",
-    "\n",
-    "def stream_gradients_kde(params,ts,w0,Msat, pos_disp, vel_disp, kde, units):\n",
-    "    #pot = Isochrone(m=params['m'], a=params['a'],units=units)\n",
-    "    #lead_arm, trail_arm = pot.gen_stream_final(ts, w0, Msat, pos_disp, vel_disp)\n",
-    "    \n",
-    "    # Compute the gradient of the final position with respect to the potential parameters\n",
-    "    def gradient_fn(params):\n",
-    "        pot_with_params = Isochrone(m=params['m'], a=params['a'],units=units)\n",
-    "        lead_arm, trail_arm = pot_with_params.gen_stream_final(ts, w0, Msat, pos_disp, vel_disp)\n",
-    "        #kde = statsjax.gaussian_kde(lead_arm.T,bw_method=.07)\n",
-    "        log_like = test_func(stream_particles_model=lead_arm)#jnp.sum(kde.logpdf(lead_arm.T))\n",
-    "        return log_like#jnp.sum(lead_arm**2) \n",
-    "    # Compute the gradient using JAX's autodiff\n",
-    "    gradient_eval = jax.jacfwd(gradient_fn)(params)\n",
-    "    \n",
-    "    ##grad_eval_func = lambda params: jax.jacfwd(gradient_fn)(params)\n",
-    "    ##second_grad_eval = jax.jacfwd(grad_eval_func)(params)\n",
-    "    \n",
-    "    return gradient_eval, None#second_grad_eval\n",
-    "    \n",
-    "params_ = {'m': params['m'], 'a': params['a']}\n",
-    "\n",
-    "gradient_eval, second_gradient = stream_gradients_kde(params_,ts,w0,M_sat,pos_disp,vel_disp, kde, usys)\n",
-    "    \n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 37,
-   "id": "1e3d5bb6-432f-44a9-966e-ef9f07d5ca74",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'a': Array(-5.49931482e-15, dtype=float64),\n",
-       " 'm': Array(2.19205184e-25, dtype=float64)}"
-      ]
-     },
-     "execution_count": 37,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "gradient_eval"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "id": "7c6152f9-365c-4657-b276-4785165aa531",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array([[1.58206676e-06, 4.30600858e+04],\n",
-       "       [4.30600858e+04, 1.21564519e+15]], dtype=float64)"
-      ]
-     },
-     "execution_count": 24,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "I = -jnp.array([ [second_gradient['a']['a'],second_gradient['a']['m'] ],\n",
-    "            [second_gradient['a']['m'], second_gradient['m']['m'] ] ])\n",
-    "jnp.linalg.inv(I)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "id": "5047a88d-9197-4635-96f9-7af7d20ff046",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "8.539590623023813"
-      ]
-     },
-     "execution_count": 19,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "np.log10(jnp.sqrt(1.2e17))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1198,
-   "id": "cd4cc6ed-fb0d-4ba0-9506-0a2d46ec63bc",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "10.0"
-      ]
-     },
-     "execution_count": 1198,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "np.sqrt(1e-4)*1000"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 960,
-   "id": "93da2b70-850c-4b96-8309-be8a08ce1175",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "1.0000283885785286"
-      ]
-     },
-     "execution_count": 960,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "10**np.sqrt(1.52e-10)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 945,
-   "id": "56b4c7ed-b310-432d-9313-4815875f29db",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array([[6.97522627e-09, 2.31555412e+02],\n",
-       "       [2.31555412e+02, 8.13557014e+12]], dtype=float64)"
-      ]
-     },
-     "execution_count": 945,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "I = -jnp.array([ [second_gradient['a']['a'],second_gradient['a']['m'] ],\n",
-    "            [second_gradient['a']['m'], second_gradient['m']['m'] ] ])\n",
-    "jnp.linalg.inv(I)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 938,
-   "id": "d8458f4f-bdb0-4e60-aff4-733233fd3d37",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(Array(0.07399038, dtype=float64), Array(0.07399038, dtype=float64))"
-      ]
-     },
-     "execution_count": 938,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "second_gradient['a']['m'], second_gradient['m']['a']"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1238,
-   "id": "907cfc74-e382-4827-90bb-2ba422d11697",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "1000000000000.0"
-      ]
-     },
-     "execution_count": 1238,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "params['m']"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1241,
-   "id": "843fe77b-34a6-402b-8a49-82ef147150b5",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pot = Isochrone(m=params['m'], a=params['a'],units=usys,)  # Create the potential with the given parameters\n",
-    "    \n",
-    "# Example Orbit:\n",
-    "t0 = 0\n",
-    "ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "    \n",
-    "### Compute the orbit with the provided potential\n",
-    "w_orb = leapfrog_run(w0, ts, pot.gradient)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1262,
-   "id": "a588cf14-eefc-4e52-8057-8f25aaaeb2dd",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array(-0., dtype=float64)"
-      ]
-     },
-     "execution_count": 1262,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "@jax.jit\n",
-    "def gauss_pt(x_eval, x_mean):\n",
-    "    return -0.5*jnp.sum(jnp.square(x_eval - x_mean))\n",
-    "gauss_pt(w_orb[-1,:],w_orb[-1,:])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1254,
-   "id": "1dc6c939-3eb6-4f8d-8e97-ec13c5b958dc",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7faa24c76d60>"
-      ]
-     },
-     "execution_count": 1254,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import jax.scipy.stats as statsjax\n",
-    "#kde = statsjax.gaussian_kde(w_orb[-1,:],bw_method=.04)\n",
-    "#key = jax.random.PRNGKey(3)\n",
-    "#samps = kde.resample(key,[20]).T\n",
-    "#ll = kde.logpdf(lead_arm[:,:].T)\n",
-    "#plt.scatter(samps[:,0],samps[:,1],s=10)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1272,
-   "id": "d3ae8521-c99b-40ae-926d-51d9fb519eb0",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def compute_orbit_and_gradients(params,w0,dt,n_steps,units):\n",
-    "    pot = Isochrone(m=params['m'], a=params['a'],units=units,)  # Create the potential with the given parameters\n",
-    "    \n",
-    "    # Example Orbit:\n",
-    "    #w0 = jnp.array([10, 0, 0, 0, .204, 0])\n",
-    "    t0 = 0\n",
-    "    #dt = 0.1\n",
-    "    #n_steps = 10000\n",
-    "    ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "    \n",
-    "    ### Compute the orbit with the provided potential\n",
-    "    ####################ws_jax = leapfrog_run(w0, ts, pot.gradient)\n",
-    "    \n",
-    "    # Compute the gradient of the final position with respect to the potential parameters\n",
-    "    def gradient_fn(params):\n",
-    "        pot_with_params = Isochrone(m=params['m'], a=params['a'],units=units)\n",
-    "        ws_with_params = leapfrog_run(w0, ts, pot_with_params.gradient)\n",
-    "        final_position = ws_with_params[-1, :]  # Extract final position\n",
-    "        return gauss_pt(final_position,w_orb[-1,:])\n",
-    "        #return final_position\n",
-    "    \n",
-    "    # Compute the gradient using JAX's autodiff\n",
-    "    gradient = jax.jacfwd(gradient_fn)(params)\n",
-    "    \n",
-    "    return gradient"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1273,
-   "id": "e83d25a4-7f91-4d90-8353-8526e7b40449",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "gg = compute_orbit_and_gradients(params,w0,dt,n_steps,usys)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1274,
-   "id": "f90f5030-0249-4385-a1f8-ef04fb55de62",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'a': Array(-0., dtype=float64), 'm': Array(-0., dtype=float64)}"
-      ]
-     },
-     "execution_count": 1274,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "gg"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 399,
-   "id": "04c08e2d-23df-4f74-93a2-81b71b2fb113",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "params = {'m': 5e11, 'a': 10.}\n",
-    "pot = Hernquist(m=params['m'], a=params['a'],units=usys,)  \n",
-    "t0 = 0\n",
-    "dt = 0.5\n",
-    "n_steps = 10_000\n",
-    "ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "### Compute the orbit with the provided potential\n",
-    "##ws_jax = leapfrog_run(w0, ts, pot.gradient)\n",
-    "\n",
-    "M_sat = 1.0e4 # TODO: mass loss rate\n",
-    "pos_disp = .001\n",
-    "vel_disp = (20*u.km/u.s).to(u.kpc/u.Myr).value#.05\n",
-    "\n",
-    "pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr = pot.gen_stream_ics(ts, w0, Msat, pos_disp, vel_disp)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 333,
-   "id": "b69344f7-9f7f-473b-a917-1fbd614d941d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#release_time_arr = get_stripping_time_arr(ts)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 308,
-   "id": "808ed1f4-eb0a-44e3-8e4d-b7be12395a98",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array([0.000e+00, 1.000e+00, 2.000e+00, ..., 9.998e+03, 9.999e+03,\n",
-       "       1.000e+04], dtype=float64)"
-      ]
-     },
-     "execution_count": 308,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "ts"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 309,
-   "id": "64ed11fc-7055-46b1-8e93-f9537ff4ca6a",
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "KeyboardInterrupt",
-     "evalue": "",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_21408/1523047885.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m# Example usage:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;31m#ts = jnp.array([1, 2, 3, 4, 5])\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_stripping_time_arr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_21408/1523047885.py\u001b[0m in \u001b[0;36mget_stripping_time_arr\u001b[0;34m(ts)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget_stripping_time_arr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0mt_release_arr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mt_release_arr\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m# Example usage:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_21408/1523047885.py\u001b[0m in \u001b[0;36m<listcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget_stripping_time_arr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0mt_release_arr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mt_release_arr\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m# Example usage:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/array.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, idx)\u001b[0m\n\u001b[1;32m    341\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0mlax_numpy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_rewriting_take\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0midx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    342\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 343\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mlax_numpy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_rewriting_take\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0midx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    344\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    345\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m__iter__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/numpy/lax_numpy.py\u001b[0m in \u001b[0;36m_rewriting_take\u001b[0;34m(arr, idx, indices_are_sorted, unique_indices, mode, fill_value)\u001b[0m\n\u001b[1;32m   3890\u001b[0m         \u001b[0;31m# Use dynamic rather than static slice here to avoid slow repeated execution:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3891\u001b[0m         \u001b[0;31m# See https://github.com/google/jax/issues/12198\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3892\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdynamic_slice_in_dim\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstart\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_max\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstop\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mstart\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   3893\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3894\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mslice_in_dim\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstart\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstop\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstep\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/lax/slicing.py\u001b[0m in \u001b[0;36mdynamic_slice_in_dim\u001b[0;34m(operand, start_index, slice_size, axis)\u001b[0m\n\u001b[1;32m    696\u001b[0m   \u001b[0mstart_indices\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mstart_index\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    697\u001b[0m   \u001b[0mslice_sizes\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_canonicalize_dimension\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mslice_size\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 698\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0mdynamic_slice\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moperand\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstart_indices\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mslice_sizes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    699\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    700\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/lax/slicing.py\u001b[0m in \u001b[0;36mdynamic_slice\u001b[0;34m(operand, start_indices, slice_sizes)\u001b[0m\n\u001b[1;32m    108\u001b[0m     \u001b[0mdynamic_sizes\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    109\u001b[0m     \u001b[0mstatic_sizes\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanonicalize_shape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mslice_sizes\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 110\u001b[0;31m   return dynamic_slice_p.bind(operand, *start_indices, *dynamic_sizes,\n\u001b[0m\u001b[1;32m    111\u001b[0m                               slice_sizes=tuple(static_sizes))\n\u001b[1;32m    112\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/core.py\u001b[0m in \u001b[0;36mbind\u001b[0;34m(self, *args, **params)\u001b[0m\n\u001b[1;32m    358\u001b[0m     assert (not config.jax_enable_checks or\n\u001b[1;32m    359\u001b[0m             all(isinstance(arg, Tracer) or valid_jaxtype(arg) for arg in args)), args\n\u001b[0;32m--> 360\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbind_with_trace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfind_top_trace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    361\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    362\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mbind_with_trace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/core.py\u001b[0m in \u001b[0;36mbind_with_trace\u001b[0;34m(self, trace, args, params)\u001b[0m\n\u001b[1;32m    361\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    362\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mbind_with_trace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 363\u001b[0;31m     \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_primitive\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    364\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfull_lower\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmultiple_results\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mfull_lower\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    365\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/core.py\u001b[0m in \u001b[0;36mprocess_primitive\u001b[0;34m(self, primitive, tracers, params)\u001b[0m\n\u001b[1;32m    815\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    816\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess_primitive\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 817\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimpl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    818\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    819\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/dispatch.py\u001b[0m in \u001b[0;36mapply_primitive\u001b[0;34m(prim, *args, **params)\u001b[0m\n\u001b[1;32m    115\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    116\u001b[0m   \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 117\u001b[0;31m     compiled_fun = xla_primitive_callable(prim, *unsafe_map(arg_spec, args),\n\u001b[0m\u001b[1;32m    118\u001b[0m                                           **params)\n\u001b[1;32m    119\u001b[0m   \u001b[0;32mexcept\u001b[0m \u001b[0mpxla\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mDeviceAssignmentMismatchError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    251\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    252\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 253\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    254\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    255\u001b[0m     \u001b[0mwrapper\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcache_clear\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcache_clear\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    244\u001b[0m     \u001b[0;34m@\u001b[0m\u001b[0mfunctools\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlru_cache\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmax_size\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    245\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 246\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    247\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    248\u001b[0m     \u001b[0;34m@\u001b[0m\u001b[0mfunctools\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwraps\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/dispatch.py\u001b[0m in \u001b[0;36mxla_primitive_callable\u001b[0;34m(prim, *arg_specs, **params)\u001b[0m\n\u001b[1;32m    206\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    207\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 208\u001b[0;31m   compiled = _xla_callable_uncached(lu.wrap_init(prim_fun), prim.name,\n\u001b[0m\u001b[1;32m    209\u001b[0m                                     donated_invars, False, *arg_specs)\n\u001b[1;32m    210\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mprim\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmultiple_results\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/dispatch.py\u001b[0m in \u001b[0;36m_xla_callable_uncached\u001b[0;34m(fun, name, donated_invars, keep_unused, *arg_specs)\u001b[0m\n\u001b[1;32m    252\u001b[0m                                  *arg_specs, lowering_platform=None)\n\u001b[1;32m    253\u001b[0m   \u001b[0mallow_prop\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcomputation\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcompile_args\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'global_out_avals'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 254\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0mcomputation\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcompile\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_allow_propagation_to_outputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mallow_prop\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munsafe_call\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    255\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    256\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/interpreters/pxla.py\u001b[0m in \u001b[0;36mcompile\u001b[0;34m(self, _allow_propagation_to_outputs, _allow_compile_replicated)\u001b[0m\n\u001b[1;32m   2814\u001b[0m             **self.compile_args)\n\u001b[1;32m   2815\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2816\u001b[0;31m         self._executable = UnloadedMeshExecutable.from_hlo(\n\u001b[0m\u001b[1;32m   2817\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_name\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2818\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_hlo\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/interpreters/pxla.py\u001b[0m in \u001b[0;36mfrom_hlo\u001b[0;34m(name, computation, mesh, global_in_avals, global_out_avals, in_shardings, out_shardings, spmd_lowering, tuple_args, auto_spmd_lowering, _allow_propagation_to_outputs, _allow_compile_replicated, unordered_effects, ordered_effects, host_callbacks, keepalive, kept_var_idx, backend, device_assignment, committed, pmap_nreps)\u001b[0m\n\u001b[1;32m   3026\u001b[0m                                      \u001b[0;34m\"in {elapsed_time} sec\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3027\u001b[0m                                      event=dispatch.BACKEND_COMPILE_EVENT):\n\u001b[0;32m-> 3028\u001b[0;31m         xla_executable = dispatch.compile_or_get_cached(\n\u001b[0m\u001b[1;32m   3029\u001b[0m             backend, computation, compile_options, host_callbacks)\n\u001b[1;32m   3030\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/dispatch.py\u001b[0m in \u001b[0;36mcompile_or_get_cached\u001b[0;34m(backend, computation, compile_options, host_callbacks)\u001b[0m\n\u001b[1;32m    524\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0mcompiled\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    525\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 526\u001b[0;31m   return backend_compile(backend, serialized_computation, compile_options,\n\u001b[0m\u001b[1;32m    527\u001b[0m                          host_callbacks)\n\u001b[1;32m    528\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/profiler.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    312\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    313\u001b[0m     \u001b[0;32mwith\u001b[0m \u001b[0mTraceAnnotation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdecorator_kwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 314\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    315\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    316\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/dispatch.py\u001b[0m in \u001b[0;36mbackend_compile\u001b[0;34m(backend, built_c, options, host_callbacks)\u001b[0m\n\u001b[1;32m    469\u001b[0m   \u001b[0;31m# TODO(sharadmv): remove this fallback when all backends allow `compile`\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    470\u001b[0m   \u001b[0;31m# to take in `host_callbacks`\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 471\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0mbackend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcompile\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbuilt_c\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcompile_options\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    472\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    473\u001b[0m \u001b[0m_ir_dump_counter\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mitertools\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcount\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
-     ]
-    }
-   ],
-   "source": [
-    "def get_stripping_time_arr(ts):\n",
-    "    t_release_arr = [ts[i:] for i in range(len(ts))]\n",
-    "    return t_release_arr\n",
-    "\n",
-    "# Example usage:\n",
-    "#ts = jnp.array([1, 2, 3, 4, 5])\n",
-    "result = get_stripping_time_arr(ts)\n",
-    "print(result)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 319,
-   "id": "94c3c17b-1eca-4441-a5a9-c2f247f09a9a",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array([2, 3, 4, 5], dtype=int64)"
-      ]
-     },
-     "execution_count": 319,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "jax.lax.slice(tt,(1,),(len(tt),))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 312,
-   "id": "d056dfcc-6321-4f84-b8ef-7b3e6d8561de",
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "TypeError",
-     "evalue": "iteration over a 0-d array",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_21408/1263285150.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     15\u001b[0m \u001b[0;31m# Example usage:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     16\u001b[0m \u001b[0mtt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 17\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_stripping_time_arr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     18\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_21408/1263285150.py\u001b[0m in \u001b[0;36mget_stripping_time_arr\u001b[0;34m(ts)\u001b[0m\n\u001b[1;32m     10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m     \u001b[0;31m# Use vmap to apply the slicing function to each row\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m     \u001b[0mt_release_arr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mslice_row\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatched_ts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     14\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mt_release_arr\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "    \u001b[0;31m[... skipping hidden 3 frame]\u001b[0m\n",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_21408/1263285150.py\u001b[0m in \u001b[0;36mslice_row\u001b[0;34m(i, arr)\u001b[0m\n\u001b[1;32m      7\u001b[0m     \u001b[0;31m# Create a function to slice each row\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mslice_row\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0marr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mslice\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marr\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m     \u001b[0;31m# Use vmap to apply the slicing function to each row\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "    \u001b[0;31m[... skipping hidden 2 frame]\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/lax/lax.py\u001b[0m in \u001b[0;36m_iter\u001b[0;34m(tracer)\u001b[0m\n\u001b[1;32m   1457\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_iter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtracer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1458\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0mtracer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1459\u001b[0;31m     \u001b[0;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"iteration over a 0-d array\"\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# same as numpy error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1460\u001b[0m   \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1461\u001b[0m     \u001b[0mn\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtracer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mTypeError\u001b[0m: iteration over a 0-d array"
-     ]
-    }
-   ],
-   "source": [
-    "from jax import vmap\n",
-    "\n",
-    "def get_stripping_time_arr(ts):\n",
-    "    # Create a batched version of ts\n",
-    "    batched_ts = jnp.stack([ts] * len(ts))\n",
-    "    \n",
-    "    # Create a function to slice each row\n",
-    "    def slice_row(i, arr):\n",
-    "        return jax.lax.slice(arr,i,-1)\n",
-    "\n",
-    "    # Use vmap to apply the slicing function to each row\n",
-    "    t_release_arr = vmap(slice_row)(jnp.arange(len(ts)), batched_ts)\n",
-    "    \n",
-    "    return t_release_arr\n",
-    "# Example usage:\n",
-    "tt = jnp.array([1, 2, 3, 4, 5])\n",
-    "result = get_stripping_time_arr(tt)\n",
-    "print(result)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 376,
-   "id": "cfb93bbb-5716-48f3-8015-e4558841b5b7",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "lead_arm, trail_arm = pot.gen_stream(ts, w0, Msat, pos_disp, vel_disp)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "12cfd522-44f0-4615-ae5a-7e1014abcaf9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "plt.scatter(lead_arm[:,-1,0],lead_arm[:,-1,1],s=0.5,rasterized=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 404,
-   "id": "4a3d40bb-5b76-49b2-81fb-35cf387792a6",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/latex": [
-       "$0.020454243 \\; \\mathrm{\\frac{kpc}{Myr}}$"
-      ],
-      "text/plain": [
-       "<Quantity 0.02045424 kpc / Myr>"
-      ]
-     },
-     "execution_count": 404,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "(50*u.km/u.s).to(u.kpc/u.Myr).value"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 405,
-   "id": "d15ca259-fd43-42fc-9fac-e66b69658915",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "lead_arm, trail_arm = pot.gen_stream_final(ts, w0, Msat, pos_disp, (50*u.km/u.s).to(u.kpc/u.Myr).value)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 406,
-   "id": "b3ed7351-88a1-4317-baca-10ed57d6c0ae",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7fa8ef2874f0>"
-      ]
-     },
-     "execution_count": 406,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.scatter(lead_arm[:,0],lead_arm[:,1],s=0.5,rasterized=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 378,
-   "id": "ec0a9dcf-2da0-459f-988d-d3fe404cde57",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7fa8e95bf4c0>"
-      ]
-     },
-     "execution_count": 378,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.scatter(lead_arm[:,-1,0],lead_arm[:,-1,1],s=0.5,rasterized=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 198,
-   "id": "322419da-c292-42d5-b79d-67eb5f16e71b",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "15\n",
-      "[ 1  3  6 10 15]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Define a step function that adds an input to the carry state\n",
-    "def step(carry, x):\n",
-    "    return carry + x, carry + x\n",
-    "\n",
-    "# Sequence of input values\n",
-    "inputs = jnp.array([1, 2, 3, 4, 5])\n",
-    "\n",
-    "# Initial carry state\n",
-    "init_carry = jnp.array(0)\n",
-    "\n",
-    "# Use jax.lax.scan to iterate over the inputs\n",
-    "final_carry, results = jax.lax.scan(step, init_carry, inputs)\n",
-    "\n",
-    "print(final_carry)  # Output: 15 (sum of all input values)\n",
-    "print(results)      # Output: [1, 3, 6, 10, 15] (cumulative sums)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "560e8dc1-b95e-4487-9729-2e4b075feb0f",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 115,
-   "id": "5c1f226a-8f37-45f4-863b-b084cdcb0aec",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array([ 0.23298915, -1.04627168,  1.35807149], dtype=float64)"
-      ]
-     },
-     "execution_count": 115,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "key = jax.random.PRNGKey(30302)\n",
-    "jax.random.normal(key,shape=(3,))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 172,
-   "id": "d6656cfa-bcf4-4538-a491-505795114d4e",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(Array([24.72606542,  9.89042617,  9.89042617], dtype=float64),\n",
-       " Array([25.27393458, 10.10957383, 10.10957383], dtype=float64))"
-      ]
-     },
-     "execution_count": 172,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "params = {'m': 1e10, 'a': 10.}\n",
-    "pot = Hernquist(m=params['m'], a=params['a'],units=usys,)  \n",
-    "\n",
-    "x = jnp.array([25,10,10.])\n",
-    "v = jnp.array([.1,.05,.04])\n",
-    "Msat = 1.0e4\n",
-    "pos_disp = .01\n",
-    "vel_disp = .005\n",
-    "#pot.tidalr_mw(x,v,Msat)\n",
-    "pot.lagrange_pts(x, v, Msat,)\n",
-    "#pot.tidalr_mw(x,v,Msat)\n",
-    "#pot.d2phidr2_mw(x)\n",
-    "#pot.omega(x, v)\n",
-    "#pot.omega(x, v) ** 2 - pot.d2phidr2_mw(x)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 165,
-   "id": "5d6dd512-ebd7-4d65-8a02-d8746dff8fc1",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array(nan, dtype=float64)"
-      ]
-     },
-     "execution_count": 165,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "(pot._G * Msat / (pot.omega(x, v) ** 2 - pot.d2phidr2_mw(x))) ** (1.0 / 3.0)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 167,
-   "id": "d23be7dc-b15a-4ee6-8a50-832849250008",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array(-0.03117464, dtype=float64)"
-      ]
-     },
-     "execution_count": 167,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "pot._G * Msat / (pot.omega(x, v) ** 2 - pot.d2phidr2_mw(x))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 168,
-   "id": "9271c65f-d971-4380-9c50-a3e48f443c9e",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(0.6299605249474367+1.0911236359717214j)"
-      ]
-     },
-     "execution_count": 168,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "(-2)**(1/3)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 60,
-   "id": "a358f1da-0083-4bcd-ab17-b18684bd39c7",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "a_arr = jnp.linspace(10,11,30)\n",
-    "w0 = jnp.array([25., 0., 0, 0.01, .104, -0.004])\n",
-    "dt = 0.1\n",
-    "t0 = 0.\n",
-    "n_steps = 30_000\n",
-    "Delta_a = jnp.diff(a_arr)[0]\n",
-    "predicted_wf = jnp.zeros((len(a_arr),6))\n",
-    "true_wf = jnp.zeros((len(a_arr)-1,6))\n",
-    "for i in range(len(a_arr)):\n",
-    "    params = {'m': 5e11, 'a': a_arr[i]}\n",
-    "    result_ws, param_gradients = compute_orbit_and_gradients(params,w0,dt,n_steps,usys)\n",
-    "    pred = result_ws[-1] + param_gradients['a']*Delta_a \n",
-    "    predicted_wf = predicted_wf.at[i,:].set( pred )\n",
-    "    if i > 0:\n",
-    "        true_wf = true_wf.at[i-1,:].set(result_ws[-1])\n",
-    "    \n",
-    "    \n",
-    "\n",
-    "    \n",
-    "\n",
-    "    \n",
-    "    "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 61,
-   "id": "527867ec-3518-47ca-bd86-e724ff732ba3",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 792x504 with 7 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig, ax = plt.subplots(2,3)\n",
-    "ax_flat = ax.flatten()\n",
-    "fig.set_size_inches(11,7)\n",
-    "for dim in range(6):\n",
-    "    xx = np.linspace(true_wf[:,dim].min(),true_wf[:,dim].max(),50)\n",
-    "    ax_flat[dim].plot(xx,xx,color='k',ls='--',zorder=0)\n",
-    "\n",
-    "    ax_flat[dim].scatter(true_wf[:,dim], predicted_wf[:-1,dim],c=a_arr[1:],s=20,cmap=cmr.guppy)\n",
-    "    ax_flat[dim].set_aspect('equal')\n",
-    "fig.subplots_adjust(hspace=0.1,wspace=.35)\n",
-    "ax_flat[0].set_xlabel(r'True $x$ [kpc]',fontsize=15)\n",
-    "ax_flat[0].set_ylabel(r'Predicted $x$',fontsize=15)\n",
-    "\n",
-    "ax_flat[1].set_xlabel(r'True $y$ [kpc]',fontsize=15)\n",
-    "ax_flat[1].set_ylabel(r'Predicted $y$',fontsize=15)\n",
-    "\n",
-    "ax_flat[2].set_xlabel(r'True $z$ [kpc]',fontsize=15)\n",
-    "ax_flat[2].set_ylabel(r'Predicted $z$',fontsize=15)\n",
-    "\n",
-    "ax_flat[3].set_xlabel(r'True $v_x$ [kpc/Myr]',fontsize=15)\n",
-    "ax_flat[3].set_ylabel(r'Predicted $v_x$',fontsize=15)\n",
-    "\n",
-    "ax_flat[4].set_xlabel(r'True $v_y$ [kpc/Myr]',fontsize=15)\n",
-    "ax_flat[4].set_ylabel(r'Predicted $v_y$',fontsize=15)\n",
-    "\n",
-    "ax_flat[5].set_xlabel(r'True $v_z$ [kpc/Myr]',fontsize=15)\n",
-    "ax_flat[5].set_ylabel(r'Predicted $v_z$',fontsize=15)\n",
-    "\n",
-    "# Add a colorbar on the right of the subplots\n",
-    "cax = fig.add_axes([0.91, 0.14, 0.02, 0.73])  # Adjust the position and size of the colorbar\n",
-    "cbar = plt.colorbar(ax_flat[dim].scatter(true_wf[:,dim], predicted_wf[:-1,dim],c=a_arr[1:],s=20,cmap=cmr.guppy), cax=cax, orientation='vertical')\n",
-    "cbar.set_label('$\\Phi$ Scale Radius [kpc]',fontsize=20)  # Set the label for the colorbar\n",
-    "##plt.savefig('TaylorExpansion_PotentialFinalSnap.pdf',bbox_inches='tight')\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 42,
-   "id": "a0034bd4-1132-4f61-b79e-21958cd81027",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "w0 = jnp.array([20, 0, 0, -.01, .104, -.03])\n",
-    "t0 = 0\n",
-    "dt = 0.1\n",
-    "n_steps = 20000\n",
-    "ts = np.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "params = {'m': 5e11, 'a': 10.}\n",
-    "pot = Hernquist(m=params['m'], a=params['a'],units=usys,)\n",
-    "\n",
-    "    \n",
-    "\n",
-    "pos_disp = 0.01 #kpc   \n",
-    "vel_dis = (20*u.km/u.s).to(u.kpc/u.Myr).value\n",
-    "    \n",
-    "\n",
-    "key = random.PRNGKey(0)  # Initialize a random key\n",
-    "num_orbits = 5000\n",
-    "ndim = 3\n",
-    "\n",
-    "pos_samps = np.random.normal(loc=0,scale=pos_disp,size=(num_orbits,3))\n",
-    "vel_samps = np.random.normal(loc=0,scale=vel_dis,size=(num_orbits,3))\n",
-    "\n",
-    "\n",
-    "pos0 = pos_samps + w0[:3]\n",
-    "vel0 = vel_samps + w0[3:]\n",
-    "w0 = jnp.hstack([pos0,vel0])\n",
-    "\n",
-    "orbs = []\n",
-    "final_snap = jnp.zeros((num_orbits,6))\n",
-    "for i in range(len(w0)):\n",
-    "    wcurr = w0[i]\n",
-    "    ws_jax = leapfrog_run(wcurr, ts, pot.gradient)\n",
-    "    orbs.append(ws_jax)\n",
-    "    \n",
-    "    final_snap = final_snap.at[i].set(ws_jax[-1,:])\n",
-    "    \n",
-    "    \n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 43,
-   "id": "fff9873f-7408-464a-be32-3da8d8b8541b",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7fb2096bd8e0>"
-      ]
-     },
-     "execution_count": 43,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.scatter(final_snap[:,0],final_snap[:,1],rasterized=True,s=0.5)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 51,
-   "id": "d77abde0-50ce-4f6b-8b93-8a5f988bd431",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "gala_pot = gp.HernquistPotential(m=params['m'],c=params['a'],units=usys)\n",
-    "H = gp.Hamiltonian(gala_pot)\n",
-    "w_test = gd.PhaseSpacePosition(pos=w0[0][:3]*u.kpc,vel=w0[0][3:]*u.kpc/u.Myr)\n",
-    "orb_gala = H.integrate_orbit(w_test,dt=dt*u.Myr,n_steps=20000)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 56,
-   "id": "1cff0a97-f1c2-4fd2-b0d0-0fcefb3de8a0",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7fb326dcb310>]"
-      ]
-     },
-     "execution_count": 56,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.plot(orb_gala.pos.x,orb_gala.pos.z)\n",
-    "plt.plot(orbs[0][:,0],orbs[0][:,2],color='r',ls='--')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 54,
-   "id": "a056b072-a286-4563-aa07-1814cc728556",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(20001, 6)"
-      ]
-     },
-     "execution_count": 54,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "e4726938-c3eb-4ee9-bd97-0038e8cb7d87",
-   "metadata": {},
-   "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.8.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/stream_integrator_static_time_dep.ipynb b/stream_integrator_static_time_dep.ipynb
deleted file mode 100644
index 492bf040..00000000
--- a/stream_integrator_static_time_dep.ipynb
+++ /dev/null
@@ -1,3147 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "1852a7c2-779f-4ceb-98c6-8916dbdee6a6",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u001b[91mA new version of galpy (1.9.0) is available, please upgrade using pip/conda/... to get the latest features and bug fixes!\u001b[0m\n"
-     ]
-    }
-   ],
-   "source": [
-    "from functools import partial\n",
-    "\n",
-    "from astropy.constants import G\n",
-    "import astropy.coordinates as coord\n",
-    "import astropy.units as u\n",
-    "import matplotlib as mpl\n",
-    "import matplotlib.pyplot as plt\n",
-    "%matplotlib inline\n",
-    "import numpy as np\n",
-    "\n",
-    "# gala\n",
-    "import gala.coordinates as gc\n",
-    "import gala.dynamics as gd\n",
-    "import gala.potential as gp\n",
-    "from gala.units import dimensionless, galactic, UnitSystem\n",
-    "\n",
-    "import jax\n",
-    "import jax.numpy as jnp\n",
-    "\n",
-    "from jax.config import config\n",
-    "config.update(\"jax_enable_x64\", True)\n",
-    "\n",
-    "import scienceplots\n",
-    "import cmasher as cmr\n",
-    "plt.style.use('science')\n",
-    "import jax.random as random \n",
-    "from matplotlib.patches import Ellipse\n",
-    "\n",
-    "usys = UnitSystem(u.kpc, u.Myr, u.Msun, u.radian)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 103,
-   "id": "be2a7229-dedd-49d5-b868-83497bb67b39",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array([-1.00638800e-17,  3.17665665e-17,  1.00000000e+00], dtype=float64)"
-      ]
-     },
-     "execution_count": 103,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "class Potential:\n",
-    "    \n",
-    "    def __init__(self, units, params):\n",
-    "        if units is None:\n",
-    "            units = dimensionless\n",
-    "        self.units = UnitSystem(units)\n",
-    "        \n",
-    "        if self.units == dimensionless:\n",
-    "            self._G = 1\n",
-    "        else:\n",
-    "            self._G = G.decompose(self.units).value\n",
-    "        \n",
-    "        for name, param in params.items():\n",
-    "            if hasattr(param, 'unit'):\n",
-    "                param = param.decompose(self.units).value\n",
-    "            setattr(self, name, param)\n",
-    "    \n",
-    "    @partial(jax.jit, static_argnums=(0,))\n",
-    "    def gradient(self, xyz, t):\n",
-    "        grad_func = jax.grad(self.potential)\n",
-    "        return grad_func(xyz, t)\n",
-    "    \n",
-    "    @partial(jax.jit, static_argnums=(0,))\n",
-    "    def density(self, xyz, t):\n",
-    "        lap = jnp.trace(jax.hessian(self.potential)(xyz, t))\n",
-    "        return lap / (4 * jnp.pi * self._G)\n",
-    "    \n",
-    "    @partial(jax.jit, static_argnums=(0,))\n",
-    "    def acceleration(self, xyz, t):\n",
-    "        return -self.gradient(xyz, t)\n",
-    "    \n",
-    "   \n",
-    "    @partial(jax.jit,static_argnums=(0,))\n",
-    "    def jacobian_force_mw(self, xyz, t):\n",
-    "        jacobian_force_mw = jax.jacfwd(self.gradient)\n",
-    "        return jacobian_force_mw(xyz, t)\n",
-    "    \n",
-    "    @partial(jax.jit,static_argnums=(0,))\n",
-    "    def d2phidr2_mw(self, x, t):\n",
-    "        \"\"\"\n",
-    "        Computes the second derivative of the Milky Way potential at a position x (in the simulation frame)\n",
-    "        Args:\n",
-    "          x: 3d position (x, y, z) in [kpc]\n",
-    "        Returns:\n",
-    "          Second derivative of force (per unit mass) in [1/Myr^2]\n",
-    "        Examples\n",
-    "        --------\n",
-    "        >>> d2phidr2_mw(x=jnp.array([8.0, 0.0, 0.0]))\n",
-    "        \"\"\"\n",
-    "        rad = jnp.linalg.norm(x)\n",
-    "        r_hat = x/rad\n",
-    "        dphi_dr_func = lambda x: jnp.sum(self.gradient(x,t)*r_hat)\n",
-    "        return jnp.sum(jax.grad(dphi_dr_func)(x)*r_hat)\n",
-    "        \n",
-    "        ##return jnp.matmul(jnp.transpose(x), jnp.matmul(self.jacobian_force_mw(x, t), x)) / rad**2\n",
-    "\n",
-    "\n",
-    "    @partial(jax.jit,static_argnums=(0,))\n",
-    "    def omega(self, x,v):\n",
-    "        \"\"\"\n",
-    "        Computes the magnitude of the angular momentum in the simulation frame\n",
-    "        Args:\n",
-    "          x: 3d position (x, y, z) in [kpc]\n",
-    "          v: 3d velocity (v_x, v_y, v_z) in [kpc/Myr]\n",
-    "        Returns:\n",
-    "          Magnitude of angular momentum in [rad/Myr]\n",
-    "        Examples\n",
-    "        --------\n",
-    "        >>> omega(x=jnp.array([8.0, 0.0, 0.0]), v=jnp.array([8.0, 0.0, 0.0]))\n",
-    "        \"\"\"\n",
-    "        rad = jnp.sqrt(x[0] ** 2 + x[1] ** 2 + x[2] ** 2)\n",
-    "        omega_vec = jnp.cross(x, v) / (rad**2)\n",
-    "        return jnp.linalg.norm(omega_vec)\n",
-    "\n",
-    "    @partial(jax.jit,static_argnums=(0,))\n",
-    "    def tidalr_mw(self, x, v, Msat, t):\n",
-    "        \"\"\"\n",
-    "        Computes the tidal radius of a cluster in the potential\n",
-    "        Args:\n",
-    "          x: 3d position (x, y, z) in [kpc]\n",
-    "          v: 3d velocity (v_x, v_y, v_z) in [kpc/Myr]\n",
-    "          Msat: Cluster mass in [Msol]\n",
-    "        Returns:\n",
-    "          Tidal radius of the cluster in [kpc]\n",
-    "        Examples\n",
-    "        --------\n",
-    "        >>> tidalr_mw(x=jnp.array([8.0, 0.0, 0.0]), v=jnp.array([8.0, 0.0, 0.0]), Msat=1e4)\n",
-    "        \"\"\"\n",
-    "        return (self._G * Msat / ( self.omega(x, v) ** 2 - self.d2phidr2_mw(x, t)) ) ** (1.0 / 3.0)\n",
-    "    \n",
-    "    @partial(jax.jit,static_argnums=(0,))\n",
-    "    def lagrange_pts(self,x,v,Msat, t):\n",
-    "        r_tidal = self.tidalr_mw(x,v,Msat, t)\n",
-    "        r_hat = x/jnp.linalg.norm(x)\n",
-    "        L_close = x - r_hat*r_tidal\n",
-    "        L_far = x + r_hat*r_tidal\n",
-    "        return L_close, L_far\n",
-    "    \n",
-    "    @partial(jax.jit,static_argnums=(0,))\n",
-    "    def release_model(self, x, v, Msat, pos_disp, vel_disp,i, t):\n",
-    "        \"\"\"\n",
-    "        Simplification of particle spray: just release particles in gaussian blob at each lagrange point.\n",
-    "        User sets the spatial and velocity dispersion for the \"leaking\" of particles\n",
-    "        TODO: change random key handling... need to do all of the sampling up front...\n",
-    "        \"\"\"\n",
-    "        keya = jax.random.PRNGKey(i*13)\n",
-    "        keyb = jax.random.PRNGKey(i*23)\n",
-    "        \n",
-    "        keyc = jax.random.PRNGKey(i*27)\n",
-    "        keyd = jax.random.PRNGKey(i*3)\n",
-    "        keye = jax.random.PRNGKey(i*17)\n",
-    "        \n",
-    "        L_close, L_far = self.lagrange_pts(x,v,Msat, t) # each is an xyz array\n",
-    "        \n",
-    "        omega_val = self.omega(x,v)\n",
-    "        \n",
-    "        \n",
-    "        r = jnp.linalg.norm(x)\n",
-    "        r_hat = x/r\n",
-    "        r_tidal = self.tidalr_mw(x,v,Msat, t)\n",
-    "        rel_v = omega_val*r_tidal #relative velocity\n",
-    "        \n",
-    "        #circlar_velocity\n",
-    "        dphi_dr = jnp.sum(self.gradient(x, t)*r_hat)\n",
-    "        v_circ = rel_v##jnp.sqrt( r*dphi_dr )\n",
-    "        \n",
-    "        L_vec = jnp.cross(x,v)\n",
-    "        z_hat = L_vec / jnp.linalg.norm(L_vec)\n",
-    "        \n",
-    "        phi_vec = v - jnp.sum(v*r_hat)*r_hat\n",
-    "        phi_hat = phi_vec/jnp.linalg.norm(phi_vec)\n",
-    "        vt_sat = jnp.sum(v*phi_hat)\n",
-    "        \n",
-    "        \n",
-    "        kr_bar = 2.0\n",
-    "        kvphi_bar = 0.3\n",
-    "        ####################kvt_bar = 0.3 ## FROM GALA\n",
-    "        \n",
-    "        kz_bar = 0.0\n",
-    "        kvz_bar = 0.0\n",
-    "        \n",
-    "        sigma_kr = 0.5\n",
-    "        sigma_kvphi = 0.5\n",
-    "        sigma_kz = 0.5\n",
-    "        sigma_kvz = 0.5\n",
-    "        ##############sigma_kvt = 0.5 ##FROM GALA\n",
-    "        \n",
-    "        kr_samp =  kr_bar + jax.random.normal(keya,shape=(1,))*sigma_kr\n",
-    "        kvphi_samp = kr_samp*(kvphi_bar  + jax.random.normal(keyb,shape=(1,))*sigma_kvphi)\n",
-    "        kz_samp = kz_bar + jax.random.normal(keyc,shape=(1,))*sigma_kz\n",
-    "        kvz_samp = kvz_bar + jax.random.normal(keyd,shape=(1,))*sigma_kvz\n",
-    "        ########kvt_samp = kvt_bar + jax.random.normal(keye,shape=(1,))*sigma_kvt\n",
-    "        \n",
-    "        ## Trailing arm\n",
-    "        pos_trail = x + kr_samp*r_hat*(r_tidal) #nudge out\n",
-    "        pos_trail  = pos_trail + z_hat*kz_samp*(r_tidal/1.0)#r #nudge above/below orbital plane\n",
-    "        v_trail = v + (0.0 + kvphi_samp*v_circ*(1.0))*phi_hat#v + (0.0 + kvphi_samp*v_circ*(-r_tidal/r))*phi_hat #nudge velocity along tangential direction\n",
-    "        v_trail = v_trail + (kvz_samp*v_circ*(1.0))*z_hat#v_trail + (kvz_samp*v_circ*(-r_tidal/r))*z_hat #nudge velocity along vertical direction\n",
-    "        \n",
-    "        ## Leading arm\n",
-    "        pos_lead = x + kr_samp*r_hat*(-r_tidal) #nudge in\n",
-    "        pos_lead  = pos_lead + z_hat*kz_samp*(-r_tidal/1.0)#r #nudge above/below orbital plane\n",
-    "        v_lead = v + (0.0 + kvphi_samp*v_circ*(-1.0))*phi_hat#v + (0.0 + kvphi_samp*v_circ*(r_tidal/r))*phi_hat #nudge velocity along tangential direction\n",
-    "        v_lead = v_lead + (kvz_samp*v_circ*(-1.0))*z_hat#v_lead + (kvz_samp*v_circ*(r_tidal/r))*z_hat #nudge velocity against vertical direction\n",
-    "        \n",
-    "    \n",
-    "        \n",
-    "        ###print(L_close, L_far)\n",
-    "        #pos_release_close = L_close + jax.random.normal(keya,shape=(3,))*pos_disp\n",
-    "        ##pos_release_far = L_far + jax.random.normal(keyb,shape=(3,))*pos_disp\n",
-    "        \n",
-    "        #DeltaR_r = jnp.sqrt(jnp.sum((L_far - L_close)**2))/jnp.linalg.norm(x)\n",
-    "        \n",
-    "        ##vel_release_close = v + jax.random.normal(keyc,shape=(3,))*vel_disp\n",
-    "        ##vel_release_far = v  + jax.random.normal(keyd,shape=(3,))*vel_disp\n",
-    "        \n",
-    "        return pos_lead, pos_trail, v_lead, v_trail\n",
-    "    \n",
-    "    @partial(jax.jit,static_argnums=(0,))\n",
-    "    def gen_stream_ics(self, ts, prog_w0, Msat, pos_disp, vel_disp):\n",
-    "        ws_jax = leapfrog_run(prog_w0, ts, self.gradient)\n",
-    "        \n",
-    "        def scan_fun(carry, t):\n",
-    "            i, pos_close, pos_far, vel_close, vel_far = carry\n",
-    "            pos_close_new, pos_far_new, vel_close_new, vel_far_new = self.release_model(ws_jax[i,:3], ws_jax[i,3:], M_sat, pos_disp, vel_disp,i, t)\n",
-    "            return [i+1, pos_close_new, pos_far_new, vel_close_new, vel_far_new], [pos_close_new, pos_far_new, vel_close_new, vel_far_new]#[i+1, pos_close_new, pos_far_new, vel_close_new, vel_far_new]\n",
-    "            \n",
-    "            \n",
-    "        #init_carry = [0, 0, 0, 0, 0]\n",
-    "        init_carry = [0, jnp.array([0.0,0.0,0.]), jnp.array([0.0,0.0,0.]), jnp.array([0.0,0.0,0.]), jnp.array([0.0,0.0,0.])] \n",
-    "        final_state, all_states = jax.lax.scan(scan_fun, init_carry, ts[1:])\n",
-    "        pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr = all_states\n",
-    "        return pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr\n",
-    "    \n",
-    "    @partial(jax.jit,static_argnums=(0,))\n",
-    "    def gen_stream(self, ts, prog_w0, Msat, pos_disp, vel_disp):\n",
-    "        pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr = self.gen_stream_ics(ts, prog_w0, Msat, pos_disp, vel_disp)\n",
-    "        \n",
-    "        def scan_fun(carry, particle_idx):\n",
-    "            i, pos_close_curr, pos_far_curr, vel_close_curr, vel_far_curr = carry\n",
-    "            curr_particle_w0_close = jnp.hstack([pos_close_curr,vel_close_curr])\n",
-    "            curr_particle_w0_far = jnp.hstack([pos_far_curr,vel_far_curr])\n",
-    "            #print(curr_particle_w0_close.shape)\n",
-    "            #indices = jnp.arange(i,len(ts))\n",
-    "            #t_particle = jnp.take(ts, indices)\n",
-    "            #################t_particle = jax.lax.slice(ts,(i,),(len(ts),))\n",
-    "            w_particle_close = leapfrog_run(curr_particle_w0_close, ts, self.gradient)\n",
-    "            w_particle_far = leapfrog_run(curr_particle_w0_far, ts, self.gradient)\n",
-    "            \n",
-    "            ###ts_update = jax.lax.dynamic_slice(ts_curr,(i+1,),(len(ts_curr)-1,))\n",
-    "            \n",
-    "            return [i+1, pos_close_arr[i+1,:], pos_far_arr[i+1,:], vel_close_arr[i+1,:], vel_far_arr[i+1,:]], [w_particle_close, w_particle_far]\n",
-    "        init_carry = [0, pos_close_arr[0,:], pos_far_arr[0,:], vel_close_arr[0,:], vel_far_arr[0,:]]\n",
-    "        particle_ids = jnp.arange(len(pos_close_arr))\n",
-    "        final_state, all_states = jax.lax.scan(scan_fun, init_carry, particle_ids)\n",
-    "        lead_arm, trail_arm = all_states\n",
-    "        return lead_arm, trail_arm\n",
-    "            \n",
-    "    @partial(jax.jit,static_argnums=(0,))\n",
-    "    def gen_stream_final(self, ts, prog_w0, Msat, pos_disp, vel_disp):\n",
-    "        pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr = self.gen_stream_ics(ts, prog_w0, Msat, pos_disp, vel_disp)\n",
-    "        \n",
-    "        def scan_fun(carry, particle_idx):\n",
-    "            i, pos_close_curr, pos_far_curr, vel_close_curr, vel_far_curr = carry\n",
-    "            curr_particle_w0_close = jnp.hstack([pos_close_curr,vel_close_curr])\n",
-    "            curr_particle_w0_far = jnp.hstack([pos_far_curr,vel_far_curr])\n",
-    "            #print(curr_particle_w0_close.shape)\n",
-    "            #indices = jnp.arange(i,len(ts))\n",
-    "            #t_particle = jnp.take(ts, indices)\n",
-    "            \n",
-    "            #######t_particle = jax.lax.slice(ts,(i,),(len(ts),))\n",
-    "            minval, maxval =  ts[i],ts[-1]#jnp.min(jax.lax.dynamic_slice(ts,(i,),(len(ts)-i,))), jnp.max(jax.lax.dynamic_slice(ts,(i,),(len(ts)-i,)))\n",
-    "            ###t_particle = ts.at[:i].set( jnp.nan )\n",
-    "            #######################t_particle = jnp.linspace(minval,maxval,len(ts))#jax.lax.dynamic_slice(ts,minval,(len(ts)-i,))##jax.lax.dynamic_slice(ts,(i+1,),(len(ts)-1,))\n",
-    "            t_particle = get_t_arr(ts,ts[i])\n",
-    "            ##print(t_particle)\n",
-    "            w_particle_close = leapfrog_run(curr_particle_w0_close, t_particle, self.gradient)\n",
-    "            w_particle_far = leapfrog_run(curr_particle_w0_far, t_particle, self.gradient)\n",
-    "            \n",
-    "            w_particle_close = w_particle_close[-1,:]#w_particle_close[-1,:]\n",
-    "            w_particle_far = w_particle_far[-1,:]#w_particle_far[-1,:]\n",
-    "            \n",
-    "            \n",
-    "            \n",
-    "            return [i+1, pos_close_arr[i+1,:], pos_far_arr[i+1,:], vel_close_arr[i+1,:], vel_far_arr[i+1,:]], [w_particle_close, w_particle_far]\n",
-    "        init_carry = [0, pos_close_arr[0,:], pos_far_arr[0,:], vel_close_arr[0,:], vel_far_arr[0,:]]\n",
-    "        particle_ids = jnp.arange(len(pos_close_arr))\n",
-    "        #print(len(particle_ids))\n",
-    "        final_state, all_states = jax.lax.scan(scan_fun, init_carry, particle_ids)\n",
-    "        #print(final_state)\n",
-    "        lead_arm, trail_arm = all_states\n",
-    "        return lead_arm, trail_arm##lead_arm, trail_arm\n",
-    "        \n",
-    "    \n",
-    "class Isochrone(Potential):\n",
-    "    \n",
-    "    def __init__(self, m, a, units=None):\n",
-    "        super().__init__(units, {'m': m, 'a': a})\n",
-    "    \n",
-    "    @partial(jax.jit, static_argnums=(0,))\n",
-    "    def potential(self, xyz, t):\n",
-    "        r = jnp.linalg.norm(xyz, axis=0)\n",
-    "        return - self._G * self.m / (self.a + jnp.sqrt(r**2 + self.a**2))\n",
-    "    \n",
-    "\n",
-    "    \n",
-    "class Isochrone_centered(Potential):\n",
-    "    \n",
-    "    def __init__(self, m, a, spline_eval_func, splines, t_min, t_max, m_ext, a_ext, units=None):\n",
-    "        super().__init__(units, {'m': m, 'a': a, 'spline_eval_func': spline_eval_func, 'splines': splines, 't_min': t_min, 't_max': t_max,\n",
-    "                                'm_ext': m_ext, 'a_ext': a_ext})\n",
-    "    \n",
-    "    @partial(jax.jit, static_argnums=(0,))\n",
-    "    def potential(self, xyz, t):\n",
-    "        is_cond_met = (t > self.t_min) & (t < self.t_max) # True if yes, False if no\n",
-    "        pot_ext = Isochrone(m=self.m_ext, a=self.a_ext, units=self.units) \n",
-    "        \n",
-    "        def true_func(xyz_t):\n",
-    "            xyz_, t = xyz_t[:3], xyz_t[-1]\n",
-    "            xyz = xyz_ - self.spline_eval_func(t,self.splines)\n",
-    "            r = jnp.linalg.norm(xyz, axis=0)\n",
-    "            return - self._G * self.m / (self.a + jnp.sqrt(r**2 + self.a**2))  + pot_ext.potential(xyz_,t)#+ self.pot_ext.potential(xyz_,t)\n",
-    "        def false_func(xyz_t):\n",
-    "            xyz, t = xyz_t[:3], xyz_t[-1]\n",
-    "            return pot_ext.potential(xyz,t)#0.#self.pot_ext.potential(xyz,t)\n",
-    "        xyz_t = jnp.hstack([xyz,t])\n",
-    "        return jax.lax.cond(pred=is_cond_met, true_fun=true_func, false_fun=false_func,operand=xyz_t)\n",
-    "    \n",
-    "    \n",
-    "def leapfrog_step(func, y0, t0, dt, a0):\n",
-    "    ndim = y0.shape[0] // 2\n",
-    "    tf = t0 + dt\n",
-    "    \n",
-    "    x0 = y0[:ndim]\n",
-    "    v0 = y0[ndim:]\n",
-    "    \n",
-    "    v1_2 = v0 + a0 * dt / 2.\n",
-    "    xf = x0 + v1_2 * dt\n",
-    "    af = - func(xf, tf)\n",
-    "    \n",
-    "    vf = v1_2 + af * dt / 2\n",
-    "    \n",
-    "    return tf, jnp.concatenate((xf, vf)), af\n",
-    "\n",
-    "@partial(jax.jit, static_argnames=['potential_gradient', 'args'])\n",
-    "def leapfrog_run(w0, ts, potential_gradient, args=()):\n",
-    "    func_ = lambda y, t: potential_gradient(y, t, *args)\n",
-    "    \n",
-    "    def scan_fun(carry, t):\n",
-    "        i, y0, t0, dt, a0 = carry\n",
-    "        tf, yf, af = leapfrog_step(func_, y0, t0, dt, a0)\n",
-    "        dt_new = ts[i+1] - ts[i]\n",
-    "        is_cond_met = dt_new > 0.\n",
-    "        \n",
-    "        def true_func(dt_new):\n",
-    "            return 0.5 #dt_base\n",
-    "        def false_func(dt_new):\n",
-    "            return 0.0\n",
-    "        dt_new = jax.lax.cond(pred=is_cond_met, true_fun=true_func, false_fun=false_func,operand=dt_new)\n",
-    "        \n",
-    "        ###tf = tf + dt_new\n",
-    "        return [i + 1, yf, tf, dt_new, af], yf\n",
-    "    \n",
-    "    ndim = w0.shape[0] // 2\n",
-    "    a0 = func_(w0[:ndim], ts[0])\n",
-    "    dt = ts[1]-ts[0] ## I ADDED THIS\n",
-    "    init_carry = [0, w0, ts[0], dt, a0]\n",
-    "    _, ws = jax.lax.scan(scan_fun, init_carry, ts[1:])\n",
-    "    res_ws = jnp.concatenate((w0[None], ws))\n",
-    "    \n",
-    "    return res_ws\n",
-    "\n",
-    "def compute_orbit_and_gradients(params,w0,dt,n_steps,units):\n",
-    "    pot = Hernquist(m=params['m'], a=params['a'],units=units,)  # Create the potential with the given parameters\n",
-    "    \n",
-    "    # Example Orbit:\n",
-    "    #w0 = jnp.array([10, 0, 0, 0, .204, 0])\n",
-    "    t0 = 0\n",
-    "    #dt = 0.1\n",
-    "    #n_steps = 10000\n",
-    "    ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "    \n",
-    "    ### Compute the orbit with the provided potential\n",
-    "    ws_jax = leapfrog_run(w0, ts, pot.gradient)\n",
-    "    \n",
-    "    # Compute the gradient of the final position with respect to the potential parameters\n",
-    "    def gradient_fn(params):\n",
-    "        pot_with_params = Hernquist(m=params['m'], a=params['a'],units=units)\n",
-    "        ws_with_params = leapfrog_run(w0, ts, pot_with_params.gradient)\n",
-    "        final_position = ws_with_params[-1, :]  # Extract final position\n",
-    "        return final_position\n",
-    "    \n",
-    "    # Compute the gradient using JAX's autodiff\n",
-    "    gradient = jax.jacfwd(gradient_fn)(params)\n",
-    "    \n",
-    "    return ws_jax, gradient\n",
-    "\n",
-    "def get_stripping_time_arr(ts):\n",
-    "    \"\"\"\n",
-    "    assuming a particle is released for index in the ts array\n",
-    "    TODO: Custom release\n",
-    "    \"\"\"\n",
-    "    t_release_arr = []\n",
-    "    for i in range(len(ts)):\n",
-    "        t_release_arr.append( ts[i:] )\n",
-    "    return t_release_arr\n",
-    "\n",
-    "from jax_cosmo.scipy.interpolate import InterpolatedUnivariateSpline\n",
-    "def get_spl_funcs(ts,ws):\n",
-    "    return [InterpolatedUnivariateSpline(ts,ws[:,i],k=3) for i in range(3)]\n",
-    "\n",
-    "def eval_spl_funcs(ts, spl_funcs):\n",
-    "    return jnp.array([spl_funcs[i](ts) for i in range(3)])\n",
-    "\n",
-    "@jax.jit\n",
-    "def get_t_arr(ts,t_min):\n",
-    "    def scan_fun(carry, t):\n",
-    "        i, ts_curr = carry\n",
-    "        \n",
-    "        def true_func(ts_curr):\n",
-    "            return ts_curr\n",
-    "        def false_func(ts_curr):\n",
-    "            return 0.0\n",
-    "        is_cond_met = ts_curr > t_min\n",
-    "        val_fill = jax.lax.cond(pred=is_cond_met, true_fun=true_func, false_fun=false_func,operand=ts_curr)\n",
-    "        \n",
-    "        return [i + 1,ts[i+1]], val_fill\n",
-    "    init_carry = [0,ts[0]]\n",
-    "    __, t_particle = jax.lax.scan(scan_fun, init_carry, ts)\n",
-    "    return t_particle\n",
-    "\n",
-    "@jax.jit\n",
-    "def get_rot_mat(n_hat):\n",
-    "    \"\"\"\n",
-    "    Get rotation matrix that transforms from INERTIAL coordinates to SATELLITE coordinates\n",
-    "    https://math.stackexchange.com/questions/1956699/getting-a-transformation-matrix-from-a-normal-vector\n",
-    "    \"\"\"\n",
-    "    nx,ny,nz = n_hat\n",
-    "    nx_ny = jnp.sqrt(nx**2 + ny**2)\n",
-    "    return jnp.array([[ny/nx_ny, -nx/nx_ny, 0], [nx*nz/nx_ny, ny*nz/nx_ny, -nx_ny], [nx,ny,nz]])\n",
-    "\n",
-    "LL = jnp.array([1,2,3.])\n",
-    "LL = LL/jnp.linalg.norm(LL)\n",
-    "R_Inertial_to_Sat = get_rot_mat(LL)\n",
-    "R_Sat_to_Inertial = jnp.linalg.inv(R_Inertial_to_Sat)\n",
-    "jnp.matmul(R_Inertial_to_Sat,LL)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "id": "ceab32fd-d57b-4b35-8cd0-bb470e9161bb",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "params = {'m': 1.0e12, 'a': 10.}\n",
-    "pot = Isochrone(m=params['m'], a=params['a'],units=usys,)  \n",
-    "t0 = 0.\n",
-    "dt = 0.5\n",
-    "n_steps = 2_000\n",
-    "w0 = jnp.array([50., 0., 0, (0*u.km/u.s).to(u.kpc/u.Myr).value, (150*u.km/u.s).to(u.kpc/u.Myr).value, (0*u.km/u.s).to(u.kpc/u.Myr).value])\n",
-    "\n",
-    "ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "### Compute the orbit with the provided potential\n",
-    "\n",
-    "t_particle = get_t_arr(ts,200.)\n",
-    "ws_jax = leapfrog_run(w0, t_particle, pot.gradient)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "id": "5247ae94-37b4-4206-8566-5f78e73935a4",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#ws_jax[:100]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "id": "7a65fe31-a435-444a-a565-063a3cd8313e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import gala.integrate as gi\n",
-    "ws_jax_time_dep = leapfrog_run(w0, ts, pot.gradient)\n",
-    "pot_gala = gp.IsochronePotential(m=1.0e12*u.Msun,b=10*u.kpc,\n",
-    "                                              units=galactic)\n",
-    "H = gp.Hamiltonian(pot_gala)\n",
-    "prog_w0 = gd.PhaseSpacePosition(pos=[50, 0, 0.] * u.kpc, vel=[0, 150, 0.] * u.km/u.s)\n",
-    "o_gala = H.integrate_orbit(prog_w0,t=ts*u.Myr,Integrator=gi.LeapfrogIntegrator)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 28,
-   "id": "87e5d4ca-3d4e-441e-ba7f-670041891f2a",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7fd8e97ea040>]"
-      ]
-     },
-     "execution_count": 28,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.plot(o_gala.pos.x,o_gala.pos.y)\n",
-    "plt.plot(ws_jax[:,0],ws_jax[:,1],color='r')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "469ca6d7-0cc8-4b21-9536-db4ed1a154fd",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "params = {'m': 1.0e12, 'a': 10.}\n",
-    "pot = Isochrone(m=params['m'], a=params['a'],units=usys,)  \n",
-    "t0 = 0.\n",
-    "dt = 0.5\n",
-    "n_steps = 2_000\n",
-    "w0 = jnp.array([50., 0., 0, (0*u.km/u.s).to(u.kpc/u.Myr).value, (150*u.km/u.s).to(u.kpc/u.Myr).value, (0*u.km/u.s).to(u.kpc/u.Myr).value])\n",
-    "\n",
-    "\n",
-    "w0_subhalo =  jnp.array([45., 0., 0, (0*u.km/u.s).to(u.kpc/u.Myr).value, (250*u.km/u.s).to(u.kpc/u.Myr).value, (0*u.km/u.s).to(u.kpc/u.Myr).value])\n",
-    "\n",
-    "\n",
-    "ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "### Compute the orbit with the provided potential\n",
-    "ws_jax = leapfrog_run(w0_subhalo, ts, pot.gradient)\n",
-    "\n",
-    "M_sat = 1.0e4 # TODO: mass loss rate\n",
-    "pos_disp = .00\n",
-    "vel_disp = (5*u.km/u.s).to(u.kpc/u.Myr).value\n",
-    "\n",
-    "\n",
-    "splines = get_spl_funcs(ts, ws_jax)\n",
-    "spline_evals = eval_spl_funcs(ts[3], splines)\n",
-    "\n",
-    "\n",
-    "params_total = {'m': 1.0, 'a': 1.0, 'spline_eval_func': eval_spl_funcs, 'splines': splines, 't_min': 0., 't_max': 50000.,\n",
-    "         'm_ext': params['m'], 'a_ext': params['a']}\n",
-    "\n",
-    "pot = Isochrone_centered(m=params_total['m'], a=params_total['a'],\n",
-    "                         spline_eval_func=params_total['spline_eval_func'],\n",
-    "                         splines=params_total['splines'],\n",
-    "                         t_min=params_total['t_min'],\n",
-    "                         t_max = params_total['t_max'],\n",
-    "                         m_ext = params_total['m_ext'],\n",
-    "                         a_ext = params_total['a_ext'],\n",
-    "                         units=usys,)  \n",
-    "\n",
-    "\n",
-    "ws_jax_time_dep = leapfrog_run(w0, ts, pot.gradient)\n",
-    "\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "d7346de3-2f13-48fd-bf80-b6fbd4a06545",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "ws_jax_time_dep = leapfrog_run(w0, ts, pot.gradient)\n",
-    "pot_gala = gp.IsochronePotential(m=1.0e12*u.Msun,b=10*u.kpc,\n",
-    "                                              units=galactic)\n",
-    "H = gp.Hamiltonian(pot_gala)\n",
-    "prog_w0 = gd.PhaseSpacePosition(pos=[50, 0, 0.] * u.kpc, vel=[0, 150, 0.] * u.km/u.s)\n",
-    "o_gala = H.integrate_orbit(prog_w0,dt=0.5*u.Myr,n_steps=n_steps)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "22318a0b-9f5c-4785-a34c-fd6ac3569ffa",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 576x576 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig, ax = plt.subplots(1,1)\n",
-    "fig.set_size_inches(8,8)\n",
-    "ax.plot(ws_jax_time_dep[:,0],ws_jax_time_dep[:,1],lw=3,color='k',label='jax')\n",
-    "ax.plot(o_gala.x,o_gala.y,color='r',lw=3,ls='--',label='gala')\n",
-    "ax.legend(fontsize=20)\n",
-    "ax.set_xlabel('x',fontsize=15)\n",
-    "ax.set_ylabel('y',fontsize=15)\n",
-    "ax.set_aspect('equal')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "00be926f-fcfd-4aad-bf6a-de74e118d7ad",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr = pot.gen_stream_ics(ts, w0, M_sat, pos_disp, vel_disp)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "c96571aa-16fa-4cc4-959e-e698aeaf81a9",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 576x576 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig, ax = plt.subplots(1,1)\n",
-    "fig.set_size_inches(8,8)\n",
-    "\n",
-    "ax.scatter(pos_close_arr[:,0],pos_close_arr[:,1],lw=3,color='b',label='leading arm ICs',s=0.5,)\n",
-    "ax.scatter(pos_far_arr[:,0],pos_far_arr[:,1],lw=3,color='r',label='trailing arm ICs',s=0.5,)\n",
-    "ax.legend(fontsize=20,frameon=True)\n",
-    "ax.set_xlabel('x',fontsize=15)\n",
-    "ax.set_ylabel('y',fontsize=15)\n",
-    "ax.set_aspect('equal')\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "f657a7aa-67f7-4180-be17-45a0a974296d",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWwAAAHXCAYAAACYkmAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAB2hUlEQVR4nO3deXhU5dnH8e+ZLfueAcJuAENAXAIouKDWUK2CFgxSrW19rYK11WqtUPWtxbqCb12qrZKqtVpQCy4tCNVERWwEi6CiMqxh33ImyWSfzPa8f8xCEgIkZJlM5v5cF1dyZiZnnkPCjyf3eRZNKYUQQoiezxDuBgghhGgbCWwhhIgQpnA34GTcdNNNauDAgUc9vmvXLoYOHdqmc7TntXJuObecW84drnM/8MADLyqlbgJAKRVxf373u9+p1hzr8Y6+Vs4t55Zzy7nDdW5gngpkX68qiVx00UVd8tqTeX1Xnbsr291TrrG9r5fvZcfP3VXtaO/r5Xt5AioMPeSO/mnv/2bd7aOPPgp3E7pFNFxnNFyjUtFxnZF6jfTWHnZP0ZX/6/ck0XCd0XCNEB3X2RuuUQJbCCEihAS2EEJECAlsIYSIEBLYQggRISSwhRAiQkTkTEcRORobG6moqKCmpgav1xvu5ggRVkajkaSkJNLT04mJiWn310dkYO/atYt58+Zx0UUX9YqhOr1VY2Mje/bsIS0tjaFDh2I2m9E0LdzNEiIslFK43W6qq6vZs2cPgwcPPmFor1q1CmBo8DgiA3vo0KHMmzcv3M0QJ1BRUUFaWhqZmZnhbooQYadpGhaLJfTvoaKigqysrON+TaBDuit4LDVs0WVqampITk4OdzOE6HGSk5Opqalp99dJYIsu4/V6MZvN4W6GED2O2Ww+qXs6EtiiS0nNWoijney/CwlsIYSIEBLYQggRISSwRY/mdoPdDuWH3XjslXhqG6jZZae61E75YTfOWjfVuyux72ugenclTof/Y+XBBlyHKyk/7ObwYTh82H+ehgaorPSft6uVlpYyefLkbikLORwOZsyYQVpaGqWlpc3asGDBgi5//0gxd+5cxo4di6ZpzJ49m+Li4lZft2HDBmbMmMGMGTOYO3cuc+fOZenSpaHnjvV1XS0ih/WJyOR2Q1WV//OUFP/H2lpIMjdgKi/Da7TQ4DKgfP7nfApq6ozUaQkM9OxGN6TQx7uTWAwoDMRUHMSLAZ8WQ7qqwm7oQ4K+k0YtiRRVjU4fUtmHnUx8GDAYoFYZiUlPoG53HSmJXmISjNSRgNboxB2TiM9gxmhs3r7ERDiZe6fZ2dkUFRV1S2CnpqayZMkS0tLSmj1eXFzMwoULmTNnTpe3IRLMnz+fwsJC5s6dy8KFC1t9zYIFCygqKmLhwoVkZ2eHHi8tLaWwsJAlS5Ywd+7c7mpyMxLYoksFQ9rrhfJy/0ejctOwrwqj8pIQ50OrPYhX0zAoL/E0D7d4jACUa1bMXicAPgyYcePGTCxOYlQjCo10n45CI1FVo9CwUoYPA1kcIPCF+DCilfvwYsTk8OB1GEnGRzXJJAfC3WMwcBAjdeYU4uOgbncVmZngjE0hJsGM03nyId7V0tPTmx3PmjWLWbNmhak1kScY1kVFRUc9l52dTX5+PrNnz5bAFpFN12H1apg0CazoVC1bTe3IERz+1o4CnCoWq68cLBYSXJUY8WDGja/WH9BuZcSIhoZCBULbiBcjXhQafdQhqrUUNKUw4UGhhT56MGHGjQczZlw0EkssTjyYMODFjRkDvsC5wIBCYQi9jwEfyVSj4fOHuw+8GPE0HsLQqAAFhzTiTGWUeTOITzKyfV8KqZlmzGZ/b7wnhrdon9LSUubOncuOHTuO+Zrs7Oyw/gcYkTXs4NT0wLRNEUa6Dk8/DRMnwuZPdJ48/SUcEy7l41++RXz1Qfp69tHXs5/h3s2kqQoyGg9gxoUHM07icBGLhsKMBxOeULAa8YTCW2Gg2pCCR7Pg1OKoNSSjoag0WtE0f+D6DGbQNLymWEx48GDGiBcfJiy4MeEBFAZNAWDCHTizv/7iwwBoeAM9eh8GYvD36I348GpGjJ5GstQBkqoPkN24Gd/+gzj3HKbsm8M4tvtr6t1RGxddY+7cueTl5TUrg7Rm8uTJ3dQimZouOomuw9uFOtufWkZy3UHmebYz6umvcPTLJbZ0E8PjABQ+DIEANeHTjHg1A0ZfIxYaMQZ6v43EUkcCbkMMPoOBxAR/SMbW6mjKh9FkINnkpjJjCA1AqrEWQ+JA0mobqPFaSaQWoxFITPHXxL3+QnkNiSRSi4YXfD7Q7bgtCZg9Thpi0jBX2fHGxhHjrMZgAM1HoNfu/+jDiAEvBjzEKi8aCicxxNCICpZaAvV2t8OM5jhA7f5EvLEJeJPTMcaaQ7XwlgoLC0Pli3Xr1jF79uxmQRG8wVVRUcGOHTuYP3/+UecI3vwKfl3LoCktLQ3dWPNvDej/mrlz51JcXExlZWXo5tm6desYP348BQUFzc6xdOlSKioqgObllmCN90SOdx3BtpSWllJUVERxcTFFRUXMnj2b9PT0VttZVFTE5MmTKSgoCJ07eJO1o3X64uLiNvWeCwoKcDgcoetLTU0F/Dd+i4qKmD9/fuixjmo5NT0iA1t0P12HosU61s+W4auqYeOntRRUvcgU5aQvh2ggHhNu3tcH02hOJKaxmkZoVr7wodB8PoiNpT7ev56CJc5IvSEFL2bMxhblBXdm6C6llpJCRugJ/401Y2ws/jyMBfw/zKmxAP5zN30OQMvMJCZwFzHRbMbjzMRtr0WlDsTkrPUX2H0+lG6nUYsjzl1NY0wSWkMtXlMMRo+TGFyABqhQqSX4n5IBH6m+ClR9Je76wzgM6VThn82mb60krk8ibmXm+ecXYDQSCoeCggKGDRvG+vXrSU1Npbi4uFlPb+nSpUyePLlZXbW4uJj58+cf9VjTESKt3fTMy8sLPVZcXBwK6IKCAjRNCwV78H2bBvPs2bMZO3Yss2bNOirYW3Oi68jLy2PJkiWccsopbNiwgVmzZuFwOHA4HOTn5x+3nUVFRc3aMGzYMAoKCk7YOz4eh8NBRkZGm14b/D6lpqaSn58fery12ndnksAWrQrWpMf009n9p2V8ufIgM6pfxOhzYcXOxXhxEYMBL4fph8sQQ7rPzqi+FRgONFJ36hkY0XDHJRPja8A7IBuPvQpzUgzGzHQSmxR9j/lPxGyGNi4c1ayGbj3O+ZqMojDFmkkcGDhOPBLshsxM4mtrIW4gsbW1+MrcuGNTsTgO4o5NxtxQjdJMmH3++ocxEMrBeropUJ/v4zsUKrFYqu2YqvdxwJjGvffOpeyAC7v9yH9Q+fn5/OMf/2DWrFksWbIEIBSUBQUFzJgxo9mlzJ49O/S6oPz8/Hb17FqGW3Z2Nhs2bCAvLw+ARx99lHvuuSf0/IwZM5g9e3aba7htuY7U1FQcDkeoLa31kltrZ9P/mJq2vSOB3V4bNmwAaBbYLa+vs0lgi+Z0nX2LVzPjmUlMmWjn9L9fSS4NXEgZLiz+lxj64vNppFOOwkA/DtIYk4YFRe1lMzDM+Av1H35LUr8sYvtnQGIiJrMZU/ox6gMdbzLTpsHMmf6P77zT5pxvXdNgj43FkJJCXG0t9B+FpaEB4gZhrK3F6/bS0AB4/eUbg9eNGX+I+9DwYEbD32NNwj9y5cv3F5GSlMy6t17mkKk/XkMMyclw8GAF69atZ9Ysfy01+Ct3UDDYUlNTKS0tpbS0NBSsJ6st4daRX+1PdB1NHe9aWmvnuHHjjjpvsHRzslJTUykvL2/z6wsKChg7dixFRUXMmDGD/Pz8ZuHdFSSwRYjdpuO6YhpLDl/Ics8vqNlhwW7uT1/3t+zQRjBQ7QEUfX0H8GGgwtCH+DQL6ifXktjogNtu48ycHACyL8vBZrM169F2ldWr/WEdGwvXXOM/nj69E9+gRYAHPxqBxOBr3Jl47RU0VtZhctb6b6T63IGbmaDAf6O0qoqM5CQuPWcsHozUkEw98Zzx+1eIVU6qy92kpWVjt29gwYIFpKamkp2d3Sz4gj27jjpRGM+cOZOioqJQCG3YsIHZs2e3+fzBXu+xrqOz2tlZ8vPz2zQhprS0FIfDQV5eHjt37uTRRx9l4cKFod8+2lLbP1kS2FFO12HZMqjarpPx7O/o40zlFvf/cYgsBrIfo9t/w3CY2ord0I+4FAsbz70JQ2oip52TRNK1UzrYne24SZP8PetrroF//MPfw+52ZjPGrL7EZREafO5tdOOuaQy8wN/Xzh4wgIrqagAsuEmjknQqUB4oN/TBvHM/j77+Tz7+dBUff1wUquc3Da3u+rU/Pz+fN954g8LCwtBj7bmx19qY5u4K35Mxf/58hg0bRmlp6XH/joM3J4uLi8nPzw/dSA3ONl26dGmbavwnQwI7Wuk6BwqX8doTB+nfsJ1xDZ+TolUzQO2nEQtphmqqfYk09h+GRz+E7bt3c/qlWSRdO4XzetiGBFarP6RXr+6EckhnCNTejRCoYIMhxozLGMcl50wAYOe+vWQPHIgXEybc+DCyZ9NqRo08k8f+8L98+s4aKrfb0VJT0MxmHA4HFRUVoTAJlkZaBsvJ9GCPJXhj82S1Nqa5tevoKbKzs5k/fz6zZ89u083DoqIisrOzQ9+D1NRU5s+fzxtvvNFlgR2R47DFydN1ePNhG+Ujz0X77f9yZ8VvmdqwhFw2s4nTWG24CAuN7DGdQkqch9rLZpD89aect/wekm67oQekYesyM/1lkB7aPLSRI4nJysA3Iofn7/8dc597Hg2FSfOPN//osxJSEhNprCkDICfZSVrdPpL321j/3nsMGTgEfdtOKsrKSE1N5S9/+ctRs+3au77FicK9vLz8pNfMCJ676VDA4E3BYGgH69kdbWdnmjNnDpMnT2by5MlH3dh0OBwsWLCg2U3Xlv+hBdeP6TJKqYj787vf/U6J9tu+bJN6NflnaqfhFLWGCaqOOLWPLLVTG6qqSVAOLVntNp2iyrJOV3U3/lypzZs79H6bNm3qpJZHph07dqhZs2YpQM2aNUutX7/e/4TLpYreekvNueMOteRPf1JFhYVqy/vFyrdunWpc96V647HH1M3Tpqk3HntMff7qq2rb2++o9579k7rrxzeo1x5/QlUcqFduvUIVrVyp5s+fr4qKitSSJUvUjh07VGpqqsrPz1dFRUVHvX9lZWWzxwoKCtT69etVZWWlmjNnjgJCX6uUUpWVlSo1NbXZn7y8PLVkyZI2Xf+SJUvUrFmz1JIlS9T69evVjh07VFFRkZozZ07osYKCglD7gu/b8u/uRO2cM2dOm9s2Z84clZeX1+p7NhVs26xZs9ScOXPUwoUL1cKFC5u9ZuHChWr9+vVqyZIloe9BW/9ulGr7vw9gngpkn6aajLuMFPPmzVMyceb4grVpgPNzdPRHCslb8SClcacxrOEbHIYMYn11JFNFFWnEm11svPI+Rl6Y1Wl1aZvNRm5ubofP0+sFat6+Q4dRLjeazxMY6e0fP+3FGJhkZArN4qwwWrFq5TB8GKbEuE5vUmlpKfPnzz/qBlpwMs7cuXO7fEREb9fWfx+apj2glJoHUsPulWw2uPJKcLkgw6cz5sAUTvNtwYeRfg2l1BPHVt8wBhoP8WrSL/jhFQ5ifnsb4wMjPEQ3C9S8DSkpoZuVStfB50PzBafp+29SKjTMuMj0HqaBOOI2b6E8YygpSQpTSuetSLVw4cJWxxQH67wLFy6UwA6DiAzs4FoiF110UXDqpgjQdbjrChuP1j3DltoBjEg4wIG4YTSaMji76n0cZivp7sM0XDGDzy69lmuvzSS9h9Z9o06Tm5X08c/y9Lq91NX4iK8+FOpp+yfqKBKpoREL6eXbqa5IIc58iJq+w0lON3c4tydPnsySJUtaDeU33nijyyeICD9ZS6SXW/tkCW/vzqfeF8N0qjlc348kqqk0ZGA3ZmHyNnL49Y+4dOaEcDdVHE+T8E7OgsbyJMw7t+DU4ohVDRjw4cFEDC4UGkmqGuXSMO7bTdnhVPqOSMEUd/KpnZ+fT3p6OgsWLDhqTeiZM2d2eNKOaBtZS6SXstt0vrlvMRe8M49DykofdA7SD4s1Be85F1PTkEb5kHGMmjOFoTnSpY40MRmJkDCa2ENleKvBaUoisf4wbsyh2ZUaihTlIMFVh9q0nwrrMJKyEk+6t52XlyfB3MNIYEcwmw1eegkuz7Zxyu1XMtrjAGAQe2kkliwO0uA1kFC2nZR33+25Y95E28TGYhg6GIPbjbm2lobGZEz7duHDEJoC78WICTduZSa1bAs77cNJ7BNPRmxtp9a4RXjIOOwIVVIC3z1Lp++Klxh465VUmTMxaj68aHytnY6TWF7sdx++eQ+BhHXvEpgqH9cvBe20UThTswBCqwb60DDjxouRU3zbSD20iZo9lfi2bu+ezSxFl5EedgTSdXjuyuV87f4xn26eSLzJTUzDfpQGSjORZKxn2dy1TLsjhyTJ6V7NFGvGNDwLnGn4DpRhd2hk+A6HVg1UaFhwY/RVoRoUzj1leCzxxGQmYu5AjVuEh/SwI4zdprNu+sO8UnEltb44LvOtxOdppCznAqpNGXwz/bekfLOGHz+UI53qaBIbiyl7MKljBlFlHYEpsDmEhsKHhhH/BgwxlQfxVtXi2rSDuirpbUcaCewIsnNRCZ7Tz2TsxpdpII40rYqDZNEn3gn5k0n++lMuWnobGXJTMWqZzZA2JAVtZA4mE4FNFvxbrWkoPJhIcvo3J67bdoCDe2Rbs0gStpKIpmkFgAPIVkoVtvJ8cADoZKVUeLYo7gGCO71kvL+YSSt+w4GkHAZW2zDjwm4ZSFbjAUrufJcLHros3E0VPUliIobRozBWVFHraCSh5hAuzYJFuVBAoqomDiOesmpKK4cz+NQ44jp/wqToZGHpYQfCGqVUceA4v8XzeUBe4Pk8TdO6bxuJHkTX4TeTSrj4V2eSsuI1GogjuWYf+xJHYsdK9eDTuGVMCbl3SFiLVpjNGPtmkpQzAOeQHEzKg1czE1zq1YAPM26GuTdTuekgh/dJb7unC1dJZDwQXAqrFGg22FMptUEptUDTtFSgVClVSpTRdfjrXBt/3jqZSpOVs/iSeGopixtC/9ptHC78FxsfW8kjH06QWrU4oXhrImrEqRjxgKYF1irxh7YBH/3UflIP2Sjd1ODfRUf0SOEqiaS2OD7Wtn7jgB0tHwxOTQd63fT04KJNyx63seDQj/mP72zGuDZhI4f+2iE+N08k7q3FjLkshzHhbqyIKKaURBg9Gu3QIXyOKvB4QzvhqMBQwKHurdRuSsaTEk/sgHQZSRImq1atCk5LhyZT08PVw3YA6Sd6UaAkMixYQgkKTk0PrifSW+g6TJkCH/zJxt82n4Pdl8Z3+Jg9SaPINW7j5Wn/5Iodz5J9mSzSJPzTxBcsWNDsePLkyc12ST/qdbGxMHQohtGjICsrtCqgP7T9C0ylqkoSHPtwf7u1V44kmTt3LmPHjkXTNGbPnn3MNb83bNjAjBkzmDFjBnPnzmXu3LksXbo09NzJrhXeFhdddFEo42gyNT1cgb2OI73sbKDZ9g6aps3XNC24SriDNoR7b7B4MZi227jH9mPWMIFyYz+Ktcmkmuu54fQvuHGhlD8iUcuF8DtLcXFxs+VPs7OzW90ppeXrAH99e0AW2sgcMBia7D2pBYYCGojBSeU2OxWllbgbek9wB3eVSU1NPeaqgwsWLGDu3LnMnz+fJUuWMH/+fObPn09eXh6FhYVHbR7RXcIS2EqppUB24GZjapObj8GftoVAaZPnjxpF0ttsLdGpu+9hiivOosKVwHcpwuo7xERtLV/9+lWeeV/GVUeqYK+ss82aNeuoLbja/brERAy5I9EsZuoMyWgoNBRGvBhQ9Gc/xgo7vk2bcVZFR3G76V6ULbdgy87ObvNmvV0hbMP6lFLB3+WKmzw2OfCxlCM3JcPzN9ONKpaXkHJVAbf7avBiZAzfsCbmQoanOXD9ex1XT5ASSCQrKipq1+a13S4uDkPuSBKqaqmriCO++jBAILwhmSp8yoBv2xacI3KITem94/9KS0tb3Yuyqezs7GbbhHUnmTgTZhXLS0i66ju4fGZicRKDkxqVyDl8Rp9/v0q6hHVEW7p0adh6Y+1iNmPMTCPxlL5oFgtwZMeb4GgSI16M27Zg312Lx17ZK9clmTt3Lnl5eSfcmb5L9208DllLJIx2LLeRftWVlKpTyGYHjVjwYSQ90YXxvY9AdoCJaEuXLmXdunUAoZrnsGHDmDVrFhs2bGDu3LmUlpZSVFREcXExRUVFzJ49O1RTDZZSKioq2LFjR7MNX4NbdRUXF3O8bf5ae13wvYuLi6msrAz9h7Ju3TrGjx9PwRVXwLbteF3+3W7e/OADKqqqAEhLSQHeo8qQzrp1xRQu+vtxVwA83jUc7+8gPT291TYWFRUxefJkCgoKQucO3iPojN9iiouL29R7LigoCG0OvHTp0tDu7w6Hg6KiIubPn981O8Krbto4tzP/RPomvGVlSv3tnk3qgKG/+izhQuVBU1s4VTViVvPTH1H2zXq4m9gpon0T3iD/P7OjBTe5DW7cOn/+/NDnwU10g5YsWaLy8/PbdO72PNZy09jQ61wu5Tmkq1f/WKhumna18q77XPnWrVM3T5umnrvnXlW/7mt18PO9qnxHhXK5Wr/utlzD8f4OjtfGlpvnZmdnN3uvE1m4cKFKTU096nFAzZ8/v83nKSoqOqotwQ2PT+RkNuGVkkg3s9lgyjk6ExZM50tDHmPqPqPEMIlMzc61A1Zz1af3yFogJ0PX4c03/R8jRGpqKg6HI/Tr95w5cygo8I9gDY5MCCooKOiS0kprN9U2bNgQmiX55MvPc/H3p+PFiA8DMy65hMdf+RsxNNJXHcJVUcO2Te5WJ9u05RqO93dwvDa2HHkTanc327Bhw1Hv25Xbp0lJpBvpOtxxmY0F+h3sYBi5nm9Yl3wJw2u/ZPm9n7LwDhkJclJ0HaZNg5kz/R/feSei1v9ubVeXuXPnhn7lDgqGW2f+qn2iWi1An/59/MP/tm7FG4iM4LjtvpSR5nZQumUEQ3Oar0fSnms43s42rbVx3LhxR523oqLihNdyIqmpqZSXl7f59QUFBYwdO5aioiJmzJhBfn5+l25OLD3sbrTySRtv7jmbMQ3ruNS7AguNDKrfgvPdD2Q51I5Yvdof1rGxcM01/uMIFwypBQsWUFhYSHFx8VHh1xlOFP4zZ86kqKgIU2IcxtxT+Wr7ZmZNnx6YIem/IWnGzXDPFio2H8bTZLx2Z11Dl9SCj6GtQ/ZKS0vZsGED2dnZ7Ny5k7y8PBYuXMiwYcOYPXt2l7VPetjdxGYDz1PPclDLol5L4AADSUlWZP7+LpJk5mLHTJrk71lfcw384x/+HnYPFfxHfqIQajoWOKg7gysoPz+fN954g8JC/1QIrU8f7rr+x2iHD4Ym2YDChId+3n24bXY8p55KbKK5x1xDe8yfP59hw4ZRWlp63N8+gjcni4uLyc/PD5V+HA4HM2bMYOnSpUeVdjpDRAZ2cC2RSFhHRNfh7UKd3Y8t5nbfclLUQUxK4cGAcdBozNdOCXcTI5/V6g/p1at7fDmktLS0TRvbtjYW2OFwUFFREQqT7gi/4uLiZnXokLQU2LoN5fMBR9YjifE1ULl5N65ThvSYa2iP7Ozs0EzI1maNthScXBMM99TUVObPn88bb7zRKYEdWE9kaPA4IksiwbVEIiGsr79UZ+y8Kfyy7hGMjXVUx/ThS9NYGq7+EeYP3+/R4RJRMjNh+vQe+ffZ2k0y4JjlgeDj6elHVmQI9syDgddZQXeiEkV5eXnrJYLERLTckWC2EBxUaMQf3mk4aNj4GXDia2hLiaQrSkHHM2fOHCZPnszkyZOP+r45HA4WLFjQbOhfy//Qgmu6dIZAxu0KHkdkYEeKZcvge47FJJnq+UYbg8EIe30DGTOoirTnH+uR4SI635IlS1i4cCFLly4N9cQ2bNjAzTffDHDUAkSpqaksWbIktNjQhg0bQutevPHGGzgcjtD46uDXt/bYhg0bTvi6m2++mQ0bNuBwOEJjooPjnwHuueceZsyYQVpaWujP2LFj/WOg4+IwjBqJx9ofBU3WIwFrUhyvPbaA239+F6+/3vo1HO/voD1tDH4e/Ds+kblz57Jw4UIcDscxF3+aM2cO8+fPZ+7cucyePZu5c+dSWFjIP/7xj2bjvYM16+AEqeD7d9mNR9WJ46O7608kjMMuK1PqF6csU07MqpIk5UVTB7Us5RwyXKnNm8PdvG4h47Aj244dO9SsWbNafTw/P7/Z+GO33aF869aFxmsHP3ev26C2fVGj6uu7s+WRQcZh9wC6Di+9BM/90sYTu67GYbaSSAM740bhHn0GMZ+vkRmMIiIsXLiw1THFwTrvkiVLQo+ZMlLQRo4EzRCa0q6hMOAl27MFp60UT210LB7VlSSwO1FwPes/P6Bzztu/YbWaSJq7jMP0YWDDVhL+8pSUQUTEmDx5crNQbuqNN944OswTE/HljMSLMVTX1vAHd4qvEsPmTVBb26Vt7u0icpRIT7V6NZw5QOfntmmsS7uQGw7OZ2PK+ZxWs4YPf/kvLpWFnEQEyc/PJz09nQULFjQb4lZaWsrMmTNbHe1iSozDMzIHtXULms/T7DkfBtTW7fhyR8tONidJArsTjRoFG5cVYvBWUV7j4f9Mc/l+/2/5cexGnrlXwlpEnry8vDYNQ2zKlBgHuTl4Nm9D83ow4AutsY0P9E1lJOYMIDGxixrdi0lgdwJd9/eua94r4X7P/TRqsfyaxynLOI3P53zIM1MypRIioktcHGpkLoe3VZHi0omnPjSdvY86SOXmRswjsojpxWtrdwWpYXdQcBmLrVsh64UH2asNYoc2nH3Gwbj7DGDKDRLWIjqZ48z0yc2kLnMoQGg6uwakUYl52yY8VVLTbg/pYXfQ6tXwo3E2+v35GXLjShlQvweXFofZ66Rmwevhbp4QYWU2Q9+hcTSqvljKD+HDgAEfBG5Latu24hyR26t3selMEdnDDk5Nb7INfNicGWPjh0+PY+Kht7HW72Lt6JvYY8qm4lcPk3bZhHA3L+zUcRbXF9EjZmBfVGxcYO2RIz1tAz60bdtw1va+3WuOp63/LlpOTY/IHnZwanq46Toc+vXjDMZFjTISg5t++kYGn5mC+Z6bwt28sDMajbjdbiyBLadEFDObMeScSuOhCoyH9wduRB5Z7c+xZS/kDCI2MTpGj7jdboxG4wlfJ1PTO0mwdu2tdULgLrgXI+bURMzvviPjrYGkpCSqq6vD3QzRU5jNxAzqi2vIqRCaXOMfp52qKvBt3ho1Pe3q6mqSkpLa/XUS2Cdp2TKY1MfGqZVr8WEk1VeBixjW3fAnCeuA9PR0KisrsdvtuFwuKY8IAOKtibit/VFoTdYfMRCLk4qt9lZ3r+kNlFK4XC7sdjuVlZXNFsZqq4gsiYSbrsO/n7Tx9KZ8Pld5jMHLAeNgPu57DTfdLOOtg2JiYhg8eDAVFRXs2rULr9cb7iaJnsLrxedwoHncgb528Dakzl59JwlZyRjNJy4ZRBqj0UhSUhKDBw8mJiam3V8vgX0S1i7Tee7AlejxWUyuLeKbrHyG1O9gyNxrpXPdQkxMDFlZWWRlZYW7KaKn6dePw9fdTkrREhqJIZk6PBjQgF3xo/EVfcip58o/qKakJHISRm9cjK/CQZZzJ3XEM6J6PXdlv8Pka+WHS4g2y8yk76Kn8QwbRSINeDBgwoeTGPrXb+PPkxazZk24G9mzSGC309YSHcMzTxOnOfF5fJhjjXxwzr08877syShEu1mtJK79gE8v/A0EZkIm0EAcTh7w3svvv/cpdnu4G9lzSGC3g67DG99fTIKvhkZlwoSHCncSk/4spRAhTlpmJiOXPMy/k3+AGxOeQFU7nnreqbqQf9wl3ewgCex2WF1o42dVj2HAi8FgoIFYdn7/TjJyJK2F6AirFc5b+dvA2GR/YBtRaCh++MqlHLrvaX+PKcpJYLfR1hKds343lV3uASRQxw7fKdRbUhnz8LXhbpoQvUL6ubmYPvkIryUhsDskmPGSSA0xj82jPn8K0V4fkcBuA12Hl6YvI0bzMFTbTaMxgSHm/ayft1x610J0pokTqfvov1SQiRv/sD6FgWSfg8MbD1P68OIwNzC8IjKwu3stkcWLIan2IAmeSr5Up9PoM/Ny1r1cKGOuheh0GeeOZMU9n1BPAi6MGAPTa4aymz5P/YYNr20JdxO7Tcu1RCIysINriQTm2XcpXYeSx0v4Vf1DKDQm8QnO1L7c+L7caBSiq1x+50h+OXwlBsCJGQXUEYMHM1/+cAFboiSzZS2RdiparPO8vYAyrS+awcBmyxis0ydJKUSILmS1whNrzuXd2f/CFNjWN4FGUqjmh+plFv1oRbibGBYS2Meh67D7scX4Gl1kqX2YfY2MVt8Sd/dt4W6aEL1eZiZ8//nLqZ3+I6pIpo7YwPR1A79dN5X3fh99w/0ksI+jaLHOTP1ZjAaoIxmMRjbNmAc5UrsWorukPXQ3SbFe4mhEAyx4MOLjrN9NZd3K6Bo1IoF9HNbPlvG14XQ8Po1d2imUaX3pf7+scy1Et8rNxfjlemr7Dg/tVaMBGZTz4VVPsnlzmNvXjSSwj8Fu0xn89pN8z/0vTHgYqTZR++dXpXYtRDjk5JDy0T9RoTEjoNC4y/0oD523ImqGZ0tgH8POZ5fRz3cIu2UAZs3DVwMvp27bgXA3S4jolZtLzaJ/AQoPGkYUoHix4ioK74qOYSMS2K3QdajZcpA4l4NkVxkxqpEBh79gxE8nhbtpQkS1tOsu58CPf4MhsFCUETDjYfQrv2blynC3rutJYLeg6/Dz79gY/dGz1JGAwkiDOYV9M2TNECF6gsH/dyfuhHSC+xdpwFSW8/epr/X6erYEdgtrl+k8vXc6e9PGkEAd+2NPoYI0Tr1f1gwRokewWol9fxmg4QrsweLGyN+8P2TOpDW9up4dkYHdlVPTJ7Ga942XMqZ8FTvJ5hTnFmr+JDcbhehRzj2Xmuf+jhkPCrDgRUPxF/1KFj7cexJbpqafgCdnFNdULMRu7McplLJu/K1ys1GIHij1luuomHgFCvDiD7Mkqjn0VO/ZqUampp/Aty+soUpLI82rU08C/b9YLjcbheihMl98HKWZQ0EWh4uH6L071Uhgt+DZe5B0pbPffArx1LPrOzdKOUSInio3l8bvFzTbqSaBev5VdQHFd/W+9UYksJuw23SGrXqRRmLo596DrvXBPEh2+xaiJ0t4+LeYLc13qjHgY9orV7FjZe8any2B3cQXDy7DoHy4iAE0PAYLo+6eEu5mCSGOJzcXw6qPcJmO7FRjAEx42DT93l5VGpHADrDZYNWyGiy+BtabzqFBi5f9GoWIFBMncvCd/1JHfGh8tgG4zPkWy/+3l9yBRAIb8E+WuesKG7/wPI0BD2N96zhsHiD7NQoRQYZfMZIDP7oXBaGeNsC0hZeyY0XvmFEjgY1/sszfHFdicTqIxYXPp0j4xf9I71qICDPyD7OoThgQOjYBidRgnnop5VsivzYStsDWNK1A07R8TdNmtfJcqqZpeYHXzO/qtpxVs5o19aeTTA1VpJJCNYcPd/W7CiE6ndWK7/1i6khsVs+2+g5Sclvkb+AblsDWNK0AQClVHDjOb/GSa4BxSqmlgeePCvXOouvwqxdGMdH7KTUkkGaswm7siyc2qaveUgjRhTLOHcm6/N+g0EL17FjcnFv0O0pXRnZpJFw97PFAaeDzUiCv6ZNKqUKlVGHgMLvJaztd0WKde7fewI7UcSRQx/qESVTE9pfRIUJEsDP+OAuHlhFaOxsgDQfx0y8lkoeNmML0vqktjjNae5GmadlARbAnHhRcSwT8Uzc7MkV94JfLyPAcJs5eSh1JnFq7gfp3P5L6tRARLDPXSuXyf8IVF+ANrJ2tgHhnOV89vJwznrwh3E08rlWrVjVdK2lo8JNwBbYDSG/D6wqUUrNbPhhcS6QzDB8OJl8ddcYkErwODuVejPPDb8m+TPZtFCKSpV1+Lm/PWsaUwqkoFEYgkTr++dR26q+BiRPD3cJja9oRfeCBB3YFHw9XSWQdR3rZ2UBRyxdomlaglFoQ+Dyv5fOd5evEiaSYG0j36SQb6jFtt8naIUL0Euc/dDkfWr4H+If6acDPeYYfX26PyMpIWAI7cDMxO3CzMbXJzceiwMd8YL6maes1TVtP23rjJ2VC0ib+mnUfpWcW8O+Eq8mYd7uUQ4ToJaxWOPuKPii0wMR1SKOaOxz/ywsvhLVpJyVsw/qUUguUUsXBXnTgscmBj8VKqWFKqbGBP8XHPlPHpEydxE/7vQtnncX3cneTdZPcbBSiN0l7+G4MGqERIwA/YyH2P78WtjadLJk4Y7VifvcdzrhiIOZ334FM6V0L0avk5qL9/e8YOFIWUcBje3/Ip09E1rR1CWzwh/T06RLWQvRW111H+TWzQqFtALxonHLX9IiaASmBLYSICpnPPkR1jDUU2hZ8VJDMR3ctC3fT2kwCWwgRHaxWDo6dgpOY0A3IUWxl9LuPsX1tZPSyJbCFEFHDuuBujHjxBSLbB4xgG2t++pfwNqyNJLCFEFEj47xcqmbfHVplxIB/h5pLN/0f61b2/F52RAZ2cGp6k6mbQgjRJtYH78SblN5szew4nLx09fIeN5kmkHFDg8cRGdjBqekdWUNECBGlrFYs/16GD2NobHYi9ZzWsJanngpnw44WyLhdweOIDGwhhOiQc8+lPv9KFEcm1PyMhex+/LUe18tuSgJbCBGVUqZciNZkzWwFvOS6nnef7Lk7rUtgCyGi03XX4bH2DYWgATDgI+3/eu5O6xLYQojoZLViWf0RDcQ122n9Utc7LH2kZ/ayJbCFENFr5EjKZt3XrJZtwkfaM7/vkb1sCWwhRFQb+tAs6oypoWMDkO9Zztt/6XmJLYEthIhuVivOn/4MONLLTqMa83NPha1JxyKBLYSIen3OGY4LS+hYA6btfZri13tWL1sCWwghpk71b0/TRCK1rP/Jkz2qli2BLYQQViuxq4tpNDQfMXKHaz4rnuo5I0YiMrBlLREhRKcbORLfVd8Hmo4Y8dL3lcfD1qSWa4mYwtWQjgiuJSKEaJ2uw+rVMGlS89/0dR2WLYOaGkhK8lcCoPXXRqOEh3+L5+03MAaWhjIArr2HsNvDsyFVy7VEIjKwhYgmTcMX/IHr2mhjyL+eYV9dKlnOXVh8TiyqEav3ECbNTU2Dif4xCVQ37qfCFIvPYMKDiUOudPI4TAK17GQYX6IYwm6sfU7n530e5s8f5Ub3Tnm5uXzT5zucUVYc2krsPD7mif+189Dz4f+LkcAWoofQdVi8GGrfK6Fg42+pqDKQ6Kqk0aVIjc9io9PJUN9OJmBkODtQGLHgOfYJGwMfm7zktCZPDz/ScWNE2Q7yylby3l++5Op7cjrzsiLOkPMG4Xub0K40qdSSuvBhttz5JDlh/quRwBaiGwVLEq6NNoa//Tg4HCgFSVoV6dW7OY8EzmIjGkcCA4D6L1o529FhrVoca6081trrvZhwEcupq1+Eexa044p6n7SH78b79ssE/3Y04Jc8zZ233cKz74c3sSWwhegiug6rC230f/MZDux1c0bVJ+xz9yGPSkbxLUbUCe/6Hy9soUWot3J8rMdaPmfAgwUnA3730xO8YxTIzaVh1u0kFD4dKou4MDOy6Bm2bHk2rL1sCWwhOkl5iY2DP3sQV+lutplHk1u1hivVN7gxMwE3AMNofYhYa8F8VC/7GF+nACdxeDQL+2OGEmPw0Ld+JxVxWVgb9rHPPBSXIRavZqLamEE/DhOvatgfN5xGJ/T37KRh+BiyXniE9AnRXQ4JSnzoPmpf/TsJDeUoIB4XsdTw+OPwwgvha5cEthAnQdfh7UIdy5uLGbn3PQZUfkM/717S8IfsWXwaeq0Jd7NAVhwJ4pYfm3IDdi2LZFWFLeN8APrWbKfRnIQjaRCJA5IZdNlpJPZNJCEpCaZMISV4x9BuJzFwp3LEMe4i9j/pq48CVivmMTn4/vtp6HvzE16leP29QPj+U5PAFqINguWNIW88Tt3Ow6TW7uE6dhBLA8ZWXh8M5WBQNw3kpp8H9xVsIIFyS18qkwaTHOfhqwGXc8a86WTXfwuTJjG+vUM3MjNh+vT2fY1oJubKy1H//TT0PTSi+MGXv2bt2mVMmBCeNklgC9GCrsPaZTqjvlrMwXc+o77CSULtQa5iLRqtzzZr2oNuWsoIfqwjDgOKTXF5xFl8VCf1xzAql9OtB4k750wSr72WxMxMhgRenx06m5QowmbWLLy/fxijqwHwfy+vYDk3/GILEz4Pz/dFAluIAJsNXvi1jcnv/5p8TzFmXE2Cs7ljBXSwpvyt5UyGeXewL3EEtqHf4+yZw8m6eQrjonqQc4SxWjFN+R7qrbdCvzEZgR9++Wvs9mVhGa+uKXWi+9A9zw033KCGDh3KRRddJDuni5MSHF5XtdbG8H8+TrzLgeawcwGfHNWLCYbwserNHuCgcQh7YnNw9R1I9iM3M9R8wD/TRQI6stlseEadhgFf6PvuA5bcsYYfPNn1dZFVq1Zx8cUX/00pdQNEaGDPmzdPydR0cVJ0nR0PLeabP3/MEM82cgPD61rWoVurPQdVE8++mBGYY014hufQ79n7ZXRFL/baT1ZwzStXAP5yWANm1lgu4Yz9K7vl/2NN0x5QSs0DKYmIKBAc0RG/qJDLNz/BYFVJdisD6ZqGdDCovUAVKWyNP4v+2iEOnXc1w/94B6NzpOccLRouvJylr8zgGpbgA+JwU+ZKZvlyuOGG7m2LBLbotUpK4M+32yj48l6u9b1PPPWtjm0Oljs0joza2MNADvc5g4YLLmXMw9cyMRDQQxDRZupU2GE+AO4jPzsFLOHBlb+HG7r3NysJbNGrbC3RWferxWRt/Rirw8bLbMZI85BWHD3MroFYPIYY9AFj2PTjx5l4xwSGSida4F/BMGZSH/jgyGNeNKz/eIYtv+/emY8S2KJX+Gy5ztc/fYJryp5hJnXHHBsd5AXcWPCY4mm4+ef0OXs4TJlCcmYmw7qpzSJyJE+9EO8Hb4eGdMbgI4EannkGnn22+9ohgS0iVrA3PWTre5zh+JjxgZJHkI/mIzs0wI3Gu8PuIO2MUxh7URJJ104hSUZyiBO57jo8c+/D3FgX+pn6Ea+yy969Mx8lsEVE0XV482Ebg//2IBMdy/gBtUdNZAmWPJo+Xkcc9Rd9jz7PP8K0cK+RKSKP1Yr7ltuxPP1ok58vxSlvPo7d/kK3jd6MyC3CRPSx2eA3F5RQ2vds/ufp0VzqeI3UJmHto/koDw8a2+NGUzP6HLRHHiFR30Ofj94k7Asai4iVeN+d1GkJTVY4hIGeHbz2Wve1QXrYokcrL7Gx9ebH8dhsPByYGt7aDURD4PM64tk9+jKyXniEETI2WnQmq5XqQaNI2LMu9HN3EatY+uYWuK17ftakhy16HF2HV+618UnfaSSdfxpn2/7K+azFwJEFlVqufrcj8XT0Ox8hUd/N6G/elIksoksk//Aq4MjPnw8D4z9ewJZu2lhdAlv0KO8v0vnrgHuY+egYzi17BzO+UO+56RRxH1BnSGKL9Xz2vL6G4TVf0feJe2QquOhSiXfOoi42LRScFnxM4Z8896C9W94/IgN7165dzJs3L7gFvIhwNhv88jqdv/a/hwnXn8Jd7sew4A39cDZdqlQDtg+6EOcjfyTxcCm5ZZ8wdGaY1roU0cdqxTigf7N7JlbKOe2brilkBzJuaPA4ImvYQ4cORdYSiXy6Dq/ea6PfCw9yP++SRvVR9engxyqSqBh0BumFjzPiMgloET6fX/MY5z86NXRsALL3fQzc1unvFVjcblfT9xKiWzUd8fHzF0Yzk9dIbxLWzSe4GPj43PvwbS5l2J5PSJOwFmE28s4p2BgBHFnKIKF8V7fUsSWwRbfRdXjiZhs7Rl3Bw/85n/FqHZYmG9E2HZbnRWNX3nRq1mziOyUPkSGLLYkewmoFTvEHdrCTcSqbefK+rq9jS2CLLqfr8Nz1R3rUl7MiNOIDjtxM9AF1JKBfNB3TZhvZ62W0h+iZhpzTN9S7Bkihjrz/PNXl7yuBLbpUSQnclr2cWYsuCPWoW5Y+FFAfm4bzvkdI1HfJBBfR4yXcfzdNZwRowA8OP035lq7tZUtgiy6h6/BkQQmG88/mb7VXopqskdc0qOuMKdjvfITEvVtJfEiG5YkIkZtL8Sk3N9toOY46vr6va6c9RuQoEdGDBXZ02f/sW9zuW91iv0MV+AgNsWmou+4m8Y6bSZSQFhEoMXcwaidNpqorGj/7skvfUwJbdJqdi0pI+5/vM9hd3mxHl2CtT2GgmhTcd95N33tvlt60iGhn9jlAIxZicQH+csXOAxbs9q770Q5bSUTTtAJN0/I1TZt1nOeLurtdov22lui8NeSXDLr+fBLcdkyBvnTwT/AG49dX3IPavFVmJIpeIWHOL7DgaTYM9Trf3yl6revq2GEJbE3TCgCUUsWB4/yWr1FKLe3udon20XV4fupy+p6fzff3/BEjR35lazozcW/G6VStXMNZy2V4nuhFcnPZNPb6FnXsWhLf7bo6drhKIuOBNwKflwJ5QHFbvzg4NR38M4ECs4FEN1q+HJYWLOLFxuuBI3W8YPmjnnhKU/NIef5xmToueq3sMYm41huwBH7yTUDcfzs+63HVqlVNl94YGvwkXIGd2uI4oz1fLFPTw0fXofBOG6cv+jUvsgInFuJxhXoYBuCwMYtDiz7izJkyNE/0bglzfoH35eeaPZZZt6vD523aEX3ggQdCJwxXDdsBpIfpvcVJ0HV48l6dJQN/yZxFo7kiMPklHhfewGvqiWfvDffR79BGCWsRHXJz2Rk7Ejjy2yWuhi6bph6uwF7HkV52NiA3F3swu03n3VN/yaxHB3GL648YA5NfFODChAbsnHYnifpuBv/1IbmhKKJK3Bn+zkmwLJiLjVfu65rEDktgB24oZgduNqY2ufkYCu7Ac+OCNyhFeOxcVIJpzEh+4vgj8TSGxlUHR4BY8FBb+DrD3npCglpEpbJRFzWbpm5CMem/j3fJe4VtWJ9SaoFSqlgptaDJY5ObfF6slEqT0SLhYbfpfDjxHgZeP4lYbzVwZN/E4A+nY1ge2po1pNw8M1zNFCLsBt19HTUkNdvr0VRxuEveS6ami6N89VwJ2qiRXLj2MYz4iMEDEOpdNxDPvsKVZGxfDxNkBIiIbpm5VvbFDgeOdGYy63Z2SR1bAluE2Gxw1xU2cm69mDQqQhNe6onBh8Z++vFcxn00bt7N4JsvC3dzhegxzAOzgCN17NP4lqW/Xtvp7yOBLQBYv8jGl6Ov484VF2PGHVpTTwGxNLI3IZd/P/I112yWyS9CtDRwXN9mMx4BLl/zv53+PhLYgq+eK2H09WcyU71Gfw4HfihUoF6tUfqD+xi662NuvidT7isK0YqE++/Gh9asjl3pjOv095HAjmLBjQWG35qPOTD5xYcBH+AkDg9mtv5hBSNek6F6QhxXbi4b484GjtSx4+oOY+/kZUUksKPUZ8t1Xh18DzctuoA4nBgg8Mf/47Z77DRq13zNqF9JrVqItkgz1DZZ9R3OZh0fPNK5deyIDOzgWiJN5tqLdvjoORt9p47jl875GAK/xnnxlz8asbDlDysZ9fki2Z5LiHb46rrHmuxB4zfy7x2rYwcybmjwOCLXw5a1RE7ev+8vYeKD3yOeWjwYMOMN9QpcmNle+DFjbpahekK01/l3nkPVX+JJoT60rHB5fcfq2IH1RHYFjyOyhy1OzuqfLSL/wQtIogYTCgte3JjwYmDz6Ok0rNkoYS3EScrctJoK84Bmj9XV0al1bAnsXk7X4c2HbXw5bBrnP389WpN1QLxoeDCz//USRn8jO5QL0SGjRjHEvR04Usfuy0GWL++8t4jIkohoG12HX59bwvPbL8GEu9k6IODfssu18kOGXia9aiE6bNMmytOHY63YFiozZrONT7fbgc4ZZSU97F7s3ftK+PP2fEw0hibCeAnMXrSkYV7zH9IkrIXoHJMmkeSqBI70sGNxYfp353WxJbB7qQ/uWs4P/zKJOJyYADNefEAjsf7p5Ru3yjogQnQmqxXvbXc0W7kvASeWfTs67S0ksHuZ4D6LFz5xFR4MoSF7XjRqSObVO7+U6eVCdJHEO2fRQHyzx8ZXt3n3wxOSwO5FdB3+eNpz3Lx8Kj4UsU1W2fNgxvH6e9zyRI5MWhSiq1itHDAPAY7cKzJ5Gjrt9BLYvYSuw+Kpi/h92a14MWJGUUcsPmB333OoX7NRNsMVohsoU/OxHC43nbbUqgR2hNN1ePppuCNnObd+9hPqiAvVq+NwUtN/FNnfLJche0J0k77W5scWnDzeSRvQRGRgy9R0P12HO84pYeydF/BK5VQcpJBAA3XEYQD+e+YtpH71sSzcJEQ3cptjmx2PZAvGHSfXxW45NT0iAzs4NT24DXy0evNXJfxt5yTOUusxAHE0UE46Mbi4a9DrjCh6TsJaiG4Wd81VzY6NwJVfPXhS55Kp6b3EZ8t1Lv77DSgUdfjXK/BhIA0HS3+ynHs3zJSsFiIMEu+cRR1xobHYGtDf2TlD+ySwI9DWEp3Uqecxgu2YUFipQAGOpEHsfb2Ea1++TMJaiHCxWvk2bhxwZKRIjZbcKaeWqekRZmuJzpaLZ3M523BiIQ4XLgz4LIkMLv1ESiBC9ACJqq7ZcWx9OXZ7x/95Sg87gmwt0fFecCGXu99GA+Jw4QVM+Gh85Q0JayF6iDiju9mxEQ+vvdbx80pgR4jPlutsmjSbU5WNeuIDu5lb0NDY/sDrpM6UnWGE6CkSE5tvyWvByWefdfy8UhKJAJ8t10mceiFTsaEBidTjxkgMHrb8YYVs4yVEDxPfJw4OHzkeyRbS9C1Ax+ZDSA+7h7PZYPX0JxnJ5iY96xgMKLb+4V0JayF6oD3D8psdG4Apto7PnpHA7sG2luj8e+w93Ol+DA+GJj1rt4S1ED3YwIuGB0qWfgbA4jh8vC9pEwnsHip4g/H2hvn4MGDBSw0JGFAcKJSwFqInS75uKqpFxTnDfbDD55XA7oG2luhsvPiXnKo2U0c85kBYx9PAgcJ3GXyzhLUQPZrVyh7LMKDJDk/q2C9vq4gM7N68lsjWEh3XpO8wxf0moEiiDjcmCWshIozD3KfZ8aHGjHZvyCtrifRgug4fX/owub5vqSYBA+AgCS1wg1HCWojIkalVNjvuw+F2b8gra4n0YJ9c/xw/rXsaHworldRjxoyXzYX/kZq1EBHGRPPJMyPYivtgO7vYLUhg9xD/WVDC99+/lUYsmPBPionBi/31Dxhzs2w8IESkcbe46WjAw8gdHduQVwK7B3h/kU7y3NlUkUwMLhoDa4TseGCx7BIjRIQqt2Q1O/ZhIiWlY+eUwA6zz5brDLj+QkZhI5VqFGDBxduXF5Jz/8xwN08IcZKGj45pduzGxLx1Uzp0TgnsMAlu7bVqmn8WYy3x+DBQTSLLkn/IhX+7OdxNFEJ0QJ8Wa7HFU0uqt7xD55S1RMJA12HKFEjdVMJyzwI8GEmhFhdGEjUnF7z3W9Jl4T0hIltM8x62CcXULY8DL5z0KaWHHQbLlsHIihKW1n6XctIx46GaRIwo6l5bJhvmCtEbTJiAD5pNT09xdmx6ugR2N9N1ePMhG89vvwQLHvqi00hMaGKMLJMqRC9x3XU4A9v3BWV6OzY9XQK7mxUt1rl/5w2YcOPDixszGj4qf/WQTIwRojexWtltGQ4cmZ7eUREZ2BE7NV3XueT3kxjPfzHiIxYvBtyovv3pc89N4W6dEKKT1Ribj+OrMyS16+tbTk2PyJuOwanpkUTXYf0Ni7moopQGYonDSSMWNJOJuI/fk+29hOiF+rn3NzvOcu1p19fL1PQw0HW48VwbZ614BCNu4nECYMZFw9/fhBy5yShEb1RnSGh+bGxfD7slCexu8Hahzp+2TyaBGkBxiL64sLDm4v+Vm4xC9GI1xtRmx9XGtA6dLyJLIpGm/8sPM4j9eNAwAUlUsyN2NLnP/TLcTRNCdKGOlkRakh52F/vquRK+u/1PeAD/8i8G6uOs9PvyfTJypG4tRG9Wb2xeEqn0JLV7Teym2hzYmqY9pmna+5qmPadp2nRN05JP/m2jw38WlDDy1u9wUOuPCXBhwoSPL25ZKGEtRBSoS+jb7Lg6vi+rV5/8+doc2Eqp3yilvgv8Bv/knaWapj0qwd26z5brDJ87nWqSyFL72MVgTPi4e8jrjL1X6tZCRIPUxuYzG1PqDzNp0smfrz097Omapk0HlFLqTWCuUuoe4JqTf/veSdeheGYhGVSQRgVGoD8HeO2W1fzm85kygk+IKGFx1TY7TjXVdOjff3tuOganxL+gaZoCigIfd57MG2uaVgA4gGylVGF7n+/JVj5p4xf18/Gh8BCDhmLLaQXc8JysbS1ENDloGsQg964jx+bBR2bBnIT23HTcAJQqpa5RSs1USr0AVJ3MmwbCGKVUceA4vz3P92RbS3QueuwyEqjDgpc4nGgohvzlt+FumhCimyX46pofq5oOne+Yga1p2j80TXtP07SbNE37jlJqp1Lqi6avCTz2wUm873igNPB5KZDXzud7JJsNlny3kD7qEB40XJhxY2LX2BmyAp8QUcio3C2OPR063/FKIguBz5VSVQCapl2Cv379YYfe0S+1xXFGe54PriUC/qmbPWH3dF2H2ybbWFb/EF6MxOOiEQ2Fkb7PSu9aCNF2q1atarpW0tDgJ8cM7JY95+CxpmnTlVJvdbA9DiD9ZJ/viWuJLF4MNx18EAfJxNCAg/6k4MD++gcMld61EFHJozWPWK/WttuGTTuiDzzwwK7g48f8ak3TzgTGAcVKqV3Het1JWseRXnQ2UNTO53sUXYcNDy3nJd/rKMCAIo5GDr/+sWyiK0QUq2+5lkg7V+tr6Xg3HScDw/GPt94WmDDzaODxDlFKLQWyAzcTU5vcXCw63vM9VdFinT/ar8WFBScWyslAP/UCCWsholxnT00/Xv+8FFiolPqNpmmn4L/xl66U+kuH3jFAKbUg8Glxk8cmH+/5nmrgKw+ThH+8pQbE0Uj10w+Ft1FCiLDr7NX6jlfDflPTtEs0TduhlNrJSY637u3KS2ycu+EZfGgYUHiBXdaJDL9MetdCRLtKU19wfRM6rjD2Pc6rT+y447CVUh90Qf2619B1+OpHj9NIDAYUCgMaYHrmiXA3TQjRA6R7mk9NT/fKJrxhEdyUYPTOdzHjwkksoFiZ8yupXQshAIj3NZ+anuDrookz4vj+/qTO09uvoM6QiA8Dh+jPboYy8uV7wt00IUQPUR3bvATiiO3XofPJBgYnQdeh/ulCBrIHr8+IES/x1HLo9dWcOUFWdhJC+CW5/ItfK/wDEpIb9Q6dT3rYJ6Fosc7s+icw4sWADw3wXDSZM2fKBBkhxBGHjf2BIyvn7Ted0qHzSWCfhPT3F5NCFRpgDuwlow87J7yNEkL0LLrOqIYNzR5ya5YOnTIiAzu4lkiTufbdRtfB+9EqDPhwYwSgSktj8N3XdntbhBA9WGEhCRxZrU8BcdS36xSBjBsaPI7IGnY41xJZ+aSNaxpWAAozXjwYsF3xa86XLb+EEE2tXBkqhQQ//s16NxPbcYrAeiK7gscRGdjhsrVEZ+jjP8eDCS9GzLip0lLJ/b+bwt00IURPk5ICHLnhWIcFq/dQh04ZkSWRcLDbdLwXf4fxnjXEUx/6H3PLFXfJhrpCiGPSQp8Z/endARLYbbTt94sZ5t5MPXEA1JDIYcsg6V0LIVrVeMje7Fhh4NOMKR06pwR2G5nXr8WAjwRqURhIMDaS8PFK6V0LIVp1uN6/0FOwU72G8cQP6lheSGC3wdYSnT7bPkEL/NV70Sgad49s+yWEOKaYmspmxynUEBPTsXNKYLfBl3MX0wcdN2bMuDlIP8Y8JaUQIcSxad7m+zma6Nh+jiCBfUK6Dv12rcWEh0rSURjQR17EcJmCLoQ4Dq/v6McCA0dOmgT2cdhscP04GyMPfIgC0qjEixF3nsxqFEIcX0P90UNC5szp2DllHPYx6DrcdYWNV/dfzCH6kYyDQ6YBGFCcer/MahRCHJ/X1bwEEmuBnA7e9orIHnZ3TE1fu0zn5YorMXud5KpvcBJLrK8ezzIZGSKEOAFdP2r/Rq+h/f1jmZreRmfVrOa/VTlcRik6mVgp59vLf8N5l8nIECHECaxeTYXRSoJ3d2imo92Y1e7TtJyaHpE97O7w4eFRXEIRPgxY0dHpg69v+//ChRBRKCaGQd7dgD9kvUClpU+HTyuB3Qpdh4N/egsTPrxogIbbYGbU3R2bpSSEiA51988PTZjxf9R4fVAH7zgigd2qosU6/1P9FD7Ai4kG4qg+e7LUroUQbWLfZkfjyMJPW8km7wcdL6dGZA27q/X/eDEpODDhwYyHRiz0f/LucDdLCBEhtEZns2Mziptv7vh5pYfdij62VZjxUEciGrAn57syDV0I0WYHTYOaHetxg8nshF/QJbBb+Gy5TubmT1FoxOHEgwF3Wt8Tf6EQQgSke/2b7Qbr2EnUdMp5JbCbsNngxWnLWGs+HzcmqrQ0vJjZcqWUQ4QQbWSzcYprM9BkLWxT51SfJbCbePlxndu8TzLJXUwlabiVkZtHrOLCm6UcIoRoG8evHzwqWNel5HfKuSWwm7j48GKGqy24sZBBOUWjbufJTyd0Su1JCBEdDq3b3WyESD0mUs4c3innlsBuYsihtcTgJpZ6THgZH/eNhLUQol32W04BjpRDakml4tzOmcMRkYHdVWuJeGoaATCH1q3Vjv1iIYRoRU7FZwAEV1etJhlz1sn1/GQtkWPYWqKTsu2/aAQXGteoHTK6U99DCNH7NXjNwJHuXj1xTDnJDrasJXIMX85dTJqhmnpi8WHAQSojL5K1Q4QQ7ePzNl8H22QxdVppVQIbf+96/GfP4vKZsOChkRjqzGm4vitrhwgh2m5ric6AwKJPQW5TbKedP+oDW9fhtSsXo5v60UAcNssZeGKT+PDuFXz8rdxxFEK0ne3OQuJpCB0r4PDZV3Xa+SOyht2ZVj5p466K+1BADI24XSZev2MViz7O4Z07w906IUQkGbN7Wah2rQF1xFExvRMWEQmI+h72gLeexYUJMx58GEi1OBl0RgbvvIMM6RNCtI+jHDgyJX03g5l8becFSdQHduyw/qRQhQcjFlysN57NJFZLWAsh2kfXyXI1r1/HmrydmiVRH9jDzkjEg4kYGvFh4CzLJlYzKdzNEkJEmsWLMeFu9lBR2sxOfYuoD+xN/61FAw7RD4WBF403MWGKdK+FEO1T/dZ7oZuCGlBNPG8PuqNT3yOqA3triU72B4V4MZJKJYfpy1mXZUk5RAjRbrXrtwJH6teH6cdFBZ0bJhEZ2J01Nf3LuYvpxyE0FHE04MVI3v0y9loI0X5l3pRmx4fo1+FdZmRqehOn1n+JES/VpJBCJRWnXcAQ2bdRCNFOdpvOCOc3zR4baNE7/Nu6TE1voi5rOEa8xFOPAUX9UFk7RAjRfl88uAzV4rGaU8Z0+vtEdWD7aXgwARpH/Y0LIUQbNKz9igRcgP+GowuN7T95pNPfJyJLIp1B16HRtp064qkwZOL2mUms3h/uZgkhItBp+1YA/iVVDcBeTumSnaqisoet6/Dz79gYvutDYnCS4dOx4GL7924Ld9OEEBHGbtPJdB8AjiypejB+eJeMNovKwF67TOfpXVeSqGpoJBYfGn9KvU/2bhRCtNuWXxeSSH3o2Ac0WAd2yXtFZWBPYjVf+k4niWoaiSEWJ2eenyjjr4UQ7WZd23zBJwUcun5Ol7xXVAZ2ytRJnG34HA1FArUoDMRYwt0qIUQkMjVUAUfGLGwhh8vv6Jrf1sMW2JqmFWialq9p2qzjPF/UFe9tt0NDA7ix4MWMXbNiTEvqircSQvRidptOn4bmCz754rrut/WwBLamaQUASqniwHF+y9copZZ21ftvWrAMTfkCw/nAY7Aw6m6Z4SiEaJ819y3jyHa7fs6UrttaMFw97PFAaeDzUiCvO9/cV1VDhq+MakMKMTSw54JryZAZjkKIdtr734Mk0Aj469c+YPh5fbrs/cI1Dju1xXFGe744uJYI+KduBqZvtluGzw4YOO2r18F+p+xYIIRol3GO95sdKwykPdzxG46rVq1qulbS0OAnXRbYgbJHeouHSwNlEEcrz7VZR9cSaWyERmKoJI0kavmPZwIXL19N8g3TT/qcQogoU1LC2LrVgP+GowJsSeMZk9PxG45NO6IPPPDAruDjXRbYJ6hBr+NILzsb6JKbi63ZWqLTZ+Xf8GBkAPvQ6cO4lO2sZhJSxRZCtFXdbb8hrsmxAXj2lKdY2IXvGZYadiDMswM3G1Ob3HwMBXfguXHBG5Sd5YsHl9HfomPBQyNxGPHxy7RXZNMCIUS76FvtoXHXGvANOQz9wYQufc+wrSWilFoQ+LS4yWOTm3xeDKR19vuOy6kh7b1D1JBMElV82fdSbp30LZmZMstRCNE25SU2BtRtafbYTkZ0eP3rE4m6iTN79/pvDMRThwYMsn/BGbfJHo5CiLY7+KvHMTRZ3lMBsUP6dPm4hagKbF2HTz6BGhI5SH+qSWXn9++UIX1CiHZR27eHwlMDvGgMf75rpqM3FVXLq65dpnMTL5BMNbGBsZODb/pumFslhIgoNhu5FZ8AR0aHfB17NnmXdX1ZNap62BfWLMNUWcZ27VQMePnUchG7ln8b7mYJISJIw70PNgtODXhqyFPd8t5RFdjJSWCKMzNCbUVpBi5wfcC+VNkWTAjRdtXrtjQbHfItOXjHdu3okKCoCmz7xKnU1hupIBWvMvBKwmwGOqSHLYRou8aKSuDI6nwuYrn//u5574gM7ODU9CZTN9vk47fspPvsZFBBHE6ur3+BM6+XHrYQom0qlpcwoGEncGR3GV98Ep0wubFVgYwbGjyOyJuOJzs1fegHL7HJdDpmn5MUVUWZZQC5m7+FCTIGWwhxYrU//81RCyH967zHGd9F7xeYnr4reByRPeyToevw54Pf5zTPBob5tpGl9jM4o57VyBhsIUTbeA4eCgzjOzK78fpnuqd+DVEU2GuX6fy+9lc4tAwM+LBrfbgtY7FMSRdCtEnF8hKGuLcDR4JzV8rYLiuHtCZqAnsSq/m8chgW1chh+hGjnMw+fY2sqCqEaJPan/+m2bEX2H9jN91tDIiawE6ZOokLzGtJpor+7CeJaswNNeFulhAiEug6aXu+wMCR4XwfcxEF93bv/a+oCWysVjadexMKqNGSw90aIUQEOfxQIQnUhY59QI01u9t/Q4+ewAY8MQn4MOKLrssWQnRQ7StLQ8P4/JNmNIY+0/Vrh7QUVcnV2Aig4TQkcGQUpRBCHIeu09fhX0o1OFnGZh7DmTO7fzhw1AS2zQarV0MNSZT5rOiGvhjTksLdLCFED1f70BPE0xA6VsDHfX8QlrZERWDrOtx1hY1feJ5Gw8NIbNQYkxl1t2wKJoQ4Dl3H9OxTzcoh9cTj+UkX71RwDFER2GuX6fzNcSUWp4NUajApN0PSasho117tQohos+dXTxDjczZ77D0u4/o7wjMeOCIDu71riUxiNWs8ZxNrcOHFiIbCaa+n5rXlXdtQIURE8/2j+V7iPsBa+Ei3jQ5puZZIRAZ2cC2R4DbwJ5IydRL5Q7fj9MVgxI0HI05l4cuvuradQojIZbfppLoOAkduNn4WeyGTbu6+m43RuZaI1Ur8h+/yVf5duDFTYbCSruwcSJJFn4QQrdt44xMkNxl77QFqLrk6fA0iWgIbIDMTr7UfFWRg9R2mgVgmv/oTsNvD3TIhRA9jt+mMX/tMs5uNThIY94drw9msKApsIIka+mDHTiZJ1PGZcwzVy1eHu1lCiB5mzW2LiQv0roPlkK+yLg37ht1RFdiDRydRRiYZ2KklgfGWjbK8qhCiGV2H+I+WYQwca4AHjf4vPRLOZgFRFthrmEgK1RyiL/HUcXfMH2V5VSFEMxsW27jQ9wHg7137gNKMs8nuhl3RTySqAjv52zVUkobVUEEtSTze+EsykRq2EOKI05+7pVnvWgOWTHgqfA1qIqoCOzYW4nBS7kvDgot1LqlhCyGOqFheQp8t/kxQgT/bOIWUS7tvV5njiarA7j99IrHUM5B9xOLkkoZ3+fxAVribJYToIfRbfksd8cCRda/npf2Za8M7OCQkqgK77ONNbM75Pl9xJo1aHBt9pzGh8EYZ2ieEYMdyG4P2/4ck6lH4w/FpfsG8NZf1mJ2pIjKw2zs1PWjEjZOI2WkjR9uKUj4GxZTxfN2PpCwihKDy5/cSixt3YPS1gwQmn7q3W/dsbKnl1HRTuBrSEcGp6SfDaIRGVwxJVFHjVsyM/SermYWs2ydEFLPZOGPPv9AAc2DkdQp18PRvjv91XSw6p6YHbHtpNa5RZ/FZ7AV8yVns0obygvlnMrRPiChXc+PtGPEBR4by/e7U10m7rGfcbAyKyB72yRpx4yQO/vFhvuP6FjcWNK9i+3UTe0x9SggRBiUlxK8tDmz95b/R+F/yuOJvM8PcsKNFVQ87M9fKgck/oYYkdGMWlaSRtWtNuJslhAgj/We/xdvisc/6FTChZ3WugSgLbIAYi39NEYPyYKUMc0NNuJskhAgTu03H9/XXmAPHGlBGBuf9NTw7ypxI1AW2nxa4rSAb8QoRzTbe+ASZ2EN1aycmbMOuYtxlPbNOGnWB7Y5Nopw0YlQj5aQBCt5807/iixAiauxcVMIFa+dj4MgUdCOK8p/OCXPLji3qAruiTw59KcOnGenHIUZ9shAOHIBp02QCjRDRQtfJvPFKDIHftX34bzj+O/YqLuzGHWXaK+oCO9f2Dp9YLiHJV8UBbSAx9v18VuKh9vJrYLVMoBEiGtQ8UUiCqyIUgBrgwozjru7br/FkRF1gD7j/Ria4PkGPHUQfdYgGLR7XF99Q+tg/KB8ta2MLEQ3qXnodDfDi71k3YmJ62mouv6Pn9q4hCgM747xcSh9/k0HObXwWezEJvhpqh53J2t+8w8ff9uD/WoUQncLx3CL6ln0DEFpG9XHm8rsVE3p07xoiNLBPdi2RoEOlDSxM/jWxRjfv8V22H07klRWZTJIOthC9m64Tf/tNoaVTfUA9sZRecUePHHcd9WuJADgGjOLG6p/QSCxjqGXbxl1875OpZPb0/16FEB1S+9ATxHucoVmNBuA5fsY9f+iZ//ajei2RoHMSN/Evw1VsM43kI75D/IBUHH9fFu5mCSG6kq5jfO5Z4MjGurXE8e0V94Z1Rb72iMrAXs0kztA2kuv5ikv4gJi92xn9yfMyrE+IXqz2oScwuBtCvWuAJ/hVj+1dtyYqAzum1s4Q3y7q4vqi4WV7ch5/Lb9K1sUWorcqKSH+j49habJqyH6y8NxyR8T0riFCa9gdddn+l1ibeilm3FgbdpPd8C3jqj7g/YPruDrcjRNCdLqaH/+MBI70rD2YeNJ8D/c+GDm9a4jSHnbCbTdysft9+hsP40XDoaXxnpqM5fNPw900IUQnq1heQnzp16Hp5xrgJIYrXr22xw/jaykqA5vcXAyfr8OTMxovZgY6d3AF73LKu89SvkXq2EL0JrX/c1tombdgD/v/xi/lkpkRltaEMbA1TSvQNC1f07RZrTyXqmlaXuA187ukATk5ZN14OR/HX0alOZNPY76D57Qz2fai1LGF6C223vUcA+1fNNucYAWTuf7Vy8LcspMTlsDWNK0AQClVHDjOb/GSa4BxSqmlgeePCvXO4MkZxYUN79HPvY8LGouI+/a/jPipzJ4RojfY/dxyhj9xa+g2oxcDHjT4wzMRdaOxqXD1sMcDpYHPS4G8pk8qpQqVUoWBw+wmr+1U376whiotDYWGixjSGsuo2iElESEind2mk37rtYB/ZIUCTPj4vzNf44pfRWhaE75RIqktjjNae5GmadlARbAnHhScmg7+mUCB2UDtpmlgUi72xwxlWONmdseOJHbaNMo3fkJGTuTVt4QQfttvfIjx1DYrhaxkMtNf73n7NLZm1apVTZfeGBr8pMsCO1D2SG/xcGkgfB2tPNeaAqXU7JYPdnRqelDu3VMpe/1ZBjTsoJYE+jj38PWEm9FfXE3GgukdPr8QovtVLC9h/No/ho4V4MZAYmHklEKadkQfeOCBXcHHuyywg/XnY1jHkV52NlDU8gWaphUopRYEPs9TSm3o7DZm5lrRvnif9b8oZGLx79kZO5zxa55Gv399Z7+VEKKb1N1yJ6nQbEbjY+e+y+968MYEbRWWGnYgzLMDNxtTm9x8LAp8zAfma5q2XtO09bStN35SMnIyMQ3sR4XBSqzbgUuLoeyV97rq7YQQXWj3c8vJ2r+uWSlkGVfwg5cic1RIS2Gb6RjsPQPFTR6bHPhYDAzrrrb4qmrI8JXhVWYsqpGcfz8N9uuIuFH1QkSxHcttDLp1WrMx124M7LzlD3w/8jvXQLROnGnBmJpEHYnUqgRqSORj1wRZV0SICKLrUFrwa0x4MNBkcSfTPfzowV6S1khgAzDqpxOJ1RqJo554Gjil0ca7NTIeW4hIsfTOEi5uXBHqXQPUksDZf7+jV/2iHJWLP7WUcWgTH+Xfx+GijYyM3ckG5yiqD6kTf6EQIux2LLdx3aLvHTX9fMsDkTn9/Hikhw0waRKjt7/DeYZPGen8gqks45L/u1TWFRGip9N1EmdcRjy1GAAP/sDemnMFZ9/fO240NiWBDWC1EnvHLRwwD6aeeGq1JPq59rL+98vD3TIhxHHsu/UhMp17UIH+tYYBFxb6vPyHMLesa0hgByRfO4WchP0kUYtVHSIFBxtWHJBNaITooWz3L6L/0j+i0DDjw4UBJ7FsL/yY9Am950ZjUxLYQVYrxl/dQY2WAhhoJIYfVL9A0WuS2EL0NDsXlTDiwR/hQcOIooEYjMCDF37AmJt74PbnnSQiAzu4lkiTufadImnWtZCSjA8DXs1MvK+G9PcWd+p7CCE6SNdJv2EqBhRmFAqIpZEfaYu5cWHvCutAxg0NHkdkYAfXEjnZRZ+OyWply/fuoFGLwasMmPBw5spHKV2xuXPfRwhx0r64tZBYTxUahJZOXUcev/x0ZsSsFdJWgYzbFTyOyMDuSiN+ey21xlQOxp5CPA2Upo9DTZsmI0aE6AHW3r+c05bejwFf4BENBcQX/okJvatz3SoJ7BYyc61UvrKMDOc+tllOo6/9G2zjfiQ70QgRZusX2ch7cBpGfJgAH+DBzOo5K3t13bopCexW7G/IwGMdQF/XblK1anI/fYGYvFHhbpYQUWtriY73Rzdg9O8ZE1rY6eucAi6e3/vGWx+LBHYrJrGaJepqVEw8JuUmw1RNyvVTpZYtRBjYbTq+Cy9krPpvs8DyYGTYy/eHrV3hIIHdipSpk/h50ivs9fVHmcz4PF4MRg3tqqlSyxaim5Xe/gQjvJupJx6ARkz40DhUuLzXjrc+Fgns1litxKx4hzFZdjweSKKWZJdOktfBxntlmJ8Q3WX3c8vJK56PAhKpx40REz62/mEFg2+OnlJIkAT2sYwcScz6NRw85yqqSAHNgIaPocuelV62EN3gq+dK6H/rVSjAiMIDGPDx8LnvMupX0RfWIIF9fJmZ9PvrfOqMyTiMGdSrBLaee4OMGBGii20t0Rl465Vo+DCh8AIGNOZzb6/ZPeZkSGC3QZ05jURPJXHUMeJjGTEiRFey2eA/37mPNCowBh7TgAMM4NKVd/S6yTHtEZGB3VVT01uz7aXVbBp9NSo2nhjcpBhq0W74iZRFhOgCug6PXrCcn7j+ElqBzws4icW9sphxl/Wu9a1PRKamt9OIGycx7ttX2OvpTyNm9qoB1HstbHhgWZe/txBRRdfZesPDLCy/mgpSMaBwYcIA7P7D22RfFn1d65ZT02XHmRPIzLVi+PAd4iZfTqKnltHqG7weA9verKd8y1QycqLrf3whuoSuUzf2PCbs3Y4LI5k4sJNKOg7e/l4hV0fpTcaWIrKH3d3SJ44k7pHf8lXMOXytnc43xjPYbRjChh/Mx27Tw908ISKarsPayfcRt3cbLkzE4kEnnUSc/MS6kgtfuTncTewxJLDbKPnaKQzNrGWU+pZTtW1c5nwH096dHBo/RerZQpwkXYf7zlrO+K/+AkAsbrxopONgetpH/PaTy3rVJrodJYHdVlYrcXNu46P0AnbGjqKaVNIaD5Hk1Nm0QLYSE+JkvHtfCU/vvxovBjT8CzoZUPwiYzFPrZkQ1SNCWiOB3Q7J104hf/gu6q1DiKMOs7uOOG8N9Yerw900ISLONwuW88O/XIgTM2Z81BGHBnx25i08tLn3rW3dGSSw28NqxfzuOzDhHHyYGNy4g2Sq6V/0NymLCNEOXz1XQs7cqwBFKnX4AAtuyjJymVj0oJRBjkECu70yMxmVP5CihO9j03LZrI2ixhcvw/yEaKOdi0oYfutkFAoTPrxogMay+Gswl6xG0vrYJLBPQsrUSUxMtXG6+pLR6hvyPP+l35uyxogQJ7JzUQn9r78IM42h/Rg1FAcYwBkfPC3DZE9AAvtkBG5AyjA/IdrumwXLybr+OxjwYcKHArwYsGPFvbKY4RMkrE9EAvskyTA/IdruPwtKyJ17JQbcmAL7MSqgggwOvv5JVM5iPBkRGdjduZbIMbUyzC/Ls5c+9btkzWwhmthaopMw9+dUkorCjBcNHxrlZHLw9U84c6aE9bHIWiKdKDjMrzFrCPHU0bdqK3Gqnux/PiW9bCGAvQsWMeD8UxjIHjKoxIQbDcVhwwBqV/5HwvoEWq4lEpGB3WMEhvmN/PlkdGM/zLgBMHudfHHVPKlni6j25c+eY+Dc69HwkkklGziD/WTxXsZ1xG76QsogJ0ECu6MyM0n+5f+w57LZWHCxVxtEPw5Rv/MQ+8+eJj1tEZU+v2sRY56/lUbMxOHEi4HR2DikDeTU5TIa5GRJYHeSMZP7UWbKwmLyUUUy/S3lbO1/IRuvl5EjInrYbTprJtxB3hPX00AsMbhpxIwRH4XmX2BY8a6MBukACexOknzdVDJG9WObeRRJ1FDVYGba1vlQW437tDPZuPDTcDdRiC61tUSn4vQLOfuzp/ECCTipIxYzbu5KKeTSr/8QdRsQdDYJ7M5itRL3wbsMnDSMZaPvISlJY2Py+Zy3+a/UmNLIueVivi5cE+5WCtHpdB2ev8OG4/wpDPPYaCAOE9CAmXicPDH+de7dfrOsDdIJJLA7U2YmWU/MYdieVdSNu5DR1Z+y15TNUNcW9pmGMmD2FEpXbA53K4XoNMHlUf/n6dMZy38xAAk04MZADB5+PfB1/mfFTJlt3kkksDtZZq6VAeveIe6skXz5u3cY6NnpD23PVspiB6JdNVVuRIpeY/nPlvPn/Vfhxgz4J8M0YMYA/OuWFdz7hYR1Z5LA7gIZOZlMWDCdc+ZdztaFq0j3lFFDKlbnPpK8DplYI3qFr54r4fo3p1FOOgk0oKGhABOKA4XvMu052Xygs0lgd7Exsyby1fQHcGNC08CgPIx651EpjYiIpevwzqzlnHprPvvpjxU7ZWTgQ7FpZAG1a75h8M2yB2NXiMjA7hFT09vhtIeupdaUysHYU4innvKYAVIaERFp/SIb6/tfwZV/mUoN8QxhD7sYTDpVbHhgJWNsS0ifIHcXO0vLqemaUipcbTlp8+bNU/PmzQt3M9qldMVmEqZchFm5UGgozcDGS+4k7swcRtw4icxca7ibKMRxffVcCSNuvYQYGgMrWIOddBKp55HJH/Hg+xPC3cReSdO0B5RS8yBCe9iRKPvykdim3YsXY6g0MrH4QRo+3UDVmRdIiUT0aN8s8JdAGonDhRENaMRMBhX8IOZtrn9Gwro7SGB3o2BpZH/CqXg1M9+kX8Bpn75AvTlNSiSiR6pYXkLpwPPJnXslVSSRigMLPryAES/PX/Q6C766TMZYdxMJ7G6UmWtF/XMZ8S4HX0+4mdEVqzHTyJC6b7F4naz/vey+LnoGu01n/aQ7SJ16AZn7v0RDkUQdZVhxYWbNkB9Ss2YTt34km+V2JwnsbpZ9+UhSN35C/PljWT/pLhKoZ782EKs6xDdvb+PdG9+UtUdEWO1cVIIaNYozP3kaLxrx1KEBHgxkUs4dQ/9J7ud/l5uLYSCBHQbBcdpnTB+G3diHQdo+6kjgZw1P8MU/tsoqfyJsvnrOv+diKhVogAkfjcShgC84i7/cUMLD62R8dbhIYIdR8nVTyRgYx2bjaJTRxGbjaMaavmJv/KlsWiC7sItupOt8ffPTDLn1chQaBnxogBuIoZGbE18nds1qbvnrBAnrMJLADierlZh/L2NMlh0ncYz0fs3FVe9wWtkHJC16nm1rpJctul7louXUDzqV/i88gAkPFtx4AjsvNpDMop+VMH/nTCbIQJCwM4XrjTVNKwAcQLZSqrCV5/MDn05WSs3tzrZ1q5EjiZl3L7V/LWGTrZasuu1Uu2JwxA/hk8mLOO+agZxzt4zTFp1L12F1oY3cF3/NyJ0rqCKZNKqpJol64gEfVfH9qX3zfX4iO8P0GGHpYQfCGqVUceA4v8XzeUBe4Pk8TdOyu7+V3WjKFE5p3Mwe0zByGr4gx2vjoso3ubfuPja/vgHHGTJOW3QeXYeff8fGpf87jpydKwBIpRoPZsx4OERfdt+ygD6718s2Xj1MuEoi44HSwOelQF7TJ5VSG5RSCzRNSwVKlVKl9GaBvSF/cLWL0tOnsc08iu3xZ7DNMJLrG16gxpiG4crL+eTGv8oIEtEh5SU2tl5wIw9vn4Fds2KnT2gSjAk3T3IXu1//L6Ofuw0pVvc84SqJpLY4zjjG68YBO1o+GFxLBPy7Cod79/ROkZlJ/O/mcOqUKbj66pQd9JLhO0wD8Qx2biWBOvZ99AGH/vE8tmtuIffuKVImEe3yzYLljJg7jXNQ+FCY8eHFiAf/JJhnzn2dGS/JuOqeYNWqVU3XShoa/KTL1hIJlD3SWzxcqpQq1jRtPlAU+Dyf49SpNU1bGHjt0uBjkbiWSJvZ7bB8OTU18N7LB5j0xdOUx/ZnYMN21qflk139FXsGTiTr4Hq0t98h+/KR4W6x6Ml0nUNPLmbXK6sYu/9fOIklngYO0xcXMdQZk9iccg5nLbpbyh89VNO1RLqsh900YFuxjiO97GygqOmTgUDfEbgZ6eDo4O+9MjPhhhtIAi7K19HHLaW/Zy9mXJxe8x9qvTEM3reGgxmjGTz1EkqXfSChLY6m6xx+uJDY554izVWFFQ8KRQL1gEZf/L+9TYt5j9c/zSFbsjoihKWGHQjz7EDvOrXJzcdgcC8ESps8f9QokmiQmWtl4KO3sfnUq/hk0v+yedBkLJqXnQmjOb2sCIc5k4QpF8sNSdHMzkUlVA0cRcbT9xPncmDCg50MNDTKScOLxrsxV/Po1et5fUOOlEAiSNjGYSulFiilipVSC5o8NjnwsTTwXLFSana42tgTJF07hbz4zXy7N4Wh7GHO8LfIqVmHk1iGN27CohpImCqhLfzrf3yQ/zADrr+IOJcDDR9GPGgoMinHjRGlmVn8sxLO3beEh5dKWEcamTjT0wVGkNx4/0A23P8OT3w6kc3T7kVDscs8gkTqqDD3IWHKRay6+o8yiiTK2G06Rde9xPIRd2AeNZyzP3gUL1ogqDW8GHFjZJl5OqunPoHR9i0/+bPMVoxUsoFBBLLbdMrGXsqAhh340IijgXoS8GKk3pjEzqvu4LSHrpVRJL3c+kU2Mn50BUmqgnSq8GDEiDfQrzZgxEMlGaz82TKu+L2EdKSSDQwiXGaulb5fvM+G6Q/iMsRRGjcGhYYJD+leO6PfepC6MeeEetx2m86au2UVwN7CbtP59xVPM/D6i8hQZSRTgwcNAC9GGjHjII3/fPdhjJtt0qPuRSSwI1RGTiYXv3k7dcs+Is5dhdIMmPDgxnhUcOtjL8O18wAHzpFVACOZ3aZTcsXD+EafxrgVvyeeOmJx4sKMCYUXAwa8vJj8a2rXfMvF791DRo4kdW8igR3hsi8fSfI3a/h62m+pMFrxaaZQcBs1H16DicyGPZj+W0J12mBZBTDC2G06q//nJT6ZdC9q1CjOXjGPJOUghSo8mGgkFg9m9Jh+HMiexIr71nDdjgcZPkGCujcK2+JPovMEe9vlW65j472Lyf7nUyT4atDwEeOpI4lqTt+7AhON2F8uYZWjRmrcPZjdprNpwTK0HdvJ+c+L5CiwUoYHEwa8+DDjDSyBWqb1QbvzTk6551r6ZGbSuxfdERF50/GGG25QQ4cO7T3T0jtZ+RY7G+9dzNBlz7K//zhydhehxw0mq6EUE16cxMjNyR5q56IS4n9cAD4fVspwYcGMGzuZJFNFDG6cWNCAP6bO4+qVN0lvuhdbtWoVF1988d+UUjdAhAZ2tI8SaavyLXY2LVhGxmvPkOncT5yqx40psJPIkeDefOkdlH/3WiZfZ8Uq2d3t7DadnfcWYt2wgn57PucgWQxiD+Vkkky1/zcl3FSSQhwNrIibQd2vfsvld+TIzcQo0HSUiAR2FAj2uIOlkhjlbBbcDcRQb0jiH8k3cdb3+pF93UTKPt7EiBtlHe7OpuuwdpnOJFaTMnEUpQvfx/L04/TnAG6MmPFQRTJmXCTgDIS0k78l/JyxYxrZc+VtXHizBHU0kcCOUscKboMGJuXGgosyrQ+pysH20Veh7dhO/IfvMmKipENH2W06Xz2zmoWfjOLp8h9yoNzC6Z4vqPIlkkQNAJWk04cyyuhDMg5eiv0555wpIR3tumXxJ9HztHpzUtVg8jlRaGw1jCTJVI/mMeDZvJ1sSln5nTnUvHg3tUVr0DTIvXuq9LrbStc5ULiMNW8dJG/jy9QOvoLC0v8hDiepGDDgJhYnDcSQQi2pVOJD8bE5n8I+v+XPH/injo8P93WIHkN62FGsfIudbQ8sJuffT9FQ5Sbdp1OvJRCvamgggURqqSKFWJxUG9Iw40I39mHvd28ivk+ShHcr7Dadbb9fTNLOL7Fu/wytXCcVB3XEkUItFaSSTiWH6UMfdFxYqNWSqFcxuIeOZP20h2g4fQJTpsj+AcJPetgC8Pe4MxbfDvbrML22nC8+q0FTipyVT2F3mEAzsJNsrJqdTGVnJ0PIcW8m892HaTTEUfPqo6yYs4wJl2dw6IVlUdkDDw7BM5YdJHnPN6R/+wlnKTtujMRTz34G4sJMPE4cpGLBhQ8D6VTixoSu9eX5xF8z/R/XMu6yTIaH+4JEjyY9bHGU8k83U3vxVAweN6DI9B3GqcVjVG7/olMxOfRv3EWFloFFNeLFiNnoAxQ+jOy46CbMg/v1qvC223S2vbQ6dCN2a4nOul8t5vz1T2PxOemrDuLDgIbCSSw6mfTjMD4MmPFQTQKpVPNJTD7jGkt4P2EaCRefQ8V3r2XytZnSmxbHJD1scVwZ546EjWvYtGA5aODNzyHl9p/wn7oxTKp/j36Nu/zDzZSPRGrZZxhCnLcKIz7MuMn6YB6HjVmUvf4sth/cRv/pEyJu1Elo8ooGyeNzSLzjJjynX4r3iZ/z4ZgfMPSrf/FdarDgxIKHKi0VnzKQQA2xOMmgAhNuPrBczqnuTWybcien/nA8GS+/xXuTnpGbiOKkSA9btI3dTvXy1RQdHM2wpfMZ9OVydhmGcopnGx5MxOHEiAcvJg5bBmFSLhLdlRxMHcVQx5esOft2hm94g23fvR3HiLHk2t4h5fsXUvXOx2ybdCOTZuWi2Zv3Ypu9ve3Yz7VHcFjd2IPLOLAfht7m/y0gGNC+qhrMjbUMLnoRvD4MPg+ZlLElaTyjaz6lkThiaaCeeFxYALDgIp56vBjxYkCnD/+Jv4zGH9/EYOMBzrhtkqzpIU6aDOsTHaPruC+bwg6GMeiLZXw28Xay176GER8m5aKvOkQ9ccTTwBecyTBtJy5lwhjY/DUNB2vNF3Ce+2M+jbmIvMY1FCbexXdcK2kceRYxm79An3Q1Gc797My9nAEbVxL35Vr2T7iaESUvsevCGzEkJ4SaExsLg0cn8XXiREazic9qR2HdvoZTs2rYvBn274c+w5JIv2Iib961hls9T2IpP0RcLOzz9cPzk5vQ/vY30tw6VnUQDQ0nMXg1MwbloVpLo5/aT62WTJyqo8qQRqKvGg8mnMRSb0xi7wXXkeY8iH3AmRy8UMocovNIYIuOs9th9Woq+o9m61vfMuKnkwA4fOs86koPkVB9iKzKTeyNGcFI5wb2GweT6K2mxpSCWXkxaW4MPg/Jvip8GACFER8fcAmXUIQBRS3xpFHNV5xBDjbsWEmgnkRqAl9D4OsUdtLJMFbzZ3ULN/kKaSSOhMD4ZtCwk0YGDjak5zO+YiUeLGh4MKP4lImMNtiw+Jx4DBZifbV4MWPA66/P42FrYh6n1a6hlmQSqeGw1g8nsWybcidjH79WetCiy0R8DXvXrl3MmzdP1hIJp8xMmD6ddGDChCP7TGW8/jvcU6bxku9yflLzFd+6hpOaVo+qrMNpTMDkcZLFQT4zn8+5vtUc1PqTqcrYoo1kqNrFCMMOfD4juqEvFuWkUhlJNDbg8VowaV6MysNhY38sPiea8pGKg2oS6YOdfd4B3MhLKDQ8GFFADck4tXgyVBllWj9GV6zGjYVYnKH/KBoSMvDWASgSfVUA1JJIozERl9fEtvE/YPhXb7H5Dyvh3eVUxg/A1zeLUXdP4bsS1KILrVq1CmBo8Fh62KLzBerda2pGcxrf8kXSJEaOhIN/WY7TCRV9RzLK9hZpk/NInXcn1fUmvMpAuq+c97RL+a76Nya81BNDGtUUa5OZqEqwY8Vs8JLhKwPAgA8NhYaiEQsWvHzLSEZhoxb/DEL/T7dGLQnE42Rj6gWc4ViFMllwezRiNDdvagWMjbdhqa+iZsRZJO/4gq8uvoNHd17LM8+A58PVjPip1KFFeEhJRPQcdjs1ry3ny6+gbNhEJiR+y9ra0WSsf5+0si2Ujp7C4G0fsuuSn3LGxRkc/MtyvA5/qcPcWMOoT19kQ2MuFzR+wHPqFn6QtJyK+ni2WE7jAtMaXtBuZsAAxXlbXmbn2TMY8vlbND76BIP+75c4x4zn8Mc2Nk++nT9snsKrr8LwA6spHz2Jj7/NZNIkmbwiwk8CW/QerfTmJ04E85rVrGYSE6b4b/6Vb7Gz7cUmPeVADV7CWfR0EthCCBEhZBNeIYSIQBLYQggRISSwhRAiQkhgCyFEhJDAFkKICCGBLYQQESIiAzs4NT0wbVMIIXqlllPTI3ItkaFDhyLjsIUQvV1graRdweOI7GELIUQ0ksAWQogIIYEthBARQgJbCCEihAS2EEJECAnsLhAtww2j4Tqj4RohOq6zN1yjBHYX6A0/GG0RDdcZDdcI0XGdveEae1Vgt+cb0t5vXld+s3tKu3vKNbb39fK97Pi5u6od7X29fC+PLyI3MNA07QVgXytPDaXJIPMTaM9r5dxybjm3nDtc5x6olLoJIjSwhRAiGvWqkogQQvRmEthCCBEhJLA7maZpBZqm5WuaNusYz+cH/szv7rZ1luNdo6ZpqZqm5QVeE7HXCG36XhZomlbU3e3qiDZe0zGfjxS98XsHEtidStO0AgClVHHgOL/F83lAXuD5PE3Tsru/lR1zomsErgHGKaWWBp6PyH/4bbhOgtcYKdrw83nCa44EvfF7FySB3bnGA6WBz0uBvKZPKqU2KKUWaJqWCpQqpUqJPCe6xkKlVGHgMLvJayPNca8zQp3omnrLNfeW6ziKBHbnSm1xnHGM140DdnRtU7pMaovjVq8x8NtDRbCXE4FSWxwf63sZSVJbHLe8phM9HylSWxxH6nUcJSI3MAinwK9b6S0eLg0Ek6OV546ilCrWNG2GpmkFPfFXs864RqBAKTW7s9vWmTrpOiOJg+Nf04mejxQOesd1HEUCu51OELDrOPK/ezbQ7KZG4CbcjkDJwEEP/aHqyDWCPwiVUgsCn+cppTZ0eiM7QUevMwKd6Jp6yzX3lus4ipREOlEgALIDNzlSm9z0CP7ALARKmzxfeIxT9VgnusbA4/M1TVuvadp6euh/SifShu9l8FrHBW9y9XQnuqZjPR9peuP3LkhmOgohRISQHrYQQkQICWwhhIgQEthCCBEhJLCFECJCSGALIUSEkMAWQogIIYEthBARQgJbCCEihAS2EC0E1kqeE1gON7iG+ZJwt0sICWwhmghMWS7Gv8LbuMDDn3P0CnBCdDsJbCGaK1VKOYBgcBM4lh62CDsJbCGaUEqVBtbyTm2xwUSkbsQgehFZXlWIo+UR6F2Dv0zSZMW3AvxLdhYHPpb21OVjRe8jPWwhjpaOf73yZgI971L8YT0z8JqI25dTRC5ZXlWIVmiatpDAwvctNzrQNG0OUCw9a9HdJLCFaKPAjkGPAh8opcb21C3eRO8lgS1EG2maNgt/SaSCwE46kbori4hMEthCCBEh5KajEEJECAlsIYSIEBLYQggRIf4fTEz2L/4P/voAAAAASUVORK5CYII=\n",
-      "text/plain": [
-       "<Figure size 576x576 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig, ax = plt.subplots(1,1)\n",
-    "fig.set_size_inches(8,8)\n",
-    "\n",
-    "ax.scatter(vel_close_arr[:,0],vel_close_arr[:,1],lw=3,color='b',label='leading arm ICs',s=0.5,)\n",
-    "ax.scatter(vel_far_arr[:,0],vel_far_arr[:,1],lw=3,color='r',label='trailing arm ICs',s=0.5,)\n",
-    "ax.legend(fontsize=20,frameon=True,loc='upper right')\n",
-    "ax.set_xlabel(r'$v_x$',fontsize=15)\n",
-    "ax.set_ylabel(r'$v_y$',fontsize=15)\n",
-    "ax.set_aspect('equal')\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 63,
-   "id": "0a037959-9a4a-4439-8051-3c1b68604a71",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import tqdm"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 533,
-   "id": "9da5147f-8831-431e-94af-b1fcf3734871",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████████████████████████████████| 2000/2000 [00:04<00:00, 439.75it/s]\n"
-     ]
-    }
-   ],
-   "source": [
-    "w0_lead_gala = gd.PhaseSpacePosition(pos=pos_close_arr.T*u.kpc,vel=vel_close_arr.T*u.kpc/u.Myr)\n",
-    "final_pos_gala = np.zeros((len(ts)-1,6))\n",
-    "for i in tqdm.tqdm(range(len(ts)-1)):\n",
-    "    t_int = np.linspace(ts[i],ts[-1],2000)\n",
-    "    o = H.integrate_orbit(w0_lead_gala[i],t=t_int*u.Myr)[-1]\n",
-    "    final_pos_gala[i,:] = np.hstack([o.pos.xyz.value.T,o.vel.d_xyz.value.T])\n",
-    "    "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 534,
-   "id": "9390efcd-991a-41ca-81c9-794b961a7b20",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([ 999.5       ,  999.50025013,  999.50050025, ...,  999.99949975,\n",
-       "        999.99974987, 1000.        ])"
-      ]
-     },
-     "execution_count": 534,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "t_int"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 535,
-   "id": "166a0913-ab94-4d5f-a4e3-013908a94ab7",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7fd38df90fd0>"
-      ]
-     },
-     "execution_count": 535,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAN8AAACiCAYAAADBRRgzAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAUmklEQVR4nO2de3RU1b3HPzszjKGNGgJyiUAYQxFQogHCU4ngCpZiLkUasVZX4SpKKxpFu6C1Vwn13t7CquXRouKjLSK018W1FCFQiTVGC5oXUEBQSBohGB8hiRolxgn7/jHnhMlkJpmQyZx5/D5rZTFn733m7CHzy96/3/7t71ZaawRBCD1xVndAEGIVMT5BsAh7KB6yYMECPWjQoC7dU1VVhdPpPK/nWXWvlc+OxHutfLZV9y5fvvw5rfUCALTWPf6zbNky3VXO5x6r77Xy2ZF4r5XPtupeIE8bdhG2086pU6dacm93sarfVn3m7j43Fj+zidIhiHbOnz9fO51Opk6daqlhBEJhYWHY9zHYyGcO3TOnTZu2QWs9H0JkfHl5eTovL6/HnyMI4Y5SarnWOg8k2ikIlhEWxtfsaiF/XzXNrharuyIIISMsjK/gYA23r32DgoM1VndFEEJGSIyvqqqKvLw8CgsLfdZnpSXzQu4UstKSQ9EdQbAE4/vvNK/bLbIrpRKBVONnnNZ6qa8yH/flAA1Aqtb6ac86p9NJRwEXh93GzNFdW4QXhEjDiK5Wmde+Rr65QIbWeguAUupuP2WtGIaH1rrAuM4KftcFIbpoN/J5jVqpwG7TqDzLvG4bB/yv8boSGAMUIAiCX/zmdiqlUoE6T8PzVWaQ6HXd1/PC9PmAiFhoF4RgUlhY6BnvcJovOkqsztFaLwygDNy+XpK/N+rM5ztfml0tFBysISstGYfdFvT3F4Rg4DngLF++vMos9xntVErlaK1XGq/H+CvzoIRzo5+vaWmPIEsUQiTTzviMYMkKpVSZUqoMSPJVZrTdDWAEYlKNdok+pqU9gixRCJGMJFYLQojwTqwOyWbanvL5vBEfUAhnAlnni1jEBxQiiagyPvEBhUgiLHI7g4WZpuZryik7JwSr8c7tDInxmT6flcGWgoM13LamiBVbD4kBCpYQ1T5fR2SlJfNg9pWs2vGO+IRCWBCSaGc44LDbWDp7FGOH9m31CSU6KlhJzIx80N4nlOioYCVRFXDpKhIdFUJJzAZcfOGw28hKS6bgYE27IIxER4VgE7MBF394Tj3rGpuY97s3qWtskimp0OPETMDFH55Tz7ue2stLxScAeOZHk2RKKvQoMe3zQdsgzKr5GcwZn8Kq+RltpqSNTc0yBRW6jbfP1+5QE9z78sYAOcAKj/Ic3JISPg9DAepx7+Nb4l3X3cM0rGJH+UmdOG+Tvn3t6/rieZv1X0ve11997dI7yk/qr752Wd09IQKhk4NSfIolmdcdcLPWero2NtxGA5kj+zMrI4W/llSbf2DEFxSCRjvj01o/rc+JKKXiFkQKhERD4yVqKDryMS+XneTB7JFsvO9arh81gKZmF4u+PZymZpdMR4Vu0SUBpU5IAuqUUuu1l85LpAooeQZjHHYb+fuquePJvZw9q1EKFt84krU7j/JC7hTRHRX84k9Aye9OdqXUEu8ppFJqt9Z6ekcPUkqtAEo8p6nRckpRs6uFXftPUXK8ljX5R7lx9KWkXJKAwx7H0tmjSIh3WN1FIczxPKXI58jnLZaktS7v5A3vBko7axfpOOw2ZmWkMCN9IFWfNLK1pLq1bu97tWxdMlUMUAiYgASUPMozTHVqo8xUKXvRuDaVqzsLzkQ0DruNm8antCl7+3gtmY/uoq6xyaJeCZGGCCidJ55T0NX5R1vL+3zTzq9+MJZZ4wZTdORj2TEhtBLVAkqhxHMKCrQaYP0XLhY+8zZ/O1DDttITbLo/U4IxAtA+tzPm08u6i8Nu45Gcqxl9WRJ73v2E8srTpDv78OzfK/jxDZez992PaWp2kT12sIyAQhvE+IKAw25jzgQncyY4aXa1cOeT/0ADfyk+QU2D2wecNXYg35s4RIxQaCXmdzUEm4KDNbxcWs3w5AtbDQ9gW9kp5q3bw4z/3i1BGQGQxOqgk5WWzOYHMnnlkek8lD2S7NGXtqkvqajj+mV/46W3qyQzJsbwTqwOSbQzWhbZz4fGpmbuenIP2/d90K5u/NAkJgy7hIfnpMn6YIzQ6SK7EDwS4h1suG8KW4vf54ld71JWVQ+AwwbFFXUUV9Rhi1NMGt5fliViDPH5QoDDbmPu5FReefQG1t2RwbABCVx4wTkjKzhwiltWFbFl778s7KUQasTnCyEOu40fTr2c/7p1DKe/POfvHTr1OQBLNpZJMCaKEZ8vDGh2tbinoX97l7J/1bep+7eLevGLW8aQ0LsXM9IHyjQ0yvD0+WTaaQGt09BHbuC+GcPb1H302dcsfOZtblv7Jr986Z8SEY1iJOBiIQ67jby56djiVJv8UJPHtx/hSPWn3HKNUxbnoxBJrA4DzGnoup1HKX+/wWeb9XeNJ6G3ezlCpqORiXdidTvjU0ol4paPSAXGaa2XGuU5wEJ/m2mN+gYg1UOGAhCfL1DcRniCxRuK+exM2+mmDWjB7SdszL0Wuy1OliYikM58vi4LKHns4yswrrOC3OeYwO0LXsbK2zPa1ZmmeBZ4tuAY319VxPayk6IhE8EES0BpnEe7StzSg8J5cvMkJ5tyr2XWGN9bkV575yM08NMXyrh1VZEoqUUowRJQSvS67ut5EakCSlZh7hW8ftQAXE/sYef+D7DFgets23Y1n37FxfE2NhYeZ+KwfiQlxFvTYaFDelRAyRBN2q21LjCmnNNNXxHE5+sO5o75379WwasdjHCzxw1i432ZIeyZcD50us7nLaAUwHuWcG70S8WtXC0EAYfdht0Wx+vvfMjM9EuxKd/tig7X8JPnS2hsag5tB4XzJigCSkYwJtVok9gFrU8hALLSktmUO4WNuVMoXZFNnA8DrPuyhfUFx8h67BVuXf06L+6plEBMmNPO5zMMZ6if8j5eZdM9XptTVDG8IGMe5gLwrQEXcfDxWWT/6lVq6r6gydW27eGTn3H45GdsLz8FwNzJUSUiHlVIYnUEktIvgX/++rusXzi5w3a//MshmYaGEZJYHUWYwZj6L5r5z83lNJxxtWszZcQl9E2IZ80d4yQaGgbIZtoowVySAOjdK447n3qrXZs3jn4CwMn6Rl75+Q2SERNGyK6GKGH2+CGsu2McDj/h0LKKeib9/GWuz9vFhw1fhrh3gi/E54sS3Bt1h/Gbee1T00zeq/mSkso6Jv5su/iCFuDt84XE+EzFasls6Xn6JFyALU4xL9N/lPP0Fy6+de8WrnskX0bBEOKtWC3TzihjRvpANt8/hV98P537Zgynl59F+S+aofz9BobnbmX2yr+LfIUFiPFFGeaa4FvHannilffobJn9LPDqoQ+57tGdoiUaYsTni1Ky0pJ5/t5r+MM9kxntTOy0fVXtGeat28NjWw6IAfYQ3j6fnFIUpXguQ7haNHc+tReACy+w8flX/o1rdf5RbHGKh+dcJcsSQUZOKYpBZo9PId7hNqRrR/TnsS0HePbvFX7bP779CMdqPmP9wkmipN2DiM8XA5ij4KyMFN46VsuG1yu5akhih/dsKzvFr7cdDk0HYxTx+WKMrLRkXsidwqIbLu+0bfHxWh7eXCaBmCDRqc/XiYBSAz4Ekoz6eqAU96baNptwxecLH8xoaLOrhYTeDjYVVZK/v/0hLuBOTXvj6Cco4I+LJjNngjOkfY02AlnnayegFKBA0s1a6+nehieEJ+ZU9Ll7JjNr7MAO22rg0T+X82HDlyLYFEQCFVAKRCAp0dB9ESKIhHgH35s4BD9r8a28f7qJcT/dzq2ri9i1/1RI+hbt+PX5vASUEr2q+7a/gySgTim1PnjdE0KB3RZHXJzigZkjeO5HE0mI9/21aPjSxVkNDY1NMgIGgY6WGnK01guN1w0YchL+MEdLpVSDoQHTqvMp6mXhjZmSlpWWDMCf3vwXBYc+8tv+oT+U0qRhw6LJxDvsIt7bCf7Uy3wanw8BpQ4Fkgxh3VKtdbmv95OAS3jjKVORv6+aVzswPIAmY/91acVpntr9Hi/kTmm9X2iP54CzfPnyKrM8IAElfwJJpoAS8KJxbQZm/KpbC+FNVloyf1w0mYzL3BOd/hf28tv2t7ve5WrnRbx+uIYX91SyrfSETEW7QFcElNoJJJkCSlrrBqDc+BHDi2AcdlvrksJ/PLGHR+eOJu/F/dR+7nv/X2nFp5RWfAocA9xTUVmSCAxZZBd8kj12MH96IJOCAzV+Dc8Xbx+r7cFeRTaSWC0EhOkHThzWj7P6LK4Wzc79H9CZ3NbG14+zOPsKBiR+IyT9jCQksVroEkkJ8Wy6/7pWpbSOMmIAPv/qLMNyt+Ls15sdD08npV9CCHsbWUhitRAQZkbMLdc4UUC/hI53O1TVnuHKB7exfve7Eojxg/h8QpfIHjuYm8anUNsYmB/4k41l3Lb2TW5bXRTzCdoimit0m8amZn697TAHKusoeKfjNUFvZqZfynP3TI7ZfYKdnlIkCB2REO8gb+5oRjn7dN7Yi/z9HzD+pzvkIBck4CJ0g6WzR1H1SSPbSqs524UJ1Mm6M9z51Fu4Ws6SmBAfs+lpIZl2zp8/XzudTsnrjELMKGjJ8VrW7DxKV75Ozn69OVl3hu9mpLBuwfion4oWFhYybdq0DVrr+SDrfEI3MaOgM9IHMvqyJFbvOMK+qvqA7q2qPYOz/zd5qfgErpYW1i+cRNGRj6N2JBTRXKFHMNPSJl1+SZfuq/r4C8CtGbPo2WJuX/sGBR0cfx1NiM8nBBWH/dzf8zjcorydkZHahwGJ3+AvxSe4aXwKmSP791j/wgkxPiGoLJ09ClucouWsZk3+0U7bD+nXm7LKeuLi6rlpfAovl53klmucMbFFSQIuQo/Q7Gpha/EJVvz1EO/VfN5h2wdmjsAWp8idOZK3jtVGrc/XacClG+plfusl4BJ7OOw25k6+jJljBnLXk3vYse8D7HHwtZ956Or8o1w1pA/xjuidjPWIelmA6mZCDJIQ72DDfVP48+JMRg6+2GebtTuPorXmn+/Xc9vaN7jrqb2t5wc2u1qiVi8mWOplgaibCTGKuT3p/x6aRnLiBW3qvtlL8Yd7JpP7nRFcMehiZqZfykvFJ1rVsgsO1kRtBNTvGO+pXqaUutmr2lu9LLGjehFQEgAGJH6D8pX/zpRHdnL8I/cSw6Th/Yl32PntrqOA4jtXJ6OAKwa5R0lTYdsUd4pEuiSgZNAV9bIO68XnE0wS4h28uuzbLHr6bYiDdQsmkBDfi+fvvZbyytM8vv0ICvi6RZO/r5qstOSIj3z6E1AKinpZAPWC0EpSQjx/evC6NmVmlkzFh41sLT3Jrn0fsGNfNbnfGcFVQ/pgt8UxI31gVEVBfUU7TfWynxlFS7XWW5RSS3yplxkS8T7rBaErOOw2nrx7ApdfehHzpg7lo0/P8JvtR1AKlILN92dG/CjoiazzCWHJY1sOsHLbYWZnDOamCYNbyz1HwGZXCwUHayJmXVASq4WIYHH2yNZ/E+Id5O+r5gdrigDF5vvdIr1mJDRSRHtFQEmICBLiHTySczXgXutztZzl9z+ejN0W1xr5zBzZn8U3XsHEYf1agzORMAKayK4GIewpOFjD/HX/IN5hZ1ZGSquBFR35mN9sP8ziP5ZG5FqgCCgJYY+vtb7GpmaKj33CvTNGsK30BItvvCLs1wJFNFeIODwPcgH3NHTRs8W8VHyCh7JHsun+zIiYcspmWiHiKThYw7ayk8wZn8JPZl1JVloyBQdrIi7/U4xPiDiy0pLZlDuFZ340iYR4B7v2n+IHa96IuBNzJdopRBze01A3Pb9eHWwk4CJEPO6TdTOZkT4wrLcgeQdcQmJ8ZsBFsluEnsAcCR12W1hPQSXgIsQAkTEFFZ9PiCrMKWi4r/mB+HxClOE5BQ03AvL5lFI5SqndXmVLlFJZSqklfu6pV0rt9lUvPp9gJeEShAnI5zPFk0wMg2rw2MfnS6PlZmNv38pgdVYQuoNpdLv2n2rN/QwXQ4TAp519gTqPa1/qZImG7osghAXmliOAF3KnkDmyPyu2HuK2NUVhkYQdaMBlPbBQKVUADAUqfLRJAuqUUus9tF8AEVASrMEzIdtht5G/r5pVO97hwewrQxqQ8Seg5HcnuykR4VWWCuQAld5TU482K4ASz3o5mVYIB8Jh53uXT6ZVSo0xRJUqcatYe/uEd/vxAwUhbAi3SKi/aGcWkOGhRF1ulOcA/+PRzoyIvuhR3y5gIwjhjFVBGBFQEmKebaUn+OHv/sHz917DrIyUHnuOCCgJgk805ZWne1QbVHI7BcGLGekDeSj7StbkHwnpEoTkdgoxj8NuY+nsUYwd2jekSxBifIKAvw26PYskVgtCiBD1MkGwCAm4CEKYIMYnCBYhPp8gnCddzYwRASVBCBJdPS9efD5BCBLdPS9ejE8Quog53QS6tUtCfD5B6CJdnW6a9KSAUo5Rf7d3nfh8QjTha7oZSPClRwSUPPbxmfW+NF4EISrwtSn3fEbDYAkojQMqjdeVgOxqF2KK8wm+BEtAKdHruq/nhQgoCdFOR4nZ/gSU0Fr7/AF2+yhLBZYAOV7lK4As43UWsMKzftmyZTpSeO2116zuQsiRzxw6gDxt2EVQBJSAEs6NfqnAbiKUWIzIyme2hqAIKBnGmGrcl6iNwEt36M5/jpX/sVb126rP3N3nxuJnNgmJgJJS6lmguou3OfEIy0bIvVY+OxLvtfLZVt07SGu9AEJkfIIgtEfSywTBIsT4BMEixPgMlFKJZlTXOG8ipoilz+zxe86xsh9ifOeYC2SYyyi+clSjFSNKHUvHu/3M+D0nWXmsnUgHGmitn/a4jOi1yq5gfPkqO20YJRh/VEuUUqlev/OQIyOfF8aXsS4Ya5URQqqRPBErDMXIVVZKrVdKJVrVETG+9uRor8M9oxWlVFYM/ZHxpEJr3QCUAZa5F2J8HhgpdCuN17GwM6PO2IOZgztDKRY+c4nH60SgwZpuiPG1YgQdViilypRSZbiPuY5qtNblxsiXRPudKVGJEWhJNPecWun3SYaLIFiEjHyCYBFifIJgEWJ8gmARYnyCYBH/D//Q6y/tcDqUAAAAAElFTkSuQmCC\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.scatter(final_pos_gala[:,0],final_pos_gala[:,1],s=0.5)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 536,
-   "id": "8e058dce-98b4-42ed-97ea-55d504749e1e",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array([0.000e+00, 5.000e-01, 1.000e+00, ..., 9.990e+02, 9.995e+02,\n",
-       "       1.000e+03], dtype=float64)"
-      ]
-     },
-     "execution_count": 536,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "ts"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 484,
-   "id": "80bb411e-6dd2-47f8-b82d-6cf291e28134",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(2000, 3)"
-      ]
-     },
-     "execution_count": 484,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "pos_far_arr.shape"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 485,
-   "id": "f8a23d5c-5b5d-4908-8cd2-1fc3121784fe",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(2000, 3)"
-      ]
-     },
-     "execution_count": 485,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "vel_far_arr.shape"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 295,
-   "id": "d2a34cba-741d-42ce-97b1-1d58264fa959",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array([0.000e+00, 5.000e-01, 1.000e+00, ..., 9.990e+02, 9.995e+02,\n",
-       "       1.000e+03], dtype=float64)"
-      ]
-     },
-     "execution_count": 295,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "i = 0\n",
-    "t_particle = jax.lax.dynamic_slice(ts,(i,),(len(ts)-i,))\n",
-    "t_particle"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 296,
-   "id": "6c6138a4-6ab7-4264-9427-a27c58e3b6ac",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<UnitSystem (kpc, Myr, solMass, rad)>"
-      ]
-     },
-     "execution_count": 296,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "usys"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 104,
-   "id": "822edcf2-0f72-4118-894a-2723167a9a0f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "params = {'m': 1.0e12, 'a': 10.}\n",
-    "pot = Isochrone(m=params['m'], a=params['a'],units=usys,)  \n",
-    "t0 = 0\n",
-    "dt = 0.5\n",
-    "n_steps = 4_000\n",
-    "w0 = jnp.array([50., 0., 0, (0*u.km/u.s).to(u.kpc/u.Myr).value, (150*u.km/u.s).to(u.kpc/u.Myr).value, (0*u.km/u.s).to(u.kpc/u.Myr).value])\n",
-    "\n",
-    "\n",
-    "w0_subhalo =  jnp.array([45., 0., 0, (0*u.km/u.s).to(u.kpc/u.Myr).value, (250*u.km/u.s).to(u.kpc/u.Myr).value, (0*u.km/u.s).to(u.kpc/u.Myr).value])\n",
-    "\n",
-    "\n",
-    "ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "### Compute the orbit with the provided potential\n",
-    "ws_jax = leapfrog_run(w0_subhalo, ts, pot.gradient)\n",
-    "\n",
-    "M_sat = 1.0e4 # TODO: mass loss rate\n",
-    "pos_disp = .00\n",
-    "vel_disp = (5*u.km/u.s).to(u.kpc/u.Myr).value\n",
-    "\n",
-    "\n",
-    "\n",
-    "#lead_ics = jnp.zeros((len(ws_jax),6))\n",
-    "#trail_ics = jnp.zeros((len(ws_jax),6))\n",
-    "\n",
-    "#for i in range(len(ws_jax)):\n",
-    "#    pos_close, pos_far, vel_close, vel_far = pot.release_model(ws_jax[i,:3], ws_jax[i,3:], M_sat, pos_disp, vel_disp)\n",
-    "    "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 105,
-   "id": "76e29d2c-ad35-4484-8ed7-ece9710ab752",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7fd86a761040>"
-      ]
-     },
-     "execution_count": 105,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAN8AAACiCAYAAADBRRgzAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAQVklEQVR4nO2dTWgcRxbH/0+OMDrMZlBALCIGWTEI+egkYu2TjJWjTpEVooMkkNbySeDLxjePb3IuhpxsrwSWDjJWopOPkfGcpEWLc3QIGEuQxSw6iFl0EMaWaw/TZbfHM5qu6ur66H4/MMxHq7rc0/+uV+9VvUdCCDAMY58O1x1gmKLC4mMYR3xi4ySzs7Pi888/BwDs7u6ir6+v7d8kOa4Ibbk4J7eVXVvLy8tLQohZAIAQIvN/N27cEJL46+NIclwR2nJxTm4ru7YAVESkC+tm5/DwsNHjTLXla7+SHsf9UjvOi34JCyPf1NSUuHHjhnjy5EmiJ0RSTLdnCl/7JYS/fStCv548eSIA3BeRLkhYCDVUKhVRqVQyP0+RGLr+CL+/PLB2vt7ySfzx07fWzpdXiOimEKICWHK4MOqsbe5g7p//wpsjP+KwL2uvUJpcbfodAVi8eh7jF07b7VTgsPg8YG1zB1fubsETnSkjAMzc2cLMna0PPp+9dAa3p4bcdCoAWHwOuLa8jcXHz113I3MWHz//4P85fLYHj66POOyRX7D4LNEz8wCHrwMd2gxRfbb3znRlU5XFlxlFGd10aTRVi2iiWvF2Tk9Pi76+PgwPDxuNr/gGCy49eR4Rq9UqLl68uCyEmAYsiS/PoYa1zZ2PHA2MGQZ7S9heGHXdDaNwqMEAA/PreFl75ez8WYwQowsbqD7bM9ZeWn5/eYDS5GpuR0MWnwK2zUrbT/7jPJEu447x+WGePKba4iOiW0KIH6LXYwBqAPqFEPcM9c0bbIwIvt9U4xdONx15bK+0kR5T369XErTER0QjAPqj12MAIITYIKIrRDQihNgw2EdnZHlj5cW71zgy2zJd8yBCZfERUT+AF7GPvgbwMHr9AsA5AEGLLwvRdXUS9pa+N9qmj8SFYMNUDVmEOiNffzTKyfflhu8/a/yD3d1dSG+nz+EG00/tctcJ/Hn3O2PthUajqZqlJSFF6KNFUa1WUa1W5ds++UIp1BA3KYnoZyHEZSK6BeDXSJAjAL6Rc0GJ76EG046UpRx65kyTpRB9tjLShBr2I4GVAfQT0TkA/8b70a8fwK9mummH7ulVvH6bvh3ecqOGnCtm4UE+fC2CMEWVdrILIX6LRr5uRIITQvyCuhBHAJRDcbYMzK+jNJleeMNne3CwMsHC0+T21BAOViZwsDKBwd6S0balKbq2uWO0XVMUboWLqRUpPs4t8kIWHlNfLJPCrnAxsSrFd1MmD8jra9IklZuBD1YmjLRngkLk7Vzb3EFpcjWV8AZ7SzhYmWDhWUSapLOXzhhrszS5imvL28baS0PudzWk9ar5Yq4wZkdCF2GgQu1qSOvJ5JCBn5gKU3QA+J9lMzQ+58ut2ZnGkyk9mCw8P9leGMXBygQ6U969b4GWSaFskDvxyfmdDh0Az+sCYv++mfmgKwHmSnyjCxvaYYTB3pJ1E4RJj3TKlLtOpGrHRTwwN+IbmF/Xjg0tXT2fux3TRePPu9+lHgVn7mxZ9YTmQnyn5h5qhRE6O8BzuxwhR8E0LD5+bk2AVsQndzXEVnYb49TcQ9QOj5T/rrd8Evv32czMI2nN0MXHzzG6YH6VZHT/98n3VsTX19eHSqViPManK7zZS2c4dpdz0pqh1Wd7xgUY3f+78n2wZufA/LqW8A5WJnhNZkFIa4ZWn+1l6oQJUnyjCxtaczyf1vUx9kjzu2eZFjI48a1t7mh5NVl4xSZNUD6rOGBw4tN5ErHwGKAelNcV4KcZCDAo8ek8gVh4TBxdAb5F3cFnkmBCDSw8xhS6AqwdHqWKAQYZahiYX1f+m6Wr57XOxRQDXQGm2dIUXKhhbXNH2bM5fLaHV60wbdm/P6ElgO5pM/M/78Wn6mDpLZ/kXQlMYnQW079+CyNL0JTER0RlIjpHRGNRvk75+RgRjRDRldQ9iqFqbnYAvHKFUUbHN2BiR73qyDcO4KsoXSCi2gzvajVEnxkZdnTMTd4SxOii4yNI6/1Uzdt5L1aFSNZs+BrvazfIWg2pUTU3TSbZYYrH+IXT6C2fVPqb2uFRquVnulWK+gHsRyniLzd8nbpWg+qC1nLXCV6vyaTmj5++VQ5pzdzZauvca1WrQTdv55gQYi56XUM9g3VLZKghKarLx4pcjIQxy8HKhLIAry1vH/vwjw84N2/e3JWfK3s7iWhMCPFj9Np4rYah64+Ujud4HmOa4bM9SsfrOl9UvZ0jAG4R0VMiegqg23StBpWUcF2dxPE8xjg6oSqduZ+qw2VDCPGFEOLL6N9G9PmP0Xc/Kvcghuqo52sZKCZ8VMMPs3fVF/x7FWRXGfVUPVMMo4pK1SSd3NPeiE91xQAH05msUc1opxr382ZXg8qk1XQdN4Zphcq91i6tSZC7GhrhHJuMLVTvteMsOC93Nais4UybmZhhVFEZ/VQsOC/Ep7KGkwPqjG2ysrS8EB/D+I6Kdz1pzM+5+FRie6orDxjGFCre9aQxP+fiU4nt8SZZJgSSxvy8CTUwjO+kDXEFG2rgFS2Ma9I6XrwKNaisauEVLUxIJPFlOBWfiTwYDGOTpHHmJL4M5w4XhgkJk3HmIMRH5LoHDGOeIMS3OMe71Zn8EUSogXerM3kg2FADw/iCbppKr0INDBMiptJUsvgYxhG6eTs/IEoZXwPQH8tozTDMMaQe+bKq1cAweceE2ZlJrQaGyTsmzM5yw/vUtRoYJk+YrtUQpwbDtRoYJk8Yq9XQBKO1GhgmBExscUstPtO1GhgmBP746dvUAjQS5zNVq4FhQiLtHtMgguxpqn8yTFao5JttRhDim1UsEc0wNlDJN9uMIHY1aBSAYRjvaNzVYGR5WTs41MAUjWbpJrza1cB1F5hQaZf8K0m6CafiU8mHoVq1lmGyxETyryAcLoBaZmuGCYFgxMcwvmAq9BWU+Nj0ZHygXSGUpAV9nIcaVCoPsenJ+EC7QiitCvp4l0CJKw8xIZHG+vIq1KDDqbmHrrvAFJh21pfKYmsvxKdSeql2eJRhTximNUkK+6gstvZCfKqll9jxwrjAdGEfL8QHqNVjYMcLY5sko55qMl1vxKdaj4FHP8YmSUY91WS6zkMNEtV6DDz6MbZIMuol8Vt4F2qIozpss+eTsUGSUS+J38LrUIPqsF07POJd7kymJJneqHjr43glPkBtxQsAzPAudyZDkkxvVL31EmXxEVGZiM4R0RgR3Yp9PkZEI0R0RasnETorXtLm0mCYZpQmV9seozvqAXoj3ziAr6KUgSCiK6brNajO/V7WXrH5yRgl6QNdd9QDNMQnhLgXq0TUj3p9BqP1Gm5PDaFTsWdsfjKmWNvcSZQcSbdIpkQ7hwsR9QPYF0JsENHlhq8/qNegU6th//5EomE/Tvf0KvbvTyj9DcM0kuRB3tmR3EGoVKshMiMb6y+8aMhGPSaEmIte15oc/w7dBEqDvSWleN7rt3XvVBpTgCk2nyZ84Ks85FvVamgqPjmfawURjcns1ER0DhnVa9heGFUe/X5/eYC1zR3loD3D9Mw8wNsEx6U1NyU63s4RALeI6CkRPQXQnWW9hoMVdTOS53+MKgPz6zh83T5DbFcnuavJHtVk+EII8WX0byP6PLN6DTpPGtURkykuowsbibNP7y19b+y83gXZm3F7akgrxycLkGnHteVtVJ/tJTp26ara4v92BCE+QC3HZxwWINOKa8vbiffoDfaWjPsRvNnVkASd+R/AAmQ+RkV4XZ1kxIPu9a6GJLAAmbSMLmwkFl5nh7l5nte7GpKia3uzAJmB+fXEczxALZ6nSpDiG79wWjvWwgIsLj0zD5Rq6ulaWUkJUnxA3QOquv1IUppcTbQ7mckPpcnVRHE8SdbCAwIWH1DffqS7pWPx8XPeCV8QVK0dG8IDAhcfUF+CpivA2uFR4rV8THiMLmx4KzwgsFBDK9II8C3qT0beD5gvuqdXlRwrQPbCaww1kGhX9cEAlUpF2CgLrRK7aUZv+aRSxmHGP3Tugc6ObL2acYjophCiAuTA7Ixze2oo1dPrZe0VO2MCpmfmgbLwessnne0BzZX4JGnNB3bGhIWc26l4M4F6si6Xlk4uxQfUBaizGFtSOzziUdBz1jZ3UJpUn9sB9YUarsvT5VZ8QH0xdtqNj4uPn+Mv7JDxjlNzD7X2bXZ21B/MPmy2zrX4gPTzQAAQqG/QZVPUPUPXH6E0uapVKm6wt+RVjp9chBqScLAyoVS4sBnSFOU8ofaRotOt0bF09bzz3D65DjUkYW1zx1iaCQ5NZM/Q9UepiuIM9paciy5OPNSgnTowVMYvnMb4hdOpf1TgfWjiBAH35s57MY/ICwPz60qLoBshAItX/f5NCic+iXwadk+v4nWSlFXHcCTqc8KZO1sYPtvj3IsWKmkXSUhmL50xluQoS1KJj4huCSF+iF6PoZ6/sz+W0dp79u9PGPvRAaD6bA+lyVU2SRVIO8pJfDMx25EmY/UI6jk6Ea/VENVuGDGZPjBrbk8N4fbUkBFTVCJNUgA8GjbB5LUud53QzvHjEi3xRaniX8Q++hqA9MPLWg3BiE8in5ombwzg/WgIhPd0Nonp60pULyfu87zuOHRHvv5olJPvyw3fp67V4JKsRAjUM2oXRYgmzfk4oYmuVa2GpqGG42o1xE1KIvpZCHE5qtP3q/wewDdyLgj4FWrQYXRhQ2sJkyqhizErsUny4FVuG2poU6thX6aFRz1FfGa1GnxBzteyFmF8VASAT04Q7v79b17ebGubO7hydwtH2YeJg38otULZ7BRC/AbUi2IiEpwQ4hci+kcWtRp8Iu40MeWhO443R+JdCENi23mztrmD2TtbsKCxj8i7o0rb2xmFE+7F3ssaDbkUXiMyjJC1qdVI3HmThMYb2JYJrUuRQjSFDbKbQoYpAD9vbFWxusBn8zpLWHwGCWmEcU2RRrhWWFlYPT09Lfr6+oIIM2SBy3mTT+R9DteOarWKixcvLgshpoEC7mrwAZueQpeEssbSJoXe1eADcmdFHNuOG9PkNRyQJSw+T4g7buL4NkoW3XQ0SdDiq1arXs4hTfar2Sh5HO3E+ua/z/DJX88C8GvFSBF+y0ZYfBngsl/txFqpVFCp+JPHRFLE39J6AqWkeVxM5ntJ0pav/Up6HPdL7Tgf+mXF20lEiwD+E73tQ6w65zEkOa4Ibbk4J7eVXVtvhBCzgCXxMQzzMbnP28kwvsLiYxhH5EZ80YZe+XqMiEaibU8u+lImonNRP7zol+tr0tAX765PIzb6lQvxtUrmFPvONuMAvpKbkqOkUs765ck1iePV9WnE1v0UvPhaJHOS72UyJ6sIIe7F0ifK/rnsl/NrEsfD6/MOm/dT8OJDPZlT/GKVG77/DI6Ifsj96KlZbvjaZr9cnrslHl2fONbuJ+9XuCRN5hSj1uR4q/2KvR8TQszZ7FcLXJ77OHy5PgDqJqXN+8l78fmazKlNv0BEYzK1hgdJprxLcOXZ9ZFYvZ+CNjuFEL9FT6puxJI5oX7hnCVzis59i4ieEtFTAN0u++XDNYnj2/WR2L6feIULwzgi6JGPYUKGxccwjmDxMYwjWHwM44j/A+V3ZNErxRTbAAAAAElFTkSuQmCC\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.scatter(ws_jax[:,0],ws_jax[:,1])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 106,
-   "id": "91b79ed3-f678-43a8-9113-3f7d19a42991",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from jax_cosmo.scipy.interpolate import InterpolatedUnivariateSpline\n",
-    "def get_spl_funcs(ts,ws):\n",
-    "    return [InterpolatedUnivariateSpline(ts,ws[:,i],k=3) for i in range(3)]\n",
-    "\n",
-    "def eval_spl_funcs(ts, spl_funcs):\n",
-    "    return jnp.array([spl_funcs[i](ts) for i in range(3)])\n",
-    "#spl_x = InterpolatedUnivariateSpline(ts,ws_jax[:,0],k=3)\n",
-    "#spl_y = InterpolatedUnivariateSpline(ts,ws_jax[:,1],k=3)\n",
-    "\n",
-    "splines = get_spl_funcs(ts, ws_jax)\n",
-    "spline_evals = eval_spl_funcs(ts[3], splines)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 107,
-   "id": "da7aebe5-7ec7-40f9-a125-254d2eab581f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "params = {'m': 0.0, 'a': 1.0, 'spline_eval_func': eval_spl_funcs, 'splines': splines, 't_min': 0., 't_max': 50000.,\n",
-    "         'm_ext': 1.0e12, 'a_ext': 10.}\n",
-    "\n",
-    "pot = Isochrone_centered(m=params['m'], a=params['a'],\n",
-    "                         spline_eval_func=params['spline_eval_func'],\n",
-    "                         splines=params['splines'],\n",
-    "                         t_min=params['t_min'],\n",
-    "                         t_max = params['t_max'],\n",
-    "                         m_ext = params['m_ext'],\n",
-    "                         a_ext = params['a_ext'],\n",
-    "                         units=usys,)  \n",
-    "\n",
-    "\n",
-    "ws_jax_time_dep = leapfrog_run(w0, ts, pot.gradient)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 108,
-   "id": "5144ccd5-d3b8-4441-bb7e-57755dcb02fc",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.colorbar.Colorbar at 0x7fd8555b40a0>"
-      ]
-     },
-     "execution_count": 108,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 2 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.scatter(ws_jax_time_dep[:,0],ws_jax_time_dep[:,1],c=ts,rasterized=True)\n",
-    "plt.colorbar()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 109,
-   "id": "40b5bfc2-72db-4dc5-b0b8-fa230be98651",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "M_sat = 1.0e4"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 110,
-   "id": "fa2aad7f-469e-47e8-abf4-a05dc401e101",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "lead_arm, trail_arm = pot.gen_stream_final(ts, w0, M_sat, pos_disp, vel_disp)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 111,
-   "id": "b1785306-222b-4c8a-838e-9dd345f682d6",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(4000, 6)"
-      ]
-     },
-     "execution_count": 111,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "trail_arm.shape"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 112,
-   "id": "96016b17-994e-4fbe-8477-5260eb3839f6",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array([-7.85247679e+00,  4.73463327e+01, -1.89712329e-02, -1.48014122e-01,\n",
-       "       -7.69234734e-02, -3.89401179e-06], dtype=float64)"
-      ]
-     },
-     "execution_count": 112,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "lead_arm[4]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 113,
-   "id": "bd2822d9-d784-45dc-a05c-e57a2ce38e19",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7fd86b14d940>"
-      ]
-     },
-     "execution_count": 113,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAANcAAACiCAYAAADSkljHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAASaklEQVR4nO3dfXAUdZ7H8fcvM+QCRAjheAy6uWFFkCcJD4oIggR8glvrDtwtiz21xKD4sKvusbt1ZUnuqk7x0N2tOsuHK92rda2rRbS8Ok8QgkRAQIEsLMjTQYg8CQTIBAKZhO753R/dnXQmkyeYnsfvqyo1M92Tnl96+pPfU/eM0lojhIi9rEQXQIh0JeESwiP+WGxk4cKFesiQIQBUVVVRWFjY5nMTvT4ZypAOZUyHv8GL1ygtLX1Xa70QAK31Nf+89NJL2uG+H02i1ydDGdKhjOnwN3jxGsBSbeci5s3C6dOne7r+Wl8/FmWQMsbnb4jH9j0to45xzeW19evXx+21rpaUMTZSsYx4WXN57Vr/28WDlDE2Ur2MKRcuIVKFhEuIzjKMLj09JuGqqqpi6dKllJeXx2JzIt108aBMSoYB69e3+7fYx3+h8zgm81yFhYUsXbo0FpsS6cY5KGfMAP9VHm7uA/pqt3Gt/P4O/wa7/1XV9CueF0pktk4clO0yDCgrA9MEnw+Ki5u3ZRjxDVsXX0vCJWKjvQO9swelU0O5n+/3W4GK3FYsakSPyYCG6JpofY5QqMP+SIdCIauGKitrvR2/v/nHvSyJgwVSc4muiFZbGAZs3AhTp3Z8oBtGyxouchvTp7cOUXuSOFgg4RKd5YQisrboTA0SClnrP/8cduyAW26B7Ozm/lMK1EJXQ5qFouPmnLvZFy0AkcucGsr53d/+1no8cyaMHw+zZ7ccmIi2jTQg81yZrqP5m1DIarJNntz+dkKh5tuyMquWMgzIyYGf/9y6zcmBu++2btMwTJHzXDEJlzPPlQrngmU0d4DcI3PRmmSGAXV1VrAmToQvv7QCU1fXeluhECxfDmfPWs+/4w5r2NyRk9N8Pw1D5Yic55JmYbqKrIncNVRkbeX3t2zGGQZ89hn87ndWsLZuteaZamvhN7+BYLDl7xsG1NfDW29ZNVxubutmXwaScKWjaE09dw0VWVs5E7Vnz1r9o1DIqnl+9jOr1pk+HaZNs2quwYNhwwYYN675dzdtgltvtZp/ubnNr5fhZA+kI78/+tB4tKafU2s1Nlo1z9NPW+saG62QvfkmjBoFI0bAiy/CokUwYQJ8+CHMnw/33dc8ySuBaiHq3lBK1QDbgbVa61ftZfOAIBDQWr8TtxKKznGP5EXOPTkBctaHQrBqlTUcPnMmrFsHd91lBQpg2TI4cMBqDhYUWM996CF48kkoKYH777eel6YDE7HS1p6Zr7Uucx7YwUJrXaaUKlFKFbvXiwSLNrk7dSqUl1uBmT27ZdjWrIGPPoK5c63+0zffwNix8PHH1vMbG60+1IYNsGcPXH89vPIKPPaYBKoL2upz5SmlAq7HE4FK+34lUORpqUTXOH0oaJ6T8vutUbtdu6wRvsmTrVCFQlbY5s6FnTvh+eet2+XL4eJF2LzZ2k5tLSxeDH/+sxWyp56y+lMSrE5ra0/lA+eVUm9rrRcBeRHr+7ofOPNcYA1HypB8HLmbe59/bt2OH9+8fNgwePZZmDPHGgHcssUKyqVLVoDGjIE//Qn274fvv7eailu3wq9/LWHqpPLycvccb6FzJ+qec/pUSqmgq6+V39bG5XquBHGag1OnNo8MVlfDggVw662YRePx1dfD8ePW6N8TT8CSJbB2Lezfj3npEj6lQGt4/HFrXU4O2J9BKTrHXaGUlpZWOctbhUspVQJs11pXuBZvo7n2CgBrPSqn6ApnVHDdOti+3RrJe+EFWL4cc99+9hw5y6iv1+Lr1ctqHpaUQEMD+P2Yly4BYGqNb8UKq5nonuwV1yxan2sFtBjEWKm1XgkElFLFQJ4MZiQRvx+mTAGlrHmq776DxYvxffBHRk4ehe/MGSt4L78MFy5AQ0NTsMJz5uLbssUaUpdgxVyrmktrHQQq7J+VruWv2nclWMkiFLJGBMGab1qwwArJ0aOwZQv+VasgHAbABJpOSHq8BP3ww3QbXySh8pD0VlOVYVijf5MmwaFD8Mgj0K9fc9igRbAAzEAA/Yf32djzeqaOLgCfnKDjJQlXqqqrg/feg6VLYffudi8b8QHmo4+i/205/r75TDXD+CVYnpNwpSLDgBUrrGH1c+esk2ppbvq1uC0osM4brDzCxmOXmJqXJ8GKE7meKxUFg9YAxZkzLYIVebtn7ASMAwdh+HB8s2cxdXSBBMtD8rmF6eDQIaiqanpoRqy+APR64ReMLC3F37OHtdDvl2aKx+RzC1NdMIg5eXJTsy+Szu9Lr9dfx/fjB2UkMMGkjZBiQm+8CbQOVg1weNYcNq34Av2Tn0iwkoDUXCnGXxts8dgAtk66m4Z/eZlpt91IoGcP6VclCQlXqgiFqLt4mXPf7KIWGAoc6tabgw+W0P2JhRRPCpCTLW9nMpF3IxWEQjT868u8xjDu27abI0OK+KJbT/b+9BkCowI8Pb5QgpWE5B1JZoZBqNHAqL3AJ+V7+ZujX/DWyHsoGzKORw5/yUf/d4kT/zRWgpWkYvKuOPNcci1XDBkG9Z+t5t3Vuzm/aTt78wrYUnQnD1duoC4nl38feT9P3TNCgpVEZJ4rRYQaDf7xaHf+KziI4t4FNPqyqe3Rmzduvo9GfzYAz/5odIJLKdzkcwuTnWFQd/Eyrz23nD9uPQnA8Avf89WAEZhZvqZgvfjASPJyZbg9mUmbIhm4PuKs9tPV/GhDkN6HLsIgMLN8/KVPYVOoAIb0UvzD9KEy5J7kJFyJZl+qb0y7k2DIYMqqGk7W+/ANGoWZZV2BtX7IGMwsH7l+6JHj4xcPjOOve/dIcMFFRyRciWTXWKFbJ7Pu29P86r2NnKy3AuUEy7k/qFcWQ/r0ZOLQAfx4SqHUWilAwpUoTo11+xS+evdjXj/jo+qCavW0iddncz7k4+7Rgxk7tB+9e3STEcIUIe9SotifNbhp7wn+fofCzGodLIBzl7OYPWYwz/3tSHYfu8DUEf2l1koRcj1XIhgGRkMjG/efZO7yr1o0AQEGdjPJ8cG8SYO4t+gGeuT42fldkKkj+kutlcRknivR7Mnh1RXHefJQT3AFKwfo7jN5oU8NIxfMofxgLcMKelN5po47hkuNlexknivBgiGDJ6u68eihnlyyg+UDRvTPofd1fj544U7OjLuNVz47ROMVk+7ZPp65Zzg52X427DuNYYYT+weITpM2Rhydrb3Mc+9/zSfbzzXVWJMK8zh3OUROTjb+BpOTtQbP/90t1NU3suNIDb4sRU62H78vi2kjBkjtlUIkXHFytvYyC9/6inXfVgPQOxsW3vVDVu0+xX8+cTuHqkNcuWLQ3Q7S3pMXmTl6EH5fFn5fFoZ8YlPKkXfLY4YZJlgX4rX//pZN31aTnQXDB/Vg3m0BqmpCzLh5ICdqr5Cb4+feoiEc+P4CALcP69dUYxlmWJqEKUhqLg8ZZphPth1l277T7K2uwQCWzLmJK2YWYwr7YIahe7aPO28e0BSkZ+4Zjt+XxYZ9p5uagdIkTE0SLg+drb3Mf6zZx4GTtTww8QfMenAwQwf1YWTBdQzMz6X821PcMbw/3xw+x7QRAwDIyfZjmOFWYZJgpR6Z5/JIsC7E78sP8/CMm/jVA2OpCTVSc8mg+mIDP31jM6fO1+HzWYMV7iA5TUCRemSey0OGGcYww5w6X8f7G6qov2KS7c+iuq6BuUU3AIrDpy/w+ydu4+PtJyiZeSNAqxpKmoCpST630COhRoM1u07w5a7vWb3nBDcN7k39FYOxhX0Im5ri0YPYdvg8T909nNzu2Szu16tV38ohwUoP8i7GgGGG+XTHMTb+5RSr95zkrYUTyb/ur3jzsduYOWogJ4KXAZgxamDT6Usyd5X+5F2NgWBdiHe/OMDOY9XcV3Q9NfVw79gC9p+q4+tD57h33BC2HT4fdUhdgpW+2n1nlVLLXPdrlFJrlVJLvC9WajDMMKFGg68PneOhKT/khv55PDX7RlDQs3s2d9zUn2y/j3tvKWiqtaSmyhxt9rnsr2gNuBbNl69rbWaYYT6rOA7AriPnGfWDPpTOH8MHX31HWGuenDWM3O7ZzBg1UPpTGSrqO62UCgCVEYvz7OUCqKtv5NMdx6hvNAlrzZ6jNew5foHHZgzlmXuGU1FVI6csZbi2aq6A1rpMqRYX8OUD55VSb2utF7lXOPNcQEZ8dqFhhtlWeY7ZYwvonu1jTGE+2f4sJgTy+cPGIyyefZM0/zJIeXm5e463sGmF1rrFD1Dsuv9hlPXLgHnuZS+99JLOFFcMU2utdX3DFb1m5wl98XKDXlVxTF+83KDX7DquL15uSHAJRSIBS7Wdi2j/Ws8rpYqVUvOAgFKqSClVopQq8iz6KcIww3y+8wSGGSYn2990ZbDPp6xaSiu5Ulg0aRUurXWFtgYu8oE8e/EKADtwaK1XxquAyaKuvpFQo8H/VByzPr/dDLP5YDWGGWbGyEHkZPtbDV6IzNbmkaC1fkdrPdQOW9C+Xam1/mU8C5gMgnUhlnywA8MMs3zBBHK7Z+P3ZXH7sH5sPljd9DwJlnCTo6EDoUaDiqoa/nn+WCqqalo0+2TeSrRHOgjtCDUabD5Y3XTh4rQon80uwRJtkSOjDU6fatLQvi1qq8jTl+TqYNEWuZ6rDU6f6pvD51oEKNq1VxIwAXI9V4fcZ1W4+1ROkJwrhkGuvRItyecWtqO9s9bbCpIES7RFjgybU2PdPqxfm4GRIImukKOF5hrLGR2UPpSIhYwPlxMkZ1RQ+lAiVjJ6nssww6zfc4pG02Tv8dqmz2SXS0VELGR0uPy+LGaMGgjAnSMGNAUr2ofGCNFVGT/P5QTImc+S4XVxtWSeK4rIQEmwxNXI+HmutkYCJVAi1jLqiJLTlUQ8ZVS4OpokFiKWMuook0liEU8ZEy7nEhKpuUS8ZMw8lwyxi3jLqHkuCZbwksxzCeGRjJ/nEiJeJFxCeETCJYRH0jZcMpclEi3twuV86bec5iQSLW3C5Q4V0OJTmoRIhLSY54oMlTOfJbWXiKe0nOeKdvaFnJEh4i1t57mihUiCJRJJjj4hPCLhEsIj7YZLKbXMdX+e/XWuJd4XS4jU12a4lFLFQMC+73xda5lrnRCiHVHDpZQKAJWuRRNdjyuBjP/ycSE60tZQfEBrXaaUch7nRazv637gzHOBNRxpD0kKkRHKy8vdc7yFzp1W4VJKFTvNP5cgkN/WxhM9zyVEIrkrlNLS0ipnebSa67zdp8oDAkqpImAbzbVXAFjrXVGFSA+t+lxa6wq75srHDpTWeiVW0IqBvCg1mxAiQpunP2mt3wHecT1+1b4rwRKiE2QSWQiPSLiE8IiESwiPpMX1XEIkg7S8nkuIZJC213MJkWwkXEJ4RMIlhEckXEJ4RMIlhEckXEJ4ROa5hIgRmecSwiMyzyVEnEi4hPCIhEsIj0i4hPCIhEsIj0i4hPCIzHMJESMyzyWER2SeS4g4kXAJ4REJlxAekXAJ4REJlxAekXAJ4RGZ5xIiRhI2z2WYYfw+qShF+krIPJdhhtmw7zSGGY7HywmRFOISLr8vi2kjBkjNJTJK3I52CZbINFGPeKVUsf2zzLWsRim1Vim1JH7Fay0VBk2kjLGR6mVsFS77O5CL7K9mLVJKBexV87XWs1zfMJkQqb7Dk4WUMTa6FC77O5FfVUrlAZVa60p7VZ4raFf1YrFYf62vH4sySBnj8zfEY/tellFpraOvsL5cvMipqZRSJcAKYJnWelHEc/8X6Gk/DAFb23nNQlzDlQlYnwxl6Gh9MpThWtcnQxk6Wh+r13DfXtJa3w/thAtAKfU2sFZrvdK1bBmwzb1MCNFatD7XMruWAggC+UqpErsvJoTopFY1l92vcg9iLLL7X87yiVrrX8a1lEKkoHabhclIKTUPWKS1nuVaVgNsx2rCJnQ00y5PtDLOw2oJBLTW7ySqbNEk2/6D5N5f0Ll9lnIzu2309ZJimsARWUb7QMGe3nAGi5JJUu2/FNhf0Il9lnLhakOnpgkSaCLgTGlUAsnWf022/Zfs+ws6sc/SJVz5wHl7dDMZ5UU87puIQrQj2fZfXsTjZNtf0Il9FpNLTmLJbhLkRyyudJoI0ThtcqVUUCk1z+tpgqsoYzDK8+Omo/LGe/91QpAE7q/O6Mw+S7pwdfWNtacNtmutKzwqUitXcfBto/m/cQBYG9MCdaC98iZi/3VCQvdXRzq7z1KuWWh3bic4nV6ss0bcneBE/9dtVUa7TAF7eV57tXACJN3+S/L9BZ3cZyk3FC9Eqki5mkuIVCHhEsIjEi4hPCLhEsIj/w9cRL1apjCWswAAAABJRU5ErkJggg==\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "#plt.plot(gala_orb.x,gala_orb.y,color='r')\n",
-    "plt.scatter(lead_arm[:,0],lead_arm[:,1],s=.01,zorder=2)\n",
-    "plt.scatter(trail_arm[:,0],trail_arm[:,1],s=.01,zorder=2,color='r')\n",
-    "\n",
-    "#plt.xlim(-70,-40)\n",
-    "#plt.\n",
-    "#plt.scatter(trail_arm[:,0],trail_arm[:,1],s=0.05)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 114,
-   "id": "c58af92e-11a3-420e-b1cc-a66274d792db",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7fd86a2ed850>"
-      ]
-     },
-     "execution_count": 114,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "#plt.plot(gala_orb.x,gala_orb.y,color='r')\n",
-    "plt.scatter(lead_arm[:,0],lead_arm[:,1],s=.01,zorder=2)\n",
-    "plt.scatter(trail_arm[:,0],trail_arm[:,1],s=.01,zorder=2,color='r')\n",
-    "\n",
-    "#plt.xlim(-70,-40)\n",
-    "#plt.\n",
-    "#plt.scatter(trail_arm[:,0],trail_arm[:,1],s=0.05)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 115,
-   "id": "19af8516-e9e4-4152-a921-1f7c24ba3949",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import astropy.units as u\n",
-    "import numpy as np\n",
-    "import gala.potential as gp\n",
-    "import gala.dynamics as gd\n",
-    "from gala.dynamics import mockstream as ms\n",
-    "from gala.units import galactic\n",
-    "import matplotlib.pyplot as plt\n",
-    "pot = gp.IsochronePotential(m=1.0e12*u.Msun,b=10*u.kpc,\n",
-    "                                              units=galactic)\n",
-    "H = gp.Hamiltonian(pot)\n",
-    "prog_w0 = gd.PhaseSpacePosition(pos=[50, 0, 0.] * u.kpc,\n",
-    "                                 vel=[0, 150, 0.] * u.km/u.s)\n",
-    "\n",
-    "df = ms.FardalStreamDF()\n",
-    "prog_mass = 1.0e4 * u.Msun\n",
-    "gen = ms.MockStreamGenerator(df, H)\n",
-    "stream, prog = gen.run(prog_w0, prog_mass,\n",
-    "                        dt=.5 * u.Myr, n_steps=4000,release_every=1,n_particles=1)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 116,
-   "id": "cafd98d1-2331-416b-9229-45ea17ab39c6",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7fd8579f0610>"
-      ]
-     },
-     "execution_count": 116,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.scatter(stream.x,stream.y,s=0.0905)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 117,
-   "id": "3997a668-8714-421c-9bae-80d3f90d6077",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(8002,)"
-      ]
-     },
-     "execution_count": 117,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "stream.x.shape"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 124,
-   "id": "6f806fca-5b98-4c01-befd-bad2227bc3bb",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 576x576 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig, ax = plt.subplots(1,1)\n",
-    "fig.set_size_inches(8,8)\n",
-    "s = 0.05\n",
-    "ax.scatter(lead_arm[:,3],lead_arm[:,4],s=s,zorder=2,color='k',label='Jax (1e4 Msun)',rasterized=True)\n",
-    "ax.scatter(trail_arm[:,3],trail_arm[:,4],s=s,zorder=2,color='k',rasterized=True)\n",
-    "\n",
-    "ax.scatter(stream.v_x,stream.v_y,s=s,color='cyan',label='Gala (1e4 Msun)',rasterized=True)\n",
-    "lgnd=ax.legend(fontsize=20)\n",
-    "lgnd.legendHandles[0]._sizes = [30]\n",
-    "lgnd.legendHandles[1]._sizes = [30]\n",
-    "ax.set_xlabel('$v_x$ [kpc/Myr]',fontsize=20)\n",
-    "ax.set_ylabel('$v_y$ [kpc/Myr]',fontsize=20)\n",
-    "\n",
-    "#####plt.savefig('FurtherTuned_jaxvgala_mockstream_Samemasses.pdf',bbox_inches='tight')\n",
-    "#plt.savefig('alignment_jax_galavxvy.pdf',bbox_inches='tight')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "bbce76de-00f5-459c-a4ba-7c25289eb6f4",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "4a62fd2a-01b2-4c3e-b670-0e091d6660a2",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "78b47ee9-c5cd-478b-ab3c-e8a3dc0d5ca4",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "340fa484-017a-461b-ab17-df6a204150c1",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 151,
-   "id": "890f1d93-4954-42e5-b348-849ea2dfa39f",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7fd44bd017f0>"
-      ]
-     },
-     "execution_count": 151,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "#plt.plot(gala_orb.x,gala_orb.y,color='r')\n",
-    "plt.scatter(lead_arm[:,0],lead_arm[:,1],s=.01,zorder=2)\n",
-    "plt.scatter(trail_arm[:,0],trail_arm[:,1],s=.01,zorder=2,color='r')\n",
-    "\n",
-    "#plt.xlim(-70,-40)\n",
-    "#plt.\n",
-    "#plt.scatter(trail_arm[:,0],trail_arm[:,1],s=0.05)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "bb9d756f-4a5a-4311-a247-1519dbfd68f8",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7fe351c53910>"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "#plt.plot(gala_orb.x,gala_orb.y,color='r')\n",
-    "plt.scatter(lead_arm[:,0],lead_arm[:,1],s=.4,zorder=2)\n",
-    "\n",
-    "#plt.xlim(-70,-40)\n",
-    "#plt.\n",
-    "#plt.scatter(trail_arm[:,0],trail_arm[:,1],s=0.05)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "a17bf61b-6eb2-44c5-b3ae-aff9bcf76068",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7fe34dfbcbe0>"
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "#plt.plot(gala_orb.x,gala_orb.y,color='r')\n",
-    "plt.scatter(lead_arm[:,0],lead_arm[:,1],s=.4,zorder=2)\n",
-    "\n",
-    "#plt.xlim(-70,-40)\n",
-    "#plt.\n",
-    "#plt.scatter(trail_arm[:,0],trail_arm[:,1],s=0.05)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "3bc559e5-78a2-4bfb-a48e-9bfaf7f65ab7",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(2000, 6)"
-      ]
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "lead_arm.shape"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "5570b804-92c7-48c4-afb2-50cb82de2711",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Text(0, 0.5, '$y$ [kpc]')"
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 576x576 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig, ax = plt.subplots(1,1)\n",
-    "fig.set_size_inches(8,8)\n",
-    "ax.scatter(lead_arm[:,0],lead_arm[:,1],s=10,color='k')\n",
-    "ax.set_xlabel(r'$x$ [kpc]',fontsize=20)\n",
-    "ax.set_ylabel(r'$y$ [kpc]',fontsize=20)\n",
-    "##plt.savefig('sample_stream.pdf',bbox_inches='tight')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "3ac0bd55-78a2-4a85-aa9a-5521a503d369",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/latex": [
-       "$48.889611 \\; \\mathrm{\\frac{km}{s}}$"
-      ],
-      "text/plain": [
-       "<Quantity 48.88961108 km / s>"
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "(.05*u.kpc/u.Myr).to(u.km/u.s)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 68,
-   "id": "329b8c08-ecf5-4514-9669-e7628153dc7c",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7fe2a3a1dfd0>"
-      ]
-     },
-     "execution_count": 68,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import jax.scipy.stats as statsjax\n",
-    "kde = statsjax.gaussian_kde(lead_arm[:,:2].T,bw_method=.05)\n",
-    "key = jax.random.PRNGKey(3)\n",
-    "samps = kde.resample(key,[len(lead_arm)]).T\n",
-    "ll = kde.logpdf(lead_arm[:,:2].T)\n",
-    "plt.scatter(samps[:,0],samps[:,1],s=.4)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 69,
-   "id": "d0cdad0d-aad3-4078-9db6-fd375faed875",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import jax.scipy.stats as statsjax\n",
-    "\n",
-    "def stream_gradients_kde(params,ts,w0,Msat, pos_disp, vel_disp, kde, units):\n",
-    "    #pot = Isochrone(m=params['m'], a=params['a'],units=units)\n",
-    "    #lead_arm, trail_arm = pot.gen_stream_final(ts, w0, Msat, pos_disp, vel_disp)\n",
-    "    \n",
-    "    # Compute the gradient of the final position with respect to the potential parameters\n",
-    "    def gradient_fn(params):\n",
-    "        params_else = {'spline_eval_func': eval_spl_funcs, 'splines': splines, 't_min': 0., 't_max': 50000.,\n",
-    "         'm_ext': 1.0e12, 'a_ext': 10.0}\n",
-    "\n",
-    "        pot_with_params = Isochrone_centered(m=params['m'], a=params['a'],\n",
-    "                         spline_eval_func=params_else['spline_eval_func'],\n",
-    "                         splines=params_else['splines'],\n",
-    "                         t_min=params_else['t_min'],\n",
-    "                         t_max = params_else['t_max'],\n",
-    "                         m_ext = params_else['m_ext'],\n",
-    "                         a_ext = params_else['a_ext'],\n",
-    "                         units=usys,)  \n",
-    "        \n",
-    "        \n",
-    "        #############pot_with_params = Isochrone(m=params['m'], a=params['a'],units=units)\n",
-    "        lead_arm, trail_arm = pot_with_params.gen_stream_final(ts, w0, Msat, pos_disp, vel_disp)\n",
-    "        #kde = statsjax.gaussian_kde(lead_arm.T,bw_method=.07)\n",
-    "        log_like = jnp.sum(kde.logpdf(lead_arm[:,:2].T)) \n",
-    "        return log_like#jnp.sum(lead_arm**2) \n",
-    "    # Compute the gradient using JAX's autodiff\n",
-    "    gradient_eval = jax.jacfwd(gradient_fn)(params)\n",
-    "    \n",
-    "    ####grad_eval_func = lambda params: jax.jacfwd(gradient_fn)(params)\n",
-    "    ####second_grad_eval = jax.jacfwd(grad_eval_func)(params)\n",
-    "    \n",
-    "    return gradient_eval, None###second_grad_eval\n",
-    "    \n",
-    "params_ = {'m': params['m'], 'a': params['a']}\n",
-    "\n",
-    "gradient_eval, second_gradient = stream_gradients_kde(params_,ts,w0,M_sat,pos_disp,vel_disp, kde, usys)\n",
-    "    \n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "480f776a-954c-4164-a59c-ca1a6f5e4bf9",
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "NameError",
-     "evalue": "name 'gradient_eval' is not defined",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_13799/1904551622.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mgradient_eval\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-      "\u001b[0;31mNameError\u001b[0m: name 'gradient_eval' is not defined"
-     ]
-    }
-   ],
-   "source": [
-    "gradient_eval"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 58,
-   "id": "29ad17f7-0baf-4a9b-8323-1851e1e2f2a9",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'a': Array(0.00073853, dtype=float64),\n",
-       " 'm': Array(-1.02281395e-10, dtype=float64)}"
-      ]
-     },
-     "execution_count": 58,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "gradient_eval"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 39,
-   "id": "2c16ab5c-5121-4126-9a7c-1eb098c2b4fa",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'a': Array(0., dtype=float64), 'm': Array(-0., dtype=float64)}"
-      ]
-     },
-     "execution_count": 39,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "gradient_eval"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "3089f3b2-24ae-49ae-8dfa-a9124c24a622",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "38848e17-59ac-4caa-b073-35fd0beff9b4",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 67,
-   "id": "5ca1c2d6-fcde-4529-b92f-8a4e5e225359",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "params_ = {'m': params['m'], 'a': params['a']}\n",
-    "\n",
-    "gradient_eval_2d, second_gradient_2d = stream_gradients_kde(params_,ts,w0,M_sat,pos_disp,vel_disp, kde, usys)\n",
-    "    "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "id": "2c3f55e6-5593-4a56-b495-9cc1b0aef2e5",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/latex": [
-       "$9.7779222 \\; \\mathrm{\\frac{km}{s}}$"
-      ],
-      "text/plain": [
-       "<Quantity 9.77792222 km / s>"
-      ]
-     },
-     "execution_count": 17,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "(.01*u.kpc/u.Myr).to(u.km/u.s)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 40,
-   "id": "c14385a2-a3cd-4ee2-a4b1-fb80164d6ae1",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(7.0, 1.0)"
-      ]
-     },
-     "execution_count": 40,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "np.log10(params['m']), params['a']"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 41,
-   "id": "1e3d5bb6-432f-44a9-966e-ef9f07d5ca74",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'a': Array(-0.06254839, dtype=float64),\n",
-       " 'm': Array(3.20675563e-09, dtype=float64)}"
-      ]
-     },
-     "execution_count": 41,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "gradient_eval"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 68,
-   "id": "6878ce67-abe8-4686-b6d4-ac023c7ddc91",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'a': Array(1.47724978, dtype=float64),\n",
-       " 'm': Array(-2.04594388e-07, dtype=float64)}"
-      ]
-     },
-     "execution_count": 68,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "gradient_eval_2d"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 42,
-   "id": "7c6152f9-365c-4657-b276-4785165aa531",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "Mass_unit = 1e6\n",
-    "I = -jnp.array([ [second_gradient['a']['a'],second_gradient['a']['m']*(Mass_unit) ],\n",
-    "            [second_gradient['a']['m']*Mass_unit, second_gradient['m']['m']*(Mass_unit**2) ] ])\n",
-    "I_inv = np.array(jnp.linalg.inv(I))\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 70,
-   "id": "79665b2c-6ecb-4123-a398-3490e965e930",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([[0.14517923, 0.55630666],\n",
-       "       [0.55630666, 3.34432455]])"
-      ]
-     },
-     "execution_count": 70,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "Mass_unit = 1e6\n",
-    "I = -jnp.array([ [second_gradient_2d['a']['a'],second_gradient_2d['a']['m']*(Mass_unit) ],\n",
-    "            [second_gradient_2d['a']['m']*Mass_unit, second_gradient_2d['m']['m']*(Mass_unit**2) ] ])\n",
-    "I_inv_2d = np.array(jnp.linalg.inv(I))\n",
-    "I_inv_2d"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 44,
-   "id": "18e074dd-c26f-4d30-bf23-e9b05c50b46e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "e_val_true, e_vec_true = jnp.linalg.eig(I_inv)\n",
-    "e_vec_true_0 = e_vec_true[:,np.argmax(e_val_true)]\n",
-    "e_vec_true_1 = e_vec_true[:,np.argmin(e_val_true)]\n",
-    "\n",
-    "theta_true = np.real(np.arctan(e_vec_true_1[0]/e_vec_true_0[0]))\n",
-    "w_true = 2*np.sqrt(np.real(e_val_true[0]))\n",
-    "h_true = 2*np.sqrt(np.real(e_val_true[1]))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 71,
-   "id": "31e007b0-34b8-49bc-8321-aa788582d96f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "e_val_true, e_vec_true = jnp.linalg.eig(I_inv_2d)\n",
-    "e_vec_true_0 = e_vec_true[:,np.argmax(e_val_true)]\n",
-    "e_vec_true_1 = e_vec_true[:,np.argmin(e_val_true)]\n",
-    "\n",
-    "theta_true_2d = np.real(np.arctan(e_vec_true_1[0]/e_vec_true_0[0]))\n",
-    "w_true_2d = 2*np.sqrt(np.real(e_val_true[0]))\n",
-    "h_true_2d = 2*np.sqrt(np.real(e_val_true[1]))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 73,
-   "id": "c79922a1-aaba-478a-b91e-5513abe4ab03",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 120,
-   "id": "8b9c692b-947c-44db-a2f5-d98ce854d034",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x432 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig, ax = plt.subplots(1,1)\n",
-    "fig.set_size_inches(6,6)\n",
-    "ellipse_true = Ellipse(\n",
-    "        xy=(0, 0),  # Center of the ellipse\n",
-    "        width=w_true,\n",
-    "        height=h_true,\n",
-    "        angle=np.rad2deg(theta_true),  # Rotation angle in degrees\n",
-    "        fill=False,  # You can set this to True if you want a filled ellipse\n",
-    "        color='b' ,lw=1.5,label=r'6d Phase Space, 10 km/s uncertainty' # Color of the ellipse\n",
-    "    )\n",
-    "\n",
-    "ellipse_2d = Ellipse(\n",
-    "        xy=(0, 0),  # Center of the ellipse\n",
-    "        width=w_true_2d,\n",
-    "        height=h_true_2d,\n",
-    "        angle=np.rad2deg(theta_true_2d),  # Rotation angle in degrees\n",
-    "        fill=False,  # You can set this to True if you want a filled ellipse\n",
-    "        color='grey' ,lw=1.5,label=r'On-sky Projection' # Color of the ellipse\n",
-    "    )\n",
-    "c1 = ax.add_patch(ellipse_true)\n",
-    "c2 = ax.add_patch(ellipse_2d)\n",
-    "#ax.set_xscale('log')\n",
-    "ax.set_title(r'$a = 1 \\ \\mathrm{kpc}, \\ M_{\\rm Subhalo} = 10^7 M_{\\odot}$',fontsize=18)\n",
-    "ax.set_xlim(-3,3)\n",
-    "\n",
-    "#ax.set_xlim(-1e6,1e6)\n",
-    "ax.set_ylim(-.4,.4)\n",
-    "ax.legend(fontsize=15,frameon=False,loc ='lower left')\n",
-    "ax.set_xlabel(r'$\\Delta M_{\\rm Subhalo} \\ \\mathrm{[10^6 ~M_\\odot]}$',fontsize=20)\n",
-    "ax.text(-.1,.3,'Long-Range Encounter',fontsize=18)\n",
-    "ax.set_ylabel(r'$\\Delta a \\ \\mathrm{[kpc]}$',fontsize=18)\n",
-    "#############ax.set_aspect('equal')\n",
-    "# plt.savefig('subhalo_constraint.pdf',bbox_inches='tight')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 797,
-   "id": "914b808c-aa71-4596-b9e6-89a679675c2a",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x432 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig, ax = plt.subplots(1,1)\n",
-    "fig.set_size_inches(6,6)\n",
-    "_=ellipse_true = Ellipse(\n",
-    "        xy=(0, 0),  # Center of the ellipse\n",
-    "        width=w_true,\n",
-    "        height=h_true,\n",
-    "        angle=np.rad2deg(theta_true),  # Rotation angle in degrees\n",
-    "        fill=False,  # You can set this to True if you want a filled ellipse\n",
-    "        color='b' ,lw=1.5,label=r'$M_{\\rm Subhalo} = 10^7 M_{\\odot}, \\ a = 0.5 \\ \\mathrm{kpc}$' # Color of the ellipse\n",
-    "    )\n",
-    "c1 = ax.add_patch(ellipse_true)\n",
-    "#ax.set_xscale('log')\n",
-    "ax.set_xlim(-1,1)\n",
-    "#ax.set_xlim(-1e6,1e6)\n",
-    "ax.set_ylim(-.1,.1)\n",
-    "ax.legend(fontsize=16)\n",
-    "ax.set_xlabel(r'$\\Delta M_{\\rm Subhalo} \\ \\mathrm{[10^6 M_\\odot]}$',fontsize=20)\n",
-    "ax.set_ylabel(r'$\\Delta a \\ \\mathrm{[kpc]}$',fontsize=18)\n",
-    "###plt.savefig('subhalo_constraint.pdf',bbox_inches='tight')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 739,
-   "id": "725b6158-ad28-4875-9896-641142074679",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(-0.1, 0.1)"
-      ]
-     },
-     "execution_count": 739,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x432 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig, ax = plt.subplots(1,1)\n",
-    "fig.set_size_inches(6,6)\n",
-    "_=ellipse_true = Ellipse(\n",
-    "        xy=(0, 0),  # Center of the ellipse\n",
-    "        width=w_true,\n",
-    "        height=h_true,\n",
-    "        angle=np.rad2deg(theta_true),  # Rotation angle in degrees\n",
-    "        fill=False,  # You can set this to True if you want a filled ellipse\n",
-    "        color='b' ,lw=1.5,label=None # Color of the ellipse\n",
-    "    )\n",
-    "c1 = ax.add_patch(ellipse_true)\n",
-    "#ax.set_xscale('log')\n",
-    "ax.set_xlim(-.1,.1)\n",
-    "ax.set_ylim(-.1,.1)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 740,
-   "id": "8baa258e-204c-41ab-a5d6-e1639fc8e5e0",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "1.2589254117941673"
-      ]
-     },
-     "execution_count": 740,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "10**(.1)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 654,
-   "id": "d02ed85e-8b82-4943-972a-55fafb3a00c8",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 576x432 with 2 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# Define the covariance matrix\n",
-    "covariance_matrix = np.array([[1.0, .1],\n",
-    "                              [.1, 2.0]])\n",
-    "\n",
-    "# Calculate the eigenvalues and eigenvectors of the covariance matrix\n",
-    "eigenvalues, eigenvectors = np.linalg.eig(covariance_matrix)\n",
-    "\n",
-    "# Calculate the standard deviations along the principal axes\n",
-    "sigma_x = np.sqrt(eigenvalues[0])\n",
-    "sigma_y = np.sqrt(eigenvalues[1])\n",
-    "\n",
-    "# Define the center of the Gaussian distribution\n",
-    "mean = np.array([2.0, 3.0])\n",
-    "\n",
-    "# Create a grid of points around the mean\n",
-    "x = np.linspace(mean[0] - 3 * sigma_x, mean[0] + 3 * sigma_x, 400)\n",
-    "y = np.linspace(mean[1] - 3 * sigma_y, mean[1] + 3 * sigma_y, 400)\n",
-    "X, Y = np.meshgrid(x, y)\n",
-    "\n",
-    "# Calculate the probability density function (PDF) for the Gaussian distribution\n",
-    "Z = np.exp(-0.5 * (((X - mean[0]) / sigma_x) ** 2 + ((Y - mean[1]) / sigma_y) ** 2)) / (2 * np.pi * sigma_x * sigma_y)\n",
-    "\n",
-    "# Plot the 1-sigma region (68% confidence interval)\n",
-    "plt.figure(figsize=(8, 6))\n",
-    "plt.contourf(X, Y, Z, levels=5, cmap='viridis')\n",
-    "plt.colorbar(label='PDF Value')\n",
-    "plt.xlabel('X')\n",
-    "plt.ylabel('Y')\n",
-    "plt.title('1-Sigma Region (68% Confidence Interval) for 2D Gaussian')\n",
-    "plt.axis('equal')\n",
-    "plt.grid(True)\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 647,
-   "id": "980bf165-cecb-4dcf-9853-219bc304b703",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array(5.80103, dtype=float64)"
-      ]
-     },
-     "execution_count": 647,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "jnp.log10(jnp.sqrt(4.0e11))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 600,
-   "id": "5047a88d-9197-4635-96f9-7af7d20ff046",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "2.6457513110645907"
-      ]
-     },
-     "execution_count": 600,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "np.sqrt(7)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1198,
-   "id": "cd4cc6ed-fb0d-4ba0-9506-0a2d46ec63bc",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "10.0"
-      ]
-     },
-     "execution_count": 1198,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "np.sqrt(1e-4)*1000"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 960,
-   "id": "93da2b70-850c-4b96-8309-be8a08ce1175",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "1.0000283885785286"
-      ]
-     },
-     "execution_count": 960,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "10**np.sqrt(1.52e-10)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 945,
-   "id": "56b4c7ed-b310-432d-9313-4815875f29db",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array([[6.97522627e-09, 2.31555412e+02],\n",
-       "       [2.31555412e+02, 8.13557014e+12]], dtype=float64)"
-      ]
-     },
-     "execution_count": 945,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "I = -jnp.array([ [second_gradient['a']['a'],second_gradient['a']['m'] ],\n",
-    "            [second_gradient['a']['m'], second_gradient['m']['m'] ] ])\n",
-    "jnp.linalg.inv(I)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "d8458f4f-bdb0-4e60-aff4-733233fd3d37",
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "NameError",
-     "evalue": "name 'second_gradient' is not defined",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_13534/591555478.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0msecond_gradient\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'a'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'm'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msecond_gradient\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'm'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'a'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-      "\u001b[0;31mNameError\u001b[0m: name 'second_gradient' is not defined"
-     ]
-    }
-   ],
-   "source": [
-    "second_gradient['a']['m'], second_gradient['m']['a']"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1238,
-   "id": "907cfc74-e382-4827-90bb-2ba422d11697",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "1000000000000.0"
-      ]
-     },
-     "execution_count": 1238,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "params['m']"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "id": "843fe77b-34a6-402b-8a49-82ef147150b5",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pot = Isochrone(m=params['m'], a=params['a'],units=usys,)  # Create the potential with the given parameters\n",
-    "    \n",
-    "# Example Orbit:\n",
-    "t0 = 0\n",
-    "ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "    \n",
-    "### Compute the orbit with the provided potential\n",
-    "w_orb = leapfrog_run(w0, ts, pot.gradient)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "id": "a588cf14-eefc-4e52-8057-8f25aaaeb2dd",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array(-0., dtype=float64)"
-      ]
-     },
-     "execution_count": 23,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "@jax.jit\n",
-    "def gauss_pt(x_eval, x_mean):\n",
-    "    return -0.5*jnp.sum(jnp.square(x_eval - x_mean))\n",
-    "gauss_pt(w_orb[-1,:],w_orb[-1,:])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1254,
-   "id": "1dc6c939-3eb6-4f8d-8e97-ec13c5b958dc",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7faa24c76d60>"
-      ]
-     },
-     "execution_count": 1254,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAN8AAACiCAYAAADBRRgzAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAJY0lEQVR4nO3dTWhb2RnG8ee1QyCratxuTDXgKu0qLmnEmJZOC6nxJriLLDwp9IukpAkM7aIdmHQKxVK7ytChdApZmJZABrpxdq0INMExGbIowQoGZzWD64WK6VCCuygG1/bpQvc6d2Q51pWv7jmy/j8Y0Mex9Eajx+deHx295pwTgPwN+S4AGFSED/DkRB5PcvXqVbe9va2xsbFDx66trXU0Ls1YX+MG9bmp8WDVavVPzrmrkiTnXM//m52ddbOzs64TnY5LM9bXuEF9bmo8mKSKi3KR22Hn+fPnvT1m1uPSoMZsHKca97icZr5OPXz4sOOxvvRDjc71R52DVqN8zHyd6sVvpKz1Q41Sf9Q5yDUGFz6gH9XqDb1154lq9UbHP0P4gCOq1Ru6cuux5h58pCu3HnccwFzCt7a2pkqlosXFxTyeDsjVwsq6Nrd2JEmbWztaWFlvOy56/4/F13NZ5xsbG1OlUsnjqYDcTY6P6oNHq9rc2tGpk8OaHB9tOy46d1yLr+cSPuA4my4XdfvN17Wwsq7J8VFNl4sd/RzhAzIwXS52HLpY1+d8ZnYzcXnGzKbM7Fq3jwcMmq7CZ2ZTkkrR5RlJcs49SNwH4BCpw2dmJUmriZsmEtdXJZUzqAs49ro55ys55x6YWXy90HL/Z1t/IF5qkJp/8emHTzUAWVlcXEwus43FF1KFz8ym4sPLhA1JIy/7OZYaMMiSE061Wl2Lb0878z2PzukKkkpmVpb0RC9mv5Kk+0crFRgMqc75nHP1aOYbURQ459xdNYM4JanQZmYE0EZX63zOuTlJc4nr70YXCR7QIT5YDXhC+ABPCB/gCVuKgJywpQjwpHVLEYedgCeED/CE8AGeED7AE8IHeMJSA5ATlhoAT1hqAAJB+ABPCB/gCeEDPCF8gCeED/CEdT4gJ6zzAZ6wzgcEgvABnqT9xuqCml+MW5I04Zy7Ed0+o+Y3V5eirxUEcIi0M98lSa9FX5QrM7tGlyKgO2m/sXouMbPF3YroUgR0odv+fCVJz6PZrtBy974uRQD263apYcY5dz26vKFDuhTRIgyD7KAWYeacS/VAZjaTOOcrK+pQ65y7G7WFXm1tllKpVBzrfIBkZlXnXEVKedgZ/THlppktmdmSpBG6FAHdSXXYGQXrdJvb6VIEpMQiO+AJ4QM8IXyAJ2wpAnLCliLAE7YUAYEgfIAnhA/whPABnhA+wBPCB3jCOh+QE9b5AE9Y5wMCQfgATwgf4AnhAzwhfIAnLDUAOWGpAfCEpQYgEIRvAFTnl/W1X9ZUnV/2XQoSMjnspEtRmGr1ht7585L+8cl/JUnPGv+RJM2+cdZnWYgceeajS1GYqvPL+u7vH+0FL3bvacNTRWiVxWEnXYoC84M/fKjf/uWZdtt0Arhwrph/QWgri8POQst1uhR5NPXrv+nvH/+77X0XJ17lkDMgWYRvQ3QpCkJ1frlt8M6NjejGxXFNl5n1fDioS1EW4XuiF7NfSdL91gGs8/VWrd7Qwsq67j395777Lk68qg9++k0PVSGWnHCq1epafPuRwxe1BnubLkV+1OoNXbn1WJtbOzoxZJ+676tf/BzBC1gmSw10KcpfdX5Z9542dPLEsDa3diRJ27tOXxl7Rf/b3tWFc0XO7wKXy8fLkJ3WtTtJOjFk2t51OnVyWL+4+GXO7foE4esjtXpD33//Q223rCGMvnJKF859XpPjowSvjxC+PnL74cf7gidJ3/n6FzjE7ENsKeojTvuDx9pd/2BLUR/70be+pMVn/9LW9q6GTPr5t88QvD7SuqWIw84+Ml0u6s5PvqGFlXXO744BwtdnpstFQndMsJ8P8ITwAZ4QPsATwgd4wjofkBPW+QBP+OpAIBCED/CE8AGeED7AE8IHeMJSA5ATlhoAT1hqAAJB+ABPUh92mllBzS/HLUmacM7diG6nUxGQQjcz3yVJrznn7kqSmV2jUxGQXurwOefmEjNbSc3ORHQqAlLq+pzPzEqSnkezXaHlbjoVAYdoe84XHUa2dh5abenDMOOcux5d3mgzfg9dijDIDupSZM616aB4CDObSZzzldU8/IybplxTS1ArlYpjnQ+QzKzqnKtIXRx2Rn9MuWlmS2a2JGkkCmKJTkVA51IvNUTBOt3mdjoVASmwyA54QvgATwgf4AlbioCcsKUI8IQtRUAgCB/gCeEDPCF8gCeED/CE8AGesM4H5IR1PsAT1vmAQBA+wBPCB3hC+ABPCB/gCUsNQE5YagA8YakBCAThAzw5UvjM7Gbi8oyZTUVfmnsktXpDb915olq9cdSHAoJ1lF4NU4q+qTrLLkXV+WV97/1Hmnvwka7cekwAcWx1Fb6oScpq4qZMuhRV55f13l+faWe3eX1za0cLK+vdPBQQvG5nvpJzLhm+Qsv9qbsU1eoN/a72TMnWEcND0uT4aFcFAqFL3aXIzKba9GLYaDN+z2Fdimr1hn5zd3lvxmvWIP1s+oymy8WO/iFAqDLrUhR1JRpRc7Z7R9KPdYQuRbV6Q1duPdbm1s7ebcNDzeDNvnE2VW1A6JJdirpplFKPHuSaosPNKHRvd9OlaGFl/VPBO1P8jH41c5YZD8de13/tjNpDn47D6Jx71zn3INGtqCOT46M6dXJYknTq5DDBw8DI5eNlLzNdLur2m69rYWVdk+OjBA8DI4hPuEyXi3rvhxOaLhf74sPX/VCj1B91DnKNQYQvaZD/Z2StH+oc5Bpz21J0+fLlzP8RnT5e1uPSoMZsHIcaW7cUpV5q6IaZ/VHN88u1DoaPdTguzVhf4wb1uTsd5/O5Ox2X9WMWnXNXpZzCB2C/4M75gEFB+ABPgg1fr/YKZsHMCmZWjuoKrs5Q6mgV+uvWqtc1Bhm+Xu0VzNAlSa855+5KzY/ahVJnKHUcINjXrVUe78HgwtervYJZij5aNxddjesNpc5Q6tgn8NdtT17vweDCpx7sFeyV6H/S8+g3YqHlbl91FlquB/N6xQJ93ZJyeQ/m/tnOrPcK9srL6kxcn3HOXY8ub7QZ78OGwqjjZUJ83SQ1Dynzeg/mHr74eP8Az+NtSZJK0d7BJ3rxm6ck6X5PC4wcUqfMbCbeweGzzjZCqaOtgF+3WG7vwaAOO51z9ei3TrxZNw5BqZu9gr0S1XLTzJbMbEnSSCh1hlJHOyG/brE834N8wgXwJKiZDxgkhA/whPABnhA+wJP/A1B7EoHect68AAAAAElFTkSuQmCC\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import jax.scipy.stats as statsjax\n",
-    "#kde = statsjax.gaussian_kde(w_orb[-1,:],bw_method=.04)\n",
-    "#key = jax.random.PRNGKey(3)\n",
-    "#samps = kde.resample(key,[20]).T\n",
-    "#ll = kde.logpdf(lead_arm[:,:].T)\n",
-    "#plt.scatter(samps[:,0],samps[:,1],s=10)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 33,
-   "id": "d3ae8521-c99b-40ae-926d-51d9fb519eb0",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def compute_orbit_and_gradients(params,w0,dt,n_steps,units):\n",
-    "    pot = Isochrone(m=params['m'], a=params['a'],units=units,)  # Create the potential with the given parameters\n",
-    "    \n",
-    "    # Example Orbit:\n",
-    "    #w0 = jnp.array([10, 0, 0, 0, .204, 0])\n",
-    "    t0 = 0\n",
-    "    #dt = 0.1\n",
-    "    #n_steps = 10000\n",
-    "    ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "    \n",
-    "    ### Compute the orbit with the provided potential\n",
-    "    ####################ws_jax = leapfrog_run(w0, ts, pot.gradient)\n",
-    "    \n",
-    "    # Compute the gradient of the final position with respect to the potential parameters\n",
-    "    def gradient_fn(params):\n",
-    "        pot_with_params = Isochrone(m=params['m'], a=params['a'],units=units)\n",
-    "        ws_with_params = leapfrog_run(w0, ts, pot_with_params.gradient)\n",
-    "        final_position = ws_with_params[-1, :]  # Extract final position\n",
-    "        return gauss_pt(final_position,w_orb[-1,:])\n",
-    "        #return final_position\n",
-    "    \n",
-    "    # Compute the gradient using JAX's autodiff\n",
-    "    gradient = jax.jacfwd(gradient_fn)(params)\n",
-    "    \n",
-    "    return gradient"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 32,
-   "id": "4ef330e2-5e31-46f6-8a77-597d4fea763a",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'m': 1000000000000.0, 'a': 10.0}"
-      ]
-     },
-     "execution_count": 32,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "params"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 34,
-   "id": "e83d25a4-7f91-4d90-8353-8526e7b40449",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "gg = compute_orbit_and_gradients(params,w0,dt,n_steps,usys)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "id": "f90f5030-0249-4385-a1f8-ef04fb55de62",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'a': Array(-213.5123923, dtype=float64),\n",
-       " 'm': Array(6.81011456e-09, dtype=float64)}"
-      ]
-     },
-     "execution_count": 35,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "gg"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 399,
-   "id": "04c08e2d-23df-4f74-93a2-81b71b2fb113",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "params = {'m': 5e11, 'a': 10.}\n",
-    "pot = Hernquist(m=params['m'], a=params['a'],units=usys,)  \n",
-    "t0 = 0\n",
-    "dt = 0.5\n",
-    "n_steps = 10_000\n",
-    "ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "### Compute the orbit with the provided potential\n",
-    "##ws_jax = leapfrog_run(w0, ts, pot.gradient)\n",
-    "\n",
-    "M_sat = 1.0e4 # TODO: mass loss rate\n",
-    "pos_disp = .001\n",
-    "vel_disp = (20*u.km/u.s).to(u.kpc/u.Myr).value#.05\n",
-    "\n",
-    "pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr = pot.gen_stream_ics(ts, w0, Msat, pos_disp, vel_disp)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 333,
-   "id": "b69344f7-9f7f-473b-a917-1fbd614d941d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#release_time_arr = get_stripping_time_arr(ts)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 308,
-   "id": "808ed1f4-eb0a-44e3-8e4d-b7be12395a98",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array([0.000e+00, 1.000e+00, 2.000e+00, ..., 9.998e+03, 9.999e+03,\n",
-       "       1.000e+04], dtype=float64)"
-      ]
-     },
-     "execution_count": 308,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "ts"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 309,
-   "id": "64ed11fc-7055-46b1-8e93-f9537ff4ca6a",
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "KeyboardInterrupt",
-     "evalue": "",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_21408/1523047885.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m# Example usage:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;31m#ts = jnp.array([1, 2, 3, 4, 5])\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_stripping_time_arr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_21408/1523047885.py\u001b[0m in \u001b[0;36mget_stripping_time_arr\u001b[0;34m(ts)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget_stripping_time_arr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0mt_release_arr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mt_release_arr\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m# Example usage:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_21408/1523047885.py\u001b[0m in \u001b[0;36m<listcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget_stripping_time_arr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0mt_release_arr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mt_release_arr\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m# Example usage:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/array.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, idx)\u001b[0m\n\u001b[1;32m    341\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0mlax_numpy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_rewriting_take\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0midx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    342\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 343\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mlax_numpy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_rewriting_take\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0midx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    344\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    345\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m__iter__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/numpy/lax_numpy.py\u001b[0m in \u001b[0;36m_rewriting_take\u001b[0;34m(arr, idx, indices_are_sorted, unique_indices, mode, fill_value)\u001b[0m\n\u001b[1;32m   3890\u001b[0m         \u001b[0;31m# Use dynamic rather than static slice here to avoid slow repeated execution:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3891\u001b[0m         \u001b[0;31m# See https://github.com/google/jax/issues/12198\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3892\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdynamic_slice_in_dim\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstart\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_max\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstop\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mstart\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   3893\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3894\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mslice_in_dim\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstart\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstop\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstep\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/lax/slicing.py\u001b[0m in \u001b[0;36mdynamic_slice_in_dim\u001b[0;34m(operand, start_index, slice_size, axis)\u001b[0m\n\u001b[1;32m    696\u001b[0m   \u001b[0mstart_indices\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mstart_index\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    697\u001b[0m   \u001b[0mslice_sizes\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_canonicalize_dimension\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mslice_size\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 698\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0mdynamic_slice\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moperand\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstart_indices\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mslice_sizes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    699\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    700\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/lax/slicing.py\u001b[0m in \u001b[0;36mdynamic_slice\u001b[0;34m(operand, start_indices, slice_sizes)\u001b[0m\n\u001b[1;32m    108\u001b[0m     \u001b[0mdynamic_sizes\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    109\u001b[0m     \u001b[0mstatic_sizes\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanonicalize_shape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mslice_sizes\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 110\u001b[0;31m   return dynamic_slice_p.bind(operand, *start_indices, *dynamic_sizes,\n\u001b[0m\u001b[1;32m    111\u001b[0m                               slice_sizes=tuple(static_sizes))\n\u001b[1;32m    112\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/core.py\u001b[0m in \u001b[0;36mbind\u001b[0;34m(self, *args, **params)\u001b[0m\n\u001b[1;32m    358\u001b[0m     assert (not config.jax_enable_checks or\n\u001b[1;32m    359\u001b[0m             all(isinstance(arg, Tracer) or valid_jaxtype(arg) for arg in args)), args\n\u001b[0;32m--> 360\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbind_with_trace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfind_top_trace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    361\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    362\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mbind_with_trace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/core.py\u001b[0m in \u001b[0;36mbind_with_trace\u001b[0;34m(self, trace, args, params)\u001b[0m\n\u001b[1;32m    361\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    362\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mbind_with_trace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 363\u001b[0;31m     \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_primitive\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    364\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfull_lower\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmultiple_results\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mfull_lower\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    365\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/core.py\u001b[0m in \u001b[0;36mprocess_primitive\u001b[0;34m(self, primitive, tracers, params)\u001b[0m\n\u001b[1;32m    815\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    816\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess_primitive\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 817\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimpl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    818\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    819\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/dispatch.py\u001b[0m in \u001b[0;36mapply_primitive\u001b[0;34m(prim, *args, **params)\u001b[0m\n\u001b[1;32m    115\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    116\u001b[0m   \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 117\u001b[0;31m     compiled_fun = xla_primitive_callable(prim, *unsafe_map(arg_spec, args),\n\u001b[0m\u001b[1;32m    118\u001b[0m                                           **params)\n\u001b[1;32m    119\u001b[0m   \u001b[0;32mexcept\u001b[0m \u001b[0mpxla\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mDeviceAssignmentMismatchError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    251\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    252\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 253\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    254\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    255\u001b[0m     \u001b[0mwrapper\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcache_clear\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcache_clear\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    244\u001b[0m     \u001b[0;34m@\u001b[0m\u001b[0mfunctools\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlru_cache\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmax_size\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    245\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 246\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    247\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    248\u001b[0m     \u001b[0;34m@\u001b[0m\u001b[0mfunctools\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwraps\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/dispatch.py\u001b[0m in \u001b[0;36mxla_primitive_callable\u001b[0;34m(prim, *arg_specs, **params)\u001b[0m\n\u001b[1;32m    206\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    207\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 208\u001b[0;31m   compiled = _xla_callable_uncached(lu.wrap_init(prim_fun), prim.name,\n\u001b[0m\u001b[1;32m    209\u001b[0m                                     donated_invars, False, *arg_specs)\n\u001b[1;32m    210\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mprim\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmultiple_results\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/dispatch.py\u001b[0m in \u001b[0;36m_xla_callable_uncached\u001b[0;34m(fun, name, donated_invars, keep_unused, *arg_specs)\u001b[0m\n\u001b[1;32m    252\u001b[0m                                  *arg_specs, lowering_platform=None)\n\u001b[1;32m    253\u001b[0m   \u001b[0mallow_prop\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcomputation\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcompile_args\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'global_out_avals'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 254\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0mcomputation\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcompile\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_allow_propagation_to_outputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mallow_prop\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munsafe_call\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    255\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    256\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/interpreters/pxla.py\u001b[0m in \u001b[0;36mcompile\u001b[0;34m(self, _allow_propagation_to_outputs, _allow_compile_replicated)\u001b[0m\n\u001b[1;32m   2814\u001b[0m             **self.compile_args)\n\u001b[1;32m   2815\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2816\u001b[0;31m         self._executable = UnloadedMeshExecutable.from_hlo(\n\u001b[0m\u001b[1;32m   2817\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_name\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2818\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_hlo\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/interpreters/pxla.py\u001b[0m in \u001b[0;36mfrom_hlo\u001b[0;34m(name, computation, mesh, global_in_avals, global_out_avals, in_shardings, out_shardings, spmd_lowering, tuple_args, auto_spmd_lowering, _allow_propagation_to_outputs, _allow_compile_replicated, unordered_effects, ordered_effects, host_callbacks, keepalive, kept_var_idx, backend, device_assignment, committed, pmap_nreps)\u001b[0m\n\u001b[1;32m   3026\u001b[0m                                      \u001b[0;34m\"in {elapsed_time} sec\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3027\u001b[0m                                      event=dispatch.BACKEND_COMPILE_EVENT):\n\u001b[0;32m-> 3028\u001b[0;31m         xla_executable = dispatch.compile_or_get_cached(\n\u001b[0m\u001b[1;32m   3029\u001b[0m             backend, computation, compile_options, host_callbacks)\n\u001b[1;32m   3030\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/dispatch.py\u001b[0m in \u001b[0;36mcompile_or_get_cached\u001b[0;34m(backend, computation, compile_options, host_callbacks)\u001b[0m\n\u001b[1;32m    524\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0mcompiled\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    525\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 526\u001b[0;31m   return backend_compile(backend, serialized_computation, compile_options,\n\u001b[0m\u001b[1;32m    527\u001b[0m                          host_callbacks)\n\u001b[1;32m    528\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/profiler.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    312\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    313\u001b[0m     \u001b[0;32mwith\u001b[0m \u001b[0mTraceAnnotation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdecorator_kwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 314\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    315\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    316\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/dispatch.py\u001b[0m in \u001b[0;36mbackend_compile\u001b[0;34m(backend, built_c, options, host_callbacks)\u001b[0m\n\u001b[1;32m    469\u001b[0m   \u001b[0;31m# TODO(sharadmv): remove this fallback when all backends allow `compile`\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    470\u001b[0m   \u001b[0;31m# to take in `host_callbacks`\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 471\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0mbackend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcompile\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbuilt_c\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcompile_options\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    472\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    473\u001b[0m \u001b[0m_ir_dump_counter\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mitertools\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcount\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
-     ]
-    }
-   ],
-   "source": [
-    "def get_stripping_time_arr(ts):\n",
-    "    t_release_arr = [ts[i:] for i in range(len(ts))]\n",
-    "    return t_release_arr\n",
-    "\n",
-    "# Example usage:\n",
-    "#ts = jnp.array([1, 2, 3, 4, 5])\n",
-    "result = get_stripping_time_arr(ts)\n",
-    "print(result)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 319,
-   "id": "94c3c17b-1eca-4441-a5a9-c2f247f09a9a",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array([2, 3, 4, 5], dtype=int64)"
-      ]
-     },
-     "execution_count": 319,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "jax.lax.slice(tt,(1,),(len(tt),))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 312,
-   "id": "d056dfcc-6321-4f84-b8ef-7b3e6d8561de",
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "TypeError",
-     "evalue": "iteration over a 0-d array",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_21408/1263285150.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     15\u001b[0m \u001b[0;31m# Example usage:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     16\u001b[0m \u001b[0mtt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 17\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_stripping_time_arr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     18\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_21408/1263285150.py\u001b[0m in \u001b[0;36mget_stripping_time_arr\u001b[0;34m(ts)\u001b[0m\n\u001b[1;32m     10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m     \u001b[0;31m# Use vmap to apply the slicing function to each row\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m     \u001b[0mt_release_arr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mslice_row\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatched_ts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     14\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mt_release_arr\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "    \u001b[0;31m[... skipping hidden 3 frame]\u001b[0m\n",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_21408/1263285150.py\u001b[0m in \u001b[0;36mslice_row\u001b[0;34m(i, arr)\u001b[0m\n\u001b[1;32m      7\u001b[0m     \u001b[0;31m# Create a function to slice each row\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mslice_row\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0marr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mslice\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marr\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m     \u001b[0;31m# Use vmap to apply the slicing function to each row\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "    \u001b[0;31m[... skipping hidden 2 frame]\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/lax/lax.py\u001b[0m in \u001b[0;36m_iter\u001b[0;34m(tracer)\u001b[0m\n\u001b[1;32m   1457\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_iter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtracer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1458\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0mtracer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1459\u001b[0;31m     \u001b[0;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"iteration over a 0-d array\"\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# same as numpy error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1460\u001b[0m   \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1461\u001b[0m     \u001b[0mn\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtracer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mTypeError\u001b[0m: iteration over a 0-d array"
-     ]
-    }
-   ],
-   "source": [
-    "from jax import vmap\n",
-    "\n",
-    "def get_stripping_time_arr(ts):\n",
-    "    # Create a batched version of ts\n",
-    "    batched_ts = jnp.stack([ts] * len(ts))\n",
-    "    \n",
-    "    # Create a function to slice each row\n",
-    "    def slice_row(i, arr):\n",
-    "        return jax.lax.slice(arr,i,-1)\n",
-    "\n",
-    "    # Use vmap to apply the slicing function to each row\n",
-    "    t_release_arr = vmap(slice_row)(jnp.arange(len(ts)), batched_ts)\n",
-    "    \n",
-    "    return t_release_arr\n",
-    "# Example usage:\n",
-    "tt = jnp.array([1, 2, 3, 4, 5])\n",
-    "result = get_stripping_time_arr(tt)\n",
-    "print(result)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 376,
-   "id": "cfb93bbb-5716-48f3-8015-e4558841b5b7",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "lead_arm, trail_arm = pot.gen_stream(ts, w0, Msat, pos_disp, vel_disp)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "12cfd522-44f0-4615-ae5a-7e1014abcaf9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "plt.scatter(lead_arm[:,-1,0],lead_arm[:,-1,1],s=0.5,rasterized=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 404,
-   "id": "4a3d40bb-5b76-49b2-81fb-35cf387792a6",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/latex": [
-       "$0.020454243 \\; \\mathrm{\\frac{kpc}{Myr}}$"
-      ],
-      "text/plain": [
-       "<Quantity 0.02045424 kpc / Myr>"
-      ]
-     },
-     "execution_count": 404,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "(50*u.km/u.s).to(u.kpc/u.Myr).value"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 405,
-   "id": "d15ca259-fd43-42fc-9fac-e66b69658915",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "lead_arm, trail_arm = pot.gen_stream_final(ts, w0, Msat, pos_disp, (50*u.km/u.s).to(u.kpc/u.Myr).value)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 406,
-   "id": "b3ed7351-88a1-4317-baca-10ed57d6c0ae",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7fa8ef2874f0>"
-      ]
-     },
-     "execution_count": 406,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.scatter(lead_arm[:,0],lead_arm[:,1],s=0.5,rasterized=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 378,
-   "id": "ec0a9dcf-2da0-459f-988d-d3fe404cde57",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7fa8e95bf4c0>"
-      ]
-     },
-     "execution_count": 378,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.scatter(lead_arm[:,-1,0],lead_arm[:,-1,1],s=0.5,rasterized=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 198,
-   "id": "322419da-c292-42d5-b79d-67eb5f16e71b",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "15\n",
-      "[ 1  3  6 10 15]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Define a step function that adds an input to the carry state\n",
-    "def step(carry, x):\n",
-    "    return carry + x, carry + x\n",
-    "\n",
-    "# Sequence of input values\n",
-    "inputs = jnp.array([1, 2, 3, 4, 5])\n",
-    "\n",
-    "# Initial carry state\n",
-    "init_carry = jnp.array(0)\n",
-    "\n",
-    "# Use jax.lax.scan to iterate over the inputs\n",
-    "final_carry, results = jax.lax.scan(step, init_carry, inputs)\n",
-    "\n",
-    "print(final_carry)  # Output: 15 (sum of all input values)\n",
-    "print(results)      # Output: [1, 3, 6, 10, 15] (cumulative sums)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "560e8dc1-b95e-4487-9729-2e4b075feb0f",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 115,
-   "id": "5c1f226a-8f37-45f4-863b-b084cdcb0aec",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array([ 0.23298915, -1.04627168,  1.35807149], dtype=float64)"
-      ]
-     },
-     "execution_count": 115,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "key = jax.random.PRNGKey(30302)\n",
-    "jax.random.normal(key,shape=(3,))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 172,
-   "id": "d6656cfa-bcf4-4538-a491-505795114d4e",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(Array([24.72606542,  9.89042617,  9.89042617], dtype=float64),\n",
-       " Array([25.27393458, 10.10957383, 10.10957383], dtype=float64))"
-      ]
-     },
-     "execution_count": 172,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "params = {'m': 1e10, 'a': 10.}\n",
-    "pot = Hernquist(m=params['m'], a=params['a'],units=usys,)  \n",
-    "\n",
-    "x = jnp.array([25,10,10.])\n",
-    "v = jnp.array([.1,.05,.04])\n",
-    "Msat = 1.0e4\n",
-    "pos_disp = .01\n",
-    "vel_disp = .005\n",
-    "#pot.tidalr_mw(x,v,Msat)\n",
-    "pot.lagrange_pts(x, v, Msat,)\n",
-    "#pot.tidalr_mw(x,v,Msat)\n",
-    "#pot.d2phidr2_mw(x)\n",
-    "#pot.omega(x, v)\n",
-    "#pot.omega(x, v) ** 2 - pot.d2phidr2_mw(x)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 165,
-   "id": "5d6dd512-ebd7-4d65-8a02-d8746dff8fc1",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array(nan, dtype=float64)"
-      ]
-     },
-     "execution_count": 165,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "(pot._G * Msat / (pot.omega(x, v) ** 2 - pot.d2phidr2_mw(x))) ** (1.0 / 3.0)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 167,
-   "id": "d23be7dc-b15a-4ee6-8a50-832849250008",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array(-0.03117464, dtype=float64)"
-      ]
-     },
-     "execution_count": 167,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "pot._G * Msat / (pot.omega(x, v) ** 2 - pot.d2phidr2_mw(x))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 168,
-   "id": "9271c65f-d971-4380-9c50-a3e48f443c9e",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(0.6299605249474367+1.0911236359717214j)"
-      ]
-     },
-     "execution_count": 168,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "(-2)**(1/3)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 60,
-   "id": "a358f1da-0083-4bcd-ab17-b18684bd39c7",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "a_arr = jnp.linspace(10,11,30)\n",
-    "w0 = jnp.array([25., 0., 0, 0.01, .104, -0.004])\n",
-    "dt = 0.1\n",
-    "t0 = 0.\n",
-    "n_steps = 30_000\n",
-    "Delta_a = jnp.diff(a_arr)[0]\n",
-    "predicted_wf = jnp.zeros((len(a_arr),6))\n",
-    "true_wf = jnp.zeros((len(a_arr)-1,6))\n",
-    "for i in range(len(a_arr)):\n",
-    "    params = {'m': 5e11, 'a': a_arr[i]}\n",
-    "    result_ws, param_gradients = compute_orbit_and_gradients(params,w0,dt,n_steps,usys)\n",
-    "    pred = result_ws[-1] + param_gradients['a']*Delta_a \n",
-    "    predicted_wf = predicted_wf.at[i,:].set( pred )\n",
-    "    if i > 0:\n",
-    "        true_wf = true_wf.at[i-1,:].set(result_ws[-1])\n",
-    "    \n",
-    "    \n",
-    "\n",
-    "    \n",
-    "\n",
-    "    \n",
-    "    "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 61,
-   "id": "527867ec-3518-47ca-bd86-e724ff732ba3",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 792x504 with 7 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig, ax = plt.subplots(2,3)\n",
-    "ax_flat = ax.flatten()\n",
-    "fig.set_size_inches(11,7)\n",
-    "for dim in range(6):\n",
-    "    xx = np.linspace(true_wf[:,dim].min(),true_wf[:,dim].max(),50)\n",
-    "    ax_flat[dim].plot(xx,xx,color='k',ls='--',zorder=0)\n",
-    "\n",
-    "    ax_flat[dim].scatter(true_wf[:,dim], predicted_wf[:-1,dim],c=a_arr[1:],s=20,cmap=cmr.guppy)\n",
-    "    ax_flat[dim].set_aspect('equal')\n",
-    "fig.subplots_adjust(hspace=0.1,wspace=.35)\n",
-    "ax_flat[0].set_xlabel(r'True $x$ [kpc]',fontsize=15)\n",
-    "ax_flat[0].set_ylabel(r'Predicted $x$',fontsize=15)\n",
-    "\n",
-    "ax_flat[1].set_xlabel(r'True $y$ [kpc]',fontsize=15)\n",
-    "ax_flat[1].set_ylabel(r'Predicted $y$',fontsize=15)\n",
-    "\n",
-    "ax_flat[2].set_xlabel(r'True $z$ [kpc]',fontsize=15)\n",
-    "ax_flat[2].set_ylabel(r'Predicted $z$',fontsize=15)\n",
-    "\n",
-    "ax_flat[3].set_xlabel(r'True $v_x$ [kpc/Myr]',fontsize=15)\n",
-    "ax_flat[3].set_ylabel(r'Predicted $v_x$',fontsize=15)\n",
-    "\n",
-    "ax_flat[4].set_xlabel(r'True $v_y$ [kpc/Myr]',fontsize=15)\n",
-    "ax_flat[4].set_ylabel(r'Predicted $v_y$',fontsize=15)\n",
-    "\n",
-    "ax_flat[5].set_xlabel(r'True $v_z$ [kpc/Myr]',fontsize=15)\n",
-    "ax_flat[5].set_ylabel(r'Predicted $v_z$',fontsize=15)\n",
-    "\n",
-    "# Add a colorbar on the right of the subplots\n",
-    "cax = fig.add_axes([0.91, 0.14, 0.02, 0.73])  # Adjust the position and size of the colorbar\n",
-    "cbar = plt.colorbar(ax_flat[dim].scatter(true_wf[:,dim], predicted_wf[:-1,dim],c=a_arr[1:],s=20,cmap=cmr.guppy), cax=cax, orientation='vertical')\n",
-    "cbar.set_label('$\\Phi$ Scale Radius [kpc]',fontsize=20)  # Set the label for the colorbar\n",
-    "##plt.savefig('TaylorExpansion_PotentialFinalSnap.pdf',bbox_inches='tight')\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 42,
-   "id": "a0034bd4-1132-4f61-b79e-21958cd81027",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "w0 = jnp.array([20, 0, 0, -.01, .104, -.03])\n",
-    "t0 = 0\n",
-    "dt = 0.1\n",
-    "n_steps = 20000\n",
-    "ts = np.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "params = {'m': 5e11, 'a': 10.}\n",
-    "pot = Hernquist(m=params['m'], a=params['a'],units=usys,)\n",
-    "\n",
-    "    \n",
-    "\n",
-    "pos_disp = 0.01 #kpc   \n",
-    "vel_dis = (20*u.km/u.s).to(u.kpc/u.Myr).value\n",
-    "    \n",
-    "\n",
-    "key = random.PRNGKey(0)  # Initialize a random key\n",
-    "num_orbits = 5000\n",
-    "ndim = 3\n",
-    "\n",
-    "pos_samps = np.random.normal(loc=0,scale=pos_disp,size=(num_orbits,3))\n",
-    "vel_samps = np.random.normal(loc=0,scale=vel_dis,size=(num_orbits,3))\n",
-    "\n",
-    "\n",
-    "pos0 = pos_samps + w0[:3]\n",
-    "vel0 = vel_samps + w0[3:]\n",
-    "w0 = jnp.hstack([pos0,vel0])\n",
-    "\n",
-    "orbs = []\n",
-    "final_snap = jnp.zeros((num_orbits,6))\n",
-    "for i in range(len(w0)):\n",
-    "    wcurr = w0[i]\n",
-    "    ws_jax = leapfrog_run(wcurr, ts, pot.gradient)\n",
-    "    orbs.append(ws_jax)\n",
-    "    \n",
-    "    final_snap = final_snap.at[i].set(ws_jax[-1,:])\n",
-    "    \n",
-    "    \n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 43,
-   "id": "fff9873f-7408-464a-be32-3da8d8b8541b",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7fb2096bd8e0>"
-      ]
-     },
-     "execution_count": 43,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.scatter(final_snap[:,0],final_snap[:,1],rasterized=True,s=0.5)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 51,
-   "id": "d77abde0-50ce-4f6b-8b93-8a5f988bd431",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "gala_pot = gp.HernquistPotential(m=params['m'],c=params['a'],units=usys)\n",
-    "H = gp.Hamiltonian(gala_pot)\n",
-    "w_test = gd.PhaseSpacePosition(pos=w0[0][:3]*u.kpc,vel=w0[0][3:]*u.kpc/u.Myr)\n",
-    "orb_gala = H.integrate_orbit(w_test,dt=dt*u.Myr,n_steps=20000)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 56,
-   "id": "1cff0a97-f1c2-4fd2-b0d0-0fcefb3de8a0",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7fb326dcb310>]"
-      ]
-     },
-     "execution_count": 56,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.plot(orb_gala.pos.x,orb_gala.pos.z)\n",
-    "plt.plot(orbs[0][:,0],orbs[0][:,2],color='r',ls='--')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 54,
-   "id": "a056b072-a286-4563-aa07-1814cc728556",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(20001, 6)"
-      ]
-     },
-     "execution_count": 54,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "e4726938-c3eb-4ee9-bd97-0038e8cb7d87",
-   "metadata": {},
-   "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.8.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/stream_integrator_static_time_dep_first_deriv_tests.ipynb b/stream_integrator_static_time_dep_first_deriv_tests.ipynb
deleted file mode 100644
index b1e4bc7f..00000000
--- a/stream_integrator_static_time_dep_first_deriv_tests.ipynb
+++ /dev/null
@@ -1,2894 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "1852a7c2-779f-4ceb-98c6-8916dbdee6a6",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u001b[91mA new version of galpy (1.9.0) is available, please upgrade using pip/conda/... to get the latest features and bug fixes!\u001b[0m\n"
-     ]
-    }
-   ],
-   "source": [
-    "from functools import partial\n",
-    "\n",
-    "from astropy.constants import G\n",
-    "import astropy.coordinates as coord\n",
-    "import astropy.units as u\n",
-    "import matplotlib as mpl\n",
-    "import matplotlib.pyplot as plt\n",
-    "%matplotlib inline\n",
-    "import numpy as np\n",
-    "\n",
-    "# gala\n",
-    "import gala.coordinates as gc\n",
-    "import gala.dynamics as gd\n",
-    "import gala.potential as gp\n",
-    "from gala.units import dimensionless, galactic, UnitSystem\n",
-    "\n",
-    "import jax\n",
-    "import jax.numpy as jnp\n",
-    "\n",
-    "from jax.config import config\n",
-    "config.update(\"jax_enable_x64\", True)\n",
-    "\n",
-    "import scienceplots\n",
-    "import cmasher as cmr\n",
-    "plt.style.use('science')\n",
-    "import jax.random as random \n",
-    "from matplotlib.patches import Ellipse\n",
-    "\n",
-    "usys = UnitSystem(u.kpc, u.Myr, u.Msun, u.radian)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "be2a7229-dedd-49d5-b868-83497bb67b39",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class Potential:\n",
-    "    \n",
-    "    def __init__(self, units, params):\n",
-    "        if units is None:\n",
-    "            units = dimensionless\n",
-    "        self.units = UnitSystem(units)\n",
-    "        \n",
-    "        if self.units == dimensionless:\n",
-    "            self._G = 1\n",
-    "        else:\n",
-    "            self._G = G.decompose(self.units).value\n",
-    "        \n",
-    "        for name, param in params.items():\n",
-    "            if hasattr(param, 'unit'):\n",
-    "                param = param.decompose(self.units).value\n",
-    "            setattr(self, name, param)\n",
-    "    \n",
-    "    @partial(jax.jit, static_argnums=(0,))\n",
-    "    def gradient(self, xyz, t):\n",
-    "        grad_func = jax.grad(self.potential)\n",
-    "        return grad_func(xyz, t)\n",
-    "    \n",
-    "    @partial(jax.jit, static_argnums=(0,))\n",
-    "    def density(self, xyz, t):\n",
-    "        lap = jnp.trace(jax.hessian(self.potential)(xyz, t))\n",
-    "        return lap / (4 * jnp.pi * self._G)\n",
-    "    \n",
-    "    @partial(jax.jit, static_argnums=(0,))\n",
-    "    def acceleration(self, xyz, t):\n",
-    "        return -self.gradient(xyz, t)\n",
-    "    \n",
-    "   \n",
-    "    @partial(jax.jit,static_argnums=(0,))\n",
-    "    def jacobian_force_mw(self, xyz, t):\n",
-    "        jacobian_force_mw = jax.jacfwd(self.gradient)\n",
-    "        return jacobian_force_mw(xyz, t)\n",
-    "    \n",
-    "    @partial(jax.jit,static_argnums=(0,))\n",
-    "    def d2phidr2_mw(self, x, t):\n",
-    "        \"\"\"\n",
-    "        Computes the second derivative of the Milky Way potential at a position x (in the simulation frame)\n",
-    "        Args:\n",
-    "          x: 3d position (x, y, z) in [kpc]\n",
-    "        Returns:\n",
-    "          Second derivative of force (per unit mass) in [1/Myr^2]\n",
-    "        Examples\n",
-    "        --------\n",
-    "        >>> d2phidr2_mw(x=jnp.array([8.0, 0.0, 0.0]))\n",
-    "        \"\"\"\n",
-    "        rad = jnp.linalg.norm(x)\n",
-    "        return jnp.matmul(jnp.transpose(x), jnp.matmul(self.jacobian_force_mw(x, t), x)) / rad**2\n",
-    "\n",
-    "\n",
-    "    @partial(jax.jit,static_argnums=(0,))\n",
-    "    def omega(self, x,v):\n",
-    "        \"\"\"\n",
-    "        Computes the magnitude of the angular momentum in the simulation frame\n",
-    "        Args:\n",
-    "          x: 3d position (x, y, z) in [kpc]\n",
-    "          v: 3d velocity (v_x, v_y, v_z) in [kpc/Myr]\n",
-    "        Returns:\n",
-    "          Magnitude of angular momentum in [rad/Myr]\n",
-    "        Examples\n",
-    "        --------\n",
-    "        >>> omega(x=jnp.array([8.0, 0.0, 0.0]), v=jnp.array([8.0, 0.0, 0.0]))\n",
-    "        \"\"\"\n",
-    "        rad = jnp.sqrt(x[0] ** 2 + x[1] ** 2 + x[2] ** 2)\n",
-    "        omega_vec = jnp.cross(x, v) / rad**2\n",
-    "        return jnp.linalg.norm(omega_vec)\n",
-    "\n",
-    "    @partial(jax.jit,static_argnums=(0,))\n",
-    "    def tidalr_mw(self, x, v, Msat, t):\n",
-    "        \"\"\"\n",
-    "        Computes the tidal radius of a clsuter in the Milky Way potential\n",
-    "        Args:\n",
-    "          x: 3d position (x, y, z) in [kpc]\n",
-    "          v: 3d velocity (v_x, v_y, v_z) in [kpc/Myr]\n",
-    "          Msat: Cluster mass in [Msol]\n",
-    "        Returns:\n",
-    "          Tidal radius of the cluster in [kpc]\n",
-    "        Examples\n",
-    "        --------\n",
-    "        >>> tidalr_mw(x=jnp.array([8.0, 0.0, 0.0]), v=jnp.array([8.0, 0.0, 0.0]), Msat=1e4)\n",
-    "        \"\"\"\n",
-    "        return (self._G * Msat / ( self.omega(x, v) ** 2 - self.d2phidr2_mw(x, t)) ) ** (1.0 / 3.0)\n",
-    "    \n",
-    "    @partial(jax.jit,static_argnums=(0,))\n",
-    "    def lagrange_pts(self,x,v,Msat, t):\n",
-    "        r_tidal = self.tidalr_mw(x,v,Msat, t)\n",
-    "        r_hat = x/jnp.linalg.norm(x)\n",
-    "        L_close = x - r_hat*r_tidal\n",
-    "        L_far = x + r_hat*r_tidal\n",
-    "        return L_close, L_far\n",
-    "    \n",
-    "    @partial(jax.jit,static_argnums=(0,))\n",
-    "    def release_model(self, x, v, Msat, pos_disp, vel_disp,i, t):\n",
-    "        \"\"\"\n",
-    "        Simplification of particle spray: just release particles in gaussian blob at each lagrange point.\n",
-    "        User sets the spatial and velocity dispersion for the \"leaking\" of particles\n",
-    "        TODO: change random key handling... need to do all of the sampling up front...\n",
-    "        \"\"\"\n",
-    "        keya = jax.random.PRNGKey(i*3)\n",
-    "        keyb = jax.random.PRNGKey(i*5)\n",
-    "        \n",
-    "        keyc = jax.random.PRNGKey(i*7)\n",
-    "        keyd = jax.random.PRNGKey(i*11)\n",
-    "        \n",
-    "        L_close, L_far = self.lagrange_pts(x,v,Msat, t) # each is an xyz array\n",
-    "        ###print(L_close, L_far)\n",
-    "        pos_release_close = L_close + jax.random.normal(keya,shape=(3,))*pos_disp\n",
-    "        pos_release_far = L_far + jax.random.normal(keyb,shape=(3,))*pos_disp\n",
-    "        \n",
-    "        #DeltaR_r = jnp.sqrt(jnp.sum((L_far - L_close)**2))/jnp.linalg.norm(x)\n",
-    "        \n",
-    "        vel_release_close = v + jax.random.normal(keyc,shape=(3,))*vel_disp\n",
-    "        vel_release_far = v  + jax.random.normal(keyd,shape=(3,))*vel_disp\n",
-    "        \n",
-    "        return pos_release_close, pos_release_far, vel_release_close, vel_release_far\n",
-    "    \n",
-    "    @partial(jax.jit,static_argnums=(0,))\n",
-    "    def gen_stream_ics(self, ts, prog_w0, Msat, pos_disp, vel_disp):\n",
-    "        ws_jax = leapfrog_run(prog_w0, ts, self.gradient)\n",
-    "        \n",
-    "        def scan_fun(carry, t):\n",
-    "            i, pos_close, pos_far, vel_close, vel_far = carry\n",
-    "            pos_close_new, pos_far_new, vel_close_new, vel_far_new = self.release_model(ws_jax[i,:3], ws_jax[i,3:], M_sat, pos_disp, vel_disp,i, t)\n",
-    "            return [i+1, pos_close_new, pos_far_new, vel_close_new, vel_far_new], [pos_close_new, pos_far_new, vel_close_new, vel_far_new]#[i+1, pos_close_new, pos_far_new, vel_close_new, vel_far_new]\n",
-    "            \n",
-    "            \n",
-    "        #init_carry = [0, 0, 0, 0, 0]\n",
-    "        init_carry = [0, jnp.array([0.0,0.0,0.]), jnp.array([0.0,0.0,0.]), jnp.array([0.0,0.0,0.]), jnp.array([0.0,0.0,0.])] \n",
-    "        final_state, all_states = jax.lax.scan(scan_fun, init_carry, ts[1:])\n",
-    "        pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr = all_states\n",
-    "        return pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr\n",
-    "    \n",
-    "    @partial(jax.jit,static_argnums=(0,))\n",
-    "    def gen_stream(self, ts, prog_w0, Msat, pos_disp, vel_disp):\n",
-    "        pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr = self.gen_stream_ics(ts, prog_w0, Msat, pos_disp, vel_disp)\n",
-    "        \n",
-    "        def scan_fun(carry, particle_idx):\n",
-    "            i, pos_close_curr, pos_far_curr, vel_close_curr, vel_far_curr = carry\n",
-    "            curr_particle_w0_close = jnp.hstack([pos_close_curr,vel_close_curr])\n",
-    "            curr_particle_w0_far = jnp.hstack([pos_far_curr,vel_far_curr])\n",
-    "            #print(curr_particle_w0_close.shape)\n",
-    "            #indices = jnp.arange(i,len(ts))\n",
-    "            #t_particle = jnp.take(ts, indices)\n",
-    "            #################t_particle = jax.lax.slice(ts,(i,),(len(ts),))\n",
-    "            w_particle_close = leapfrog_run(curr_particle_w0_close, ts, self.gradient)\n",
-    "            w_particle_far = leapfrog_run(curr_particle_w0_far, ts, self.gradient)\n",
-    "            \n",
-    "            ###ts_update = jax.lax.dynamic_slice(ts_curr,(i+1,),(len(ts_curr)-1,))\n",
-    "            \n",
-    "            return [i+1, pos_close_arr[i+1,:], pos_far_arr[i+1,:], vel_close_arr[i+1,:], vel_far_arr[i+1,:]], [w_particle_close, w_particle_far]\n",
-    "        init_carry = [0, pos_close_arr[0,:], pos_far_arr[0,:], vel_close_arr[0,:], vel_far_arr[0,:]]\n",
-    "        particle_ids = jnp.arange(len(pos_close_arr))\n",
-    "        final_state, all_states = jax.lax.scan(scan_fun, init_carry, particle_ids)\n",
-    "        lead_arm, trail_arm = all_states\n",
-    "        return lead_arm, trail_arm\n",
-    "            \n",
-    "    @partial(jax.jit,static_argnums=(0,))\n",
-    "    def gen_stream_final(self, ts, prog_w0, Msat, pos_disp, vel_disp):\n",
-    "        pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr = self.gen_stream_ics(ts, prog_w0, Msat, pos_disp, vel_disp)\n",
-    "        \n",
-    "        def scan_fun(carry, particle_idx):\n",
-    "            i, pos_close_curr, pos_far_curr, vel_close_curr, vel_far_curr = carry\n",
-    "            curr_particle_w0_close = jnp.hstack([pos_close_curr,vel_close_curr])\n",
-    "            curr_particle_w0_far = jnp.hstack([pos_far_curr,vel_far_curr])\n",
-    "            #print(curr_particle_w0_close.shape)\n",
-    "            #indices = jnp.arange(i,len(ts))\n",
-    "            #t_particle = jnp.take(ts, indices)\n",
-    "            \n",
-    "            #######t_particle = jax.lax.slice(ts,(i,),(len(ts),))\n",
-    "            t_particle = jax.lax.dynamic_slice(ts,(i+1,),(len(ts)-1,))\n",
-    "            w_particle_close = leapfrog_run(curr_particle_w0_close, t_particle, self.gradient)\n",
-    "            w_particle_far = leapfrog_run(curr_particle_w0_far, t_particle, self.gradient)\n",
-    "            \n",
-    "            w_particle_close = w_particle_close[-1,:]\n",
-    "            w_particle_far = w_particle_far[-1,:]\n",
-    "            \n",
-    "            \n",
-    "            \n",
-    "            return [i+1, pos_close_arr[i+1,:], pos_far_arr[i+1,:], vel_close_arr[i+1,:], vel_far_arr[i+1,:]], [w_particle_close, w_particle_far]\n",
-    "        init_carry = [0, pos_close_arr[0,:], pos_far_arr[0,:], vel_close_arr[0,:], vel_far_arr[0,:]]\n",
-    "        particle_ids = jnp.arange(len(pos_close_arr))\n",
-    "        final_state, all_states = jax.lax.scan(scan_fun, init_carry, particle_ids)\n",
-    "        lead_arm, trail_arm = all_states\n",
-    "        return lead_arm, trail_arm\n",
-    "        \n",
-    "    \n",
-    "class Isochrone(Potential):\n",
-    "    \n",
-    "    def __init__(self, m, a, units=None):\n",
-    "        super().__init__(units, {'m': m, 'a': a})\n",
-    "    \n",
-    "    @partial(jax.jit, static_argnums=(0,))\n",
-    "    def potential(self, xyz, t):\n",
-    "        r = jnp.linalg.norm(xyz, axis=0)\n",
-    "        return - self._G * self.m / (self.a + jnp.sqrt(r**2 + self.a**2))\n",
-    "    \n",
-    "\n",
-    "    \n",
-    "    \n",
-    "class Isochrone_centered(Potential):\n",
-    "    \n",
-    "    def __init__(self, m, a, spline_eval_func, splines, t_min, t_max, m_ext, a_ext, units=None):\n",
-    "        super().__init__(units, {'m': m, 'a': a, 'spline_eval_func': spline_eval_func, 'splines': splines, 't_min': t_min, 't_max': t_max,\n",
-    "                                'm_ext': m_ext, 'a_ext': a_ext})\n",
-    "    \n",
-    "    @partial(jax.jit, static_argnums=(0,))\n",
-    "    def potential(self, xyz, t):\n",
-    "        is_cond_met = (t > self.t_min) & (t < self.t_max) # True if yes, False if no\n",
-    "        \n",
-    "        pot_ext = Isochrone(m=self.m_ext, a=self.a_ext, units=self.units)\n",
-    "        \n",
-    "        def true_func(xyz_t):\n",
-    "            xyz_, t = xyz_t[:3], xyz_t[-1]\n",
-    "            xyz = xyz_ - self.spline_eval_func(t,self.splines)\n",
-    "            r = jnp.linalg.norm(xyz, axis=0)\n",
-    "            return - self._G * self.m / (self.a + jnp.sqrt(r**2 + self.a**2))  + pot_ext.potential(xyz_,t)#+ self.pot_ext.potential(xyz_,t)\n",
-    "        def false_func(xyz_t):\n",
-    "            xyz, t = xyz_t[:3], xyz_t[-1]\n",
-    "            return pot_ext.potential(xyz,t)#0.#self.pot_ext.potential(xyz,t)\n",
-    "        xyz_t = jnp.hstack([xyz,t])\n",
-    "        return jax.lax.cond(pred=is_cond_met, true_fun=true_func, false_fun=false_func,operand=xyz_t)\n",
-    "    \n",
-    "        \n",
-    "\n",
-    "    \n",
-    "\n",
-    "    \n",
-    "    \n",
-    "    \n",
-    "def leapfrog_step(func, y0, t0, dt, a0):\n",
-    "    ndim = y0.shape[0] // 2\n",
-    "    tf = t0 + dt\n",
-    "    \n",
-    "    x0 = y0[:ndim]\n",
-    "    v0 = y0[ndim:]\n",
-    "    \n",
-    "    v1_2 = v0 + a0 * dt / 2.\n",
-    "    xf = x0 + v1_2 * dt\n",
-    "    af = - func(xf, tf)\n",
-    "    \n",
-    "    vf = v1_2 + af * dt / 2\n",
-    "    \n",
-    "    return tf, jnp.concatenate((xf, vf)), af\n",
-    "\n",
-    "@partial(jax.jit, static_argnames=['potential_gradient', 'args'])\n",
-    "def leapfrog_run(w0, ts, potential_gradient, args=()):\n",
-    "    func_ = lambda y, t: potential_gradient(y, t, *args)\n",
-    "    \n",
-    "    def scan_fun(carry, t):\n",
-    "        i, y0, t0, dt, a0 = carry\n",
-    "        tf, yf, af = leapfrog_step(func_, y0, t0, dt, a0)\n",
-    "        return [i + 1, yf, tf, dt, af], yf\n",
-    "    \n",
-    "    ndim = w0.shape[0] // 2\n",
-    "    a0 = func_(w0[:ndim], ts[0])\n",
-    "    init_carry = [0, w0, t0, dt, a0]\n",
-    "    _, ws = jax.lax.scan(scan_fun, init_carry, ts[1:])\n",
-    "    res_ws = jnp.concatenate((w0[None], ws))\n",
-    "    \n",
-    "    return res_ws\n",
-    "\n",
-    "def compute_orbit_and_gradients(params,w0,dt,n_steps,units):\n",
-    "    pot = Hernquist(m=params['m'], a=params['a'],units=units,)  # Create the potential with the given parameters\n",
-    "    \n",
-    "    # Example Orbit:\n",
-    "    #w0 = jnp.array([10, 0, 0, 0, .204, 0])\n",
-    "    t0 = 0\n",
-    "    #dt = 0.1\n",
-    "    #n_steps = 10000\n",
-    "    ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "    \n",
-    "    ### Compute the orbit with the provided potential\n",
-    "    ws_jax = leapfrog_run(w0, ts, pot.gradient)\n",
-    "    \n",
-    "    # Compute the gradient of the final position with respect to the potential parameters\n",
-    "    def gradient_fn(params):\n",
-    "        pot_with_params = Hernquist(m=params['m'], a=params['a'],units=units)\n",
-    "        ws_with_params = leapfrog_run(w0, ts, pot_with_params.gradient)\n",
-    "        final_position = ws_with_params[-1, :]  # Extract final position\n",
-    "        return final_position\n",
-    "    \n",
-    "    # Compute the gradient using JAX's autodiff\n",
-    "    gradient = jax.jacfwd(gradient_fn)(params)\n",
-    "    \n",
-    "    return ws_jax, gradient\n",
-    "\n",
-    "def get_stripping_time_arr(ts):\n",
-    "    \"\"\"\n",
-    "    assuming a particle is released for index in the ts array\n",
-    "    TODO: Custom release\n",
-    "    \"\"\"\n",
-    "    t_release_arr = []\n",
-    "    for i in range(len(ts)):\n",
-    "        t_release_arr.append( ts[i:] )\n",
-    "    return t_release_arr"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "196d9377-e4a8-4c47-b4b7-3218a5e94efb",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from jax_cosmo.scipy.interpolate import InterpolatedUnivariateSpline\n",
-    "def get_spl_funcs(ts,ws):\n",
-    "    return [InterpolatedUnivariateSpline(ts,ws[:,i],k=3) for i in range(3)]\n",
-    "\n",
-    "def eval_spl_funcs(ts, spl_funcs):\n",
-    "    return jnp.array([spl_funcs[i](ts) for i in range(3)])\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "0532916d-3083-4acf-b6e0-38e8c9428255",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "params_global = {'m': 1.0e12, 'a': 10.}\n",
-    "pot = Isochrone(m=params_global['m'], a=params_global['a'],units=usys,)  \n",
-    "t0 = 0\n",
-    "dt = 0.5\n",
-    "n_steps = 2_000\n",
-    "w0 = jnp.array([50., 0., 0, (0*u.km/u.s).to(u.kpc/u.Myr).value, (150*u.km/u.s).to(u.kpc/u.Myr).value, (0*u.km/u.s).to(u.kpc/u.Myr).value])\n",
-    "\n",
-    "M_sat = 1.0e4\n",
-    "w0_subhalo =  jnp.array([45., 0., 0, (0*u.km/u.s).to(u.kpc/u.Myr).value, (250*u.km/u.s).to(u.kpc/u.Myr).value, (0*u.km/u.s).to(u.kpc/u.Myr).value])\n",
-    "\n",
-    "\n",
-    "ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "### Compute the orbit with the provided potential\n",
-    "ws_jax = leapfrog_run(w0_subhalo, ts, pot.gradient)\n",
-    "\n",
-    "\n",
-    "#spl_x = InterpolatedUnivariateSpline(ts,ws_jax[:,0],k=3)\n",
-    "#spl_y = InterpolatedUnivariateSpline(ts,ws_jax[:,1],k=3)\n",
-    "\n",
-    "splines = get_spl_funcs(ts, ws_jax)\n",
-    "spline_evals = eval_spl_funcs(ts[3], splines)\n",
-    "\n",
-    "#########################################\n",
-    "\n",
-    "params_else = {'spline_eval_func': eval_spl_funcs, 'splines': splines, 't_min': 0., 't_max': 50000.,\n",
-    "         'm_ext': 1.0e12, 'a_ext': 10.0}\n",
-    "params_subhalo = {'m':1e7, 'a':1.0}\n",
-    "pot_with_params = Isochrone_centered(m=params_subhalo['m'], a=params_subhalo['a'],\n",
-    "                         spline_eval_func=params_else['spline_eval_func'],\n",
-    "                         splines=params_else['splines'],\n",
-    "                         t_min=params_else['t_min'],\n",
-    "                         t_max = params_else['t_max'],\n",
-    "                         m_ext = params_else['m_ext'],\n",
-    "                         a_ext = params_else['a_ext'],\n",
-    "                         units=usys,)  \n",
-    "w_orb = leapfrog_run(w0, ts, pot_with_params.gradient)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "86f07be7-d471-4325-9cca-0915000242f0",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "@jax.jit\n",
-    "def gauss_pt(x_eval, x_mean):\n",
-    "    return -0.5*jnp.sum(jnp.square(x_eval - x_mean))\n",
-    "#gauss_pt(w_orb[-1,:],w_orb[-1,:])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "d3981bc8-9831-48e2-9f34-1883c9abc03f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def compute_orbit_and_gradients(params,w0,dt,n_steps,units):\n",
-    "    # Compute the gradient of the final position with respect to the potential parameters\n",
-    "    def gradient_fn(params):\n",
-    "        pot = Isochrone(m=params_global['m'], a=params_global['a'],units=usys,)  \n",
-    "        t0 = 0\n",
-    "        dt = 0.5\n",
-    "        n_steps = 2_000\n",
-    "        w0 = jnp.array([50., 0., 0, (0*u.km/u.s).to(u.kpc/u.Myr).value, (150*u.km/u.s).to(u.kpc/u.Myr).value, (0*u.km/u.s).to(u.kpc/u.Myr).value])\n",
-    "\n",
-    "\n",
-    "        w0_subhalo =  jnp.array([45., 0., 0, (0*u.km/u.s).to(u.kpc/u.Myr).value, (250*u.km/u.s).to(u.kpc/u.Myr).value, (0*u.km/u.s).to(u.kpc/u.Myr).value])\n",
-    "\n",
-    "\n",
-    "        ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "        ### Compute the orbit with the provided potential\n",
-    "        ws_jax = leapfrog_run(w0_subhalo, ts, pot.gradient)\n",
-    "\n",
-    "        splines = get_spl_funcs(ts, ws_jax)\n",
-    "        \n",
-    "        \n",
-    "        \n",
-    "        \n",
-    "        ######################spline_evals = eval_spl_funcs(ts[3], splines)\n",
-    "        ################\n",
-    "        \n",
-    "        \n",
-    "        \n",
-    "        \n",
-    "        #splines = get_spl_funcs(ts, ws_jax)\n",
-    "        #spline_evals = eval_spl_funcs(ts[3], splines)\n",
-    "        params_else = {'spline_eval_func': eval_spl_funcs, 'splines': splines, 't_min': 0., 't_max': 50000.,\n",
-    "         'm_ext': 1.0e12, 'a_ext': 10.0}\n",
-    "\n",
-    "        pot_with_params = Isochrone_centered(m=params['m'], a=params['a'],\n",
-    "                         spline_eval_func=params_else['spline_eval_func'],\n",
-    "                         splines=params_else['splines'],\n",
-    "                         t_min=params_else['t_min'],\n",
-    "                         t_max = params_else['t_max'],\n",
-    "                         m_ext = params_else['m_ext'],\n",
-    "                         a_ext = params_else['a_ext'],\n",
-    "                         units=usys,)  \n",
-    "        ws_with_params = leapfrog_run(w0, ts, pot_with_params.gradient)\n",
-    "        final_position = ws_with_params[-1, :]  # Extract final position\n",
-    "        return gauss_pt(final_position,w_orb[-1,:])\n",
-    "        #return final_position\n",
-    "    \n",
-    "    # Compute the gradient using JAX's autodiff\n",
-    "    gradient = jax.jacfwd(gradient_fn)(params) #grad gives zero!!!!\n",
-    "    \n",
-    "    return gradient"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "3abb656d-6401-476a-9cba-9b85d17788de",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "gradient_out = compute_orbit_and_gradients(params_subhalo,w0,dt,n_steps,usys)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "id": "32dcdcd9-05dc-4eb1-840f-f3c9a6f5b120",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'a': Array(0., dtype=float64, weak_type=True),\n",
-       " 'm': Array(0., dtype=float64, weak_type=True)}"
-      ]
-     },
-     "execution_count": 21,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "gradient_out"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "8d32b658-945b-4418-ad9c-b7287f20bd6a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "jacfwd_out = compute_orbit_and_gradients(params_subhalo,w0,dt,n_steps,usys)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "b72cb37d-2e3b-42f9-9720-70cf727ddc03",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'a': Array(2.67710422e-17, dtype=float64),\n",
-       " 'm': Array(-9.97662795e-24, dtype=float64)}"
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "jacfwd_out"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "97121975-3f11-4a18-b829-7ba752e2ccc6",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "6bd2c40c-2e42-4d1f-9601-30caf3868bee",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pos_disp = 0.0\n",
-    "vel_disp = (5.0*u.km/u.s).to(u.kpc/u.Myr).value\n",
-    "\n",
-    "lead_arm_data, trail_arm_data = pot_with_params.gen_stream_final(ts, w0, M_sat, pos_disp, vel_disp)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "932d5ad6-d323-42ef-a845-85ebb62ccb7b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#@partial(jax.jit, static_argnums=(1,))\n",
-    "def cost_func(stream_particles_data=None,stream_particles_model=None):\n",
-    "    return -jnp.mean(jnp.square(stream_particles_data[:] - stream_particles_model[:]))\n",
-    "from functools import partial\n",
-    "test_func = partial(cost_func,stream_particles_data=lead_arm_data)\n",
-    "#test_func(stream_particles_model=lead_arm_data)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "id": "54a49536-d154-4f30-9e12-c62a66a75282",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def stream_gradients_kde(params,ts,w0,Msat, pos_disp, vel_disp, kde, units):\n",
-    "    #pot = Isochrone(m=params['m'], a=params['a'],units=units)\n",
-    "    #lead_arm, trail_arm = pot.gen_stream_final(ts, w0, Msat, pos_disp, vel_disp)\n",
-    "    \n",
-    "    # Compute the gradient of the final position with respect to the potential parameters\n",
-    "    #$@partial(jax.jit, static_argnames=['lead_arm_data'])\n",
-    "    def gradient_fn(params):\n",
-    "        pot = Isochrone(m=params_global['m'], a=params_global['a'],units=usys,)  \n",
-    "        t0 = 0\n",
-    "        dt = 0.5\n",
-    "        n_steps = 2_000\n",
-    "        w0 = jnp.array([50., 0., 0, (0*u.km/u.s).to(u.kpc/u.Myr).value, (150*u.km/u.s).to(u.kpc/u.Myr).value, (0*u.km/u.s).to(u.kpc/u.Myr).value])\n",
-    "\n",
-    "\n",
-    "        w0_subhalo =  jnp.array([45., 0., 0, (0*u.km/u.s).to(u.kpc/u.Myr).value, (250*u.km/u.s).to(u.kpc/u.Myr).value, (0*u.km/u.s).to(u.kpc/u.Myr).value])\n",
-    "\n",
-    "\n",
-    "        ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "        ### Compute the orbit with the provided potential\n",
-    "        ws_jax = leapfrog_run(w0_subhalo, ts, pot.gradient)\n",
-    "\n",
-    "        splines = get_spl_funcs(ts, ws_jax)\n",
-    "        \n",
-    "        \n",
-    "\n",
-    "        \n",
-    "        \n",
-    "        \n",
-    "        \n",
-    "        #splines = get_spl_funcs(ts, ws_jax)\n",
-    "        #spline_evals = eval_spl_funcs(ts[3], splines)\n",
-    "        params_else = {'spline_eval_func': eval_spl_funcs, 'splines': splines, 't_min': 0., 't_max': 50000.,\n",
-    "         'm_ext': 1.0e12, 'a_ext': 10.0}\n",
-    "\n",
-    "        pot_with_params = Isochrone_centered(m=params['m'], a=params['a'],\n",
-    "                         spline_eval_func=params_else['spline_eval_func'],\n",
-    "                         splines=params_else['splines'],\n",
-    "                         t_min=params_else['t_min'],\n",
-    "                         t_max = params_else['t_max'],\n",
-    "                         m_ext = params_else['m_ext'],\n",
-    "                         a_ext = params_else['a_ext'],\n",
-    "                         units=usys,)   \n",
-    "        \n",
-    "        \n",
-    "        #############pot_with_params = Isochrone(m=params['m'], a=params['a'],units=units)\n",
-    "        lead_arm, trail_arm = pot_with_params.gen_stream_final(ts, w0, Msat, pos_disp, vel_disp)\n",
-    "        #kde = statsjax.gaussian_kde(lead_arm.T,bw_method=.07)\n",
-    "        log_like = test_func(stream_particles_model=lead_arm)#cost_func(lead_arm,lead_arm_data)#cost_func(lead_arm)#jnp.sum(kde.logpdf(lead_arm[:,:2].T))\n",
-    "        return log_like#jnp.sum(lead_arm**2) \n",
-    "    \n",
-    "    #func_take_grad = lambda xx: jax.jacfwd(gradient_fn)(xx,lead_arm_data)\n",
-    "    # Compute the gradient using JAX's autodiff\n",
-    "    gradient_eval = jax.jacfwd(gradient_fn)(params)\n",
-    "    \n",
-    "    vall = gradient_fn(params)\n",
-    "    \n",
-    "    #grad_eval_func = lambda params: jax.jacfwd(gradient_fn)(params,lead_arm_data)\n",
-    "    #second_grad_eval = jax.jacfwd(grad_eval_func)(params)\n",
-    "    \n",
-    "    return gradient_eval,vall#, second_grad_eval\n",
-    "    \n",
-    "params_ = {'m': 10000000.0, 'a': 1.0}\n",
-    "\n",
-    "gradient_eval, second_gradient = stream_gradients_kde(params_,ts,w0,M_sat,pos_disp,vel_disp, None, usys)\n",
-    "    \n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "54d4c983-e05b-4381-a64d-01d15398822d",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 32,
-   "id": "107369c1-f1ea-4f1b-a6ee-bf4c2e240077",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'a': Array(1.22908552e-16, dtype=float64),\n",
-       " 'm': Array(-2.90937077e-23, dtype=float64)}"
-      ]
-     },
-     "execution_count": 32,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "gradient_eval"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 34,
-   "id": "a7ad4581-c0a8-4bcf-b3df-a43923501d0f",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(True, True)"
-      ]
-     },
-     "execution_count": 34,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "np.isclose(np.float64(1.22908552e-16), 0), np.isclose(np.float64(-2.90937077e-23), 0)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 44,
-   "id": "7ce2eec5-0e3a-49b7-afd0-55faaab09453",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'a': Array(-2.2275778e-18, dtype=float64),\n",
-       " 'm': Array(8.39263526e-25, dtype=float64)}"
-      ]
-     },
-     "execution_count": 44,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 32,
-   "id": "822edcf2-0f72-4118-894a-2723167a9a0f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "params = {'m': 1.0e12, 'a': 10.}\n",
-    "pot = Isochrone(m=params['m'], a=params['a'],units=usys,)  \n",
-    "t0 = 0\n",
-    "dt = 0.5\n",
-    "n_steps = 2_000\n",
-    "w0 = jnp.array([50., 0., 0, (0*u.km/u.s).to(u.kpc/u.Myr).value, (150*u.km/u.s).to(u.kpc/u.Myr).value, (0*u.km/u.s).to(u.kpc/u.Myr).value])\n",
-    "\n",
-    "\n",
-    "w0_subhalo =  jnp.array([45., 0., 0, (0*u.km/u.s).to(u.kpc/u.Myr).value, (250*u.km/u.s).to(u.kpc/u.Myr).value, (0*u.km/u.s).to(u.kpc/u.Myr).value])\n",
-    "\n",
-    "\n",
-    "ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "### Compute the orbit with the provided potential\n",
-    "ws_jax = leapfrog_run(w0_subhalo, ts, pot.gradient)\n",
-    "\n",
-    "M_sat = 1.0e4 # TODO: mass loss rate\n",
-    "\n",
-    "\n",
-    "\n",
-    "\n",
-    "#lead_ics = jnp.zeros((len(ws_jax),6))\n",
-    "#trail_ics = jnp.zeros((len(ws_jax),6))\n",
-    "\n",
-    "#for i in range(len(ws_jax)):\n",
-    "#    pos_close, pos_far, vel_close, vel_far = pot.release_model(ws_jax[i,:3], ws_jax[i,3:], M_sat, pos_disp, vel_disp)\n",
-    "    "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 32,
-   "id": "c02fa9c4-20bb-45a9-bbd2-8a8e3bfb8ab7",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "aa = ts/dt\n",
-    "#jnp.integer(aa[10])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 34,
-   "id": "9ce51581-90dd-4ba5-a659-0df7b797b146",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array(1., dtype=float64)"
-      ]
-     },
-     "execution_count": 34,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "aa[1]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "76e29d2c-ad35-4484-8ed7-ece9710ab752",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7fcba1f51700>"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.scatter(ws_jax[:,0],ws_jax[:,1])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 33,
-   "id": "91b79ed3-f678-43a8-9113-3f7d19a42991",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from jax_cosmo.scipy.interpolate import InterpolatedUnivariateSpline\n",
-    "def get_spl_funcs(ts,ws):\n",
-    "    return [InterpolatedUnivariateSpline(ts,ws[:,i],k=3) for i in range(3)]\n",
-    "\n",
-    "def eval_spl_funcs(ts, spl_funcs):\n",
-    "    return jnp.array([spl_funcs[i](ts) for i in range(3)])\n",
-    "#spl_x = InterpolatedUnivariateSpline(ts,ws_jax[:,0],k=3)\n",
-    "#spl_y = InterpolatedUnivariateSpline(ts,ws_jax[:,1],k=3)\n",
-    "\n",
-    "splines = get_spl_funcs(ts, ws_jax)\n",
-    "spline_evals = eval_spl_funcs(ts[3], splines)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 34,
-   "id": "09e6d9ac-caf0-436d-a746-548511490ac2",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "params = {'m': 1.0e12, 'a': 10.}\n",
-    "pot = Isochrone(m=params['m'], a=params['a'],units=usys,)  \n",
-    "t0 = 0\n",
-    "dt = 0.5\n",
-    "n_steps = 2_000\n",
-    "w0 = jnp.array([50., 0., 0, (0*u.km/u.s).to(u.kpc/u.Myr).value, (150*u.km/u.s).to(u.kpc/u.Myr).value, (0*u.km/u.s).to(u.kpc/u.Myr).value])\n",
-    "\n",
-    "\n",
-    "w0_subhalo =  jnp.array([45., 0., 0, (0*u.km/u.s).to(u.kpc/u.Myr).value, (250*u.km/u.s).to(u.kpc/u.Myr).value, (0*u.km/u.s).to(u.kpc/u.Myr).value])\n",
-    "\n",
-    "\n",
-    "ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "### Compute the orbit with the provided potential\n",
-    "ws_jax = leapfrog_run(w0_subhalo, ts, pot.gradient)\n",
-    "\n",
-    "splines = get_spl_funcs(ts, ws_jax)\n",
-    "spline_evals = eval_spl_funcs(ts[3], splines)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "id": "da7aebe5-7ec7-40f9-a125-254d2eab581f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "params = {'m': 1.0e7, 'a': 1.0, 'spline_eval_func': eval_spl_funcs, 'splines': splines, 't_min': 0., 't_max': 50000.,\n",
-    "         'm_ext': 1.0e12, 'a_ext': 10.}\n",
-    "\n",
-    "pot = Isochrone_centered(m=params['m'], a=params['a'],\n",
-    "                         spline_eval_func=params['spline_eval_func'],\n",
-    "                         splines=params['splines'],\n",
-    "                         t_min=params['t_min'],\n",
-    "                         t_max = params['t_max'],\n",
-    "                         m_ext = params['m_ext'],\n",
-    "                         a_ext = params['a_ext'],\n",
-    "                         units=usys,)  \n",
-    "\n",
-    "\n",
-    "ws_jax_time_dep = leapfrog_run(w0, ts, pot.gradient)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 37,
-   "id": "5144ccd5-d3b8-4441-bb7e-57755dcb02fc",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.colorbar.Colorbar at 0x7f80e7902c40>"
-      ]
-     },
-     "execution_count": 37,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 2 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.scatter(ws_jax_time_dep[:,0],ws_jax_time_dep[:,1],c=ts,rasterized=True)\n",
-    "plt.colorbar()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "id": "fa2aad7f-469e-47e8-abf4-a05dc401e101",
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "NameError",
-     "evalue": "name 'M_sat' is not defined",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_34929/4114538110.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mlead_arm\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrail_arm\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpot\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgen_stream_final\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mw0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mM_sat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpos_disp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvel_disp\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-      "\u001b[0;31mNameError\u001b[0m: name 'M_sat' is not defined"
-     ]
-    }
-   ],
-   "source": [
-    "lead_arm, trail_arm = pot.gen_stream_final(ts, w0, M_sat, pos_disp, vel_disp)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 39,
-   "id": "bb9d756f-4a5a-4311-a247-1519dbfd68f8",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7f80e7c09dc0>"
-      ]
-     },
-     "execution_count": 39,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "#plt.plot(gala_orb.x,gala_orb.y,color='r')\n",
-    "plt.scatter(lead_arm[:,0],lead_arm[:,1],s=.4,zorder=2)\n",
-    "\n",
-    "#plt.xlim(-70,-40)\n",
-    "#plt.\n",
-    "#plt.scatter(trail_arm[:,0],trail_arm[:,1],s=0.05)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 40,
-   "id": "a17bf61b-6eb2-44c5-b3ae-aff9bcf76068",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7f80ed8ec070>"
-      ]
-     },
-     "execution_count": 40,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "#plt.plot(gala_orb.x,gala_orb.y,color='r')\n",
-    "plt.scatter(lead_arm[:,0],lead_arm[:,1],s=.4,zorder=2)\n",
-    "\n",
-    "#plt.xlim(-70,-40)\n",
-    "#plt.\n",
-    "#plt.scatter(trail_arm[:,0],trail_arm[:,1],s=0.05)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 41,
-   "id": "3bc559e5-78a2-4bfb-a48e-9bfaf7f65ab7",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(2000, 6)"
-      ]
-     },
-     "execution_count": 41,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "lead_arm.shape"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 42,
-   "id": "5570b804-92c7-48c4-afb2-50cb82de2711",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Text(0, 0.5, '$y$ [kpc]')"
-      ]
-     },
-     "execution_count": 42,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 576x576 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig, ax = plt.subplots(1,1)\n",
-    "fig.set_size_inches(8,8)\n",
-    "ax.scatter(lead_arm[:,0],lead_arm[:,1],s=10,color='k')\n",
-    "ax.set_xlabel(r'$x$ [kpc]',fontsize=20)\n",
-    "ax.set_ylabel(r'$y$ [kpc]',fontsize=20)\n",
-    "##plt.savefig('sample_stream.pdf',bbox_inches='tight')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "3ac0bd55-78a2-4a85-aa9a-5521a503d369",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#@partial(jax.jit, static_argnums=(1,))\n",
-    "def cost_func(stream_particles_data=None,stream_particles_model=None):\n",
-    "    return -jnp.mean(jnp.square(stream_particles_data - stream_particles_model))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "bc239ecf-0c93-4793-abe6-1116cef2e3ca",
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "NameError",
-     "evalue": "name 'M_sat' is not defined",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_34929/1835354117.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mlead_arm_data\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrail_arm_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpot\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgen_stream_final\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mw0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mM_sat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpos_disp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvel_disp\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-      "\u001b[0;31mNameError\u001b[0m: name 'M_sat' is not defined"
-     ]
-    }
-   ],
-   "source": [
-    "lead_arm_data, trail_arm_data = pot.gen_stream_final(ts, w0, M_sat, pos_disp, vel_disp)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 45,
-   "id": "b16c73d0-3b81-431e-b281-cc6c6ab03420",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array([ 2.69442469e+00,  2.10445949e+01,  3.52088852e-01, -3.37212765e-01,\n",
-       "        1.74464865e-01,  2.95407934e-03], dtype=float64)"
-      ]
-     },
-     "execution_count": 45,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "lead_arm_data[4]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 46,
-   "id": "590da05f-8407-496a-a6b9-55ab925a41bb",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array(-0., dtype=float64)"
-      ]
-     },
-     "execution_count": 46,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from functools import partial\n",
-    "test_func = partial(cost_func,stream_particles_data=lead_arm_data)\n",
-    "test_func(stream_particles_model=lead_arm_data)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 47,
-   "id": "ba9d13fb-02ff-45fc-821c-2322f2db9018",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array(-11.96141064, dtype=float64)"
-      ]
-     },
-     "execution_count": 47,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "cost_func(lead_arm_data,trail_arm_data)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 109,
-   "id": "329b8c08-ecf5-4514-9669-e7628153dc7c",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7fce87ed74f0>"
-      ]
-     },
-     "execution_count": 109,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import jax.scipy.stats as statsjax\n",
-    "kde = statsjax.gaussian_kde(lead_arm[:,:2].T,bw_method=.01)\n",
-    "key = jax.random.PRNGKey(3)\n",
-    "samps = kde.resample(key,[len(lead_arm)]).T\n",
-    "ll = kde.logpdf(lead_arm[:,:2].T)\n",
-    "plt.scatter(samps[:,0],samps[:,1],s=.4)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 58,
-   "id": "d0cdad0d-aad3-4078-9db6-fd375faed875",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import jax.scipy.stats as statsjax\n",
-    "\n",
-    "def stream_gradients_kde(params,ts,w0,Msat, pos_disp, vel_disp, kde, units):\n",
-    "    #pot = Isochrone(m=params['m'], a=params['a'],units=units)\n",
-    "    #lead_arm, trail_arm = pot.gen_stream_final(ts, w0, Msat, pos_disp, vel_disp)\n",
-    "    \n",
-    "    # Compute the gradient of the final position with respect to the potential parameters\n",
-    "    #$@partial(jax.jit, static_argnames=['lead_arm_data'])\n",
-    "    def gradient_fn(params):\n",
-    "        params_else = {'spline_eval_func': eval_spl_funcs, 'splines': splines, 't_min': 0., 't_max': 50000.,\n",
-    "         'm_ext': 1.0e12, 'a_ext': 10.0}\n",
-    "\n",
-    "        pot_with_params = Isochrone_centered(m=params['m'], a=params['a'],\n",
-    "                         spline_eval_func=params_else['spline_eval_func'],\n",
-    "                         splines=params_else['splines'],\n",
-    "                         t_min=params_else['t_min'],\n",
-    "                         t_max = params_else['t_max'],\n",
-    "                         m_ext = params_else['m_ext'],\n",
-    "                         a_ext = params_else['a_ext'],\n",
-    "                         units=usys,)  \n",
-    "        \n",
-    "        \n",
-    "        #############pot_with_params = Isochrone(m=params['m'], a=params['a'],units=units)\n",
-    "        lead_arm, trail_arm = pot_with_params.gen_stream_final(ts, w0, Msat, pos_disp, vel_disp)\n",
-    "        #kde = statsjax.gaussian_kde(lead_arm.T,bw_method=.07)\n",
-    "        log_like = test_func(stream_particles_model=lead_arm)#cost_func(lead_arm,lead_arm_data)#cost_func(lead_arm)#jnp.sum(kde.logpdf(lead_arm[:,:2].T))\n",
-    "        return log_like#jnp.sum(lead_arm**2) \n",
-    "    \n",
-    "    #func_take_grad = lambda xx: jax.jacfwd(gradient_fn)(xx,lead_arm_data)\n",
-    "    # Compute the gradient using JAX's autodiff\n",
-    "    gradient_eval = jax.jacfwd(gradient_fn)(params)\n",
-    "    \n",
-    "    #grad_eval_func = lambda params: jax.jacfwd(gradient_fn)(params,lead_arm_data)\n",
-    "    #second_grad_eval = jax.jacfwd(grad_eval_func)(params)\n",
-    "    \n",
-    "    return gradient_eval,None#, second_grad_eval\n",
-    "    \n",
-    "params_ = {'m': 10000000.0, 'a': 1.0}\n",
-    "\n",
-    "gradient_eval, second_gradient = stream_gradients_kde(params_,ts,w0,M_sat,pos_disp,vel_disp, None, usys)\n",
-    "    \n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 62,
-   "id": "2d84b734-16c9-480d-a072-66b2192ca44a",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'a': Array(1.22908552e-16, dtype=float64),\n",
-       " 'm': Array(-2.90937077e-23, dtype=float64)}"
-      ]
-     },
-     "execution_count": 62,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "gradient_eval"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 50,
-   "id": "c0d011cd-b1e6-46fe-9ba0-f34232a6bb1d",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'a': Array(1.22908552e-16, dtype=float64),\n",
-       " 'm': Array(-2.90937077e-23, dtype=float64)}"
-      ]
-     },
-     "execution_count": 50,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "gradient_eval"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 54,
-   "id": "b34d1f56-bd79-43f2-8e9e-3cb842f63c33",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'a': Array(1.22908552e-16, dtype=float64),\n",
-       " 'm': Array(-2.90937077e-23, dtype=float64)}"
-      ]
-     },
-     "execution_count": 54,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "gradient_eval"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 55,
-   "id": "9d09916a-7bfe-4c23-920e-c9052d568858",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'a': Array(1.22908552e-16, dtype=float64),\n",
-       " 'm': Array(-2.90937077e-23, dtype=float64)}"
-      ]
-     },
-     "execution_count": 55,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "gradient_eval"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 67,
-   "id": "5ca1c2d6-fcde-4529-b92f-8a4e5e225359",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "params_ = {'m': params['m'], 'a': params['a']}\n",
-    "\n",
-    "gradient_eval_2d, second_gradient_2d = stream_gradients_kde(params_,ts,w0,M_sat,pos_disp,vel_disp, kde, usys)\n",
-    "    "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "id": "2c3f55e6-5593-4a56-b495-9cc1b0aef2e5",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/latex": [
-       "$9.7779222 \\; \\mathrm{\\frac{km}{s}}$"
-      ],
-      "text/plain": [
-       "<Quantity 9.77792222 km / s>"
-      ]
-     },
-     "execution_count": 17,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "(.01*u.kpc/u.Myr).to(u.km/u.s)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 40,
-   "id": "c14385a2-a3cd-4ee2-a4b1-fb80164d6ae1",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(7.0, 1.0)"
-      ]
-     },
-     "execution_count": 40,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "np.log10(params['m']), params['a']"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 41,
-   "id": "1e3d5bb6-432f-44a9-966e-ef9f07d5ca74",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'a': Array(-0.06254839, dtype=float64),\n",
-       " 'm': Array(3.20675563e-09, dtype=float64)}"
-      ]
-     },
-     "execution_count": 41,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "gradient_eval"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 68,
-   "id": "6878ce67-abe8-4686-b6d4-ac023c7ddc91",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'a': Array(1.47724978, dtype=float64),\n",
-       " 'm': Array(-2.04594388e-07, dtype=float64)}"
-      ]
-     },
-     "execution_count": 68,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "gradient_eval_2d"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 42,
-   "id": "7c6152f9-365c-4657-b276-4785165aa531",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "Mass_unit = 1e6\n",
-    "I = -jnp.array([ [second_gradient['a']['a'],second_gradient['a']['m']*(Mass_unit) ],\n",
-    "            [second_gradient['a']['m']*Mass_unit, second_gradient['m']['m']*(Mass_unit**2) ] ])\n",
-    "I_inv = np.array(jnp.linalg.inv(I))\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 70,
-   "id": "79665b2c-6ecb-4123-a398-3490e965e930",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([[0.14517923, 0.55630666],\n",
-       "       [0.55630666, 3.34432455]])"
-      ]
-     },
-     "execution_count": 70,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "Mass_unit = 1e6\n",
-    "I = -jnp.array([ [second_gradient_2d['a']['a'],second_gradient_2d['a']['m']*(Mass_unit) ],\n",
-    "            [second_gradient_2d['a']['m']*Mass_unit, second_gradient_2d['m']['m']*(Mass_unit**2) ] ])\n",
-    "I_inv_2d = np.array(jnp.linalg.inv(I))\n",
-    "I_inv_2d"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 44,
-   "id": "18e074dd-c26f-4d30-bf23-e9b05c50b46e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "e_val_true, e_vec_true = jnp.linalg.eig(I_inv)\n",
-    "e_vec_true_0 = e_vec_true[:,np.argmax(e_val_true)]\n",
-    "e_vec_true_1 = e_vec_true[:,np.argmin(e_val_true)]\n",
-    "\n",
-    "theta_true = np.real(np.arctan(e_vec_true_1[0]/e_vec_true_0[0]))\n",
-    "w_true = 2*np.sqrt(np.real(e_val_true[0]))\n",
-    "h_true = 2*np.sqrt(np.real(e_val_true[1]))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 71,
-   "id": "31e007b0-34b8-49bc-8321-aa788582d96f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "e_val_true, e_vec_true = jnp.linalg.eig(I_inv_2d)\n",
-    "e_vec_true_0 = e_vec_true[:,np.argmax(e_val_true)]\n",
-    "e_vec_true_1 = e_vec_true[:,np.argmin(e_val_true)]\n",
-    "\n",
-    "theta_true_2d = np.real(np.arctan(e_vec_true_1[0]/e_vec_true_0[0]))\n",
-    "w_true_2d = 2*np.sqrt(np.real(e_val_true[0]))\n",
-    "h_true_2d = 2*np.sqrt(np.real(e_val_true[1]))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 73,
-   "id": "c79922a1-aaba-478a-b91e-5513abe4ab03",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 120,
-   "id": "8b9c692b-947c-44db-a2f5-d98ce854d034",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x432 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig, ax = plt.subplots(1,1)\n",
-    "fig.set_size_inches(6,6)\n",
-    "ellipse_true = Ellipse(\n",
-    "        xy=(0, 0),  # Center of the ellipse\n",
-    "        width=w_true,\n",
-    "        height=h_true,\n",
-    "        angle=np.rad2deg(theta_true),  # Rotation angle in degrees\n",
-    "        fill=False,  # You can set this to True if you want a filled ellipse\n",
-    "        color='b' ,lw=1.5,label=r'6d Phase Space, 10 km/s uncertainty' # Color of the ellipse\n",
-    "    )\n",
-    "\n",
-    "ellipse_2d = Ellipse(\n",
-    "        xy=(0, 0),  # Center of the ellipse\n",
-    "        width=w_true_2d,\n",
-    "        height=h_true_2d,\n",
-    "        angle=np.rad2deg(theta_true_2d),  # Rotation angle in degrees\n",
-    "        fill=False,  # You can set this to True if you want a filled ellipse\n",
-    "        color='grey' ,lw=1.5,label=r'On-sky Projection' # Color of the ellipse\n",
-    "    )\n",
-    "c1 = ax.add_patch(ellipse_true)\n",
-    "c2 = ax.add_patch(ellipse_2d)\n",
-    "#ax.set_xscale('log')\n",
-    "ax.set_title(r'$a = 1 \\ \\mathrm{kpc}, \\ M_{\\rm Subhalo} = 10^7 M_{\\odot}$',fontsize=18)\n",
-    "ax.set_xlim(-3,3)\n",
-    "\n",
-    "#ax.set_xlim(-1e6,1e6)\n",
-    "ax.set_ylim(-.4,.4)\n",
-    "ax.legend(fontsize=15,frameon=False,loc ='lower left')\n",
-    "ax.set_xlabel(r'$\\Delta M_{\\rm Subhalo} \\ \\mathrm{[10^6 ~M_\\odot]}$',fontsize=20)\n",
-    "ax.text(-.1,.3,'Long-Range Encounter',fontsize=18)\n",
-    "ax.set_ylabel(r'$\\Delta a \\ \\mathrm{[kpc]}$',fontsize=18)\n",
-    "#############ax.set_aspect('equal')\n",
-    "# plt.savefig('subhalo_constraint.pdf',bbox_inches='tight')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 797,
-   "id": "914b808c-aa71-4596-b9e6-89a679675c2a",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x432 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig, ax = plt.subplots(1,1)\n",
-    "fig.set_size_inches(6,6)\n",
-    "_=ellipse_true = Ellipse(\n",
-    "        xy=(0, 0),  # Center of the ellipse\n",
-    "        width=w_true,\n",
-    "        height=h_true,\n",
-    "        angle=np.rad2deg(theta_true),  # Rotation angle in degrees\n",
-    "        fill=False,  # You can set this to True if you want a filled ellipse\n",
-    "        color='b' ,lw=1.5,label=r'$M_{\\rm Subhalo} = 10^7 M_{\\odot}, \\ a = 0.5 \\ \\mathrm{kpc}$' # Color of the ellipse\n",
-    "    )\n",
-    "c1 = ax.add_patch(ellipse_true)\n",
-    "#ax.set_xscale('log')\n",
-    "ax.set_xlim(-1,1)\n",
-    "#ax.set_xlim(-1e6,1e6)\n",
-    "ax.set_ylim(-.1,.1)\n",
-    "ax.legend(fontsize=16)\n",
-    "ax.set_xlabel(r'$\\Delta M_{\\rm Subhalo} \\ \\mathrm{[10^6 M_\\odot]}$',fontsize=20)\n",
-    "ax.set_ylabel(r'$\\Delta a \\ \\mathrm{[kpc]}$',fontsize=18)\n",
-    "###plt.savefig('subhalo_constraint.pdf',bbox_inches='tight')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 739,
-   "id": "725b6158-ad28-4875-9896-641142074679",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(-0.1, 0.1)"
-      ]
-     },
-     "execution_count": 739,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x432 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig, ax = plt.subplots(1,1)\n",
-    "fig.set_size_inches(6,6)\n",
-    "_=ellipse_true = Ellipse(\n",
-    "        xy=(0, 0),  # Center of the ellipse\n",
-    "        width=w_true,\n",
-    "        height=h_true,\n",
-    "        angle=np.rad2deg(theta_true),  # Rotation angle in degrees\n",
-    "        fill=False,  # You can set this to True if you want a filled ellipse\n",
-    "        color='b' ,lw=1.5,label=None # Color of the ellipse\n",
-    "    )\n",
-    "c1 = ax.add_patch(ellipse_true)\n",
-    "#ax.set_xscale('log')\n",
-    "ax.set_xlim(-.1,.1)\n",
-    "ax.set_ylim(-.1,.1)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 740,
-   "id": "8baa258e-204c-41ab-a5d6-e1639fc8e5e0",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "1.2589254117941673"
-      ]
-     },
-     "execution_count": 740,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "10**(.1)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 654,
-   "id": "d02ed85e-8b82-4943-972a-55fafb3a00c8",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 576x432 with 2 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# Define the covariance matrix\n",
-    "covariance_matrix = np.array([[1.0, .1],\n",
-    "                              [.1, 2.0]])\n",
-    "\n",
-    "# Calculate the eigenvalues and eigenvectors of the covariance matrix\n",
-    "eigenvalues, eigenvectors = np.linalg.eig(covariance_matrix)\n",
-    "\n",
-    "# Calculate the standard deviations along the principal axes\n",
-    "sigma_x = np.sqrt(eigenvalues[0])\n",
-    "sigma_y = np.sqrt(eigenvalues[1])\n",
-    "\n",
-    "# Define the center of the Gaussian distribution\n",
-    "mean = np.array([2.0, 3.0])\n",
-    "\n",
-    "# Create a grid of points around the mean\n",
-    "x = np.linspace(mean[0] - 3 * sigma_x, mean[0] + 3 * sigma_x, 400)\n",
-    "y = np.linspace(mean[1] - 3 * sigma_y, mean[1] + 3 * sigma_y, 400)\n",
-    "X, Y = np.meshgrid(x, y)\n",
-    "\n",
-    "# Calculate the probability density function (PDF) for the Gaussian distribution\n",
-    "Z = np.exp(-0.5 * (((X - mean[0]) / sigma_x) ** 2 + ((Y - mean[1]) / sigma_y) ** 2)) / (2 * np.pi * sigma_x * sigma_y)\n",
-    "\n",
-    "# Plot the 1-sigma region (68% confidence interval)\n",
-    "plt.figure(figsize=(8, 6))\n",
-    "plt.contourf(X, Y, Z, levels=5, cmap='viridis')\n",
-    "plt.colorbar(label='PDF Value')\n",
-    "plt.xlabel('X')\n",
-    "plt.ylabel('Y')\n",
-    "plt.title('1-Sigma Region (68% Confidence Interval) for 2D Gaussian')\n",
-    "plt.axis('equal')\n",
-    "plt.grid(True)\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 647,
-   "id": "980bf165-cecb-4dcf-9853-219bc304b703",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array(5.80103, dtype=float64)"
-      ]
-     },
-     "execution_count": 647,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "jnp.log10(jnp.sqrt(4.0e11))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 600,
-   "id": "5047a88d-9197-4635-96f9-7af7d20ff046",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "2.6457513110645907"
-      ]
-     },
-     "execution_count": 600,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "np.sqrt(7)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1198,
-   "id": "cd4cc6ed-fb0d-4ba0-9506-0a2d46ec63bc",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "10.0"
-      ]
-     },
-     "execution_count": 1198,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "np.sqrt(1e-4)*1000"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 960,
-   "id": "93da2b70-850c-4b96-8309-be8a08ce1175",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "1.0000283885785286"
-      ]
-     },
-     "execution_count": 960,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "10**np.sqrt(1.52e-10)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 945,
-   "id": "56b4c7ed-b310-432d-9313-4815875f29db",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array([[6.97522627e-09, 2.31555412e+02],\n",
-       "       [2.31555412e+02, 8.13557014e+12]], dtype=float64)"
-      ]
-     },
-     "execution_count": 945,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "I = -jnp.array([ [second_gradient['a']['a'],second_gradient['a']['m'] ],\n",
-    "            [second_gradient['a']['m'], second_gradient['m']['m'] ] ])\n",
-    "jnp.linalg.inv(I)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 938,
-   "id": "d8458f4f-bdb0-4e60-aff4-733233fd3d37",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(Array(0.07399038, dtype=float64), Array(0.07399038, dtype=float64))"
-      ]
-     },
-     "execution_count": 938,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "second_gradient['a']['m'], second_gradient['m']['a']"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 133,
-   "id": "907cfc74-e382-4827-90bb-2ba422d11697",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'m': 10000000.0,\n",
-       " 'a': 1.0,\n",
-       " 'spline_eval_func': <function __main__.eval_spl_funcs(ts, spl_funcs)>,\n",
-       " 'splines': [<jax_cosmo.scipy.interpolate.InterpolatedUnivariateSpline at 0x7fceb64bccd0>,\n",
-       "  <jax_cosmo.scipy.interpolate.InterpolatedUnivariateSpline at 0x7fceb66009d0>,\n",
-       "  <jax_cosmo.scipy.interpolate.InterpolatedUnivariateSpline at 0x7fceb6611040>],\n",
-       " 't_min': 0.0,\n",
-       " 't_max': 50000.0,\n",
-       " 'm_ext': 1000000000000.0,\n",
-       " 'a_ext': 10.0}"
-      ]
-     },
-     "execution_count": 133,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "params"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 135,
-   "id": "843fe77b-34a6-402b-8a49-82ef147150b5",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "params = {'m': 10000000.0, 'a': 1.0}\n",
-    "pot = Isochrone(m=params['m'], a=params['a'],units=usys,)  # Create the potential with the given parameters\n",
-    "    \n",
-    "# Example Orbit:\n",
-    "t0 = 0\n",
-    "ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "    \n",
-    "### Compute the orbit with the provided potential\n",
-    "w_orb = leapfrog_run(w0, ts, pot.gradient)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 53,
-   "id": "376f51a8-1ddb-4e50-96de-a4ede0118889",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "params_else = {'spline_eval_func': eval_spl_funcs, 'splines': splines, 't_min': 0., 't_max': 50000.,\n",
-    "         'm_ext': 1.0e12, 'a_ext': 10.0}\n",
-    "\n",
-    "pot_with_params = Isochrone_centered(m=params['m'], a=params['a'],\n",
-    "                         spline_eval_func=params_else['spline_eval_func'],\n",
-    "                         splines=params_else['splines'],\n",
-    "                         t_min=params_else['t_min'],\n",
-    "                         t_max = params_else['t_max'],\n",
-    "                         m_ext = params_else['m_ext'],\n",
-    "                         a_ext = params_else['a_ext'],\n",
-    "                         units=usys,)  \n",
-    "    \n",
-    "t0 = 0\n",
-    "ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "### Compute the orbit with the provided potential\n",
-    "w_orb = leapfrog_run(w0, ts, pot_with_params.gradient)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 137,
-   "id": "1dc6c939-3eb6-4f8d-8e97-ec13c5b958dc",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import jax.scipy.stats as statsjax\n",
-    "#kde = statsjax.gaussian_kde(w_orb[-1,:],bw_method=.04)\n",
-    "#key = jax.random.PRNGKey(3)\n",
-    "#samps = kde.resample(key,[20]).T\n",
-    "#ll = kde.logpdf(lead_arm[:,:].T)\n",
-    "#plt.scatter(samps[:,0],samps[:,1],s=10)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 183,
-   "id": "ada96471-d231-46d5-997e-b47883eb098b",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array([  10. ,   10.5,   11. , ..., 1009. , 1009.5, 1010. ], dtype=float64)"
-      ]
-     },
-     "execution_count": 183,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "ts"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 194,
-   "id": "547d9446-240d-4431-a909-801c434c8697",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from jax_cosmo.scipy.interpolate import InterpolatedUnivariateSpline\n",
-    "def get_spl_funcs(ts,ws):\n",
-    "    return [InterpolatedUnivariateSpline(ts,ws_jax[:,i],k=3) for i in range(3)]\n",
-    "\n",
-    "def eval_spl_funcs(ts, spl_funcs):\n",
-    "    return jnp.array([spl_funcs[i](ts) for i in range(3)])\n",
-    "#spl_x = InterpolatedUnivariateSpline(ts,ws_jax[:,0],k=3)\n",
-    "#spl_y = InterpolatedUnivariateSpline(ts,ws_jax[:,1],k=3)\n",
-    "\n",
-    "splines = get_spl_funcs(ts, ws_jax)\n",
-    "spline_evals = eval_spl_funcs(ts[3], splines)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 50,
-   "id": "910c8845-c845-4979-aeb7-786a6c90d141",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "@jax.jit\n",
-    "def gauss_pt(x_eval, x_mean):\n",
-    "    return -0.5*jnp.sum(jnp.square(x_eval - x_mean))\n",
-    "#gauss_pt(w_orb[-1,:],w_orb[-1,:])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 54,
-   "id": "d3ae8521-c99b-40ae-926d-51d9fb519eb0",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def compute_orbit_and_gradients(params,w0,dt,n_steps,units):\n",
-    "    ####pot = Isochrone(m=params['m'], a=params['a'],units=units,)  # Create the potential with the given parameters\n",
-    "    \n",
-    "    # Example Orbit:\n",
-    "    #w0 = jnp.array([10, 0, 0, 0, .204, 0])\n",
-    "    ###t0 = 0\n",
-    "    #dt = 0.1\n",
-    "    #n_steps = 10000\n",
-    "    ##ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "    \n",
-    "    ### Compute the orbit with the provided potential\n",
-    "    ####################ws_jax = leapfrog_run(w0, ts, pot.gradient)\n",
-    "    \n",
-    "    # Compute the gradient of the final position with respect to the potential parameters\n",
-    "    def gradient_fn(params):\n",
-    "        params_global = {'m': 1.0e12, 'a': 10.}\n",
-    "        pot = Isochrone(m=params_global['m'], a=params_global['a'],units=usys,)  \n",
-    "        t0 = 0\n",
-    "        dt = 0.5\n",
-    "        n_steps = 2_000\n",
-    "        w0 = jnp.array([50., 0., 0, (0*u.km/u.s).to(u.kpc/u.Myr).value, (150*u.km/u.s).to(u.kpc/u.Myr).value, (0*u.km/u.s).to(u.kpc/u.Myr).value])\n",
-    "\n",
-    "\n",
-    "        w0_subhalo =  jnp.array([45., 0., 0, (0*u.km/u.s).to(u.kpc/u.Myr).value, (250*u.km/u.s).to(u.kpc/u.Myr).value, (0*u.km/u.s).to(u.kpc/u.Myr).value])\n",
-    "\n",
-    "\n",
-    "        ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "        ### Compute the orbit with the provided potential\n",
-    "        ws_jax = leapfrog_run(w0_subhalo, ts, pot.gradient)\n",
-    "\n",
-    "        splines = get_spl_funcs(ts, ws_jax)\n",
-    "        ######################spline_evals = eval_spl_funcs(ts[3], splines)\n",
-    "        ################\n",
-    "        \n",
-    "        \n",
-    "        \n",
-    "        \n",
-    "        #splines = get_spl_funcs(ts, ws_jax)\n",
-    "        #spline_evals = eval_spl_funcs(ts[3], splines)\n",
-    "        params_else = {'spline_eval_func': eval_spl_funcs, 'splines': splines, 't_min': 0., 't_max': 50000.,\n",
-    "         'm_ext': 1.0e12, 'a_ext': 10.0}\n",
-    "\n",
-    "        pot_with_params = Isochrone_centered(m=params['m'], a=params['a'],\n",
-    "                         spline_eval_func=params_else['spline_eval_func'],\n",
-    "                         splines=params_else['splines'],\n",
-    "                         t_min=params_else['t_min'],\n",
-    "                         t_max = params_else['t_max'],\n",
-    "                         m_ext = params_else['m_ext'],\n",
-    "                         a_ext = params_else['a_ext'],\n",
-    "                         units=usys,)  \n",
-    "        ws_with_params = leapfrog_run(w0, ts, pot_with_params.gradient)\n",
-    "        final_position = ws_with_params[-1, :]  # Extract final position\n",
-    "        return gauss_pt(final_position,w_orb[-1,:])\n",
-    "        #return final_position\n",
-    "    \n",
-    "    # Compute the gradient using JAX's autodiff\n",
-    "    gradient = jax.jacfwd(gradient_fn)(params)\n",
-    "    \n",
-    "    return gradient"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 55,
-   "id": "e83d25a4-7f91-4d90-8353-8526e7b40449",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "gg = compute_orbit_and_gradients(params,w0,dt,n_steps,usys)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 56,
-   "id": "f90f5030-0249-4385-a1f8-ef04fb55de62",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'a': Array(-1.42737306e-12, dtype=float64),\n",
-       " 'm': Array(5.40207223e-24, dtype=float64)}"
-      ]
-     },
-     "execution_count": 56,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "gg"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 152,
-   "id": "9daddba7-e95a-4845-beb6-d1fe41c33c1b",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'m': 10000000.0, 'a': 1.0}"
-      ]
-     },
-     "execution_count": 152,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "params"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "4b6eba18-87d1-4afb-b9f0-781d76e9ad0f",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "84602c70-c486-4391-9e5b-41766f9fc5aa",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "0f778bd9-c565-4427-b4e7-06e49b571725",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 399,
-   "id": "04c08e2d-23df-4f74-93a2-81b71b2fb113",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "params = {'m': 5e11, 'a': 10.}\n",
-    "pot = Hernquist(m=params['m'], a=params['a'],units=usys,)  \n",
-    "t0 = 0\n",
-    "dt = 0.5\n",
-    "n_steps = 10_000\n",
-    "ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "### Compute the orbit with the provided potential\n",
-    "##ws_jax = leapfrog_run(w0, ts, pot.gradient)\n",
-    "\n",
-    "M_sat = 1.0e4 # TODO: mass loss rate\n",
-    "pos_disp = .001\n",
-    "vel_disp = (20*u.km/u.s).to(u.kpc/u.Myr).value#.05\n",
-    "\n",
-    "pos_close_arr, pos_far_arr, vel_close_arr, vel_far_arr = pot.gen_stream_ics(ts, w0, Msat, pos_disp, vel_disp)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 333,
-   "id": "b69344f7-9f7f-473b-a917-1fbd614d941d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#release_time_arr = get_stripping_time_arr(ts)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 308,
-   "id": "808ed1f4-eb0a-44e3-8e4d-b7be12395a98",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array([0.000e+00, 1.000e+00, 2.000e+00, ..., 9.998e+03, 9.999e+03,\n",
-       "       1.000e+04], dtype=float64)"
-      ]
-     },
-     "execution_count": 308,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "ts = jnp.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "ts"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 309,
-   "id": "64ed11fc-7055-46b1-8e93-f9537ff4ca6a",
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "KeyboardInterrupt",
-     "evalue": "",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_21408/1523047885.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m# Example usage:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;31m#ts = jnp.array([1, 2, 3, 4, 5])\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_stripping_time_arr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_21408/1523047885.py\u001b[0m in \u001b[0;36mget_stripping_time_arr\u001b[0;34m(ts)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget_stripping_time_arr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0mt_release_arr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mt_release_arr\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m# Example usage:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_21408/1523047885.py\u001b[0m in \u001b[0;36m<listcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget_stripping_time_arr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0mt_release_arr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mt_release_arr\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m# Example usage:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/array.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, idx)\u001b[0m\n\u001b[1;32m    341\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0mlax_numpy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_rewriting_take\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0midx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    342\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 343\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mlax_numpy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_rewriting_take\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0midx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    344\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    345\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m__iter__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/numpy/lax_numpy.py\u001b[0m in \u001b[0;36m_rewriting_take\u001b[0;34m(arr, idx, indices_are_sorted, unique_indices, mode, fill_value)\u001b[0m\n\u001b[1;32m   3890\u001b[0m         \u001b[0;31m# Use dynamic rather than static slice here to avoid slow repeated execution:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3891\u001b[0m         \u001b[0;31m# See https://github.com/google/jax/issues/12198\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3892\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdynamic_slice_in_dim\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstart\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_max\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstop\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mstart\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   3893\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3894\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mslice_in_dim\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstart\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstop\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstep\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/lax/slicing.py\u001b[0m in \u001b[0;36mdynamic_slice_in_dim\u001b[0;34m(operand, start_index, slice_size, axis)\u001b[0m\n\u001b[1;32m    696\u001b[0m   \u001b[0mstart_indices\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mstart_index\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    697\u001b[0m   \u001b[0mslice_sizes\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_canonicalize_dimension\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mslice_size\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 698\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0mdynamic_slice\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moperand\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstart_indices\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mslice_sizes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    699\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    700\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/lax/slicing.py\u001b[0m in \u001b[0;36mdynamic_slice\u001b[0;34m(operand, start_indices, slice_sizes)\u001b[0m\n\u001b[1;32m    108\u001b[0m     \u001b[0mdynamic_sizes\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    109\u001b[0m     \u001b[0mstatic_sizes\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanonicalize_shape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mslice_sizes\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 110\u001b[0;31m   return dynamic_slice_p.bind(operand, *start_indices, *dynamic_sizes,\n\u001b[0m\u001b[1;32m    111\u001b[0m                               slice_sizes=tuple(static_sizes))\n\u001b[1;32m    112\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/core.py\u001b[0m in \u001b[0;36mbind\u001b[0;34m(self, *args, **params)\u001b[0m\n\u001b[1;32m    358\u001b[0m     assert (not config.jax_enable_checks or\n\u001b[1;32m    359\u001b[0m             all(isinstance(arg, Tracer) or valid_jaxtype(arg) for arg in args)), args\n\u001b[0;32m--> 360\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbind_with_trace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfind_top_trace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    361\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    362\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mbind_with_trace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/core.py\u001b[0m in \u001b[0;36mbind_with_trace\u001b[0;34m(self, trace, args, params)\u001b[0m\n\u001b[1;32m    361\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    362\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mbind_with_trace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 363\u001b[0;31m     \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_primitive\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    364\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfull_lower\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmultiple_results\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mfull_lower\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    365\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/core.py\u001b[0m in \u001b[0;36mprocess_primitive\u001b[0;34m(self, primitive, tracers, params)\u001b[0m\n\u001b[1;32m    815\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    816\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess_primitive\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 817\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimpl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    818\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    819\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/dispatch.py\u001b[0m in \u001b[0;36mapply_primitive\u001b[0;34m(prim, *args, **params)\u001b[0m\n\u001b[1;32m    115\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    116\u001b[0m   \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 117\u001b[0;31m     compiled_fun = xla_primitive_callable(prim, *unsafe_map(arg_spec, args),\n\u001b[0m\u001b[1;32m    118\u001b[0m                                           **params)\n\u001b[1;32m    119\u001b[0m   \u001b[0;32mexcept\u001b[0m \u001b[0mpxla\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mDeviceAssignmentMismatchError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    251\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    252\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 253\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    254\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    255\u001b[0m     \u001b[0mwrapper\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcache_clear\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcache_clear\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    244\u001b[0m     \u001b[0;34m@\u001b[0m\u001b[0mfunctools\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlru_cache\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmax_size\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    245\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 246\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    247\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    248\u001b[0m     \u001b[0;34m@\u001b[0m\u001b[0mfunctools\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwraps\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/dispatch.py\u001b[0m in \u001b[0;36mxla_primitive_callable\u001b[0;34m(prim, *arg_specs, **params)\u001b[0m\n\u001b[1;32m    206\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    207\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 208\u001b[0;31m   compiled = _xla_callable_uncached(lu.wrap_init(prim_fun), prim.name,\n\u001b[0m\u001b[1;32m    209\u001b[0m                                     donated_invars, False, *arg_specs)\n\u001b[1;32m    210\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mprim\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmultiple_results\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/dispatch.py\u001b[0m in \u001b[0;36m_xla_callable_uncached\u001b[0;34m(fun, name, donated_invars, keep_unused, *arg_specs)\u001b[0m\n\u001b[1;32m    252\u001b[0m                                  *arg_specs, lowering_platform=None)\n\u001b[1;32m    253\u001b[0m   \u001b[0mallow_prop\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcomputation\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcompile_args\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'global_out_avals'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 254\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0mcomputation\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcompile\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_allow_propagation_to_outputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mallow_prop\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munsafe_call\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    255\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    256\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/interpreters/pxla.py\u001b[0m in \u001b[0;36mcompile\u001b[0;34m(self, _allow_propagation_to_outputs, _allow_compile_replicated)\u001b[0m\n\u001b[1;32m   2814\u001b[0m             **self.compile_args)\n\u001b[1;32m   2815\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2816\u001b[0;31m         self._executable = UnloadedMeshExecutable.from_hlo(\n\u001b[0m\u001b[1;32m   2817\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_name\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2818\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_hlo\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/interpreters/pxla.py\u001b[0m in \u001b[0;36mfrom_hlo\u001b[0;34m(name, computation, mesh, global_in_avals, global_out_avals, in_shardings, out_shardings, spmd_lowering, tuple_args, auto_spmd_lowering, _allow_propagation_to_outputs, _allow_compile_replicated, unordered_effects, ordered_effects, host_callbacks, keepalive, kept_var_idx, backend, device_assignment, committed, pmap_nreps)\u001b[0m\n\u001b[1;32m   3026\u001b[0m                                      \u001b[0;34m\"in {elapsed_time} sec\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3027\u001b[0m                                      event=dispatch.BACKEND_COMPILE_EVENT):\n\u001b[0;32m-> 3028\u001b[0;31m         xla_executable = dispatch.compile_or_get_cached(\n\u001b[0m\u001b[1;32m   3029\u001b[0m             backend, computation, compile_options, host_callbacks)\n\u001b[1;32m   3030\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/dispatch.py\u001b[0m in \u001b[0;36mcompile_or_get_cached\u001b[0;34m(backend, computation, compile_options, host_callbacks)\u001b[0m\n\u001b[1;32m    524\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0mcompiled\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    525\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 526\u001b[0;31m   return backend_compile(backend, serialized_computation, compile_options,\n\u001b[0m\u001b[1;32m    527\u001b[0m                          host_callbacks)\n\u001b[1;32m    528\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/profiler.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    312\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    313\u001b[0m     \u001b[0;32mwith\u001b[0m \u001b[0mTraceAnnotation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdecorator_kwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 314\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    315\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    316\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/dispatch.py\u001b[0m in \u001b[0;36mbackend_compile\u001b[0;34m(backend, built_c, options, host_callbacks)\u001b[0m\n\u001b[1;32m    469\u001b[0m   \u001b[0;31m# TODO(sharadmv): remove this fallback when all backends allow `compile`\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    470\u001b[0m   \u001b[0;31m# to take in `host_callbacks`\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 471\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0mbackend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcompile\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbuilt_c\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcompile_options\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    472\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    473\u001b[0m \u001b[0m_ir_dump_counter\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mitertools\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcount\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
-     ]
-    }
-   ],
-   "source": [
-    "def get_stripping_time_arr(ts):\n",
-    "    t_release_arr = [ts[i:] for i in range(len(ts))]\n",
-    "    return t_release_arr\n",
-    "\n",
-    "# Example usage:\n",
-    "#ts = jnp.array([1, 2, 3, 4, 5])\n",
-    "result = get_stripping_time_arr(ts)\n",
-    "print(result)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 319,
-   "id": "94c3c17b-1eca-4441-a5a9-c2f247f09a9a",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array([2, 3, 4, 5], dtype=int64)"
-      ]
-     },
-     "execution_count": 319,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "jax.lax.slice(tt,(1,),(len(tt),))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 312,
-   "id": "d056dfcc-6321-4f84-b8ef-7b3e6d8561de",
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "TypeError",
-     "evalue": "iteration over a 0-d array",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_21408/1263285150.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     15\u001b[0m \u001b[0;31m# Example usage:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     16\u001b[0m \u001b[0mtt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 17\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_stripping_time_arr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     18\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_21408/1263285150.py\u001b[0m in \u001b[0;36mget_stripping_time_arr\u001b[0;34m(ts)\u001b[0m\n\u001b[1;32m     10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m     \u001b[0;31m# Use vmap to apply the slicing function to each row\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m     \u001b[0mt_release_arr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mslice_row\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatched_ts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     14\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mt_release_arr\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "    \u001b[0;31m[... skipping hidden 3 frame]\u001b[0m\n",
-      "\u001b[0;32m/var/folders/rq/9c89gb15479bjnxrpnmdf_p40000gn/T/ipykernel_21408/1263285150.py\u001b[0m in \u001b[0;36mslice_row\u001b[0;34m(i, arr)\u001b[0m\n\u001b[1;32m      7\u001b[0m     \u001b[0;31m# Create a function to slice each row\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mslice_row\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0marr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mslice\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marr\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m     \u001b[0;31m# Use vmap to apply the slicing function to each row\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "    \u001b[0;31m[... skipping hidden 2 frame]\u001b[0m\n",
-      "\u001b[0;32m~/opt/anaconda3/envs/MachineLearnGravPotential/lib/python3.8/site-packages/jax/_src/lax/lax.py\u001b[0m in \u001b[0;36m_iter\u001b[0;34m(tracer)\u001b[0m\n\u001b[1;32m   1457\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_iter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtracer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1458\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0mtracer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1459\u001b[0;31m     \u001b[0;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"iteration over a 0-d array\"\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# same as numpy error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1460\u001b[0m   \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1461\u001b[0m     \u001b[0mn\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtracer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mTypeError\u001b[0m: iteration over a 0-d array"
-     ]
-    }
-   ],
-   "source": [
-    "from jax import vmap\n",
-    "\n",
-    "def get_stripping_time_arr(ts):\n",
-    "    # Create a batched version of ts\n",
-    "    batched_ts = jnp.stack([ts] * len(ts))\n",
-    "    \n",
-    "    # Create a function to slice each row\n",
-    "    def slice_row(i, arr):\n",
-    "        return jax.lax.slice(arr,i,-1)\n",
-    "\n",
-    "    # Use vmap to apply the slicing function to each row\n",
-    "    t_release_arr = vmap(slice_row)(jnp.arange(len(ts)), batched_ts)\n",
-    "    \n",
-    "    return t_release_arr\n",
-    "# Example usage:\n",
-    "tt = jnp.array([1, 2, 3, 4, 5])\n",
-    "result = get_stripping_time_arr(tt)\n",
-    "print(result)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 376,
-   "id": "cfb93bbb-5716-48f3-8015-e4558841b5b7",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "lead_arm, trail_arm = pot.gen_stream(ts, w0, Msat, pos_disp, vel_disp)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "12cfd522-44f0-4615-ae5a-7e1014abcaf9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "plt.scatter(lead_arm[:,-1,0],lead_arm[:,-1,1],s=0.5,rasterized=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 404,
-   "id": "4a3d40bb-5b76-49b2-81fb-35cf387792a6",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/latex": [
-       "$0.020454243 \\; \\mathrm{\\frac{kpc}{Myr}}$"
-      ],
-      "text/plain": [
-       "<Quantity 0.02045424 kpc / Myr>"
-      ]
-     },
-     "execution_count": 404,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "(50*u.km/u.s).to(u.kpc/u.Myr).value"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 405,
-   "id": "d15ca259-fd43-42fc-9fac-e66b69658915",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "lead_arm, trail_arm = pot.gen_stream_final(ts, w0, Msat, pos_disp, (50*u.km/u.s).to(u.kpc/u.Myr).value)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 406,
-   "id": "b3ed7351-88a1-4317-baca-10ed57d6c0ae",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7fa8ef2874f0>"
-      ]
-     },
-     "execution_count": 406,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.scatter(lead_arm[:,0],lead_arm[:,1],s=0.5,rasterized=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 378,
-   "id": "ec0a9dcf-2da0-459f-988d-d3fe404cde57",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7fa8e95bf4c0>"
-      ]
-     },
-     "execution_count": 378,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.scatter(lead_arm[:,-1,0],lead_arm[:,-1,1],s=0.5,rasterized=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 198,
-   "id": "322419da-c292-42d5-b79d-67eb5f16e71b",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "15\n",
-      "[ 1  3  6 10 15]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Define a step function that adds an input to the carry state\n",
-    "def step(carry, x):\n",
-    "    return carry + x, carry + x\n",
-    "\n",
-    "# Sequence of input values\n",
-    "inputs = jnp.array([1, 2, 3, 4, 5])\n",
-    "\n",
-    "# Initial carry state\n",
-    "init_carry = jnp.array(0)\n",
-    "\n",
-    "# Use jax.lax.scan to iterate over the inputs\n",
-    "final_carry, results = jax.lax.scan(step, init_carry, inputs)\n",
-    "\n",
-    "print(final_carry)  # Output: 15 (sum of all input values)\n",
-    "print(results)      # Output: [1, 3, 6, 10, 15] (cumulative sums)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "560e8dc1-b95e-4487-9729-2e4b075feb0f",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 115,
-   "id": "5c1f226a-8f37-45f4-863b-b084cdcb0aec",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array([ 0.23298915, -1.04627168,  1.35807149], dtype=float64)"
-      ]
-     },
-     "execution_count": 115,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "key = jax.random.PRNGKey(30302)\n",
-    "jax.random.normal(key,shape=(3,))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 172,
-   "id": "d6656cfa-bcf4-4538-a491-505795114d4e",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(Array([24.72606542,  9.89042617,  9.89042617], dtype=float64),\n",
-       " Array([25.27393458, 10.10957383, 10.10957383], dtype=float64))"
-      ]
-     },
-     "execution_count": 172,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "params = {'m': 1e10, 'a': 10.}\n",
-    "pot = Hernquist(m=params['m'], a=params['a'],units=usys,)  \n",
-    "\n",
-    "x = jnp.array([25,10,10.])\n",
-    "v = jnp.array([.1,.05,.04])\n",
-    "Msat = 1.0e4\n",
-    "pos_disp = .01\n",
-    "vel_disp = .005\n",
-    "#pot.tidalr_mw(x,v,Msat)\n",
-    "pot.lagrange_pts(x, v, Msat,)\n",
-    "#pot.tidalr_mw(x,v,Msat)\n",
-    "#pot.d2phidr2_mw(x)\n",
-    "#pot.omega(x, v)\n",
-    "#pot.omega(x, v) ** 2 - pot.d2phidr2_mw(x)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 165,
-   "id": "5d6dd512-ebd7-4d65-8a02-d8746dff8fc1",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array(nan, dtype=float64)"
-      ]
-     },
-     "execution_count": 165,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "(pot._G * Msat / (pot.omega(x, v) ** 2 - pot.d2phidr2_mw(x))) ** (1.0 / 3.0)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 167,
-   "id": "d23be7dc-b15a-4ee6-8a50-832849250008",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array(-0.03117464, dtype=float64)"
-      ]
-     },
-     "execution_count": 167,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "pot._G * Msat / (pot.omega(x, v) ** 2 - pot.d2phidr2_mw(x))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 168,
-   "id": "9271c65f-d971-4380-9c50-a3e48f443c9e",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(0.6299605249474367+1.0911236359717214j)"
-      ]
-     },
-     "execution_count": 168,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "(-2)**(1/3)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 60,
-   "id": "a358f1da-0083-4bcd-ab17-b18684bd39c7",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "a_arr = jnp.linspace(10,11,30)\n",
-    "w0 = jnp.array([25., 0., 0, 0.01, .104, -0.004])\n",
-    "dt = 0.1\n",
-    "t0 = 0.\n",
-    "n_steps = 30_000\n",
-    "Delta_a = jnp.diff(a_arr)[0]\n",
-    "predicted_wf = jnp.zeros((len(a_arr),6))\n",
-    "true_wf = jnp.zeros((len(a_arr)-1,6))\n",
-    "for i in range(len(a_arr)):\n",
-    "    params = {'m': 5e11, 'a': a_arr[i]}\n",
-    "    result_ws, param_gradients = compute_orbit_and_gradients(params,w0,dt,n_steps,usys)\n",
-    "    pred = result_ws[-1] + param_gradients['a']*Delta_a \n",
-    "    predicted_wf = predicted_wf.at[i,:].set( pred )\n",
-    "    if i > 0:\n",
-    "        true_wf = true_wf.at[i-1,:].set(result_ws[-1])\n",
-    "    \n",
-    "    \n",
-    "\n",
-    "    \n",
-    "\n",
-    "    \n",
-    "    "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 61,
-   "id": "527867ec-3518-47ca-bd86-e724ff732ba3",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 792x504 with 7 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig, ax = plt.subplots(2,3)\n",
-    "ax_flat = ax.flatten()\n",
-    "fig.set_size_inches(11,7)\n",
-    "for dim in range(6):\n",
-    "    xx = np.linspace(true_wf[:,dim].min(),true_wf[:,dim].max(),50)\n",
-    "    ax_flat[dim].plot(xx,xx,color='k',ls='--',zorder=0)\n",
-    "\n",
-    "    ax_flat[dim].scatter(true_wf[:,dim], predicted_wf[:-1,dim],c=a_arr[1:],s=20,cmap=cmr.guppy)\n",
-    "    ax_flat[dim].set_aspect('equal')\n",
-    "fig.subplots_adjust(hspace=0.1,wspace=.35)\n",
-    "ax_flat[0].set_xlabel(r'True $x$ [kpc]',fontsize=15)\n",
-    "ax_flat[0].set_ylabel(r'Predicted $x$',fontsize=15)\n",
-    "\n",
-    "ax_flat[1].set_xlabel(r'True $y$ [kpc]',fontsize=15)\n",
-    "ax_flat[1].set_ylabel(r'Predicted $y$',fontsize=15)\n",
-    "\n",
-    "ax_flat[2].set_xlabel(r'True $z$ [kpc]',fontsize=15)\n",
-    "ax_flat[2].set_ylabel(r'Predicted $z$',fontsize=15)\n",
-    "\n",
-    "ax_flat[3].set_xlabel(r'True $v_x$ [kpc/Myr]',fontsize=15)\n",
-    "ax_flat[3].set_ylabel(r'Predicted $v_x$',fontsize=15)\n",
-    "\n",
-    "ax_flat[4].set_xlabel(r'True $v_y$ [kpc/Myr]',fontsize=15)\n",
-    "ax_flat[4].set_ylabel(r'Predicted $v_y$',fontsize=15)\n",
-    "\n",
-    "ax_flat[5].set_xlabel(r'True $v_z$ [kpc/Myr]',fontsize=15)\n",
-    "ax_flat[5].set_ylabel(r'Predicted $v_z$',fontsize=15)\n",
-    "\n",
-    "# Add a colorbar on the right of the subplots\n",
-    "cax = fig.add_axes([0.91, 0.14, 0.02, 0.73])  # Adjust the position and size of the colorbar\n",
-    "cbar = plt.colorbar(ax_flat[dim].scatter(true_wf[:,dim], predicted_wf[:-1,dim],c=a_arr[1:],s=20,cmap=cmr.guppy), cax=cax, orientation='vertical')\n",
-    "cbar.set_label('$\\Phi$ Scale Radius [kpc]',fontsize=20)  # Set the label for the colorbar\n",
-    "##plt.savefig('TaylorExpansion_PotentialFinalSnap.pdf',bbox_inches='tight')\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 42,
-   "id": "a0034bd4-1132-4f61-b79e-21958cd81027",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "w0 = jnp.array([20, 0, 0, -.01, .104, -.03])\n",
-    "t0 = 0\n",
-    "dt = 0.1\n",
-    "n_steps = 20000\n",
-    "ts = np.arange(t0, t0 + dt * n_steps + dt/10., dt)\n",
-    "params = {'m': 5e11, 'a': 10.}\n",
-    "pot = Hernquist(m=params['m'], a=params['a'],units=usys,)\n",
-    "\n",
-    "    \n",
-    "\n",
-    "pos_disp = 0.01 #kpc   \n",
-    "vel_dis = (20*u.km/u.s).to(u.kpc/u.Myr).value\n",
-    "    \n",
-    "\n",
-    "key = random.PRNGKey(0)  # Initialize a random key\n",
-    "num_orbits = 5000\n",
-    "ndim = 3\n",
-    "\n",
-    "pos_samps = np.random.normal(loc=0,scale=pos_disp,size=(num_orbits,3))\n",
-    "vel_samps = np.random.normal(loc=0,scale=vel_dis,size=(num_orbits,3))\n",
-    "\n",
-    "\n",
-    "pos0 = pos_samps + w0[:3]\n",
-    "vel0 = vel_samps + w0[3:]\n",
-    "w0 = jnp.hstack([pos0,vel0])\n",
-    "\n",
-    "orbs = []\n",
-    "final_snap = jnp.zeros((num_orbits,6))\n",
-    "for i in range(len(w0)):\n",
-    "    wcurr = w0[i]\n",
-    "    ws_jax = leapfrog_run(wcurr, ts, pot.gradient)\n",
-    "    orbs.append(ws_jax)\n",
-    "    \n",
-    "    final_snap = final_snap.at[i].set(ws_jax[-1,:])\n",
-    "    \n",
-    "    \n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 43,
-   "id": "fff9873f-7408-464a-be32-3da8d8b8541b",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7fb2096bd8e0>"
-      ]
-     },
-     "execution_count": 43,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAN8AAACiCAYAAADBRRgzAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAA/ZUlEQVR4nO2deVgUZ77vPwWIoCirCIKIKCLiyqZG42QcYlCROE7OLJlEnckejcYkk9yTc+ZqknvmXnMSd806mUwmOieTxKMIaJRjMsYYldUFQUEFAUEEREXBtrvr/lFdRXXTDd3QQKv9fR4e6FrefqmqX/327yuIoogTTjjR83Dp7Qk44cS9CqfwOeFEL8GtJ77kySefFENDQy3uLysrIzw8vN0xOjrGHmP05DGONBdrjnHOpfPHqPe/8cYbfxZF8UkARFHs9p+VK1eK7aGj/dYcY48xevIYR5qLNcc459L5Y9T7gVWiQS7uGLPzgQce6NJ+ex5jDZzz7fwxPfU9vT5fsQc036JFi8SVK1eK3377rdk3g6XtjgrnfLsXd+t8v/32WxH4VDTIhSDakGoQBMEHiDD8JIii+Jph+yNAIxAhiuKHpuetWrVKXLVqlU1vCyecuBshCMIboiiuAtujnb8E4kVR/Mow0NMGwUMUxSzDtiQ7ztUJJ+5a2CR8oih+qNJsEcA5IMHwG8PvWPtNz4n2oNHqyMyvRKPV9ch5TtgXnUo1CIIQATSIopglCMK/mOz2Nz2+rKwM2ex84IEH7BYkuNeRdaKaxzZ8z+fL7mfOJMupHHucp9HqyDpRTdK4YNzdXDs75XsS3333Hd999538MVzZIXYigAK8qvp7NZBk+DsJWG16vDXhWidsx63bWjEjr0K8dVvb7edl5FWIvou3iRl5FbZO0wkV6EqqQRCER0RRfNvwdyyQDfgYdkcA+2x+Ndyj6Kr55+7mypxJoTZros6clzQumM+X3U/SuGBbp+mEBdgkfIZgympBEHIFQcgF/EQp+BJh2OcjGgIvTnQM2fzLOlHd21PpEJ0VdCcsw9aAS5YoiiNEUYwz/GQZtr9t2Pe2ufNkn09l9zoBzIgOZMXcMcyIDuyW8Z2BFceC4fkPlz/3SIVLeHg4q1atcgZaTHCgqJa1Gac4UFTbLePfSZr1XoDh+S+TP98x5WV3I7rbj5LHnxEd2Ksa0KmBzcMpfL2InvKj9p+s6VUN6NTA5tEjwnc3+ny9/Ta35vvlhx7o1UhlZzV8b19je8PU53OIlqI7EZbyXp3NvXUE03Gtybu1N5fumqc9cTfmFlHl+ZzC10lYenhtfWCsFQLTcbsqPHfCg30nvCBshVP4OoGOHgR5//XmWzY9MNZq0K4+iPYez4nOgZ5upr0bfL6Oggby/gNFtW2CKO35Lpb8IXsGKTRaHat3nOS36w8o4zmT5j0Pp8/XCdy6rRV3ZpeLO7PLjTSFWntcb74lvvllgXi9+VYbrbIzu1z0XrRV3Jld3u53tKeZ1GPYqrVk7frmlwVOTdfL4E6kkegpaLQ60nIusP1IGWk5F5Rq/sWbf8DN1cVIU6i10/6TNbybXsj+kzUWtJagjG9OC2adqOa36w+wesdJNFqdBc0ktPleayBr19fmj3VqOkeC6NR8RtiZXS4OXLhVHPD4VnHgwq2KNpP9ObUGVGsgSTNtE3dmlxtpQVE01mLt+XhvfllgMQiiHsPpr925wBlwMYZaWL4+fF4cuHCr+K9bc8SVX+QZCUNGXoXovWib6L1oa5uoozrQ0l4ksT3z0ilUdz/oakuRIAj7TLZdEQRhnyAIr5o7x9EDLmvTi3g7rZC16UW4ubogCDBl1CBeXzBeCYZotDq0Oj0fPj2ZF+dEK8XQ5gIt7SWVZXMSIC3nAm99dYzfrDvAn7Yf73Qy+W5LRt+tsEvABdhn8jmpveMdUfOZC5bUX29uE1iRTcqVX+SJPou3iQs3fm91vs3Svlu3teLKL/IU83bA41tF70XbLJqdHWnEOyFn54QEVJrPXozVPoIgRIiieK7jQ3sXGq2OPQVV5J2rZ11GES/Pi2FFSjRxI/w5WFzL4s0/sGLuGJInhgCQnlvB4s2HEIEFiWHsOHqB+YlhiuZTazL1d2SdqKZFo+V3Ww6xYm40ry8YrwQ7sk5UszajCL0ICSP8eHJmJF6efZg5Noi4Ef4W0w6WaB+cja53JuwV7fQDGgRB+MBO43ULmlo0PPX+jzy24SBrM4qYFx/KmvRCnvvoML9ee4Ds0jqWzR7NmvRCJZJ4vPwKIjA50p/Vj8UyPzGMtNwKpQ3InMknC8vx8isArMssMopMJo0L5m8vTGd+QijZZxs4e6mJ1PgwvDzcFeFSj9mRcDlzdncm7KL5RAOjmSAIjQaaia/U+x2BQKmhqYUH39rHmerrjBzcn7O1N5gXF8qoYG/eTT8FwIbdxXz0zFReSolhSmQAaTkXGBPqzfyEUHblVPLyX7NJy60iNS5E0Xx7CqpYuOkgny2dTmp8GNDaJLskOYrYCIlPSvYbZRKi1PgwZo4NYlRwEStSoo3maqrpzGnX7oCTJKl7YIlAqcvCJwjC00COKIp5lo6Rm2l7Cxqtjl+u/Sdnqq8DUHrpBgBfHioncshANj+RSHpOBen5F9mZfYHMgouU1lxnR/YFBEHgk+em4iK4sCP7AgC7cqv4bVEtSeOCyTtXDwhodXoy8yuZER3I2vQi1qQXEjfCXxFIkLSZqVDFjfBvUw2j1en5dMm0TpmRXRGgzrKhOdE+1ArnjTfeKJO3dybamQTEy2S5wD8M22Xy3K8sndsbkE3NIyX1AAzwEJR9e45Xs3HPaf78bQmZBRcRgF15VSRE+LMz5wKpcUP58OkpHC+/QlrOBeZMHALA00mRHC25THpuBesyipg9IZiNu4v4zdoDvJNWyNqMU7yUEmMkPKZCJc9LXfIFGCX0odX8tDai2V4CvqMxnL5jz8Jm4RMlrhZfWchEUWwURTFPFMWvRAN9vCPhnbRCth+9QLCPBwDXW0S8PSWN4NNP+p1T2sCy2aP5+NkpPBwfyuGSOuJH+JOWW8Gu3ArWpBeRMCKAlPihuLoIFJQ38G56EfnnG5gXH0p6/kVyzl1BD0QGD2TZ7NHEDPVW5iDXVqqFasnHR9l+9AKp8WFGD7taANSCtKegikfXH2BPQZXR/2cqUO0JUEeVMU7fsWdx1xdWjwoeCEB1Y4uy7dfTIkgY6UfjTR3hg/ohAtEhA/HydGdXbiWjggdwpKQevQg7sytJjPTnx5I6Sqqv8XLKGLJL6kkc4Udp9TV25RoLQ2ZeJWszivj9ez+yp6CKzPxK9hRUsSa9UCFLWr3jJGm5FUyNDGDt4njpPDMaqa0gtWptWej2FFQZCVR7AuTUbL2Le4JAqaGphUWbDnKhromP/6fEaN/8hFDuixpE7tkGAMou3wTgnV2naGrWMHtiCKcNQRkBEARYeP9wpkYG8Kv7hlNc1cicSUM4eraB9PyLjBjsBUhikRoXQlpuFaIIz88axZc/lvHougNodXpeSpFSGvtP1vDOrkJSYkPIPlvH4ZI6I42k/lstSMkTQ/hs6TSg1a+ztUvdqdl6F6YESj2yMm1PY/kn2ezIqeBEeQMll5oASIjwY+ns0cyaMIT9J2t478nJ7MyuQKvVU3rpOiU1TTzx/mGCvPsCUlBmwjBvrt3U8PH+s+SXXeGh/9jHlRu3ARju74GLmysl1dd5cc5oADRaPSD5hN8cu8iZ6utMjQwAYG3GKeJGSJFPQYCfJ4bxm+kRzIgOZP/JGj5+dipanZ6ZY4PMCpO7myturi5KQEStxdoTJmcE03FxVwlfU4uGd9IKGewr+XcDPPsA4O3pSva5Br4vusSmzGJyyxoIH9Sfc7VS1NO3v3RcsI+HkXl6rPyq9MflZvq6CYrgAZyvl46LDPKitOY6uwsuIooiAvBtYQ1nqq8zxNeTo2fr8f2hjNkThzAlMgAvjz5sWz5DEYbM/Eolsb8245RRpNFUcEwFzpqIpDOC6biwaX2+zmLx4sVieHh4t+f4Vv0jn3fTiwAYPLAvtdduMWiAO7XXNRbPcQH0QH93F16eF8OGzFM0Nrf6Xu4uoNG3Hh8zdCCFFdeIGTqAy1dvUXtNGjtl0hAQBG7r9Ow7Xk18hB9PzBzJsx8dRb7CUyMD2P6HB/DycAdaq20AZo4N4oAhfSFrKNPURGfg1HyOg++++46f/vSnfxVFcTHcJT6fRqtj+5Eyjl9oVLZdunYLEdoVPJAED+CGRs+bX58wEjwAXy9JUPoYrtQwP8kXHB4wQBG8YJ++DB88gPS8Kr45Vo1ehFtaPcfKr/DQeMl8jBzsxY8ldcz/z2/ZfqTMqE/wWNmVNv6YLfm+9lII5vw8ZyF27+CuJM3NOlHNos2H2He8c5QLfv1cGTSgT5vt/d1duWQQsNt6GDzQneqrLYhAsK8nIwf3B6C68RZnq68RaQi+ABwrb2TL3hL2GOb04IQhShR18eZDrN5xkhnRgSx5KIr/TCskPbeizf+0ePMPgFRFIzf2moOUhvi+TRrCEpw8mo6Bu8Lnix3uh4+naxutZS0abuoA43NHBXlxpqbJaNulaxpFGKsbWyi9dIPUOKkAO82QcpgzcQh6nZ78C1e4dPUWIEVB3993BpCirUP9+/NueiETwn0BEIGvD5eTEjdU0VCxw/2Ij/CnqVnD83/ORhRFVsyNJjbCn+SJIWZMSOvdB2fKwTFwx+f5SmuuMfalnZ0WPICJw3wAeGpmBCmxIaRMGsK5yzeYHOmPYEitCUiC9UJyFH9dch8/TxyKiwC/mDKMhxOGKmOFB3rh7u7Kpau3SBzhx1+X3MfDCUMRRVg2ezR/fm4aU0YNAgS+/LGM6BBvBCA9r0qhkNBodSzceJAfS+rYXXCRz5ZOY8XcaNZlFrFw0w9tNFbyxBC2LZ+hdGKA07R0RNxVeb6GphYmv57BLa1tQaPAAZIflzQ2iBfnjOZYeSMAVfXNpOdVkZ5/keWzR/P5C/eTEOEHwLy4EPYev8iUUYPwcHdjTmwof39xBrMmDOFU5VVl7C17z5CeV4UALEkezYLJ4UpVi0ar40/bj5M4MoDEEf7syK5kd0EVHz87hdT4UN7dVahUsxwprWNypD//+Xg8bq4uvJIawyfP3ceLc0a3WdXInF/XnmnpNDt7B3dVnu+FPx9BY0Hw5CimjLGhAymsvMbEcF/yy6RWn8d/EqF0rosi7D7W+jCOH+bLR1klHD3bwNTIADY+MZnfltSh1el5bMP3fLpESni/k1bI+t3FTI7050hJPalxITycMJQThuCPRqtThO+9vSWIQMnF6xwuqWNUkBdpOZWAVKz94txoksYFK77b9KhAjpbWsWjTQV5KiWFCuC/rM4twdXHpkAypPdPSdF93RkSd0VbLuGMDLhfqmviusMbi/jGhA5W/fxodSNJ4qSh6qH8/BAHmxw9l1oQhTB8dSLxBuz03axSpcSG4CODm6sKKlGgWJIaRfa6ewyV1zJkUSvLEED5fdj9anZ7HNx5kTXoRL80dwz9W/IRXU2P44JmpeHm6s3HPaX7/3iH+tP04Wp2epclRynyGBfZHEKD0UhMjgwawM7sSnV7kbE0TTS1SLnHF3Gg27C5Gq9OTGh/Gmgyp7emllBjWZpzqUGu1V81iuq87NaFTy1pGj2g+2eezV56vqUXDfa9ncK3Fsj9zsvIaE4b6cKyikb59XNmwu5jhgf1Jy60ibrgvO3MqGBHkhU4vctRQalZZf4ONT0zmV9OkRll3N1c+enYqvygIQ6vTK5R+SeOC+dP24wC8lBLNa/PHAijtQUnjgvls6TTyztWzNqMIQRCYFxeCiBRweSU1BlcXgXWZxZypvk5suA+h/v3ZkVOBi4vArtwKPl0yTRHytJwLvJQSw8yxQQCdbjdSQ62R2tOSXdVczuBOK7rs81kgUHpEEIQkQ29fG9jT52toamHa6xlctSB4Hm6txceXrjXjIkhxTL2IUtGSe14yO9dmFKHTi0pQJS23is17TgOwcNNB0nMrlDf24s2tgY6sE9Vs2F3MK/NiFHoI05rM5IkhxEb485fnJT8tPbeSBYlhZORVcbikjoSRAco888oaGTbIi5dTolm7OJ7Pl91P8sQQRdNuXT6D1+aP5UBRrVn+UFPYsoKRaQ1pe8d1Bs560lZ0Oc9n2q+n6uPLMnxO6soEO8JzH/zIubpmi/tbVD5gzdVbvDIvhr6uknRFDOpHSmwIHzw1meWGesz4Ef58/sJ0/vzsFF5OiVa6ykURtuw9zW/NFC+bI6E1fcNLHe6SoLy+YDxbl89g85OJyjHJE0N4ftYoZa6bvznN+GG+bMgsokWjVbbLmjTrRDUzogP5dMk0tDo9TS0aIwFTC5w1AmOtRnJqru6DPczOBOALw9/ngFggyw7jtkFTi4aj5+os7h/o6ca1ZunBnTNxCHNjh/DNsWoeHB+Mi4vAwwlDmZ84DHc3VzRaHVOjAs2aU8kTQ5ifEMb2oxdYkBjWJq9mWldpzjTT6vSIokh2aR3JE0OMBEg+9q1fT2La6EC0Oik09PXhciVf+HJKa05PXZ8pF1eb1oKqj7FGYNT/Q3umZU9RWNyLsIfw+Zh89jc9wB4cLhqtjgXvfEfd9dsWj5EFLy7cl8yCi5ypvkrppRuk5Vbx4pzRPP3hYTzc3UiND2v3oXJ3c2Xzk4mMDBqgaMLM/EqLfo+54mU5wrlhdzFTo6TUgKnQyMIhHyv3BkYO9jL4iihF2Orj5aWe1UxnMm+MaRrCGpibvzNKaT9Y4nDpVGG1IAj7RFF80PD3aiQezyyDyfmgaUf7qlWrxK5yuGzZU8Rr2/LbbA8e2IdxQ/3YW3gJgDkTgsk0pAwEpLoPFwGWPBTFpj2nWT5nNH98ZIJND1RHBc7mHlR10XTyxBA0Wh1r04tYkhzF4ZI6RRM+uv4AICi9en8/eJ70POm81LgQKXpqKMS2do6ATQXZ5uZvj6JuJ9pCEIQ3RFFcBfbRfNm0ar8IYJ/lQzuP180IHkD1tdtUGwRPAFxcBFwEiAjsz8/GDSF2uB9nqq8xJtQbQZA0UcLIACNio47QUV7MnBZ1d3M1+g6Jq1Pq6ZOPlaKi0wEU0/aH4lrlnF25VTycV4mXpzszogPbdD2o5zIjOtBojrJvKPuE7Wkxc/N3+nrdjy4TKBkCMBGG7T5y4MWeuFDXhFVFUgJk5F8kbrgfpZdu8NH/lHCm+hrrMoulvN3c6I7HMANr8mKdISeSBVQ2g6Vt0i0ZMbg/IvD+3jM8uv573kkrNPudf9p+nN+sk4ib1C8DN1cXJULbmYilM0rZ/egygZJh29uG7W+bO6ertZ0P/Z+9Vh0XG+6HCAwaKDXTpsSGMCbUW6a055XUGF6Z15ovM4emFg2r/pGvtP2YgzlB6og1TNY8YJ6vRcaKlDEsSAzjpbnRCED2uQZ0epGIwP7MjQ2hqVljpM3WZRYjirAmvcioq0E9R6cWcwzccbWdNY03qWxo6fhAIO+8lCwPC+jH/PihbHxishLMADhQVMuadGlBFEsP/9r0It5NL+J3Ww51yPIF0mInaTkX2ph9aljiaDGHwyV17MqtwMfLQ0mHAOzOv8iO7Eqe+uCwcq6czF8+Z7SSqzSdo9ostqTFnEXYPYM7rrbzF+9+Z3Z74IA+1BoinyMD+1Nae4ORQV6U1DTxflYpLgL85v7hSu2mm6sLSeOClfIste+lxoqUaOUh7ChymHWimoWbDgIC25ZbDkyYi1Za0kJy1FLWznLQCEHgxTmjmTTcTzlXNluTJ4YoaZOOYC644qSa6B04fG3nuZprZrf3V0UAS2tvMDUygPOGNiCASeF+bD1wlsSRAWxbPoOZY4PIOlHNipRoPl0yjRaN1myDqpeHO1OjAtn8zWllPQZLkAMmny1tv9zLFv/pQFEtazNOcaColpljg1iaHEVChB8ZeVVMGu6Hh7ubkaayNSVgTvM6zdLegcNzuPgt3IalzF5ChB9TRg0ifoQ/syYM4UBRLVMiA1jxaQ7bj0rU7vMTQvnbCzPahOLlEL9aY6kjh+rIYnsPuGlKoSMBsBTCN/3uGdGBBvZraTUjgBfnjGbzN6eZGxvCrtxKPls6XUm6f7pkmqLdnWxmjok7isOloanFouCBFIzYtOc0x8uv0NSi5YsfytBo9fxiShhPzRwBgG//vqz6Rz5TIgOMAhCfLZ3OJ89NNQrHy3QM+0/WWF31n3Wimsc3HuS3Gw7yxHs/0NSiadeHsqRlTBfZlDRgEep3Y2n1NZY8FMXO7EpluzweYFVE0xnF7D3cUT7fko+PdHiMiFQg/X3RJY6ebaCyvom88w1MMrQJ/eW7swAcOn2Z7X94QNFkbq4uSluQvH5e64jGUAuMOTq/FXOjWZNexI7sSkYFFxE3wt+iD2WpsmZGdCDLZo+mRaNFo9Up/C7na5sI8vHk4/2lpOdf5MXggUogZubYIGU8jVbnNB3vMDi08F29cavDYwIH9mHS8AD0BtssfkQAD8QE8056IYIAzz0YSc7Zen4sqWP1jpNMjZJqKRdv/oFls6WHeK2hQXVFSjTbls9gRnQgaTmS2Sqbkup180wFa/wwX5YmR+HqIrAiJRp3N1eLwirDdPuBolrWZRYhVbu4cKzsCpu/OY1ehCG+ngCMCh7AuDAfnv7wMCAwNSpQmYM19aZOOBYcup8v37C4ZHuovXabbwzlZIkj/JgwzAc3VxeWJY9mXJgvHu6uxEX4k3PuMIDiH8n1kbER/uSdq+fdXYXo9HpiI/zZf7KGhZt+AES2LZ9h5BOa0vntKajid1sOAfDKvJg2FS+ysJr6ZKYRxqRxwXzy3H0cL79Ci0bLO7sKWfJQFEdL6zhSWk9ksETOW1B2hU+eu08ZSw21wDkjmI4H0zxfjwhfZ9fn6+MqdHyQCkfPNnD07FEAXF0EXk6RipiXzR7NX56/D61OZMlDUWh1eiOyofHDfHnRQFAk11nKtZZTIgN466tjrEiJVvrpPl92v7LyUNSQAQCkxocapTBMy75k+gm1sJlqRzdXFzbsLmbZ7NEIgkD8CH8mhvsS7OuJX393Sqqb2LjnNK+mSus+qDWbPB910bZcYlbTeJPXPs/jrV9P5JP9Jfj2c+PdjNMsT44kr6yRhyYEU3zxOhqtnoq6G4QHejFhmA8nK66i04u4uggMG+TFB/tOs3zuGH4xOUwJCu0/KbEJyNfTdE5O7dsKU5+vR6KdnS2sHvbsFwZaP/OQc2A+/dxovNnaAxcf4ctTP4vkZMVVzl+6Tkb+RebFhZCeJy1iIgjw9xdnAPCbdQcAqfAaJKGV+/SyTlRztOQy76YX8WpqDK/NH6s8TKt3nOTttELmJ4TyL1PDmTk2iL3HLnK8/AqvpMZwoKjWSNg0Wh3puRXKfjVr9eodJ1mTcYrls0czfphEJygXByzcdBBRhEDvvtQ03iI8wJOyumZiDVw0I4O8WL84kUfWfMdNjR53F+jb141JYT40Nms5fqERH083Gpu1+PR3o/FG63XqLEYO7k/ppRsEefelxkCP6NffnVcfjuH1v+czaIA7qfGh9HFz4/19Z/jL8/cxa8IQAzubHp1epKrhJj9PHMqc2FAjAb7bhdTehdXdhiDf/jTcNJ/ng9bQiCx4gQPdqb2mIff8FVy/PcuR0npFQOU+OQGJH0U22VbMjWZtRhGb9pxGECTBdHdzJWaoN79/70c+fHqyomnUWJIcxT+LatiRXcmIwQNInhhCYcVV3k1v9R/lFh9Z8DZ9U0x2aQMHT9ey4w8/xd3NVRK89ELmTAphTXoRz80axfv7zvDUzyKpqr/BM0mjKK25zl4D+W6NYS2JPAMJVElNE3P+335lXho9aJq1HDjd2vfYaGi1slXwZKE1JaOSV/aVBQ+g4YaGP36Rj16U+E0/2n9O2ff378+zIbOYXEMFkoz0vCqenxWpEEu9kBzFxHBfCsqk6PXB4kvseHUmQT6eRuV5tqR2HBkO7fNZa3Z6e7pxtVlL3TUNKbEhZORXcaRUWkPviZkjOVlxlU3fnAZR4lyRI5tZJ6pZNicanV5EpxeZGO7LqcqrrEkvZGnyaERRxM3VhT8+MgGA7UfK+N2WQ/zl+fvwcHcj52wDAlK09XztDVY/FotOrydmqDf7T9awJr0QgAnhvvxuyyElX3ekpJ4nthzCzVUgLbeKYB9Pmm7eRgT+9s8S9CJ8kCUtbSZgvJpui400iWq4uYBW3/FxMhqbtQzx8eBio3XlfbctGCl72mES//pIufIS3Wig8FDjvn/LpG8fgdprt3kmKRIvDzcl9zln4hBcBEiODeX8pessmxOttGvJQtnQ1MKKT3NYuzgePy8Pq/6P7kK3+HyCIFwBcpD6+toUV3fW50sYGcCxC1c7PO6q4c2uB4J8PJUc2NGzDUwafoWqupuIorSi0O9nRpJ1opoWjZbfbTlESqzBHAWWzx7NipQxuLq4MMJABX+kpI788w1MGu5Hzllpwcz88w28Nn8sL84ZzZhQb/77cAXbj15Aq9PxiynDWLz5EPPiQng6KZJ3dhUyYZgvE4ZJb3RPdxduavRkFlxU5l/d2Ex1o0SNcf2WsXCJwLUW6wVOvbBLQH9X6m5IEhHq70FlvWUhchVAZ/iaAZ5ujBjkxYnKq4wb5ouH+zWF/0aNQV5uXG5q1abjw7y5fO2W0UpPbc/pw+UmKXvr08+NS1fbX0vjarMWDKwh8gupv7srNzQ65Rqm50u/DxRfIqe0gfiRfmxbNoP9J6r5X9tyuXJDS0VdE0tnt9bKurm6MH20VMhwtvoaQwd54e7mQvwIf4U53N4+a3fl+f6lO1qJvDzarp/QEb4+Ug5Iqw7d0OiVGwaSibZ4y0Fyzzbw7IOjjMxRgHWZxVyou8nO7As8NGEIelEiwZUhE+iWXrzOW18dZ8veM6RMGsItAw3ErtwqQv37KeMOHuguCavBRHQBbmpsUD3toK8r3FJpmgGeblxv1hqtqBQR5E2dgZlt8EBPKutbpEVeAvtxrvamcpzsw7m7gkYH15u1DPH1JHywFzuyK5XjPN2gWWW5Xm7SkhDhR/Y56TsenRbOhfpmtuw9Q+wwH/IMZMRqyIIHGPnpfVyk9TCswQ2Njj4C3Fa9k/q6CWSXSvPILm1g+r9nKtT+IBVkLNp8yGiciMD+Zl8q/+/Rifx3dgVxw/35MOsMW1URb3vCXhUuPoIgRNhpLAWvzR/LMD9Pq493dYErN27j5iKtOgTwQPQgRgZKC5hEBnkx0KMPehEOFV/CNNYkrSxbwcMJYUaaKTxAmkP2uQaiggeQXlClCGV6/kX2nZACBiKw7eB55Tz1zQdjv6k9PD8rkjkTghVm7T5m7pJa8CIG9WNKZCsb2pyJQ5gc6U/22QZeSI5ifkIo/7XiJ7xo6H547eFxSg1sZJCX4sNpVGO6uLrw80TjhmNZ8CYO8yF2uA8gXRN5fcM/f3tWuS5TogKVdSxMof5/wvz6AcaCFzVEul+GBaKYFO7DIC/jF/Ftk3tnylpueu39+7fVM+YED+B/bSvgSEk9W/aeITSgH1v2FDP+5R384u39/OPQebt1f9hL8/kBDYIgfCCK4jOmOzvL4eLl4U5MmC/lDZbZytQwKCAjv+a7osu4CJJgRQwewLrMYgAKTMzZiMD+VNXf5OmfRbIiZQxBPh5sP3qBmsYWygxsaT793PjbC/fz9Ic/UFBm3hxWv81tgWcfgebbIhGB/cg5W8/Rsw08PyuSmsZbrH4slkOna8k5W0+zRkfeuXoCvPoyPGgA1Vdukp5bRXl9MymxEuHvwwlhPPvRYf5giNDKJlPCyAAEAc5UXyO7pJ6pkQEsfiCCZz6S0jNxw33JO3+FxEh/Nj85GS+PPrycEs26zGKSxgUp+dTnZo2iqOoaeecbAemFNyp4AMtnR7HkkxwEQYoaZ+RfJNLQaQIwfFB/zl++YSRoFxpaNTBIPu6IwIGcvthEk0F+8ssaGTSgYyoNaA26Abi5CGgNjnbTLWOBkbW8u5ugsJ6bBpYAympvUmawEs5fvsm+kzWs3nmSjH/9GUE+/ayak105XCzBwOeSbUov2BUOl38cOscT7x+2+bwQP0+amjVcNSygkjDCj+yzDfQz+FxqePV1Nbo5lkwmaGvudRYRg/rz4IQhlNc28c2Jat55LI6vDpczabifoj3+uuQ+FkwOB1qT9ZPCfTl6toHEEX7kl11RaOtlLN78g8Uia3XucW16EWszTvHpEoncd11mMZ88NxUPd7c2XDSyj7zYYLYtTZb4cGQW7s3fnOYvz99HStxQJZ0yJtSbpz44jChC/Eg/JTiVEhtCVf1NcsuMCygiBvfj3CXpIX9y5kg+3l9KkI+UXjHFM0kj2XH0gqLdJoR6g6ugrLkBUuqj4Ya0P8jHQ4kSu2K6HlWrye7hCu3wMLfBd/97FnEq/lVrYNdUg4EoN0cUxbyujmUO8xOHAfB///uEYh5ZgyoTbZl9tgFPN/M+l+lbUS14phFCewgewMpfTmDB5HDSci6w72Q1Qb6e7P3jLJpaNHi6uzJ+mC8pca2rH8lJ+W/yKzl6toGxQ31YPncM0BpyV9d3dsTV8tr8sQr7WfLEEBIjB7VLHSiNLfHNZJfWISJRXsRG+LNlrxSlNC0UkEmrnk0ahcccN7Q6PW6uLrRotDz5/mHiInzJOScJYVntTSUtVNMokR3XXr1FSmwIiCI/jQnkvw5dIDbCn6qGm0Zm5cmL15g7aYgifPMTQln/u0SW/+UoO7Ir6e/eaufqaJsXvm6wp20RPIBZ/2cv9Z8+attJKtjD7PwHEoeLmtPFbnB3c+WX90UwJzaUia+ktbHlbUGzGYvQRUBJAZiDLaF5gACvPtQ13WaghyvXWnREDOrHqGBvQgd58fH/lDAp3Jepo6S3pUarU5b3knNYXh7uvL5gfJvuBFkI/vZPqVD8xIVGfjZ+SBtNZ21gwLQW1PQ8uVVKFpjkiSEKIZRc0L0kOYqDxbVKWdyG3cV8/OxU5sUNZW16EakJobi4SGmSY2VXiBnqrcz3v1bMYEpkABsyixgT6o2bqwtHSi6zZW8J8+JC+M304QBS6V96Ee593MgrayD3fIORr54Q4ceMMYMZFTyAtNwqRgZ6GV5Gks9a3djMkZJ6o//tkSnhVNTfoKT6qhJ4kosXbIFGD7mldTZrPxldDriIotgoimKeKIpfmVIG2gsarY4DRbXs+fdZDPGxb66mPcHrCCFmgkG/mBKOAPzn4/G8mhpDWd1N9p6o5v7Rg/hixQxeSY3hg6xSfv/eIYtU7e21MD04bjAgBTq0Or1N7US2QO7S/92WQyzcdNBobC8Pd/74yAQOl9SxePMPFFZcZX1mESvmjsHN1YVduRXMTwwjPbeSl1PGcOJCI2+nFZJ/voGPn51K3rl6ZkQH4uflwapfTmJ+4jA83N2YHDkIVxfw8nRXiKVeSY3h1dQY1i6O55Pn7mPJQ1HMnigteiP3c67PLMLL052pkQGU1jbx3EdHeCetkCfeO0TiiABSJg3hdz8dQVy4L8njg/l4fynfHKvmXO1Ngrz7IgAPTQxBACICPHlwfBALZ0Tg069j3TTLSn4hc3DoJLsMmXr9xTmjqb3WwtTIAH4sscxc3R0YPqgfZZdvKpUYU0YNInFkAH/4LJfkSUPo4ypwqvIqY0K9+Xh/CV6efXht/lh0er3Cniabb3LdqKX2H0s9fxqtjs8OlBlta6+dqCt5KrnnsUWj41Rlo1lKDXmepgS+ny6ZRlOzBr2oZ0lyFFnHpcixTi9yvPwK76YXASimrvyy+XTJNCMrACQNHTfCHy+PPni4u7Fl72mpRBCYNlpiHHgpJUYynUcGMPs/9nH20g1GBQ/kpZQY3k0/hShK63G8bPishlyl4+rigouLwNhhfkQMHsD6zGJEWlNWlkrzNHqJdMsabtU7jkCpFSLjh/nyUkoM2eek6hVT9Df5/709rP/31Ed69mmtKHly5ki2LpvOof+Yw0sp0bgIMGXUIFLjw8g730BGfiW+Xn3x8nRnfWYRpyqv8tnS6Yof9vqC8Wxbfr9SeGyOLtAUlhpes05UG5VoyfWfpsfLzbx7Cqo6rRHleXp59mHD7mKzlBpyP6O661+mLXzuY8nf2pBZhIe7Gy6CtPbF+GG+vJoaw/hhvsrc1Lw18v9h7n9IGhfMh09PUZZ0mzTcz2jNjAOnaii9dAMROFnRyIRwXz55biofPTOFF+dEsyQ5ihcNvZCRg/uz6YlEJR3i6iKQOMKftNwq1mcWMzJYSnfc0Ohxd22/NG/1jpNWXdM7qplWhtovSokbStwIf6ZEBvBOWiHna5oIC+zPB1klPDZjJB9klTB4gDuThvuzV/XQySVo8pvMFPKWySP9+XzZ/RwtrVO+W36oX18wXnlbQ1sNJZMzfb7sfhUPp/3WOkgaF8wHTyXy8f+UkjAyQCFZMtVwak3S1QbbjvhdZKvks6XTFJ8waVwwy2aPZn1mMeOH+ZI8MYS/vdBKDrxgcrhBW7spms+U1Mrc/+Du5srpi9c5eraB+QmhbSK6u3JbCwJcXQQWbTrIckP54MY9p4mN8Of1BeOJjfBX5vKLyWGMTi8iZqg37+07Q2pcCHoRhTUcjPOf5tDQ1HHfqTncEcJnuqgHSNUv06MH8/6+M3y6ZBo/iQmiRaPl4/0lPPaTEazPLGLZ7NGUXrxOxrEq/vSbiXz+fRlHSup4OSWa8cN8yT/fwMY9p5k9IZjhgwcYlRaZY7Q2FSTTz+oIYnddBw93N3LOSYGHn8QEtVkkxbRdqatlUda9PETyztUrLyp3N1f++MgEI0Y1U0FRj6tuf1KvgagWevnlIhe4xwz1VoRLXlBm/e8S0etFQv37My7Ml+VzpBylTi8iIC1eI2tmed2M1+aP5Y+PTECj1fHnZ6XFajLzJcF7JimSqoabaLV6vjlezYNjgzh6rq5NLne3SlBtgUP4fLb4JpZW45FNFbkTXdZQGq2Od9IK8fJ0Z/sfHjAykVLihjI1KtAiFbut6IkVfXLO1iMCcycOsaiBe3JloeSJIbycEsOa9EISIweZ7aw37f43R7cvC4R8THvny8Ii+XSFyD2Ybq4u/GracIXOUe7LzC6tY+Oe04qZPiM6kLmxIfxnWiExQ72V3GZhxVWj7pf7ogbh4e5Gi0bL3hPVnL/cZLaI4lqzxiq/z9Tnc4h+PlsW5bA1iJCZX8mj67/HtCu9s9/f2/jjf+WxLrOYlElD+Jf7wpU0QG+21nR0T0wZu+U2qpdSWitwOmKIM7evqUXDO2mFjB/mi1an56kPDvPRM1PwcHczSpHIi9SsSInGy8NdeSZ0epEXkqPY8s1pHk4I461fT+TftuUze9IQvDz7oNXp+f17P/LJc1ONAkXm8OKc0bz169gOr5U6ye4QvJ228Ebayr4lszp/tnS6zdFFR8SS5NFEBQ8g89hFs2mA3oCleyIHTQBlf9aJatakF5IaH2a0tryloJFshpqOLwvUht3FeLi7caryKnoRTlVeJTU+DDdXFxZu+oE9BVVGXKgg3e95qkDLw4a1GP/t73nszKlgd0EViSMD+PpwOTq9iFYnNQC3hxst7fHsmYdD+HzdaSZZ8t966vvtjY+ySjhdfZ358UP5+eShZrlcHAVZJ6r57foDRhouaVwwWw2uwa+mhVuce0ccNLIQv5QSQ9K4YGZEBypNzK2QBMacWf7eU1MYFSwt2fZdYQ1hAf0UAduRXUlR5VVOV19HQBLo9YaaYIC+LnDLJGZ3pBOpL4cnzXWiFWoqimdnRfFRVoliSjkiTHllLL3gLK1vaK0pa26/tU20ssuxYu4YpYm67HITadmVpCaE8vPEMOJHBPCzVXuoUVVXBQxwp+566+eh/p6cWvvzdq+HKWmuQxMoOWGMPQVV/P69H/ls6TQ+yirh7TSpU17utHc0uLu58tr8sUwI91XWkTcX2DKn5SxZI+ricPmzmlZCHu9oyWW2H73AyKAB7V4fS4UCWdNbBfvxDd8bCR5gJHgA1250HHQxzfM5hM8HzpVyLEF9XeR13ls0WmKGevNySnQbbhlHgxzJXLz5B9amF5lN+tvic8uCKo+1Nr2IhZt+UHxfeb+czF+SHGXxuVLXr6qFXdaoTS23eXzjAXwH9DU7FzXLydUWHW99ddyGK+MgPh84V8qxBPV1kXHiQiObvznN58vud1iTUw1L2kWGLT636VgzogOZEO6r7IPWVaAWTA43MivVvY3QWr8qivC3F6aTGh9mlNzftLvYqIwxIrA/IwYPIOtEDSJSj+h/57Tm+H48c9mm6+IwPp+T49E81Nflvw6eZcknOaxfFEuQn5fzWlmApdSGTAehNl3fSStkTXqREbHWnoIqfiiuZcveMwwe6G51J82cCcF88fJPLe7vloVSBEF4RBCEJENvXxtYU9vpXMDDPNTX5dPvJDq+z78vc16rdqDuCpH9zq2qgm31ojSvLxjPH1Jj2LC7WDkeWrl7TAVvZGB/zHHqubnAql9Nandedvf5VH18WYbPSV0d0wnzGBfmbfTbCfNob2Eb0/2ycMqfm1o0fPljGSDx2/x0jNTCJSC1MP1sfDCzJw5psxKwVg9L/2wb44I9fL4E4AvD3+eAWMDuTGb3OppaNHxfLPkUppE2J4xhzVoZ5mp0m1o0zH/7O46U1hHs3ZezNU1EBQ8EYF5cCJHBA42qXJ6fNQpXF4FvC2s4WXEVn37uSlGANbCH8PmYfPY3PaCzBEp3ErrbZ1294yQlNU1EBnmx8YnJdh//boWs5UzXyjCFWvAAqg19fsmxoUSFeDMm1JvbOpH4CF9yz11BBDzdXdmwu5jZE4dwsuIq+07WsKegqk1RhyUCJXsIXyMSe5lF3At5vu6O1moMfBYPjh/S68zLjgBrE/PWrl/41lfHFMGLG+5L7nmJW6a0+hoJIwN4fONBQGI+EAR4eW40r6TGEBvhz/Xm21RduUneuStodW3b1dQK54033iiTt9sj4JJNq/aLAPbZYcw2cPQ8YHfXh7q7uRj9vtdhjmqjPfqN9gJ6Gq2Ovcekbvsg774cK79CapxEwzhpuKRXRGDEYKnB9iWD4Mm1okv+fJS8c1cwG4lpB/bgcPkKiUApCfDpDuZqaP/COgK6M1rb0NRCafU1UmJDWJEyxu7j34kw97JT5wCteVFrtDrSci7wp+3HFWa8fzVERjc+MZlls0eTf76BxJEBJI70p6SmifkJobySGsPa9CJ+u15a4eqF5ChEaEPC3BHskmRXrc9gVvC6yuECd1bngb0gm1F///486fkXEYDHS+qcRQiYT8zL26xtEdtTUMXjGw8iCAKTRwaQfa6OC/U3eewnI8k6Uc2G3cXoRSi73MRRAwPazxPD2H+yhnfTT/HinGhmjg0i71w9LoIkfHLPoDncUYtjqnEndR7YA+qi5PefmgKCyLy40Hvq5dNZWPOi1mgl5m+9CJNH+pFdUsf8xDDWZxaRGDmIGdGBLHkoivLLTcyeOIRduVW8OGe0QgwsiiJjQr1Zm17EuowiVsxt7ai3BIfncHFWukhQt8zMiQ3By7PPPX9NrIE13RB7CqoMLN1F0poWpfWsSJH8OLnNKT23Qlmz8eGEMF5OGaPU0R43LFd+qvIqG3YX8/K8GJ5KiuS1z/OYPjoQPy/r7pHDee+O7tv1FOS+t9fmj1VWub3Xr4k16Oj5kU3NdZnFPBwfRnapZE7GRvjj5eGu+O3Hy6V0gtSg26g048rm6Iq50YwJ9WbJQ1HEDPXmD5/lsv3oBVZ8mmP1XB2Cw0WNe9G3swStTk96bgUgcWE6r0nHMEfGZFrrCVLSfO3ieH4xJUxJD6hbnl5JjQFg/DBfZk0YYsRaJ+cNF276Ab1e4gRdsyiBoqpG3vr1RItzc0gOl7sNtprOpj1p7m6uZOZX8pt1B4zWkL+XfN6uQB1wSRoXrBRWL02WODt1epHNe06zwlBMLdEfHmRe7FAy8iut5hJKz63g6x8vkF5QSWrsUHbkVPBqaky7/YMOx+FiLzhKLtBW01lubVm46QflHJn7UhCklX3MMUY7YR5q60nNGbNhdzHrMoupqL8BAqzLLFKutyjCzpwK5sUNtepayzSOGfmVzI8P4z8encSCxDCWGFZusgYOF3DpCtqrMunJQI6tprNMzS7/DdLNHRfmg16UVrz9bVGtU/NZCXVVi1an569LpzN9dCBhAdJ6eitSxvAvU8OB1uv9txemk3eung27i/nVtHDlfFOLRI2kccG8PE8iSh4ZNIBduRXKuVZBFMVu/1m0aJG4cuVK8dtvvxWtxa3bWjEjr0K8dVtrl3My8ipE38XbxIy8CqvH62509D+u/CJP9Hp8q/jY+gM2XQcnpGv75pcFos/ibeKbXxaIO7PLO7z/8v243nxLzMirEHdml4vei7aJAxduFXdml1t1Tnv36dtvvxWBT0WDXDjsWg2diXq2V2XS04Eca0zg9v5HjVbHmFBvaa253yc4UwxWQr3Gw5r0QlLjhrImvRCtTs+KuWPaNSnl50eOLgPK2g6m42u0OppaNKzecZIpkQHsP1ljtq5TDdM8X49ovpUrV1r1tjL3RunKG98eY3QW1mja9ua3M7tcHLhwq+i9yLG0taPievMt8c0vC8SvD58XfRdvE3dml7fRYrZqvuvNt8Sd2eXizuxy5R6p7+ubXxaIXo9vFRdu/F70XrRN9F60tcN7BawSDXLhsMJnD/SmqdkVwb91Wyuu/CJPHPD4VnHlF3lOk9MKyIKw8os8s9fdGvPQ9Hkx9/zcuq1VBLL+erP45pcFYvWVG+LKL/LErw+f7/BeqYWvR8xOOc+n6mmyCZ2NYnbF1Oxq5LSjQuv2xpcTuX9IjeH1BeOdJmcH0Gh1xAz15sU5oxk/zJcZ0YFknag2uramJqWpqS8HZ9T5VNOOePl+HSu7wqJNBzlYXEvcCH+OltYpzNnt3SvTPJ/dtBtwBamd6FXTfV3VfBl5FaLPoq3im18WdFqT2KqFultrtjd+b5rLdxLk67Qzu1z0WbRVfGzDP8WBCyXtpzY91dfR0rXt6H7L+9/8skD5LZuy5r7HEugOsxNIsrSvq8InR67MmQDW/NOdEaTuEAD1mObGdwqdbZDv69eHzyt+18CFW8WvD58Xd2aXi//+91zRe9E2s5FK02utNktN/TzT/fLvrw+fF1d+kSdeb75l9Zy7S/geASLM7bOHz2fuwbRWqCxd6J5+yK19uzoDLG0h+1qyYKlfYLLmW/lFnrIvI69CHLhwq5ImML3nlq51Rl6FVcETa48zhVr47FZeZqAN/AewWhTFZ9T7ZN5OsC+HS2cT5721JFhHSVtnR4dlpOVc4PGNB9GL4CK0ktyCZUoJ+VrPHBvE2vQiozUjLN2Lju6RDDXbdUfLtKk5XN544w2Ft9NWzfa0yU8bUxNYDTwi2lnz2RPWaD51VMtS5KwzmtOc/+o0N1thKSopJby3io+u+07x66y9fpZiBvawNGwdA3ubnQZBjBV7WPi6+tC2d/7Xh8+LAxZuFQc+3tas6MpNu958S1y48XvRx3C+JX/2XoT6Wrz5ZYGRwMgvwy9+OCs+tuGfyvUTRVGpRPn68Pl20wymvra9csmWXtLmQDekGv4BRgS6X9lp3HbR1d6/9s4/Xn4FUYTU+KFtUhVdSWEcKKolLecCL80dY1T4u8Lw+V6GfC2WzR5NzFBvls+JVhbQlE26pz44TFpOpXL9WiGSf76BR9d/r5iNMtRpH1M2667y7qgXgrH5ORTtoPk6+ulMbac1sKWurr3zzZ0nV0zYEsnqaExz+50mZytkLbLyizzRZ9FWoxB+e4UH8jX8+vB50XvRViMNaOv1tndNsRqmtZ09Inzd7fP1RJSwM2kNp2B1DFOzTTYhZQFTRzRlc7QjwVGXktl6PzobQbcW3G3lZT3xkHfmpqgdfbkU6XrzrR6Z750i+HIN68CFWxXB8V7U2kUgX3dbEuaW/LqO7mFH/pva0pJ9Ultf+Hed8PUEOmuOyAGEhRu/F70elwSxJzT1nZAzlE3JgQul6hRzL6b2rrs1wmSLydmZKheH13zd5fPdCZBv+L2g+Wz9TtkyWLjx+069KLoqTLaO19UYw13p83UWtoaJbRn3TjD57InOpExMX0z115s7/XCbu+adDZp1J+jprgZHhTnuFOh6R8O9SH9oLmVizXXU6vRsyCxiTXohm/ecNlpv3ZbrZ+6aHyiqVSj/bEWP8AGJTs1npPnskfS+VzWfrbW3Un2k1DAsayh7ar6u3Ifu8plxBlwsw1IpkhrWRNnuJnT2/7LGhzL38rP3NezO3J2t4E5rpu1JqJmizRU+y/wg5syiu9Xc7K7/y93NldT4MFLjw5Rr3R3fZc2YpmZmd6w61W3NtO393Emarz2oc07t9XzdrZrP1By0NtpoS0jeUo7OHvNvTwN3Nm9nK3AGXDqHGdGBrJg7hpljg8zW83XmbdkTjr3pd9j6naYUDHsKqtq1AGQkjQtmxdwxrEkvtFqTWarD7Ao6ui9ZJ6pZm3GKl1Jiera+VnRqPqthqVSpJxz7ruSYTL+jvaoRS99rrtRLbQFYmldXrk1PWRI9abHQ1YALUm/fPjPbkoCnTY+/W5LsliJqXTFZrL3xptUVttSOmh5nSrPX3rzNvRzUgRJ1zaWjV9T0NuyWZFcLn0HwHjH83abJ9m7RfObQnl9jzyS+Oc1nSzjctC6xM5pPDVPt2dmqD3vD0f3uLms+sa3wraa1mTYJEwazu1n4Oqo9lPNY3aERbMltqV8SXWGC6+h7ehuOXtNKNwRcfEw++9tpXIdHRxT1ny2dzmdL7b+2niW+F0tBihnRgSybPZqoIQP469LpvDZ/LCDx2TS1aGwO+nRHKN4euJPWdzS7SpGhI93PZPM5URSzLIzTaOZ4BXKeD+xLoOTokPNYlmCJ+McaEiVLKzJZevgOFNWyLrMYENm2fIayBuBjG75nxdwxRuRCdzLkl4IjQU2ghD3yfDh9vi7DnIlka/TTlvyZpWoSR/HX7gVgh2hnEhJD9SOqba9ixt8TncJnEfauR3Sie2DPe0JXfT5RFLNEUfQVVURJoii+bdj+dmfGvBdhzm9yVF/qXkZ3ldc5azudcKID2CuIY1rb2SPLQsuLYzrhxJ0IewVxTBfHdNZ2OnHPoUcaZa2AU/icuOfgKK1fTp/PiXsOvZWId/p8Ttzz6K1EvEP6fHeaRnTOt3txr8zXKXydgHO+3Yt7Zb53jM/X0bnWjG2vY6yBc76dP6anvqen52vq89ltZdr2IAjCx0BlO4eEo7KFO3mMPcboyWMcaS7WHOOcS+ePUe8PFUXxSegh4XPCCSfawiF8PiecuBfhFD4nnOgl9LrwCYLgIwhCrCAIjwiCsFq1/RFBEJIEQXi6N+dnDoa57TOzzaHm64hzMoc75XqCfZ/XXhc+4JdAvNyeJAjC06q13bMM25J6cX5tIJqsOe+I83XEOVnCnXA9VbDb89rrwieK4oeiKH5o+BgBnAMSDL8x/I7tjbnZAEecryPOyVo47Nzt+bz2uvDJEAQhAmgwvD18THY7OiGTj8lnR5ivj8lnR5iTtfAx+exwc7fH89ojtZ1WEjI9IoriM4a/G80c32OwN4FUL6ERx5uTtWjE8efe5ee1R4TP1KY3hSAIj8j0E4IgxALZtL5NIoB9Fk7tFnQ0XzPo1flagCPOyVo49Nzt9bz2utlpcE5XC4KQKwhCLuBnePgjDPt82tE4vQLDvOJVjrbDzdcR52QJd8L1lGHP59VZ4eKEE72EXtd8Tjhxr8IpfE440UtwCp8TTvQSnMLnhBO9hP8PNUxr5d8sQAAAAAAASUVORK5CYII=\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.scatter(final_snap[:,0],final_snap[:,1],rasterized=True,s=0.5)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 51,
-   "id": "d77abde0-50ce-4f6b-8b93-8a5f988bd431",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "gala_pot = gp.HernquistPotential(m=params['m'],c=params['a'],units=usys)\n",
-    "H = gp.Hamiltonian(gala_pot)\n",
-    "w_test = gd.PhaseSpacePosition(pos=w0[0][:3]*u.kpc,vel=w0[0][3:]*u.kpc/u.Myr)\n",
-    "orb_gala = H.integrate_orbit(w_test,dt=dt*u.Myr,n_steps=20000)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 56,
-   "id": "1cff0a97-f1c2-4fd2-b0d0-0fcefb3de8a0",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7fb326dcb310>]"
-      ]
-     },
-     "execution_count": 56,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 252x189 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.plot(orb_gala.pos.x,orb_gala.pos.z)\n",
-    "plt.plot(orbs[0][:,0],orbs[0][:,2],color='r',ls='--')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 54,
-   "id": "a056b072-a286-4563-aa07-1814cc728556",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(20001, 6)"
-      ]
-     },
-     "execution_count": 54,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "e4726938-c3eb-4ee9-bd97-0038e8cb7d87",
-   "metadata": {},
-   "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.8.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/subhalo_constraint.pdf b/subhalo_constraint.pdf
deleted file mode 100644
index 3e81ee4e..00000000
Binary files a/subhalo_constraint.pdf and /dev/null differ
diff --git a/tests/test_package.py b/tests/test_package.py
new file mode 100644
index 00000000..6e348a7a
--- /dev/null
+++ b/tests/test_package.py
@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+import importlib.metadata
+
+import galdynamix as m
+
+
+def test_version():
+    assert importlib.metadata.version("galdynamix") == m.__version__
diff --git a/try_train.ipynb b/try_train.ipynb
deleted file mode 100644
index af883a59..00000000
--- a/try_train.ipynb
+++ /dev/null
@@ -1,727 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "a9a3d48d-dcb1-4dd8-b89a-4f1611c1db47",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import jax.numpy as jnp\n",
-    "import jax.random as jr\n",
-    "from flowjax.flows import MaskedAutoregressiveFlow\n",
-    "from flowjax.train import fit_to_data\n",
-    "from flowjax.distributions import Normal\n",
-    "from flowjax.bijections import RationalQuadraticSpline\n",
-    "import matplotlib.pyplot as plt\n",
-    "from flowjax.tasks import two_moons\n",
-    "import numpy as np"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "1e631e7f-c511-47c2-9643-1e50a2e4e41c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "nstar = 2000\n",
-    "ics_x = np.random.normal(loc=[8,0,0],scale=.05,size=(nstar,3))\n",
-    "ics_v = np.random.normal(loc=[0,.1,0],scale=.005,size=(nstar,3))\n",
-    "ics = jnp.array(np.hstack([ics_x,ics_v]))\n",
-    "t0 = jnp.array(np.zeros(len(ics))).T#.reshape(1,-1)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "dce731ac-5e56-4275-82ff-6bb00d298ca0",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "((2000,), (2000, 3))"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "t0.shape, ics[:,:3].shape"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "033584fa-02f0-46b1-97b8-2a979145a0ee",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 35%|▎| 35/100 [00:14<00:26,  2.47it/s, train=-4.3344183, val=-4.4149218 (Max pa\n"
-     ]
-    }
-   ],
-   "source": [
-    "key, subkey = jr.split(jr.PRNGKey(0))\n",
-    "base_dist = Normal(jnp.zeros(3))\n",
-    "flow_x_t = MaskedAutoregressiveFlow(\n",
-    "    subkey,\n",
-    "    base_dist,\n",
-    "    RationalQuadraticSpline(knots=15, interval=40),\n",
-    "    cond_dim = 1\n",
-    ")\n",
-    "\n",
-    "key, subkey = jr.split(key)\n",
-    "flow_x_t, losses = fit_to_data(\n",
-    "    key=subkey,\n",
-    "    dist=flow_x_t,\n",
-    "    x=ics[:,:3],\n",
-    "    condition=t0[:,None],\n",
-    "    learning_rate=5e-3,\n",
-    "    max_patience=10)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "95791842-535c-4acd-a5d1-11e9f9b9f0d1",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "samps = flow_x_t.sample(key=key,condition=t0[:,None],sample_shape=())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "dc8e88d7-4c0b-4c2c-90a0-1d0a155f5f28",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7fbd68a842b0>"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.scatter(samps[:,0],samps[:,1],s=.1)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "86c24740-4f40-4c4a-9367-8250b21fba06",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|████████| 100/100 [00:31<00:00,  3.23it/s, train=-11.43757, val=-11.338518]\n"
-     ]
-    }
-   ],
-   "source": [
-    "key, subkey = jr.split(jr.PRNGKey(1))\n",
-    "base_dist = Normal(jnp.zeros(3))\n",
-    "flow_v_x_t = MaskedAutoregressiveFlow(\n",
-    "    subkey,\n",
-    "    base_dist,\n",
-    "    RationalQuadraticSpline(knots=30, interval=40),\n",
-    "    cond_dim = 4\n",
-    ")\n",
-    "\n",
-    "key, subkey = jr.split(key)\n",
-    "flow_v_x_t, losses = fit_to_data(\n",
-    "    key=subkey,\n",
-    "    dist=flow_v_x_t,\n",
-    "    x=ics[:,3:],\n",
-    "    condition=jnp.hstack([ics[:,:3],t0[:,None]]),\n",
-    "    learning_rate=5e-3,\n",
-    "    max_patience=50)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "a6316e26-7635-44e8-b531-5d05aa14882e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "samps = flow_v_x_t.sample(key=key,condition=jnp.hstack([ics[:,:3],t0[:,None]]),sample_shape=())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "63a66dcb-92d9-4a70-860c-07b5dd9748eb",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(-0.3, 0.3)"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.scatter(samps[:,0],samps[:,1],s=.1)\n",
-    "plt.xlim(-0.3,.3)\n",
-    "plt.ylim(-0.3,.3)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 160,
-   "id": "51d4a5a5-e6d9-449d-a900-03419f1fe162",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import equinox as eqx\n",
-    "import jax\n",
-    "class NeuralNetwork(eqx.Module):\n",
-    "    layers: list\n",
-    "    extra_bias: jax.Array\n",
-    "\n",
-    "    def __init__(self, key):\n",
-    "        key1, key2, key3 = jax.random.split(key, 3)\n",
-    "        # These contain trainable parameters.\n",
-    "        self.layers = [eqx.nn.Linear(4, 8, key=key1),\n",
-    "                       eqx.nn.Linear(8, 8, key=key2),\n",
-    "                       eqx.nn.Linear(8, 1, key=key3)]\n",
-    "        # This is also a trainable parameter.\n",
-    "        self.extra_bias = jax.numpy.ones(1)\n",
-    "\n",
-    "    def __call__(self, x):\n",
-    "        for layer in self.layers[:-1]:\n",
-    "            x = jax.nn.tanh(layer(x))\n",
-    "        return self.layers[-1](x) + self.extra_bias\n",
-    "\n",
-    "@jax.jit  # compile this function to make it run fast.\n",
-    "@jax.grad  # differentiate all floating-point arrays in `model`.\n",
-    "def loss(model, x, y):\n",
-    "    pred_y = jax.vmap(model)(x)  # vectorise the model over a batch of data\n",
-    "    return jax.numpy.mean((y - pred_y) ** 2)  # L2 loss\n",
-    "\n",
-    "x_key, y_key, model_key = jax.random.split(jax.random.PRNGKey(0), 3)\n",
-    "# Example data\n",
-    "x = jax.random.normal(x_key, (100, 4))\n",
-    "y = jax.random.normal(y_key, (100, 4))\n",
-    "model = NeuralNetwork(model_key)\n",
-    "\n",
-    "\n",
-    "model_eval = lambda x: jax.vmap(model)(x).sum()\n",
-    "\n",
-    "dphi_dinp = lambda x: jax.grad(model_eval)(x)\n",
-    "dphi_dinp_sum = lambda x: jax.grad(model_eval)(x).sum()\n",
-    "dphi2_dinp2 = lambda x: jax.grad(dphi_dinp_sum)(x)\n",
-    "\n",
-    "#model_eval2 = dphi2_dinp2(x)\n",
-    "# Compute gradients\n",
-    "#grads = loss(model, x, y)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 195,
-   "id": "2453cd3e-02e4-4fc5-9f4d-46e4a2debde3",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "key = jax.random.PRNGKey(42)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 196,
-   "id": "9ce5c54a-74bf-4cf3-bc94-f8f5a9b69498",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import astropy\n",
-    "from astropy.constants import G\n",
-    "import astropy.units as u\n",
-    "G_val = G.to((u.kpc**3/(u.Msun*u.Myr**2))).value\n",
-    "@eqx.filter_value_and_grad\n",
-    "def loss_func(model,ii):\n",
-    "    key = jax.random.PRNGKey(ii)\n",
-    "    model_eval = lambda x: jax.vmap(model)(x).sum()\n",
-    "    dphi_dinp = lambda x: jax.grad(model_eval)(x)\n",
-    "    dphi_dinp_sum = lambda x: jax.grad(model_eval)(x).sum()\n",
-    "    dphi2_dinp2 = lambda x: jax.grad(dphi_dinp_sum)(x)\n",
-    "\n",
-    "    samps = flow_x_t.sample(key=key,condition=t0[:,None],sample_shape=())\n",
-    "    density = jnp.exp(flow_x_t.log_prob(samps,t0[:,None]))*2000.\n",
-    "    laplacian = jnp.sum( dphi2_dinp2( jnp.hstack([samps,t0[:,None]]) )[:,:3] , axis = 1)\n",
-    "    return jnp.sum(jnp.square(laplacian - 4.0*jnp.pi*G_val*density)) + jnp.sum(jnp.square( jnp.minimum(laplacian, 0) ))\n",
-    "\n",
-    "import optax  # https://github.com/deepmind/optax\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 201,
-   "id": "de80bc72-33c8-4333-ac2e-47862e925d05",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "0\n",
-      "10\n",
-      "20\n",
-      "30\n"
-     ]
-    },
-    {
-     "ename": "KeyboardInterrupt",
-     "evalue": "",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn[201], line 15\u001b[0m\n\u001b[1;32m     13\u001b[0m steps \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m200\u001b[39m\n\u001b[1;32m     14\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m step \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(steps):\n\u001b[0;32m---> 15\u001b[0m     loss, model, opt_state \u001b[38;5;241m=\u001b[39m \u001b[43mmake_step\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43mopt_state\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstep\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     16\u001b[0m     loss \u001b[38;5;241m=\u001b[39m loss\u001b[38;5;241m.\u001b[39mitem()\n\u001b[1;32m     17\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m step \u001b[38;5;241m%\u001b[39m \u001b[38;5;241m10\u001b[39m \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n",
-      "File \u001b[0;32m~/opt/anaconda3/envs/sml/lib/python3.10/site-packages/equinox/_jit.py:162\u001b[0m, in \u001b[0;36m_JitWrapper.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    160\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__call__\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m/\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m    161\u001b[0m     \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 162\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    163\u001b[0m     \u001b[38;5;28;01mexcept\u001b[39;00m XlaRuntimeError \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m    164\u001b[0m         \u001b[38;5;66;03m# Catch Equinox's runtime errors, and strip the more intimidating parts of\u001b[39;00m\n\u001b[1;32m    165\u001b[0m         \u001b[38;5;66;03m# the error message.\u001b[39;00m\n\u001b[1;32m    166\u001b[0m         \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(e\u001b[38;5;241m.\u001b[39margs) \u001b[38;5;241m!=\u001b[39m \u001b[38;5;241m1\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(e\u001b[38;5;241m.\u001b[39margs[\u001b[38;5;241m0\u001b[39m], \u001b[38;5;28mstr\u001b[39m):\n",
-      "File \u001b[0;32m~/opt/anaconda3/envs/sml/lib/python3.10/site-packages/equinox/_module.py:854\u001b[0m, in \u001b[0;36mBoundMethod.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    853\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__call__\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m--> 854\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;18;43m__func__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;18;43m__self__\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/opt/anaconda3/envs/sml/lib/python3.10/site-packages/equinox/_jit.py:157\u001b[0m, in \u001b[0;36m_JitWrapper._call\u001b[0;34m(self, is_lower, args, kwargs)\u001b[0m\n\u001b[1;32m    155\u001b[0m         out \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_cached(dynamic, static)\n\u001b[1;32m    156\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 157\u001b[0m     out \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_cached\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdynamic\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstatic\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    158\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _postprocess(out)\n",
-      "    \u001b[0;31m[... skipping hidden 1 frame]\u001b[0m\n",
-      "File \u001b[0;32m~/opt/anaconda3/envs/sml/lib/python3.10/site-packages/jax/_src/pjit.py:256\u001b[0m, in \u001b[0;36m_cpp_pjit.<locals>.cache_miss\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    254\u001b[0m \u001b[38;5;129m@api_boundary\u001b[39m\n\u001b[1;32m    255\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcache_miss\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m--> 256\u001b[0m   outs, out_flat, out_tree, args_flat, jaxpr \u001b[38;5;241m=\u001b[39m \u001b[43m_python_pjit_helper\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    257\u001b[0m \u001b[43m      \u001b[49m\u001b[43mfun\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minfer_params_fn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    258\u001b[0m   executable \u001b[38;5;241m=\u001b[39m _read_most_recent_pjit_call_executable(jaxpr)\n\u001b[1;32m    259\u001b[0m   fastpath_data \u001b[38;5;241m=\u001b[39m _get_fastpath_data(executable, out_tree, args_flat, out_flat)\n",
-      "File \u001b[0;32m~/opt/anaconda3/envs/sml/lib/python3.10/site-packages/jax/_src/pjit.py:167\u001b[0m, in \u001b[0;36m_python_pjit_helper\u001b[0;34m(fun, infer_params_fn, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m   dispatch\u001b[38;5;241m.\u001b[39mcheck_arg(arg)\n\u001b[1;32m    166\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 167\u001b[0m   out_flat \u001b[38;5;241m=\u001b[39m \u001b[43mpjit_p\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbind\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs_flat\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mparams\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    168\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m pxla\u001b[38;5;241m.\u001b[39mDeviceAssignmentMismatchError \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m    169\u001b[0m   fails, \u001b[38;5;241m=\u001b[39m e\u001b[38;5;241m.\u001b[39margs\n",
-      "File \u001b[0;32m~/opt/anaconda3/envs/sml/lib/python3.10/site-packages/jax/_src/core.py:2657\u001b[0m, in \u001b[0;36mAxisPrimitive.bind\u001b[0;34m(self, *args, **params)\u001b[0m\n\u001b[1;32m   2653\u001b[0m axis_main \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mmax\u001b[39m((axis_frame(a)\u001b[38;5;241m.\u001b[39mmain_trace \u001b[38;5;28;01mfor\u001b[39;00m a \u001b[38;5;129;01min\u001b[39;00m used_axis_names(\u001b[38;5;28mself\u001b[39m, params)),\n\u001b[1;32m   2654\u001b[0m                 default\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, key\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mlambda\u001b[39;00m t: \u001b[38;5;28mgetattr\u001b[39m(t, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mlevel\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m))\n\u001b[1;32m   2655\u001b[0m top_trace \u001b[38;5;241m=\u001b[39m (top_trace \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m axis_main \u001b[38;5;129;01mor\u001b[39;00m axis_main\u001b[38;5;241m.\u001b[39mlevel \u001b[38;5;241m<\u001b[39m top_trace\u001b[38;5;241m.\u001b[39mlevel\n\u001b[1;32m   2656\u001b[0m              \u001b[38;5;28;01melse\u001b[39;00m axis_main\u001b[38;5;241m.\u001b[39mwith_cur_sublevel())\n\u001b[0;32m-> 2657\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbind_with_trace\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtop_trace\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mparams\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/opt/anaconda3/envs/sml/lib/python3.10/site-packages/jax/_src/core.py:389\u001b[0m, in \u001b[0;36mPrimitive.bind_with_trace\u001b[0;34m(self, trace, args, params)\u001b[0m\n\u001b[1;32m    388\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mbind_with_trace\u001b[39m(\u001b[38;5;28mself\u001b[39m, trace, args, params):\n\u001b[0;32m--> 389\u001b[0m   out \u001b[38;5;241m=\u001b[39m \u001b[43mtrace\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mprocess_primitive\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mmap\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mtrace\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfull_raise\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mparams\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    390\u001b[0m   \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mmap\u001b[39m(full_lower, out) \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmultiple_results \u001b[38;5;28;01melse\u001b[39;00m full_lower(out)\n",
-      "File \u001b[0;32m~/opt/anaconda3/envs/sml/lib/python3.10/site-packages/jax/_src/core.py:869\u001b[0m, in \u001b[0;36mEvalTrace.process_primitive\u001b[0;34m(self, primitive, tracers, params)\u001b[0m\n\u001b[1;32m    868\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mprocess_primitive\u001b[39m(\u001b[38;5;28mself\u001b[39m, primitive, tracers, params):\n\u001b[0;32m--> 869\u001b[0m   \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mprimitive\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mimpl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mtracers\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mparams\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/opt/anaconda3/envs/sml/lib/python3.10/site-packages/jax/_src/pjit.py:1212\u001b[0m, in \u001b[0;36m_pjit_call_impl\u001b[0;34m(jaxpr, in_shardings, out_shardings, resource_env, donated_invars, name, keep_unused, inline, *args)\u001b[0m\n\u001b[1;32m   1209\u001b[0m donated_argnums \u001b[38;5;241m=\u001b[39m [i \u001b[38;5;28;01mfor\u001b[39;00m i, d \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(donated_invars) \u001b[38;5;28;01mif\u001b[39;00m d]\n\u001b[1;32m   1210\u001b[0m has_explicit_sharding \u001b[38;5;241m=\u001b[39m _pjit_explicit_sharding(\n\u001b[1;32m   1211\u001b[0m     in_shardings, out_shardings, \u001b[38;5;28;01mNone\u001b[39;00m, \u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[0;32m-> 1212\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mxc\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_xla\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpjit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcall_impl_cache_miss\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdonated_argnums\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1213\u001b[0m \u001b[43m                    \u001b[49m\u001b[43mtree_util\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdispatch_registry\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1214\u001b[0m \u001b[43m                    \u001b[49m\u001b[43m_get_cpp_global_cache\u001b[49m\u001b[43m(\u001b[49m\u001b[43mhas_explicit_sharding\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/opt/anaconda3/envs/sml/lib/python3.10/site-packages/jax/_src/pjit.py:1196\u001b[0m, in \u001b[0;36m_pjit_call_impl.<locals>.call_impl_cache_miss\u001b[0;34m(*args_, **kwargs_)\u001b[0m\n\u001b[1;32m   1195\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcall_impl_cache_miss\u001b[39m(\u001b[38;5;241m*\u001b[39margs_, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs_):\n\u001b[0;32m-> 1196\u001b[0m   out_flat, compiled \u001b[38;5;241m=\u001b[39m \u001b[43m_pjit_call_impl_python\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m   1197\u001b[0m \u001b[43m      \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mjaxpr\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mjaxpr\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43min_shardings\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43min_shardings\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1198\u001b[0m \u001b[43m      \u001b[49m\u001b[43mout_shardings\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mout_shardings\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mresource_env\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mresource_env\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1199\u001b[0m \u001b[43m      \u001b[49m\u001b[43mdonated_invars\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdonated_invars\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkeep_unused\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mkeep_unused\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1200\u001b[0m \u001b[43m      \u001b[49m\u001b[43minline\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minline\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1201\u001b[0m   fastpath_data \u001b[38;5;241m=\u001b[39m _get_fastpath_data(\n\u001b[1;32m   1202\u001b[0m       compiled, tree_structure(out_flat), args, out_flat)\n\u001b[1;32m   1203\u001b[0m   \u001b[38;5;28;01mreturn\u001b[39;00m out_flat, fastpath_data\n",
-      "File \u001b[0;32m~/opt/anaconda3/envs/sml/lib/python3.10/site-packages/jax/_src/pjit.py:1132\u001b[0m, in \u001b[0;36m_pjit_call_impl_python\u001b[0;34m(jaxpr, in_shardings, out_shardings, resource_env, donated_invars, name, keep_unused, inline, *args)\u001b[0m\n\u001b[1;32m   1123\u001b[0m \u001b[38;5;28;01mglobal\u001b[39;00m _most_recent_pjit_call_executable\n\u001b[1;32m   1125\u001b[0m in_shardings \u001b[38;5;241m=\u001b[39m _resolve_in_shardings(\n\u001b[1;32m   1126\u001b[0m     args, in_shardings, out_shardings,\n\u001b[1;32m   1127\u001b[0m     resource_env\u001b[38;5;241m.\u001b[39mphysical_mesh \u001b[38;5;28;01mif\u001b[39;00m resource_env \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[1;32m   1129\u001b[0m compiled \u001b[38;5;241m=\u001b[39m \u001b[43m_pjit_lower\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m   1130\u001b[0m \u001b[43m    \u001b[49m\u001b[43mjaxpr\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43min_shardings\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mout_shardings\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mresource_env\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1131\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdonated_invars\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkeep_unused\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minline\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m-> 1132\u001b[0m \u001b[43m    \u001b[49m\u001b[43mlowering_parameters\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmlir\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mLoweringParameters\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcompile\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1133\u001b[0m _most_recent_pjit_call_executable\u001b[38;5;241m.\u001b[39mweak_key_dict[jaxpr] \u001b[38;5;241m=\u001b[39m compiled\n\u001b[1;32m   1134\u001b[0m \u001b[38;5;66;03m# This check is expensive so only do it if enable_checks is on.\u001b[39;00m\n",
-      "File \u001b[0;32m~/opt/anaconda3/envs/sml/lib/python3.10/site-packages/jax/_src/interpreters/pxla.py:2276\u001b[0m, in \u001b[0;36mMeshComputation.compile\u001b[0;34m(self, compiler_options)\u001b[0m\n\u001b[1;32m   2274\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcompile\u001b[39m(\u001b[38;5;28mself\u001b[39m, compiler_options\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m MeshExecutable:\n\u001b[1;32m   2275\u001b[0m   \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_executable \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mor\u001b[39;00m compiler_options \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m-> 2276\u001b[0m     executable \u001b[38;5;241m=\u001b[39m \u001b[43mUnloadedMeshExecutable\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfrom_hlo\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m   2277\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_name\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_hlo\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcompile_args\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2278\u001b[0m \u001b[43m        \u001b[49m\u001b[43mcompiler_options\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcompiler_options\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   2279\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m compiler_options \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m   2280\u001b[0m       \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_executable \u001b[38;5;241m=\u001b[39m executable\n",
-      "File \u001b[0;32m~/opt/anaconda3/envs/sml/lib/python3.10/site-packages/jax/_src/interpreters/pxla.py:2624\u001b[0m, in \u001b[0;36mUnloadedMeshExecutable.from_hlo\u001b[0;34m(***failed resolving arguments***)\u001b[0m\n\u001b[1;32m   2621\u001b[0m       mesh \u001b[38;5;241m=\u001b[39m i\u001b[38;5;241m.\u001b[39mmesh  \u001b[38;5;66;03m# type: ignore\u001b[39;00m\n\u001b[1;32m   2622\u001b[0m       \u001b[38;5;28;01mbreak\u001b[39;00m\n\u001b[0;32m-> 2624\u001b[0m xla_executable, compile_options \u001b[38;5;241m=\u001b[39m \u001b[43m_cached_compilation\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m   2625\u001b[0m \u001b[43m    \u001b[49m\u001b[43mhlo\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmesh\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mspmd_lowering\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2626\u001b[0m \u001b[43m    \u001b[49m\u001b[43mtuple_args\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mauto_spmd_lowering\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mallow_prop_to_outputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2627\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;28;43mtuple\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mhost_callbacks\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbackend\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mda\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpmap_nreps\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2628\u001b[0m \u001b[43m    \u001b[49m\u001b[43mcompiler_options_keys\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcompiler_options_values\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   2630\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(backend, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcompile_replicated\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m   2631\u001b[0m   semantics_in_shardings \u001b[38;5;241m=\u001b[39m SemanticallyEqualShardings(in_shardings)  \u001b[38;5;66;03m# type: ignore\u001b[39;00m\n",
-      "File \u001b[0;32m~/opt/anaconda3/envs/sml/lib/python3.10/site-packages/jax/_src/interpreters/pxla.py:2531\u001b[0m, in \u001b[0;36m_cached_compilation\u001b[0;34m(computation, name, mesh, spmd_lowering, tuple_args, auto_spmd_lowering, _allow_propagation_to_outputs, host_callbacks, backend, da, pmap_nreps, compiler_options_keys, compiler_options_values)\u001b[0m\n\u001b[1;32m   2526\u001b[0m   \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m, compile_options\n\u001b[1;32m   2528\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m dispatch\u001b[38;5;241m.\u001b[39mlog_elapsed_time(\n\u001b[1;32m   2529\u001b[0m     \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mFinished XLA compilation of \u001b[39m\u001b[38;5;132;01m{fun_name}\u001b[39;00m\u001b[38;5;124m in \u001b[39m\u001b[38;5;132;01m{elapsed_time}\u001b[39;00m\u001b[38;5;124m sec\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m   2530\u001b[0m     fun_name\u001b[38;5;241m=\u001b[39mname, event\u001b[38;5;241m=\u001b[39mdispatch\u001b[38;5;241m.\u001b[39mBACKEND_COMPILE_EVENT):\n\u001b[0;32m-> 2531\u001b[0m   xla_executable \u001b[38;5;241m=\u001b[39m \u001b[43mcompiler\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcompile_or_get_cached\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m   2532\u001b[0m \u001b[43m      \u001b[49m\u001b[43mbackend\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcomputation\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdev\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcompile_options\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mhost_callbacks\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   2533\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m xla_executable, compile_options\n",
-      "File \u001b[0;32m~/opt/anaconda3/envs/sml/lib/python3.10/site-packages/jax/_src/compiler.py:294\u001b[0m, in \u001b[0;36mcompile_or_get_cached\u001b[0;34m(backend, computation, devices, compile_options, host_callbacks)\u001b[0m\n\u001b[1;32m    290\u001b[0m use_compilation_cache \u001b[38;5;241m=\u001b[39m (compilation_cache\u001b[38;5;241m.\u001b[39mis_initialized() \u001b[38;5;129;01mand\u001b[39;00m\n\u001b[1;32m    291\u001b[0m                          backend\u001b[38;5;241m.\u001b[39mplatform \u001b[38;5;129;01min\u001b[39;00m supported_platforms)\n\u001b[1;32m    293\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m use_compilation_cache:\n\u001b[0;32m--> 294\u001b[0m   \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mbackend_compile\u001b[49m\u001b[43m(\u001b[49m\u001b[43mbackend\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcomputation\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcompile_options\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    295\u001b[0m \u001b[43m                         \u001b[49m\u001b[43mhost_callbacks\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    297\u001b[0m \u001b[38;5;66;03m# TODO(b/293308239) Instrument a metric to track the adoption of the new cache\u001b[39;00m\n\u001b[1;32m    298\u001b[0m \u001b[38;5;66;03m# key implementation after it is enabled.\u001b[39;00m\n\u001b[1;32m    299\u001b[0m \u001b[38;5;28;01mglobal\u001b[39;00m _cache_used\n",
-      "File \u001b[0;32m~/opt/anaconda3/envs/sml/lib/python3.10/site-packages/jax/_src/profiler.py:314\u001b[0m, in \u001b[0;36mannotate_function.<locals>.wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    311\u001b[0m \u001b[38;5;129m@wraps\u001b[39m(func)\n\u001b[1;32m    312\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mwrapper\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m    313\u001b[0m   \u001b[38;5;28;01mwith\u001b[39;00m TraceAnnotation(name, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mdecorator_kwargs):\n\u001b[0;32m--> 314\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    315\u001b[0m   \u001b[38;5;28;01mreturn\u001b[39;00m wrapper\n",
-      "File \u001b[0;32m~/opt/anaconda3/envs/sml/lib/python3.10/site-packages/jax/_src/compiler.py:256\u001b[0m, in \u001b[0;36mbackend_compile\u001b[0;34m(backend, module, options, host_callbacks)\u001b[0m\n\u001b[1;32m    251\u001b[0m   \u001b[38;5;28;01mreturn\u001b[39;00m backend\u001b[38;5;241m.\u001b[39mcompile(built_c, compile_options\u001b[38;5;241m=\u001b[39moptions,\n\u001b[1;32m    252\u001b[0m                          host_callbacks\u001b[38;5;241m=\u001b[39mhost_callbacks)\n\u001b[1;32m    253\u001b[0m \u001b[38;5;66;03m# Some backends don't have `host_callbacks` option yet\u001b[39;00m\n\u001b[1;32m    254\u001b[0m \u001b[38;5;66;03m# TODO(sharadmv): remove this fallback when all backends allow `compile`\u001b[39;00m\n\u001b[1;32m    255\u001b[0m \u001b[38;5;66;03m# to take in `host_callbacks`\u001b[39;00m\n\u001b[0;32m--> 256\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mbackend\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcompile\u001b[49m\u001b[43m(\u001b[49m\u001b[43mbuilt_c\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcompile_options\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[43m)\u001b[49m\n",
-      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
-     ]
-    }
-   ],
-   "source": [
-    "# Important for efficiency whenever you use JAX: wrap everything into a single JIT\n",
-    " # region.\n",
-    "@eqx.filter_jit\n",
-    "def make_step(model,opt_state, ii):\n",
-    "    loss, grads = loss_func(model, ii)\n",
-    "    updates, opt_state = optim.update(grads, opt_state)\n",
-    "    model = eqx.apply_updates(model, updates)\n",
-    "    return loss, model, opt_state\n",
-    "learning_rate = 1e-2\n",
-    "optim = optax.adam(learning_rate)\n",
-    "opt_state = optim.init(model)\n",
-    "\n",
-    "steps = 200\n",
-    "for step in range(steps):\n",
-    "    loss, model, opt_state = make_step(model,opt_state, step)\n",
-    "    loss = loss.item()\n",
-    "    if step % 10 == 0:\n",
-    "        print(step)\n",
-    "    #print(f\"step={step}, loss={loss}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 202,
-   "id": "96b84a65-762a-4320-9c65-84b81ec85224",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "model_eval = lambda x: jax.vmap(model)(x).sum()\n",
-    "dphi_dinp = lambda x: jax.grad(model_eval)(x)\n",
-    "dphi_dinp_sum = lambda x: jax.grad(model_eval)(x).sum()\n",
-    "dphi2_dinp2 = lambda x: jax.grad(dphi_dinp_sum)(x)\n",
-    "\n",
-    "samps = flow_x_t.sample(key=key,condition=t0[:,None],sample_shape=())\n",
-    "density = jnp.exp(flow_x_t.log_prob(samps,t0[:,None]))*2000.\n",
-    "laplacian = jnp.sum( dphi2_dinp2( jnp.hstack([samps,t0[:,None]]) )[:,:3] , axis = 1)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 203,
-   "id": "027ceea2-b002-4cc2-88c9-d07e2cdcdaac",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "x = jnp.linspace(-10,10,30)\n",
-    "X,Y = jnp.meshgrid(x,x)\n",
-    "inp_test = jnp.vstack([X.flatten(),Y.flatten(),jnp.zeros_like(X.flatten()), jnp.zeros_like(X.flatten())]).T\n",
-    "laplacian = jnp.sum( dphi2_dinp2(  inp_test  )[:,:3] , axis = 1)\n",
-    "\n",
-    "density = jnp.exp(flow_x_t.log_prob(inp_test[:,:3], inp_test[:,-1][:,None]))*2000.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 204,
-   "id": "5e97b937-899f-45bf-93f4-1cc1933175c7",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.QuadMesh at 0x7fbd012da410>"
-      ]
-     },
-     "execution_count": 204,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "aa = laplacian.reshape(len(x),len(x))\n",
-    "plt.pcolormesh(X,Y,aa)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 135,
-   "id": "009f7dad-e3da-48dc-bb01-3be5aec23dba",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array([1.8537801e-05, 2.5734538e-05, 1.3212264e-06, ..., 4.9401220e-05,\n",
-       "       6.6881898e-06, 1.5206607e-06], dtype=float32)"
-      ]
-     },
-     "execution_count": 135,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "4*jnp.pi*G_val*density"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 85,
-   "id": "9d6b605a-c547-46d3-bc00-c12052dc9931",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Important for efficiency whenever you use JAX: wrap everything into a single JIT\n",
-    "# region.\n",
-    "@eqx.filter_jit\n",
-    "def make_step(model, opt_state):\n",
-    "        loss, grads = compute_loss(model, x, y)\n",
-    "        updates, opt_state = optim.update(grads, opt_state)\n",
-    "        model = eqx.apply_updates(model, updates)\n",
-    "        return loss, model, opt_state\n",
-    "\n",
-    "    optim = optax.adam(learning_rate)\n",
-    "    opt_state = optim.init(model)\n",
-    "    for step, (x, y) in zip(range(steps), iter_data):\n",
-    "        loss, model, opt_state = make_step(model, x, y, opt_state)\n",
-    "        loss = loss.item()\n",
-    "        print(f\"step={step}, loss={loss}\")\n",
-    "\n",
-    "    pred_ys = jax.vmap(model)(xs)\n",
-    "    num_correct = jnp.sum((pred_ys > 0.5) == ys)\n",
-    "    final_accuracy = (num_correct / dataset_size).item()\n",
-    "    print(f\"final_accuracy={final_accuracy}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "3885b7aa-988e-4021-978d-6d4b4ed319d2",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "8f135d31-add9-417a-9fd3-8acdb99685e2",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "982e49a9-995c-4969-a422-db0ba24e1cb3",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "3e96efbf-f67a-4aff-8dc4-dfd889d9191d",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 69,
-   "id": "936bae9f-cd8b-4f5a-850f-2b5a129c16e4",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array(0.00023171, dtype=float32)"
-      ]
-     },
-     "execution_count": 69,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "samps = flow_x_t.sample(key=key,condition=t0[:,None],sample_shape=())\n",
-    "density = jnp.exp(flow_x_t.log_prob(samps,t0[:,None]))*2000.\n",
-    "Laplacian = jnp.sum( dphi2_dinp2( jnp.hstack([samps,t0[:,None]]) )[:,:3] , axis = 1)\n",
-    "loss_func(density,Laplacian)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 67,
-   "id": "74a77ef0-a9e9-4ca7-93d8-543d772fdfcb",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(2000,)"
-      ]
-     },
-     "execution_count": 67,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "second_derivs.shape"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "e4425aec-7ba7-4ebc-98e7-cd93bab80868",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "f66e3e50-b98f-4984-9bba-48d8f771a1eb",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "f7d1774f-4511-4f58-bf42-155b8c440e48",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "1bd1cc3e-5d42-46be-b4b2-9d842766be3d",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "eb451c65-87eb-4bf6-a414-fd3ade6ca0b0",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "n_samples = 10000\n",
-    "rng = jr.PRNGKey(0)\n",
-    "x = two_moons(rng, n_samples)\n",
-    "#x = (x - x.mean(axis=0)) / x.std(axis=0)  # Standardize"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "id": "ca72845d-7ae3-4aea-963a-9b341d341cdf",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "key, subkey = jr.split(jr.PRNGKey(0))\n",
-    "base_dist = Normal(jnp.zeros(x.shape[1]))\n",
-    "flow = MaskedAutoregressiveFlow(\n",
-    "    subkey,\n",
-    "    base_dist,\n",
-    "    RationalQuadraticSpline(knots=8, interval=4),\n",
-    ")\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "id": "a9c1594a-e3ae-4154-ab65-c3ecec3fa0fe",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 34%|▎| 34/100 [00:26<00:50,  1.30it/s, train=2.4324656, val=2.4858453 (Max pati\n"
-     ]
-    }
-   ],
-   "source": [
-    "key, subkey = jr.split(key)\n",
-    "flow, losses = fit_to_data(subkey, flow, x, learning_rate=1e-3)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "id": "11278e6f-9e8b-4e2b-b94b-9cb6b5f5c26a",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Array([-2.4572847, -2.4572847, -2.4572847, -2.4572847, -2.4572847],      dtype=float32)"
-      ]
-     },
-     "execution_count": 19,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "five_points = jnp.ones((5, 2))\n",
-    "flow.log_prob(five_points)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "id": "6e925c06-2fec-430b-ac9b-5daa0e2e8e58",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "key, subkey = jr.split(key)\n",
-    "x_samples = flow.sample(subkey, (n_samples,))\n",
-    "\n",
-    "fig, axs = plt.subplots(ncols=2)\n",
-    "\n",
-    "axs[0].scatter(x[:, 0], x[:, 1], s=0.1)\n",
-    "axs[0].set_title(\"True samples\")\n",
-    "\n",
-    "axs[1].scatter(x_samples[:, 0], x_samples[:, 1], s=0.1)\n",
-    "axs[1].set_title(\"Flow samples\")\n",
-    "\n",
-    "lims = (-2.5, 2.5)\n",
-    "for ax in axs:\n",
-    "    ax.set_xlim(lims)\n",
-    "    ax.set_ylim(lims)\n",
-    "    ax.set_aspect(\"equal\")\n",
-    "\n",
-    "plt.tight_layout()\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "09599cb6-755f-47d8-8e3f-da483a877e00",
-   "metadata": {},
-   "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.8.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}