bformAdapt.hh

Go to the documentation of this file.
1 
6 #ifndef bformAdapt_hh
7 #define bformAdapt_hh
8 
9 #include "operator/bilinearForm.hh"
10 #include "bemInt.hh"
11 #include "bem/element.hh"
12 
13 // debugging bilinear forms
14 #define AdaptLaplaceDL00_D 0
15 
16 namespace bem {
17 
18  // ****************************************************** AdaptLaplaceDL00 **
19 
25  template <class F>
26  class AdaptLaplaceDL00 : public concepts::BilinearForm<F> {
27  public:
37  inline AdaptLaplaceDL00(uint stroud = 2, uint gauss = 2,
38  concepts::Real dist = 0.0,
39  concepts::Real eta = 0.5);
40 #if AdaptLaplaceDL00_D
41  virtual ~AdaptLaplaceDL00() {
42  std::cout << "AdaptLaplaceDL00(samel=" << samel_ << ", far=" << far_;
43  std::cout << ", recX=" << recX_ << ", recY=" << recY_;
44  std::cout << ", rec=" << rec_ << ", farrec=" << farrec_ << ")\n";
45  };
46 #endif
47 
54  void operator()(const concepts::Element<F>& elmX,
55  const concepts::Element<F>& elmY,
56  concepts::ElementMatrix<F>& em);
57  void operator()(const Constant3d001<F>& elmX,
58  const Constant3d001<F>& elmY,
59  concepts::ElementMatrix<F>& em);
60 
61  virtual AdaptLaplaceDL00* clone() const {
62  return new AdaptLaplaceDL00(stroud_, gauss_, dist_, eta_); }
63  private:
65  void ball_(const Constant3d001<F>& elm, concepts::Real3d* c,
66  concepts::Real* r) const;
67  void ball_(const concepts::Triangle3d& cell, concepts::Real3d* c,
68  concepts::Real* r) const;
75  inline bool admissible_(const concepts::Real3d* cX,
76  const concepts::Real* rX,
77  const concepts::Real3d* cY,
78  const concepts::Real* rY) const;
85  void update_(concepts::Triangle3d& cell, const Constant3d001<F>& elm,
86  uint deltal, F* m, bool swp) const;
87 
89  uint stroud_;
91  uint gauss_;
93  concepts::Real dist_;
95  concepts::Real eta_;
97  LplGal014<F> qr_;
98 
100  concepts::Real3d* c_;
101  concepts::Real* r_;
102 
103 #if AdaptLaplaceDL00_D
104  // Debug information
105  // # integration (on the same level)
106  uint samel_;
107  // # integration (elements far away from each other)
108  uint far_;
109  // # integration (elements far away in recursive call)
110  mutable uint farrec_;
111  // # integration (recursive with \f$l_X > l_Y\f$)
112  uint recX_;
113  // # integration (recursive with \f$l_Y > l_X\f$)
114  uint recY_;
115  // # recursive integration calls
116  mutable uint rec_;
117 #endif
118  };
119 
120  template <class F>
121  inline AdaptLaplaceDL00<F>::AdaptLaplaceDL00(uint stroud, uint gauss,
122  concepts::Real dist,
123  concepts::Real eta)
124  : stroud_(stroud), gauss_(gauss), dist_(dist), eta_(eta), c_(0), r_(0) {
125 #if AdaptLaplaceDL00_D
126  samel_ = 0; far_ = 0; recX_ = 0; recY_ = 0; rec_ = 0; farrec_ = 0;
127 #endif
128  }
129 
130  template <class F>
131  inline bool
132  AdaptLaplaceDL00<F>::admissible_(const concepts::Real3d* cX,
133  const concepts::Real* rX,
134  const concepts::Real3d* cY,
135  const concepts::Real* rY) const {
136  return concepts::Real3d(*cX - *cY).l2() * eta_ > *rX + *rY;
137  }
138 
139  // ****************************************************** AdaptLaplaceDL01 **
140 
152  template <class F>
153  class AdaptLaplaceDL01 : public concepts::BilinearForm<F> {
154  public:
168  inline AdaptLaplaceDL01(uint gaussX = 2, uint gaussY = 2,
169  concepts::Real deltaG = 1.0,
170  concepts::Real dist = 0.0,
171  concepts::Real eta = 0.5);
172 
179  void operator()(const concepts::Element<F>& elmX,
180  const concepts::Element<F>& elmY,
181  concepts::ElementMatrix<F>& em);
182  void operator()(const Constant3d001<F>& elmX,
183  const Constant3d001<F>& elmY,
184  concepts::ElementMatrix<F>& em);
185 
186  virtual AdaptLaplaceDL01* clone() const {
187  return new AdaptLaplaceDL01(gaussX_, gaussY_, deltaG_, dist_, eta_); }
188  private:
190  void ball_(const Constant3d001<F>& elm, concepts::Real3d* c,
191  concepts::Real* r) const;
192  void ball_(const concepts::Triangle3d& cell, concepts::Real3d* c,
193  concepts::Real* r) const;
200  inline bool admissible_(const concepts::Real3d* cX,
201  const concepts::Real* rX,
202  const concepts::Real3d* cY,
203  const concepts::Real* rY) const;
210  void update_(concepts::Triangle3d& cell, const Constant3d001<F>& elm,
211  uint deltal, F* m, bool swp) const;
212 
214  uint gaussX_;
215  uint gaussY_;
217  concepts::Real deltaG_;
219  concepts::Real dist_;
221  concepts::Real eta_;
222 
224  LplGal011<F> qr_;
225 
227  concepts::Real3d* c_;
228  concepts::Real* r_;
229  };
230 
231  template <class F>
232  inline AdaptLaplaceDL01<F>::AdaptLaplaceDL01(uint gaussX, uint gaussY,
233  concepts::Real deltaG,
234  concepts::Real dist,
235  concepts::Real eta)
236  : gaussX_(gaussX), gaussY_(gaussY), deltaG_(deltaG), dist_(dist),
237  eta_(eta), c_(0), r_(0) {
238  }
239 
240  template <class F>
241  inline bool
242  AdaptLaplaceDL01<F>::admissible_(const concepts::Real3d* cX,
243  const concepts::Real* rX,
244  const concepts::Real3d* cY,
245  const concepts::Real* rY) const {
246  return concepts::Real3d(*cX - *cY).l2() * eta_ > *rX + *rY;
247  }
248 
249  // ****************************************************** AdaptLaplaceSL01 **
250 
262  template <class F>
263  class AdaptLaplaceSL01 : public concepts::BilinearForm<F> {
264  public:
278  inline AdaptLaplaceSL01(uint stroud = 0, uint gauss = 0,
279  concepts::Real deltaI = 1.0,
280  concepts::Real dist = 0.0,
281  concepts::Real eta = 0.5);
282 
289  void operator()(const concepts::Element<F>& elmX,
290  const concepts::Element<F>& elmY,
291  concepts::ElementMatrix<F>& em);
292  void operator()(const Constant3d001<F>& elmX,
293  const Constant3d001<F>& elmY,
294  concepts::ElementMatrix<F>& em);
295 
296  virtual AdaptLaplaceSL01* clone() const {
297  return new AdaptLaplaceSL01(stroud_, gauss_, deltaI_, dist_, eta_); }
298  private:
300  void ball_(const Constant3d001<F>& elm, concepts::Real3d* c,
301  concepts::Real* r) const;
302  void ball_(const concepts::Triangle3d& cell, concepts::Real3d* c,
303  concepts::Real* r) const;
310  inline bool admissible_(const concepts::Real3d* cX,
311  const concepts::Real* rX,
312  const concepts::Real3d* cY,
313  const concepts::Real* rY) const;
320  void update_(concepts::Triangle3d& cell, const Constant3d001<F>& elm,
321  uint deltal, F* m, bool swp) const;
322 
324  uint stroud_;
326  uint gauss_;
328  concepts::Real deltaI_;
330  concepts::Real dist_;
332  concepts::Real eta_;
333 
335  LplGal018<F> qr_;
336 
338  concepts::Real3d* c_;
339  concepts::Real* r_;
340  };
341 
342  template <class F>
343  inline AdaptLaplaceSL01<F>::AdaptLaplaceSL01(uint stroud, uint gauss,
344  concepts::Real deltaI,
345  concepts::Real dist,
346  concepts::Real eta)
347  : stroud_(stroud), gauss_(gauss), deltaI_(deltaI), dist_(dist),
348  eta_(eta), c_(0), r_(0) {
349  }
350 
351  template <class F>
352  inline bool
353  AdaptLaplaceSL01<F>::admissible_(const concepts::Real3d* cX,
354  const concepts::Real* rX,
355  const concepts::Real3d* cY,
356  const concepts::Real* rY) const {
357  return concepts::Real3d(*cX - *cY).l2() * eta_ > *rX + *rY;
358  }
359 
360 } // namespace bem
361 
362 #endif // bformAdapt_hh
bem::AdaptLaplaceSL01::gauss_
uint gauss_
Number of Integration points (inner $y$ integration)
Definition: bformAdapt.hh:326
bem::AdaptLaplaceDL01::clone
virtual AdaptLaplaceDL01 * clone() const
Virtual constructor.
Definition: bformAdapt.hh:186
bem::AdaptLaplaceSL01::operator()
void operator()(const Constant3d001< F > &elmX, const Constant3d001< F > &elmY, concepts::ElementMatrix< F > &em)
bem::LplGal018
Evaluation of the Laplace single layer potential with constant test/trial functions.
Definition: lplGal018.hh:28
bem::AdaptLaplaceDL00::AdaptLaplaceDL00
AdaptLaplaceDL00(uint stroud=2, uint gauss=2, concepts::Real dist=0.0, concepts::Real eta=0.5)
3-dim quadrature (Stroud + 1-d Gauss)
Definition: bformAdapt.hh:121
concepts::Element
An abstract class for an element of a space.
Definition: exceptions.hh:15
bem::AdaptLaplaceDL01::dist_
concepts::Real dist_
Distance to distinguish between near/far field.
Definition: bformAdapt.hh:219
bem::AdaptLaplaceDL00::operator()
void operator()(const Constant3d001< F > &elmX, const Constant3d001< F > &elmY, concepts::ElementMatrix< F > &em)
bem::AdaptLaplaceDL00::clone
virtual AdaptLaplaceDL00 * clone() const
Virtual constructor.
Definition: bformAdapt.hh:61
bem::AdaptLaplaceDL01::eta_
concepts::Real eta_
Ratio between element size and distance for recursive subdivision.
Definition: bformAdapt.hh:221
bem::AdaptLaplaceSL01::AdaptLaplaceSL01
AdaptLaplaceSL01(uint stroud=0, uint gauss=0, concepts::Real deltaI=1.0, concepts::Real dist=0.0, concepts::Real eta=0.5)
3-dim quadrature (3-d Gauss)
Definition: bformAdapt.hh:343
bem::AdaptLaplaceDL01::update_
void update_(concepts::Triangle3d &cell, const Constant3d001< F > &elm, uint deltal, F *m, bool swp) const
Recursive subdivison of the panel on the higher level.
bem::AdaptLaplaceDL01::c_
concepts::Real3d * c_
Space for some intermediate values.
Definition: bformAdapt.hh:227
bem::AdaptLaplaceSL01::stroud_
uint stroud_
Number of Integration points (outer $x$ integration)
Definition: bformAdapt.hh:324
bem::AdaptLaplaceDL00::admissible_
bool admissible_(const concepts::Real3d *cX, const concepts::Real *rX, const concepts::Real3d *cY, const concepts::Real *rY) const
Admissible condition of two panels for integration.
Definition: bformAdapt.hh:132
bem::AdaptLaplaceSL01::admissible_
bool admissible_(const concepts::Real3d *cX, const concepts::Real *rX, const concepts::Real3d *cY, const concepts::Real *rY) const
Admissible condition of two panels for integration.
Definition: bformAdapt.hh:353
bem::AdaptLaplaceSL01::ball_
void ball_(const Constant3d001< F > &elm, concepts::Real3d *c, concepts::Real *r) const
Computes the center and radius of a panels.
concepts::Real3d
Point< Real, 3 > Real3d
Definition: vectorsMatricesForward.hh:19
bem::AdaptLaplaceDL00
Bilinear form for the Laplace double layer potential with piecewise constant shape functions and hang...
Definition: bformAdapt.hh:26
bem::AdaptLaplaceSL01::qr_
LplGal018< F > qr_
Integration.
Definition: bformAdapt.hh:335
concepts::BilinearForm
Abstract function class to evaluate a bilinear form.
Definition: bilinearForm.hh:33
bem::AdaptLaplaceDL00::qr_
LplGal014< F > qr_
Integration.
Definition: bformAdapt.hh:97
bem::AdaptLaplaceDL01::qr_
LplGal011< F > qr_
Integration.
Definition: bformAdapt.hh:224
bem::AdaptLaplaceDL01::admissible_
bool admissible_(const concepts::Real3d *cX, const concepts::Real *rX, const concepts::Real3d *cY, const concepts::Real *rY) const
Admissible condition of two panels for integration.
Definition: bformAdapt.hh:242
bem::AdaptLaplaceDL00::c_
concepts::Real3d * c_
Space for some intermediate values.
Definition: bformAdapt.hh:100
bem::Constant3d001
Constant space element with a level dependent key.
Definition: element.hh:335
bem::AdaptLaplaceSL01::deltaI_
concepts::Real deltaI_
Additional number of Integration points per level.
Definition: bformAdapt.hh:328
concepts::Point::l2
Real l2() const
Returns the Euclidian norm of the vector.
Definition: vectorsMatrices.hh:182
bem::AdaptLaplaceDL00::update_
void update_(concepts::Triangle3d &cell, const Constant3d001< F > &elm, uint deltal, F *m, bool swp) const
Recursive subdivison of the panel on the higher level.
bem::AdaptLaplaceDL01::deltaG_
concepts::Real deltaG_
Additional number of Integration points per level.
Definition: bformAdapt.hh:217
bem::AdaptLaplaceDL01::operator()
void operator()(const concepts::Element< F > &elmX, const concepts::Element< F > &elmY, concepts::ElementMatrix< F > &em)
Application operator.
bem::AdaptLaplaceSL01::clone
virtual AdaptLaplaceSL01 * clone() const
Virtual constructor.
Definition: bformAdapt.hh:296
bem::AdaptLaplaceSL01::ball_
void ball_(const concepts::Triangle3d &cell, concepts::Real3d *c, concepts::Real *r) const
bem::AdaptLaplaceDL01::ball_
void ball_(const concepts::Triangle3d &cell, concepts::Real3d *c, concepts::Real *r) const
bem::AdaptLaplaceDL01::ball_
void ball_(const Constant3d001< F > &elm, concepts::Real3d *c, concepts::Real *r) const
Computes the center and radius of a panels.
bem::AdaptLaplaceSL01::r_
concepts::Real * r_
Definition: bformAdapt.hh:339
bem::AdaptLaplaceSL01::c_
concepts::Real3d * c_
Space for some intermediate values.
Definition: bformAdapt.hh:338
bem::AdaptLaplaceSL01::eta_
concepts::Real eta_
Ratio between element size and distance for recursive subdivision.
Definition: bformAdapt.hh:332
bem::AdaptLaplaceDL01
Bilinear form for the Laplace double layer potential with piecewise constant shape functions and hang...
Definition: bformAdapt.hh:153
bem
Used for the basic classes of the boundary element method.
Definition: bform.hh:13
bem::AdaptLaplaceDL01::operator()
void operator()(const Constant3d001< F > &elmX, const Constant3d001< F > &elmY, concepts::ElementMatrix< F > &em)
bem::AdaptLaplaceDL00::dist_
concepts::Real dist_
Distance to distinguish between near/far field.
Definition: bformAdapt.hh:93
bem::AdaptLaplaceDL00::eta_
concepts::Real eta_
Ratio between element size and distance for recursive subdivision.
Definition: bformAdapt.hh:95
bem::AdaptLaplaceSL01::dist_
concepts::Real dist_
Distance to distinguish between near/far field.
Definition: bformAdapt.hh:330
bem::AdaptLaplaceDL00::gauss_
uint gauss_
Number of Gauss points.
Definition: bformAdapt.hh:91
bem::AdaptLaplaceSL01::operator()
void operator()(const concepts::Element< F > &elmX, const concepts::Element< F > &elmY, concepts::ElementMatrix< F > &em)
Application operator.
bem::AdaptLaplaceDL00::stroud_
uint stroud_
Number of Stroud points.
Definition: bformAdapt.hh:89
bem::AdaptLaplaceDL00::ball_
void ball_(const concepts::Triangle3d &cell, concepts::Real3d *c, concepts::Real *r) const
concepts::ElementMatrix
Element matrix.
Definition: linearForm.hh:18
bem::AdaptLaplaceSL01::update_
void update_(concepts::Triangle3d &cell, const Constant3d001< F > &elm, uint deltal, F *m, bool swp) const
Recursive subdivison of the panel on the higher level.
bem::AdaptLaplaceDL00::operator()
void operator()(const concepts::Element< F > &elmX, const concepts::Element< F > &elmY, concepts::ElementMatrix< F > &em)
Application operator.
concepts::Triangle3d
A 3D cell: triangle.
Definition: cell2D.hh:719
bem::LplGal014
Evaluation of the Laplace double layer potential with constant test/trial functions.
Definition: lplGal014.hh:29
bem::AdaptLaplaceSL01
Bilinear form for the Laplace Single Layer potential with piecewise constant shape functions and hang...
Definition: bformAdapt.hh:263
bem::AdaptLaplaceDL01::gaussX_
uint gaussX_
Number of Gauss points.
Definition: bformAdapt.hh:214
bem::AdaptLaplaceDL01::r_
concepts::Real * r_
Definition: bformAdapt.hh:228
bem::AdaptLaplaceDL00::r_
concepts::Real * r_
Definition: bformAdapt.hh:101
bem::LplGal011
Evaluation of the Laplace double layer potential with constant test/trial functions.
Definition: lplGal011.hh:29
concepts::Real
double Real
Type normally used for a floating point number.
Definition: typedefs.hh:36
bem::AdaptLaplaceDL01::AdaptLaplaceDL01
AdaptLaplaceDL01(uint gaussX=2, uint gaussY=2, concepts::Real deltaG=1.0, concepts::Real dist=0.0, concepts::Real eta=0.5)
3-dim quadrature (3-d Gauss)
Definition: bformAdapt.hh:232
bem::AdaptLaplaceDL00::ball_
void ball_(const Constant3d001< F > &elm, concepts::Real3d *c, concepts::Real *r) const
Computes the center and radius of a panels.
Page URL: http://wiki.math.ethz.ch/bin/view/Concepts/WebHome
21 August 2020
© 2020 Eidgenössische Technische Hochschule Zürich