Add espresso recipes and custom calculator

src/quacc/calculators/espresso/calculators.py

@@ -0,0 +1,58 @@
+from quacc import SETTINGS
+from quacc.calculators.espresso.core import EspressoCalculator
+from quacc.calculators.espresso.keys import (DYNMAT_KEYS, NEB_KEYS, PH_KEYS,
+                                             Q2R_KEYS, MATDYN_KEYS)
+
+# Mini classes that might be useful for binaries
+# that have very specific requirements
+
+class Ph(EspressoCalculator):
+    # These are not supposed to change
+    _BIN = 'ph'
+    _KEYS = PH_KEYS
+    _CMD = SETTINGS['ESPRESSO_PH_CMD']
+
+    def __init__(self, input_data):
+        self.input_data = input_data
+        super().__init__()
+
+class Neb(EspressoCalculator):
+
+    _BIN = 'neb'
+    _KEYS = NEB_KEYS
+    _CMD = SETTINGS['ESPRESSO_NEB_CMD']
+
+    def __init__(self, input_data):
+        self.input_data = input_data
+        super().__init__()
+        self.input_file = 'neb.dat'
+
+class Q2r(EspressoCalculator):
+    # These are not supposed to change
+    _BIN = 'q2r'
+    _KEYS = Q2R_KEYS
+    _CMD = SETTINGS['ESPRESSO_Q2R_CMD']
+
+    def __init__(self, input_data):
+        self.input_data = input_data
+        super().__init__()
+
+class Dynmat(EspressoCalculator):
+    # These are not supposed to change
+    _BIN = 'dynmat'
+    _KEYS = DYNMAT_KEYS
+    _CMD = SETTINGS['ESPRESSO_DYNMAT_CMD']
+
+    def __init__(self, input_data):
+        self.input_data = input_data
+        super().__init__()
+
+class Matdyn(EspressoCalculator):
+    # These are not supposed to change
+    _BIN = 'matdyn'
+    _KEYS = MATDYN_KEYS
+    _CMD = SETTINGS['ESPRESSO_MATDYN_CMD']
+
+    def __init__(self, input_data):
+        self.input_data = input_data
+        super().__init__()

src/quacc/calculators/espresso/core.py

@@ -0,0 +1,31 @@
+from quacc.calculators.espresso.utils import construct_namelist
+from quacc.calculators.espresso.io import _write, _read
+
+# Very simple class that can run calculations ASE style
+# I don't think we even need atoms object here.
+class EspressoCalculator:
+    # These are not supposed to change
+    def __init__(self):
+        self.input_file = f'{self._BIN}.in'
+        self.output_file = f'{self._BIN}.out'
+
+    def write_input(self, parameters, **kwargs):
+        _write(self.input_file, parameters, format = self._BIN, **kwargs)
+
+    def run(self):
+        from os import environ
+        from subprocess import check_call
+        argv = list(self._CMD) + ['-in', self.input_file]
+        with open(self.output_file, 'wb') as fd:
+            check_call(argv, stdout=fd, env=environ)
+
+    def execute(self, **kwargs):
+        parameters = self.to_namelist(self.input_data)
+        self.write_input(parameters, **kwargs)
+        self.run()
+
+    def read_results(self, **kwargs):
+        return _read(self.output_file, format = self._BIN, **kwargs)
+
+    def to_namelist(self):
+        return construct_namelist(self.input_data, keys=self._KEYS)

src/quacc/calculators/espresso/io.py

@@ -0,0 +1,43 @@
+"""I/O utilities for the espresso calculator."""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pathlib import Path
+    from typing import Any
+
+
+# Three ways to call a function based on a string:
+
+# 1. use the globals() dictionary
+# 2. use sys.modules[__name__] and getattr
+# 3. keep track of all functions in a dictionary
+
+def _write(filename, parameters, *, format, **kwargs):
+    lines = write_namelist(filename, parameters)
+
+    with open(filename, 'w') as fd:
+        fd.write(''.join(lines))
+
+def write_namelist(filename: str | Path, parameters: dict):
+    # This function aim to write basic input keywords to a file
+    # For additional cards (binary specifics) this is down in the child class
+    # Stolen from ase.io.espresso, maybe this could be made to a function "write_namelist"
+    # and imported here? See with the ASE gods.
+    pwi = []
+    for section in parameters:
+        pwi.append('&{0}\n'.format(section.upper()))
+        for key, value in parameters[section].items():
+            if value is True:
+                pwi.append('   {0:16} = .true.\n'.format(key))
+            elif value is False:
+                pwi.append('   {0:16} = .false.\n'.format(key))
+            else:
+                # repr format to get quotes around strings
+                pwi.append('   {0:16} = {1!r:}\n'.format(key, value))
+        pwi.append('/\n')  # terminate section
+    pwi.append('\n')
+    return pwi
+
+def write_ph_specifics():
+    pass

src/quacc/calculators/espresso/keys.py

@@ -0,0 +1,168 @@
+# We work ase.io.espresso style, but we need to add the namelist keys for each binary.
+# !!! For now this is GPT3.5 generated, must be checked !!!
+
+from ase.io.espresso import Namelist
+
+PH_KEYS = Namelist([
+    ('input_ph', [
+        'amass',
+        'outdir',
+        'prefix',
+        'niter_ph',
+        'tr2_ph',
+        'alpha_mix',
+        'nmix_ph',
+        'verbosity',
+        'reduce_io',
+        'max_seconds',
+        'dftd3_hess',
+        'fildyn',
+        'fildrho',
+        'fildvscf',
+        'epsil',
+        'lrpa',
+        'lnoloc',
+        'trans',
+        'lraman',
+        'eth_rps',
+        'eth_ns',
+        'dek',
+        'recover',
+        'low_directory_check',
+        'only_init',
+        'qplot',
+        'q2d',
+        'q_in_band_form',
+        'electron_phonon',
+        'el_ph_nsigma',
+        'el_ph_sigma',
+        'ahc_dir',
+        'ahc_nbnd',
+        'ahc_nbndskip',
+        'skip_upperfan',
+        'lshift_q',
+        'zeu',
+        'zue',
+        'elop',
+        'fpol',
+        'ldisp',
+        'nogg',
+        'asr',
+        'ldiag',
+        'lqdir',
+        'search_sym',
+        'nq1',
+        'nq2',
+        'nq3',
+        'nk1',
+        'nk2',
+        'nk3',
+        'k1',
+        'k2',
+        'k3',
+        'diagonalization',
+        'read_dns_bare',
+        'ldvscf_interpolate',
+        'wpot_dir',
+        'do_long_range',
+        'do_charge_neutral',
+        'start_irr',
+        'last_irr',
+        'nat_todo',
+        'modenum',
+        'start_q',
+        'last_q',
+        'dvscf_star',
+        'drho_star',]
+    )])
+
+NEB_KEYS = Namelist([
+    ('path', [
+        'string_method',
+        'restart_mode',
+        'nstep_path',
+        'num_of_images',
+        'opt_scheme',
+        'CI_scheme',
+        'first_last_opt',
+        'minimum_image',
+        'temp_req',
+        'ds',
+        'k_max',
+        'k_min',
+        'path_thr',
+        'uses_masses',
+        'use_freezing',
+        'lfcp',
+        'fcp_mu',
+        'fcp_thr',
+        'fcp_scheme']
+    )])
+
+Q2R_KEYS = Namelist([('input', [
+        'fildyn',
+        'flfrc',
+        'zasr',
+        'loto_2d',
+        'write_lr']
+    )])
+
+MATDYN_KEYS = Namelist([
+    ('&input', [
+        'flfrc',
+        'asr',
+        'huang',
+        'dos',
+        'nk1',
+        'nk2',
+        'nk3',
+        'deltaE',
+        'ndos',
+        'degauss',
+        'fldos',
+        'flfrq',
+        'flvec',
+        'fleig',
+        'fldyn',
+        'at',
+        'l1',
+        'l2',
+        'l3',
+        'ntyp',
+        'amass',
+        'readtau',
+        'fltau',
+        'la2F',
+        'q_in_band_form',
+        'q_in_cryst_coord',
+        'eigen_similarity',
+        'fd',
+        'na_ifc',
+        'nosym',
+        'loto_2d',
+        'loto_disable',
+        'read_lr',
+        'write_frc']
+    )])
+
+DYNMAT_KEYS = Namelist([
+    ('&input', [
+        'fildyn',
+        'q',
+        'amass',
+        'asr',
+        'remove_interaction_blocks',
+        'axis',
+        'lperm',
+        'lplasma',
+        'filout',
+        'fileig',
+        'filmol',
+        'filxsf',
+        'loto_2d',
+        'el_ph_nsig',
+        'el_ph_sigma']
+    )])
+
+# Is this cleaner to import?
+ALL_KEYS = {'ph': PH_KEYS, 'neb': NEB_KEYS, 'q2r': Q2R_KEYS, 'dynmat': DYNMAT_KEYS}