matcalc 0.2.0__tar.gz → 0.2.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matcalc
-Version: 0.2.0
+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
+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",
@@ -160,7 +164,8 @@ elast_calc = ElasticityCalc(
     relax_structure=False,  # Since we are chaining, we do not need to relax structure in later steps.
     relax_deformed_structures=True,
 )
-results = elast_calc.calc(energetics_calc.calc(relax_calc.calc(structure)))
+prop_calc = ChainedCalc([relax_calc, energetics_calc, elast_calc])
+results = prop_calc.calc(structure)
 ```
 
 Chaining can also be used with the `calc_many` method, with parallelization.
@@ -181,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.0 → 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
+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",
@@ -115,7 +115,8 @@ elast_calc = ElasticityCalc(
     relax_structure=False,  # Since we are chaining, we do not need to relax structure in later steps.
     relax_deformed_structures=True,
 )
-results = elast_calc.calc(energetics_calc.calc(relax_calc.calc(structure)))
+prop_calc = ChainedCalc([relax_calc, energetics_calc, elast_calc])
+results = prop_calc.calc(structure)
 ```
 
 Chaining can also be used with the `calc_many` method, with parallelization.
@@ -136,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.0 → 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.0"
+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"
@@ -84,8 +90,10 @@ build-backend = "setuptools.build_meta"
 
 [dependency-groups]
 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",
@@ -102,13 +110,21 @@ 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 = "py39"
+target-version = "py310"
 line-length = 120
 extend-include = ["*.ipynb"]
 
@@ -168,6 +184,7 @@ exclude_lines = [
     "except PackageNotFoundError:",
     "if 0:",
     "if TYPE_CHECKING:",
+    "if typing.TYPE_CHECKING:",
     "if __name__ == .__main__.:",
     "if self.debug:",
     "if settings.DEBUG",

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

@@ -9,7 +9,7 @@ try:
 except PackageNotFoundError:
     pass  # package not installed
 
-from .base import PropCalc
+from .base import ChainedCalc, PropCalc
 from .config import clear_cache
 from .elasticity import ElasticityCalc
 from .eos import EOSCalc
@@ -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.0 → matcalc-0.2.2}/src/matcalc/base.py

@@ -78,3 +78,66 @@ class PropCalc(abc.ABC):
         else:
             _func = self.calc  # type: ignore[assignment]
         return parallel(delayed(_func)(s) for s in structures)
+
+
+class ChainedCalc(PropCalc):
+    """A chained calculator that runs a series of PropCalcs on a structure or set of structures.
+
+    Often, you may want to obtain multiple properties at once, e.g., perform a relaxation with a formation energy
+    computation and a elasticity calculation. This can be done using this class by supplying a list of calculators.
+    Note that it is likely
+    """
+
+    def __init__(self, prop_calcs: Sequence[PropCalc]) -> None:
+        """
+        Initialize a chained calculator.
+
+        Args:
+            prop_calcs: Sequence of prop calcs.
+        """
+        self.prop_calcs = tuple(prop_calcs)
+
+    def calc(self, structure: Structure | dict[str, Any]) -> dict[str, Any]:
+        """
+        Runs the series of PropCalcs on a structure.
+
+        Args:
+            structure: Pymatgen structure or a dict containing a pymatgen Structure under a "final_structure" or
+                "structure" key. Allowing dicts provide the means to chain calculators, e.g., do a relaxation followed
+                by an elasticity calculation.
+
+        Returns:
+            dict[str, Any]: In the form {"prop_name": value}.
+        """
+        results = structure  # type:ignore[assignment]
+        for prop_calc in self.prop_calcs:
+            results = prop_calc.calc(results)  # type:ignore[assignment]
+        return results  # type:ignore[return-value]
+
+    def calc_many(
+        self,
+        structures: Sequence[Structure | dict[str, Any]],
+        n_jobs: None | int = None,
+        allow_errors: bool = False,  # noqa: FBT001,FBT002
+        **kwargs: Any,
+    ) -> Generator[dict | None]:
+        """Runs the sequence of PropCalc on many structures.
+
+        Args:
+            structures: List or generator of Structures.
+            n_jobs: The maximum number of concurrently running jobs. If -1 all CPUs are used. For n_jobs below -1,
+                (n_cpus + 1 + n_jobs) are used. None is a marker for `unset` that will be interpreted as n_jobs=1
+                unless the call is performed under a parallel_config() context manager that sets another value for
+                n_jobs.
+            allow_errors: Whether to skip failed calculations. For these calculations, None will be returned. For
+                large scale calculations, you may want this to be True to avoid the entire calculation failing.
+                Defaults to False.
+            **kwargs: Passthrough to calc_many method of all PropCalcs.
+
+        Returns:
+            Generator of dicts.
+        """
+        results = structures  # type:ignore[assignment]
+        for prop_calc in self.prop_calcs:
+            results = prop_calc.calc_many(results, n_jobs=n_jobs, allow_errors=allow_errors, **kwargs)  # type:ignore[assignment]
+        return results  # type:ignore[return-value]

{matcalc-0.2.0 → matcalc-0.2.2}/src/matcalc/benchmark.py

@@ -7,20 +7,24 @@ import json
 import logging
 import os
 import random
-import typing
 from pathlib import Path
+from typing import TYPE_CHECKING, Any
 from urllib.parse import urlparse
 
 import fsspec
 import numpy as np
 import pandas as pd
 import requests
+from matminer.featurizers.site import CrystalNNFingerprint
+from matminer.featurizers.structure import SiteStatsFingerprint
 from monty.json import MontyDecoder
 from monty.serialization import dumpfn, loadfn
 from pymatgen.io.ase import AseAtomsAdaptor
 from scipy.optimize import curve_fit
 
-if typing.TYPE_CHECKING:
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
     from ase.calculators.calculator import Calculator
 
     from .base import PropCalc
@@ -28,7 +32,7 @@ if typing.TYPE_CHECKING:
 from .config import BENCHMARK_DATA_DIR, BENCHMARK_DATA_DOWNLOAD_URL, BENCHMARK_DATA_URL
 from .elasticity import ElasticityCalc
 from .phonon import PhononCalc
-from .relaxation import RelaxCalc
+from .stability import EnergeticsCalc
 from .units import eVA3ToGPa
 
 logger = logging.getLogger(__name__)
@@ -119,7 +123,7 @@ class CheckpointFile:
             return results, *[a[len(results) :] for a in args]
         return [], *args
 
-    def save(self, results: list[dict[str, typing.Any]]) -> None:
+    def save(self, results: list[dict[str, Any]]) -> None:
         """
         Saves a list of results at the specified checkpoint location.
 
@@ -161,7 +165,7 @@ class Benchmark(metaclass=abc.ABCMeta):
     def __init__(
         self,
         benchmark_name: str | Path,
-        properties: typing.Sequence[str],
+        properties: Sequence[str],
         index_name: str,
         other_fields: tuple = (),
         property_rename_map: dict[str, str] | None = None,
@@ -237,7 +241,7 @@ class Benchmark(metaclass=abc.ABCMeta):
         self.ground_truth = rows
 
     @abc.abstractmethod
-    def get_prop_calc(self, calculator: Calculator, **kwargs: typing.Any) -> PropCalc:
+    def get_prop_calc(self, calculator: Calculator, **kwargs: Any) -> PropCalc:
         """
         Abstract method to retrieve a property calculation object using the provided calculator and additional
         parameters.
@@ -336,8 +340,7 @@ class Benchmark(metaclass=abc.ABCMeta):
         # We make sure of the generator from prop_calc.calc_many to do this in a memory efficient manner.
         # allow_errors typically should be true since some of the calculations may fail.
         for row, d in zip(
-            ground_truth,
-            prop_calc.calc_many(structures, n_jobs=n_jobs, allow_errors=True, **kwargs),
+            ground_truth, prop_calc.calc_many(structures, n_jobs=n_jobs, allow_errors=True, **kwargs), strict=True
         ):
             r = dict(row)
             r.update(self.process_result(d, model_name))
@@ -366,15 +369,16 @@ class Benchmark(metaclass=abc.ABCMeta):
         return results_df
 
 
-class RelaxationBenchmark(Benchmark):
+class EquilibriumBenchmark(Benchmark):
     """
-    Represents a benchmark for evaluating and analyzing relaxation properties of materials.
+    Represents a benchmark for evaluating and analyzing equilibrium properties of materials.
     This benchmark utilizes a dataset and provides functionality for property calculation
     and result processing. The class is designed to work with a predefined framework for
-    benchmarking relaxation properties. The benchmark dataset contains data such as relaxed
-    structures along with additional metadata. This class supports configurability through
-    metadata files, index names, and additional benchmark properties. It relies on external
-    calculators and utility classes for property computations and result handling.
+    benchmarking equilibrium properties. The benchmark dataset contains data such as relaxed
+    structures, un-/corrected formation energy along with additional metadata. This class
+    supports configurability through metadata files, index names, and additional benchmark
+    properties. It relies on external calculators and utility classes for property computations
+    and result handling.
     """
 
     def __init__(
@@ -385,9 +389,9 @@ class RelaxationBenchmark(Benchmark):
         **kwargs,  # noqa:ANN003
     ) -> None:
         """
-        Initializes the RelaxationBenchmark instance with specified benchmark metadata and
+        Initializes the EquilibriumBenchmark instance with specified benchmark metadata and
         configuration parameters. It sets up the benchmark with the necessary properties
-        required for relaxation analysis.
+        required for equilibrium benchmark analysis.
 
         :param index_name: The name of the index used to uniquely identify records in the dataset.
         :type index_name: str
@@ -399,36 +403,38 @@ class RelaxationBenchmark(Benchmark):
         :type kwargs: dict
         """
         self.folder_name = folder_name
-        # Define the expected property from the relaxation calculator.
-        kwargs.setdefault("properties", ("structure",))
-        # Other fields such as the material formula may be included.
+        kwargs.setdefault("properties", ("structure", "formation_energy_per_atom"))
+        kwargs.setdefault("property_rename_map", {"formation_energy_per_atom": "Eform"})
         kwargs.setdefault("other_fields", ("formula",))
         super().__init__(benchmark_name, index_name=index_name, **kwargs)
 
-    def get_prop_calc(self, calculator: Calculator, **kwargs: typing.Any) -> PropCalc:
+    def get_prop_calc(self, calculator: Calculator, **kwargs: Any) -> PropCalc:
         """
-        Returns a property calculation object for performing relaxation calculations.
-        This method initializes the relaxation calculator using the provided Calculator
-        object and any additional configuration parameters.
+        Returns a property calculation object for performing relaxation and formation energy
+        calculations. This method initializes the stability calculator using the provided
+        Calculator object and any additional configuration parameters.
 
-        :param calculator: A Calculator object responsible for performing the relaxation calculation.
+        :param calculator: A Calculator object responsible for performing the relaxation and
+            formation energy calculation.
         :type calculator: Calculator
         :param kwargs: Additional keyword arguments used for configuration.
         :type kwargs: dict
-        :return: An initialized PropCalc object configured for relaxation calculations.
+        :return: An initialized PropCalc object configured for relaxation and formation energy
+            calculations.
         :rtype: PropCalc
         """
-        return RelaxCalc(calculator, **kwargs)
+        return EnergeticsCalc(calculator, relax_calc_kwargs={"perturb_distance": 0.1}, **kwargs)
 
     def process_result(self, result: dict | None, model_name: str) -> dict:
         """
-        Processes the result dictionary containing final relaxed structures, formats the keys
-        according to the provided model name. If the result is None, default values of
-        NaN are returned for final structures.
+        Processes the result dictionary containing final structures and formation energy per atom,
+        formats the keys according to the provided model name. If the result is None, default values
+        of NaN are returned for final structures or formation energy per atom.
 
         :param result:
-            A dictionary containing the final relaxed structures under the keys
-            'final_structure'. It can also be None to indicate missing elemental_refs.
+            A dictionary containing the final structures and formation energy per atom under the keys
+            'final_structure' and 'formation energy per atom'. It can also be None to indicate missing
+            elemental_refs.
         :type result: dict or None
 
         :param model_name:
@@ -437,15 +443,97 @@ class RelaxationBenchmark(Benchmark):
         :type model_name: str
 
         :return:
-            A dictionary containing the specific final relaxed structure prefixed by the model name.
-            The values will be NaN if the input result is None.
+            A dictionary containing the specific final structure and formation energy per atomprefixed
+            by the model name. The values will be NaN if the input result is None.
 
         :rtype: dict
         """
         return {
             f"structure_{model_name}": (result["final_structure"] if result is not None else float("nan")),
+            f"formation_energy_per_atom_{model_name}": (
+                result["formation_energy_per_atom"] if result is not None else float("nan")
+            ),
         }
 
+    def run(
+        self,
+        calculator: Calculator,
+        model_name: str,
+        *,
+        n_jobs: None | int = -1,
+        checkpoint_file: str | Path | None = None,
+        checkpoint_freq: int = 1000,
+        delete_checkpoint_on_finish: bool = True,
+        include_full_results: bool = False,
+        **kwargs,  # noqa:ANN003
+    ) -> pd.DataFrame:
+        """
+        Processes a collection of structures using a calculator, saves intermittent checkpoints,
+        and returns the results in a DataFrame. In addition to the base processing performed
+        by the parent class, this method computes the Euclidean distance between the relaxed
+        structure (obtained from the property calculation) and the reference DFT structure,
+        using SiteStatsFingerprint. The computed distance is added as a new column in the
+        results DataFrame with the key "distance_{model_name}".
+
+        This function supports parallel computation and allows for error tolerance during processing.
+        It retrieves a property calculator and utilizes it to calculate desired results for the given
+        set of structures. Checkpoints are saved periodically based on the specified frequency,
+        ensuring that progress is not lost in case of interruptions.
+
+        :param calculator: ASE-compatible calculator instance used to provide PES information for PropCalc.
+        :type calculator: Calculator
+        :param model_name: Name of the model used for properties' calculation.
+            This name is updated in the results DataFrame.
+        :type model_name: str
+        :param n_jobs: Number of parallel jobs to be used in the computation. Use -1
+            to allocate all cores available on the system. Defaults to -1.
+        :type n_jobs: int | None
+        :param checkpoint_file: File path where checkpoint elemental_refs is saved periodically.
+            If None, no checkpoints are saved.
+        :type checkpoint_file: str | Path | None
+        :param checkpoint_freq: Frequency after which checkpoint elemental_refs is saved.
+            Corresponds to the number of structures processed.
+        :type checkpoint_freq: int
+        :param delete_checkpoint_on_finish: Whether to delete checkpoint files when the benchmark finishes. Defaults to
+            True.
+        :type delete_checkpoint_on_finish: bool
+        :param include_full_results: Whether to save full results from PropCalc.calc for analysis afterwards. For
+            instance, the ElasticityProp does not just compute the bulk and shear moduli, but also the full elastic
+            tensors, which can be used for other kinds of analysis. Defaults to False.
+        :type include_full_results: bool
+        :param kwargs: Additional keyword arguments passed to the property calculator,
+            for instance, to customize its behavior or computation options.
+        :type kwargs: dict
+        :return: A pandas DataFrame containing the processed results for the given
+            input structures. The DataFrame includes updated results and relevant
+            metrics.
+        :rtype: pd.DataFrame
+        """
+        results_df = super().run(
+            calculator,
+            model_name,
+            n_jobs=n_jobs,
+            checkpoint_file=checkpoint_file,
+            checkpoint_freq=checkpoint_freq,
+            delete_checkpoint_on_finish=delete_checkpoint_on_finish,
+            include_full_results=include_full_results,
+            **kwargs,
+        )
+
+        ssf = SiteStatsFingerprint(
+            CrystalNNFingerprint.from_preset("ops", distance_cutoffs=None, x_diff_weight=0),
+            stats=("mean", "std_dev", "minimum", "maximum"),
+        )
+
+        results_df[f"d_{model_name}"] = [
+            np.linalg.norm(np.array(ssf.featurize(model)) - np.array(ssf.featurize(dft)))
+            if model is not None and dft is not None
+            else np.nan
+            for model, dft in zip(results_df[f"structure_{model_name}"], results_df["structure_DFT"], strict=True)
+        ]
+
+        return results_df
+
 
 class ElasticityBenchmark(Benchmark):
     """
@@ -490,7 +578,7 @@ class ElasticityBenchmark(Benchmark):
             **kwargs,
         )
 
-    def get_prop_calc(self, calculator: Calculator, **kwargs: typing.Any) -> PropCalc:
+    def get_prop_calc(self, calculator: Calculator, **kwargs: Any) -> PropCalc:
         """
         Calculates and returns a property calculation object based on the provided
         calculator and optional parameters. This is useful for initializing and
@@ -581,7 +669,7 @@ class PhononBenchmark(Benchmark):
             **kwargs,
         )
 
-    def get_prop_calc(self, calculator: Calculator, **kwargs: typing.Any) -> PropCalc:
+    def get_prop_calc(self, calculator: Calculator, **kwargs: Any) -> PropCalc:
         """
         Retrieves a phonon calculation instance based on the given calculator and
         additional keyword arguments.
@@ -598,7 +686,7 @@ class PhononBenchmark(Benchmark):
             optional parameters.
         :rtype: PropCalc
         """
-        return PhononCalc(calculator, **kwargs)
+        return PhononCalc(calculator, write_phonon=False, **kwargs)
 
     def process_result(self, result: dict | None, model_name: str) -> dict:
         """

{matcalc-0.2.0 → 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.0 → matcalc-0.2.2}/src/matcalc/config.py

@@ -11,7 +11,7 @@ BENCHMARK_DATA_DIR = pathlib.Path.home() / ".cache" / "matcalc"
 
 
 def clear_cache(*, confirm: bool = True) -> None:
-    """Deletes all files in the matgl.cache. This is used to clean out downloaded models.
+    """Deletes all files in the mattcalc cache. This is used to clean out downloaded benchmarks.
 
     Args:
         confirm: Whether to ask for confirmation. Default is True.

{matcalc-0.2.0 → matcalc-0.2.2}/src/matcalc/elasticity.py

@@ -30,6 +30,7 @@ class ElasticityCalc(PropCalc):
         norm_strains: Sequence[float] | float = (-0.01, -0.005, 0.005, 0.01),
         shear_strains: Sequence[float] | float = (-0.06, -0.03, 0.03, 0.06),
         fmax: float = 0.1,
+        symmetry: bool = False,
         relax_structure: bool = True,
         relax_deformed_structures: bool = False,
         use_equilibrium: bool = True,
@@ -43,10 +44,11 @@ class ElasticityCalc(PropCalc):
             shear_strains: single or multiple strain values to apply to each shear mode.
                 Defaults to (-0.06, -0.03, 0.03, 0.06).
             fmax: maximum force in the relaxed structure (if relax_structure). Defaults to 0.1.
+            symmetry: whether or not to use symmetry reduction. Defaults to False.
             relax_structure: whether to relax the provided structure with the given calculator.
                 Defaults to True.
             relax_deformed_structures: whether to relax the atomic positions of the deformed/strained structures
-                with the given calculator. Defaults to True.
+                with the given calculator. Defaults to False.
             use_equilibrium: whether to use the equilibrium stress and strain. Ignored and set
                 to True if either norm_strains or shear_strains has length 1 or is a float.
                 Defaults to True.
@@ -65,6 +67,7 @@ class ElasticityCalc(PropCalc):
         self.relax_structure = relax_structure
         self.relax_deformed_structures = relax_deformed_structures
         self.fmax = fmax
+        self.symmetry = symmetry
         if len(self.norm_strains) > 1 and len(self.shear_strains) > 1:
             self.use_equilibrium = use_equilibrium
         else:
@@ -93,14 +96,17 @@ class ElasticityCalc(PropCalc):
 
         if self.relax_structure or self.relax_deformed_structures:
             relax_calc = RelaxCalc(self.calculator, fmax=self.fmax, **(self.relax_calc_kwargs or {}))
-            result |= relax_calc.calc(structure_in)
-            structure_in = result["final_structure"]
-            relax_calc.relax_cell = False
+            if self.relax_structure:
+                result |= relax_calc.calc(structure_in)
+                structure_in = result["final_structure"]
+            if self.relax_deformed_structures:
+                relax_calc.relax_cell = False
 
         deformed_structure_set = DeformedStructureSet(
             structure_in,
             self.norm_strains,
             self.shear_strains,
+            self.symmetry,
         )
         stresses = []
         for deformed_structure in deformed_structure_set: