# ver_reticulado_3d(ret)
ret.agregar_restriccion(0, 0, 0)
ret.agregar_restriccion(0, 1, 0)
ret.agregar_restriccion(0, 2, 0)
ret.agregar_restriccion(2, 2, 0)
ret.agregar_restriccion(5, 2, 0)
ret.agregar_restriccion(7, 2, 0)
ret.agregar_restriccion(5, 0, 0)
ret.agregar_fuerza(4, 2, -F)
peso = ret.calcular_peso_total()
print(f"peso = {peso}")
ret.ensamblar_sistema()
ret.resolver_sistema()
f = ret.recuperar_fuerzas()
fu = ret.recuperar_factores_de_utilizacion(f)
ver_reticulado_3d(ret,
opciones_nodos={
"usar_posicion_deformada": True,
"factor_amplificacion_deformada": 30.,
},
opciones_barras={
"color_barras_por_dato": True,
def fun(H, graficar=False):
# Unidades base
m = 1.
kg = 1.
s = 1.
#Unidades derivadas
N = kg * m / s**2
cm = 0.01 * m
mm = 0.001 * m
KN = 1000 * N
Pa = N / m**2
KPa = 1000 * Pa
MPa = 1000 * KPa
GPa = 1000 * MPa
#Parametros
L = 5.0 * m
F = 100 * KN
B = 2.0 * m
#Inicializar modelo
ret = Reticulado()
#Nodos
ret.agregar_nodo(0, 0, 0)
ret.agregar_nodo(L, 0, 0)
ret.agregar_nodo(2 * L, 0, 0)
ret.agregar_nodo(L / 2, B / 2, H)
ret.agregar_nodo(3 * L / 2, B / 2, H)
ret.agregar_nodo(0, B, 0)
ret.agregar_nodo(L, B, 0)
ret.agregar_nodo(2 * L, B, 0)
#Barras
A = (1.1 * cm)**2
r = sqrt(A / 3.141593)
props = [r, r, 200 * GPa, 7600 * kg / m**3, 420 * MPa]
props2 = [r, r, 200 * GPa, 7600 * kg / m**3, 420 * MPa]
# props2 = [0.6*r, 0.6*r, 200*GPa, 7600*kg/m**3, 420*MPa]
ret.agregar_barra(Barra(0, 1, *props)) # 0
ret.agregar_barra(Barra(1, 2, *props)) # 1
ret.agregar_barra(Barra(3, 4, *props)) # 2
ret.agregar_barra(Barra(0, 3, *props2)) # 3
ret.agregar_barra(Barra(3, 1, *props2)) # 4
ret.agregar_barra(Barra(1, 4, *props2)) # 5
ret.agregar_barra(Barra(4, 2, *props)) # 6
ret.agregar_barra(Barra(5, 6, *props)) # 7
ret.agregar_barra(Barra(6, 7, *props)) # 8
ret.agregar_barra(Barra(5, 3, *props2)) # 9
ret.agregar_barra(Barra(3, 6, *props2)) # 10
ret.agregar_barra(Barra(6, 4, *props2)) # 11
ret.agregar_barra(Barra(4, 7, *props)) # 12
ret.agregar_barra(Barra(0, 5, *props)) # 13
ret.agregar_barra(Barra(1, 6, *props)) # 14
ret.agregar_barra(Barra(2, 7, *props)) # 15
ret.agregar_barra(Barra(0, 6, *props)) # 16
ret.agregar_barra(Barra(6, 2, *props)) # 17
ret.agregar_barra(Barra(5, 1, *props)) # 18
ret.agregar_barra(Barra(1, 7, *props)) # 19
# ver_reticulado_3d(ret)
ret.agregar_restriccion(0, 0, 0)
ret.agregar_restriccion(0, 1, 0)
ret.agregar_restriccion(0, 2, 0)
ret.agregar_restriccion(2, 2, 0)
ret.agregar_restriccion(5, 2, 0)
ret.agregar_restriccion(7, 2, 0)
ret.agregar_restriccion(5, 0, 0)
ret.agregar_fuerza(4, 2, -F)
peso = ret.calcular_peso_total()
print(f"peso = {peso}")
ret.ensamblar_sistema()
ret.resolver_sistema()
f = ret.recuperar_fuerzas()
if graficar:
ver_reticulado_3d(ret,
opciones_nodos={
"usar_posicion_deformada": True,
"factor_amplificacion_deformada": 30.,
},
opciones_barras={
"color_barras_por_dato": True,
"ver_numeros_de_barras": False,
"ver_dato_en_barras": True,
"dato": f,
"color_fondo": [1, 1, 1, 0.4]
},
llamar_show=False)
return f[2]
def caso_D():
# Unidades base
m = 1.
kg = 1.
s = 1.
#Unidades derivadas
N = kg * m / s**2
cm = 0.01 * m
mm = 0.001 * m
KN = 1000 * N
Pa = N / m**2
KPa = 1000 * Pa
MPa = 1000 * KPa
GPa = 1000 * MPa
posibles_apoyos = loadtxt("coordenadas_apoyos.txt")
importantes = []
for i in range(7, 29):
importantes.append(list(posibles_apoyos[i]))
x = []
z = []
for i in importantes:
x.append(i[0])
z.append(i[1])
dist_x = []
for i in range(len(x) - 1):
d = np.abs(x[i] - x[i + 1])
dist_x.append(d)
nodos_x = []
for i in range(len(dist_x)):
d = dist_x[i]
if d > 6:
cant = d / 6
dec, ent = math.modf(cant)
for i in range(int(ent)):
nodos_x.append(6.0)
L = d - ent * 6
nodos_x.append(L)
else:
nodos_x.append(d)
# Con BARRAS DE 6 m c/u
i = 10 * m
delta = 6 * m
h = 5.0
ret = Reticulado()
for j in range(37):
ret.agregar_nodo(i + delta * j, 0, 100.0)
ret.agregar_nodo(i + delta * j, 2, 100.0)
ret.agregar_nodo(230.0, 0, 100.0)
ret.agregar_nodo(230.0, 2, 100.0)
nodos = np.arange(0, ret.Nnodos, 1)
par = []
impar = []
for n in nodos:
if n % 2 == 0:
par.append(n)
else:
impar.append(n)
# especie de arco
for a in range(19):
if a == 0:
h = 115.0
else:
h = 115.0 + a * 0.5
ret.agregar_nodo(a + delta * a, 1, h)
for a in range(19, 37):
h = 124 - (a - 19) * 0.5
if h <= 230:
ret.agregar_nodo(a + delta * a, 1, h)
'''
fig = plt.figure()
fig.set_size_inches([12, 10], forward=True)
ax = fig.add_subplot(111, projection='3d')
graficar_nodos(ret, fig, opciones={})
plt.show()
'''
#, R, t, E, ρ, σy
R = 20 * cm
t = 200 * mm
props1 = [R, t, 200 * GPa, 7500 * kg / m**3, 420 * MPa]
props2 = [R * 2, t * 3, 200 * GPa, 7500 * kg / m**3, 420 * MPa]
for i in range(int(38 / 2)):
a = par[2 * i]
b = impar[2 * i + 1]
ret.agregar_barra(Barra(a, b, *props2))
for i in range(int(38 / 2)):
a = par[2 * i + 1]
b = impar[2 * i]
ret.agregar_barra(Barra(a, b, *props2))
for i in range(0, 75):
ret.agregar_barra(Barra(i, i + 1, *props2))
for i in range(0, 36):
p = i * 2 + 1
ret.agregar_barra(Barra(p, p + 2, *props2))
for i in range(0, 36):
p = 2 * i
ret.agregar_barra(Barra(p, p + 2, *props2))
arc = np.arange(76, 113, 1)
for i in range(len(arc)):
n1 = 2 * i
n2 = 2 * i + 1
ret.agregar_barra(Barra(n1, arc[i], *props1))
ret.agregar_barra(Barra(arc[i], n2, *props1))
#restricciones
ret.agregar_restriccion(0, 0, 0)
ret.agregar_restriccion(0, 1, 0)
ret.agregar_restriccion(0, 2, 0)
ret.agregar_restriccion(1, 0, 0)
ret.agregar_restriccion(1, 1, 0)
ret.agregar_restriccion(1, 2, 0)
ret.agregar_restriccion(38, 0, 0)
ret.agregar_restriccion(38, 1, 0)
ret.agregar_restriccion(38, 2, 0)
ret.agregar_restriccion(39, 0, 0)
ret.agregar_restriccion(39, 1, 0)
ret.agregar_restriccion(39, 2, 0)
ret.agregar_restriccion(74, 0, 0)
ret.agregar_restriccion(74, 1, 0)
ret.agregar_restriccion(74, 2, 0)
ret.agregar_restriccion(75, 0, 0)
ret.agregar_restriccion(75, 1, 0)
ret.agregar_restriccion(75, 2, 0)
for i in arc:
ret.agregar_restriccion(i, 0, 0)
ret.agregar_restriccion(i, 1, 0)
ret.agregar_restriccion(i, 2, 0)
# Carga muerta
# nodos 0 y 1
peso = ret.calcular_peso_total()
qD = ((peso) / (230 * m**2))
qD_A1 = -qD * (3 * m**2)
ret.agregar_fuerza(0, 2, qD_A1)
ret.agregar_fuerza(1, 2, qD_A1)
# nodos 2 al 71
qD_A2 = -qD * (6 * m**2)
for i in range(2, 72):
ret.agregar_fuerza(i, 2, qD_A2)
# nodos 72 y 73
qD_A3 = -qD * (5 * m**2)
ret.agregar_fuerza(72, 2, qD_A3)
ret.agregar_fuerza(73, 2, qD_A3)
#nodos 74 y 75
qD_A4 = -qD * (2 * m**2)
ret.agregar_fuerza(74, 2, qD_A4)
ret.agregar_fuerza(75, 2, qD_A4)
return ret
def caso_D():
# Unidades base
m = 1.
kg = 1.
s = 1.
#Unidades derivadas
N = kg * m / s**2
cm = 0.01 * m
mm = 0.001 * m
KN = 1000 * N
Pa = N / m**2
KPa = 1000 * Pa
MPa = 1000 * KPa
GPa = 1000 * MPa
#Parametros
L = 5.0 * m
F = 100 * KN
B = 2.0 * m
h = 3.5 * m
#Inicializar modelo
ret = Reticulado()
#Nodos
ret.agregar_nodo(0, 0, 0) #0
ret.agregar_nodo(L, 0, 0) #1
ret.agregar_nodo(2 * L, 0, 0) #2
ret.agregar_nodo(3 * L, 0, 0) #3
ret.agregar_nodo(L / 2, B / 2, h) #4
ret.agregar_nodo(3 * L / 2, B / 2, h) #5
ret.agregar_nodo(5 * L / 2, B / 2, h) #6
ret.agregar_nodo(0, B, 0) #7
ret.agregar_nodo(L, B, 0) #8
ret.agregar_nodo(2 * L, B, 0) #9
ret.agregar_nodo(3 * L, B, 0) #10
#Barras
R = 8 * cm
t = 5 * mm
#, R, t, E, ρ, σy
props = [R, t, 200 * GPa, 7600 * kg / m**3, 420 * MPa]
ret.agregar_barra(Barra(0, 1, *props)) # 0
ret.agregar_barra(Barra(1, 2, *props)) # 1
ret.agregar_barra(Barra(2, 3, *props)) # 2
ret.agregar_barra(Barra(3, 10, *props)) # 3
ret.agregar_barra(Barra(9, 10, *props)) # 4
ret.agregar_barra(Barra(8, 9, *props)) # 5
ret.agregar_barra(Barra(7, 8, *props)) # 6
ret.agregar_barra(Barra(0, 7, *props)) # 7
ret.agregar_barra(Barra(1, 7, *props)) # 8
ret.agregar_barra(Barra(0, 8, *props)) # 9
ret.agregar_barra(Barra(1, 8, *props)) # 10
ret.agregar_barra(Barra(2, 8, *props)) # 11
ret.agregar_barra(Barra(1, 9, *props)) # 12
ret.agregar_barra(Barra(2, 9, *props)) # 13
ret.agregar_barra(Barra(3, 9, *props)) # 14
ret.agregar_barra(Barra(2, 10, *props)) # 15
ret.agregar_barra(Barra(4, 7, *props)) # 16
ret.agregar_barra(Barra(0, 4, *props)) # 17
ret.agregar_barra(Barra(4, 8, *props)) # 18
ret.agregar_barra(Barra(1, 4, *props)) # 19
ret.agregar_barra(Barra(5, 8, *props)) # 20
ret.agregar_barra(Barra(1, 5, *props)) # 21
ret.agregar_barra(Barra(5, 9, *props)) # 22
ret.agregar_barra(Barra(2, 5, *props)) # 23
ret.agregar_barra(Barra(6, 9, *props)) # 24
ret.agregar_barra(Barra(2, 6, *props)) # 25
ret.agregar_barra(Barra(6, 10, *props)) # 26
ret.agregar_barra(Barra(3, 6, *props)) # 27
ret.agregar_barra(Barra(4, 5, *props)) # 28
ret.agregar_barra(Barra(5, 6, *props)) # 29
#ver_reticulado_3d(ret)
ret.agregar_restriccion(0, 0, 0)
ret.agregar_restriccion(0, 1, 0)
ret.agregar_restriccion(0, 2, 0)
ret.agregar_restriccion(7, 0, 0)
ret.agregar_restriccion(7, 1, 0)
ret.agregar_restriccion(7, 2, 0)
ret.agregar_restriccion(3, 1, 0)
ret.agregar_restriccion(3, 2, 0)
ret.agregar_restriccion(10, 1, 0)
ret.agregar_restriccion(10, 2, 0)
# Carga muerta
peso = ret.calcular_peso_total()
qD = ((peso) / (90 * m**2))
qD_A1 = -qD * (7.5 * m**2)
qD_A2 = -qD * (15 * m**2)
ret.agregar_fuerza(0, 2, qD_A1)
ret.agregar_fuerza(3, 2, qD_A1)
ret.agregar_fuerza(7, 2, qD_A1)
ret.agregar_fuerza(10, 2, qD_A1)
ret.agregar_fuerza(1, 2, qD_A2)
ret.agregar_fuerza(2, 2, qD_A2)
ret.agregar_fuerza(8, 2, qD_A2)
ret.agregar_fuerza(9, 2, qD_A2)
return ret
def caso_L():
# Unidades base
m = 1.
kg = 1.
s = 1.
#Unidades derivadas
N = kg * m / s**2
cm = 0.01 * m
mm = 0.001 * m
KN = 1000 * N
Pa = N / m**2
KPa = 1000 * Pa
MPa = 1000 * KPa
GPa = 1000 * MPa
# Parametros
L = 5.0 * m
H = 3.5 * m
B = 2.0 * m
q = 400 * 9.80665 * N / (m * m)
# Areas Tributarias
A0 = 1 * 2.5 * m * m
A1 = 2 * 2.5 * m * m
A2 = 2 * 2.5 * m * m
A3 = 1 * 2.5 * m * m
A7 = 1 * 2.5 * m * m
A8 = 2 * 2.5 * m * m
A9 = 2 * 2.5 * m * m
A10 = 1 * 2.5 * m * m
#Inicializar modelo
ret = Reticulado()
# Nodos
ret.agregar_nodo(0, 0, 0)
ret.agregar_nodo(L, 0, 0)
ret.agregar_nodo(2 * L, 0, 0)
ret.agregar_nodo(3 * L, 0, 0)
ret.agregar_nodo(L / 2, B / 2, H)
ret.agregar_nodo(3 * L / 2, B / 2, H)
ret.agregar_nodo(5 * L / 2, B / 2, H)
ret.agregar_nodo(0, B, 0)
ret.agregar_nodo(L, B, 0)
ret.agregar_nodo(2 * L, B, 0)
ret.agregar_nodo(3 * L, B, 0)
# Barras
props = [8 * cm, 5 * mm, 200 * GPa, 7600 * kg / m**3, 420 * MPa]
ret.agregar_barra(Barra(0, 1, *props)) # Hor 1
ret.agregar_barra(Barra(1, 2, *props))
ret.agregar_barra(Barra(2, 3, *props))
ret.agregar_barra(Barra(0, 8, *props)) # Diag 1
ret.agregar_barra(Barra(1, 9, *props))
ret.agregar_barra(Barra(2, 10, *props))
ret.agregar_barra(Barra(0, 4, *props)) # diag vertical 1.1
ret.agregar_barra(Barra(1, 5, *props))
ret.agregar_barra(Barra(2, 6, *props))
ret.agregar_barra(Barra(1, 4, *props)) # diag vertical 1.2
ret.agregar_barra(Barra(2, 5, *props))
ret.agregar_barra(Barra(3, 6, *props))
ret.agregar_barra(Barra(0, 7, *props)) # Lateral
ret.agregar_barra(Barra(1, 8, *props))
ret.agregar_barra(Barra(2, 9, *props))
ret.agregar_barra(Barra(3, 10, *props))
ret.agregar_barra(Barra(1, 7, *props)) # Hor 2
ret.agregar_barra(Barra(2, 8, *props))
ret.agregar_barra(Barra(3, 9, *props))
ret.agregar_barra(Barra(7, 8, *props)) # Diag 2
ret.agregar_barra(Barra(8, 9, *props))
ret.agregar_barra(Barra(9, 10, *props))
ret.agregar_barra(Barra(4, 7, *props)) # diag vertical 2.1
ret.agregar_barra(Barra(5, 8, *props))
ret.agregar_barra(Barra(6, 9, *props))
ret.agregar_barra(Barra(4, 8, *props)) # diag vertical 2.2
ret.agregar_barra(Barra(5, 9, *props))
ret.agregar_barra(Barra(6, 10, *props))
ret.agregar_barra(Barra(4, 5, *props)) # Hor arriba
ret.agregar_barra(Barra(5, 6, *props))
ret.agregar_restriccion(0, 0, 0) # Nodo 0 FIjo
ret.agregar_restriccion(0, 1, 0)
ret.agregar_restriccion(0, 2, 0)
ret.agregar_restriccion(7, 0, 0) # Nodo 7 FIjo
ret.agregar_restriccion(7, 1, 0)
ret.agregar_restriccion(7, 2, 0)
ret.agregar_restriccion(3, 1, 0) # Nodo 3 deslizable en x
ret.agregar_restriccion(3, 2, 0)
ret.agregar_restriccion(10, 1, 0) # Nodo 10 deslizable en x
ret.agregar_restriccion(10, 2, 0)
peso1 = ret.calcular_peso_total()
ret.agregar_fuerza(0, 2, -q * A0)
ret.agregar_fuerza(1, 2, -q * A1)
ret.agregar_fuerza(2, 2, -q * A2)
ret.agregar_fuerza(3, 2, -q * A3)
ret.agregar_fuerza(7, 2, -q * A7)
ret.agregar_fuerza(8, 2, -q * A8)
ret.agregar_fuerza(9, 2, -q * A9)
ret.agregar_fuerza(10, 2, -q * A10)
return ret
