now passing tests

Author: sbillinge

src/diffpy/utils/diffraction_objects.py

@@ -1,4 +1,5 @@
 import datetime
+import warnings
 from copy import deepcopy
 
 import numpy as np
@@ -18,17 +19,31 @@
 )
 
 
+def _xtype_wmsg(xtype):
+    return (
+        f"WARNING: I don't know how to handle the xtype, '{xtype}'.  Please rerun specifying and "
+        f"xtype from {*XQUANTITIES, }"
+    )
+
+
 class DiffractionObject:
     def __init__(
-        self, name="", wavelength=None, scat_quantity="", metadata={}, xarray=None, yarray=None, xtype=""
+        self, name=None, wavelength=None, scat_quantity=None, metadata=None, xarray=None, yarray=None, xtype=""
     ):
+        if name is None:
+            name = ""
+        self.name = name
+        if metadata is None:
+            metadata = {}
+        self.metadata = metadata
+        self.scat_quantity = scat_quantity
+        self.wavelength = wavelength
+
         if xarray is None:
             xarray = np.empty(0)
         if yarray is None:
             yarray = np.empty(0)
-        self.insert_scattering_quantity(
-            xarray, yarray, xtype, metadata=metadata, scat_quantity=scat_quantity, name=name, wavelength=wavelength
-        )
+        self.insert_scattering_quantity(xarray, yarray, xtype)
 
     def __eq__(self, other):
         if not isinstance(other, DiffractionObject):
@@ -241,15 +256,32 @@ def get_angle_index(self, angle):
         if count >= len(self.angles):
             raise IndexError(f"WARNING: no angle {angle} found in angles list")
 
+    def _set_xarrays(self, xarray, xtype):
+        self.all_arrays = np.empty(shape=(len(xarray), 4))
+        if xtype.lower() in QQUANTITIES:
+            self.all_arrays[:, 1] = xarray
+            self.all_arrays[:, 2] = q_to_tth(xarray, self.wavelength)
+            self.all_arrays[:, 3] = q_to_d(xarray)
+        elif xtype.lower() in ANGLEQUANTITIES:
+            self.all_arrays[:, 2] = xarray
+            self.all_arrays[:, 1] = tth_to_q(xarray, self.wavelength)
+            self.all_arrays[:, 3] = tth_to_d(xarray, self.wavelength)
+        elif xtype.lower() in DQUANTITIES:
+            self.all_arrays[:, 3] = xarray
+            self.all_arrays[:, 1] = d_to_q(xarray)
+            self.all_arrays[:, 2] = d_to_tth(xarray, self.wavelength)
+        self.qmin = np.nanmin(self.all_arrays[:, 1], initial=np.inf)
+        self.qmax = np.nanmax(self.all_arrays[:, 1], initial=0.0)
+        self.tthmin = np.nanmin(self.all_arrays[:, 2], initial=np.inf)
+        self.tthmax = np.nanmax(self.all_arrays[:, 2], initial=0.0)
+        self.dmin = np.nanmin(self.all_arrays[:, 3], initial=np.inf)
+        self.dmax = np.nanmax(self.all_arrays[:, 3], initial=0.0)
+
     def insert_scattering_quantity(
         self,
         xarray,
         yarray,
         xtype,
-        metadata={},
-        scat_quantity="",
-        name=None,
-        wavelength=None,
     ):
         f"""
         insert a new scattering quantity into the scattering object
@@ -262,38 +294,14 @@ def insert_scattering_quantity(
           the dependent variable array
         xtype string
           the type of quantity for the independent variable from {*XQUANTITIES, }
-        metadata: dict
-          the metadata in the form of a dictionary of user-supplied key:value pairs
 
         Returns
         -------
 
         """
-        self.input_xtype = xtype
-        self.metadata = metadata
-        self.scat_quantity = scat_quantity
-        self.name = name
-        self.wavelength = wavelength
-        self.all_arrays = np.empty(shape=(len(yarray), 4))
+        self._set_xarrays(xarray, xtype)
         self.all_arrays[:, 0] = yarray
-        if xtype.lower() in QQUANTITIES:
-            self.all_arrays[:, 1] = xarray
-            self.all_arrays[:, 2] = q_to_tth(xarray, wavelength)
-            self.all_arrays[:, 3] = q_to_d(xarray)
-        elif xtype.lower() in ANGLEQUANTITIES:
-            self.all_arrays[:, 2] = xarray
-            self.all_arrays[:, 1] = tth_to_q(xarray, wavelength)
-            self.all_arrays[:, 3] = tth_to_d(xarray, wavelength)
-        elif xtype.lower() in DQUANTITIES:
-            self.all_arrays[:, 3] = xarray
-            self.all_arrays[:, 1] = d_to_q(xarray)
-            self.all_arrays[:, 2] = d_to_tth(xarray, wavelength)
-        self.qmin = np.nanmin(self.all_arrays[:, 1], initial=np.inf)
-        self.qmax = np.nanmax(self.all_arrays[:, 1], initial=0.0)
-        self.tthmin = np.nanmin(self.all_arrays[:, 2], initial=np.inf)
-        self.tthmax = np.nanmax(self.all_arrays[:, 2], initial=0.0)
-        self.dmin = np.nanmin(self.all_arrays[:, 3], initial=np.inf)
-        self.dmax = np.nanmax(self.all_arrays[:, 3], initial=0.0)
+        self.input_xtype = xtype
 
     def _get_original_array(self):
         if self.input_xtype in QQUANTITIES:
@@ -319,7 +327,7 @@ def scale_to(self, target_diff_object, xtype=None, xvalue=None):
         Parameters
         ----------
         target_diff_object: DiffractionObject
-          the diffractoin object you want to scale the current one on to
+          the diffraction object you want to scale the current one on to
         xtype: string, optional.  Default is Q
           the xtype, from {XQUANTITIES}, that you will specify a point from to scale to
         xvalue: float. Default is the midpoint of the array
@@ -351,6 +359,7 @@ def scale_to(self, target_diff_object, xtype=None, xvalue=None):
     def on_xtype(self, xtype):
         """
         return a 2D np array with x in the first column and y in the second for x of type type
+
         Parameters
         ----------
         xtype
@@ -360,24 +369,25 @@ def on_xtype(self, xtype):
 
         """
         if xtype.lower() in ANGLEQUANTITIES:
-            return self.on_tth
+            return self.on_tth()
         elif xtype.lower() in QQUANTITIES:
-            return self.on_q
+            return self.on_q()
         elif xtype.lower() in DQUANTITIES:
-            return self.on_d
-        pass
+            return self.on_d()
+        else:
+            warnings.warn(_xtype_wmsg(xtype))
 
     def dump(self, filepath, xtype=None):
         if xtype is None:
-            xtype = " q"
-        if xtype == "q":
+            xtype = "q"
+        if xtype in QQUANTITIES:
             data_to_save = np.column_stack((self.on_q()[0], self.on_q()[1]))
-        elif xtype == "tth":
+        elif xtype in ANGLEQUANTITIES:
             data_to_save = np.column_stack((self.on_tth()[0], self.on_tth()[1]))
-        elif xtype == "d":
+        elif xtype in DQUANTITIES:
             data_to_save = np.column_stack((self.on_d()[0], self.on_d()[1]))
         else:
-            print(f"WARNING: cannot handle the xtype '{xtype}'")
+            warnings.warn(_xtype_wmsg(xtype))
         self.metadata.update(get_package_info("diffpy.utils", metadata=self.metadata))
         self.metadata["creation_time"] = datetime.datetime.now()
 

tests/test_diffraction_objects.py

@@ -22,18 +22,23 @@ def compare_dicts(dict1, dict2):
 
 def dicts_equal(dict1, dict2):
     equal = True
+    print("")
+    print(dict1)
+    print(dict2)
     if not dict1.keys() == dict2.keys():
         equal = False
     for key in dict1:
         val1, val2 = dict1[key], dict2[key]
         if isinstance(val1, np.ndarray) and isinstance(val2, np.ndarray):
             if not np.allclose(val1, val2):
                 equal = False
+        elif isinstance(val1, list) and isinstance(val2, list):
+            if not val1.all() == val2.all():
+                equal = False
         elif isinstance(val1, np.float64) and isinstance(val2, np.float64):
             if not np.isclose(val1, val2):
                 equal = False
         else:
-            print(key, val1, val2)
             if not val1 == val2:
                 equal = False
     return equal
@@ -187,12 +192,13 @@ def dicts_equal(dict1, dict2):
 
 @pytest.mark.parametrize("inputs1, inputs2, expected", params)
 def test_diffraction_objects_equality(inputs1, inputs2, expected):
-    diffraction_object1 = DiffractionObject(inputs1)
-    diffraction_object2 = DiffractionObject(inputs2)
+    diffraction_object1 = DiffractionObject(**inputs1)
+    diffraction_object2 = DiffractionObject(**inputs2)
     # diffraction_object1_attributes = [key for key in diffraction_object1.__dict__ if not key.startswith("_")]
     # for i, attribute in enumerate(diffraction_object1_attributes):
     #     setattr(diffraction_object1, attribute, inputs1[i])
     #     setattr(diffraction_object2, attribute, inputs2[i])
+    print(dicts_equal(diffraction_object1.__dict__, diffraction_object2.__dict__), expected)
     assert dicts_equal(diffraction_object1.__dict__, diffraction_object2.__dict__) == expected
 
 
@@ -246,7 +252,7 @@ def test_dump(tmp_path, mocker):
             "metadata": {},
             "input_xtype": "",
             "name": "",
-            "scat_quantity": "",
+            "scat_quantity": None,
             "qmin": np.float64(np.inf),
             "qmax": np.float64(0.0),
             "tthmin": np.float64(np.inf),
@@ -291,7 +297,7 @@ def test_dump(tmp_path, mocker):
             "metadata": {},
             "input_xtype": "tth",
             "name": "",
-            "scat_quantity": "",
+            "scat_quantity": None,
             "qmin": np.float64(0.0),
             "qmax": np.float64(1.0),
             "tthmin": np.float64(0.0),