xxxxxxxxxx
# 办公楼程序化计算书
马克
本计算书编写之初仅用于内部快速试算、设计、验算之用,未曾考虑公示甲方之用。虽应要求增加Latex公式行便于阅读,如仍有不便还请谅解。
除非额外标注,本计算书使用国际标准单位SI。
本计算书已经过SAP2000验算,结果见附。
马克
本计算书编写之初仅用于内部快速试算、设计、验算之用,未曾考虑公示甲方之用。虽应要求增加Latex公式行便于阅读,如仍有不便还请谅解。
除非额外标注,本计算书使用国际标准单位SI。
本计算书已经过SAP2000验算,结果见附。
xxxxxxxxxx
from IPython.display import display, Markdown, Latex, Math
# https://dev.to/callas1900/how-to-display-latex-matrix-as-output-of-a-code-cell-40ck
def latex_matrix(array):
data = ''
for line in array:
if type(line) == type([1]) or type(line) == type([1.1]) or type(line) == type(np.float64(1)):
data += ' %.3E &'%line + r' \\'
continue
if len(line) == 1:
data += ' %.3E &'%line + r' \\\r'
continue
for element in line:
data += ' %.3E &'%element
data += r' \\' + '\n'
#display(Math('\\begin{bmatrix} \n%s\end{bmatrix}'%data))
return '\\begin{bmatrix} \n%s\end{bmatrix}'%data
from IPython.core.display import HTML
HTML("""
<style>
div.output_latex {
text-align: center;
}
.jp-OutputArea-output.jp-RenderedLatex {
text-align: center;
}
div.output_area .MathJax_Display {
text-align: center !important;
}
div.jp-InputArea {
display: none;
}
</style>
""")
xxxxxxxxxx
## 1 框架布置
主梁 x方向 5m x 6跨 = 30m
主梁 y方向 8m x 2跨 = 16m
次梁 x方向 1.6m x 5跨每榀
xxxxxxxxxx
frame_x = 30
frame_y = 16
frame_z = 10
frame_x_span = 5
frame_x_span_n = frame_x/frame_x_span
frame_y_span = 8
frame_y_span_n = frame_y/frame_y_span
frame_y_sub_span = 1.6
frame_y_sub_span_n = frame_y_span/frame_y_sub_span
frame_zs = [4,3,4]
frame_z_abss = [4,7,10]
frame_z_1 = frame_zs[0]
frame_z_2 = frame_zs[1]
frame_z_3 = frame_zs[2]
xxxxxxxxxx
## 2 荷载计算
### 2.1 活荷载
#### 2.1.1 办公楼面活荷载
根据GB50009-2012 p14
$$
2kN/m^2
$$
$$
\psi_c = 0.7
$$
$$
\psi_f = 0.5
$$
$$
\psi_q = 0.4
$$
#### 2.1.2 不上人屋面活荷载
根据GB50009-2012 p18
$$
0.5kN/m^2
$$
$$
\psi_c = 0.7
$$
$$
\psi_f = 0.5
$$
$$
\psi_q = 0
$$
#### 2.1.3 雪荷载
[雪荷载分区](https://www.dlubal.com/zh/solutions/online-services/load-zones)
根据GB50009-2012 p26
$$
s_0 = 0.5kN/m^2
$$
$$
\mu_r = 1
$$
$$
s_k = \mu_r s_0 = 0.5kN/m^2
$$
xxxxxxxxxx
liveload_floor_perarea = 2000
liveload_roof_perarea = 500
liveload_snow_perarea = 500
xxxxxxxxxx
### 2.2 恒荷载
#### 2.2.1 轻质混凝土楼板
单向板 100厚轻质混凝土根据[某公司数据](http://www.yzjz169.com/news/hydt/308.html),保守设计取值850 kg/m3,即85kg/m2,按安全取1.2e3kg/m3 - 肖
由[蒸压加气混凝土楼板(alc楼板)](https://www.hnalcb.cn/cp/e/57.html),1.6m跨长承载力5kN/m2
20厚水泥砂浆找平 2e3kg/m3,即40kg/m2
10厚地砖2.5e3kg/m3,即25kg/m2
或木地板10kg/m2
总质量按较大值
单向板 100厚轻质混凝土根据某公司数据,保守设计取值850 kg/m3,即85kg/m2,按安全取1.2e3kg/m3 - 肖
由蒸压加气混凝土楼板(alc楼板),1.6m跨长承载力5kN/m2
20厚水泥砂浆找平 2e3kg/m3,即40kg/m2 10厚地砖2.5e3kg/m3,即25kg/m2 或木地板10kg/m2
总质量按较大值
xxxxxxxxxx
class Material:
def __init__(self, density=0, E = 0):
self.density = density
self.E = E
xxxxxxxxxx
material_lightconcrete = Material(density=1200)
material_cement = Material(density=2000)
material_tile = Material(density=2500)
material_glubam = Material(density=750, E = 1e10)
xxxxxxxxxx
class Layer:
def __init__(self, material, thickness=0):
self.mass_perarea = material.density * thickness
xxxxxxxxxx
经计算,每平方米质量
经计算,每平方米质量
xxxxxxxxxx
floor_layer_lightconcrete = Layer(material_lightconcrete, thickness=0.1)
floor_layer_cement = Layer(material_cement, thickness=0.02)
floor_layer_tile = Layer(material_tile, thickness=0.01)
mass_floor_perarea = floor_layer_lightconcrete.mass_perarea\
+ floor_layer_cement.mass_perarea\
+ floor_layer_tile.mass_perarea
mass_floor_perarea
display(Markdown('$$m=\sum{m_i}='+str(mass_floor_perarea)+'$$'))
xxxxxxxxxx
class Beam:
def __init__(self, material, crosec_width, crosec_height, length=1):
self.crosec_width = crosec_width
self.crosec_height = crosec_height
self.length = length
self.A = crosec_width * crosec_height
self.density_perlength = material.density * self.A
self.I = crosec_width * crosec_height ** 3 /12
beam_sub = Beam(material_glubam, 0.12, 0.36)
beam = Beam(material_glubam, 0.3, 0.6)
column = Beam(material_glubam, 0.3, 0.5)
xxxxxxxxxx
根据GB50009-2012 3.2.4
荷载设计值
$$S_d = \max(1.2\sum{G}+1.4\sum{Q}, 1.35\sum{G}+1.4\times0.7Q)$$
荷载标准值
$$S_s = \sum{G}+Q_1+0.7\sum{Q_i}, (i>1)$$
根据GB50009-2012 3.2.4
荷载设计值
荷载标准值
xxxxxxxxxx
g = 9.8
def designload(deadload,liveload):
return max(
1.2*sum(deadload) + 1.4*sum(liveload),
1.35*sum(deadload) + 1.4*0.7*sum(liveload),
)
def standardload(deadload,liveload):
return sum(deadload)+0.3*liveload[0]+0.7*sum(liveload)
xxxxxxxxxx
deadload_floor_perarea = mass_floor_perarea * g
designload_floor_perarea = designload([deadload_floor_perarea], [liveload_floor_perarea])
designload_floor_perarea
display(Markdown('$$S_d='+str(designload_floor_perarea)+'$$'))
xxxxxxxxxx
小于5kN
小于5kN
xxxxxxxxxx
使用率
使用率
xxxxxxxxxx
designload_floor_perarea/5000
display(Markdown('$$utilization='+str(designload_floor_perarea/5000)+'$$'))
xxxxxxxxxx
deadload_beam_sub_perlength = deadload_floor_perarea * frame_y_sub_span\
+ beam_sub.density_perlength * g
liveload_beam_sub_perlength = liveload_floor_perarea * frame_y_sub_span
xxxxxxxxxx
#### 3.2.1 验算承载力
$$
\sigma=\cfrac{My}{I}<[\sigma]
$$
其中
$$
M = \cfrac{qL^2}{8}
$$
xxxxxxxxxx
designload_beam_sub_perlength = designload([deadload_beam_sub_perlength], [liveload_beam_sub_perlength])
max_moment_beam_sub = designload_beam_sub_perlength*frame_y_sub_span**2/8
max_sigma_beam_sub = max_moment_beam_sub*beam_sub.crosec_height/2/beam_sub.I
max_sigma_beam_sub
display(Markdown('$$\sigma='+str(max_sigma_beam_sub)+'$$'))
xxxxxxxxxx
小于glubam抗拉强度
按 Y. Wu, Y. Xiao, Steel and glubam hybrid space truss, Engineering Structures 171, 2018, p140, 其他材料力学性质同
$$[\sigma] = 1.06e8$$
小于glubam抗拉强度
按 Y. Wu, Y. Xiao, Steel and glubam hybrid space truss, Engineering Structures 171, 2018, p140, 其他材料力学性质同
xxxxxxxxxx
使用率
使用率
xxxxxxxxxx
max_sigma_beam_sub/1.06e8
display(Markdown('$$utilization='+str(max_sigma_beam_sub/1.06e8)+'$$'))
xxxxxxxxxx
#### 3.2.2 验算正常使用极限状态位移
$$
u = \cfrac{5qL^4}{384EI}< [u] = \cfrac{1}{250}L
$$
xxxxxxxxxx
standardload_beam_sub_perlength = standardload([deadload_beam_sub_perlength], [liveload_beam_sub_perlength])
def disp_distributed_load(q,L,E,I):
return 5*q*L**4/384/E/I
max_disp_beam_sub = disp_distributed_load(standardload_beam_sub_perlength, frame_x_span, material_glubam.E, beam_sub.I)
max_disp_beam_sub
display(Markdown('$$u='+str(max_disp_beam_sub)+'$$'))
xxxxxxxxxx
小于限值
小于限值
xxxxxxxxxx
frame_x_span/250
display(Markdown('$$[u]='+str(frame_x_span/250)+'$$'))
xxxxxxxxxx
使用率
使用率
xxxxxxxxxx
max_disp_beam_sub / (frame_x_span/250)
display(Markdown('$$utilization='+str(max_disp_beam_sub / (frame_x_span/250))+'$$'))
xxxxxxxxxx
deadload_beam_perlength = deadload_floor_perarea * frame_x_span\
+ beam_sub.density_perlength * frame_x_span * (frame_y_sub_span_n-1) * g\
+ beam.density_perlength * g
liveload_beam_perlength = liveload_floor_perarea * frame_x_span
xxxxxxxxxx
designload_beam_perlength = designload([deadload_beam_perlength], [liveload_beam_perlength])
max_moment_beam = designload_beam_perlength*frame_x_span**2/8
max_sigma_beam = max_moment_beam*beam.crosec_height/2/beam.I
max_sigma_beam
display(Markdown('$$\sigma='+str(max_sigma_beam)+'$$'))
xxxxxxxxxx
小于glubam抗拉强度
$$[\sigma] = 65.3e6$$
小于glubam抗拉强度
xxxxxxxxxx
使用率
使用率
xxxxxxxxxx
max_sigma_beam/65.3e6
display(Markdown('$$utilization='+str(max_sigma_beam/65.3e6)+'$$'))
xxxxxxxxxx
standardload_beam_perlength = standardload([deadload_beam_perlength], [liveload_beam_perlength])
def disp_distributed_load(q,L,E,I):
return 5*q*L**4/384/E/I
max_disp_beam = disp_distributed_load(standardload_beam_perlength, frame_y_span, material_glubam.E, beam.I)
max_disp_beam
display(Markdown('$$u='+str(max_disp_beam)+'$$'))
xxxxxxxxxx
小于限值
小于限值
xxxxxxxxxx
frame_y_span/250
display(Markdown('$$u='+str(frame_y_span/250)+'$$'))
xxxxxxxxxx
使用率
使用率
xxxxxxxxxx
max_disp_beam / (frame_y_span/250)
display(Markdown('$$utilization='+str(max_disp_beam / (frame_y_span/250))+'$$'))
xxxxxxxxxx
### 3.4 柱
2楼、3楼、屋面按楼面恒载,2楼、3楼按办公楼活载,屋面按雪荷载
各层柱荷载如下
xxxxxxxxxx
deadload_perstory = deadload_floor_perarea * frame_x * frame_y\
+ (beam_sub.density_perlength * frame_x * (frame_y_sub_span_n-1) * frame_y_span_n\
+ beam.density_perlength * frame_x * (frame_y_span_n+1) \
+ beam.density_perlength * frame_y * (frame_x_span_n+1))*g
deadload_roof_perarea = 500
deadload_roof = deadload_roof_perarea * frame_x * frame_y
liveload_perstory = liveload_floor_perarea * frame_x * frame_y
liveload_snow = liveload_snow_perarea * frame_x * frame_y
liveload_roof = liveload_roof_perarea * frame_x * frame_y
# 3楼 (按扣除一侧边柱)
deadload_columns_only_3 = (column.density_perlength * frame_z_3 * (frame_x_span_n+1) * (frame_y_span_n+1)) * g
deadload_columns_3 = deadload_roof + deadload_columns_only_3
liveload_columns_3 = liveload_roof
designload_columns_3 = designload([deadload_columns_3], [liveload_roof, liveload_snow])
standardload_columns_3 = standardload([deadload_columns_3], [liveload_roof, liveload_snow])
designload_column_3 = designload_columns_3/((frame_x_span_n) * (frame_y_span_n))
standardload_column_3 = standardload_columns_3/((frame_x_span_n) * (frame_y_span_n))
print("3楼单柱荷载")
display(Markdown('$$F='+str(designload_column_3)+'$$'))
# 2楼(按扣除一侧边柱)
deadload_columns_only_2 = (column.density_perlength * frame_z_2 * (frame_x_span_n+1) * (frame_y_span_n+1)) * g
deadload_columns_2 = deadload_columns_3 + deadload_perstory + deadload_columns_only_2
liveload_columns_2 = liveload_columns_3 + liveload_perstory
designload_columns_2 = designload([deadload_columns_2], [liveload_columns_2, liveload_snow])
standardload_columns_2 = standardload([deadload_columns_2], [liveload_columns_2, liveload_snow])
designload_column_2 = designload_columns_2/((frame_x_span_n) * (frame_y_span_n))
standardload_column_2 = standardload_columns_2/((frame_x_span_n) * (frame_y_span_n))
print("2楼单柱荷载")
display(Markdown('$$F='+str(designload_column_2)+'$$'))
# 1楼(按扣除一侧边柱)
deadload_columns_only_1 = (column.density_perlength * frame_z_1 * (frame_x_span_n+1) * (frame_y_span_n+1)) * g
deadload_columns_1 = deadload_columns_2 + deadload_perstory + deadload_columns_only_1
liveload_columns_1 = liveload_columns_2 + liveload_perstory
designload_columns_1 = designload([deadload_columns_1], [liveload_columns_1, liveload_snow])
standardload_columns_1 = standardload([deadload_columns_1], [liveload_columns_1, liveload_snow])
designload_column_1 = designload_columns_1/((frame_x_span_n) * (frame_y_span_n))
standardload_column_1 = standardload_columns_1/((frame_x_span_n) * (frame_y_span_n))
print("1楼单柱荷载")
display(Markdown('$$F='+str(designload_column_1)+'$$'))
xxxxxxxxxx
长细比根据GB0005-2017 p32 按胶合木计算
长细比根据GB0005-2017 p32 按胶合木计算
xxxxxxxxxx
import numpy as np
a_c = 0.91
b_c = 3.69
c_c = 3.45
beta = 1.05
E_k = 10000e6
f_ck = 71.2e6
lambda_c = c_c * np.sqrt(beta*E_k/f_ck)
lambda_c
display(Markdown('$$\lambda_c='+str(lambda_c)+'$$'))
xxxxxxxxxx
# GB0005-2017 p32
def phi(lambda_):
if lambda_ > lambda_c:
return a_c*np.pi**2*beta*E_k/lambda_**2/f_ck
else:
return 1/(1+(lambda_**2*f_ck)/(b_c*np.pi**2*beta*E_k))
# GB0005-2017 表 5.1.5 按最不利模式
k_l = 2.4
# 1层
l = k_l*frame_z_1
i = np.sqrt(column.crosec_width**2/12)
lambda_ = l/i
display(Markdown('$$\phi='+str(phi(lambda_))+'$$'))
print("等效应力")
display(Markdown('$$\sigma='+str(designload_column_1/phi(lambda_)/column.A)+'$$'))
xxxxxxxxxx
小于glubam抗压强度
小于glubam抗压强度
xxxxxxxxxx
$$[\sigma]=62.9e6$$
xxxxxxxxxx
截面安全
截面安全
xxxxxxxxxx
使用率
使用率
xxxxxxxxxx
designload_column_1/phi(lambda_)/column.A/71.2e6
display(Markdown('$$utilization='+str(designload_column_1/phi(lambda_)/column.A/62.9e6)+'$$'))
xxxxxxxxxx
符合强柱弱梁
符合强柱弱梁
xxxxxxxxxx
## 4 地震计算
根据 GB18306-2015 附录A 6度即可
根据肖老师 按7度设防
根据 GBT51226-2017 p9 4.3.4.2 可按底部剪力法计算
xxxxxxxxxx
G_eq = 1 * 3 * deadload_perstory + 1 * 2 * liveload_perstory + 0.5 * liveload_snow
m_1 = (deadload_perstory + liveload_perstory)/g
m_2 = (deadload_perstory + liveload_perstory)/g
m_3 = (deadload_roof + 0.5 * liveload_snow)/g
xxxxxxxxxx
alpha_1_common = 0.08
alpha_1_rare = 0.5
alpha_1 = alpha_1_rare
xxxxxxxxxx
G_eq = 0.85*(m_1+m_2+m_3)*g
display(Math('G_{eq} = '+str(G_eq)))
xxxxxxxxxx
F_Ek = alpha_1 * G_eq
G = [m_1 * g, m_2 * g, m_3 * g]
H = frame_z_abss
F_1s_1 = G[0]*H[0]/np.dot(G,H)*F_Ek*(1-0)
display(Math('F_{1s,1} = '+str(F_1s_1)))
xxxxxxxxxx
#### 4.1.2 按铰接 考虑斜撑(非屈曲支撑) 计算
支撑
$$0.2 \times 0.2$$
结构简化为静定桁架,支撑按轴压杆件计算
xxxxxxxxxx
v_support = Beam(material_glubam, 0.2, 0.2)
v_support_length = np.sqrt((frame_y_span/2)**2+(frame_z_1)**2)
cos_theta = (frame_y_span/2)/v_support_length
N = F_1s_1/4/cos_theta
l = k_l*v_support_length
i = np.sqrt(v_support.crosec_width**2/12)
lambda_ = l/i
display(Markdown('$$\phi='+str(phi(lambda_))+'$$'))
xxxxxxxxxx
print("等效应力")
display(Markdown('$$\sigma='+str(N/phi(lambda_)/column.A)+'$$'))
xxxxxxxxxx
小于glubam抗压强度
小于glubam抗压强度
xxxxxxxxxx
$$[\sigma] = 62.9e6$$
xxxxxxxxxx
支撑安全
支撑安全
xxxxxxxxxx
# GB50011-2010 p35
def stiffness_per_column(E, I, L):
return 12 * E*I/L**3
k_1 = (frame_y_span_n+1) * stiffness_per_column(material_glubam.E, column.I, frame_z_1)
k_2 = (frame_y_span_n+1) * stiffness_per_column(material_glubam.E, column.I, frame_z_2)
k_3 = (frame_y_span_n) * stiffness_per_column(material_glubam.E, column.I, frame_z_3)
m = np.array(
[[m_1,0,0],
[0,m_2,0],
[0,0,m_3]])
k = np.array(
[[k_1+k_2, -k_2, 0],
[ -k_2, k_2+k_3, -k_3],
[ 0, -k_3, k_3]])
xxxxxxxxxx
$$
(\mathbf{k}-\mathbf{\omega^2} \mathbf{m}) \mathbf{\phi} = \mathbf{0}
$$
xxxxxxxxxx
from scipy.linalg import eigh, det
eigvals, eigvecs = eigh(k, m, eigvals_only=False)
eigvecs_normed = eigvecs / np.linalg.norm(eigvecs, axis=0)
xxxxxxxxxx
振型
振型
xxxxxxxxxx
display(Math('\mathbf{\Phi} = '+latex_matrix(eigvecs)))
import matplotlib.pyplot as plt
plt.figure(figsize=(2, 4))
plt.plot(np.append([0],eigvecs[:,0]), np.append([0],frame_z_abss),label='$\phi_1$')
plt.plot(np.append([0],eigvecs[:,1]), np.append([0],frame_z_abss),label='$\phi_2$')
plt.plot(np.append([0],eigvecs[:,2]), np.append([0],frame_z_abss),label='$\phi_3$')
plt.legend();
plt.xlabel('$\phi$');
plt.ylabel('$z$');
xxxxxxxxxx
$w^2$
xxxxxxxxxx
display(Math('w^2 = '+latex_matrix(eigvals)))
xxxxxxxxxx
自振周期
自振周期
xxxxxxxxxx
T = []
for i, w2 in enumerate(eigvals):
T.append(2*np.pi/np.sqrt(w2))
display(Math('T = '+latex_matrix(T)))
xxxxxxxxxx
需要场地信息进行后续计算
暂按$0.1g$, $T_g = 0.4$
根据
GB50011-2010 p34 5.1.5
GB50011-2010 p36 5.2.2
按SRSS组合
需要场地信息进行后续计算
暂按,
根据
GB50011-2010 p34 5.1.5
GB50011-2010 p36 5.2.2
按SRSS组合
xxxxxxxxxx
T_g = 0.4
alpha_max = 0.5
# GB50011-2010 p34 5.1.5
def alpha(T, T_g, alpha_max, eta_2=1, zeta=0.05):
gamma = 0.9 + (0.05-zeta)/(0.3+6*zeta)
if T<0.1:
alpha = (5.5*T+0.45)*eta_2*alpha_max
elif T<T_g:
alpha = eta_2*alpha_max
elif T<5*T_g:
alpha = np.power(T_g/T,gamma)*eta_2*alpha_max
elif T<6:
eta_1 = 0.02+(0.05-zeta)/(4+32*zeta)
if eta_1<0:
eta_1 = 0
alpha = np.abs(eta_2*np.power(0.2, gamma)-eta_1*(T-5*T_g))*alpha_max
return(alpha)
G = np.array([m_1, m_2, m_3])*g
gamma_j = (eigvecs.T@G)/((eigvecs.T*eigvecs.T)@G)
alpha_j = np.array([alpha(T[0], T_g, alpha_max), alpha(T[1], T_g, alpha_max), alpha(T[2], T_g, alpha_max)])
F = eigvecs.copy()
for j in range(len(gamma_j)):
for i in range(len(G)):
F[j,i] = alpha_j[j]*gamma_j[j]*eigvecs[j,i]*G[i]
display(Math('F = '+latex_matrix(F)))
F_1s_2 = np.sqrt(sum(F[:,1]*F[:,1]))
display(Math('F_{1s,2} = '+str(F_1s_2)))
xxxxxxxxxx
# GB50011-2010 p35
v_support = Beam(material_glubam, 0.2, 0.2)
v_support_length = np.sqrt((frame_y_span/2)**2+(frame_z_1)**2)
cos_theta = (frame_y_span/2)/v_support_length
k_1 = 4 * material_glubam.E * v_support.A * cos_theta
k_2 = k_1
k_3 = k_1
m = np.array(
[[m_1,0,0],
[0,m_2,0],
[0,0,m_3]])
k = np.array(
[[k_1+k_2, -k_2, 0],
[ -k_2, k_2+k_3, -k_3],
[ 0, -k_3, k_3]])
xxxxxxxxxx
$$
(\mathbf{k}-\mathbf{\omega^2} \mathbf{m}) \mathbf{\phi} = \mathbf{0}
$$
xxxxxxxxxx
from scipy.linalg import eigh, det
eigvals, eigvecs = eigh(k, m, eigvals_only=False)
eigvecs_normed = eigvecs / np.linalg.norm(eigvecs, axis=0)
xxxxxxxxxx
振型
振型
xxxxxxxxxx
display(Math('\mathbf{\Phi} = '+latex_matrix(eigvecs)))
import matplotlib.pyplot as plt
plt.figure(figsize=(2, 4))
plt.plot(np.append([0],eigvecs[:,0]), np.append([0],frame_z_abss),label='$\phi_1$')
plt.plot(np.append([0],eigvecs[:,1]), np.append([0],frame_z_abss),label='$\phi_2$')
plt.plot(np.append([0],eigvecs[:,2]), np.append([0],frame_z_abss),label='$\phi_3$')
plt.legend();
plt.xlabel('$\phi$');
plt.ylabel('$z$');
xxxxxxxxxx
$w^2$
xxxxxxxxxx
display(Math('w^2 = '+latex_matrix(eigvals)))
xxxxxxxxxx
自振周期
自振周期
xxxxxxxxxx
T = []
for i, w2 in enumerate(eigvals):
T.append(2*np.pi/np.sqrt(w2))
display(Math('T = '+latex_matrix(T)))
xxxxxxxxxx
需要场地信息进行后续计算
暂按$0.1g$, $T_g = 0.4$
根据
GB50011-2010 p34 5.1.5
GB50011-2010 p36 5.2.2
按SRSS组合
需要场地信息进行后续计算
暂按,
根据
GB50011-2010 p34 5.1.5
GB50011-2010 p36 5.2.2
按SRSS组合
xxxxxxxxxx
T_g = 0.4
alpha_max = 0.5
# GB50011-2010 p34 5.1.5
def alpha(T, T_g, alpha_max, eta_2=1, zeta=0.05):
gamma = 0.9 + (0.05-zeta)/(0.3+6*zeta)
if T<0.1:
alpha = (5.5*T+0.45)*eta_2*alpha_max
elif T<T_g:
alpha = eta_2*alpha_max
elif T<5*T_g:
alpha = np.power(T_g/T,gamma)*eta_2*alpha_max
elif T<6:
eta_1 = 0.02+(0.05-zeta)/(4+32*zeta)
if eta_1<0:
eta_1 = 0
alpha = np.abs(eta_2*np.power(0.2, gamma)-eta_1*(T-5*T_g))*alpha_max
return(alpha)
G = np.array([m_1, m_2, m_3])*g
gamma_j = (eigvecs.T@G)/((eigvecs.T*eigvecs.T)@G)
alpha_j = np.array([alpha(T[0], T_g, alpha_max), alpha(T[1], T_g, alpha_max), alpha(T[2], T_g, alpha_max)])
F = eigvecs.copy()
for j in range(len(gamma_j)):
for i in range(len(G)):
F[j,i] = alpha_j[j]*gamma_j[j]*eigvecs[j,i]*G[i]
display(Math('F = '+latex_matrix(F)))
F_1s_2 = np.sqrt(sum(F[:,1]*F[:,1]))
display(Math('F_{1s,2} = '+str(F_1s_2)))
xxxxxxxxxx
结构简化为静定桁架,支撑按轴压杆件计算
结构简化为静定桁架,支撑按轴压杆件计算
xxxxxxxxxx
N = F_1s_2/4/cos_theta
l = k_l*v_support_length
i = np.sqrt(v_support.crosec_width**2/12)
lambda_ = l/i
display(Markdown('$$\phi='+str(phi(lambda_))+'$$'))
xxxxxxxxxx
print("等效应力")
display(Markdown('$$\sigma='+str(N/phi(lambda_)/column.A)+'$$'))
xxxxxxxxxx
小于glubam抗压强度
小于glubam抗压强度
xxxxxxxxxx
$$[\sigma] = 62.9e6$$
xxxxxxxxxx
支撑安全
支撑安全
xxxxxxxxxx
F_1s = max(F_1s_1, F_1s_2)
display(Math('F_1s = '+str(F_1s)))
xxxxxxxxxx
求解单层2榀连续钢架(与实际结构相比该结构约束不足,更加危险,因此计算是安全的),全节点固接,不考虑二阶效应,按UCB CEE220
求解单层2榀连续钢架(与实际结构相比该结构约束不足,更加危险,因此计算是安全的),全节点固接,不考虑二阶效应,按UCB CEE220
xxxxxxxxxx
EIc = material_glubam.E*column.I
EIb = material_glubam.E*beam.I
Lc = frame_z_1
Lb = frame_y_span
k11 = 12*EIc/Lc**3 * 3
k12 = -6*EIc/Lc**2
k13 = k12
k14 = k12
k21 = k12
k22 = 4*EIc/Lc + 4*EIb/Lb
k23 = EIb/Lb
k24 = 0
k31 = k13
k32 = k23
k33 = 4*EIc/Lc + 8*EIb/Lb
k34 = k23
k41 = k14
k42 = k24
k43 = k34
k44 = k22
K = np.array([
[k11,k12,k13,k14],
[k21,k22,k23,k24],
[k31,k32,k33,k34],
[k41,k42,k43,k44]
])*(frame_x_span_n+1)
display(Math('K = '+latex_matrix(K)))
P0 = np.array([F_1s, 0,0,0])
display(Math('P_0 = '+latex_matrix(P0)))
Uf = np.linalg.inv(K)@P0
print("1层广义位移")
display(Math('U_f = '+latex_matrix(Uf)))
F_1 = Uf[0]*12*EIc/Lc**3 - Uf[2]*6*EIc/Lc**2
print("1楼中柱剪力")
display(Math('F_1 = '+str(F_1)))
M_1 = Uf[0]*(-6)*EIc/Lc**2 + Uf[2]*2*EIc/Lc
print("1楼中柱支座弯矩")
display(Math('M_1 = '+str(M_1)))
xxxxxxxxxx
根据 GB50005-2017 p39 5.3.2 验算强度
根据 GB50005-2017 p39 5.3.2 验算强度
xxxxxxxxxx
N = standardload_column_1
A_n = column.A
f_c = 71.2e6
M_0 = -M_1
e_0 = 0.05 * column.crosec_height
Wn = column.I/(column.crosec_height/2)
f_m = 84.3e6
N/A_n/f_c + (M_0+N*e_0)/Wn/f_m<1
display(Math('\cfrac{N}{A_n f_c} + \cfrac{M_0+Ne_0}{Wn f_m} = '+str(N/A_n/f_c + (M_0+N*e_0)/Wn/f_m) + '<1'))
xxxxxxxxxx
根据 GB50005-2017 p39 5.3.2 验算稳定性
根据 GB50005-2017 p39 5.3.2 验算稳定性
xxxxxxxxxx
A_0 = column.A
A = column.A
k = (M_0+N*e_0)/Wn/f_m/(1+np.sqrt(N/A/f_c))
display(Math('k = \cfrac{M_0+N e_0}{Wn f_m (1+\sqrt{\cfrac{N}{A f_c}})} = '+str((M_0+N*e_0)/Wn/f_m/(1+np.sqrt(N/A/f_c)))))
k_0 = N*e_0/(Wn*f_m*(1+np.sqrt(N/A/f_c)))
display(Math('k_0 = \cfrac{N e_0}{Wn f_m (1+\sqrt{\cfrac{N}{A f_c}})} = '+str(N*e_0/(Wn*f_m*(1+np.sqrt(N/A/f_c))))))
phi_m=(1-k)**2*(1-k_0)
display(Math('\phi_m=(1-k)^2 (1-k_0) = '+str((1-k)**2*(1-k_0))))
N/phi(lambda_)/phi_m/A_0
display(Math('\cfrac{N}{\phi \phi_m A_0} = '+str(N/phi(lambda_)/phi_m/A_0) + '< ' + str(f_c)))
xxxxxxxxxx
杆件稳定
杆件稳定
xxxxxxxxxx
根据 GB50005-2017 p39 5.3.3 验算侧向稳定性
$\phi_l$ 根据GB50005-2017 p34 5.2.2 按胶合木计算
$f_{mk}$ 根据 Y. Wu, Y. Xiao, Steel and glubam hybrid space truss, Engineering Structures 171, 2018, p140 取$84.3e6$
根据 GB50005-2017 p39 5.3.3 验算侧向稳定性
根据GB50005-2017 p34 5.2.2 按胶合木计算
根据 Y. Wu, Y. Xiao, Steel and glubam hybrid space truss, Engineering Structures 171, 2018, p140 取
xxxxxxxxxx
l = k_l*frame_z_1
i = np.sqrt(column.crosec_width**2/12)
lambda_ = l/i
I_y = column.crosec_height**3*column.crosec_width/12
lambda_y = l/np.sqrt(I_y / column.A)
phi_y = phi(lambda_y)
W = I_y/(column.crosec_width/2)
a_m = 0.7
b_m = 4.9
c_m = 0.9
beta = 1.05
E_k = 10000e6
f_mk = 84.3e6
lambda_m = c_m*np.sqrt(beta*E_k/f_mk)
b = column.crosec_width
h = column.crosec_height
l_e = frame_z_1
lambda_B = np.sqrt(l_e*h/b**2)
if lambda_B>lambda_m:
phi_l = a_m*beta*E_k/lambda_B**2/f_mk
else:
phi_l = 1/(1+lambda_B**2*f_mk/b_m/beta/E_k)
N/phi_y/A_0/f_c + ((M_0)/phi_l/W/f_m)**2
display(Math('\cfrac{N}{\phi_y A_0 f_c} + (\cfrac{M_0}{\phi_l W f_m})^2 = '+str(N/phi_y/A_0/f_c + ((M_0)/phi_l/W/f_m)**2) + '<1'))
xxxxxxxxxx
侧向稳定
侧向稳定