MADNESS 0.10.1
test_problems.h
Go to the documentation of this file.
1/*
2 This file is part of MADNESS.
3
4 Copyright (C) 2007,2010 Oak Ridge National Laboratory
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19
20 For more information please contact:
21
22 Robert J. Harrison
23 Oak Ridge National Laboratory
24 One Bethel Valley Road
25 P.O. Box 2008, MS-6367
26
27 email: harrisonrj@ornl.gov
28 tel: 865-241-3937
29 fax: 865-572-0680
30
31 $Id$
32*/
33
34/** \file test_problems.h
35 \brief Provides test problems for examining the convergence of
36 embedded (Dirichlet) boundary conditions.
37
38 The auxiliary PDE being solved is
39 \f[ \nabla^2 u - p(\varepsilon) S (u-g) = \varphi f, \f]
40 where
41 - \f$u\f$ is the solution function
42 - \f$\varepsilon\f$ is the thickness of the boundary layer
43 - \f$p(\varepsilon)\f$ is the penalty prefactor, \f$2/\varepsilon\f$
44 seems to work well.
45 - \f$S\f$ is the surface function
46 - \f$g\f$ is the Dirichlet condition to be enforced on the surface
47 - \f$\varphi\f$ is the domain mask (1 inside, 0 outside, blurry on the
48 border)
49 - \f$f\f$ is the inhomogeneity.
50
51 The available test problems are
52 -# A sphere of radius \f$R\f$ with \f$g = Y_0^0\f$, homogeneous
53 (ConstantSphere)
54 -# A sphere of radius \f$R\f$ with \f$g = Y_1^0\f$, homogeneous
55 (CosineSphere)
56 -# A sphere of radius \f$R\f$ with \f$g = Y_2^0\f$, homogeneous
57 (Y20Sphere)
58 -# A sphere of radius \f$R\f$ with \f$g = Y_0^0\f$, inhomogeneous
59 \f$ f = 1 \f$ (InhomoConstantSphere)
60
61 This file sets up the various details of the problems... the main program
62 is found in embedded_dirichlet.cc. */
63
64#ifndef MADNESS_INTERIOR_BC_TEST_PROBLEMS_H__INCLUDED
65#define MADNESS_INTERIOR_BC_TEST_PROBLEMS_H__INCLUDED
66
67#include <madness/mra/mra.h>
68#include <madness/mra/lbdeux.h>
70#include <string>
71
72using namespace madness;
73
74enum Mask { LLRV, Gaussian };
75
77
78// load balancing structure lifted from dataloadbal.cc
79template <int NDIM>
81 double leaf_value;
85
86 double operator() (const Key<NDIM> &key,
87 const FunctionNode<double, NDIM> &node) const {
88
89 if(key.level() <= 1) {
90 return 100.0*(leaf_value+parent_value);
91 }
92 else if(node.is_leaf()) {
93 return leaf_value;
94 }
95 else {
96 return parent_value;
97 }
98 }
99};
100
101/** \brief Abstract base class for embedded Dirichlet problems. */
103 private:
106 int k;
107 double thresh;
108 std::string penalty_name;
109
110 protected:
114 std::string problem_name;
116 std::string domain_mask_name;
117
118 // is the problem homogeneous?
119 virtual bool isHomogeneous() const = 0;
120
121 public:
122 /// which function to use when projecting:
123 /// -# the weighted surface (SURFACE)
124 /// -# the rhs of the auxiliary DE (DIRICHLET_RHS)
125 /// -# the exact solution (EXACT)
126 /// -# the domain mask (DOMAIN_MASK)
128
129 /// \brief Sets up the data for the problem-inspecific parts.
130 ///
131 /// Also sets the FunctionDefaults for the appropriate dimension.
133 double eps, int k, double thresh, Mask mask)
134 : k(k), thresh(thresh), penalty_name(penalty_name), dmi(nullptr),
137
138 // calculate some nice initial projection level
139 // should be no lower than 6, but may need to be higher for small
140 // eps
141 initial_level = ceil(log(4.0 / eps) / log(2.0) - 4);
142 if(initial_level < 6)
143 initial_level = 6;
145
146 switch(mask) {
147 case LLRV:
148 domain_mask_name = "LLRV";
149 dmi = new LLRVDomainMask(eps);
150 break;
151 case Gaussian:
152 domain_mask_name = "Gaussian";
154 break;
155 default:
156 error("Unknown mask");
157 break;
158 }
159 }
160
162 if(sdfi != nullptr)
163 delete sdfi;
164 if(dmi != nullptr)
165 delete dmi;
166 }
167
168 /// \brief Load balances using the provided Function
170 const {
171
172 LoadBalanceDeux<3> lb(world);
173 lb.add_tree(f, DirichletLBCost<3>(1.0, 1.0));
174 // set this map as the default
176 false));
177 }
178
179 /// \brief Do a standard Printout of the problem details
180 void printout() const {
181 printf("Solving problem: %s\nWavelet Order: %d\nThreshold: %.6e" \
182 "\nEpsilon: %.6e\nPenalty Prefactor, %s: %.6e\nUsing %s " \
183 "domain masking\n%s\n",
184 problem_name.c_str(), k, thresh, eps, penalty_name.c_str(),
186 problem_specific_info.c_str());
187 fflush(stdout);
188 }
189
190 /// \brief The operator for projecting a MADNESS function.
191 double operator() (const Vector<double, 3> &x) const {
192 switch(fop) {
193 case EXACT:
194 return ExactSol(x);
195 break;
196 case DIRICHLET_RHS:
197 if(isHomogeneous())
198 return -DirichletCond(x) * dmi->surface(sdfi->sdf(x)) *
200 else
201 return dmi->mask(sdfi->sdf(x)) * Inhomogeneity(x) -
202 DirichletCond(x) * dmi->surface(sdfi->sdf(x)) *
204 break;
205 case SURFACE:
206 return dmi->surface(sdfi->sdf(x)) * penalty_prefact;
207 break;
208 case DOMAIN_MASK:
209 return dmi->mask(sdfi->sdf(x));
210 break;
211 default:
212 error("shouldn't be here...");
213 return 0.0;
214 break;
215 }
216 }
217
218 virtual double DirichletCond(const Vector<double, 3> &x) const = 0;
219
220 virtual double ExactSol(const Vector<double, 3> &x) const = 0;
221
222 virtual double Inhomogeneity(const Vector<double, 3> &x) const = 0;
223
224 /// \brief The surface area of the domain
225 virtual double SurfaceIntegral() const = 0;
226
227 /// \brief The volume of the domain
228 virtual double VolumeIntegral() const = 0;
229
230 /// \brief A list of points where we should compare the computed
231 /// solution to the exact solution
232 virtual std::vector< Vector<double, 3> > check_pts() const {
233 return std::vector< Vector<double, 3> >();
234 }
235};
236
237/** \brief The constant on a sphere problem */
239 protected:
240 double radius;
241
242 bool isHomogeneous() const { return true; }
243
244 public:
245 ConstantSphere(int k, double thresh, double eps, std::string penalty_name,
246 double penalty_prefact, double radius, Mask mask)
249
250 char str[80];
251 sprintf(str, "Sphere radius: %.6e\n", radius);
253 problem_name = "Constant Sphere";
254
255 // set up the domain masks, etc.
256 coord_3d pt(0.0); // origin
257 sdfi = new SDFSphere(radius, pt);
258 }
259
260 double DirichletCond(const Vector<double, 3> &x) const {
261 return 1.0;
262 }
263
264 double ExactSol(const Vector<double, 3> &x) const {
265 double r = sqrt(x[0]*x[0] + x[1]*x[1] + x[2]*x[2]);
266
267 if(r <= radius)
268 return 1.0;
269 else
270 return radius / r;
271 }
272
273 double Inhomogeneity(const Vector<double, 3> &x) const {
274 return 0.0;
275 }
276
277 double SurfaceIntegral() const {
278 return 4.0*constants::pi*radius*radius;
279 }
280
281 double VolumeIntegral() const {
282 return 4.0*constants::pi*radius*radius*radius / 3.0;
283 }
284
285 virtual std::vector< Vector<double, 3> > check_pts() const {
286 std::vector< Vector<double, 3> > vec;
288
289 pt[0] = pt[1] = 0.0;
290 pt[2] = 0.1 * radius;
291 vec.push_back(pt);
292
293 pt[2] = radius;
294 vec.push_back(pt);
295
296 pt[2] = 2.0;
297 vec.push_back(pt);
298
299 return vec;
300 }
301};
302
303/** \brief The constant on a sphere problem, with inhomogeneity */
305 protected:
306 double radius;
307
308 bool isHomogeneous() const { return false; }
309
310 public:
311 InhomoConstantSphere(int k, double thresh, double eps, std::string penalty_name,
312 double penalty_prefact, double radius, Mask mask)
315
316 char str[80];
317 sprintf(str, "Sphere radius: %.6e\n", radius);
319 problem_name = "Inhomogeneous Constant Sphere";
320
321 // set up the domain masks, etc.
322 coord_3d pt(0.0); // origin
323 sdfi = new SDFSphere(radius, pt);
324 }
325
326 double DirichletCond(const Vector<double, 3> &x) const {
327 return 1.0;
328 }
329
330 double ExactSol(const Vector<double, 3> &x) const {
331 double r = sqrt(x[0]*x[0] + x[1]*x[1] + x[2]*x[2]);
332
333 if(r <= radius)
334 return r*r / (radius*radius);
335 else
336 return radius / r;
337 }
338
339 double Inhomogeneity(const Vector<double, 3> &x) const {
340 return 6.0 / (radius*radius);
341 }
342
343 double SurfaceIntegral() const {
344 return 4.0*constants::pi*radius*radius;
345 }
346
347 double VolumeIntegral() const {
348 return 4.0*constants::pi*radius*radius*radius / 3.0;
349 }
350
351 virtual std::vector< Vector<double, 3> > check_pts() const {
352 std::vector< Vector<double, 3> > vec;
354
355 pt[0] = pt[1] = 0.0;
356 pt[2] = 0.1 * radius;
357 vec.push_back(pt);
358
359 pt[2] = radius;
360 vec.push_back(pt);
361
362 pt[2] = 2.0;
363 vec.push_back(pt);
364
365 return vec;
366 }
367};
368
369/** \brief The cos(theta) on a sphere problem */
371 protected:
372 double radius;
373
374 bool isHomogeneous() const { return true; }
375
376 public:
377 CosineSphere(int k, double thresh, double eps, std::string penalty_name,
378 double penalty_prefact, double radius, Mask mask)
381
382 char str[80];
383 sprintf(str, "Sphere radius: %.6e\n", radius);
385 problem_name = "Cosine Sphere";
386
387 // set up the domain masks, etc.
388 coord_3d pt(0.0); // origin
389 sdfi = new SDFSphere(radius, pt);
390 }
391
392 double DirichletCond(const Vector<double, 3> &x) const {
393 double r = sqrt(x[0]*x[0] + x[1]*x[1] + x[2]*x[2]);
394
395 if(r < 1.0e-4)
396 return 0.0;
397 else
398 return x[2] / r;
399 }
400
401 double ExactSol(const Vector<double, 3> &x) const {
402 double r = sqrt(x[0]*x[0] + x[1]*x[1] + x[2]*x[2]);
403
404 if(r <= radius)
405 return x[2] / radius;
406 else
407 return x[2] * radius * radius / (r*r*r);
408 }
409
410 double Inhomogeneity(const Vector<double, 3> &x) const {
411 return 0.0;
412 }
413
414 double SurfaceIntegral() const {
415 return 4.0*constants::pi*radius*radius;
416 }
417
418 double VolumeIntegral() const {
419 return 4.0*constants::pi*radius*radius*radius / 3.0;
420 }
421
422 virtual std::vector< Vector<double, 3> > check_pts() const {
423 std::vector< Vector<double, 3> > vec;
425
426 pt[0] = pt[1] = 0.0;
427 pt[2] = 0.1 * radius;
428 vec.push_back(pt);
429
430 pt[2] = radius;
431 vec.push_back(pt);
432
433 pt[2] = 2.0;
434 vec.push_back(pt);
435
436 return vec;
437 }
438};
439
440/** \brief The Y_2^0 on a sphere problem */
442 protected:
443 double radius;
444
445 bool isHomogeneous() const { return true; }
446
447 public:
448 Y20Sphere(int k, double thresh, double eps, std::string penalty_name,
449 double penalty_prefact, double radius, Mask mask)
452
453 char str[80];
454 sprintf(str, "Sphere radius: %.6e\n", radius);
456 problem_name = "Y20 Sphere";
457
458 // set up the domain masks, etc.
459 coord_3d pt(0.0); // origin
460 sdfi = new SDFSphere(radius, pt);
461 }
462
463 double DirichletCond(const Vector<double, 3> &x) const {
464 double r = sqrt(x[0]*x[0] + x[1]*x[1] + x[2]*x[2]);
465
466 if(r < 1.0e-4)
467 return 0.0;
468 else
469 return 3.0* x[2] * x[2] / (r*r) - 1.0;
470 }
471
472 double ExactSol(const Vector<double, 3> &x) const {
473 double r = sqrt(x[0]*x[0] + x[1]*x[1] + x[2]*x[2]);
474
475 if(r <= radius)
476 //return x[2] / radius;
477 return (3.0*x[2]*x[2] - r*r) / (radius * radius);
478 else
479 return radius*radius*radius / (r*r*r) * (3.0*x[2]*x[2]/(r*r) - 1.0);
480 }
481
482 double Inhomogeneity(const Vector<double, 3> &x) const {
483 return 0.0;
484 }
485
486 double SurfaceIntegral() const {
487 return 4.0*constants::pi*radius*radius;
488 }
489
490 double VolumeIntegral() const {
491 return 4.0*constants::pi*radius*radius*radius / 3.0;
492 }
493
494 virtual std::vector< Vector<double, 3> > check_pts() const {
495 std::vector< Vector<double, 3> > vec;
497
498 pt[0] = pt[1] = 0.0;
499 pt[2] = 0.1 * radius;
500 vec.push_back(pt);
501
502 pt[2] = radius;
503 vec.push_back(pt);
504
505 pt[2] = 2.0;
506 vec.push_back(pt);
507
508 return vec;
509 }
510};
511
512/** \brief The operator needed for solving for \f$u\f$ with GMRES */
513class DirichletCondIntOp : public Operator<Function<double, 3> > {
514 protected:
515 /// \brief The Green's function
517 /// \brief The surface function (normalized)
519
520 /** \brief Applies the operator to \c invec
521
522 \note \c G is actually \f$-G\f$.
523
524 \param[in] invec The input vector
525 \param[out] outvec The action of the operator on \c invec */
526 void action(const Function<double, 3> &invec,
527 Function<double, 3> &outvec) const {
528
529 Function<double, 3> f = b*invec;
530 f.broaden();
531 f.broaden();
532 outvec = invec + G(f);
533 f.clear();
534 outvec.scale(-1.0);
535 outvec.truncate();
536 }
537
538 public:
540 const Function<double, 3> &bin)
541 : G(gin), b(bin) {}
542};
543
544#endif // MADNESS_INTERIOR_BC_TEST_PROBLEMS_H__INCLUDED
The constant on a sphere problem.
Definition test_problems.h:238
double SurfaceIntegral() const
The surface area of the domain.
Definition test_problems.h:277
double ExactSol(const Vector< double, 3 > &x) const
Definition test_problems.h:264
double VolumeIntegral() const
The volume of the domain.
Definition test_problems.h:281
bool isHomogeneous() const
Definition test_problems.h:242
double radius
Definition test_problems.h:240
ConstantSphere(int k, double thresh, double eps, std::string penalty_name, double penalty_prefact, double radius, Mask mask)
Definition test_problems.h:245
double Inhomogeneity(const Vector< double, 3 > &x) const
Definition test_problems.h:273
double DirichletCond(const Vector< double, 3 > &x) const
Definition test_problems.h:260
virtual std::vector< Vector< double, 3 > > check_pts() const
A list of points where we should compare the computed solution to the exact solution.
Definition test_problems.h:285
The cos(theta) on a sphere problem.
Definition test_problems.h:370
CosineSphere(int k, double thresh, double eps, std::string penalty_name, double penalty_prefact, double radius, Mask mask)
Definition test_problems.h:377
double DirichletCond(const Vector< double, 3 > &x) const
Definition test_problems.h:392
double SurfaceIntegral() const
The surface area of the domain.
Definition test_problems.h:414
double ExactSol(const Vector< double, 3 > &x) const
Definition test_problems.h:401
double VolumeIntegral() const
The volume of the domain.
Definition test_problems.h:418
bool isHomogeneous() const
Definition test_problems.h:374
virtual std::vector< Vector< double, 3 > > check_pts() const
A list of points where we should compare the computed solution to the exact solution.
Definition test_problems.h:422
double radius
Definition test_problems.h:372
double Inhomogeneity(const Vector< double, 3 > &x) const
Definition test_problems.h:410
The operator needed for solving for with GMRES.
Definition test_problems.h:513
DirichletCondIntOp(const SeparatedConvolution< double, 3 > &gin, const Function< double, 3 > &bin)
Definition test_problems.h:539
void action(const Function< double, 3 > &invec, Function< double, 3 > &outvec) const
Applies the operator to invec.
Definition test_problems.h:526
const SeparatedConvolution< double, 3 > & G
The Green's function.
Definition test_problems.h:516
const Function< double, 3 > & b
The surface function (normalized)
Definition test_problems.h:518
Abstract base class for embedded Dirichlet problems.
Definition test_problems.h:102
double thresh
Definition test_problems.h:107
EmbeddedDirichlet()
Definition test_problems.h:104
int k
Definition test_problems.h:106
virtual std::vector< Vector< double, 3 > > check_pts() const
A list of points where we should compare the computed solution to the exact solution.
Definition test_problems.h:232
virtual double VolumeIntegral() const =0
The volume of the domain.
FunctorOutput fop
Definition test_problems.h:127
virtual double Inhomogeneity(const Vector< double, 3 > &x) const =0
double eps
Definition test_problems.h:113
virtual double ExactSol(const Vector< double, 3 > &x) const =0
SignedDFInterface< 3 > * sdfi
Definition test_problems.h:112
EmbeddedDirichlet(double penalty_prefact, std::string penalty_name, double eps, int k, double thresh, Mask mask)
Sets up the data for the problem-inspecific parts.
Definition test_problems.h:132
double penalty_prefact
Definition test_problems.h:113
DomainMaskInterface * dmi
Definition test_problems.h:111
virtual double DirichletCond(const Vector< double, 3 > &x) const =0
std::string penalty_name
Definition test_problems.h:108
double operator()(const Vector< double, 3 > &x) const
The operator for projecting a MADNESS function.
Definition test_problems.h:191
virtual double SurfaceIntegral() const =0
The surface area of the domain.
void printout() const
Do a standard Printout of the problem details.
Definition test_problems.h:180
std::string problem_name
Definition test_problems.h:114
void load_balance(World &world, const Function< double, 3 > &f) const
Load balances using the provided Function.
Definition test_problems.h:169
virtual bool isHomogeneous() const =0
std::string domain_mask_name
Definition test_problems.h:116
std::string problem_specific_info
Definition test_problems.h:115
virtual ~EmbeddedDirichlet()
Definition test_problems.h:161
int initial_level
Definition test_problems.h:105
Definition test_derivative.cc:24
Definition dataloadbal.cc:141
The constant on a sphere problem, with inhomogeneity.
Definition test_problems.h:304
double DirichletCond(const Vector< double, 3 > &x) const
Definition test_problems.h:326
bool isHomogeneous() const
Definition test_problems.h:308
virtual std::vector< Vector< double, 3 > > check_pts() const
A list of points where we should compare the computed solution to the exact solution.
Definition test_problems.h:351
double radius
Definition test_problems.h:306
double SurfaceIntegral() const
The surface area of the domain.
Definition test_problems.h:343
double Inhomogeneity(const Vector< double, 3 > &x) const
Definition test_problems.h:339
double ExactSol(const Vector< double, 3 > &x) const
Definition test_problems.h:330
double VolumeIntegral() const
The volume of the domain.
Definition test_problems.h:347
InhomoConstantSphere(int k, double thresh, double eps, std::string penalty_name, double penalty_prefact, double radius, Mask mask)
Definition test_problems.h:311
The Y_2^0 on a sphere problem.
Definition test_problems.h:441
bool isHomogeneous() const
Definition test_problems.h:445
double radius
Definition test_problems.h:443
double SurfaceIntegral() const
The surface area of the domain.
Definition test_problems.h:486
double DirichletCond(const Vector< double, 3 > &x) const
Definition test_problems.h:463
double ExactSol(const Vector< double, 3 > &x) const
Definition test_problems.h:472
virtual std::vector< Vector< double, 3 > > check_pts() const
A list of points where we should compare the computed solution to the exact solution.
Definition test_problems.h:494
double Inhomogeneity(const Vector< double, 3 > &x) const
Definition test_problems.h:482
double VolumeIntegral() const
The volume of the domain.
Definition test_problems.h:490
Y20Sphere(int k, double thresh, double eps, std::string penalty_name, double penalty_prefact, double radius, Mask mask)
Definition test_problems.h:448
The interface for masking functions defined by signed distance functions.
Definition sdf_domainmask.h:104
virtual double mask(double d) const =0
Returns the characteristic mask function.
virtual double surface(double d) const =0
Returns the value of the normalized surface layer function.
static void redistribute(World &world, const std::shared_ptr< WorldDCPmapInterface< Key< NDIM > > > &newpmap)
Sets the default process map and redistributes all functions using the old map.
Definition funcdefaults.h:513
static void set_initial_level(int value)
Sets the default initial projection level.
Definition funcdefaults.h:303
Abstract base class interface required for functors used as input to Functions.
Definition function_interface.h:68
FunctionNode holds the coefficients, etc., at each node of the 2^NDIM-tree.
Definition funcimpl.h:124
bool is_leaf() const
Returns true if this does not have children.
Definition funcimpl.h:210
A multiresolution adaptive numerical function.
Definition mra.h:122
void broaden(const BoundaryConditions< NDIM > &bc=FunctionDefaults< NDIM >::get_bc(), bool fence=true) const
Inplace broadens support in scaling function basis.
Definition mra.h:836
Function< T, NDIM > & scale(const Q q, bool fence=true)
Inplace, scale the function by a constant. No communication except for optional fence.
Definition mra.h:953
Function< T, NDIM > & truncate(double tol=0.0, bool fence=true)
Truncate the function with optional fence. Compresses with fence if not compressed.
Definition mra.h:602
Use a Gaussian for the surface function and the corresponding erf for the domain mask.
Definition sdf_domainmask.h:374
Key is the index for a node of the 2^NDIM-tree.
Definition key.h:66
Level level() const
Definition key.h:159
Provides the Li-Lowengrub-Ratz-Voight (LLRV) domain mask characteristic functions.
Definition sdf_domainmask.h:301
Definition lbdeux.h:228
std::shared_ptr< WorldDCPmapInterface< keyT > > load_balance(double fac=1.0, bool printstuff=false)
Actually does the partitioning of the tree.
Definition lbdeux.h:320
void add_tree(const Function< T, NDIM > &f, const costT &costfn, bool fence=false)
Accumulates cost from a function.
Definition lbdeux.h:289
A generic operator: takes in one T and produces another T.
Definition gmres.h:62
A spherical surface (3 dimensions)
Definition sdf_shape_3D.h:103
Convolutions in separated form (including Gaussian)
Definition operator.h:136
The interface for a signed distance function (sdf).
Definition sdf_domainmask.h:74
virtual double sdf(const Vector< double, NDIM > &x) const =0
Returns the signed distance from the surface,.
A simple, fixed dimension vector.
Definition vector.h:64
A parallel world class.
Definition world.h:132
real_function_3d mask
Definition dirac-hatom.cc:27
Implements (2nd generation) static load/data balancing for functions.
Main include file for MADNESS and defines Function interface.
const double pi
Mathematical constant .
Definition constants.h:48
Namespace for all elements and tools of MADNESS.
Definition DFParameters.h:10
NDIM & f
Definition mra.h:2416
void error(const char *msg)
Definition world.cc:139
Vector< T, sizeof...(Ts)+1 > vec(T t, Ts... ts)
Factory function for creating a madness::Vector.
Definition vector.h:711
Implements the SignedDFInterface for common 3-D geometric objects.
Definition test_problems.h:80
double operator()(const Key< NDIM > &key, const FunctionNode< double, NDIM > &node) const
Definition test_problems.h:86
double parent_value
Definition test_problems.h:82
double leaf_value
Definition test_problems.h:81
DirichletLBCost(double leaf_value=1.0, double parent_value=1.0)
Definition test_problems.h:83
Mask
Definition test_problems.h:74
@ LLRV
Definition test_problems.h:74
@ Gaussian
Definition test_problems.h:74
FunctorOutput
Definition test_problems.h:76
@ EXACT
Definition test_problems.h:76
@ DIRICHLET_RHS
Definition test_problems.h:76
@ DOMAIN_MASK
Definition test_problems.h:76
@ SURFACE
Definition test_problems.h:76