pyextal.jaxMultipole.bank¶

XD data banks of Slater-type atomic wavefunctions.

Two banks ship with the package, both in the format of the XD charge-density program:

RDF_SCM: Dirac-Fock wavefunctions, He..Kr from Su & Coppens (1998) Acta Cryst. A54, 646, and Rb..Xe plus common ions from Macchi & Coppens (2001) Acta Cryst. A57, 656. 116 entries, ions included, no lanthanides.
PBE-QZ4P-ZORA: Scalar-relativistic PBE/QZ4P wavefunctions (Volkov & Macchi, unpublished) for neutral ground-state atoms H..Cf, 99 entries.

An entry is:

:ELEM  Z W  df'Mo df''Mo df'Cu df''Cu  b_n  r_atomic r_cov r_vdW
 SPH   a1 b1 ... a6 b6 c        analytical f_x(s) = sum a exp(-b s^2) + c
 SZ    zeta_1 ... zeta_12|18    single-zeta exponents, fixed orbital order
 STO   orb occ nbf  orb occ nbf ...   (occ < 0 marks valence)
 C zeta n  C zeta n ...         nbf triples per occupied orbital, in the
                                order of the STO header

with basis functions N r^(n-1) exp(-zeta r), N = (2 zeta)^(n+1/2) / sqrt((2n)!), exponents in bohr^-1. A line ending in = continues on the next one (the PBE bank’s 18-slot SZ and long STO headers).

The order of the 12 SZ slots is documented in the RDF bank header. The PBE bank adds six more without saying which; checking every one of its 99 entries against the occupied orbitals pins them to 6s 6p 5d 7s 6d 5f – each slot is non-zero only in atoms that occupy that orbital – and load_bank() re-asserts it on every load.

Core and valence¶

A bank’s occupation signs are XD’s default partition, and they are not always the one a model wants: Ti is stored 4s 2 (core) 3d -2 (valence), while Friis et al. (2004) refine Ti with 3d^2 4s^2 as valence; La in the PBE bank is 6s 2 5d -1. configure() takes the partition and the occupations explicitly, and can take the core from one entry and the valence from another.

Attributes¶

SZ_ORDER

Classes¶

`Orbital`	One occupied orbital of a bank entry.
`BankEntry`	One `:ELEM` segment.
`Shell`	A group of orbitals that share one scattering function.
`AtomConfig`	A core/valence partition of one atom.

Functions¶

`bank_path`(name)	File of a bundled bank, or `name` itself when it is a path.
`load_bank`([name])	Parses a bank.
`entry`(key[, bank])	One bank entry, by label, ignoring case (`'TI'` finds `'Ti'`).
`radial_density`(orbitals, r_bohr[, occupations, ...])	Spherical density `4 pi r^2 rho(r)` (electrons per bohr) of a set of orbitals.
`configure`(entry_or_key[, valence, occupations, ...])	Chooses the core/valence partition and the occupations of one atom.
`pair_table`(shell[, renormalize])	Fourier-Bessel weights of a shell's spherical density.
`sph_fx`(e, s)	The bank's analytical spherical form factor `sum a exp(-b s^2) + c`.

Module Contents¶

pyextal.jaxMultipole.bank.SZ_ORDER = ('1s', '2s', '3s', '4s', '2p', '3p', '4p', '3d', '4d', '4f', '5s', '5p', '6s', '6p', '5d', '7s',...¶

class pyextal.jaxMultipole.bank.Orbital¶

One occupied orbital of a bank entry.

Variables:

name (str) – '3d', '4s', …
l (int) – Angular momentum.
occ (float) – Occupation as stored, sign removed.
valence (bool) – The bank marked it valence (negative occupation).
coef (np.ndarray) – Expansion coefficients C_k.
zeta (np.ndarray) – Exponents, bohr^-1.
n (np.ndarray) – Principal quantum numbers of the basis functions.

name: str¶

l: int¶

occ: float¶

valence: bool¶

coef: numpy.ndarray¶

zeta: numpy.ndarray¶

n: numpy.ndarray¶

norm()¶: int R(r)^2 r^2 dr, which should be 1 up to the bank’s rounding.

class pyextal.jaxMultipole.bank.BankEntry¶

One :ELEM segment.

Variables:

key (str) – Segment label as written, e.g. 'Ti', 'Ti4+', 'O-'.
Z (int) – Atomic number.
mass (float) – Atomic mass.
sph (tuple) – (a, b, c) of the analytical spherical form factor.
sz (dict) – Orbital name -> single-zeta exponent (bohr^-1), non-zero only.
orbitals (tuple[Orbital]) – Occupied orbitals, in the STO header order.
bank (str) – Which bank it came from.

key: str¶

Z: int¶

mass: float¶

sph: tuple¶

sz: dict¶

orbitals: tuple¶

bank: str = ''¶

property element¶

property electrons¶

orbital(name)¶

pyextal.jaxMultipole.bank.bank_path(name)¶: File of a bundled bank, or name itself when it is a path.

pyextal.jaxMultipole.bank.load_bank(name='RDF_SCM')¶

Parses a bank.

Parameters:: name (str) – 'RDF_SCM', 'PBE-QZ4P-ZORA' or a path to an XD bank.
Returns:: Keyed by segment label exactly as written ('Ti', 'Ti4+'); look-ups through entry() tolerate case.
Return type:: dict[str, BankEntry]

pyextal.jaxMultipole.bank.entry(key, bank='RDF_SCM')¶: One bank entry, by label, ignoring case ('TI' finds 'Ti').

pyextal.jaxMultipole.bank.radial_density(orbitals, r_bohr, occupations=None, renormalize=True)¶

Spherical density 4 pi r^2 rho(r) (electrons per bohr) of a set of orbitals.

Used for tests and maps; the scattering factors never need it.

class pyextal.jaxMultipole.bank.Shell¶

A group of orbitals that share one scattering function.

Variables:

name (str) – e.g. 'core', '3d', '4s', or '3d+4s'.
orbitals (tuple[Orbital]) – Members.
occupations (tuple[float]) – Electrons in each member.
source (str) – Bank key the orbitals came from.

name: str¶

orbitals: tuple¶

occupations: tuple¶

source: str¶

property electrons¶

class pyextal.jaxMultipole.bank.AtomConfig¶

A core/valence partition of one atom.

Variables:

key (str) – Bank key of the valence entry.
element (str) – Element symbol.
Z (int) – Nuclear charge.
core (Shell) – The frozen core, scattered with kappa = 1.
valence (tuple[Shell]) – Valence shells. Each gets a population; they share or not a kappa according to the model specification.
bank (str) – Bank name.

key: str¶

element: str¶

Z: int¶

core: Shell¶

valence: tuple¶

bank: str¶

property Pc¶

property Pv¶

property neutral_valence¶: Valence electrons the neutral atom would have, Z - Pc.

pyextal.jaxMultipole.bank.configure(entry_or_key, valence=None, occupations=None, core_from=None, shells='joined', bank='RDF_SCM')¶

Chooses the core/valence partition and the occupations of one atom.

Parameters:

entry_or_key (BankEntry | str) – The atom, e.g. 'Ti' or an entry.
valence (list[str], optional) – Orbitals to treat as valence. Defaults to those the bank marks valence. [] makes the atom all core.
occupations (dict, optional) – Orbital -> electrons, overriding the stored values (both core and valence orbitals may be listed).
core_from (BankEntry | str, optional) – Take the core orbitals from this entry instead – e.g. an ion’s contracted core under a neutral atom’s valence.
shells (str) – 'joined' puts all valence orbitals into one shell with one population (Friis-style 3d^2 4s^2 with a single Pv); 'separate' gives each orbital its own shell.
bank (str) – Bank to resolve string keys in.

Returns:

AtomConfig

pyextal.jaxMultipole.bank.pair_table(shell, renormalize=True)¶

Fourier-Bessel weights of a shell’s spherical density.

The shell’s density, normalised to one electron when every orbital is, is sum_orb (occ/Pshell) R_orb^2 – so its scattering factor at kappa is sum w <j_0>_N(k; kappa alpha) with sum w = 1.

Parameters:

shell (Shell) – The shell.
renormalize (bool) – Rescale each orbital to unit norm first; the stored coefficients are rounded and miss by up to ~2e-5.

Returns:

N -> (w, alpha), alpha in bohr^-1, grouped by power so each group is one vectorised evaluation. Empty for an empty shell.

Return type:

dict[int, tuple[np.ndarray, np.ndarray]]

pyextal.jaxMultipole.bank.sph_fx(e, s)¶

The bank’s analytical spherical form factor sum a exp(-b s^2) + c.

Parameters:

e (BankEntry) – Entry.
s (array-like) – sin(theta)/lambda, Angstrom^-1.