// 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); } }