Desarrollo de un código en Phyton con el apoyo de la IA para el análisis lineal – dinámico de un pórtico con OpenseesPy: caso estudio Autor: Ing. Civil Santiago López Osorio Monografía presentada para optar al título de Especialista en Análisis y Diseño de Estructuras Asesor Juan Carlos Vélez Cadavid, Doctor (PhD) en Ingeniería estructural Universidad de Antioquia Facultad de Ingeniería Especialización en Análisis y Diseño de Estructuras Medellín, Antioquia, Colombia 2025 2 Cita (López Osorio, 2025) Referencia Estilo APA 7 (2020) López Osorio, S. (2025). Desarrollo de un código en Phyton con el apoyo de la IA para el análisis lineal – dinámico de un pórtico de seis grados de libertad: caso de estudio. [Trabajo de grado especialización]. Universidad de Antioquia, Medellín, Colombia. Especialización en Análisis y Diseño de Estructuras, Cohorte XII. Grupo de Investigación Seleccione grupo de investigación UdeA (A-Z). Seleccione centro de investigación UdeA (A-Z). Elija un elemento. Repositorio Institucional: http://bibliotecadigital.udea.edu.co Universidad de Antioquia - www.udea.edu.co El contenido de esta obra corresponde al derecho de expresión de los autores y no compromete el pensamiento institucional de la Universidad de Antioquia ni desata su responsabilidad frente a terceros. Los autores asumen la responsabilidad por los derechos de autor y conexos. https://co.creativecommons.net/tipos-de-licencias/ https://co.creativecommons.net/tipos-de-licencias/ 3 Tabla de contenido Resumen ...........................................................................................................................................4 Abstract ............................................................................................................................................5 Justificación .....................................................................................................................................6 Objetivos ..........................................................................................................................................7 Introducción .....................................................................................................................................8 Caso estudio .....................................................................................................................................9 Comprobación ................................................................................................................................26 Análisis de resultados y Conclusiones ...........................................................................................32 Recomendaciones ..........................................................................................................................33 Referencias .....................................................................................................................................34 4 Resumen Este trabajo presenta un análisis estructural de un pórtico de 6 grados de libertad, abordando tanto su comportamiento lineal estático como su respuesta dinámica. Para este fin, se ha desarrollado un código en Python utilizando el entorno de Google Colaboratory, lo que permite una ejecución flexible y accesible. El estudio lineal se centra en determinar las reacciones de los apoyos, los diagramas de fuerzas internas (axiales, cortantes y momentos flectores), y las deformaciones resultantes de la aplicación de cargas estáticas. Por otro lado, el análisis dinámico explora la respuesta del pórtico ante cargas variables en el tiempo. Se identifican las frecuencias y modos de vibración propios de la estructura, lo cual es fundamental para evaluar su comportamiento ante fenómenos como sismos o vibraciones forzadas. Los resultados obtenidos del análisis computacional proporcionan una comprensión detallada y precisa de la rigidez y estabilidad del pórtico. Este enfoque metodológico integra la teoría de la mecánica estructural con la potencia de la programación, ofreciendo una herramienta versátil para el diseño y la verificación de estructuras. 5 Abstract This work presents a structural analysis of a 6-degree-of-freedom portal frame, addressing both its linear static behavior and dynamic response. To this end, a code has been developed in Python using the Google Colaboratory environment, allowing for a flexible and accessible execution. The linear study focuses on determining support reactions, internal force diagrams (axial, shear, and bending moments), and the resulting deformations from the application of static loads. The dynamic analysis, on the other hand, explores the frame's response to time-varying loads. The structure's natural frequencies and vibration modes are identified, which is essential for evaluating its behavior under phenomena such as earthquakes or forced vibrations. The results obtained from the computational analysis provide a detailed and precise understanding of the portal frame's stiffness and stability. This methodological approach integrates structural mechanics theory with the power of programming, offering a versatile tool for the design and verification of structures. 6 Justificación El diseño y la verificación de estructuras, como los pórticos, requieren una comprensión precisa de su comportamiento bajo diversas condiciones de carga. Tradicionalmente, este análisis se ha realizado mediante métodos manuales o herramientas comerciales costosas, que a menudo presentan limitaciones en términos de flexibilidad, transparencia del proceso y accesibilidad. La complejidad de los cálculos, especialmente en estructuras con múltiples grados de libertad, puede llevar a aproximaciones que no siempre capturan la respuesta real de la estructura de manera completa. Este proyecto se motiva por la necesidad de una herramienta de análisis accesible, transparente y adaptable. En lugar de depender de software, el desarrollo de un código en Python permite a los ingenieros y estudiantes comprender cada paso del proceso computacional, desde la formulación de las matrices de rigidez hasta la obtención de los resultados finales. Este enfoque no solo facilita la enseñanza y el aprendizaje de la mecánica estructural, sino que también permite la personalización del análisis para problemas específicos, como la inclusión de diferentes tipos de materiales, cargas o condiciones de apoyo. El problema que se aborda es la brecha existente entre la teoría y la práctica computacional en la ingeniería estructural. Se busca demostrar que es posible desarrollar una herramienta analítica robusta, capaz de realizar un análisis tanto lineal-estático como dinámico de un pórtico con un número significativo de grados de libertad (6 en este caso), utilizando únicamente herramientas de código abierto como Python, OpenseesPy y Google Colab. Esto no solo democratiza el acceso a potentes herramientas de análisis, sino que también fomenta una comprensión más profunda de los principios fundamentales que rigen el comportamiento de las estructuras, preparando a los futuros ingenieros para enfrentar los desafíos de diseño del mundo real con mayor confianza y conocimiento. 7 Objetivo General Desarrollar y validar un modelo computacional en Python para el análisis estructural de un pórtico de 6 grados de libertad, abarcando tanto su comportamiento estático lineal como su respuesta dinámica. Objetivos Específicos Formular las ecuaciones de equilibrio estático del pórtico, considerando las matrices de rigidez de cada elemento para construir la matriz de rigidez global de la estructura. Implementar el código de cálculo en el entorno de Google Colaboratory que permita resolver el sistema de ecuaciones para determinar los desplazamientos, las fuerzas internas (momentos, cortantes y axiales) y las reacciones en los apoyos bajo cargas estáticas. Realizar el análisis dinámico del pórtico para obtener sus frecuencias y modos de vibración naturales, que son cruciales para entender su respuesta ante cargas dinámicas, como vibraciones o sismos. 8 Introducción Esta monografía aborda el desarrollo y la implementación de un código en Python para el análisis estructural de un pórtico de concreto de 6 grados de libertad. El trabajo se enfoca en dos metodologías clave: el análisis estático para evaluar la respuesta de la estructura bajo cargas permanentes y de servicio, y el análisis dinámico para comprender su comportamiento frente a excitaciones transitorias, como sismos. La herramienta de programación utilizada es Google Colaboratory (Colab), un entorno de desarrollo integrado que facilita la ejecución de código en la nube, lo que elimina la necesidad de instalaciones complejas de software y permite un acceso más flexible y colaborativo al proyecto. El objetivo principal es demostrar cómo las herramientas computacionales modernas, como Python y Colab, pueden simplificar y optimizar el proceso de cálculo estructural. Tradicionalmente, este tipo de análisis se realiza con software comercial de alto costo o mediante métodos manuales que son propensos a errores y consumen mucho tiempo. En contraste, esta monografía presenta un enfoque alternativo y accesible que, a través de la programación, permite a los ingenieros y estudiantes construir sus propias herramientas de análisis, lo que fomenta una comprensión más profunda de los principios de la mecánica estructural y la teoría de las vibraciones. A lo largo de este documento, se detallará el marco teórico subyacente a los análisis estático y dinámico y la implementación de los algoritmos de solución numérica en Python. Finalmente, se presentarán los resultados obtenidos, validando la precisión del modelo computacional y su utilidad para aplicaciones prácticas en la ingeniería civil. 9 Caso estudio El presente trabajo se basa principalmente en el desarrollo paso a paso del video de Maldonado, L. [@Structural Tech](2025, mayo 28). Análisis Estructural y Dinámico con OpenseesPy. [Video]. Youtube. https://www.youtube.com/watch?v=uvLyCMow-h0 Para realizar el paso a paso correctamente debe tenerse instalado previamente sistemas de programación y tener cierto grado de conocimiento en programas como: Phyton, OpenseesPy, Visual Basic, Google Colab, Google Gemini, entre otras. Desarrollo del Paso a paso: 1. En Google Colab: Abrir nuevo código: para instalar las librerías que se utilizaran a lo largo de toda la formulación del trabajo. En esta línea de código se insertarán: Openseespy (librería para realizar simulaciones y análisis estructurales no lineales utilizando Python), Opsvis (librería para ver resultados de manera gráfica), Matplotlib (librería que permite personalizar los resultados gráficos) y Numpy (librería que se asemeja al algebra lineal en Python para vectores). Insertar: pip install openseespy pip install opsvis pip install matplotlib pip install numpy Ejecutar 2. Abrir nueva línea de código para importar y nombrar las librerías previamente instaladas. Insertar: Import openseespy.opensees as ops Import opsvis as opsv Import matplotlib.pyplot as plt Import numpy as np Ejecutar 3. Abrir nueva línea de código: este código limpia los parámetros iniciales que tengas en modelos anteriores. Insertar: ops.wipe () Ejecutar 4. Abrir nueva línea de código, este código crea el modelo como tal, donde ndm es el # de dimensiones con las que se va a trabajar (3 para este caso), ndf es el # de grados de libertad (6 para este caso) de cada nodo del modelo a realizar. https://www.youtube.com/watch?v=uvLyCMow-h0 10 Insertar: ops.model (‘basic’ , ‘-ndm’ , 3, ‘-ndf’ , 6) Ejecutar 5. En un archivo de OneNote, Paint o similar, se dibuja el siguiente esquema inicial del modelo: Figura 1 Esquema inicial del pórtico. Fuente: elaboración propia. 6. Una vez creado este esquema, se copia y se pega en Google Colab mediante una línea de texto y no en línea de código. 7. Abrir nueva línea de cogido para definir la geometría del modelo y propiedades del modelo, donde; B: base, L: longitud, H: altura, E: módulo de elasticidad, G: módulo de corte. Insertar: B = 4.8 L = 6.5 H = 2.7 E = 2.1e7 G = E / (2*(1+0.20)) Ejecutar 8. En el archivo de OneNote definir la numeración de los nodos y las coordenadas de cada uno, así: 11 Figura 2 Numeración y Localización de los nodos (coordenadas). Fuente: elaboración propia. 9. En Google Colab, copiar y pegar esta imagen en línea de texto. 10. Abrir nueva línea de código para ingresar los nodos del modelo: Insertar: ops.node(1, 0, 0, 0) ops.node(2, L, 0, 0) ops.node(3, L, B, 0) ops.node(4, 0, B, 0) ops.node(5, 0, 0, H) ops.node(6, L, 0, H) ops.node(7, L, B, H) ops.node(8, 0, B, H) Ejecutar 11. Se realiza una prueba para verificar que se está modelando: abrir nueva línea de código: Insertar: opsv.plot_model() Ejecutar Se obtiene la localización de los nodos, mostrada en la figura 3. 12 Figura 3 Localización de los nodos en el modelo. Fuente: elaboración propia. 12. Ahora se definen las propiedades de los elementos a modelar: 12.1 Definir área e inercias de las columnas: Abrir nueva línea de código: Insertar: # columnas a = 0.45 A_col = a**2 Iz_col = a**4 / 12 Iy_col = Iz_col Ejecutar 12.2 Definir área e inercias de las vigas: Abrir nueva línea de código: Insertar: # vigas b, h = 0.30, 0.60 A_beam = b * h Iz_beam = h * b**3 / 12 Iy_beam = b*h**3 / 12 J = 0.05 Ejecutar 13. Se ingresa ahora el orden de conectividad de los elementos, pero antes de crearlos, se requiere definir la transformada geométrica, que es la manera en que se van a ordenar los ejes locales de los elementos. Abrir nueva línea de código: 13 Insertar: ops.geomTransf('Linear',1,*[1,0,0]) ops.geomTransf('Linear',2,*[0,0,1]) Ejecutar 14. Creación de las columnas: Abrir nueva línea de código: Insertar: ops.element('elasticBeamColumn', 1, 1, 5, A_col, E, G, J, Iy_col,Iz_col, 1) ops.element('elasticBeamColumn', 2, 2, 6, A_col, E, G, J, Iy_col,Iz_col, 1) ops.element('elasticBeamColumn', 3, 3, 7, A_col, E, G, J, Iy_col,Iz_col, 1) ops.element('elasticBeamColumn', 4, 4, 8, A_col, E, G, J, Iy_col,Iz_col, 1) Ejecutar Se vuelve a chequear que el modelo si este creando con el código: opsv.plot_model() Ejecutar Se obtiene el modelado de las columnas, mostradas en la figura 4. Figura 4 Modelado de las columnas. Fuente: elaboración propia. 15. Creación de las vigas: Abrir nueva línea de código: Insertar: ops.element('elasticBeamColumn', 5, 5, 6, A_beam, E, G, J, Iy_beam, Iz_beam, 2) ops.element('elasticBeamColumn', 6, 6, 7, A_beam, E, G, J, Iy_beam, Iz_beam, 2) ops.element('elasticBeamColumn', 7, 7, 8, A_beam, E, G, J, Iy_beam, Iz_beam, 2) ops.element('elasticBeamColumn', 8, 5, 8, A_beam, E, G, J, Iy_beam, Iz_beam, 2) Ejecutar Se vuelve a chequear que el modelo si este creando con el código: opsv.plot_model() Ejecutar 14 Se obtiene el pórtico conectado por las vigas mostrado en la figura 5. Figura 5 Modelado de las vigas del segundo nivel. Fuente: elaboración propia. 16. Aplicación de restricciones (empotrar nodos iniciales de las columnas 1 al 4) Abrir nueva línea de código: Insertar: ops.fix(1, 1, 1, 1, 1, 1) ops.fix(2, 1, 1, 1, 1, 1) ops.fix(3, 1, 1, 1, 1, 1) ops.fix(4, 1, 1, 1, 1, 1) opsv.plot_model() Ejecutar Se obtiene la restricción de los nodos 1, 2, 3 y 4 mostrados en la figura 6. Figura 6 Restricción de los nodos iniciales (1,2,3,4) de las columnas. Fuente: elaboración propia. 15 17. Abrir nuevo código para visualizar la geometría extruida (3D) : Abrir nueva línea de código: Insertar: ele_shapes = { 1: ['rect', [a, a]], 2: ['rect', [a, a]], 3: ['rect', [a, a]], 4: ['rect', [a, a]], 5: ['rect', [h, b]], 6: ['rect', [h, b]], 7: ['rect', [h, b]], 8: ['rect', [h, b]], } Para verificar que se está modelando se introduce el siguiente código: opsv.plot_extruded_shapes_3d(ele_shapes) Ejecutar Se obtiene el modelo de forma extruida mostrado en la figura 7. Figura 7 Geometría del pórtico en 3D. Fuente: elaboración propia. 18. Para la creación de cargas se utiliza: Abrir nueva línea de código: Insertar: # Cargas ops.timeSeries('Linear', 1) ops.pattern('Plain', 1, 1) Ejecutar 19. Ingresar un nuevo código para una carga distribuida de 1.2 Kn/m, aplicada en las vigas, en los nodos 5, 6, 7 y 8. 16 # q = 1.2 kN/m (en dirección -Y) ops.eleLoad('-ele', 5, '-type', '-beamUniform', 0.0, -1.2, 0.0) ops.eleLoad('-ele', 6, '-type', '-beamUniform', 0.0, -1.2, 0.0) ops.eleLoad('-ele', 7, '-type', '-beamUniform', 0.0, -1.2, 0.0) ops.eleLoad('-ele', 8, '-type', '-beamUniform', 0.0, -1.2, 0.0) Ejecutar Se ingresa ahora una carga puntual de 10Kn, en los nodos 5 y 6: ops.load(5,0,10,0,0,0,0) ops.load(6,0,10,0,0,0,0) Ejecutar 20. Se realiza ahora la configuración del análisis del modelo, por ejemplo, si es dinámico, modal, estático etc. Para este caso se utiliza: análisis estático, mediante el siguiente código, insertar: #Analissys ops.system('BandGeneral') ops.constraints('Plain') ops.numberer('RCM') ops.test('NormDispIncr', 1e-6, 10) ops.algorithm('Newton') ops.integrator('LoadControl', 1) ops.analysis('Static') ops.analyze(1) Ejecutar 21. Ahora se grafica la deformada que va a tener el modelo, indicando la escala 1e4, introducir el siguiente código: opsv.plot_defo(1e4) Ejecutar Se obtiene la deformada del modelo mostrada en la figura 8. 17 Figura 8 Deformación del pórtico según el análisis. Fuente: elaboración propia. 22. Para ver los resultados de las fuerzas internas de acuerdo con el análisis estipulado: Abrir nueva línea de código: Insertar: #Fzas Internas import opsvis as opsv Ejecutar 23. Abrir nuevo código: #Fzas Internas opsv.section_force_diagram_3d(sf_type='N', sfac = 1e-1) Ejecutar Se obtiene el diagrama de fuerzas internas mostrado en la figura 9. Figura 9 Diagrama de las fuerzas internas en los elementos. Fuente: elaboración propia. 18 24. Calcular la cortante (Vz), abrir nuevo código: #Cortante opsv.section_force_diagram_3d(sf_type='Vz', sfac = 1e-1) Ejecutar Se obtiene el diagrama de cortantes mostrado en la figura 10. Figura 10 Diagramas de cortante de los elementos. Fuente: elaboración propia. 25. Calcular el diagrama de momentos flectores (My) para las vigas, abrir nuevo código: # Momentos Flectores de la viga opsv.section_force_diagram_3d(sf_type='My', sfac = 1e-1) Ejecutar Se obtiene el diagrama de momentos flectores mostrado en la figura 11. Figura 11 Momentos flectores en los elementos. Fuente: elaboración propia. 19 26. Ver los modelos creados en 3D Se debe crear un nuevo archivo (bloc de Colab) con extensión .PY, luego copiar todo el código del análisis anterior y pegarlo, adicionalmente al final del código debe ingresar este nuevo código: opsv.plot_extruded_shapes_3d(ele_shapes) plt.show() Ejecutar Se genera una nueva grafica en 3D, mostrada en la figura 12, que puede descargase al PC y luego abrirse como archivo .PY (Phyton) para su manipulación. Figura 12 Pórtico modelado en 3D. Fuente: elaboración propia. 27. Análisis Modal: se realiza para determinar sus frecuencias naturales, formas de modo y parámetros de amortiguación, lo que permite entender y predecir su respuesta dinámica ante cargas como el viento, sismos o vibraciones, optimizando el diseño para que sea más segura, resistente y funcione correctamente frente a las vibraciones y resonancias. Ingresar nuevo código: #Analisis Modal ratio = 1000 #peso (kg/m2) Peso_s = ratio*L*B #peso sísmico Masa_nodal = Peso_s/4*9.81/1000 #peso sísmico por cada nivel (4 nodos) #Kn-s2/m ops.mass(5, Masa_nodal, Masa_nodal,0,0,0,0) #masa nodo 5 ops.mass(6, Masa_nodal, Masa_nodal,0,0,0,0) #masa nodo 6 ops.mass(7, Masa_nodal, Masa_nodal,0,0,0,0) #masa nodo 7 ops.mass(8, Masa_nodal, Masa_nodal,0,0,0,0) #masa nodo 8 Ejecutar 20 28. Se realiza ahora la configuración del análisis modal. Ingresar nuevo código: #Analisis Modal ops.wipeAnalysis() # limpia el análisis anterior ops.numberer(‘RCM’) # manera en que se enumeran los nodos ops.constraints(‘Transformation’) #restricciones especiales ops.test(‘NormDispIncr’ , 1e-12, 10) #evaluador de convergencia ops.algorithm(‘Newton’) #algoritmo para encontrar la solución Ejecutar Determinar la cantidad de modos de vibración a considerar, para este caso se utilizan 3 modos por piso. Ingresar nuevo código: Nmodos = 3 w_i = np.sqrt(ops.eigen(Nmodos)) #Método de valores propios T_i = 2 * np.pi / w_i #Cálculo del periodo (2π/w) print(w_i) print(T_i) Ejecutar Se obtienen los resultados de w_i y T_i= [13.66145785 15.22687931 22.02019276] [0.45992056 0.41263776 0.28533743] 29. Gráficas de los modos: Insertar nuevo código: for i in range(1, Nmodos + 1): opsv.plot_mode_shape(i, endDispFlag=0, fig_wi_he=(18, 18), node_supports=False) plt.title(f'Modo {i}\n T1: {T_i[i-1]:.4f} s', fontweight='bold') plt.show() Ejecutar Se obtienen las gráficas de los 3 modos (traslacional en x, traslacional en Y, y un tercer modo rotacional), mostrados en las figuras 13, 14 y 15. 21 Figura 13 Modo de vibración en X. Fuente: elaboración propia. Figura 14 Modo de vibración en Y. Fuente: elaboración propia. 22 Figura 15 Modo de vibración Rotacional. Fuente: elaboración propia. 30. Ahora se halla el amortiguamiento dinámico para el análisis tiempo-historia Abrir nuevo código: #Analisis tiempo historia lineal #Amortiguamiento ζ = 0.05 w1, w2 = w_1[0], w_1[1] #frecuencia de los dos primeros modos aM = 0 aK = 0 akimit = 0 akcom = 2*ζ/(w1+w2) ops.rayleigh(aM, aK, aKimit, akcom Ejecutar Se busca ahora online, un registro sísmico, en este caso se ingresó al sitio web de El Centro Peruano-Japonés de Investigaciones Sísmicas y Mitigación de Desastres, aquí se registran los acelerómetros de los diferentes sismos que han ocurrido en el Perú. Para este trabajo se utiliza un acelerómetro de un sismo ocurrido en la ciudad de Ica, registrado con la estación Universidad Nacional San Luis Gonzaga de Ica - UNICA (ICA002): 23 Figura 16 Registro de acelerogramas. Fuente: sitio web del Centro Peruano-Japonés de Investigaciones Sísmicas y Mitigación de Desastres. Para configurar el acelerograma en Colab, se utiliza el siguiente código: from google.colab import files uploaded = files.upload() Elegir el archive .txt guardado en el PC, para este caso es ICA002_20070815184058.txt Saving ICA002_20070815184058.txt to ICA002_20070815184058.txt Ejecutar import numpy as np data = np.loadtxt('ICA002_20070815184058.txt', skiprows=1) tiempo = data[:, 0] acc_x = data[:, 1] dt = 0.01 Ejecutar ops.timeSeries('Path',3,'-dt',dt,'-values', *acc_x,'-factor', factor) ops.pattern(ÚniformExcitation,2,1, '-accel', 2) Ejecutar 31. Configuración del análisis dinámico. Ingresar el siguiente código: # Configuración del Análisis Dinámico ops.system('BandGeneral') ops.constraints('Plain') ops.numberer('RCM') 24 ops.test('NormDispIncr', 1e-8, 10) ops.algorithm('Newton') ops.integrator('Newmark', 0.5,0.25) ops.analysis('Transient') Ejecutar #Ejecutar el Análisis paso a paso t = ops.getTime() Tfinal = len(acc_x)*dt ux = [] t_plot = [] while t < Tfinal: ops.analyze(1,dt) ux.append(ops.nodeDisp(7,1)) t_plot.append(t) t = ops.getTime() 32. El siguiente paso es el ingreso del código para obtener los resultados de manera gráfica: plt.figure(figsize=(10, 4)) plt.plot(tiempo, acc_x, label='Aceleración') plt.xlim(0) plt.grid() plt.title('Aceleración del registro') plt.xlabel('Aceleración (m/s²)') plt.show() Se obtiene la gráfica de aceleración del registro sísmico mostrada en la figura 17. Figura 17 Aceleración del sismo según el archivo suministrado. Fuente: elaboración propia. 25 33. El último paso es el ingreso del código para graficar tiempo Vs el desplazamiento del nodo 7, se ingresa entonces el siguiente código: plt.figure(figsize=(10, 4)) plt.plot(t_plot, ux, color = 'k', label='Aceleración') plt.xlim(0) plt.grid() plt.title('Respuesta del nodo 7') plt.xlabel('Aceleración (m/s²)') plt.show() Ejecutar Se obtiene la gráfica de la respuesta de la estructura del nodo 7 mostrada en la figura 18. Figura 18 Respuesta del nodo 7 al sismo. Fuente: elaboración propia. 26 Comprobación del diseño del pórtico mediante el software SAP2000 Se realiza el modelado del pórtico, con las mismas dimensiones de columnas y vigas, las mismas distancias entre ejes, las mismas propiedades de los elementos y las mismas cargas distribuidas y puntuales. Figura 19 pórticos modelados en SAP2000. Fuente: elaboración propia en SAP2000. Realizando el análisis del pórtico se obtienen los siguientes resultados: Figura 20 Deformada del pórtico. Fuente: elaboración propia en SAP2000. 27 Figura 21 Diagrama de fuerzas axiales. Fuente: elaboración propia en SAP2000. Figura 22 Diagrama de fuerza cortante 2-2. Fuente: elaboración propia en SAP2000. 28 Figura 23 Diagrama de momento 2-2. Fuente: elaboración propia en SAP2000. Figura 24 Diagrama de momento 3-3. Fuente: elaboración propia en SAP2000. 29 Se define ahora la función para la respuesta del espectro (sismo), para este caso en SAP2000 se utiliza el espectro Perú Norma E.030. Se utilizan los siguientes datos de load case para el espectro de respuesta: Figura 25 Datos imputados para el espectro de respuesta. Fuente: elaboración propia en SAP2000. 30 En los resultados para el load case del sismo de Perú analizados en SAP2000, se observan diferencias con el caso utilizado en OpenseesPy, debido a que el espectro utilizado en este es diferente al usado en SAP2000, sin embargo, son valores que sirven también para determinar que los modos 1, 2 y 3 tienen respuestas similares en cada uno de los casos analizados en este proyecto. Ahora se muestran las gráficas obtenidas del espectro en SAP2000. Figura 26 Deformada para el caso de carga Seismic Perú. Fuente: elaboración propia en SAP2000. Figura 27 Deformada del modo 1, periodo y frecuencia. Fuente: elaboración propia en SAP2000. 31 Figura 28 Deformada del modo 2, periodo y frecuencia. Fuente: elaboración propia en SAP2000. Figura 29 Deformada del modo 3, periodo y frecuencia. Fuente: elaboración propia en SAP2000. 32 Análisis de resultados y conclusiones El pórtico de un nivel analizado en este trabajo exhibe un comportamiento general estable bajo las cargas consideradas. La respuesta estática inicial confirma su estabilidad al mostrar desplazamientos casi nulos en los ejes Y y Z, a la vez que su primera frecuencia indica una rigidez muy alta para este tipo de estructura. En cuanto a las zonas críticas, se observa que los momentos máximos se concentran en la base de las columnas y en la unión viga-columna. Consecuentemente, estas áreas deben ser verificadas en detalle para el armado a flexión y cortante. Respecto al servicio y seguridad de la estructura, si la deriva máxima es menor que 1/200, el pórtico cumple con los requisitos de servicio, lo que implica una baja probabilidad de daños no estructurales. Si la deriva excede este valor, se recomienda tomar medidas como reducir las cargas laterales, aumentar la rigidez o, principalmente, mejorar el diseño de las columnas para asegurar la integridad. Desde la perspectiva dinámica, la frecuencia fundamental (f1) obtenida sitúa la estructura en la categoría de rigidez esperada para un pórtico pequeño. Por lo tanto, se concluye que la respuesta sísmica estará dominada principalmente por el primer modo. Finalmente, cabe destacar que el modelo desarrollado en OpenseesPy fue fundamental, ya que permitió visualizar y comprender el comportamiento estructural del pórtico de una forma sencilla. Este método en Python y Colab demuestra ser una herramienta extremadamente útil para automatizar análisis estructurales y, a su vez, proporciona una mejor comprensión sobre el efecto de las cargas y las propiedades de los materiales. 33 Recomendaciones Generales Para el modelado y organización del código debe tenerse en cuenta lo siguiente: Comenzar siempre limpiando el modelo con wipe() para evitar errores de modelos anteriores. Usar nombres de variables claros (CO_concreto, C_columna, V_viga) para que el código sea fácil de entender. Trabajar el código en bloques separados (materiales, nodos, elementos, cargas, análisis) para evitar confusiones. Agregar comentarios (mediante #) en cada parte para explicar qué estás haciendo; esto ahorra tiempo si después se modifica el modelo. Guardar copias del script (por ejemplo, Portico_v1, Portico_v2) a medida que se avanza en el modelo. También verificar que se está modelando mediante el code plot(). Definición del modelo estructural: Definir correctamente los grados de libertad (ndm, ndf) según si el modelo es 2D o 3D. Ejemplo: model('basic', '-ndm', 2, '-ndf', 3) → para pórticos planos. Verificar la conectividad: que los nodos de cada elemento estén bien asignados. Un error común es tener nodos sin conectar o mal numerados. Apoyos realistas: Para pórticos empotrados, usa fix(1, 1, 1, 1) en la base. Si se quiere simular articulaciones, se puede liberar el giro (fix(1,1,1,0)). Propiedades de materiales y secciones: Usar valores realistas del módulo de elasticidad (E) del concreto: entre 25–30 GPa (25e9–30e9 Pa), densidad del concreto: 2400–2500 kg/m³, calcular área (A) y momento de inercia (I) con las fórmulas geométricas básicas. Realizar siempre una verificación de los resultados del modelo diseñado con OpenseesPy y Colab, esta verificación puede hacerse con los softwares ya conocidos y trabajados mundialmente como SAP2000 y ETABS. 34 Referencias Bibliográficas Centro Peruano-Japonés de Investigaciones Sísmicas y Mitigación de Desastres. (s.f.). CISMID. https://www.cismid.uni.edu.pe/ Computers and Structures, Inc. (2024). ETABS (V22.0.0) [Software]. https://www.csiamerica.com/products/etabs Computers and Structures, Inc. (2024). SAP2000 (V26.0.0) [Software]. https://www.csiamerica.com/products/sap2000 Google. (2023). Gemini [Modelo de lenguaje]. https://gemini.google.com/ Maldonado, L. [Structural Tech]. (2025, mayo 28). Análisis estructural y dinámico con OpenSeesPy [Video]. YouTube. https://www.youtube.com/watch?v=uvLyCMow-h0 OpenAI. (2023). ChatGPT (versión GPT-4) [Modelo de lenguaje]. https://chat.openai.com/ OpenSeesPy. (2019–2024). The OpenSeesPy Library. https://openseespydoc.readthedocs.io/en/latest/ Picha Chani, G. M. (2021). Análisis y diseño de pórticos de concreto armado usando inteligencia artificial [Tesis para optar al título de Ingeniero Civil]. Universidad Nacional de San Agustín, Facultad de Ingeniería Civil, Escuela de Ingeniería Civil, Arequipa, Perú. Zapata Vélez, J. A., & Guayara Roldan, D. M. (2024). Revisión bibliográfica sobre la inteligencia artificial “IA” y su aporte a la ingeniería estructural: avances, aplicaciones y desafíos [Trabajo de grado de especialización]. Universidad de Antioquia, Medellín, Colombia. https://www.csiamerica.com/products/sap2000 https://gemini.google.com/ https://chat.openai.com/