MFEM  v4.5.2
Finite element discretization library
minimal-surface.cpp
Go to the documentation of this file.
1 // Copyright (c) 2010-2023, Lawrence Livermore National Security, LLC. Produced
2 // at the Lawrence Livermore National Laboratory. All Rights reserved. See files
3 // LICENSE and NOTICE for details. LLNL-CODE-806117.
4 //
5 // This file is part of the MFEM library. For more information and source code
6 // availability visit https://mfem.org.
7 //
8 // MFEM is free software; you can redistribute it and/or modify it under the
9 // terms of the BSD-3 license. We welcome feedback and contributions, see file
10 // CONTRIBUTING.md for details.
11 //
12 // -------------------------------------------------
13 // Minimal Surface Miniapp: Compute minimal surfaces
14 // -------------------------------------------------
15 //
16 // This miniapp solves Plateau's problem: the Dirichlet problem for the minimal
17 // surface equation.
18 //
19 // Two problems can be run:
20 //
21 // - Problem 0 solves the minimal surface equation of parametric surfaces.
22 // The surface (-s) option allow the selection of different
23 // parametrization:
24 // s=0: Uses the given mesh from command line options
25 // s=1: Catenoid
26 // s=2: Helicoid
27 // s=3: Enneper
28 // s=4: Hold
29 // s=5: Costa
30 // s=6: Shell
31 // s=7: Scherk
32 // s=8: FullPeach
33 // s=9: QuarterPeach
34 // s=10: SlottedSphere
35 //
36 // - Problem 1 solves the minimal surface equation of the form z=f(x,y),
37 // for the Dirichlet problem, using Picard iterations:
38 // -div( q grad u) = 0, with q(u) = (1 + |∇u|²)^{-1/2}
39 //
40 // Compile with: make minimal-surface
41 //
42 // Sample runs: minimal-surface
43 // minimal-surface -a
44 // minimal-surface -c
45 // minimal-surface -c -a
46 // minimal-surface -no-pa
47 // minimal-surface -no-pa -a
48 // minimal-surface -no-pa -a -c
49 // minimal-surface -p 1
50 //
51 // Device sample runs:
52 // minimal-surface -d debug
53 // minimal-surface -d debug -a
54 // minimal-surface -d debug -c
55 // minimal-surface -d debug -c -a
56 // minimal-surface -d cuda
57 // minimal-surface -d cuda -a
58 // minimal-surface -d cuda -c
59 // minimal-surface -d cuda -c -a
60 // minimal-surface -d cuda -no-pa
61 // minimal-surface -d cuda -no-pa -a
62 // minimal-surface -d cuda -no-pa -c
63 // minimal-surface -d cuda -no-pa -c -a
64 
65 #include "mfem.hpp"
66 #include "../../general/forall.hpp"
67 
68 using namespace mfem;
69 
70 // Constant variables
71 constexpr int DIM = 2;
72 constexpr int SDIM = 3;
73 constexpr double PI = M_PI;
74 constexpr double NRM = 1.e-4;
75 constexpr double EPS = 1.e-14;
77 constexpr double NL_DMAX = std::numeric_limits<double>::max();
78 
79 // Static variables for GLVis
80 constexpr int GLVIZ_W = 1024;
81 constexpr int GLVIZ_H = 1024;
82 constexpr int visport = 19916;
83 constexpr char vishost[] = "localhost";
84 
85 // Context/Options for the solver
86 struct Opt
87 {
88  int sz, id;
89  int pb = 0;
90  int nx = 6;
91  int ny = 6;
92  int order = 3;
93  int refine = 2;
94  int niters = 8;
95  int surface = 5;
96  bool pa = true;
97  bool vis = true;
98  bool amr = false;
99  bool wait = false;
100  bool print = false;
101  bool radial = false;
102  bool by_vdim = false;
103  bool snapshot = false;
104  bool vis_mesh = false;
105  double tau = 1.0;
106  double lambda = 0.1;
107  double amr_threshold = 0.6;
108  const char *keys = "gAm";
109  const char *device_config = "cpu";
110  const char *mesh_file = "../../data/mobius-strip.mesh";
111  void (*Tptr)(const Vector&, Vector&) = nullptr;
112 };
113 
114 class Surface: public Mesh
115 {
116 protected:
117  Opt &opt;
118  Mesh *mesh;
119  Array<int> bc;
120  socketstream glvis;
121  H1_FECollection *fec;
122  FiniteElementSpace *fes;
123 
124 public:
125  // Reading from mesh file
126  Surface(Opt &opt, const char *file): Mesh(file, true), opt(opt) { }
127 
128  // Generate 2D empty surface mesh
129  Surface(Opt &opt, bool): Mesh(), opt(opt) { }
130 
131  // Generate 2D quad surface mesh
132  Surface(Opt &opt)
133  : Mesh(Mesh::MakeCartesian2D(opt.nx, opt.ny, QUAD, true)), opt(opt) { }
134 
135  // Generate 2D generic surface mesh
136  Surface(Opt &opt, int nv, int ne, int nbe):
137  Mesh(DIM, nv, ne, nbe, SDIM), opt(opt) { }
138 
139  void Create()
140  {
141  if (opt.surface > 0)
142  {
143  Prefix();
144  Transform();
145  }
146  Postfix();
147  Refine();
148  Snap();
149  fec = new H1_FECollection(opt.order, DIM);
150  if (opt.amr) { EnsureNCMesh(); }
151  mesh = new Mesh(*this, true);
152  fes = new FiniteElementSpace(mesh, fec, opt.by_vdim ? 1 : SDIM);
153  BoundaryConditions();
154  }
155 
156  int Solve()
157  {
158  // Initialize GLVis server if 'visualization' is set
159  if (opt.vis) { opt.vis = glvis.open(vishost, visport) == 0; }
160  // Send to GLVis the first mesh
161  if (opt.vis) { Visualize(glvis, opt, mesh, GLVIZ_W, GLVIZ_H); }
162  // Create and launch the surface solver
163  if (opt.by_vdim)
164  {
165  ByVDim(*this, opt).Solve();
166  }
167  else
168  {
169  ByNodes(*this, opt).Solve();
170  }
171  if (opt.vis && opt.snapshot)
172  {
173  opt.keys = "Sq";
174  Visualize(glvis, opt, mesh, mesh->GetNodes());
175  }
176  return 0;
177  }
178 
179  ~Surface()
180  {
181  if (opt.vis) { glvis.close(); }
182  delete mesh; delete fec; delete fes;
183  }
184 
185  virtual void Prefix()
186  {
187  SetCurvature(opt.order, false, SDIM, Ordering::byNODES);
188  }
189 
190  virtual void Transform() { if (opt.Tptr) { Mesh::Transform(opt.Tptr); } }
191 
192  virtual void Postfix()
193  {
194  SetCurvature(opt.order, false, SDIM, Ordering::byNODES);
195  }
196 
197  virtual void Refine()
198  {
199  for (int l = 0; l < opt.refine; l++)
200  {
201  UniformRefinement();
202  }
203  }
204 
205  virtual void Snap()
206  {
207  GridFunction &nodes = *GetNodes();
208  for (int i = 0; i < nodes.Size(); i++)
209  {
210  if (std::abs(nodes(i)) < EPS)
211  {
212  nodes(i) = 0.0;
213  }
214  }
215  }
216 
217  void SnapNodesToUnitSphere()
218  {
219  Vector node(SDIM);
220  GridFunction &nodes = *GetNodes();
221  for (int i = 0; i < nodes.FESpace()->GetNDofs(); i++)
222  {
223  for (int d = 0; d < SDIM; d++)
224  {
225  node(d) = nodes(nodes.FESpace()->DofToVDof(i, d));
226  }
227  node /= node.Norml2();
228  for (int d = 0; d < SDIM; d++)
229  {
230  nodes(nodes.FESpace()->DofToVDof(i, d)) = node(d);
231  }
232  }
233  }
234 
235  virtual void BoundaryConditions()
236  {
237  if (bdr_attributes.Size())
238  {
239  Array<int> ess_bdr(bdr_attributes.Max());
240  ess_bdr = 1;
241  bc.HostReadWrite();
242  fes->GetEssentialTrueDofs(ess_bdr, bc);
243  }
244  }
245 
246  // Initialize visualization of some given mesh
247  static void Visualize(socketstream &glvis,
248  Opt &opt, const Mesh *mesh,
249  const int w, const int h,
250  const GridFunction *sol = nullptr)
251  {
252  const GridFunction &solution = sol ? *sol : *mesh->GetNodes();
253  if (opt.vis_mesh) { glvis << "mesh\n" << *mesh; }
254  else { glvis << "solution\n" << *mesh << solution; }
255  glvis.precision(8);
256  glvis << "window_size " << w << " " << h << "\n";
257  glvis << "keys " << opt.keys << "\n";
258  opt.keys = nullptr;
259  if (opt.wait) { glvis << "pause\n"; }
260  glvis << std::flush;
261  }
262 
263  // Visualize some solution on the given mesh
264  static void Visualize(socketstream &glvis,
265  const Opt &opt, const Mesh *mesh,
266  const GridFunction *sol = nullptr)
267  {
268  const GridFunction &solution = sol ? *sol : *mesh->GetNodes();
269  if (opt.vis_mesh) { glvis << "mesh\n" << *mesh; }
270  else { glvis << "solution\n" << *mesh << solution; }
271  if (opt.wait) { glvis << "pause\n"; }
272  if (opt.snapshot && opt.keys) { glvis << "keys " << opt.keys << "\n"; }
273  glvis << std::flush;
274  }
275 
276  using Mesh::Print;
277  static void Print(const Opt &opt, Mesh *mesh, const GridFunction *sol)
278  {
279  const char *mesh_file = "surface.mesh";
280  const char *sol_file = "sol.gf";
281  if (!opt.id)
282  {
283  mfem::out << "Printing " << mesh_file << ", " << sol_file << std::endl;
284  }
285 
286  std::ofstream mesh_ofs(mesh_file);
287  mesh_ofs.precision(8);
288  mesh->Print(mesh_ofs);
289  mesh_ofs.close();
290 
291  std::ofstream sol_ofs(sol_file);
292  sol_ofs.precision(8);
293  sol->Save(sol_ofs);
294  sol_ofs.close();
295  }
296 
297  // Surface Solver class
298  class Solver
299  {
300  protected:
301  Opt &opt;
302  Surface &S;
303  CGSolver cg;
304  OperatorPtr A;
305  BilinearForm a;
306  GridFunction x, x0, b;
308  mfem::Solver *M = nullptr;
309  const int print_iter = -1, max_num_iter = 2000;
310  const double RTOLERANCE = EPS, ATOLERANCE = EPS*EPS;
311  public:
312  Solver(Surface &S, Opt &opt): opt(opt), S(S), cg(),
313  a(S.fes), x(S.fes), x0(S.fes), b(S.fes), one(1.0)
314  {
315  cg.SetRelTol(RTOLERANCE);
316  cg.SetAbsTol(ATOLERANCE);
317  cg.SetMaxIter(max_num_iter);
318  cg.SetPrintLevel(print_iter);
319  }
320 
321  ~Solver() { delete M; }
322 
323  void Solve()
324  {
325  constexpr bool converged = true;
326  if (opt.pa) { a.SetAssemblyLevel(AssemblyLevel::PARTIAL);}
327  for (int i=0; i < opt.niters; ++i)
328  {
329  if (opt.amr) { Amr(); }
330  if (opt.vis) { Surface::Visualize(S.glvis, opt, S.mesh); }
331  if (!opt.id) { mfem::out << "Iteration " << i << ": "; }
332  S.mesh->NodesUpdated();
333  a.Update();
334  a.Assemble();
335  if (Step() == converged) { break; }
336  }
337  if (opt.print) { Surface::Print(opt, S.mesh, S.mesh->GetNodes()); }
338  }
339 
340  virtual bool Step() = 0;
341 
342  protected:
343  bool Converged(const double rnorm) { return rnorm < NRM; }
344 
345  bool ParAXeqB()
346  {
347  b = 0.0;
348  Vector X, B;
349  a.FormLinearSystem(S.bc, x, b, A, X, B);
350  if (!opt.pa) { M = new GSSmoother((SparseMatrix&)(*A)); }
351  if (M) { cg.SetPreconditioner(*M); }
352  cg.SetOperator(*A);
353  cg.Mult(B, X);
354  a.RecoverFEMSolution(X, b, x);
355  const bool by_vdim = opt.by_vdim;
356  GridFunction *nodes = by_vdim ? &x0 : S.fes->GetMesh()->GetNodes();
357  x.HostReadWrite();
358  nodes->HostRead();
359  double rnorm = nodes->DistanceTo(x) / nodes->Norml2();
360  if (!opt.id) { mfem::out << "rnorm = " << rnorm << std::endl; }
361  const double lambda = opt.lambda;
362  if (by_vdim)
363  {
364  MFEM_VERIFY(!opt.radial,"'VDim solver can't use radial option!");
365  return Converged(rnorm);
366  }
367  if (opt.radial)
368  {
369  GridFunction delta(S.fes);
370  subtract(x, *nodes, delta); // delta = x - nodes
371  // position and Δ vectors at point i
372  Vector ni(SDIM), di(SDIM);
373  for (int i = 0; i < delta.Size()/SDIM; i++)
374  {
375  // extract local vectors
376  const int ndof = S.fes->GetNDofs();
377  for (int d = 0; d < SDIM; d++)
378  {
379  ni(d) = (*nodes)(d*ndof + i);
380  di(d) = delta(d*ndof + i);
381  }
382  // project the delta vector in radial direction
383  const double ndotd = (ni*di) / (ni*ni);
384  di.Set(ndotd,ni);
385  // set global vectors
386  for (int d = 0; d < SDIM; d++) { delta(d*ndof + i) = di(d); }
387  }
388  add(*nodes, delta, *nodes);
389  }
390  // x = lambda*nodes + (1-lambda)*x
391  add(lambda, *nodes, (1.0-lambda), x, x);
392  return Converged(rnorm);
393  }
394 
395  void Amr()
396  {
397  MFEM_VERIFY(opt.amr_threshold >= 0.0 && opt.amr_threshold <= 1.0, "");
398  Mesh *smesh = S.mesh;
399  Array<Refinement> amr;
400  const int NE = smesh->GetNE();
401  DenseMatrix Jadjt, Jadj(DIM, SDIM);
402  for (int e = 0; e < NE; e++)
403  {
404  double minW = +NL_DMAX;
405  double maxW = -NL_DMAX;
407  const Geometry::Type &type =
408  smesh->GetElement(e)->GetGeometryType();
409  const IntegrationRule *ir = &IntRules.Get(type, opt.order);
410  const int NQ = ir->GetNPoints();
411  for (int q = 0; q < NQ; q++)
412  {
413  eTr->SetIntPoint(&ir->IntPoint(q));
414  const DenseMatrix &J = eTr->Jacobian();
415  CalcAdjugate(J, Jadj);
416  Jadjt = Jadj;
417  Jadjt.Transpose();
418  const double w = Jadjt.Weight();
419  minW = std::fmin(minW, w);
420  maxW = std::fmax(maxW, w);
421  }
422  if (std::fabs(maxW) != 0.0)
423  {
424  const double rho = minW / maxW;
425  MFEM_VERIFY(rho <= 1.0, "");
426  if (rho < opt.amr_threshold) { amr.Append(Refinement(e)); }
427  }
428  }
429  if (amr.Size()>0)
430  {
431  smesh->GetNodes()->HostReadWrite();
432  smesh->GeneralRefinement(amr);
433  S.fes->Update();
434  x.HostReadWrite();
435  x.Update();
436  a.Update();
437  b.HostReadWrite();
438  b.Update();
439  S.BoundaryConditions();
440  }
441  }
442  };
443 
444  // Surface solver 'by vector'
445  class ByNodes: public Solver
446  {
447  public:
448  ByNodes(Surface &S, Opt &opt): Solver(S, opt)
449  { a.AddDomainIntegrator(new VectorDiffusionIntegrator(one)); }
450 
451  bool Step()
452  {
453  x = *S.fes->GetMesh()->GetNodes();
454  bool converge = ParAXeqB();
455  S.mesh->SetNodes(x);
456  return converge ? true : false;
457  }
458  };
459 
460  // Surface solver 'by ByVDim'
461  class ByVDim: public Solver
462  {
463  public:
464  void SetNodes(const GridFunction &Xi, const int c)
465  {
466  auto d_Xi = Xi.Read();
467  auto d_nodes = S.fes->GetMesh()->GetNodes()->Write();
468  const int ndof = S.fes->GetNDofs();
469  MFEM_FORALL(i, ndof, d_nodes[c*ndof + i] = d_Xi[i]; );
470  }
471 
472  void GetNodes(GridFunction &Xi, const int c)
473  {
474  auto d_Xi = Xi.Write();
475  const int ndof = S.fes->GetNDofs();
476  auto d_nodes = S.fes->GetMesh()->GetNodes()->Read();
477  MFEM_FORALL(i, ndof, d_Xi[i] = d_nodes[c*ndof + i]; );
478  }
479 
480  ByVDim(Surface &S, Opt &opt): Solver(S, opt)
481  { a.AddDomainIntegrator(new DiffusionIntegrator(one)); }
482 
483  bool Step()
484  {
485  bool cvg[SDIM] {false};
486  for (int c=0; c < SDIM; ++c)
487  {
488  GetNodes(x, c);
489  x0 = x;
490  cvg[c] = ParAXeqB();
491  SetNodes(x, c);
492  }
493  const bool converged = cvg[0] && cvg[1] && cvg[2];
494  return converged ? true : false;
495  }
496  };
497 };
498 
499 // #0: Default surface mesh file
500 struct MeshFromFile: public Surface
501 {
502  MeshFromFile(Opt &opt): Surface(opt, opt.mesh_file) { }
503 };
504 
505 // #1: Catenoid surface
506 struct Catenoid: public Surface
507 {
508  Catenoid(Opt &opt): Surface((opt.Tptr = Parametrization, opt)) { }
509 
510  void Prefix()
511  {
512  SetCurvature(opt.order, false, SDIM, Ordering::byNODES);
513  Array<int> v2v(GetNV());
514  for (int i = 0; i < v2v.Size(); i++) { v2v[i] = i; }
515  // identify vertices on vertical lines
516  for (int j = 0; j <= opt.ny; j++)
517  {
518  const int v_old = opt.nx + j * (opt.nx + 1);
519  const int v_new = j * (opt.nx + 1);
520  v2v[v_old] = v_new;
521  }
522  // renumber elements
523  for (int i = 0; i < GetNE(); i++)
524  {
525  Element *el = GetElement(i);
526  int *v = el->GetVertices();
527  const int nv = el->GetNVertices();
528  for (int j = 0; j < nv; j++)
529  {
530  v[j] = v2v[v[j]];
531  }
532  }
533  // renumber boundary elements
534  for (int i = 0; i < GetNBE(); i++)
535  {
536  Element *el = GetBdrElement(i);
537  int *v = el->GetVertices();
538  const int nv = el->GetNVertices();
539  for (int j = 0; j < nv; j++)
540  {
541  v[j] = v2v[v[j]];
542  }
543  }
544  RemoveUnusedVertices();
545  RemoveInternalBoundaries();
546  }
547 
548  static void Parametrization(const Vector &x, Vector &p)
549  {
550  p.SetSize(SDIM);
551  // u in [0,2π] and v in [-π/6,π/6]
552  const double u = 2.0*PI*x[0];
553  const double v = PI*(x[1]-0.5)/3.;
554  p[0] = cos(u);
555  p[1] = sin(u);
556  p[2] = v;
557  }
558 };
559 
560 // #2: Helicoid surface
561 struct Helicoid: public Surface
562 {
563  Helicoid(Opt &opt): Surface((opt.Tptr = Parametrization, opt)) { }
564 
565  static void Parametrization(const Vector &x, Vector &p)
566  {
567  p.SetSize(SDIM);
568  // u in [0,2π] and v in [-2π/3,2π/3]
569  const double u = 2.0*PI*x[0];
570  const double v = 2.0*PI*(2.0*x[1]-1.0)/3.0;
571  p(0) = sin(u)*v;
572  p(1) = cos(u)*v;
573  p(2) = u;
574  }
575 };
576 
577 // #3: Enneper's surface
578 struct Enneper: public Surface
579 {
580  Enneper(Opt &opt): Surface((opt.Tptr = Parametrization, opt)) { }
581 
582  static void Parametrization(const Vector &x, Vector &p)
583  {
584  p.SetSize(SDIM);
585  // (u,v) in [-2, +2]
586  const double u = 4.0*(x[0]-0.5);
587  const double v = 4.0*(x[1]-0.5);
588  p[0] = +u - u*u*u/3.0 + u*v*v;
589  p[1] = -v - u*u*v + v*v*v/3.0;
590  p[2] = u*u - v*v;
591  }
592 };
593 
594 // #4: Hold surface
595 struct Hold: public Surface
596 {
597  Hold(Opt &opt): Surface((opt.Tptr = Parametrization, opt)) { }
598 
599  void Prefix()
600  {
601  SetCurvature(opt.order, false, SDIM, Ordering::byNODES);
602  Array<int> v2v(GetNV());
603  for (int i = 0; i < v2v.Size(); i++) { v2v[i] = i; }
604  // identify vertices on vertical lines
605  for (int j = 0; j <= opt.ny; j++)
606  {
607  const int v_old = opt.nx + j * (opt.nx + 1);
608  const int v_new = j * (opt.nx + 1);
609  v2v[v_old] = v_new;
610  }
611  // renumber elements
612  for (int i = 0; i < GetNE(); i++)
613  {
614  Element *el = GetElement(i);
615  int *v = el->GetVertices();
616  const int nv = el->GetNVertices();
617  for (int j = 0; j < nv; j++)
618  {
619  v[j] = v2v[v[j]];
620  }
621  }
622  // renumber boundary elements
623  for (int i = 0; i < GetNBE(); i++)
624  {
625  Element *el = GetBdrElement(i);
626  int *v = el->GetVertices();
627  const int nv = el->GetNVertices();
628  for (int j = 0; j < nv; j++)
629  {
630  v[j] = v2v[v[j]];
631  }
632  }
633  RemoveUnusedVertices();
634  RemoveInternalBoundaries();
635  }
636 
637  static void Parametrization(const Vector &x, Vector &p)
638  {
639  p.SetSize(SDIM);
640  // u in [0,2π] and v in [0,1]
641  const double u = 2.0*PI*x[0];
642  const double v = x[1];
643  p[0] = cos(u)*(1.0 + 0.3*sin(3.*u + PI*v));
644  p[1] = sin(u)*(1.0 + 0.3*sin(3.*u + PI*v));
645  p[2] = v;
646  }
647 };
648 
649 // #5: Costa minimal surface
650 #include <complex>
651 using cdouble = std::complex<double>;
652 #define I cdouble(0.0, 1.0)
653 
654 // https://dlmf.nist.gov/20.2
655 cdouble EllipticTheta(const int a, const cdouble u, const cdouble q)
656 {
657  cdouble J = 0.0;
658  double delta = std::numeric_limits<double>::max();
659  switch (a)
660  {
661  case 1:
662  for (int n=0; delta > EPS; n+=1)
663  {
664  const cdouble j = pow(-1,n)*pow(q,n*(n+1.0))*sin((2.0*n+1.0)*u);
665  delta = abs(j);
666  J += j;
667  }
668  return 2.0*pow(q,0.25)*J;
669 
670  case 2:
671  for (int n=0; delta > EPS; n+=1)
672  {
673  const cdouble j = pow(q,n*(n+1))*cos((2.0*n+1.0)*u);
674  delta = abs(j);
675  J += j;
676  }
677  return 2.0*pow(q,0.25)*J;
678  case 3:
679  for (int n=1; delta > EPS; n+=1)
680  {
681  const cdouble j = pow(q,n*n)*cos(2.0*n*u);
682  delta = abs(j);
683  J += j;
684  }
685  return 1.0 + 2.0*J;
686  case 4:
687  for (int n=1; delta > EPS; n+=1)
688  {
689  const cdouble j =pow(-1,n)*pow(q,n*n)*cos(2.0*n*u);
690  delta = abs(j);
691  J += j;
692  }
693  return 1.0 + 2.0*J;
694  }
695  return J;
696 }
697 
698 // https://dlmf.nist.gov/23.6#E5
700  const cdouble w1 = 0.5,
701  const cdouble w3 = 0.5*I)
702 {
703  const cdouble tau = w3/w1;
704  const cdouble q = exp(I*M_PI*tau);
705  const cdouble e1 = M_PI*M_PI/(12.0*w1*w1)*
706  (1.0*pow(EllipticTheta(2,0,q),4) +
707  2.0*pow(EllipticTheta(4,0,q),4));
708  const cdouble u = M_PI*z / (2.0*w1);
709  const cdouble P = M_PI * EllipticTheta(3,0,q)*EllipticTheta(4,0,q) *
710  EllipticTheta(2,u,q)/(2.0*w1*EllipticTheta(1,u,q));
711  return P*P + e1;
712 }
713 
714 cdouble EllipticTheta1Prime(const int k, const cdouble u, const cdouble q)
715 {
716  cdouble J = 0.0;
717  double delta = std::numeric_limits<double>::max();
718  for (int n=0; delta > EPS; n+=1)
719  {
720  const double alpha = 2.0*n+1.0;
721  const cdouble Dcosine = pow(alpha,k)*sin(k*M_PI/2.0 + alpha*u);
722  const cdouble j = pow(-1,n)*pow(q,n*(n+1.0))*Dcosine;
723  delta = abs(j);
724  J += j;
725  }
726  return 2.0*pow(q,0.25)*J;
727 }
728 
729 // Logarithmic Derivative of Theta Function 1
731 {
732  cdouble J = 0.0;
733  double delta = std::numeric_limits<double>::max();
734  for (int n=1; delta > EPS; n+=1)
735  {
736  cdouble q2n = pow(q, 2*n);
737  if (abs(q2n) < EPS) { q2n = 0.0; }
738  const cdouble j = q2n/(1.0-q2n)*sin(2.0*n*u);
739  delta = abs(j);
740  J += j;
741  }
742  return 1.0/tan(u) + 4.0*J;
743 }
744 
745 // https://dlmf.nist.gov/23.6#E13
747  const cdouble w1 = 0.5,
748  const cdouble w3 = 0.5*I)
749 {
750  const cdouble tau = w3/w1;
751  const cdouble q = exp(I*M_PI*tau);
752  const cdouble n1 = -M_PI*M_PI/(12.0*w1) *
753  (EllipticTheta1Prime(3,0,q)/
754  EllipticTheta1Prime(1,0,q));
755  const cdouble u = M_PI*z / (2.0*w1);
756  return z*n1/w1 + M_PI/(2.0*w1)*LogEllipticTheta1Prime(u,q);
757 }
758 
759 // https://www.mathcurve.com/surfaces.gb/costa/costa.shtml
760 static double ALPHA[4] {0.0};
761 struct Costa: public Surface
762 {
763  Costa(Opt &opt): Surface((opt.Tptr = Parametrization, opt), false) { }
764 
765  void Prefix()
766  {
767  ALPHA[3] = opt.tau;
768  const int nx = opt.nx, ny = opt.ny;
769  MFEM_VERIFY(nx>2 && ny>2, "");
770  const int nXhalf = (nx%2)==0 ? 4 : 2;
771  const int nYhalf = (ny%2)==0 ? 4 : 2;
772  const int nxh = nXhalf + nYhalf;
773  const int NVert = (nx+1) * (ny+1);
774  const int NElem = nx*ny - 4 - nxh;
775  const int NBdrElem = 0;
776  InitMesh(DIM, SDIM, NVert, NElem, NBdrElem);
777  // Sets vertices and the corresponding coordinates
778  for (int j = 0; j <= ny; j++)
779  {
780  const double cy = ((double) j / ny) ;
781  for (int i = 0; i <= nx; i++)
782  {
783  const double cx = ((double) i / nx);
784  const double coords[SDIM] = {cx, cy, 0.0};
785  AddVertex(coords);
786  }
787  }
788  // Sets elements and the corresponding indices of vertices
789  for (int j = 0; j < ny; j++)
790  {
791  for (int i = 0; i < nx; i++)
792  {
793  if (i == 0 && j == 0) { continue; }
794  if (i+1 == nx && j == 0) { continue; }
795  if (i == 0 && j+1 == ny) { continue; }
796  if (i+1 == nx && j+1 == ny) { continue; }
797  if ((j == 0 || j+1 == ny) && (abs(nx-(i<<1)-1)<=1)) { continue; }
798  if ((i == 0 || i+1 == nx) && (abs(ny-(j<<1)-1)<=1)) { continue; }
799  const int i0 = i + j*(nx+1);
800  const int i1 = i+1 + j*(nx+1);
801  const int i2 = i+1 + (j+1)*(nx+1);
802  const int i3 = i + (j+1)*(nx+1);
803  const int ind[4] = {i0, i1, i2, i3};
804  AddQuad(ind);
805  }
806  }
807  RemoveUnusedVertices();
808  FinalizeQuadMesh(false, 0, true);
809  FinalizeTopology();
810  SetCurvature(opt.order, false, SDIM, Ordering::byNODES);
811  }
812 
813  static void Parametrization(const Vector &X, Vector &p)
814  {
815  const double tau = ALPHA[3];
816  Vector x = X;
817  x -= +0.5;
818  x *= tau;
819  x -= -0.5;
820 
821  p.SetSize(3);
822  const bool y_top = x[1] > 0.5;
823  const bool x_top = x[0] > 0.5;
824  double u = x[0];
825  double v = x[1];
826  if (y_top) { v = 1.0 - x[1]; }
827  if (x_top) { u = 1.0 - x[0]; }
828  const cdouble w = u + I*v;
829  const cdouble w3 = I/2.;
830  const cdouble w1 = 1./2.;
831  const cdouble pw = WeierstrassP(w);
832  const cdouble e1 = WeierstrassP(0.5);
833  const cdouble zw = WeierstrassZeta(w);
834  const cdouble dw = WeierstrassZeta(w-w1) - WeierstrassZeta(w-w3);
835  p[0] = real(PI*(u+PI/(4.*e1))- zw +PI/(2.*e1)*(dw));
836  p[1] = real(PI*(v+PI/(4.*e1))-I*zw-PI*I/(2.*e1)*(dw));
837  p[2] = sqrt(PI/2.)*log(abs((pw-e1)/(pw+e1)));
838  if (y_top) { p[1] *= -1.0; }
839  if (x_top) { p[0] *= -1.0; }
840  const bool nan = std::isnan(p[0]) || std::isnan(p[1]) || std::isnan(p[2]);
841  MFEM_VERIFY(!nan, "nan");
842  ALPHA[0] = std::fmax(p[0], ALPHA[0]);
843  ALPHA[1] = std::fmax(p[1], ALPHA[1]);
844  ALPHA[2] = std::fmax(p[2], ALPHA[2]);
845  }
846 
847  void Snap()
848  {
849  Vector node(SDIM);
850  MFEM_VERIFY(ALPHA[0] > 0.0,"");
851  MFEM_VERIFY(ALPHA[1] > 0.0,"");
852  MFEM_VERIFY(ALPHA[2] > 0.0,"");
853  GridFunction &nodes = *GetNodes();
854  const double phi = (1.0 + sqrt(5.0)) / 2.0;
855  for (int i = 0; i < nodes.FESpace()->GetNDofs(); i++)
856  {
857  for (int d = 0; d < SDIM; d++)
858  {
859  const double alpha = d==2 ? phi : 1.0;
860  const int vdof = nodes.FESpace()->DofToVDof(i, d);
861  nodes(vdof) /= alpha * ALPHA[d];
862  }
863  }
864  }
865 };
866 
867 // #6: Shell surface model
868 struct Shell: public Surface
869 {
870  Shell(Opt &opt): Surface((opt.niters = 1, opt.Tptr = Parametrization, opt)) { }
871 
872  static void Parametrization(const Vector &x, Vector &p)
873  {
874  p.SetSize(3);
875  // u in [0,2π] and v in [-15, 6]
876  const double u = 2.0*PI*x[0];
877  const double v = 21.0*x[1]-15.0;
878  p[0] = +1.0*pow(1.16,v)*cos(v)*(1.0+cos(u));
879  p[1] = -1.0*pow(1.16,v)*sin(v)*(1.0+cos(u));
880  p[2] = -2.0*pow(1.16,v)*(1.0+sin(u));
881  }
882 };
883 
884 // #7: Scherk's doubly periodic surface
885 struct Scherk: public Surface
886 {
887  static void Parametrization(const Vector &x, Vector &p)
888  {
889  p.SetSize(SDIM);
890  const double alpha = 0.49;
891  // (u,v) in [-απ, +απ]
892  const double u = alpha*PI*(2.0*x[0]-1.0);
893  const double v = alpha*PI*(2.0*x[1]-1.0);
894  p[0] = u;
895  p[1] = v;
896  p[2] = log(cos(v)/cos(u));
897  }
898 
899  Scherk(Opt &opt): Surface((opt.Tptr = Parametrization, opt)) { }
900 };
901 
902 // #8: Full Peach street model
903 struct FullPeach: public Surface
904 {
905  static constexpr int NV = 8;
906  static constexpr int NE = 6;
907 
908  FullPeach(Opt &opt):
909  Surface((opt.niters = std::min(4, opt.niters), opt), NV, NE, 0) { }
910 
911  void Prefix()
912  {
913  const double quad_v[NV][SDIM] =
914  {
915  {-1, -1, -1}, {+1, -1, -1}, {+1, +1, -1}, {-1, +1, -1},
916  {-1, -1, +1}, {+1, -1, +1}, {+1, +1, +1}, {-1, +1, +1}
917  };
918  const int quad_e[NE][4] =
919  {
920  {3, 2, 1, 0}, {0, 1, 5, 4}, {1, 2, 6, 5},
921  {2, 3, 7, 6}, {3, 0, 4, 7}, {4, 5, 6, 7}
922 
923  };
924  for (int j = 0; j < NV; j++) { AddVertex(quad_v[j]); }
925  for (int j = 0; j < NE; j++) { AddQuad(quad_e[j], j+1); }
926 
927  FinalizeQuadMesh(false, 0, true);
928  FinalizeTopology(false);
929  UniformRefinement();
930  SetCurvature(opt.order, false, SDIM, Ordering::byNODES);
931  }
932 
933  void Snap() { SnapNodesToUnitSphere(); }
934 
935  void BoundaryConditions()
936  {
937  Vector X(SDIM);
938  Array<int> dofs;
939  Array<int> ess_vdofs, ess_tdofs;
940  ess_vdofs.SetSize(fes->GetVSize());
941  MFEM_VERIFY(fes->GetVSize() >= fes->GetTrueVSize(),"");
942  ess_vdofs = 0;
943  DenseMatrix PointMat;
944  mesh->GetNodes()->HostRead();
945  for (int e = 0; e < fes->GetNE(); e++)
946  {
947  fes->GetElementDofs(e, dofs);
948  const IntegrationRule &ir = fes->GetFE(e)->GetNodes();
950  eTr->Transform(ir, PointMat);
951  Vector one(dofs.Size());
952  for (int dof = 0; dof < dofs.Size(); dof++)
953  {
954  one = 0.0;
955  one[dof] = 1.0;
956  const int k = dofs[dof];
957  MFEM_ASSERT(k >= 0, "");
958  PointMat.Mult(one, X);
959  const bool halfX = std::fabs(X[0]) < EPS && X[1] <= 0.0;
960  const bool halfY = std::fabs(X[2]) < EPS && X[1] >= 0.0;
961  const bool is_on_bc = halfX || halfY;
962  for (int c = 0; c < SDIM; c++)
963  { ess_vdofs[fes->DofToVDof(k, c)] = is_on_bc; }
964  }
965  }
966  const SparseMatrix *R = fes->GetRestrictionMatrix();
967  if (!R)
968  {
969  ess_tdofs.MakeRef(ess_vdofs);
970  }
971  else
972  {
973  R->BooleanMult(ess_vdofs, ess_tdofs);
974  }
975  bc.HostReadWrite();
976  FiniteElementSpace::MarkerToList(ess_tdofs, bc);
977  }
978 };
979 
980 // #9: 1/4th Peach street model
981 struct QuarterPeach: public Surface
982 {
983  QuarterPeach(Opt &opt): Surface((opt.Tptr = Parametrization, opt)) { }
984 
985  static void Parametrization(const Vector &X, Vector &p)
986  {
987  p = X;
988  const double x = 2.0*X[0]-1.0;
989  const double y = X[1];
990  const double r = sqrt(x*x + y*y);
991  const double t = (x==0.0) ? PI/2.0 :
992  (y==0.0 && x>0.0) ? 0. :
993  (y==0.0 && x<0.0) ? PI : acos(x/r);
994  const double sqrtx = sqrt(1.0 + x*x);
995  const double sqrty = sqrt(1.0 + y*y);
996  const bool yaxis = PI/4.0<t && t < 3.0*PI/4.0;
997  const double R = yaxis?sqrtx:sqrty;
998  const double gamma = r/R;
999  p[0] = gamma * cos(t);
1000  p[1] = gamma * sin(t);
1001  p[2] = 1.0 - gamma;
1002  }
1003 
1004  void Postfix()
1005  {
1006  for (int i = 0; i < GetNBE(); i++)
1007  {
1008  Element *el = GetBdrElement(i);
1009  const int fn = GetBdrElementEdgeIndex(i);
1010  MFEM_VERIFY(!FaceIsTrueInterior(fn),"");
1011  Array<int> vertices;
1012  GetFaceVertices(fn, vertices);
1013  const GridFunction *nodes = GetNodes();
1014  Vector nval;
1015  double R[2], X[2][SDIM];
1016  for (int v = 0; v < 2; v++)
1017  {
1018  R[v] = 0.0;
1019  const int iv = vertices[v];
1020  for (int d = 0; d < SDIM; d++)
1021  {
1022  nodes->GetNodalValues(nval, d+1);
1023  const double x = X[v][d] = nval[iv];
1024  if (d < 2) { R[v] += x*x; }
1025  }
1026  }
1027  if (std::fabs(X[0][1])<=EPS && std::fabs(X[1][1])<=EPS &&
1028  (R[0]>0.1 || R[1]>0.1))
1029  { el->SetAttribute(1); }
1030  else { el->SetAttribute(2); }
1031  }
1032  }
1033 };
1034 
1035 // #10: Slotted sphere mesh
1036 struct SlottedSphere: public Surface
1037 {
1038  SlottedSphere(Opt &opt): Surface((opt.niters = 4, opt), 64, 40, 0) { }
1039 
1040  void Prefix()
1041  {
1042  constexpr double delta = 0.15;
1043  constexpr int NV1D = 4;
1044  constexpr int NV = NV1D*NV1D*NV1D;
1045  constexpr int NEPF = (NV1D-1)*(NV1D-1);
1046  constexpr int NE = NEPF*6;
1047  const double V1D[NV1D] = {-1.0, -delta, delta, 1.0};
1048  double QV[NV][3];
1049  for (int iv=0; iv<NV; ++iv)
1050  {
1051  int ix = iv % NV1D;
1052  int iy = (iv / NV1D) % NV1D;
1053  int iz = (iv / NV1D) / NV1D;
1054 
1055  QV[iv][0] = V1D[ix];
1056  QV[iv][1] = V1D[iy];
1057  QV[iv][2] = V1D[iz];
1058  }
1059  int QE[NE][4];
1060  for (int ix=0; ix<NV1D-1; ++ix)
1061  {
1062  for (int iy=0; iy<NV1D-1; ++iy)
1063  {
1064  int el_offset = ix + iy*(NV1D-1);
1065  // x = 0
1066  QE[0*NEPF + el_offset][0] = NV1D*ix + NV1D*NV1D*iy;
1067  QE[0*NEPF + el_offset][1] = NV1D*(ix+1) + NV1D*NV1D*iy;
1068  QE[0*NEPF + el_offset][2] = NV1D*(ix+1) + NV1D*NV1D*(iy+1);
1069  QE[0*NEPF + el_offset][3] = NV1D*ix + NV1D*NV1D*(iy+1);
1070  // x = 1
1071  int x_off = NV1D-1;
1072  QE[1*NEPF + el_offset][3] = x_off + NV1D*ix + NV1D*NV1D*iy;
1073  QE[1*NEPF + el_offset][2] = x_off + NV1D*(ix+1) + NV1D*NV1D*iy;
1074  QE[1*NEPF + el_offset][1] = x_off + NV1D*(ix+1) + NV1D*NV1D*(iy+1);
1075  QE[1*NEPF + el_offset][0] = x_off + NV1D*ix + NV1D*NV1D*(iy+1);
1076  // y = 0
1077  QE[2*NEPF + el_offset][0] = NV1D*NV1D*iy + ix;
1078  QE[2*NEPF + el_offset][1] = NV1D*NV1D*iy + ix + 1;
1079  QE[2*NEPF + el_offset][2] = NV1D*NV1D*(iy+1) + ix + 1;
1080  QE[2*NEPF + el_offset][3] = NV1D*NV1D*(iy+1) + ix;
1081  // y = 1
1082  int y_off = NV1D*(NV1D-1);
1083  QE[3*NEPF + el_offset][0] = y_off + NV1D*NV1D*iy + ix;
1084  QE[3*NEPF + el_offset][1] = y_off + NV1D*NV1D*iy + ix + 1;
1085  QE[3*NEPF + el_offset][2] = y_off + NV1D*NV1D*(iy+1) + ix + 1;
1086  QE[3*NEPF + el_offset][3] = y_off + NV1D*NV1D*(iy+1) + ix;
1087  // z = 0
1088  QE[4*NEPF + el_offset][0] = NV1D*iy + ix;
1089  QE[4*NEPF + el_offset][1] = NV1D*iy + ix + 1;
1090  QE[4*NEPF + el_offset][2] = NV1D*(iy+1) + ix + 1;
1091  QE[4*NEPF + el_offset][3] = NV1D*(iy+1) + ix;
1092  // z = 1
1093  int z_off = NV1D*NV1D*(NV1D-1);
1094  QE[5*NEPF + el_offset][0] = z_off + NV1D*iy + ix;
1095  QE[5*NEPF + el_offset][1] = z_off + NV1D*iy + ix + 1;
1096  QE[5*NEPF + el_offset][2] = z_off + NV1D*(iy+1) + ix + 1;
1097  QE[5*NEPF + el_offset][3] = z_off + NV1D*(iy+1) + ix;
1098  }
1099  }
1100  // Delete on x = 0 face
1101  QE[0*NEPF + 1 + 2*(NV1D-1)][0] = -1;
1102  QE[0*NEPF + 1 + 1*(NV1D-1)][0] = -1;
1103  // Delete on x = 1 face
1104  QE[1*NEPF + 1 + 2*(NV1D-1)][0] = -1;
1105  QE[1*NEPF + 1 + 1*(NV1D-1)][0] = -1;
1106  // Delete on y = 1 face
1107  QE[3*NEPF + 1 + 0*(NV1D-1)][0] = -1;
1108  QE[3*NEPF + 1 + 1*(NV1D-1)][0] = -1;
1109  // Delete on z = 1 face
1110  QE[5*NEPF + 0 + 1*(NV1D-1)][0] = -1;
1111  QE[5*NEPF + 1 + 1*(NV1D-1)][0] = -1;
1112  QE[5*NEPF + 2 + 1*(NV1D-1)][0] = -1;
1113  // Delete on z = 0 face
1114  QE[4*NEPF + 1 + 0*(NV1D-1)][0] = -1;
1115  QE[4*NEPF + 1 + 1*(NV1D-1)][0] = -1;
1116  QE[4*NEPF + 1 + 2*(NV1D-1)][0] = -1;
1117  // Delete on y = 0 face
1118  QE[2*NEPF + 1 + 0*(NV1D-1)][0] = -1;
1119  QE[2*NEPF + 1 + 1*(NV1D-1)][0] = -1;
1120  for (int j = 0; j < NV; j++) { AddVertex(QV[j]); }
1121  for (int j = 0; j < NE; j++)
1122  {
1123  if (QE[j][0] < 0) { continue; }
1124  AddQuad(QE[j], j+1);
1125  }
1126  RemoveUnusedVertices();
1127  FinalizeQuadMesh(false, 0, true);
1128  EnsureNodes();
1129  FinalizeTopology();
1130  }
1131 
1132  void Snap() { SnapNodesToUnitSphere(); }
1133 };
1134 
1135 static int Problem0(Opt &opt)
1136 {
1137  // Create our surface mesh from command line options
1138  Surface *S = nullptr;
1139  switch (opt.surface)
1140  {
1141  case 0: S = new MeshFromFile(opt); break;
1142  case 1: S = new Catenoid(opt); break;
1143  case 2: S = new Helicoid(opt); break;
1144  case 3: S = new Enneper(opt); break;
1145  case 4: S = new Hold(opt); break;
1146  case 5: S = new Costa(opt); break;
1147  case 6: S = new Shell(opt); break;
1148  case 7: S = new Scherk(opt); break;
1149  case 8: S = new FullPeach(opt); break;
1150  case 9: S = new QuarterPeach(opt); break;
1151  case 10: S = new SlottedSphere(opt); break;
1152  default: MFEM_ABORT("Unknown surface (surface <= 10)!");
1153  }
1154  S->Create();
1155  S->Solve();
1156  delete S;
1157  return 0;
1158 }
1159 
1160 // Problem 1: solve the Dirichlet problem for the minimal surface equation
1161 // of the form z=f(x,y), using Picard iterations.
1162 static double u0(const Vector &x) { return sin(3.0 * PI * (x[1] + x[0])); }
1163 
1164 enum {NORM, AREA};
1165 
1166 static double qf(const int order, const int ker, Mesh &m,
1168 {
1169  const Geometry::Type type = m.GetElementBaseGeometry(0);
1170  const IntegrationRule &ir(IntRules.Get(type, order));
1172 
1173  const int NE(m.GetNE());
1174  const int ND(fes.GetFE(0)->GetDof());
1175  const int NQ(ir.GetNPoints());
1177  const GeometricFactors *geom = m.GetGeometricFactors(ir, flags);
1178 
1179  const int D1D = fes.GetFE(0)->GetOrder() + 1;
1180  const int Q1D = IntRules.Get(Geometry::SEGMENT, ir.GetOrder()).GetNPoints();
1181  MFEM_VERIFY(ND == D1D*D1D, "");
1182  MFEM_VERIFY(NQ == Q1D*Q1D, "");
1183 
1184  Vector Eu(ND*NE), grad_u(DIM*NQ*NE), sum(NE*NQ), one(NE*NQ);
1185  qi->SetOutputLayout(QVectorLayout::byVDIM);
1187  const Operator *G(fes.GetElementRestriction(e_ordering));
1188  G->Mult(u, Eu);
1189  qi->Derivatives(Eu, grad_u);
1190 
1191  auto W = Reshape(ir.GetWeights().Read(), Q1D, Q1D);
1192  auto J = Reshape(geom->J.Read(), Q1D, Q1D, DIM, DIM, NE);
1193  auto detJ = Reshape(geom->detJ.Read(), Q1D, Q1D, NE);
1194  auto grdU = Reshape(grad_u.Read(), DIM, Q1D, Q1D, NE);
1195  auto S = Reshape(sum.Write(), Q1D, Q1D, NE);
1196 
1197  MFEM_FORALL_2D(e, NE, Q1D, Q1D, 1,
1198  {
1199  MFEM_FOREACH_THREAD(qy,y,Q1D)
1200  {
1201  MFEM_FOREACH_THREAD(qx,x,Q1D)
1202  {
1203  const double w = W(qx, qy);
1204  const double J11 = J(qx, qy, 0, 0, e);
1205  const double J12 = J(qx, qy, 1, 0, e);
1206  const double J21 = J(qx, qy, 0, 1, e);
1207  const double J22 = J(qx, qy, 1, 1, e);
1208  const double det = detJ(qx, qy, e);
1209  const double area = w * det;
1210  const double gu0 = grdU(0, qx, qy, e);
1211  const double gu1 = grdU(1, qx, qy, e);
1212  const double tgu0 = (J22*gu0 - J12*gu1)/det;
1213  const double tgu1 = (J11*gu1 - J21*gu0)/det;
1214  const double ngu = tgu0*tgu0 + tgu1*tgu1;
1215  const double s = (ker == AREA) ? sqrt(1.0 + ngu) :
1216  (ker == NORM) ? ngu : 0.0;
1217  S(qx, qy, e) = area * s;
1218  }
1219  }
1220  });
1221  one = 1.0;
1222  return sum * one;
1223 }
1224 
1225 static int Problem1(Opt &opt)
1226 {
1227  const int order = opt.order;
1228  Mesh mesh = Mesh::MakeCartesian2D(opt.nx, opt.ny, QUAD);
1229  mesh.SetCurvature(opt.order, false, DIM, Ordering::byNODES);
1230  for (int l = 0; l < opt.refine; l++) { mesh.UniformRefinement(); }
1231  const H1_FECollection fec(order, DIM);
1232  FiniteElementSpace fes(&mesh, &fec);
1233  Array<int> ess_tdof_list;
1234  if (mesh.bdr_attributes.Size())
1235  {
1236  Array<int> ess_bdr(mesh.bdr_attributes.Max());
1237  ess_bdr = 1;
1238  fes.GetEssentialTrueDofs(ess_bdr, ess_tdof_list);
1239  }
1240  GridFunction uold(&fes), u(&fes), b(&fes);
1241  FunctionCoefficient u0_fc(u0);
1242  u.ProjectCoefficient(u0_fc);
1243  socketstream glvis;
1244  if (opt.vis) { opt.vis = glvis.open(vishost, visport) == 0; }
1245  if (opt.vis) { Surface::Visualize(glvis, opt, &mesh, GLVIZ_W, GLVIZ_H, &u); }
1246  CGSolver cg;
1247  cg.SetRelTol(EPS);
1248  cg.SetAbsTol(EPS*EPS);
1249  cg.SetMaxIter(400);
1250  cg.SetPrintLevel(0);
1251  Vector B, X;
1252  OperatorPtr A;
1253  GridFunction eps(&fes);
1254  for (int i = 0; i < opt.niters; i++)
1255  {
1256  b = 0.0;
1257  uold = u;
1258  BilinearForm a(&fes);
1259  if (opt.pa) { a.SetAssemblyLevel(AssemblyLevel::PARTIAL); }
1260  const double q_uold = qf(order, AREA, mesh, fes, uold);
1261  MFEM_VERIFY(std::fabs(q_uold) > EPS,"");
1262  ConstantCoefficient q_uold_cc(1.0/sqrt(q_uold));
1263  a.AddDomainIntegrator(new DiffusionIntegrator(q_uold_cc));
1264  a.Assemble();
1265  a.FormLinearSystem(ess_tdof_list, u, b, A, X, B);
1266  cg.SetOperator(*A);
1267  cg.Mult(B, X);
1268  a.RecoverFEMSolution(X, b, u);
1269  subtract(u, uold, eps);
1270  const double norm = sqrt(std::fabs(qf(order, NORM, mesh, fes, eps)));
1271  const double area = qf(order, AREA, mesh, fes, u);
1272  if (!opt.id)
1273  {
1274  mfem::out << "Iteration " << i << ", norm: " << norm
1275  << ", area: " << area << std::endl;
1276  }
1277  if (opt.vis) { Surface::Visualize(glvis, opt, &mesh, &u); }
1278  if (opt.print) { Surface::Print(opt, &mesh, &u); }
1279  if (norm < NRM) { break; }
1280  }
1281  return 0;
1282 }
1283 
1284 int main(int argc, char *argv[])
1285 {
1286  Opt opt;
1287  opt.sz = opt.id = 0;
1288  // Parse command-line options.
1289  OptionsParser args(argc, argv);
1290  args.AddOption(&opt.pb, "-p", "--problem", "Problem to solve.");
1291  args.AddOption(&opt.mesh_file, "-m", "--mesh", "Mesh file to use.");
1292  args.AddOption(&opt.wait, "-w", "--wait", "-no-w", "--no-wait",
1293  "Enable or disable a GLVis pause.");
1294  args.AddOption(&opt.radial, "-rad", "--radial", "-no-rad", "--no-radial",
1295  "Enable or disable radial constraints in solver.");
1296  args.AddOption(&opt.nx, "-x", "--num-elements-x",
1297  "Number of elements in x-direction.");
1298  args.AddOption(&opt.ny, "-y", "--num-elements-y",
1299  "Number of elements in y-direction.");
1300  args.AddOption(&opt.order, "-o", "--order", "Finite element order.");
1301  args.AddOption(&opt.refine, "-r", "--ref-levels", "Refinement");
1302  args.AddOption(&opt.niters, "-n", "--niter-max", "Max number of iterations");
1303  args.AddOption(&opt.surface, "-s", "--surface", "Choice of the surface.");
1304  args.AddOption(&opt.pa, "-pa", "--partial-assembly", "-no-pa",
1305  "--no-partial-assembly", "Enable Partial Assembly.");
1306  args.AddOption(&opt.tau, "-t", "--tau", "Costa scale factor.");
1307  args.AddOption(&opt.lambda, "-l", "--lambda", "Lambda step toward solution.");
1308  args.AddOption(&opt.amr, "-a", "--amr", "-no-a", "--no-amr", "Enable AMR.");
1309  args.AddOption(&opt.amr_threshold, "-at", "--amr-threshold", "AMR threshold.");
1310  args.AddOption(&opt.device_config, "-d", "--device",
1311  "Device configuration string, see Device::Configure().");
1312  args.AddOption(&opt.keys, "-k", "--keys", "GLVis configuration keys.");
1313  args.AddOption(&opt.vis, "-vis", "--visualization", "-no-vis",
1314  "--no-visualization", "Enable or disable visualization.");
1315  args.AddOption(&opt.vis_mesh, "-vm", "--vis-mesh", "-no-vm",
1316  "--no-vis-mesh", "Enable or disable mesh visualization.");
1317  args.AddOption(&opt.by_vdim, "-c", "--solve-byvdim",
1318  "-no-c", "--solve-bynodes",
1319  "Enable or disable the 'ByVdim' solver");
1320  args.AddOption(&opt.print, "-print", "--print", "-no-print", "--no-print",
1321  "Enable or disable result output (files in mfem format).");
1322  args.AddOption(&opt.snapshot, "-ss", "--snapshot", "-no-ss", "--no-snapshot",
1323  "Enable or disable GLVis snapshot.");
1324  args.Parse();
1325  if (!args.Good()) { args.PrintUsage(mfem::out); return 1; }
1326  MFEM_VERIFY(opt.lambda >= 0.0 && opt.lambda <= 1.0,"");
1327  if (!opt.id) { args.PrintOptions(mfem::out); }
1328 
1329  // Initialize hardware devices
1330  Device device(opt.device_config);
1331  if (!opt.id) { device.Print(); }
1332 
1333  if (opt.pb == 0) { Problem0(opt); }
1334 
1335  if (opt.pb == 1) { Problem1(opt); }
1336 
1337  return 0;
1338 }
const T * Read(bool on_dev=true) const
Shortcut for mfem::Read(a.GetMemory(), a.Size(), on_dev).
Definition: array.hpp:307
const char vishost[]
T * HostReadWrite()
Shortcut for mfem::ReadWrite(a.GetMemory(), a.Size(), false).
Definition: array.hpp:327
Conjugate gradient method.
Definition: solvers.hpp:493
int GetNPoints() const
Returns the number of the points in the integration rule.
Definition: intrules.hpp:247
constexpr double PI
Class for an integration rule - an Array of IntegrationPoint.
Definition: intrules.hpp:90
Class for grid function - Vector with associated FE space.
Definition: gridfunc.hpp:30
cdouble LogEllipticTheta1Prime(const cdouble u, const cdouble q)
const IntegrationRule & Get(int GeomType, int Order)
Returns an integration rule for given GeomType and Order.
Definition: intrules.cpp:923
A coefficient that is constant across space and time.
Definition: coefficient.hpp:84
const GeometricFactors * GetGeometricFactors(const IntegrationRule &ir, const int flags, MemoryType d_mt=MemoryType::DEFAULT)
Return the mesh geometric factors corresponding to the given integration rule.
Definition: mesh.cpp:840
virtual void GetVertices(Array< int > &v) const =0
Returns element&#39;s vertices.
void PrintOptions(std::ostream &out) const
Print the options.
Definition: optparser.cpp:324
Geometry::Type GetElementBaseGeometry(int i) const
Definition: mesh.hpp:1108
cdouble WeierstrassZeta(const cdouble z, const cdouble w1=0.5, const cdouble w3=0.5 *I)
constexpr double NRM
virtual const double * HostRead() const
Shortcut for mfem::Read(vec.GetMemory(), vec.Size(), false).
Definition: vector.hpp:452
void PrintUsage(std::ostream &out) const
Print the usage message.
Definition: optparser.cpp:454
Pointer to an Operator of a specified type.
Definition: handle.hpp:33
std::complex< double > cdouble
constexpr int GLVIZ_W
void SetIntPoint(const IntegrationPoint *ip)
Set the integration point ip that weights and Jacobians will be evaluated at.
Definition: eltrans.hpp:93
void CalcAdjugate(const DenseMatrix &a, DenseMatrix &adja)
Definition: densemat.cpp:2479
virtual void Mult(const Vector &b, Vector &x) const
Operator application: y=A(x).
Definition: solvers.cpp:712
int Size() const
Returns the size of the vector.
Definition: vector.hpp:199
T Max() const
Find the maximal element in the array, using the comparison operator < for class T.
Definition: array.cpp:68
Data type dense matrix using column-major storage.
Definition: densemat.hpp:23
void Transform(void(*f)(const Vector &, Vector &))
Definition: mesh.cpp:11691
int GetNDofs() const
Returns number of degrees of freedom.
Definition: fespace.hpp:584
virtual const double * Read(bool on_dev=true) const
Shortcut for mfem::Read(vec.GetMemory(), vec.Size(), on_dev).
Definition: vector.hpp:448
virtual void GetEssentialTrueDofs(const Array< int > &bdr_attr_is_ess, Array< int > &ess_tdof_list, int component=-1)
Get a list of essential true dofs, ess_tdof_list, corresponding to the boundary attributes marked in ...
Definition: fespace.cpp:564
virtual void Mult(const Vector &x, Vector &y) const =0
Operator application: y=A(x).
void Print(std::ostream &out=mfem::out)
Print the configuration of the MFEM virtual device object.
Definition: device.cpp:279
const Element * GetElement(int i) const
Definition: mesh.hpp:1081
bool Good() const
Return true if the command line options were parsed successfully.
Definition: optparser.hpp:150
constexpr int DIM
constexpr Element::Type QUAD
Structure for storing mesh geometric factors: coordinates, Jacobians, and determinants of the Jacobia...
Definition: mesh.hpp:1915
STL namespace.
double Weight() const
Definition: densemat.cpp:545
void add(const Vector &v1, const Vector &v2, Vector &v)
Definition: vector.cpp:314
virtual const FiniteElement * GetFE(int i) const
Returns pointer to the FiniteElement in the FiniteElementCollection associated with i&#39;th element in t...
Definition: fespace.cpp:2783
static void MarkerToList(const Array< int > &marker, Array< int > &list)
Convert a Boolean marker array to a list containing all marked indices.
Definition: fespace.cpp:598
IntegrationRules IntRules(0, Quadrature1D::GaussLegendre)
A global object with all integration rules (defined in intrules.cpp)
Definition: intrules.hpp:379
int close()
Close the socketstream.
Data type for Gauss-Seidel smoother of sparse matrix.
const ElementRestrictionOperator * GetElementRestriction(ElementDofOrdering e_ordering) const
Return an Operator that converts L-vectors to E-vectors.
Definition: fespace.cpp:1259
IntegrationPoint & IntPoint(int i)
Returns a reference to the i-th integration point.
Definition: intrules.hpp:250
int main(int argc, char *argv[])
Vector J
Jacobians of the element transformations at all quadrature points.
Definition: mesh.hpp:1956
const Array< double > & GetWeights() const
Return the quadrature weights in a contiguous array.
Definition: intrules.cpp:83
double DistanceTo(const double *p) const
Compute the Euclidean distance to another vector.
Definition: vector.hpp:664
virtual void SetPrintLevel(int print_lvl)
Legacy method to set the level of verbosity of the solver output.
Definition: solvers.cpp:71
Geometry::Type GetGeometryType() const
Definition: element.hpp:52
void Parse()
Parse the command-line options. Note that this function expects all the options provided through the ...
Definition: optparser.cpp:151
cdouble WeierstrassP(const cdouble z, const cdouble w1=0.5, const cdouble w3=0.5 *I)
Data type sparse matrix.
Definition: sparsemat.hpp:50
int Append(const T &el)
Append element &#39;el&#39; to array, resize if necessary.
Definition: array.hpp:756
Vector detJ
Determinants of the Jacobians at all quadrature points.
Definition: mesh.hpp:1962
virtual double * Write(bool on_dev=true)
Shortcut for mfem::Write(vec.GetMemory(), vec.Size(), on_dev).
Definition: vector.hpp:456
A class that performs interpolation from an E-vector to quadrature point values and/or derivatives (Q...
double b
Definition: lissajous.cpp:42
void UniformRefinement(int i, const DSTable &, int *, int *, int *)
Definition: mesh.cpp:9878
virtual const SparseMatrix * GetRestrictionMatrix() const
The returned SparseMatrix is owned by the FiniteElementSpace.
Definition: fespace.hpp:495
const DenseMatrix & Jacobian()
Return the Jacobian matrix of the transformation at the currently set IntegrationPoint, using the method SetIntPoint().
Definition: eltrans.hpp:119
int GetOrder() const
Returns the order of the integration rule.
Definition: intrules.hpp:240
void SetMaxIter(int max_it)
Definition: solvers.hpp:201
virtual void SetCurvature(int order, bool discont=false, int space_dim=-1, int ordering=1)
Set the curvature of the mesh nodes using the given polynomial degree.
Definition: mesh.cpp:5356
double delta
Definition: lissajous.cpp:43
Type
Constants for the classes derived from Element.
Definition: element.hpp:41
cdouble EllipticTheta(const int a, const cdouble u, const cdouble q)
const int visport
FiniteElementSpace * FESpace()
Definition: gridfunc.hpp:683
void Mult(const double *x, double *y) const
Matrix vector multiplication.
Definition: densemat.cpp:173
int GetNE() const
Returns number of elements in the mesh.
Definition: fespace.hpp:614
constexpr double NL_DMAX
void GetNodalValues(int i, Array< double > &nval, int vdim=1) const
Returns the values in the vertices of i&#39;th element for dimension vdim.
Definition: gridfunc.cpp:396
constexpr double EPS
virtual int GetTrueVSize() const
Return the number of vector true (conforming) dofs.
Definition: fespace.hpp:590
void SetAbsTol(double atol)
Definition: solvers.hpp:200
Array< int > bdr_attributes
A list of all unique boundary attributes used by the Mesh.
Definition: mesh.hpp:275
void SetRelTol(double rtol)
Definition: solvers.hpp:199
void Transpose()
(*this) = (*this)^t
Definition: densemat.cpp:1420
Class FiniteElementSpace - responsible for providing FEM view of the mesh, mainly managing the set of...
Definition: fespace.hpp:96
OutStream out(std::cout)
Global stream used by the library for standard output. Initially it uses the same std::streambuf as s...
Definition: globals.hpp:66
void subtract(const Vector &x, const Vector &y, Vector &z)
Definition: vector.cpp:461
void AddOption(bool *var, const char *enable_short_name, const char *enable_long_name, const char *disable_short_name, const char *disable_long_name, const char *description, bool required=false)
Add a boolean option and set &#39;var&#39; to receive the value. Enable/disable tags are used to set the bool...
Definition: optparser.hpp:82
void SetSize(int nsize)
Change the logical size of the array, keep existing entries.
Definition: array.hpp:684
static Mesh MakeCartesian2D(int nx, int ny, Element::Type type, bool generate_edges=false, double sx=1.0, double sy=1.0, bool sfc_ordering=true)
Definition: mesh.cpp:3726
int GetDof() const
Returns the number of degrees of freedom in the finite element.
Definition: fe_base.hpp:322
virtual DofTransformation * GetElementDofs(int elem, Array< int > &dofs) const
Returns indices of degrees of freedom of element &#39;elem&#39;.
Definition: fespace.cpp:2680
virtual void Update()
Transform by the Space UpdateMatrix (e.g., on Mesh change).
Definition: gridfunc.cpp:165
void BooleanMult(const Array< int > &x, Array< int > &y) const
y = A * x, treating all entries as booleans (zero=false, nonzero=true).
Definition: sparsemat.cpp:1026
int GetNE() const
Returns number of elements.
Definition: mesh.hpp:936
double a
Definition: lissajous.cpp:41
A "square matrix" operator for the associated FE space and BLFIntegrators The sum of all the BLFInteg...
const QuadratureInterpolator * GetQuadratureInterpolator(const IntegrationRule &ir) const
Return a QuadratureInterpolator that interpolates E-vectors to quadrature point values and/or derivat...
Definition: fespace.cpp:1327
void GetElementTransformation(int i, IsoparametricTransformation *ElTr)
Definition: mesh.cpp:348
ElementDofOrdering
Constants describing the possible orderings of the DOFs in one element.
Definition: fespace.hpp:74
constexpr int GLVIZ_H
constexpr int SDIM
int GetVSize() const
Return the number of vector dofs, i.e. GetNDofs() x GetVDim().
Definition: fespace.hpp:587
Lexicographic ordering for tensor-product FiniteElements.
virtual int GetNVertices() const =0
void SetAttribute(const int attr)
Set element&#39;s attribute.
Definition: element.hpp:58
double Norml2() const
Returns the l2 norm of the vector.
Definition: vector.cpp:804
int open(const char hostname[], int port)
Open the socket stream on &#39;port&#39; at &#39;hostname&#39;.
int Size() const
Return the logical size of the array.
Definition: array.hpp:141
RefCoord t[3]
void MakeRef(T *, int)
Make this Array a reference to a pointer.
Definition: array.hpp:869
virtual void SetOperator(const Operator &op)
Also calls SetOperator for the preconditioner if there is one.
Definition: solvers.hpp:507
const double alpha
Definition: ex15.cpp:369
A general function coefficient.
int DofToVDof(int dof, int vd, int ndofs=-1) const
Definition: fespace.cpp:251
Vector data type.
Definition: vector.hpp:60
virtual void Print(std::ostream &os=mfem::out) const
Definition: mesh.hpp:1749
virtual void Transform(const IntegrationPoint &, Vector &)=0
Transform integration point from reference coordinates to physical coordinates and store them in the ...
virtual void SetPreconditioner(Solver &pr)
This should be called before SetOperator.
Definition: solvers.cpp:173
Arbitrary order H1-conforming (continuous) finite elements.
Definition: fe_coll.hpp:252
void GetNodes(Vector &node_coord) const
Definition: mesh.cpp:7949
RefCoord s[3]
double u(const Vector &xvec)
Definition: lor_mms.hpp:24
cdouble EllipticTheta1Prime(const int k, const cdouble u, const cdouble q)
Base class for solvers.
Definition: operator.hpp:682
virtual void Save(std::ostream &out) const
Save the GridFunction to an output stream.
Definition: gridfunc.cpp:3673
The MFEM Device class abstracts hardware devices such as GPUs, as well as programming models such as ...
Definition: device.hpp:121
Abstract operator.
Definition: operator.hpp:24
MFEM_HOST_DEVICE DeviceTensor< sizeof...(Dims), T > Reshape(T *ptr, Dims... dims)
Wrap a pointer as a DeviceTensor with automatically deduced template parameters.
Definition: dtensor.hpp:131
const IntegrationRule & GetNodes() const
Get a const reference to the nodes of the element.
Definition: fe_base.hpp:388
void GeneralRefinement(const Array< Refinement > &refinements, int nonconforming=-1, int nc_limit=0)
Definition: mesh.cpp:9467
Abstract data type element.
Definition: element.hpp:28
int GetOrder() const
Returns the order of the finite element. In the case of anisotropic orders, returns the maximum order...
Definition: fe_base.hpp:326
virtual double * HostReadWrite()
Shortcut for mfem::ReadWrite(vec.GetMemory(), vec.Size(), false).
Definition: vector.hpp:468
VDIM x NQPT x NE (values) / VDIM x DIM x NQPT x NE (grads)