def setUp(self):
# Domain
nx = ny = nz = 10
mesh = fenics.RectangleMesh(fenics.Point(-2, -2), fenics.Point(2, 2),
nx, ny)
# function spaces
displacement_element = fenics.VectorElement("Lagrange",
mesh.ufl_cell(), 1)
concentration_element = fenics.FiniteElement("Lagrange",
mesh.ufl_cell(), 1)
element = fenics.MixedElement(
[displacement_element, concentration_element])
subspace_names = {0: 'displacement', 1: 'concentration'}
functionspace = FunctionSpace(mesh)
functionspace.init_function_space(element, subspace_names)
# build a 'solution' function
u_0_conc_expr = fenics.Expression(
'sqrt(pow(x[0]-x0,2)+pow(x[1]-y0,2)) < 0.1 ? (1.0) : (0.0)',
degree=1,
x0=0.25,
y0=0.5)
u_0_disp_expr = fenics.Constant((0.0, 0.0))
self.U = functionspace.project_over_space(function_expr={
0: u_0_disp_expr,
1: u_0_conc_expr
})
self.tsd = TimeSeriesData(functionspace=functionspace, name='solution')
def test_split_function(self):
subspace_names = {0: 'displacement', 1: 'concentration'}
functionspace = FunctionSpace(self.mesh)
functionspace.init_function_space(self.element, subspace_names)
u_0_conc_expr = fenics.Expression('sqrt(pow(x[0]-x0,2)+pow(x[1]-y0,2)) < 0.1 ? (1.0) : (0.0)', degree=1,
x0=0.25,
y0=0.5)
u_0_disp_expr = fenics.Constant((0.0, 0.0))
U_orig = functionspace.project_over_space(function_expr={0: u_0_disp_expr, 1: u_0_conc_expr})
U = functionspace.split_function(U_orig)
self.assertEqual(U_orig, U)
U_1 = functionspace.split_function(U_orig, subspace_id=1)
U_0 = functionspace.split_function(U_orig, subspace_id=0)
class TestBoundaryConditions(TestCase):
def setUp(self):
# Domain
nx = ny = nz = 10
self.nx, self.ny = nx, ny
self.mesh = fenics.RectangleMesh(fenics.Point(-2, -2), fenics.Point(2, 2), nx, ny)
# function spaces
self.displacement_element = fenics.VectorElement("Lagrange", self.mesh.ufl_cell(), 1)
self.concentration_element = fenics.FiniteElement("Lagrange", self.mesh.ufl_cell(), 1)
self.element = fenics.MixedElement([self.displacement_element, self.concentration_element])
subspace_names = {0: 'displacement', 1: 'concentration'}
self.functionspace = FunctionSpace(self.mesh)
self.functionspace.init_function_space(self.element, subspace_names)
# define 'solution' with concentration=1 everywhere
self.conc_expr = fenics.Constant(1.0)
self.conc = self.functionspace.project_over_space(self.conc_expr, subspace_name='concentration')
# subdomains
label_funspace = fenics.FunctionSpace(self.mesh, "DG", 1)
label_expr = fenics.Expression('(x[0]>=0) ? (1.0) : (2.0)', degree=1)
labels = fenics.project(label_expr, label_funspace)
self.labels = labels
self.tissue_id_name_map = {0: 'outside',
1: 'tissue',
2: 'tumor'}
self.parameter = {'outside': 0.0,
'tissue': 1.0,
'tumor': 0.1}
self.boundary_pos = BoundaryPos()
self.boundary_neg = BoundaryNeg()
boundary_dict = {'boundary_pos': self.boundary_pos,
'boundary_neg': self.boundary_neg}
self.boundary_dict = boundary_dict
self.subdomains = SubDomains(self.mesh)
self.subdomains.setup_subdomains(label_function=self.labels)
self.subdomains.setup_boundaries(tissue_map=self.tissue_id_name_map,
boundary_fct_dict=self.boundary_dict)
self.subdomains.setup_measures()
# BCs
self.bcs = BoundaryConditions(self.functionspace, self.subdomains)
self.dirichlet_bcs = {'clamped_0': {'bc_value': fenics.Constant((0.0, 0.0)),
'boundary': BoundaryPos(),
'subspace_id': 0},
'clamped_1': {'bc_value': fenics.Constant((0.0, 0.0)),
'subdomain_boundary': 'tissue_tumor',
'subspace_id': 0},
'clamped_pos': {'bc_value': fenics.Constant((0.0, 0.0)),
'named_boundary': 'boundary_pos',
'subspace_id': 0},
'clamped_neg': {'bc_value': fenics.Constant((0.0, 0.0)),
'named_boundary': 'boundary_neg',
'subspace_id': 0}
}
self.von_neuman_bcs = {
'flux_boundary_pos': {'bc_value': fenics.Constant(1.0),
'named_boundary': 'boundary_pos',
'subspace_id': 1},
'flux_boundary_neg': {'bc_value': fenics.Constant(-5.0),
'named_boundary': 'boundary_neg',
'subspace_id': 1}
# 'no_flux_domain_boundary': {'bc_value': fenics.Constant(1.0),
# 'subdomain_boundary': 'tissue_tumor',
# 'subspace_id': 1},
}
def test_setup_dirichlet_boundary_conditions(self):
self.bcs.setup_dirichlet_boundary_conditions(self.dirichlet_bcs)
self.assertTrue(hasattr(self.bcs, 'dirichlet_bcs'))
self.assertEqual(len(self.bcs.dirichlet_bcs),4)
def test_setup_von_neumann_boundary_conditions(self):
self.bcs.setup_von_neumann_boundary_conditions(self.von_neuman_bcs)
self.assertTrue(hasattr(self.bcs, 'von_neumann_bcs'))
self.assertEqual(len(self.bcs.von_neumann_bcs), 2)
def test_implement_von_neumann_bcs(self):
# seutp bcs
self.bcs.setup_von_neumann_boundary_conditions(self.von_neuman_bcs)
#v0, v1 = fenics.TestFunctions(self.functionspace.function_space)
#param = self.subdomains.create_discontinuous_scalar_from_parameter_map(self.parameter, 'param')
#bc_terms_0 = self.bcs.implement_von_neumann_bc(param * v0, subspace_id=0)
#bc_terms_1 = self.bcs.implement_von_neumann_bc(param * v1, subspace_id=1)
param = fenics.Constant(1.0)
# compute surface integral based on implementation functions
bc_boundary_auto_form = self.bcs.implement_von_neumann_bc(param * self.conc, subspace_id=1)
bc_boundary_auto = fenics.assemble(bc_boundary_auto_form)
# compute surface integral by defining form manually
boundary_pos_id = self.subdomains.named_boundaries_id_dict['boundary_pos']
boundary_neg_id = self.subdomains.named_boundaries_id_dict['boundary_neg']
bc_boundary_pos_form = param * self.conc * fenics.Constant(1.0) * self.subdomains.dsn(boundary_pos_id)
bc_boundary_neg_form = param * self.conc * fenics.Constant(-5.0) * self.subdomains.dsn(boundary_neg_id)
bc_boundary = fenics.assemble(bc_boundary_pos_form) + fenics.assemble(bc_boundary_neg_form)
self.assertAlmostEqual(bc_boundary_auto, bc_boundary)
class TestTimeSeriesMultiData(TestCase):
def setUp(self):
# Domain
nx = ny = nz = 10
mesh = fenics.RectangleMesh(fenics.Point(-2, -2), fenics.Point(2, 2), nx, ny)
# function spaces
displacement_element = fenics.VectorElement("Lagrange", mesh.ufl_cell(), 1)
concentration_element = fenics.FiniteElement("Lagrange", mesh.ufl_cell(), 1)
element = fenics.MixedElement([displacement_element, concentration_element])
subspace_names = {0: 'displacement', 1: 'concentration'}
self.functionspace = FunctionSpace(mesh)
self.functionspace.init_function_space(element, subspace_names)
# build a 'solution' function
u_0_conc_expr = fenics.Expression('sqrt(pow(x[0]-x0,2)+pow(x[1]-y0,2)) < 0.1 ? (1.0) : (0.0)', degree=1,
x0=0.25,
y0=0.5)
u_0_disp_expr = fenics.Constant((1.0, 0.0))
self.U = self.functionspace.project_over_space(function_expr={0: u_0_disp_expr, 1: u_0_conc_expr})
def test_register_time_series(self):
tsmd = TimeSeriesMultiData()
tsmd.register_time_series(name='solution', functionspace=self.functionspace)
self.assertTrue(hasattr(tsmd, tsmd.time_series_prefix+'solution'))
tsmd.register_time_series(name='solution2', functionspace=self.functionspace)
self.assertTrue(hasattr(tsmd, tsmd.time_series_prefix+'solution2'))
def test_get_time_series(self):
tsmd = TimeSeriesMultiData()
tsmd.register_time_series(name='solution', functionspace=self.functionspace)
self.assertEqual(tsmd.get_time_series('solution'), getattr(tsmd, tsmd.time_series_prefix+'solution'))
def test_add_observation(self):
tsmd = TimeSeriesMultiData()
tsmd.register_time_series(name='solution', functionspace=self.functionspace)
tsmd.add_observation('solution', field=self.U, time=1, time_step=1, recording_step=1)
tsmd.add_observation('solution2', field=self.U, time=1, time_step=1, recording_step=1)
self.assertEqual(tsmd.get_time_series('solution').get_observation(1).get_time_step(), 1)
def test_get_observation(self):
tsmd = TimeSeriesMultiData()
tsmd.register_time_series(name='solution', functionspace=self.functionspace)
tsmd.add_observation('solution', field=self.U, time=1, time_step=1, recording_step=1)
tsmd.add_observation('solution2', field=self.U, time=1, time_step=1, recording_step=1)
self.assertEqual(tsmd.get_time_series('solution').get_observation(1),
tsmd.get_observation('solution', 1))
self.assertEqual(tsmd.get_observation('solution3', 1), None)
def test_get_solution_function(self):
tsmd = TimeSeriesMultiData()
tsmd.register_time_series(name='solution', functionspace=self.functionspace)
tsmd.add_observation('solution', field=self.U, time=1, time_step=1, recording_step=1)
u = tsmd.get_solution_function('solution', subspace_id=None, recording_step=1)
self.assertEqual(u.function_space(), self.U.function_space())
self.assertNotEqual(u, self.U)
def test_get_all_time_series(self):
tsmd = TimeSeriesMultiData()
tsmd.register_time_series(name='solution', functionspace=self.functionspace)
tsmd.register_time_series(name='solution2', functionspace=self.functionspace)
ts_dict = tsmd.get_all_time_series()
self.assertEqual(len(ts_dict), 2)
self.assertTrue('solution' in ts_dict.keys())
self.assertTrue('solution2' in ts_dict.keys())
def test_save_to_hdf5(self):
path_to_file = os.path.join(config.output_dir_testing, 'timeseries_to_hdf5.h5')
fu.ensure_dir_exists(path_to_file)
tsmd = TimeSeriesMultiData()
tsmd.register_time_series(name='solution', functionspace=self.functionspace)
tsmd.add_observation('solution', field=self.U, time=1, time_step=1, recording_step=1)
tsmd.add_observation('solution', field=self.U, time=1, time_step=1, recording_step=2)
tsmd.add_observation('solution', field=self.U, time=1, time_step=1, recording_step=3)
tsmd.register_time_series(name='solution2', functionspace=self.functionspace)
tsmd.add_observation('solution2', field=self.U, time=1, time_step=1, recording_step=1)
tsmd.add_observation('solution2', field=self.U, time=1, time_step=1, recording_step=2)
tsmd.add_observation('solution2', field=self.U, time=1, time_step=1, recording_step=3)
tsmd.save_to_hdf5(path_to_file, replace=True)
# path_to_file2 = os.path.join(config.output_dir_testing, 'timeseries_to_hdf5_manual.h5')
# hdf = fenics.HDF5File(self.functionspace._mesh.mpi_comm(), path_to_file2, "w")
# function = tsmd.get_solution_function('solution', recording_step=1)
# hdf.write(function, 'solution', 1)
# hdf.write(function, 'solution', 2)
# hdf.close()
def test_load_from_hdf5(self):
path_to_file = os.path.join(config.output_dir_testing, 'timeseries_to_hdf5_for_reading.h5')
fu.ensure_dir_exists(path_to_file)
# create file
tsmd = TimeSeriesMultiData()
tsmd.register_time_series(name='solution', functionspace=self.functionspace)
tsmd.add_observation('solution', field=self.U, time=1, time_step=1, recording_step=1)
tsmd.add_observation('solution', field=self.U, time=1, time_step=1, recording_step=2)
tsmd.add_observation('solution', field=self.U, time=1, time_step=1, recording_step=3)
tsmd.register_time_series(name='solution2', functionspace=self.functionspace)
tsmd.add_observation('solution2', field=self.U, time=1, time_step=1, recording_step=1)
tsmd.add_observation('solution2', field=self.U, time=1, time_step=1, recording_step=2)
tsmd.add_observation('solution2', field=self.U, time=1, time_step=1, recording_step=3)
tsmd.save_to_hdf5(path_to_file, replace=True)
# read file
tsmd2 = TimeSeriesMultiData()
tsmd2.register_time_series(name='solution', functionspace=self.functionspace)
tsmd2.register_time_series(name='solution2', functionspace=self.functionspace)
tsmd2.load_from_hdf5(path_to_file)
self.assertEqual(len(tsmd2.get_all_time_series()),2)
self.assertEqual(len(tsmd2.get_time_series('solution').get_all_recording_steps()),3)
self.assertEqual(len(tsmd2.get_time_series('solution2').get_all_recording_steps()), 3)
u_reloaded = tsmd2.get_solution_function(name='solution')
# print(u_reloaded.vector().array())
# print(self.U.vector().array())
array_1 = u_reloaded.vector().get_local()
array_2 = self.U.vector().get_local()
self.assertTrue(np.allclose(array_1, array_2))