1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
# -----------------------------------------------------------------------------
#
# Gmsh Python extended tutorial 1
#
# Geometry and mesh data
#
# -----------------------------------------------------------------------------
# The Python API allows to do much more than what can be done in .geo
# files. These additional features are introduced gradually in the extended
# tutorials, starting with `x1.py'.
# In this first extended tutorial, we start by using the API to access basic
# geometrical and mesh data.
import gmsh
import sys
gmsh.initialize()
if len(sys.argv) > 1 and sys.argv[1][0] != '-':
# If an argument is provided, handle it as a file that Gmsh can read, e.g. a
# mesh file in the MSH format (`python x1.py file.msh')
gmsh.open(sys.argv[1])
else:
# Otherwise, create and mesh a simple geometry
gmsh.model.occ.addCone(1, 0, 0, 1, 0, 0, 0.5, 0.1)
gmsh.model.occ.synchronize()
gmsh.model.mesh.generate()
# Print the model name and dimension:
print('Model ' + gmsh.model.getCurrent() + ' (' +
str(gmsh.model.getDimension()) + 'D)')
# Geometrical data is made of elementary model `entities', called `points'
# (entities of dimension 0), `curves' (entities of dimension 1), `surfaces'
# (entities of dimension 2) and `volumes' (entities of dimension 3). As we have
# seen in the other Python tutorials, elementary model entities are identified
# by their dimension and by a `tag': a strictly positive identification
# number. Model entities can be either CAD entities (from the built-in `geo'
# kernel or from the OpenCASCADE `occ' kernel) or `discrete' entities (defined
# by a mesh). `Physical groups' are collections of model entities and are also
# identified by their dimension and by a tag.
# Get all the elementary entities in the model, as a vector of (dimension, tag)
# pairs:
entities = gmsh.model.getEntities()
for e in entities:
# Dimension and tag of the entity:
dim = e[0]
tag = e[1]
# Mesh data is made of `elements' (points, lines, triangles, ...), defined
# by an ordered list of their `nodes'. Elements and nodes are identified by
# `tags' as well (strictly positive identification numbers), and are stored
# ("classified") in the model entity they discretize. Tags for elements and
# nodes are globally unique (and not only per dimension, like entities).
# A model entity of dimension 0 (a geometrical point) will contain a mesh
# element of type point, as well as a mesh node. A model curve will contain
# line elements as well as its interior nodes, while its boundary nodes will
# be stored in the bounding model points. A model surface will contain
# triangular and/or quadrangular elements and all the nodes not classified
# on its boundary or on its embedded entities. A model volume will contain
# tetrahedra, hexahedra, etc. and all the nodes not classified on its
# boundary or on its embedded entities.
# Get the mesh nodes for the entity (dim, tag):
nodeTags, nodeCoords, nodeParams = gmsh.model.mesh.getNodes(dim, tag)
# Get the mesh elements for the entity (dim, tag):
elemTypes, elemTags, elemNodeTags = gmsh.model.mesh.getElements(dim, tag)
# Elements can also be obtained by type, by using `getElementTypes()'
# followed by `getElementsByType()'.
# Let's print a summary of the information available on the entity and its
# mesh.
# * Type and name of the entity:
type = gmsh.model.getType(dim, tag)
name = gmsh.model.getEntityName(dim, tag)
if len(name): name += ' '
print("Entity " + name + str(e) + " of type " + type)
# * Number of mesh nodes and elements:
numElem = sum(len(i) for i in elemTags)
print(" - Mesh has " + str(len(nodeTags)) + " nodes and " + str(numElem) +
" elements")
# * Upward and downward adjacencies:
up, down = gmsh.model.getAdjacencies(dim, tag)
if len(up):
print(" - Upward adjacencies: " + str(up))
if len(down):
print(" - Downward adjacencies: " + str(down))
# * Does the entity belong to physical groups?
physicalTags = gmsh.model.getPhysicalGroupsForEntity(dim, tag)
if len(physicalTags):
s = ''
for p in physicalTags:
n = gmsh.model.getPhysicalName(dim, p)
if n: n += ' '
s += n + '(' + str(dim) + ', ' + str(p) + ') '
print(" - Physical groups: " + s)
# * Is the entity a partition entity? If so, what is its parent entity?
partitions = gmsh.model.getPartitions(dim, tag)
if len(partitions):
print(" - Partition tags: " + str(partitions) + " - parent entity " +
str(gmsh.model.getParent(dim, tag)))
# * List all types of elements making up the mesh of the entity:
for t in elemTypes:
name, dim, order, numv, parv, _ = gmsh.model.mesh.getElementProperties(
t)
print(" - Element type: " + name + ", order " + str(order) + " (" +
str(numv) + " nodes in param coord: " + str(parv) + ")")
# Launch the GUI to see the model:
if '-nopopup' not in sys.argv:
gmsh.fltk.run()
# We can use this to clear all the model data:
gmsh.clear()
gmsh.finalize()
|
