jaxion 0.0.1__py3-none-any.whl

jaxion/__init__.py

@@ -0,0 +1,2 @@
+from .simulation import Simulation as Simulation
+from .constants import constants as constants

jaxion/constants.py

@@ -0,0 +1,17 @@
+# Copyright (c) 2025 The Jaxion Team.
+
+# Physical Constants
+#
+# Jaxion uses a unit system of:
+# [L] = kpc
+# [V] = km/s
+# [M] = Msun
+#
+# other units are derived from these base units, e.g., [T] = [L]/[V] = kpc / (km/s) ~= 0.978 Gyr
+
+constants = {
+    "gravitational_constant": 4.30241002e-6,  # G / (kpc * (km/s)^2 / Msun)
+    "reduced_planck_constant": 1.71818134e-87,  # hbar / ((km/s) * kpc * mass of sun)
+    "electron_volt": 8.05478173e-56,  # eV / (mass of sun * (km/s)^2)
+    "speed_of_light": 299792.458,  # c / (km/s)
+}

jaxion/gravity.py

@@ -0,0 +1,9 @@
+import jax.numpy as jnp
+
+# Pure functions for gravity calculations
+
+
+def calculate_gravitational_potential(rho, k_sq, G, rho_bar):
+    Vhat = -jnp.fft.fftn(4.0 * jnp.pi * G * (rho - rho_bar)) / (k_sq + (k_sq == 0))
+    V = jnp.real(jnp.fft.ifftn(Vhat))
+    return V

jaxion/hydro.py

@@ -0,0 +1,231 @@
+import jax.numpy as jnp
+
+# Pure functions for hydro simulation
+
+
+def get_conserved(rho, vx, vy, vz, vol):
+    Mass = rho * vol
+    Momx = rho * vx * vol
+    Momy = rho * vy * vol
+    Momz = rho * vz * vol
+
+    return Mass, Momx, Momy, Momz
+
+
+def get_primitive(Mass, Momx, Momy, Momz, vol):
+    rho = Mass / vol
+    vx = Momx / Mass
+    vy = Momy / Mass
+    vz = Momz / Mass
+
+    return rho, vx, vy, vz
+
+
+def get_gradient(f, dx):
+    f_dx = (jnp.roll(f, -1, axis=0) - jnp.roll(f, 1, axis=0)) / (2.0 * dx)
+    f_dy = (jnp.roll(f, -1, axis=1) - jnp.roll(f, 1, axis=1)) / (2.0 * dx)
+    f_dz = (jnp.roll(f, -1, axis=2) - jnp.roll(f, 1, axis=2)) / (2.0 * dx)
+
+    return f_dx, f_dy, f_dz
+
+
+def extrap_to_face(f, f_dx, f_dy, f_dz, dx):
+    f_XL = f + 0.5 * f_dx * dx
+    f_XR = f - 0.5 * f_dx * dx
+    f_XR = jnp.roll(f_XR, -1, axis=0)
+
+    f_YL = f + 0.5 * f_dy * dx
+    f_YR = f - 0.5 * f_dy * dx
+    f_YR = jnp.roll(f_YR, -1, axis=1)
+
+    f_ZL = f + 0.5 * f_dz * dx
+    f_ZR = f - 0.5 * f_dz * dx
+    f_ZR = jnp.roll(f_ZR, -1, axis=2)
+
+    return f_XL, f_XR, f_YL, f_YR, f_ZL, f_ZR
+
+
+def apply_fluxes(F, flux_F_X, flux_F_Y, flux_F_Z, dx, dt):
+    fac = dt * dx * dx
+    F += -fac * flux_F_X
+    F += fac * jnp.roll(flux_F_X, 1, axis=0)
+
+    F += -fac * flux_F_Y
+    F += fac * jnp.roll(flux_F_Y, 1, axis=1)
+
+    F += -fac * flux_F_Z
+    F += fac * jnp.roll(flux_F_Z, 1, axis=2)
+
+    return F
+
+
+def get_flux(rho_L, vx_L, vy_L, vz_L, rho_R, vx_R, vy_R, vz_R, cs):
+    # compute star (averaged) states
+    rho_star = 0.5 * (rho_L + rho_R)
+    momx_star = 0.5 * (rho_L * vx_L + rho_R * vx_R)
+    momy_star = 0.5 * (rho_L * vy_L + rho_R * vy_R)
+    momz_star = 0.5 * (rho_L * vz_L + rho_R * vz_R)
+
+    P_star = rho_star * cs * cs
+
+    # compute fluxes (local Lax-Friedrichs/Rusanov)
+    flux_Mass = momx_star
+    flux_Momx = momx_star**2 / rho_star + P_star
+    flux_Momy = momx_star * momy_star / rho_star
+    flux_Momz = momx_star * momz_star / rho_star
+
+    # find wavespeeds
+    C_L = cs + jnp.abs(vx_L)
+    C_R = cs + jnp.abs(vx_R)
+    C = jnp.maximum(C_L, C_R)
+
+    # add stabilizing diffusive term
+    flux_Mass -= C * 0.5 * (rho_R - rho_L)
+    flux_Momx -= C * 0.5 * (rho_R * vx_R - rho_L * vx_L)
+    flux_Momy -= C * 0.5 * (rho_R * vy_R - rho_L * vy_L)
+    flux_Momz -= C * 0.5 * (rho_R * vz_R - rho_L * vz_L)
+
+    return flux_Mass, flux_Momx, flux_Momy, flux_Momz
+
+
+def hydro_accelerate(vx, vy, vz, V, kx, ky, kz, dt):
+    V_hat = jnp.fft.fftn(V)
+
+    ax = -jnp.real(jnp.fft.ifftn(1.0j * kx * V_hat))
+    ay = -jnp.real(jnp.fft.ifftn(1.0j * ky * V_hat))
+    az = -jnp.real(jnp.fft.ifftn(1.0j * kz * V_hat))
+
+    vx += ax * dt
+    vy += ay * dt
+    vz += az * dt
+
+    return vx, vy, vz
+
+
+def hydro_fluxes(rho, vx, vy, vz, dt, dx, cs):
+    # calculate gradients
+    rho_dx, rho_dy, rho_dz = get_gradient(rho, dx)
+    vx_dx, vx_dy, vx_dz = get_gradient(vx, dx)
+    vy_dx, vy_dy, vy_dz = get_gradient(vy, dx)
+    vz_dx, vz_dy, vz_dz = get_gradient(vz, dx)
+
+    # slope limit gradients
+    rho_dx, rho_dy, rho_dz = slope_limiter(rho, dx, rho_dx, rho_dy, rho_dz)
+    vx_dx, vx_dy, vx_dz = slope_limiter(vx, dx, vx_dx, vx_dy, vx_dz)
+    vy_dx, vy_dy, vy_dz = slope_limiter(vy, dx, vy_dx, vy_dy, vy_dz)
+    vz_dx, vz_dy, vz_dz = slope_limiter(vz, dx, vz_dx, vz_dy, vz_dz)
+
+    # extrapolate half-step in time
+    rho_prime = rho - 0.5 * dt * (
+        vx * rho_dx
+        + rho * vx_dx
+        + vy * rho_dy
+        + rho * vy_dy
+        + vz * rho_dz
+        + rho * vz_dz
+    )
+    vx_prime = vx - 0.5 * dt * (
+        vx * vx_dx + vy * vx_dy + vz * vx_dz + (1.0 / rho) * rho_dx * cs * cs
+    )
+    vy_prime = vy - 0.5 * dt * (
+        vx * vy_dx + vy * vy_dy + vz * vy_dz + (1.0 / rho) * rho_dy * cs * cs
+    )
+    vz_prime = vz - 0.5 * dt * (
+        vx * vz_dx + vy * vz_dy + vz * vz_dz + (1.0 / rho) * rho_dz * cs * cs
+    )
+
+    # extrapolate in space to face centers
+    rho_XL, rho_XR, rho_YL, rho_YR, rho_ZL, rho_ZR = extrap_to_face(
+        rho_prime, rho_dx, rho_dy, rho_dz, dx
+    )
+    vx_XL, vx_XR, vx_YL, vx_YR, vx_ZL, vx_ZR = extrap_to_face(
+        vx_prime, vx_dx, vx_dy, vx_dz, dx
+    )
+    vy_XL, vy_XR, vy_YL, vy_YR, vy_ZL, vy_ZR = extrap_to_face(
+        vy_prime, vy_dx, vy_dy, vy_dz, dx
+    )
+    vz_XL, vz_XR, vz_YL, vz_YR, vz_ZL, vz_ZR = extrap_to_face(
+        vz_prime, vz_dx, vz_dy, vz_dz, dx
+    )
+
+    # compute fluxes (local Lax-Friedrichs/Rusanov)
+    flux_Mass_X, flux_Momx_X, flux_Momy_X, flux_Momz_X = get_flux(
+        rho_XL, vx_XL, vy_XL, vz_XL, rho_XR, vx_XR, vy_XR, vz_XR, cs
+    )
+    flux_Mass_Y, flux_Momy_Y, flux_Momz_Y, flux_Momx_Y = get_flux(
+        rho_YL, vy_YL, vz_YL, vx_YL, rho_YR, vy_YR, vz_YR, vx_YR, cs
+    )
+    flux_Mass_Z, flux_Momz_Z, flux_Momx_Z, flux_Momy_Z = get_flux(
+        rho_ZL, vz_ZL, vx_ZL, vy_ZL, rho_ZR, vz_ZR, vx_ZR, vy_ZR, cs
+    )
+
+    Mass, Momx, Momy, Momz = get_conserved(rho, vx, vy, vz, dx**3)
+
+    # update solution
+    Mass = apply_fluxes(Mass, flux_Mass_X, flux_Mass_Y, flux_Mass_Z, dx, dt)
+    Momx = apply_fluxes(Momx, flux_Momx_X, flux_Momx_Y, flux_Momx_Z, dx, dt)
+    Momy = apply_fluxes(Momy, flux_Momy_X, flux_Momy_Y, flux_Momy_Z, dx, dt)
+    Momz = apply_fluxes(Momz, flux_Momz_X, flux_Momz_Y, flux_Momz_Z, dx, dt)
+
+    # get Primitive variables
+    rho, vx, vy, vz = get_primitive(Mass, Momx, Momy, Momz, dx**3)
+
+    return rho, vx, vy, vz
+
+
+def slope_limiter(f, dx, f_dx, f_dy, f_dz):
+    """
+    Apply slope limiter to slopes (minmod)
+    """
+
+    eps = 1.0e-12
+
+    # Keep a copy of the original slopes
+    orig_f_dx = f_dx
+    orig_f_dy = f_dy
+    orig_f_dz = f_dz
+
+    # Function to adjust the denominator safely
+    def adjust_denominator(denom):
+        denom_safe = jnp.where(
+            denom > 0, denom + eps, jnp.where(denom < 0, denom - eps, eps)
+        )
+        return denom_safe
+
+    # For x-direction
+    denom = adjust_denominator(orig_f_dx)
+    num = (f - jnp.roll(f, 1, axis=0)) / dx
+    ratio = num / denom
+    limiter = jnp.maximum(0.0, jnp.minimum(1.0, ratio))
+    f_dx = limiter * f_dx
+
+    num = -(f - jnp.roll(f, -1, axis=0)) / dx
+    ratio = num / denom  # Use the same adjusted denominator
+    limiter = jnp.maximum(0.0, jnp.minimum(1.0, ratio))
+    f_dx = limiter * f_dx
+
+    # For y-direction
+    denom = adjust_denominator(orig_f_dy)
+    num = (f - jnp.roll(f, 1, axis=1)) / dx
+    ratio = num / denom
+    limiter = jnp.maximum(0.0, jnp.minimum(1.0, ratio))
+    f_dy = limiter * f_dy
+
+    num = -(f - jnp.roll(f, -1, axis=1)) / dx
+    ratio = num / denom
+    limiter = jnp.maximum(0.0, jnp.minimum(1.0, ratio))
+    f_dy = limiter * f_dy
+
+    # For z-direction
+    denom = adjust_denominator(orig_f_dz)
+    num = (f - jnp.roll(f, 1, axis=2)) / dx
+    ratio = num / denom
+    limiter = jnp.maximum(0.0, jnp.minimum(1.0, ratio))
+    f_dz = limiter * f_dz
+
+    num = -(f - jnp.roll(f, -1, axis=2)) / dx
+    ratio = num / denom
+    limiter = jnp.maximum(0.0, jnp.minimum(1.0, ratio))
+    f_dz = limiter * f_dz
+
+    return f_dx, f_dy, f_dz

jaxion/params_default.json

@@ -0,0 +1,77 @@
+{
+  "physics": {
+    "quantum": { 
+      "default": true,
+      "description": "switch on for fuzzy dark matter."
+    },
+    "gravity": { 
+      "default": true,
+      "description": "switch on for self-gravity."
+    },
+    "hydro": { 
+      "default": false,
+      "description": "switch on for hydrodynamics (isothermal)."
+    },
+    "particles": { 
+      "default": false,
+      "description": "switch on for particle-mesh particles."
+    },
+    "cosmology": { 
+      "default": false,
+      "description": "switch on for cosmological factors/comoving units."
+    },
+    "external_potential": { 
+      "default": false,
+      "description": "switch on for external gravitational potential."
+    }
+  },
+  "domain": {
+    "box_size": { 
+      "default": 10.0,
+      "description": "periodic domain box size (kpc)."
+    },
+    "resolution_base": { 
+      "default": 32,
+      "description": "base resolution per linear dimension."
+    },
+    "resolution_multiplier": { 
+      "default": 1,
+      "description": "resolution multiplier."
+    }
+  },
+  "time": {
+    "start": 0.0,
+    "end": 1.0,
+    "adaptive": false
+  },
+  "output": {
+    "path": "./checkpoints",
+    "num_checkpoints": 100,
+    "save": true,
+    "plot_dynamic_range": 100.0
+  },
+  "quantum": {
+    "m_22": { 
+      "default": 1.0,
+      "description": "axion mass in units of 10^{-22} eV."
+    }
+  },
+  "hydro": {
+    "sound_speed": { 
+      "default": 1.0,
+      "description": "Isothermal sound speed (km/s)."
+    }
+  },
+  "particles": {
+    "num_particles": 0,
+    "particle_mass": 1.0
+  },
+  "cosmology": {
+    "Omega_m": 0.3,
+    "Omega_Lambda": 0.7
+  },
+  "version": {
+    "default": "unknown",
+    "description": "version of the jaxion library used to create these parameters (automatically detected)."
+  }
+}

jaxion/particles.py

@@ -0,0 +1,113 @@
+import jax
+import jax.numpy as jnp
+
+# Pure functions for particle-mesh calculations (stars, BHs, ...)
+
+
+def get_cic_indices_and_weights(pos, dx, resolution):
+    """Compute the cloud-in-cell indices and weights for the particle positions."""
+    nx = resolution
+    dxs = jnp.array([dx, dx, dx])
+    i = jnp.floor((pos - 0.5 * dxs) / dxs)
+    ip1 = i + 1.0
+    weight_i = ((ip1 + 0.5) * dxs - pos) / dxs
+    weight_ip1 = (pos - (i + 0.5) * dxs) / dxs
+    i = jnp.mod(i, jnp.array([nx, nx, nx])).astype(int)
+    ip1 = jnp.mod(ip1, jnp.array([nx, nx, nx])).astype(int)
+    return i, ip1, weight_i, weight_ip1
+
+
+def bin_particles(pos, dx, resolution, m_particle):
+    """Bin the particles into the grid using cloud-in-cell weights."""
+    nx = resolution
+    n_particle = pos.shape[0]
+    rho = jnp.zeros((nx, nx, nx))
+    i, ip1, w_i, w_ip1 = get_cic_indices_and_weights(pos, dx, resolution)
+
+    def deposit_particle(s, rho):
+        """Deposit the particle mass into the grid."""
+        fac = m_particle / (dx * dx * dx)
+        rho = rho.at[i[s, 0], i[s, 1], i[s, 2]].add(
+            w_i[s, 0] * w_i[s, 1] * w_i[s, 2] * fac
+        )
+        rho = rho.at[ip1[s, 0], i[s, 1], i[s, 2]].add(
+            w_ip1[s, 0] * w_i[s, 1] * w_i[s, 2] * fac
+        )
+        rho = rho.at[i[s, 0], ip1[s, 1], i[s, 2]].add(
+            w_i[s, 0] * w_ip1[s, 1] * w_i[s, 2] * fac
+        )
+        rho = rho.at[i[s, 0], i[s, 1], ip1[s, 2]].add(
+            w_i[s, 0] * w_i[s, 1] * w_ip1[s, 2] * fac
+        )
+        rho = rho.at[ip1[s, 0], ip1[s, 1], i[s, 2]].add(
+            w_ip1[s, 0] * w_ip1[s, 1] * w_i[s, 2] * fac
+        )
+        rho = rho.at[ip1[s, 0], i[s, 1], ip1[s, 2]].add(
+            w_ip1[s, 0] * w_i[s, 1] * w_ip1[s, 2] * fac
+        )
+        rho = rho.at[i[s, 0], ip1[s, 1], ip1[s, 2]].add(
+            w_i[s, 0] * w_ip1[s, 1] * w_ip1[s, 2] * fac
+        )
+        rho = rho.at[ip1[s, 0], ip1[s, 1], ip1[s, 2]].add(
+            w_ip1[s, 0] * w_ip1[s, 1] * w_ip1[s, 2] * fac
+        )
+        return rho
+
+    rho = jax.lax.fori_loop(0, n_particle, deposit_particle, rho)
+    return rho
+
+
+def get_acceleration(pos, V, kx, ky, kz, dx):
+    """Compute the acceleration of the particles."""
+    n_particle = pos.shape[0]
+    resolution = V.shape[0]
+    i, ip1, w_i, w_ip1 = get_cic_indices_and_weights(pos, dx, resolution)
+
+    # find accelerations on the grid
+    V_hat = jnp.fft.fftn(V)
+    ax = -jnp.real(jnp.fft.ifftn(1.0j * kx * V_hat))
+    ay = -jnp.real(jnp.fft.ifftn(1.0j * ky * V_hat))
+    az = -jnp.real(jnp.fft.ifftn(1.0j * kz * V_hat))
+    a_grid = jnp.stack((ax, ay, az), axis=-1)
+
+    # interpolate the accelerations to the particle positions
+    acc = jnp.zeros((n_particle, 3))
+    acc += (w_i[:, 0] * w_i[:, 1] * w_i[:, 2])[:, None] * a_grid[
+        i[:, 0], i[:, 1], i[:, 2]
+    ]
+    acc += (w_ip1[:, 0] * w_i[:, 1] * w_i[:, 2])[:, None] * a_grid[
+        ip1[:, 0], i[:, 1], i[:, 2]
+    ]
+    acc += (w_i[:, 0] * w_ip1[:, 1] * w_i[:, 2])[:, None] * a_grid[
+        i[:, 0], ip1[:, 1], i[:, 2]
+    ]
+    acc += (w_i[:, 0] * w_i[:, 1] * w_ip1[:, 2])[:, None] * a_grid[
+        i[:, 0], i[:, 1], ip1[:, 2]
+    ]
+    acc += (w_ip1[:, 0] * w_ip1[:, 1] * w_i[:, 2])[:, None] * a_grid[
+        ip1[:, 0], ip1[:, 1], i[:, 2]
+    ]
+    acc += (w_ip1[:, 0] * w_i[:, 1] * w_ip1[:, 2])[:, None] * a_grid[
+        ip1[:, 0], i[:, 1], ip1[:, 2]
+    ]
+    acc += (w_i[:, 0] * w_ip1[:, 1] * w_ip1[:, 2])[:, None] * a_grid[
+        i[:, 0], ip1[:, 1], ip1[:, 2]
+    ]
+    acc += (w_ip1[:, 0] * w_ip1[:, 1] * w_ip1[:, 2])[:, None] * a_grid[
+        ip1[:, 0], ip1[:, 1], ip1[:, 2]
+    ]
+    return acc
+
+
+def particles_accelerate(vel, pos, V, kx, ky, kz, dx, dt):
+    """Apply the acceleration to the particles."""
+    acc = get_acceleration(pos, V, kx, ky, kz, dx)
+    vel += acc * dt
+    return vel
+
+
+def particles_drift(pos, vel, dt, box_size):
+    pos += vel * dt
+    pos = jnp.mod(pos, jnp.array([box_size, box_size, box_size]))
+
+    return pos

jaxion/quantum.py

@@ -0,0 +1,15 @@
+import jax.numpy as jnp
+
+# Pure functions for quantum simulation
+
+
+def quantum_kick(psi, V, m_per_hbar, dt):
+    psi = jnp.exp(-1.0j * m_per_hbar * dt * V) * psi
+    return psi
+
+
+def quantum_drift(psi, k_sq, m_per_hbar, dt):
+    psi_hat = jnp.fft.fftn(psi)
+    psi_hat = jnp.exp(dt * (-1.0j * k_sq / m_per_hbar / 2.0)) * psi_hat
+    psi = jnp.fft.ifftn(psi_hat)
+    return psi

jaxion/simulation.py

@@ -0,0 +1,284 @@
+import jax
+import jax.numpy as jnp
+import orbax.checkpoint as ocp
+import os
+import json
+import time
+
+from .constants import constants
+from .quantum import quantum_kick, quantum_drift
+from .gravity import calculate_gravitational_potential
+from .hydro import hydro_fluxes, hydro_accelerate
+from .particles import particles_accelerate, particles_drift, bin_particles
+from .utils import set_up_parameters, print_parameters
+from .visualization import plot_sim
+
+
+class Simulation:
+    """
+    Simulation: The base class for an astrophysics simulation.
+
+    Parameters
+    ----------
+      params (dict): The Python dictionary that contains the simulation parameters.
+
+    """
+
+    def __init__(self, params):
+        # start from default simulation parameters and update with user params
+        self._params = set_up_parameters(params)
+
+        # additional checks
+        if self.resolution % 2 != 0:
+            raise ValueError("Resolution must be divisible by 2.")
+
+        if self.params["output"]["save"]:
+            print("Simulation initialized with parameters:")
+            print_parameters(self.params)
+
+        # simulation state
+        self.state = {}
+        self.state["t"] = 0.0
+        if self.params["physics"]["quantum"]:
+            self.state["psi"] = (
+                jnp.zeros((self.resolution, self.resolution, self.resolution)) * 1j
+            )
+        if self.params["physics"]["external_potential"]:
+            self.state["V_ext"] = jnp.zeros(
+                (self.resolution, self.resolution, self.resolution)
+            )
+        if self.params["physics"]["hydro"]:
+            self.state["rho"] = jnp.zeros(
+                (self.resolution, self.resolution, self.resolution)
+            )
+            self.state["vx"] = jnp.zeros(
+                (self.resolution, self.resolution, self.resolution)
+            )
+            self.state["vy"] = jnp.zeros(
+                (self.resolution, self.resolution, self.resolution)
+            )
+            self.state["vz"] = jnp.zeros(
+                (self.resolution, self.resolution, self.resolution)
+            )
+        if self.params["physics"]["particles"]:
+            self.state["pos"] = jnp.zeros((self.num_particles, 3))
+            self.state["vel"] = jnp.zeros((self.num_particles, 3))
+
+    @property
+    def resolution(self):
+        return (
+            self.params["domain"]["resolution_base"]
+            * self.params["domain"]["resolution_multiplier"]
+        )
+
+    @property
+    def num_particles(self):
+        return self.params["particles"]["num_particles"]
+
+    @property
+    def box_size(self):
+        return self.params["domain"]["box_size"]
+
+    @property
+    def dx(self):
+        return self.box_size / self.resolution
+
+    @property
+    def axion_mass(self):
+        return (
+            self.params["quantum"]["m_22"]
+            * 1.0e-22
+            * constants["electron_volt"]
+            / constants["speed_of_light"] ** 2
+        )
+
+    @property
+    def sound_speed(self):
+        return self.params["hydro"]["sound_speed"]
+
+    @property
+    def params(self):
+        return self._params
+
+    @property
+    def grid(self):
+        hx = 0.5 * self.dx
+        x_lin = jnp.linspace(hx, self.box_size - hx, self.resolution)
+        X, Y, Z = jnp.meshgrid(x_lin, x_lin, x_lin, indexing="ij")
+        return X, Y, Z
+
+    @property
+    def kgrid(self):
+        nx = self.resolution
+        k_lin = (2.0 * jnp.pi / self.box_size) * jnp.arange(-nx / 2, nx / 2)
+        kx, ky, kz = jnp.meshgrid(k_lin, k_lin, k_lin, indexing="ij")
+        kx = jnp.fft.ifftshift(kx)
+        ky = jnp.fft.ifftshift(ky)
+        kz = jnp.fft.ifftshift(kz)
+        return kx, ky, kz
+
+    def _calc_rho_bar(self, state):
+        rho_bar = 0.0
+        if self.params["physics"]["quantum"]:
+            rho_bar += jnp.mean(jnp.abs(state["psi"]) ** 2)
+        if self.params["physics"]["hydro"]:
+            rho_bar += jnp.mean(state["rho"])
+        if self.params["physics"]["particles"]:
+            m_particle = self.params["particles"]["particle_mass"]
+            n_particles = self.num_particles
+            box_size = self.box_size
+            rho_bar += m_particle * n_particles / box_size
+        return rho_bar
+
+    def _calc_grav_potential(self, state, k_sq):
+        G = constants["gravitational_constant"]
+        m_particle = self.params["particles"]["particle_mass"]
+        rho_bar = self._calc_rho_bar(self.state)
+        rho_tot = 0.0
+        if self.params["physics"]["quantum"]:
+            rho_tot += jnp.abs(state["psi"]) ** 2
+        if self.params["physics"]["hydro"]:
+            rho_tot += state["rho"]
+        if self.params["physics"]["particles"]:
+            rho_tot += bin_particles(state["pos"], self.dx, self.resolution, m_particle)
+        return calculate_gravitational_potential(rho_tot, k_sq, G, rho_bar)
+
+    @property
+    def potential(self):
+        kx, ky, kz = self.kgrid
+        k_sq = kx**2 + ky**2 + kz**2
+        return self._calc_grav_potential(self.state, k_sq)
+
+    def _evolve(self, state):
+        """
+        This function evolves the simulation state according to the simulation parameters/physics.
+
+        Parameters
+        ----------
+        state: jax.pytree
+          The current state of the simulation.
+
+        Returns
+        -------
+        state: jax.pytree
+          The evolved state of the simulation.
+        """
+
+        # Simulation parameters
+        dx = self.dx
+        m_per_hbar = self.axion_mass / constants["reduced_planck_constant"]
+
+        dt_fac = 1.0
+        dt_kin = dt_fac * (m_per_hbar / 6.0) * (dx * dx)
+        t_end = self.params["time"]["end"]
+
+        c_sound = self.params["hydro"]["sound_speed"]
+        box_size = self.box_size
+
+        # round up to the nearest multiple of num_checkpoints
+        num_checkpoints = self.params["output"]["num_checkpoints"]
+        nt = int(round(round(t_end / dt_kin) / num_checkpoints) * num_checkpoints)
+        nt_sub = int(round(nt / num_checkpoints))
+        dt = t_end / nt
+
+        # Fourier space variables
+        if self.params["physics"]["gravity"] or self.params["physics"]["quantum"]:
+            kx, ky, kz = self.kgrid
+            k_sq = kx**2 + ky**2 + kz**2
+
+        # Checkpointer
+        if self.params["output"]["save"]:
+            options = ocp.CheckpointManagerOptions()
+            checkpoint_dir = checkpoint_dir = os.path.join(
+                os.getcwd(), self.params["output"]["path"]
+            )
+            path = ocp.test_utils.erase_and_create_empty(checkpoint_dir)
+            async_checkpoint_manager = ocp.CheckpointManager(path, options=options)
+
+        def _kick(state, dt):
+            # Kick (half-step)
+            if (
+                self.params["physics"]["gravity"]
+                and self.params["physics"]["external_potential"]
+            ):
+                V = self._calc_grav_potential(state, k_sq) + state["V_ext"]
+            elif self.params["physics"]["gravity"]:
+                V = self._calc_grav_potential(state, k_sq)
+            elif self.params["physics"]["external_potential"]:
+                V = state["V_ext"]
+
+            if (
+                self.params["physics"]["gravity"]
+                or self.params["physics"]["external_potential"]
+            ):
+                if self.params["physics"]["quantum"]:
+                    state["psi"] = quantum_kick(state["psi"], V, m_per_hbar, dt)
+                if self.params["physics"]["hydro"]:
+                    state["vx"], state["vy"], state["vz"] = hydro_accelerate(
+                        state["vx"], state["vy"], state["vz"], V, kx, ky, kz, dt
+                    )
+                if self.params["physics"]["particles"]:
+                    state["vel"] = particles_accelerate(
+                        state["vel"], state["pos"], V, kx, ky, kz, dx, dt
+                    )
+
+        def _drift(state, dt):
+            # Drift (full-step)
+            if self.params["physics"]["quantum"]:
+                state["psi"] = quantum_drift(state["psi"], k_sq, m_per_hbar, dt)
+            if self.params["physics"]["hydro"]:
+                state["rho"], state["vx"], state["vy"], state["vz"] = hydro_fluxes(
+                    state["rho"], state["vx"], state["vy"], state["vz"], dt, dx, c_sound
+                )
+            if self.params["physics"]["particles"]:
+                state["pos"] = particles_drift(state["pos"], state["vel"], dt, box_size)
+
+        @jax.jit
+        def _update(_, state):
+            # Update the simulation state by one timestep
+            # according to a 2nd-order `kick-drift-kick` scheme
+            _kick(state, 0.5 * dt)
+            _drift(state, dt)
+            _kick(state, 0.5 * dt)
+
+            # update time
+            state["t"] += dt
+
+            return state
+
+        # save initial state
+        print("Starting simulation ...")
+        if self.params["output"]["save"]:
+            with open(os.path.join(checkpoint_dir, "params.json"), "w") as f:
+                json.dump(self.params, f, indent=2)
+            async_checkpoint_manager.save(0, args=ocp.args.StandardSave(state))
+            plot_sim(state, checkpoint_dir, 0, self.params)
+            async_checkpoint_manager.wait_until_finished()
+
+        # Simulation Main Loop
+        t_start_timer = time.time()
+        if self.params["output"]["save"]:
+            for i in range(1, num_checkpoints + 1):
+                state = jax.lax.fori_loop(0, nt_sub, _update, init_val=state)
+                jax.block_until_ready(state)
+                # save state
+                async_checkpoint_manager.save(i, args=ocp.args.StandardSave(state))
+                percent = int(100 * i / num_checkpoints)
+                elapsed = time.time() - t_start_timer
+                est_total = elapsed / i * num_checkpoints
+                est_remaining = est_total - elapsed
+                print(
+                    f"{percent:.1f}%: estimated time remaining (s): {est_remaining:.1f}"
+                )
+                plot_sim(state, checkpoint_dir, i, self.params)
+                async_checkpoint_manager.wait_until_finished()
+        else:
+            state = jax.lax.fori_loop(0, nt, _update, init_val=state)
+        jax.block_until_ready(state)
+        print("Simulation Run Time (s): ", time.time() - t_start_timer)
+
+        return state
+
+    def run(self):
+        self.state = self._evolve(self.state)
+        jax.block_until_ready(self.state)

jaxion/utils.py

@@ -0,0 +1,92 @@
+import sys
+import os
+import importlib.util
+from pathlib import Path
+import importlib.resources
+import json
+from importlib.metadata import version
+
+
+def print_parameters(params):
+    print(json.dumps(params, indent=2))
+
+
+def set_up_parameters(user_overwrites):
+    # first load the default params
+    params_path = importlib.resources.files("jaxion") / "params_default.json"
+    with params_path.open("r", encoding="utf-8") as f:
+        params = json.load(f)
+
+    # go down to lowest level in dict and eliminate meta-data
+    params = _eliminate_metadata(params)
+
+    # update default values with user-supplied overwrites
+    params = _update_dicts(params, user_overwrites)
+
+    # detect jaxion version
+    params["version"] = version("jaxion")
+
+    return params
+
+
+def _eliminate_metadata(params):
+    for key, value in params.items():
+        if isinstance(value, dict):
+            if "default" not in value:
+                _eliminate_metadata(value)
+            else:
+                params[key] = value["default"]
+
+    return params
+
+
+def _update_dicts(orig_dict, new_dict):
+    for key, value in new_dict.items():
+        if (
+            key in orig_dict
+            and isinstance(orig_dict[key], dict)
+            and isinstance(value, dict)
+        ):
+            _update_dicts(orig_dict[key], value)
+        else:
+            if key in orig_dict:
+                if not isinstance(value, dict):
+                    orig_dict[key] = value
+                else:
+                    raise ValueError(
+                        f"Value: {value} for parameter key: {key} must be a value, not dict"
+                    )
+            else:
+                raise KeyError(f"Unknown parameter key: {key}")
+    return orig_dict
+
+
+def run_example_main(example_path, argv=None):
+    """
+    Utility to run an example script's main() as if from its directory, with optional argv patching.
+    Args:
+        example_path (str or Path): Path to the example script (e.g., 'examples/foo/foo.py')
+        argv (list, optional): List of arguments to patch sys.argv with. If None, uses [script_name].
+    """
+    example_path = Path(example_path)
+    example_dir = example_path.parent
+    script_name = example_path.name
+    old_cwd = os.getcwd()
+    old_argv = sys.argv.copy()
+    try:
+        spec = importlib.util.spec_from_file_location(
+            script_name.rstrip(".py"), example_path
+        )
+        os.chdir(example_dir)
+        sys.argv = [script_name] + (argv if argv is not None else [])
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[script_name.rstrip(".py")] = module
+        spec.loader.exec_module(module)
+        if hasattr(module, "main"):
+            result = module.main()
+        else:
+            raise AttributeError(f"No main() in {example_path}")
+    finally:
+        os.chdir(old_cwd)
+        sys.argv = old_argv
+    return result

jaxion/visualization.py

@@ -0,0 +1,74 @@
+import jax.numpy as jnp
+import matplotlib.pyplot as plt
+import os
+
+
+def plot_sim(state, checkpoint_dir, i, params):
+    """Plot the simulation state."""
+
+    dynamic_range = params["output"]["plot_dynamic_range"]
+
+    if params["physics"]["quantum"]:
+        plt.clf()
+
+        # DM projection
+        nx = state["psi"].shape[0]
+        rho_bar = jnp.mean(jnp.abs(state["psi"]) ** 2)
+        vmin = jnp.log10(rho_bar / dynamic_range)
+        vmax = jnp.log10(rho_bar * dynamic_range)
+
+        rho_proj_dm = jnp.log10(jnp.mean(jnp.abs(state["psi"]) ** 2, axis=2)).T
+        ax = plt.gca()
+        ax.imshow(
+            rho_proj_dm,
+            cmap="inferno",
+            origin="lower",
+            vmin=vmin,
+            vmax=vmax,
+            extent=[0, nx, 0, nx],
+        )
+        if params["physics"]["particles"]:
+            # draw particles
+            box_size = params["domain"]["box_size"]
+            sx = (state["pos"][:, 0] / box_size) * nx
+            sy = (state["pos"][:, 1] / box_size) * nx
+            plt.plot(sx, sy, color="cyan", marker=".", linestyle="None", markersize=2)
+        ax.set_aspect("equal")
+        ax.get_xaxis().set_visible(False)
+        ax.get_yaxis().set_visible(False)
+
+        plt.savefig(
+            os.path.join(checkpoint_dir, f"dm{i:03d}.png"),
+            bbox_inches="tight",
+            pad_inches=0,
+        )
+        plt.close()
+
+    if params["physics"]["hydro"]:
+        plt.clf()
+
+        # gas projection
+        nx = state["rho"].shape[0]
+        rho_bar = jnp.mean(state["rho"])
+        vmin = jnp.log10(rho_bar / dynamic_range)
+        vmax = jnp.log10(rho_bar * dynamic_range)
+        rho_proj_gas = jnp.log10(jnp.mean(state["rho"], axis=2)).T
+        ax = plt.gca()
+        ax.imshow(
+            rho_proj_gas,
+            cmap="viridis",
+            origin="lower",
+            vmin=vmin,
+            vmax=vmax,
+            extent=[0, nx, 0, nx],
+        )
+        ax.set_aspect("equal")
+        ax.get_xaxis().set_visible(False)
+        ax.get_yaxis().set_visible(False)
+
+        plt.savefig(
+            os.path.join(checkpoint_dir, f"gas{i:03d}.png"),
+            bbox_inches="tight",
+            pad_inches=0,
+        )
+        plt.close()

jaxion-0.0.1.dist-info/METADATA

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: jaxion
+Version: 0.0.1
+Summary: A differentiable simulation library for fuzzy dark matter in JAX
+Author-email: Philip Mocz <philip.mocz@gmail.com>
+License-Expression: Apache-2.0
+Project-URL: Documentation, https://jaxion.readthedocs.io
+Project-URL: Homepage, https://github.com/JaxionProject/jaxion
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jax==0.5.3
+Requires-Dist: jaxdecomp==0.2.7
+Requires-Dist: tensorflow
+Requires-Dist: orbax-checkpoint==0.11.18
+Requires-Dist: optax==0.2.5
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: setuptools>=70.1.1
+Provides-Extra: cuda12
+Requires-Dist: jax[cuda12]==0.5.3; extra == "cuda12"
+Dynamic: license-file
+
+# jaxion
+
+[![Repo Status][status-badge]][status-link]
+[![PyPI Version Status][pypi-badge]][pypi-link]
+[![Test Status][workflow-test-badge]][workflow-test-link]
+[![Readthedocs Status][docs-badge]][docs-link]
+[![License][license-badge]][license-link]
+
+[status-link]:         https://www.repostatus.org/#active
+[status-badge]:        https://www.repostatus.org/badges/latest/active.svg
+[pypi-link]:           https://pypi.org/project/jaxion
+[pypi-badge]:          https://img.shields.io/pypi/v/jaxion?label=PyPI&logo=pypi
+[workflow-test-link]:  https://github.com/JaxionProject/jaxion/actions/workflows/test-package.yml
+[workflow-test-badge]: https://github.com/JaxionProject/jaxion/actions/workflows/test-package.yml/badge.svg?event=push
+[docs-link]:           https://jaxion.readthedocs.io
+[docs-badge]:          https://readthedocs.org/projects/jaxion/badge
+[license-link]:        https://opensource.org/licenses/Apache-2.0
+[license-badge]:       https://img.shields.io/badge/License-Apache_2.0-blue.svg
+
+A simple JAX-powered simulation library for numerical experiments of fuzzy dark matter, stars, gas + more!
+
+Author: [Philip Mocz (@pmocz)](https://github.com/pmocz/)
+
+⚠️ Jaxion is currently being developed and is not yet ready for use. Check back later ⚠️
+
+Jaxion is built for multi-GPU scalability and is fully differentiable. It is a high-performance JAX-based simulation library for modeling fuzzy dark matter alongside stars, gas, and cosmological dynamics. Being differentiable, Jaxion can seemlessly integrate with piplines for inverse-problems, inference, optimization, and coupling to ML models.
+
+
+## Getting started
+
+Install with:
+
+```console
+pip install jaxion
+```
+
+or, for GPU support use:
+
+```console
+pip install jaxion[cuda12]
+```
+
+Check out the `examples/` directory for demonstrations of using Jaxion.
+
+
+## Links
+
+* [Code repository](https://github.com/JaxionProject/jaxion) on GitHub (this page).
+* [Documentation](https://jaxion.readthedocs.io) for up-to-date information about installing and running jaxion.
+
+
+## Cite this repository
+

jaxion-0.0.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+jaxion/__init__.py,sha256=gHrU_SvIBIbuYt-MeEeyiMyuJKwLjTTiz513OZ7CDHQ,95
+jaxion/constants.py,sha256=b0vgqtezIEGp4O5JRJo3YK3eQC8AN6hmV84-4pYWgmc,528
+jaxion/gravity.py,sha256=DdVOhAaoIPLXtW7ALrMK2umLPkStzxJ778l1SD2yMkY,266
+jaxion/hydro.py,sha256=3ZFNDhIaPBw4uTBqFbjJotCLkuKG8AvRcY1T78QQ96U,6953
+jaxion/params_default.json,sha256=4-XNPN52phGxYsP6FOeIJH0ALtICjrQxApotz-NhJEc,1782
+jaxion/particles.py,sha256=7oJBVyddfOXUDYxQuGIs8_ByL2Hu6jkuWE1MWtshFjk,3953
+jaxion/quantum.py,sha256=91tEotQhX1CB3HCaRCDARRPX_dEx58GIUCluY5RyPvA,377
+jaxion/simulation.py,sha256=KcIi91LHJO5K4M0gxU4qc7e4JEeOyW1HUZOYwt8FOG0,10385
+jaxion/utils.py,sha256=LCVx5_N9-6HsbENENOEz8tI6Czl0Z8Bit2icf1k4024,2880
+jaxion/visualization.py,sha256=WKID2_LFbbqXwmW_TLTnVznKYHfjiDKNbjD9xS4GfLc,2209
+jaxion-0.0.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+jaxion-0.0.1.dist-info/METADATA,sha256=HrFYMTjSNAo8RqT9PPP1kSqyjVpi1v-N-sheaxU_YAs,2811
+jaxion-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+jaxion-0.0.1.dist-info/top_level.txt,sha256=S1OV2VdlDG_9UwpKOIji4itQGOS-VWUOWUi3GeXWzt0,7
+jaxion-0.0.1.dist-info/RECORD,,

jaxion-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

jaxion-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

jaxion-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+jaxion