off 0.1.0__tar.gz

off-0.1.0/LICENSE

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

off-0.1.0/PKG-INFO

@@ -0,0 +1,154 @@
+Metadata-Version: 2.4
+Name: off
+Version: 0.1.0
+Summary: A library for learning the ground state energy using orbital free density functional theory with continuous normalizing flows.
+Author-email: Alexandre de Camargo <decamara@mcmaster.ca>
+Project-URL: Homepage, https://github.com/AlexandreDeCamargo/of_flows
+Project-URL: Repository, https://github.com/AlexandreDeCamargo/of_flows
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jax>=0.6.0
+Requires-Dist: jaxlib>=0.6.0
+Requires-Dist: equinox>=0.12.0
+Requires-Dist: diffrax>=0.7.0
+Requires-Dist: optax>=0.2.0
+Requires-Dist: scipy>=1.15.0
+Requires-Dist: chex>=0.1.89
+Requires-Dist: jaxtyping>=0.3.0
+Requires-Dist: distrax>=0.1.5
+Requires-Dist: pyscf>=2.7.0
+Requires-Dist: pandas>=2.0.3
+Requires-Dist: matplotlib>=3.10.0
+Provides-Extra: examples
+Requires-Dist: matplotlib>=3.10.0; extra == "examples"
+Requires-Dist: chex>=0.1.89; extra == "examples"
+Requires-Dist: numpy>=2.3.0; extra == "examples"
+Dynamic: license-file
+
+# OFF: An Orbital-Free Density Functional Theory Python library using Normalizing Flows
+
+OFF is a [JAX](https://github.com/google/jax)-based library for **orbital-free density
+functional theory (OF-DFT)** in which the electron density is represented by a
+**continuous normalizing flow (CNF)** and the ground-state energy is obtained by
+*variationally minimizing* a density functional with Monte-Carlo gradient estimates.
+The density is normalized by construction (it is a probability flow), and the physical
+density is recovered as `ρ(x) = Ne · ρ_φ(x)`.
+
+OFF is built entirely on the JAX ecosystem — automatic differentiation, JIT
+compilation, vectorization, and GPU acceleration — with
+[Diffrax](https://github.com/patrick-kidger/diffrax) for the flow ODEs,
+[Equinox](https://github.com/patrick-kidger/equinox) for the models and functionals,
+[Distrax](https://github.com/google-deepmind/distrax) for the base distribution, and
+[Optax](https://github.com/google-deepmind/optax) for the optimization.
+
+## Functionality
+
+The current version of the library has the following capabilities: 
+
+* Provides an implementation of OF-DFT methods with continuous normalizing flows. 
+* A modular library of density functionals:
+  * **kinetic**: Thomas–Fermi, von Weizsäcker, and TF-λW;
+  * **exchange**: LDA and B88;
+  * **correlation**: VWN and PW92;
+  * **nuclear attraction**, 
+  * **Hartree**, and 
+  * **nuclear-cusp corrections** (Kato, Hutcheon).
+* Evaluates density functionals using Monte Carlo estimators. 
+* In addition to Monte Carlo estimators, it also has a deterministic **grid (quadrature) readout** of the energy after training, using a
+  [PySCF](https://github.com/pyscf/pyscf) Becke grid converted to `jax.Array`.
+
+## Install
+
+A core dependency is [PySCF](https://pyscf.org), which needs `cmake` available on the
+`PATH`. In a fresh environment, from the repository root:
+
+```bash
+pip install -e .
+```
+
+The `db_sir` prior additionally requires AtomDB; install it only if you use that prior.
+
+## Use
+
+Two stages: (1) **train** a normalizing flow for a given molecule and functional, then
+(2) read out the energy on a **quadrature grid**. Both are exposed as command-line
+tools (after `pip install -e .`) and as a Python API.
+
+### 1. Train a flow
+
+```bash
+off-train --mol_name H2 --bond_length 1.4 \
+          --kin tf_w --lam 1/5 --x lda_b88_x --c none \
+          --hart coulomb --prior promolecular \
+          --solver dopri8 --epochs 500 --bs 512
+```
+(equivalently `python -m off.main ...`). This minimizes the OF-DFT energy with the
+Monte-Carlo estimator and writes everything under a method-tagged directory:
+
+```
+Results/H2/tf_w_lam0.2_none_lda_b88_x_none_dopri8_promolecular_sched_mix/bl_1.40/
+    Checkpoints/checkpoint_*.eqx     # the trained flow
+    training_metrics_ema.csv         # EMA energy trace
+    job_params.json                  # everything needed to rebuild the run
+```
+
+Key options: `--kin {tf,w,tf_w}`, `--x {lda,b88_x,lda_b88_x}`, `--c {vwn_c,pw92_c,none}`,
+`--cc {kato,hutcheon,none}`, `--hart {coulomb,coulomb_}` (all-pairs / element-wise),
+`--prior {promolecular,db_sir}`, `--solver {dopri5,tsit5,dopri8}`.
+
+### 2. Evaluate the energy on a grid
+
+After training, point the quadrature tool at the run directory. It rebuilds the flow
+from `job_params.json`, builds a PySCF grid, evaluates `ρ_φ` and its score there, and
+integrates every energy term:
+
+```bash
+off-quadrature Results/H2/tf_w_lam0.2_none_lda_b88_x_none_dopri8_promolecular_sched_mix/bl_1.40 --grid_level 3
+```
+(equivalently `python -m off.quadrature ...`). It prints the per-term energies
+(`T, V_N, V_H, E_X, E_C, E_CC, E_NN, E_total`) and the `∫ρ` check, and caches the
+result in `energy_summary.json`. The same call from Python:
+
+```python
+from off import grid_energy_from_checkpoint
+
+e = grid_energy_from_checkpoint(
+    "Results/H2/.../bl_1.40", grid_level=3)
+print(e["E_total"], e["Ne_integral"])
+```
+
+### Build a grid
+
+```python
+from off import getGrid
+
+h2_geom = "H 0 0 0; H 0 0 1.4"               
+w_grid, x_grid = getGrid(h2_geom, level=3, units="bohr")
+```
+
+## Package layout
+
+```
+off/
+  main.py            # training entry point   (off-train)
+  quadrature.py      # grid-energy readout    (off-quadrature)
+  flow/              # the continuous normalizing flow (CNF)
+  ode_solver/        # Diffrax forward/reverse ODE solves
+  promolecular/      # base distributions (promolecular, AtomDB)
+  functionals/       # kinetic, exchange-correlation, nuclear, Hartree, cusp
+  train/             # loss (Monte-Carlo energy) and the optimization loop
+```
+
+## Citation
+
+```bibtex
+@article{off,
+  title  = {Orbital-Free DFT with Normalizing Flows},
+  author = {de Camargo, Alexandre and others},
+  year   = {2026},
+}
+```

off-0.1.0/README.md

@@ -0,0 +1,123 @@
+# OFF: An Orbital-Free Density Functional Theory Python library using Normalizing Flows
+
+OFF is a [JAX](https://github.com/google/jax)-based library for **orbital-free density
+functional theory (OF-DFT)** in which the electron density is represented by a
+**continuous normalizing flow (CNF)** and the ground-state energy is obtained by
+*variationally minimizing* a density functional with Monte-Carlo gradient estimates.
+The density is normalized by construction (it is a probability flow), and the physical
+density is recovered as `ρ(x) = Ne · ρ_φ(x)`.
+
+OFF is built entirely on the JAX ecosystem — automatic differentiation, JIT
+compilation, vectorization, and GPU acceleration — with
+[Diffrax](https://github.com/patrick-kidger/diffrax) for the flow ODEs,
+[Equinox](https://github.com/patrick-kidger/equinox) for the models and functionals,
+[Distrax](https://github.com/google-deepmind/distrax) for the base distribution, and
+[Optax](https://github.com/google-deepmind/optax) for the optimization.
+
+## Functionality
+
+The current version of the library has the following capabilities: 
+
+* Provides an implementation of OF-DFT methods with continuous normalizing flows. 
+* A modular library of density functionals:
+  * **kinetic**: Thomas–Fermi, von Weizsäcker, and TF-λW;
+  * **exchange**: LDA and B88;
+  * **correlation**: VWN and PW92;
+  * **nuclear attraction**, 
+  * **Hartree**, and 
+  * **nuclear-cusp corrections** (Kato, Hutcheon).
+* Evaluates density functionals using Monte Carlo estimators. 
+* In addition to Monte Carlo estimators, it also has a deterministic **grid (quadrature) readout** of the energy after training, using a
+  [PySCF](https://github.com/pyscf/pyscf) Becke grid converted to `jax.Array`.
+
+## Install
+
+A core dependency is [PySCF](https://pyscf.org), which needs `cmake` available on the
+`PATH`. In a fresh environment, from the repository root:
+
+```bash
+pip install -e .
+```
+
+The `db_sir` prior additionally requires AtomDB; install it only if you use that prior.
+
+## Use
+
+Two stages: (1) **train** a normalizing flow for a given molecule and functional, then
+(2) read out the energy on a **quadrature grid**. Both are exposed as command-line
+tools (after `pip install -e .`) and as a Python API.
+
+### 1. Train a flow
+
+```bash
+off-train --mol_name H2 --bond_length 1.4 \
+          --kin tf_w --lam 1/5 --x lda_b88_x --c none \
+          --hart coulomb --prior promolecular \
+          --solver dopri8 --epochs 500 --bs 512
+```
+(equivalently `python -m off.main ...`). This minimizes the OF-DFT energy with the
+Monte-Carlo estimator and writes everything under a method-tagged directory:
+
+```
+Results/H2/tf_w_lam0.2_none_lda_b88_x_none_dopri8_promolecular_sched_mix/bl_1.40/
+    Checkpoints/checkpoint_*.eqx     # the trained flow
+    training_metrics_ema.csv         # EMA energy trace
+    job_params.json                  # everything needed to rebuild the run
+```
+
+Key options: `--kin {tf,w,tf_w}`, `--x {lda,b88_x,lda_b88_x}`, `--c {vwn_c,pw92_c,none}`,
+`--cc {kato,hutcheon,none}`, `--hart {coulomb,coulomb_}` (all-pairs / element-wise),
+`--prior {promolecular,db_sir}`, `--solver {dopri5,tsit5,dopri8}`.
+
+### 2. Evaluate the energy on a grid
+
+After training, point the quadrature tool at the run directory. It rebuilds the flow
+from `job_params.json`, builds a PySCF grid, evaluates `ρ_φ` and its score there, and
+integrates every energy term:
+
+```bash
+off-quadrature Results/H2/tf_w_lam0.2_none_lda_b88_x_none_dopri8_promolecular_sched_mix/bl_1.40 --grid_level 3
+```
+(equivalently `python -m off.quadrature ...`). It prints the per-term energies
+(`T, V_N, V_H, E_X, E_C, E_CC, E_NN, E_total`) and the `∫ρ` check, and caches the
+result in `energy_summary.json`. The same call from Python:
+
+```python
+from off import grid_energy_from_checkpoint
+
+e = grid_energy_from_checkpoint(
+    "Results/H2/.../bl_1.40", grid_level=3)
+print(e["E_total"], e["Ne_integral"])
+```
+
+### Build a grid
+
+```python
+from off import getGrid
+
+h2_geom = "H 0 0 0; H 0 0 1.4"               
+w_grid, x_grid = getGrid(h2_geom, level=3, units="bohr")
+```
+
+## Package layout
+
+```
+off/
+  main.py            # training entry point   (off-train)
+  quadrature.py      # grid-energy readout    (off-quadrature)
+  flow/              # the continuous normalizing flow (CNF)
+  ode_solver/        # Diffrax forward/reverse ODE solves
+  promolecular/      # base distributions (promolecular, AtomDB)
+  functionals/       # kinetic, exchange-correlation, nuclear, Hartree, cusp
+  train/             # loss (Monte-Carlo energy) and the optimization loop
+```
+
+## Citation
+
+```bibtex
+@article{off,
+  title  = {Orbital-Free DFT with Normalizing Flows},
+  author = {de Camargo, Alexandre and others},
+  year   = {2026},
+}
+```

off-0.1.0/off/__init__.py

@@ -0,0 +1,23 @@
+"""OFF — orbital-free DFT with continuous normalizing flows."""
+
+__version__ = "0.1.0"
+
+from .functionals.functional import (
+    Functional,
+    CompositeFunctional,
+    EnergyFunctional,
+    FunctionalInputs,
+    unit_coefficient,
+)
+from .functionals import (
+    tf, weizsacker, tf_weizsacker,
+    lda, b88, vwn, pw92, lda_b88,
+    NuclearPotential, CoulombPotential, CoulombPotential_,
+    KatoCondition, HutcheonCuspCondition,
+)
+from .quadrature import (
+    getGrid, get_grid, build_grid,
+    grid_energy, grid_energy_from_checkpoint,
+)
+from .train.loss import build_energy_functional, create_loss_function
+from .train.loop import training

off-0.1.0/off/atom_energies.py

@@ -0,0 +1,151 @@
+"""
+Grid-integrated total energy vs EMA energy, side by side, for a set of atoms.
+
+For each atom it:
+  1. grid-integrates the LAST checkpoint via ``quadrature.grid_energy_from_checkpoint``
+     ->  E_grid (= E_total; for a single atom E_NN = 0, so this is the electronic
+     total energy).
+  2. averages the last --window rows of training_metrics_ema.csv (E + CC) -> E_ema.
+  3. writes both numbers side by side to a CSV (+ prints a table).
+
+Because E_NN = 0 for an isolated atom, E_grid and E_ema are the *same* physical
+quantity (total atomic energy); the only difference is grid quadrature vs the
+Monte-Carlo EMA estimate during training.
+
+Directory layout assumed (same as main.py):
+    {results_root}/{atom}/{method}/bl_0.0000/
+        Checkpoints/checkpoint_*.eqx
+        training_metrics_ema.csv
+        job_params.json
+
+Usage
+-----
+python atom_energies.py --method tf_w_lam0.2_none_lda_none_dopri8_db_sir_sched_MIX
+python atom_energies.py --method <tag> --atoms B Be C F H He Li N Ne O \
+    --window 1000 --recompute --results_root /path/to/Results
+"""
+
+import sys, os
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+import argparse
+from pathlib import Path
+
+import pandas as pd
+
+from quadrature import grid_energy_from_checkpoint
+
+# atomic number == electron count for a neutral atom
+Z_TABLE = {"H": 1, "He": 2, "Li": 3, "Be": 4, "B": 5,
+           "C": 6, "N": 7, "O": 8, "F": 9, "Ne": 10}
+
+# ── CLI ───────────────────────────────────────────────────────────────────────
+parser = argparse.ArgumentParser(
+    description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+parser.add_argument("--method", type=str, required=True,
+                    help="Method directory name, e.g. "
+                         "tf_w_lam0.2_none_lda_none_dopri8_db_sir_sched_MIX")
+parser.add_argument("--atoms", type=str, nargs="+",
+                    default=["B", "Be", "C", "F", "H", "He", "Li", "N", "Ne", "O"],
+                    help="Atoms to process (default: the full set).")
+parser.add_argument("--results_root", type=str, default="Results",
+                    help="Root dir holding {atom}/{method}/bl_0.0000 (default: Results)")
+parser.add_argument("--window", type=int, default=1000,
+                    help="Average the last N rows of training_metrics_ema.csv (default: 1000)")
+parser.add_argument("--bs", type=int, default=256, help="Grid chunk size")
+parser.add_argument("--grid_level", type=int, default=3, help="PySCF grid level")
+parser.add_argument("--recompute", action="store_true",
+                    help="Re-run grid integration even if energy_summary.json is cached")
+parser.add_argument("--out", type=str, default="atom_energies.csv",
+                    help="Output CSV path (default: atom_energies.csv)")
+args = parser.parse_args()
+
+
+def read_last_ema(bl_dir: Path, window: int):
+    """Mean of the last `window` rows of training_metrics_ema.csv.
+    E = E + CC  (no nuclear repulsion; for an atom this is the total energy)."""
+    csv = bl_dir / "training_metrics_ema.csv"
+    if not csv.exists():
+        return None, None
+    try:
+        df = pd.read_csv(csv)
+    except pd.errors.EmptyDataError:
+        return None, None
+    if df.empty:
+        return None, None
+    tail = df.tail(window)
+    E = float(tail["E"].mean())
+    if "CC" in tail.columns:
+        E += float(tail["CC"].mean())
+    epoch = int(df.iloc[-1]["epoch"])
+    return E, epoch
+
+
+# ── main loop ─────────────────────────────────────────────────────────────────
+root = Path(args.results_root).resolve()
+print(f"Results root : {root}")
+print(f"Method       : {args.method}")
+print(f"EMA window   : last {args.window} rows\n")
+
+rows = []
+for atom in args.atoms:
+    atom_dir = root / atom / args.method / "bl_0.0000"
+    print(f"[{atom}]  {atom_dir}")
+
+    if not (atom_dir / "job_params.json").exists():
+        print("    SKIP — no job_params.json (directory missing?)\n")
+        continue
+
+    # grid integration of the last checkpoint (via the OFF quadrature module)
+    try:
+        data = grid_energy_from_checkpoint(
+            atom_dir, grid_level=args.grid_level, chunk=args.bs, recompute=args.recompute)
+        E_grid     = data["E_total"]
+        grid_epoch = data["epoch"]
+        Ne_int     = data["Ne_integral"]
+    except Exception as e:
+        print(f"    grid integration FAILED: {e}")
+        E_grid = grid_epoch = Ne_int = None
+
+    # EMA mean of last `window` rows
+    E_ema, ema_epoch = read_last_ema(atom_dir, args.window)
+    if E_ema is None:
+        print("    no training_metrics_ema.csv")
+
+    diff = (E_grid - E_ema) if (E_grid is not None and E_ema is not None) else None
+    rows.append({
+        "atom":       atom,
+        "Ne":         Z_TABLE.get(atom),
+        "E_grid_Ha":  E_grid,
+        "grid_epoch": grid_epoch,
+        "E_ema_Ha":   E_ema,
+        "ema_epoch":  ema_epoch,
+        "diff_Ha":    diff,
+        "Ne_int":     Ne_int,
+    })
+    if E_grid is not None and E_ema is not None:
+        print(f"    E_grid={E_grid:+.6f}  E_ema={E_ema:+.6f}  Δ={diff:+.6f} Ha")
+    print()
+
+if not rows:
+    raise RuntimeError("No atoms processed — check --results_root / --method.")
+
+df = pd.DataFrame(rows)
+
+# ── print + save ──────────────────────────────────────────────────────────────
+print("=" * 80)
+print(f"{'atom':>4}  {'Ne':>3}  {'E_grid [Ha]':>15}  {'E_ema [Ha]':>15}  "
+      f"{'Δ(grid-ema)':>13}  {'∫ρ':>8}")
+print("-" * 80)
+for _, r in df.iterrows():
+    eg = f"{r['E_grid_Ha']:+15.6f}" if pd.notna(r['E_grid_Ha']) else f"{'—':>15}"
+    em = f"{r['E_ema_Ha']:+15.6f}"  if pd.notna(r['E_ema_Ha'])  else f"{'—':>15}"
+    dd = f"{r['diff_Ha']:+13.6f}"   if pd.notna(r['diff_Ha'])   else f"{'—':>13}"
+    ni = f"{r['Ne_int']:8.4f}"      if pd.notna(r['Ne_int'])    else f"{'—':>8}"
+    ne = f"{int(r['Ne'])}"          if pd.notna(r['Ne'])        else "?"
+    print(f"{r['atom']:>4}  {ne:>3}  {eg}  {em}  {dd}  {ni}")
+print("=" * 80)
+
+out_path = Path(args.out).resolve()
+df.to_csv(out_path, index=False, float_format="%.8f")
+print(f"\nSaved → {out_path}")

off-0.1.0/off/config/_config.py

@@ -0,0 +1,108 @@
+"""
+Global configuration module for storing runtime parameters and directories.
+"""
+
+class Config:
+    """Global configuration class to store all runtime parameters."""
+    
+    # Model parameters
+    mol_name = None
+    epochs = None
+    bs = None
+    hl = None
+    lr = None
+    prior = None 
+    
+    # Functionals
+    kin = None
+    nuc = None
+    hart = None
+    x = None
+    c = None
+    cc = None
+    
+    # Training settings
+    sched = None
+    solver = None
+    ckpt_freq = None
+    
+    # Directories (set during runtime)
+    results_dir = None
+    ckpt_dir = None
+    
+    @classmethod
+    def from_args(cls, args):
+        """
+        Initialize configuration from argparse arguments.
+        
+        Args:
+            args: argparse.Namespace object containing parsed arguments
+        """
+        # Model parameters
+        cls.mol_name = args.mol_name
+        cls.epochs = args.epochs
+        cls.bs = args.bs
+        cls.hl = args.hl
+        cls.lr = args.lr
+        cls.prior = args.prior
+
+        # Functionals
+        cls.kin = args.kin
+        cls.nuc = args.nuc
+        cls.hart = args.hart
+        cls.x = args.x
+        cls.c = args.c
+        cls.cc = args.cc
+        
+        # Training settings
+        cls.sched = args.sched
+        cls.solver = args.solver
+        cls.ckpt_freq = args.ckpt_freq
+    
+    @classmethod
+    def set_directories(cls, results_dir, ckpt_dir):
+        """
+        Set the results and checkpoint directories.
+        
+        Args:
+            results_dir: Path to results directory
+            ckpt_dir: Path to checkpoint directory
+        """
+        cls.results_dir = results_dir
+        cls.ckpt_dir = ckpt_dir
+    
+    @classmethod
+    def get_model_params(cls):
+        """Return dictionary of model parameters."""
+        return {
+            'mol_name': cls.mol_name,
+            'epochs': cls.epochs,
+            'bs': cls.bs,
+            'hl': cls.hl,
+            'lr': cls.lr,
+            'prior': cls.prior 
+        }
+    
+    @classmethod
+    def get_functionals(cls):
+        """Return dictionary of functional parameters."""
+        return {
+            'kin': cls.kin,
+            'nuc': cls.nuc,
+            'hart': cls.hart,
+            'x': cls.x,
+            'c': cls.c,
+            'cc': cls.cc
+        }
+    
+    @classmethod
+    def __repr__(cls):
+        """String representation of configuration."""
+        return (
+            f"Config(\n"
+            f"  Model: mol_name={cls.mol_name}, epochs={cls.epochs}, "
+            f"bs={cls.bs}, hl={cls.hl}, lr={cls.lr}, prior={cls.prior}\n"
+            f"  Functionals: kin={cls.kin}, x={cls.x}, c={cls.c}, cc={cls.cc}\n"
+            f"  Directories: results={cls.results_dir}, ckpt={cls.ckpt_dir}\n"
+            f")"
+        )

off-0.1.0/off/dft_distrax/__init__.py

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