Capítulo 2

Nuestro primer notebook

Todo análisis de una armadura empieza por su geometría. Antes de hablar de rigideces, cada barra debe quedar descrita por su longitud y por su orientación en el plano. En este capítulo damos el primer paso de nuestra calculadora: obtenemos la geometría de una barra, escribiendo nuestras primeras líneas de Python en un notebook de Google Colab.

No necesitamos instalar nada. Basta con una cuenta de Google y un navegador.

2.1 La geometría de una barra

Consideremos una barra que va de un nodo inicial $i$, de coordenadas $(x_i, y_i)$, a un nodo final $j$, de coordenadas $(x_j, y_j)$ (figura 2.1). Las proyecciones de la barra sobre los ejes son

y con ellas obtenemos su longitud y sus cosenos directores (direction cosines):

El ángulo $\theta$ se mide desde el eje $x$ global, en sentido antihorario, hasta la dirección que va del nodo $i$ al nodo $j$. Por eso el orden de los nodos importa: si intercambiamos $i$ y $j$, cambian los signos de $c$ y $s$, y el ángulo aumenta en 180°.

Estas tres cantidades parecen modestas, pero las usaremos en todo el libro: la longitud interviene en la rigidez de la barra, y los cosenos directores en la matriz de transformación del capítulo 5.

2.2 Nuestro primer notebook

Un notebook es un documento que mezcla celdas de texto y celdas de código que se pueden ejecutar. Usaremos Google Colab (Google Colaboratory), un servicio gratuito que ejecuta notebooks de Python en los servidores de Google. Tiene dos ventajas decisivas para nosotros: no requiere instalar nada, y ya incluye las bibliotecas que usa este libro.

Crear el notebook en Google Drive

Para que nuestro trabajo quede guardado y organizado, creamos el notebook dentro de nuestro propio Google Drive:

1. Abrir drive.google.com con nuestra cuenta de Google.
2. Crear una carpeta para el curso, por ejemplo Calculadora de armaduras.
3. Dentro de la carpeta, elegir Nuevo $\to$ Más $\to$ Google Colaboratory. Si la opción no aparece, elegir Conectar más aplicaciones, buscar Colaboratory e instalarla.
4. Cambiar el nombre del notebook (arriba a la izquierda), por ejemplo, Capitulo 02.

La figura 2.2 muestra el menú para crear el notebook, y la figura 2.3, el notebook recién creado.

Celdas de código

Un notebook nuevo trae una celda de código vacía. Escribimos en ella la siguiente línea y la ejecutamos con el botón de reproducción, a la izquierda de la celda, o con las teclas Mayús + Enter:

print("Hola, armaduras")

Hola, armaduras

La primera ejecución tarda unos segundos, porque Colab prepara una máquina para nosotros. Debajo de la celda aparece lo que el programa imprime (figura 2.4).

Una celda también puede contener una operación. Si la última línea de una celda es una expresión, el notebook muestra su valor:

2 + 3 * 4

14

Python respeta la precedencia habitual: la multiplicación se evalúa antes que la suma. Para agregar celdas usamos los botones + Código y + Texto; las celdas de texto sirven para anotar qué estamos calculando.

2.3 Variables y operaciones

Una variable es un nombre que guarda un valor. Guardemos las coordenadas de los nodos de la barra 3 del ejemplo A, que va del nodo 1, en $(0, 0)$, al nodo 3, en $(3, 4)$:

# Coordenadas (en m) del nodo inicial i y del nodo final j
x_i = 0.0
y_i = 0.0
x_j = 3.0
y_j = 4.0

El signo = no expresa una igualdad matemática: es una asignación (assignment). Se lee «guardar el valor 0.0 con el nombre x_i». Las líneas que empiezan con # son comentarios: Python las ignora, pero a nosotros nos recuerdan qué representa cada valor.

Con las variables definidas, calculamos las proyecciones de la ecuación (2.1). Al escribir dos expresiones separadas por una coma, el notebook muestra ambas:

dx = x_j - x_i
dy = y_j - y_i
dx, dy

(3.0, 4.0)

Las operaciones aritméticas se escriben con +, -, * y /, y la potencia con **. La suma de los cuadrados de las proyecciones es:

dx**2 + dy**2

25.0

Los números muy grandes o muy pequeños se escriben en notación científica (scientific notation): 2.0e8 significa $2.0\times10^{8}$. Así escribiremos el módulo de elasticidad del acero en kN/m²:

E = 2.0e8  # módulo de elasticidad del acero, en kN/m²
A = 0.0020  # área de la sección, en m²
E * A

400000.0

El producto $EA = 400\,000\,\mathrm{kN}$ es la rigidez axial de la sección; la retomaremos en el capítulo 5.

2.4 El módulo math

Python trae incorporadas solo las operaciones básicas. Las funciones matemáticas, como la raíz cuadrada o las funciones trigonométricas, están en el módulo (module) math, que debemos importar una vez por notebook:

import math

A partir de ese momento, escribimos las funciones del módulo con el prefijo math seguido de un punto. La longitud de la barra es:

L = math.sqrt(dx**2 + dy**2)
L

5.0

Y sus cosenos directores:

c = dx / L
s = dy / L
c, s

(0.6, 0.8)

Para el ángulo usamos math.atan2(dy, dx), que devuelve el ángulo en radianes, y math.degrees, que lo convierte a grados:

theta = math.degrees(math.atan2(dy, dx))
theta

53.13010235415598

2.5 Mostrar resultados con print y f-strings

El ángulo anterior aparece con catorce decimales, una precisión que ninguna medición justifica. Para presentar resultados usamos print junto con f-strings (formatted string literals): textos precedidos por una f en los que cada expresión entre llaves se reemplaza por su valor. Después de los dos puntos indicamos el formato; por ejemplo, :.3f significa «número con tres decimales»:

print(f"Longitud: L = {L:.3f} m")
print(f"Cosenos directores: c = {c:.4f}, s = {s:.4f}")
print(f"Ángulo: θ = {theta:.2f}°")

Longitud: L = 5.000 m
Cosenos directores: c = 0.6000, s = 0.8000
Ángulo: θ = 53.13°

De ahora en adelante, todo resultado que presentemos llevará sus unidades y una cantidad razonable de decimales: milímetros para los desplazamientos, tres cifras significativas para las fuerzas.

2.6 La geometría de una barra en Python

Reunimos todo lo anterior para obtener la geometría completa de una barra. Los pasos son siempre los mismos:

# Barra 2 del ejemplo A: del nodo 2 al nodo 3
x_i, y_i = 6.0, 0.0
x_j, y_j = 3.0, 4.0

dx = x_j - x_i
dy = y_j - y_i
L = math.sqrt(dx**2 + dy**2)
c = dx / L
s = dy / L
theta = math.degrees(math.atan2(dy, dx))

print(f"L = {L:.3f} m")
print(f"c = {c:.4f}, s = {s:.4f}")
print(f"θ = {theta:.2f}°")

L = 5.000 m
c = -0.6000, s = 0.8000
θ = 126.87°

Repaso y resumen del capítulo

• La geometría de una barra que va del nodo $i$ al nodo $j$ queda determinada por $L = \sqrt{\Delta x^2 + \Delta y^2}$, $c = \Delta x / L$ y $s = \Delta y / L$, con $\Delta x = x_j - x_i$ y $\Delta y = y_j - y_i$.
• El orden de los nodos define el sentido de la barra: intercambiarlos cambia los signos de $c$ y $s$.
• Un notebook combina texto y código. Recuerda lo que se ejecutó, no lo que está escrito: ante dudas, Ejecutar todas.
• En Python, = asigna un valor a una variable; la potencia se escribe ** y la notación científica 2.0e8.
• El módulo math aporta math.sqrt, math.atan2 y math.degrees, entre otras funciones.
• Los resultados se presentan con f-strings, con unidades y un número razonable de decimales: f"{L:.3f} m".

Ejercicios

Los ejercicios con resultado numérico tienen una celda de verificación en el notebook del capítulo: al escribir allí el resultado y ejecutar la celda, se indica si es correcto.

Cada ejercicio tiene su solución completa debajo del enunciado.

# Barra 1 del ejemplo A: de (0, 0) a (6, 0)
dx = 6.0 - 0.0
dy = 0.0 - 0.0
L = math.sqrt(dx**2 + dy**2)
c = dx / L
s = dy / L
print(f"L = {L:.3f} m")
print(f"c = {c:.4f}, s = {s:.4f}")

L = 6.000 m
c = 1.0000, s = 0.0000

# Barra de cubierta: de (0, 0) a (4.5, 1.5)
dx = 4.5 - 0.0
dy = 1.5 - 0.0
L = math.sqrt(dx**2 + dy**2)
c = dx / L
s = dy / L
theta = math.degrees(math.atan2(dy, dx))
print(f"L = {L:.3f} m")
print(f"c = {c:.4f}, s = {s:.4f}")
print(f"θ = {theta:.2f}°")

L = 4.743 m
c = 0.9487, s = 0.3162
θ = 18.43°

E = 2.0e8  # kN/m²
A = 0.0020  # m²
L = 5.0  # m
rigidez_axial = E * A / L
print(f"EA/L = {rigidez_axial:.0f} kN/m")

EA/L = 80000 kN/m

# Barra de (6, 0) a (0, 3): hacia la izquierda y arriba
dx = 0.0 - 6.0
dy = 3.0 - 0.0
con_atan = math.degrees(math.atan(dy / dx))
con_atan2 = math.degrees(math.atan2(dy, dx))
print(f"Con atan:  θ = {con_atan:.2f}°")
print(f"Con atan2: θ = {con_atan2:.2f}°")

Con atan:  θ = -26.57°
Con atan2: θ = 153.43°

# Barra vertical: de (2, 3) a (2, -1)
dx = 2.0 - 2.0
dy = -1.0 - 3.0
L = math.sqrt(dx**2 + dy**2)
c = dx / L
s = dy / L
theta = math.degrees(math.atan2(dy, dx))
print(f"L = {L:.3f} m")
print(f"c = {c:.4f}, s = {s:.4f}")
print(f"θ = {theta:.2f}°")

L = 4.000 m
c = 0.0000, s = -1.0000
θ = -90.00°