Python en Ingeniería Civil

4. Geometría de masas

Para introducir el conceto de Geometría de las Masa dejamos una  Presentación ppt

También hay un video Explicativo sobre el uso del Código


Ver Presentación

Ver Video


Solución:

from cmath import pi
import math
 
def menu():
    opcion = input("\nMenu:\na) Cargar Datos.\nb) Area del conjunto.\nc) Posicion del baricentro de la seccion.\nd) Momentos de segundo orden (Jx-Jy-Jxy).\ne) Momentos principales de inercia (Jmax-Jmin).\nS o s) Salir.\n...")
    return (opcion.lower()) ##Para que retorne todo en minuscula
 
def A_Cj(dt): #dt = datos *A_Cj = Areas del conjunto
    d_g = {}
    Ar = (dt[1][0])*(dt[1][1])
    At = (((dt[2][0])*(dt[2][1]))/2)
    Ac = (-1*(dt[4][0])*(dt[4][1])) #-1 porque es un hueco
    As = round(((math.pi)*((dt[3][0])**2)/2),3)
    Atotal = (round((Ar + At + Ac + As),2))
    d_g[1] = [Ar] #1 = Rectangulo
    d_g[2] = [At] #2 = Triangulo
    d_g[3] = [As] #3 = Semicirculo
    d_g[4] = [Ac] #4 = Cuadrado7
    d_g[5] = [Atotal] #5 = Area total
 
    return d_g
 
def Pos_b_sec(d_calc,dt): #Posicion del baricentro de la seccion
    ##Rectangulo
    Xgr = (round((dt[1][0]/2),3)*(d_calc[1][0]))/(d_calc[5][0])
    Ygr = (round(((dt[1][1]/2)+(dt[2][1])),3)*(d_calc[1][0]))/(d_calc[5][0])
    d_calc[1].append([Xgr,Ygr])
    ##Triangulo
    Xgt = (round((dt[2][0]*(2/3)),3)*(d_calc[2][0]))/(d_calc[5][0])
    Ygt = (((dt[2][1]*(2/3)))*(d_calc[2][0]))/(d_calc[5][0])
    d_calc[2].append([Xgt,Ygt])
    ##Semicirculo
    Xgs = (round((((4/3)*(dt[3][0]))/math.pi)+(dt[2][0]),3)*(d_calc[3][0]))/(d_calc[5][0])
    Ygs = (((dt[3][0]) + (dt[2][1]))*(d_calc[3][0]))/(d_calc[5][0])
    d_calc[3].append([Xgs,Ygs])
    ##Cuadrado
    Xgc = (round((dt[1][0]/2),3)*(d_calc[4][0]))/(d_calc[5][0])
    Ygc = (((dt[2][1])+3.50)*(d_calc[4][0]))/(d_calc[5][0])
    d_calc[4].append([Xgc,Ygc])  
    ##Posicion del baricentro de la seccion
    XG = Xgr+Xgt+Xgs+Xgc
    YG = Ygr+Ygt+Ygs+Ygc
    d_calc[5].append([XG,YG])  
    print("Posicion del baricentro de la seccion".center(100))
    print("XG = {}".format(XG))
    print("YG = {}".format(YG))
 
    return True
 
def m_s_o_p(datos, result): #Momentos de segundo orden propios
    form = [[1/12,1/36,1/128,-1/12],[1/12,1/36,1/145.77,-1/12],[0,-1/72,0,0]]
    for i in range(3): #1v = Jx, 2v = Jy, 3v Jxy
        for e in range(4):
            if (i==0):
                if (e==2):
                    jx = ((math.pi)*((2*(datos[e+1][0]))**4))*form[i][e]
                    result[e+1] = [jx]
                else:
                    jx = (datos[e+1][0]*((datos[e+1][1])**3))*form[i][e]
                    result[e+1] = [jx]
            elif (i==1):
                if (e==2):
                    jy = ((2*(datos[e+1][0]))**4)*form[i][e]
                    result[e+1].append(jy)
                else:
                    jy = (datos[e+1][1]*((datos[e+1][0])**3))*form[i][e]
                    result[e+1].append(jy)
            else:
                if (e==1):
                    jxy = (((datos[e+1][0])**2)*((datos[e+1][1])**2))*form[i][e]
                    result[e+1].append(jxy)
                else:
                    result[e+1].append(0.0)
 
def dbp(calc,dt,result): #Distancia entre ejes baricentricos paralelos
    XGr = (dt[1][0]/2)-((calc[5][1])[0])
    YGr = (dt[1][1]/2)+(dt[2][1])-((calc[5][1])[1])
    result[1].append(XGr)
    result[1].append(YGr)
 
    XGt = (dt[2][0]*(2/3))-((calc[5][1])[0])
    YGt = (dt[2][1]*(2/3))-((calc[5][1])[1])
    result[2].append(XGt)
    result[2].append(YGt)
 
    XGs = ((((4/3)*(dt[3][0]))/math.pi)+(dt[2][0]))-((calc[5][1])[0])
    YGs = ((dt[3][0]) + (dt[2][1]))-((calc[5][1])[1])
    result[3].append(XGs)
    result[3].append(YGs)
 
    XGc = (dt[1][0]/2)-((calc[5][1])[0])
    YGc = ((dt[2][1])+3.50)-((calc[5][1])[1])
    result[4].append(XGc)
    result[4].append(YGc)
 
 
def m_s_o(calc, datos): #momentos de segundo orden
    m_s_o_p_r = {} #momentos de segundo orden propios
    d_b_p = {1:[],2:[],3:[],4:[]} #Distancia entre ejes baricentricos pararelos
    m_s_o_b = {1:[],2:[],3:[],4:[],5:[]}
    m_s_o_p(datos,m_s_o_p_r)
    dbp(calc,datos,d_b_p)
    Jxt = 0
    Jyt = 0
    Jxyt = 0
    for i in range(4):
        jx = (m_s_o_p_r[i+1][0])+((calc[i+1][0])*((d_b_p[i+1][1])**2))
        Jxt+=jx
        m_s_o_b[i+1].append(jx)
        jy = (m_s_o_p_r[i+1][1])+((calc[i+1][0])*((d_b_p[i+1][0])**2))
        Jyt+=jy
        m_s_o_b[i+1].append(jy)
        jxy = (m_s_o_p_r[i+1][2])+((calc[i+1][0])*(d_b_p[i+1][0])*(d_b_p[i+1][1]))
        Jxyt+=jxy
        m_s_o_b[i+1].append(jxy)
     
    m_s_o_b[5].append(Jxt)
    m_s_o_b[5].append(Jyt)
    m_s_o_b[5].append(Jxyt)
    return m_s_o_b     
 
def Jm(m_b_p): #Momentos principales de inercia
    Jxym = math.sqrt(((((m_b_p[5][0])-(m_b_p[5][1]))/2)**2)+((m_b_p[5][2])**2))
    Jmax = (((m_b_p[5][0])+(m_b_p[5][1]))/2)+Jxym
    Jmin = (((m_b_p[5][0])+(m_b_p[5][1]))/2)-Jxym
    Alfa = (0.5*(math.atan(((2*m_b_p[5][2])/(m_b_p[5][1])-(m_b_p[5][0])))))
 
    print("Momentos principales de inercia".center(100))
    print("* Jxymax = {}".format(Jxym))
    print("* Jmax = {}".format(Jmax))
    print("* Jmin = {}".format(Jmin))
    print("* α = {}".format(Alfa))
 
def main():
    b1  = True
    ba, bb, bc, bd= False, False, False, False
    while (b1):
        op = menu()  
        if op=='a':
            print("\nIngrese los datos requeridos\n")
            Datos={1: [],2:[],3:[],4:[],5:[]} ##Datos Geometricos
            nombres=["Rectangulo","Triangulo","Semicirculo","Cuadrado","Total"] ##Datos Geometricos
            for i in Datos:
                b_d = True #Bandera de datos
                while(b_d):
                    try:
                        if (i==1 or i==2 or i==4):
                            base = float(input("* Base del {}: ".format(nombres[i-1])))
                            if (base>0):
                                Datos[i].append(base)
                                altura = float(input("* Altura del {}: ".format(nombres[i-1])))
                                if (altura>0):
                                    Datos[i].append(altura)
                                    b_d = False
                                else:
                                    print("\n¡ERROR! Reingrese...\n")
                            else:
                                print("\n¡ERROR! Reingrese...\n")
                        elif (i==3):
                            radio = float(input("* Radio del {}: ".format(nombres[i-1])))
                            if (radio>0):
                                Datos[i].append(radio)
                                b_d=False
                            else:
                                print("\n¡ERROR! Reingrese...\n")
                        else:
                            b_d = False
                    except ValueError:
                        print("\n¡ERROR! Reingresar...\n")
                print("\n")
            print("DATOS INGRESADOS EXITOSAMENTE".center(100))
            for i in Datos:
                print("* {}---->{}".format(nombres[i-1],Datos[i]))
            ba = True
        elif op=='b':
            if (ba==True):
              Calc_g = A_Cj(Datos)
              print("AREAS".center(100))
              for i in Calc_g:
                  print("* {} ----> {}".format(i,Calc_g[i]))  
              bb = True
            else:
                print("\n¡NO SE CARGARON LOS DATOS!\n")
        elif op=='c':
            if (ba==True and bb==True):
                bc=Pos_b_sec(Calc_g,Datos)
            else:
                print("\n¡ACCESO DENEGADO!")
        elif op=='d':
            if (ba==True and bb==True and bc==True):
                m_b = m_s_o(Calc_g,Datos) #Momentos baricentro
                bd = True
                print("Momentos de segundo orden".center(100))
                for i in range(1,6):
                    print("\n{}".format(nombres[i-1]))
                    print("Jx = {}".format(m_b[i][0]))
                    print("Jy = {}".format(m_b[i][1]))
                    print("Jxy = {}".format(m_b[i][2]))
                     
            else:
                print("\n¡ACCESO DENEGADO!")
        elif op=='e':
            if (ba==True and bb==True and bc==True and bd==True):
                 Jm(m_b)
            else:
                print("\n¡ACCESO DENEGADO!")
        elif op=='s':
            print("\n¡FINALIZANDO PROGRAMA!\n")
            b1=False
        else:
            print("\n¡OPCION NO VALIDA!\n")
             
 
main()