mainprofiletest.html

Delaunay三角形的网格剖分程序

<TITLE>COG 1.0 - CogenProfile</TITLE>

<H1>class CogenProfile</H1>

<PRE>
#include "<A HREF="cogenprofile.hxx">cogenprofile.hxx</A>"
</PRE>

 <P>The class <B>CogenProfile</B> was developed for geological
applications. It is defined in
 <A HREF="cogenprofile.cxx">cogenprofile.cxx</A> creates a geometry
and a grid for geological profiles.  These profiles are multi-layer
structures, and the boundaries between the layers are defined by
functions x = f(y,z) where x is the coordinate in vertical direction
and y,z coordinates in the horizontal directions.

 <P>The cogeometry is defined in a rather obvious way by the values
f(x,y) for a regular grid of y- and z-values.

 <P>The more interesting part is the related grid generation
algorithm.  In the geological applications, we have a rather
interesting property: much larger distances in the horizontal
directions (kilometers) than in horizontal directions (meters).
Therefore, we need highly anisotropical grids.  Isotropically refined
grids require far too much points.  Moreover, we have very thin,
slightly skew layers.  The usual octree strategy requires a lot of
refinement in this situation. It requires a lower number of points in
comparison with isotropical refinement, but the number of additional
nodes remains much too high. 

 <P>Now, in this situation a grid with a much lower number of nodes is
possible if we do not require the Delaunay property.  The purpose of
cogenProfile is to create these non-Delaunay grids.  An example of a
grid created by this algorithm is the following:

 <P><IMG SRC="profiletest.gif">
    <IMG SRC="profilegrid.gif">

 <P>At a first look, there are a lot of obtuse triangles with large
obtuse angles.  But note that the picture is very much compressed in
horizontal direction (~ 1:30).  Therefore, in the real grid the
triangles remain obtuse, but the angles are much more close to 90
degrees than it looks in the picture.  The main property is that even
for very thin skew layers the geometry is defined correctly, and with
very few nodes.

<H2>Reading the data</H2>

<P>First, we read the data from a file written in a very simple data
format:

<PRE>
#include "<A HREF="coglib.hxx">cog/coglib.hxx</A>"
#include "cog1d.hxx"
int main()
{
  cogenProfile gen = new CogenProfile("cog/profileinput.gfz");
</PRE>

<H2>Controlling non-Delaunay grid generation</H2>

 <P>To obtain the non-Delaunay grids using the usual Delaunay grid
generator we shift the nodes with different materials away from each
other in vertical direction.  Then we compute the Delaunay grid and
shift back.  This shift is controlled by the
<B>materialShiftFactor</B>:

<PRE>
  gen-&gt;materialShiftFactor = 1.0;
</PRE>

 <P>Setting this factor zero creates a Delaunay grid, but for skew
boundaries the probability is very low that this grid has the correct
geometry.  The shift is relative, 1.0 means the whole vertical
range.  Values larger than 1.0 are unreasonable.  But lower values may
be appropriate.

 <P>A problem is that for large shift values the resulting grid may
have triangles with negative area.  This happens if the distance
between neighbour points in horizontal direction is comparable with
the shift.  If this happens, there is a possibility to avoid this: to
set the <B>horizontalFactor</B> greater than 1.0:

<PRE>
  gen-&gt;horizontalFactor = 10.0;
</PRE>

 <P>This possibly results in some additional non-Delaunay simplices,
but there is reasonable hope that this does not happen.

<H2>Defining the box</H2>

 <P>It seems meaningful to define the box in relative values - values
which depend on the data defined in the input file.  The first four
parameters define the part of the index range which should be used,
using large enough values like (0,10000,0,10000,...) has the effect of
using the full range as given in the Profile file.  Then, some subrange of
layers may be defined, again with (...,0,10000,...) for all layers.
 <P>The last two parameters define the relative range in vertical
direction, with (...,0,1) as the range defined in the input file. We
recommend to use a greater range:

<PRE>
  gen-&gt;setRelativeBox(0,1000,0,1,0,10000,-0.5,1.5);
</PRE>

<H2>Refinement</H2>

 <P>Now, we can define refinement parameters relative to the input
data too:

<PRE>
  gen-&gt;refinementGlobal(
	0.04*(gen-&gt;xmax-gen-&gt;xmin),
	0.16*(gen-&gt;ymax-gen-&gt;ymin),
	2.1*(gen-&gt;zmax-gen-&gt;zmin));
//  gen-&gt;faceRefinementGlobal(0.05,1.0);
</PRE>

<H2>Grid generation</H2>

 <P>Now, we generate the grid and write it out as usual:

<PRE>
  wzgrid grid = (*gen)(gen-&gt;geometry());
  grid->write("test.sg");
  v();
}
</PRE>