// Copyright (C) 2007 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 .
//
// Unit tests for the mesh library
#include
#include
using namespace dolfin;
//-----------------------------------------------------------------------------
TEST_CASE("Simple shapes test")
{
SECTION("Test UnitSquareMesh")
{
// Create mesh of unit square
UnitSquareMesh mesh(5, 7);
CHECK(mesh.num_vertices() == (std::size_t) 48);
CHECK(mesh.num_cells() == (std::size_t) 70);
// Create mesh of unit square
auto mesh1 = UnitSquareMesh::create({{5, 7}}, CellType::Type::triangle);
CHECK(mesh1.num_vertices() == (std::size_t) 48);
CHECK(mesh1.num_cells() == (std::size_t) 70);
}
SECTION("Test UnitCubeMesh")
{
// Create mesh of unit cube
UnitCubeMesh mesh(5, 7, 9);
CHECK(mesh.num_vertices() == (std::size_t) 480);
CHECK(mesh.num_cells() == (std::size_t) 1890);
// Create mesh of unit cube
auto mesh1 = UnitCubeMesh::create({{5, 7, 9}}, CellType::Type::tetrahedron);
CHECK(mesh1.num_vertices() == (std::size_t) 480);
CHECK(mesh1.num_cells() == (std::size_t) 1890);
}
}
TEST_CASE("Mesh refinement")
{
SECTION("Test refine UnitSquareMesh")
{
// Refine mesh of unit square
UnitSquareMesh mesh0(5, 7);
Mesh mesh1 = refine(mesh0);
CHECK(mesh1.num_vertices() == (std::size_t) 165);
CHECK(mesh1.num_cells() == (std::size_t) 280);
}
SECTION("Test refine UnitCubeMesh")
{
// Refine mesh of unit cube
UnitCubeMesh mesh0(5, 7, 9);
Mesh mesh1 = refine(mesh0);
CHECK(mesh1.num_vertices() == (std::size_t) 3135);
CHECK(mesh1.num_cells() == (std::size_t) 15120);
}
}
TEST_CASE("Mesh iterators")
{
SECTION("Test vertex iterators")
{
// Iterate over vertices
UnitCubeMesh mesh(5, 5, 5);
unsigned int n = 0;
for (VertexIterator v(mesh); !v.end(); ++v)
n++;
CHECK(n == mesh.num_vertices());
}
SECTION("Test edge iterators")
{
// Iterate over edges
UnitCubeMesh mesh(5, 5, 5);
unsigned int n = 0;
for (EdgeIterator e(mesh); !e.end(); ++e)
n++;
CHECK(n == mesh.num_edges());
}
SECTION("Test face iterators")
{
// Iterate over faces
UnitCubeMesh mesh(5, 5, 5);
unsigned int n = 0;
for (FaceIterator f(mesh); !f.end(); ++f)
n++;
CHECK(n == mesh.num_faces());
}
SECTION("Test facet iterators")
{
// Iterate over facets
UnitCubeMesh mesh(5, 5, 5);
unsigned int n = 0;
for (FacetIterator f(mesh); !f.end(); ++f)
n++;
CHECK(n == mesh.num_facets());
}
SECTION("Test cell iterators")
{
// Iterate over cells
UnitCubeMesh mesh(5, 5, 5);
unsigned int n = 0;
for (CellIterator c(mesh); !c.end(); ++c)
n++;
CHECK(n == mesh.num_cells());
}
SECTION("Test mixed iterators")
{
// Iterate over vertices of cells
UnitCubeMesh mesh(5, 5, 5);
unsigned int n = 0;
for (CellIterator c(mesh); !c.end(); ++c)
for (VertexIterator v(*c); !v.end(); ++v)
n++;
CHECK(n == 4*mesh.num_cells());
}
SECTION("Test boundary computation")
{
// Compute boundary of mesh
UnitCubeMesh mesh(2, 2, 2);
BoundaryMesh boundary(mesh, "exterior");
CHECK(boundary.num_vertices() == (std::size_t) 26);
CHECK(boundary.num_cells() == (std::size_t) 48);
}
}
TEST_CASE("Boundary extraction")
{
SECTION("Test boundary of boundary")
{
// Compute boundary of boundary
//
// Note that we can't do
//
// BoundaryMesh b0(mesh);
// BoundaryMesh b1(b0);
//
// since b1 would then be a copy of b0 (copy
// constructor in Mesh will be used).
UnitCubeMesh mesh(2, 2, 2);
BoundaryMesh b0(mesh, "exterior");
b0.order();
BoundaryMesh b1(b0, "exterior");
CHECK(b1.num_vertices() == (std::size_t) 0);
CHECK(b1.num_cells() == (std::size_t) 0);
}
SECTION("Test assign")
{
/// Assign value of mesh function
auto mesh = std::make_shared(3, 3);
MeshFunction f(mesh, 0);
f[3] = 10;
Vertex v(*mesh, 3);
CHECK(f[v] == 10);
}
}
TEST_CASE("InputOutput")
{
SECTION("Test mesh XML 2D")
{
// Write and read 2D mesh to/from file
UnitSquareMesh mesh_out(3, 3);
Mesh mesh_in;
File file("unitsquare.xml");
file << mesh_out;
file >> mesh_in;
CHECK(mesh_in.num_vertices() == (std::size_t) 16);
}
SECTION("Test mesh XML 3D")
{
// Write and read 3D mesh to/from file
UnitCubeMesh mesh_out(3, 3, 3);
Mesh mesh_in;
File file("unitcube.xml");
file << mesh_out;
file >> mesh_in;
CHECK(mesh_in.num_vertices() == (std::size_t) 64);
}
SECTION("Test MeshFunction")
{
// Write and read mesh function to/from file
auto mesh = std::make_shared(1, 1);
MeshFunction f(mesh, 0);
f[0] = 2;
f[1] = 4;
f[2] = 6;
f[3] = 8;
File file("meshfunction.xml");
file << f;
MeshFunction g(mesh, 0);
file >> g;
for (VertexIterator v(*mesh); !v.end(); ++v)
CHECK(f[*v] == g[*v]);
}
}
TEST_CASE("PyCCInterface")
{
SECTION("Test get geometrical dimension")
{
// Get geometrical dimension of mesh
UnitSquareMesh mesh(5, 5);
CHECK(mesh.geometry().dim() == (std::size_t) 2);
}
SECTION("Test get coordinates")
{
// Get coordinates of vertices
UnitSquareMesh mesh(5, 5);
CHECK(mesh.geometry().num_vertices() == (std::size_t) 36);
}
SECTION("Test get cells")
{
// Get cells of mesh
UnitSquareMesh mesh(5, 5);
CHECK(mesh.topology().size(2) == (std::size_t) 50);
}
}