def assign(self, *args, **kwargs):
annotate = annotate_tape(kwargs)
outputs = Enlist(args[0])
inputs = Enlist(args[1])
if annotate:
for i, o in enumerate(outputs):
if not isinstance(o, OverloadedType):
outputs[i] = create_overloaded_object(o)
for j, i in enumerate(outputs):
if not isinstance(i, OverloadedType):
inputs[j] = create_overloaded_object(i)
block = FunctionAssignerBlock(self, inputs)
tape = get_working_tape()
tape.add_block(block)
with stop_annotating():
ret = backend.FunctionAssigner.assign(self, outputs.delist(), inputs.delist(), **kwargs)
if annotate:
for output in outputs:
block.add_output(output.block_variable)
return ret
def wrapper(*args, **kwargs):
"""When a form is assembled, the information about its nonlinear dependencies is lost,
and it is no longer easy to manipulate. Therefore, we decorate :func:`.assemble`
to *attach the form to the assembled object*. This lets the automatic annotation work,
even when the user calls the lower-level :py:data:`solve(A, x, b)`.
"""
ad_block_tag = kwargs.pop("ad_block_tag", None)
annotate = annotate_tape(kwargs)
with stop_annotating():
output = assemble(*args, **kwargs)
form = args[0]
if isinstance(output, numbers.Complex):
if not annotate:
return output
if not isinstance(output, float):
raise NotImplementedError(
"Taping for complex-valued 0-forms not yet done!")
output = create_overloaded_object(output)
block = AssembleBlock(form, ad_block_tag=ad_block_tag)
tape = get_working_tape()
tape.add_block(block)
block.add_output(output.block_variable)
else:
# Assembled a vector or matrix
output.form = form
return output
def _ad_convert_type(self, value, options=None):
options = {} if options is None else options
riesz_representation = options.get("riesz_representation", "l2")
if riesz_representation == "l2":
return create_overloaded_object(
compat.function_from_vector(self.function_space(),
value,
cls=backend.Function))
elif riesz_representation == "L2":
ret = compat.create_function(self.function_space())
u = backend.TrialFunction(self.function_space())
v = backend.TestFunction(self.function_space())
M = backend.assemble(backend.inner(u, v) * backend.dx)
compat.linalg_solve(M, ret.vector(), value)
return ret
elif riesz_representation == "H1":
ret = compat.create_function(self.function_space())
u = backend.TrialFunction(self.function_space())
v = backend.TestFunction(self.function_space())
M = backend.assemble(
backend.inner(u, v) * backend.dx +
backend.inner(backend.grad(u), backend.grad(v)) * backend.dx)
compat.linalg_solve(M, ret.vector(), value)
return ret
elif callable(riesz_representation):
return riesz_representation(value)
else:
raise NotImplementedError("Unknown Riesz representation %s" %
riesz_representation)
def sub(self, i, deepcopy=False, **kwargs):
from .function_assigner import FunctionAssigner, FunctionAssignerBlock
annotate = annotate_tape(kwargs)
if deepcopy:
ret = create_overloaded_object(
backend.Function.sub(self, i, deepcopy, **kwargs))
if annotate:
fa = FunctionAssigner(ret.function_space(),
self.function_space())
block = FunctionAssignerBlock(fa, Enlist(self))
tape = get_working_tape()
tape.add_block(block)
block.add_output(ret.block_variable)
else:
extra_kwargs = {}
if annotate:
extra_kwargs = {
"block_class": FunctionSplitBlock,
"_ad_floating_active": True,
"_ad_args": [self, i],
"_ad_output_args": [i],
"output_block_class": FunctionMergeBlock,
"_ad_outputs": [self],
}
ret = compat.create_function(self, i, **extra_kwargs)
return ret
def interpolate(*args, **kwargs):
"""Interpolation is overloaded to ensure that the returned Function object is overloaded.
We are not able to annotate the interpolation call at the moment.
"""
output = backend.interpolate(*args, **kwargs)
return create_overloaded_object(output)
def get_mesh(Ln,Lr,Ll,resolution,delta,theta):
cosdt = cos(atan2(delta*theta,1.))
sindt = sin(atan2(delta*theta,1.))
# input edges
top_left = edgeinput([Point(0.,1.0),Point(-Ll, 1.0)])
top_mid = edgeinput([Point(Ln,1-0.5*theta),Point(0., 1.)])
top_right = edgeinput([Point(Ln+Lr,1-0.5*theta),Point(Ln, 1-0.5*theta)])
right_top = edgeinput([Point(Ln+Lr,0.5*theta),Point(Ln+Lr, 1.-0.5*theta)])
right_bottom = edgeinput([Point(Ln+Lr,-0.5*theta),Point(Ln+Lr, 0.5*theta)])
mid_right = edgeinput([Point(Ln,0.5*theta ),Point(Ln+Lr,0.5*theta )])
mid_left = edgeinput([Point(0.,0.),Point(0., 1.)])
mid_bottom = edgeinput([Point(0.,0.),Point(Ln, 0.5*theta)])
left = edgeinput([Point(-Ll,1.),Point(-Ll, 0.)])
bottom_left = edgeinput([Point(-Ll,0.),Point(0., 0.)])
bottom_mid = edgeinput([Point(0.,0.),Point(Ln,-0.5*theta )])
bottom_right = edgeinput([Point(Ln,-0.5*theta ),Point(Ln+Lr,-0.5*theta )])
# define a vector with the edges
edges = [top_left,top_mid,top_right,right_top,right_bottom,mid_right,mid_left,mid_bottom,left,bottom_left,bottom_mid,bottom_right]
edges_number = len(edges)
# input domain
domain_complete = subdomaininput([top_left,left,bottom_left, bottom_mid, bottom_right, right_bottom, right_top, top_right, top_mid],[0,0,0,0,0,0,0,0,0],0)
# input subdomains
domain_left = subdomaininput([top_left,left,bottom_left,mid_left],[0,0,0,0],0)
domain_top = subdomaininput([mid_bottom,mid_right,right_top,top_right,top_mid,mid_left],[0,0,0,0,0,1],0)
domain_bottom = subdomaininput([bottom_mid,bottom_right,right_bottom,mid_right,mid_bottom],[0,0,0,1,1],0)
# define vector of subdomains
subdomains = [domain_left,domain_top,domain_bottom]
subdomain_number = len(subdomains)
# defining the domain, and the subdomains
domain = Polygon(domain_complete.get_polygon())
for i in range(0, subdomain_number):
domain.set_subdomain (i+1, Polygon((subdomains[i]).get_polygon()))
# generat the mesh
mesh = generate_mesh (domain, resolution)
mesh = create_overloaded_object(mesh)
print ("Anzahl Knoten:", mesh.num_vertices())
# defining coefficients on subdomains
X = FunctionSpace (mesh, "DG", 0)
dm = X.dofmap()
sudom = MeshFunction ('size_t', mesh, 2, mesh.domains())
sudom_arr = numpy.asarray (sudom.array(), dtype=numpy.int)
for cell in cells (mesh): sudom_arr [dm.cell_dofs (cell.index())] = sudom [cell]
def sudom_fct (sudom_arr, vals, fctspace):
f = Function (fctspace)
f.vector()[:] = numpy.choose (sudom_arr, vals)
return f
chi_a = sudom_fct (sudom_arr, [0,1,0,1], X)
chi_b = sudom_fct (sudom_arr, [0,0,1,0], X)
chi_test = sudom_fct (sudom_arr, [0,1,2,1], X)
return mesh, edges, edges_number, chi_a, chi_b, chi_test,mesh.num_vertices()
def wrapper(*args, **kwargs):
"""The project call performs an equation solve, and so it too must be annotated so that the
adjoint and tangent linear models may be constructed automatically by pyadjoint.
To disable the annotation of this function, just pass :py:data:`annotate=False`. This is useful in
cases where the solve is known to be irrelevant or diagnostic for the purposes of the adjoint
computation (such as projecting fields to other function spaces for the purposes of
visualisation)."""
annotate = annotate_tape(kwargs)
with stop_annotating():
output = project(*args, **kwargs)
output = create_overloaded_object(output)
if annotate:
bcs = kwargs.pop("bcs", [])
sb_kwargs = ProjectBlock.pop_kwargs(kwargs)
block = ProjectBlock(args[0], args[1], output, bcs, **sb_kwargs)
tape = get_working_tape()
tape.add_block(block)
block.add_output(output.block_variable)
return output
def refine(*args, **kwargs):
""" Refine is overloaded to ensure that the returned mesh is overloaded.
"""
with stop_annotating():
output = backend.refine(*args, **kwargs)
overloaded = create_overloaded_object(output)
return overloaded
def assemble(*args, **kwargs):
"""When a form is assembled, the information about its nonlinear dependencies is lost,
and it is no longer easy to manipulate. Therefore, fenics_adjoint overloads the :py:func:`dolfin.assemble`
function to *attach the form to the assembled object*. This lets the automatic annotation work,
even when the user calls the lower-level :py:data:`solve(A, x, b)`.
"""
annotate = annotate_tape(kwargs)
with stop_annotating():
output = backend.assemble(*args, **kwargs)
form = args[0]
if isinstance(output, float):
output = create_overloaded_object(output)
if annotate:
block = AssembleBlock(form)
tape = get_working_tape()
tape.add_block(block)
block.add_output(output.block_variable)
else:
# Assembled a vector or matrix
output.form = form
return output
def split(self, deepcopy=False, **kwargs):
from .function_assigner import FunctionAssigner, FunctionAssignerBlock
ad_block_tag = kwargs.pop("ad_block_tag", None)
annotate = annotate_tape(kwargs)
num_sub_spaces = backend.Function.function_space(self).num_sub_spaces()
if not annotate:
if deepcopy:
ret = tuple(
create_overloaded_object(
backend.Function.sub(self, i, deepcopy, **kwargs))
for i in range(num_sub_spaces))
else:
ret = tuple(
compat.create_function(self, i)
for i in range(num_sub_spaces))
elif deepcopy:
ret = []
fs = []
for i in range(num_sub_spaces):
f = create_overloaded_object(
backend.Function.sub(self, i, deepcopy, **kwargs))
fs.append(f.function_space())
ret.append(f)
fa = FunctionAssigner(fs, self.function_space())
block = FunctionAssignerBlock(fa,
Enlist(self),
ad_block_tag=ad_block_tag)
tape = get_working_tape()
tape.add_block(block)
for output in ret:
block.add_output(output.block_variable)
ret = tuple(ret)
else:
ret = tuple(
compat.create_function(self,
i,
block_class=FunctionSplitBlock,
_ad_floating_active=True,
_ad_args=[self, i],
_ad_output_args=[i],
output_block_class=FunctionMergeBlock,
_ad_outputs=[self])
for i in range(num_sub_spaces))
return ret
def __getitem__(self, item):
annotate = annotate_tape()
if annotate:
block = NumpyArraySliceBlock(self, item)
tape = get_working_tape()
tape.add_block(block)
with stop_annotating():
out = numpy.ndarray.__getitem__(self, item)
if annotate:
out = create_overloaded_object(out)
block.add_output(out.create_block_variable())
return out
def copy(self, *args, **kwargs):
annotate = annotate_tape(kwargs)
c = backend.Function.copy(self, *args, **kwargs)
func = create_overloaded_object(c)
if annotate:
if kwargs.pop("deepcopy", False):
block = FunctionAssignBlock(func, self)
tape = get_working_tape()
tape.add_block(block)
block.add_output(func.create_block_variable())
else:
# TODO: Implement. Here we would need to use floating types.
pass
return func
def project(self, b, *args, **kwargs):
annotate = annotate_tape(kwargs)
with stop_annotating():
output = super(Function, self).project(b, *args, **kwargs)
output = create_overloaded_object(output)
if annotate:
bcs = kwargs.pop("bcs", [])
block = ProjectBlock(b, self.function_space(), output, bcs)
tape = get_working_tape()
tape.add_block(block)
block.add_output(output.create_block_variable())
return output
def transfer_to_boundary(*args, **kwargs):
"""
Transfers values from a CG1 function on a mesh to its corresponding
BoundaryMesh.
"""
annotate = annotate_tape(kwargs)
with stop_annotating():
output = vector_mesh_to_boundary(*args)
output = create_overloaded_object(output)
if annotate:
block = VolumeTransferBlock(args[0], args[1])
tape = get_working_tape()
tape.add_block(block)
block.add_output(output.block_variable)
return output
def assign(self, *args, **kwargs):
annotate_tape = kwargs.pop("annotate_tape", True)
if annotate_tape:
other = args[0]
if not isinstance(other, OverloadedType):
other = create_overloaded_object(other)
block = AssignBlock(self, other)
tape = get_working_tape()
tape.add_block(block)
ret = backend.Constant.assign(self, *args, **kwargs)
if annotate_tape:
block.add_output(self.create_block_variable())
return ret
def wrapper(self, *args, **kwargs):
annotate = annotate_tape(kwargs)
if annotate:
other = args[0]
if not isinstance(other, OverloadedType):
other = create_overloaded_object(other)
block = ConstantAssignBlock(other)
tape = get_working_tape()
tape.add_block(block)
ret = assign(self, *args, **kwargs)
if annotate:
block.add_output(self.create_block_variable())
return ret
def transfer_from_boundary(*args, **kwargs):
"""
Transfers values from a CG1 function on the BoundaryMesh to its
original mesh
"""
annotate = annotate_tape(kwargs)
with stop_annotating():
output = vector_boundary_to_mesh(*args)
output = create_overloaded_object(output)
if annotate:
block = SurfaceTransferBlock(args[0], args[1])
tape = get_working_tape()
tape.add_block(block)
block.add_output(output.block_variable)
return output
def __call__(self, *args, **kwargs):
annotate = False
if len(args) == 1 and isinstance(args[0], (numpy.ndarray, )):
annotate = annotate_tape(kwargs)
if annotate:
block = FunctionEvalBlock(self, args[0])
tape = get_working_tape()
tape.add_block(block)
with stop_annotating():
out = backend.Function.__call__(self, *args, **kwargs)
if annotate:
out = create_overloaded_object(out)
block.add_output(out.create_block_variable())
return out
def BaseHeight(x, y, ground, **kwargs):
'''This is the adjoint version of RelativeHeight. It's goal is to
calculate the height of the turbine's base. At the same time, it creates
a block that helps propagate the adjoint information.'''
annotate = annotate_tape(kwargs)
with stop_annotating():
output = backend_BaseHeight(x, y, ground)
output = create_overloaded_object(output)
if annotate:
block = BaseHeightBlock(x, y, ground, output)
tape = get_working_tape()
tape.add_block(block)
block.add_output(output.block_variable)
return output
def assign(self, *args, **kwargs):
ad_block_tag = kwargs.pop("ad_block_tag", None)
annotate = annotate_tape(kwargs)
if annotate:
other = args[0]
if not isinstance(other, OverloadedType):
other = create_overloaded_object(other)
block = ConstantAssignBlock(other, ad_block_tag=ad_block_tag)
tape = get_working_tape()
tape.add_block(block)
with stop_annotating():
ret = backend.Constant.assign(self, *args, **kwargs)
if annotate:
block.add_output(self.create_block_variable())
return ret
def assign(self, other, *args, **kwargs):
"""To disable the annotation, just pass :py:data:`annotate=False` to this routine, and it acts exactly like the
Dolfin assign call."""
# do not annotate in case of self assignment
annotate = annotate_tape(kwargs) and self != other
if annotate:
if not isinstance(other, ufl.core.operator.Operator):
other = create_overloaded_object(other)
block = FunctionAssignBlock(self, other)
tape = get_working_tape()
tape.add_block(block)
with stop_annotating():
ret = super(Function, self).assign(other, *args, **kwargs)
if annotate:
block.add_output(self.create_block_variable())
return ret
parameters ["form_compiler"]["cpp_optimize"] = True
parameters ["form_compiler"]["representation"] = "uflacs"
Ll = 2; Ln = 4.5; Lr = 7.5
theta = 0.22
a1=11.56; a2=-17.44; a3=10.04; a4=-9.38
delta = 0.1
# Create domain with subdomains
domain = Rectangle (Point (-Ll, -0.5), Point (Ln+Lr, 0.5))
domain.set_subdomain (1, Rectangle (Point (-Ll, -0.5), Point (0, 0.5)))
domain.set_subdomain (2, Rectangle (Point (0, -0.5), Point (Ln, 0.5)))
domain.set_subdomain (3, Polygon ([Point (0, 0), Point (Ln, -0.5*theta), Point (Ln, 0.5*theta)]))
domain.set_subdomain (4, Polygon ([Point (Ln, -0.5*theta), Point (Ln+Lr, -0.5*theta), Point (Ln+Lr, 0.5*theta), Point (Ln, 0.5*theta)]))
with Timer ("mesh"): mesh = create_overloaded_object (generate_mesh (domain, 126)) # 126 253 505 1011 2022
class PeriodicBoundary (SubDomain):
# bottom boundary is target domain
def inside (self, x, on_boundary): return bool (near (x[1], -0.5) and on_boundary)
# Map top boundary to bottom boundary
def map (self, x, y): y[0] = x[0]; y[1] = x[1]-1.0
U = FunctionSpace (mesh, "CG", 1)
V = VectorFunctionSpace (mesh, "CG", 1, constrained_domain=PeriodicBoundary())
Vnp = VectorFunctionSpace (mesh, "CG", 1)
W = TensorFunctionSpace (mesh, "DG", 0)
X = FunctionSpace (mesh, "DG", 0)
x = SpatialCoordinate (mesh)
mu = 5.
weight = 1.5
volweight = 0.02
ftol = 1e-10
gtol = 1e-8
# defining the domain and the function spaces
domain = Rectangle(dolfin.Point(0., 0.), dolfin.Point(1., 1.))
for i in range(0, n):
for j in range(0, n):
domain = domain - Circle(dolfin.Point((0.5 + i) / n,
(0.5 + j) / n), 1 / (4 * n))
# define mesh and function space
mesh = generate_mesh(domain, resolution)
mesh = create_overloaded_object(mesh)
x = SpatialCoordinate(mesh)
# Function spaces
U = VectorFunctionSpace(mesh, 'CG', 1)
V = FunctionSpace(mesh, 'CG', 1)
density = Function(V)
u = Function(U)
uu = TrialFunction(U)
xx = Function(U, name="xx")
xx.assign(project(x, U))
# define subdomain for top boundary
subdomains = MeshFunction("size_t", mesh, mesh.topology().dim() - 1)
subdomains.set_all(0)
def inner(*args, **kwargs):
"Creating an overloaded Mesh that will be used in shape optimization"
with stop_annotating():
mesh = constructor(*args, **kwargs)
return create_overloaded_object(mesh)
def get_mesh(ILt1,ILt2,ILr1,ILr2,ILtt,ILrr,Ipt,Ipr,phi,theta_t,theta_r,resolution,c_periodic):
rounded = 12
# input edges)
a_x = round(0.,rounded)
a_y = round(Ipt+ILt1+ILtt-(1-theta_t)*sin(phi),rounded)
b_x = round((1-theta_t)*cos(phi),rounded)
b_y = round(Ipt+ILt1+ILtt,rounded)
c_x = round(cos(phi),rounded)
c_y = round(Ipt+ILt1+ILtt+theta_t*sin(phi),rounded)
d_x = round(0.,rounded)
d_y = round(ILt2,rounded)
e_x = round((1-theta_t)*cos(phi),rounded)
e_y = round(Ipt+ILt1,rounded)
f_x = round(cos(phi),rounded)
f_y = round(sin(phi) + ILt2,rounded)
g_x = round(0.,rounded)
g_y = round(0.,rounded)
h_x = round(Ipr,rounded)
h_y = round(Ipt,rounded)
i_x = round(cos(phi),rounded)
i_y = round(sin(phi),rounded)
j_x = round(ILr1,rounded)
j_y = round(Ipt-theta_r*sin(phi),rounded)
k_x = round(Ipr+ILr2,rounded)
k_y = round(Ipt,rounded)
l_x = round(cos(phi)+ILr1,rounded)
l_y = round(sin(phi)+Ipt-theta_r*sin(phi),rounded)
m_x = round(ILr1+ILrr,rounded)
m_y = round(Ipt-theta_r*sin(phi),rounded)
n_x = round(ILr1+ILrr+theta_r*cos(phi),rounded)
n_y = round(Ipt,rounded)
o_x = round(ILr1+ILrr+cos(phi),rounded)
o_y = round(sin(phi)+Ipt-theta_r*sin(phi),rounded)
tl = edgeinput([dolfin.Point(b_x,b_y),dolfin.Point(a_x, a_y)])
tr = edgeinput([dolfin.Point(c_x,c_y),dolfin.Point(b_x, b_y)])
rb = edgeinput([dolfin.Point(m_x, m_y),dolfin.Point(n_x, n_y)])
rt = edgeinput([dolfin.Point(n_x, n_y),dolfin.Point(o_x, o_y)])
mt = edgeinput([dolfin.Point(e_x,e_y),dolfin.Point(b_x, b_y)])
mr = edgeinput([dolfin.Point(k_x, k_y),dolfin.Point(n_x, n_y)])
lt = edgeinput(get_points(True,a_x,a_y,d_x,d_y,resolution,c_periodic))
lt2 = edgeinput(get_points(False,f_x,f_y,c_x,c_y,resolution,c_periodic))
br = edgeinput(get_points(True,j_x,j_y,m_x,m_y,resolution,c_periodic))
br2 = edgeinput(get_points(False,o_x,o_y,l_x,l_y,resolution,c_periodic))
t1 = edgeinput([dolfin.Point(h_x,h_y),dolfin.Point(e_x,e_y)])
t2 = edgeinput(get_points(True,d_x,d_y,g_x,g_y,resolution,c_periodic))
t3 = edgeinput([dolfin.Point(h_x,h_y),dolfin.Point(i_x,i_y)])
t4 = edgeinput(get_points(False,i_x,i_y,f_x,f_y,resolution,c_periodic))
r1 = edgeinput(get_points(True,g_x,g_y,j_x,j_y,resolution,c_periodic))
r2 = edgeinput([dolfin.Point(h_x,h_y),dolfin.Point(k_x,k_y)])
r3 = edgeinput([dolfin.Point(g_x,g_y),dolfin.Point(h_x,h_y)])
r4 = edgeinput(get_points(False,l_x,l_y,i_x,i_y,resolution,c_periodic))
# define a vector with the edges
edges = [tl,tr,rb,rt,mt,mr,lt,lt2,br,br2,t1,t2,t3,t4,r1,r2,r3,r4]
edges_number = len(edges)
# define the complete domain
domain_complete = subdomaininput([lt,t2,r1,br,rb,rt,br2,r4,t4,lt2,tr,tl],[0,0,0,0,0,0,0,0,0,0,0,0],0)
# input subdomains
domain_left = subdomaininput([lt,t2,r3,t1,mt,tl],[0,0,0,0,0,0],0)
domain_top = subdomaininput([t3,t4,lt2,tr,mt,t1],[0,0,0,0,1,1],0)
domain_right = subdomaininput([r2,mr,rt,br2,r4,t3],[0,0,0,0,0,1],0)
domain_bottom = subdomaininput([r1,br,rb,mr,r2,r3],[0,0,0,1,1,1],0)
# define a vector with the subdomains
subdomains = [domain_left,domain_top,domain_right,domain_bottom]
subdomain_number = len(subdomains)
# defining the domain, and the subdomains
domain = Polygon(domain_complete.get_polygon())
for i in range(0, subdomain_number):
domain.set_subdomain (i+1, Polygon((subdomains[i]).get_polygon()))
# generat the mesh
#domain2 = Polygon([Point(0,0),dolfin.Point(3,0),dolfin.Point(3,3),dolfin.Point(0,3)])
mesh = generate_mesh (domain, resolution)
sudom = MeshFunction ('size_t', mesh, 2, mesh.domains())
print ("Anzahl Knoten:", mesh.num_vertices())
# refining the mesh everywhere but in the laminate
maximumt = max(ILt1,Ipt+ILt2)
maximumr = max(ILr1,Ipr+ILr2)
tanphi = tan(phi)
cell_markers = MeshFunction("bool", mesh,2)
cell_markers.set_all(False)
for cell in cells(mesh):
if ((cell.get_vertex_coordinates()[1]< maximumt*1. + tanphi * cell.get_vertex_coordinates()[0]) and (cell.get_vertex_coordinates()[0]< maximumr*1. + (1/tanphi) * cell.get_vertex_coordinates()[1])):
cell_markers[cell]=True
mesh = refine(mesh, cell_markers)
sudom = adapt(sudom, mesh)
print ("Anzahl Knoten:", mesh.num_vertices())
# cell_markers = MeshFunction("bool", mesh,2)
# cell_markers.set_all(False)
# for cell in cells(mesh):
# if ((cell.get_vertex_coordinates()[1]< maximumt*1.25 + tanphi * cell.get_vertex_coordinates()[0]) and (cell.get_vertex_coordinates()[0]< maximumr*1.25 + (1/tanphi) * cell.get_vertex_coordinates()[1])):
# cell_markers[cell]=True
# mesh = refine(mesh, cell_markers)
# sudom = adapt(sudom, mesh)
# print ("Anzahl Knoten:", mesh.num_vertices())
# cell_markers = MeshFunction("bool", mesh,2)
# cell_markers.set_all(False)
# for cell in cells(mesh):
# if ((cell.get_vertex_coordinates()[1]< maximumt*1. + tanphi * cell.get_vertex_coordinates()[0]) and (cell.get_vertex_coordinates()[0]< maximumr*1. + (1/tanphi) * cell.get_vertex_coordinates()[1])):
# cell_markers[cell]=True
# mesh = refine(mesh, cell_markers)
# sudom = adapt(sudom, mesh)
# print ("Anzahl Knoten:", mesh.num_vertices())
# cell_markers = MeshFunction("bool", mesh,2)
# cell_markers.set_all(False)
# for cell in cells(mesh):
# if ((cell.get_vertex_coordinates()[1]< 0.5 + 0.5*Ipt - 0.5*Ipt*tanphi + tanphi * cell.get_vertex_coordinates()[0]) and (cell.get_vertex_coordinates()[0]< 0.5 + 0.5*Ipr - 0.5*Ipt * (1/tanphi) + (1/tanphi) * cell.get_vertex_coordinates()[1])):
# cell_markers[cell]=True
# mesh = refine(mesh, cell_markers)
# sudom = adapt(sudom, mesh)
# print ("Anzahl Knoten:", mesh.num_vertices())
# refining the mesh at the endpoint of edges
# ref_rad=0.05
# for k in range(0,1):
# cell_markers = MeshFunction("bool", mesh,2)
# cell_markers.set_all(False)
# for cell in cells(mesh):
# if (cell.distance(Point(d_x,d_y))<ref_rad*2**(-k)):
# cell_markers[cell]=True
# elif (cell.distance(Point(e_x,e_y))<ref_rad*2**(-k)):
# cell_markers[cell]=True
# elif (cell.distance(Point(f_x,f_y))<ref_rad*2**(-k)):
# cell_markers[cell]=True
# elif (cell.distance(Point(j_x,j_y))<ref_rad*2**(-k)):
# cell_markers[cell]=True
# elif (cell.distance(Point(k_x,k_y))<ref_rad*2**(-k)):
# cell_markers[cell]=True
# elif (cell.distance(Point(l_x,l_y))<ref_rad*2**(-k)):
# cell_markers[cell]=True
# mesh = refine(mesh, cell_markers)
# sudom = adapt(sudom, mesh)
# print ("Anzahl Knoten:", mesh.num_vertices())
# for k in range(0,1):
# cell_markers = MeshFunction("bool", mesh,2)
# cell_markers.set_all(False)
# for cell in cells(mesh):
# if (cell.distance(Point(g_x,g_y))<ref_rad*2**(-k)):
# cell_markers[cell]=True
# elif (cell.distance(Point(h_x,h_y))<ref_rad*2**(-k)):
# cell_markers[cell]=True
# elif (cell.distance(Point(i_x,i_y))<ref_rad*2**(-k)):
# cell_markers[cell]=True
# mesh = refine(mesh, cell_markers)
# sudom = adapt(sudom, mesh)
# print ("Anzahl Knoten:", mesh.num_vertices())
mesh = create_overloaded_object(mesh)
# defining coefficients on subdomains
X = FunctionSpace (mesh, "DG", 0)
dm = X.dofmap()
sudom_arr = numpy.asarray (sudom.array(), dtype=numpy.int64)
for cell in cells (mesh):
sudom_arr [dm.cell_dofs (cell.index())] = sudom [cell]
#sudom_arr = numpy.asarray (sudom.array(), dtype=numpy.int64)
#for cell in cells (mesh): sudom_arr [dm.cell_dofs (cell.index())] = sudom [cell]
def sudom_fct (sudom_arr, vals, fctspace):
f = Function (fctspace)
f.vector()[:] = numpy.choose (sudom_arr, vals)
return f
chi_a = sudom_fct (sudom_arr, [0,1,0,1,0], X)
chi_b = sudom_fct (sudom_arr, [0,0,1,0,1], X)
return mesh, edges, edges_number, chi_a, chi_b,mesh.num_vertices()
def recompute_component(self, inputs, block_variable, idx, prepared):
form = prepared
output = backend.assemble(form)
output = create_overloaded_object(output)
return output
