Add FHI-aims DFT calculator

docs/about/contributors.md

@@ -103,6 +103,13 @@ University of Arizona
 [tpurcell90]: https://github.com/tpurcell90
 [0000-0003-4564-7206]: https://orcid.org/0000-0003-4564-7206
 
+**Andrei Sobolev** [![gh]][ansobolev] [![orc]][0000-0001-5086-6601] \
+Software Scientist \
+MS1P e.V.
+
+[ansobolev]: https://github.com/ansobolev
+[0000-0001-5086-6601]: https://orcid.org/0000-0001-5086-6601
+
 **Alexander Bonkowski** [![gh]][ab5424] [![orc]][0000-0002-0525-4742] \
 PhD student in Chemistry \
 RWTH Aachen University

src/atomate2/aims/__init__.py

@@ -0,0 +1 @@
+"""FHI-aims interface for atomate2."""

src/atomate2/aims/files.py

@@ -0,0 +1,151 @@
+"""Functions dealing with FHI-aims files."""
+from __future__ import annotations
+
+import logging
+from glob import glob
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from atomate2.common.files import copy_files, get_zfile, gunzip_files
+from atomate2.utils.file_client import FileClient, auto_fileclient
+from atomate2.utils.path import strip_hostname
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from pymatgen.core import Molecule, Structure
+    from pymatgen.io.aims.sets.base import AimsInputGenerator
+
+logger = logging.getLogger(__name__)
+
+__all__ = ["copy_aims_outputs", "write_aims_input_set", "cleanup_aims_outputs"]
+
+
+@auto_fileclient
+def copy_aims_outputs(
+    src_dir: Path | str,
+    src_host: str | None = None,
+    additional_aims_files: list[str] | None = None,
+    restart_to_input: bool = False,
+    file_client: FileClient | None = None,
+) -> None:
+    """
+    Copy FHI-aims output files to the current directory (inspired by CP2K plugin).
+
+    Parameters
+    ----------
+    src_dir : str or Path
+        The source directory.
+    src_host : str or None
+        The source hostname used to specify a remote filesystem. Can be given as
+        either "username@remote_host" or just "remote_host" in which case the username
+        will be inferred from the current user. If ``None``, the local filesystem will
+        be used as the source.
+    additional_aims_files : list[str]
+        Additional files to copy
+    restart_to_input : bool
+        Move the aims restart files to by the aims input in the new directory
+    file_client : .FileClient
+        A file client to use for performing file operations.
+    """
+    src_dir = strip_hostname(src_dir)
+    logger.info(f"Copying FHI-aims inputs from {src_dir}")
+    directory_listing = file_client.listdir(src_dir, host=src_host)
+    # additional files like bands, DOS, *.cube, whatever
+    additional_files = additional_aims_files if additional_aims_files else []
+
+    # copy files
+    # (no need to copy aims.out by default; it can be added to additional_aims_files
+    # explicitly if needed)
+    files: list[str] = (
+        ["hessian.aims", "geometry.in.next_step", "*.csc"] if restart_to_input else []
+    )
+
+    files += [
+        Path(f).name
+        for pattern in set(files + additional_files)
+        for f in glob((Path(src_dir) / pattern).as_posix())
+    ]
+
+    all_files = [
+        get_zfile(directory_listing, str(r), allow_missing=True) for r in files
+    ]
+    all_files = [f for f in all_files if f]
+
+    copy_files(
+        src_dir,
+        src_host=src_host,
+        include_files=all_files,
+        file_client=file_client,
+    )
+
+    zipped_files = [f for f in all_files if f.name.endswith("gz")]
+
+    gunzip_files(
+        include_files=zipped_files,
+        allow_missing=True,
+        file_client=file_client,
+    )
+
+    logger.info("Finished copying inputs")
+
+
+def write_aims_input_set(
+    structure: Structure | Molecule,
+    input_set_generator: AimsInputGenerator,
+    directory: str | Path = ".",
+    prev_dir: str | Path | None = None,
+    **kwargs,
+) -> None:
+    """
+    Write FHI-aims input set.
+
+    Parameters
+    ----------
+    structure : Structure or Molecule
+        A to write the input set for.
+    input_set_generator : .AimsInputGenerator
+        An GHI-aims input set generator.
+    directory : str or Path
+        The directory to write the input files to.
+    prev_dir : str or Path or None
+        If the input set is to be initialized from a previous calculation,
+        the previous calc directory
+    **kwargs
+        Keyword arguments to pass to :obj:`.AimsInputSet.write_input`.
+    """
+    properties = kwargs.get("properties", [])
+    aims_is = input_set_generator.get_input_set(
+        structure, prev_dir=prev_dir, properties=properties
+    )
+
+    logger.info("Writing FHI-aims input set.")
+    aims_is.write_input(directory, **kwargs)
+
+
+@auto_fileclient
+def cleanup_aims_outputs(
+    directory: Path | str,
+    host: str | None = None,
+    file_patterns: Sequence[str] = (),
+    file_client: FileClient | None = None,
+) -> None:
+    """Remove unnecessary files.
+
+    Parameters
+    ----------
+    directory: Path or str
+        Directory containing files
+    host: str or None
+        File client host
+    file_patterns: Sequence[str]
+        Glob patterns to find files for deletion.
+    file_client: .FileClient
+        A file client to use for performing file operations.
+    """
+    files_to_delete = []
+    for pattern in file_patterns:
+        files_to_delete.extend(file_client.glob(Path(directory) / pattern, host=host))
+
+    for file in files_to_delete:
+        file_client.remove(file)

src/atomate2/aims/flows/__init__.py

@@ -0,0 +1 @@
+"""Workflows for FHI-aims."""

src/atomate2/aims/flows/core.py

@@ -0,0 +1,105 @@
+"""(Work)flows for FHI-aims."""
+from __future__ import annotations
+
+from copy import deepcopy
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from jobflow import Flow, Maker
+from pymatgen.io.aims.sets.core import RelaxSetGenerator
+
+from atomate2.aims.jobs.core import RelaxMaker
+
+if TYPE_CHECKING:
+    from pymatgen.core import Molecule, Structure
+
+    from atomate2.aims.jobs.base import BaseAimsMaker
+
+
+@dataclass
+class DoubleRelaxMaker(Maker):
+    """Double relaxation maker for FHI-aims.
+
+    A maker to perform a double relaxation in FHI-aims (first with light,
+    and then with tight species_defaults).
+
+    Parameters
+    ----------
+    name : str
+        A name for the flow
+    relax_maker1: .BaseAimsMaker
+        A maker that generates the first relaxation
+    relax_maker2: .BaseAimsMaker
+        A maker that generates the second relaxation
+    """
+
+    name: str = "Double relaxation"
+    relax_maker1: BaseAimsMaker = field(default_factory=RelaxMaker)
+    relax_maker2: BaseAimsMaker = field(default_factory=RelaxMaker)
+
+    def make(
+        self,
+        structure: Structure | Molecule,
+        prev_dir: str | Path | None = None,
+    ) -> Flow:
+        """Create a flow with two chained relaxations.
+
+        Parameters
+        ----------
+        structure : Structure or Molecule
+            The structure to relax.
+        prev_dir : str or Path or None
+            A previous FHI-aims calculation directory to copy output files from.
+        """
+        relax1 = self.relax_maker1.make(structure, prev_dir=prev_dir)
+        relax1.name += " 1"
+
+        relax2 = self.relax_maker2.make(
+            relax1.output.structure, prev_dir=relax1.output.dir_name
+        )
+        relax2.name += " 2"
+
+        return Flow([relax1, relax2], relax2.output, name=self.name)
+
+    @classmethod
+    def from_parameters(
+        cls,
+        parameters: dict[str, Any],
+        species_defaults: list[str] | tuple[str, str] = ("light", "tight"),
+    ) -> DoubleRelaxMaker:
+        """Create the maker from an ASE parameter set.
+
+        Creates a DoubleRelaxFlow for the same parameters with two different
+        species defaults.
+
+        Parameters
+        ----------
+        parameters : dict
+            a dictionary with calculation parameters
+        species_defaults: list | tuple
+            paths for species defaults to use relative to the given `species_dir`
+            in parameters
+        """
+        # various checks
+        if len(species_defaults) != 2:
+            raise ValueError(
+                "Two species defaults directories must be provided for DoubleRelaxFlow"
+            )
+        if "species_dir" not in parameters:
+            raise KeyError("Provided parameters do not include species_dir")
+        species_dir = Path(parameters["species_dir"])
+        for basis_set in species_defaults:
+            if not (species_dir / basis_set).exists():
+                basis_set_dir = (species_dir / basis_set).as_posix()
+                raise OSError(
+                    f"The species defaults directory {basis_set_dir} does not exist"
+                )
+
+        # now the actual work begins
+        makers = []
+        for basis_set in species_defaults:
+            parameters["species_dir"] = (species_dir / basis_set).as_posix()
+            input_set = RelaxSetGenerator(user_params=deepcopy(parameters))
+            makers.append(RelaxMaker(input_set_generator=input_set))
+        return cls(relax_maker1=makers[0], relax_maker2=makers[1])

src/atomate2/aims/flows/gw.py

@@ -0,0 +1,38 @@
+"""GW workflows for FHI-aims with automatic convergence."""
+from dataclasses import dataclass, field
+
+from atomate2.aims.jobs.convergence import ConvergenceMaker
+from atomate2.aims.jobs.core import GWMaker
+
+
+@dataclass
+class GWConvergenceMaker(ConvergenceMaker):
+    """A maker to perform a GW workflow with automatic convergence in FHI-aims.
+
+    Basically a .ConvergenceMaker with adjusted defaults. Employs the fact that
+    GW calculations in FHI-aims scale as O(N^4) with a large prefactor, which makes
+    running a DFT part for any structure negligible with respect to the GW
+    postprocessing.
+
+    Parameters
+    ----------
+    name : str
+        A name for the job
+    maker: .GWMaker
+        A maker for the run
+    criterion_name: str
+        A name for the convergence criterion. Must be in the run results
+    epsilon: float
+        A difference in criterion value for subsequent runs
+    convergence_field: str
+        An input parameter that changes to achieve convergence
+    convergence_steps: Iterable
+        An iterable of the possible values for the convergence field.
+        If the iterable is depleted and the convergence is not reached,
+        then the job is failed
+    """
+
+    name: str = "GW convergence"
+    maker: GWMaker = field(default_factory=GWMaker)
+    criterion_name: str = "bandgap"
+    epsilon: float = 0.1