orochi.pdfsim 4.0.0__py3-none-any.whl

orochi/__init__.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python
+##############################################################################
+#
+# (c) 2025 National Institute for Materials Science (NIMS).
+# All rights reserved.
+#
+# File coded by: Tominaka Laboratory members and community contributors.
+#
+# See GitHub contributions for a more detailed list of contributors.
+# https://github.com/Tominaka-Laboratory/orochi.pdf-simulator/graphs/contributors
+#
+# See LICENSE.rst for license information.
+#
+##############################################################################
+"""Blank namespace package for module orochi."""
+
+
+from pkgutil import extend_path
+
+__path__ = extend_path(__path__, __name__)
+
+# End of file

orochi/pdfsim/__init__.py

@@ -0,0 +1,4 @@
+from .simulator import Simulator
+
+__all__ = ["Simulator"]
+

orochi/pdfsim/_old/no_q_depend.py

@@ -0,0 +1,84 @@
+#old one before refactoring
+
+# import numpy as np
+# from numpy.typing import NDArray
+
+# def calc_gij(self, aij: NDArray[np.int64]) -> NDArray[np.float64]:
+#     """
+#     Calculates the scattering factor product g_ij (Q-independent).
+
+#     This function calculates the scattering factor product g_ij, assuming that
+#     the atomic scattering factors are independent of the scattering vector Q.
+#     This simplification is often used for simpler models or when Q-dependence
+#     is not significant.  The calculation uses the atomic numbers (zi) to
+#     approximate the scattering factors.
+
+#     Parameters
+#     ----------
+#     self : Simulator
+#         The Simulator object, which must contain the atomic numbers (zi)
+#         and atomic symbols.
+#     aij : NDArray[np.int64]
+#         A 2D array representing the atomic pairs. Each row contains the indices
+#         of the two atoms in a pair.
+
+#     Returns
+#     -------
+#     numpy.ndarray
+#         A 1D NumPy array representing g_ij, the scattering factor product
+#         for each atomic pair.
+
+#     Notes
+#     -----
+#     The function performs the following steps:
+#     1.  Retrieves the atomic numbers zi for each unique atom.
+#     2.  Assigns the corresponding zi to each atom in the pairs defined by aij.
+#     3.  Calculates the product of the atomic numbers for each pair.
+#     4.  Normalizes the product by the square of the average atomic number,
+#         weighted by the atomic occupancies.
+#     """
+#     symbols_all = self.phase.model["symbol"]
+#     occ = self.phase.model["occ"]
+
+#     sfs = np.ones_like(symbols_all).astype(float)
+#     fij = np.ones_like(aij).astype(float)
+
+#     symbols = np.unique(symbols_all)
+#     for atom in symbols:
+#         zi = self.zi[atom]
+#         sfs[np.where(symbols_all == atom)] = zi
+#         fij[np.where(aij == atom)] = zi
+
+#     gij = np.abs(fij[:, 0] * fij[:, 1])
+#     gij /= np.square(np.average(sfs * occ))  # fij/<cf>2
+#     return gij
+
+
+
+# def calc_scattering_factors(self) -> NDArray[np.float64]:
+#     """
+#     Calculates the atomic scattering factors (Q-independent approximation).
+
+#     This function calculates the atomic scattering factors f(Q) using the
+#     approximation that they are equal to the atomic numbers (zi).  This
+#     is a simplification that neglects the Q-dependence of the scattering factors.
+
+#     Parameters
+#     ----------
+#     self : Simulator
+#         The Simulator object, which must contain the atomic symbols and
+#         atomic numbers (zi).
+
+#     Returns
+#     -------
+#     numpy.ndarray
+#         A 1D NumPy array of the atomic scattering factors f(Q) for each atom
+#         in the structure.
+#     """
+#     symbols_all = self.phase.model["symbol"]
+#     sfs = np.ones_like(symbols_all).astype(float)
+#     symbols = np.unique(symbols_all)
+#     for atom in symbols:
+#         zi = self.zi[atom]
+#         sfs[np.where(symbols_all == atom)] = zi
+#     return sfs

orochi/pdfsim/_old/q_depend.py

@@ -0,0 +1,123 @@
+# import numpy as np
+# from scipy.fft import dct
+# import scipy.interpolate as intp
+# from numpy.typing import NDArray
+
+# def calc_gij(self, aij: NDArray[np.int64]) -> NDArray[np.complex128]:
+#     """
+#     Calculates the scattering factor product g_ij(Q) with Q-dependence.
+
+#     This function calculates the scattering factor product g_ij(Q), which accounts for
+#     the Q-dependence of the atomic scattering factors.  This is important for accurate
+#     PDF calculations, especially when dealing with materials containing elements with
+#     significant differences in their scattering factors.  The calculation involves
+#     obtaining the atomic scattering factors f0, f1, and f2, and then performing
+#     a discrete cosine transform (DCT) to obtain the real-space representation.
+
+#     Parameters
+#     ----------
+#     self : Simulator
+#         The Simulator object, which must contain the atomic scattering factors
+#         (f0s, f1f2s), atomic symbols, and relevant parameters (qmax, number_scf_function, pad).
+#     aij : NDArray[np.int64]
+#         A 2D array representing the atomic pairs.  Each row contains the indices
+#         of the two atoms in a pair.
+
+#     Returns
+#     -------
+#     NDArray[np.complex128]
+#         A 2D NumPy array representing g_ij(r), the scattering factor product
+#         in real space. The shape is (n_pairs, n_r_points).
+
+#     Notes
+#     -----
+#     The function performs the following steps:
+#     1.  Creates a Q-space vector.
+#     2.  Retrieves atomic scattering factors f0, f1, f2 for each unique atom.
+#     3.  Calculates the scattering factor product for each atomic pair.
+#     4.  Calculates the average scattering factor.
+#     5.  Normalizes the scattering factor product.
+#     6.  Applies a Discrete Cosine Transform (DCT) to obtain the real-space
+#         representation.
+#     7.  Interpolates the result to match the desired r-space grid.
+#     """
+#     q = np.linspace(0, self["qmax"], self["number_scf_function"])
+#     symbols_all = self.phase.model["symbol"]
+#     sfs = np.zeros((symbols_all.size, q.size)) + 0.0j
+#     fij = np.ones(np.append(aij.shape, q.size)).astype(float) + 0.0j
+
+#     symbols = np.unique(symbols_all)
+#     for atom in symbols:
+#         f0 = self.f0s[atom](q)
+#         f1, f2 = self.f1f2s[atom](self["energy"])
+#         sf = f0 + f1 + 1.0j * f2
+#         sfs[np.where(symbols_all == atom)] = sf
+#         fij[np.where(aij == atom)] = sf
+
+#     gij = fij[:, 0] * fij[:, 1]
+#     occ = self.phase.model["occ"]
+#     ave = np.average(sfs * occ[:, np.newaxis], axis=0)
+#     gij /= np.square(ave)  # fij/<cf>2
+#     gij = np.abs(gij)
+
+#     number_scf_function = self["number_scf_function"] * self["pad"]
+#     gij = dct(gij, n=number_scf_function, type=2, norm=None, axis=1) / (
+#         2.0 * number_scf_function
+#     )
+
+#     if (self.r[1] - self.r[1]) != (self["qmax"] * np.float64(self["pad"])):
+#         r = (
+#             np.arange(0, np.float64(number_scf_function), 1.0)
+#             * np.pi
+#             / (self["qmax"] * np.float64(self["pad"]))
+#         )
+#         r_new = np.arange(r[0], r[-1], self.r[1] - self.r[0])
+#         gij_new = np.empty((0, r_new.size))
+
+#         for g in gij:
+#             gn = intp.interp1d(r, g, fill_value=0.0)(r_new)
+#             gij_new = np.append(gij_new, gn.reshape(1, -1), axis=0)
+
+#         norm = np.sum(gij, axis=-1)
+#         gij = gij_new
+#         norm2 = np.sum(gij, axis=-1)
+#         gij = gij / norm2[:, np.newaxis] * norm[:, np.newaxis]
+
+#     gij = np.append(gij[:, :0:-1], gij, axis=-1)
+#     return gij
+
+
+
+# def calc_scattering_factors(self) -> NDArray[np.complex128]:
+#     """
+#     Calculates the atomic scattering factors with Q-dependence.
+
+#     This function calculates the atomic scattering factors f(Q) for all unique atomic
+#     symbols in the Phase object.  It combines the contributions from the
+#     normal scattering factor (f0) and the anomalous scattering factors (f1, f2),
+#     which are energy-dependent.
+
+#     Parameters
+#     ----------
+#     self : Simulator
+#         The Simulator object, which must contain the atomic symbols,
+#         the Q-values, and the functions to calculate f0, f1, and f2
+#         (self.f0s, self.f1f2s).
+
+#     Returns
+#     -------
+#     numpy.ndarray
+#         A 2D NumPy array of the atomic scattering factors f(Q) for each atom.
+#         The shape is (n_atoms, n_q_points). The values are complex.
+#     """
+#     symbols = np.unique(self.symbols)
+#     q = np.linspace(0, self["qmax"], self["number_scf_function"])
+#     sfs = np.zeros((self.symbols.size, q.size)) + 0.0j
+
+#     for atom in symbols:
+#         f0 = self.f0s[atom](q)
+#         f1, f2 = self.f1f2s[atom](self["energy"])
+#         sf = f0 + f1 + 1.0j * f2
+#         sfs[np.where(self.symbols == atom)] = sf
+
+#     return sfs

orochi/pdfsim/gr_histogram/_old/cpu.py

@@ -0,0 +1,313 @@
+#old one before refactoring
+
+# import numpy as np
+
+
+# def calc_gr_histogram(self, q_dependence=False):
+#     """
+#     Prepares for the pair distribution function g(r) histogram calculation using CPU.
+
+#     This function prepares the histogram for calculating the pair distribution
+#     function (PDF) g(r). It groups pair data to enhance computational
+#     efficiency by performing similar calculations in batches. Based on the
+#     `q_dependence` parameter, it selects the appropriate structure factor
+#     and PDF calculation functions.
+
+#     Parameters
+#     ----------
+#     self : Calculator
+#         An instance of the Calculator class for PDF calculation.
+#     q_dependence : bool, optional
+#         A flag indicating whether to consider Q-dependent structure factors.
+#         Defaults to False.
+
+#     Returns
+#     -------
+#     r : numpy.ndarray
+#         Array of radial distances r.
+#     gr : numpy.ndarray
+#         The calculated histogram of the pair distribution function g(r).
+
+#     Notes
+#     -----
+#     This function calculates the histogram through the following steps:
+
+#     1.  Determines the range of pair data to be used for calculation using
+#         the `set_r_range` function.
+#     2.  Groups the pair data using the `grouping` function.
+#     3.  Selects the appropriate structure factor and PDF calculation functions
+#         based on the `q_dependence` parameter.
+#     4.  Calculates the histogram of g(r) using the selected functions.
+#     5.  Normalizes the histogram if necessary.
+
+#     """
+#     # data_in_r_range = set_r_range(self)
+#     ai = self.pairs["symbol"][:, 0]
+#     aj = self.pairs["symbol"][:, 1]
+#     rij = self.pairs["distance"]
+#     sij = self.pairs["adp"]
+#     cij = self.pairs["occ"]
+#     r = self.r
+#     r_pair = self.r_pair
+
+
+#     grouped_pairs = grouping(self, rij, cij, sij, ai, aj, r)
+#     rij = grouped_pairs["rij"]
+#     cij = grouped_pairs["cij"]
+#     sij = grouped_pairs["sij"]
+#     bin_min = grouped_pairs["bin_min"]
+#     bin_max = grouped_pairs["bin_max"]
+#     same_aij_groups = grouped_pairs["same_aij_groups"]
+#     same_uij_groups = grouped_pairs["same_uij_groups"]
+#     unique_aij = grouped_pairs["unique_aij"]
+
+#     if q_dependence:
+#         from ..structure_factor.q_depend import calc_gij
+#         from .histogram.pdf_q_depend_cpu import calc_pdf
+#     else:
+#         from ..structure_factor.no_q_depend import calc_gij
+#         from .histogram.pdf_no_q_depend_cpu import calc_pdf
+
+#     gij = calc_gij(self, unique_aij)
+#     gr = calc_pdf(
+#         r,
+#         rij,
+#         cij,
+#         sij,
+#         gij,
+#         same_aij_groups,
+#         same_uij_groups,
+#         bin_min,
+#         bin_max,
+#         r_pair,
+#     )
+
+#     if not q_dependence:
+#         gr /= r
+
+#     gr *= (self["qmax"] * self["pad"]) / np.pi
+#     gr /= self.phase.model["occ"].size
+#     return r, gr
+
+
+# def calc_simulation_range(self, r_pair):
+#     """
+#     Calculates the simulation range.
+
+#     This function determines the range of data to be used for PDF calculation
+#     based on the provided `r_pair`. The calculation range is determined by the
+#     minimum and maximum values of `self.r` extended by the range of `r_pair`.
+
+#     Parameters
+#     ----------
+#     self : Calculator
+#         An instance of the Calculator class for PDF calculation.
+#     r_pair : numpy.ndarray
+#         Array of pair distances r_ij.
+
+#     Returns
+#     -------
+#     numpy.ndarray
+#         An array of indices representing the simulation range.
+#     """
+#     eval_min = self.r[0] - r_pair[-1] 
+#     eval_max = self.r[-1] + r_pair[-1]
+
+#     if eval_min <= 0:
+#         eval_min = 0
+#     simulation_range = np.where((self.rij > eval_min) & (self.rij < eval_max))
+#     return simulation_range[0]
+
+
+# def make_bins(self, r, rij):
+#     """
+#     Generates histogram bins.
+
+#     This function generates histogram bins based on the provided arrays of
+#     radial distances `r` and pair distances `rij`. It calculates which bins
+#     each `rij` value contributes to and returns the minimum and maximum
+#     bin indices for each pair.
+
+#     Parameters
+#     ----------
+#     self : Calculator
+#         An instance of the Calculator class for PDF calculation.
+#     r : numpy.ndarray
+#         Array of radial distances r.
+#     rij : numpy.ndarray
+#         Array of pair distances r_ij.
+
+#     Returns
+#     -------
+#     bin_min : numpy.ndarray
+#         Array of minimum bin indices for each rij value.
+#     bin_max : numpy.ndarray
+#         Array of maximum bin indices for each rij value.
+#     """
+#     rstep = r[1] - r[0]
+#     shift = (rij - r[0]) // rstep + 1
+#     rmax_id = r.size - 1
+
+#     n = self.num_p_peak - 1
+#     bin_min = shift - n
+#     bin_max = shift + n
+
+#     bin_min[bin_min > rmax_id] = -1
+#     bin_min[bin_min < 0] = 0
+#     bin_max[bin_max < 0] = 1
+#     return bin_min.flatten(), bin_max.flatten()
+
+
+# # def grouping(self, rij, cij, sij, ai, aj, r):
+# #     """
+# #     Groups pair data.
+
+# #     This function groups pair data based on the atomic pair type (ai, aj) and
+# #     the mean-square relative displacement (sij) to enhance the efficiency of
+# #     PDF calculation. It organizes the data so that similar calculations can
+# #     be performed together.
+
+# #     Parameters
+# #     ----------
+# #     self : Calculator
+# #         An instance of the Calculator class for PDF calculation.
+# #     rij : numpy.ndarray
+# #         Array of pair distances r_ij.
+# #     cij : numpy.ndarray
+# #         Array of coherence lengths c_ij.
+# #     sij : numpy.ndarray
+# #         Array of mean-square relative displacements u_ij.
+# #     ai : numpy.ndarray
+# #         Array of indices for atom i.
+# #     aj : numpy.ndarray
+# #         Array of indices for atom j.
+# #     r : numpy.ndarray
+# #         Array of radial distances r.
+
+# #     Returns
+# #     -------
+# #     grouped_pairs : dict
+# #         A dictionary containing the grouped pair data.
+# #         Keys include 'rij', 'cij', 'sij', 'bin_min', 'bin_max',
+# #         'same_aij_groups', 'same_uij_groups', and 'unique_aij'.
+# #     """
+# #     grouped_pairs = {}
+
+# #     # order the aij array
+# #     aij = self.pair["symbol"]
+# #     aij = np.sort(aij, axis=-1)
+# #     self.pair_name = aij[:, 0].astype(object) + aij[:, 1].astype(object)
+# #     self.pair_order = np.argsort(self.pair_name)
+# #     aij = aij[self.pair_order]
+
+# #     unique_aij, index_aij, counts_aij = np.unique(
+# #         aij, return_index=True, return_counts=True, axis=0
+# #     )
+
+# #     index_sort = np.argsort(index_aij)
+# #     index_aij = index_aij[index_sort]
+# #     counts_aij = counts_aij[index_sort]
+# #     self.pair_group_bounds = index_aij + counts_aij
+
+
+
+# #     rij = self.pairs["distance"][sort]
+# #     cij = self.pairs["occ"][sort]
+# #     sij = self.pairs["adp"][sort]
+
+
+# #     # find unique aij for scattering_factors
+
+
+# #     rij = np.split(rij, same_aij_groups[:-1])
+# #     cij = np.split(cij, same_aij_groups[:-1])
+# #     sij = np.split(sij, same_aij_groups[:-1])
+
+#     # bin_min = np.split(bin_min, same_aij_groups[:-1])
+#     # bin_max = np.split(bin_max, same_aij_groups[:-1])
+
+#     # rearrange the par by sorting them on the basis of simga values (adps)
+#     # number_of_unique_aij = len(rij)
+#     # same_uij_groups = np.array([])
+
+#     # for x in range(number_of_unique_aij):
+#     #     order_in_local_sigma = np.argsort(sij[x])
+#     #     sorted_local_sigma = sij[x][order_in_local_sigma]
+#     #     unique_local_sigma, counts = np.unique(
+#     #         sorted_local_sigma, return_counts=True, axis=0
+#     #     )
+
+#     #     rij[x] = rij[x][order_in_local_sigma]
+#     #     cij[x] = cij[x][order_in_local_sigma]
+#     #     sij[x] = sorted_local_sigma
+#     #     # bin_min[x] = bin_min[x][order_in_local_sigma]
+#     #     # bin_max[x] = bin_max[x][order_in_local_sigma]
+
+#     #     same_uij_groups = np.concatenate([same_uij_groups, counts], axis=0)
+
+#     # rij = np.concatenate(rij, axis=0)
+#     # cij = np.concatenate(cij, axis=0)
+#     # sij = np.concatenate(sij, axis=0)
+#     # bin_min = np.concatenate(bin_min, axis=0)
+#     # bin_max = np.concatenate(bin_max, axis=0)
+
+
+
+#     # grouped_pairs["rij"] = rij
+#     # grouped_pairs["cij"] = cij
+#     # grouped_pairs["sij"] = sij
+#     # grouped_pairs["bin_min"] = bin_min
+#     # grouped_pairs["bin_max"] = bin_max
+#     # grouped_pairs["same_aij_groups"] = same_aij_groups
+#     # # grouped_pairs["same_uij_groups"] = same_uij_groups
+#     # # grouped_pairs["unique_aij"] = unique_aij
+
+#     # return grouped_pairs
+
+
+# # def set_r_range(self):
+# #     """
+# #     Sets the range of radial distances r to be used for calculation.
+
+# #     This function determines the range of radial distances r to be used for
+# #     PDF calculation. The range is calculated based on the specified r range
+# #     and the width of the Gaussian function. It also calls the
+# #     `calc_simulation_range` function to limit the calculation range.
+
+# #     Parameters
+# #     ----------
+# #     self : Calculator
+# #         An instance of the Calculator class for PDF calculation.
+
+# #     Returns
+# #     -------
+# #     data_in_r_range : dict
+# #         A dictionary containing the range of radial distances r to be used
+# #         for calculation, along with related pair data.
+# #         Keys include 'ai', 'aj', 'rij', 'sij', 'cij', 'r', and 'r_pair'.
+# #     """
+# #     # calculate evaluation range (from r[0] to r[-1] + gaussian width)
+
+# #     # data_in_r_range = {}
+
+# #     # rstep = self.r[1] - self.r[0]
+# #     # r_extension = self.num_p_peak / self["qmax"] * 2.0
+# #     # r_pair = np.arange(0.0, self.num_p_peak / self["qmax"], rstep)
+# #     # r_pair = np.append(-r_pair[:0:-1], r_pair)
+
+# #     r = np.arange(self.r[0], self.r[-1] + rstep + r_extension, rstep)
+
+# #     # limit simulation_range
+# #     sr = calc_simulation_range(self, r_pair)
+
+# #     data_in_r_range["ai"] = self.ai[sr]
+# #     data_in_r_range["aj"] = self.aj[sr]
+# #     data_in_r_range["rij"] = self.rij[sr]
+
+# #     sij = self.sij * self.peak_width
+# #     data_in_r_range["sij"] = sij[sr]
+# #     data_in_r_range["cij"] = self.cij[sr]
+# #     data_in_r_range["r"] = r
+# #     data_in_r_range["r_pair"] = r_pair
+
+# #     return data_in_r_range

orochi/pdfsim/gr_histogram/_old/epf.py

@@ -0,0 +1,60 @@
+# This is for future work
+
+
+def read_phase_for_epf(self):
+    self.read_phase_lattice()
+    self.read_phase_shape()
+    self.calc_translational_vector()
+
+
+def calc_gr_epf(self):
+    r, gr = self.calc_gr_histogram_for_epf()
+    gr *= (self["qmax"] * self["pad"]) / np.pi
+
+    density = self.calc_density(gr, r)
+    gr = self.convolution_with_q(gr, r, self["qmax"])
+    self.gr = intp.interp1d(r, gr, fill_value="extrapolate")(self.r)
+    self.density = intp.interp1d(r, density, fill_value="extrapolate")(self.r)
+
+
+def calc_gr_histogram_for_epf(self):
+    xyz = self["phase"]["map", "xyz"].reshape(-1, 3)
+    xyz = np.dot(self.g, xyz.T).T
+
+    map = self["phase"]["map", "value"]
+    map = map.flatten()
+    self.Np = np.sum(map)
+
+    rstep = self.r[1] - self.r[0]
+    r_extension = self.num_p_peak / self["qmax"]
+    r = np.arange(0, self.r[-1] + rstep + r_extension, rstep)
+
+    tvs = self.translational_vectors.reshape(-1, 3)
+
+    if self["sampling_probability"] != 1.0:
+        probability = self["sampling_probability"]
+        rand = np.random.rand(map.size)
+        use = np.where((rand < probability) | (map > np.amax(map) / 100.0))
+        xyz = xyz[use]
+        ratio = np.sum(map[use]) / np.sum(map)
+        map = map[use]
+        # self.par.logger.info("sampling probability: " + str(probability))
+
+    if self["simulation_type"] == "epf":
+        if self["processor_type"] == "cpu":
+            from orochi.pdfsim.calculator.epf_cpu import calc_epf_cpu
+
+            gr = calc_epf_cpu(map, xyz, tvs, r)
+            return r, gr / ratio**2.0
+
+        else:
+            from orochi.pdfsim.calculator.epf_gpu import calc_epf_gpu
+
+            gr = calc_epf_gpu(map, xyz, tvs, r)
+            return r, gr / ratio**2.0
+
+    elif self["simulation_type"] == "partial_epf":
+        from orochi.pdfsim.calculator.epf_partial import calc_partial_epf
+
+        origin = np.dot(self.g, np.array(self["partial_epf_origin"]))
+        return r, calc_partial_epf(map, xyz, tvs, r, origin)

orochi/pdfsim/gr_histogram/_old/gpu.py

@@ -0,0 +1,58 @@
+import numpy as np
+
+
+def calc_gr_histogram(self):
+    """
+    Calculates the pair distribution function g(r) histogram using GPU.
+
+    This function calculates the pair distribution function g(r) histogram
+    using GPU acceleration. It performs a direct calculation using CUDA without
+    the grouping strategy employed in the CPU version.
+
+    Parameters
+    ----------
+    self : Calculator
+        An instance of the Calculator class for PDF calculation.
+
+    Returns
+    -------
+    r : numpy.ndarray
+        Array of radial distances r.
+    gr : numpy.ndarray
+        The calculated histogram of the pair distribution function g(r).
+
+    Notes
+    -----
+    This function performs the following steps:
+
+    1.  Calculates the radial distances `r` and `r_rij`.
+    2.  Calculates the scattering factors using `calc_scattering_factors`.
+    3.  Obtains atomic coordinates, translational vectors, occupancies, and
+        atomic displacement parameters.
+    4.  Calls the CUDA-accelerated `calc_pdf` function to compute the histogram.
+    5.  Normalizes the resulting histogram.
+    """
+    rstep = self.r[1] - self.r[0]
+    r_extension = self.num_p_peak / 2.0 / self["qmax"]
+    r = np.arange(self.r[0], self.r[-1] + rstep + r_extension, rstep)
+
+    r_rij = np.arange(0.0, r_extension, rstep)
+    r_rij = np.append(-r_rij[:0:-1], r_rij)
+
+    from ..structure_factor.no_q_depend import calc_scattering_factors
+    from .histogram.pdf_no_q_depend_gpu import calc_pdf
+
+    sf = calc_scattering_factors(self)
+
+    xyz = self.phase.model["xyz"]
+    occ = self.phase.model["occ"]
+    adp = self.phase.model["adp"]
+    g = self.phase.model["lattice_vector"].T
+    xyz = np.dot(g, xyz.T).T
+    tvs = self.translational_vectors
+
+    gr = calc_pdf(xyz, tvs, occ, sf, adp, r, r_rij)
+    gr /= r
+    gr *= (self["qmax"] * self["pad"]) / np.pi
+    gr /= occ.size
+    return r, gr