Clase 2: Método de Rigidez 1D en Python
Propósito de la clase: Traducir el razonamiento mecánico y matemático del Método de
Rigidez aprendido en la sesión anterior a un entorno de programación. Al finalizar, los
alumnos podrán sistematizar el cálculo de desplazamientos, reacciones y fuerzas axiales para
elementos 1D, sentando las bases computacionales para futuros análisis en 2D y 3D.
1. Entorno de Trabajo: Jupyter Lab y Tipos de Archivos
Para automatizar nuestros cálculos, utilizaremos la plataforma Jupyter Lab. Es un entorno
interactivo ideal para ingeniería, ya que permite combinar código, texto explicativo y resultados
visuales paso a paso.
Trabajaremos con dos tipos de archivos fundamentales:
• Archivo de módulo (.py): Aquí guardaremos las funciones base (nuestro "motor de cálculo").
Este archivo no se ejecuta línea a línea de forma interactiva, sino que sirve como una
biblioteca personalizada. Para crearlo en Jupyter Lab, deben ir a File > New > Text File,
escribir el código y guardarlo con la extensión .py (por ejemplo, metodo_rigidez_1D.py).
• Cuaderno interactivo (.ipynb): Es el archivo donde resolveremos el problema paso a paso
(el Jupyter Notebook). Aquí importaremos las funciones de nuestro módulo .py y
ejecutaremos el código en bloques (celdas). Se crea desde File > New > Notebook.
2. Creación del Módulo de Funciones (metodo_rigidez_1D.py)
En la clase anterior demostramos que el Método de Rigidez resuelve el sistema global [K]{u} =
{F} [cite: 3]. Ahora, programaremos las funciones necesarias para construir este sistema [cite: 2].
A. Matriz de Rigidez Elemental
Sabemos por la Ley de Hooke que la rigidez axial de una barra se define como k = EA/L [cite: 3].
La matriz elemental que relaciona fuerzas nodales y desplazamientos es (EA/L) [[1, -1], [-1, 1]]
[cite: 3]. En nuestro archivo metodo_rigidez_1D.py, importaremos herramientas matemáticas
e implementaremos esta lógica:
from numpy import array, dot, transpose, zeros
def matriz_rigidez_barra_1D(barra, E, A, L):
k = E * A / L
klocal = array([[k, -k], [-k, k]])
return klocal
Esta función recibe las propiedades geométricas y de material de la barra y retorna su matriz local
de 2x2 [cite: 2].
B. Ensamblaje de la Matriz Global
El ensamblaje consiste en colocar cada matriz elemental en las filas y columnas correspondientes
a sus nodos dentro del sistema completo [cite: 3]. La siguiente función suma las contribuciones de
la matriz local (klocal) en las coordenadas correctas de la matriz global (Kglobal) [cite: 2]:
def ensambla_1D(Kglobal, klocal, nodoi, nodof):
gdl = array([nodoi - 1, nodof - 1])
for i in range(2):
for j in range(2):
Kglobal[gdl[i], gdl[j]] += klocal[i, j]
Nota: En Python los índices comienzan en 0, por lo que restamos 1 al número de nodo para
ubicarlo correctamente en la matriz.
C. Extracción de Submatrices para Condiciones de Borde
Para resolver el sistema, debemos separar los grados de libertad libres de los restringidos (apoyos
fijos) [cite: 3]. Para ello, usaremos una función que extrae particiones de la matriz global (KLL,
KLR, KRL, KRR) [cite: 2]:
def submat(Kglobal, gdl_fila, gdl_col):
nfila = len(gdl_fila)
ncol = len(gdl_col)
K = zeros([nfila, ncol])
for i in range(nfila):
for j in range(ncol):
K[i, j] = Kglobal[gdl_fila[i] - 1, gdl_col[j] - 1]
return K
3. Script Principal de Resolución (ejercicio_1.ipynb)
Una vez guardado el módulo anterior, abrimos nuestro cuaderno interactivo para resolver un
sistema real de múltiples barras. Esta estructura modular nos permite replicar de forma
automatizada los mismos pasos analíticos que hicimos a mano [cite: 3].
Paso 1: Importar funciones y definir datos de entrada
Comenzamos importando numpy y nuestras funciones [cite: 1]. Luego, introducimos las
propiedades de nuestra estructura [cite: 1]:
from numpy import array, dot, zeros, pi
from metodo_rigidez_1D import matriz_rigidez_barra_1D, ensambla_1D, submat
from [Link] import solve
# Ingreso de datos
nnodo = 5
gdl_L = array([3, 4, 5]) # grados de libertad libres
gdl_R = array([1, 2]) # grados de libertad fijos
x_R = array([0, 0]) # desplazamiento de los grados de libertad fijos
F_L = array([1000, -300, 450]) # Fuerzas externas en grados de libertad libres
Aquí estamos aplicando las condiciones de borde: los nodos 1 y 2 están fijos (x_R = 0), mientras
que los nodos 3, 4 y 5 están libres y sometidos a cargas [cite: 1].
Paso 2: Inicialización y Ensamblaje
Ahora creamos la matriz global vacía (llena de ceros) y calculamos la matriz local para cada una
de nuestras barras usando sus propiedades (E, A, L) [cite: 1]. Después, ensamblamos cada una
indicando qué nodos conecta [cite: 1]:
Kglobal = zeros([nnodo, nnodo]) # Inicialización matriz global
# Calcula matrices de rigidez locales
kloc1 = matriz_rigidez_barra_1D(barra=1, E=2100000, A=2827.43, L=200)
kloc2 = matriz_rigidez_barra_1D(barra=2, E=2100000, A=1590.43, L=400)
kloc3 = matriz_rigidez_barra_1D(barra=3, E=2100000, A=706.85, L=100)
kloc4 = matriz_rigidez_barra_1D(barra=4, E=2100000, A=19.63, L=500)
# Ensambla en la matriz de rigidez global Kglobal
ensambla_1D(Kglobal, kloc1, nodoi=1, nodof=3)
ensambla_1D(Kglobal, kloc2, nodoi=3, nodof=4)
ensambla_1D(Kglobal, kloc3, nodoi=4, nodof=5)
ensambla_1D(Kglobal, kloc4, nodoi=5, nodof=2)
Paso 3: Partición de Matrices y Solución del Sistema
Extraemos las submatrices para aislar las variables incógnitas. Luego, resolvemos el sistema
reducido algebraicamente para encontrar los desplazamientos libres (x_L) y, posteriormente, las
fuerzas de reacción (F_R) [cite: 1].
KLL = submat(Kglobal, gdl_L, gdl_L)
KLR = submat(Kglobal, gdl_L, gdl_R)
KRL = submat(Kglobal, gdl_R, gdl_L)
KRR = submat(Kglobal, gdl_R, gdl_R)
# Desplazamientos libres
x_L = solve(KLL, (F_L - dot(KLR, x_R)))
# Fuerzas resultantes (Reacciones)
F_R = dot(KRL, x_L) + dot(KRR, x_R)
Esta es la materialización en código de la ecuación matricial analizada teóricamente, separando el
sistema en [K_{ff}]\{u_f\} = \{F_f\} - [K_{fr}]\{u_r\} [cite: 3].
Paso 4: Cálculo de Fuerzas Axiales Internas
Finalmente, para la Barra 1, tomamos los desplazamientos nodales en sus extremos (nodo 1 que
es 0, y nodo 3 que corresponde al primer valor de x_L) y los multiplicamos por la matriz local de la
barra [cite: 1]. Esto aplica la fórmula de fuerza axial elemental N = k(u_j - u_i) [cite: 3].
# Fuerzas axiales para la Barra 1
X_local1 = array([0, 3.84988394e-05])
FUERZAS_AXIALES = dot(kloc1, X_local1)
print('FUERZAS AXIALES BARRA 1 =', FUERZAS_AXIALES)
El código genera como salida un vector con fuerzas opuestas en los extremos de la barra, por
ejemplo, [-1142.95, 1142.95], indicando el estado de compresión o tracción [cite: 1]. Esta
misma lógica se repite iterativamente para las barras restantes [cite: 1].
Conclusión y Próximos Pasos
A través de la programación en Python, hemos eliminado el riesgo de errores en cálculos
manuales y nos hemos preparado para estructuras complejas con cientos de barras. En las
próximas clases, ampliaremos esta lógica agregando componentes trigonométricas para resolver
cerchas en 2D y 3D.