"""Unit tests for SubDomain""" # Copyright (C) 2013 Johan Hake # # 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 . import numpy as np from dolfin import * from dolfin_utils.test import skip_in_parallel import pytest def test_compiled_subdomains(): def noDefaultValues(): CompiledSubDomain("a") def wrongDefaultType(): CompiledSubDomain("a", a="1") def wrongParameterNames(): CompiledSubDomain("foo", bar=1.0) with pytest.raises(RuntimeError): noDefaultValues() with pytest.raises(TypeError): wrongDefaultType() with pytest.raises(RuntimeError): wrongParameterNames() @skip_in_parallel def test_compiled_subdomains_compilation_failure(): def invalidCppCode(): CompiledSubDomain("/") with pytest.raises(RuntimeError): invalidCppCode() def test_creation_and_marking(): class Left(SubDomain): def inside(self, x, on_boundary): return x[0] < DOLFIN_EPS class LeftOnBoundary(SubDomain): def inside(self, x, on_boundary): return x[0] < DOLFIN_EPS and on_boundary class Right(SubDomain): def inside(self, x, on_boundary): return x[0] > 1.0 - DOLFIN_EPS class RightOnBoundary(SubDomain): def inside(self, x, on_boundary): return x[0] > 1.0 - DOLFIN_EPS and on_boundary cpp_code = """ #include #include namespace py = pybind11; #include #include class Left : public dolfin::SubDomain { public: virtual bool inside(Eigen::Ref x, bool on_boundary) const { return x[0] < DOLFIN_EPS; } }; class LeftOnBoundary : public dolfin::SubDomain { public: virtual bool inside(Eigen::Ref x, bool on_boundary) const { return x[0] < DOLFIN_EPS and on_boundary; } }; class Right : public dolfin::SubDomain { public: virtual bool inside(Eigen::Ref x, bool on_boundary) const { return x[0] > 1.0 - DOLFIN_EPS; } }; class RightOnBoundary : public dolfin::SubDomain { public: virtual bool inside(Eigen::Ref x, bool on_boundary) const { return x[0] > 1.0 - DOLFIN_EPS and on_boundary; } }; PYBIND11_MODULE(SIGNATURE, m) { //py::object SubDomain = (py::object) py::module::import("dolfin").attr("SubDomain"); py::class_(m, "SubDomain", py::module_local()); py::class_, dolfin::SubDomain>(m, "Left").def(py::init<>()); py::class_, dolfin::SubDomain>(m, "Right").def(py::init<>()); py::class_, dolfin::SubDomain>(m, "LeftOnBoundary").def(py::init<>()); py::class_, dolfin::SubDomain>(m, "RightOnBoundary").def(py::init<>()); } """ compiled_domain_module = compile_cpp_code(cpp_code) subdomain_pairs = [(Left(), Right()), (LeftOnBoundary(), RightOnBoundary()), (AutoSubDomain(lambda x, on_boundary: x[0] < DOLFIN_EPS), AutoSubDomain(lambda x, on_boundary: x[0] > 1.0 - DOLFIN_EPS)), (AutoSubDomain(lambda x, on_boundary: x[0] < DOLFIN_EPS and on_boundary), AutoSubDomain(lambda x, on_boundary: x[0] > 1.0 - DOLFIN_EPS and on_boundary)), (CompiledSubDomain("near(x[0], _a)", _a=0.0), CompiledSubDomain("near(x[0], _a)", _a=1.0)), (CompiledSubDomain("near(x[0], _a) and on_boundary", _a=0.0), CompiledSubDomain("near(x[0], _a) and on_boundary", _a=1.0)), (CompiledSubDomain("near(x[0], 0.0)"), CompiledSubDomain("near(x[0], 1.0)")), (CompiledSubDomain("near(x[0], 0.0) and on_boundary"), CompiledSubDomain("near(x[0], 1.0) and on_boundary")), # # (compiled_domain_module.Left(), # compiled_domain_module.Right()), # (compiled_domain_module.LeftOnBoundary(), # compiled_domain_module.RightOnBoundary()) ] empty = CompiledSubDomain("false") every = CompiledSubDomain("true") for ind, MeshClass in enumerate([UnitIntervalMesh, UnitSquareMesh, UnitCubeMesh]): dim = ind + 1 args = [10]*dim mesh = MeshClass(*args) mesh.init() for left, right in subdomain_pairs: for t_dim, f_dim in [(0, 0), (mesh.topology().dim()-1, dim - 1), (mesh.topology().dim(), dim)]: f = MeshFunction("size_t", mesh, t_dim, 0) left.mark(f, int(1)) right.mark(f, 2) correct = {(1, 0): 1, (1, 1): 0, (2, 0): 11, (2, 1): 10, (2, 2): 0, (3, 0): 121, (3, 2): 200, (3, 3): 0} # Check that the number of marked entities are at least the # correct number (it can be larger in parallel) assert all(value >= correct[dim, f_dim] for value in [ MPI.sum(mesh.mpi_comm(), float((f.array() == 2).sum())), MPI.sum(mesh.mpi_comm(), float((f.array() == 1).sum())), ]) for t_dim, f_dim in [(0, 0), (mesh.topology().dim()-1, dim-1), (mesh.topology().dim(), dim)]: f = MeshFunction("size_t", mesh, t_dim, 0)# empty.mark(f, 1) every.mark(f, 2) # Check that the number of marked entities is correct assert sum(f.array() == 1) == 0 assert sum(f.array() == 2) == mesh.num_entities(f_dim) # Skipping in parallel due to lack of parallel support for SubMesh @skip_in_parallel def test_snap_boundary(): # This test checks whether the expected modifications are made # to mesh vertex coordinates when snap_boundary is called. for ind, MeshClass in enumerate([UnitIntervalMesh, UnitSquareMesh, UnitCubeMesh]): # SubDomain whose snap method modifies all coordinate components # to be zero. dim = ind+1 class ZeroSnap(SubDomain): def inside(self,x,on_boundary): return True def snap(self,x): for i in range(0,dim): x[i] = 0.0 # Create mesh and modify coordinates via snapping. Note that all vertices # are on the boundary. args = [1,]*dim mesh = MeshClass(*args) mesh.snap_boundary(ZeroSnap()) # Verify that all mesh coordinates are now zero. for x in mesh.coordinates(): for x_i in x: assert x_i==0.0