Diffpack Documentation

(Functionality not available, requires installation of an additional Diffpack Toolbox)

Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members   Search  

GridFEAdT Class Reference

triangles/tetrahedral elements with refiniments. More...

#include <GridFEAdT.h>

Inheritance diagram for GridFEAdT::

GridFE GridWithPts Grid HandleId List of all members.

Public Methods

 GridFEAdT ()
 GridFEAdT (const GridFE &grid)
 GridFEAdT (const GridFEAdT &grid)
 ~GridFEAdT ()
bool ok () const
void operator= (const GridFEAdT &grid)
void operator= (const GridFE &grid)
GridFEAdT* refine (const VecSimple(bool) &mark_elms, const int ref_method)
GridFEAdT* refine (const VecSimple(int) &mark_elms)
GridFEAdT* refineUniformly (const int ref_method=3, bool regref=false)
GridFEAdT* refineLongEdges (const real break_ratio)
GridFEAdT* changeGridL2Q ()
GridFEAdT* changeGridQ2L ()
void setRegBisectOrShort (int method)
int getRegBisectOrShort ()
void setNodeForEqualTest (bool flag)
bool useNodeForEqualTest ()
GridFEAdT* makeCopyOfHierarchy (const int firstlevel, const int lastlevel)
GridFEAdT* createPartOfGrid (int subdomainno, int fromlevel)
GridFEAdT* createPartOfGrid (VecSimple(int) &partition, int startlevel, int stoplevel)
void initNeighbor (bool alwaysSortEdgesIn2D=false)
void removeNeighborInfo ()
void removeNewNodeInfo ()
void removeHierInfo ()
void removeChildrenInfo ()
void removeChildGrid ()
void removeParentInfo ()
void removeParentGrid ()
bool isParentInfo ()
bool isChildrenInfo ()
bool isNeighborsComputed ()
bool isNewNodesSet ()
bool isThisFinestGrid ()
bool isThisCoarsestGrid ()
GridFEAdT* getParentGrid ()
GridFEAdT* getChildGrid ()
virtual int getGridLevelNo ()
int getFinestGridLevelNo ()
GridFEAdT* getFinestGrid ()
GridFEAdT* getCoarsestGrid ()
virtual GridFE& getStartGrid ()
int getParent (int e)
int getParent (int rel_level, int e)
int getParent_eff (int e)
int getParent_eff (int rel_level, int e)
int getNoChildren (int e)
int getChild (int e, int child_no)
int getChild_eff (int e, int child_no)
int getFirstChild (int e)
bool checkParentInfo ()
bool checkChildrenInfo ()
void getEdgeLengthOrder (VecSimple(int) &order, int e)
int getLocEdgeNo (int n1, int n2, int e)
void getNodesOnEdge (int e, int edge_no, int &n1, int &n2)
int getFaceNo (int n1, int n2, int n3, int e, bool safe=false)
void getGlobNodesOnFace (int &n1, int &n2, int &n3, int f, int e)
int getLongestEdgeNo (int e)
int getSecondLongestEdgeNo1 (int e)
int getShortestEdgeNo (int e)
int getShortestEdgeNo1 (int e)
int getElmNeighbor (int e, int ef_no)
bool isElmNeighbor (int e, int elnei)
void removeInteriorIndicators ()
bool checkElementOrientation ()
bool isElmNeighborConsistent ()
void makeSmoothing (int nrepetitions=1, int qualcrit=1)
void smoothNode (int node, int qualcrit=1)
void smoothNeighbors (int node, int qualcrit=1)
real getMinEta (VecSimplest(int) &element_list, int qualcrit=1)
void makeStatistics (Os os)
bool findElm (Ptv(real) &x, int level, int &element)
bool findElm (Ptv(real) &x, int &element)
int findElm (Ptv(real) &x, int level0, int elm0, int level1)
bool simpleSearch (Ptv(real) &x, int &element)
bool isInsideElm (Ptv(real) &x, int element)
void computeBoundingBoxes ()
void removeBoundingBoxes ()
bool isBoundingBoxesComputed ()
void initSearchStat ()
void initSearchStatAllGrids ()
void printSearchStatAllGrids (Os os)
int getNoBoxTests ()
int getNoElmTests ()
void printGrid (Os os)
void printBoundary (Os os)
void printGrid (Os os, const int sbdtype) const
void presentGridHier (Os os)

Public Attributes

ToolsElmT3n2D FET3
ToolsElmT4n3D FET4

Detailed Description

triangles/tetrahedral elements with refiniments.

NAME: GridFEAdT - triangles/tetrahedral elements with refiniments

DESCRIPTION:

The class represents a collection of functions for refinement and representation of a hierarchy of finite element grids with triangular or tetrahedral elements

"GridFEAdT" is an extension of the "GridFE" class, for description of the members which are inherited see the documentation in "GridFE".

The refinement algorithms described below will construct refined grids which will be nested in the original parent grid, i.e., each of the elements in the refined "child" grid will lie inside an element of the parent grid.

When a grid is refined it will be connected to the old grid from which it was refined. This connection consists of pointers and information on which parent element in the new grid an element in the refined grid lies in. The old grid will for each element contain the element numbers of the child elements in the refined grid into which the element was refined. This parent-child information describes a tree structure which is useful e.g., for searching in the grid (see "findElm"). The methods "getParent", "getChild" and other methods are used to extract the tree structure information.

The sequence of refined grids will define a grid hierarchy where each of its components is a "GridFEAdT". In addition, by inheritance from "GridFE" each of the grid can also be used as a "GridFE" grid in all the normal uses of a "GridFE" grid, such as assembly of systems, defining fields, etc. Each of the grids in the hierarchy is given a grid level number, where the coarsest grid (without parent grid) has level 1, the level is then increased for each finer grid. The grid level number is obtained by the method "getGridLevelNo".

In the refinement algorithms and for many other applications such as finding outer or internal boundaries, computing error estimates, etc., it is important to have information on which neighbor elements an element has. The neighbor element information is initialized by "initNeighbor", and contain the element number of the neighbor elements. The neighbor element is found by using "getElmNeighbor". In 1D the element on the left side is in column 1, and the element on the right side of the element is in column 2 of the array which "getElmNeighbor" access. In 2D, triangle edges have a local ordering where edge 1 goes between local nodes 1 and 2, edge 2 goes between local node 2 and 3, and edge 3 is between nodes 3 and 1. In 3D the following ordering of faces are used: Face 1 contains nodes 1, 2 and 4; face 2 contains nodes 2, 3 and 4; face 3 contains nodes 1, 3 and 4; face 4 contains nodes 1, 2 and 3.

The local numbering of edges in a tetrahedron is as follows: edge 1 is between node 1 and 2, edge 2 is between node 2 and 3, edge 3 is between node 3 and 1, edge 4 is between node 1 and 4, edge 5 is between node 2 and 4, edge 6 is between node 3 and 4.

If an element does not have a neighbor at a node (in 1D), edge (2D) or face (3D), the corresponding column position in elm_neigh accessed by "getElmNeighbor" will contain the value 0.

Refinement algorithms:

The algorithm used to refine a grid consists of two phases. The first phase is to determine where new nodes should be inserted and which global node number these new nodes are going to get in the new grid. The second phase consists of using the node numbers introduced in phase one and refine the elements individually into their children elements. It is crucial that the first phase has succeeded in choosing the positions and numbers of the new nodes (which are shared by many elements) so that the refined grid will be consistent (regular) and that the shape of the elements in the refined grids will not degenerate after repeated refinement.

For the linear elements "ElmT3n2D" (triangles) and "ElmT4n3D" (tetrahedra) the new nodes will be inserted on midpoints of edges in the grid. The number of edges in each element to be refined is determined by the argument of the "refine" functions. The n longest edges in the element will be refined, where 0<=n<=3 in 2D and 0<=n<=6 in 3D. In addition an edge can be refined because the neighbor element wants to refine that edge. In addition, to ensure that the shape of the refined elements will not degenerate by repeated refinement, the longest edge (in 2D) in a triangle will be refined, (if n was larger than 1 it was already refined). Correspondingly for 3D the longest edge of the element and the longest edges of faces with any refined edges of tetrahedra are refined.

The refinement for "ElmT6n2D" elements are similar to the case of "ElmT3n2D", but new nodes are inserted (and numbered), also between vertex nodes and midpoints nodes (which already was present from the old grid). New nodes will also be inserted on new interior edges of the elements. Refinement of quadratic elements in 3D ("ElmT10n3D") is not yet implemented, but it is possible to use the function "changeL2Q" to change an "ElmT4n3D" grid to an "ElmT10n3D" grid.

Setting of indicators and subdomain types for the refined grid:

All the nodes in the old grid will also be present in the new grid (with the same numbering) and their old indicator values are copied. For the new inserted nodes in the refined grid an indicator value will be set ON if both the nodes on the edge where the new node was inserted had that indicator value ON. Note that for a refined grid this means that nodes inserted on an edge, which goes between two nodes on the boundary, but not belonging to the boundary could get an indicator value set ON (if both the nodes on the boundary had the same indicator value set to ON). If this is not what the user wanted this can be solved by either using different indicators on different part of the boundary, or by calling "removeInteriorIndicators" after refinement, (but this will also remove other, perhaps wanted, indicators in the interior).

The element subdomain type of refined elements are given the same (integer) value as the parent element.

Here are the details of the subdivision of elements (the second phase) of the refinement of "ElmT3n2D" triangles. In phase one the nodes of the element has been permuted so that edge 1 is the longest edge. The following cases can occur: 0, 1, 2, or 3 of the edges has been subdivided by new nodes. Let Ti(k,l,m) be a created refined element with local node numbers k,l and m.

0 marked edges: Copy the old element which gives element T1=(1,2,3), see fig. _________________________________________________________ 1 marked edge: Divide the element into 2 elements, there is only one way to do this. Create elements T1=(3,1,m1) and T2=(2,3,m1), see figure below. By the permutation of edges and the method of marking of new nodes at the longest edges m1 will lie on edge 1.

3______2 

   \ 2 /     m1 is the midpoint of edge 1 (the edge between node 1 and 2).
   1\/m1

   /
_________________________________________________________

2 marked edges: (here the nodes are on edges 1 and 2, could also be 1 and 3). Divide the element into 3 new elements, there are 2 alternative ways to do this. We choose the alternative which will introduce the shortest edge of the two alternatives, (rule of thumb: divide long edges and add short edges): Choose alternative 1 if edge 1-2 is longer than edge 2-3. Alternative 1 is hence always chosen since edge 1 is the longest edge of the element. alt 1: T1=(3,1,m1), T2=(3,m1,m2), T3=(m1,2,m2), alt 2: T1=(3,1,m2), T2=(m2,1,m1), T3=(2,m2,m1), with the number convention below

3__m2__2 

       /
     /m1

   /
_________________________________________________________

3 marked edges: Divide into 4 new elements. There are 4 ways to do this, (one regular and three bisections). Only 2 ways if bisection with the two shorter sides as base are excluded. a) Regular refinement: T1=(1,m1,m3), T2=(m1,2,m2), T3=(m3,m2,3), T4=(m2,m3,m1) b) Bisection refinement with edge 1 as "base": T1=(1,m1,m3), T2=(m1,2,m2), T3=(m1,3,m3), T4=(3,m1,m2) The choice between regular or bisection refinement is determined by setting "setRegBisectOrShort". The choices for this parameters is 0) always regular refinement, 1) always bisection refinement, or 2) the alternative which adds the shortest alternative edge to the new grid.

3__m2__2 

        /
  m3  /m1

    /

Observe that all new and old elements use counter clockwise orientation.

Refinement in 3D:

In 3D, bisection of elements are always used, except for uniform refinement of all edges, in which case regular refinement can be used. By phase 1 of the refinement there is for every tetrahedron to be refined always a node dividing the longest edge of the tetrahedron. The tetrahedron is bisected into two tetrahedra by connecting the node on the longest edge to the opposing edge to the longest edge, (i.e. an edge between the midpoints of edge 1 and 6 with the local edge numbering). The two new tetrahedra are then further subdivided if any of the 5 other edges also have midpoints nodes to be inserted. The order in which these further bisections are done will depend on the length of the edges. For the refinement to result in a regular grid it is necessary that the edges subdividing a face shared by two tetrahedras are drawn consistently for both the involved tetrahedras.

To use regular refinement in 3D it is necessary that all elements and all edges are refined. In regular refinement the 8 new tetrahedra are constructed by first cutting of 4 tetrahedras similar to the parent tetrahedron from the parent tetrahedron, and making a regular refinement of the triangular face. The four remaining tetrahedra are constructed by adding an edge between the nodes of two opposing edges. There are three such possible tetrahedral interior edges. The alternative which adds the shortest edge length is chosen.

Refinement in 1D:

Phase 1 of the refinement is trivial since all the new nodes are interior to the elements and can hence be determined locally in the construction of the refined elements. Up to 4 nodes can be inserted into an element (a segment).

Constructor & Destructor Documentation

GridFEAdT::GridFEAdT ( )
 

"GridFEAdT" can be constructed from a GridFE, if all the elements of the grid are of the same type, where the allowed element types are "ElmB2n2D", "ElmB3n2D", "ElmT3n2D", "ElmT6n2D", "ElmT4n3D" and "ElmT10n3D". Since "GridFEAdT" is derived from "GridFE" can the "GridFE" preprocessors also be used directly to create an initial "GridFEAdT" grid.

GridFEAdT::GridFEAdT ( const GridFE & grid )
 

See documentation of one of the overloaded constructor.

GridFEAdT::GridFEAdT ( const GridFEAdT & grid )
 

See documentation of one of the overloaded constructor.

GridFEAdT::~GridFEAdT ( )
 

Member Function Documentation

GridFEAdT * GridFEAdT::changeGridL2Q ( )
 

from a grid with piece-wise linear elements construct a grid with piece-wise quadratic elements. Works in 1D, 2D and 3D.

GridFEAdT * GridFEAdT::changeGridQ2L ( )
 

The opposite of "changeGridL2Q" (inverse transformation).

bool GridFEAdT::checkChildrenInfo ( )
 

checks that children info is consistent, i.e. that the child of an element has this element as its parent.

bool GridFEAdT::checkElementOrientation ( )
 

computes area/volume of elements and checks that area/volume are positive as they should. (Otherwise the element can be degenerate or the nodes are in wrong order. The function is applicable in both 2D and 3D.

bool GridFEAdT::checkParentInfo ( )
 

checks that the parent info is consistent, i.e., that an element which has parent element p is also a child of p.

void GridFEAdT::computeBoundingBoxes ( )
 

computation of bounding boxes.

GridFEAdT * GridFEAdT::createPartOfGrid ( VecSimple(int) & partition,
int startlevel,
int stoplevel )
 

GridFEAdT * GridFEAdT::createPartOfGrid ( int subdomainno,
int fromlevel )
 

int GridFEAdT::findElm ( Ptv(real) & x,
int level0,
int elm0,
int level1 )
 

See documentation of one of the overloaded functions.

bool GridFEAdT::findElm ( Ptv(real) & x,
int & element ) [inline]
 

See documentation of one of the overloaded functions.

bool GridFEAdT::findElm ( Ptv(real) & x,
int level,
int & element )
 

given a point "x", find in which element the point is in level "level" without a priori info on where the node is. If no level is given the search is performed on this grid.

int GridFEAdT::getChild ( int e,
int child_no )
 

returns the element number of child number "child_no" of element "e".

GridFEAdT * GridFEAdT::getChildGrid ( ) [inline]
 

gets pointer to the child grid (a finer grid) return NULL if no grid or safer: check with "isThisCoarsestGrid"/ "isThisFinestGrid" before calling "getParentGrid" or "getChildGrid".

int GridFEAdT::getChild_eff ( int e,
int child_no ) [inline]
 

more efficient version of "getChild" (skips some checking).

GridFEAdT * GridFEAdT::getCoarsestGrid ( )
 

get a pointer to the coarsest grid in the hierarchy

void GridFEAdT::getEdgeLengthOrder ( VecSimple(int) & order,
int e )
 

computes the order of the lengths of the edges. If the integer sequence (5,2,1,6,4,3) is returned this means that edge 5 was longest, then edge 2 and so on. If the lengths are equal the priority is uniquely decided by the node numbers. See the function "lessThan". The function is only applicable in 3D.

int GridFEAdT::getElmNeighbor ( int e,
int ef_no ) [inline]
 

gets the element number of the neighbor on local node/edge/face in 1D/2D/3D, respectively. The value 0 is returned if no neighbor, i.e. the element is on the outer boundary.

int GridFEAdT::getFaceNo ( int n1,
int n2,
int n3,
int e,
bool safe = false )
 

returns the (local) face number (1-4) which contains global nodes n1, n2, and n3. The bool parameter "safe" chooses between two different algorithms. For the faster algorithm with safe=false then wrong face is returned IF n1, n2, n3, are not nodes of the element. The function is only applicable in 3D.

GridFEAdT * GridFEAdT::getFinestGrid ( )
 

get a pointer to the finest grid in the hierarchy

int GridFEAdT::getFinestGridLevelNo ( )
 

returns the level number of the finest grid level

int GridFEAdT::getFirstChild ( int e ) [inline]
 

returns the element number of the first child of an element.

void GridFEAdT::getGlobNodesOnFace ( int & n1,
int & n2,
int & n3,
int f,
int e )
 

gets the global node numbers of the nodes which are on the local face f in element e. The function is only applicable in 3D.

int GridFEAdT::getGridLevelNo ( ) [virtual]
 

returns the level number in the hierarchy of this grid, where the coarsest level (without parent grid) has level number 1 and the level number for each added child grid to the hierarchy is increased by 1.

Reimplemented from GridFE.

int GridFEAdT::getLocEdgeNo ( int n1,
int n2,
int e )
 

returns the local edge number of the edge with global node numbers n1 and n2. The function is only applicable in 3D.

int GridFEAdT::getLongestEdgeNo ( int e )
 

returns the local edge number of the longest edge. The function is applicable in both 2D and 3D.

real GridFEAdT::getMinEta ( VecSimplest(int) & element_list,
int qualcrit = 1 )
 

returns the smallest value of all the elements in the list of elements.

int GridFEAdT::getNoBoxTests ( ) [inline]
 

returns number of boxtests.

int GridFEAdT::getNoChildren ( int e ) [inline]
 

returns the number of elements this element has been divided into in the child grid.

int GridFEAdT::getNoElmTests ( ) [inline]
 

returns number of barycentric tests.

void GridFEAdT::getNodesOnEdge ( int e,
int edge_no,
int & n1,
int & n2 )
 

gets the two global node numbers of the nodes which are on the local edge "edge_no" in element "e". The function is only applicable in 3D.

int GridFEAdT::getParent ( int rel_level,
int e )
 

See documentation of one of the overloaded functions.

int GridFEAdT::getParent ( int e )
 

The version with one argument returns the element number of the parent element of e, 0 is returned if no parent grid. The version with two arguments returns the parent element rel_level levels up, (rel_level==0 returns the input element number)

GridFEAdT * GridFEAdT::getParentGrid ( ) [inline]
 

gets pointer to the parent grid (a coarser grid).

int GridFEAdT::getParent_eff ( int rel_level,
int e )
 

See documentation of one of the overloaded functions.

int GridFEAdT::getParent_eff ( int e ) [inline]
 

more efficient version, can be used if it has been checked that the input element number is legal, that the grid has parent grid and that the parent information is computed.

int GridFEAdT::getRegBisectOrShort ( ) [inline]
 

(Only 2D grids). Sets and gets the parameter determining which refinement alternative to be used in the case that all 3 edges are refined. The value 0 of the parameter means, "always regular refinement" (4 triangles of same shape as original), value 1 means "always bisection", (longest edge as base), and value 2 means that the alternative of regular and bisection refinement which introduces the shortest new edge is used.

int GridFEAdT::getSecondLongestEdgeNo1 ( int e )
 

returns the second longest edge number, where in 2D it is assumed that edge number 1 is longest, (no assumption in 3D). The function is applicable in both 2D and 3D.

int GridFEAdT::getShortestEdgeNo ( int e )
 

gets the edge number of the shortest edge in element e. The function is applicable in both 2D and 3D.

int GridFEAdT::getShortestEdgeNo1 ( int e )
 

gets the edge number of the shortest edge in element e, where in 2D it is assumed that edge number 1 is longest, (no assumption in 3D). The function is applicable in both 2D and 3D.

GridFE & GridFEAdT::getStartGrid ( ) [inline, virtual]
 

Reimplemented from GridFE.

void GridFEAdT::initNeighbor ( bool alwaysSortEdgesIn2D = false )
 

In 2D and 3D "initNeighbor" reorder the nodes in the element so that the longest edge is first. It also computes the numbers of the element neighbors. In the refinement process "initNeighbor" is called for the old grid, but "initNeighbor" not automatically called for the new refined grid (until the new grid is refined), so if e.g. the method "getElmNeighbor" needs to be used before the grid has been refined then "initNeighbor" must be called.

void GridFEAdT::initSearchStat ( ) [inline]
 

initialization for search statistics set counters to zero.

void GridFEAdT::initSearchStatAllGrids ( )
 

initialization.

bool GridFEAdT::isBoundingBoxesComputed ( ) [inline]
 

check flag.

bool GridFEAdT::isChildrenInfo ( ) [inline]
 

is information about the child grid computed so that getChild can be used?

bool GridFEAdT::isElmNeighbor ( int e,
int elnei )
 

does element "e" have element "elnei" as one of its neighbors?

bool GridFEAdT::isElmNeighborConsistent ( )
 

returns true if the element neighbor information is self consistent. (A neighbor to an element must have the element as its neighbor.) The function is applicable in both 2D and 3D.

bool GridFEAdT::isInsideElm ( Ptv(real) & x,
int element )
 

returns true if the node is inside a given element.

bool GridFEAdT::isNeighborsComputed ( ) [inline]
 

is element-element info computed?

bool GridFEAdT::isNewNodesSet ( ) [inline]
 

is the array new_nodes filled?

bool GridFEAdT::isParentInfo ( ) [inline]
 

is information about the parent grid computed so that getParent can be used?

bool GridFEAdT::isThisCoarsestGrid ( ) [inline]
 

returns true if the grid has no parent grid.

bool GridFEAdT::isThisFinestGrid ( ) [inline]
 

returns true if the grid has no child grid.

GridFEAdT * GridFEAdT::makeCopyOfHierarchy ( const int firstlevel,
const int lastlevel )
 

makes a copy of a part of the gridhierarchy, the two parameters determines the levels in the old grid which will be the first and last levels in the copied grid hierarchy. A pointer to the finest grid of the copied hierarchy is returned.

void GridFEAdT::makeSmoothing ( int nrepetitions = 1,
int qualcrit = 1 )
 

Mesh improvement according to the criterion "qualcrit". Move nodes without indicators so that the form of the elements are improved.

void GridFEAdT::makeStatistics ( Os os )
 

computes some statistics about the elements of the grid.

bool GridFEAdT::ok ( ) const
 

Simply calls GridFE ok

Reimplemented from GridFE.

void GridFEAdT::operator= ( const GridFE & grid )
 

Reimplemented from GridFE.

void GridFEAdT::operator= ( const GridFEAdT & grid )
 

void GridFEAdT::presentGridHier ( Os os )
 

writes info on the grids in the hierarchy.

void GridFEAdT::printBoundary ( Os os )
 

"plotmtv" format of plot of the boundary of the grid, 2D and 3D.

void GridFEAdT::printGrid ( Os os,
const int sbdtype ) const
 

See documentation of one of the overloaded functions.

void GridFEAdT::printGrid ( Os os )
 

prints a picture of the grid in .mtv-format, 1D, 2D, 3D. The overloaded version taking a 2nd argument, subdomain type (sbdtype) prints an mtv plot of elements with subdomain sbdtype, 2D and 3D.

void GridFEAdT::printSearchStatAllGrids ( Os os )
 

prints the result of the search.

GridFEAdT * GridFEAdT::refine ( const VecSimple(int) & mark_elms )
 

See documentation of one of the overloaded functions.

GridFEAdT * GridFEAdT::refine ( const VecSimple(bool) & mark_elms,
const int ref_method )
 

See documentation of one of the overloaded functions.

GridFEAdT * GridFEAdT::refineLongEdges ( const real break_ratio )
  

       refines all edges with length longer than break_ratio*longest
       edge, where |longest edge| is the length of the longest edge
       edge, where longest edge| is the length of the longest edge
       edge, where longest edge is the length of the longest edge
in the grid. This refinement function will construct grids where all elements will be of approximately the same size.

GridFEAdT * GridFEAdT::refineUniformly ( const int ref_method = 3,
bool regref = false )
 

refines all elements, the parameter "ref_method" is used as in "refine", if the parameter "regref" is true, then regular refinement will be used if in addition ref_method==6 for 3D grids or ref_method==3 for 2D grids.

void GridFEAdT::removeBoundingBoxes ( )
 

frees the space occupied by the bounding boxes.

void GridFEAdT::removeChildGrid ( )
 

removal of pointer to child grid and its information. Because the method removes handles/pointers to the other grids in the hierarchy, this may lead to those grids being deleted depending on whether other handles are referring to that grid.

void GridFEAdT::removeChildrenInfo ( )
 

removal of pointer to "next_grid" and children info

void GridFEAdT::removeHierInfo ( )
 

remove the coupling children, "parent,prev_" and "next_grid". Because the method removes handles/pointers to the other grids in the hierarchy, this may lead to those grids being deleted depending on whether other handles are referring to that grid.

void GridFEAdT::removeInteriorIndicators ( )
 

removes all the indicators which are not on the boundary of the domain, useful if refinement has caused unwanted indicators. (A node inserted at the midpoint of an edge will get an indicator set to ON if both the endpoints nodes have that indicator set to ON. The function is applicable in both 2D and 3D.

void GridFEAdT::removeNeighborInfo ( )
 

removes neighbor data, i.e., "elm_neigh" and "new_nodes"

void GridFEAdT::removeNewNodeInfo ( )
 

removes the "new_nodes" data

void GridFEAdT::removeParentGrid ( )
 

removal of parent grid and its information. Because the method removes handles/pointers to the other grids in the hierarchy, this may lead to those grids being deleted depending on whether other handles are referring to that grid.

void GridFEAdT::removeParentInfo ( )
 

removal of pointer to parent, prev_grid

void GridFEAdT::setNodeForEqualTest ( bool flag ) [inline]
 

void GridFEAdT::setRegBisectOrShort ( int method ) [inline]
 

see the documentation function for "getRegBisectOrShort".

bool GridFEAdT::simpleSearch ( Ptv(real) & x,
int & element )
 

returns the element number a given point is inside

void GridFEAdT::smoothNeighbors ( int node,
int qualcrit = 1 )
 

smooths the neighbor nodes of a node.

void GridFEAdT::smoothNode ( int node,
int qualcrit = 1 )
 

moves one node.

bool GridFEAdT::useNodeForEqualTest ( ) [inline]
 

Member Data Documentation

ToolsElmT3n2D GridFEAdT::FET3
 

ToolsElmT4n3D GridFEAdT::FET4
 

The documentation for this class was generated from the following file:
Copyright © 2003 inuTech GmbH. All rights reserved.