Flow123d  release_3.0.0-1008-gca43bb7
mesh.h
Go to the documentation of this file.
1 /*!
2  *
3  * Copyright (C) 2015 Technical University of Liberec. All rights reserved.
4  *
5  * This program is free software; you can redistribute it and/or modify it under
6  * the terms of the GNU General Public License version 3 as published by the
7  * Free Software Foundation. (http://www.gnu.org/licenses/gpl-3.0.en.html)
8  *
9  * This program is distributed in the hope that it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11  * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
12  *
13  *
14  * @file mesh.h
15  * @brief
16  */
17 
18 #ifndef MAKE_MESH_H
19 #define MAKE_MESH_H
20 
21 #include <mpi.h> // for MPI_Comm, MPI_COMM_WORLD
22 #include <boost/exception/info.hpp> // for error_info::~error_info<...
23 //#include <boost/range.hpp>
24 #include <memory> // for shared_ptr
25 #include <string> // for string
26 #include <vector> // for vector, vector<>::iterator
27 #include "input/accessors.hh" // for Record, Array (ptr only)
28 #include "input/accessors_impl.hh" // for Record::val
29 #include "input/storage.hh" // for ExcStorageTypeMismatch
30 #include "input/type_record.hh" // for Record (ptr only), Recor...
31 #include "mesh/long_idx.hh" // for LongIdx
32 #include "mesh/boundaries.h" // for Boundary
33 #include "mesh/edges.h" // for Edge
34 #include "mesh/region.hh" // for RegionDB, RegionDB::MapE...
35 #include "mesh/nodes.hh"
36 #include "mesh/bounding_box.hh" // for BoundingBox
37 #include "mesh/range_wrapper.hh"
40 #include "system/exceptions.hh" // for operator<<, ExcStream, EI
41 #include "system/file_path.hh" // for FilePath
42 #include "system/sys_vector.hh" // for FullIterator, VectorId<>...
43 
44 class BIHTree;
45 class Distribution;
46 class Partitioning;
48 class Neighbour;
49 class SideIter;
50 class BCMesh;
51 class DuplicateNodes;
52 template <int spacedim> class ElementAccessor;
53 template <int spacedim> class NodeAccessor;
54 
55 
56 #define ELM 0
57 #define BC 1
58 #define NODE 2
59 
60 /**
61  * This parameter limits volume of elements from below.
62  */
63 #define MESH_CRITICAL_VOLUME 1.0E-12
64 
66 public:
68 };
69 
70 
71 
72 //=============================================================================
73 // STRUCTURE OF THE MESH
74 //=============================================================================
75 
76 class Mesh {
77 public:
78  TYPEDEF_ERR_INFO( EI_ElemLast, int);
79  TYPEDEF_ERR_INFO( EI_ElemNew, int);
80  TYPEDEF_ERR_INFO( EI_RegLast, std::string);
81  TYPEDEF_ERR_INFO( EI_RegNew, std::string);
82  DECLARE_EXCEPTION(ExcDuplicateBoundary,
83  << "Duplicate boundary elements! \n"
84  << "Element id: " << EI_ElemLast::val << " on region name: " << EI_RegLast::val << "\n"
85  << "Element id: " << EI_ElemNew::val << " on region name: " << EI_RegNew::val << "\n");
86 
87 
88  /**
89  * \brief Types of search algorithm for finding intersection candidates.
90  */
91  typedef enum IntersectionSearch {
92  BIHsearch = 1,
93  BIHonly = 2,
94  BBsearch = 3
96 
97  /**
98  * \brief The definition of input record for selection of variant of file format
99  */
100  static const Input::Type::Selection & get_input_intersection_variant();
101 
102  static const unsigned int undef_idx=-1;
103  static const Input::Type::Record & get_input_type();
104 
105 
106 
107  /** Labels for coordinate indexes in arma::vec3 representing vectors and points.*/
108  enum {x_coord=0, y_coord=1, z_coord=2};
109 
110  /**
111  * Empty constructor.
112  *
113  * Use only for unit tests!!!
114  */
115  Mesh();
116  /**
117  * Constructor from an input record.
118  * Do not process input record. That is done in init_from_input.
119  */
120  Mesh(Input::Record in_record, MPI_Comm com = MPI_COMM_WORLD);
121  /**
122  * Common part of both previous constructors and way how to reinitialize a mesh from the given input record.
123  */
124  void reinit(Input::Record in_record);
125 
126  /// Destructor.
127  virtual ~Mesh();
128 
129  virtual inline unsigned int n_nodes() const {
130  return node_vec_.size();
131  }
132 
133  inline unsigned int n_boundaries() const {
134  return boundary_.size();
135  }
136 
137  inline unsigned int n_edges() const {
138  return edges.size();
139  }
140 
141  unsigned int n_corners();
142 
143  inline const RegionDB &region_db() const {
144  return region_db_;
145  }
146 
147 // /// Reserve size of node vector
148 // inline void reserve_node_size(unsigned int n_nodes) {
149 // node_vector.reserve(n_nodes);
150 // }
151 //
152 // /// Reserve size of element vector
153 // inline void reserve_element_size(unsigned int n_elements) {
154 // element.reserve(n_elements);
155 // }
156 
157  /**
158  * Returns pointer to partitioning object. Partitioning is created during setup_topology.
159  */
160  virtual Partitioning *get_part();
161 
162  virtual const LongIdx *get_local_part();
163 
165  { return el_ds; }
166 
168  { return row_4_el; }
169 
171  { return el_4_loc; }
172 
174  { return node_ds_; }
175 
177  { return node_4_loc_; }
178 
179  unsigned int n_local_nodes() const
180  { return n_local_nodes_; }
181 
182  /**
183  * Returns MPI communicator of the mesh.
184  */
185  inline MPI_Comm get_comm() const { return comm_; }
186 
187 
188  MixedMeshIntersections &mixed_intersections();
189 
190  unsigned int n_sides() const;
191 
192  unsigned int n_vb_neighbours() const;
193 
194  /**
195  * Returns maximal number of sides of one edge, which connects elements of dimension @p dim.
196  * @param dim Dimension of elements sharing the edge.
197  */
198  unsigned int max_edge_sides(unsigned int dim) const { return max_edge_sides_[dim-1]; }
199 
200  /**
201  * Reads mesh from stream.
202  *
203  * Method is especially used in unit tests.
204  */
205  void read_gmsh_from_stream(istream &in);
206  /**
207  * Reads input record, creates regions, read the mesh, setup topology. creates region sets.
208  */
209  void init_from_input();
210 
211 
212  /**
213  * Initialize all mesh structures from raw information about nodes and elements (including boundary elements).
214  * Namely: create remaining boundary elements and Boundary objects, find edges and compatible neighborings.
215  */
216  void setup_topology();
217 
218  /**
219  * Returns vector of ID numbers of elements, either bulk or bc elemnts.
220  */
221  void elements_id_maps( vector<LongIdx> & bulk_elements_id, vector<LongIdx> & boundary_elements_id) const;
222 
223  /*
224  * Check if nodes and elements are compatible with \p mesh.
225  */
226  virtual bool check_compatible_mesh( Mesh & mesh, vector<LongIdx> & bulk_elements_id, vector<LongIdx> & boundary_elements_id );
227 
228  /// Create and return ElementAccessor to element of given idx
229  virtual ElementAccessor<3> element_accessor(unsigned int idx) const;
230 
231  /// Create and return NodeAccessor to node of given idx
232  NodeAccessor<3> node_accessor(unsigned int idx) const;
233 
234  /**
235  * Reads elements and their affiliation to regions and region sets defined by user in input file
236  * Format of input record is defined in method RegionSetBase::get_input_type()
237  *
238  * @param region_list Array input AbstractRecords which define regions, region sets and elements
239  */
240  void read_regions_from_input(Input::Array region_list);
241 
242  /**
243  * Returns nodes_elements vector, if doesn't exist creates its.
244  */
245  vector<vector<unsigned int> > const & node_elements();
246 
247  /// Vector of boundary sides where is prescribed boundary condition.
248  /// TODO: apply all boundary conditions in the main assembling cycle over elements and remove this Vector.
250 
251  /// Vector of MH edges, this should not be part of the geometrical mesh
253 
254  //flow::VectorId<int> bcd_group_id; // gives a index of group for an id
255 
256  /**
257  * Vector of individual intersections of two elements.
258  * This is enough for local mortar.
259  */
260  std::shared_ptr<MixedMeshIntersections> intersections;
261 
262  /**
263  * For every element El we have vector of indices into @var intersections array for every intersection in which El is master element.
264  * This is necessary for true mortar.
265  */
267 
269 
270  /**
271  * Vector of compatible neighbourings.
272  */
274 
275  int n_insides; // # of internal sides
276  int n_exsides; // # of external sides
277  mutable int n_sides_; // total number of sides (should be easy to count when we have separated dimensions
278 
279  int n_lines; // Number of line elements
280  int n_triangles; // Number of triangle elements
281  int n_tetrahedras; // Number of tetrahedra elements
282 
283  // Temporary solution for numbering of nodes on sides.
284  // The data are defined in RefElement<dim>::side_nodes,
285  // Mesh::side_nodes can be removed as soon as Element
286  // is templated by dimension.
287  //
288  // for every side dimension D = 0 .. 2
289  // for every element side 0 .. D+1
290  // for every side node 0 .. D
291  // index into element node array
293 
294  /**
295  * Check usage of regions, set regions to elements defined by user, close RegionDB
296  */
297  void check_and_finish();
298 
299  /// Compute bounding boxes of elements contained in mesh.
300  std::vector<BoundingBox> get_element_boxes();
301 
302  /// Getter for BIH. Creates and compute BIH at first call.
303  const BIHTree &get_bih_tree();\
304 
305  /**
306  * Find intersection of element lists given by Mesh::node_elements_ for elements givne by @p nodes_list parameter.
307  * The result is placed into vector @p intersection_element_list. If the @p node_list is empty, and empty intersection is
308  * returned.
309  */
310  void intersect_element_lists(vector<unsigned int> const &nodes_list, vector<unsigned int> &intersection_element_list);
311 
312  /// Add new node of given id and coordinates to mesh
313  void add_node(unsigned int node_id, arma::vec3 coords);
314 
315  /// Add new element of given id to mesh
316  void add_element(unsigned int elm_id, unsigned int dim, unsigned int region_id, unsigned int partition_id,
317  std::vector<unsigned int> node_ids);
318 
319  /// Add new node of given id and coordinates to mesh
320  void add_physical_name(unsigned int dim, unsigned int id, std::string name);
321 
322  /// Return FilePath object representing "mesh_file" input key
323  inline FilePath mesh_file() {
324  return in_record_.val<FilePath>("mesh_file");
325  }
326 
327  /// Getter for input type selection for intersection search algorithm.
328  IntersectionSearch get_intersection_search();
329 
330  /// Maximal distance of observe point from Mesh relative to its size
331  double global_snap_radius() const;
332 
333  /// Initialize element_vec_, set size and reset counters of boundary and bulk elements.
334  void init_element_vector(unsigned int size);
335 
336  /// Initialize node_vec_, set size
337  void init_node_vector(unsigned int size);
338 
339  /// Returns range of bulk elements
340  virtual Range<ElementAccessor<3>> elements_range() const;
341 
342  /// Returns range of nodes
343  Range<NodeAccessor<3>> node_range() const;
344 
345  /// Returns count of boundary or bulk elements
346  virtual unsigned int n_elements(bool boundary=false) const {
347  if (boundary) return element_ids_.size()-bulk_size_;
348  else return bulk_size_;
349  }
350 
351  /// For each node the vector contains a list of elements that use this node
353 
354  /// For element of given elem_id returns index in element_vec_ or (-1) if element doesn't exist.
355  inline int elem_index(int elem_id) const
356  {
357  return element_ids_.get_position(elem_id);
358  }
359 
360  /// Return element id (in GMSH file) of element of given position in element vector.
361  inline int find_elem_id(unsigned int pos) const
362  {
363  return element_ids_[pos];
364  }
365 
366  /// For node of given node_id returns index in element_vec_ or (-1) if node doesn't exist.
367  inline int node_index(int node_id) const
368  {
369  return node_ids_.get_position(node_id);
370  }
371 
372  /// Return node id (in GMSH file) of node of given position in node vector.
373  inline int find_node_id(unsigned int pos) const
374  {
375  return node_ids_[pos];
376  }
377 
378  /// Check if given index is in element_vec_
379  void check_element_size(unsigned int elem_idx) const;
380 
381  /// Create boundary elements from data of temporary structure, this method MUST be call after read mesh from
382  void create_boundary_elements();
383 
384  /// Permute nodes of 3D elements of given elm_idx
385  void permute_tetrahedron(unsigned int elm_idx, std::vector<unsigned int> permutation_vec);
386 
387  /// Permute nodes of 2D elements of given elm_idx
388  void permute_triangle(unsigned int elm_idx, std::vector<unsigned int> permutation_vec);
389 
390  /// Create boundary mesh if doesn't exist and return it.
391  BCMesh *get_bc_mesh();
392 
393 protected:
394 
395  /**
396  * Allow store boundary element data to temporary structure.
397  *
398  * We need this structure to preserve correct order of boundary elements.
399  */
400  struct ElementTmpData {
401  /// Constructor
402  ElementTmpData(unsigned int e_id, unsigned int dm, RegionIdx reg_idx, unsigned int part_id, std::vector<unsigned int> nodes)
403  : elm_id(e_id), dim(dm), region_idx(reg_idx), partition_id(part_id), node_ids(nodes) {}
404 
405  unsigned int elm_id;
406  unsigned int dim;
408  unsigned int partition_id;
410  };
411 
412  /**
413  * This replaces read_neighbours() in order to avoid using NGH preprocessor.
414  *
415  * TODO:
416  * - Avoid maps:
417  *
418  * 5) need not to have temporary array for Edges, only postpone setting pointers in elements and set them
419  * after edges are found; we can temporary save Edge index instead of pointer in Neigbours and elements
420  *
421  * 6) Try replace Edge * by indexes in Neigbours and elements (anyway we have mesh pointer in elements so it is accessible also from Neigbours)
422  *
423  */
424  void make_neighbours_and_edges();
425 
426  /**
427  * On edges sharing sides of many elements it may happen that each side has its nodes ordered in a different way.
428  * This method finds the permutation for each side so as to obtain the ordering of side 0.
429  */
430  void make_edge_permutations();
431  /**
432  * Create element lists for nodes in Mesh::nodes_elements.
433  */
434  void create_node_element_lists();
435  /**
436  * Remove elements with dimension not equal to @p dim from @p element_list. Index of the first element of dimension @p dim-1,
437  * is returned in @p element_idx. If no such element is found the method returns false, if one such element is found the method returns true,
438  * if more elements are found we report an user input error.
439  */
440  bool find_lower_dim_element(vector<unsigned int> &element_list, unsigned int dim, unsigned int &element_idx);
441 
442  /**
443  * Returns true if side @p si has same nodes as in the list @p side_nodes.
444  */
445  bool same_sides(const SideIter &si, vector<unsigned int> &side_nodes);
446 
447 
448  void element_to_neigh_vb();
449 
450  void count_element_types();
451  void count_side_types();
452 
453  /**
454  * Possibly modify region id of elements sets by user in "regions" part of input file.
455  *
456  * TODO: This method needs check in issue 'Review mesh setting'.
457  * Changes have been done during generalized region key and may be causing problems
458  * during the further development.
459  */
460  void modify_element_ids(const RegionDB::MapElementIDToRegionID &map);
461 
462  /// Adds element to mesh data structures (element_vec_, element_ids_), returns pointer to this element.
463  Element * add_element_to_vector(int id, bool boundary=false);
464 
465  /// Initialize element
466  void init_element(Element *ele, unsigned int elm_id, unsigned int dim, RegionIdx region_idx, unsigned int partition_id,
467  std::vector<unsigned int> node_ids);
468 
469  unsigned int n_bb_neigh, n_vb_neigh;
470 
471  /// Maximal number of sides per one edge in the actual mesh (set in make_neighbours_and_edges()).
472  unsigned int max_edge_sides_[3];
473 
474  /// Output of neighboring data into raw output.
475  void output_internal_ngh_data();
476 
477  /**
478  * Database of regions (both bulk and boundary) of the mesh. Regions are logical parts of the
479  * domain that allows setting of different data and boundary conditions on them.
480  */
482  /**
483  * Mesh partitioning. Created in setup_topology.
484  */
485  std::shared_ptr<Partitioning> part_;
486 
487  /**
488  * BIH Tree for intersection and observe points lookup.
489  */
490  std::shared_ptr<BIHTree> bih_tree_;
491 
492 
493  /**
494  * Accessor to the input record for the mesh.
495  */
497 
498  /**
499  * MPI communicator used for partitioning and ...
500  */
502 
503  /**
504  * Vector of elements of the mesh.
505  *
506  * Store all elements of the mesh in order bulk elements - boundary elements
507  */
509 
510  /// Hold data of boundary elements during reading mesh (allow to preserve correct order during reading of mix bulk-boundary element)
512 
513  /// Count of bulk elements
514  unsigned int bulk_size_;
515 
516  /// Count of boundary elements loaded from mesh file
517  unsigned int boundary_loaded_size_;
518 
519  /// Maps element ids to indexes into vector element_vec_
521 
522  /**
523  * Vector of nodes of the mesh.
524  */
526 
527  /// Maps node ids to indexes into vector node_vec_
529 
530 
531 
532 
533  friend class RegionSetBase;
534  friend class Element;
535  friend class BIHTree;
536  friend class Boundary;
537  friend class BCMesh;
538  template <int spacedim> friend class ElementAccessor;
539  template <int spacedim> friend class NodeAccessor;
540 
541 
542 
543 private:
544 
545  /// Fill array node_4_loc_ and create object node_ds_ according to element distribution.
546  void distribute_nodes();
547 
548  /// Index set assigning to global element index the local index used in parallel vectors.
550  /// Index set assigning to local element index its global index.
552  /// Parallel distribution of elements.
554  /// Index set assigning to local node index its global index.
556  /// Parallel distribution of nodes. Depends on elements distribution.
558  /// Hold number of local nodes (own + ghost), value is equal with size of node_4_loc array.
559  unsigned int n_local_nodes_;
560  /// Boundary mesh, object is created only if it's necessary
562 
564 };
565 
566 #endif
567 //-----------------------------------------------------------------------------
568 // vim: set cindent:
int n_triangles
Definition: mesh.h:280
Distribution * el_ds
Parallel distribution of elements.
Definition: mesh.h:553
int LongIdx
Define type that represents indices of large arrays (elements, nodes, dofs etc.)
Definition: long_idx.hh:22
Class for the mesh partitioning. This should provide:
Definition: partitioning.hh:52
vector< Element > element_vec_
Definition: mesh.h:508
ElementTmpData(unsigned int e_id, unsigned int dm, RegionIdx reg_idx, unsigned int part_id, std::vector< unsigned int > nodes)
Constructor.
Definition: mesh.h:402
BidirectionalMap< int > node_ids_
Maps node ids to indexes into vector node_vec_.
Definition: mesh.h:528
Accessor to input data conforming to declared Array.
Definition: accessors.hh:567
unsigned int n_local_nodes_
Hold number of local nodes (own + ghost), value is equal with size of node_4_loc array.
Definition: mesh.h:559
LongIdx * get_row_4_el() const
Definition: mesh.h:167
int MPI_Comm
Definition: mpi.h:141
unsigned int partition_id
Definition: mesh.h:408
BCMesh * bc_mesh_
Boundary mesh, object is created only if it&#39;s necessary.
Definition: mesh.h:561
Nodes of a mesh.
LongIdx * get_node_4_loc() const
Definition: mesh.h:176
BidirectionalMap< int > element_ids_
Maps element ids to indexes into vector element_vec_.
Definition: mesh.h:520
static Input::Type::Record input_type
Definition: mesh.h:67
LongIdx * node_4_loc_
Index set assigning to local node index its global index.
Definition: mesh.h:555
DuplicateNodes * tree
Definition: mesh.h:268
int n_lines
Definition: mesh.h:279
Implementation of bidirectional map.
#define DECLARE_EXCEPTION(ExcName, Format)
Macro for simple definition of exceptions.
Definition: exceptions.hh:158
ofstream raw_ngh_output_file
Definition: mesh.h:563
int elem_index(int elem_id) const
For element of given elem_id returns index in element_vec_ or (-1) if element doesn&#39;t exist...
Definition: mesh.h:355
std::shared_ptr< MixedMeshIntersections > intersections
Definition: mesh.h:260
Definition: mesh.h:76
Template Iter serves as general template for internal iterators.
unsigned int n_local_nodes() const
Definition: mesh.h:179
std::vector< unsigned int > node_ids
Definition: mesh.h:409
Input::Record in_record_
Definition: mesh.h:496
vector< vector< vector< unsigned int > > > side_nodes
Definition: mesh.h:292
int n_tetrahedras
Definition: mesh.h:281
const RegionDB & region_db() const
Definition: mesh.h:143
virtual unsigned int n_nodes() const
Definition: mesh.h:129
vector< Boundary > boundary_
Definition: mesh.h:249
int node_index(int node_id) const
For node of given node_id returns index in element_vec_ or (-1) if node doesn&#39;t exist.
Definition: mesh.h:367
int n_exsides
Definition: mesh.h:276
unsigned int boundary_loaded_size_
Count of boundary elements loaded from mesh file.
Definition: mesh.h:517
int find_elem_id(unsigned int pos) const
Return element id (in GMSH file) of element of given position in element vector.
Definition: mesh.h:361
MPI_Comm get_comm() const
Definition: mesh.h:185
LongIdx * el_4_loc
Index set assigning to local element index its global index.
Definition: mesh.h:551
Range helper class.
unsigned int n_boundaries() const
Definition: mesh.h:133
Accessor to the data with type Type::Record.
Definition: accessors.hh:292
Class for O(log N) lookup for intersections with a set of bounding boxes.
Definition: bih_tree.hh:38
LongIdx * row_4_el
Index set assigning to global element index the local index used in parallel vectors.
Definition: mesh.h:549
vector< Node > node_vec_
Definition: mesh.h:525
#define TYPEDEF_ERR_INFO(EI_Type, Type)
Macro to simplify declaration of error_info types.
Definition: exceptions.hh:194
std::shared_ptr< BIHTree > bih_tree_
Definition: mesh.h:490
Distribution * get_el_ds() const
Definition: mesh.h:164
vector< vector< unsigned int > > node_elements_
For each node the vector contains a list of elements that use this node.
Definition: mesh.h:352
unsigned int dim
Definition: mesh.h:406
Dedicated class for storing path to input and output files.
Definition: file_path.hh:54
vector< vector< unsigned int > > master_elements
Definition: mesh.h:266
vector< Neighbour > vb_neighbours_
Definition: mesh.h:273
unsigned int n_vb_neigh
Definition: mesh.h:469
Distribution * node_ds_
Parallel distribution of nodes. Depends on elements distribution.
Definition: mesh.h:557
virtual unsigned int n_elements(bool boundary=false) const
Returns count of boundary or bulk elements.
Definition: mesh.h:346
int n_sides_
Definition: mesh.h:277
unsigned int max_edge_sides(unsigned int dim) const
Definition: mesh.h:198
FilePath mesh_file()
Return FilePath object representing "mesh_file" input key.
Definition: mesh.h:323
Class represents boundary part of mesh.
Definition: bc_mesh.hh:35
Vector classes to support both Iterator, index and Id access and creating co-located vectors...
RegionDB region_db_
Definition: mesh.h:481
std::vector< Edge > edges
Vector of MH edges, this should not be part of the geometrical mesh.
Definition: mesh.h:252
MPI_Comm comm_
Definition: mesh.h:501
int n_insides
Definition: mesh.h:275
#define MPI_COMM_WORLD
Definition: mpi.h:123
Record type proxy class.
Definition: type_record.hh:182
IntersectionSearch
Types of search algorithm for finding intersection candidates.
Definition: mesh.h:91
unsigned int n_edges() const
Definition: mesh.h:137
Distribution * get_node_ds() const
Definition: mesh.h:173
LongIdx * get_el_4_loc() const
Definition: mesh.h:170
Template for classes storing finite set of named values.
Implementation of range helper class.
unsigned int bulk_size_
Count of bulk elements.
Definition: mesh.h:514
std::shared_ptr< Partitioning > part_
Definition: mesh.h:485
vector< ElementTmpData > bc_element_tmp_
Hold data of boundary elements during reading mesh (allow to preserve correct order during reading of...
Definition: mesh.h:511
Main class for computation of intersection of meshes of combined dimensions.
int find_node_id(unsigned int pos) const
Return node id (in GMSH file) of node of given position in node vector.
Definition: mesh.h:373
RegionIdx region_idx
Definition: mesh.h:407
unsigned int elm_id
Definition: mesh.h:405