Mesh splitting and selection

examples/01-Detailed-Examples/05-mesh-exploration.py

@@ -0,0 +1,203 @@
+"""
+.. _ref_mesh_exploration_example:
+
+Explore the mesh
+================
+In this script a static simulation is used as an example to show how to
+query mesh information such as connectivity, element IDs, element types and so on.
+"""
+
+###############################################################################
+# Perform required imports
+# ------------------------
+# Perform required imports. # This example uses a supplied file that you can
+# get by importing the DPF ``examples`` package.
+
+from ansys.dpf import post
+from ansys.dpf.post import examples
+from ansys.dpf.post.common import elemental_properties
+
+###############################################################################
+# Get ``Simulation`` object
+# -------------------------
+# Get the ``Simulation`` object that allows access to the result. The ``Simulation``
+# object must be instantiated with the path for the result file. For example,
+# ``"C:/Users/user/my_result.rst"`` on Windows or ``"/home/user/my_result.rst"``
+# on Linux.
+
+example_path = examples.download_all_kinds_of_complexity()
+simulation = post.StaticMechanicalSimulation(example_path)
+
+# print the simulation to get an overview of what's available
+print(simulation)
+
+###############################################################################
+# Get the mesh
+# ------------
+
+# Retrieve the actual mesh
+mesh = simulation.mesh
+
+###############################################################################
+# Query basic information about the mesh
+# --------------------------------------
+
+# Node IDs
+n_ids = mesh.node_ids
+
+# Element IDs
+e_ids = mesh.element_ids
+
+# Available named selection names
+named_selections = mesh.named_selections.keys()
+
+# Number of nodes
+n_nodes = mesh.num_nodes
+
+# Number of elements
+n_elements = mesh.num_elements
+
+# Number of named selections
+n_ns = len(named_selections)
+
+# Unit (get and set)
+mesh_unit = mesh.unit
+mesh.unit = "mm"
+
+print(n_ids)
+print(e_ids)
+print(named_selections)
+print(n_nodes)
+print(n_elements)
+
+###############################################################################
+# Get Named Selections
+# --------------------
+ns_list = mesh.named_selections.keys()
+first_key = ns_list[0]
+named_selection = mesh.named_selections[first_key]
+
+for k in mesh.named_selections.keys():
+    print(k)
+for v in mesh.named_selections.values():
+    print(v)
+for k, v in mesh.named_selections.items():
+    print(f"{k} = {v}")
+
+###############################################################################
+# Get elements
+# ------------
+
+# Get an element by ID
+el_by_id = mesh.elements.by_id[1]
+
+# Get an element by index
+index = el_by_id.index
+print(mesh.elements[index])
+
+###############################################################################
+# Element Types and Materials
+# ---------------------------
+
+# Get the element types
+el_types = mesh.element_types
+print(el_types)
+
+# Get the materials
+e_materials = mesh.materials
+print(e_materials)
+
+###############################################################################
+# Query information about one particular element
+# ----------------------------------------------
+
+# Get the nodes of an element
+elem_0_nodes = mesh.elements[0].nodes
+
+# Get the node IDs of an element
+elem_0_nodes_ids = mesh.elements[0].node_ids
+
+# Get the number of nodes of an element
+num_nodes_elem_0 = mesh.elements[0].num_nodes
+
+# Get the type of the element
+elem_0_type_info = mesh.elements[0].type_info
+elem_0_type = mesh.elements[0].type
+
+# Get the shape of the element
+elem_0_shape = mesh.elements[0].shape
+
+###############################################################################
+# Get the elemental connectivity
+# ------------------------------
+
+# get node indices from element index
+conn1 = mesh.element_to_node_connectivity
+
+# get node IDs from element index
+conn2 = mesh.element_to_node_ids_connectivity
+
+el_idx_5 = mesh.elements[5]
+# get node IDS from element ID
+node_ids = conn2.by_id[el_idx_5.id]
+
+###############################################################################
+# Get nodes
+# ---------
+
+# Get a node by ID
+node_by_id = mesh.nodes.by_id[1]
+
+# Get a node by index
+node_by_index = mesh.nodes[0]
+
+# Get the coordinates of all nodes
+print(mesh.coordinates)
+
+###############################################################################
+# Query information about one particular node
+# -------------------------------------------
+
+# Coordinates
+node_1 = mesh.nodes[1].coordinates
+
+# Get Nodal connectivity
+conn3 = mesh.node_to_element_connectivity
+conn4 = mesh.node_to_element_ids_connectivity
+
+print(mesh.nodes[0])
+
+# elements indices to elem_id
+print(conn3[0])
+
+# elements IDs from node index
+print(conn4[0])
+
+###############################################################################
+# Splitting into meshes
+# ---------------------
+
+# Plot the mesh
+mesh.plot()
+
+# Split the global mesh according to mesh properties
+meshes = simulation.split_mesh_by_properties(
+    properties=[elemental_properties.material, elemental_properties.element_shape]
+)
+meshes.plot()
+
+# Split the global mesh and select meshes for specific property values
+print(meshes)
+meshes = simulation.split_mesh_by_properties(
+    properties={
+        elemental_properties.material: 1,
+        elemental_properties.element_shape: [0, 1],
+    }
+)
+
+meshes.plot()
+
+# Select a specific Mesh in the Meshes, by index
+meshes[0].plot()
+# or by property values
+meshes[{"mat": 1, "elshape": 0}].plot()

src/ansys/dpf/post/__init__.py

@@ -33,6 +33,8 @@
 from ansys.dpf.post.harmonic_mechanical_simulation import (  # noqa: F401
     HarmonicMechanicalSimulation,
 )
+from ansys.dpf.post.mesh import Mesh  # noqa: F401
+from ansys.dpf.post.meshes import Meshes  # noqa: F401
 from ansys.dpf.post.misc import Report
 from ansys.dpf.post.modal_mechanical_simulation import (  # noqa: F401
     ModalMechanicalSimulation,

src/ansys/dpf/post/common.py

@@ -4,6 +4,9 @@
 ------
 
 """
+from ansys.dpf.core.common import (  # noqa: F401  # pylint: disable=W0611
+    elemental_properties,
+)
 
 from ansys.dpf.post.fluid_simulation import FluidSimulation
 from ansys.dpf.post.harmonic_mechanical_simulation import HarmonicMechanicalSimulation

src/ansys/dpf/post/connectivity.py

@@ -0,0 +1,145 @@
+"""Module containing wrapper class for the connectivities property fields."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from enum import Enum
+from typing import List
+
+from ansys.dpf.core.property_field import PropertyField
+from ansys.dpf.core.scoping import Scoping
+
+
+class ReturnMode(Enum):
+    """Enum made for internal use, to dictate the behavior of _ConnectivityList."""
+
+    IDS = 1
+    IDX = 2
+
+
+class _ConnectivityList(ABC):
+    """Abstract class for ConnectivityList objects."""
+
+    def __init__(
+        self,
+        field: PropertyField,
+        mode: ReturnMode,
+        scoping: Scoping,
+    ):
+        """Constructs a _ConnectivityList by wrapping the given PropertyField.
+
+        Arguments:
+        ---------
+        field:
+            Field of connectivity.
+        mode:
+            Whether to return indexes or IDs.
+        scoping:
+            Element or node scoping to map returned indexes to IDs.
+        """
+        self._field = field
+        if mode not in [ReturnMode.IDS, ReturnMode.IDX]:
+            raise ValueError("'mode' argument must be a valid ReturnMode value")
+        self._mode = mode
+        self._scoping = scoping
+        self._idx = 0
+        self.local_scoping = None
+
+    def __next__(self) -> List[int]:
+        """Returns the next element in the list."""
+        if self._idx >= len(self):
+            raise StopIteration
+        out = self.__getitem__(self._idx)
+        self._idx += 1
+        return out
+
+    def __getitem__(self, idx: int) -> List[int]:
+        """Returns, for a given entity index, the connected indexes or IDs (see ReturnMode)."""
+        if self._mode == ReturnMode.IDS:
+            return self._get_ids_from_idx(idx)
+        elif self._mode == ReturnMode.IDX:
+            return self._get_idx_from_idx(idx)
+
+    def __len__(self) -> int:
+        """Returns the number of entities."""
+        return self._field.scoping.size
+
+    def __repr__(self) -> str:
+        """Returns string representation of a _ConnectivityList object."""
+        return f"{self.__class__.__name__}({self.__str__()}, __len__={self.__len__()})"
+
+    def _short_list(self) -> str:
+        _str = "["
+        if self.__len__() > 3:
+            _fst = self._field.get_entity_data(0)
+            _lst = self._field.get_entity_data(self.__len__() - 1)
+            if self._mode == ReturnMode.IDS:
+                _fst = self._to_ids(_fst)
+                _lst = self._to_ids(_lst)
+            _str += f"{_fst}, ..., {_lst}"
+        else:
+            conn_list = [
+                self._field.get_entity_data(idx) for idx in range(self.__len__())
+            ]
+            if self._mode == ReturnMode.IDS:
+                conn_list = list(map(self._to_ids, conn_list))
+            _str += ", ".join(map(str, conn_list))
+        _str += "]"
+        return _str
+
+    def __str__(self) -> str:
+        """Returns string representation of a _ConnectivityList object."""
+        return self._short_list()
+
+    def _get_ids_from_idx(self, idx: int) -> List[int]:
+        """Helper method to retrieve list of IDs from a given index."""
+        return self._to_ids(self._get_idx_from_idx(idx))
+
+    def _get_idx_from_idx(self, idx: int) -> List[int]:
+        """Helper method to retrieve list of indexes from a given index."""
+        return self._field.get_entity_data(idx).tolist()
+
+    def _to_ids(self, indices) -> List[int]:
+        """Helper method to convert a list of indexes into a list of IDs."""
+        if not self.local_scoping:
+            self.local_scoping = self._scoping.as_local_scoping()
+
+        to_id = self.local_scoping.id
+        return list(map(to_id, indices))
+
+    @abstractmethod
+    def __iter__(self):  # pragma: no cover
+        """Returns the object to iterate on."""
+
+
+class ConnectivityListByIndex(_ConnectivityList):
+    """Connectivity list object using indexes as input."""
+
+    @property
+    def by_id(self) -> ConnectivityListById:
+        """Returns an equivalent list which accepts IDs as input."""
+        return ConnectivityListById(
+            field=self._field, mode=self._mode, scoping=self._scoping
+        )
+
+    def __iter__(self) -> ConnectivityListByIndex:
+        """Returns the object to iterate on."""
+        self._idx = 0
+        return self
+
+
+class ConnectivityListById(_ConnectivityList):
+    """Connectivity list object using IDs as input."""
+
+    def __getitem__(self, id: int) -> List[int]:  # pylint: disable=redefined-builtin
+        """Returns, for a given entity ID, the connected indexes or IDs (see ReturnMode)."""
+        idx = self._field.scoping.index(id)
+        return super().__getitem__(idx)
+
+    def __iter__(self) -> ConnectivityListByIndex:
+        """Returns the object to iterate on."""
+        return ConnectivityListByIndex(
+            field=self._field,
+            mode=self._mode,
+            scoping=self._scoping,
+        )