Skip to content
GitLab
Projects
Groups
Snippets
/
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
Menu
Open sidebar
Aland, Sebastian
amdis
Commits
9bb9b920
Commit
9bb9b920
authored
Jul 30, 2010
by
Thomas Witkowski
Browse files
Fixed some problems in 3D refinement with reversed mesh traversel stratagey.
parent
acfe9a60
Changes
15
Hide whitespace changes
Inline
Side-by-side
AMDiS/src/CoarseningManager3d.cc
View file @
9bb9b920
...
...
@@ -257,7 +257,7 @@ namespace AMDiS {
edge
[
0
][
0
],
edge
[
1
][
0
],
neigh
->
getIndex
(),
neigh
->
getDOF
(
0
,
0
),
neigh
->
getDOF
(
1
,
0
),
neigh
->
getDOF
(
2
,
0
),
neigh
->
getDOF
(
3
,
0
));
}
edge_no
=
Tetrahedron
::
edgeOfD
OF
s
[
j
][
k
];
edge_no
=
Tetrahedron
::
edgeOfD
of
s
[
j
][
k
];
coarsenList
->
setCoarsePatch
(
*
n_neigh
,
edge_no
==
0
);
/****************************************************************************/
...
...
AMDiS/src/Debug.cc
View file @
9bb9b920
...
...
@@ -231,21 +231,22 @@ namespace AMDiS {
void
printInfoByDof
(
FiniteElemSpace
*
feSpace
,
DegreeOfFreedom
dof
)
{
FUNCNAME
(
"debug::printInfoByDof()"
);
Element
*
el
=
getDofIndexElement
(
feSpace
,
dof
);
Element
*
parEl
=
getLevel0ParentElement
(
feSpace
->
getMesh
(),
el
);
std
::
cout
<<
"[DBG] DOF-INFO: dof = "
<<
dof
<<
" elidx = "
<<
el
->
getIndex
()
<<
" pelidx = "
<<
parEl
->
getIndex
()
<<
std
::
endl
;
MSG
(
"[DBG] DOF-INFO: dof = %d elidx = %d pelidx = %d
\n
"
,
dof
,
el
->
getIndex
(),
parEl
->
getIndex
());
TraverseStack
stack
;
ElInfo
*
elInfo
=
stack
.
traverseFirst
(
feSpace
->
getMesh
(),
-
1
,
Mesh
::
CALL_EVERY_EL_PREORDER
);
while
(
elInfo
)
{
if
(
elInfo
->
getElement
()
->
getIndex
()
==
parEl
->
getIndex
())
std
::
cout
<<
"[DBG] EL INFO TO
"
<<
parEl
->
getIndex
()
<<
": "
<<
" type = "
<<
elInfo
->
getType
()
<<
std
::
endl
;
if
(
elInfo
->
getElement
()
->
getIndex
()
==
parEl
->
getIndex
())
{
MSG
(
"[DBG] EL INFO TO
%d: type = %d
\n
"
,
parEl
->
getIndex
()
,
elInfo
->
getType
());
}
elInfo
=
stack
.
traverseNext
(
elInfo
);
}
}
...
...
@@ -470,6 +471,37 @@ namespace AMDiS {
}
int
getLocalNeighbourIndex
(
Mesh
*
mesh
,
int
elIndex
,
int
neighIndex
)
{
FUNCNAME
(
"debug::getLocalNeighbourIndex()"
);
TraverseStack
stack
;
ElInfo
*
elInfo
=
stack
.
traverseFirst
(
mesh
,
-
1
,
Mesh
::
CALL_EVERY_EL_PREORDER
|
Mesh
::
FILL_NEIGH
);
while
(
elInfo
)
{
if
(
elInfo
->
getElement
()
->
getIndex
()
==
elIndex
)
{
int
returnValue
=
-
1
;
for
(
int
i
=
0
;
i
<=
mesh
->
getDim
();
i
++
)
{
if
(
elInfo
->
getNeighbour
(
i
))
{
MSG
(
"NEIGH %d of El-Idx %d: %d
\n
"
,
i
,
elIndex
,
elInfo
->
getNeighbour
(
i
)
->
getIndex
());
}
else
{
MSG
(
"NEIGH %d of El-Idx %d: %d
\n
"
,
i
,
elIndex
,
-
1
);
}
if
(
elInfo
->
getNeighbour
(
i
)
&&
elInfo
->
getNeighbour
(
i
)
->
getIndex
()
==
neighIndex
)
returnValue
=
i
;
}
return
returnValue
;
}
elInfo
=
stack
.
traverseNext
(
elInfo
);
}
return
-
2
;
}
void
createSortedDofs
(
Mesh
*
mesh
,
ElementIdxToDofs
&
elMap
)
{
FUNCNAME
(
"debug::dbgCreateElementMap()"
);
...
...
AMDiS/src/Debug.h
View file @
9bb9b920
...
...
@@ -135,6 +135,8 @@ namespace AMDiS {
void
printElementHierarchie
(
Mesh
*
mesh
,
int
elIndex
);
int
getLocalNeighbourIndex
(
Mesh
*
mesh
,
int
elIndex
,
int
neighIndex
);
/** \brief
* Traverse a mesh and store for each element all its vertex DOFs in local sorted
* order (by values).
...
...
AMDiS/src/MacroReader.cc
View file @
9bb9b920
...
...
@@ -1346,7 +1346,7 @@ namespace AMDiS {
if
(
!
mesh
->
getNumberOfDOFs
(
EDGE
)
&&
nei
->
getIndex
()
<
mel_index
)
return
false
;
edge_no
=
Tetrahedron
::
edgeOfD
OF
s
[
j
][
k
];
edge_no
=
Tetrahedron
::
edgeOfD
of
s
[
j
][
k
];
TEST_EXIT
(
*
n_neigh
<
max_no_list_el
)
(
"too many neigbours for local list
\n
"
);
...
...
@@ -1428,7 +1428,7 @@ namespace AMDiS {
if
(
nei
->
getIndex
()
<
mel_index
)
return
false
;
edge_no
=
Tetrahedron
::
edgeOfD
OF
s
[
j
][
k
];
edge_no
=
Tetrahedron
::
edgeOfD
of
s
[
j
][
k
];
TEST_EXIT
(
*
n_neigh
<
max_no_list_el
)(
"too many neigbours for local list
\n
"
);
...
...
@@ -1440,7 +1440,7 @@ namespace AMDiS {
(
"dof %d on element %d is already set, but not on element %d
\n
"
,
node
+
edge_no
,
nei
->
getIndex
(),
mel_index
);
nei
->
element
->
setDOF
(
node
+
edge_no
,
edge_dof
);
nei
->
element
->
setDOF
(
node
+
edge_no
,
edge_dof
);
}
if
(
next_el
[
edge_no
][
0
]
!=
opp_v
)
{
...
...
AMDiS/src/MeshStructure.cc
View file @
9bb9b920
...
...
@@ -308,6 +308,33 @@ namespace AMDiS {
}
void
MeshStructure
::
print
(
bool
resetCode
)
{
FUNCNAME
(
"MeshStructure::print()"
);
std
::
stringstream
oss
;
if
(
empty
())
{
oss
<<
"-"
<<
std
::
endl
;
}
else
{
if
(
resetCode
)
reset
();
bool
cont
=
true
;
while
(
cont
)
{
if
(
isLeafElement
())
oss
<<
"0"
;
else
oss
<<
"1"
;
cont
=
nextElement
();
}
}
MSG
(
"Mesh structure code: %s
\n
"
,
oss
.
str
().
c_str
());
}
bool
MeshStructure
::
compare
(
MeshStructure
&
other
)
{
return
(
other
.
getCode
()
==
code
);
...
...
AMDiS/src/MeshStructure.h
View file @
9bb9b920
...
...
@@ -114,29 +114,7 @@ namespace AMDiS {
int
macroElIndex
=
-
1
);
/// Prints the mesh structure code.
void
print
()
{
FUNCNAME
(
"MeshStructure::print()"
);
std
::
stringstream
oss
;
if
(
empty
())
{
oss
<<
"-"
<<
std
::
endl
;
}
else
{
reset
();
bool
cont
=
true
;
while
(
cont
)
{
if
(
isLeafElement
())
oss
<<
"0"
;
else
oss
<<
"1"
;
cont
=
nextElement
();
}
}
MSG
(
"Mesh structure code: %s
\n
"
,
oss
.
str
().
c_str
());
}
void
print
(
bool
resetCode
=
true
);
/// Returns the mesh structure code.
inline
const
std
::
vector
<
unsigned
long
int
>&
getCode
()
...
...
AMDiS/src/RefinementManager.cc
View file @
9bb9b920
...
...
@@ -53,7 +53,7 @@ namespace AMDiS {
stack
->
traverseFirst
(
mesh
,
-
1
,
Mesh
::
CALL_LEAF_EL
|
Mesh
::
FILL_NEIGH
|
Mesh
::
FILL_BOUND
);
while
(
elInfo
)
{
if
(
elInfo
->
getElement
()
->
getMark
()
>
0
)
{
if
(
elInfo
->
getElement
()
->
getMark
()
>
0
)
{
doMoreRecursiveRefine
=
doMoreRecursiveRefine
||
(
elInfo
->
getElement
()
->
getMark
()
>
1
);
elInfo
=
refineFunction
(
elInfo
);
...
...
AMDiS/src/RefinementManager3d.cc
View file @
9bb9b920
...
...
@@ -146,13 +146,13 @@ namespace AMDiS {
int
el_type
=
ref_list
->
getType
(
index
);
int
n_type
=
0
;
int
dir
,
adjc
,
i
,
j
,
i_neigh
,
j_neigh
;
int
node0
,
node1
,
opp
_v
=
0
;
int
node0
,
node1
,
opp
Vertex
=
0
;
for
(
dir
=
0
;
dir
<
2
;
dir
++
)
{
neigh
=
ref_list
->
getNeighbourElement
(
index
,
dir
);
if
(
neigh
)
{
n_type
=
ref_list
->
getType
(
ref_list
->
getNeighbourNr
(
index
,
dir
));
opp
_v
=
ref_list
->
getOppVertex
(
index
,
dir
);
opp
Vertex
=
ref_list
->
getOppVertex
(
index
,
dir
);
}
if
(
!
neigh
||
neigh
->
isLeaf
())
{
...
...
@@ -199,7 +199,7 @@ namespace AMDiS {
j
=
Tetrahedron
::
adjacentChild
[
adjc
][
i
];
i_neigh
=
Tetrahedron
::
nChildFace
[
el_type
][
i
][
dir
];
j_neigh
=
Tetrahedron
::
nChildFace
[
n_type
][
j
][
opp
_v
-
2
];
j_neigh
=
Tetrahedron
::
nChildFace
[
n_type
][
j
][
opp
Vertex
-
2
];
/****************************************************************************/
/* adjust dof pointer in the edge in the common face of el and neigh and */
...
...
@@ -208,7 +208,7 @@ namespace AMDiS {
if
(
mesh
->
getNumberOfDOFs
(
EDGE
))
{
node0
=
mesh
->
getNode
(
EDGE
)
+
Tetrahedron
::
nChildEdge
[
el_type
][
i
][
dir
];
node1
=
mesh
->
getNode
(
EDGE
)
+
Tetrahedron
::
nChildEdge
[
n_type
][
j
][
opp
_v
-
2
];
node1
=
mesh
->
getNode
(
EDGE
)
+
Tetrahedron
::
nChildEdge
[
n_type
][
j
][
opp
Vertex
-
2
];
TEST_EXIT_DBG
(
neigh
->
getChild
(
j
)
->
getDOF
(
node1
))
(
"no dof on neighbour %d at node %d
\n
"
,
...
...
@@ -267,9 +267,8 @@ namespace AMDiS {
edge
[
i
]
=
const_cast
<
int
*>
(
el_info
->
getElement
()
->
getDOF
(
i
));
if
(
getRefinePatch
(
&
elinfo
,
edge
,
0
,
refList
,
&
n_neigh
))
{
/****************************************************************************/
/* domain's boundary was reached while looping around the refinement edge */
/****************************************************************************/
// Domain's boundary was reached while looping around the refinement edge.
getRefinePatch
(
&
elinfo
,
edge
,
1
,
refList
,
&
n_neigh
);
}
...
...
@@ -383,173 +382,209 @@ namespace AMDiS {
int
RefinementManager3d
::
getRefinePatch
(
ElInfo
**
el_info
,
DegreeOfFreedom
*
edge
[
2
],
int
dir
,
int
dir
ection
,
RCNeighbourList
*
refineList
,
int
*
n_neigh
)
{
FUNCNAME
(
"RefinementManager3d::getRefinePatch()"
);
int
i
,
j
,
k
;
int
localNeighbour
=
3
-
direction
;
Tetrahedron
*
el
=
dynamic_cast
<
Tetrahedron
*>
(
const_cast
<
Element
*>
((
*
el_info
)
->
getElement
()));
if
((
*
el_info
)
->
getNeighbour
(
3
-
di
r
)
==
NULL
)
if
((
*
el_info
)
->
getNeighbour
(
localNeighbou
r
)
==
NULL
)
return
1
;
int
opp_v
=
(
*
el_info
)
->
getOppVertex
(
3
-
dir
);
ElInfo
*
neigh_info
=
stack
->
traverseNeighbour3d
((
*
el_info
),
3
-
dir
);
int
neigh_el_type
=
neigh_info
->
getType
();
int
oppVertex
=
(
*
el_info
)
->
getOppVertex
(
localNeighbour
);
int
testIndex
=
(
*
el_info
)
->
getNeighbour
(
localNeighbour
)
->
getIndex
();
ElInfo
*
neighInfo
=
stack
->
traverseNeighbour3d
((
*
el_info
),
localNeighbour
);
int
neighElType
=
neighInfo
->
getType
();
TEST_EXIT_DBG
(
neighInfo
->
getElement
()
->
getIndex
()
==
testIndex
)
(
"Should not happen!
\n
"
);
Tetrahedron
*
neigh
=
dynamic_cast
<
Tetrahedron
*>
(
const_cast
<
Element
*>
(
neigh_info
->
getElement
()));
dynamic_cast
<
Tetrahedron
*>
(
const_cast
<
Element
*>
(
neighInfo
->
getElement
()));
int
vertices
=
mesh
->
getGeo
(
VERTEX
);
while
(
neigh
!=
el
)
{
for
(
j
=
0
;
j
<
vertices
;
j
++
)
if
(
neigh
->
getDOF
(
j
)
==
edge
[
0
])
// === Determine the common edge of the element and its neighbour. ===
int
edgeDof0
,
edgeDof1
;
for
(
edgeDof0
=
0
;
edgeDof0
<
vertices
;
edgeDof0
++
)
if
(
neigh
->
getDOF
(
edgeDof0
)
==
edge
[
0
])
break
;
for
(
k
=
0
;
k
<
vertices
;
k
++
)
if
(
neigh
->
getDOF
(
k
)
==
edge
[
1
])
for
(
edgeDof1
=
0
;
edgeDof1
<
vertices
;
edgeDof1
++
)
if
(
neigh
->
getDOF
(
edgeDof1
)
==
edge
[
1
])
break
;
if
(
j
>
3
||
k
>
3
)
{
for
(
j
=
0
;
j
<
vertices
;
j
++
)
if
(
mesh
->
associated
(
neigh
->
getDOF
(
j
,
0
),
edge
[
0
][
0
]))
if
(
edgeDof0
>
3
||
edgeDof1
>
3
)
{
for
(
edgeDof0
=
0
;
edgeDof0
<
vertices
;
edgeDof0
++
)
if
(
mesh
->
associated
(
neigh
->
getDOF
(
edgeDof0
,
0
),
edge
[
0
][
0
]))
break
;
for
(
k
=
0
;
k
<
vertices
;
k
++
)
if
(
mesh
->
associated
(
neigh
->
getDOF
(
k
,
0
),
edge
[
1
][
0
]))
for
(
edgeDof1
=
0
;
edgeDof1
<
vertices
;
edgeDof1
++
)
if
(
mesh
->
associated
(
neigh
->
getDOF
(
edgeDof1
,
0
),
edge
[
1
][
0
]))
break
;
if
(
j
>
3
||
k
>
3
)
{
for
(
j
=
0
;
j
<
vertices
;
j
++
)
if
(
mesh
->
indirectlyAssociated
(
neigh
->
getDOF
(
j
,
0
),
edge
[
0
][
0
]))
if
(
edgeDof0
>
3
||
edgeDof1
>
3
)
{
for
(
edgeDof0
=
0
;
edgeDof0
<
vertices
;
edgeDof0
++
)
if
(
mesh
->
indirectlyAssociated
(
neigh
->
getDOF
(
edgeDof0
,
0
),
edge
[
0
][
0
]))
break
;
for
(
k
=
0
;
k
<
vertices
;
k
++
)
if
(
mesh
->
indirectlyAssociated
(
neigh
->
getDOF
(
k
,
0
),
edge
[
1
][
0
]))
for
(
edgeDof1
=
0
;
edgeDof1
<
vertices
;
edgeDof1
++
)
if
(
mesh
->
indirectlyAssociated
(
neigh
->
getDOF
(
edgeDof1
,
0
),
edge
[
1
][
0
]))
break
;
TEST_EXIT_DBG
(
j
<
vertices
&&
k
<
vertices
)
(
"dof %d or dof %d not found on element %d with nodes (%d %d %d %d)
\n
"
,
edge
[
0
][
0
],
edge
[
1
][
0
],
neigh
->
getIndex
(),
neigh
->
getDOF
(
0
,
0
),
neigh
->
getDOF
(
1
,
0
),
neigh
->
getDOF
(
2
,
0
),
neigh
->
getDOF
(
3
,
0
));
TEST_EXIT_DBG
(
edgeDof0
<
vertices
&&
edgeDof1
<
vertices
)
(
"dof %d or dof %d not found on element %d with nodes (%d %d %d %d)
\n
"
,
edge
[
0
][
0
],
edge
[
1
][
0
],
neigh
->
getIndex
(),
neigh
->
getDOF
(
0
,
0
),
neigh
->
getDOF
(
1
,
0
),
neigh
->
getDOF
(
2
,
0
),
neigh
->
getDOF
(
3
,
0
));
}
}
TEST_EXIT_DBG
(
j
<
mesh
->
getGeo
(
VERTEX
)
&&
k
<
mesh
->
getGeo
(
VERTEX
))
TEST_EXIT_DBG
(
edgeDof0
<
vertices
&&
edgeDof1
<
vertices
)
(
"dof %d or dof %d not found on element %d with nodes (%d %d %d %d)
\n
"
,
edge
[
0
][
0
],
edge
[
1
][
0
],
neigh
->
getIndex
(),
neigh
->
getDOF
(
0
,
0
),
neigh
->
getDOF
(
1
,
0
),
neigh
->
getDOF
(
2
,
0
),
neigh
->
getDOF
(
3
,
0
));
edge
[
0
][
0
],
edge
[
1
][
0
],
neigh
->
getIndex
(),
neigh
->
getDOF
(
0
,
0
),
neigh
->
getDOF
(
1
,
0
),
neigh
->
getDOF
(
2
,
0
),
neigh
->
getDOF
(
3
,
0
));
int
edgeNo
=
Tetrahedron
::
edgeOfDofs
[
edgeDof0
][
edgeDof1
];
if
(
edgeNo
)
{
// Only 0 can be a compatible commen refinement edge. Thus, neigh has not
// a compatible refinement edge. Refine it first.
int
edge_no
=
Tetrahedron
::
edgeOfDOFs
[
j
][
k
];
if
(
edge_no
)
{
/****************************************************************************/
/* neigh has not a compatible refinement edge */
/****************************************************************************/
neigh
->
setMark
(
max
(
neigh
->
getMark
(),
1
));
neigh_info
=
refineFunction
(
neigh_info
);
/****************************************************************************/
/
* n
ow, go to a child at the edge and determine the opposite vertex
for */
/
*
this child; continue the looping around the edge with this
element */
/
****************************************************************************/
neighInfo
=
refineFunction
(
neighInfo
);
/
/ === N
ow, go to a child at the edge and determine the opposite vertex
===
/
/ === for
this child; continue the looping around the edge with this
===
/
/ === element. ===
neigh_info
=
stack
->
traverseNext
(
neigh_info
);
neigh_el_type
=
neigh_info
->
getType
();
neighInfo
=
stack
->
traverseNext
(
neighInfo
);
neighElType
=
neighInfo
->
getType
();
bool
reverseMode
=
stack
->
getTraverseFlag
().
isSet
(
Mesh
::
CALL_REVERSE_MODE
);
switch
(
edge
_n
o
)
{
switch
(
edge
N
o
)
{
case
1
:
opp_v
=
opp_v
==
1
?
3
:
2
;
if
(
reverseMode
)
{
neighInfo
=
stack
->
traverseNext
(
neighInfo
);
neighElType
=
neighInfo
->
getType
();
}
oppVertex
=
(
oppVertex
==
1
?
3
:
2
);
break
;
case
2
:
opp_v
=
opp_v
==
2
?
1
:
3
;
if
(
reverseMode
)
{
neighInfo
=
stack
->
traverseNext
(
neighInfo
);
neighElType
=
neighInfo
->
getType
();
}
oppVertex
=
(
oppVertex
==
2
?
1
:
3
);
break
;
case
3
:
neigh_info
=
stack
->
traverseNext
(
neigh_info
);
neigh_el_type
=
neigh_info
->
getType
();
if
(
neigh_el_type
!=
1
)
opp_v
=
opp_v
==
0
?
3
:
2
;
if
(
!
reverseMode
)
{
neighInfo
=
stack
->
traverseNext
(
neighInfo
);
neighElType
=
neighInfo
->
getType
();
}
if
(
neighElType
!=
1
)
oppVertex
=
(
oppVertex
==
0
?
3
:
2
);
else
opp
_v
=
opp
_v
==
0
?
3
:
1
;
opp
Vertex
=
(
opp
Vertex
==
0
?
3
:
1
)
;
break
;
case
4
:
neigh_info
=
stack
->
traverseNext
(
neigh_info
);
neigh_el_type
=
neigh_info
->
getType
();
if
(
neigh_el_type
!=
1
)
opp_v
=
opp_v
==
0
?
3
:
1
;
if
(
!
reverseMode
)
{
neighInfo
=
stack
->
traverseNext
(
neighInfo
);
neighElType
=
neighInfo
->
getType
();
}
if
(
neighElType
!=
1
)
oppVertex
=
(
oppVertex
==
0
?
3
:
1
);
else
opp
_v
=
opp
_v
==
0
?
3
:
2
;
opp
Vertex
=
(
opp
Vertex
==
0
?
3
:
2
)
;
break
;
case
5
:
if
(
neigh_el_type
!=
1
)
{
neigh_info
=
stack
->
traverseNext
(
neigh_info
);
neigh_el_type
=
neigh_info
->
getType
();
if
(
neighElType
!=
1
)
{
if
(
!
reverseMode
)
{
neighInfo
=
stack
->
traverseNext
(
neighInfo
);
neighElType
=
neighInfo
->
getType
();
}
}
opp
_v
=
3
;
opp
Vertex
=
3
;
break
;
}
neigh
=
dynamic_cast
<
Tetrahedron
*>
(
const_cast
<
Element
*>
(
neigh
_i
nfo
->
getElement
()));
dynamic_cast
<
Tetrahedron
*>
(
const_cast
<
Element
*>
(
neigh
I
nfo
->
getElement
()));
}
else
{
/****************************************************************************/
/* neigh is compatible devisible; put neigh to the list of patch elements; */
/* go to next neighbour */
/****************************************************************************/
// Neigh is compatible devisible. Put neigh to the list of patch elements
// and go to next neighbour.
TEST_EXIT_DBG
(
*
n_neigh
<
mesh
->
getMaxEdgeNeigh
())
(
"too many neighbours %d in refine patch
\n
"
,
*
n_neigh
);
refineList
->
setElement
(
*
n_neigh
,
neigh
);
refineList
->
setElType
(
*
n_neigh
,
neigh_el_type
);
/****************************************************************************/
/* we have to go back to the starting element via opp_v values */
/* correct information is produce by get_neigh_on_patch() */
/****************************************************************************/
refineList
->
setOppVertex
(
*
n_neigh
,
0
,
opp_v
);
refineList
->
setElType
(
*
n_neigh
,
neighElType
);
++*
n_neigh
;
// We have to go back to the starting element via oppVertex values.
if
(
opp_v
!=
3
)
i
=
3
;
else
i
=
2
;
refineList
->
setOppVertex
(
*
n_neigh
,
0
,
oppVertex
);
if
(
neigh_info
->
getNeighbour
(
i
))
{
opp_v
=
neigh_info
->
getOppVertex
(
i
);
neigh_info
=
stack
->
traverseNeighbour3d
(
neigh_info
,
i
);
neigh_el_type
=
neigh_info
->
getType
();
(
*
n_neigh
)
++
;
int
i
=
(
oppVertex
!=
3
?
3
:
2
);
if
(
neighInfo
->
getNeighbour
(
i
))
{
oppVertex
=
neighInfo
->
getOppVertex
(
i
);
int
testIndex
=
neighInfo
->
getNeighbour
(
i
)
->
getIndex
();
neighInfo
=
stack
->
traverseNeighbour3d
(
neighInfo
,
i
);
TEST_EXIT_DBG
(
neighInfo
->
getElement
()
->
getIndex
()
==
testIndex
)
(
"Should not happen!
\n
"
);
neighElType
=
neighInfo
->
getType
();
neigh
=
dynamic_cast
<
Tetrahedron
*>
(
const_cast
<
Element
*>
(
neigh
_i
nfo
->
getElement
()));
}
else
dynamic_cast
<
Tetrahedron
*>
(
const_cast
<
Element
*>
(
neigh
I
nfo
->
getElement
()));
}
else
{
break
;
}
}
}
if
(
neigh
==
el
)
{
(
*
el_info
)
=
neigh_info
;
(
*
el_info
)
=
neighInfo
;
return
0
;
}
/****************************************************************************/
/* the domain's boundary is reached; loop back to the starting el */
/****************************************************************************/
// The domain's boundary is reached. Loop back to the starting el.
i
=
*
n_neigh
-
1
;
opp
_v
=
refineList
->
getOppVertex
(
i
,
0
);
int
i
=
*
n_neigh
-
1
;
opp
Vertex
=
refineList
->
getOppVertex
(
i
,
0
);
do
{
TEST_EXIT_DBG
(
neigh
_i
nfo
->
getNeighbour
(
opp
_v
)
&&
i
>
0
)
TEST_EXIT_DBG
(
neigh
I
nfo
->
getNeighbour
(
opp
Vertex
)
&&
i
>
0
)
(
"While looping back domains boundary was reached or i == 0
\n
"
);
opp_v
=
refineList
->
getOppVertex
(
i
--
,
0
);
neigh_info
=
stack
->
traverseNeighbour3d
(
neigh_info
,
opp_v
);
}
while
(
neigh_info
->
getElement
()
!=
el
);
oppVertex
=
refineList
->
getOppVertex
(
i
--
,
0
);
int
testIndex
=
neighInfo
->
getNeighbour
(
oppVertex
)
->
getIndex
();
neighInfo
=
stack
->
traverseNeighbour3d
(
neighInfo
,
oppVertex
);
int
edgeDof0
,
edgeDof1
;
for
(
edgeDof0
=
0
;
edgeDof0
<
vertices
;
edgeDof0
++
)
if
(
neigh
->
getDOF
(
edgeDof0
)
==
edge
[
0
])
break
;
for
(
edgeDof1
=
0
;
edgeDof1
<
vertices
;
edgeDof1
++
)
if
(
neigh
->
getDOF
(
edgeDof1
)
==
edge
[
1
])
break
;
TEST_EXIT_DBG
(
neighInfo
->
getElement
()
->
getIndex
()
==
testIndex
)
(
"Should not happen!
\n
"
);
}
while
(
neighInfo
->
getElement
()
!=
el
);
(
*
el_info
)
=
neigh
_i
nfo
;
(
*
el_info
)
=
neigh
I
nfo
;
return
1
;
}
...
...
@@ -565,9 +600,8 @@ namespace AMDiS {
if
(
el_info
->
getElement
()
->
getMark
()
<=
0
)
return
el_info
;
/* element may not be refined */
/****************************************************************************/
/* get memory for a list of all elements at the refinement edge */
/****************************************************************************/
// === Get memory for a list of all elements at the refinement edge. ===
RCNeighbourList
*
ref_list
=
new
RCNeighbourList
(
mesh
->
getMaxEdgeNeigh
());
ref_list
->
setElType
(
0
,
el_info
->
getType
());
ref_list
->
setElement
(
0
,
el_info
->
getElement
());
...
...
@@ -577,37 +611,31 @@ namespace AMDiS {
el_info
->
getProjection
(
0
)
->
getType
()
==
VOLUME_PROJECTION
)
newCoords
=
true
;
/****************************************************************************/
/* give the refinement edge the right orientation */
/****************************************************************************/
if
(
el_info
->
getElement
()
->
getDOF
(
0
,
0
)
<
el_info
->
getElement
()
->
getDOF
(
1
,
0
))
{
edge
[
0
]
=
const_cast
<
int
*>
(
el_info
->
getElement
()
->
getDOF
(
0
));
edge
[
1
]
=
const_cast
<
int
*>
(
el_info
->
getElement
()
->
getDOF
(
1
));
// === Give the refinement edge the right orientation. ===
if
(
el_info
->
getElement
()
->
getDOF
(
0
,
0
)
<
el_info
->
getElement
()
->
getDOF
(
1
,
0
))
{
edge
[
0
]
=
const_cast
<
DegreeOfFreedom
*>
(
el_info
->
getElement
()
->
getDOF
(
0
));
edge
[
1
]
=
const_cast
<
DegreeOfFreedom
*>
(
el_info
->
getElement
()
->
getDOF
(
1
));
}
else
{
edge
[
1
]
=
const_cast
<
int
*>
(
el_info
->
getElement
()
->
getDOF
(
0
));
edge
[
0
]
=
const_cast
<
int
*>
(
el_info
->
getElement
()
->
getDOF
(
1
));
edge
[
1
]
=
const_cast
<
DegreeOfFreedom
*>
(
el_info
->
getElement
()
->
getDOF
(
0
));
edge
[
0
]
=
const_cast
<
DegreeOfFreedom
*>
(
el_info
->
getElement
()
->
getDOF
(
1
));
}
/****************************************************************************/
/
* get the refinement patch */
/****************************************************************************/
/
/ === Traverse and refine the refinement patch. ====
if
(
getRefinePatch
(
&
el_info
,
edge
,
0
,
ref_list
,
&
n_neigh
))
{
/****************************************************************************/
/* domain's boundary was reached while looping around the refinement edge */
/****************************************************************************/
// Domain's boundary was reached while looping around the refinement edge