Rutina de Python para resolver armaduras

bi-dimensionales en el curso de Estática

@arpan3t1

1
https://www.facebook.com/arpan3t

27 de octubre de 2021

Resumen

En este trabajo se presenta un programa de computadora escrito en Python 3.4.7

para resolver armaduras bi-dimensionales estáticamente determinadas con un apoyo
articulado fijo y un apoyo libre. El programa calcula la fuerza que actúa en cada
elemento de la armadura, indicando si está en tensión o compresión, o si es un elemento
de fuerza cero. En principio, se describe la nomenclatura y el marco de referencia usado
en las armaduras. Después, se presenta el bloque de código principal, y finalmente, se
resuelve un problema de armaduras usando el programa, a modo de ejemplo. Esta
rutina es útil para los estudiantes que estén tomando el curso de Estática, o para
cualquier profesional que desee resolver una armadura de forma rápida y sencilla.

1. Introducción

Una armadura es un tipo de estructura diseñada para soportar cargas. Por lo general, son
estructuras estacionarias que están totalmente restringidas. Las armaduras consisten exclu-
sivamente de elementos rectos que están conectados en nodos localizados en los extremos
de cada elemento. Por tanto, los elementos de una armadura son elementos sujetos a dos
fuerzas, esto es, elementos sobre los cuales actúan dos fuerzas [1]. Resolver una armadu-
ra significa hallar la fuerza que actúa en cada uno de sus elementos y establecer cuáles se
encuentran en tensión o compresión. El programa presentado en este trabajo resuelve la
armadura y muestra una tabla con las fuerzas que actúan en cada elemento, indicando si
están en tensión o compresión, o si es un elemento de fuerza cero. Para el uso del programa,

1
es necesario enumerar los nodos y los elementos de acuerdo a la convención que se describe
a continuación.

1. El nodo con apoyo articulado fijo siempre será el nodo inicial (nodo 1).

2. El origen de coordenadas del sistema de referencia establecido coincide con el nodo 1.

3. Enumerar todos los nodos y todos los elementos con números consecutivos.

Para ilustrar mejor el uso del sistema de convenciones, se ha usado el problema 6-17 del libro
Ingenierı́a Mecánica-Estática, de R.C. Hibbeler [2]. La Figura 1, muestra una armadura con
5 nodos y 7 elementos, la cual soporta una carga vertical concentrada aplicada en el punto D.
Se ha elegido el nodo articulado fijo como el nodo número 1 y como el origen de coordenadas.
Seguidamente, se han enumerado los demás nodos y los elementos de forma consecutiva.

Figura 1: Enumeración de nodos y elementos de la armadura

4 7 5

3 4 5 6

1 1 2 2 3 x

La dirección de la carga aplicada, se establece según las convenciones mostradas en la Figura

2. Según el sistema de referencia, una carga vertical hacia abajo, como la aplicada en el
punto D, tiene una dirección θ = 270◦ . Del mismo modo, una carga vertical hacia arriba
tiene una dirección θ = 90◦ , una carga horizontal hacia la derecha tiene una dirección θ = 0◦ ,
y una carga horizontal hacia la izquierda tiene una dirección θ = 180◦ . Si la carga aplicada
en un nodo tiene componentes en dirección x y dirección y, se debe hacer la descomposición
vectorial y considerar las componentes como cargas independientes.

2
 Figura 2: Convención usada para la dirección de las cargas

(a) (b)
y y

θ = 90° θ = 0°
x x

(c) (d)
y y

θ = 270° θ = 180°
x x

Por otro lado, se considera que cada elemento tiene un nodo inicial y un nodo final. Por
ejemplo, el elemento 5 de la armadura mostrada en la Figura 1, tiene como nodo inicial al
nodo 2, y como nodo final al nodo 5, considerando inicial al nodo de menor número. Con
respecto al programa, el usuario únicamente debe ingresar los datos de entrada, los cuales
son un conjunto de 12 variables cuyo significado se muestra a continuación.

Cuadro 1: Variables de entrada

Ítem Variable Significado

1 nodos Número de nodos de la armadura
2 elementos Número de elementos de la armadura
3 x coord Coordenadas x de cada nodo
4 y coord Coordenadas y de cada nodo
5 ielem Nodos iniciales de los elementos
6 jelem Nodos finales de los elementos
7 kfixed Número de nodo de apoyo articulado fijo
8 kslide Número de nodo de apoyo libre
9 nforce Número total de nodos con cargas externas
10 kforce Nodos con cargas externas
11 fforce Fuerzas externas aplicadas en los nodos
12 tforce Dirección de las fuerzas aplicadas

3
 2. Código del programa

1 import numpy as np
2 from prettytable import PrettyTable
3
4 # - - - - - - - - - - - - - - - - - - - - - - - - Datos de entrada - - - - - - - - - - - - - - - - - - - - - - - - - - - -
5 nodos =8
6 elementos =13
7 x_coord = np . array ([0 , 6 , 12 , 18 , 4 , 8 , 15 , 12])
8 y_coord = np . array ([0 , 0 , 0 , 0 , 2 , 4 , 3 , 6])
9 ielem = np . array ([1 , 2 , 3 , 1 , 2 , 2 , 3 , 3 , 3 , 4 , 5 , 6 , 7])
10 jelem = np . array ([2 , 3 , 4 , 5 , 5 , 6 , 6 , 8 , 7 , 7 , 6 , 8 , 8])
11 kfixed = np . array ([1])
12 kslide = np . array ([4])
13 nforce =6
14 kforce = np . array ([1 , 4 ,5 ,6 ,7 ,8])
15 fforce = np . array ([1 , 0.75 , 2 , 2 , 1.5 , 1.75])
16 tforce = np . array ([270 , 270 , 270 , 270 , 270 , 270]) /180* np . pi
17
18 # - - - - - - - - - - - - - - - - - - - - - - - Codigo principal - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
19
20 nfixed =1
21 nslide =1
22 tslide = np . array ([0]) /180* np . pi
23 telem =[]
24 lelem = np . sqrt (( y_coord [ jelem -1] - y_coord [ ielem -1]) **2+( x_coord [ jelem -1] -
x_coord [ ielem -1]) **2)
25 telem = np . arctan2 ( y_coord [ jelem -1] - y_coord [ ielem -1] , x_coord [ jelem -1] -
x_coord [ ielem -1])
26 theta = telem *180/ np . pi
27 nunk = elementos +2* nfixed + nslide
28 kg = np . zeros (( nunk , nunk ) )
29 xg = np . zeros (( nunk , 1) )
30 fg = np . zeros (( nunk ,1) )
31
32 for i in range (0 , elementos ) :
33 kg [2* ielem [ i ] -2][ i ]= np . cos ( telem [ i ])
34 kg [2* ielem [ i ] -1][ i ]= np . sin ( telem [ i ])
35 kg [2* jelem [ i ] -2][ i ]= - np . cos ( telem [ i ])
36 kg [2* jelem [ i ] -1][ i ]= - np . sin ( telem [ i ])
37
38 for i in range (0 , nfixed ) :
39 kg [2* kfixed [ i ] -2][ elementos +2* i ]=1
40 kg [2* kfixed [ i ] -1][ elementos +2* i +1]=1
41
42 for i in range (0 , nslide ) :
43 kg [2* kslide [ i ] -2][ elementos +2* nfixed + i ]= np . cos ( tslide [ i ] - np . pi /2)
44 kg [2* kslide [ i ] -1][ elementos +2* nfixed + i ]= np . sin ( tslide [ i ] - np . pi /2)
45
46 for i in range (0 , nforce ) :
47 fg [2* kforce [ i ] -2]= fforce [ i ]* np . cos ( tforce [ i ])
48 fg [2* kforce [ i ] -1]= fforce [ i ]* np . sin ( tforce [ i ])
49
50 fg_mejorada = fg
51 for i in range (0 , elementos +3) :
52 if np . abs ( fg [ i ]) <0.000000001:
53 fg_mejorada [ i ]=0
54
55 fg = fg_mejorada
56 kg_mejorada = kg
57
58 for i in range (0 , elementos +3) :
59 for j in range (0 , elementos +3) :
60 if np . abs ( kg [ i ][ j ]) <0.000000001:
61 kg_mejorada [ i ][ j ]=0
62
63 kg = kg_mejorada

4
64 x_solu = np . linalg . solve ( - kg , fg )
65
66 fuerza = np . abs ( x_solu )
67 fuerza = np . round ( fuerza ,3)
68
69 estado ={}
70 for i in range (0 , elementos ) :
71 if x_solu [ i ] >0:
72 estado [ i ]= " Tension "
73 elif x_solu [ i ] <0:
74 estado [ i ]= ’ Compresion ’
75 elif np . abs ( x_solu [ i ]) <0.01:
76 estado [ i ]= ’ Elemento de fuerza cero ’
77
78 F =([ ’ F1 ’ , ’ F2 ’ , ’ F3 ’ , ’ F4 ’ , ’ F5 ’ , ’ F6 ’ , ’ F7 ’ , ’ F8 ’ ,
79 ’ F9 ’ , ’ F10 ’ , ’ F11 ’ , ’ F12 ’ , ’ F13 ’ , ’ F14 ’ , ’ F15 ’ , ’ F16 ’ ])
80
81 # - - - - - - - - - - - - - - - - - - - - - - - Imprimir resultados - - - - - - - - - - - - - - - - - - - - - - - - -
82
83 table = PrettyTable ([ " Elemento " , " Fuerza [ kips ] " , " Estado " ])
84 for x in range (0 , elementos ) :
85 table . add_row (([ " {} " . format ( F [ x ]) , " {} " . format ( fuerza [ x ]) ," {} " . format (
estado [ x ]) ]) )
86 print ( table )
87
88 # - - - - - - - - - - - - - - - - - - - - - - - - - Fin del programa - - - - - - - - - - - - - - - - - - - - - - - - - - -

3. Ejemplo de uso del programa

Para ilustrar el uso del programa, se ha usado el Problema 6.27 del libro Mecánica vectorial
para ingenieros Beer & Johnston, novena edición [1]. La Figura 3, presenta la armadura del
problema, la cual tiene 7 nodos y 11 elementos. Se pide determinar la fuerza que actúa en
cada elemento y establecer si están en tensión o en compresión, para las condiciones de carga
mostradas.

Figura 3: Armadura del problema 6.27

5
 Es preciso ingresar los datos de entrada. Por lo tanto, el usuario deberı́a llegar a los mismos
datos mostrados a continuación:
1
2 # - - - - - - - - - - - - - - - - - - - - - - - - Datos de entrada - - - - - - - - - - - - - - - - - - - - - - - - - - - -
3 nodos =7
4 elementos =11
5 x_coord = np . array ([0 ,20 ,5 ,15 ,0 ,20 ,10])
6 y_coord = np . array ([0 ,0 ,10 ,10 ,16 ,16 ,20])
7 ielem = np . array ([1 ,1 ,2 ,2 ,3 ,3 ,3 ,4 ,4 ,5 ,6])
8 jelem = np . array ([5 ,3 ,4 ,6 ,4 ,5 ,7 ,7 ,6 ,7 ,7])
9 kfixed = np . array ([1])
10 kslide = np . array ([2])
11 nforce =2
12 kforce = np . array ([4 ,5])
13 fforce = np . array ([40 ,15])
14 tforce = np . array ([270 ,0]) /180* np . pi
15 # ----------------------------------------------------------------------

Al ingresar el conjunto de datos mostrados anteriormente y ejecutar el programa, se obtiene

la tabla con la solución de la armadura, como se muestra en la Figura 4. Un vı́deo explicativo
del uso del programa, se puede ver en el enlace https://fb.watch/8V9-tAhTiw/.

Figura 4: Fuerza y estado en cada elemento de la armadura

Referencias

[1] F. Beer, Vector mechanics for engineers: Statics. New York: McGraw-Hill, 11th ed., 2016.

[2] R. Hibbeler, Engineering Mechanics: Statics. Engineering mechanics, Pearson Prentice

Hall, 2016.