Proceedings
 home
preface
contents
authors
keywords
copyright
reference
©2012 Civil-Comp Ltd |
 |
|
|
C. de Bellabre, F. Ledoux and J.-Ch. Weill
CEA, DAM, DIF, Arpajon, France
Keywords: meshing framework, C++ generic programming, computation time, memory footprint, mesh model, Delaunay triangulation.
full paper (pdf) -
reference
One of the main building blocks of computational simulations is the
mesh data structure. Depending on the numerical approximation methods
or the meshing algorithm to be implemented, the mesh data structure must
provide drastically different features. In order to provide a single
and uniform way to handle any type of meshes, general meshing
infrastructures have been developed in the last few years. In this
work, is on one of them, the C++ generic mesh data
structure (GMDS) framework, which intensively uses generic
programming, and allows users to select the mesh model, i.e. a
combination of available cells and connections, that best fits their
requirements.
At compile-time, the GMDS provides a tailored mesh data structure both in
computation time and memory footprint, which fits as best as possible
the algorithm requirements.
A mesh framework such as GMDS provides code sharing and a uniform
access to any kind of mesh model whatever the developer's requirements.
However, some main issues remain to be solved in an industrial
context: how to select the mesh model that best fits the
requirements of an algorithm? and how to combine algorithms
requiring different mesh models without space memory duplication? In
order to provide a first answer, a new level of abstraction has been
added into GMDS: for any mesh model, at compile-time some
pieces of C++ source code to retrieve the connections that are not
kept in memory according to the mesh model are built.
These pieces of source code are a
direct implementation of combinatorial terms that must be exhibited to
build missing connections. For instance, if an algorithm is built
for a mesh model where nodes, edges and faces are available and the
connection from faces to edges and edges to nodes are kept in memory,
it is possible to obtain the nodes of a face by traversing its adjacent
edges.
In order to illustrate the benefits of this approach,
an algorithm is implemented that generates a Delaunay triangulation. The
source code obtained runs for 105 different mesh models with different
performances both in computational time and memory footprint.
|
