API: everything else

This page lists every name rietx exports that the other two API pages do not, alphabetically.

Most are the types a result, a report or a project is made of. You read their fields more often than you construct them.

rx.__version__ = 1.10.0

A constant.

class rx.AbsorptionCorrection

Record of the specimen absorption applied (cylinder or flat plate).

method: 'rouse_cylinder' | 'flat_plate_reflection' | 'flat_plate_transmission' = 'rouse_cylinder'

mu_r: float

mu_r_source: 'given' | 'estimated'

wavelength: float

equivalent_delta_biso: float

skipped: str | None = None

out_of_range: bool = False

unabsorbed_fraction: float | None = None

identifiable_fraction: float | None = None

intensity_fraction_of_optimal: float | None = None

class rx.AmbiguityPartner

A distinct lattice whose calculated line positions match this one’s.

cell: tuple[float, float, float, float, float, float]

transformation: list[list[int]]

index: int

system: str

volume: float

discriminating_reflections: list[tuple[int, int, int]] = []

discriminating_two_theta: list[float] = []

class rx.AngleRestraint

A soft restraint on the i–j–k bond angle (vertex = the middle atom atom_j), contributing √weight·(angle − target_deg)/sigma degrees.

atom_i: int

atom_j: int

atom_k: int

target_deg: float

sigma: float

weight: float = 1.0

op_index_i: int | None = None

translation_i: tuple[int, int, int] = (0 × 3)

op_index_k: int | None = None

translation_k: tuple[int, int, int] = (0 × 3)

class rx.Annotation

An append-only overlay: labels, refs and scores, applied after nodes.

node_id: str = ''

label: str | None = None

refs: dict[str, str] = {}

scores: dict[str, float] = {}

notes: dict[str, str] = {}

class rx.AntiBumpRestraint

A one-sided distance restraint: zero beyond min_distance, linear inside.

atom_i: int

atom_j: int

min_distance: float

sigma: float

weight: float = 1.0

op_index: int | None = None

translation: tuple[int, int, int] = (0 × 3)

class rx.Base

Base for every rietx schema.

class rx.BodyOrigin

A rigid body’s origin: the point (0, 0, 0) of its template, fractional.

x: Parameter

y: Parameter

z: Parameter

class rx.BodyTorsion

A rotation of declared body atoms about the line through two others (WP-1808).

name: str

axis: tuple[str, str]

moves: list[str]

angle: float = 0.0

vary: bool = False

class rx.BondRestraint

A soft restraint on the distance between two atoms of one phase.

atom_i: int

atom_j: int

target: float

sigma: float

weight: float = 1.0

op_index: int | None = None

translation: tuple[int, int, int] = (0 × 3)

class rx.BravaisOpinion

What gemmi and spglib each say about a candidate’s lattice symmetry.

system: str

system_loosest: str

system_gemmi: str

system_spglib: str

ambiguous: bool = False

methods_disagree: bool = False

reduced_cell: tuple[float, float, float, float, float, float] = (0.0 × 6)

class rx.CandidateEvidence

One candidate’s evidence, collected for a consumer that can reason.

index: int

cell: tuple[float, float, float, float, float, float]

cell_esd: tuple[float, float, float, float, float, float]

system: str

centring: str

volume: float

confidence: 'high' | 'medium' | 'low'

caveats: list[CaveatEvidence] = []

found_by: list[str] = []

n_indexed: int = 0

n_lines: int = 0

fom: dict[str, float] = {}

validated: bool = False

lebail_status: str | None = None

lebail_rwp: float | None = None

predicted_but_absent: int | None = None

unmatched_observed: int | None = None

ambiguity_partners: int = 0

class rx.CaveatEvidence

One caveat, with the half of it the gate never wrote out: its kind.

name: 'engines_disagree' | 'geometric_ambiguity' | 'fom_panel_disagrees' | 'fom_panel_reduced' | 'not_validated' | 'validation_failed' | 'predicted_but_absent' | 'indexed_fraction_low' | 'indexed_lines_low' | 'search_incomplete' | 'shift_allowance_assumed' | 'bravais_ambiguous' | 'volume_unphysical' | 'supercell_refuted'

kind: 'refuting' | 'capping'

class rx.CellCandidate

One candidate lattice, with everything needed to rank or reject it.

cell: tuple[float, float, float, float, float, float]

cell_esd: tuple[float, float, float, float, float, float]

system: str

centring: str = 'P'

lattice_group: str = ''

volume: float = 0.0

volume_esd: float = 0.0

af: tuple[float, float, float, float, float, float] = (0.0 × 6)

engine_cell: tuple[float, float, float, float, float, float] | None = None

change_of_basis: tuple[tuple[int, int, int], tuple[int, int, int], tuple[int, int, int]] | None = None

n_indexed: int = 0

n_lines: int = 0

n_search_unindexed: int | None = None

unindexed_two_theta: list[float] | None = None

chi2_red: float = 0.0

shift_template: str | None = None

shift_coefficient: float = 0.0

shift_esd: float = 0.0

fom: list[FigureOfMerit] = []

found_by: list[str] = []

ambiguity: list[AmbiguityPartner] = []

supercell_checks: list[SupercellCheck] | None = None

bravais: BravaisOpinion | None = None

lebail: LeBailValidation | None = None

confidence: 'high' | 'medium' | 'low' = 'low'

confidence_caveats: list['engines_disagree' | 'geometric_ambiguity' | 'fom_panel_disagrees' | 'fom_panel_reduced' | 'not_validated' | 'validation_failed' | 'predicted_but_absent' | 'indexed_fraction_low' | 'indexed_lines_low' | 'search_incomplete' | 'shift_allowance_assumed' | 'bravais_ambiguous' | 'volume_unphysical' | 'supercell_refuted'] = []

diagnostics: list[Diagnostic] = []

class rx.CellVolume

One phase’s unit-cell volume in ų, with its esd (WP-1933).

phase_index: int

volume: float

stderr: float | None = None

stderr_diagonal: float | None = None

class rx.CoordinateTable

Each pattern’s coordinates: named columns, one row per pattern.

columns: dict[str, list[float | None]]

units: dict[str, str] = {}

class rx.CorrelationPair

One entry of the worst-|ρ| list (WP-1056).

path_a: str

path_b: str

rho: float

class rx.DataQualityReport

Is this peak list fit to index, and what does it already say?

n_usable: int

n_total: int

two_theta_min: float

two_theta_max: float

source: 'fitted' | 'positions'

sigma_two_theta_median: float

sigma_two_theta_worst: float

relative_sigma_q_median: float

sigma_over_spacing: float

lines_per_dof: dict[str, float] = {}

systems_supported: list[str] = []

fom_undefined: dict[str, str] = {}

volume_envelope: dict[str, float] = {}

shift: ShiftScreen | None = None

supports_indexing: bool = True

abstained_reason: str | None = None

thresholds_version: str = '1.11'

diagnostics: list[Diagnostic] = []

class rx.DataRef

The pattern a project is fitted against, held as a reference you can check.

filename: str

sha256: str

fingerprint: str

reader: str

options: dict[str, str] = {}

n_points: int

two_theta_range: tuple[float, float]

has_sigma: bool

class rx.DataSupport

How many observations the pattern actually holds (WP-1071).

n_unique_reflections: int

n_effective_observations: float | None = None

n_structural_parameters: int

observations_per_parameter: float | None = None

effective_observations_per_parameter: float | None = None

class rx.EmissionLine

One wavelength component of the incident spectrum.

wavelength: Parameter

weight: Parameter = Parameter(1.0, min=0.0)

class rx.ExchangeRow

How well the fitted parameters can imitate one held parameter.

held: str

r2: float

partners: dict[str, float] = {}

class rx.ExtinctionCandidate

One extinction class: the space groups that share an absence set.

symbol: str

representative: str

space_groups: list[str] = []

excluded_groups: list[str] = []

laue_classes: dict[str, list[str]] = {}

conditions: list[str] = []

conditions_complete: bool = True

n_lines: int = 0

n_absent: int = 0

n_testable: int | None = None

n_present: int = 0

forbidden_hkl: list[tuple[int, int, int]] = []

forbidden_two_theta: list[float] = []

rwp: float = inf

gof: float = inf

chi2: float = inf

delta_bic: float = 0.0

absences_rejected: bool = False

screened: bool = False

refuted: bool = False

refuted_reason: str | None = None

diagnostics: list[Diagnostic] = []

class rx.ExtinctionPrior

Declared facts about the specimen that remove space groups from a class.

sohncke: bool | None = None

centrosymmetric: bool | None = None

polar: bool | None = None

class rx.ExtinctionScreen

What rietx.determine_extinction_symbol returns.

candidates: list[ExtinctionCandidate] = []

lattice_group: str = ''

cell: tuple[float, float, float, float, float, float] = (0.0 × 6)

system: str = ''

centring: str = 'P'

wavelength: float = 0.0

two_theta_range: tuple[float, float] = (0.0 × 2)

n_classes: int = 0

n_screened: int = 0

reference_rwp: float = inf

reference_chi2: float = inf

reference_lines: int = 0

n_points: int = 0

profile_rwp: float = inf

prior: ExtinctionPrior | None = None

status: str = 'converged'

thresholds_version: str = '1.11'

diagnostics: list[Diagnostic] = []

class rx.FigureOfMerit

One figure of merit, and what it cannot see.

name: str

value: float

n_lines: int

n_possible: int

k_sigma: float

mean_discrepancy: float = -1.0

blind_spot: str = ''

class rx.FractionProfile

Every fraction of one phase the pattern admits along its width.

phase: str

phase_index: int

axes: list[str]

weight_fraction: float

weight_fraction_stderr: float | None = None

chi2_fit: float

chi2_best: float

delta_chi2_cut: float

fit_admissible: bool

points: list[FractionProfilePoint] = []

range_low: float

range_high: float

excess: float | None = None

diagnostics: list[Diagnostic] = []

class rx.FractionProfilePoint

One pinned width and what the refit made of the fraction there.

axis: str

value: float

fwhm: float

admissible: bool

weight_fraction: float | None = None

chi2: float | None = None

delta_chi2: float | None = None

rwp: float | None = None

status: str | None = None

error: str | None = None

node_id: str | None = None

class rx.GeometryAngle

One interatomic angle at atom_2, in degrees (WP-1072).

phase_index: int

atom_1: str

atom_2: str

atom_3: str

atom_index_1: int

atom_index_2: int

atom_index_3: int

angle: float

stderr: float | None = None

stderr_diagonal: float | None = None

symmetry_1: str | None = '.'

symmetry_2: str = '.'

symmetry_3: str | None = '.'

class rx.GeometryDistance

One interatomic distance, bonding or nonbonding (WP-1072).

phase_index: int

atom_1: str

atom_2: str

atom_index_1: int

atom_index_2: int

distance: float

stderr: float | None = None

stderr_diagonal: float | None = None

symmetry_1: str = '.'

symmetry_2: str | None = '.'

bonded: bool = True

class rx.GeometryTable

Bonding geometry of the converged model, with propagated esds (WP-1072).

distances: list[GeometryDistance] = []

angles: list[GeometryAngle] = []

bond_slack: float = 0.0

contact_max: float = 0.0

notes: list[str] = []

class rx.GuardFinding

One guard hit, as data: which parameters, which number, which code.

code: str

paths: tuple[str, ...]

value: float | None

message: str

detail: str = ''

limit: tuple[str, float] | None = None

class rx.Harmonic

An nth-order contribution at λ/n from a monochromator that passes order.

order: int

weight: Parameter = Parameter(0.01, min=0.0)

rx.help_key_for(path: str) → str | None

The family glob that claims a parameter dot-path, or None.

rx.help_registry() → dict[str, object]

The whole corpus as JSON-able data, for GET /api/help.

class rx.HelpEntry

What one name is, in the fields a reference entry always carries.

title: str

description: str

unit: str | None = None

default: str | None = None

typical: str | None = None

anchor: str | None = None

label: str | None = None

class rx.HistogramResult

One pattern’s slice of a multi-histogram joint refinement.

label: str = ''

weight: float = 1.0

statistics: Statistics

two_theta: list[float] = []

y_obs: list[float] = []

y_calc: list[float] = []

y_background: list[float] = []

sigma: list[float] = []

ticks: dict[str, list[float]] = {}

tick_hkl: dict[str, list[list[int]]] = {}

qpa: QuantitativePhaseAnalysis | None = None

restraints: RestraintReport | None = None

phase_agreement: list[PhaseAgreement] = []

diagnostics: list[Diagnostic] = []

class rx.HistoryNode

One immutable checkpoint in the refinement DAG.

id: str

parents: list[str] = []

action: NodeAction

state: RefinementState

metrics: NodeMetrics = NodeMetrics(…)

diagnostics: list[Diagnostic] = []

label: str = ''

created_utc: str = ''

scores: dict[str, float] = {}

notes: dict[str, str] = {}

schema_version: str | None = None

class rx.HistoryRecord

One JSONL line.

record: 'header' | 'node' | 'annotation'

header: TreeHeader | None = None

node: HistoryNode | None = None

annotation: Annotation | None = None

class rx.HumpComponent

One explicit broad Gaussian added on top of whatever background is in use.

position: Parameter = Parameter(0.0)

height: Parameter = Parameter(0.0, min=0.0)

fwhm: Parameter = Parameter(5.0, min=0.1)

kind: 'hump' = 'hump'

label: str | None = None

class rx.Identifiability

Degeneracy evidence measured on the final Jacobian (WP-1055/-1056).

background_absorption: dict[str, float] = {}

extra_peak_absorption: dict[str, float] = {}

top_correlations: list[CorrelationPair] = []

soft_modes: list[SoftMode] = []

exchangeability: list[ExchangeRow] = []

class rx.IncidentSpectrum

The moderator spectrum a time-of-flight bank still carries, or none.

itype: int = 0

coefficients: list[Parameter] = []

tof_min_us: float | None = None

tof_max_us: float | None = None

class rx.IndexingControls

Everything an indexing run is asked with that is not the data itself.

search: SearchSpecSpec = SearchSpecSpec(…)

engines: list[str] | None = None

validate_candidates: bool = True

check_top: int | None = None

class rx.IndexingEvidence

The reasoning consumer’s view of an IndexingResult (WP-1043).

candidates: list[CandidateEvidence] = []

systems_searched: list[str] = []

search_complete: dict[str, bool] = {}

systems_supported: list[str] = []

n_usable_lines: int = 0

fom_ranked: list[str] = []

fom_undefined: dict[str, str] = {}

validated: bool = False

class rx.LeBailValidation

A candidate cell tested against the whole pattern by a Le Bail fit.

rwp: float

gof: float

space_group: str

n_reflections: int

predicted_but_absent: int = 0

unmatched_observed: int = 0

predicted_but_absent_two_theta: list[float] = []

unmatched_observed_two_theta: list[float] = []

status: str = 'converged'

n_stages: int = 0

diagnostics: list[Diagnostic] = []

class rx.MagneticOnset

Where along the series axis the moment stops being supported (WP-1329).

path: str = ''

atom: str = ''

x: float | None = None

x_esd: float | None = None

bracket: list[float] = []

bracket_labels: list[str] = []

sense: 'falls' | 'rises' | 'none' = 'none'

monotone: bool = True

boundaries: list[list[float]] = []

n_supported: int = 0

n_held: int = 0

n_unmeasured: int = 0

unmeasured_labels: list[str] = []

n_unconverged: int = 0

bracket_verdicts_final: bool | None = None

note: str = ''

class rx.MagneticSymmetry

A magnetic (Shubnikov) space group as the two magCIF loops that state it.

operations: list[str]

centerings: list[str] = ['x,y,z,+1']

bns_number: str | None = None

og_number: str | None = None

uni_number: int | None = None

symbol: str | None = None

setting: str | None = None

propagation_vector_parent: tuple[str, str, str] | None = None

class rx.MagneticTrajectory

|m| against the series axis, with the held patterns marked as held.

path: str

x: list[float] = []

x_label: str = 'index'

value: list[float] = []

stderr: list[float | None] = []

labels: list[str] = []

positions: list[int] = []

supported: list[bool] = []

measured: list[bool] = []

status: list[str] = []

atom: str = ''

ion: str = ''

onset: MagneticOnset | None = None

class rx.MicroabsorptionCorrection

Mixture-level record of the Brindley correction (Brindley, 1945).

method: 'brindley_sphere' = 'brindley_sphere'

wavelength: float

mu_mean_cm: float

class rx.MicrostructureTerm

One profile coefficient read as the physical quantity behind it.

path: str

kind: 'size' | 'strain'

coefficient: float

value: float | None = None

esd: float | None = None

unavailable: str | None = None

class rx.Moment

A magnetic moment on a site, in crystal-axis components (μ_B).

crystalaxis_x: Parameter = Parameter(0.0)

crystalaxis_y: Parameter = Parameter(0.0)

crystalaxis_z: Parameter = Parameter(0.0)

ion: str

g: float | None = None

class rx.MomentAngleTest

One round of the stationary-angle test on a stage’s covariance (WP-1929).

paths: list[str]

reached: bool

statistic: float | None = None

cut: float

zeroed: bool

stationary_at: dict[str, float] = {}

half_widths: dict[str, float] = {}

class rx.NodeAction

The edge operation that produced a node from its parent or parents.

kind: 'root' | 'stage' | 'set_vary' | 'set_value' | 'set_tie' | 'set_variable' | 'set_hold' | 'edit_model' | 'merge'

name: str = ''

turn_on: list[str] = []

turn_off: list[str] = []

values: dict[str, float] = {}

max_iter: int = 100

lebail_cycles: int = 3

seed: float = 0.0

strain_seed: float = 0.0

restraint_weight_scale: float = 1.0

ftol: float | None = None

window_slack_deg: float | None = None

window_area_tol: float | None = None

phase_support_sigma: float | None = 3.0

correlation_guard: float = 0.98

ties: dict[str, TieSpec] = {}

untied: list[str] = []

variables: dict[str, Parameter] = {}

removed_variables: list[str] = []

held: list[str] = []

unheld: list[str] = []

class rx.NodeMetrics

Cached scalars so queries (best, compare) need no recompute.

statistics: Statistics | None = None

status: 'converged' | 'max_iter' | 'diverged' | None = None

n_iterations: int = 0

cost_initial: float | None = None

cost_final: float | None = None

stderr: dict[str, float] = {}

held_scale_phases: list[int] = []

exception rx.NoPhasesError

An exception. A refining verb was handed a model with no phases (WP-1207).

class rx.ObservedPeak

One measured line: a fitted position with its esd, width, shape, area.

two_theta: float

two_theta_esd: float

two_theta_esd_fit: float | None = None

intensity: float

intensity_esd: float

q: float

q_esd: float

fwhm: float

eta: float

group: int

n_in_group: int

chi2_red: float

flags: list['ghost_kbeta' | 'ghost_tungsten' | 'excluded' | 'fit_failed' | 'sigma_assumed' | 'unresolved_shoulder' | 'position_at_bound' | 'asymmetry_unmodelled' | 'not_separable' | 'background_extrapolated' | 'axial_tail' | 'kalpha2_residual' | 'no_intensity' | 'unnamed_neighbour' | 'position_unmeasured' | 'duplicate_line' | 'weak_line' | 'unresolved_split' | 'width_capped'] = []

origin: 'fitted' | 'manual' | 'edited' = 'fitted'

class rx.ParameterCandidate

One held-but-refinable parameter, scored at the current state.

path: str

gain: float

gradient: float

absorption: float = 0.0

seeded: bool = False

seed_value: float | None = None

action_kind: str | None = None

class rx.ParameterInterval

The profile interval for one refined parameter.

path: str

value: float

stderr: float | None

at_bound: bool | None

level: float

one_sided: bool

quantile: float

delta_chi2_cut: float

lower: float | None

upper: float | None

lower_stop: 'threshold' | 'bound' | 'refits' | 'error' | 'period'

upper_stop: 'threshold' | 'bound' | 'refits' | 'error' | 'period'

chi2_fit: float

chi2_lowest: float

fit_is_minimum: bool

points: list[ParameterIntervalPoint] = []

n_refits: int

class rx.ParameterIntervalPoint

One pinned value and the lowest data χ² its refits reached there.

value: float

runs: int

chi2: float | None = None

delta_chi2: float | None = None

status: str | None = None

error: str | None = None

node_id: str | None = None

class rx.ParametricCoefficient

One refined coefficient of a ParametricEquation, in user units.

equation: str

target: str

term: str

path: str

value: float

esd: float | None

vary: bool

unit: str | None

reference: dict[str, float] | None

class rx.ParametricEquation

One target refined as a declared linear function of the coordinates.

name: str

target: str

basis: 'constant' | 'polynomial' | 'design'

terms: list[list[str]] | None = None

design: list[list[float]] | None = None

patterns: list[int] | None = None

reference: dict[str, float] | None = None

scale: dict[str, float] | None = None

class rx.ParametricFormReading

One reading of a form test (ParametricFormTest), or of every tested declaration at once (RefinementResult.parametric_form_joint <rietx.schemas.results.RefinementResult.parametric_form_joint>).

dof: int

statistic: float | None

cut: float | None

rejected: bool | None

p_value: float | None

class rx.ParametricFormTest

Whether one ParametricEquation’s form survives its own data.

equation: str

target: str

n_patterns: int

n_subset: int

rejected: bool | None

tied: ParametricFormReading | None

others_freed: ParametricFormReading | None

provisional_on: list[str]

class rx.ParametricValue

One declaration’s target evaluated at a coordinate, with its esd.

equation: str

target: str

coordinates: dict[str, float]

row: list[float] | None

value: float

esd: float | None

unit: str | None

outside: list[str] | None

form_rejected: bool | None

provisional_on: list[str]

joint_rejected: bool | None

class rx.PeakComponent

One declared sharp pseudo-Voigt peak the phases cannot account for.

center: Parameter = Parameter(0.0)

area: Parameter = Parameter(0.0, min=0.0)

fwhm: Parameter = Parameter(0.1, min=0.005, max=0.5)

eta: Parameter = Parameter(0.5, min=0.0, max=1.0)

all_lines: bool = True

kind: 'peak' = 'peak'

label: str | None = None

class rx.PeakList

Every resolvable line in one pattern, with per-line σ.

peaks: list[ObservedPeak]

wavelength: float

two_theta_min: float

two_theta_max: float

source: 'fitted' | 'positions' = 'fitted'

thresholds_version: str = '1.11'

diagnostics: list[Diagnostic] = []

class rx.PhaseAgreement

One phase’s structure-sensitive agreement indices (WP-1069).

name: str

r_bragg: float | None = None

r_f: float | None = None

n_reflections: int = 0

class rx.PhaseMicrostructure

A phase’s size and strain as physical numbers, with esds (WP-1131).

phase_index: int

phase_name: str = ''

wavelength: float | None = None

scherrer_k: float

terms: list[MicrostructureTerm] = []

size_agreement: float | None = None

strain_agreement: float | None = None

separable: bool | None = None

size_strain_collinearity: float | None = None

class rx.PhaseQuantity

One phase’s quantitative-analysis row (Hill & Howard, 1987).

name: str

weight_fraction: float | None

weight_fraction_stderr: float | None = None

scale: float

z: int | None = None

molar_mass: float | None = None

cell_mass: float

cell_volume: float

zmv: float

weight_fraction_corrected: float | None = None

brindley_tau: float | None = None

mu_cm: float | None = None

mu_r: float | None = None

particle_radius_um: float | None = None

class rx.PhaseTexture

One phase’s spherical-harmonics texture at the answer (WP-1960).

name: str

texture_index: float

min_p_reflections: float

min_p_sphere: float

rx.PLAN_PRESETS

A dict. Keys: mccusker_default, mccusker_structural, lab_bragg_brentano, lab_calibrate, lab_sample_refine, profile_only, pawley_default, magnetic_width.

class rx.PlanInfo

What a preset is for, in the words a chooser needs.

title: str

description: str

modes: tuple[Mode, ...]

when_to_use: str

class rx.PlanSpec

A staged plan as data that round-trips through JSON, mirroring RefinementPlan.

stages: list[StageSpec] = []

correlation_guard: float = 0.98

intermediate_ftol: float | None = 1e-06

lebail_passes: int = 1

phase_support_sigma: float | None = 3.0

closing_window_tol: float | None = 0.001

class rx.ProfileTOF

GSAS type-3 time-of-flight profile coefficients.

alpha0: Parameter = Parameter(0.0)

alpha1: Parameter = Parameter(0.0)

beta0: Parameter = Parameter(0.0)

beta1: Parameter = Parameter(0.0)

sig0: Parameter = Parameter(0.0, min=0.0)

sig1: Parameter = Parameter(0.0, min=0.0)

sig2: Parameter = Parameter(0.0, min=0.0)

gam0: Parameter = Parameter(0.0)

gam1: Parameter = Parameter(0.0)

gam2: Parameter = Parameter(0.0)

class rx.ProjectDoc

The settings half of a project, stored as project.json (see the module docstring).

format_version: str = '1.5'

package_version: str = ''

created_utc: str = ''

updated_utc: str = ''

patterns: list[DataRef] = []

plan: PlanSpec | None = None

mode: 'rietveld' | 'lebail' | 'pawley' = 'rietveld'

two_theta_limits: tuple[float, float] | None = None

excluded_regions: list[tuple[float, float]] = []

indexing: IndexingControls = IndexingControls(…)

history_file: str = 'history.jsonl'

ui: dict[str, Any] = {}

class rx.ProjectFormat

One foreign refinement format this build reads, and how it is recognised.

name: str

title: str

extensions: tuple[str, ...]

sniff: str

carries: tuple[str, ...]

reports_at: 'read' | 'build' | 'both'

matches: Callable[[Path], bool]

read: Callable[..., Any]

to_structure: Callable[..., Structure]

write: Callable[..., None] | None = None

refuses: str | None = None

class rx.ProjectModel

What a foreign refinement file stated, and which format stated it.

format: ProjectFormat

path: Path

stated: Any

diagnostics: tuple[Diagnostic, ...] = ()

class rx.Provenance

Everything needed to reproduce a result.

package_version: str

schema_version: str = '0.59'

backend: str = 'numpy'

dtype: str = 'float64'

solver: str = 'trf'

report_thresholds_version: str = '0.1'

created_utc: str | None = None

notes: dict[str, str] = {}

class rx.QuantitativePhaseAnalysis

Per-phase weight fractions from the refined Rietveld scales.

phases: list[PhaseQuantity]

method: 'zmv' = 'zmv'

crystalline_only: bool = True

unmeasured_phases: list[str] = []

unmeasured_held: list[str] = []

microabsorption: MicroabsorptionCorrection | None = None

microabsorption_skipped: str | None = None

class rx.Recipe

One PowderLine recipe, resolved into what this package refines with.

structure: Structure

instrument: Instrument

pattern: PatternData

plan: RefinementPlan

limits: tuple[float, float] | None

diagnostics: list[Diagnostic] = []

schema_name: str = 'GSASII_Rietveld'

schema_version: str = '0.26.0'

phase_names: tuple[str, ...] = ()

exception rx.RecipeError

An exception. A recipe this reader refuses, naming the field that caused it.

class rx.RefinedParametricEquation

One parametric declaration as the fit resolved it, with what a reader needs to evaluate it anywhere (WP-1325).

equation: ParametricEquation

unit: str | None

span: dict[str, tuple[float, float]]

covariance: list[list[float]] | None

exception rx.RefinementCancelled

An exception. Raised out of a fit whose CancelToken was set.

class rx.RefinementState

Everything needed to reconstruct a refinement exactly.

structure: Structure

instrument: Instrument

mode: 'rietveld' | 'lebail' | 'pawley' = 'rietveld'

free_paths: list[str] = []

free_declared: bool = False

two_theta_limits: tuple[float, float] | None = None

reflections: list[ReflectionState] = []

ties: dict[str, TieSpec] = {}

variables: dict[str, Parameter] = {}

holds: list[str] = []

class rx.RefinementTree(header: TreeHeader, *, path: str | Path | None = None)

A record of every state a refinement passed through, and how.

class rx.ReflectionPairScreen

Evidence behind a shift measured from harmonic reflection pairs.

n_pairs: int

n_candidate_triples: int

n_clustered: int

null_k_mean: float

null_k_std: float

z: float

p_value: float

null_replicates: int

seed: int

scatter_deg: float

refuted_templates: list[str] = []

declined_reason: str | None = None

class rx.ReflectionRow

One (emission line, reflection) row of a reflection table.

phase: str

line: int

wavelength: float

h: int

k: int

l: int

d: float

two_theta: float

multiplicity: int

f_squared: float | None

intensity: float

satellite_order: int = 0

component: str = 'total'

phase_index: int = 0

class rx.ReflectionState

Per-hkl intensities, the state that is not in the parameter vector.

phase_index: int

hkl: list[list[int]] = []

satellite_order: list[int] | None = None

intensity: list[float] = []

kind: 'lebail_extracted' | 'pawley_refined' = 'lebail_extracted'

stderr: list[float] | None = None

varied: bool = False

class rx.RegionAttribution

What a locally linear model says is wrong in one region.

two_theta_lo: float

two_theta_hi: float

n_reflections: int

chi2_share: float

mean_two_theta: float

mean_fwhm: float

coefficients: list[BasisCoefficient] = []

r2: float

gram_condition: float

chi2_reduced: float = 0.0

has_significant_misfit: bool = True

gates_passed: bool

gate_failures: list[GateFailure] = []

class rx.RestraintReport

Per-restraint deviations and the pooled restraint χ² (WP-0406).

rows: list[RestraintRow]

restraint_chi2: float

n_restraints: int

weight_scale: float = 1.0

class rx.RestraintRow

One soft restraint’s computed-vs-target deviation (WP-0406).

phase_index: int | None = None

kind: 'bond' | 'angle' | 'value' | 'tether' | 'anti_bump'

atoms: list[int] | None = None

path: str | None = None

computed: float

target: float

sigma: float

weight: float = 1.0

deviation: float

deviation_over_sigma: float

class rx.RigidBody

A set of a phase’s atoms that moves as one rigid template (WP-1805, #561).

name: str

atoms: list[str]

template: list[tuple[float, float, float]]

origin: BodyOrigin

orientation: tuple[float, float, float, float] = (1.0, 0.0, 0.0, 0.0)

rotation_vary: bool = False

torsions: list[BodyTorsion] = []

riding: list[str] = []

class rx.RoughnessPitschke

Surface-roughness intensity correction, Pitschke et al. (1993) form.

kind: 'pitschke' = 'pitschke'

c: Parameter = Parameter(0.0, min=0.0, max=4.0)

tau: Parameter = Parameter(0.05, min=0.0, max=0.3)

class rx.RoughnessSuortti

Surface-roughness intensity correction, Suortti (1972) form.

kind: 'suortti' = 'suortti'

a: Parameter = Parameter(0.5, min=0.0, max=1.0)

b: Parameter = Parameter(0.0, min=0.0, max=5.0)

class rx.SearchSpecSpec

Mirrors indexing.engines.SearchSpec; every engine reads the same one.

systems: list[str] | None = None

centrings: dict[str, list[str]] | None = None

min_d_axis: float = 2.0

max_d_axis: float = 25.0

min_volume: float = 15.0

max_volume: float | None = None

n_unindexed: int | 'inliers' | None = None

n_search_lines: int = 20

k_sigma: float = 3.0

shift_allowance_deg: float = 0.0

shift_template: str | None = None

budget_seconds: float = 30.0

total_budget_seconds: float | None = None

preset: str | None = None

max_candidates: int = 12

seed: int = 0

prior_cells: list[tuple[float, float, float, float, float, float]] | None = None

prior_spacegroups: list[str] | None = None

class rx.SeriesFailure

One pattern the chain could not fit at all.

index: int

label: str

exception: str

class rx.SeriesStep

One step SEQUENTIAL_DISCONTINUITY flagged, as fields (WP-1469).

path: str

labels: tuple[str, str]

indices: tuple[int, int]

step: float

class rx.SharingMap

Which parameter paths are shared across histograms vs.

per_histogram: list[str] = []

shared: list[str] = []

class rx.ShiftScreen

Which physical cause a systematic 2θ shift has, or that it has none that can be named over the range measured.

n_lines: int

templates: list[ShiftTemplateFit] = []

best: str | None = None

separable: bool = False

separability_ratio: float = 0.0

max_collinearity: float = 0.0

sigma_sys_deg: float = 0.0

prediction_spread_deg: float = 0.0

allowance_deg: float = 0.0

source: 'measured' | 'reflection_pairs' | 'unavailable' = 'unavailable'

pairs: ReflectionPairScreen | None = None

class rx.ShiftTemplateFit

One systematic-shift template fitted alone to the deviations.

name: str

coefficient: float

stderr: float

r2: float

residual_ss: float

class rx.SoftMode

One near-null direction of the scale-normalised normal matrix.

eigenvalue: float

loadings: dict[str, float] = {}

class rx.SphericalHarmonicTexture

Spherical-harmonics preferred-orientation correction (Von Dreele 1997).

order: int

coefficients: dict[str, Parameter] = {}

class rx.StageSpec

One stage of a staged plan as data that round-trips through JSON, mirroring Stage.

name: str

turn_on: list[str] = []

max_iter: int = 100

ftol: float | None = None

lebail_cycles: int = 3

seed: float = 0.0

strain_seed: float = 0.0

restraint_weight_scale: float = 1.0

window_slack_deg: float | None = None

class rx.SuggestedAction

An advisory, typed suggestion.

kind: 'refine_zero_shift' | 'refine_sample_displacement' | 'refine_sample_transparency' | 'refine_capillary_offset_along_beam' | 'refine_capillary_offset_across_beam' | 'refine_cell' | 'refine_profile_widths' | 'refine_sample_size_broadening' | 'refine_sample_strain_broadening' | 'refine_axial_asymmetry' | 'refine_biso' | 'refine_preferred_orientation' | 'refine_scale' | 'add_impurity_phase' | 'increase_background_flexibility' | 'decrease_background_flexibility' | 'reindex_or_recheck_cell' | 'collect_better_data'

confidence: float

rationale: str

parameter_paths: list[str] = []

expected_delta_chi2: float | None = None

alternatives: list['refine_zero_shift' | 'refine_sample_displacement' | 'refine_sample_transparency' | 'refine_capillary_offset_along_beam' | 'refine_capillary_offset_across_beam' | 'refine_cell' | 'refine_profile_widths' | 'refine_sample_size_broadening' | 'refine_sample_strain_broadening' | 'refine_axial_asymmetry' | 'refine_biso' | 'refine_preferred_orientation' | 'refine_scale' | 'add_impurity_phase' | 'increase_background_flexibility' | 'decrease_background_flexibility' | 'reindex_or_recheck_cell' | 'collect_better_data'] = []

two_theta_range: tuple[float, float] | None = None

vetoed_by: str | None = None

execution: 'stage' | 'index' | 'advice' | None = None

class rx.SupercellCheck

This candidate asked as a superlattice of another reported candidate.

parent_cell: tuple[float, float, float, float, float, float]

parent_system: str

parent_centring: str

index: int

n_extra: int

n_seen: int

p0: float

p_value: float

n_seen_unexplained: int | None = None

verdict: 'supported' | 'refuted' | 'undecided'

absent_two_theta: list[float] = []

class rx.TetherRestraint

A one-sided distance restraint: zero inside max_distance, linear outside.

atom_i: int

atom_j: int

max_distance: float

sigma: float

weight: float = 1.0

op_index: int | None = None

translation: tuple[int, int, int] = (0 × 3)

class rx.TieSpec

The JSON form of params.vector.AffineTie, value = Σ c·src + k.

terms: list[tuple[str, float]] = []

const: float = 0.0

user: bool = False

class rx.TOFSource

Neutron time-of-flight bank: a white beam, a fixed detector angle.

kind: 'neutron_tof' = 'neutron_tof'

difc: Parameter

difa: Parameter = Parameter(0.0)

tzero: Parameter = Parameter(0.0)

difb: Parameter = Parameter(0.0)

two_theta_bank_deg: float

l1_m: float | None = None

l2_m: float | None = None

profile_tof: ProfileTOF = ProfileTOF(…)

incident_spectrum: IncidentSpectrum = IncidentSpectrum(…)

class rx.Trajectory

One parameter’s path across the series, with its per-point esds.

path: str

x: list[float] = []

x_label: str = 'index'

value: list[float] = []

stderr: list[float | None] = []

labels: list[str] = []

positions: list[int] = []

class rx.TreeHeader

Identifies the tree and the pattern every node is fitted against.

tree_id: str

created_utc: str = ''

data_fingerprint: str = ''

data_source: str = ''

n_points: int = 0

plan: PlanSpec | None = None

package_version: str = ''

schema_version: str = '0.59'

class rx.ValueRestraint

A soft restraint pulling a single parameter toward target.

path: str

target: float

sigma: float

weight: float = 1.0