raddefects 0.1.3__tar.gz

raddefects-0.1.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Alexander Hauck
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

raddefects-0.1.3/PKG-INFO

@@ -0,0 +1,48 @@
+Metadata-Version: 2.1
+Name: raddefects
+Version: 0.1.3
+Summary: Framework to analyze properties of radiation-induced defects in semiconductor materials from first principles.
+Author-email: Alexander Hauck <ash5615@psu.edu>
+License: MIT License
+        
+        Copyright (c) 2024 Alexander Hauck
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://radDefects.readthedocs.io/en/latest/
+Project-URL: Repository, https://github.com/hauck-as/radDefects
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: importlib-metadata; python_version < "3.12"
+Requires-Dist: numpy
+Requires-Dist: pymatgen
+Requires-Dist: mp-api
+Requires-Dist: vise
+Requires-Dist: pydefect
+Requires-Dist: sumo
+Requires-Dist: pymatgen-analysis-defects
+Requires-Dist: niet
+
+# radDefects
+Framework to analyze properties of radiation-induced defects in semiconductor materials from first principles.

raddefects-0.1.3/README.md

@@ -0,0 +1,2 @@
+# radDefects
+Framework to analyze properties of radiation-induced defects in semiconductor materials from first principles.

raddefects-0.1.3/docs/conf.py

@@ -0,0 +1,82 @@
+# Configuration file for the Sphinx documentation builder.
+# Templated from both RTD tutorial and doped by SMTG-Bham.
+
+# -- Project information
+
+project = 'radDefects'
+copyright = '2024, Alexander S. Hauck'
+author = 'Alexander S. Hauck'
+
+release = '0.1'
+version = '0.1.3'
+
+# -- General configuration
+
+extensions = [
+    'sphinx.ext.duration',
+    'sphinx.ext.doctest',
+    'sphinx.ext.autodoc',
+    'sphinx.ext.autosummary',
+    'sphinx.ext.intersphinx',
+    'sphinx.ext.coverage',
+    'sphinx.ext.napoleon',
+    'sphinx.ext.mathjax',
+    'sphinx.ext.viewcode',
+    'sphinx.ext.autosectionlabel',
+    'sphinx_book_theme',
+]
+
+intersphinx_mapping = {
+    'python': ('https://docs.python.org/3/', None),
+    'sphinx': ('https://www.sphinx-doc.org/en/master/', None),
+}
+intersphinx_disabled_domains = ['std']
+
+templates_path = ['_templates']
+
+# -- Options for HTML output
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+html_theme = 'sphinx_book_theme'
+
+# The name of an image file (relative to this directory) to place at the top
+# of the sidebar.
+# html_logo = "rad-defects-logo.png"
+html_title = "radDefects"
+
+# If true, SmartyPants will be used to convert quotes and dashes to
+# typographically correct entities.
+html_use_smartypants = True
+
+# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
+# html_show_sphinx = True
+
+html_theme_options = {
+    "repository_url": "https://github.com/hauck-as/radDefects",
+    "github_repo": "https://github.com/hauck-as/radDefects",
+    "github_button": True,
+    "github_user": "hauck-as", # Username
+    "description": "Framework to analyze properties of radiation-induced defects in semiconductor materials from first principles.",
+    "repository_branch": "main",
+    "path_to_docs": "docs",
+    "use_repository_button": True,
+    "home_page_in_toc": True,
+    "launch_buttons": {
+        "binderhub_url": "https://mybinder.org",
+        "colab_url": "https://colab.research.google.com",
+    },
+}
+
+# Adding “Edit Source” links on your Sphinx theme
+html_context = {
+    "display_github": True, # Integrate GitHub
+    "github_user": "hauck-as", # Username
+    "github_repo": "radDefects", # Repo name
+    "github_version": "main", # Version
+    "conf_py_path": "/docs/", # Path in the checkout to the docs root
+}
+
+# -- Options for EPUB output
+epub_show_urls = 'footnote'

raddefects-0.1.3/pyproject.toml

@@ -0,0 +1,41 @@
+[project]
+name = "raddefects"
+version = "0.1.3"
+authors = [
+  { name="Alexander Hauck", email="ash5615@psu.edu" },
+]
+description = "Framework to analyze properties of radiation-induced defects in semiconductor materials from first principles."
+readme = "README.md"
+license = {file = "LICENSE"}
+requires-python = ">=3.6"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "requests",
+    'importlib-metadata; python_version<"3.12"',
+    "numpy",
+    "pymatgen",
+    "mp-api",
+    "vise",
+    "pydefect",
+    "sumo",
+    "pymatgen-analysis-defects",
+    "niet"
+]
+
+[project.urls]
+Homepage = "https://radDefects.readthedocs.io/en/latest/"
+Repository = "https://github.com/hauck-as/radDefects"
+
+[project.scripts]
+cli-name = "raddefects.cli.main:main"
+
+[tool.setuptools.packages]
+find = {}  # Scan the project directory with the default parameters
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"

raddefects-0.1.3/raddefects/__init__.py

@@ -0,0 +1,10 @@
+# Copyright (c) 2024 Alexander Hauck. Distributed under the terms of the MIT License.
+
+"""
+radDefects is a Python-based framework to analyze properties of radiation-induced defects in semiconductor materials from first principles.
+"""
+
+__author__ = "Alexander Hauck"
+__copyright__ = "Copyright (C) 2024 Alexander Hauck"
+__license__ = "MIT License"
+__version__ = "0.0.1"

raddefects-0.1.3/raddefects/analysis/transition_levels.py

@@ -0,0 +1,104 @@
+"""Analysis for charge transition levels within the pydefect format."""
+import logging
+from typing import TYPE_CHECKING, Optional
+
+import os
+import glob
+from pathlib import Path
+import json
+from monty.serialization import dumpfn, loadfn
+from monty.json import MSONable, MontyEncoder, MontyDecoder
+
+import re
+import pprint
+
+import numpy as np
+import pandas as pd
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+import plotly.graph_objects as go
+import plotly.express as px
+from plotly.subplots import make_subplots
+import plotly.io as pio
+
+from pydefect.analyzer.unitcell import Unitcell
+from pydefect.analyzer.band_edge_states import BandEdgeOrbitalInfos, BandEdgeState, PerfectBandEdgeState
+from pydefect.analyzer.defect_energy import DefectEnergyInfo, ChargeEnergies, SingleChargeEnergies, CrossPoints
+from pydefect.analyzer.transition_levels import TransitionLevels, make_transition_levels
+
+# Change Plotly default template to simple white and modify for 
+pl_paper_theme = pio.templates['simple_white']
+pl_paper_theme.layout.xaxis.ticks = 'inside'
+pl_paper_theme.layout.yaxis.ticks = 'inside'
+pl_paper_theme.layout.xaxis.mirror = 'ticks'  # True | "ticks" | False | "all" | "allticks"
+pl_paper_theme.layout.yaxis.mirror = 'ticks'  # True | "ticks" | False | "all" | "allticks"
+pl_paper_theme.layout.font.size = 32
+# pl_paper_theme.layout.xaxis.title.standoff = 20
+pl_paper_theme.layout.xaxis.title.font.size = 44
+pl_paper_theme.layout.xaxis.tickfont.size = 36
+pl_paper_theme.layout.yaxis.title.standoff = 24
+pl_paper_theme.layout.yaxis.title.font.size = 28
+#pl_paper_theme.layout.coloraxis.colorbar.title.standoff = 20
+pio.templates.default = pl_paper_theme
+
+
+def generate_transition_level_diagram(transition_levels, im_write=False, im_name='transition_levels.png'):
+    """
+    Given a TransitionLevels object from pydefect, plots a charge transition level diagram
+    showing the Fermi energy levels and which charges for each defect calculated.
+    """
+    # add capability to remove defects without transition levels or that are not of interest
+    # ex. transition_levels.transition_levels.pop(3)
+    defects_list = [defect.name for defect in transition_levels.transition_levels]
+    
+    fig = go.Figure()
+    
+    for i in range(len(defects_list)):
+        if len(transition_levels.transition_levels[i].fermi_levels) > 0:
+            for j in range(len(transition_levels.transition_levels[i].fermi_levels)):
+                defect_fermi_levels = transition_levels.transition_levels[i].fermi_levels
+                defect_fermi_levels.sort()
+                fig.add_trace(go.Scatter(x=[transition_levels.transition_levels[i].name for j in range(len(defect_fermi_levels))],
+                                         y=[defect_fermi_levels[j] for j in range(len(defect_fermi_levels))],
+                                         text=[f'{transition_levels.transition_levels[i].charges[j][0]:+}/{transition_levels.transition_levels[i].charges[j][1]:+}' for j in range(len(defect_fermi_levels))],
+                                         mode='markers+text',
+                                         marker=dict(symbol='line-ew-open',
+                                                     size=28,
+                                                     color=px.colors.qualitative.Plotly[i],
+                                                     line=dict(width=6)
+                                                    )
+                                        ))
+        else:
+            fig.add_trace(go.Scatter(x=[transition_levels.transition_levels[i].name],
+                                     y=[0.],
+                                     marker=dict(size=0, opacity=0)
+                                    ))
+
+    fig.update_traces(textposition='top center')
+
+    # VBM
+    fig.add_hline(y=transition_levels.supercell_vbm, line=dict(color='black', width=3, dash='dash'), annotation_text='VBM', annotation_position='bottom left')
+    fig.add_hrect(y0=transition_levels.supercell_vbm-0.2, y1=transition_levels.supercell_vbm, line_width=0, fillcolor='red', opacity=0.2)
+    
+    # CBM
+    fig.add_hline(y=transition_levels.supercell_cbm, line=dict(color='black', width=3, dash='dash'), annotation_text='CBM', annotation_position='top left')
+    fig.add_hrect(y0=transition_levels.supercell_cbm, y1=transition_levels.supercell_cbm+0.2, line_width=0, fillcolor='blue', opacity=0.2)
+
+    fig.update_layout(xaxis_title=r'Defects',
+                      yaxis_title=r'$\Huge{E_{F} \; [eV]}$',
+                      xaxis_type='category',
+                      yaxis_showticklabels=False,
+                      showlegend=False,
+                      margin=dict(l=20, r=20, t=20, b=20),
+                      autosize=False, width = 850, height = 650
+                     )
+
+    fig.show()
+    
+    if im_write == True:
+        fig.write_image(im_name, scale=1)
+    elif im_write == False:
+        pass
+    
+    return
+

raddefects-0.1.3/raddefects/cli/__init__.py

@@ -0,0 +1,5 @@
+# Copyright (c) 2024 Alexander Hauck. Distributed under the terms of the MIT License.
+
+"""
+radDefects package containing command line interfaces.
+"""

raddefects-0.1.3/raddefects/core.py

@@ -0,0 +1,253 @@
+"""Core functions and classes for analyzing rad-induced defects from VASP."""
+import logging
+from typing import TYPE_CHECKING, Optional
+import importlib.resources as ilr
+
+import os
+import glob
+from pathlib import Path
+import shutil
+import json
+from monty.serialization import dumpfn, loadfn
+from monty.json import MSONable, MontyEncoder, MontyDecoder
+
+import subprocess
+import re
+import pprint
+
+import math as m
+from fractions import Fraction
+import random as rand
+
+import numpy as np
+import pandas as pd
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+
+from pymatgen.io.vasp.sets import VaspInputSet, Poscar
+from pymatgen.io.vasp.outputs import Locpot, Outcar, Vasprun
+from pymatgen.core import Structure, Lattice
+from pymatgen.io.vasp.sets import MPRelaxSet
+from pymatgen.symmetry.analyzer import *
+from pymatgen.analysis.defects.core import DefectComplex, Substitution, Vacancy
+from pymatgen.analysis.defects.finder import DefectSiteFinder
+from mp_api.client import MPRester
+
+from pydefect.analyzer.unitcell import Unitcell
+from pydefect.analyzer.band_edge_states import BandEdgeOrbitalInfos, BandEdgeState, PerfectBandEdgeState
+from pydefect.analyzer.calc_results import CalcResults
+from pydefect.analyzer.defect_energy import DefectEnergyInfo
+from pydefect.input_maker.defect_entry import DefectEntry
+from pydefect.corrections.efnv_correction import ExtendedFnvCorrection
+
+from doped.analysis import DefectParser, DefectsParser
+
+# pydefect file structure
+base_path = os.getcwd()
+cpd_path, defects_path, unitcell_path, band_path, diele_path, dos_path, struc_opt_path = os.path.relpath('cpd'), os.path.relpath('defect'), os.path.relpath('unitcell'), os.path.relpath('unitcell/band'), os.path.relpath('unitcell/dielectric'), os.path.relpath('unitcell/dos'), os.path.relpath('unitcell/structure_opt')
+pydefect_paths = [cpd_path, defects_path, unitcell_path, band_path, diele_path, dos_path, struc_opt_path]
+
+
+# create pydefect file structure
+def create_pydefect_file_structure():
+    os.makedirs([os.path.join(base_path, i) for i in pydefect_paths])
+    return
+
+
+# maybe define class for defective supercells
+# get defect and perfect supercells on definition
+def get_mpid_from_supercell(perfect_poscar_path):
+    """
+    Given a path for a perfect supercell POSCAR, determine the
+    characteristics of the unitcell and fetches from the
+    Materials Project.
+    """
+    # read POSCAR files with pymatgen and determine unitcell from perfect supercell
+    perfect_pos = Poscar.from_file(perfect_poscar_path)
+    unitcell_strc = perfect_pos.structure.get_primitive_structure()
+    unitcell_spg = SpacegroupAnalyzer(unitcell_strc)
+    
+    # query MPD to get material ID matching perfect supercell structure
+    # API key is parsed via .pmgrc.yaml
+    with MPRester() as mpr:
+        docs = mpr.materials.summary.search(
+            elements=map(str, unitcell_strc.elements),
+            num_elements=len(unitcell_strc.elements),
+            num_sites=len(unitcell_strc.sites),
+            spacegroup_symbol=unitcell_spg.get_space_group_symbol(),
+            fields=['material_id', 'composition', 'symmetry', 'band_gap', 'structure']
+        )
+        mpid_dict = {doc.material_id: [doc.composition, doc.symmetry, doc.band_gap, doc.structure] for doc in docs}
+        if len(mpid_dict.keys()) == 1:
+            unitcell_mpid = list(mpid_dict.keys())[0]
+            unitcell_info = {
+                'mpid': unitcell_mpid,
+                'composition': mpid_dict[unitcell_mpid][0],
+                'symmetry': mpid_dict[unitcell_mpid][1],
+                'band_gap': mpid_dict[unitcell_mpid][2],
+                'structure': mpid_dict[unitcell_mpid][3]
+            }
+        else:
+            raise UserWarning('Multiple matching structures were found.')
+    return unitcell_info
+
+
+# band edge orbital infos gives fermi level, states below should be occupied and above should be unoccupied
+# interested in occupation of states between VBM & CBM: gap states
+def find_gap_states(pbes_path, beois_path):
+    """
+    Given a path to the perfect band edge state and band edge orbital
+    info JSON files, determine VBM & CBM energies as well as orbital
+    energies and occupations from pydefect.
+    """
+    pbes, beois = PerfectBandEdgeState.from_dict(json.load(open(pbes_path, 'r'))), BandEdgeOrbitalInfos.from_dict(json.load(open(beois_path, 'r')))
+    e_vbm, e_cbm = pbes.vbm_info.orbital_info.energy, pbes.cbm_info.orbital_info.energy
+
+    for s in range(len(beois.orbital_infos)):    # spin up/down channels
+        for k in range(len(beois.orbital_infos[s])):    # kpt idx
+            for b in range(len(beois.orbital_infos[s][k])):    # band idx
+                beois_ens, beois_occs = beois.orbital_infos[s][k][b].energy, beois.orbital_infos[s][k][b].occupation
+
+# maybe make a GapState class that incorporates the Orbital Infos plus the s/k/b for the given gap state
+# gap state defined as energy between e_vbm and e_cbm
+# gap state occupancy is of interest
+# use gap state to determine charge localization?
+
+
+def get_plnr_avg_only(
+    defect_locpot: Locpot,
+    bulk_locpot: Locpot,
+    lattice: Optional[Lattice] = None
+):
+    """Calculates the planar average electrostatic potential.
+    Based on FNV correction function from pymatgen.analysis.defects.
+
+    Args:
+        defect_locpot:
+            Locpot of defect
+        bulk_locpot:
+            Locpot of bulk
+        lattice:
+            Lattice of the defect supercell. If None, then uses the lattice of the
+            defect_locpot.
+
+    Returns:
+        Plotting data for the planar average electrostatic potential.
+            ```
+            plot_plnr_avg(result.metadata[0], title="Lattice Direction 1")
+            plot_plnr_avg_only(plnr_avg_data['plot_data'][direction]['pot_plot_data'], ax=axs[direction], title=axis_label_dict[direction])
+            ```
+    """
+
+    if isinstance(defect_locpot, Locpot):
+        list_axis_grid = [*map(defect_locpot.get_axis_grid, [0, 1, 2])]
+        list_defect_plnr_avg_esp = [
+            *map(defect_locpot.get_average_along_axis, [0, 1, 2])
+        ]
+        lattice_ = defect_locpot.structure.lattice.copy()
+        if lattice is not None and lattice != lattice_:
+            raise ValueError(
+                "Lattice of defect_locpot and user provided lattice do not match."
+            )
+        lattice = lattice_
+    elif isinstance(defect_locpot, dict):
+        defect_locpot_ = {int(k): v for k, v in defect_locpot.items()}
+        list_defect_plnr_avg_esp = [defect_locpot_[i] for i in range(3)]
+        list_axis_grid = [
+            *map(
+                np.linspace,
+                [0, 0, 0],
+                lattice.abc,
+                [len(i) for i in list_defect_plnr_avg_esp],
+            )
+        ]
+    else:
+        raise ValueError("defect_locpot must be of type Locpot or dict")
+
+    # TODO this can be done with regridding later
+    if isinstance(bulk_locpot, Locpot):
+        list_bulk_plnr_avg_esp = [*map(bulk_locpot.get_average_along_axis, [0, 1, 2])]
+    elif isinstance(bulk_locpot, dict):
+        bulk_locpot_ = {int(k): v for k, v in bulk_locpot.items()}
+        list_bulk_plnr_avg_esp = [bulk_locpot_[i] for i in range(3)]
+    else:
+        raise ValueError("bulk_locpot must be of type Locpot or dict")
+
+    plot_data = dict()
+
+    for x, pureavg, defavg, axis in zip(
+        list_axis_grid, list_bulk_plnr_avg_esp, list_defect_plnr_avg_esp, [0, 1, 2]
+    ):
+        # log plotting data:
+        metadata = dict()
+        metadata["pot_plot_data"] = {
+            "x": x,
+            "dft_diff": np.array(defavg) - np.array(pureavg)
+        }
+        
+        plot_data[axis] = metadata
+
+    corr_metadata = {"plot_data": plot_data}
+
+    return corr_metadata
+
+
+def plot_plnr_avg_only(plot_data, title=None, ax=None, style_file=None):
+    """
+    Plots exclusively the planar-averaged electrostatic potential.
+
+    Original code templated from the original PyCDT and new
+    pymatgen.analysis.defects implementations as plot_FNV in doped.
+    Functionality for plotting only the planar-averaged electrostatic
+    potential is kept.
+
+    Args:
+         plot_data (dict):
+            Dictionary of Freysoldt correction metadata to plot
+            (i.e. defect_entry.corrections_metadata["plot_data"][axis] where
+            axis is one of [0, 1, 2] specifying which axis to plot along (a, b, c)).
+         title (str): Title for the plot. Default is no title.
+         ax (matplotlib.axes.Axes): Axes object to plot on. If None, makes new figure.
+         style_file (str):
+            Path to a mplstyle file to use for the plot. If None (default), uses
+            the default doped style (from doped/utils/doped.mplstyle).
+    """
+
+    x = plot_data["x"]
+    dft_diff = plot_data["dft_diff"]
+
+    style_file = style_file or f"{ilr.files('doped')}/utils/doped.mplstyle"
+    plt.style.use(style_file)  # enforce style, as style.context currently doesn't work with jupyter
+    with plt.style.context(style_file):
+        if ax is None:
+            plt.close("all")  # close any previous figures
+            fig, ax = plt.subplots()
+        (line1,) = ax.plot(x, dft_diff, c="red", label=r"$\Delta$(Locpot)")
+        leg1 = ax.legend(handles=[line1], loc=9)  # middle top legend
+        ax.add_artist(leg1)  # so isn't overwritten with later legend call
+
+        ax.set_xlim(round(x[0]), round(x[-1]))
+        ymin = min(*dft_diff)
+        ymax = max(*dft_diff)
+        ax.set_ylim(-0.2 + ymin, 0.2 + ymax)
+        ax.set_xlabel(r"Distance along axis ($\AA$)")
+        ax.set_ylabel("Potential (V)")
+        ax.axhline(y=0, linewidth=0.2, color="black")
+        if title is not None:
+            ax.set_title(str(title))
+        ax.set_xlim(0, max(x))
+
+        return ax
+    
+
+def plot_plnr_avg_abc(plot_data, title=None, ax=None, style_file=None):
+    axis_label_dict = {0: r"$a$-axis", 1: r"$b$-axis", 2: r"$c$-axis"}
+    fig, axs = plt.subplots(1, 3, sharey=True, figsize=(12, 3.5), dpi=600)
+    for direction in range(3):
+        plot_plnr_avg_only(
+            plot_data['plot_data'][direction]['pot_plot_data'],
+            ax=axs[direction],
+            title=axis_label_dict[direction]
+        )
+    return
+

raddefects-0.1.3/raddefects/sxda/analysis.py

@@ -0,0 +1,162 @@
+"""Analysis for sxdefectalign calculations using pydefect, doped, and radDefects tools."""
+import logging
+from typing import TYPE_CHECKING, Optional
+
+import os
+import glob
+from pathlib import Path
+import json
+from monty.serialization import dumpfn, loadfn
+from monty.json import MSONable, MontyEncoder, MontyDecoder
+
+import re
+import pprint
+
+import numpy as np
+import pandas as pd
+
+from pydefect.analyzer.unitcell import Unitcell
+from pydefect.analyzer.band_edge_states import BandEdgeOrbitalInfos, BandEdgeState, PerfectBandEdgeState
+from pydefect.analyzer.defect_energy import DefectEnergyInfo, ChargeEnergies, SingleChargeEnergies, CrossPoints
+from pydefect.analyzer.transition_levels import TransitionLevels, make_transition_levels
+
+from raddefects.sxda.io import parse_sxda_vatoms
+
+
+def sxda_transition_levels(base_path=os.getcwd(), chg_offset=0):
+    """
+    Using sxdefectalign calculations within the pydefect structure, calculate
+    charge transition levels.
+    """
+    # use unitcell.yaml and perfect_band_edge_state.json files to get CBM/VBM info
+    unitcell_yaml = os.path.join(base_path, 'unitcell', 'unitcell.yaml')
+    defect_path=os.path.join(base_path, 'defect')
+    perfect_band_edge_state_json = os.path.join(defect_path, 'perfect', 'perfect_band_edge_state.json')
+    uc_info, pbes = Unitcell.from_yaml(unitcell_yaml), loadfn(perfect_band_edge_state_json)
+    cbm, supercell_vbm, supercell_cbm = uc_info.cbm, pbes.vbm_info.energy, pbes.cbm_info.energy
+    cbm -= supercell_vbm
+    supercell_cbm -= supercell_vbm
+    supercell_vbm -= supercell_vbm
+    
+    # gather pydefect defect directories
+    defect_paths = glob.glob(os.path.join(defect_path, '*_*/'), recursive=True)
+    
+    # empty dictionaries for sxda charge energies and sxda cross points
+    sxda_single_charge_energies = {}
+    sxda_charge_energies = {}
+    sxda_cross_point_dicts = {}
+    
+    for defect_dir in defect_paths:
+        # get defect type and charge from defect directory
+        defect = os.path.basename(os.path.dirname(defect_dir))
+        defect_type, defect_chg = '_'.join(defect.split('_')[0:2]), int(defect.split('_')[2])
+        
+        # add defect type to single charge energies dictionary
+        if defect_type not in sxda_single_charge_energies:
+            sxda_single_charge_energies.update({defect_type: []})
+        
+        # get defect.sxda filename
+        if 'FP' in defect_type:
+            if defect_chg > 0:
+                vac_chg, int_chg = chg_offset, defect_chg+chg_offset
+            elif defect_chg < 0:
+                vac_chg, int_chg = defect_chg-chg_offset, chg_offset
+            elif defect_chg == 0:
+                if float(chg_offset) == 0.:
+                    vac_chg, int_chg = 0., 0.
+                else:
+                    vac_chg, int_chg = -1*(chg_offset/2.), chg_offset/2.
+            else:
+                raise ValueError('Defect charge must be a valid number.')
+
+            sxda_outfile = os.path.join(defect_dir, f'{defect}_qv{vac_chg:.2f}qi{int_chg:.2f}.sxda')
+        else:
+            sxda_outfile = os.path.join(defect_dir, f'{defect}.sxda')
+        
+        # compare first line of defect.sxda with defect type and charge
+        with open(sxda_outfile) as f:
+            sxda_lines = f.readlines()
+        title_line, correction_line = sxda_lines[0].strip('\n'), sxda_lines[-1]
+
+        # check if defect type is correct
+        sxda_defect_type, sxda_defect_chg = title_line.split(',')[0], int(title_line.split(',')[1].split(' = ')[1])
+        if (sxda_defect_type != defect_type) or (sxda_defect_chg != defect_chg):
+            raise ValueError('Defect type/charge does not match between pydefect and sxdefectalign')
+        
+        # ensure correction line contains the correction and extract correction value
+        if 'correction' in correction_line:
+            sxda_corr = float(re.findall(r'\d[.,]?\d*', correction_line)[0])
+        else:
+            continue
+        
+        bes = loadfn(os.path.join(defect_dir, 'band_edge_orbital_infos.json'))
+        fermi_level = bes.fermi_level - supercell_vbm
+        
+        dei = DefectEnergyInfo.from_yaml(os.path.join(defect_dir, 'defect_energy_info.yaml'))
+        formation_en = dei.defect_energy.energy(with_correction=False)
+        formation_en_sxda = formation_en + sxda_corr
+        
+        # add charge and formation energies to single charge energies dictionary
+        sxda_single_charge_energies[defect_type] += [(int(defect_chg), formation_en_sxda)]
+        
+    for d_type in sxda_single_charge_energies:
+        sxda_charge_energies.update({d_type: SingleChargeEnergies(sxda_single_charge_energies[d_type])})
+    sxda_energies = ChargeEnergies(sxda_charge_energies, e_min=0., e_max=cbm)
+    
+    sxda_cross_point_dicts = sxda_energies.cross_point_dicts
+
+    # create TransitionLevels object
+    sxda_tls = make_transition_levels(
+        cross_point_dicts=sxda_cross_point_dicts,
+        cbm=cbm,
+        supercell_vbm=supercell_vbm,
+        supercell_cbm=supercell_cbm
+    )
+    
+    return sxda_tls
+
+
+def atomic_potential_convergence(base_path=os.getcwd()):
+    """
+    Calculates the convergence for atomic site potential data from sxdefectalign
+    calculations in terms of averages and standard deviations within the sampling
+    region.
+    """
+    # defect directory
+    defect_path=os.path.join(base_path, 'defect')
+    
+    # gather pydefect defect directories
+    defect_paths = glob.glob(os.path.join(defect_path, '*_*/'), recursive=True)
+    
+    # empty dictionary for alignment averages and standard deviations
+    alignment_dict = {}
+    
+    for defect_dir in defect_paths:
+        # get defect type and charge from defect directory
+        defect = os.path.basename(os.path.dirname(defect_dir))
+        defect_type, defect_chg = '_'.join(defect.split('_')[0:2]), int(defect.split('_')[2])
+        
+        # use parse_sxda_vatoms on directory
+        vatoms = parse_sxda_vatoms(defect_dir)
+    
+        # use lattice parameters for defect region radius or use pydefect correction.json file
+        if os.path.isfile(os.path.join(defect_dir, 'correction.json')):
+            correction_json = loadfn(os.path.join(defect_dir, 'correction.json'))
+            defect_region_radius = correction_json.defect_region_radius
+        else:
+            contcar_filepath = os.path.join(filepath, 'CONTCAR')
+            contcar = Poscar.from_file(contcar_filepath)
+            abc = np.array(contcar.structure.lattice.abc)
+            abc /= 2.
+            defect_region_radius = np.min(abc)
+    
+        # alignment stats (mean, stdev) from atomic site potential dataframe with r>defect_region_radius
+        vatoms_total = pd.concat((vatoms[i] for i in vatoms.keys()))
+        vatoms_sample_region = vatoms_total.where(vatoms_total['r']>defect_region_radius)
+        alignment_average = vatoms_sample_region.loc[:, 'V_defect-V_ref-V_lr'].mean(skipna=True)
+        alignment_stdev = vatoms_sample_region.loc[:, 'V_defect-V_ref-V_lr'].std(skipna=True)
+        
+        alignment_dict.update({defect: (alignment_average, alignment_stdev)})
+    
+    return alignment_dict
+

raddefects-0.1.3/raddefects/sxda/io.py

@@ -0,0 +1,59 @@
+"""Parsing I/O for sxdefectalign calculations."""
+import logging
+from typing import TYPE_CHECKING, Optional
+from io import StringIO
+
+import os
+import glob
+from pathlib import Path
+import json
+from monty.serialization import dumpfn, loadfn
+from monty.json import MSONable, MontyEncoder, MontyDecoder
+
+import re
+import pprint
+
+import numpy as np
+import pandas as pd
+
+
+def parse_sxda_vatoms(filepath=os.getcwd()):
+    """
+    Parses sxdefectalign vAtoms.dat files.
+    
+    potential terms sxdefectalign = pydefect
+        V(long-range) = V_{PC,q}
+        V(defect)-V(ref) = V_{q/b}
+        V(defect)-V(ref)-V(long-range) = dV_{PC,q/b}
+    
+    vAtoms.dat format
+        r V(long-range) V(defect)-V(ref) V(defect)-V(ref)-V(long-range) x y z ...
+        empty lines between different species (need to include in plotting now)
+        with auto_sxda, empty lines are replaced with double empty lines to enable gnuplot index use
+    """
+    vatoms_filepath, contcar_filepath = os.path.join(filepath, 'vAtoms.dat'), os.path.join(filepath, 'CONTCAR')
+    contcar = Poscar.from_file(contcar_filepath)
+    
+    vatoms_dict = {i.symbol:'' for i in contcar.structure.elements}
+    
+    with open(vatoms_filepath, 'r') as va_dat:
+        va_dat_text = va_dat.read()
+        
+        # find double line breaks in vatoms data file string
+        idx_split = [0]
+        idx_split += re.search(r'\n\n\n', va_dat_text).span()
+        idx_split.append(len(va_dat_text))
+        
+        # create dataframes for each element's atomic site potentials
+        for i in range(int(len(idx_split)/2)):
+            atomic_site_type = contcar.structure.elements[i].symbol
+            vatoms_str = StringIO(va_dat_text[idx_split[2*i]:idx_split[2*i+1]].strip())
+            vatoms_arr = np.genfromtxt(vatoms_str)
+            vatoms_df = pd.DataFrame(
+                data=vatoms_arr,
+                columns=['r', 'V_lr', 'V_defect-V_ref', 'V_defect-V_ref-V_lr', 'x', 'y', 'z']
+            )
+            vatoms_dict.update({atomic_site_type:vatoms_df})
+    
+    return vatoms_dict
+

raddefects-0.1.3/raddefects.egg-info/PKG-INFO

@@ -0,0 +1,48 @@
+Metadata-Version: 2.1
+Name: raddefects
+Version: 0.1.3
+Summary: Framework to analyze properties of radiation-induced defects in semiconductor materials from first principles.
+Author-email: Alexander Hauck <ash5615@psu.edu>
+License: MIT License
+        
+        Copyright (c) 2024 Alexander Hauck
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://radDefects.readthedocs.io/en/latest/
+Project-URL: Repository, https://github.com/hauck-as/radDefects
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: importlib-metadata; python_version < "3.12"
+Requires-Dist: numpy
+Requires-Dist: pymatgen
+Requires-Dist: mp-api
+Requires-Dist: vise
+Requires-Dist: pydefect
+Requires-Dist: sumo
+Requires-Dist: pymatgen-analysis-defects
+Requires-Dist: niet
+
+# radDefects
+Framework to analyze properties of radiation-induced defects in semiconductor materials from first principles.

raddefects-0.1.3/raddefects.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+docs/conf.py
+raddefects/__init__.py
+raddefects/core.py
+raddefects.egg-info/PKG-INFO
+raddefects.egg-info/SOURCES.txt
+raddefects.egg-info/dependency_links.txt
+raddefects.egg-info/entry_points.txt
+raddefects.egg-info/requires.txt
+raddefects.egg-info/top_level.txt
+raddefects/analysis/transition_levels.py
+raddefects/cli/__init__.py
+raddefects/cli/main.py
+raddefects/sxda/analysis.py
+raddefects/sxda/io.py

raddefects-0.1.3/raddefects.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

raddefects-0.1.3/raddefects.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cli-name = raddefects.cli.main:main

raddefects-0.1.3/raddefects.egg-info/requires.txt

@@ -0,0 +1,12 @@
+requests
+numpy
+pymatgen
+mp-api
+vise
+pydefect
+sumo
+pymatgen-analysis-defects
+niet
+
+[:python_version < "3.12"]
+importlib-metadata

raddefects-0.1.3/raddefects.egg-info/top_level.txt

@@ -0,0 +1,3 @@
+dist
+docs
+raddefects

raddefects-0.1.3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+