Adds new dataset type "angle_dim"

Author: DrPaulSharp

sasdata/data.py

@@ -39,7 +39,9 @@ def __init__(
     @property
     def ordinate(self) -> Quantity:
         match self.dataset_type:
-            case dataset_types.one_dim | dataset_types.two_dim:
+            case (dataset_types.one_dim |
+                  dataset_types.two_dim |
+                  dataset_types.angle_dim):
                 return self._data_contents["I"]
             case dataset_types.sesans:
                 return self._data_contents["Depolarisation"]
@@ -70,6 +72,8 @@ def abscissae(self) -> Quantity:
                 # probably want to avoid creating a new Quantity but at the moment I
                 # can't see a way around it.
                 return Quantity(data_contents, reference_data_content.units, name=self._data_contents["Qx"].name, id_header=self._data_contents["Qx"]._id_header)
+            case dataset_types.angle_dim:
+                return self._data_contents["Phi"]
             case dataset_types.sesans:
                 return self._data_contents["SpinEchoLength"]
             case _:

sasdata/data_util/averaging.py

@@ -9,9 +9,10 @@
 from sasdata.data_util.binning import DirectionalAverage
 from sasdata.data_util.interval import IntervalType
 from sasdata.data_util.roi import CartesianROI, PolarROI
-from sasdata.dataset_types import one_dim
+from sasdata.dataset_types import angle_dim, one_dim
 from sasdata.quantities.constants import Pi, TwoPi
 from sasdata.quantities.quantity import Quantity
+from sasdata.quantities.units import radians
 
 
 def get_dq_data(data2d: SasData) -> npt.NDArray[np.floating]:
@@ -503,10 +504,10 @@ def __call__(self, data2D: SasData) -> SasData:
             raise ValueError(msg)
 
         data_contents = {
-            "Q": Quantity(phi_values[idx], data2D._data_contents["Qx"].units, None),
+            "Phi": Quantity(phi_values[idx], radians, None),
             "I": Quantity(phi_bins[idx], data2D._data_contents["I"].units, phi_err[idx]),
         }
-        return SasData(f"{data2D.name}: Ring Average", data_contents, one_dim, data2D.metadata)
+        return SasData(f"{data2D.name}: Ring Average", data_contents, angle_dim, data2D.metadata)
 
 
 class SectorQ(PolarROI):
@@ -665,9 +666,9 @@ class WedgeQ(PolarROI):
     the positive x-axis.
 
     This class is initialised by specifying lower and upper limits on both the
-    magnitude of Q and the angle φ.
-    When called, this class is supplied with a SasData object. It returns a
-    sasData object where intensity is given as a function of Q only.
+    magnitude of Q and the angle φ. When called, this class is supplied with a
+    SasData object. It returns a sasData object where intensity is given as a
+    function of Q only.
     """
 
     def __init__(
@@ -752,7 +753,7 @@ class WedgePhi(PolarROI):
     This class is initialised by specifying lower and upper limits on both the
     magnitude of Q and the angle φ, measured anticlockwise from the positive
     x-axis. When called, this class is supplied with a SasData object. It returns
-    a SasData object where intensity is given as a function of Q only.
+    a SasData object where intensity is given as a function of φ only.
     """
 
     def __init__(
@@ -818,7 +819,7 @@ def __call__(self, data2d: SasData = None) -> SasData:
             nbins=self.nbins,
             base=self.base,
         )
-        phi_data, intensity, error = directional_average(data=self.data, err_data=self.err_data)
+        _, intensity, error = directional_average(data=self.data, err_data=self.err_data)
 
         # Compute phi bin starts to match legacy behaviour (Ring / old SectorPhi)
         # phi_min has been normalized to 0 earlier; phi_offset stores original start.
@@ -844,10 +845,10 @@ def __call__(self, data2d: SasData = None) -> SasData:
 
         # intensity and error returned by DirectionalAverage are already filtered to the populated/finite bins
         data_contents = {
-            "Q": Quantity(phi_centers, data2d._data_contents["Qx"].units, None),
+            "Phi": Quantity(phi_centers, radians, None),
             "I": Quantity(intensity, data2d._data_contents["I"].units, error),
         }
-        return SasData(f"{data2d.name}: Wedge Phi Average", data_contents, one_dim, data2d.metadata)
+        return SasData(f"{data2d.name}: Wedge Phi Average", data_contents, angle_dim, data2d.metadata)
 
 
 class SectorPhi(WedgePhi):

sasdata/data_util/manipulations.py

@@ -544,7 +544,7 @@ def _agv(self, data2D, run='phi'):
         if not ("Qx" in data2D._data_contents and
                 "Qy" in data2D._data_contents and
                 "I" in data2D._data_contents):
-            raise RuntimeError("For ring averaging the SasData object must contain 'Qx', 'Qy', and 'I' data.")
+            raise RuntimeError("For averaging the SasData object must contain 'Qx', 'Qy', and 'I' data.")
 
         # Get all the data & info
         finite_mask = np.isfinite(data2D._data_contents["I"].value)

sasdata/dataset_types.py

@@ -42,13 +42,21 @@ class DatasetType:
                 ["Qx", "Qy", "Qz", "I", "dI"],
                 ["Qx", "Qy", "Qz", "dQx", "dQy", "dQz", "I", "dI"]])
 
+angle_dim = DatasetType(
+            name="I vs Phi",
+            required=["Phi", "I"],
+            optional=["dI", "dPhi", "Shadowfactor"],
+            expected_orders=[
+                ["Phi", "I", "dI"],
+                ["Phi", "dPhi", "I", "dI"]])
+
 sesans = DatasetType(
     name="SESANS",
     required=["SpinEchoLength", "Depolarisation", "Wavelength"],
     optional=["Transmission", "Polarisation"],
     expected_orders=[["z", "G"]])
 
-dataset_types = {dataset.name for dataset in [one_dim, two_dim, sesans]}
+dataset_types = {dataset.name for dataset in [one_dim, two_dim, angle_dim, sesans]}
 
 
 #

test/sasmanipulations/utest_averaging.py

@@ -155,7 +155,8 @@ def test_ring(self):
 
         self.assertEqual(len(answer_list), 1)
         for i in range(r.nbins_phi - 1):
-            self.assertAlmostEqual(o._data_contents["Q"].value[i], answer._data_contents["Q"].value[i], 4)
+            # Current ascii reader implementation assumes file data is "one_dim"
+            self.assertAlmostEqual(o._data_contents["Phi"].value[i], answer._data_contents["Q"].value[i], 4)
             self.assertAlmostEqual(o._data_contents["I"].value[i], answer._data_contents["I"].value[i], 4)
             self.assertAlmostEqual(o._data_contents["I"].variance.value[i], answer._data_contents["I"].variance.value[i], 4)
 

test/sasmanipulations/utest_averaging_circle.py

@@ -169,7 +169,7 @@ def test_ring_averages_azimuthally(self):
         data1d = ring_object(averager_data.data)
 
         expected_area = test_data.area_under_region(r_min=r_min, r_max=r_max)
-        actual_area = integrate.simpson(data1d._data_contents["I"].value, data1d._data_contents["Q"].value)
+        actual_area = integrate.simpson(data1d._data_contents["I"].value, data1d._data_contents["Phi"].value)
 
         self.assertAlmostEqual(actual_area, expected_area, 1)
 
@@ -223,9 +223,9 @@ def test_sectorq_averaging_without_fold(self):
 
         r_min = 0
         r_max = 0.9 * averager_data.qmax
-        phi_min = Pi/6
-        phi_max = 5*Pi/6
-        nbins = int(test_data.matrix_size * np.sqrt(2)/4)  # usually reliable
+        phi_min = Pi / 6.0
+        phi_max = 5.0 * Pi / 6.0
+        nbins = int(0.25 * test_data.matrix_size * np.sqrt(2))  # usually reliable
 
         wedge_object = SectorQ(r_range=(r_min, r_max), phi_range=(phi_min,phi_max), nbins=nbins)
         # Explicitly set fold to False - results span full +/- range
@@ -256,9 +256,9 @@ def test_sectorq_averaging_with_fold(self):
 
         r_min = 0
         r_max = 0.9 * averager_data.qmax
-        phi_min = Pi/6
-        phi_max = 5*Pi/6
-        nbins = int(test_data.matrix_size * np.sqrt(2)/4)  # usually reliable
+        phi_min = Pi / 6.0
+        phi_max = 5.0 * Pi / 6.0
+        nbins = int(0.25 * test_data.matrix_size * np.sqrt(2))  # usually reliable
 
         wedge_object = SectorQ(r_range=(r_min, r_max), phi_range=(phi_min,phi_max), nbins=nbins)
         # Explicitly set fold to True - points either side of 0,0 are averaged
@@ -317,16 +317,15 @@ def test_wedgeq_averaging(self):
 
         r_min = 0.1 * averager_data.qmax
         r_max = 0.9 * averager_data.qmax
-        phi_min = Pi/6
-        phi_max = 5*Pi/6
+        phi_min = Pi / 6.0
+        phi_max = 5.0 * Pi / 6.0
         nbins = int(test_data.matrix_size * np.sqrt(2)/4)  # usually reliable
 
         wedge_object = WedgeQ(r_range=(r_min, r_max), phi_range=(phi_min,phi_max), nbins=nbins)
         data1d = wedge_object(averager_data.data)
 
         expected_area = test_data.area_under_region(r_min=r_min, r_max=r_max,
-                                                    phi_min=phi_min,
-                                                    phi_max=phi_max)
+                                                    phi_min=phi_min, phi_max=phi_max)
         actual_area = integrate.simpson(data1d._data_contents["I"].value, data1d._data_contents["Q"].value)
 
         self.assertAlmostEqual(actual_area, expected_area, 1)
@@ -351,8 +350,6 @@ def test_wedgephi_init(self):
         nbins = 100
         # base = 10
 
-        # wedge_object = WedgePhi(r_min=r_min, r_max=r_max, phi_min=phi_min,
-        #                           phi_max=phi_max, nbins=nbins, base=base)
         wedge_object = WedgePhi(r_range=(r_min, r_max), phi_range=(phi_min,phi_max), nbins=nbins)
 
         self.assertEqual(wedge_object.r_min, r_min)
@@ -380,17 +377,17 @@ def test_wedgephi_averaging(self):
 
         r_min = 0.1 * averager_data.qmax
         r_max = 0.9 * averager_data.qmax
-        phi_min = Pi/6
-        phi_max = 5*Pi/6
-        nbins = int(test_data.matrix_size * np.sqrt(2)/4)  # usually reliable
+        phi_min = Pi / 6.0
+        phi_max = 5.0 * Pi / 6.0
+        nbins = int(0.25 *test_data.matrix_size * np.sqrt(2))  # usually reliable
 
         wedge_object = WedgePhi(r_range=(r_min, r_max), phi_range=(phi_min,phi_max), nbins=nbins)
         data1d = wedge_object(averager_data.data)
 
         expected_area = test_data.area_under_region(r_min=r_min, r_max=r_max,
-                                                    phi_min=phi_min,
-                                                    phi_max=phi_max)
-        actual_area = integrate.simpson(data1d._data_contents["I"].value, data1d._data_contents["Q"].value)
+                                                    phi_min=phi_min, phi_max=phi_max)
+
+        actual_area = integrate.simpson(data1d._data_contents["I"].value, data1d._data_contents["Phi"].value)
 
         self.assertAlmostEqual(actual_area, expected_area, 1)
 

test/utest_new_sasdata.py

@@ -2,11 +2,12 @@
 
 from sasdata.data import SasData
 from sasdata.data_backing import Group
-from sasdata.dataset_types import one_dim, three_dim, two_dim
+from sasdata.dataset_types import angle_dim, one_dim, three_dim, two_dim
 from sasdata.metadata import Instrument, Metadata, Source
 from sasdata.postprocess import deduce_qz
+from sasdata.quantities.constants import Pi
 from sasdata.quantities.quantity import Quantity
-from sasdata.quantities.units import angstroms, per_angstrom, per_centimeter
+from sasdata.quantities.units import angstroms, per_angstrom, per_centimeter, radians
 
 
 def test_1d():
@@ -105,3 +106,20 @@ def test_3d():
     deduce_qz(data)
 
     assert (data._data_contents['Qz'].value != (0*data._data_contents['Qx'].value)).all()
+
+def test_angle():
+    phi = [0.4 * Pi, 0.8 * Pi, 1.2 * Pi, 1.6 * Pi, 2 * Pi]
+    i = [5, 4, 3, 2, 1]
+
+    phi_quantity = Quantity(np.array(phi), radians)
+    i_quantity = Quantity(np.array(i), per_centimeter)
+
+    data_contents = {
+        'Phi': phi_quantity,
+        'I': i_quantity
+    }
+
+    data = SasData('TestData', data_contents, angle_dim, Group('root', {}), True)
+
+    assert all(data.abscissae.value == np.array(phi))
+    assert all(data.ordinate.value == np.array(i))