Académique Documents
Professionnel Documents
Culture Documents
CAMPUS ARACAJU
DIRETORIA DE ENSINO
MONOGRAFIA
ARACAJU
2018
BRUNO SOUZA MUNIZ
ARACAJU
2018
INSTITUTO FEDERAL DE EDUCAÇÃO, CIÊNCIA E TECNOLOGIA DE SERGIPE
CAMPUS ARACAJU
TERMO DE APROVAÇÃO
Esta monografia foi apresentada às 09 horas e 30 minutos do dia 18 de maio de 2018 como
requisito parcial para a obtenção do título de BACHAREL EM ENGENHARIA CIVIL. O
candidato foi arguido pela Banca Examinadora composta pelos professores abaixo assinados.
Após deliberação, a Banca Examinadora considerou o trabalho aprovado.
Prof. DSc. Emerson Figueiredo dos Santos Prof. MSc. Marcílio Fabiano Goivinho da Silva
(Universidade Tiradentes) (Instituto Federal de Sergipe - IFS)
Prof. MSc. Rodolfo Santos da Conceição Prof. MSc. Rodolfo Santos da Conceição (IFS
– Campus Aracaju)
(Instituto Federal de Sergipe - IFS)
Coordenador da COEC
Orientador
AGRADECIMENTOS
Primeiro agradeço aos meus pais, Selene Soledade de Aguiar Souza Muniz e José
Cláudio Pereira Muniz, por terem me proporcionado, mesmo diante das preocupações, da
saudade e das incertezas, a liberdade de vivenciar outros mundos e aprender com meus erros,
estando sempre presentes e dispostos a me amparar nas eventuais falhas e nos momentos de
dificuldade.
Agradeço a meu irmão, André Souza Muniz, por ser inspiração para encarar os desafios
da vida e fornecer as respostas que tanto quis em momentos passados.
Agradeço ao meu amigo André Luiz por me mostrar que as amizades são confidentes e
suplantam os momentos de felicidade.
Agradeço aos meus amigos Hector Rodrigues e Camilla Adan pela companhia nos
momentos turbulentos que permeiam o início da vida adulta e pela frequente oportunidade de
desenvolver minha criatividade.
Agradeço a Raysa Barros Ramos, minha namorada e amiga, por ter me proporcionado
crescer e encarar desafios maiores do que eu me achava capaz de encarar, me dando força
constantemente com o seu companheirismo, me mostrando uma melhor versão de mim.
Agradeço ao meu orientador Prof. MSc. Rodolfo Santos da Conceição pela ajuda e boa
vontade únicas, sem as quais a conclusão desse trabalho não seria possível.
Finalmente, sou extremamente grato aos demais familiares e amigos que tive até este
momento. Tenho certeza que todas as suas influências foram determinantes para construção de
quem sou hoje.
“The magic of myth and legend has come true in our
time. One types the correct incantation on a
keyboard, and a display screen comes to life,
showing things that never were nor could be”
(BROOKS, Fred, 1975)
RESUMO
Grid models usually represent the behavior of concrete slabs and bridge decks, being studied in
most of the undergraduate courses. However, there are few free software’s that can perform
grid’ structural analysis, and by its intricate input of models, they are not attractive for structural
analysis classes at a graduation level. This work intended to develop a simple grid’ structural
analysis software using the Direct Stiffness Method and Python programming. The software
solves grids regardless of their staticity, with the input data being inserted through tables and
the displacements, stresses and stiffness matrices, presented in the same way. The clear help in
the resolution and verification of the problems presented in the structures disciplines is verified.
1 INTRODUÇÃO .................................................................................................... 12
1.1 OBJETIVOS ....................................................................................................... 13
1.1.1 Objetivos Específicos ..................................................................................... 13
1.2 METODOLOGIA ............................................................................................... 13
2 ANÁLISE ESTRUTURAL .................................................................................. 15
2.1 PRINCÍPIOS DA ANÁLISE ESTRUTURAL .................................................. 15
2.2 ESTRUTURAS RETICULADAS ...................................................................... 17
2.3 PRINCÍPIO DOS TRABALHOS VIRTUAIS ................................................... 19
2.4 MÉTODO DAS FORÇAS ................................................................................. 20
2.5 MÉTODO DOS DESLOCAMENTOS .............................................................. 22
2.5.1 Sistemática do método dos deslocamentos ..................................................... 22
2.6 ANÁLISE MATRICIAL .................................................................................... 25
2.6.1 Desenvolvimento da matriz de rigidez global. ............................................... 26
2.6.2 Desenvolvimento do Vetor de Forças globais ................................................ 29
2.6.3 Matrizes de rotação ......................................................................................... 30
2.6.4 Cálculo das Reações de Apoio e dos Esforços Solicitantes Internos ............. 32
2.6.5 Matriz de Rigidez de Elemento de Grelha ...................................................... 33
3 PROGRAMAÇÃO APLICADA À ENGENHARIA ........................................ 34
3.1 PROGRAMAÇÃO DIRECIONADA A OBJETOS .......................................... 34
3.2 PROGRAMAÇÃO EM PYTHON ..................................................................... 35
3.2.1 Pacotes de terceiros ......................................................................................... 36
3.2.2 Desenvolvimento de Interfaces Gráficas ........................................................ 37
4 DESENVOLVIMENTO DO PROGRAMA ...................................................... 38
4.1 ESCOPO GERAL DO PROGRAMA ................................................................ 38
4.2 FORMULAÇÃO MATRICIAL APLICADA NO CÁLCULO ESTRUTURAL
DE ESTRUTURAS DE GRELHAS ........................................................................................ 39
5 VALIDAÇÃO DO PROGRAMA GRELHAPY................................................ 41
5.1 PROBLEMA PROPOSTO 01 – GRELHA ISOSTÁTICA ............................... 41
5.2 PROBLEMA PROPOSTO 02 – GRELHA HIPERESTÁTICA ........................ 45
5.2.1 Resolução Manual ........................................................................................... 45
5.2.1.1 Esforços de engastamento perfeito ................................................................ 46
5.2.1.2 Coeficientes de rigidez ................................................................................... 46
5.2.1.3 Equações de equilíbrio ................................................................................... 48
5.2.2 Resultados do Programa ................................................................................. 49
6 CONCLUSÕES .................................................................................................... 52
APÊNDICE A – CÓDIGO DO PROGRAMA..........................................................55
12
1 INTRODUÇÃO
Dessa forma, é necessária uma abordagem de métodos de análise que sejam compatíveis
com a implementação computacional, isto é, através dos métodos matriciais. Tanto o método
das forças quanto o método dos deslocamentos possuem abordagens matriciais, porém este
último possui uma sistemática mais adequada para implementação, ainda assim, necessitando
do primeiro para o seu desenvolvimento.
Dentro deste quadro, é possível destacar programas gratuitos como o Mastan2 e o Ftool,
sendo este último o mais difundido para cálculo de treliças, pórticos e vigas dentro dos
ambientes de graduação. Estes programas usam interfaces gráficas para a inserção dos dados
necessários para análise, desenvolvendo as análises internamente através das formulações
matriciais dos métodos anteriormente citados, com posterior demonstração gráfica dos
resultados, facilitando o entendimento do comportamento estrutural através dos esforços e
deslocamentos exibidos, bem como a manipulação dos dados das estruturas.
1.1 OBJETIVOS
1.2 METODOLOGIA
f) Validação do programa.
15
2 ANÁLISE ESTRUTURAL
Em seu livro sobre análise estrutural, Martha (2010) adapta o paradigma dos quatro
universos, idealizado por Gomes e Velho (1998) e, baseado no conceito de análise estrutural de
Felippa (2009), estabelece quatro níveis de abstração para a análise estrutural, como exposto na
Figura 1.
O Modelo Estrutural tem por objetivo representar, com um bom nível de fidelidade, a
estrutura real, de tal forma a equacionar o seu comportamento matematicamente, permitindo
sua análise. Nesse nível, é comum a idealização da estrutura contínua em uma estrutura
reticulada, como representado na Figura 2, formada por barras e nós, assim como as cargas
oriundas do seu peso próprio e demais ações são convertidas em cargas pontuais ou distribuídas
16
sobre o eixo geométrico das barras. Essa representação é feita através de algumas considerações
básicas, que são baseadas nas leis da física e que estabelecem o equilíbrio entre as forças e
tensões, relações entre deslocamentos e deformações e características dos materiais
componentes da estrutura. Logo, o desenvolvimento do modelo estrutural é uma das fases mais
importantes da análise estrutural (Martha, 2010).
Partindo dessa configuração, as forças externas podem ser aplicadas nas barras, de
forma distribuída, podendo representar seu peso próprio e cargas distribuídas, e também ser
aplicadas diretamente nos nós.
18
As estruturas em barras podem ser classificadas sob diversos aspectos, como por
exemplo, quanto à geometria e aos esforços seccionais desenvolvidos, ao equilíbrio, ao material
utilizado, à finalidade e ao processo de fabricação (Soriano, 2010). Quanto à geometria e aos
esforços seccionais as estruturas em barras podem ser classificadas como vigas, pórticos (planos
ou espaciais), grelhas, treliças (plana ou espaciais), arcos e cabos.
Os pórticos planos são formados por barras retas ou curvas dispostas em um plano
vertical, sob carregamentos atuantes neste mesmo plano, de maneira que as barras desenvolvam
apenas o momento fletor de vetor representativo normal a esse plano, o esforço cortante e o
esforço normal tais como as vigas. Nos pórticos espaciais, as barras podem ter posições
arbitrárias no espaço, com carregamentos atuantes em qualquer direção, possibilitando aos seus
elementos constituintes o desenvolvimento de esforços nas seis direções (três translações e três
rotações), ou seja, esforço normal, esforços cortantes no plano perpendicular ao eixo do
elemento, momento torçor, e momentos fletores em tornos dos eixos perpendiculares ao eixo
longitudinal do elemento.
As grelhas, objeto de estudo deste trabalho, são constituídas de barras retas ou curvas
situadas em um plano geralmente horizontal submetida à carregamentos normais a este plano,
de modo que os elementos podem estar sujeitos à esforços cortantes normais ao plano, esforços
torçores e momentos fletores de vetores representativos neste plano.
Os arcos são formados por barras curvas ou poligonais. São utilizados quando se deseja
preponderância de esforço normal de compressão frente ao momento fletor, com o objetivo de
favorecer o uso de materiais de pouca resistência à tração e/ou de buscar formas arquitetônicas
estéticas. Os cabos são elementos unidimensionais e de rigidez à flexão desprezível frente à
rigidez axial, de maneira a resistir apenas a esforço de tração e assumir forma em função das
forças que lhe são aplicadas (Soriano, 2010).
19
O princípio dos trabalhos virtuais versa sobre o trabalho originado por forças reais
quando da imposição de deslocamentos virtuais e sobre o trabalho gerado pelos deslocamentos
reais quando da imposição de forças virtuais, tanto em corpos rígidos como em corpos flexíveis.
Nos corpos rígidos, a imposição de uma força ou deslocamento virtual não muda a
condição de nulidade da resultante das forças ou dos deslocamentos impostos ao corpo em
questão. Dessa forma, podemos estabelecer que o trabalho resultante da imposição de forças e
deslocamentos virtuais em corpos rígidos também é nula.
U = ∫ M 𝑑𝜑 + ∫ T 𝑑𝜃 + ∫ Q 𝑑𝜆 (1)
𝐹. ̅ 𝑑𝜑 + ∫ 𝑇̅ 𝑑𝜃 + ∫ 𝑄̅ 𝑑𝜆
̅ 𝑑 = ∫𝑀 (2)
20
̅ , 𝑇̅ e 𝑄̅ correspondem, respectivamente,
Onde 𝐹̅ corresponde à força virtual imposta e 𝑀
ao momento fletor, momento torsor e esforço cortante oriundos da imposição da força virtual.
1 1 1
̅𝑑=
𝐹. ̅ 𝑀 𝑑𝑥 +
∫𝑀 ∫ 𝑇̅ 𝑇 𝑑𝑥 + ∫ 𝑄̅ 𝑄 𝑑𝑥 (3)
𝐸𝐼 𝐺𝐽 𝐺 𝐴𝑄
Essa abordagem do princípio dos trabalhos virtuais é denominada princípio das forças
virtuais e pode ser utilizada de forma a encontrar os deslocamentos em pontos específicos da
estrutura. Isso pode ser feito ao considerar a imposição de uma força ou momento virtual
unitário na direção do deslocamento transversal ou rotação que se pretende obter. Assim, a
equação (3) toma a forma:
1 1 1
1 .𝑑 = ̅ 𝑀 𝑑𝑥 +
∫𝑀 ∫ 𝑇̅ 𝑇 𝑑𝑥 + ∫ 𝑄̅ 𝑄 𝑑𝑥 (4)
𝐸𝐼 𝐺𝐽 𝐺 𝐴𝑄
̅̅̅̅ + ∫ T 𝑑𝜃
̅ . F = ∫ M 𝑑𝜑
𝐷 ̅̅̅̅ + ∫ Q 𝑑𝜆
̅̅̅̅ (5)
1 . F = ∫ M ̅̅̅̅
𝑑𝜑 + ∫ T ̅̅
𝑑𝜃̅̅ + ∫ Q ̅𝑑𝜆
̅̅̅ (6)
O método das forças tem por objetivo diminuir esse grau de indeterminação, na medida
que determina certos vínculos, respeitando as leis constitutivas dos materiais e suas condições
de compatibilidade, de forma a permitir o cálculo das reações nos demais vínculos através das
equações da estática.
No método das forças, os sistemas principais são estruturas derivadas das estruturas
originais caracterizadas pela retirada de vínculos em quantidade igual ao seu grau de
indeterminação estática original. Devido à quantidade infinita de combinações de vínculos
possíveis, determinada pela infinidade de pontos existente nas barras da estrutura, há uma
quantidade de sistemas principais também infinita (Soriano, 2004), cabendo somente uma
escolha de um sistema que seja estável estaticamente. Essa infinidade de sistemas principais
dificulta a implementação computacional do método, tornando-o menos atrativo nesse quesito
que o método dos deslocamentos.
Em função disso, alguns métodos podem ser utilizados para o cálculo dos deslocamentos
gerados na análise individual das incógnitas, como o cálculo através das equações da linha
elástica. Porém, a forma mais usual para cálculo é através da aplicação de forças e momentos
virtuais unitários na direção dos vínculos retirados e consequente utilização do Princípio dos
Trabalhos Virtuais, no qual o deslocamento será igual ao trabalho dos esforços internos gerados
pela força virtual na aplicação de deslocamentos gerados pelas forças reais externas.
Ao contrário da análise feita pelo método das forças, o método dos deslocamentos prevê
a formação de um sistema cinematicamente determinado, chamado de sistema hipergeométrico,
derivado da estrutura original, em que os nós que possuem liberdade de deslocamentos
transversais e rotações, chamadas de deslocabilidades, são restringidos. Esses deslocamentos
são tratados como incógnitas que serão analisadas individualmente, satisfazendo as condições
de compatibilidade, e posteriormente terão seus efeitos sobrepostos de forma a atender as
condições de equilíbrio. Assim, diferentemente do sistema principal do método das forças, só
há um sistema hipergeométrico possível, em que todas as deslocabilidades são restringidas. Em
função disso, o método dos deslocamentos possui uma implementação computacional mais
simples, o que o torna mais utilizado no desenvolvimento de ferramentas computacionais.
Finalmente, os esforços internos da estrutura são gerados pela superposição dos esforços
gerados pelas cargas reais e pelos deslocamentos unitários.
25
𝑑 = 𝐾 −1 𝑓 (7)
Figura 9 – Matrizes necessárias para o desenvolvimento das matrizes de rigidez e do vetor de forças no
referencial global
Vetor de forças
Matrizes de rigidez
nodais em
locais
referencial local
Vetor de forças de
Matrizes de rotação engastamento
perfeito
Vetores de
correspondência Matrizes de rotação
das
deslocabilidades
Fonte: O autor (2018)
26
𝐾111 + 𝐾22 2 𝐾121 + 𝐾21 2 𝐾131 + 𝐾23 2 𝐾141 𝐾151 𝐾161 𝐾25 2 𝐾24 2 𝐾26 2
𝐾211 + 𝐾12 2 𝐾221 + 𝐾11 2 𝐾231 + 𝐾13 2 𝐾241 𝐾251 𝐾261 𝐾15 2 𝐾14 2 𝐾16 2
𝐾311 + 𝐾32 2 𝐾321 + 𝐾31 2 𝐾331 + 𝐾33 2 𝐾341 𝐾351 𝐾361 𝐾35 2 𝐾34 2 𝐾36 2
𝐾411 𝐾421 𝐾431 𝐾441 𝐾451 𝐾461 0 0 0
𝐾= 𝐾511 𝐾521 𝐾531 𝐾541 𝐾551 𝐾561 0 0 0 (10)
𝐾611 𝐾621 𝐾631 𝐾641 𝐾651 𝐾661 0 0 0
𝐾52 2 𝐾51 2 𝐾53 2 0 0 0 𝐾77 2 𝐾54 2 𝐾49 2
𝐾42 2 𝐾41 2 𝐾43 2 0 0 0 𝐾45 2 𝐾44 2 𝐾49 2
[ 𝐾62 2 𝐾61 2 𝐾63 2 0 0 0 𝐾65 2 𝐾64 2 𝐾66 2 ]
A etapa final da construção da matriz de rigidez global visa, através das condições de
contorno, torná-la não singular. Isso pode ser executado através da imposição de uma rigidez
de ordem muito superior às demais na direção da deslocabilidade prescrita, de forma que o seu
comportamento se aproxime ao de um elemento indeformável, o que é denominado Técnica do
Número Grande. Logo, é adicionado um acréscimo na rigidez relativa à direção do
deslocamento prescrito quando da imposição de um deslocamento unitário na direção do
mesmo.
𝐾111 + 𝐾22 2 𝐾121 + 𝐾21 2 𝐾131 + 𝐾23 2 𝐾141 𝐾151 𝐾161 𝐾25 2 𝐾24 2 𝐾26 2
𝐾211 + 𝐾12 2 𝐾221 + 𝐾11 2 𝐾231 + 𝐾13 2 𝐾241 𝐾251 𝐾261 𝐾15 2
𝐾14 2
𝐾16 2
𝐾311 + 𝐾32 2 𝐾321 + 𝐾31 2 𝐾331 + 𝐾33 2 𝐾341 𝐾351 𝐾361 𝐾35 2
𝐾34 2
𝐾36 2
𝐾411 𝐾421 𝐾431 1
𝐾44 + 𝑁𝑔 𝐾451 𝐾461 0 0 0
K= 𝐾511 𝐾521 𝐾531 𝐾541 𝐾551 + 𝑁𝑔 𝐾561 0 0 0 (11)
𝐾611 𝐾621 𝐾631 𝐾641 𝐾651 𝐾661 + 𝑁𝑔 0 0 0
𝐾52 2 𝐾51 2 𝐾53 2 𝐾77 2 𝐾54 2 𝐾49 2
0 0 0
𝐾42 2 𝐾41 2 𝐾43 2 0 0 0 𝐾45 2 𝐾44 2 𝐾49 2
2 2
[ 𝐾62 2 𝐾61 2 𝐾63 2 0 0 0 𝐾65 𝐾64 𝐾66 2 + 𝑁𝑔]
29
𝑃𝐿2
− 2
0 0
𝑃𝐿 0
−2
𝑓𝑏1 = 𝑃𝐿2
𝑓𝑏2 = 0 (12)
0
2 0
0 {0}
𝑃𝐿
{− 2 }
30
𝑃𝐿2
− +0
2
0+0
𝑃𝐿
− 2 +0
0
𝑓= 0 (13)
0
𝑃𝐿2
2
0
𝑃𝐿
{ −2 }
𝑉𝑥 ′ = 𝑉𝑥 𝑐𝑜𝑠 𝛼 + 𝑉𝑦 𝑠𝑒𝑛 𝛼
{ (14)
𝑉𝑦′ = −𝑉𝑥 𝑠𝑒𝑛 𝛼 + 𝑉𝑦 𝑐𝑜𝑠 𝛼
Em forma matricial o sistema da equação (14) pode ser escrito dessa forma:
𝑉𝑥 ′ 𝑐𝑜𝑠 𝛼 𝑠𝑒𝑛 𝛼 𝑉𝑥
{𝑉 } = [ ]{ } (15)
𝑦′ −𝑠𝑒𝑛 𝛼 𝑐𝑜𝑠 𝛼 𝑉𝑦
𝑓 ′ = 𝑅. 𝑓 (17)
Logo, já que a matriz de rotação é ortogonal, ou seja, sua transposta é igual à sua inversa,
podemos definir que:
𝑓 = 𝑅𝑇 . 𝑓 ′ (19)
Essa relação também serve para a transformação dos deslocamentos entre referenciais,
gerando:
𝐷 = 𝑅 𝑇 . 𝐷′ (20)
Dessa forma, podemos multiplicar os elementos da equação (7) pela matriz de rotação,
obtendo:
𝑅 . 𝐷 = 𝑅 𝑘 −1 (𝑅 𝑇 . 𝑅)𝑓 (21)
𝐷′ = 𝑅 𝑘 −1 𝑅 𝑇 𝑓′ (22)
Finalmente, podemos então definir que a matriz de rigidez pode ser passada para o
referencial global dessa forma:
𝑘 ′ = 𝑅 𝑘 𝑅𝑇 (23)
32
𝑘 = 𝑅 𝑇 𝑘′ 𝑅 (24)
𝑓 = 𝐾. 𝑑 (25)
Assim, retirando as parcelas das ações externas relativas às forças nodais e a aos
esforços de engastamento perfeito, podemos obter as reações de apoio.
Para obtenção dos esforços solicitantes nas extremidades da barra, é necessário obter o
vetor de deslocamentos local a partir do global obtido pela equação (7). Dessa maneira,
podemos utilizar a equação (25) nos referenciais locais das barras e, retirando as parcelas dos
esforços de engastamento perfeito, podemos obter um vetor com os esforços solicitantes nos
nós das barras. Assim, por facilidade de compreensão, podemos obter esse vetor no referencial
global, utilizando a equação (19).
33
Figura 16 – Referencial adotado para elaboração da matriz de rigidez de uma barra de grelha
𝐺𝐽/𝐿 0 0 −𝐺𝐽/𝐿 0 0
0 4𝐸𝐼/𝐿 −6𝐸𝐼/𝐿2 0 2𝐸𝐼/𝐿 −6𝐸𝐼/𝐿2
0 −6𝐸𝐼/𝐿2 12𝐸𝐼/𝐿3 0 −6𝐸𝐼/𝐿2 −12𝐸𝐼/𝐿3
𝐾= (25)
−𝐺𝐽/𝐿 0 0 𝐺𝐽/𝐿 0 0
0 2𝐸𝐼/𝐿 −6𝐸𝐼/𝐿2 0 4𝐸𝐼/𝐿 6𝐸𝐼/𝐿2
[ 0 6𝐸𝐼/𝐿2 −12𝐸𝐼/𝐿3 0 6𝐸𝐼/𝐿2 12𝐸𝐼/𝐿3 ]
34
propriedades necessárias, além das novas propriedades que lhe podem ser atribuídas, como
demonstrado na Figura 17.
Classe EstruturaReticulada2d
Grelha
Nós
Quantidade de Coordenadas Quantidade de Novas
delimitantes
nós dos nós barras propriedades
das barras
Com esse recurso, é possível tornar o código mais conciso, já que toda vez que for
necessário criar um objeto referente a uma estrutura reticulada, as propriedades e métodos não
precisarão ser declarados novamente.
Criada por Guido Van Rossum, Python é uma linguagem de programação em alto nível
que permite o emprego de vários paradigmas da programação, como a programação imperativa
e a programação direcionada a objetos. Um dos seus principais objetivos é propiciar uma fácil
leitura e escrita do seu código, aumentando a produtividade dos programadores em relação a
outras linguagens. Além disso, a grande comunidade de desenvolvedores de Python é
responsável pelo desenvolvimento de pacotes que permitem a utilização da linguagem para fins
diversos, como desenvolvimento de interfaces gráficas, análise de dados e computação
científica.
36
Todos esses pacotes podem ser instalados, no sistema operacional Windows, através do
Python Package Index, que pode ser acessado pelo prompt de comando do sistema operacional
através do comando ‘pip’. Assim que instalados, eles podem ser importados para uso nos
scripts.
4 DESENVOLVIMENTO DO PROGRAMA
Páginas de
Classe de análise Páginas de inserção
apresentação dos
linear elástica de dados
resultados
Deslocamentos
Classe de Grelha Dados geométricos
nodais
Esforços solicitantes
Forças concentradas
nas extremidades
e distribuídas
das barras
Dessa forma, a análise ocorre na sequência demonstrada pela Figura 20. Primeiro
ocorrem as definições das informações iniciais, que são compostas de matrizes com as
coordenadas dos nós, nós delimitadores das barras, forças externas concentradas e distribuídas,
características das seções das barras e dos módulos de elasticidade. As informações iniciais são
complementadas por variáveis do sistema, que representam informações que não necessitam de
modificação, pois serão utilizadas com o mesmo valor para qualquer estrutura analisada, como
o número grande utilizado para aumentar a rigidez referente aos apoios e as deslocabilidades
40
dos nós. A partir das matrizes contendo as informações iniciais e das variáveis do sistema, são
declaradas funções, que possuem a barra como parâmetro, referentes aos comprimentos de
barra, matriz de rigidez local, engastamento perfeito, matriz de rotação e vetor de
correspondência das deslocabilidades das barras. Após as declarações das funções são
desenvolvidas as rotinas para cálculo do vetor de forças global e da matriz de rigidez global.
Finalmente os deslocamentos, reações de apoio e esforços solicitantes internos são calculados.
Declaração da funções
•Comprimento de barra
•Matriz de rigidez local
•Engastamento perfeito
•Matriz de rotação
Rotinas de cálculo
•Forças nodais globais
• Matriz de rigidez global
• Deslocamentos nodais
• Reações de apoio
• Esforços solicitantes
Dessa forma:
∑ 𝐹𝑧 = 0
𝐹1 − 10 − 3 . 3,5 = 0
𝐹1 = 20,5 𝐾𝑁
∑ 𝑇𝑥 = 0
3,52
𝑇𝑥 − 10 . 3,5 − 3 . =0
2
𝑇𝑥 = 53,375 𝐾𝑁/𝑚
∑ 𝑀𝑦 = 0
𝑀𝑦 = 91,5 𝐾𝑁/𝑚
Tabela 2 – Esforços solicitantes nas extremidades das barras obtidos através das equações da estática
Eixo X Eixo Y Eixo Z Eixo X Eixo Y Eixo Z
inicial inicial inicial final final final
(KNm) (KNm) (KN) (KNm) (KNm) (KN)
BARRA 1 53,375 91,500 20,500 -53,375 -30,000 -20,500
BARRA 2 53,375 30,000 20,500 0,000 -30,000 -10,000
BARRA 3 0,000 30,000 10,000 0,000 0,000 -10,000
Os resultados obtidos pelo programa são apresentados nas Figuras 24 e 25 e nas Tabelas
3 e 4.
Tabela 4 - Esforços solicitantes nas extremidades das barras da grelha do Problema Proposto 01
obtidos através do programa
Eixo X Eixo Y Eixo Z Eixo X Eixo Y Eixo Z
inicial inicial inicial final final final
(KNm) (KNm) (KN) (KNm) (KNm) (KN)
BARRA 1 53,375 91,500 20,500 -53,375 -30,000 -20,500
BARRA 2 53,375 30,000 20,500 0,000 -30,000 -10,000
BARRA 3 0,000 30,000 10,000 0,000 0,000 -10,000
Verifica-se que os resultados gerados pelo programa são idênticos aos calculados
manualmente. Contudo, cabe apontar que os esforços apresentados estão correlacionados às
direções dos esforços definidas quando da elaboração da matriz de rigidez, portanto sendo
necessária a adequação para a convenção de sinais comumente utilizada.
45
Conforme pode ser visto na Figura 28, o problema apresenta três deslocabilidades livres
no nó 2, duas rotações (em torno dos eixos X e Y) e uma translação na direção do eixo Z.
Denominaremos de deslocabilidades D1, D2 e D3, respectivamente, a rotação em torno do eixo
X, a rotação em torno do eixo Y e a translação na direção do eixo Z.
Tabela 7 – Coeficientes de rigidez obtidos através da consideração de uma rotação unitária na direção D1
na extremidade da Barra 1
Rigidez em X Rigidez em Y Rigidez em Z
(kNm) (kNm) (kN)
NÓ 1 -1,3333x105 0,0 0,0
NÓ 2 1,3333x105 0,0 0,0
NÓ 3 0,0 0,0 0,0
Tabela 8 – Coeficientes de rigidez obtidos através da consideração de uma rotação unitária na direção D1
na extremidade da Barra 2
Rigidez em X Rigidez em Y Rigidez em Z
(kNm) (kNm) (kN)
NÓ 1 0,0 0,0 0,0
NÓ 2 5,0x105 0,0 1,875x105
NÓ 3 2,5x105 0,0 -1,875x105
Tabela 9 – Coeficientes de rigidez obtidos através da consideração de uma rotação unitária na direção D2
na extremidade da Barra 1
Rigidez em X Rigidez em Y Rigidez em Z
(kNm) (kNm) (kN)
NÓ 1 0,0 3,3333x105 3,3333x105
NÓ 2 0,0 6,6667x105 -3,3333x105
NÓ 3 0,0 0,0 0,0
𝐷1 = 0,6922x10−5 𝑟𝑎𝑑
𝐷2 = −1,4472x10−5 𝑟𝑎𝑑
𝐷3 = −3,7606x10−5 𝑚
Tabela 13 – Reações de apoio obtidas através do desenvolvimento manual do método dos deslocamentos
Eixo X Eixo Y Eixo Z
(kNm) (kNm) (kN)
NÓ 1 -0,9229 9,8713 6,7728
NÓ 3 -7,9873 1,4472 6,2273
49
Tabela 14 – Esforços solicitantes nas extremidades das barras obtidos através do desenvolvimento manual
do método dos deslocamentos
Eixo X Eixo Y Eixo Z Eixo X Eixo Y Eixo Z
inicial inicial inicial final final final
(KNm) (KNm) (KN) (KNm) (KNm) (KN)
BARRA 1 -0,9229 9,8713 6,7728 0,9229 1,4472 -1,7729
BARRA 2 -0,9234 -1,4472 1,7727 -7,9873 1,4472 6,2273
Novamente verifica-se que os resultados gerados pelo programa são muito próximos
aos calculados manualmente, ainda considerando-se os arredondamentos inerentes da análise
manual a maior diferença entre os valores encontrados foi menor que 0,05%.
6 CONCLUSÕES
REFERÊNCIAS
SORIANO, Humberto Lima; LIMA, Sílvio de Souza. Análise de Estruturas – Volume I. Rio
de Janeiro: Editora Ciência Moderna Ltda, 2004.
SORIANO, Humberto Lima. Estática das Estruturas. Rio de Janeiro: Editora Ciência
Moderna Ltda, 2010.
A.1 – GrelhaPy.py
import sys
NumeroDeNos = None
NumeroDeBarras = None
MatrizDeCoordenadas = None
MatrizDeConectividade = None
ForcasDistribuidas = None
ForcasNodais = None
CondicoesDeContorno = None
G = None
E = None
J = None
I = None
# noinspection PyUnresolvedReferences
class GrelhaCalcMain(VisualConfig):
def __init__(self):
super().__init__()
###########################################################################
"""Criação dos menus"""
main_menu = self.menuBar()
menu_arquivo = main_menu.addMenu('Arquivo')
menu_geometria = main_menu.addMenu('Geometria')
menu_materiais = main_menu.addMenu('Materiais')
menu_forcas = main_menu.addMenu('Forças')
menu_analise = main_menu.addMenu('Análise')
###########################################################################
# Criação do objeto da classe janelas que irá conter o stack das
páginas
self.Janelas = Janelas()
self.setCentralWidget(self.Janelas)
###########################################################################
"""Definição dos submenus"""
# Menu de arquivo
menu_arquivo.addAction(self.Janelas.botao_abrir)
menu_arquivo.addAction(self.Janelas.botao_novo)
menu_arquivo.addAction(self.Janelas.botao_salvar)
# Menu de geometria
menu_geometria.addAction(self.Janelas.botao_nos)
menu_forcas.addAction(self.Janelas.botao_forcas_distribuidas)
#
###########################################################################
self.setStatusBar(self.Janelas.statusBar)
self.show()
if __name__ == '__main__':
app = QApplication(sys.argv)
ex = GrelhaCalcMain()
sys.exit(app.exec_())
A.2 – VisualConfig.py
class VisualConfig(QMainWindow):
def __init__(self):
super().__init__()
###########################################################################
"""Características básicas da tela principal"""
self.setWindowTitle('GrelhaPy - Programa para análise estrutural de
grelhas')
self.setGeometry(50, 50, 800, 600)
# self.setMaximumSize(1280, 768)
self.setMinimumSize(800, 600)
icon = QIcon("Logo2.JPG")
self.setWindowIcon(icon)
###########################################################################
self.setAutoFillBackground(True)
p = self.palette()
p.setColor(self.backgroundRole(), Qt.white)
self.setPalette(p)
57
A.3 - Janelas.py
import matplotlib.pyplot as pl
import matplotlib.patches as patches
from matplotlib.path import Path
# noinspection PyArgumentList,PyUnresolvedReferences,PyAttributeOutsideInit
class Janelas(QWidget):
def __init__(self):
super().__init__()
self.statusBar = QStatusBar()
self.statusBar.showMessage("GrelhaPy!", 2000)
###########################################################################
"""Definição das janelas """
self.nost = QTabWidget()
self.nos = QWidget()
self.nos_view = QWidget()
self.barras = QWidget()
self.modulos = QWidget()
self.forcas_distribuidas = QWidget()
self.forcas_concentradas = QWidget()
self.deslocamentos = QWidget()
self.reacoes_apoio = QWidget()
self.esi = QWidget()
self.matriz_de_rigidez = QWidget()
self.nost.addTab(self.nos, 'Nós')
self.nost.addTab(self.barras, 'Barras')
self.nost.addTab(self.nos_view, 'Estrutura')
self.nost.setTabEnabled(1, False)
self.nost.setTabEnabled(2, True)
58
###########################################################################
"""Inicialização dos métodos das páginas"""
self.nos_ui()
self.nos_view_ui()
self.barras_ui()
self.modulos_ui()
self.forcas_distribuidas_ui()
self.forcas_concentradas_ui()
self.deslocamentos_ui()
self.reacoes_apoio_ui()
self.esi_ui()
self.matriz_de_rigidez_ui()
###########################################################################
"""Inserção das páginas no stack"""
self.Stack = QStackedWidget()
self.Stack.addWidget(self.nost)
self.Stack.addWidget(self.modulos)
self.Stack.addWidget(self.forcas_distribuidas)
self.Stack.addWidget(self.forcas_concentradas)
self.Stack.addWidget(self.deslocamentos)
self.Stack.addWidget(self.reacoes_apoio)
self.Stack.addWidget(self.esi)
self.Stack.addWidget(self.matriz_de_rigidez)
###########################################################################
vbox = QVBoxLayout()
vbox.addWidget(self.Stack)
###########################################################################
self.setLayout(vbox)
# Menu de geometria
self.botao_nos = QAction('Nós e Barras', self)
self.botao_deslocamentos.setDisabled(True)
59
self.botao_reacoes_apoio.setDisabled(True)
self.botao_esi.setDisabled(True)
self.botao_matriz.setDisabled(True)
###########################################################################
# Definição das funções dos botões do submenu
self.botao_salvar.triggered.connect(self.save_event)
self.botao_abrir.triggered.connect(self.read_event)
self.botao_novo.triggered.connect(self.novo_event)
# Páginas
self.botao_nos.triggered.connect(lambda:
self.Stack.setCurrentIndex(0))
self.botao_elasticidade.triggered.connect(lambda:
self.Stack.setCurrentIndex(1))
self.botao_forcas_distribuidas.triggered.connect(lambda:
self.Stack.setCurrentIndex(2))
self.botao_forcas_concentradas.triggered.connect(lambda:
self.Stack.setCurrentIndex(3))
self.botao_analise.triggered.connect(self.botao_analise_exec)
self.botao_deslocamentos.triggered.connect(lambda:
self.Stack.setCurrentIndex(4))
self.botao_reacoes_apoio.triggered.connect(lambda:
self.Stack.setCurrentIndex(5))
self.botao_esi.triggered.connect(lambda:
self.Stack.setCurrentIndex(6))
self.botao_matriz.triggered.connect(lambda:
self.Stack.setCurrentIndex(7))
###########################################################################
"""Métodos das páginas"""
def nos_ui(self):
# Definição dos objetos da página
text = QLabel('Defina a quantidade de nós:')
# Tabela
self.tabela_nos = QTableWidget()
self.tabela_nos.setColumnCount(5)
self.tabela_nos.setHorizontalHeaderLabels(("Coordenada X(m)",
"Coordenada Y(m)", "Apoio em X",
"Apoio em Y", "Apoio em
Z"))
###########################################################################
# Definição dos layouts da página
layout = QGridLayout()
vlayout = QVBoxLayout()
hlayout = QHBoxLayout()
60
hlayout.addWidget(self.edit_text_nos)
hlayout.addWidget(botao)
hlayout.addStretch()
hlayout.addWidget(self.botao_atualizar_nos)
vlayout.addWidget(text)
vlayout.addLayout(hlayout)
layout.addLayout(vlayout, 0, 0)
layout.addWidget(self.tabela_nos, 1, 0)
self.nos.setLayout(layout)
###########################################################################
def nos_view_ui(self):
# Tela de apresentação da estrutura
self.fig, self.ax = pl.subplots()
self.canvas = FigureCanvas(self.fig)
pl.subplots_adjust(left=0, bottom=0, right=1, top=1)
self.ax.grid()
self.ax.axis('equal')
self.mpl_toolbar = NavigationToolbar(self.canvas, self.nos)
self.nos_view.setLayout(layout)
def barras_ui(self):
# Definição dos objetos da página
text = QLabel('Defina a quantidade de barras:')
self.botao_atualizar_barras.clicked.connect(self.botao_atualizar_barrasm)
# Criação da tabela
self.tabela_barras = QTableWidget()
self.tabela_barras.setColumnCount(4)
self.tabela_barras.setHorizontalHeaderLabels(
("Nó inicial", "Nó final", "Momento de inércia longitudinal
(I)", "Momento de inércia Transversal (J)"))
self.tabela_barras.setColumnWidth(2, 230)
self.tabela_barras.setColumnWidth(3, 230)
61
###########################################################################
# Definição do layout da página
layout = QGridLayout()
vlayout = QVBoxLayout()
hlayout = QHBoxLayout()
hlayout.addWidget(self.edit_text_barras)
hlayout.addWidget(botao)
hlayout.addStretch()
hlayout.addWidget(self.botao_atualizar_barras)
vlayout.addWidget(text)
vlayout.addLayout(hlayout)
layout.addLayout(vlayout, 0, 0)
layout.addWidget(self.tabela_barras, 1, 0)
self.barras.setLayout(layout)
def modulos_ui(self):
# Objetos da página
text = QLabel('Defina os módulos de elasticidade:')
# Criação da tabela
self.tabela_modulos = QTableWidget()
self.tabela_modulos.setColumnCount(2)
self.tabela_modulos.setHorizontalHeaderLabels(
("Módulo de elasticidade longitudinal (E)", "Módulo de
elasticidade transversal (G)"))
self.tabela_modulos.setColumnWidth(0, 240)
self.tabela_modulos.setColumnWidth(1, 240)
###########################################################################
# Definição do layout
layout = QGridLayout()
layout.addWidget(text, 0, 0)
layout.addWidget(self.tabela_modulos, 1, 0)
layout.addWidget(botao, 2, 0)
self.modulos.setLayout(layout)
def forcas_distribuidas_ui(self):
# Objetos da página
text = QLabel('Defina as forças distribuídas:')
# Criação da tabela
self.tabela_forcas_distribuidas = QTableWidget()
self.tabela_forcas_distribuidas.setColumnCount(1)
self.tabela_forcas_distribuidas.setHorizontalHeaderLabels(["Força
62
distribuída KN/m"])
self.tabela_forcas_distribuidas.setColumnWidth(0, 240)
###########################################################################
# Definição do layout
layout = QGridLayout()
layout.addWidget(text, 0, 0)
layout.addWidget(self.tabela_forcas_distribuidas, 1, 0)
layout.addWidget(botao, 2, 0)
self.forcas_distribuidas.setLayout(layout)
def forcas_concentradas_ui(self):
# Objetos da página
text = QLabel('Defina as forças concentradas:')
# Criação da tabela
self.tabela_forcas_concentradas = QTableWidget()
self.tabela_forcas_concentradas.setColumnCount(3)
self.tabela_forcas_concentradas.setHorizontalHeaderLabels(
("Momento em X(KN.m)", "Momento em Y(KN.m)", "Força horizontal
em Z(KN)"))
self.tabela_forcas_concentradas.setColumnWidth(0, 200)
self.tabela_forcas_concentradas.setColumnWidth(1, 200)
self.tabela_forcas_concentradas.setColumnWidth(2, 200)
###########################################################################
# Definição do layout
layout = QGridLayout()
layout.addWidget(text, 0, 0)
layout.addWidget(self.tabela_forcas_concentradas, 1, 0)
layout.addWidget(botao, 2, 0)
self.forcas_concentradas.setLayout(layout)
def deslocamentos_ui(self):
# Objetos da página
text = QLabel('Deslocamentos:')
# Criação da tabela
self.tabela_deslocamentos = QTableWidget()
self.tabela_deslocamentos.setColumnCount(1)
self.tabela_deslocamentos.setHorizontalHeaderLabels(["Deslocamentos
nodais(m)"])
self.tabela_deslocamentos.setColumnWidth(0, 200)
###########################################################################
# Definição do layout
layout = QGridLayout()
layout.addWidget(text, 0, 0)
layout.addWidget(self.tabela_deslocamentos, 1, 0)
63
self.deslocamentos.setLayout(layout)
def reacoes_apoio_ui(self):
# Objetos da página
text = QLabel('Reações de apoio:')
# Criação da tabela
self.tabela_reacoes = QTableWidget()
self.tabela_reacoes.setColumnCount(3)
self.tabela_reacoes.setHorizontalHeaderLabels(("Reação em X(KN.m)",
"Reação em Y(KN.m)", "Reação em Z(KN)"))
self.tabela_reacoes.setColumnWidth(0, 160)
self.tabela_reacoes.setColumnWidth(1, 160)
self.tabela_reacoes.setColumnWidth(2, 160)
###########################################################################
# Definição do layout
layout = QGridLayout()
layout.addWidget(text, 0, 0)
layout.addWidget(self.tabela_reacoes, 1, 0)
self.reacoes_apoio.setLayout(layout)
def esi_ui(self):
# Objetos da página
text = QLabel('Esforços solicitantes internos:')
# Criação da tabela
self.tabela_esi = QTableWidget()
self.tabela_esi.setColumnCount(6)
self.tabela_esi.setHorizontalHeaderLabels(
("Esforço inicial em X(KN.m)", "Esforço inicial em Y(KN.m)",
"Esforço inicial em Z(KN)", "Esforço final em X(KN.m)",
"Esforço final em Y(KN.m)",
"Esforço final em Z(KN)"))
self.tabela_esi.setColumnWidth(0, 220)
self.tabela_esi.setColumnWidth(1, 220)
self.tabela_esi.setColumnWidth(2, 220)
self.tabela_esi.setColumnWidth(3, 220)
self.tabela_esi.setColumnWidth(4, 220)
self.tabela_esi.setColumnWidth(5, 220)
###########################################################################
# Definição do layout
layout = QGridLayout()
layout.addWidget(text, 0, 0)
layout.addWidget(self.tabela_esi, 1, 0)
self.esi.setLayout(layout)
def matriz_de_rigidez_ui(self):
# Objetos da página
text = QLabel('Matriz de rigidez global:')
# Criação da tabela
self.tabela_matriz_rigidez = QTableWidget()
64
###########################################################################
# Definição do layout
layout = QGridLayout()
layout.addWidget(text, 0, 0)
layout.addWidget(self.tabela_matriz_rigidez, 1, 0)
self.matriz_de_rigidez.setLayout(layout)
###########################################################################
"""Métodos dos botões"""
def botao_def_nos(self):
# Recuperação de variável global
global NumeroDeNos
except ValueError:
erro_formato_errado()
def botao_atualizar_nosm(self):
# Recuperação de variáveis globais
global NumeroDeNos, MatrizDeCoordenadas, CondicoesDeContorno
float(self.tabela_nos.item(i, j).text())
for j in range(3):
CondicoesDeContorno[i, j] = int(self.tabela_nos.item(i,
j+2).text())
except ValueError:
erro_null()
self.nost.setTabEnabled(1, True)
def botao_def_barras(self):
# Recuperação de variável global
global NumeroDeBarras
try:
# Atribuição de valor da caixa de texto para variável do número
de barras
NumeroDeBarras = int(self.edit_text_barras.text())
except ValueError:
erro_formato_errado()
def botao_atualizar_barrasm(self):
# Recuperação de variáveis globais
global NumeroDeBarras, MatrizDeConectividade, J, I,
MatrizDeCoordenadas
try:
# Recuperação dos valores da tabela para inserção nas matrizes
zeradas
for i in range(NumeroDeBarras):
for j in range(2):
MatrizDeConectividade[i, j] =
int(self.tabela_barras.item(i, j).text())
def botao_def_modulos(self):
# Recuperação de variáveis globais
global NumeroDeBarras, G, E
try:
# Recuperação dos valores da tabela e inserção
for i in range(NumeroDeBarras):
def botao_forcas_distribuidas_at(self):
# Recuperação das variáveis globais
global ForcasDistribuidas, NumeroDeBarras
try:
# Recuperação dos valores da tabela e inserção nas matrizes
67
zeradas
for i in range(NumeroDeBarras):
ForcasDistribuidas[i, 0] =
int(self.tabela_forcas_distribuidas.item(i, 0).text())
except:
erro_null()
def botao_forcas_concentradas_at(self):
# Recuperação das variáveis globais
global NumeroDeNos, ForcasNodais
try:
# Recuperação dos valores da tabela e inserção na matriz zerada
for i in range(NumeroDeNos):
for j in range(3):
ForcasNodais[i, j] =
int(self.tabela_forcas_concentradas.item(i, j).text())
except:
erro_null()
###########################################################################
def botao_analise_exec(self):
# Recuperação das variáveis globais
global NumeroDeNos, NumeroDeBarras, MatrizDeCoordenadas,
MatrizDeConectividade, ForcasDistribuidas, \
ForcasNodais, CondicoesDeContorno, G, E, J, I
###########################################################################
# Cálculo das reações de apoio
reacoes = R.reacoes_apoio()
###########################################################################
# Cálculo dos esforços solicitantes
esi = R.eforcos_solicitantes()
###########################################################################
# apresentação da matriz de rigidez
matrizderigidez = R.MatrizRigidezGlobal
self.botao_deslocamentos.setDisabled(False)
self.botao_reacoes_apoio.setDisabled(False)
self.botao_esi.setDisabled(False)
self.botao_matriz.setDisabled(False)
###########################################################################
"""Métodos de arquivo"""
def save_event(self):
def read_event(self):
def novo_event(self):
A.4. Analises.Py
self.estrutura = Estrutura
self.MatrizRigidezGlobal = None
self.ForcasNodaisEquivalentes = None
def linear_elastica(self):
###########################################################################
"""Criação do vetor de forças"""
self.ForcasNodaisEquivalentes =
zeros((self.estrutura.Deslocabilidades * self.estrutura.NumeroDeNos, 1))
EngastamentoPerfeitoGlobal =
dot(self.estrutura.matriz_rotacao(i).T,
self.estrutura.engastamento_perfeito(i))
VetorCorrespondenciaIndex =
self.estrutura.vetor_correspondencia(i)
self.ForcasNodaisEquivalentes[int((VetorCorrespondenciaIndex[j-1, 0])-1),
0]\
-= EngastamentoPerfeitoGlobal[j-1, 0]
self.ForcasNodaisCombinadas = copy(self.ForcasNodaisEquivalentes)
self.ForcasNodaisCombinadas[(((i-
1)*self.estrutura.Deslocabilidades) + j)-1, 0] \
+= self.estrutura.ForcasNodais[i-1, j-1]
self.ForcasNodaisNumeroGrande =
zeros((self.estrutura.Deslocabilidades * self.estrutura.NumeroDeNos, 1))
for i in range(1, self.estrutura.NumeroDeNos + 1):
for j in range(1, self.estrutura.Deslocabilidades + 1):
if self.estrutura.CondicoesDeContorno[i - 1, j - 1] == 1:
self.ForcasNodaisNumeroGrande[(self.estrutura.Deslocabilidades * (i - 1) +
j) - 1, 0] = \
self.ForcasNodaisCombinadas[(self.estrutura.Deslocabilidades * (i - 1) + j)
70
- 1, 0] + \
self.estrutura.NumeroGrande *
self.estrutura.DeslocamentosPrescritos[i - 1, j - 1]
else:
self.ForcasNodaisNumeroGrande[(self.estrutura.Deslocabilidades * (i - 1) +
j) - 1, 0] = \
self.ForcasNodaisCombinadas[(self.estrutura.Deslocabilidades * (i - 1) + j)
- 1, 0]
###########################################################################
"""Criação da matriz de rigidez global"""
self.MatrizRigidezGlobal =
zeros((self.estrutura.Deslocabilidades*self.estrutura.NumeroDeNos,
self.estrutura.Deslocabilidades*self.estrutura.NumeroDeNos))
MatrizIndex = dot(self.estrutura.matriz_rotacao(i).T,
dot(self.estrutura.matriz_rigidez_local(i),
self.estrutura.matriz_rotacao(i)))
VetorCorrespondenciaIndex =
self.estrutura.vetor_correspondencia(i)
self.MatrizRigidezGlobal[int((VetorCorrespondenciaIndex[j-1, 0])-1),
int((VetorCorrespondenciaIndex[jk-
1, 0])-1)] += MatrizIndex[j-1, jk-1]
self.MatrizRigidezNumeroGrande =
zeros((self.estrutura.Deslocabilidades*self.estrutura.NumeroDeNos,
self.estrutura.Deslocabilidades*self.estrutura.NumeroDeNos))
for i in range(1, (self.estrutura.Deslocabilidades *
self.estrutura.NumeroDeNos)+1):
for j in range(1, (self.estrutura.Deslocabilidades *
self.estrutura.NumeroDeNos)+1):
self.MatrizRigidezNumeroGrande[i-1, j-1] =
self.MatrizRigidezGlobal[i-1, j-1]
self.MatrizRigidezNumeroGrande[self.estrutura.Deslocabilidades*(i-1)+j-1,
self.estrutura.Deslocabilidades*(i-1)+j-1] = \
self.MatrizRigidezNumeroGrande[self.estrutura.Deslocabilidades*(i-1)+j-1,
self.estrutura.Deslocabilidades*(i-1)+j-1] + self.estrutura.NumeroGrande
71
###########################################################################
"""Cálculo dos deslocamentos"""
Deslocamentos = dot(inv(self.MatrizRigidezNumeroGrande),
self.ForcasNodaisNumeroGrande)
return Deslocamentos
def reacoes_apoio(self):
Deslocamentos = self.linear_elastica()
rr = zeros(((self.estrutura.Deslocabilidades *
self.estrutura.NumeroDeNos), 1))
for i in range(1,( self.estrutura.Deslocabilidades *
self.estrutura.NumeroDeNos)+1):
for j in range(1, (self.estrutura.Deslocabilidades *
self.estrutura.NumeroDeNos)+1):
rr[i-1, 0] = rr[i-1, 0] + self.MatrizRigidezGlobal[i-1, j-
1] * Deslocamentos[j-1, 0]
ReacoesDeApoio = zeros((self.estrutura.NumeroDeNos,
self.estrutura.Deslocabilidades))
for i in range(1,self.estrutura.NumeroDeNos+1):
for j in range(1,self.estrutura.Deslocabilidades+1):
if (self.estrutura.CondicoesDeContorno[i - 1, j-1]) == 1:
ReacoesDeApoio[i-1, j-1] =
rr[(self.estrutura.Deslocabilidades * (i - 1) + j)-1, 0] -\
self.ForcasNodaisEquivalentes[(self.estrutura.Deslocabilidades * (i - 1)
+ j) - 1, 0]
ReacoesDeApoio[i - 1, j - 1] -=
self.estrutura.ForcasNodais[i - 1, j-1]
else:
ReacoesDeApoio[i - 1, j-1] = 0
# print("rr {}".format(rr))
return ReacoesDeApoio
def eforcos_solicitantes(self):
self.linear_elastica()
uG = zeros((2*self.estrutura.Deslocabilidades, 1))
EsforcosInternos = zeros((self.estrutura.NumeroDeBarras, 2 *
self.estrutura.Deslocabilidades))
for i in range(1, self.estrutura.NumeroDeBarras+1):
qi = self.estrutura.vetor_correspondencia(i)
print(qi)
for j in range((2 * self.estrutura.Deslocabilidades)):
uG[j, 0] = self.linear_elastica()[(int(qi[j, 0]))-1, 0]
uL = dot(self.estrutura.matriz_rotacao(i), uG)
aLF = (dot(self.estrutura.matriz_rigidez_local(i), uL)) +
self.estrutura.engastamento_perfeito(i)
aGF = dot(self.estrutura.matriz_rotacao(i).T, aLF)
for j in range((2 * self.estrutura.Deslocabilidades)):
EsforcosInternos[i-1, j] = aGF[j, 0]
return EsforcosInternos
72
A.5. Estruturas.py
class Grelha:
self.MatrizDeCoordenadas = MatrizDeCoordenadas
self.MatrizDeConectividade = MatrizDeConectividade
self.NumeroDeNos = self.MatrizDeCoordenadas.shape[0]
self.NumeroDeBarras = self.MatrizDeConectividade.shape[0]
self.ForcasDistribuidas = ForcasDistribuidas
self.ForcasNodais = ForcasNodais
self.CondicoesDeContorno = CondicoesDeContorno
self.G = G
self.E = E
self.J = J
self.I = I
self.Deslocabilidades = 3
self.NumeroGrande = 1E20
return
((((self.MatrizDeCoordenadas[int(self.MatrizDeConectividade[i - 1, 1]) - 1,
0] -
((self.MatrizDeCoordenadas[int(self.MatrizDeConectividade[i - 1, 1]) - 1,
1] -
x[1, 0] = - x[0, 1]
x[1, 1] = x[0, 0]
x[2, 2] = 1
y = 0
w = self.Deslocabilidades * (self.MatrizDeConectividade[i -
1, j - 1] - 1) + jk
x[y - 1, 0] = int(w)
return x