fix: adding support for unequal step vectors in 2D and 3D structured grid interpolators

Author: lachlangrose

LoopStructural/interpolators/supports/_2d_structured_grid.py

@@ -495,22 +495,36 @@ def vtk(self, node_properties={}, cell_properties={}):
         pass
 
     def get_operators(self, weights: Dict[str, float]) -> Dict[str, Tuple[np.ndarray, float]]:
-        """Get
+        """Get operators with step vector scaling for unequal spacing
 
         Parameters
         ----------
         weights : Dict[str, float]
-            _description_
+            Weight value per operator
 
         Returns
         -------
         Dict[str, Tuple[np.ndarray, float]]
-            _description_
+            Dictionary mapping operator names to (mask, scaled_weight) tuples
+        
+        Notes
+        -----
+        Operator weights are scaled by step vector to account for unequal grid spacing:
+        - Second derivatives (dxx, dyy): scale by 1 / step_vector[d]^2
+        - Mixed derivatives (dxy): scale by 1 / (step_vector[0] * step_vector[1])
         """
+        # Get step vector for scaling (2D uses x and y)
+        step_x, step_y = self.step_vector[0], self.step_vector[1]
+        
+        # Scale factors for finite difference operators
+        dxx_scale = 1.0 / (step_x ** 2)
+        dyy_scale = 1.0 / (step_y ** 2)
+        dxy_scale = 1.0 / (step_x * step_y)
+        
         # in a map we only want the xy operators
         operators = {
-            'dxy': (Operator.Dxy_mask[1, :, :], weights['dxy'] * 2),
-            'dxx': (Operator.Dxx_mask[1, :, :], weights['dxx']),
-            'dyy': (Operator.Dyy_mask[1, :, :], weights['dyy']),
+            'dxy': (Operator.Dxy_mask[1, :, :], weights['dxy'] * 2 * dxy_scale),
+            'dxx': (Operator.Dxx_mask[1, :, :], weights['dxx'] * dxx_scale),
+            'dyy': (Operator.Dyy_mask[1, :, :], weights['dyy'] * dyy_scale),
         }
         return operators

LoopStructural/interpolators/supports/_3d_structured_grid.py

@@ -487,13 +487,33 @@ def get_operators(self, weights: Dict[str, float]) -> Dict[str, Tuple[np.ndarray
         -------
         operators
             A dictionary with a numpy array and float weight
+        
+        Notes
+        -----
+        Operator weights are scaled by step vector to account for unequal grid spacing:
+        - Second derivatives (dxx, dyy, dzz): scale by 1 / step_vector[d]^2
+        - Mixed derivatives (dxy, dxz, dyz): scale by 1 / (step_vector[d1] * step_vector[d2])
         """
+        # Get step vector for scaling
+        step_x, step_y, step_z = self.step_vector[0], self.step_vector[1], self.step_vector[2]
+        
+        # Scale factors for finite difference operators
+        # Second derivatives need 1/h^2 scaling for physical space
+        dxx_scale = 1.0 / (step_x ** 2)
+        dyy_scale = 1.0 / (step_y ** 2)
+        dzz_scale = 1.0 / (step_z ** 2)
+        
+        # Mixed derivatives need 1/(h1*h2) scaling for physical space
+        dxy_scale = 1.0 / (step_x * step_y)
+        dyz_scale = 1.0 / (step_y * step_z)
+        dxz_scale = 1.0 / (step_x * step_z)
+        
         operators = {
-            'dxy': (Operator.Dxy_mask, weights['dxy'] / 4),
-            'dyz': (Operator.Dyz_mask, weights['dyz'] / 4),
-            'dxz': (Operator.Dxz_mask, weights['dxz'] / 4),
-            'dxx': (Operator.Dxx_mask, weights['dxx'] / 1),
-            'dyy': (Operator.Dyy_mask, weights['dyy'] / 1),
-            'dzz': (Operator.Dzz_mask, weights['dzz'] / 1),
+            'dxy': (Operator.Dxy_mask, weights['dxy'] / 4 * dxy_scale),
+            'dyz': (Operator.Dyz_mask, weights['dyz'] / 4 * dyz_scale),
+            'dxz': (Operator.Dxz_mask, weights['dxz'] / 4 * dxz_scale),
+            'dxx': (Operator.Dxx_mask, weights['dxx'] / 1 * dxx_scale),
+            'dyy': (Operator.Dyy_mask, weights['dyy'] / 1 * dyy_scale),
+            'dzz': (Operator.Dzz_mask, weights['dzz'] / 1 * dzz_scale),
         }
         return operators