thggalg.html

有限元学习研究用源代码(老外的),供科研人员参考

<h1><a NAME="gdgridgen">The Grid Generation Algorithm </a></h1>


  <p> Now we give a short overview over the grid generation
algorithm. Let's consider at first our reasons to use especially this
algorithm. The base of our decisions are the requirements of the
application, the criteria we have derived in the previous sections and
the decision to use the contravariant geometry description defined in the
first part.
<h2><a NAME="indbasic">Boundary-Independent Basic Grid</a></h2>


  <p> The first point we have fixed was to create at first a grid
independently of the boundary and to create the boundary grid in a
second step. This is de facto predefined by the contravariant geometry
description --- we obtain boundary data only if we have some region
points before. But it is also in good agreement with other problems:

 
 <ul>
 <li> The numerical grid quality inside doesn't depend on the boundary
and can be more easily controlled.
 
 <li> We have no boundary discretization data, so the advancing front
algorithm cannot be used immediately.
 
 <li> In this way it will be easier to organize the alignment for
anisotropical grid generation.
 
 <li> Some initial part of the grid generation may be done in
principal only once for some time steps, if we have only small changes
in time.
 
 <li> For a small modification of the (time-dependent) boundary the
majority of inner points doesn't move. This leads to minimal
interpolation error inside.
 
 </ul>


<h2><a NAME="bcompgr">Boundary Computation by Computing Intersections with Grid Lines</a></h2>


This decision is also de-facto predefined by using the contravariant
geometry description. Computing such intersections is the only
possibility to obtain information about the boundary.

  <p>But this method is also in good coincidence with other problems we
have to solve. Especially, this allows to guarantee the alignment of
the nodes near the boundary. We obtain also a lot of right angles near
the boundary. Remark that such right angles lead to zero coefficients
in the resulting matrix. This allows to omit the related coefficients
and makes the matrix simpler.

  <p>Remark, that we compute the boundary intersections on the finest
grid, because we need a very accurate description of the geometry in
the resulting grid.
<h2><a NAME="ggalgdel">Delaunay Grid Computation</a></h2>


After these initial steps, we compute the Delaunay grid for the
resulting point set. This is predefined by the numerical criterion we
have to use.

  <p>The only question is if it is possible to create this grid "by
hand", based on the data structures of the initial grid. In 2D this
seems possible, but in 3D, there are too much different cases.
<h2><a NAME="ggalgoct">Using the Anisotropical Variant of the Octree Method</a></h2>


By our application, local refinement is required. We also need
anisotropical refinement. In our domain of interest, the directions
which need high refinement are often parallel to the coordinate axes.
That's why the main problem of the anisotropical octree method ---
that it cannot make good anisotropical refinement in skew directions
--- seems to be not so big. But, in my opinion, this seems to be the
greatest problem of the current state of the algorithm.


<h2><a NAME="ggalgcon">Conclusion</a></h2>


  <p>Thus, we start with an anisotropical variant of the octree method
to obtain a fine point set defined by local an anisotropical
refinement criteria. Then we compute boundary intersections to define
the exact boundary position. For the resulting point set, we compute
the Delaunay grid.

  <p>In the following two sections, we consider these parts of the
algorithm in detail: