def reset_geom_params(self):
"""
Reset the necessary parameters to create a new geometry.
Returns:
"""
# Reset the mesh object.
self.my_mesh = Mesh()
# Initialize physical groups and geometry parameters.
self.p_dict = dict(
) # Create a dictionary containing all the points of the geometry.
self.interface_points = dict(
) # Dictionary that will isolate the points conforming the interface.
self.list_points_interface = list()
self.refinement_points_tip = None # List containing the refinement points of the tip.
self.refinement_points_knee = None # List containing the refinement points of the knee.
self.point_num = 1 # Number of points counter.
self.key = '' # Variable creating the dicts of the self.p_dict variable.
self.interface_end_point = None # Locator of the last point defining the interface
self.interface_end_point_z = None # Locator of the z coordinate of the last point defining the interface
self.inlet = Entity.PhysicalGroup(name='Inlet', mesh=self.my_mesh)
self.twr = Entity.PhysicalGroup(name='Tube_Wall_R', mesh=self.my_mesh)
self.twl = Entity.PhysicalGroup(name='Tube_Wall_L', mesh=self.my_mesh)
self.bw = Entity.PhysicalGroup(name='Bottom_Wall', mesh=self.my_mesh)
self.lwr = Entity.PhysicalGroup(name='Lateral_Wall_R',
mesh=self.my_mesh)
self.tw = Entity.PhysicalGroup(name='Top_Wall', mesh=self.my_mesh)
self.lwl = Entity.PhysicalGroup(name='Lateral_Wall_L',
mesh=self.my_mesh)
self.interface = Entity.PhysicalGroup(name='Interface',
mesh=self.my_mesh)
self.vacuum = Entity.PhysicalGroup(name='Vacuum', mesh=self.my_mesh)
self.liquid = Entity.PhysicalGroup(name='Liquid', mesh=self.my_mesh)
def writeGEO(grid, mesh, filename):
"""Example: grid = np.array([[0,0],[0.5,0.5],[0,0.5]]), mesh = np.array([1,4,3])"""
# with pygmsh.geo.Geometry() as geom:
# for e in range(mesh.shape[0] // 3):
# p1 = grid[mesh[3*e]]
# p2 = grid[mesh[3*e+1]]
# p3 = grid[mesh[3*e+2]]
#
# geom.add_polygon(
# [
# list(p1),list(p2),list(p3)
# ],
# )
# mesh = geom.generate_mesh()
#
# mesh.write(filename)
mesh_geo = Mesh()
pt_list = []
for i in range(grid.shape[0]):
p = Entity.Point(grid[i, :])
pt_list.append(p)
mesh_geo.addEntity(p)
for e in range(mesh.shape[0] // 3):
p1 = pt_list[mesh[3 * e]]
p2 = pt_list[mesh[3 * e + 1]]
p3 = pt_list[mesh[3 * e + 2]]
l1 = Entity.Curve([p1, p2])
l2 = Entity.Curve([p2, p3])
l3 = Entity.Curve([p3, p1])
# entities can also be added in a batch
mesh_geo.addEntities([l1, l2, l3])
mesh_geo.writeGeo(filename)
def adaptive_refinement_tip(self):
"""
Small Algorithm to adaptively refine the tip of the interface, to obtain a much higher quality of the mesh at
that part. This method is independent on the number of points defining the interface, thus it can be widely
used.
This algorithm will calculate the distance between all the points defining the interface, and then it will
'project' these points onto the Lateral Wall Left and the Tube Wall Left. In this way, we will be forcing GMSH
to dramatically increment the quality of the mesh at that zone by increasing the density of nodes. This method
will yield increments of quality of ten times their quality without the algorithm, or even more in less refined
cases.
"""
if self.refinement_points_tip is None: # This if statement will be initialized by the Lateral Wall L refinement
self.refinement_points_tip = np.array([])
prev_z = self.interface_end_point_z
for i in np.arange(1, len(self.list_points_interface)):
distance = GMSHInterface.length_wrapper(points=[
self.list_points_interface[i], self.list_points_interface[
i - 1]
])
self.refinement_points_tip = np.append(
self.refinement_points_tip, prev_z + distance)
self.p_dict[self.key] = Entity.Point([0, prev_z + distance, 0],
mesh=self.my_mesh)
self.point_num += 1
self.key = 'p' + str(self.point_num)
prev_z += distance
else: # This statement will be executed by the refinement of the Tube Wall Left boundary.
for z in self.refinement_points_tip[::-1]:
self.p_dict[self.key] = Entity.Point(
[0, 2 * self.interface_end_point_z - z, 0],
mesh=self.my_mesh)
self.point_num += 1
self.key = 'p' + str(self.point_num)
def __init__(self):
self.geoPath = '' # Initialize the path where the .geo file will be stored.
self.filename = '' # Initialize the name of the .geo file.
self.refinement = '' # This string will be later modified by the user to indicate the refinement of mesh.
self.msh_filename = ''
self.geo_filename = ''
self.mesh_filename = ''
self.app = None # Variable containing all the mesh details specified by the user.
# Define the geometry and mesh object, as well as some of its properties.
self.my_mesh = Mesh()
self.max_element_size = None
self.min_element_size = None
self.length_from_curvature = None
self.length_extend = None
# Define auxiliary variables.
self.interface_fun = ''
self.interface_fun_r = ''
self.interface_fun_z = ''
# Initialize physical groups and geometry parameters.
self.p_dict = dict(
) # Create a dictionary containing all the points of the geometry.
self.interface_points = dict(
) # Dictionary that will isolate the points conforming the interface.
self.list_points_interface = list()
self.refinement_points_tip = None # List containing the refinement points of the tip.
self.refinement_points_knee = None # List containing the refinement points of the knee.
self.point_num = 1 # Number of points counter.
self.key = '' # Variable creating the dicts of the self.p_dict variable.
self.interface_end_point = None # Locator of the last point defining the interface
self.interface_end_point_z = None # Locator of the z coordinate of the last point defining the interface
self.inlet = Entity.PhysicalGroup(name='Inlet', mesh=self.my_mesh)
self.twr = Entity.PhysicalGroup(name='Tube_Wall_R', mesh=self.my_mesh)
self.twl = Entity.PhysicalGroup(name='Tube_Wall_L', mesh=self.my_mesh)
self.bw = Entity.PhysicalGroup(name='Bottom_Wall', mesh=self.my_mesh)
self.lwr = Entity.PhysicalGroup(name='Lateral_Wall_R',
mesh=self.my_mesh)
self.tw = Entity.PhysicalGroup(name='Top_Wall', mesh=self.my_mesh)
self.lwl = Entity.PhysicalGroup(name='Lateral_Wall_L',
mesh=self.my_mesh)
self.interface = Entity.PhysicalGroup(name='Interface',
mesh=self.my_mesh)
self.vacuum = Entity.PhysicalGroup(name='Vacuum', mesh=self.my_mesh)
self.liquid = Entity.PhysicalGroup(name='Liquid', mesh=self.my_mesh)
def objective(x, sign=-1.0):
my_mesh = Mesh()
d = x[0]
a = x[1]
L = x[2]
if volume(x) > 10 * V_sk:
d1 = 0.05
elif volume(x) > 2 * V_sk:
d1 = 0.005
else:
d1 = 0.0005
filename = 'my_mesh'
# create points
p1 = Entity.Point([0., 0., 0., d1]) #fyrsti punktur neðri vinstri
# add point to mesh
my_mesh.addEntity(p1)
#create more points
p2 = Entity.Point([0., a / 2, 0., d1]) #2. punktur efri vinstri
my_mesh.addEntity(p2)
p3 = Entity.Point([t_veggur, a / 2, 0., d1]) #3. punktur efri hægri
my_mesh.addEntity(p3)
p4 = Entity.Point([t_veggur, (a - d) / 2 + d - a / 2, 0.,
d1]) #4. punktur niður frá efri hægri
my_mesh.addEntity(p4)
p5 = Entity.Point([t_veggur + L, (a - d) / 2 + d - a / 2, 0.,
d1]) #5.punktur endi á ribbu efri
my_mesh.addEntity(p5)
p6 = Entity.Point([t_veggur + L, 0., 0.,
d1]) #6. punktur endi á ribbu neðri
my_mesh.addEntity(p6)
# create curves
l1 = Entity.Curve([p1, p2]) #innri bein lína upp
l2 = Entity.Curve([p2, p3]) # efri hlið einangrun
l3 = Entity.Curve([p3, p4]) # ytri bein lína upp
l4 = Entity.Curve([p4, p5]) #ribba bein lína upp
l5 = Entity.Curve([p5, p6]) #ribba endi
l6 = Entity.Curve([p6, p1]) #ribba bein lína niðri
my_mesh.addEntities([l1, l2, l3, l4, l5, l6])
ll1 = Entity.CurveLoop([l1, l2, l3, l4, l5, l6], mesh=my_mesh)
s1 = Entity.PlaneSurface([ll1], mesh=my_mesh)
g1 = Entity.PhysicalGroup(name='innri')
g2 = Entity.PhysicalGroup(name='ytri')
g3 = Entity.PhysicalGroup(name='ribba')
g4 = Entity.PhysicalGroup(name='einangrun')
my_mesh.addEntities([g1, g2, g3, g4])
g1.addEntities([l1])
g2.addEntities([l3, l4, l5, l6])
g4.addEntities([l2])
g3.addEntities([s1])
# set max element size
#my_mesh.Options.Mesh.CharacteristicLengthMax = 0.1
# adding Coherence option
my_mesh.Coherence = True
# write the geofile
#os.system('rm .geo')
try:
my_mesh.writeGeo('{}.geo'.format(filename))
os.system('gmsh {}.geo -2 -o {}.msh'.format(filename, filename))
except:
return -0.1
#os.system('gmsh my_mesh.geo')
try:
xu, y, tri, T, V, q = axifem.axiHeatCond('{}.msh'.format(filename), \
{'ribba':k}, {'ytri':(h_utan,-h_utan*T_inf_utan),'innri':(h_innan,-h_innan*T_inf_innan),'einangrun':(0,0)})
print(sign * q['ytri'][1])
except:
return -0.1
return sign * q['ytri'][1]
#print(vte)
print('initial volume: {}'.format(V_sk))
#sol = differential_evolution(objective,bounds,constraints = (nlc1,nlc3,nlc4))
sol = minimize(objective, x0, method='COBYLA', constraints=cons)
a = sol['x'][1]
print(a)
#sol = minimize(objective,x0,method='SLSQP',options={'gtol': 1e-6, 'disp': True}, constraints = cons)
print(sol)
print('initial volume: {}'.format(V_sk))
x, y, tri, T, V, q = axifem.axiHeatCond('my_mesh.msh', \
{'ribba':k}, {'ytri':(h_utan,-h_utan*T_inf_utan),'innri':(h_innan,-h_innan*T_inf_innan),'einangrun':(0,0)})
my_mesh = Mesh()
# create points
p1 = Entity.Point([0., 0., 0., d1]) #fyrsti punktur neðri vinstri
# add point to mesh
my_mesh.addEntity(p1)
#create more points
p2 = Entity.Point([0., a / 2, 0., d1]) #2. punktur efri vinstri
my_mesh.addEntity(p2)
p3 = Entity.Point([t_veggur, a / 2, 0., d1]) #3. punktur efri hægri
my_mesh.addEntity(p3)
p4 = Entity.Point([t_veggur, 0., 0., d1]) #4. punktur niður frá efri hægri
my_mesh.addEntity(p4)
# create curves
l1 = Entity.Curve([p1, p2]) #innri bein lína upp
l2 = Entity.Curve([p2, p3]) # efri hlið einangrun
l3 = Entity.Curve([p3, p4]) # ytri bein lína upp
def objective(x, sign=-1.0):
print(x)
my_mesh = Mesh()
filename = 'my_mesh'
a = x[1]
L = x[2]
s = x[3:]
# create points
p1 = Entity.Point([0., -a / 2, 0., d1]) #fyrsti punktur neðri vinstri
p2 = Entity.Point([0., a - a / 2, 0., d1]) #2. punktur efri vinstri
p3 = Entity.Point([t_veggur, a - a / 2, 0., d1]) #3. punktur efri hægri
pe = []
pn = []
my_mesh.addEntities([p1, p2, p3])
for j in range(0, len(s)):
pe.append(
Entity.Point(
[t_veggur + L / (len(s) - 1) * j, a - s[j] - a / 2, 0., d1]))
pn.append(
Entity.Point([
t_veggur + L / (len(s) - 1) * (len(s) - j - 1),
s[len(s) - 1 - j] - a / 2, 0., d1
]))
my_mesh.addEntities(pe)
my_mesh.addEntities(pn)
p10 = Entity.Point([t_veggur, 0. - a / 2, 0.,
d1]) #síðasti punktur neðri hægri
my_mesh.addEntities([p10])
# create curves
l1 = Entity.Curve([p1, p2]) #innri bein lína upp
l2 = Entity.Curve([p2, p3]) # efri hlið einangrun
l3 = Entity.Curve([p3, pe[0]]) # ytri bein lína upp
le = []
ln = []
my_mesh.addEntities([l1, l2, l3])
for i in range(0, len(pe) - 1):
le.append(Entity.Curve([pe[i], pe[i + 1]]))
ln.append(Entity.Curve([pe[-1], pn[0]]))
for i in range(0, len(pn) - 1):
ln.append(Entity.Curve([pn[i], pn[i + 1]]))
l9 = Entity.Curve([pn[-1], p10])
l10 = Entity.Curve([p10, p1]) #einangrun neðri
my_mesh.addEntities(le)
my_mesh.addEntities(ln)
my_mesh.addEntities([l9])
my_mesh.addEntities([l10])
lines = []
lines.append(l1)
lines.append(l2)
lines.append(l3)
for line in le:
lines.append(line)
for line in ln:
lines.append(line)
lines.append(l9)
lines.append(l10)
ll1 = Entity.CurveLoop(lines, mesh=my_mesh)
s1 = Entity.PlaneSurface([ll1], mesh=my_mesh)
g1 = Entity.PhysicalGroup(name='innri')
g2 = Entity.PhysicalGroup(name='ytri')
g3 = Entity.PhysicalGroup(name='ribba')
g4 = Entity.PhysicalGroup(name='einangrun')
my_mesh.addEntities([g1, g2, g3, g4])
g1.addEntities([l1])
g2.addEntities([l3])
g2.addEntities(le)
g2.addEntities(ln)
g2.addEntities([l9])
g4.addEntities([l2, l10])
g3.addEntities([s1])
# set max element size
#my_mesh.Options.Mesh.CharacteristicLengthMax = 0.1
# adding Coherence option
my_mesh.Coherence = True
# write the geofile
#os.system('rm .geo')
try:
my_mesh.writeGeo('{}.geo'.format(filename))
os.system('gmsh {}.geo -2 -o {}.msh'.format(filename, filename))
except:
return -0.5
#os.system('gmsh my_mesh.geo')
try:
xu, y, tri, T, V, q = axifem.axiHeatCond('{}.msh'.format(filename), \
{'ribba':k}, {'ytri':(h_utan,-h_utan*T_inf_utan),'innri':(h_innan,-h_innan*T_inf_innan),'einangrun':(0,0)})
print(sign * q['ytri'][1])
except:
return -0.5
return sign * q['ytri'][1]
def geometry_generator(self,
interface_fun=None,
interface_fun_r=None,
interface_fun_z=None,
factor=10,
**kwargs):
"""
Generate the geometry given some parameters. The generation of the geometry has been created in such a way to
let the user introduce any shape of the interface by introducing the corresponding function(s). The process of
creating the interface, works as follows:
1. Create the points defining the shape of the domain. To establish a common way of defining these points
independently on how the user introduces the r array or the independent parameter array, all the points will
be defined counterclockwise. In this way, we can create a general way of defining the domain.\n
2. Create the curves and assign it a physical curve. Basically, physical curve = FEniCS boundary. By
defining these physical groups, a file wil be generated by the mesh creator so that FEniCS will be able to
recognize these boundaries, which will then be identified by the physical group id contained in the .geo
file.\n
3. Create curveloops. This step is crucial for the each of the subdomains' definitions. A curveloop is a set
of curves that enclose a subdomain. It must be a closed loop and it should be defined following a logical
direction. Notice that a badly defined curveloop will not be notified here. However, one must always check
the .geo file within GMSH to make sure all the steps above have been successful.\n
This generator has been designed by taking into account that the geometry is non-dimensionalized by the radius
of the capillary tube.\n
Args:
interface_fun: string. Expression containing the equation y(x) for the interface. In this case, there is an
unique expression for the interface shape. This expression will be used when none of the other options are
used (interface_fun_r and interface_fun_z must be None). Otherwise, an error will rise.
interface_fun_r: Expression containing the equation r(s) which will create the radial coordinates of the
interface. It should only depend on a single parameter.
interface_fun_z: Expression containing the equation z(s) which will create the z coordinates of the
interface. It should only depend on a single parameter.
factor: Ratio between the top wall z coordinate and bottom wall coord. Optional, default is 10.
**kwargs:
filename: String containing the name of the generated geometry (with the extension).
number_points: Number of points that will define the shape of the interface. This kwarg is necessary
if the user does not input an r or independent parameter array. Default is 300.
angle_unit: 'degrees' of 'radians'. If no angle is present, ignore this kwarg. Default is radians.
r: Array containing the radial coords of the points defining the interface. Required if
interface_fun is used.
independent_param: Array containing the values of the independent parameter. Required if
interface_fun_r and interface_fun_z are used.
Returns:
"""
# Define default values for the kwargs.
kwargs.setdefault('filename', 'GeneratedGeometry.geo')
kwargs.setdefault('number_points', 300)
kwargs.setdefault('angle_unit', 'radians')
# Do some checks before proceeding.
if interface_fun is not None and kwargs.get('r') is None:
print(
'** WARNING: No array for the r coordinates was given. Assuming equidistant points based on number of points selected.',
flush=True)
kwargs.setdefault('r',
np.linspace(0, 1, kwargs.get('number_points')))
elif interface_fun is not None and interface_fun_r is not None and interface_fun_z is not None:
raise NotImplementedError(
'Incompatible functions were introduced.')
elif interface_fun is not None and interface_fun_r is not None and interface_fun_z is None:
raise NotImplementedError(
'Incompatible functions were introduced.')
elif interface_fun is not None and interface_fun_r is None and interface_fun_z is not None:
raise NotImplementedError(
'Incompatible functions were introduced.')
if interface_fun_r is not None and interface_fun_z is not None and kwargs.get(
'independent_param') is None:
print(
'** WARNING: No array for the independent parameter was given. Assuming equidistant parameters based on number of points selected.',
flush=True)
kwargs.setdefault('independent_param',
np.linspace(0, 1, kwargs.get('number_points')))
self.filename = kwargs.get('filename')
# Initialize the string parser class.
nsp = NumericStringParser()
# Save the original functions in the self object.
self.interface_fun = interface_fun
self.interface_fun_r = interface_fun_r
self.interface_fun_z = interface_fun_z
# Detect which is the independent variable in the string.
if isinstance(self.interface_fun, str) or isinstance(self.interface_fun_r, str) or \
isinstance(self.interface_fun_z, str):
if self.interface_fun is not None: # The user has introduced a function of the form z = f(r).
ind_var = GMSHInterface.get_independent_var_from_equation(
interface_fun)
if kwargs.get('angle_unit') == 'degrees':
self.interface_fun = GMSHInterface.angle_handler(
self.interface_fun)
elif self.interface_fun_z is not None and self.interface_fun_r is not None:
ind_var_r = GMSHInterface.get_independent_var_from_equation(
interface_fun_r)
ind_var_z = GMSHInterface.get_independent_var_from_equation(
interface_fun_z)
assert ind_var_r == ind_var_z, 'Independent parameters for r and z must be the same.'
if kwargs.get('angle_unit') == 'degrees':
self.interface_fun_r = GMSHInterface.angle_handler(
self.interface_fun_r)
self.interface_fun_z = GMSHInterface.angle_handler(
self.interface_fun_z)
else:
pass # We assume it is an already evaluable function.
# %% STEP 1: DEFINE THE POINTS OF THE GEOMETRY.
r_arr = np.array([])
z_arr = np.array([])
# MENISCUS POINTS DEFINITION.
if interface_fun is not None:
r_arr = np.sort(kwargs.get(
'r'))[::-1] # Sort the r array from higher to lower.
for r_val in r_arr:
self.key = 'p' + str(self.point_num)
if isinstance(interface_fun, str):
interface_fun = self.interface_fun # Necessary because degrees may have changed to radians.
interface_fun = GMSHInterface.replace_ind_var(
interface_fun, ind_var, str(r_val))
z_val = nsp.eval(interface_fun)
else:
try: # In case the user introduces a Scipy solution object, we need to specify which sol to use.
z_val = interface_fun(r_val)[0]
except TypeError: # In case the user introduces a standard function.
z_val = interface_fun(r_val)
if r_val != 1:
self.p_dict[self.key] = Entity.Point([r_val, z_val, 0],
mesh=self.my_mesh)
self.interface_points[self.key] = Entity.Point(
[r_val, z_val, 0], mesh=self.my_mesh)
self.point_num += 1
z_arr = np.append(z_arr, z_val)
r_arr = r_arr[1:]
elif interface_fun_r is not None and interface_fun_z is not None:
for s in kwargs.get('independent_param'):
interface_fun_r = self.interface_fun_r
interface_fun_z = self.interface_fun_z
self.key = 'p' + str(self.point_num)
# Replace the independent variables with the corresponding values.
if isinstance(interface_fun_r, str) and isinstance(
interface_fun_z, str):
interface_fun_r = GMSHInterface.replace_ind_var(
interface_fun_r, ind_var_r, str(s))
interface_fun_z = GMSHInterface.replace_ind_var(
interface_fun_z, ind_var_z, str(s))
r = nsp.eval(interface_fun_r)
z = nsp.eval(interface_fun_z)
else:
r = interface_fun_r(s)
z = interface_fun_z(s)
if r != 1:
r_arr = np.append(r_arr, r)
z_arr = np.append(z_arr, z)
self.p_dict[self.key] = Entity.Point([r, z, 0],
mesh=self.my_mesh)
self.interface_points[self.key] = Entity.Point(
[r, z, 0], mesh=self.my_mesh)
self.point_num += 1
self.list_points_interface = list(self.interface_points.values())[::-1]
self.interface_end_point = self.p_dict[self.key]
self.interface_end_point_z = self.interface_end_point.xyz[1]
self.key = 'p' + str(self.point_num)
# LATERAL WALL LEFT POINTS DEFINITION.
# Create an adaptive point generation based on the density of points of the interface.
self.adaptive_refinement_tip()
self.p_dict[self.key] = Entity.Point([0, factor, 0], mesh=self.my_mesh)
self.point_num += 1
self.key = 'p' + str(self.point_num)
# TOP WALL POINTS DEFINITION.
self.p_dict[self.key] = Entity.Point([factor, factor, 0],
mesh=self.my_mesh)
self.point_num += 1
self.key = 'p' + str(self.point_num)
# LATERAL WALL RIGHT POINTS DEFINITION.
self.p_dict[self.key] = Entity.Point([factor, 0, 0], mesh=self.my_mesh)
self.point_num += 1
self.key = 'p' + str(self.point_num)
# BOTTOM WALL POINTS DEFINITION.
# Create the knee point.
self.p_dict[self.key] = Entity.Point([1, 0, 0], mesh=self.my_mesh)
knee_point = self.p_dict[self.key]
self.point_num += 1
self.key = 'p' + str(self.point_num)
# TUBE WALL RIGHT POINTS DEFINITION.
self.p_dict[self.key] = Entity.Point([1, -factor, 0],
mesh=self.my_mesh)
self.point_num += 1
self.key = 'p' + str(self.point_num)
# INLET POINTS DEFINITION.
self.p_dict[self.key] = Entity.Point([0, -factor, 0],
mesh=self.my_mesh)
self.point_num += 1
self.key = 'p' + str(self.point_num)
# TUBE WALL LEFT POINTS DEFINITION.
# Create an adaptive point generation based on the density of points of the interface.
self.adaptive_refinement_tip()
# Create the curves.
p_list = list(self.p_dict)
for i in np.arange(0, len(p_list) - 1):
curve = Entity.Curve(
[self.p_dict[p_list[i]], self.p_dict[p_list[i + 1]]],
mesh=self.my_mesh)
if self.p_dict[p_list[i]].xyz[1] in z_arr and self.p_dict[p_list[
i + 1]].xyz[1] in z_arr:
self.interface.addEntity(curve)
elif self.p_dict[p_list[i]].xyz[0] == 0 and self.p_dict[p_list[
i + 1]].xyz[0] == 0 and self.p_dict[
p_list[i]].xyz[1] >= self.interface_end_point_z:
self.lwl.addEntity(curve)
elif self.p_dict[p_list[i]].xyz[1] == 0 and self.p_dict[p_list[
i + 1]].xyz[1] == 0:
self.bw.addEntity(curve)
elif self.p_dict[p_list[i]].xyz[1] == factor and self.p_dict[
p_list[i + 1]].xyz[1] == factor:
self.tw.addEntity(curve)
elif self.p_dict[p_list[i]].xyz[0] == factor and self.p_dict[
p_list[i + 1]].xyz[0] == factor:
self.lwr.addEntity(curve)
elif self.p_dict[p_list[i]].xyz[0] == 1 and self.p_dict[p_list[
i + 1]].xyz[0] == 1:
self.twr.addEntity(curve)
elif self.p_dict[p_list[i]].xyz[1] == -factor and self.p_dict[
p_list[i + 1]].xyz[1] == -factor:
self.inlet.addEntity(curve)
elif self.p_dict[p_list[i]].xyz[0] == 0 and self.p_dict[p_list[
i + 1]].xyz[0] == 0 and self.p_dict[
p_list[i]].xyz[1] <= self.interface_end_point_z:
self.twl.addEntity(curve)
# Lastly, join remaining points.
add_int_curve = Entity.Curve([knee_point, self.p_dict[p_list[0]]],
mesh=self.my_mesh)
self.interface.addEntity(add_int_curve)
twl_l = Entity.Curve(
[self.p_dict[p_list[-1]], self.interface_end_point],
mesh=self.my_mesh)
self.twl.addEntity(twl_l)
# Create the subdomains physical groups.
vacuum_curveloop = Entity.CurveLoop(
list(self.lwl.curves.values()) + list(self.tw.curves.values()) +
list(self.lwr.curves.values()) + list(self.bw.curves.values()) +
[add_int_curve] + list(self.interface.curves.values())[:-1],
mesh=self.my_mesh)
vacuum_surf = Entity.PlaneSurface([vacuum_curveloop],
mesh=self.my_mesh)
self.vacuum.addEntity(vacuum_surf)
liquid_curveloop = Entity.CurveLoop(
list(self.twr.curves.values()) + list(self.inlet.curves.values()) +
list(self.twl.curves.values()) +
list(self.interface.curves.values())[:-1][::-1] + [add_int_curve],
mesh=self.my_mesh)
liquid_surf = Entity.PlaneSurface([liquid_curveloop],
mesh=self.my_mesh)
self.liquid.addEntity(liquid_surf)
def objective(x, sign=-1.0):
#x = [d,a,L,n,t,r]
my_mesh = Mesh()
filename = 'my_mesh'
d = x[0]
a = x[1]
L = x[2]
n = int(x[3])
t = x[4]
r = x[5]
dx = x[6]
if volume(x) > 10 * V_sk:
d1 = 0.05
elif volume(x) > 2 * V_sk:
d1 = 0.005
else:
d1 = 0.0005
# create points
p1 = Entity.Point([0., 0., 0., d1]) #fyrsti punktur neðri vinstri
p2 = Entity.Point([0., a / 2, 0., d1]) #2. punktur efri vinstri
p3 = Entity.Point([t_veggur, a / 2, 0., d1]) #3. punktur efri hægri
pe = []
my_mesh.addEntities([p1, p2, p3])
pe.append(Entity.Point([t_veggur, d / 2, 0., d1])) #fyrsti punktur á ribbu
for i in range(0, n):
delta_x = dx + i * (dx + t)
pe.append(Entity.Point([t_veggur + delta_x, d / 2, 0., d1]))
pe.append(Entity.Point([t_veggur + delta_x, r / 2, 0., d1]))
pe.append(Entity.Point([t_veggur + delta_x + t, r / 2, 0., d1]))
pe.append(Entity.Point([t_veggur + delta_x + t, d / 2, 0., d1]))
my_mesh.addEntities(pe)
p10 = Entity.Point([t_veggur + dx * n + t * n, 0., 0.,
d1]) #síðasti punktur neðri hægri
my_mesh.addEntities([p10])
# create curves
l1 = Entity.Curve([p1, p2]) #innri bein lína upp
l2 = Entity.Curve([p2, p3]) # efri hlið einangrun
l3 = Entity.Curve([p3, pe[0]]) # ytri bein lína upp
le = []
my_mesh.addEntities([l1, l2, l3])
for i in range(0, len(pe) - 1):
le.append(Entity.Curve([pe[i], pe[i + 1]]))
le.append(Entity.Curve([pe[-1], p10])) #klára ferð niður
l9 = Entity.Curve([p10, p1]) #lína niðri
my_mesh.addEntities(le)
my_mesh.addEntities([l9])
lines = []
lines.append(l1)
lines.append(l2)
lines.append(l3)
for line in le:
lines.append(line)
lines.append(l9)
ll1 = Entity.CurveLoop(lines, mesh=my_mesh)
s1 = Entity.PlaneSurface([ll1], mesh=my_mesh)
g1 = Entity.PhysicalGroup(name='innri')
g2 = Entity.PhysicalGroup(name='ytri')
g3 = Entity.PhysicalGroup(name='ribba')
g4 = Entity.PhysicalGroup(name='einangrun')
my_mesh.addEntities([g1, g2, g3, g4])
g1.addEntities([l1])
g4.addEntities([l2])
g2.addEntities([l3])
for line in le:
g2.addEntities([line])
g3.addEntities([s1])
# set max element size
#my_mesh.Options.Mesh.CharacteristicLengthMax = 0.1
# adding Coherence option
my_mesh.Coherence = True
# write the geofile
#os.system('rm .geo')
try:
my_mesh.writeGeo('{}.geo'.format(filename))
os.system('gmsh {}.geo -2 -o {}.msh'.format(filename, filename))
except:
return min(-0.5 * (dx + t) * n, -0.5 * random())
#os.system('gmsh my_mesh.geo')
try:
xu, y, tri, T, V, q = axifem.axiHeatCond('{}.msh'.format(filename), \
{'ribba':k}, {'ytri':(h_utan,-h_utan*T_inf_utan),'innri':(h_innan,-h_innan*T_inf_innan),'einangrun':(0,0)})
print(sign * q['ytri'][1])
if sign * q['ytri'][1] != sign * q['ytri'][1]:
return min(-0.5 * (dx + t) * n, -0.5 * random())
except:
return min(-0.5 * (dx + t) * n, -0.5 * random())
return sign * q['ytri'][1]
d = 0.003
a = 0.01
L = 0.01
d1 = 0.01
V_sk = np.pi * (a / 2)**2 * t_veggur + np.pi * (d / 2)**2 * L
print(V_sk)
res = ()
for i in range(5, 13):
d1 = 1.0 / (2**(i + 1))
# create Mesh class instance
my_mesh = Mesh()
# create points
p1 = Entity.Point([0., 0., 0., d1]) #fyrsti punktur neðri vinstri
# add point to mesh
my_mesh.addEntity(p1)
#create more points
p2 = Entity.Point([0., a / 2, 0., d1]) #2. punktur efri vinstri
my_mesh.addEntity(p2)
p3 = Entity.Point([t_veggur, a / 2, 0., d1]) #3. punktur efri hægri
my_mesh.addEntity(p3)
p4 = Entity.Point([t_veggur, (a - d) / 2 + d - a / 2, 0.,
d1]) #4. punktur niður frá efri hægri
my_mesh.addEntity(p4)
p5 = Entity.Point([t_veggur + L, (a - d) / 2 + d - a / 2, 0.,
d1]) #5.punktur endi á ribbu efri
my_mesh.addEntity(p5)
def _mesh_geometry(
self,
x_camber: np.ndarray,
upper_curve: np.ndarray,
lower_curve: np.ndarray,
) -> Mesh:
"""
Function computing a triangulation of the airfoil domain.
:params:
x_camber: x-coeficients of points used in the discretization.
upper_curve: y-coefficients of the upper profile of the sampled airfoil.
The discretization is evaluated at x_camber points.
lower_curve: y-coefficients of the lower profile of the sampled airfoil.
The discretization is evaluated at x_camber points.
:returns:
mash: airfoil's triangulation computed using GMSH package.
"""
mesh = Mesh()
top_left = Entity.Point([*self.top_left_corner, 0])
top_right = Entity.Point(
[self.bottom_right_corner[0], self.top_left_corner[1], 0])
bottom_left = Entity.Point(
[self.top_left_corner[0], self.bottom_right_corner[1], 0])
bottom_right = Entity.Point([*self.bottom_right_corner, 0])
# Add domain's corners to the geometry
mesh.addEntity(top_left)
mesh.addEntity(top_right)
mesh.addEntity(bottom_left)
mesh.addEntity(bottom_right)
# Define the outer boundary
top_boundary = Entity.Curve([top_left, top_right])
right_boundary = Entity.Curve([top_right, bottom_right])
bottom_boundary = Entity.Curve([bottom_right, bottom_left])
left_boundary = Entity.Curve([bottom_left, top_left])
domain_outer_boundary = [
top_boundary,
right_boundary,
bottom_boundary,
left_boundary,
]
mesh.addEntities(domain_outer_boundary)
# Add airfoil points
airfoil_points = []
for x, y in zip(x_camber, upper_curve):
point = Entity.Point([x, y, 0])
airfoil_points.append(point)
mesh.addEntity(point)
for x, y in zip(x_camber[::-1][1:-1], lower_curve[::-1][1:-1]):
point = Entity.Point([x, y, 0])
airfoil_points.append(point)
mesh.addEntity(point)
# Discretize the airfoil profile
intervals = []
for i in range(len(airfoil_points) - 1):
point1 = airfoil_points[i]
point2 = airfoil_points[i + 1]
interval = Entity.Curve([point1, point2])
intervals.append(interval)
# Close the profile using endpoints
point1 = airfoil_points[-1]
point2 = airfoil_points[0]
interval = Entity.Curve([point1, point2])
intervals.append(interval)
mesh.addEntities(intervals)
field_boundary_layer = Field.BoundaryLayer(mesh=mesh)
# Setting boundary layer parameters
field_boundary_layer.EdgesList = intervals
field_boundary_layer.AnisoMax = 1.0
field_boundary_layer.hfar = 0.2
field_boundary_layer.hwall_n = 0.001
field_boundary_layer.thickness = 0.05
field_boundary_layer.ratio = 1.1
field_boundary_layer.Quads = 1
field_boundary_layer.IntersectMetrics = 0
mesh.BoundaryLayerField = field_boundary_layer
# set max element size
mesh.Options.Mesh.CharacteristicLengthMax = 0.3
return mesh
def objective(x, sign=-1.0):
time.sleep(0.1)
my_mesh = Mesh()
filename = 'my_mesh'
d = x[0]
a = x[1]
L = x[2]
s1 = x[3]
s2 = x[4]
s3 = x[5]
# create points
p1 = Entity.Point([0., -a / 2, 0., d1]) #fyrsti punktur neðri vinstri
p2 = Entity.Point([0., a - a / 2, 0., d1]) #2. punktur efri vinstri
p3 = Entity.Point([t_veggur, a - a / 2, 0., d1]) #3. punktur efri hægri
p4 = Entity.Point([t_veggur, a - s1 - a / 2, 0., d1]) #fyrsti ribbup ef
p5 = Entity.Point([t_veggur + L / 2, a - s2 - a / 2, 0.,
d1]) # 2 ribbup ef
p6 = Entity.Point([t_veggur + L, s3 - a / 2, 0., d1]) #síðast ribbup ef
p7 = Entity.Point([t_veggur + L, s3 - a / 2, 0., d1]) #síðast ribbup ne
p8 = Entity.Point([t_veggur + L / 2, s2 - a / 2, 0, d1]) #2. ribbup ne
p9 = Entity.Point([t_veggur, s1 - a / 2, 0., d1]) #1. ribbup ef
p10 = Entity.Point([t_veggur, 0. - a / 2, 0.,
d1]) #síðasti punktur neðri hægri
my_mesh.addEntities([p1, p2, p3, p4, p5, p6, p7, p8, p9, p10])
# create curves
l1 = Entity.Curve([p1, p2]) #innri bein lína upp
l2 = Entity.Curve([p2, p3]) # efri hlið einangrun
l3 = Entity.Curve([p3, p4]) # ytri bein lína upp
l4 = Entity.Curve([p4, p5]) #ribba 1. 2. p e
l5 = Entity.Curve([p5, p6]) #ribba 2. 3. p e
l6 = Entity.Curve([p6, p7]) #ribba endi
l7 = Entity.Curve([p7, p8]) #ribba 3. 2. n
l8 = Entity.Curve([p8, p9]) #ribba 2. 1. n
l9 = Entity.Curve([p9, p10]) #neðri bein lína upp
l10 = Entity.Curve([p10, p1]) #einangrun neðri
my_mesh.addEntities([l1, l2, l3, l4, l5, l6, l7, l8, l9, l10])
ll1 = Entity.CurveLoop([l1, l2, l3, l4, l5, l6, l7, l8, l9, l10],
mesh=my_mesh)
s1 = Entity.PlaneSurface([ll1], mesh=my_mesh)
g1 = Entity.PhysicalGroup(name='innri')
g2 = Entity.PhysicalGroup(name='ytri')
g3 = Entity.PhysicalGroup(name='ribba')
g4 = Entity.PhysicalGroup(name='einangrun')
my_mesh.addEntities([g1, g2, g3, g4])
g1.addEntities([l1])
g2.addEntities([l3, l4, l5, l6, l7, l8, l9])
g4.addEntities([l2, l10])
g3.addEntities([s1])
# set max element size
#my_mesh.Options.Mesh.CharacteristicLengthMax = 0.1
# adding Coherence option
my_mesh.Coherence = True
# write the geofile
#os.system('rm .geo')
my_mesh.writeGeo('{}.geo'.format(filename))
os.system('gmsh {}.geo -2 -o {}.msh'.format(filename, filename))
#os.system('gmsh my_mesh.geo')
try:
xu, y, tri, T, V, q = axifem.axiHeatCond('{}.msh'.format(filename), \
{'ribba':k}, {'ytri':(h_utan,-h_utan*T_inf_utan),'innri':(h_innan,-h_innan*T_inf_innan),'einangrun':(0,0)})
print(sign * q['ytri'][1])
except:
return 0
return sign * q['ytri'][1]