Clarity update

Author: Sparks29032

src/diffpy/morph/morph_io.py

@@ -447,17 +447,13 @@ def handle_extrapolation_warnings(morph):
 
 def handle_check_increase_warning(squeeze_morph):
     if squeeze_morph is not None:
-        if squeeze_morph.strictly_increasing:
-            wmsg = None
-        else:
+        if not squeeze_morph.strictly_increasing:
             wmsg = (
                 "Warning: The squeeze morph has interpolated your morphed "
                 "function from a non-monotonically increasing grid. "
-                "This can result in strange behavior in the non-unique "
-                "grid regions. To disable this setting, "
-                "please enable --check-increasing."
+                "This can result in strange behavior in certain "
+                "grid regions."
             )
-        if wmsg:
             warnings.warn(
                 wmsg,
                 UserWarning,

src/diffpy/morph/morphpy.py

@@ -51,7 +51,6 @@ def __get_morph_opts__(parser, scale, stretch, smear, plot, **kwargs):
         "reverse",
         "diff",
         "get-diff",
-        "check-increase",
     ]
     opts_to_ignore = ["multiple-morphs", "multiple-targets"]
     for opt in opts_storing_values:

src/diffpy/morph/morphs/morphsqueeze.py

@@ -73,7 +73,7 @@ class MorphSqueeze(Morph):
     def __init__(self, config=None):
         super().__init__(config)
 
-    def _ensure_strictly_increase(self, x, x_sorted):
+    def _check_strictly_increasing(self, x, x_sorted):
         if list(x) != list(x_sorted):
             self.strictly_increasing = False
         else:
@@ -83,20 +83,20 @@ def _sort_squeeze(self, x, y):
         """Sort x,y according to the value of x."""
         xy = list(zip(x, y))
         xy_sorted = sorted(xy, key=lambda pair: pair[0])
-        x_sorted, y_sorted = list(zip(*xy_sorted))
+        x_sorted, y_sorted = numpy.array(list(zip(*xy_sorted)))
         return x_sorted, y_sorted
 
     def _handle_duplicates(self, x, y):
         """Remove duplicated x and use the mean value of y corresponded
         to the duplicated x."""
-        unq_x, unq_inv = numpy.unique(x, return_inverse=True)
-        if len(unq_x) == len(x):
+        x_unique, inv = numpy.unique(x, return_inverse=True)
+        if len(x_unique) == len(x):
             return x, y
         else:
-            y_avg = numpy.zeros_like(unq_x)
-            for i in range(len(unq_x)):
-                y_avg[i] = numpy.array(y)[unq_inv == i].mean()
-            return unq_x, y_avg
+            y_avg = numpy.zeros_like(x_unique)
+            for idx, _ in enumerate(x_unique):
+                y_avg[idx] = y[inv == idx].mean()
+            return x_unique, y_avg
 
     def morph(self, x_morph, y_morph, x_target, y_target):
         """Apply a polynomial to squeeze the morph function.
@@ -112,7 +112,7 @@ def morph(self, x_morph, y_morph, x_target, y_target):
         x_squeezed_sorted, y_morph_sorted = self._sort_squeeze(
             x_squeezed, self.y_morph_in
         )
-        self._ensure_strictly_increase(x_squeezed, x_squeezed_sorted)
+        self._check_strictly_increasing(x_squeezed, x_squeezed_sorted)
         x_squeezed_sorted, y_morph_sorted = self._handle_duplicates(
             x_squeezed_sorted, y_morph_sorted
         )

tests/test_morphsqueeze.py

@@ -172,80 +172,56 @@ def test_morphsqueeze_extrapolate(user_filesystem, squeeze_coeffs, wmsg_gen):
         single_morph(parser, opts, pargs, stdout_flag=False)
 
 
-@pytest.mark.parametrize(
-    "squeeze_coeffs, x_morph",
-    [
-        ({"a0": 0.01, "a1": 0.01, "a2": -0.1}, np.linspace(0, 10, 101)),
-    ],
-)
-def test_non_strictly_increasing_squeeze(squeeze_coeffs, x_morph):
-    x_target = x_morph
-    y_target = np.sin(x_target)
+def test_non_unique_grid():
+    squeeze_coeffs = {"a0": 0.01, "a1": 0.01, "a2": -0.1}
+    x_grid = np.linspace(0, 10, 101)
+
     coeffs = [squeeze_coeffs[f"a{i}"] for i in range(len(squeeze_coeffs))]
     squeeze_polynomial = Polynomial(coeffs)
-    x_squeezed = x_morph + squeeze_polynomial(x_morph)
-    # non-strictly-increasing
-    assert not np.all(np.sign(np.diff(x_squeezed)) > 0)
-    y_morph = np.sin(x_squeezed)
-    # all zero initial guess
-    morph_results = morphpy.morph_arrays(
+    x_morph = x_grid + squeeze_polynomial(x_grid)
+    x_gradient = np.diff(x_morph)
+    x_gradient_sign = np.sign(x_gradient)
+    # non-strictly increasing means the gradient becomes 0 or negative
+    assert not np.all(x_gradient_sign > 0)
+
+    x_target = np.linspace(min(x_morph), max(x_morph), len(x_morph))
+    y_target = np.sin(x_target)
+
+    y_morph = np.sin(x_morph)
+    # apply no squeeze, but the morph should sort the function
+    _, table = morphpy.morph_arrays(
         np.array([x_morph, y_morph]).T,
         np.array([x_target, y_target]).T,
-        squeeze=[0, 0, 0],
+        squeeze=[0, 0, 0.0001],
         apply=True,
     )
-    _, y_morph_actual = morph_results[1].T  # noqa: F841
-    y_morph_expected = np.sin(x_morph)  # noqa: F841
-    # squeeze morph extrapolates.
-    #   Need to extract extrap_index from morph_results to examine
-    #   the convergence.
-    # assert np.allclose(y_morph_actual, y_morph_expected, atol=1e-3)
-    # Raise warning when called without --check-increase
-    with pytest.warns() as w:
-        morph_results = morphpy.morph_arrays(
-            np.array([x_morph, y_morph]).T,
-            np.array([x_target, y_target]).T,
-            squeeze=[0.01, 0.01, -0.1],
-            apply=True,
-        )
-    assert w[0].category is UserWarning
-    actual_wmsg = " ".join([str(w[i].message) for i in range(len(w))])
-    expected_wmsg = (
-        "Warning: The squeeze morph has interpolated your morphed "
-        "function from a non-monotonically increasing grid. "
-    )
-    assert expected_wmsg in actual_wmsg
-    _, y_morph_actual = morph_results[1].T  # noqa: F841
-    y_morph_expected = np.sin(x_morph)  # noqa: F841
-    # squeeze morph extrapolates.
-    #   Need to extract extrap_index from morph_results to examine
-    #   the convergence.
-    # assert np.allclose(y_morph_actual, y_morph_expected, atol=1e-3)
-    # System exits when called with --check-increase
-    with pytest.raises(SystemExit) as excinfo:
-        morphpy.morph_arrays(
-            np.array([x_morph, y_morph]).T,
-            np.array([x_target, y_target]).T,
-            squeeze=[0.01, 0.009, -0.1],
-            check_increase=True,
-        )
-    actual_emsg = str(excinfo.value)
-    expected_emsg = "2"
-    assert expected_emsg == actual_emsg
+    x_refined, y_refined = table[:, 0], table[:, 1]
+
+    # grid should be properly sorted
+    assert np.allclose(x_refined, x_target)
+
+    print(y_refined, y_target)
+    x_sorted = x_morph.copy()
+    x_sorted.sort()
+    print(x_morph)
+    print(x_sorted)
+    # function values
+    assert np.allclose(y_refined, y_target)
 
 
 @pytest.mark.parametrize(
     "squeeze_coeffs, x_morph",
     [
+        # The following squeezes make the function non-monotonic
         ({"a0": -1, "a1": -1, "a2": 2}, np.linspace(-1, 1, 101)),
         (
             {"a0": -1, "a1": -1, "a2": 0, "a3": 0, "a4": 2},
             np.linspace(-1, 1, 101),
         ),
     ],
 )
-def test_sort_squeeze_bad(user_filesystem, squeeze_coeffs, x_morph):
-    # call in .py without --check-increase
+def test_squeeze_warnings(user_filesystem, squeeze_coeffs, x_morph):
+    # call in .py
     x_target = x_morph
     y_target = np.sin(x_target)
     coeffs = [squeeze_coeffs[f"a{i}"] for i in range(len(squeeze_coeffs))]
@@ -267,10 +243,12 @@ def test_sort_squeeze_bad(user_filesystem, squeeze_coeffs, x_morph):
     expected_wmsg = (
         "Warning: The squeeze morph has interpolated your morphed "
         "function from a non-monotonically increasing grid. "
+        "This can result in strange behavior in certain "
+        "grid regions."
     )
     assert expected_wmsg in actual_wmsg
 
-    # call in CLI without --check-increase
+    # call in CLI
     morph_file, target_file = create_morph_data_file(
         user_filesystem / "cwd_dir", x_morph, y_morph, x_target, y_target
     )
@@ -293,18 +271,16 @@ def test_sort_squeeze_bad(user_filesystem, squeeze_coeffs, x_morph):
 
 
 def test_handle_duplicates():
-    unq_x = np.linspace(0, 11, 10)
+    x_choices = np.linspace(0, 10, 11)
     iter = 10
     morph = MorphSqueeze()
     for i in range(iter):
-        actual_x = np.random.choice(unq_x, size=20)
-        actual_y = np.sin(actual_x)
-        actual_handled_x, actual_handled_y = morph._handle_duplicates(
-            actual_x, actual_y
-        )
-        expected_handled_x = np.unique(actual_x)
-        expected_handled_y = np.array(
-            [actual_y[actual_x == x].mean() for x in expected_handled_x]
+        x_sampled = np.random.choice(x_choices, size=20)
+        y_sampled = np.sin(x_sampled)
+        x_handled, y_handled = morph._handle_duplicates(x_sampled, y_sampled)
+        x_target = np.unique(x_sampled)
+        y_target = np.array(
+            [y_sampled[x_sampled == x].mean() for x in x_target]
         )
-        assert np.allclose(actual_handled_x, expected_handled_x)
-        assert np.allclose(actual_handled_y, expected_handled_y)
+        assert np.allclose(x_handled, x_target)
+        assert np.allclose(y_handled, y_target)