matcalc 0.2.1__tar.gz → 0.2.2__tar.gz

{matcalc-0.2.1/src/matcalc.egg-info → matcalc-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matcalc
-Version: 0.2.1
+Version: 0.2.2
 Summary: Calculators for materials properties from the potential energy surface.
 Author-email: Runze Liu <rul048@ucsd.edu>, Eliott Liu <elliottliu17@gmail.com>, Janosh Riebesell <janosh@lbl.gov>, Ji Qi <j1qi@ucsd.edu>, Shyue Ping Ong <ongsp@ucsd.edu>, Tsz Wai Ko <t1ko@ucsd.edu>
 Keywords: AI,deep learning,force field,graph,interatomic potential,machine learning,materials,property prediction,science
@@ -41,11 +41,15 @@ Provides-Extra: grace
 Requires-Dist: tensorpotential>=0.5.1; extra == "grace"
 Provides-Extra: matgl
 Requires-Dist: matgl>=1.2.3; extra == "matgl"
+Provides-Extra: orb
+Requires-Dist: orb-models>=0.4.2; extra == "orb"
+Provides-Extra: ace
+Requires-Dist: pyace>=0.1.1; extra == "ace"
 Dynamic: license-file
 
 <h1 align="center">
-  <img src="https://github.com/materialsvirtuallab/matcalc/assets/30958850/89486f2f-73fb-40fb-803a-dfafe510eb6d" width="100" alt="MatCalc logo" style="vertical-align: middle;" /><br>
-  MatCalc
+  <img src="https://raw.githubusercontent.com/materialsvirtuallab/matcalc/refs/heads/main/docs/assets/matcalc.png"
+width="200" alt="MatCalc" style="vertical-align: middle;" /><br>
 </h1>
 
 [![Testing](https://github.com/materialsvirtuallab/matcalc/workflows/Testing/badge.svg)](https://github.com/materialsvirtuallab/matcalc/workflows/Testing/badge.svg)
@@ -87,12 +91,12 @@ MatCalc provides convenient methods to quickly compute properties, using a minim
 an example of a computation of the elastic constants of Si using the `TensorNet-MatPES-PBE-v2025.1-PES` universal MLIP.
 
 ```python
-from matcalc import PESCalculator, ElasticityCalc
+from matcalc import PESCalculator, ElasticityCalc, load_up
 from pymatgen.ext.matproj import MPRester
 
 mpr = MPRester()
 si = mpr.get_structure_by_material_id("mp-149")
-c = ElasticityCalc(PESCalculator.load_universal("TensorNet-MatPES-PBE-v2025.1-PES"), relax_structure=True)
+c = ElasticityCalc(load_up("TensorNet-MatPES-PBE-v2025.1-PES"), relax_structure=True)
 props = c.calc(si)
 print(f"K_VRH = {props['bulk_modulus_vrh'] * 160.2176621} GPa")
 ```
@@ -103,9 +107,9 @@ While we generally recommend users to specify exactly the model they would like
 (case-insensitive) aliases to our recommended models for PBE and r2SCAN predictions. These can be loaded using:
 
 ```python
-from matcalc import PESCalculator
-pbe_calculator = PESCalculator.load_universal("pbe")
-r2scan_calculator = PESCalculator.load_universal("r2scan")
+from matcalc import load_up
+pbe_calculator = load_up("pbe")
+r2scan_calculator = load_up("r2scan")
 ```
 
 At the time of writing, these are the TensorNet-MatPES models. However, these recommendations may updated as improved
@@ -138,9 +142,9 @@ computed by all steps. Note that the `relax_structure` should be set to False in
 do not redo the relatively expensive relaxation.
 
 ```python
-from matcalc import PESCalculator, ElasticityCalc, RelaxCalc, EnergeticsCalc, ChainedCalc
+from matcalc import load_up, ElasticityCalc, RelaxCalc, EnergeticsCalc, ChainedCalc
 import numpy as np
-calculator = PESCalculator.load_universal("pbe")
+calculator = load_up("pbe")
 relax_calc = RelaxCalc(
     calculator,
     optimizer="FIRE",
@@ -182,8 +186,8 @@ the `MatCalc-Benchmark`.
 For example, the following code can be used to run the ElasticityBenchmark on `TensorNet-MatPES-PBE-v2025.1-PES` UMLIP.
 
 ```python
-from matcalc import PESCalculator
-calculator = PESCalculator.load_universal("TensorNet-MatPES-PBE-v2025.1-PES")
+from matcalc import load_up
+calculator = load_up("TensorNet-MatPES-PBE-v2025.1-PES")
 from matcalc.benchmark import ElasticityBenchmark
 benchmark = ElasticityBenchmark(fmax=0.05, relax_structure=True)
 results = benchmark.run(calculator, "TensorNet-MatPES")

{matcalc-0.2.1 → matcalc-0.2.2}/README.md

@@ -1,6 +1,6 @@
 <h1 align="center">
-  <img src="https://github.com/materialsvirtuallab/matcalc/assets/30958850/89486f2f-73fb-40fb-803a-dfafe510eb6d" width="100" alt="MatCalc logo" style="vertical-align: middle;" /><br>
-  MatCalc
+  <img src="https://raw.githubusercontent.com/materialsvirtuallab/matcalc/refs/heads/main/docs/assets/matcalc.png"
+width="200" alt="MatCalc" style="vertical-align: middle;" /><br>
 </h1>
 
 [![Testing](https://github.com/materialsvirtuallab/matcalc/workflows/Testing/badge.svg)](https://github.com/materialsvirtuallab/matcalc/workflows/Testing/badge.svg)
@@ -42,12 +42,12 @@ MatCalc provides convenient methods to quickly compute properties, using a minim
 an example of a computation of the elastic constants of Si using the `TensorNet-MatPES-PBE-v2025.1-PES` universal MLIP.
 
 ```python
-from matcalc import PESCalculator, ElasticityCalc
+from matcalc import PESCalculator, ElasticityCalc, load_up
 from pymatgen.ext.matproj import MPRester
 
 mpr = MPRester()
 si = mpr.get_structure_by_material_id("mp-149")
-c = ElasticityCalc(PESCalculator.load_universal("TensorNet-MatPES-PBE-v2025.1-PES"), relax_structure=True)
+c = ElasticityCalc(load_up("TensorNet-MatPES-PBE-v2025.1-PES"), relax_structure=True)
 props = c.calc(si)
 print(f"K_VRH = {props['bulk_modulus_vrh'] * 160.2176621} GPa")
 ```
@@ -58,9 +58,9 @@ While we generally recommend users to specify exactly the model they would like
 (case-insensitive) aliases to our recommended models for PBE and r2SCAN predictions. These can be loaded using:
 
 ```python
-from matcalc import PESCalculator
-pbe_calculator = PESCalculator.load_universal("pbe")
-r2scan_calculator = PESCalculator.load_universal("r2scan")
+from matcalc import load_up
+pbe_calculator = load_up("pbe")
+r2scan_calculator = load_up("r2scan")
 ```
 
 At the time of writing, these are the TensorNet-MatPES models. However, these recommendations may updated as improved
@@ -93,9 +93,9 @@ computed by all steps. Note that the `relax_structure` should be set to False in
 do not redo the relatively expensive relaxation.
 
 ```python
-from matcalc import PESCalculator, ElasticityCalc, RelaxCalc, EnergeticsCalc, ChainedCalc
+from matcalc import load_up, ElasticityCalc, RelaxCalc, EnergeticsCalc, ChainedCalc
 import numpy as np
-calculator = PESCalculator.load_universal("pbe")
+calculator = load_up("pbe")
 relax_calc = RelaxCalc(
     calculator,
     optimizer="FIRE",
@@ -137,8 +137,8 @@ the `MatCalc-Benchmark`.
 For example, the following code can be used to run the ElasticityBenchmark on `TensorNet-MatPES-PBE-v2025.1-PES` UMLIP.
 
 ```python
-from matcalc import PESCalculator
-calculator = PESCalculator.load_universal("TensorNet-MatPES-PBE-v2025.1-PES")
+from matcalc import load_up
+calculator = load_up("TensorNet-MatPES-PBE-v2025.1-PES")
 from matcalc.benchmark import ElasticityBenchmark
 benchmark = ElasticityBenchmark(fmax=0.05, relax_structure=True)
 results = benchmark.run(calculator, "TensorNet-MatPES")

{matcalc-0.2.1 → matcalc-0.2.2}/pyproject.toml

@@ -42,9 +42,9 @@ dependencies = [
     "pymatgen",
     "numpy<2.0.0",
     "fsspec",
-    "scikit-learn>=1.6.1",
+    "scikit-learn>=1.6.1"
 ]
-version = "0.2.1"
+version = "0.2.2"
 
 [project.optional-dependencies]
 phonon = ["seekpath"]
@@ -67,6 +67,12 @@ grace = [
 matgl = [
     "matgl>=1.2.3",
 ]
+orb = [
+    "orb-models>=0.4.2",
+]
+ace = [
+    "pyace>=0.1.1",
+]
 
 [project.scripts]
 matcalc = "matcalc.cli:main"
@@ -87,6 +93,7 @@ dev = [
     "codecov-cli>=10.3.0",
     "coverage>=7.7.1",
     "coveralls>=4.0.1",
+    "ipython>=8.34.0",
     "jupyter>=1.1.1",
     "maml>=2025.2.25",
     "matgl>=1.2.3",
@@ -103,10 +110,18 @@ lint = [
     "ruff>=0.11.2",
 ]
 maintain = [
+    "docutils>=0.21.2",
     "invoke>=2.2.0",
     "sphinx>=8.1.3",
     "sphinx-markdown-builder>=0.6.8",
 ]
+test-models = [
+    "mace-torch>=0.3.12",
+    "orb-models>=0.4.2",
+    "pynanoflann>=0.10.0",
+    "sevenn>=0.10.4",
+    "tensorpotential>=0.5.1",
+]
 
 [tool.ruff]
 target-version = "py310"

{matcalc-0.2.1 → matcalc-0.2.2}/src/matcalc/__init__.py

@@ -19,3 +19,6 @@ from .qha import QHACalc
 from .relaxation import RelaxCalc
 from .stability import EnergeticsCalc
 from .utils import UNIVERSAL_CALCULATORS, PESCalculator
+
+# Provide an alias for loading calculators quickly.
+load_up = PESCalculator.load_universal

{matcalc-0.2.1 → matcalc-0.2.2}/src/matcalc/cli.py

@@ -23,7 +23,7 @@ def calculate_property(args: Any) -> None:
     :param args:
     :return:
     """
-    calculator = mtc.PESCalculator.load_universal(args.model)
+    calculator = mtc.load_up(args.model)
     mod = mtc.__dict__[args.property](calculator)
     results = []
     for f in args.structure:

{matcalc-0.2.1 → matcalc-0.2.2}/src/matcalc/utils.py

@@ -286,31 +286,26 @@ class PESCalculator(Calculator):
             result = name
 
         elif any(name.lower().startswith(m) for m in ("m3gnet", "chgnet", "tensornet", "pbe", "r2scan")):
-            import matgl
-            from matgl.ext.ase import PESCalculator as PESCalculator_
-
             name = MODEL_ALIASES.get(name.lower(), name)
-            model = matgl.load_model(name)  # type: ignore[arg-type]
-            kwargs.setdefault("stress_unit", "eV/A3")
-            result = PESCalculator_(potential=model, **kwargs)
+            result = PESCalculator.load_matgl(name, **kwargs)
 
         elif name.lower() == "mace":  # pragma: no cover
             from mace.calculators import mace_mp
 
             result = mace_mp(**kwargs)
 
-        elif name.lower() == "sevennet":  # pragma: no cover
+        elif name.lower() == "sevennet":
             from sevenn.calculator import SevenNetCalculator
 
             result = SevenNetCalculator(**kwargs)
 
-        elif name.lower() == "grace" or name.lower() == "tensorpotential":  # pragma: no cover
+        elif name.lower() == "grace" or name.lower() == "tensorpotential":
             from tensorpotential.calculator.foundation_models import grace_fm
 
             kwargs.setdefault("model", "GRACE-2L-OAM")
             result = grace_fm(**kwargs)
 
-        elif name.lower() == "orb":  # pragma: no cover
+        elif name.lower() == "orb":
             from orb_models.forcefield.calculator import ORBCalculator
             from orb_models.forcefield.pretrained import ORB_PRETRAINED_MODELS
 
@@ -344,59 +339,7 @@ def get_universal_calculator(name: str | Calculator, **kwargs: Any) -> Calculato
     Returns:
         Calculator
     """
-    result: Calculator
-
-    if not isinstance(name, str):  # e.g. already an ase Calculator instance
-        result = name
-
-    elif name.lower().startswith("m3gnet") or name.lower().startswith("tensornet"):
-        import matgl
-        from matgl.ext.ase import PESCalculator as PESCalculator_
-
-        # M3GNet is shorthand for latest M3GNet based on DIRECT sampling.
-        # TensorNet is shorthand for latest TensorNet trained on MatPES.
-        name = {"m3gnet": "M3GNet-MP-2021.2.8-DIRECT-PES", "tensornet": "TensorNet-MatPES-PBE-v2025.1-PES"}.get(
-            name.lower(), name
-        )
-        model = matgl.load_model(name)  # type: ignore[arg-type]
-        kwargs.setdefault("stress_unit", "eV/A3")
-        result = PESCalculator_(potential=model, **kwargs)
-
-    elif name.lower() == "chgnet":
-        from chgnet.model.dynamics import CHGNetCalculator
-
-        result = CHGNetCalculator(**kwargs)
-
-    elif name.lower() == "mace":
-        from mace.calculators import mace_mp
-
-        result = mace_mp(**kwargs)
-
-    elif name.lower() == "sevennet":
-        from sevenn.calculator import SevenNetCalculator
-
-        result = SevenNetCalculator(**kwargs)
-
-    elif name.lower() == "grace" or name.lower() == "tensorpotential":
-        from tensorpotential.calculator.foundation_models import grace_fm
-
-        kwargs.setdefault("model", "GRACE-2L-OAM")
-        result = grace_fm(**kwargs)
-
-    elif name.lower() == "orb":
-        from orb_models.forcefield.calculator import ORBCalculator
-        from orb_models.forcefield.pretrained import ORB_PRETRAINED_MODELS
-
-        model = kwargs.pop("model", "orb-v2")
-        device = kwargs.get("device", "cpu")
-
-        orbff = ORB_PRETRAINED_MODELS[model](device=device)
-        result = ORBCalculator(orbff, **kwargs)
-
-    else:
-        raise ValueError(f"Unrecognized {name=}, must be one of {UNIVERSAL_CALCULATORS}")
-
-    return result
+    return PESCalculator.load_universal(name=name, **kwargs)
 
 
 def is_ase_optimizer(key: str | Optimizer) -> bool:

{matcalc-0.2.1 → matcalc-0.2.2/src/matcalc.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matcalc
-Version: 0.2.1
+Version: 0.2.2
 Summary: Calculators for materials properties from the potential energy surface.
 Author-email: Runze Liu <rul048@ucsd.edu>, Eliott Liu <elliottliu17@gmail.com>, Janosh Riebesell <janosh@lbl.gov>, Ji Qi <j1qi@ucsd.edu>, Shyue Ping Ong <ongsp@ucsd.edu>, Tsz Wai Ko <t1ko@ucsd.edu>
 Keywords: AI,deep learning,force field,graph,interatomic potential,machine learning,materials,property prediction,science
@@ -41,11 +41,15 @@ Provides-Extra: grace
 Requires-Dist: tensorpotential>=0.5.1; extra == "grace"
 Provides-Extra: matgl
 Requires-Dist: matgl>=1.2.3; extra == "matgl"
+Provides-Extra: orb
+Requires-Dist: orb-models>=0.4.2; extra == "orb"
+Provides-Extra: ace
+Requires-Dist: pyace>=0.1.1; extra == "ace"
 Dynamic: license-file
 
 <h1 align="center">
-  <img src="https://github.com/materialsvirtuallab/matcalc/assets/30958850/89486f2f-73fb-40fb-803a-dfafe510eb6d" width="100" alt="MatCalc logo" style="vertical-align: middle;" /><br>
-  MatCalc
+  <img src="https://raw.githubusercontent.com/materialsvirtuallab/matcalc/refs/heads/main/docs/assets/matcalc.png"
+width="200" alt="MatCalc" style="vertical-align: middle;" /><br>
 </h1>
 
 [![Testing](https://github.com/materialsvirtuallab/matcalc/workflows/Testing/badge.svg)](https://github.com/materialsvirtuallab/matcalc/workflows/Testing/badge.svg)
@@ -87,12 +91,12 @@ MatCalc provides convenient methods to quickly compute properties, using a minim
 an example of a computation of the elastic constants of Si using the `TensorNet-MatPES-PBE-v2025.1-PES` universal MLIP.
 
 ```python
-from matcalc import PESCalculator, ElasticityCalc
+from matcalc import PESCalculator, ElasticityCalc, load_up
 from pymatgen.ext.matproj import MPRester
 
 mpr = MPRester()
 si = mpr.get_structure_by_material_id("mp-149")
-c = ElasticityCalc(PESCalculator.load_universal("TensorNet-MatPES-PBE-v2025.1-PES"), relax_structure=True)
+c = ElasticityCalc(load_up("TensorNet-MatPES-PBE-v2025.1-PES"), relax_structure=True)
 props = c.calc(si)
 print(f"K_VRH = {props['bulk_modulus_vrh'] * 160.2176621} GPa")
 ```
@@ -103,9 +107,9 @@ While we generally recommend users to specify exactly the model they would like
 (case-insensitive) aliases to our recommended models for PBE and r2SCAN predictions. These can be loaded using:
 
 ```python
-from matcalc import PESCalculator
-pbe_calculator = PESCalculator.load_universal("pbe")
-r2scan_calculator = PESCalculator.load_universal("r2scan")
+from matcalc import load_up
+pbe_calculator = load_up("pbe")
+r2scan_calculator = load_up("r2scan")
 ```
 
 At the time of writing, these are the TensorNet-MatPES models. However, these recommendations may updated as improved
@@ -138,9 +142,9 @@ computed by all steps. Note that the `relax_structure` should be set to False in
 do not redo the relatively expensive relaxation.
 
 ```python
-from matcalc import PESCalculator, ElasticityCalc, RelaxCalc, EnergeticsCalc, ChainedCalc
+from matcalc import load_up, ElasticityCalc, RelaxCalc, EnergeticsCalc, ChainedCalc
 import numpy as np
-calculator = PESCalculator.load_universal("pbe")
+calculator = load_up("pbe")
 relax_calc = RelaxCalc(
     calculator,
     optimizer="FIRE",
@@ -182,8 +186,8 @@ the `MatCalc-Benchmark`.
 For example, the following code can be used to run the ElasticityBenchmark on `TensorNet-MatPES-PBE-v2025.1-PES` UMLIP.
 
 ```python
-from matcalc import PESCalculator
-calculator = PESCalculator.load_universal("TensorNet-MatPES-PBE-v2025.1-PES")
+from matcalc import load_up
+calculator = load_up("TensorNet-MatPES-PBE-v2025.1-PES")
 from matcalc.benchmark import ElasticityBenchmark
 benchmark = ElasticityBenchmark(fmax=0.05, relax_structure=True)
 results = benchmark.run(calculator, "TensorNet-MatPES")

{matcalc-0.2.1 → matcalc-0.2.2}/src/matcalc.egg-info/requires.txt

@@ -6,6 +6,9 @@ numpy<2.0.0
 fsspec
 scikit-learn>=1.6.1
 
+[ace]
+pyace>=0.1.1
+
 [benchmark]
 matminer>=0.9.3
 
@@ -24,6 +27,9 @@ matgl>=1.2.3
 [nequip]
 nequip>=0.6.2
 
+[orb]
+orb-models>=0.4.2
+
 [phonon]
 seekpath
 

matcalc-0.2.2/tests/test_utils.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+from importlib.util import find_spec
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import ase.optimize
+import pytest
+from ase import Atoms
+from ase.calculators.calculator import Calculator
+from ase.optimize.optimize import Optimizer
+
+from matcalc import RelaxCalc
+from matcalc.utils import (
+    MODEL_ALIASES,
+    UNIVERSAL_CALCULATORS,
+    VALID_OPTIMIZERS,
+    PESCalculator,
+    get_ase_optimizer,
+    get_universal_calculator,
+    is_ase_optimizer,
+)
+
+DIR = Path(__file__).parent.absolute()
+
+if TYPE_CHECKING:
+    from pymatgen.core import Structure
+
+
+@pytest.mark.parametrize(
+    ("expected_unit", "expected_weight"),
+    [
+        ("eV/A3", 0.006241509125883258),
+        ("GPa", 1.0),
+    ],
+)
+@pytest.mark.skipif(not find_spec("maml"), reason="maml is not installed")
+def test_pescalculator_load_mtp(expected_unit: str, expected_weight: float) -> None:
+    calc = PESCalculator.load_mtp(
+        filename=DIR / "pes" / "MTP-Cu-2020.1-PES" / "fitted.mtp",
+        elements=["Cu"],
+    )
+    assert isinstance(calc, Calculator)
+    assert PESCalculator(
+        potential=calc.potential,
+        stress_unit=expected_unit,
+    ).stress_weight == pytest.approx(expected_weight)
+    with pytest.raises(ValueError, match="Unsupported stress_unit: Pa. Must be 'GPa' or 'eV/A3'."):
+        PESCalculator(potential=calc.potential, stress_unit="Pa")
+
+
+@pytest.mark.skipif(not find_spec("maml"), reason="maml is not installed")
+def test_pescalculator_load_gap() -> None:
+    calc = PESCalculator.load_gap(filename=DIR / "pes" / "GAP-NiMo-2020.3-PES" / "gap.xml")
+    assert isinstance(calc, Calculator)
+
+
+@pytest.mark.skipif(not find_spec("maml"), reason="maml is not installed")
+def test_pescalculator_load_nnp() -> None:
+    calc = PESCalculator.load_nnp(
+        input_filename=DIR / "pes" / "NNP-Cu-2020.1-PES" / "input.nn",
+        scaling_filename=DIR / "pes" / "NNP-Cu-2020.1-PES" / "scaling.data",
+        weights_filenames=[DIR / "pes" / "NNP-Cu-2020.1-PES" / "weights.029.data"],
+    )
+    assert isinstance(calc, Calculator)
+
+
+@pytest.mark.skipif(not find_spec("maml"), reason="maml is not installed")
+@pytest.mark.skipif(not find_spec("lammps"), reason="lammps is not installed")
+def test_pescalculator_load_snap() -> None:
+    for name in ("SNAP", "qSNAP"):
+        calc = PESCalculator.load_snap(
+            param_file=DIR / "pes" / f"{name}-Cu-2020.1-PES" / "SNAPotential.snapparam",
+            coeff_file=DIR / "pes" / f"{name}-Cu-2020.1-PES" / "SNAPotential.snapcoeff",
+        )
+        assert isinstance(calc, Calculator)
+
+
+@pytest.mark.skipif(not find_spec("pyace"), reason="pyace is not installed")
+def test_pescalculator_load_ace() -> None:
+    calc = PESCalculator.load_ace(basis_set=DIR / "pes" / "ACE-Cu-2021.5.15-PES" / "Cu-III.yaml")
+    assert isinstance(calc, Calculator)
+
+
+@pytest.mark.skipif(not find_spec("nequip"), reason="nequip is not installed")
+def test_pescalculator_load_nequip() -> None:
+    calc = PESCalculator.load_nequip(model_path=DIR / "pes" / "NequIP-am-Al2O3-2023.9-PES" / "default.pth")
+    assert isinstance(calc, Calculator)
+
+
+@pytest.mark.skipif(not find_spec("matgl"), reason="matgl is not installed")
+def test_pescalculator_load_matgl() -> None:
+    calc = PESCalculator.load_matgl(path=DIR / "pes" / "M3GNet-MP-2021.2.8-PES")
+    assert isinstance(calc, Calculator)
+
+
+@pytest.mark.skipif(not find_spec("matgl"), reason="matgl is not installed")
+@pytest.mark.skipif(not find_spec("mace"), reason="mace is not installed")
+@pytest.mark.skipif(not find_spec("sevenn"), reason="sevenn is not installed")
+def test_pescalculator_load_universal(Li2O: Structure) -> None:
+    for name in UNIVERSAL_CALCULATORS:
+        calc = PESCalculator.load_universal(name)
+        assert isinstance(calc, Calculator)
+        same_calc = PESCalculator.load_universal(calc)  # test ASE Calculator classes are returned as-is
+        assert calc is same_calc
+        # We run a basic relaxation calc to make sure that all calculators work.
+        relaxed_calc = RelaxCalc(calc, relax_cell=False, relax_atoms=False)
+        result = relaxed_calc.calc(Li2O)
+        assert isinstance(result, dict)
+
+    name = "whatever"
+    with pytest.raises(ValueError, match=f"Unrecognized {name=}") as exc:
+        get_universal_calculator(name)
+    assert str(exc.value) == f"Unrecognized {name=}, must be one of {UNIVERSAL_CALCULATORS}"
+
+
+@pytest.mark.skipif(not find_spec("lammps"), reason="lammps is not installed")
+def test_pescalculator_calculate() -> None:
+    calc = PESCalculator.load_snap(
+        param_file=DIR / "pes" / "SNAP-Cu-2020.1-PES" / "SNAPotential.snapparam",
+        coeff_file=DIR / "pes" / "SNAP-Cu-2020.1-PES" / "SNAPotential.snapcoeff",
+    )
+
+    atoms = Atoms(
+        "Cu4",
+        scaled_positions=[(0, 0, 0), (0, 0.5, 0.5), (0.5, 0, 0.5), (0.5, 0.5, 0)],
+        cell=[3.57743067] * 3,
+        pbc=True,
+    )
+
+    atoms.set_calculator(calc)
+
+    energy = atoms.get_potential_energy()
+    forces = atoms.get_forces()
+    stresses = atoms.get_stress()
+
+    assert isinstance(energy, float)
+    assert list(forces.shape) == [4, 3]
+    assert list(stresses.shape) == [6]
+
+
+def test_get_ase_optimizer() -> None:
+    for name in dir(ase.optimize):
+        if is_ase_optimizer(name):
+            optimizer = get_ase_optimizer(name)
+            assert issubclass(optimizer, Optimizer)
+            same_optimizer = get_ase_optimizer(optimizer)  # test ASE Optimizer classes are returned as-is
+            assert optimizer is same_optimizer
+
+    for optimizer in ("whatever", 42):
+        with pytest.raises(ValueError, match=f"Unknown {optimizer=}") as exc:
+            get_ase_optimizer(optimizer)
+        assert str(exc.value) == f"Unknown {optimizer=}, must be one of {VALID_OPTIMIZERS}"
+
+
+def test_is_ase_optimizer() -> None:
+    assert is_ase_optimizer(ase.optimize.BFGS)
+    assert is_ase_optimizer(Optimizer)
+    assert not is_ase_optimizer(Calculator)
+
+    for name in ("whatever", 42, -3.14):
+        assert not is_ase_optimizer(name)
+
+
+def test_aliases() -> None:
+    # Ensures that model aliases always point to valid models.
+    for v in MODEL_ALIASES.values():
+        assert v in UNIVERSAL_CALCULATORS

matcalc-0.2.1/tests/test_utils.py

@@ -1,157 +0,0 @@
-from __future__ import annotations
-
-from importlib.util import find_spec
-from pathlib import Path
-
-import ase.optimize
-import pytest
-from ase import Atoms
-from ase.calculators.calculator import Calculator
-from ase.optimize.optimize import Optimizer
-
-from matcalc.utils import (
-    MODEL_ALIASES,
-    UNIVERSAL_CALCULATORS,
-    VALID_OPTIMIZERS,
-    PESCalculator,
-    get_ase_optimizer,
-    get_universal_calculator,
-    is_ase_optimizer,
-)
-
-DIR = Path(__file__).parent.absolute()
-
-
-class TestPESCalculator:
-    @pytest.mark.parametrize(
-        ("expected_unit", "expected_weight"),
-        [
-            ("eV/A3", 0.006241509125883258),
-            ("GPa", 1.0),
-        ],
-    )
-    @pytest.mark.skipif(not find_spec("maml"), reason="maml is not installed")
-    def test_pescalculator_load_mtp(self, expected_unit: str, expected_weight: float) -> None:
-        calc = PESCalculator.load_mtp(
-            filename=DIR / "pes" / "MTP-Cu-2020.1-PES" / "fitted.mtp",
-            elements=["Cu"],
-        )
-        assert isinstance(calc, Calculator)
-        assert PESCalculator(
-            potential=calc.potential,
-            stress_unit=expected_unit,
-        ).stress_weight == pytest.approx(expected_weight)
-        with pytest.raises(ValueError, match="Unsupported stress_unit: Pa. Must be 'GPa' or 'eV/A3'."):
-            PESCalculator(potential=calc.potential, stress_unit="Pa")
-
-    @pytest.mark.skipif(not find_spec("maml"), reason="maml is not installed")
-    def test_pescalculator_load_gap(self) -> None:
-        calc = PESCalculator.load_gap(filename=DIR / "pes" / "GAP-NiMo-2020.3-PES" / "gap.xml")
-        assert isinstance(calc, Calculator)
-
-    @pytest.mark.skipif(not find_spec("maml"), reason="maml is not installed")
-    def test_pescalculator_load_nnp(self) -> None:
-        calc = PESCalculator.load_nnp(
-            input_filename=DIR / "pes" / "NNP-Cu-2020.1-PES" / "input.nn",
-            scaling_filename=DIR / "pes" / "NNP-Cu-2020.1-PES" / "scaling.data",
-            weights_filenames=[DIR / "pes" / "NNP-Cu-2020.1-PES" / "weights.029.data"],
-        )
-        assert isinstance(calc, Calculator)
-
-    @pytest.mark.skipif(not find_spec("maml"), reason="maml is not installed")
-    @pytest.mark.skipif(not find_spec("lammps"), reason="lammps is not installed")
-    def test_pescalculator_load_snap(self) -> None:
-        for name in ("SNAP", "qSNAP"):
-            calc = PESCalculator.load_snap(
-                param_file=DIR / "pes" / f"{name}-Cu-2020.1-PES" / "SNAPotential.snapparam",
-                coeff_file=DIR / "pes" / f"{name}-Cu-2020.1-PES" / "SNAPotential.snapcoeff",
-            )
-            assert isinstance(calc, Calculator)
-
-    @pytest.mark.skipif(not find_spec("pyace"), reason="pyace is not installed")
-    def test_pescalculator_load_ace(self) -> None:
-        calc = PESCalculator.load_ace(basis_set=DIR / "pes" / "ACE-Cu-2021.5.15-PES" / "Cu-III.yaml")
-        assert isinstance(calc, Calculator)
-
-    @pytest.mark.skipif(not find_spec("nequip"), reason="nequip is not installed")
-    def test_pescalculator_load_nequip(self) -> None:
-        calc = PESCalculator.load_nequip(model_path=DIR / "pes" / "NequIP-am-Al2O3-2023.9-PES" / "default.pth")
-        assert isinstance(calc, Calculator)
-
-    @pytest.mark.skipif(not find_spec("matgl"), reason="matgl is not installed")
-    def test_pescalculator_load_matgl(self) -> None:
-        calc = PESCalculator.load_matgl(path=DIR / "pes" / "M3GNet-MP-2021.2.8-PES")
-        assert isinstance(calc, Calculator)
-
-    @pytest.mark.skipif(not find_spec("matgl"), reason="matgl is not installed")
-    @pytest.mark.skipif(not find_spec("chgnet"), reason="chgnet is not installed")
-    @pytest.mark.skipif(not find_spec("mace"), reason="mace is not installed")
-    @pytest.mark.skipif(not find_spec("sevenn"), reason="sevenn is not installed")
-    def test_pescalculator_load_universal(self) -> None:
-        for name in UNIVERSAL_CALCULATORS:
-            calc = PESCalculator.load_universal(name)
-            assert isinstance(calc, Calculator)
-            same_calc = PESCalculator.load_universal(calc)  # test ASE Calculator classes are returned as-is
-            assert calc is same_calc
-
-        name = "whatever"
-        with pytest.raises(ValueError, match=f"Unrecognized {name=}") as exc:
-            get_universal_calculator(name)
-        assert str(exc.value) == f"Unrecognized {name=}, must be one of {UNIVERSAL_CALCULATORS}"
-
-        # cover edge case like https://github.com/materialsvirtuallab/matcalc/issues/14
-        # where non-str and non-ASE Calculator instances are passed in
-        assert get_universal_calculator(42) == 42  # test non-str input is returned as-is
-
-    @pytest.mark.skipif(not find_spec("lammps"), reason="lammps is not installed")
-    def test_pescalculator_calculate(self) -> None:
-        calc = PESCalculator.load_snap(
-            param_file=DIR / "pes" / "SNAP-Cu-2020.1-PES" / "SNAPotential.snapparam",
-            coeff_file=DIR / "pes" / "SNAP-Cu-2020.1-PES" / "SNAPotential.snapcoeff",
-        )
-
-        atoms = Atoms(
-            "Cu4",
-            scaled_positions=[(0, 0, 0), (0, 0.5, 0.5), (0.5, 0, 0.5), (0.5, 0.5, 0)],
-            cell=[3.57743067] * 3,
-            pbc=True,
-        )
-
-        atoms.set_calculator(calc)
-
-        energy = atoms.get_potential_energy()
-        forces = atoms.get_forces()
-        stresses = atoms.get_stress()
-
-        assert isinstance(energy, float)
-        assert list(forces.shape) == [4, 3]
-        assert list(stresses.shape) == [6]
-
-
-def test_get_ase_optimizer() -> None:
-    for name in dir(ase.optimize):
-        if is_ase_optimizer(name):
-            optimizer = get_ase_optimizer(name)
-            assert issubclass(optimizer, Optimizer)
-            same_optimizer = get_ase_optimizer(optimizer)  # test ASE Optimizer classes are returned as-is
-            assert optimizer is same_optimizer
-
-    for optimizer in ("whatever", 42):
-        with pytest.raises(ValueError, match=f"Unknown {optimizer=}") as exc:
-            get_ase_optimizer(optimizer)
-        assert str(exc.value) == f"Unknown {optimizer=}, must be one of {VALID_OPTIMIZERS}"
-
-
-def test_is_ase_optimizer() -> None:
-    assert is_ase_optimizer(ase.optimize.BFGS)
-    assert is_ase_optimizer(Optimizer)
-    assert not is_ase_optimizer(Calculator)
-
-    for name in ("whatever", 42, -3.14):
-        assert not is_ase_optimizer(name)
-
-
-def test_aliases() -> None:
-    # Ensures that model aliases always point to valid models.
-    for v in MODEL_ALIASES.values():
-        assert v in UNIVERSAL_CALCULATORS