Saltearse al contenido

El pórtico completo

Los ocho capítulos anteriores son piezas. Este las junta en un programa que recibe nudos y barras, arma la matriz, resuelve y devuelve reacciones y fuerzas internas. Con NumPy ocupa lo que ocupa una hoja, y sigue siendo legible.

Seis piezas —Nodo, Barra, k_local, rotacion, k_global, ensamblar— y calcular encima, con tres validaciones que se ejecutan en cada cambio.

Este bloque es una biblioteca, no un programa: no trae datos ni main, y no imprime nada. El ejecutable es mediciones/09-03-portico-numpy.py; cópialo como portico.py si quieres usarlo desde otro archivo (el capítulo 11 lo hace así).

import math
import numpy as np
class Nodo:
def __init__(self, nombre, x, y, ux=False, uy=False, rz=False):
self.nombre, self.x, self.y = nombre, x, y
self.restringido = (ux, uy, rz)
class Barra:
def __init__(self, i, j, E, A, I, nombre="", q=0.0):
self.i, self.j, self.E, self.A, self.I = i, j, E, A, I
self.nombre = nombre
self.q = q # carga uniforme en el eje local y (positiva hacia arriba)
@property
def L(self):
return math.hypot(self.j.x - self.i.x, self.j.y - self.i.y)
@property
def alpha(self):
return math.atan2(self.j.y - self.i.y, self.j.x - self.i.x)
def k_local(b):
ka = b.E * b.A / b.L
a, bb = 12 * b.E * b.I / b.L**3, 6 * b.E * b.I / b.L**2
c, d = 4 * b.E * b.I / b.L, 2 * b.E * b.I / b.L
return np.array([
[ka, 0, 0, -ka, 0, 0],
[0, a, bb, 0, -a, bb],
[0, bb, c, 0, -bb, d],
[-ka, 0, 0, ka, 0, 0],
[0, -a, -bb, 0, a, -bb],
[0, bb, d, 0, -bb, c],
], dtype=float)
def q0_local(b):
"""Fuerzas de empotramiento de una carga uniforme, en ejes locales."""
w, L = b.q, b.L
return np.array([0.0, w * L / 2, w * L**2 / 12, 0.0, w * L / 2, -w * L**2 / 12])
def rotacion(alpha):
c, s = math.cos(alpha), math.sin(alpha)
return np.array([
[c, s, 0, 0, 0, 0],
[-s, c, 0, 0, 0, 0],
[0, 0, 1, 0, 0, 0],
[0, 0, 0, c, s, 0],
[0, 0, 0, -s, c, 0],
[0, 0, 0, 0, 0, 1],
], dtype=float)
def k_global(b):
T = rotacion(b.alpha)
return T.T @ k_local(b) @ T
def ensamblar(nodos, barras):
n = 3 * len(nodos)
pos = {id(nd): 3 * i for i, nd in enumerate(nodos)}
assert len(pos) == len(nodos), "hay nudos repetidos en la lista"
K = np.zeros((n, n))
for b in barras:
idx = [pos[id(b.i)] + k for k in range(3)] + [pos[id(b.j)] + k for k in range(3)]
K[np.ix_(idx, idx)] += k_global(b)
return K, pos
def calcular(nodos, barras, cargas):
K, pos = ensamblar(nodos, barras)
n = 3 * len(nodos)
libres = [3 * i + k for i, nd in enumerate(nodos)
for k in range(3) if not nd.restringido[k]]
F = np.zeros(n)
for b in barras: # cargas equivalentes
idx = [pos[id(b.i)] + k for k in range(3)] + [pos[id(b.j)] + k for k in range(3)]
F[idx] += rotacion(b.alpha).T @ q0_local(b)
for nd, (fx, fy, mz) in cargas.items():
p = pos[id(nd)]
F[p:p + 3] += (fx, fy, mz)
Kr = K[np.ix_(libres, libres)]
if np.linalg.cond(Kr) > 1e12: # apoyos insuficientes
raise ValueError("estructura inestable: faltan apoyos o hay un mecanismo")
u = np.zeros(n)
u[libres] = np.linalg.solve(Kr, F[libres])
R = K @ u - F
fuerzas = {}
for b in barras:
idx = [pos[id(b.i)] + k for k in range(3)] + [pos[id(b.j)] + k for k in range(3)]
q = k_local(b) @ rotacion(b.alpha) @ u[idx] - q0_local(b)
fuerzas[b.nombre or f"b{len(fuerzas)}"] = q
return u, R, fuerzas, pos

Este bloque es el archivo mediciones/09-03-portico-numpy.py sin las validaciones. Guárdalo como portico.py y el capítulo 11 lo usa tal cual.

Las tres piezas que NumPy simplifica:

  • K = np.zeros((n, n)) en lugar de listas de listas.
  • K[np.ix_(idx, idx)] += kg suma el bloque de 6×6 en su posición con una sola línea, sin doble bucle.
  • np.linalg.solve resuelve con pivoteo parcial y descomposición LU, sin invertir.

Y una que NumPy no hace sola: np.linalg.cond(Kr) antes de resolver. Si faltan apoyos, la matriz reducida es singular, pero el redondeo suele dejarla «casi» singular y solve devuelve números en lugar de un error. Un número de condición por encima de 1e12 es la señal; en los casos de este capítulo queda varios órdenes de magnitud por debajo.

El solver no comprueba unidades: si te equivocas, devuelve números plausibles. Las tres líneas que hay que escribir siempre:

E = 30e6 # kN/m² (30 GPa, hormigón)
A = b * h # m²
I = b * h**3 / 12 # m⁴ (sección rectangular, eje fuerte)

Para 0.30 × 0.50 m: A = 0.15 m² e I = 0.003125 m⁴. Si pones E = 30 en lugar de 30e6, el solver no falla: las reacciones salen bien y la flecha sale un millón de veces mayor. Ese es el error silencioso que hay que temer.

Un programa de análisis sin validación es una calculadora de números plausibles. Estas tres cubren los tres mecanismos que pueden fallar: la matriz local, el ensamblaje y las condiciones de contorno.

Validación contra soluciones cerradas
Caso Resultado Teoría Error
Voladizo, P = 10 kN −0.428571 m PL³/3EI = −0.428571 2.6e-14 %
Biempotrada, P = 10 kN −0.053571 m PL³/192EI = −0.053571 0 %
Reacción del voladizo 10.000 kN · 30.000 kN·m P · P·L 0 %
Biempotrada + w = 10 kN/m −0.160714 m wL⁴/384EI 0 %

python mediciones/09-03-portico-numpy.py

Y el pórtico, que no tiene fórmula cerrada, se comprueba por equilibrio:

Pórtico de dos columnas: equilibrio global
Comprobación Valor
Carga horizontal 10 kN
Suma de reacciones horizontales −10 kN
Deriva del nudo cargado 82.80 mm
Momentos en las bases 8.864 y 8.863 kN·m

python mediciones/09-03-portico-numpy.py

Los dos momentos de base salen casi iguales porque el pórtico es simétrico. La diferencia de 0,001 kN·m no es redondeo: es la deformación axial de la viga (se alarga unas centésimas de milímetro y las columnas derivan distinto). Con A → ∞ desaparece. Si la diferencia fuera del 10 %, sí habría un error de ensamblaje.

Nodo(nombre, x, y, ux, uy, rz) # coordenadas y apoyos
Barra(i, j, E, A, I) # propiedades y longitud
.L, .alpha # calculadas al construir
k_local(barra) → 6×6 # capítulo 4
rotacion(alpha) → 6×6 # capítulo 5
k_global(barra) → 6×6 # Tᵀ·k·T
ensamblar(nodos, barras) → K # capítulo 6
calcular(...) → u, R # capítulos 7 y 8

Cada función corresponde a un capítulo. Esa es la señal de que el diseño está bien: el código se lee como el índice de la parte.

Para cualquier pórtico nuevo, antes de mirar un diagrama:

Comprobación Cómo Tolerancia
Equilibrio vertical ΣR_y = carga total 1e-6 relativo
Equilibrio horizontal ΣR_x = 0 (sin cargas horizontales) 1e-6 de la carga total
Momento global ΣM respecto a un punto = 0 1e-6 relativo
Simetría si el modelo es simétrico, R y M también 1e-6 relativo

El equilibrio no es una aproximación: sale de la misma K que se resolvió, así que cierra al redondeo de la máquina (del orden de 1e-9 o mejor en estos casos). Una diferencia del 0,1 % no es «casi bien»: es una carga que falta o un apoyo que sobra.

Dos avisos que ahorran una hora de duda:

  • Las reacciones horizontales pueden no ser cero en un pórtico simétrico con carga vertical. Son el empuje: la viga flecta, los nudos giran y empujan las columnas. Lo que debe cumplirse es que sumen cero y que el momento global cierre, no que cada una sea nula.
  • Si todo sale cero, la carga no se aplicó: revisa que el nudo de la carga esté en la lista y que su grado no esté restringido.

Es análisis lineal de primer orden en 2D. No hace combinaciones de acciones con coeficientes, no incluye efectos P-Δ, no comprueba secciones, uniones ni pandeo, y no conoce ninguna normativa. Sirve para aprender cómo funciona un solver y para comprobar equilibrio y órdenes de magnitud; no para firmar un cálculo.

  • Cargas repartidas sin el vector equivalente: el capítulo 10 explica cómo añadirlo, y el solver de mediciones/09-03 ya lo incluye.
  • Grandes desplazamientos: la rigidez deja de ser constante.
  • Material no lineal: hace falta iterar.
  • Mallas grandes: K densa no escala; hay que pasar a dispersa.

Escribe una función comprobar(nombre, calculado, teorico) que devuelva el error relativo en porcentaje, y úsala para validar los tres casos del capítulo: voladizo, viga biempotrada y equilibrio del pórtico.

Solución
import sys
sys.stdout.reconfigure(encoding="utf-8") # Σ no existe en cp1252
def comprobar(nombre, calculado, teorico, tolerancia=1e-4):
"""Error relativo en % y veredicto. tolerancia en tanto por uno."""
error = abs(calculado - teorico) / abs(teorico) * 100 if teorico else abs(calculado)
estado = "OK" if error < tolerancia * 100 else "REVISAR"
print(f"{nombre:28} {calculado:>12.6f} {teorico:>12.6f} {error:>9.2e} % {estado}")
return error
EI, L, P = 210.0, 6.0, -10.0
# 1. voladizo: PL³/3EI con L = 3 m
comprobar("voladizo", -0.428571, P * 3**3 / (3 * EI))
# 2. biempotrada: PL³/192EI con L = 6 m
comprobar("biempotrada", -0.053571, P * L**3 / (192 * EI))
# 3. equilibrio del pórtico: suma de reacciones = -carga aplicada
reacciones = [-5.0, -5.0] # las dos columnas, medidas en el capítulo
comprobar("ΣR_x del pórtico", sum(reacciones), 10.0)

Salida:

voladizo -0.428571 -0.428571 1.00e-04 % OK
biempotrada -0.053571 -0.053571 8.00e-04 % OK
ΣR_x del pórtico -10.000000 10.000000 2.00e+02 % REVISAR

Los dos primeros pasan con margen; el tercero falla a propósito: las reacciones son opuestas a la carga, así que hay que comparar con -10. Es la lección del capítulo 7: el signo de la reacción no es un detalle.

La corrección es comprobar("ΣR_x del pórtico", sum(reacciones), -10.0), y entonces da 0 %.

Una suite de validación no es un lujo: es lo que permite cambiar la matriz o el ensamblaje sin miedo. Si los tres casos siguen en verde, el cambio no rompió la física.

  • Ruta de estudio · Python para estructuras: el orden recomendado para llegar hasta aquí.
  • Ingeniería estructural · fase 2: el siguiente paso, con vectores y mallas.