uxarray 2026.6.0__tar.gz → 2026.7.0__tar.gz

{uxarray-2026.6.0 → uxarray-2026.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uxarray
-Version: 2026.6.0
+Version: 2026.7.0
 Summary: Xarray extension for unstructured climate and global weather data analysis and visualization.
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -217,6 +217,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -226,10 +227,10 @@ Requires-Dist: dask[dataframe]
 Requires-Dist: datashader
 Requires-Dist: geoviews
 Requires-Dist: holoviews
-Requires-Dist: matplotlib
+Requires-Dist: matplotlib<3.11
 Requires-Dist: matplotlib-inline
 Requires-Dist: netcdf4
-Requires-Dist: numba
+Requires-Dist: numba>=0.63
 Requires-Dist: numpy
 Requires-Dist: pandas
 Requires-Dist: pyarrow
@@ -247,7 +248,6 @@ Requires-Dist: pyproj
 Provides-Extra: complete
 Requires-Dist: uxarray[dev]; extra == "complete"
 Provides-Extra: dev
-Requires-Dist: pathlib; extra == "dev"
 Requires-Dist: pre_commit; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"

{uxarray-2026.6.0 → uxarray-2026.7.0}/pyproject.toml

@@ -9,6 +9,7 @@ classifiers=[
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
 ]
 
 dynamic = ["version"]
@@ -27,10 +28,10 @@ dependencies = [
   "datashader",
   "geoviews",
   "holoviews",
-  "matplotlib",
+  "matplotlib<3.11",  # matplotlib 3.11.0 breaks some plots but <3.11 is fine; see issue #1542.
   "matplotlib-inline",
   "netcdf4",
-  "numba",
+  "numba>=0.63",  # 0.63 is the first release supporting Python 3.14 (3.10 <= py < 3.15). See #1561.
   "numpy",
   "pandas",
   "pyarrow",
@@ -50,7 +51,7 @@ dependencies = [
 
 [project.optional-dependencies]
 complete = ["uxarray[dev]"]
-dev = ['pathlib', 'pre_commit', 'pytest', 'pytest-cov', 'ruff', 'asv']
+dev = ['pre_commit', 'pytest', 'pytest-cov', 'ruff', 'asv']
 
 [project.urls]
 Documentation = "https://uxarray.readthedocs.io/"

{uxarray-2026.6.0 → uxarray-2026.7.0}/uxarray/core/api.py

@@ -353,7 +353,7 @@ def list_grid_names(
 
 def open_dataset(
     grid_filename_or_obj: str | os.PathLike[Any] | dict | Dataset,
-    filename_or_obj: str | os.PathLike[Any],
+    filename_or_obj: str | os.PathLike[Any] | Dataset | None = None,
     chunks=None,
     chunk_grid: bool = True,
     use_dual: bool | None = False,
@@ -364,14 +364,22 @@ def open_dataset(
 
     Parameters
     ----------
-    grid_filename_or_obj : str | os.PathLike[Any] | dict | xr.dataset
-        Strings and Path objects are interpreted as a path to a grid file. Xarray Datasets assume that
-        each member variable is in the UGRID conventions and will be used to create a ``ux.Grid``. Similarly, a dictionary
-        containing UGRID variables can be used to create a ``ux.Grid``
-    filename_or_obj : str | os.PathLike[Any]
+    grid_filename_or_obj : str | os.PathLike[Any] | dict | xr.Dataset
+        Grid information for the ``UxDataset``. Strings and Path objects are interpreted as a path to a grid
+        file. Xarray Datasets assume that each member variable is in the UGRID conventions and will be used to
+        create a ``ux.Grid``. Similarly, a dictionary containing UGRID variables can be used to create a
+        ``ux.Grid``. A path to a directory containing grid files (e.g. a FESOM2 ASCII grid) is also accepted,
+        but only when ``filename_or_obj`` is provided; directory input is not supported in the single-argument
+        form below.
+    filename_or_obj : str | os.PathLike[Any] | xr.Dataset, optional
         String or Path object as a path to a netCDF file or an OpenDAP URL that
-        stores the actual data set. It is the same ``filename_or_obj`` in
-        ``xarray.open_dataset``.
+        stores the actual data set, or an already-open ``xarray.Dataset``. It
+        is the same ``filename_or_obj`` in ``xarray.open_dataset``. If omitted,
+        ``grid_filename_or_obj`` is also used as the data source, allowing a
+        combined grid-and-data file or ``xarray.Dataset`` to be opened with a
+        single argument. In this single-argument form the file is used to build
+        the grid and also treated as data; all variables it contains, including
+        grid variables, will be included as data.
     chunks : int, dict, 'auto' or None, default: None
         If provided, used to load the grid into dask arrays.
 
@@ -400,29 +408,76 @@ def open_dataset(
     uxds : uxarray.UxDataset
         Dataset with linked `uxgrid` property of type `Grid`.
 
+    Notes
+    -----
+    The grid need not be a complete or fully UGRID-compliant mesh, nor represent
+    a spherical/Earth-science domain. A partial grid can be opened; operations
+    requiring information absent from the file will raise when used, but
+    unrelated functionality remains available.
+
     Examples
     --------
     Open a dataset with a grid file and data file
 
     >>> import uxarray as ux
     >>> ux_ds = ux.open_dataset("grid_file.nc", "data_file.nc")
+
+    Open a dataset stored in a single combined grid-and-data file
+
+    >>> ux_ds = ux.open_dataset("combined_file.nc")
     """
+    import xarray as xr
+
     if grid_kwargs is None:
         grid_kwargs = {}
 
-    # Construct a Grid, validate parameters, and correct chunks
-    uxgrid, corrected_chunks = _get_grid(
-        grid_filename_or_obj, chunks, chunk_grid, use_dual, grid_kwargs, **kwargs
-    )
+    if filename_or_obj is None:
+        if isinstance(grid_filename_or_obj, (str, os.PathLike)):
+            if os.path.isdir(grid_filename_or_obj):
+                raise ValueError(
+                    "ux.open_dataset() with a single directory argument is not supported. "
+                    "Supply a path to a grid file instead. Directory-based grids (e.g. a "
+                    "FESOM2 ASCII grid) are only recognized when a separate data file is "
+                    "also provided, i.e. ux.open_dataset(grid_directory, data_file)."
+                )
 
-    # Load the data as a Xarray Dataset
-    ds = _open_dataset_with_fallback(filename_or_obj, chunks=corrected_chunks, **kwargs)
+            ds = _open_dataset_with_fallback(
+                grid_filename_or_obj,
+                chunks=match_chunks_to_ugrid(grid_filename_or_obj, chunks),
+                **kwargs,
+            )
+        elif isinstance(grid_filename_or_obj, xr.Dataset):
+            ds = grid_filename_or_obj
+        else:
+            raise ValueError(
+                "If filename_or_obj is omitted, grid_filename_or_obj must be a file path or xarray.Dataset."
+            )
+
+        uxgrid, _ = _get_grid(ds, chunks, chunk_grid, use_dual, grid_kwargs, **kwargs)
+        filename_or_obj = grid_filename_or_obj
+    else:
+        # Construct a Grid, validate parameters, and correct chunks
+        uxgrid, corrected_chunks = _get_grid(
+            grid_filename_or_obj, chunks, chunk_grid, use_dual, grid_kwargs, **kwargs
+        )
+
+        # Load the data as a Xarray Dataset
+        if isinstance(filename_or_obj, xr.Dataset):
+            ds = filename_or_obj
+        else:
+            ds = _open_dataset_with_fallback(
+                filename_or_obj, chunks=corrected_chunks, **kwargs
+            )
 
     # Map original dimensions to the UGRID conventions
     ds = _map_dims_to_ugrid(ds, uxgrid._source_dims_dict, uxgrid)
 
     # Create a UXarray Dataset by linking the Xarray Dataset with a UXarray Grid
-    return UxDataset(ds, uxgrid=uxgrid, source_datasets=str(filename_or_obj))
+    source_datasets = (
+        None if isinstance(filename_or_obj, xr.Dataset) else str(filename_or_obj)
+    )
+
+    return UxDataset(ds, uxgrid=uxgrid, source_datasets=source_datasets)
 
 
 def open_mfdataset(

{uxarray-2026.6.0 → uxarray-2026.7.0}/uxarray/core/dataarray.py

@@ -164,6 +164,40 @@ class UxDataArray(xr.DataArray):
         else:
             return None
 
+    @property
+    def data_location(self):
+        """Returns where on the grid the data variable is stored.
+
+        The location is inferred from the grid dimension present in the data
+        variable, using UGRID-style names:
+
+        - ``"face_centered"`` if the data contains the ``n_face`` dimension
+        - ``"node_centered"`` if the data contains the ``n_node`` dimension
+        - ``"edge_centered"`` if the data contains the ``n_edge`` dimension
+        - ``None`` if the data is not mapped to the grid
+
+        Notes
+        -----
+        Additional locations described in the UGRID/spectral-element ecosystem
+        (e.g. ``"face_average"``, ``"edge_orthogonal"``, ``"edge_parallel"``,
+        ``"cgll"``, ``"dgll"``) cannot be inferred from a data variable's
+        dimensions alone and are not currently distinguished here.
+
+        Returns
+        -------
+        str or None
+            One of ``"face_centered"``, ``"node_centered"``,
+            ``"edge_centered"``, or ``None``.
+        """
+        if self._face_centered():
+            return "face_centered"
+        elif self._node_centered():
+            return "node_centered"
+        elif self._edge_centered():
+            return "edge_centered"
+        else:
+            return None
+
     def to_geodataframe(
         self,
         periodic_elements: str | None = "exclude",
@@ -1483,20 +1517,33 @@ class UxDataArray(xr.DataArray):
         Parameters
         ----------
         scale_by_radius : bool, default=True
-            Divide unit-sphere derivatives by ``uxgrid.sphere_radius``.
+            Divide unit-sphere derivatives by ``uxgrid.sphere_radius`` so the
+            result carries physical, per-meter units (``[data units]/m``). When
+            ``False`` the result is left on the unit sphere with per-radian units
+            (``[data units]/rad``). If ``True`` but the grid has no
+            ``sphere_radius`` attribute, the result falls back to unit-sphere
+            output and a ``UserWarning`` is emitted.
 
         Returns
         -------
         gradient: UxDataset
-            Dataset containing the zonal and merdional components of the gradient.
+            Dataset containing the zonal and meridional components of the gradient.
+            With the default ``scale_by_radius=True`` the components are in
+            ``[data units]/m``; with ``scale_by_radius=False`` they are in
+            ``[data units]/rad``.
 
         Notes
         -----
-        The Green-Gauss theorm is utilized, where a closed control volume around each cell
+        The Green-Gauss theorem is utilized, where a closed control volume around each cell
         is formed connecting centroids of the neighboring cells. The surface integral is
         approximated using the trapezoidal rule. The sum of the contributions is then
         normalized by the cell volume.
 
+        By default the raw unit-sphere (per-radian) gradient is divided by
+        ``uxgrid.sphere_radius`` to yield physical per-meter values. For Earth
+        (radius ~6.37e6 m) this scales magnitudes down by ~1/6.37e6 relative to
+        the unit-sphere result.
+
         Example
         -------
         >>> uxds["var"].gradient()
@@ -1539,7 +1586,10 @@ class UxDataArray(xr.DataArray):
             represent the meridional (v) component, while self represents the
             zonal (u) component.
         scale_by_radius : bool, default=True
-            Divide unit-sphere derivatives by ``uxgrid.sphere_radius``.
+            Divide unit-sphere derivatives by ``uxgrid.sphere_radius`` so the
+            result carries physical, per-meter units (e.g. ``1/s`` for a velocity
+            field). When ``False`` the result is left on the unit sphere
+            (per radian).
         **kwargs : dict
             Additional keyword arguments (currently unused, reserved for future extensions).
 
@@ -1547,7 +1597,9 @@ class UxDataArray(xr.DataArray):
         -------
         curl : UxDataArray
             The curl of the vector field (u, v), computed as:
-            curl = ∂v/∂x - ∂u/∂y
+            curl = ∂v/∂x - ∂u/∂y. With the default ``scale_by_radius=True`` the
+            result is in ``([u units])/m`` (``1/s`` for velocity); with
+            ``scale_by_radius=False`` it is in ``([u units])/rad``.
 
         Notes
         -----
@@ -1603,7 +1655,7 @@ class UxDataArray(xr.DataArray):
         u_units = self.attrs.get("units", "")
         has_sphere_radius = "sphere_radius" in self.uxgrid._ds.attrs
         if scale_by_radius and has_sphere_radius:
-            curl_units = f"({u_units})/m" if u_units else "1/s"
+            curl_units = f"({u_units})/m" if u_units else "1/m"
         else:
             curl_units = f"({u_units})/rad" if u_units else "1/rad"
 
@@ -1622,16 +1674,26 @@ class UxDataArray(xr.DataArray):
 
         return curl_da
 
-    def divergence(self, other: "UxDataArray", **kwargs) -> "UxDataArray":
+    def divergence(
+        self, other: "UxDataArray", scale_by_radius: bool = True, **kwargs
+    ) -> "UxDataArray":
         """
         Computes the divergence of the vector field defined by this UxDataArray and other.
 
         Parameters
         ----------
         other : UxDataArray
-            The second component of the vector field. This UxDataArray represents the first component.
+            The second (meridional, v) component of the vector field; ``self`` is
+            the first (zonal, u) component.
+        scale_by_radius : bool, default=True
+            Divide unit-sphere derivatives by ``uxgrid.sphere_radius``. When
+            ``True`` (and the grid has a ``sphere_radius`` attribute) the result
+            carries physical, per-meter units (e.g. ``1/s`` for a velocity
+            field); when ``False`` the result is left on the unit sphere
+            (per radian).
         **kwargs
-            Additional keyword arguments (reserved for future use).
+            Additional keyword arguments. ``units`` may be passed to override the
+            automatically inferred units.
 
         Returns
         -------
@@ -1645,7 +1707,9 @@ class UxDataArray(xr.DataArray):
         the divergence is calculated as div(V) = ∂u/∂x + ∂v/∂y.
 
         The implementation uses edge-centered gradients and face-centered divergence calculation
-        following the discrete divergence theorem.
+        following the discrete divergence theorem. By default the underlying
+        gradients are divided by ``uxgrid.sphere_radius``; pass
+        ``scale_by_radius=False`` for per-radian (unit-sphere) output.
 
         Example
         -------
@@ -1675,8 +1739,8 @@ class UxDataArray(xr.DataArray):
             )
 
         # Compute gradients of both components
-        u_gradient = self.gradient()
-        v_gradient = other.gradient()
+        u_gradient = self.gradient(scale_by_radius=scale_by_radius)
+        v_gradient = other.gradient(scale_by_radius=scale_by_radius)
 
         # For divergence: div(V) = ∂u/∂x + ∂v/∂y
         # We use the zonal gradient (∂/∂lon) of u and meridional gradient (∂/∂lat) of v
@@ -1687,10 +1751,24 @@ class UxDataArray(xr.DataArray):
         u, v = xr.align(u, v)
         divergence = u + v
         divergence.name = "divergence"
+
+        # Infer units consistently with gradient()/curl(): a divergence is a
+        # spatial derivative of the input field, so it carries an extra 1/length
+        # factor (per meter when scaled by radius, otherwise per radian).
+        if "units" in kwargs:
+            div_units = kwargs["units"]
+        else:
+            u_units = self.attrs.get("units", "")
+            has_sphere_radius = "sphere_radius" in self.uxgrid._ds.attrs
+            if scale_by_radius and has_sphere_radius:
+                div_units = f"({u_units})/m" if u_units else "1/m"
+            else:
+                div_units = f"({u_units})/rad" if u_units else "1/rad"
+
         divergence.attrs.update(
             {
                 "divergence": True,
-                "units": "1/s" if "units" not in kwargs else kwargs["units"],
+                "units": div_units,
             }
         )
 

{uxarray-2026.6.0 → uxarray-2026.7.0}/uxarray/core/dataset.py

@@ -570,7 +570,13 @@ class UxDataset(xr.Dataset):
         buf.write("\n".join(lines))
 
     def integrate(self, quadrature_rule="triangular", order=4):
-        """Integrates over all the faces of the givfen mesh.
+        """Integrates over all the faces of the given mesh, for every data
+        variable in the dataset.
+
+        Each data variable is integrated independently using
+        :meth:`UxDataArray.integrate`, and the results are collected into a new
+        :class:`UxDataset`. Variables whose final dimension does not map to the
+        grid (i.e. that are not face/node/edge centered) are skipped.
 
         Parameters
         ----------
@@ -581,45 +587,45 @@ class UxDataset(xr.Dataset):
 
         Returns
         -------
-        Calculated integral : float
+        uxds : UxDataset
+            Dataset containing the integrated value of each (grid-mapped) data
+            variable.
 
         Examples
         --------
-        Open a UXarray dataset
+        Open a UXarray dataset and integrate every data variable
 
         >>> import uxarray as ux
         >>> uxds = ux.open_dataset("grid.ug", "centroid_pressure_data_ug")
-
-        # Compute the integral
         >>> integral = uxds.integrate()
-        """
 
-        # TODO: Deprecation Warning
-        warn(
-            "This method currently only works when there is a single DataArray in this Dataset. For integration of a "
-            "single data variable, use the UxDataArray.integrate() method instead. This function will be deprecated and "
-            "replaced with one that can perform a Dataset-wide integration in a future release.",
-            DeprecationWarning,
-        )
+        Access the integral of a single variable
 
-        integral = 0.0
+        >>> integral["psi"]
+        """
+        integrated_vars = {}
+        skipped = []
 
-        face_areas = self.uxgrid.face_areas.values
+        for name, uxda in self.items():
+            try:
+                integrated_vars[name] = uxda.integrate(
+                    quadrature_rule=quadrature_rule, order=order
+                )
+            except ValueError:
+                # Variable is not mapped to the grid (or its location is not
+                # yet supported for integration); skip it rather than failing
+                # the whole dataset-wide integration.
+                skipped.append(name)
 
-        # TODO: Should we fix this requirement? Shouldn't it be applicable to
-        # TODO: all variables of dataset or a dataarray instead?
-        var_key = list(self.keys())
-        if len(var_key) > 1:
-            # warning: print message
-            print(
-                "WARNING: The dataset has more than one variable, using the first variable for integration"
+        if skipped:
+            warn(
+                "The following variables were skipped during integration because "
+                "their final dimension does not map to the grid (n_face, n_node, "
+                f"or n_edge) or is not yet supported: {skipped}.",
+                UserWarning,
             )
 
-        var_key = var_key[0]
-        face_vals = self[var_key].to_numpy()
-        integral = np.dot(face_areas, face_vals)
-
-        return integral
+        return UxDataset(integrated_vars, uxgrid=self.uxgrid)
 
     def to_array(
         self,

{uxarray-2026.6.0 → uxarray-2026.7.0}/uxarray/core/gradient.py

@@ -295,59 +295,58 @@ def _compute_gradients_on_faces(
     # Parallel across faces
     for face_idx in prange(n_face):
         gradient = np.zeros(3)
-
-        if not _check_face_on_boundary(
-            face_idx,
-            face_node_connectivity,
-            node_edge_connectivity,
-            edge_face_connectivity,
-        ):  # check face is not on boundary
-            for node_idx in face_node_connectivity[
-                face_idx
-            ]:  # take each node on that face
-                if node_idx != INT_FILL_VALUE:
-                    for edge_idx in node_edge_connectivity[
-                        node_idx
-                    ]:  # grab each edge connected to that node
-                        if edge_idx != INT_FILL_VALUE:
-                            if (
-                                face_idx not in edge_face_connectivity[edge_idx]
-                            ):  # check if edge connected to original face
-                                face1_idx = edge_face_connectivity[edge_idx][0]
-                                face2_idx = edge_face_connectivity[edge_idx][1]
-
-                                face1_coords = face_coords[face1_idx]
-                                face2_coords = face_coords[face2_idx]
-
-                                # compute normal pointing outwards from face
-                                cross = np.cross(face1_coords, face2_coords)
-                                norm = np.linalg.norm(cross)
-                                if (
-                                    np.dot(cross, face1_coords - face_coords[face_idx])
-                                    > 0
-                                ):
-                                    normal = cross / norm
-                                else:
-                                    normal = -cross / norm
-
-                                # compute arc length between the two faces
-                                arc_length = _compute_arc_length(
-                                    face_lat[face1_idx],
-                                    face_lat[face2_idx],
-                                    face_lon[face1_idx],
-                                    face_lon[face2_idx],
-                                )
-
-                                # compute trapezoidal rule
-                                trapz = (data[face1_idx] + data[face2_idx]) / 2
-
-                                # add to the gradient (subtract correction term)
-                                gradient = (
-                                    gradient
-                                    + (trapz - data[face_idx]) * arc_length * normal
-                                )
-
-        else:
+        has_contribution = False
+
+        for node_idx in face_node_connectivity[face_idx]:  # take each node on that face
+            if node_idx != INT_FILL_VALUE:
+                for edge_idx in node_edge_connectivity[
+                    node_idx
+                ]:  # grab each edge connected to that node
+                    if edge_idx != INT_FILL_VALUE:
+                        # Skip edges that lack a second face neighbor
+                        # instead of NaN-ing the entire face.  Fixes
+                        # grids where edge_face_connectivity has
+                        # spurious INT_FILL_VALUE entries (e.g. SCRIP-
+                        # derived SE grids like ne120np4).  See #1452.
+                        if INT_FILL_VALUE in edge_face_connectivity[edge_idx]:
+                            continue
+
+                        if (
+                            face_idx not in edge_face_connectivity[edge_idx]
+                        ):  # check if edge connected to original face
+                            face1_idx = edge_face_connectivity[edge_idx][0]
+                            face2_idx = edge_face_connectivity[edge_idx][1]
+
+                            face1_coords = face_coords[face1_idx]
+                            face2_coords = face_coords[face2_idx]
+
+                            # compute normal pointing outwards from face
+                            cross = np.cross(face1_coords, face2_coords)
+                            norm = np.linalg.norm(cross)
+                            if np.dot(cross, face1_coords - face_coords[face_idx]) > 0:
+                                normal = cross / norm
+                            else:
+                                normal = -cross / norm
+
+                            # compute arc length between the two faces
+                            arc_length = _compute_arc_length(
+                                face_lat[face1_idx],
+                                face_lat[face2_idx],
+                                face_lon[face1_idx],
+                                face_lon[face2_idx],
+                            )
+
+                            # compute trapezoidal rule
+                            trapz = (data[face1_idx] + data[face2_idx]) / 2
+
+                            # add to the gradient (subtract correction term)
+                            gradient = (
+                                gradient
+                                + (trapz - data[face_idx]) * arc_length * normal
+                            )
+                            has_contribution = True
+
+        if not has_contribution:
             gradient = np.full(3, np.nan)
 
         node_neighbors = face_node_connectivity[face_idx]

{uxarray-2026.6.0 → uxarray-2026.7.0}/uxarray/core/utils.py

@@ -104,7 +104,11 @@ def match_chunks_to_ugrid(grid_filename_or_obj, chunks):
         # No need to rename
         return chunks
 
-    ds = _open_dataset_with_fallback(grid_filename_or_obj, chunks=chunks)
+    if isinstance(grid_filename_or_obj, xr.Dataset):
+        ds = grid_filename_or_obj
+    else:
+        ds = _open_dataset_with_fallback(grid_filename_or_obj, chunks=chunks)
+
     grid_spec, _, _ = _parse_grid_type(ds)
 
     source_dims_dict = _get_source_dims_dict(ds, grid_spec)

{uxarray-2026.6.0 → uxarray-2026.7.0}/uxarray/grid/grid.py

@@ -302,7 +302,7 @@ class Grid:
                 # custom source grid spec is provided
                 source_grid_spec = kwargs.get("source_grid_spec", None)
                 grid_ds = dataset
-                source_dims_dict = {}
+                source_dims_dict = kwargs.get("source_dims_dict") or {}
         else:
             try:
                 if os.path.isdir(dataset):
@@ -528,9 +528,18 @@ class Grid:
         if ds is not None:
             return cls.from_dataset(ds)
         if lon is not None and lat is not None:
-            grid_ds = _read_structured_grid(lon, lat, tol)
+            # Capture the source dimension names so data variables mapped over
+            # (lon, lat) can later be flattened onto ``n_face`` by
+            # ``UxDataset.from_xarray`` (see GH #1410). ``xr.DataArray`` inputs
+            # carry their dim names; plain arrays fall back to "lon"/"lat".
+            lon_name = lon.dims[0] if isinstance(lon, xr.DataArray) else "lon"
+            lat_name = lat.dims[0] if isinstance(lat, xr.DataArray) else "lat"
+
+            grid_ds = _read_structured_grid(np.asarray(lon), np.asarray(lat), tol)
             return cls.from_dataset(
-                grid_ds, source_dims_dict=None, source_grid_spec="structured"
+                grid_ds,
+                source_dims_dict={"n_face": (lon_name, lat_name)},
+                source_grid_spec="Structured",
             )
         else:
             raise ValueError(
@@ -1951,8 +1960,21 @@ class Grid:
         -------
         Sum of area of all the faces in the mesh : float
         """
+        # Default parameters match the cached ``face_areas`` property, which also
+        # preserves the equal-area values used for HEALPix grids; reuse it to avoid
+        # recomputation. Any non-default quadrature settings require a fresh
+        # geometric computation so the requested rule/order actually take effect.
+        if (
+            quadrature_rule == "triangular"
+            and order == 4
+            and not latitude_adjusted_area
+        ):
+            return np.sum(self.face_areas.values)
 
-        return np.sum(self.face_areas.values)
+        face_areas, _ = self._compute_face_areas(
+            quadrature_rule, order, latitude_adjusted_area
+        )
+        return np.sum(face_areas)
 
     def compute_face_areas(
         self,