diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
new file mode 100644
index 00000000..0b65d021
--- /dev/null
+++ b/.github/workflows/workflow.yml
@@ -0,0 +1,49 @@
+name: CodeCov
+on: [push, pull_request]
+jobs:
+ run:
+ runs-on: ubuntu-latest
+ env:
+ OS: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v3
+ - name: Setup Python
+ uses: actions/setup-python@v4
+ with:
+ python-version: "3.10"
+ - name: Install dependencies
+ run: |
+ python -m pip install --upgrade pip
+ pip install -r kvnchv/requirements.txt
+ pip install -e kvnchv/
+ pip install pytest pytest-cov pytest-assume
+ - name: Build qe from source
+ run: |
+ sudo apt-get install -y --no-install-recommends \
+ autoconf \
+ build-essential \
+ ca-certificates \
+ gfortran \
+ libblas3 \
+ libc6 \
+ libfftw3-dev \
+ libgcc-s1 \
+ liblapack-dev \
+ wget
+ cd $HOME
+ wget https://gitlab.com/QEF/q-e/-/archive/qe-7.1/q-e-qe-7.1.tar.gz
+ tar -xzf q-e-qe-7.1.tar.gz
+ cd q-e-qe-7.1
+ ./configure
+ make pw
+ echo 'export PATH="$HOME/q-e-qe-7.1/bin:$PATH"' >> ~/.bashrc
+ source ~/.bashrc
+ - name: Run pytest
+ run: |
+ pytest --rootdir=/home/runner/work/rewotes/rewotes/kvnchv/ --cov=kvnchv/converger --cov-report=xml --verbose kvnchv/tests
+ - name: Build coverage report
+ run: coverage lcov
+ - name: Upload coverage reports to Codecov
+ uses: codecov/codecov-action@v3
+ with:
+ files: ./coverage.lcov
diff --git a/kvnchv/.coverage b/kvnchv/.coverage
new file mode 100644
index 00000000..8c6244fc
Binary files /dev/null and b/kvnchv/.coverage differ
diff --git a/kvnchv/.gitignore b/kvnchv/.gitignore
new file mode 100644
index 00000000..13df159d
--- /dev/null
+++ b/kvnchv/.gitignore
@@ -0,0 +1,13 @@
+# environment
+venv
+.vscode/
+
+# packaging
+*.egg-info/
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+
+# testing files
+tests/.pytest_cache
+tests/resources/*/outdir/
diff --git a/kvnchv/.pre-commit-config.yaml b/kvnchv/.pre-commit-config.yaml
new file mode 100644
index 00000000..62f6db17
--- /dev/null
+++ b/kvnchv/.pre-commit-config.yaml
@@ -0,0 +1,13 @@
+repos:
+ - repo: https://github.com/pycqa/flake8
+ rev: 5.0.4
+ hooks:
+ - id: flake8
+ additional_dependencies:
+ - flake8-import-order
+ args: ['--config=kvnchv/setup.cfg']
+ - repo: https://github.com/pycqa/pydocstyle
+ rev: 4.0.0 # pick a git hash / tag to point to
+ hooks:
+ - id: pydocstyle
+ args: ['--config=kvnchv/setup.cfg']
diff --git a/kvnchv/README.md b/kvnchv/README.md
new file mode 100644
index 00000000..199b1d6c
--- /dev/null
+++ b/kvnchv/README.md
@@ -0,0 +1,62 @@
+# K-point convergence tracker (Materials)
+
+> Ideal candidate: scientists skilled in Density Functional Theory and proficient in python.
+
+# Overview
+
+The aim of this task is to create a python package that implements automatic convergence tracking mechanism for a materials simulations engine. The convergence is tracked with respect to the k-point sampling inside a reciprocal cell of a crystalline compound.
+
+# Requirements
+
+1. automatically find the dimensions of a k-point mesh that satisfy a certain criteria for total energy (eg. total energy is converged within dE = 0.01meV)
+1. the code shall be written in a way that can facilitate easy addition of convergence wrt other characteristics extracted from simulations (forces, pressures, phonon frequencies etc)
+1. the code shall support VASP or Quantum ESPRESSO
+
+# Expectations
+
+- correctly find k-point mesh that satisfies total energy convergence parameters for a set of 10 materials, starting from Si2, as simplest, to a 10-20-atom supercell of your choice
+- modular and object-oriented implementation
+- commit early and often - at least once per 24 hours
+
+# Timeline
+
+We leave exact timing to the candidate. Must fit Within 5 days total.
+
+# User story
+
+As a user of this software I can start it passing:
+
+- path to input data (eg. pw.in / POSCAR, INCAR, KPOINTS) and
+- kinetic energy cutoff
+
+as parameters and get the k-point dimensions (eg. 5 5 5).
+
+# Operating assumptions
+
+The assumed directory structure is:
+```
+rundir/
+ pw.in
+ pseudo/
+ potentialfile.UPF
+```
+
+The input file should be named `pw.in` and is assumed to have the following:
+
+&CONTROL section contains the following fixed parameters
+- outdir = 'outdir'
+- pseudo_dir = 'pseudo'
+- prefix='__prefix__',
+- tstress = .true.
+- tprnfor = .true.
+
+Automatically generated uniform of k-points, i.e. `K_POINTS automatic`
+- K_POINTS is the last "card" in the input
+
+
+# Notes
+
+- *create an account at exabyte.io and use it for the calculation purposes*
+ - Could authenticate API but not submit jobs succesfully.
+ - Package tests are with a local quantum ESPRESSO install.
+- suggested modeling engine: Quantum ESPRESSO
diff --git a/kvnchv/converger/__init__.py b/kvnchv/converger/__init__.py
new file mode 100644
index 00000000..3a86d814
--- /dev/null
+++ b/kvnchv/converger/__init__.py
@@ -0,0 +1,3 @@
+from .manager import Manager
+from .solvers import EspressoSolver
+from .version import __version__
diff --git a/kvnchv/converger/exceptions.py b/kvnchv/converger/exceptions.py
new file mode 100644
index 00000000..112d8344
--- /dev/null
+++ b/kvnchv/converger/exceptions.py
@@ -0,0 +1,29 @@
+"""Custom exceptions."""
+
+
+class InputFilesNotFoundError(Exception):
+ """Error when the provided input path string is not a valid Path."""
+
+
+class TargetOutputNotFoundError(Exception):
+ """Error when requested target variable was not found in solver results."""
+
+
+class SolverSubprocessFailedError(Exception):
+ """Return processed subprocess error."""
+
+
+class SolverNotImplementedError(Exception):
+ """Error when the requested solver is not implemented."""
+
+
+class SolverNotInstalledError(Exception):
+ """Error when the requested solver is not installed."""
+
+
+class UnsupportedParameterError(Exception):
+ """Error when provided parameters are unsupported."""
+
+
+class EspressoOutputNotFoundError(Exception):
+ """Error when expected espresso output XML file was not found."""
diff --git a/kvnchv/converger/manager.py b/kvnchv/converger/manager.py
new file mode 100644
index 00000000..9b30fcb9
--- /dev/null
+++ b/kvnchv/converger/manager.py
@@ -0,0 +1,130 @@
+"""Convergence workflow manager."""
+import itertools
+from copy import deepcopy
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from jsonschema import ValidationError, validate
+
+from .exceptions import (InputFilesNotFoundError,
+ SolverNotImplementedError,
+ TargetOutputNotFoundError
+ )
+from .schema import input_schema
+from .solvers import EspressoSolver
+
+solvers = {"espresso": EspressoSolver}
+
+
+class Manager():
+ """Main class for convergence workflow run."""
+
+ def __init__(self, input_dict: dict):
+ self.input_dict: dict = deepcopy(input_dict)
+ self.schema: dict = input_schema # schema to validate against
+
+ self.solver_input: dict # solver-configuration
+ self.input_path: Path
+ self.target: str # convergence target value name
+ self.tol: float # tolerance (absolute) to satisfy
+ self.parameter_space: list # list of input parameter specifications
+
+ self.data: pd.DataFrame # DataFrame for parameter sets and outputs
+
+ self.validate_schema()
+ self._parse_input()
+
+ def _parse_input(self):
+ """Convert input dict to class attrs."""
+ for param, val in self.input_dict.items():
+ # special handling for input path
+ if param == "input_path":
+ if not Path(val).exists():
+ raise InputFilesNotFoundError
+ self.input_path = Path(val)
+ else:
+ setattr(self, param, val)
+
+ def validate_schema(self):
+ """Validate against schema."""
+ try:
+ validate(self.input_dict, self.schema)
+ except ValidationError as err:
+ raise err
+ return True
+
+ def _get_solver(self, run_params: dict):
+ """Initialize solver object."""
+ if self.solver_input["name"] not in solvers:
+ raise SolverNotImplementedError
+
+ return solvers[self.solver_input["name"]](
+ self.solver_input,
+ self.input_path,
+ run_params
+ )
+
+ def run(self):
+ """Run convergence workflow."""
+ self.process_parameters()
+ return_target = np.zeros(len(self.data))
+ return_target.fill((np.nan))
+ return_reldelta = np.zeros(len(self.data))
+ return_reldelta.fill((np.nan))
+
+ # run first iteration
+ target_prev = 0.0
+ target_eval = self.run_solver(0)
+ return_target[0] = target_eval
+
+ rel_tol = (target_eval - target_prev) / target_eval
+ return_reldelta[0] = rel_tol
+ target_prev = target_eval
+
+ converged = False
+ for run_idx in range(1, len(self.data)):
+ if abs(rel_tol) < self.tol:
+ # assemble results dataframe
+ converged = True
+ break
+ target_eval = self.run_solver(run_idx)
+ return_target[run_idx] = target_eval
+
+ rel_tol = (target_eval - target_prev) / target_prev
+ return_reldelta[run_idx] = rel_tol
+ target_prev = target_eval
+
+ # update job results data
+ self.data[self.target] = return_target
+ self.data["relative_tol"] = return_reldelta
+ self.data = self.data.dropna()
+
+ if converged:
+ return 0
+ return 1
+
+ def run_solver(self, idx: int) -> float:
+ """Run solver for parameter set 'idx' and extract target converence value."""
+ run_params = dict(self.data.iloc[idx])
+ solver = self._get_solver(run_params)
+ solver.run()
+ if self.target not in solver.results.keys():
+ err_string = (f"{self.target} not found in results."
+ f"Possible values are {list(solver.results.keys())}")
+ raise TargetOutputNotFoundError(err_string)
+ return solver.results[self.target]
+
+ def process_parameters(self):
+ """Process parameter_space input values define simulation set."""
+ param_arrays = []
+ param_names = []
+ for param_d in deepcopy(self.parameter_space):
+ # if delta is not provided, assume unit step
+ del_p = 1.0 if "delta" not in param_d else param_d["delta"]
+ param_names.append(param_d["name"])
+ param_arrays.append(np.arange(param_d["start"], param_d["max"]+del_p, del_p))
+
+ self.data = pd.DataFrame(
+ list(itertools.product(*param_arrays)),
+ columns=param_names)
diff --git a/kvnchv/converger/schema.py b/kvnchv/converger/schema.py
new file mode 100644
index 00000000..e2d5274e
--- /dev/null
+++ b/kvnchv/converger/schema.py
@@ -0,0 +1,62 @@
+"""Input schema for Manager convergence workflow."""
+
+solver_schema = {
+ "description": "Solver parameters",
+ "type": "object",
+ "properties": {
+ "name": {
+ "description": "Name of solver type.",
+ "type": "string"
+ },
+ "solver_path": {
+ "description": "Explicit path to solver.",
+ "type": "string"
+ },
+ },
+ "required": ["name"]
+}
+
+input_schema = {
+ "type": "object",
+ "properties": {
+ "solver_input": solver_schema,
+ "input_path": {
+ "description": "Path containing required files for solver.",
+ "type": "string"
+ },
+ "tol": {
+ "description": "Minimum relative tolerance for target quantity.",
+ "type": "number"
+ },
+ "target": {
+ "description": "Output quantity to converge.",
+ "type": "string",
+ },
+ "parameter_space": {
+ "description": "Parametric space to evaluate convergence on.",
+ "type": "array",
+ "items": {
+ "type": "object",
+ "properties": {
+ "name": {
+ "description": "Parameter name",
+ "type": "string"
+ },
+ "start": {
+ "description": "Initial parameter value.",
+ "type": "number"
+ },
+ "max": {
+ "description": "Final parameter value.",
+ "type": "number"
+ },
+ "delta": {
+ "description": "Step size between parameters"
+ }
+ },
+ "required": ["name", "start", "max"]
+ }
+ }
+ },
+ "required": ["solver_input", "input_path", "tol", "target", "parameter_space"]
+}
diff --git a/kvnchv/converger/solvers/__init__.py b/kvnchv/converger/solvers/__init__.py
new file mode 100644
index 00000000..caa22176
--- /dev/null
+++ b/kvnchv/converger/solvers/__init__.py
@@ -0,0 +1 @@
+from .espresso_solver import EspressoSolver
diff --git a/kvnchv/converger/solvers/base_solver.py b/kvnchv/converger/solvers/base_solver.py
new file mode 100644
index 00000000..1055ef47
--- /dev/null
+++ b/kvnchv/converger/solvers/base_solver.py
@@ -0,0 +1,84 @@
+"""Base solver class."""
+import shutil
+from abc import ABC, abstractmethod
+from copy import deepcopy
+from pathlib import Path
+
+from ..exceptions import (SolverNotInstalledError,
+ UnsupportedParameterError)
+
+# solver name and executable name on path
+implemented_solvers = {"espresso": "pw.x"}
+
+
+class BaseSolver(ABC):
+ """Base class for solver implementations.
+
+ Attributes
+ ----------
+ input_dict : dict
+ Contains name and solver_path
+ input_path : str
+ Directory containing expected input structure
+ parameter_set : dict
+ Parameter name(s) and value(s) to replace in the provided input file
+ supported_parameters : list
+ Valid parameterizable inputs, correspond to keys in parameter_set
+ results : dict
+ All implemented return values from simulation. Keys match 'target'
+ solver_path : Path
+ Resolved solver path, provided or default (on PATH)
+ """
+
+ def __init__(self, input_dict: dict, input_path: str, parameter_set: dict):
+ """Construct base Solver object.
+
+ Parameters
+ ----------
+ input_dict : dict
+ Contains name and solver_path
+ input_path : str
+ Directory containing expected input structure
+ parameter_set : dict
+ Parameter name(s) and value(s) to replace in the provided input file
+ """
+ self.input_dict: dict = deepcopy(input_dict)
+ self.input_path: Path = input_path
+ self.parameter_set: dict = parameter_set
+ self.supported_parameters: list = []
+ self.results: dict = {}
+ self.solver_path: Path = self._validate_solver_path()
+
+ @abstractmethod
+ def run(self):
+ """Run solver-specific executable command."""
+ raise NotImplementedError
+
+ @abstractmethod
+ def parse_output(self, outdir: Path):
+ """Implement solver-specific output format parsing."""
+ raise NotImplementedError
+
+ def _validate_solver_path(self) -> Path:
+ """Check solver is installed locally."""
+ if "solver_path" in self.input_dict:
+ try_path = self.input_dict["solver_path"]
+ # fallback to check for solver on PATH
+ if not Path(try_path).exists():
+ try_path = shutil.which(implemented_solvers[self.input_dict["name"]])
+ else:
+ try_path = shutil.which(implemented_solvers[self.input_dict["name"]])
+
+ if not Path(try_path).exists():
+ raise SolverNotInstalledError
+ return Path(try_path)
+
+ def _validate_parameters(self):
+ """Check editable parameters are supported."""
+ if not all(param in self.supported_parameters for param in self.parameter_set):
+ raise UnsupportedParameterError
+
+ @abstractmethod
+ def _generate_new_file(self, new_input_fname: str):
+ """Implement solver-specific input file parameter replacement."""
+ raise NotImplementedError
diff --git a/kvnchv/converger/solvers/espresso_solver.py b/kvnchv/converger/solvers/espresso_solver.py
new file mode 100644
index 00000000..136efe4a
--- /dev/null
+++ b/kvnchv/converger/solvers/espresso_solver.py
@@ -0,0 +1,101 @@
+"""Solver implementations for Quantum Espresso."""
+import re
+import subprocess
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+import numpy as np
+
+from .base_solver import BaseSolver
+from ..exceptions import EspressoOutputNotFoundError, SolverSubprocessFailedError
+
+
+class EspressoSolver(BaseSolver):
+ """Derived class for quantum espresso simulations.
+
+ Attributes
+ ----------
+ supported_parameters : list
+ String keys corresponding to implemented search/replace methods.
+ default_input_name : str
+ Default input file name to copy/replace parameters in.
+ params_string : str
+ String built from provided param, value pairs to generate input file copies.
+ """
+
+ def __init__(self, input_dict: dict, input_path: Path, parameter_set: dict):
+ super().__init__(input_dict, input_path, parameter_set)
+ self.supported_parameters: list = ["k"]
+ self.default_input_name: str = "pw.in"
+ self._validate_parameters()
+ self.params_string: str = "_".join(f"{k}-{v}" for k, v in self.parameter_set.items())
+
+ def run(self):
+ """Run solver subprocess."""
+ # modify input file based on parameters
+ run_input_file = f"{self.default_input_name}_{self.params_string}"
+ run_output_dir = f"outdir_{self.params_string}"
+ self._generate_new_file(run_input_file, run_output_dir)
+
+ # run solver in input_path
+ run_cmd = f"{self.solver_path} < {self.input_path.joinpath(run_input_file)}"
+ result = subprocess.run(run_cmd, check=False, shell=True,
+ cwd=self.input_path, capture_output=True, text=True)
+ output = result.stdout
+ if result.returncode:
+ raise SolverSubprocessFailedError(self._process_errors(output))
+
+ self.parse_output(run_output_dir)
+
+ def parse_output(self, outdir: Path):
+ """Parse XML output and save as dict."""
+ result_xml = self.input_path.joinpath(outdir, "__prefix__.xml")
+ if not result_xml.exists():
+ raise EspressoOutputNotFoundError
+ tree = ET.parse(result_xml)
+ self.results["etot"] = self.parse_etot(tree)
+ self.results["fnorm"] = self.parse_forces(tree)
+
+ @staticmethod
+ def parse_etot(tree: ET) -> float:
+ """Get value of etot in result tree."""
+ return float(tree.findall('output/total_energy/etot')[0].text)
+
+ @staticmethod
+ def parse_forces(tree: ET) -> float:
+ """Return norm of force vector on all atoms."""
+ forces = tree.findall('output/forces')[0].text.strip().split("\n")
+ fvecs = np.array([f.split() for f in forces], dtype='float')
+ return np.linalg.norm(fvecs)
+
+ @staticmethod
+ def _process_errors(stdout: str):
+ """Identify exact error for failed subprocess."""
+ # espresso does not output CRASH in the cwd
+ return re.search(r"Error.*\s*.+", stdout)[0]
+
+ def _generate_new_file(self, new_input_fname: str, outdir: str = ''):
+ """Modify input file to update specified parameters."""
+ with open(self.input_path.joinpath(self.default_input_name), 'r') as default_fp:
+ original_lines = default_fp.read()
+
+ # set output dir
+ new_lines = original_lines.replace("'outdir'", f"'{outdir}'")
+
+ for param, value in self.parameter_set.items():
+ regex, replace_string = getattr(self, f"_match_{param}")(value)
+ new_lines = re.sub(regex, replace_string, new_lines)
+
+ with open(self.input_path.joinpath(new_input_fname), 'w+') as new_fp:
+ new_fp.write(new_lines)
+
+ @staticmethod
+ def _match_k(value: int):
+ """Return match regex and replace_string.
+
+ Room for flexibility improvement. Assumptions:
+ - K_POINTS automatic is used.
+ - K_POINTS is the last command issued
+ """
+ return ("K_POINTS automatic.*",
+ f"K_POINTS automatic\n{value} {value} {value} 0 0 0")
diff --git a/kvnchv/converger/version.py b/kvnchv/converger/version.py
new file mode 100644
index 00000000..789a7dca
--- /dev/null
+++ b/kvnchv/converger/version.py
@@ -0,0 +1,2 @@
+"""Package version attribute."""
+__version__ = "0.1.0"
diff --git a/kvnchv/pyproject.toml b/kvnchv/pyproject.toml
new file mode 100644
index 00000000..8cf32563
--- /dev/null
+++ b/kvnchv/pyproject.toml
@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
\ No newline at end of file
diff --git a/kvnchv/requirements.txt b/kvnchv/requirements.txt
new file mode 100644
index 00000000..3d4b7eab
--- /dev/null
+++ b/kvnchv/requirements.txt
@@ -0,0 +1,3 @@
+jsonschema==4.17.3
+numpy==1.24.2
+pandas==1.5.3
diff --git a/kvnchv/setup.cfg b/kvnchv/setup.cfg
new file mode 100644
index 00000000..bafb8ac1
--- /dev/null
+++ b/kvnchv/setup.cfg
@@ -0,0 +1,33 @@
+[metadata]
+name = converger
+version = attr: converger.version.__version__
+author = Kevin C
+author_email = kvnchv@gmail.com
+description = ReWoTe Convergence
+long_description = file: README.md
+long_description_content_type = text/markdown
+
+[options]
+package_dir =
+ = .
+packages = find:
+python_requires = >= 3.6
+
+[pydocstyle]
+convention = numpy
+ignore-decorators = property
+add-ignore = D104
+
+[flake8]
+max-line-length = 99
+import-order-style = pycharm
+per-file-ignores =
+# imported but unused
+ __init__.py: F401
+exclude =
+ .git
+ venv
+
+[tool:pytest]
+markers =
+ espresso: marks tests as requiring Quantum Espresso install
diff --git a/kvnchv/tests/demo_notebook.ipynb b/kvnchv/tests/demo_notebook.ipynb
new file mode 100644
index 00000000..f023f6b9
--- /dev/null
+++ b/kvnchv/tests/demo_notebook.ipynb
@@ -0,0 +1,963 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from copy import deepcopy\n",
+ "from pathlib import Path\n",
+ "\n",
+ "import seaborn as sns\n",
+ "from converger import Manager"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Most test structures obtained from https://gitlab.com/QEF/q-e/-/tree/master/PW/examples\n",
+ "\n",
+ "examples = Path.home().joinpath(\"examples\")\n",
+ "\n",
+ "# default base input values\n",
+ "base_input = {\n",
+ " \"solver_input\": {\n",
+ " \"name\": \"espresso\",\n",
+ " },\n",
+ " \"input_path\": '',\n",
+ " \"target\": \"etot\",\n",
+ " \"tol\": 1.0e-5,\n",
+ " \"parameter_space\": [\n",
+ " {\n",
+ " \"name\": \"k\",\n",
+ " \"start\": 1,\n",
+ " \"max\": 10,\n",
+ " \"delta\": 1\n",
+ " },\n",
+ " ]\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " k | \n",
+ " etot | \n",
+ " relative_tol | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " 1 | \n",
+ " -1.937625 | \n",
+ " 1.000000 | \n",
+ "
\n",
+ " \n",
+ " | 1 | \n",
+ " 2 | \n",
+ " -1.937829 | \n",
+ " 0.000106 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# Al - single atom\n",
+ "al_dir = str(examples.joinpath(\"Al\"))\n",
+ "input_al = deepcopy(base_input)\n",
+ "input_al['input_path'] = al_dir\n",
+ "input_al['tol'] = 2.0e-4\n",
+ "\n",
+ "m1 = Manager(input_al)\n",
+ "m1.run()\n",
+ "sns.relplot(data=m1.data, x='k', y='etot', kind='line', marker='o')\n",
+ "m1.data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# Si2 2 atom\n",
+ "\n",
+ "si_dir = str(examples.joinpath(\"Si\"))\n",
+ "input_si = deepcopy(base_input)\n",
+ "input_si['input_path'] = si_dir\n",
+ "\n",
+ "m2 = Manager(input_si)\n",
+ "m2.run()\n",
+ "sns.relplot(m2.data, x='k', y='etot', kind='line', marker='o')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# GaAs 2 atom\n",
+ "gaas_dir = str(examples.joinpath(\"GaAs\"))\n",
+ "input_gass = deepcopy(base_input)\n",
+ "input_gass['input_path'] = gaas_dir\n",
+ "\n",
+ "m2_2 = Manager(input_gass)\n",
+ "m2_2.run()\n",
+ "sns.relplot(m2_2.data, x='k', y='etot', kind='line', marker='o')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " k | \n",
+ " etot | \n",
+ " relative_tol | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " 1 | \n",
+ " -365.096798 | \n",
+ " 1.000000 | \n",
+ "
\n",
+ " \n",
+ " | 1 | \n",
+ " 2 | \n",
+ " -365.839634 | \n",
+ " 0.002035 | \n",
+ "
\n",
+ " \n",
+ " | 2 | \n",
+ " 3 | \n",
+ " -365.772991 | \n",
+ " -0.000182 | \n",
+ "
\n",
+ " \n",
+ " | 3 | \n",
+ " 4 | \n",
+ " -365.817309 | \n",
+ " 0.000121 | \n",
+ "
\n",
+ " \n",
+ " | 4 | \n",
+ " 5 | \n",
+ " -365.827799 | \n",
+ " 0.000029 | \n",
+ "
\n",
+ " \n",
+ " | 5 | \n",
+ " 6 | \n",
+ " -365.837340 | \n",
+ " 0.000026 | \n",
+ "
\n",
+ " \n",
+ " | 6 | \n",
+ " 7 | \n",
+ " -365.829612 | \n",
+ " -0.000021 | \n",
+ "
\n",
+ " \n",
+ " | 7 | \n",
+ " 8 | \n",
+ " -365.833171 | \n",
+ " 0.000010 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# FeO 3 atom\n",
+ "feo_dir = str(examples.joinpath(\"FeO\"))\n",
+ "input_feo = deepcopy(base_input)\n",
+ "input_feo['input_path'] = feo_dir\n",
+ "\n",
+ "m3 = Manager(input_feo)\n",
+ "m3.run()\n",
+ "sns.relplot(data=m3.data, x='k', y='etot', kind='line', marker='o')\n",
+ "m3.data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " k | \n",
+ " etot | \n",
+ " relative_tol | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " 1 | \n",
+ " -36.394971 | \n",
+ " 1.000000 | \n",
+ "
\n",
+ " \n",
+ " | 1 | \n",
+ " 2 | \n",
+ " -36.741448 | \n",
+ " 0.009520 | \n",
+ "
\n",
+ " \n",
+ " | 2 | \n",
+ " 3 | \n",
+ " -36.855517 | \n",
+ " 0.003105 | \n",
+ "
\n",
+ " \n",
+ " | 3 | \n",
+ " 4 | \n",
+ " -36.898898 | \n",
+ " 0.001177 | \n",
+ "
\n",
+ " \n",
+ " | 4 | \n",
+ " 5 | \n",
+ " -36.894758 | \n",
+ " -0.000112 | \n",
+ "
\n",
+ " \n",
+ " | 5 | \n",
+ " 6 | \n",
+ " -36.892590 | \n",
+ " -0.000059 | \n",
+ "
\n",
+ " \n",
+ " | 6 | \n",
+ " 7 | \n",
+ " -36.897511 | \n",
+ " 0.000133 | \n",
+ "
\n",
+ " \n",
+ " | 7 | \n",
+ " 8 | \n",
+ " -36.896535 | \n",
+ " -0.000026 | \n",
+ "
\n",
+ " \n",
+ " | 8 | \n",
+ " 9 | \n",
+ " -36.895421 | \n",
+ " -0.000030 | \n",
+ "
\n",
+ " \n",
+ " | 9 | \n",
+ " 10 | \n",
+ " -36.896899 | \n",
+ " 0.000040 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# C4 4 atom\n",
+ "c4_dir = str(examples.joinpath(\"C4\"))\n",
+ "input_c4 = deepcopy(base_input)\n",
+ "input_c4['input_path'] = c4_dir\n",
+ "\n",
+ "m4 = Manager(input_c4)\n",
+ "m4.run()\n",
+ "sns.relplot(data=m4.data, x='k', y='etot', kind='line', marker='o')\n",
+ "m4.data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " k | \n",
+ " etot | \n",
+ " relative_tol | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " 2 | \n",
+ " -166.826682 | \n",
+ " 1.000000 | \n",
+ "
\n",
+ " \n",
+ " | 1 | \n",
+ " 3 | \n",
+ " -166.856894 | \n",
+ " 0.000181 | \n",
+ "
\n",
+ " \n",
+ " | 2 | \n",
+ " 4 | \n",
+ " -166.859332 | \n",
+ " 0.000015 | \n",
+ "
\n",
+ " \n",
+ " | 3 | \n",
+ " 5 | \n",
+ " -166.860100 | \n",
+ " 0.000005 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# PbTiO3 5 atom\n",
+ "pbtio3_dir = str(examples.joinpath(\"PbTiO3\"))\n",
+ "input_pbtio3 = deepcopy(base_input)\n",
+ "input_pbtio3['input_path'] = pbtio3_dir\n",
+ "input_pbtio3['parameter_space'][0]['start'] = 2 # increase initial k value \n",
+ "\n",
+ "m5 = Manager(input_pbtio3)\n",
+ "m5.run()\n",
+ "sns.relplot(data=m5.data, x='k', y='etot', kind='line', marker='o')\n",
+ "m5.data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " k | \n",
+ " etot | \n",
+ " relative_tol | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " 1 | \n",
+ " -16.172553 | \n",
+ " 1.000000 | \n",
+ "
\n",
+ " \n",
+ " | 1 | \n",
+ " 2 | \n",
+ " -16.172529 | \n",
+ " -0.000001 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# NH4+ 5 atom\n",
+ "nh4_dir = str(examples.joinpath(\"NH4\"))\n",
+ "input_nh4 = deepcopy(base_input)\n",
+ "input_nh4['input_path'] = nh4_dir\n",
+ "\n",
+ "m5_2 = Manager(input_nh4)\n",
+ "m5_2.run()\n",
+ "sns.relplot(data=m5_2.data, x='k', y='etot', kind='line', marker='o')\n",
+ "m5_2.data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " k | \n",
+ " etot | \n",
+ " relative_tol | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " 1 | \n",
+ " -157.709724 | \n",
+ " 1.000000 | \n",
+ "
\n",
+ " \n",
+ " | 1 | \n",
+ " 2 | \n",
+ " -158.383750 | \n",
+ " 0.004274 | \n",
+ "
\n",
+ " \n",
+ " | 2 | \n",
+ " 3 | \n",
+ " -158.393771 | \n",
+ " 0.000063 | \n",
+ "
\n",
+ " \n",
+ " | 3 | \n",
+ " 4 | \n",
+ " -158.392326 | \n",
+ " -0.000009 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# SrVO3 5 atom\n",
+ "srvo3_dir = str(examples.joinpath(\"SrVO3\"))\n",
+ "input_srvo3 = deepcopy(base_input)\n",
+ "input_srvo3['input_path'] = srvo3_dir\n",
+ "\n",
+ "m5_3 = Manager(input_srvo3)\n",
+ "m5_3.run()\n",
+ "sns.relplot(data=m5_3.data, x='k', y='etot', kind='line', marker='o')\n",
+ "m5_3.data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " k | \n",
+ " etot | \n",
+ " relative_tol | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " 1 | \n",
+ " -186.369894 | \n",
+ " 1.000000 | \n",
+ "
\n",
+ " \n",
+ " | 1 | \n",
+ " 2 | \n",
+ " -186.587601 | \n",
+ " 0.001168 | \n",
+ "
\n",
+ " \n",
+ " | 2 | \n",
+ " 3 | \n",
+ " -186.587018 | \n",
+ " -0.000003 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# LiCoO2 5 atom\n",
+ "licoo2_dir = str(examples.joinpath(\"LiCoO2\"))\n",
+ "input_licoo2 = deepcopy(base_input)\n",
+ "input_licoo2['input_path'] = licoo2_dir\n",
+ "input_licoo2['parameter_space'][0]['start'] = 1 # increase initial k value \n",
+ "\n",
+ "m5_3 = Manager(input_licoo2)\n",
+ "m5_3.run()\n",
+ "sns.relplot(data=m5_3.data, x='k', y='etot', kind='line', marker='o')\n",
+ "m5_3.data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " k | \n",
+ " etot | \n",
+ " relative_tol | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " 2 | \n",
+ " -25.937756 | \n",
+ " 1.000000 | \n",
+ "
\n",
+ " \n",
+ " | 1 | \n",
+ " 3 | \n",
+ " -25.942999 | \n",
+ " 0.000202 | \n",
+ "
\n",
+ " \n",
+ " | 2 | \n",
+ " 4 | \n",
+ " -25.942708 | \n",
+ " -0.000011 | \n",
+ "
\n",
+ " \n",
+ " | 3 | \n",
+ " 5 | \n",
+ " -25.941808 | \n",
+ " -0.000035 | \n",
+ "
\n",
+ " \n",
+ " | 4 | \n",
+ " 6 | \n",
+ " -25.942601 | \n",
+ " 0.000031 | \n",
+ "
\n",
+ " \n",
+ " | 5 | \n",
+ " 7 | \n",
+ " -25.941970 | \n",
+ " -0.000024 | \n",
+ "
\n",
+ " \n",
+ " | 6 | \n",
+ " 8 | \n",
+ " -25.941885 | \n",
+ " -0.000003 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "