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))