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
amdis
amdis-core
Commits
9379904a
Commit
9379904a
authored
May 24, 2018
by
Praetorius, Simon
Browse files
rebased on develop and cleaned up
parent
ea53bf87
Changes
5
Hide whitespace changes
Inline
Side-by-side
src/amdis/Marker.hpp
View file @
9379904a
#pragma once
// TODO: Cleanup of copied comments
#include
<string>
#include
<dune/grid/common/grid.hh>
...
...
@@ -10,7 +10,7 @@
namespace
AMDiS
{
/**
* \ingroup Adaption
*
...
...
@@ -20,60 +20,56 @@ namespace AMDiS {
template
<
class
Traits
>
class
Marker
{
protected:
using
GlobalBasis
=
typename
Traits
::
GlobalBasis
;
using
GridView
=
typename
GlobalBasis
::
GridView
;
using
Grid
=
typename
GridView
::
Grid
;
using
IndexSet
=
typename
GridView
::
IndexSet
;
using
Element
=
typename
GridView
::
template
Codim
<
0
>
::
Entity
;
using
Est
Type
=
std
::
vector
<
double
>
;
using
Est
imates
=
std
::
vector
<
double
>
;
public:
/// Constructor.
Marker
()
{}
/// Constructor.
Marker
(
std
::
string
name_
,
std
::
string
component_
,
const
EstType
&
est_
,
std
::
shared_ptr
<
Grid
>
grid_
)
:
name
(
name_
),
component
(
component_
),
grid
(
grid_
),
est
(
est_
),
maximumMarking
(
false
),
p
(
2
),
info
(
10
),
maxRefineLevel
(
-
1
),
minRefineLevel
(
-
1
),
refineAllowed
(
true
),
coarsenAllowed
(
false
)
Marker
(
std
::
string
name
,
std
::
string
component
,
Estimates
const
&
est
,
std
::
shared_ptr
<
Grid
>
const
&
grid
)
:
name_
(
name
)
,
component_
(
component
)
,
grid_
(
grid
)
,
est_
(
est
)
,
maximumMarking_
(
false
)
{
Parameters
::
get
(
name
+
"->p"
,
p
);
Parameters
::
get
(
name
+
"->info"
,
info
);
Parameters
::
get
(
name
+
"->max refinement level"
,
maxRefineLevel
);
Parameters
::
get
(
name
+
"->min refinement level"
,
minRefineLevel
);
Parameters
::
get
(
name
_
+
"->p"
,
p
_
);
Parameters
::
get
(
name
_
+
"->info"
,
info
_
);
Parameters
::
get
(
name
_
+
"->max refinement level"
,
maxRefineLevel
_
);
Parameters
::
get
(
name
_
+
"->min refinement level"
,
minRefineLevel
_
);
}
/// destructor
virtual
~
Marker
()
{}
/// Marks element with newMark. If \ref maximumMarking is set, the element
/// Marks element with newMark. If \ref maximumMarking
_
is set, the element
/// is marked only if the new mark is bigger than the old one. The return
/// value specifies whether the element has been marked, or not.
inline
void
mark
(
const
Element
&
elem
,
int
newMark
)
void
mark
(
Elemen
t
cons
t
&
elem
,
int
newMark
)
{
int
oldMark
=
grid
->
getMark
(
elem
);
int
oldMark
=
grid
_
->
getMark
(
elem
);
if
(
!
maximumMarking
||
(
newMark
>
oldMark
))
{
bool
(
marked
)
=
grid
->
mark
(
newMark
,
elem
);
if
(
!
maximumMarking
_
||
(
newMark
>
oldMark
))
{
bool
marked
=
grid
_
->
mark
(
newMark
,
elem
);
if
(
marked
)
{
if
(
oldMark
>
0
)
{
elMarkRefine
--
;
elMarkRefine
_
--
;
}
else
if
(
oldMark
<
0
)
{
elMarkCoarsen
--
;
elMarkCoarsen
_
--
;
}
if
(
newMark
>
0
)
{
elMarkRefine
++
;
elMarkRefine
_
++
;
}
else
if
(
newMark
<
0
)
{
elMarkCoarsen
++
;
elMarkCoarsen
_
++
;
}
}
else
{
msg
(
"Marking failed"
);
...
...
@@ -88,88 +84,88 @@ namespace AMDiS {
virtual
void
finishMarking
(
AdaptInfo
&
adaptInfo
);
/// Marks one element.
virtual
void
markElement
(
AdaptInfo
&
adaptInfo
,
const
Element
&
elem
);
virtual
void
markElement
(
AdaptInfo
&
adaptInfo
,
Elemen
t
cons
t
&
elem
);
/// Marking of the mesh.
virtual
Flag
markGrid
(
AdaptInfo
&
adaptInfo
);
/// Sets \ref maximumMarking.
inline
void
setMaximumMarking
(
bool
maxMark
)
void
setMaximumMarking
(
bool
maxMark
)
{
maximumMarking
=
maxMark
;
maximumMarking
_
=
maxMark
;
}
inline
int
getElMarkRefine
()
int
getElMarkRefine
()
{
return
elMarkRefine
;
return
elMarkRefine
_
;
}
inline
int
getElMarkCoarsen
()
int
getElMarkCoarsen
()
{
return
elMarkCoarsen
;
return
elMarkCoarsen
_
;
}
/// Returns \ref name of the Marker
inline
std
::
string
getName
()
const
std
::
string
getName
()
const
{
return
name
;
return
name
_
;
}
/// Creates a scalar marker depending on the strategy set in parameters.
static
std
::
shared_ptr
<
Marker
<
Traits
>
>
createMarker
(
std
::
string
name
,
std
::
string
component
_
,
const
EstType
&
est
_
,
std
::
shared_ptr
<
Grid
>
grid
_
);
static
std
::
shared_ptr
<
Marker
<
Traits
>
>
createMarker
(
std
::
string
name
,
std
::
string
component
,
Estimates
const
&
est
,
std
::
shared_ptr
<
Grid
>
const
&
grid
);
protected:
/// Name of the scalar marker.
std
::
string
name
;
std
::
string
name
_
;
/// Problem component to work on
std
::
string
component
;
std
::
string
component
_
;
/// Pointer to the grid
std
::
shared_ptr
<
Grid
>
grid
;
std
::
shared_ptr
<
Grid
>
grid
_
;
/// Pointer to the local error estimates
Est
Type
est
;
Est
imates
est
_
;
/// estimation sum
double
estSum
;
double
estSum
_
=
0.0
;
/// estmation maximum
double
estMax
;
double
estMax
_
=
0.0
;
/// If true, elements are marked only if the new value is bigger than
/// the current marking.
bool
maximumMarking
;
bool
maximumMarking
_
;
/// Lower limit for error estimation, from which an element is marked for
/// refinement
double
markRLimit
;
double
markRLimit
_
;
/// Upper limit for error estimation, from which an element is marked for
/// coarsening
double
markCLimit
;
double
markCLimit
_
;
/// power in estimator norm
double
p
;
/// power in estimator norm
TODO: is this info necessary in marker?
double
p
_
=
2.0
;
/// Info level.
int
info
;
int
info
_
=
10
;
/// Counter for elements marked for refinement
int
elMarkRefine
;
int
elMarkRefine
_
=
0
;
/// Counter for elements marked for coarsening
int
elMarkCoarsen
;
int
elMarkCoarsen
_
=
0
;
/// Maximal level of all elements.
int
maxRefineLevel
;
int
maxRefineLevel
_
=
-
1
;
/// Minimal level of all elements.
int
minRefineLevel
;
int
minRefineLevel
_
=
-
1
;
bool
refineAllowed
;
bool
refineAllowed
_
=
true
;
bool
coarsenAllowed
;
bool
coarsenAllowed
_
=
false
;
};
...
...
@@ -180,25 +176,25 @@ namespace AMDiS {
* Global refinement.
*/
template
<
class
Traits
>
class
GRMarker
:
public
Marker
<
Traits
>
class
GRMarker
:
public
Marker
<
Traits
>
{
using
GlobalBasis
=
typename
Traits
::
GlobalBasis
;
using
GridView
=
typename
GlobalBasis
::
GridView
;
using
Grid
=
typename
GridView
::
Grid
;
using
IndexSet
=
typename
GridView
::
IndexSet
;
using
Element
=
typename
GridView
::
template
Codim
<
0
>
::
Entity
;
using
EstType
=
std
::
vector
<
double
>
;
using
Super
=
Marker
<
Traits
>
;
using
Grid
=
typename
Super
::
Grid
;
using
Element
=
typename
Super
::
Element
;
using
Estimates
=
typename
Super
::
Estimates
;
public:
/// Constructor.
GRMarker
(
std
::
string
name_
,
std
::
string
component_
,
const
EstType
&
est_
,
std
::
shared_ptr
<
Grid
>
grid_
)
:
Marker
<
Traits
>
(
name_
,
component_
,
est_
,
grid_
)
GRMarker
(
std
::
string
name
,
std
::
string
component
,
Estimates
const
&
est
,
std
::
shared_ptr
<
Grid
>
const
&
grid
)
:
Marker
<
Traits
>
(
std
::
move
(
name
),
std
::
move
(
component
),
est
,
grid
)
{}
/// Implementation of Marker::markElement().
virtual
void
markElement
(
AdaptInfo
&
adaptInfo
,
const
Element
&
elem
)
virtual
void
markElement
(
AdaptInfo
&
adaptInfo
,
Elemen
t
cons
t
&
elem
)
{
if
(
this
->
refineAllowed
)
if
(
this
->
refineAllowed
_
)
this
->
mark
(
elem
,
1
);
}
};
...
...
@@ -210,26 +206,23 @@ namespace AMDiS {
* \brief
* Maximum strategy.
*/
template
<
class
Traits
>
class
MSMarker
:
public
Marker
<
Traits
>
class
MSMarker
:
public
Marker
<
Traits
>
{
using
GlobalBasis
=
typename
Traits
::
GlobalBasis
;
using
GridView
=
typename
GlobalBasis
::
GridView
;
using
Grid
=
typename
GridView
::
Grid
;
using
IndexSet
=
typename
GridView
::
IndexSet
;
using
Element
=
typename
GridView
::
template
Codim
<
0
>
::
Entity
;
using
EstType
=
std
::
vector
<
double
>
;
using
Super
=
Marker
<
Traits
>
;
using
Grid
=
typename
Super
::
Grid
;
using
Estimates
=
typename
Super
::
Estimates
;
public:
/// Constructor.
MSMarker
(
std
::
string
name_
,
std
::
string
component_
,
const
EstType
&
est_
,
std
::
shared_ptr
<
Grid
>
grid_
)
:
Marker
<
Traits
>
(
name_
,
component_
,
est_
,
grid_
),
MSGamma
(
0.5
),
MSGammaC
(
0.1
)
MSMarker
(
std
::
string
name
,
std
::
string
component
,
Estimates
const
&
est
,
std
::
shared_ptr
<
Grid
>
const
&
grid
)
:
Super
{
std
::
move
(
name
),
std
::
move
(
component
),
est
,
grid
}
{
Parameters
::
get
(
this
->
name
+
"->MSGamma"
,
MS
Gamma
);
Parameters
::
get
(
this
->
name
+
"->MSGammaC"
,
MS
GammaC
);
Parameters
::
get
(
this
->
name
_
+
"->MSGamma"
,
ms
Gamma
_
);
Parameters
::
get
(
this
->
name
_
+
"->MSGammaC"
,
ms
GammaC
_
);
}
/// Implementation of Marker::initMarking().
...
...
@@ -237,10 +230,10 @@ namespace AMDiS {
protected:
/// Marking parameter.
double
MS
Gamma
;
double
ms
Gamma
_
=
0.5
;
/// Marking parameter.
double
MS
GammaC
;
double
ms
GammaC
_
=
0.1
;
};
...
...
@@ -250,26 +243,23 @@ namespace AMDiS {
* \brief
* Equidistribution strategy
*/
template
<
class
Traits
>
class
ESMarker
:
public
Marker
<
Traits
>
class
ESMarker
:
public
Marker
<
Traits
>
{
using
GlobalBasis
=
typename
Traits
::
GlobalBasis
;
using
GridView
=
typename
GlobalBasis
::
GridView
;
using
Grid
=
typename
GridView
::
Grid
;
using
IndexSet
=
typename
GridView
::
IndexSet
;
using
Element
=
typename
GridView
::
template
Codim
<
0
>
::
Entity
;
using
EstType
=
std
::
vector
<
double
>
;
using
Super
=
Marker
<
Traits
>
;
using
Grid
=
typename
Super
::
Grid
;
using
Estimates
=
typename
Super
::
Estimates
;
public:
/// Constructor.
ESMarker
(
std
::
string
name_
,
std
::
string
component_
,
const
EstType
&
est_
,
std
::
shared_ptr
<
Grid
>
grid_
)
:
Marker
<
Traits
>
(
name_
,
component_
,
est_
,
grid_
),
ESTheta
(
0.9
),
ESThetaC
(
0.2
)
ESMarker
(
std
::
string
name
,
std
::
string
component
,
Estimates
const
&
est
,
std
::
shared_ptr
<
Grid
>
const
&
grid
)
:
Super
{
std
::
move
(
name
),
std
::
move
(
component
),
est
,
grid
}
{
Parameters
::
get
(
this
->
name
+
"->ESTheta"
,
ES
Theta
);
Parameters
::
get
(
this
->
name
+
"->ESThetaC"
,
ES
ThetaC
);
Parameters
::
get
(
this
->
name
_
+
"->ESTheta"
,
es
Theta
_
);
Parameters
::
get
(
this
->
name
_
+
"->ESThetaC"
,
es
ThetaC
_
);
}
/// Implementation of Marker::initMarking().
...
...
@@ -277,10 +267,10 @@ namespace AMDiS {
protected:
/// Marking parameter.
double
ES
Theta
;
double
es
Theta
_
=
0.9
;
/// Marking parameter.
double
ES
ThetaC
;
double
es
ThetaC
_
=
0.2
;
};
...
...
@@ -290,29 +280,25 @@ namespace AMDiS {
* \brief
* Guaranteed error reduction strategy
*/
template
<
class
Traits
>
class
GERSMarker
:
public
Marker
<
Traits
>
class
GERSMarker
:
public
Marker
<
Traits
>
{
using
GlobalBasis
=
typename
Traits
::
GlobalBasis
;
using
GridView
=
typename
GlobalBasis
::
GridView
;
using
Grid
=
typename
GridView
::
Grid
;
using
IndexSet
=
typename
GridView
::
IndexSet
;
using
Element
=
typename
GridView
::
template
Codim
<
0
>
::
Entity
;
using
EstType
=
std
::
vector
<
double
>
;
using
Super
=
Marker
<
Traits
>
;
using
Grid
=
typename
Super
::
Grid
;
using
Element
=
typename
Super
::
Element
;
using
Estimates
=
typename
Super
::
Estimates
;
public:
/// Constructor.
GERSMarker
(
std
::
string
name_
,
std
::
string
component_
,
const
EstType
&
est_
,
std
::
shared_ptr
<
Grid
>
grid_
)
:
Marker
<
Traits
>
(
name_
,
component_
,
est_
,
grid_
),
oldErrSum
(
0.0
),
GERSThetaStar
(
0.6
),
GERSNu
(
0.1
),
GERSThetaC
(
0.1
)
GERSMarker
(
std
::
string
name
,
std
::
string
component
,
Estimates
const
&
est
,
std
::
shared_ptr
<
Grid
>
const
&
grid
)
:
Super
{
std
::
move
(
name
),
std
::
move
(
component
),
est
,
grid
}
{
Parameters
::
get
(
this
->
name
+
"->GERSThetaStar"
,
GERS
ThetaStar
);
Parameters
::
get
(
this
->
name
+
"->GERSNu"
,
GERS
Nu
);
Parameters
::
get
(
this
->
name
+
"->GERSThetaC"
,
GERS
ThetaC
);
Parameters
::
get
(
this
->
name
_
+
"->GERSThetaStar"
,
gers
ThetaStar
_
);
Parameters
::
get
(
this
->
name
_
+
"->GERSNu"
,
gers
Nu
_
);
Parameters
::
get
(
this
->
name
_
+
"->GERSThetaC"
,
gers
ThetaC
_
);
}
/// Implementation of Marker::markGrid().
...
...
@@ -320,28 +306,28 @@ namespace AMDiS {
protected:
/// Refinement marking function.
void
markElementForRefinement
(
AdaptInfo
&
adaptInfo
,
const
Element
&
elem
);
void
markElementForRefinement
(
AdaptInfo
&
adaptInfo
,
Elemen
t
cons
t
&
elem
);
/// Coarsening marking function.
void
markElementForCoarsening
(
AdaptInfo
&
adaptInfo
,
const
Element
&
elem
);
void
markElementForCoarsening
(
AdaptInfo
&
adaptInfo
,
Elemen
t
cons
t
&
elem
);
protected:
/// Marking parameter.
double
GERSSum
;
double
gersSum_
=
0.0
;
/// Marking parameter.
double
oldErrSum
;
double
oldErrSum
_
=
0.0
;
/// Marking parameter.
double
GERS
ThetaStar
;
double
gers
ThetaStar
_
=
0.6
;
/// Marking parameter.
double
GERSNu
;
double
gersNu_
=
0.1
;
/// Marking parameter.
double
GERS
ThetaC
;
double
gers
ThetaC
_
=
0.1
;
};
}
#include
"Marker.inc.hpp"
\ No newline at end of file
#include
"Marker.inc.hpp"
src/amdis/Marker.inc.hpp
View file @
9379904a
// TODO: Cleanup of copied comments
#include
<amdis/common/Math.hpp>
#include
<cmath>
namespace
AMDiS
{
using
std
::
pow
;
template
<
class
Traits
>
std
::
shared_ptr
<
Marker
<
Traits
>
>
Marker
<
Traits
>::
createMarker
(
std
::
string
name
,
std
::
string
component
,
const
EstType
&
est
,
std
::
shared_ptr
<
Grid
>
grid
)
{
int
strategy
=
0
;
Parameters
::
get
(
name
+
"->strategy"
,
strategy
);
std
::
shared_ptr
<
Marker
<
Traits
>
>
marker
;
switch
(
strategy
)
{
case
0
:
// no refinement/coarsening
break
;
case
1
:
msg
(
"Creating global refinement (GR) marker"
);
marker
=
std
::
make_shared
<
GRMarker
<
Traits
>
>
(
name
,
component
,
est
,
grid
);
break
;
case
2
:
msg
(
"Creating maximum strategy (MS) marker"
);
marker
=
std
::
make_shared
<
MSMarker
<
Traits
>
>
(
name
,
component
,
est
,
grid
);
break
;
case
3
:
msg
(
"Creating equidistribution strategy (ES) marker"
);
marker
=
std
::
make_shared
<
ESMarker
<
Traits
>
>
(
name
,
component
,
est
,
grid
);
break
;
case
4
:
msg
(
"Creating guaranteed error reduction strategy (GERS) marker"
);
marker
=
std
::
make_shared
<
GERSMarker
<
Traits
>
>
(
name
,
component
,
est
,
grid
);
break
;
default:
error_exit
(
"invalid strategy"
);
}
return
marker
;
template
<
class
Traits
>
std
::
shared_ptr
<
Marker
<
Traits
>
>
Marker
<
Traits
>::
createMarker
(
std
::
string
name
,
std
::
string
component
,
Estimates
const
&
est
,
std
::
shared_ptr
<
Grid
>
const
&
grid
)
{
int
strategy
=
0
;
Parameters
::
get
(
name
+
"->strategy"
,
strategy
);
std
::
shared_ptr
<
Marker
<
Traits
>
>
marker
;
switch
(
strategy
)
{
case
0
:
// no refinement/coarsening
break
;
case
1
:
msg
(
"Creating global refinement (GR) marker"
);
marker
=
std
::
make_shared
<
GRMarker
<
Traits
>
>
(
name
,
component
,
est
,
grid
);
break
;
case
2
:
msg
(
"Creating maximum strategy (MS) marker"
);
marker
=
std
::
make_shared
<
MSMarker
<
Traits
>
>
(
name
,
component
,
est
,
grid
);
break
;
case
3
:
msg
(
"Creating equidistribution strategy (ES) marker"
);
marker
=
std
::
make_shared
<
ESMarker
<
Traits
>
>
(
name
,
component
,
est
,
grid
);
break
;
case
4
:
msg
(
"Creating guaranteed error reduction strategy (GERS) marker"
);
marker
=
std
::
make_shared
<
GERSMarker
<
Traits
>
>
(
name
,
component
,
est
,
grid
);
break
;
default:
error_exit
(
"invalid strategy"
);
}
return
marker
;
}
template
<
class
Traits
>
void
Marker
<
Traits
>::
initMarking
(
AdaptInfo
&
adaptInfo
)
{
elMarkRefine
=
0
;
elMarkCoarsen
=
0
;
estSum
=
pow
(
adaptInfo
.
getEstSum
(
component
),
p
);
estMax
=
adaptInfo
.
getEstMax
(
component
);
refineAllowed
=
adaptInfo
.
isRefinementAllowed
(
component
);
coarsenAllowed
=
adaptInfo
.
isCoarseningAllowed
(
component
);
}
template
<
class
Traits
>
void
Marker
<
Traits
>::
initMarking
(
AdaptInfo
&
adaptInfo
)
{
elMarkRefine_
=
0
;
elMarkCoarsen_
=
0
;
estSum_
=
std
::
pow
(
adaptInfo
.
getEstSum
(
component_
),
p_
);
estMax_
=
adaptInfo
.
getEstMax
(
component_
);
refineAllowed_
=
adaptInfo
.
isRefinementAllowed
(
component_
);
coarsenAllowed_
=
adaptInfo
.
isCoarseningAllowed
(
component_
);
}
template
<
class
Traits
>
void
Marker
<
Traits
>::
finishMarking
(
AdaptInfo
&
adaptInfo
)
{
msg
(
elMarkRefine
,
" elements marked for refinement"
);
msg
(
elMarkCoarsen
,
" elements marked for coarsening"
);
}
template
<
class
Traits
>
void
Marker
<
Traits
>::
finishMarking
(
AdaptInfo
&
adaptInfo
)
{
msg
(
elMarkRefine_
,
" elements marked for refinement"
);
msg
(
elMarkCoarsen_
,
" elements marked for coarsening"
);
}
template
<
class
Traits
>
void
Marker
<
Traits
>::
markElement
(
AdaptInfo
&
adaptInfo
,
const
Element
&
elem
)
{
const
auto
&
index
=
grid
->
leafIndexSet
().
index
(
elem
);
double
lError
=
est
[
index
];
if
(
lError
>
markRLimit
&&
refineAllowed
&&
(
maxRefineLevel
==
-
1
||
elem
.
level
()
<
maxRefineLevel
))
{
this
->
mark
(
elem
,
1
);
}
else
{
if
(
lError
<=
markCLimit
&&
coarsenAllowed
&&
(
minRefineLevel
==
-
1
||
elem
.
level
()
>
minRefineLevel
))
if
(
/*!elem->getElementData()->getElementData(COARSENABLE) ||*/
lError
/*+ elem->getCoarseningEstimation(index)*/
<=
markCLimit
)
this
->
mark
(
elem
,
-
1
);
}
template
<
class
Traits
>
void
Marker
<
Traits
>::
markElement
(
AdaptInfo
&
adaptInfo
,
const
Element
&
elem
)
{
const
auto
&
index
=
grid_
->
leafIndexSet
().
index
(
elem
);
double
lError
=
est_
[
index
];
if
(
lError
>
markRLimit_
&&
refineAllowed_
&&
(
maxRefineLevel_
==
-
1
||
elem
.
level
()
<
maxRefineLevel_
))
{
this
->
mark
(
elem
,
1
);
}
else
if
(
lError
<=
markCLimit_
&&
coarsenAllowed_
&&
(
minRefineLevel_
==
-
1
||
elem
.
level
()
>
minRefineLevel_
))
{
this
->
mark
(
elem
,
-
1
);
}
}
template
<
class
Traits
>
Flag
Marker
<
Traits
>::
markGrid
(
AdaptInfo
&
adaptInfo
)
{
if
(
!
(
grid
))
error_exit
(
"No grid!"
);
template
<
class
Traits
>
Flag
Marker
<
Traits
>::
markGrid
(
AdaptInfo
&
adaptInfo
)
{
if
(
!
grid_
)
error_exit
(
"No grid!"
);
initMarking
(
adaptInfo
);
initMarking
(
adaptInfo
);
if
(
!
coarsenAllowed
&&
!
refineAllowed
)
{
return
0
;
}
for
(
const
auto
&
elem
:
Dune
::
elements
(
grid
->
leafGridView
()))
{
markElement
(
adaptInfo
,
elem
);
}
if
(
!
coarsenAllowed_
&&
!
refineAllowed_
)
return
0
;
finishMarking
(
adaptInfo
);
for
(
const
auto
&
elem
:
Dune
::
elements
(
grid_
->
leafGridView
()))
markElement
(
adaptInfo
,
elem
);
Flag
markFlag
;
if
(
elMarkRefine
)
markFlag
=
1
;
if
(
elMarkCoarsen
)
markFlag
|=
2
;
finishMarking
(
adaptInfo
);
return
markFlag
;
}
Flag
markFlag
;