off 0.1.0__py3-none-any.whl

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/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/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/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
+)

off/dft_distrax/dft_distrax.py

@@ -0,0 +1,216 @@
+from functools import partial
+from typing import Any
+
+import numpy as np
+
+import jax
+import jax.numpy as jnp
+from jaxtyping import Array, Float
+
+from pyscf import gto, dft
+from pyscf.dft import numint
+from pyscf.data.nist import BOHR
+
+import distrax
+from distrax import MultivariateNormalDiag, Categorical
+from distrax._src.distributions.distribution import Array
+
+Dtype = Any
+
+class MixGaussian(distrax.Distribution):
+  def __init__(self, loc: Array , scale_diag: Array , probs: Array):
+    r"""
+    Creates a distribution with a mixture of Gaussian components.
+
+    Parameters
+    ----------
+    loc : Array
+        Molecular coordinates.
+    scale_diag : Array
+        Sigma matrix.
+    probs : Array
+        Mixture probabilities.
+    """    
+   
+    self.loc = loc
+    self.scale_diag = scale_diag
+    self.probs = probs
+    self.mixture_dist = Categorical(probs=probs)
+    self.components_dist = MultivariateNormalDiag(loc=self.loc,scale_diag=self.scale_diag)
+
+   
+  @jax.jit
+  def prob(self, value: Array) -> jax.Array:
+    """
+    Calculates the probability of an event.
+
+    Parameters
+    ----------
+    value : Array
+        An event. 
+
+    Returns
+    -------
+    jax.Array
+        The probability of the event.
+    """    
+    log_px_components_dist = self.components_dist.log_prob(value).T
+    px_components_dist = jnp.exp(log_px_components_dist)
+    px = px_components_dist@self.probs[:,None]
+    return px
+
+  @jax.jit
+  def log_prob(self, value: Array) -> jax.Array:
+    """
+    Calculates the log probability of an event.
+
+    Parameters
+    ----------
+    value : Array
+        An event.
+
+    Returns
+    -------
+    jax.Array
+        The log probability of the event.
+    """    
+    return jnp.log(self.prob(value))
+
+
+  def _sample_n(self, key: jax.random.PRNGKey, n: int) -> jax.Array:
+    """
+    Returns 'n' samples. 
+
+    Parameters
+    ----------
+    key : PRNGKey
+        Random key.
+    n : int
+        Number of samples to generate. 
+
+    Returns
+    -------
+    jax.Array
+        An array of 'n' samples. 
+    """    
+    _, key_mixt, key_comp = jax.random.split(key,3)
+    samples_mixt = self.mixture_dist._sample_n(key_mixt,n)
+    samples_mixt_one_hot = jax.nn.one_hot(samples_mixt,self.probs.shape[-1])
+    samples_comp = self.components_dist.sample(seed=key_comp, sample_shape=n)
+    samples_comp = jnp.squeeze(samples_comp,axis=-2)
+
+    samples = jnp.einsum('ijl,ij->il',samples_comp,samples_mixt_one_hot)
+    return samples
+
+  def event_shape(self):
+      pass
+      #6-31G(d,p)
+  @jax.jit
+  def score(self,values):
+    return jax.vmap(jax.grad(lambda x:
+                              self.log_prob(x).sum()))(values)
+  
+  
+class DFTDistribution(distrax.Distribution):
+
+    def __init__(self, atoms: Any, geometry: Any, basis_set: str = '6-31G(d,p)', exc: str = 'b3lyp', dtype_: Dtype = jnp.float32):
+
+        self.atoms = atoms
+        self.geometry = geometry
+        self.basis_set = basis_set
+        self.exc = exc
+        self.dtype_ = dtype_
+
+        self._grid_level = 5 # change this for larger molecules
+        self.mol = self._mol()
+        self.grids = dft.gen_grid.Grids(self.mol)
+        self.grids.level = self._grid_level
+        self.grids.build()
+        self.Ne = self.mol.tot_electrons()
+        self.dft, self.rdm1 = self._dft()
+
+        self.coords = jnp.array(self.grids.coords)
+        self.weights = jnp.array(self.grids.weights)
+    
+    def get_molecule(self):
+        m_ = ""
+        for a, xi in zip(self.atoms, self.geometry):
+            print(a, xi)
+            mi_ = f'{a} '
+            mxi_ = ""
+            for xii in xi:
+                mxi_ += str(xii) + " "
+            mi_ += mxi_ + '\n'
+            m_ += mi_
+        return m_
+
+    def _mol(self):
+        atoms = self.get_molecule()
+        #mol = gto.M(atom=atoms, basis=self.basis_set,
+        #            unit='B',spin=1)  # , symmetry = True)
+        spin_dict = {
+        'H': 1, 'He': 0,
+        'Li': 1, 'Be': 0, 'B': 1, 'C': 2, 'N': 3, 'O': 2, 'F': 1, 'Ne': 0
+        }
+        # If single atom, use spin_dict; else, compute total spin (more complex)
+        if len(self.atoms) == 1:
+            spin = spin_dict.get(self.atoms[0], 0)  # Default to 0 if not found
+            mol = gto.M(atom=atoms, basis=self.basis_set, unit='B', spin=spin)
+        else:
+            #atoms = self.get_molecule()
+            mol = gto.M(atom=atoms, basis=self.basis_set,
+                    unit='B')
+        return mol
+    
+    def _dft(self):
+       
+        mf_hf = dft.RKS(self.mol)
+        LDA_X = 1.
+        B88_X = 1.
+        VWN_C = 1.
+
+        mf_hf.xc = f'{LDA_X:} * LDA + {B88_X:} * B88, {VWN_C:} * VWN'
+        # mf_hf.xc = f'{LDA_X:} * LDA'
+        mf_hf = mf_hf.newton() # second-order algortihm
+        mf_hf.kernel()
+        dm = mf_hf.make_rdm1()
+        return mf_hf, dm
+
+    @partial(jax.custom_vjp, nondiff_argnums=(0,))
+    def prob(self, value):
+        coords = np.array(value)
+        ao_value = numint.eval_ao(self.mol, coords, deriv=1)
+        rho_and_grho = numint.eval_rho(
+            self.mol, ao_value, self.rdm1, xctype='GGA')
+        rho = jnp.asarray(rho_and_grho[0], dtype=self.dtype_)  # /self.Ne
+        return rho[:, None]  # includes batch dimension
+
+    def prob_fwd(self, value):
+        coords = value
+        ao_value = numint.eval_ao(self.mol, coords, deriv=1)
+        rho_and_grho = numint.eval_rho(
+            self.mol, ao_value, self.rdm1, xctype='GGA')
+        rho = jnp.array(rho_and_grho[0], dtype=self.dtype_)/self.Ne
+        drho_dx = jnp.array(
+            rho_and_grho[1:, :].T, dtype=self.dtype_)/self.Ne
+        return rho[:, None], (drho_dx)
+
+    def prob_bwd(self, res, g):
+        drho_dx = res
+        return (drho_dx*g,)
+        # return (jnp.matmul(g.T, drho_dx),)
+
+    prob.defvjp(prob_fwd, prob_bwd)
+
+    def log_prob(self, value: Any) -> Array:
+        pass
+
+    def _sample_n(self, key, n):
+        pass
+
+    def event_shape(self):
+        pass
+
+    def _sample_n_and_log_prob(self, key, n):
+        pass
+

off/flow/__init__.py

@@ -0,0 +1,29 @@
+# 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 .equiv_flows import (
+    _Flow,
+    Radial_MLP,
+    CNF
+)

off/flow/equiv_flows.py

@@ -0,0 +1,99 @@
+import jax
+from jax import lax, numpy as jnp
+import equinox as eqx
+from jaxtyping import Array, Float, Int, Scalar
+
+class _Flow(eqx.Module):
+    linear_in: eqx.nn.Linear
+    linear_out: eqx.nn.Linear
+    blocks: list[eqx.nn.Linear]
+
+    def __init__(
+        self, 
+        din: Int[Scalar, ""], 
+        dim: Int[Scalar, ""], 
+        key: jax.random.PRNGKey
+    ):
+        keys = jax.random.split(key, 5)
+        
+        self.linear_in = eqx.nn.Linear(din + 1, dim, key=keys[0])
+        self.blocks = [eqx.nn.Linear(dim, dim, key=k) for k in jax.random.split(keys[1], 3)]
+        self.linear_out = eqx.nn.Linear(dim, din, key=keys[2])        
+
+    def __call__(
+        self, 
+        t, 
+        xi_norm, 
+        zi_one_hot
+    ):
+        t = jnp.reshape(t, (1,))
+        xi_norm = jnp.reshape(xi_norm, (1,))
+        x = jnp.hstack((t, xi_norm, zi_one_hot)) 
+        x = self.linear_in(x)  
+        x = jnp.tanh(x)
+        for block in self.blocks:
+            x = block(x)  
+            x = jnp.tanh(x)
+        x = self.linear_out(x) 
+        return x
+
+class Radial_MLP(eqx.Module):
+    xyz_nuclei : Array
+    z_one_hot : Array
+    flow: _Flow
+
+    def __init__(
+        self, 
+        dim: int, 
+        key, 
+        xyz_nuclei, 
+        z_one_hot
+        ):
+        din_flow = 1 + z_one_hot.shape[-1]
+        self.xyz_nuclei = xyz_nuclei[:,None,:] 
+        self.z_one_hot = z_one_hot
+        self.flow = _Flow(din_flow, dim, key=key)
+
+    def __call__(self, states, t): 
+        vmap_radial_block = jax.vmap(self.flow, in_axes=(None, 0, 0))
+        z = lax.expand_dims(states, dimensions=(0,)) - self.xyz_nuclei
+        z_norm = jnp.linalg.norm(z, axis=-1)
+        x = vmap_radial_block(t, z_norm, self.z_one_hot)
+        x = jnp.einsum('ijk,ij->k', z, x)
+        return x
+
+class CNF(eqx.Module):
+    flow: Radial_MLP
+
+    def __init__(
+        self, 
+        din: Int[Scalar, ""], 
+        dim: Int[Scalar, ""], 
+        mu: any, 
+        one_hot:any, 
+        key: jax.random.PRNGKey
+    ):
+        self.flow = Radial_MLP(dim, key, mu, one_hot)
+
+    def __call__(self, states, t):
+        data_dim = 3 #Hardcoded for 3 dimensions
+
+        @jax.jit
+        def _f_ode(self, states, t):
+            x, log_px, score = states[:data_dim], states[data_dim:data_dim+1], states[data_dim+1:] 
+            jac = jax.jacrev(self.flow)(x, t) 
+            dtrJ = -1. * jnp.trace(jac)
+            dz = self.flow(x, t)  
+            return dz, dtrJ
+
+        @jax.jit
+        def f_ode(self,states,t):
+            state, score = states[:-data_dim], states[-data_dim:]
+            dx_and_dlopz, _f_vjp = jax.vjp(
+                lambda state: _f_ode(self,state, t), state)
+            dx, dlopz = dx_and_dlopz
+            (vjp_all,) = _f_vjp((score, -1.))
+            score_vjp, grad_div = vjp_all[:-1], vjp_all[-1]
+            dscore = -score_vjp + grad_div
+            return jnp.append(jnp.append(dx, dlopz), dscore)
+        return f_ode(self, states, t)

off/functionals/__init__.py

@@ -0,0 +1,35 @@
+# 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 .functional import (
+    Functional,
+    CompositeFunctional,
+    EnergyFunctional,
+    FunctionalInputs,
+)
+from .kinetic import tf, weizsacker, tf_weizsacker
+from .exchange_correlation import lda, b88, vwn, pw92, lda_b88
+from .external import NuclearPotential
+from .hartree import CoulombPotential, CoulombPotential_
+from .core_correction import KatoCondition, HutcheonCuspCondition