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