Você está aqui: Python ::: Python para Engenharia ::: Engenharia Civil - Cálculo Estrutural

Como calcular o Momento Fletor Mínimo e a Excentricidade Mínima de 1ª Ordem de um pilar em Python - Python para Engenharia Civil e Cálculo Estrutural

Quantidade de visualizações: 252 vezes


O cálculo e dimensionamento de pilares, sejam pilares de canto, extremidade ou intermediários, sempre seguem alguns passos cujas ordens são muito importantes, pois os dados de entrada de um passo podem vir de um ou mais passos anteriores.

Em dicas anteriores do uso da linguagem Python no cálculo de pilares eu mostrei como calcular os esforços solicitantes majorados em pilares e também como calcular o índice de esbeltez de um pilar nas direções x e y.

Nesta dica mostrarei como calcular o Momento Fletor Mínimo e a Excentricidade Mínima de 1ª Ordem de um pilar. Estes dados são muito importantes para a aplicação das fórmulas que embasam a área de aço a ser usada no pilar. Note que a Excentricidade Mínima de 1ª Ordem pode ser desprezada no caso de pilares intermediários (também chamados pilares de centro).

O Momento Fletor Mínimo é o momento mínimo que deve ser considerado, mesmo em pilares nos quais a carga está centrada, e é calculado por meio da seguinte fórmula:

\[M_\text{1d,min} = Nd \cdot (1,5 + (0,03 \cdot h) \]

Onde:

M1d,min é o momento fletor mínimo na direção x ou y em kN.cm.

Nd são os esforços solicitantes majorados em kN.

h é a dimensão do pilar na direção considerada (x ou y) em cm.

A Excentricidade Mínima de 1ª Ordem do pilar pode ser calculada por meio da fórmula:

\[e_\text{1,min} = \frac{M_\text{1d,min}}{Nd} \]

Onde:

e1,min é excentricidade mínima de 1ª ordem na direção escolhida.

Nd são os esforços solicitantes majorados em kN.

Note que, a exemplo do momento fletor mínimo, a excentricidade mínima de 1ª ordem também deve ser calculada nas direções x e y do pilar.

Vamos ao código Python agora? Veja que o código pede para o usuário informar as dimensões do pilar nas direções x e y em centímetros, a carga total que chega ao pilar em kN e mostra o momento fletor mínimo e a excentricidade mínima de 1ª ordem no pilar, tanto na direção x quanto na direção y:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

# método principal
def main():
  # vamos pedir as dimensões do pilar
  hx = float(input("Informe a dimensão do pilar na direção x (em cm): "))
  hy = float(input("Informe a dimensão do pilar na direção y (em cm): "))

  # vamos pedir a carga total no pilar em kN
  Nk = float(input("Informe a carga total no pilar (em kN): "))

  # vamos obter o menor lado do pilar (menor dimensão da seção transversal)
  if (hx < hy):
    b = hx
  else:
    b = hy
   
  # agora vamos calcular a área do pilar em centímetros quadrados
  area = hx * hy
 
  # a área está de acordo com a norma NBR 6118 (ABNT, 2014)
  if (area < 360):
    print("A área do pilar não pode ser inferior a 360cm2")
    return

  # vamos calcular a força normal de projeto Nd
  yn = 1.95 - (0.05 * b) # de acordo com a norma NBR 6118 (ABNT, 2014) Tabela 13.1
  yf = 1.4 # regra geral para concreto armado
  Nd = yn * yf * Nk

  # e agora vamos calcular o momento fletor mínimo na direção x do pilar
  M1d_min_x = Nd * (1.5 + (0.03 * hx))

  # e agora vamos calcular o momento fletor mínimo na direção y do pilar
  M1d_min_y = Nd * (1.5 + (0.03 * hy))

  # agora vamos calcular a excentricidade mínima de 1ª ordem na direção x do pilar
  e1x_min = M1d_min_x / Nd

  # e finalmente a excentricidade mínima de 1ª ordem na direção y do pilar
  e1y_min = M1d_min_y / Nd

  # e mostramos os resultados
  print("\nO momento fletor mínimo na direção x é: {0} kN.cm".format(
    round(M1d_min_x, 2)))
  print("O momento fletor mínimo na direção y é: {0} kN.cm".format(
    round(M1d_min_y, 2)))
  print("A excentricidade mínima de 1ª ordem na direção x é: {0} cm".format(
    round(e1x_min, 2)))
  print("A excentricidade mínima de 1ª ordem na direção y é: {0} cm".format(
    round(e1y_min, 2)))

if __name__== "__main__":
  main()

Ao executar este código Python nós teremos o seguinte resultado:

Informe a dimensão do pilar na direção x (em cm): 40
Informe a dimensão do pilar na direção y (em cm): 19
Informe a carga total no pilar (em kN): 841.35

O momento fletor mínimo na direção x é: 3180.3 kN.cm
O momento fletor mínimo na direção y é: 2438.23 kN.cm
A excentricidade mínima de 1ª ordem na direção x é: 2.7 cm
A excentricidade mínima de 1ª ordem na direção y é: 2.07 cm

Link para compartilhar na Internet ou com seus amigos:

Python ::: Dicas & Truques ::: Geometria, Trigonometria e Figuras Geométricas

Como calcular o coeficiente angular de uma reta em Python dados dois pontos no plano cartesiano

Quantidade de visualizações: 3080 vezes
O Coeficiente Angular de uma reta é a variação, na vertical, ou seja, no eixo y, pela variação horizontal, no eixo x. Sim, isso mesmo. O coeficiente angular de uma reta tem tudo a ver com a derivada, que nada mais é que a taxa de variação de y em relação a x.

Vamos começar analisando o seguinte gráfico, no qual temos dois pontos distintos no plano cartesiano:



Veja que o segmento de reta AB passa pelos pontos A (x=3, y=6) e B (x=9, y=10). Dessa forma, a fórmula para obtenção do coeficiente angular m dessa reta é:

\[\ \text{m} = \frac{y_2 - y_1}{x_2 - x_1} = \frac{\Delta y}{\Delta x} = tg \theta \]

Note que __$\Delta y__$ e __$\Delta x__$ são as variações dos valores no eixo das abscissas e no eixo das ordenadas. No triângulo retângulo que desenhei acima, a variação __$\Delta y__$ se refere ao comprimento do cateto oposto e a variação __$\Delta y__$ se refere ao comprimento do cateto adjascente.

Veja agora o trecho de código na linguagem Python que solicita as coordenadas x e y dos dois pontos, efetua o cálculo e mostra o coeficiente angular m da reta que passa pelos dois pontos:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

# vamos importar o módulo Math
import math as math

def main():
  # x e y do primeiro ponto
  x1 = float(input("Coordenada x do primeiro ponto: "))
  y1 = float(input("Coordenada y do primeiro ponto: "))

  # x e y do segundo ponto
  x2 = float(input("Coordenada x do segundo ponto: "))
  y2 = float(input("Coordenada y do segundo ponto: "))

  # agora vamos calcular o coeficiente angular
  m = (y2 - y1) / (x2 - x1)

  # e mostramos o resultado
  print("O coeficiente angular é: %f\n\n" % m)
  
if __name__== "__main__":
  main()

Ao executar este código em linguagem Python nós teremos o seguinte resultado:

Coordenada x do primeiro ponto: 3
Coordenada y do primeiro ponto: 6
Coordenada x do segundo ponto: 9
Coordenada y do segundo ponto: 10
O coeficiente angular é: 0.666667

Veja agora como podemos calcular o coeficiente angular da reta que passa pelos dois pontos usando o Teorema de Pitágoras. Note que agora nós estamos tirando proveito da tangente do ângulo Theta (__$\theta__$), também chamado de ângulo Alfa ou Alpha (__$\alpha__$):

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

# vamos importar o módulo Math
import math as math

def main():
  # x e y do primeiro ponto
  x1 = float(input("Coordenada x do primeiro ponto: "))
  y1 = float(input("Coordenada y do primeiro ponto: "))

  # x e y do segundo ponto
  x2 = float(input("Coordenada x do segundo ponto: "))
  y2 = float(input("Coordenada y do segundo ponto: "))

  # vamos obter o comprimento do cateto oposto
  cateto_oposto = y2 - y1
  # e agora o cateto adjascente
  cateto_adjascente = x2 - x1
  # vamos obter o ângulo tetha, ou seja, a inclinação da hipetunesa
  # (em radianos, não se esqueça)
  tetha = math.atan2(cateto_oposto, cateto_adjascente)
  # e finalmente usamos a tangente desse ângulo para calcular
  # o coeficiente angular
  tangente = math.tan(tetha)

  # e mostramos o resultado
  print("O coeficiente angular é: %f\n\n" % tangente)
  
if __name__== "__main__":
  main()

Ao executar este código você verá que o resultado é o mesmo. No entanto, fique atento às propriedades do coeficiente angular da reta:

1) O coeficiente angular é positivo quando a reta for crescente, ou seja, m > 0;

2) O coeficiente angular é negativo quando a reta for decrescente, ou seja, m < 0;

3) Se a reta estiver na horizontal, ou seja, paralela ao eixo x, seu coeficiente angular é zero (0).

4) Se a reta estiver na vertical, ou seja, paralela ao eixo y, o coeficiente angular não existe.


Python ::: Dicas & Truques ::: Lista (List)

Como criar uma lista Python vazia e adicionar itens a ela usando o laço for..in

Quantidade de visualizações: 11830 vezes
Nesta dica mostrarei como é possível usar o operador de vetor "[]" para criar um objeto List vazio na linguagem Python. Em seguida usaremos o laço for..in para adicionar 10 elementos a esta lista.

Veja o código completo para o exemplo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

"""
  Este exemplo mostra como criar uma list
  vazia e inicializá-la usando o laço for.
"""

def main():
  # cria uma lista vazia
  valores = []
 
  # adiciona valores a ela
  for num in range(1, 11):
    valores += [(num * 2)]
 
  # exibe os valores da lista
  for num in valores:
    print(num)

if __name__== "__main__":
  main()

Ao executar este código Python nós teremos o seguinte resultado:

2
4
6
8
10
12
14
16
18
20


Python ::: Dicas & Truques ::: Trigonometria - Funções Trigonométricas

Como calcular o cateto oposto dadas as medidas da hipotenusa e do cateto adjascente em Python

Quantidade de visualizações: 2663 vezes
Todos estamos acostumados com o Teorema de Pitágoras, que diz que "o quadrado da hipotenusa é igual à soma dos quadrados dos catetos". Baseado nessa informação, fica fácil retornar a medida do cateto oposto quando temos as medidas da hipotenusa e do cateto adjascente. Isso, claro, via programação em linguagem Python.

Comece observando a imagem a seguir:



Veja que, nessa imagem, eu já coloquei os comprimentos da hipotenusa, do cateto oposto e do cateto adjascente. Para facilitar a conferência dos cálculos, eu coloquei também os ângulos theta (que alguns livros chamam de alfa) e beta já devidamente calculados. A medida da hipotenusa é, sem arredondamentos, 36.056 metros.

Então, sabendo que o quadrado da hipotenusa é igual à soma dos quadrados dos catetos (Teorema de Pitógoras):

\[c^2 = a^2 + b^2\]

Tudo que temos que fazer é mudar a fórmula para:

\[a^2 = c^2 - b^2\]

Veja que agora o quadrado do cateto oposto é igual ao quadrado da hipotenusa menos o quadrado do cateto adjascente. Não se esqueça de que a hipotenusa é o maior lado do triângulo retângulo.

Veja agora como esse cálculo é feito em linguagem Python:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

# vamos importar o módulo Math
import math as math

def main():
  c = 36.056 # medida da hipotenusa
  b = 30 # medida do cateto adjascente
  
  # agora vamos calcular o comprimento da cateto oposto
  a = math.sqrt(math.pow(c, 2) - math.pow(b, 2))
 
  # e mostramos o resultado
  print("A medida do cateto oposto é: %f" % a)
  
if __name__== "__main__":
  main()

Ao executar este código Python nós teremos o seguinte resultado:

A medida do cateto oposto é: 20.000878

Como podemos ver, o resultado retornado com o código Python confere com os valores da imagem apresentada.


Desafios, Exercícios e Algoritmos Resolvidos de Python

Veja mais Dicas e truques de Python

Dicas e truques de outras linguagens

Códigos Fonte

Programa de Gestão Financeira Controle de Contas a Pagar e a Receber com Cadastro de Clientes e FornecedoresSoftware de Gestão Financeira com código fonte em PHP, MySQL, Bootstrap, jQuery - Inclui cadastro de clientes, fornecedores e ticket de atendimento
Diga adeus às planilhas do Excel e tenha 100% de controle sobre suas contas a pagar e a receber, gestão de receitas e despesas, cadastro de clientes e fornecedores com fotos e histórico de atendimentos. Código fonte completo e funcional, com instruções para instalação e configuração do banco de dados MySQL. Fácil de modificar e adicionar novas funcionalidades. Clique aqui e saiba mais
Controle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidadesControle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidades
Tenha o seu próprio sistema de controle de estoque web. com cadastro de produtos, categorias, fornecedores, entradas e saídas de produtos, com relatórios por data, margem de lucro e muito mais. Código simples e fácil de modificar. Acompanha instruções para instalação e criação do banco de dados MySQL. Clique aqui e saiba mais

Linguagens Mais Populares

1º lugar: Java
2º lugar: Python
3º lugar: C#
4º lugar: PHP
5º lugar: C
6º lugar: Delphi
7º lugar: JavaScript
8º lugar: C++
9º lugar: VB.NET
10º lugar: Ruby



© 2025 Arquivo de Códigos - Todos os direitos reservados
Neste momento há 66 usuários muito felizes estudando em nosso site.