Modifying Meshes ¶

Table of contents

Split Volumes into Tetrahedra ¶

# Split volumic elements into tetrahedrons

import salome
salome.salome_init_without_session()

from salome.geom import geomBuilder
from salome.smesh import smeshBuilder

geom_builder = geomBuilder.New()
smesh_builder = smeshBuilder.New()

# mesh a hexahedral mesh
box = geom_builder.MakeBoxDXDYDZ (1, 1, 1 )
mesh = smesh_builder.Mesh( box )
mesh.AutomaticHexahedralization(0)
print("Nb volumes mesh: %s" % mesh.NbHexas())

# split each hexahedron into 6 tetrahedra
mesh.SplitVolumesIntoTetra( mesh, smesh_builder.Hex_6Tet )
print("Nb volumes mesh: %s" % mesh.NbTetras())

Download this script

Convert mesh to/from quadratic ¶

# Convert mesh to/from quadratic

import salome
salome.salome_init_without_session()

from salome.geom import geomBuilder
from salome.smesh import smeshBuilder

geom_builder = geomBuilder.New()
smesh_builder = smeshBuilder.New()

# create sphere of radius 100

Sphere = geom_builder.MakeSphereR( 100 )
geom_builder.addToStudy( Sphere, "Sphere" )

# create simple tetrahedral mesh

Mesh = smesh_builder.Mesh(Sphere)
Mesh.Segment().NumberOfSegments(5)
Mesh.Triangle()
Mesh.Tetrahedron()

# compute mesh

if not Mesh.Compute(): raise Exception("Error when computing Mesh")

# convert to quadratic
# theForce3d = 1; this results in the medium node lying at the
# middle of the line segments connecting start and end node of a mesh
# element

Mesh.ConvertToQuadratic( theForce3d=1 )

# revert back to the non-quadratic mesh

Mesh.ConvertFromQuadratic()

# convert to quadratic
# theForce3d = 0; this results in the medium node lying at the
# geometrical edge from which the mesh element is built

Mesh.ConvertToQuadratic( theForce3d=0 )

# to convert not the whole mesh but a sub-mesh, provide it as 
# an additional argument to the functions:
# Mesh.ConvertToQuadratic( 0, subMesh )
# Mesh.ConvertFromQuadratic( subMesh )
#
# Note that the mesh becomes non-conformal at conversion of sub-mesh.

Download this script

Split bi-quadratic into linear ¶

# Split bi-quadratic to linear

import salome
salome.salome_init_without_session()

from salome.geom import geomBuilder
from salome.smesh import smeshBuilder

geom_builder = geomBuilder.New()
smesh_builder = smeshBuilder.New()

# make a shape consisting of two quadranges
OY  = geom_builder.MakeVectorDXDYDZ(0, 1, 0)
OY1 = geom_builder.MakeTranslation( OY, 1, 0, 0 )
OY2 = geom_builder.MakeTranslation( OY, 2, 0, 0 )
q1  = geom_builder.MakeQuad2Edges( OY, OY1 )
q2  = geom_builder.MakeQuad2Edges( OY1, OY2 )

shape = geom_builder.Partition( [q1,q2], theName='shape' )
ff    = geom_builder.SubShapeAll( shape, geom_builder.ShapeType["FACE"], theName="quad" )

# mesh one quadrange with quadrangless and the other with triangles
mesh = smesh_builder.Mesh( shape )
mesh.Segment().NumberOfSegments(1)
mesh.Quadrangle()
mesh.Triangle( ff[1] )
if not mesh.Compute(): raise Exception("Error when computing Mesh")

# make group of quadrangles and extrude them into a hexahedron
quadGroup = mesh.Group( ff[0], "quads")
mesh.ExtrusionSweepObject2D( quadGroup, [0,0,1], 1 )

# make the mesh bi-quadratic
mesh.ConvertToQuadratic( theToBiQuad=True )

# split all elements into linear ones
mesh.SplitBiQuadraticIntoLinear()

Download this script

Double nodes on groups boundaries ¶

Double nodes on shared faces between groups of volumes and create flat elements on demand.

The list of groups must contain at least two groups. The groups have to be disjoint: no common element into two different groups.

The nodes of the internal faces at the boundaries of the groups are doubled. Optionally, the internal faces are replaced by flat elements.

Triangles are transformed into prisms, and quadrangles into hexahedrons.

The flat elements are stored in groups of volumes.

These groups are named according to the position of the group in the list: the group j_n_p is the group of the flat elements that are built between the group #n and the group #p in the list. If there is no shared faces between the group #n and the group #p in the list, the group j_n_p is not created. All the flat elements are gathered into the group named “joints3D” (or “joints2D” in 2D situation). The flat element of the multiple junctions between the simple junction are stored in a group named “jointsMultiples”.

This example represents an iron cable (a thin cylinder) in a concrete block (a big cylinder). The big cylinder is defined by two geometric volumes.

# Double nodes on groups boundaries

# This example represents an iron cable (a thin cylinder) in a concrete block (a big cylinder).
# The big cylinder is defined by two geometric volumes.

import salome
salome.salome_init_without_session()

import GEOM
import SMESH
from salome.geom import geomBuilder
from salome.smesh import smeshBuilder

geom_builder = geomBuilder.New()
smesh_builder = smeshBuilder.New()

# geometry 

O = geom_builder.MakeVertex(0, 0, 0)
OX = geom_builder.MakeVectorDXDYDZ(1, 0, 0)
OY = geom_builder.MakeVectorDXDYDZ(0, 1, 0)
OZ = geom_builder.MakeVectorDXDYDZ(0, 0, 1)
Vertex_1 = geom_builder.MakeVertex(50, 0, 0)
Cylinder_1 = geom_builder.MakeCylinder(O, OX, 10, 500)
Cylinder_2 = geom_builder.MakeCylinder(Vertex_1, OX, 100, 400)
Vertex_2 = geom_builder.MakeVertex(-200, -200, -200)
Vertex_3 = geom_builder.MakeVertex(250, 200, 200)
Box_1 = geom_builder.MakeBoxTwoPnt(Vertex_2, Vertex_3)
Fuse_1 = geom_builder.MakeFuse(Cylinder_1, Cylinder_2)
Partition_1 = geom_builder.MakePartition([Fuse_1], [Cylinder_1, Box_1], [], [], geom_builder.ShapeType["SOLID"], 0, [], 0)
[Solid_1,Solid_2] = geom_builder.GetShapesOnShape(Cylinder_1, Partition_1, geom_builder.ShapeType["SOLID"], GEOM.ST_IN)
[Solid_3,Solid_4] = geom_builder.GetShapesOnShape(Cylinder_2, Partition_1, geom_builder.ShapeType["SOLID"], GEOM.ST_IN)
Vertex_4 = geom_builder.MakeVertex(450, 0, 0)
Vertex_5 = geom_builder.MakeVertex(500, 0, 0)
Vertex_6 = geom_builder.MakeVertex(550, 0, 0)
vec1 = geom_builder.MakeVector(Vertex_4, Vertex_5)
vec2 = geom_builder.MakeVector(Vertex_5, Vertex_6)
[Face_1] = geom_builder.GetShapesOnPlane(Partition_1, geom_builder.ShapeType["FACE"], vec1, GEOM.ST_ON)
[Face_2] = geom_builder.GetShapesOnPlane(Partition_1, geom_builder.ShapeType["FACE"], vec2, GEOM.ST_ON)

# meshing (we have linear tetrahedrons here, but other elements are OK)

Mesh_1 = smesh_builder.Mesh(Partition_1)
Mesh_1.Segment().NumberOfSegments(15)
Mesh_1.Triangle().LengthFromEdges()
Mesh_1.Tetrahedron()
if not Mesh_1.Compute(): raise Exception("Error when computing Mesh")

# relevant groups of volumes and faces

Solid_1_1 = Mesh_1.GroupOnGeom(Solid_1,'Solid_1',SMESH.VOLUME)
Solid_2_1 = Mesh_1.GroupOnGeom(Solid_2,'Solid_2',SMESH.VOLUME)
Solid_3_1 = Mesh_1.GroupOnGeom(Solid_3,'Solid_3',SMESH.VOLUME)
Solid_4_1 = Mesh_1.GroupOnGeom(Solid_4,'Solid_4',SMESH.VOLUME)
Face_1_1 = Mesh_1.GroupOnGeom(Face_1,'Face_1',SMESH.FACE)
Face_2_1 = Mesh_1.GroupOnGeom(Face_2,'Face_2',SMESH.FACE)

# Building of flat elements

Mesh_1.DoubleNodesOnGroupBoundaries([Solid_1_1, Solid_2_1, Solid_3_1, Solid_4_1], 1)

Mesh_1.CreateFlatElementsOnFacesGroups([Face_1_1, Face_2_1])

Download this script

Here, the 4 groups of volumes [Solid_1_1, Solid_2_1, Solid_3_1, Solid_4_1] constitute a partition of the mesh. The flat elements on group boundaries and on faces are built with the 2 last lines of the code above.

If the last argument (Boolean) in DoubleNodesOnGroupBoundaries is set to 1, the flat elements are built, otherwise, there is only a duplication of the nodes.

To observe flat element groups, save the resulting mesh on a MED file and reload it.

Modifying Meshes ¶

Adding Nodes and Elements ¶

Add Node ¶

Add 0D Element ¶

Add 0D Element on Element Nodes ¶

Add Edge ¶

Add Triangle ¶

Add Quadrangle ¶

Add Tetrahedron ¶

Add Hexahedron ¶

Add Polygon ¶

Add Polyhedron ¶

Removing Nodes and Elements ¶

Removing Nodes ¶

Removing Elements ¶

Removing Orphan Nodes ¶

Moving Nodes ¶

Diagonal Inversion ¶

Uniting two Triangles ¶

Uniting a Set of Triangles ¶

Orientation ¶

Cutting Quadrangles ¶

Cutting Triangles ¶

Split Volumes into Tetrahedra ¶

Smoothing ¶

Extrusion ¶

Extrusion along a Path ¶

Revolution ¶

Pattern Mapping ¶

Convert mesh to/from quadratic ¶

Split bi-quadratic into linear ¶

Double nodes on groups boundaries ¶