def show_pressure(self):
import paraBEM
from paraBEM.pan2d import DirichletDoublet0Source0Case2
# 1. get the panels from the airfoil
self.current_airfoil.apply_splines()
coords = self.current_airfoil.data[:-1]
pans = []
vertices = []
vertices = [paraBEM.PanelVector2(*i) for i in coords]
vertices[0].wake_vertex = True
for i, coord in enumerate(coords):
j = (i + 1 if (i + 1) < len(coords) else 0)
pan = paraBEM.Panel2([vertices[i], vertices[j]])
pans.append(pan)
# 2. compute pressure
case = DirichletDoublet0Source0Case2(pans)
alpha = np.deg2rad(self.Qalpha.value())
case.v_inf = paraBEM.Vector2(np.cos(alpha), np.sin(alpha))
case.run()
for pan in pans:
p0 = pan.center
p1 = p0 + pan.n * pan.cp * 0.03
l = [[*p0, 0.], [*p1, 0.]] # adding z-value
self.pressure_sep += pp.Line(l).object
return True
def Vector(array, *args):
if args:
return Vector([array] + list(args))
if len(array) == 2:
return paraBEM.Vector2(*array)
elif len(array) == 3:
return paraBEM.Vector3(*array)
else:
raise AttributeError(
"array has too many values, 2d and 3d is supported")
vertices[0].wake_vertex = True
panels = [
Panel2([vertices[i], vertices[i + 1]]) for i in range(len(vertices[:-1]))
]
panels.append(Panel2([vertices[-1], vertices[0]]))
case = Case(panels)
case.v_inf = Vector2(np.cos(alpha), np.sin(alpha))
case.run()
nx = 500
ny = 500
space_x = np.linspace(-3, 7, nx)
space_y = np.linspace(-2, 2, ny)
vec = lambda x: paraBEM.Vector2(x[0], x[1])
vec3 = lambda x: [x[0], x[1], 0]
grid = [[x, y, 0] for y in space_y for x in space_x]
_grid = list(map(vec, grid))
velocity = list(map(vec3, list(map(case.off_body_velocity, _grid))))
vel1 = [(i[0]**2 + i[1]**2)**(0.5) for i in velocity]
pot = list(map(case.off_body_potential, _grid))
with open(check_path("results/coordinates_not_aligned/field.vtk"),
"w") as _file:
writer = VtkWriter()
writer.structed_grid(_file, "airfoil", [nx, ny, 1])
writer.points(_file, grid)
writer.data(_file,
velocity,
def v_inf_deg_range2(v_inf, alpha0, alpha1, num=10):
phi = np.linspace(np.deg2rad(alpha0), np.deg2rad(alpha1), num)
return [abs(v_inf) * paraBEM.Vector2(np.cos(p), np.sin(p)) for p in phi]
import numpy as np
import paraBEM
from paraBEM.pan2d import vortex_2, vortex_2_v
from paraBEM.vtk_export import VtkWriter
from paraBEM.utils import check_path
source = paraBEM.Vector2(0, 0)
direction = paraBEM.Vector2(1, 0)
n = 20
a = np.linspace(-10, 10, n).tolist()
b = [paraBEM.Vector2(i, j) for i in a for j in a]
vel = [vortex_2_v(target, source) for target in b]
pot = [vortex_2(target, source, direction) for target in b]
writer = VtkWriter()
with open(check_path("results/vortex_2_field.vtk"), "w") as _file:
writer.structed_grid(_file, "vortex", [n, n, 1])
writer.points(_file, b)
writer.data(_file,
vel,
name="velocity",
_type="VECTORS",
data_type="POINT_DATA")
writer.data(_file,
pot,
name="potential",
_type="SCALARS",
data_type="POINT_DATA")
import numpy as np
import paraBEM
from paraBEM.pan2d import doublet_2_0, doublet_2_0_v
v1 = paraBEM.PanelVector2(-1, 0)
v2 = paraBEM.PanelVector2(1, 0)
p = paraBEM.Panel2([v1, v2])
v = paraBEM.Vector2(0, 0)
print("doublet influence on panel center:")
print(doublet_2_0_v(v, p).y)
print("")
y = 3
pos = [[x, y] for x in np.linspace(-2, 2, 100)]
_pos = map(paraBEM.Vector2, pos)
vals = [doublet_2_0(i, p) for i in _pos]
print("x, y, doublet_value")
print("==============================\n")
print(np.array([[pos[0], pos[1], vals[i]] for i, pos in enumerate(pos)]))
import paraBEM
from paraBEM.pan2d import DirichletDoublet0Source0Case2 as Case
from paraBEM.airfoil import Airfoil
from paraBEM.utils import check_path
a = Airfoil.trefftz_kutta(-0.1 + 0.01j, np.deg2rad(2), 51)
alpha_list = np.deg2rad(np.linspace(-15, 30, 30))
cl = []
cd = []
cm = []
xcp = []
for alpha in alpha_list:
case = Case(a.panels)
case.v_inf = paraBEM.Vector2(np.cos(alpha), np.sin(alpha))
case.mom_ref_point = paraBEM.Vector2(-0, -3)
case.run()
cl.append(case.cl)
cd.append(case.force.dot(case.v_inf) * 10)
cm.append(case.cm)
# xcp.append(case.center_of_pressure.x)
del (case)
plt.plot(cl, alpha_list, color="black", linestyle="-", label="cl")
plt.plot(cm, alpha_list, color="black", dashes=[8, 4, 2, 4, 2, 4], label="cm")
# plt.plot(xcp, alpha_list, color="black", linestyle="dashed", label="x(cm=0)")
plt.legend()
plt.plot(*zip(*a.coordinates), marker="*")
plt.grid(True)
# plt.axes().set_aspect("equal", "datalim")
import paraBEM from paraBEM.pan2d import DirichletDoublet0Case2 as Case from paraBEM.airfoil import Airfoil airfoil = Airfoil.vandevooren(0.5) airfoil.numpoints = 40 case = Case(airfoil.panels) case.v_inf = paraBEM.Vector2(1, 0.1) case.run() print(airfoil.coordinates)
import paraBEM
from paraBEM.pan2d import doublet_2_0, source_2_0, doublet_2_0_v, source_2_0_v, doublet_2_1, doublet_2_1_v
from paraBEM.vtk_export import VtkWriter
import numpy as np
from paraBEM.utils import check_path
v1 = paraBEM.PanelVector2(-2, 0)
v2 = paraBEM.PanelVector2(2, 0)
panel = paraBEM.Panel2([v1, v2])
n = 500
space = np.linspace(-5, 5, n)
grid = [paraBEM.Vector2([x, y]) for y in space for x in space]
dub_vals = [doublet_2_0(target, panel) for target in grid]
dub_vals_lin_1 = [doublet_2_1(target, panel, True) for target in grid]
dub_vals_lin_2 = [doublet_2_1(target, panel, False) for target in grid]
src_vals = [source_2_0(target, panel) for target in grid]
dublinv1_vals = [doublet_2_1_v(target, panel, True) for target in grid]
dublinv2_vals = [doublet_2_1_v(target, panel, False) for target in grid]
dubv_vals = [doublet_2_0_v(target, panel) for target in grid]
srcv_vals = [source_2_0_v(target, panel) for target in grid]
writer = VtkWriter()
with open(check_path("results/element_2.vtk"), "w") as _file:
writer.structed_grid(_file, "element_2", [n, n, 1])
writer.points(_file, grid)
writer.data(_file, dub_vals, name="doublet", _type="SCALARS", data_type="POINT_DATA")
writer.data(_file, dub_vals_lin_1, name="doublet_lin_1", _type="SCALARS", data_type="POINT_DATA")
writer.data(_file, dub_vals_lin_2, name="doublet_lin_2", _type="SCALARS", data_type="POINT_DATA")
from paraBEM.pan2d import doublet_2_1
import paraBEM
import numpy as np
v1 = paraBEM.PanelVector2(-1, 0)
v2 = paraBEM.PanelVector2(1, 0)
panel = paraBEM.Panel2([v2, v1])
vals = ([
doublet_2_1(paraBEM.Vector2(x, 0), panel, True)
for x in np.linspace(-2, 2, 20)
])
print(vals)
import numpy
import paraBEM
from paraBEM.pan2d import doublet_2_0, source_2_0, source_2_0_v
from paraBEM.vtk_export import VtkWriter
from paraBEM.utils import check_path
a = list(map(paraBEM.PanelVector2, [[-1, -1], [-1, 1]]))
b = list(map(paraBEM.PanelVector2, [[1, -1], [1, 1]]))
pan_a = paraBEM.Panel2(a)
pan_b = paraBEM.Panel2(b)
n = 100
space = numpy.linspace(-2, 2, n)
grid = [paraBEM.Vector2(x, y) for y in space for x in space]
pot = [source_2_0(v, pan_a) - source_2_0(v, pan_b) for v in grid]
vel = [source_2_0_v(v, pan_a) - source_2_0_v(v, pan_b) for v in grid]
writer = VtkWriter()
with open(check_path("results/parallel_flow.vtk"), "w") as _file:
writer.structed_grid(_file, "doublet_2", [n, n, 1])
writer.points(_file, grid)
writer.data(_file,
pot,
name="potential",
_type="SCALARS",
data_type="POINT_DATA")
writer.data(_file,
vel,
name="velocity",
from paraBEM.pan2d import DirichletDoublet1Case2 as Case
# geometry
airfoil = Airfoil.trefftz_kutta(-0.1 + 0.0j, np.deg2rad(30))
airfoil.numpoints = 50
points = [paraBEM.PanelVector2(*i) for i in airfoil.coordinates[:-1]]
points[0].wake_vertex = True
panels = [
paraBEM.Panel2([coord, points[i + 1]])
for i, coord in enumerate(points[:-1])
]
panels.append(paraBEM.Panel2([points[-1], points[0]]))
# panelmethode
case = Case(panels)
case.v_inf = paraBEM.Vector2(1, 0.3)
case.run()
# plt.plot(np.array(case.matrix.values).T)
# # plt.show()
nx = 200
ny = 200
space_x = np.linspace(-0.2, 1.5, nx)
space_y = np.linspace(-0.5, 0.5, ny)
grid = [paraBEM.Vector2(x, y) for y in space_y for x in space_x]
velocity = list(map(case.off_body_velocity, grid))
pot = list(map(case.off_body_potential, grid))
with open(check_path("results/airfoil_2d_linear/field.vtk"), "w") as _file:
writer = VtkWriter()
import paraBEM from paraBEM.pan2d import doublet_2, doublet_2_v t = paraBEM.Vector2(2, 2) s = paraBEM.Vector2(0, 0) d = paraBEM.Vector2(1, 0) print(doublet_2_v(t, s, d))
airfoil = Airfoil.vandevooren(tau=np.deg2rad(20), epsilon=0.05)
airfoil.numpoints = 150
alpha = np.deg2rad(10)
# panelmethode
case = Case(airfoil.panels)
case.v_inf = Vector2(np.cos(alpha), np.sin(alpha))
case.run()
nx = 200
ny = 200
space_x = np.linspace(-1, 2, nx)
space_y = np.linspace(-0.2, 0.2, ny)
vec = lambda x: paraBEM.Vector2(x[0], x[1])
vec3 = lambda x: [x[0], x[1], 0]
grid = [paraBEM.Vector2(x, y) for y in space_y for x in space_x]
velocity = list(map(vec3, map(case.off_body_velocity, grid)))
vel1 = [(i[0]**2 + i[1]**2)**(0.5) for i in velocity]
pot = list(map(case.off_body_potential, grid))
with open(check_path("results/neumann/field.vtk"), "w") as _file:
writer = VtkWriter()
writer.structed_grid(_file, "airfoil", [nx, ny, 1])
writer.points(_file, grid)
writer.data(_file, velocity, name="velocity", _type="VECTORS", data_type="POINT_DATA")
writer.data(_file, pot, name="pot", _type="SCALARS", data_type="POINT_DATA")
writer.data(_file, vel1, name="vel", _type="SCALARS", data_type="POINT_DATA")
T_boundary = [0, 0, 0, 0, 1, 1, 1, 1]
mat = np.zeros([8, 8])
rhs = np.zeros([8])
for i, panel_i in enumerate(panels):
rhs[i] = T_boundary[i]
for j, panel_j in enumerate(panels):
mat[i, j] = -source_2_0(panel_i.center, panel_j)
mat[i, j] += doublet_2_0(panel_i.center, panel_j) * R
sol = np.linalg.solve(mat, rhs)
nx = 300
ny = 300
x_grid = np.linspace(-3, 3, nx)
y_grid = np.linspace(-3, 3, ny)
grid = [paraBEM.Vector2(x, y) for y in y_grid for x in x_grid]
t_list = []
for point in grid:
t = 0
for i, panel_i in enumerate(panels):
t -= source_2_0(point, panel_i) * sol[i]
t += doublet_2_0(point, panel_i) * sol[i] * R
t_list.append(t)
q_list = []
for point in grid:
q = paraBEM.Vector2(0, 0)
for i, panel_i in enumerate(panels):
q -= source_2_0_v(point, panel_i) * sol[i]
q += doublet_2_0_v(point, panel_i) * sol[i] * R
q_list.append(q)
import matplotlib
matplotlib.use('Agg')
from matplotlib import pyplot as plt
import numpy as np
import paraBEM
from paraBEM.pan2d import doublet_2_0, source_2_0, doublet_2_0_v
from paraBEM.utils import check_path
pnt1 = paraBEM.PanelVector2(-1, 0)
pnt2 = paraBEM.PanelVector2(1, 0)
source = paraBEM.Panel2([pnt1, pnt2])
y = np.linspace(-3, 3, 100)
val = [source_2_0(paraBEM.Vector2(yi, 8), source) for yi in y]
plt.plot(y, val)
val = [source_2_0(paraBEM.Vector2(yi, 0.01), source) for yi in y]
plt.plot(y, val)
val = [source_2_0(paraBEM.Vector2(yi, 0.0), source) for yi in y]
plt.plot(y, val)
val = [source_2_0(paraBEM.Vector2(yi, 3), source) for yi in y]
plt.plot(y, val)
plt.savefig(check_path("results/2d/source.png"))
plt.close()
y = np.linspace(-3, 3, 100)
val = [doublet_2_0(paraBEM.Vector2(yi, 7), source) for yi in y]
plt.plot(y, val)
val = [doublet_2_0(paraBEM.Vector2(yi, 0.01), source) for yi in y]
plt.plot(y, val)