matris update

.gitignore

@@ -0,0 +1,20 @@
+*.wandb
+debug.log
+debug-internal.log
+debug-core.log
+*.log
+
+# Weights & Biases
+wandb/
+**/wandb/
+# Build artifacts
+models/matris/build/
+*.so
+*.o
+
+# Compiled/build artifacts
+models/matris/build/
+models/matris/**/*.so
+models/matris/**/*.o
+*.so
+*.o

models/matris/README.md

@@ -0,0 +1,5 @@
+# Introduction
+
+To train matris, run the run_matris.py script, there's also a ddp version called run_matris_ddp.py
+
+To eval matris, run the eval_matris.py

models/matris/bench_matris_speed_single.py

@@ -0,0 +1,227 @@
+#!/usr/bin/env python3
+"""
+Benchmark MatRIS speed (energy + forces) on a single structure ~96 atoms.
+
+- Selects a structure from an extxyz file (closest natoms to target, default 96)
+- Loads a pretrained MatRIS model (matris_10m_oam or matris_10m_mp)
+- Converts the structure to a MatRIS graph (optional to include conversion time)
+- Times the forward pass that returns energy + forces (forces require autograd)
+
+Notes
+- Do NOT wrap the model call in torch.no_grad(): MatRIS computes forces via autograd.
+- For reliable repeated timing, we refresh the coordinate tensor each iteration to be a leaf
+  requiring grad (avoids "does not require grad" and avoids graph growth).
+"""
+
+from __future__ import annotations
+import argparse
+import time
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+from ase.io import read
+from ase.atoms import Atoms
+
+def pick_index_by_natoms(atoms_list: list[Atoms], target: int) -> int:
+    best_i = 0
+    best_d = 10**9
+    for i, a in enumerate(atoms_list):
+        d = abs(len(a) - target)
+        if d < best_d:
+            best_d = d
+            best_i = i
+            if best_d == 0:
+                break
+    return best_i
+
+def maybe_cuda_sync(device: str):
+    if device.startswith("cuda"):
+        try:
+            import torch
+            torch.cuda.synchronize()
+        except Exception:
+            pass
+
+def refresh_grad_coords(graph: Any):
+    """
+    Ensure graph has a fresh leaf coordinate tensor requiring grad.
+
+    MatRIS force computation needs gradients w.r.t. Cartesian coordinates.
+    Supports dict-like graphs and RadiusGraph-style objects.
+    """
+    import torch
+
+    candidate_keys = [
+        "batch_cart_coords",
+        "cart_coords",
+        "cartesian_coords",
+        "pos",
+        "positions",
+        "atom_frac_coord",
+    ]
+
+    # Case 1: dictionary-like graph
+    if isinstance(graph, dict):
+        for key in candidate_keys:
+            if key in graph:
+                coords = graph[key]
+                if not torch.is_tensor(coords):
+                    raise TypeError(f"graph['{key}'] is not a torch.Tensor, got {type(coords)}")
+                graph[key] = coords.detach().clone().requires_grad_(True)
+                return
+
+        raise KeyError(f"Could not find coordinate tensor in graph keys: {list(graph.keys())}")
+
+    # Case 2: object with attributes, e.g. RadiusGraph
+    for key in candidate_keys:
+        if hasattr(graph, key):
+            coords = getattr(graph, key)
+
+            if torch.is_tensor(coords):
+                setattr(graph, key, coords.detach().clone().requires_grad_(True))
+                return
+
+    # Helpful debug print
+    attrs = [a for a in dir(graph) if not a.startswith("_")]
+    raise TypeError(
+        f"Unsupported graph type for coord refresh: {type(graph)}\n"
+        f"Available public attributes include:\n{attrs[:80]}"
+    )
+
+def main():
+    ap = argparse.ArgumentParser(description="Benchmark MatRIS speed on a single ~96-atom structure.")
+    ap.add_argument("--xyz", required=True, help="Path to extxyz dataset (or single-structure xyz)")
+    ap.add_argument("--model-name", default="none", choices=["none", "matris_10m_oam", "matris_10m_mp"])
+    ap.add_argument("--device", default=None, help='Device, e.g. "cuda" or "cpu" (default: auto)')
+    ap.add_argument("--target-natoms", type=int, default=96, help="Pick structure with natoms closest to this (default 96)")
+    ap.add_argument("--index", default=":", help='ASE selector for candidate pool (default ":" for all)')
+    ap.add_argument("--pick", choices=["closest", "first", "given"], default="closest",
+                    help="How to pick the structure: closest to target natoms, first, or given index")
+    ap.add_argument("--given-index", type=int, default=0, help="Used when --pick given")
+    ap.add_argument("--warmup", type=int, default=50, help="Warmup iterations (default 50)")
+    ap.add_argument("--iters", type=int, default=300, help="Timed iterations (default 300)")
+    ap.add_argument("--include-graph", action="store_true", help="Include structure->graph conversion time in each iteration")
+    ap.add_argument("--disable-ref-energy", action="store_true",
+                    help="Disable MatRIS composition reference energy (mpa AtomRef) during inference")
+    ap.add_argument(
+        "--is-conservative",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help=(
+            "Use conservative forces F = -dE/dx. "
+            "Use --no-is-conservative for direct force prediction."
+        ),
+    )
+    args = ap.parse_args()
+
+    # device auto
+    if args.device is None:
+        try:
+            import torch
+            device = "cuda" if torch.cuda.is_available() else "cpu"
+        except Exception:
+            device = "cpu"
+    else:
+        device = args.device
+
+    # Lazy imports for MatRIS + adaptor
+    try:
+        import torch
+        from pymatgen.io.ase import AseAtomsAdaptor
+        from matris.model.model import MatRIS
+    except Exception as e:
+        raise SystemExit(f"Failed imports. Ensure MatRIS + pymatgen + torch installed.\nOriginal error: {e}")
+
+    atoms_list = read(args.xyz, index=args.index)
+    if isinstance(atoms_list, Atoms):
+        atoms_list = [atoms_list]
+    if len(atoms_list) == 0:
+        raise SystemExit("No structures read from --xyz/--index.")
+
+    if args.pick == "first":
+        idx = 0
+    elif args.pick == "given":
+        idx = int(args.given_index)
+        if idx < 0 or idx >= len(atoms_list):
+            raise SystemExit(f"--given-index {idx} out of range (0..{len(atoms_list)-1})")
+    else:
+        idx = pick_index_by_natoms(atoms_list, args.target_natoms)
+
+    atoms = atoms_list[idx]
+    n_atoms = len(atoms)
+
+    if args.model_name is None or args.model_name == "none":
+        print("Training from scratch")
+        model = MatRIS(is_conservation=args.is_conservative).to(args.device)
+    else:
+        print(f"Starting from foundation model: {args.model_name}")
+        model = MatRIS.load(args.model_name, 
+                            device=args.device,
+                            cache_dir="foundation_models",)
+        # override loaded setting if needed
+        model.force_stress_head.is_conservation = args.is_conservative
+    
+    model.eval()
+
+    if args.disable_ref_energy:
+        # The head uses model.reference_energy if present
+        model.reference_energy = None
+
+    adaptor = AseAtomsAdaptor()
+
+    def build_graph():
+        structure = adaptor.get_structure(atoms)
+        g = model.graph_converter(structure).to(device)
+        return g
+
+    # Prebuild graph for forward-only timing
+    graph0 = build_graph()
+
+    def one_call():
+        # optionally include graph conversion
+        g = build_graph() if args.include_graph else graph0
+
+        # ensure grad leaf coords each call
+        refresh_grad_coords(g)
+
+        out = model([g], task="ef", is_training=False)
+        # touch outputs so work is not optimized away
+        e = out["e"][0]
+        f = out["f"][0]
+        # small reduction
+        _ = float(e.detach().cpu()) + float(f.detach().abs().mean().cpu())
+        return
+
+    # Warmup
+    for _ in range(args.warmup):
+        one_call()
+    maybe_cuda_sync(device)
+
+    # Timed loop
+    t0 = time.time()
+    for _ in range(args.iters):
+        one_call()
+    maybe_cuda_sync(device)
+    t1 = time.time()
+
+    dt = (t1 - t0) / float(args.iters)
+    ms = dt * 1e3
+    us_per_atom = (dt / max(1, n_atoms)) * 1e6
+
+    print("MatRIS speed benchmark")
+    print(f"  device:              {device}")
+    print(f"  model:               {args.model_name}")
+    print(f"  conservative:               {args.is_conservative}")
+    print(f"  dataset:             {Path(args.xyz)}")
+    print(f"  selected index:      {idx}")
+    print(f"  natoms:              {n_atoms}")
+    print(f"  include graph build: {args.include_graph}")
+    print(f"  ref energy enabled:  {not args.disable_ref_energy}")
+    print(f"  warmup iters:        {args.warmup}")
+    print(f"  timed iters:         {args.iters}")
+    print(f"  avg time / call:     {ms:.4f} ms")
+    print(f"  avg time / atom:     {us_per_atom:.4f} µs/atom")
+
+if __name__ == "__main__":
+    main()

models/matris/eval_matris.py

@@ -0,0 +1,334 @@
+from __future__ import annotations
+
+import argparse
+import collections
+from pathlib import Path
+
+import torch
+from torch import nn
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+
+from matris.model.model import MatRIS
+from matris.model.reference_energy import AtomRef
+from matris_dataset import (
+    MatRISDataset,
+    matris_collate_fn,
+    move_matris_batch_to_device,
+)
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+
+TEST_PATH = REPO_ROOT / "datasets/xyz/testdata.xyz"
+SAVE_DIR = REPO_ROOT / "models/matris/checkpoints_matris"
+
+
+
+E0S_DEFAULT = {
+    1: 2.467478445,   # H
+    6: 8.0273263225,  # C
+    8: 3.334308855,   # O
+    22: 4.879036065,  # Ti
+}
+
+def build_random_init_model(
+    device: str,
+    is_conservative: bool,
+    use_reference_energy: bool,
+    model_name: str | None = None,
+) -> MatRIS:
+    print("Building RANDOM INIT model")
+    print(f"Requested model_name: {model_name}")
+
+    if model_name is None or model_name == "none" or model_name == "":
+        print("Random scratch MatRIS architecture")
+        model = MatRIS(is_conservation=is_conservative)
+    else:
+        print(f"Random foundation architecture: {model_name}")
+        model = MatRIS.load(
+            model_name,
+            device="cpu",
+            cache_dir="foundation_models",
+        )
+        model.force_stress_head.is_conservation = is_conservative
+
+    if use_reference_energy:
+        model.reference_energy = build_reference_energy_module(model, E0S_DEFAULT)
+    else:
+        model.reference_energy = None
+
+    model = model.to(device)
+    model.eval()
+    return model
+
+
+def build_reference_energy_module(model: MatRIS, e0_dict: dict[int, float]) -> AtomRef:
+    atom_ref = AtomRef(reference_energy="mptrj", is_intensive=model.is_intensive)
+
+    weight = torch.zeros(94, dtype=torch.float32)
+    for Z, e0 in e0_dict.items():
+        weight[Z - 1] = e0
+
+    state_dict = collections.OrderedDict()
+    state_dict["weight"] = weight.view(1, 94)
+    atom_ref.fc.load_state_dict(state_dict)
+
+    atom_ref.fitted = True
+    for p in atom_ref.parameters():
+        p.requires_grad = False
+
+    return atom_ref
+
+
+class MatRISEvalLoss(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.l1_sum = nn.L1Loss(reduction="sum")
+        self.l2_sum = nn.MSELoss(reduction="sum")
+
+    def forward(self, pred_forces, ref_forces, pred_energy, ref_energy):
+        loss_forces_l1 = self.l1_sum(pred_forces, ref_forces)
+        loss_energy_l1 = self.l1_sum(pred_energy, ref_energy)
+
+        loss_forces_l2 = self.l2_sum(pred_forces, ref_forces)
+        loss_energy_l2 = self.l2_sum(pred_energy, ref_energy)
+
+        return loss_forces_l1, loss_energy_l1, loss_forces_l2, loss_energy_l2
+
+
+def load_matris_from_checkpoint(
+    checkpoint_path: str | Path,
+    device: str,
+    is_conservative: bool,
+    use_reference_energy: bool,
+    model_name: str | None = None,
+) -> MatRIS:
+    checkpoint = torch.load(checkpoint_path, map_location="cpu", weights_only=False)
+
+    print(f"Requested model_name: {model_name}")
+
+    if model_name is None or model_name == "none" or model_name == "":
+        print("Loading scratch MatRIS architecture")
+        model = MatRIS(is_conservation=is_conservative)
+    else:
+        print(f"Loading foundation model architecture: {model_name}")
+        model = MatRIS.load(
+            model_name,
+            device="cpu",
+            cache_dir="foundation_models",
+        )
+        model.force_stress_head.is_conservation = is_conservative
+
+    if use_reference_energy:
+        model.reference_energy = build_reference_energy_module(model, E0S_DEFAULT)
+    else:
+        model.reference_energy = None
+
+    model.load_state_dict(checkpoint["model_state_dict"], strict=True)
+
+    model = model.to(device)
+    model.eval()
+    return model
+
+
+def evaluate(model, loader, loss_fn, use_grad, device, desc="Eval"):
+    model.eval()
+
+    sum_abs_dF = torch.tensor(0.0, device=device)
+    sum_abs_dE = torch.tensor(0.0, device=device)
+
+    sum_sq_dF = torch.tensor(0.0, device=device)
+    sum_sq_dE = torch.tensor(0.0, device=device)
+
+    sum_abs_dE_per_atom = torch.tensor(0.0, device=device)
+    sum_sq_dE_per_atom = torch.tensor(0.0, device=device)
+
+    total_force_components = torch.tensor(0.0, device=device)
+    total_systems = torch.tensor(0.0, device=device)
+    total_atoms = torch.tensor(0.0, device=device)
+
+    # Important: no torch.no_grad(), because conservative forces need autograd.
+    for batch in tqdm(loader, desc=desc, dynamic_ncols=True):
+        # There's one sample in testset where this happens
+        if batch is None:
+            continue
+        batch = move_matris_batch_to_device(batch, device=device)
+
+        with torch.set_grad_enabled(use_grad):
+            out = model(batch["graphs"], task="ef", is_training=False)
+
+            n_atoms_per_graph = out["atoms_per_graph"].float()
+            natoms_batch = n_atoms_per_graph.sum()
+            n_systems = n_atoms_per_graph.numel()
+
+            pred_energy = out["e"]
+            if model.is_intensive:
+                pred_energy = pred_energy * n_atoms_per_graph
+
+            ref_energy = batch["energy"]
+
+            pred_forces = torch.cat(out["f"], dim=0)
+            ref_forces = torch.cat(batch["forces"], dim=0)
+
+            loss_forces_l1, loss_energy_l1, loss_forces_l2, loss_energy_l2 = loss_fn(
+                pred_forces=pred_forces,
+                ref_forces=ref_forces,
+                pred_energy=pred_energy,
+                ref_energy=ref_energy,
+            )
+
+            dE = pred_energy.view(-1) - ref_energy.view(-1)
+            abs_dE = dE.abs()
+
+        total_atoms += natoms_batch.detach()
+        total_force_components += (3.0 * natoms_batch).detach()
+        total_systems += torch.tensor(float(n_systems), device=device)
+
+        sum_abs_dF += loss_forces_l1.detach()
+        sum_abs_dE += loss_energy_l1.detach()
+
+        sum_sq_dF += loss_forces_l2.detach()
+        sum_sq_dE += loss_energy_l2.detach()
+
+        sum_abs_dE_per_atom += (abs_dE / n_atoms_per_graph).sum().detach()
+        sum_sq_dE_per_atom += ((dE / n_atoms_per_graph) ** 2).sum().detach()
+    mae_F = (sum_abs_dF / total_force_components).item()
+    mae_E_sys = (sum_abs_dE / total_systems).item()
+    mae_E_atom_weighted = (sum_abs_dE / total_atoms).item()
+    mae_E_atom_mace = (sum_abs_dE_per_atom / total_systems).item()
+
+    rmse_F = torch.sqrt(sum_sq_dF / total_force_components).item()
+    rmse_E_sys = torch.sqrt(sum_sq_dE / total_systems).item()
+    rmse_E_atom_weighted = torch.sqrt(sum_sq_dE / total_atoms).item()
+    rmse_E_atom_mace = torch.sqrt(sum_sq_dE_per_atom / total_systems).item()
+
+    print()
+    print("========== MatRIS Evaluation ==========")
+    print(f"MAE(F components) [eV/A]:        {mae_F:.6f}")
+    print(f"MAE(E per system) [eV]:          {mae_E_sys:.6f}")
+    print(f"MAE(E per atom, weighted) [eV]:  {mae_E_atom_weighted:.6f}")
+    print(f"MAE(E per atom, MACE) [eV]:      {mae_E_atom_mace:.6f}")
+    print(f"MAE(E per atom, MACE) [meV]:     {1000.0 * mae_E_atom_mace:.3f}")
+    print()
+    print(f"RMSE(F components) [eV/A]:       {rmse_F:.6f}")
+    print(f"RMSE(E per system) [eV]:         {rmse_E_sys:.6f}")
+    print(f"RMSE(E per atom, weighted) [eV]: {rmse_E_atom_weighted:.6f}")
+    print(f"RMSE(E per atom, MACE) [eV]:     {rmse_E_atom_mace:.6f}")
+    print(f"RMSE(E per atom, MACE) [meV]:    {1000.0 * rmse_E_atom_mace:.3f}")
+    print("=======================================")
+
+    return {
+        "mae_F": mae_F,
+        "mae_E_sys": mae_E_sys,
+        "mae_E_atom_weighted": mae_E_atom_weighted,
+        "mae_E_atom_mace": mae_E_atom_mace,
+        "rmse_F": rmse_F,
+        "rmse_E_sys": rmse_E_sys,
+        "rmse_E_atom_weighted": rmse_E_atom_weighted,
+        "rmse_E_atom_mace": rmse_E_atom_mace,
+    }
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Evaluate a MatRIS checkpoint.")
+
+    parser.add_argument("--test_path", type=str, default=str(TEST_PATH))
+    parser.add_argument("--checkpoint", type=str, default=None)
+    parser.add_argument(
+    "--random_init",
+    action="store_true",
+    help="Evaluate a randomly initialized model instead of loading checkpoint weights.",
+    )
+
+    parser.add_argument("--batch_size", type=int, default=1)
+    parser.add_argument("--num_workers", type=int, default=0)
+    parser.add_argument("--device", type=str, default="cuda" if torch.cuda.is_available() else "cpu")
+
+    parser.add_argument(
+        "--is_conservative",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Use conservative forces.",
+    )
+
+    parser.add_argument(
+        "--use_reference_energy",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Use the same custom AtomRef reference energies as training.",
+    )
+
+    parser.add_argument("--model_name", type=str, default="")
+
+
+
+    
+
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    print(f"Device: {args.device}")
+    print(f"Checkpoint: {args.checkpoint}")
+    print(f"Random init: {args.random_init}")
+    print(f"Test path: {args.test_path}")
+    print(f"Conservative forces: {args.is_conservative}")
+    print(f"Use reference energy: {args.use_reference_energy}")
+
+    
+    if args.random_init:
+        print("Evaluing random init model")
+        model = build_random_init_model(
+            device=args.device,
+            is_conservative=args.is_conservative,
+            use_reference_energy=args.use_reference_energy,
+            model_name=args.model_name,
+        )
+    else:
+        if args.checkpoint is None:
+            raise ValueError("--checkpoint is required unless --random_init is used.")
+
+        model = load_matris_from_checkpoint(
+            checkpoint_path=args.checkpoint,
+            device=args.device,
+            is_conservative=args.is_conservative,
+            use_reference_energy=args.use_reference_energy,
+            model_name=args.model_name,
+        )
+    
+
+    use_grad = model.force_stress_head.is_conservation
+
+    print(f'use_grad is: {use_grad}')
+
+    # NOTE Try a random init model.
+    # print("Running random Matrsi model")
+    # model = MatRIS(is_conservation=args.is_conservative).to(args.device)
+    # model.reference_energy = build_reference_energy_module(model, E0S_DEFAULT).to(args.device)
+
+    test_dataset = MatRISDataset(args.test_path, model=model)
+
+    test_loader = DataLoader(
+        test_dataset,
+        batch_size=args.batch_size,
+        shuffle=False,
+        num_workers=args.num_workers,
+        collate_fn=matris_collate_fn,
+    )
+
+    loss_fn = MatRISEvalLoss()
+
+    evaluate(
+        model=model,
+        loader=test_loader,
+        loss_fn=loss_fn,
+        use_grad = use_grad,
+        device=args.device,
+        desc="MatRIS Eval",
+    )
+
+
+if __name__ == "__main__":
+    main()

models/matris/example/cif_file/demo.cif

@@ -0,0 +1,36 @@
+# generated using pymatgen
+data_Pu2Si3
+_symmetry_space_group_name_H-M   'P 1'
+_cell_length_a   4.26022438
+_cell_length_b   7.16692875
+_cell_length_c   7.16692875
+_cell_angle_alpha   90.00000000
+_cell_angle_beta   90.00000000
+_cell_angle_gamma   90.00000000
+_symmetry_Int_Tables_number   1
+_chemical_formula_structural   Pu2Si3
+_chemical_formula_sum   'Pu4 Si6'
+_cell_volume   218.82586168
+_cell_formula_units_Z   2
+loop_
+ _symmetry_equiv_pos_site_id
+ _symmetry_equiv_pos_as_xyz
+  1  'x, y, z'
+loop_
+ _atom_site_type_symbol
+ _atom_site_label
+ _atom_site_symmetry_multiplicity
+ _atom_site_fract_x
+ _atom_site_fract_y
+ _atom_site_fract_z
+ _atom_site_occupancy
+  Pu  Pu0  1  0.50000000  0.67597000  0.82403000  1.0
+  Pu  Pu1  1  0.50000000  0.32403000  0.17597000  1.0
+  Pu  Pu2  1  0.50000000  0.17597000  0.67597000  1.0
+  Pu  Pu3  1  0.50000000  0.82403000  0.32403000  1.0
+  Si  Si4  1  0.00000000  0.88257100  0.61742900  1.0
+  Si  Si5  1  0.00000000  0.11742900  0.38257100  1.0
+  Si  Si6  1  0.00000000  0.38257100  0.88257100  1.0
+  Si  Si7  1  0.00000000  0.61742900  0.11742900  1.0
+  Si  Si8  1  0.00000000  0.00000000  0.00000000  1.0
+  Si  Si9  1  0.00000000  0.50000000  0.50000000  1.0

models/matris/example/test_ralexation.py

@@ -0,0 +1,36 @@
+import ase
+from ase.build import bulk
+import torch
+from pymatgen.core.structure import Structure
+from matris.applications.relax import StructOptimizer
+
+model_name = "matris_10m_oam"
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+matris_opt = StructOptimizer(
+    model=model_name, 
+    task = "efsm",
+    optimizer = "FIRE", # FIRE, BFGS ...
+    device=device
+)
+
+atom = Structure.from_file(f"example/cif_file/demo.cif")
+
+max_steps = 500
+fmax = 0.05
+opt_result = matris_opt.relax(
+        atoms=atom, # pymatgen.Structure or ase.Atoms
+        verbose=True,
+        steps=max_steps,
+        fmax=fmax,
+        relax_cell=max_steps > 0,
+        ase_filter="FrechetCellFilter",
+    )
+
+trajectory = opt_result['trajectory']
+energy = trajectory.energies[-1]
+force = trajectory.forces[-1]
+stress = trajectory.stresses[-1]
+magmom = trajectory.magmoms[-1]
+
+final_structure = opt_result['final_structure']

models/matris/foundation_models/MatRIS_10M_MP.pth.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:333b6019ec901a4bce9735ef28136d7da637899272825ff7ef9c84587b22f2d9
+size 42184483

models/matris/foundation_models/MatRIS_10M_OAM.pth.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c033abc53601a74f10d9b7fec0f658220c013c3b11d4d405f1d32136d4c2b067
+size 42273174

models/matris/matris/__init__.py

@@ -0,0 +1,8 @@
+from importlib.metadata import version
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version(__name__)  # read from pyproject.toml
+except PackageNotFoundError:
+    __version__ = "unknown"

models/matris/matris/applications/__init__.py

@@ -0,0 +1,4 @@
+
+from .base import MatRISCalculator
+from .md import MolecularDynamics
+from .relax import StructOptimizer

models/matris/matris/applications/base.py

@@ -0,0 +1,199 @@
+from ase import Atoms, units
+from ase.calculators.calculator import Calculator, all_changes, all_properties
+import numpy as np
+
+from ..model.model import MatRIS
+
+from pymatgen.io.ase import AseAtomsAdaptor
+from ..graph import RadiusGraph
+
+from ase.optimize import (
+    BFGS, BFGSLineSearch, 
+    FIRE, LBFGS, 
+    LBFGSLineSearch, MDMin
+)
+
+names = [
+    "BFGS", "BFGSLineSearch", 
+    "FIRE", "LBFGS", 
+    "LBFGSLineSearch", "MDMin"
+]
+
+OPTIMIZERS = {name: globals()[name] for name in names}
+
+class MatRISCalculator(Calculator):
+    """MatRIS Calculator for ASE applications."""
+    
+    implemented_properties = ("energy", "forces", "stress", "magmoms")  # type: ignore
+    
+    def __init__(
+        self,
+        model: str = "matris_10m_oam",
+        task: str = "efs",
+        device: str = "cpu",
+        **kwargs,
+    ) -> None:
+        """
+        Args:
+            model (MatRIS): Instance of a MatRIS model. If set to None, the default MatRIS is loaded.
+            task (str): The prediction task. Can be 'e', 'em', 'ef', 'efs', 'efsm'.
+            device (str): The device to be used for predictions,
+            stress_unit (float): the conversion factor to convert GPa(MatRIS default) to eV/A^3.
+            **kwargs: Passed to the Calculator parent class.
+        """
+        super().__init__(**kwargs)
+        self.task=task
+        self.device = device
+        self.model = MatRIS.load(model_name=model, device=self.device)
+        
+        self.stress_unit = units.GPa
+        key = ["atoms_per_graph", "ref_energy"]
+        for t in task:
+            key.append(t)
+        self.key = set(key)
+     
+    def calculate(
+        self,
+        atoms: Atoms,
+        properties: list,
+        system_changes: list,
+    ) -> None:
+        
+        properties = properties or all_properties
+        system_changes = system_changes or all_changes
+        super().calculate(
+            atoms=atoms,
+            properties=properties,
+            system_changes=system_changes,
+        )
+
+        pbc = atoms.get_pbc()
+        if (not pbc[0]) or (not pbc[1]) or (not pbc[2]):
+            pos = atoms.get_positions()
+            cell = np.array(atoms.get_cell())
+            
+            pbc_x = pbc[0]
+            pbc_y = pbc[1]
+            pbc_z = pbc[2]
+            identity = np.identity(3, dtype=float)
+            max_positions = np.max(np.absolute(pos)) + 1
+            
+            cutoff = self.model.config["pairwise_cutoff"]
+            expand = max(5, self.model.config["num_layers"])
+
+            # Extend cell in non-periodic directions
+            if not pbc_x:
+                cell[0, :] = max_positions * expand * cutoff * identity[0, :]
+            if not pbc_y:
+                cell[1, :] = max_positions * expand * cutoff * identity[1, :]
+            if not pbc_z:
+                cell[2, :] = max_positions * expand * cutoff * identity[2, :]
+            
+            # update
+            atoms.set_cell(cell, scale_atoms=False)
+        
+        
+        structure = AseAtomsAdaptor.get_structure(atoms)
+        graph = self.model.graph_converter(structure).to(self.device) # convert to List
+        
+        graphs = [graph] if isinstance(graph, RadiusGraph) else graph
+        
+        model_prediction = self.model(
+            graphs,
+            task = self.task,
+            is_training = False,
+        )
+        model_predictions = {}
+        
+        for key in self.key & set(model_prediction.keys()):
+            for idx, tensor in enumerate(model_prediction[key]):
+                model_predictions[key] = tensor.cpu().detach().numpy()
+        
+        # Convert Result
+        n_atoms = 1 if not self.model.is_intensive else structure.composition.num_atoms
+        
+        self.results.update(
+            ref_energy=model_predictions["ref_energy"] * n_atoms,
+            energy=model_predictions["e"] * n_atoms,  # Total Energy
+            forces=model_predictions.get("f", None),
+            # Stress: GPa -> eV/A^3
+            stress=model_predictions.get("s", None) * self.stress_unit if model_predictions.get("s", None) is not None else None,
+            magmoms=model_predictions.get("m", None),
+        )
+
+
+class TrajectoryObserver:
+    # ref: https://github.com/CederGroupHub/chgnet
+
+    def __init__(self, atoms: Atoms) -> None:
+        
+        self.atoms = atoms
+        self.energies: list[float] = []
+        self.forces: list[np.ndarray] = []
+        self.stresses: list[np.ndarray] = []
+        self.magmoms: list[np.ndarray] = []
+        self.atom_positions: list[np.ndarray] = []
+        self.cells: list[np.ndarray] = []
+
+    def __call__(self) -> None:
+        """The logic for saving the properties of an Atoms during the relaxation."""
+        self.energies.append(self.compute_energy())
+        self.forces.append(self.atoms.get_forces())
+        self.stresses.append(self.atoms.get_stress())
+        self.magmoms.append(self.atoms.get_magnetic_moments())
+        self.atom_positions.append(self.atoms.get_positions())
+        self.cells.append(self.atoms.get_cell()[:])
+
+    def __len__(self) -> int:
+        """The number of steps in the trajectory."""
+        return len(self.energies)
+
+    def compute_energy(self) -> float:
+        """Calculate the potential energy.
+
+        Returns:
+            energy (float): the potential energy.
+        """
+        return self.atoms.get_potential_energy()
+
+    def save(self, filename: str) -> None:
+        """Save the trajectory to file.
+
+        Args:
+            filename (str): filename to save the trajectory
+        """
+        out_pkl = {
+            "energy": self.energies,
+            "forces": self.forces,
+            "stresses": self.stresses,
+            "magmoms": self.magmoms,
+            "atom_positions": self.atom_positions,
+            "cell": self.cells,
+            "atomic_number": self.atoms.get_atomic_numbers(),
+        }
+        with open(filename, "wb") as file:
+            pickle.dump(out_pkl, file)
+
+
+class CrystalFeasObserver:
+    # ref: https://github.com/CederGroupHub/chgnet
+
+    def __init__(self, atoms: Atoms) -> None:
+        """Create a CrystalFeasObserver from an Atoms object."""
+        self.atoms = atoms
+        self.crystal_feature_vectors: list[np.ndarray] = []
+
+    def __call__(self) -> None:
+        """Record Atoms crystal feature vectors after an MD/relaxation step."""
+        self.crystal_feature_vectors.append(self.atoms._calc.results["crystal_fea"])
+
+    def __len__(self) -> int:
+        """Number of recorded steps."""
+        return len(self.crystal_feature_vectors)
+
+    def save(self, filename: str) -> None:
+        """Save the crystal feature vectors to filename in pickle format."""
+        out_pkl = {"crystal_feas": self.crystal_feature_vectors}
+        with open(filename, "wb") as file:
+            pickle.dump(out_pkl, file)
+                      

models/matris/matris/applications/md.py

@@ -0,0 +1,349 @@
+""" Modified from CHGNet: https://github.com/CederGroupHub/chgnet """
+from __future__ import annotations
+
+import inspect
+import sys
+import io
+import contextlib
+from ase import Atoms, units
+from ase.io import Trajectory
+from ase.optimize.optimize import Optimizer
+import ase.filters as filter_classes
+from ase.filters import Filter
+from pymatgen.io.ase import AseAtomsAdaptor
+from pymatgen.core.structure import Structure, Molecule
+
+from ase.md.npt import NPT
+from ase.md.nptberendsen import Inhomogeneous_NPTBerendsen, NPTBerendsen
+from ase.md.nvtberendsen import NVTBerendsen
+from ase.md.velocitydistribution import MaxwellBoltzmannDistribution, Stationary
+from ase.md.verlet import VelocityVerlet
+
+from ..model.model import MatRIS
+
+from .base import (
+    OPTIMIZERS,
+    MatRISCalculator, 
+    TrajectoryObserver,
+    CrystalFeasObserver
+)
+
+class MolecularDynamics:
+    """This class is used for Molecular Dynamics."""
+
+    def __init__(
+        self,
+        atoms: Atoms | Structure,
+        model: str = "matris_10m_oam",
+        ensemble: str = "nvt",
+        thermostat: str = "Berendsen_inhomogeneous",
+        temperature: int = 300,
+        starting_temperature: int | None = None,
+        timestep: float = 2.0,
+        pressure: float = 1.01325e-4,
+        taut: float | None = None,
+        taup: float | None = None,
+        bulk_modulus: float | None = None,
+        trajectory: str | Trajectory | None = None,
+        logfile: str | None = None,
+        loginterval: int = 1,
+        crystal_feas_logfile: str | None = None,
+        append_trajectory: bool = False,
+        task: str = "efs",
+        device: str | None = None,
+    ) -> None:
+        """
+        Args:
+            atoms (Atoms): atoms to run the MD
+            model (MatRIS): instance of a MatRIS model or MatRISCalculator.
+                If set to None, the pretrained MatRIS is loaded.
+                Default = None
+            ensemble (str): choose from 'nve', 'nvt', 'npt'
+                Default = "nvt"
+            thermostat (str): Thermostat to use
+                choose from "Nose-Hoover", "Berendsen", "Berendsen_inhomogeneous"
+                Default = "Berendsen_inhomogeneous"
+            temperature (float): temperature for MD simulation, in K
+                Default = 300
+            starting_temperature (float): starting temperature of MD simulation, in K
+                if set as None, the MD starts with the momentum carried by ase.Atoms
+                if input is a pymatgen.core.Structure, the MD starts at 0K
+                Default = None
+            timestep (float): time step in fs
+                Default = 2
+            pressure (float): pressure in GPa
+                Can be 3x3 or 6 np.array if thermostat is "Nose-Hoover"
+                Default = 1.01325e-4 GPa = 1 atm
+            taut (float): time constant for temperature coupling in fs.
+                The temperature will be raised to target temperature in approximate
+                10 * taut time.
+                Default = 100 * timestep
+            taup (float): time constant for pressure coupling in fs
+                Default = 1000 * timestep
+            bulk_modulus (float): bulk modulus of the material in GPa.
+            trajectory (str or Trajectory): Attach trajectory object
+                Default = None
+            logfile (str): open this file for recording MD outputs
+                Default = None
+            loginterval (int): write to log file every interval steps
+                Default = 1
+            crystal_feas_logfile (str): open this file for recording crystal features
+                during MD. Default = None
+            append_trajectory (bool): Whether to append to prev trajectory.
+                If false, previous trajectory gets overwritten
+                Default = False
+            task (str): The prediction task. Can be 'e', 'em', 'ef', 'efs', 'efsm'.
+            device (str): the device for the MD run
+                Default = None
+        """
+        self.ensemble = ensemble
+        self.thermostat = thermostat
+        if isinstance(atoms, (Structure, Molecule)):
+            atoms = AseAtomsAdaptor().get_atoms(atoms)
+
+        if starting_temperature is not None:
+            MaxwellBoltzmannDistribution(
+                atoms, temperature_K=starting_temperature, force_temp=True
+            )
+            Stationary(atoms)
+
+        self.atoms = atoms
+        
+        self.atoms.calc = MatRISCalculator(
+            model=model,
+            device=device,
+            task=task,
+        )
+
+        if taut is None:
+            taut = 100 * timestep
+        if taup is None:
+            taup = 1000 * timestep
+
+        if ensemble.lower() == "nve":
+            """
+            VelocityVerlet (constant N, V, E) molecular dynamics.
+
+            Note: it's recommended to use smaller timestep for NVE compared to other
+            ensembles, since the VelocityVerlet algorithm assumes a strict conservative
+            force field.
+            """
+            self.dyn = VelocityVerlet(
+                atoms=self.atoms,
+                timestep=timestep * units.fs,
+                trajectory=trajectory,
+                logfile=logfile,
+                loginterval=loginterval,
+                append_trajectory=append_trajectory,
+            )
+            print("NVE-MD created")
+
+        elif ensemble.lower() == "nvt":
+            """
+            Constant volume/temperature molecular dynamics.
+            """
+            if thermostat.lower() == "nose-hoover":
+                """
+                Nose-hoover (constant N, V, T) molecular dynamics.
+                ASE implementation currently only supports upper triangular lattice
+                """
+                self.upper_triangular_cell()
+                self.dyn = NPT(
+                    atoms=self.atoms,
+                    timestep=timestep * units.fs,
+                    temperature_K=temperature,
+                    externalstress=pressure
+                    * units.GPa,  # ase NPT does not like externalstress=None
+                    ttime=taut * units.fs,
+                    pfactor=None,
+                    trajectory=trajectory,
+                    logfile=logfile,
+                    loginterval=loginterval,
+                    append_trajectory=append_trajectory,
+                )
+                print("NVT-Nose-Hoover MD created")
+            elif thermostat.lower().startswith("berendsen"):
+                """
+                Berendsen (constant N, V, T) molecular dynamics.
+                """
+                self.dyn = NVTBerendsen(
+                    atoms=self.atoms,
+                    timestep=timestep * units.fs,
+                    temperature_K=temperature,
+                    taut=taut * units.fs,
+                    trajectory=trajectory,
+                    logfile=logfile,
+                    loginterval=loginterval,
+                    append_trajectory=append_trajectory,
+                )
+                print("NVT-Berendsen-MD created")
+            else:
+                raise ValueError(
+                    "Thermostat not supported, choose in 'Nose-Hoover', 'Berendsen', "
+                    "'Berendsen_inhomogeneous'"
+                )
+
+        elif ensemble.lower() == "npt":
+            """
+            Constant pressure/temperature molecular dynamics.
+            """
+            # Bulk modulus is needed for pressure damping time
+            if bulk_modulus is not None:
+                bulk_modulus_au = bulk_modulus * units.GPa  # GPa to eV/A^3
+                compressibility_au = 1 / bulk_modulus_au
+            else:
+                try:
+                    # Fit bulk modulus by equation of state
+                    eos = EquationOfState(model=self.atoms.calc)
+                    eos.fit(atoms=atoms, steps=500, fmax=0.1, verbose=False)
+                    bulk_modulus = eos.get_bulk_modulus(unit="GPa")
+                    bulk_modulus_au = eos.get_bulk_modulus(unit="eV/A^3")
+                    compressibility_au = eos.get_compressibility(unit="A^3/eV")
+                    print(
+                        f"Completed bulk modulus calculation: "
+                        f"k = {bulk_modulus:.3}GPa, {bulk_modulus_au:.3}eV/A^3"
+                    )
+                except Exception:
+                    bulk_modulus_au = 2 * units.GPa
+                    compressibility_au = 1 / bulk_modulus_au
+                    print(
+                        "Warning!!! Equation of State fitting failed, setting bulk "
+                        "modulus to 2 GPa. NPT simulation can proceed with incorrect "
+                        "pressure relaxation time."
+                        "User input for bulk modulus is recommended."
+                    )
+            self.bulk_modulus = bulk_modulus
+
+            if thermostat.lower() == "nose-hoover":
+                """
+                Combined Nose-Hoover and Parrinello-Rahman dynamics, creating an
+                NPT (or N,stress,T) ensemble.
+                see: https://gitlab.com/ase/ase/-/blob/master/ase/md/npt.py
+                ASE implementation currently only supports upper triangular lattice
+                """
+                self.upper_triangular_cell()
+                ptime = taup * units.fs
+                self.dyn = NPT(
+                    atoms=self.atoms,
+                    timestep=timestep * units.fs,
+                    temperature_K=temperature,
+                    externalstress=pressure * units.GPa,
+                    ttime=taut * units.fs,
+                    pfactor=bulk_modulus * units.GPa * ptime * ptime,
+                    trajectory=trajectory,
+                    logfile=logfile,
+                    loginterval=loginterval,
+                    append_trajectory=append_trajectory,
+                )
+                print("NPT-Nose-Hoover MD created")
+
+            elif thermostat.lower() == "berendsen_inhomogeneous":
+                """
+                Inhomogeneous_NPTBerendsen thermo/barostat
+                This is a more flexible scheme that fixes three angles of the unit
+                cell but allows three lattice parameter to change independently.
+                see: https://gitlab.com/ase/ase/-/blob/master/ase/md/nptberendsen.py
+                """
+
+                self.dyn = Inhomogeneous_NPTBerendsen(
+                    atoms=self.atoms,
+                    timestep=timestep * units.fs,
+                    temperature_K=temperature,
+                    pressure_au=pressure * units.GPa,
+                    taut=taut * units.fs,
+                    taup=taup * units.fs,
+                    compressibility_au=compressibility_au,
+                    trajectory=trajectory,
+                    logfile=logfile,
+                    loginterval=loginterval,
+                )
+                print("NPT-Berendsen-inhomogeneous-MD created")
+
+            elif thermostat.lower() == "npt_berendsen":
+                """
+                This is a similar scheme to the Inhomogeneous_NPTBerendsen.
+                This is a less flexible scheme that fixes the shape of the
+                cell - three angles are fixed and the ratios between the three
+                lattice constants.
+                see: https://gitlab.com/ase/ase/-/blob/master/ase/md/nptberendsen.py
+                """
+
+                self.dyn = NPTBerendsen(
+                    atoms=self.atoms,
+                    timestep=timestep * units.fs,
+                    temperature_K=temperature,
+                    pressure_au=pressure * units.GPa,
+                    taut=taut * units.fs,
+                    taup=taup * units.fs,
+                    compressibility_au=compressibility_au,
+                    trajectory=trajectory,
+                    logfile=logfile,
+                    loginterval=loginterval,
+                    append_trajectory=append_trajectory,
+                )
+                print("NPT-Berendsen-MD created")
+            else:
+                raise ValueError(
+                    "Thermostat not supported, choose in 'Nose-Hoover', 'Berendsen', "
+                    "'Berendsen_inhomogeneous'"
+                )
+        
+        self.trajectory = trajectory
+        self.logfile = logfile
+        self.loginterval = loginterval
+        self.timestep = timestep
+        self.crystal_feas_logfile = crystal_feas_logfile
+
+    def run(self, steps: int) -> None:
+        """Thin wrapper of ase MD run.
+
+        Args:
+            steps (int): number of MD steps
+        """
+        if self.crystal_feas_logfile:
+            obs = CrystalFeasObserver(self.atoms)
+            self.dyn.attach(obs, interval=self.loginterval)
+
+        self.dyn.run(steps)
+
+        if self.crystal_feas_logfile:
+            obs.save(self.crystal_feas_logfile)
+
+    def set_atoms(self, atoms: Atoms) -> None:
+        """Set new atoms to run MD.
+
+        Args:
+            atoms (Atoms): new atoms for running MD
+        """
+        calculator = self.atoms.calc
+        self.atoms = atoms
+        self.dyn.atoms = atoms
+        self.dyn.atoms.calc = calculator
+
+    def upper_triangular_cell(self, verbose: bool | None = False) -> None:
+        """Transform to upper-triangular cell.
+        ASE Nose-Hoover implementation only supports upper-triangular cell
+        while ASE's canonical description is lower-triangular cell.
+
+        Args:
+            verbose (bool): Whether to notify user about upper-triangular cell
+                transformation. Default = False
+        """
+        if not NPT._isuppertriangular(self.atoms.get_cell()):
+            a, b, c, alpha, beta, gamma = self.atoms.cell.cellpar()
+            angles = np.radians((alpha, beta, gamma))
+            sin_a, sin_b, _sin_g = np.sin(angles)
+            cos_a, cos_b, cos_g = np.cos(angles)
+            cos_p = (cos_g - cos_a * cos_b) / (sin_a * sin_b)
+            cos_p = np.clip(cos_p, -1, 1)
+            sin_p = (1 - cos_p**2) ** 0.5
+
+            new_basis = [
+                (a * sin_b * sin_p, a * sin_b * cos_p, a * cos_b),
+                (0, b * sin_a, b * cos_a),
+                (0, 0, c),
+            ]
+
+            self.atoms.set_cell(new_basis, scale_atoms=True)
+            if verbose:
+                print("Transformed to upper triangular unit cell.", flush=True)

models/matris/matris/applications/relax.py

@@ -0,0 +1,144 @@
+""" Modified from CHGNet: https://github.com/CederGroupHub/chgnet """
+
+import inspect
+import sys
+import io
+import contextlib
+from ase import Atoms, units
+from ase.optimize.optimize import Optimizer
+import ase.filters as filter_classes
+from ase.filters import Filter
+from pymatgen.io.ase import AseAtomsAdaptor
+from pymatgen.core.structure import Structure
+
+from ..model.model import MatRIS
+from .base import (
+    OPTIMIZERS,
+    MatRISCalculator, 
+    TrajectoryObserver,
+    CrystalFeasObserver
+)
+
+class StructOptimizer:
+    """This class is used for Sturcture Optimization."""
+
+    def __init__(
+        self,
+        model: str = "matris_10m_oam",
+        task: str = "efs",
+        optimizer: str = "FIRE",
+        device: str = "cpu",
+    ) -> None:
+        """
+        Args:
+            model (MatRIS): Instance of a MatRIS model. If set to None, the default MatRIS is loaded.
+            task (str): The prediction task. Can be 'e', 'em', 'ef', 'efs', 'efsm'.
+            optimizer (Optimizer,str): choose optimizer from ASE.
+            device (str): The device to be used for predictions,
+            stress_unit (float): the conversion factor to convert GPa(MatRIS default) to eV/A^3.
+            **kwargs: Passed to the Calculator parent class.
+        """
+        
+        if optimizer in OPTIMIZERS:
+            optimizer = OPTIMIZERS[optimizer]
+        else:
+            raise ValueError(
+                f"Optimizer {optimizer} not found. Select from {list(OPTIMIZERS)}"
+            )
+        
+        self.optimizer: Optimizer = optimizer
+        
+        self.calculator = MatRISCalculator(
+            model=model,
+            task=task,
+            device=device,
+        )
+    
+    def relax(
+        self,
+        atoms: Structure | Atoms,
+        fmax: float = 0.05,
+        steps: int = 500,
+        relax_cell: bool = True,
+        ase_filter: str = "FrechetCellFilter",
+        save_path: str = None,
+        loginterval: int = 1,
+        crystal_feas_save_path: str = None,
+        verbose: bool = True,
+        assign_magmoms: bool = True,
+        **kwargs,
+    ) -> dict[str, Structure | TrajectoryObserver]:
+        """
+        Args:
+            atoms (Structure | Atoms): A Structure or Atoms object to relax.
+            fmax (float): The maximum force tolerance for relaxation.
+            steps (int): The maximum number of steps for relaxation.
+            relax_cell (bool): Whether to relax the cell as well.
+            ase_filter (str): The filter to apply to the atoms object for relaxation. 
+            save_path (str): The path to save the trajectory.
+            loginterval (int): Interval for logging trajectory and crystal feas.
+            crystal_feas_save_path (str): Path to save crystal feature vectors
+                which are logged at a loginterval rage
+            verbose (bool): Whether to print the output of the ASE optimizer.
+            assign_magmoms (bool): Whether to assign magnetic moments to the final
+                structure.
+            **kwargs: Additional parameters for the optimizer.
+        """
+
+        valid_filter_names = [
+            name
+            for name, cls in inspect.getmembers(filter_classes, inspect.isclass)
+            if issubclass(cls, Filter)
+        ]
+
+        if isinstance(ase_filter, str):
+            if ase_filter in valid_filter_names:
+                ase_filter = getattr(filter_classes, ase_filter)
+            else:
+                raise ValueError(
+                    f"Invalid {ase_filter=}, must be one of {valid_filter_names}. "
+                )
+
+        if isinstance(atoms, Structure):
+            atoms = AseAtomsAdaptor().get_atoms(atoms)
+
+        atoms.calc = self.calculator
+
+        stream = sys.stdout if verbose else io.StringIO()
+        with contextlib.redirect_stdout(stream):
+            obs = TrajectoryObserver(atoms)
+
+            if crystal_feas_save_path:
+                cry_obs = CrystalFeasObserver(atoms)
+
+            if relax_cell:
+                atoms = ase_filter(atoms)
+            optimizer: Optimizer = self.optimizer(atoms, **kwargs)
+            optimizer.attach(obs, interval=loginterval)
+
+            if crystal_feas_save_path:
+                optimizer.attach(cry_obs, interval=loginterval)
+
+            optimizer.run(fmax=fmax, steps=steps)
+            obs()
+
+        if save_path is not None:
+            obs.save(save_path)
+
+        if crystal_feas_save_path:
+            cry_obs.save(crystal_feas_save_path)
+
+        if isinstance(atoms, Filter):
+            atoms = atoms.atoms
+        struct = AseAtomsAdaptor.get_structure(atoms)
+        
+        if assign_magmoms:
+            if atoms.get_magnetic_moments() is not None:
+                for key in struct.site_properties:
+                    struct.remove_site_property(property_name=key)
+                struct.add_site_property(
+                    "magmom", [float(magmom) for magmom in atoms.get_magnetic_moments()]
+                )
+        
+        return {"final_structure": struct, "trajectory": obs}
+

models/matris/matris/graph/__init__.py

@@ -0,0 +1,3 @@
+
+from .converter import GraphConverter
+from .radiusgraph import RadiusGraph, datatype

models/matris/matris/graph/converter.py

@@ -0,0 +1,226 @@
+"""
+    This code is referenced from: https://github.com/CederGroupHub/chgnet/blob/main/chgnet/graph/converter.py
+    The original implementation can be found at the link above.
+"""
+from __future__ import annotations
+
+import numpy as np
+import torch
+from torch import nn
+import gc
+
+from .radiusgraph import Graph, Node, RadiusGraph
+from pymatgen.core import Structure
+
+try:
+    from .cygraph import make_graph
+except (ImportError, AttributeError):
+    make_graph = None
+    print("Failed with make_graph, run some program before")
+
+datatype = torch.float32
+
+class GraphConverter(nn.Module):
+    """Convert a pymatgen.core.Structure to a RadiusGraph"""
+
+    def __init__(
+        self,
+        atom_graph_cutoff: float = 6,
+        line_graph_cutoff: float = 4,
+        verbose: bool = False,
+    ) -> None:
+        """Initialize the Graph Converter.
+        
+        Args:
+            atom_graph_cutoff (float): cutoff radius in atom graph.
+            line_graph_cutoff (float): bond length threshold in line graph.
+            verbose (bool): whether to print the GraphConverter.
+        """
+        super().__init__()
+        self.atom_graph_cutoff = atom_graph_cutoff
+        self.line_graph_cutoff = (
+            atom_graph_cutoff if line_graph_cutoff is None else line_graph_cutoff
+        )
+        
+        if make_graph is not None:
+            self.create_graph = self._create_graph_fast
+            self.algorithm = 'fast'
+        else: 
+            self.create_graph = self._create_graph_legacy
+            self.algorithm = 'legacy'
+            print("fast graph converter algorithm import error, using legacy")
+        
+        if verbose:
+            print(self)
+
+    def __repr__(self) -> str:
+        """String representation of the GraphConverter."""
+        atom_graph_cutoff = self.atom_graph_cutoff
+        line_graph_cutoff = self.line_graph_cutoff
+        algorithm = self.algorithm
+        cls_name = type(self).__name__
+        return f"{cls_name}({algorithm=}, {atom_graph_cutoff=}, {line_graph_cutoff=})"
+
+    def forward(
+        self,
+        structure: Structure,
+        graph_id=None,
+        mp_id=None,
+    ) -> RadiusGraph:
+        """Convert a structure, return a RadiusGraph.
+
+        Args:
+            structure (pymatgen.core.Structure): structure to convert
+            graph_id (str): an id to keep track of this crystal graph
+                Default = None
+            mp_id (str): Materials Project id of this structure
+                Default = None
+        
+        """
+        n_atoms = len(structure)
+        atomic_number = torch.tensor( [site.specie.Z for site in structure], dtype=torch.int32 )
+        
+        atom_frac_coord = torch.tensor( structure.frac_coords, dtype=datatype )
+        lattice = torch.tensor( structure.lattice.matrix, dtype=datatype )
+        
+        center_index, neighbor_index, image, distance = structure.get_neighbor_list(
+            r=self.atom_graph_cutoff, sites=structure.sites, numerical_tol=1e-8
+        )
+        # Ceate atom graph
+        graph = self.create_graph(
+            n_atoms, center_index, neighbor_index, image, distance
+        )
+        atom_graph, directed2undirected = graph.adjacency_list()
+        atom_graph = torch.tensor(atom_graph, dtype=torch.int32)
+        directed2undirected = torch.tensor(directed2undirected, dtype=torch.int32)
+        undirected2directed = graph.undirected2directed()
+        undirected2directed = torch.tensor(undirected2directed, dtype=torch.int32)
+        
+        line_graph = []
+        try:
+            line_graph = graph.line_graph_adjacency_list(
+                cutoff=self.line_graph_cutoff
+            ) 
+        except Exception as exc:
+            structure.to(filename="error_graph.cif")
+
+        line_graph = torch.tensor(line_graph, dtype=torch.int32)
+
+        # For isolated atom, we stop this calculation
+        n_isolated_atoms = len({*range(n_atoms)} - {*center_index})
+        if n_isolated_atoms:
+            atom_graph_cutoff = self.atom_graph_cutoff
+            error = f"Error: Detected {n_isolated_atoms} isolated atom. Calculation stopped"
+            raise ValueError(error) # or print(error)
+        
+        return RadiusGraph(
+            atomic_number=atomic_number,
+            atom_frac_coord=atom_frac_coord,
+            atom_graph=atom_graph,
+            neighbor_image=torch.tensor(image, dtype=datatype),
+            directed2undirected=directed2undirected,
+            undirected2directed=undirected2directed,
+            line_graph=line_graph,
+            lattice=lattice,
+            graph_id=graph_id,
+            mp_id=mp_id,
+            composition=structure.composition.formula,
+            atom_graph_cutoff=self.atom_graph_cutoff,
+            line_graph_cutoff=self.line_graph_cutoff,
+        )
+
+    @staticmethod
+    def _create_graph_legacy(
+        n_atoms: int,
+        center_index: np.ndarray,
+        neighbor_index: np.ndarray,
+        image: np.ndarray,
+        distance: np.ndarray,
+    ) -> Graph:
+        """Given structure information, create a Graph structure to be used to
+        create Crystal_Graph using pure python implementation.
+
+        Args:
+            n_atoms (int): the number of atoms in the structure
+            center_index (np.ndarray): np array of indices of center atoms.
+                [num_undirected_bonds]
+            neighbor_index (np.ndarray): np array of indices of neighbor atoms.
+                [num_undirected_bonds]
+            image (np.ndarray): np array of images for each edge.
+                [num_undirected_bonds, 3]
+            distance (np.ndarray): np array of distances.
+                [num_undirected_bonds]
+
+        Return:
+            Graph data structure used to create Crystal_Graph object
+        """
+        
+        graph = Graph([Node(index=idx) for idx in range(n_atoms)])
+        for ii, jj, img, dist in zip(center_index, neighbor_index, image, distance):
+            graph.add_edge(center_index=ii, neighbor_index=jj, image=img, distance=dist)
+      
+        return graph
+
+    @staticmethod
+    def _create_graph_fast(
+        n_atoms: int,
+        center_index: np.ndarray,
+        neighbor_index: np.ndarray,
+        image: np.ndarray,
+        distance: np.ndarray,
+    ) -> Graph:
+        """Given structure information, create a Graph structure to be used to
+        create Crystal_Graph using C implementation.
+
+        NOTE: this is the fast version of _create_graph_legacy optimized
+            in c (~3x speedup).
+
+        Args:
+            n_atoms (int): the number of atoms in the structure
+            center_index (np.ndarray): np array of indices of center atoms.
+                [num_undirected_bonds]
+            neighbor_index (np.ndarray): np array of indices of neighbor atoms.
+                [num_undirected_bonds]
+            image (np.ndarray): np array of images for each edge.
+                [num_undirected_bonds, 3]
+            distance (np.ndarray): np array of distances.
+                [num_undirected_bonds]
+        
+        Return:
+            Graph data structure used to create Crystal_Graph object
+        """
+        center_index = np.ascontiguousarray(center_index)
+        neighbor_index = np.ascontiguousarray(neighbor_index)
+        image = np.ascontiguousarray(image, dtype=np.int_)
+        distance = np.ascontiguousarray(distance)
+        gc_saved = gc.get_threshold()
+        gc.set_threshold(0)
+        (
+            nodes,
+            directed_edges_list,
+            undirected_edges_list,
+            undirected_edges,
+        ) = make_graph(
+            center_index, len(center_index), neighbor_index, image, distance, n_atoms
+        )
+        
+        graph = Graph(nodes=nodes)
+        graph.directed_edges_list = directed_edges_list
+        graph.undirected_edges_list = undirected_edges_list
+        graph.undirected_edges = undirected_edges
+        gc.set_threshold(gc_saved[0])
+        
+        return graph
+
+    def as_dict(self) -> dict[str, float]:
+        """Save the args of the graph converter."""
+        return {
+            "atom_graph_cutoff": self.atom_graph_cutoff,
+            "line_graph_cutoff": self.line_graph_cutoff,
+            "algorithm": self.algorithm,
+        }
+
+    @classmethod
+    def from_dict(cls, dict) -> GraphConverter:
+        """Create converter from dictionary."""
+        return GraphConverter(**dict)

models/matris/matris/graph/cygraph.pyx

@@ -0,0 +1,174 @@
+"""
+    This code is referenced from: https://github.com/CederGroupHub/chgnet/blob/main/chgnet/graph/converter.py
+    The original implementation can be found at the link above.
+"""
+
+# cython: language_level=3
+# cython: initializedcheck=False
+# cython: nonecheck=False
+# cython: boundscheck=False
+# cython: wraparound=False
+# cython: cdivision=True
+# cython: profile=False
+# distutils: language = c
+
+
+from . import radiusgraph
+import numpy as np
+from libc.stdlib cimport free
+
+cdef extern from 'fast_converter_libraries/create_graph.c':
+    ctypedef struct Node:
+        long index
+        LongToDirectedEdgeList* neighbors
+        long num_neighbors
+
+    ctypedef struct NodeIndexPair:
+        long center
+        long neighbor
+
+    ctypedef struct UndirectedEdge:
+        NodeIndexPair nodes
+        long index
+        long* directed_edge_indices
+        long num_directed_edges
+        double distance
+
+    ctypedef struct DirectedEdge:
+        NodeIndexPair nodes
+        long index
+        const long* image
+        long undirected_edge_index
+        double distance
+
+    ctypedef struct LongToDirectedEdgeList:
+        long key
+        DirectedEdge** directed_edges_list
+        int num_directed_edges_in_group
+
+    ctypedef struct ReturnElems2:
+        long num_nodes
+        long num_directed_edges
+        long num_undirected_edges
+        Node* nodes
+        UndirectedEdge** undirected_edges_list
+        DirectedEdge** directed_edges_list
+
+    ReturnElems2* create_graph(
+        long* center_index,
+        long n_e,
+        long* neighbor_index,
+        long* image,
+        double* distance,
+        long num_atoms)
+
+    void free_LongToDirectedEdgeList_in_nodes(Node* nodes, long num_nodes)
+
+
+    LongToDirectedEdgeList** get_neighbors(Node* node)
+
+def make_graph(
+        const long[::1] center_index,
+        const long n_e,
+        const long[::1] neighbor_index,
+        const long[:, ::1] image,
+        const double[::1] distance,
+        const long num_atoms
+    ):
+    cdef ReturnElems2* returned
+    returned = <ReturnElems2*> create_graph(<long*> &center_index[0], n_e, <long*> &neighbor_index[0], <long*> &image[0][0], <double*> &distance[0], num_atoms)
+    
+    chg_DirectedEdge = radiusgraph.DirectedEdge
+    chg_Node = radiusgraph.Node
+    chg_UndirectedEdge = radiusgraph.UndirectedEdge
+    
+    image_np = np.asarray(image)
+
+    cdef LongToDirectedEdgeList** node_neighbors
+    cdef Node this_node
+    cdef LongToDirectedEdgeList this_entry
+    py_nodes = []
+    cdef DirectedEdge* this_DE
+
+    # Handling nodes + directed edges
+    for idx in range(returned[0].num_nodes):
+        this_node = returned[0].nodes[idx]
+        this_py_node = chg_Node(index=idx)
+
+        node_neighbors = get_neighbors(&this_node)
+
+        # Iterate through all neighbors and populate our py_node.neighbors dict
+        for j in range(this_node.num_neighbors):
+            this_entry = node_neighbors[j][0]
+            directed_edges = []
+
+            for k in range(this_entry.num_directed_edges_in_group):
+                this_DE = this_entry.directed_edges_list[k]
+                directed_edges.append(this_DE[0].index)
+
+            this_py_node.neighbors[this_entry.key] = directed_edges
+
+        py_nodes.append(this_py_node)
+
+        free(node_neighbors)
+
+    # Handling directed edges
+    py_directed_edges_list = []
+
+    for idx in range(returned[0].num_directed_edges):
+        this_DE = returned[0].directed_edges_list[idx]
+        py_DE = chg_DirectedEdge(nodes = [this_DE[0].nodes.center, this_DE[0].nodes.neighbor], index=this_DE[0].index, info = {"distance": this_DE[0].distance, "image": image_np[this_DE[0].index], "undirected_edge_index": this_DE[0].undirected_edge_index})
+
+        py_directed_edges_list.append(py_DE)
+
+
+    # Handling undirected edges
+    py_undirected_edges_list = []
+    cdef UndirectedEdge* UDE
+
+    for idx in range(returned[0].num_undirected_edges):
+        UDE = returned[0].undirected_edges_list[idx]
+        py_undirected_edge = chg_UndirectedEdge([UDE[0].nodes.center, UDE[0].nodes.neighbor], index = UDE[0].index, info =  {"distance": UDE[0].distance, "directed_edge_index": []})
+
+        for j in range(UDE[0].num_directed_edges):
+            py_undirected_edge.info["directed_edge_index"].append(UDE[0].directed_edge_indices[j])
+
+        py_undirected_edges_list.append(py_undirected_edge)
+
+
+    # Create Undirected_Edges hashmap
+    py_undirected_edges = {}
+    for undirected_edge in py_undirected_edges_list:
+        this_set = frozenset(undirected_edge.nodes)
+        if this_set not in py_undirected_edges:
+            py_undirected_edges[this_set] = [undirected_edge]
+        else:
+            py_undirected_edges[this_set].append(undirected_edge)
+
+    # # Update the nodes list to have pointers to DirectedEdges instead of indices
+    for node_index in range(returned[0].num_nodes):
+        this_neighbors = py_nodes[node_index].neighbors
+        for this_neighbor_index in this_neighbors:
+            replacement = [py_directed_edges_list[edge_index] for edge_index in this_neighbors[this_neighbor_index]]
+            this_neighbors[this_neighbor_index] = replacement
+
+
+    # Free everything unneeded
+    for idx in range(returned[0].num_directed_edges):
+        free(returned[0].directed_edges_list[idx])
+
+    for idx in range(returned[0].num_undirected_edges):
+        free(returned[0].undirected_edges_list[idx].directed_edge_indices)
+        free(returned[0].undirected_edges_list[idx])
+
+
+    # Free node LongToDirectedEdgeList
+    free_LongToDirectedEdgeList_in_nodes(returned[0].nodes, returned[0].num_nodes)
+
+    free(returned[0].directed_edges_list)
+    free(returned[0].undirected_edges_list)
+    free(returned[0].nodes)
+
+    free(returned)
+    
+    return py_nodes, py_directed_edges_list, py_undirected_edges_list, py_undirected_edges

models/matris/matris/graph/fast_converter_libraries/create_graph.c

@@ -0,0 +1,423 @@
+#include "uthash.h"
+#include <stdbool.h>
+
+typedef struct _UndirectedEdge UndirectedEdge;
+typedef struct _DirectedEdge DirectedEdge;
+typedef struct _Node Node;
+typedef struct _NodeIndexPair NodeIndexPair;
+typedef struct _LongToDirectedEdgeList LongToDirectedEdgeList;
+typedef struct _ReturnElems2 ReturnElems2;
+
+// NOTE: This code was mainly written to replicate the original add_edges method
+// in the graph class in chgnet.graph.graph such that anyone familiar with that code should be able to pick up this
+// code pretty easily.
+
+long MEM_ERR = 100;
+
+typedef struct _Node {
+    long index;
+    LongToDirectedEdgeList* neighbors; // Assuming neighbors can only be directed edge. Key is dest_node, value is DirectedEdge struct
+    long num_neighbors;
+} Node;
+
+typedef struct _NodeIndexPair {
+    long center;
+    long neighbor;
+} NodeIndexPair;
+
+typedef struct _UndirectedEdge {
+    NodeIndexPair nodes;
+    long index;
+    long* directed_edge_indices;
+    long num_directed_edges;
+    double distance;
+} UndirectedEdge;
+
+typedef struct _DirectedEdge {
+    NodeIndexPair nodes;
+    long index;
+    const long* image; // Only access the first 3, never edit
+    long undirected_edge_index;
+    double distance;
+} DirectedEdge;
+
+typedef struct _StructToUndirectedEdgeList {
+    NodeIndexPair key;
+    UndirectedEdge** undirected_edges_list;
+    int num_undirected_edges_in_group;
+    UT_hash_handle hh;
+} StructToUndirectedEdgeList;
+
+typedef struct _LongToDirectedEdgeList {
+    long key;
+    DirectedEdge** directed_edges_list;
+    int num_directed_edges_in_group;
+    UT_hash_handle hh;
+} LongToDirectedEdgeList;
+
+
+typedef struct _ReturnElems2 {
+    long num_nodes;
+    long num_directed_edges;
+    long num_undirected_edges;
+    Node* nodes;
+    UndirectedEdge** undirected_edges_list;
+    DirectedEdge** directed_edges_list;
+} ReturnElems2;
+
+bool find_in_undirected(NodeIndexPair* tmp, StructToUndirectedEdgeList** undirected_edges, StructToUndirectedEdgeList** found_entry);
+void directed_to_undirected(DirectedEdge* directed, UndirectedEdge* undirected, long undirected_index);
+void create_new_undirected_edges_entry(StructToUndirectedEdgeList** undirected_edges, NodeIndexPair* tmp, UndirectedEdge* new_undirected_edge);
+void append_to_undirected_edges_tmp(UndirectedEdge* undirected, StructToUndirectedEdgeList** undirected_edges, NodeIndexPair* tmp);
+void append_to_undirected_edges_list(UndirectedEdge** undirected_edges_list, UndirectedEdge* to_add, long* num_undirected_edges);
+void append_to_directed_edges_list(DirectedEdge** directed_edges_list, DirectedEdge* to_add, long* num_directed_edges);
+void add_neighbors_to_node(Node* node, long neighbor_index, DirectedEdge* directed_edge);
+void print_neighbors(Node* node);
+void append_to_directed_edge_indices(UndirectedEdge* undirected_edge, long directed_edge_index);
+bool is_reversed_directed_edge(DirectedEdge* directed_edge1, DirectedEdge* directed_edge2);
+void free_undirected_edges(StructToUndirectedEdgeList** undirected_edges);
+void free_LongToDirectedEdgeList_in_nodes(Node* nodes, long num_nodes);
+
+
+Node* create_nodes(long num_nodes) {
+    Node* Nodes = (Node*) malloc(sizeof(Node) * num_nodes);
+
+    if (Nodes == NULL) {
+        return NULL;
+    }
+
+    for (long i = 0; i < num_nodes; i++) {
+        Nodes[i].index = i;
+        Nodes[i].num_neighbors = 0;
+
+        // Initialize the uthash
+        Nodes[i].neighbors = NULL;
+    }
+
+    return Nodes;
+}
+
+ReturnElems2* create_graph(
+        long* center_indices,
+        long num_edges,
+        long* neighbor_indices,
+        long* images, // contiguous memory (row-major) of image elements (total of n_e * 3 integers)
+        double* distances,
+        long num_atoms
+    ) {
+    // Initialize pertinent data structures ---------------------
+    Node* nodes = create_nodes(num_atoms);
+
+    DirectedEdge** directed_edges_list = calloc(num_edges, sizeof(DirectedEdge));
+    long num_directed_edges = 0;
+
+    // There will never be more undirected edges than directed edges
+    UndirectedEdge** undirected_edges_list = calloc(num_edges, sizeof(UndirectedEdge));
+    long num_undirected_edges = 0;
+    StructToUndirectedEdgeList* undirected_edges = NULL;
+
+    // Pointer to beginning of list of UndirectedEdges corresponding to tmp of current iteration
+    StructToUndirectedEdgeList* corr_undirected_edges_item = NULL;
+
+    // Pointer to NodeIndexPair storing tmp
+    NodeIndexPair* tmp = malloc(sizeof(NodeIndexPair));
+
+    // Flag for whether or not the value was found
+    bool found = false;
+
+    // Flag used to show if we've already processed the current undirected edge
+    bool processed_edge = false;
+
+    // Pointer used to store the previously added directed edge between two nodes
+    DirectedEdge* added_DE;
+    DirectedEdge* this_directed_edge;
+
+    // Add all edges to graph information
+    for (long i = 0; i < num_edges; i++) {
+        // Haven't processed the edge yet
+        processed_edge = false;
+        // Create the current directed edge -------------------
+        this_directed_edge = calloc(1, sizeof(DirectedEdge));
+        this_directed_edge->nodes.center = center_indices[i];
+        this_directed_edge->nodes.neighbor = neighbor_indices[i];
+        this_directed_edge->distance = distances[i];
+        this_directed_edge->index = num_directed_edges;
+        this_directed_edge->image = images + (3 * i);
+
+        // Load tmp
+        memset(tmp, 0, sizeof(NodeIndexPair));
+        tmp->center = center_indices[i];
+        tmp->neighbor = neighbor_indices[i];
+
+        // See if tmp is in undirected
+        corr_undirected_edges_item = NULL;
+        found = find_in_undirected(tmp, &undirected_edges, &corr_undirected_edges_item);
+
+        if (!found) {
+            // Never seen this edge combination before
+            this_directed_edge->undirected_edge_index = num_undirected_edges;
+
+            // Create new undirected edge
+            UndirectedEdge* this_undirected_edge = malloc(sizeof(UndirectedEdge));
+
+            directed_to_undirected(this_directed_edge, this_undirected_edge, num_undirected_edges);
+
+            // Add this new edge information to various data structures
+            create_new_undirected_edges_entry(&undirected_edges, tmp, this_undirected_edge);
+            append_to_undirected_edges_list(undirected_edges_list, this_undirected_edge, &num_undirected_edges);
+            add_neighbors_to_node(&nodes[center_indices[i]], neighbor_indices[i], this_directed_edge);
+            append_to_directed_edges_list(directed_edges_list, this_directed_edge, &num_directed_edges);
+        } else {
+            // This pair of nodes has been added before. We have to check if it's the other directed edge (but pointed in
+            // the different direction) OR it's another totally different undirected edge that has different image and distance
+
+            // if found is true, then corr_undirected_edges_item points to self.undirected_edges[tmp]
+            // iterate through all previously scanned undirected edges that have the same endpoints as this edge
+                // if there exists an undirected edge with the same inverted image as this_undirected_edge, then add this new directed edge
+                // and associate it with this undirected edge
+            for (int j = 0; j < corr_undirected_edges_item->num_undirected_edges_in_group; j++) {
+                // Grab the 0th directed edge associated with this undirected edge
+                added_DE = directed_edges_list[((corr_undirected_edges_item->undirected_edges_list)[j]->directed_edge_indices)[0]];
+
+                if (is_reversed_directed_edge(added_DE, this_directed_edge)) {
+                    this_directed_edge->undirected_edge_index = added_DE->undirected_edge_index;
+                    add_neighbors_to_node(&nodes[center_indices[i]], neighbor_indices[i], this_directed_edge);
+                    append_to_directed_edges_list(directed_edges_list, this_directed_edge, &num_directed_edges);
+                    append_to_directed_edge_indices((corr_undirected_edges_item->undirected_edges_list)[j], this_directed_edge->index);
+                    processed_edge = true;
+                    break;
+                }
+            }
+            // There wasn't a pre-existing undirected edge that corresponds to this directed edge
+            // Create a new undirected edge and process
+            if (!processed_edge) {
+                this_directed_edge->undirected_edge_index = num_undirected_edges;
+                // Create a new undirected edge
+                UndirectedEdge* this_undirected_edge = malloc(sizeof(UndirectedEdge));
+                directed_to_undirected(this_directed_edge, this_undirected_edge, num_undirected_edges);
+                append_to_undirected_edges_tmp(this_undirected_edge, &undirected_edges, tmp);
+                append_to_undirected_edges_list(undirected_edges_list, this_undirected_edge, &num_undirected_edges);
+                add_neighbors_to_node(&nodes[center_indices[i]], neighbor_indices[i], this_directed_edge);
+                append_to_directed_edges_list(directed_edges_list, this_directed_edge, &num_directed_edges);
+            }
+        }
+    }
+
+    ReturnElems2* returned2 = malloc(sizeof(ReturnElems2));
+    returned2->num_nodes = num_atoms;
+    returned2->num_undirected_edges = num_undirected_edges;
+    returned2->num_directed_edges = num_directed_edges;
+
+    returned2->nodes = nodes;
+    returned2->directed_edges_list = directed_edges_list;
+    returned2->undirected_edges_list = undirected_edges_list;
+
+    free(tmp);
+    free_undirected_edges(&undirected_edges);
+
+    return returned2;
+}
+
+void print_neighbors(Node* node) {
+    LongToDirectedEdgeList *tmp, *neighbor;
+    HASH_ITER(hh, node->neighbors, neighbor, tmp) {
+        printf("C:neighboring atom: %lu\n", neighbor->key);
+    }
+}
+
+void free_undirected_edges(StructToUndirectedEdgeList** undirected_edges) {
+    StructToUndirectedEdgeList* current;
+    StructToUndirectedEdgeList* tmp;
+
+    HASH_ITER(hh, *undirected_edges, current, tmp) {
+        HASH_DEL(*undirected_edges, current);
+        free(current->undirected_edges_list);
+        free(current);
+    }
+}
+
+void free_LongToDirectedEdgeList_in_nodes(Node* nodes, long num_nodes) {
+    LongToDirectedEdgeList* current;
+    LongToDirectedEdgeList* tmp;
+
+    for (long node_i = 0; node_i < num_nodes; node_i++) {
+        HASH_ITER(hh, nodes[node_i].neighbors, current, tmp) {
+            HASH_DEL(nodes[node_i].neighbors, current);
+            free(current->directed_edges_list);
+            free(current);
+        }
+    }
+}
+
+// Returns true if the two directed edges have images that are inverted
+// NOTE: assumes that directed_edge1->center = directed_edge2->neighbor and directed_edge1->neighbor = directed_edge2->center
+bool is_reversed_directed_edge(DirectedEdge* directed_edge1, DirectedEdge* directed_edge2) {
+    for (int i = 0; i < 3; i++) {
+        if (directed_edge1->image[i] != -1 * directed_edge2->image[i]) {
+            return false;
+        }
+    }
+
+    // The two directed edges should have opposing center/neighbor nodes (i.e. center-neighbor for DE1 is [0, 1] and for DE2 is [1, 0])
+    // We check for that condition here
+    if (directed_edge1->nodes.center != directed_edge2->nodes.neighbor) {
+        return false;
+    }
+    if (directed_edge1->nodes.neighbor != directed_edge2->nodes.center) {
+        return false;
+    }
+    return true;
+}
+
+// If tmp or the reverse of tmp is found in undirected_edges, True is returned and the corresponding StructToUndirectedEdgeList pointer is placed
+// into found_entry. Otherwise, False is returned.
+// NOTE: does not edit the *tmp
+// Assumes *tmp bits have already been 0'd at padding within a struct
+bool find_in_undirected(NodeIndexPair* tmp, StructToUndirectedEdgeList** undirected_edges, StructToUndirectedEdgeList** found_entry) {
+    StructToUndirectedEdgeList* out_list;
+    // Check tmp
+    HASH_FIND(hh, *undirected_edges, tmp, sizeof(NodeIndexPair), out_list);
+
+    if (out_list) {
+        *found_entry = out_list;
+        return true;
+    }
+
+    // Check tmp_rev
+    NodeIndexPair tmp_rev;
+    tmp_rev.center = tmp->neighbor;
+    tmp_rev.neighbor = tmp->center;
+
+    HASH_FIND(hh, *undirected_edges, &tmp_rev, sizeof(NodeIndexPair), out_list);
+
+    if (out_list) {
+        *found_entry = out_list;
+        return true;
+    }
+
+    return false;
+}
+
+
+// Creates new entry in undirected_edges and initializes necessary arrays
+void create_new_undirected_edges_entry(StructToUndirectedEdgeList** undirected_edges, NodeIndexPair* tmp, UndirectedEdge* new_undirected_edge) {
+    StructToUndirectedEdgeList* new_entry = malloc(sizeof(StructToUndirectedEdgeList));
+    memset(new_entry, 0, sizeof(StructToUndirectedEdgeList));
+
+    // Set up fields within the new entry in the hashmap
+    new_entry->key.center = tmp->center;
+    new_entry->key.neighbor = tmp->neighbor;
+
+    new_entry->num_undirected_edges_in_group = 1;
+    new_entry->undirected_edges_list = malloc(sizeof(UndirectedEdge*));
+    new_entry->undirected_edges_list[0] = new_undirected_edge;
+
+    HASH_ADD(hh, *undirected_edges, key, sizeof(NodeIndexPair), new_entry);
+
+}
+
+// Appends undirected into the StructToUndirectedEdgeList entry that corresponds to tmp
+// This function will first look up tmp
+void append_to_undirected_edges_tmp(UndirectedEdge* undirected, StructToUndirectedEdgeList** undirected_edges, NodeIndexPair* tmp) {
+
+    StructToUndirectedEdgeList* this_undirected_edges_item;
+    find_in_undirected(tmp, undirected_edges, &this_undirected_edges_item);
+
+    long num_undirected_edges = this_undirected_edges_item->num_undirected_edges_in_group;
+
+    // No need to worry about originally malloc'ing memory for this_undirected_edges_item->undirected_edges_list
+    // this is because, we first call create_new_undirected_edges_entry for all entries. This function already mallocs for us.
+
+    // Realloc the space to fit a new pointer to an undirected edge
+    UndirectedEdge** new_list = realloc(this_undirected_edges_item->undirected_edges_list, sizeof(UndirectedEdge*) * (num_undirected_edges + 1));
+    this_undirected_edges_item->undirected_edges_list = new_list;
+
+    // Insert the undirected pointer into the newly allocated slot
+    this_undirected_edges_item->undirected_edges_list[num_undirected_edges] = undirected;
+
+    // Increase the counter for # of undirected edges
+    this_undirected_edges_item->num_undirected_edges_in_group = num_undirected_edges + 1;
+}
+
+
+void directed_to_undirected(DirectedEdge* directed, UndirectedEdge* undirected, long undirected_index) {
+    // Copy over image and distance
+    undirected->distance = directed->distance;
+    undirected->nodes = directed->nodes;
+    undirected->index = undirected_index;
+
+    // Add a new directed_edge_index to the directed_edge_indices pointer. This should be the first
+    undirected->num_directed_edges = 1;
+    undirected->directed_edge_indices = malloc(sizeof(long));
+    undirected->directed_edge_indices[0] = directed->index;
+}
+
+
+void append_to_undirected_edges_list(UndirectedEdge** undirected_edges_list, UndirectedEdge* to_add, long* num_undirected_edges) {
+    // No need to realloc for space since our original alloc should cover everything
+
+    // Assign value to next available position
+    undirected_edges_list[*num_undirected_edges] = to_add;
+    *num_undirected_edges += 1;
+}
+
+void append_to_directed_edges_list(DirectedEdge** directed_edges_list, DirectedEdge* to_add, long* num_directed_edges) {
+    // No need to realloc for space since our original alloc should cover everything
+
+    // Assign value to next available position
+    directed_edges_list[*num_directed_edges] = to_add;
+    *num_directed_edges += 1;
+}
+
+void append_to_directed_edge_indices(UndirectedEdge* undirected_edge, long directed_edge_index) {
+    // TODO: don't need to realloc if we always know that there will be 2 directed edges per undirected edge. Update this later for performance boosts.
+    // TODO: other random performance boost: don't pass longs into function parameters, pass long* instead
+    undirected_edge->directed_edge_indices = realloc(undirected_edge->directed_edge_indices, sizeof(long) * (undirected_edge->num_directed_edges + 1));
+    undirected_edge->directed_edge_indices[undirected_edge->num_directed_edges] = directed_edge_index;
+    undirected_edge->num_directed_edges += 1;
+}
+
+// If there already exists neighbor_index within the Node node, then adds directed_edge to the list of directed edges.
+// If there doesn't already exist neighbor_index within the Node node, then create a new entry into the node's neighbors hashmap and add the entry
+void add_neighbors_to_node(Node* node, long neighbor_index, DirectedEdge* directed_edge) {
+    LongToDirectedEdgeList* entry = NULL;
+
+    // Search for the neighbor_index in our hashmap
+    HASH_FIND(hh, node->neighbors, &neighbor_index, sizeof(long), entry);
+
+    if (entry) {
+        // We found something, update the list within this pointer
+        entry->directed_edges_list = realloc(entry->directed_edges_list, sizeof(DirectedEdge*) * (entry->num_directed_edges_in_group + 1));
+        entry->directed_edges_list[entry->num_directed_edges_in_group] = directed_edge;
+
+        entry->num_directed_edges_in_group += 1;
+    } else {
+        // allocate memory for entry
+        entry = malloc(sizeof(LongToDirectedEdgeList));
+
+        // The entry doesn't exist, initialize the entry and enter it into our hashmap
+        entry->directed_edges_list = malloc(sizeof(DirectedEdge*));
+        entry->directed_edges_list[0] = directed_edge;
+        entry->key = neighbor_index;
+
+        entry->num_directed_edges_in_group = 1;
+        HASH_ADD(hh, node->neighbors, key, sizeof(long), entry);
+
+        node->num_neighbors += 1;
+    }
+}
+
+// Returns a list of LongToDirectedEdgeList pointers which are entries for the neighbors of the inputted node
+LongToDirectedEdgeList** get_neighbors(Node* node) {
+    long num_neighbors = HASH_COUNT(node->neighbors);
+    LongToDirectedEdgeList** entries = malloc(sizeof(LongToDirectedEdgeList*) * num_neighbors);
+
+    LongToDirectedEdgeList* entry;
+    long counter = 0;
+    for (entry = node->neighbors; entry != NULL; entry = entry->hh.next) {
+        entries[counter] = entry;
+        counter += 1;
+    }
+
+    return entries;
+}

models/matris/matris/graph/fast_converter_libraries/uthash.h

@@ -0,0 +1,1140 @@
+/*
+Copyright (c) 2003-2022, Troy D. Hanson  https://troydhanson.github.io/uthash/
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef UTHASH_H
+#define UTHASH_H
+
+#define UTHASH_VERSION 2.3.0
+
+#include <string.h>   /* memcmp, memset, strlen */
+#include <stddef.h>   /* ptrdiff_t */
+#include <stdlib.h>   /* exit */
+
+#if defined(HASH_DEFINE_OWN_STDINT) && HASH_DEFINE_OWN_STDINT
+/* This codepath is provided for backward compatibility, but I plan to remove it. */
+#warning "HASH_DEFINE_OWN_STDINT is deprecated; please use HASH_NO_STDINT instead"
+typedef unsigned int uint32_t;
+typedef unsigned char uint8_t;
+#elif defined(HASH_NO_STDINT) && HASH_NO_STDINT
+#else
+#include <stdint.h>   /* uint8_t, uint32_t */
+#endif
+
+/* These macros use decltype or the earlier __typeof GNU extension.
+   As decltype is only available in newer compilers (VS2010 or gcc 4.3+
+   when compiling c++ source) this code uses whatever method is needed
+   or, for VS2008 where neither is available, uses casting workarounds. */
+#if !defined(DECLTYPE) && !defined(NO_DECLTYPE)
+#if defined(_MSC_VER)   /* MS compiler */
+#if _MSC_VER >= 1600 && defined(__cplusplus)  /* VS2010 or newer in C++ mode */
+#define DECLTYPE(x) (decltype(x))
+#else                   /* VS2008 or older (or VS2010 in C mode) */
+#define NO_DECLTYPE
+#endif
+#elif defined(__MCST__)  /* Elbrus C Compiler */
+#define DECLTYPE(x) (__typeof(x))
+#elif defined(__BORLANDC__) || defined(__ICCARM__) || defined(__LCC__) || defined(__WATCOMC__)
+#define NO_DECLTYPE
+#else                   /* GNU, Sun and other compilers */
+#define DECLTYPE(x) (__typeof(x))
+#endif
+#endif
+
+#ifdef NO_DECLTYPE
+#define DECLTYPE(x)
+#define DECLTYPE_ASSIGN(dst,src)                                                 \
+do {                                                                             \
+  char **_da_dst = (char**)(&(dst));                                             \
+  *_da_dst = (char*)(src);                                                       \
+} while (0)
+#else
+#define DECLTYPE_ASSIGN(dst,src)                                                 \
+do {                                                                             \
+  (dst) = DECLTYPE(dst)(src);                                                    \
+} while (0)
+#endif
+
+#ifndef uthash_malloc
+#define uthash_malloc(sz) malloc(sz)      /* malloc fcn                      */
+#endif
+#ifndef uthash_free
+#define uthash_free(ptr,sz) free(ptr)     /* free fcn                        */
+#endif
+#ifndef uthash_bzero
+#define uthash_bzero(a,n) memset(a,'\0',n)
+#endif
+#ifndef uthash_strlen
+#define uthash_strlen(s) strlen(s)
+#endif
+
+#ifndef HASH_FUNCTION
+#define HASH_FUNCTION(keyptr,keylen,hashv) HASH_JEN(keyptr, keylen, hashv)
+#endif
+
+#ifndef HASH_KEYCMP
+#define HASH_KEYCMP(a,b,n) memcmp(a,b,n)
+#endif
+
+#ifndef uthash_noexpand_fyi
+#define uthash_noexpand_fyi(tbl)          /* can be defined to log noexpand  */
+#endif
+#ifndef uthash_expand_fyi
+#define uthash_expand_fyi(tbl)            /* can be defined to log expands   */
+#endif
+
+#ifndef HASH_NONFATAL_OOM
+#define HASH_NONFATAL_OOM 0
+#endif
+
+#if HASH_NONFATAL_OOM
+/* malloc failures can be recovered from */
+
+#ifndef uthash_nonfatal_oom
+#define uthash_nonfatal_oom(obj) do {} while (0)    /* non-fatal OOM error */
+#endif
+
+#define HASH_RECORD_OOM(oomed) do { (oomed) = 1; } while (0)
+#define IF_HASH_NONFATAL_OOM(x) x
+
+#else
+/* malloc failures result in lost memory, hash tables are unusable */
+
+#ifndef uthash_fatal
+#define uthash_fatal(msg) exit(-1)        /* fatal OOM error */
+#endif
+
+#define HASH_RECORD_OOM(oomed) uthash_fatal("out of memory")
+#define IF_HASH_NONFATAL_OOM(x)
+
+#endif
+
+/* initial number of buckets */
+#define HASH_INITIAL_NUM_BUCKETS 32U     /* initial number of buckets        */
+#define HASH_INITIAL_NUM_BUCKETS_LOG2 5U /* lg2 of initial number of buckets */
+#define HASH_BKT_CAPACITY_THRESH 10U     /* expand when bucket count reaches */
+
+/* calculate the element whose hash handle address is hhp */
+#define ELMT_FROM_HH(tbl,hhp) ((void*)(((char*)(hhp)) - ((tbl)->hho)))
+/* calculate the hash handle from element address elp */
+#define HH_FROM_ELMT(tbl,elp) ((UT_hash_handle*)(void*)(((char*)(elp)) + ((tbl)->hho)))
+
+#define HASH_ROLLBACK_BKT(hh, head, itemptrhh)                                   \
+do {                                                                             \
+  struct UT_hash_handle *_hd_hh_item = (itemptrhh);                              \
+  unsigned _hd_bkt;                                                              \
+  HASH_TO_BKT(_hd_hh_item->hashv, (head)->hh.tbl->num_buckets, _hd_bkt);         \
+  (head)->hh.tbl->buckets[_hd_bkt].count++;                                      \
+  _hd_hh_item->hh_next = NULL;                                                   \
+  _hd_hh_item->hh_prev = NULL;                                                   \
+} while (0)
+
+#define HASH_VALUE(keyptr,keylen,hashv)                                          \
+do {                                                                             \
+  HASH_FUNCTION(keyptr, keylen, hashv);                                          \
+} while (0)
+
+#define HASH_FIND_BYHASHVALUE(hh,head,keyptr,keylen,hashval,out)                 \
+do {                                                                             \
+  (out) = NULL;                                                                  \
+  if (head) {                                                                    \
+    unsigned _hf_bkt;                                                            \
+    HASH_TO_BKT(hashval, (head)->hh.tbl->num_buckets, _hf_bkt);                  \
+    if (HASH_BLOOM_TEST((head)->hh.tbl, hashval) != 0) {                         \
+      HASH_FIND_IN_BKT((head)->hh.tbl, hh, (head)->hh.tbl->buckets[ _hf_bkt ], keyptr, keylen, hashval, out); \
+    }                                                                            \
+  }                                                                              \
+} while (0)
+
+#define HASH_FIND(hh,head,keyptr,keylen,out)                                     \
+do {                                                                             \
+  (out) = NULL;                                                                  \
+  if (head) {                                                                    \
+    unsigned _hf_hashv;                                                          \
+    HASH_VALUE(keyptr, keylen, _hf_hashv);                                       \
+    HASH_FIND_BYHASHVALUE(hh, head, keyptr, keylen, _hf_hashv, out);             \
+  }                                                                              \
+} while (0)
+
+#ifdef HASH_BLOOM
+#define HASH_BLOOM_BITLEN (1UL << HASH_BLOOM)
+#define HASH_BLOOM_BYTELEN (HASH_BLOOM_BITLEN/8UL) + (((HASH_BLOOM_BITLEN%8UL)!=0UL) ? 1UL : 0UL)
+#define HASH_BLOOM_MAKE(tbl,oomed)                                               \
+do {                                                                             \
+  (tbl)->bloom_nbits = HASH_BLOOM;                                               \
+  (tbl)->bloom_bv = (uint8_t*)uthash_malloc(HASH_BLOOM_BYTELEN);                 \
+  if (!(tbl)->bloom_bv) {                                                        \
+    HASH_RECORD_OOM(oomed);                                                      \
+  } else {                                                                       \
+    uthash_bzero((tbl)->bloom_bv, HASH_BLOOM_BYTELEN);                           \
+    (tbl)->bloom_sig = HASH_BLOOM_SIGNATURE;                                     \
+  }                                                                              \
+} while (0)
+
+#define HASH_BLOOM_FREE(tbl)                                                     \
+do {                                                                             \
+  uthash_free((tbl)->bloom_bv, HASH_BLOOM_BYTELEN);                              \
+} while (0)
+
+#define HASH_BLOOM_BITSET(bv,idx) (bv[(idx)/8U] |= (1U << ((idx)%8U)))
+#define HASH_BLOOM_BITTEST(bv,idx) (bv[(idx)/8U] & (1U << ((idx)%8U)))
+
+#define HASH_BLOOM_ADD(tbl,hashv)                                                \
+  HASH_BLOOM_BITSET((tbl)->bloom_bv, ((hashv) & (uint32_t)((1UL << (tbl)->bloom_nbits) - 1U)))
+
+#define HASH_BLOOM_TEST(tbl,hashv)                                               \
+  HASH_BLOOM_BITTEST((tbl)->bloom_bv, ((hashv) & (uint32_t)((1UL << (tbl)->bloom_nbits) - 1U)))
+
+#else
+#define HASH_BLOOM_MAKE(tbl,oomed)
+#define HASH_BLOOM_FREE(tbl)
+#define HASH_BLOOM_ADD(tbl,hashv)
+#define HASH_BLOOM_TEST(tbl,hashv) (1)
+#define HASH_BLOOM_BYTELEN 0U
+#endif
+
+#define HASH_MAKE_TABLE(hh,head,oomed)                                           \
+do {                                                                             \
+  (head)->hh.tbl = (UT_hash_table*)uthash_malloc(sizeof(UT_hash_table));         \
+  if (!(head)->hh.tbl) {                                                         \
+    HASH_RECORD_OOM(oomed);                                                      \
+  } else {                                                                       \
+    uthash_bzero((head)->hh.tbl, sizeof(UT_hash_table));                         \
+    (head)->hh.tbl->tail = &((head)->hh);                                        \
+    (head)->hh.tbl->num_buckets = HASH_INITIAL_NUM_BUCKETS;                      \
+    (head)->hh.tbl->log2_num_buckets = HASH_INITIAL_NUM_BUCKETS_LOG2;            \
+    (head)->hh.tbl->hho = (char*)(&(head)->hh) - (char*)(head);                  \
+    (head)->hh.tbl->buckets = (UT_hash_bucket*)uthash_malloc(                    \
+        HASH_INITIAL_NUM_BUCKETS * sizeof(struct UT_hash_bucket));               \
+    (head)->hh.tbl->signature = HASH_SIGNATURE;                                  \
+    if (!(head)->hh.tbl->buckets) {                                              \
+      HASH_RECORD_OOM(oomed);                                                    \
+      uthash_free((head)->hh.tbl, sizeof(UT_hash_table));                        \
+    } else {                                                                     \
+      uthash_bzero((head)->hh.tbl->buckets,                                      \
+          HASH_INITIAL_NUM_BUCKETS * sizeof(struct UT_hash_bucket));             \
+      HASH_BLOOM_MAKE((head)->hh.tbl, oomed);                                    \
+      IF_HASH_NONFATAL_OOM(                                                      \
+        if (oomed) {                                                             \
+          uthash_free((head)->hh.tbl->buckets,                                   \
+              HASH_INITIAL_NUM_BUCKETS*sizeof(struct UT_hash_bucket));           \
+          uthash_free((head)->hh.tbl, sizeof(UT_hash_table));                    \
+        }                                                                        \
+      )                                                                          \
+    }                                                                            \
+  }                                                                              \
+} while (0)
+
+#define HASH_REPLACE_BYHASHVALUE_INORDER(hh,head,fieldname,keylen_in,hashval,add,replaced,cmpfcn) \
+do {                                                                             \
+  (replaced) = NULL;                                                             \
+  HASH_FIND_BYHASHVALUE(hh, head, &((add)->fieldname), keylen_in, hashval, replaced); \
+  if (replaced) {                                                                \
+    HASH_DELETE(hh, head, replaced);                                             \
+  }                                                                              \
+  HASH_ADD_KEYPTR_BYHASHVALUE_INORDER(hh, head, &((add)->fieldname), keylen_in, hashval, add, cmpfcn); \
+} while (0)
+
+#define HASH_REPLACE_BYHASHVALUE(hh,head,fieldname,keylen_in,hashval,add,replaced) \
+do {                                                                             \
+  (replaced) = NULL;                                                             \
+  HASH_FIND_BYHASHVALUE(hh, head, &((add)->fieldname), keylen_in, hashval, replaced); \
+  if (replaced) {                                                                \
+    HASH_DELETE(hh, head, replaced);                                             \
+  }                                                                              \
+  HASH_ADD_KEYPTR_BYHASHVALUE(hh, head, &((add)->fieldname), keylen_in, hashval, add); \
+} while (0)
+
+#define HASH_REPLACE(hh,head,fieldname,keylen_in,add,replaced)                   \
+do {                                                                             \
+  unsigned _hr_hashv;                                                            \
+  HASH_VALUE(&((add)->fieldname), keylen_in, _hr_hashv);                         \
+  HASH_REPLACE_BYHASHVALUE(hh, head, fieldname, keylen_in, _hr_hashv, add, replaced); \
+} while (0)
+
+#define HASH_REPLACE_INORDER(hh,head,fieldname,keylen_in,add,replaced,cmpfcn)    \
+do {                                                                             \
+  unsigned _hr_hashv;                                                            \
+  HASH_VALUE(&((add)->fieldname), keylen_in, _hr_hashv);                         \
+  HASH_REPLACE_BYHASHVALUE_INORDER(hh, head, fieldname, keylen_in, _hr_hashv, add, replaced, cmpfcn); \
+} while (0)
+
+#define HASH_APPEND_LIST(hh, head, add)                                          \
+do {                                                                             \
+  (add)->hh.next = NULL;                                                         \
+  (add)->hh.prev = ELMT_FROM_HH((head)->hh.tbl, (head)->hh.tbl->tail);           \
+  (head)->hh.tbl->tail->next = (add);                                            \
+  (head)->hh.tbl->tail = &((add)->hh);                                           \
+} while (0)
+
+#define HASH_AKBI_INNER_LOOP(hh,head,add,cmpfcn)                                 \
+do {                                                                             \
+  do {                                                                           \
+    if (cmpfcn(DECLTYPE(head)(_hs_iter), add) > 0) {                             \
+      break;                                                                     \
+    }                                                                            \
+  } while ((_hs_iter = HH_FROM_ELMT((head)->hh.tbl, _hs_iter)->next));           \
+} while (0)
+
+#ifdef NO_DECLTYPE
+#undef HASH_AKBI_INNER_LOOP
+#define HASH_AKBI_INNER_LOOP(hh,head,add,cmpfcn)                                 \
+do {                                                                             \
+  char *_hs_saved_head = (char*)(head);                                          \
+  do {                                                                           \
+    DECLTYPE_ASSIGN(head, _hs_iter);                                             \
+    if (cmpfcn(head, add) > 0) {                                                 \
+      DECLTYPE_ASSIGN(head, _hs_saved_head);                                     \
+      break;                                                                     \
+    }                                                                            \
+    DECLTYPE_ASSIGN(head, _hs_saved_head);                                       \
+  } while ((_hs_iter = HH_FROM_ELMT((head)->hh.tbl, _hs_iter)->next));           \
+} while (0)
+#endif
+
+#if HASH_NONFATAL_OOM
+
+#define HASH_ADD_TO_TABLE(hh,head,keyptr,keylen_in,hashval,add,oomed)            \
+do {                                                                             \
+  if (!(oomed)) {                                                                \
+    unsigned _ha_bkt;                                                            \
+    (head)->hh.tbl->num_items++;                                                 \
+    HASH_TO_BKT(hashval, (head)->hh.tbl->num_buckets, _ha_bkt);                  \
+    HASH_ADD_TO_BKT((head)->hh.tbl->buckets[_ha_bkt], hh, &(add)->hh, oomed);    \
+    if (oomed) {                                                                 \
+      HASH_ROLLBACK_BKT(hh, head, &(add)->hh);                                   \
+      HASH_DELETE_HH(hh, head, &(add)->hh);                                      \
+      (add)->hh.tbl = NULL;                                                      \
+      uthash_nonfatal_oom(add);                                                  \
+    } else {                                                                     \
+      HASH_BLOOM_ADD((head)->hh.tbl, hashval);                                   \
+      HASH_EMIT_KEY(hh, head, keyptr, keylen_in);                                \
+    }                                                                            \
+  } else {                                                                       \
+    (add)->hh.tbl = NULL;                                                        \
+    uthash_nonfatal_oom(add);                                                    \
+  }                                                                              \
+} while (0)
+
+#else
+
+#define HASH_ADD_TO_TABLE(hh,head,keyptr,keylen_in,hashval,add,oomed)            \
+do {                                                                             \
+  unsigned _ha_bkt;                                                              \
+  (head)->hh.tbl->num_items++;                                                   \
+  HASH_TO_BKT(hashval, (head)->hh.tbl->num_buckets, _ha_bkt);                    \
+  HASH_ADD_TO_BKT((head)->hh.tbl->buckets[_ha_bkt], hh, &(add)->hh, oomed);      \
+  HASH_BLOOM_ADD((head)->hh.tbl, hashval);                                       \
+  HASH_EMIT_KEY(hh, head, keyptr, keylen_in);                                    \
+} while (0)
+
+#endif
+
+
+#define HASH_ADD_KEYPTR_BYHASHVALUE_INORDER(hh,head,keyptr,keylen_in,hashval,add,cmpfcn) \
+do {                                                                             \
+  IF_HASH_NONFATAL_OOM( int _ha_oomed = 0; )                                     \
+  (add)->hh.hashv = (hashval);                                                   \
+  (add)->hh.key = (char*) (keyptr);                                              \
+  (add)->hh.keylen = (unsigned) (keylen_in);                                     \
+  if (!(head)) {                                                                 \
+    (add)->hh.next = NULL;                                                       \
+    (add)->hh.prev = NULL;                                                       \
+    HASH_MAKE_TABLE(hh, add, _ha_oomed);                                         \
+    IF_HASH_NONFATAL_OOM( if (!_ha_oomed) { )                                    \
+      (head) = (add);                                                            \
+    IF_HASH_NONFATAL_OOM( } )                                                    \
+  } else {                                                                       \
+    void *_hs_iter = (head);                                                     \
+    (add)->hh.tbl = (head)->hh.tbl;                                              \
+    HASH_AKBI_INNER_LOOP(hh, head, add, cmpfcn);                                 \
+    if (_hs_iter) {                                                              \
+      (add)->hh.next = _hs_iter;                                                 \
+      if (((add)->hh.prev = HH_FROM_ELMT((head)->hh.tbl, _hs_iter)->prev)) {     \
+        HH_FROM_ELMT((head)->hh.tbl, (add)->hh.prev)->next = (add);              \
+      } else {                                                                   \
+        (head) = (add);                                                          \
+      }                                                                          \
+      HH_FROM_ELMT((head)->hh.tbl, _hs_iter)->prev = (add);                      \
+    } else {                                                                     \
+      HASH_APPEND_LIST(hh, head, add);                                           \
+    }                                                                            \
+  }                                                                              \
+  HASH_ADD_TO_TABLE(hh, head, keyptr, keylen_in, hashval, add, _ha_oomed);       \
+  HASH_FSCK(hh, head, "HASH_ADD_KEYPTR_BYHASHVALUE_INORDER");                    \
+} while (0)
+
+#define HASH_ADD_KEYPTR_INORDER(hh,head,keyptr,keylen_in,add,cmpfcn)             \
+do {                                                                             \
+  unsigned _hs_hashv;                                                            \
+  HASH_VALUE(keyptr, keylen_in, _hs_hashv);                                      \
+  HASH_ADD_KEYPTR_BYHASHVALUE_INORDER(hh, head, keyptr, keylen_in, _hs_hashv, add, cmpfcn); \
+} while (0)
+
+#define HASH_ADD_BYHASHVALUE_INORDER(hh,head,fieldname,keylen_in,hashval,add,cmpfcn) \
+  HASH_ADD_KEYPTR_BYHASHVALUE_INORDER(hh, head, &((add)->fieldname), keylen_in, hashval, add, cmpfcn)
+
+#define HASH_ADD_INORDER(hh,head,fieldname,keylen_in,add,cmpfcn)                 \
+  HASH_ADD_KEYPTR_INORDER(hh, head, &((add)->fieldname), keylen_in, add, cmpfcn)
+
+#define HASH_ADD_KEYPTR_BYHASHVALUE(hh,head,keyptr,keylen_in,hashval,add)        \
+do {                                                                             \
+  IF_HASH_NONFATAL_OOM( int _ha_oomed = 0; )                                     \
+  (add)->hh.hashv = (hashval);                                                   \
+  (add)->hh.key = (const void*) (keyptr);                                        \
+  (add)->hh.keylen = (unsigned) (keylen_in);                                     \
+  if (!(head)) {                                                                 \
+    (add)->hh.next = NULL;                                                       \
+    (add)->hh.prev = NULL;                                                       \
+    HASH_MAKE_TABLE(hh, add, _ha_oomed);                                         \
+    IF_HASH_NONFATAL_OOM( if (!_ha_oomed) { )                                    \
+      (head) = (add);                                                            \
+    IF_HASH_NONFATAL_OOM( } )                                                    \
+  } else {                                                                       \
+    (add)->hh.tbl = (head)->hh.tbl;                                              \
+    HASH_APPEND_LIST(hh, head, add);                                             \
+  }                                                                              \
+  HASH_ADD_TO_TABLE(hh, head, keyptr, keylen_in, hashval, add, _ha_oomed);       \
+  HASH_FSCK(hh, head, "HASH_ADD_KEYPTR_BYHASHVALUE");                            \
+} while (0)
+
+#define HASH_ADD_KEYPTR(hh,head,keyptr,keylen_in,add)                            \
+do {                                                                             \
+  unsigned _ha_hashv;                                                            \
+  HASH_VALUE(keyptr, keylen_in, _ha_hashv);                                      \
+  HASH_ADD_KEYPTR_BYHASHVALUE(hh, head, keyptr, keylen_in, _ha_hashv, add);      \
+} while (0)
+
+#define HASH_ADD_BYHASHVALUE(hh,head,fieldname,keylen_in,hashval,add)            \
+  HASH_ADD_KEYPTR_BYHASHVALUE(hh, head, &((add)->fieldname), keylen_in, hashval, add)
+
+#define HASH_ADD(hh,head,fieldname,keylen_in,add)                                \
+  HASH_ADD_KEYPTR(hh, head, &((add)->fieldname), keylen_in, add)
+
+#define HASH_TO_BKT(hashv,num_bkts,bkt)                                          \
+do {                                                                             \
+  bkt = ((hashv) & ((num_bkts) - 1U));                                           \
+} while (0)
+
+/* delete "delptr" from the hash table.
+ * "the usual" patch-up process for the app-order doubly-linked-list.
+ * The use of _hd_hh_del below deserves special explanation.
+ * These used to be expressed using (delptr) but that led to a bug
+ * if someone used the same symbol for the head and deletee, like
+ *  HASH_DELETE(hh,users,users);
+ * We want that to work, but by changing the head (users) below
+ * we were forfeiting our ability to further refer to the deletee (users)
+ * in the patch-up process. Solution: use scratch space to
+ * copy the deletee pointer, then the latter references are via that
+ * scratch pointer rather than through the repointed (users) symbol.
+ */
+#define HASH_DELETE(hh,head,delptr)                                              \
+    HASH_DELETE_HH(hh, head, &(delptr)->hh)
+
+#define HASH_DELETE_HH(hh,head,delptrhh)                                         \
+do {                                                                             \
+  const struct UT_hash_handle *_hd_hh_del = (delptrhh);                          \
+  if ((_hd_hh_del->prev == NULL) && (_hd_hh_del->next == NULL)) {                \
+    HASH_BLOOM_FREE((head)->hh.tbl);                                             \
+    uthash_free((head)->hh.tbl->buckets,                                         \
+                (head)->hh.tbl->num_buckets * sizeof(struct UT_hash_bucket));    \
+    uthash_free((head)->hh.tbl, sizeof(UT_hash_table));                          \
+    (head) = NULL;                                                               \
+  } else {                                                                       \
+    unsigned _hd_bkt;                                                            \
+    if (_hd_hh_del == (head)->hh.tbl->tail) {                                    \
+      (head)->hh.tbl->tail = HH_FROM_ELMT((head)->hh.tbl, _hd_hh_del->prev);     \
+    }                                                                            \
+    if (_hd_hh_del->prev != NULL) {                                              \
+      HH_FROM_ELMT((head)->hh.tbl, _hd_hh_del->prev)->next = _hd_hh_del->next;   \
+    } else {                                                                     \
+      DECLTYPE_ASSIGN(head, _hd_hh_del->next);                                   \
+    }                                                                            \
+    if (_hd_hh_del->next != NULL) {                                              \
+      HH_FROM_ELMT((head)->hh.tbl, _hd_hh_del->next)->prev = _hd_hh_del->prev;   \
+    }                                                                            \
+    HASH_TO_BKT(_hd_hh_del->hashv, (head)->hh.tbl->num_buckets, _hd_bkt);        \
+    HASH_DEL_IN_BKT((head)->hh.tbl->buckets[_hd_bkt], _hd_hh_del);               \
+    (head)->hh.tbl->num_items--;                                                 \
+  }                                                                              \
+  HASH_FSCK(hh, head, "HASH_DELETE_HH");                                         \
+} while (0)
+
+/* convenience forms of HASH_FIND/HASH_ADD/HASH_DEL */
+#define HASH_FIND_STR(head,findstr,out)                                          \
+do {                                                                             \
+    unsigned _uthash_hfstr_keylen = (unsigned)uthash_strlen(findstr);            \
+    HASH_FIND(hh, head, findstr, _uthash_hfstr_keylen, out);                     \
+} while (0)
+#define HASH_ADD_STR(head,strfield,add)                                          \
+do {                                                                             \
+    unsigned _uthash_hastr_keylen = (unsigned)uthash_strlen((add)->strfield);    \
+    HASH_ADD(hh, head, strfield[0], _uthash_hastr_keylen, add);                  \
+} while (0)
+#define HASH_REPLACE_STR(head,strfield,add,replaced)                             \
+do {                                                                             \
+    unsigned _uthash_hrstr_keylen = (unsigned)uthash_strlen((add)->strfield);    \
+    HASH_REPLACE(hh, head, strfield[0], _uthash_hrstr_keylen, add, replaced);    \
+} while (0)
+#define HASH_FIND_INT(head,findint,out)                                          \
+    HASH_FIND(hh,head,findint,sizeof(int),out)
+#define HASH_ADD_INT(head,intfield,add)                                          \
+    HASH_ADD(hh,head,intfield,sizeof(int),add)
+#define HASH_REPLACE_INT(head,intfield,add,replaced)                             \
+    HASH_REPLACE(hh,head,intfield,sizeof(int),add,replaced)
+#define HASH_FIND_PTR(head,findptr,out)                                          \
+    HASH_FIND(hh,head,findptr,sizeof(void *),out)
+#define HASH_ADD_PTR(head,ptrfield,add)                                          \
+    HASH_ADD(hh,head,ptrfield,sizeof(void *),add)
+#define HASH_REPLACE_PTR(head,ptrfield,add,replaced)                             \
+    HASH_REPLACE(hh,head,ptrfield,sizeof(void *),add,replaced)
+#define HASH_DEL(head,delptr)                                                    \
+    HASH_DELETE(hh,head,delptr)
+
+/* HASH_FSCK checks hash integrity on every add/delete when HASH_DEBUG is defined.
+ * This is for uthash developer only; it compiles away if HASH_DEBUG isn't defined.
+ */
+#ifdef HASH_DEBUG
+#include <stdio.h>   /* fprintf, stderr */
+#define HASH_OOPS(...) do { fprintf(stderr, __VA_ARGS__); exit(-1); } while (0)
+#define HASH_FSCK(hh,head,where)                                                 \
+do {                                                                             \
+  struct UT_hash_handle *_thh;                                                   \
+  if (head) {                                                                    \
+    unsigned _bkt_i;                                                             \
+    unsigned _count = 0;                                                         \
+    char *_prev;                                                                 \
+    for (_bkt_i = 0; _bkt_i < (head)->hh.tbl->num_buckets; ++_bkt_i) {           \
+      unsigned _bkt_count = 0;                                                   \
+      _thh = (head)->hh.tbl->buckets[_bkt_i].hh_head;                            \
+      _prev = NULL;                                                              \
+      while (_thh) {                                                             \
+        if (_prev != (char*)(_thh->hh_prev)) {                                   \
+          HASH_OOPS("%s: invalid hh_prev %p, actual %p\n",                       \
+              (where), (void*)_thh->hh_prev, (void*)_prev);                      \
+        }                                                                        \
+        _bkt_count++;                                                            \
+        _prev = (char*)(_thh);                                                   \
+        _thh = _thh->hh_next;                                                    \
+      }                                                                          \
+      _count += _bkt_count;                                                      \
+      if ((head)->hh.tbl->buckets[_bkt_i].count !=  _bkt_count) {                \
+        HASH_OOPS("%s: invalid bucket count %u, actual %u\n",                    \
+            (where), (head)->hh.tbl->buckets[_bkt_i].count, _bkt_count);         \
+      }                                                                          \
+    }                                                                            \
+    if (_count != (head)->hh.tbl->num_items) {                                   \
+      HASH_OOPS("%s: invalid hh item count %u, actual %u\n",                     \
+          (where), (head)->hh.tbl->num_items, _count);                           \
+    }                                                                            \
+    _count = 0;                                                                  \
+    _prev = NULL;                                                                \
+    _thh =  &(head)->hh;                                                         \
+    while (_thh) {                                                               \
+      _count++;                                                                  \
+      if (_prev != (char*)_thh->prev) {                                          \
+        HASH_OOPS("%s: invalid prev %p, actual %p\n",                            \
+            (where), (void*)_thh->prev, (void*)_prev);                           \
+      }                                                                          \
+      _prev = (char*)ELMT_FROM_HH((head)->hh.tbl, _thh);                         \
+      _thh = (_thh->next ? HH_FROM_ELMT((head)->hh.tbl, _thh->next) : NULL);     \
+    }                                                                            \
+    if (_count != (head)->hh.tbl->num_items) {                                   \
+      HASH_OOPS("%s: invalid app item count %u, actual %u\n",                    \
+          (where), (head)->hh.tbl->num_items, _count);                           \
+    }                                                                            \
+  }                                                                              \
+} while (0)
+#else
+#define HASH_FSCK(hh,head,where)
+#endif
+
+/* When compiled with -DHASH_EMIT_KEYS, length-prefixed keys are emitted to
+ * the descriptor to which this macro is defined for tuning the hash function.
+ * The app can #include <unistd.h> to get the prototype for write(2). */
+#ifdef HASH_EMIT_KEYS
+#define HASH_EMIT_KEY(hh,head,keyptr,fieldlen)                                   \
+do {                                                                             \
+  unsigned _klen = fieldlen;                                                     \
+  write(HASH_EMIT_KEYS, &_klen, sizeof(_klen));                                  \
+  write(HASH_EMIT_KEYS, keyptr, (unsigned long)fieldlen);                        \
+} while (0)
+#else
+#define HASH_EMIT_KEY(hh,head,keyptr,fieldlen)
+#endif
+
+/* The Bernstein hash function, used in Perl prior to v5.6. Note (x<<5+x)=x*33. */
+#define HASH_BER(key,keylen,hashv)                                               \
+do {                                                                             \
+  unsigned _hb_keylen = (unsigned)keylen;                                        \
+  const unsigned char *_hb_key = (const unsigned char*)(key);                    \
+  (hashv) = 0;                                                                   \
+  while (_hb_keylen-- != 0U) {                                                   \
+    (hashv) = (((hashv) << 5) + (hashv)) + *_hb_key++;                           \
+  }                                                                              \
+} while (0)
+
+
+/* SAX/FNV/OAT/JEN hash functions are macro variants of those listed at
+ * http://eternallyconfuzzled.com/tuts/algorithms/jsw_tut_hashing.aspx
+ * (archive link: https://archive.is/Ivcan )
+ */
+#define HASH_SAX(key,keylen,hashv)                                               \
+do {                                                                             \
+  unsigned _sx_i;                                                                \
+  const unsigned char *_hs_key = (const unsigned char*)(key);                    \
+  hashv = 0;                                                                     \
+  for (_sx_i=0; _sx_i < keylen; _sx_i++) {                                       \
+    hashv ^= (hashv << 5) + (hashv >> 2) + _hs_key[_sx_i];                       \
+  }                                                                              \
+} while (0)
+/* FNV-1a variation */
+#define HASH_FNV(key,keylen,hashv)                                               \
+do {                                                                             \
+  unsigned _fn_i;                                                                \
+  const unsigned char *_hf_key = (const unsigned char*)(key);                    \
+  (hashv) = 2166136261U;                                                         \
+  for (_fn_i=0; _fn_i < keylen; _fn_i++) {                                       \
+    hashv = hashv ^ _hf_key[_fn_i];                                              \
+    hashv = hashv * 16777619U;                                                   \
+  }                                                                              \
+} while (0)
+
+#define HASH_OAT(key,keylen,hashv)                                               \
+do {                                                                             \
+  unsigned _ho_i;                                                                \
+  const unsigned char *_ho_key=(const unsigned char*)(key);                      \
+  hashv = 0;                                                                     \
+  for(_ho_i=0; _ho_i < keylen; _ho_i++) {                                        \
+      hashv += _ho_key[_ho_i];                                                   \
+      hashv += (hashv << 10);                                                    \
+      hashv ^= (hashv >> 6);                                                     \
+  }                                                                              \
+  hashv += (hashv << 3);                                                         \
+  hashv ^= (hashv >> 11);                                                        \
+  hashv += (hashv << 15);                                                        \
+} while (0)
+
+#define HASH_JEN_MIX(a,b,c)                                                      \
+do {                                                                             \
+  a -= b; a -= c; a ^= ( c >> 13 );                                              \
+  b -= c; b -= a; b ^= ( a << 8 );                                               \
+  c -= a; c -= b; c ^= ( b >> 13 );                                              \
+  a -= b; a -= c; a ^= ( c >> 12 );                                              \
+  b -= c; b -= a; b ^= ( a << 16 );                                              \
+  c -= a; c -= b; c ^= ( b >> 5 );                                               \
+  a -= b; a -= c; a ^= ( c >> 3 );                                               \
+  b -= c; b -= a; b ^= ( a << 10 );                                              \
+  c -= a; c -= b; c ^= ( b >> 15 );                                              \
+} while (0)
+
+#define HASH_JEN(key,keylen,hashv)                                               \
+do {                                                                             \
+  unsigned _hj_i,_hj_j,_hj_k;                                                    \
+  unsigned const char *_hj_key=(unsigned const char*)(key);                      \
+  hashv = 0xfeedbeefu;                                                           \
+  _hj_i = _hj_j = 0x9e3779b9u;                                                   \
+  _hj_k = (unsigned)(keylen);                                                    \
+  while (_hj_k >= 12U) {                                                         \
+    _hj_i +=    (_hj_key[0] + ( (unsigned)_hj_key[1] << 8 )                      \
+        + ( (unsigned)_hj_key[2] << 16 )                                         \
+        + ( (unsigned)_hj_key[3] << 24 ) );                                      \
+    _hj_j +=    (_hj_key[4] + ( (unsigned)_hj_key[5] << 8 )                      \
+        + ( (unsigned)_hj_key[6] << 16 )                                         \
+        + ( (unsigned)_hj_key[7] << 24 ) );                                      \
+    hashv += (_hj_key[8] + ( (unsigned)_hj_key[9] << 8 )                         \
+        + ( (unsigned)_hj_key[10] << 16 )                                        \
+        + ( (unsigned)_hj_key[11] << 24 ) );                                     \
+                                                                                 \
+     HASH_JEN_MIX(_hj_i, _hj_j, hashv);                                          \
+                                                                                 \
+     _hj_key += 12;                                                              \
+     _hj_k -= 12U;                                                               \
+  }                                                                              \
+  hashv += (unsigned)(keylen);                                                   \
+  switch ( _hj_k ) {                                                             \
+    case 11: hashv += ( (unsigned)_hj_key[10] << 24 ); /* FALLTHROUGH */         \
+    case 10: hashv += ( (unsigned)_hj_key[9] << 16 );  /* FALLTHROUGH */         \
+    case 9:  hashv += ( (unsigned)_hj_key[8] << 8 );   /* FALLTHROUGH */         \
+    case 8:  _hj_j += ( (unsigned)_hj_key[7] << 24 );  /* FALLTHROUGH */         \
+    case 7:  _hj_j += ( (unsigned)_hj_key[6] << 16 );  /* FALLTHROUGH */         \
+    case 6:  _hj_j += ( (unsigned)_hj_key[5] << 8 );   /* FALLTHROUGH */         \
+    case 5:  _hj_j += _hj_key[4];                      /* FALLTHROUGH */         \
+    case 4:  _hj_i += ( (unsigned)_hj_key[3] << 24 );  /* FALLTHROUGH */         \
+    case 3:  _hj_i += ( (unsigned)_hj_key[2] << 16 );  /* FALLTHROUGH */         \
+    case 2:  _hj_i += ( (unsigned)_hj_key[1] << 8 );   /* FALLTHROUGH */         \
+    case 1:  _hj_i += _hj_key[0];                      /* FALLTHROUGH */         \
+    default: ;                                                                   \
+  }                                                                              \
+  HASH_JEN_MIX(_hj_i, _hj_j, hashv);                                             \
+} while (0)
+
+/* The Paul Hsieh hash function */
+#undef get16bits
+#if (defined(__GNUC__) && defined(__i386__)) || defined(__WATCOMC__)             \
+  || defined(_MSC_VER) || defined (__BORLANDC__) || defined (__TURBOC__)
+#define get16bits(d) (*((const uint16_t *) (d)))
+#endif
+
+#if !defined (get16bits)
+#define get16bits(d) ((((uint32_t)(((const uint8_t *)(d))[1])) << 8)             \
+                       +(uint32_t)(((const uint8_t *)(d))[0]) )
+#endif
+#define HASH_SFH(key,keylen,hashv)                                               \
+do {                                                                             \
+  unsigned const char *_sfh_key=(unsigned const char*)(key);                     \
+  uint32_t _sfh_tmp, _sfh_len = (uint32_t)keylen;                                \
+                                                                                 \
+  unsigned _sfh_rem = _sfh_len & 3U;                                             \
+  _sfh_len >>= 2;                                                                \
+  hashv = 0xcafebabeu;                                                           \
+                                                                                 \
+  /* Main loop */                                                                \
+  for (;_sfh_len > 0U; _sfh_len--) {                                             \
+    hashv    += get16bits (_sfh_key);                                            \
+    _sfh_tmp  = ((uint32_t)(get16bits (_sfh_key+2)) << 11) ^ hashv;              \
+    hashv     = (hashv << 16) ^ _sfh_tmp;                                        \
+    _sfh_key += 2U*sizeof (uint16_t);                                            \
+    hashv    += hashv >> 11;                                                     \
+  }                                                                              \
+                                                                                 \
+  /* Handle end cases */                                                         \
+  switch (_sfh_rem) {                                                            \
+    case 3: hashv += get16bits (_sfh_key);                                       \
+            hashv ^= hashv << 16;                                                \
+            hashv ^= (uint32_t)(_sfh_key[sizeof (uint16_t)]) << 18;              \
+            hashv += hashv >> 11;                                                \
+            break;                                                               \
+    case 2: hashv += get16bits (_sfh_key);                                       \
+            hashv ^= hashv << 11;                                                \
+            hashv += hashv >> 17;                                                \
+            break;                                                               \
+    case 1: hashv += *_sfh_key;                                                  \
+            hashv ^= hashv << 10;                                                \
+            hashv += hashv >> 1;                                                 \
+            break;                                                               \
+    default: ;                                                                   \
+  }                                                                              \
+                                                                                 \
+  /* Force "avalanching" of final 127 bits */                                    \
+  hashv ^= hashv << 3;                                                           \
+  hashv += hashv >> 5;                                                           \
+  hashv ^= hashv << 4;                                                           \
+  hashv += hashv >> 17;                                                          \
+  hashv ^= hashv << 25;                                                          \
+  hashv += hashv >> 6;                                                           \
+} while (0)
+
+/* iterate over items in a known bucket to find desired item */
+#define HASH_FIND_IN_BKT(tbl,hh,head,keyptr,keylen_in,hashval,out)               \
+do {                                                                             \
+  if ((head).hh_head != NULL) {                                                  \
+    DECLTYPE_ASSIGN(out, ELMT_FROM_HH(tbl, (head).hh_head));                     \
+  } else {                                                                       \
+    (out) = NULL;                                                                \
+  }                                                                              \
+  while ((out) != NULL) {                                                        \
+    if ((out)->hh.hashv == (hashval) && (out)->hh.keylen == (keylen_in)) {       \
+      if (HASH_KEYCMP((out)->hh.key, keyptr, keylen_in) == 0) {                  \
+        break;                                                                   \
+      }                                                                          \
+    }                                                                            \
+    if ((out)->hh.hh_next != NULL) {                                             \
+      DECLTYPE_ASSIGN(out, ELMT_FROM_HH(tbl, (out)->hh.hh_next));                \
+    } else {                                                                     \
+      (out) = NULL;                                                              \
+    }                                                                            \
+  }                                                                              \
+} while (0)
+
+/* add an item to a bucket  */
+#define HASH_ADD_TO_BKT(head,hh,addhh,oomed)                                     \
+do {                                                                             \
+  UT_hash_bucket *_ha_head = &(head);                                            \
+  _ha_head->count++;                                                             \
+  (addhh)->hh_next = _ha_head->hh_head;                                          \
+  (addhh)->hh_prev = NULL;                                                       \
+  if (_ha_head->hh_head != NULL) {                                               \
+    _ha_head->hh_head->hh_prev = (addhh);                                        \
+  }                                                                              \
+  _ha_head->hh_head = (addhh);                                                   \
+  if ((_ha_head->count >= ((_ha_head->expand_mult + 1U) * HASH_BKT_CAPACITY_THRESH)) \
+      && !(addhh)->tbl->noexpand) {                                              \
+    HASH_EXPAND_BUCKETS(addhh,(addhh)->tbl, oomed);                              \
+    IF_HASH_NONFATAL_OOM(                                                        \
+      if (oomed) {                                                               \
+        HASH_DEL_IN_BKT(head,addhh);                                             \
+      }                                                                          \
+    )                                                                            \
+  }                                                                              \
+} while (0)
+
+/* remove an item from a given bucket */
+#define HASH_DEL_IN_BKT(head,delhh)                                              \
+do {                                                                             \
+  UT_hash_bucket *_hd_head = &(head);                                            \
+  _hd_head->count--;                                                             \
+  if (_hd_head->hh_head == (delhh)) {                                            \
+    _hd_head->hh_head = (delhh)->hh_next;                                        \
+  }                                                                              \
+  if ((delhh)->hh_prev) {                                                        \
+    (delhh)->hh_prev->hh_next = (delhh)->hh_next;                                \
+  }                                                                              \
+  if ((delhh)->hh_next) {                                                        \
+    (delhh)->hh_next->hh_prev = (delhh)->hh_prev;                                \
+  }                                                                              \
+} while (0)
+
+/* Bucket expansion has the effect of doubling the number of buckets
+ * and redistributing the items into the new buckets. Ideally the
+ * items will distribute more or less evenly into the new buckets
+ * (the extent to which this is true is a measure of the quality of
+ * the hash function as it applies to the key domain).
+ *
+ * With the items distributed into more buckets, the chain length
+ * (item count) in each bucket is reduced. Thus by expanding buckets
+ * the hash keeps a bound on the chain length. This bounded chain
+ * length is the essence of how a hash provides constant time lookup.
+ *
+ * The calculation of tbl->ideal_chain_maxlen below deserves some
+ * explanation. First, keep in mind that we're calculating the ideal
+ * maximum chain length based on the *new* (doubled) bucket count.
+ * In fractions this is just n/b (n=number of items,b=new num buckets).
+ * Since the ideal chain length is an integer, we want to calculate
+ * ceil(n/b). We don't depend on floating point arithmetic in this
+ * hash, so to calculate ceil(n/b) with integers we could write
+ *
+ *      ceil(n/b) = (n/b) + ((n%b)?1:0)
+ *
+ * and in fact a previous version of this hash did just that.
+ * But now we have improved things a bit by recognizing that b is
+ * always a power of two. We keep its base 2 log handy (call it lb),
+ * so now we can write this with a bit shift and logical AND:
+ *
+ *      ceil(n/b) = (n>>lb) + ( (n & (b-1)) ? 1:0)
+ *
+ */
+#define HASH_EXPAND_BUCKETS(hh,tbl,oomed)                                        \
+do {                                                                             \
+  unsigned _he_bkt;                                                              \
+  unsigned _he_bkt_i;                                                            \
+  struct UT_hash_handle *_he_thh, *_he_hh_nxt;                                   \
+  UT_hash_bucket *_he_new_buckets, *_he_newbkt;                                  \
+  _he_new_buckets = (UT_hash_bucket*)uthash_malloc(                              \
+           sizeof(struct UT_hash_bucket) * (tbl)->num_buckets * 2U);             \
+  if (!_he_new_buckets) {                                                        \
+    HASH_RECORD_OOM(oomed);                                                      \
+  } else {                                                                       \
+    uthash_bzero(_he_new_buckets,                                                \
+        sizeof(struct UT_hash_bucket) * (tbl)->num_buckets * 2U);                \
+    (tbl)->ideal_chain_maxlen =                                                  \
+       ((tbl)->num_items >> ((tbl)->log2_num_buckets+1U)) +                      \
+       ((((tbl)->num_items & (((tbl)->num_buckets*2U)-1U)) != 0U) ? 1U : 0U);    \
+    (tbl)->nonideal_items = 0;                                                   \
+    for (_he_bkt_i = 0; _he_bkt_i < (tbl)->num_buckets; _he_bkt_i++) {           \
+      _he_thh = (tbl)->buckets[ _he_bkt_i ].hh_head;                             \
+      while (_he_thh != NULL) {                                                  \
+        _he_hh_nxt = _he_thh->hh_next;                                           \
+        HASH_TO_BKT(_he_thh->hashv, (tbl)->num_buckets * 2U, _he_bkt);           \
+        _he_newbkt = &(_he_new_buckets[_he_bkt]);                                \
+        if (++(_he_newbkt->count) > (tbl)->ideal_chain_maxlen) {                 \
+          (tbl)->nonideal_items++;                                               \
+          if (_he_newbkt->count > _he_newbkt->expand_mult * (tbl)->ideal_chain_maxlen) { \
+            _he_newbkt->expand_mult++;                                           \
+          }                                                                      \
+        }                                                                        \
+        _he_thh->hh_prev = NULL;                                                 \
+        _he_thh->hh_next = _he_newbkt->hh_head;                                  \
+        if (_he_newbkt->hh_head != NULL) {                                       \
+          _he_newbkt->hh_head->hh_prev = _he_thh;                                \
+        }                                                                        \
+        _he_newbkt->hh_head = _he_thh;                                           \
+        _he_thh = _he_hh_nxt;                                                    \
+      }                                                                          \
+    }                                                                            \
+    uthash_free((tbl)->buckets, (tbl)->num_buckets * sizeof(struct UT_hash_bucket)); \
+    (tbl)->num_buckets *= 2U;                                                    \
+    (tbl)->log2_num_buckets++;                                                   \
+    (tbl)->buckets = _he_new_buckets;                                            \
+    (tbl)->ineff_expands = ((tbl)->nonideal_items > ((tbl)->num_items >> 1)) ?   \
+        ((tbl)->ineff_expands+1U) : 0U;                                          \
+    if ((tbl)->ineff_expands > 1U) {                                             \
+      (tbl)->noexpand = 1;                                                       \
+      uthash_noexpand_fyi(tbl);                                                  \
+    }                                                                            \
+    uthash_expand_fyi(tbl);                                                      \
+  }                                                                              \
+} while (0)
+
+
+/* This is an adaptation of Simon Tatham's O(n log(n)) mergesort */
+/* Note that HASH_SORT assumes the hash handle name to be hh.
+ * HASH_SRT was added to allow the hash handle name to be passed in. */
+#define HASH_SORT(head,cmpfcn) HASH_SRT(hh,head,cmpfcn)
+#define HASH_SRT(hh,head,cmpfcn)                                                 \
+do {                                                                             \
+  unsigned _hs_i;                                                                \
+  unsigned _hs_looping,_hs_nmerges,_hs_insize,_hs_psize,_hs_qsize;               \
+  struct UT_hash_handle *_hs_p, *_hs_q, *_hs_e, *_hs_list, *_hs_tail;            \
+  if (head != NULL) {                                                            \
+    _hs_insize = 1;                                                              \
+    _hs_looping = 1;                                                             \
+    _hs_list = &((head)->hh);                                                    \
+    while (_hs_looping != 0U) {                                                  \
+      _hs_p = _hs_list;                                                          \
+      _hs_list = NULL;                                                           \
+      _hs_tail = NULL;                                                           \
+      _hs_nmerges = 0;                                                           \
+      while (_hs_p != NULL) {                                                    \
+        _hs_nmerges++;                                                           \
+        _hs_q = _hs_p;                                                           \
+        _hs_psize = 0;                                                           \
+        for (_hs_i = 0; _hs_i < _hs_insize; ++_hs_i) {                           \
+          _hs_psize++;                                                           \
+          _hs_q = ((_hs_q->next != NULL) ?                                       \
+            HH_FROM_ELMT((head)->hh.tbl, _hs_q->next) : NULL);                   \
+          if (_hs_q == NULL) {                                                   \
+            break;                                                               \
+          }                                                                      \
+        }                                                                        \
+        _hs_qsize = _hs_insize;                                                  \
+        while ((_hs_psize != 0U) || ((_hs_qsize != 0U) && (_hs_q != NULL))) {    \
+          if (_hs_psize == 0U) {                                                 \
+            _hs_e = _hs_q;                                                       \
+            _hs_q = ((_hs_q->next != NULL) ?                                     \
+              HH_FROM_ELMT((head)->hh.tbl, _hs_q->next) : NULL);                 \
+            _hs_qsize--;                                                         \
+          } else if ((_hs_qsize == 0U) || (_hs_q == NULL)) {                     \
+            _hs_e = _hs_p;                                                       \
+            if (_hs_p != NULL) {                                                 \
+              _hs_p = ((_hs_p->next != NULL) ?                                   \
+                HH_FROM_ELMT((head)->hh.tbl, _hs_p->next) : NULL);               \
+            }                                                                    \
+            _hs_psize--;                                                         \
+          } else if ((cmpfcn(                                                    \
+                DECLTYPE(head)(ELMT_FROM_HH((head)->hh.tbl, _hs_p)),             \
+                DECLTYPE(head)(ELMT_FROM_HH((head)->hh.tbl, _hs_q))              \
+                )) <= 0) {                                                       \
+            _hs_e = _hs_p;                                                       \
+            if (_hs_p != NULL) {                                                 \
+              _hs_p = ((_hs_p->next != NULL) ?                                   \
+                HH_FROM_ELMT((head)->hh.tbl, _hs_p->next) : NULL);               \
+            }                                                                    \
+            _hs_psize--;                                                         \
+          } else {                                                               \
+            _hs_e = _hs_q;                                                       \
+            _hs_q = ((_hs_q->next != NULL) ?                                     \
+              HH_FROM_ELMT((head)->hh.tbl, _hs_q->next) : NULL);                 \
+            _hs_qsize--;                                                         \
+          }                                                                      \
+          if ( _hs_tail != NULL ) {                                              \
+            _hs_tail->next = ((_hs_e != NULL) ?                                  \
+              ELMT_FROM_HH((head)->hh.tbl, _hs_e) : NULL);                       \
+          } else {                                                               \
+            _hs_list = _hs_e;                                                    \
+          }                                                                      \
+          if (_hs_e != NULL) {                                                   \
+            _hs_e->prev = ((_hs_tail != NULL) ?                                  \
+              ELMT_FROM_HH((head)->hh.tbl, _hs_tail) : NULL);                    \
+          }                                                                      \
+          _hs_tail = _hs_e;                                                      \
+        }                                                                        \
+        _hs_p = _hs_q;                                                           \
+      }                                                                          \
+      if (_hs_tail != NULL) {                                                    \
+        _hs_tail->next = NULL;                                                   \
+      }                                                                          \
+      if (_hs_nmerges <= 1U) {                                                   \
+        _hs_looping = 0;                                                         \
+        (head)->hh.tbl->tail = _hs_tail;                                         \
+        DECLTYPE_ASSIGN(head, ELMT_FROM_HH((head)->hh.tbl, _hs_list));           \
+      }                                                                          \
+      _hs_insize *= 2U;                                                          \
+    }                                                                            \
+    HASH_FSCK(hh, head, "HASH_SRT");                                             \
+  }                                                                              \
+} while (0)
+
+/* This function selects items from one hash into another hash.
+ * The end result is that the selected items have dual presence
+ * in both hashes. There is no copy of the items made; rather
+ * they are added into the new hash through a secondary hash
+ * hash handle that must be present in the structure. */
+#define HASH_SELECT(hh_dst, dst, hh_src, src, cond)                              \
+do {                                                                             \
+  unsigned _src_bkt, _dst_bkt;                                                   \
+  void *_last_elt = NULL, *_elt;                                                 \
+  UT_hash_handle *_src_hh, *_dst_hh, *_last_elt_hh=NULL;                         \
+  ptrdiff_t _dst_hho = ((char*)(&(dst)->hh_dst) - (char*)(dst));                 \
+  if ((src) != NULL) {                                                           \
+    for (_src_bkt=0; _src_bkt < (src)->hh_src.tbl->num_buckets; _src_bkt++) {    \
+      for (_src_hh = (src)->hh_src.tbl->buckets[_src_bkt].hh_head;               \
+        _src_hh != NULL;                                                         \
+        _src_hh = _src_hh->hh_next) {                                            \
+        _elt = ELMT_FROM_HH((src)->hh_src.tbl, _src_hh);                         \
+        if (cond(_elt)) {                                                        \
+          IF_HASH_NONFATAL_OOM( int _hs_oomed = 0; )                             \
+          _dst_hh = (UT_hash_handle*)(void*)(((char*)_elt) + _dst_hho);          \
+          _dst_hh->key = _src_hh->key;                                           \
+          _dst_hh->keylen = _src_hh->keylen;                                     \
+          _dst_hh->hashv = _src_hh->hashv;                                       \
+          _dst_hh->prev = _last_elt;                                             \
+          _dst_hh->next = NULL;                                                  \
+          if (_last_elt_hh != NULL) {                                            \
+            _last_elt_hh->next = _elt;                                           \
+          }                                                                      \
+          if ((dst) == NULL) {                                                   \
+            DECLTYPE_ASSIGN(dst, _elt);                                          \
+            HASH_MAKE_TABLE(hh_dst, dst, _hs_oomed);                             \
+            IF_HASH_NONFATAL_OOM(                                                \
+              if (_hs_oomed) {                                                   \
+                uthash_nonfatal_oom(_elt);                                       \
+                (dst) = NULL;                                                    \
+                continue;                                                        \
+              }                                                                  \
+            )                                                                    \
+          } else {                                                               \
+            _dst_hh->tbl = (dst)->hh_dst.tbl;                                    \
+          }                                                                      \
+          HASH_TO_BKT(_dst_hh->hashv, _dst_hh->tbl->num_buckets, _dst_bkt);      \
+          HASH_ADD_TO_BKT(_dst_hh->tbl->buckets[_dst_bkt], hh_dst, _dst_hh, _hs_oomed); \
+          (dst)->hh_dst.tbl->num_items++;                                        \
+          IF_HASH_NONFATAL_OOM(                                                  \
+            if (_hs_oomed) {                                                     \
+              HASH_ROLLBACK_BKT(hh_dst, dst, _dst_hh);                           \
+              HASH_DELETE_HH(hh_dst, dst, _dst_hh);                              \
+              _dst_hh->tbl = NULL;                                               \
+              uthash_nonfatal_oom(_elt);                                         \
+              continue;                                                          \
+            }                                                                    \
+          )                                                                      \
+          HASH_BLOOM_ADD(_dst_hh->tbl, _dst_hh->hashv);                          \
+          _last_elt = _elt;                                                      \
+          _last_elt_hh = _dst_hh;                                                \
+        }                                                                        \
+      }                                                                          \
+    }                                                                            \
+  }                                                                              \
+  HASH_FSCK(hh_dst, dst, "HASH_SELECT");                                         \
+} while (0)
+
+#define HASH_CLEAR(hh,head)                                                      \
+do {                                                                             \
+  if ((head) != NULL) {                                                          \
+    HASH_BLOOM_FREE((head)->hh.tbl);                                             \
+    uthash_free((head)->hh.tbl->buckets,                                         \
+                (head)->hh.tbl->num_buckets*sizeof(struct UT_hash_bucket));      \
+    uthash_free((head)->hh.tbl, sizeof(UT_hash_table));                          \
+    (head) = NULL;                                                               \
+  }                                                                              \
+} while (0)
+
+#define HASH_OVERHEAD(hh,head)                                                   \
+ (((head) != NULL) ? (                                                           \
+ (size_t)(((head)->hh.tbl->num_items   * sizeof(UT_hash_handle))   +             \
+          ((head)->hh.tbl->num_buckets * sizeof(UT_hash_bucket))   +             \
+           sizeof(UT_hash_table)                                   +             \
+           (HASH_BLOOM_BYTELEN))) : 0U)
+
+#ifdef NO_DECLTYPE
+#define HASH_ITER(hh,head,el,tmp)                                                \
+for(((el)=(head)), ((*(char**)(&(tmp)))=(char*)((head!=NULL)?(head)->hh.next:NULL)); \
+  (el) != NULL; ((el)=(tmp)), ((*(char**)(&(tmp)))=(char*)((tmp!=NULL)?(tmp)->hh.next:NULL)))
+#else
+#define HASH_ITER(hh,head,el,tmp)                                                \
+for(((el)=(head)), ((tmp)=DECLTYPE(el)((head!=NULL)?(head)->hh.next:NULL));      \
+  (el) != NULL; ((el)=(tmp)), ((tmp)=DECLTYPE(el)((tmp!=NULL)?(tmp)->hh.next:NULL)))
+#endif
+
+/* obtain a count of items in the hash */
+#define HASH_COUNT(head) HASH_CNT(hh,head)
+#define HASH_CNT(hh,head) ((head != NULL)?((head)->hh.tbl->num_items):0U)
+
+typedef struct UT_hash_bucket {
+   struct UT_hash_handle *hh_head;
+   unsigned count;
+
+   /* expand_mult is normally set to 0. In this situation, the max chain length
+    * threshold is enforced at its default value, HASH_BKT_CAPACITY_THRESH. (If
+    * the bucket's chain exceeds this length, bucket expansion is triggered).
+    * However, setting expand_mult to a non-zero value delays bucket expansion
+    * (that would be triggered by additions to this particular bucket)
+    * until its chain length reaches a *multiple* of HASH_BKT_CAPACITY_THRESH.
+    * (The multiplier is simply expand_mult+1). The whole idea of this
+    * multiplier is to reduce bucket expansions, since they are expensive, in
+    * situations where we know that a particular bucket tends to be overused.
+    * It is better to let its chain length grow to a longer yet-still-bounded
+    * value, than to do an O(n) bucket expansion too often.
+    */
+   unsigned expand_mult;
+
+} UT_hash_bucket;
+
+/* random signature used only to find hash tables in external analysis */
+#define HASH_SIGNATURE 0xa0111fe1u
+#define HASH_BLOOM_SIGNATURE 0xb12220f2u
+
+typedef struct UT_hash_table {
+   UT_hash_bucket *buckets;
+   unsigned num_buckets, log2_num_buckets;
+   unsigned num_items;
+   struct UT_hash_handle *tail; /* tail hh in app order, for fast append    */
+   ptrdiff_t hho; /* hash handle offset (byte pos of hash handle in element */
+
+   /* in an ideal situation (all buckets used equally), no bucket would have
+    * more than ceil(#items/#buckets) items. that's the ideal chain length. */
+   unsigned ideal_chain_maxlen;
+
+   /* nonideal_items is the number of items in the hash whose chain position
+    * exceeds the ideal chain maxlen. these items pay the penalty for an uneven
+    * hash distribution; reaching them in a chain traversal takes >ideal steps */
+   unsigned nonideal_items;
+
+   /* ineffective expands occur when a bucket doubling was performed, but
+    * afterward, more than half the items in the hash had nonideal chain
+    * positions. If this happens on two consecutive expansions we inhibit any
+    * further expansion, as it's not helping; this happens when the hash
+    * function isn't a good fit for the key domain. When expansion is inhibited
+    * the hash will still work, albeit no longer in constant time. */
+   unsigned ineff_expands, noexpand;
+
+   uint32_t signature; /* used only to find hash tables in external analysis */
+#ifdef HASH_BLOOM
+   uint32_t bloom_sig; /* used only to test bloom exists in external analysis */
+   uint8_t *bloom_bv;
+   uint8_t bloom_nbits;
+#endif
+
+} UT_hash_table;
+
+typedef struct UT_hash_handle {
+   struct UT_hash_table *tbl;
+   void *prev;                       /* prev element in app order      */
+   void *next;                       /* next element in app order      */
+   struct UT_hash_handle *hh_prev;   /* previous hh in bucket order    */
+   struct UT_hash_handle *hh_next;   /* next hh in bucket order        */
+   const void *key;                  /* ptr to enclosing struct's key  */
+   unsigned keylen;                  /* enclosing struct's key len     */
+   unsigned hashv;                   /* result of hash-fcn(key)        */
+} UT_hash_handle;
+
+#endif /* UTHASH_H */

models/matris/matris/graph/radiusgraph.py

@@ -0,0 +1,504 @@
+"""
+    This code is referenced from: https://github.com/CederGroupHub/chgnet/blob/main/chgnet/graph/converter.py
+    The original implementation can be found at the link above.
+"""
+from __future__ import annotations
+
+import os
+from typing import Any
+
+import torch
+from torch import Tensor
+import sys
+from abc import ABC, abstractmethod
+
+datatype = torch.float32
+
+class RadiusGraph:
+    def __init__(
+        self,
+        graph_id: str | None,
+        mp_id: str | None,
+        composition: str | None,
+        atomic_number: Tensor,
+        atom_frac_coord: Tensor,
+        lattice: Tensor,
+        neighbor_image: Tensor,
+        atom_graph: Tensor,
+        atom_graph_cutoff: float,
+        line_graph: Tensor,
+        line_graph_cutoff: float,
+        directed2undirected: Tensor,
+        undirected2directed: Tensor,
+    ):
+        """Initialize a RadiusGraph object representing a material graph.
+        
+        Args:
+            graph_id (str | None): Unique identifier for this graph instance.
+            mp_id (str | None): Materials Project ID associated with this structure.
+            composition (str | None): Chemical composition of the compound.
+
+            atomic_number (Tensor): Atomic numbers of all atoms in the structure. 
+                Shape: [n_atom]
+
+            atom_frac_coord (Tensor): Fractional atomic coordinates within the unit cell.
+                Shape: [n_atom, 3]
+
+            lattice (Tensor): Lattice vectors defining the periodic cell.
+                Shape: [3, 3]
+
+            neighbor_image (Tensor): Periodic image offsets for each directed edge, 
+                indicating how many unit cells away the neighbor lies along each axis.
+                Shape: [n_directed_edges, 3]
+
+            atom_graph (Tensor): Directed atomic graph, where each row stores 
+                (center_atom_index, neighbor_atom_index).
+                Shape: [n_directed_edges, 2]
+
+            atom_graph_cutoff (float): Cutoff radius (in Å) used to build the atom graph.
+
+            line_graph (Tensor): Line graph describing angular connections between bonds.
+                Each row stores 
+                (central_atom, undirected_bond_1, directed_bond_1, 
+                 undirected_bond_2, directed_bond_2).
+                Shape: [n_angle, 5]
+
+            line_graph_cutoff (float): Cutoff radius (in Å) used to build the line graph.
+
+            directed2undirected (Tensor): Mapping from each directed edge index 
+                to its corresponding undirected edge index.
+                Shape: [n_directed_edges]
+
+            undirected2directed (Tensor): Mapping from each undirected edge index 
+                to one of its directed edge indices.
+                Shape: [n_undirected_edges]
+        """
+        super().__init__()
+        self.graph_id = graph_id
+        self.mp_id = mp_id
+        self.composition = composition
+        
+        self.atomic_number = atomic_number
+        self.atom_frac_coord = atom_frac_coord
+        self.lattice = lattice
+        self.neighbor_image = neighbor_image
+        self.line_graph = line_graph
+        self.line_graph_cutoff = line_graph_cutoff
+        self.atom_graph = atom_graph
+        self.atom_graph_cutoff = atom_graph_cutoff
+        self.directed2undirected = directed2undirected
+        self.undirected2directed = undirected2directed
+        
+        assert len(directed2undirected) == 2 * len(undirected2directed), (
+            f"Number of directed indices ({len(directed2undirected)}) != "
+            f"2 * number of undirected indices ({2 * len(undirected2directed)})!"
+        )
+        
+    def to(self, device: str = "cpu") -> RadiusGraph:
+        """Move the graph to a device."""
+        return RadiusGraph(
+            graph_id=self.graph_id,
+            mp_id=self.mp_id,
+            composition=self.composition,
+            atomic_number=self.atomic_number.to(device),
+            atom_frac_coord=self.atom_frac_coord.to(device),
+            lattice=self.lattice.to(device),
+            neighbor_image=self.neighbor_image.to(device),
+            atom_graph=self.atom_graph.to(device),
+            atom_graph_cutoff=self.atom_graph_cutoff,
+            line_graph=self.line_graph.to(device),
+            line_graph_cutoff=self.line_graph_cutoff,
+            directed2undirected=self.directed2undirected.to(device),
+            undirected2directed=self.undirected2directed.to(device),
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "graph_id": self.graph_id,
+            "mp_id": self.mp_id,
+            "composition": self.composition,
+            "atomic_number": self.atomic_number,
+            "atom_frac_coord": self.atom_frac_coord,
+            "lattice": self.lattice,
+            "neighbor_image": self.neighbor_image,
+            "atom_graph": self.atom_graph,
+            "atom_graph_cutoff": self.atom_graph_cutoff,
+            "line_graph": self.line_graph,
+            "line_graph_cutoff": self.line_graph_cutoff,
+            "directed2undirected": self.directed2undirected,
+            "undirected2directed": self.undirected2directed,
+        }
+
+    def save(self, fname: str | None = None, save_dir: str = ".") -> str:
+        """Save the Radiusgraph to a file.
+
+        Args:
+            fname (str, optional): File name. Defaults to None.
+            save_dir (str, optional): Directory to save the file. Defaults to ".".
+        """
+        if fname is not None:
+            save_name = os.path.join(save_dir, fname)
+        elif self.graph_id is not None:
+            save_name = os.path.join(save_dir, f"{self.graph_id}.pt")
+        else:
+            save_name = os.path.join(save_dir, f"{self.composition}.pt")
+        torch.save(self.to_dict(), f=save_name)
+        return save_name
+
+    @classmethod
+    def from_file(cls, file_name: str) -> RadiusGraph:
+        """Load a Radiusgraph from a file.
+
+        Args:
+            file_name (str): The path to the file.
+        """
+        return torch.load(file_name)
+
+    @classmethod
+    def from_dict(cls, dic: dict[str, Any]) -> RadiusGraph:
+        """Load a RadiusGraph from a dictionary."""
+        return RadiusGraph(**dic)
+
+    def __repr__(self) -> str:
+        """String representation of the graph."""
+        composition = self.composition
+        atom_graph_cutoff = self.atom_graph_cutoff
+        line_graph_cutoff = self.line_graph_cutoff
+        atom_graph_len = self.atom_graph
+        n_atoms = len(self.atomic_number)
+        atom_graph_len = len(self.atom_graph)
+        line_graph_len = len(self.line_graph)
+        return (
+            f"RadiusGraph({composition=}, {atom_graph_cutoff=}, {line_graph_cutoff=}, "
+            f"{n_atoms=}, {atom_graph_len=}, {line_graph_len=})"
+        )
+    
+
+class Node:
+    """A node in graph."""
+
+    def __init__(self, index: int, info: dict | None = None) -> None:
+        """Initialize a Node.
+
+        Args:
+            index (int): the index of this node
+            info (dict, optional): any additional information about this node.
+        """
+        self.index = index
+        self.info = info
+        self.neighbors: dict[int, list[DirectedEdge | UndirectedEdge]] = {}
+
+    def add_neighbor(self, index, edge):
+        """Draw an directed edge between self and the node specified by index.
+
+        Args:
+            index (int): the index of neighboring node
+            edge (DirectedEdge): an DirectedEdge object pointing from self to the node.
+        """
+        if index not in self.neighbors:
+            self.neighbors[index] = [edge]
+        else:
+            self.neighbors[index].append(edge)
+
+
+class Edge(ABC):
+    """Abstract base class for edges in a graph."""
+
+    def __init__(
+        self, nodes: list, index: int | None = None, info: dict | None = None
+    ) -> None:
+        """Initialize an Edge."""
+        self.nodes = nodes
+        self.index = index
+        self.info = info
+
+    def __repr__(self):
+        """String representation of this edge."""
+        nodes, index, info = self.nodes, self.index, self.info
+        return f"{type(self).__name__}({nodes=}, {index=}, {info=})"
+
+    def __hash__(self) -> int:
+        """Hash this edge."""
+        img = (self.info or {}).get("image")
+        img_str = "" if img is None else img.tobytes()
+        return hash((self.nodes[0], self.nodes[1], img_str))
+
+    @abstractmethod
+    def __eq__(self, other: object) -> bool:
+        """Check if two edges are equal."""
+        raise NotImplementedError
+
+
+class UndirectedEdge(Edge):
+    """An undirected/bi-directed edge in a graph."""
+
+    __hash__ = Edge.__hash__
+
+    def __eq__(self, other):
+        """Check if two undirected edges are equal."""
+        return set(self.nodes) == set(other.nodes) and self.info == other.info
+
+
+class DirectedEdge(Edge):
+    """A directed edge in a graph."""
+
+    __hash__ = Edge.__hash__
+
+    def make_undirected(self, index: int, info: dict | None = None) -> UndirectedEdge:
+        """Make a directed edge undirected."""
+        info = info or {}
+        info["distance"] = self.info["distance"]
+        return UndirectedEdge(self.nodes, index, info)
+
+    def __eq__(self, other: object) -> bool:
+        """Check if the two directed edges are equal.
+
+        Args:
+            other (DirectedEdge): another DirectedEdge to compare to
+
+        Returns:
+            bool: True if other is the same directed edge, or if other is the directed
+                edge with reverse direction of self, else False.
+        """
+        self_img = (self.info or {}).get("image")
+        other_img = (other.info or {}).get("image")
+        none_img = self_img is other_img is None
+        if self.nodes == other.nodes and (none_img or all(self_img == other_img)):
+            # the image key here is provided by Pymatgen, which refers to the periodic
+            # cell the neighbor node comes from
+
+            # In this case the two directed edges are exactly the same, but this is not
+            # supposed tp happen unless there's a bug in Pymatgen. (we will never add
+            # the same edge twice in creating a crystal graph.)
+            print(
+                "!!!!!! the two directed edges are equal but this operation is "
+                "not supposed to happen",
+                file=sys.stderr,
+            )
+            return True
+
+        # In this case the first edge is from node i to j and the second edge is
+        # from node j to i
+        return self.nodes == other.nodes[::-1] and (
+            none_img or all(self_img == -1 * other_img)
+        )
+
+
+class Graph:
+    """A graph for storing the neighbor information of atoms."""
+
+    def __init__(self, nodes: list[Node]) -> None:
+        """Initialize a Graph from a list of nodes."""
+        self.nodes = nodes
+        self.directed_edges: dict[frozenset[int], list[DirectedEdge]] = {}
+        self.directed_edges_list: list[DirectedEdge] = []
+        self.undirected_edges: dict[frozenset[int], list[UndirectedEdge]] = {}
+        self.undirected_edges_list: list[UndirectedEdge] = []
+
+    def add_edge(self, center_index, neighbor_index, image, distance) -> None:
+        """Add an directed edge to the graph.
+
+        Args:
+            center_index (int): center node index
+            neighbor_index (int): neighbor node index
+            image (np.array): the periodic cell image the neighbor is from
+            distance (float): distance between center and neighbor.
+        """
+        # Create directed_edge (DE) index using the length of added DEs
+        directed_edge_index = len(self.directed_edges_list)
+
+        # Create the DE with info
+        this_directed_edge = DirectedEdge(
+            [center_index, neighbor_index],
+            index=directed_edge_index,
+            info={"image": image, "distance": distance},
+        )
+        # Record the two ends of the DE and see if they have been added
+        # Here the sequence of the ends doesn't matter since we want to
+        #  search for associated undirected_edge (UDE)
+        tmp = frozenset([center_index, neighbor_index])
+        # This combination of two ends hasn't been added
+        if tmp not in self.undirected_edges:
+            # Create UDE index
+            this_directed_edge.info["undirected_edge_index"] = len(
+                self.undirected_edges_list
+            )
+            # Create UDE
+            this_undirected_edge = this_directed_edge.make_undirected(
+                index=len(self.undirected_edges_list),
+                info={"directed_edge_index": [directed_edge_index]},
+            )
+            self.undirected_edges[tmp] = [this_undirected_edge]
+            
+            self.undirected_edges_list.append(this_undirected_edge)
+            self.nodes[center_index].add_neighbor(neighbor_index, this_directed_edge)
+            self.directed_edges_list.append(this_directed_edge)
+        else:
+            # This pair of nodes has been added before, we need to see if this time,
+            # 1. it's the other directed edge of the same undirected edge or,
+            # 2. it's another totally different undirected edge that has
+            # different image and distance (this is possible consider periodicity)
+            for undirected_edge in self.undirected_edges[tmp]:
+                if (
+                    abs(undirected_edge.info["distance"] - distance) < 1e-6
+                    and len(undirected_edge.info["directed_edge_index"]) == 1
+                ):
+                    # There is an undirected edge with similar length and only one of
+                    # the directed edges associated has been added
+                    added_DE = self.directed_edges_list[
+                        undirected_edge.info["directed_edge_index"][0]
+                    ]
+
+                    # See if the DE that's associated to this UDE
+                    # is the reverse of our DE
+                    if added_DE == this_directed_edge:
+                        # Add UDE index to this DE
+                        this_directed_edge.info[
+                            "undirected_edge_index"
+                        ] = added_DE.info["undirected_edge_index"]
+
+                        # At the center node, draw edge with this DE
+                        self.nodes[center_index].add_neighbor(
+                            neighbor_index, this_directed_edge
+                        )
+
+                        # Add this DE to DE list
+                        self.directed_edges_list.append(this_directed_edge)
+
+                        # Add this DE to the UDE
+                        undirected_edge.info["directed_edge_index"].append(
+                            directed_edge_index
+                        )
+                        return
+
+            # no undirected_edge matches to this directed edge
+            this_directed_edge.info["undirected_edge_index"] = len(
+                self.undirected_edges_list
+            )
+            this_undirected_edge = this_directed_edge.make_undirected(
+                index=len(self.undirected_edges_list),
+                info={"directed_edge_index": [directed_edge_index]},
+            )
+            self.undirected_edges[tmp].append(this_undirected_edge)
+            
+            self.undirected_edges_list.append(this_undirected_edge)
+            self.nodes[center_index].add_neighbor(neighbor_index, this_directed_edge)
+            self.directed_edges_list.append(this_directed_edge)
+
+    def adjacency_list(self):
+        """Get the adjacency list
+        Return:
+            graph: the adjacency list
+                [[0, 1],
+                 [0, 2],
+                 ...
+                 [5, 2]
+                 ...  ]]
+                the fist column specifies center/source node,
+                the second column specifies neighbor/destination node
+            directed2undirected:
+                [0, 1, ...]
+                a list of length = num_directed_edge that specifies
+                the undirected edge index corresponding to the directed edges
+                represented in each row in the graph adjacency list.
+        """
+        graph = [edge.nodes for edge in self.directed_edges_list]
+        directed2undirected = [
+            edge.info["undirected_edge_index"] for edge in self.directed_edges_list
+        ]
+
+        return graph, directed2undirected
+
+    def line_graph_adjacency_list(self, cutoff):
+        """Get the line graph adjacency list.
+
+        Args:
+            cutoff (float): a float to indicate the maximum edge length to be included
+                in constructing the line graph, this is used to decrease computation
+                complexity
+
+        Return:
+            line_graph:
+                [[0, 1, 1, 2, 2],
+                [0, 1, 1, 4, 23],
+                [1, 4, 23, 5, 66],
+                ... ...  ]
+                the fist column specifies node(atom) index at this angle,
+                the second column specifies 1st undirected edge(left bond) index,
+                the third column specifies 1st directed edge(left bond) index,
+                the fourth column specifies 2nd undirected edge(right bond) index,
+                the fifth column specifies 2nd directed edge(right bond) index,.
+            undirected2directed:
+                [32, 45, ...]
+                a list of length = num_undirected_edge that
+                maps the undirected edge index to one of its directed edges indices
+        """
+        assert len(self.directed_edges_list) == 2 * len(self.undirected_edges_list), (
+            f"Error: number of directed edges={len(self.directed_edges_list)} != 2 * "
+            f"number of undirected edges={len(self.directed_edges_list)}!"
+            f"This indicates directed edges are not complete"
+        )
+        line_graph = []
+        #undirected2directed = []
+
+        # Loop through all the undirected edges(UDE)
+        for u_edge in self.undirected_edges_list:
+            # Create the mapping from the UDE index to one of its DE index
+            #undirected2directed.append(u_edge.info["directed_edge_index"][0])
+
+            # Ignore the UDE if its length is larger than cutoff (3A for default)
+            if u_edge.info["distance"] > cutoff:
+                continue
+
+            # Assert if the UDE is valid
+            # if encountered exception,
+            # it means after Atom_Graph creation, the UDE has only 1 DE associated
+            # This exception is not encountered from the develop team's experience
+            assert len(u_edge.info["directed_edge_index"]) == 2, (
+                "Did not find 2 Directed_edges !!!"
+                f"undirected edge {u_edge} has:"
+                f"edge.info['directed_edge_index'] = "
+                f"{u_edge.info['directed_edge_index']}"
+                f"len directed_edges_list = {len(self.directed_edges_list)}"
+                f"len undirected_edges_list = {len(self.undirected_edges_list)}"
+            )
+
+            # This UDE is valid to be considered as a node in Bond_Graph
+
+            # Get the two ends (centers) and the two DE associated with this UDE
+            # DE1 should have center=center1 and DE2 should have center=center2
+            # We will need to find directed edges with center = center1
+            # and create angles with DE1, then do the same for center2 and DE2
+            for center, DE in zip(u_edge.nodes, u_edge.info["directed_edge_index"]):
+                for directed_edges in self.nodes[center].neighbors.values():
+                    for directed_edge in directed_edges:
+                        if directed_edge.index == DE:
+                            continue
+                        if directed_edge.info["distance"] < cutoff:
+                            line_graph.append(
+                                [
+                                    center,
+                                    u_edge.index,
+                                    DE,
+                                    directed_edge.info["undirected_edge_index"],
+                                    directed_edge.index,
+                                ]
+                            )
+        return line_graph#, undirected2directed
+
+    def undirected2directed(self):
+        """The index map from undirected_edge index to one of its directed_edge
+        index.
+        """
+        return [
+            undirected_edge.info["directed_edge_index"][0]
+            for undirected_edge in self.undirected_edges_list
+        ]
+
+    def __repr__(self) -> str:
+        """Return string representation of the Graph."""
+        num_nodes = len(self.nodes)
+        num_directed_edges = len(self.directed_edges_list)
+        num_undirected_edges = len(self.undirected_edges_list)
+        return f"Graph({num_nodes=}, {num_directed_edges=}, {num_undirected_edges=})"
+    

models/matris/matris/graph/setup.py

@@ -0,0 +1,8 @@
+
+from setuptools import Extension, setup
+
+ext_modules = [Extension("matris.graph.cygraph", ["matris/graph/cygraph.pyx"])]
+
+setup(ext_modules=ext_modules, setup_requires=["Cython"])
+
+# python setup.py build_ext --inplace

models/matris/matris/model/__init__.py

@@ -0,0 +1 @@
+from .model import MatRIS

models/matris/matris/model/basis_function.py

@@ -0,0 +1,367 @@
+from __future__ import annotations
+
+import torch
+from torch import Tensor, nn
+import math
+import numpy as np
+
+class PolynomialEnvelope(nn.Module):
+    """
+        Polynomial cutoff function for distance
+        Details are given in: https://doi.org/10.48550/arXiv.2106.08903
+    """
+
+    def __init__(self, cutoff: float = 6, envelope_exponent: float = 8) -> None:
+        """Initialize the polynomial cutoff function.
+
+        Args:
+            cutoff (float): cutoff radius in graph construction
+                Default = 6
+            envelope_exponent (float): envelope exponent
+                Default = 8
+        """
+        super().__init__()
+        assert envelope_exponent > 0
+        self.cutoff = cutoff
+        self.p = float(envelope_exponent)
+        self.a = -(self.p + 1) * (self.p + 2) / 2
+        self.b = self.p * (self.p + 2)
+        self.c = -self.p * (self.p + 1) / 2
+
+    def forward(self, dist: Tensor) -> Tensor:
+        """
+        Args:
+            dist (Tensor): radius distance tensor
+
+        Returns:
+            polynomial cutoff functions: decaying from 1 to 0
+        """
+        if self.p != 0:
+            dist_scaled = dist / self.cutoff
+            
+            env_val = (
+                1
+                + self.a * dist_scaled ** self.p
+                + self.b * dist_scaled ** (self.p + 1)
+                + self.c * dist_scaled ** (self.p + 2)
+            )
+            
+            return torch.where(dist_scaled < 1, env_val, torch.zeros_like(dist_scaled))
+        return dist.new_ones(dist.shape)
+
+
+@torch.jit.script
+def SphericalHarmonics(lmax: int, x: torch.Tensor) -> torch.Tensor:
+    
+    sh_0_0 = torch.ones_like(x) * 0.5 * math.sqrt(1.0 / math.pi)
+    if lmax == 0:
+        return torch.stack(
+            [
+                sh_0_0,
+            ],
+            dim=-1,
+        )
+
+    sh_1_1 = math.sqrt(3.0 / (4.0 * math.pi)) * x
+    if lmax == 1:
+        return torch.stack([sh_0_0, sh_1_1], dim=-1)
+
+    sh_2_2 = math.sqrt(5.0 / (16.0 * math.pi)) * (3.0 * x**2 - 1.0)
+    if lmax == 2:
+        return torch.stack([sh_0_0, sh_1_1, sh_2_2], dim=-1)
+
+    sh_3_3 = math.sqrt(7.0 / (16.0 * math.pi)) * x * (5.0 * x**2 - 3.0)
+    if lmax == 3:
+        return torch.stack([sh_0_0, sh_1_1, sh_2_2, sh_3_3], dim=-1)
+
+    raise ValueError("lmax <= 3")
+
+class FourierExpansion(nn.Module):
+    """
+        Fourier expansion for three-body feature.
+        Details are given in: https://doi.org/10.1038/s42256-023-00716-3
+    """
+
+    def __init__(self, max_f: int = 5, 
+                 scale: float = np.pi, 
+                 learnable: bool = False):
+        """
+        Args:
+            max_f (int): the maximum frequency of the expansion. 
+                Default = 5
+            learnable (bool): whether to set the frequencies as learnable parameters. 
+                Default = False
+        """
+        super().__init__()
+        self.max_f = max_f
+        self.scale = np.sqrt(scale)
+        if learnable:
+            self.frequencies = torch.nn.Parameter(
+                data=torch.arange(1, max_f + 1, dtype=torch.float),
+                requires_grad=True,
+            )
+        else:
+            self.register_buffer("frequencies", torch.arange(1, max_f + 1, dtype=torch.float))
+
+    def forward(self, feature: Tensor) -> Tensor:
+        """Apply Fourier expansion to feature."""
+        result = feature.new_zeros(feature.shape[0], 1 + 2 * self.max_f)
+        result[:, 0] = 1 / torch.sqrt(torch.tensor([2]))
+        tmp = torch.outer(feature, self.frequencies) 
+        result[:, 1 : self.max_f + 1] = torch.sin(tmp)
+        result[:, self.max_f + 1 :] = torch.cos(tmp)
+        return result / self.scale
+
+
+class BesselExpansion(torch.nn.Module):
+    """
+        Bessel expansion for pairwise feature
+        Details are given in: https://arxiv.org/abs/2003.03123
+    """
+    def __init__(
+        self,
+        num_radial: int = 9,
+        cutoff: float = 6,
+        envelope_exponent: int = 8,
+        learnable: bool = False,
+    ):
+        """
+        Args:
+            num_radial (int): number of radial basis.
+                Default = 9
+            cutoff (float):  cutoff distance.
+                Default = 6
+            envelope_exponent (int): envelope exponent of Envelope function.
+                Default = 8
+            learnable (bool): whether to set the frequencies as learnable parameters.
+                Default = False
+        """
+        super().__init__()
+        self.num_radial = num_radial
+        self.inv_cutoff = 1 / cutoff
+        self.norm_const = (2 * self.inv_cutoff) ** 0.5
+
+        if learnable:
+            self.frequencies = torch.nn.Parameter(
+                data=torch.Tensor(
+                    np.pi * torch.arange(1, self.num_radial + 1, dtype=torch.float)
+                ), requires_grad=True,
+            )
+        else:
+            self.register_buffer(
+                "frequencies",
+                np.pi * torch.arange(1, self.num_radial + 1, dtype=torch.float),
+            )
+        if envelope_exponent is not None:
+            self.envelope_func = PolynomialEnvelope(
+                cutoff=cutoff, envelope_exponent=envelope_exponent
+            )
+        else:
+            self.envelope_func = None
+
+    def forward(
+        self, dist: Tensor, return_smooth_factor: bool = False
+    ) -> Tensor | tuple[Tensor, Tensor]:
+        """Apply Bessel expansion to feature.
+        
+        Args:
+            dist (Tensor): tensor of distances. [nEdges]
+            return_smooth_factor (bool): whether to return the smooth factor
+                Default = False
+
+        Returns:
+            out (Tensor): tensor of Bessel basis [nEdges, num_radial]
+            smooth_factor (Tensor): tensor of smooth factors [nEdges, 1]
+        
+        TODO: 'torch.script.jit' boosts performance.
+        """
+        dist = dist[:, None]  # [nEdges] -> [nEdges, 1]
+        d_scaled = dist * self.inv_cutoff
+        out = self.norm_const * torch.sin(self.frequencies * d_scaled) / dist
+        if self.envelope_func is not None:
+            smooth_factor = self.envelope_func(dist)
+            out = smooth_factor * out
+            if return_smooth_factor:
+                return out, smooth_factor
+        return out
+
+
+class GaussianExpansion(nn.Module):
+    """
+        Gaussian expansion for pairwise feature.
+        Code adapted from the repo: https://github.com/facebookresearch/fairchem/blob/main/src/fairchem/core/models/uma/nn/radial.py#L42
+    """
+    def __init__(
+        self,
+        start: float = 0.0, 
+        stop: float = 6.0, 
+        num_gaussians: int = 7,
+        basis_width_scalar: float = 2.0, 
+    ):
+        super().__init__()
+        self.num_output = num_gaussians
+        offset = torch.linspace(start, stop, num_gaussians)
+        self.coeff = -0.5 / (basis_width_scalar * (offset[1] - offset[0])).item() ** 2
+        self.register_buffer("offset", offset)
+
+    def forward(self, dist) -> Tensor:
+        """Apply Bessel expansion to feature.
+        
+        Args:
+            dist (Tensor): tensor of distances. [nEdges]
+
+        Returns:
+            out (Tensor): tensor of Bessel basis [nEdges, num_gaussians]
+        
+        TODO: 'torch.script.jit' boosts performance.
+        """
+        dist = dist.view(-1, 1) - self.offset.view(1, -1)
+        return torch.exp(self.coeff * torch.pow(dist, 2))
+
+
+class SphericalExpansion(nn.Module):
+    """
+        Spherical expansion for three-body feature.
+        Code adapted from the repo: https://github.com/microsoft/mattersim
+    """
+    def __init__(self, max_n = 4, max_l = 4, cutoff = 6):
+        super().__init__()
+
+        assert max_l <= 4, "lmax must be less than 5"
+        assert max_n <= 4, "max_n must be less than 5"
+
+        self.max_n = max_n
+        self.max_l = max_l
+        self.cutoff = cutoff
+
+        # retrieve formulas
+        self.register_buffer(
+            "factor", torch.sqrt(torch.tensor(2.0 / (self.cutoff**3)))
+        )
+        self.coef = torch.zeros(4, 9, 4)
+        self.coef[0, 0, :] = torch.tensor(
+            [ 3.14159274101257, 6.28318548202515, 9.42477798461914, 12.5663709640503 ]
+        )
+        self.coef[1, :4, :] = torch.tensor(
+            [
+                [ -1.02446483277785, -1.00834335996107, -1.00419641763893, -1.00252381898662  ],
+                [ 4.49340963363647,  7.7252516746521,   10.9041213989258,  14.0661935806274   ],
+                [ 0.22799275301076,  0.130525632358311, 0.092093290316619, 0.0712718627992818 ],
+                [ 4.49340963363647,  7.7252516746521,   10.9041213989258,  14.0661935806274   ], 
+            ]
+        )
+        self.coef[2, :6, :] = torch.tensor(
+            [
+                [ -1.04807944170731,  -1.01861796359391,  -1.01002272174988,  -1.00628955560036  ],
+                [ 5.76345920562744,   9.09501171112061,   12.322940826416,    15.5146026611328   ],
+                [ 0.545547077361439,  0.335992298618515,  0.245888396928293,  0.194582402961821  ],
+                [ 5.76345920562744,   9.09501171112061,   12.322940826416,    15.5146026611328   ],
+                [ 0.0946561878721665, 0.0369424811413594, 0.0199537107571916, 0.0125418876146463 ],
+                [ 5.76345920562744,   9.09501171112061,   12.322940826416,    15.5146026611328   ], 
+            ]
+        )
+        self.coef[3, :8, :] = torch.tensor(
+            [
+                [ 1.06942831392075,   1.0292173312802,    1.01650804843248,   1.01069656069999    ], 
+                [ 6.9879322052002,    10.4171180725098,   13.6980228424072,   16.9236221313477    ],
+                [ 0.918235852195231,  0.592803493701152,  0.445250264272671,  0.358326327374518   ],
+                [ 6.9879322052002,    10.4171180725098,   13.6980228424072,   16.9236221313477    ],
+                [ 0.328507713452024,  0.142266673367543,  0.0812617757677838, 0.0529328657590962  ],
+                [ 6.9879322052002,    10.4171180725098,   13.6980228424072,   16.9236221313477    ],
+                [ 0.0470107184508114, 0.0136570088173405, 0.0059323726279831, 0.00312775039221944 ],
+                [ 6.9879322052002,    10.4171180725098,   13.6980228424072,   16.9236221313477    ],
+            ]
+        )
+
+    def forward(self, dist, three_body):
+        dist = dist / self.cutoff
+        rbfs = []
+
+        for j in range(self.max_l):
+            rbfs.append(torch.sin(self.coef[0, 0, j] * dist) / dist)
+
+        if self.max_n > 1:
+            for j in range(self.max_l):
+                rbfs.append(
+                    (
+                        self.coef[1, 0, j]
+                        * dist
+                        * torch.cos(self.coef[1, 1, j] * dist) 
+                        + self.coef[1, 2, j]
+                        * torch.sin(self.coef[1, 3, j] * dist)
+                    )
+                    / dist**2
+                )
+
+            if self.max_n > 2:
+                for j in range(self.max_l):
+                    rbfs.append(
+                        (
+                            self.coef[2, 0, j]
+                            * (dist**2)
+                            * torch.sin(self.coef[2, 1, j] * dist)
+                            - self.coef[2, 2, j]
+                            * dist
+                            * torch.cos(self.coef[2, 3, j] * dist) 
+                            + self.coef[2, 4, j]
+                            * torch.sin(self.coef[2, 5, j] * dist)
+                        )
+                        / (dist**3)
+                    )
+
+                if self.max_n > 3:
+                    for j in range(self.max_l):
+                        rbfs.append(
+                            (
+                                self.coef[3, 0, j]
+                                * (dist**3)
+                                * torch.cos(self.coef[3, 1, j] * dist)
+                                - self.coef[3, 2, j]
+                                * (dist**2)
+                                * torch.sin(self.coef[3, 3, j] * dist)
+                                - self.coef[3, 4, j]
+                                * dist
+                                * torch.cos(self.coef[3, 5, j] * dist)
+                                + self.coef[3, 6, j]
+                                * torch.sin(self.coef[3, 7, j] * dist)
+                            )
+                            / dist**4
+                        )
+
+        rbfs = torch.stack(rbfs, dim=-1)
+        rbfs = rbfs * self.factor
+        
+        cbfs = SphericalHarmonics(self.max_l - 1, torch.cos(three_body))
+
+        cbfs = cbfs.repeat_interleave(self.max_n, dim=1)
+        
+        return rbfs * cbfs
+
+
+class SinusoidalTimeExpansion(nn.Module):
+    """ Encode time """
+    
+    def __init__(self, dim: int = 128):
+        """
+        Args:
+            dim (int): the embedding size of Time.
+        """
+        super().__init__()
+
+        self.dim = dim
+        half_dim = self.dim // 2
+        # Inverse frequencies for sinusoidal embedding
+        self.register_buffer(
+            "inv_freq",
+            torch.exp(torch.arange(half_dim, dtype=torch.float32) * (-math.log(10000) / (half_dim - 1)))
+        )
+    
+    def forward(self, feature):
+        shape = feature.shape
+        feature = feature.view(-1).to(torch.float32)
+        sinusoid_in = torch.ger(feature, self.inv_freq)
+        time_emb = torch.cat([sinusoid_in.sin(), sinusoid_in.cos()], dim=-1)
+        # Restore original shape with embedding dimension
+        time_emb = time_emb.view(*shape, self.dim)
+
+        return time_emb

models/matris/matris/model/feature_embed.py

@@ -0,0 +1,268 @@
+from __future__ import annotations
+
+import torch
+from torch import Tensor, nn
+
+from .basis_function import (
+    FourierExpansion, 
+    BesselExpansion, 
+    GaussianExpansion,
+    GaussianExpansion,
+    SphericalExpansion,
+    SinusoidalTimeExpansion
+)
+from .functions import get_normalization, SwishLayer, aggregate
+
+class AtomTypeEmbedding(nn.Module):
+    """Encode an atom by its atomic number using 'nn.Embedding'."""
+    
+    def __init__(self, atom_feat_dim: int, max_num_elements: int = 94):
+        """
+        Args:
+            atom_feature_dim (int): dimension of atomic embedding.
+            max_num_elements (int): maximum number of elements in the dataset.
+                Default = 94
+        """
+        super().__init__()
+        self.embedding = nn.Embedding(max_num_elements, atom_feat_dim)
+        self.atom_swish_layer = SwishLayer(input_dim = atom_feat_dim,
+                                           output_dim = atom_feat_dim,
+                                           bias=False)
+
+    def forward(self, atom_type: Tensor) -> Tensor:
+        """
+        Args:
+            atom_type (Tensor): [nAtoms, 1].
+        """
+        node_feat = self.embedding(atom_type)
+        node_feat = self.atom_swish_layer(node_feat)
+        return node_feat
+
+
+class EdgeBasisEmbedding(nn.Module):
+    """Embed edge length using 'Bessel' or 'Gaussian'."""
+    
+    def __init__(
+        self,
+        pairwise_cutoff: float = 6,
+        three_body_cutoff: float = 4,
+        num_radial: int = 7,
+        edge_feat_dim: int = 128,
+        envelope_exponent: int = 8,
+        distance_expansion: str = "Bessel",
+        learnable: bool = False,
+    ):
+        """
+        Args:
+            pairwise_cutoff (float): The cutoff for pairwise interaction.
+                Default = 6
+            three_body_cutoff (float): The cutoff for three-body interaction. 
+                Default = 4
+            num_radial (int): The number of radial. 
+                Default = 7
+            envelope_exponent (int): envelope exponent of Envelope function.
+                Default = 8
+            distance_expansion (str): The function of basis, "Bessel" or "Gaussian".
+                Default = "Bessel"
+            learnable(bool): Whether the frequency in bessel expansion is learnable.
+                Default = False
+        """
+        super().__init__()
+
+        self.distance_expansion = distance_expansion
+        if self.distance_expansion.lower() == "bessel":
+            self.pairwise_rbf_expansion = BesselExpansion(
+                num_radial=num_radial,
+                cutoff=pairwise_cutoff,
+                envelope_exponent=envelope_exponent,
+                learnable=learnable,
+            )
+            self.threebody_rbf_expansion = BesselExpansion(
+                num_radial=num_radial,
+                cutoff=three_body_cutoff,
+                envelope_exponent=envelope_exponent,
+                learnable=learnable,
+            )
+        elif self.distance_expansion.lower() == "gaussian":
+            self.pairwise_rbf_expansion = GaussianExpansion(
+                start=0.0,
+                stop=pairwise_cutoff,
+                num_gaussians=num_radial,
+                basis_width_scalar=2.0,
+            )
+            self.threebody_rbf_expansion = GaussianExpansion(
+                start=0.0,
+                stop=three_body_cutoff,
+                num_gaussians=num_radial,
+                basis_width_scalar=2.0,
+            )
+        else:
+            raise NotImplementedError
+
+        self.edge_linear1 = nn.Linear(
+            in_features=num_radial, out_features=edge_feat_dim, bias=False
+        )
+        self.edge_linear2 = nn.Linear(
+            in_features=edge_feat_dim, out_features=edge_feat_dim, bias=False
+        )
+        self.swish_layer = SwishLayer(input_dim = edge_feat_dim,
+                                           output_dim = edge_feat_dim,
+                                           bias=False)
+        self.edge_init_norm = get_normalization(name="layer", dim=edge_feat_dim)
+
+        
+    def forward(
+        self,
+        graphs, 
+    ) -> tuple[Tensor, Tensor, Tensor]:
+        """
+        Args:
+            center_pos (Tensor): coord of center atoms.
+            neighbor_pos (Tensor): coordinates of neighbor atoms.
+            undirected2directed (Tensor): mapping from undirected vectors to one of its
+                directed vectors. Following repo: https://github.com/CederGroupHub/chgnet
+            image (Tensor): the periodic image specifying the location of neighbor atoms.
+            lattice (Tensor): the lattice matrix of structure.
+        """
+         
+        # From directed edge to undirected edge, this motivation is inspired by https://github.com/CederGroupHub/chgnet
+        unique_edge_lengths = torch.index_select( graphs['edge_lengths'], 0, graphs['undirected2directed'] ) #[nEdges/2]
+
+        pairwise_rbf = self.pairwise_rbf_expansion(unique_edge_lengths)  #[nEdges/2, num_radial]
+        threebody_rbf = self.threebody_rbf_expansion(unique_edge_lengths)  #[nEdges/2, num_radial]
+        
+        edge_feat_undirect = self.edge_linear1(pairwise_rbf)
+        # [edges, dim] -> [2*edges, dim]
+        edge_feat_direct = torch.index_select(edge_feat_undirect, 0, graphs['directed2undirected'])
+        edge_feat_direct = self.edge_linear2(edge_feat_direct)
+        edge_feat_direct = self.edge_init_norm(edge_feat_direct)
+        # Aggregate to bond_feas_ude
+        edge_feat = aggregate(data=edge_feat_direct, 
+                                                 segment=graphs['directed2undirected'],
+                                                 bin_count=None, 
+                                                 average=True, 
+                                                 num_segment=None)
+        edge_feat = self.swish_layer(edge_feat)
+        smooth_weight={"atom graph": pairwise_rbf, "line graph": threebody_rbf}
+        #return edge_feat, pairwise_rbf, threebody_rbf
+        return edge_feat, smooth_weight
+
+
+class ThreebodyEmbedding(nn.Module):
+    """Embed threebody using 'Fourier' or 'Sphere Harmonic'."""
+
+    def __init__(self, 
+                 num_angular: int = 7, # Fourier
+                 max_n: int=4, max_l: int=4, cutoff: int=6,  #SH
+                 three_body_feat_dim: int = 128,
+                 three_body_expansion: str = "fourier",
+                 learnable: bool = True):
+        super().__init__()
+        
+        self.three_body_expansion = three_body_expansion.lower()
+        if self.three_body_expansion == "fourier":
+            max_f = (num_angular - 1) // 2
+            self.expansion = FourierExpansion(
+                max_f=max_f, learnable=learnable
+            )
+            self.angle_embedding = nn.Linear(
+                in_features=num_angular, out_features=three_body_feat_dim, bias=False
+            )
+        elif self.three_body_expansion == "sh":
+            self.expansion = SphericalExpansion(max_n=max_n, max_l=max_l, cutoff=cutoff)
+            self.angle_embedding = nn.Linear(
+                in_features=max_n * max_l, out_features=three_body_feat_dim, bias=False
+            ) 
+        else:
+            raise NotImplementedError
+
+        self.swish_layer = SwishLayer(input_dim = three_body_feat_dim,
+                                    output_dim = three_body_feat_dim,
+                                    bias=False)
+     
+    def forward(self, graphs):
+        edge_vecs_ij = torch.index_select(
+            graphs['unit_edge_vectors'], 0, graphs['line_graph_dict']['target_DE_index']
+        ) # normalized edge vector ij [nAngle, 3]
+        edge_vecs_jk = torch.index_select(
+            graphs['unit_edge_vectors'], 0, graphs['line_graph_dict']['source_DE_index']
+        ) # normalized edge vector jk [nAngle, 3]
+        
+        theta_ijk = torch.sum(edge_vecs_ij * edge_vecs_jk, dim=1) * (1 - 1e-6)
+        angle = torch.acos(theta_ijk) 
+        
+        if self.three_body_expansion == "sh":
+            edge_vecs_jk_len = torch.norm(edge_vecs_jk, dim=1)
+            three_body_basis = self.expansion(edge_vecs_jk_len, angle)
+        else:
+            three_body_basis = self.expansion(angle)
+        
+        threebody_feat = self.angle_embedding(three_body_basis)
+        threebody_feat = self.swish_layer(threebody_feat)    
+        
+        return threebody_feat
+    
+
+class ThreebodyFourierExpansion(nn.Module):
+    """Encode an three-body terms using Fourier Expansion."""
+    
+    def __init__(self, num_angular: int = 7, learnable: bool = True):
+        super().__init__()
+        
+        assert num_angular % 2 == 1, f"{num_angular=} must be an odd integer"
+        max_f = (num_angular - 1) // 2
+        self.fourier_expansion = FourierExpansion(
+            max_f=max_f, learnable=learnable
+        )
+
+    def forward(self, edge_vec_ij: Tensor, edge_vec_jk: Tensor) -> Tensor:
+        """
+        Args:
+            edge_vec_i (Tensor): normalized edge vector ij [n_angle, 3]
+            edge_vec_j (Tensor): normalized edge vector jk [n_angle, 3]
+        """
+        theta_ijk = torch.sum(edge_vec_ij * edge_vec_jk, dim=1) * (1 - 1e-6)
+        angle = torch.acos(theta_ijk) 
+        return self.fourier_expansion(angle)
+
+
+class three_bodySHExpansion(nn.Module):
+    """Encode an three-body terms using Sphere Harmonic Expansion."""
+
+    def __init__(self, max_n: int=4, max_l: int=4, cutoff: int=6) -> None:
+        super().__init__()
+        self.sbf = SphericalExpansion(max_n=max_n, max_l=max_l, cutoff=cutoff)
+    
+    def forward(self, edge_vec_ij: Tensor, edge_vec_jk: Tensor) -> Tensor:
+        """
+        Args:
+            edge_vec_i (Tensor): normalized edge vector ij [n_angle, 3]
+            edge_vec_j (Tensor): normalized edge vector jk [n_angle, 3]
+        """
+        theta_ijk = torch.sum(edge_vec_ij * edge_vec_jk, dim=1) * (1 - 1e-6)
+        angle = torch.acos(theta_ijk)
+        
+        edge_vec_jk_len = torch.norm(edge_vec_jk, dim=1)
+        angle_basis = self.sbf(edge_vec_jk_len, angle)
+        return angle_basis
+
+
+class TimeEmbedding(nn.Module):
+    """Encode time using nonlinear"""
+
+    def __init__(self, time_feat_dim):
+        super().__init__()
+        self.time_encode = SinusoidalTimeExpansion(dim = time_feat_dim)
+        self.linear1 = nn.Linear(
+            in_features = time_feat_dim, out_features = 2 * time_feat_dim
+        )
+        self.act = nn.SiLU()
+        self.linear2 = nn.Linear(
+            in_features = time_feat_dim * 2, out_features = time_feat_dim
+        )
+     
+    def forward(self, time):
+        time_enc= self.time_encode(time)
+        time_enc = self.act(self.linear1(time_enc))
+        time_emb = self.linear2(time_enc)
+        return time_emb

models/matris/matris/model/functions.py

@@ -0,0 +1,466 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import torch
+from torch import Tensor, nn
+import math
+from .op import fused_silu, fused_sigmoid
+
+class FusedSiLU(torch.nn.Module):
+    """Fused Sigmoid Linear Unit."""
+
+    def __init__(self) -> None:
+        """Initialize a fused SiLU."""
+        super().__init__()
+
+    def forward(self, x: Tensor) -> Tensor:
+        """Forward pass."""
+        if x.device.type == "cuda":
+            return fused_silu(x)
+        else:
+            return torch.nn.functional.silu(x) 
+
+class FusedSigmoid(torch.nn.Module):
+    """Fused Sigmoid Linear Unit."""
+
+    def __init__(self) -> None:
+        """Initialize a fused SiLU."""
+        super().__init__()
+
+    def forward(self, x: Tensor) -> Tensor:
+        """Forward pass."""
+        if x.device.type == "cuda":
+            return fused_sigmoid(x)
+        else:
+            return torch.nn.functional.sigmoid(x)
+
+def get_activation(name: str) -> nn.Module:
+    """Return an activation function"""
+    activation_map = {
+        "relu": nn.ReLU,
+        "silu": FusedSiLU,  # Using fused version for better performance
+        "gelu": nn.GELU,
+        "softplus": nn.Softplus,
+        "sigmoid": FusedSigmoid,  # Using fused version for better performance
+        "tanh": nn.Tanh,
+    }
+    
+    name_lower = name.lower()
+    if name_lower not in activation_map:
+        raise NotImplementedError(
+            f"Activation '{name}' is not implemented. "
+            f"Supported activations: {list(activation_map.keys())}"
+        )
+    return activation_map[name_lower]()
+
+def get_normalization(name: str, dim: int | None = None) -> nn.Module | None:
+    """Return an normalization function"""
+    if name is None:
+        return None
+        
+    normalization_map = {
+        "layer": nn.LayerNorm(dim),
+        "rms": nn.RMSNorm(dim), # torch >= 2.6.0
+        "batch": nn.BatchNorm1d(dim),
+    }
+    name_lower = name.lower()
+    return normalization_map[name_lower]
+
+class SwishLayer(nn.Module):
+    def __init__(
+        self,
+        input_dim: int = 128,
+        output_dim: int = 128,
+        bias: bool = True,
+    ) -> None:
+        """
+        Args:
+            input_dim: Input dimension.
+            output_dim: Output dimension.
+            bias: Whether to use bias in the linear layer. Default: True.
+        """
+        super().__init__()
+        self.linear = nn.Linear(input_dim, output_dim, bias=bias)
+        self.act = get_activation("silu")
+    
+    def forward(self, feas: Tensor) -> Tensor:
+        """
+        Args:
+            feas: shape (feas_num, in_dim)
+            
+        Returns:
+            output: shape (feas_num, out_dim)
+        """
+        return self.act(self.linear(feas))
+
+def Dimwise_softmax(feas: Tensor, segment: Tensor, num_segment=None) -> Tensor:
+    """Computes a sparsely evaluated softmax.
+    
+    Args:
+        feas: The source tensor. shape: [num, dim]
+        segment: specify the segment of each row [num, 1] 
+    """
+    num, dim = feas.shape
+    if num_segment is None:
+        num_segment = int(segment.max()) + 1
+    
+    segment_expanded = segment.unsqueeze(1).expand(-1, dim) # [num, dim]
+    
+    feas_max = torch.empty( num_segment, dim, dtype=feas.dtype, device=feas.device )
+    feas_max.fill_(float("-inf"))
+    feas_max = feas_max.scatter_reduce(
+        0, segment_expanded, feas, reduce='amax', include_self=False,
+    ) #[num_segment, dim]
+    # Gather: [num_segment, dim] -> [num, dim]
+    feas_max = feas_max[segment]
+    out = (feas - feas_max).exp()
+    
+    # =========== scatter sum ============
+    out_sum = torch.zeros(num_segment, dim, device=feas.device, dtype=feas.dtype)
+    out_sum = out_sum.scatter_reduce(
+        0, segment_expanded, out, reduce='sum', include_self=False
+    )
+    # Gather: [num_segment, dim] -> [num, dim]
+    out_sum = out_sum[segment]
+    score = out / out_sum
+    return score
+
+def aggregate(data: torch.Tensor, 
+              segment: torch.Tensor, 
+              bin_count: torch.Tensor = None, 
+              average=True, 
+              num_segment=None) -> torch.Tensor:
+    """Aggregate rows in data by specifying the segment.
+
+    Args:
+        data (Tensor): data tensor to aggregate [n_row, feature_dim]
+        segment (Tensor): specify the owner of each row [n_row, 1]
+        average (bool): if True, average the rows, if False, sum the rows.
+            Default = True
+        num_owner (int, optional): the number of owners, this is needed if the
+            max idx of owner is not presented in owners tensor
+            Default = None
+
+    Returns:
+        output (Tensor): [num_owner, feature_dim]
+    """
+    if bin_count is None:
+        bin_count = torch.bincount(segment)
+        bin_count = bin_count.where(bin_count != 0, bin_count.new_ones(1))
+
+    if (num_segment is not None) and (bin_count.shape[0] != num_segment):
+        difference = num_segment - bin_count.shape[0]
+        bin_count = torch.cat([bin_count, bin_count.new_ones(difference)])
+    # make sure this operation is done on the same device of data and owners
+    output = data.new_zeros([bin_count.shape[0], data.shape[1]])
+    output = output.index_add_(0, segment, data)
+    if average:
+        output = (output.T / bin_count).T
+    return output
+
+
+class MLP(nn.Module):
+        
+    def __init__(
+        self,
+        input_dim: int = 128,
+        hidden_dim: int | Sequence[int] | None = (128, 128),
+        output_dim: int = 128,
+        dropout: float = 0.0,
+        activation: Literal["silu", "relu", "tanh", "gelu"] = "silu",
+        bias: bool = True,
+        use_fp16: bool = False,
+    ):
+        """Initialize the MLP layer.
+        Args:
+            input_dim: Dimension of input features.
+            hidden_dim: Number of hidden units. Can be an integer for a single
+                hidden layer, a sequence of integers for multiple hidden layers,
+                or None for no hidden layers. Default: (128, 128).
+            output_dim: Dimension of output predictions. Default: 128.
+            dropout: Dropout rate applied before each linear layer. Default: 0.0.
+            activation: Activation function. Supported: "relu", "silu", "tanh", "gelu".
+            bias: Whether to use bias in linear layers. Default: True.
+            use_fp16: Whether to use mixed precision (FP16). Default: False.
+        """
+        super().__init__()
+        if not 0.0 <= dropout < 1.0:
+            raise ValueError(f"Dropout rate must be in [0.0, 1.0), got {dropout}")
+        
+        self.use_fp16 = use_fp16
+        activation_func = get_activation(activation)
+
+        layers = []
+        if hidden_dim in (None, 0):
+            layers.append(nn.Dropout(dropout))
+            layers.append(nn.Linear(input_dim, output_dim, bias=bias))
+        elif isinstance(hidden_dim, int):
+            # Single hidden layer
+            layers.extend([
+                nn.Linear(input_dim, hidden_dim, bias=bias),
+                activation_func,
+                nn.Dropout(dropout),
+                nn.Linear(hidden_dim, output_dim, bias=bias),
+            ])
+        elif isinstance(hidden_dim, Sequence):
+            # Multiple hidden layers
+            layers.extend([
+                nn.Linear(input_dim, hidden_dim[0], bias=bias),
+                activation_func,
+            ])
+            # Additional hidden layers
+            for i in range(len(hidden_dim) - 1):
+                layers.extend([
+                    nn.Dropout(dropout),
+                    nn.Linear(hidden_dim[i], hidden_dim[i + 1], bias=bias),
+                    activation_func,
+                ])
+            # Output layer
+            layers.extend([nn.Dropout(dropout), nn.Linear(hidden_dim[-1], output_dim, bias=bias)])
+        else:
+            raise TypeError(
+                f"hidden_dim must be an integer, sequence of integers, or None, "
+                f"got {type(hidden_dim).__name__}"
+            )
+        
+        self.layers = nn.Sequential(*layers)
+        
+    def forward(self, feas: Tensor) -> Tensor:
+        """
+            Args:
+                feas: Input tensor of shape (features, input_dim)
+            Returns:
+                Output tensor of shape (features, output_dim)
+        """
+        if self.use_fp16 and feas.is_cuda:
+            with torch.amp.autocast(dtype=torch.float16, device_type="cuda"):
+                out = self.layers(feas)
+            out = out.to(torch.float32)
+        else:
+            out = self.layers(feas) 
+        return out
+
+
+class GatedMLP(nn.Module):
+    
+    def __init__(
+        self,
+        input_dim: int = 128,
+        hidden_dim: int | Sequence[int] | None = (128, 128),
+        output_dim: int = 128,
+        dropout: float = 0.0,
+        activation: str = "silu",
+        norm_type: str = "layer",
+        bias: bool = True,
+        use_fp16: bool = False,
+    ) -> None:
+        """
+        Args:
+            input_dim: The input dimension.
+            hidden_dim: A list of integers or a single integer representing the number 
+                of hidden units in each layer of the MLP. Default: None.
+            output_dim: The output dimension.
+            dropout: The dropout rate. Default: 0.0.
+            activation: The name of the activation function. Must be one of "relu", 
+                "silu", "tanh", or "gelu". Default: "silu".
+            norm_type: The name of the normalization layer to use. Must be one of 
+                "layer", "rms", "batch", "group", or None. Default: "layer".
+            bias: Whether to use bias in linear layers. Default: True.
+            use_fp16: Whether to use mixed precision (FP16). Default: False.
+        """
+        super().__init__()
+        self.use_fp16 = use_fp16
+        self.activation_func = get_activation(activation)
+        self.activation_gate = get_activation("sigmoid")
+        self.gate_norm = get_normalization(name=norm_type, dim=output_dim)
+        self.core_norm = get_normalization(name=norm_type, dim=output_dim)
+        self.mlp_core = MLP(
+            input_dim=input_dim,
+            hidden_dim=hidden_dim,
+            output_dim=output_dim,
+            dropout=dropout,
+            activation=activation,
+            bias=bias,
+            use_fp16=use_fp16,
+        )
+        self.mlp_gate = MLP(
+            input_dim=input_dim,
+            hidden_dim=hidden_dim,
+            output_dim=output_dim,
+            dropout=dropout,
+            activation=activation,
+            bias=bias,
+            use_fp16=use_fp16,
+        )
+
+    def forward(self, feas: Tensor) -> Tensor:
+        """
+        Args:
+            feas (Tensor): shape (feas_num, input_dim)
+        Returns:
+            output: shape (feas_num, output_dim)
+        """
+        if self.gate_norm is None:
+            core = self.activation_func(self.mlp_core(feas))
+            gate = self.activation_gate(self.mlp_gate(feas))
+        else:
+            core = self.activation_func(self.core_norm(self.mlp_core(feas)))
+            gate = self.activation_gate(self.gate_norm(self.mlp_gate(feas)))
+        out = core * gate # gate mul
+        return out
+
+
+class MOE_Layer(nn.Module):
+    
+    def __init__(
+        self,
+        num_expert: int = 64,
+        input_dim: int = 128,
+        hidden_dim: int | Sequence[int] | None = (128, 128),
+        output_dim: int = 128,
+        dropout: float = 0.0,
+        activation: Literal["silu", "relu", "tanh", "gelu"] = "silu",
+        bias: bool = True,
+        use_fp16: bool = False,
+    ):
+        """Initialize the MOE layer.
+
+        Args:
+            
+        """
+        super().__init__()
+        
+        raise NotImplementedError
+         
+    def forward(self, feas: Tensor) -> Tensor:
+        return None
+
+
+class GraphPooling(nn.Module):
+    def __init__(self, average: bool = False) -> None:
+        
+        super().__init__()
+        self.average = average
+
+    def forward(self, node_feat: Tensor, segment: Tensor) -> Tensor:
+        """
+        Args:
+            atom_feat (Tensor): batched atom features after convolution layers.
+                [num_batch_atoms, node_feat_dim or 1]
+            segment (Tensor): graph indices for each atom.
+                [num_batch_atoms]
+        
+        Returns:
+            crystal_feas (Tensor): crystal feature matrix.
+                [n_crystals, node_feat_dim or 1]
+        """
+        bin_count = torch.bincount(segment)
+        bin_count = bin_count.where(bin_count != 0, bin_count.new_ones(1))
+
+        output = node_feat.new_zeros([bin_count.shape[0], node_feat.shape[1]])
+        output = output.index_add_(0, segment, node_feat)
+        if self.average:
+            output = (output.T / bin_count).T
+        return output
+
+
+def cg_change_mat(ang_mom: int, device: str = "cpu") -> torch.tensor:
+    if ang_mom not in [2]:
+        raise NotImplementedError
+
+    if ang_mom == 2:
+        change_mat = torch.tensor(
+            [
+                [3 ** (-0.5), 0, 0, 0, 3 ** (-0.5), 0, 0, 0, 3 ** (-0.5)],
+                [0, 0, 0, 0, 0, 2 ** (-0.5), 0, -(2 ** (-0.5)), 0],
+                [0, 0, -(2 ** (-0.5)), 0, 0, 0, 2 ** (-0.5), 0, 0],
+                [0, 2 ** (-0.5), 0, -(2 ** (-0.5)), 0, 0, 0, 0, 0],
+                [0, 0, 0.5**0.5, 0, 0, 0, 0.5**0.5, 0, 0],
+                [0, 2 ** (-0.5), 0, 2 ** (-0.5), 0, 0, 0, 0, 0],
+                [
+                    -(6 ** (-0.5)),
+                    0,
+                    0,
+                    0,
+                    2 * 6 ** (-0.5),
+                    0,
+                    0,
+                    0,
+                    -(6 ** (-0.5)),
+                ],
+                [0, 0, 0, 0, 0, 2 ** (-0.5), 0, 2 ** (-0.5), 0],
+                [-(2 ** (-0.5)), 0, 0, 0, 0, 0, 0, 0, 2 ** (-0.5)],
+            ],
+            device=device,
+        ).detach()
+
+    return change_mat
+
+
+def irreps_sum(ang_mom: int) -> int:
+    """
+    Returns the sum of the dimensions of the irreps up to the specified angular momentum.
+
+    :param ang_mom: max angular momenttum to sum up dimensions of irreps
+    """
+    total = 0
+    for i in range(ang_mom + 1):
+        total += 2 * i + 1
+
+    return total
+
+
+def reshape_stress(L0out, L2out, batch_size=1):
+    _max_rank = 2
+    pred_irreps = torch.zeros(
+        (batch_size, irreps_sum(_max_rank)),
+        device = L0out.device,
+    )
+    # L=0
+    L=0
+    pred_irreps[: ,irreps_sum(L-1): irreps_sum(L)] = L0out.view(batch_size, -1)
+    
+    L=2
+    pred_irreps[: ,irreps_sum(L-1): irreps_sum(L)] = L2out.view(batch_size, -1) 
+    
+    pred = torch.einsum(
+        "ba, cb->ca",
+        cg_change_mat(_max_rank, device = L0out.device),
+        pred_irreps,
+    )
+    
+    return pred.view(batch_size, 3,3)
+
+
+class Sphere(nn.Module):
+    
+    def __init__(self, lmax=2):
+        super(Sphere, self).__init__()
+        self.lmax = lmax
+        
+    def forward(self, edge_vec):
+        edge_sh = self._spherical_harmonics(self.lmax, edge_vec[..., 0], edge_vec[..., 1], edge_vec[..., 2])
+        return edge_sh
+        
+    @staticmethod
+    def _spherical_harmonics(lmax: int, x: Tensor, y: Tensor, z: Tensor) -> Tensor:
+        sh_0_0 = torch.ones_like(x)
+        if lmax == 0:
+            return torch.stack([ sh_0_0, ], dim=-1)
+        
+        sh_1_0, sh_1_1, sh_1_2 = x, y, z
+        
+        if lmax == 1:
+            return torch.stack([sh_0_0, sh_1_0, sh_1_1, sh_1_2], dim=-1)
+
+        sh_2_0 = math.sqrt(3.0) * x * z
+        sh_2_1 = math.sqrt(3.0) * x * y
+        y2 = y.pow(2)
+        x2z2 = x.pow(2) + z.pow(2)
+        sh_2_2 = y2 - 0.5 * x2z2
+        sh_2_3 = math.sqrt(3.0) * y * z
+        sh_2_4 = math.sqrt(3.0) / 2.0 * (z.pow(2) - x.pow(2))
+
+        if lmax == 2:
+            return torch.stack([sh_0_0, sh_1_0, sh_1_1, sh_1_2, sh_2_0, sh_2_1, sh_2_2, sh_2_3, sh_2_4], dim=-1)

models/matris/matris/model/interaction_block.py

@@ -0,0 +1,507 @@
+from __future__ import annotations
+
+import torch
+from torch import Tensor, nn
+from typing import Any, Dict
+from .functions import (
+    MLP,
+    GatedMLP,
+    aggregate,
+    get_normalization,
+    Dimwise_softmax,
+)
+from torch.utils.checkpoint import checkpoint
+
+THRESHOLD_VALUE = 60000 # Safe value for MatRIS-10M (A100-80GB)
+
+class Graph_Attention_Layer(nn.Module):
+    
+    def __init__(
+        self,
+        node_feat_dim: int = 128,
+        edge_feat_dim: int = 128,
+        hidden_dim: int = 128,
+        use_bias: bool = False,
+        dropout: float = 0.0,
+        mlp_type: str = "GateMLP", # MLP, GateMLP
+        activation_type: str = "silu",
+        norm_type: str = "layer",
+        use_fp16: bool = False, 
+    ):
+        super().__init__()
+        
+        self.source_weight_linear = nn.Linear(
+            in_features = edge_feat_dim, out_features = edge_feat_dim, bias = False
+        )
+        self.target_weight_linear = nn.Linear(
+            in_features = edge_feat_dim, out_features = edge_feat_dim, bias = False
+        )
+        if mlp_type.lower() == "mlp":
+            self.node_nonlinear_update = nn.Sequential(
+                MLP(
+                    input_dim=edge_feat_dim * 2 + node_feat_dim,
+                    hidden_dim=hidden_dim,
+                    output_dim=node_feat_dim,
+                    dropout=dropout,
+                    bias=use_bias,
+                    activation=activation_type,
+                ),
+                get_normalization(name=norm_type, dim=node_feat_dim) 
+            )
+            self.edge_nonlinear_update = nn.Sequential(
+                MLP(
+                    input_dim=node_feat_dim * 2 + edge_feat_dim,
+                    hidden_dim=hidden_dim,
+                    output_dim=edge_feat_dim,
+                    dropout=dropout,
+                    bias=use_bias,
+                    activation=activation_type,
+                    use_fp16=use_fp16,
+                ),
+                get_normalization(name=norm_type, dim=edge_feat_dim) 
+            )
+        elif mlp_type.lower() == "gatemlp":
+            self.node_nonlinear_update = GatedMLP(
+                input_dim=edge_feat_dim * 2 + node_feat_dim,
+                hidden_dim=hidden_dim,
+                output_dim=node_feat_dim,
+                norm_type=norm_type,
+                dropout=dropout,
+                activation=activation_type,
+            )
+            self.edge_nonlinear_update = GatedMLP(
+                input_dim=node_feat_dim * 2 + edge_feat_dim,
+                hidden_dim=hidden_dim,
+                output_dim=edge_feat_dim,
+                norm_type=norm_type,
+                dropout=dropout,
+                activation=activation_type,
+                use_fp16=use_fp16,
+            )
+        else:
+            raise NotImplementedError
+
+        self.node_res_weight = torch.nn.Parameter(torch.ones(1, node_feat_dim), requires_grad=True)
+        self.edge_res_weight = torch.nn.Parameter(torch.ones(1, edge_feat_dim), requires_grad=True)
+    
+    def forward(self, 
+        node_feat: Tensor, 
+        edge_feat: Tensor, 
+        graph: Dict, # atom graph or line graph
+        directed2undirected: Tensor = None,
+    ): 
+        source_node_index = graph['source_index']
+        target_node_index = graph['target_index']
+        # gather
+        source_node_feat = torch.index_select(node_feat, 0, source_node_index)
+        target_node_feat = torch.index_select(node_feat, 0, target_node_index)
+        if directed2undirected is not None:
+            # Atom Graph Update
+            edge_feat_0 = torch.index_select(edge_feat, 0, directed2undirected) # [edge, dim] -> [2*edge, dim]
+        else:
+            # Line Graph Update
+            edge_feat_0 = edge_feat
+
+        #======= combine feature =======
+        attn_edge_feat = torch.cat([edge_feat_0, target_node_feat, source_node_feat], dim=1)
+        attn_edge_feat = self.edge_nonlinear_update(attn_edge_feat)
+
+        # ======= update atom feature ======= 
+        source_alpha_0 = self.source_weight_linear(edge_feat_0)
+        target_alpha_0 = self.target_weight_linear(edge_feat_0)
+        
+        # Softmax
+        num_segment = None #torch.unique(source_node_index).numel()
+        source_alpha = Dimwise_softmax(source_alpha_0, source_node_index, num_segment)
+        target_alpha = Dimwise_softmax(target_alpha_0, target_node_index, num_segment)
+        
+        source_weight = source_alpha * attn_edge_feat # refer to sa_{ij} * e'_{ij} in MatRIS paper
+        target_weight = target_alpha * attn_edge_feat # refer to ta_{ij} * e'_{ij} in MatRIS paper
+        
+        if directed2undirected is not None:
+            attn_edge_feat = aggregate(data=attn_edge_feat, segment=directed2undirected, bin_count=None, average=True, num_segment=None) #[2*edge, dim] -> [edge, dim]
+        # Compute Attention output
+        attn_source_feat = aggregate(data=source_weight, 
+                                     segment=source_node_index, 
+                                     bin_count=graph['source_bincount'],#bincount_source, 
+                                     average=False, 
+                                     num_segment=len(node_feat)) 
+
+        attn_target_feat = aggregate(data=target_weight, 
+                                     segment=target_node_index, 
+                                     bin_count=graph['target_bincount'],#bincount_target, 
+                                     average=False, 
+                                     num_segment=len(node_feat)) 
+
+        fusion_node_feat = torch.cat([node_feat, attn_target_feat, attn_source_feat], dim=1)
+        attn_node_feat = self.node_nonlinear_update(fusion_node_feat)
+        
+        # Resdual
+        attn_node_feat = attn_node_feat + self.node_res_weight * node_feat
+        attn_edge_feat = attn_edge_feat + self.edge_res_weight * edge_feat
+
+        return attn_node_feat, attn_edge_feat
+
+
+class Refinement(nn.Module):
+    
+    def __init__(
+        self,
+        node_feat_dim: int = 128,
+        edge_feat_dim: int = 128,
+        hidden_dim: int = 128,
+        num_basis: int = 7,
+        dropout: float = 0.0,
+        mlp_type: str = "GateMLP",    
+        activation_type: str = "silu",
+        norm_type: str = "layer",
+        use_bias: bool = False,
+        graph_type: Literal["atom graph", "line graph"] = "atom graph",
+        atom_feat_dim: int = 128,
+        use_smoothed_for_delta_edge: bool = False,
+        use_fp16: bool = False, 
+    ):
+        super().__init__()
+        self.graph_type = graph_type
+        self.use_smoothed_for_delta_edge = use_smoothed_for_delta_edge
+        
+        if graph_type == "atom graph":
+            input_dim = 2 * node_feat_dim + edge_feat_dim
+        else:
+            input_dim = atom_feat_dim + 2 * node_feat_dim + edge_feat_dim 
+        if mlp_type.lower() == "mlp":
+            self.edge_nonlinear_update = nn.Sequential(
+                MLP(
+                    input_dim=input_dim,
+                    hidden_dim=hidden_dim,
+                    output_dim=edge_feat_dim,
+                    dropout=dropout,
+                    bias=use_bias,
+                    activation=activation_type,
+                    use_fp16=use_fp16,
+                ),
+                get_normalization(name=norm_type, dim=edge_feat_dim)
+            )
+        elif mlp_type.lower() == "gatemlp":
+            self.edge_nonlinear_update = GatedMLP(
+                input_dim=input_dim,
+                hidden_dim=hidden_dim,
+                output_dim=edge_feat_dim,
+                dropout=dropout,
+                norm_type=norm_type,
+                activation=activation_type,
+                use_fp16=use_fp16,
+            )
+        else:
+            raise NotImplementedError
+        
+        self.node_FFN = MLP(
+            input_dim=edge_feat_dim,
+            hidden_dim=node_feat_dim,
+            output_dim=node_feat_dim,
+            bias=use_bias,
+        )
+        self.edge_FFN = MLP(
+            input_dim=edge_feat_dim,
+            hidden_dim=edge_feat_dim,
+            output_dim=edge_feat_dim,
+            bias=use_bias,
+            use_fp16=use_fp16,
+        )
+        self.learnable_envelope = nn.Linear(
+            in_features = num_basis, out_features = edge_feat_dim, bias = False
+        )
+        
+        self.node_res_weight = torch.nn.Parameter(torch.ones(1, node_feat_dim), requires_grad=True)
+        self.edge_res_weight = torch.nn.Parameter(torch.ones(1, edge_feat_dim), requires_grad=True)
+
+    def forward(
+        self,
+        node_feat: Tensor,
+        edge_feat: Tensor,
+        smooth_weight: Tensor,
+        graph: Dict,
+        directed2undirected: Tensor = None,
+        atom_feat: Tensor = None, # Line graph
+    ) -> Tensor:
+        # Gather
+        # when graph=="line graph", make sure atom_deat is not None.
+        is_atom_graph = (self.graph_type == "atom graph")
+        
+        if is_atom_graph: 
+            edge_feat_0 = torch.index_select(edge_feat, 0, directed2undirected) 
+        else:
+            edge_feat_0 = edge_feat
+
+        source_node_feat = torch.index_select(node_feat, 0, graph['source_index'])
+        target_node_feat = torch.index_select(node_feat, 0, graph['target_index'])
+        # Envelope 
+        if is_atom_graph:
+            smooth_weight = torch.index_select(smooth_weight, 0, directed2undirected)
+            smooth_weight = self.learnable_envelope(smooth_weight)
+            # Fusion feature
+            refine_fusion_feat = torch.cat([edge_feat_0, target_node_feat, source_node_feat], dim=1) 
+        else:
+            base_envelope = self.learnable_envelope(smooth_weight) 
+            base_weights_i = torch.index_select(base_envelope, 0, graph['source_index'])
+            base_weights_j = torch.index_select(base_envelope, 0, graph['target_index'])
+            smooth_weight = base_weights_i * base_weights_j
+            # Fusion feature
+            three_body_atom_feat = torch.index_select(atom_feat, 0, graph['atom_list'])
+            refine_fusion_feat = torch.cat([edge_feat_0, three_body_atom_feat, target_node_feat, source_node_feat], dim=1) 
+        
+        # Nonlinear            
+        refine_fusion_feat_nonlinear = self.edge_nonlinear_update(refine_fusion_feat)
+        refine_fusion_feat_smooth = refine_fusion_feat_nonlinear * smooth_weight 
+         
+        refine_node_feas = aggregate(refine_fusion_feat_smooth, 
+                                     graph['target_index'], 
+                                     graph['target_bincount'],
+                                     average=False, 
+                                     num_segment=len(node_feat))
+
+        input2edgeFFN = (
+            refine_fusion_feat_smooth
+            if is_atom_graph and self.use_smoothed_for_delta_edge
+            else refine_fusion_feat_nonlinear
+        )
+        
+        delta_node_feat = self.node_FFN(refine_node_feas)
+        delta_edge_feat = self.edge_FFN(input2edgeFFN)
+        
+        if is_atom_graph:  
+            delta_edge_feat = aggregate(data=delta_edge_feat, segment=directed2undirected, bin_count=None, average=True, num_segment=None) # [2*edge, dim] -> [edge, dim]
+
+        update_node_feat = delta_node_feat + self.node_res_weight * node_feat
+        update_edge_feat = delta_edge_feat + self.edge_res_weight * edge_feat
+        
+        return update_node_feat, update_edge_feat
+
+
+class Interaction_Block(nn.Module):
+    """
+    Interaction Block for MatRIS that processes both atom graphs and line graphs.
+    
+    This block performs attention-based message passing and refinement on two hierarchical graph structures:
+    1. Atom graph: Nodes represent atoms, edges represent bonds
+    2. Line graph: Nodes represent bonds, edges represent three-body interactions (angles)
+    
+    Attributes:
+        attn_block_atom_graph (Graph_Attention_Layer): Attention layer for atom graph
+        attn_block_line_graph (Graph_Attention_Layer): Attention layer for line graph
+        refine_block_atom_graph (Refinement): Refinement layer for atom graph  
+        refine_block_line_graph (Refinement): Refinement layer for line graph
+    """
+    
+    def __init__(self,
+                 node_feat_dim: int = 128,
+                 edge_feat_dim: int = 128,
+                 three_body_feat_dim: int = 128,
+                 num_radial: int = 7,
+                 num_angular: int = 7,
+                 dropout: float = 0.0, 
+                 use_bias: bool = False,
+                 use_smoothed_for_delta_edge: bool = False,
+                 mlp_type: str = "GateMLP",
+                 norm_type: str = "layer",
+                 activation_type: str = "silu",
+                 ):
+        """
+        Initialize the Interaction Block.
+
+        Args:
+            node_feat_dim (int): Dimension of node features (atom features)
+            edge_feat_dim (int): Dimension of edge features (bond features)  
+            three_body_feat_dim (int): Dimension of three-body features (angle features)
+            mlp_type (str): Type of MLP to use in the layers
+            norm_type (str): Type of normalization to apply
+            activation_type (str): Type of activation function to use
+        """
+        super().__init__()
+        
+        self.attn_block_atom_graph = Graph_Attention_Layer(
+                node_feat_dim=node_feat_dim,
+                edge_feat_dim=edge_feat_dim,
+                hidden_dim=node_feat_dim,
+                use_bias=use_bias,
+                mlp_type=mlp_type,
+                norm_type=norm_type,
+                activation_type=activation_type,
+            )
+
+        self.attn_block_line_graph = Graph_Attention_Layer(
+                node_feat_dim=edge_feat_dim,
+                edge_feat_dim=three_body_feat_dim,
+                hidden_dim=edge_feat_dim,
+                use_bias=use_bias,
+                mlp_type=mlp_type,
+                norm_type=norm_type,
+                activation_type=activation_type,
+                use_fp16=False,
+            )
+        
+        self.refine_block_atom_graph = Refinement(
+                node_feat_dim=node_feat_dim,
+                edge_feat_dim=edge_feat_dim,
+                hidden_dim=node_feat_dim,  
+                num_basis=num_radial,      
+                dropout=dropout,            
+                activation_type=activation_type,
+                norm_type=norm_type,
+                use_bias=use_bias,
+                mlp_type=mlp_type,
+                graph_type="atom graph",
+                use_smoothed_for_delta_edge=use_smoothed_for_delta_edge,
+            )
+        
+        self.refine_block_line_graph = Refinement(
+                node_feat_dim=edge_feat_dim,
+                edge_feat_dim=three_body_feat_dim,
+                hidden_dim=edge_feat_dim,  
+                num_basis=num_angular,     
+                dropout=dropout,          
+                activation_type=activation_type,
+                norm_type=norm_type,
+                use_bias=use_bias,
+                mlp_type=mlp_type,
+                graph_type="line graph",
+                atom_feat_dim=node_feat_dim,
+                use_fp16=False, 
+            )
+    
+    def forward(
+        self,
+        batch_graph: Dict,
+        node_feat: Tensor, 
+        edge_feat: Tensor, 
+        threebody_feat: Tensor | None,
+        smooth_weight: Tensor,
+    ) -> Tuple[Tensor, Tensor, Tensor]:
+        """Forward pass of the Interaction Block.
+        
+        Args:
+            batch_graph: Graph object containing:
+                - atom_graph_dict: Atom graph structure
+                - line_graph_dict: Bond graph (line graph) structure  
+                - directed2undirected: Mapping from directed to undirected edges
+                - bond_bases_bg: Smooth weights for bond graph
+                - bond_bases_ag: Smooth weights for atom graph
+            node_feat (Tensor): Node features [num_atoms, node_feat_dim]
+            edge_feat (Tensor): Edge features [num_bonds, edge_feat_dim] 
+            threebody_feat (Tensor): Three-body features [num_angles, three_body_feat_dim] or None
+            bincount_atom_graph (Dict): Bincount information for atom graph
+            bincount_line_graph (Dict): Bincount information for line graph
+        """
+        # Initialize variables to handle both cases (with and without threebody features)
+        attn_edge_feat = edge_feat 
+        attn_threebody_feat = threebody_feat
+        update_edge_feat = edge_feat
+        update_threebody_feat = threebody_feat 
+        use_checkpoint = (
+            isinstance(threebody_feat, torch.Tensor)
+            and threebody_feat.shape[0] > THRESHOLD_VALUE
+        )
+
+        # Process line graph (bond graph) with attention if threebody features exist
+        if threebody_feat is not None: 
+            attn_edge_feat, attn_threebody_feat = self.wrapper_attn_layer(
+                attn_layer=self.attn_block_line_graph,
+                node_feat=edge_feat,
+                edge_feat=threebody_feat,
+                graph=batch_graph['line_graph_dict'],
+                use_checkpoint=use_checkpoint, 
+            )
+
+        # Process atom graph with attention
+        attn_node_feat, attn_edge_feat = self.wrapper_attn_layer(
+            attn_layer=self.attn_block_atom_graph,
+            node_feat=node_feat, 
+            edge_feat=attn_edge_feat, 
+            graph=batch_graph['atom_graph_dict'], 
+            directed2undirected=batch_graph['directed2undirected'],
+        ) 
+        
+        # Refine line graph features if threebody features exist
+        if threebody_feat is not None:
+            update_edge_feat, update_threebody_feat = self.wrapper_refine_layer(
+                refine_layer=self.refine_block_line_graph,
+                node_feat=attn_edge_feat,
+                edge_feat=attn_threebody_feat,
+                smooth_weight=smooth_weight['line graph'],
+                graph=batch_graph['line_graph_dict'],
+                atom_feat=attn_node_feat,
+                use_checkpoint=use_checkpoint,
+            )
+        
+        # Refine atom graph features
+        update_node_feat, update_edge_feat = self.wrapper_refine_layer(
+            refine_layer=self.refine_block_atom_graph,
+            node_feat=attn_node_feat,
+            edge_feat=update_edge_feat,
+            smooth_weight=smooth_weight['atom graph'],
+            graph=batch_graph['atom_graph_dict'],
+            directed2undirected=batch_graph['directed2undirected'],
+        )
+        
+        return update_node_feat, update_edge_feat, update_threebody_feat
+    
+    def wrapper_attn_layer(self,
+                            attn_layer: nn.Module,
+                            node_feat: Tensor, 
+                            edge_feat: Tensor, 
+                            graph: Dict,
+                            directed2undirected: Tensor = None,
+                            use_checkpoint: bool = False,
+                       ):
+        if use_checkpoint:
+            attn_node_feat, attn_edge_feat = checkpoint(
+                attn_layer,
+                node_feat, 
+                edge_feat, 
+                graph,
+                directed2undirected,
+                use_reentrant=False,
+            ) 
+        else:
+            attn_node_feat, attn_edge_feat = attn_layer(
+                node_feat=node_feat, 
+                edge_feat=edge_feat, 
+                graph=graph,
+                directed2undirected=directed2undirected,
+            )
+        
+        return attn_node_feat, attn_edge_feat 
+        
+    def wrapper_refine_layer(self, 
+                            refine_layer: nn.Module,
+                            node_feat: Tensor,
+                            edge_feat: Tensor,
+                            smooth_weight: Tensor,
+                            graph: Dict,
+                            directed2undirected: Tensor = None,
+                            atom_feat: Tensor = None,
+                            use_checkpoint: bool = False,
+                        ):
+        if use_checkpoint:
+            update_node_feat, update_edge_feat = checkpoint(
+                refine_layer,
+                node_feat,
+                edge_feat,
+                smooth_weight,
+                graph,
+                directed2undirected,
+                atom_feat,
+                use_reentrant=False,
+            )
+        else:
+            update_node_feat, update_edge_feat = refine_layer(
+                    node_feat=node_feat,
+                    edge_feat=edge_feat,
+                    smooth_weight=smooth_weight,
+                    graph=graph,
+                    directed2undirected=directed2undirected,
+                    atom_feat=atom_feat,
+                )
+        return update_node_feat, update_edge_feat 
+        
+    

models/matris/matris/model/model.py

@@ -0,0 +1,321 @@
+from typing import Literal, Union, Sequence
+
+import torch
+from torch import Tensor, nn
+import os
+from collections.abc import Sequence
+
+from ..graph import RadiusGraph, GraphConverter, datatype
+from .reference_energy import AtomRef
+from .processgraph import process_graphs
+from .feature_embed import (
+    ThreebodyFourierExpansion, 
+    AtomTypeEmbedding, 
+    EdgeBasisEmbedding, 
+    ThreebodyEmbedding
+)
+from .functions import (
+    MLP,
+    GatedMLP,
+    get_normalization
+)
+from .interaction_block import Interaction_Block
+from .readout import (
+    EnergyHead,
+    MagmomHead,
+    ForceStressHead,
+)
+
+
+class MatRIS(nn.Module):
+    """ Init MatRIS Potential """
+    
+    def __init__(
+        self,
+        num_layers: int = 6, # NOTE orig,debug = 6,2
+        node_feat_dim: int = 128, # NOTE orig,debug = 128,32
+        edge_feat_dim: int = 128, # NOTE orig,debug = 128,3
+        three_body_feat_dim: int = 128, # NOTE orig,debug = 128,32
+        mlp_hidden_dims: Union[int, Sequence[int]] = (128, 128),
+        dropout: float = 0.0,
+        use_bias: bool = False, 
+        distance_expansion: str = "Bessel", 
+        three_body_expansion: str = "SH",
+        num_radial: int = 7,
+        num_angular: int = 7,
+        max_l: int = 4,
+        max_n: int = 4,
+        envelope_exponent: int = 8,
+        graph_conv_mlp: str = "GateMLP",
+        activation_type: str = "silu",
+        norm_type: str = "rms",
+        pairwise_cutoff: float = 6,
+        three_body_cutoff: float = 4,
+        use_smoothed_for_delta_edge: bool = False,
+        learnable_basis: bool = True,
+        is_intensive: bool = True,
+        is_conservation: bool = True,
+        reference_energy: str | None = None,
+    ):
+        """
+        Args:
+            num_layers (int): message passing layers.
+            node_feat_dim (int): atom feature embedding dim.
+            edge_feat_dim (int): edge(pairwise) feature embedding dim.
+            three_body_feat_dim (int): angle(three body) feature embedding dim.
+            mlp_hidden_dims (List or int): hidden dims of MLP. 
+                Can be 'int' or 'list'.
+            dropout (float): dropout rate in MLP.
+            use_bias (bool): whether use bias in Interaction block.
+            distance_expansion (str):  The function of pairwise basis. 
+                Can be "Bessel" or "Gaussian".
+            three_body_expansion (str): The function of three body basis. 
+                Can be "Fourier(fourier)" or "Spherical Harmonics(sh)".
+            num_radial (int): number of radial basis used in Bessel and Gaussian basis.
+            num_angular (int): number of three_body basis used in Fourier basis.
+            max_l (int): Maximum l value for Spherical Harmonics basis (SH).
+            max_n (int): Maximum n value for Spherical Harmonics basis (SH).
+            envelope_exponent (int): exponent of 'PolynomialEnvelope'.
+            graph_conv_mlp (str): The type of MLP in mp layers. 
+                Can be "MLP", "GatedMLP" and "MoE". 
+                See fucntion.py for more informations.
+            activation_type (str): activation function. 
+                Can be "SiLU(silu)", "Sigmoid(sigmoid)", "ReLU(relu)"...
+                See fucntion.py for more informations.
+            norm_type (str): normalization function used in MLP.
+                Can be "LayerNorm(layer)", "BatchNorm(batch)", "RMSNorm(rms)"...
+                See fucntion.py for more informations.
+            pairwise_cutoff (float): The cutoff of Atom graph.
+            three_body_cutoff (float): The cutoff of Line graph.
+            use_smoothed_for_delta_edge (bool): Whether to use the smoothed features for edge feature update.
+            learnable_basis (bool): Whether the basis functions are learnable.
+            is_intensive (bool): whether the model outputs energy per atom (True) or total energy (False).
+            is_conservation (bool): whether use conservate force and stress.
+            reference_energy (str): refernece energy of 'str'(eg. MPtrj, OMat..) dataset(Caculated by linear regression).
+                more details can be found at reference_energy.py.
+        """
+        
+        super().__init__()
+        # model configs
+        self.config = { k: v for k, v in locals().items() if k not in ["self", "__class__"] }
+
+        self.is_intensive = is_intensive
+        
+        self.reference_energy = None
+        if reference_energy is not None:
+            self.reference_energy = AtomRef(
+                reference_energy=reference_energy,
+                is_intensive=is_intensive
+            ) 
+        
+        # Define Graph Converter
+        self.graph_converter = GraphConverter(
+            atom_graph_cutoff=pairwise_cutoff,
+            line_graph_cutoff=three_body_cutoff,
+        )
+
+        # ====== embedding layers ========
+        self.atom_embedding = AtomTypeEmbedding(atom_feat_dim=node_feat_dim)
+        self.edge_embedding = EdgeBasisEmbedding(
+            pairwise_cutoff=pairwise_cutoff,
+            three_body_cutoff=three_body_cutoff,
+            num_radial=num_radial,
+            edge_feat_dim=edge_feat_dim,
+            envelope_exponent=envelope_exponent,
+            learnable=learnable_basis,
+            distance_expansion=distance_expansion,
+        )
+        self.three_body_embedding = ThreebodyEmbedding(
+            num_angular = num_angular, # Fourier
+            max_n=max_n, max_l=max_l, cutoff=pairwise_cutoff, # Spherical Harmonics
+            three_body_feat_dim = three_body_feat_dim,
+            three_body_expansion = three_body_expansion,
+            learnable = learnable_basis
+        )
+        # ====== Interaction layers ========
+        interaction_block = [
+            Interaction_Block(
+                node_feat_dim=node_feat_dim, 
+                edge_feat_dim=edge_feat_dim,
+                three_body_feat_dim=three_body_feat_dim,
+                num_radial=num_radial,
+                num_angular=num_angular,
+                dropout=dropout,
+                use_bias=use_bias,
+                use_smoothed_for_delta_edge=use_smoothed_for_delta_edge,
+                mlp_type=graph_conv_mlp,
+                norm_type=norm_type,
+                activation_type=activation_type,
+            )
+            for _ in range(num_layers)
+        ]
+        self.interaction_block = nn.ModuleList(interaction_block)
+
+        # ====== Readout layers ======== 
+        self.readout_norm = get_normalization(norm_type, dim=node_feat_dim)
+
+        self.energy_head = EnergyHead(
+            feat_dim = node_feat_dim,
+            hidden_dim = mlp_hidden_dims,
+            output_dim = 1,
+            mlp_type = "mlp",
+            activation_type = activation_type,
+        )
+        self.magmom_head = MagmomHead(
+            feat_dim = node_feat_dim,
+            hidden_dim = 2 * node_feat_dim,
+            output_dim = 1,
+            mlp_type = "mlp",
+            activation_type = activation_type,
+        )
+        self.force_stress_head = ForceStressHead(
+            is_conservation = is_conservation,
+            feat_dim = edge_feat_dim, # is_conservation == False
+            hidden_dim = mlp_hidden_dims, # is_conservation == False
+            output_dim = 3, # is_conservation == False
+            mlp_type = "mlp", # is_conservation == False
+            activation_type = activation_type, # is_conservation == False
+        )
+        
+        if not torch.distributed.is_initialized() or torch.distributed.get_rank() == 0:
+            print(f"MatRIS initialized with {self.get_params()} parameters")
+
+    def forward(
+        self,
+        graphs: Sequence[RadiusGraph],
+        task: str = "ef",
+        is_training: bool = False,
+    ) -> dict[str, Tensor]:
+        """
+        Args:
+            graphs (List): a list of RadiusGraph.
+            task (str): the prediction task. Can be 'e', 'em', 'ef', 'efs', 'efsm'.
+        """
+        prediction = {}
+        # ======== Graph processing ========
+        batch_graph = process_graphs(graphs, compute_stress="s" in task)
+        
+        # ======== Feature embedding ========
+        node_feat = self.atom_embedding( batch_graph['atomic_numbers'] - 1 ) # atom type feature init (use 0 for 'H')
+        edge_feat, smooth_weight = self.edge_embedding(graphs=batch_graph) # pairwise feature init
+        threebody_feat = None 
+        if len(batch_graph['line_graph_dict']['line_graph']) != 0:
+            threebody_feat = self.three_body_embedding(graphs=batch_graph) # three body feature init
+        
+        # ======== Interaction Block =======
+        for mp_layer in self.interaction_block:
+            node_feat, edge_feat, threebody_feat = mp_layer(
+                batch_graph=batch_graph,
+                node_feat=node_feat,
+                edge_feat=edge_feat,
+                threebody_feat=threebody_feat,
+                smooth_weight=smooth_weight,
+            )
+        
+        # ======== Readout Block ======= 
+        node_feat = self.readout_norm(node_feat)
+        
+        total_energy = self.energy_head(batch_graph = batch_graph, node_feat = node_feat)
+        
+        force_stress_dict = self.force_stress_head(
+            batch_graph = batch_graph, 
+            compute_force="f" in task,
+            compute_stress="s" in task,
+            total_energy = total_energy, 
+            node_feat = node_feat, 
+            edge_feat = edge_feat, 
+            is_training = is_training)
+        prediction.update(force_stress_dict)
+        
+        if "m" in task:
+            magmom = self.magmom_head(batch_graph = batch_graph, node_feat = node_feat)
+            prediction["m"] = magmom
+        
+        atoms_per_graph_tensor = torch.tensor(batch_graph['atoms_per_graph'], 
+                                                  dtype=torch.int32, 
+                                                  device=total_energy.device)
+        if self.is_intensive:
+            energy_per_atom = total_energy / atoms_per_graph_tensor
+            prediction["e"] = energy_per_atom
+        else:
+            prediction["e"] = total_energy
+
+        prediction["atoms_per_graph"] = atoms_per_graph_tensor 
+
+        ref_energy = (
+            0 if self.reference_energy is None else self.reference_energy(graphs)
+        )
+        prediction["e"] += ref_energy
+        prediction["ref_energy"] = ref_energy
+        return prediction
+    
+    def get_params(self) -> int:
+        """Return the number of parameters in the model."""
+        return sum(p.numel() for p in self.parameters())
+
+    @classmethod
+    def from_dict(cls, dct: dict):
+        matris = MatRIS(**dct["config"])
+        matris.load_state_dict(dct["state_dict"])
+        return matris
+    
+    @classmethod
+    def load(
+        cls,
+        model_name: str = "matris_10m_oam",
+        device: str | None = None,
+        cache_dir: str | None = None,
+    ):
+        """Load pretrained model."""
+        model_name = model_name.lower()
+        supported_models = ["matris_10m_oam", "matris_10m_mp"]
+        if model_name not in supported_models:
+            raise ValueError(f"Unsupported model_name: {model_name}. Supported models are: {supported_models}")
+
+        if device is None:
+            device = "cuda" if torch.cuda.is_available() else "cpu"
+        
+        
+        if cache_dir is None:
+            cache_dir = os.environ.get("MATRIS_CACHE_DIR", "~/.cache/matris")
+
+        cache_dir = os.path.expanduser(cache_dir)
+        os.makedirs(cache_dir, exist_ok=True)
+
+        checkpoint_files = {
+            "matris_10m_omat": "MatRIS_10M_OMAT.pth.tar",
+            "matris_10m_oam": "MatRIS_10M_OAM.pth.tar",
+            "matris_10m_mp": "MatRIS_10M_MP.pth.tar",
+            "matris_6m_mp": "MatRIS_6M_MP.pth.tar",
+        }
+
+        DOWNLOAD_URLS = {
+            "matris_10m_omat": "",  # TODO
+            "matris_10m_oam": "https://figshare.com/ndownloader/files/59142728",
+            "matris_10m_mp": "https://figshare.com/ndownloader/files/59143058",
+            "matris_6m_mp": "",  # TODO
+        }
+
+        ckpt_filename = checkpoint_files[model_name]
+        ckpt_path = os.path.join(cache_dir, ckpt_filename)
+
+        if not os.path.exists(ckpt_path):
+            url = DOWNLOAD_URLS.get(model_name)
+            if not url:
+                raise ValueError(f"No download URL provided for model: {model_name}")
+
+            print(f"Checkpoint not found, downloading to {ckpt_path} ...")
+            torch.hub.download_url_to_file(url, ckpt_path)
+        
+        
+        ckpt_state = torch.load(
+            ckpt_path, 
+            map_location=torch.device("cpu"), 
+            weights_only=False
+        )
+        model = MatRIS.from_dict(ckpt_state)
+        
+        model = model.to(device)
+        print(f"Loading {model_name} successfully, running on {device}.")
+        
+        return model

models/matris/matris/model/op/__init__.py

@@ -0,0 +1,9 @@
+from .fused_silu_op import fused_silu
+from .fuse_sigmoid_op import fused_sigmoid
+from .fuse_basis_func import fusion_env_val
+
+__all__ = [
+    "fused_silu",
+    "fused_sigmoid",
+    "fusion_env_val",
+]

models/matris/matris/model/op/fuse_basis_func.py

@@ -0,0 +1,129 @@
+import torch
+from torch.autograd import Function
+from torch.profiler import profile, ProfilerActivity,record_function
+
+fusion_envelop_string = """
+    template <typename T> T envelop_fwd_kernel(T r_scaled, T a, T b, T c, T p) 
+    {
+        return ( 1 + a * pow(r_scaled, p) + b * pow(r_scaled, (p + 1)) + c * pow(r_scaled, (p + 2)) );
+    }
+"""
+#return ( 1 + a * r_scaled ** p + b * r_scaled ** (p + 1) + c * r_scaled ** (p + 2) );
+envelop_fwd_func = torch.cuda.jiterator._create_jit_fn(fusion_envelop_string)
+
+fusion_envelop_bwd_string = """
+    template <typename T> T envelop_bwd_kernel(T grad_output, T r_scaled, T a, T b, T c, T p) 
+    {
+        T grad_r_scaled = (
+            a * p * pow(r_scaled, (p - 1))
+            + b * (p + 1) * pow(r_scaled, p)
+            + c * (p + 2) * pow(r_scaled, (p + 1))
+        );
+        return grad_output * grad_r_scaled; 
+    }
+"""
+envelop_bwd_func = torch.cuda.jiterator._create_jit_fn(fusion_envelop_bwd_string)
+
+fusion_envelop_gradbwd_string = """
+    template <typename T> T envelop_bwd_kernel(T d_grad_r_scaled, T grad_output, T r_scaled, T a, T b, T c, T p, T &grad_grad_output, T &grad_r_scaled) 
+    {
+        grad_grad_output = (
+            a * p * pow(r_scaled, (p - 1))
+            + b * (p + 1) * pow(r_scaled, p)
+            + c * (p + 2) * pow(r_scaled, (p + 1))
+        );
+        grad_grad_output = d_grad_r_scaled * grad_grad_output;
+
+        T grad_r_scaled_term = (
+            a * p * (p - 1) * pow(r_scaled, (p - 2))
+            + b * (p + 1) * p * pow(r_scaled, (p - 1))
+            + c * (p + 2) * (p + 1) * pow(r_scaled, p)
+        );
+        grad_r_scaled = d_grad_r_scaled * grad_output * grad_r_scaled_term;
+    }
+"""
+envelop_gradbwd_func = torch.cuda.jiterator._create_multi_output_jit_fn(fusion_envelop_gradbwd_string, num_outputs=2)
+
+
+class envelop_bwd(Function):
+    @staticmethod
+    def forward(ctx, grad_output: torch.Tensor, r_scaled: torch.Tensor, a: torch.Tensor, b: torch.Tensor, c: torch.Tensor, p: torch.Tensor): 
+        """
+        # Compute grad_r_scaled
+        grad_r_scaled_part = (
+            a * p * r_scaled ** (p - 1)
+            + b * (p + 1) * r_scaled ** p
+            + c * (p + 2) * r_scaled ** (p + 1)
+        )
+        
+        grad_r_scaled = grad_output * grad_r_scaled_part
+        """ 
+        grad_r_scaled = envelop_bwd_func(grad_output, r_scaled, a, b, c, p)
+        # Save for backward
+        ctx.save_for_backward(grad_output, r_scaled)
+        ctx.a = a
+        ctx.b = b
+        ctx.c = c
+        ctx.p = p
+
+        return grad_r_scaled
+
+    @staticmethod
+    def backward(ctx, d_grad_r_scaled):
+        grad_output, r_scaled = ctx.saved_tensors
+        a = ctx.a
+        b = ctx.b
+        c = ctx.c
+        p = ctx.p
+        """
+        # Compute gradient w.r.t grad_output
+        grad_grad_output = (
+            a * p * r_scaled ** (p - 1)
+            + b * (p + 1) * r_scaled ** p
+            + c * (p + 2) * r_scaled ** (p + 1)
+        )
+        grad_grad_output = d_grad_r_scaled * grad_grad_output  # chain rule
+
+        # Compute gradient w.r.t r_scaled
+        grad_r_scaled_term = (
+            a * p * (p - 1) * r_scaled ** (p - 2)
+            + b * (p + 1) * p * r_scaled ** (p - 1)
+            + c * (p + 2) * (p + 1) * r_scaled ** p
+        )
+        grad_r_scaled = d_grad_r_scaled * grad_output * grad_r_scaled_term  # chain rule
+        """
+        grad_grad_output, grad_r_scaled = envelop_gradbwd_func(d_grad_r_scaled, grad_output, r_scaled, a, b, c, p)
+        # Return gradients in the order of forward's inputs
+        return grad_grad_output, grad_r_scaled, None, None, None, None
+
+    
+class envelop_fwd(Function):
+    @staticmethod
+    def forward(ctx, r_scaled: torch.Tensor, a: torch.Tensor, b:torch.Tensor, c: torch.Tensor, p:torch.Tensor): 
+        output = envelop_fwd_func(r_scaled, a, b, c, p)
+        ctx.save_for_backward(r_scaled)
+        ctx.a = a
+        ctx.b = b
+        ctx.c = c
+        ctx.p = p
+        return output
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        (r_scaled,) = ctx.saved_tensors
+        a = ctx.a
+        b = ctx.b
+        c = ctx.c
+        p = ctx.p
+
+        grad_r_scaled = envelop_bwd.apply(grad_output, r_scaled, a, b, c, p)
+        
+        return grad_r_scaled, None, None, None, None
+    
+
+def fusion_env_val(r_scaled:torch.Tensor, a:torch.Tensor, b:torch.Tensor, c:torch.Tensor, p:torch.Tensor):
+    if r_scaled.device.type == "cuda":
+        return envelop_fwd.apply(r_scaled, a, b, c, p) 
+    else:
+        return ( 1 + a * r_scaled ** p + b * r_scaled ** (p + 1) + c * r_scaled ** (p + 2) )
+

models/matris/matris/model/op/fuse_sigmoid_op.py

@@ -0,0 +1,63 @@
+import torch
+from torch.autograd import Function
+from torch.profiler import profile, ProfilerActivity,record_function
+
+
+sigmoid_bwd_string = """
+    template <typename T> T sigmoid_bwd_kernel(T dgrad, T output) 
+    { 
+        return dgrad * output * (1 - output); 
+    }
+"""
+sigmoid_bwd_func = torch.cuda.jiterator._create_jit_fn(sigmoid_bwd_string)
+
+sigmoid_gradbwd_string = """
+    template <typename T> T sigmoid_grad_bwd_kernel(T grad_output, T dgrad, T output, T &grad_dgrad, T &grad_output_val) 
+    { 
+        grad_dgrad = grad_output * output * (1 - output);
+        grad_output_val = grad_output * dgrad * (1 - 2 * output); 
+    }
+"""
+sigmoid_gradbwd_func = torch.cuda.jiterator._create_multi_output_jit_fn(sigmoid_gradbwd_string, num_outputs=2)
+
+
+class sigmoid_bwd(Function):
+    @staticmethod
+    def forward(ctx, dgrad, output):
+        #grad_feas = dgrad * output * (1 - output)
+        with record_function("sigmoid bwd"):  
+            grad_feas = sigmoid_bwd_func(dgrad, output)
+        ctx.save_for_backward(dgrad, output)
+        #ctx.save_for_backward()
+        return grad_feas
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        dgrad, output = ctx.saved_tensors
+        """
+        grad_dgrad = grad_output * output * (1 - output)
+        grad_output_val = grad_output * dgrad * (1 - 2 * output)
+        """
+        with record_function("sigmoid grad bwd"):  
+            grad_dgrad, grad_output_val = sigmoid_gradbwd_func(grad_output, dgrad, output) 
+        return grad_dgrad, grad_output_val
+
+class sigmoid_fwd(Function):
+    @staticmethod
+    def forward(ctx, feas): 
+        output = torch.nn.functional.sigmoid(feas)
+        ctx.save_for_backward(output)
+        return output
+
+    @staticmethod
+    def backward(ctx, dgrad):
+        output, = ctx.saved_tensors
+        grad_feas = sigmoid_bwd.apply(dgrad, output)
+        return grad_feas
+
+def fused_sigmoid(input_feas):
+    if input_feas.device.type == "cuda":
+        return sigmoid_fwd.apply(input_feas)
+    else:
+        return torch.nn.functional.sigmoid(input_feas)
+    

models/matris/matris/model/op/fused_silu_op.py

@@ -0,0 +1,82 @@
+import torch
+from torch.autograd import Function
+from torch.profiler import profile, ProfilerActivity,record_function
+
+silu_bwd_string = """
+    template <typename T> T silu_bwd_kernel(T dgrad, T x) 
+    { 
+        T sigmoid_x = 1/(1 + exp(-x));
+        
+        T grad_input = dgrad * (1 + x*(1-sigmoid_x)) * sigmoid_x;
+        
+        return grad_input;
+    }
+"""
+silu_bwd_func = torch.cuda.jiterator._create_jit_fn(silu_bwd_string)
+
+silu_gradbwd_string = """
+    template <typename T> T silu_grad_bwd_kernel(T grad_grad_input, T grad_output, T x, T &grad_grad_output, T &grad_x) 
+    {   
+        T sigmoid_x = 1/(1 + exp(-x));
+        T term = sigmoid_x * (1 + x * (1 - sigmoid_x));
+        grad_grad_output = grad_grad_input * term;
+        
+        T sigmoid_derivative = sigmoid_x * (1 - sigmoid_x);
+        T d_term_dx = sigmoid_derivative * (2 + x * (1 - 2 * sigmoid_x));
+        grad_x = grad_grad_input * grad_output * d_term_dx; 
+        
+    }
+"""
+silu_gradbwd_func = torch.cuda.jiterator._create_multi_output_jit_fn(silu_gradbwd_string, num_outputs=2)
+
+
+class fusion_silu_bwd(Function):
+    @staticmethod
+    def forward(ctx, grad_output, x):
+        ctx.save_for_backward(x, grad_output)
+        """
+        sigmoid_x = torch.sigmoid(x)
+        grad_input = grad_output * (1 + x * (1 - sigmoid_x)) * sigmoid_x
+        """
+        with record_function("silu bwd"): 
+            grad_input = silu_bwd_func(grad_output, x) 
+        return grad_input
+
+    @staticmethod
+    def backward(ctx, grad_grad_input):
+        """
+        sigmoid_x = torch.sigmoid(x)
+        term = sigmoid_x * (1 + x * (1 - sigmoid_x))
+        grad_grad_output = grad_grad_input * term
+        sigmoid_derivative = sigmoid_x * (1 - sigmoid_x)
+        d_term_dx = sigmoid_derivative * (2 + x * (1 - 2 * sigmoid_x))
+        
+        grad_x = grad_grad_input * grad_output * d_term_dx
+        """
+        x, grad_output = ctx.saved_tensors
+            
+        with record_function("silu grad bwd"):  
+            grad_grad_output, grad_x = silu_gradbwd_func(grad_grad_input, grad_output, x)  
+        return grad_grad_output, grad_x
+
+class fusion_silu_fwd(Function):
+    @staticmethod
+    def forward(ctx, x):
+        
+        out = torch.nn.functional.silu(x)
+        ctx.save_for_backward(x)
+        return out
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        x, = ctx.saved_tensors
+        grad_input = fusion_silu_bwd.apply(grad_output, x)
+        return grad_input
+
+def fused_silu(input_feas):
+    if input_feas.device.type == "cuda":
+        return fusion_silu_fwd.apply(input_feas)
+    else:
+        return torch.nn.functional.silu(input_feas)
+
+# out = fused_silu(input)

models/matris/matris/model/op/src/Opdefine.h

@@ -0,0 +1,13 @@
+#ifndef OP_SRC_OPDECLARE_H_
+#define OP_SRC_OPDECLARE_H_
+
+#include <torch/extension.h>
+
+
+torch::Tensor fused_SiLU_Bwd(const torch::Tensor &dgrad, const torch::Tensor &input);
+
+std::vector<torch::Tensor> fused_SiLU_Grad_Bwd(const torch::Tensor &grad_grad_input, const torch::Tensor &grad_output,
+                                                const torch::Tensor &input);
+
+
+#endif  // OP_SRC_OPDECLARE_H_