Source code for ase2sprkkr.result_files.definitions.rat

from ..result_files_definitions import (
    ResultFileValueDefinition as V,
    create_result_file_definition,
    ResultFileDefinition,
    BlankSeparator,
    ResultFileSectionDefinition,
)
from typing import Optional
import numpy as np
from ase.units import Rydberg
from ase2sprkkr.physics.broadening import create_lorentz_broadener, create_gaussian_broadener, compute_wlortab
import pyparsing as pp

from ...common.grammar import generate_grammar
from ..result_files import CommonResultFile
from ...common.grammar_types import Array, Keyword, Char, Table, Sequence, Complex, Real
from ...common.generated_configuration_definitions import GeneratedValueDefinition
from ...common.configuration_definitions import KeywordSeparator, SeparatorDefinition, BaseDefinition
from .._plot_support import Multiplot, set_up_common_plot, single_plot
from ...common.decorators import cached_property, add_to_signature


[docs] class RATResultFile(CommonResultFile): extension = "rat" plot_parameters = {} """ Result file for XAS (X-ray Absorption Spectroscopy) and related spectra (XMCD, spin and orbital sum-rule integrands). """
[docs] def __init__(self, definition, container=None, potential=None): super().__init__(definition, container, potential=potential) self.EFERMI.add_hook(self.clear_cached_data)
[docs] def clear_cached_data(self, _option=None): """Discard derived spectra after editing source data. EFERMI assignments clear the cache automatically. Call this explicitly after changing group data, including direct writes into NumPy views. """ for name in ("_data", "_data_key", "core_states_index", "core_state_types"): self.__dict__.pop(name, None)
[docs] def energies(self, group=0): """Energies in Ev relative to E-Fermi.""" efermi = self.EFERMI() return np.array([(i.ENERGY()[0].real - efermi) * Rydberg for i in self.GROUPS[group].DATA.values()])
@property def absorbing_element(self): """Chemical symbol of the element whose core spectrum is plotted.""" type_index = self.GROUPS[0].IT() - 1 return str(self.TYPES[type_index]["TXT_T"]).strip() @property def system_formula(self): """Build the system formula from the atom types and their multiplicities.""" parts = [] for atom_type in self.TYPES(): symbol = str(atom_type["TXT_T"]).strip() count = int(atom_type["NAT"]) parts.append(symbol if count == 1 else f"{symbol}{count}") return "".join(parts) @property def spectrum_subject(self): return f"of {self.absorbing_element} in {self.system_formula}" @property def xray_edge(self): """Spectroscopic label of the absorbing core edge, for example L₂,₃.""" n = self.GROUPS[0].NCXRAY() l = self.GROUPS[0].LCXRAY() shells = "KLMNOPQ" shell = shells[n - 1] if 1 <= n <= len(shells) else f"n={n}" if n == 1: return shell subshell = "1" if l == 0 else f"{2 * l},{2 * l + 1}" return rf"{shell}_{{{subshell}}}"
[docs] def order(self): """Order of the energie dataset."""
[docs] def validate_data(self): energies = self.energies() for i in range(1, len(self.GROUPS)): if not (self.energies(i) != energies): raise ValueError(f"Set of energies for GROUP={i} differs from the ones for GROUP=0") cst = self.core_state_types if len(cst[0]) > 2: raise ValueError("Too much KAP core-state-types") if len(cst[0]) == 2: itr = iter(cst[1]) changes = 0 prev = next(i) for i in itr: if prev != i: changes += 1 if changes >= len(cst[0]): raise ValueError("KAP types can't be interleaved")
[docs] @cached_property def core_states_index(self): """Return indexes of core_states in CORE_STATES table, some of them can have two lines""" STATES = self.GROUPS[0].CORE_STATES return [i for i in range(len(STATES)) if i == 0 or STATES[i]["ICST"] != STATES[i - 1]["ICST"]]
[docs] @cached_property def core_state_types(self): """classify the core states according to the KAP property""" return np.unique(self.GROUPS[0].CORE_STATES["KAP"], return_inverse=True)
[docs] def core_states_energies(self, no_core_splitting=False): states_index = self.core_states_index n_groups = len(self.GROUPS) out = np.empty((n_groups, len(states_index))) def fill_group(i): out[i] = self.GROUPS[i].CORE_STATES["E(Ry)"][states_index] * Rydberg if no_core_splitting: fill_group(0) out[1:] = out[0] else: for i in range(n_groups): fill_group(i) return out
[docs] def lorentz_width(self, source="campbell-papp"): """ Return tuple of Lorentz widths (for the two possible KAP types). The `source` argument is forwarded to the core_hole_width lookup. """ from ase2sprkkr.physics.core_hole_width import core_hole_width from ase.data import atomic_numbers atomic_number = atomic_numbers[self.absorbing_element] nc = self.GROUPS[0].NCXRAY() lc = self.GROUPS[0].LCXRAY() return ( core_hole_width(atomic_number, nc, lc, 1, source=source), core_hole_width(atomic_number, nc, lc, 2, source=source), )
[docs] def broadener(self, energies, gauss_width, lorentz_width, n_valence=None, wlortab=None): if lorentz_width is None: lorentz_width = self.lorentz_width() if n_valence is None: from ase2sprkkr.physics.atomic_data import valence_electrons n_valence = valence_electrons(self.absorbing_element) # Accept Python floats and NumPy scalar floats here if np.isscalar(lorentz_width): lorentz_width = [float(lorentz_width)] # Allow user to pass a precomputed wlortab array; otherwise compute from n_valence if wlortab is None: wlortab = compute_wlortab(energies, n_valence) lorentz = [ None if w < 0.001 and n_valence > 0 else create_lorentz_broadener(energies, w, wlortab) for w in lorentz_width ] if len(lorentz) == 1: lorentz *= 2 if gauss_width > 0.001: gauss = create_gaussian_broadener(energies, gauss_width, method="dense") else: gauss = None def broaden(data, k): # RAT stores spectra as (energy, group, state, polarization), # while generic broadeners operate along the last axis. data = np.moveaxis(data, 0, -1) if lorentz[k]: data = lorentz[k](data) if gauss: data = gauss(data) return np.moveaxis(data, -1, 0) return broaden
@property def data(self): if not hasattr(self, "_data"): raise ValueError("First call the `generate_data` method to compute the data") return self._data
[docs] def plot( self, layout=(None, 2), figsize=None, latex=None, filename: Optional[str] = None, show: Optional[bool] = None, dpi=800, separate_plots=False, interpolate_to_fermi=True, interpolation_threshold=1e-4, zero_below=True, zero_below_num=50, zero_below_energy=25, no_core_splitting=False, merge_all=None, updown_layout=True, gauss_width=0.1, lorentz_width=None, n_valence=None, core_hole_width="campbell-papp", mld=False, layout_kind="constrained", **kwargs, ): data = self.generate_data( interpolate_to_fermi, interpolation_threshold, zero_below, zero_below_num, zero_below_energy, no_core_splitting, merge_all, gauss_width, lorentz_width, n_valence, core_hole_width, mld, ) num = data["XAS"].shape[0] # 1 or 2 if "SPIN" in data: num += 1 num = num * 2 if figsize is None: figsize = lambda layout: (layout[0] * 4, layout[1] * 4) with Multiplot( layout=layout, figsize=figsize, latex=latex, filename=filename, show=show, dpi=dpi, updown_layout=updown_layout, separate_plots=separate_plots, layout_kind=layout_kind, number_of_plots=num, **kwargs, ) as mp: self.XAS.plot(multiplot=mp, data_generated=True, **kwargs) self.XMCD.plot(multiplot=mp, data_generated=True, **kwargs) if "SPIN" in data: self.SPIN.plot(multiplot=mp, data_generated=True, **kwargs) self.ORBIT.plot(multiplot=mp, data_generated=True, **kwargs)
[docs] def generate_data( self, interpolate_to_fermi=True, interpolation_threshold=1e-4, zero_below=True, zero_below_num=50, zero_below_energy=25, no_core_splitting=False, merge_all=None, gauss_width=0.0, lorentz_width=None, n_valence=None, core_hole_width="campbell-papp", mld=False, ): key = {**locals()} del key['self'] ckey = getattr(self, '_data_key', None) if ckey: for i,v in key.items(): if ckey[i] != v: break else: return self._data self._data = self.compute_data(**key) self._data_key = key return self._data
[docs] def compute_data( self, interpolate_to_fermi=True, interpolation_threshold=1e-4, zero_below=True, zero_below_num=50, zero_below_energy=25, no_core_splitting=False, merge_all=None, gauss_width=0.0, lorentz_width=None, n_valence=None, core_hole_width="campbell-papp", mld=False, ): """core energies""" ktypes, type_map = self.core_state_types n_ktypes = len(ktypes) groups = [np.where(type_map[self.core_states_index] == i)[0].tolist() for i in range(len(ktypes))] if len(groups) > 1: if groups[0][0] > groups[1][0]: groups = groups[::-1] e_core = self.core_states_energies(no_core_splitting) e_core_avg = np.empty(n_ktypes) for i in range(n_ktypes): e_core_avg[i] = np.average(e_core[:, groups[i]]) dcormin = float("inf") border = len(groups[0]) if n_ktypes > 1: for i in e_core: dcormin = min(dcormin, np.min(np.abs(i[:border, np.newaxis] - i[border:]))) """ energies """ energies = self.energies() order = np.argsort(energies) senergies = energies[order] if senergies[-1] > 650: n_valence = 0 """ replace energies below e-fermi and add e-fermi energy """ fidx = np.searchsorted(senergies, 0.0) if fidx >= len(senergies): raise ValueError("Fermi energy not in the range of energies") if fidx == 0: nef = 0 elif abs(senergies[fidx]) < abs(senergies[fidx - 1]): nef = fidx else: nef = fidx - 1 if interpolate_to_fermi: if abs(senergies[nef]) < interpolation_threshold: interpolate_to_fermi = False def make_slice(order): """transform order array to slice, if possible - check for subsequent numbers""" if len(order) == 0: return slice(0, 0) if np.all(order[:-1] < order[1:]) and 2 * np.sum(order) == (order[-1] - order[0] + 1) * ( order[0] + order[-1] ): return slice(order[0], order[-1] + 1) return order if zero_below or interpolate_to_fermi: if interpolate_to_fermi: upper_half_idx_source = upper_half_idx = nef # weights for interpolation to fermi if ((nef == 0) or (senergies[nef] <= 0.0)) and (nef < len(senergies) - 1): interp_idx = nef + 1 else: interp_idx = nef - 1 x1, x2 = senergies[nef], senergies[interp_idx] df = x2 - x1 w1, w2 = -x2 / df, x1 / df my_fermi = 0.0 else: upper_half_idx_source = upper_half_idx = nef my_fermi = senergies[nef] if zero_below: senergies = np.concatenate( [ abs(zero_below_energy) * (np.linspace(-1.0, 0.0, zero_below_num, endpoint=False) ** 3), senergies[upper_half_idx:], ] ) upper_half_idx = zero_below_num if interpolate_to_fermi: senergies[upper_half_idx] = 0 size = len(senergies) # Energy, Group, State, Polarization STATES = self.GROUPS[0].CORE_STATES n_states = STATES[-1]["ICST"] n_pol = len(self.NPOL()) shape = (size, len(self.GROUPS), n_states, n_pol) source_shape = (len(energies), len(self.GROUPS), n_states, n_pol) def read_rdt(name): """Fill the below fermi with either zero or data fill above the fermi with data And finally, the middle fermi-energy point set as interpolation. """ source = np.empty(source_shape) for i, g in enumerate(self.GROUPS.values()): for j, d in enumerate(g.DATA.values()): source[j, i] = d.DATA[name].real.reshape((-1, n_pol)) source = source[order] out = np.empty(shape) if zero_below: out[:upper_half_idx] = 0.0 out[upper_half_idx:] = source[upper_half_idx_source:] else: out[:] = source if interpolate_to_fermi: out[upper_half_idx] = w1 * source[nef] + w2 * source[interp_idx] return out rd = read_rdt("ABSRTA") rt = read_rdt("ABSRATE") if n_pol == 3: if mld: # XBand's MLD mode compares the average of the two circular # polarizations with the z polarization. rd[:, :, :, 1] = 0.5 * (rd[:, :, :, 0] + rd[:, :, :, 1]) rd = rd[:, :, :, 1:] rt[:, :, :, 1] = 0.5 * (rt[:, :, :, 0] + rt[:, :, :, 1]) rt = rt[:, :, :, 1:] else: # RDRXAS reads all three columns, but XBand's default MCD # mode subsequently sets NPOL=2 and uses the + and - columns. rd = rd[:, :, :, :2] rt = rt[:, :, :, :2] n_pol = 2 # If caller didn't provide explicit lorentz_width, compute using requested dataset if lorentz_width is None: lorentz_width = self.lorentz_width(core_hole_width) broaden = self.broadener(senergies, gauss_width, lorentz_width, n_valence) borders = [0, border, n_states] for i in range(n_ktypes): rd[:, :, borders[i] : borders[i + 1]] = broaden(rd[:, :, borders[i] : borders[i + 1]], i) rt[:, :, borders[i] : borders[i + 1]] = broaden(rt[:, :, borders[i] : borders[i + 1]], i) if merge_all is None: merge_all = abs(e_core_avg[0] - e_core_avg[-1]) < (senergies[-1] - senergies[0]) if n_ktypes <= 1 or no_core_splitting: merge_all = False """ Výpočet SD """ def shift_by_e_core_avg_diff(data, energies=senergies, borders=borders, out=None, ref_avg=None, clip=False): """ Interpolate `data` shifted by core-energy differences onto `energies`. Parameters - data: array shaped (len(senergies), groups, states, n_pol) - energies: target energy grid where the shifted spectra are evaluated - borders: grouping borders as used elsewhere in this function - out: optional pre-allocated output array; if None a new array is created - out: optional pre-allocated output array; if None a new array is created. Returns the output array (the same object passed as `out` when provided). """ # determine evaluation grid and output view N = len(energies) if out is None: out = np.empty((N,) + data.shape[1:]) eval_energies = energies out_view = out from scipy.interpolate import interp1d for i in range(e_core.shape[0]): for k in range(n_ktypes): for j in range(borders[k], borders[k + 1]): if ref_avg is None: de = e_core_avg[k] - e_core[i, j] else: de = ref_avg - e_core[i, j] shifted = eval_energies - de for p in range(n_pol): f = interp1d(senergies, data[:, i, j, p], kind="cubic", fill_value="extrapolate") out_view[:, i, j, p] = f(shifted) # values corresponding to evaluation points outside source grid if clip: out_view[shifted < senergies[0], i, j, p] = 0.0 out_view[shifted > senergies[-1], i, j, p] = data[-1, i, j, p] return out if merge_all: ie = np.searchsorted(senergies, dcormin, side="right") if ie >= len(senergies): raise ValueError("No E(i) > Dcormin found") shifted_energies = np.concatenate((senergies[:ie], senergies[upper_half_idx:] - my_fermi + dcormin)) kref = np.argmax(e_core_avg) avg = e_core_avg[kref] # Use shift_by_e_core_avg_diff to fill ad/at on the merged energy grid # pass ref_avg so all states are shifted to the same reference (kref) ad = shift_by_e_core_avg_diff(rd, energies=shifted_energies, borders=borders, ref_avg=avg, clip=True) at = shift_by_e_core_avg_diff(rt, energies=shifted_energies, borders=borders, ref_avg=avg, clip=True) df = avg - e_core ebot = shifted_energies[0] + np.max(df) iebot = np.searchsorted(shifted_energies, ebot, side="right") etop = senergies[-1] + np.min(df) ietop = np.searchsorted(shifted_energies, etop, side="left") shifted_energies = shifted_energies[iebot:ietop] ad = ad[iebot:ietop] at = at[iebot:ietop] # Recompute per-ktype `sd` on the merged energy grid (preserve per-ktype shifts) sd = shift_by_e_core_avg_diff(rd, energies=shifted_energies, borders=borders, clip=True) senergies = shifted_energies else: sd = shift_by_e_core_avg_diff(rd) ad = sd.copy() at = shift_by_e_core_avg_diff(rt) # ------ combine spectra with common KAPPA for core state shape = ad.shape[:2] + (n_ktypes, n_pol) rd = np.empty(shape) rt = np.empty(shape) for i in range(n_ktypes): rd[:, :, i] = ad[:, :, borders[i] : borders[i + 1]].sum(axis=2) rt[:, :, i] = at[:, :, borders[i] : borders[i + 1]].sum(axis=2) index = [i.IT() - 1 for i in self.GROUPS.values()] concealment = np.asarray(self.TYPES()["CONC"]).ravel()[index] nqt = np.asarray(self.TYPES()["NAT"]).ravel()[index] weight = (concealment * nqt)[None, :, None, None] def sum_groups(data): data *= weight return data.sum(axis=1) if merge_all: rd = rd.sum(axis=2)[:, :, None] rt = rt.sum(axis=2)[:, :, None] rd = sum_groups(rd) rt = sum_groups(rt) tt = 0.5 * (rd[:, :, -1] + rd[:, :, 0]).T td = 0.5 * (rd[:, :, -1] - rd[:, :, 0]).T out = {"XAS": tt, "XMCD": td, "ENERGY": senergies, "DICHROISM": "MLD" if mld else "XMCD"} if n_ktypes > 1: _sd = np.empty(shape) for i in range(n_ktypes): _sd[:, :, i] = sd[:, :, borders[i] : borders[i + 1]].sum(axis=2) sd = sum_groups(_sd) # now (energy, ktype, n_pol) shape yd = 0.5 * (sd[:, :, 1] - sd[:, :, 0]) spin = 3 * (yd[:, 1] - 2 * yd[:, 0]) orb = 2 * (yd[:, 1] + yd[:, 0]) out["SPIN"] = spin out["ORBIT"] = orb return out """ Czech notes - mimics the XBAND plot // NCXRAY(ITXG) = principal quantum number n of the absorbing core orbital. // LCXRAY(ITXG) = orbital angular momentum l of that core orbital. TODO * CORE STATES se opakuje, ale N a L musí být stejné pro všechny skupiny ?? asi OK * očísluje grupy tak, že jde číslem grupy chodit rovnou do tabulky typů OK * vytvoří seřazenou tabulku indexů energií E - ty by měly být stejné pro všechny grupy OK * odečte od CORE_STATES.E(Ry) a ENERGY[0] Fermi enegy (EFERMI) OK * najde energii nejblíže k FE (NEF je index, DIST vzdálenost) OK * pokud DIST > 1E-4 tak provede lineární interpolaci do EFERMI z dvou nejbližších bodů (starý kód přepíše ten nejbližší bod) energies udělány OK * pro XAS/CHIXAS - vyhodí cokoli pod Fermi level - pokud ne NOTABEXT tak přidá samé nuly na n=50 energií pod Fermi level do souřadnic - 25Ev * (i/n)**3 ??? * pokud je rozdíl nějakých energií menší nežli 1e-6, vynásobí tu energii 1.00001 * rozdělí CST podle KAP, mohou být jen dva typy - pole KTYP OK - pokud poslední energie > 50, nastav NVAL=0, jinak NVAL=number_of_valence_electrons_of_the_first_atom (může být předefinováno) OK * Načte wcorehole(atomic_number, N(1),L(1),IK=1,2 pro počet typů) OK * core-spliting (vypnutelné parametrem) - pokud je vypnuto CORE_STATES[i,j].E(Ry) = CORE_STATES[0,0].E(Ry) OK * ECOREAV(KTYP) = avg( CORE_STATES[i,j].E(Ry) for given KTYP) - pokud ECOREAV(i) - ECOREAV(j) < E(1) - E(n) (v abs) nastav MERGE_ALL OK * dormin, dcormax min a max abs(rozdílů) všech CORE_STATES[i,j].E(Ry) pro core s ROZDILNYM KTYP. Asi jde udělat tak, že se najde min a max energií pro každý ktyp a pak se to odečte. OK seřadí data v RD/RT (skupiny) podle energií E RD/RT jsou REAL(ABSRTA), REAL(ABSRATE) OK broaodening RD a RT pro datasety dle energií íce způsobů, dopracovat * SD = transformace podle ECOREAV, viz line 571 - lagrange interpolace, kdy se posunou hodnoty o ECOREAV(K) - ECORE(ITXG,ICST) * Pokud ne Meerge ALL, tak - AD, AT je stejná interpolace RD a RT, jako výš * Pokud Merge ALL - merging spectra, see line 620 and below * sum AD a AT according to the KTYP to RD, RT sum SD according to the KTYP (to SD) * 845: (*not XMO/XRS) - xmo: magneto-optics, xrs: resonant-scattering over ITXG, NE SUMK(K) = SUMK(K) + 0.5*(E(I)-E(I-1)) *(RD(I,ITXG,K,NPOL)-RD(I,ITXG,K,1)) * Pokud MergeALL, sum RD/RT over K """
[docs] class RATDefinition(ResultFileDefinition): result_class = RATResultFile
[docs] def G(name, **kwargs): def get(section: object, _key: object = None): """Read ``name`` from the runtime output section.""" return section.data[name] return GeneratedValueDefinition(name, get, **kwargs)
_ylabel_base = { "XAS": r"$\mu(E)$", "XMCD": r"$\Delta\mu(E)$", "SPIN": r"$\Delta\mu_{\mathrm{spin\,SR}}(E)$", "ORBIT": r"$\Delta\mu_{\mathrm{orb\,SR}}(E)$", } _kunit_labels = { 1: "Mb", 2: r"$10^{15}\,\mathrm{s}^{-1}$", }
[docs] def draw_plot(axis, x, y, title, name=None, kunit=1, edge=None, controls=None, **kwargs): axis.set_title(title) axis.set_xlabel(r"$E-E_{\rm F}$ (eV)") base = _ylabel_base.get(name, "") if edge and base: math = base[1:-1] if base.startswith("$") and base.endswith("$") else base base = rf"${edge}\;{math}$" unit = _kunit_labels.get(kunit, "Mb") axis.set_ylabel(f"{base} ({unit})" if base else f"({unit})") set_up_common_plot(axis, **kwargs) axis.plot(x, y)
[docs] def plot( option, multiplot=False, interpolate_to_fermi=True, interpolation_threshold=1e-4, zero_below=True, zero_below_num=50, zero_below_energy=25, no_core_splitting=False, merge_all=None, gauss_width=0.0, lorentz_width=None, n_valence=None, core_hole_width="campbell-papp", mld=False, *args, data_generated=False, **kwargs): if not data_generated: option._container.generate_data( interpolate_to_fermi, interpolation_threshold, zero_below, zero_below_num, zero_below_energy, no_core_splitting, merge_all, gauss_width, lorentz_width, n_valence, core_hole_width, mld, ) def just_plot(plotter, kwargs=kwargs): for i, d in enumerate(data): if len(data) > 1: tit = f"{title} - type {i + 1}" else: tit = title with plotter(title, kwargs) as (axis, kw): draw_plot(axis, energy, d, tit, name=option.name, kunit=kunit, edge=c.xray_edge, **kw) c = option._container kunit = c.GROUPS[0].IFMT()[1] data = c.data titles = { "XAS": "XAS", "XMCD": data["DICHROISM"], "SPIN": "XMCD spin sum-rule integrand", "ORBIT": "XMCD orbital sum-rule integrand", } title = f"{titles.get(option.name, option.info)} {c.spectrum_subject}" energy = data["ENERGY"] data = data[option.name] if len(data.shape) == 1: data = data[None] if multiplot: just_plot(multiplot.new_axis, kwargs) elif len(data.shape) and len(data) > 1: kwargs["layout"] = (2, 1) with Multiplot(**kwargs) as mp: just_plot(mp.new_axis, {}) else: just_plot(single_plot, kwargs)
[docs] def nktypes(option): return len(option._container.core_state_types[0])
[docs] def create_definition(): definition = create_result_file_definition( Keyword("RXAS"), [ G("XAS", plot=(plot, nktypes), info="Polarization averaged X-ray absorption spectra"), G("XMCD", plot=(plot, nktypes), info="X-ray Magnetic Circular Dichroism"), G("SPIN", plot=plot, info="XMCD spin sum-rule integrand: 3(\u0394\u03bc\u208a \u2212 2\u0394\u03bc\u208b)"), G("ORBIT", plot=plot, info="XMCD orbital sum-rule integrand: 2(\u0394\u03bc\u208a + \u0394\u03bc\u208b)"), G("ENERGY"), V("NTXRSGRP", int), V("IDIPOL", int), V("NPOL", Array(Char(), write_length=True)), ResultFileSectionDefinition( "GROUPS", [ V("SPECTRUM", str), V("IT", int), V("NCXRAY", int), V("LCXRAY", int), BlankSeparator(), BlankSeparator(), SeparatorDefinition(KeywordSeparator("CORE STATES :")), BlankSeparator(), V("NCST", int, written_name="NCST:", indent=" "), V("NKPCOR", Array(int), written_name="NKPCOR:", indent=" "), BlankSeparator(), V( "CORE_STATES", Table( { "ICST": int, "N": int, "L": int, "KAP": int, "MUE": Array(int, delimiter="/"), "IKM": int, "NORM": float, "E(Ry)": float, "E(eV)": float, "<SIGMA_z>": float, "I0": int, }, repeat_sparse=["IKM", "NORM"], ), name_in_grammar=False, ), BlankSeparator(), V("N_ENERGIES", int, written_name="number of energies", indent=" "), V("IFMT", Array(int, length=2), written_name="output format IFMT", indent=" "), V("VUC", float), BlankSeparator(), ResultFileSectionDefinition( "DATA", [ V( "ENERGY", Sequence( Complex(postfix=" RYD ", delimiter="", prefix=""), Real(postfix=" EV (REL EF)") ), name_in_grammar=False, ), V( "DATA", Table( {"ABSRTA": complex, "ABSRTB": complex, "ABSRATE": complex, "ADD": str}, grouping=True, numbering=True, header=False, groups_as_list=False, ), name_in_grammar=False, ), ], name_in_grammar=False, repeated_delimiter=pp.Regex("[ \t]*\n").set_name("\n"), is_repeated=BaseDefinition.Repeated.LIST_SECTION, ), ], is_repeated=True, name_in_grammar=False, ), ], name="RAT", cls=RATDefinition, info="Result of a X-ray spectroscopy", ) return definition
with generate_grammar(): definition = create_definition()