def test_gaussian_elimination(geometry, mesh):
cell = mesh.ufl_cell().cellname()
DG1_elt = FiniteElement("DG", cell, 1, variant="equispaced")
DG1 = FunctionSpace(mesh, DG1_elt)
vec_DG1 = VectorFunctionSpace(mesh, DG1_elt)
act_coords = Function(vec_DG1)
eff_coords = Function(vec_DG1)
field_init = Function(DG1)
field_true = Function(DG1)
field_final = Function(DG1)
# We now include things for the num of exterior values, which may be removed
DG0 = FunctionSpace(mesh, "DG", 0)
num_ext = Function(DG0)
num_ext.dat.data[0] = 1.0
# Get initial and true conditions
field_init, field_true, act_coords, eff_coords = setup_values(
geometry, field_init, field_true, act_coords, eff_coords)
kernel = kernels.GaussianElimination(DG1)
kernel.apply(field_init, field_final, act_coords, eff_coords, num_ext)
tolerance = 1e-12
assert abs(field_true.dat.data[0] - field_final.dat.data[0]) < tolerance
assert abs(field_true.dat.data[1] - field_final.dat.data[1]) < tolerance
if geometry == "2D":
assert abs(field_true.dat.data[2] -
field_final.dat.data[2]) < tolerance
assert abs(field_true.dat.data[3] -
field_final.dat.data[3]) < tolerance
def __init__(self,
v_CG1,
v_DG1,
method=Boundary_Method.physics,
eff_coords=None):
self.v_DG1 = v_DG1
self.v_CG1 = v_CG1
self.v_DG1_old = Function(v_DG1.function_space())
self.eff_coords = eff_coords
self.method = method
mesh = v_CG1.function_space().mesh()
DG0 = FunctionSpace(mesh, "DG", 0)
CG1 = FunctionSpace(mesh, "CG", 1)
if DG0.extruded:
cell = mesh._base_mesh.ufl_cell().cellname()
DG1_hori_elt = FiniteElement("DG", cell, 1, variant="equispaced")
DG1_vert_elt = FiniteElement("DG",
interval,
1,
variant="equispaced")
DG1_element = TensorProductElement(DG1_hori_elt, DG1_vert_elt)
else:
cell = mesh.ufl_cell().cellname()
DG1_element = FiniteElement("DG", cell, 1, variant="equispaced")
DG1 = FunctionSpace(mesh, DG1_element)
self.num_ext = find_domain_boundaries(mesh)
# check function spaces of functions
if self.method == Boundary_Method.dynamics:
if v_CG1.function_space() != CG1:
raise NotImplementedError(
"This boundary recovery method requires v1 to be in CG1.")
if v_DG1.function_space() != DG1:
raise NotImplementedError(
"This boundary recovery method requires v_out to be in DG1."
)
if eff_coords is None:
raise ValueError(
'Need eff_coords field for dynamics boundary methods')
elif self.method == Boundary_Method.physics:
# check that mesh is valid -- must be an extruded mesh
if not DG0.extruded:
raise NotImplementedError(
'The physics boundary method only works on extruded meshes'
)
# base spaces
cell = mesh._base_mesh.ufl_cell().cellname()
w_hori = FiniteElement("DG", cell, 0, variant="equispaced")
w_vert = FiniteElement("CG", interval, 1, variant="equispaced")
# build element
theta_element = TensorProductElement(w_hori, w_vert)
# spaces
Vtheta = FunctionSpace(mesh, theta_element)
Vtheta_broken = FunctionSpace(mesh, BrokenElement(theta_element))
if v_CG1.function_space() != Vtheta:
raise ValueError(
"This boundary recovery method requires v_CG1 to be in DG0xCG1 TensorProductSpace."
)
if v_DG1.function_space() != Vtheta_broken:
raise ValueError(
"This boundary recovery method requires v_DG1 to be in the broken DG0xCG1 TensorProductSpace."
)
else:
raise ValueError(
"Boundary method should be a Boundary Method Enum object.")
vec_DG1 = VectorFunctionSpace(DG0.mesh(), DG1_element)
x = SpatialCoordinate(DG0.mesh())
self.interpolator = Interpolator(self.v_CG1, self.v_DG1)
if self.method == Boundary_Method.dynamics:
# STRATEGY
# obtain a coordinate field for all the nodes
self.act_coords = Function(vec_DG1).project(
x) # actual coordinates
self.eff_coords = eff_coords # effective coordinates
self.output = Function(DG1)
self.on_exterior = find_domain_boundaries(mesh)
self.gaussian_elimination_kernel = kernels.GaussianElimination(DG1)
elif self.method == Boundary_Method.physics:
self.bottom_kernel = kernels.PhysicsRecoveryBottom()
self.top_kernel = kernels.PhysicsRecoveryTop()
def __init__(self,
v_CG1,
v_DG1,
method=Boundary_Method.physics,
coords_to_adjust=None):
self.v_DG1 = v_DG1
self.v_CG1 = v_CG1
self.v_DG1_old = Function(v_DG1.function_space())
self.coords_to_adjust = coords_to_adjust
self.method = method
mesh = v_CG1.function_space().mesh()
VDG0 = FunctionSpace(mesh, "DG", 0)
VCG1 = FunctionSpace(mesh, "CG", 1)
if VDG0.extruded:
cell = mesh._base_mesh.ufl_cell().cellname()
DG1_hori_elt = FiniteElement("DG", cell, 1, variant="equispaced")
DG1_vert_elt = FiniteElement("DG",
interval,
1,
variant="equispaced")
DG1_element = TensorProductElement(DG1_hori_elt, DG1_vert_elt)
else:
cell = mesh.ufl_cell().cellname()
DG1_element = FiniteElement("DG", cell, 1, variant="equispaced")
VDG1 = FunctionSpace(mesh, DG1_element)
self.num_ext = Function(VDG0)
# check function spaces of functions
if self.method == Boundary_Method.dynamics:
if v_CG1.function_space() != VCG1:
raise NotImplementedError(
"This boundary recovery method requires v1 to be in CG1.")
if v_DG1.function_space() != VDG1:
raise NotImplementedError(
"This boundary recovery method requires v_out to be in DG1."
)
# check whether mesh is valid
if mesh.topological_dimension() == 2:
# if mesh is extruded then we're fine, but if not needs to be quads
if not VDG0.extruded and mesh.ufl_cell().cellname(
) != 'quadrilateral':
raise NotImplementedError(
'For 2D meshes this recovery method requires that elements are quadrilaterals'
)
elif mesh.topological_dimension() == 3:
# assume that 3D mesh is extruded
if mesh._base_mesh.ufl_cell().cellname() != 'quadrilateral':
raise NotImplementedError(
'For 3D extruded meshes this recovery method requires a base mesh with quadrilateral elements'
)
elif mesh.topological_dimension() != 1:
raise NotImplementedError(
'This boundary recovery is implemented only on certain classes of mesh.'
)
if coords_to_adjust is None:
raise ValueError(
'Need coords_to_adjust field for dynamics boundary methods'
)
elif self.method == Boundary_Method.physics:
# check that mesh is valid -- must be an extruded mesh
if not VDG0.extruded:
raise NotImplementedError(
'The physics boundary method only works on extruded meshes'
)
# base spaces
cell = mesh._base_mesh.ufl_cell().cellname()
w_hori = FiniteElement("DG", cell, 0, variant="equispaced")
w_vert = FiniteElement("CG", interval, 1, variant="equispaced")
# build element
theta_element = TensorProductElement(w_hori, w_vert)
# spaces
Vtheta = FunctionSpace(mesh, theta_element)
Vtheta_broken = FunctionSpace(mesh, BrokenElement(theta_element))
if v_CG1.function_space() != Vtheta:
raise ValueError(
"This boundary recovery method requires v_CG1 to be in DG0xCG1 TensorProductSpace."
)
if v_DG1.function_space() != Vtheta_broken:
raise ValueError(
"This boundary recovery method requires v_DG1 to be in the broken DG0xCG1 TensorProductSpace."
)
else:
raise ValueError(
"Boundary method should be a Boundary Method Enum object.")
VuDG1 = VectorFunctionSpace(VDG0.mesh(), DG1_element)
x = SpatialCoordinate(VDG0.mesh())
self.interpolator = Interpolator(self.v_CG1, self.v_DG1)
if self.method == Boundary_Method.dynamics:
# STRATEGY
# obtain a coordinate field for all the nodes
self.act_coords = Function(VuDG1).project(x) # actual coordinates
self.eff_coords = Function(VuDG1).project(
x) # effective coordinates
self.output = Function(VDG1)
shapes = {
"nDOFs":
self.v_DG1.function_space().finat_element.space_dimension(),
"dim":
np.prod(VuDG1.shape, dtype=int)
}
num_ext_domain = ("{{[i]: 0 <= i < {nDOFs}}}").format(**shapes)
num_ext_instructions = ("""
<float64> SUM_EXT = 0
for i
SUM_EXT = SUM_EXT + EXT_V1[i]
end
NUM_EXT[0] = SUM_EXT
""")
coords_domain = ("{{[i, j, k, ii, jj, kk, ll, mm, iii, kkk]: "
"0 <= i < {nDOFs} and "
"0 <= j < {nDOFs} and 0 <= k < {dim} and "
"0 <= ii < {nDOFs} and 0 <= jj < {nDOFs} and "
"0 <= kk < {dim} and 0 <= ll < {dim} and "
"0 <= mm < {dim} and 0 <= iii < {nDOFs} and "
"0 <= kkk < {dim}}}").format(**shapes)
coords_insts = (
"""
<float64> sum_V1_ext = 0
<int> index = 100
<float64> dist = 0.0
<float64> max_dist = 0.0
<float64> min_dist = 0.0
"""
# only do adjustment in cells with at least one DOF to adjust
"""
if NUM_EXT[0] > 0
"""
# find the maximum distance between DOFs in this cell, to serve as starting point for finding min distances
"""
for i
for j
dist = 0.0
for k
dist = dist + pow(ACT_COORDS[i,k] - ACT_COORDS[j,k], 2.0)
end
dist = pow(dist, 0.5) {{id=sqrt_max_dist, dep=*}}
max_dist = fmax(dist, max_dist) {{id=max_dist, dep=sqrt_max_dist}}
end
end
"""
# loop through cells and find which ones to adjust
"""
for ii
if EXT_V1[ii] > 0.5
"""
# find closest interior node
"""
min_dist = max_dist
index = 100
for jj
if EXT_V1[jj] < 0.5
dist = 0.0
for kk
dist = dist + pow(ACT_COORDS[ii,kk] - ACT_COORDS[jj,kk], 2)
end
dist = pow(dist, 0.5)
if dist <= min_dist
index = jj
end
min_dist = fmin(min_dist, dist)
for ll
EFF_COORDS[ii,ll] = 0.5 * (ACT_COORDS[ii,ll] + ACT_COORDS[index,ll])
end
end
end
else
"""
# for DOFs that aren't exterior, use the original coordinates
"""
for mm
EFF_COORDS[ii, mm] = ACT_COORDS[ii, mm]
end
end
end
else
"""
# for interior elements, just use the original coordinates
"""
for iii
for kkk
EFF_COORDS[iii, kkk] = ACT_COORDS[iii, kkk]
end
end
end
""").format(**shapes)
_num_ext_kernel = (num_ext_domain, num_ext_instructions)
_eff_coords_kernel = (coords_domain, coords_insts)
self.gaussian_elimination_kernel = kernels.GaussianElimination(
VDG1)
# find number of external DOFs per cell
par_loop(_num_ext_kernel,
dx, {
"NUM_EXT": (self.num_ext, WRITE),
"EXT_V1": (self.coords_to_adjust, READ)
},
is_loopy_kernel=True)
# find effective coordinates
logger.warning(
'Finding effective coordinates for boundary recovery. This could give unexpected results for deformed meshes over very steep topography.'
)
par_loop(_eff_coords_kernel,
dx, {
"EFF_COORDS": (self.eff_coords, WRITE),
"ACT_COORDS": (self.act_coords, READ),
"NUM_EXT": (self.num_ext, READ),
"EXT_V1": (self.coords_to_adjust, READ)
},
is_loopy_kernel=True)
elif self.method == Boundary_Method.physics:
self.bottom_kernel = kernels.PhysicsRecoveryBottom()
self.top_kernel = kernels.PhysicsRecoveryTop()
def __init__(self, v_CG1, v_DG1, method=Boundary_Method.physics, eff_coords=None):
self.v_DG1 = v_DG1
self.v_CG1 = v_CG1
self.v_DG1_old = Function(v_DG1.function_space())
self.eff_coords = eff_coords
self.method = method
mesh = v_CG1.function_space().mesh()
DG0 = FunctionSpace(mesh, "DG", 0)
CG1 = FunctionSpace(mesh, "CG", 1)
if DG0.extruded:
cell = mesh._base_mesh.ufl_cell().cellname()
DG1_hori_elt = FiniteElement("DG", cell, 1, variant="equispaced")
DG1_vert_elt = FiniteElement("DG", interval, 1, variant="equispaced")
DG1_element = TensorProductElement(DG1_hori_elt, DG1_vert_elt)
else:
cell = mesh.ufl_cell().cellname()
DG1_element = FiniteElement("DG", cell, 1, variant="equispaced")
DG1 = FunctionSpace(mesh, DG1_element)
self.num_ext = find_domain_boundaries(mesh)
# check function spaces of functions
if self.method == Boundary_Method.dynamics:
if v_CG1.function_space() != CG1:
raise NotImplementedError("This boundary recovery method requires v1 to be in CG1.")
if v_DG1.function_space() != DG1:
raise NotImplementedError("This boundary recovery method requires v_out to be in DG1.")
if eff_coords is None:
raise ValueError('Need eff_coords field for dynamics boundary methods')
elif self.method == Boundary_Method.physics:
# check that mesh is valid -- must be an extruded mesh
if not DG0.extruded:
raise NotImplementedError('The physics boundary method only works on extruded meshes')
# check that function spaces are valid
sub_elements = v_CG1.function_space().ufl_element().sub_elements()
if (sub_elements[0].family() not in ['Discontinuous Lagrange', 'DQ']
or sub_elements[1].family() != 'Lagrange'
or v_CG1.function_space().ufl_element().degree() != (0, 1)):
raise ValueError("This boundary recovery method requires v_CG1 to be in DG0xCG1 TensorProductSpace.")
brok_elt = v_DG1.function_space().ufl_element()
if (brok_elt.degree() != (0, 1)
or (type(brok_elt) is not BrokenElement
and (brok_elt.sub_elements[0].family() not in ['Discontinuous Lagrange', 'DQ']
or brok_elt.sub_elements[1].family() != 'Discontinuous Lagrange'))):
raise ValueError("This boundary recovery method requires v_DG1 to be in the broken DG0xCG1 TensorProductSpace.")
else:
raise ValueError("Boundary method should be a Boundary Method Enum object.")
vec_DG1 = VectorFunctionSpace(DG0.mesh(), DG1_element)
x = SpatialCoordinate(DG0.mesh())
self.interpolator = Interpolator(self.v_CG1, self.v_DG1)
if self.method == Boundary_Method.dynamics:
# STRATEGY
# obtain a coordinate field for all the nodes
self.act_coords = Function(vec_DG1).project(x) # actual coordinates
self.eff_coords = eff_coords # effective coordinates
self.output = Function(DG1)
self.on_exterior = find_domain_boundaries(mesh)
self.gaussian_elimination_kernel = kernels.GaussianElimination(DG1)
elif self.method == Boundary_Method.physics:
self.bottom_kernel = kernels.PhysicsRecoveryBottom()
self.top_kernel = kernels.PhysicsRecoveryTop()