func/test: replacing squeeze list for dictionary

Author: Luiskitsu

src/diffpy/morph/morphs/morphsqueeze.py

@@ -28,11 +28,11 @@ def morph(self, x_morph, y_morph, x_target, y_target):
 
         Configuration Variables
         -----------------------
-        squeeze : list
-            The polynomial coefficients [a0, a1, ..., an] for the squeeze
+        squeeze : Dictionary
+            The polynomial coefficients {a0, a1, ..., an} for the squeeze
             function where the polynomial would be of the form
             a0 + a1*x + a2*x^2 and so on.  The order of the polynomial is
-            determined by the length of the list.
+            determined by the length of the dictionary.
 
         Returns
         -------
@@ -46,7 +46,7 @@ def morph(self, x_morph, y_morph, x_target, y_target):
         Import the squeeze morph function:
         >>> from diffpy.morph.morphs.morphsqueeze import MorphSqueeze
         Provide initial guess for squeezing coefficients:
-        >>> squeeze_coeff = [0.1, -0.01, 0.005]
+        >>> squeeze_coeff = {"a0":0.1, "a1":-0.01, "a2":0.005}
         Run the squeeze morph given input morph array (x_morph, y_morph)
         and target array (x_target, y_target):
         >>> morph = MorphSqueeze()
@@ -62,7 +62,8 @@ def morph(self, x_morph, y_morph, x_target, y_target):
         """
         Morph.morph(self, x_morph, y_morph, x_target, y_target)
 
-        squeeze_polynomial = Polynomial(self.squeeze)
+        coeffs = [self.squeeze[f"a{i}"] for i in range(len(self.squeeze))]
+        squeeze_polynomial = Polynomial(coeffs)
         x_squeezed = self.x_morph_in + squeeze_polynomial(self.x_morph_in)
         self.y_morph_out = CubicSpline(x_squeezed, self.y_morph_in)(
             self.x_morph_in

src/diffpy/morph/refine.py

@@ -63,13 +63,9 @@ def _update_chain(self, pvals):
                 updated[param] = value
             else:
                 if param not in updated:
-                    updated[param] = {} if isinstance(subkey, str) else []
-                if isinstance(updated[param], dict):
-                    updated[param][subkey] = value
-                else:
-                    while len(updated[param]) <= subkey:
-                        updated[param].append(0.0)
-                    updated[param][subkey] = value
+                    updated[param] = {}
+                updated[param][subkey] = value
+
         # Apply the reconstructed grouped parameter back to config
         self.chain.config.update(updated)
         return
@@ -143,10 +139,6 @@ def refine(self, *args, **kw):
                 for k, v in val.items():
                     initial.append(v)
                     self.flat_to_grouped[len(initial) - 1] = (p, k)
-            elif isinstance(val, list):
-                for i, v in enumerate(val):
-                    initial.append(v)
-                    self.flat_to_grouped[len(initial) - 1] = (p, i)
             else:
                 initial.append(val)
                 self.flat_to_grouped[len(initial) - 1] = (p, None)

tests/test_morph_func.py

@@ -104,12 +104,12 @@ def test_smear_with_morph_func():
 
 
 def test_squeeze_with_morph_func():
-    squeeze_init = [0, -0.001, -0.0001, 0.0001]
+    squeeze_init = {"a0": 0, "a1": -0.001, "a2": -0.0001, "a3": 0.0001}
     x_morph = np.linspace(0, 10, 101)
     y_morph = 2 * np.sin(
         x_morph + x_morph * 0.01 + 0.0001 * x_morph**2 + 0.001 * x_morph**3
     )
-    expected_squeeze = [0, 0.01, 0.0001, 0.001]
+    expected_squeeze = {"a0": 0, "a1": 0.01, "a2": 0.0001, "a3": 0.001}
     expected_scale = 1 / 2
     x_target = np.linspace(0, 10, 101)
     y_target = np.sin(x_target)
@@ -121,7 +121,18 @@ def test_squeeze_with_morph_func():
     ].xyallout
     assert np.allclose(x_morph_out, x_target_out)
     assert np.allclose(y_morph_out, y_target_out, atol=1e-6)
-    assert np.allclose(expected_squeeze, morphed_cfg["squeeze"], atol=1e-6)
+    assert np.allclose(
+        expected_squeeze["a0"], morphed_cfg["squeeze"]["a0"], atol=1e-6
+    )
+    assert np.allclose(
+        expected_squeeze["a1"], morphed_cfg["squeeze"]["a1"], atol=1e-6
+    )
+    assert np.allclose(
+        expected_squeeze["a2"], morphed_cfg["squeeze"]["a2"], atol=1e-6
+    )
+    assert np.allclose(
+        expected_squeeze["a3"], morphed_cfg["squeeze"]["a3"], atol=1e-6
+    )
     assert np.allclose(expected_scale, morphed_cfg["scale"], atol=1e-6)
 
 

tests/test_morphsqueeze.py

@@ -4,24 +4,24 @@
 
 from diffpy.morph.morphs.morphsqueeze import MorphSqueeze
 
-squeeze_coeffs_list = [
-    # The order of coefficients is [a0, a1, a2, ..., an]
+squeeze_coeffs_dic = [
+    # The order of coefficients is {a0, a1, a2, ..., an}
     # Negative cubic squeeze coefficients
-    [-0.01, -0.0005, -0.0005, -1e-6],
+    {"a0": -0.01, "a1": -0.0005, "a2": -0.0005, "a3": -1e-6},
     # Positive cubic squeeze coefficients
-    [0.2, 0.01, 0.001, 0.0001],
+    {"a0": 0.2, "a1": 0.01, "a2": 0.001, "a3": 0.0001},
     # Positive and negative cubic squeeze coefficients
-    [0.2, -0.01, 0.002, -0.0001],
+    {"a0": 0.2, "a1": -0.01, "a2": 0.002, "a3": -0.0001},
     # Quadratic squeeze coefficients
-    [-0.2, 0.005, -0.0004],
+    {"a0": -0.2, "a1": 0.005, "a2": -0.0004},
     # Linear squeeze coefficients
-    [0.1, 0.3],
+    {"a0": 0.1, "a1": 0.3},
     # 4th order squeeze coefficients
-    [0.2, -0.01, 0.001, -0.001, 0.0001],
+    {"a0": 0.2, "a1": -0.01, "a2": 0.001, "a3": -0.001, "a4": 0.0001},
     # Zeros and non-zeros, the full polynomial is applied
-    [0, 0.03, 0, -0.0001],
+    {"a0": 0, "a1": 0.03, "a2": 0, "a3": -0.0001},
     # Testing zeros, expect no squeezing
-    [0, 0, 0, 0, 0, 0],
+    {"a0": 0, "a1": 0, "a2": 0, "a3": 0, "a4": 0, "a5": 0},
 ]
 morph_target_grids = [
     # UCs from issue 181: https://github.com/diffpy/diffpy.morph/issues/181
@@ -41,10 +41,11 @@
 
 
 @pytest.mark.parametrize("x_morph, x_target", morph_target_grids)
-@pytest.mark.parametrize("squeeze_coeffs", squeeze_coeffs_list)
+@pytest.mark.parametrize("squeeze_coeffs", squeeze_coeffs_dic)
 def test_morphsqueeze(x_morph, x_target, squeeze_coeffs):
     y_target = np.sin(x_target)
-    squeeze_polynomial = Polynomial(squeeze_coeffs)
+    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)
     y_morph = np.sin(x_squeezed)
     low_extrap = np.where(x_morph < x_squeezed[0])[0]