def test_get_functionspace(self):
# single element
subspace_name = 'displacement'
functionspace_single = FunctionSpace(self.mesh)
functionspace_single.init_function_space(self.displacement_element, subspace_name)
V = functionspace_single.get_functionspace()
self.assertEqual(functionspace_single.get_functionspace(subspace_id=1), V)
# multiple elements
subspace_names = {0: 'displacement', 1: 'concentration'}
functionspace_double = FunctionSpace(self.mesh)
functionspace_double.init_function_space(self.element, subspace_names)
V = functionspace_double.get_functionspace()
self.assertNotEqual(functionspace_double.get_functionspace(1), V)
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 setUp(self):
# Domain
nx = ny = nz = 10
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)
# 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 = Boundary()
boundary_dict = {
'boundary_1': self.boundary,
'boundary_2': self.boundary
}
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()
# parameter instance
self.params = Parameters(self.functionspace, self.subdomains)
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)
def __init__(self, mesh, time_dependent=True):
"""
Init routine.
:param mesh: The mesh.
:param time_dependent: Boolean switch indicating whether this simulation is time-dependent.
"""
self.logger = logging.getLogger(__name__)
self.mesh = mesh
self.geometric_dimension = self.mesh.geometry().dim()
self.time_dependent = time_dependent
self.projection_parameters = {
'solver_type': 'cg',
'preconditioner_type': 'amg'
}
self.functionspace = FunctionSpace(
self.mesh, projection_parameters=self.projection_parameters)
self._define_model_params()
if fenics.is_version("<2018.1.x"):
pass
else:
if config.USE_ADJOINT:
self.tape = fenics.get_working_tape()
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},
}