glassure.transform module

glassure.transform.calculate_fr(sq_pattern: Pattern, r: ndarray | None = None, use_modification_fcn: bool = False, method: str = 'integral') → Pattern

Calculates F(r) from a given S(Q) pattern for r values. If r is None, a range from 0 to 10 with step 0.01 is used. A Lorch modification function of the form:

m = sin(q*pi/q_max)/(q*pi/q_max)

can be used to address issues with a low q_max. This will broaden the sharp peaks in g(r)

Parameters:

• sq_pattern – Structure factor S(Q) with lim_inf S(Q) = 1 and unit(q)=A^-1

• r – numpy array giving the r-values for which F(r) will be calculated, default is 0.01 to 10 with 0.01 as a step. units should be in Angstrom.

• use_modification_fcn – boolean flag whether to use the Lorch modification function

• method – determines the method used for calculating fr, possible values are: - ‘integral’ solves the Fourier integral, by calculating the integral - ‘fft’ solves the Fourier integral by using fast fourier transformation

Returns:

F(r) pattern

glassure.transform.calculate_gr(fr_pattern: Pattern, atomic_density: float) → Pattern

Calculates a g(r) pattern from a given F(r) pattern and the atomic density

Parameters:

• fr_pattern – F(r) pattern

• atomic_density – atomic density in atoms/A^3

Returns:

g(r) pattern

glassure.transform.calculate_rdf(gr_pattern: Pattern, atomic_density: float) → Pattern

Calculates a RDF pattern from a given g(r) pattern and the atomic density

RDF = 4 * pi * r^2 * g(r) * rho

Parameters:

• gr_pattern – g(r) pattern

• atomic_density – atomic density in atoms/A^3

Returns:

RDF pattern

glassure.transform.calculate_sq(normalized_pattern: Pattern, f_squared_mean: ndarray, f_mean_squared: ndarray) → Pattern

Calculates the Faber Ziman structure factor, using the equation: S(Q) = (n * Intensity - incoherent_scattering - <f>^2-)/<f^2> + 1 where n is the normalization factor and f are the scattering factors. The function takes in the already normalized intensity (incoherent scattering is also subtracted)

Parameters:

• normalized_pattern – Pattern with q and (n * Intensity - incoherent scattering) as x and y

• f_squared_mean – <f^2> - mean squared scattering factor for each q value in the pattern

• f_mean_squared – <f>^2 - squared mean scattering factor for each q value in the pattern

Returns:

S(Q) pattern

glassure.transform.calculate_sq_from_fr(fr_pattern: Pattern, q: ndarray | None = None, method: str = 'integral', use_modification_fcn: bool = False) → Pattern

Calculates S(Q) from an F(r) pattern for given q values.

Parameters:

• fr_pattern – input F(r) pattern

• q – numpy array giving the q-values for which S(q) will be calculated,

Returns:

F(r) pattern

glassure.transform.calculate_sq_from_gr(gr_pattern: Pattern, q: ndarray, atomic_density: float, method: str = 'integral') → Pattern

Performs a back Fourier transform from the pair distribution function g(r)

Parameters:

• gr_pattern – g(r) pattern

• q – numpy array of q values for which S(Q) should be calculated

• atomic_density – number_density in atoms/A^3

Returns:

S(Q) pattern

glassure.transform.calculate_tr(gr_pattern: Pattern, atomic_density: float) → Pattern

Calculates a transfer function from a given g(r) pattern and the atomic density

T(r) = 4 * pi * r * g(r) * rho = RDF/r

Parameters:

• gr_pattern – g(r) pattern

• atomic_density – atomic density in atoms/A^3

Returns:

transfer function