Upload starting point for mace

models/mace/README.md

@@ -0,0 +1,5 @@
+## Introduction
+
+Running the script can be found in mace/cli/run_train
+
+you can run it from scripts/run_mace.sh. Just speicfy pathways

models/mace/mace/__init__.py

@@ -0,0 +1,5 @@
+import os
+
+from .__version__ import __version__
+
+os.environ["TORCH_FORCE_NO_WEIGHTS_ONLY_LOAD"] = "1"

models/mace/mace/__version__.py

@@ -0,0 +1,3 @@
+__version__ = "0.3.15"
+
+__all__ = ["__version__"]

models/mace/mace/calculators/__init__.py

@@ -0,0 +1,11 @@
+from .foundations_models import mace_anicc, mace_mp, mace_off, mace_omol
+from .lammps_mace import LAMMPS_MACE
+from .mace import MACECalculator
+
+__all__ = [
+    "MACECalculator",
+    "LAMMPS_MACE",
+    "mace_mp",
+    "mace_off",
+    "mace_anicc",
+]

models/mace/mace/calculators/foundations_models.py

@@ -0,0 +1,445 @@
+import os
+import urllib.request
+from pathlib import Path
+from typing import Any, Literal, Optional, Union, overload
+
+import torch
+from ase import units
+from ase.calculators.mixing import SumCalculator
+
+from mace.tools.utils import get_cache_dir
+
+from .mace import MACECalculator
+
+module_dir = os.path.dirname(__file__)
+local_model_path = os.path.join(
+    module_dir, "foundations_models/mace-mpa-0-medium.model"
+)
+
+mace_mp_urls = {
+    "small": "https://github.com/ACEsuit/mace-mp/releases/download/mace_mp_0/2023-12-10-mace-128-L0_energy_epoch-249.model",
+    "medium": "https://github.com/ACEsuit/mace-mp/releases/download/mace_mp_0/2023-12-03-mace-128-L1_epoch-199.model",
+    "large": "https://github.com/ACEsuit/mace-mp/releases/download/mace_mp_0/MACE_MPtrj_2022.9.model",
+    "small-0b": "https://github.com/ACEsuit/mace-mp/releases/download/mace_mp_0b/mace_agnesi_small.model",
+    "medium-0b": "https://github.com/ACEsuit/mace-mp/releases/download/mace_mp_0b/mace_agnesi_medium.model",
+    "small-0b2": "https://github.com/ACEsuit/mace-mp/releases/download/mace_mp_0b2/mace-small-density-agnesi-stress.model",
+    "medium-0b2": "https://github.com/ACEsuit/mace-mp/releases/download/mace_mp_0b2/mace-medium-density-agnesi-stress.model",
+    "large-0b2": "https://github.com/ACEsuit/mace-mp/releases/download/mace_mp_0b2/mace-large-density-agnesi-stress.model",
+    "medium-0b3": "https://github.com/ACEsuit/mace-mp/releases/download/mace_mp_0b3/mace-mp-0b3-medium.model",
+    "medium-mpa-0": "https://github.com/ACEsuit/mace-mp/releases/download/mace_mpa_0/mace-mpa-0-medium.model",
+    "small-omat-0": "https://github.com/ACEsuit/mace-mp/releases/download/mace_omat_0/mace-omat-0-small.model",
+    "medium-omat-0": "https://github.com/ACEsuit/mace-mp/releases/download/mace_omat_0/mace-omat-0-medium.model",
+    "mace-matpes-pbe-0": "https://github.com/ACEsuit/mace-foundations/releases/download/mace_matpes_0/MACE-matpes-pbe-omat-ft.model",
+    "mace-matpes-r2scan-0": "https://github.com/ACEsuit/mace-foundations/releases/download/mace_matpes_0/MACE-matpes-r2scan-omat-ft.model",
+    "mh-0": "https://github.com/ACEsuit/mace-foundations/releases/download/mace_mh_1/mace-mh-0.model",
+    "mh-1": "https://github.com/ACEsuit/mace-foundations/releases/download/mace_mh_1/mace-mh-1.model",
+}
+mace_mp_names = [None] + list(mace_mp_urls.keys())
+
+
+def download_mace_mp_checkpoint(model: Optional[Union[str, Path]] = None) -> str:
+    """
+    Downloads or locates the MACE-MP checkpoint file.
+
+    Args:
+        model (str, optional): Path to the model or size specification.
+            Defaults to None which uses the medium model.
+
+    Returns:
+        str: Path to the downloaded (or cached, if previously loaded) checkpoint file.
+    """
+    if model in (None, "medium-mpa-0") and os.path.isfile(local_model_path):
+        return local_model_path
+
+    checkpoint_url = (
+        mace_mp_urls.get(model, mace_mp_urls["medium-mpa-0"])
+        if model in mace_mp_names
+        else model
+    )
+
+    if checkpoint_url == mace_mp_urls["medium-mpa-0"]:
+        print(
+            "Using medium MPA-0 model as default MACE-MP model, to use previous (before 3.10) default model please specify 'medium' as model argument"
+        )
+    ASL_checkpoint_urls = {
+        mace_mp_urls["small-omat-0"],
+        mace_mp_urls["medium-omat-0"],
+        mace_mp_urls["mace-matpes-pbe-0"],
+        mace_mp_urls["mace-matpes-r2scan-0"],
+    }
+    if checkpoint_url in ASL_checkpoint_urls:
+        print(
+            "Using model under Academic Software License (ASL) license, see https://github.com/gabor1/ASL \n To use this model you accept the terms of the license."
+        )
+
+    cache_dir = get_cache_dir()
+    checkpoint_url_name = "".join(
+        c for c in os.path.basename(checkpoint_url) if c.isalnum() or c in "_"
+    )
+    cached_model_path = f"{cache_dir}/{checkpoint_url_name}"
+
+    if not os.path.isfile(cached_model_path):
+        os.makedirs(cache_dir, exist_ok=True)
+        print(f"Downloading MACE model from {checkpoint_url!r}")
+        _, http_msg = urllib.request.urlretrieve(checkpoint_url, cached_model_path)
+        if "Content-Type: text/html" in http_msg:
+            raise RuntimeError(
+                f"Model download failed, please check the URL {checkpoint_url}"
+            )
+        print(f"Cached MACE model to {cached_model_path}")
+
+    return cached_model_path
+
+
+@overload
+def mace_mp(*, return_raw_model: Literal[True], **kwargs: Any) -> torch.nn.Module: ...
+
+
+@overload
+def mace_mp(
+    *, return_raw_model: Literal[False] = False, **kwargs: Any
+) -> MACECalculator: ...
+
+
+def mace_mp(
+    model: Optional[Union[str, Path]] = None,
+    device: str = "",
+    default_dtype: str = "float32",
+    dispersion: bool = False,
+    damping: str = "bj",  # choices: ["zero", "bj", "zerom", "bjm"]
+    dispersion_xc: str = "pbe",
+    dispersion_cutoff: float = 40.0 * units.Bohr,
+    return_raw_model: bool = False,
+    **kwargs,
+) -> Union[MACECalculator, torch.nn.Module, SumCalculator]:
+    """
+    Constructs a MACECalculator with a pretrained model based on the Materials Project (89 elements).
+    The model is released under the MIT license. See https://github.com/ACEsuit/mace-foundations for all models.
+    Note:
+        If you are using this function, please cite the relevant paper for the Materials Project,
+        any paper associated with the MACE model, and also the following:
+        - MACE-MP by Ilyes Batatia, Philipp Benner, Yuan Chiang, Alin M. Elena,
+            Dávid P. Kovács, Janosh Riebesell, et al., 2023, arXiv:2401.00096
+        - MACE-Universal by Yuan Chiang, 2023, Hugging Face, Revision e5ebd9b,
+            DOI: 10.57967/hf/1202, URL: https://huggingface.co/cyrusyc/mace-universal
+        - Matbench Discovery by Janosh Riebesell, Rhys EA Goodall, Philipp Benner, Yuan Chiang,
+            Alpha A Lee, Anubhav Jain, Kristin A Persson, 2023, arXiv:2308.14920
+
+    Args:
+        model (str, optional): Path to the model. Defaults to None which first checks for
+            a local model and then downloads the default model from figshare. Specify "small",
+            "medium" or "large" to download a smaller or larger model from figshare.
+        device (str, optional): Device to use for the model. Defaults to "cuda" if available.
+        default_dtype (str, optional): Default dtype for the model. Defaults to "float32".
+        dispersion (bool, optional): Whether to use D3 dispersion corrections. Defaults to False.
+        damping (str): The damping function associated with the D3 correction. Defaults to "bj" for D3(BJ).
+        dispersion_xc (str, optional): Exchange-correlation functional for D3 dispersion corrections.
+        dispersion_cutoff (float, optional): Cutoff radius in Bohr for D3 dispersion corrections.
+        return_raw_model (bool, optional): Whether to return the raw model or an ASE calculator. Defaults to False.
+        **kwargs: Passed to MACECalculator and TorchDFTD3Calculator.
+
+    Returns:
+        MACECalculator: trained on the MPtrj dataset (unless model otherwise specified).
+    """
+    try:
+        if model in mace_mp_names or str(model).startswith("https:"):
+            model_path = download_mace_mp_checkpoint(model)
+            print(f"Using Materials Project MACE for MACECalculator with {model_path}")
+        else:
+            if not Path(model).exists():
+                raise FileNotFoundError(f"{model} not found locally")
+            model_path = model
+    except Exception as exc:
+        raise RuntimeError("Model download failed and no local model found") from exc
+
+    device = device or ("cuda" if torch.cuda.is_available() else "cpu")
+    if default_dtype == "float64":
+        print(
+            "Using float64 for MACECalculator, which is slower but more accurate. Recommended for geometry optimization."
+        )
+    if default_dtype == "float32":
+        print(
+            "Using float32 for MACECalculator, which is faster but less accurate. Recommended for MD. Use float64 for geometry optimization."
+        )
+
+    if return_raw_model:
+        return torch.load(model_path, map_location=device)
+
+    mace_calc = MACECalculator(
+        model_paths=model_path, device=device, default_dtype=default_dtype, **kwargs
+    )
+
+    if not dispersion:
+        return mace_calc
+
+    try:
+        from torch_dftd.torch_dftd3_calculator import TorchDFTD3Calculator
+    except ImportError as exc:
+        raise RuntimeError(
+            "Please install torch-dftd to use dispersion corrections (see https://github.com/pfnet-research/torch-dftd)"
+        ) from exc
+
+    print("Using TorchDFTD3Calculator for D3 dispersion corrections")
+    dtype = torch.float32 if default_dtype == "float32" else torch.float64
+    d3_calc = TorchDFTD3Calculator(
+        device=device,
+        damping=damping,
+        dtype=dtype,
+        xc=dispersion_xc,
+        cutoff=dispersion_cutoff,
+        **kwargs,
+    )
+
+    return SumCalculator([mace_calc, d3_calc])
+
+
+@overload
+def mace_off(*, return_raw_model: Literal[True], **kwargs: Any) -> torch.nn.Module: ...
+
+
+@overload
+def mace_off(
+    *, return_raw_model: Literal[False] = False, **kwargs: Any
+) -> MACECalculator: ...
+
+
+def mace_off(
+    model: Optional[Union[str, Path]] = None,
+    device: str = "",
+    default_dtype: str = "float64",
+    return_raw_model: bool = False,
+    **kwargs,
+) -> Union[MACECalculator, torch.nn.Module]:
+    """
+    Constructs a MACECalculator with a pretrained model based on the MACE-OFF23 models.
+    The model is released under the ASL license.
+    Note:
+        If you are using this function, please cite the relevant paper by Kovacs et.al., arXiv:2312.15211
+
+    Args:
+        model (str, optional): Path to the model. Defaults to None which first checks for
+            a local model and then downloads the default medium model from https://github.com/ACEsuit/mace-off.
+            Specify "small", "medium" or "large" to download a smaller or larger model.
+        device (str, optional): Device to use for the model. Defaults to "cuda".
+        default_dtype (str, optional): Default dtype for the model. Defaults to "float64".
+        return_raw_model (bool, optional): Whether to return the raw model or an ASE calculator. Defaults to False.
+        **kwargs: Passed to MACECalculator.
+
+    Returns:
+        MACECalculator: trained on the MACE-OFF23 dataset
+    """
+    try:
+        if model in (None, "small", "medium", "large") or str(model).startswith(
+            "https:"
+        ):
+            urls = dict(
+                small="https://github.com/ACEsuit/mace-off/blob/main/mace_off23/MACE-OFF23_small.model?raw=true",
+                medium="https://github.com/ACEsuit/mace-off/raw/main/mace_off23/MACE-OFF23_medium.model?raw=true",
+                large="https://github.com/ACEsuit/mace-off/blob/main/mace_off23/MACE-OFF23_large.model?raw=true",
+            )
+            checkpoint_url = (
+                urls.get(model, urls["medium"])
+                if model in (None, "small", "medium", "large")
+                else model
+            )
+            cache_dir = get_cache_dir()
+            checkpoint_url_name = os.path.basename(checkpoint_url).split("?")[0]
+            cached_model_path = f"{cache_dir}/{checkpoint_url_name}"
+            if not os.path.isfile(cached_model_path):
+                os.makedirs(cache_dir, exist_ok=True)
+                # download and save to disk
+                print(f"Downloading MACE model from {checkpoint_url!r}")
+                print(
+                    "The model is distributed under the Academic Software License (ASL) license, see https://github.com/gabor1/ASL \n To use the model you accept the terms of the license."
+                )
+                print(
+                    "ASL is based on the Gnu Public License, but does not permit commercial use"
+                )
+                urllib.request.urlretrieve(checkpoint_url, cached_model_path)
+                print(f"Cached MACE model to {cached_model_path}")
+            model = cached_model_path
+            msg = f"Using MACE-OFF23 MODEL for MACECalculator with {model}"
+            print(msg)
+        else:
+            if not Path(model).exists():
+                raise FileNotFoundError(f"{model} not found locally")
+    except Exception as exc:
+        raise RuntimeError("Model download failed and no local model found") from exc
+
+    device = device or ("cuda" if torch.cuda.is_available() else "cpu")
+
+    if return_raw_model:
+        return torch.load(model, map_location=device)
+
+    if default_dtype == "float64":
+        print(
+            "Using float64 for MACECalculator, which is slower but more accurate. Recommended for geometry optimization."
+        )
+    if default_dtype == "float32":
+        print(
+            "Using float32 for MACECalculator, which is faster but less accurate. Recommended for MD. Use float64 for geometry optimization."
+        )
+    mace_calc = MACECalculator(
+        model_paths=model, device=device, default_dtype=default_dtype, **kwargs
+    )
+    return mace_calc
+
+
+@overload
+def mace_anicc(
+    *, return_raw_model: Literal[True], **kwargs: Any
+) -> torch.nn.Module: ...
+
+
+@overload
+def mace_anicc(
+    *, return_raw_model: Literal[False] = False, **kwargs: Any
+) -> MACECalculator: ...
+
+
+def mace_anicc(
+    device: str = "cuda",
+    model_path: Optional[str] = None,
+    return_raw_model: bool = False,
+) -> Union[MACECalculator, torch.nn.Module]:
+    """
+    Constructs a MACECalculator with a pretrained model based on the ANI (H, C, N, O).
+    The model is released under the MIT license.
+    Note:
+        If you are using this function, please cite the relevant paper associated with the MACE model, ANI dataset, and also the following:
+        - "Evaluation of the MACE Force Field Architecture by Dávid Péter Kovács, Ilyes Batatia, Eszter Sára Arany, and Gábor Csányi, The Journal of Chemical Physics, 2023, URL: https://doi.org/10.1063/5.0155322
+    """
+    if model_path is None:
+        model_path = os.path.join(
+            module_dir, "foundations_models/ani500k_large_CC.model"
+        )
+        print(
+            "Using ANI couple cluster model for MACECalculator, see https://doi.org/10.1063/5.0155322"
+        )
+
+    if not os.path.exists(model_path):
+        model_dir = os.path.dirname(model_path)
+        os.makedirs(model_dir, exist_ok=True)
+
+        # Download the model
+        print(f"Model not found at {model_path}. Downloading...")
+        model_url = "https://github.com/ACEsuit/mace/raw/main/mace/calculators/foundations_models/ani500k_large_CC.model"
+
+        try:
+
+            def report_progress(block_num, block_size, total_size):
+                downloaded = block_num * block_size
+                percent = min(100, downloaded * 100 / total_size)
+                if total_size > 0:
+                    print(
+                        f"\rDownloading model: {percent:.1f}% ({downloaded / 1024 / 1024:.1f} MB / {total_size / 1024 / 1024:.1f} MB)",
+                        end="",
+                    )
+
+            urllib.request.urlretrieve(
+                model_url, model_path, reporthook=report_progress
+            )
+            print("\nDownload complete!")
+
+        except Exception as e:
+            raise RuntimeError(f"Failed to download model: {e}") from e
+
+    if return_raw_model:
+        return torch.load(model_path, map_location=device)
+    return MACECalculator(
+        model_paths=model_path, device=device, default_dtype="float64"
+    )
+
+
+@overload
+def mace_omol(*, return_raw_model: Literal[True], **kwargs: Any) -> torch.nn.Module: ...
+
+
+@overload
+def mace_omol(
+    *, return_raw_model: Literal[False] = False, **kwargs: Any
+) -> MACECalculator: ...
+
+
+def mace_omol(
+    model: Optional[Union[str, Path]] = None,
+    device: str = "",
+    default_dtype: str = "float64",
+    return_raw_model: bool = False,
+    **kwargs,
+) -> Union[MACECalculator, torch.nn.Module]:
+    """
+    Constructs a MACECalculator with a pretrained model based on the MACE-OMOL models.
+    The model is released under the ASL license.
+    Note:
+        If you are using this function, please cite the relevant OMOL paper.
+
+    Args:
+        model (str or Path, optional): Either a path to a local model file or a string specifier.
+            Use "extra_large" or None to download the default OMOL model.
+        device (str, optional): Device to use for the model. Defaults to "cuda" if available.
+        default_dtype (str, optional): Default dtype for the model. Defaults to "float64".
+        return_raw_model (bool, optional): Whether to return the raw model or an ASE calculator. Defaults to False.
+        **kwargs: Passed to MACECalculator.
+
+    Returns:
+        MACECalculator: trained on the OMOL dataset.
+    """
+    urls = {
+        "extra_large": "https://github.com/ACEsuit/mace-foundations/releases/download/mace_omol_0/MACE-omol-0-extra-large-1024.model"
+    }
+
+    try:
+        if model is None or model == "extra_large":
+            checkpoint_url = urls["extra_large"]
+        elif isinstance(model, str) and model.startswith("https:"):
+            checkpoint_url = model
+        elif isinstance(model, (str, Path)) and Path(model).exists():
+            checkpoint_url = str(model)
+        else:
+            raise ValueError(
+                f"Invalid model specification: {model}. "
+                f"Supported options: {list(urls.keys())}, a local file path, or a direct URL."
+            )
+
+        if checkpoint_url.startswith("http"):
+            cache_dir = get_cache_dir()
+            os.makedirs(cache_dir, exist_ok=True)
+            checkpoint_url_name = os.path.basename(checkpoint_url).split("?")[0]
+            cached_model_path = os.path.join(cache_dir, checkpoint_url_name)
+
+            if not os.path.isfile(cached_model_path):
+                print(f"Downloading MACE model from {checkpoint_url!r}")
+                print(
+                    "The model is distributed under the Academic Software License (ASL), see https://github.com/gabor1/ASL\n"
+                    "To use the model, you accept the terms of the license.\n"
+                    "ASL is based on the GNU Public License, but does not permit commercial use."
+                )
+                urllib.request.urlretrieve(checkpoint_url, cached_model_path)
+                print(f"Cached MACE model to {cached_model_path}")
+            model = cached_model_path
+        else:
+            model = checkpoint_url
+
+    except Exception as exc:
+        raise RuntimeError("Model download failed and no local model found") from exc
+
+    device = device or ("cuda" if torch.cuda.is_available() else "cpu")
+
+    if return_raw_model:
+        return torch.load(model, map_location=device)
+
+    if default_dtype == "float64":
+        print(
+            "Using float64 for MACECalculator, recommended for geometry optimization."
+        )
+    elif default_dtype == "float32":
+        print("Using float32 for MACECalculator, recommended for MD.")
+
+    return MACECalculator(
+        model_paths=model,
+        device=device,
+        default_dtype=default_dtype,
+        **kwargs,
+        head="omol",
+    )

models/mace/mace/calculators/foundations_models/2023-12-03-mace-mp.model

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

models/mace/mace/calculators/foundations_models/ani500k_large_CC.model

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

models/mace/mace/calculators/foundations_models/mace-mpa-0-medium.model

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

models/mace/mace/calculators/foundations_models/mp_vasp_e0.json

@@ -0,0 +1,91 @@
+{
+    "pbe": {
+        "1": -1.11734008,
+        "2": 0.00096759,
+        "3": -0.29754725,
+        "4": -0.01781697,
+        "5": -0.26885011,
+        "6": -1.26173507,
+        "7": -3.12438806,
+        "8": -1.54838784,
+        "9": -0.51882044,
+        "10": -0.01241601,
+        "11": -0.22883163,
+        "12": -0.00951015,
+        "13": -0.21630193,
+        "14": -0.8263903,
+        "15": -1.88816619,
+        "16": -0.89160769,
+        "17": -0.25828273,
+        "18": -0.04925973,
+        "19": -0.22697913,
+        "20": -0.0927795,
+        "21": -2.11396364,
+        "22": -2.50054871,
+        "23": -3.70477179,
+        "24": -5.60261985,
+        "25": -5.32541181,
+        "26": -3.52004933,
+        "27": -1.93555024,
+        "28": -0.9351969,
+        "29": -0.60025846,
+        "30": -0.1651332,
+        "31": -0.32990651,
+        "32": -0.77971828,
+        "33": -1.68367812,
+        "34": -0.76941032,
+        "35": -0.22213843,
+        "36": -0.0335879,
+        "37": -0.1881724,
+        "38": -0.06826294,
+        "39": -2.17084228,
+        "40": -2.28579303,
+        "41": -3.13429753,
+        "42": -4.60211419,
+        "43": -3.45201492,
+        "44": -2.38073513,
+        "45": -1.46855515,
+        "46": -1.4773126,
+        "47": -0.33954585,
+        "48": -0.16843877,
+        "49": -0.35470981,
+        "50": -0.83642657,
+        "51": -1.41101987,
+        "52": -0.65740879,
+        "53": -0.18964571,
+        "54": -0.00857582,
+        "55": -0.13771876,
+        "56": -0.03457659,
+        "57": -0.45580806,
+        "58": -1.3309175,
+        "59": -0.29671824,
+        "60": -0.30391193,
+        "61": -0.30898427,
+        "62": -0.25470891,
+        "63": -8.38001538,
+        "64": -10.38896525,
+        "65": -0.3059505,
+        "66": -0.30676216,
+        "67": -0.30874667,
+        "69": -0.25190039,
+        "70": -0.06431414,
+        "71": -0.31997586,
+        "72": -3.52770927,
+        "73": -3.54492209,
+        "75": -4.70108713,
+        "76": -2.88257209,
+        "77": -1.46779304,
+        "78": -0.50269936,
+        "79": -0.28801193,
+        "80": -0.12454674,
+        "81": -0.31737194,
+        "82": -0.77644932,
+        "83": -1.32627283,
+        "89": -0.26827152,
+        "90": -0.90817426,
+        "91": -2.47653193,
+        "92": -4.90438537,
+        "93": -7.63378961,
+        "94": -10.77237713
+    }
+}

models/mace/mace/calculators/lammps_mace.py

@@ -0,0 +1,105 @@
+from typing import Dict, List, Optional
+
+import torch
+from e3nn.util.jit import compile_mode
+
+from mace.tools.scatter import scatter_sum
+
+
+@compile_mode("script")
+class LAMMPS_MACE(torch.nn.Module):
+    def __init__(self, model, **kwargs):
+        super().__init__()
+        self.model = model
+        self.register_buffer("atomic_numbers", model.atomic_numbers)
+        self.register_buffer("r_max", model.r_max)
+        self.register_buffer("num_interactions", model.num_interactions)
+        if not hasattr(model, "heads"):
+            model.heads = [None]
+        self.register_buffer(
+            "head",
+            torch.tensor(
+                self.model.heads.index(kwargs.get("head", self.model.heads[-1])),
+                dtype=torch.long,
+            ).unsqueeze(0),
+        )
+
+        for param in self.model.parameters():
+            param.requires_grad = False
+
+    def forward(
+        self,
+        data: Dict[str, torch.Tensor],
+        local_or_ghost: torch.Tensor,
+        compute_virials: bool = False,
+    ) -> Dict[str, Optional[torch.Tensor]]:
+        num_graphs = data["ptr"].numel() - 1
+        compute_displacement = False
+        if compute_virials:
+            compute_displacement = True
+        data["head"] = self.head
+        out = self.model(
+            data,
+            training=False,
+            compute_force=False,
+            compute_virials=False,
+            compute_stress=False,
+            compute_displacement=compute_displacement,
+        )
+        node_energy = out["node_energy"]
+        if node_energy is None:
+            return {
+                "total_energy_local": None,
+                "node_energy": None,
+                "forces": None,
+                "virials": None,
+            }
+        positions = data["positions"]
+        displacement = out["displacement"]
+        forces: Optional[torch.Tensor] = torch.zeros_like(positions)
+        virials: Optional[torch.Tensor] = torch.zeros_like(data["cell"])
+        # accumulate energies of local atoms
+        node_energy_local = node_energy * local_or_ghost
+        total_energy_local = scatter_sum(
+            src=node_energy_local, index=data["batch"], dim=-1, dim_size=num_graphs
+        )
+        # compute partial forces and (possibly) partial virials
+        grad_outputs: List[Optional[torch.Tensor]] = [
+            torch.ones_like(total_energy_local)
+        ]
+        if compute_virials and displacement is not None:
+            forces, virials = torch.autograd.grad(
+                outputs=[total_energy_local],
+                inputs=[positions, displacement],
+                grad_outputs=grad_outputs,
+                retain_graph=False,
+                create_graph=False,
+                allow_unused=True,
+            )
+            if forces is not None:
+                forces = -1 * forces
+            else:
+                forces = torch.zeros_like(positions)
+            if virials is not None:
+                virials = -1 * virials
+            else:
+                virials = torch.zeros_like(displacement)
+        else:
+            forces = torch.autograd.grad(
+                outputs=[total_energy_local],
+                inputs=[positions],
+                grad_outputs=grad_outputs,
+                retain_graph=False,
+                create_graph=False,
+                allow_unused=True,
+            )[0]
+            if forces is not None:
+                forces = -1 * forces
+            else:
+                forces = torch.zeros_like(positions)
+        return {
+            "total_energy_local": total_energy_local,
+            "node_energy": node_energy,
+            "forces": forces,
+            "virials": virials,
+        }

models/mace/mace/calculators/lammps_mliap_mace.py

@@ -0,0 +1,228 @@
+import logging
+import os
+import sys
+import time
+from contextlib import contextmanager
+from typing import Dict, Tuple
+
+import torch
+from ase.data import chemical_symbols
+from e3nn.util.jit import compile_mode
+
+try:
+    from lammps.mliap.mliap_unified_abc import MLIAPUnified
+except ImportError:
+
+    class MLIAPUnified:
+        def __init__(self):
+            pass
+
+
+class MACELammpsConfig:
+    """Configuration settings for MACE-LAMMPS integration."""
+
+    def __init__(self):
+        self.debug_time = self._get_env_bool("MACE_TIME", False)
+        self.debug_profile = self._get_env_bool("MACE_PROFILE", False)
+        self.profile_start_step = int(os.environ.get("MACE_PROFILE_START", "5"))
+        self.profile_end_step = int(os.environ.get("MACE_PROFILE_END", "10"))
+        self.allow_cpu = self._get_env_bool("MACE_ALLOW_CPU", False)
+        self.force_cpu = self._get_env_bool("MACE_FORCE_CPU", False)
+
+    @staticmethod
+    def _get_env_bool(var_name: str, default: bool) -> bool:
+        return os.environ.get(var_name, str(default)).lower() in (
+            "true",
+            "1",
+            "t",
+            "yes",
+        )
+
+
+@contextmanager
+def timer(name: str, enabled: bool = True):
+    """Context manager for timing code blocks."""
+    if not enabled:
+        yield
+        return
+
+    start = time.perf_counter()
+    try:
+        yield
+    finally:
+        elapsed = time.perf_counter() - start
+        logging.info(f"Timer - {name}: {elapsed*1000:.3f} ms")
+
+
+@compile_mode("script")
+class MACEEdgeForcesWrapper(torch.nn.Module):
+    """Wrapper that adds per-pair force computation to a MACE model."""
+
+    def __init__(self, model: torch.nn.Module, **kwargs):
+        super().__init__()
+        self.model = model
+        self.register_buffer("atomic_numbers", model.atomic_numbers)
+        self.register_buffer("r_max", model.r_max)
+        self.register_buffer("num_interactions", model.num_interactions)
+        self.register_buffer(
+            "total_charge",
+            kwargs.get(
+                "total_charge", torch.tensor([0.0], dtype=torch.get_default_dtype())
+            ),
+        )
+        self.register_buffer(
+            "total_spin",
+            kwargs.get(
+                "total_spin", torch.tensor([1.0], dtype=torch.get_default_dtype())
+            ),
+        )
+
+        if not hasattr(model, "heads"):
+            model.heads = ["Default"]
+
+        head_name = kwargs.get("head", model.heads[-1])
+        head_idx = model.heads.index(head_name)
+        self.register_buffer("head", torch.tensor([head_idx], dtype=torch.long))
+
+        for p in self.model.parameters():
+            p.requires_grad = False
+
+    def forward(
+        self, data: Dict[str, torch.Tensor]
+    ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        """Compute energies and per-pair forces."""
+        data["head"] = self.head
+        data["total_charge"] = self.total_charge
+        data["total_spin"] = self.total_spin
+
+        out = self.model(
+            data,
+            training=False,
+            compute_force=False,
+            compute_virials=False,
+            compute_stress=False,
+            compute_displacement=False,
+            compute_edge_forces=True,
+            lammps_mliap=True,
+        )
+
+        node_energy = out["node_energy"]
+        pair_forces = out["edge_forces"]
+        total_energy = out["energy"][0]
+
+        if pair_forces is None:
+            pair_forces = torch.zeros_like(data["vectors"])
+
+        return total_energy, node_energy, pair_forces
+
+
+class LAMMPS_MLIAP_MACE(MLIAPUnified):
+    """MACE integration for LAMMPS using the MLIAP interface."""
+
+    def __init__(self, model, **kwargs):
+        super().__init__()
+        self.config = MACELammpsConfig()
+        self.model = MACEEdgeForcesWrapper(model, **kwargs)
+        self.element_types = [chemical_symbols[s] for s in model.atomic_numbers]
+        self.num_species = len(self.element_types)
+        self.rcutfac = 0.5 * float(model.r_max)
+        self.ndescriptors = 1
+        self.nparams = 1
+        self.dtype = model.r_max.dtype
+        self.device = "cpu"
+        self.initialized = False
+        self.step = 0
+
+    def _initialize_device(self, data):
+        using_kokkos = "kokkos" in data.__class__.__module__.lower()
+
+        if using_kokkos and not self.config.force_cpu:
+            device = torch.as_tensor(data.elems).device
+            if device.type == "cpu" and not self.config.allow_cpu:
+                raise ValueError(
+                    "GPU requested but tensor is on CPU. Set MACE_ALLOW_CPU=true to allow CPU computation."
+                )
+        else:
+            device = torch.device("cpu")
+
+        self.device = device
+        self.model = self.model.to(device)
+        logging.info(f"MACE model initialized on device: {device}")
+        self.initialized = True
+
+    def compute_forces(self, data):
+        natoms = data.nlocal
+        ntotal = data.ntotal
+        nghosts = ntotal - natoms
+        npairs = data.npairs
+        species = torch.as_tensor(data.elems, dtype=torch.int64)
+
+        if not self.initialized:
+            self._initialize_device(data)
+
+        self.step += 1
+        self._manage_profiling()
+
+        if natoms == 0 or npairs <= 1:
+            return
+
+        with timer("total_step", enabled=self.config.debug_time):
+            with timer("prepare_batch", enabled=self.config.debug_time):
+                batch = self._prepare_batch(data, natoms, nghosts, species)
+
+            with timer("model_forward", enabled=self.config.debug_time):
+                _, atom_energies, pair_forces = self.model(batch)
+
+                if self.device.type != "cpu":
+                    torch.cuda.synchronize()
+
+            with timer("update_lammps", enabled=self.config.debug_time):
+                self._update_lammps_data(data, atom_energies, pair_forces, natoms)
+
+    def _prepare_batch(self, data, natoms, nghosts, species):
+        """Prepare the input batch for the MACE model."""
+        return {
+            "vectors": torch.as_tensor(data.rij).to(self.dtype).to(self.device),
+            "node_attrs": torch.nn.functional.one_hot(
+                species.to(self.device), num_classes=self.num_species
+            ).to(self.dtype),
+            "edge_index": torch.stack(
+                [
+                    torch.as_tensor(data.pair_j, dtype=torch.int64).to(self.device),
+                    torch.as_tensor(data.pair_i, dtype=torch.int64).to(self.device),
+                ],
+                dim=0,
+            ),
+            "batch": torch.zeros(natoms, dtype=torch.int64, device=self.device),
+            "lammps_class": data,
+            "natoms": (natoms, nghosts),
+        }
+
+    def _update_lammps_data(self, data, atom_energies, pair_forces, natoms):
+        """Update LAMMPS data structures with computed energies and forces."""
+        if self.dtype == torch.float32:
+            pair_forces = pair_forces.double()
+        eatoms = torch.as_tensor(data.eatoms)
+        eatoms.copy_(atom_energies[:natoms])
+        data.energy = torch.sum(atom_energies[:natoms])
+        data.update_pair_forces_gpu(pair_forces)
+
+    def _manage_profiling(self):
+        if not self.config.debug_profile:
+            return
+
+        if self.step == self.config.profile_start_step:
+            logging.info(f"Starting CUDA profiler at step {self.step}")
+            torch.cuda.profiler.start()
+
+        if self.step == self.config.profile_end_step:
+            logging.info(f"Stopping CUDA profiler at step {self.step}")
+            torch.cuda.profiler.stop()
+            logging.info("Profiling complete. Exiting.")
+            sys.exit()
+
+    def compute_descriptors(self, data):
+        pass
+
+    def compute_gradients(self, data):
+        pass

models/mace/mace/calculators/mace.py

@@ -0,0 +1,620 @@
+###########################################################################################
+# The ASE Calculator for MACE
+# Authors: Ilyes Batatia, David Kovacs
+# This program is distributed under the MIT License (see MIT.md)
+###########################################################################################
+
+import logging
+
+# pylint: disable=wrong-import-position
+import os
+from glob import glob
+from pathlib import Path
+from typing import List, Union
+
+os.environ["TORCH_FORCE_NO_WEIGHTS_ONLY_LOAD"] = "1"
+
+import numpy as np
+import torch
+from ase.calculators.calculator import Calculator, all_changes
+from ase.stress import full_3x3_to_voigt_6_stress
+from e3nn import o3
+
+from mace import data as mace_data
+from mace.modules.utils import extract_invariant
+from mace.tools import torch_geometric, torch_tools, utils
+from mace.tools.compile import prepare
+from mace.tools.scripts_utils import extract_model
+
+try:
+    from mace.cli.convert_e3nn_cueq import run as run_e3nn_to_cueq
+
+    CUEQQ_AVAILABLE = True
+except (ImportError, ModuleNotFoundError):
+    CUEQQ_AVAILABLE = False
+    run_e3nn_to_cueq = None
+
+try:
+    from mace.cli.convert_e3nn_oeq import run as run_e3nn_to_oeq
+
+    OEQ_AVAILABLE = True
+except (ImportError, ModuleNotFoundError):
+    OEQ_AVAILABLE = False
+    run_e3nn_to_oeq = None
+
+try:
+    import intel_extension_for_pytorch as ipex
+
+    has_ipex = True
+except ImportError:
+    has_ipex = False
+
+
+def get_model_dtype(model: torch.nn.Module) -> torch.dtype:
+    """Get the dtype of the model"""
+    mode_dtype = next(model.parameters()).dtype
+    if mode_dtype == torch.float64:
+        return "float64"
+    if mode_dtype == torch.float32:
+        return "float32"
+    raise ValueError(f"Unknown dtype {mode_dtype}")
+
+
+class MACECalculator(Calculator):
+    """MACE ASE Calculator
+    args:
+        model_paths: str, path to model or models if a committee is produced
+                to make a committee use a wild card notation like mace_*.model
+        device: str, device to run on (cuda or cpu or xpu)
+        energy_units_to_eV: float, conversion factor from model energy units to eV
+        length_units_to_A: float, conversion factor from model length units to Angstroms
+        default_dtype: str, default dtype of model
+        charges_key: str, Array field of atoms object where atomic charges are stored
+        model_type: str, type of model to load
+                    Options: [MACE, DipoleMACE, EnergyDipoleMACE]
+
+    Dipoles are returned in units of Debye
+    """
+
+    def __init__(
+        self,
+        model_paths: Union[list, str, None] = None,
+        models: Union[List[torch.nn.Module], torch.nn.Module, None] = None,
+        device: str = "cpu",
+        energy_units_to_eV: float = 1.0,
+        length_units_to_A: float = 1.0,
+        default_dtype="",
+        charges_key="Qs",
+        info_keys=None,
+        arrays_keys=None,
+        model_type="MACE",
+        compile_mode=None,
+        fullgraph=True,
+        enable_cueq=False,
+        enable_oeq=False,
+        **kwargs,
+    ):
+        Calculator.__init__(self, **kwargs)
+        if enable_cueq or enable_oeq:
+            assert model_type == "MACE", "CuEq only supports MACE models"
+            if compile_mode is not None:
+                logging.warning(
+                    "CuEq or Oeq does not support torch.compile, setting compile_mode to None"
+                )
+                compile_mode = None
+        if enable_cueq and enable_oeq:
+            raise ValueError(
+                "CuEq and OEq cannot be used together, please choose one of them"
+            )
+        if enable_cueq and not CUEQQ_AVAILABLE:
+            raise ImportError(
+                "cuequivariance is not installed so CuEq acceleration cannot be used"
+            )
+        if enable_oeq and not OEQ_AVAILABLE:
+            raise ImportError(
+                "openequivariance is not installed so OEq acceleration cannot be used"
+            )
+        if "model_path" in kwargs:
+            deprecation_message = (
+                "'model_path' argument is deprecated, please use 'model_paths'"
+            )
+            if model_paths is None:
+                logging.warning(f"{deprecation_message} in the future.")
+                model_paths = kwargs["model_path"]
+            else:
+                raise ValueError(
+                    f"both 'model_path' and 'model_paths' given, {deprecation_message} only."
+                )
+
+        if (model_paths is None) == (models is None):
+            raise ValueError(
+                "Exactly one of 'model_paths' or 'models' must be provided"
+            )
+
+        self.results = {}
+        if info_keys is None:
+            info_keys = {"total_spin": "spin", "total_charge": "charge"}
+        if arrays_keys is None:
+            arrays_keys = {}
+        self.info_keys = info_keys
+        self.arrays_keys = arrays_keys
+
+        self.model_type = model_type
+        self.compute_atomic_stresses = False
+
+        if model_type not in [
+            "MACE",
+            "DipoleMACE",
+            "EnergyDipoleMACE",
+            "DipolePolarizabilityMACE",
+        ]:
+            raise ValueError(
+                f"Give a valid model_type: [MACE, DipoleMACE, DipolePolarizabilityMACE, EnergyDipoleMACE], {model_type} not supported"
+            )
+
+        # superclass constructor initializes self.implemented_properties to an empty list
+        if model_type in ["MACE", "EnergyDipoleMACE"]:
+            self.implemented_properties.extend(
+                [
+                    "energy",
+                    "energies",
+                    "free_energy",
+                    "node_energy",
+                    "forces",
+                    "stress",
+                ]
+            )
+            if kwargs.get("compute_atomic_stresses", False):
+                self.implemented_properties.extend(["stresses", "virials"])
+                self.compute_atomic_stresses = True
+        if model_type in ["EnergyDipoleMACE", "DipoleMACE", "DipolePolarizabilityMACE"]:
+            self.implemented_properties.extend(["dipole"])
+        if model_type == "DipolePolarizabilityMACE":
+            self.implemented_properties.extend(
+                [
+                    "charges",
+                    "polarizability",
+                    "polarizability_sh",
+                ]
+            )
+
+        if model_paths is not None:
+            if isinstance(model_paths, str):
+                # Find all models that satisfy the wildcard (e.g. mace_model_*.pt)
+                model_paths_glob = glob(model_paths)
+
+                if len(model_paths_glob) == 0:
+                    raise ValueError(f"Couldn't find MACE model files: {model_paths}")
+
+                model_paths = model_paths_glob
+            elif isinstance(model_paths, Path):
+                model_paths = [model_paths]
+
+            if len(model_paths) == 0:
+                raise ValueError("No mace file names supplied")
+            self.num_models = len(model_paths)
+
+            # Load models from files
+            self.models = [
+                torch.load(f=model_path, map_location=device)
+                for model_path in model_paths
+            ]
+
+
+        elif models is not None:
+            if not isinstance(models, list):
+                models = [models]
+
+            if len(models) == 0:
+                raise ValueError("No models supplied")
+
+            self.models = models
+            self.num_models = len(models)
+
+        if self.num_models > 1:
+            logging.info(f"Running committee mace with {self.num_models} models")
+
+            if model_type in ["MACE", "EnergyDipoleMACE"]:
+                self.implemented_properties.extend(
+                    ["energy_comm", "energy_var", "forces_comm", "stress_var"]
+                )
+            if model_type in [
+                "DipoleMACE",
+                "EnergyDipoleMACE",
+                "DipolePolarizabilityMACE",
+            ]:
+                self.implemented_properties.extend(["dipole_var"])
+
+        if compile_mode is not None:
+            logging.info(f"Torch compile is enabled with mode: {compile_mode}")
+            self.models = [
+                torch.compile(
+                    prepare(extract_model)(model=model, map_location=device),
+                    mode=compile_mode,
+                    fullgraph=fullgraph,
+                )
+                for model in self.models
+            ]
+            self.use_compile = True
+        else:
+            self.use_compile = False
+
+        # Ensure all models are on the same device
+        for model in self.models:
+            model.to(device)
+
+        if has_ipex and device == "xpu":
+            for model in self.models:
+                model = ipex.optimize(model)
+
+        r_maxs = [model.r_max.cpu() for model in self.models]
+        r_maxs = np.array(r_maxs)
+        if not np.all(r_maxs == r_maxs[0]):
+            raise ValueError(f"committee r_max are not all the same {' '.join(r_maxs)}")
+        self.r_max = float(r_maxs[0])
+
+        self.device = torch_tools.init_device(device)
+        self.energy_units_to_eV = energy_units_to_eV
+        self.length_units_to_A = length_units_to_A
+        self.z_table = utils.AtomicNumberTable(
+            [int(z) for z in self.models[0].atomic_numbers]
+        )
+        self.charges_key = charges_key
+
+        try:
+            self.available_heads: List[str] = self.models[0].heads  # type: ignore
+        except AttributeError:
+            self.available_heads = ["Default"]
+        kwarg_head = kwargs.get("head", None)
+        if kwarg_head is not None:
+            self.head = kwarg_head
+            if isinstance(self.head, str):
+                if self.head not in self.available_heads:
+                    last_head = self.available_heads[-1]
+                    logging.warning(
+                        f"Head {self.head} not found in available heads {self.available_heads}, defaulting to the last head: {last_head}"
+                    )
+                    self.head = last_head
+        elif len(self.available_heads) == 1:
+            self.head = self.available_heads[0]
+        else:
+            self.head = [
+                head for head in self.available_heads if head.lower() == "default"
+            ]
+            if len(self.head) == 0:
+                raise ValueError(
+                    "Head keyword was not provided, and no head in the model is 'default'. "
+                    "Please provide a head keyword to specify the head you want to use. "
+                    f"Available heads are: {self.available_heads}"
+                )
+            self.head = self.head[0]
+
+        logging.info(f"Using head {self.head} out of  {self.available_heads}")
+
+        model_dtype = get_model_dtype(self.models[0])
+        if default_dtype == "":
+            logging.warning(
+                f"No dtype selected, switching to {model_dtype} to match model dtype."
+            )
+            default_dtype = model_dtype
+        if model_dtype != default_dtype:
+            logging.warning(
+                f"Default dtype {default_dtype} does not match model dtype {model_dtype}, converting models to {default_dtype}."
+            )
+            if default_dtype == "float64":
+                self.models = [model.double() for model in self.models]
+            elif default_dtype == "float32":
+                self.models = [model.float() for model in self.models]
+        torch_tools.set_default_dtype(default_dtype)
+        if enable_cueq:
+            logging.info("Converting models to CuEq for acceleration")
+            self.models = [
+                run_e3nn_to_cueq(model, device=device).to(device)
+                for model in self.models
+            ]
+        if enable_oeq:
+            logging.info("Converting models to OEq for acceleration")
+            self.models = [
+                run_e3nn_to_oeq(model, device=device).to(device)
+                for model in self.models
+            ]
+        for model in self.models:
+            for param in model.parameters():
+                param.requires_grad = False
+
+    def check_state(self, atoms, tol: float = 1e-15) -> list:
+        """
+        Check for any system changes since the last calculation.
+
+        Args:
+            atoms (ase.Atoms): The atomic structure to check.
+            tol (float): Tolerance for detecting changes.
+
+        Returns:
+            list: A list of changes detected in the system.
+        """
+        state = super().check_state(atoms, tol=tol)
+        if (not state) and (self.atoms.info != atoms.info):
+            state.append("info")
+        return state
+
+    def _create_result_tensors(
+        self, num_models: int, num_atoms: int, batch, out: dict
+    ) -> dict:
+        # unfortunately, code is expecting shape that isn't always same as underlying model
+        # output tensor shape, e.g. stress is returned as 1x3x3 and we want 3x3
+        tensor_shapes = {
+            "energy": [],
+            "node_energy": [num_atoms],
+            "forces": [num_atoms, 3],
+            "stress": [3, 3],
+            "atomic_stresses": [num_atoms, 3, 3],
+            "atomic_virials": [num_atoms, 3, 3],
+            "dipole": [3],
+            "charges": [num_atoms],
+            "polarizability": [3, 3],
+            "polarizability_sh": [6],
+        }
+        dict_of_tensors = {}
+        for key in out:
+            if key not in tensor_shapes or out.get(key) is None:
+                continue
+            shape = [num_models] + tensor_shapes[key]
+            dict_of_tensors[key] = torch.zeros(*shape, device=self.device)
+
+        node_e0 = None
+        if "node_energy" in out:
+            node_heads = batch["head"][batch["batch"]]
+            num_atoms_arange = torch.arange(batch["positions"].shape[0])
+            node_e0 = (
+                self.models[0]
+                .atomic_energies_fn(batch["node_attrs"])[num_atoms_arange, node_heads]
+                .detach()
+                .cpu()
+                .numpy()
+            )
+
+        return dict_of_tensors, node_e0
+
+    def _atoms_to_batch(self, atoms):
+        self.arrays_keys.update({self.charges_key: "charges"})
+        keyspec = mace_data.KeySpecification(
+            info_keys=self.info_keys, arrays_keys=self.arrays_keys
+        )
+        config = mace_data.config_from_atoms(
+            atoms, key_specification=keyspec, head_name=self.head
+        )
+
+        
+        data_loader = torch_geometric.dataloader.DataLoader(
+            dataset=[
+                mace_data.AtomicData.from_config(
+                    config,
+                    z_table=self.z_table,
+                    cutoff=self.r_max,
+                    heads=self.available_heads,
+                )
+            ],
+            batch_size=1,
+            shuffle=False,
+            drop_last=False,
+        )
+        batch = next(iter(data_loader)).to(self.device)
+        return batch
+
+    def _clone_batch(self, batch):
+        batch_clone = batch.clone()
+        if self.use_compile:
+            batch_clone["node_attrs"].requires_grad_(True)
+            batch_clone["positions"].requires_grad_(True)
+        return batch_clone
+
+    # pylint: disable=dangerous-default-value
+    def calculate(self, atoms=None, properties=None, system_changes=all_changes):
+        """
+        Calculate properties.
+        :param atoms: ase.Atoms object
+        :param properties: [str], properties to be computed, used by ASE internally
+        :param system_changes: [str], system changes since last calculation, used by ASE internally
+        :return:
+        """
+        # call to base-class to set atoms attribute
+        Calculator.calculate(self, atoms)
+
+
+        batch_base = self._atoms_to_batch(atoms)
+
+        if self.model_type in ["MACE", "EnergyDipoleMACE"]:
+            compute_stress = not self.use_compile
+        else:
+            compute_stress = False
+
+        ret_tensors = None
+        node_e0 = None
+        
+
+        # copy from output of model() call to ret_tensors
+        for i, model in enumerate(self.models):
+            batch = self._clone_batch(batch_base)
+            #print(type(model)) # Scale shift mace
+            out = model(
+                batch.to_dict(),
+                compute_stress=compute_stress, # Fakse
+                compute_force = True,
+                training=self.use_compile, #false
+                compute_edge_forces=self.compute_atomic_stresses, #False
+                compute_atomic_stresses=self.compute_atomic_stresses, # False
+            )
+            if i == 0:
+                ret_tensors, node_e0 = self._create_result_tensors(
+                    self.num_models, len(atoms), batch, out
+                )
+            for key, val in ret_tensors.items():
+                if out.get(key) is not None:
+                    val[i] = out[key].detach()
+
+        # covert from ret_tensors to calculator results dict
+        self.results = {}
+        scalar_tensors = set(["energy"])
+        results_store_ensemble = set(["energy", "forces", "stress", "dipole"])
+        for results_key, ret_key, unit_conv in [
+            ("energy", "energy", self.energy_units_to_eV),
+            ("node_energy", "node_energy", self.energy_units_to_eV),
+            ("forces", "forces", self.energy_units_to_eV / self.length_units_to_A),
+            ("stress", "stress", self.energy_units_to_eV / self.length_units_to_A**3),
+            (
+                "stresses",
+                "atomic_stresses",
+                self.energy_units_to_eV / self.length_units_to_A**3,
+            ),
+            (
+                "virials",
+                "atomic_virials",
+                self.energy_units_to_eV / self.length_units_to_A**3,
+            ),
+            ("dipole", "dipole", 1.0),
+            ("charges", "charges", 1.0),
+            ("polarizability", "polarizability", 1.0),
+            ("polarizability_sh", "polarizability_sh", 1.0),
+        ]:
+            if ret_tensors.get(ret_key) is not None:
+                data = torch.mean(ret_tensors[ret_key], dim=0).cpu()
+                if ret_key in scalar_tensors:
+                    data = data.item()
+                else:
+                    data = data.numpy()
+                self.results[results_key] = data * unit_conv
+
+                if self.num_models > 1 and results_key in results_store_ensemble:
+                    data = ret_tensors[results_key].cpu().numpy()
+                    data *= unit_conv
+                    self.results[results_key + "_comm"] = data
+
+                    data = torch.var(
+                        ret_tensors[results_key], dim=0, unbiased=False
+                    ).cpu()
+                    if ret_key in scalar_tensors:
+                        data = data.item()
+                    else:
+                        data = data.numpy()
+                    data *= unit_conv
+                    self.results[results_key + "_var"] = data
+
+        # special cases
+        if self.results.get("energy") is not None:
+            self.results["free_energy"] = self.results["energy"]
+        if self.results.get("node_energy") is not None:
+            self.results["energies"] = self.results["node_energy"].copy()
+            self.results["node_energy"] -= node_e0
+        if self.results.get("stress") is not None:
+            self.results["stress"] = full_3x3_to_voigt_6_stress(self.results["stress"])
+        if self.results.get("stresses") is not None:
+            self.results["stresses"] = np.asarray(
+                [
+                    full_3x3_to_voigt_6_stress(stress)
+                    for stress in self.results["stresses"]
+                ]
+            )
+
+    def get_dielectric_derivatives(self, atoms=None):
+        if atoms is None and self.atoms is None:
+            raise ValueError("atoms not set")
+        if atoms is None:
+            atoms = self.atoms
+        if self.model_type not in ["DipoleMACE", "DipolePolarizabilityMACE"]:
+            raise NotImplementedError(
+                "Only implemented for DipoleMACE or DipolePolarizabilityMACE models"
+            )
+        batch = self._atoms_to_batch(atoms)
+        outputs = [
+            model(
+                self._clone_batch(batch).to_dict(),
+                compute_dielectric_derivatives=True,
+                training=self.use_compile,
+            )
+            for model in self.models
+        ]
+        dipole_derivatives = [
+            output["dmu_dr"].clone().detach().cpu().numpy() for output in outputs
+        ]
+        if self.models[0].use_polarizability:
+            polarizability_derivatives = [
+                output["dalpha_dr"].clone().detach().cpu().numpy() for output in outputs
+            ]
+            if self.num_models == 1:
+                dipole_derivatives = dipole_derivatives[0]
+                polarizability_derivatives = polarizability_derivatives[0]
+            del outputs, batch, atoms
+            return dipole_derivatives, polarizability_derivatives
+        if self.num_models == 1:
+            return dipole_derivatives[0]
+        del outputs, batch, atoms
+        return dipole_derivatives
+
+    def get_hessian(self, atoms=None):
+        if atoms is None and self.atoms is None:
+            raise ValueError("atoms not set")
+        if atoms is None:
+            atoms = self.atoms
+        if self.model_type != "MACE":
+            raise NotImplementedError("Only implemented for MACE models")
+        batch = self._atoms_to_batch(atoms)
+        hessians = [
+            model(
+                self._clone_batch(batch).to_dict(),
+                compute_hessian=True,
+                compute_stress=False,
+                training=self.use_compile,
+            )["hessian"]
+            for model in self.models
+        ]
+        hessians = [hessian.detach().cpu().numpy() for hessian in hessians]
+        if self.num_models == 1:
+            return hessians[0]
+        return hessians
+
+    def get_descriptors(self, atoms=None, invariants_only=True, num_layers=-1):
+        """Extracts the descriptors from MACE model.
+        :param atoms: ase.Atoms object
+        :param invariants_only: bool, if True only the invariant descriptors are returned
+        :param num_layers: int, number of layers to extract descriptors from, if -1 all layers are used
+        :return: np.ndarray (num_atoms, num_interactions, invariant_features) of invariant descriptors if num_models is 1 or list[np.ndarray] otherwise
+        """
+        if atoms is None and self.atoms is None:
+            raise ValueError("atoms not set")
+        if atoms is None:
+            atoms = self.atoms
+        if self.model_type != "MACE":
+            raise NotImplementedError("Only implemented for MACE models")
+        num_interactions = int(self.models[0].num_interactions)
+        if num_layers == -1:
+            num_layers = num_interactions
+        batch = self._atoms_to_batch(atoms)
+        descriptors = [model(batch.to_dict())["node_feats"] for model in self.models]
+
+        irreps_out = o3.Irreps(str(self.models[0].products[0].linear.irreps_out))
+        l_max = irreps_out.lmax
+        num_invariant_features = irreps_out.dim // (l_max + 1) ** 2
+        per_layer_features = [irreps_out.dim for _ in range(num_interactions)]
+        per_layer_features[-1] = (
+            num_invariant_features  # Equivariant features not created for the last layer
+        )
+
+        if invariants_only:
+            descriptors = [
+                extract_invariant(
+                    descriptor,
+                    num_layers=num_layers,
+                    num_features=num_invariant_features,
+                    l_max=l_max,
+                )
+                for descriptor in descriptors
+            ]
+        to_keep = np.sum(per_layer_features[:num_layers])
+        descriptors = [
+            descriptor[:, :to_keep].detach().cpu().numpy() for descriptor in descriptors
+        ]
+
+        if self.num_models == 1:
+            return descriptors[0]
+        return descriptors

models/mace/mace/cli/active_learning_md.py

@@ -0,0 +1,193 @@
+"""Demonstrates active learning molecular dynamics with constant temperature."""
+
+import argparse
+import os
+import time
+
+import ase.io
+import numpy as np
+from ase import units
+from ase.md.langevin import Langevin
+from ase.md.velocitydistribution import MaxwellBoltzmannDistribution
+
+from mace.calculators.mace import MACECalculator
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument("--config", help="path to XYZ configurations", required=True)
+    parser.add_argument(
+        "--config_index", help="index of configuration", type=int, default=-1
+    )
+    parser.add_argument(
+        "--error_threshold", help="error threshold", type=float, default=0.1
+    )
+    parser.add_argument("--temperature_K", help="temperature", type=float, default=300)
+    parser.add_argument("--friction", help="friction", type=float, default=0.01)
+    parser.add_argument("--timestep", help="timestep", type=float, default=1)
+    parser.add_argument("--nsteps", help="number of steps", type=int, default=1000)
+    parser.add_argument(
+        "--nprint", help="number of steps between prints", type=int, default=10
+    )
+    parser.add_argument(
+        "--nsave", help="number of steps between saves", type=int, default=10
+    )
+    parser.add_argument(
+        "--ncheckerror", help="number of steps between saves", type=int, default=10
+    )
+
+    parser.add_argument(
+        "--model",
+        help="path to model. Use wildcards to add multiple models as committee eg "
+        "(`mace_*.model` to load mace_1.model, mace_2.model) ",
+        required=True,
+    )
+    parser.add_argument("--output", help="output path", required=True)
+    parser.add_argument(
+        "--device",
+        help="select device",
+        type=str,
+        choices=["cpu", "cuda"],
+        default="cuda",
+    )
+    parser.add_argument(
+        "--default_dtype",
+        help="set default dtype",
+        type=str,
+        choices=["float32", "float64"],
+        default="float64",
+    )
+    parser.add_argument(
+        "--compute_stress",
+        help="compute stress",
+        action="store_true",
+        default=False,
+    )
+    parser.add_argument(
+        "--info_prefix",
+        help="prefix for energy, forces and stress keys",
+        type=str,
+        default="MACE_",
+    )
+    return parser.parse_args()
+
+
+def printenergy(dyn, start_time=None):  # store a reference to atoms in the definition.
+    """Function to print the potential, kinetic and total energy."""
+    a = dyn.atoms
+    epot = a.get_potential_energy() / len(a)
+    ekin = a.get_kinetic_energy() / len(a)
+    if start_time is None:
+        elapsed_time = 0
+    else:
+        elapsed_time = time.time() - start_time
+    forces_var = np.var(a.calc.results["forces_comm"], axis=0)
+    print(
+        "%.1fs: Energy per atom: Epot = %.3feV  Ekin = %.3feV (T=%3.0fK)  "  # pylint: disable=C0209
+        "Etot = %.3feV t=%.1ffs Eerr = %.3feV Ferr = %.3feV/A"
+        % (
+            elapsed_time,
+            epot,
+            ekin,
+            ekin / (1.5 * units.kB),
+            epot + ekin,
+            dyn.get_time() / units.fs,
+            a.calc.results["energy_var"],
+            np.max(np.linalg.norm(forces_var, axis=1)),
+        ),
+        flush=True,
+    )
+
+
+def save_config(dyn, fname):
+    atomsi = dyn.atoms
+    ens = atomsi.get_potential_energy()
+    frcs = atomsi.get_forces()
+
+    atomsi.info.update(
+        {
+            "mlff_energy": ens,
+            "time": np.round(dyn.get_time() / units.fs, 5),
+            "mlff_energy_var": atomsi.calc.results["energy_var"],
+        }
+    )
+    atomsi.arrays.update(
+        {
+            "mlff_forces": frcs,
+            "mlff_forces_var": np.var(atomsi.calc.results["forces_comm"], axis=0),
+        }
+    )
+
+    ase.io.write(fname, atomsi, append=True)
+
+
+def stop_error(dyn, threshold, reg=0.2):
+    atomsi = dyn.atoms
+    force_var = np.var(atomsi.calc.results["forces_comm"], axis=0)
+    force = atomsi.get_forces()
+    ferr = np.sqrt(np.sum(force_var, axis=1))
+    ferr_rel = ferr / (np.linalg.norm(force, axis=1) + reg)
+
+    if np.max(ferr_rel) > threshold:
+        print(
+            "Error too large {:.3}. Stopping t={:.2} fs.".format(  # pylint: disable=C0209
+                np.max(ferr_rel), dyn.get_time() / units.fs
+            ),
+            flush=True,
+        )
+        dyn.max_steps = 0
+
+
+def main() -> None:
+    args = parse_args()
+    run(args)
+
+
+def run(args: argparse.Namespace) -> None:
+    mace_fname = args.model
+    atoms_fname = args.config
+    atoms_index = args.config_index
+
+    mace_calc = MACECalculator(
+        model_paths=mace_fname,
+        device=args.device,
+        default_dtype=args.default_dtype,
+    )
+
+    NSTEPS = args.nsteps
+
+    if os.path.exists(args.output):
+        print("Trajectory exists. Continuing from last step.")
+        atoms = ase.io.read(args.output, index=-1)
+        len_save = len(ase.io.read(args.output, ":"))
+        print("Last step: ", atoms.info["time"], "Number of configs: ", len_save)
+        NSTEPS -= len_save * args.nsave
+    else:
+        atoms = ase.io.read(atoms_fname, index=atoms_index)
+        MaxwellBoltzmannDistribution(atoms, temperature_K=args.temperature_K)
+
+    atoms.calc = mace_calc
+
+    # We want to run MD with constant energy using the Langevin algorithm
+    # with a time step of 5 fs, the temperature T and the friction
+    # coefficient to 0.02 atomic units.
+    dyn = Langevin(
+        atoms=atoms,
+        timestep=args.timestep * units.fs,
+        temperature_K=args.temperature_K,
+        friction=args.friction,
+    )
+
+    dyn.attach(printenergy, interval=args.nsave, dyn=dyn, start_time=time.time())
+    dyn.attach(save_config, interval=args.nsave, dyn=dyn, fname=args.output)
+    dyn.attach(
+        stop_error, interval=args.ncheckerror, dyn=dyn, threshold=args.error_threshold
+    )
+    # Now run the dynamics
+    dyn.run(NSTEPS)
+
+
+if __name__ == "__main__":
+    main()

models/mace/mace/cli/convert_cueq_e3nn.py

@@ -0,0 +1,259 @@
+import argparse
+import logging
+import os
+from typing import Dict, List, Tuple, Union
+
+import numpy as np
+import torch
+from e3nn import o3
+
+from mace.tools.cg import O3_e3nn
+from mace.tools.cg_cueq_tools import symmetric_contraction_proj
+from mace.tools.scripts_utils import extract_config_mace_model
+
+try:
+    import cuequivariance as cue
+
+    CUEQQ_AVAILABLE = True
+except (ImportError, ModuleNotFoundError):
+    CUEQQ_AVAILABLE = False
+    cue = None
+
+SizeLike = Union[torch.Size, List[int]]
+
+
+def shapes_match_up_to_unsqueeze(a: SizeLike, b: SizeLike) -> bool:
+    if isinstance(a, torch.Tensor):
+        a = a.shape
+    if isinstance(b, torch.Tensor):
+        b = b.shape
+
+    def drop(s):
+        return tuple(d for d in s if d != 1)
+
+    return drop(a) == drop(b)
+
+
+def reshape_like(src: torch.Tensor, ref_shape: torch.Size) -> torch.Tensor:
+    try:
+        return src.reshape(ref_shape)
+    except RuntimeError:
+        return src.clone().reshape(ref_shape)
+
+
+def get_kmax_pairs(
+    num_product_irreps: int, correlation: int, num_layers: int
+) -> List[Tuple[int, int]]:
+    """Determine kmax pairs based on num_product_irreps and correlation"""
+    if correlation == 2:
+        kmax_pairs = [[i, num_product_irreps] for i in range(num_layers - 1)]
+        kmax_pairs = kmax_pairs + [[num_layers - 1, 0]]
+        return kmax_pairs
+    if correlation == 3:
+        kmax_pairs = [[i, num_product_irreps] for i in range(num_layers - 1)]
+        kmax_pairs = kmax_pairs + [[num_layers - 1, 0]]
+        return kmax_pairs
+    raise NotImplementedError(f"Correlation {correlation} not supported")
+
+
+def transfer_symmetric_contractions(
+    source_dict: Dict[str, torch.Tensor],
+    target_dict: Dict[str, torch.Tensor],
+    num_product_irreps: int,
+    products: torch.nn.Module,
+    correlation: int,
+    num_layers: int,
+    use_reduced_cg: bool,
+):
+    """Transfer symmetric contraction weights from CuEq to E3nn format"""
+    kmax_pairs = get_kmax_pairs(num_product_irreps, correlation, num_layers)
+    suffixes = ["_max"] + [f".{i}" for i in range(correlation - 1)]
+    for i, kmax in kmax_pairs:
+        # Get the combined weight tensor from source
+        irreps_in = o3.Irreps(
+            irrep.ir for irrep in products[i].symmetric_contractions.irreps_in
+        )
+        irreps_out = o3.Irreps(
+            irrep.ir for irrep in products[i].symmetric_contractions.irreps_out
+        )
+        wm = source_dict[f"products.{i}.symmetric_contractions.weight"]
+        if use_reduced_cg:
+            _, proj = symmetric_contraction_proj(
+                cue.Irreps(O3_e3nn, str(irreps_in)),
+                cue.Irreps(O3_e3nn, str(irreps_out)),
+                list(range(1, correlation + 1)),
+            )
+            proj = np.linalg.pinv(proj)
+            proj = torch.tensor(proj, dtype=wm.dtype, device=wm.device)
+            wm = torch.einsum("zau,ab->zbu", wm, proj)
+        # Get split sizes based on target dimensions
+        splits = []
+        for k in range(kmax + 1):
+            for suffix in suffixes:
+                key = f"products.{i}.symmetric_contractions.contractions.{k}.weights{suffix}"
+                target_shape = target_dict[key].shape
+                splits.append(target_shape[1])
+                if (
+                    target_dict.get(
+                        f"products.{i}.symmetric_contractions.contractions.{k}.weights{suffix.replace('.', '_')}"
+                        + "_zeroed",
+                        False,
+                    )
+                    and not use_reduced_cg
+                ):
+                    splits[-1] = 0
+
+        # Split the weights using the calculated sizes
+        weights_split = torch.split(wm, splits, dim=1)
+
+        # Assign back to target dictionary
+        idx = 0
+        for k in range(kmax + 1):
+            for suffix in suffixes:
+                key = f"products.{i}.symmetric_contractions.contractions.{k}.weights{suffix}"
+                if (
+                    target_dict.get(
+                        f"products.{i}.symmetric_contractions.contractions.{k}.weights{suffix.replace('.', '_')}_zeroed",
+                        False,
+                    )
+                    and not use_reduced_cg
+                ):
+                    continue
+                target_dict[key] = (
+                    weights_split[idx] if splits[idx] > 0 else target_dict[key]
+                )
+                idx += 1
+
+
+def transfer_weights(
+    source_model: torch.nn.Module,
+    target_model: torch.nn.Module,
+    num_product_irreps: int,
+    correlation: int,
+    num_layers: int,
+    use_reduced_cg: bool,
+):
+    """Transfer weights from CuEq to E3nn format"""
+    # Get state dicts
+    source_dict = source_model.state_dict()
+    target_dict = target_model.state_dict()
+
+    # Transfer symmetric contractions
+    products = target_model.products
+    transfer_symmetric_contractions(
+        source_dict,
+        target_dict,
+        num_product_irreps,
+        products,
+        correlation,
+        num_layers,
+        use_reduced_cg,
+    )
+
+    # Transfer remaining matching keys
+    transferred_keys = set()
+    remaining_keys = (
+        set(source_dict.keys()) & set(target_dict.keys()) - transferred_keys
+    )
+    remaining_keys = {k for k in remaining_keys if "symmetric_contraction" not in k}
+
+    if remaining_keys:
+        for key in remaining_keys:
+            src = source_dict[key]
+            tgt = target_dict[key]
+            if source_dict[key].shape == target_dict[key].shape:
+                logging.debug(f"Transferring additional key: {key}")
+                target_dict[key] = source_dict[key]
+            elif shapes_match_up_to_unsqueeze(src.shape, tgt.shape):
+                logging.debug(
+                    f"Transferring key {key} after adapting shape "
+                    f"{tuple(src.shape)} → {tuple(tgt.shape)}"
+                )
+                target_dict[key] = reshape_like(src, tgt.shape)
+            else:
+                logging.warning(
+                    f"Shape mismatch for key {key}: "
+                    f"source {source_dict[key].shape} vs target {target_dict[key].shape}"
+                )
+
+    # Transfer avg_num_neighbors
+    for i in range(num_layers):
+        target_model.interactions[i].avg_num_neighbors = source_model.interactions[
+            i
+        ].avg_num_neighbors
+
+    # Load state dict into target model
+    target_model.load_state_dict(target_dict)
+
+
+def run(input_model, output_model="_e3nn.model", device="cpu", return_model=True):
+
+    # Load CuEq model
+    if isinstance(input_model, str):
+        source_model = torch.load(input_model, map_location=device)
+    else:
+        source_model = input_model
+    default_dtype = next(source_model.parameters()).dtype
+    torch.set_default_dtype(default_dtype)
+    # Extract configuration
+    config = extract_config_mace_model(source_model)
+
+    # Get max_L and correlation from config
+    num_product_irreps = len(config["hidden_irreps"].slices()) - 1
+    correlation = config["correlation"]
+    use_reduced_cg = config.get("use_reduced_cg", True)
+
+    # Remove CuEq config
+    config.pop("cueq_config", None)
+
+    # Create new model without CuEq config
+    logging.info("Creating new model without CuEq settings")
+    target_model = source_model.__class__(**config)
+
+    # Transfer weights with proper remapping
+    num_layers = config["num_interactions"]
+    transfer_weights(
+        source_model,
+        target_model,
+        num_product_irreps,
+        correlation,
+        num_layers,
+        use_reduced_cg,
+    )
+
+    if return_model:
+        return target_model
+
+    # Save model
+    if isinstance(input_model, str):
+        base = os.path.splitext(input_model)[0]
+        output_model = f"{base}.{output_model}"
+    logging.warning(f"Saving E3nn model to {output_model}")
+    torch.save(target_model, output_model)
+    return None
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("input_model", help="Path to input CuEq model")
+    parser.add_argument(
+        "--output_model", help="Path to output E3nn model", default="e3nn_model.pt"
+    )
+    parser.add_argument("--device", default="cpu", help="Device to use")
+    parser.add_argument(
+        "--return_model",
+        action="store_false",
+        help="Return model instead of saving to file",
+    )
+    args = parser.parse_args()
+
+    run(
+        input_model=args.input_model,
+        output_model=args.output_model,
+        device=args.device,
+        return_model=args.return_model,
+    )
+
+
+if __name__ == "__main__":
+    main()

models/mace/mace/cli/convert_device.py

@@ -0,0 +1,31 @@
+from argparse import ArgumentParser
+
+import torch
+
+
+def main():
+    parser = ArgumentParser()
+    parser.add_argument(
+        "--target_device",
+        "-t",
+        help="device to convert to, usually 'cpu' or 'cuda'",
+        default="cpu",
+    )
+    parser.add_argument(
+        "--output_file",
+        "-o",
+        help="name for output model, defaults to model_file.target_device",
+    )
+    parser.add_argument("model_file", help="input model file path")
+    args = parser.parse_args()
+
+    if args.output_file is None:
+        args.output_file = args.model_file + "." + args.target_device
+
+    model = torch.load(args.model_file, weights_only=False)
+    model.to(args.target_device)
+    torch.save(model, args.output_file)
+
+
+if __name__ == "__main__":
+    main()

models/mace/mace/cli/convert_e3nn_cueq.py

@@ -0,0 +1,258 @@
+import argparse
+import logging
+import os
+from typing import Dict, List, Tuple, Union
+
+import torch
+from e3nn import o3
+
+from mace.modules.wrapper_ops import CuEquivarianceConfig
+from mace.tools.cg import O3_e3nn
+from mace.tools.cg_cueq_tools import symmetric_contraction_proj
+from mace.tools.scripts_utils import extract_config_mace_model
+
+try:
+    import cuequivariance as cue
+
+    CUEQQ_AVAILABLE = True
+except (ImportError, ModuleNotFoundError):
+    CUEQQ_AVAILABLE = False
+    cue = None
+
+SizeLike = Union[torch.Size, List[int]]
+
+
+def shapes_match_up_to_unsqueeze(a: SizeLike, b: SizeLike) -> bool:
+    if isinstance(a, torch.Tensor):
+        a = a.shape
+    if isinstance(b, torch.Tensor):
+        b = b.shape
+
+    def drop(s):
+        return tuple(d for d in s if d != 1)
+
+    return drop(a) == drop(b)
+
+
+def reshape_like(src: torch.Tensor, ref_shape: torch.Size) -> torch.Tensor:
+    try:
+        return src.reshape(ref_shape)
+    except RuntimeError:
+        return src.clone().reshape(ref_shape)
+
+
+def get_kmax_pairs(
+    num_product_irreps: int, correlation: int, num_layers: int
+) -> List[Tuple[int, int]]:
+    """Determine kmax pairs based on num_product_irreps and correlation"""
+    if correlation == 2:
+        kmax_pairs = [[i, num_product_irreps] for i in range(num_layers - 1)]
+        kmax_pairs = kmax_pairs + [[num_layers - 1, 0]]
+        return kmax_pairs
+    if correlation == 3:
+        kmax_pairs = [[i, num_product_irreps] for i in range(num_layers - 1)]
+        kmax_pairs = kmax_pairs + [[num_layers - 1, 0]]
+        return kmax_pairs
+    raise NotImplementedError(f"Correlation {correlation} not supported")
+
+
+def transfer_symmetric_contractions(
+    source_dict: Dict[str, torch.Tensor],
+    target_dict: Dict[str, torch.Tensor],
+    num_product_irreps: int,
+    products: torch.nn.Module,
+    correlation: int,
+    num_layers: int,
+    use_reduced_cg: bool,
+):
+    """Transfer symmetric contraction weights"""
+    kmax_pairs = get_kmax_pairs(num_product_irreps, correlation, num_layers)
+    suffixes = ["_max"] + [f".{i}" for i in range(correlation - 1)]
+    for i, kmax in kmax_pairs:
+        irreps_in = o3.Irreps(
+            irrep.ir for irrep in products[i].symmetric_contractions.irreps_in
+        )
+        irreps_out = o3.Irreps(
+            irrep.ir for irrep in products[i].symmetric_contractions.irreps_out
+        )
+        if use_reduced_cg:
+            wm = torch.concatenate(
+                [
+                    source_dict[
+                        f"products.{i}.symmetric_contractions.contractions.{k}.weights{j}"
+                    ]
+                    for k in range(kmax + 1)
+                    for j in suffixes
+                ],
+                dim=1,
+            )
+        else:
+            wm = torch.concatenate(
+                [
+                    source_dict[
+                        f"products.{i}.symmetric_contractions.contractions.{k}.weights{j}"
+                    ]
+                    for k in range(kmax + 1)
+                    for j in suffixes
+                    if not source_dict.get(
+                        f"products.{i}.symmetric_contractions.contractions.{k}.weights{j.replace('.', '_')}_zeroed",
+                        False,
+                    )
+                ],
+                dim=1,
+            )
+        if use_reduced_cg:
+            _, proj = symmetric_contraction_proj(
+                cue.Irreps(O3_e3nn, str(irreps_in)),
+                cue.Irreps(O3_e3nn, str(irreps_out)),
+                list(range(1, correlation + 1)),
+            )
+            proj = torch.tensor(proj, dtype=wm.dtype, device=wm.device)
+            wm = torch.einsum("zau,ab->zbu", wm, proj)
+        target_dict[f"products.{i}.symmetric_contractions.weight"] = wm
+
+
+def transfer_weights(
+    source_model: torch.nn.Module,
+    target_model: torch.nn.Module,
+    num_product_irreps: int,
+    correlation: int,
+    num_layers: int,
+    use_reduced_cg: bool,
+):
+    """Transfer weights with proper remapping"""
+    # Get source state dict
+    source_dict = source_model.state_dict()
+    target_dict = target_model.state_dict()
+
+    products = source_model.products
+    # Transfer symmetric contractions
+    transfer_symmetric_contractions(
+        source_dict,
+        target_dict,
+        num_product_irreps,
+        products,
+        correlation,
+        num_layers,
+        use_reduced_cg,
+    )
+
+    transferred_keys = set()
+    remaining_keys = (
+        set(source_dict.keys()) & set(target_dict.keys()) - transferred_keys
+    )
+    remaining_keys = {k for k in remaining_keys if "symmetric_contraction" not in k}
+    if remaining_keys:
+        for key in remaining_keys:
+            src = source_dict[key]
+            tgt = target_dict[key]
+            if source_dict[key].shape == target_dict[key].shape:
+                logging.debug(f"Transferring additional key: {key}")
+                target_dict[key] = source_dict[key]
+            elif shapes_match_up_to_unsqueeze(src.shape, tgt.shape):
+                logging.debug(
+                    f"Transferring key {key} after adapting shape "
+                    f"{tuple(src.shape)} → {tuple(tgt.shape)} -> {reshape_like(src, tgt.shape).shape}"
+                )
+                target_dict[key] = reshape_like(src, tgt.shape)
+            else:
+                logging.debug(
+                    f"Shape mismatch for key {key}: "
+                    f"source {source_dict[key].shape} vs target {target_dict[key].shape}"
+                )
+    # Transfer avg_num_neighbors
+    for i in range(num_layers):
+        target_model.interactions[i].avg_num_neighbors = source_model.interactions[
+            i
+        ].avg_num_neighbors
+
+    # Load state dict into target model
+    target_model.load_state_dict(target_dict)
+
+
+def run(
+    input_model,
+    output_model="_cueq.model",
+    device="cpu",
+    return_model=True,
+):
+    # Setup logging
+
+    # Load original model
+    # logging.warning(f"Loading model")
+    # check if input_model is a path or a model
+    if isinstance(input_model, str):
+        source_model = torch.load(input_model, map_location=device)
+    else:
+        source_model = input_model
+    default_dtype = next(source_model.parameters()).dtype
+    torch.set_default_dtype(default_dtype)
+    # Extract configuration
+    config = extract_config_mace_model(source_model)
+
+    # Get max_L and correlation from config
+    num_product_irreps = len(config["hidden_irreps"].slices()) - 1
+    correlation = config["correlation"]
+    use_reduced_cg = config.get("use_reduced_cg", True)
+
+    # Add cuequivariance config
+    config["cueq_config"] = CuEquivarianceConfig(
+        enabled=True,
+        layout="ir_mul",
+        group="O3_e3nn",
+        optimize_all=True,
+        conv_fusion=(device == "cuda"),
+    )
+
+    # Create new model with cuequivariance config
+    logging.info("Creating new model with cuequivariance settings")
+    target_model = source_model.__class__(**config).to(device)
+
+    # Transfer weights with proper remapping
+    num_layers = config["num_interactions"]
+    transfer_weights(
+        source_model,
+        target_model,
+        num_product_irreps,
+        correlation,
+        num_layers,
+        use_reduced_cg,
+    )
+
+    if return_model:
+        return target_model
+
+    if isinstance(input_model, str):
+        base = os.path.splitext(input_model)[0]
+        output_model = f"{base}.{output_model}"
+    logging.warning(f"Saving CuEq model to {output_model}")
+    torch.save(target_model, output_model)
+    return None
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("input_model", help="Path to input MACE model")
+    parser.add_argument(
+        "--output_model",
+        help="Path to output cuequivariance model",
+        default="cueq_model.pt",
+    )
+    parser.add_argument("--device", default="cpu", help="Device to use")
+    parser.add_argument(
+        "--return_model",
+        action="store_false",
+        help="Return model instead of saving to file",
+    )
+    args = parser.parse_args()
+
+    run(
+        input_model=args.input_model,
+        output_model=args.output_model,
+        device=args.device,
+        return_model=args.return_model,
+    )
+
+
+if __name__ == "__main__":
+    main()

models/mace/mace/cli/convert_e3nn_oeq.py

@@ -0,0 +1,89 @@
+import argparse
+import logging
+import os
+
+import torch
+
+from mace.modules.wrapper_ops import OEQConfig
+from mace.tools.scripts_utils import extract_config_mace_model
+
+
+def run(
+    input_model,
+    output_model="_oeq.model",
+    device="cpu",
+    return_model=True,
+):
+    # Setup logging
+
+    # Load original model
+    # logging.warning(f"Loading model")
+    # check if input_model is a path or a model
+    if isinstance(input_model, str):
+        source_model = torch.load(input_model, map_location=device)
+    else:
+        source_model = input_model
+    default_dtype = next(source_model.parameters()).dtype
+    torch.set_default_dtype(default_dtype)
+
+    config = extract_config_mace_model(source_model)
+
+    # Add OEQ config
+    config["oeq_config"] = OEQConfig(
+        enabled=False, optimize_all=True, conv_fusion="atomic"
+    )
+
+    # Create new model with oeq config
+    logging.info("Creating new model with openequivariance settings")
+    target_model = source_model.__class__(**config).to(device)
+    source_dict = source_model.state_dict()
+    target_dict = target_model.state_dict()
+
+    for key in target_dict:
+        if ".conv_tp." not in key:
+            target_dict[key] = source_dict[key]
+
+    target_model.load_state_dict(target_dict)
+
+    for i in range(2):
+        target_model.interactions[i].avg_num_neighbors = source_model.interactions[
+            i
+        ].avg_num_neighbors
+
+    if return_model:
+        return target_model
+
+    if isinstance(input_model, str):
+        base = os.path.splitext(input_model)[0]
+        output_model = f"{base}.{output_model}"
+    logging.warning(f"Saving OEQ model to {output_model}")
+    torch.save(target_model, output_model)
+    return None
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("input_model", help="Path to input MACE model")
+    parser.add_argument(
+        "--output_model",
+        help="Path to output openequviariance model",
+        default="oeq_model.pt",
+    )
+    parser.add_argument("--device", default="cpu", help="Device to use")
+    parser.add_argument(
+        "--return_model",
+        action="store_false",
+        help="Return model instead of saving to file",
+    )
+    args = parser.parse_args()
+
+    run(
+        input_model=args.input_model,
+        output_model=args.output_model,
+        device=args.device,
+        return_model=args.return_model,
+    )
+
+
+if __name__ == "__main__":
+    main()

models/mace/mace/cli/convert_oeq_e3nn.py

@@ -0,0 +1,78 @@
+import argparse
+import logging
+import os
+
+import torch
+
+from mace.tools.scripts_utils import extract_config_mace_model
+
+
+def run(input_model, output_model="_e3nn.model", device="cpu", return_model=True):
+    # Load OEQ model
+    if isinstance(input_model, str):
+        source_model = torch.load(input_model, map_location=device)
+    else:
+        source_model = input_model
+    default_dtype = next(source_model.parameters()).dtype
+    torch.set_default_dtype(default_dtype)
+    # Extract configuration
+    config = extract_config_mace_model(source_model)
+
+    # Remove OEQ config
+    config.pop("oeq_config", None)
+
+    # Create new model without CuEq config
+    logging.info("Creating new model without OEQ settings")
+    target_model = source_model.__class__(**config).to(device)
+
+    source_dict = source_model.state_dict()
+    target_dict = target_model.state_dict()
+
+    for key in source_dict:
+        if ".conv_tp." not in key:
+            target_dict[key] = source_dict[key]
+
+    for i in range(2):
+
+        target_model.interactions[i].avg_num_neighbors = source_model.interactions[
+            i
+        ].avg_num_neighbors
+
+    target_model.load_state_dict(target_dict)
+
+    if return_model:
+        return target_model
+
+    # Save model
+    if isinstance(input_model, str):
+        base = os.path.splitext(input_model)[0]
+        output_model = f"{base}.{output_model}"
+    logging.warning(f"Saving E3nn model to {output_model}")
+    torch.save(target_model, output_model)
+    return None
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("input_model", help="Path to input oeq model")
+    parser.add_argument(
+        "--output_model", help="Path to output E3nn model", default="e3nn_model.pt"
+    )
+    parser.add_argument("--device", default="cpu", help="Device to use")
+    parser.add_argument(
+        "--return_model",
+        action="store_false",
+        help="Return model instead of saving to file",
+    )
+    args = parser.parse_args()
+
+    run(
+        input_model=args.input_model,
+        output_model=args.output_model,
+        device=args.device,
+        return_model=args.return_model,
+    )
+
+
+if __name__ == "__main__":
+    main()

models/mace/mace/cli/create_lammps_model.py

@@ -0,0 +1,114 @@
+# pylint: disable=wrong-import-position
+import argparse
+import copy
+import os
+
+os.environ["TORCH_FORCE_NO_WEIGHTS_ONLY_LOAD"] = "1"
+
+import torch
+from e3nn.util import jit
+
+from mace.calculators import LAMMPS_MACE
+from mace.calculators.lammps_mliap_mace import LAMMPS_MLIAP_MACE
+from mace.cli.convert_e3nn_cueq import run as run_e3nn_to_cueq
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument(
+        "model_path",
+        type=str,
+        help="Path to the model to be converted to LAMMPS",
+    )
+    parser.add_argument(
+        "--head",
+        type=str,
+        nargs="?",
+        help="Head of the model to be converted to LAMMPS",
+        default=None,
+    )
+    parser.add_argument(
+        "--dtype",
+        type=str,
+        nargs="?",
+        help="Data type of the model to be converted to LAMMPS",
+        default="float64",
+    )
+    parser.add_argument(
+        "--format",
+        type=str,
+        help="Old libtorch format, or new mliap format",
+        default="libtorch",
+    )
+    return parser.parse_args()
+
+
+def select_head(model):
+    if hasattr(model, "heads"):
+        heads = model.heads
+    else:
+        heads = [None]
+
+    if len(heads) == 1:
+        print(f"Only one head found in the model: {heads[0]}. Skipping selection.")
+        return heads[0]
+
+    print("Available heads in the model:")
+    for i, head in enumerate(heads):
+        print(f"{i + 1}: {head}")
+
+    # Ask the user to select a head
+    selected = input(
+        f"Select a head by number (Defaulting to head: {len(heads)}, press Enter to accept): "
+    )
+
+    if selected.isdigit() and 1 <= int(selected) <= len(heads):
+        return heads[int(selected) - 1]
+    if selected == "":
+        print("No head selected. Proceeding without specifying a head.")
+        return None
+    print(f"No valid selection made. Defaulting to the last head: {heads[-1]}")
+    return heads[-1]
+
+
+def main():
+    args = parse_args()
+    model_path = args.model_path  # takes model name as command-line input
+    model = torch.load(
+        model_path,
+        map_location=torch.device("cuda" if torch.cuda.is_available() else "cpu"),
+    )
+    if args.dtype == "float64":
+        model = model.double().to("cpu")
+    elif args.dtype == "float32":
+        print("Converting model to float32, this may cause loss of precision.")
+        model = model.float().to("cpu")
+
+    if args.format == "mliap":
+        # Enabling cuequivariance by default. TODO: switch?
+        model = run_e3nn_to_cueq(copy.deepcopy(model))
+        model.lammps_mliap = True
+
+    if args.head is None:
+        head = select_head(model)
+    else:
+        head = args.head
+        print(
+            f"Selected head: {head} from command line in the list available heads: {model.heads}"
+        )
+
+    lammps_class = LAMMPS_MLIAP_MACE if args.format == "mliap" else LAMMPS_MACE
+    lammps_model = (
+        lammps_class(model, head=head) if head is not None else lammps_class(model)
+    )
+    if args.format == "mliap":
+        torch.save(lammps_model, model_path + "-mliap_lammps.pt")
+    else:
+        lammps_model_compiled = jit.compile(lammps_model)
+        lammps_model_compiled.save(model_path + "-lammps.pt")
+
+
+if __name__ == "__main__":
+    main()

models/mace/mace/cli/eval_configs.py

@@ -0,0 +1,337 @@
+###########################################################################################
+# Script for evaluating configurations contained in an xyz file with a trained model
+# Authors: Ilyes Batatia, Gregor Simm
+# This program is distributed under the MIT License (see MIT.md)
+###########################################################################################
+
+import argparse
+from typing import Dict
+
+import ase.data
+import ase.io
+import numpy as np
+import torch
+from e3nn import o3
+
+from mace import data
+from mace.cli.convert_e3nn_cueq import run as run_e3nn_to_cueq
+from mace.modules.utils import extract_invariant
+from mace.tools import torch_geometric, torch_tools, utils
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument("--configs", help="path to XYZ configurations", required=True)
+    parser.add_argument("--model", help="path to model", required=True)
+    parser.add_argument("--output", help="output path", required=True)
+    parser.add_argument(
+        "--device",
+        help="select device",
+        type=str,
+        choices=["cpu", "cuda"],
+        default="cpu",
+    )
+    parser.add_argument(
+        "--enable_cueq",
+        help="enable cuequivariance acceleration",
+        action="store_true",
+        default=False,
+    )
+    parser.add_argument(
+        "--default_dtype",
+        help="set default dtype",
+        type=str,
+        choices=["float32", "float64"],
+        default="float64",
+    )
+    parser.add_argument("--batch_size", help="batch size", type=int, default=64)
+    parser.add_argument(
+        "--compute_stress",
+        help="compute stress",
+        action="store_true",
+        default=False,
+    )
+    parser.add_argument(
+        "--compute_bec",
+        help="compute BEC",
+        action="store_true",
+        default=False,
+    )
+    parser.add_argument(
+        "--return_contributions",
+        help="model outputs energy contributions for each body order, only supported for MACE, not ScaleShiftMACE",
+        action="store_true",
+        default=False,
+    )
+    parser.add_argument(
+        "--return_descriptors",
+        help="model outputs MACE descriptors",
+        action="store_true",
+        default=False,
+    )
+    parser.add_argument(
+        "--descriptor_num_layers",
+        help="number of layers to take descriptors from",
+        type=int,
+        default=-1,
+    )
+    parser.add_argument(
+        "--descriptor_aggregation_method",
+        help="method for aggregating node features. None saves descriptors for each atom.",
+        choices=["mean", "per_element_mean", None],
+        default=None,
+    )
+    parser.add_argument(
+        "--descriptor_invariants_only",
+        help="save invariant (l=0) descriptors only",
+        type=bool,
+        default=True,
+    )
+    parser.add_argument(
+        "--return_node_energies",
+        help="model outputs MACE node energies",
+        action="store_true",
+        default=False,
+    )
+    parser.add_argument(
+        "--info_prefix",
+        help="prefix for energy, forces and stress keys",
+        type=str,
+        default="MACE_",
+    )
+    parser.add_argument(
+        "--head",
+        help="Model head used for evaluation",
+        type=str,
+        required=False,
+        default=None,
+    )
+    return parser.parse_args()
+
+
+def get_model_output(
+    model: torch.nn.Module,
+    batch: Dict[str, torch.Tensor],
+    compute_stress: bool,
+    compute_bec: bool,
+) -> Dict[str, torch.Tensor]:
+    forward_args = {
+        "compute_stress": compute_stress,
+    }
+    if compute_bec:
+        # Only add `compute_bec` if it is requested
+        # We check if the model is MACELES at the start of the run function
+        forward_args["compute_bec"] = compute_bec
+    return model(batch, **forward_args)
+
+
+def main() -> None:
+    args = parse_args()
+    run(args)
+
+
+def run(args: argparse.Namespace) -> None:
+    torch_tools.set_default_dtype(args.default_dtype)
+    device = torch_tools.init_device(args.device)
+
+    # Load model
+    model = torch.load(f=args.model, map_location=args.device)
+    if model.__class__.__name__ != "MACELES" and args.compute_bec:
+        raise ValueError("BEC can only be computed with MACELES model. ")
+    if args.enable_cueq:
+        print("Converting models to CuEq for acceleration")
+        model = run_e3nn_to_cueq(model, device=device)
+    #model = model.to(
+    #    args.device
+    #)  # shouldn't be necessary but seems to help with CUDA problems
+
+
+
+
+    for param in model.parameters():
+        param.requires_grad = False
+
+    # Load data and prepare input
+    atoms_list = ase.io.read(args.configs, index=":")
+    if args.head is not None:
+        for atoms in atoms_list:
+            atoms.info["head"] = args.head
+    configs = [data.config_from_atoms(atoms) for atoms in atoms_list]
+
+    z_table = utils.AtomicNumberTable([int(z) for z in model.atomic_numbers])
+
+    try:
+        heads = model.heads
+    except AttributeError:
+        heads = None
+
+    data_loader = torch_geometric.dataloader.DataLoader(
+        dataset=[
+            data.AtomicData.from_config(
+                config, z_table=z_table, cutoff=float(model.r_max), heads=heads
+            )
+            for config in configs
+        ],
+        batch_size=args.batch_size,
+        shuffle=False,
+        drop_last=False,
+    )
+
+
+    # Collect data
+    energies_list = []
+    contributions_list = []
+    descriptors_list = []
+    node_energies_list = []
+    stresses_list = []
+    bec_list = []
+    qs_list = []
+    forces_collection = []
+
+    for batch in data_loader:
+        batch = batch.to(device)
+        output = get_model_output(
+            model, batch.to_dict(), args.compute_stress, args.compute_bec
+        )
+        energies_list.append(torch_tools.to_numpy(output["energy"]))
+        if args.compute_stress:
+            stresses_list.append(torch_tools.to_numpy(output["stress"]))
+        if args.compute_bec:
+            becs = np.split(
+                torch_tools.to_numpy(output["BEC"]),
+                indices_or_sections=batch.ptr[1:],
+                axis=0,
+            )
+            bec_list.append(becs[:-1])  # drop last as its empty
+
+            qs = np.split(
+                torch_tools.to_numpy(output["latent_charges"]),
+                indices_or_sections=batch.ptr[1:],
+                axis=0,
+            )
+            qs_list.append(qs[:-1])  # drop last as its empty
+
+        if args.return_contributions:
+            contributions_list.append(torch_tools.to_numpy(output["contributions"]))
+
+        if args.return_descriptors:
+            num_layers = args.descriptor_num_layers
+            if num_layers == -1:
+                num_layers = int(model.num_interactions)
+            irreps_out = o3.Irreps(str(model.products[0].linear.irreps_out))
+            l_max = irreps_out.lmax
+            num_invariant_features = irreps_out.dim // (l_max + 1) ** 2
+            per_layer_features = [
+                irreps_out.dim for _ in range(int(model.num_interactions))
+            ]
+            per_layer_features[-1] = (
+                num_invariant_features  # Equivariant features not created for the last layer
+            )
+
+            descriptors = output["node_feats"]
+
+            if args.descriptor_invariants_only:
+                descriptors = extract_invariant(
+                    descriptors,
+                    num_layers=num_layers,
+                    num_features=num_invariant_features,
+                    l_max=l_max,
+                )
+
+            to_keep = np.sum(per_layer_features[:num_layers])
+            descriptors = descriptors[:, :to_keep].detach().cpu().numpy()
+
+            descriptors = np.split(
+                descriptors,
+                indices_or_sections=batch.ptr[1:],
+                axis=0,
+            )
+            descriptors_list.extend(descriptors[:-1])  # drop last as its empty
+
+        if args.return_node_energies:
+            node_energies_list.append(
+                np.split(
+                    torch_tools.to_numpy(output["node_energy"]),
+                    indices_or_sections=batch.ptr[1:],
+                    axis=0,
+                )[
+                    :-1
+                ]  # drop last as its empty
+            )
+
+        forces = np.split(
+            torch_tools.to_numpy(output["forces"]),
+            indices_or_sections=batch.ptr[1:],
+            axis=0,
+        )
+        forces_collection.append(forces[:-1])  # drop last as its empty
+
+    energies = np.concatenate(energies_list, axis=0)
+    forces_list = [
+        forces for forces_list in forces_collection for forces in forces_list
+    ]
+    assert len(atoms_list) == len(energies) == len(forces_list)
+    if args.compute_stress:
+        stresses = np.concatenate(stresses_list, axis=0)
+        assert len(atoms_list) == stresses.shape[0]
+
+    if args.compute_bec:
+        bec_list = [becs for sublist in bec_list for becs in sublist]
+        qs_list = [qs for sublist in qs_list for qs in sublist]
+
+    if args.return_contributions:
+        contributions = np.concatenate(contributions_list, axis=0)
+        assert len(atoms_list) == contributions.shape[0]
+
+    if args.return_descriptors:
+        # no concatentation  - elements of descriptors_list have non-uniform shapes
+        assert len(atoms_list) == len(descriptors_list)
+
+    if args.return_node_energies:
+        node_energies = np.concatenate(node_energies_list, axis=0)
+        assert len(atoms_list) == node_energies.shape[0]
+
+    # Store data in atoms objects
+    for i, (atoms, energy, forces) in enumerate(zip(atoms_list, energies, forces_list)):
+        atoms.calc = None  # crucial
+        atoms.info[args.info_prefix + "energy"] = energy
+        atoms.arrays[args.info_prefix + "forces"] = forces
+
+        if args.compute_stress:
+            atoms.info[args.info_prefix + "stress"] = stresses[i]
+
+        if args.compute_bec:
+            atoms.arrays[args.info_prefix + "BEC"] = bec_list[i].reshape(-1, 9)
+            atoms.arrays[args.info_prefix + "latent_charges"] = qs_list[i]
+
+        if args.return_contributions:
+            atoms.info[args.info_prefix + "BO_contributions"] = contributions[i]
+
+        if args.return_descriptors:
+            descriptors = descriptors_list[i]
+            if args.descriptor_aggregation_method:
+                if args.descriptor_aggregation_method == "mean":
+                    descriptors = np.mean(descriptors, axis=0)
+                elif args.descriptor_aggregation_method == "per_element_mean":
+                    descriptors = {
+                        element: np.mean(
+                            descriptors[atoms.symbols == element], axis=0
+                        ).tolist()
+                        for element in np.unique(atoms.symbols)
+                    }
+                atoms.info[args.info_prefix + "descriptors"] = descriptors
+            else:  # args.descriptor_aggregation_method is None
+                # Save descriptors for each atom (default behavior)
+                atoms.arrays[args.info_prefix + "descriptors"] = np.array(descriptors)
+
+        if args.return_node_energies:
+            atoms.arrays[args.info_prefix + "node_energies"] = node_energies[i]
+
+    # Write atoms to output path
+    ase.io.write(args.output, images=atoms_list, format="extxyz")
+
+
+if __name__ == "__main__":
+    main()

models/mace/mace/cli/fine_tuning_select.py

@@ -0,0 +1,529 @@
+###########################################################################################
+# This program is distributed under the MIT License (see MIT.md)
+###########################################################################################
+from __future__ import annotations
+
+import argparse
+import ast
+import logging
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+from typing import List, Tuple, Union
+
+import ase.data
+import ase.io
+import numpy as np
+import torch
+
+from mace.calculators import MACECalculator, mace_mp
+
+try:
+    import fpsample  # type: ignore
+except ImportError:
+    pass
+
+
+class FilteringType(Enum):
+    NONE = "none"
+    COMBINATIONS = "combinations"
+    EXCLUSIVE = "exclusive"
+    INCLUSIVE = "inclusive"
+
+
+class SubselectType(Enum):
+    FPS = "fps"
+    RANDOM = "random"
+
+
+@dataclass
+class SelectionSettings:
+    configs_pt: str
+    output: str
+    configs_ft: str | None = None
+    atomic_numbers: List[int] | None = None
+    num_samples: int | None = None
+    subselect: SubselectType = SubselectType.FPS
+    model: str = "small"
+    descriptors: str | None = None
+    device: str = "cpu"
+    default_dtype: str = "float64"
+    head_pt: str | None = None
+    head_ft: str | None = None
+    filtering_type: FilteringType = FilteringType.COMBINATIONS
+    weight_ft: float = 1.0
+    weight_pt: float = 1.0
+    allow_random_padding: bool = True
+    seed: int = 42
+
+
+def str_to_list(s: str) -> List[int]:
+    assert isinstance(s, str), "Input must be a string"
+    return ast.literal_eval(s)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument(
+        "--configs_pt",
+        help="path to XYZ configurations for the pretraining",
+        required=True,
+    )
+    parser.add_argument(
+        "--configs_ft",
+        help="path or list of paths to XYZ configurations for the finetuning",
+        required=False,
+        default=None,
+    )
+    parser.add_argument(
+        "--num_samples",
+        help="number of samples to select for the pretraining",
+        type=int,
+        required=False,
+        default=None,
+    )
+    parser.add_argument(
+        "--subselect",
+        help="method to subselect the configurations of the pretraining set",
+        type=SubselectType,
+        choices=list(SubselectType),
+        default=SubselectType.FPS,
+    )
+    parser.add_argument(
+        "--model", help="path to model", default="small", required=False
+    )
+    parser.add_argument("--output", help="output path", required=True)
+    parser.add_argument(
+        "--descriptors", help="path to descriptors", required=False, default=None
+    )
+    parser.add_argument(
+        "--device",
+        help="select device",
+        type=str,
+        choices=["cpu", "cuda"],
+        default="cpu",
+    )
+    parser.add_argument(
+        "--default_dtype",
+        help="set default dtype",
+        type=str,
+        choices=["float32", "float64"],
+        default="float64",
+    )
+    parser.add_argument(
+        "--head_pt",
+        help="level of head for the pretraining set",
+        type=str,
+        default=None,
+    )
+    parser.add_argument(
+        "--head_ft",
+        help="level of head for the finetuning set",
+        type=str,
+        default=None,
+    )
+    parser.add_argument(
+        "--filtering_type",
+        help="filtering type",
+        type=FilteringType,
+        choices=list(FilteringType),
+        default=FilteringType.NONE,
+    )
+    parser.add_argument(
+        "--weight_ft",
+        help="weight for the finetuning set",
+        type=float,
+        default=1.0,
+    )
+    parser.add_argument(
+        "--weight_pt",
+        help="weight for the pretraining set",
+        type=float,
+        default=1.0,
+    )
+    parser.add_argument(
+        "--atomic_numbers",
+        help="list of atomic numbers to filter the configurations",
+        type=str_to_list,
+        default=None,
+    )
+    parser.add_argument(
+        "--disallow_random_padding",
+        help="do not allow random padding of the configurations to match the number of samples",
+        action="store_false",
+        dest="allow_random_padding",
+    )
+    parser.add_argument("--seed", help="random seed", type=int, default=42)
+    return parser.parse_args()
+
+
+def calculate_descriptors(atoms: List[ase.Atoms], calc: MACECalculator) -> None:
+    logging.info("Calculating descriptors")
+    for mol in atoms:
+        descriptors = calc.get_descriptors(mol.copy(), invariants_only=True)
+        # average descriptors over atoms for each element
+        descriptors_dict = {
+            element: np.mean(descriptors[mol.symbols == element], axis=0)
+            for element in np.unique(mol.symbols)
+        }
+        mol.info["mace_descriptors"] = descriptors_dict
+
+
+def filter_atoms(
+    atoms: ase.Atoms,
+    element_subset: List[str],
+    filtering_type: FilteringType = FilteringType.COMBINATIONS,
+) -> bool:
+    """
+    Filters atoms based on the provided filtering type and element subset.
+
+    Parameters:
+    atoms (ase.Atoms): The atoms object to filter.
+    element_subset (list): The list of elements to consider during filtering.
+    filtering_type (FilteringType): The type of filtering to apply.
+        Can be one of the following `FilteringType` enum members:
+          - `FilteringType.NONE`: No filtering is applied.
+          - `FilteringType.COMBINATIONS`: Return true if `atoms` is composed of combinations of elements in the subset, false otherwise. I.e. does not require all of the specified elements to be present.
+          - `FilteringType.EXCLUSIVE`: Return true if `atoms` contains *only* elements in the subset, false otherwise.
+          - `FilteringType.INCLUSIVE`: Return true if `atoms` contains all elements in the subset, false otherwise. I.e. allows additional elements.
+
+    Returns:
+    bool: True if the atoms pass the filter, False otherwise.
+    """
+    if filtering_type == FilteringType.NONE:
+        return True
+    if filtering_type == FilteringType.COMBINATIONS:
+        atom_symbols = np.unique(atoms.symbols)
+        return all(
+            x in element_subset for x in atom_symbols
+        )  # atoms must *only* contain elements in the subset
+    if filtering_type == FilteringType.EXCLUSIVE:
+        atom_symbols = set(list(atoms.symbols))
+        return atom_symbols == set(element_subset)
+    if filtering_type == FilteringType.INCLUSIVE:
+        atom_symbols = np.unique(atoms.symbols)
+        return all(
+            x in atom_symbols for x in element_subset
+        )  # atoms must *at least* contain elements in the subset
+    raise ValueError(
+        f"Filtering type {filtering_type} not recognised. Must be one of {list(FilteringType)}."
+    )
+
+
+class FPS:
+    def __init__(self, atoms_list: List[ase.Atoms], n_samples: int):
+        self.n_samples = n_samples
+        self.atoms_list = atoms_list
+        self.species = np.unique([x.symbol for atoms in atoms_list for x in atoms])  # type: ignore
+        self.species_dict = {x: i for i, x in enumerate(self.species)}
+        # start from a random configuration
+        self.list_index = [np.random.randint(0, len(atoms_list))]
+        self.assemble_descriptors()
+
+    def run(
+        self,
+    ) -> List[int]:
+        """
+        Run the farthest point sampling algorithm.
+        """
+        descriptor_dataset_reshaped = (
+            self.descriptors_dataset.reshape(  # pylint: disable=E1121
+                (len(self.atoms_list), -1)
+            )
+        )
+        logging.info(f"{descriptor_dataset_reshaped.shape}")
+        logging.info(f"n_samples: {self.n_samples}")
+        self.list_index = fpsample.fps_npdu_kdtree_sampling(
+            descriptor_dataset_reshaped,
+            self.n_samples,
+        )
+        return self.list_index
+
+    def assemble_descriptors(self) -> None:
+        """
+        Assemble the descriptors for all the configurations.
+        """
+        self.descriptors_dataset: np.ndarray = 10e10 * np.ones(
+            (
+                len(self.atoms_list),
+                len(self.species),
+                len(list(self.atoms_list[0].info["mace_descriptors"].values())[0]),
+            ),
+            dtype=np.float32,
+        ).astype(np.float32)
+
+        for i, atoms in enumerate(self.atoms_list):
+            descriptors = atoms.info["mace_descriptors"]
+            for z in descriptors:
+                self.descriptors_dataset[i, self.species_dict[z]] = np.array(
+                    descriptors[z]
+                ).astype(np.float32)
+
+
+def _load_calc(
+    model: str, device: str, default_dtype: str, subselect: SubselectType
+) -> Union[MACECalculator, None]:
+    if subselect == SubselectType.RANDOM:
+        return None
+    if model in ["small", "medium", "large"]:
+        calc = mace_mp(model, device=device, default_dtype=default_dtype)
+    else:
+        calc = MACECalculator(
+            model_paths=model,
+            device=device,
+            default_dtype=default_dtype,
+        )
+    return calc
+
+
+def _get_finetuning_elements(
+    atoms: List[ase.Atoms], atomic_numbers: List[int] | None
+) -> List[str]:
+    if atoms:
+        logging.debug(
+            "Using elements from the finetuning configurations for filtering."
+        )
+        species = np.unique([x.symbol for atoms in atoms for x in atoms]).tolist()  # type: ignore
+    elif atomic_numbers is not None and atomic_numbers:
+        logging.debug("Using the supplied atomic numbers for filtering.")
+        species = [ase.data.chemical_symbols[z] for z in atomic_numbers]
+    else:
+        species = []
+    return species
+
+
+def _read_finetuning_configs(
+    configs_ft: Union[str, list[str], None],
+) -> List[ase.Atoms]:
+    if isinstance(configs_ft, str):
+        path = configs_ft
+        return ase.io.read(path, index=":")  # type: ignore
+    if isinstance(configs_ft, list):
+        assert all(isinstance(x, str) for x in configs_ft)
+        atoms_list_ft = []
+        for path in configs_ft:
+            atoms_list_ft += ase.io.read(path, index=":")
+        return atoms_list_ft
+    if configs_ft is None:
+        return []
+    raise ValueError(f"Invalid type for configs_ft: {type(configs_ft)}")
+
+
+def _filter_pretraining_data(
+    atoms: list[ase.Atoms],
+    filtering_type: FilteringType,
+    all_species_ft: List[str],
+) -> Tuple[List[ase.Atoms], List[ase.Atoms], list[bool]]:
+    logging.info(
+        "Filtering configurations based on the finetuning set, "
+        f"filtering type: {filtering_type}, elements: {all_species_ft}"
+    )
+    passes_filter = [filter_atoms(x, all_species_ft, filtering_type) for x in atoms]
+    assert len(passes_filter) == len(atoms), "Filtering failed"
+    filtered_atoms = [x for x, passes in zip(atoms, passes_filter) if passes]
+    remaining_atoms = [x for x, passes in zip(atoms, passes_filter) if not passes]
+    return filtered_atoms, remaining_atoms, passes_filter
+
+
+def _get_random_configs(
+    num_samples: int,
+    atoms: List[ase.Atoms],
+) -> list[ase.Atoms]:
+    if num_samples > len(atoms):
+        raise ValueError(
+            f"Requested more samples ({num_samples}) than available in the remaining set ({len(atoms)})"
+        )
+    indices = np.random.choice(list(range(len(atoms))), num_samples, replace=False)
+    return [atoms[i] for i in indices]
+
+
+def _load_descriptors(
+    atoms: List[ase.Atoms],
+    passes_filter: List[bool],
+    descriptors_path: str | None,
+    calc: MACECalculator | None,
+    full_data_length: int,
+) -> None:
+    if descriptors_path is not None:
+        logging.info(f"Loading descriptors from {descriptors_path}")
+        descriptors = np.load(descriptors_path, allow_pickle=True)
+        assert sum(passes_filter) == len(atoms)
+        if len(descriptors) != full_data_length:
+            raise ValueError(
+                f"Length of the descriptors ({len(descriptors)}) does not match the length of the data ({full_data_length})"
+                "Please provide descriptors for all configurations"
+            )
+        required_descriptors = [
+            descriptors[i] for i, passes in enumerate(passes_filter) if passes
+        ]
+        for i, atoms_ in enumerate(atoms):
+            atoms_.info["mace_descriptors"] = required_descriptors[i]
+    else:
+        logging.info("Calculating descriptors")
+        if calc is None:
+            raise ValueError("MACECalculator must be provided to calculate descriptors")
+        calculate_descriptors(atoms, calc)
+
+
+def _maybe_save_descriptors(
+    atoms: List[ase.Atoms],
+    output_path: str,
+) -> None:
+    """
+    Save the descriptors if they are present in the atoms objects.
+    Also, delete the descriptors from the atoms objects.
+    """
+    if all("mace_descriptors" in x.info for x in atoms):
+        output_path = Path(output_path)
+        descriptor_save_path = output_path.parent / (
+            output_path.stem + "_descriptors.npy"
+        )
+        logging.info(f"Saving descriptors at {descriptor_save_path}")
+        descriptors_list = [x.info["mace_descriptors"] for x in atoms]
+        np.save(descriptor_save_path, descriptors_list, allow_pickle=True)
+        for x in atoms:
+            del x.info["mace_descriptors"]
+
+
+def _maybe_fps(atoms: List[ase.Atoms], num_samples: int) -> List[ase.Atoms]:
+    try:
+        fps_pt = FPS(atoms, num_samples)
+        idx_pt = fps_pt.run()
+        logging.info(f"Selected {len(idx_pt)} configurations")
+        return [atoms[i] for i in idx_pt]
+    except Exception as e:  # pylint: disable=W0703
+        logging.error(f"FPS failed, selecting random configurations instead: {e}")
+        return _get_random_configs(num_samples, atoms)
+
+
+def _subsample_data(
+    filtered_atoms: List[ase.Atoms],
+    remaining_atoms: List[ase.Atoms],
+    passes_filter: List[bool],
+    num_samples: int | None,
+    subselect: SubselectType,
+    descriptors_path: str | None,
+    allow_random_padding: bool,
+    calc: MACECalculator | None,
+) -> List[ase.Atoms]:
+    if num_samples is None or num_samples == len(filtered_atoms):
+        logging.info(
+            f"No subsampling, keeping all {len(filtered_atoms)} filtered configurations"
+        )
+        return filtered_atoms
+    if num_samples > len(filtered_atoms) and allow_random_padding:
+        num_sample_randomly = num_samples - len(filtered_atoms)
+        logging.info(
+            f"Number of configurations after filtering {len(filtered_atoms)} "
+            f"is less than the number of samples {num_samples}, "
+            f"selecting {num_sample_randomly} random configurations for the rest."
+        )
+        return filtered_atoms + _get_random_configs(
+            num_sample_randomly, remaining_atoms
+        )
+    if num_samples == 0:
+        raise ValueError("Number of samples must be greater than 0")
+    if subselect == SubselectType.FPS:
+        _load_descriptors(
+            filtered_atoms,
+            passes_filter,
+            descriptors_path,
+            calc,
+            full_data_length=len(filtered_atoms) + len(remaining_atoms),
+        )
+        logging.info(
+            f"Selecting {num_samples} configurations out of {len(filtered_atoms)} using Farthest Point Sampling"
+        )
+        return _maybe_fps(filtered_atoms, num_samples)
+    if subselect == SubselectType.RANDOM:
+        logging.info(
+            f"Subselecting {num_samples} from filtered {len(filtered_atoms)} using random sampling"
+        )
+        return _get_random_configs(num_samples, filtered_atoms)
+    raise ValueError(f"Invalid subselect type: {subselect}")
+
+
+def _write_metadata(
+    atoms: list[ase.Atoms], pretrained: bool, config_weight: float, head: str | None
+) -> None:
+    for a in atoms:
+        a.info["pretrained"] = pretrained
+        a.info["config_weight"] = config_weight
+        if head is not None:
+            a.info["head"] = head
+
+
+def select_samples(
+    settings: SelectionSettings,
+) -> None:
+    np.random.seed(settings.seed)
+    torch.manual_seed(settings.seed)
+    calc = _load_calc(
+        settings.model, settings.device, settings.default_dtype, settings.subselect
+    )
+    atoms_list_ft = _read_finetuning_configs(settings.configs_ft)
+    all_species_ft = _get_finetuning_elements(atoms_list_ft, settings.atomic_numbers)
+
+    if settings.filtering_type is not FilteringType.NONE and not all_species_ft:
+        raise ValueError(
+            "Filtering types other than NONE require elements for filtering. They can be specified via the `--atomic_numbers` flag."
+        )
+
+    atoms_list_pt: list[ase.Atoms] = ase.io.read(settings.configs_pt, index=":")  # type: ignore
+    filtered_pt_atoms, remaining_atoms, passes_filter = _filter_pretraining_data(
+        atoms_list_pt, settings.filtering_type, all_species_ft
+    )
+
+    subsampled_atoms = _subsample_data(
+        filtered_pt_atoms,
+        remaining_atoms,
+        passes_filter,
+        settings.num_samples,
+        settings.subselect,
+        settings.descriptors,
+        settings.allow_random_padding,
+        calc,
+    )
+    if ase.io.formats.filetype(settings.output, read=False) != "extxyz":
+        raise ValueError(
+            f"filename '{settings.output}' does no have "
+            "suffix compatible with extxyz format"
+        )
+    _maybe_save_descriptors(subsampled_atoms, settings.output)
+
+    _write_metadata(
+        subsampled_atoms,
+        pretrained=True,
+        config_weight=settings.weight_pt,
+        head=settings.head_pt,
+    )
+    _write_metadata(
+        atoms_list_ft,
+        pretrained=False,
+        config_weight=settings.weight_ft,
+        head=settings.head_ft,
+    )
+
+    logging.info("Saving the selected configurations")
+    ase.io.write(settings.output, subsampled_atoms)
+
+    logging.info("Saving a combined XYZ file")
+    atoms_fps_pt_ft = subsampled_atoms + atoms_list_ft
+
+    output = Path(settings.output)
+    ase.io.write(
+        output.parent / (output.stem + "_combined" + output.suffix),
+        atoms_fps_pt_ft,
+    )
+
+
+def main():
+    args = parse_args()
+    settings = SelectionSettings(**vars(args))
+    select_samples(settings)
+
+
+if __name__ == "__main__":
+    main()

models/mace/mace/cli/our_files/run_calc.py

@@ -0,0 +1,34 @@
+from ase.io import read, write
+from ase.optimize import FIRE, BFGS
+from pathlib import Path
+from mace.calculators import MACECalculator
+
+
+input_structure = ""
+device = "cuda"
+#device = "cpu"
+
+atoms = read(input_structure)
+
+# Attach YOUR calculator (loads model internally)
+
+# calc = MACECalculator(
+#     model_paths='',
+#     device=device,
+# )
+
+#
+print("a")
+calc = MACECalculator(
+   model_path='',
+   device=device,
+   head='Default',
+)
+
+atoms.set_calculator(calc)
+
+opt = BFGS(atoms, logfile="ml_relax.log", trajectory="ml_relax.traj")
+opt.run(fmax=0.02, steps=1000)
+
+atoms.write('POSCAR_final')
+print("Done.")