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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
|
// -----------------------------------------------------------------------------
//
// Gmsh C++ extended tutorial 1
//
// Geometry and mesh data
//
// -----------------------------------------------------------------------------
// The C++ 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.cpp'.
// In this first extended tutorial, we start by using the API to access basic
// geometrical and mesh data.
#include <set>
#include <iostream>
#include <gmsh.h>
int main(int argc, char **argv)
{
gmsh::initialize();
if(argc > 1 && 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 (`x1.exe file.msh')
gmsh::open(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:
std::string name;
gmsh::model::getCurrent(name);
std::cout << "Model " << name << " (" << gmsh::model::getDimension()
<< "D)\n";
// 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 C++ 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:
std::vector<std::pair<int, int> > entities;
gmsh::model::getEntities(entities);
for(auto e : entities) {
// Dimension and tag of the entity:
int dim = e.first, tag = e.second;
// 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):
std::vector<std::size_t> nodeTags;
std::vector<double> nodeCoords, nodeParams;
gmsh::model::mesh::getNodes(nodeTags, nodeCoords, nodeParams, dim, tag);
// Get the mesh elements for the entity (dim, tag):
std::vector<int> elemTypes;
std::vector<std::vector<std::size_t> > elemTags, elemNodeTags;
gmsh::model::mesh::getElements(elemTypes, elemTags, elemNodeTags, 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 of the entity:
std::string type;
gmsh::model::getType(dim, tag, type);
std::string name;
gmsh::model::getEntityName(dim, tag, name);
if(name.size()) name += " ";
std::cout << "Entity " << name << "(" << dim << "," << tag << ") of type "
<< type << "\n";
// * Number of mesh nodes and elements:
int numElem = 0;
for(auto &tags : elemTags) numElem += tags.size();
std::cout << " - Mesh has " << nodeTags.size() << " nodes and " << numElem
<< " elements\n";
// * Upward and downward adjacencies:
std::vector<int> up, down;
gmsh::model::getAdjacencies(dim, tag, up, down);
if(up.size()) {
std::cout << " - Upward adjacencies: ";
for(auto e : up) std::cout << e << " ";
std::cout << "\n";
}
if(down.size()) {
std::cout << " - Downward adjacencies: ";
for(auto e : down) std::cout << e << " ";
std::cout << "\n";
}
// * Does the entity belong to physical groups?
std::vector<int> physicalTags;
gmsh::model::getPhysicalGroupsForEntity(dim, tag, physicalTags);
if(physicalTags.size()) {
std::cout << " - Physical group: ";
for(auto physTag : physicalTags) {
std::string n;
gmsh::model::getPhysicalName(dim, physTag, n);
if(n.size()) n += " ";
std::cout << n << "(" << dim << ", " << physTag << ") ";
}
std::cout << "\n";
}
// * Is the entity a partition entity? If so, what is its parent entity?
std::vector<int> partitions;
gmsh::model::getPartitions(dim, tag, partitions);
if(partitions.size()) {
std::cout << " - Partition tags:";
for(auto part : partitions) std::cout << " " << part;
int parentDim, parentTag;
gmsh::model::getParent(dim, tag, parentDim, parentTag);
std::cout << " - parent entity (" << parentDim << "," << parentTag
<< ")\n";
}
// * List all types of elements making up the mesh of the entity:
for(auto elemType : elemTypes) {
std::string name;
int d, order, numv, numpv;
std::vector<double> param;
gmsh::model::mesh::getElementProperties(elemType, name, d, order, numv,
param, numpv);
std::cout << " - Element type: " << name << ", order " << order << "\n";
std::cout << " with " << numv << " nodes in param coord: (";
for(auto p : param) std::cout << p << " ";
std::cout << ")\n";
}
}
// Launch the GUI to see the model:
std::set<std::string> args(argv, argv + argc);
if(!args.count("-nopopup")) gmsh::fltk::run();
// We can use this to clear all the model data:
gmsh::clear();
gmsh::finalize();
return 0;
}
|
