Select Git revision
-
Christophe Geuzaine authored
tutorial/ -> tutorials/
Christophe Geuzaine authoredtutorial/ -> tutorials/
x1.cpp 6.46 KiB
// -----------------------------------------------------------------------------
//
// 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;
}