matcalc 0.3.2__tar.gz → 0.3.3__tar.gz

{matcalc-0.3.2/src/matcalc.egg-info → matcalc-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matcalc
-Version: 0.3.2
+Version: 0.3.3
 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
@@ -39,7 +39,7 @@ Requires-Dist: deepmd-kit>=3.0.2; extra == "deepmd"
 Provides-Extra: grace
 Requires-Dist: tensorpotential>=0.5.1; extra == "grace"
 Provides-Extra: maml
-Requires-Dist: maml>=2025.2.25; extra == "maml"
+Requires-Dist: maml>=2025.4.3; extra == "maml"
 Provides-Extra: orb
 Requires-Dist: orb-models>=0.4.2; extra == "orb"
 Requires-Dist: pynanoflann>=0.10.0; extra == "orb"
@@ -96,12 +96,12 @@ from pymatgen.ext.matproj import MPRester
 
 mpr = MPRester()
 si = mpr.get_structure_by_material_id("mp-149")
-c = mtc.ElasticityCalc(mtc.load_up("TensorNet-MatPES-PBE-v2025.1-PES"), relax_structure=True)
+c = mtc.ElasticityCalc("TensorNet-MatPES-PBE-v2025.1-PES", relax_structure=True)
 props = c.calc(si)
 print(f"K_VRH = {props['bulk_modulus_vrh'] * 160.2176621} GPa")
 ```
 
-The output is `K_VRH = 102.08363100102596 GPa`.
+The calculated `K_VRH` is about 102 GPa, in reasonably good agreement with the experimental and DFT values.
 
 While we generally recommend users to specify exactly the model they would like to use, MatCalc provides useful
 (case-insensitive) aliases to our recommended models for PBE and r2SCAN predictions. These can be loaded using:
@@ -213,6 +213,10 @@ results.to_csv("benchmark_results.csv")
 These will usually take a long time to run. Running on HPC resources is recommended. Please set `n_samples` when
 initializing the benchmark to limit the number of calculations to do some testing before running the full benchmark.
 
+## Docker Images
+
+Docker images with MatCalc and LAMMPS support are available at the [Materials Virtual Lab Docker Repository].
+
 ## Citing
 
 A manuscript on `matcalc` is currently in the works. In the meantime, please see [`citation.cff`](citation.cff) or the GitHub
@@ -223,3 +227,4 @@ sidebar for a BibTeX and APA citation.
 [MatPES]: https://matpes.ai
 [MatCalc]: https://matcalc.ai
 [ASE]: https://wiki.fysik.dtu.dk/ase/
+[Materials Virtual Lab Docker Repository]: https://hub.docker.com/orgs/materialsvirtuallab/repositories

{matcalc-0.3.2 → matcalc-0.3.3}/README.md

@@ -47,12 +47,12 @@ from pymatgen.ext.matproj import MPRester
 
 mpr = MPRester()
 si = mpr.get_structure_by_material_id("mp-149")
-c = mtc.ElasticityCalc(mtc.load_up("TensorNet-MatPES-PBE-v2025.1-PES"), relax_structure=True)
+c = mtc.ElasticityCalc("TensorNet-MatPES-PBE-v2025.1-PES", relax_structure=True)
 props = c.calc(si)
 print(f"K_VRH = {props['bulk_modulus_vrh'] * 160.2176621} GPa")
 ```
 
-The output is `K_VRH = 102.08363100102596 GPa`.
+The calculated `K_VRH` is about 102 GPa, in reasonably good agreement with the experimental and DFT values.
 
 While we generally recommend users to specify exactly the model they would like to use, MatCalc provides useful
 (case-insensitive) aliases to our recommended models for PBE and r2SCAN predictions. These can be loaded using:
@@ -164,6 +164,10 @@ results.to_csv("benchmark_results.csv")
 These will usually take a long time to run. Running on HPC resources is recommended. Please set `n_samples` when
 initializing the benchmark to limit the number of calculations to do some testing before running the full benchmark.
 
+## Docker Images
+
+Docker images with MatCalc and LAMMPS support are available at the [Materials Virtual Lab Docker Repository].
+
 ## Citing
 
 A manuscript on `matcalc` is currently in the works. In the meantime, please see [`citation.cff`](citation.cff) or the GitHub
@@ -174,3 +178,4 @@ sidebar for a BibTeX and APA citation.
 [MatPES]: https://matpes.ai
 [MatCalc]: https://matcalc.ai
 [ASE]: https://wiki.fysik.dtu.dk/ase/
+[Materials Virtual Lab Docker Repository]: https://hub.docker.com/orgs/materialsvirtuallab/repositories

{matcalc-0.3.2 → matcalc-0.3.3}/pyproject.toml

@@ -45,7 +45,7 @@ dependencies = [
     "phonopy>=2.38.0",
     "phono3py>=3.15.0",
 ]
-version = "0.3.2"
+version = "0.3.3"
 
 [project.optional-dependencies]
 phonon = ["seekpath"]
@@ -63,7 +63,7 @@ grace = [
     "tensorpotential>=0.5.1",
 ]
 maml = [
-    "maml>=2025.2.25",
+    "maml>=2025.4.3",
 ]
 orb = [
     "orb-models>=0.4.2",
@@ -94,10 +94,11 @@ dev = [
     "coveralls>=4.0.1",
     "ipython>=8.34.0",
     "jupyter>=1.1.1",
-    "maml>=2025.2.25",
+    "maml>=2025.4.3",
     "matgl>=1.2.3",
     "matminer>=0.9.3",
     "mp-api>=0.45.3",
+    "nbmake>=1.5.5",
     "pre-commit>=4.2.0",
     "pytest>=8.3.5",
     "pytest-cov>=6.0.0",
@@ -113,6 +114,7 @@ maintain = [
     "invoke>=2.2.0",
     "sphinx>=8.1.3",
     "sphinx-markdown-builder>=0.6.8",
+    "sphinx-rtd-theme>=3.0.2",
 ]
 test-models = [
     "mace-torch>=0.3.12",

{matcalc-0.3.2 → matcalc-0.3.3}/src/matcalc/__init__.py

@@ -18,6 +18,7 @@ from ._phonon3 import Phonon3Calc
 from ._qha import QHACalc
 from ._relaxation import RelaxCalc
 from ._stability import EnergeticsCalc
+from ._surface import SurfaceCalc
 from .config import clear_cache
 from .utils import UNIVERSAL_CALCULATORS, PESCalculator
 

{matcalc-0.3.2 → matcalc-0.3.3}/src/matcalc/_base.py

@@ -7,9 +7,12 @@ from typing import TYPE_CHECKING, Any
 
 from joblib import Parallel, delayed
 
+from .utils import PESCalculator
+
 if TYPE_CHECKING:
     from collections.abc import Generator, Sequence
 
+    from ase.calculators.calculator import Calculator
     from pymatgen.core import Structure
 
 
@@ -25,6 +28,33 @@ class PropCalc(abc.ABC):
     on multiple structures using joblib.
     """
 
+    @property
+    def calculator(self) -> Calculator:
+        """
+        This method returns the Calculator object associated with the current instance.
+
+        Parameters:
+            None
+
+        Returns:
+            Calculator: The Calculator object associated with the current instance.
+        """
+        return self._pes_calculator
+
+    @calculator.setter
+    def calculator(self, val: str | Calculator) -> None:
+        """
+        Set the calculator for PES calculation.
+
+        Parameters:
+            val (str | Calculator): A string path to load a PESCalculator or a PESCalculator object.
+
+        Return:
+            None
+
+        """
+        self._pes_calculator = PESCalculator.load_universal(val) if isinstance(val, str) else val
+
     @abc.abstractmethod
     def calc(self, structure: Structure | dict[str, Any]) -> dict[str, Any]:
         """
@@ -93,16 +123,15 @@ class PropCalc(abc.ABC):
             the `allow_errors` flag).
         """
         parallel = Parallel(n_jobs=n_jobs, return_as="generator", **kwargs)
-        if allow_errors:
 
-            def _func(s: Structure) -> dict | None:
-                try:
-                    return self.calc(s)
-                except Exception:  # noqa: BLE001
+        def _func(s: Structure) -> dict | None:
+            try:
+                return self.calc(s)
+            except Exception as ex:
+                if allow_errors:
                     return None
+                raise ex  # noqa:TRY201
 
-        else:
-            _func = self.calc  # type: ignore[assignment]
         return parallel(delayed(_func)(s) for s in structures)
 
 

{matcalc-0.3.2 → matcalc-0.3.3}/src/matcalc/_elasticity.py

@@ -49,7 +49,7 @@ class ElasticityCalc(PropCalc):
 
     def __init__(
         self,
-        calculator: Calculator,
+        calculator: Calculator | str,
         *,
         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),
@@ -65,7 +65,9 @@ class ElasticityCalc(PropCalc):
         and control relaxation behavior for structures. Validates input parameters to ensure
         appropriate constraints are maintained.
 
-        :param calculator: Calculator object used for performing calculations.
+        :param calculator: An ASE calculator object used to perform energy and force
+            calculations. If string is provided, the corresponding universal calculator is loaded.
+        :type calculator: Calculator | str
         :param norm_strains: Sequence of normalized strain values applied during deformation.
             Can also be a single float. Must not be empty or contain zero.
         :param shear_strains: Sequence of shear strain values applied during deformation.
@@ -81,7 +83,7 @@ class ElasticityCalc(PropCalc):
         :param relax_calc_kwargs: Optional dictionary containing keyword arguments for structure
             relaxation calculations.
         """
-        self.calculator = calculator
+        self.calculator = calculator  # type: ignore[assignment]
         self.norm_strains = tuple(np.array([1]) * np.asarray(norm_strains))
         self.shear_strains = tuple(np.array([1]) * np.asarray(shear_strains))
         if len(self.norm_strains) == 0:

{matcalc-0.3.2 → matcalc-0.3.3}/src/matcalc/_eos.py

@@ -49,7 +49,7 @@ class EOSCalc(PropCalc):
 
     def __init__(
         self,
-        calculator: Calculator,
+        calculator: Calculator | str,
         *,
         optimizer: Optimizer | str = "FIRE",
         max_steps: int = 500,
@@ -65,10 +65,9 @@ class EOSCalc(PropCalc):
         simulation parameters, structural relaxation options, and optimizations
         with specified constraints and tolerances.
 
-        :param calculator: The calculator object that handles the computation of
-            forces, energies, and other related properties for the system being
-            studied.
-        :type calculator: Calculator
+        :param calculator: An ASE calculator object used to perform energy and force
+            calculations. If string is provided, the corresponding universal calculator is loaded.
+        :type calculator: Calculator | str
         :param optimizer: The optimization algorithm used for structural relaxations
             or energy minimizations. Can be an optimizer object or the string name
             of the algorithm. Default is "FIRE".
@@ -92,7 +91,7 @@ class EOSCalc(PropCalc):
             relaxation calculation process. Default is None.
         :type relax_calc_kwargs: dict | None, optional
         """
-        self.calculator = calculator
+        self.calculator = calculator  # type: ignore[assignment]
         self.optimizer = optimizer
         self.relax_structure = relax_structure
         self.n_points = n_points

matcalc-0.3.3/src/matcalc/_neb.py

@@ -0,0 +1,142 @@
+"""NEB calculations."""
+
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING, Any
+
+from ase.io import Trajectory
+from ase.mep import NEBTools
+from ase.neb import NEB
+from ase.utils.forcecurve import fit_images
+from pymatgen.core import Structure
+from pymatgen.io.ase import AseAtomsAdaptor
+
+from ._base import PropCalc
+from .utils import get_ase_optimizer
+
+if TYPE_CHECKING:
+    from ase import Atoms
+    from ase.calculators.calculator import Calculator
+    from ase.optimize.optimize import Optimizer
+
+
+class NEBCalc(PropCalc):
+    """NEB calculator."""
+
+    def __init__(
+        self,
+        calculator: Calculator | str,
+        *,
+        optimizer: str | Optimizer = "BFGS",
+        traj_folder: str | None = None,
+        interval: int = 1,
+        climb: bool = True,
+        fmax: float = 0.1,
+        max_steps: int = 1000,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the instance of the class.
+
+        Parameters:
+            calculator (Calculator | str): An ASE calculator object used to perform energy and force
+                calculations. If string is provided, the corresponding universal calculator is loaded.
+            optimizer (str | Optimizer, optional): The optimization algorithm to use. Defaults to "BFGS".
+            traj_folder (str | None, optional): The folder to save trajectory information. Defaults to None.
+            interval (int, optional): The interval for recording trajectory information. Defaults to 1.
+            climb (bool, optional): Whether to perform climbing image nudged elastic band (CI-NEB). Defaults to True.
+            fmax (float, optional): The maximum force tolerance for convergence. Defaults to 0.1.
+            max_steps (int, optional): The maximum number of optimization steps. Defaults to 1000.
+            **kwargs (Any): Additional keyword arguments.
+
+        Returns:
+            None
+        """
+        self.calculator = calculator  # type: ignore[assignment]
+
+        self.traj_folder = traj_folder
+        self.interval = interval
+        self.climb = climb
+        self.optimizer = get_ase_optimizer(optimizer)
+        self.fmax = fmax
+        self.max_steps = max_steps
+        self.kwargs = kwargs
+
+    def calc_images(
+        self,
+        start_struct: Structure,
+        end_struct: Structure,
+        *,
+        n_images: int = 7,
+        interpolate_lattices: bool = False,
+        autosort_tol: float = 0.5,
+    ) -> dict[str, Any]:
+        """Calculate NEB images between given start and end structures.
+
+        Parameters:
+            start_struct (Structure): Initial structure.
+            end_struct (Structure): Final structure.
+            n_images (int): Number of images to calculate (default is 7).
+            interpolate_lattices (bool): Whether to interpolate lattices between start and end structures (default is
+                False).
+            autosort_tol (float): Tolerance for autosorting the images (default is 0.5).
+
+        Returns:
+            NEBCalc: NEB calculation object containing the interpolated images.
+        """
+        images = start_struct.interpolate(
+            end_struct,
+            nimages=n_images + 1,
+            interpolate_lattices=interpolate_lattices,
+            pbc=False,
+            autosort_tol=autosort_tol,
+        )
+        return self.calc({f"image{i:02d}": s for i, s in enumerate(images)})
+
+    def calc(
+        self,
+        structure: Structure | dict[str, Any],
+    ) -> dict[str, Any]:
+        """Calculate the energy barrier using the nudged elastic band method.
+
+        Parameters:
+            - structure: A dictionary containing the images with keys 'image0', 'image1', etc. Must be of type dict.
+
+        Returns:
+                dict:
+                    - "barrier" (float): The energy barrier of the reaction pathway.
+                    - "force" (float): The force exerted on the atoms during the NEB calculation.
+                    - "mep" (dict): a dictionary containing the images and their respective energies.
+        """
+        if not isinstance(structure, dict):
+            raise ValueError(  # noqa:TRY004
+                "For NEB calculations, structure must be a dict containing the images with keys image00, image01, etc."
+            )
+        images: list[Atoms] = []
+        for _, image in sorted(structure.items(), key=lambda x: x[0]):
+            atoms = image.to_ase_atoms() if isinstance(image, Structure) else image
+            atoms.calc = self.calculator
+            images.append(atoms)
+
+        self.neb = NEB(images, climb=self.climb, allow_shared_calculator=True, **self.kwargs)
+        optimizer = self.optimizer(self.neb)  # type:ignore[operator]
+        if self.traj_folder is not None:
+            os.makedirs(self.traj_folder, exist_ok=True)
+            for idx, img in enumerate(images):
+                optimizer.attach(
+                    Trajectory(f"{self.traj_folder}/image-{idx}.traj", "w", img),
+                    interval=self.interval,
+                )
+
+        optimizer.run(fmax=self.fmax, steps=self.max_steps)
+        neb_tool = NEBTools(self.neb.images)
+        data = neb_tool.get_barrier()  # add structures
+        result = {"barrier": data[0], "force": data[1]}
+
+        energies = fit_images(self.neb.images).energies
+        mep = {
+            f"image{i:02d}": {"structure": AseAtomsAdaptor.get_structure(image), "energy": energy}
+            for i, (image, energy) in enumerate(zip(self.neb.images, energies, strict=False))
+        }
+        result["mep"] = mep
+        return result

matcalc-0.3.3/src/matcalc/_phonon.py

@@ -0,0 +1,222 @@
+"""Calculator for phonon properties."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import phonopy
+from phonopy.file_IO import write_FORCE_CONSTANTS as write_force_constants
+from pymatgen.io.ase import AseAtomsAdaptor
+from pymatgen.io.phonopy import get_phonopy_structure, get_pmg_structure
+
+from ._base import PropCalc
+from ._relaxation import RelaxCalc
+
+if TYPE_CHECKING:
+    from pathlib import Path
+    from typing import Any
+
+    from ase.calculators.calculator import Calculator
+    from numpy.typing import ArrayLike
+    from phonopy.structure.atoms import PhonopyAtoms
+    from pymatgen.core import Structure
+
+
+class PhononCalc(PropCalc):
+    """
+    A class for phonon and thermal property calculations using phonopy.
+
+    The `PhononCalc` class extends the `PropCalc` class to provide
+    functionalities for calculating phonon properties and thermal properties
+    of a given structure using the phonopy library. It includes options for
+    structural relaxation before phonon property determination, as well as
+    methods to export calculated properties to various output files for
+    further analysis or visualization.
+
+    :ivar calculator: A calculator object or a string specifying the
+        computational backend to be used.
+    :type calculator: Calculator | str
+    :ivar atom_disp: Magnitude of atomic displacements for phonon
+        calculations.
+    :type atom_disp: float
+    :ivar supercell_matrix: Array defining the transformation matrix to
+        construct supercells for phonon calculations.
+    :type supercell_matrix: ArrayLike
+    :ivar t_step: Temperature step for thermal property calculations in
+        Kelvin.
+    :type t_step: float
+    :ivar t_max: Maximum temperature for thermal property calculations in
+        Kelvin.
+    :type t_max: float
+    :ivar t_min: Minimum temperature for thermal property calculations in
+        Kelvin.
+    :type t_min: float
+    :ivar fmax: Maximum force convergence criterion for structural relaxation.
+    :type fmax: float
+    :ivar optimizer: String specifying the optimizer type to be used for
+        structural relaxation.
+    :type optimizer: str
+    :ivar relax_structure: Boolean flag to determine whether to relax the
+        structure before phonon calculation.
+    :type relax_structure: bool
+    :ivar relax_calc_kwargs: Optional dictionary containing additional
+        arguments for the structural relaxation calculation.
+    :type relax_calc_kwargs: dict | None
+    :ivar write_force_constants: Path, boolean, or string specifying whether
+        to write the calculated force constants to an output file, and the
+        path or name of the file if applicable.
+    :type write_force_constants: bool | str | Path
+    :ivar write_band_structure: Path, boolean, or string specifying whether
+        to write the calculated phonon band structure to an output file,
+        and the path or name of the file if applicable.
+    :type write_band_structure: bool | str | Path
+    :ivar write_total_dos: Path, boolean, or string specifying whether to
+        write the calculated total density of states (DOS) to an output
+        file, and the path or name of the file if applicable.
+    :type write_total_dos: bool | str | Path
+    :ivar write_phonon: Path, boolean, or string specifying whether to write
+        the calculated phonon properties (e.g., phonon.yaml) to an output
+        file, and the path or name of the file if applicable.
+    :type write_phonon: bool | str | Path
+    """
+
+    def __init__(
+        self,
+        calculator: Calculator | str,
+        *,
+        atom_disp: float = 0.015,
+        supercell_matrix: ArrayLike = ((2, 0, 0), (0, 2, 0), (0, 0, 2)),
+        t_step: float = 10,
+        t_max: float = 1000,
+        t_min: float = 0,
+        fmax: float = 0.1,
+        optimizer: str = "FIRE",
+        relax_structure: bool = True,
+        relax_calc_kwargs: dict | None = None,
+        write_force_constants: bool | str | Path = False,
+        write_band_structure: bool | str | Path = False,
+        write_total_dos: bool | str | Path = False,
+        write_phonon: bool | str | Path = True,
+    ) -> None:
+        """
+        Initializes the class with configuration for the phonon calculations. The initialization parameters control
+        the behavior of structural relaxation, thermal properties, force calculations, and output file generation.
+        The class allows for customization of key parameters to facilitate the study of material behaviors.
+
+        :param calculator: The calculator object or string name specifying the calculation backend to use.
+        :param atom_disp: Atom displacement to be used for finite difference calculation of force constants.
+        :param supercell_matrix: Transformation matrix to define the supercell for the calculation.
+        :param t_step: Temperature step for thermal property calculations.
+        :param t_max: Maximum temperature for thermal property calculations.
+        :param t_min: Minimum temperature for thermal property calculations.
+        :param fmax: Maximum force during structure relaxation, used as a convergence criterion.
+        :param optimizer: Name of the optimization algorithm for structural relaxation.
+        :param relax_structure: Flag to indicate whether structure relaxation should be performed before calculations.
+        :param relax_calc_kwargs: Additional keyword arguments for relaxation phase calculations.
+        :param write_force_constants: File path or boolean flag to write force constants.
+            Defaults to "force_constants".
+        :param write_band_structure: File path or boolean flag to write band structure data.
+            Defaults to "band_structure.yaml".
+        :param write_total_dos: File path or boolean flag to write total density of states (DOS) data.
+            Defaults to "total_dos.dat".
+        :param write_phonon: File path or boolean flag to write phonon data. Defaults to "phonon.yaml".
+        """
+        self.calculator = calculator  # type: ignore[assignment]
+        self.atom_disp = atom_disp
+        self.supercell_matrix = supercell_matrix
+        self.t_step = t_step
+        self.t_max = t_max
+        self.t_min = t_min
+        self.fmax = fmax
+        self.optimizer = optimizer
+        self.relax_structure = relax_structure
+        self.relax_calc_kwargs = relax_calc_kwargs
+        self.write_force_constants = write_force_constants
+        self.write_band_structure = write_band_structure
+        self.write_total_dos = write_total_dos
+        self.write_phonon = write_phonon
+
+        # Set default paths for output files.
+        for key, val, default_path in (
+            ("write_force_constants", self.write_force_constants, "force_constants"),
+            ("write_band_structure", self.write_band_structure, "band_structure.yaml"),
+            ("write_total_dos", self.write_total_dos, "total_dos.dat"),
+            ("write_phonon", self.write_phonon, "phonon.yaml"),
+        ):
+            setattr(self, key, str({True: default_path, False: ""}.get(val, val)))  # type: ignore[arg-type]
+
+    def calc(self, structure: Structure | dict[str, Any]) -> dict:
+        """Calculates thermal properties of Pymatgen structure with phonopy.
+
+        Args:
+            structure: Pymatgen structure.
+
+        Returns:
+        {
+            phonon: Phonopy object with force constants produced
+            thermal_properties:
+                {
+                    temperatures: list of temperatures in Kelvin,
+                    free_energy: list of Helmholtz free energies at corresponding temperatures in kJ/mol,
+                    entropy: list of entropies at corresponding temperatures in J/K/mol,
+                    heat_capacity: list of heat capacities at constant volume at corresponding temperatures in J/K/mol,
+                    The units are originally documented in phonopy.
+                    See phonopy.Phonopy.run_thermal_properties()
+                    (https://github.com/phonopy/phonopy/blob/develop/phonopy/api_phonopy.py#L2591)
+                    -> phonopy.phonon.thermal_properties.ThermalProperties.run()
+                    (https://github.com/phonopy/phonopy/blob/develop/phonopy/phonon/thermal_properties.py#L498)
+                    -> phonopy.phonon.thermal_properties.ThermalPropertiesBase.run_free_energy()
+                    (https://github.com/phonopy/phonopy/blob/develop/phonopy/phonon/thermal_properties.py#L217)
+                    phonopy.phonon.thermal_properties.ThermalPropertiesBase.run_entropy()
+                    (https://github.com/phonopy/phonopy/blob/develop/phonopy/phonon/thermal_properties.py#L233)
+                    phonopy.phonon.thermal_properties.ThermalPropertiesBase.run_heat_capacity()
+                    (https://github.com/phonopy/phonopy/blob/develop/phonopy/phonon/thermal_properties.py#L225)
+                }
+        }
+        """
+        result = super().calc(structure)
+        structure_in: Structure = result["final_structure"]
+
+        if self.relax_structure:
+            relaxer = RelaxCalc(
+                self.calculator, fmax=self.fmax, optimizer=self.optimizer, **(self.relax_calc_kwargs or {})
+            )
+            result |= relaxer.calc(structure_in)
+            structure_in = result["final_structure"]
+        cell = get_phonopy_structure(structure_in)
+        phonon = phonopy.Phonopy(cell, self.supercell_matrix)  # type: ignore[arg-type]
+        phonon.generate_displacements(distance=self.atom_disp)
+        disp_supercells = phonon.supercells_with_displacements
+        phonon.forces = [  # type: ignore[assignment]
+            _calc_forces(self.calculator, supercell)
+            for supercell in disp_supercells  # type:ignore[union-attr]
+            if supercell is not None
+        ]
+        phonon.produce_force_constants()
+        phonon.run_mesh()
+        phonon.run_thermal_properties(t_step=self.t_step, t_max=self.t_max, t_min=self.t_min)
+        if self.write_force_constants:
+            write_force_constants(phonon.force_constants, filename=self.write_force_constants)
+        if self.write_band_structure:
+            phonon.auto_band_structure(write_yaml=True, filename=self.write_band_structure)
+        if self.write_total_dos:
+            phonon.auto_total_dos(write_dat=True, filename=self.write_total_dos)
+        if self.write_phonon:
+            phonon.save(filename=self.write_phonon)
+        return result | {"phonon": phonon, "thermal_properties": phonon.get_thermal_properties_dict()}
+
+
+def _calc_forces(calculator: Calculator, supercell: PhonopyAtoms) -> ArrayLike:
+    """Helper to compute forces on a structure.
+
+    Args:
+        calculator: ASE Calculator
+        supercell: Supercell from phonopy.
+
+    Return:
+        forces
+    """
+    struct = get_pmg_structure(supercell)
+    atoms = AseAtomsAdaptor.get_atoms(struct)
+    atoms.calc = calculator
+    return atoms.get_forces()