def test_mesh(self): p1 = Vertex(*[0, 0, 0]) p2 = Vertex(*[1, 0, 0]) p3 = Vertex(*[0, 1, 0]) p4 = Vertex(*[1, 1, 0]) p5 = Vertex(*[0, 0, 0]) a = Polygon([p1, p2, p3, p4]) b = Polygon([p1, p2, p4, p5]) m1 = Mesh({"a": [a]}, boundary_nodes={"j": list(a)}) m2 = Mesh({"b": [b]}, boundary_nodes={"j": list(b)}) m3 = m1 + m2 m3.delete_duplicates() for vertex in a: self.assertTrue(vertex in m3.vertices)
def get_mesh_panels(self, num_midribs=0): mesh = Mesh(name="panels") for cell in self.cells: for panel in cell.panels: mesh += panel.get_mesh(cell, num_midribs) return mesh
def get_mesh_hull(self, num_midribs=0, ballooning=True): ribs = self.return_ribs(num=num_midribs, ballooning=ballooning) num = len(ribs) numpoints = len(ribs[0]) # points per rib polygons = [] boundary = { "ribs": [], "trailing_edge": [] } for i in range(num-1): # because we use i+1 below boundary["trailing_edge"].append(i*numpoints) if not i % (num_midribs+1): boundary["ribs"] += [i*numpoints+k for k in range(numpoints-1)] for k in range(numpoints - 1): # same reason as above kplus = (k+1) % (numpoints-1) polygons.append([ i * numpoints + k, i * numpoints + kplus, (i + 1) * numpoints + kplus, (i + 1) * numpoints + k ]) return Mesh.from_indexed(np.concatenate(ribs), {"hull": polygons}, boundary)
def get_upper_line_mesh(self, numpoints=1, breaks=False): mesh = Mesh() for line in self.uppermost_lines: if not breaks: # TODO: is there a better solution??? if "BR" in line.upper_node.name: continue mesh += line.get_mesh(numpoints) return mesh
def get_mesh(self, cell): boundaries = {} rib1 = cell.rib1 rib2 = cell.rib2 p1 = rib1.profile_3d[rib1.profile_2d(self.left)] p2 = rib2.profile_3d[rib2.profile_2d(self.right)] boundaries[rib1.name] = [0] boundaries[rib2.name] = [1] return Mesh.from_indexed([p1, p2], {"tension_lines": [[0, 1]]}, boundaries=boundaries)
def get_mesh(self, numpoints): line_points = [Vertex(*point) for point in self.get_line_points(numpoints=numpoints)] boundary = {"lines": []} if self.lower_node.type == 0: boundary["lower_attachment_points"] = [line_points[0]] else: boundary["lines"].append(line_points[0]) if self.upper_node.type == 2: boundary["attachment_points"] = [line_points[-1]] else: boundary["lines"].append(line_points[-1]) line_poly = {"lines": [Polygon(line_points[i:i + 2]) for i in range(len(line_points) - 1)]} return Mesh(line_poly, boundary)
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 get_mesh(self, midribs=0): mesh = Mesh() for rib in self.ribs: if not rib.profile_2d.has_zero_thickness: mesh += rib.get_mesh(filled=True, glider=self) for cell in self.cells: for diagonal in cell.diagonals: mesh += diagonal.get_mesh(cell) mesh += self.lineset.get_mesh() mesh += self.get_mesh_panels(num_midribs=midribs) mesh += self.get_mesh_hull(midribs) return mesh
def get_mesh_mapping(self, cell_number=0, numribs=0, with_numpy=False, half_cell=False): """ Get Cell-mesh :cell_number: number of cell :param numribs: number of miniribs to calculate :return: mesh """ numribs += 1 ribs = [] rib_indices = range(numribs + 1) if half_cell: rib_indices = rib_indices[(numribs) // 2:] for rib_no in rib_indices: y = rib_no / max(numribs, 1) rib = (self.rib1.profile_2d.get_data(negative_x=True) * (1 - y) + self.rib2.profile_2d.get_data(negative_x=True) * y) y += cell_number rib = np.array([rib.T[0], np.array([y] * len(rib)), rib.T[1]]).T # insert y-value ribs.append(Vertex.from_vertices_list(rib)) quads = [] for rib_left, rib_right in zip(ribs[:-1], ribs[1:]): numpoints = len(rib_left) for i in range(numpoints - 1): i_next = i + 1 pol = Polygon([ rib_left[i], rib_right[i], rib_right[i_next], rib_left[i_next] ]) quads.append(pol) mesh = Mesh({"hull": quads}, { self.rib1.name: ribs[0], self.rib2.name: ribs[-1] }) return mesh
def get_mesh(self, numribs=0, with_numpy=False, half_cell=False): """ Get Cell-mesh :param numribs: number of miniribs to calculate :return: mesh """ numribs += 1 ribs = [] trailing_edge = [] rib_indices = range(numribs + 1) if half_cell: rib_indices = rib_indices[(numribs) // 2:] for rib_no in rib_indices: y = rib_no / max(numribs, 1) rib = self.midrib(y, with_numpy=with_numpy).data ribs.append(Vertex.from_vertices_list(rib[:-1])) quads = [] for rib_left, rib_right in zip(ribs[:-1], ribs[1:]): numpoints = len(rib_left) for i in range(numpoints): i_next = (i + 1) % numpoints pol = Polygon([ rib_left[i], rib_right[i], rib_right[i_next], rib_left[i_next] ]) pol.influenceFlow = True quads.append(pol) for rib in ribs: trailing_edge.append(rib[0]) mesh = Mesh({"hull": quads}, { self.rib1.name: ribs[0], self.rib2.name: ribs[-1], "trailing_edge": trailing_edge }) return mesh
def get_mesh(self, numpoints=10): return sum([line.get_mesh(numpoints) for line in self.lines], Mesh())
def get_mesh(self, cell, numribs=0, with_numpy=False): """ Get Panel-mesh :param cell: the parent cell of the panel :param numribs: number of interpolation steps between ribs :param with_numpy: compute midribs with numpy (faster if available) :return: mesh objects consisting of triangles and quadrangles """ numribs += 1 # TODO: doesnt work for numribs=0? xvalues = cell.rib1.profile_2d.x_values ribs = [] points = [] nums = [] count = 0 for rib_no in range(numribs + 1): y = rib_no / max(numribs, 1) x1 = self.cut_front["left"] + y * (self.cut_front["right"] - self.cut_front["left"]) front = get_x_value(xvalues, x1) x2 = self.cut_back["left"] + y * (self.cut_back["right"] - self.cut_back["left"]) back = get_x_value(xvalues, x2) midrib = cell.midrib(y, with_numpy=with_numpy) ribs.append([x for x in midrib.get_positions(front, back)]) points += list(midrib[front:back]) nums.append([i + count for i, _ in enumerate(ribs[-1])]) count += len(ribs[-1]) triangles = [] # helper functions def left_triangle(l_i, r_i): return [l_i + 1, l_i, r_i] def right_triangle(l_i, r_i): return [r_i + 1, l_i, r_i] def quad(l_i, r_i): return [l_i + 1, l_i, r_i, r_i + 1] for rib_no, _ in enumerate(ribs[:-1]): num_l = nums[rib_no] num_r = nums[rib_no + 1] pos_l = ribs[rib_no] pos_r = ribs[rib_no + 1] l_i = r_i = 0 while l_i < len(num_l)-1 or r_i < len(num_r)-1: if l_i == len(num_l) - 1: triangles.append(right_triangle(num_l[l_i], num_r[r_i])) r_i += 1 elif r_i == len(num_r) - 1: triangles.append(left_triangle(num_l[l_i], num_r[r_i])) l_i += 1 elif abs(pos_l[l_i] - pos_r[r_i]) == 0: triangles.append(quad(num_l[l_i], num_r[r_i])) r_i += 1 l_i += 1 elif pos_l[l_i] <= pos_r[r_i]: triangles.append(left_triangle(num_l[l_i], num_r[r_i])) l_i += 1 elif pos_r[r_i] < pos_l[l_i]: triangles.append(right_triangle(num_l[l_i], num_r[r_i])) r_i += 1 #connection_info = {cell.rib1: np.array(ribs[0], int), # cell.rib2: np.array(ribs[-1], int)} return Mesh.from_indexed(points, {"panel_"+self.material_code: triangles}, name=self.name)
def get_mesh(self, cell, insert_points=4, project_3d=False): """ get a mesh from a diagonal (2 poly lines) """ left, right = self.get_3d(cell) if insert_points: point_array = [] points2d = [] number_array = [] # create array of points # the outermost points build the segments num_left = len(left) num_right = len(right) count = 0 for y_pos in np.linspace(0., 1., insert_points + 2): # from left to right line_points = [] line_points_2d = [] # TODO: mesh 2d (x, y) -> 3d nodes line_indices = [] num_points = int(num_left * (1. - y_pos) + num_right * y_pos) for x_pos in np.linspace(0., 1., num_points): line_points.append(left[x_pos * (num_left - 1)] * (1. - y_pos) + right[x_pos * (num_right - 1)] * y_pos) line_points_2d.append([x_pos, y_pos]) line_indices.append(count) count += 1 point_array += line_points points2d += line_points_2d number_array.append(line_indices) # outline edge = number_array[0] edge += [line[-1] for line in number_array[1:]] edge += number_array[-1][-2::-1] # last line reversed without the last element edge += [line[0] for line in number_array[1:-1]][::-1] segment = [[edge[i], edge[i +1]] for i in range(len(edge) - 1)] segment.append([edge[-1], edge[0]]) point_array = np.array(point_array) import openglider.mesh.mesh as _mesh if project_3d: points2d = _mesh.map_to_2d(point_array) tri = triangulate.Triangulation(points2d, [edge]) mesh = tri.triangulate(options="Qz") # mesh_info = _mesh.mptriangle.MeshInfo() # mesh_info.set_points(points2d) # mesh_info.set_facets(segment) # mesh = _mesh.custom_triangulation(mesh_info, "Qz") return Mesh.from_indexed(point_array, {"diagonals": list(mesh.elements)}, boundaries={"diagonals": edge}) else: vertices = np.array(list(left) + list(right)[::-1]) polygon = [range(len(vertices))] return Mesh.from_indexed(vertices, {"diagonals": polygon})
def join(self): mesh = Mesh() for obj in self.objects: mesh += obj return mesh
def test_mesh(self): self.rib.holes.append(RibHole(0.2)) Mesh.from_rib(self.rib)