主頁 > 軟體設計 > 如何創建以特定方式定向的繪圖函式(門戶框架-矩圖)?

如何創建以特定方式定向的繪圖函式(門戶框架-矩圖)?

2022-05-14 16:09:00 軟體設計

我是機械工程專業的學生,??我正在嘗試用 Python 為矩圖創建一個腳本。我的代碼中缺少的是如何定位矩函式以便像門戶框架一樣對齊。

Mpilar1 是第一列的矩函式(從左到右)。

Masna1 是第一個梁的力矩函式(從左到右)。

Masna2 是第二個梁的力矩函式(從左到右)。

Mpilar2 是第二列(從左到右)的矩函式。

代碼:

import math as mt
import numpy as np
import warnings
import matplotlib.pyplot as plt

warnings.filterwarnings("ignore", category=np.VisibleDeprecationWarning) 


#Definir parametros do pavilh?o

v = 20 #(V?o em metros)
h = 6 #("Altura do pilar em metros:")
ht = 8 #("Altura total metros:")



alfa = (mt.atan((int(ht)-int(h))/(int(v)/2)))*180/((mt.pi))
print("?ngulo da vertente:", round(alfa, 1), "o")
lasna = ((v/2) ** 2   (ht-h) ** 2) ** 0.5
print("Comprimento de cada asna: ", round(lasna, 2), "m")


h1 = np.arange(0, h 1, 1)
ha1 = np.arange(0, lasna, 0.1)


def draw_line():
    x_number_list = [0, 0, (v/2), v, v]
    y_number_list = [0, h, ht, h, 0]
    plt.plot(x_number_list, y_number_list, linewidth=3)
    plt.title("Pórtico", fontsize=15)
    plt.xlabel("V?o (m)", fontsize=10)
    plt.ylabel("Altura (m)", fontsize=10)
    plt.tick_params(axis='both', labelsize=9)
    plt.show()
if __name__ == '__main__':
    draw_line()
    

Mpilar1 = 1500 * h1 ** 2   350 * h1
Masna1 = 300 * ha1 ** 2   15 * ha1
Masna2 = 200 * ha1 ** 2   15 * ha1
Mpilar2 = 1400 * h1 ** 2   10 * h1


plt.plot(h1, Mpilar1)
plt.plot(ha1, Masna1)
plt.plot(ha1, Masna2)
plt.plot(h1, Mpilar2)

uj5u.com熱心網友回復:

您必須在代表曲線的點上使用變換矩陣。特別是,您必須使用旋轉平移矩陣來旋轉曲線并將其平移到正確的位置和方向,并且您可能必須應用鏡像矩陣來根據您的慣例對齊力矩。

請注意,我的結構工程時代已經一去不復返了,所以我不記得正確定位這些時刻的慣例。這留給你作為練習。

import math as mt
import numpy as np
import warnings
import matplotlib.pyplot as plt

warnings.filterwarnings("ignore", category=np.VisibleDeprecationWarning) 


#Definir parametros do pavilh?o

v = 20 #(V?o em metros)
h = 6 #("Altura do pilar em metros:")
ht = 8 #("Altura total metros:")



alfa_rad = mt.atan((int(ht)-int(h))/(int(v)/2))
alfa_deg = alfa_rad*180/mt.pi
print("?ngulo da vertente:", round(alfa_deg, 1), "o")
lasna = ((v/2) ** 2   (ht-h) ** 2) ** 0.5
print("Comprimento de cada asna: ", round(lasna, 2), "m")


h1 = np.arange(0, h 1, 1)
ha1 = np.arange(0, lasna, 0.1)

# Roto-translation matrix:
# Rotates the points by an angle theta and translates
# them by x in the horizontal direction, and y in the
# vertical direction
R = lambda x, y, theta: np.array([
    [np.cos(theta), np.sin(theta), x],
    [-np.sin(theta), np.cos(theta), y],
    [0, 0, 1],
])
# mirror matrix about the x-axis
Mx = np.array([
    [1, 0, 0], [0, -1, 0], [0, 0, 1]
])
# mirror matrix about the y-axis
My = np.array([
    [-1, 0, 0], [0, 1, 0], [0, 0, 1]
])

Mpilar1 = 1500 * h1 ** 2   350 * h1
Masna1 = 300 * ha1 ** 2   15 * ha1
Masna2 = 200 * ha1 ** 2   15 * ha1
Mpilar2 = 1400 * h1 ** 2   10 * h1

def draw_line():
    plt.figure()
    x_number_list = [0, 0, (v/2), v, v]
    y_number_list = [0, h, ht, h, 0]
    plt.plot(x_number_list, y_number_list, linewidth=3)
    
    # left column
    points1 = np.stack([h1, Mpilar1 / max(Mpilar1), np.ones_like(h1)])
    points1 = np.matmul(R(0, 0, -np.pi/2), points1)
    plt.plot(points1[0, :], points1[1, :], label="Mpilar1")
    
    # right column
    points2 = np.stack([h1, Mpilar2 / max(Mpilar2), np.ones_like(h1)])
    points2 = np.matmul(R(20, 0, -np.pi/2), points2)
    plt.plot(points2[0, :], points2[1, :], label="Mpilar2")
    
    # left asna
    points3 = np.stack([ha1, Masna1 / max(Masna1), np.ones_like(ha1)])
    points3 = np.matmul(R(0, 6, -alfa_rad), points3)
    plt.plot(points3[0, :], points3[1, :], label="Masna1")
    
    # right asna
    points4 = np.stack([ha1, Masna2 / max(Masna2), np.ones_like(ha1)])
    points4 = np.matmul(np.matmul(R(20, 6, alfa_rad), My), points4)
    plt.plot(points4[0, :], points4[1, :], label="Masna2")
    
    plt.title("Pórtico", fontsize=15)
    plt.xlabel("V?o (m)", fontsize=10)
    plt.ylabel("Altura (m)", fontsize=10)
    plt.tick_params(axis='both', labelsize=9)
    plt.legend()
    plt.show()


draw_line()

如何創建以特定方式定向的繪圖函式(門戶框架 - 矩圖)?

上面的代碼有幾點需要注意:

  • 讓我們考慮一下points1 = np.stack([h1, Mpilar1 / max(Mpilar1), np.ones_like(h1)])它創建了一個 3xn 坐標矩陣。第一行是 x 坐標,h1第二行是此刻的 y 坐標,Mpilar1 / max(Mpilar1)(請注意,我已經對它進行了維度化以適合圖表)。第三行是 1,能夠應用平移矩陣是一個技巧。在繪圖命令中,我們將只使用第一行和第二行(x 和 y 坐標)。

  • points4 = np.matmul(np.matmul(R(20, 6, alfa_rad), My), points4)在這里,我首先鏡像關于 y 軸的點,然后應用旋轉和平移。你必須玩才能正確定位這一刻!

uj5u.com熱心網友回復:

該解決方案有效,但在這種情況下,我無法獲得正確的矩圖。

代碼:

import math as mt
import numpy as np
import warnings
import matplotlib.pyplot as plt

warnings.filterwarnings("ignore", category=np.VisibleDeprecationWarning) 


#Definir parametros do pavilh?o

v = 20 #(V?o em metros)
h = 6 #("Altura do pilar em metros:")
ht = 8 #("Altura total metros:")
nm = 7 #("Número de madres por asna:")
npo = 5 #("Número de pórticos:")
dp = 5 #("Distancia entre pórticos em metros:")


alfa_rad = mt.atan((int(ht)-int(h))/(int(v)/2))
alfa_deg = alfa_rad*180/mt.pi

alfa = (mt.atan((int(ht)-int(h))/(int(v)/2)))*180/((mt.pi))
print("?ngulo da vertente:", round(alfa, 1), "o")

lasna = ((v/2) ** 2   (ht-h) ** 2) ** 0.5
print("Comprimento de cada asna: ", round(lasna, 2), "m")

dm = lasna / nm
print(("Distancia entre madres da cobertura em metros:"), round(dm, 2), "m")    
   
lp = npo * dp
print("Comprimento total do pavilh?o:", round(lp, 1), "m")

def draw_line():
    # x axis value list.
    x_number_list = [0, 0, (v/2), v, v]
    # y axis value list.
    y_number_list = [0, h, ht, h, 0]
    # Plot the number in the list and set the line thickness.
    plt.plot(x_number_list, y_number_list, linewidth=3)
    # Set the line chart title and the text font size.
    plt.title("Pórtico", fontsize=15)
    # Set x axis label.
    plt.xlabel("V?o (m)", fontsize=10)
    # Set y axis label.
    plt.ylabel("Altura (m)", fontsize=10)
    # Set the x, y axis tick marks text size.
    plt.tick_params(axis='both', labelsize=9)
    # Display the plot in the matplotlib's viewer.
    plt.show()
if __name__ == '__main__':
    draw_line()


#EXEMPLO - IPE 100

pppilar = 8.1 #variavel do peso próprio do pilar
arpilar = 10.32 * 10 ** -4 #variavél da área de sec??o do pilar - m^2
inypilar = 171 * 10 ** -8 #variavél da inércia pilar segundo y - m^4


ppasna = 8.1 #variavel do peso próprio da asna
arasna = 10.32 * 10 ** -4 #variavél da área de sec??o do pilar - m^2
inyasna = 171 * 10 ** -8 #variavél da inércia pilar - m^4
    
        

pesomadre = 4.84 #(Peso linear das madres de cobertura em kg/m)
pesopainel = 11.2 #(Peso painel revestimento kg/m2)


rotulado = 1
base = rotulado




#Definir a??es


ppcobertura = (pesopainel * dp   ((pesomadre*dp)/dm)   ppasna) * 9.81 / 1000 #kN/m
#print("Peso próprio da cobertura:", round(ppcobertura, 1), "kN/m")

#Sobrecarga
qk = 0.4 #Sobrecarga em kN/m2
sb = qk * dp #Sobrecarga em kN/m

#Neve
Sk = 0.5 #Neve em kN/m2
ne = Sk * dp #Neve em kN/m

#Vento
Qp1 = 0.5 #Vento pilar 1 em kN/m2
vnp1 = Qp1 * dp #Vento pilar 1 em kN/m

Qp2 = 0.5 #Vento pilar 2 em kN/m2
vnp2 = Qp2 * dp #Vento pilar 2 em kN/m

Qa1 = 0.5 #Vento asna 1 em kN/m2
vna1 = Qa1 * dp #Vento asna 1 em kN/m

Qa2 = 0.5 #Vento asna 2 em kN/m2
vna2 = Qa2 * dp #Vento asna 2 em kN/m

#Decompor as a??es em normal e tagencial

ppcoberturan = ppcobertura * mt.cos(alfa*mt.pi/180)
ppcoberturat = ppcobertura * mt.sin(alfa*mt.pi/180)

sbn = sb * mt.cos(alfa*mt.pi/180) * mt.cos(alfa*mt.pi/180)
sbt = sb * mt.cos(alfa*mt.pi/180) * mt.sin(alfa*mt.pi/180)

nen = ne * mt.cos(alfa*mt.pi/180) * mt.cos(alfa*mt.pi/180)
net = ne * mt.cos(alfa*mt.pi/180) * mt.sin(alfa*mt.pi/180)

#Coeficientes de majora??o
    
psipp = 1.35  
#print("\u03A8 peso próprio:", psipp)

psi0sb = 0   
#print("\u03A8 0 sobrecarga:", psi0sb)

psi1sb = 0

#print("\u03A8 1 sobrecarga:", psi1sb)

psi2sb = 0
#print("\u03A8 2 sobrecarga:", psi2sb)

ne1 = 1
ne2 = 2

nete = ne1



if nete == ne1:
    
    psi0ne = 0.5
    #print("\u03A8 0 neve:", psi0ne)

    psi1ne = 0.2
    #print("\u03A8 1 neve:", psi1ne)

    psi2ne = 0
    #print("\u03A8 2 neve:", psi2ne)




psi0vn = 0.6
#print("\u03A8 0 vento:", psi0vn)

psi1vn = 0.2
#print("\u03A8 1 vento:", psi1vn)

psi2vn = 0  
#print("\u03A8 2 vento:", psi2vn)



#Combina??o das a??es para a cobertura - ELU - asna 1 - normal


comb_sbn = (psipp * ppcoberturan   sbn * 1.5   (1.5 * psi0ne * nen   1.5 * psi0vn * vna1)) * 1000 #N/m

comb_vnn = (psipp * ppcoberturan   vna1 * 1.5   (1.5 * psi0ne * nen   1.5 * sbn * psi0sb)) * 1000 #N/m

comb_nen =( psipp * ppcoberturan   nen * 1.5   (1.5 * psi0vn * vna1   1.5 * sbn * psi0sb)) * 1000 #N/m

if (comb_sbn >= comb_vnn) and (comb_sbn >= comb_nen):
   comb_a1n = comb_sbn
elif (comb_vnn >= comb_sbn) and (comb_vnn >= comb_nen):
   comb_a1n = comb_vnn
else:
   comb_a1n = comb_nen
   
   
   
#Combina??o das a??es para a cobertura - ELU - asna 1 - tangencial

comb_sbt = (psipp * ppcoberturat   sbt * 1.5   (1.5 * psi0ne * net   1.5 * psi0vn * 0)) * 1000 #N/m

comb_vnt = (psipp * ppcoberturat   0 * 1.5   (1.5 * psi0ne * net   1.5 * sbt * psi0sb)) * 1000 #N/m

comb_net = (psipp * ppcoberturat   net * 1.5   (1.5 * psi0vn * 0   1.5 * sbt * psi0sb)) * 1000 #N/m

if (comb_sbn >= comb_vnn) and (comb_sbn >= comb_nen):
   comb_a1t = comb_sbt
elif (comb_vnn >= comb_sbn) and (comb_vnn >= comb_nen):
   comb_a1t = comb_vnt
else:
   comb_a1t = comb_net



#Combina??o das a??es para a cobertura - ELU - asna 2 - normal

comb_sb2n = (psipp * ppcoberturan   sbn * 1.5   (1.5 * psi0ne * nen   1.5 * psi0vn * vna2)) * 1000 #N/m

comb_vn2n = (psipp * ppcoberturan   vna2 * 1.5   (1.5 * psi0ne * nen   1.5 * sbn * psi0sb)) * 1000 #N/m

comb_ne2n = (psipp * ppcoberturan    nen * 1.5   (1.5 * psi0vn * vna2   1.5 * sbn * psi0sb)) * 1000 #N/m

if (comb_sb2n >= comb_vn2n) and (comb_sb2n >= comb_ne2n):
   comb_a2n = comb_sb2n
elif (comb_vn2n >= comb_sb2n) and (comb_vn2n >= comb_ne2n):
   comb_a2n = comb_vn2n
else:
   comb_a2n = comb_ne2n
   


#Combina??o das a??es para a cobertura - ELU - asna 2 - tangencial

comb_sbt2 = (psipp * ppcoberturat   sbt * 1.5   (1.5 * psi0ne * net   1.5 * psi0vn * 0)) * 1000 #N/m

comb_vnt2 = (psipp * ppcoberturat   0 * 1.5   (1.5 * psi0ne * net   1.5 * sbt * psi0sb)) * 1000 #N/m

comb_net2 = (psipp * ppcoberturat    net * 1.5   (1.5 * psi0vn * 0   1.5 * sbt * psi0sb)) * 1000 #N/m

if (comb_sb2n >= comb_vn2n) and (comb_sb2n >= comb_ne2n):
   comb_a2t = comb_sbt2
elif (comb_vn2n >= comb_sb2n) and (comb_vn2n >= comb_ne2n):
   comb_a2t = comb_vnt2
else:
   comb_a2t = comb_net2
   

   

#Elementos finitos - Rea??es e deslocamentos

E = 210 * 10 ** 9 #módulo de elasticidade do a?o em Pa

#Elemento 1 - asna1

a1 = E * arpilar / h
b1 = 12 * E * inypilar / h**3
c1 = 6 * E * inypilar / h**2
d1 = 4 * E * inypilar / h
e1 = 2 * E * inypilar / h

alfa1 = 90 * mt.pi / 180

l1 = mt.cos(alfa1)
m1 = mt.sin(alfa1)

t1 = np.matrix([[l1, m1, 0, 0, 0, 0],
                [-m1, l1, 0, 0, 0, 0],
                [0, 0 , 1, 0, 0, 0],
                [0, 0, 0, l1, m1, 0],
                [0, 0, 0, -m1, l1, 0],
                [0 , 0, 0, 0, 0, 1]])


k1local = np.matrix([[a1, 0, 0, -a1, 0, 0],
                     [0, b1, c1, 0, -b1, c1],
                     [0, c1, d1, 0, -c1, e1],
                     [-a1, 0, 0, a1, 0, 0],
                     [0, -b1, -c1, 0, b1, -c1],
                     [0, c1, e1, 0, -c1, d1]])

invt1 = np.matrix.transpose(t1)

k1global = np.linalg.multi_dot([invt1, k1local, t1])

#Elmento 2 - asna 1

a2 = E * arasna / lasna
b2 = 12 * E *inyasna / lasna**3
c2 = 6 * E * inyasna / lasna**2
d2 = 4 * E * inyasna / lasna
e2 = 2 * E *inyasna / lasna

alfa2 = ((alfa) * mt.pi) / 180

l2 = mt.cos(alfa2)
m2 = mt.sin(alfa2)

t2 = np.matrix([[l2, m2, 0, 0, 0, 0],
                [-m2, l2, 0, 0, 0, 0],
                [0, 0 , 1, 0, 0, 0],
                [0, 0, 0, l2, m2, 0],
                [0, 0, 0, -m2, l2, 0],
                [0 , 0, 0, 0, 0, 1]])

k2local = np.matrix([[a2, 0, 0, -a2, 0, 0],
                     [0, b2, c2, 0, -b2, c2],
                     [0, c2, d2, 0, -c2, e2],
                     [-a2, 0, 0, a2, 0, 0],
                     [0, -b2, -c2, 0, b2, -c2],
                     [0, c2, e2, 0, -c2, d2]])

invt2 = np.matrix.transpose(t2)

k2global = np.linalg.multi_dot([invt2, k2local, t2])

#Elmento 3 - asna 2

a3 = E * arasna / lasna
b3 = 12 * E *inyasna / lasna**3
c3 = 6 * E * inyasna / lasna**2
d3 = 4 * E * inyasna / lasna
e3 = 2 * E *inyasna / lasna

alfa3 = -alfa2

l3 = mt.cos(alfa3)
m3 = mt.sin(alfa3)

t3 = np.matrix([[l3, m3, 0, 0, 0, 0],
                [-m3, l3, 0, 0, 0, 0],
                [0, 0 , 1, 0, 0, 0],
                [0, 0, 0, l3, m3, 0],
                [0, 0, 0, -m3, l3, 0],
                [0 , 0, 0, 0, 0, 1]])

k3local = np.matrix([[a3, 0, 0, -a3, 0, 0],
                     [0, b3, c3, 0, -b3, c3],
                     [0, c3, d3, 0, -c3, e3],
                     [-a3, 0, 0, a3, 0, 0],
                     [0, -b3, -c3, 0, b3, -c3],
                     [0, c3, e3, 0, -c3, d3]])

invt3 = np.matrix.transpose(t3)

k3global = np.linalg.multi_dot([invt3, k3local, t3])

#Elmento 4 - pilar 2

a4 = E * arpilar / h
b4 = 12 * E *inypilar / h**3
c4 = 6 * E * inypilar / h**2
d4 = 4 * E * inypilar / h
e4 = 2 * E *inypilar / h

alfa4 = -(90 * mt.pi/180)

l4 = mt.cos(alfa4)
m4 = mt.sin(alfa4)

t4 = np.matrix([[l4, m4, 0, 0, 0, 0],
                [-m4, l4, 0, 0, 0, 0],
                [0, 0 , 1, 0, 0, 0],
                [0, 0, 0, l4, m4, 0],
                [0, 0, 0, -m4, l4, 0],
                [0 , 0, 0, 0, 0, 1]])

k4local = np.matrix([[a4, 0, 0, -a4, 0, 0],
                     [0, b4, c4, 0, -b4, c4],
                     [0, c4, d4, 0, -c4, e4],
                     [-a4, 0, 0, a4, 0, 0],
                     [0, -b4, -c4, 0, b4, -c4],
                     [0, c4, e4, 0, -c4, d4]])

invt4 = np.matrix.transpose(t4)

k4global = np.linalg.multi_dot([invt4, k4local, t4])


k = [k1global, k2global, k3global, k4global]

kportico = np.zeros([15,15])

for i,m in enumerate(k):
    kportico[i*3:i*3 6,i*3:i*3 6]  = m



#[K] * {U} = {F} - ELU

F12x = (comb_a1n * lasna / 2) * mt.sin((alfa*mt.pi) / 180)
F12y = (comb_a1n * lasna / 2) * mt.cos((alfa*mt.pi) / 180)

F22x = (comb_a1t * lasna / 2) * mt.cos((alfa*mt.pi) / 180)
F22y = (comb_a1t* lasna / 2) * mt.sin((alfa*mt.pi) / 180)

F13x = F12x
F13y = F12y

F23x = F22x
F23y = F22y

F33x = (comb_a2n * lasna / 2) * mt.sin((alfa*mt.pi) / 180)
F33y = (comb_a2n * lasna / 2) * mt.cos((alfa*mt.pi) / 180)

F43x = (comb_a2t * lasna / 2) * mt.cos((alfa*mt.pi) / 180)
F43y = (comb_a2t * lasna / 2) * mt.sin((alfa*mt.pi) / 180)

F14x = F33x
F14y = F33y

F24x = F43x
F24y = F43y

                                 


F1x = (vnp1 * 1000 * h) / 2
F1y = 0
M1 = -(vnp1 * 1000 * h ** 2) / 12

F2x = int((vnp1 * 1000 * h / 2)   F12x - F22x)
F2y = - F12y - F22y
M2 = ((vnp1 * 1000 * h ** 2) / 12) - ((comb_a1n * lasna ** 2) / 12)

F3x = F13x - F23x - F33x   F43x
F3y = -F13y - F23y - F33y - F43y
M3 = ((comb_a1n * lasna ** 2) / 12) - ((comb_a2n * lasna ** 2) / 12)

F4x = (vnp2 * h * 1000 / 2)   F24x - F14x
F4y = - F14y - F24y
M4 = - ((vnp2 * 1000 * h ** 2) / 12)   ((comb_a2n * lasna ** 2) / 12)


F5x = (vnp2 * 1000 * h) / 2
F5y = 0
M5 = (vnp2 * 1000 * h ** 2) / 12




f = np.array([[F1x],
              [F1y],
              [M1],
              [F2x],
              [F2y],
              [M2],
              [F3x],
              [F3y],
              [M3],
              [F4x],
              [F4y],
              [M4],
              [F5x],
              [F5y],
              [M5]])

fel1 = np.array([[(vnp1 * 1000 * h) / 2],
                 [0],
                 [-(vnp1 * 1000 * h ** 2) / 12],
                 [(vnp1 * 1000 * h) / 2],
                 [0],
                 [(vnp1 * 1000 * h ** 2) / 12]])

fel2 = np.array([[(comb_a1n * lasna / 2) * mt.sin(alfa2) - (comb_a1t * lasna / 2) * mt.cos(alfa2)],
                 [- (comb_a1n * lasna / 2) * mt.cos(alfa2) - (comb_a1t * lasna / 2) * mt.sin(alfa2)],
                 [-(comb_a1n * lasna ** 2) / 12],
                 [(comb_a1n * lasna / 2) * mt.sin(alfa2) - (comb_a1t * lasna / 2) * mt.cos(alfa2)],
                 [- (comb_a1n * lasna / 2) * mt.cos(alfa2) - (comb_a1t * lasna / 2) * mt.sin(alfa2)],
                 [(comb_a1n * lasna ** 2) / 12]])

fel3 = np.array([[( - comb_a2n * lasna / 2) * mt.sin(-alfa3)   (comb_a2t * lasna / 2) * mt.cos(-alfa3)],
                 [( - comb_a2n * lasna / 2) * mt.cos(-alfa3) - (comb_a2t * lasna / 2) * mt.sin(-alfa3)],
                 [-(comb_a2n * lasna ** 2) / 12],
                 [( - comb_a2n * lasna / 2) * mt.sin(-alfa3)   (comb_a2t * lasna / 2) * mt.cos(-alfa3)],
                 [( - comb_a2n * lasna / 2) * mt.cos(-alfa3) - (comb_a2t * lasna / 2) * mt.sin(-alfa3)],
                 [(comb_a2n * lasna ** 2) / 12]])

fel4 = np.array([[(vnp2 * 1000 * h) / 2],
                 [0],
                 [-(vnp2 * 1000 * h ** 2) / 12],
                 [(vnp2 * 1000 * h) / 2],
                 [0],
                 [(vnp2 * 1000 * h ** 2) / 12]])





    

if base == rotulado:
    
    u = np.dot(np.linalg.pinv(kportico[np.ix_([2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 14], [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 14])]), f[np.ix_([2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 14])])
    
    utotal = np.array([[0],
                       [0],
                       [u[0]],
                       [u[1]],
                       [u[2]],
                       [u[3]],
                       [u[4]],
                       [u[5]],
                       [u[6]],
                       [u[7]],
                       [u[8]],
                       [u[9]],
                       [0],
                       [0],
                       [u[10]]])
                     
    
    r = np.dot(kportico, utotal) - f
    
    rp = np.array([[r[0]],
                   [r[1]],
                   [r[12]],
                   [r[13]]])
    
    rv = np.array([["R1x ="],
                   ["R1y ="],
                   ["R5x ="],
                   ["R5y ="]])
    
    uni = np.array([["N"],
                   ["N"],
                   ["N"],
                   ["N"]])
    
    
    size = len(rv)
    
    print(" ")
    print(" ")
    
    if len(rv) == len(rp) and len(rv) == len(uni):
        for x in range(size):
            print(rv[x],rp[x],uni[x])

        
    Fpilar1 = np.dot(k1global, utotal[0:6]) - fel1 #ESFOR?OS NóS PILAR 1
        
    Fasna1 = np.dot(k2global, utotal[3:9]) - fel2 #ESFOR?OS NóS ASNA 1
        
    Fasna2 = np.dot(k3global, utotal[6:12]) - fel3 #ESFOR?OS NóS ASNA 2
        
    Fpilar2 = np.dot(k4global, utotal[9:15]) - fel4 #ESFOR?OS NóS PILAR 2
    
    
    #Diagrama de esfor?o transverso e momentos fletores
    
    fig, ax = plt.subplots()
    
    h1 = np.arange(0, h 1, 1)
    ha1 = np.arange(0, lasna, 0.1)
    ha2 = np.arange(0, lasna, 0.1)
    hp2 = np.arange(0, h 1, 1)
    
    Mpilar1 = ((-vnp1 * 1000 * h1 ** 2 / 2) - float(Fpilar1[0]) * h1 - float(Fpilar1[2])) / 1000
    Masna1 = (((- comb_a1n * ha1 ** 2 ) / 2)   (float(Fasna1[1]) * mt.cos(alfa2) - float(Fasna1[0]) * mt.sin(alfa2)) * ha1 - float(Fasna1[2])) / 1000
    Masna2 = (((- comb_a2n * ha2 ** 2 ) / 2)   (float(Fasna2[1]) * mt.cos(alfa2)   float(Fasna2[0]) * mt.sin(alfa2)) * ha2 - float(Fasna2[2])) / 1000
    Mpilar2 = ((vnp2 * 1000 * hp2 ** 2 / 2)   float(Fpilar2[0]) * hp2 - float(Fpilar2[2])) / 1000
    
    # Roto-translation matrix:
    # Rotates the points by an angle theta and translates
    # them by x in the horizontal direction, and y in the
    # vertical direction
    R = lambda x, y, theta: np.array([
        [np.cos(theta), np.sin(theta), x],
        [-np.sin(theta), np.cos(theta), y],
        [0, 0, 1],
    ])
    # mirror matrix about the x-axis
    Mx = np.array([
        [1, 0, 0], [0, -1, 0], [0, 0, 1]
    ])
    # mirror matrix about the y-axis
    My = np.array([
        [-1, 0, 0], [0, 1, 0], [0, 0, 1]
    ])
    
    def draw_line():
        plt.figure()
        x_number_list = [0, 0, (v/2), v, v]
        y_number_list = [0, h, ht, h, 0]
        plt.plot(x_number_list, y_number_list, linewidth=3)
        
        # left column
        points1 = np.stack([h1, Mpilar1 / max(Mpilar1), np.ones_like(h1)])
        points1 = np.matmul(R(0, 0, -np.pi/2), points1)
        plt.plot(points1[0, :], points1[1, :], label="Mpilar1")
        
        # right column
        points2 = np.stack([h1, Mpilar2 / max(Mpilar2), np.ones_like(h1)])
        points2 = np.matmul(R(20, 0, -np.pi/2), points2)
        plt.plot(points2[0, :], points2[1, :], label="Mpilar2")
        
        # left asna
        points3 = np.stack([ha1, Masna1 / max(Masna1), np.ones_like(ha1)])
        points3 = np.matmul(R(0, 6, -alfa_rad), points3)
        plt.plot(points3[0, :], points3[1, :], label="Masna1")
        
        # right asna
        points4 = np.stack([ha1, Masna2 / max(Masna2), np.ones_like(ha1)])
        points4 = np.matmul(np.matmul(R(20, 6, alfa_rad), My), points4)
        plt.plot(points4[0, :], points4[1, :], label="Masna2")
        
        plt.title("Pórtico", fontsize=15)
        plt.xlabel("V?o (m)", fontsize=10)
        plt.ylabel("Altura (m)", fontsize=10)
        plt.tick_params(axis='both', labelsize=9)
        plt.legend()
        plt.show()


    draw_line()

    
    

轉載請註明出處,本文鏈接:https://www.uj5u.com/ruanti/473862.html

標籤:Python matplotlib 阴谋

上一篇:python:使用子圖作為其他子圖的圖例

下一篇:Matplotlib/Mplfinance-如何更改線寬

標籤雲
其他(157675) Python(38076) JavaScript(25376) Java(17977) C(15215) 區塊鏈(8255) C#(7972) AI(7469) 爪哇(7425) MySQL(7132) html(6777) 基礎類(6313) sql(6102) 熊猫(6058) PHP(5869) 数组(5741) R(5409) Linux(5327) 反应(5209) 腳本語言(PerlPython)(5129) 非技術區(4971) Android(4554) 数据框(4311) css(4259) 节点.js(4032) C語言(3288) json(3245) 列表(3129) 扑(3119) C++語言(3117) 安卓(2998) 打字稿(2995) VBA(2789) Java相關(2746) 疑難問題(2699) 细绳(2522) 單片機工控(2479) iOS(2429) ASP.NET(2402) MongoDB(2323) 麻木的(2285) 正则表达式(2254) 字典(2211) 循环(2198) 迅速(2185) 擅长(2169) 镖(2155) 功能(1967) .NET技术(1958) Web開發(1951) python-3.x(1918) HtmlCss(1915) 弹簧靴(1913) C++(1909) xml(1889) PostgreSQL(1872) .NETCore(1853) 谷歌表格(1846) Unity3D(1843) for循环(1842)

熱門瀏覽
  • 面試突擊第一季,第二季,第三季

    第一季必考 https://www.bilibili.com/video/BV1FE411y79Y?from=search&seid=15921726601957489746 第二季分布式 https://www.bilibili.com/video/BV13f4y127ee/?spm_id_fro ......

    uj5u.com 2020-09-10 05:35:24 more
  • 第三單元作業總結

    1.前言 這應該是本學期最后一次寫作業總結了吧。總體來說,對作業的節奏也差不多掌握了,作業做起來的效率也更高了。雖然和之前的作業一樣,作業中都要用到新的知識,但是相比之前,更加懂得了如何利用工具以及資料。雖然之間卡過殼,但總體而言,這幾次作業還算完成的比較好。 2.作業程序總結 相比前兩個單元,此單 ......

    uj5u.com 2020-09-10 05:35:41 more
  • 北航OO(2020)第四單元博客作業暨課程總結博客

    北航OO(2020)第四單元博客作業暨課程總結博客 本單元作業的架構設計 在本單元中,由于UML圖具有比較清晰的樹形結構,因此我對其中需要進行查詢操作的元素進行了包裝,在樹的父節點中存盤所有孩子的參考。考慮到性能問題,我采用了快取機制,一次查詢后盡可能快取已經遍歷過的資訊,以減少遍歷次數。 本單元我 ......

    uj5u.com 2020-09-10 05:35:48 more
  • BUAA_OO_第四單元

    一、UML決議器設計 ? 先看下題目:第四單元實作一個基于JDK 8帶有效性檢查的UML(Unified Modeling Language)類圖,順序圖,狀態圖分析器 MyUmlInteraction,實際上我們要建立一個有向圖模型,UML中的物件(元素)可能與同級元素連接,也可與低級元素相連形成 ......

    uj5u.com 2020-09-10 05:35:54 more
  • 6.1邏輯運算子

    邏輯運算子 1. && 短路與 運算式1 && 運算式2 01.運算式1為true并且運算式2也為true 整體回傳為true 02.運算式1為false,將不會執行運算式2 整體回傳為false 03.只要有一個運算式為false 整體回傳為false 2. || 短路或 運算式1 || 運算式2 ......

    uj5u.com 2020-09-10 05:35:56 more
  • BUAAOO 第四單元 & 課程總結

    1. 第四單元:StarUml檔案決議 本單元采用了圖模型決議UML。 UML檔案可以抽象為圖、子圖、邊的邏輯結構。 在實作中,圖的節點包括類、介面、屬性,子圖包括狀態圖、順序圖等。 采用了三次遍歷UML元素的方法建圖,第一遍遍歷建點,第二、三次遍歷設定屬性、連邊,實作圖物件的初始化。這里借鑒了一些 ......

    uj5u.com 2020-09-10 05:36:06 more
  • 談談我對C# 多型的理解

    面向物件三要素:封裝、繼承、多型。 封裝和繼承,這兩個比較好理解,但要理解多型的話,可就稍微有點難度了。今天,我們就來講講多型的理解。 我們應該經常會看到面試題目:請談談對多型的理解。 其實呢,多型非常簡單,就一句話:呼叫同一種方法產生了不同的結果。 具體實作方式有三種。 一、多載 多載很簡單。 p ......

    uj5u.com 2020-09-10 05:36:09 more
  • Python 資料驅動工具:DDT

    背景 python 的unittest 沒有自帶資料驅動功能。 所以如果使用unittest,同時又想使用資料驅動,那么就可以使用DDT來完成。 DDT是 “Data-Driven Tests”的縮寫。 資料:http://ddt.readthedocs.io/en/latest/ 使用方法 dd. ......

    uj5u.com 2020-09-10 05:36:13 more
  • Python里面的xlrd模塊詳解

    那我就一下面積個問題對xlrd模塊進行學習一下: 1.什么是xlrd模塊? 2.為什么使用xlrd模塊? 3.怎樣使用xlrd模塊? 1.什么是xlrd模塊? ?python操作excel主要用到xlrd和xlwt這兩個庫,即xlrd是讀excel,xlwt是寫excel的庫。 今天就先來說一下xl ......

    uj5u.com 2020-09-10 05:36:28 more
  • 當我們創建HashMap時,底層到底做了什么?

    jdk1.7中的底層實作程序(底層基于陣列+鏈表) 在我們new HashMap()時,底層創建了默認長度為16的一維陣列Entry[ ] table。當我們呼叫map.put(key1,value1)方法向HashMap里添加資料的時候: 首先,呼叫key1所在類的hashCode()計算key1 ......

    uj5u.com 2020-09-10 05:36:38 more
最新发布
  • 【中介者設計模式詳解】C/Java/JS/Go/Python/TS不同語言實作

    * 中介者模式是一種行為型設計模式,它可以用來減少類之間的直接依賴關系,
    * 將物件之間的通信封裝到一個中介者物件中,從而使得各個物件之間的關系更加松散。
    * 在中介者模式中,物件之間不再直接相互互動,而是通過中介者來中轉訊息。 ......

    uj5u.com 2023-04-20 08:20:47 more
  • 露天煤礦現場調研和交流案例分享

    他們集團的資訊化公司及研究院在一個礦區正在做智能礦山的統一平臺的 試點,專案投資大概1億,包括了礦山的各方面的內容,顯示得我們這次交流有點多余。他們2年前開始做智能礦山的規劃,有很多煤礦行業專家的加持,他們的描述是非常完美,但是去年底應該上線的平臺,現在還沒有看到影子。他們確實有很多場景需求,但是被... ......

    uj5u.com 2023-04-20 08:20:25 more
  • 《社區人員管理》實戰案例設計&個人案例分享

    設計是一個讓人夢想成真程序,開始編碼、測驗、除錯之前進行需求分析和架構設計,才能保證關鍵方面都做正確 ......

    uj5u.com 2023-04-20 08:20:17 more
  • 軟體架構生態化-多角色交付的探索實踐

    作為一個技術架構師,不僅僅要緊跟行業技術趨勢,還要結合研發團隊現狀及痛點,探索新的交付方案。在日常中,你是否遇到如下問題 “ 業務需求排期長研發是瓶頸;非研發角色感受不到研發技改提效的變化;引入ISV 團隊又擔心質量和安全,培訓周期長“等等,基于此我們探索了一種新的技術體系及交付方案來解決如上問題。 ......

    uj5u.com 2023-04-20 08:20:10 more
  • 【中介者設計模式詳解】C/Java/JS/Go/Python/TS不同語言實作

    * 中介者模式是一種行為型設計模式,它可以用來減少類之間的直接依賴關系,
    * 將物件之間的通信封裝到一個中介者物件中,從而使得各個物件之間的關系更加松散。
    * 在中介者模式中,物件之間不再直接相互互動,而是通過中介者來中轉訊息。 ......

    uj5u.com 2023-04-20 08:19:44 more
  • 露天煤礦現場調研和交流案例分享

    他們集團的資訊化公司及研究院在一個礦區正在做智能礦山的統一平臺的 試點,專案投資大概1億,包括了礦山的各方面的內容,顯示得我們這次交流有點多余。他們2年前開始做智能礦山的規劃,有很多煤礦行業專家的加持,他們的描述是非常完美,但是去年底應該上線的平臺,現在還沒有看到影子。他們確實有很多場景需求,但是被... ......

    uj5u.com 2023-04-20 08:19:07 more
  • 《社區人員管理》實戰案例設計&個人案例分享

    設計是一個讓人夢想成真程序,開始編碼、測驗、除錯之前進行需求分析和架構設計,才能保證關鍵方面都做正確 ......

    uj5u.com 2023-04-20 08:18:57 more
  • 軟體架構生態化-多角色交付的探索實踐

    作為一個技術架構師,不僅僅要緊跟行業技術趨勢,還要結合研發團隊現狀及痛點,探索新的交付方案。在日常中,你是否遇到如下問題 “ 業務需求排期長研發是瓶頸;非研發角色感受不到研發技改提效的變化;引入ISV 團隊又擔心質量和安全,培訓周期長“等等,基于此我們探索了一種新的技術體系及交付方案來解決如上問題。 ......

    uj5u.com 2023-04-20 08:18:49 more
  • 05單件模式

    #經典的單件模式 public class Singleton { private static Singleton uniqueInstance; //一個靜態變數持有Singleton類的唯一實體。 // 其他有用的實體變數寫在這里 //構造器宣告為私有,只有Singleton可以實體化這個類! ......

    uj5u.com 2023-04-19 08:42:51 more
  • 【架構與設計】常見微服務分層架構的區別和落地實踐

    軟體工程的方方面面都遵循一個最基本的道理:沒有銀彈,架構分層模型更是如此,每一種都有各自優缺點,所以請根據不同的業務場景,并遵循簡單、可演進這兩個重要的架構原則選擇合適的架構分層模型即可。 ......

    uj5u.com 2023-04-19 08:42:41 more