Source code for ase2sprkkr.sprkkr.atomic_types

"""Atomic could be placed at the atomic site."""

from ..common.decorators import cached_property
import copy
from .radial import RadialPotential, RadialCharge
from .moments import Moments
from typing import Dict
import numpy as np
from ase.data import atomic_numbers, chemical_symbols


_UNSET = object()


[docs] class AtomicType: """Atomic type represent a type of atom, that could be placed at the atomic site. It can be either a real chemical element, or vacuum pseudoelement. It also determine the number of electrons and valence electrons. """
[docs] @classmethod def to_atomic_type(cls, value, for_mesh=None): if isinstance(value, cls): return value.for_mesh(for_mesh) return cls(value, mesh=for_mesh)
[docs] @cached_property def mendeleev(self): """Optional detailed elemental metadata from the shared provider.""" from ..physics.atomic_data import mendeleev_element return mendeleev_element(self.atomic_number)
[docs] def __init__( self, symbol, atomic_number=None, n_core=None, n_valence=None, n_semicore=None, n_electrons=None, mesh=None ): """ Parameters ---------- symbol: str or int Chemical symbol, e.g. Fe, N, .... If int is given, attempt to guess the symbol using third party library is done atomic_number: int Atomic number If it's zero, an attempt to guess it from the chemical symbol is done. n_core: int Number of core electrons If it's zero, an attempt to guess it from the chemical symbol/atomic number is done. n_valence: int Number of valence electrons If it's zero, an attempt to guess it from the chemical symbol/atomic_number is done. n_semicore: int Number of semicore electrons If it's zero, an attempt to guess it from the chemical symbol/atomic_number is done. n_electrons: int """ if isinstance(symbol, (int, np.int64)): if atomic_number is not None and atomic_number != symbol: raise ValueError(f"Number of electrons in symbol ({symbol}) and atomic_number ({atomic_number}) differ") atomic_number = int(symbol) symbol = None else: symbol = symbol atomic_number = None if atomic_number is None else int(atomic_number) if atomic_number is None and symbol is None: raise ValueError("Unknown atomic type") if symbol and "_" in symbol: symbol = symbol.split("_", 1)[0] if symbol == "Vc" or atomic_number == 0 or (symbol == "X" and atomic_number is None): self._symbol = "Vc" self._atomic_number = 0 else: if symbol is None: if atomic_number < 1 or atomic_number >= len(chemical_symbols): raise ValueError(f"Unknown atomic number: {atomic_number}") self._atomic_number = atomic_number self._symbol = chemical_symbols[atomic_number] else: self._symbol = symbol try: self._atomic_number = atomic_number if atomic_number is not None else atomic_numbers[symbol] except KeyError as exc: raise ValueError(f"Unknown chemical element: {symbol!r}") from exc self._n_electrons = n_electrons self._n_valence = n_valence self._n_core = n_core self._n_semicore = n_semicore self._potential = None self._charge = None self._moments = None self._mesh = mesh self.magnetisation = np.zeros(3) self._check_n_electrons()
@property def mesh(self): return self._mesh @mesh.setter def mesh(self, mesh): if self._mesh is mesh: return self._mesh = mesh if self.potential: self.potential.mesh = mesh if self.charge: self.charge.mesh = mesh
[docs] def _check_n_electrons( self, *, n_core=_UNSET, n_valence=_UNSET, n_semicore=_UNSET, n_electrons=_UNSET, ): n_core = self._n_core if n_core is _UNSET else n_core n_valence = self._n_valence if n_valence is _UNSET else n_valence n_semicore = self._n_semicore if n_semicore is _UNSET else n_semicore n_electrons = self._n_electrons if n_electrons is _UNSET else n_electrons if ( n_core is not None and n_valence is not None and n_semicore is not None and n_electrons is not None and n_core + n_valence + n_semicore != n_electrons ): raise ValueError(f"""The following atom setup is inconsistent: n_electrons: {n_electrons}, n_core: {n_core}, n_valence: {n_valence}, n_semicore: {n_semicore}""")
@property def atomic_number(self): return self._atomic_number
[docs] def _clear_symbol_cache(self): try: del self.mendeleev except (AttributeError, KeyError): pass try: del self.atomic_number except (AttributeError, KeyError): pass try: del self.symbol except (AttributeError, KeyError): pass self._n_core = None self._n_semicore = None self._n_valence = None self._n_electrons = None
@atomic_number.setter def atomic_number(self, v): v = int(v) if v < 0 or v >= len(chemical_symbols): raise ValueError(f"Unknown atomic number: {v}") self._atomic_number = v self._clear_symbol_cache() self._symbol = chemical_symbols[v] if v else "Vc" @property def symbol(self): return self._symbol @symbol.setter def symbol(self, v): self._symbol = v self._atomic_number = None self._clear_symbol_cache() try: self._atomic_number = atomic_numbers[v] if v not in ["X", "Vc"] else 0 except KeyError as exc: raise ValueError(f"Unknown chemical element: {v!r}") from exc @property def n_electrons(self): if self._n_electrons is not None: return self._n_electrons if self._n_valence is not None and self._n_core is not None and self._n_semicore is not None: return self._n_valence + self._n_core + self._n_semicore return self.atomic_number @n_electrons.setter def n_electrons(self, v): self._check_n_electrons(n_electrons=v) self._n_electrons = v if self._potential: self._potential.z = v @property def n_valence(self): if self._n_valence is not None: return self._n_valence if self._n_core is not None: return self.n_electrons - self._n_core if self.n_electrons == 0: return 0 from ..physics.atomic_data import valence_electrons return valence_electrons(self.symbol) @n_valence.setter def n_valence(self, v): self._check_n_electrons(n_valence=v) self._n_valence = v @property def n_core(self): if self._n_core is not None: return self._n_core return self.n_electrons - self.n_valence - self.n_semicore @n_core.setter def n_core(self, v): self._check_n_electrons(n_core=v) self._n_core = v @property def n_semicore(self): if self._n_semicore is not None: return self._n_semicore if self._n_core is not None and self._n_valence is not None: return self.n_electrons - self._n_core - self._n_valence return 0 @n_semicore.setter def n_semicore(self, v): self._check_n_electrons(n_semicore=v) self._n_semicore = v def __repr__(self): return f"({self.atomic_number})" if self.symbol == "X" else self.symbol def __str__(self): return self.__repr__()
[docs] def to_tuple(self): return (self.symbol, self.n_electrons, self.n_core, self.n_valence, self.n_semicore)
[docs] def is_vacuum(self): return self.atomic_number == 0
@property def potential(self): """The radial potential data of the site""" return self._potential @potential.setter def potential(self, value): if value is None: self._potential = None return if not isinstance(value, RadialPotential): self._potential = RadialPotential(value, self._mesh, self.n_electrons) elif value.z is not None: self._potential = value.copy(self.mesh) self._potential.z = self._n_electrons else: self._potential = value self._potential.z = self._n_electrons @property def charge(self): """The radial charge data of the site""" return self._charge @charge.setter def charge(self, value): if value is None: self._charge = None return if not isinstance(value, RadialCharge): self._charge = RadialCharge(value, self.mesh) else: self._charge = value.for_mesh(self.mesh) @property def moments(self): """The moments data of the site""" return self._moments @moments.setter def moments(self, value): if not isinstance(value, Moments): value = Moments(*value) self._moments = value
[docs] def for_mesh(self, mesh): """Return copy for a given mesh""" if mesh is None: return self smesh = self.mesh if smesh is mesh: return self if smesh is None: self.mesh = mesh return self return self.copy(mesh)
[docs] def copy(self, for_mesh=None): """Return an independent copy, optionally remeshed to ``for_mesh``.""" out = copy.copy(self) target_mesh = self.mesh if for_mesh is None else for_mesh out._mesh = target_mesh out._potential = self.potential.copy(target_mesh) if self.potential is not None else None out._charge = self.charge.copy(target_mesh) if self.charge is not None else None out._moments = self.moments.copy() if self.moments is not None else None out.magnetisation = self.magnetisation.copy() return out
[docs] def remesh(self, mesh, map: "Dict[AtomicType,AtomicType]"): """Return the copy for a given mesh, updating the informations in the map of the old: new objects, so the remeshed items will share the meshes.""" if self in map: return map[self] out = map[self] = self.for_mesh(mesh) return out
[docs] def reset(self): """Remove data produced by an SPR-KKR calculation.""" self._potential = None self._charge = None self._moments = None
[docs] def has_converged_data(self): return self.potential and self.charge and self.moments