Split a mesh#

MAPDL LSDYNA Fluent CFX

This tutorial shows how to split a mesh on a given property.

There are two approaches to accomplish this goal:

Download tutorial as Python script Download tutorial as Jupyter notebook

Define the mesh#

The mesh object in DPF is a MeshedRegion. You can obtain a MeshedRegion by creating your own from scratch or by getting it from a result file. For more information check the Create a mesh from scratch and Get a mesh from a result file tutorials.

For this tutorial, we get a MeshedRegion from a result file. You can use one available in the Examples module. For more information see the Get a mesh from a result file tutorial.

# Import the ``ansys.dpf.core`` module
from ansys.dpf import core as dpf
# Import the examples module
from ansys.dpf.core import examples
# Import the operators module
from ansys.dpf.core import operators as ops

# Define the result file path
result_file_path_1 = examples.find_multishells_rst()
# Create the model
model_1 = dpf.Model(data_sources=result_file_path_1)
# Get the mesh
meshed_region_1 = model_1.metadata.meshed_region

# Import the ``ansys.dpf.core`` module
from ansys.dpf import core as dpf
# Import the examples module
from ansys.dpf.core import examples
# Import the operators module
from ansys.dpf.core import operators as ops

# Define the result file path
result_file_path_2 = examples.download_d3plot_beam()
# Create the DataSources object
ds_2 = dpf.DataSources()
ds_2.set_result_file_path(filepath=result_file_path_2[0], key="d3plot")
ds_2.add_file_path(filepath=result_file_path_2[3], key="actunits")
# Create the model
model_2 = dpf.Model(data_sources=ds_2)
# Get the mesh
meshed_region_2 = model_2.metadata.meshed_region

# Import the ``ansys.dpf.core`` module
from ansys.dpf import core as dpf
# Import the examples module
from ansys.dpf.core import examples
# Import the operators module
from ansys.dpf.core import operators as ops

# Define the result file path
result_file_path_3 = examples.download_fluent_axial_comp()["flprj"]
# Create the model
model_3 = dpf.Model(data_sources=result_file_path_3)
# Get the mesh
meshed_region_3 = model_3.metadata.meshed_region

# Import the ``ansys.dpf.core`` module
from ansys.dpf import core as dpf
# Import the examples module
from ansys.dpf.core import examples
# Import the operators module
from ansys.dpf.core import operators as ops

# Define the result file path
result_file_path_4 = examples.download_cfx_mixing_elbow()
# Create the model
model_4 = dpf.Model(data_sources=result_file_path_4)
# Get the mesh
meshed_region_4 = model_4.metadata.meshed_region

First approach#

This approach consists in splitting an already existing MeshedRegion based on a given property. To accomplish that end, you must use the split_mesh operator. Currently you can split a mesh by material or eltype.

The split mesh parts are stored in the DPF collection called MeshesContainer, where they are ordered by labels. When you use the split_mesh operator, each split mesh part has two different labels:

  • A “body” label

  • A label with the property used to split the mesh

Here, we split the MeshedRegion by material.

# Split the mesh by material
meshes_11 = ops.mesh.split_mesh(mesh=meshed_region_1, property="mat").eval()

# Print the meshes
print(meshes_11)

DPF  Meshes Container
  with 12 mesh(es)
  defined on labels: body mat 

  with:
  - mesh 0 {mat:  2, body:  1, } with 5072 nodes and 3086 elements.
  - mesh 1 {mat:  3, body:  2, } with 135 nodes and 112 elements.
  - mesh 2 {mat:  5, body:  3, } with 104 nodes and 34 elements.
  - mesh 3 {mat:  7, body:  4, } with 218 nodes and 105 elements.
  - mesh 4 {mat:  11, body:  5, } with 71 nodes and 22 elements.
  - mesh 5 {mat:  4, body:  6, } with 90 nodes and 70 elements.
  - mesh 6 {mat:  6, body:  7, } with 104 nodes and 34 elements.
  - mesh 7 {mat:  8, body:  8, } with 218 nodes and 105 elements.
  - mesh 8 {mat:  12, body:  9, } with 71 nodes and 22 elements.
  - mesh 9 {mat:  9, body:  10, } with 327 nodes and 165 elements.
  - mesh 10 {mat:  1, body:  11, } with 1782 nodes and 300 elements.
  - mesh 11 {mat:  10, body:  12, } with 327 nodes and 165 elements.


# Split the mesh by material
meshes_21 = ops.mesh.split_mesh(mesh=meshed_region_2, property="mat").eval()

# Print the meshes
print(meshes_21)

DPF  Meshes Container
  with 2 mesh(es)
  defined on labels: body mat 

  with:
  - mesh 0 {mat:  2, body:  1, } with 1651 nodes and 1512 elements.
  - mesh 1 {mat:  1, body:  2, } with 289 nodes and 544 elements.


# Split the mesh by material
meshes_31 = ops.mesh.split_mesh(mesh=meshed_region_3, property="mat").eval()

# Print the meshes
print(meshes_31)

DPF  Meshes Container
  with 1 mesh(es)
  defined on labels: body mat 

  with:
  - mesh 0 {mat:  -1, body:  1, } with 16660 nodes and 13856 elements.


# Split the mesh by material
meshes_41 = ops.mesh.split_mesh(mesh=meshed_region_4, property="mat").eval()
# Print the meshes
print(meshes_41)

DPF  Meshes Container
  with 1 mesh(es)
  defined on labels: body mat 

  with:
  - mesh 0 {mat:  -1, body:  1, } with 6219 nodes and 15695 elements.

Second approach#

This approach consists in splitting the Scoping of a given MeshedRegion based on a given property and then creating a new MeshedRegion for each split Scoping.

To accomplish this goal you must follow these steps:

  1. Use the split_on_property_type operator to split the mesh Scoping.

    This operator splits a Scoping on a given property (elshape and/or material, since 2025R1 it supports any scalar property field name contained in the mesh property fields). The split Scoping is stored in the DPF collection called ScopingsContainer, where they are ordered by labels. In this case, you get labels with the property used to split the Scoping.

  2. Create the split MeshedRegion objects using the from_scopings operator for the Scoping of interest.

    The split parts are stored in the DPF collection called MeshesContainer where they are also ordered by labels. These labels are corresponding to the “mat” labels gotten with the split_on_property_type operator.

Here, we split the mesh scoping by material and create a MeshedRegion for all the split Scoping in the ScopingsContainer.

# Define the scoping split by material
split_scoping_1 = ops.scoping.split_on_property_type(mesh=meshed_region_1, label1="mat").eval()
# Get the split meshes
meshes_12 = ops.mesh.from_scopings(scopings_container=split_scoping_1, mesh=meshed_region_1).eval()
# Print the meshes
print(meshes_12)

DPF  Meshes Container
  with 12 mesh(es)
  defined on labels: mat 

  with:
  - mesh 0 {mat:  2, } with 5072 nodes and 3086 elements.
  - mesh 1 {mat:  3, } with 135 nodes and 112 elements.
  - mesh 2 {mat:  5, } with 104 nodes and 34 elements.
  - mesh 3 {mat:  7, } with 218 nodes and 105 elements.
  - mesh 4 {mat:  11, } with 71 nodes and 22 elements.
  - mesh 5 {mat:  4, } with 90 nodes and 70 elements.
  - mesh 6 {mat:  6, } with 104 nodes and 34 elements.
  - mesh 7 {mat:  8, } with 218 nodes and 105 elements.
  - mesh 8 {mat:  12, } with 71 nodes and 22 elements.
  - mesh 9 {mat:  9, } with 327 nodes and 165 elements.
  - mesh 10 {mat:  1, } with 1782 nodes and 300 elements.
  - mesh 11 {mat:  10, } with 327 nodes and 165 elements.


# Define the scoping split by material
split_scoping_2 = ops.scoping.split_on_property_type(mesh=meshed_region_2, label1="mat").eval()
# Get the split meshes
meshes_22 = ops.mesh.from_scopings(scopings_container=split_scoping_2, mesh=meshed_region_2).eval()
# Print the meshes
print(meshes_22)

DPF  Meshes Container
  with 2 mesh(es)
  defined on labels: mat 

  with:
  - mesh 0 {mat:  2, } with 1651 nodes and 1512 elements.
  - mesh 1 {mat:  1, } with 289 nodes and 544 elements.


# Define the scoping split by material
split_scoping_3 = ops.scoping.split_on_property_type(mesh=meshed_region_3, label1="mat").eval()
# Get the split meshes
meshes_32 = ops.mesh.from_scopings(scopings_container=split_scoping_3, mesh=meshed_region_3).eval()
# Print the meshes
print(meshes_32)

DPF  Meshes Container
  with 1 mesh(es)
  defined on labels: mat 

  with:
  - mesh 0 {mat:  -1, } with 16660 nodes and 13856 elements.


# Define the scoping split by material
split_scoping_4 = ops.scoping.split_on_property_type(mesh=meshed_region_4, label1="mat").eval()
# Get the split meshes
meshes_42 = ops.mesh.from_scopings(scopings_container=split_scoping_4, mesh=meshed_region_4).eval()
# Print the meshes
print(meshes_42)

DPF  Meshes Container
  with 1 mesh(es)
  defined on labels: mat 

  with:
  - mesh 0 {mat:  -1, } with 6219 nodes and 15695 elements.