Merge pull request #127 from aiidateam/release/1.3.0

Release/1.3.0

.github/workflows/ci.yml

@@ -0,0 +1,39 @@
+name: Continuous Integration
+
+on:
+ [push, pull_request]
+
+jobs:
+
+ test-plugin:
+
+ runs-on: ubuntu-latest
+ timeout-minutes: 30
+
+ steps:
+
+ - uses: actions/checkout@v2
+
+ - name: Install docker
+ run: |
+ sudo apt-get update
+ sudo apt-get install apt-transport-https ca-certificates curl software-properties-common
+ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
+ sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
+ sudo apt-get update
+ sudo apt-get install docker-ce
+
+ - name: Build the Docker image
+ run: |
+ docker build -t aiida_cp2k_test .
+
+ - name: Run aiida_cp2k_test image and test the plugin inside the corresponding container.
+ run: |
+ export DOCKERID=`docker run -d aiida_cp2k_test`
+ docker exec --tty $DOCKERID wait-for-services
+ docker logs $DOCKERID
+ docker exec --tty --user aiida $DOCKERID /bin/bash -l -c 'cd /opt/aiida-cp2k/ && pre-commit run --all-files || ( git status --short ; git diff ; exit 1 )'
+ docker exec --tty --user aiida $DOCKERID /bin/bash -l -c 'cd /opt/aiida-cp2k/ && py.test --cov aiida_cp2k --cov-append .'
+ docker exec --tty --user aiida $DOCKERID /bin/bash -l -c 'cd /opt/aiida-cp2k/docs && make'
+
+

aiida_cp2k/__init__.py

@@ -7,6 +7,6 @@
 ###############################################################################
 """AiiDA-CP2K plugins, parsers, workflows, etc ..."""
 
-__version__ = "1.2.1"
+__version__ = "1.3.0"
 
 # EOF

aiida_cp2k/calculations/__init__.py

@@ -11,8 +11,9 @@
 from operator import add
 
 from aiida.engine import CalcJob
-from aiida.orm import Computer, Dict, SinglefileData, StructureData, RemoteData, BandsData
 from aiida.common import CalcInfo, CodeInfo, InputValidationError
+from aiida.orm import Computer, Dict, RemoteData, SinglefileData
+from aiida.plugins import DataFactory
 
 from ..utils.datatype_helpers import (
  validate_basissets,
@@ -24,6 +25,10 @@
 )
 from ..utils import Cp2kInput
 
+BandsData = DataFactory('array.bands') # pylint: disable=invalid-name
+StructureData = DataFactory('structure') # pylint: disable=invalid-name
+KpointsData = DataFactory('array.kpoints') # pylint: disable=invalid-name
+
 
 class Cp2kCalculation(CalcJob):
  """This is a Cp2kCalculation, subclass of JobCalculation, to prepare input for an ab-initio CP2K calculation.
@@ -46,15 +51,18 @@ def define(cls, spec):
  super(Cp2kCalculation, cls).define(spec)
 
  # Input parameters.
- spec.input('parameters', valid_type=Dict, help='the input parameters')
- spec.input('structure', valid_type=StructureData, required=False, help='the main input structure')
- spec.input('settings', valid_type=Dict, required=False, help='additional input parameters')
- spec.input('resources', valid_type=dict, required=False, help='special settings')
- spec.input('parent_calc_folder', valid_type=RemoteData, required=False, help='remote folder used for restarts')
+ spec.input('parameters', valid_type=Dict, help='The input parameters.')
+ spec.input('structure', valid_type=StructureData, required=False, help='The main input structure.')
+ spec.input('settings', valid_type=Dict, required=False, help='Optional input parameters.')
+ spec.input('parent_calc_folder',
+ valid_type=RemoteData,
+ required=False,
+ help='Working directory of a previously ran calculation to restart from.')
+ spec.input('kpoints', valid_type=KpointsData, required=False, help='Input kpoint mesh.')
  spec.input_namespace('file',
  valid_type=(SinglefileData, StructureData),
  required=False,
- help='additional input files',
+ help='Additional input files.',
  dynamic=True)
 
  spec.input_namespace(
@@ -101,7 +109,7 @@ def define(cls, spec):
  spec.exit_code(301, 'ERROR_OUTPUT_READ', message='The output file could not be read.')
  spec.exit_code(302, 'ERROR_OUTPUT_PARSE', message='The output file could not be parsed.')
  spec.exit_code(303, 'ERROR_OUTPUT_INCOMPLETE', message='The output file was incomplete.')
- spec.exit_code(304, 'ERROR_OUTPUT_CONTAINS_ABORT', message='The output file contains the word "ABORT"')
+ spec.exit_code(304, 'ERROR_OUTPUT_CONTAINS_ABORT', message='The output file contains the word "ABORT".')
  spec.exit_code(312, 'ERROR_STRUCTURE_PARSE', message='The output structure could not be parsed.')
  spec.exit_code(350, 'ERROR_UNEXPECTED_PARSER_EXCEPTION', message='The parser raised an unexpected exception.')
 
@@ -114,9 +122,12 @@ def define(cls, spec):
  message='The ionic minimization cycle did not converge for the given thresholds.')
 
  # Output parameters.
- spec.output('output_parameters', valid_type=Dict, required=True, help='the results of the calculation')
- spec.output('output_structure', valid_type=StructureData, required=False, help='optional relaxed structure')
- spec.output('output_bands', valid_type=BandsData, required=False, help='optional band structure')
+ spec.output('output_parameters',
+ valid_type=Dict,
+ required=True,
+ help='The output dictionary containing results of the calculation.')
+ spec.output('output_structure', valid_type=StructureData, required=False, help='The relaxed output structure.')
+ spec.output('output_bands', valid_type=BandsData, required=False, help='Computed electronic band structure.')
  spec.default_output_node = 'output_parameters'
 
  spec.outputs.dynamic = True
@@ -130,7 +141,7 @@ def prepare_for_submission(self, folder):
 
  # pylint: disable=too-many-statements,too-many-branches
 
- # create cp2k input file
+ # Create cp2k input file.
  inp = Cp2kInput(self.inputs.parameters.get_dict())
  inp.add_keyword("GLOBAL/PROJECT", self._DEFAULT_PROJECT_NAME)
 
@@ -160,6 +171,16 @@ def prepare_for_submission(self, folder):
  validate_pseudos(inp, self.inputs.pseudos, self.inputs.structure if 'structure' in self.inputs else None)
  write_pseudos(inp, self.inputs.pseudos, folder)
 
+ # Kpoints.
+ if 'kpoints' in self.inputs:
+ try:
+ mesh, _ = self.inputs.kpoints.get_kpoints_mesh()
+ except AttributeError:
+ raise InputValidationError("K-point sampling for SCF must be given in mesh form.")
+
+ inp.add_keyword('FORCE_EVAL/DFT/KPOINTS', {'WAVEFUNCTIONS': ' COMPLEX', 'FULL_GRID': '.TRUE.'})
+ inp.add_keyword('FORCE_EVAL/DFT/KPOINTS/SCHEME MONKHORST-PACK', f'{mesh[0]} {mesh[1]} {mesh[2]}')
+
  with io.open(folder.get_abs_path(self._DEFAULT_INPUT_FILE), mode="w", encoding="utf-8") as fobj:
  try:
  fobj.write(inp.render())
@@ -214,21 +235,42 @@ def prepare_for_submission(self, folder):
 
  # Check for left over settings.
  if settings:
- raise InputValidationError("The following keys have been found " +
-  "in the settings input node {}, ".format(self.pk) + "but were not understood: " +
-  ",".join(settings.keys()))
+ raise InputValidationError(
+ f"The following keys have been found in the settings input node {self.pk}, but were not understood: " +
+ ",".join(settings.keys()))
 
  return calcinfo
 
  @staticmethod
  def _write_structure(structure, folder, name):
  """Function that writes a structure and takes care of element tags."""
 
- # Create file with the structure.
- s_ase = structure.get_ase()
- elem_tags = ['' if t == 0 else str(t) for t in s_ase.get_tags()]
- elem_symbols = list(map(add, s_ase.get_chemical_symbols(), elem_tags))
- elem_coords = ['{:25.16f} {:25.16f} {:25.16f}'.format(p[0], p[1], p[2]) for p in s_ase.get_positions()]
+ xyz = _atoms_to_xyz(structure.get_ase())
  with io.open(folder.get_abs_path(name), mode="w", encoding="utf-8") as fobj:
- fobj.write(u'{}\n\n'.format(len(elem_coords)))
- fobj.write(u'\n'.join(map(add, elem_symbols, elem_coords)))
+ fobj.write(xyz)
+
+
+def kind_names(atoms):
+ """Get atom kind names from ASE atoms based on tags.
+
+ Simply append the tag to element symbol. E.g., 'H' with tag 1 becomes 'H1'.
+ Note: This mirrors the behavior of StructureData.get_kind_names()
+
+ :param atoms: ASE atoms instance
+ :returns: list of kind names
+ """
+ elem_tags = ['' if t == 0 else str(t) for t in atoms.get_tags()]
+ return list(map(add, atoms.get_chemical_symbols(), elem_tags))
+
+
+def _atoms_to_xyz(atoms):
+ """Converts ASE atoms to string, taking care of element tags.
+
+ :param atoms: ASE Atoms instance
+ :returns: str (in xyz format)
+ """
+ elem_symbols = kind_names(atoms)
+ elem_coords = ['{:25.16f} {:25.16f} {:25.16f}'.format(p[0], p[1], p[2]) for p in atoms.get_positions()]
+ xyz = f'{len(elem_coords)}\n\n'
+ xyz += u'\n'.join(map(add, elem_symbols, elem_coords))
+ return xyz

aiida_cp2k/parsers/__init__.py

@@ -18,6 +18,7 @@
 from aiida.plugins import DataFactory
 
 StructureData = DataFactory('structure') # pylint: disable=invalid-name
+BandsData = DataFactory('array.bands') # pylint: disable=invalid-name
 
 
 class Cp2kBaseParser(Parser):
@@ -97,7 +98,6 @@ class Cp2kAdvancedParser(Cp2kBaseParser):
  def _parse_stdout(self):
  """Advanced CP2K output file parser."""
 
- from aiida.orm import BandsData
  from aiida_cp2k.utils import parse_cp2k_output_advanced
 
  fname = self.node.process_class._DEFAULT_OUTPUT_FILE # pylint: disable=protected-access

aiida_cp2k/utils/datatype_helpers.py

@@ -37,15 +37,14 @@ def _validate_gdt_namespace(entries, gdt_cls, attr):
 
  for kind, gdt_instance in _unpack(entries):
  if not isinstance(gdt_instance, gdt_cls):
- return "invalid {attr} for '{kind}' specified".format(attr=attr, kind=kind)
+ return f"invalid {attr} for '{kind}' specified"
 
  identifier = _identifier(gdt_instance)
 
  if identifier in identifiers:
  # note: this should be possible for basissets with different versions
  # but at this point we should require some format for the key to match it
- return "{attr} for kind {gdt_instance.element} ({gdt_instance.name}) specified multiple times".format(
- attr=attr, gdt_instance=gdt_instance)
+ return f"{attr} for kind {gdt_instance.element} ({gdt_instance.name}) specified multiple times"
 
  identifiers += [identifier]
 
@@ -113,17 +112,14 @@ def validate_basissets(inp, basissets, structure):
  try:
  basisset_used[(element, bsname)] += 1
  except KeyError:
- raise InputValidationError(("'BASIS_SET {bstype} {bsname}' for element {element} (from kind {kind})"
- " not found in basissets input namespace").format(bsname=bsname,
- bstype=bstype,
- element=element,
- kind=kind))
+ raise InputValidationError(f"'BASIS_SET {bstype} {bsname}' for element {element} (from kind {kind})"
+ " not found in basissets input namespace")
 
  if basisset_kw_used:
  for (sym, name), used in basisset_used.items():
  if not used:
- raise InputValidationError("Basis sets provided in calculation for kind {sym} ({name}),"
- " but not used in input".format(sym=sym, name=name))
+ raise InputValidationError(f"Basis sets provided in calculation for kind {sym} ({name}),"
+ " but not used in input")
  # if all basissets are referenced in the input, we're done
  return
 
@@ -144,9 +140,8 @@ def validate_basissets(inp, basissets, structure):
  bstype = "ORB"
 
  if label not in allowed_labels:
- raise InputValidationError("Basis sets provided in calculation for kind {bset.element} ({bset.name}),"
- " with label {label} could not be matched to a kind in the structure".format(
- bset=bset, label=label))
+ raise InputValidationError(f"Basis sets provided in calculation for kind {bset.element} ({bset.name}),"
+ f" with label {label} could not be matched to a kind in the structure")
 
  if "SUBSYS" not in inp["FORCE_EVAL"]:
  inp["FORCE_EVAL"]["SUBSYS"] = {}
@@ -160,7 +155,7 @@ def validate_basissets(inp, basissets, structure):
  inp["FORCE_EVAL"]["SUBSYS"]["KIND"].append({"_": label})
  kind_sec = inp["FORCE_EVAL"]["SUBSYS"]["KIND"][-1]
 
- kind_sec["BASIS_SET"] = "{bstype} {bset.name}".format(bstype=bstype, bset=bset)
+ kind_sec["BASIS_SET"] = f"{bstype} {bset.name}"
  if "ELEMENT" not in kind_sec:
  kind_sec["ELEMENT"] = bset.element
 
@@ -208,17 +203,14 @@ def validate_pseudos(inp, pseudos, structure):
  try:
  pseudo_used[(element, pname)] += 1
  except KeyError:
- raise InputValidationError(("'POTENTIAL {ptype} {pname}' for element {element} (from kind {kind})"
- " not found in pseudos input namespace").format(pname=pname,
- ptype=ptype,
- element=element,
- kind=kind))
+ raise InputValidationError(f"'POTENTIAL {ptype} {pname}' for element {element} (from kind {kind})"
+ " not found in pseudos input namespace")
 
  if pseudo_kw_used:
  for (sym, name), used in pseudo_used.items():
  if not used:
- raise InputValidationError("Pseudos provided in calculation for kind {sym} ({name}),"
- " but not used in input".format(sym=sym, name=name))
+ raise InputValidationError(f"Pseudos provided in calculation for kind {sym} ({name}),"
+ " but not used in input")
  return
 
  if not structure: # no support for COORD section (yet)
@@ -233,9 +225,8 @@ def validate_pseudos(inp, pseudos, structure):
 
  for label, pseudo in pseudos.items():
  if label not in allowed_labels:
- raise InputValidationError("Pseudo provided in calculation for kind {pseudo.element} ({pseudo.name}),"
- " with label {label} could not be matched to a kind in the structure".format(
- pseudo=pseudo, label=label))
+ raise InputValidationError(f"Pseudo provided in calculation for kind {pseudo.element} ({pseudo.name}),"
+ f" with label {label} could not be matched to a kind in the structure")
 
  if "SUBSYS" not in inp["FORCE_EVAL"]:
  inp["FORCE_EVAL"]["SUBSYS"] = {}
@@ -249,7 +240,7 @@ def validate_pseudos(inp, pseudos, structure):
  inp["FORCE_EVAL"]["SUBSYS"]["KIND"].append({"_": label})
  kind_sec = inp["FORCE_EVAL"]["SUBSYS"]["KIND"][-1]
 
- kind_sec["POTENTIAL"] = "GTH {pseudo.name}".format(pseudo=pseudo)
+ kind_sec["POTENTIAL"] = f"GTH {pseudo.name}"
 
  if "ELEMENT" not in kind_sec:
  kind_sec["ELEMENT"] = pseudo.element

aiida_cp2k/utils/input_generator.py

@@ -150,29 +150,29 @@ def _render_section(output, params, indent=0):
  for key, val in sorted(params.items()):
  # keys are not case-insensitive, ensure that they follow the current scheme
  if key.upper() != key:
- raise ValueError("keyword '{}' not upper case".format(key))
+ raise ValueError(f"keyword '{key}' not upper case.")
 
  if key.startswith(("@", "$")):
- raise ValueError("CP2K preprocessor directives not supported")
+ raise ValueError("CP2K preprocessor directives not supported.")
 
  if isinstance(val, Mapping):
- line = "{}&{}".format(' ' * indent, key)
+ line = f"{' ' * indent}&{key}"
  if "_" in val: # if there is a section parameter, add it
- line += " {}".format(val.pop('_'))
+ line += f" {val.pop('_')}"
  output.append(line)
  Cp2kInput._render_section(output, val, indent + 3)
- output.append('{}&END {}'.format(' ' * indent, key))
+ output.append(f"{' ' * indent}&END {key}")
 
  elif isinstance(val, Sequence) and not isinstance(val, str):
  for listitem in val:
  Cp2kInput._render_section(output, {key: listitem}, indent)
 
  elif isinstance(val, bool):
  val_str = '.TRUE.' if val else '.FALSE.'
- output.append('{}{} {}'.format(' ' * indent, key, val_str))
+ output.append(f"{' ' * indent}{key} {val_str}")
 
  else:
- output.append('{}{} {}'.format(' ' * indent, key, val))
+ output.append(f"{' ' * indent}{key} {val}")
 
 
 @calcfunction