def create_potential_table(self):
if not self.paraBEM:
self.QWarning = QtGui.QLabel('no panel_method installed')
self.layout.addWidget(self.QWarning)
else:
self._vertices, self._panels, self._trailing_edges = paraBEM_Panels(
self.parametric_glider.get_glider_3d(),
midribs=0,
profile_numpoints=50,
num_average=4,
distribution=Distribution.from_nose_cos_distribution(0.2),
symmetric=True)
case = self.pan3d.DirichletDoublet0Source0Case3(
self._panels, self._trailing_edges)
case.A_ref = self.parametric_glider.shape.area
case.mom_ref_point = self.paraBEM.Vector3(1.25, 0, -6)
case.v_inf = self.paraBEM.Vector(self.parametric_glider.v_inf)
case.drag_calc = 'trefftz'
case.farfield = 5
case.create_wake(10000000, 20)
pols = case.polars(
self.paraBEM_utils.v_inf_deg_range3(case.v_inf, 2, 15, 20))
self.cL = []
self.cDi = []
self.cPi = []
self.alpha = []
for i in pols.values:
self.alpha.append(i.alpha)
self.cL.append(i.cL)
self.cDi.append(i.cD)
self.cPi.append(i.cP)
self.alpha = np.array(self.alpha)
self.cL = np.array(self.cL)
self.cDi = np.array(self.cDi)
self.cPi = np.array(self.cPi)
def create_potential_table(self):
if not self.paraBEM:
self.QWarning = QtGui.QLabel("no panel_method installed")
self.layout.addWidget(self.QWarning)
else:
self._vertices, self._panels, self._trailing_edges = paraBEM_Panels(
self.ParametricGlider.get_glider_3d(),
midribs=0,
profile_numpoints=50,
num_average=4,
distribution=Distribution.from_nose_cos_distribution(0.2),
symmetric=True
)
case = self.pan3d.DirichletDoublet0Source0Case3(self._panels, self._trailing_edges)
case.A_ref = self.ParametricGlider.shape.area
case.mom_ref_point = self.paraBEM.Vector3(1.25, 0, -6)
case.v_inf = self.paraBEM.Vector(self.ParametricGlider.v_inf)
case.drag_calc = "trefftz"
case.farfield = 5
case.create_wake(10000000, 20)
pols = case.polars(self.paraBEM_utils.v_inf_deg_range3(case.v_inf, 2, 15, 20))
self.cL = []
self.cDi = []
self.cPi = []
self.alpha = []
for i in pols.values:
self.alpha.append(i.alpha)
self.cL.append(i.cL)
self.cDi.append(i.cD)
self.cPi.append(i.cP)
self.alpha = np.array(self.alpha)
self.cL = np.array(self.cL)
self.cDi = np.array(self.cDi)
self.cPi = np.array(self.cPi)
def min_func(x):
global count
count += 1
print("\niteration: " + str(count))
_glider2d = deepcopy(glider2d)
glider_set_controlpoint(_glider2d, x)
glider3d = _glider2d.get_glider_3d()
panels = paraBEM_Panels(glider3d,
midribs=0,
profile_numpoints=40,
symmetric=True,
distribution=Distribution.from_nose_cos_distribution(40, 0.2),
num_average=0)
case = Case(panels[1], panels[2])
case.farfield = 5
case.drag_calc = "trefftz"
case.A_ref = 23
case.create_wake(length=10000, count=5)
case.v_inf = paraBEM.Vector3(8, 0, 1)
case.trefftz_cut_pos = case.v_inf * 50
alpha = v_inf_deg_range3(case.v_inf, 5, 9, 20)
polars = case.polars(alpha)
vtk_writer = CaseToVTK(case, "results/vtk_opt", suffix=str(count))
vtk_writer.write_panels(data_type="point")
cL = []
cD = []
for i in polars.values:
cL.append(i.cL)
cD.append(i.cD)
return np.interp(0.6, cL, cD)
def test_is_in_list(self):
for typ in self.dist_types:
a = Distribution.new(numpoints=self.num_dist,
fixed_nodes=self.fixpoints,
dist_type=typ)
for fixed in self.fixpoints:
self.assertAlmostEqual(min(np.abs(a.data - fixed)), 0)
def min_func(x):
global count
count += 1
print("\niteration: " + str(count))
_glider2d = deepcopy(glider2d)
glider_set_controlpoint(_glider2d, x)
glider3d = _glider2d.get_glider_3d()
panels = paraBEM_Panels(
glider3d,
midribs=0,
profile_numpoints=40,
symmetric=True,
distribution=Distribution.from_nose_cos_distribution(40, 0.2),
num_average=0)
case = Case(panels[1], panels[2])
case.farfield = 5
case.drag_calc = "trefftz"
case.A_ref = 23
case.create_wake(length=10000, count=5)
case.v_inf = paraBEM.Vector3(8, 0, 1)
case.trefftz_cut_pos = case.v_inf * 50
alpha = v_inf_deg_range3(case.v_inf, 5, 9, 20)
polars = case.polars(alpha)
vtk_writer = CaseToVTK(case, "results/vtk_opt", suffix=str(count))
vtk_writer.write_panels(data_type="point")
cL = []
cD = []
for i in polars.values:
cL.append(i.cL)
cD.append(i.cD)
return np.interp(0.6, cL, cD)
def create_panels(self, midribs=0, profile_numpoints=10, mean=False, symmetric=True):
self._vertices, self._panels, self._trailing_edges = paraBEM_Panels(
self.ParametricGlider.get_glider_3d(),
midribs=midribs,
profile_numpoints=profile_numpoints,
num_average=mean*5,
distribution=Distribution.from_nose_cos_distribution(0.2),
symmetric=symmetric)
def setUp(self):
self.glider2d = self.import_glider_2d()
self.glider3d = self.glider2d.get_glider_3d()
config = {"v_inf": [10, 0, 2],
"symmetric_case": True,
"cell_numpoints": 5,
"distribution": Distribution.from_nose_cos_distribution(100, 0.2)
}
self.glidercase = GliderPanelMethod(self.glider3d, config)
class PatternConfig(Config):
complete_glider = True
debug = False
profile_numpoints = 250
cut_entry = cuts.FoldedCut
cut_trailing_edge = cuts.ParallelCut
cut_design = cuts.ParallelCut
cut_diagonal_fold = cuts.FoldedCut
cut_3d = cuts.Cut3D
midribs = 50
patterns_align_dist_y = 0.05
patterns_align_dist_x = patterns_align_dist_y
patterns_scale = 1000
allowance_general = 0.01
allowance_parallel = 0.01
allowance_orthogonal = 0.01
allowance_diagonals = 0.01
allowance_trailing_edge = 0.01
allowance_entry_open = 0.015
marks_diagonal_front = marks.Inside(marks.Arrow(left=True, name="diagonal_front"))
marks_diagonal_back = marks.Inside(marks.Arrow(left=False, name="diagonal_back"))
marks_laser_diagonal = marks.Dot(0.8)
marks_laser_attachment_point = marks.Dot(0.2, 0.8)
marks_attachment_point = marks.OnLine(marks.Rotate(marks.Cross(name="attachment_point"), np.pi / 4))
marks_strap = marks.Inside(marks.Line(name="strap"))
distribution_controlpoints = Distribution.from_linear(20, -1, 1)
marks_laser_controlpoint = marks.Dot(0.2)
marks_controlpoint = marks.Dot(0.2)
marks_panel_cut = marks.Line(name="panel_cut")
rib_text_pos = -0.005
allowance_design = 0.012 # trailing_edge
drib_allowance_folds = 0.012
drib_num_folds = 1
drib_text_position = 0.1
strap_num_folds = 0
sigma_3d_cut = 0.03
insert_attachment_point_text = True
layout_seperate_panels = True
def create_panels(self,
midribs=0,
profile_numpoints=10,
mean=False,
symmetric=True):
self._vertices, self._panels, self._trailing_edges = paraBEM_Panels(
self.parametric_glider.get_glider_3d(),
midribs=midribs,
profile_numpoints=profile_numpoints,
num_average=mean * 5,
distribution=Distribution.from_nose_cos_distribution(0.2),
symmetric=symmetric)
def test_glider_mesh(self):
dist = Distribution.from_nose_cos_distribution(30, 0.2)
dist.add_glider_fixed_nodes(self.glider)
self.glider.profile_x_values = dist
m = Mesh(name="glider_mesh")
for cell in self.glider.cells[1:-1]:
m += cell.get_mesh(0)
for rib in self.glider.ribs:
m += Mesh.from_rib(rib)
m.delete_duplicates()
m.get_indexed()
def create_fem_dict(par_glider):
# not yet working
# create a paraBEM object and compute the pressure
# create a dict with:
# nodes, elements, forces, bc, joints
vertices, panels, trailing_edges = paraBEM_Panels(
par_glider.get_glider_3d(),
midribs=0,
profile_numpoints=50,
num_average=4,
distribution=Distribution.from_nose_cos_distribution(0.2),
symmetric=True)
def create_fem_dict(par_glider):
# create a paraBEM object and compute the pressure
# create a dict with:
# nodes, elements, forces, bc, joints
vertices, panels, trailing_edges = paraBEM_Panels(
par_glider.get_glider_3d(),
midribs=0,
profile_numpoints=50,
num_average=4,
distribution=Distribution.from_nose_cos_distribution(0.2),
symmetric=True)
case.A_ref = par_glider.flat_area
case.v_inf = paraBEM.Vector(glider.v_inf)
self.case.farfield = 5
self.case.create_wake(9999, 10)
self.case.run()
def create_fem_dict(par_glider):
# create a paraBEM object and compute the pressure
# create a dict with:
# nodes, elements, forces, bc, joints
vertices, panels, trailing_edges = paraBEM_Panels(
par_glider.get_glider_3d(),
midribs=0,
profile_numpoints=50,
num_average=4,
distribution=Distribution.from_nose_cos_distribution(0.2),
symmetric=True
)
case.A_ref = par_glider.flat_area
case.v_inf = paraBEM.Vector(glider.v_inf)
self.case.farfield = 5
self.case.create_wake(9999, 10)
self.case.run()
def test_run(self):
config = {
"v_inf": [14, 0, 2],
"fem_timestep": 1.e-06,
"fem_steps": 100,
"fem_output": 10,
"d_velocity": 1.,
"pressure_ramp": 100, # steps for linear pressure ramp
"caseType": "line_forces",
"line_numpoints": 10,
"line_rho": 0.00001,
"line_elasticity": 30000,
"rib_rho": 0.00001,
"cell_numpoints": 0,
"vtk_fem_output": "/tmp/Fem/testFEM",
"symmetric_case": True,
"line_numpoints": 2,
"distribution": Distribution.from_nose_cos_distribution(30, 0.3)
}
self.glidercase = GliderFemCase(self.glider3d, config)
self.glidercase.run()
def profile_numpoints(self, numpoints):
self.profile_x_values = Distribution.from_nose_cos_distribution(numpoints, 0.3)
import paraBEM.pan2d as bem import paraBEM import paraFEM as fem import matplotlib.tri as mtri import matplotlib.pyplot as plt # parameters numpoints = 200 insert_values = [0.09, 0.22, 0.5, 0.75] # 1: erstelle ein profil dist = Distribution.from_nose_cos_distribution(numpoints, 0.2) dist.insert_values(insert_values) fixed = [list(dist.data).index(value) for value in insert_values] boundary = range(len(dist)) airfoil = Profile2D.compute_trefftz(m=-0.1+0.1j, tau=0.2, numpoints=100) airfoil.x_values = dist # 2: berechne druckverteilung (bem) vertices = [paraBEM.PanelVector2(*point) for point in airfoil.data[:-1]] vertices.append(vertices[0]) vertices[0].wake_vertex = True panels = [paraBEM.Panel2(vertices[i:i + 2]) for i in range(len(vertices) - 1)] case = bem.DirichletDoublet0Source0Case2(panels) case.v_inf = paraBEM.Vector2(1, 0.1)
import paraEigen as eigen import paraBEM.pan2d as bem import paraBEM import paraFEM as fem import matplotlib.tri as mtri import matplotlib.pyplot as plt # parameters numpoints = 80 insert_values = [0.11, 0.27, 0.5, 0.75] # 1: erstelle ein profil dist = Distribution.from_nose_cos_distribution(numpoints, 0.2) dist.insert_values(insert_values) fixed = [list(dist.data).index(value) for value in insert_values] boundary = range(len(dist)) airfoil = Profile2D.compute_trefftz(-0.1, 0.2, 100) airfoil.x_values = dist # 2: berechne druckverteilung (bem) vertices = [paraBEM.PanelVector2(*point) for point in airfoil.data[:-1]] vertices.append(vertices[0]) vertices[0].wake_vertex = True panels = [paraBEM.Panel2(vertices[i:i + 2]) for i in range(len(vertices) - 1)] case = bem.DirichletDoublet0Source0Case2(panels) case.v_inf = eigen.vector2(1, 0.2)
def numpoints(self, numpoints):
self.x_values = Distribution.from_cos_distribution(numpoints)
from paraBEM.pan3d import DirichletDoublet0Source0Case3 as Case
from paraBEM.vtk_export import CaseToVTK
from paraBEM.utils import v_inf_deg_range3
n_x = 30
with open("glider/referenz_schirm_berg.json") as _file:
glider_2d = load(_file)["data"]
glider_2d.shape.set_const_cell_dist()
glider = glider_2d.get_glider_3d()
_, panels, trailing_edge = paraBEM_Panels(
glider,
midribs=3,
profile_numpoints=n_x,
distribution=Distribution.from_cos_2_distribution(n_x),
num_average=0,
symmetric=False)
v_inf = [8, 0, 1]
case = Case(panels, trailing_edge)
case.mom_ref_point = paraBEM.Vector3(1.25, 0, 0)
case.A_ref = glider_2d.shape.area
case.farfield = 5
case.drag_calc = "on_body"
case.v_inf = paraBEM.Vector3(v_inf)
case.create_wake(length=10000, count=4) # length, count
polars = case.polars(v_inf_deg_range3(case.v_inf, -5, 15, 50))
def paraBEM_Panels(glider,
midribs=0,
profile_numpoints=None,
num_average=0,
symmetric=False,
distribution=None):
"""return the vertices, panels and the trailing edge of a glider, as paraBEM objects.
midribs: midribs of a cell spanwise. if num_average is greater then
0 ballooning will be disables
profile_numpoints: coordinates of every rib, choordwise
num_average: steps to average a cell profile
symmetric: set to True if a symmetric result is expected (this will
reduce evaluation time)
"""
# paraBEM is not a dependency of openglider so if problems occure here, get the module.
import paraBEM
if symmetric:
glider = glider.copy()
else:
glider = glider.copy_complete()
glider.close_rib(0)
glider.close_rib()
if profile_numpoints:
glider.profile_x_values = Distribution.from_nose_cos_distribution(
profile_numpoints, 0.2)
if num_average > 0:
glider.apply_mean_ribs(num_average)
glider.close_rib()
ribs = glider.return_ribs(midribs, ballooning=False)
else:
ribs = glider.return_ribs(midribs)
# deleting the last vertex of every rib (no trailing edge gap)
ribs = [rib[:-1] for rib in ribs]
# get a numbered representation + flatten vertices
i = 0
vertices = []
ribs_new = []
panels = []
sym_panels = []
trailing_edge = []
for rib in ribs:
rib_new = []
for vertex in rib:
rib_new.append(i)
vertices.append(vertex)
i += 1
rib_new.append(rib_new[0])
ribs_new.append(rib_new)
ribs = ribs_new
panel_nr = 0
for i, rib_i in enumerate(ribs[:-1]):
rib_j = ribs[i + 1]
if symmetric:
if vertices[rib_j[0]][1] > 0.00001:
trailing_edge.append(rib_i[0])
else:
trailing_edge.append(rib_i[0])
if i == len(ribs[:-2]):
trailing_edge.append(rib_j[0])
for k, _ in enumerate(rib_j[:-1]):
l = k + 1
panel = [rib_i[k], rib_j[k], rib_j[l], rib_i[l]]
if symmetric:
sym = True
add_panel = False
for p in panel:
if not vertices[p][
1] > -0.000001: # if one point lies on the y- side
sym = False # y- is the mirrored side
if not vertices[p][
1] < 0.0001: # if one point lies on the y+ side
add_panel = True
if add_panel:
panels.append(panel)
if sym:
sym_panels.append(panel_nr)
panel_nr += 1
else:
panels.append(panel)
vertices = [paraBEM.PanelVector3(*point) for point in vertices]
panels = [
paraBEM.Panel3([vertices[nr] for nr in panel]) for panel in panels
]
trailing_edge = [vertices[nr] for nr in trailing_edge]
for nr in sym_panels:
panels[nr].set_symmetric()
return vertices, panels, trailing_edge
def get_glider_3d(self, glider=None, num=50, num_profile=None):
"""returns a new glider from parametric values"""
glider = glider or Glider()
ribs = []
self.rescale_curves()
x_values = self.shape.rib_x_values
shape_ribs = self.shape.ribs
profile_merge_curve = self.profile_merge_curve.interpolation(num=num)
ballooning_merge_curve = self.ballooning_merge_curve.interpolation(
num=num)
aoa_int = self.aoa.interpolation(num=num)
zrot_int = self.zrot.interpolation(num=num)
arc_pos = list(self.arc.get_arc_positions(x_values))
rib_angles = self.arc.get_rib_angles(x_values)
if self.num_profile is not None:
num_profile = self.num_profile
if num_profile is not None:
profile_x_values = Distribution.from_cos_distribution(num_profile)
else:
profile_x_values = self.profiles[0].x_values
rib_holes = self.elements.get("holes", [])
rigids = self.elements.get("rigidfoils", [])
cell_centers = [(p1 + p2) / 2
for p1, p2 in zip(x_values[:-1], x_values[1:])]
offset_x = shape_ribs[0][0][1]
for rib_no, pos in enumerate(x_values):
front, back = shape_ribs[rib_no]
arc = arc_pos[rib_no]
startpoint = np.array([-front[1] + offset_x, arc[0], arc[1]])
chord = abs(front[1] - back[1])
factor = profile_merge_curve(abs(pos))
profile = self.get_merge_profile(factor)
profile.name = "Profile{}".format(rib_no)
profile.x_values = profile_x_values
this_rib_holes = [
RibHole(ribhole["pos"], ribhole["size"])
for ribhole in rib_holes if rib_no in ribhole["ribs"]
]
this_rigid_foils = [
RigidFoil(rigid["start"], rigid["end"], rigid["distance"])
for rigid in rigids if rib_no in rigid["ribs"]
]
ribs.append(
Rib(profile_2d=profile,
startpoint=startpoint,
chord=chord,
arcang=rib_angles[rib_no],
glide=self.glide,
aoa_absolute=aoa_int(pos),
zrot=zrot_int(pos),
holes=this_rib_holes,
rigidfoils=this_rigid_foils,
name="rib{}".format(rib_no)))
ribs[-1].aoa_relative = aoa_int(pos)
if self.shape.has_center_cell:
new_rib = ribs[0].copy()
new_rib.name = "rib0"
new_rib.mirror()
new_rib.mirrored_rib = ribs[0]
ribs.insert(0, new_rib)
cell_centers.insert(0, 0.)
glider.cells = []
for cell_no, (rib1, rib2) in enumerate(zip(ribs[:-1], ribs[1:])):
ballooning_factor = ballooning_merge_curve(cell_centers[cell_no])
ballooning = self.merge_ballooning(ballooning_factor)
cell = Cell(rib1, rib2, ballooning, name="c{}".format(cell_no + 1))
glider.cells.append(cell)
glider.close_rib()
# CELL-ELEMENTS
self.get_panels(glider)
self.apply_diagonals(glider)
for minirib in self.elements.get("miniribs", []):
data = minirib.copy()
cells = data.pop("cells")
for cell_no in cells:
glider.cells[cell_no].miniribs.append(MiniRib(**data))
# RIB-ELEMENTS
#self.apply_holes(glider)
glider.rename_parts()
glider.lineset = self.lineset.return_lineset(glider, self.v_inf)
glider.lineset.glider = glider
glider.lineset.calculate_sag = False
for _ in range(3):
glider.lineset.recalc()
glider.lineset.calculate_sag = True
glider.lineset.recalc()
return glider
