Marker.h 7.89 KB
Newer Older
1
2
3
4
5
6
// ============================================================================
// ==                                                                        ==
// == AMDiS - Adaptive multidimensional simulations                          ==
// ==                                                                        ==
// ============================================================================
// ==                                                                        ==
7
// ==  TU Dresden                                                            ==
8
// ==                                                                        ==
9
10
11
// ==  Institut fr Wissenschaftliches Rechnen                               ==
// ==  Zellescher Weg 12-14                                                  ==
// ==  01069 Dresden                                                         ==
12
13
14
15
// ==  germany                                                               ==
// ==                                                                        ==
// ============================================================================
// ==                                                                        ==
16
// ==  https://gforge.zih.tu-dresden.de/projects/amdis/                      ==
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
// ==                                                                        ==
// ============================================================================

/** \file Marker.h */

#ifndef AMDIS_MARKER_H
#define AMDIS_MARKER_H

#include "Element.h"
#include "ElInfo.h"
#include "Flag.h"
#include "Mesh.h"
#include "AdaptInfo.h"
#include "Traverse.h"
#include "MatrixVector.h"

namespace AMDiS {

  /**
   * \ingroup Adaption
   * 
   * \brief
   * Base class for all scalar markers.
   */
  class Marker
  {
  public:
44
    /// Constructor.
Thomas Witkowski's avatar
Thomas Witkowski committed
45
    Marker() {}
46

47
    /// Constructor.
48
    Marker(std::string name_, int row_)
49
50
51
52
      : name(name_), 
	row(row_),
	maximumMarking(false),
	p(2),
53
54
	info(10),
	maxRefineLevel(-1)
55
56
57
    {
      GET_PARAMETER(0, name + "->p", "%f", &p);
      GET_PARAMETER(0, name + "->info", "%d", &info);
58
      GET_PARAMETER(0, name + "->max refinement level", "%d", &maxRefineLevel);
Thomas Witkowski's avatar
Thomas Witkowski committed
59
    }
60

61
    /// destructor
Thomas Witkowski's avatar
Thomas Witkowski committed
62
    virtual ~Marker() {}
63
64
65
66
67
68

    /** \brief
     * 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.
     */
69
70
    inline void setMark(Element *el, char newMark) 
    {
71
72
73
74
      char oldMark = el->getMark();

      if (!maximumMarking || (newMark > oldMark)) {
	el->setMark(newMark);
75
76
77
78
79
80
81
82
83
84
85
86
87
88

	if (oldMark > 0) {
	  elMarkRefine--; 
	} else {
	  if (oldMark < 0) 
	    elMarkCoarsen--;
	}

	if (newMark > 0) {
	  elMarkRefine++; 
	} else { 
	  if (newMark < 0) 
	    elMarkCoarsen++;
	}
89
      }
Thomas Witkowski's avatar
Thomas Witkowski committed
90
    }
91

92
    /// Can be used by sub classes. Called before traversal.
93
    virtual void initMarking(AdaptInfo *adaptInfo, Mesh *mesh);
94

95
    /// Can be used by sub classes. Called after traversal.
96
    virtual void finishMarking(AdaptInfo *adaptInfo);
97

98
    /// Marks one element.
99
    virtual void markElement(AdaptInfo *adaptInfo, ElInfo *elInfo);
100
  
101
    /// Marking of the mesh.
102
    virtual Flag markMesh(AdaptInfo *adaptInfo, Mesh *mesh);
103

104
105
106
    /// Sets \ref maximumMarking.
    inline void setMaximumMarking(bool maxMark) 
    {
107
      maximumMarking = maxMark;
Thomas Witkowski's avatar
Thomas Witkowski committed
108
    }
109

110
111
    inline int getElMarkRefine() 
    { 
Thomas Witkowski's avatar
Thomas Witkowski committed
112
113
      return elMarkRefine; 
    }
114

115
116
    inline int getElMarkCoarsen() 
    { 
117
      return elMarkCoarsen; 
Thomas Witkowski's avatar
Thomas Witkowski committed
118
    }
119

120
121
122
123
124
125
    // Returns \ref name of the Marker
    inline std::string getName() const 
    { 
      return name; 
    }

126
    /// Creates a scalr marker depending on the strategy set in parameters.
127
    static Marker *createMarker(std::string name, int row_);
128
129

  protected:
130
    /// Name of the scalar marker.
131
    std::string name;
132
133
134
135
136
137
138

    /** \brief
     * Equal to -1 for scalar problems. Component number if marker is
     * part of a vector valued marker.
     */
    int row;

139
    /// estimation sum
140
141
    double estSum;

142
    /// estmation maximum
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
    double estMax;

    /** \brief
     * If true, elements are marked only if the new value is bigger than
     * the current marking.
     */
    bool maximumMarking;

    /** \brief
     * Lower limit for error estimation, from which an element is marked for
     * refinement
     */
    double markRLimit;

    /** \brief
     * Upper limit for error estimation, from which an element is marked for 
     * coarsening
     */
    double markCLimit;

163
    /// power in estimator norm
164
165
    double p;

166
    /// Info level.
167
168
    int info;

169
    /// Counter for elements marked for refinement
170
171
    int elMarkRefine;

172
    /// Counter for elements marked for coarsening
173
174
    int elMarkCoarsen;

175
    /// Maximal depth for element refinement.
176
    int maxRefineLevel;
177
178
179
180
181
182
183
184
185
186
187
188
  };


  /**
   * \ingroup Adaption
   * 
   * \brief
   * Global refinement.
   */
  class GRMarker : public Marker
  {
  public:
189
    /// Constructor.
190
    GRMarker(std::string name_, int row_) 
191
      : Marker(name_, row_) 
Thomas Witkowski's avatar
Thomas Witkowski committed
192
    {}
193

194
195
196
    /// Implementation of Marker::markElement().
    virtual void markElement(AdaptInfo *adaptInfo, ElInfo *elInfo) 
    {
197
      Element *el = elInfo->getElement();
198
      if (adaptInfo->isRefinementAllowed(row == -1 ? 0 : row))
199
	setMark(el, adaptInfo->getRefineBisections(row == -1 ? 0 : row));
Thomas Witkowski's avatar
Thomas Witkowski committed
200
    }
201
202
203
204
205
206
207
208
209
210
211
212
  };


  /**
   * \ingroup Adaption
   * 
   * \brief
   * Maximum strategy.
   */
  class MSMarker : public Marker
  {
  public:
213
    /// Constructor.
214
    MSMarker(std::string name_, int row_) 
215
216
217
218
219
220
      : Marker(name_, row_),
	MSGamma(0.5),
	MSGammaC(0.1)
    {
      GET_PARAMETER(0, name + "->MSGamma", "%f", &MSGamma);
      GET_PARAMETER(0, name + "->MSGammaC", "%f", &MSGammaC);
Thomas Witkowski's avatar
Thomas Witkowski committed
221
    }
222

223
224
225
    /// Implementation of MarkScal::initMarking().
    virtual void initMarking(AdaptInfo *adaptInfo, Mesh *mesh) 
    {
226
227
228
229
230
231
232
      Marker::initMarking(adaptInfo, mesh);
    
      double MSGammaP = pow(MSGamma, p);
      double MSGammaCP = pow(MSGammaC, p);

      markRLimit = MSGammaP * adaptInfo->getEstMax(row == -1 ? 0 : row);
      markCLimit = MSGammaCP * adaptInfo->getEstMax(row == -1 ? 0 : row);
Thomas Witkowski's avatar
Thomas Witkowski committed
233
    }
234
235
  
  protected:
236
    /// Marking parameter.
237
238
    double MSGamma;

239
    /// Marking parameter.
240
241
242
243
244
245
246
247
248
249
250
251
252
    double MSGammaC;
  };


  /**
   * \ingroup Adaption
   * 
   * \brief
   * Equidistribution strategy
   */
  class ESMarker : public Marker
  {
  public:
253
    /// Constructor.
254
    ESMarker(std::string name_, int row_) 
255
256
257
258
259
260
      : Marker(name_, row_),
	ESTheta(0.9),
	ESThetaC(0.2)
    {
      GET_PARAMETER(0, name + "->ESTheta", "%f", &ESTheta);
      GET_PARAMETER(0, name + "->ESThetaC", "%f", &ESThetaC);
Thomas Witkowski's avatar
Thomas Witkowski committed
261
    }
262

263
    /// Implementation of MarkScal::initMarking().
264
    virtual void initMarking(AdaptInfo *adaptInfo, Mesh *mesh);
265
266
  
  protected:
267
    /// Marking parameter.
268
269
    double ESTheta;

270
    /// Marking parameter.
271
272
273
274
275
276
277
278
279
280
281
282
283
    double ESThetaC;
  };


  /**
   * \ingroup Adaption
   * 
   * \brief
   * Guaranteed error reduction strategy 
   */
  class GERSMarker : public Marker
  {
  public:
284
    /// Constructor.
285
    GERSMarker(std::string name_, int row_) 
286
287
288
289
290
291
292
293
294
      : Marker(name_, row_),
	oldErrSum(0.0),
	GERSThetaStar(0.6),
	GERSNu(0.1),
	GERSThetaC(0.1)
    {
      GET_PARAMETER(0, name + "->GERSThetaStar", "%f", &GERSThetaStar);
      GET_PARAMETER(0, name + "->GERSNu", "%f", &GERSNu);
      GET_PARAMETER(0, name + "->GERSThetaC", "%f", &GERSThetaC);
Thomas Witkowski's avatar
Thomas Witkowski committed
295
    }
296

297
    /// Implementation of Marker::markMesh().
298
    virtual Flag markMesh(AdaptInfo *adaptInfo, Mesh *mesh);
299
300

  protected:
301
    /// Refinement marking function.
302
    void markElementForRefinement(AdaptInfo *adaptInfo, ElInfo *elInfo);
303

304
    /// Coarsening marking function.
305
    void markElementForCoarsening(AdaptInfo *adaptInfo, ElInfo *elInfo);
306
307

  protected:
308
    /// Marking parameter.
309
310
    double GERSSum;

311
    /// Marking parameter.
312
313
    double oldErrSum;

314
    /// Marking parameter.
315
316
    double GERSThetaStar;

317
    /// Marking parameter.
318
319
    double GERSNu;

320
    /// Marking parameter.
321
322
323
324
325
326
    double GERSThetaC;
  };

}

#endif