update docstring

Author: philipc2

uxarray/cross_sections/dataarray_accessor.py

@@ -16,8 +16,6 @@
 
 
 class UxDataArrayCrossSectionAccessor:
-    """TODO"""
-
     def __init__(self, uxda) -> None:
         self.uxda = uxda
 
@@ -29,16 +27,58 @@ def __call__(
         lat: float | None = None,
         lon: float | None = None,
         steps: int = 100,
-        interp_type="nearest",
     ) -> xr.DataArray:
         """
-        TODO:
-        """
+        Extracts a cross-section sampled along an arbitrary great-circle arc (GCA) or line of constant latitude/longitude.
 
-        if interp_type != "nearest":
-            raise ValueError(
-                f"Only 'nearest' interpolation is supported, not '{interp_type}'"
-            )
+        Exactly one mode must be specified:
+
+        - **Great‐circle**: supply both `start` and `end` (lon, lat) tuples,
+          samples a geodesic arc.
+        - **Constant latitude**: supply `lat` alone (float),
+          returns points along that latitude.
+        - **Constant longitude**: supply `lon` alone (float),
+          returns points along that longitude.
+
+        Parameters
+        ----------
+        start : tuple[float, float], optional
+            (lon, lat) of the geodesic start point.
+        end : tuple[float, float], optional
+            (lon, lat) of the geodesic end point.
+        lat : float, optional
+            Latitude for a constant‐latitude slice.
+        lon : float, optional
+            Longitude for a constant‐longitude slice.
+        steps : int, default 100
+            Number of sample points (including endpoints).
+
+        Returns
+        -------
+        xr.DataArray
+            A DataArray with a new `"steps"` dimension, plus `"lat"` and `"lon"`
+            coordinate variables giving the sampling positions.
+
+
+        Examples
+        --------
+
+        Cross-section between two points (lon ,lat)
+
+        >>> uxda.cross_section(start=(-45, -45), end=(45, 45))
+
+        Constant latitude cross-section
+
+        >>> uxda.cross_section(lat=45)
+
+        Constant longitude cross-section
+
+        >>> uxda.cross_section(lon=0)
+
+        Constant longitude cross-section with custom number of steps
+
+        >>> uxda.cross_section(lon=0, steps=200)
+        """
 
         great_circle = start is not None or end is not None
         const_lon = lon is not None
@@ -68,15 +108,13 @@ def __call__(
         )
         face_idx = np.array([row[0] if row else -1 for row in faces], dtype=INT_DTYPE)
 
-        # Prepare new dimension names & axes
         orig_dims = list(self.uxda.dims)
         face_axis = orig_dims.index("n_face")
         new_dim = "steps"
         new_dims = [new_dim if d == "n_face" else d for d in orig_dims]
         dim_axis = new_dims.index(new_dim)
 
-        # TODO:
-        arr = np.moveaxis(self.uxda.compute().data, face_axis, -1)
+        arr = np.moveaxis(self.uxda.compute().values, face_axis, -1)
         M, Nf = arr.reshape(-1, arr.shape[-1]).shape
         flat_orig = arr.reshape(M, Nf)
 

uxarray/cross_sections/sample.py

@@ -4,10 +4,10 @@
 
 
 @njit(parallel=True)
-def _fill_numba(flat_orig, face_idx, n_face, n_samples):
+def _fill_numba(flat_orig, face_idx, n_face, n_steps):
     M = flat_orig.shape[0]
-    out = np.full((M, n_samples), np.nan, flat_orig.dtype)
-    for i in prange(n_samples):
+    out = np.full((M, n_steps), np.nan, flat_orig.dtype)
+    for i in prange(n_steps):
         f = face_idx[i]
         if 0 <= f < n_face:
             out[:, i] = flat_orig[:, f]
@@ -77,7 +77,7 @@ def sample_constant_latitude(lat: float, steps: int) -> tuple[np.ndarray, np.nda
     rad_lon = np.deg2rad(lons)
     rad_lat = np.deg2rad(lats)
 
-    # spherical → Cartesian
+    # spherical to Cartesian
     x = np.cos(rad_lat) * np.cos(rad_lon)
     y = np.cos(rad_lat) * np.sin(rad_lon)
     z = np.sin(rad_lat)
@@ -104,7 +104,7 @@ def sample_constant_longitude(lon: float, steps: int) -> tuple[np.ndarray, np.nd
     rad_lon = np.deg2rad(lons)
     rad_lat = np.deg2rad(lats)
 
-    # spherical → Cartesian
+    # spherical to Cartesian
     x = np.cos(rad_lat) * np.cos(rad_lon)
     y = np.cos(rad_lat) * np.sin(rad_lon)
     z = np.sin(rad_lat)