Merge remote-tracking branch 'origin/develop' into gaussian-parser

Author: EBB2675

.gitignore

@@ -128,3 +128,7 @@ dmypy.json
 
 # Pyre type checker
 .pyre/
+
+# MDAnalysis temporary/cache artifacts under tests data
+tests/data/**/*.lock
+tests/data/**/*.npz

pyproject.toml

@@ -34,8 +34,14 @@ license = { file = "LICENSE" }
 dependencies = [
     "nomad-lab>=1.3.16.dev100",
     "nomad-simulations@git+https://github.com/nomad-coe/nomad-simulations.git@develop",
+    "nomad-schema-plugin-simulation-workflow>=1.0.10",
     "python-magic-bin; sys_platform == 'win32'",
     "phonopy>=2.35",
+    "mdanalysis>=2.8.0,<3.0.0 ; python_full_version >= '3.10'",
+    "mdanalysis<2.8 ; python_full_version < '3.10'",
+    "panedr>=0.2",
+    # issue with reading nc file in 1.7.3: https://github.com/Unidata/netcdf4-python/issues/1438
+    "netcdf4<=1.7.2",
 ]
 
 [project.urls]
@@ -145,6 +151,8 @@ gaussian_parser = "nomad_simulation_parsers.parsers:gaussian_parser"
 gaussian_schema_package = "nomad_simulation_parsers.schema_packages:gaussian_schema_package"
 gpaw_parser = "nomad_simulation_parsers.parsers:gpaw_parser"
 gpaw_schema_package = "nomad_simulation_parsers.schema_packages:gpaw_schema_package"
+gromacs_parser = "nomad_simulation_parsers.parsers:gromacs_parser"
+gromacs_schema_package = "nomad_simulation_parsers.schema_packages:gromacs_schema_package"
 h5md_parser = "nomad_simulation_parsers.parsers:h5md_parser"
 h5md_schema_package = "nomad_simulation_parsers.schema_packages:h5md_schema_package"
 lammps_parser = "nomad_simulation_parsers.parsers:lammps_parser"
@@ -158,6 +166,8 @@ vasp_parser = "nomad_simulation_parsers.parsers:vasp_parser"
 vasp_schema_package = "nomad_simulation_parsers.schema_packages:vasp_schema_package"
 wannier90_parser = "nomad_simulation_parsers.parsers:wannier90_parser"
 wannier90_schema_package = "nomad_simulation_parsers.schema_packages:wannier90_schema_package"
+yambo_parser = "nomad_simulation_parsers.parsers:yambo_parser"
+yambo_schema_package = "nomad_simulation_parsers.schema_packages:yambo_schema_package"
 
 
 [tool.cruft]

src/nomad_simulation_parsers/parsers/__init__.py

@@ -131,6 +131,18 @@ class Wannier90ParserEntryPoint(EntryPoint):
     code_category='Atomistic code',
 )
 
+gromacs_parser = EntryPoint(
+    name='parsers/gromacs',
+    aliases=['parsers/gromacs'],
+    description='NOMAD parser for GROMACS.',
+    python_package='nomad_simulation_parsers',
+    mainfile_contents_re=r'gmx mdrun, (VERSION|version)[\s\S]*Input Parameters:',
+    parser_class_name='nomad_simulation_parsers.parsers.gromacs.parser.GromacsParser',
+    code_name='GROMACS',
+    code_homepage='http://www.gromacs.org/',
+    code_category='Atomistic code',
+)
+
 h5md_parser = EntryPoint(
     name='parsers/h5md',
     aliases=['parsers/h5md'],
@@ -223,3 +235,15 @@ class Wannier90ParserEntryPoint(EntryPoint):
     code_homepage='http://www.wannier.org/',
     code_category='Atomistic code',
 )
+
+yambo_parser = EntryPoint(
+    name='parsers/yambo',
+    aliases=['parsers/yambo'],
+    description='NOMAD parser for YAMBO.',
+    parser_class_name='nomad_simulation_parsers.parsers.yambo.parser.YamboParser',
+    python_package='nomad_simulation_parsers',
+    mainfile_contents_re=r'Build[\s\S]+?http://www\.yambo-code\.org',
+    code_name='YAMBO',
+    code_homepage='http://www.yambo-code.org/',
+    code_category='Atomistic code',
+)

src/nomad_simulation_parsers/parsers/fhiaims/parser.py

@@ -372,8 +372,8 @@ def get_forces(
                     f'../upload/archive/mainfile/{mainfile}'
                 )
             # check if supercell match calculation cell
-            calc_cell: Atoms = (
-                archive.data.model_system[-1].cell[-1].to_ase_atoms(self.logger)
+            calc_cell: Atoms = archive.data.model_system[-1].to_ase_atoms(
+                logger=self.logger
             )
             supercell_atoms = Atoms(
                 positions=supercell.positions,

src/nomad_simulation_parsers/parsers/gromacs/common.py

@@ -0,0 +1,12 @@
+RE_FLOAT = r'[-+]?\d+\.*\d*(?:[Ee][-+]\d+)?'
+RE_N = r'[\n\r]'
+
+
+def to_float(string: str | None) -> float | None:
+    if string is None:
+        return None
+    try:
+        value = float(string)
+    except ValueError:
+        value = None
+    return value

src/nomad_simulation_parsers/parsers/gromacs/edr_parser.py

@@ -0,0 +1,37 @@
+import numpy as np
+import panedr
+from nomad.parsing.file_parser import FileParser
+
+
+class GromacsEDRParser(FileParser):
+    @property
+    def fileedr(self):
+        if self._file_handler is None:
+            try:
+                self._file_handler = panedr.edr_to_df(self.mainfile)
+            except Exception:
+                self.logger.error('Error reading edr file.')
+
+        return self._file_handler
+
+    def parse(self, key: str):
+        if self.fileedr is None:
+            return
+
+        val = self.fileedr.get(key, None)
+        if self._results is None:
+            self._results = dict()
+
+        if val is not None:
+            val = np.asarray(val)
+
+        self._results[key] = val
+
+    def keys(self) -> list[str]:
+        if self.fileedr is None:
+            return []
+        return list(self.fileedr.keys())
+
+    @property
+    def length(self) -> int:
+        return self.fileedr.shape[0]

src/nomad_simulation_parsers/parsers/gromacs/log_parser.py

@@ -0,0 +1,165 @@
+import re
+from typing import Any
+
+from nomad.parsing.file_parser.text_parser import Quantity, TextParser
+
+from .common import RE_N, to_float
+
+
+def str_to_header(block: str) -> dict[str, Any]:
+    n_val = 2
+    val = [v.split(':', 1) for v in block.strip().splitlines()]
+    return {v[0].strip(): v[1].strip() for v in val if len(v) == n_val}
+
+
+def str_to_input_parameters(block: str) -> dict[str, Any]:
+    re_section = re.compile(r'^\s*([\w\-]+):\s*$')
+    re_subsection = re.compile(r'^\s*([\w\-]+\s[\d]+):\s*$')
+    re_scalar = re.compile(r'\s*([\w\-]+)\s*[=:]\s*(.+)')
+    re_array = re.compile(r'\s*([\w\-]+)\[[\d ]+\]\s*=\s*\{*(.+)')
+    re_shorthand_array = re.compile(
+        r'\s*([\w\-]+)\[\d+,\.\.\.,\d+\]\s*=\s*\{(\d+),\.\.\.,(\d+)\}'
+    )
+
+    parameters = dict()
+    stack = [parameters]  # Stack to track the current context
+    indent_levels = []  # To track the indentation levels
+
+    for line in block.strip().splitlines():
+        val_n = line.rstrip()  # Remove trailing spaces
+        if not val_n:
+            continue
+
+        # Calculate the indentation level
+        current_indent = len(val_n) - len(val_n.lstrip())
+
+        # Handle end of section based on indentation
+        while indent_levels and current_indent <= indent_levels[-1]:
+            stack.pop()
+            indent_levels.pop()
+
+        # Check for section or subsection
+        if match := (re_section.match(val_n) or re_subsection.match(val_n)):
+            key = match.group(1)
+            stack[-1][key] = {}
+            stack.append(stack[-1][key])
+            indent_levels.append(current_indent)
+        # Check for scalar
+        elif match := re_scalar.match(val_n):
+            key = match.group(1)
+            value = match.group(2)
+            if value.lower() in ['true', 'false']:
+                value = value.lower() == 'true'
+            elif value.replace('.', '', 1).isdigit():
+                value = float(value) if '.' in value else int(value)
+            stack[-1][key] = value
+        # Check for shorthand array
+        elif match := re_shorthand_array.match(val_n):
+            array_key = match.group(1)
+            start = int(match.group(2))
+            end = int(match.group(3))
+            stack[-1][array_key] = list(range(start, end + 1))
+        # Check for array
+        elif match := re_array.match(val_n):
+            array_key = match.group(1)
+            value = [float(v) for v in match.group(2).rstrip('}').split(',')]
+            stack[-1].setdefault(array_key, [])
+            stack[-1][array_key].append(value[0] if len(value) == 1 else value)
+    return parameters
+
+
+def str_to_energies(block: str) -> dict[str, float]:
+    thermo_common = [
+        r'Total Energy',
+        r'Potential',
+        r'Kinetic En.',
+        r'Temperature',
+        r'Pressure \(bar\)',
+        r'LJ \(SR\)',
+        r'Coulomb \(SR\)',
+        r'Proper Dih.',
+    ]
+    n_chars_val = re.search(rf'( +{"| +".join(thermo_common)})', block)
+    n_chars_val = len(n_chars_val.group(1)) if n_chars_val is not None else None
+    if n_chars_val is None:
+        n_chars_val = 15
+    energies = {}
+    rows = [v for v in block.splitlines() if v]
+    for n in range(0, len(rows), 2):
+        pointer = 0
+        while pointer < len(rows[n]):
+            key = rows[n][pointer : pointer + n_chars_val].strip()
+            value = rows[n + 1][pointer : pointer + n_chars_val]
+            float_value = to_float(value)
+            if float_value is not None:
+                energies[key] = to_float(value)
+            pointer += n_chars_val
+    return energies
+
+
+def str_to_step_info(block: str) -> dict[str, float]:
+    val = block.strip().splitlines()
+    keys = val[0].split()
+    values = [to_float(v) for v in val[1].split()]
+    return {key: values[n] for n, key in enumerate(keys) if values[n] is not None}
+
+
+class GromacsLogParser(TextParser):
+    def init_quantities(self):
+        thermo_quantities = [
+            Quantity(
+                'energies',
+                r'Energies \(kJ/mol\).*\n(\s*[\s\S]+?)(?:\n.*step.* load imb.*|\n\n)',
+                str_operation=str_to_energies,
+                convert=False,
+            ),
+            Quantity(
+                'step_info',
+                rf'{RE_N}\s*(Step.+\n[\d\.\- ]+)',
+                str_operation=str_to_step_info,
+                convert=False,
+            ),
+        ]
+
+        self._quantities = [
+            Quantity('time_start', r'Log file opened on (.+)', flatten=False),
+            Quantity(
+                'host_info',
+                r'Host:\s*(\S+)\s*pid:\s*(\d+)\s*'
+                r'rank ID:\s*(\d+)\s*number of ranks:\s*(\d*)',
+            ),
+            Quantity(
+                'module_version', r'GROMACS:\s*(.+?),\s*VERSION\s*(\S+)', flatten=False
+            ),
+            Quantity('execution_path', r'Executable:\s*(.+)'),
+            Quantity('working_path', r'Data prefix:\s*(.+)'),
+            # TODO cannot understand treatment of the command line in the old parser
+            Quantity(
+                'header',
+                r'(?:GROMACS|Gromacs) (20[\s\S]+?)\n\n',
+                str_operation=str_to_header,
+            ),
+            Quantity(
+                'header',
+                r'(?:GROMACS|Gromacs) (version:[\s\S]+?)\n\n',
+                str_operation=str_to_header,
+            ),
+            Quantity(
+                'input_parameters',
+                r'Input Parameters:\s*\n([\s\S]+?)\n\n',
+                str_operation=str_to_input_parameters,
+            ),
+            Quantity('maximum_force', r'Norm of force\s*([\s\S]+?)\n\n', flatten=False),
+            Quantity(
+                'step',
+                r'(Step\s*Time[\s\S]+?Energies[\s\S]+?\n\n)',
+                repeats=True,
+                sub_parser=TextParser(quantities=thermo_quantities),
+            ),
+            Quantity(
+                'averages',
+                r'A V E R A G E S  ====>([\s\S]+?\n\n\n)',
+                sub_parser=TextParser(quantities=thermo_quantities),
+            ),
+            Quantity('time_end', r'Finished \S+ on rank \d+ (.+)', flatten=False),
+        ]