Migrating code we don't want to merge with QE into a utilities folder

Makefile

@@ -1,5 +1,5 @@
 # List of available tasks
-.PHONY: help install submodules configure_4 configure_6 configure espresso_4 espresso_6 espresso workflow tests mock_tests clean clean_espresso clean_tests
+.PHONY: help install submodules configure_4 configure_7 configure espresso_4 espresso_7 espresso_utils espresso workflow tests mock_tests clean clean_espresso clean_tests
 
 MPIF90 = "mpif90"
 
@@ -37,18 +37,21 @@ submodules:
 configure_4:
 	cd quantum_espresso/cp_koopmans; ./configure MPIF90=$(MPIF90);
 
-configure_6:
+configure_7:
 	cd quantum_espresso/qe_koopmans; ./configure MPIF90=$(MPIF90);
 
-configure: configure_4 configure_6
+configure: configure_4 configure_7
 
 espresso_4:
 	@(cd quantum_espresso/cp_koopmans; $(MAKE) kcp)
 
-espresso_6:
-	@(cd quantum_espresso/qe_koopmans; $(MAKE) kc)
+espresso_7:
+	@(cd quantum_espresso/qe_koopmans; $(MAKE) kcw)
 
-espresso: configure_4 espresso_4 configure_6 espresso_6
+espresso_utils:
+	@(cd quantum_espresso/utils; $(MAKE) all)
+
+espresso: configure_4 espresso_4 configure_7 espresso_7 espresso_utils
 
 workflow:
 	python3 -m pip install --upgrade pip
@@ -59,6 +62,7 @@ clean: clean_espresso clean_tests
 clean_espresso:
 	@(cd quantum_espresso/cp_koopmans; $(MAKE) veryclean)
 	@(cd quantum_espresso/qe_koopmans; $(MAKE) veryclean)
+	@(cd quantum_espresso/utils; $(MAKE) clean)
 
 tests:
 	python3 -m pytest -m "standard" tests/

bin/merge_evc.x

@@ -1 +1 @@
-../quantum_espresso/qe_koopmans/bin/merge_evc.x
+../quantum_espresso/utils/bin/merge_evc.x

bin/wann2kcp.x

@@ -0,0 +1 @@
+../quantum_espresso/utils/bin/wann2kcp.x

koopmans/calculators/__init__.py

@@ -5,7 +5,8 @@
 from ._koopmans_screen import KoopmansScreenCalculator
 from ._pw import PWCalculator
 from ._pw2wannier import PW2WannierCalculator
+from ._wann2kcp import Wann2KCPCalculator
 from ._wannier90 import Wannier90Calculator
 from ._wann2kc import Wann2KCCalculator
 from ._ui import UnfoldAndInterpolateCalculator
-from ._utils import CalculatorExt, qe_bin_directory, CalculatorCanEnforceSpinSym, ReturnsBandStructure
+from ._utils import CalculatorExt, bin_directory, CalculatorCanEnforceSpinSym, ReturnsBandStructure

koopmans/calculators/_koopmans_cp.py

@@ -21,7 +21,7 @@
 from ase.calculators.espresso import Espresso_kcp
 from koopmans import utils, settings, pseudopotentials, bands
 from koopmans.commands import ParallelCommand
-from ._utils import CalculatorExt, CalculatorABC, kcp_bin_directory, CalculatorCanEnforceSpinSym
+from ._utils import CalculatorExt, CalculatorABC, bin_directory, CalculatorCanEnforceSpinSym
 
 
 def read_ham_file(filename: Path) -> np.ndarray:
@@ -69,7 +69,7 @@ def __init__(self, atoms: Atoms, skip_qc: bool = False, alphas: Optional[List[Li
 
         if not isinstance(self.command, ParallelCommand):
             self.command = ParallelCommand(os.environ.get(
-                'ASE_ESPRESSO_KCP_COMMAND', str(kcp_bin_directory) + os.path.sep + self.command))
+                'ASE_ESPRESSO_KCP_COMMAND', str(bin_directory) + os.path.sep + self.command))
 
         if alphas is not None:
             self.alphas = alphas

koopmans/calculators/_koopmans_ham.py

@@ -13,7 +13,7 @@
 from ase.calculators.espresso import KoopmansHam
 from ase.dft.kpoints import BandPath
 from koopmans import utils, settings
-from ._utils import KCWannCalculator, CalculatorABC, qe_bin_directory, ReturnsBandStructure
+from ._utils import KCWannCalculator, CalculatorABC, bin_directory, ReturnsBandStructure
 from koopmans.commands import ParallelCommand
 
 
@@ -31,7 +31,7 @@ def __init__(self, atoms: Atoms, alphas: Optional[List[int]] = None, *args, **kw
         KCWannCalculator.__init__(self, *args, **kwargs)
 
         self.command = ParallelCommand(
-            f'{qe_bin_directory}{os.path.sep}kcw.x -in PREFIX{self.ext_in} > PREFIX{self.ext_out}')
+            f'{bin_directory}{os.path.sep}kcw.x -in PREFIX{self.ext_in} > PREFIX{self.ext_out}')
 
         self.results_for_qc = ['ki_eigenvalues_on_grid', 'band structure']
 

koopmans/calculators/_koopmans_screen.py

@@ -11,7 +11,7 @@
 from ase import Atoms
 from ase.calculators.espresso import KoopmansScreen
 from koopmans import utils, settings
-from ._utils import KCWannCalculator, CalculatorABC, qe_bin_directory
+from ._utils import KCWannCalculator, CalculatorABC, bin_directory
 from koopmans.commands import ParallelCommandWithPostfix
 
 
@@ -30,7 +30,7 @@ def __init__(self, atoms: Atoms, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
         self.command = ParallelCommandWithPostfix(
-            f'{qe_bin_directory}{os.path.sep}kcw.x -in PREFIX{self.ext_in} > PREFIX{self.ext_out}')
+            f'{bin_directory}{os.path.sep}kcw.x -in PREFIX{self.ext_in} > PREFIX{self.ext_out}')
 
         self.results_for_qc = ['alphas']
 

koopmans/calculators/_pw.py

@@ -12,7 +12,7 @@
 from ase.calculators.espresso import Espresso
 from ase.dft.kpoints import BandPath
 from koopmans.settings import PWSettingsDict
-from ._utils import CalculatorExt, CalculatorABC, qe_bin_directory, ReturnsBandStructure
+from ._utils import CalculatorExt, CalculatorABC, bin_directory, ReturnsBandStructure
 from koopmans.commands import ParallelCommandWithPostfix, Command
 
 
@@ -32,7 +32,7 @@ def __init__(self, atoms: Atoms, *args, **kwargs):
         self.results_for_qc = ['energy']
         if not isinstance(self.command, Command):
             self.command = ParallelCommandWithPostfix(os.environ.get(
-                'ASE_ESPRESSO_COMMAND', str(qe_bin_directory) + os.path.sep + self.command))
+                'ASE_ESPRESSO_COMMAND', str(bin_directory) + os.path.sep + self.command))
 
         self.results_for_qc = ['energy']
 

koopmans/calculators/_pw2wannier.py

@@ -11,7 +11,7 @@
 from ase.calculators.espresso import PW2Wannier
 from koopmans.settings import PW2WannierSettingsDict
 from koopmans.commands import ParallelCommand
-from ._utils import CalculatorExt, CalculatorABC, qe_bin_directory
+from ._utils import CalculatorExt, CalculatorABC, bin_directory
 
 
 class PW2WannierCalculator(CalculatorExt, PW2Wannier, CalculatorABC):
@@ -27,7 +27,7 @@ def __init__(self, atoms: Atoms, *args, **kwargs):
         CalculatorExt.__init__(self, *args, **kwargs)
 
         self.command = ParallelCommand(os.environ.get('ASE_PW2WANNIER_COMMAND',
-                                                      str(qe_bin_directory) + os.path.sep + self.command))
+                                                      str(bin_directory) + os.path.sep + self.command))
 
     def is_converged(self):
         return True

koopmans/calculators/_utils.py

@@ -32,9 +32,7 @@ class ExtendedCalc(CalculatorExt, ASECalc, CalculatorABC):
 from koopmans import utils, settings
 
 # Directories of the various QE calculators
-qe_parent_directory = Path(__file__).parents[2] / 'quantum_espresso'
-qe_bin_directory = qe_parent_directory / 'qe_koopmans/bin/'
-kcp_bin_directory = qe_parent_directory / 'cp_koopmans/bin/'
+bin_directory = Path(__file__).parents[2] / 'bin'
 
 
 def sanitise_filenames(filenames: Union[str, Path, List[str], List[Path]], ext_in: str, ext_out: str) -> List[Path]:

koopmans/calculators/_wann2kc.py

@@ -9,7 +9,7 @@
 import os
 from ase import Atoms
 from ase.calculators.espresso import Wann2KC
-from ._utils import KCWannCalculator, qe_bin_directory, CalculatorABC
+from ._utils import KCWannCalculator, bin_directory, CalculatorABC
 from koopmans.settings import Wann2KCSettingsDict
 from koopmans.commands import ParallelCommandWithPostfix
 
@@ -28,7 +28,7 @@ def __init__(self, atoms: Atoms, *args, **kwargs):
         KCWannCalculator.__init__(self, *args, **kwargs)
 
         self.command = ParallelCommandWithPostfix(
-            f'{qe_bin_directory}{os.path.sep}kcw.x -in PREFIX{self.ext_in} > PREFIX{self.ext_out}')
+            f'{bin_directory}{os.path.sep}kcw.x -in PREFIX{self.ext_in} > PREFIX{self.ext_out}')
 
     def is_converged(self):
         return True

koopmans/calculators/_wann2kcp.py

@@ -0,0 +1,36 @@
+"""
+
+wann2kcp calculator module for koopmans
+
+Written by Riccardo De Gennaro Mar 2022
+
+"""
+
+import os
+from ase import Atoms
+from ase.calculators.espresso import Wann2KCP
+from koopmans.settings import Wann2KCPSettingsDict
+from koopmans.commands import ParallelCommand
+from ._utils import CalculatorExt, CalculatorABC, bin_directory
+
+
+class Wann2KCPCalculator(CalculatorExt, Wann2KCP, CalculatorABC):
+
+    ext_in = '.wki'
+    ext_out = '.wko'
+
+    def __init__(self, atoms: Atoms, *args, **kwargs):
+        self.parameters = Wann2KCPSettingsDict()
+
+        # Initialise first using the ASE parent and then CalculatorExt
+        Wann2KCP.__init__(self, atoms=atoms)
+        CalculatorExt.__init__(self, *args, **kwargs)
+
+        self.command = ParallelCommand(os.environ.get('ASE_WANN2KCP_COMMAND',
+                                                      str(bin_directory) + os.path.sep + self.command))
+
+    def is_converged(self):
+        return True
+
+    def is_complete(self):
+        return self.results['job done']

koopmans/calculators/_wannier90.py

@@ -14,7 +14,7 @@
 from koopmans.utils import warn
 from koopmans.settings import Wannier90SettingsDict
 from koopmans.commands import Command
-from ._utils import CalculatorExt, CalculatorABC, qe_bin_directory
+from ._utils import CalculatorExt, CalculatorABC, bin_directory
 
 
 class Wannier90Calculator(CalculatorExt, Wannier90, CalculatorABC):
@@ -31,7 +31,7 @@ def __init__(self, atoms: Atoms, *args, **kwargs):
 
         # Set up the command for running this calculator
         self.command = Command(os.environ.get('ASE_WANNIER90_COMMAND',
-                                              str(qe_bin_directory) + os.path.sep + self.command))
+                                              str(bin_directory) + os.path.sep + self.command))
 
         self.results_for_qc = ['centers', 'spreads']
 

koopmans/io/_calculators.py

@@ -2,28 +2,28 @@
 from typing import Union, List, Type
 from pathlib import Path
 from koopmans.calculators import KoopmansCPCalculator, PWCalculator, Wannier90Calculator, \
-    PW2WannierCalculator, UnfoldAndInterpolateCalculator, Wann2KCCalculator, KoopmansScreenCalculator, \
-    KoopmansHamCalculator
+    PW2WannierCalculator, Wann2KCPCalculator, UnfoldAndInterpolateCalculator, Wann2KCCalculator, \
+    KoopmansScreenCalculator, KoopmansHamCalculator
 
 
 def read_calculator(filenames: Union[Path, List[Path]]) -> Union[KoopmansCPCalculator, PWCalculator,
                                                                  Wannier90Calculator, PW2WannierCalculator,
-                                                                 UnfoldAndInterpolateCalculator,
+                                                                 Wann2KCPCalculator, UnfoldAndInterpolateCalculator,
                                                                  Wann2KCCalculator, KoopmansScreenCalculator,
                                                                  KoopmansHamCalculator]:
 
     # Interpreting the filenames argument
     if not isinstance(filenames, list):
         filenames = [filenames]
-    valid_extensions = ['.cpi', '.cpo', '.pwi', '.pwo', '.win', '.wout', '.p2wi',
-                        '.p2wo', '.uii', '.uio', '.w2ki', '.w2ko', '.ksi', '.kso', '.khi', '.kho']
+    valid_extensions = ['.cpi', '.cpo', '.pwi', '.pwo', '.win', '.wout', '.p2wi', '.p2wo',
+                        '.wki', '.wko', '.uii', '.uio', '.w2ki', '.w2ko', '.ksi', '.kso', '.khi', '.kho']
     if not all([f.is_file() for f in filenames]):
         filenames = [Path(f) for prefix in filenames for f in glob(f'{prefix}.*') if Path(f).suffix in valid_extensions]
     extensions = set([f.suffix for f in filenames])
 
     calc_class: Union[Type[KoopmansCPCalculator], Type[PWCalculator], Type[Wannier90Calculator],
-                      Type[PW2WannierCalculator], Type[UnfoldAndInterpolateCalculator], Type[Wann2KCCalculator],
-                      Type[KoopmansScreenCalculator], Type[KoopmansHamCalculator]]
+                      Type[PW2WannierCalculator], Type[Wann2KCPCalculator], Type[UnfoldAndInterpolateCalculator],
+                      Type[Wann2KCCalculator], Type[KoopmansScreenCalculator], Type[KoopmansHamCalculator]]
 
     if extensions.issubset(set(['.cpi', '.cpo'])):
         calc_class = KoopmansCPCalculator
@@ -33,6 +33,8 @@ def read_calculator(filenames: Union[Path, List[Path]]) -> Union[KoopmansCPCalcu
         calc_class = Wannier90Calculator
     elif extensions.issubset(set(['.p2wi', '.p2wo'])):
         calc_class = PW2WannierCalculator
+    elif extensions.issubset(set(['.wki', '.wko'])):
+        calc_class = Wann2KCPCalculator
     elif extensions.issubset(set(['.uii', '.uio'])):
         calc_class = UnfoldAndInterpolateCalculator
     elif extensions.issubset(set(['.w2ki', '.w2ko'])):

koopmans/settings/__init__.py

@@ -11,6 +11,7 @@
 from ._koopmans_screen import KoopmansScreenSettingsDict
 from ._pw import PWSettingsDict
 from ._pw2wannier import PW2WannierSettingsDict
+from ._wann2kcp import Wann2KCPSettingsDict
 from ._ui import UnfoldAndInterpolateSettingsDict
 from ._utils import Setting, SettingsDict, SettingsDictWithChecks
 from ._wann2kc import Wann2KCSettingsDict
@@ -23,6 +24,7 @@
                               'kc_screen': KoopmansScreenSettingsDict(),
                               'pw': PWSettingsDict(),
                               'pw2wannier': PW2WannierSettingsDict(),
+                              'wann2kcp': Wann2KCPSettingsDict(),
                               'ui': UnfoldAndInterpolateSettingsDict(),
                               'ui_occ': UnfoldAndInterpolateSettingsDict(),
                               'ui_emp': UnfoldAndInterpolateSettingsDict(),

koopmans/settings/_koopmans_cp.py

@@ -1,5 +1,5 @@
 from typing import Dict, Any
-from ase.io.espresso import koopmans_cp as kcp_io
+from ase.io.espresso import kcp_keys
 from pathlib import Path
 from ._utils import SettingsDict
 
@@ -42,7 +42,7 @@ def __init__(self, **kwargs) -> None:
             else:
                 flattened_kwargs[k] = v
 
-        super().__init__(valid=[k for sublist in kcp_io.KEYS.values() for k in sublist],
+        super().__init__(valid=[k for sublist in kcp_keys.values() for k in sublist],
                          defaults=defaults,
                          are_paths=['outdir', 'pseudo_dir'],
                          to_not_parse=['assume_isolated'],

koopmans/settings/_koopmans_ham.py

@@ -1,12 +1,12 @@
 from typing import Any
 from ase.dft.kpoints import BandPath
-from ase.io.espresso import koopmans_ham as kch_io
+from ase.io.espresso import kch_keys
 from ._utils import SettingsDict, kc_wann_defaults
 
 
 class KoopmansHamSettingsDict(SettingsDict):
     def __init__(self, **kwargs) -> None:
-        super().__init__(valid=[k for block in kch_io.KEYS.values() for k in block],
+        super().__init__(valid=[k for block in kch_keys.values() for k in block],
                          defaults={'calculation': 'ham', 'do_bands': True, 'use_ws_distance': True, 'write_hr': True,
                                    'l_alpha_corr': False, **kc_wann_defaults},
                          are_paths=['outdir', 'pseudo_dir'],

koopmans/settings/_koopmans_screen.py

@@ -1,11 +1,11 @@
 from typing import Any
-from ase.io.espresso import koopmans_screen as kcs_io
+from ase.io.espresso import kcs_keys
 from ._utils import SettingsDict, kc_wann_defaults
 
 
 class KoopmansScreenSettingsDict(SettingsDict):
     def __init__(self, **kwargs) -> None:
-        super().__init__(valid=[k for block in kcs_io.KEYS.values() for k in block],
+        super().__init__(valid=[k for block in kcs_keys.values() for k in block],
                          defaults={'calculation': 'screen', 'tr2': 1.0e-18, 'nmix': 4, 'niter': 33,
                                    'check_spread': True, **kc_wann_defaults},
                          are_paths=['outdir', 'pseudo_dir'],

koopmans/settings/_pw.py

@@ -1,5 +1,5 @@
 from typing import Any, Dict
-from ase.io.espresso import pw as pw_io
+from ase.io.espresso import pw_keys
 from ase.dft.kpoints import BandPath
 from ._utils import SettingsDict
 
@@ -14,7 +14,7 @@ def __init__(self, **kwargs) -> None:
             else:
                 flattened_kwargs[k] = v
 
-        super().__init__(valid=[k for block in pw_io.KEYS.values() for k in block],
+        super().__init__(valid=[k for block in pw_keys.values() for k in block],
                          defaults={'calculation': 'scf', 'outdir': './TMP/', 'prefix': 'kc',
                                    'conv_thr': '2.0e-9*nelec', 'verbosity': 'high'},
                          are_paths=['outdir', 'pseudo_dir'],

koopmans/settings/_pw2wannier.py

@@ -5,9 +5,7 @@ class PW2WannierSettingsDict(SettingsDict):
     def __init__(self, **kwargs) -> None:
         super().__init__(valid=['outdir', 'prefix', 'seedname', 'write_mmn',
                                 'write_amn', 'write_uHu', 'uHu_formatted',
-                                'write_unk', 'reduce_unk', 'wan_mode', 'wannier_plot',
-                                'wannier_plot_list', 'gamma_trick', 'spin_component',
-                                'print_rho'],
+                                'write_unk', 'reduce_unk', 'wan_mode', 'spin_component'],
                          defaults={'outdir': 'TMP', 'prefix': 'kc', 'seedname': 'wann',
                                    'wan_mode': 'standalone'},
                          are_paths=['outdir'],

koopmans/settings/_wann2kc.py

@@ -1,5 +1,5 @@
 from typing import Dict, Any, List
-from ase.io.espresso import wann2kc as w2k_io
+from ase.io.espresso import w2kcw_keys
 from ._utils import SettingsDict, kc_wann_defaults
 
 
@@ -14,7 +14,7 @@ def __init__(self, **kwargs) -> None:
             else:
                 flattened_kwargs[k] = v
 
-        super().__init__(valid=[k for block in w2k_io.KEYS.values() for k in block],
+        super().__init__(valid=[k for block in w2kcw_keys.values() for k in block],
                          defaults={'calculation': 'wann2kcw', **kc_wann_defaults},
                          are_paths=['outdir', 'pseudo_dir'],
                          to_not_parse=['assume_isolated'],