\n",
+ " \n",
+ "
\n",
+ ""
+ ],
+ "text/plain": [
+ ":Overlay\n",
+ " .Path.I :Path [Longitude,Latitude]\n",
+ " .Points.Node_Data :Points [lon,lat] (z)\n",
+ " .Points.Edge_Data :Points [lon,lat] (z)\n",
+ " .Points.Face_Data :Points [lon,lat] (z)"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {
+ "application/vnd.holoviews_exec.v0+json": {
+ "id": "7525dfe8-6240-48aa-aef6-0c6bf325d4c3"
+ }
+ },
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "(\n",
+ " uxds.uxgrid.plot(line_color=\"black\")\n",
+ " * uxds[\"random_data_node\"]\n",
+ " .plot.points(\n",
+ " cmap=\"inferno\", size=150, marker=\"circle\", clabel=None, tools=[\"hover\"]\n",
+ " )\n",
+ " .relabel(\"Node Data\")\n",
+ " * uxds[\"random_data_edge\"]\n",
+ " .plot.points(\n",
+ " cmap=\"inferno\", size=150, marker=\"square\", clabel=None, tools=[\"hover\"]\n",
+ " )\n",
+ " .relabel(\"Edge Data\")\n",
+ " * uxds[\"random_data_face\"]\n",
+ " .plot.points(\n",
+ " cmap=\"inferno\", size=150, marker=\"triangle\", clabel=None, tools=[\"hover\"]\n",
+ " )\n",
+ " .relabel(\"Face Data\")\n",
+ ").opts(legend_position=\"top_right\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "584207e271b49e06",
+ "metadata": {
+ "collapsed": false,
+ "jupyter": {
+ "outputs_hidden": false
+ }
+ },
+ "source": [
+ "## Node Aggregations\n",
+ "\n",
+ "The follow aggregations are for node-centered data."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "62136ed1b4e4d52e",
+ "metadata": {
+ "collapsed": false,
+ "jupyter": {
+ "outputs_hidden": false
+ }
+ },
+ "source": [
+ "### Node to Face\n",
+ "\n",
+ "We can aggregate the data from the nodes that surround each face and store the result on each face.\n",
+ "\n",
+ "![\"Optional](\"../_static/examples/agg/node_face.png\")
"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "6cdf74072b2c2b43",
+ "metadata": {
+ "collapsed": false,
+ "jupyter": {
+ "outputs_hidden": false
+ }
+ },
+ "outputs": [],
+ "source": [
+ "uxda_node_face_agg = uxds[\"random_data_node\"].topological_mean(destination=\"face\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "fdea0dda96ebe09d",
+ "metadata": {
+ "collapsed": false,
+ "jupyter": {
+ "outputs_hidden": false
+ }
+ },
+ "outputs": [
+ {
+ "data": {},
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.holoviews_exec.v0+json": "",
+ "text/html": [
+ "\n",
+ " \n",
+ "
\n",
+ ""
+ ],
+ "text/plain": [
+ ":Overlay\n",
+ " .Path.I :Path [Longitude,Latitude]\n",
+ " .Points.Node_Data :Points [lon,lat] (z)\n",
+ " .Points.Node_to_Face_Mean :Points [lon,lat] (z)"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {
+ "application/vnd.holoviews_exec.v0+json": {
+ "id": "p1164"
+ }
+ },
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "(\n",
+ " uxds.uxgrid.plot(line_color=\"black\")\n",
+ " * uxds[\"random_data_node\"]\n",
+ " .plot.points(\n",
+ " cmap=\"inferno\", size=150, marker=\"circle\", clabel=None, tools=[\"hover\"]\n",
+ " )\n",
+ " .relabel(\"Node Data\")\n",
+ " * uxda_node_face_agg.plot.points(\n",
+ " cmap=\"inferno\", size=150, marker=\"triangle\", clabel=None, tools=[\"hover\"]\n",
+ " ).relabel(\"Node to Face Mean\")\n",
+ ").opts(title=\"Node to Face Aggregation (Mean)\", legend_position=\"top_right\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e8f959f893e838ff",
+ "metadata": {
+ "collapsed": false,
+ "jupyter": {
+ "outputs_hidden": false
+ }
+ },
+ "source": [
+ "One use case for aggregating node-centered data to each face is that it allows for the result to be plotted as Polygons."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "e7c7780435202338",
+ "metadata": {
+ "collapsed": false,
+ "jupyter": {
+ "outputs_hidden": false
+ }
+ },
+ "outputs": [
+ {
+ "data": {},
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.holoviews_exec.v0+json": "",
+ "text/html": [
+ "\n",
+ " \n",
+ "
\n",
+ ""
+ ],
+ "text/plain": [
+ ":DynamicMap []\n",
+ " :Image [Longitude,Latitude] (Longitude_Latitude random_data_node)"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {
+ "application/vnd.holoviews_exec.v0+json": {
+ "id": "p1293"
+ }
+ },
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "uxda_node_face_agg.plot.polygons(\n",
+ " cmap=\"inferno\",\n",
+ " title=\"Polygon Plot of Node to Face Aggregation (Mean)\",\n",
+ " tools=[\"hover\"],\n",
+ ").opts(title=\"Node to Face Aggregation (Mean)\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "71b10f1a1f0a0939",
+ "metadata": {
+ "collapsed": false,
+ "jupyter": {
+ "outputs_hidden": false
+ }
+ },
+ "source": [
+ "### Node to Edge\n",
+ "\n",
+ "We can aggregate the data from the nodes that saddle each edge and store the result on each edge.\n",
+ "\n",
+ "![\"Optional](\"../_static/examples/agg/node_edge.png\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "19b624f42cbdc16b",
+ "metadata": {
+ "collapsed": false,
+ "jupyter": {
+ "outputs_hidden": false
+ }
+ },
+ "source": [
+ "For a node-centered data variable, we can set `destination=\"edge\"` to specify that the aggregation should be performed on the nodes that saddle each edge, with the result stored on each edge."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "db5c4cce296023a",
+ "metadata": {
+ "collapsed": false,
+ "jupyter": {
+ "outputs_hidden": false
+ }
+ },
+ "outputs": [],
+ "source": [
+ "uxda_node_edge_agg = uxds[\"random_data_node\"].topological_mean(destination=\"edge\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "4a3c7b486e5d78d",
+ "metadata": {
+ "collapsed": false,
+ "jupyter": {
+ "outputs_hidden": false
+ }
+ },
+ "outputs": [
+ {
+ "data": {},
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.holoviews_exec.v0+json": "",
+ "text/html": [
+ "\n",
+ " \n",
+ "
\n",
+ ""
+ ],
+ "text/plain": [
+ ":Overlay\n",
+ " .Path.I :Path [Longitude,Latitude]\n",
+ " .Points.Node_Data :Points [lon,lat] (z)\n",
+ " .Points.Node_to_Edge_Mean :Points [lon,lat] (z)"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {
+ "application/vnd.holoviews_exec.v0+json": {
+ "id": "p1370"
+ }
+ },
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "(\n",
+ " uxds.uxgrid.plot(line_color=\"black\")\n",
+ " * uxds[\"random_data_node\"]\n",
+ " .plot.points(\n",
+ " cmap=\"inferno\", size=150, marker=\"circle\", clabel=None, tools=[\"hover\"]\n",
+ " )\n",
+ " .relabel(\"Node Data\")\n",
+ " * uxda_node_edge_agg.plot.points(\n",
+ " cmap=\"inferno\", size=150, marker=\"square\", clabel=None, tools=[\"hover\"]\n",
+ " ).relabel(\"Node to Edge Mean\")\n",
+ ").opts(title=\"Node to Edge Aggregation (Mean)\", legend_position=\"top_right\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "448ac6705a18f85b",
+ "metadata": {
+ "collapsed": false,
+ "jupyter": {
+ "outputs_hidden": false
+ }
+ },
+ "source": [
+ "## Edge Aggregations\n",
+ "\n",
+ "The follow aggregations are for edge-centered data. \n",
+ "\n",
+ "```{warning}\n",
+ "Aggregation of edge-centered data is not yet supported in UXarray. \n",
+ "```\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "357fe2f645bf3d4e",
+ "metadata": {
+ "collapsed": false,
+ "jupyter": {
+ "outputs_hidden": false
+ }
+ },
+ "source": [
+ "### Edge to Node\n",
+ "\n",
+ "We can aggregate the data from the edges that surround each node and store the result on each node.\n",
+ "\n",
+ "![\"Optional](\"../_static/examples/agg/edge_node.png\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "86846522863860f5",
+ "metadata": {
+ "collapsed": false,
+ "jupyter": {
+ "outputs_hidden": false
+ }
+ },
+ "source": [
+ "### Edge to Face\n",
+ "\n",
+ "We can aggregate the data from the edges that surround each face and store the result on each face.\n",
+ "\n",
+ "![\"Optional](\"../_static/examples/agg/edge_face.png\")
"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "b9769693-62a8-4566-95cc-6a8078358bf5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "uxda_edge_face_agg = uxds[\"random_data_edge\"].topological_mean(destination=\"face\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "f2bc4883-ea2c-47c6-8305-b5b06224a56e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {},
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.holoviews_exec.v0+json": "",
+ "text/html": [
+ "\n",
+ " \n",
+ "
\n",
+ ""
+ ],
+ "text/plain": [
+ ":Overlay\n",
+ " .Path.I :Path [Longitude,Latitude]\n",
+ " .Points.Node_Data :Points [lon,lat] (z)\n",
+ " .Points.Node_to_Edge_Mean :Points [lon,lat] (z)"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {
+ "application/vnd.holoviews_exec.v0+json": {
+ "id": "p1011"
+ }
+ },
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "(\n",
+ " uxds.uxgrid.plot(line_color=\"black\")\n",
+ " * uxds[\"random_data_edge\"]\n",
+ " .plot.points(\n",
+ " cmap=\"inferno\", size=150, marker=\"circle\", clabel=None, tools=[\"hover\"]\n",
+ " )\n",
+ " .relabel(\"Node Data\")\n",
+ " * uxda_edge_face_agg.plot.points(\n",
+ " cmap=\"inferno\", size=150, marker=\"square\", clabel=None, tools=[\"hover\"]\n",
+ " ).relabel(\"Node to Edge Mean\")\n",
+ ").opts(title=\"Node to Edge Aggregation (Mean)\", legend_position=\"top_right\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7dd482e719e7d775",
+ "metadata": {
+ "collapsed": false,
+ "jupyter": {
+ "outputs_hidden": false
+ }
+ },
+ "source": [
+ "## Face Aggregations\n",
+ "\n",
+ "The following aggregations are for face-centered data.\n",
+ "\n",
+ "```{warning}\n",
+ "Aggregation of face-centered data is not yet supported in UXarray. \n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "29ebe5d21bbcc46b",
+ "metadata": {
+ "collapsed": false,
+ "jupyter": {
+ "outputs_hidden": false
+ }
+ },
+ "source": [
+ "### Face to Node\n",
+ "\n",
+ "We can aggregate the data from the faces that surround each node and store the result on each node.\n",
+ "\n",
+ "![\"Optional](\"../_static/examples/agg/face_node.png\")
"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "4fb30cee-69b9-4136-8a65-40cbd0d4f708",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "The autoreload extension is already loaded. To reload it, use:\n",
+ " %reload_ext autoreload\n"
+ ]
+ },
+ {
+ "ename": "NameError",
+ "evalue": "name 'uxds' is not defined",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[2], line 4\u001b[0m\n\u001b[1;32m 1\u001b[0m get_ipython()\u001b[38;5;241m.\u001b[39mrun_line_magic(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mload_ext\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mautoreload\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 2\u001b[0m get_ipython()\u001b[38;5;241m.\u001b[39mrun_line_magic(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mautoreload\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m2\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m----> 4\u001b[0m uxda_face_node_agg \u001b[38;5;241m=\u001b[39m uxds[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mrandom_data_face\u001b[39m\u001b[38;5;124m\"\u001b[39m]\u001b[38;5;241m.\u001b[39mtopological_mean(destination\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnode\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
+ "\u001b[0;31mNameError\u001b[0m: name 'uxds' is not defined"
+ ]
+ }
+ ],
+ "source": [
+ "%load_ext autoreload\n",
+ "%autoreload 2\n",
+ "\n",
+ "uxda_face_node_agg = uxds[\"random_data_face\"].topological_mean(destination=\"node\")\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1609e8bef449a334",
+ "metadata": {
+ "collapsed": false,
+ "jupyter": {
+ "outputs_hidden": false
+ }
+ },
+ "source": [
+ "### Face to Edge\n",
+ "\n",
+ "We can aggregate the data from the faces that saddle each edge and store the result on each edge\n",
+ "\n",
+ "![\"Optional](\"../_static/examples/agg/face_edge.png\")
"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.7"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/user-guide/topological-aggregations.ipynb b/docs/user-guide/topological-aggregations.ipynb
index 68593878d..cf5d9ee4c 100644
--- a/docs/user-guide/topological-aggregations.ipynb
+++ b/docs/user-guide/topological-aggregations.ipynb
@@ -377,12 +377,7 @@
"source": [
"## Edge Aggregations\n",
"\n",
- "The follow aggregations are for edge-centered data. \n",
- "\n",
- "```{warning}\n",
- "Aggregation of edge-centered data is not yet supported in UXarray. \n",
- "```\n",
- "\n"
+ "The follow aggregations are for edge-centered data. "
]
},
{
@@ -402,6 +397,36 @@
""
]
},
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8c462c1c-cf55-4bb5-a78a-5ac28366cc9b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "uxda_edge_face_agg = uxds[\"random_data_edge\"].topological_mean(destination=\"node\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6c809274-1b47-42da-8f21-227cd7206fac",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "(\n",
+ " uxds.uxgrid.plot(line_color=\"black\")\n",
+ " * uxds[\"random_data_edge\"]\n",
+ " .plot.points(\n",
+ " cmap=\"inferno\", size=150, marker=\"circle\", clabel=None, tools=[\"hover\"]\n",
+ " )\n",
+ " .relabel(\"Edge Data\")\n",
+ " * uxda_node_edge_agg.plot.points(\n",
+ " cmap=\"inferno\", size=150, marker=\"square\", clabel=None, tools=[\"hover\"]\n",
+ " ).relabel(\"Edge to Node Mean\")\n",
+ ").opts(title=\"Edge to Node Aggregation (Mean)\", legend_position=\"top_right\")"
+ ]
+ },
{
"cell_type": "markdown",
"id": "86846522863860f5",
@@ -419,6 +444,38 @@
""
]
},
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b9769693-62a8-4566-95cc-6a8078358bf5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "%load_ext autoreload\n",
+ "%autoreload 2\n",
+ "uxda_edge_face_agg = uxds[\"random_data_edge\"].topological_mean(destination=\"face\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f2bc4883-ea2c-47c6-8305-b5b06224a56e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "(\n",
+ " uxds.uxgrid.plot(line_color=\"black\")\n",
+ " * uxds[\"random_data_edge\"]\n",
+ " .plot.points(\n",
+ " cmap=\"inferno\", size=150, marker=\"circle\", clabel=None, tools=[\"hover\"]\n",
+ " )\n",
+ " .relabel(\"Edge Data\")\n",
+ " * uxda_edge_face_agg.plot.points(\n",
+ " cmap=\"inferno\", size=150, marker=\"square\", clabel=None, tools=[\"hover\"]\n",
+ " ).relabel(\"Edge to Face Mean\")\n",
+ ").opts(title=\"Edge to Face Aggregation (Mean)\", legend_position=\"top_right\")"
+ ]
+ },
{
"cell_type": "markdown",
"id": "7dd482e719e7d775",
@@ -431,11 +488,7 @@
"source": [
"## Face Aggregations\n",
"\n",
- "The following aggregations are for face-centered data.\n",
- "\n",
- "```{warning}\n",
- "Aggregation of face-centered data is not yet supported in UXarray. \n",
- "```\n"
+ "The following aggregations are for face-centered data."
]
},
{
@@ -455,6 +508,36 @@
""
]
},
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4fb30cee-69b9-4136-8a65-40cbd0d4f708",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "uxda_face_node_agg = uxds[\"random_data_face\"].topological_mean(destination=\"node\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e68c204f-ae92-4d2a-aada-696239b73f62",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "(\n",
+ " uxds.uxgrid.plot(line_color=\"black\")\n",
+ " * uxds[\"random_data_face\"]\n",
+ " .plot.points(\n",
+ " cmap=\"inferno\", size=150, marker=\"circle\", clabel=None, tools=[\"hover\"]\n",
+ " )\n",
+ " .relabel(\"Face Data\")\n",
+ " * uxda_face_node_agg.plot.points(\n",
+ " cmap=\"inferno\", size=150, marker=\"square\", clabel=None, tools=[\"hover\"]\n",
+ " ).relabel(\"Face to Node Mean\")\n",
+ ").opts(title=\"Face to Node Aggregation (Mean)\", legend_position=\"top_right\")"
+ ]
+ },
{
"cell_type": "markdown",
"id": "1609e8bef449a334",
@@ -471,6 +554,44 @@
"\n",
""
]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f1104d1e-97fc-4403-8daa-f2dc33a37900",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "uxda_face_edge_agg = uxds[\"random_data_face\"].topological_mean(destination=\"edge\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ff32897f-e555-474a-978a-723929261b38",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "(\n",
+ " uxds.uxgrid.plot(line_color=\"black\")\n",
+ " * uxds[\"random_data_face\"]\n",
+ " .plot.points(\n",
+ " cmap=\"inferno\", size=150, marker=\"circle\", clabel=None, tools=[\"hover\"]\n",
+ " )\n",
+ " .relabel(\"Face Data\")\n",
+ " * uxda_face_edge_agg.plot.points(\n",
+ " cmap=\"inferno\", size=150, marker=\"square\", clabel=None, tools=[\"hover\"]\n",
+ " ).relabel(\"Face to Edge Mean\")\n",
+ ").opts(title=\"Face to Edge Aggregation (Mean)\", legend_position=\"top_right\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b55ecc0e-2015-4248-b5a6-c5a997faa6d5",
+ "metadata": {},
+ "outputs": [],
+ "source": []
}
],
"metadata": {
@@ -489,7 +610,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.11.8"
+ "version": "3.12.7"
}
},
"nbformat": 4,
diff --git a/test/test_topological_agg.py b/test/test_topological_agg.py
index f8f4a05a0..e6c066aac 100644
--- a/test/test_topological_agg.py
+++ b/test/test_topological_agg.py
@@ -7,7 +7,6 @@
current_path = Path(os.path.dirname(os.path.realpath(__file__)))
-
ds_path = current_path / 'meshfiles' / "mpas" / "QU" / 'oQU480.231010.nc'
AGGS = ["topological_mean",
@@ -32,7 +31,6 @@ def test_node_to_face_aggs():
assert 'n_face' in grid_reduction.dims
-
def test_node_to_edge_aggs():
uxds = ux.open_dataset(ds_path, ds_path)
@@ -40,3 +38,15 @@ def test_node_to_edge_aggs():
grid_reduction = getattr(uxds['areaTriangle'], agg_func)(destination='edge')
assert 'n_edge' in grid_reduction.dims
+
+
+def test_edge_to_face_aggs():
+ grid_path = '/Users/aaronzedwick/uxarray/test/meshfiles/mpas/QU/mesh.QU.1920km.151026.nc'
+
+ uxds = ux.open_dataset(grid_path, grid_path)
+
+ uxds = uxds['latCell'].subset.nearest_neighbor(k=3, center_coord=[0, 0])
+
+ uxda_edge_face_agg = uxds.topological_mean(destination="node")
+
+ print(uxda_edge_face_agg)
diff --git a/uxarray/conventions/ugrid.py b/uxarray/conventions/ugrid.py
index 707c1dd79..21fc245f4 100644
--- a/uxarray/conventions/ugrid.py
+++ b/uxarray/conventions/ugrid.py
@@ -224,6 +224,33 @@
N_NODES_PER_FACE_DIMS = ["n_face"]
+N_FACES_PER_NODE_ATTRS = {
+ "cf_role": "n_faces_per_node",
+ "long name": "Number of faces per node",
+}
+
+N_FACES_PER_NODE_DIMS = ["n_node"]
+
+N_FACES_PER_EDGE_ATTRS = {
+ "cf_role": "n_faces_per_edge",
+ "long name": "Number of faces per edge",
+}
+
+N_FACES_PER_EDGE_DIMS = ["n_edge"]
+
+N_EDGES_PER_FACE_ATTRS = {
+ "cf_role": "n_edges_per_face",
+ "long name": "Number of edges per face",
+}
+
+N_EDGES_PER_FACE_DIMS = ["n_face"]
+
+N_EDGES_PER_NODE_ATTRS = {
+ "cf_role": "n_edges_per_node",
+ "long name": "Number of edges per node",
+}
+
+N_EDGES_PER_NODE_DIMS = ["n_node"]
CONNECTIVITY_NAMES = [
"face_node_connectivity",
diff --git a/uxarray/core/aggregation.py b/uxarray/core/aggregation.py
index 23aaa6ba0..de2b241ed 100644
--- a/uxarray/core/aggregation.py
+++ b/uxarray/core/aggregation.py
@@ -37,32 +37,32 @@ def _uxda_grid_aggregate(uxda, destination, aggregation, **kwargs):
else:
raise ValueError(
f"Invalid destination for a node-centered data variable. Expected"
- f"one of ['face', 'edge' but received {destination}"
+ f"one of ['face', 'edge'] but received {destination}"
)
elif uxda._edge_centered():
# aggregation of an edge-centered data variable
- raise NotImplementedError(
- "Aggregation of edge-centered data variables is not yet supported."
- )
- # if destination == "node":
- # pass
- # elif destination == "face":
- # pass
- # else:
- # raise ValueError("TODO: )
+ if destination == "face":
+ return _edge_to_face_aggregation(uxda, aggregation, kwargs)
+ elif destination == "node":
+ return _edge_to_node_aggregation(uxda, aggregation, kwargs)
+ else:
+ raise ValueError(
+ f"Invalid destination for an edge-centered data variable. Expected"
+ f"one of ['face', 'node'] but received {destination}"
+ )
elif uxda._face_centered():
# aggregation of a face-centered data variable
- raise NotImplementedError(
- "Aggregation of face-centered data variables is not yet supported."
- )
- # if destination == "node":
- # pass
- # elif destination == "edge":
- # pass
- # else:
- # raise ValueError("TODO: ")
+ if destination == "node":
+ return _face_to_node_aggregation(uxda, aggregation, kwargs)
+ elif destination == "edge":
+ return _face_to_edge_aggregation(uxda, aggregation, kwargs)
+ else:
+ raise ValueError(
+ f"Invalid destination for a face-centered data variable. Expected"
+ f"one of ['node', 'edge'] but received {destination}"
+ )
else:
raise ValueError(
@@ -181,3 +181,247 @@ def _apply_node_to_edge_aggregation_numpy(
def _apply_node_to_edge_aggregation_dask(*args, **kwargs):
"""Applies a Node to Edge topological aggregation on a dask array."""
pass
+
+
+def _apply_edge_to_face_aggregation_numpy(
+ uxda, aggregation_func, aggregation_func_kwargs
+):
+ """Applies an Edge to Face Topological aggregation on a Numpy array."""
+ data = uxda.values
+ face_edge_conn = uxda.uxgrid.face_edge_connectivity.values
+ n_nodes_per_face = uxda.uxgrid.n_nodes_per_face.values
+
+ (
+ change_ind,
+ n_nodes_per_face_sorted_ind,
+ element_sizes,
+ size_counts,
+ ) = get_face_node_partitions(n_nodes_per_face)
+
+ result = np.empty(shape=(data.shape[:-1]) + (uxda.uxgrid.n_face,))
+
+ for e, start, end in zip(element_sizes, change_ind[:-1], change_ind[1:]):
+ face_inds = n_nodes_per_face_sorted_ind[start:end]
+ face_nodes_par = face_edge_conn[face_inds, 0:e]
+
+ # apply aggregation function to current face edge partition
+ aggregation_par = aggregation_func(
+ data[..., face_nodes_par], axis=-1, **aggregation_func_kwargs
+ )
+
+ # store current aggregation
+ result[..., face_inds] = aggregation_par
+
+ return result
+
+
+def _edge_to_face_aggregation(uxda, aggregation, aggregation_func_kwargs):
+ """Applies an Edge to Face Topological aggregation."""
+ if not uxda._edge_centered():
+ raise ValueError(
+ f"Data Variable must be mapped to the edge centers of each face, with dimension "
+ f"{uxda.uxgrid.n_edge}."
+ )
+
+ if isinstance(uxda.data, np.ndarray):
+ # apply aggregation using numpy
+ aggregated_var = _apply_edge_to_face_aggregation_numpy(
+ uxda, NUMPY_AGGREGATIONS[aggregation], aggregation_func_kwargs
+ )
+ elif isinstance(uxda.data, da.Array):
+ # apply aggregation on dask array, TODO:
+ aggregated_var = _apply_edge_to_face_aggregation_numpy(
+ uxda, NUMPY_AGGREGATIONS[aggregation], aggregation_func_kwargs
+ )
+ else:
+ raise ValueError
+
+ return uxarray.core.dataarray.UxDataArray(
+ uxgrid=uxda.uxgrid,
+ data=aggregated_var,
+ dims=uxda.dims,
+ name=uxda.name,
+ ).rename({"n_edge": "n_face"})
+
+
+def _apply_edge_to_node_aggregation_numpy(
+ uxda, aggregation_func, aggregation_func_kwargs
+):
+ """Applies an Edge to Node Topological aggregation on a Numpy array."""
+ data = uxda.values
+ node_edge_conn = uxda.uxgrid.node_edge_connectivity.values
+ n_edges_per_node = uxda.uxgrid.n_edges_per_node.values
+
+ (
+ change_ind,
+ n_edges_per_node_sorted_ind,
+ element_sizes,
+ size_counts,
+ ) = get_face_node_partitions(n_edges_per_node)
+
+ result = np.empty(shape=(data.shape[:-1]) + (uxda.uxgrid.n_node,))
+
+ for e, start, end in zip(element_sizes, change_ind[:-1], change_ind[1:]):
+ node_inds = n_edges_per_node_sorted_ind[start:end]
+ node_edges_par = node_edge_conn[node_inds, 0:e]
+
+ # apply aggregation function to current node edge partition
+ aggregation_par = aggregation_func(
+ data[..., node_edges_par], axis=-1, **aggregation_func_kwargs
+ )
+
+ # store current aggregation
+ result[..., node_inds] = aggregation_par
+
+ return result
+
+
+def _edge_to_node_aggregation(uxda, aggregation, aggregation_func_kwargs):
+ """Applies an Edge to Node Topological aggregation."""
+ if not uxda._edge_centered():
+ raise ValueError(
+ f"Data Variable must be mapped to the edge centers of each face, with dimension "
+ f"{uxda.uxgrid.n_edge}."
+ )
+
+ if isinstance(uxda.data, np.ndarray):
+ # apply aggregation using numpy
+ aggregated_var = _apply_edge_to_node_aggregation_numpy(
+ uxda, NUMPY_AGGREGATIONS[aggregation], aggregation_func_kwargs
+ )
+ elif isinstance(uxda.data, da.Array):
+ # apply aggregation on dask array, TODO:
+ aggregated_var = _apply_edge_to_node_aggregation_numpy(
+ uxda, NUMPY_AGGREGATIONS[aggregation], aggregation_func_kwargs
+ )
+ else:
+ raise ValueError
+
+ return uxarray.core.dataarray.UxDataArray(
+ uxgrid=uxda.uxgrid,
+ data=aggregated_var,
+ dims=uxda.dims,
+ name=uxda.name,
+ ).rename({"n_edge": "n_node"})
+
+
+def _apply_face_to_node_aggregation_numpy(
+ uxda, aggregation_func, aggregation_func_kwargs
+):
+ """Applies a Face to Node Topological aggregation on a Numpy array."""
+ data = uxda.values
+ node_face_conn = uxda.uxgrid.node_face_connectivity.values
+ n_faces_per_node = uxda.uxgrid.n_faces_per_node.values
+
+ (
+ change_ind,
+ n_faces_per_node_sorted_ind,
+ element_sizes,
+ size_counts,
+ ) = get_face_node_partitions(n_faces_per_node)
+
+ result = np.empty(shape=(data.shape[:-1]) + (uxda.uxgrid.n_node,))
+
+ for e, start, end in zip(element_sizes, change_ind[:-1], change_ind[1:]):
+ face_inds = n_faces_per_node_sorted_ind[start:end]
+ face_nodes_par = node_face_conn[face_inds, 0:e]
+
+ # apply aggregation function to current node face partition
+ aggregation_par = aggregation_func(
+ data[..., face_nodes_par], axis=-1, **aggregation_func_kwargs
+ )
+
+ # store current aggregation
+ result[..., face_inds] = aggregation_par
+
+ return result
+
+
+def _face_to_node_aggregation(uxda, aggregation, aggregation_func_kwargs):
+ """Applies a Face to Node Topological aggregation."""
+ if not uxda._face_centered():
+ raise ValueError(
+ f"Data Variable must be mapped to the face centers of each face, with dimension "
+ f"{uxda.uxgrid.n_face}."
+ )
+
+ if isinstance(uxda.data, np.ndarray):
+ # apply aggregation using numpy
+ aggregated_var = _apply_face_to_node_aggregation_numpy(
+ uxda, NUMPY_AGGREGATIONS[aggregation], aggregation_func_kwargs
+ )
+ elif isinstance(uxda.data, da.Array):
+ # apply aggregation on dask array, TODO:
+ aggregated_var = _apply_face_to_node_aggregation_numpy(
+ uxda, NUMPY_AGGREGATIONS[aggregation], aggregation_func_kwargs
+ )
+ else:
+ raise ValueError
+
+ return uxarray.core.dataarray.UxDataArray(
+ uxgrid=uxda.uxgrid,
+ data=aggregated_var,
+ dims=uxda.dims,
+ name=uxda.name,
+ ).rename({"n_face": "n_node"})
+
+
+def _apply_face_to_edge_aggregation_numpy(
+ uxda, aggregation_func, aggregation_func_kwargs
+):
+ """Applies a Face to Edge Topological aggregation on a Numpy array."""
+ data = uxda.values
+ edge_face_conn = uxda.uxgrid.edge_face_connectivity.values
+ n_faces_per_edge = uxda.uxgrid.n_faces_per_edge.values
+
+ (
+ change_ind,
+ n_faces_per_edge_sorted_ind,
+ element_sizes,
+ size_counts,
+ ) = get_face_node_partitions(n_faces_per_edge)
+
+ result = np.empty(shape=(data.shape[:-1]) + (uxda.uxgrid.n_edge,))
+
+ for e, start, end in zip(element_sizes, change_ind[:-1], change_ind[1:]):
+ face_inds = n_faces_per_edge_sorted_ind[start:end]
+ face_edge_par = edge_face_conn[face_inds, 0:e]
+
+ # apply aggregation function to current node face partition
+ aggregation_par = aggregation_func(
+ data[..., face_edge_par], axis=-1, **aggregation_func_kwargs
+ )
+
+ # store current aggregation
+ result[..., face_inds] = aggregation_par
+
+ return result
+
+
+def _face_to_edge_aggregation(uxda, aggregation, aggregation_func_kwargs):
+ """Applies a Face to Edge Topological aggregation."""
+ if not uxda._face_centered():
+ raise ValueError(
+ f"Data Variable must be mapped to the face centers of each face, with dimension "
+ f"{uxda.uxgrid.n_face}."
+ )
+
+ if isinstance(uxda.data, np.ndarray):
+ # apply aggregation using numpy
+ aggregated_var = _apply_face_to_edge_aggregation_numpy(
+ uxda, NUMPY_AGGREGATIONS[aggregation], aggregation_func_kwargs
+ )
+ elif isinstance(uxda.data, da.Array):
+ # apply aggregation on dask array, TODO:
+ aggregated_var = _apply_face_to_edge_aggregation_numpy(
+ uxda, NUMPY_AGGREGATIONS[aggregation], aggregation_func_kwargs
+ )
+ else:
+ raise ValueError
+
+ return uxarray.core.dataarray.UxDataArray(
+ uxgrid=uxda.uxgrid,
+ data=aggregated_var,
+ dims=uxda.dims,
+ name=uxda.name,
+ ).rename({"n_face": "n_edge"})
diff --git a/uxarray/grid/connectivity.py b/uxarray/grid/connectivity.py
index 2fff94244..fc9718e85 100644
--- a/uxarray/grid/connectivity.py
+++ b/uxarray/grid/connectivity.py
@@ -158,6 +158,114 @@ def _build_n_nodes_per_face(face_nodes, n_face, n_max_face_nodes):
return n_nodes_per_face
+def _populate_n_faces_per_node(grid):
+ """Constructs the connectivity variable (``n_faces_per_node``) and stores
+ it within the internal (``Grid._ds``) and through the attribute
+ (``Grid.n_faces_per_node``)."""
+
+ n_faces_per_node = _build_n_nodes_per_face(
+ grid.node_face_connectivity.values, grid.n_node, grid.n_max_node_faces
+ )
+
+ if n_faces_per_node.ndim == 0:
+ # convert scalar value into a [1, 1] array
+ n_faces_per_node = np.expand_dims(n_faces_per_node, 0)
+
+ # add to internal dataset
+ grid._ds["n_faces_per_node"] = xr.DataArray(
+ data=n_faces_per_node,
+ dims=ugrid.N_FACES_PER_NODE_DIMS,
+ attrs=ugrid.N_FACES_PER_NODE_ATTRS,
+ )
+
+
+@njit(cache=True)
+def _build_n_faces_per_node(node_faces, n_nodes, n_max_node_faces):
+ """Constructs ``n_faces_per_node``, which contains the number of non-fill-
+ value nodes for each face in ``node_face_connectivity``"""
+
+ # padding to shape [n_nodes, n_max_node_faces + 1]
+ closed = np.ones((n_nodes, n_max_node_faces + 1), dtype=INT_DTYPE) * INT_FILL_VALUE
+
+ closed[:, :-1] = node_faces.copy()
+
+ n_faces_per_node = np.argmax(closed == INT_FILL_VALUE, axis=1)
+
+ return n_faces_per_node
+
+
+def _populate_n_faces_per_edge(grid):
+ """Constructs the connectivity variable (``n_faces_per_edge``) and stores
+ it within the internal (``Grid._ds``) and through the attribute
+ (``Grid.n_faces_per_edge``)."""
+
+ n_faces_per_edge = _build_n_faces_per_edge(
+ grid.edge_face_connectivity.values, grid.n_edge, 2
+ )
+
+ if n_faces_per_edge.ndim == 0:
+ # convert scalar value into a [1, 1] array
+ n_faces_per_edge = np.expand_dims(n_faces_per_edge, 0)
+
+ # add to internal dataset
+ grid._ds["n_faces_per_edge"] = xr.DataArray(
+ data=n_faces_per_edge,
+ dims=ugrid.N_FACES_PER_EDGE_DIMS,
+ attrs=ugrid.N_FACES_PER_EDGE_ATTRS,
+ )
+
+
+@njit(cache=True)
+def _build_n_faces_per_edge(edge_faces, n_edges, n_max_edge_faces):
+ """Constructs ``n_faces_per_edge``, which contains the number of non-fill-
+ value nodes for each face in ``edge_face_connectivity``"""
+
+ # padding to shape [n_edges, n_max_edge_faces + 1]
+ closed = np.ones((n_edges, n_max_edge_faces + 1), dtype=INT_DTYPE) * INT_FILL_VALUE
+
+ closed[:, :-1] = edge_faces.copy()
+
+ n_faces_per_edge = np.argmax(closed == INT_FILL_VALUE, axis=1)
+
+ return n_faces_per_edge
+
+
+def _populate_n_edges_per_node(grid):
+ """Constructs the connectivity variable (``n_edges_per_node``) and stores
+ it within the internal (``Grid._ds``) and through the attribute
+ (``Grid.n_edges_per_node``)."""
+
+ n_edges_per_node = _build_n_edges_per_node(
+ grid.node_edge_connectivity.values, grid.n_edge, grid.n_max_node_edges
+ )
+
+ if n_edges_per_node.ndim == 0:
+ # convert scalar value into a [1, 1] array
+ n_edges_per_node = np.expand_dims(n_edges_per_node, 0)
+
+ # add to internal dataset
+ grid._ds["n_edges_per_node"] = xr.DataArray(
+ data=n_edges_per_node,
+ dims=ugrid.N_EDGES_PER_NODE_DIMS,
+ attrs=ugrid.N_EDGES_PER_NODE_ATTRS,
+ )
+
+
+@njit(cache=True)
+def _build_n_edges_per_node(edge_nodes, n_edges, n_max_node_edges):
+ """Constructs ``n_edges_per_node``, which contains the number of non-fill-
+ value nodes for each face in ``node_edge_connectivity``"""
+
+ # padding to shape [n_edges, n_max_edge_faces + 1]
+ closed = np.ones((n_edges, n_max_node_edges + 1), dtype=INT_DTYPE) * INT_FILL_VALUE
+
+ closed[:, :-1] = edge_nodes.copy()
+
+ n_edges_per_node = np.argmax(closed == INT_FILL_VALUE, axis=1)
+
+ return n_edges_per_node
+
+
def _populate_edge_node_connectivity(grid):
"""Constructs the UGRID connectivity variable (``edge_node_connectivity``)
and stores it within the internal (``Grid._ds``) and through the attribute
diff --git a/uxarray/grid/grid.py b/uxarray/grid/grid.py
index c975ebff8..cb7980560 100644
--- a/uxarray/grid/grid.py
+++ b/uxarray/grid/grid.py
@@ -57,6 +57,9 @@
_populate_node_face_connectivity,
_populate_edge_face_connectivity,
_populate_face_face_connectivity,
+ _populate_n_faces_per_node,
+ _populate_n_faces_per_edge,
+ _populate_n_edges_per_node,
)
from uxarray.grid.geometry import (
@@ -870,6 +873,57 @@ def n_nodes_per_face(self, value):
assert isinstance(value, xr.DataArray)
self._ds["n_nodes_per_face"] = value
+ @property
+ def n_faces_per_node(self) -> xr.DataArray:
+ """The number of faces that surround each node.
+
+ Dimensions: ``(n_face, )``
+ """
+ if "n_faces_per_node" not in self._ds:
+ _populate_n_faces_per_node(self)
+
+ return self._ds["n_faces_per_node"]
+
+ @n_faces_per_node.setter
+ def n_faces_per_node(self, value):
+ """Setter for ``n_faces_per_node``"""
+ assert isinstance(value, xr.DataArray)
+ self._ds["n_faces_per_node"] = value
+
+ @property
+ def n_faces_per_edge(self) -> xr.DataArray:
+ """The number of faces that surround each edge.
+
+ Dimensions: ``(n_face, )``
+ """
+ if "n_faces_per_edge" not in self._ds:
+ _populate_n_faces_per_edge(self)
+
+ return self._ds["n_faces_per_edge"]
+
+ @n_faces_per_edge.setter
+ def n_faces_per_edge(self, value):
+ """Setter for ``n_faces_per_edge``"""
+ assert isinstance(value, xr.DataArray)
+ self._ds["n_faces_per_edge"] = value
+
+ @property
+ def n_edges_per_node(self) -> xr.DataArray:
+ """The number of edges that surround each node.
+
+ Dimensions: ``(n_edge, )``
+ """
+ if "n_edges_per_node" not in self._ds:
+ _populate_n_edges_per_node(self)
+
+ return self._ds["n_edges_per_node"]
+
+ @n_edges_per_node.setter
+ def n_edges_per_node(self, value):
+ """Setter for ``n_edges_per_node``"""
+ assert isinstance(value, xr.DataArray)
+ self._ds["n_edges_per_node"] = value
+
@property
def node_lon(self) -> xr.DataArray:
"""Longitude of each node in degrees.