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 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 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 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 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)
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 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 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 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)