![]() |
|
|
Planilha de Dimensionamento de Tubulações
Hidráulicas Água Fria e Água Quente CompletaNossa planilha automática de dimensionamento de tubulações de água fria e quente é uma ferramenta desenvolvida para auxiliar engenheiros e projetistas no cálculo rápido e preciso das redes hidráulicas de edificaçoes. Por meio da inserçao de dados como vazao, diâmetro da tubulaçao, comprimento da rede, material do tubo e coeficientes hidráulicos, a planilha realiza automaticamente os cálculos necessários para verificar velocidade da água, perda de carga e dimensionamento adequado das tubulaçoes. |
||
Você está aqui: Cards de Python |
||
|
||
|
|
||
Python ::: Python para Engenharia ::: Engenharia Civil - Concreto, Concreto Armado e Concretos Especiais |
Cálculo de estribos em vigas de concreto armado usando Python - Verificação da compressão diagonal do concretoQuantidade de visualizações: 1280 vezes |
|
No dimensionamento de vigas de concreto armado à força cortante, ou seja, aos esforços de cisalhamento, nós adotamos, de acordo com recomendações da ABNT NBR 6118 (Projeto de estruturas de concreto armado), o modelo de treliça clássica de Ritter-Mörsh, na qual é suposto que uma carga aplicada num ponto qualquer de uma viga de concreto armado, chegue até os apoios percorrendo o caminho de uma treliça. Recordemos ainda que na treliça clássica de Ritter-Mörsh o ângulo de inclinação das bielas comprimidas é igual à 45°. Neste modelo de treliça, a compressão do banzo superior é resistida pelo concreto, enquanto a tração do banzo inferior é resistida pelo aço. As diagonais comprimidas também são resistidas pelo concreto, cabendo ao aço (estribos) o papel de reforçar as diagonais tracionadas. Notem que usei "reforçar", pois o concreto oferece também uma parcela de resistência à tração nestas diagonais. Sendo assim, um dos primeiros passos no cálculo e detalhamento das armaduras transversais, ou seja, a armadura de cisalhamento de uma viga de concreto armado, é a verificação da compressão diagonal do concreto. Neste passo nós verificamos se as bielas comprimidas resistem ao esforço cortante solicitante de projeto VSd. A verificação da compressão diagonal do concreto no Modelo I (no qual o ângulo α, que é o ângulo entre os estribos e o eixo longitudinal da viga, pode ser considerado entre 45º e 90º) pode ser realizada por meio da seguinte fórmula: \[V_\text{Rd2} = 0,27 \cdot \alpha_\text{v2} \cdot f_\text{cd} \cdot b_w \cdot d \] Onde: fcd é a resistência de cálculo do concreto, em kN/cm2; bw é a largura da viga, em centímetros; d é a altura útil da viga em centímetros; Já o αv2 pode ser calculado pela seguinte fórmula: \[\alpha_\text{v2} = 1 - \frac{f_\text{ck}}{250}\] Onde: fck é a resistência característica do concreto, em Mpa. Veja agora o código Python :
# método principal
def main():
# vamos pedir para o usuário informar a altura da viga
altura = float(input("Informe a altura h da viga em cm: "))
# vamos pedir para o usuário informar a largura da viga
largura = float(input("Informe a largura bw da viga em cm: "))
# vamos calcular a altura útil da viga
# aqui eu usei 0.9 mas alguns engenheiros usam 0.95
altura_util = 0.9 * altura
# vamos pedir para o usuário informar o FCK do concreto
fck = float(input("Informe o FCK do concreto em Mpa: "))
# vamos ler o coeficiente de minoração do concreto
yc = float(input("Informe o coeficiente de minoração yc: "))
# vamos solicitar o esforço cortante solicitante VSk
VSk = float(input("Informe o esforço cortante solicitante em kN: "))
# vamos ler o coeficiente de majoração das cargas
yf = float(input("Informe o coeficiente de majoração yf: "))
# vamos calcular o esforço cortante solicitante de cálculo VSd
VSd = yf * VSk
# agora vamos calcular o fcd do concreto
fcd = fck / yc
# vamos calcular o alfa v2
av2 = 1 - (fck / 250)
# finalmente vamos calcular o VRd2 no Modelo de Cálculo I
VRd2 = 0.27 * av2 * (fcd / 10) * largura * altura_util
# vamos mostrar os resultados
print("\n------ RESULTADOS -----------------------------")
print("O fcd do concreto é: {0} Mpa".format(round(fcd, 4)))
print("O valor de av2 é: {0}".format(round(av2, 4)))
print("O valor de VRd2 é: {0} kN".format(round(VRd2, 4)))
print("O valor de VSd é: {0} kN".format(round(VSd, 4)))
# vamos testar se as bielas de compressão não serão esmagadas
if (VSd <= VRd2):
print("VSd <= VRd2: As bielas de compressão RESISTEM")
else:
print("VSd > VRd2: As bielas de compressão NÃO RESISTEM")
if __name__ == "__main__":
main()
Ao executar este código Python nós teremos o seguinte resultado: Informe a altura h da viga em cm: 40 Informe a largura bw da viga em cm: 20 Informe o FCK do concreto em Mpa: 25 Informe o coeficiente de minoração yc: 1.4 Informe o esforço cortante solicitante em kN: 75 Informe o coeficiente de majoração yf: 1.4 ------ RESULTADOS ----------------------------- O fcd do concreto é: 17.8571 Mpa O valor de av2 é: 0.9 O valor de VRd2 é: 312.4286 kN O valor de VSd é: 105.0 kN VSd <= VRd2: As bielas de compressão RESISTEM |
Python ::: Dicas & Truques ::: Arquivos e Diretórios |
Como usar a função exists() do módulo os.path para testar a existência de um arquivo ou diretório em PythonQuantidade de visualizações: 3815 vezes |
|
Antes de efetuarmos qualquer ação em um arquivo ou diretório, é sempre uma boa idéia testar primeiro se tal arquivo ou diretório existe no sistema. Isso pode ser feito por meio do método exists() do módulo os.path. Este método retorna True se o arquivo ou diretório existir, e False em caso contrário. Veja um exemplo no qual checamos a existência de um arquivo chamado "teste.txt":
from os import path
def main():
# vamos verificar se este arquivo existe, neste local
if path.exists("C:\\estudos_python\\teste.txt"):
print("Arquivo foi encontrado")
else:
print("Arquivo não foi encontrado")
if __name__== "__main__":
main()
Se o arquivo existir no caminho informado, o texto "Arquivo foi encontrado" será impresso na tela. Se o arquivo não puder ser encontrado, o texto "Arquivo não foi encontrado" será exibido. Veja agora como podemos verificar se um diretório existe ou não no sistema operacional:
from os import path
def main():
# vamos verificar se este diretório existe
if path.exists("C:\\estudos_python"):
print("Diretório existe.")
else:
print("Diretório não existe.")
if __name__== "__main__":
main()
Execute este código e veja o resultado. Se o diretório pesquisado existir, o texto "Diretório existe." será exibido. |
Delphi ::: Dicas & Truques ::: Geometria, Trigonometria e Figuras Geométricas |
Como calcular o coeficiente angular de uma reta em Delphi dados dois pontos no plano cartesianoQuantidade de visualizações: 1725 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 Delphi 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:
procedure TForm4.Button2Click(Sender: TObject);
var
x1, y1, x2, y2, m: Double;
begin
// x e y do primeiro ponto
x1 := 3;
y1 := 6;
// x e y do segundo ponto
x2 := 9;
y2 := 10;
// agora vamos calcular o coeficiente angular
m := (y2 - y1) / (x2 - x1);
// e mostramos o resultado
Memo1.Lines.Add('O coeficiente angular é: ' +
FloatToStr(m));
end;
Ao executar este código em linguagem Delphi nós teremos o seguinte resultado: O coeficiente angular é: 0,666666666666667 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__$):
procedure TForm4.Button2Click(Sender: TObject);
var
x1, y1, x2, y2, tangente: Double;
cateto_oposto, cateto_adjascente, tetha: Double;
begin
// incluir a unit Math
// x e y do primeiro ponto
x1 := 3;
y1 := 6;
// x e y do segundo ponto
x2 := 9;
y2 := 10;
// 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 := ArcTan2(cateto_oposto, cateto_adjascente);
// e finalmente usamos a tangente desse ângulo para calcular
// o coeficiente angular
tangente := Tan(tetha);
// e mostramos o resultado
Memo1.Lines.Add('O coeficiente angular é: ' +
FloatToStr(tangente));
end;
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. |
VisuAlg ::: Desafios e Lista de Exercícios Resolvidos ::: Estruturas de Controle |
Exercício Resolvido de VisuAlg - Um algoritmo em VisuAlg que testa se um triângulo é equilátero, isósceles ou escalenoQuantidade de visualizações: 1579 vezes |
|
Pergunta/Tarefa: Escreva um algoritmo que lê três valores para os lados de um triângulo. O algoritmo deve verificar se o triângulo é equilátero (todos os lados iguais), isósceles (dois lados iguais) ou escaleno (todos os lados diferentes). Sua saída deverá ser parecida com: Informe o lado 1 do triângulo: 6 Informe o lado 2 do triângulo: 8 Informe o lado 3 do triângulo: 2 O triângulo é escaleno Veja a resolução deste algoritmo em VisuAlg:
Algoritmo "Testa se um triângulo é equilátero, escaleno ou isósceles"
Var
// variáveis usadas na resolução do problema
lado1, lado2, lado3: real
Inicio
// vamos ler os lados do triângulo
escreva("Informe o lado 1 do triângulo: ")
leia(lado1)
escreva("Informe o lado 2 do triângulo: ")
leia(lado2)
escreva("Informe o lado 3 do triângulo: ")
leia(lado3)
// vamos testar se o triângulo é equilátero
// os três lados iguais
se (lado1 = lado2) e (lado2 = lado3) entao
escreval("O triângulo é equilátaro.")
senao
// vamos testar se o triângulo é escaleno
// os três lados diferentes
se (lado1 <> lado2) e (lado1 <> lado3) e (lado2 <> lado3) entao
escreval("O triângulo é escaleno")
senao
// vamos testar se o triângulo é isósceles
// dois lados iguais e um diferente
se (lado1 = lado2) ou (lado1 = lado3) ou (lado2 = lado3) entao
escreval("O triângulo é isósceles")
fimse
fimse
fimse
Fimalgoritmo
|
Python ::: Dicas & Truques ::: Trigonometria - Funções Trigonométricas |
Como calcular o cosseno de um ângulo em Python usando a função cos() do módulo Math - Calculadora de cosseno em PythonQuantidade de visualizações: 2994 vezes |
|
Como calcular o cosseno de um ângulo em Python usando a função cos() do módulo Math - Calculadora de cosseno em Python Em geral, quando falamos de cosseno, estamos falando do triângulo retângulo de Pitágoras (Teorema de Pitágoras). A verdade é que podemos usar a função cosseno disponível nas linguagens de programação para calcular o cosseno de qualquer número, mesmo nossas aplicações não tendo nenhuma relação com trigonometria. No entanto, é sempre importante entender o que é a função cosseno. Veja a seguinte imagem: ![]() Veja que temos um triângulo retângulo com as medidas já calculadas para a hipotenusa e os dois catetos, assim como os ângulos entre eles. Assim, o cosseno é a razão entre o cateto adjascente e a hipotenusa, ou seja, o cateto adjascente dividido pela hipotenusa. Veja a fórmula: \[\text{Cosseno} = \frac{\text{Cateto adjascente}}{\text{Hipotenusa}} \] Então, se dividirmos 30 por 36.056 (na figura eu arredondei) nós teremos 0.8320, que é a razão entre o cateto adjascente e a hipotenusa (em radianos). Agora, experimente calcular o arco-cosseno de 0.8320. O resultado será 0.5881 (em radianos). Convertendo 0.5881 radianos para graus, nós obtemos 33.69º, que é exatamente o ângulo em graus entre o cateto adjascente e a hipotenusa na figura acima. Pronto! Agora que já sabemos o que é cosseno na trigonometria, vamos entender mais sobre a função cos() da linguagem Python. Esta função, que faz parte do módulo Math, recebe um valor numérico float e retorna um valor float, ou seja, também numérico) entre -1 até 1 (ambos inclusos). Veja:
# vamos importar o módulo Math
import math as math
def main():
# vamos calcular o cosseno de três números
print("Cosseno de 0 = %f" % math.cos(0))
print("Cosseno de 1 = %f" % math.cos(1))
print("Cosseno de 2 = %f" % math.cos(2))
if __name__== "__main__":
main()
Ao executar este código Python nós teremos o seguinte resultado: Cosseno de 0 = 1.000000 Cosseno de 1 = 0.540302 Cosseno de 2 = -0.416147 Note que calculamos os cossenos dos valores 0, 1 e 2. Observe como os resultados conferem com a curva da função cosseno mostrada abaixo: ![]() |
Desafios, Exercícios e Algoritmos Resolvidos de Python |
Veja mais Dicas e truques de Python |
Dicas e truques de outras linguagens |
|
Java - Como calcular o coeficiente angular de uma reta em Java dados dois pontos no plano cartesiano |
E-Books em PDF |
||||
|
||||
|
||||
Linguagens Mais Populares |
||||
|
1º lugar: Java |








