Fix changing r-grid issue in refine

Author: Sparks29032

docs/source/morphpy.rst

@@ -193,12 +193,6 @@ funcy: tuple (function, dict)
 funcx: tuple (function, dict)
     Apply a function to the x-axis of the (two-column) data.
 
-    This morph works fundamentally differently from the other grid morphs
-    (e.g. stretch and squeeze) as it directly modifies the grid of the
-    morph function.
-    The other morphs maintain the original grid and apply the morphs by interpolating
-    the function ***.
-
     This morph applies the function funcx[0] with parameters given in funcx[1].
     The function funcx[0] take in as parameters both the abscissa and ordinate
     (i.e. take in at least two inputs with as many additional parameters as needed).
@@ -403,137 +397,4 @@ how much the
 MorphFuncxy:
 ^^^^^^^^^^^^
 The ``MorphFuncxy`` morph allows users to apply a custom Python function
-to a dataset that modifies both the ``x`` and ``y`` column values.
-This is equivalent to applying a ``MorphFuncx`` and ``MorphFuncy``
-simultaneously.
-
-This morph is useful when you want to apply operations that modify both
-the grid and function value. A PDF-specific example includes computing
-PDFs from 1D diffraction data (see paragraph at the end of this section).
-
-For this tutorial, we will go through two examples. One simple one
-involving shifting a function in the ``x`` and ``y`` directions, and
-another involving a Fourier transform.
-
-    1. Let's start by taking a simple ``sine`` function.
-
-       .. code-block:: python
-
-            import numpy as np
-            morph_x = np.linspace(0, 10, 101)
-            morph_y = np.sin(morph_x)
-            morph_table = np.array([morph_x, morph_y]).T
-
-    2. Then, let our target function be that same ``sine`` function shifted
-       to the right by ``0.3`` and up by ``0.7``.
-
-       .. code-block:: python
-
-            target_x = morph_x + 0.3
-            target_y = morph_y + 0.7
-            target_table = np.array([target_x, target_y]).T
-
-    3. While we could use the ``hshift`` and ``vshift`` morphs,
-       this would require us to refine over two separate morph
-       operations. We can instead perform these morphs simultaneously
-       by defining a function:
-
-       .. code-block:: python
-
-            def shift(x, y, hshift, vshift):
-                return x + hshift, y + vshift
-
-    4. Now, let's try finding the optimal shift parameters using the ``MorphFuncxy`` morph.
-       We can try an initial guess of ``hshift=0.0`` and ``vshift=0.0``.
-
-       .. code-block:: python
-
-            from diffpy.morph.morphpy import morph_arrays
-            initial_guesses = {"hshift": 0.0, "vshift": 0.0}
-            info, table = morph_arrays(morph_table, target_table, funcxy=(shift, initial_guesses))
-
-    5. Finally, to see the refined ``hshift`` and ``vshift`` parameters, we extract them from ``info``.
-
-       .. code-block:: python
-
-            print(f"Refined hshift: {info["funcxy"]["hshift"]}")
-            print(f"Refined vshift: {info["funcxy"]["vshift"]}")
-
-Now for an example involving a Fourier transform.
-
-    1. Let's say you measured a signal of the form :math:`f(x)=\exp\{\cos(\pi x)\}`.
-       Unfortunately, your measurement was taken against a noisy sinusoidal
-       background of the form :math:`n(x)=A\sin(Bx)`, where ``A``, ``B`` are unknown.
-       For our example, let's say (unknown to us) that ``A=2`` and ``B=1.7``.
-
-       .. code-block:: python
-
-            import numpy as np
-            n = 201
-            dx = 0.01
-            measured_x = np.linspace(0, 2, n)
-
-            def signal(x):
-                return np.exp(np.cos(np.pi * x))
-
-            def noise(x, A, B):
-                return A * np.sin(B * x)
-
-            measured_f = signal(measured_x) + noise(measured_x, 2, 1.7)
-            morph_table = np.array([measured_x, measured_f]).T
-
-    2. Your colleague remembers they previously computed the Fourier transform
-       of the function and has sent that to you.
-
-       .. code-block:: python
-
-            # We only consider the region where the grid is positive for simplicity
-            target_x = np.fft.fftfreq(n, dx)[:n//2]
-            target_f = np.real(np.fft.fft(signal(measured_x))[:n//2])
-            target_table = np.array([target_x, target_f]).T
-
-    3. We can now write a noise subtraction function that takes in our measured
-       signal and guesses for parameters ``A``, ``B``, and computes the Fourier
-       transform post-noise-subtraction.
-
-       .. code-block:: python
-
-            def noise_subtracted_ft(x, y, A, B):
-                n = 201
-                dx = 0.01
-                background_subtracted_y = y - noise(x, A, B)
-
-                ft_x = np.fft.fftfreq(n, dx)[:n//2]
-                ft_f = np.real(np.fft.fft(background_subtracted_y)[:n//2])
-
-                return ft_x, ft_f
-
-    4. Finally, we can provide initial guesses of ``A=0`` and ``B=1`` to the
-       ``MorphFuncxy`` morph and see what refined values we get.
-
-       .. code-block:: python
-
-            from diffpy.morph.morphpy import morph_arrays
-            initial_guesses = {"A": 0, "B": 1}
-            info, table = morph_arrays(morph_table, target_table, funcxy=(background_subtracted_ft, initial_guesses))
-
-    5. Print these values to see if they match with the true values of
-       of ``A=2.0`` and ``B=1.7``!
-
-       .. code-block:: python
-
-            print(f"Refined A: {info["funcxy"]["A"]}")
-            print(f"Refined B: {info["funcxy"]["B"]}")
-
-You can also use this morph to help find optimal parameters
-(e.g. ``rpoly``, ``qmin``, ``qmax``, ``bgscale``) for computing
-PDFs of materials with known structures.
-One does this by setting the ``MorphFuncxy`` function to a PDF
-computing function such as
-`PDFgetx3 <https://www.diffpy.org/products/pdfgetx.html>`_.
-The input (morphed) 1D function should be the 1D diffraction data
-one wishes to compute the PDF of and the target 1D function
-can be the PDF of a target material with similar geometry.
-More information about this will be released in the ``diffpy.morph``
-manuscript, and we plan to integrate this feature automatically into
-``PDFgetx3`` soon.
+to a dataset, ***.

src/diffpy/morph/morphs/morphfuncx.py

@@ -11,13 +11,16 @@ class MorphFuncx(Morph):
     General morph function that applies a user-supplied function to the
     x-coordinates of morph data to make it align with a target.
 
-    Notice: the morph should maintain the monotonicity of the grid.
+    Notice: the function provided must preserve the monotonic
+    increase of the grid.
+    I.e. the function f applied on the grid x must ensure for all
+    indices i<j, f(x[i]) < f(x[j]).
 
     Configuration Variables
     -----------------------
     function: callable
         The user-supplied function that applies a transformation to the
-        y-coordinates of the data.
+        x-coordinates of the data.
 
     parameters: dict
         A dictionary of parameters to pass to the function.
@@ -29,27 +32,31 @@ class MorphFuncx(Morph):
         transformed according to the user-specified function and parameters
         The morphed data is returned on the same grid as the unmorphed data
 
-    Example (FIX)
-    -------------
-    Import the funcy morph function:
+    Example
+    -------
+    Import the funcx morph function:
 
-        >>> from diffpy.morph.morphs.morphfuncy import MorphFuncy
+        >>> from diffpy.morph.morphs.morphfuncx import MorphFuncx
 
     Define or import the user-supplied transformation function:
 
-        >>> def sine_function(x, y, amplitude, frequency):
-        >>>     return amplitude * np.sin(frequency * x) * y
+        >>> import numpy as np
+        >>> def exp_function(x, y, scale, rate):
+        >>>     return abs(scale) * np.exp(rate * x)
+
+    Note that this transformation is monotonic increasing, so will preserve
+    the monotonic increasing nature of the provided grid.
 
     Provide initial guess for parameters:
 
-        >>> parameters = {'amplitude': 2, 'frequency': 2}
+        >>> parameters = {'scale': 1, 'rate': 1}
 
     Run the funcy morph given input morph array (x_morph, y_morph)and target
     array (x_target, y_target):
 
-        >>> morph = MorphFuncy()
-        >>> morph.function = sine_function
-        >>> morph.funcy = parameters
+        >>> morph = MorphFuncx()
+        >>> morph.funcx_function = exp_function
+        >>> morph.funcx = parameters
         >>> x_morph_out, y_morph_out, x_target_out, y_target_out =
         ... morph.morph(x_morph, y_morph, x_target, y_target)
 
@@ -63,7 +70,7 @@ class MorphFuncx(Morph):
     """
 
     # Define input output types
-    summary = "Apply a Python function to the y-axis data"
+    summary = "Apply a Python function to the x-axis data"
     xinlabel = LABEL_RA
     yinlabel = LABEL_GR
     xoutlabel = LABEL_RA

src/diffpy/morph/morphs/morphrgrid.py

@@ -51,39 +51,26 @@ class MorphRGrid(Morph):
     youtlabel = LABEL_GR
     parnames = ["rmin", "rmax", "rstep"]
 
-    # Define rmin rmax holders for adaptive x-grid refinement
-    # Without these, the program r-grid can only decrease in interval size
-    rmin_origin = None
-    rmax_origin = None
-    rstep_origin = None
-
     def morph(self, x_morph, y_morph, x_target, y_target):
         """Resample arrays onto specified grid."""
-        if self.rmin is not None:
-            self.rmin_origin = self.rmin
-        if self.rmax is not None:
-            self.rmax_origin = self.rmax
-        if self.rstep is not None:
-            self.rstep_origin = self.rstep
-
         Morph.morph(self, x_morph, y_morph, x_target, y_target)
-        rmininc = max(min(self.x_target_in), min(self.x_morph_in))
-        r_step_target = (max(self.x_target_in) - min(self.x_target_in)) / (
+        rmininc = max(self.x_target_in[0], self.x_morph_in[0])
+        r_step_target = (self.x_target_in[-1] - self.x_target_in[0]) / (
             len(self.x_target_in) - 1
         )
-        r_step_morph = (max(self.x_morph_in) - min(self.x_morph_in)) / (
+        r_step_morph = (self.x_morph_in[-1] - self.x_morph_in[0]) / (
             len(self.x_morph_in) - 1
         )
         rstepinc = max(r_step_target, r_step_morph)
         rmaxinc = min(
-            max(self.x_target_in) + r_step_target,
-            max(self.x_morph_in) + r_step_morph,
+            self.x_target_in[-1] + r_step_target,
+            self.x_morph_in[-1] + r_step_morph,
         )
-        if self.rmin_origin is None or self.rmin_origin < rmininc:
+        if self.rmin is None or self.rmin < rmininc:
             self.rmin = rmininc
-        if self.rmax_origin is None or self.rmax_origin > rmaxinc:
+        if self.rmax is None or self.rmax > rmaxinc:
             self.rmax = rmaxinc
-        if self.rstep_origin is None or self.rstep_origin < rstepinc:
+        if self.rstep is None or self.rstep < rstepinc:
             self.rstep = rstepinc
         # roundoff tolerance for selecting bounds on arrays.
         epsilon = self.rstep / 2

src/diffpy/morph/refine.py

@@ -91,17 +91,12 @@ def _residual(self, pvals):
         else:
             # Padding
             if len(rvec) < self.res_length:
-                diff_length = self.res_length - len(rvec)
                 rvec = list(rvec)
-                rvec.extend([0] * diff_length)
+                rvec.extend([0] * (self.res_length - len(rvec)))
                 rvec = array(rvec)
             # Removal
-            # For removal, pass the average RMS
-            # This is fast and easy to compute
-            # For sufficiently functions, this approximation becomes exact
             elif len(rvec) > self.res_length:
-                avg_rms = sum(rvec**2) / len(rvec)
-                rvec = array([avg_rms for _ in range(self.res_length)])
+                pass
 
         return rvec