Você está na página 1de 73

INSTITUTO FEDERAL DE EDUCAÇÃO, CIÊNCIA E TECNOLOGIA DE SERGIPE

CAMPUS ARACAJU

DIRETORIA DE ENSINO

COORDENADORIA DE ENGENHARIA CIVIL

CURSO DE BACHARELADO EM ENGENHARIA CIVIL

BRUNO SOUZA MUNIZ

DESENVOLVIMENTO DE PROGRAMA PARA ANÁLISE ESTRUTURAL DE


GRELHAS

MONOGRAFIA

ARACAJU
2018
BRUNO SOUZA MUNIZ

DESENVOLVIMENTO DE PROGRAMA PARA ANÁLISE ESTRUTURAL DE


GRELHAS

Monografia apresentada como requisito parcial à


obtenção do título de Bacharel, da Coordenação do
Curso de Engenharia Civil, do Instituto Federal de
Sergipe – Campus Aracaju.
Orientador: Prof. MSc. Rodolfo Santos da Conceição

ARACAJU
2018
INSTITUTO FEDERAL DE EDUCAÇÃO, CIÊNCIA E TECNOLOGIA DE SERGIPE

CAMPUS ARACAJU

CURSO DE BACHARELADO EM ENGENHARIA CIVIL

TERMO DE APROVAÇÃO

Título da Monografia Nº 110

DESENVOLVIMENTO DE PROGRAMA PARA ANÁLISE ESTRUTURAL DE


GRELHAS

BRUNO SOUZA MUNIZ

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

MUNIZ, Bruno Souza. Desenvolvimento de programa para análise estrutural de grelhas


71 folhas. Monografia (Bacharelado em Engenharia Civil) – Instituto Federal de Educação,
Ciência e Tecnologia de Sergipe – Campus Aracaju. 2018

Os modelos de grelha são normalmente utilizados para representar o comportamento de lajes


de edifícios e tabuleiros de pontes, sendo estudada na maioria dos cursos de graduação. Apesar
disso, existem poucos programas gratuitos que permitem o cálculo de grelhas e estes, por sua
utilização mais complexa, não são atrativos para o aprendizado de estruturas nas matérias de
graduação. O objetivo desse trabalho foi desenvolver um programa de cálculo grelhas de fácil
manipulação utilizando a formulação matricial do método dos deslocamentos e programação
em Python. O programa resolve grelhas independentemente de sua estaticidade, com os dados
de entrada sendo inseridos através de tabelas e as respostas, deslocamentos, esforços e matrizes
de rigidez, apresentadas da mesma maneira. Verifica-se o nítido auxílio na resolução e
verificação dos problemas apresentados nas disciplinas de isostática e hiperestática.

Palavras-chave: Grelhas. Formulação Matricial. Implementação Computacional.


ABSTRACT

MUNIZ, Bruno Souza. Grid’ structural analysis software development. 74 folhas.


Monografia (Bacharelado em Engenharia Civil) – Instituto Federal de Educação, Ciência e
Tecnologia de Sergipe – Campus Aracaju. 2018

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.

Keywords: Grid models. Matrix Formulation. Software development.


LISTA DE ILUSTRAÇÕES

Figura 1 – Níveis de abstração de uma estrutura na análise estrutural 15


Figura 2 – Estrutura real e seu modelo estrutural 16
Figura 3 – Representações dos tipos de elementos estruturais 17
Figura 4 – Grelha hiperestática 22
Figura 5 – Representação das deslocabilidades livres da grelha da Figura 4 23
Figura 6 – Grelha da Figura 4 com as deslocabilidades restringidas 23
Figura 7 – Esforços nodais gerados por carregamentos reais 24
Figura 8 – Esforços gerados para um deslocamento unitário vertical no nó central 24
Figura 9 – Matrizes necessárias para o desenvolvimento das matrizes de rigidez e do vetor de
forças no referencial global 25
Figura 10 – Estrutura hiperestática 26
Figura 11 – Deslocabilidades nodais da estrutura da Figura 10 27
Figura 12 – Exemplo de grelha formada por duas barras e as suas deslocabilidades 28
Figura 13 – esforços de engastamento perfeito. 29
Figura 14 – Vetor V e suas componentes cartesianas 30
Figura 15 – Transformação das forças do eixo X’Y’Z’ para o eixo XYZ 32
Figura 16 – Referencial adotado para elaboração da matriz de rigidez de uma barra de grelha
33
Figura 17 – Exemplo de estrutura de criação de um objeto a partir de uma classe 35
Figura 18 – Exemplo de desenho elaborado no Matplotlib 36
Figura 19 – Estrutura básica do programa GrelhaPy 39
Figura 20 – Sequência de Análise do Programa GrelhaPy 40
Figura 21 – Problema Proposto 01 – Grelha isostática 41
Figura 22 – Discretização da Grelha do Problema Proposto 01 41
Figura 23 – Tela demonstrando a inserção das características da estrutura no programa 43
Figura 24 – Tela demonstrando a apresentação das reações de apoio no programa 43
Figura 25 – Tela demonstrando a apresentação dos esforços internos no programa 44
Figura 26 – Problema Proposto 02 – Grelha hiperestática 45
Figura 27- Discretização da Grelha para solução manual do Problema Proposto 02 45
Figura 28- Deslocabilidades livres da grelha do Problema Proposto 02 46
Figura 29 – Discretização da grelha para solução numérica do Problema Proposto 02 49
Figura 30 – Tela de apresentação das reações de apoio da grelha do Problema Proposto 02 50
Figura 31 – Matriz de Rigidez do Problema Proposto 02 51
LISTA DE TABELAS

Tabela 1 – Reações de apoio obtidas através das equações da estática .................................... 42


Tabela 2 – Esforços solicitantes nas extremidades das barras obtidos através das equações da
estática .............................................................................................................................. 42
Tabela 3 – Reações de apoio da grelha do Problema Proposto 01 calculadas através do programa
.......................................................................................................................................... 44
Tabela 4 - Esforços solicitantes nas extremidades das barras da grelha do Problema Proposto
01 obtidos através do programa ........................................................................................ 44
Tabela 5 – Ações nodais reais causadas pela força concentrada na Barra 1 ............................ 46
Tabela 6 – Ações nodais reais causadas pela força distribuída na Barra 2 .............................. 46
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 .............................................................................. 47
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 .............................................................................. 47
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 .............................................................................. 47
Tabela 10 – Coeficientes de rigidez obtidos através da consideração de uma rotação unitária na
direção D2 na extremidade da Barra 2 .............................................................................. 47
Tabela 11 – Coeficientes de rigidez obtidos através da consideração de um deslocamento
transversal unitário na direção D3 na extremidade da Barra 1 ......................................... 48
Tabela 12 - Coeficientes de rigidez obtidos através da consideração de um deslocamento
transversal unitário na direção D3 na extremidade da Barra 2 ......................................... 48
Tabela 13 – Reações de apoio obtidas através do desenvolvimento manual do método dos
deslocamentos................................................................................................................... 48
Tabela 14 – Esforços solicitantes nas extremidades das barras obtidos através do
desenvolvimento manual do método dos deslocamentos ................................................. 49
Tabela 15 – Reações de apoio da grelha do Problema Proposto 02 obtidas através do programa
.......................................................................................................................................... 49
Tabela 16 – Esforços internos da grelha do Problema Proposto 02 obtidos através do programa.
.......................................................................................................................................... 49
SUMÁRIO

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

Dentro os métodos de análise estrutural, dois se destacam: O método das forças e o


método dos deslocamentos. Com estes métodos é possível obter informações do
comportamento das estruturas, quando da imposição de carregamentos de origens diversas,
através de sistemáticas, em etapas que analisam os seus elementos constituintes de forma
discreta, levando em conta as condições de equilíbrio, compatibilidade e características dos
materiais constituintes.

Com o desenvolvimento acelerado do poder de processamento dos computadores nas


últimas décadas, esses métodos de análise foram potencializados através de implementações
computacionais, garantindo uma maior assertividade e capacidade na análise de estruturas.

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.

É observado, porém, que quando se trata da análise de modelos de grelha, há uma


pequena quantidade de programas gratuitos e de simples utilização, tornando a análise
computacional desse tipo de estrutura mais complicada.

O comportamento de lajes de edifícios e tabuleiros de pontes pode ser analisado através


da analogia de grelha, desenvolvendo modelos estruturais de grelha com características
geométricas e físicas e condições de contorno de forma a representar as lajes e tabuleiros,
facilitando sua análise em comparação à implementação de métodos mais complexos como o
Método dos Elementos Finitos. Isto evidencia a importância do estudo e da análise de grelhas,
13

consequentemente ratificando a necessidade de um programa gratuito que permita, de forma


simples, a análise destas estruturas.

1.1 OBJETIVOS

Em virtude da carência de programas gratuitos que propiciem a análise de grelhas, esse


trabalho propõe o desenvolvimento de uma ferramenta computacional para cálculo de grelhas,
utilizando a formulação matricial do método dos deslocamentos, norteando-se principalmente
na forma apresentada por Soriano (2005), e linguagem de alto nível.

1.1.1 Objetivos Específicos

 Desenvolvimento de um programa que permita execução de análise linear estática de


grelhas, com consideração de carregamento concentrados e distribuídos, seção transversal
constante ao longo da barra e apoios restritivos;

 Desenvolvimento de interface gráfica simples que propicie fácil inserção de dados e


fácil leitura dos resultados.

1.2 METODOLOGIA

O desenvolvimento deste trabalho partiu primordialmente da análise dos objetivos do


programa idealizado e da escolha dos recursos a serem utilizados, seguido da criação de rotinas
que permitissem a leitura de variáveis contendo as informações de inserção sobre a estrutura e
gerassem os valores das matrizes de rigidez, dos deslocamentos nodais, os esforços internos nas
extremidades das barras e as reações de apoio. Posteriormente foi elaborada uma interface
gráfica com o intuito de facilitar a inserção e a leitura dos dados. Finalmente, visando a
validação, estruturas resolvidas manualmente foram calculadas através do programa, tendo os
resultados de ambos métodos comparados.

Em suma, o desenvolvimento do trabalho seguiu a seguinte sistemática:

a) Escolha da linguagem de programação, ambiente de desenvolvimento e


framework para desenvolvimento da interface gráfica;

b) Desenvolvimento do algoritmo que implementa o método dos deslocamentos,


em sua formulação matricial para grelhas;

c) Implementação dos algoritmos em rotinas na linguagem de programação;


14

d) Desenvolvimento da interface gráfica;

e) Integração da interface com as rotinas de cálculo de grelhas;

f) Validação do programa.
15

2 ANÁLISE ESTRUTURAL

A análise estrutural é a etapa componente do projeto estrutural em que se visa prever


certos comportamentos da estrutura, como deslocamentos, esforços internos e reações de
equilíbrio, considerando suas características geométricas e físicas e condições de apoio, quando
submetida à ação de carregamentos diversos. Desse modo, a segurança da estrutura pode ser
garantida, já que são aferidas as influências de todos os possíveis agentes no seu equilíbrio e
segurança.

2.1 PRINCÍPIOS DA 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.

Figura 1 – Níveis de abstração de uma estrutura na análise estrutural

Fonte: adaptado de MARTHA (2010)

A Estrutura Real é o nível em que não há idealização do comportamento estrutural.


Assim, a estrutura está sujeita a ações oriundas do seu peso próprio, do peso de corpos externos,
da influência do vento, das suas imperfeições geométricas e demais ações. Essas ações geram
variados esforços em todo o corpo da estrutura, de tal forma que a distribuição interna desses
esforços depende das condições geométricas da estrutura e das características dos seus materiais
constituintes. Dessa maneira, a análise nesse nível torna-se muito complexa, devido à
impossibilidade da reprodução de todos os fatores determinantes dos esforços, gerando a
necessidade da elaboração de modelos que simplifiquem seus comportamentos e características.

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).

Figura 2 – Estrutura real e seu modelo estrutural

Fonte: MARTHA (2010)

O Modelo Discreto é o nível de abstração referente a cada método de análise. Logo,


cada método adota os seus parâmetros, dentro das considerações básicas, para o cálculo da
estrutura. O método das forças, por exemplo, adota como parâmetros as forças superabundantes
à determinação estática da estrutura, que são encontradas através da resolução de equações de
compatibilidade, enquanto o método dos deslocamentos adota deslocamentos em pontos nodais
devidamente escolhidos e que são obtidos através de equações de equilíbrio (Soriano, 2004).

O Modelo Computacional é o nível através do qual ocorre a implementação


computacional dos métodos de análise de estruturas. Isso permite utilizar do alto poder de
processamento das máquinas atuais, até mesmo de computadores pessoais, para execução de
cálculos envolvendo uma grande quantidade de informações, possibilitando análise de
estruturas mais complexas e em um intervalo de tempo significativamente menor que através
da análise com cálculos manuais. Os métodos computacionais utilizam-se da parametrização
das componentes de análise em matrizes e são estruturalmente divididos em três etapas, nas
quais ocorrem a inserção dos dados referentes à geometria, características do material e ações
que influem na estrutura; seguida das rotinas de análise e subsequente apresentação dos
resultados (Soriano, 2004).
17

2.2 ESTRUTURAS RETICULADAS

Dentro da análise estrutural, podemos discriminar os elementos básicos constituintes de


uma estrutura em três categorias básicas: a dos elementos que possuem uma dimensão
preponderante em relação às demais dimensões, denominados barras, e que podem ser
exemplificadas pelas vigas, pilares, escoras, tirantes etc.; a dos elementos que possuem duas
dimensões preponderantes, denominados elementos de superfície, a exemplo das lajes; e a dos
elementos que não possuem nenhuma dimensão preponderante, que podem ser exemplificados
pelos blocos. A Figura 3 representa estes elementos.

Figura 3 – Representações dos tipos de elementos estruturais

Fonte: O autor (2018)

É costumeiro, pela simplificação de cálculo, que o modelo estrutural seja desenvolvido


a partir de estruturas de barras, respeitando parâmetros que validem essa simplificação. Ao
modelo estrutural constituído por barras é dado o nome de estrutura reticulada.

A análise de estruturas através da representação de estruturas reticuladas parte da


discretização dos seus elementos mais básicos, as barras, em uma análise local, de tal forma
que, posteriormente, a estrutura possa ser analisada como um todo. Dessa forma, algumas
considerações devem ser ponderadas em relação às barras.

Os elementos de barras são idealizados como a trajetória do centro geométrico da figura


plana que forma sua seção transversal, delimitados externamente por pontos nodais. Isso parte
da consideração que a seção transversal da barra continue plana após a aplicação de ações
externas e ainda que a seção transversal pode ser variável ao longo do comprimento da barra.
Além disso, para facilitar a análise, pontos nodais podem ser considerados internamente nas
barras, não afetando os resultados (Soriano, 2004).

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.

As vigas são elementos dispostos sequencialmente em linha reta horizontal, sob


carregamentos atuantes no plano vertical, de maneira que desenvolva apenas o momento fletor
de vetor representativo normal a esse plano, o esforço cortante e o esforço normal.

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.

As definições de treliças planas e espaciais são similares aos pórticos, excetuando-se


pelas particularidades de seus elementos possuírem extremidades rotuladas e dos
carregamentos serem aplicados apenas nos nós de ligação, assim, torna-se possível apenas o
desenvolvimento de esforços normais em todos elementos.

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

2.3 PRINCÍPIO DOS TRABALHOS VIRTUAIS

Os métodos de análises de estruturas comumente utilizados envolvem a imposição de


forças ou deslocamentos virtuais. Esse artifício é utilizado para criar equações complementares
que, em conjunto com as informações inicialmente estabelecidas sobre a estrutura, serão
resolvidas através de equações de compatibilidade ou equações de equilíbrio, fornecendo
deslocamentos e/ou esforços.

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.

Em corpos flexíveis em equilíbrio, existe uma condição relativa à transferência da


energia gerada pela aplicação de ações externas, de tal forma que a soma algébrica do trabalho
referente às forças externas reais é igual à soma algébrica do trabalho exercido pelos seus
respectivos esforços internos. Então, na aplicação de uma força ou deslocamento virtual, essa
condição se mantém, ou seja, a soma algébrica do trabalho gerado pelas forças ou
deslocamentos virtuais externos é igual à soma algébrica do trabalho exercido pelos seus
respectivos esforços internos.

Se considerarmos a linearidade física e geométrica da estrutura, podemos utilizar da


superposição de efeitos, de tal forma que, considerando uma barra de uma grelha qualquer, o
trabalho gerado pelos esforços internos pode ser dado pela equação (1):

U = ∫ M 𝑑𝜑 + ∫ T 𝑑𝜃 + ∫ Q 𝑑𝜆 (1)

Onde ∫ M 𝑑𝜑 , ∫ T 𝑑𝜃 e ∫ Q 𝑑𝜆 são, respectivamente, as parcelas do trabalho relativas


ao momento fletor, momento torsor e ao esforço cortante desenvolvidos no elemento.

Na aplicação de uma força virtual e na consideração da igualdade entre o trabalho virtual


externo e o trabalho dos esforços internos, obtemos:

𝐹. ̅ 𝑑𝜑 + ∫ 𝑇̅ 𝑑𝜃 + ∫ 𝑄̅ 𝑑𝜆
̅ 𝑑 = ∫𝑀 (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.

Dessa forma, podemos desenvolver a equação (2) de forma a aplicar os conceitos da


resistência dos materiais para cálculo dos deslocamentos e rotações em barras, obtendo:

1 1 1
̅𝑑=
𝐹. ̅ 𝑀 𝑑𝑥 +
∫𝑀 ∫ 𝑇̅ 𝑇 𝑑𝑥 + ∫ 𝑄̅ 𝑄 𝑑𝑥 (3)
𝐸𝐼 𝐺𝐽 𝐺 𝐴𝑄

Onde E corresponde ao módulo de elasticidade longitudinal, G ao módulo de


elasticidade transversal, I ao momento de inércia longitudinal, J ao momento de inércia
transversal e AQ à área efetiva de cisalhamento.

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)
𝐸𝐼 𝐺𝐽 𝐺 𝐴𝑄

Na consideração do trabalho virtual externo, também podemos encontrar as reações de


apoio e os esforços seccionais ao impor um deslocamento unitário, de forma análoga ao
apresentado no princípio das forças virtuais, na direção das forças preteridas. Assim, da equação
(1) podemos obter as equações (5) e (6), que representam o princípio dos deslocamentos
virtuais.

̅̅̅̅ + ∫ T 𝑑𝜃
̅ . F = ∫ M 𝑑𝜑
𝐷 ̅̅̅̅ + ∫ Q 𝑑𝜆
̅̅̅̅ (5)

1 . F = ∫ M ̅̅̅̅
𝑑𝜑 + ∫ T ̅̅
𝑑𝜃̅̅ + ∫ Q ̅𝑑𝜆
̅̅̅ (6)

̅ é o deslocamento virtual imposto e ̅̅̅̅


Onde 𝐷 𝑑𝜑, ̅̅̅̅ e ̅𝑑𝜆
𝑑𝜃 ̅̅̅ são os deslocamentos virtuais
internos compatíveis com o deslocamento virtual externo.

2.4 MÉTODO DAS FORÇAS

O método aplicado na análise de uma estrutura é imperiosamente determinado pelos


seus vínculos externos e internos. No caso de uma estrutura isostática, as equações de equilíbrio
21

da estática são suficientes para determinação desses vínculos. Em contraponto, as estruturas


hiperestáticas possuem configurações de vínculo que excedem o calculável por essas equações,
o que define o seu grau de indeterminação estática, necessitando de métodos mais elaborados
de cálculo.

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.

A retirada de vínculos implica na necessidade do cálculo de esforços que os substituam,


restabelecendo as condições iniciais de compatibilidade. Isso implica que as incógnitas
estabelecidas no sistema principal devem atender às condições originais de deslocamento dos
vínculos substituídos. Além disso, o procedimento do método passa pela análise das incógnitas
de forma isolada, onde são aferidas suas influências nas suas condições de deformação e nas
demais, nos determinados casos básicos (Martha, 2010).

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.

Calculados os deslocamentos, as condições de compatibilidade são restabelecidas


através da utilização da sobreposição de efeitos, culminando na descoberta dos valores das
incógnitas e permitindo o cálculo da estrutura original.
22

2.5 MÉTODO DOS DESLOCAMENTOS

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.

2.5.1 Sistemática do método dos deslocamentos

A primeira etapa visa obter o sistema cinematicamente determinado. Todas as


deslocabilidades livres da estrutura são restringidas, permitindo o cálculo dos deslocamentos
de forma local. As Figuras 4 e 5 demonstram, respectivamente, uma grelha hiperestática e suas
deslocabilidades livres, enquanto a Figura 6 mostra o sistema hipergeométrico.

Figura 4 – Grelha hiperestática

Fonte: O autor (2018)


23

Figura 5 – Representação das deslocabilidades livres da grelha da Figura 4

Fonte: O autor (2018)

Figura 6 – Grelha da Figura 4 com as deslocabilidades restringidas

Fonte: O autor (2018)

Em seguida, ocorrem as análises dos casos básicos, onde se consideram os esforços


gerados pela imposição de deslocamentos unitários na direção das deslocabilidades, que são
analisadas isoladamente, e análises dos carregamentos reais. Para a obtenção dos esforços
gerados pelos carregamentos reais, são utilizados os esforços de engastamento perfeito, que
podem ser calculados em casos básicos através das equações da linha elástica, princípio dos
trabalhos virtuais ou mesmo pelo método das forças. Já os esforços gerados pela imposição de
deslocamentos e rotações unitárias podem ser calculados através dos coeficientes de rigidez,
que variam de acordo com as condições de contorno da barra que está sendo analisada, assim
como pelas características das seções e dos materiais constituintes.

A Figura 7 mostra os esforços a serem calculados pelos carregamentos reais na estrutura


da Figura 4. Já a Figura 8 mostra os coeficientes de rigidez que devem ser obtidos.
24

Figura 7 – Esforços nodais gerados por carregamentos reais

Fonte: O autor (2018)

Figura 8 – Esforços gerados para um deslocamento unitário vertical no nó central

Fonte: O autor (2018)

A segunda etapa parte do restabelecimento das condições de equilíbrio, onde é utilizada


a superposição de efeitos. Todos os esforços previamente estabelecidos serão impostos, a nível
nodal, às condições de equilíbrio da estática. Ou seja, existirá uma equação para cada
deslocabilidade, em número igual aos deslocamentos ainda indeterminados. Sendo então
possível o cálculo desses deslocamentos.

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

2.6 ANÁLISE MATRICIAL

O desenvolvimento do cálculo estrutural através da formulação matricial visa,


primeiramente, estabelecer um sistema de equações que determinará os deslocamentos nodais,
nas direções das deslocabilidades e em sentidos preestabelecidos, o que é feito através do
desenvolvimento do sistema linear representado pela equação (7), em sua forma matricial, para
o cálculo posterior das reações de apoio e dos esforços solicitantes internos.

𝑑 = 𝐾 −1 𝑓 (7)

onde K -1 corresponde à inversa da matriz de rigidez global e f corresponde ao vetor de forças


nodais global e d ao vetor dos deslocamentos nodais.

Dessa maneira, as operações iniciais visam definir as matrizes que determinam as


informações básicas da estrutura, relativas às suas características geométricas e físicas, das suas
condições de contorno e das ações externas à qual a estrutura está submetida. Essas matrizes
viabilizam o desenvolvimento das matrizes de rigidez global e o vetor de força global, como
esquematizado na Figura 9.

O ponto primordial para a construção da matriz de rigidez global advém da necessidade


da mesma ser uma matriz não singular, o que define que existe somente uma resolução para a
equação (7), logo, somente um vetor de deslocamentos é possível. Assim, o que torna a matriz
de rigidez não singular são as definições das condições de contorno, que, através do método do
número grande, por exemplo, atribui rigidezes de ordem numérica muito maior que as demais
rigidezes nas direções das deslocabilidades prescritas.

Figura 9 – Matrizes necessárias para o desenvolvimento das matrizes de rigidez e do vetor de forças no
referencial global

Matriz de Vetor de forças no


rigidez global 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

2.6.1 Desenvolvimento da matriz de rigidez global.

A matriz de rigidez global é formada por todos os coeficientes de rigidez de uma


estrutura. Logo, ela é uma matriz quadrada de ordem igual a quantidade de nós de uma estrutura
multiplicada pela quantidade de deslocabilidades por nó.

Para simplificação das operações do método, a estrutura é discretizada em barras, isso


permite que sejam desenvolvidas matrizes de rigidez das barras, em um referencial local, para
posteriormente serem transformadas para o referencial global e serem acopladas, formando a
matriz de rigidez global.

Como exemplo, na consideração de todas as deslocabilidades, livres e prescritas,


podemos determinar que as barras da Figura 10 podem ser discretizadas, em referenciais locais
como apresentado na Figura 11. Assim, Dnb representa a deslocabilidade n referente à barra b,
que apresenta referencial Xb, Yb, Zb. Com a imposição de forças e rotações unitárias, podemos
obter os coeficientes de rigidez na direção de cada deslocabilidade, quando da imposição de
cada um dos deslocamentos unitários. A esses coeficientes de rigidez podemos adotar a notação
kijb que representa o coeficiente de rigidez na direção da deslocabilidade i da Barra 2 quando o
deslocamento j é imposto unitário. Logo, podemos obter as matrizes de rigidez locais das barras
da estrutura da Figura 10, representadas nas equações (8) e (9).

Figura 10 – Estrutura hiperestática

Fonte: O autor (2018)


27

Figura 11 – Deslocabilidades nodais da estrutura da Figura 10

Fonte: O autor (2018)

𝐾111 𝐾121 𝐾131 𝐾141 𝐾151 𝐾161


. 𝐾221 𝐾231 𝐾241 𝐾251 𝐾261
. . 𝐾331 𝐾341 𝐾351 𝐾361
𝐾1 = (8)
. . . 𝐾441 𝐾451 𝐾461
. . . . 𝐾551 𝐾561
𝑠𝑖𝑚. . .
[ . . 𝐾661 ]

𝐾11 2 𝐾12 2 𝐾13 2 𝐾14 2 𝐾15 2 𝐾16 2


. 𝐾22 2 𝐾23 2 𝐾24 2 𝐾25 2 𝐾26 2
. . 𝐾33 2 𝐾34 2 𝐾35 2 𝐾36 2
𝐾2 = (9)
. . . 𝐾44 2 𝐾45 2 𝐾46 2
. . . . 𝐾55 2 𝐾56 2
𝑠𝑖𝑚. . .
[ . . 𝐾66 2 ]

Com o estabelecimento das matrizes de rigidez locais, é necessário realizar o


acoplamento dessas matrizes, transpondo os coeficientes de rigidez dos referenciais locais para
o referencial global. Isso pode ser alcançado através da transformação para o referencial global
com as matrizes de rotação e o correto acoplamento proporcionado por vetores de
correspondência das deslocabilidades, que atribuem identificações de ordem global às
deslocabilidades dos nós da estrutura.

Logo, adotando o referencial global apresentado na Figura 12 e as matrizes globais


apresentadas nas equações (3) e (4), a matriz de rigidez global da estrutura da Figura 10 deverá
ter o formato apresentado na equação (10).
28

Figura 12 – Exemplo de grelha formada por duas barras e as suas deslocabilidades

Fonte: O autor (2018)

𝐾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.

Considerando as condições de contorno da Figura 10, a matriz de rigidez global após a


aplicação da técnica do número grande possui essa forma:

𝐾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.6.2 Desenvolvimento do Vetor de Forças globais

Assim como na definição da matriz de rigidez no referencial global, a parte inicial


consiste na discretização das barras em um referencial local. Logo, as ações externas são
discriminadas em forças concentradas e forças distribuídas. Estas últimas precisam ser
transformadas em forças concentradas nas extremidades das barras, já que o vetor de forças é
desenvolvido em função das forças concentradas nos nós limitantes das barras, e isso é
alcançado através dos esforços de engastamento perfeito.

Considerando a Barra 2 de grelha da Figura 12, de comprimento L, sob efeito de uma


força concentrada no nó 2 de valor P e uma carga distribuída de valor Q, podemos aplicar os
esforços de engastamento para obter o resultado da Figura 13.

Figura 13 – esforços de engastamento perfeito.

Fonte: O autor (2018)

Considerando que os esforços de engastamento perfeito nos permite obter as forças


reativas de equilíbrio das barras, podemos obter as forças nodais gerada pelas ações externas
através da mudança do sentido das forças. Desse modo, podemos obter os vetores de forças
nodais das duas barras, em seus referenciais locais:

𝑃𝐿2
− 2
0 0
𝑃𝐿 0
−2
𝑓𝑏1 = 𝑃𝐿2
𝑓𝑏2 = 0 (12)
0
2 0
0 {0}
𝑃𝐿
{− 2 }
30

Transformando-as para o referencial global através da matriz de rotação e considerando


os efeitos das forças externa originalmente concentradas, podemos obter o vetor de forças
global.

𝑃𝐿2
− +0
2
0+0
𝑃𝐿
− 2 +0
0
𝑓= 0 (13)
0
𝑃𝐿2
2
0
𝑃𝐿
{ −2 }

2.6.3 Matrizes de rotação

A recorrente transformação de referenciais adotado na construção da matriz de rigidez


global e no vetor de forças nodais global ocorre através da utilização de matrizes de rotação. Já
que todas as barras são trabalhadas inicialmente em um referencial local, todas necessitam de
uma matriz de rotação.

Considerando o vetor V da Figura 14 e suas componentes no eixo XY, podemos obter


suas componentes no eixo X’Y’ dessa forma:

𝑉𝑥 ′ = 𝑉𝑥 𝑐𝑜𝑠 𝛼 + 𝑉𝑦 𝑠𝑒𝑛 𝛼
{ (14)
𝑉𝑦′ = −𝑉𝑥 𝑠𝑒𝑛 𝛼 + 𝑉𝑦 𝑐𝑜𝑠 𝛼

Figura 14 – Vetor V e suas componentes cartesianas

Fonte: O autor (2018)


31

Em forma matricial o sistema da equação (14) pode ser escrito dessa forma:

𝑉𝑥 ′ 𝑐𝑜𝑠 𝛼 𝑠𝑒𝑛 𝛼 𝑉𝑥
{𝑉 } = [ ]{ } (15)
𝑦′ −𝑠𝑒𝑛 𝛼 𝑐𝑜𝑠 𝛼 𝑉𝑦

Assim podemos determinar a matriz de rotação do vetor V como:


𝑐𝑜𝑠 𝛼 𝑠𝑒𝑛 𝛼
𝑅= [ ] (16)
−𝑠𝑒𝑛 𝛼 𝑐𝑜𝑠 𝛼

Analogamente, considerando a transformação das forças da barra apresentada na Figura


14, do referencial local X’Y’Z’ para o referencial global XYZ, na observância do paralelismo
dos eixos Z’ e Z, podemos determinar que:

𝑓 ′ = 𝑅. 𝑓 (17)

𝐹′1 𝑐𝑜𝑠 𝛼 𝑠𝑒𝑛 𝛼 0 0 0 0 𝐹1


𝐹′2 −𝑠𝑒𝑛 𝛼 𝑐𝑜𝑠 𝛼 0 0 0 0 𝐹2
𝐹′3 0 0 1 0 0 0 𝐹3
= (18)
𝐹′4 0 0 0 𝑐𝑜𝑠 𝛼 𝑠𝑒𝑛 𝛼 0 𝐹4
𝐹′5 0 0 0 −𝑠𝑒𝑛 𝛼 𝑐𝑜𝑠 𝛼 0 𝐹5
[ 0 0 0 0 0 1 ] {𝐹6 }
{𝐹′6 }

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)

Onde D é o vetor deslocamentos no referencial global e D’ é o vetor deslocamentos no


referencial local.

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)

A Figura 15 apresenta a transformação do sistema local para o sistema global de


carregamentos reais aplicados à estrutura.

Figura 15 – Transformação das forças do eixo X’Y’Z’ para o eixo XYZ

Fonte: O autor (2018)

2.6.4 Cálculo das Reações de Apoio e dos Esforços Solicitantes Internos

A aplicação da técnica do número grande implica na grande rigidez na direção das


deslocabilidades restringidas, logo, os deslocamentos nas direções das deslocabilidades
restringidas tornam-se relativamente nulos. Dessa forma, primeiramente, é possível calcular os
esforços externos nas direções das deslocabilidades no referencial global modificando a
equação (7):

𝑓 = 𝐾. 𝑑 (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

2.6.5 Matriz de Rigidez de Elemento de Grelha

Para a implementação computacional do método dos deslocamentos, é necessária a


elaboração de um modelo da matriz de rigidez de um elemento de grelha. A Figura 16 mostra
a ordem e direções dos graus de liberdade adotados para elaboração da matriz de rigidez local
do elemento de grelha.

Figura 16 – Referencial adotado para elaboração da matriz de rigidez de uma barra de grelha

Fonte: O autor (2018)

Considerando o referencial adotado, e utilizando os conceitos da Resistência dos


Materiais para o cálculo das deformações e rigidezes associadas, a matriz de rigidez do
elemento de grelha resulta em:

𝐺𝐽/𝐿 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

3 PROGRAMAÇÃO APLICADA À ENGENHARIA

O desenvolvimento do poder de processamento dos computadores nas últimas décadas,


somado ao consequente desenvolvimento das linguagens de programação, propiciou, de forma
acessível, o desenvolvimento de ferramentas poderosas para aplicação na engenharia.
Programas como Matlab e pacotes como o Matplotlib e Numpy, para Python, fornecem
ferramentas para desenvolvimento de operações com matrizes e construção de gráficos,
facilitando o desenvolvimento de rotinas e programas mais complexos voltados para
engenharia.

A programação de computadores tem por objetivo elaborar instruções de procedimentos


a serem executados, normalmente, de forma recursiva, com o intuito de desempenhar funções
e realizar cálculos de forma automatizada. Isso ocorre através de linguagens de programação,
que, em alto nível, dispõem de instruções que serão interpretadas a um nível mais próximo ao
trabalhado pelos componentes físicos do computador (hardwares), facilitando o
desenvolvimento de programas. Ademais, as linguagens de script permitem o desenvolvimento
de sequências de instruções, ou algoritmos, simultaneamente, de tal forma que instruções mais
complexas podem ser elaboradas.

3.1 PROGRAMAÇÃO DIRECIONADA A OBJETOS

O paradigma da programação direcionada a objetos, diferentemente do paradigma


imperativo, onde as instruções do algoritmo se dão de forma sequencial, tem por objetivo a
criação de conjuntos de dados, chamados objetos, que podem ser dotados de funcionalidades,
chamadas de métodos, visando criar códigos mais concisos, com maior manutenibilidade e mais
fáceis de se compreender.

A estrutura básica de um algoritmo voltado a objetos visa a definição de classes, que


determinarão todas as propriedades e métodos de um objeto pertencente à mesma. Assim, na
criação de um objeto, precisamos definir qual a classe do objeto que estamos criando, a fim de
determinar suas propriedades e métodos básicos. Por exemplo, podemos definir a classe
EstruturaReticulada2d determinando propriedades necessárias de quantidade e coordenadas
dos nós, assim como a quantidade de barras e os nós limitantes das barras. Logo, podemos criar
o objeto Grelha, pertencente à classe EstruturaReticulada2d, e ele terá as mesmas
35

propriedades necessárias, além das novas propriedades que lhe podem ser atribuídas, como
demonstrado na Figura 17.

Figura 17 – Exemplo de estrutura de criação de um objeto a partir de uma classe

Classe EstruturaReticulada2d

Coordenadas dos Quantidade de Nós delimitantes


Quantidade de nós
nós barras das barras

Grelha
Nós
Quantidade de Coordenadas Quantidade de Novas
delimitantes
nós dos nós barras propriedades
das barras

Fonte: O autor (2018)

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.

Outro recurso importante da programação direcionada a objetos é a Hierarquia, com a


qual é possível criar uma classe, chamada de subclasse, com propriedades de outra classe,
chamada de superclasse. Ainda assim, novas propriedades e funcionalidades podem ser criadas
ou podem substituir as originárias da superclasse. Esse artifício diminui ainda mais a quantidade
de códigos necessários para a criação de novos objetos.

3.2 PROGRAMAÇÃO EM PYTHON

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

A comparação com o Matlab, programa que possui linguagem própria, normalmente


utilizado no ambiente científico, evidencia algumas vantagens do Python:

a) O Python é uma linguagem de utilização gratuita, assim como os pacotes que


implementam as funções de computação científica, diferentemente do Matlab,
que necessita do pagamento de uma assinatura;
b) A escrita do Python é mais limpa que a da Linguagem do Matlab, propiciando
maior produtividade e entendimento do código;
c) Possui pacotes para desenvolvimento de interfaces gráficas mais poderosos que
o Guide do Matlab, além de possibilitar o desenvolvimento de aplicações de
tamanho menor.

3.2.1 Pacotes de terceiros

Com o intuito de ampliar as funcionalidades básicas do Python, existem diversos


pacotes gratuitos de terceiros que disponibilizam diversas classes e métodos que podem
propiciar uma resolução mais refinada de alguns problemas. No meio científico, alguns dos
pacotes mais utilizados são o Numpy e o Matplotlib. O primeiro permite o trabalho com
matrizes e vetores de uma forma mais simples, disponibilizando métodos para declaração de
matrizes nulas, matrizes identidade, assim como para operações com matrizes e modificação
dos seus elementos. O segundo pacote tem por objetivo propiciar métodos para elaboração de
gráficos e desenhos 3D e 2D (Figura 18), além de ser integrado com o pacote Numpy.

Figura 18 – Exemplo de desenho elaborado no Matplotlib

Fonte: O autor (2018)


37

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.

3.2.2 Desenvolvimento de Interfaces Gráficas

O desenvolvimento de interfaces gráficas para usuários (GUI) visa facilitar a leitura e


inserção de dados por usuários de programas. Para isso são necessárias ferramentas que
permitam a construção e integração dos arquivos que executam as análises dos programas com
objetos de interface gráfica, além da construção dos próprios objetos da interface. O Python
possui módulo nativo chamado Tkinter, ele fornece a possibilidade de criação de interfaces
gráficas, entretanto, não fornece tantas possibilidades para desenvolvimento quanto as
proporcionadas por pacotes de terceiros.

Dentre os pacotes de terceiros voltados para o desenvolvimento de GUI’s está o PyQt.


Este propicia o uso da vasta quantidade de objetos do Qt, originalmente feito para a linguagem
C++, para Python, possibilitando a criação de GUI’s complexas, além de poder integrar as
funcionalidades do Numpy e os desenhos e gráficos gerados pelo Matplotlib.
38

4 DESENVOLVIMENTO DO PROGRAMA

As considerações iniciais para o desenvolvimento do programa foram relativas aos


recursos a serem implementados, assim, estes foram elencados para estabelecer parâmetros que
permeariam a escolha da linguagem de programação e do framework a ser utilizado para
desenvolvimento da interface gráfica. Dessa maneira, foi estabelecido que a inserção dos dados
a serem trabalhados, assim como os resultados apresentados se dariam através da
implementação de tabelas, o que facilitaria a visualização de informações de forma mais ampla,
além de facilitar a implementação da interface.

Outro fator decisivo na escolha da linguagem de programação foi a implementação da


formulação matricial do método dos deslocamentos, o que exigia uma linguagem que permitisse
o trabalho com matrizes e a execução das operações empregadas no método.

Em vista disso, foi escolhida a linguagem de programação Python. Ela possibilitou o


trabalho com matrizes de forma simples, além de permitir o desenvolvimento de uma interface
gráfica que atendia aos parâmetros preestabelecidos.

Dada a escolha da linguagem de programação Python e do objetivo principal do


programa ser o cálculo de estruturas de grelha, o mesmo foi denominado de GrelhaPy.

4.1 ESCOPO GERAL DO PROGRAMA

O desenvolvimento do programa foi dividido em rotinas de cálculo, que implementam


a formulação matricial do método dos deslocamentos e as rotinas responsáveis pela construção
da interface gráfica (Figura 19). As primeiras adotam a programação direcionada a objetos,
implementando uma classe de análise estrutural, que integram as operações para obter os
deslocamentos, reações de apoio e os esforços solicitantes internos, e uma classe de grelha, que
integra as características geométricas, de materiais da estrutura e possui métodos para
desenvolvimento das matrizes de rigidez da barra e dos vetores de forças nodais. Essa estrutura
favorece implementações futuras de outros modelos estruturais e outros métodos de análise. As
rotinas voltadas para o desenvolvimento da interface gráfica contêm as diretrizes para criação
das páginas, limitações para inserção de dados e métodos para transformação dos dados
inseridos em matrizes que podem ser analisadas através das rotinas de análise.
39

Figura 19 – Estrutura básica do programa GrelhaPy


Programa
GrelhaPy

Rotinas de cálculo Interface gráfica

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

Dados de materiais Reações de apoio

Esforços solicitantes
Forças concentradas
nas extremidades
e distribuídas
das barras

Fonte: O autor (2018)

4.2 FORMULAÇÃO MATRICIAL APLICADA NO CÁLCULO ESTRUTURAL DE


ESTRUTURAS DE GRELHAS

A implementação da formulação matricial em rotinas de programação visa automatizar


a metodologia de desenvolvimento do método matricial de forma que os resultados pretendidos
da análise sejam obtidos a partir da inserção das informações essenciais sobre a estrutura.

A elaboração das rotinas de cálculo passa pela definição de variáveis contendo as


informações básicas da estrutura, definição de funções que permitem obter dados de elementos
da estrutura através das informações básicas e sub-rotinas que fornecem os resultados da
análise.

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.

A matriz de conectividade e a função vetor de correspondência tem por objetivo


correlacionar as barras, nós e suas respectivas deslocabilidades. Assim, as deslocabilidades,
rigidezes e forças podem ser descriminadas em função das barras em nível local e, depois de
transformadas para o referencial global através das matrizes de rotação podem ser acopladas no
vetor de forças global e na matriz de rigidez global de forma correta.

Figura 20 – Sequência de Análise do Programa GrelhaPy

Definição das informações iniciais


•Coordenadas dos nós
•Conectividade das barras
•Forças distribuídas
•Forças concentradas
•Condições de contorno
•Módulos de elasticidade
•Momentos de inércia

Declaração das variáveis do sistema


•Deslocabilidades
•Número grande
•Número de nós
•Número de barras

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

Fonte: O autor (2018)


41

5 VALIDAÇÃO DO PROGRAMA GRELHAPY

Com o intuito de validar os resultados fornecidos pelo programa GrelhaPy, foram


desenvolvidos manualmente dois problemas de grelhas e os resultados comparados com os
gerados no programa.

5.1 PROBLEMA PROPOSTO 01 – GRELHA ISOSTÁTICA

O Problema Proposto 01 consiste numa grelha isostática, conforme a Figura 21,


estrutura facilmente calculada manualmente. O primeiro passo na resolução manual da grelha
da Figura 21 foi a discretização das suas barras e nós, demonstrado na Figura 22.
Consecutivamente, ocorreu a obtenção das reações no engaste do nó 1 através do somatório das
forças verticais em Z e as rotações em X e Y (Tabela 1).

Figura 21 – Problema Proposto 01 – Grelha isostática

Fonte: O autor (2018)

Figura 22 – Discretização da Grelha do Problema Proposto 01

Fonte: O autor (2018)


42

Dessa forma:

∑ 𝐹𝑧 = 0

𝐹1 − 10 − 3 . 3,5 = 0

𝐹1 = 20,5 𝐾𝑁

∑ 𝑇𝑥 = 0

3,52
𝑇𝑥 − 10 . 3,5 − 3 . =0
2

𝑇𝑥 = 53,375 𝐾𝑁/𝑚

∑ 𝑀𝑦 = 0

𝑀𝑦 − 10 . 6,0 − 3 . 3,5 . 3,0 = 0

𝑀𝑦 = 91,5 𝐾𝑁/𝑚

Tabela 1 – Reações de apoio obtidas através das equações da estática


Eixo X Eixo Y Eixo Z
(kNm) (kNm) (kN)
NÓ 1 53,375 91,500 20,500
NÓ 2 0,000 0,000 0,000
NÓ 3 0,000 0,000 0,000
NÓ 4 0,000 0,000 0,000

Assim, os esforços solicitantes encontrados nas extremidades das barras são


apresentados na Tabela 2:

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

Para inserção da grelha no programa, a mesma discretização da Figura 22 foi utilizada


(vide Figura 23). Além disso, os valores dos momentos de inércia e dos módulos de elasticidade
foram considerados unitários.
43

Figura 23 – Tela demonstrando a inserção das características da estrutura no programa

Fonte: O autor (2018)

Os resultados obtidos pelo programa são apresentados nas Figuras 24 e 25 e nas Tabelas
3 e 4.

Figura 24 – Tela demonstrando a apresentação das reações de apoio no programa

Fonte: O autor (2018)


44

Figura 25 – Tela demonstrando a apresentação dos esforços internos no programa

Fonte: O autor (2018)

Tabela 3 – Reações de apoio da grelha do Problema Proposto 01 calculadas através do programa


Eixo X Eixo Y Eixo Z
(kNm) (kNm) (kN)
NÓ 1 53,375 91,500 20,500
NÓ 2 0,000 0,000 0,000
NÓ 3 0,000 0,000 0,000
NÓ 4 0,000 0,000 0,000

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

5.2 PROBLEMA PROPOSTO 02 – GRELHA HIPERESTÁTICA

O Problema Proposto 02 consiste numa grelha hiperestática conforme Figura 26.

5.2.1 Resolução Manual

A estrutura foi primeiro resolvida através do método dos deslocamentos, utilizando a


discretização apresentada na Figura 27, considerando a rigidez à flexão (EI) e à torção (GJ) das
barras iguais a 5,0x105 kNm2 e 4,0x105 kNm2, respectivamente.

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.

Figura 26 – Problema Proposto 02 – Grelha hiperestática

Fonte: O autor (2018)

Figura 27- Discretização da Grelha para solução manual do Problema Proposto 02

Fonte: O autor (2018)


46

Figura 28- Deslocabilidades livres da grelha do Problema Proposto 02

Fonte: O autor (2018)

5.2.1.1 Esforços de engastamento perfeito


A primeira etapa foi calcular as ações nos nós causadas pelas forças nas barras. Assim,
as ações relativas às forças da barra 1 são mostradas na Tabela 5.

Tabela 5 – Ações nodais reais causadas pela força concentrada na Barra 1


Ação em X Ação em Y Ação em Z
(kNm) (kNm) (kN)
NÓ 1 0,00 2,16 3,24
NÓ 2 0,00 -1,44 1,76
NÓ 3 0,00 0,00 0,00

De forma análoga, as ações relativas às forças da barra 2 são mostradas na Tabela 6.

Tabela 6 – Ações nodais reais causadas pela força distribuída na Barra 2


Ação em X Ação em Y Ação em Z
(kNm) (kNm) (kN)
NÓ 1 0,0 0,0 0,0
NÓ 2 2,6667 0,0 4,0
NÓ 3 -2,6667 0,0 4,0

5.2.1.2 Coeficientes de rigidez


Após a obtenção dos esforços de engastamento perfeito, foram obtidos os coeficientes
de rigidez quando da aplicação de rotações e deslocamentos unitários nas direções das
deslocabilidades livres.

Assim, na aplicação de uma rotação unitária em torno do eixo X (deslocabilidade D1),


obtém-se os seguintes coeficientes de rigidez na barra 1 (oriundos da rigidez à torção),
mostrados na Tabela 7.
47

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

Para a barra 2, ainda considerando-se a deslocabilidade D1, obtém-se os seguintes


coeficientes de rigidez (oriundos da rigidez à flexão), conforme Tabela 8.

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

Na aplicação de uma rotação unitária em torno do eixo Y (deslocabilidade D2), obtém-


se os seguintes coeficientes de rigidez na barra 1 (oriundos da rigidez à flexão), mostrados na
Tabela 9.

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

Para a barra 2, ainda considerando-se a deslocabilidade D2, obtém-se os seguintes


coeficientes de rigidez (oriundos da rigidez à torção), conforme Tabela 10.

Tabela 10 – Coeficientes de rigidez obtidos através da consideração de uma rotação unitária na


direção D2 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 0,0 1,0x105 0,0
NÓ 3 0,0 -1,0x105 0,0

Na aplicação de deslocamento transversal na direção do eixo Z (deslocabilidade D3),


obtém-se os seguintes coeficientes de rigidez na barra 1 (oriundos da rigidez à flexão),
mostrados na Tabela 11.
48

Tabela 11 – Coeficientes de rigidez obtidos através da consideração de um deslocamento


transversal unitário na direção D3 na extremidade da Barra 1
Rigidez em X Rigidez em Y Rigidez em Z
(kNm) (kNm) (kN)
NÓ 1 0,0 -3,3333x105 -2,2222x105
NÓ 2 0,0 -3,3333x105 2,2222x105
NÓ 3 0,0 0,0 0,0

Para a barra 2, ainda considerando-se a deslocabilidade D3, obtém-se os seguintes


coeficientes de rigidez (oriundos da rigidez à flexão), conforme Tabela 12.

Tabela 12 - Coeficientes de rigidez obtidos através da consideração de um deslocamento transversal


unitário na direção D3 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 1,875x105 0,0 0,9374x105
NÓ 3 1,875x105 0,0 -0,9374x105

5.2.1.3 Equações de equilíbrio


Com os esforços de engastamento perfeito e os coeficientes de rigidez, foi possível
montar as seguintes equações de equilíbrio:

2,67 + 6,3333x105 . 𝐷1 + 0. 𝐷2 + 1,875x105 . 𝐷3 = 0


{ −1,44 + 0. 𝐷1 + 7,6667x105 . 𝐷2 −3,3333x105 . 𝐷3 = 0
5,76 + 1,875x105 . 𝐷1 −3,3333x105 . 𝐷2 + 3,1596x105 . 𝐷3 = 0

A resolução do sistema anterior nos fornece:

𝐷1 = 0,6922x10−5 𝑟𝑎𝑑
𝐷2 = −1,4472x10−5 𝑟𝑎𝑑
𝐷3 = −3,7606x10−5 𝑚

Dessa forma, podemos obter as reações de apoio, apresentadas na Tabela 13, e os


esforços solicitantes internos nas extremidades das barras, apresentados na Tabela 14.

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

5.2.2 Resultados do Programa

Para inserção dos dados da estrutura no programa, foi adotada a discretização


apresentada na Figura 29, sendo consideradas as mesmas características da solução manual. Os
dados foram inseridos de forma similar ao problema anterior. Assim, os resultados obtidos
(Figura 30) estão apresentados nas Tabelas 15 e 16.

Figura 29 – Discretização da grelha para solução numérica do Problema Proposto 02

Fonte: O autor (2018)

Tabela 15 – Reações de apoio da grelha do Problema Proposto 02 obtidas através do programa


Eixo X Eixo Y Eixo Z
(kNm) (kNm) (kN)
NÓ 1 -0,9229 9,8707 6,7726
NÓ 2 0,0000 0,0000 0,0000
NÓ 3 0,0000 0,0000 0,0000
NÓ 4 -7,9867 1,4471 6,2274

Tabela 16 – Esforços internos da grelha do Problema Proposto 02 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 -0,9229 9,8707 6,7726 0,9229 -1,7436 -6,7726
BARRA 2 -0,9229 1,7436 1,7726 0,9229 1,4471 -1,7726
BARRA 3 -0,9229 -1,4471 1,7726 -7,9867 1,4471 6,2274
50

Figura 30 – Tela de apresentação das reações de apoio da grelha do Problema Proposto 02

Fonte: O autor (2018)

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%.

Ressalta-se 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.

Outra importante funcionalidade possível ao programa é a plotagem da matriz de rigidez


da estrutura (Figura 31). Definida a mesma discretização para a solução manual e solução
numérica torna-se possível também a conferência dos coeficientes de rigidez encontrados na
solução manual. No problema proposto não é possível fazer essa verificação porque as
discretizações são distintas (Figuras 27 e 29), sendo necessário adequá-las. A melhor alternativa
seria a adequação do modelo numérico, contudo se faz necessária a implementação no programa
de novo caso de carregamento (carga pontual localizada internamente na barra), do contrário a
solução manual tornar-se-ia um problema com indeterminação cinemática de ordem igual a 6.
51

Figura 31 – Matriz de Rigidez do Problema Proposto 02

Fonte: O autor (2018)


52

6 CONCLUSÕES

O desenvolvimento da ferramenta computacional, embora simples, mostra-se eficiente


ao seu objetivo, cálculo automático de grelhas. O lançamento dos dados dos problemas é de
simples entendimento através da interface gráfica desenvolvida e a obtenção de resultados
demanda ao usuário um curto período de tempo, tornando-se, assim, uma importante ferramenta
auxiliar para as disciplinas de isostática e hiperestática, uma vez que possibilita a conferência
dos resultados obtidos manualmente.
Os exemplos utilizados para validação demonstram, que as respostas obtidas nas
resoluções manuais e através do programa para a grelha isostática são idênticas e para grelha
hiperestática, os resultados apresentam erros relativos insignificantes, certamente gerados nos
arredondamentos inerentes da análise manual.
O programa fornece as respostas triviais de quaisquer programas de análise estrutural
tais como reações de apoio, deslocamentos e esforços seccionais e, ainda possibilita, para
auxílio à solução manual de problemas hiperestáticos, a matriz de rigidez global para simples
conferência dos coeficientes de rigidez necessários nas soluções manuais.

Considerando-se que a estrutura utilizada no desenvolvimento do programa permite que


novas propriedades e funcionalidades podem ser criadas ou ainda substituir as originais sem
grandes dificuldades, entende-se que o programa possibilita a expansão de sua aplicação em
diferentes problemas.

Assim, com o intuito de dar continuidade ao trabalho em pesquisas futuras, apresentam-


se como sugestões para modificações e/ou implementações no programa:

 Apresentação dos resultados graficamente, com construção dos diagramas de


esforços solicitantes através das ferramentas de construção de gráficos disponíveis
para o Python;
 Inserção dos elementos da grelha graficamente, utilizando, por exemplo, um grid pré-
definido;
 Inserção de outras condições de contorno, tais como deslocamentos prescritos, apoios
elásticos e liberações locais;
 Criação de uma biblioteca de carregamentos, tais como carregamentos
uniformemente variados e cargas de temperatura;
53

 Criação de biblioteca de seções transversais tais como seções retangulares, circulares


e perfis metálicos, requerendo-se aos usuários a simples inserção das dimensões da
seção, ficando à cargo do programa o cálculo de suas propriedades geométricas,
como áreas e momentos de inércia;
 Geração automática de problemas pré-definidos como um modelo de laje em grelha
com dimensões L1 x L2 e n x m divisões;
 Implementação de demais tipos de modelos estruturais de barras (vigas, treliças
planas, treliças espaciais, pórticos planos e pórticos espaciais). Sugere-se aqui uma
alteração macro com a inserção ao programa do elemento de pórtico espacial, assim
através de uma tela inicial o usuário faria a escolha do tipo de elemento que pretende
resolver e internamente (de forma invisível ao usuário final) o programa adequaria a
matriz de rigidez ao problema requerido (ajustando-se coordenadas, deslocabilidades
e esforços irrelevantes para solução do problema, tal qual deslocamentos horizontais
e esforços normais em um modelo de grelha);
 Implementação de algoritmo para análise não-linear geométrica;
 Implementação de algoritmo para análise dinâmica;
 Dimensionamento otimizado de armação de lajes e vigas utilizando-se o modelo de
grelha.

À priori, pretende-se utilizar o programa como ferramenta acadêmica, como já apontado


para as disciplinas de isostática e hiperestática. Com alguns ajustes como os sugeridos acima,
e outros tantos que podem vir a ser implementados, verifica-se aplicação direta em outras
disciplinas tais como resistência dos materiais, análise matricial de estruturas, concreto armado,
pontes, estruturas de madeira e estruturas metálicas.
54

REFERÊNCIAS

MARTHA, Luiz Fernando. Análise de estruturas: conceitos e métodos básicos. Rio de


Janeiro: Elsevier, 2010.

SORIANO, Humberto Lima. Análise de Estruturas – Formulação Matricial e


Implementação Computacional. Rio de Janeiro: Editora Ciência Moderna Ltda, 2005.

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.

GOMES, J.; VELHO, L. Computação Gráfica. V. 1. Série de Computação e matemática.


Instituto de Matemática Pura e Aplicada – IMPA. Rio de Janeiro, 1998.

FELLIPA, Carlos A. Introduction to Finite Element Methods. Notas de aula da disciplina


Introduction to Dinite Elements Methods (ASEN 5007), Aerospace Engineering Sciences
Department, University of Colorado at Boulder,
https://www.colorado.edu/engineering/CAS/courses.d/IFEM.d/, 2018.
55

APENDICE A – CÓDIGO DO PROGRAMA

A.1 – GrelhaPy.py
import sys

from PyQt5.QtWidgets import (QApplication, QAction, QFileDialog)

from Data.Visual.Janelas import Janelas


from Data.Visual.VisualConfig import VisualConfig

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 dos módulos de elasticidade


menu_materiais.addAction(self.Janelas.botao_elasticidade)

# Menu das forças


menu_forcas.addAction(self.Janelas.botao_forcas_concentradas)
56

menu_forcas.addAction(self.Janelas.botao_forcas_distribuidas)

# Menu das análises


menu_analise.addAction(self.Janelas.botao_analise)
menu_analise.addSeparator()
menu_analise.addAction(self.Janelas.botao_deslocamentos)
menu_analise.addAction(self.Janelas.botao_reacoes_apoio)
menu_analise.addAction(self.Janelas.botao_esi)
menu_analise.addAction(self.Janelas.botao_matriz)

#
###########################################################################
self.setStatusBar(self.Janelas.statusBar)

self.show()

if __name__ == '__main__':
app = QApplication(sys.argv)
ex = GrelhaCalcMain()
sys.exit(app.exec_())

A.2 – VisualConfig.py

"""Arquivo para configurações visuais da interface do programa"""


from PyQt5.QtWidgets import QMainWindow
from PyQt5.QtGui import QIcon
from PyQt5.QtCore import Qt

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

"""Arquivo de construção das páginas do programa e métodos para obtenção


dos dados da tabela e
apresentação dos resultados"""

from numpy import zeros, around

from PyQt5.QtWidgets import (QStackedWidget, QWidget,


QGridLayout, QHBoxLayout, QLabel, QPushButton,
QTableWidget
, QVBoxLayout, QLineEdit, QTableWidgetItem,
QTabWidget, QStatusBar, QAction)

from Data.Analise import Analises


from Data.Erros.Erros import erro_null, erro_formato_errado

import matplotlib.pyplot as pl
import matplotlib.patches as patches
from matplotlib.path import Path

from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as


FigureCanvas
from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT as
NavigationToolbar

# 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)

"""Definição dos submenus"""


# Menu de arquivo
self.botao_abrir = QAction('Abrir...', self)
self.botao_novo = QAction('Novo', self)
self.botao_salvar = QAction('Salvar', self)

# Menu de geometria
self.botao_nos = QAction('Nós e Barras', self)

# Menu dos módulos de elasticidade


self.botao_elasticidade = QAction('Módulos de elasticidade', self)

# Menu das forças


self.botao_forcas_distribuidas = QAction('Forças Distribuídas',
self)
self.botao_forcas_concentradas = QAction('Forças Concentradas',
self)

# Menu das análises


self.botao_analise = QAction('Executar análise', self)
self.botao_deslocamentos = QAction('Deslocamentos', self)
self.botao_reacoes_apoio = QAction('Reações de apoio', self)
self.botao_esi = QAction('Esforços solicitantes', self)
self.botao_matriz = QAction('Matriz de rigidez', 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:')

# Caixa de texto para definição dos nós


self.edit_text_nos = QLineEdit(self)
self.edit_text_nos.setMaximumSize(180, 50)

# Botão para definir a quantidade de nós


botao = QPushButton('Definir', self)
botao.clicked.connect(self.botao_def_nos)

# Botão de atualizar as informações da tabela


self.botao_atualizar_nos = QPushButton('Atualizar', self)
self.botao_atualizar_nos.setEnabled(False)
self.botao_atualizar_nos.clicked.connect(self.botao_atualizar_nosm)

# 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)

# Definição dos layouts


layout = QGridLayout()
# layout.addWidget(view, 0, 0)
layout.addWidget(self.canvas, 0, 0)
layout.addWidget(self.mpl_toolbar, 1, 0)

self.nos_view.setLayout(layout)

def barras_ui(self):
# Definição dos objetos da página
text = QLabel('Defina a quantidade de barras:')

# Caixa de texto para inserção da quantidade de barras


self.edit_text_barras = QLineEdit()
self.edit_text_barras.setMaximumSize(180, 50)

# Botão de definição da quantidade de barras


botao = QPushButton('Definir')
botao.clicked.connect(self.botao_def_barras)

# Botão para atualizar as características das barras


self.botao_atualizar_barras = QPushButton('Atualizar', self)
self.botao_atualizar_barras.setEnabled(False)

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:')

# Botão para atualizar os dados dos módulos das barras


botao = QPushButton('Atualizar')
botao.setMaximumSize(100, 50)
botao.clicked.connect(self.botao_def_modulos)

# 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:')

# botão de atualizar as informações da tabela


botao = QPushButton('Atualizar')
botao.setMaximumSize(100, 50)
botao.clicked.connect(self.botao_forcas_distribuidas_at)

# 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:')

# Botão para atualizar as informações da tabela


botao = QPushButton('Atualizar')
botao.setMaximumSize(100, 50)
botao.clicked.connect(self.botao_forcas_concentradas_at)

# 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

# início das operações que necessítam da quantidades de nós da


estrutura
try:
# Recuperação do valor do número de nós a partir da caixa de
edição de texto
NumeroDeNos = int(self.edit_text_nos.text())

# Definição do tamanho da tabela em função da quantidade de nós


self.tabela_nos.setRowCount(NumeroDeNos)

# Determinação de valores nulos para as restrições dos apoios


na tabela
for j in range(3):
for i in range(NumeroDeNos):
self.tabela_nos.setItem(i, j+2, QTableWidgetItem("0"))

# Permissão para atualização dos valores da tabela


self.botao_atualizar_nos.setEnabled(True)

# Determinação do tamanho da tabela de forças concentradas em


função do número de nós
self.tabela_forcas_concentradas.setRowCount(NumeroDeNos)

# Determinação de valores nulos para as forças concentradas na


tabela
for j in range(3):
for i in range(NumeroDeNos):
self.tabela_forcas_concentradas.setItem(i, j,
QTableWidgetItem("0"))

except ValueError:
erro_formato_errado()

def botao_atualizar_nosm(self):
# Recuperação de variáveis globais
global NumeroDeNos, MatrizDeCoordenadas, CondicoesDeContorno

# Determinação das variáveis como matrizes zeradas


MatrizDeCoordenadas = zeros((NumeroDeNos, 2))
CondicoesDeContorno = zeros((NumeroDeNos, 3))

# Recuperação dos valores da tabela e inserção nas matrizes


try:
for i in range(NumeroDeNos):
for j in range(2):
MatrizDeCoordenadas[i, j] =
65

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()

# Criação dos desenhos dos nós no gráfico


self.ax.clear()
self.ax.grid()
for i, j in MatrizDeCoordenadas:
self.ax.plot(i, j, 'go-')
self.canvas.draw()

self.nost.setTabEnabled(1, True)

self.statusBar.showMessage('Informações dos nós atualizadas!',


2500)

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())

# Definição da quantidade de linhas da tabela de barras em


função do número de barras
self.tabela_barras.setRowCount(NumeroDeBarras)

# Dimensionamento da tabela de módulos em função do número de


barras
self.tabela_modulos.setRowCount(NumeroDeBarras)

# Dimensionamento da tabela de forças distribuídas em função do


número de barras
self.tabela_forcas_distribuidas.setRowCount(NumeroDeBarras)

# Permissão para atualização das informações da tabela de


barras
self.botao_atualizar_barras.setEnabled(True)

# Determinação de valores zerados para a tabela de forças


distribuídas
for i in range(NumeroDeBarras):
self.tabela_forcas_distribuidas.setItem(i, 0,
QTableWidgetItem("0"))

except ValueError:
erro_formato_errado()

def botao_atualizar_barrasm(self):
# Recuperação de variáveis globais
global NumeroDeBarras, MatrizDeConectividade, J, I,
MatrizDeCoordenadas

# Atribuição de valores nulos às variáveis


MatrizDeConectividade = zeros((NumeroDeBarras, 2))
J = zeros((NumeroDeBarras, 1))
I = zeros((NumeroDeBarras, 1))
66

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())

J[i, 0] = float(self.tabela_barras.item(i, 2).text())


I[i, 0] = float(self.tabela_barras.item(i, 3).text())
except ValueError:
erro_null()

# Criação dos desenhos das barras no gráfico


self.ax.clear()
self.ax.grid()
self.botao_atualizar_nosm()
for i in MatrizDeConectividade:
diretriz = zeros((2, 2))
indice = 0
for j in i:
diretriz[indice, :] = MatrizDeCoordenadas[int(j - 1), :]
indice += 1
path = Path(diretriz, [Path.MOVETO, Path.LINETO])
patch3 = patches.PathPatch(path, facecolor='white', lw=2)
self.ax.add_patch(patch3)
self.canvas.draw()

# Status de informações atualizadas


self.statusBar.showMessage('Informações das barras atualizadas!',
2500)

def botao_def_modulos(self):
# Recuperação de variáveis globais
global NumeroDeBarras, G, E

# Atribuição de matriz com valores nulos às variáveis


G = zeros((NumeroDeBarras, 1))
E = zeros((NumeroDeBarras, 1))

try:
# Recuperação dos valores da tabela e inserção
for i in range(NumeroDeBarras):

G[i, 0] = float(self.tabela_modulos.item(i, 0).text())


E[i, 0] = float(self.tabela_modulos.item(i, 1).text())
except:
erro_null()

self.statusBar.showMessage('Módulos atualizados!', 2500)

def botao_forcas_distribuidas_at(self):
# Recuperação das variáveis globais
global ForcasDistribuidas, NumeroDeBarras

# Atribuição de matrizes de valores nulos às variáveis


ForcasDistribuidas = zeros((NumeroDeBarras, 1))

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()

self.statusBar.showMessage('Forças distribuídas atualizadas!',


2500)

def botao_forcas_concentradas_at(self):
# Recuperação das variáveis globais
global NumeroDeNos, ForcasNodais

# Atribuição de matriz zerada à variável


ForcasNodais = zeros((NumeroDeNos, 3))

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()

self.statusBar.showMessage('Forças concentradas atualizadas!',


2500)

###########################################################################
def botao_analise_exec(self):
# Recuperação das variáveis globais
global NumeroDeNos, NumeroDeBarras, MatrizDeCoordenadas,
MatrizDeConectividade, ForcasDistribuidas, \
ForcasNodais, CondicoesDeContorno, G, E, J, I

# Execução da pré-análise, com definição das variáveis


R = Analises.Analise(
Analises.Grelha(MatrizDeCoordenadas, MatrizDeConectividade,
ForcasDistribuidas, ForcasNodais,
CondicoesDeContorno, G, E, J, I))
# Cálculo dos deslocamentos
D = R.linear_elastica()

# Dimensionamento da tabela de deslocamentos em função da


quantidade de nós
self.tabela_deslocamentos.setRowCount(NumeroDeNos * 3)

# Atribuição dos resultados à tabela


for i in range(NumeroDeNos * 3):
self.tabela_deslocamentos.setItem(i, 0,
QTableWidgetItem(str(around(D[i, 0], 4))))

###########################################################################
# Cálculo das reações de apoio
reacoes = R.reacoes_apoio()

# Dimensionamento da tabela em função do número de nós


self.tabela_reacoes.setRowCount(NumeroDeNos)
68

# Inserção dos valores dos resultados nas tabelas


for i in range(NumeroDeNos):
for j in range(3):
if abs(reacoes[i, j]) >= 0.0001:
self.tabela_reacoes.setItem(i, j,
QTableWidgetItem(str(around(reacoes[i, j], 4))))
else:
self.tabela_reacoes.setItem(i, j,
QTableWidgetItem("0.0"))
self.tabela_reacoes.setDisabled(True)

###########################################################################
# Cálculo dos esforços solicitantes
esi = R.eforcos_solicitantes()

# Dimensionamento da tabela em função do número de barras


self.tabela_esi.setRowCount(NumeroDeBarras)

# Inserção dos valores dos resultados na tabela


for j in range(6):
for i in range(NumeroDeBarras):
if abs(esi[i, j]) >= 0.0001:
self.tabela_esi.setItem(i, j,
QTableWidgetItem(str(around(esi[i, j], 4))))
else:
self.tabela_esi.setItem(i, j, QTableWidgetItem("0.0"))

###########################################################################
# apresentação da matriz de rigidez
matrizderigidez = R.MatrizRigidezGlobal

# Dimensionamento da tabela em função do número de nós


self.tabela_matriz_rigidez.setRowCount(3*NumeroDeNos)
self.tabela_matriz_rigidez.setColumnCount(3*NumeroDeNos)

# Inserção dos valores dos resultados na tabela


for j in range(3*NumeroDeNos):
for i in range(3*NumeroDeNos):
self.tabela_matriz_rigidez.setItem(i, j,
QTableWidgetItem(str("{0:1.4E}".format(matrizderigidez[i, j]))))

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

"""Arquivo para obtenção dos resultados da análise"""


from numpy import dot, zeros, array

from numpy.linalg import inv


69

from copy import copy

from Data.Analise.Estruturas import Grelha

# Vetor de forças nodais equivalentes


class Analise:

def __init__(self, Estrutura):

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))

for i in range(1, self.estrutura.NumeroDeBarras+1):

EngastamentoPerfeitoGlobal =
dot(self.estrutura.matriz_rotacao(i).T,

self.estrutura.engastamento_perfeito(i))

VetorCorrespondenciaIndex =
self.estrutura.vetor_correspondencia(i)

for j in range(1, (2*self.estrutura.Deslocabilidades)+1):

self.ForcasNodaisEquivalentes[int((VetorCorrespondenciaIndex[j-1, 0])-1),
0]\
-= EngastamentoPerfeitoGlobal[j-1, 0]

self.ForcasNodaisCombinadas = copy(self.ForcasNodaisEquivalentes)

for i in range(1, self.estrutura.NumeroDeNos+1):

for j in range(1, self.estrutura.Deslocabilidades+1):

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))

for i in range(1, self.estrutura.NumeroDeBarras+1):

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)

for j in range(1, 2*self.estrutura.Deslocabilidades+1):


for jk in range(1, 2*self.estrutura.Deslocabilidades+1):

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]

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.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

"""Arquivo de criação do objeto da estrutura"""


from numpy import array, zeros, absolute

class Grelha:

def __init__(self, MatrizDeCoordenadas, MatrizDeConectividade,


ForcasDistribuidas, ForcasNodais,
CondicoesDeContorno, G, E, J, I):

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.DeslocamentosPrescritos = zeros((self.NumeroDeNos, 3))

self.Deslocabilidades = 3

self.NumeroGrande = 1E20

def comprimento_barra(self, i):

return
((((self.MatrizDeCoordenadas[int(self.MatrizDeConectividade[i - 1, 1]) - 1,
0] -

self.MatrizDeCoordenadas[int(self.MatrizDeConectividade[i - 1, 0]) - 1, 0])


** 2) +

((self.MatrizDeCoordenadas[int(self.MatrizDeConectividade[i - 1, 1]) - 1,
1] -

self.MatrizDeCoordenadas[int(self.MatrizDeConectividade[i - 1, 0]) - 1, 1])


** 2)) ** 0.5)

def matriz_rigidez_local(self, i):

x = array(([((self.G[i - 1, 0] * self.J[i - 1, 0]) /


self.comprimento_barra(i)), 0, 0,
((-self.G[i - 1, 0] * self.J[i - 1, 0]) /
self.comprimento_barra(i)), 0, 0],
# segunda linha
[0, ((4 * self.E[i - 1, 0] * self.I[i - 1, 0]) /
self.comprimento_barra(i)),
((-6 * self.E[i - 1, 0] * self.I[i - 1, 0]) /
self.comprimento_barra(i) ** 2), 0,
((2 * self.E[i - 1, 0] * self.I[i - 1, 0]) /
self.comprimento_barra(i)),
((6 * self.E[i - 1, 0] * self.I[i - 1, 0]) /
self.comprimento_barra(i) ** 2)],
# Terceira linha
73

[0, ((-6 * self.E[i - 1, 0] * self.I[i - 1, 0]) /


self.comprimento_barra(i) ** 2),
((12 * self.E[i - 1, 0] * self.I[i - 1, 0]) /
self.comprimento_barra(i) ** 3), 0,
((-6 * self.E[i - 1, 0] * self.I[i - 1, 0]) /
self.comprimento_barra(i) ** 2),
((-12 * self.E[i - 1, 0] * self.I[i - 1, 0]) /
self.comprimento_barra(i) ** 3)],
# Quarta Linha
[((-self.G[i - 1, 0] * self.J[i - 1, 0]) /
self.comprimento_barra(i)), 0, 0,
((self.G[i - 1, 0] * self.J[i - 1, 0]) /
self.comprimento_barra(i)), 0, 0],
# Quinta linha
[0, ((2 * self.E[i - 1, 0] * self.I[i - 1, 0]) /
self.comprimento_barra(i)),
((-6 * self.E[i - 1, 0] * self.I[i - 1, 0]) /
self.comprimento_barra(i) ** 2), 0,
((4 * self.E[i - 1, 0] * self.I[i - 1, 0]) /
self.comprimento_barra(i)),
((6 * self.E[i - 1, 0] * self.I[i - 1, 0]) /
self.comprimento_barra(i) ** 2)],
# Sexta linha
[0, ((6 * self.E[i - 1, 0] * self.I[i - 1, 0]) /
self.comprimento_barra(i) ** 2),
((-12 * self.E[i - 1, 0] * self.I[i - 1, 0]) /
self.comprimento_barra(i) ** 3), 0,
((6 * self.E[i - 1, 0] * self.I[i - 1, 0]) /
self.comprimento_barra(i) ** 2),
((12 * self.E[i - 1, 0] * self.I[i - 1, 0]) /
self.comprimento_barra(i) ** 3)]))
return x

def engastamento_perfeito(self, i):

engperf = zeros((6, 1))


engperf[0, 0] = 0
engperf[3, 0] = 0
engperf[2, 0] = -(self.ForcasDistribuidas[i - 1, 0] *
self.comprimento_barra(i)) / 2
engperf[5, 0] = engperf[2, 0]
engperf[1, 0] = (self.ForcasDistribuidas[i - 1, 0] *
(self.comprimento_barra(i) ** 2) / 12)
engperf[4, 0] = - engperf[1, 0]
return engperf

def matriz_rotacao(self, i):

x = zeros((2 * self.Deslocabilidades, 2 * self.Deslocabilidades))


x[0, 0] =
(((self.MatrizDeCoordenadas[int(self.MatrizDeConectividade[i - 1, 1]) - 1,
0]
- self.MatrizDeCoordenadas[
int(self.MatrizDeConectividade[i - 1, 0])
- 1, 0]) / self.comprimento_barra(i)))
x[0, 1] =
(((self.MatrizDeCoordenadas[int(self.MatrizDeConectividade[i - 1, 1]) - 1,
1]
- self.MatrizDeCoordenadas[
int(self.MatrizDeConectividade[i - 1, 0])
- 1, 1]) / self.comprimento_barra(i)))
74

x[1, 0] = - x[0, 1]
x[1, 1] = x[0, 0]
x[2, 2] = 1

for ii in range(1, self.Deslocabilidades + 1):


for ij in range(1, self.Deslocabilidades + 1):
x[2 + ii, 2 + ij] = x[ii - 1, ij - 1]
return x

def vetor_correspondencia(self, i):

x = zeros((2 * self.Deslocabilidades, 1))

y = 0

for j in range(1, 3):

for jk in range(1, self.Deslocabilidades + 1):


y += 1

w = self.Deslocabilidades * (self.MatrizDeConectividade[i -
1, j - 1] - 1) + jk

x[y - 1, 0] = int(w)

return x