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 
72 using namespace madness;
73 
74 enum Mask { LLRV, Gaussian };
75 
77 
78 // load balancing structure lifted from dataloadbal.cc
79 template <int NDIM>
81  double leaf_value;
82  double parent_value;
83  DirichletLBCost(double leaf_value = 1.0, double parent_value = 1.0)
84  : leaf_value(leaf_value), parent_value(parent_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. */
102 class EmbeddedDirichlet : public FunctionFunctorInterface<double, 3> {
103  private:
106  int k;
107  double thresh;
108  std::string penalty_name;
109 
110  protected:
113  double penalty_prefact, eps;
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.
132  EmbeddedDirichlet(double penalty_prefact, std::string penalty_name,
133  double eps, int k, double thresh, Mask mask)
134  : k(k), thresh(thresh), penalty_name(penalty_name), dmi(nullptr),
135  sdfi(nullptr), penalty_prefact(penalty_prefact), eps(eps),
136  fop(DIRICHLET_RHS) {
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";
153  dmi = new GaussianDomainMask(eps);
154  break;
155  default:
156  error("Unknown mask");
157  break;
158  }
159  }
160 
161  virtual ~EmbeddedDirichlet() {
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(),
185  penalty_prefact, domain_mask_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)) *
199  penalty_prefact;
200  else
201  return dmi->mask(sdfi->sdf(x)) * Inhomogeneity(x) -
202  DirichletCond(x) * dmi->surface(sdfi->sdf(x)) *
203  penalty_prefact;
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)
247  : EmbeddedDirichlet(penalty_prefact, penalty_name, eps, k,
248  thresh, mask), radius(radius) {
249 
250  char str[80];
251  sprintf(str, "Sphere radius: %.6e\n", radius);
252  problem_specific_info = str;
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)
313  : EmbeddedDirichlet(penalty_prefact, penalty_name, eps, k,
314  thresh, mask), radius(radius) {
315 
316  char str[80];
317  sprintf(str, "Sphere radius: %.6e\n", radius);
318  problem_specific_info = str;
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)
379  : EmbeddedDirichlet(penalty_prefact, penalty_name, eps, k,
380  thresh, mask), radius(radius) {
381 
382  char str[80];
383  sprintf(str, "Sphere radius: %.6e\n", radius);
384  problem_specific_info = str;
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 */
441 class Y20Sphere : public EmbeddedDirichlet {
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)
450  : EmbeddedDirichlet(penalty_prefact, penalty_name, eps, k,
451  thresh, mask), radius(radius) {
452 
453  char str[80];
454  sprintf(str, "Sphere radius: %.6e\n", radius);
455  problem_specific_info = str;
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 */
513 class 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
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
double DirichletCond(const Vector< double, 3 > &x) const
Definition: test_problems.h:260
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
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 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
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 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
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
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
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
double radius
Definition: test_problems.h:306
double SurfaceIntegral() const
The surface area of the domain.
Definition: test_problems.h:343
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 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
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 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
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:209
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
virtual double sdf(const Vector< double, NDIM > &x) const =0
Returns the signed distance from the surface,.
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
File holds all helper structures necessary for the CC_Operator and CC2 class.
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
static const double b
Definition: nonlinschro.cc:119
static const double thresh
Definition: rk.cc:45
static const long k
Definition: rk.cc:44
Implements the SignedDFInterface for common 3-D geometric objects.
Definition: test_problems.h:80
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
pcomplex_operatorT G
Definition: tdse1d.cc:167
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