Merge pull request #7 from cassidymwagner/sep_dist_debug

Separation distance bug fix

Author: cassidymwagner

oceans_sf/__init__.py

@@ -4,6 +4,7 @@
 """
 
 from .bin_data import bin_data
+from .calculate_advection import calculate_advection
 from .calculate_separation_distances import calculate_separation_distances
 from .calculate_structure_function import (
     calculate_structure_function,

oceans_sf/generate_structure_functions.py

@@ -25,6 +25,7 @@ def generate_structure_functions(  # noqa: C901, D417
     nbins=10,
 ):
     """
+    TEST
     Full method for generating structure functions for 2D data, either advective or
     traditional structure functions. Supports velocity-based and scalar-based structure
     functions. Defaults to calculating the velocity-based advective structure functions
@@ -113,8 +114,8 @@ def generate_structure_functions(  # noqa: C901, D417
             SF_m_trad_scalar = np.zeros(len(sep_m) + 1)
 
     # Iterate over separations right and down
-    for down, right in zip(sep_m, sep_z):  # noqa: B905
-        xroll = shift_array1d(x, shift_by=right, boundary=boundary)
+    for down in sep_m:
+        right = 1
         yroll = shift_array1d(y, shift_by=down, boundary=boundary)
 
         SF_dicts = calculate_structure_function(
@@ -131,27 +132,50 @@ def generate_structure_functions(  # noqa: C901, D417
             boundary,
         )
 
-        # Maybe don't do this and just let the dict have Nones in it,
-        # probably a lot easier and less silly
         if skip_velocity_sf is False:
-            SF_z[right] = SF_dicts["SF_velocity_right"]
             SF_m[down] = SF_dicts["SF_velocity_down"]
             if traditional_order > 0:
-                SF_z_trad_velocity[right] = SF_dicts["SF_trad_velocity_right"]
                 SF_m_trad_velocity[down] = SF_dicts["SF_trad_velocity_down"]
         if scalar is not None:
-            SF_z_scalar[right] = SF_dicts["SF_scalar_right"]
             SF_m_scalar[down] = SF_dicts["SF_scalar_down"]
             if traditional_order > 0:
-                SF_z_trad_scalar[right] = SF_dicts["SF_trad_scalar_right"]
                 SF_m_trad_scalar[down] = SF_dicts["SF_trad_scalar_down"]
 
-        # Calculate separation distances in x and y
-        xd[right], tmp = calculate_separation_distances(
-            x[right], y[right], xroll[right], yroll[right], grid_type
-        )
+        # Calculate separation distances in y
         tmp, yd[down] = calculate_separation_distances(
-            x[down], y[down], xroll[down], yroll[down], grid_type
+            x[right], y[down], x[right], yroll[down], grid_type
+        )
+
+    for right in sep_z:
+        down = 1
+        xroll = shift_array1d(x, shift_by=right, boundary=boundary)
+
+        SF_dicts = calculate_structure_function(
+            u,
+            v,
+            adv_E,
+            adv_N,
+            down,
+            right,
+            skip_velocity_sf,
+            scalar,
+            adv_scalar,
+            traditional_order,
+            boundary,
+        )
+
+        if skip_velocity_sf is False:
+            SF_z[right] = SF_dicts["SF_velocity_right"]
+            if traditional_order > 0:
+                SF_z_trad_velocity[right] = SF_dicts["SF_trad_velocity_right"]
+        if scalar is not None:
+            SF_z_scalar[right] = SF_dicts["SF_scalar_right"]
+            if traditional_order > 0:
+                SF_z_trad_scalar[right] = SF_dicts["SF_trad_scalar_right"]
+
+        # Calculate separation distances in x
+        xd[right], tmp = calculate_separation_distances(
+            x[right], y[down], xroll[right], y[down], grid_type
         )
 
     # Bin the data if the grid is uneven

tests/test_generate_structure_functions.py

@@ -197,13 +197,13 @@
                     [
                         0.0,
                         111127.34496561,
-                        222085.35856591,
-                        332772.46924562,
-                        443087.12759851,
-                        552927.80866002,
-                        662193.01584979,
-                        770781.28701475,
-                        878591.20301767,
+                        222254.67962213,
+                        333381.99365421,
+                        444509.27673393,
+                        555636.51851453,
+                        666763.70862407,
+                        777890.83665907,
+                        889017.89217812,
                     ]
                 ),
             },  # expected_dict
@@ -257,9 +257,9 @@
                     [
                         0.0,
                         111127.34496561,
-                        222085.35856591,
-                        332772.46924562,
-                        443087.12759851,
+                        222254.67962213,
+                        333381.99365421,
+                        444509.27673393,
                     ]
                 ),
             },  # expected_dict
@@ -304,7 +304,7 @@
                 "y-diffs": np.array([1, 4, 7]),
             },  # expected_dict
         ),
-        # Test 5: all with no boundary and latlon grid and binning
+        # Test 6: all with no boundary and latlon grid and binning
         (
             np.array(
                 [[i + 1 for i in range(j * 10, (j + 1) * 10)] for j in range(10)]
@@ -344,10 +344,50 @@
                     [111195.08372419, 444780.33489677, 778365.58606934]
                 ),
                 "y-diffs": np.array(
-                    [111070.90117717, 442929.13516805, 770521.83529407]
+                    [111127.34152924, 444509.26296756, 777890.81248708]
                 ),
             },  # expected_dict
         ),
+        # Test 7: all with no boundary and uneven x vs y
+        (
+            np.array(
+                [[i + 1 for i in range(j * 5, (j + 1) * 5)] for j in range(10)]
+            ),  # u
+            np.array([[i + 1 for i in range(j * 5, (j + 1) * 5)] for j in range(10)])
+            * 2,  # v
+            np.linspace(1, 5, 5),  # x
+            np.linspace(1, 10, 10),  # y
+            False,  # skip_velocity_sf
+            np.array([[i + 1 for i in range(j * 5, (j + 1) * 5)] for j in range(10)])
+            * 3,  # scalar
+            3,  # traditional_order
+            None,  # dx
+            None,  # dy
+            None,  # boundary
+            False,  # even
+            "uniform",  # grid_type
+            5,  # nbins
+            {
+                "SF_advection_velocity_zonal": np.array([0, 55, 220, 495]),
+                "SF_advection_velocity_meridional": np.array(
+                    [687.5, 8937.5, 22000, 41937.5, 77687.5]
+                ),
+                "SF_advection_scalar_zonal": np.array([0, 99, 396, 891]),
+                "SF_advection_scalar_meridional": np.array(
+                    [1237.5, 16087.5, 39600.0, 75487.5, 139837.5]
+                ),
+                "SF_traditional_velocity_zonal": np.array([0, -1, -8, -27]),
+                "SF_traditional_velocity_meridional": np.array(
+                    [-62.5, -2187.5, -8000.0, -21312.5, -53437.5]
+                ),
+                "SF_traditional_scalar_zonal": np.array([0, -27, -216, -729]),
+                "SF_traditional_scalar_meridional": np.array(
+                    [-1687.5, -59062.5, -216000.0, -575437.5, -1442812.5]
+                ),
+                "x-diffs": np.linspace(0, 3, 4),
+                "y-diffs": np.array([0.5, 2.5, 4, 5.5, 7.5]),
+            },  # expected_dict
+        ),
     ],
 )
 def test_generate_structure_functions_parameterized(