// Copyright (C) 2005-2010 Anders Logg
//
// This file is part of DOLFIN.
//
// DOLFIN is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// DOLFIN is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with DOLFIN. If not, see .
#include
#include "Poisson2D_1.h"
#include "Poisson2D_2.h"
#include "Poisson2D_3.h"
#include "Poisson2D_4.h"
#include "Poisson2D_5.h"
#include "Poisson3D_1.h"
#include "Poisson3D_2.h"
#include "Poisson3D_3.h"
#include "Poisson3D_4.h"
using namespace dolfin;
// Boundary condition
class DirichletBoundary : public SubDomain
{
public:
DirichletBoundary() {}
bool inside(const Array& x, bool on_boundary) const
{ return on_boundary; }
};
// Right-hand side, 2D
class Source2D : public Expression
{
void eval(Array& values, const Array& x) const
{
values[0] = 2.0*DOLFIN_PI*DOLFIN_PI*sin(DOLFIN_PI*x[0])*sin(DOLFIN_PI*x[1]);
}
};
// Right-hand side, 3D
class Source3D : public Expression
{
void eval(Array& values, const Array& x) const
{
values[0] = 3.0*DOLFIN_PI*DOLFIN_PI*sin(DOLFIN_PI*x[0])*sin(DOLFIN_PI*x[1])*sin(DOLFIN_PI*x[2]);
}
};
// Solve equation and compute error, 2D
double solve2D(int q, int n)
{
printf("Solving Poisson's equation in 2D for q = %d, n = %d.\n", q, n);
// Set up problem
auto mesh = std::make_shared(n, n);
auto f = std::make_shared();
auto zero = std::make_shared(0.0);
// Choose forms
Form* a = 0;
Form* L = 0;
std::shared_ptr V;
switch (q)
{
case 1:
V = std::make_shared(mesh);
a = new Poisson2D_1::BilinearForm(V, V);
L = new Poisson2D_1::LinearForm(V, f);
break;
case 2:
V = std::make_shared(mesh);
a = new Poisson2D_2::BilinearForm(V, V);
L = new Poisson2D_2::LinearForm(V, f);
break;
case 3:
V = std::make_shared(mesh);
a = new Poisson2D_3::BilinearForm(V, V);
L = new Poisson2D_3::LinearForm(V, f);
break;
case 4:
V = std::make_shared(mesh);
a = new Poisson2D_4::BilinearForm(V, V);
L = new Poisson2D_4::LinearForm(V, f);
break;
case 5:
V = std::make_shared(mesh);
a = new Poisson2D_5::BilinearForm(V, V);
L = new Poisson2D_5::LinearForm(V, f);
break;
default:
error("Forms not compiled for q = %d.", q);
}
// Set up boundary conditions
auto boundary = std::make_shared();
DirichletBC bc(V, zero, boundary);
// Discretize equation
Matrix A;
Vector x, b;
assemble(A, *a);
assemble(b, *L);
bc.apply(A, b);
// Solve the linear system
KrylovSolver solver("gmres");
solver.parameters["relative_tolerance"] = 1e-14;
solver.solve(A, x, b);
// Compute maximum norm of error
double emax = 0.0;
std::vector U;
x.get_local(U);
for (VertexIterator v(*mesh); !v.end(); ++v)
{
const Point p = v->point();
const double u = sin(DOLFIN_PI*p.x())*sin(DOLFIN_PI*p.y());
const double e = std::abs(U[v->index()] - u);
emax = std::max(emax, e);
}
delete a;
delete L;
return emax;
}
// Solve equation and compute error, 3D
double solve3D(int q, int n)
{
printf("Solving Poisson's equation in 3D for q = %d, n = %d.\n", q, n);
// Set up problem
auto mesh = std::make_shared(n, n, n);
auto f = std::make_shared();
auto zero = std::make_shared(0.0);
// Choose forms
Form* a = 0;
Form* L = 0;
std::shared_ptr V;
switch (q)
{
case 1:
V = std::make_shared(mesh);
a = new Poisson3D_1::BilinearForm(V, V);
L = new Poisson3D_1::LinearForm(V, f);
break;
case 2:
V = std::make_shared(mesh);
a = new Poisson3D_2::BilinearForm(V, V);
L = new Poisson3D_2::LinearForm(V, f);
break;
case 3:
V = std::make_shared(mesh);
a = new Poisson3D_3::BilinearForm(V, V);
L = new Poisson3D_3::LinearForm(V, f);
break;
case 4:
V = std::make_shared(mesh);
a = new Poisson3D_4::BilinearForm(V, V);
L = new Poisson3D_4::LinearForm(V, f);
break;
default:
error("Forms not compiled for q = %d.", q);
}
// Set up boundary conditions
auto boundary = std::make_shared();
DirichletBC bc(V, zero, boundary);
// Discretize equation
Matrix A;
Vector x, b;
assemble(A, *a);
assemble(b, *L);
bc.apply(A, b);
// Solve the linear system
KrylovSolver solver("gmres");
solver.parameters["relative_tolerance"] = 1e-14;
solver.solve(A, x, b);
// Compute maximum norm of error
double emax = 0.0;
std::vector U;
x.get_local(U);
for (VertexIterator v(*mesh); !v.end(); ++v)
{
const Point p = v->point();
const double u = sin(DOLFIN_PI*p.x())*sin(DOLFIN_PI*p.y())*sin(DOLFIN_PI*p.z());
const double e = std::abs(U[v->index()] - u);
emax = std::max(emax, e);
}
delete a;
delete L;
return emax;
}
int main()
{
info("Runtime of convergence benchmark");
set_log_active(false);
const int qmax_2D = 5;
const int qmax_3D = 4;
const int num_meshes = 3;
std::vector> e2D(qmax_2D,
std::vector(num_meshes));
std::vector> e3D(qmax_3D,
std::vector(num_meshes));
// Compute errors in 2D
for (int q = 1; q <= qmax_2D; q++)
{
int n = 2;
for (int i = 0; i < num_meshes; i++)
{
e2D[q - 1][i] = solve2D(q, n);
n *= 2;
}
}
// Compute errors in 3D
for (int q = 1; q <= qmax_3D; q++)
{
int n = 2;
for (int i = 0; i < num_meshes; i++)
{
e3D[q - 1][i] = solve3D(q, n);
n *= 2;
}
}
// Write errors in 2D
printf("\nMaximum norm error in 2D:\n");
printf("-------------------------\n");
for (int q = 1; q <= qmax_2D; q++)
{
printf("q = %d:", q);
for (int i = 0; i < num_meshes; i++)
printf(" %.3e", e2D[q - 1][i]);
printf("\n");
}
// Write errors in 3D
printf("\nMaximum norm error in 3D:\n");
printf("-------------------------\n");
for (int q = 1; q <= qmax_3D; q++)
{
printf("q = %d:", q);
for (int i = 0; i < num_meshes; i++)
printf(" %.3e", e3D[q - 1][i]);
printf("\n");
}
}