Desbloqueando la Resistencia de Vigas: Cálculo del Momento a partir de la Curvatura con Python
Un enfoque práctico para analizar vigas de concreto reforzado simplemente armadas usando principios de ingeniería y programación.
Analizar el comportamiento de las vigas de concreto reforzado bajo carga es fundamental en la ingeniería estructural. Una métrica clave es la relación entre el momento flector (M) que actúa sobre una sección y la curvatura (φ) que induce. Entender cómo calcular el momento resistente de una sección para una curvatura dada permite evaluar su capacidad, ductilidad y comportamiento en diferentes etapas de carga. Este análisis es crucial para el diseño sismorresistente y la evaluación de estructuras existentes.
Este artículo proporciona un programa en Python, junto con una explicación detallada, para calcular el momento en una sección rectangular de viga de concreto simplemente reforzada (con acero únicamente en la zona de tracción) cuando se conoce la curvatura. Nos basaremos en los principios de equilibrio de fuerzas internas y compatibilidad de deformaciones.
Puntos Clave
- Relación Momento-Curvatura (M-φ): Explora cómo la curvatura impuesta a una sección de viga se relaciona directamente con las deformaciones internas y, en consecuencia, con el momento flector que puede resistir.
- Equilibrio y Compatibilidad: El cálculo se basa en satisfacer el equilibrio entre la fuerza de compresión en el concreto y la fuerza de tensión en el acero, asumiendo una distribución lineal de deformaciones (compatibilidad).
- Implementación en Python: Se presenta un código Python que utiliza modelos de materiales aceptados (bloque de Whitney para concreto, elástico-plástico para acero) y un método numérico (`fsolve`) para determinar la profundidad del eje neutro y calcular el momento resistente.
Fundamentos Conceptuales: La Relación Momento-Curvatura
Entendiendo las Bases del Análisis
La relación Momento-Curvatura (M-φ) es una propiedad fundamental de cualquier sección transversal de un elemento estructural sometido a flexión. Describe cómo la sección se deforma (curvatura) bajo la acción de un momento flector. Para una viga de concreto reforzado, esta relación no es lineal debido al comportamiento complejo de los materiales:
- Fisuración del Concreto: A bajos niveles de momento, el concreto a tracción se fisura, cambiando la rigidez de la sección.
- Comportamiento No Lineal del Concreto: A mayores compresiones, el concreto exhibe un comportamiento no lineal.
- Fluencia del Acero: El acero de refuerzo a tracción eventualmente alcanza su límite de fluencia, limitando el incremento de la fuerza de tensión.
Para calcular el momento (M) correspondiente a una curvatura específica (φ), necesitamos analizar el estado de deformaciones y esfuerzos en la sección bajo esa curvatura.
Hipótesis del Análisis
- Secciones Planas: Se asume que una sección transversal plana antes de la flexión permanece plana después de la flexión. Esto implica una distribución lineal de las deformaciones unitarias a lo largo de la altura de la sección.
- Adherencia Perfecta: Existe una adherencia perfecta entre el concreto y las barras de acero de refuerzo, por lo que la deformación en el acero es igual a la deformación en el concreto circundante en la misma ubicación.
- Modelos de Materiales: Se utilizan modelos constitutivos (relaciones esfuerzo-deformación) para el concreto y el acero.
Equilibrio de Fuerzas Internas
Para cualquier curvatura dada (φ), la distribución de deformaciones queda definida si se conoce la profundidad del eje neutro (c), medido desde la fibra más comprimida. La deformación en la fibra extrema de concreto es \( \epsilon_c = \phi \cdot c \) y la deformación en el acero de refuerzo (a una distancia efectiva 'd' desde la fibra extrema) es \( \epsilon_s = \phi \cdot (d - c) \).
Con las deformaciones conocidas, se calculan los esfuerzos correspondientes en el concreto (f_c) y el acero (f_s) usando sus modelos de materiales. La fuerza total de compresión en el concreto (C) y la fuerza total de tensión en el acero (T) se calculan integrando los esfuerzos sobre sus respectivas áreas.
La profundidad del eje neutro (c) correcta es aquella que satisface el equilibrio de fuerzas axiales:
\[ C = T \]Una vez encontrado el valor de 'c' que cumple el equilibrio, el momento resistente interno (M) se calcula tomando momentos de las fuerzas internas (C y T) respecto a cualquier eje horizontal, comúnmente el eje neutro o el centroide del acero de tracción. Usando el par interno:
\[ M = T \times z \quad \text{o} \quad M = C \times z \]donde 'z' es el brazo de palanca interno, la distancia entre las resultantes de las fuerzas C y T.
Ejemplo genérico de un elemento viga de concreto prefabricado.
Implementación en Python
Código para Calcular el Momento dada la Curvatura
El siguiente programa en Python implementa el análisis descrito. Utiliza la biblioteca `scipy.optimize.fsolve` para encontrar iterativamente la profundidad del eje neutro (`c`) que satisface la ecuación de equilibrio `C - T = 0` para una curvatura (`phi`) dada. Se emplea el modelo del bloque rectangular de esfuerzos equivalentes (bloque de Whitney) para el concreto en compresión y un modelo elástico-perfectamente plástico para el acero de refuerzo.
import numpy as np
from scipy.optimize import fsolve
def calcular_momento_desde_curvatura(b, h, d, As, fc, fy, phi, Es=200000.0, ecu_max=0.003):
"""
Calcula el momento resistente (M) en una viga rectangular simplemente reforzada
dada la curvatura (phi).
Parámetros:
- b (float): Ancho de la viga (mm).
- h (float): Altura total de la viga (mm).
- d (float): Peralte efectivo (distancia desde fibra comprimida al centroide del acero) (mm).
- As (float): Área del acero de refuerzo a tracción (mm^2).
- fc (float): Resistencia a la compresión especificada del concreto (MPa).
- fy (float): Límite de fluencia especificado del acero de refuerzo (MPa).
- phi (float): Curvatura impuesta a la sección (1/mm). Debe ser positiva.
- Es (float, opcional): Módulo de elasticidad del acero (MPa). Default: 200000 MPa.
- ecu_max (float, opcional): Deformación unitaria máxima utilizable en el concreto. Default: 0.003.
Retorna:
- tuple: (M_kn_m, c, status)
- M_kn_m (float): Momento resistente calculado (kN-m). NaN si no converge.
- c (float): Profundidad del eje neutro (mm). NaN si no converge.
- status (str): Estado de la convergencia ('Convergencia exitosa' o 'Error de convergencia').
"""
if phi <= 0:
print("Advertencia: La curvatura debe ser positiva.")
# Podríamos retornar 0 o manejarlo como un caso especial,
# pero una curvatura no positiva no induce compresión arriba/tracción abajo.
# Asumiendo que se busca momento positivo con curvatura positiva.
return 0.0, 0.0, "Curvatura no positiva"
# Factor beta1 según ACI 318 (aproximado)
if fc <= 28:
beta1 = 0.85
elif fc < 55:
beta1 = 0.85 - 0.05 * (fc - 28) / 7
else:
beta1 = 0.65
# Límite de deformación por fluencia del acero
epsilon_y = fy / Es
# Ecuación de equilibrio (C - T = 0) a resolver para 'c'
def equilibrio(c_trial):
if c_trial <= 0: # Evitar división por cero o resultados sin sentido
return np.inf # Penalizar soluciones no físicas
# 1. Calcular deformaciones basadas en phi y c_trial
epsilon_c = phi * c_trial # Deformación en fibra extrema de concreto
epsilon_s = phi * (d - c_trial) # Deformación en el acero
# Limitar deformación del concreto (aunque fsolve debería manejarlo)
if epsilon_c > ecu_max:
# Si la deformación del concreto supera el límite,
# la curvatura dada es muy alta para esta 'c'.
# El eje neutro real debería ser más profundo para reducir epsilon_c,
# O la curvatura es simplemente inalcanzable antes del aplastamiento.
# Para el cálculo M-phi, usualmente se itera phi. Aquí phi es dato.
# Usaremos ecu_max como límite para calcular la fuerza C.
epsilon_c = ecu_max
# Ajustamos c_trial para que sea consistente con phi y ecu_max,
# aunque esto altera la 'c' que estamos buscando.
# Es más directo limitar la fuerza C basada en ecu_max.
# c_trial_ajustado = ecu_max / phi # No usar esto directamente en la iteración.
# 2. Calcular esfuerzo y fuerza en el acero (T)
if epsilon_s >= epsilon_y:
fs = fy # Acero fluyendo
elif epsilon_s <= -epsilon_y: # Caso de posible compresión si c > d
# Para viga simplemente reforzada, usualmente c < d.
# Si c > d, el acero estaría en compresión.
# Aquí asumimos que no hay acero a compresión, pero calculamos fs.
fs = max(-fy, Es * epsilon_s) # Comportamiento elástico o fluencia en compresión
else:
fs = Es * epsilon_s # Acero en régimen elástico
T = As * fs # Fuerza de tensión (puede ser negativa si hay compresión)
# 3. Calcular fuerza de compresión en el concreto (C) - Bloque de Whitney
# La fuerza C se calcula basada en la deformación real epsilon_c, hasta ecu_max
if epsilon_c <= 0: # No hay compresión
C = 0
a = 0
else:
# Usamos el c_trial actual para definir la zona de compresión teórica
# Pero la magnitud de la fuerza se basa en el bloque de Whitney
a = beta1 * c_trial
# Asegurar que 'a' no exceda la altura total 'h' (aunque c ecu_max,
# la fuerza C ya está en su máximo posible para este bloque.
# Esta condición se maneja implícitamente por la definición de 'a'.
# 4. Retornar la diferencia (para que fsolve busque la raíz C - T = 0)
return C - T
# Resolver para 'c' usando fsolve
# Una buena estimación inicial para 'c' puede ser d/3 o d/2
c_inicial = d / 3
try:
c_solution, infodict, ier, mesg = fsolve(equilibrio, c_inicial, full_output=True)
if ier == 1: # Convergencia exitosa
c = c_solution[0]
status = "Convergencia exitosa"
# Recalcular fuerzas con la 'c' encontrada para obtener M
epsilon_s = phi * (d - c)
if epsilon_s >= epsilon_y:
fs = fy
elif epsilon_s <= -epsilon_y:
fs = max(-fy, Es * epsilon_s)
else:
fs = Es * epsilon_s
T = As * fs
a = beta1 * c
a = min(a, h) # Asegurar que 'a' no exceda h
# Calcular Momento (T por brazo de palanca z = d - a/2)
z = d - a / 2
M_n_mm = T * z # Momento en N-mm
# Convertir a kN-m
M_kn_m = M_n_mm / 1e6
else: # No convergió
print(f"Advertencia: fsolve no convergió. Mensaje: {mesg}")
M_kn_m = np.nan
c = np.nan
status = f"Error de convergencia: {mesg}"
except Exception as e:
print(f"Error durante la solución numérica: {e}")
M_kn_m = np.nan
c = np.nan
status = f"Error de cálculo: {e}"
# Asegurar que c no sea negativo (resultado de posible mala convergencia)
if c < 0:
M_kn_m = np.nan # O manejar como un caso especial
status = "Error: Profundidad del eje neutro negativa."
return M_kn_m, c, status
# --- Ejemplo de Uso ---
if __name__ == "__main__":
# Propiedades de la viga y materiales (ejemplo)
b_viga = 300 # mm
h_viga = 500 # mm
recub = 40 # mm (recubrimiento libre)
diam_barra = 16 # mm (diámetro barra refuerzo)
d_viga = h_viga - recub - diam_barra / 2 # mm (peralte efectivo)
num_barras = 3
As_viga = num_barras * (np.pi * (diam_barra**2) / 4) # mm^2
fc_viga = 25 # MPa
fy_viga = 420 # MPa
# Curvatura dada
curvatura_dada = 0.00005 # 1/mm (ejemplo)
print(f"--- Parámetros de Entrada ---")
print(f"Ancho (b): {b_viga} mm")
print(f"Altura (h): {h_viga} mm")
print(f"Peralte Efectivo (d): {d_viga:.2f} mm")
print(f"Área de Acero (As): {As_viga:.2f} mm^2")
print(f"Resistencia Concreto (f'c): {fc_viga} MPa")
print(f"Fluencia Acero (fy): {fy_viga} MPa")
print(f"Curvatura (phi): {curvatura_dada} 1/mm")
print(f"-----------------------------\n")
# Calcular el momento
momento_calculado, c_calculado, estado = calcular_momento_desde_curvatura(
b_viga, h_viga, d_viga, As_viga, fc_viga, fy_viga, curvatura_dada
)
# Mostrar resultados
print(f"--- Resultados ---")
print(f"Estado del cálculo: {estado}")
if not np.isnan(momento_calculado):
print(f"Profundidad del Eje Neutro (c): {c_calculado:.2f} mm")
print(f"Momento Resistente (M): {momento_calculado:.2f} kN-m")
else:
print("No se pudo calcular el momento.")
print(f"------------------")
Explicación del Código
- Función `calcular_momento_desde_curvatura`: Encapsula toda la lógica. Recibe las propiedades geométricas (b, h, d), el área de acero (As), las resistencias de los materiales (fc, fy) y la curvatura (phi) como entrada.
- Parámetros `Es` y `ecu_max`: Módulo de elasticidad del acero y deformación máxima del concreto, con valores por defecto comunes.
- Cálculo de `beta1`: Determina el factor para la profundidad del bloque de Whitney según la resistencia del concreto `fc`, siguiendo las pautas del ACI 318.
- Función `equilibrio(c_trial)`: Esta función interna calcula las fuerzas de compresión (C) y tensión (T) para una profundidad de eje neutro de prueba `c_trial`.
- Calcula las deformaciones `epsilon_c` y `epsilon_s` basadas en `phi` y `c_trial`.
- Determina el esfuerzo en el acero `fs` (elástico o plástico) y calcula `T = As * fs`.
- Calcula la profundidad del bloque de Whitney `a = beta1 * c_trial` y la fuerza de compresión `C = 0.85 * fc * b * a`.
- Retorna la diferencia `C - T`. `fsolve` buscará el `c_trial` que haga esta diferencia cero.
- `fsolve(equilibrio, c_inicial, ...)`: Llama al optimizador numérico para encontrar la raíz de la función `equilibrio`, es decir, el valor de `c` que satisface `C = T`. Se proporciona una estimación inicial `c_inicial`.
- Cálculo del Momento `M`: Una vez encontrada la `c` de equilibrio, se recalculan `T` y `a`, y se calcula el momento como `M = T * (d - a/2)`.
- Manejo de Errores y Convergencia: El código incluye bloques `try-except` y verifica el estado de convergencia de `fsolve`, retornando `NaN` y un mensaje si el cálculo falla.
- Ejemplo de Uso (`if __name__ == "__main__":`): Muestra cómo llamar a la función con datos de ejemplo y cómo imprimir los resultados.
Modelos de Materiales Utilizados
Simplificaciones para el Análisis
El análisis se basa en modelos simplificados pero ampliamente aceptados para el comportamiento del concreto y el acero bajo carga:
| Material | Modelo | Descripción | Parámetros Clave |
|---|---|---|---|
| Concreto (Compresión) | Bloque Rectangular Equivalente (Whitney) | Asume una distribución uniforme de esfuerzos de \( 0.85 f'_c \) sobre una profundidad \( a = \beta_1 c \). Ignora la resistencia a tracción del concreto. | \( f'_c \), \( \beta_1 \) (depende de \( f'_c \)), \( \epsilon_{cu} \) (deformación última, típicamente 0.003) |
| Acero (Tracción/Compresión) | Elástico - Perfectamente Plástico | Comportamiento linealmente elástico hasta alcanzar el límite de fluencia \( f_y \). Más allá de la fluencia, el esfuerzo se mantiene constante en \( f_y \) (sin endurecimiento por deformación). | \( f_y \), \( E_s \) (Módulo de Young, aprox. 200,000 MPa), \( \epsilon_y = f_y / E_s \) (deformación de fluencia) |
Estos modelos simplifican el cálculo de las fuerzas internas C y T, permitiendo un análisis manejable.
Influencia de los Parámetros en el Momento
Visualización con un Gráfico Radar
El momento resistente de la sección para una curvatura dada depende de múltiples factores. El siguiente gráfico radar ilustra la sensibilidad relativa del momento calculado a cambios en los parámetros de entrada principales, considerando un rango típico de operación (post-fisuración, pre-aplastamiento). La influencia se califica subjetivamente en una escala donde valores más altos indican mayor impacto.
Como se observa, el peralte efectivo (`d`) y el área de acero (`As`) suelen tener la mayor influencia en el momento resistente, seguidos por la resistencia del acero (`fy`) y las dimensiones de la sección (`b`, `f'c`). La curvatura (`phi`) define el estado de deformación, pero su influencia directa en el valor del momento puede variar dependiendo de si el acero ha fluido o no.
Flujo de Trabajo del Análisis
Pasos Clave del Cálculo
El proceso implementado en el código Python para encontrar el momento (M) a partir de la curvatura (φ) sigue un flujo lógico basado en el equilibrio y la compatibilidad. El siguiente diagrama mental resume los pasos esenciales:
(a = β1 * c)"] id2_5["Verificar Equilibrio (C == T?)"] id2_6["Ajustar 'c' (usando fsolve)"] id3["Cálculo Final (con 'c' de equilibrio)"] id3_1["Recalcular Fuerzas C y T"] id3_2["Calcular Brazo Interno (z = d - a/2)"] id3_3["Calcular Momento (M = T * z)"] id4["Salida"] id4_1["Momento Resistente (M)"] id4_2["Profundidad Eje Neutro (c)"]
Este diagrama ilustra cómo, a partir de los datos de entrada y la curvatura especificada, el algoritmo itera para encontrar la profundidad del eje neutro ('c') que equilibra las fuerzas internas de compresión y tensión. Una vez hallada 'c', se calcula el momento resistente final.
Video Relevante: El Bloque de Whitney
Comprendiendo el Modelo de Compresión del Concreto
El modelo del bloque rectangular de esfuerzos equivalentes, conocido como Bloque de Whitney, es una simplificación fundamental utilizada en el diseño y análisis de secciones de concreto reforzado, tal como se implementa en el código Python anterior. Este modelo permite calcular fácilmente la fuerza resultante de compresión en el concreto.
El siguiente video explica la teoría detrás del diagrama de Whitney y su aplicación según normativas como el ACI 318, lo cual es directamente relevante para entender cómo se calcula la fuerza 'C' en nuestro programa:
Comprender este modelo es crucial, ya que representa la contribución del concreto a la resistencia a flexión de la viga en el estado límite último o en estados de deformación elevados, como los que se analizan al construir una curva Momento-Curvatura completa.
Preguntas Frecuentes (FAQ)
¿Qué unidades utiliza el programa?
El programa espera las longitudes (b, h, d, recubrimiento, diámetro) en milímetros (mm), las áreas (As) en milímetros cuadrados (mm²), y las resistencias (fc, fy) y el módulo de elasticidad (Es) en Megapascales (MPa). La curvatura (phi) se introduce en unidades de 1/mm. El momento resultante se devuelve en Kilonewton-metro (kN-m).
¿Qué representa el factor `beta1`?
`beta1` (β₁) es un factor utilizado en el modelo del bloque de Whitney para relacionar la profundidad del bloque de esfuerzos de compresión rectangular equivalente (`a`) con la profundidad del eje neutro (`c`). La relación es `a = β₁ * c`. El valor de β₁ depende de la resistencia a la compresión del concreto (f'c) y disminuye para concretos de mayor resistencia, según lo estipulado por códigos de diseño como el ACI 318.
¿Qué sucede si la curvatura introducida es muy alta o muy baja?
Curvatura muy baja: Si la curvatura es tan baja que la deformación máxima en el concreto no causa esfuerzos significativos o el momento resultante es menor que el momento de fisuración, el programa aún así calculará un momento basado en las hipótesis elásticas (si aplica) o del bloque de Whitney. Puede resultar en un momento pequeño.
Curvatura muy alta: Si la curvatura es tan alta que la deformación calculada en la fibra extrema de concreto (`epsilon_c = phi * c`) excede la deformación última admisible (`ecu_max`, típicamente 0.003), teóricamente la sección ya habría fallado por aplastamiento del concreto. El programa limita internamente la contribución del concreto basada en `ecu_max` y el bloque de Whitney asociado, pero el resultado debe interpretarse con cautela, ya que representa un estado post-falla teórica para esa curvatura. Idealmente, se analiza el rango de curvaturas hasta alcanzar `ecu_max` o una deformación límite en el acero.
¿Cuáles son las limitaciones de este programa?
Este programa tiene algunas limitaciones:
- Asume una sección rectangular y refuerzo solo a tracción (simplemente reforzada).
- Utiliza modelos de materiales simplificados (Whitney y elástico-plástico perfecto). No considera endurecimiento por deformación del acero ni modelos más complejos para el concreto.
- No considera efectos de cortante, torsión, o efectos de segundo orden.
- No incluye factores de reducción de resistencia (φ) que se usan en el diseño final según códigos. Calcula el momento nominal (Mn).
- La convergencia del solver numérico (`fsolve`) puede fallar para ciertas combinaciones extremas de parámetros o curvaturas.
Referencias
- Revisión de diseño a flexión de una viga rectangular - Marcelo Pardo
- Determinación y Análisis de la gráfica Momento-Curvatura de diferentes secciones de vigas de concreto reforzado - Academia.edu
- [PDF] DIAGRAMAS MOMENTO-CURVATURA (M-φ) EN EL HORMIGÓN - Repositorio El Poli
- Vigas doblemente reforzadas_expo | PPT - SlideShare
- Momento de inercia: descripción general, Fórmula, Cálculos - SkyCiv
- [PDF] análisis de la relación de la ductilidad con la cuantía de refuerzo a ... - CORE
Consultas Recomendadas
Last updated April 13, 2025