{ "cells": [ { "cell_type": "markdown", "id": "36e8b323", "metadata": {}, "source": [ "(tuto4)=\n", "# Towards custom mesh manipulation\n", "\n", "The previous tutorial had you search the documentation for functionalities\n", "and chain them together to create your workflow. In this tutorial, you will take a\n", "step on the developer side, as some questions require you to manipulate the mesh directly,\n", "especially in the second part of the tutorial.\n", "\n", "This time, we will explore some post processing capabilities of maia.\n", "We work on an CRM airplane mesh, with data fields computed by a solver.\n", "\n", "To run this tutorial, you need to download the input mesh [airplane.cgns] and\n", "the script {download}`04_post.py`. We prepared few functions for you in the script,\n", "but you will need to complete it as usual.\n", "\n", "[airplane.cgns]: https://github.com/onera/Maia/releases/download/v1.8/airplane.cgns" ] }, { "cell_type": "code", "execution_count": null, "id": "6d2f24fd", "metadata": { "tags": [ "remove-cell", "no-parallel" ] }, "outputs": [], "source": [ "# This create a symlink of the input file in current directory, for automatic execution\n", "SRC = '/stck/jcoulet/Public/maia_training/MESHES/airplane.cgns'\n", "import os\n", "if not os.path.exists('airplane.cgns'):\n", " os.symlink(SRC, 'airplane.cgns')" ] }, { "cell_type": "markdown", "id": "e94c1a2d", "metadata": {}, "source": [ "## Basic postprocessing\n", "\n", "### Warmup" ] }, { "cell_type": "code", "execution_count": null, "id": "0c6860db", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [], "source": [ "def get_solver_tree():\n", " tree = maia.io.file_to_dist_tree('airplane.cgns', comm)\n", " ptree = maia.factory.partition_dist_tree(tree, comm, preserve_orientation=True, data_transfer='FIELDS')\n", " return ptree\n", "\n", "def plot_1d_profile(x, y, comm):\n", " import numpy as np\n", " import plotly.graph_objects as go\n", "\n", " import utils\n", "\n", " x = comm.gather(x, root=0)\n", " y = comm.gather(y, root=0)\n", " \n", " if comm.Get_rank() != 0:\n", " return\n", "\n", " # > Concatenate arrays\n", " x = np.concatenate(x)\n", " y = np.concatenate(y)\n", "\n", " fig = go.Figure()\n", "\n", " fig.add_trace(\n", " go.Scatter(\n", " x=x, y=y,\n", " mode='markers',\n", " name='Wing',\n", " line=dict(color=utils.rtd_note_title),\n", " )\n", " )\n", "\n", " fig.update_layout(\n", " xaxis=dict(\n", " title=dict(\n", " text='X position',\n", " ),\n", " showline=True,\n", " linecolor='black',\n", " gridcolor='lightgrey'\n", " ),\n", " yaxis=dict(\n", " title=dict(\n", " text='Pressure',\n", " ),\n", " showline=True,\n", " linecolor='black',\n", " gridcolor='lightgrey'\n", " ),\n", " font=dict(\n", " family='Courier New, monospace',\n", " size=14,\n", " ),\n", " plot_bgcolor='white',\n", " showlegend=False,\n", " )\n", "\n", " fig.write_html('../_static/tuto04_1dprofile.html')" ] }, { "cell_type": "markdown", "id": "910ed319", "metadata": {}, "source": [ "👉️ As usual, we import the useful modules and we get the MPI communicator" ] }, { "cell_type": "code", "execution_count": null, "id": "18a238d3", "metadata": {}, "outputs": [], "source": [ "from mpi4py import MPI\n", "comm = MPI.COMM_WORLD\n", "\n", "import maia\n", "import maia.pytree as PT" ] }, { "cell_type": "markdown", "id": "5bc269ff", "metadata": {}, "source": [ "👉️ Then, we use the following function which simulates a solver run." ] }, { "cell_type": "code", "execution_count": null, "id": "8fc1d5c7", "metadata": { "tags": [ "remove-output" ] }, "outputs": [ { "data": { "text/plain": [ "[stdout:0] Distributed read of file airplane.cgns...\n", "Read completed (5.14 s) -- Size of dist_tree for current rank is 89.7MiB (Σ=552.5MiB)\n", "Partitioning tree of 1 initial block...\n", "Partitioning completed (2.93 s) -- Nb of cells for current rank is 770.0K (Σ=4.5M)\n" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "\n" ] } ], "source": [ "tree = get_solver_tree()" ] }, { "cell_type": "markdown", "id": "6a26f281", "metadata": {}, "source": [ "❓ What is the parallel kind of the returned tree ?\n", "\n", "```{toggle}\n", "The tree is partitioned. Since the function `get_solver_tree` is private, the only way to answer the question is\n", "to display the tree with {func}`~maia.pytree.print_tree`.\n", "```\n", "\n", "### Extraction\n", "\n", "The first task is to extract a surface mesh from the input volumetric mesh.\n", "As is often the case, the surfaces of the input mesh are flagged with `FamilyName`\n", "nodes to indicate their logical group. Here, we want to extract the airplane surface,\n", "which is referred to as the `Walls` family.\n", "\n", "✏️ Extract a surfacic mesh corresponding to the faces belonging to Walls family" ] }, { "cell_type": "code", "execution_count": null, "id": "85bc94d3", "metadata": { "mystnb": { "code_prompt_hide": "Hide solution", "code_prompt_show": "Show solution" }, "tags": [ "hide-cell" ] }, "outputs": [ { "data": { "text/plain": [ "[stdout:0] Extraction from Family \"Walls\" completed (0.13 s) -- Extracted tree has locally 20.7K faces (Σ=123.4K)\n" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "surf_tree = maia.algo.part.extract_part_from_family(tree, 'Walls', comm)" ] }, { "cell_type": "markdown", "id": "3a42be8c", "metadata": {}, "source": [ "❓ What is the dimension of the returned tree ?\n", "\n", "```{toggle}\n", "The output mesh has a {func}`~maia.pytree.Base.CellDimension` of two, because\n", "we extracted surfacic entities.\n", "Fortunately, several of Maia's functions allow 2D trees to be used as input.\n", "```\n", "\n", "Note that the output tree is still a partioned tree: as you learned in the\n", "{ref}`first tutorial `, functions belonging to `maia.algo` do not change\n", "the parallel nature of trees. In the first tutorial, we used the Transfer module\n", "to bring back data to a distributed tree and save it using {func}`maia.io.dist_tree_to_file`.\n", "\n", "❓ Here, we can no do that. Why ?\n", "\n", "```{toggle}\n", "The extraction function created a new partitioned tree. There is no distributed\n", "tree associated to it.\n", "```\n", "\n", "👉 We can still save the partitioned tree using {func}`maia.io.part_tree_to_file`:" ] }, { "cell_type": "code", "execution_count": null, "id": "7c5c58da", "metadata": {}, "outputs": [], "source": [ "maia.io.part_tree_to_file(surf_tree, 'airplane_walls_part.cgns', comm)" ] }, { "cell_type": "markdown", "id": "8e2533d4", "metadata": {}, "source": [ "However, if you display it with `maia_print_tree` or visualise it, you will notice that\n", "the mesh retains information about parallelism.\n", "This is not satisfactory because we want a unified result that is independent of parallelism.\n", "\n", "Indeed, we need to develop a distributed vision of the partitioned tree — the reverse\n", "of the partitioning process.\n", "\n", "✏️ Use {func}`maia.factory.recover_dist_tree` to rebuild a distributed view of the tree.\n", "Then, write it on the disk.\n", "\n", "*Hint : do not forget to transfer the data fields as well*" ] }, { "cell_type": "code", "execution_count": null, "id": "a0ffed67", "metadata": { "mystnb": { "code_prompt_hide": "Hide solution", "code_prompt_show": "Show solution" }, "tags": [ "hide-cell" ] }, "outputs": [ { "data": { "text/plain": [ "[stdout:0] Distributed write of a 1.5MiB dist_tree (Σ=9.1MiB)...\n", "Write completed [airplane_walls.cgns] (0.72 s)\n" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "dsurf_tree = maia.factory.recover_dist_tree(surf_tree, comm, data_transfer='FIELDS')\n", "maia.io.dist_tree_to_file(dsurf_tree, 'airplane_walls.cgns', comm)" ] }, { "cell_type": "markdown", "id": "cd101ba3", "metadata": {}, "source": [ "```{tip}\n", "Saving partitioned trees is useful mainly for experimentation or debugging purposes,\n", "but it should be avoided in a finalized workflow.\n", "```\n", "\n", "### Slice\n", "\n", "Another family of post processing functionnalities are isosurface and slices functions.\n", "\n", "✏️ Create a plane slice from the equation $y=1$." ] }, { "cell_type": "code", "execution_count": null, "id": "47a474cc", "metadata": { "mystnb": { "code_prompt_hide": "Hide solution", "code_prompt_show": "Show solution" }, "tags": [ "hide-cell" ] }, "outputs": [ { "data": { "text/plain": [ "[stdout:0] Plane slice completed (0.25 s)\n" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "slice_tree = maia.algo.part.plane_slice(tree, [0.,1.,0.,1], comm)" ] }, { "cell_type": "markdown", "id": "a15ffde6", "metadata": {}, "source": [ "❓ Do you have any data fields on the output tree ? If not, modify your\n", "call to the slicing function to ensure that the volumic solution\n", "`FlowSolution#Centers` is transfered on the slice." ] }, { "cell_type": "code", "execution_count": null, "id": "0fb833da", "metadata": { "mystnb": { "code_prompt_hide": "Hide solution", "code_prompt_show": "Show solution" }, "tags": [ "hide-cell" ] }, "outputs": [ { "data": { "text/plain": [ "[stdout:0] Plane slice completed (0.36 s)\n" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "slice_tree = maia.algo.part.plane_slice(tree, [0.,1.,0.,1], comm,\n", " containers_name=['FlowSolution#Centers'])" ] }, { "cell_type": "markdown", "id": "0f49ac38", "metadata": {}, "source": [ "👉️ Then, we save the slice on the disk using the same methodology as above:" ] }, { "cell_type": "code", "execution_count": null, "id": "6b45532f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[stdout:0] Distributed write of a 1.7MiB dist_tree (Σ=10.5MiB)...\n", "Write completed [airplane_slice.cgns] (0.55 s)\n" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "dslice_tree = maia.factory.recover_dist_tree(slice_tree, comm, data_transfer='FIELDS')\n", "maia.io.dist_tree_to_file(dslice_tree, 'airplane_slice.cgns', comm)" ] }, { "cell_type": "code", "execution_count": null, "id": "f5d86033", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [ { "data": { "text/plain": [ "[stdout:0] Distributed write of a 1.2MiB dist_tree (Σ=7.1MiB)...\n", "Write completed [airplane_walls_visu.cgns] (0.43 s)\n", "\u001b[0;34mRank 0: \u001b[0mWarning: Scaling mesh does not affect fields, and some are present in tree. Update their value if needed.\n", "Distributed write of a 1.2MiB dist_tree (Σ=7.1MiB)...\n", "Write completed [airplane_walls_visu2.cgns] (0.44 s)\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "[stdout:1] \u001b[0;34mRank 1: \u001b[0mWarning: Scaling mesh does not affect fields, and some are present in tree. Update their value if needed.\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "[stdout:3] \u001b[0;34mRank 3: \u001b[0mWarning: Scaling mesh does not affect fields, and some are present in tree. Update their value if needed.\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "[stdout:2] \u001b[0;34mRank 2: \u001b[0mWarning: Scaling mesh does not affect fields, and some are present in tree. Update their value if needed.\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "[stdout:4] \u001b[0;34mRank 4: \u001b[0mWarning: Scaling mesh does not affect fields, and some are present in tree. Update their value if needed.\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "[stdout:5] \u001b[0;34mRank 5: \u001b[0mWarning: Scaling mesh does not affect fields, and some are present in tree. Update their value if needed.\n" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Prepare files for visualization : we remove 2D elements from walls\n", "# mesh, because not supported by old vtk versions.\n", "# In addition we create second half of the plane\n", "vtree = PT.deep_copy(dsurf_tree)\n", "maia.algo.dist.reorder_elt_sections_from_dim(vtree, reverse=True)\n", "PT.rm_nodes_from_name(vtree, 'ZoneBC')\n", "PT.rm_nodes_from_name(vtree, 'EdgeElements')\n", "maia.io.dist_tree_to_file(vtree, 'airplane_walls_visu.cgns', comm)\n", "maia.algo.scale_mesh(vtree, [1,-1,1])\n", "maia.io.dist_tree_to_file(vtree, 'airplane_walls_visu2.cgns', comm)" ] }, { "cell_type": "markdown", "id": "da99c368", "metadata": {}, "source": [ "Combining the surfacic extraction and slice, we obtain the following visualization." ] }, { "cell_type": "code", "execution_count": null, "id": "0ab99c06", "metadata": { "tags": [ "remove-input", "no-parallel" ] }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import pyvista as pv\n", "pv.set_jupyter_backend('static')\n", "\n", "plotter = pv.Plotter(off_screen=True)\n", "plotter.camera_position = [\n", " (-1.7057,-4.5868, 2.7434), # Camera Position\n", " ( 2.3915, 0.5035, 0.3620), # Focal Point\n", " ( 0.1865, 0.2892, 0.9389) # View Up\n", "]\n", "plotter.camera.view_angle = 30.0 # View Angle\n", "\n", "reader = pv.CGNSReader(\"airplane_slice.cgns\")\n", "reader.load_boundary_patch = False\n", "mesh_slice = reader.read()\n", "\n", "mesh_surf1 = pv.read(\"airplane_walls_visu.cgns\")\n", "mesh_surf2 = pv.read(\"airplane_walls_visu2.cgns\")\n", "\n", "sargs = dict(title='Density', vertical=True, n_labels=5, title_font_size=20, position_x=0.01, position_y=.525)\n", "plotter.add_mesh(mesh_slice, scalars='Density', cmap='coolwarm', clim=[1.15,1.25], scalar_bar_args=sargs)\n", "sargs = dict(title='Pressure', vertical=False, n_labels=5, fmt='%.2g', title_font_size=20, position_x=0.55, position_y=.02, width=.4, height=.11)\n", "plotter.add_mesh(mesh_surf1, scalars='Pressure', scalar_bar_args=sargs)\n", "plotter.add_mesh(mesh_surf2, scalars='Pressure', show_scalar_bar=False)\n", "\n", "\n", "plotter.add_axes()\n", "plotter.show(window_size=[1200,800])\n", "#img = plotter.screenshot(return_img=True, window_size=[1200,800])" ] }, { "cell_type": "markdown", "id": "f289ed63", "metadata": {}, "source": [ "``` {admonition} Did you notice ?\n", "If you open the surfacic mesh by yourself, you will have only half of the plane.\n", "Can you guess which other function of maia we used to generate this figure ?\n", "```\n", "\n", "\n", "### 1D profile\n", "\n", "In this last step, we are going to update again our slice in order\n", "to plot a one dimensioanl profile $P = f(x)$ around the wing.\n", "\n", "❓ Do you see the pressure array in the slice tree ? Why ?\n", "\n", "```{toggle}\n", "We transfered the volumic fields `FlowSolution#Centers` to the slice, but there is no volumic pressure field\n", "in the input mesh.\n", "All we have is a FaceCenter value of the pressure in the BCDataSet related to the wing.\n", "```\n", "\n", "✏️ As the slice function can only transfer containers of type `FlowSolution_t` or `ZoneSubRegion_t`,\n", "create a container of type `ZoneSubRegion_t` on the volumic tree and move the fields inside it.\n", "\n", "*Hint : you can do it by hand, or using a function of {ref}`maia.pytree `*" ] }, { "cell_type": "code", "execution_count": null, "id": "adbbe825", "metadata": { "mystnb": { "code_prompt_hide": "Hide solution", "code_prompt_show": "Show solution" }, "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "for zone in PT.get_all_Zone_t(tree):\n", " if PT.get_node_from_name_and_label(zone, 'Wing', 'BC_t') is not None:\n", " PT.new_ZoneSubRegion('WingFields', bc_name='Wing', parent=zone)\n", "PT.subregion_fields_from_bcdataset(tree)" ] }, { "cell_type": "markdown", "id": "e6aca2fe", "metadata": {}, "source": [ "️ \n", "✏️ Update (one last time) the slice function call to get the wing pressure field on the computed slice" ] }, { "cell_type": "code", "execution_count": null, "id": "b4111d24", "metadata": { "mystnb": { "code_prompt_hide": "Hide solution", "code_prompt_show": "Show solution" }, "tags": [ "hide-cell" ] }, "outputs": [ { "data": { "text/plain": [ "[stdout:0] Plane slice completed (0.77 s)\n" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "slice_tree = maia.algo.part.plane_slice(tree, [0.,1.,0.,1], comm,\n", " containers_name=['FlowSolution#Centers', 'WingFields'])" ] }, { "cell_type": "markdown", "id": "0df7abe4", "metadata": {}, "source": [ "👉️ You should now have a EdgeCenter pressure field on the slice tree:" ] }, { "cell_type": "code", "execution_count": null, "id": "f1fce9ae", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[stdout:0] \n", " CGNSTree CGNSTree_t \n", " ├───CGNSLibraryVersion CGNSLibraryVersion_t R4 [4.2]\n", " └───Base CGNSBase_t I4 [2 3]\n", " └───Zone.P0.N0 Zone_t I4 [[15847 31192 0]]\n", " ├───ZoneType ZoneType_t \"Unstructured\"\n", " ├───GridCoordinates GridCoordinates_t \n", " │ ╵╴╴╴ (3 children masked)\n", " ├───TRI_3 Elements_t I4 [5 0]\n", " │ ╵╴╴╴ (3 children masked)\n", " ├───BAR_2 Elements_t I4 [3 0]\n", " │ ╵╴╴╴ (3 children masked)\n", " ├───ZoneBC ZoneBC_t \n", " │ ╵╴╴╴ (1 child masked)\n", " ├───:CGNS#GlobalNumbering UserDefinedData_t \n", " │ ╵╴╴╴ (2 children masked)\n", " ├───maia#surface_data UserDefinedData_t \n", " │ ╵╴╴╴ (6 children masked)\n", " ├───FamilyName FamilyName_t \"Unspecified\"\n", " ├───FlowSolution#Centers FlowSolution_t \n", " │ ╵╴╴╴ (6 children masked)\n", " └───WingFields ZoneSubRegion_t \n", " ╵╴╴╴ (7 children masked)\n", "\n" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "if comm.rank == 0:\n", " PT.print_tree(slice_tree, max_depth=3)" ] }, { "cell_type": "markdown", "id": "8763eda7", "metadata": {}, "source": [ "```{note}\n", "If you launch the script in parallel, only the processes touching the wing `BC_t` on the slice have\n", "the `ZoneSubRegion_t` node (as for the volumic tree).\n", "```\n", "\n", "✏️ We have a EdgeCenter located pressure, we need a EdgeCenter located position to plot the profile.\n", "Compute the centers of the edges on `slice_tree` using {func}`maia.algo.compute_elements_center`." ] }, { "cell_type": "code", "execution_count": null, "id": "7d4b9073", "metadata": { "mystnb": { "code_prompt_hide": "Hide solution", "code_prompt_show": "Show solution" }, "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "maia.algo.compute_elements_center(slice_tree, 1, comm)" ] }, { "cell_type": "markdown", "id": "400332f4", "metadata": {}, "source": [ "Now starts the difficult part: we have the center of all edges, but the pressure is\n", "defined only for edges belonging the `BC_t` subset `Wing`.\n", "Thus, we need to extract the center for edges in the `Wing` subset.\n", "The steps to do it are:\n", "\n", "- get the component X of the computed edges center (computed for all edges)\n", "- get the list of edges indices belonging to the Wing subset, ie the `PointList` of the `BC_t`\n", " or of the related `ZoneSubRegion_t` node (the two should be equal)\n", "- use these indices to extract X centers (be careful, the indices must be shifted to start at 0)\n", "\n", "\n", "```{attention}\n", "Keep in mind that some ranks may not know the Wing subset at all.\n", "For these ranks, empty arrays must be created.\n", "This is the main pitfall of working with partitioned meshes.\n", "```\n", "\n", "✏️ Implement the above strategy to compute the `x` and `pressure` arrays on each rank." ] }, { "cell_type": "code", "execution_count": null, "id": "167b492a", "metadata": { "mystnb": { "code_prompt_hide": "Hide solution", "code_prompt_show": "Show solution" }, "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "import numpy as np\n", "zsr_n = PT.get_node_from_name(slice_tree, 'WingFields')\n", "if zsr_n is not None:\n", " # Get X component of computed edge centers\n", " center_x = PT.get_value(PT.get_node_from_name(slice_tree, 'CenterX'))\n", " # Get edges ids belonging to Wing subset\n", " edge_ids = PT.get_np_value(PT.get_child_from_name(zsr_n, 'PointList'))[0]\n", " # Get edge offset\n", " edge_n = PT.get_node_from_predicate(slice_tree, PT.pred.is_element_of_type('BAR_2'))\n", " offset = PT.Element.Range(edge_n)[0]\n", " # Extract x values, and get pressure field\n", " x = center_x[edge_ids - offset]\n", " pressure = PT.get_value(PT.get_child_from_name(zsr_n, 'Pressure'))\n", "else:\n", " # Create empty array for ranks not related to the Wing subset\n", " x = np.empty(0, dtype=np.float64)\n", " pressure = np.empty(0, dtype=np.float64)" ] }, { "cell_type": "markdown", "id": "c06e82d6", "metadata": {}, "source": [ "👉️ Then, you can use the following function to plot the $P=f(x)$ profile:" ] }, { "cell_type": "code", "execution_count": null, "id": "ddec4c04", "metadata": {}, "outputs": [], "source": [ "plot_1d_profile(x, pressure, comm)" ] }, { "cell_type": "markdown", "id": "71c7c2b1", "metadata": {}, "source": [ "```{raw} html\n", "\n", "```\n", "\n", "This ends the first part of this tutorial 🏁 !\n", "\n", "We explored some of maia's postprocessing capabilities to produce results of interest\n", "in a parallel context. We even started to manipulated partitioned meshes by hand. \n", "The final script should now look like this: {download}`04_post_final.py`.\n", "\n", "The next section will take us a step further: we will manipulate partitioned trees more\n", "directly and implement some of the missing pieces ourselves.\n", "\n", "## Advanced partitioned algorithms\n", "\n", "🏗️ Under construction" ] } ], "metadata": { "jupytext": { "text_representation": { "format_name": "myst" } }, "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "myst_html_secnum_depth": 0 }, "nbformat": 4, "nbformat_minor": 5 }