From ee138dc23b9a17a5bcb63e38560d35dd3e8b6311 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Wed, 5 Jul 2023 10:49:26 +0000 Subject: [PATCH 01/56] Bump scipy from 1.10.1 to 1.11.1 Bumps [scipy](https://github.com/scipy/scipy) from 1.10.1 to 1.11.1. - [Release notes](https://github.com/scipy/scipy/releases) - [Commits](https://github.com/scipy/scipy/compare/v1.10.1...v1.11.1) --- updated-dependencies: - dependency-name: scipy dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index e25ae7cf..a470ab69 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,5 @@ numpy == 1.24.3 -scipy ==1.10.1 +scipy ==1.11.1 spglib ==2.0.2 future ==0.18.3 ase ==3.22.1 From 2bdeac683e2bb2e7ec8b118165dbd7d088a81055 Mon Sep 17 00:00:00 2001 From: Anthony Onwuli Date: Thu, 10 Aug 2023 14:52:49 +0100 Subject: [PATCH 02/56] Remove cell --- examples/Dopant_Prediction/doper_example.ipynb | 13 +------------ 1 file changed, 1 insertion(+), 12 deletions(-) diff --git a/examples/Dopant_Prediction/doper_example.ipynb b/examples/Dopant_Prediction/doper_example.ipynb index aa269ca6..dde348c8 100644 --- a/examples/Dopant_Prediction/doper_example.ipynb +++ b/examples/Dopant_Prediction/doper_example.ipynb @@ -18,17 +18,6 @@ "## Application to titanium dioxide" ] }, - { - "cell_type": "code", - "execution_count": 16, - "id": "eb3f1399", - "metadata": {}, - "outputs": [], - "source": [ - "import sys\n", - "sys.path.append(\"/Users/jiwoolee/Documents/smactClone/SMACT\")" - ] - }, { "cell_type": "code", "execution_count": 18, @@ -138,7 +127,7 @@ "material = Doper((\"Ti4+\", \"O2-\"))\n", "material.get_dopants()\n", "\n", - "#15 possible dopants\n", + "# 15 possible dopants\n", "material.get_dopants(15)" ] }, From 949c83bcc0e1f5dd0e7702df950a75b82ba9c2e2 Mon Sep 17 00:00:00 2001 From: Anthony Onwuli Date: Wed, 23 Aug 2023 17:36:43 +0100 Subject: [PATCH 03/56] Update version number --- setup.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/setup.py b/setup.py index 4404200e..6f33bcc9 100644 --- a/setup.py +++ b/setup.py @@ -5,10 +5,10 @@ __copyright__ = ( "Copyright Daniel W. Davies, Adam J. Jackson, Keith T. Butler (2019)" ) -__version__ = "2.5.2" +__version__ = "2.5.3" __maintainer__ = "Anthony O. Onwuli" __maintaier_email__ = "anthony.onwuli16@imperial.ac.uk" -__date__ = "July 13 2023" +__date__ = "August 23 2023" import os import unittest From c68cb0dc0c6b411c34df6faca3830abadbe39bb5 Mon Sep 17 00:00:00 2001 From: Anthony Onwuli Date: Wed, 23 Aug 2023 17:37:09 +0100 Subject: [PATCH 04/56] Enable predecorated structures for SmactStructures --- smact/structure_prediction/structure.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/smact/structure_prediction/structure.py b/smact/structure_prediction/structure.py index 1cf5a56c..e9993774 100644 --- a/smact/structure_prediction/structure.py +++ b/smact/structure_prediction/structure.py @@ -274,9 +274,12 @@ def from_py_struct( ) struct = oxi_transform.apply_transformation(structure) print("Oxidation states assigned based on ICSD statistics") + elif determine_oxi == "predecorated": + struct = structure + else: raise ValueError( - f"Argument for 'determine_oxi', <{determine_oxi}> is not valid. Choose either 'BV','comp_ICSD' or 'both'." + f"Argument for 'determine_oxi', <{determine_oxi}> is not valid. Choose either 'BV','comp_ICSD','both' or 'predecorated'." ) sites, species = SmactStructure.__parse_py_sites(struct) From de9659edbd0f043c0948c7dbe04d73fdba8e4ff2 Mon Sep 17 00:00:00 2001 From: Anthony Onwuli Date: Thu, 24 Aug 2023 14:27:18 +0100 Subject: [PATCH 05/56] Update requirements.txt using pip-compile --- requirements.txt | 166 +++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 155 insertions(+), 11 deletions(-) diff --git a/requirements.txt b/requirements.txt index 41c9be93..875f84ec 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,11 +1,155 @@ -numpy == 1.24.3 -scipy ==1.10.1 -spglib ==2.0.2 -future ==0.18.3 -ase ==3.22.1 -pymatgen ==2023.7.20 -pandas == 2.0.3 -pathos ==0.3.0 -pytest ==7.4.0 -pytest-subtests ==0.11.0 -pydantic ==1.* \ No newline at end of file +# +# This file is autogenerated by pip-compile with Python 3.9 +# by the following command: +# +# pip-compile +# +ase==3.22.1 + # via SMACT (setup.py) +certifi==2023.7.22 + # via requests +charset-normalizer==3.2.0 + # via requests +contourpy==1.1.0 + # via matplotlib +cycler==0.11.0 + # via matplotlib +dill==0.3.7 + # via + # multiprocess + # pathos +emmet-core==0.66.0 + # via mp-api +fonttools==4.42.1 + # via matplotlib +future==0.18.3 + # via uncertainties +idna==3.4 + # via requests +importlib-resources==6.0.1 + # via matplotlib +joblib==1.3.2 + # via pymatgen +kiwisolver==1.4.5 + # via matplotlib +latexcodec==2.0.1 + # via pybtex +matplotlib==3.7.2 + # via + # ase + # pymatgen +monty==2023.8.8 + # via + # emmet-core + # mp-api + # pymatgen +mp-api==0.34.3 + # via pymatgen +mpmath==1.3.0 + # via sympy +msgpack==1.0.5 + # via mp-api +multiprocess==0.70.15 + # via pathos +networkx==3.1 + # via pymatgen +numpy==1.24.3 + # via + # SMACT (setup.py) + # ase + # contourpy + # matplotlib + # pandas + # pymatgen + # scipy + # spglib +packaging==23.1 + # via + # matplotlib + # plotly +palettable==3.3.3 + # via pymatgen +pandas==2.0.3 + # via + # SMACT (setup.py) + # pymatgen +pathos==0.3.0 + # via SMACT (setup.py) +pillow==10.0.0 + # via matplotlib +plotly==5.16.1 + # via pymatgen +pox==0.3.3 + # via pathos +ppft==1.7.6.7 + # via pathos +pybtex==0.24.0 + # via + # emmet-core + # pymatgen +pydantic==1.10.12 + # via + # emmet-core + # pymatgen +pymatgen==2023.7.20 + # via + # SMACT (setup.py) + # emmet-core + # mp-api +pyparsing==3.0.9 + # via matplotlib +python-dateutil==2.8.2 + # via + # matplotlib + # pandas +pytz==2023.3 + # via pandas +pyyaml==6.0.1 + # via pybtex +requests==2.31.0 + # via + # mp-api + # pymatgen +ruamel-yaml==0.17.32 + # via pymatgen +ruamel-yaml-clib==0.2.7 + # via ruamel-yaml +scipy==1.10.1 + # via + # SMACT (setup.py) + # ase + # pymatgen +six==1.16.0 + # via + # latexcodec + # pybtex + # python-dateutil +spglib==2.0.2 + # via + # SMACT (setup.py) + # emmet-core + # pymatgen +sympy==1.12 + # via pymatgen +tabulate==0.9.0 + # via pymatgen +tenacity==8.2.3 + # via plotly +tqdm==4.66.1 + # via pymatgen +typing-extensions==4.7.1 + # via + # emmet-core + # mp-api + # pydantic +tzdata==2023.3 + # via pandas +uncertainties==3.1.7 + # via pymatgen +urllib3==2.0.4 + # via requests +zipp==3.16.2 + # via importlib-resources + +# The following packages are considered to be unsafe in a requirements file: +# setuptools From 7fe8d3c4eb24ee8786093ed7603dd017bd7fcce3 Mon Sep 17 00:00:00 2001 From: Anthony Onwuli Date: Thu, 24 Aug 2023 15:25:57 +0100 Subject: [PATCH 06/56] Add requirements files for docs --- docs/requirements.in | 4 +++ docs/requirements.txt | 65 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 69 insertions(+) create mode 100644 docs/requirements.in create mode 100644 docs/requirements.txt diff --git a/docs/requirements.in b/docs/requirements.in new file mode 100644 index 00000000..1ee13a2b --- /dev/null +++ b/docs/requirements.in @@ -0,0 +1,4 @@ +# Defining the exact version will make sure things don't break +sphinx==5.3.0 +sphinx_rtd_theme==1.1.1 +readthedocs-sphinx-search==0.1.1 \ No newline at end of file diff --git a/docs/requirements.txt b/docs/requirements.txt new file mode 100644 index 00000000..122723af --- /dev/null +++ b/docs/requirements.txt @@ -0,0 +1,65 @@ +# +# This file is autogenerated by pip-compile with Python 3.9 +# by the following command: +# +# pip-compile +# +alabaster==0.7.13 + # via sphinx +babel==2.12.1 + # via sphinx +certifi==2023.7.22 + # via requests +charset-normalizer==3.2.0 + # via requests +docutils==0.17.1 + # via + # sphinx + # sphinx-rtd-theme +idna==3.4 + # via requests +imagesize==1.4.1 + # via sphinx +importlib-metadata==6.8.0 + # via sphinx +jinja2==3.1.2 + # via sphinx +markupsafe==2.1.3 + # via jinja2 +packaging==23.1 + # via sphinx +pygments==2.16.1 + # via sphinx +readthedocs-sphinx-search==0.1.1 + # via -r requirements.in +requests==2.31.0 + # via sphinx +snowballstemmer==2.2.0 + # via sphinx +sphinx==5.3.0 + # via + # -r requirements.in + # sphinx-rtd-theme + # sphinxcontrib-applehelp + # sphinxcontrib-devhelp + # sphinxcontrib-htmlhelp + # sphinxcontrib-qthelp + # sphinxcontrib-serializinghtml +sphinx-rtd-theme==1.1.1 + # via -r requirements.in +sphinxcontrib-applehelp==1.0.7 + # via sphinx +sphinxcontrib-devhelp==1.0.5 + # via sphinx +sphinxcontrib-htmlhelp==2.0.4 + # via sphinx +sphinxcontrib-jsmath==1.0.1 + # via sphinx +sphinxcontrib-qthelp==1.0.6 + # via sphinx +sphinxcontrib-serializinghtml==1.1.9 + # via sphinx +urllib3==2.0.4 + # via requests +zipp==3.16.2 + # via importlib-metadata From f534eea72834158ac457b9bf1b745b836492bf43 Mon Sep 17 00:00:00 2001 From: Anthony Onwuli Date: Thu, 24 Aug 2023 15:26:21 +0100 Subject: [PATCH 07/56] Update .readthedocs.yaml --- .readthedocs.yaml | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/.readthedocs.yaml b/.readthedocs.yaml index 5c2617ef..723ca6ca 100644 --- a/.readthedocs.yaml +++ b/.readthedocs.yaml @@ -7,4 +7,9 @@ build: # Build documentation in the docs/ directory with Sphinx sphinx: - configuration: docs/conf.py \ No newline at end of file + configuration: docs/conf.py + +# Explicitly set the version of Python and its requirements +python: + install: + - requirements: docs/requirements.txt \ No newline at end of file From 6eccdf2f0a9fbd87b376439d7d12eda7a1aefde9 Mon Sep 17 00:00:00 2001 From: Anthony Onwuli Date: Thu, 24 Aug 2023 15:37:44 +0100 Subject: [PATCH 08/56] Fix requirements for python3.8 compatibility --- docs/requirements.txt | 19 ++++++++----------- 1 file changed, 8 insertions(+), 11 deletions(-) diff --git a/docs/requirements.txt b/docs/requirements.txt index 122723af..549fb24c 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -1,5 +1,5 @@ # -# This file is autogenerated by pip-compile with Python 3.9 +# This file is autogenerated by pip-compile with Python 3.8 # by the following command: # # pip-compile @@ -30,6 +30,8 @@ packaging==23.1 # via sphinx pygments==2.16.1 # via sphinx +pytz==2023.3 + # via babel readthedocs-sphinx-search==0.1.1 # via -r requirements.in requests==2.31.0 @@ -40,24 +42,19 @@ sphinx==5.3.0 # via # -r requirements.in # sphinx-rtd-theme - # sphinxcontrib-applehelp - # sphinxcontrib-devhelp - # sphinxcontrib-htmlhelp - # sphinxcontrib-qthelp - # sphinxcontrib-serializinghtml sphinx-rtd-theme==1.1.1 # via -r requirements.in -sphinxcontrib-applehelp==1.0.7 +sphinxcontrib-applehelp==1.0.4 # via sphinx -sphinxcontrib-devhelp==1.0.5 +sphinxcontrib-devhelp==1.0.2 # via sphinx -sphinxcontrib-htmlhelp==2.0.4 +sphinxcontrib-htmlhelp==2.0.1 # via sphinx sphinxcontrib-jsmath==1.0.1 # via sphinx -sphinxcontrib-qthelp==1.0.6 +sphinxcontrib-qthelp==1.0.3 # via sphinx -sphinxcontrib-serializinghtml==1.1.9 +sphinxcontrib-serializinghtml==1.1.5 # via sphinx urllib3==2.0.4 # via requests From ab052a35f53357791423442420e691ee3c1c9153 Mon Sep 17 00:00:00 2001 From: Anthony Onwuli Date: Thu, 24 Aug 2023 15:53:06 +0100 Subject: [PATCH 09/56] python3.11 compatibility --- .github/workflows/ci.yml | 2 +- setup.py | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 009f7f65..315d101c 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -15,7 +15,7 @@ jobs: strategy: fail-fast: false matrix: - python-version: ["3.8","3.9","3.10"] + python-version: ["3.8","3.9","3.10","3.11"] os: [ubuntu-latest,macos-latest,windows-latest] runs-on: ${{matrix.os}} diff --git a/setup.py b/setup.py index 6f33bcc9..2cc88833 100644 --- a/setup.py +++ b/setup.py @@ -61,6 +61,7 @@ "Programming Language :: Python :: 3.8", "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", "Development Status :: 5 - Production/Stable", "Intended Audience :: Science/Research", "Operating System :: OS Independent", From 56a04c5db939b1bbe9e17567cc238d06016e639d Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Fri, 1 Sep 2023 17:01:48 +0000 Subject: [PATCH 10/56] Bump pathos from 0.3.0 to 0.3.1 Bumps [pathos](https://github.com/uqfoundation/pathos) from 0.3.0 to 0.3.1. - [Release notes](https://github.com/uqfoundation/pathos/releases) - [Commits](https://github.com/uqfoundation/pathos/compare/pathos-0.3.0...pathos-0.3.1) --- updated-dependencies: - dependency-name: pathos dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index a810b3ed..42c7bfa5 100644 --- a/requirements.txt +++ b/requirements.txt @@ -72,7 +72,7 @@ pandas==2.0.3 # via # SMACT (setup.py) # pymatgen -pathos==0.3.0 +pathos==0.3.1 # via SMACT (setup.py) pillow==10.0.0 # via matplotlib From 9f04616756bb20333cf1c356493da3b29b976029 Mon Sep 17 00:00:00 2001 From: Anthony Onwuli Date: Tue, 5 Sep 2023 14:42:08 +0100 Subject: [PATCH 11/56] Add data_loader function to call custom ox states --- smact/data_loader.py | 53 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 53 insertions(+) diff --git a/smact/data_loader.py b/smact/data_loader.py index 79631a8e..52c238d8 100644 --- a/smact/data_loader.py +++ b/smact/data_loader.py @@ -269,6 +269,59 @@ def lookup_element_oxidation_states_wiki(symbol, copy=True): return None +_el_ox_states_custom = None + + +def lookup_element_oxidation_states_custom(symbol, filepath, copy=True): + """ + Retrieve a list of known oxidation states for an element. + The oxidation states list is specified by the user in a text file. + + Args: + symbol (str) : the atomic symbol of the element to look up. + copy (Optional(bool)): if True (default), return a copy of the + oxidation-state list, rather than a reference to the cached + data -- only use copy=False in performance-sensitive code + and where the list will not be modified! + + Returns: + list: List of known oxidation states for the element. + + Return None if oxidation states for the Element were not + found in the external data. + """ + + global _el_ox_states_custom + + if _el_ox_states_custom is None: + _el_ox_states_custom = {} + + for items in _get_data_rows(filepath): + _el_ox_states_custom[items[0]] = [ + int(oxidationState) for oxidationState in items[1:] + ] + + if symbol in _el_ox_states_custom: + if copy: + # _el_ox_states_custom stores lists -> if copy is set, make an implicit + # deep copy. The elements of the lists are integers, which are + # "value types" in Python. + + return [ + oxidationState + for oxidationState in _el_ox_states_custom[symbol] + ] + else: + return _el_ox_states_custom[symbol] + else: + if _print_warnings: + print( + "WARNING: Oxidation states for element {} " + "not found.".format(symbol) + ) + return None + + # Loader and cache for the element HHI scores. _element_hhis = None From e2c8056658c1c9d261acdace3b746ad8c736f8ca Mon Sep 17 00:00:00 2001 From: Anthony Onwuli Date: Tue, 5 Sep 2023 15:00:08 +0100 Subject: [PATCH 12/56] Add line-length arg to pre-commit config --- .pre-commit-config.yaml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 9afc9ae2..3ff89c33 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -4,11 +4,12 @@ repos: hooks: - id: isort additional_dependencies: [toml] - args: ["--profile", "black", "--filter-files"] + args: ["--profile", "black", "--filter-files","--line-length=80"] - repo: https://github.com/psf/black rev: "23.1.0" hooks: - id: black-jupyter + args: [--line-length=80] - repo: https://github.com/asottile/pyupgrade rev: v3.3.1 hooks: From defdd7167209023522d3c5073551d0510dda7efd Mon Sep 17 00:00:00 2001 From: Anthony Onwuli Date: Tue, 5 Sep 2023 15:00:14 +0100 Subject: [PATCH 13/56] Add custom oxi states call to smact_filter --- smact/screening.py | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/smact/screening.py b/smact/screening.py index 13db4930..591c1284 100644 --- a/smact/screening.py +++ b/smact/screening.py @@ -1,10 +1,14 @@ import itertools +import os import warnings from collections import namedtuple from itertools import combinations from typing import Iterable, List, Optional, Tuple, Union from smact import Element, neutral_ratios +from smact.data_loader import ( + lookup_element_oxidation_states_custom as oxi_custom, +) # Use named tuple to improve readability of smact_filter outputs _allowed_compositions = namedtuple( @@ -371,10 +375,12 @@ def smact_filter( } if oxidation_states_set in oxi_set: ox_combos = oxi_set[oxidation_states_set] + elif os.path.exists(oxidation_states_set): + ox_combos = [oxi_custom(e.symbol, oxidation_states_set) for e in els] else: raise ( Exception( - f'{oxidation_states_set} is not valid. Enter either "default", "icsd", "pymatgen" or "wiki" for oxidation_states_set.' + f'{oxidation_states_set} is not valid. Enter either "default", "icsd", "pymatgen","wiki" or a filepath to a textfile of oxidation states.' ) ) if oxidation_states_set == "wiki": From e9aab000f7c067013b1972652b469c1351bf2a8a Mon Sep 17 00:00:00 2001 From: Anthony Onwuli Date: Tue, 5 Sep 2023 15:00:53 +0100 Subject: [PATCH 14/56] Ran pre-commit --- examples/Counting/ElementCombinationsParallel.py | 6 ++---- examples/Oxidation_states/oxidation_states.ipynb | 6 ++---- .../Structure_Prediction/Li-Garnet_Generator.ipynb | 3 +-- smact/data_loader.py | 12 +++--------- smact/dopant_prediction/doper.py | 4 +--- smact/structure_prediction/database.py | 4 +--- smact/structure_prediction/mutation.py | 3 +-- smact/structure_prediction/prediction.py | 3 +-- smact/structure_prediction/structure.py | 5 +---- smact/tests/test_core.py | 4 +--- smact/tests/test_structure.py | 4 +--- 11 files changed, 15 insertions(+), 39 deletions(-) diff --git a/examples/Counting/ElementCombinationsParallel.py b/examples/Counting/ElementCombinationsParallel.py index 57856c95..d19dede1 100644 --- a/examples/Counting/ElementCombinationsParallel.py +++ b/examples/Counting/ElementCombinationsParallel.py @@ -165,8 +165,7 @@ def n_neutral_ratios(oxidation_states, threshold=8): ) print( - "Counting ({} element combinations)" - "...".format(combination_count) + "Counting ({} element combinations)" "...".format(combination_count) ) # Combinations are counted in chunks set by count_progress_interval. @@ -237,8 +236,7 @@ def n_neutral_ratios(oxidation_states, threshold=8): time_elapsed = time.time() - start_time time_remaining = ( - combination_count * (time_elapsed / data_pointer) - - time_elapsed + combination_count * (time_elapsed / data_pointer) - time_elapsed ) print_status( diff --git a/examples/Oxidation_states/oxidation_states.ipynb b/examples/Oxidation_states/oxidation_states.ipynb index ca2bfdf6..588d1fdf 100644 --- a/examples/Oxidation_states/oxidation_states.ipynb +++ b/examples/Oxidation_states/oxidation_states.ipynb @@ -282,12 +282,10 @@ "# Here we grab the species string for each composition generated by smact\n", "list_of_species = [species[3] for species in flat_list]\n", "A_species = [\n", - " f\"{species[0].symbol}{species[0].oxidation}+\"\n", - " for species in list_of_species\n", + " f\"{species[0].symbol}{species[0].oxidation}+\" for species in list_of_species\n", "]\n", "B_species = [\n", - " f\"{species[1].symbol}{species[1].oxidation}+\"\n", - " for species in list_of_species\n", + " f\"{species[1].symbol}{species[1].oxidation}+\" for species in list_of_species\n", "]\n", "X_species = [f\"{species[2].symbol}1-\" for species in list_of_species]\n", "\n", diff --git a/examples/Structure_Prediction/Li-Garnet_Generator.ipynb b/examples/Structure_Prediction/Li-Garnet_Generator.ipynb index 0b64e0a2..36ad2cf5 100644 --- a/examples/Structure_Prediction/Li-Garnet_Generator.ipynb +++ b/examples/Structure_Prediction/Li-Garnet_Generator.ipynb @@ -285,8 +285,7 @@ " sus_factor = 0\n", " for i in Composition(comp).elements:\n", " sus_factor += (\n", - " Composition(comp).get_wt_fraction(i)\n", - " * smact.Element(i.symbol).HHI_r\n", + " Composition(comp).get_wt_fraction(i) * smact.Element(i.symbol).HHI_r\n", " )\n", " return sus_factor\n", "\n", diff --git a/smact/data_loader.py b/smact/data_loader.py index 52c238d8..79e0dd8a 100644 --- a/smact/data_loader.py +++ b/smact/data_loader.py @@ -420,9 +420,7 @@ def lookup_element_data(symbol, copy=True): # or, if not clearly a number, to None clean_items = items[0:2] + list(map(float_or_None, items[2:])) - _element_data.update( - {items[0]: dict(list(zip(keys, clean_items)))} - ) + _element_data.update({items[0]: dict(list(zip(keys, clean_items)))}) if symbol in _element_data: if copy: @@ -437,9 +435,7 @@ def lookup_element_data(symbol, copy=True): return _element_data[symbol] else: if _print_warnings: - print( - "WARNING: Elemental data for {}" " not found.".format(symbol) - ) + print("WARNING: Elemental data for {}" " not found.".format(symbol)) print(_element_data) return None @@ -524,9 +520,7 @@ def lookup_element_shannon_radius_data(symbol, copy=True): # function on each element. # The dictionary values are all Python "value types", so # nothing further is required to make a deep copy. - return [ - item.copy() for item in _element_shannon_radii_data[symbol] - ] + return [item.copy() for item in _element_shannon_radii_data[symbol]] else: return _element_shannon_radii_data[symbol] else: diff --git a/smact/dopant_prediction/doper.py b/smact/dopant_prediction/doper.py index f3dba6ff..53b4b6b4 100644 --- a/smact/dopant_prediction/doper.py +++ b/smact/dopant_prediction/doper.py @@ -20,9 +20,7 @@ class Doper: """ - def __init__( - self, original_species: Tuple[str, ...], filepath: str = None - ): + def __init__(self, original_species: Tuple[str, ...], filepath: str = None): """ Intialise the `Doper` class with a tuple of species diff --git a/smact/structure_prediction/database.py b/smact/structure_prediction/database.py index 72001c03..42f0d764 100644 --- a/smact/structure_prediction/database.py +++ b/smact/structure_prediction/database.py @@ -202,9 +202,7 @@ def add_structs( return num - def get_structs( - self, composition: str, table: str - ) -> List[SmactStructure]: + def get_structs(self, composition: str, table: str) -> List[SmactStructure]: """Get SmactStructures for a given composition. Args: diff --git a/smact/structure_prediction/mutation.py b/smact/structure_prediction/mutation.py index 9ca2e055..41667506 100644 --- a/smact/structure_prediction/mutation.py +++ b/smact/structure_prediction/mutation.py @@ -373,8 +373,7 @@ def pair_corr(self, s1: str, s2: str) -> float: def cond_sub_prob(self, s1: str, s2: str) -> float: """Calculate the probability of substitution of one species with another.""" return ( - np.exp(self.get_lambda(s1, s2)) - / np.exp(self.get_lambdas(s2)).sum() + np.exp(self.get_lambda(s1, s2)) / np.exp(self.get_lambdas(s2)).sum() ) def cond_sub_probs(self, s1: str) -> pd.Series: diff --git a/smact/structure_prediction/prediction.py b/smact/structure_prediction/prediction.py index 85741ef5..5fedfd28 100644 --- a/smact/structure_prediction/prediction.py +++ b/smact/structure_prediction/prediction.py @@ -183,8 +183,7 @@ def nary_predict_structs( sub_species = list(map(list, sub_species)) potential_nary_parents: List[List[SmactStructure]] = list( - self.db.get_with_species(specs, self.table) - for specs in sub_species + self.db.get_with_species(specs, self.table) for specs in sub_species ) for spec_idx, parents in enumerate(potential_nary_parents): diff --git a/smact/structure_prediction/structure.py b/smact/structure_prediction/structure.py index e9993774..0f072b35 100644 --- a/smact/structure_prediction/structure.py +++ b/smact/structure_prediction/structure.py @@ -436,10 +436,7 @@ def from_poscar(poscar: str): lattice_param = float(lines[1]) lattice = np.array( - [ - [float(point) for point in line.split(" ")] - for line in lines[2:5] - ] + [[float(point) for point in line.split(" ")] for line in lines[2:5]] ) sites = defaultdict(list) diff --git a/smact/tests/test_core.py b/smact/tests/test_core.py index ccfb2768..6ddb5fd6 100755 --- a/smact/tests/test_core.py +++ b/smact/tests/test_core.py @@ -46,9 +46,7 @@ def test_are_eq(self): [1.00, 2.00, 3.00], [1.001, 1.999, 3.00], tolerance=1e-2 ) ) - self.assertFalse( - smact.are_eq([1.00, 2.00, 3.00], [1.001, 1.999, 3.00]) - ) + self.assertFalse(smact.are_eq([1.00, 2.00, 3.00], [1.001, 1.999, 3.00])) def test_gcd_recursive(self): self.assertEqual(smact._gcd_recursive(4, 12, 10, 32), 2) diff --git a/smact/tests/test_structure.py b/smact/tests/test_structure.py index 8ebc32dc..d92253bc 100644 --- a/smact/tests/test_structure.py +++ b/smact/tests/test_structure.py @@ -363,9 +363,7 @@ def setUpClass(cls): """Set up the test initial structure and mutator.""" cls.test_struct = SmactStructure.from_file(TEST_POSCAR) - cls.test_mutator = CationMutator.from_json( - lambda_json=TEST_LAMBDA_JSON - ) + cls.test_mutator = CationMutator.from_json(lambda_json=TEST_LAMBDA_JSON) cls.test_pymatgen_mutator = CationMutator.from_json( lambda_json=None, alpha=lambda x, y: -5 ) From 16873e60b6750ea2c61fce8d31766ad91209f113 Mon Sep 17 00:00:00 2001 From: Anthony Onwuli Date: Tue, 5 Sep 2023 15:19:31 +0100 Subject: [PATCH 15/56] Add test for custom ox state calls in smact_filter --- smact/tests/files/test_oxidation_states.txt | 108 ++++++++++++++++++++ smact/tests/test_core.py | 9 ++ 2 files changed, 117 insertions(+) create mode 100644 smact/tests/files/test_oxidation_states.txt diff --git a/smact/tests/files/test_oxidation_states.txt b/smact/tests/files/test_oxidation_states.txt new file mode 100644 index 00000000..122f9ee0 --- /dev/null +++ b/smact/tests/files/test_oxidation_states.txt @@ -0,0 +1,108 @@ +H -1 +1 +He +Li +1 +Be +1 +2 +B +1 +2 +3 +C -4 -3 -2 -1 +1 +2 +3 +4 +N -3 -2 -1 +1 +2 +3 +4 +5 +O -2 -1 +1 +2 +F -1 +Ne +Na -1 +1 +Mg +1 +2 +Al +1 +2 +3 +Si -4 -3 -2 -1 +1 +2 +3 +4 +P -3 -2 -1 +1 +2 +3 +4 +5 +S -2 -1 +1 +2 +3 +4 +5 +6 +Cl -1 +1 +2 +3 +4 +5 +6 +7 +Ar +K -1 +1 +Ca +1 +2 +Sc +1 +2 +3 +Ti -1 +1 +2 +3 +4 +V -1 +1 +2 +3 +4 +5 +Cr -2 -1 +1 +2 +3 +4 +5 +6 +Mn -3 -2 -1 +1 +2 +3 +4 +5 +6 +7 +Fe -2 -1 +1 +2 +3 +4 +5 +6 +Co -1 +1 +2 +3 +4 +5 +Ni -1 +1 +2 +3 +4 +Cu +1 +2 +3 +4 +Zn +1 +2 +Ga +1 +2 +3 +Ge -4 -3 -2 -1 +1 +2 +3 +4 +As -3 +1 +2 +3 +5 +Se -2 +1 +2 +4 +6 +Br -1 +1 +2 +3 +4 +5 +7 +Kr +2 +Rb -1 +1 +Sr +1 +2 +Y +1 +2 +3 +Zr +1 +2 +3 +4 +Nb -1 +1 +2 +3 +4 +5 +Mo -2 -1 +1 +2 +3 +4 +5 +6 +Tc -3 -1 +1 +2 +3 +4 +5 +6 +7 +Ru -2 +1 +2 +3 +4 +5 +6 +7 +8 +Rh -1 +1 +2 +3 +4 +5 +6 +Pd +1 +2 +4 +6 +Ag +1 +2 +3 +4 +Cd +1 +2 +In +1 +2 +3 +Sn -4 +2 +4 +Sb -3 +3 +5 +Te -2 +2 +4 +5 +6 +I -1 +1 +3 +4 +5 +7 +Xe +1 +2 +4 +6 +8 +Cs -1 +1 +Ba +2 +La +2 +3 +Ce +2 +3 +4 +Pr +2 +3 +4 +Nd +2 +3 +4 +Pm +2 +3 +Sm +2 +3 +Eu +2 +3 +Gd +1 +2 +3 +Tb +1 +2 +3 +4 +Dy +2 +3 +4 +Ho +2 +3 +Er +2 +3 +Tm +2 +3 +Yb +2 +3 +Lu +3 +Hf +2 +3 +4 +Ta -1 +2 +3 +4 +5 +W -2 -1 +1 +2 +3 +4 +5 +6 +Re -3 -1 +1 +2 +3 +4 +5 +6 +7 +Os -2 -1 +1 +2 +3 +4 +5 +6 +7 +8 +Ir -3 -1 +1 +2 +3 +4 +5 +6 +7 +8 +Pt -2 -1 +1 +2 +3 +4 +5 +6 +Au -1 +1 +2 +3 +5 +Hg +1 +2 +4 +Tl -1 +1 +3 +Pb -4 +2 +4 +Bi -3 +1 +3 +5 +7 +Po -2 +2 +4 +5 +6 +At -1 +1 +3 +5 +7 +Rn +2 +6 +Fr +1 +Ra +2 +Ac +2 +3 +Th +2 +3 +4 +Pa +2 +3 +4 +5 +U +2 +3 +4 +5 +6 +Np +3 +4 +5 +6 +7 +Pu +2 +3 +4 +5 +6 +7 +8 +Am +2 +3 +4 +5 +6 +7 +Cm +2 +3 +4 +6 +8 +Bk +2 +3 +4 +Cf +2 +3 +4 +Es +2 +3 +4 +Fm +2 +3 +Md +2 +3 +No +2 +3 +Lr +3 +Rf +4 +Db +5 +Sg +6 +Bh +7 +Hs +8 diff --git a/smact/tests/test_core.py b/smact/tests/test_core.py index 6ddb5fd6..045d8488 100755 --- a/smact/tests/test_core.py +++ b/smact/tests/test_core.py @@ -15,6 +15,9 @@ from smact.builder import wurtzite from smact.properties import band_gap_Harrison, compound_electroneg +files_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), "files") +TEST_OX_STATES = os.path.join(files_dir, "test_oxidation_states.txt") + class TestSequenceFunctions(unittest.TestCase): # ---------------- TOP-LEVEL ---------------- @@ -344,6 +347,12 @@ def test_smact_filter(self): (("Na", "Fe", "Cl"), (1, 1, -1), (1, 1, 2)), ], ) + self.assertEqual( + result, + smact.screening.smact_filter( + [Na, Fe, Cl], threshold=2, oxidation_states_set=TEST_OX_STATES + ), + ) result_comp_tuple = smact.screening.smact_filter( [Na, Fe, Cl], threshold=2, comp_tuple=True ) From 88ab9c3631c47b6792f9e48701acaa799a94f442 Mon Sep 17 00:00:00 2001 From: Anthony Onwuli <30937913+AntObi@users.noreply.github.com> Date: Sat, 9 Sep 2023 14:02:08 +0100 Subject: [PATCH 16/56] Update README.md --- README.md | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/README.md b/README.md index 0c88af41..ee23ebf1 100644 --- a/README.md +++ b/README.md @@ -5,6 +5,7 @@ ![python version](https://img.shields.io/pypi/pyversions/smact) [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black) [![PyPi](https://img.shields.io/pypi/v/smact)](https://pypi.org/project/SMACT/) +[![Conda](https://anaconda.org/conda-forge/smact/badges/version.svg)](https://anaconda.org/conda-forge/smact) [![GitHub issues](https://img.shields.io/github/issues-raw/WMD-Group/SMACT)](https://github.com/WMD-group/SMACT/issues) ![dependencies](https://img.shields.io/librariesio/release/pypi/smact) [![CI Status](https://github.com/WMD-group/SMACT/actions/workflows/ci.yml/badge.svg)](https://github.com/WMD-group/SMACT/actions/workflows/ci.yml) @@ -91,6 +92,12 @@ The latest stable release of SMACT can be installed via pip which will automatic pip install smact +SMACT is also available via conda through the conda-forge channel on Anaconda Cloud: + +``` +conda install -c conda-forge smact +``` + Alternatively, the very latest version can be installed using: pip install git+git://github.com/WMD-group/SMACT.git From e80c750e0bb686eb08afe47f6cf8d9f853036b44 Mon Sep 17 00:00:00 2001 From: Anthony Onwuli <30937913+AntObi@users.noreply.github.com> Date: Mon, 11 Sep 2023 11:17:11 +0100 Subject: [PATCH 17/56] Update README.md Add descriptions for structure prediction and dopant prediction modules to the README --- README.md | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index ee23ebf1..39766c7d 100644 --- a/README.md +++ b/README.md @@ -60,7 +60,9 @@ Code features - The code also has some tools for manipulating common crystal lattice types: - Common crystal structure types can be built using the [builder module](https://smact.readthedocs.io/en/latest/smact.builder.html) - Lattice parameters can be quickly estimated using ionic radii of the elements for various common crystal structure types using the [lattice_parameters module](https://smact.readthedocs.io/en/latest/smact.lattice_parameters.html). - - The [lattice module](https://smact.readthedocs.io/en/latest/smact.lattice.html) and [distorter module](https://smact.readthedocs.io/en/latest/smact.distorter.html) rely on the [Atomic Simulation Environment](https://wiki.fysik.dtu.dk/ase/) and can be used to generate unique atomic substitutions on a given crystal structure. + - The [lattice module](https://smact.readthedocs.io/en/latest/smact.lattice.html) and [distorter module](https://smact.readthedocs.io/en/latest/smact.distorter.html) rely on the [Atomic Simulation Environment](https://wiki.fysik.dtu.dk/ase/) and can be used to generate unique atomic substitutions on a given crystal structure. + - The [structure prediction](https://smact.readthedocs.io/en/latest/smact.structure_prediction.html) module can be used to predict the structure of hypothetical compositions using species similarity measures. + - The [dopant prediction](https://smact.readthedocs.io/en/latest/smact.dopant_prediction.html) module can be used to facilitate high-throughput predictions of p-type and n-type dopants of multicomponent solids. List of modules ------- @@ -78,6 +80,9 @@ List of modules * **lattice_parameters.py** Estimation of lattice parameters for various lattice types using covalent/ionic radii. * **distorter.py** A collection of functions for enumerating and then substituting on inequivalent sites of a sub-lattice. + * **oxidation_states.py**: Used for predicting the likelihood of species coexisting in a compound based on a statistical model. + * **structure_prediction**: A submodule which contains a collection of tools for facilitating crystal structure predictions via ionic substitutions + * **dopant_prediction**: A submodule which contains a collections of tools for predicting n-type and p-type dopants. Requirements ------------ From 6749f929f1cf10e6709614677b8ae85843a28664 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Sun, 1 Oct 2023 17:52:20 +0000 Subject: [PATCH 18/56] Bump actions/checkout from 3 to 4 Bumps [actions/checkout](https://github.com/actions/checkout) from 3 to 4. - [Release notes](https://github.com/actions/checkout/releases) - [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md) - [Commits](https://github.com/actions/checkout/compare/v3...v4) --- updated-dependencies: - dependency-name: actions/checkout dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] --- .github/workflows/ci.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 315d101c..a5232f58 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -7,7 +7,7 @@ jobs: qa: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 - uses: pre-commit/action@v3.0.0 test: @@ -20,7 +20,7 @@ jobs: runs-on: ${{matrix.os}} steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v4 with: From 4de2dc174e57e0b6309b53c42378fdde958a8ef2 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 3 Oct 2023 00:14:51 +0000 Subject: [PATCH 19/56] Bump urllib3 from 2.0.4 to 2.0.6 Bumps [urllib3](https://github.com/urllib3/urllib3) from 2.0.4 to 2.0.6. - [Release notes](https://github.com/urllib3/urllib3/releases) - [Changelog](https://github.com/urllib3/urllib3/blob/main/CHANGES.rst) - [Commits](https://github.com/urllib3/urllib3/compare/2.0.4...2.0.6) --- updated-dependencies: - dependency-name: urllib3 dependency-type: direct:production ... Signed-off-by: dependabot[bot] --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 42c7bfa5..bdda772c 100644 --- a/requirements.txt +++ b/requirements.txt @@ -145,7 +145,7 @@ tzdata==2023.3 # via pandas uncertainties==3.1.7 # via pymatgen -urllib3==2.0.4 +urllib3==2.0.6 # via requests zipp==3.16.2 # via importlib-resources From 0c8d113872481635c2c2ce3aade60f1add3ec88a Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 3 Oct 2023 00:15:03 +0000 Subject: [PATCH 20/56] Bump urllib3 from 2.0.4 to 2.0.6 in /docs Bumps [urllib3](https://github.com/urllib3/urllib3) from 2.0.4 to 2.0.6. - [Release notes](https://github.com/urllib3/urllib3/releases) - [Changelog](https://github.com/urllib3/urllib3/blob/main/CHANGES.rst) - [Commits](https://github.com/urllib3/urllib3/compare/2.0.4...2.0.6) --- updated-dependencies: - dependency-name: urllib3 dependency-type: indirect ... Signed-off-by: dependabot[bot] --- docs/requirements.txt | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/docs/requirements.txt b/docs/requirements.txt index 549fb24c..f33562e7 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -20,8 +20,6 @@ idna==3.4 # via requests imagesize==1.4.1 # via sphinx -importlib-metadata==6.8.0 - # via sphinx jinja2==3.1.2 # via sphinx markupsafe==2.1.3 @@ -30,8 +28,6 @@ packaging==23.1 # via sphinx pygments==2.16.1 # via sphinx -pytz==2023.3 - # via babel readthedocs-sphinx-search==0.1.1 # via -r requirements.in requests==2.31.0 @@ -56,7 +52,5 @@ sphinxcontrib-qthelp==1.0.3 # via sphinx sphinxcontrib-serializinghtml==1.1.5 # via sphinx -urllib3==2.0.4 +urllib3==2.0.6 # via requests -zipp==3.16.2 - # via importlib-metadata From 9ed7cb12113f429062e738ad0f02b0e5c2886dc1 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 3 Oct 2023 20:46:47 +0000 Subject: [PATCH 21/56] Bump pillow from 10.0.0 to 10.0.1 Bumps [pillow](https://github.com/python-pillow/Pillow) from 10.0.0 to 10.0.1. - [Release notes](https://github.com/python-pillow/Pillow/releases) - [Changelog](https://github.com/python-pillow/Pillow/blob/main/CHANGES.rst) - [Commits](https://github.com/python-pillow/Pillow/compare/10.0.0...10.0.1) --- updated-dependencies: - dependency-name: pillow dependency-type: direct:production ... Signed-off-by: dependabot[bot] --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 42c7bfa5..f3cecea5 100644 --- a/requirements.txt +++ b/requirements.txt @@ -74,7 +74,7 @@ pandas==2.0.3 # pymatgen pathos==0.3.1 # via SMACT (setup.py) -pillow==10.0.0 +pillow==10.0.1 # via matplotlib plotly==5.16.1 # via pymatgen From 77661ce846734f98caebd00e42d6bc3b632724a2 Mon Sep 17 00:00:00 2001 From: Chloe <57512209+JiwooChloeLee@users.noreply.github.com> Date: Thu, 5 Oct 2023 00:23:52 +0900 Subject: [PATCH 22/56] compare ternary/quaternary charge state fixed --- .../Dopant_Prediction/doper_example.ipynb | 138 ++++++++++---- smact/dopant_prediction/doper.py | 176 ++++++++++-------- 2 files changed, 191 insertions(+), 123 deletions(-) diff --git a/examples/Dopant_Prediction/doper_example.ipynb b/examples/Dopant_Prediction/doper_example.ipynb index dde348c8..f02a93c5 100644 --- a/examples/Dopant_Prediction/doper_example.ipynb +++ b/examples/Dopant_Prediction/doper_example.ipynb @@ -20,7 +20,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 2, "id": "58e48522", "metadata": {}, "outputs": [], @@ -49,7 +49,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 3, "id": "193682c3", "metadata": {}, "outputs": [ @@ -80,14 +80,16 @@ " ('Ni2+', 'Ti4+', 5.534033894511336e-05),\n", " ('V3+', 'Ti4+', 5.312098771970144e-05),\n", " ('Li1+', 'Ti4+', 4.90559802023167e-05),\n", + " ('Cs1+', 'Ti4+', 4.7198027389186586e-05),\n", + " ('Ba2+', 'Ti4+', 4.7198027389186586e-05),\n", " ('Co2+', 'Ti4+', 4.3842431279341393e-05),\n", " ('K1+', 'Ti4+', 4.3838924025131085e-05),\n", " ('Cr3+', 'Ti4+', 4.234338028148513e-05),\n", - " ('Mn3+', 'Ti4+', 3.7092622638148224e-05),\n", - " ('Fe2+', 'Ti4+', 3.333914056567426e-05),\n", - " ('Al3+', 'Ti4+', 3.0368749390927986e-05)],\n", + " ('Cd2+', 'Ti4+', 4.0952468901483766e-05)],\n", " 'n-type anion substitutions': [('F1-', 'O2-', 0.01508116810515677),\n", " ('Cl1-', 'O2-', 0.004737202729901607),\n", + " ('Br1-', 'O2-', 0.0010829911758767157),\n", + " ('I1-', 'O2-', 0.0007848025041948803),\n", " ('H1-', 'O2-', 9.31310255126729e-08),\n", " ('C1-', 'O2-', 9.31310255126729e-08),\n", " ('N1-', 'O2-', 9.31310255126729e-08),\n", @@ -98,9 +100,7 @@ " ('S1-', 'O2-', 9.31310255126729e-08),\n", " ('K1-', 'O2-', 9.31310255126729e-08),\n", " ('Ti1-', 'O2-', 9.31310255126729e-08),\n", - " ('V1-', 'O2-', 9.31310255126729e-08),\n", - " ('Cr1-', 'O2-', 9.31310255126729e-08),\n", - " ('Mn1-', 'O2-', 9.31310255126729e-08)],\n", + " ('V1-', 'O2-', 9.31310255126729e-08)],\n", " 'p-type anion substitutions': [('N3-', 'O2-', 0.0014663800608945628),\n", " ('C4-', 'O2-', 9.31310255126729e-08),\n", " ('C3-', 'O2-', 9.31310255126729e-08),\n", @@ -118,7 +118,7 @@ " ('Ir3-', 'O2-', 9.31310255126729e-08)]}" ] }, - "execution_count": 6, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -142,28 +142,28 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 4, "id": "df5a5dbb", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'n-type cation substitutions': [('Si4+', 'Ge4+', 0.0008777853600526021),\n", - " ('Co2+', 'Zn2+', 0.00038676299875561366),\n", - " ('Cd2+', 'Zn2+', 0.00034479571082730946),\n", - " ('Mg2+', 'Zn2+', 0.00034293540270251613),\n", - " ('Mn2+', 'Zn2+', 0.00033249741948425897)],\n", - " 'p-type cation substitutions': [('Ag1+', 'Cu1+', 0.0004187742948950742),\n", - " ('Co2+', 'Zn2+', 0.00038676299875561366),\n", - " ('Cd2+', 'Zn2+', 0.00034479571082730946),\n", - " ('Mg2+', 'Zn2+', 0.00034293540270251613),\n", - " ('Mn2+', 'Zn2+', 0.00033249741948425897)],\n", + "{'n-type cation substitutions': [('Si4+', 'Zn2+', 0.0002388228584563032),\n", + " ('Zn2+', 'Cu1+', 0.00021454984717151132),\n", + " ('Hg2+', 'Cu1+', 0.00020520758963053147),\n", + " ('Ge4+', 'Zn2+', 0.0001751936790055855),\n", + " ('P5+', 'Ge4+', 0.0001357428244856664)],\n", + " 'p-type cation substitutions': [('Na1+', 'Zn2+', 0.00025743109681607455),\n", + " ('Cu1+', 'Zn2+', 0.00021454984717151132),\n", + " ('Zn2+', 'Ge4+', 0.0001751936790055855),\n", + " ('K1+', 'Zn2+', 0.0001201669587993145),\n", + " ('Cd2+', 'Ge4+', 0.0001186113401908585)],\n", " 'n-type anion substitutions': [('Cl1-', 'S2-', 0.000708721114826238),\n", + " ('Br1-', 'S2-', 0.00037892265173268845),\n", + " ('I1-', 'S2-', 0.0003595495863623017),\n", " ('F1-', 'S2-', 0.00021217514709258802),\n", - " ('H1-', 'S2-', 9.31310255126729e-08),\n", - " ('C1-', 'S2-', 9.31310255126729e-08),\n", - " ('N1-', 'S2-', 9.31310255126729e-08)],\n", + " ('H1-', 'S2-', 9.31310255126729e-08)],\n", " 'p-type anion substitutions': [('N3-', 'S2-', 0.0007862635952461277),\n", " ('C4-', 'S2-', 9.31310255126729e-08),\n", " ('C3-', 'S2-', 9.31310255126729e-08),\n", @@ -171,7 +171,7 @@ " ('Si3-', 'S2-', 9.31310255126729e-08)]}" ] }, - "execution_count": 19, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -182,39 +182,95 @@ ] }, { - "attachments": {}, "cell_type": "markdown", - "id": "f2524a92", + "id": "c770725e", "metadata": {}, "source": [ - "If you want to plot the results in the form of heatmap, use `plot_dopants` method.\n", + "If you want to plot the results in the form of heatmap, use `plot_dopants` method. Note that `get_dopants` method must be ran before `plot_dopants`.\n", "\n", "`num_dopants` input can also be used." ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 6, "id": "dc29d078", "metadata": {}, "outputs": [ { - "ename": "ValueError", - "evalue": "too many values to unpack (expected 2)", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[20], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m quaternary\u001b[39m.\u001b[39;49mplot_dopants(\u001b[39m10\u001b[39;49m)\n", - "File \u001b[0;32m~/Documents/smactClone/SMACT/smact/dopant_prediction/doper.py:191\u001b[0m, in \u001b[0;36mDoper.plot_dopants\u001b[0;34m(self, num_dopants)\u001b[0m\n\u001b[1;32m 184\u001b[0m results \u001b[39m=\u001b[39m {\n\u001b[1;32m 185\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mn-type cation substitutions\u001b[39m\u001b[39m\"\u001b[39m: \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mn_type_cat[:num_dopants],\n\u001b[1;32m 186\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mp-type cation substitutions\u001b[39m\u001b[39m\"\u001b[39m: \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mp_type_cat[:num_dopants],\n\u001b[1;32m 187\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mn-type anion substitutions\u001b[39m\u001b[39m\"\u001b[39m: \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mn_type_an[:num_dopants],\n\u001b[1;32m 188\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mp-type anion substitutions\u001b[39m\u001b[39m\"\u001b[39m: \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mp_type_an[:num_dopants],\n\u001b[1;32m 189\u001b[0m }\n\u001b[1;32m 190\u001b[0m \u001b[39mfor\u001b[39;00m key, val \u001b[39min\u001b[39;00m results\u001b[39m.\u001b[39mitems():\n\u001b[0;32m--> 191\u001b[0m dict_results \u001b[39m=\u001b[39m {utilities\u001b[39m.\u001b[39mparse_spec(x)[\u001b[39m0\u001b[39m]: y \u001b[39mfor\u001b[39;00m x, y \u001b[39min\u001b[39;00m val}\n\u001b[1;32m 192\u001b[0m plotting\u001b[39m.\u001b[39mperiodic_table_heatmap(\n\u001b[1;32m 193\u001b[0m elemental_data\u001b[39m=\u001b[39mdict_results,\n\u001b[1;32m 194\u001b[0m cmap\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mrainbow\u001b[39m\u001b[39m\"\u001b[39m,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 197\u001b[0m show_plot\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m,\n\u001b[1;32m 198\u001b[0m )\n", - "File \u001b[0;32m~/Documents/smactClone/SMACT/smact/dopant_prediction/doper.py:191\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 184\u001b[0m results \u001b[39m=\u001b[39m {\n\u001b[1;32m 185\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mn-type cation substitutions\u001b[39m\u001b[39m\"\u001b[39m: \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mn_type_cat[:num_dopants],\n\u001b[1;32m 186\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mp-type cation substitutions\u001b[39m\u001b[39m\"\u001b[39m: \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mp_type_cat[:num_dopants],\n\u001b[1;32m 187\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mn-type anion substitutions\u001b[39m\u001b[39m\"\u001b[39m: \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mn_type_an[:num_dopants],\n\u001b[1;32m 188\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mp-type anion substitutions\u001b[39m\u001b[39m\"\u001b[39m: \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mp_type_an[:num_dopants],\n\u001b[1;32m 189\u001b[0m }\n\u001b[1;32m 190\u001b[0m \u001b[39mfor\u001b[39;00m key, val \u001b[39min\u001b[39;00m results\u001b[39m.\u001b[39mitems():\n\u001b[0;32m--> 191\u001b[0m dict_results \u001b[39m=\u001b[39m {utilities\u001b[39m.\u001b[39mparse_spec(x)[\u001b[39m0\u001b[39m]: y \u001b[39mfor\u001b[39;00m x, y \u001b[39min\u001b[39;00m val}\n\u001b[1;32m 192\u001b[0m plotting\u001b[39m.\u001b[39mperiodic_table_heatmap(\n\u001b[1;32m 193\u001b[0m elemental_data\u001b[39m=\u001b[39mdict_results,\n\u001b[1;32m 194\u001b[0m cmap\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mrainbow\u001b[39m\u001b[39m\"\u001b[39m,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 197\u001b[0m show_plot\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m,\n\u001b[1;32m 198\u001b[0m )\n", - "\u001b[0;31mValueError\u001b[0m: too many values to unpack (expected 2)" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "quaternary.plot_dopants(10)" + "quaternary.plot_dopants()" ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "3f2f72b5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'TODO: mention Lambda file as input\\n& introduce getter and setter'" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"TODO: mention Lambda file as input\n", + "& introduce getter and setter\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1e44be06", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -233,7 +289,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.9.17" } }, "nbformat": 4, diff --git a/smact/dopant_prediction/doper.py b/smact/dopant_prediction/doper.py index f3dba6ff..52220a87 100644 --- a/smact/dopant_prediction/doper.py +++ b/smact/dopant_prediction/doper.py @@ -12,7 +12,7 @@ class Doper: Methods: get_dopants, plot_dopants Attributes: - original_species: A tuple which describes the constituent species of a material. For example: + _original_species: A tuple which describes the constituent species of a material. For example: >>> test= Doper(("Zn2+","S2-")) >>> test.original_species @@ -21,23 +21,40 @@ class Doper: """ def __init__( - self, original_species: Tuple[str, ...], filepath: str = None + self, _original_species: Tuple[str, ...], filepath: str = None ): """ Intialise the `Doper` class with a tuple of species Args: - original_species: See :class:`~.Doper`. + _original_species: See :class:`~.Doper`. + filepath (str): lambda table json file """ - self.original_species = original_species - self._get_dopants(filepath) + self._original_species = _original_species + self._filepath = filepath + + @property + def original_species(self): + return self._original_species + + @original_species.setter + def original_species(self, original_species): + self._original_species = original_species + + @property + def filepath(self): + return self._filepath + + @filepath.setter + def filepath(self, filepath): + self._filepath = filepath def _get_cation_dopants( self, element_objects: List[smact.Element], cations: List[str] ): - poss_n_type_cat = [] - poss_p_type_cat = [] + poss_n_type_cat = set() + poss_p_type_cat = set() for element in element_objects: # [-2, -1, 0, +1, +2] @@ -48,19 +65,17 @@ def _get_cation_dopants( ele = utilities.unparse_spec((el_symbol, state)) _, charge = utilities.parse_spec(cation) if state > charge: - if ele not in poss_n_type_cat: - poss_n_type_cat.append(ele) + poss_n_type_cat.add(ele) elif state < charge and state > 0: - if ele not in poss_p_type_cat: - poss_p_type_cat.append(ele) + poss_p_type_cat.add(ele) - return poss_n_type_cat, poss_p_type_cat + return list(poss_n_type_cat), list(poss_p_type_cat) def _get_anion_dopants( self, element_objects: List[smact.Element], anions: List[str] ): - poss_n_type_an = [] - poss_p_type_an = [] + poss_n_type_an = set() + poss_p_type_an = set() for element in element_objects: oxi_state = element.oxidation_states @@ -70,27 +85,48 @@ def _get_anion_dopants( ele = utilities.unparse_spec((el_symbol, state)) _, charge = utilities.parse_spec(anion) if state > charge and state < 0: - if ele not in poss_n_type_an: - poss_n_type_an.append(ele) + poss_n_type_an.add(ele) elif state < charge: - if ele not in poss_p_type_an: - poss_p_type_an.append(ele) - return poss_n_type_an, poss_p_type_an + poss_p_type_an.add(ele) + return list(poss_n_type_an), list(poss_p_type_an) + + def get_dopants( + self, + num_dopants: int = 5, + ) -> dict: + """ + Args: + num_dopants (int): The number of suggestions to return for n- and p-type dopants. + Returns: + (dict): Dopant suggestions, given as a dictionary with keys + "n_type_cation", "p_type_cation", "n_type_anion", "p_type_anion". + + Examples: + >>> test = Doper(('Ti4+','O2-')) + >>> print(test.get_dopants(num_dopants=2)) + {'n-type cation substitutions': [('Ta5+', 8.790371775858281e-05), + ('Nb5+', 7.830035204694342e-05)], + 'p-type cation substitutions': [('Na1+', 0.00010060400812977031), + ('Zn2+', 8.56373996146833e-05)], + 'n-type anion substitutions': [('F1-', 0.01508116810515677), + ('Cl1-', 0.004737202729901607)], + 'p-type anion substitutions': [('N3-', 0.0014663800608945628), + ('C4-', 9.31310255126729e-08)]} + """ - def _get_dopants(self, filepath: str): cations = [] anions = [] try: - for ion in self.original_species: + for ion in self._original_species: _, charge = utilities.parse_spec(ion) if charge > 0: cations.append(ion) elif charge < 0: anions.append(ion) except Exception as e: - print(e, "charge is not defined") + print(f"{e}: charge is not defined for {ion}!") - CM = mutation.CationMutator.from_json(filepath) + CM = mutation.CationMutator.from_json(self._filepath) # call all elements element_objects = list(smact.element_dictionary().values()) @@ -104,23 +140,35 @@ def _get_dopants(self, filepath: str): n_type_cat, p_type_cat, n_type_an, p_type_an = [], [], [], [] for cation in cations: - for n_specie, p_specie in zip(poss_n_type_cat, poss_p_type_cat): - if cation == n_specie or cation == p_specie: + cation_charge = utilities.parse_spec(cation)[1] + for n_specie in poss_n_type_cat: + n_specie_charge = utilities.parse_spec(n_specie)[1] + if cation_charge >= n_specie_charge: continue n_type_cat.append( (n_specie, cation, CM.sub_prob(cation, n_specie)) ) + for p_specie in poss_p_type_cat: + p_specie_charge = utilities.parse_spec(p_specie)[1] + if cation_charge <= p_specie_charge: + continue p_type_cat.append( (p_specie, cation, CM.sub_prob(cation, p_specie)) ) for anion in anions: - for n_specie, p_specie in zip(poss_n_type_an, poss_p_type_an): - if anion == n_specie or cation == p_specie: + anion_charge = utilities.parse_spec(anion)[1] + for n_specie in poss_n_type_an: + n_specie_charge = utilities.parse_spec(n_specie)[1] + if anion == n_specie or anion_charge >= n_specie_charge: continue n_type_an.append( (n_specie, anion, CM.sub_prob(anion, n_specie)) ) + for p_specie in poss_p_type_an: + p_specie_charge = utilities.parse_spec(p_specie)[1] + if anion == p_specie or anion_charge <= p_specie_charge: + continue p_type_an.append( (p_specie, anion, CM.sub_prob(anion, p_specie)) ) @@ -132,67 +180,31 @@ def _get_dopants(self, filepath: str): n_type_an.sort(key=lambda x: x[-1], reverse=True) p_type_an.sort(key=lambda x: x[-1], reverse=True) - self.n_type_cat = n_type_cat - self.p_type_cat = p_type_cat - self.n_type_an = n_type_an - self.p_type_an = p_type_an - - def get_dopants( - self, - num_dopants: int = 5, - ) -> dict: - """ - Args: - num_dopants (int): The number of suggestions to return for n- and p-type dopants. - Returns: - (dict): Dopant suggestions, given as a dictionary with keys - "n_type_cation", "p_type_cation", "n_type_anion", "p_type_anion". - - Examples: - >>> test = Doper(('Ti4+','O2-')) - >>> print(test.get_dopants(num_dopants=2)) - {'n-type cation substitutions': [('Ta5+', 8.790371775858281e-05), - ('Nb5+', 7.830035204694342e-05)], - 'p-type cation substitutions': [('Na1+', 0.00010060400812977031), - ('Zn2+', 8.56373996146833e-05)], - 'n-type anion substitutions': [('F1-', 0.01508116810515677), - ('Cl1-', 0.004737202729901607)], - 'p-type anion substitutions': [('N3-', 0.0014663800608945628), - ('C4-', 9.31310255126729e-08)]} - """ - - results = { - "n-type cation substitutions": self.n_type_cat[:num_dopants], - "p-type cation substitutions": self.p_type_cat[:num_dopants], - "n-type anion substitutions": self.n_type_an[:num_dopants], - "p-type anion substitutions": self.p_type_an[:num_dopants], + self.results = { + "n-type cation substitutions": n_type_cat[:num_dopants], + "p-type cation substitutions": p_type_cat[:num_dopants], + "n-type anion substitutions": n_type_an[:num_dopants], + "p-type anion substitutions": p_type_an[:num_dopants], } # return the top (num_dopants) results for each case - return results + return self.results - def plot_dopants( - self, - num_dopants: int = 5, - ) -> None: + def plot_dopants(self) -> None: """ Uses pymatgen plotting utilities to plot the results of doping search Args: - num_dopants (int): The number of suggestions to return for n- and p-type dopants. + None Returns: None """ - results = { - "n-type cation substitutions": self.n_type_cat[:num_dopants], - "p-type cation substitutions": self.p_type_cat[:num_dopants], - "n-type anion substitutions": self.n_type_an[:num_dopants], - "p-type anion substitutions": self.p_type_an[:num_dopants], - } - for key, val in results.items(): - dict_results = {utilities.parse_spec(x)[0]: y for x, _, y in val} - plotting.periodic_table_heatmap( - elemental_data=dict_results, - cmap="rainbow", - blank_color="gainsboro", - edge_color="white", - show_plot=True, - ) + try: + for val in self.results.values(): + dict_results = {utilities.parse_spec(x)[0]: y for x, _, y in val} + plotting.periodic_table_heatmap( + elemental_data=dict_results, + cmap="rainbow", + blank_color="gainsboro", + edge_color="white", + ) + except AttributeError as e: + print(f"Dopants are not calculated. Run get_dopants first.") From 8e75a7b2021f8b50ba6767d860cae3b8d9f994fa Mon Sep 17 00:00:00 2001 From: Anthony Onwuli <30937913+AntObi@users.noreply.github.com> Date: Thu, 5 Oct 2023 14:18:45 +0100 Subject: [PATCH 23/56] Update ci.yml --- .github/workflows/ci.yml | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index a5232f58..8f3c0921 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -1,6 +1,10 @@ name: SMACT CI -on: [push] +on: + pull_request: + push: + branches: + - master jobs: @@ -42,4 +46,4 @@ jobs: verbose: true - \ No newline at end of file + From 716c506dee31c5a0abc2b332ded958b924ec7189 Mon Sep 17 00:00:00 2001 From: Anthony Onwuli Date: Thu, 5 Oct 2023 17:58:58 +0100 Subject: [PATCH 24/56] Ran pre-commit --- smact/dopant_prediction/doper.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/smact/dopant_prediction/doper.py b/smact/dopant_prediction/doper.py index 52220a87..82f1ed76 100644 --- a/smact/dopant_prediction/doper.py +++ b/smact/dopant_prediction/doper.py @@ -37,7 +37,7 @@ def __init__( @property def original_species(self): return self._original_species - + @original_species.setter def original_species(self, original_species): self._original_species = original_species @@ -45,7 +45,7 @@ def original_species(self, original_species): @property def filepath(self): return self._filepath - + @filepath.setter def filepath(self, filepath): self._filepath = filepath @@ -199,7 +199,9 @@ def plot_dopants(self) -> None: """ try: for val in self.results.values(): - dict_results = {utilities.parse_spec(x)[0]: y for x, _, y in val} + dict_results = { + utilities.parse_spec(x)[0]: y for x, _, y in val + } plotting.periodic_table_heatmap( elemental_data=dict_results, cmap="rainbow", From 4a9fa624b7cc86efc9bb8349049658a21574e5b6 Mon Sep 17 00:00:00 2001 From: Anthony Onwuli Date: Thu, 5 Oct 2023 18:30:29 +0100 Subject: [PATCH 25/56] Update ci.yml --- .github/workflows/ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index a5232f58..6f9d85ba 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -37,7 +37,7 @@ jobs: with: token: ${{ secrets.CODECOV_TOKEN }} #files: ./coverage.xml - fail_ci_if_error: true + fail_ci_if_error: False env_vars: OS,PYTHON verbose: true From 1f8341a50df4dff4af3cc4652624fd57e07895a4 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 17 Oct 2023 21:07:07 +0000 Subject: [PATCH 26/56] Bump urllib3 from 2.0.6 to 2.0.7 Bumps [urllib3](https://github.com/urllib3/urllib3) from 2.0.6 to 2.0.7. - [Release notes](https://github.com/urllib3/urllib3/releases) - [Changelog](https://github.com/urllib3/urllib3/blob/main/CHANGES.rst) - [Commits](https://github.com/urllib3/urllib3/compare/2.0.6...2.0.7) --- updated-dependencies: - dependency-name: urllib3 dependency-type: direct:production ... Signed-off-by: dependabot[bot] --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 9a685e05..cf419b80 100644 --- a/requirements.txt +++ b/requirements.txt @@ -145,7 +145,7 @@ tzdata==2023.3 # via pandas uncertainties==3.1.7 # via pymatgen -urllib3==2.0.6 +urllib3==2.0.7 # via requests zipp==3.16.2 # via importlib-resources From 667263a851126cc901afac8ec7d44e8a75c36062 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 17 Oct 2023 21:08:21 +0000 Subject: [PATCH 27/56] Bump urllib3 from 2.0.6 to 2.0.7 in /docs Bumps [urllib3](https://github.com/urllib3/urllib3) from 2.0.6 to 2.0.7. - [Release notes](https://github.com/urllib3/urllib3/releases) - [Changelog](https://github.com/urllib3/urllib3/blob/main/CHANGES.rst) - [Commits](https://github.com/urllib3/urllib3/compare/2.0.6...2.0.7) --- updated-dependencies: - dependency-name: urllib3 dependency-type: indirect ... Signed-off-by: dependabot[bot] --- docs/requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/requirements.txt b/docs/requirements.txt index f33562e7..b8d61b3a 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -52,5 +52,5 @@ sphinxcontrib-qthelp==1.0.3 # via sphinx sphinxcontrib-serializinghtml==1.1.5 # via sphinx -urllib3==2.0.6 +urllib3==2.0.7 # via requests From 7c8f0a09c3d1e24c766923e14083d62bb2db81cb Mon Sep 17 00:00:00 2001 From: Park Date: Thu, 19 Oct 2023 16:22:15 +0100 Subject: [PATCH 28/56] a tiny error in eletronegativity of Zr in element_data.txt --- smact/data/element_data.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/smact/data/element_data.txt b/smact/data/element_data.txt index af843539..ed06754e 100644 --- a/smact/data/element_data.txt +++ b/smact/data/element_data.txt @@ -97,7 +97,7 @@ Kr Krypton 36 83.7980000000 1.16 None -13.00 -26.50 1 Rb Rubidium 37 85.4678000000 2.20 0.485916 None -3.94 9.00e+01 0.82 4.177128 316.20 Sr Strontium 38 87.6200000000 1.95 0.05206 None -5.00 3.70e+02 0.95 5.69486720 190.82 Y Yttrium 39 88.9058400000 1.90 0.307 None -5.53 3.30e+01 1.22 6.21726 153.00 -Zr Zirconium 40 91.2240000000 1.75 0.426 None None 1.65e+02 0.33 6.63390 121.00 +Zr Zirconium 40 91.2240000000 1.75 0.426 None None 1.65e+02 1.33 6.63390 121.00 Nb Niobium 41 92.9063700000 1.64 0.893 None None 2.20e+02 1.6 6.75885 106.00 Mo Molybdenum 42 95.9500000000 1.54 0.7472 None None 1.20e+00 2.16 7.09243 72.50 Tc Technetium 43 98.0000000000 1.47 0.55 None None None 2.10 7.11938 80.40 From ef2811b13fcdd41bcd1bbe03239817388bf1088a Mon Sep 17 00:00:00 2001 From: AntObi Date: Thu, 9 Nov 2023 10:10:16 +0000 Subject: [PATCH 29/56] Instantiate Element class with custom oxidation states --- smact/__init__.py | 41 +++++++++++++++++++++++++++++++++++++---- 1 file changed, 37 insertions(+), 4 deletions(-) diff --git a/smact/__init__.py b/smact/__init__.py index ea8eb597..e9af27a8 100644 --- a/smact/__init__.py +++ b/smact/__init__.py @@ -59,6 +59,8 @@ class Element: Element.oxidation_states_wiki (list): List of oxidation states that appear wikipedia (https://en.wikipedia.org/wiki/Template:List_of_oxidation_states_of_the_elements) Data retrieved: 2022-09-22 + Element.oxidation_states_custom (list): List of oxidation states that appear in the custom data file supplied + Element.coord_envs (list): The allowed coordination enviroments for the ion Element.covalent_radius (float) : Covalent radius of the element @@ -77,15 +79,35 @@ class Element: """ - def __init__(self, symbol: str): + def __init__( + self, symbol: str, oxi_states_custom_filepath: Optional[str] = None + ): """Initialise Element class Args: symbol (str): Chemical element symbol (e.g. 'Fe') + oxi_states_custom_filepath (str): Path to custom oxidation states file """ + # Get the oxidation states from the custom file if it exists + if oxi_states_custom_filepath: + try: + self._oxidation_states_custom = ( + data_loader.lookup_element_oxidation_states_custom( + symbol, oxi_states_custom_filepath + ) + ) + self.oxidation_states_custom = self._oxidation_states_custom + except TypeError: + warnings.warn( + "Custom oxidation states file not found. Please check the file path." + ) + self.oxidation_states_custom = None + else: + self.oxidation_states_custom = None + self.symbol = symbol - dataset = data_loader.lookup_element_data(symbol, copy=False) + dataset = data_loader.lookup_element_data(self.symbol, copy=False) if dataset == None: raise NameError(f"Elemental data for {symbol} not found.") @@ -307,7 +329,10 @@ def ordered_elements(x: int, y: int) -> List[str]: return ordered_elements -def element_dictionary(elements: Optional[Iterable[str]] = None): +def element_dictionary( + elements: Optional[Iterable[str]] = None, + oxi_states_custom_filepath: Optional[str] = None, +): """ Create a dictionary of initialised smact.Element objects @@ -317,13 +342,21 @@ def element_dictionary(elements: Optional[Iterable[str]] = None): Args: elements (iterable of strings) : Elements to include. If None, use all elements up to 103. + + Returns: dict: Dictionary with element symbols as keys and smact.Element objects as data """ if elements == None: elements = ordered_elements(1, 103) - return {symbol: Element(symbol) for symbol in elements} + if oxi_states_custom_filepath: + return { + symbol: Element(symbol, oxi_states_custom_filepath) + for symbol in elements + } + else: + return {symbol: Element(symbol) for symbol in elements} def are_eq(A: list, B: list, tolerance: float = 1e-4): From ad08aa18a4d957a0648c5f78985a4f3a0fa528c1 Mon Sep 17 00:00:00 2001 From: AntObi Date: Thu, 9 Nov 2023 10:11:52 +0000 Subject: [PATCH 30/56] Update test to check `oxidation_states_custom` attribute --- smact/tests/test_core.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/smact/tests/test_core.py b/smact/tests/test_core.py index 045d8488..b895bc53 100755 --- a/smact/tests/test_core.py +++ b/smact/tests/test_core.py @@ -23,7 +23,9 @@ class TestSequenceFunctions(unittest.TestCase): # ---------------- TOP-LEVEL ---------------- def test_Element_class_Pt(self): - Pt = smact.Element("Pt") + Pt = smact.Element( + "Pt", + ) self.assertEqual(Pt.name, "Platinum") self.assertEqual(Pt.ionpot, 8.95883) self.assertEqual(Pt.number, 78) @@ -37,9 +39,10 @@ def test_ordered_elements(self): def test_element_dictionary(self): newlist = ["O", "Rb", "W"] - dictionary = smact.element_dictionary(newlist) + dictionary = smact.element_dictionary(newlist, TEST_OX_STATES) self.assertEqual(dictionary["O"].crustal_abundance, 461000.0) self.assertEqual(dictionary["Rb"].oxidation_states, [-1, 1]) + self.assertEqual(dictionary["Rb"].oxidation_states_custom, [-1, 1]) self.assertEqual(dictionary["W"].name, "Tungsten") self.assertTrue("Rn" in smact.element_dictionary()) From b27e5fe528ccfed5f812eb497c22550e8e899b11 Mon Sep 17 00:00:00 2001 From: AntObi Date: Thu, 9 Nov 2023 10:29:41 +0000 Subject: [PATCH 31/56] Update doc strings --- smact/__init__.py | 3 ++- smact/screening.py | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/smact/__init__.py b/smact/__init__.py index e9af27a8..e19dc51b 100644 --- a/smact/__init__.py +++ b/smact/__init__.py @@ -59,7 +59,7 @@ class Element: Element.oxidation_states_wiki (list): List of oxidation states that appear wikipedia (https://en.wikipedia.org/wiki/Template:List_of_oxidation_states_of_the_elements) Data retrieved: 2022-09-22 - Element.oxidation_states_custom (list): List of oxidation states that appear in the custom data file supplied + Element.oxidation_states_custom (list | None ): List of oxidation states that appear in the custom data file supplied (if any) Element.coord_envs (list): The allowed coordination enviroments for the ion @@ -342,6 +342,7 @@ def element_dictionary( Args: elements (iterable of strings) : Elements to include. If None, use all elements up to 103. + oxi_states_custom_filepath (str): Path to custom oxidation states file Returns: diff --git a/smact/screening.py b/smact/screening.py index 591c1284..1931e0ab 100644 --- a/smact/screening.py +++ b/smact/screening.py @@ -328,7 +328,7 @@ def smact_filter( threshold (int): Threshold for stoichiometry limit, default = 8 stoichs (list[int]): A selection of valid stoichiometric ratios for each site. species_unique (bool): Whether or not to consider elements in different oxidation states as unique in the results. - oxidation_states_set (string): A string to choose which set of oxidation states should be chosen. Options are 'default', 'icsd', 'pymatgen' and 'wiki' for the default, icsd, pymatgen structure predictor and Wikipedia (https://en.wikipedia.org/wiki/Template:List_of_oxidation_states_of_the_elements) oxidation states respectively. + oxidation_states_set (string): A string to choose which set of oxidation states should be chosen. Options are 'default', 'icsd', 'pymatgen' and 'wiki' for the default, icsd, pymatgen structure predictor and Wikipedia (https://en.wikipedia.org/wiki/Template:List_of_oxidation_states_of_the_elements) oxidation states respectively. A filepath to an oxidation states text file can also be supplied as well. comp_tuple (bool): Whether or not to return the results as a named tuple of elements and stoichiometries (True) or as a normal tuple of elements and stoichiometries (False). Returns: allowed_comps (list): Allowed compositions for that chemical system From aea3937951245903ebbe36faf9f3cc00c2eaf4af Mon Sep 17 00:00:00 2001 From: AntObi Date: Thu, 9 Nov 2023 10:50:07 +0000 Subject: [PATCH 32/56] Ran pre-commit --- smact/dopant_prediction/doper.py | 1 - 1 file changed, 1 deletion(-) diff --git a/smact/dopant_prediction/doper.py b/smact/dopant_prediction/doper.py index 63c57649..82f1ed76 100644 --- a/smact/dopant_prediction/doper.py +++ b/smact/dopant_prediction/doper.py @@ -20,7 +20,6 @@ class Doper: """ - def __init__( self, _original_species: Tuple[str, ...], filepath: str = None ): From c5e4723a2c75b9f3d0a0fb7634435ef8e39e0721 Mon Sep 17 00:00:00 2001 From: Aron Walsh Date: Fri, 17 Nov 2023 09:50:23 +0000 Subject: [PATCH 33/56] Remove legacy folder Removing old oxidation state folder (outdated files not used in current codebase) --- .../data/oxidation_states/oxidationstates_prob_table.csv | 8 -------- smact/data/oxidation_states/species_list.txt | 1 - 2 files changed, 9 deletions(-) delete mode 100644 smact/data/oxidation_states/oxidationstates_prob_table.csv delete mode 100644 smact/data/oxidation_states/species_list.txt diff --git a/smact/data/oxidation_states/oxidationstates_prob_table.csv b/smact/data/oxidation_states/oxidationstates_prob_table.csv deleted file mode 100644 index 99b3887e..00000000 --- a/smact/data/oxidation_states/oxidationstates_prob_table.csv +++ /dev/null @@ -1,8 +0,0 @@ -"('F', -1)","[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0392156862745098, 0.35294117647058826, 0.6078431372549019, 0.21739130434782608, 0.45652173913043476, 0.17391304347826086, 0.15217391304347827, 0.13157894736842105, 0.5789473684210527, 0.19736842105263158, 0.09210526315789473, 0.0, 0.0, 0.47959183673469385, 0.41836734693877553, 0.10204081632653061, 0.0, 0.0, 0.0, 0.0, 0.23333333333333334, 0.7666666666666667, 0.0, 0.0, 0.6428571428571429, 0.30952380952380953, 0.047619047619047616, 0.0, 0.7288135593220338, 0.13559322033898305, 0.13559322033898305, 0.08080808080808081, 0.8686868686868687, 0.050505050505050504, 1.0, 0.0, 0.0, 1.0, 0.043478260869565216, 0.0, 0.9565217391304348, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.08333333333333333, 0.19444444444444445, 0.7222222222222222, 0.0, 0.2972972972972973, 0.08108108108108109, 0.02702702702702703, 0.5945945945945946, 0.13333333333333333, 0.13333333333333333, 0.13333333333333333, 0.4666666666666667, 0.13333333333333333, 0.05, 0.4, 0.55, 0.7142857142857143, 0.047619047619047616, 0.23809523809523808, 0.4, 0.4666666666666667, 0.13333333333333333, 1.0, 0.045454545454545456, 0.0, 0.9545454545454546, 0.4430379746835443, 0.02531645569620253, 0.5316455696202531, 0.35036496350364965, 0.021897810218978103, 0.6131386861313869, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.9375, 0.0625, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.47368421052631576, 0.5263157894736842, 0.0, 1.0, 0.0, 0.0, 0.3684210526315789, 0.631578947368421, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.26666666666666666, 0.7333333333333333, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.125, 0.0, 0.0, 0.875, 0.0, 0.0, 0.08333333333333333, 0.041666666666666664, 0.25, 0.625, 0.2, 0.5, 0.1, 0.2, 0.25, 0.75, 0.8444444444444444, 0.15555555555555556, 0.8888888888888888, 0.1111111111111111, 0.0, 0.0, 0.7142857142857143, 0.2857142857142857, 0.0, 1.0, 0.0, 0.034482758620689655, 0.41379310344827586, 0.1724137931034483, 0.3793103448275862]" -"('O', -2)","[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.014814814814814815, 0.9851851851851852, 0.0025188916876574307, 0.0982367758186398, 0.8992443324937027, 0.008368200836820083, 0.1297071129707113, 0.26778242677824265, 0.5941422594142259, 0.0960960960960961, 0.40540540540540543, 0.04804804804804805, 0.10510510510510511, 0.34534534534534533, 0.0, 0.5506216696269982, 0.22380106571936056, 0.19005328596802842, 0.019538188277087035, 0.007104795737122558, 0.008880994671403197, 0.0019193857965451055, 0.2399232245681382, 0.7428023032629558, 0.015355086372360844, 0.0117096018735363, 0.7634660421545667, 0.16627634660421545, 0.0585480093676815, 0.0033003300330033004, 0.8679867986798679, 0.10231023102310231, 0.026402640264026403, 0.145748987854251, 0.8205128205128205, 0.033738191632928474, 1.0, 0.004464285714285714, 0.0, 0.9955357142857143, 0.005763688760806916, 0.002881844380403458, 0.9769452449567724, 1.0, 1.0, 0.0, 0.004149377593360996, 0.995850622406639, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0029154518950437317, 0.043731778425655975, 0.061224489795918366, 0.892128279883382, 0.0, 0.02872531418312388, 0.059245960502693, 0.10771992818671454, 0.8043087971274686, 0.029940119760479042, 0.0718562874251497, 0.3413173652694611, 0.49700598802395207, 0.059880239520958084, 0.0, 0.6949152542372882, 0.3050847457627119, 0.881578947368421, 0.07894736842105263, 0.039473684210526314, 0.9866666666666667, 0.0044444444444444444, 0.008888888888888889, 1.0, 0.0, 0.017857142857142856, 0.9821428571428571, 0.2875, 0.00625, 0.70625, 0.321285140562249, 0.0, 0.5863453815261044, 1.0, 1.0, 0.002680965147453083, 0.02680965147453083, 0.9705093833780161, 0.00819672131147541, 0.7049180327868853, 0.28688524590163933, 0.028409090909090908, 0.9715909090909091, 0.02158273381294964, 0.9784172661870504, 0.011560693641618497, 0.9884393063583815, 0.25, 0.75, 0.006329113924050633, 0.9936708860759493, 0.0, 0.0, 0.8709677419354839, 0.12903225806451613, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0136986301369863, 0.9863013698630136, 0.08333333333333333, 0.9166666666666666, 1.0, 0.0, 1.0, 0.0, 0.0, 0.01282051282051282, 0.02564102564102564, 0.9615384615384616, 0.0, 0.0, 0.00980392156862745, 0.029411764705882353, 0.9607843137254902, 0.0, 0.0, 0.05357142857142857, 0.26785714285714285, 0.19047619047619047, 0.4880952380952381, 0.046511627906976744, 0.4883720930232558, 0.3953488372093023, 0.06976744186046512, 0.23417721518987342, 0.7658227848101266, 0.7772020725388601, 0.22279792746113988, 0.8956043956043956, 0.1043956043956044, 0.002702702702702703, 0.0, 0.9297297297297298, 0.05945945945945946, 0.025, 0.975, 0.0, 0.010344827586206896, 0.07586206896551724, 0.07241379310344828, 0.8413793103448276]" -"('Cl', -1)","[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.045454545454545456, 0.3181818181818182, 0.6363636363636364, 0.2727272727272727, 0.45454545454545453, 0.2727272727272727, 0.5, 0.2857142857142857, 0.14285714285714285, 0.07142857142857142, 0.5909090909090909, 0.4090909090909091, 0.0, 0.0, 0.0, 0.0, 0.9285714285714286, 0.0, 0.07142857142857142, 0.0, 0.0, 0.0, 0.0, 0.4375, 0.5625, 0.0, 0.0, 0.8148148148148148, 0.18518518518518517, 0.0, 0.0, 1.0, 0.0, 0.0, 0.4418604651162791, 0.5116279069767442, 0.046511627906976744, 1.0, 0.043478260869565216, 0.08695652173913043, 0.8695652173913043, 0.3333333333333333, 0.0, 0.5, 1.0, 1.0, 0.1111111111111111, 0.0, 0.8888888888888888, 0.03333333333333333, 0.23333333333333334, 0.3, 0.43333333333333335, 0.0, 0.0, 0.3333333333333333, 0.16666666666666666, 0.5, 0.21621621621621623, 0.1891891891891892, 0.21621621621621623, 0.2702702702702703, 0.10810810810810811, 0.1, 0.6, 0.3, 0.0, 0.0, 0.0, 0.75, 0.25, 0.8387096774193549, 0.0, 0.16129032258064516, 0.9473684210526315, 0.05263157894736842, 0.0, 1.0, 0.4166666666666667, 0.08333333333333333, 0.5, 0.4166666666666667, 0.0, 0.5833333333333334, 0.3181818181818182, 0.0, 0.5681818181818182, 1.0, 1.0, 0.0, 0.05, 0.95, 0.0, 0.875, 0.125, 0.0, 1.0, 0.0, 1.0, 0.3333333333333333, 0.6666666666666666, 0.4444444444444444, 0.5555555555555556, 0.16666666666666666, 0.8333333333333334, 0.2, 0.0, 0.8, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.5, 0.5, 1.0, 0.2857142857142857, 0.7142857142857143, 0.0, 0.0, 0.08695652173913043, 0.2608695652173913, 0.6521739130434783, 0.1111111111111111, 0.2222222222222222, 0.2777777777777778, 0.16666666666666666, 0.2222222222222222, 0.03225806451612903, 0.3225806451612903, 0.3225806451612903, 0.22580645161290322, 0.03225806451612903, 0.06451612903225806, 0.6666666666666666, 0.16666666666666666, 0.16666666666666666, 0.0, 0.020833333333333332, 0.9791666666666666, 0.875, 0.125, 0.8125, 0.1875, 0.0, 0.04, 0.96, 0.0, 0.0, 1.0, 0.0, 0.26666666666666666, 0.4, 0.26666666666666666, 0.06666666666666667]" -"('Br', -1)","[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.5, 0.5, 0.5, 0.3333333333333333, 0.16666666666666666, 0.8333333333333334, 0.16666666666666666, 0.0, 0.0, 0.42857142857142855, 0.5714285714285714, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.4444444444444444, 0.5555555555555556, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.7391304347826086, 0.17391304347826086, 0.08695652173913043, 1.0, 0.0, 0.1, 0.9, 0.5555555555555556, 0.0, 0.3333333333333333, 1.0, 1.0, 0.0, 0.0, 1.0, 0.1111111111111111, 0.2222222222222222, 0.3333333333333333, 0.3333333333333333, 0.0, 0.058823529411764705, 0.35294117647058826, 0.11764705882352941, 0.47058823529411764, 0.5, 0.4166666666666667, 0.08333333333333333, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.5, 0.5, 0.0, 0.5384615384615384, 0.15384615384615385, 0.3076923076923077, 1.0, 0.0, 0.0, 1.0, 0.43478260869565216, 0.2608695652173913, 0.30434782608695654, 0.625, 0.0, 0.375, 0.7777777777777778, 0.0, 0.0, 1.0, 1.0, 0.05, 0.2, 0.75, 0.0, 1.0, 0.0, 0.125, 0.875, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 0.2, 0.8, 0.14285714285714285, 0.14285714285714285, 0.7142857142857143, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.8, 0.2, 1.0, 0.0, 0.0, 0.0, 0.0, 0.2, 0.2, 0.6, 0.4166666666666667, 0.08333333333333333, 0.16666666666666666, 0.16666666666666666, 0.16666666666666666, 0.0, 0.5454545454545454, 0.09090909090909091, 0.18181818181818182, 0.09090909090909091, 0.09090909090909091, 1.0, 0.0, 0.0, 0.0, 0.023809523809523808, 0.9761904761904762, 0.9047619047619048, 0.09523809523809523, 1.0, 0.0, 0.1, 0.1, 0.75, 0.0, 0.14285714285714285, 0.8571428571428571, 0.0, 0.25, 0.625, 0.125, 0.0]" -"('I', -1)","[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.5, 0.5, 0.5, 0.3333333333333333, 0.16666666666666666, 1.0, 0.0, 0.0, 0.0, 0.7777777777777778, 0.2222222222222222, 0.0, 0.0, 0.0, 0.14285714285714285, 0.8571428571428571, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.8, 0.2, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.9473684210526315, 0.0, 0.05263157894736842, 1.0, 0.0, 0.2, 0.8, 0.5, 0.0, 0.16666666666666666, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.3076923076923077, 0.5384615384615384, 0.15384615384615385, 0.0, 0.1111111111111111, 0.2777777777777778, 0.1111111111111111, 0.5, 0.5, 0.25, 0.25, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.3333333333333333, 0.2222222222222222, 0.4444444444444444, 1.0, 0.0, 0.0, 1.0, 0.5, 0.05555555555555555, 0.4444444444444444, 0.8, 0.0, 0.2, 0.7647058823529411, 0.0, 0.0, 1.0, 1.0, 0.043478260869565216, 0.34782608695652173, 0.6086956521739131, 0.5, 0.5, 0.0, 0.16666666666666666, 0.8333333333333334, 0.6666666666666666, 0.3333333333333333, 0.3333333333333333, 0.6666666666666666, 1.0, 0.0, 0.5, 0.5, 0.0, 0.0, 1.0, 0.0, 0.3333333333333333, 0.6666666666666666, 0.0, 1.0, 1.0, 0.6666666666666666, 0.3333333333333333, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.2222222222222222, 0.1111111111111111, 0.6666666666666666, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.6, 0.2, 0.2, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.02857142857142857, 0.9714285714285714, 0.9642857142857143, 0.03571428571428571, 1.0, 0.0, 0.125, 0.0625, 0.8125, 0.0, 0.0, 1.0, 0.0, 0.2857142857142857, 0.7142857142857143, 0.0, 0.0]" -"('S', -2)","[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.05263157894736842, 0.9473684210526315, 0.03125, 0.28125, 0.6875, 0.10204081632653061, 0.32653061224489793, 0.3673469387755102, 0.20408163265306123, 0.15789473684210525, 0.8070175438596491, 0.03508771929824561, 0.0, 0.0, 0.0, 0.9423076923076923, 0.038461538461538464, 0.019230769230769232, 0.0, 0.0, 0.0, 0.0, 0.47058823529411764, 0.5098039215686274, 0.0196078431372549, 0.0, 0.6333333333333333, 0.26666666666666666, 0.1, 0.0, 0.7407407407407407, 0.25925925925925924, 0.0, 0.8060344827586207, 0.1939655172413793, 0.0, 1.0, 0.0, 0.05555555555555555, 0.9444444444444444, 0.030927835051546393, 0.041237113402061855, 0.9175257731958762, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.125, 0.041666666666666664, 0.8333333333333334, 0.0, 0.10638297872340426, 0.1702127659574468, 0.3829787234042553, 0.3404255319148936, 0.10526315789473684, 0.42105263157894735, 0.3157894736842105, 0.0, 0.15789473684210525, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.8, 0.2, 1.0, 0.0, 0.0, 0.9919354838709677, 0.008064516129032258, 0.0, 1.0, 0.02666666666666667, 0.04, 0.9333333333333333, 0.3229166666666667, 0.041666666666666664, 0.6354166666666666, 0.8271604938271605, 0.0, 0.12345679012345678, 1.0, 1.0, 0.0, 0.04081632653061224, 0.9591836734693877, 0.023809523809523808, 0.9285714285714286, 0.047619047619047616, 0.041666666666666664, 0.9583333333333334, 0.058823529411764705, 0.9411764705882353, 0.029411764705882353, 0.9705882352941176, 0.9166666666666666, 0.08333333333333333, 0.05, 0.95, 0.0, 0.05555555555555555, 0.9444444444444444, 0.0, 0.045454545454545456, 0.9545454545454546, 0.05263157894736842, 0.9473684210526315, 1.0, 0.05555555555555555, 0.9444444444444444, 0.3333333333333333, 0.6666666666666666, 1.0, 0.07692307692307693, 0.9230769230769231, 0.022222222222222223, 0.08888888888888889, 0.022222222222222223, 0.3333333333333333, 0.5333333333333333, 0.0, 0.0, 0.2857142857142857, 0.0, 0.7142857142857143, 0.0, 0.6, 0.4, 0.0, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0, 0.9887640449438202, 0.011235955056179775, 1.0, 0.0, 0.0, 0.04918032786885246, 0.9508196721311475, 0.0, 0.08333333333333333, 0.9166666666666666, 0.027777777777777776, 0.1388888888888889, 0.7777777777777778, 0.027777777777777776, 0.027777777777777776]" -"('Se', -2)","[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.14285714285714285, 0.8571428571428571, 0.13333333333333333, 0.4, 0.4666666666666667, 0.1111111111111111, 0.5, 0.2222222222222222, 0.16666666666666666, 0.07692307692307693, 0.9230769230769231, 0.0, 0.0, 0.0, 0.0, 0.9285714285714286, 0.07142857142857142, 0.0, 0.0, 0.0, 0.0, 0.0, 0.47058823529411764, 0.5294117647058824, 0.0, 0.0, 0.631578947368421, 0.2631578947368421, 0.10526315789473684, 0.05263157894736842, 0.7894736842105263, 0.15789473684210525, 0.0, 0.8391608391608392, 0.16083916083916083, 0.0, 1.0, 0.0, 0.1111111111111111, 0.8888888888888888, 0.07017543859649122, 0.08771929824561403, 0.8421052631578947, 1.0, 1.0, 0.0, 0.0, 1.0, 0.08333333333333333, 0.0, 0.0, 0.9166666666666666, 0.034482758620689655, 0.0, 0.20689655172413793, 0.3103448275862069, 0.4482758620689655, 0.3, 0.2, 0.4, 0.0, 0.1, 0.5, 0.0, 0.5, 0.0, 0.0, 0.0, 0.6666666666666666, 0.3333333333333333, 1.0, 0.0, 0.0, 0.9850746268656716, 0.014925373134328358, 0.0, 1.0, 0.022727272727272728, 0.06818181818181818, 0.9090909090909091, 0.25862068965517243, 0.017241379310344827, 0.7241379310344828, 0.7586206896551724, 0.0, 0.13793103448275862, 1.0, 1.0, 0.0, 0.05555555555555555, 0.9444444444444444, 0.043478260869565216, 0.9130434782608695, 0.043478260869565216, 0.06666666666666667, 0.9333333333333333, 0.06666666666666667, 0.9333333333333333, 0.05, 0.95, 1.0, 0.0, 0.08333333333333333, 0.9166666666666666, 0.0, 0.058823529411764705, 0.9411764705882353, 0.0, 0.06666666666666667, 0.9333333333333333, 0.07692307692307693, 0.9230769230769231, 1.0, 0.1111111111111111, 0.8888888888888888, 0.3333333333333333, 0.6666666666666666, 1.0, 0.0, 1.0, 0.058823529411764705, 0.14705882352941177, 0.029411764705882353, 0.38235294117647056, 0.38235294117647056, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.9787234042553191, 0.02127659574468085, 1.0, 0.0, 0.0, 0.0967741935483871, 0.9032258064516129, 0.0, 0.0, 1.0, 0.05555555555555555, 0.05555555555555555, 0.8888888888888888, 0.0, 0.0]" -"('Te', -2)","[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.125, 0.125, 0.75, 0.25, 0.5, 0.25, 0.5, 0.25, 0.25, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.8823529411764706, 0.11764705882352941, 0.0, 0.0, 0.0, 0.0, 0.0, 0.75, 0.25, 0.0, 0.0, 0.8333333333333334, 0.0, 0.16666666666666666, 0.0, 0.8571428571428571, 0.14285714285714285, 0.0, 0.6764705882352942, 0.3235294117647059, 0.0, 1.0, 0.0, 0.1111111111111111, 0.8888888888888888, 0.7333333333333333, 0.06666666666666667, 0.2, 1.0, 1.0, 0.0, 0.0, 1.0, 0.09090909090909091, 0.36363636363636365, 0.09090909090909091, 0.45454545454545453, 0.0, 0.25, 0.3333333333333333, 0.25, 0.16666666666666666, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.045454545454545456, 0.09090909090909091, 0.8636363636363636, 0.36363636363636365, 0.0, 0.6363636363636364, 0.5263157894736842, 0.0, 0.0, 1.0, 1.0, 0.0, 0.16666666666666666, 0.8333333333333334, 0.2, 0.8, 0.0, 0.2857142857142857, 0.7142857142857143, 0.14285714285714285, 0.8571428571428571, 0.16666666666666666, 0.8333333333333334, 1.0, 0.0, 0.5, 0.5, 0.0, 0.2, 0.8, 0.0, 0.16666666666666666, 0.8333333333333334, 0.16666666666666666, 0.8333333333333334, 1.0, 0.3333333333333333, 0.6666666666666666, 1.0, 0.0, 1.0, 0.0, 1.0, 0.11764705882352941, 0.29411764705882354, 0.17647058823529413, 0.11764705882352941, 0.29411764705882354, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.08333333333333333, 0.9166666666666666, 0.0, 0.0, 1.0, 0.1111111111111111, 0.1111111111111111, 0.7777777777777778, 0.0, 0.0]" diff --git a/smact/data/oxidation_states/species_list.txt b/smact/data/oxidation_states/species_list.txt deleted file mode 100644 index 8fd5ac03..00000000 --- a/smact/data/oxidation_states/species_list.txt +++ /dev/null @@ -1 +0,0 @@ -[('Li', 1.0), ('Be', 2.0), ('Na', 1.0), ('Mg', 2.0), ('Al', 3.0), ('K', 1.0), ('Ca', 2.0), ('Sc', 1.0), ('Sc', 2.0), ('Sc', 3.0), ('Ti', 2.0), ('Ti', 3.0), ('Ti', 4.0), ('V', 2.0), ('V', 3.0), ('V', 4.0), ('V', 5.0), ('Cr', 2.0), ('Cr', 3.0), ('Cr', 4.0), ('Cr', 5.0), ('Cr', 6.0), ('Mn', 1.0), ('Mn', 2.0), ('Mn', 3.0), ('Mn', 4.0), ('Mn', 5.0), ('Mn', 6.0), ('Mn', 7.0), ('Fe', 1.0), ('Fe', 2.0), ('Fe', 3.0), ('Fe', 4.0), ('Co', 1.0), ('Co', 2.0), ('Co', 3.0), ('Co', 4.0), ('Ni', 1.0), ('Ni', 2.0), ('Ni', 3.0), ('Ni', 4.0), ('Cu', 1.0), ('Cu', 2.0), ('Cu', 3.0), ('Zn', 2.0), ('Ga', 1.0), ('Ga', 2.0), ('Ga', 3.0), ('Ge', 2.0), ('Ge', 3.0), ('Ge', 4.0), ('Rb', 1.0), ('Sr', 2.0), ('Y', 1.0), ('Y', 2.0), ('Y', 3.0), ('Zr', 1.0), ('Zr', 2.0), ('Zr', 3.0), ('Zr', 4.0), ('Nb', 1.0), ('Nb', 2.0), ('Nb', 3.0), ('Nb', 4.0), ('Nb', 5.0), ('Mo', 2.0), ('Mo', 3.0), ('Mo', 4.0), ('Mo', 5.0), ('Mo', 6.0), ('Ru', 2.0), ('Ru', 3.0), ('Ru', 4.0), ('Ru', 5.0), ('Ru', 6.0), ('Rh', 1.0), ('Rh', 3.0), ('Rh', 4.0), ('Pd', 2.0), ('Pd', 3.0), ('Pd', 4.0), ('Ag', 1.0), ('Ag', 2.0), ('Ag', 3.0), ('Cd', 2.0), ('In', 1.0), ('In', 2.0), ('In', 3.0), ('Sn', 2.0), ('Sn', 3.0), ('Sn', 4.0), ('Sb', 3.0), ('Sb', 4.0), ('Sb', 5.0), ('Cs', 1.0), ('Ba', 2.0), ('La', 1.0), ('La', 2.0), ('La', 3.0), ('Ce', 2.0), ('Ce', 3.0), ('Ce', 4.0), ('Pr', 2.0), ('Pr', 3.0), ('Nd', 2.0), ('Nd', 3.0), ('Sm', 2.0), ('Sm', 3.0), ('Eu', 2.0), ('Eu', 3.0), ('Gd', 2.0), ('Gd', 3.0), ('Tb', 1.0), ('Tb', 2.0), ('Tb', 3.0), ('Tb', 4.0), ('Dy', 2.0), ('Dy', 3.0), ('Ho', 2.0), ('Ho', 3.0), ('Er', 3.0), ('Tm', 2.0), ('Tm', 3.0), ('Yb', 2.0), ('Yb', 3.0), ('Lu', 3.0), ('Hf', 2.0), ('Hf', 4.0), ('Ta', 1.0), ('Ta', 2.0), ('Ta', 3.0), ('Ta', 4.0), ('Ta', 5.0), ('W', 2.0), ('W', 3.0), ('W', 4.0), ('W', 5.0), ('W', 6.0), ('Re', 2.0), ('Re', 3.0), ('Re', 4.0), ('Re', 5.0), ('Re', 6.0), ('Re', 7.0), ('Ir', 3.0), ('Ir', 4.0), ('Ir', 5.0), ('Ir', 6.0), ('Hg', 1.0), ('Hg', 2.0), ('Tl', 1.0), ('Tl', 3.0), ('Pb', 2.0), ('Pb', 4.0), ('Bi', 1.0), ('Bi', 2.0), ('Bi', 3.0), ('Bi', 5.0), ('Th', 3.0), ('Th', 4.0), ('U', 2.0), ('U', 3.0), ('U', 4.0), ('U', 5.0), ('U', 6.0)] \ No newline at end of file From b63a979938a69af49b1890e9da312e8321714725 Mon Sep 17 00:00:00 2001 From: Aron Walsh Date: Wed, 22 Nov 2023 20:35:12 +0000 Subject: [PATCH 34/56] Doctoring the docs Very minor edits --- docs/conf.py | 4 +-- docs/examples.rst | 34 +++++++++---------- docs/getting_started.rst | 2 +- docs/introduction.rst | 14 ++++---- docs/smact.builder.rst | 2 +- docs/smact.dopant_prediction.doper.rst | 3 +- docs/smact.properties.rst | 11 +++--- docs/smact.rst | 2 +- ...tructure_prediction.probability_models.rst | 2 +- 9 files changed, 37 insertions(+), 37 deletions(-) diff --git a/docs/conf.py b/docs/conf.py index 689c691c..fa1cdb7b 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -52,8 +52,8 @@ # General information about the project. project = "Smact" -copyright = "2016, Walsh Materials Design Group" -author = "Walsh Materials Design Group" +copyright = "2016, Materials Design Group" +author = "Materials Design Group" # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the diff --git a/docs/examples.rst b/docs/examples.rst index 86fe445a..9e002273 100644 --- a/docs/examples.rst +++ b/docs/examples.rst @@ -2,8 +2,8 @@ Examples ======== -Here we will give a demonstration of how to use some of `smact`'s features. For a full set of -work-through examples in Jupyter notebook form check out +Here we will give a demonstration of how to use some `smact` features. For a full set of +work-through examples in Jupyter Notebook form check out `the examples section of our GitHub repo `_. For workflows that have been used in real examples and in published work, visit our `separate repository `_. @@ -12,7 +12,7 @@ For workflows that have been used in real examples and in published work, visit Element and species classes =========================== -The element and species classes are at the heart of :mod:`smact`'s functionality. Elements are the +The element and species classes are at the heart of :mod:`smact` functionality. Elements are the elements of the periodic table. Species are elements, with some additional information; the oxidation state and the coordination environment (if known). So for example the element iron can have many oxidation states and those oxidation states can have many coordination @@ -29,7 +29,7 @@ environments. The element Fe has 8 oxidation states. They are [-2, -1, 1, 2, 3, 4, 5, 6]. When an element has an oxidation state and coordination environment then it has additional -features. For example the Shannon radius [1]_ of the element, this is often useful for calculating +features. For example, the Shannon radius [1]_ of the element is useful for calculating radius ratio rules [2]_, or for training neural networks [3]_ . .. code:: python @@ -43,7 +43,7 @@ radius ratio rules [2]_, or for training neural networks [3]_ . List building ============= -Often when using :mod:`smact` the aim will to be to search over combinations of a set of elements. This +Often when using :mod:`smact` the aim will be to search over combinations of a set of elements. This is most efficiently achieved by setting up a dictionary of the elements that you want to search over. The easiest way to achieve this in :mod:`smact` is to first create a list of the symbols of the elements that you want to include, then to build a dictionary of the corresponding element objects. @@ -88,7 +88,7 @@ the search. Neutral combinations ==================== -One of the most basic tests for establishing sensible combinations of elements is that they should form charge neutral +One of the most basic tests for establishing sensible combinations of elements is that they should form charge-neutral combinations. This is a straightforward combinatorial problem of comparing oxidation states and allowed stoichiometries. :math:`\Sigma_i Q_in_i = 0` @@ -211,14 +211,14 @@ in function to calculate this property for a given composition. Interfacing to machine learning =============================== -When preparing to do machine learning, we have to convert the compositions that we have into +When preparing to build machine learning models, we have to convert the chemical compositions into something that can be fed into an algorithm. Many of the properties provided in :mod:`smact` are suitable for this, -one can take properties like electronegativity, mass, electron affinity etc etc (for the full list see +one can take properties like electronegativity, mass, electron affinity, etc. (for the full list see :ref:`smact_module`). -One useful representation that is often used in machine learning is the one-hot-vector formulation. A similar -construction to this can be used to encode a chemical formula. A vector of length of the periodic table is -set up and each element set to be a number corresponding to the stoichiometric ratio of that element in the compound. +One useful representation in machine learning is the one-hot-vector formulation. A similar +construction to this can be used to encode a chemical formula. A vector of length covering the periodic table is +constructed and each element is set to a number corresponding to the stoichiometric ratio of that element in the compound. For example we could convert :math:`Ba(OH)_2` .. code:: python @@ -226,17 +226,15 @@ For example we could convert :math:`Ba(OH)_2` ml_vector = smact.screening.ml_rep_generator(['Ba', 'H', 'O'], stoichs=[1, 2, 2]) There is also `an example `_ -demonstrating the conversion of charge neutral compositions produced by `smact` to a list of formulas using Pymatgen, +demonstrating the conversion of charge-neutral compositions produced by `smact` to a list of formulas using Pymatgen, or to a Pandas dataframe, both of which could then be used as input for a machine learning algorithm. For a full machine learning example that uses `smact`, there is a repository `here `_ which demonstrates a search for solar energy materials from the four-component (quaternary) oxide materials space. -.. [1] "Revised effective ionic radii and systematic studies of interatomic distances in halides and chalcogenides". - Acta Crystallogr A. 32: 751–767, 1976 +.. [1] "Revised effective ionic radii and systematic studies of interatomic distances in halides and chalcogenides" Acta Cryst. A. **32**, 751–767 (1976). -.. [2] "Crystal Structure and Chemical Constitution" Trans. Faraday Soc. 25, 253-283, 1929. +.. [2] "Crystal structure and chemical constitution" Trans. Faraday Soc. **25**, 253-283 (1929). -.. [3] "Deep neural networks for accurate predictions of crystal stability" Nat. Comms. 9, 3800, 2018. +.. [3] "Deep neural networks for accurate predictions of crystal stability" Nat. Comms. **9**, 3800 (2018). -.. [4] "Prediction of Flatband Potentials at Semiconductor‐Electrolyte Interfaces from Atomic Electronegativities" - J. Electrochem. Soc. 125, 228-32, 1975. +.. [4] "Prediction of flatband potentials at semiconductor‐electrolyte interfaces from atomic electronegativities" J. Electrochem. Soc. **125**, 228-232 (1975). diff --git a/docs/getting_started.rst b/docs/getting_started.rst index a584b499..bb2249b6 100644 --- a/docs/getting_started.rst +++ b/docs/getting_started.rst @@ -15,7 +15,7 @@ and `pymatgen `_ are also required for many components. Installation ============ -The latest stable release of SMACT can be installed via pip which will automatically setup other Python packages as required: +The latest stable release of SMACT can be installed via pip, which will automatically setup other Python packages as required: .. code:: diff --git a/docs/introduction.rst b/docs/introduction.rst index b0c4b610..16453c5c 100644 --- a/docs/introduction.rst +++ b/docs/introduction.rst @@ -3,7 +3,7 @@ Introduction ============ :mod:`smact` is a collection of tools and examples for "low-fi" screening of -potential semiconducting materials through the use of simple chemical +potential semiconducting materials through the use of chemical rules. :mod:`smact` uses a combination of heuristics and models derived from data to @@ -11,17 +11,17 @@ rapidly search large areas of chemical space. This combination of methods allows :mod:`smact` to identify new materials for applications such as photovoltaics, water splitting and thermoelectrics. Read more about :mod:`smact` in our publications: -- `Computational Screening of All Stoichiometric Inorganic Materials `_ +- `Computational screening of all stoichiometric inorganic materials `_ - `Computer-aided design of metal chalcohalide semiconductors: from chemical composition to crystal structure `_ - `Materials discovery by chemical analogy: role of oxidation states in structure prediction `_ -This approach is heavily inspired by the work of Harrison [1]_ and -Pamplin [2]_. The work is an active project in the `Walsh Materials Design Group `_. +This approach is inspired by the work of Harrison [1]_ and +Pamplin [2]_. The work is an active project in the `Materials Design Group `_. -SMACT is now available *via* :code:`pip install smact`. +The package is available *via* :code:`pip install smact`. -We are also developing a set of Jupyter notebook examples `here `_. +We are also developing a set of Jupyter Notebook examples `here `_. .. [1] http://www.worldcat.org/oclc/5170450 Harrison, W. A. *Electronic structure and the properties of solids: the physics of the chemical bond* (1980) -.. [2] http://dx.doi.org/10.1016/0022-3697(64)90176-3 Pamplin, B. R. *J. Phys. Chem. Solids* (1964) **7** 675--684 +.. [2] http://dx.doi.org/10.1016/0022-3697(64)90176-3 Pamplin, B. R. *A systematic method of deriving new semiconducting compounds by structural analogy* J. Phys. Chem. Solids **7**, 675--684 (1964) diff --git a/docs/smact.builder.rst b/docs/smact.builder.rst index bcb38122..1a4099d3 100644 --- a/docs/smact.builder.rst +++ b/docs/smact.builder.rst @@ -2,7 +2,7 @@ smact.builder module ==================== A collection of functions for building certain lattice types. -Currently there are examples here for the Perovskite and Wurzite lattice types, +Currently, there are examples here for the perovskite and wurtzite structure types, which rely on the Atomic Simulation Environment (ASE) :func:`spacegroup.crystal` function. diff --git a/docs/smact.dopant_prediction.doper.rst b/docs/smact.dopant_prediction.doper.rst index 83b826a6..28e0ad8c 100644 --- a/docs/smact.dopant_prediction.doper.rst +++ b/docs/smact.dopant_prediction.doper.rst @@ -1,7 +1,8 @@ smact.dopant_prediction.doper module ============================= -A class to create possible n-type and p-type dopants +A class to create possible n-type and p-type dopants according to +their accessible oxidation states. .. automodule:: smact.dopant_prediction.doper :members: diff --git a/docs/smact.properties.rst b/docs/smact.properties.rst index 599f338b..43136104 100644 --- a/docs/smact.properties.rst +++ b/docs/smact.properties.rst @@ -1,7 +1,8 @@ smact.properties module ======================= -A collection of tools for estimating useful properties. +A collection of tools for estimating physical properties +based on chemical composition. The "electronegativity of a compound" computed with :func:`compound_electroneg` is the rescaled geometric mean of @@ -12,15 +13,15 @@ photoelectric threshold: [1]_ In other words, the computed group :math:`2.86(\chi_{A}\chi_{B})^{1/2}` -is the mid-gap energy and the VBM/CBM positions can be estimated by -subtracting/adding half of the band gap :math:`E_g`. +is the mid-gap energy. The valence band maximum/conduction band minimum positions +can be estimated by subtracting/adding half of the band gap :math:`E_g`. This is an extension Mulliken's electronegativity scale in which :math:`\chi_{A} = (I_{A} + E_{A})/2` (where :math:`I` and :math:`E` are respectively the ionisation potential and electron affinity.) [2]_ -.. [1] Nethercot, A. H. (1974). *Phys. Rev. Lett.*, **33**, 1088–1091. http://dx.doi.org/10.1103/PhysRevLett.33.1088 +.. [1] Nethercot, A. H., *Prediction of Fermi energies and photoelectric thresholds based on electronegativity concepts* Phys. Rev. Lett. **33**, 1088–1091 (1974). http://dx.doi.org/10.1103/PhysRevLett.33.1088 -.. [2] Mulliken, R. S. (1934). *J. Chem. Phys.*, **2**, 782. http://dx.doi.org/10.1063/1.1749394 +.. [2] Mulliken, R. S., *A new electroaffinity scale; together with data on valence states and on valence ionization potentials and electron affinities* J. Chem. Phys. **2**, 782 (1934). http://dx.doi.org/10.1063/1.1749394 .. automodule:: smact.properties :members: diff --git a/docs/smact.rst b/docs/smact.rst index d28c41b5..215effd8 100644 --- a/docs/smact.rst +++ b/docs/smact.rst @@ -11,7 +11,7 @@ which returns a dictionary of :class:`smact.Element` objects indexed by their chemical symbols. Generating this dictionary once and then performing lookups is generally the fastest way of accessing element data while enumerating -possibilities. +possibilities in chemical space. .. automodule:: smact :members: diff --git a/docs/smact.structure_prediction.probability_models.rst b/docs/smact.structure_prediction.probability_models.rst index 7a98139d..1a9dfe3d 100644 --- a/docs/smact.structure_prediction.probability_models.rst +++ b/docs/smact.structure_prediction.probability_models.rst @@ -2,7 +2,7 @@ Substitution Probability Models =============================== Minimal API for developing substitution likelihood probability models -for ion mutation. +for species mutation. .. automodule:: smact.structure_prediction.probability_models :members: From 74c0599027d843886ef5c1b33b7f8c3bc4b582ea Mon Sep 17 00:00:00 2001 From: AntObi Date: Thu, 30 Nov 2023 12:26:08 -0500 Subject: [PATCH 35/56] Add .github/release.yml --- .github/release.yml | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 .github/release.yml diff --git a/.github/release.yml b/.github/release.yml new file mode 100644 index 00000000..3c3a8a8e --- /dev/null +++ b/.github/release.yml @@ -0,0 +1,28 @@ +changelog: + exclude: + authors: [dependabot, github-actions, pre-commit-ci] + categories: + - title: 🎉 New Features + labels: [feature] + - title: 🐛 Bug Fixes + labels: [fix] + - title: 🛠 Enhancements + labels: [enhancement, DX, UX] + - title: 📖 Documentation + labels: [docs] + - title: 🧹 House-Keeping + labels: [housekeeping] + - title: 🚀 Performance + labels: [performance] + - title: 💡 Refactoring + labels: [refactor] + - title: 🧪 Tests + labels: [tests] + - title: 💥 Breaking Changes + labels: [breaking] + - title: 🔒 Security Fixes + labels: [security] + - title: 🏥 Package Health + labels: [pkg] + - title: 🤷‍♂️ Other Changes + labels: ["*"] \ No newline at end of file From 11f05a81e3f5242f7889eb741091a4d7b82b30e2 Mon Sep 17 00:00:00 2001 From: AntObi Date: Thu, 30 Nov 2023 12:26:26 -0500 Subject: [PATCH 36/56] Update version number --- setup.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/setup.py b/setup.py index 2cc88833..f0778ecf 100644 --- a/setup.py +++ b/setup.py @@ -5,10 +5,10 @@ __copyright__ = ( "Copyright Daniel W. Davies, Adam J. Jackson, Keith T. Butler (2019)" ) -__version__ = "2.5.3" +__version__ = "2.5.4" __maintainer__ = "Anthony O. Onwuli" __maintaier_email__ = "anthony.onwuli16@imperial.ac.uk" -__date__ = "August 23 2023" +__date__ = "November 30 2023" import os import unittest From 19ccbe4e3485e1091a8409e121aa7a6a1e0928b1 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Fri, 1 Dec 2023 17:06:50 +0000 Subject: [PATCH 37/56] Bump actions/github-script from 6 to 7 Bumps [actions/github-script](https://github.com/actions/github-script) from 6 to 7. - [Release notes](https://github.com/actions/github-script/releases) - [Commits](https://github.com/actions/github-script/compare/v6...v7) --- updated-dependencies: - dependency-name: actions/github-script dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] --- .github/workflows/combine-prs.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/combine-prs.yml b/.github/workflows/combine-prs.yml index 2a9998f3..635e50f2 100644 --- a/.github/workflows/combine-prs.yml +++ b/.github/workflows/combine-prs.yml @@ -30,7 +30,7 @@ jobs: # Steps represent a sequence of tasks that will be executed as part of the job steps: - - uses: actions/github-script@v6 + - uses: actions/github-script@v7 id: create-combined-pr name: Create Combined PR with: From 93f71861e92e82ff97abfa1c0f7169de1cfa66f0 Mon Sep 17 00:00:00 2001 From: Anthony Onwuli <30937913+AntObi@users.noreply.github.com> Date: Fri, 1 Dec 2023 12:18:53 -0500 Subject: [PATCH 38/56] Update ci.yml Test relaxed project requirement --- .github/workflows/ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 0fc93a4c..23aa4321 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -32,7 +32,7 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip wheel setuptools - pip install -r requirements.txt + pip install -e . pip install pytest-cov - name: Run tests and collect coverage run: python -m pytest --cov=smact --cov-report=xml -v From 6443f10b64bd75d7c399f2e7252358048c6b5567 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Sat, 2 Dec 2023 02:12:44 +0000 Subject: [PATCH 39/56] Bump mp-api from 0.34.3 to 0.37.1 Bumps [mp-api]() from 0.34.3 to 0.37.1. --- updated-dependencies: - dependency-name: mp-api dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index cf419b80..f7d4b86c 100644 --- a/requirements.txt +++ b/requirements.txt @@ -42,7 +42,7 @@ monty==2023.8.8 # emmet-core # mp-api # pymatgen -mp-api==0.34.3 +mp-api==0.35.1 # via pymatgen mpmath==1.3.0 # via sympy From c231de48dfb22e7cf03410758e2574fa05b16b59 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Sat, 2 Dec 2023 02:13:02 +0000 Subject: [PATCH 40/56] Bump pyparsing from 3.0.9 to 3.1.1 Bumps [pyparsing](https://github.com/pyparsing/pyparsing) from 3.0.9 to 3.1.1. - [Release notes](https://github.com/pyparsing/pyparsing/releases) - [Changelog](https://github.com/pyparsing/pyparsing/blob/master/CHANGES) - [Commits](https://github.com/pyparsing/pyparsing/compare/pyparsing_3.0.9...3.1.1) --- updated-dependencies: - dependency-name: pyparsing dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index cf419b80..8bc64fdd 100644 --- a/requirements.txt +++ b/requirements.txt @@ -95,7 +95,7 @@ pymatgen==2023.7.20 # SMACT (setup.py) # emmet-core # mp-api -pyparsing==3.0.9 +pyparsing==3.1.1 # via matplotlib python-dateutil==2.8.2 # via From 03304bcb31682efdb69189148f69903f1d28cc1a Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Sat, 2 Dec 2023 02:21:05 +0000 Subject: [PATCH 41/56] Bump pydantic from 1.10.12 to 2.5.2 Bumps [pydantic](https://github.com/pydantic/pydantic) from 1.10.12 to 2.5.2. - [Release notes](https://github.com/pydantic/pydantic/releases) - [Changelog](https://github.com/pydantic/pydantic/blob/v2.5.2/HISTORY.md) - [Commits](https://github.com/pydantic/pydantic/compare/v1.10.12...v2.5.2) --- updated-dependencies: - dependency-name: pydantic dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index cf419b80..1412d5ee 100644 --- a/requirements.txt +++ b/requirements.txt @@ -86,7 +86,7 @@ pybtex==0.24.0 # via # emmet-core # pymatgen -pydantic==1.10.12 +pydantic==2.5.2 # via # emmet-core # pymatgen From d068dfdef7af6b2b465b554b0b2a1872c72a91f4 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 4 Dec 2023 11:19:56 +0000 Subject: [PATCH 42/56] Bump numpy from 1.24.3 to 1.24.4 Bumps [numpy](https://github.com/numpy/numpy) from 1.24.3 to 1.24.4. - [Release notes](https://github.com/numpy/numpy/releases) - [Changelog](https://github.com/numpy/numpy/blob/main/doc/RELEASE_WALKTHROUGH.rst) - [Commits](https://github.com/numpy/numpy/compare/v1.24.3...v1.24.4) --- updated-dependencies: - dependency-name: numpy dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index c4eef325..fa74d35c 100644 --- a/requirements.txt +++ b/requirements.txt @@ -52,7 +52,7 @@ multiprocess==0.70.15 # via pathos networkx==3.1 # via pymatgen -numpy==1.24.3 +numpy==1.24.4 # via # SMACT (setup.py) # ase From 6ccfba3305d6d627c3037d038a444c7541426a80 Mon Sep 17 00:00:00 2001 From: hspark1212 Date: Wed, 6 Dec 2023 09:20:23 +0000 Subject: [PATCH 43/56] crystal_space --- examples/Crystal_Space/0_screening.ipynb | 210 +++++++++ examples/Crystal_Space/1_reduction.ipynb | 402 ++++++++++++++++++ .../download_compounds_with_mp_api.py | 96 +++++ .../generate_composition_with_smact.py | 143 +++++++ examples/Crystal_Space/plot_embedding.py | 156 +++++++ 5 files changed, 1007 insertions(+) create mode 100644 examples/Crystal_Space/0_screening.ipynb create mode 100644 examples/Crystal_Space/1_reduction.ipynb create mode 100644 examples/Crystal_Space/download_compounds_with_mp_api.py create mode 100644 examples/Crystal_Space/generate_composition_with_smact.py create mode 100644 examples/Crystal_Space/plot_embedding.py diff --git a/examples/Crystal_Space/0_screening.ipynb b/examples/Crystal_Space/0_screening.ipynb new file mode 100644 index 00000000..92d9725b --- /dev/null +++ b/examples/Crystal_Space/0_screening.ipynb @@ -0,0 +1,210 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exploring Chemical Space with SMACT and Materials Project Database" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this notebook, we undertake a comprehensive exploration of binary chemical compositions. This approach can also be extended to explore ternary and quaternary compositions. Our methodology involves two primary tools: the SMACT filter for generating compositions and the Materials Project database for additional data acquisition. \n", + "\n", + "The final phase will categorize the compositions into four distinct categories based on their properties. The categorization is based on whether a composition is allowed by the SMACT filter (smact_allowed) and whether it is present in the Materials Project database (mp). The categories are as follows:\n", + "\n", + "| smact_allowed | mp | label |\n", + "|---------------|------|------------|\n", + "| yes | yes | standard |\n", + "| yes | no | missing |\n", + "| no | yes | interesting|\n", + "| no | no | unlikely |" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Generate compositions with the SMACT filter" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We begin by generating binary compositions using the SMACT filter. The SMACT filter serves as a chemical filter including oxidation states and electronegativity test.\n", + "\n", + "[`generate_composition_with_smact`](./generate_composition_with_smact.py) function generates a composition with the SMACT filter. The function takes in the following parameters:\n", + "\n", + "num_elements: number of elements in the composition\n", + "\n", + "max_stoich: maximum stoichiometry of each element\n", + "\n", + "max_atomic_num: maximum atomic number of each element\n", + "\n", + "num_processes: number of processes to run in parallel\n", + "\n", + "save_path: path to save the dataframe containing the compositions with the SMACT filter" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from generate_composition_with_smact import generate_composition_with_smact" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df_smact = generate_composition_with_smact(\n", + " num_elements=2,\n", + " max_stoich=8,\n", + " max_atomic_num=103,\n", + " num_processes=8,\n", + " save_path=\"data/binary/df_binary_label.pkl\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 2. Download data from the Materials Project database" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we download data from the Materials Project database using the `MPRester` class from the [`pymatgen`](https://pymatgen.org/) library. \n", + "\n", + "[`download_mp_data`](./download_compounds_with_mp_api.py) function takes in the following parameters:\n", + "\n", + "mp_api_key: Materials Project API key\n", + "\n", + "num_elements: number of elements in the composition\n", + "\n", + "max_stoich: maximum stoichiometry of each element\n", + "\n", + "save_dir: path to save the downloaded data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mp_api_key = None # replace with your own MP API key" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from download_compounds_with_mp_api import download_mp_data\n", + "\n", + "# download data from MP for binary compounds\n", + "save_mp_dir = \"data/binary/mp_data\"\n", + "docs = download_mp_data(\n", + " mp_api_key=mp_api_key,\n", + " num_elements=2,\n", + " max_stoich=8,\n", + " save_dir=save_mp_dir,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Categorize compositions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we categorize the compositions into four lables: standard, missing, interesting, and unlikely." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "import pandas as pd" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mp_data = {p.stem: True for p in Path(save_mp_dir).glob(\"*.json\")}\n", + "df_mp = pd.DataFrame.from_dict(mp_data, orient=\"index\", columns=[\"mp\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# make category dataframe\n", + "df_category = df_smact.join(df_mp, how=\"left\").fillna(False)\n", + "# make label for each category\n", + "dict_label = {\n", + " (True, True): \"standard\",\n", + " (True, False): \"missing\",\n", + " (False, True): \"interesting\",\n", + " (False, False): \"unlikely\",\n", + "}\n", + "df_category[\"label\"] = df_category.apply(\n", + " lambda x: dict_label[(x[\"smact_allowed\"], x[\"mp\"])], axis=1\n", + ")\n", + "df_category[\"label\"].apply(dict_label.get)\n", + "\n", + "# count number of each label\n", + "print(df_category[\"label\"].value_counts())\n", + "\n", + "# save dataframe\n", + "df_category.to_pickle(\"data/binary/df_binary_category.pkl\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "smact", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.18" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/Crystal_Space/1_reduction.ipynb b/examples/Crystal_Space/1_reduction.ipynb new file mode 100644 index 00000000..e4a3c14e --- /dev/null +++ b/examples/Crystal_Space/1_reduction.ipynb @@ -0,0 +1,402 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Dimension Reduction" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this notebook, we will use the dimension reduction techniques to reduce the dimension of the data. We will use the following techniques:\n", + "\n", + "- Principal Component Analysis (PCA)\n", + "- t-distributed Stochastic Neighbor Embedding (t-SNE)\n", + "- Uniform Manifold Approximation and Projection (UMAP)\n", + "\n", + "we will make composional embedding created by element embeddings, as follows:\n", + "\n", + "(Please refer to [ElementEmbeddings](https://wmd-group.github.io/ElementEmbeddings/0.4/reference/) for the details of element embedding)\n", + "\n", + "- Magpie\n", + "- Mat2Vec\n", + "- Megnet16\n", + "- Skipatom\n", + "- Oliynyk\n", + "- random_200" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Element Embeddings" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To begin, we will make compositional embedding created by element embeddings using the ElementEmbeddings package." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# pip install ElementEmbeddings" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Iterable\n", + "from pathlib import Path\n", + "\n", + "from tqdm import tqdm\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "from elementembeddings.composition import CompositionalEmbedding" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "embedding_names = [\n", + " \"magpie\",\n", + " \"mat2vec\",\n", + " \"megnet16\",\n", + " \"skipatom\",\n", + " \"oliynyk\",\n", + " \"random_200\",\n", + "]\n", + "\n", + "reducers = [\"pca\", \"tsne\", \"umap\"]\n", + "\n", + "# set save directory\n", + "save_dir = Path(\"data/binary/\")\n", + "save_dir.mkdir(parents=True, exist_ok=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df_category = pd.read_pickle(save_dir / \"df_binary_category.pkl\")\n", + "df_category" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# sampling\n", + "n_samples = 3000\n", + "\n", + "dict_label = {\n", + " \"standard\": 0,\n", + " \"missing\": 1,\n", + " \"interesting\": 2,\n", + " \"unlikely\": 3,\n", + "}\n", + "labels = [\"standard\", \"missing\", \"interesting\", \"unlikely\"]\n", + "list_df_sample = []\n", + "for label in labels:\n", + " m = df_category[\"label\"] == label\n", + " df = df_category[m].sample(\n", + " n=min(n_samples, len(df_category[m])),\n", + " random_state=42,\n", + " )\n", + " list_df_sample.append(df)\n", + "df_sample = pd.concat(list_df_sample)\n", + "# save sampled data\n", + "df_sample.to_pickle(save_dir / \"df_binary_sample.pkl\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def get_embedding(formula, embedding=\"magpie\", stats=\"mean\"):\n", + " \"\"\"\n", + " Computes a compositional embedding for a given chemical formula or a list of chemical formulas.\n", + "\n", + " Parameters:\n", + " -----------\n", + " formula : str or iterable\n", + "\n", + " embedding : str, optional\n", + " The type of embedding to compute. Must be one of ['magpie', 'mat2vec', 'megnet16', 'skipatom', 'oliynyk', 'random_200'].\n", + " Default is 'magpie'.\n", + " stats : str, optional\n", + " The type of statistics to compute for the embedding. Must be one of\n", + " [\"mean\", \"variance\", \"minpool\", \"maxpool\", \"range\", \"sum\", \"geometric_mean\", \"harmonic_mean\"].\n", + " Default is 'mean'.\n", + " Returns:\n", + " --------\n", + " numpy.ndarray\n", + " 1D array when formula is a string, 2D array when formula is a list of strings.\n", + " \"\"\"\n", + " if isinstance(formula, str):\n", + " formula = [formula]\n", + " elif isinstance(formula, Iterable):\n", + " pass\n", + " else:\n", + " raise TypeError(\"formula must be a string or a list of strings\")\n", + "\n", + " # get embedding dimension\n", + " embedding_dim = CompositionalEmbedding(\n", + " \"\", embedding=embedding\n", + " ).embedding_dim\n", + "\n", + " # compute embedding\n", + " embeddings = []\n", + " for f in tqdm(formula):\n", + " try:\n", + " compositional_embedding = CompositionalEmbedding(\n", + " f, embedding=embedding\n", + " )\n", + " embeddings.append(\n", + " compositional_embedding.feature_vector(stats=stats)\n", + " )\n", + " except Exception as e:\n", + " # the exception is raised when the embedding doesn't support the element\n", + " embeddings.append(np.full(embedding_dim, np.nan))\n", + "\n", + " # concatenate the embedded vectors\n", + " embeddings = np.stack(embeddings, axis=0).squeeze()\n", + " return embeddings" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# make the directory to save the embeddings\n", + "(save_dir / \"embeddings\").mkdir(parents=True, exist_ok=True)\n", + "# save the embeddings\n", + "for name in embedding_names:\n", + " print(f\"Computing {name} embeddings\")\n", + " embeddings = get_embedding(df_sample.index, embedding=name)\n", + " df_embeddings = pd.DataFrame(embeddings, index=df_sample.index)\n", + " df_embeddings = df_embeddings.dropna(axis=0)\n", + " df_embeddings.to_pickle(save_dir / \"embeddings\" / f\"embeddings_{name}.pkl\")\n", + " print(\n", + " f\"Saved {name} embeddings with shape {df_embeddings.shape} to {save_dir / 'embeddings' / f'embeddings_{name}.pkl'}\"\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Dimension Reduction" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we will use the dimension reduction techniques to reduce the dimension of the data." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# pip install umap-learn==0.5.3" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.decomposition import PCA\n", + "from sklearn.manifold import TSNE\n", + "from umap import UMAP" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def dimension_reduction(\n", + " embeddings,\n", + " reducer=\"pca\",\n", + " n_components=2,\n", + " save_dir=None,\n", + " file_name=None,\n", + " **kwargs,\n", + "):\n", + " \"\"\"\n", + " Performs dimensionality reduction on the given embeddings.\n", + "\n", + " Parameters:\n", + " -----------\n", + " embeddings : pandas.DataFrame\n", + " The embeddings to reduce.\n", + " reducer : str, optional\n", + " The dimensionality reduction algorithm to use. Must be one of ['pca', 'tsne', 'umap'].\n", + " Default is 'pca'.\n", + " n_components : int, optional\n", + " The number of components to reduce to. Default is 2.\n", + " save_dir : str, optional\n", + " The directory to save the reduced embeddings. Default is None.\n", + " file_name : str, optional\n", + " The file name to save the reduced embeddings. Default is None.\n", + " **kwargs : dict, optional\n", + "\n", + " Returns:\n", + " --------\n", + " numpy.ndarray\n", + " The reduced embeddings.\n", + " \"\"\"\n", + " if reducer == \"pca\":\n", + " reducer = PCA(n_components=n_components, **kwargs)\n", + " elif reducer == \"tsne\":\n", + " reducer = TSNE(n_components=n_components, **kwargs)\n", + " elif reducer == \"umap\":\n", + " reducer = UMAP(n_components=n_components, **kwargs)\n", + " else:\n", + " raise ValueError(\"reducer must be one of ['pca', 'tsne', 'umap']\")\n", + "\n", + " reduced_embeddings = reducer.fit_transform(embeddings.values)\n", + "\n", + " if save_dir is not None:\n", + " save_dir = Path(save_dir)\n", + " save_dir.mkdir(exist_ok=True)\n", + " if file_name is None:\n", + " file_name = f\"reduced_embeddings_{reducer.__class__.__name__}.pkl\"\n", + " else:\n", + " file_name = f\"{file_name}.pkl\"\n", + " pd.DataFrame(reduced_embeddings, index=embeddings.index).to_pickle(\n", + " save_dir / file_name\n", + " )\n", + " print(f\"Saved reduced embeddings to {save_dir / file_name}\")\n", + " return reduced_embeddings" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# make the directory to save the reduced embeddings\n", + "(save_dir / \"reduced_embeddings_2d\").mkdir(parents=True, exist_ok=True)\n", + "# calculate the reduced embeddings\n", + "silhouette_scores = {}\n", + "for name in embedding_names:\n", + " for reducer in reducers:\n", + " print(f\"Computing {name} {reducer} embeddings\")\n", + "\n", + " embeddings = pd.read_pickle(\n", + " save_dir / \"embeddings\" / f\"embeddings_{name}.pkl\"\n", + " )\n", + "\n", + " reduced_embeddings = dimension_reduction(\n", + " embeddings,\n", + " reducer=reducer,\n", + " n_components=2,\n", + " save_dir=save_dir / \"reduced_embeddings_2d\",\n", + " file_name=f\"{reducer}_{name}\",\n", + " random_state=42,\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Visualization of the Reduced Embeddings" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# pip install -U kaleido" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from plot_embedding import plot_reducers_embeddings" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df_category = pd.read_pickle(save_dir / \"df_binary_category.pkl\")\n", + "df_category[\"formula\"] = df_category.index\n", + "embedding_dir = Path(save_dir / \"reduced_embeddings_2d/\")\n", + "save_path = save_dir / \"plot_binary.jpg\" # save path for the plot\n", + "fig = plot_reducers_embeddings(\n", + " df_category,\n", + " reducers,\n", + " embedding_names,\n", + " embedding_dir,\n", + " symbol=\"circle\",\n", + " title=\"Compositional space for binary compounds\",\n", + " save_path=save_path,\n", + ")\n", + "# check the plot in save_path" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "smact", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.18" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/Crystal_Space/download_compounds_with_mp_api.py b/examples/Crystal_Space/download_compounds_with_mp_api.py new file mode 100644 index 00000000..6e559cb9 --- /dev/null +++ b/examples/Crystal_Space/download_compounds_with_mp_api.py @@ -0,0 +1,96 @@ +import json +import time +import string +import itertools +from pathlib import Path +from collections import defaultdict +from tqdm import tqdm + +from mp_api.client import MPRester +from pymatgen.core.composition import Composition + + +def download_mp_data( + mp_api_key: str = None, + num_elements: int = 2, + max_stoich: int = 8, + save_dir: str = "data/binary/mp_api", + request_interval: float = 0.1, +): + """ + Downloads Materials Project data all possible combinations of `num_elements` elements + with atomic numbers. + When chemical formula is same, the one with lowest energy above hull is saved. + The data is saved to a specified directory. + + Args: + mp_api_key (str, optional): the API key for Materials Project. + num_elements (int, optional): the number of elements in each compound to consider. + Defaults to 2. + max_stoich (int, optional): the maximum integer of stoichiometric coefficient + in chemical formula. Defaults to 8. + save_dir (str, optional): the directory to save the downloaded data to. + Defaults to "data/mp_api". + request_interval (float, optional): the time interval between API requests, in seconds. + Defaults to 1. + + Returns: + None + """ + # check if MP_API_KEY is set + if mp_api_key is None: + raise ValueError( + "Please set your MP_API_KEY in the environment variable." + ) + # set save directory + save_dir = Path(save_dir) + save_dir.mkdir(parents=True, exist_ok=True) + + # make a list for all possible combinartions of formula anonymous + symbols = string.ascii_uppercase + formula_anonymous_list = [] + for stoichs in itertools.combinations_with_replacement( + range(1, max_stoich + 1), num_elements + ): + formula_dict = {symbols[i]: stoich for i, stoich in enumerate(stoichs)} + formula_anonymous_list.append( + Composition(formula_dict).reduced_formula + ) + formula_anonymous_list = sorted(set(formula_anonymous_list)) + + e_hull_dict = defaultdict(lambda: float("inf")) + + for formula_anonymous in tqdm(formula_anonymous_list): + # donwload data from MP + with MPRester(mp_api_key) as mpr: + docs = mpr.materials.summary.search( + formula=formula_anonymous, + fields=[ + "formula_pretty", + "material_id", + "formula_anonymous", + "volume", + "density", + "density_atomic", + "energy_per_atom", + "formation_energy_per_atom", + "energy_above_hull", + "is_stable", + "band_gap", + "efermi", + "total_magnetization", + "structure", + ], + ) + # save data with lowest energy above hull + for doc in docs: + formula_pretty = doc.formula_pretty + energy_above_hull = doc.energy_above_hull + + if (energy_above_hull) < e_hull_dict[formula_pretty]: + e_hull_dict[formula_pretty] = energy_above_hull + + json.dump( + doc.dict(), open(save_dir / f"{formula_pretty}.json", "w") + ) + time.sleep(request_interval) diff --git a/examples/Crystal_Space/generate_composition_with_smact.py b/examples/Crystal_Space/generate_composition_with_smact.py new file mode 100644 index 00000000..e1b73dd1 --- /dev/null +++ b/examples/Crystal_Space/generate_composition_with_smact.py @@ -0,0 +1,143 @@ +import warnings +from pathlib import Path + +import itertools +import multiprocessing +from functools import partial + +from tqdm import tqdm +import pandas as pd +from pymatgen.core.composition import Composition + +from smact import Element, ordered_elements +from smact.screening import smact_filter + +warnings.simplefilter(action="ignore", category=UserWarning) + + +def convert_formula(combinations, num_elements, max_stoich): + symbols = [element.symbol for element in combinations] + local_compounds = [] + for counts in itertools.product( + range(1, max_stoich + 1), repeat=num_elements + ): + formula_dict = { + symbol: count for symbol, count in zip(symbols, counts) + } + formula = Composition(formula_dict).reduced_formula + local_compounds.append(formula) + return local_compounds + + +def generate_composition_with_smact( + num_elements: int = 2, + max_stoich: int = 8, + max_atomic_num: int = 103, + num_processes: int = None, + save_path: str = None, +): + """Generate all possible compositions of a given number of elements and + filter them with SMACT. + + Args: + num_elements: the number of elements in a compound. Defaults to 2. + max_stoich: the maximum stoichiometric coefficient. Defaults to 8. + max_atomic_num: the maximum atomic number. Defaults to 103. + num_processes: the number of processes to use. Defaults to None. + save_path: the path to save the results. Defaults to None. + + Returns: + _description_ + """ + + # 1. generate all possible combinations of elements + print("#1. Generating all possible combinations of elements...") + + elements = [ + Element(element) for element in ordered_elements(1, max_atomic_num) + ] + combinations = list(itertools.combinations(elements, num_elements)) + print(f"Number of generated combinations: {len(list(combinations))}") + + # 2. generate all possible stoichiometric combinations + print("#2. Generating all possible stoichiometric combinations...") + + pool = multiprocessing.Pool( + processes=multiprocessing.cpu_count() + if num_processes is None + else num_processes + ) + compounds = list( + tqdm( + pool.imap_unordered( + partial( + convert_formula, + num_elements=num_elements, + max_stoich=max_stoich, + ), + combinations, + ), + total=len(combinations), + ) + ) + + pool.close() + pool.join() + # Flatten the list of lists into a single list + compounds = [item for sublist in compounds for item in sublist] + + print(f"Number of generated compounds: {len(compounds)}") + compounds = list(set(compounds)) + print(f"Number of generated compounds (unique): {len(compounds)}") + + # 3. filter compounds with smact + print("#3. Filtering compounds with SMACT...") + elements_pauling = [ + Element(element) + for element in ordered_elements(1, max_atomic_num) + if Element(element).pauling_eneg is not None + ] # omit elements without Pauling electronegativity (e.g., He, Ne, Ar, ...) + compounds_pauling = list( + itertools.combinations(elements_pauling, num_elements) + ) + + pool = multiprocessing.Pool( + processes=multiprocessing.cpu_count() + if num_processes is None + else num_processes + ) + results = list( + tqdm( + pool.imap_unordered( + partial(smact_filter, threshold=max_stoich), compounds_pauling + ), + total=len(compounds_pauling), + ) + ) + pool.close() + pool.join() + + # 4. make data frame of results + print("#4. Making data frame of results...") + # make dataframework with index is compound and columns are boolean smact results + smact_allowed = [] + + for result in results: + for res in result: + symbols_stoich = zip(res[0], res[2]) + composition_dict = { + symbol: stoich for symbol, stoich in symbols_stoich + } + smact_allowed.append(Composition(composition_dict).reduced_formula) + smact_allowed = list(set(smact_allowed)) + print(f"Number of compounds allowed by SMACT: {len(smact_allowed)}") + + df = pd.DataFrame(data=False, index=compounds, columns=["smact_allowed"]) + df.loc[smact_allowed, "smact_allowed"] = True + + if save_path is not None: + Path(save_path).parent.mkdir(parents=True, exist_ok=True) + df.to_pickle(save_path) + print(f"Saved to {save_path}") + + return df diff --git a/examples/Crystal_Space/plot_embedding.py b/examples/Crystal_Space/plot_embedding.py new file mode 100644 index 00000000..90976726 --- /dev/null +++ b/examples/Crystal_Space/plot_embedding.py @@ -0,0 +1,156 @@ +from typing import List +from pathlib import Path + +import pandas as pd + +from plotly.subplots import make_subplots +import plotly.graph_objects as go + + +def update_layout( + fig: go.Figure, + title: str, + num_row: int = 6, + num_col: int = 3, + width: float = 1200, + height: float = 1800, +): + # set axis + for i in range(1, num_row + 1): + for j in range(1, num_col + 1): + fig.update_xaxes( + showticklabels=False, + linecolor="black", + showline=True, + linewidth=1, + mirror=True, + row=i, + col=j, + ) + fig.update_yaxes( + showticklabels=False, + linecolor="black", + showline=True, + linewidth=1, + mirror=True, + row=i, + col=j, + ) + + # set layout + fig.update_layout( + title=title, + title_x=0.5, + title_font_size=30, + width=width, + height=height, + margin=dict(l=10, r=10, t=80, b=50), + paper_bgcolor="rgba(255,255,255,1)", + plot_bgcolor="rgba(255,255,255,1)", + legend=dict( + orientation="h", + yanchor="bottom", + xanchor="center", + x=0.5, + y=-0.04, + font=dict(size=30), + ), + ) + return fig + + +def plot_reducers_embeddings( + df_label: pd.DataFrame, + reducers: List[str], + embedding_names: List[str], + embedding_dir: Path, + save_path: Path, + symbol: str = "circle", + title: str = "Embedding Visualization", +): + fig = make_subplots( + rows=6, + cols=3, + subplot_titles=[ + f"{reducer} - {embedding_name}" + for embedding_name in embedding_names + for reducer in reducers + ], + vertical_spacing=0.02, + horizontal_spacing=0.02, + ) + + # updatee the font size of subplot titles + for i in fig["layout"]["annotations"]: + i["font"] = dict(size=25) + + legend_colors = { + "unlikely": "#D9D9D9", + "interesting": "#22E000", + "missing": "#FF1201", + "standard": "#002FFF", + } + + for i, embedding_name in enumerate(embedding_names): + for j, reducer in enumerate(reducers): + print(f"processing {i} {j}...") + embedding_data = pd.read_pickle( + embedding_dir / f"{reducer}_{embedding_name}.pkl", + ) + embedding_data.columns = ["x", "y"] + df_plot = embedding_data.join(df_label) + df_plot = df_plot.sample(frac=1, random_state=42) + + fig.add_trace( + go.Scatter( + x=df_plot["x"], + y=df_plot["y"], + mode="markers", + marker=dict( + size=8, + color=df_plot["label"].map(legend_colors), + opacity=0.8, + symbol=symbol, + line=dict(width=0.5, color="DarkSlateGrey"), + ), + showlegend=False, + text=df_plot["formula"], + hovertemplate=("%{text}

"), + ), + row=i + 1, + col=j + 1, + ) + + # add legend + for label, _ in legend_colors.items(): + fig.add_trace( + go.Scatter( + x=[None], + y=[None], + mode="markers", + marker=dict( + size=8, + color=legend_colors[label], + opacity=0.8, + symbol=symbol, + line=dict(width=0.5, color="DarkSlateGrey"), + ), + # make only first letter capital + name=label.capitalize(), + showlegend=True, + ), + row=1, + col=1, + ) + + # update layout + fig = update_layout(fig, title=title) + + if save_path is not None: + if save_path.suffix == ".html": + fig.write_html(save_path) + else: + fig.write_image(save_path, scale=6) + print(f"Save to {save_path}") + + return fig From 1bda7be13157cd632a04e9629ec4b145696e95a8 Mon Sep 17 00:00:00 2001 From: AntObi Date: Wed, 6 Dec 2023 10:36:44 +0000 Subject: [PATCH 44/56] Run pre-commit --- .../Crystal_Space/download_compounds_with_mp_api.py | 12 +++++------- .../Crystal_Space/generate_composition_with_smact.py | 11 ++++------- examples/Crystal_Space/plot_embedding.py | 5 ++--- 3 files changed, 11 insertions(+), 17 deletions(-) diff --git a/examples/Crystal_Space/download_compounds_with_mp_api.py b/examples/Crystal_Space/download_compounds_with_mp_api.py index 6e559cb9..54b5b0e5 100644 --- a/examples/Crystal_Space/download_compounds_with_mp_api.py +++ b/examples/Crystal_Space/download_compounds_with_mp_api.py @@ -1,13 +1,13 @@ +import itertools import json -import time import string -import itertools -from pathlib import Path +import time from collections import defaultdict -from tqdm import tqdm +from pathlib import Path from mp_api.client import MPRester from pymatgen.core.composition import Composition +from tqdm import tqdm def download_mp_data( @@ -53,9 +53,7 @@ def download_mp_data( range(1, max_stoich + 1), num_elements ): formula_dict = {symbols[i]: stoich for i, stoich in enumerate(stoichs)} - formula_anonymous_list.append( - Composition(formula_dict).reduced_formula - ) + formula_anonymous_list.append(Composition(formula_dict).reduced_formula) formula_anonymous_list = sorted(set(formula_anonymous_list)) e_hull_dict = defaultdict(lambda: float("inf")) diff --git a/examples/Crystal_Space/generate_composition_with_smact.py b/examples/Crystal_Space/generate_composition_with_smact.py index e1b73dd1..55449d2b 100644 --- a/examples/Crystal_Space/generate_composition_with_smact.py +++ b/examples/Crystal_Space/generate_composition_with_smact.py @@ -1,13 +1,12 @@ -import warnings -from pathlib import Path - import itertools import multiprocessing +import warnings from functools import partial +from pathlib import Path -from tqdm import tqdm import pandas as pd from pymatgen.core.composition import Composition +from tqdm import tqdm from smact import Element, ordered_elements from smact.screening import smact_filter @@ -21,9 +20,7 @@ def convert_formula(combinations, num_elements, max_stoich): for counts in itertools.product( range(1, max_stoich + 1), repeat=num_elements ): - formula_dict = { - symbol: count for symbol, count in zip(symbols, counts) - } + formula_dict = {symbol: count for symbol, count in zip(symbols, counts)} formula = Composition(formula_dict).reduced_formula local_compounds.append(formula) return local_compounds diff --git a/examples/Crystal_Space/plot_embedding.py b/examples/Crystal_Space/plot_embedding.py index 90976726..8b76f5ef 100644 --- a/examples/Crystal_Space/plot_embedding.py +++ b/examples/Crystal_Space/plot_embedding.py @@ -1,10 +1,9 @@ -from typing import List from pathlib import Path +from typing import List import pandas as pd - -from plotly.subplots import make_subplots import plotly.graph_objects as go +from plotly.subplots import make_subplots def update_layout( From b23c17e151d406314c0f2056ff88412fbbd5e68f Mon Sep 17 00:00:00 2001 From: Anthony Onwuli <30937913+AntObi@users.noreply.github.com> Date: Thu, 7 Dec 2023 16:38:15 +0000 Subject: [PATCH 45/56] Add files via upload Added oxidation state decorated cif file for CsPbI3 --- .../Oxidation_states/mp-540839_CsPbI3_oxi.cif | 52 +++++++++++++++++++ 1 file changed, 52 insertions(+) create mode 100644 examples/Oxidation_states/mp-540839_CsPbI3_oxi.cif diff --git a/examples/Oxidation_states/mp-540839_CsPbI3_oxi.cif b/examples/Oxidation_states/mp-540839_CsPbI3_oxi.cif new file mode 100644 index 00000000..ac3953e9 --- /dev/null +++ b/examples/Oxidation_states/mp-540839_CsPbI3_oxi.cif @@ -0,0 +1,52 @@ +# generated using pymatgen +data_CsPbI3 +_symmetry_space_group_name_H-M 'P 1' +_cell_length_a 4.84714164 +_cell_length_b 10.65044663 +_cell_length_c 18.03119927 +_cell_angle_alpha 90.00000000 +_cell_angle_beta 90.00000000 +_cell_angle_gamma 90.00000000 +_symmetry_Int_Tables_number 1 +_chemical_formula_structural CsPbI3 +_chemical_formula_sum 'Cs4 Pb4 I12' +_cell_volume 930.84665829 +_cell_formula_units_Z 4 +loop_ + _symmetry_equiv_pos_site_id + _symmetry_equiv_pos_as_xyz + 1 'x, y, z' +loop_ + _atom_type_symbol + _atom_type_oxidation_number + Cs+ 1.0 + Pb2+ 2.0 + I- -1.0 +loop_ + _atom_site_type_symbol + _atom_site_label + _atom_site_symmetry_multiplicity + _atom_site_fract_x + _atom_site_fract_y + _atom_site_fract_z + _atom_site_occupancy + Cs+ Cs0 1 0.75000000 0.58127558 0.17211973 1.0 + Cs+ Cs1 1 0.25000000 0.41872442 0.82788027 1.0 + Cs+ Cs2 1 0.75000000 0.08127558 0.32788027 1.0 + Cs+ Cs3 1 0.25000000 0.91872442 0.67211973 1.0 + Pb2+ Pb4 1 0.25000000 0.66184885 0.43921676 1.0 + Pb2+ Pb5 1 0.75000000 0.33815115 0.56078324 1.0 + Pb2+ Pb6 1 0.25000000 0.16184885 0.06078324 1.0 + Pb2+ Pb7 1 0.75000000 0.83815115 0.93921676 1.0 + I- I8 1 0.75000000 0.83721116 0.50204455 1.0 + I- I9 1 0.25000000 0.16278884 0.49795545 1.0 + I- I10 1 0.75000000 0.33721116 0.99795545 1.0 + I- I11 1 0.25000000 0.66278884 0.00204455 1.0 + I- I12 1 0.25000000 0.52927197 0.61230824 1.0 + I- I13 1 0.75000000 0.47072803 0.38769176 1.0 + I- I14 1 0.25000000 0.02927197 0.88769176 1.0 + I- I15 1 0.75000000 0.97072803 0.11230824 1.0 + I- I16 1 0.25000000 0.79631664 0.28730552 1.0 + I- I17 1 0.75000000 0.20368336 0.71269448 1.0 + I- I18 1 0.25000000 0.29631664 0.21269448 1.0 + I- I19 1 0.75000000 0.70368336 0.78730552 1.0 From ad7f7aaf82fd258a3f9d7fdd459a74864a5593fe Mon Sep 17 00:00:00 2001 From: Anthony Onwuli <30937913+AntObi@users.noreply.github.com> Date: Thu, 7 Dec 2023 17:14:43 +0000 Subject: [PATCH 46/56] Fix bug with using structures --- smact/oxidation_states.py | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/smact/oxidation_states.py b/smact/oxidation_states.py index cec08a61..300b28ef 100644 --- a/smact/oxidation_states.py +++ b/smact/oxidation_states.py @@ -12,7 +12,8 @@ from numpy import mean from pymatgen.core import Structure -from pymatgen.core.periodic_table import Specie as pmgSpecies +from pymatgen.core.periodic_table import Species as pmgSpecies +from pymatgen.core.periodic_table import get_el_sp from smact import Element, Species, data_directory @@ -146,7 +147,13 @@ def compound_probability( if not all(isinstance(i, pmgSpecies) for i in species): raise TypeError("Structure must have oxidation states.") else: - structure = [Species(i.symbol, i.oxi_state) for i in structure] + structure = [ + Species( + get_el_sp(i.species_string).symbol, + get_el_sp(i.species_string).oxi_state, + ) + for i in structure + ] else: raise TypeError( "Input requires a list of SMACT or Pymatgen Species or a Structure." From 030d68b0b7688ea955b1ba736bbec573e380c01a Mon Sep 17 00:00:00 2001 From: Anthony Onwuli <30937913+AntObi@users.noreply.github.com> Date: Thu, 7 Dec 2023 17:14:59 +0000 Subject: [PATCH 47/56] Add example using a structure --- .../Oxidation_states/oxidation_states.ipynb | 172 +++++++++++++----- 1 file changed, 126 insertions(+), 46 deletions(-) diff --git a/examples/Oxidation_states/oxidation_states.ipynb b/examples/Oxidation_states/oxidation_states.ipynb index 588d1fdf..45908c2b 100644 --- a/examples/Oxidation_states/oxidation_states.ipynb +++ b/examples/Oxidation_states/oxidation_states.ipynb @@ -22,7 +22,7 @@ "import multiprocess\n", "import numpy as np\n", "import pandas as pd\n", - "from pymatgen.core import Composition\n", + "from pymatgen.core import Composition, Structure\n", "\n", "import smact\n", "from smact import Element, Species, screening\n", @@ -65,7 +65,7 @@ "output_type": "stream", "text": [ "The species included in the probability table for the oxidation states model are show below \n", - "['F-1', 'I-1', 'O-2', 'Cl-1', 'S-2', 'Se-2', 'Br-1', 'Te-2', 'Mn5', 'Fe3', 'U6', 'Nb1', 'Cr4', 'Pr2', 'Re4', 'Cu2', 'Sr2', 'Sc1', 'Sb5', 'Eu3', 'Mn1', 'Ag2', 'Cs1', 'Al3', 'V5', 'Ta2', 'Dy3', 'Rb1', 'Ta4', 'La2', 'Rh4', 'Lu3', 'Nd2', 'Tm2', 'Y1', 'Re2', 'Th4', 'Co1', 'Mn2', 'Mn3', 'Ni4', 'Pb4', 'Sc3', 'W2', 'Ta3', 'Mo4', 'Ru2', 'Ru3', 'Ce3', 'Gd2', 'Tl3', 'Ir6', 'Zr4', 'Ga1', 'Sn4', 'Mn6', 'La3', 'Pr3', 'Ti2', 'Bi2', 'Tb1', 'Pd4', 'Ru5', 'Eu2', 'Pb2', 'Nd3', 'Ru6', 'Cr6', 'Hf4', 'Zr2', 'Ho3', 'Ce4', 'Ce2', 'Ge3', 'Th3', 'Mg2', 'Re3', 'Co4', 'Ni1', 'Ni2', 'Ir3', 'Gd3', 'In2', 'Y3', 'U4', 'Re5', 'Ir4', 'Mo2', 'Sn3', 'Cu3', 'Ti3', 'Tb2', 'Pd3', 'Bi5', 'Y2', 'U3', 'Ge4', 'Mo3', 'Zr3', 'Er3', 'Sm2', 'Sm3', 'Cr2', 'Sb3', 'Mo6', 'Be2', 'Ta5', 'V3', 'Rh1', 'Pd2', 'Dy2', 'Cd2', 'Sn2', 'Tb4', 'Co3', 'Re6', 'Yb3', 'W3', 'Mo5', 'Re7', 'Hf2', 'Fe2', 'Ag1', 'Ir5', 'Nb5', 'Yb2', 'Li1', 'Tl1', 'Zr1', 'Zn2', 'Sb4', 'Ti4', 'Ba2', 'Co2', 'V4', 'Nb2', 'U2', 'Bi1', 'W4', 'Na1', 'Nb4', 'Ho2', 'Nb3', 'Ge2', 'Mn4', 'Ru4', 'Ca2', 'In1', 'U5', 'Ag3', 'In3', 'V2', 'W6', 'Fe4', 'Ni3', 'Tm3', 'Ga3', 'Hg1', 'Sc2', 'Cr3', 'Ta1', 'Cu1', 'Bi3', 'K1', 'Ga2', 'Rh3', 'W5', 'Fe1', 'La1', 'Mn7', 'Hg2', 'Cr5', 'Tb3']\n" + "['Cl-1', 'O-2', 'S-2', 'I-1', 'Br-1', 'F-1', 'Se-2', 'Te-2', 'La2', 'Pr2', 'Tb2', 'Sc1', 'Cr3', 'Sc2', 'Tl3', 'Ru2', 'Mn7', 'W3', 'Ir5', 'Ru6', 'Ho3', 'Ag3', 'Cs1', 'Eu3', 'Mn2', 'Cd2', 'Re2', 'In3', 'Ta1', 'Ca2', 'Re7', 'U5', 'Zn2', 'Yb3', 'Hg2', 'W5', 'Co3', 'Ru5', 'Er3', 'Sm2', 'Ir3', 'Ru4', 'Sb4', 'Zr3', 'Lu3', 'Ta5', 'Ru3', 'U2', 'Tl1', 'V4', 'La3', 'Re3', 'Ag1', 'Sn2', 'Sm3', 'Th4', 'Tm2', 'Ga3', 'Co1', 'Ce3', 'Co2', 'Rh4', 'Bi5', 'Pd4', 'Pb2', 'Gd2', 'Nb4', 'Gd3', 'Bi1', 'Li1', 'Pd2', 'V5', 'Y3', 'Dy2', 'Sn4', 'Th3', 'Sb5', 'Fe4', 'Cr6', 'W4', 'Ti3', 'Ni2', 'Re5', 'U3', 'Ge2', 'Sn3', 'Bi3', 'Eu2', 'Sc3', 'Zr4', 'In2', 'Cr5', 'Mn3', 'Tb3', 'Ag2', 'Fe3', 'Ir4', 'Ga1', 'Cu2', 'Sr2', 'W2', 'Mo5', 'Tb4', 'Mn6', 'Ta4', 'Cu1', 'Fe2', 'Mn4', 'U6', 'Pr3', 'Bi2', 'Zr2', 'Nd3', 'Ta3', 'Ti2', 'Mg2', 'Cu3', 'V2', 'Tm3', 'W6', 'Rb1', 'Ta2', 'K1', 'Ga2', 'Ti4', 'Ba2', 'Mn1', 'La1', 'Cr2', 'Al3', 'U4', 'Ge4', 'Nd2', 'Mo3', 'Yb2', 'Tb1', 'Ge3', 'Ni1', 'Nb5', 'Rh3', 'Hf4', 'Nb3', 'Ni3', 'Dy3', 'Re6', 'Na1', 'In1', 'Hg1', 'Rh1', 'Y2', 'Pd3', 'Ce2', 'Sb3', 'Cr4', 'Y1', 'Zr1', 'Hf2', 'Pb4', 'Nb1', 'Fe1', 'Ni4', 'Ce4', 'Mn5', 'Mo6', 'Ho2', 'Nb2', 'Ir6', 'Mo4', 'V3', 'Mo2', 'Co4', 'Re4', 'Be2']\n" ] } ], @@ -143,6 +143,86 @@ "print(f\"The compound probability for CaAl2O4 is {prob_compound}.\")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can compute this compound probability for a pymatgen Structure as well." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The structure of mp-540839 CsPbI3:\n", + "\n", + "Full Formula (Cs4 Pb4 I12)\n", + "Reduced Formula: CsPbI3\n", + "abc : 4.847142 10.650447 18.031199\n", + "angles: 90.000000 90.000000 90.000000\n", + "pbc : True True True\n", + "Sites (20)\n", + " # SP a b c\n", + "--- ---- ---- -------- --------\n", + " 0 Cs+ 0.75 0.581276 0.17212\n", + " 1 Cs+ 0.25 0.418724 0.82788\n", + " 2 Cs+ 0.75 0.081276 0.32788\n", + " 3 Cs+ 0.25 0.918724 0.67212\n", + " 4 Pb2+ 0.25 0.661849 0.439217\n", + " 5 Pb2+ 0.75 0.338151 0.560783\n", + " 6 Pb2+ 0.25 0.161849 0.060783\n", + " 7 Pb2+ 0.75 0.838151 0.939217\n", + " 8 I- 0.75 0.837211 0.502045\n", + " 9 I- 0.25 0.162789 0.497955\n", + " 10 I- 0.75 0.337211 0.997955\n", + " 11 I- 0.25 0.662789 0.002045\n", + " 12 I- 0.25 0.529272 0.612308\n", + " 13 I- 0.75 0.470728 0.387692\n", + " 14 I- 0.25 0.029272 0.887692\n", + " 15 I- 0.75 0.970728 0.112308\n", + " 16 I- 0.25 0.796317 0.287306\n", + " 17 I- 0.75 0.203683 0.712694\n", + " 18 I- 0.25 0.296317 0.212694\n", + " 19 I- 0.75 0.703683 0.787306\n", + "\n", + "The compound probability for CsPbI3 is 1.0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/codespace/.python/current/lib/python3.10/site-packages/pymatgen/io/cif.py:1186: UserWarning: The default value of primitive was changed from True to False in https://github.com/materialsproject/pymatgen/pull/3419. CifParser now returns the cell in the CIF file as is. If you want the primitive cell, please set primitive=True explicitly.\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "# Load the structure file\n", + "\n", + "struct = Structure.from_file(\"mp-540839_CsPbI3_oxi.cif\")\n", + "print(\"The structure of mp-540839 CsPbI3:\\n\")\n", + "print(struct)\n", + "\n", + "\n", + "# Get the compound probability for CsPbI3\n", + "prob = ox_prob_finder.compound_probability(struct)\n", + "\n", + "print(f\"\\nThe compound probability for CsPbI3 is {prob_compound}.\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "markdown", "metadata": {}, @@ -163,7 +243,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": { "tags": [ "hide-input", @@ -249,7 +329,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": { "tags": [ "hide-input", @@ -264,11 +344,11 @@ "Number of compositions: 14832\n", "Each list entry looks like this:\n", " elements, oxidation states, stoichiometries\n", - "['Mn', 'Fe', 'F'] (5, 3, -1) (1, 1, 8)\n", - "['Mn', 'Fe', 'Cl'] (5, 3, -1) (1, 1, 8)\n", - "['Mn', 'Fe', 'Br'] (5, 3, -1) (1, 1, 8)\n", - "['Mn', 'Fe', 'I'] (5, 3, -1) (1, 1, 8)\n", - "['Mn', 'Nb', 'F'] (5, 1, -1) (1, 1, 6)\n" + "['Sc', 'Cr', 'F'] (1, 3, -1) (1, 1, 4)\n", + "['Sc', 'Cr', 'Cl'] (1, 3, -1) (1, 1, 4)\n", + "['Sc', 'Cr', 'Br'] (1, 3, -1) (1, 1, 4)\n", + "['Sc', 'Cr', 'I'] (1, 3, -1) (1, 1, 4)\n", + "['Sc', 'Sc', 'F'] (1, 2, -1) (1, 1, 3)\n" ] } ], @@ -300,7 +380,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": { "tags": [ "hide-input", @@ -313,11 +393,11 @@ "output_type": "stream", "text": [ "Each list entry now looks like this: \n", - "MnFeF8\n", - "MnFeCl8\n", - "MnFeBr8\n", - "MnFeI8\n", - "MnNbF6\n" + "ScCrF4\n", + "ScCrCl4\n", + "ScCrBr4\n", + "ScCrI4\n", + "Sc2F3\n" ] } ], @@ -354,7 +434,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -366,7 +446,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -400,41 +480,41 @@ " \n", " \n", " 0\n", - " MnFeF8\n", - " Mn5+\n", - " Fe3+\n", + " ScCrF4\n", + " Sc1+\n", + " Cr3+\n", " F1-\n", - " 0.383333\n", + " 0.289474\n", " \n", " \n", " 1\n", - " MnFeCl8\n", - " Mn5+\n", - " Fe3+\n", + " ScCrCl4\n", + " Sc1+\n", + " Cr3+\n", " Cl1-\n", - " 0.281250\n", + " 0.227273\n", " \n", " \n", " 2\n", - " MnFeBr8\n", - " Mn5+\n", - " Fe3+\n", + " ScCrBr4\n", + " Sc1+\n", + " Cr3+\n", " Br1-\n", - " 0.277778\n", + " 0.285714\n", " \n", " \n", " 3\n", - " MnFeI8\n", - " Mn5+\n", - " Fe3+\n", + " ScCrI4\n", + " Sc1+\n", + " Cr3+\n", " I1-\n", - " 0.100000\n", + " 0.111111\n", " \n", " \n", " 4\n", - " MnNbF6\n", - " Mn5+\n", - " Nb1+\n", + " Sc2F3\n", + " Sc1+\n", + " Sc2+\n", " F1-\n", " 0.000000\n", " \n", @@ -444,14 +524,14 @@ ], "text/plain": [ " formula_pretty A B X compound_probability\n", - "0 MnFeF8 Mn5+ Fe3+ F1- 0.383333\n", - "1 MnFeCl8 Mn5+ Fe3+ Cl1- 0.281250\n", - "2 MnFeBr8 Mn5+ Fe3+ Br1- 0.277778\n", - "3 MnFeI8 Mn5+ Fe3+ I1- 0.100000\n", - "4 MnNbF6 Mn5+ Nb1+ F1- 0.000000" + "0 ScCrF4 Sc1+ Cr3+ F1- 0.289474\n", + "1 ScCrCl4 Sc1+ Cr3+ Cl1- 0.227273\n", + "2 ScCrBr4 Sc1+ Cr3+ Br1- 0.285714\n", + "3 ScCrI4 Sc1+ Cr3+ I1- 0.111111\n", + "4 Sc2F3 Sc1+ Sc2+ F1- 0.000000" ] }, - "execution_count": 10, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -472,7 +552,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -507,12 +587,12 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -555,7 +635,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.13" + "version": "3.10.13" }, "orig_nbformat": 4, "vscode": { From a4c29d1d20afadda0f30d60a76947ff0e5bbf20f Mon Sep 17 00:00:00 2001 From: Anthony Onwuli <30937913+AntObi@users.noreply.github.com> Date: Thu, 7 Dec 2023 17:15:09 +0000 Subject: [PATCH 48/56] Add test for structure --- smact/tests/test_core.py | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/smact/tests/test_core.py b/smact/tests/test_core.py index b895bc53..c3e27a47 100755 --- a/smact/tests/test_core.py +++ b/smact/tests/test_core.py @@ -3,6 +3,7 @@ import os import unittest +from pymatgen.core import Structure from pymatgen.core.periodic_table import Specie import smact @@ -17,6 +18,7 @@ files_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), "files") TEST_OX_STATES = os.path.join(files_dir, "test_oxidation_states.txt") +TEST_STRUCT = os.path.join(files_dir, "mp-540839_CsPbI3_oxi.cif") class TestSequenceFunctions(unittest.TestCase): @@ -417,7 +419,7 @@ def test_lattice_parameters(self): self.assertAlmostEqual(wurtz[0], 5.13076) self.assertAlmostEqual(wurtz[2], 8.3838) - # ---------- Lattice parameters ----------- + # ---------- smact.oxidation_states module ----------- def test_oxidation_states(self): ox = smact.oxidation_states.Oxidation_state_probability_finder() self.assertAlmostEqual( @@ -429,3 +431,8 @@ def test_oxidation_states(self): 0.74280230326, ) self.assertEqual(len(ox.get_included_species()), 173) + + def test_compound_probability_structure(self): + structure = Structure.from_file(TEST_STRUCT) + ox = smact.oxidation_states.Oxidation_state_probability_finder() + self.assertEqual(ox.compound_probability(structure), 1.0) From 407025d97168e730a2f47776bd1510b413f9d6ea Mon Sep 17 00:00:00 2001 From: Anthony Onwuli <30937913+AntObi@users.noreply.github.com> Date: Thu, 7 Dec 2023 19:25:59 +0000 Subject: [PATCH 49/56] Add json structure file in tests --- smact/tests/files/mp-540839_CsPbI3_oxi.json | 1 + 1 file changed, 1 insertion(+) create mode 100644 smact/tests/files/mp-540839_CsPbI3_oxi.json diff --git a/smact/tests/files/mp-540839_CsPbI3_oxi.json b/smact/tests/files/mp-540839_CsPbI3_oxi.json new file mode 100644 index 00000000..815bce89 --- /dev/null +++ b/smact/tests/files/mp-540839_CsPbI3_oxi.json @@ -0,0 +1 @@ +{"@module": "pymatgen.core.structure", "@class": "Structure", "charge": 0, "lattice": {"matrix": [[4.84714164, -0.0, 0.0], [0.0, 10.65044663, 0.0], [0.0, 0.0, 18.03119927]], "pbc": [true, true, true], "a": 4.84714164, "b": 10.65044663, "c": 18.03119927, "alpha": 90.0, "beta": 90.0, "gamma": 90.0, "volume": 930.846658290349}, "properties": {}, "sites": [{"species": [{"element": "Cs", "oxidation_state": 1, "spin": null, "occu": 1.0}], "abc": [0.75, 0.58127558, 0.17211973], "xyz": [3.63535623, 6.190844542112295, 3.103525149928597], "properties": {"magmom": -0.0}, "label": "Cs"}, {"species": [{"element": "Cs", "oxidation_state": 1, "spin": null, "occu": 1.0}], "abc": [0.25, 0.41872442, 0.82788027], "xyz": [1.21178541, 4.4596020878877045, 14.927674120071401], "properties": {"magmom": -0.0}, "label": "Cs"}, {"species": [{"element": "Cs", "oxidation_state": 1, "spin": null, "occu": 1.0}], "abc": [0.75, 0.08127558, 0.32788027], "xyz": [3.63535623, 0.8656212271122954, 5.912074485071402], "properties": {"magmom": -0.0}, "label": "Cs"}, {"species": [{"element": "Cs", "oxidation_state": 1, "spin": null, "occu": 1.0}], "abc": [0.25, 0.91872442, 0.67211973], "xyz": [1.21178541, 9.784825402887703, 12.119124784928596], "properties": {"magmom": -0.0}, "label": "Cs"}, {"species": [{"element": "Pb", "oxidation_state": 2, "spin": null, "occu": 1.0}], "abc": [0.25, 0.66184885, 0.43921676], "xyz": [1.21178541, 7.0489858540518755, 7.919604922283765], "properties": {"magmom": 0.0}, "label": "Pb"}, {"species": [{"element": "Pb", "oxidation_state": 2, "spin": null, "occu": 1.0}], "abc": [0.75, 0.33815115, 0.56078324], "xyz": [3.63535623, 3.6014607759481243, 10.111594347716235], "properties": {"magmom": 0.0}, "label": "Pb"}, {"species": [{"element": "Pb", "oxidation_state": 2, "spin": null, "occu": 1.0}], "abc": [0.25, 0.16184885, 0.06078324], "xyz": [1.21178541, 1.7237625390518754, 1.0959947127162348], "properties": {"magmom": 0.0}, "label": "Pb"}, {"species": [{"element": "Pb", "oxidation_state": 2, "spin": null, "occu": 1.0}], "abc": [0.75, 0.83815115, 0.93921676], "xyz": [3.63535623, 8.926684090948124, 16.935204557283765], "properties": {"magmom": 0.0}, "label": "Pb"}, {"species": [{"element": "I", "oxidation_state": -1, "spin": null, "occu": 1.0}], "abc": [0.75, 0.83721116, 0.50204455], "xyz": [3.63535623, 8.91667277762039, 9.052465323467478], "properties": {"magmom": -0.0}, "label": "I"}, {"species": [{"element": "I", "oxidation_state": -1, "spin": null, "occu": 1.0}], "abc": [0.25, 0.16278884, 0.49795545], "xyz": [1.21178541, 1.733773852379609, 8.978733946532522], "properties": {"magmom": -0.0}, "label": "I"}, {"species": [{"element": "I", "oxidation_state": -1, "spin": null, "occu": 1.0}], "abc": [0.75, 0.33721116, 0.99795545], "xyz": [3.63535623, 3.5914494626203908, 17.99433358153252], "properties": {"magmom": -0.0}, "label": "I"}, {"species": [{"element": "I", "oxidation_state": -1, "spin": null, "occu": 1.0}], "abc": [0.25, 0.66278884, 0.00204455], "xyz": [1.21178541, 7.0589971673796095, 0.036865688467478494], "properties": {"magmom": -0.0}, "label": "I"}, {"species": [{"element": "I", "oxidation_state": -1, "spin": null, "occu": 1.0}], "abc": [0.25, 0.52927197, 0.61230824], "xyz": [1.21178541, 5.6369828692399615, 11.040651890102982], "properties": {"magmom": -0.0}, "label": "I"}, {"species": [{"element": "I", "oxidation_state": -1, "spin": null, "occu": 1.0}], "abc": [0.75, 0.47072803, 0.38769176], "xyz": [3.63535623, 5.013463760760039, 6.990547379897015], "properties": {"magmom": -0.0}, "label": "I"}, {"species": [{"element": "I", "oxidation_state": -1, "spin": null, "occu": 1.0}], "abc": [0.25, 0.02927197, 0.88769176], "xyz": [1.21178541, 0.3117595542399611, 16.006147014897014], "properties": {"magmom": -0.0}, "label": "I"}, {"species": [{"element": "I", "oxidation_state": -1, "spin": null, "occu": 1.0}], "abc": [0.75, 0.97072803, 0.11230824], "xyz": [3.63535623, 10.338687075760038, 2.0250522551029846], "properties": {"magmom": -0.0}, "label": "I"}, {"species": [{"element": "I", "oxidation_state": -1, "spin": null, "occu": 1.0}], "abc": [0.25, 0.79631664, 0.28730552], "xyz": [1.21178541, 8.481127874900922, 5.180463082490969], "properties": {"magmom": -0.0}, "label": "I"}, {"species": [{"element": "I", "oxidation_state": -1, "spin": null, "occu": 1.0}], "abc": [0.75, 0.20368336, 0.71269448], "xyz": [3.63535623, 2.1693187550990767, 12.850736187509028], "properties": {"magmom": -0.0}, "label": "I"}, {"species": [{"element": "I", "oxidation_state": -1, "spin": null, "occu": 1.0}], "abc": [0.25, 0.29631664, 0.21269448], "xyz": [1.21178541, 3.1559045599009234, 3.835136552509029], "properties": {"magmom": -0.0}, "label": "I"}, {"species": [{"element": "I", "oxidation_state": -1, "spin": null, "occu": 1.0}], "abc": [0.75, 0.70368336, 0.78730552], "xyz": [3.63535623, 7.494542070099076, 14.19606271749097], "properties": {"magmom": -0.0}, "label": "I"}]} \ No newline at end of file From be4cb2b330065d7fe6d52caaeff03c65a0fd593b Mon Sep 17 00:00:00 2001 From: Anthony Onwuli <30937913+AntObi@users.noreply.github.com> Date: Thu, 7 Dec 2023 19:26:20 +0000 Subject: [PATCH 50/56] Remove deprecated np.product --- smact/properties.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/smact/properties.py b/smact/properties.py index 722a624f..55e33700 100644 --- a/smact/properties.py +++ b/smact/properties.py @@ -1,6 +1,6 @@ from typing import List, Optional, Union -from numpy import product, sqrt +import numpy as np import smact @@ -70,10 +70,10 @@ def band_gap_Harrison( V1_bar = (V1_An + V1_Cat) / 2 V2 = 2.16 * hbarsq_over_m / (d**2) V3 = (Cat.eig - An.eig) / 2 - alpha_m = (1.11 * V1_bar) / sqrt(V2**2 + V3**2) + alpha_m = (1.11 * V1_bar) / np.sqrt(V2**2 + V3**2) # Calculate Band gap [(3-43) Harrison 1980 ] - Band_gap = (3.60 / 3.0) * (sqrt(V2**2 + V3**2)) * (1 - alpha_m) + Band_gap = (3.60 / 3.0) * (np.sqrt(V2**2 + V3**2)) * (1 - alpha_m) if verbose: print("V1_bar = ", V1_bar) print("V2 = ", V2) @@ -150,7 +150,7 @@ def compound_electroneg( elementlist[i] = [elementlist[i] ** stoichslist[i]] # Calculate geometric mean (n-th root of product) - prod = product(elementlist) + prod = np.prod(elementlist) compelectroneg = (prod) ** (1.0 / (sum(stoichslist))) if verbose: From bc9c44bf3f5f117267620194f141acde3c434891 Mon Sep 17 00:00:00 2001 From: Anthony Onwuli <30937913+AntObi@users.noreply.github.com> Date: Thu, 7 Dec 2023 19:26:32 +0000 Subject: [PATCH 51/56] Fix path to structure --- smact/tests/test_core.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/smact/tests/test_core.py b/smact/tests/test_core.py index c3e27a47..8b649a0f 100755 --- a/smact/tests/test_core.py +++ b/smact/tests/test_core.py @@ -18,7 +18,7 @@ files_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), "files") TEST_OX_STATES = os.path.join(files_dir, "test_oxidation_states.txt") -TEST_STRUCT = os.path.join(files_dir, "mp-540839_CsPbI3_oxi.cif") +TEST_STRUCT = os.path.join(files_dir, "mp-540839_CsPbI3_oxi.json") class TestSequenceFunctions(unittest.TestCase): From cc8426c142da9e5d820d5da1f9de04b632a75de1 Mon Sep 17 00:00:00 2001 From: Anthony Onwuli <30937913+AntObi@users.noreply.github.com> Date: Thu, 7 Dec 2023 19:44:11 +0000 Subject: [PATCH 52/56] Update requirements using pip-compile --- requirements.txt | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/requirements.txt b/requirements.txt index fa74d35c..442c09c5 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,4 +1,5 @@ -# This file is autogenerated by pip-compile with Python 3.9 +# +# This file is autogenerated by pip-compile with Python 3.10 # by the following command: # # pip-compile @@ -25,8 +26,6 @@ future==0.18.3 # via uncertainties idna==3.4 # via requests -importlib-resources==6.0.1 - # via matplotlib joblib==1.3.2 # via pymatgen kiwisolver==1.4.5 @@ -86,7 +85,7 @@ pybtex==0.24.0 # via # emmet-core # pymatgen -pydantic==2.5.2 +pydantic==1.10.13 # via # emmet-core # pymatgen @@ -95,7 +94,7 @@ pymatgen==2023.7.20 # SMACT (setup.py) # emmet-core # mp-api -pyparsing==3.1.1 +pyparsing==3.0.9 # via matplotlib python-dateutil==2.8.2 # via @@ -147,8 +146,6 @@ uncertainties==3.1.7 # via pymatgen urllib3==2.0.7 # via requests -zipp==3.16.2 - # via importlib-resources # The following packages are considered to be unsafe in a requirements file: -# setuptools \ No newline at end of file +# setuptools From f9a769b649df5b61b840c56156afe8538c73d496 Mon Sep 17 00:00:00 2001 From: Anthony Onwuli <30937913+AntObi@users.noreply.github.com> Date: Thu, 7 Dec 2023 19:44:25 +0000 Subject: [PATCH 53/56] Bump version number --- docs/conf.py | 2 +- setup.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/conf.py b/docs/conf.py index fa1cdb7b..86db5ebc 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -62,7 +62,7 @@ # The short X.Y version. version = "2.5" # The full version, including alpha/beta/rc tags. -release = "2.5.1" +release = "2.5.5" # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. diff --git a/setup.py b/setup.py index f0778ecf..8b151a32 100644 --- a/setup.py +++ b/setup.py @@ -5,10 +5,10 @@ __copyright__ = ( "Copyright Daniel W. Davies, Adam J. Jackson, Keith T. Butler (2019)" ) -__version__ = "2.5.4" +__version__ = "2.5.5" __maintainer__ = "Anthony O. Onwuli" __maintaier_email__ = "anthony.onwuli16@imperial.ac.uk" -__date__ = "November 30 2023" +__date__ = "December 7 2023" import os import unittest From 541efda80c23201979ec40cc16a0ce51bd019b17 Mon Sep 17 00:00:00 2001 From: Anthony Onwuli <30937913+AntObi@users.noreply.github.com> Date: Thu, 7 Dec 2023 19:44:52 +0000 Subject: [PATCH 54/56] Install from requirements file --- .github/workflows/ci.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 23aa4321..0aa4e733 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -32,6 +32,7 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip wheel setuptools + pip install -r requirements.txt pip install -e . pip install pytest-cov - name: Run tests and collect coverage From 9dd1a6fa989507a9ea97ea4910c047b669ebd3b0 Mon Sep 17 00:00:00 2001 From: Anthony Onwuli <30937913+AntObi@users.noreply.github.com> Date: Thu, 7 Dec 2023 19:48:53 +0000 Subject: [PATCH 55/56] Update requirements.txt using pip-compile --- requirements.txt | 273 +++++++++++++++++++++-------------------------- 1 file changed, 122 insertions(+), 151 deletions(-) diff --git a/requirements.txt b/requirements.txt index 442c09c5..0341cc29 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,151 +1,122 @@ -# -# This file is autogenerated by pip-compile with Python 3.10 -# by the following command: -# -# pip-compile -# -ase==3.22.1 - # via SMACT (setup.py) -certifi==2023.7.22 - # via requests -charset-normalizer==3.2.0 - # via requests -contourpy==1.1.0 - # via matplotlib -cycler==0.11.0 - # via matplotlib -dill==0.3.7 - # via - # multiprocess - # pathos -emmet-core==0.66.0 - # via mp-api -fonttools==4.42.1 - # via matplotlib -future==0.18.3 - # via uncertainties -idna==3.4 - # via requests -joblib==1.3.2 - # via pymatgen -kiwisolver==1.4.5 - # via matplotlib -latexcodec==2.0.1 - # via pybtex -matplotlib==3.7.2 - # via - # ase - # pymatgen -monty==2023.8.8 - # via - # emmet-core - # mp-api - # pymatgen -mp-api==0.35.1 - # via pymatgen -mpmath==1.3.0 - # via sympy -msgpack==1.0.5 - # via mp-api -multiprocess==0.70.15 - # via pathos -networkx==3.1 - # via pymatgen -numpy==1.24.4 - # via - # SMACT (setup.py) - # ase - # contourpy - # matplotlib - # pandas - # pymatgen - # scipy - # spglib -packaging==23.1 - # via - # matplotlib - # plotly -palettable==3.3.3 - # via pymatgen -pandas==2.0.3 - # via - # SMACT (setup.py) - # pymatgen -pathos==0.3.1 - # via SMACT (setup.py) -pillow==10.0.1 - # via matplotlib -plotly==5.16.1 - # via pymatgen -pox==0.3.3 - # via pathos -ppft==1.7.6.7 - # via pathos -pybtex==0.24.0 - # via - # emmet-core - # pymatgen -pydantic==1.10.13 - # via - # emmet-core - # pymatgen -pymatgen==2023.7.20 - # via - # SMACT (setup.py) - # emmet-core - # mp-api -pyparsing==3.0.9 - # via matplotlib -python-dateutil==2.8.2 - # via - # matplotlib - # pandas -pytz==2023.3 - # via pandas -pyyaml==6.0.1 - # via pybtex -requests==2.31.0 - # via - # mp-api - # pymatgen -ruamel-yaml==0.17.32 - # via pymatgen -ruamel-yaml-clib==0.2.7 - # via ruamel-yaml -scipy==1.10.1 - # via - # SMACT (setup.py) - # ase - # pymatgen -six==1.16.0 - # via - # latexcodec - # pybtex - # python-dateutil -spglib==2.0.2 - # via - # SMACT (setup.py) - # emmet-core - # pymatgen -sympy==1.12 - # via pymatgen -tabulate==0.9.0 - # via pymatgen -tenacity==8.2.3 - # via plotly -tqdm==4.66.1 - # via pymatgen -typing-extensions==4.7.1 - # via - # emmet-core - # mp-api - # pydantic -tzdata==2023.3 - # via pandas -uncertainties==3.1.7 - # via pymatgen -urllib3==2.0.7 - # via requests - -# The following packages are considered to be unsafe in a requirements file: -# setuptools +# +# This file is autogenerated by pip-compile with Python 3.10 +# by the following command: +# +# pip-compile +# +ase==3.22.1 + # via SMACT (setup.py) +certifi==2023.11.17 + # via requests +charset-normalizer==3.3.2 + # via requests +contourpy==1.2.0 + # via matplotlib +cycler==0.12.1 + # via matplotlib +dill==0.3.7 + # via + # multiprocess + # pathos +fonttools==4.46.0 + # via matplotlib +future==0.18.3 + # via uncertainties +idna==3.6 + # via requests +joblib==1.3.2 + # via pymatgen +kiwisolver==1.4.5 + # via matplotlib +latexcodec==2.0.1 + # via pybtex +matplotlib==3.8.2 + # via + # ase + # pymatgen +monty==2023.11.3 + # via pymatgen +mpmath==1.3.0 + # via sympy +multiprocess==0.70.15 + # via pathos +networkx==3.2.1 + # via pymatgen +numpy==1.26.2 + # via + # SMACT (setup.py) + # ase + # contourpy + # matplotlib + # pandas + # pymatgen + # scipy + # spglib +packaging==23.2 + # via + # matplotlib + # plotly +palettable==3.3.3 + # via pymatgen +pandas==2.1.3 + # via + # SMACT (setup.py) + # pymatgen +pathos==0.3.1 + # via SMACT (setup.py) +pillow==10.1.0 + # via matplotlib +plotly==5.18.0 + # via pymatgen +pox==0.3.3 + # via pathos +ppft==1.7.6.7 + # via pathos +pybtex==0.24.0 + # via pymatgen +pymatgen==2023.11.12 + # via SMACT (setup.py) +pyparsing==3.1.1 + # via matplotlib +python-dateutil==2.8.2 + # via + # matplotlib + # pandas +pytz==2023.3.post1 + # via pandas +pyyaml==6.0.1 + # via pybtex +requests==2.31.0 + # via pymatgen +ruamel-yaml==0.18.5 + # via pymatgen +ruamel-yaml-clib==0.2.8 + # via ruamel-yaml +scipy==1.11.4 + # via + # SMACT (setup.py) + # ase + # pymatgen +six==1.16.0 + # via + # latexcodec + # pybtex + # python-dateutil +spglib==2.1.0 + # via + # SMACT (setup.py) + # pymatgen +sympy==1.12 + # via pymatgen +tabulate==0.9.0 + # via pymatgen +tenacity==8.2.3 + # via plotly +tqdm==4.66.1 + # via pymatgen +tzdata==2023.3 + # via pandas +uncertainties==3.1.7 + # via pymatgen +urllib3==2.1.0 + # via requests From ec1444bc74b4ab2462732b8b51ad60317b3f1933 Mon Sep 17 00:00:00 2001 From: Anthony Onwuli <30937913+AntObi@users.noreply.github.com> Date: Thu, 7 Dec 2023 21:12:47 +0000 Subject: [PATCH 56/56] Remove pip install from requirements in ci.yml --- .github/workflows/ci.yml | 1 - 1 file changed, 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 0aa4e733..23aa4321 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -32,7 +32,6 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip wheel setuptools - pip install -r requirements.txt pip install -e . pip install pytest-cov - name: Run tests and collect coverage