Skip to content
Snippets Groups Projects
Select Git revision
  • gmsh_4_11_1
  • master default protected
  • hierarchical-basis
  • alphashapes
  • bl
  • relaying
  • new_export_boris
  • oras_vs_osm
  • reassign_partitions
  • distributed_fwi
  • rename-classes
  • fix/fortran-api-example-t4
  • robust_partitions
  • reducing_files
  • fix_overlaps
  • 3115-issue-fix
  • 3023-Fillet2D-Update
  • convert_fdivs
  • tmp_jcjc24
  • fixedMeshIF
  • save_edges
  • gmsh_4_14_0
  • gmsh_4_13_1
  • gmsh_4_13_0
  • gmsh_4_12_2
  • gmsh_4_12_1
  • gmsh_4_12_0
  • gmsh_4_11_0
  • gmsh_4_10_5
  • gmsh_4_10_4
  • gmsh_4_10_3
  • gmsh_4_10_2
  • gmsh_4_10_1
  • gmsh_4_10_0
  • gmsh_4_9_5
  • gmsh_4_9_4
  • gmsh_4_9_3
  • gmsh_4_9_2
  • gmsh_4_9_1
  • gmsh_4_9_0
40 results

t6.cpp

Blame
  • 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;
    }