Nos adentramos en el terreno de la especialización. Para tus estudiantes de Ingeniería Civil, descubrir que Python puede resolver álgebra simbólica y ecuaciones de estática tal como lo hacen a mano en una hoja de papel es una verdadera revelación.
A diferencia de numpy, que necesita números exactos para
calcular, sympy trabaja con símbolos
(letras y variables algebraicas), lo que les permitirá plantear
sumatorias de fuerzas (\(\sum F_x =
0\), \(\sum F_y = 0\)) y
despejar incógnitas de reacciones.
Aquí tienes el contenido limpio de la Semana 12 (Ruta A), listo para tu cuaderno de Colab:
# SEMANA 12 (Ruta A): Álgebra Simbólica y Estática Básica con SymPy
**Especialidad:** Ingeniería Civil
**Asignatura:** Programación de Computadores con Python
En el análisis estructural y la estática, muchas veces no tenemos todos los valores numéricos desde el principio. Frecuentemente planteamos ecuaciones con incógnitas (como las reacciones $R_A$ o $R_B$ en los apoyos de una viga) y luego las despejamos usando álgebra.
Hasta ahora, Python solo sabía trabajar con números. Hoy conoceremos **SymPy** (Symbolic Python), una librería que le enseña a la computadora a hacer álgebra y cálculo simbólico exactamente como lo harías tú en un cuaderno con lápiz y papel.
**Objetivos de Aprendizaje:**
* Importar la librería `sympy` y declarar variables algebraicas (símbolos).
* Plantear y resolver ecuaciones de equilibrio estático bidimensional.
* Introducir el módulo `continuum_mechanics` para modelar vigas isostáticas.
* Calcular reacciones en los apoyos de una estructura sencilla.
## SESIÓN 1: Variables Simbólicas y Ecuaciones de Equilibrio
**¿Qué es el cálculo simbólico?**
Si en Python normal escribes `x + x` sin haberle dado un valor numérico a `x`, el programa arrojará un error. Con `sympy`, le decimos a Python que trate a `x` como un símbolo matemático, por lo que responderá lógicamente: `2*x`.
Vamos a importar la librería e iniciar con un problema básico de estática: **Una partícula en equilibrio**.
import sympy as sp
# 1. Declaramos nuestras incógnitas como "Símbolos" matemáticos
# Imagina que son las tensiones de dos cables que sostienen un semáforo
T1, T2 = sp.symbols('T1 T2')
# 2. Planteamos las ecuaciones de equilibrio (Sumatoria de Fuerzas = 0)
# En sympy, una ecuación igualada a cero se escribe directamente:
# Ecuación en X: -T1*cos(45°) + T2*cos(30°) = 0
eq_x = -T1 * sp.cos(sp.pi/4) + T2 * sp.cos(sp.pi/6)
# Ecuación en Y: T1*sin(45°) + T2*sin(30°) - Peso = 0 (Asumimos un peso de 100 N)
eq_y = T1 * sp.sin(sp.pi/4) + T2 * sp.sin(sp.pi/6) - 100
print("Ecuación en el eje X igualada a cero:")
sp.pprint(eq_x) # pprint muestra la ecuación en un formato matemático bonito
print("\nEcuación en el eje Y igualada a cero:")
sp.pprint(eq_y)
### Resolviendo el Sistema de Ecuaciones
Ahora que tenemos nuestras sumatorias de fuerzas $\sum F_x = 0$ y $\sum F_y = 0$, le pediremos a `sympy` que resuelva el sistema matricial y despeje los valores de las tensiones `T1` y `T2`.
# 3. Resolvemos el sistema de ecuaciones
# sp.solve recibe una lista de ecuaciones y una lista de las incógnitas a despejar
solucion = sp.solve([eq_x, eq_y], (T1, T2))
print("Los valores de las tensiones en equilibrio son:")
print(f"Tensión 1: {solucion[T1].evalf(4)} Newtons") # evalf(4) muestra el resultado con 4 cifras significativas
print(f"Tensión 2: {solucion[T2].evalf(4)} Newtons")
---
## SESIÓN 2: Introducción a la Mecánica del Medio Continuo (Vigas)
Resolver ecuaciones está muy bien, pero `sympy` tiene un módulo especial para ingenieros civiles llamado `continuum_mechanics`. Este módulo tiene una herramienta llamada `Beam` (Viga) que nos permite modelar vigas con apoyos y cargas en pocas líneas de código.
**El Problema:**
Tenemos una viga simplemente apoyada de 10 metros de longitud.
* Un apoyo fijo en el extremo izquierdo (x = 0).
* Un apoyo móvil en el extremo derecho (x = 10).
* Una carga puntual de 50 kN en el centro de la viga (x = 5).
Vamos a modelar esto para encontrar las reacciones en los apoyos.
# Importamos la herramienta Beam
from sympy.physics.continuum_mechanics import Beam
# 1. Definimos las propiedades básicas (E: Módulo de elasticidad, I: Inercia)
# Por ahora las dejamos como símbolos algebraicos genéricos
E, I = sp.symbols('E I')
# 2. Creamos la viga (Longitud 10 m, con módulo E e inercia I)
mi_viga = Beam(10, E, I)
# 3. Declaramos los símbolos para nuestras reacciones desconocidas
R_A, R_B = sp.symbols('R_A R_B')
# 4. Aplicamos las cargas puntuales (apply_load)
# Sintaxis: apply_load(valor, posición, orden)
# Orden -1 significa "carga puntual", orden -2 significa "momento concentrado"
mi_viga.apply_load(R_A, 0, -1) # Reacción hacia arriba en x = 0
mi_viga.apply_load(R_B, 10, -1) # Reacción hacia arriba en x = 10
mi_viga.apply_load(-50, 5, -1) # Carga de 50 kN hacia abajo en x = 5
# 5. Definimos las condiciones de frontera (Apoyos)
# bc_deflection es "Boundary Condition for Deflection" (Deflexión cero en los apoyos)
mi_viga.bc_deflection = [(0, 0), (10, 0)]
# 6. Resolvemos las reacciones del sistema
mi_viga.solve_for_reaction_loads(R_A, R_B)
print("Las reacciones en los apoyos calculadas por SymPy son:")
print(mi_viga.reaction_loads)
---
### Interacción con el Tutor IA 🤖
SymPy tiene una curva de aprendizaje interesante. Usemos nuestro asistente para aclarar su sintaxis:
> **PROMPT DE APRENDIZAJE - SEMANA 12 (CIVIL):**
> Actúa como un Ingeniero Civil Senior experto en análisis estructural computacional. Estoy aprendiendo a usar la librería `sympy` en Python.
> 1) Explícame con una analogía sencilla cuál es la diferencia fundamental entre el cálculo numérico (con `numpy`) y el cálculo simbólico (con `sympy`).
> 2) En el módulo `continuum_mechanics`, cuando uso `apply_load()`, hay un parámetro llamado "orden" (ej. -1 o -2). Explícame qué significan físicamente esos órdenes para cargas puntuales y momentos concentrados.
> 3) ¿Cómo plantearías conceptualmente (sin código largo) una carga distribuida rectangular usando esta librería?
> Después hazme 3 preguntas teóricas de estática para verificar si comprendo cómo plantear un problema antes de programarlo.
---
## ACTIVIDAD FINAL: Hoja "Estudia y Aprende"
Sintetiza lo aprendido sobre programación aplicada a tu área:
> **PROMPT GLOBAL DE CIERRE:**
> Actúa como tutor experto en Análisis Estructural asistido por Python. Elabora un RESUMEN BREVE que cumpla estas condiciones:
> 1. Debe caber en UNA SOLA HOJA escrita a mano.
> 2. Lenguaje claro y orientado exclusivamente a Ingeniería Civil.
> 3. Debe incluir: Qué es el cálculo simbólico, cómo la función `sp.solve()` nos ayuda a resolver sistemas de equilibrio ($\sum F = 0$), y para qué sirve la clase `Beam` en el modelado estructural básico.
> 4. Pensado para que yo lo escriba comprendiendo lo esencial.
> Al final agrega una frase de reflexión sobre cómo la programación moderniza el trabajo del ingeniero calculista.
**Instrucción para el estudiante:** En el reverso de tu hoja, dibuja el diagrama de cuerpo libre de la viga que modelamos en la Sesión 2, identificando dónde pusimos las cargas en el código y cuáles fueron las reacciones que calculó Python.
Con esto, los futuros ingenieros civiles empezarán a ver el verdadero potencial de automatizar sus cálculos estructurales. En la Semana 13 profundizaremos en este módulo para que puedan extraer los diagramas de cortante y momento flector y mostrarlos en Streamlit.
¿Te gustaría que preparemos ahora la guía de la Semana 12 (Ruta B) para los ingenieros Agrícolas y Agroindustriales, enfocada en los algoritmos para el contenido de humedad y secado solar?