def triangular_section( b: float, h: float, material: pre.Material = pre.DEFAULT_MATERIAL ) -> geometry.Geometry: """Constructs a right angled triangle with points *(0, 0)*, *(b, 0)*, *(0, h)*. :param float b: Base length of triangle :param float h: Height of triangle :param Optional[sectionproperties.pre.pre.Material]: Material to associate with this geometry The following example creates a triangular cross-section with a base width of 10 and height of 10, and generates a mesh with a maximum triangular area of 0.5:: from sectionproperties.pre.library.primitive_sections import triangular_section geometry = triangular_section(b=10, h=10) geometry.create_mesh(mesh_sizes=[0.5]) .. figure:: ../images/sections/triangle_geometry.png :align: center :scale: 40 % Triangular section geometry. .. figure:: ../images/sections/triangle_mesh.png :align: center :scale: 40 % Mesh generated from the above geometry. """ points = [[0, 0], [b, 0], [0, h]] triangle = Polygon(points) return geometry.Geometry(triangle, material)
def rectangular_section( b: float, d: float, material: pre.Material = pre.DEFAULT_MATERIAL ) -> geometry.Geometry: """Constructs a rectangular section with the bottom left corner at the origin *(0, 0)*, with depth *d* and width *b*. :param float d: Depth (y) of the rectangle :param float b: Width (x) of the rectangle :param Optional[sectionproperties.pre.pre.Material]: Material to associate with this geometry The following example creates a rectangular cross-section with a depth of 100 and width of 50, and generates a mesh with a maximum triangular area of 5:: from sectionproperties.pre.library.primitive_sections import rectangular_section geometry = rectangular_section(d=100, b=50) geometry.create_mesh(mesh_sizes=[5]) .. figure:: ../images/sections/rectangle_geometry.png :align: center :scale: 75 % Rectangular section geometry. .. figure:: ../images/sections/rectangle_mesh.png :align: center :scale: 75 % Mesh generated from the above geometry. """ points = [[0, 0], [b, 0], [b, d], [0, d]] rectangle = Polygon(points) return geometry.Geometry(rectangle, material)
def triangular_radius_section( b: float, n_r: float, material: pre.Material = pre.DEFAULT_MATERIAL ) -> geometry.Geometry: """Constructs a right angled isosceles triangle with points *(0, 0)*, *(b, 0)*, *(0, h)* and a concave radius on the hypotenuse. :param float b: Base length of triangle :param int n_r: Number of points discretising the radius :param Optional[sectionproperties.pre.pre.Material]: Material to associate with this geometry The following example creates a triangular radius cross-section with a base width of 6, using *n_r* points to construct the radius, and generates a mesh with a maximum triangular area of 0.5:: from sectionproperties.pre.library.primitive_sections import triangular_radius_section geometry = triangular_radius_section(b=6, n_r=16) geometry.create_mesh(mesh_sizes=[0.5]) .. figure:: ../images/sections/triangle_radius_geometry.png :align: center :scale: 40 % Triangular radius section geometry. .. figure:: ../images/sections/triangle_radius_mesh.png :align: center :scale: 40 % Mesh generated from the above geometry. """ points = [(0, 0)] points += draw_radius(pt=[b, b], r=b, theta=3 * np.pi / 2, n=n_r, ccw=False) triangle = Polygon(points) return geometry.Geometry(triangle, material)
def rectangular_hollow_section( b: float, d: float, t: float, r_out: float, n_r: int, material: pre.Material = pre.DEFAULT_MATERIAL, ) -> geometry.Geometry: """Constructs a rectangular hollow section (RHS) centered at *(b/2, d/2)*, with depth *d*, width *b*, thickness *t* and outer radius *r_out*, using *n_r* points to construct the inner and outer radii. If the outer radius is less than the thickness of the RHS, the inner radius is set to zero. :param float d: Depth of the RHS :param float b: Width of the RHS :param float t: Thickness of the RHS :param float r_out: Outer radius of the RHS :param int n_r: Number of points discretising the inner and outer radii :param Optional[sectionproperties.pre.pre.Material]: Material to associate with this geometry The following example creates an RHS with a depth of 100, a width of 50, a thickness of 6 and an outer radius of 9, using 8 points to discretise the inner and outer radii. A mesh is generated with a maximum triangular area of 2.0:: from sectionproperties.pre.library.steel_sections import rectangular_hollow_section geometry = rectangular_hollow_section(d=100, b=50, t=6, r_out=9, n_r=8) geometry.create_mesh(mesh_sizes=[2.0]) .. figure:: ../images/sections/rhs_geometry.png :align: center :scale: 75 % RHS geometry. .. figure:: ../images/sections/rhs_mesh.png :align: center :scale: 75 % Mesh generated from the above geometry. """ points_inner = [] points_outer = [] # calculate internal radius r_in = max(r_out - t, 0) # construct the outer radius points points_outer += draw_radius([r_out, r_out], r_out, np.pi, n_r) points_outer += draw_radius([b - r_out, r_out], r_out, 1.5 * np.pi, n_r) points_outer += draw_radius([b - r_out, d - r_out], r_out, 0, n_r) points_outer += draw_radius([r_out, d - r_out], r_out, 0.5 * np.pi, n_r) points_inner += draw_radius([t + r_in, t + r_in], r_in, np.pi, n_r) points_inner += draw_radius([b - t - r_in, t + r_in], r_in, 1.5 * np.pi, n_r) points_inner += draw_radius([b - t - r_in, d - t - r_in], r_in, 0, n_r) points_inner += draw_radius([t + r_in, d - t - r_in], r_in, 0.5 * np.pi, n_r) outer = Polygon(points_outer) inner = Polygon(points_inner) return geometry.Geometry(outer - inner, material)
def elliptical_hollow_section( d_y: float, d_x: float, t: float, n: int, material: pre.Material = pre.DEFAULT_MATERIAL, ) -> geometry.Geometry: """Constructs an elliptical hollow section (EHS) centered at the origin *(0, 0)*, with outer vertical diameter *d_y*, outer horizontal diameter *d_x*, and thickness *t*, using *n* points to construct the inner and outer ellipses. :param float d_y: Diameter of the ellipse in the y-dimension :param float d_x: Diameter of the ellipse in the x-dimension :param float t: Thickness of the EHS :param int n: Number of points discretising the inner and outer ellipses :param Optional[sectionproperties.pre.pre.Material]: Material to associate with this geometry The following example creates a EHS discretised with 30 points, with a outer vertical diameter of 25, outer horizontal diameter of 50, and thickness of 2.0, and generates a mesh with a maximum triangular area of 0.5:: from sectionproperties.pre.library.steel_sections import elliptical_hollow_section geometry = elliptical_hollow_section(d_y=25, d_x=50, t=2.0, n=64) geometry.create_mesh(mesh_sizes=[0.5]) .. figure:: ../images/sections/ehs_geometry.png :align: center :scale: 75 % EHS geometry. .. figure:: ../images/sections/ehs_mesh.png :align: center :scale: 75 % Mesh generated from the above geometry. """ points_inner = [] points_outer = [] # loop through each point of the EHS for i in range(n): # determine polar angle theta = i * 2 * np.pi * 1.0 / n # calculate location of outer and inner points x_outer = 0.5 * d_x * np.cos(theta) y_outer = 0.5 * d_y * np.sin(theta) x_inner = ((0.5 * d_x) - t) * np.cos(theta) y_inner = ((0.5 * d_y) - t) * np.sin(theta) # append the current points to the points list points_outer.append([x_outer, y_outer]) points_inner.append([x_inner, y_inner]) outer = Polygon(points_outer) inner = Polygon(points_inner) return geometry.Geometry(outer - inner, material)
def circular_hollow_section( d: float, t: float, n: int, material: pre.Material = pre.DEFAULT_MATERIAL ) -> geometry.Geometry: """Constructs a circular hollow section (CHS) centered at the origin *(0, 0)*, with diameter *d* and thickness *t*, using *n* points to construct the inner and outer circles. :param float d: Outer diameter of the CHS :param float t: Thickness of the CHS :param int n: Number of points discretising the inner and outer circles :param Optional[sectionproperties.pre.pre.Material]: Material to associate with this geometry The following example creates a CHS discretised with 64 points, with a diameter of 48 and thickness of 3.2, and generates a mesh with a maximum triangular area of 1.0:: from sectionproperties.pre.library.steel_sections import circular_hollow_section geometry = circular_hollow_section(d=48, t=3.2, n=64) geometry.create_mesh(mesh_sizes=[1.0]) .. figure:: ../images/sections/chs_geometry.png :align: center :scale: 75 % CHS geometry. .. figure:: ../images/sections/chs_mesh.png :align: center :scale: 75 % Mesh generated from the above geometry. """ points_inner = [] points_outer = [] # loop through each point of the CHS for i in range(n): # determine polar angle theta = i * 2 * np.pi * 1.0 / n # calculate location of outer and inner points x_outer = 0.5 * d * np.cos(theta) y_outer = 0.5 * d * np.sin(theta) x_inner = (0.5 * d - t) * np.cos(theta) y_inner = (0.5 * d - t) * np.sin(theta) # append the current points to the points list points_outer.append([x_outer, y_outer]) points_inner.append([x_inner, y_inner]) inner_circle = Polygon(points_inner) outer_circle = Polygon(points_outer) return geometry.Geometry(outer_circle - inner_circle, material)
def elliptical_section( d_y: float, d_x: float, n: int, material: pre.Material = pre.DEFAULT_MATERIAL ) -> geometry.Geometry: """Constructs a solid ellipse centered at the origin *(0, 0)* with vertical diameter *d_y* and horizontal diameter *d_x*, using *n* points to construct the ellipse. :param float d_y: Diameter of the ellipse in the y-dimension :param float d_x: Diameter of the ellipse in the x-dimension :param int n: Number of points discretising the ellipse :param Optional[sectionproperties.pre.pre.Material]: Material to associate with this geometry The following example creates an elliptical cross-section with a vertical diameter of 25 and horizontal diameter of 50, with 40 points, and generates a mesh with a maximum triangular area of 1.0:: from sectionproperties.pre.library.primitive_sections import elliptical_section geometry = elliptical_section(d_y=25, d_x=50, n=40) geometry.create_mesh(mesh_sizes=[1.0]) .. figure:: ../images/sections/ellipse_geometry.png :align: center :scale: 75 % Elliptical section geometry. .. figure:: ../images/sections/ellipse_mesh.png :align: center :scale: 75 % Mesh generated from the above geometry. """ points = [] # loop through each point on the ellipse for i in range(n): # determine polar angle theta = i * 2 * np.pi * 1.0 / n # calculate location of the point x = 0.5 * d_x * np.cos(theta) y = 0.5 * d_y * np.sin(theta) # append the current point to the points list points.append([x, y]) ellipse = Polygon(points) return geometry.Geometry(ellipse, material)
def circular_section( d: float, n: int, material: pre.Material = pre.DEFAULT_MATERIAL ) -> geometry.Geometry: """Constructs a solid circle centered at the origin *(0, 0)* with diameter *d* and using *n* points to construct the circle. :param float d: Diameter of the circle :param int n: Number of points discretising the circle :param Optional[sectionproperties.pre.pre.Material]: Material to associate with this geometry The following example creates a circular geometry with a diameter of 50 with 64 points, and generates a mesh with a maximum triangular area of 2.5:: from sectionproperties.pre.library.primitive_sections import circular_section geometry = circular_section(d=50, n=64) geometry.create_mesh(mesh_sizes=[2.5]) .. figure:: ../images/sections/circle_geometry.png :align: center :scale: 75 % Circular section geometry. .. figure:: ../images/sections/circle_mesh.png :align: center :scale: 75 % Mesh generated from the above geometry. """ x_off, y_off = (0, 0) points = [] # loop through each point on the circle for i in range(n): # determine polar angle theta = i * 2 * np.pi * 1.0 / n # calculate location of the point x = 0.5 * d * np.cos(theta) + x_off y = 0.5 * d * np.sin(theta) + y_off # append the current point to the points list points.append([x, y]) circle = Polygon(points) return geometry.Geometry(circle, material)
def do_section(b, S, d_mid=1, plot_geom=False): delta = S * d_mid d1 = d_mid - delta d2 = d_mid + delta # compute mesh size ms = d_mid * b / n points = [] points.append([0, 0]) points.append([0, d1]) points.append([b, d2]) points.append([b, 0]) if S < 1.0: trap_geom = geometry.Geometry(Polygon(points)) else: trap_geom = sections.triangular_section(h=d2, b=b) jt = get_section_j(trap_geom, ms, plot_geom) rect_geom = sections.rectangular_section(d=(d1 + d2) / 2, b=b) jr = get_section_j(rect_geom, ms, plot_geom) return jt, jr, d1, d2
def super_t_girder_section( girder_type: int, girder_subtype: int = 2, w: float = 2100, t_w: float = None, t_f: float = 75, material: pre.Material = pre.DEFAULT_MATERIAL, ) -> geometry.Geometry: """Constructs a Super T Girder section to AS5100.5. :param int girder_type: Type of Super T (1 to 5) :param int girder_subtype: Era Super T (1: pre-2001, 2:contemporary) :param float w: Overall width of top flange :param float t_w: Web thickness of the Super-T section (defaults to those of AS5100.5 Tb D3(B)) :param float t_f: Thickness of top flange (VIC (default) = 75 mm; NSW = 90 mm) :param Optional[sectionproperties.pre.pre.Material]: Material to associate with this geometry The following example creates a T5 Super-T section with a 180 mm overlay slab and assigns the different material properties:: import sectionproperties.pre.library.bridge_sections as bridge_sections import sectionproperties.pre.library.standard_sections as standard_sections from sectionproperties.pre.pre import Material from sectionproperties.analysis.section import Section Dslab, w, t_f = 180, 2100, 75 precast = Material( name="65 MPa", elastic_modulus=37.4e3, poissons_ratio=0.2, yield_strength=65, density=2.4e-6, color="grey", ) insitu = Material( name="40 MPa", elastic_modulus=32.8e3, poissons_ratio=0.2, yield_strength=40, density=2.4e-6, color="lightgrey", ) super_t = bridge_sections.super_t_girder_section(girder_type=5, w=w, material=precast) slab = standard_sections.rectangular_section( d=Dslab, b=w, material=insitu ).shift_section(-w / 2, t_f) geom = super_t + slab geom.plot_geometry() geom.create_mesh(mesh_sizes=[500]) sec = Section(geom) sec.plot_mesh() sec.calculate_geometric_properties() sec.calculate_warping_properties() sec.display_results(fmt=".3f") Note that the properties are reported as ``modulus weighted`` properties (e.g. E.A) and can be normalized to the reference material by dividing by that elastic modulus:: A_65 = section.get_ea() / precast.elastic_modulus The reported section centroids are already weighted. .. figure:: ../images/sections/super_tee.png :align: center :scale: 40 % Super Tee Girder. """ if girder_type < 1 or girder_type > 5: msg = "Super-T Girder Type must be between 1 and 5" raise Exception(msg) if girder_subtype not in [1, 2]: msg = "Only 2 subtypes: pre- and post-2001" raise Exception(msg) if girder_type == 5 and girder_subtype == 1: msg = "Only girders T1 to T4 before 2001" raise Exception(msg) # Some super-t constants, refer to AS5100.5, Figure D1(B) d_fillet, b_fillet = 75, 100 d_recess, b_recess = 25, 25 d_chamfer, b_chamfer = 13, 13 web_slope = 10.556 flg_slope = 5.347 w_nom = 1027 if girder_subtype == 1: flg_slope = 5.0 w_nom = 920 # Dims for the specific girder type d, t_b, t_w_nom = get_super_t_girder_dims(girder_type) # Overriding default web thickness? if t_w is None: t_w = t_w_nom # Origin is middle at level of bottom of top flange # Some geometrics of the slope web_hyp = np.sqrt(1 + web_slope**2) web_horiz = t_w * web_slope / web_hyp x_fillet = w_nom / 2 - d_fillet * 1 / web_hyp # initialise points variable points = [] # Right recess pt_b = w_nom / 2 - web_horiz + (t_f - d_recess) / web_slope pt_a = pt_b + b_recess points.append([pt_b, t_f - d_recess]) points.append([pt_a, t_f - d_recess]) points.append([pt_a, t_f]) # Right flange points.append([w / 2, t_f]) points.append([w / 2, d_chamfer]) points.append([w / 2 - b_chamfer, 0]) points.append([w_nom / 2 + b_fillet, 0]) points.append([x_fillet, -d_fillet]) # Bottom outer btm_corner = x_fillet - d / web_slope points.append([btm_corner + d_chamfer / web_slope, -(d - d_chamfer)]) points.append([btm_corner - b_chamfer, -d]) points.append([-btm_corner + b_chamfer, -d]) points.append([-btm_corner - d_chamfer / web_slope, -(d - d_chamfer)]) # Left flange points.append([-x_fillet, -d_fillet]) points.append([-w_nom / 2 - b_fillet, 0]) points.append([-w / 2 + b_chamfer, 0]) points.append([-w / 2, d_chamfer]) points.append([-w / 2, t_f]) # Left Recess points.append([-pt_a, t_f]) points.append([-pt_a, t_f - d_recess]) points.append([-pt_b, t_f - d_recess]) # Bottom inner - find intersection point y10 = t_f - d_recess y20 = -(d - t_b) y_inner = (1 / (1 / web_slope - flg_slope)) * (y10 / web_slope - y20 * flg_slope - pt_b) x_inner = flg_slope * (y20 - y_inner) points.append([x_inner, y_inner]) points.append([0, y20]) points.append([-x_inner, y_inner]) return geometry.Geometry(Polygon(points), material)
def cee_section( d: float, b: float, l: float, t: float, r_out: float, n_r: int, material: pre.Material = pre.DEFAULT_MATERIAL, ) -> geometry.Geometry: """Constructs a Cee section (typical of cold-formed steel) with the bottom left corner at the origin *(0, 0)*, with depth *d*, width *b*, lip *l*, thickness *t* and outer radius *r_out*, using *n_r* points to construct the radius. If the outer radius is less than the thickness of the Cee Section, the inner radius is set to zero. :param float d: Depth of the Cee section :param float b: Width of the Cee section :param float l: Lip of the Cee section :param float t: Thickness of the Cee section :param float r_out: Outer radius of the Cee section :param int n_r: Number of points discretising the outer radius :raises Exception: Lip length must be greater than the outer radius :param Optional[sectionproperties.pre.pre.Material]: Material to associate with this geometry The following example creates a Cee section with a depth of 125, a width of 50, a lip of 30, a thickness of 1.5 and an outer radius of 6, using 8 points to discretise the radius. A mesh is generated with a maximum triangular area of 0.25:: from sectionproperties.pre.library.steel_sections import cee_section geometry = cee_section(d=125, b=50, l=30, t=1.5, r_out=6, n_r=8) geometry.create_mesh(mesh_sizes=[0.25]) .. figure:: ../images/sections/cee_geometry.png :align: center :scale: 75 % Cee section geometry. .. figure:: ../images/sections/cee_mesh.png :align: center :scale: 75 % """ # ensure the lip length is greater than the outer radius if l < r_out: raise Exception("Lip length must be greater than the outer radius") points = [] # calculate internal radius r_in = max(r_out - t, 0) # construct the outer bottom left radius points += draw_radius([r_out, r_out], r_out, np.pi, n_r) # construct the outer bottom right radius points += draw_radius([b - r_out, r_out], r_out, 1.5 * np.pi, n_r) if r_out != l: # add next two points points.append([b, l]) points.append([b - t, l]) # construct the inner bottom right radius points += draw_radius([b - t - r_in, t + r_in], r_in, 0, n_r, False) # construct the inner bottom left radius points += draw_radius([t + r_in, t + r_in], r_in, 1.5 * np.pi, n_r, False) # construct the inner top left radius points += draw_radius([t + r_in, d - t - r_in], r_in, np.pi, n_r, False) # construct the inner top right radius points += draw_radius([b - t - r_in, d - t - r_in], r_in, 0.5 * np.pi, n_r, False) if r_out != l: # add next two points points.append([b - t, d - l]) points.append([b, d - l]) # construct the outer top right radius points += draw_radius([b - r_out, d - r_out], r_out, 0, n_r) # construct the outer top left radius points += draw_radius([r_out, d - r_out], r_out, 0.5 * np.pi, n_r) polygon = Polygon(points) return geometry.Geometry(polygon, material)
def i_girder_section( girder_type: int, material: pre.Material = pre.DEFAULT_MATERIAL) -> geometry.Geometry: """Constructs a precast I girder section to AS5100.5. :param int girder_type: Type of I Girder (1 to 4) :param Optional[sectionproperties.pre.pre.Material]: Material to associate with this geometry As an example, replicate the table shown in AS5100.5 Fig. D1(A):: import pandas as pd import sectionproperties.pre.library.bridge_sections as bridge_sections from sectionproperties.analysis.section import Section df = pd.DataFrame(columns=["Ag", "Zt", "Zb", "I", "dy", "th"]) for i in range(4): geom = bridge_sections.i_girder_section(girder_type=i + 1) dims = bridge_sections.get_i_girder_dims(girder_type=i + 1) d = sum(dims[-5:]) geom.create_mesh(mesh_sizes=[200]) geom.plot_geometry() sec = Section(geom) sec.plot_mesh() sec.calculate_geometric_properties() sec.calculate_warping_properties() A = sec.get_area() th = A / (sec.get_perimeter() / 2) df.loc[i] = [ A, *(sec.get_z()[:2]), sec.get_ic()[0], d + sec.get_c()[1], th, ] print(df) Note that the section depth is obtained by summing the heights from the section dictionary in ``get_i_girder_dims()``. .. figure:: ../images/sections/i_girder.png :align: center :scale: 40 % I Girder. """ if girder_type < 1 or girder_type > 4: msg = "I Girder Type must be between 1 and 4" raise Exception(msg) b_tf, b_bf, b_w, h_tf, h_ts, h_w, h_bs, h_bf = get_i_girder_dims( girder_type) # Some section constants d = sum([h_tf, h_ts, h_w, h_bs, h_bf]) inset_tf = (b_tf - b_w) / 2 inset_bf = (b_bf - b_w) / 2 # initialise points variable points = [] # Origin at centre top; clockwise from top right corner points.append([b_tf / 2, 0]) points.append([b_tf / 2, -h_tf]) points.append([b_tf / 2 - inset_tf, -h_tf - h_ts]) points.append([b_tf / 2 - inset_tf, -h_tf - h_ts - h_w]) points.append([b_bf / 2, -d + h_bf]) points.append([b_bf / 2, -d]) points.append([-b_bf / 2, -d]) points.append([-b_bf / 2, -d + h_bf]) points.append([-b_tf / 2 + inset_tf, -h_tf - h_ts - h_w]) points.append([-b_tf / 2 + inset_tf, -h_tf - h_ts]) points.append([-b_tf / 2, -h_tf]) points.append([-b_tf / 2, 0]) return geometry.Geometry(Polygon(points), material)
def box_girder_section( d: float, b_t: float, b_b: float, t_ft: float, t_fb: float, t_w: float, material: pre.Material = pre.DEFAULT_MATERIAL, ): """Constructs a box girder section centered at at *(max(b_t, b_b)/2, d/2)*, with depth *d*, top width *b_t*, bottom width *b_b*, top flange thickness *t_ft*, bottom flange thickness *t_fb* and web thickness *t_w*. :param float d: Depth of the Box Girder section :param float b_t: Top width of the Box Girder section :param float b_b: Bottom width of the Box Girder section :param float t_ft: Top flange thickness of the Box Girder section :param float t_fb: Bottom flange thickness of the Box Girder section :param float t_w: Web thickness of the Box Girder section The following example creates a Box Girder section with a depth of 1200, a top width of 1200, a bottom width of 400, a top flange thickness of 16, a bottom flange thickness of 12 and a web thickness of 8. A mesh is generated with a maximum triangular area of 5.0:: from sectionproperties.pre.library.steel_sections import box_girder_section geometry = box_girder_section(d=1200, b_t=1200, b_b=400, t_ft=100, t_fb=80, t_w=50) geometry.create_mesh(mesh_sizes=[200.0]) .. figure:: ../images/sections/box_girder_geometry.png :align: center :scale: 75 % Box Girder geometry. .. figure:: ../images/sections/box_girder_mesh.png :align: center :scale: 75 % Mesh generated from the above geometry. """ outer_points = [] inner_points = [] # calculate central axis x_c = max(b_t, b_b) * 0.5 # determine side wall angle if b_t < b_b: phi_b = np.arctan2(d, 0.5 * (b_b - b_t)) phi_t = np.pi - phi_b else: phi_t = np.arctan2(d, 0.5 * (b_t - b_b)) phi_b = np.pi - phi_t # determine inner wall x-offsets x_bot = t_fb / np.tan(np.pi - phi_b) x_top = t_ft / np.tan(np.pi - phi_t) web_x = abs(t_w / np.sin(np.pi - phi_b)) # add outer points outer_points.append([x_c - 0.5 * b_b, 0]) outer_points.append([x_c + 0.5 * b_b, 0]) outer_points.append([x_c + 0.5 * b_t, d]) outer_points.append([x_c - 0.5 * b_t, d]) # add inner points inner_points.append([x_c - 0.5 * b_b - x_bot + web_x, t_fb]) inner_points.append([x_c + 0.5 * b_b + x_bot - web_x, t_fb]) inner_points.append([x_c + 0.5 * b_t + x_top - web_x, d - t_ft]) inner_points.append([x_c - 0.5 * b_t - x_top + web_x, d - t_ft]) outer_polygon = Polygon(outer_points) inner_polygon = Polygon(inner_points) return geometry.Geometry(outer_polygon - inner_polygon, material)
def zed_section( d: float, b_l: float, b_r: float, l: float, t: float, r_out: float, n_r: int, material: pre.Material = pre.DEFAULT_MATERIAL, ) -> geometry.Geometry: """Constructs a zed section with the bottom left corner at the origin *(0, 0)*, with depth *d*, left flange width *b_l*, right flange width *b_r*, lip *l*, thickness *t* and outer radius *r_out*, using *n_r* points to construct the radius. If the outer radius is less than the thickness of the Zed Section, the inner radius is set to zero. :param float d: Depth of the zed section :param float b_l: Left flange width of the Zed section :param float b_r: Right flange width of the Zed section :param float l: Lip of the Zed section :param float t: Thickness of the Zed section :param float r_out: Outer radius of the Zed section :param int n_r: Number of points discretising the outer radius :param Optional[sectionproperties.pre.pre.Material]: Material to associate with this geometry The following example creates a zed section with a depth of 100, a left flange width of 40, a right flange width of 50, a lip of 20, a thickness of 1.2 and an outer radius of 5, using 8 points to discretise the radius. A mesh is generated with a maximum triangular area of 0.15:: from sectionproperties.pre.library.steel_sections import zed_section geometry = zed_section(d=100, b_l=40, b_r=50, l=20, t=1.2, r_out=5, n_r=8) geometry.create_mesh(mesh_sizes=[0.15]) .. figure:: ../images/sections/zed_geometry.png :align: center :scale: 75 % zed section geometry. .. figure:: ../images/sections/zed_mesh.png :align: center :scale: 75 % """ # ensure the lip length is greater than the outer radius if l < r_out: raise Exception("Lip length must be greater than the outer radius") points = [] # calculate internal radius r_in = max(r_out - t, 0) # construct the outer bottom left radius points += draw_radius([r_out, r_out], r_out, np.pi, n_r) # construct the outer bottom right radius points += draw_radius([b_r - r_out, r_out], r_out, 1.5 * np.pi, n_r) if r_out != l: # add next two points points.append([b_r, l]) points.append([b_r - t, l]) # construct the inner bottom right radius points += draw_radius([b_r - t - r_in, t + r_in], r_in, 0, n_r, False) # construct the inner bottom left radius points += draw_radius([t + r_in, t + r_in], r_in, 1.5 * np.pi, n_r, False) # construct the outer top right radius points += draw_radius([t - r_out, d - r_out], r_out, 0, n_r) # construct the outer top left radius points += draw_radius([t - b_l + r_out, d - r_out], r_out, 0.5 * np.pi, n_r) if r_out != l: # add the next two points points.append([t - b_l, d - l]) points.append([t - b_l + t, d - l]) # construct the inner top left radius points += draw_radius([2 * t - b_l + r_in, d - t - r_in], r_in, np.pi, n_r, False) # construct the inner top right radius points += draw_radius([-r_in, d - t - r_in], r_in, 0.5 * np.pi, n_r, False) polygon = Polygon(points) return geometry.Geometry(polygon, material)
def polygon_hollow_section( d: float, t: float, n_sides: int, r_in: float = 0, n_r: int = 1, rot: float = 0, material: pre.Material = pre.DEFAULT_MATERIAL, ) -> geometry.Geometry: """Constructs a regular hollow polygon section centered at *(0, 0)*, with a pitch circle diameter of bounding polygon *d*, thickness *t*, number of sides *n_sides* and an optional inner radius *r_in*, using *n_r* points to construct the inner and outer radii (if radii is specified). :param float d: Pitch circle diameter of the outer bounding polygon (i.e. diameter of circle that passes through all vertices of the outer polygon) :param float t: Thickness of the polygon section wall :param float r_in: Inner radius of the polygon corners. By default, if not specified, a polygon with no corner radii is generated. :param int n_r: Number of points discretising the inner and outer radii, ignored if no inner radii is specified :param float rot: Initial counterclockwise rotation in degrees. By default bottom face is aligned with x axis. :param Optional[sectionproperties.pre.pre.Material]: Material to associate with this geometry :raises Exception: Number of sides in polygon must be greater than or equal to 3 The following example creates an Octagonal section (8 sides) with a diameter of 200, a thickness of 6 and an inner radius of 20, using 12 points to discretise the inner and outer radii. A mesh is generated with a maximum triangular area of 5:: from sectionproperties.pre.library.steel_sections import polygon_hollow_section geometry = polygon_hollow_section(d=200, t=6, n_sides=8, r_in=20, n_r=12) geometry.create_mesh(mesh_sizes=[5]) .. figure:: ../images/sections/polygon_geometry.png :align: center :scale: 75 % Octagonal section geometry. .. figure:: ../images/sections/polygon_mesh.png :align: center :scale: 75 % Mesh generated from the above geometry. """ outer_points = [] inner_points = [] if n_sides < 3: msg = "n_sides required to be greater than 3 for polygon_section()" raise Exception(msg) # initial rotation rot = rot * np.pi / 180 # radians # determine triangular segment angle alpha = 2 * np.pi / n_sides # radians # determine distance from origin to point perpendicular on face of side a_out = d / 2 * np.cos(alpha / 2) a_in = a_out - t # determine side length for outer & inner faces neglecting radii side_length_out = d * np.sin(alpha / 2) side_length_in = a_in / a_out * side_length_out # check limit on internal radii, if exceeded then radii merge to circle if r_in > a_in: r_in = a_in circle = True else: circle = False # calculate external radius, if r_in is zero, r_out also is zero if r_in == 0: r_out = 0 n_r = 1 else: r_out = r_in + t # equivalent side length of half the corner radii triangular segment c_out = r_out * (side_length_out / 2) / a_out c_in = r_in * (side_length_in / 2) / a_in # determine straight side length between corner radii (if present) side_length_straight_out = side_length_out - (2 * c_out) side_length_straight_in = side_length_in - (2 * c_in) # temp list for repeating geometry outer_base_points = [] inner_base_points = [] # start at bottom face, constructing one corner radii, then rotate by initial rotation + # alpha and repeat for n_side number of times to form full section perimeter # construct the first radius (bottom right) for i in range(n_r): # determine polar angle theta = 1 / 2 * np.pi + i * 1.0 / max(1, n_r - 1) * alpha # calculate location of inner and outer points x_outer = side_length_straight_out / 2 - r_out * np.cos(theta) y_outer = -a_out + r_out - r_out * np.sin(theta) x_inner = side_length_straight_in / 2 - r_in * np.cos(theta) y_inner = -a_in + r_in - r_in * np.sin(theta) # append the current temporary points to the temporary points list outer_base_points.append([x_outer, y_outer]) inner_base_points.append([x_inner, y_inner]) for i in range(n_sides): for point in outer_base_points: point_new = rotate(point, alpha * i + rot) outer_points.append(point_new) for point in inner_base_points: point_new = rotate(point, alpha * i + rot) inner_points.append(point_new) outer_polygon = Polygon(outer_points) inner_polygon = Polygon(inner_points) return geometry.Geometry(outer_polygon - inner_polygon, material)
def cruciform_section( d: float, b: float, t: float, r: float, n_r: int, material: pre.Material = pre.DEFAULT_MATERIAL, ) -> geometry.Geometry: """Constructs a cruciform section centered at the origin *(0, 0)*, with depth *d*, width *b*, thickness *t* and root radius *r*, using *n_r* points to construct the root radius. :param float d: Depth of the cruciform section :param float b: Width of the cruciform section :param float t: Thickness of the cruciform section :param float r: Root radius of the cruciform section :param int n_r: Number of points discretising the root radius :param Optional[sectionproperties.pre.pre.Material]: Material to associate with this geometry The following example creates a cruciform section with a depth of 250, a width of 175, a thickness of 12 and a root radius of 16, using 16 points to discretise the radius. A mesh is generated with a maximum triangular area of 5.0:: from sectionproperties.pre.library.primitive_sections import cruciform_section geometry = cruciform_section(d=250, b=175, t=12, r=16, n_r=16) geometry.create_mesh(mesh_sizes=[5.0]) .. figure:: ../images/sections/cruciform_geometry.png :align: center :scale: 75 % Cruciform section geometry. .. figure:: ../images/sections/cruciform_mesh.png :align: center :scale: 75 % """ points = [] # add first two points points.append([-t * 0.5, -d * 0.5]) points.append([t * 0.5, -d * 0.5]) # construct the bottom right radius pt = [0.5 * t + r, -0.5 * t - r] points += draw_radius(pt, r, np.pi, n_r, False) # add the next two points points.append([0.5 * b, -t * 0.5]) points.append([0.5 * b, t * 0.5]) # construct the top right radius pt = [0.5 * t + r, 0.5 * t + r] points += draw_radius(pt, r, 1.5 * np.pi, n_r, False) # add the next two points points.append([t * 0.5, 0.5 * d]) points.append([-t * 0.5, 0.5 * d]) # construct the top left radius pt = [-0.5 * t - r, 0.5 * t + r] points += draw_radius(pt, r, 0, n_r, False) # add the next two points points.append([-0.5 * b, t * 0.5]) points.append([-0.5 * b, -t * 0.5]) # construct the bottom left radius pt = [-0.5 * t - r, -0.5 * t - r] points += draw_radius(pt, r, 0.5 * np.pi, n_r, False) polygon = Polygon(points) return geometry.Geometry(polygon, material)
def angle_section( d: float, b: float, t: float, r_r: float, r_t: float, n_r: int, material: pre.Material = pre.DEFAULT_MATERIAL, ) -> geometry.Geometry: """Constructs an angle section with the bottom left corner at the origin *(0, 0)*, with depth *d*, width *b*, thickness *t*, root radius *r_r* and toe radius *r_t*, using *n_r* points to construct the radii. :param float d: Depth of the angle section :param float b: Width of the angle section :param float t: Thickness of the angle section :param float r_r: Root radius of the angle section :param float r_t: Toe radius of the angle section :param int n_r: Number of points discretising the radii :param Optional[sectionproperties.pre.pre.Material]: Material to associate with this geometry The following example creates an angle section with a depth of 150, a width of 100, a thickness of 8, a root radius of 12 and a toe radius of 5, using 16 points to discretise the radii. A mesh is generated with a maximum triangular area of 2.0:: from sectionproperties.pre.library.steel_sections import angle_section geometry = angle_section(d=150, b=100, t=8, r_r=12, r_t=5, n_r=16) geometry.create_mesh(mesh_sizes=[2.0]) .. figure:: ../images/sections/angle_geometry.png :align: center :scale: 75 % Angle section geometry. .. figure:: ../images/sections/angle_mesh.png :align: center :scale: 75 % """ if r_t > t: raise ValueError( "The radius of the toe (r_t) cannot be larger than the toe thickness (t)." ) points = [] # add first two points points.append([0, 0]) points.append([b, 0]) # construct the bottom toe radius pt = [b - r_t, t - r_t] points += draw_radius(pt, r_t, 0, n_r) # construct the root radius pt = [t + r_r, t + r_r] points += draw_radius(pt, r_r, 1.5 * np.pi, n_r, False) # construct the top toe radius pt = [t - r_t, d - r_t] points += draw_radius(pt, r_t, 0, n_r) # add the next point points.append([0, d]) polygon = Polygon(points) return geometry.Geometry(polygon, material)
def i_section( d: float, b: float, t_f: float, t_w: float, r: float, n_r: int, material: pre.Material = pre.DEFAULT_MATERIAL, ) -> geometry.Geometry: # More specific description and less ambiguous? e.g. not an "S" section. """Constructs an I Section centered at *(b/2, d/2)*, with depth *d*, width *b*, flange thickness *t_f*, web thickness *t_w*, and root radius *r*, using *n_r* points to construct the root radius. :param float d: Depth of the I Section :param float b: Width of the I Section :param float t_f: Flange thickness of the I Section :param float t_w: Web thickness of the I Section :param float r: Root radius of the I Section :param int n_r: Number of points discretising the root radius :param Optional[sectionproperties.pre.pre.Material]: Material to associate with this geometry The following example creates an I Section with a depth of 203, a width of 133, a flange thickness of 7.8, a web thickness of 5.8 and a root radius of 8.9, using 16 points to discretise the root radius. A mesh is generated with a maximum triangular area of 3.0:: from sectionproperties.pre.library.steel_sections import i_section geometry = i_section(d=203, b=133, t_f=7.8, t_w=5.8, r=8.9, n_r=16) geometry.create_mesh(mesh_sizes=[3.0]) .. figure:: ../images/sections/isection_geometry.png :align: center :scale: 75 % I Section geometry. .. figure:: ../images/sections/isection_mesh.png :align: center :scale: 75 % Mesh generated from the above geometry. """ points = [] # add first three points points.append([0, 0]) points.append([b, 0]) points.append([b, t_f]) # construct the bottom right radius pt = [b * 0.5 + t_w * 0.5 + r, t_f + r] points += draw_radius(pt, r, 1.5 * np.pi, n_r, False) # construct the top right radius pt = [b * 0.5 + t_w * 0.5 + r, d - t_f - r] points += draw_radius(pt, r, np.pi, n_r, False) # add the next four points points.append([b, d - t_f]) points.append([b, d]) points.append([0, d]) points.append([0, d - t_f]) # construct the top left radius pt = [b * 0.5 - t_w * 0.5 - r, d - t_f - r] points += draw_radius(pt, r, 0.5 * np.pi, n_r, False) # construct the bottom left radius pt = [b * 0.5 - t_w * 0.5 - r, t_f + r] points += draw_radius(pt, r, 0, n_r, False) # # add the last point points.append([0, t_f]) i_section = Polygon(points) return geometry.Geometry(i_section, material)
def tee_section( d: float, b: float, t_f: float, t_w: float, r: float, n_r: int, material: pre.Material = pre.DEFAULT_MATERIAL, ) -> geometry.Geometry: """Constructs a Tee section with the top left corner at *(0, d)*, with depth *d*, width *b*, flange thickness *t_f*, web thickness *t_w* and root radius *r*, using *n_r* points to construct the root radius. :param float d: Depth of the Tee section :param float b: Width of the Tee section :param float t_f: Flange thickness of the Tee section :param float t_w: Web thickness of the Tee section :param float r: Root radius of the Tee section :param int n_r: Number of points discretising the root radius :param Optional[sectionproperties.pre.pre.Material]: Material to associate with this geometry The following example creates a Tee section with a depth of 200, a width of 100, a flange thickness of 12, a web thickness of 6 and a root radius of 8, using 8 points to discretise the root radius. A mesh is generated with a maximum triangular area of 3.0:: from sectionproperties.pre.library.steel_sections import tee_section geometry = tee_section(d=200, b=100, t_f=12, t_w=6, r=8, n_r=8) geometry.create_mesh(mesh_sizes=[3.0]) .. figure:: ../images/sections/tee_geometry.png :align: center :scale: 75 % Tee section geometry. .. figure:: ../images/sections/tee_mesh.png :align: center :scale: 75 % Mesh generated from the above geometry. """ points = [] # add first two points points.append([b * 0.5 - t_w * 0.5, 0]) points.append([b * 0.5 + t_w * 0.5, 0]) # construct the top right radius pt = [b * 0.5 + t_w * 0.5 + r, d - t_f - r] points += draw_radius(pt, r, np.pi, n_r, False) # add next four points points.append([b, d - t_f]) points.append([b, d]) points.append([0, d]) points.append([0, d - t_f]) # construct the top left radius pt = [b * 0.5 - t_w * 0.5 - r, d - t_f - r] points += draw_radius(pt, r, 0.5 * np.pi, n_r, False) polygon = Polygon(points) return geometry.Geometry(polygon, material)
def tapered_flange_channel( d: float, b: float, t_f: float, t_w: float, r_r: float, r_f: float, alpha: float, n_r: int, material: pre.Material = pre.DEFAULT_MATERIAL, ) -> geometry.Geometry: """Constructs a Tapered Flange Channel section with the bottom left corner at the origin *(0, 0)*, with depth *d*, width *b*, mid-flange thickness *t_f*, web thickness *t_w*, root radius *r_r*, flange radius *r_f* and flange angle *alpha*, using *n_r* points to construct the radii. :param float d: Depth of the Tapered Flange Channel section :param float b: Width of the Tapered Flange Channel section :param float t_f: Mid-flange thickness of the Tapered Flange Channel section (measured at the point equidistant from the face of the web to the edge of the flange) :param float t_w: Web thickness of the Tapered Flange Channel section :param float r_r: Root radius of the Tapered Flange Channel section :param float r_f: Flange radius of the Tapered Flange Channel section :param float alpha: Flange angle of the Tapered Flange Channel section (degrees) :param int n_r: Number of points discretising the radii :param Optional[sectionproperties.pre.pre.Material]: Material to associate with this geometry The following example creates a Tapered Flange Channel section with a depth of 10, a width of 3.5, a mid-flange thickness of 0.575, a web thickness of 0.475, a root radius of 0.575, a flange radius of 0.4 and a flange angle of 8°, using 16 points to discretise the radii. A mesh is generated with a maximum triangular area of 0.02:: from sectionproperties.pre.library.steel_sections import tapered_flange_channel geometry = tapered_flange_channel( d=10, b=3.5, t_f=0.575, t_w=0.475, r_r=0.575, r_f=0.4, alpha=8, n_r=16 ) geometry.create_mesh(mesh_sizes=[0.02]) .. figure:: ../images/sections/taperedchannel_geometry.png :align: center :scale: 75 % Tapered flange channel geometry. .. figure:: ../images/sections/taperedchannel_mesh.png :align: center :scale: 75 % Mesh generated from the above geometry. """ points = [] # calculate alpha in radians alpha_rad = np.pi * alpha / 180 # calculate the height of the flange toe and dimensions of the straight x1 = b * 0.5 - t_w * 0.5 - r_f * (1 - np.sin(alpha_rad)) y1 = x1 * np.tan(alpha_rad) x2 = b * 0.5 - t_w * 0.5 - r_r * (1 - np.sin(alpha_rad)) y2 = x2 * np.tan(alpha_rad) y_t = t_f - y1 - r_f * np.cos(alpha_rad) # add first two points points.append([0, 0]) points.append([b, 0]) # construct the bottom right flange toe radius if r_f == 0: points.append([b, y_t]) else: for i in range(n_r): # determine polar angle theta = i * 1.0 / max(1, n_r - 1) * (np.pi * 0.5 - alpha_rad) # calculate the locations of the radius points x = b - r_f + r_f * np.cos(theta) y = y_t + r_f * np.sin(theta) # append the current points to the points list points.append([x, y]) # construct the bottom right root radius if r_r == 0: points.append([t_w, t_f + y2]) else: for i in range(n_r): # determine polar angle theta = (3.0 / 2 * np.pi - alpha_rad) - ( i * 1.0 / max(1, n_r - 1) * (np.pi * 0.5 - alpha_rad) ) # calculate the locations of the radius points x = t_w + r_r + r_r * np.cos(theta) y = t_f + y2 + r_r * np.cos(alpha_rad) + r_r * np.sin(theta) # append the current points to the points list points.append([x, y]) # construct the top right root radius if r_r == 0: points.append([t_w, d - t_f - y2]) else: for i in range(n_r): # determine polar angle theta = np.pi - i * 1.0 / max(1, n_r - 1) * (np.pi * 0.5 - alpha_rad) # calculate the locations of the radius points x = t_w + r_r + r_r * np.cos(theta) y = d - t_f - y2 - r_r * np.cos(alpha_rad) + r_r * np.sin(theta) # append the current points to the points list points.append([x, y]) # construct the top right flange toe radius if r_f == 0: points.append([b, d - y_t]) else: for i in range(n_r): # determine polar angle theta = (3.0 * np.pi / 2 + alpha_rad) + ( i * 1.0 / max(1, n_r - 1) * (np.pi * 0.5 - alpha_rad) ) # calculate the locations of the radius points x = b - r_f + r_f * np.cos(theta) y = d - y_t + r_f * np.sin(theta) # append the current points to the points list points.append([x, y]) # add the final two points points.append([b, d]) points.append([0, d]) polygon = Polygon(points) return geometry.Geometry(polygon, material)
def bulb_section( d: float, b: float, t: float, r: float, n_r: int, d_b: float = None, material: pre.Material = pre.DEFAULT_MATERIAL, ) -> geometry.Geometry: """Constructs a bulb section with the bottom left corner at the point *(-t / 2, 0)*, with depth *d*, bulb depth *d_b*, bulb width *b*, web thickness *t* and radius *r*, using *n_r* points to construct the radius. :param float d: Depth of the section :param float b: Bulb width :param float t: Web thickness :param float r: Bulb radius :param float d_b: Depth of the bulb (automatically calculated for standard sections, if provided the section may have sharp edges) :param int n_r: Number of points discretising the radius :param Optional[sectionproperties.pre.pre.Material]: Material to associate with this geometry The following example creates a bulb section with a depth of 240, a width of 34, a web thickness of 12 and a bulb radius of 16, using 16 points to discretise the radius. A mesh is generated with a maximum triangular area of 5.0:: from sectionproperties.pre.library.steel_sections import bulb_section geometry = bulb_section(d=240, b=34, t=12, r=10, n_r=16) geometry.create_mesh(mesh_sizes=[5.0]) .. figure:: ../images/sections/bulb_geometry.png :align: center :scale: 75 % Bulb section geometry. .. figure:: ../images/sections/bulb_mesh.png :align: center :scale: 75 % Mesh generated from the above geometry. """ if d_b is None: d_b = r * np.cos(np.pi / 3) / np.cos(np.pi / 6) + r + b * np.tan(np.pi / 6) points = [] # add first two points points.append([-t * 0.5, 0]) points.append([t * 0.5, 0]) # test of additional radius dc = r / np.sin(2 / 3 * np.pi / 2) ptb0 = [t * 0.5 + dc * np.cos(np.pi / 6), d - d_b - dc * np.cos(np.pi / 3)] points += draw_radius(ptb0, r, np.pi, n_r, False, np.pi / 3) # end of test of additional radius ptb = [b + t * 0.5 - r, d - r] dzero = ((b + t * 0.5 - r - t * 0.5) ** 2 + (d - r - d + d_b) ** 2) ** 0.5 # build radius points += draw_radius(ptb, r, -np.pi * 1 / 3, n_r, True, np.pi / 3) points += draw_radius(ptb, r, 0, n_r, True) # build the top part points.append([b + t * 0.5 - r, d]) points.append([-t * 0.5, d]) polygon = Polygon(points) return geometry.Geometry(polygon, material)
def channel_section( d: float, b: float, t_f: float, t_w: float, r: float, n_r: int, material: pre.Material = pre.DEFAULT_MATERIAL, ) -> geometry.Geometry: """Constructs a parallel-flange channel (PFC) section with the bottom left corner at the origin *(0, 0)*, with depth *d*, width *b*, flange thickness *t_f*, web thickness *t_w* and root radius *r*, using *n_r* points to construct the root radius. :param float d: Depth of the PFC section :param float b: Width of the PFC section :param float t_f: Flange thickness of the PFC section :param float t_w: Web thickness of the PFC section :param float r: Root radius of the PFC section :param int n_r: Number of points discretising the root radius :param shift: Vector that shifts the cross-section by *(x, y)* :type shift: list[float, float] :param Optional[sectionproperties.pre.pre.Material]: Material to associate with this geometry The following example creates a PFC section with a depth of 250, a width of 90, a flange thickness of 15, a web thickness of 8 and a root radius of 12, using 8 points to discretise the root radius. A mesh is generated with a maximum triangular area of 5.0:: from sectionproperties.pre.library.steel_sections import channel_section geometry = channel_section(d=250, b=90, t_f=15, t_w=8, r=12, n_r=8) geometry.create_mesh(mesh_sizes=[5.0]) .. figure:: ../images/sections/pfc_geometry.png :align: center :scale: 75 % PFC geometry. .. figure:: ../images/sections/pfc_mesh.png :align: center :scale: 75 % Mesh generated from the above geometry. """ points = [] # add first three points points.append([0, 0]) points.append([b, 0]) points.append([b, t_f]) # construct the bottom right radius pt = [t_w + r, t_f + r] points += draw_radius(pt, r, 1.5 * np.pi, n_r, False) # construct the top right radius pt = [t_w + r, d - t_f - r] points += draw_radius(pt, r, np.pi, n_r, False) # add last three points points.append([b, d - t_f]) points.append([b, d]) points.append([0, d]) polygon = Polygon(points) return geometry.Geometry(polygon, material)
def mono_i_section( d: float, b_t: float, b_b: float, t_ft: float, t_fb: float, t_w: float, r: float, n_r: int, material: pre.Material = pre.DEFAULT_MATERIAL, ) -> geometry.Geometry: """Constructs a monosymmetric I Section centered at *(max(b_t, b_b)/2, d/2)*, with depth *d*, top flange width *b_t*, bottom flange width *b_b*, top flange thickness *t_ft*, top flange thickness *t_fb*, web thickness *t_w*, and root radius *r*, using *n_r* points to construct the root radius. :param float d: Depth of the I Section :param float b_t: Top flange width :param float b_b: Bottom flange width :param float t_ft: Top flange thickness of the I Section :param float t_fb: Bottom flange thickness of the I Section :param float t_w: Web thickness of the I Section :param float r: Root radius of the I Section :param int n_r: Number of points discretising the root radius :param Optional[sectionproperties.pre.pre.Material]: Material to associate with this geometry The following example creates a monosymmetric I Section with a depth of 200, a top flange width of 50, a top flange thickness of 12, a bottom flange width of 130, a bottom flange thickness of 8, a web thickness of 6 and a root radius of 8, using 16 points to discretise the root radius. A mesh is generated with a maximum triangular area of 3.0:: from sectionproperties.pre.library.steel_sections import mono_i_section geometry = mono_i_section( d=200, b_t=50, b_b=130, t_ft=12, t_fb=8, t_w=6, r=8, n_r=16 ) geometry.create_mesh(mesh_sizes=[3.0]) .. figure:: ../images/sections/monoisection_geometry.png :align: center :scale: 75 % I Section geometry. .. figure:: ../images/sections/monoisection_mesh.png :align: center :scale: 75 % Mesh generated from the above geometry. """ points = [] # calculate central axis x_central = max(b_t, b_b) * 0.5 # add first three points points.append([x_central - b_b * 0.5, 0]) points.append([x_central + b_b * 0.5, 0]) points.append([x_central + b_b * 0.5, t_fb]) # construct the bottom right radius pt = [x_central + t_w * 0.5 + r, t_fb + r] points += draw_radius(pt, r, 1.5 * np.pi, n_r, False) # construct the top right radius pt = [x_central + t_w * 0.5 + r, d - t_ft - r] points += draw_radius(pt, r, np.pi, n_r, False) # add the next four points points.append([x_central + b_t * 0.5, d - t_ft]) points.append([x_central + b_t * 0.5, d]) points.append([x_central - b_t * 0.5, d]) points.append([x_central - b_t * 0.5, d - t_ft]) # construct the top left radius pt = [x_central - t_w * 0.5 - r, d - t_ft - r] points += draw_radius(pt, r, 0.5 * np.pi, n_r, False) # construct the bottom left radius pt = [x_central - t_w * 0.5 - r, t_fb + r] points += draw_radius(pt, r, 0, n_r, False) # add the last point points.append([x_central - b_b * 0.5, t_fb]) polygon = Polygon(points) return geometry.Geometry(polygon, material)