py4vasp-core 0.9.0__py3-none-any.whl

py4vasp/__init__.py

@@ -0,0 +1,10 @@
+# Copyright © VASP Software GmbH,
+# Licensed under the Apache License 2.0 (http://www.apache.org/licenses/LICENSE-2.0)
+from py4vasp._analysis.mlff import MLFFErrorAnalysis
+from py4vasp._calculations import Calculations
+from py4vasp._third_party.graph import plot
+from py4vasp._third_party.interactive import set_error_handling
+from py4vasp.calculation._class import Calculation
+
+__version__ = "0.9.0"
+set_error_handling("Minimal")

py4vasp/_analysis/mlff.py

@@ -0,0 +1,325 @@
+# Copyright © VASP Software GmbH,
+# Licensed under the Apache License 2.0 (http://www.apache.org/licenses/LICENSE-2.0)
+from types import SimpleNamespace
+from typing import Dict
+
+import numpy as np
+
+import py4vasp
+from py4vasp import exception
+
+
+class MLFFErrorAnalysis:
+    """A class to handle the error analysis of MLFF calculations.
+
+    This class is used to perform error analysis of MLFF calculations. It
+    provides methods to calculate the error in energy, forces and stresses
+    from MLFF and DFT calculations. See the documentation for the methods
+    for more details on the type of error calculated.
+
+    Notes
+    -----
+    The class is designed to be instantiated using the class methods
+    :meth:`from_paths` and :meth:`from_files`. Please use these methods instead
+    of directly calling the class.
+
+    Examples
+    --------
+    >>> from py4vasp import MLFFErrorAnalysis
+    >>> mlff_error_analysis = MLFFErrorAnalysis.from_paths(
+    ...     dft_data="path/to/dft/data",
+    ...     mlff_data="path/to/mlff/data",
+    ... )
+    >>> energy_error = mlff_error_analysis.get_energy_error_per_atom()
+    >>> force_error = mlff_error_analysis.get_force_rmse()
+    >>> stress_error = mlff_error_analysis.get_stress_rmse()
+    >>> # If you want to normalize the error by the number of configurations
+    >>> energy_error = mlff_error_analysis.get_energy_error_per_atom(
+    ...     normalize_by_configurations=True
+    ... )
+    >>> force_error = mlff_error_analysis.get_force_rmse(
+    ...     normalize_by_configurations=True
+    ... )
+    >>> stress_error = mlff_error_analysis.get_stress_rmse(
+    ...     normalize_by_configurations=True
+    ... )
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.mlff = SimpleNamespace()
+        self.dft = SimpleNamespace()
+
+    @classmethod
+    def _from_data(cls, _calculations):
+        mlff_error_analysis = cls(_internal=True)
+        mlff_error_analysis._calculations = _calculations
+        set_appropriate_attrs(mlff_error_analysis)
+        return mlff_error_analysis
+
+    @classmethod
+    def from_paths(cls, dft_data, mlff_data):
+        """Create an instance of MLFFErrorAnalysis from paths to the data.
+
+        Starting from paths for DFT and MLFF data, this method creates an
+        instance of MLFFErrorAnalysis. The paths are used to read the data
+        from the files.
+
+        Parameters
+        ----------
+        dft_data : str or pathlib.Path
+            Path to the DFT data. Accepts wildcards.
+        mlff_data : str or pathlib.Path
+            Path to the MLFF data. Accepts wildcards.
+        """
+        mlff_error_analysis = cls(_internal=True)
+        calculations = py4vasp.Calculations.from_paths(
+            dft_data=dft_data, mlff_data=mlff_data
+        )
+        mlff_error_analysis._calculations = calculations
+        set_appropriate_attrs(mlff_error_analysis)
+        return mlff_error_analysis
+
+    @classmethod
+    def from_files(cls, dft_data, mlff_data):
+        """Create an instance of MLFFErrorAnalysis from files.
+
+        Starting from files for DFT and MLFF data, this method creates an
+        instance of MLFFErrorAnalysis. The files are used to read the data
+        from the files.
+
+        Parameters
+        ----------
+        dft_data : str or pathlib.Path
+            Path to the DFT data. Accepts wildcards.
+        mlff_data : str or pathlib.Path
+            Path to the MLFF data. Accepts wildcards.
+        """
+        mlff_error_analysis = cls(_internal=True)
+        calculations = py4vasp.Calculations.from_files(
+            dft_data=dft_data, mlff_data=mlff_data
+        )
+        mlff_error_analysis._calculations = calculations
+        set_appropriate_attrs(mlff_error_analysis)
+        return mlff_error_analysis
+
+    def get_energy_error_per_atom(self, normalize_by_configurations=False):
+        """Get the error in energy per atom.
+
+        This method calculates the error in energy per atom between the MLFF
+        and DFT calculations. The error is calculated as
+        :math:`\\frac{E_{MLFF} - E_{DFT}}{N_{ions}}`, where :math:`E_{MLFF}`
+        and :math:`E_{DFT}` are the energies from the MLFF and DFT calculations
+        respectively, and :math:`N_{ions}` is the number of ions in the
+        structure. If ``normalize_by_configurations`` is set to ``True``, the
+        error is averaged over the number of configurations.
+
+        Parameters
+        ----------
+        normalize_by_configurations : bool, optional
+            If set to ``True``, the error is averaged over the number of
+            configurations. Defaults to ``False``.
+        """
+        error = (self.mlff.energies - self.dft.energies) / self.dft.nions
+        if normalize_by_configurations:
+            error = np.sum(np.abs(error), axis=-1) / self.dft.nconfig
+        return error
+
+    def _get_rmse(self, dft_quantity, mlff_quantity, degrees_of_freedom):
+        norm_error = np.linalg.norm(dft_quantity - mlff_quantity, axis=-1)
+        error = np.sqrt(np.sum(norm_error**2, axis=-1) / degrees_of_freedom)
+        return error
+
+    def get_force_rmse(self, normalize_by_configurations=False):
+        """Get the root mean square error in forces.
+
+        This method calculates the root mean square error in forces between the
+        MLFF and DFT calculations. The error is calculated as
+        :math:`\\sqrt{\\frac{\\sum_{i=1}^{N_{ions}}{\\sum_{j=1}^{3}{(F_{MLFF} - F_{DFT})^2}}}{3N_{ions}}}`,
+        where :math:`F_{MLFF}` and :math:`F_{DFT}` are the forces from the MLFF
+        and DFT calculations respectively, and :math:`N_{ions}` is the number
+        of ions in the structure. If ``normalize_by_configurations`` is set to
+        ``True``, the error is averaged over the number of configurations.
+
+        Parameters
+        ----------
+        normalize_by_configurations : bool, optional
+            If set to ``True``, the error is averaged over the number of
+            configurations. Defaults to ``False``.
+        """
+        deg_freedom = 3 * self.dft.nions
+        error = self._get_rmse(self.dft.forces, self.mlff.forces, deg_freedom)
+        if normalize_by_configurations:
+            error = np.sum(error, axis=-1) / self.dft.nconfig
+        return error
+
+    def get_stress_rmse(self, normalize_by_configurations=False):
+        """Get the root mean square error in stresses.
+
+        This method calculates the root mean square error in stresses between
+        the MLFF and DFT calculations. The error is calculated as
+        :math:`\\sqrt{\\frac{\\sum_{i=1}^{6}{(\\sigma_{MLFF} - \\sigma_{DFT})^2}}{6}}`,
+        where :math:`\\sigma_{MLFF}` and :math:`\\sigma_{DFT}` are the stresses
+        from the MLFF and DFT calculations respectively. If
+        ``normalize_by_configurations`` is set to ``True``, the error is
+        averaged over the number of configurations.
+        """
+        deg_freedom = 6
+        dft_stresses = np.triu(self.dft.stresses)
+        mlff_stresses = np.triu(self.mlff.stresses)
+        error = self._get_rmse(dft_stresses, mlff_stresses, deg_freedom)
+        if normalize_by_configurations:
+            error = np.sum(error, axis=-1) / self.dft.nconfig
+        return error
+
+
+def set_appropriate_attrs(cls):
+    set_paths_and_files(cls)
+    set_number_of_ions(cls)
+    set_number_of_configurations(cls)
+    set_energies(cls)
+    set_force_related_attributes(cls)
+    set_stresses(cls)
+    validate_data(cls)
+
+
+def validate_data(cls):
+    """Validate the data passed to the class.
+
+    This method validates the data passed to the class. It checks if the
+    number of ions, lattice vectors and positions are consistent between the
+    DFT and MLFF calculations. If not, it raises an exception.
+    """
+    try:
+        np.testing.assert_almost_equal(cls.dft.positions, cls.mlff.positions)
+        np.testing.assert_almost_equal(
+            cls.dft.lattice_vectors, cls.mlff.lattice_vectors
+        )
+        np.testing.assert_almost_equal(cls.dft.nions, cls.mlff.nions)
+    except AssertionError:
+        raise exception.IncorrectUsage(
+            """\
+Please pass a consistent set of data between DFT and MLFF calculations."""
+        )
+
+
+def set_number_of_configurations(cls):
+    """Set the number of configurations in the data.
+
+    This method sets the number of configurations in the data. It uses the
+    number of calculations performed to set the number of configurations.
+
+    Parameters
+    ----------
+    cls : MLFFErrorAnalysis
+        An instance of MLFFErrorAnalysis.
+    """
+    number_of_calculations = cls._calculations.number_of_calculations()
+    cls.dft.nconfig = number_of_calculations["dft_data"]
+    cls.mlff.nconfig = number_of_calculations["mlff_data"]
+
+
+def set_number_of_ions(cls):
+    """Set the number of ions in the data.
+
+    This method sets the number of ions in the data. It uses the number of
+    elements in the structures to set the number of ions.
+
+    Parameters
+    ----------
+    cls : MLFFErrorAnalysis
+        An instance of MLFFErrorAnalysis.
+    """
+    force_data = cls._calculations.forces.read()
+    structures_dft = _dict_to_list(force_data["dft_data"], "structure")
+    structures_mlff = _dict_to_list(force_data["mlff_data"], "structure")
+    elements_dft = _dict_to_array(structures_dft, "elements")
+    elements_mlff = _dict_to_array(structures_mlff, "elements")
+    nions_dft = np.array([len(_elements) for _elements in elements_dft])
+    nions_mlff = np.array([len(_elements) for _elements in elements_mlff])
+    cls.dft.nions = nions_dft
+    cls.mlff.nions = nions_mlff
+
+
+def set_paths_and_files(cls):
+    """Set the paths and files for the data.
+
+    This method sets the paths and files for the data. It uses the
+    :meth:`Calculations.paths` and :meth:`Calculations.files` methods to set
+    the paths and files.
+
+    Parameters
+    ----------
+    cls : MLFFErrorAnalysis
+        An instance of MLFFErrorAnalysis.
+    """
+    paths = cls._calculations.paths()
+    cls.dft.paths = paths["dft_data"]
+    cls.mlff.paths = paths["mlff_data"]
+    if hasattr(cls._calculations, "_files"):
+        files = cls._calculations.files()
+        cls.dft.files = files["dft_data"]
+        cls.mlff.files = files["mlff_data"]
+
+
+def set_energies(cls):
+    """Set the energies for the data.
+
+    This method sets the energies for the data. It uses the
+    :meth:`Calculations.energies` method to set the energies.
+
+    Parameters
+    ----------
+    cls : MLFFErrorAnalysis
+        An instance of MLFFErrorAnalysis.
+    """
+    tag = "free energy    TOTEN"
+    energies_data = cls._calculations.energies.read()
+    cls.mlff.energies = _dict_to_array(energies_data["mlff_data"], tag)
+    cls.dft.energies = _dict_to_array(energies_data["dft_data"], tag)
+
+
+def _dict_to_array(data: Dict, key: str) -> np.ndarray:
+    return np.array([_data[key] for _data in data])
+
+
+def _dict_to_list(data: Dict, key: str) -> list:
+    return [_data[key] for _data in data]
+
+
+def set_force_related_attributes(cls):
+    """Set the force related attributes for the data.
+
+    This method sets the force related attributes for the data. It uses the
+    :meth:`Calculations.forces` method to set the forces, lattice vectors and
+    positions.
+
+    Parameters
+    ----------
+    cls : MLFFErrorAnalysis
+        An instance of MLFFErrorAnalysis.
+    """
+    force_data = cls._calculations.forces.read()
+    cls.dft.forces = _dict_to_array(force_data["dft_data"], "forces")
+    cls.mlff.forces = _dict_to_array(force_data["mlff_data"], "forces")
+    dft_structures = _dict_to_list(force_data["dft_data"], "structure")
+    mlff_structures = _dict_to_list(force_data["mlff_data"], "structure")
+    cls.dft.lattice_vectors = _dict_to_array(dft_structures, "lattice_vectors")
+    cls.mlff.lattice_vectors = _dict_to_array(mlff_structures, "lattice_vectors")
+    cls.dft.positions = _dict_to_array(dft_structures, "positions")
+    cls.mlff.positions = _dict_to_array(mlff_structures, "positions")
+
+
+def set_stresses(cls):
+    """Set the stresses for the data.
+
+    This method sets the stresses for the data. It uses the
+    :meth:`Calculations.stresses` method to set the stresses.
+
+    Parameters
+    ----------
+    cls : MLFFErrorAnalysis
+        An instance of MLFFErrorAnalysis.
+    """
+    stress_data = cls._calculations.stresses.read()
+    cls.dft.stresses = _dict_to_array(stress_data["dft_data"], "stress")
+    cls.mlff.stresses = _dict_to_array(stress_data["mlff_data"], "stress")

py4vasp/_calculations.py

@@ -0,0 +1,131 @@
+# Copyright © VASP Software GmbH,
+# Licensed under the Apache License 2.0 (http://www.apache.org/licenses/LICENSE-2.0)
+import inspect
+import pathlib
+from typing import Dict, List
+
+from py4vasp import combine, exception
+from py4vasp._util import convert
+
+
+class Calculations:
+    """A class to handle multiple Calculations all at once.
+
+    This class combines the functionality of the Calculation class for more than one
+    calculation. Create a Calculations object using either a wildcard for a set of
+    paths or files or pass in paths and files directly. Then you can access the
+    properties of all calculations via the attributes of the object.
+
+    Examples
+    --------
+    >>> calcs = Calculations.from_paths(calc1="path_to_calc1", calc2="path_to_calc2")
+    >>> calcs.energies.read() # returns a dictionary with the energies of calc1 and calc2
+    >>> calcs.forces.read()   # returns a dictionary with the forces of calc1 and calc2
+    >>> calcs.stresses.read() # returns a dictionary with the stresses of calc1 and calc2
+
+    Notes
+    -----
+    To create new instances, you should use the classmethod :meth:`from_paths` or
+    :meth:`from_files`. This will ensure that the paths to your VASP calculations are
+    properly set and all features work as intended. Note that this is an alpha version
+    and the API might change in the future.
+    """
+
+    def __init__(self, *args, **kwargs):
+        if not kwargs.get("_internal"):
+            message = """\
+Please setup new CompareCalculations instance using the classmethod CompareCalculations.from_paths()
+or CompareCalculations.from_files() instead of the constructor CompareCalculations()."""
+            raise exception.IncorrectUsage(message)
+
+    def _path_finder(**kwargs):
+        for key, value in kwargs.items():
+            if not (isinstance(value, pathlib.Path) or isinstance(value, str)):
+                message = """\
+Please provide a path to a VASP calculation as a string or pathlib.Path."""
+                raise exception.IncorrectUsage(message)
+            paths = pathlib.Path(value).expanduser().absolute()
+            if "*" in paths.as_posix():
+                paths = sorted(list(paths.parent.glob(paths.name)))
+            else:
+                paths = [paths]
+            yield key, paths
+
+    @classmethod
+    def from_paths(cls, **kwargs):
+        """Set up a Calculations object for paths.
+
+        Setup a calculation for paths by passing in a dictionary with the name of the
+        calculation as key and the path to the calculation as value.
+
+        Parameters
+        ----------
+        **kwargs : Dict[str, str or pathlib.Path]
+            A dictionary with the name of the calculation as key and the path to the
+            calculation as value. Wildcards are allowed.
+        """
+        calculations = cls(_internal=True)
+        calculations._paths = {}
+        for key, paths in cls._path_finder(**kwargs):
+            calculations._paths[key] = paths
+        calculations = _add_all_combination_classes(
+            calculations, _add_attribute_from_path
+        )
+        return calculations
+
+    @classmethod
+    def from_files(cls, **kwargs):
+        """Set up a Calculations object from files.
+
+        Setup a calculation for files by passing in a dictionary with the name of the
+        calculation as key and the path to the calculation as value. Note that this
+        limits the amount of information, you have access to, so prefer creating the
+        instance with the :meth:`from_paths` if possible.
+
+        Parameters
+        ----------
+        **kwargs : Dict[str, str or pathlib.Path]
+            A dictionary with the name of the calculation as key and the files to the
+            calculation as value. Wildcards are allowed.
+        """
+        calculations = cls(_internal=True)
+        calculations._paths = {}
+        calculations._files = {}
+        for key, paths in cls._path_finder(**kwargs):
+            basedir_paths = [path.parent for path in paths]
+            calculations._paths[key] = basedir_paths
+            calculations._files[key] = paths
+        calculations = _add_all_combination_classes(
+            calculations, _add_attribute_from_file
+        )
+        return calculations
+
+    def paths(self) -> Dict[str, List[pathlib.Path]]:
+        """Return the paths of the calculations."""
+        return self._paths
+
+    def files(self) -> Dict[str, List[pathlib.Path]]:
+        """Return the files of the calculations."""
+        return self._files
+
+    def number_of_calculations(self) -> Dict[str, int]:
+        """Return the number of calculations for each calculation."""
+        return {key: len(value) for key, value in self._paths.items()}
+
+
+def _add_attribute_from_path(calc, class_):
+    instance = class_.from_paths(calc.paths())
+    setattr(calc, convert.quantity_name(class_.__name__), instance)
+    return calc
+
+
+def _add_attribute_from_file(calc, class_):
+    instance = class_.from_files(calc.files())
+    setattr(calc, convert.quantity_name(class_.__name__), instance)
+    return calc
+
+
+def _add_all_combination_classes(calc, add_single_class):
+    for _, class_ in inspect.getmembers(combine, inspect.isclass):
+        calc = add_single_class(calc, class_)
+    return calc

py4vasp/_combine/base.py

@@ -0,0 +1,99 @@
+# Copyright © VASP Software GmbH,
+# Licensed under the Apache License 2.0 (http://www.apache.org/licenses/LICENSE-2.0)
+import inspect
+import pathlib
+from typing import Dict, List
+
+from py4vasp import calculation, exception
+
+
+def _match_combine_with_refinement(combine_name: str):
+    combine_to_refinement_name = {
+        "Energies": "energy",
+        "Forces": "force",
+        "Stresses": "stress",
+    }
+    return getattr(calculation, combine_to_refinement_name[combine_name])
+    # for _, class_ in inspect.getmembers(data_depr, inspect.isclass):
+    #     if class_.__name__ == combine_to_refinement_name[combine_name]:
+    #         return class_
+    # else:
+    #     raise exception.IncorrectUsage(
+    #         f"Could not find refinement class for {combine_name}."
+    #     )
+
+
+class BaseCombine:
+    """A class to handle multiple refinements all at once.
+
+    This class combines the functionality of the refinement class for more than one
+    refinement. Create a BaseCombine object using either a wildcard for a set of
+    paths or files or pass in paths and files directly. Then you can access the
+    properties of all refinements via the attributes of the object.
+
+    Notes
+    -----
+    To create new instances, you should use the classmethod :meth:`from_paths` or
+    :meth:`from_files`. This will ensure that the paths to your VASP calculations are
+    properly set and all features work as intended. Note that this is an alpha version
+    and the API might change in the future.
+    """
+
+    def __init__(self):
+        pass
+
+    @classmethod
+    def from_paths(cls, paths: Dict[str, List[pathlib.Path]]):
+        """Set up a BaseCombine object for paths.
+
+        Setup the object for paths by passing in a dictionary with the name of the
+        calculation as key and the path to the calculation as value.
+
+        Parameters
+        ----------
+        paths : Dict[str, List[pathlib.Path]]
+            A dictionary with the name of the calculation as key and the path to the
+            calculation as value.
+        """
+        base = cls()
+        refinement = _match_combine_with_refinement(cls.__name__)
+        setattr(base, f"_{cls.__name__.lower()}", {})
+        for key, path in paths.items():
+            all_refinements = [refinement.from_path(_path) for _path in path]
+            base.__getattribute__(f"_{cls.__name__.lower()}")[key] = all_refinements
+        return base
+
+    @classmethod
+    def from_files(cls, files: Dict[str, List[pathlib.Path]]):
+        """Set up a BaseCombine object for files.
+
+        Setup the object for files by passing in a dictionary with the name of the
+        calculation as key and the path to the calculation as value.
+
+        Parameters
+        ----------
+        files : Dict[str, List[pathlib.Path]]
+            A dictionary with the name of the calculation as key and the path to the
+            calculation as value.
+        """
+        base = cls()
+        refinement = _match_combine_with_refinement(cls.__name__)
+        setattr(base, f"_{cls.__name__.lower()}", {})
+        for key, file in files.items():
+            all_refinements = [refinement.from_file(_file) for _file in file]
+            base.__getattribute__(f"_{cls.__name__.lower()}")[key] = all_refinements
+        return base
+
+    def _to_dict(self, *args, **kwargs):
+        _data = {}
+        _class_name = f"_{self.__class__.__name__.lower()}"
+        keyval_refinements = self.__getattribute__(_class_name).items()
+        for key, refinement in keyval_refinements:
+            _data[key] = [
+                _refinement.read(*args, **kwargs) for _refinement in refinement
+            ]
+        return _data
+
+    def read(self, *args, **kwargs):
+        """Read the data from the :meth:`read` method of the refinement class."""
+        return self._to_dict(*args, **kwargs)

py4vasp/_combine/energies.py

@@ -0,0 +1,9 @@
+# Copyright © VASP Software GmbH,
+# Licensed under the Apache License 2.0 (http://www.apache.org/licenses/LICENSE-2.0)
+
+from py4vasp._combine.base import BaseCombine
+
+
+class Energies(BaseCombine):
+    def __init__(self):
+        pass

py4vasp/_combine/forces.py

@@ -0,0 +1,9 @@
+# Copyright © VASP Software GmbH,
+# Licensed under the Apache License 2.0 (http://www.apache.org/licenses/LICENSE-2.0)
+
+from py4vasp._combine.base import BaseCombine
+
+
+class Forces(BaseCombine):
+    def __init__(self):
+        pass

py4vasp/_combine/stresses.py

@@ -0,0 +1,9 @@
+# Copyright © VASP Software GmbH,
+# Licensed under the Apache License 2.0 (http://www.apache.org/licenses/LICENSE-2.0)
+
+from py4vasp._combine.base import BaseCombine
+
+
+class Stresses(BaseCombine):
+    def __init__(self):
+        pass

py4vasp/_config.py

@@ -0,0 +1,4 @@
+# Copyright © VASP Software GmbH,
+# Licensed under the Apache License 2.0 (http://www.apache.org/licenses/LICENSE-2.0)
+VASP_COLORS = ("#4C265F", "#2FB5AB", "#2C68FC", "#A82C35", "#808080")
+VASP_PURPLE, VASP_CYAN, VASP_BLUE, VASP_RED, VASP_GRAY = VASP_COLORS

py4vasp/_control/base.py

@@ -0,0 +1,64 @@
+# Copyright © VASP Software GmbH,
+# Licensed under the Apache License 2.0 (http://www.apache.org/licenses/LICENSE-2.0)
+from pathlib import Path
+
+
+class InputFile:
+    def __init__(self, path):
+        self._path = path
+
+    @classmethod
+    def from_string(cls, string, path=None):
+        """Generate the file from a given string and store it.
+
+        If no path is provided, the content of the file is stored in memory otherwise
+        it is stored in the path.
+
+        Parameters
+        ----------
+        string : str
+            Content of the file.
+        path : str or Path
+            If provided should define where the file is stored.
+        """
+        obj = cls(path)
+        obj.write(string)
+        return obj
+
+    def print(self):
+        "Write the contents of the file to screen."
+        print(self)
+
+    def write(self, string):
+        "Store the given string in the file."
+        if self._path is not None:
+            self._write_to_file(string)
+        else:
+            self._write_to_memory(string)
+
+    def read(self):
+        "Return the content of the file as a string."
+        if self._path is not None:
+            return self._read_from_file()
+        else:
+            return self._read_from_memory()
+
+    def _repr_pretty_(self, p, cycle):
+        p.text(str(self))
+
+    def _write_to_file(self, string):
+        with open(Path(self._path) / self.__class__.__name__, "w") as file:
+            file.write(string)
+
+    def _write_to_memory(self, string):
+        self._content = string
+
+    def _read_from_file(self):
+        with open(Path(self._path) / self.__class__.__name__, "r") as file:
+            return file.read()
+
+    def _read_from_memory(self):
+        return self._content
+
+    def __str__(self):
+        return self.read()

py4vasp/_control/incar.py

@@ -0,0 +1,14 @@
+# Copyright © VASP Software GmbH,
+# Licensed under the Apache License 2.0 (http://www.apache.org/licenses/LICENSE-2.0)
+from py4vasp._control import base
+
+
+class INCAR(base.InputFile):
+    """The INCAR file defining the input parameters of a VASP calculation.
+
+    Parameters
+    ----------
+    path : str or Path
+        Defines where the INCAR file is stored. If set to None, the file will be kept
+        in memory.
+    """