def setUp(self, numpoints=100): self.prof1 = Profile2D.compute_naca(1223) self.prof2 = Profile2D.compute_naca(1223) for prof in [self.prof1, self.prof2]: naca = random.randint(1, 1399) # prof.compute_naca(naca=1223, numpoints=numpoints) prof.close() prof.normalize() self.ballooning = BallooningBezier() self.rib2 = Rib(self.prof1, self.ballooning, [0.0, 0.12, 0], 1.0, 20 * math.pi / 180, 2 * math.pi / 180, 0, 7.0) self.rib3 = Rib( self.prof2, self.ballooning, [0.2, 0.3, -0.1], 0.8, 30 * math.pi / 180, 5 * math.pi / 180, 0, 7.0 ) self.rib1 = self.rib2.copy() self.rib1.mirror() self.cell1 = Cell(self.rib1, self.rib2) self.cell2 = Cell(self.rib2, self.rib3)
def setUp(self, numpoints=100): self.prof1 = Profile2D.compute_naca(1223) self.prof2 = Profile2D.compute_naca(1223) for prof in [self.prof1, self.prof2]: naca = random.randint(1, 1399) #prof.compute_naca(naca=1223, numpoints=numpoints) prof.close() prof.normalize() self.ballooning = BallooningBezier() self.rib2 = Rib(self.prof1, self.ballooning, [0., 0.12, 0], 1., 20 * math.pi / 180, 2 * math.pi / 180, 0, 7.) self.rib3 = Rib(self.prof2, self.ballooning, [0.2, 0.3, -0.1], 0.8, 30 * math.pi / 180, 5 * math.pi / 180, 0, 7.) self.rib1 = self.rib2.copy() self.rib1.mirror() self.cell1 = Cell(self.rib1, self.rib2) self.cell2 = Cell(self.rib2, self.rib3)
class TestCell(unittest.TestCase): def setUp(self, numpoints=100): self.prof1 = Profile2D.compute_naca(1223) self.prof2 = Profile2D.compute_naca(1223) for prof in [self.prof1, self.prof2]: naca = random.randint(1, 1399) #prof.compute_naca(naca=1223, numpoints=numpoints) prof.close() prof.normalize() self.ballooning = BallooningBezier() self.rib2 = Rib(self.prof1, self.ballooning, [0., 0.12, 0], 1., 20 * math.pi / 180, 2 * math.pi / 180, 0, 7.) self.rib3 = Rib(self.prof2, self.ballooning, [0.2, 0.3, -0.1], 0.8, 30 * math.pi / 180, 5 * math.pi / 180, 0, 7.) self.rib1 = self.rib2.copy() self.rib1.mirror() self.cell1 = Cell(self.rib1, self.rib2) self.cell2 = Cell(self.rib2, self.rib3) def test_show_cell(self, num=10): #print(self.rib1.profile_2d.x_values) ribs = [self.cell1.midrib(x * 1. / num) for x in range(num)] ribs += [self.cell2.midrib(x * 1. / num) for x in range(num)] Graph.Graphics([Graph.Line(x.data) for x in ribs] + [Graph.Line(self.rib1.profile_3d.data)]) def test_mirror(self): cell1 = self.cell2 cell2 = self.cell2.copy() cell2.mirror() print(cell1._basic_cell.normvectors) print([[p, normvector] for p, normvector in zip( cell1.prof2.data, cell1._basic_cell.normvectors)]) Graph.Graphics([ Graph.Line(cell1.rib1.profile_3d.data), Graph.Line(cell2.rib1.profile_3d.data), Graph.Red, Graph.Line(cell1.prof2.data), Graph.Line(cell2.prof2.data), Graph.Green ] + [ Graph.Line([p, p + normvector]) for p, normvector in zip( cell2.prof2.data, cell2.basic_cell.normvectors) ])
class TestCell(unittest.TestCase): def setUp(self, numpoints=100): self.prof1 = Profile2D.compute_naca(1223) self.prof2 = Profile2D.compute_naca(1223) for prof in [self.prof1, self.prof2]: naca = random.randint(1, 1399) # prof.compute_naca(naca=1223, numpoints=numpoints) prof.close() prof.normalize() self.ballooning = BallooningBezier() self.rib2 = Rib(self.prof1, self.ballooning, [0.0, 0.12, 0], 1.0, 20 * math.pi / 180, 2 * math.pi / 180, 0, 7.0) self.rib3 = Rib( self.prof2, self.ballooning, [0.2, 0.3, -0.1], 0.8, 30 * math.pi / 180, 5 * math.pi / 180, 0, 7.0 ) self.rib1 = self.rib2.copy() self.rib1.mirror() self.cell1 = Cell(self.rib1, self.rib2) self.cell2 = Cell(self.rib2, self.rib3) def test_show_cell(self, num=10): # print(self.rib1.profile_2d.x_values) ribs = [self.cell1.midrib(x * 1.0 / num) for x in range(num)] ribs += [self.cell2.midrib(x * 1.0 / num) for x in range(num)] Graph.Graphics([Graph.Line(x.data) for x in ribs] + [Graph.Line(self.rib1.profile_3d.data)]) def test_mirror(self): cell1 = self.cell2 cell2 = self.cell2.copy() cell2.mirror() print(cell1._basic_cell.normvectors) print([[p, normvector] for p, normvector in zip(cell1.prof2.data, cell1._basic_cell.normvectors)]) Graph.Graphics( [ Graph.Line(cell1.rib1.profile_3d.data), Graph.Line(cell2.rib1.profile_3d.data), Graph.Red, Graph.Line(cell1.prof2.data), Graph.Line(cell2.prof2.data), Graph.Green, ] + [Graph.Line([p, p + normvector]) for p, normvector in zip(cell2.prof2.data, cell2.basic_cell.normvectors)] )
#MiniRib(0.2, 0.8, 1), MiniRib(0.5, 0.7, 1), #MiniRib(0.8, 0.8, 1), ] b1 = BallooningBezier() b2 = BallooningBezier() b2.Amount *= 0.8 r2 = Rib(a, b1, [0, 0.12, 0], 1., 20 * math.pi / 180, 2 * math.pi / 180, 0, 7) r1 = r2.copy() r1.mirror() r3 = Rib(a, b2, [0.2, 0.3, -0.1], 0.8, 30 * math.pi / 180, 5 * math.pi / 180, 0, 7) cell1 = Cell(r1, r2, midribs) cell1.recalc() cell2 = Cell(r2, r3, []) cell2.recalc() num = 20 #ribs = [cell1.midrib(x*1./num) for x in range(num+1)] #ribs += [cell2.midrib(x*1./num) for x in range(num+1)] #G.Graphics3D([G.Line(r1.profile_3d.data),G.Line(r2.profile_3d.data),G.Line([[0.,0.,0.],[1.,0.,0.]]),G.Line([[0.,0.,0.],[0.,0.5,0.]])]) #Graph.Graphics3D([Graph.Line(x.data) for x in ribs]) ribs = [] for x in range(num + 1): ribs.append(cell1.midrib(x * 1. / num).data) for x in range(1, num + 1): ribs.append(cell2.midrib(x * 1. / num).data) ribs = numpy.concatenate(ribs)
# MiniRib(0.2, 0.8, 1), MiniRib(0.5, 0.7, 1), # MiniRib(0.8, 0.8, 1), ] b1 = BallooningBezier() b2 = BallooningBezier() b2.Amount *= 0.8 r2 = Rib(a, b1, [0, 0.12, 0], 1.0, 20 * math.pi / 180, 2 * math.pi / 180, 0, 7) r1 = r2.copy() r1.mirror() r3 = Rib(a, b2, [0.2, 0.3, -0.1], 0.8, 30 * math.pi / 180, 5 * math.pi / 180, 0, 7) cell1 = Cell(r1, r2, midribs) cell1.recalc() cell2 = Cell(r2, r3, []) cell2.recalc() num = 20 # ribs = [cell1.midrib(x*1./num) for x in range(num+1)] # ribs += [cell2.midrib(x*1./num) for x in range(num+1)] # G.Graphics3D([G.Line(r1.profile_3d.data),G.Line(r2.profile_3d.data),G.Line([[0.,0.,0.],[1.,0.,0.]]),G.Line([[0.,0.,0.],[0.,0.5,0.]])]) # Graph.Graphics3D([Graph.Line(x.data) for x in ribs]) ribs = [] for x in range(num + 1): ribs.append(cell1.midrib(x * 1.0 / num).data) for x in range(1, num + 1): ribs.append(cell2.midrib(x * 1.0 / num).data) ribs = numpy.concatenate(ribs)
def import_ods(filename, glider=None): ods = ezodf.opendoc(filename) sheets = ods.sheets # Profiles -> map xvalues profiles = [Profile2D(profile) for profile in transpose_columns(sheets[3])] xvalues = sorted(profiles, key=lambda prof: prof.numpoints)[0].x_values # Use airfoil with maximum profilepoints for profile in profiles: profile.x_values = xvalues # Ballooning old : 1-8 > upper (prepend/append (0,0),(1,0)), 9-16 > lower (same + * (1,-1)) balloonings_temp = transpose_columns(sheets[4]) balloonings = [] for baloon in balloonings_temp: upper = [[0, 0]] + baloon[:7] + [[1, 0]] lower = [[0, 0]] + [[i[0], -1 * i[1]] for i in baloon[8:15]] + [[1, 0]] balloonings.append(BallooningBezier([upper, lower])) # Data data = {} datasheet = sheets[-1] assert isinstance(datasheet, ezodf.Sheet) for i in range(datasheet.nrows()): data[datasheet.get_cell([i, 0]).value] = datasheet.get_cell([i, 1]).value #print(data["GLEITZAHL"]) glider.data = data cells = [] main = sheets[0] x = y = z = span_last = 0. alpha2 = 0. thisrib = None # TODO: Glide -> DATAIMPORT for i in range(1, main.nrows()): line = [main.get_cell([i, j]).value for j in range(main.ncols())] if not line[0]: #print("leere zeile:", i, main.nrows()) break chord = line[1] # Rib-Chord span = line[2] # spanwise-length (flat) alpha1 = alpha2 # angle before the rib alpha2 += line[4] * numpy.pi / 180 # angle after the rib alpha = (span > 0) * (alpha1 + alpha2) * 0.5 + line[6] * numpy.pi / 180 # rib's angle x = line[3] # x-value -> front/back (ribwise) y += numpy.cos(alpha1) * (span - span_last) # y-value -> spanwise z -= numpy.sin(alpha1) * (span - span_last) # z-axis -> up/down aoa = line[5] * numpy.pi / 180 zrot = line[7] * numpy.pi / 180 span_last = span profile = merge(line[8], profiles) ballooning = merge(line[9], balloonings) lastrib = thisrib thisrib = Rib(profile, ballooning, numpy.array([x, y, z]), chord, alpha, aoa, zrot, data["GLEITZAHL"]) if i == 1 and y != 0: # Middle-cell #print("midrib!", y) lastrib = thisrib.copy() lastrib.mirror() if lastrib: cell = Cell(lastrib, thisrib, []) cell.name = "Cell_no"+str(i) cells.append(cell) if glider: glider.cells = cells glider.close_rib() glider.attachment_points = read_elements(sheets[2], "AHP", AttachmentPoint) glider.attachment_points_lower = get_lower_aufhaengepunkte(glider.data) for p in glider.attachment_points: p.force = numpy.array([0, 0, 1]) p.get_position(glider) glider.lines = tolist_lines(sheets[6], glider.attachment_points_lower, glider.attachment_points) glider.lines.calc_geo() glider.lines.calc_sag() return return cells
def import_ods(filename, glider): ods = ezodf.opendoc(filename) sheets = ods.sheets # Profiles -> map xvalues profiles = [Profile2D(profile) for profile in transpose_columns(sheets[3])] xvalues = sorted(profiles, key=lambda prof: prof.numpoints)[0].x_values # Use airfoil with maximum profilepoints for profile in profiles: profile.x_values = xvalues # Ballooning old : 1-8 > upper (prepend/append (0,0),(1,0)), 9-16 > lower (same + * (1,-1)) balloonings_temp = transpose_columns(sheets[4]) balloonings = [] for baloon in balloonings_temp: upper = [[0, 0]] + baloon[:7] + [[1, 0]] lower = [[0, 0]] + [[i[0], -1 * i[1]] for i in baloon[8:15]] + [[1, 0]] balloonings.append(BallooningBezier(upper, lower)) # Data data = {} datasheet = sheets[-1] assert isinstance(datasheet, ezodf.Sheet) for i in range(datasheet.nrows()): data[datasheet.get_cell([i, 0]).value] = datasheet.get_cell([i, 1]).value #print(data["GLEITZAHL"]) glider.data = data cells = [] main = sheets[0] x = y = z = span_last = 0. alpha2 = 0. thisrib = None for i in range(1, main.nrows()): line = [main.get_cell([i, j]).value for j in range(main.ncols())] if not line[0]: break # skip empty line chord = line[1] # Rib-Chord span = line[2] # spanwise-length (flat) alpha1 = alpha2 # angle before the rib alpha2 += line[4] * np.pi / 180 # angle after the rib alpha = (span > 0) * (alpha1 + alpha2) * 0.5 + line[6] * np.pi / 180 # rib's angle x = line[3] # x-value -> front/back (ribwise) y += np.cos(alpha1) * (span - span_last) # y-value -> spanwise z -= np.sin(alpha1) * (span - span_last) # z-axis -> up/down aoa = line[5] * np.pi / 180 zrot = line[7] * np.pi / 180 span_last = span profile = merge(line[8], profiles) ballooning = merge(line[9], balloonings) lastrib = thisrib thisrib = Rib(profile, np.array([x, y, z]), chord, alpha, aoa, zrot, data["GLIDE"], name="Rib ({})".format(i)) if i == 1 and y != 0: # Middle-cell #print("midrib!", y) lastrib = thisrib.copy() lastrib.mirror() if lastrib: cell = Cell(lastrib, thisrib, ballooning) cell.name = "Cell_no"+str(i) cells.append(cell) glider.cells = cells glider.close_rib() ######################################LINESET###################################################### attachment_points = [AttachmentPoint(glider.ribs[args[0]], args[1], args[2]) for args in read_elements(sheets[2], "AHP", len_data=2)] attachment_points.sort(key=lambda element: element.name) attachment_points_lower = get_lower_aufhaengepunkte(glider.data) for p in attachment_points: p.force = np.array([0, 0, 10]) p.get_position() glider.lineset = tolist_lines(sheets[6], attachment_points_lower, attachment_points) glider.lineset.recalc() ####################################PANELS########################################################## cuts = [cut+[1, glider.data["Designzugabe"]] for cut in read_elements(sheets[1], "DESIGNO")] cuts += [cut+[1, glider.data["Designzugabe"]] for cut in read_elements(sheets[1], "DESIGNM")] cuts += [cut+[2, glider.data["EKzugabe"]] for cut in read_elements(sheets[1], "EKV")] cuts += [cut+[2, glider.data["EKzugabe"]] for cut in read_elements(sheets[1], "EKH")] for i, cell in enumerate(glider.cells): # cut = [cell_no, x_left, x_right, cut_type, amount_add] cuts_this = [cut for cut in cuts if cut[0] == i] cuts_this.sort(key=lambda cut: cut[1]) cuts_this.sort(key=lambda cut: cut[2]) # Insert leading-/trailing-edge cuts_this.insert(0, [i, -1, -1, 3, glider.data["HKzugabe"]]) cuts_this.append([i, 1, 1, 3, glider.data["HKzugabe"]]) cell.panels = [] for j in range(len(cuts_this)-1): if cuts_this[j][3] != 2 or cuts_this[j+1][3] != 2: # skip entry cell.panels.append(Panel(cuts_this[j][1:], cuts_this[j+1][1:])) return glider
import tempfile from openglider.airfoil.parametric import BezierProfile2D from openglider.glider.cell import Cell from openglider.glider.rib import Rib from openglider.glider import Glider from openglider.glider.ballooning import BallooningBezier from openglider.graphics import Graphics3D, Polygon, Line from openglider.glider.in_out.export_3d import export_obj path = "/tmp/cell.obj" # a tool to optimize a parafoil for a given cell geometry ar = 0.1 bal = BallooningBezier() profile = BezierProfile2D.compute_naca(2412) rib0 = Rib(profile, [0, -ar / 2, 0], 1, 0., 0., 0., 999999.) rib1 = Rib(profile, [0, ar / 2, 0], 1, 0., 0., 0., 999999.) cell1 = Cell(rib0, rib1, bal) glider = Glider([cell1]) export_obj(glider, path, midribs=40, numpoints=50, floatnum=6, copy=False)
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
prof.importdat(os.path.dirname(os.path.abspath(__file__)) + "/testprofile.dat") ballooning = BallooningBezier() balloon = [ballooning(i) for i in prof.x_values] r1 = Rib(prof, ballooning, [0., 0.12, 0], 1., 20 * math.pi / 180, 2 * math.pi / 180, 0, 7.) r2 = r1.copy() r2.mirror() left, right = flatten_list(r2.profile_3d.data, r1.profile_3d.data) ding = [numpy.array([0, 0]), numpy.array([1., 0])] #[numpy.array([0,0]),numpy.array([1,0]) cell = Cell(r1, r2) left2, right2 = flattened_cell(cell) left_out = left2.copy() left_out.add_stuff(-0.02) right_out = right2.copy() right_out.add_stuff(0.02) openglider.graphics.Graphics2D([ openglider.graphics.Line(left.data), openglider.graphics.Line(right.data), openglider.graphics.Line(left2.data), openglider.graphics.Line(right2.data), openglider.graphics.Line(left_out.data), openglider.graphics.Line(right_out.data) ])