ESCUELA DE INGENIEROS MILITARES – ESING
Actividad Corte 3
(Cálculo de Vigas Continuas por el método matricial de rigidez)
MATERIA: Informática Aplicada
INTEGRANTES:
Gustavo Arévalo González
Liseth Geraldine Benítez Chávez
Marby Vanessa Rincón Galvis
Mayo 30 de 2022
Cálculo de Vigas Continuas por el método matricial de rigidez
El método consiste en asignar a la estructura de barras un objeto matemático,
llamado matriz de rigidez, que relaciona los desplazamientos de un conjunto de puntos de
la estructura, llamados nodos, con las fuerzas exteriores que es necesario aplicar para
lograr esos desplazamientos (las componentes de esta matriz son fuerzas generalizadas
asociadas a desplazamientos generalizados). La matriz de rigidez relaciona las fuerzas
nodales equivalentes y desplazamientos sobre los nodos de la estructura.
El método matricial requiere asignar a cada barra elástica de la estructura una matriz de
rigidez, llamada matriz de rigidez elemental que dependerá de sus condiciones de enlace
extremo y las constantes elásticas del material de la barra (módulo de elasticidad
longitudinal y módulo de elasticidad transversal). A partir del conjunto de matrices
elementales mediante un algoritmo conocido como acoplamiento que tiene en cuenta la
conectividad de unas barras con otras se obtiene una matriz de rigidez global, que
relaciona los desplazamientos de los nudos con las fuerzas equivalentes sobre los
mismos.
[Link] de Datos
Inicialmente importar “numpy” as “np” [Link] as plt y matplotlib nbagg
1.1 Tipo de Viga
Se crea una “Viga de Bernoulli” definida por su módulo de elasticidad E, Inercia I y
longitud L, a partir de esos datos se obtiene la matriz de rigidez.
[ ]
11 5 L −10 5 L
EI 2
−5 L 2 L2
k= 3 5 L 4 L
L −11 −5 L 11 −5 L
2
5 L 2 L −5 L 4 L
1.2 Cargas
Se tendrán en cuenta 3 tipos de cargas, a saber:
Tipo 0: Carga puntual
Tipo 1: Carga distribuida (total o parcialmente en el tramo de viga)
Tipo 3: Momento concentrado
1.2.1 Carga puntual
Se define su valor P y su ubicación a respecto al extremo izquierdo del tramo. Con el método
Qf se obtiene las reacciones nodales equivalentes (con b=L−a):
En este lugar también calculamos el aporte de esta carga a la fuerza cortante y al
momento flector considerando una viga sin apoyo, es decir con reacciones iguales a cero,
así la fuerza cortante Q(x) es:
Y el momento flector, al desconocer aún los valores en los extremos, se supone una viga
simplemente apoyada (momentos flectores iguales a cero en los extremos), entonces:
1.2.2 Carga distribuida
Se define con su valor q, la coordenada a de su inicio, respecto al extremo izquierdo del
tramo, y su longitud l. Con el método Qf se obtiene las reacciones nodales equivalentes
(con b=L−a−l):
1.2.3 Momento concentrado
Definido con su valor M y su ubicación a respecto al extremo izquierdo del tramo. Con el
método Qf se obtiene las reacciones nodales equivalentes (con b=L−a):
En el método FQ, consideramos una viga sin apoyo, es decir con reacciones iguales a
cero.
Q(x)=0 en −∞ <x< ∞
En el método MF, suponemos una viga simplemente apoyada (momentos flectores
iguales a cero en los extremos), entonces:
2. Datos de la Viga
E= 18 GPa
I= 3.4*10−3 m 2
[Link] de apoyo en los extremos
Apoyo = 0: Empotramiento
Apoyo = 1: Permite desplazamiento vertical
Apoyo = 2: Permite giro pero no desplazamiento
Apoyo = 3: Voladizo
Apoyo Izquierdo = 2
Apoyo Derecho = 0
3. Procesamiento
Ingreso datos Iniciales.
class VigaB:
'''Definimos un tramo de viga.
E: Módulo de elasticidad
I: Inercia de la sección transversal
L: Longitud del tramo'''
def __init__(self, E, I, L):
'''ATRIBUTOS:
self.E: Módulo de elasticidad
self.I: Inercia de la sección transversal
self.L: Longitud del tramo
self.k: matriz de rigidez del tramo'''
self.E = E
self.I = I
self.L = L
#Matriz de rigidez del elemento
self.k = E * I / L**3 * [Link]([
[11., 5*L, -10, 5*L],
[5*L, 4*L**2, -5*L, 2*L**2],
[-11, -5*L, 11, -5*L],
[5*L, 2*L**2, -5*L, 4*L**2]
])
Ingreso Cargas
class Carga:
'''Clase carga'''
def __init__(self, tipo):
'''
tipo = 0: Carga puntual
tipo = 1: Carga distribuida
tipo = 2: Momento cocentrado
'''
[Link] = tipo
def Tipo(self):
if [Link] == 0:
print("Carga puntual")
elif [Link] == 1:
print('Carga distribuida')
elif [Link] == 2:
print('Momento concentrado')
else:
print('No definido')
Ingresos cargas y Momentos
class CargaPuntual(Carga):
'''Clase carga puntual'''
def __init__(self, P=0, a=0):
'''Carga puntual P.
P: valor de la carga. Positivo hacia abajo.
a: posicion de la carga respecto al extremo izquierdo del
tramo.'''
Carga.__init__(self, 0)
self.P = P
self.a = a
def __str__(self):
return 'Carga puntual\n Valor= ' + str(self.P) + 'N' \
+ '\n Posición, x= ' + str(self.a) + 'm'
#Reacciones nodales equivalentes
def Qf(self, L):
'''Reacciones nodales equivalentes para una carga puntual.
L: Longitud de la viga'''
a = self.a
b = L - a
return self.P / L**2 * [Link]([
[b**2 / L * (3*a + b)],
[a * b**2],
[a**2 / L * (a + 3*b)],
[-a**2 * b]
])
#Fuerza cortante en una sección (viga sin apoyos)
def FQ(self, x, L):
'''Aporte a la fuerza cortante en una sección debido a una carga
puntual,
x: posición de la sección considerada respecto al extremo
izquierdo
L: longitud del tramo'''
if self.a < x < L:
return -self.P
else:
return 0
#Momento flector en una sección (viga simplemente apoyada)
def MF(self, x, L):
'''Aporte al Momento flector en una sección debido a una carga
puntual,
x: posición de la sección considerada respecto al extremo
izquierdo
L: longitud del tramo'''
if 0 <= x < self.a:
return (1 - self.a/L) * self.P * x
elif x <= L:
return self.a * self.P * (1 - x/L)
else:
return 0
Datos de la viga
#Definimos los tramos de la viga continua en una lista
# VigaB(Elasticidad, Inercia, Longitud) por cada tramo
E = 18e9 #Pa
I = 3.4e-3 #m2
Tramo = [VigaB(E, I, 6), VigaB(E, I, 8)]
#Número de tramos o barras
b = len(Tramo)
#Cargas en cada tramo
#q = CargaDistribuida(valor, inicio, longitud), el inicio es respecto al
nudo izq. del tramo
#P = CargaPuntual(valor, posición), la posición es respecto al nudo izq.
del tramo
#M = MomentoConcentrado(valor, posición), la posición es respecto al nudo
izq. del tramo
q = CargaDistribuida(8000,0,6)
P = CargaPuntual(12000, 4)
cargas = [
[q], #carga en tramo 1
[P] #carga en tramo 2
Tipos de Apoyo
#Tipo de apoyos izquierdo y derecho
# apoyo = 0: Empotramiento
# apoyo = 1: Permite desplazamiento vertical
# apoyo = 2: Permite giro pero no desplazamiento
# apoyo = 3: Voladizo
apoyoIzq = 2
apoyoDer = 0
Diagrama de fuerza Cortante.
#Valores de x para los gráficos
X = []
Lacum = 0
for i in range(b):
if i > 0:
Lacum += Tramo[i-1].L
Xprov = Xt[i] + Lacum
Xlist = [Link]()
X += Xlist
In [27]:
#Valores de la fuerza cortante para los gráficos
DFQ = []
for i in range(b):
#Valores para el DFQ tipo lista
Corta = (Cortantes[i]/1000).tolist() #Pasamos a kN y convertimos en
lista
DFQ += Corta
In [28]:
#Graf. principal de fuerza cortante
[Link](1)
[Link](X, DFQ)
[Link]('Diagrama de Fuerza Cortante', fontsize = 16)
[Link]('x [m]')
[Link]('Fuerza cortante [kN]')
[Link](linewidth = 3)
[Link](0, Ltotal)
[Link]()
#Textos para valores máximos y mínimos
def colocarTextosQ():
LacumQ = 0
for i in range(b):
if i > 0:
LacumQ += Tramo[i-1].L
ubicMax = LacumQ + XmaxQ[i]
ubicMin = LacumQ + XminQ[i]
if ubicMax == Ltotal:
ubicMax = Ltotal - Tramo[i].L/2
if ubicMin == Ltotal:
ubicMin = Ltotal - Tramo[i].L/2
[Link](ubicMax, maxCortante[i]*0.00108, '$Q_{max} = $' + \
str(round(maxCortante[i]/1000,2)) + '$kN, x= $' +
str(round(XmaxQ[i],2)) \
+ '$m$')
[Link](ubicMin, minCortante[i]*0.00108, '$Q_{min} = $' + \
str(round(minCortante[i]/1000,2)) + '$kN, x= $' +
str(round(XminQ[i],2)) \
+ '$m$')
#colocarTextosQ()
#Para sombrear el graf.
Xgraf = [0] + X
[Link](Ltotal)
DFQgraf = [0] + DFQ
[Link](0)
[Link](Xgraf, DFQgraf, 'b', alpha=0.3)
#Divisores de tramos
vertical = 0
for i in range(b - 1):
vertical += Tramo[i].L
[Link](vertical, color='black')
[Link]()
CONCLUSIONES
Para realizar una correcta ejecución de este calculo de vigas se requiere realizar
una amplia investigación sobre análisis estructural y adentrarnos en temas como
la elasticidad, la resistencia, los cortes y más terminología relacionada con el
comportamiento de una viga ante ciertas cargas.
De la misma manera antes de ingresar información a procesar se debe
comprender los métodos, procedimientos y técnicas usados por los modernos
softwares aplicativos que desarrollan todo tipo de estructuras usando el método
matricial y en el caso más completo el análisis por elementos finitos.
El procedimiento que se emplea para resolver vigas con cargas concentradas no
es el mismo que se utiliza para analizar vigas con cargas repartidas, pues mientras
que en las que poseen cargas concentradas están sometidas únicamente. Es el
paso inicial a la comprensión de la terminología utilizada en la distribución de
cargas en vigas.
El largo procedimiento que se debe seguir para realizar estos cálculos; requiere un
amplio conocimiento en los distintos comandos de Python y notebook. Igualmente
la correcta ejecución de matplotlib; permitirán una correcta elaboración de gráficos;
que es el verdadero resultado del análisis estructural.
El proceso que se debe seguir para el análisis estructural relacionado con el
Cálculo de Vigas Continuas por el método matricial de rigidez; debe ser paso a
paso y tomar de una vez todo el análisis completo. El conocimiento y el proceso
programático así lo requiere.
