SymPy-1-13-中文文档-四十一-

布客飞龙
42 阅读49分钟

SymPy 1.13 中文文档（四十一）

原文：docs.sympy.org/latest/index.html

控制系统绘图

原文：docs.sympy.org/latest/modules/physics/control/control_plots.html

该模块包含用于控制系统中一些常见绘图的绘图函数。如果用户需要绘图，则需要外部依赖 Matplotlib。如果仅需获得绘图的数值数据，则需要外部依赖 NumPy。

极点-零点图

control_plots.pole_zero_plot(pole_color='blue', pole_markersize=10, zero_color='orange', zero_markersize=7, grid=True, show_axes=True, show=True, **kwargs)

返回系统的极点-零点图（也称为 PZ 图或 PZ 图）。

极点-零点图是系统极点和零点的图形表示。它在复平面上绘制，圆形标记表示系统的零点，'x'形标记表示系统的极点。

参数：

系统：SISOLinearTimeInvariant 类型系统

用于计算极点-零点图的系统。

极点颜色：str, tuple, 可选

绘图中极点的颜色。默认颜色为蓝色。颜色可以作为 Matplotlib 颜色字符串或在 0-1 范围内的 3 元组提供。

极点标记大小：数字，可选

用于标记绘图中极点的标记的大小。默认极点标记大小为 10。

零点颜色：str, tuple, 可选

绘图中零点的颜色。默认颜色为橙色。颜色可以作为 Matplotlib 颜色字符串或在 0-1 范围内的 3 元组提供。

零点标记大小：数字，可选

用于标记绘图中零点的标记的大小。默认零点标记大小为 7。

网格：布尔值，可选

如果为True，则绘图将具有网格。默认为 True。

显示坐标轴：布尔值，可选

如果为True，则显示坐标轴。默认为 False。

显示：布尔值，可选

如果为True，则显示绘图，否则返回等效的 matplotlib plot对象。默认为 True。

示例

>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunction
>>> from sympy.physics.control.control_plots import pole_zero_plot
>>> tf1 = TransferFunction(s**2 + 1, s**4 + 4*s**3 + 6*s**2 + 5*s + 2, s)
>>> pole_zero_plot(tf1)

(png, hires.png, pdf)

../../../_images/control_plots-1.png

另请参见

pole_zero_numerical_data

参考文献

[R730]

en.wikipedia.org/wiki/Pole%E2%80%93zero_plot

control_plots.pole_zero_numerical_data()

返回系统的极点和零点的数值数据。它被pole_zero_plot内部使用，以获取用于绘制极点和零点的数据。用户可以使用这些数据进一步分析系统的动态或使用不同的后端/绘图模块进行绘制。

参数：

系统：SISOLinearTimeInvariant

要计算极点-零点数据的系统。

返回：

元组：(零点, 极点)

zeros = 系统的零点。复数的 NumPy 数组。poles = 系统的极点。复数的 NumPy 数组。

引发：

NotImplementedError

当未传递 SISO LTI 系统时。

当系统中存在时间延迟项时。

ValueError

当系统中存在多个自由符号时。传递函数中唯一的变量应该是 Laplace 变换的变量。

示例

>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunction
>>> from sympy.physics.control.control_plots import pole_zero_numerical_data
>>> tf1 = TransferFunction(s**2 + 1, s**4 + 4*s**3 + 6*s**2 + 5*s + 2, s)
>>> pole_zero_numerical_data(tf1)   
([-0.+1.j  0.-1.j], [-2\. +0.j        -0.5+0.8660254j -0.5-0.8660254j -1\. +0.j       ])

另请参阅

pole_zero_plot

Bode 图

control_plots.bode_plot(initial_exp=-5, final_exp=5, grid=True, show_axes=False, show=True, freq_unit='rad/sec', phase_unit='rad', phase_unwrap=True, **kwargs)

返回连续时间系统的 Bode 相位和幅值图。

参数：

system：SISOLinearTimeInvariant 类型

要计算其 Bode Plot 的 LTI SISO 系统。

initial_exp：Number，可选

半对数图的初始 10 的指数。默认为-5。

final_exp：Number，可选

半对数图的最终 10 的指数。默认为 5。

show：boolean，可选

如果为True，则显示绘图，否则将返回等效的 matplotlib plot对象。默认为 True。

prec：int，可选

点坐标值的小数点精度。默认为 8。

grid：boolean，可选

如果为True，则绘图将具有网格。默认为 True。

show_axes：boolean，可选

如果为True，则显示坐标轴。默认为 False。

freq_unit：string，可选

用户可以在'rad/sec'（弧度/秒）和'Hz'（赫兹）之间选择频率单位。

phase_unit：string，可选

用户可以在'rad'（弧度）和'deg'（度）之间选择相位单位。

示例

>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunction
>>> from sympy.physics.control.control_plots import bode_plot
>>> tf1 = TransferFunction(1*s**2 + 0.1*s + 7.5, 1*s**4 + 0.12*s**3 + 9*s**2, s)
>>> bode_plot(tf1, initial_exp=0.2, final_exp=0.7)

（png，hires.png，pdf)

../../../_images/control_plots-2.png

另请参见

bode_magnitude_plot，bode_phase_plot

control_plots.bode_magnitude_plot(initial_exp=-5, final_exp=5, color='b', show_axes=False, grid=True, show=True, freq_unit='rad/sec', **kwargs)

返回连续时间系统的 Bode 幅值图。

请参阅bode_plot以获取所有参数。

control_plots.bode_phase_plot(initial_exp=-5, final_exp=5, color='b', show_axes=False, grid=True, show=True, freq_unit='rad/sec', phase_unit='rad', phase_unwrap=True, **kwargs)

返回连续时间系统的 Bode 相位图。

请参阅bode_plot以获取所有参数。

control_plots.bode_magnitude_numerical_data(initial_exp=-5, final_exp=5, freq_unit='rad/sec', **kwargs)

返回系统 Bode 幅值图的数值数据。它由bode_magnitude_plot在绘制 Bode 幅值图时内部使用。用户可以使用这些数据进一步分析系统的动态或使用不同的后端/绘图模块进行绘图。

参数：

system：SISOLinearTimeInvariant

要计算其数据的系统。

initial_exp：Number，可选

半对数图的初始 10 的指数。默认为-5。

final_exp：Number，可选

半对数图的最终指数为 10。默认为 5。

freq_unit : 字符串，可选

用户可以在 'rad/sec'（弧度/秒）和 'Hz'（赫兹）之间选择频率单位。

返回：

tuple : (x, y)

x = Bode 幅度图的 x 轴数值。y = Bode 幅度图的 y 轴数值。

抛出：

NotImplementedError

未传递 SISO 线性时不变系统时。

当系统中存在时间延迟项时。

ValueError

当系统中存在超过一个自由符号时。传递函数中唯一的变量应为拉普拉斯变换的变量。

提供了错误的频率单位作为输入时。

示例

>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunction
>>> from sympy.physics.control.control_plots import bode_magnitude_numerical_data
>>> tf1 = TransferFunction(s**2 + 1, s**4 + 4*s**3 + 6*s**2 + 5*s + 2, s)
>>> bode_magnitude_numerical_data(tf1)   
([1e-05, 1.5148378120533502e-05,..., 68437.36188804005, 100000.0],
[-6.020599914256786, -6.0205999155219505,..., -193.4117304087953, -200.00000000260573])

参见

bode_magnitude_plot, bode_phase_numerical_data

control_plots.bode_phase_numerical_data(initial_exp=-5, final_exp=5, freq_unit='rad/sec', phase_unit='rad', phase_unwrap=True, **kwargs)

返回系统的 Bode 相位图的数值数据。这些数据由 bode_phase_plot 内部使用，以获取绘制 Bode 相位图所需的数据。用户可以使用这些数据进一步分析系统的动态或使用不同的后端/绘图模块进行绘图。

参数：

system : SISOLinearTimeInvariant

要计算 Bode 相位图数据的系统。

initial_exp : 数字，可选

半对数图的初始指数为 10。默认为 -5。

final_exp : 数字，可选

半对数图的最终指数为 10。默认为 5。

freq_unit : 字符串，可选

用户可以在 'rad/sec'（弧度/秒）和 'Hz'（赫兹）之间选择频率单位。

phase_unit : 字符串，可选

用户可以在 'rad'（弧度）和 'deg'（度）之间选择相位单位。

phase_unwrap : 布尔值，可选

默认设置为 True。

返回：

tuple : (x, y)

x = Bode 相位图的 x 轴数值。y = Bode 相位图的 y 轴数值。

抛出：

NotImplementedError

未传递 SISO 线性时不变系统时。

当系统中存在时间延迟项时。

ValueError

当系统中存在超过一个自由符号时。传递函数中唯一的变量应为拉普拉斯变换的变量。

提供了错误的频率或相位单位作为输入时。

示例

>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunction
>>> from sympy.physics.control.control_plots import bode_phase_numerical_data
>>> tf1 = TransferFunction(s**2 + 1, s**4 + 4*s**3 + 6*s**2 + 5*s + 2, s)
>>> bode_phase_numerical_data(tf1)   
([1e-05, 1.4472354033813751e-05, 2.035581932165858e-05,..., 47577.3248186011, 67884.09326036123, 100000.0],
[-2.5000000000291665e-05, -3.6180885085e-05, -5.08895483066e-05,...,-3.1415085799262523, -3.14155265358979])

参见

bode_magnitude_plot, bode_phase_numerical_data

冲激响应图

control_plots.impulse_response_plot(color='b', prec=8, lower_limit=0, upper_limit=10, show_axes=False, grid=True, show=True, **kwargs)

返回连续时间系统的单位冲激响应（输入为 Dirac-Delta 函数）。

参数：

system : SISOLinearTimeInvariant 类型

要计算冲激响应的 LTI SISO 系统。

color : 字符串，元组，可选

线条的颜色。默认为蓝色。

show : 布尔值，可选

如果为True，则显示绘图，否则返回等效的 matplotlib plot对象。默认为 True。

lower_limit : 数字，可选

绘图范围的下限。默认为 0。

upper_limit : 数字，可选

绘图范围的上限。默认为 10。

prec : int, optional

点坐标值的小数点精度。默认为 8。

show_axes : 布尔值，可选

如果为True，则显示坐标轴。默认为 False。

grid : 布尔值，可选

如果为True，则绘图将具有网格。默认为 True。

示例

>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunction
>>> from sympy.physics.control.control_plots import impulse_response_plot
>>> tf1 = TransferFunction(8*s**2 + 18*s + 32, s**3 + 6*s**2 + 14*s + 24, s)
>>> impulse_response_plot(tf1)

(png, hires.png, pdf)

../../../_images/control_plots-3.png

另请参阅

step_response_plot, ramp_response_plot

引用

[R731]

www.mathworks.com/help/control/ref/dynamicsystem.impulse.html

control_plots.impulse_response_numerical_data(prec=8, lower_limit=0, upper_limit=10, **kwargs)

返回 SISO 连续时间系统脉冲响应绘图中点的数值。默认使用自适应采样。如果用户想要获取均匀采样响应，则应将adaptive关键字传递为False，并且必须将n作为附加关键字传递。有关更多详细信息，请参阅类sympy.plotting.series.LineOver1DRangeSeries的参数。

参数：

system : SISO 线性时不变

要计算脉冲响应数据的系统。

prec : int, optional

点坐标值的小数点精度。默认为 8。

lower_limit : 数字，可选

绘图范围的下限。默认为 0。

upper_limit : 数字，可选

绘图范围的上限。默认为 10。

kwargs :

将其他关键字参数传递给底层sympy.plotting.series.LineOver1DRangeSeries类。

返回：

tuple : (x, y)

x = 脉冲响应中点的时间轴值。NumPy 数组。y = 脉冲响应中点的幅度轴值。NumPy 数组。

引发：

NotImplementedError

当未传递 SISO LTI 系统时。

当系统中存在时间延迟项时。

ValueError

当系统中存在多个自由符号时。传输函数中唯一的变量应为拉普拉斯变换的变量。

当lower_limit参数小于 0 时。

示例

>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunction
>>> from sympy.physics.control.control_plots import impulse_response_numerical_data
>>> tf1 = TransferFunction(s, s**2 + 5*s + 8, s)
>>> impulse_response_numerical_data(tf1)   
([0.0, 0.06616480200395854,... , 9.854500743565858, 10.0],
[0.9999999799999999, 0.7042848373025861,...,7.170748906965121e-13, -5.1901263495547205e-12])

另请参阅

impulse_response_plot

阶跃响应图

control_plots.step_response_plot(color='b', prec=8, lower_limit=0, upper_limit=10, show_axes=False, grid=True, show=True, **kwargs)

返回连续时间系统的阶跃响应。当输入信号为阶跃函数时，系统的响应即为阶跃响应。

参数：

系统：SISOLinearTimeInvariant 类型

要计算阶跃响应的 LTI SISO 系统。

颜色：str，元组，可选

线的颜色。默认为蓝色。

显示：布尔值，可选

如果为True，则显示绘图，否则返回等效的 matplotlib plot对象。默认为 True。

下限：数值，可选

绘图范围的下限。默认为 0。

上限：数值，可选

绘图范围的上限。默认为 10。

精度：整数，可选

点坐标值的小数点精度。默认为 8。

显示坐标轴：布尔值，可选

如果为True，则显示坐标轴。默认为 False。

网格：布尔值，可选

如果为True，则绘图将包含网格。默认为 True。

示例

>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunction
>>> from sympy.physics.control.control_plots import step_response_plot
>>> tf1 = TransferFunction(8*s**2 + 18*s + 32, s**3 + 6*s**2 + 14*s + 24, s)
>>> step_response_plot(tf1)

（png，hires.png，pdf)

../../../_images/control_plots-4.png

另请参阅

impulse_response_plot，ramp_response_plot

参考文献

[R732]

www.mathworks.com/help/control/ref/lti.step.html

control_plots.step_response_numerical_data(prec=8, lower_limit=0, upper_limit=10, **kwargs)

返回 SISO 连续时间系统阶跃响应图中点的数值。默认情况下使用自适应采样。如果用户希望获取均匀采样响应，则应将adaptive kwarg 传递为False并将n作为额外的 kwargs 传递。有关更多详细信息，请参阅sympy.plotting.series.LineOver1DRangeSeries类的参数。

参数：

系统：SISOLinearTimeInvariant

要计算单位阶跃响应数据的系统。

精度：整数，可选

点坐标值的小数点精度。默认为 8。

下限：数值，可选

绘图范围的下限。默认为 0。

上限：数值，可选

绘图范围的上限。默认为 10。

kwargs：

其他关键字参数传递给底层的sympy.plotting.series.LineOver1DRangeSeries类。

返回：

tuple：(x, y)

x = 步响应中点的时间轴值。NumPy 数组。 y = 步响应中点的振幅轴值。NumPy 数组。

抛出：

NotImplementedError

当未传递 SISO LTI 系统时。

当系统中存在时间延迟项时。

ValueError

当系统中存在多个自由符号时。传递函数中唯一的变量应为拉普拉斯变换的变量。

当 lower_limit 参数小于 0 时。

示例

>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunction
>>> from sympy.physics.control.control_plots import step_response_numerical_data
>>> tf1 = TransferFunction(s, s**2 + 5*s + 8, s)
>>> step_response_numerical_data(tf1)   
([0.0, 0.025413462339411542, 0.0484508722725343, ... , 9.670250533855183, 9.844291913708725, 10.0],
[0.0, 0.023844582399907256, 0.042894276802320226, ..., 6.828770759094287e-12, 6.456457160755703e-12])

另请参阅

step_response_plot

坡度响应图

control_plots.ramp_response_plot(slope=1, color='b', prec=8, lower_limit=0, upper_limit=10, show_axes=False, grid=True, show=True, **kwargs)

返回连续时间系统的坡度响应。

坡度函数定义为通过原点的直线（(f(x) = mx)）。用户可以通过用户变量来变化坡度函数的斜率，默认值为 1。

参数：

system：SISOLinearTimeInvariant 类型

要计算坡度响应的 LTI SISO 系统。

slope：数字，可选

输入坡度函数的斜率。默认为 1。

color：字符串，元组，可选

线的颜色。默认为蓝色。

show：布尔值，可选

如果为 True，则显示绘图，否则返回等效的 matplotlib plot 对象。默认为 True。

lower_limit：数字，可选

绘图范围的下限。默认为 0。

upper_limit：数字，可选

绘图范围的上限。默认为 10。

prec：整数，可选

点坐标值的小数点精度。默认为 8。

show_axes：布尔值，可选

如果为 True，将显示坐标轴。默认为 False。

grid：布尔值，可选

如果为 True，绘图将带有网格。默认为 True。

示例

>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunction
>>> from sympy.physics.control.control_plots import ramp_response_plot
>>> tf1 = TransferFunction(s, (s+4)*(s+8), s)
>>> ramp_response_plot(tf1, upper_limit=2)

(png, hires.png, pdf)

../../../_images/control_plots-5.png

另请参阅

step_response_plot, impulse_response_plot

参考资料

[R733]

zh.wikipedia.org/wiki/%E5%9D%A1%E5%87%BD%E5%87%BD%E6%95%B0

control_plots.ramp_response_numerical_data(slope=1, prec=8, lower_limit=0, upper_limit=10, **kwargs)

返回 SISO 连续时间系统斜坡响应图中点的数值。默认使用自适应采样。如果用户希望获得均匀采样的响应，则应传递 adaptive kwarg 为 False 并将 n 作为额外的 kwargs 传递。有关更多详细信息，请参阅类 sympy.plotting.series.LineOver1DRangeSeries 的参数。

参数：

system : SISOLinearTimeInvariant

计算斜坡响应数据的系统。

slope : 数字，可选

输入斜坡函数的斜率。默认为 1。

prec : 整数，可选

点坐标值的小数点精度。默认为 8。

lower_limit : 数字，可选

绘图范围的下限。默认为 0。

upper_limit : 数字，可选

绘图范围的上限。默认为 10。

kwargs :

其他关键字参数传递给底层 sympy.plotting.series.LineOver1DRangeSeries 类。

返回：

tuple : (x, y)

x = 斜坡响应图中点的时间轴值。NumPy 数组。 y = 斜坡响应图中点的振幅轴值。NumPy 数组。

引发异常：

NotImplementedError

当 SISO LTI 系统未经过。

当系统中存在时间延迟项时。

ValueError

当系统中存在多个自由符号时。传递函数中唯一的变量应该是拉普拉斯变换的变量。

当 lower_limit 参数小于 0 时。

当 slope 为负数时。

示例

>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunction
>>> from sympy.physics.control.control_plots import ramp_response_numerical_data
>>> tf1 = TransferFunction(s, s**2 + 5*s + 8, s)
>>> ramp_response_numerical_data(tf1)   
(([0.0, 0.12166980856813935,..., 9.861246379582118, 10.0],
[1.4504508011325967e-09, 0.006046440489058766,..., 0.12499999999568202, 0.12499999999661349]))

另请参见

ramp_response_plot

连续介质力学

原文：docs.sympy.org/latest/modules/physics/continuum_mechanics/index.html

梁

  • 梁（文档字符串）

  • 使用奇异函数解决梁弯曲问题

桁架

  • 桁架（文档字符串）

电缆

  • 电缆（文档字符串）

梁（文档字符串）

原文：docs.sympy.org/latest/modules/physics/continuum_mechanics/beam.html

该模块可用于解决力学中带有奇性函数的二维梁弯曲问题。

class sympy.physics.continuum_mechanics.beam.Beam(length, elastic_modulus, second_moment, area=A, variable=x, base_char='C')

梁是一种通过抵抗弯曲主要承受载荷的结构元素。梁的特征在于其横截面轮廓（截面二阶矩）、长度和材料。

注意

在解决梁弯曲问题时必须使用一致的符号约定；结果将自动遵循所选择的符号约定。然而，所选择的符号约定必须遵守以下规则：在梁轴的正侧（相对于当前截面），给定正剪力的载荷力产生负弯矩，如下所示（弯曲箭头显示正弯矩和旋转）：

../../../_images/allowed-sign-conventions.png

例子

有一根长度为 4 米的梁。从梁的中点到末端施加了一个恒定分布载荷 6 N/m。梁下面有两个简支，一个在起点，另一个在梁的终点。梁的末端受到限制。

使用向下力为正的符号约定。

>>> from sympy.physics.continuum_mechanics.beam import Beam
>>> from sympy import symbols, Piecewise
>>> E, I = symbols('E, I')
>>> R1, R2 = symbols('R1, R2')
>>> b = Beam(4, E, I)
>>> b.apply_load(R1, 0, -1)
>>> b.apply_load(6, 2, 0)
>>> b.apply_load(R2, 4, -1)
>>> b.bc_deflection = [(0, 0), (4, 0)]
>>> b.boundary_conditions
{'deflection': [(0, 0), (4, 0)], 'slope': []}
>>> b.load
R1*SingularityFunction(x, 0, -1) + R2*SingularityFunction(x, 4, -1) + 6*SingularityFunction(x, 2, 0)
>>> b.solve_for_reaction_loads(R1, R2)
>>> b.load
-3*SingularityFunction(x, 0, -1) + 6*SingularityFunction(x, 2, 0) - 9*SingularityFunction(x, 4, -1)
>>> b.shear_force()
3*SingularityFunction(x, 0, 0) - 6*SingularityFunction(x, 2, 1) + 9*SingularityFunction(x, 4, 0)
>>> b.bending_moment()
3*SingularityFunction(x, 0, 1) - 3*SingularityFunction(x, 2, 2) + 9*SingularityFunction(x, 4, 1)
>>> b.slope()
(-3*SingularityFunction(x, 0, 2)/2 + SingularityFunction(x, 2, 3) - 9*SingularityFunction(x, 4, 2)/2 + 7)/(E*I)
>>> b.deflection()
(7*x - SingularityFunction(x, 0, 3)/2 + SingularityFunction(x, 2, 4)/4 - 3*SingularityFunction(x, 4, 3)/2)/(E*I)
>>> b.deflection().rewrite(Piecewise)
(7*x - Piecewise((x**3, x >= 0), (0, True))/2
 - 3*Piecewise(((x - 4)**3, x >= 4), (0, True))/2
 + Piecewise(((x - 2)**4, x >= 2), (0, True))/4)/(E*I)

计算长度为 L 的完全符号梁的支反应。梁下面有两个简支，一个在起点，另一个在梁的终点。梁的末端受到限制。梁上载荷为：

  • 一个向下的点载荷 P1，在 L/4 处施加

  • 一个向上的点载荷 P2，在 L/8 处施加

  • 一个逆时针力矩 M1，在 L/2 处施加

  • 一个顺时针力矩 M2，在 3*L/4 处施加

  • 一个分布恒定载荷 q1，向下施加，从 L/2 开始到 3*L/4

  • 一个分布恒定载荷 q2，向上施加，从 3*L/4 开始到 L

不需要为符号负载做任何假设。但是，定义一个正长度将有助于算法计算解决方案。

>>> E, I = symbols('E, I')
>>> L = symbols("L", positive=True)
>>> P1, P2, M1, M2, q1, q2 = symbols("P1, P2, M1, M2, q1, q2")
>>> R1, R2 = symbols('R1, R2')
>>> b = Beam(L, E, I)
>>> b.apply_load(R1, 0, -1)
>>> b.apply_load(R2, L, -1)
>>> b.apply_load(P1, L/4, -1)
>>> b.apply_load(-P2, L/8, -1)
>>> b.apply_load(M1, L/2, -2)
>>> b.apply_load(-M2, 3*L/4, -2)
>>> b.apply_load(q1, L/2, 0, 3*L/4)
>>> b.apply_load(-q2, 3*L/4, 0, L)
>>> b.bc_deflection = [(0, 0), (L, 0)]
>>> b.solve_for_reaction_loads(R1, R2)
>>> print(b.reaction_loads[R1])
(-3*L**2*q1 + L**2*q2 - 24*L*P1 + 28*L*P2 - 32*M1 + 32*M2)/(32*L)
>>> print(b.reaction_loads[R2])
(-5*L**2*q1 + 7*L**2*q2 - 8*L*P1 + 4*L*P2 + 32*M1 - 32*M2)/(32*L) 

property applied_loads

返回施加在梁对象上的所有载荷的列表。列表中的每个载荷都是形式为（值，起始，顺序，结束）的元组。

例子

有一根长度为 4 米的梁。在梁的起点以顺时针方向施加了一个大小为 3 Nm 的力矩。从距离起点 2 米处梁顶部施加了大小为 4 N 的点载荷。另一个大小为 5 N 的点载荷在同一位置施加。

>>> from sympy.physics.continuum_mechanics.beam import Beam
>>> from sympy import symbols
>>> E, I = symbols('E, I')
>>> b = Beam(4, E, I)
>>> b.apply_load(-3, 0, -2)
>>> b.apply_load(4, 2, -1)
>>> b.apply_load(5, 2, -1)
>>> b.load
-3*SingularityFunction(x, 0, -2) + 9*SingularityFunction(x, 2, -1)
>>> b.applied_loads
[(-3, 0, -2, None), (4, 2, -1, None), (5, 2, -1, None)] 

apply_load(value, start, order, end=None)

此方法将所给定的载荷加到特定的梁对象上。

参数：

value：可符号化

插入的值应具有单位 [Force/(Distance**(n+1)]，其中 n 是施加载荷的顺序。施加载荷的单位：

  • 对于弯矩，单位 = kN*m
  • 对于点载荷，单位 = kN
  • 对于恒定分布载荷，单位 = kN/m
  • 对于坡道载荷，单位 = kN/m/m
  • 对于抛物线坡道载荷，单位 = kN/m/m/m
  • … 等等。

start：可符号化

应用载荷的起始点。对于点力和点力矩，这是应用位置。

order：整数

应用载荷的顺序。

  • 对于力矩，order = -2
  • 对于点载荷，order = -1
  • 对于恒定分布载荷，order = 0
  • 对于坡道载荷，order = 1
  • 对于抛物线坡道载荷，order = 2
  • …等等。

end：可符号化，可选

如果载荷在梁的长度内有一个端点，则可以使用的可选参数。

示例

有一根长度为 4 米的梁。在梁的起点顺时针方向施加一个大小为 3 Nm 的力矩。从梁的顶部在距起点 2 米处施加一个大小为 4 N 的点载荷，以及在距离梁起点 2 米到 3 米处施加一个大小为 2 N/m 的抛物线坡道载荷。

>>> from sympy.physics.continuum_mechanics.beam import Beam
>>> from sympy import symbols
>>> E, I = symbols('E, I')
>>> b = Beam(4, E, I)
>>> b.apply_load(-3, 0, -2)
>>> b.apply_load(4, 2, -1)
>>> b.apply_load(-2, 2, 2, end=3)
>>> b.load
-3*SingularityFunction(x, 0, -2) + 4*SingularityFunction(x, 2, -1) - 2*SingularityFunction(x, 2, 2) + 2*SingularityFunction(x, 3, 0) + 4*SingularityFunction(x, 3, 1) + 2*SingularityFunction(x, 3, 2) 

apply_support(loc, type='fixed')

此方法将支持应用于特定的梁对象，并返回未知反应载荷符号。

参数：

loc：可符号化的

支座应用位置的点位。

type：字符串

确定应用的梁支座类型。要应用零自由度的支座结构，type = “fixed”；要应用一个自由度的支座结构，type = “pin”；要应用两个自由度的支座结构，type = “roller”

返回：

符号或符号元组

未知反应载荷作为符号。- 如果 type = “pin”或“roller”，则为 Symbol(reaction_force)；如果 type = “fixed”，则为 Symbol(reaction_force)，Symbol(reaction_moment)

示例

有一根长度为 20 米的梁。在梁的末端顺时针方向施加一个大小为 100 Nm 的力矩。从梁的顶部在距起点 10 米处施加一个大小为 8 N 的点载荷。在梁的起点有一个固定支座，末端有一个滚动支座。

使用上升力和顺时针力矩为正的符号约定。

>>> from sympy.physics.continuum_mechanics.beam import Beam
>>> from sympy import symbols
>>> E, I = symbols('E, I')
>>> b = Beam(20, E, I)
>>> p0, m0 = b.apply_support(0, 'fixed')
>>> p1 = b.apply_support(20, 'roller')
>>> b.apply_load(-8, 10, -1)
>>> b.apply_load(100, 20, -2)
>>> b.solve_for_reaction_loads(p0, m0, p1)
>>> b.reaction_loads
{M_0: 20, R_0: -2, R_20: 10}
>>> b.reaction_loads[p0]
-2
>>> b.load
20*SingularityFunction(x, 0, -2) - 2*SingularityFunction(x, 0, -1)
- 8*SingularityFunction(x, 10, -1) + 100*SingularityFunction(x, 20, -2)
+ 10*SingularityFunction(x, 20, -1) 

property area

梁的横截面积。

bending_moment()

返回一个 Singularity Function 表达式，表示 Beam 对象的弯矩曲线。

示例

有一根长度为 30 米的梁。在梁的末端顺时针方向施加一个大小为 120 Nm 的力矩。从梁的起点顶部施加一个大小为 8 N 的点载荷。梁下有两个简支。一个在末端，另一个距起点 10 米处。在两个支座处都限制挠度。

使用上升力和顺时针力矩为正的符号约定。

>>> from sympy.physics.continuum_mechanics.beam import Beam
>>> from sympy import symbols
>>> E, I = symbols('E, I')
>>> R1, R2 = symbols('R1, R2')
>>> b = Beam(30, E, I)
>>> b.apply_load(-8, 0, -1)
>>> b.apply_load(R1, 10, -1)
>>> b.apply_load(R2, 30, -1)
>>> b.apply_load(120, 30, -2)
>>> b.bc_deflection = [(10, 0), (30, 0)]
>>> b.solve_for_reaction_loads(R1, R2)
>>> b.bending_moment()
8*SingularityFunction(x, 0, 1) - 6*SingularityFunction(x, 10, 1) - 120*SingularityFunction(x, 30, 0) - 2*SingularityFunction(x, 30, 1) 

property boundary_conditions

返回应用在梁上的边界条件字典。字典有三个关键词，分别是 moment、slope 和 deflection。每个关键词的值是一个元组列表，每个元组以(location, value)的格式表示边界条件的位置和值。

示例

有一根长度为 4 米的梁。在 0 处的弯矩应为 4，在 4 处应为 0。梁在 0 处的斜率应为 1。挠度在 0 处应为 2。

>>> from sympy.physics.continuum_mechanics.beam import Beam
>>> from sympy import symbols
>>> E, I = symbols('E, I')
>>> b = Beam(4, E, I)
>>> b.bc_deflection = [(0, 2)]
>>> b.bc_slope = [(0, 1)]
>>> b.boundary_conditions
{'deflection': [(0, 2)], 'slope': [(0, 1)]}

这里梁的挠度应在0处为2。类似地，梁在0处的斜率应为1。

property cross_section

梁的横截面

deflection()

返回表示梁弹性曲线或挠度的奇异函数表达式。

示例

有一根长度为 30 米的梁。在梁的末端顺时针方向施加了 120 Nm 大小的弯矩。从梁的起点顶部施加了 8 N 大小的点载荷。梁下方有两个简支。一个在梁的末端，另一个距起点 10 米处。在两个支座处限制挠度。

使用上升力和顺时针力矩为正的符号约定。

>>> from sympy.physics.continuum_mechanics.beam import Beam
>>> from sympy import symbols
>>> E, I = symbols('E, I')
>>> R1, R2 = symbols('R1, R2')
>>> b = Beam(30, E, I)
>>> b.apply_load(-8, 0, -1)
>>> b.apply_load(R1, 10, -1)
>>> b.apply_load(R2, 30, -1)
>>> b.apply_load(120, 30, -2)
>>> b.bc_deflection = [(10, 0), (30, 0)]
>>> b.solve_for_reaction_loads(R1, R2)
>>> b.deflection()
(4000*x/3 - 4*SingularityFunction(x, 0, 3)/3 + SingularityFunction(x, 10, 3)
 + 60*SingularityFunction(x, 30, 2) + SingularityFunction(x, 30, 3)/3 - 12000)/(E*I) 

draw(pictorial=True)

返回表示梁图的绘图对象。特别是，图表可能包括：

  • 梁。

  • 垂直黑箭头代表点载荷和支反力（如果已使用apply_load方法添加）。

  • 圆形箭头表示弯矩。

  • 阴影区域表示分布载荷。

  • 如果apply_support已执行。

  • 如果使用join方法创建了复合梁，并指定了铰链，它将显示为白色圆盘。

图表显示梁的上侧正载荷和下侧负载荷。如果两个或更多分布载荷沿相同区域的相同方向作用，则函数将将它们相加。

注意

用户在输入载荷值时必须小心。绘图函数假定一种符号约定，用于绘制载荷。给定右手坐标系与 XYZ 坐标，假定梁的长度沿正 X 轴。绘图函数将正载荷（带有 n > -2）识别为沿负 Y 方向作用的载荷和正力矩作用的正 Z 方向。

参数：

图解：布尔值（默认=True）

设置pictorial=True将仅创建梁图的图解（按比例缩放）。另一方面，pictorial=False将在图表上创建具有精确尺寸的梁图。

示例

>>> from sympy.physics.continuum_mechanics.beam import Beam
>>> from sympy import symbols
>>> P1, P2, M = symbols('P1, P2, M')
>>> E, I = symbols('E, I')
>>> b = Beam(50, 20, 30)
>>> b.apply_load(-10, 2, -1)
>>> b.apply_load(15, 26, -1)
>>> b.apply_load(P1, 10, -1)
>>> b.apply_load(-P2, 40, -1)
>>> b.apply_load(90, 5, 0, 23)
>>> b.apply_load(10, 30, 1, 50)
>>> b.apply_load(M, 15, -2)
>>> b.apply_load(-M, 30, -2)
>>> p50 = b.apply_support(50, "pin")
>>> p0, m0 = b.apply_support(0, "fixed")
>>> p20 = b.apply_support(20, "roller")
>>> p = b.draw()  
>>> p  
Plot object containing:
[0]: cartesian line: 25*SingularityFunction(x, 5, 0) - 25*SingularityFunction(x, 23, 0)
+ SingularityFunction(x, 30, 1) - 20*SingularityFunction(x, 50, 0)
- SingularityFunction(x, 50, 1) + 5 for x over (0.0, 50.0)
[1]: cartesian line: 5 for x over (0.0, 50.0)
...
>>> p.show()

(png, hires.png, pdf)

../../../_images/beam-1.png

property elastic_modulus

杨氏模量的梁。

property ild_moment

返回 I.L.D.弯矩方程。

property ild_reactions

返回一个字典，表示 I.L.D.反力。

property ild_shear

返回 I.L.D.剪切方程。

join(beam, via='fixed')

此方法将两个梁连接以形成新的复合梁系统。传递的 Beam 类实例附加到调用对象的右端。此方法可用于形成具有弹性模量或二阶矩不连续值的梁。

参数：

梁：Beam 类对象

将与调用对象右侧连接的 Beam 对象。

通过：字符串

说明两个梁对象如何连接 - 对于轴向固定的梁，通过=”fixed” - 对于通过铰链连接的梁，通过=”hinge”

示例

有一根长度为 4 米的悬臂梁。前 2 米的惯性矩为(1.5*I)，末端为(I)。在自由端施加一个大小为 4 N 的点载荷。

>>> from sympy.physics.continuum_mechanics.beam import Beam
>>> from sympy import symbols
>>> E, I = symbols('E, I')
>>> R1, R2 = symbols('R1, R2')
>>> b1 = Beam(2, E, 1.5*I)
>>> b2 = Beam(2, E, I)
>>> b = b1.join(b2, "fixed")
>>> b.apply_load(20, 4, -1)
>>> b.apply_load(R1, 0, -1)
>>> b.apply_load(R2, 0, -2)
>>> b.bc_slope = [(0, 0)]
>>> b.bc_deflection = [(0, 0)]
>>> b.solve_for_reaction_loads(R1, R2)
>>> b.load
80*SingularityFunction(x, 0, -2) - 20*SingularityFunction(x, 0, -1) + 20*SingularityFunction(x, 4, -1)
>>> b.slope()
(-((-80*SingularityFunction(x, 0, 1) + 10*SingularityFunction(x, 0, 2) - 10*SingularityFunction(x, 4, 2))/I + 120/I)/E + 80.0/(E*I))*SingularityFunction(x, 2, 0)
- 0.666666666666667*(-80*SingularityFunction(x, 0, 1) + 10*SingularityFunction(x, 0, 2) - 10*SingularityFunction(x, 4, 2))*SingularityFunction(x, 0, 0)/(E*I)
+ 0.666666666666667*(-80*SingularityFunction(x, 0, 1) + 10*SingularityFunction(x, 0, 2) - 10*SingularityFunction(x, 4, 2))*SingularityFunction(x, 2, 0)/(E*I) 

property length

梁的长度。

property load

返回表示梁对象载荷分布曲线的奇异函数表达式。

示例

有一根长度为 4 米的梁。在梁的起点顺时针方向施加一个大小为 3 Nm 的弯矩。从梁的起点 2 米处顶部施加一个 4 N 的点载荷，以及从梁的起点 3 米处开始施加大小为 2 N/m 的抛物线坡度载荷。

>>> from sympy.physics.continuum_mechanics.beam import Beam
>>> from sympy import symbols
>>> E, I = symbols('E, I')
>>> b = Beam(4, E, I)
>>> b.apply_load(-3, 0, -2)
>>> b.apply_load(4, 2, -1)
>>> b.apply_load(-2, 3, 2)
>>> b.load
-3*SingularityFunction(x, 0, -2) + 4*SingularityFunction(x, 2, -1) - 2*SingularityFunction(x, 3, 2) 

max_bmoment()

返回梁对象中最大剪力及其坐标。

max_deflection()

返回梁对象中最大挠度点及其对应的挠度值。

max_shear_force()

返回梁对象中最大剪力及其坐标。

plot_bending_moment(subs=None)

返回梁对象中弯矩曲线的绘图。

参数：

subs：字典

包含符号作为键和相应值的 Python 字典。

示例

有一根长度为 8 米的梁。从梁的中点到末端施加一个 10 KN/m 的恒定分布载荷。梁下方有两个简支，一个在起点，另一个在终点。此外，从梁顶部距起点 4 米处施加一个 5 KN 的点载荷。取 E = 200 GPa 和 I = 400*(10**-6) 米**4。

使用向下力为正的符号约定。

>>> from sympy.physics.continuum_mechanics.beam import Beam
>>> from sympy import symbols
>>> R1, R2 = symbols('R1, R2')
>>> b = Beam(8, 200*(10**9), 400*(10**-6))
>>> b.apply_load(5000, 2, -1)
>>> b.apply_load(R1, 0, -1)
>>> b.apply_load(R2, 8, -1)
>>> b.apply_load(10000, 4, 0, end=8)
>>> b.bc_deflection = [(0, 0), (8, 0)]
>>> b.solve_for_reaction_loads(R1, R2)
>>> b.plot_bending_moment()
Plot object containing:
[0]: cartesian line: 13750*SingularityFunction(x, 0, 1) - 5000*SingularityFunction(x, 2, 1)
- 5000*SingularityFunction(x, 4, 2) + 31250*SingularityFunction(x, 8, 1)
+ 5000*SingularityFunction(x, 8, 2) for x over (0.0, 8.0)

(png, hires.png, pdf)

../../../_images/beam-2.png

plot_deflection(subs=None)

返回梁对象挠曲线的绘图。

参数：

subs：字典

包含符号作为键和相应值的 Python 字典。

示例

有一根长度为 8 米的梁。从梁的中点到末端施加一个 10 KN/m 的恒定分布载荷。梁下方有两个简支，一个在起点，另一个在终点。此外，从梁顶部距起点 4 米处施加一个 5 KN 的点载荷。取 E = 200 GPa 和 I = 400*(10**-6) 米**4。

使用向下力为正的符号约定。

>>> from sympy.physics.continuum_mechanics.beam import Beam
>>> from sympy import symbols
>>> R1, R2 = symbols('R1, R2')
>>> b = Beam(8, 200*(10**9), 400*(10**-6))
>>> b.apply_load(5000, 2, -1)
>>> b.apply_load(R1, 0, -1)
>>> b.apply_load(R2, 8, -1)
>>> b.apply_load(10000, 4, 0, end=8)
>>> b.bc_deflection = [(0, 0), (8, 0)]
>>> b.solve_for_reaction_loads(R1, R2)
>>> b.plot_deflection()
Plot object containing:
[0]: cartesian line: 0.00138541666666667*x - 2.86458333333333e-5*SingularityFunction(x, 0, 3)
+ 1.04166666666667e-5*SingularityFunction(x, 2, 3) + 5.20833333333333e-6*SingularityFunction(x, 4, 4)
- 6.51041666666667e-5*SingularityFunction(x, 8, 3) - 5.20833333333333e-6*SingularityFunction(x, 8, 4)
for x over (0.0, 8.0)

(png, hires.png, pdf)

../../../_images/beam-3.png

plot_ild_moment(subs=None)

在移动载荷的作用下，为弯矩作用线图绘制函数。此函数应在调用 solve_for_ild_moment()后调用。

参数：

subs：字典

包含符号作为键和相应值的 Python 字典。

示例

有一根长度为 12 米的梁。梁下方有两个简支，一个在起点，另一个在 8 米处。在 1kN 移动载荷的作用下，在距离起点 4 米处的弯矩 I.L.D.作图。

使用下行力的符号约定为正。

>>> from sympy import symbols
>>> from sympy.physics.continuum_mechanics.beam import Beam
>>> E, I = symbols('E, I')
>>> R_0, R_8 = symbols('R_0, R_8')
>>> b = Beam(12, E, I)
>>> p0 = b.apply_support(0, 'roller')
>>> p8 = b.apply_support(8, 'roller')
>>> b.solve_for_ild_reactions(1, R_0, R_8)
>>> b.solve_for_ild_moment(4, 1, R_0, R_8)
>>> b.ild_moment
Piecewise((-x/2, x < 4), (x/2 - 4, x > 4))
>>> b.plot_ild_moment()
Plot object containing:
[0]: cartesian line: Piecewise((-x/2, x < 4), (x/2 - 4, x > 4)) for x over (0.0, 12.0)

(png, hires.png, pdf)

../../../_images/beam-4.png

plot_ild_reactions(subs=None)

在移动载荷的作用下，为反力作用线图绘制函数。此函数应在调用 solve_for_ild_reactions()后调用。

参数：

subs：字典

包含符号作为键和相应值的 Python 字典。

示例

有一根长度为 10 米的梁。梁上还施加了一个大小为 5KN 的点载荷，距离起点 4 米处。梁下方有两个简支，一个位于起点，另一个距离起点 7 米处。在 1kN 移动载荷的作用下，在两个支点处的反应作用线方程作图。

使用下行力的符号约定为正。

>>> from sympy import symbols
>>> from sympy.physics.continuum_mechanics.beam import Beam
>>> E, I = symbols('E, I')
>>> R_0, R_7 = symbols('R_0, R_7')
>>> b = Beam(10, E, I)
>>> p0 = b.apply_support(0, 'roller')
>>> p7 = b.apply_support(7, 'roller')
>>> b.apply_load(5,4,-1)
>>> b.solve_for_ild_reactions(1,R_0,R_7)
>>> b.ild_reactions
{R_0: x/7 - 22/7, R_7: -x/7 - 20/7}
>>> b.plot_ild_reactions()
PlotGrid object containing:
Plot[0]:Plot object containing:
[0]: cartesian line: x/7 - 22/7 for x over (0.0, 10.0)
Plot[1]:Plot object containing:
[0]: cartesian line: -x/7 - 20/7 for x over (0.0, 10.0)

(png, hires.png, pdf)

../../../_images/beam-5.png

plot_ild_shear(subs=None)

在移动载荷的作用下，为剪力作用线图绘制函数。此函数应在调用 solve_for_ild_shear()后调用。

参数：

subs：字典

包含符号作为键和相应值的 Python 字典。

示例

有一根长度为 12 米的梁。梁下方有两个简支，一个在起点，另一个在 8 米处。在 1kN 移动载荷的作用下，在距离起点 4 米处的剪力 I.L.D.作图。

使用下行力的符号约定为正。

>>> from sympy import symbols
>>> from sympy.physics.continuum_mechanics.beam import Beam
>>> E, I = symbols('E, I')
>>> R_0, R_8 = symbols('R_0, R_8')
>>> b = Beam(12, E, I)
>>> p0 = b.apply_support(0, 'roller')
>>> p8 = b.apply_support(8, 'roller')
>>> b.solve_for_ild_reactions(1, R_0, R_8)
>>> b.solve_for_ild_shear(4, 1, R_0, R_8)
>>> b.ild_shear
Piecewise((x/8, x < 4), (x/8 - 1, x > 4))
>>> b.plot_ild_shear()
Plot object containing:
[0]: cartesian line: Piecewise((x/8, x < 4), (x/8 - 1, x > 4)) for x over (0.0, 12.0)

(png, hires.png, pdf)

../../../_images/beam-6.png

plot_loading_results(subs=None)

返回梁对象的剪力、弯矩、斜率和挠度的子图。

参数：

subs：字典

Python 字典包含符号作为键和其对应值。

示例

有一根长度为 8 米的梁。从梁的中点至末端施加均布的 10 千牛每米的恒定分布载荷。梁下有两个简支，一个在起点，另一个在终点。梁顶部还施加了一个距起点 4 米处的大小为 5 千牛的集中力。取 E = 200 GPa 和 I = 400*(10**-6) 米⁴。

使用向下力为正的符号约定。

>>> from sympy.physics.continuum_mechanics.beam import Beam
>>> from sympy import symbols
>>> R1, R2 = symbols('R1, R2')
>>> b = Beam(8, 200*(10**9), 400*(10**-6))
>>> b.apply_load(5000, 2, -1)
>>> b.apply_load(R1, 0, -1)
>>> b.apply_load(R2, 8, -1)
>>> b.apply_load(10000, 4, 0, end=8)
>>> b.bc_deflection = [(0, 0), (8, 0)]
>>> b.solve_for_reaction_loads(R1, R2)
>>> axes = b.plot_loading_results()

(png, hires.png, pdf)

../../../_images/beam-7.png

plot_shear_force(subs=None)

返回梁对象中存在的剪力图。

参数：

subs：字典

Python 字典包含符号作为键和其对应值。

示例

有一根长度为 8 米的梁。从梁的中点至末端施加均布的 10 千牛每米的恒定分布载荷。梁下有两个简支，一个在起点，另一个在终点。梁顶部还施加了一个距起点 4 米处的大小为 5 千牛的集中力。取 E = 200 GPa 和 I = 400*(10**-6) 米⁴。

使用向下力为正的符号约定。

>>> from sympy.physics.continuum_mechanics.beam import Beam
>>> from sympy import symbols
>>> R1, R2 = symbols('R1, R2')
>>> b = Beam(8, 200*(10**9), 400*(10**-6))
>>> b.apply_load(5000, 2, -1)
>>> b.apply_load(R1, 0, -1)
>>> b.apply_load(R2, 8, -1)
>>> b.apply_load(10000, 4, 0, end=8)
>>> b.bc_deflection = [(0, 0), (8, 0)]
>>> b.solve_for_reaction_loads(R1, R2)
>>> b.plot_shear_force()
Plot object containing:
[0]: cartesian line: 13750*SingularityFunction(x, 0, 0) - 5000*SingularityFunction(x, 2, 0)
- 10000*SingularityFunction(x, 4, 1) + 31250*SingularityFunction(x, 8, 0)
+ 10000*SingularityFunction(x, 8, 1) for x over (0.0, 8.0)

(png, hires.png, pdf)

../../../_images/beam-8.png

plot_shear_stress(subs=None)

返回梁对象中存在的剪切应力图。

参数：

subs：字典

Python 字典包含符号作为键和其对应值。

示例

有一根长度为 8 米、横截面积为 2 平方米的梁。从梁的中点至末端施加均布的 10 千牛每米的恒定分布载荷。梁下有两个简支，一个在起点，另一个在终点。梁顶部还施加了一个距起点 4 米处的大小为 5 千牛的集中力。取 E = 200 GPa 和 I = 400*(10**-6) 米⁴。

使用向下力为正的符号约定。

>>> from sympy.physics.continuum_mechanics.beam import Beam
>>> from sympy import symbols
>>> R1, R2 = symbols('R1, R2')
>>> b = Beam(8, 200*(10**9), 400*(10**-6), 2)
>>> b.apply_load(5000, 2, -1)
>>> b.apply_load(R1, 0, -1)
>>> b.apply_load(R2, 8, -1)
>>> b.apply_load(10000, 4, 0, end=8)
>>> b.bc_deflection = [(0, 0), (8, 0)]
>>> b.solve_for_reaction_loads(R1, R2)
>>> b.plot_shear_stress()
Plot object containing:
[0]: cartesian line: 6875*SingularityFunction(x, 0, 0) - 2500*SingularityFunction(x, 2, 0)
- 5000*SingularityFunction(x, 4, 1) + 15625*SingularityFunction(x, 8, 0)
+ 5000*SingularityFunction(x, 8, 1) for x over (0.0, 8.0)

(png, hires.png, pdf)

../../../_images/beam-9.png

plot_slope(subs=None)

返回梁对象挠度曲线的斜率图。

参数：

subs：字典

Python 字典，包含符号作为键和相应值。

示例

有一根长度为 8 米的梁。从梁的中点到末端施加大小为 10 KN/m 的常分布载荷。梁下有两个简支，一个在起点，另一个在梁的末端。从梁顶部距离起点 4 米处施加大小为 5 KN 的点载荷。取 E = 200 GPa 和 I = 400*(10**-6) 米的四次方。

使用向下力为正的符号约定。

>>> from sympy.physics.continuum_mechanics.beam import Beam
>>> from sympy import symbols
>>> R1, R2 = symbols('R1, R2')
>>> b = Beam(8, 200*(10**9), 400*(10**-6))
>>> b.apply_load(5000, 2, -1)
>>> b.apply_load(R1, 0, -1)
>>> b.apply_load(R2, 8, -1)
>>> b.apply_load(10000, 4, 0, end=8)
>>> b.bc_deflection = [(0, 0), (8, 0)]
>>> b.solve_for_reaction_loads(R1, R2)
>>> b.plot_slope()
Plot object containing:
[0]: cartesian line: -8.59375e-5*SingularityFunction(x, 0, 2) + 3.125e-5*SingularityFunction(x, 2, 2)
+ 2.08333333333333e-5*SingularityFunction(x, 4, 3) - 0.0001953125*SingularityFunction(x, 8, 2)
- 2.08333333333333e-5*SingularityFunction(x, 8, 3) + 0.00138541666666667 for x over (0.0, 8.0)

(png, hires.png, pdf)

../../../_images/beam-10.png

point_cflexure()

返回具有零弯矩的点集，并且梁对象的弯矩曲线从负变为正或反之亦然。

示例

有一个长度为 10 米的悬臂梁。梁下方有两个简支。一个在起点，另一个距离起点 6 米处。点载荷大小分别为 10KN 和 20KN 施加在距离起点 2 米和 4 米处。还有一个均匀分布载荷，从距离起点 6 米处开始，大小为 3KN/m。使用向上力和顺时针力矩为正的符号约定。

>>> from sympy.physics.continuum_mechanics.beam import Beam
>>> from sympy import symbols
>>> E, I = symbols('E, I')
>>> b = Beam(10, E, I)
>>> b.apply_load(-4, 0, -1)
>>> b.apply_load(-46, 6, -1)
>>> b.apply_load(10, 2, -1)
>>> b.apply_load(20, 4, -1)
>>> b.apply_load(3, 6, 0)
>>> b.point_cflexure()
[10/3] 

property reaction_loads

返回字典中的反应力。

remove_load(value, start, order, end=None)

此方法移除梁对象上的特定负载。如果传递的负载作为参数不在梁上，则返回一个 ValueError。

参数：

值：可符号化

应用载荷的大小。

开始：可符号化

应用载荷的起始点。对于点力矩和点力，这是应用位置。

顺序：整数

应用载荷的顺序。- 对于力矩，顺序= -2 - 对于点载荷，顺序= -1 - 对于恒定分布载荷，顺序= 0 - 对于斜坡载荷，顺序= 1 - 对于抛物线斜坡载荷，顺序= 2 - ... 依此类推。

结束：可符号化，可选

如果负载在梁的长度内有一个端点，可以使用可选参数。

示例

有一根长度为 4 米的梁。以顺时针方向在梁的起点施加大小为 3 Nm 的力矩。从梁顶部距离起点 2 米处施加大小为 4 N 的点载荷，以及从梁下方施加的大小为 2 N/m 的抛物线斜坡载荷，从距离梁起点 3 米处开始，一直延伸到 2 米处。

>>> from sympy.physics.continuum_mechanics.beam import Beam
>>> from sympy import symbols
>>> E, I = symbols('E, I')
>>> b = Beam(4, E, I)
>>> b.apply_load(-3, 0, -2)
>>> b.apply_load(4, 2, -1)
>>> b.apply_load(-2, 2, 2, end=3)
>>> b.load
-3*SingularityFunction(x, 0, -2) + 4*SingularityFunction(x, 2, -1) - 2*SingularityFunction(x, 2, 2) + 2*SingularityFunction(x, 3, 0) + 4*SingularityFunction(x, 3, 1) + 2*SingularityFunction(x, 3, 2)
>>> b.remove_load(-2, 2, 2, end = 3)
>>> b.load
-3*SingularityFunction(x, 0, -2) + 4*SingularityFunction(x, 2, -1) 

property second_moment

梁的截面二阶矩。

shear_force()

返回表示梁对象的剪力曲线的奇异函数表达式。

示例

长度为 30 米的梁上施加了 120 Nm 的顺时针方向力矩。起始点上从梁顶施加了 8 N 的点载荷。梁下有两个简支，一个在末端，另一个距起点 10 米处。在两个支座处都限制了挠度。

使用向上力和顺时针力矩为正的符号约定。

>>> from sympy.physics.continuum_mechanics.beam import Beam
>>> from sympy import symbols
>>> E, I = symbols('E, I')
>>> R1, R2 = symbols('R1, R2')
>>> b = Beam(30, E, I)
>>> b.apply_load(-8, 0, -1)
>>> b.apply_load(R1, 10, -1)
>>> b.apply_load(R2, 30, -1)
>>> b.apply_load(120, 30, -2)
>>> b.bc_deflection = [(10, 0), (30, 0)]
>>> b.solve_for_reaction_loads(R1, R2)
>>> b.shear_force()
8*SingularityFunction(x, 0, 0) - 6*SingularityFunction(x, 10, 0) - 120*SingularityFunction(x, 30, -1) - 2*SingularityFunction(x, 30, 0) 

shear_stress()

返回表示梁对象的剪切应力曲线的表达式。

slope()

返回一个表示梁对象弹性曲线斜率的奇异函数表达式。

示例

长度为 30 米的梁上施加了 120 Nm 的顺时针方向力矩。起始点上从梁顶施加了 8 N 的点载荷。梁下有两个简支，一个在末端，另一个距起点 10 米处。在两个支座处都限制了挠度。

使用向上力和顺时针力矩为正的符号约定。

>>> from sympy.physics.continuum_mechanics.beam import Beam
>>> from sympy import symbols
>>> E, I = symbols('E, I')
>>> R1, R2 = symbols('R1, R2')
>>> b = Beam(30, E, I)
>>> b.apply_load(-8, 0, -1)
>>> b.apply_load(R1, 10, -1)
>>> b.apply_load(R2, 30, -1)
>>> b.apply_load(120, 30, -2)
>>> b.bc_deflection = [(10, 0), (30, 0)]
>>> b.solve_for_reaction_loads(R1, R2)
>>> b.slope()
(-4*SingularityFunction(x, 0, 2) + 3*SingularityFunction(x, 10, 2)
 + 120*SingularityFunction(x, 30, 1) + SingularityFunction(x, 30, 2) + 4000/3)/(E*I) 

solve_for_ild_moment(distance, value, *reactions)

确定受移动载荷影响下特定点处弯矩影响线图方程。

参数：

距离：整数

点距离梁起点的距离，用于确定方程。

数值：整数

移动载荷的大小

反力：

施加在梁上的反力。

示例

长度为 12 米的梁。梁下有两个简支，一个在起点，另一个在距离 8 米处。计算在 1kN 移动载荷作用下，距离 4 米处的弯矩的 I.L.D.方程。

使用向下力为正的符号约定。

>>> from sympy import symbols
>>> from sympy.physics.continuum_mechanics.beam import Beam
>>> E, I = symbols('E, I')
>>> R_0, R_8 = symbols('R_0, R_8')
>>> b = Beam(12, E, I)
>>> p0 = b.apply_support(0, 'roller')
>>> p8 = b.apply_support(8, 'roller')
>>> b.solve_for_ild_reactions(1, R_0, R_8)
>>> b.solve_for_ild_moment(4, 1, R_0, R_8)
>>> b.ild_moment
Piecewise((-x/2, x < 4), (x/2 - 4, x > 4)) 

solve_for_ild_reactions(value, *reactions)

确定受移动载荷影响下特定点处反力影响线图方程。

参数：

数值：整数

移动载荷的大小

反力：

施加在梁上的反力。

示例

长度为 10 米的梁。梁下有两个简支，一个在起点，另一个在梁的末端。计算在 1kN 移动载荷作用下的反力的 I.L.D.方程。

使用向下力为正的符号约定。

>>> from sympy import symbols
>>> from sympy.physics.continuum_mechanics.beam import Beam
>>> E, I = symbols('E, I')
>>> R_0, R_10 = symbols('R_0, R_10')
>>> b = Beam(10, E, I)
>>> p0 = b.apply_support(0, 'roller')
>>> p10 = b.apply_support(10, 'roller')
>>> b.solve_for_ild_reactions(1,R_0,R_10)
>>> b.ild_reactions
{R_0: x/10 - 1, R_10: -x/10} 

solve_for_ild_shear(distance, value, *reactions)

确定受移动载荷影响下特定点处剪力影响线图方程。

参数：

距离：整数

点距离梁起点的距离，用于确定方程。

数值：整数

移动载荷的大小

反力：

施加在梁上的反力。

示例

长度为 12 米的梁。梁下有两个简支，一个在起点，另一个在距离 8 米处。计算在 1kN 移动载荷作用下，距离 4 米处的剪力的 I.L.D.方程。

使用向下力为正的符号约定。

>>> from sympy import symbols
>>> from sympy.physics.continuum_mechanics.beam import Beam
>>> E, I = symbols('E, I')
>>> R_0, R_8 = symbols('R_0, R_8')
>>> b = Beam(12, E, I)
>>> p0 = b.apply_support(0, 'roller')
>>> p8 = b.apply_support(8, 'roller')
>>> b.solve_for_ild_reactions(1, R_0, R_8)
>>> b.solve_for_ild_shear(4, 1, R_0, R_8)
>>> b.ild_shear
Piecewise((x/8, x < 4), (x/8 - 1, x > 4)) 

solve_for_reaction_loads(*reactions)

解算反力。

示例

一根长度为 30 米的梁。在梁的末端以顺时针方向施加了 120 Nm 的力矩。从梁的起点顶部施加了 8 N 的点载荷。梁下方有两个简支点。一个在末端，另一个距离起点 10 米处。在两个支点处梁的挠度被限制。

使用向上力和顺时针力矩为正的符号约定。

>>> from sympy.physics.continuum_mechanics.beam import Beam
>>> from sympy import symbols
>>> E, I = symbols('E, I')
>>> R1, R2 = symbols('R1, R2')
>>> b = Beam(30, E, I)
>>> b.apply_load(-8, 0, -1)
>>> b.apply_load(R1, 10, -1)  # Reaction force at x = 10
>>> b.apply_load(R2, 30, -1)  # Reaction force at x = 30
>>> b.apply_load(120, 30, -2)
>>> b.bc_deflection = [(10, 0), (30, 0)]
>>> b.load
R1*SingularityFunction(x, 10, -1) + R2*SingularityFunction(x, 30, -1)
 - 8*SingularityFunction(x, 0, -1) + 120*SingularityFunction(x, 30, -2)
>>> b.solve_for_reaction_loads(R1, R2)
>>> b.reaction_loads
{R1: 6, R2: 2}
>>> b.load
-8*SingularityFunction(x, 0, -1) + 6*SingularityFunction(x, 10, -1)
 + 120*SingularityFunction(x, 30, -2) + 2*SingularityFunction(x, 30, -1) 

property variable

一个符号，可用作沿梁长度表示载荷分布、剪力曲线、弯矩、斜率曲线和挠度曲线的变量。默认情况下设置为Symbol('x')，但此属性可变。

示例

>>> from sympy.physics.continuum_mechanics.beam import Beam
>>> from sympy import symbols
>>> E, I, A = symbols('E, I, A')
>>> x, y, z = symbols('x, y, z')
>>> b = Beam(4, E, I)
>>> b.variable
x
>>> b.variable = y
>>> b.variable
y
>>> b = Beam(4, E, I, A, z)
>>> b.variable
z 

class sympy.physics.continuum_mechanics.beam.Beam3D(length, elastic_modulus, shear_modulus, second_moment, area, variable=x)

此类处理施加在 3D 空间任意方向的载荷，以及不同轴向的二阶矩值不等的情况。

注意

在解决梁弯曲问题时必须使用一致的符号约定；结果将自动遵循所选择的符号约定。此类假设任何类型的分布载荷/力矩都施加在梁的跨度上。

示例

一根长度为 l 米的梁。从起点到梁末端沿 y 轴施加了大小为 q 的恒定分布载荷。从起点到梁末端沿 z 轴施加了大小为 m 的恒定分布力矩。梁在两端固定，因此两端的挠度被限制。

>>> from sympy.physics.continuum_mechanics.beam import Beam3D
>>> from sympy import symbols, simplify, collect, factor
>>> l, E, G, I, A = symbols('l, E, G, I, A')
>>> b = Beam3D(l, E, G, I, A)
>>> x, q, m = symbols('x, q, m')
>>> b.apply_load(q, 0, 0, dir="y")
>>> b.apply_moment_load(m, 0, -1, dir="z")
>>> b.shear_force()
[0, -q*x, 0]
>>> b.bending_moment()
[0, 0, -m*x + q*x**2/2]
>>> b.bc_slope = [(0, [0, 0, 0]), (l, [0, 0, 0])]
>>> b.bc_deflection = [(0, [0, 0, 0]), (l, [0, 0, 0])]
>>> b.solve_slope_deflection()
>>> factor(b.slope())
[0, 0, x*(-l + x)*(-A*G*l**3*q + 2*A*G*l**2*q*x - 12*E*I*l*q
 - 72*E*I*m + 24*E*I*q*x)/(12*E*I*(A*G*l**2 + 12*E*I))]
>>> dx, dy, dz = b.deflection()
>>> dy = collect(simplify(dy), x)
>>> dx == dz == 0
True
>>> dy == (x*(12*E*I*l*(A*G*l**2*q - 2*A*G*l*m + 12*E*I*q)
... + x*(A*G*l*(3*l*(A*G*l**2*q - 2*A*G*l*m + 12*E*I*q) + x*(-2*A*G*l**2*q + 4*A*G*l*m - 24*E*I*q))
... + A*G*(A*G*l**2 + 12*E*I)*(-2*l**2*q + 6*l*m - 4*m*x + q*x**2)
... - 12*E*I*q*(A*G*l**2 + 12*E*I)))/(24*A*E*G*I*(A*G*l**2 + 12*E*I)))
True

参考资料

[R729]

homes.civil.aau.dk/jc/FemteSemester/Beams3D.pdf

angular_deflection()

返回 x 的函数，描述由梁上 x 轴上的力矩引起的角偏转如何随 x 变化。

apply_load(value, start, order, dir='y')

此方法将力载荷添加到特定的梁对象上。

参数：

value : 可用 SymPy 处理的类型

施加载荷的大小。

dir : 字符串

施加载荷的轴线。

order : 整数

施加载荷的顺序。- 对于点载荷，order=-1 - 对于恒定分布载荷，order=0 - 对于斜坡载荷，order=1 - 对于抛物线斜坡载荷，order=2 - ...以此类推。

apply_moment_load(value, start, order, dir='y')

此方法将力矩载荷添加到特定的梁对象上。

参数：

value : 可用 SymPy 处理的类型

施加力矩的大小。

dir : 字符串

施加力矩的轴线。

order : 整数

施加载荷的顺序。- 对于点力矩，order=-2 - 对于恒定分布力矩，order=-1 - 对于斜坡力矩，order=0 - 对于抛物线斜坡力矩，order=1 - ...以此类推。

property area

梁的横截面积。

axial_force()

返回梁对象内部的轴向剪力表达式。

axial_stress()

返回梁对象内部轴向应力的表达式。

bending_moment()

返回三个表达式的列表，表示梁对象沿三个轴的弯矩曲线。

property boundary_conditions

返回一个包含梁上应用的边界条件字典。字典有两个关键字，即斜率和挠度。每个关键字的值是一个元组列表，每个元组包含格式为（位置，值）的边界条件的位置和值。进一步，每个值都是对应于该位置处三个轴上的斜率或挠度值的列表。

示例

有一根长度为 4 米的梁。在 x 轴上，起点处的斜率应为 4，其他轴上为 0。在梁的另一端，沿着所有三个轴的挠度应为零。

>>> from sympy.physics.continuum_mechanics.beam import Beam3D
>>> from sympy import symbols
>>> l, E, G, I, A, x = symbols('l, E, G, I, A, x')
>>> b = Beam3D(30, E, G, I, A, x)
>>> b.bc_slope = [(0, (4, 0, 0))]
>>> b.bc_deflection = [(4, [0, 0, 0])]
>>> b.boundary_conditions
{'deflection': [(4, [0, 0, 0])], 'slope': [(0, (4, 0, 0))]}

在这里，梁的挠度应在4处沿着所有三个轴为0。类似地，梁在0处沿 x 轴的斜率应为4，y 轴和 z 轴为0。

deflection()

返回一个表示梁上挠曲线的三元素列表。

property load_vector

返回一个包含载荷向量的三元素列表。

max_bending_moment()

返回梁对象中所有方向上最大弯矩点及其对应的弯矩值，作为列表。必须在使用此函数之前调用 solve_for_reaction_loads()。

示例

有一根长度为 20 米的梁。两端支承于滚轮上。沿 y 轴施加斜率为 12 的线性载荷。沿 z 轴从起点到终点施加 15N 的恒定分布载荷。

>>> from sympy.physics.continuum_mechanics.beam import Beam3D
>>> from sympy import symbols
>>> l, E, G, I, A, x = symbols('l, E, G, I, A, x')
>>> b = Beam3D(20, 40, 21, 100, 25, x)
>>> b.apply_load(15, start=0, order=0, dir="z")
>>> b.apply_load(12*x, start=0, order=0, dir="y")
>>> b.bc_deflection = [(0, [0, 0, 0]), (20, [0, 0, 0])]
>>> R1, R2, R3, R4 = symbols('R1, R2, R3, R4')
>>> b.apply_load(R1, start=0, order=-1, dir="z")
>>> b.apply_load(R2, start=20, order=-1, dir="z")
>>> b.apply_load(R3, start=0, order=-1, dir="y")
>>> b.apply_load(R4, start=20, order=-1, dir="y")
>>> b.solve_for_reaction_loads(R1, R2, R3, R4)
>>> b.max_bending_moment()
[(0, 0), (20, 3000), (20, 16000)] 

max_bmoment()

返回梁对象中所有方向上最大弯矩点及其对应的弯矩值，作为列表。必须在使用此函数之前调用 solve_for_reaction_loads()。

示例

有一根长度为 20 米的梁。两端支承于滚轮上。沿 y 轴施加斜率为 12 的线性载荷。沿 z 轴从起点到终点施加 15N 的恒定分布载荷。

>>> from sympy.physics.continuum_mechanics.beam import Beam3D
>>> from sympy import symbols
>>> l, E, G, I, A, x = symbols('l, E, G, I, A, x')
>>> b = Beam3D(20, 40, 21, 100, 25, x)
>>> b.apply_load(15, start=0, order=0, dir="z")
>>> b.apply_load(12*x, start=0, order=0, dir="y")
>>> b.bc_deflection = [(0, [0, 0, 0]), (20, [0, 0, 0])]
>>> R1, R2, R3, R4 = symbols('R1, R2, R3, R4')
>>> b.apply_load(R1, start=0, order=-1, dir="z")
>>> b.apply_load(R2, start=20, order=-1, dir="z")
>>> b.apply_load(R3, start=0, order=-1, dir="y")
>>> b.apply_load(R4, start=20, order=-1, dir="y")
>>> b.solve_for_reaction_loads(R1, R2, R3, R4)
>>> b.max_bending_moment()
[(0, 0), (20, 3000), (20, 16000)] 

max_deflection()

返回梁对象中所有方向上最大挠度点及其对应的挠度值，作为列表。必须在使用此函数之前调用 solve_for_reaction_loads()和 solve_slope_deflection()。

示例

有一根长度为 20 米的梁。两端支承于滚轮上。沿 y 轴施加斜率为 12 的线性载荷。沿 z 轴从起点到终点施加 15N 的恒定分布载荷。

>>> from sympy.physics.continuum_mechanics.beam import Beam3D
>>> from sympy import symbols
>>> l, E, G, I, A, x = symbols('l, E, G, I, A, x')
>>> b = Beam3D(20, 40, 21, 100, 25, x)
>>> b.apply_load(15, start=0, order=0, dir="z")
>>> b.apply_load(12*x, start=0, order=0, dir="y")
>>> b.bc_deflection = [(0, [0, 0, 0]), (20, [0, 0, 0])]
>>> R1, R2, R3, R4 = symbols('R1, R2, R3, R4')
>>> b.apply_load(R1, start=0, order=-1, dir="z")
>>> b.apply_load(R2, start=20, order=-1, dir="z")
>>> b.apply_load(R3, start=0, order=-1, dir="y")
>>> b.apply_load(R4, start=20, order=-1, dir="y")
>>> b.solve_for_reaction_loads(R1, R2, R3, R4)
>>> b.solve_slope_deflection()
>>> b.max_deflection()
[(0, 0), (10, 495/14), (-10 + 10*sqrt(10793)/43, (10 - 10*sqrt(10793)/43)**3/160 - 20/7 + (10 - 10*sqrt(10793)/43)**4/6400 + 20*sqrt(10793)/301 + 27*(10 - 10*sqrt(10793)/43)**2/560)] 

max_shear_force()

返回梁对象中所有方向上最大剪力点及其对应的剪力值，作为列表。必须在使用此函数之前调用 solve_for_reaction_loads()。

示例

有一根长度为 20 米的梁。两端支承于滚轮上。沿 y 轴施加斜率为 12 的线性载荷。沿 z 轴从起点到终点施加 15N 的恒定分布载荷。

>>> from sympy.physics.continuum_mechanics.beam import Beam3D
>>> from sympy import symbols
>>> l, E, G, I, A, x = symbols('l, E, G, I, A, x')
>>> b = Beam3D(20, 40, 21, 100, 25, x)
>>> b.apply_load(15, start=0, order=0, dir="z")
>>> b.apply_load(12*x, start=0, order=0, dir="y")
>>> b.bc_deflection = [(0, [0, 0, 0]), (20, [0, 0, 0])]
>>> R1, R2, R3, R4 = symbols('R1, R2, R3, R4')
>>> b.apply_load(R1, start=0, order=-1, dir="z")
>>> b.apply_load(R2, start=20, order=-1, dir="z")
>>> b.apply_load(R3, start=0, order=-1, dir="y")
>>> b.apply_load(R4, start=20, order=-1, dir="y")
>>> b.solve_for_reaction_loads(R1, R2, R3, R4)
>>> b.max_shear_force()
[(0, 0), (20, 2400), (20, 300)] 

property moment_load_vector

返回一个表示梁上弯矩载荷的三元素列表。

plot_bending_moment(dir='all', subs=None)

返回一个图表，显示梁对象中所有三个方向的弯矩。

参数：

dir ：字符串（默认

需要绘制弯矩图的方向。如果未指定方向，则显示所有图。

subs : dictionary

包含符号及其对应值的 Python 字典。

示例

一根长度为 20 米的梁。两端支承有滚轮。沿 y 轴施加斜率为 12 的线性载荷。从起点到终点沿 z 轴施加 15N 的恒定分布载荷。

>>> from sympy.physics.continuum_mechanics.beam import Beam3D
>>> from sympy import symbols
>>> l, E, G, I, A, x = symbols('l, E, G, I, A, x')
>>> b = Beam3D(20, E, G, I, A, x)
>>> b.apply_load(15, start=0, order=0, dir="z")
>>> b.apply_load(12*x, start=0, order=0, dir="y")
>>> b.bc_deflection = [(0, [0, 0, 0]), (20, [0, 0, 0])]
>>> R1, R2, R3, R4 = symbols('R1, R2, R3, R4')
>>> b.apply_load(R1, start=0, order=-1, dir="z")
>>> b.apply_load(R2, start=20, order=-1, dir="z")
>>> b.apply_load(R3, start=0, order=-1, dir="y")
>>> b.apply_load(R4, start=20, order=-1, dir="y")
>>> b.solve_for_reaction_loads(R1, R2, R3, R4)
>>> b.plot_bending_moment()
PlotGrid object containing:
Plot[0]:Plot object containing:
[0]: cartesian line: 0 for x over (0.0, 20.0)
Plot[1]:Plot object containing:
[0]: cartesian line: -15*x**2/2 for x over (0.0, 20.0)
Plot[2]:Plot object containing:
[0]: cartesian line: 2*x**3 for x over (0.0, 20.0)

(png, hires.png, pdf)

../../../_images/beam-18.png

plot_deflection(dir='all', subs=None)

返回 Beam 对象中所有三个方向的挠曲图。

参数：

dir : string (default

需要绘制挠曲图的方向。如果未指定方向，则显示所有图。

subs : dictionary

包含符号及其对应值的 Python 字典。

示例

一根长度为 20 米的梁。两端支承有滚轮。沿 y 轴施加斜率为 12 的线性载荷。从起点到终点沿 z 轴施加 15N 的恒定分布载荷。

>>> from sympy.physics.continuum_mechanics.beam import Beam3D
>>> from sympy import symbols
>>> l, E, G, I, A, x = symbols('l, E, G, I, A, x')
>>> b = Beam3D(20, 40, 21, 100, 25, x)
>>> b.apply_load(15, start=0, order=0, dir="z")
>>> b.apply_load(12*x, start=0, order=0, dir="y")
>>> b.bc_deflection = [(0, [0, 0, 0]), (20, [0, 0, 0])]
>>> R1, R2, R3, R4 = symbols('R1, R2, R3, R4')
>>> b.apply_load(R1, start=0, order=-1, dir="z")
>>> b.apply_load(R2, start=20, order=-1, dir="z")
>>> b.apply_load(R3, start=0, order=-1, dir="y")
>>> b.apply_load(R4, start=20, order=-1, dir="y")
>>> b.solve_for_reaction_loads(R1, R2, R3, R4)
>>> b.solve_slope_deflection()
>>> b.plot_deflection()
PlotGrid object containing:
Plot[0]:Plot object containing:
[0]: cartesian line: 0 for x over (0.0, 20.0)
Plot[1]:Plot object containing:
[0]: cartesian line: x**5/40000 - 4013*x**3/90300 + 26*x**2/43 + 1520*x/903 for x over (0.0, 20.0)
Plot[2]:Plot object containing:
[0]: cartesian line: x**4/6400 - x**3/160 + 27*x**2/560 + 2*x/7 for x over (0.0, 20.0)

(png, hires.png, pdf)

../../../_images/beam-19.png

plot_loading_results(dir='x', subs=None)

返回 Beam 对象沿指定方向的剪力、弯矩、斜率和挠曲的子图。

参数：

dir : string (default

需要绘制的方向。如果未指定方向，则显示沿 x 轴的图。

subs : dictionary

包含符号及其对应值的 Python 字典。

示例

一根长度为 20 米的梁。两端支承有滚轮。沿 y 轴施加斜率为 12 的线性载荷。从起点到终点沿 z 轴施加 15N 的恒定分布载荷。

>>> from sympy.physics.continuum_mechanics.beam import Beam3D
>>> from sympy import symbols
>>> l, E, G, I, A, x = symbols('l, E, G, I, A, x')
>>> b = Beam3D(20, E, G, I, A, x)
>>> subs = {E:40, G:21, I:100, A:25}
>>> b.apply_load(15, start=0, order=0, dir="z")
>>> b.apply_load(12*x, start=0, order=0, dir="y")
>>> b.bc_deflection = [(0, [0, 0, 0]), (20, [0, 0, 0])]
>>> R1, R2, R3, R4 = symbols('R1, R2, R3, R4')
>>> b.apply_load(R1, start=0, order=-1, dir="z")
>>> b.apply_load(R2, start=20, order=-1, dir="z")
>>> b.apply_load(R3, start=0, order=-1, dir="y")
>>> b.apply_load(R4, start=20, order=-1, dir="y")
>>> b.solve_for_reaction_loads(R1, R2, R3, R4)
>>> b.solve_slope_deflection()
>>> b.plot_loading_results('y',subs)
PlotGrid object containing:
Plot[0]:Plot object containing:
[0]: cartesian line: -6*x**2 for x over (0.0, 20.0)
Plot[1]:Plot object containing:
[0]: cartesian line: -15*x**2/2 for x over (0.0, 20.0)
Plot[2]:Plot object containing:
[0]: cartesian line: -x**3/1600 + 3*x**2/160 - x/8 for x over (0.0, 20.0)
Plot[3]:Plot object containing:
[0]: cartesian line: x**5/40000 - 4013*x**3/90300 + 26*x**2/43 + 1520*x/903 for x over (0.0, 20.0)

(png, hires.png, pdf)

../../../_images/beam-20.png

plot_shear_force(dir='all', subs=None)

返回 Beam 对象中所有三个方向的剪力图。

参数：

dir : string (default

需要绘制剪力图的方向。如果未指定方向，则显示所有图。

subs : dictionary

包含符号及其对应值的 Python 字典。

示例

钢筋束的长度为 20 米。它由两端的滚轮支撑。沿 y 轴施加斜率为 12 的线性载荷。从起点到终点沿 z 轴施加 15 牛顿的恒定分布载荷。

>>> from sympy.physics.continuum_mechanics.beam import Beam3D
>>> from sympy import symbols
>>> l, E, G, I, A, x = symbols('l, E, G, I, A, x')
>>> b = Beam3D(20, E, G, I, A, x)
>>> b.apply_load(15, start=0, order=0, dir="z")
>>> b.apply_load(12*x, start=0, order=0, dir="y")
>>> b.bc_deflection = [(0, [0, 0, 0]), (20, [0, 0, 0])]
>>> R1, R2, R3, R4 = symbols('R1, R2, R3, R4')
>>> b.apply_load(R1, start=0, order=-1, dir="z")
>>> b.apply_load(R2, start=20, order=-1, dir="z")
>>> b.apply_load(R3, start=0, order=-1, dir="y")
>>> b.apply_load(R4, start=20, order=-1, dir="y")
>>> b.solve_for_reaction_loads(R1, R2, R3, R4)
>>> b.plot_shear_force()
PlotGrid object containing:
Plot[0]:Plot object containing:
[0]: cartesian line: 0 for x over (0.0, 20.0)
Plot[1]:Plot object containing:
[0]: cartesian line: -6*x**2 for x over (0.0, 20.0)
Plot[2]:Plot object containing:
[0]: cartesian line: -15*x for x over (0.0, 20.0)

（png, hires.png, pdf)

../../../_images/beam-21.png

plot_shear_stress(dir='all', subs=None)

返回表示钢束对象沿所有三个方向的剪切应力曲线的图。

参数：

dir：字符串（默认

需要绘制剪切应力图的方向。如果未指定方向，则显示所有图形。

subs：字典

包含符号作为键和相应值的 Python 字典。

示例

钢筋束的长度为 20 米，横截面积为 2 平方米。它由两端的滚轮支撑。沿 y 轴施加斜率为 12 的线性载荷。从起点到终点沿 z 轴施加 15 牛顿的恒定分布载荷。

>>> from sympy.physics.continuum_mechanics.beam import Beam3D
>>> from sympy import symbols
>>> l, E, G, I, A, x = symbols('l, E, G, I, A, x')
>>> b = Beam3D(20, E, G, I, 2, x)
>>> b.apply_load(15, start=0, order=0, dir="z")
>>> b.apply_load(12*x, start=0, order=0, dir="y")
>>> b.bc_deflection = [(0, [0, 0, 0]), (20, [0, 0, 0])]
>>> R1, R2, R3, R4 = symbols('R1, R2, R3, R4')
>>> b.apply_load(R1, start=0, order=-1, dir="z")
>>> b.apply_load(R2, start=20, order=-1, dir="z")
>>> b.apply_load(R3, start=0, order=-1, dir="y")
>>> b.apply_load(R4, start=20, order=-1, dir="y")
>>> b.solve_for_reaction_loads(R1, R2, R3, R4)
>>> b.plot_shear_stress()
PlotGrid object containing:
Plot[0]:Plot object containing:
[0]: cartesian line: 0 for x over (0.0, 20.0)
Plot[1]:Plot object containing:
[0]: cartesian line: -3*x**2 for x over (0.0, 20.0)
Plot[2]:Plot object containing:
[0]: cartesian line: -15*x/2 for x over (0.0, 20.0)

（png, hires.png, pdf)

../../../_images/beam-22.png

plot_slope(dir='all', subs=None)

返回一个表示钢束对象沿所有三个方向的斜率的图。

参数：

dir：字符串（默认

需要绘制斜率图的方向。如果未指定方向，则显示所有图形。

subs：字典

包含符号作为键和相应值的 Python 字典。

示例

钢筋束的长度为 20 米。它由两端的滚轮支撑。沿 y 轴施加斜率为 12 的线性载荷。从起点到终点沿 z 轴施加 15 牛顿的恒定分布载荷。

>>> from sympy.physics.continuum_mechanics.beam import Beam3D
>>> from sympy import symbols
>>> l, E, G, I, A, x = symbols('l, E, G, I, A, x')
>>> b = Beam3D(20, 40, 21, 100, 25, x)
>>> b.apply_load(15, start=0, order=0, dir="z")
>>> b.apply_load(12*x, start=0, order=0, dir="y")
>>> b.bc_deflection = [(0, [0, 0, 0]), (20, [0, 0, 0])]
>>> R1, R2, R3, R4 = symbols('R1, R2, R3, R4')
>>> b.apply_load(R1, start=0, order=-1, dir="z")
>>> b.apply_load(R2, start=20, order=-1, dir="z")
>>> b.apply_load(R3, start=0, order=-1, dir="y")
>>> b.apply_load(R4, start=20, order=-1, dir="y")
>>> b.solve_for_reaction_loads(R1, R2, R3, R4)
>>> b.solve_slope_deflection()
>>> b.plot_slope()
PlotGrid object containing:
Plot[0]:Plot object containing:
[0]: cartesian line: 0 for x over (0.0, 20.0)
Plot[1]:Plot object containing:
[0]: cartesian line: -x**3/1600 + 3*x**2/160 - x/8 for x over (0.0, 20.0)
Plot[2]:Plot object containing:
[0]: cartesian line: x**4/8000 - 19*x**2/172 + 52*x/43 for x over (0.0, 20.0)

（png, hires.png, pdf)

../../../_images/beam-23.png

polar_moment()

返回关于质心的 X 轴的钢筋的极点矩。

示例

>>> from sympy.physics.continuum_mechanics.beam import Beam3D
>>> from sympy import symbols
>>> l, E, G, I, A = symbols('l, E, G, I, A')
>>> b = Beam3D(l, E, G, I, A)
>>> b.polar_moment()
2*I
>>> I1 = [9, 15]
>>> b = Beam3D(l, E, G, I1, A)
>>> b.polar_moment()
24 

property second_moment

钢筋的截面惯性矩。

shear_force()

返回表示钢束对象沿所有三个轴的剪切力曲线的三个表达式列表。

property shear_modulus

钢筋的杨氏模量。

shear_stress()

返回表示钢束对象沿所有三个轴的剪切应力曲线的三个表达式列表。

slope()

返回表示钢束对象沿所有三个轴的挠度曲线斜率的三个元素列表。

solve_for_reaction_loads(*reaction)

解决反应力问题。

示例

有一根长度为 30 米的梁。它在两端由滚轮支撑。从起点到终点沿着 y 轴施加 8 N 的恒定分布载荷。沿着 z 轴施加斜率为 9 的线性载荷。

>>> from sympy.physics.continuum_mechanics.beam import Beam3D
>>> from sympy import symbols
>>> l, E, G, I, A, x = symbols('l, E, G, I, A, x')
>>> b = Beam3D(30, E, G, I, A, x)
>>> b.apply_load(8, start=0, order=0, dir="y")
>>> b.apply_load(9*x, start=0, order=0, dir="z")
>>> b.bc_deflection = [(0, [0, 0, 0]), (30, [0, 0, 0])]
>>> R1, R2, R3, R4 = symbols('R1, R2, R3, R4')
>>> b.apply_load(R1, start=0, order=-1, dir="y")
>>> b.apply_load(R2, start=30, order=-1, dir="y")
>>> b.apply_load(R3, start=0, order=-1, dir="z")
>>> b.apply_load(R4, start=30, order=-1, dir="z")
>>> b.solve_for_reaction_loads(R1, R2, R3, R4)
>>> b.reaction_loads
{R1: -120, R2: -120, R3: -1350, R4: -2700} 

solve_for_torsion()

解决由于在 x 方向施加的扭转矩而导致的角偏转，即从梁内或外施加。

这里，正扭矩意味着扭矩方向为正，即沿着梁轴向外。同样，负扭矩表示扭矩进入梁截面。

示例

>>> from sympy.physics.continuum_mechanics.beam import Beam3D
>>> from sympy import symbols
>>> l, E, G, I, A, x = symbols('l, E, G, I, A, x')
>>> b = Beam3D(20, E, G, I, A, x)
>>> b.apply_moment_load(4, 4, -2, dir='x')
>>> b.apply_moment_load(4, 8, -2, dir='x')
>>> b.apply_moment_load(4, 8, -2, dir='x')
>>> b.solve_for_torsion()
>>> b.angular_deflection().subs(x, 3)
18/(G*I) 

torsional_moment()

返回梁对象内存在的扭转力矩表达式。

avatar
文章
阅读
粉丝