TCC - II - FINAL - Eduardo Viali - 04-07-2020

Ministério da Educação
Universidade Federal da Integração Latino-Americana

Instituto de Tecnologia, Infraestrutura e Território
Centro Interdisciplinar de Tecnologia e Infraestrutura
DESENVOLVIMENTO DE SOFTWARE PARA ANÁLISE ESTRUTURAL

E DIMENSIONAMENTO DE VIGAS DE CONCRETO ARMADO SOB
FLEXÃO SIMPLES
EDUARDO DE PADUA VIALI
Foz do Iguaçu, PR
Julho de 2020
Ministério da Educação
Instituto de Tecnologia, Infraestrutura e Território
Centro Interdisciplinar de Tecnologia e Infraestrutura
DESENVOLVIMENTO DE SOFTWARE PARA ANÁLISE ESTRUTURAL

E DIMENSIONAMENTO DE VIGAS DE CONCRETO ARMADO SOB
FLEXÃO SIMPLES
EDUARDO DE PADUA VIALI
Trabalho de Conclusão de Curso apresentado a

Banca Examinadora do Curso de Engenharia Civil
de Infraestrutura da UNILA, como parte dos
requisitos para obtenção do Grau de Bacharel em
Engenharia Civil de Infraestrutura.
Orientador: Prof. Dr. AREF KALILO LIMA KZAM
Foz do Iguaçu, PR
Julho de 2020
ii
iii
Engenharia Civil de Infraestrutura
VIALI, E. P. Desenvolvimento De Software Para Análise Estrutural E Dimensionamento

De Vigas De Concreto Armado Sob Flexão Simples. Trabalho de Conclusão de Curso
(Graduação em Engenharia Civil de infraestrutura) – Universidade Federal da Integração
Latino-Americana, Foz do Iguaçu, 2020.
RESUMO
Com o intuito de reduzir o tempo dispensado na análise e dimensionamento de estruturas,

são desenvolvidas ferramentas computacionais com a função de automatizar os processos
de cálculos, propondo soluções com maior grau de confiabilidade e dimensionamentos mais
econômicos. Assim, o objetivo do presente estudo consistiu no desenvolvimento de um
software para análise de estrutural, através da aplicação do método dos elementos finitos e
dimensionamento de vigas de concreto armado, sob flexão simples. Para a implementação
do código fonte, foi utilizada a linguagem de programação Python em conjunto com suas
bibliotecas Numpy e Matplotlib, sendo a interface gráfica do programa concebida através do
software Qt Designer e da biblioteca PyQt. Visando validar a confiabilidade e aplicabilidade
do software, e ainda propor uma nova ferramenta para auxiliar na análise estrutural,
modelos foram definidos e simulados sendo posteriormente os resultados comparados com
os obtidos através de programas similares. Conforme apresentado, os resultados obtidos
pelo software desenvolvido neste estudo foram os mesmos obtidos ao simular os modelos
em outro programa, validando sua aplicação, garantindo a confiabilidade de seus resultados.
Logo, o programa desenvolvido é passível de aplicação no estudo e análise das estruturas.
Palavras-chave: Análise estrutural; Dimensionamento de vigas; Concreto armado;

Software.
iv
Desenvolvimento de Software Para Análise Estrutural e Dimensionamento de Vigas de
VIALI, E. P. Concreto Armado Sob Flexão Simples
VIALI, E. P. Desenvolvimento De Software Para Análise Estrutural E Dimensionamento

De Vigas De Concreto Armado Sob Flexão Simples. Trabalho de Conclusão de Curso
(Graduação em Engenharia Civil de infraestrutura) – Universidade Federal da Integração
Latino-Americana, Foz do Iguaçu, 2020.
ABSTRACT
In order to reduce the time spent on the analysis and design of structures, computational
tools are developed with the function of automating the calculation processes, proposing
solutions with a higher degree of reliability and more economical dimensioning. Thus, the
objective of the present study was to develop software for structural analysis, through the
application of the finite element method and design of reinforced concrete beams, under
simple bending. For the implementation of the source code, the Python programming
language was used in conjunction with its Numpy and Matplotlib libraries, the program's
graphical interface being designed using the Qt Designer software and the PyQt library. In
order to validate the reliability and applicability of the software, and also to propose a new
tool to assist in the structural analysis, models were defined and simulated and the results
were subsequently compared with those obtained through similar programs. As shown, the
results obtained by the software developed in this study were the same as those obtained
when simulating the models in another program, validating their application, ensuring the
reliability of their results. Therefore, the program developed is passive for application in the
study and analysis of structures.
Keywords: Structural analysis; Beam design; Reinforced concrete; Software.
v
LISTA DE FIGURAS
FIGURA 1. INTERFACE GRÁFICA DO PROGRAMA FTOOL....................................16

FIGURA 2. INTERFACE GRÁFICA DO PROGRAMA ACADFRAME BETA................17
FIGURA 3. INTERFACE GRÁFICA DO PROGRAMA TRAME 4.0..............................17
FIGURA 4. INTERFACE GRÁFICA DO QT DESIGNER.............................................19
FIGURA 5. NÍVEIS DE ABSTRAÇÃO DE UMA ESTRUTURA....................................20
FIGURA 6. REPRESENTAÇÃO DOS MODELOS REAL E ESTRUTURAL.................21
FIGURA 7. DESLOCAMENTOS E ROTAÇÕES NODAIS PARA UM ELEMENTO DE
PÓRTICO PLANO.......................................................................................................22
FIGURA 8. SISTEMA DE EIXOS LOCAIS E ELÁSTICA DA BARRA..........................23
FIGURA 9. ROTAÇÃO RELATIVA POR FLEXÃO DE UM ELEMENTO
INFINITESIMAL DE BARRA........................................................................................23
FIGURA 10. EQUILÍBRIO DO ELEMENTO INFINITESIMAL.......................................25
FIGURA 11 TRANSFORMAÇÃO DO SISTEMA DE COORDENADAS – LOCAL VS
GLOBAL...................................................................................................................... 28
FIGURA 12 (REAPRESENTAÇÃO DA FIGURA 7) - DESLOCAMENTOS E
ROTAÇÕES NODAIS PARA UM ELEMENTO DE PÓRTICO PLANO........................30
FIGURA 13 PÓRTICO PLANO MODELO PARA APRESENTAÇÃO DA OBTENÇÃO
DA MATRIZ DE RIGIDEZ GLOBAL DA ESTRUTURA................................................34
FIGURA 14 MATRIZES DE RIGIDEZ DOS ELEMENTOS DO MODELO....................35
FIGURA 15 MATRIZES DE RIGIDEZ DOS ELEMENTOS DO MODELO DIVIDIDA EM
QUADRANTES............................................................................................................ 36
FIGURA 16 MATRIZES DE RIGIDEZ GLOBAL DA ESTRUTURA DIVIDIDA EM
QUADRANTES............................................................................................................ 36
FIGURA 17 APLICAÇÃO DA INCIDÊNCIA SOBRE A MATRIZ DE RIGIDEZ GLOBAL
DA ESTRUTURA.........................................................................................................37
FIGURA 18 ELEMENTO INCLINADO COM SOB AÇÃO DE UM CARREGAMENTO
LINEARMENTE VARIÁVEL.........................................................................................38
FIGURA 19 COMPORTAMENTO DO CONCRETO NA FLEXÃO PURA (ESTÁDIO I).
..................................................................................................................................... 42
FIGURA 20 COMPORTAMENTO DO CONCRETO NA FLEXÃO PURA (ESTÁDIO II).
..................................................................................................................................... 43
FIGURA 21 COMPORTAMENTO DO CONCRETO NA FLEXÃO PURA (ESTÁDIO III).
..................................................................................................................................... 43
FIGURA 22 DIAGRAMA RETANGULAR – NBR 6118.................................................44
vi
Desenvolvimento de Software Livre Para Análise de Estruturas Planas e Dimensionamento
VIALI, E. P. de Vigas em Concreto Armado Sob Flexão Simples
FIGURA 23 DIAGRAMAS TENSÃO X DEFORMAÇÃO DO CONCRETO E AÇO –

SEGUNDO A NBR 6118 (ABNT, 2014).......................................................................45
FIGURA 24 DOMÍNIOS DE ESTADO-LIMITE ÚLTIMO DE UMA SEÇÃO
TRANSVERSAL...........................................................................................................45
FIGURA 25 ELEMENTOS DA SEÇÃO RETANGULAR E DIAGRAMAS DE TENSÕES
E DEFORMAÇÕES.....................................................................................................47
FIGURA 26 EQUILÍBRIO DA SEÇÃO TRANSVERSAL PARA DIMENSIONAMENTO
COM ARMADURA SIMPLES.......................................................................................47
FIGURA 27. FLUXO PARA INSERÇÃO DE DADOS E VISUALIZAÇÃO DOS
RESULTADOS.............................................................................................................50
FIGURA 28 JANELA-1 - INTERFACE GRÁFICA DO PROGRAMA............................51
FIGURA 29 JANELA-2 - INSERÇÃO DOS NÓS DA ESTRUTURA.............................52
FIGURA 30 JANELA-3 - INSERÇÃO DOS ELEMENTOS DA ESTRUTURA...............52
FIGURA 31 JANELA-4 - INSERÇÃO DAS PROPRIEDADES FÍSICAS E MECÂNICAS
DOS ELEMENTOS DA ESTRUTURA.........................................................................53
FIGURA 32 JANELA-5 - INSERÇÃO DAS RESTRIÇÕES NODAIS............................54
FIGURA 33 JANELA-6 - INSERÇÃO DAS CARGAS NODAIS....................................54
FIGURA 34 JANELA-7 - INSERÇÃO DAS CARGAS DISTRIBUÍDAS.........................55
FIGURA 35 JANELA-10 – DIMENSIONAMENTO DAS ARMADURAS.......................56
FIGURA 36. TRECHO DE CÓDIGO PARA INSERÇÃO E ARMAZENAMENTO DE
DADOS REFERENTES AOS NÓS DA ESTRUTURA.................................................57
FIGURA 37. TRECHO DE CÓDIGO PARA INSERÇÃO E ARMAZENAMENTO DE
DADOS REFERENTES AOS ELEMENTOS DA ESTRUTURA...................................58
FIGURA 38. TRECHO DE CÓDIGO PARA INSERÇÃO E ARMAZENAMENTO DAS
PROPRIEDADES FÍSICAS E MECÂNICAS DOS ELEMENTOS DA ESTRUTURA....58
RESTRIÇÕES NODAIS...............................................................................................59
CARGAS NODAIS.......................................................................................................59
CARGAS DISTRIBUÍDAS............................................................................................60
FIGURA 42 ELEMENTO DEFINIDO PELO USUÁRIO E ELEMENTOS GERADOS
PELO SISTEMA...........................................................................................................60
FIGURA 43. TRECHO DE CÓDIGO PARA BUSCA DE DADOS PARA CÁLCULO....61
FIGURA 44. TRECHO DE CÓDIGO PARA GERAÇÃO DA MATRIZ DE
TRANSFORMAÇÃO DO SISTEMA DE COORDENADAS (LOCAL X GLOBAL).........61
vii
FIGURA 45. TRECHO DE CÓDIGO PARA GERAÇÃO DA MATRIZ DE RIGIDEZ DO
ELEMENTO FINITO NO SISTEMA DE COORDENADAS LOCAL..............................62
FIGURA 46. TRECHO DE CÓDIGO PARA OBTENÇÃO DA MATRIZ DE RIGIDEZ DO
ELEMENTO FINITO NO SISTEMA DE COORDENADAS GLOBAL............................62
FIGURA 47. TRECHO DE CÓDIGO PARA GERAÇÃO DA MATRIZ DE RIGIDEZ
GLOBAL DA ESTRUTURA..........................................................................................63
FIGURA 48. MODELO-01 – VIGA BIAPOIADA COM 2 METROS DE COMPRIMENTO.
..................................................................................................................................... 64
FIGURA 49. MODELO-02 – PÓRTICO PLANO COM 4 METROS DE COMPRIMENTO
E 4 METROS DE ALTURA..........................................................................................65
FIGURA 50. MODELO PARA VALIDAÇÃO DO DIMENSIONAMENTO DA
ARMADURA LONGITUDINAL.....................................................................................65
FIGURA 51. JANELA DO PROGRAMA COM A INSERÇÃO DOS DADOS DEFINIDOS
NO EXEMPLO UTILIZADO PARA VALIDAÇÃO DO DIMENSIONAMENTO...............66
FIGURA 52. REAÇÕES NOS APOIOS CALCULADAS PELO SOFTWARE
DESENVOLVIDO – MODELO-01................................................................................67
FIGURA 53. REAÇÕES NOS APOIOS CALCULADAS PELO PROGRAMA FTOOL –
MODELO-01................................................................................................................ 67
FIGURA 54. ESFORÇOS CORTANTES CALCULADOS PELO SOFTWARE
FIGURA 55. ESFORÇOS CORTANTES CALCULADOS PELO PROGRAMA FTOOL –
MODELO-01................................................................................................................ 68
FIGURA 56. MOMENTOS FLETORES CALCULADOS PELO SOFTWARE
FIGURA 57. MOMENTOS FLETORES CALCULADOS PELO PROGRAMA FTOOL –
MODELO-01................................................................................................................ 69
FIGURA 58. VALORES DOS ESFORÇOS INTERNOS CALCULADOS PELO
SOFTWARE DESENVOLVIDO – MODELO-01...........................................................70
FIGURA 59. VALORES DOS DESLOCAMENTOS CALCULADOS PELO SOFTWARE
FIGURA 60. DIAGRAMA DE DESLOCAMENTOS OBTIDO PELO SOFTWARE
FIGURA 61. DIAGRAMA DE DESLOCAMENTOS NO EIXO Y OBTIDO PELO
PROGRAMA FTOOL – MODELO-01...........................................................................72
FIGURA 62. DIAGRAMA DE ROTAÇÕES OBTIDO PELO PROGRAMA FTOOL –
MODELO-01................................................................................................................ 72
viii
FIGURA 63. REAÇÕES NOS APOIOS CALCULADAS PELO SOFTWARE

FIGURA 64. REAÇÕES NOS APOIOS CALCULADAS PELO PROGRAMA FTOOL –
MODELO-02................................................................................................................ 73
FIGURA 65. ESFORÇOS NORMAIS CALCULADOS PELO SOFTWARE
FIGURA 66. ESFORÇOS NORMAIS CALCULADOS PELO PROGRAMA FTOOL –
MODELO-02................................................................................................................ 74
FIGURA 67. ESFORÇOS CORTANTES CALCULADOS PELO SOFTWARE
MODELO-02................................................................................................................ 76
FIGURA 69. MOMENTOS FLETORES CALCULADOS PELO SOFTWARE
MODELO-02................................................................................................................ 77
FIGURA 71. VALORES DOS ESFORÇOS INTERNOS CALCULADOS PELO
SOFTWARE DESENVOLVIDO – MODELO-02...........................................................78
FIGURA 72. VALORES DOS DESLOCAMENTOS CALCULADOS PELO SOFTWARE
FIGURA 73. DIAGRAMA DOS DESLOCAMENTOS OBTIDO PELO SOFTWARE
FIGURA 74. DIAGRAMA DE DESLOCAMENTOS OBTIDO PELO PROGRAMA
FTOOL – MODELO-02................................................................................................80
FIGURA 75. MODELO UTILIZADO PARA VALIDAÇÃO DO DIMENSIONAMENTO DA
ARMADURA LONGITUDINAL.....................................................................................81
FIGURA 76. RESULTADOS DO DIMENSIONAMENTO DA ARMADURA
LONGITUDINAL OBTIDO PELO PROGRAMA............................................................82
ix
SUMÁRIO
RESUMO...................................................................................................................... iii
ABSTRACT.................................................................................................................. iv
LISTA DE FIGURAS.....................................................................................................v
1. INTRODUÇÃO E JUSTIFICATIVA..........................................................................12
2. OBJETIVOS............................................................................................................14
2.1 OBJETIVO GERAL................................................................................................14
2.2 OBJETIVOS ESPECÍFICOS..................................................................................14
3. REVISÃO BIBLIOGRÁFICA...................................................................................15
3.1 FERRAMENTAS COMPUTACIONAIS ACADÊMICAS VOLTADAS À ANÁLISE

ESTRUTURAL.............................................................................................................15
3.1.1 Ftool....................................................................................................................15
3.1.2 AcadFrame.........................................................................................................16
3.1.3 Trame................................................................................................................. 17
3.2 A LINGUAGEM DE PROGRAMAÇÃO PYTHON...................................................18
3.2.1 Biblioteca NumPy................................................................................................18
3.2.2 Biblioteca Matplotlib............................................................................................18
3.2.3 Biblioteca PyQt e Qt Designer.............................................................................19
3.2.4 Qt Designer.........................................................................................................19
3.3 ANÁLISE ESTRUTURAL.......................................................................................20
3.3.1 Modelo Estrutural................................................................................................20
3.3.2 Teoria Elementar De Vigas.................................................................................22
3.3.3 Método Dos Elementos Finitos – MEF................................................................27
3.3.4 Método De Galerkin – Resíduos Ponderados.....................................................27
3.3.5 Transformação Do Sistema De Coordenadas –Local Vs Global.........................28
3.3.6 Funções Aproximadoras E De Forma.................................................................30
3.3.7 Matriz De Rigidez Do Elemento Finito.................................................................31
x
3.3.8 Matriz De Rigidez Global Da Estrutura................................................................33
3.3.9 Vetor De Cargas Nodais Equivalentes................................................................37
3.3.10 Esforços Nodais Atuantes No Elemento Finito..................................................39
3.4 DIMENSIONAMENTO ESTRUTURAL...................................................................40
3.4.1 Verificação Da Segurança..................................................................................40
3.4.2 Capacidade Resistente.......................................................................................41
3.4.2.1 Estádio I...........................................................................................................41
3.4.2.2 Estádio II.......................................................................................................... 42
3.4.2.3 Estádio III.........................................................................................................43
3.4.3 Hipóteses de dimensionamento..........................................................................44
3.4.4 Diagramas tensão deformação...........................................................................44
3.4.5 Domínios de deformação....................................................................................45
3.4.5.1 Domínio 2.........................................................................................................46
3.4.5.2 Domínio 3.........................................................................................................46
3.4.6 Dimensionamento da seção retangular com armadura simples..........................46
4. METODOLOGIA......................................................................................................50
4.1 INTRODUÇÃO.......................................................................................................50
4.2 APRESENTAÇÃO DA INTERFACE GRÁFICA DO PROGRAMA..........................50
4.3 ARMAZENAMENTO E FLUXO DE MANIPULAÇÃO DE DADOS..........................56
4.3.1 Inserção dos nós.................................................................................................57
4.3.2 Inserção dos elementos......................................................................................57
4.3.3 Inserção das propriedades físicas e mecânicas dos elementos..........................58
4.3.4 Inserção das condições de contorno...................................................................59
4.3.5 Inserção das cargas nodais................................................................................59
4.3.6 Inserção das cargas distribuídas.........................................................................59
4.4 METODOLOGIA DE CÁLCULO DO SISTEMA......................................................60
4.5 DIMENSIONAMENTO DAS ARMADURAS LONGITUDINAIS...............................63
4.6 MODELOS PARA VALIDAÇÃO DO SOFTWARE..................................................64
4.6.1 Modelos para validação da análise estrutural.....................................................64
xi
4.6.2 Modelo para validação do dimensionamento das armaduras longitudinais.........65
5. RESULTADOS........................................................................................................67
5.1 ANÁLISE DO MODELO-01....................................................................................67
5.1.1 Reações nos apoios da estrutura........................................................................67
5.1.2 Esforços internos................................................................................................67
5.1.2.1 Esforços normais.............................................................................................67
5.1.2.2 Esforços cortantes...........................................................................................68
5.1.2.3 Momentos fletores............................................................................................69
5.1.3 Deslocamentos...................................................................................................71
5.2 ANÁLISE DO MODELO-02....................................................................................73
5.2.1 Reações nos apoios da estrutura........................................................................73
5.2.2 Esforços internos................................................................................................74
5.2.2.1 Esforços normais.............................................................................................74
5.2.2.2 Esforços cortantes...........................................................................................75
5.2.2.3 Momentos fletores............................................................................................77
5.2.3 Deslocamentos...................................................................................................79
5.3 ANÁLISE PARA VALIDAÇÃO DO DIMENSIONAMENTO DAS ARMADURAS

LONGITUDINAIS......................................................................................................... 81
6. CONCLUSÕES........................................................................................................83
REFERÊNCIAS BIBLIOGRÁFICAS............................................................................84
APÊNDICE A – CÓDIGO DESENVOLVIDO PARA A CONCEPÇÃO DO PROGRAMA
..................................................................................................................................... 87
xii
1. INTRODUÇÃO E JUSTIFICATIVA
Conforme apresentado por Kim e Sankar (2011), de maneira geral, a solução de

problemas (modelos) de engenharia apresenta um grau de complexidade que não permite
sua representação por expressões matemáticas simples, uma vez que, na maioria dos
casos resultam em equações algébricas, diferenciais e integrais, ou em suas combinações,
remetendo à aplicação de métodos numéricos para sua resolução. Salientam ainda que, o
Método dos Elementos Finitos (MEF) permite a geração de programas computacionais
versáteis para a resolução de problemas relacionados às estruturas, ressaltando a
existência de sérios riscos frente ao uso desses programas sem o adequado conhecimento
da teoria que lhes serve de alicerce.
Frente ao exposto, observa-se que o desenvolvimento de ferramentas
computacionais voltadas à análise estrutural vem se difundido crescentemente no meio
acadêmico, seja pela motivação e interesse na área de pesquisa, limitações e/ou restrições
apresentadas por softwares livres, ou mesmo devido aos altos investimentos necessários
para aquisição de licenças de softwares profissionais. Outros fatores relacionados devem-se
ao fato de não se ter conhecimento das considerações adotadas pelos desenvolvedores
desses programas, cujo uso acadêmico é livre, já que o acesso a tais informações é
geralmente restrito. Assim, desenvolver ferramentas em que tais considerações sejam
abertas ao usuário, confere a este maior confiança quanto aos resultados obtidos nas
análises.
Segundo Piedade Neto et al (2011), em muitos centros de pesquisa o
desenvolvimento desse tipo de ferramenta tem sido realizado de maneira individual ou por
pequenos grupos, remetendo à elevada produção de conteúdo científico. No entanto, este
mostra-se desconexo perante as funcionalidades dos softwares desenvolvidos por outros
grupos, uma vez que os códigos que poderiam ser utilizados e aprimorados por outros
pesquisadores tornam-se ferramentas de pesquisa utilizadas por uma única pessoa ou
grupo restrito.
Atualmente, existe um considerável número de softwares de uso livre desenvolvidos
para a área de estruturas, estando entre os principais: Ftool, Acadframe e Trame. Por se
tratar de softwares desenvolvidos com foco em estudos acadêmicos, podem, entretanto,
apresentar algumas limitações a outros usuários, exceto aos desenvolvedores, posto que
foram criados para suprir necessidades específicas, sejam em relação ao modelo estrutural
passível de análise, ou em relação aos materiais que possam ser inseridos, a fim de
dimensioná-los ou verifica-los em seus estados limites.
Considerando que os softwares citados estão entre os mais utilizados no meio
acadêmico, uma vez que apresentam confiabilidade em seus resultados, no entanto não
13
contemplam o dimensionamento de vigas em concreto armado, o desenvolvimento de uma
ferramenta que permita tal procedimento contribui de forma significativa aos estudos
acadêmicos voltados à análise estrutural. Além disso, sendo o código do software
desenvolvido aberto, este pode ser otimizado, adaptado ou ainda ampliado com a inserção
de novos módulos, conforme as necessidades de seus usuários, obtendo desta forma um
programa com maiores recursos e funcionalidades.
14
2. OBJETIVOS
2.1 OBJETIVO GERAL
Desenvolvimento de software voltado à análise de estruturas planas através da

aplicação do método dos elementos finitos e ao dimensionamento da armadura longitudinal
de vigas de concreto armado sob flexão simples conforme as recomendações da NBR 6118
(ABNT, 2014).
2.2 OBJETIVOS ESPECÍFICOS
Diante do objetivo proposto, este estudo teve como objetivos específicos:

a) Implementar o código fonte do software, fazendo uso da linguagem de
programação Python;
b) Criar uma interface gráfica amigável ao usuário utilizando o programa Qt
Designer em conjunto com a biblioteca PyQt do Python;
c) Criar modelos para a validação do software por meio de análises
comparativas entre os resultados apresentados pelo programa e os obtidos
em softwares semelhantes (e.g. Ftool);
d) Dimensionar as armaduras longitudinais de vigas de concreto armado sob
flexão simples, com uso do software que será desenvolvido e validar os
resultados por meio da simulação de modelos propostos na literatura.
15
3. REVISÃO BIBLIOGRÁFICA
Este capítulo aborda temas pertinentes ao desenvolvimento deste projeto.

Inicialmente são apresentadas algumas ferramentas computacionais desenvolvidas no meio
acadêmico, as quais são similares ao software desenvolvido neste trabalho. Em seguida faz-
se uma breve introdução sobre a linguagem de programação Python e as bibliotecas aqui
aplicadas, já que esta foi a linguagem selecionada para a implementação do código fonte do
programa. Apresenta-se ainda, a metodologia de abstração e concepção do modelo
estrutural utilizado, bem como a metodologia de cálculo aplicada.
3.1 FERRAMENTAS COMPUTACIONAIS ACADÊMICAS VOLTADAS À ANÁLISE ESTRUTURAL
Com o intuito de reduzir o tempo dispensado na análise e dimensionamento de

estruturas, são desenvolvidas ferramentas computacionais com a função de automatizar o
processo de cálculos, propondo soluções com maior grau de confiabilidade e
dimensionamentos mais econômicos.
Conforme Piedade Neto et al (2011), tais ferramentas são implementadas por
profissionais de diversas áreas, como física e engenharia. Assim, essas ferramentas têm
sido desenvolvidas e utilizadas desde o surgimento dos computadores, dando suporte aos
projetos de engenharia.
Dentre as ferramentas de análise estrutural voltadas ao meio acadêmico, são
apresentadas aquelas que serviram como base a este estudo, as quais foram definidas
como referência por apresentarem similaridade ao programa desenvolvido neste trabalho.
3.1.1 Ftool
Criado com o objetivo de auxiliar os estudantes de engenharia estrutural na

compreensão do comportamento estrutural de pórticos planos, o Ftool (Two-dimensional
Frame Analysis tool) consiste em uma ferramenta de análise onde a resolução é dada por
meio do método da rigidez direta, no qual o usuário interage com o sistema através da
manipulação direta, fazendo uso de menus em cascata e botões, contidos no sistema de
janelas da interface gráfica do programa (KAEFER, 2000)
Segundo Martha (2015), idealizador e responsável pelo programa, o
desenvolvimento do Ftool teve início em 1991, tendo sua primeira versão lançada em 1995.
Desde então, o software vem sendo ampliado e aprimorado constantemente, estando
atualmente em sua versão 4.00.04, lançada em janeiro de 2018.
16
Embora o Ftool permita a análise do comportamento de estruturas planas (vigas,
pórticos e treliças), o programa não tem como objetivo o dimensionamento dos elementos
analisados, porém leva em consideração as propriedades do material atribuído à estrutura
em análise, bem como as dimensões da seção transversal definida pelo usuário. A interface
gráfica do programa (Figura 1), além de ser amigável ao usuário, é bastante interativa,
permitindo a rápida familiarização do usuário com o programa.
Figura 1. Interface gráfica do programa Ftool.
Fonte: Martha (2017).
3.1.2 AcadFrame
Desenvolvido com o intuito de oferecer uma ferramenta simples e eficiente para a

solução de problemas da engenharia estrutural, o AcadFrame teve sua primeira versão
concluída e disponibilizada, para a comunidade da Universidade de São Paulo, em agosto
de 2006. Concebido por meio de pesquisas relacionadas à análise não linear geométrica de
estruturas, que resultou no chamado Elemento Finito Posicional, a ferramenta permite a
simulação de pórticos e treliças planas, incluindo nessa análise os efeitos da temperatura e
a combinação das ações externas (CODA e PACCOLA, 2009).
Ormonde (2013) salienta que, a interface gráfica para definição da geometria e
lançamento dos carregamentos do AcadFrame é semelhante a do Ftool, porém apresenta
menos interatividade na modificação e visualização da estrutura, podendo dificultar
trabalhos em que a estrutura seja composta por elevado número de elementos de barras.
O ambiente de trabalho do AcadFrame é ilustrado na Figura 2, onde são destacados:
1) menu superior, 2) menu lateral, 3) área de trabalho e 4)barra de mensagens.
Figura 2. Interface gráfica do programa AcadFrame Beta.
17
Fonte: Coda e Paccola (2009).
3.1.3 Trame.
Voltado para a análise do comportamento estrutural de treliças planas, o Trame

ganhou sua versão (proprietária) em novembro de 2004, sendo sua primeira versão gratuita
disponibilizada na internet em fevereiro de 2005. O programa, que é especialmente voltado
a projetos de treliças em madeira, faz uso do Método dos deslocamentos para a análise
elástica linear da estrutura (ORMONDE, 2013).
Figura 3. Interface gráfica do programa Trame 4.0.
Fonte: Ormonde (2013).
18
3.2 A LINGUAGEM DE PROGRAMAÇÃO PYTHON
Criada em 1990, Python consiste em uma linguagem de programação de altíssimo

nível orientada a objetos, de tipagem dinâmica e forte, interpretada e interativa. Seu criador,
Guido Van Rossum, do Instituto Nacional de Pesquisa para Matemática e Ciência da
Computação da Holanda (CWI), tinha como foco usuários das áreas de física e engenharia,
fato que o remeteu a criação de uma linguagem de sintaxe clara e concisa, garantindo maior
produtividade aos usuários da plataforma, devido à legibilidade de seu código fonte
(BORGES, 2010).
Em constante crescimento, a linguagem vem sendo utilizada em diversas áreas da
computação, como inteligência artificial, bancos de dados, biotecnologia, animação 3D,
aplicativos para celulares, jogos, plataformas web entre outros. Essa crescente demanda
deve-se ao fato da linguagem Python ser completa, contando com inúmeras bibliotecas que
auxiliam no desenvolvimento de softwares de distintas áreas de estudo (MENEZES, 2014).
Conforme apresentado por Borges (2010), a linguagem de programação Python vem
sendo utilizada por empresas de alta tecnologia estando entre elas:
 Google (para aplicações web);
 Yahoo (para aplicações web);
 Microsoft (Iorn Python: Python para .NET);
 Nokia (linhas recentes de celulares e PDAs);
 Disney (animações 3D).
3.2.1 Biblioteca NumPy
Fundamental para computação científica, NumPy é uma biblioteca do Python que

fornece um objeto de matriz multidimensional, além de uma variedade de rotinas para
operações com matrizes, incluindo matemática, lógica, manipulação de formas,
classificação, seleção, transformadas discretas de Fourier, álgebra linear básica, operações
estatísticas básicas, simulação aleatória entre muitas outras funções (SCIPY, 2020).
3.2.2 Biblioteca Matplotlib
Consiste em uma biblioteca do Python voltada a plotagem de gráficos. Com ela é

possível a geração de histogramas, espectros, gráficos de barras, gráficos de erros, gráficos
de dispersão, dentre muitos outros, sendo seu conjunto de funções similares aquelas
utilizadas no MATLAB (SCIPY, 2020).
19
3.2.3 Biblioteca PyQt e Qt Designer
Segundo apresentado por Borges (2010), o PyQt é um conjunto de ferramentas que

pode ser utilizado por diversos programas além do Python. Embora seja mais utilizado para
a criação de Interfaces Gráficas com Usuário (Graphic User Interface - GUI), o PyQt possui
bibliotecas com outras funcionalidades, como acesso a banco de dados. Entre o conjunto de
módulos contido no PyQt, destacam-se como principais o QtGui, que define as rotinas de
interface, e o QtCore, que define estruturas essenciais para o funcionamento dos sinais
(eventos executados pelo usuário).
3.2.4 Qt Designer
Como complemento ao PyQt, é possível a utilização do Qt Designer (Figura 4), que

consiste em uma ferramenta para a construção da interface gráfica com o usuário na qual
após ser criada uma janela principal, são inseridos através do sistema drag-and-drop
(arrastar e soltar) os itens que irão compor a interface (botões, caixas de texto, etc.). Tal
ferramenta tem como objetivo facilitar a criação dessas interfaces, além de apresentar a
possibilidade de visualização do que está sendo criado pelo desenvolvedor em tempo real.
Figura 4. Interface gráfica do Qt Designer.
Fonte: Borges (2015).
Após a interface ter sido criada no Qt Designer, um arquivo XML é gerado (com a
extensão .ui). Este arquivo depois de convertido para um módulo Python (com extensão
.py), através do utilitário pyuic, pode então ser importado ao código fonte do software criado
(BORGES, 2010).
20
3.3 ANÁLISE ESTRUTURAL
3.3.1 Modelo Estrutural
A análise estrutural consiste na previsão do comportamento de uma estrutura, com o

intuito de que esta atenda às condições de segurança e utilização para a qual foi projetada.
Esse comportamento pode, através dos estudos da mecânica, ser expresso por diversos
parâmetros como: campos de tensões, deformações e deslocamentos que ocorrem na
estrutura, sendo o principal objetivo desta análise a verificação dos esforços internos e
externos (carregamentos e reações de apoio), e de suas tensões correspondentes, além da
determinação dos deslocamentos e deformações dos elementos estruturais (MARTHA,
2010; SUSSEKIND, 1981).
Conforme apresentado por Martha (2010), a análise estrutural moderna é composta
por quatro níveis de abstração (Figura 5) relacionados à estrutura que está sendo analisada.
Figura 5. Níveis de abstração de uma estrutura.
Fonte: Adaptado de Martha (2010) (b); DS Engenharia (2012) (a); Kim e Sankar (2011) (c).
O primeiro nível de abstração (Figura 5.a) trata da representação da estrutura no

mundo físico, ou seja, é o modelo real da estrutura como construída, estando presentes
todas as propriedades geométricas da estrutura.
Da idealização do modelo real, passa-se para o segundo nível de abstração onde é
obtido o modelo estrutural (Figura 5.b), que consiste na representação matemática (ou
analítica) da estrutura, onde estão incorporadas as teorias e hipóteses que descrevem o
comportamento da estrutura frente as solicitações as quais será submetida. Tais teorias e
hipóteses possuem como alicerce as leis físicas como o equilíbrio entre forças e tensões, a
compatibilidade entre deslocamentos e deformações, além das leis constitutivas dos
21
materiais. Assim, os elementos estruturais passam representados por barras unifilares
(linhas), que representam os eixos dos elementos estruturais, estando o comportamento do
meio sólido contínuo contido no eixo das barras.
Com base em teorias físicas e em resultados experimentais e estatísticos, algumas
hipóteses simplificadoras podem ser adotadas na concepção do modelo estrutural:
 Hipóteses sobre a geometria do modelo;
 Hipóteses relacionadas às condições de suporte (ligações com o meio
externo);
 Hipóteses sobre o comportamento dos materiais;
 Hipóteses sobre as solicitações atuantes na estrutura.
A Figura 6 apresenta um dos pórticos de um galpão em modelo real e modelo
estrutural, neste último, os elementos estruturais de vigas e pilares são representados por
barras, ficando as informações tridimensionais dos elementos representadas por
propriedades globais de sua seção transversal, como a área e o momento de inércia.
Figura 6. Representação dos modelos real e estrutural.
A passagem do segundo para o terceiro nível de abstração, é denominada como

discretização do modelo, que consiste na substituição do comportamento analítico do
modelo estrutural pelo comportamento discreto. No modelo discreto (Figura 5.c), as
soluções analíticas contínuas passam a ser representadas por um conjunto de variáveis ou
parâmetros discretos, definidos com base no método adotado para a análise estrutural (e.g.
Método das Forças, Método dos Deslocamentos e Método dos Elementos Finitos - MEF).
A Figura 7 apresenta a discretização de um elemento de pórtico plano utilizando o
método dos elementos finitos, onde os graus de liberdade do elemento estrutural são:
deflexões longitudinais (u), deflexões transversais ( v) e rotações (θ ).
22
Figura 7. Deslocamentos e rotações nodais para um
elemento de pórtico plano.
Fonte: Autor (2020).
Após a discretização do modelo, o qual geralmente apresenta elevada complexidade

devido ao seu grau de hiperestaticidade, a análise estrutural pode então ser realizada por
meio de métodos computacionais, sendo neste estudo implementado o Método dos
Elementos Finitos.
3.3.2 Teoria Elementar De Vigas
Conforme abordado por Beer e Johnston (2015); Hibbeler (2013); Kim e Sankar
(2011); Martha (2010); Timoshenko e Gere (1983), a análise do comportamento de
estruturas reticuladas tem como base a teoria da viga de Navier (1785-1836), a qual é
fundamentada em duas hipóteses simplificadoras: a primeira, originalmente proposta por
Jacob Bernoulli (1654-1705), expressa o fato de que, as seções transversais de uma viga
permanecem planas após a viga ter sido deformada; a segunda consiste em desprezar as
deformações geradas por forças de cisalhamento. Assim, da união destas hipóteses tem-se
que, estando a viga deformada por flexão simples, suas seções transversais são mantidas
planas e normais ao eixo da viga. Além disso, segundo salientado por Martha (2010), uma
vez que cada seção transversal da viga permanece unida a suas adjacentes, existe a
continuidade de deslocamentos em todos os pontos interiores de uma viga que sofre flexão
simples.
Frente ao fato de que a análise estrutural será realizada por meio da aplicação do
método dos elementos finitos, onde os graus de liberdade da estrutura são os
deslocamentos e as rotações da seção transversal, apresenta-se a formulação da equação
diferencial da viga de Navier.
Inicialmente serão determinadas as relações entre os deslocamentos e as
deformações em uma viga. Desta forma, define-se um sistema de coordenadas locais (ou
eixos locais) para uma barra conforme apresentado na figura Figura 8. Definido o sistema de
eixos locais, e tomando como modelo uma viga engastada em uma de suas extremidades,
traça-se a sua curva elástica onde podem ser representados os deslocamentos e rotações
que ocorrem na viga sob flexão.
23
Figura 8. Sistema de eixos locais e elástica
da barra.
Assim são definidos:

u ( x ): deslocamento axial na direção x;
v( x): deslocamento transversal na direção de y;
θ(x ): rotação da seção transversal por flexão em torno do eixo z.
Considerando que os deslocamentos são pequenos, a rotação da seção transversal

pode ser aproximada pela tangente da curva elástica (θ ≈ tan θ ), podendo o deslocamento
transversal ser associado à rotação da seção transversal, sendo a equação resultante
considerada uma equação de compatibilidade (MARTHA, 2010).
dv
θ(x )= [1]
dx
Considerando a rotação relativa por flexão (dθ ) de um elemento infinitesimal de barra

(dx ) conforme ilustrado na Figura 9, verifica-se que a deformação por flexão é obtida pela
razão entre o encurtamento da fibra (δ ) e seu comprimento inicial (dx ).
Figura 9. Rotação relativa por flexão de um elemento

infinitesimal de barra.
Fonte: Martha. (2010).
24
Sendo:
δ ≈ dθ . y [2]
A deformação normal na direção do eixo longitudinal é dada por:
dθ
ε fx =− y [3]
dx
ε fx : deformação normal na direção de x devido a flexão.
Da relação:
dx= ρdθ [4]
Resulta:
1 dθ
= [5]
ρ dx
dθ : rotação relativa interna por flexão de um elemento infinitesimal;

ρ : raio de curvatura da linha elástica transversal v( x);
1/ ρ: curvatura da linha elástica transversal v( x).
Aplicando a Equação 1 na Equação 3 e em seguida na Equação 5 é possível

escrever as relações:
d²v
ε fx =− y [6]
dx ²
1 d² v
= [7]
ρ dx ²
Sendo o equilíbrio do elemento infinitesimal apresentado na Figura 10.
25
Figura 10. Equilíbrio do elemento infinitesimal.
Fonte: Martha. (2010).
Podem ser escritas as equações:
dQ
∑ F y =0 → dx =q(x ) [8]
dM
∑ M o =0 → dx
=Q( x ) [9]
Das quais obtêm-se a relação:
d2 M
=q ( x) [10]
d x2
Fazendo o equilíbrio entre o momento fletor ( M ) e as tensões normais (σ ) atuantes

na seção transversal.
❑
M =−∫ y σ fx dA [11]
A
Aplicando a Lei de Hooke para escrever a relação entre as tensões e deformações:
σ fx =E ε fx [12]
Substituindo a Equação 3 na Equação 12:
dθ
(
σ fx =E − y
dx ) [13]
Aplicando a Equação 13 na Equação 11 e reorganizando os termos tem-se:
❑
dθ
M =E
( ∫ y 2 dA
A
) dx
[14]
26
O momento de inércia da seção transversal é dado por:
I =∫ y ² dA [15]
Portanto, a Equação 14 torna-se:
dθ
M =EI [16]
dx
dθ
Conforme apresentado na Equação 5, a relação representa a curvatura da linha
dx
elástica v( x), podendo a Equação 16 ser reescrita.
d ²v
M =EI [17]
dx ²
M : momento fletor;
E : módulo de Young – módulo de elasticidade;
I : momento de inércia da seção transversal.
Combinando as Equação 10 e Equação 17, é possível escrever:
d2 d2 v
dx ²[EI
dx ² ]
=q ( x) [18]
d4 v q ( x )
= [19]
d x 4 EI
Sendo q (x) a força atuante na barra

Desta forma, fica definida a equação diferencial da viga de Navier com momento de
inércia ( I ) constante.
3.3.3 Método Dos Elementos Finitos – MEF
Com origem na mecânica estrutural, o método dos elementos finitos (MEF) consiste
em uma poderosa ferramenta para a análise das estruturas, auxiliando na resolução de
27
equações diferenciais-parciais e equações integrais-diferenciais. Seu princípio é embasado
na discretização (divisão) do sistema estrutural analisado em elementos menores,
denominados elementos finitos. Para cada elemento são identificados os graus de liberdade
que descrevem seu comportamento, podendo assim, serem determinadas as equações que
apresentam seu comportamento e sua interação com os elementos vizinhos por meio dos
nós compartilhados, obtendo ao fim da análise a resposta global da estrutura com base nas
solicitações impostas (KIM e SANKAR, 2011).
3.3.4 Método De Galerkin – Resíduos Ponderados
Dada a complexidade apresentada pelos modelos matemáticos utilizados para a

análise estrutural, foram desenvolvidos métodos aproximados para a solução dos sistemas
de equações, sendo os métodos de Galerkin e de Rayleigh-Ritz os mais conhecidos, dos
quais originou-se o método dos elementos finitos (Assan, 2003). Para a aplicação do
método de Galerkin, não é necessária a existências de um funcional, pois o método utiliza
diretamente a equação diferencial (forma forte) que descreve o problema em análise. Assim,
a resolução do sistema de equações diferenciais dá-se substituindo na equação ou nas
equações diferenciais, funções aproximadoras que satisfaçam as condições de contorno.
Conforme salienta Assan (2003), uma vez que as funções aproximadoras não
remetem à solução exata, são gerados resíduos que devem ser ponderados por meio de
funções ponderadoras, devendo o produto entre a função residual e cada função
ponderadora ser assumido como nulo no domínio de integração, ficando definida a condição
de ortogonalidade.
Para um sistema de equações lineares dado por:
Lv=f [20]
Onde f é uma função ponderadora, L um operador e v uma função que satisfaz as

condições de contorno. Assim, admite-se uma função aproximadora v́ para v .
n
v́=∑ ai ϕi [21]
i=1
Sendo ϕ i funções ponderadoras (ou de forma) que satisfazem as condições de

contorno do problema.
28
Ao substituir v por v́ , a igualdade apresentada na Equação 20 não é mais verificada,
havendo um erro dado por:
ϵ =¿L v́−f [22]
Assim, o método de Galerkin exprime a condição de ortogonalidade entre a função ϵ

e as funções ponderadoras ϕ i resultando:
∫ ( L v́ −f ) ϕi dV =0 ,i=1, 2 , … , n [23]
V
Logo, os coeficientes a i podem ser obtidos pela solução do sistema de n equações

representado na Equação 23, sendo estes coeficientes determinados de modo que os
resíduos se anulem em cada integração ponderada.
3.3.5 Transformação Do Sistema De Coordenadas –Local Vs Global
Figura 11 Transformação do sistema de coordenadas – Local vs Global.
A Figura 11a apresenta um elemento finito de pórtico plano, rotacionado por um

ângulo α , com os seis graus de liberdade dispostos segundo um referencial local que está
atrelado às direções do eixo da barra e ortogonal a ele. A Figura 11b ilustra o mesmo
elemento com seus graus de liberdade agora dispostos segundo um referencial global.
Com base no apresentado, é possível extrair as seguintes relações:
29
uiG =uiL cosα−viL senα
viG =uiL senα + v iL cosα [24]
θiG =θiL
Os subíndices G e L representam os sistemas de coordenadas global e local

respectivamente, sendo i o índice do nó analisado.
Atribuindo as relações aos seis graus de liberdade do elemento finito e escrevendo

na forma matricial tem-se:
u1G u1L
{ }[ ]{ }
cos α −sin α 0 0 0 0
v 1G sin α cos α 0 0 0 0 v 1L
θ1G θ1L
= 0 0 1 0 0 0
[25]
uG2
0 0 0 cos α −sin α 0 u2L
vG2 0 0 0 sin α cos α 0 v 2
L
0 0 0 0 0 1 2
θ2G θL
Que pode ser escrita na forma compacta como:
{V }=[T ]{v } [26]
Assim, o vetor {V } contém os graus de liberdade no sistema global da estrutura, a

matriz [T ] representa a matriz de transformação entre o sistema de coordenadas locais
(relacionado ao elemento finto) e o sistema de coordenadas globais (relacionado à estrutura
como um todo) e o vetor { v } traz os graus de liberdade dos nós no sistema de coordenadas
local.
3.3.6 Funções Aproximadoras E De Forma
É importante ressaltar que este trabalho não tem como objetivo esgotar o tema em
questão. Assim, a obtenção das funções aproximadoras e de forma é apresentada de
maneira sucinta, podendo maiores detalhes quanto ao desenvolvimento do tema serem
30
obtidos na literatura que embasou este subcapítulo (Método dos Elementos Finitos; Assan,
2003).
A fundamentação para obtenção das funções aproximadoras e das funções de forma
é dada como base na Figura 7.
Figura 12 (reapresentação da Figura 7) -

Deslocamentos e rotações nodais para um elemento
de pórtico plano.
Conforme apresentado por Assan (2003), o elemento finito de pórtico plano possui
como incógnitas nodais duas translações u e v , longitudinal e transversal respectivamente,
além de uma rotação θ .
Admitindo que a deformação longitudinal ε seja constante ao longo do elemento
finito, tais deslocamentos podem ser representados por uma reta, sendo sua função
aproximadora dada por:
u(x )=a 1+ a2 x [27]
Logo, os deslocamentos transversais devem ser representados por um polinômio do

terceiro grau na forma:
v( x)=a3+ a4 x +a5 x 2+ a6 x3 [28]
Uma vez que é mais cômodo trabalhar com as funções aproximadoras explicitadas
em relação às incógnitas nodais, tem-se:
u=( 1−ξ ) u 1+ ξ u2 [29]
v=( 1−3 ξ 2 +2 ξ3 ) v 1+ ( ξ−2 ξ2 +ξ 3 ) lθ 1+ ( 3 ξ2−2ξ 3 ) v 2 + ( ξ 3−ξ2 ) lθ 2 [30]
31
x
Sendo ξ uma coordenada adimensional dada por ξ= .
l
Assim, a matriz ϕ que contém as funções de forma é representada como segue.
1−ξ 0 0 ξ 0 0
ϕ=
[ 0 1−3 ξ +2 ξ ( ξ−2 ξ + ξ ) l 0 3 ξ −2 ξ ( ξ −ξ 2 ) l
2 3 2 3 2 3 3
] [31]
3.3.7 Matriz De Rigidez Do Elemento Finito
Uma vez que as tensões e deformações no elemento finito de pórtico plano são
compostas por uma parcela relativa ao esforço axial e outra devida ao momento fletor, tem-
se as relações entre esses esforços e os deslocamentos (Assan, 2003).
du
N=σA=EεA=EA [32]
dx
d2 v
M =EIχ =−EI [33]
d x2
Sendo:
E o módulo de Young;
A a área da seção transversal do elemento;
I o momento de inércia da seção transversal em relação ao seu eixo neutro;
ε a deformação longitudinal;
χ a curvatura do eixo da barra no ponto analisado;
N os esforços normais; e
M os momentos fletores.
Representando as Equações 29 e 30 na forma matricial tem-se:
{MN }=[ EA0 EI0 ] {εχ } [34]
Que também pode ser escrita na forma:
σ =D ε [35]
32
Sendo D a matriz que contém os parâmetros elásticos que caracterizam o material.
As deformações associadas ao elemento finito são dadas por:
du 1 du −d 2 v −1 d2 v
ε= = e χ= = 2 [36]
dx l dε d x2 l d ε2
Desta forma, derivando as Equações 29 e 30, é possível relacionar as deformações

às incógnitas nodais por meio da matriz B , que contém as funções de forma.
u1
{}
v1
0 0 1/l 0 0 θ1
{εχ }=[−1/l
0 (12 ξ−6)/l (6 ξ−4)/l 0 (6−12 ξ)/l 2
2
]
(6 ξ−2)/l u2
[37]
v2
θ2
Podendo a equação ser escrita como segue:
ϵ =Bv [38]
Uma vez que as funções aproximadoras são escritas em função das incógnitas
nodais, a matriz de rigidez k do elemento finito de pórtico plano pode ser obtida por meio da
equação:
❑ ❑ ❑
(∫ BT DB dV
V
) v=∫ ϕT b dV +∫ ϕ T p dS
V S
[39]
Sendo v o vetor que contém as incógnitas nodais (graus de liberdade), b o vetor que
representa as ações volumétricas (nulo nesta análise), já que as cargas em questão são
inseridas como ações na estrutura, e p o vetor que contém as ações nodais atuantes.
kv =r [40]
Assim:
33
❑
k =∫ BT DB dV [41]
V
Logo a matriz de rigidez do elemento finito de pórtico é dada por:
EA −EA
0 0 0 0
[ ]
l l
12 EI 6 EI −12 EI 6 EI
0 0
l3 l2 l3 l2
6 EI 4 EI −6 EI 2 EI
0 0
l2 l l2 l
k= [42]
−EA EA
0 0 0 0
l l
−12 EI −6 EI 12 EI −6 EI
0 0
l3 l2 l3 l2
6 EI 2 EI −6 EI 4 EI
0 0
l2 l l2 l
3.3.8 Matriz De Rigidez Global Da Estrutura
A obtenção da matriz de rigidez global da estrutura dá-se por meio incidência

cinemática das matrizes de rigidez de cada elemento sobre a matriz global.
De modo a apresentar a obtenção da matriz de rigidez global da estrutura, toma-se
como base uma adaptação do apresentado por Assan (2003).
Para apresentar a obtenção da matriz de rigidez global de uma estrutura, toma-se
como exemplo o pórtico plano apresentado na Figura 13.
34
Figura 13
Pórtico
plano
modelo para
apresentaçã
o da
obtenção da
matriz de
rigidez
global da
estrutura.
Fonte: Autor
(2020).
A matriz de rigidez global da estrutura consiste em uma matriz quadrada de ordem

(m , n), onde m e n são dados pelo produto entre a quantidade de nós presentes na estrutura
e a quantidade de graus de liberdade de cada nó (3 no caso do elemento de pórtico). Logo,
para a estrutura apresentada (Figura 13), tem-se uma matriz da ordem (12, 12), já que a
estrutura em questão possui quatro nós com três graus de liberdade cada.
35
A Figura 14 apresenta as matrizes de rigidez de cada um dos elementos do modelo
utilizado.
Figura 14 Matrizes de rigidez dos elementos do modelo.
Os valores de k 1ij, k 2ij, k 3ij e k 4ij, com i e j variando de 1 a 12, correspondem aos termos
das matrizes de rigidez dos elementos 1, 2, 3 e 4 respectivamente.
Com o intuito de tornar mais claro o entendimento, as matrizes dos elementos foram
divididas em quadrantes numerados conforme apresenta a Figura 15.
36
Figura 15 Matrizes de rigidez dos elementos do modelo
dividida em quadrantes.
Assim, termo a termo de cada quadrante deve incidir em seus respectivos

quadrantes na matriz de rigidez global da estrutura (Figura 16).
Figura 16 Matrizes de rigidez global da estrutura dividida

em quadrantes.
37
O fato dos quadrantes 12 e 21 estarem em branco na matriz de rigidez global,
elucida que na estrutura utilizada como modelo não há elemento ligando o nó 1 ao nó 2,
sendo a mesma observação válida para os quadrantes 23 e 32.
Com relação aos quadrantes 11, 33 e 44, que são comuns a mais de um elemento,
esses deverão serem somados termo a termo em sua respectiva posição dentro da matriz
1 4
de rigidez global conforme exemplificado na Figura 17 para os termos k 1,1 e k 1,1 que ocorrem
dentro do quadrante 11, o qual se repete nas matrizes dos elementos 1 e 4 do modelo.
Assim, o termo K 1,1 da matriz de rigidez global é dado pela soma k 11,1+ k 41,1.
Figura 17 Aplicação da incidência sobre a matriz de rigidez global da

estrutura.
Uma vez aplicado o exposto para todos os elementos que compõe o modelo
estrutural, tem-se a matriz de rigidez global da estrutura.
3.3.9 Vetor De Cargas Nodais Equivalentes
No contexto desse estudo, as cargas atuantes na estrutura são consideradas

unicamente aplicadas sobre os nós do elemento finito. Desta forma, ao ser aplicado um
carregamento distribuído sobre o elemento, faz-se necessárias a conversão desse
carregamento em cargas nodais equivalentes que serão aplicadas aos nós do elemento.
38
Com o intuito de determinar um vetor genérico das cargas nodais equivalentes,
toma-se um elemento finito inclinado de um ângulo α com a direção horizontal, sendo esse
elemento submetido a ação de um carregamento vertical linearmente variável (Figura 18).
Figura 18 Elemento inclinado com sob ação de um carregamento

linearmente variável.
Fonte: Assan (2003).
Ao decompor o carregamento apresentado na Figura 18 a em uma carga

perpendicular ao elemento finito (Figura 18 b) e outra tangente ao mesmo (Figura 18 c),
obtém-se as relações:
pu ( ξ )=− p1 (1−ξ ) senαcosα −p 2 ξsenαcosα [43]
pv ( ξ )=− p1 ( 1−ξ ) co s 2 α− p2 ξ cos2 α [44]
Nas equações acima, os sinais negativos indicam que pu (ξ ) e pv (ξ ) tem sentido

contrário aos sentido positivo dos eixos ξ e y , respectivamente.
Escrevendo as equações na forma matricial, tem-se:
pu( ξ) −( 1−ξ ) senαcosα −ξsenαcosα p 1

{ }[
pv ( ξ)
=
−( 1−ξ ) co s2 α −ξ cos2 α p2 ]{ } [45]
Ou:
p=F pi [46]
Logo, o vetor das cargas nodais equivalentes pode ser calculado através da
equação:
39
❑
r =∫ ϕT p dS [47]
S
Sendo a matriz ϕ que contém as funções de forma, apresentada na Equação 31.
Desta forma obtém-se:
1 1
( )
p1 + p2 lsenαcosα
{ }
3 2
1
( 7 p 1+ 3 p2 ) lco s 2 α
20
1 1 1
r =−
(
10 2 1 3 2 )
p + p l 2 co s 2 α
[48]
1 1
(
3 2 1 2 )
p + p lsenαcosα
1 2
20
( 3 p 1+7 p2 ) lco s α
−1 1 1
10 3 ( )
p1 + p2 l 2 co s 2 α
2
A este vetor devem ser somadas as cargas diretamente aplicadas sobre os nós
(caso existam) nas posições correspondentes aos graus de liberdade a que se relacionam e
considerando seus sinais corretos, obtendo assim o vetor de cargas nodais equivalentes
total.
3.3.10 Esforços Nodais Atuantes No Elemento Finito
Definidas as matrizes de rigidez [k ] e de transformação do sistema de coordenadas

[T ], bem como o vetor das incógnitas nodais {v } e o vetor das cargas nodais equivalentes
{r }, sendo todos definidos no sistema de coordenas local, é possível determinar os esforços
atuantes nos nós dos elementos finitos através da equação.
T
{ F }=[ T ] [ k ][ T ] {v }−{r } [49]
40
3.4 DIMENSIONAMENTO ESTRUTURAL
Este subcapítulo baseia-se nas recomendações propostas pela NBR 6118 e na

literatura citada, e não tem como objetivo esgotar o tema, uma vez que esse não é objetivo
deste estudo. Assim, apresenta-se o breve embasamento sobre o tema, de modo a garantir
o bom entendimento quanto as considerações adotadas no estudo.
Conforme apresentado por Carvalho e Figueiredo Filho (2015), o dimensionamento
de uma estrutura tem como finalidade impedir a ruína (falha) dessa estrutura ou de suas
partes. Assim, entende-se por ruína não somente o perigo de ruptura, como também as
situações nas quais a edificação não apresenta um perfeito estado para utilização, devido a
deformações excessivas, formação de fissuras, dentre outros. Logo, o dimensionamento
deve garantir a integridade tanto da estrutura, como de seus ocupantes durante sua
execução e utilização (vida útil), devendo a estrutura suportar todas as solicitações as quais
estará submetida.
3.4.1 Verificação Da Segurança
Segundo o item 12.5 da NBR 6118 (ABNT, 2014), para a verificação da segurança
das estruturas de concreto armado, devem ser atendidas além das condições construtivas
as condições analíticas de segurança.
Quanto às condições construtivas, devem ser atendidos as exigências estabelecidas:
 nos critérios de detalhamento previstos nas seções 18 e 20 da norma;
 nas normas de controle dos materiais, especialmente a ABNT NBR 12655;
 no controle de execução da obra, conforme ABNT NBR 14931 e Normas
Brasileiras específicas.
No que diz respeito às condições analíticas e de segurança, a NBR 6118 (ABNT,
2014) estabelece que as resistências não devem ser menores que as solicitações e devem
ser verificadas em relação a todos os estados-limites e todos os carregamentos
especificados para o tipo de construção. Assim, em qualquer caso deve ser respeitada a
condição:
Rd ≥ Sd [50]
41
Onde Rd são os valores de cálculo dos esforços resistentes e Sd são os valores de
cálculo dos esforços solicitantes.
Para a verificação do estado-limite último de perda de equilíbrio como corpo rígido,

Rd e Sd devem assumir os valores de cálculo das ações estabilizantes e desestabilizantes
respectivamente.
Segundo Carvalho e Figueiredo Filho (2015), o método de cálculo semi-probabilístico
baseado na verificação dos estados limites, consiste em um processo simplificado para a
verificação da segurança, já que uma análise probabilística completa seria de grande
complexidade ou mesmo impossível. Logo, admite-se a segurança da estrutura quando
verificadas que as solicitações de cálculo forem menores que os valores suportados pela
estrutura, conforme apresentado na Equação 50.
Com o intuito de garantir a segurança da estrutura, a NBR 6118 (ABNT, 2014) prevê
coeficientes para ponderação das ações (item 11.7) e das resistências (item 12.4) que
devem ser utilizadas no dimensionamento da estrutura, sendo majoradas as ações e
minoradas as resistências, desta forma é possível cobrir maior parte das incertezas
existentes na metodologia de cálculo.
3.4.2 Capacidade Resistente
A capacidade resistente das vigas de concreto é determinada a partir do

comportamento das seções transversais em relação ao aumento do carregamento atuante
até que seja atingida a ruptura total ou parcial desse elemento.
No concreto, essa verificação é feita de acordo com o aumento da incidência de
fissuras na seção tracionada e do comportamento não linear da região comprimida. Assim,
classificam-se três fases distintas, denominadas estádios de dimensionamento. Estando
entre eles: estádio I, estádio II e estádio III (PINHEIRO et al., 2007).
3.4.2.1 Estádio I
Neste estádio (início do carregamento) as tensões normais são suficientemente

baixas de modo que o concreto seja capaz de resistir às tensões de tração. Assim, faz-se
válida a relação linear entre tensões x deformações, ou seja, é válida a lei de Hooke.
A Figura 19 ilustra as tensões e deformações atuantes na seção de concreto no
estádio I.
42
Figura 19 Comportamento do concreto na flexão pura (Estádio I).
Fonte: Adaptado de Pinheiro et al. (2007).
Uma vez que a resistência do concreto à tração é significativamente baixa se

comparada a sua resistência à compressão, torna-se inviável a possibilidade de
dimensionamento neste estádio. Assim, no estádio I faz-se unicamente o cálculo do
momento de fissuração, que separa o estádio I do estádio II.
Conhecido o momento de fissuração, calcula-se a armadura mínima, de modo que
esta seja capaz de absorver, com adequada segurança, as tensões causadas por um
momento fletor de mesma intensidade. Logo, o estádio I termina ao ser iniciado o processo
de formação de fissuras (PINHEIRO et al., 2007).
3.4.2.2 Estádio II
Neste estádio, o concreto passa a não resistir a atuação das tensões de tração,
sendo sua contribuição resistente a esse tipo de esforço desprezada. Nesse momento, a
região tracionada do concreto inicia a fase de fissuração(Figura 20). Entretanto, a relação
linear das tensões ainda é válida para a parte do elemento sob compressão.
No estádio II, podem ser verificados os estados limites de serviço onde são
verificados os limites de aberturas de fissuras e deformações excessivas, podendo ou não
ocorrer o escoamento das armaduras (PINHEIRO et al., 2007).
43
Figura 20 Comportamento do concreto na flexão pura (Estádio II).
3.4.2.3 Estádio III
No estádio III, o concreto tracionado encontra-se totalmente fissurado, como mostra

a Figura 21. Na região comprimida, o concreto atinge a plastificação, estando essa região na
iminência de colapso. Nessa fase, admite-se o diagrama parabólico-retangular para a
representação da distribuição das tensões.
Figura 21 Comportamento do concreto na flexão pura (Estádio III).
Em substituição a esse diagrama (e para efeito de cálculo), a NBR 6118/2014

permite que se trabalhe com o diagrama retangular equivalente.
44
Figura 22 Diagrama retangular – NBR 6118.
3.4.3 Hipóteses de dimensionamento
No dimensionamento de vigas sob flexão normal simples, devem ser consideradas

as hipóteses:
a) As seções transversais permanecem planas e perpendiculares ao eixo
longitudinal da peça, seguindo a teoria clássica de Bernoulli-Euler. A
configuração das deformações é linear até a ruptura do elemento;
b) A ligação entre o concreto e as barras de aço é considerada perfeita, de forma
que, suas deformações sejam iguais na região solicitada;
c) As tensões de tração são obrigatoriamente desprezadas no concreto quando
dimensionadas no estado limite último;
d) Encurtamento convencional de 3,5‰, permitido para o concreto em ruptura;
e) Alongamento máximo de 10‰, para que não haja deformação plástica excessiva
da armadura tracionada;
f) As tensões de compressão no concreto para o diagrama retangular-simplificado e
para as seções retangulares, expressa por altura y=0,80 x e tensão σ cd =0,85 f cd ,
em substituição ao modelo parabólico-retangular.
3.4.4 Diagramas tensão deformação
Conforme apresenta a NBR 6118 (ABNT, 2014), para o dimensionamento de

estruturas em concreto armado devem ser considerados os diagramas tensão deformação
do concreto em compressão (Figura 23.a) e o diagrama com região de escoamento do aço
(Figura 23.b).
45
Figura 23 Diagramas tensão x deformação do concreto e aço – Segundo a NBR 6118
(ABNT, 2014).
Fonte: Adaptado NBR 6118 (2014).
3.4.5 Domínios de deformação
Conforme apresentado por Carvalho e Figueiredo Filho (2015), são definidos seis
domínios de deformação (Figura 24) com base no conjunto de deformações específicas do
concreto e do aço ao longo de uma seção transversal retangular com armadura simples
(apenas tracionada) submetida a ações normais.
A NBR 6118 (ABNT, 2014) apresenta os domínios de deformação correspondentes
aos limites de encurtamento do concreto à compressão simples ou do alongamento
excessivo do aço por deformação plástica excessiva à tração simples. O encurtamento
último do concreto para o caso de flexão simples é igual a ε cd =3,5 ‰, enquanto, que para o
aço o alongamento último é ε yd =10 ‰.

Uma vez que a NBR 6118 (ABNT, 2014) de modo a garantir boas condições de
ductilidade limita a posição da linha neutra ( x /d ≤ 0,45) para concretos de classe até C50,
tem-se que, para o dimensionamento de vigas sob flexão simples deve-se trabalhar em
parte do domínio 3, sendo aceitável o dimensionamento dentro do domínio 2.
Figura 24 Domínios de estado-limite último de uma seção transversal.
Fonte: Carvalho e Figueiredo Filho (2015).
46
3.4.5.1 Domínio 2
No domínio 2 a ruína ocorre devido a deformação plástica excessiva do aço (

ε yd =10 ‰) e a deformação do concreto varia no intervalo 0 ≤ ε cd ≤ 3,5 ‰ . Desta forma, o
concreto não é aproveitado em sua capacidade máxima (PINHEIRO et al., 2007).
3.4.5.2 Domínio 3
Nesse domínio tanto o concreto quanto o aço trabalham com suas capacidades
máximas, a deformação do concreto comprimido varia até ε cd =3,5 ‰, enquanto o
alongamento da armadura tracionada varia da deformação relativa ao escoamento e ao
alongamento máximo permitido (2,07 ≤ ε yd ≤10 ‰ ¿ para o aço CA-50 aplicado neste estudo.
Assim, o concreto encontra-se plastificado e o aço atinge sua tensão de escoamento f yd ,
para qualquer valor de deformação dentro do intervalo de ε yd. Logo, caso ocorra a ruptura,
esta se dará com aviso prévio, pois o concreto apresentará fissuras aparentes e flechas
significativas no momento em que a armadura entrar em sua fase de escoamento
(PINHEIRO et al., 2007).
3.4.6 Dimensionamento da seção retangular com armadura simples
Neste subcapítulo apresenta-se o equacionamento para o dimensionamento para

seções sob flexão simples, considerando concretos de classe até C50 e aço CA-50, sendo a
viga armada com armadura simples.
As vigas com armaduras simples são projetadas de modo que as barras de aço
suportem apenas tensões de tração, sendo as tensões de compressão unicamente
resistidas pela seção de concreto.
De modo a atender os critérios de ductilidade adotados pela NBR 6118 (ABNT,
2014), a Figura 25 apresenta a situação da seção retangular quando submetida a flexão
simples, com as deformações possíveis considerando concretos com classe até C50. Neste
caso, ε lim ¿¿ corresponde ao valor de x /d=0,45 imposta pela norma.
47
Figura 25 Elementos da seção retangular e diagramas de tensões e deformações.
Fonte: Carvalho e Figueiredo Filho (2015).
A Figura 26 apresenta o modelo utilizado para a dedução das expressões para o

dimensionamento de elementos de seção retangular por meio do equilíbrio da seção
transversal.
Figura 26 Equilíbrio da seção transversal para dimensionamento com armadura simples.
Sendo:
h a altura da seção transversal;
d a altura útil da seção transversal;
b w a largura da seção transversal;
x a profundidade da linha neutra;
z o braço de alavanca;
Acc a área de concreto comprimido;
σ c a tensão de compressão atuante no concreto;
f cd a resistência de cálculo do concreto;
A s a área de aço resistente aos esforços de tração;
f yd a resistência de cálculo do aço;
48
F c ação atuante no concreto;
F s ação atuante na armadura;
M Sd Momento solicitante de cálculo;
M Rd Momento resistente de cálculo.
Conforme apresentado por Carvalho e Figueiredo Filho (2015), para o

equacionamento para concretos de classe até C50 tem-se:
a) Equilíbrio da seção transversal:
Equilíbrio das forças normais atuantes na seção:
Σ F=0→ F s−F c =0 ∴ F s =F c [51]
Sendo:
F c =0,85 ⋅f cd ⋅bw ⋅0,80 ⋅ x ∴ Fc =0,68⋅ f cd ⋅ bw ⋅ x [52]
F S=f yd ⋅ A s [53]
Com:
f ck f yk
f cd = e f yd = [54]
1,4 1,15
Onde f ck é a resistência característica à compressão do concreto e f yk a resistência

característica à tração do aço.
Equilíbrio dos momentos:
Σ M =0 → M Sd −M Rd =0 ∴ M Sd =M Rd [55]
M Sd =Fc ⋅ z ∴ M sd=F s ⋅ z [56]
49
Uma vez que:
z=d −0,50 ⋅ y ,com y=0,80 ⋅ x [57]
z=d −0,40 ⋅ x [58]
Colocando z e F c na Equação 56 obtém-se:
M Sd =(0,68 ⋅ x ⋅ d−0,272 x 2)⋅ bw ⋅f cd [59]
b) Posição da linha neutra:
Resolvendo a Equação 59, é possível obter o valor de x que define a posição da

linha neutra.
M Sd
x=
√ 2
0,68 ⋅ d ± ( 0,68 d ) −4 ⋅ 0,272⋅
0,544
( bw ⋅ f cd ) [60]
c) Cálculo da armadura longitudinal necessária:
Das Equações 53 e 56 tem-se:
M Sd
A s= [61]
z ⋅ f yd
50
4. METODOLOGIA
4.1 INTRODUÇÃO
O capítulo que segue apresenta a metodologia aplicada para a concepção do

software. Inicialmente será apresentada a interface gráfica desenvolvida para o programa.
Na sequência serão apresentados os métodos utilizados para o armazenamento e
manipulação dos dados inseridos pelo usuário, sendo posteriormente apresentadas as
metodologias de cálculo aplicadas pelo sistema tanto para a análise estrutural, como para o
dimensionamento das armaduras longitudinais das vigas.
Vale ressaltar que este trabalho não tem como objetivo aprofundar o leitor quanto à
linguagem de programação aqui utilizada, entretanto, o código desenvolvido para a
concepção do programa será disponibilizado na íntegra permitindo ao leitor maior
compreensão sobre o funcionamento do sistema.
4.2 APRESENTAÇÃO DA INTERFACE GRÁFICA DO PROGRAMA
Conforme discutido anteriormente, para a concepção da interface gráfica do sistema

fez-se uso do programa Qt Designer em conjunto com a biblioteca PyQt do Python.
Para a criação da interface, que conta com 14 janelas interativas com o usuário,
inicialmente foi definido o fluxo de trabalho a ser seguido (Figura 27), ou seja, o caminho
que o usuário irá percorrer desde a inserção dos dados, até a obtenção dos resultados.
Figura 27. Fluxo para inserção de dados e visualização dos resultados.

1
1
Interface Principal do Programa
2
2
Inserção dos nós da estrutura
3
3
Inserção dos elementos
4
4
Inserção das propriedades físicas e mecânicas dos elementos
5
5 Inserção dos apoios da estrutura - Condições de contorno
6
6 Inserção de cargas nodais
7
7
Inseção de cargas distribuídas
8
8 Visualização dos valores dos esforços internos
9
9 Visualização do diagrama de esforços normais
10
10 Visualização do diagrama de esforços cortantes
11
11 Visualizaçao do diagrama de momentos fletores
12
12
Visualizaçao dos valores dos deslocamentos
13
13
Visualização do diagrama de deslocamentos
14 Dimensionamento das armaduras longitudinais
14
Fonte: Autor. (2020).
51
As 14 janelas que compõe o programa foram criadas em módulos distintos
(independentes), sendo posteriormente interligadas a janela principal (interface) do sistema,
possibilitando ao usuário o acompanhamento em tempo real das informações inseridas na
análise.
A seguir são apresentadas as telas que compõe a interface gráfica do software
desenvolvido neste trabalho.
A Figura 28 mostra a tela inicial do sistema, composta por uma área onde estão
dispostos os botões de acesso às telas de inserção de dados e visualização dos resultados,
contando ainda com uma área (canvas) para a visualização do modelo a ser analisado.
Figura 28 Janela-1 - Interface gráfica do programa.
52
Na Figura 29 é apresentada a tela na qual o usuário faz a inserção dos nós da
estrutura por meio da indicação das coordenadas ( x , y ).
Figura 29 Janela-2 - Inserção dos nós da estrutura.
Após inseridos os nós, o usuário pode então inserir os elementos da estrutura

utilizando os nós como referência (Figura 30).
Figura 30 Janela-3 - Inserção dos elementos da estrutura.
53
Posteriormente, o usuário pode inserir as propriedades físicas e mecânicas dos
elementos da estrutura conforme apresenta a Figura 31. Tais propriedades podem ser
inseridas igualmente a todos os elementos ou de maneira distinta para cada elemento,
conforme opção do usuário.
Figura 31 Janela-4 - Inserção das propriedades físicas e mecânicas dos elementos da

estrutura.
Através da janela de inserção de apoios (restrições nodais) da estrutura, o usuário

pode selecionar os graus de liberdade que devem ser restringidos em um determinado nó,
que pode ser escolhido em uma lista onde constam os nós anteriormente inseridos.
A imagem que segue (Figura 32) apresenta a inserção de um apoio do tipo
engastado no nó 5.
54
Figura 32 Janela-5 - Inserção das restrições nodais.
As cargas nodais são inseridas através de uma janela na qual o usuário pode
selecionar o nó em que as cargas de valor definido irão atuar.
A Figura 33 apresenta o momento em que são inseridas cargas nodais no nó 4 do
modelo.
Figura 33 Janela-6 - Inserção das cargas nodais.
55
De maneira similar, são inseridas as cargas distribuídas, para tal, o usuário seleciona
o elemento onde a carga irá atuar, bem como a orientação ( x , y ) e as cargas inicial (w i) e
final (w f ) que atuarão respectivamente no nó inicial e final do elemento.

A Figura 34 apresenta o momento em que é inserida uma carga distribuída no
elemento 3 do modelo.
Figura 34 Janela-7 - Inserção das cargas distribuídas.
Finalmente, a Figura 35 apresenta a janela onde pode ser dimensionada a armadura

longitudinal da viga sob flexão simples.
Nesta janela, o usuário poderá inserir os seguintes dados para o dimensionamento:
 Coeficiente de ponderação das resistências no Estado Limite Último (ELU);

 Classe de Agressividade Ambiental (CAA) a qual a estrutura estará exposta;
 Dimensão Máxima Característica (DMC) do agregado graúdo;
 Classe do aço;
 Resistência característica a compressão do concreto ( F ck);
 Propriedades geométricas da seção transversa; e
 Momento fletor solicitante ( M Sd ).
56
Figura 35 Janela-10 – Dimensionamento das armaduras.
4.3 ARMAZENAMENTO E FLUXO DE MANIPULAÇÃO DE DADOS
Para o armazenamento e manipulação dos dados inseridos pelo usuário, foi criado
um módulo para servir como banco de dados do software, utilizando a funcionalidade dos
dicionários do Python. Tal funcionalidade permite a busca das propriedades dos nós e
elementos do modelo por meio da identidade dos mesmos, aqui definidas como I dnó e I d elm
respectivamente.
Os dados inseridos pelo usuário são alocados dentro deste módulo e salvos em
arquivos de texto (arquivos do tipo .txt), podendo ser manipulados pelo sistema a qualquer
momento.
57
4.3.1 Inserção dos nós
A Figura 36 apresenta um trecho do código onde é possível visualizar a função

responsável pela inserção e armazenamento de dados referentes aos nós da estrutura
dentro do banco de dados.
Figura 36. Trecho de código para inserção e armazenamento de dados referentes aos
nós da estrutura.
Inicialmente, ao serem inseridos os nós da estrutura, são armazenados somente os

dados referentes a identidade do nó ( I dnó ) e suas coordenadas ( x , y ). Conforme o usuário
segue inserindo outros dados no sistema, como restrições de apoios e cargas, o programa
faz a busca do nó por meio de sua identidade para armazenar os dados que serão
posteriormente utilizados para efetuar os cálculos.
4.3.2 Inserção dos elementos
De maneira análoga, ocorre a inserção dos elementos. Conforme apresenta o trecho

do código que segue (Figura 37), para a inserção dos elementos o usuário deve informar os
nós (inicial e final) aos quais o elemento estará ligado, assim, o programa faz a busca das
informações referentes a esses nós para alimentar o banco de dados.
58
Figura 37. Trecho de código para inserção e armazenamento de dados referentes aos
elementos da estrutura.
4.3.3 Inserção das propriedades físicas e mecânicas dos elementos
Inseridos os elementos, o usuário pode então definir suas propriedades físicas e

mecânicas. Para isso, basta selecionar o elemento ao qual devem ser aplicadas as
propriedades para que o sistema faça a busca do elemento através de sua identidade ( I d elm
) e alimente o banco de dados.
A Figura 38 apresenta o trecho do código responsável por esse processo.
Figura 38. Trecho de código para inserção e armazenamento das

propriedades físicas e mecânicas dos elementos da estrutura.
4.3.4 Inserção das condições de contorno
59
A inserção das condições de contorno (apoios da estrutura), é feita por meio da
seleção do nó a ser restringido e definição das restrições a serem aplicadas ao nó. Assim, o
programa faz a busca do nó por meio de sua identidade alimentando o banco de dados.
O trecho do código referente a essa função é apresentado na Figura 39.
Figura 39. Trecho de código para inserção e armazenamento das restrições

nodais.
4.3.5 Inserção das cargas nodais
A Figura 40 apresenta parte do código responsável pela inserção e armazenamento

dos dados referentes às ações aplicadas aos nós. Esta etapa consiste na escolha do
usuário do nó e determinação das ações que a ele serão aplicadas.
Figura 40. Trecho de código para inserção e armazenamento das

cargas nodais.
4.3.6 Inserção das cargas distribuídas
A inserção das cargas distribuídas é dada por meio da seleção do elemento ao qual
a carga será aplicada, bem como sua orientação ( x , y ) e intensidades inicial e final da
carga, respectivamente w i e w f .
A Figura 41 apresenta o código desenvolvido para essa função.
60
Figura 41. Trecho de código para inserção e armazenamento das cargas distribuídas.
4.4 METODOLOGIA DE CÁLCULO DO SISTEMA
Além do banco de dados onde são armazenados os dados inseridos pelo usuário, foi
desenvolvido um segundo banco de dados similar onde são armazenadas as informações
que serão utilizadas para os cálculos a serem executados pelo sistema.
De modo a obter maior aproximação quanto aos resultados obtidos pelo programa,
foi desenvolvido um módulo responsável por subdividir cada elemento inserido pelo usuário
em 10 novos elementos exatamente idênticos, conforme apresentado na Figura 42. Dessa
forma, 9 novos nós são criados, sendo a análise realizada em um número maior de pontos
da estrutura, permitindo assim a representação gráfica mais precisa dos resultados.
Ressalta-se que havendo necessidade, a quantidade de elementos a serem gerados
pelo programa pode facilmente ser alterada dentro do código.
Figura 42 Elemento definido pelo usuário e elementos gerados pelo sistema.
Gerados os novos elementos, aplica-se o método dos elementos finitos para a

obtenção da matriz de rigidez de cada elemento.
É importante ressaltar que o programa conta com uma função para o tratamento dos
carregamentos distribuídos sobre o elemento. Assim, ao ser subdividido um elemento
inserido pelo usuário, são calculadas pelo programa as cargas nodais equivalentes a serem
aplicadas a cada novo nó gerado pelo sistema. Tais cargas são calculadas conforme
demonstrado anteriormente.
61
Passada esta etapa, o programa faz a incidência cinemática das matrizes de rigidez
dos novos elementos sobre a matriz de rigidez global da estrutura. Logo, são calculados os
esforços e deslocamentos atuantes para o sistema de coordenadas global da estrutura.
A seguir são apresentadas as funções criadas para o desenvolvimento dos cálculos
referentes a análise do modelo estrutural.
Inicialmente é feito o acesso ao banco de dados para a obtenção dos valores a
serem utilizados no procedimento dos cálculos (Figura 43).
Figura 43. Trecho de código para busca de dados para cálculo.
Em seguida é gerada a matriz de transformação do sistema de coordenadas (local x

global), conforme trecho de código apresentado na Figura 44.
Figura 44. Trecho de código para geração da matriz de transformação do sistema de

coordenadas (local x global).
A Figura 45 apresenta o trecho do código responsável pela obtenção da matriz de

rigidez do elemento finito no sistema de coordenadas local.
62
Figura 45. Trecho de código para geração da matriz de rigidez do elemento finito no sistema
de coordenadas local.
A função para a obtenção da matriz de rigidez do elemento finito no sistema de

coordenadas global é apresentada na Figura 46.
Figura 46. Trecho de código para obtenção da matriz de rigidez do elemento finito no
sistema de coordenadas global.
Finalmente, a Figura 47 apresenta o trecho do código responsável pela geração da

matriz de rigidez global da estrutura.
63
Figura 47. Trecho de código para geração da matriz de rigidez global da
estrutura.
Após a obtenção da matriz de rigidez global da estrutura, o programa aplica nesta

matriz as condições de contorno inseridas pelo usuário, e em seguida são calculados os
valores de interesse (reações nos apoios, deslocamentos e esforços internos), podendo o
usuário observar e analisar os resultados por meio de tabelas e gráficos apresentados pelo
programa.
4.5 DIMENSIONAMENTO DAS ARMADURAS LONGITUDINAIS

Conforme apresentado anteriormente, o dimensionamento das armaduras
longitudinais segue as diretrizes impostas pela NBR 6118 (ABNT, 2014), sendo as equações
para os cálculos deduzidas com base no equilíbrio da seção transversal de uma viga de
seção retangular com armadura simples (resistente apenas a esforços de tração).
Para a análise do dimensionamento, o usuário conta com uma interface onde podem
ser inseridos os dados referentes as propriedades dos materiais, bem como as propriedades
geométricas do elemento em estudo, sendo posteriormente inserido o momento fletor
atuante.
Após o sistema ter sido alimentado, é realizado o cálculo da área de aço necessária
para conter os esforços de tração aos quais a peça está submetida, sendo os resultados
apresentados ao usuário.
64
Dada a extensão do código responsável pelos cálculos, o mesmo será apresentado
como apêndice a este trabalho.
4.6 MODELOS PARA VALIDAÇÃO DO SOFTWARE
4.6.1 Modelos para validação da análise estrutural
Visando validar os resultados obtidos pelo software quanto a análise estrutural, fez-
se uso de 2 modelos estruturais, os quais foram analisados pelo programa desenvolvido
neste estudo, sendo os resultados comparados com os aqueles obtidos fazendo uso do
programa ftool.
Para a validação do software foram definidos os modelos:
 Viga biapoiada;
 Pórtico plano.
Para os modelos definidos, foram consideradas as propriedades físicas e mecânicas:
 Elementos de concreto com seção retangular com b w =15 cm e h=30 cm;

 Área da seção transversal igual a 450 cm² ;
 Inércia da seção transversal igual a 33.750 c m 4;
 Módulo de elasticidade igual a 25000 MPa.
A Figura 48 apresenta o Modelo-01, utilizado para validação do programa.
Figura 48. Modelo-01 – Viga biapoiada com 2 metros de comprimento.
O Modelo-02, que consiste em um pórtico plano, com 4 metros de comprimento e 3

metros de altura, é apresentado na Figura 49.
65
Figura 49. Modelo-02 – Pórtico plano com 4 metros de
comprimento e 4 metros de altura.
4.6.2 Modelo para validação do dimensionamento das armaduras longitudinais
Para a validação do dimensionamento das armaduras longitudinais, tomou-se como

base o exemplo apresentado por Mesquita Filho (2015), apresentado na Figura 50.
Figura 50. Modelo para validação do dimensionamento da armadura longitudinal.
Fonte: Adaptado de Mesquita Filho. (2015).
A Figura 51 apresenta a tela do programa com a inserção dos dados definidos no

exemplo utilizado como modelo. Ressalta-se que, de modo a atender ao disposto na NBR
6118 (ABNT, 2014), a classe do concreto foi alterada para 25 MPa. Entretanto, conforme
será apresentado, tal alteração não leva a discrepâncias significativas nos resultados.
66
Figura 51. Janela do programa com a inserção dos dados definidos no
exemplo utilizado para validação do dimensionamento.
67
5. RESULTADOS
5.1 ANÁLISE DO MODELO-01
5.1.1 Reações nos apoios da estrutura
Analisando as imagens que seguem, verifica-se que os valores calculados pelo

programa para as reações nos apoios (Figura 52), são as mesmas obtidas através do
programa ftool (Figura 53).
Figura 52. Reações nos apoios calculadas pelo software desenvolvido – Modelo-01.
Figura 53. Reações nos apoios calculadas pelo programa ftool – Modelo-01.
Fonte: Autor – extraído do programa ftool (2020).
5.1.2 Esforços internos
5.1.2.1 Esforços normais
Para a estrutura definida neste modelo, faz-se dispensável a discussão dos

resultados referentes aos esforços normais, já que não existem ações normais atuantes na
seção transversal do elemento em estudo, tornando nulos esses esforços.
68
5.1.2.2 Esforços cortantes
Conforme apresentado nas imagens que seguem (Figura 54 e Figura 55), os valores
dos esforços cortantes obtidos pelo programa desenvolvido são os mesmos apresentados
pelo programa ftool.
Figura 54. Esforços cortantes calculados pelo software desenvolvido –

Modelo-01.
Figura 55. Esforços cortantes calculados pelo programa ftool – Modelo-01.
69
5.1.2.3 Momentos fletores
As imagens apresentadas a seguir (Figura 56 e Figura 57), elucidam a igualdade dos

valores dos momentos fletores calculados pelo programa frente aos resultados
apresentados pelo programa ftool.
Figura 56. Momentos fletores calculados pelo software desenvolvido –

Modelo-01.
Figura 57. Momentos fletores calculados pelo programa ftool – Modelo-01.
70
Os valores calculados pelo programa também podem ser observados dispostos em
uma tabela conforme apresenta a Figura 58.
Figura 58. Valores dos esforços internos calculados pelo software

desenvolvido – Modelo-01.
71
5.1.3 Deslocamentos
Os deslocamentos calculados para este modelo são apresentados na Figura 59,

sendo o diagrama gerado pelo programa apresentado na Figura 60. Os resultados obtidos
pela ferramenta ftool são apresentados nas Figura 61 e Figura 62.
Figura 59. Valores dos deslocamentos calculados pelo software desenvolvido –

Modelo-01.
72
Figura 60. Diagrama de deslocamentos obtido pelo software desenvolvido –
Modelo-01.
Figura 61. Diagrama de deslocamentos no eixo y obtido pelo programa ftool – Modelo-01.
Figura 62. Diagrama de rotações obtido pelo programa ftool – Modelo-01.
A estrutura em análise não apresenta deslocamentos na direção do eixo x.
73
5.2 ANÁLISE DO MODELO-02
5.2.1 Reações nos apoios da estrutura
As imagens que seguem, apresentam a igualdade entre os valores calculados pelo
programa (Figura 63) e os obtidos através do programa ftool (Figura 64).
Figura 63. Reações nos apoios calculadas pelo

software desenvolvido – Modelo-02.
Figura 64. Reações nos apoios calculadas pelo

programa ftool – Modelo-02.
74
5.2.2 Esforços internos
5.2.2.1 Esforços normais
As imagens que seguem (Figura 65 e Figura 66) apresentam respectivamente os
esforços normais calculados pelo programa e os resultados obtidos pelo ftool.
Figura 65. Esforços normais calculados pelo software desenvolvido

– Modelo-02.
Figura 66. Esforços normais calculados pelo programa

ftool – Modelo-02.
75
5.2.2.2 Esforços cortantes
Conforme apresentado nas imagens que seguem (Figura 67 e Figura 68), os valores
dos esforços cortantes obtidos pelo programa desenvolvido são os mesmos apresentados
pelo programa ftool.
Figura 67. Esforços cortantes calculados pelo software desenvolvido – Modelo-02.
76
Figura 68. Esforços cortantes calculados pelo programa ftool – Modelo-02.
77
5.2.2.3 Momentos fletores
As imagens (Figura 69 e Figura 70), elucidam a igualdade dos valores dos momentos
fletores calculados pelo programa frente aos resultados apresentados pelo programa ftool.
Figura 69. Momentos fletores calculados pelo software

Figura 70. Esforços cortantes calculados pelo programa ftool –

Modelo-02.
78
Conforme apresentado anteriormente, o programa ainda conta com uma janela
(Figura 71) onde os valores calculados são dispostos em uma tabela para visualização e
análise pelo usuário.
Figura 71. Valores dos esforços internos calculados pelo software

79
5.2.3 Deslocamentos
Os deslocamentos calculados para este modelo podem ser observados na Figura 72,
sendo o diagrama gerado pelo programa apresentado na Figura 73. O diagrama gerado pela
ferramenta ftool é apresentado na Figura 74.
Figura 72. Valores dos deslocamentos calculados pelo software desenvolvido –

Modelo-02.
80
Figura 73. Diagrama dos deslocamentos obtido pelo software desenvolvido
– Modelo-02.
Figura 74. Diagrama de deslocamentos obtido pelo programa ftool –

Modelo-02.
81
5.3 ANÁLISE PARA VALIDAÇÃO DO DIMENSIONAMENTO DAS ARMADURAS LONGITUDINAIS
Conforme apresentado anteriormente, para validação do dimensionamento das

armaduras longitudinais tomou-se como base o modelo apresentado na Figura 75, no qual a
área de aço calculada é igual a 4,32 cm².
Figura 75. Modelo utilizado para validação do dimensionamento da armadura

longitudinal.
Fonte: Adaptado de Mesquita Filho (2015).
82
A imagem que segue (Figura 76esenta a tela do programa com os valores do modelo
inseridos para o dimensionamento das armaduras, bem como os resultados obtidos.
Nesta análise, fez-se a alteração da classe do concreto para C25 de modo a atender
a normativa vigente. Porém, como pode ser observado, a área de aço calculada pelo
programa foi de 4,30 cm², sendo a diferença entre os valores inferior a 0,5 %, sendo esta
diferença insignificativa.
Figura 76. Resultados do dimensionamento da armadura longitudinal obtido pelo

programa.
83
6. CONCLUSÕES
Frente a comparação dos resultados apresentados, fica verificado que, na análise

estrutural o programa desenvolvido neste trabalho apresentou valores calculados idênticos
aqueles obtidos através do uso do programa ftool, utilizado como base comparativa. Além
disso, o programa também apresentou diagramas fiéis aqueles apresentados pelo programa
ftool.
No que diz respeito ao dimensionamento das armaduras longitudinais, foi verificado
que o programa obteve resultados significativamente próximos aqueles obtidos nos cálculos
do exemplo apresentado. Ressaltando que, o programa desenvolvido segue rigorosamente
a normativa vigente.
Assim, conclui-se que o programa desenvolvido neste estudo, além de garantir ao
usuário a facilidade de iteração com o sistema por meio da simplicidade de sua interface,
dispõe a confiabilidade quanto aos resultados calculados, sendo o programa passível de
aplicação nos estudos relacionados a análise estrutural.
84
REFERÊNCIAS BIBLIOGRÁFICAS
ARAÚJO, J. M. Curso de concreto armado. 4. ed. Rio Grande: Dunas, 2014.
ASSAN, A. A. Método dos elementos finitos: primeiros passos. 2. ed. Campinas: Editora
da UNICAMP, 2003.
ASSOCIAÇÃO BRASILEIRA DE NORMAS TÉCNICAS. NBR 6118: Projeto de estruturas de

concreto - Procedimento. 3 ed. Rio de Janeiro: ABNT, 2014.
BEER, F. P.; JOHNSTON, E. R. Jr. Mecânica dos materiais. 7. ed. Porto Alegre: AMGH,
2015.
BORGES, L. E. Python para desenvolvedores. 3.ed. Rio de Janeiro: Novatec, 2010.

CARVALHO, R. C.; FIGUEIREDO FILHO, J. R. Cálculo e detalhamento de estruturas
usuais de concreto armado. 4. ed. São Carlos: Edufscar, 2015.
CODA, H. B.; PACCOLA, R. R. AcadFrame: manual de utilização. 2006. Disponível em:

<http://www.set.eesc.usp.br/softwares_depto/acadframe/manual/>. Acesso em: 02 jul. 2020.
DSENGENHARIA. Projetos: residencial mistral. 2012. Disponível em:

<http://www.dsengenharia.com/projetos.php?id_P=36#!prettyPhoto>. Acesso em: 26 mai.
2017.
HIBBELER, R. C. Análise das estruturas. 8. ed. São Paulo: Pearson, 2013.
KAEFER, L. F. Desenvolvimento de uma ferramenta gráfica para análise de pórticos de

concreto armado. 2000. 258 f. Dissertação (Mestrado) - Curso de Engenharia Civil, Escola
Politécnica, Universidade de São Paulo, São Paulo, 2000.
KIM, N.; SANKAR, B. V. Introdução à análise e ao projeto em elementos finitos. Rio de

Janeiro: LTC - Livros Técnicos Científicos, 2011.
MARTHA, L. F. Análise de estruturas: conceitos e métodos básicos 2.ed. Rio de Janeiro:

Elsevier, 2010.
MARTHA, L. F. Ftool: um programa gráfico-interativo para ensino de comportamento de
estruturas – Versão educacional 3.01. Rio de Janeiro: Tecgraf/PUC-Rio, 2015.
85
MENEZES, N. N. C. Introdução à programação com Python: algoritmos e lógica de
programação para iniciantes 2.ed. São Paulo: Novatec, 2014.
MESQUITA FILHO J. Estudo das vigas: flexão normal simples. 2015. Disponível em: <
https://www.feis.unesp.br/Home/departamentos/engenhariacivil/nepae/estudo-das-
vigas.pdf>. Acesso em: 02 jul. 2020.
ORMONDE, P. C. Software Educacional Livre para análise não linear de pórticos

planos em estruturas metálicas. 2013. 123 f. Dissertação (Mestrado) - Curso de
Engenharia Civil, Centro de Ciências Exatas e de Tecnologia, Universidade Federal de São
Carlos, São Carlos, 2013.
PINHEIRO, L. M.; MUZARDO, C. D.; SANTOS, S. P. Fundamentos do concreto e projeto

de edifícios. São Carlos: Escola de Engenharia de São Carlos - Departamento de
Estruturas, 2007.
PIEDADE NETO, D.; FERREIRA, M. D. C.; FAGÁ JR, R.; PACCOLA, R. R.

Desenvolvimento de uma plataforma livre para análise estrutural de pórticos
tridimensionais. In: WORKSHOP DE SOFTWARE LIVRE - WSL 2011. Porto Alegre: Anais
do Workshop de Software Livre - WSL, 2011. Disponível em
<http://wsl.softwarelivre.org/2011/0002/85174_1.pdf>. Acesso em: 02 jul. 2020.
SCIPY NumPy user guide. 2017. Disponível em:

<https://docs.scipy.org/doc/numpy/user/whatisnumpy.html>. Acesso em: 02 jul. 2020.
SUSSEKIND, J. C. Curso de análise estrutural. 6. ed. Porto Alegre - Rio de Janeiro:

Globo, 1981.
TIMOSHENKO, S. P.; GERE, J. E. Mecânica dos sólidos. Rio de Janeiro: LTC - Livros
Técnicos Científicos, 1983.
86
APÊNDICES
APÊNDICE A – CÓDIGO DESENVOLVIDO PARA A CONCEPÇÃO DO PROGRAMA
87
Código para armazenamento dos dados
import math as m
import pickle
import csv
#__DICIONÁRIOS UTILIZADOS PARA O ARMAZENAMENTO DE

DADOS_________________________________________________________________
class Dados(object):
def __init__(self):
"Inicialização do Banco de Dados"
pass
def dic_nos(self):
"Dicionário de Nós"
self.Nos = {}
return self.Nos
def dic_nos_des(self):
"Dicionário de Nós para o desenho da estrutura"
self.Nos_des = {}
return self.Nos_des
def dic_elem(self):
"Dicionário de Elementos"
self.Elem = {}
return self.Elem
def dic_elem_des(self):
"Dicionário de Elementos para o desenho da estrutura"
self.Elem_des = {}
return self.Elem_des
def dic_w_dist(self):
"Dicionário das ações atuantes na estruturra"
self.W_dist = {}
return self.W_dist
def limpar(self):
self.Nos = {}
self.salvar_nos(self.Nos)
self.Nos_des = {}
self.salvar_nos_des(self.Nos_des)
self.Elem = {}
self.salvar_elem(self.Elem)
self.Elem_des = {}
self.salvar_elem_des(self.Elem_des)
self.W_dist = {}
self.salvar_w_dist(self.W_dist)
#__FUNÇÕES UTILIZADAS PARA CONVERSÃO DE VALORES - NÓS E

ELEMENTOS_______________________________________________________
def n(self):
"Função para definir a quantidade de elementos na discretização da
estrutura"
num_elem = 10
return num_elem
88
def conv_prog(self,valor):
"Função para converter valores do usuário para valores do programa"
n = self.n()
return (valor*n)-(n-1)
def conv_real(self,valor):
"Função para converter valores do programa para valores do usuário
- Valores de Desenho"
n = self.n()
return (valor+(n-1))/n
def no_int(self,elem):
"Função para calcular o primeiro nó interno ao longo do elemento
discretizado"
n = self.n()
return (elem*n)-(n-2)
#__FUNNÇÕES PARA LEITURA DOS

DICIONÁRIOS________________________________________________________________
________________
def abrir_nos(self):
arq = open("Nos.txt", "rb")
self.Nos = pickle.load(arq)
arq.close()
return self.Nos
def abrir_nos_des(self):
arq = open("Nos_des.txt", "rb")
self.Nos_des = pickle.load(arq)
arq.close()
return self.Nos_des
def abrir_elem(self):
arq = open("Elementos.txt", "rb")
self.Elem = pickle.load(arq)
arq.close()
return self.Elem
def abrir_elem_des(self):
arq = open("Elementos_des.txt", "rb")
self.Elem_des = pickle.load(arq)
arq.close()
def abrir_w_dist(self):
arq = open("W_dist.txt", "rb")
self.W_dist = pickle.load(arq)
arq.close()
return self.W_dist
def abrir_resultados(self):
arq = open("Resultados.txt", "w")
arq.close()
#__FUNÇÕES PARA VERIFICAÇÃO DA EXISTÊNCIA DOS ARQUIVOS (.txt) QUE ARMAZENAM

OS DICIONÁRIOS______________________________
#__SE EXISTIR O ARQUIVO SERÁ ABERTO, CASO CONTRÁRIO O ARQUIVO SERÁ CRIADO
PELO SISTEMA__________________________________
#__ESTES ARQUIVOS (.txt) TERÃO SEUS DADOS EXISTENTES SEMPRE SOBREPOSTOS
PELOS NOVOS DADOS QUE SERÃO SALVOS______________
89
def arq_nos(self):
"Função para verificar se o arquivo de nós existe"
try:
with open('Nos.txt', 'r') as f:
f = 'Nos.txt'
self.Nos = self.abrir_nos()
except IOError:
self.Nos = self.dic_nos()
return self.Nos
def arq_nos_des(self):
"Função para verificar se o arquivo de nós existe - Desenho"
try:
with open('Nos_des.txt', 'r') as f:
f = 'Nos_des.txt'
self.Nos_des = self.abrir_nos_des()
except IOError:
self.Nos_des = self.dic_nos_des()
return self.Nos_des
def arq_elem(self):
"Função para verificar se o arquivo de elementos existe"
try:
with open('Elementos.txt', 'r') as f:
f = 'Elementos.txt'
self.Elem = self.abrir_elem()
except IOError:
self.Elem = self.dic_elem()
return self.Elem
def arq_elem_des(self):
"Função para verificar se o arquivo de elementos existe - Desenho"
try:
with open('Elementos_des.txt', 'r') as f:
f = 'Elementos_des.txt'
self.Elem_des = self.abrir_elem_des()
except IOError:
self.Elem_des = self.dic_elem_des()
def arq_w_dist(self):
"Função para verificar se o arquivo de cargas distribuídas existe"
try:
with open('W_dist.txt', 'r') as f:
f = 'W_dist.txt'
self.W_dist = self.abrir_w_dist()
except IOError:
self.W_dist = self.dic_w_dist()
return self.W_dist
#__FUNÇÕES PARA GRAVAÇÃO DOS DICIONÁRIOS EM ARQUIVOS

.txt_______________________________________________________________
def salvar_nos(self,dic):
arq = open("Nos.txt","wb")
pickle.dump(dic,arq)
arq.close()
def salvar_nos_des(self,dic):
arq = open("Nos_des.txt","wb")
90
arq.close()
def salvar_elem(self,dic):
arq = open("Elementos.txt","wb")
arq.close()
def salvar_elem_des(self,dic):
arq = open("Elementos_des.txt","wb")
arq.close()
def salvar_w_dist(self,dic):
arq = open("W_dist.txt","wb")
arq.close()
def salvar_resultados(self, arquivo):

"Função para salvar os resultados em um arquivo no formato CSV -
Excel"
arq = open(arquivo + ".txt", "w")
try:
writer = csv.writer(arq)
writer.writerow(("Elem","No_i","No_f", "xi", "yi", "xf", "yf",
"dx_i", "dx_f", "dy_i", "dy_f", "rz_i",
"rz_f",
"Fx_i", "Fx_f", "Fy_i", "Fy_f", "Mz_i",
"Mz_f",
"Normal_i", "Normal_f", "Cortante_i",
"Cortante_f", "Fletor_i", "Fletor_f"))
ord = list(self.Elem.keys())
ord.sort()
for elem in ord:
noi = self.Elem[elem]["noi"]["id"]
nof = self.Elem[elem]["nof"]["id"]
xi = self.Nos[noi]["x"]
yi = self.Nos[noi]["y"]
xf = self.Nos[nof]["x"]
yf = self.Nos[nof]["y"]
dxi = self.Nos[noi]["Desloc."]["dx"]
dyi = self.Nos[noi]["Desloc."]["dy"]
rzi = self.Nos[noi]["Desloc."]["rz"]
dxf = self.Nos[nof]["Desloc."]["dx"]
dyf = self.Nos[nof]["Desloc."]["dy"]
rzf = self.Nos[nof]["Desloc."]["rz"]
Fxi = self.Nos[noi]["Reacoes"]["Fx"]
Fyi = self.Nos[noi]["Reacoes"]["Fy"]
Mzi = self.Nos[noi]["Reacoes"]["Mz"]
Fxf = self.Nos[nof]["Reacoes"]["Fx"]
Fyf = self.Nos[nof]["Reacoes"]["Fy"]
Mzf = self.Nos[nof]["Reacoes"]["Mz"]
Ni = self.Elem[elem]["noi"]["Esforcos"]["N"]
Vi = self.Elem[elem]["noi"]["Esforcos"]["V"]
Mi = self.Elem[elem]["noi"]["Esforcos"]["M"]
Nf = self.Elem[elem]["nof"]["Esforcos"]["N"]
Vf = self.Elem[elem]["nof"]["Esforcos"]["V"]
Mf = self.Elem[elem]["nof"]["Esforcos"]["M"]
writer.writerow((elem,noi,nof,xi,yi,xf,yf,dxi,dxf,dyi,dyf,rzi,rzf,Fxi,Fxf,F
91
yi,Fyf,Mzi,Mzf,Ni,Nf,Vi,Vf,Mi,Mf))
finally:
arq.close()
arq_2 = open("Nodais_Eq.txt","w")
try:
writer = csv.writer(arq_2)
writer.writerow((u"Nós","Fx_eq","Fy_eq","Mz_eq"))
ord = list(self.Nos.keys())
ord.sort()
for no in ord:
Id_no = no
Fx_eq = self.Nos[Id_no]["Q_eq"]["fx_eq"]
Fy_eq = self.Nos[Id_no]["Q_eq"]["fy_eq"]
Mz_eq = self.Nos[Id_no]["Q_eq"]["mz_eq"]
writer.writerow((Id_no,Fx_eq,Fy_eq,Mz_eq))
finally:
arq_2.close()
#__FUNÇÕES PARA MANIPULAÇÃO DE DADOS REFERENTE AOS

NÓS__________________________________________________________________
def inserir_no(self,no,x,y):
"Função para inserir nós"
entrada = {"x": x,
"y": y,
"Restr.": {"u": 0, "v": 0, "t":
0},
"Q_nodal": {"fx": 0.00, "fy": 0.00, "mz":
0.00},
"Q_eq": {"fx_eq": 0.00, "fy_eq": 0.00, "mz_eq":
0.00},
"Desloc.": {"dx": 0.00, "dy": 0.00, "rz":
0.00},
"Reacoes": {"Fx": 0.00, "Fy": 0.00, "Mz":
0.00},
"Esforcos": {"N": 0.00, "V": 0.00, "M":
0.00}}
self.Nos[no] = entrada
def inserir_no_des(self,no,x,y):
"Função para inserir nós - Desenho"
entrada = {"x": x,
"y": y,
"Restr.": {"u": 0, "v": 0, "t":
0, "Rot.": 0},
"Q_nodal": {"fx": 0.00, "fy": 0.00, "mz":
0.00},
#"Q_eq": {"fx_eq": 0.00, "fy_eq": 0.00, "mz_eq":
0.00},
#"Desloc.": {"dx": 0.00, "dy": 0.00, "rz":
0.00},
"Reacoes": {"Fx": 0.00, "Fy": 0.00, "Mz":
0.00},
#"Esforcos": {"N": 0.00, "V": 0.00, "M":
0.00}
}
self.Nos_des[no] = entrada
92
def excluir_no(self,no):
"Função para excluir nós"
del self.Nos[no]
def excluir_no_des(self, no):

"Função para excluir nós - Desenho"
del self.Nos_des[no]
def rest_nos(self,no,u,v,t):
"Função para inserir as condições de contorno dos nós\
Manter livres u,v ou t: 0\
Manter Fixos u,v ou t: 1"
self.Nos[no]["Restr."] = {"u": u,
"v": v,
"t": t}
def rest_nos_des(self,no,u,v,t,rot):
"Função para inserir as condições de contorno (restrições) dos nós\
Manter livres u,v ou t: 0\
Manter Fixos u,v ou t: 1"
self.Nos_des[no]["Restr."] = {"u": u, "v": v, "t": t, "Rot.": rot}
def inserir_Qnodal(self,no,fx,fy,mz):
"Função para inserir cargas nodais - Q"
no = self.conv_prog(no)
self.Nos[no]["Q_nodal"] = {"fx": fx,
"fy": fy,
"mz": mz}
def inserir_Qnodal_des(self, no, fx, fy, mz):

"Função para inserir cargas nodais - Q"
self.Nos_des[no]["Q_nodal"] = {"fx": fx, "fy": fy, "mz": mz}
def ord_nos(self):
"Função para ordenar o dicionário Nós com base nas chaves"
ord = list(self.Nos.keys())
ord.sort()
for key in ord:
print("Nós: %d\t" % key, "--->", self.Nos[key])
def ord_nos_des(self):
"Função para ordenar o dicionário Nós com base nas chaves"
ord = list(self.Nos_des.keys())
ord.sort()
for key in ord:
print("Nós_des: %d\t" % key, "--->", self.Nos_des[key])
#__FUNÇÕES PARA MANIPULAÇÃO DE DADOS REFERENTES AOS

ELEMENTOS____________________________________________________________
def inserir_elem(self,elem,noi,nof):
"Função para inserir elementos"
n = self.n()
no_int = self.no_int(elem)
93
elem = self.conv_prog(elem)
noi = self.conv_prog(noi)
nof = self.conv_prog(nof)
L = m.sqrt(m.pow((xf-xi),2)+m.pow((yf-yi),2))
L_prog = L/n
Lamb_x = (xf-xi)/L
Lamb_y = (yf-yi)/L
x_prog = (Lamb_x*L_prog)+xi
y_prog = (Lamb_y*L_prog)+yi
entrada = {"noi": {"id": int(noi), "x": round(xi,2), "y":
round(yi,2),
"Q_eq": {"fx_eq": 0.00,"fy_eq": 0.00, "mz_eq":
0.00},
"Esforcos":{"N": 0, "V": 0, "M": 0}},
"nof": {"id": int(no_int), "x": round(x_prog,2), "y":

round(y_prog,2),
"Q_eq": {"fx_eq": 0.00,"fy_eq": 0.00, "mz_eq":
0.00},
"Esforcos":{"N": 0, "V": 0, "M": 0}},
"Prop.": {"area": 0.00, "inercia": 0.00, "elast.":

0.00}}
self.Elem[elem] = entrada
self.inserir_no(int(no_int),round(x_prog,2),round(y_prog,2))
c = 1
while c <= (n-2):
elem = elem+1
x_prog = (Lamb_x*c*L_prog)+xi
y_prog = (Lamb_y*c*L_prog)+yi
entrada = {"noi": {"id": int(no_int), "x": round(x_prog,2),
"y": round(y_prog,2),
"Q_eq": {"fx_eq": 0.00,"fy_eq": 0.00,
"mz_eq": 0.00},
"Esforcos":{"N": 0, "V": 0, "M": 0}},
"nof": {"id": int(no_int+1), "x":

round((Lamb_x*(c+1)*L_prog)+xi,2), "y": round((Lamb_y*(c+1)*L_prog)+yi,2),
"Q_eq": {"fx_eq": 0.00,"fy_eq": 0.00,
"mz_eq": 0.00},
"Esforcos":{"N": 0, "V": 0, "M": 0}},

0.00}}
self.Elem[elem] = entrada
self.inserir_no(int(no_int+1), round((Lamb_x*(c+1)*L_prog)
+xi,2), round((Lamb_y*(c+1)*L_prog)+yi,2))
c += 1
no_int =int(no_int+1)
x_prog = (Lamb_x*c*L_prog)+xi
y_prog = (Lamb_y*c*L_prog)+yi
entrada = {"noi": {"id": int(no_int), "x": round(x_prog, 2),
"y": round(y_prog, 2),
"Q_eq": {"fx_eq": 0.00,"fy_eq": 0.00,
"mz_eq": 0.00},
94
"Esforcos":{"N": 0, "V": 0, "M": 0}},
"nof": {"id": int(nof), "x": round(xf,2), "y":

round(yf,2),
"Q_eq": {"fx_eq": 0.00,"fy_eq": 0.00,
"mz_eq": 0.00},
"Esforcos":{"N": 0, "V": 0, "M": 0}},

0.00}}
self.Elem[elem+1] = entrada
def inserir_elem_des(self,elem,noi,nof):
"Função para inserir elementos no desenho"
xi = self.Nos_des[noi]["x"]
yi = self.Nos_des[noi]["y"]
xf = self.Nos_des[nof]["x"]
yf = self.Nos_des[nof]["y"]
entrada = {"noi": {"id": noi, "x": xi, "y": yi, "wi": 0.00},
"nof": {"id": nof, "x": xf, "y": yf, "wf": 0.00}}
self.Elem_des[elem] = entrada
def excluir_elem(self, elem):

"Função para excluir elementos"
no_int = self.no_int(elem)
c = 0
while c < self.n()-1:
del self.Nos[no_int+c]
c += 1
elem = self.conv_prog(elem)
c = 0
while c < self.n():
del self.Elem[elem]
elem += 1
c += 1
def excluir_elem_des(self,elem):
"Função para excluir elementos do desenho"
del self.Elem_des[elem]
def prop_elem(self,elem,area,inercia,elasticidade):
"Função para inserir as propriedades do elemento"
self.Elem[elem]["Prop."] = {"area": area,
"inercia": inercia,
"elast.": elasticidade}
def inserir_Wdist(self,elem,orientacao,wi,wf):
"Função para inserir cargas distribuídas"
n = self.n()
elem_prog = self.conv_prog(elem)
noi = self.Elem[elem_prog]["noi"]["id"]
95
nof = self.Elem[elem_prog+(n-1)]["nof"]["id"]
entrada = {"oreient.": str(orientacao), "noi": noi, "nof": nof,
"wi": wi, "wf": wf}
self.W_dist[elem] = entrada
self.salvar_w_dist(self.W_dist)
#__Inserindo w_dist em elementos do desenho

self.Elem_des = self.abrir_elem_des()
self.Elem_des[elem]["noi"]["wi"] = wi
self.Elem_des[elem]["nof"]["wf"] = wf
def ord_elem(self):
"Função para ordenar o dicionário Elem com base nas chaves"
ord = list(self.Elem.keys())
ord.sort()
for key in ord:
print("Elemento: %d" % key,"\t", "--->", self.Elem[key])
def ord_elem_des(self):
ord = list(self.Elem_des.keys())
ord.sort()
for key in ord:
print("Elemento_des: %d" % key, "\t", "--->",
self.Elem_des[key])
def ord_wdist(self):
ord = list(self.W_dist.keys())
ord.sort()
for key in ord:
print("Elemento: %d" % key, "\t", "--->", self.W_dist[key])
#_FUNÇÕES PARA MANIPULAÇÃO DAS AÇÕES ATUANTES NA

ESTRUTURA______________________________________________________________
def Wx(self, x, xi_global, xf_global, wi, wf):

"Funçao para interpolar a carga W(x) - Variável\
x: ponto onde é calculado o valor de W\
xi, xf: coordenadas noi e nof respectivamente\
wi, wf: valor de W(xi) e W(xf) respectivamente"
self.x = x
self.xi = xi_global
self.xf = xf_global
self.wi = wi
self.wf = wf
a = (self.wf-self.wi)/(self.xf-self.xi)
return self.wi+a*(self.x-self.xi)
def inserir_eq(self):
"Função para calcular e inserir as cargas nodais equivalentes"
self.W_dist = self.abrir_w_dist()
n = self.n()
for elem in self.W_dist:

"Limpa as cargas nodais equivalentes - Para o caso do usuário
alterar os valores inicialmente inseridos"
96
c = 0
while c < n:
self.noi = self.Elem[elem_prog+c]["noi"]["id"]
self.nof = self.Elem[elem_prog+c]["nof"]["id"]
self.Nos[self.noi]["Q_eq"] = {"fx_eq": 0.00, "fy_eq": 0.00,
"mz_eq": 0.00}
self.Nos[self.nof]["Q_eq"] = {"fx_eq": 0.00, "fy_eq": 0.00,
"mz_eq": 0.00}
c += 1
for elem in self.W_dist:

"Laço para inserir as cargas nodais equivalentes"
self.wi = self.W_dist[elem]["wi"]
self.wf = self.W_dist[elem]["wf"]
self.xi_global = self.Elem[elem_prog]["noi"]["x"]
self.yi_global = self.Elem[elem_prog]["noi"]["y"]
self.xf_global = self.Elem[elem_prog+(n-1)]["nof"]["x"]
self.yf_global = self.Elem[elem_prog+(n-1)]["nof"]["y"]
if self.wi != 0 or self.wf != 0:
c = 0
while c < n:
self.noi = self.Elem[elem_prog]["noi"]["id"]
self.nof = self.Elem[elem_prog]["nof"]["id"]
self.xi = self.Elem[elem_prog]["noi"]["x"]
self.yi = self.Elem[elem_prog]["noi"]["y"]
self.xf = self.Elem[elem_prog]["nof"]["x"]
self.yf = self.Elem[elem_prog]["nof"]["y"]
self.L = m.sqrt(m.pow((self.xf - self.xi), 2) +
m.pow((self.yf - self.yi), 2))
self.Lamb_X = (self.xf - self.xi) / self.L
self.Lamb_y = (self.yf - self.yi) / self.L
print("\nElemento", elem_prog)
print("xi = ", self.xi)
print("xf = ", self.xf)
print("yi = ", self.yi)
print("yf = ", self.yf)
print("L = ", self.L)
print("Lamb_x = ", self.Lamb_X)
print("Lamb_y = ", self.Lamb_y)
print("xi_global = ", self.xi_global)
print("xf_global = ", self.xf_global)
print("yi_global = ", self.yi_global)
print("yf_global = ", self.yf_global)
xi = self.xi
xf = self.xf
fx = self.Nos[self.noi]["Q_eq"]["fx_eq"]
fy = self.Nos[self.noi]["Q_eq"]["fy_eq"]
mz = self.Nos[self.noi]["Q_eq"]["mz_eq"]
print("fx=", fx, "fy=", fy, "mz=", mz)
self.qi = self.Wx(xi, self.xi_global, self.xf_global,
self.wi, self.wf)
self.qf = self.Wx(xf, self.xi_global, self.xf_global,
self.wi, self.wf)
97
print("qi = ", self.qi, "\nqf = ", self.qf)
self.fx1 = ((1/3) * (self.qi + self.qf / 2) * self.L *

self.Lamb_y * self.Lamb_X)
self.fy1 = ((1/20) * (7 * self.qi + 3 * self.qf) *
self.L * m.pow(self.Lamb_X, 2))
self.mz1 = ((1/10) * (self.qi / 2 + self.qf / 3) *
m.pow(self.L, 2) * m.pow(self.Lamb_X, 2))
#__Insere as equivalentes nodais devidas somente ao
elemento em questão
#__Cargas utilizadas para o cálculo dos esforços
internos
#__Sem isso as cargas equivalentes são subtraídas
erroneamente gerando esforços incorretos
self.Elem[elem_prog]["noi"]["Q_eq"] = {"fx_eq":
self.fx1, "fy_eq": self.fy1, "mz_eq": self.mz1}
#__Soma das cargas nodais equivalentes dos n elementos
ligados ao nó
self.fx1 = self.fx1 + fx
self.fy1 = self.fy1 + fy
self.mz1 = self.mz1 + mz
#__Insere as equivalentes nodais devidas a cada
elemento ligado ao nó
#__Cargas utilizadas para o cálculo das reações nos
apoios
self.Nos[self.noi]["Q_eq"] = {"fx_eq": self.fx1,
"fy_eq": self.fy1, "mz_eq": self.mz1}
print("fx1=",self.fx1,"fy1=",self.fy1,"mz1=",self.mz1)
fx = self.Nos[self.nof]["Q_eq"]["fx_eq"]
fy = self.Nos[self.nof]["Q_eq"]["fy_eq"]
mz = self.Nos[self.nof]["Q_eq"]["mz_eq"]
print("fx=", fx, "fy=", fy, "mz=", mz)
self.fx2 = ((1/3) * (self.qi / 2 + self.qf) * self.L *
self.Lamb_y * self.Lamb_X)
self.fy2 = ((1/20) * (3 * self.qi + 7 * self.qf) *
self.L * m.pow(self.Lamb_X, 2))
self.mz2 = ((-1) * (1/10) * (self.qi / 3 + self.qf / 2)
* m.pow(self.L, 2) * m.pow(self.Lamb_X, 2))
#__Insere as equivalentes nodais devidas somente ao
elemento em questão
#__Cargas utilizadas para o cálculo dos esforços
internos
#__Sem isso as cargas equivalentes são subtraídas
erroneamente gerando esforços incorretos
self.Elem[elem_prog]["nof"]["Q_eq"] = {"fx_eq":
self.fx2, "fy_eq": self.fy2, "mz_eq": self.mz2}
#__Soma das cargas nodais equivalentes dos n elementos
ligados ao nó
self.fx2 = self.fx2 + fx
self.fy2 = self.fy2 + fy
self.mz2 = self.mz2 + mz
#__Insere as equivalentes nodais devidas a cada
elemento ligado ao nó
#__Cargas utilizadas para o cálculo das reações nos
apoios
self.Nos[self.nof]["Q_eq"] = {"fx_eq": self.fx2,
98
"fy_eq": self.fy2, "mz_eq": self.mz2}
print("fx2=", self.fx2, "fy2=", self.fy2, "mz2=",

self.mz2)
elem_prog += 1
c += 1
def deslocamentos(self, no, dx, dy, rz):

"Função para inserir os deslocamentos calculados no dicionário Nos"
self.Nos[no]["Desloc."] = {"dx": dx, "dy": dy, "rz": rz}
def reacoes(self, no, fx, fy, mz):

"Função para inserir as reações calculadas no dicionário Nos"
self.Nos[no]["Reacoes"] = {"Fx": fx, "Fy": fy, "Mz": mz}
def reacoes_des(self, no, fx, fy, mz):

"Função para inserir as reações calculadas no dicionário Nos_des"
self.Nos_des[no]["Reacoes"] = {"Fx": fx, "Fy": fy, "Mz": mz}
def esforcos(self, no, N, V, M):

"Função para inserir os esforços internos - N, V e M"
self.Nos[no]["Esforcos"] = {"N": N, "V": V, "M": M}
def esforcos_elem(self, elem, Ni, Vi, Mi, Nf, Vf, Mf):

"Função para inserir os esforços internos - N, V e M"
self.Elem[elem]["noi"]["Esforcos"] = {"N": Ni, "V": Vi, "M": Mi}
self.Elem[elem]["nof"]["Esforcos"] = {"N": Nf, "V": Vf, "M": Mf}
Código da janela inicial do programa
from PyQt4.QtGui import*

from PyQt4.QtCore import*
import time
#import csv
import math as m
from Dicionarios import*

from J_Nos import*
from J_Elementos import*
from J_Propriedades import*
from J_Apoios import*
from J_Carga_C import*
from J_Carga_D import*
from J_Dimensionamento import*
from J_Salvar_txt import*
from CALCULAR import*
from J_Res_Desloc import*

from J_Res_Esforcos import*
99
class Drawing(QWidget):
"Classe que define o canvas de desenho"
def __init__(self, parent=None):
super(Drawing, self).__init__(parent)
self.setMinimumSize(5000,5000)
self.size = self.size()
self.h = self.size.height()
self.w = self.size.width()
self.n = 50
self.grid = self.n # ---> Assume-se: 50 pixels = 1 metro
#self.QScrollBar.setSliderPosition(99)
"Coordenadas estáticas (x, y)"

"Os desenhos nos quais estas coordenadas são aplicadas não sofrem
efeito do zoom"
self.xo_estat = 2*self.n
self.yo_estat = self.h - 2*self.n
self.xo = 2*self.grid
self.yo = (self.h - self.h % self.grid) - 2*self.grid
#__FUNÇÕES PARA A CONVERSÃO DO SISTEMA DE COORDENADAS DA ÁREA DE

DESENHO________________________________________________
def conv_x(self,x):
conv_x = self.xo+x*self.grid
return conv_x
def conv_y(self,y):
conv_y = self.yo-y*self.grid
return conv_y
def x_estat(self,x):
x_estat = self.xo_estat+x*self.n
return x_estat
def y_estat(self,y):
y_estat = self.yo_estat-y*self.n
return y_estat
#__EVENTOS DO
MOUSE______________________________________________________________________
_______________________________
def wheelEvent(self, event):

"Função para realizar o zoom do desenho"
self.grid += (event.delta() / 120)*5
self.update()
if self.grid < self.n:
self.grid = self.n
if self.grid > 250:
self.grid = 250
#======================================================================#
# A FUNÇÃO PAINT_EVENT FUNCIONA DE MÓDO CUMULATIVO, SENDO ASSIM,
#
# É NECESSÁRIA A INCLUSÃO DOS DICIONÁRIOS DENTRO DO MÓDULOS DE DESENHO
#
100
#======================================================================#
def paintEvent(self, e):

"Função para a criação e execução do pintor - qp = QPainter()"
self.db = Dados()
self.Nos = self.db.arq_nos()
self.Nos_des = self.db.arq_nos_des()
self.Elem = self.db.arq_elem()
self.Elem_des = self.db.arq_elem_des()
self.W_dist = self.db.arq_w_dist()
qp = QPainter()
qp.begin(self)
"Definindo o plano de fundo da interface de desenho - Background"

qp.fillRect(e.rect(), QBrush(QColor(40, 40, 40)))
"Opação de ativação do grid (True / False)"
grid = True
if grid==True:
self.drawGrid(qp)
"Desenha os eixos coordenados"

self.drawEixos_Coord(qp)
"Desenha os elementos"
self.drawElem(qp)
"Desenha os nós"
self.drawNos(qp)
"Desenha as cargas distribuídas - Eixo y"

self.Wy1(qp)
#==========================================================#
# Verificação das restrições e rotação dos apoios #
# Índices e ângulos das rotações: 0=0, 1=90, 2=180 e 3=270 #
#==========================================================#
for no in self.Nos_des:
if self.Nos_des[no]["Reacoes"]["Fx"] == 0 and \
self.Nos_des[no]["Reacoes"]["Fy"] == 0 and \
self.Nos_des[no]["Reacoes"]["Mz"] == 0:
u = self.Nos_des[no]["Restr."]["u"]
v = self.Nos_des[no]["Restr."]["v"]
t = self.Nos_des[no]["Restr."]["t"]
rot = self.Nos_des[no]["Restr."]["Rot."]
if u == 1 and v == 0 and t == 0 and rot == 0:
self.drawApoioX(qp, no)
elif u == 1 and v == 0 and t == 0 and rot == 2:
self.drawApoioX_180(qp, no)
self.drawApoioY(qp, no)
self.drawApoioY_180(qp, no)
self.drawApoioXY(qp, no)
self.drawApoioXY_180(qp, no)
101
self.drawApoioXZ(qp, no)
self.drawApoioXZ_180(qp, no)
self.drawApoioYZ(qp, no)
self.drawApoioYZ_180(qp, no)
self.drawApoioXYZ(qp, no)
self.drawApoioXYZ_90(qp, no)
self.drawApoioZ(qp, no)
#================================================================#
# Verificação e inserção das CARGAS NODAIS atuantes na estrutura #
#================================================================#
fx = self.Nos_des[no]["Q_nodal"]["fx"]
fy = self.Nos_des[no]["Q_nodal"]["fy"]
mz = self.Nos_des[no]["Q_nodal"]["mz"]
if fx > 0:
self.drawFx1(qp, no, fx)
if fx < 0:
if fy > 0:
self.drawFy1(qp, no, fy)
if fy < 0:
if mz > 0:
self.drawMz1(qp, no, mz)
if mz < 0:
#===================================================================#
# Verificação e inserção das REAÇÕES DE APOIO atuantes na estrutura #
#===================================================================#
fx = self.Nos_des[no]["Reacoes"]["Fx"]
fy = self.Nos_des[no]["Reacoes"]["Fy"]
mz = self.Nos_des[no]["Reacoes"]["Mz"]
if fx > 0:
if fx < 0:
if fy > 0:
if fy < 0:
if mz > 0:
if mz < 0:
#======================================================================#
102
# Verificação e inserção das cargas distribuídas atuantes na estrutura
#
#======================================================================#
"PARTE AINDA NAO IMPLEMENTADA COMPLETAMENTE"
"Escreve a mensagem inicial - Rolagem"

self.msg_inicio(qp)
qp.end()
###########################################################################
#############################################
#__FUNÇÕES PARA A CRIAÇÃO DE
DESENHOS___________________________________________________________________
________________
###########################################################################
#############################################
def drawGrid(self, qp):

"Função que desenha o grid"
qp.setPen(Qt.white)
qp.setRenderHint(qp.Antialiasing)
"Determinação das coordenadas (x=0,y=0) - Coordenadas Dinâmicas"

self.xo = 2 * self.grid
self.yo = (self.h - self.h % self.grid) - 2 * self.grid
h = int((self.h-self.h%self.grid)/(self.grid/2))
w = int((self.w-self.w%self.grid)/(self.grid/2))
for i in range(w):
x = (i*self.grid)
for j in range(h):
y = (j*self.grid)
qp.drawPoint(x, y)
def drawEixos_Coord(self, qp):

"Função para desenhar os eixos coordenados (x,y)"
"Faz-se uso de coordenadas estáticas para que o desenho do eixo
permaneça no mesmo ponto durante o zoom"
qp.setPen(Qt.green)
"Eixo x"
qp.drawLine(self.x_estat(-1.8), self.y_estat(-1.8), self.x_estat(-
0.5), self.y_estat(-1.8))
qp.drawText(self.x_estat(-0.4), self.y_estat(-1.8), "x")
"Eixo y"
qp.setPen(Qt.red)
qp.drawText(self.x_estat(-1.7), self.y_estat(-0.4), "y")
103
qp.setPen(Qt.yellow)
qp.drawText(self.x_estat(-0.10), self.y_estat(-1.85), "Produced By:
EPV_ENGENHARIA")
def msg_inicio(self, qp):

qp.setPen(Qt.yellow)
font = QFont("Arial",25)
qp.setFont(font)
qp.drawText(15,37.5, "PARA INICIAR, DESÇA A BARRA DE ROLAGEM
A DIREITA > > > > > > >")
###########################################################################
#############################################
#__FUNÇÕES PARA DESENHAR A ESTRUTURA (Nós e
Elementos)_________________________________________________________________
_
###########################################################################
#############################################
def drawNos(self, qp):

"Função para extrair dados do dicionários Nos desenhar os nós da
estrutura - Coordenadas Dinâmicas"
x = self.conv_x(self.Nos_des[no]["x"])
y = self.conv_y(self.Nos_des[no]["y"])
pen = QPen(Qt.red, 5, Qt.SolidLine)
pen.setCapStyle(Qt.RoundCap)
qp.setPen(pen)
qp.drawPoint(x, y)
#__Para escrever o número do nó
pen = QPen(Qt.white)
qp.setPen(pen)
font = QFont("Arial", 9)
qp.setFont(font)
qp.drawText(x - 12.5, y - 5, str(no))
def drawElem(self, qp):

"Função para desenhar os elementos da estrutura - Coordenadas
Dinâmicas"
for elem in self.Elem_des:
xi = self.conv_x(self.Elem_des[elem]["noi"]["x"])
yi = self.conv_y(self.Elem_des[elem]["noi"]["y"])
xf = self.conv_x(self.Elem_des[elem]["nof"]["x"])
yf = self.conv_y(self.Elem_des[elem]["nof"]["y"])
#__Para desenhar o elemento

pen = QPen(Qt.white, 1.5, Qt.SolidLine)
qp.setPen(pen)
qp.drawLine(xi, yi, xf, yf)
#__Para escrever o número do elemento

delta_x = abs(xf-xi)
delta_y = abs(yf-yi)
if yi > yf:
y = yi
else:
104
y = yf
pen = QPen(Qt.green)
qp.setPen(pen)
font = QFont("Arial", 9)
qp.setFont(font)
#__Analise da orientaçao do elemento
#__Elemento na posição vertical

if delta_x == 0:
qp.drawText(xi - 12.5, y - delta_y/2, str(elem))
#__Elemento na posição horizontal

elif delta_y == 0:
qp.drawText(xi + delta_x/2, yi + 17.5, str(elem))
#__Elementos inclinados
elif delta_x != 0 and delta_y != 0:
qp.drawText(xi + delta_x/2, y - delta_y/2 + 17.5,
str(elem))
###########################################################################
#############################################
#__FUNÇÕES PARA DESENHAR OS
APOIOS_____________________________________________________________________
_______________
###########################################################################
#############################################
def drawApoioX(self, qp, no):

"Função para desenhar apoio fixo x - Default"
ponto_no = QPointF(x, y)
a = ponto_no
b = QPoint(x-14, y-10.5)
c = QPoint(x-14, y+10.5)
"Desenhando"
pen = QPen(Qt.green, 1, Qt.SolidLine)
qp.setPen(pen)
"Desenha o triângulo"
qp.drawPolygon(a, b, c)
"Desenha a linha da base"
qp.drawLine(x-21, y+10.5, x-21, y-10.5)
def drawApoioX_180(self, qp, no):

"Função para desenhar apoio fixo x - Rot_180"
a = ponto_no
b = QPoint(x+14, y-10.5)
c = QPoint(x+14, y+10.5)
"Desenhando"
qp.setPen(pen)
105
qp.drawLine(x+21, y+10.5, x+21, y-10.5)
def drawApoioY(self, qp, no):

"Função para desenhar apoio fixo y - Default"
ponto_no = QPointF(x,y)
a = ponto_no
b = QPoint(x-10.5, y+14)
c = QPoint(x+10.5, y+14)
"Desenhando o apoio global"
qp.setPen(pen)
qp.drawLine(x-10.5, y+21, x+10.5, y+21)
def drawApoioY_180(self, qp, no):

"Função para desenhar apoio fixo y - Rot_180"
a = ponto_no
b = QPoint(x-10.5, y-14)
c = QPoint(x+10.5, y-14)
"Desenhando"
qp.setPen(pen)
qp.drawLine(x-10.5, y-21, x+10.5, y-21)
def drawApoioXY(self, qp, no):

"Função para desenhar apoio fixo xy - Default"
a = ponto_no
b = QPoint(x-10.5, y+14)
c = QPoint(x+10.5, y+14)
"Desenhando o apoio global"
qp.setPen(pen)
"Desenha as linhas inclinadas - Fixação"
k = 0
while k <= 21:
qp.drawLine(x-10.5+k, y+14, x-15+k, y+19)
k += 7
def drawApoioXY_180(self, qp, no):

"Função para desenhar apoio fixo xy - Rot_180"
106
a = ponto_no
b = QPoint(x-10.5, y-14)
c = QPoint(x+10.5, y-14)
"Desenhando"
qp.setPen(pen)
k = 0
while k <= 21:
qp.drawLine(x-10.5+k, y-14, x-6+k, y-19)
k += 7
def drawApoioXZ(self, qp, no):

"Função para desenhar apoio fixo xz - Default"
"Desenhando"
qp.setPen(pen)
"Centros dos Roletes"
p1 = QPointF(x-17.5, y-6)
p2 = QPointF(x-17.5, y+6)
"Desenha roletes"
qp.drawEllipse(p1, 2.5, 2.5)
"Desenha a linha_1 da base"
qp.drawLine(x-14, y+10.5, x-14, y-10.5)
qp.drawLine(x-21, y+10.5, x-21, y-10.5)
"Desenha a linha de ligação"
qp.drawLine(x, y, x-14, y)
k = 0
while k <= 21:
qp.drawLine(x-21, y-10.5+k, x-26, y-6+k)
k += 7
def drawApoioXZ_180(self, qp, no):

"Função para desenhar apoio fixo xz - Rot_180"
"Desenhando"
qp.setPen(pen)
p1 = QPointF(x+17.5, y-6)
p2 = QPointF(x+17.5, y+6)
"Desenha roletes"
qp.drawLine(x+14, y+10.5, x+14, y-10.5)
qp.drawLine(x+21, y+10.5, x+21, y-10.5)
107
qp.drawLine(x, y, x+14, y)
k = 0
while k <= 21:
qp.drawLine(x+21, y-10.5+k, x+26, y-15+k)
k += 7
def drawApoioYZ(self, qp, no):

"Função para desenhar apoio fixo yz - Default"
"Desenhando"
qp.setPen(pen)
p1 = QPointF(x-6, y+17.5)
p2 = QPointF(x+6, y+17.5)
"Desenha roletes"
qp.drawLine(x-10.5, y+14, x+10.5, y+14)
qp.drawLine(x-10.5, y+21, x+10.5, y+21)
"Desenha linha de ligação"
qp.drawLine(x, y, x, y + 14)
k = 0
while k <= 21:
k += 7
def drawApoioYZ_180(self, qp, no):

"Função para desenhar apoio fixo yz - Rot_180"
"Desenhando"
qp.setPen(pen)
p1 = QPointF(x-6, y-17.5)
p2 = QPointF(x+6, y-17.5)
"Desenha roletes (Engaste + Apoio_1G)"
qp.drawLine(x-10.5, y-14, x+10.5, y-14)
qp.drawLine(x-10.5, y-21, x+10.5, y-21)
qp.drawLine(x, y, x, y-14)
k = 0
while k <= 21:
k += 7
def drawApoioXYZ(self, qp, no):
108
"Função para desenhar apoio fixo xyz - Default - Rot_0"
"Desenhando"
qp.setPen(pen)
qp.drawLine(x-10.5, y+14, x+10.5, y+14)
qp.drawLine(x, y, x, y + 14)
k = 0
while k <= 21:
k += 7
def drawApoioXYZ_90(self, qp, no):

"Função para desenhar apoio fixo xyz - Rot_90"
"Desenhando"
qp.setPen(pen)
qp.drawLine(x+14, y+10.5, x+14, y-10.5)
qp.drawLine(x, y, x+14, y)
k = 0
while k <= 21:
qp.drawLine(x+14, y-10.5+k, x+19, y-15+k)
k += 7

"Desenhando"
qp.setPen(pen)
qp.drawLine(x-10.5, y-14, x+10.5, y-14)
qp.drawLine(x, y, x, y-14)
k = 0
while k <= 21:
k += 7

"Desenhando"
qp.setPen(pen)
109
qp.drawLine(x-14, y+10.5, x-14, y-10.5)
qp.drawLine(x, y, x - 14, y)
k = 0
while k <= 21:
qp.drawLine(x-14, y-10.5+k, x-19, y-6+k)
k += 7
def drawApoioZ(self, qp, no):

"Função para desenhar apoio fixo z - Default - Rot_0"
"Desenhando"
qp.setPen(pen)
centro = QRectF(x-10, y+10, 20, -20)
qp.drawRects(centro)
###########################################################################
#############################################
#__FUNÇÕES PARA DESENHAR AS CARGAS
NODAIS_____________________________________________________________________
__________
###########################################################################
#############################################
def drawFx1(self, qp, no, fx):

"Função para desenhar carga nodal - Eixo x positivo"
fx = str("%.2f" %(abs(fx)))
a = QPointF(x-10, y)
b = QPoint(x-20, y-5)
c = QPoint(x-20, y+5)
pen = QPen(Qt.cyan, 1, Qt.SolidLine)
qp.setPen(pen)
qp.setBrush(QColor(Qt.cyan))
qp.setBrush(Qt.NoBrush)
qp.drawLine(x-10, y, x-65, y)
qp.drawText(x-75, y-8, fx+" kN")
def drawFx2(self, qp, no, fx):

"Função para desenhar carga nodal - Eixo x negativo"
fx = str("%.2f" %(abs(fx)))
a = QPointF(x+10, y)
b = QPoint(x+20, y-5)
c = QPoint(x+20, y+5)
pen = QPen(Qt.cyan, 1, Qt.SolidLine)
qp.setPen(pen)
qp.setBrush(QColor(Qt.cyan))
qp.drawLine(x+10, y, x+65, y)
110
qp.drawText(x+40, y-8, fx+" kN")
def drawFy1(self, qp, no, fy):

"Função para desenhar carga nodal - Eixo y positivo"
fy = str("%.2f" %(abs(fy)))
a = QPointF(x, y+10)
b = QPoint(x-5, y+20)
c = QPoint(x+5, y+20)
pen = QPen(Qt.yellow, 1, Qt.SolidLine)
qp.setPen(pen)
qp.setBrush(QColor(Qt.yellow))
qp.drawLine(x, y+10, x, y+65)
qp.drawText(x+8, y+65, fy+" kN")
def drawFy2(self, qp, no, fy):

"Função para desenhar carga nodal - Eixo y negativo"
fy = str("%.2f" %(abs(fy)))
a = QPointF(x, y-10)
b = QPoint(x-5, y-20)
c = QPoint(x+5, y-20)
pen = QPen(Qt.yellow, 1, Qt.SolidLine)
qp.setPen(pen)
qp.setBrush(QColor(Qt.yellow))
qp.drawLine(x, y-10, x, y-65)
qp.drawText(x+8, y-60, fy+" kN")
def drawMz1(self, qp, no, mz):

"Função para desenhar momento aplicado - Eixo z positivo"
mz = str("%.2f" %(abs(mz)))
a = QPointF(x-10, y-30)
b = QPoint(x, y-35)
c = QPoint(x, y-25)
centro = QRectF(x-30, y+30, 60, -60)
qp.setPen(pen)
qp.setBrush(QColor(Qt.red))
qp.drawArc(centro,225*16,225*16)
qp.drawText(x+30, y+30, mz+" kN.m")
#qp.drawRects(centro)
def drawMz2(self, qp, no, mz):

"Função para desenhar momento aplicado - Eixo z negativo"
mz = str("%.2f" %(abs(mz)))
a = QPointF(x+10, y-30)
111
b = QPoint(x, y-35)
c = QPoint(x, y-25)
centro = QRectF(x-30, y+30, 60, -60)
qp.setPen(pen)
qp.setBrush(QColor(Qt.red))
qp.drawArc(centro, -45*16, -225*16)
qp.drawText(x+30, y+30, mz+" kN.m")
#__FUNÇÕES PARA DESENHAR AS CARGAS

DISTRIBUÍDAS_______________________________________________________________
__________
def Wy1(self, qp):

"Função para inserir carga distribuida aplicada na direção -y"
for elem in self.Elem_des:
wi = self.Elem_des[elem]["noi"]["wi"]
wf = self.Elem_des[elem]["nof"]["wf"]
if wi != 0 or wf != 0:
xi = self.conv_x(self.Elem_des[elem]["noi"]["x"])
yi = self.conv_y(self.Elem_des[elem]["noi"]["y"])
xf = self.conv_x(self.Elem_des[elem]["nof"]["x"])
yf = self.conv_y(self.Elem_des[elem]["nof"]["y"])
L = xf - xi
#L = m.sqrt(m.pow((xf-xi),2)+m.pow((yf-yi),2))
if yi > yf:
y = yf
elif yf > yi:
y = yi
elif yi == yf:
y = yf
pen = QPen(Qt.darkGray, 0.5, Qt.SolidLine)
qp.setPen(pen)
"Desenha a linha superior da carga"
qp.drawLine(xi, (y+wi), xf, (y+wf))
c = 0
while c <= L:
x = xi + c
y1 = y+(wi+((wf-wi)/(xf-xi))*(x-xi))
if y1 < y:
a = 3
y2 = y-5
elif y1 > y:
a = -3
y2 = y+5
"Desenhando as setas que representam o carregamento"
if abs(y1-y2) >= 5:
qp.drawLine(x, y1, x, y2)
qp.drawLine(x, y2, x+a, y2-a)
qp.drawLine(x, y2, x-a, y2-a)
'''if abs(wi) <= abs(wf) and y1 <= y2:
if abs(y1-y2)>=8:
112
elif abs(wi) >= abs(wf) and y1 <= y2:
if abs(y1 - y2) >= 8:
elif abs(wi) == abs(wf):
if abs(y1 - y2) >= 8:
qp.drawLine(x, y2, x-a, y2-a)'''
c += 10
"Escrevendo os textos com os valores dos carregamentos"
if wi == wf:
w = str(abs(wi))
qp.setPen(pen)
qp.drawText(((xi+xf)/2)-30, y+wi-5,"w = " + w + "
kN/m")
if wi != wf:
w1 = str(abs(wi))
w2 = str(abs(wf))
qp.setPen(pen)
qp.drawText(((xi+xf)/2)-30, y+((wi+wf)/2)-30, "wi = " +
w1 + " kN/m")
qp.drawText(((xi+xf)/2)-30, y+((wi+wf)/2)-15, "wf = " +
w2 + " kN/m")
#==========================================================================
============================================#
# JANELA DA INTERFACE
#==========================================================================
============================================#
class Interface(QWidget):
super(Interface, self).__init__(parent)
#self.setGeometry(QRect(200, 50, 800, 500))

self.setMinimumSize(400, 500)
self.setWindowTitle('Interface do Sistema')
self.db = Dados()
#self.Nos = self.db.arq_nos()
''''BOTÕES SEM USO'''

self.bt_3 = QPushButton("BT-1")
self.bt_3.setMinimumSize(QSize(85, 25))
self.bt_3.setMaximumSize(QSize(85, 25))
self.bt_4 = QPushButton("BT-2")
self.bt_3.setVisible(False)
self.bt_4.setVisible(False)
self.bt_5 = QPushButton("Fechar")
113
self.bt_5.clicked.connect(self.fechar)
self.h_layout_2 = QHBoxLayout()
self.h_layout_2.setSpacing(5)
self.h_layout_2.addStretch(1)
#self.h_layout_2.addWidget(self.bt_Deslocamentos)
#self.h_layout_2.addWidget(self.bt_Esforcos)
self.h_layout_2.addWidget(self.bt_3)
#self.bt_Iniciar = QPushButton("Iniciar")
#self.bt_Iniciar.setMinimumSize(QSize(60, 60))
#self.bt_Iniciar.setMaximumSize(QSize(60, 60))
#self.bt_Iniciar.clicked.connect(self.abrir_nos)
self.bt_Nos = QPushButton("Inserir\nNós")
self.bt_Nos.setMinimumSize(QSize(60, 60))
self.bt_Nos.setMaximumSize(QSize(60, 60))
self.bt_Nos.clicked.connect(self.abrir_nos)
self.bt_Elementos = QPushButton("Inserir\nElementos")
self.bt_Elementos.setMinimumSize(QSize(60, 60))
self.bt_Elementos.setMaximumSize(QSize(60, 60))
self.bt_Elementos.clicked.connect(self.abrir_elementos)
self.bt_Propriedades = QPushButton("Inserir\nPropried.")
self.bt_Propriedades.setMinimumSize(QSize(60, 60))
self.bt_Propriedades.setMaximumSize(QSize(60, 60))
self.bt_Propriedades.clicked.connect(self.abrir_propriedades)
self.bt_Apoios = QPushButton("Inserir\nApoios")
self.bt_Apoios.setMinimumSize(QSize(60, 60))
self.bt_Apoios.setMaximumSize(QSize(60, 60))
self.bt_Apoios.clicked.connect(self.abrir_apoios)
self.bt_CargaNodal = QPushButton("Inserir\nNodal\n( Q )")

self.bt_CargaNodal.setMinimumSize(QSize(60, 60))
self.bt_CargaNodal.setMaximumSize(QSize(60, 60))
self.bt_CargaNodal.clicked.connect(self.abrir_carga_C)
self.bt_Carga_Dist = QPushButton("Inserir\nDist.\n( W )")

self.bt_Carga_Dist.setMinimumSize(QSize(60, 60))
self.bt_Carga_Dist.setMaximumSize(QSize(60, 60))
self.bt_Carga_Dist.clicked.connect(self.abrir_carga_D)
self.bt_Deslocamentos = QPushButton("Visualizar\nDeslocam.")
self.bt_Deslocamentos.setMinimumSize(QSize(60, 60))
self.bt_Deslocamentos.setMaximumSize(QSize(60, 60))
self.bt_Deslocamentos.clicked.connect(self.calcular)
self.bt_Deslocamentos.clicked.connect(self.abrir_desloc)
self.bt_Esforcos = QPushButton("Visualizar\nEsforços")
self.bt_Esforcos.setMinimumSize(QSize(60, 60))
self.bt_Esforcos.setMaximumSize(QSize(60, 60))
self.bt_Esforcos.clicked.connect(self.calcular)
self.bt_Esforcos.clicked.connect(self.abrir_esforcos)
#self.bt_Calcular = QPushButton("Calcular\nEstrutura")
#self.bt_Calcular.setMinimumSize(QSize(60, 60))
#self.bt_Calcular.setMaximumSize(QSize(60, 60))
114
#self.bt_Calcular.clicked.connect(self.calcular)
self.bt_Dimensionar = QPushButton("Dimens.\nArmadura\nLong.")
self.bt_Dimensionar.setMinimumSize(QSize(60, 60))
self.bt_Dimensionar.setMaximumSize(QSize(60, 60))
self.bt_Dimensionar.clicked.connect(self.abrir_dimensionamento)
self.bt_Salvar_txt = QPushButton("Salvar\ntxt / CSV")

self.bt_Salvar_txt.setMinimumSize(QSize(60, 60))
self.bt_Salvar_txt.setMaximumSize(QSize(60, 60))
self.bt_Salvar_txt.clicked.connect(self.salvar)
self.bt_Salvar_txt.setVisible(False)
self.bt_Limpar = QPushButton("Limpar\nDados")
self.bt_Limpar.setMinimumSize(QSize(60, 60))
self.bt_Limpar.setMaximumSize(QSize(60, 60))
self.bt_Limpar.clicked.connect(self.limpar)
self.h_layout = QHBoxLayout()
self.h_layout.setSpacing(5)
#self.h_layout.addWidget(self.bt_Iniciar)
self.h_layout.addWidget(self.bt_Nos)
self.h_layout.addWidget(self.bt_Elementos)
self.h_layout.addWidget(self.bt_Propriedades)
self.h_layout.addWidget(self.bt_Apoios)
self.h_layout.addWidget(self.bt_CargaNodal)
self.h_layout.addWidget(self.bt_Carga_Dist)
self.h_layout.addWidget(self.bt_Esforcos)
self.h_layout.addWidget(self.bt_Deslocamentos)
#self.h_layout.addWidget(self.bt_Calcular)
self.h_layout.addWidget(self.bt_Dimensionar)
self.h_layout.addWidget(self.bt_Salvar_txt)
self.h_layout.addWidget(self.bt_Limpar)
self.h_layout.addStretch(1)
#self.lineEdit = QLineEdit()
#self.lineEdit.setMinimumSize(QSize(200, 20))
#self.lineEdit.setMaximumSize(QSize(200, 20))
###########################################################################
#############################################
self.drawing = Drawing()
self.scrollArea = QScrollArea()
self.scrollArea.setWidget(self.drawing)
###########################################################################
#############################################
#self.formLayout = QFormLayout()
#self.formLayout.setMargin(10)
#self.formLayout.setHorizontalSpacing(10)
#self.formLayout.setLayout(0, QFormLayout.SpanningRole,
self.h_layout)
#self.formLayout.setWidget(1, QFormLayout.LabelRole, self.lineEdit)
#self.formLayout.setWidget(2, QFormLayout.SpanningRole,
self.drawing)
#self.formLayout.setLayout(3, QFormLayout.LabelRole,
self.h_layout_2)
self.GridLayout = QGridLayout()
self.GridLayout.addLayout(self.h_layout, 0, 0)
115
#self.GridLayout.addWidget(self.lineEdit, 1, 0)
self.GridLayout.addWidget(self.scrollArea, 1, 0)
self.GridLayout.addLayout(self.h_layout_2, 2, 0)
#self.GridLayout.addWidget(self.bt_1, 3, 0)
#self.GridLayout.addWidget(self.bt_Esforcos, 3, 1)
#self.setLayout(self.formLayout)
self.setLayout(self.GridLayout)
def abrir_nos(self):
W = J_Nos(self)
W.setModal(True)
W.show()
W.exec_()
def abrir_elementos(self):
W = J_Elementos(self)
W.setModal(True)
W.show()
W.exec_()
def abrir_propriedades(self):
W = J_Propriedades(self)
W.setModal(True)
W.show()
W.exec_()
def abrir_apoios(self):
W = J_Apoios(self)
W.setModal(True)
W.show()
W.exec_()
def abrir_carga_C(self):
W = J_Carga_C(self)
W.setModal(True)
W.show()
W.exec_()
def abrir_carga_D(self):
W = J_Carga_D(self)
W.setModal(True)
W.show()
W.exec_()
def abrir_dimensionamento(self):
W = J_Dimensionamento(self)
W.setModal(True)
W.showMaximized()
W.exec_()
def abrir_selvar_txt(self):
W = J_Salvar_txt(self)
W.setModal(True)
W.show()
W.exec_()
116
def abrir_desloc(self):
W = J_Res_Desloc(self)
W.setModal(True)
W.show()
W.exec_()
def abrir_esforcos(self):
W = J_Res_Esforcos(self)
W.setModal(True)
W.show()
W.exec_()
def calcular(self):
inicio = time.time()
self.calculos = Calculos()
self.calculos.deslocamentos()
self.calculos.reacoes()
self.calculos.esforcos()
fim = time.time()
print("\nTempo de execução:", round((fim - inicio),ndigits=4))
#self.close()
#self.show()
def salvar(self):
"Função para salvar os resultados em arquivo .txt, para abrir com
EXCEL"
#self.db.abrir_resultados()
#self.db.salvar_resultados()
self.abrir_selvar_txt()
'''def teste(self):
self.lineEdit.setText('Testando a Janela')'''
def limpar(self):
self.db.limpar()
self.close()
self.show()
def fechar(self):
self.close()
self.destroy()
if __name__ == '__main__':
import sys
root = QApplication(sys.argv)
app = Interface(None)
app.showMaximized()
app.show()
root.exec_()
Código da janela para inserção dos nós

#from J_Interface import*
class J_Nos(QDialog):
117
super(J_Nos, self).__init__(parent)
self.db = Dados()
self.setWindowTitle("INSERIR NÓS")
self.resize(270, 465)
self.setMinimumSize(QSize(270, 465))
self.setMaximumSize(QSize(270, 465))
self.tableWidget = QTableWidget(self)
self.tableWidget.setGeometry(20, 130, 230, 230)
self.tableWidget.setColumnCount(3)
item = QTableWidgetItem()
item.setText("Nó")
self.tableWidget.setHorizontalHeaderItem(0, item)
item.setText("X")
item.setText("Y")
for i in range(0):
self.tableWidget.insertRow(i)
self.tableWidget.horizontalHeader().setDefaultSectionSize(70)
self.tableWidget.verticalHeader().setVisible(False)
self.tableWidget.verticalHeader().setDefaultSectionSize(20)
self.bt_Excluir = QPushButton("Excluir", self)

self.bt_Excluir.setGeometry(QRect(17.5, 370, 75, 25))
self.bt_Excluir.setFocusPolicy(Qt.NoFocus)
self.bt_Excluir.clicked.connect(self.excluir)
self.bt_Inserir = QPushButton("Inserir", self)

self.bt_Inserir.setGeometry(QRect(97.5, 370, 75, 25))
self.bt_Inserir.clicked.connect(self.inserir)
self.bt_Inserir.setShortcut("Enter")
self.bt_Salvar = QPushButton("Salvar", self)

self.bt_Salvar.setGeometry(QRect(177.5, 370, 75, 25))
self.bt_Salvar.clicked.connect(self.salvar)
#self.bt_Salvar.clicked.connect(self.abrir_elementos)
self.lineEdit_y = QLineEdit(self)
self.lineEdit_y.setGeometry(QRect(180, 70, 70, 20))
self.lineEdit_y.setMinimumSize(QSize(15, 20))
self.lineEdit_y.setAlignment(Qt.AlignCenter)
self.lineEdit_x = QLineEdit(self)
self.lineEdit_x.setGeometry(QRect(100, 70, 70, 20))
self.lineEdit_x.setAlignment(Qt.AlignCenter)
self.lineEdit_No = QLineEdit(self)
self.lineEdit_No.setEnabled(True)
self.lineEdit_No.setGeometry(QRect(20, 70, 70, 20))
item = self.tableWidget.currentRow()
118
self.lineEdit_No.setText(str(item + 2))
self.lineEdit_No.setMouseTracking(False)
self.lineEdit_No.setFocusPolicy(Qt.NoFocus)
self.lineEdit_No.setAcceptDrops(False)
self.lineEdit_No.setAlignment(Qt.AlignCenter)
#self.label_1 = QLabel(self)
#self.label_1.setGeometry(QRect(20, 400, 221, 41))
#self.label_1.setText("Clique duas vezes sobre uma coordenada\n
para editar.")
self.label_2 = QLabel(self)
self.label_2.setGeometry(QRect(20, 425, 221, 41))
self.label_2.setText("Clique 'Excluir' para deletar a última
linha.")
self.label_No = QLabel(self)
self.label_No.setGeometry(QRect(20, 50, 70, 13))
self.label_No.setText("Id - Nó")
self.label_No.setAlignment(Qt.AlignCenter)
self.label_x = QLabel(self)
self.label_x.setGeometry(QRect(100, 50, 70, 13))
self.label_x.setText("X")
self.label_x.setAlignment(Qt.AlignCenter)
self.label_y = QLabel(self)
self.label_y.setGeometry(QRect(180, 50, 70, 13))
self.label_y.setText("Y")
self.label_y.setAlignment(Qt.AlignCenter)
self.label_3.setText("Inserir Coordenadas dos Nós")
font = QFont()
font.setPointSize(10)
font.setBold(True)
font.setWeight(75)
self.label_3.setFont(font)
self.label_3.setAlignment(Qt.AlignCenter)
self.label_4.setText("Nós Inseridos")
font = QFont()
font.setBold(True)
font.setWeight(75)
self.setTabOrder(self.lineEdit_x, self.lineEdit_y)
self.setTabOrder(self.lineEdit_y, self.bt_Inserir)
self.setTabOrder(self.bt_Inserir, self.bt_Salvar)
self.setTabOrder(self.bt_Salvar, self.tableWidget)
self.setTabOrder(self.tableWidget, self.lineEdit_No)
self.tableWidget.setFocusPolicy(Qt.NoFocus)
self.bt_Inserir.setFocusPolicy(Qt.NoFocus)
self.bt_Salvar.setFocusPolicy(Qt.NoFocus)
self.repopular()
119
def repopular(self):
"Função para extrair dados do dicionário Nós e repopular a janela
Nós"
Nos = list(self.Nos.keys())
Nos.sort()
for no in Nos:
id_no = no
x = self.Nos[id_no]["x"]
y = self.Nos[id_no]["y"]
id_no = self.db.conv_real(no)
if id_no %1 == 0:
id_no = int(id_no)
self.lineEdit_No.setText(str(id_no+1))
self.tableWidget.insertRow(id_no-1)
item.setText(str(id_no))
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter |
Qt.AlignCenter)
item.setFlags(Qt.ItemIsEnabled) #__Para desabilitar a
ediçao dos campos da coluna 0 da tabela
self.tableWidget.setItem((id_no-1), 0, item)
item.setText(str(x))
Qt.AlignCenter)
item.setFlags(Qt.ItemIsEnabled)
item.setText(str(y))
Qt.AlignCenter)
def inserir(self):
x = self.lineEdit_x.text()
y = self.lineEdit_y.text()
c=0
while self.tableWidget.item(c,0)!=None:
c+=1
if x and y != '':
self.lineEdit_No.setText(str(c+2))
self.tableWidget.insertRow(c)
item.setText(str(c + 1))
Qt.AlignCenter)
self.tableWidget.setItem(c, 0, item)
item.setText(str(float(x)))
Qt.AlignCenter)
item.setText(str(float(y)))
Qt.AlignCenter)
120
no = (int(float(self.lineEdit_No.text())-1))
no_prog = int(self.db.conv_prog(no))
x = (float(self.lineEdit_x.text()))
y = (float(self.lineEdit_y.text()))
self.db.inserir_no(no_prog,x,y)
self.db.inserir_no_des(no,x,y)
self.close()
self.show()
self.lineEdit_x.clear()
self.lineEdit_y.clear()
self.lineEdit_x.setFocus()
def salvar(self):
# _TRECHO PARA O CASO DE SER POSSÍVEL EDITAR AS COORDENADAS DOS
NÓS_#
'''c = 0
while self.tableWidget.item(c, 0) != None:
no = int(float(self.tableWidget.item(c, 0).text()))
x = float(self.tableWidget.item(c, 1).text())
y = float(self.tableWidget.item(c, 2).text())
#self.db.atualizar_no(no, x, y)
self.db.salvar_nos(self.Nos)
c += 1'''
print("\nNós")
self.db.ord_nos()
print("\nNós_des")
self.db.ord_nos_des()
self.close()
self.destroy()
def excluir (self):

c = 0
c += 1
self.tableWidget.removeRow(c-1)
self.lineEdit_No.setText(str(c))
self.db.excluir_no(self.db.conv_prog(c))
self.db.excluir_no_des(c)
self.close()
self.show()
if __name__ == '__main__':
import sys
app = J_Nos()
app.show()
root.exec_()
Codigo da janela para inserção dos elementos

from J_Propriedades import*
import time
class J_Elementos(QDialog):
121
super(J_Elementos, self).__init__(parent)
self.db = Dados()
self.Elem_des = self.db.arq_elem_des()
self.setWindowTitle("INSERIR ELEMENTOS")
self.tableWidget.setGeometry(20, 130, 230, 230)
item.setText("Elemento")
item.setText("Nó i")
item.setText("Nó f")
for i in range(0):
self.bt_Excluir = QPushButton("Excluir", self)

self.bt_Excluir.setGeometry(QRect(17.5, 370, 75, 25))
self.bt_Excluir.setFocusPolicy(Qt.NoFocus)
self.bt_Excluir.clicked.connect(self.excluir)
#self.bt_Excluir.setShortcut("Enter")
self.bt_Inserir = QPushButton("Inserir",self)
self.bt_Inserir.setGeometry(QRect(97.5, 370, 75, 25))
self.bt_Inserir.setShortcut("Enter")

self.bt_Salvar.setGeometry(QRect(177.5, 370, 75, 25))
self.bt_Salvar.clicked.connect(self.close)
self.lineEdit_Nof = QLineEdit(self)
self.lineEdit_Nof.setGeometry(QRect(180, 70, 70, 20))
self.lineEdit_Nof.setMinimumSize(QSize(15, 20))
self.lineEdit_Nof.setAlignment(Qt.AlignCenter)
self.lineEdit_Noi = QLineEdit(self)
self.lineEdit_Noi.setGeometry(QRect(100, 70, 70, 20))
self.lineEdit_Noi.setAlignment(Qt.AlignCenter)
122
self.lineEdit_Elemento = QLineEdit(self)
self.lineEdit_Elemento.setEnabled(True)
self.lineEdit_Elemento.setGeometry(QRect(20, 70, 70, 20))
item = self.tableWidget.currentRow()
self.lineEdit_Elemento.setText(str(item + 2))
self.lineEdit_Elemento.setFocusPolicy(Qt.NoFocus)
self.lineEdit_Elemento.setAlignment(Qt.AlignCenter)
self.label_Elemento = QLabel(self)
self.label_Elemento.setGeometry(QRect(20, 50, 70, 13))
self.label_Elemento.setText("Id - Elemento")
self.label_Elemento.setAlignment(Qt.AlignCenter)
self.label_Noi = QLabel(self)
self.label_Noi.setGeometry(QRect(100, 50, 70, 13))
self.label_Noi.setText("Nó i")
self.label_Noi.setAlignment(Qt.AlignCenter)
self.label_Nof = QLabel(self)
self.label_Nof.setGeometry(QRect(180, 50, 70, 13))
self.label_Nof.setText("Nó f")
self.label_Nof.setAlignment(Qt.AlignCenter)
self.label_1.setText("Inserir Elementos e Nós Vinculados")
font = QFont()
font.setBold(True)
font.setWeight(75)
self.label_2.setText("Elementos Inseridos")
font = QFont()
font.setBold(True)
font.setWeight(75)
#self.label_3 = QLabel(self)
#self.label_3.setGeometry(QRect(20, 400, 221, 41))
#self.label_3.setText("Clique duas vezes sobre um Nó para editar.")
self.label_4.setText("Clique 'EXCLUIR' para deletar a última
linha.")
self.setTabOrder(self.lineEdit_Noi, self.lineEdit_Nof)
self.setTabOrder(self.lineEdit_Nof, self.bt_Inserir)
self.setTabOrder(self.bt_Inserir, self.bt_Salvar)
self.setTabOrder(self.bt_Salvar, self.tableWidget)
self.setTabOrder(self.tableWidget, self.lineEdit_Elemento)
self.tableWidget.setFocusPolicy(Qt.NoFocus)
123
self.repopular()
def repopular(self):
"Função para extrair dados do dicionário Elem e repopular a janela
Elementos"
n = self.db.n()
Elementos = list(self.Elem.keys())
Elementos.sort()
for elem in Elementos:
id_elem = self.db.conv_real(elem)
if id_elem % 1 == 0:
noi = self.db.conv_real(self.Elem[elem]["noi"]["id"])
nof = self.db.conv_real(self.Elem[elem+(n-1)]["nof"]["id"])
id_elem = int(id_elem)
self.lineEdit_Elemento.setText(str(id_elem+1))
self.tableWidget.insertRow(id_elem-1)
item.setText(str(id_elem))
Qt.AlignCenter)
self.tableWidget.setItem((id_elem-1), 0, item)
item.setText(str(noi))
Qt.AlignCenter)
item.setText(str(nof))
Qt.AlignCenter)
def inserir(self):
noi = self.lineEdit_Noi.text()
nof = self.lineEdit_Nof.text()
c = 0
c += 1
if noi and nof != '':
self.lineEdit_Elemento.setText(str(c + 2))
self.tableWidget.insertRow(c)
item.setText(str(c + 1))
Qt.AlignCenter)
item.setText(str(float(noi)))
Qt.AlignCenter)
item.setText(str(float(nof)))
124
Qt.AlignCenter)
elem = (int(float(self.lineEdit_Elemento.text())-1))
noi = (float(self.lineEdit_Noi.text()))
nof = (float(self.lineEdit_Nof.text()))
self.db.inserir_elem(elem, noi, nof)
self.db.inserir_elem_des(elem, noi, nof)
self.close()
self.show()
self.lineEdit_Noi.clear()
self.lineEdit_Nof.clear()
self.lineEdit_Noi.setFocus()
def salvar(self):
#inicio = time.time()
print("\nNós")
self.db.ord_nos()
print("\nNós Desenho")
print("\nElementos")
self.db.ord_elem()
print("\nElementos Desenho")
self.db.ord_elem_des()
self.close()
self.destroy()
self.abrir_propriedades()
#fim = time.time()
#print("\nTempo de execução:",fim-inicio)
def excluir(self):
c = 0
c += 1
self.tableWidget.removeRow(c-1)
self.lineEdit_Elemento.setText(str(c))
self.db.excluir_elem(c)
#__Função que será desnecessária apos nova adequação sem os
elementos e nós de desenho
self.db.excluir_elem_des(c)
self.close()
self.show()
def abrir_propriedades(self):
time.sleep(1)
W = J_Propriedades(self)
W.setModal(True)
W.show()
W.exec_()
if __name__ == '__main__':
import sys
app = J_Elementos()
app.show()
root.exec_()
125
Código da janela para inserção das propriedades físicas e mecânicas dos
elementos

from Dicionarios import *
class J_Propriedades(QDialog):
super(J_Propriedades, self).__init__(parent)
self.db = Dados()
'''try:
with open('Elementos.txt', 'r') as f:
f = 'Elementos.txt'
print("\nO arquivo",f, "existe e pode ser utilizado pelo
sistema")
self.Elem = self.db.abrir_elem()
except IOError:
print(u'Arquivo não encontrado - O banco de dados esta sendo
inicializado!')
self.Elem = self.db.dic_elem()'''
self.setWindowTitle("PROPRIEDADES")
self.label_Area = QLabel("Área da Seção (cm^2):", self)

self.label_Area.setGeometry(QRect(10, 20, 115, 16))
self.label_Area.setAlignment(Qt.AlignLeading|Qt.AlignLeft|
Qt.AlignVCenter)
self.label_Inercia = QLabel("Momento de Inércia (cm^4):", self)

self.label_Inercia.setGeometry(QRect(10, 50, 135, 16))
self.label_Inercia.setAlignment(Qt.AlignLeading|Qt.AlignLeft|
Qt.AlignVCenter)
self.label_ModuloE = QLabel("Módulo de Elasticidade (MPa):", self)

self.label_ModuloE.setGeometry(QRect(10, 80, 145, 16))
self.label_ModuloE.setAlignment(Qt.AlignLeading|Qt.AlignLeft|
Qt.AlignVCenter)
self.label_Elementos = QLabel("Elementos:", self)

self.label_Elementos.setGeometry(QRect(10, 120, 55, 16))
self.label_Elementos.setAlignment(Qt.AlignLeading|Qt.AlignLeft|
Qt.AlignVCenter)
self.lineEdit_Area = QLineEdit(self)
self.lineEdit_Area.setGeometry(QRect(155, 20, 90, 20))
self.lineEdit_Area.setAlignment(Qt.AlignCenter)
self.lineEdit_Area.setText("450.00")
self.lineEdit_MomentoI = QLineEdit(self)
self.lineEdit_MomentoI.setGeometry(QRect(155, 50, 90, 20))
self.lineEdit_MomentoI.setAlignment(Qt.AlignCenter)
self.lineEdit_MomentoI.setText("33750.00")
126
self.lineEdit_ModuloE = QLineEdit(self)
self.lineEdit_ModuloE.setGeometry(QRect(155, 80, 90, 20))
self.lineEdit_ModuloE.setAlignment(Qt.AlignCenter)
self.lineEdit_ModuloE.setText("25000.00")
self.bt_Aplicar = QPushButton("Aplicar", self)

self.bt_Aplicar.setGeometry(QRect(90, 270, 75, 23))
self.bt_Aplicar.setFocusPolicy(Qt.NoFocus)
self.bt_Aplicar.clicked.connect(self.aplicar)
self.bt_Aplicar.setShortcut("Enter")

self.bt_Salvar.setGeometry(QRect(170, 270, 75, 23))
self.comboBox_Elementos = QComboBox(self)
self.comboBox_Elementos.setGeometry(QRect(70, 120, 80, 22))
self.comboBox_Elementos.addItem("")
self.comboBox_Elementos.setItemText(0, "Selecione...")
self.checkBox_Elementos = QCheckBox("Todos", self)

self.checkBox_Elementos.setGeometry(QRect(160, 125, 70, 17))
self.popular_elementos()
def popular_elementos(self):
"Função para inserir os elementos no ComboBox Elementos"
Elementos.sort()
self.comboBox_Elementos.addItem("")
self.comboBox_Elementos.setItemText(id_elem, str(id_elem))
def aplicar(self):
if self.checkBox_Elementos.isChecked():
for elem in self.Elem:
elem = elem
A = float(self.lineEdit_Area.text())
I = float(self.lineEdit_MomentoI.text())
E = float(self.lineEdit_ModuloE.text())
self.db.prop_elem(elem, A, I, E)
else:
n = self.db.n()
elem = float(self.comboBox_Elementos.currentText())
elem = self.db.conv_prog(elem)
A = float(self.lineEdit_Area.text())
I = float(self.lineEdit_MomentoI.text())
E = float(self.lineEdit_ModuloE.text())
"Laço para inserir as propriedades nos novos elementos gerados"
c = 0
while c < n:
self.db.prop_elem(elem+c, A, I, E)
c+=1
self.comboBox_Elementos.setCurrentIndex(0)
self.checkBox_Elementos.setChecked(False)
127
def salvar(self):
print("\nElementos")
self.db.ord_elem()
self.close()
self.destroy()
if __name__ == '__main__':
import sys
app = J_Propriedades()
app.show()
root.exec_()
Código da janela para inserção dos apoios da estrutura

class J_Apoios(QDialog):
super(J_Apoios, self).__init__(parent)
self.db = Dados()
self.setWindowTitle("INSERIR RESTRIÇÕES")
self.label_Condicoes = QLabel("Inserir Restrições Nodais", self)

self.label_Condicoes.setGeometry(QRect(0, 20, 275, 16))
font = QFont()
font.setBold(True)
font.setWeight(75)
self.label_Condicoes.setFont(font)
self.label_Condicoes.setAlignment(Qt.AlignCenter)
self.groupBox_Fixar = QGroupBox("Restringir Nós:", self)

self.groupBox_Fixar.setGeometry(QRect(10, 50, 165, 145))
self.checkBox_Dx = QCheckBox("Fixar Desloc. x",

self.groupBox_Fixar)
self.checkBox_Dx.setGeometry(QRect(10, 25, 100, 20))
self.checkBox_Dy = QCheckBox("Fixar Desloc. y",

self.groupBox_Fixar)
self.checkBox_Dy.setGeometry(QRect(10, 55, 100, 20))
self.checkBox_Rz = QCheckBox("Fixar Rot. z", self.groupBox_Fixar)

self.checkBox_Rz.setGeometry(QRect(10, 85, 100, 20))
self.label_Angulo = QLabel("Ângulo (deg):", self.groupBox_Fixar)

self.label_Angulo.setGeometry(QRect(10, 115, 70, 16))
128
self.comboBox_Angulo = QComboBox(self.groupBox_Fixar)
self.comboBox_Angulo.setGeometry(QRect(80, 115, 80, 20))
self.comboBox_Angulo.addItem("0\xB0")
self.checkBox_Dx.clicked.connect(self.angulos)
self.checkBox_Dy.clicked.connect(self.angulos)
self.checkBox_Rz.clicked.connect(self.angulos)
self.groupBox_Atribuir = QGroupBox("Atribuir Deslocamentos:", self)

self.groupBox_Atribuir.setGeometry(QRect(10, 205, 165, 120))
self.label_Dx = QLabel("Desloc. x (cm):", self.groupBox_Atribuir)

self.label_Dx.setGeometry(QRect(10, 30, 75, 13))
self.label_Dy = QLabel("Desloc. y (cm):", self.groupBox_Atribuir)

self.label_Dy.setGeometry(QRect(10, 60, 75, 13))
self.label_Rz = QLabel("Rot. z (rad):", self.groupBox_Atribuir)

self.label_Rz.setGeometry(QRect(10, 90, 75, 13))
self.lineEdit_Dx = QLineEdit(self.groupBox_Atribuir)
self.lineEdit_Dx.setGeometry(QRect(85, 30, 70, 20))
self.lineEdit_Dx.setAlignment(Qt.AlignCenter)
self.lineEdit_Dy = QLineEdit(self.groupBox_Atribuir)
self.lineEdit_Dy.setGeometry(QRect(85, 60, 70, 20))
self.lineEdit_Dy.setAlignment(Qt.AlignCenter)
self.lineEdit_Rz = QLineEdit(self.groupBox_Atribuir)
self.lineEdit_Rz.setGeometry(QRect(85, 90, 70, 20))
self.lineEdit_Rz.setAlignment(Qt.AlignCenter)
self.groupBox_Restringir = QGroupBox("Restringir Ações:", self)

self.groupBox_Restringir.setGeometry(QRect(10, 335, 165, 110))
self.checkBox_Rest_Fx = QCheckBox("Rest. Fx (Normal)",

self.groupBox_Restringir)
self.checkBox_Rest_Fx.setGeometry(QRect(10, 25, 120, 20))
self.checkBox_Rest_Fy = QCheckBox("Rest. Fy (Cortante)",

self.checkBox_Rest_Fy.setGeometry(QRect(10, 55, 120, 20))
self.checkBox_Rest_Rz = QCheckBox("Rest. Rz (M. Fletor)",

self.checkBox_Rest_Rz.setGeometry(QRect(10, 85, 120, 20))
self.label_Selecionar = QLabel("Selecionar Nós:", self)

self.label_Selecionar.setGeometry(QRect(185, 50, 81, 16))
self.comboBox_Nos = QComboBox(self)
self.comboBox_Nos.setGeometry(QRect(185, 70, 80, 22))
self.comboBox_Nos.addItem("")
self.comboBox_Nos.setItemText(0, "Selecione...")
self.bt_Inserir = QPushButton("Inserir", self)

self.bt_Inserir.setGeometry(QRect(185, 100, 80, 23))
129
self.checkBox_Dx.clicked.connect(self.verificar_Dx)
self.checkBox_Dy.clicked.connect(self.verificar_Dy)
self.checkBox_Rz.clicked.connect(self.verificar_Rz)
self.popular_nos()
def popular_nos(self):
'''Inserir (popular) os nós do banco de dados dentro do
ComboBox_Nos'''
Nos.sort()
for no in Nos:
if id_no % 1 == 0:
id_no = int(id_no)
self.comboBox_Nos.addItem("")
self.comboBox_Nos.setItemText(id_no, str(id_no))
def angulos(self):
self.comboBox_Angulo.clear()
self.Dx = self.checkBox_Dx
self.Dy = self.checkBox_Dy
self.Rz= self.checkBox_Rz
if self.Rz.isChecked():
if self.Dx.isChecked() or self.Dy.isChecked():
if self.Dx.isChecked() and self.Dy.isChecked() and
self.Rz.isChecked():
def inserir(self):
'''Inserir restrições nodais'''
angulo = self.comboBox_Angulo.currentText()
if angulo == "0\xB0":
rot = 0
elif angulo == "90\xB0":
rot = 1
rot = 2
rot = 3
if self.checkBox_Dx.isChecked():
u = 1
else:
u = 0
if self.checkBox_Dy.isChecked():
v = 1
130
else:
v = 0
if self.checkBox_Rz.isChecked():
t = 1
else:
t = 0
no = int(self.comboBox_Nos.currentText())
no_prog = self.db.conv_prog(no)
self.db.rest_nos(no_prog, u, v, t)
self.db.rest_nos_des(no, u, v, t, rot)
self.close()
self.show()
# __Desmarcando opções selecionadas
self.comboBox_Nos.setCurrentIndex(0)
self.checkBox_Dx.setChecked(False)
self.checkBox_Dy.setChecked(False)
self.checkBox_Rz.setChecked(False)
#__Funções para verificar se os checkBox estão selecionados e então

desabilitar o campo de inserção de deslocamentos
def verificar_Dx(self):
if self.checkBox_Dx.isChecked():
self.lineEdit_Dx.setText("0.00")
self.lineEdit_Dx.setEnabled(False)
else:
self.lineEdit_Dx.setText("")
self.lineEdit_Dx.setEnabled(True)
def verificar_Dy(self):
if self.checkBox_Dy.isChecked():
self.lineEdit_Dy.setText("0.00")
self.lineEdit_Dy.setEnabled(False)
else:
self.lineEdit_Dy.setText("")
self.lineEdit_Dy.setEnabled(True)
def verificar_Rz(self):
if self.checkBox_Rz.isChecked():
self.lineEdit_Rz.setText("0.00")
self.lineEdit_Rz.setEnabled(False)
else:
self.lineEdit_Rz.setText("")
self.lineEdit_Rz.setEnabled(True)
def salvar(self):
print("\nNós")
self.db.ord_nos()
print("\nNós_des")
self.close()
self.destroy()
if __name__ == '__main__':
import sys
app = J_Apoios()
app.show()
root.exec_()
131
Código da janela para inserção sas cargas nodais

class J_Carga_C(QDialog):
super(J_Carga_C, self).__init__(parent)
self.db = Dados()
self.setWindowTitle("CARGAS NODAIS")
self.label_Fx = QLabel("Fx (kN):", self)

self.label_Fx.setGeometry(QRect(0, 18, 60, 16))
self.label_Fx.setAlignment(Qt.AlignRight)
self.label_Fy = QLabel("Fy (kN):", self)
self.label_Fy.setGeometry(QRect(0, 48, 60, 16))
self.label_Fy.setAlignment(Qt.AlignRight)
self.label_Mz = QLabel("Mz (kN.m):", self)
self.label_Mz.setGeometry(QRect(0, 78, 60, 16))
self.label_Mz.setAlignment(Qt.AlignRight)
self.label_No = QLabel("Nó:", self)
self.label_No.setGeometry(QRect(0, 108, 60, 16))
self.label_No.setAlignment(Qt.AlignRight)
self.lineEdit_Fx = QLineEdit(self)
self.lineEdit_Fx.setGeometry(QRect(65, 15, 80, 20))
self.lineEdit_Fx.setAlignment(Qt.AlignCenter)
self.lineEdit_Fx.setText("0.00")
self.lineEdit_Fx.setFocus()
self.lineEdit_Fy = QLineEdit(self)
self.lineEdit_Fy.setGeometry(QRect(65, 45, 80, 20))
self.lineEdit_Fy.setAlignment(Qt.AlignCenter)
self.lineEdit_Fy.setText("0.00")
self.lineEdit_Mz = QLineEdit(self)
self.lineEdit_Mz.setGeometry(QRect(65, 75, 80, 20))
self.lineEdit_Mz.setAlignment(Qt.AlignCenter)
self.lineEdit_Mz.setText("0.00")
self.comboBox_No = QComboBox(self)
self.comboBox_No.setGeometry(QRect(65, 105, 80, 22))
self.comboBox_No.addItem("")
self.comboBox_No.setItemText(0, "Selecione...")


132
self.popular_nos()
def popular_nos(self):
"Função para extrair dados do dicionário Nós e popular o ComboBox
Nós"
Nos.sort()
for no in Nos:
if id_no % 1 == 0:
id_no = int(id_no)
self.comboBox_No.addItem("")
self.comboBox_No.setItemText(id_no, str(id_no))
def aplicar(self):
no = int(float(self.comboBox_No.currentText()))
fx = float(self.lineEdit_Fx.text())
fy = float(self.lineEdit_Fy.text())
mz = float(self.lineEdit_Mz.text())
self.db.inserir_Qnodal(no, fx, fy, mz)
self.db.inserir_Qnodal_des(no, fx, fy, mz)
self.close()
self.show()
self.lineEdit_Fx.setText("0.00")
self.lineEdit_Fy.setText("0.00")
self.lineEdit_Mz.setText("0.00")
self.comboBox_No.setCurrentIndex(0)
self.lineEdit_Fx.setFocus()
def salvar(self):
print()
self.db.ord_nos()
self.close()
self.destroy()
if __name__ == '__main__':
import sys
app = J_Carga_C()
app.show()
root.exec_()
Código da janela para inserção das cargas distribuídas

class J_Carga_D(QDialog):
super(J_Carga_D, self).__init__(parent)
self.db = Dados()
self.n = self.db.n()
self.W_dist = self.db.arq_w_dist()
133
self.setWindowTitle("CARGAS DISTRIBUÍDAS")
self.label_Wi = QLabel("Wi (kN/m):", self)

self.label_Wi.setGeometry(QRect(10, 15, 71, 16))
self.label_Wf = QLabel("Wf (kN/m):", self)

self.label_Wf.setGeometry(QRect(10, 45, 71, 16))
self.label_Orientacao = QLabel("Orientação:", self)

self.label_Orientacao.setGeometry(QRect(10, 75, 61, 16))
self.label_Elemento = QLabel("Elemento:", self)

self.label_Elemento.setGeometry(QRect(10, 105, 61, 16))
self.lineEdit_Wi = QLineEdit(self)
self.lineEdit_Wi.setGeometry(QRect(75, 15, 80, 20))
self.lineEdit_Wi.setAlignment(Qt.AlignCenter)
self.lineEdit_Wi.setText('0.00')
self.lineEdit_Wi.setFocus()
self.lineEdit_Wf = QLineEdit(self)
self.lineEdit_Wf.setGeometry(QRect(75, 45, 80, 20))
self.lineEdit_Wf.setAlignment(Qt.AlignCenter)
self.lineEdit_Wf.setText('0.00')
self.comboBox_Orientacao = QComboBox(self)
self.comboBox_Orientacao.setGeometry(QRect(75, 75, 80, 22))
self.comboBox_Orientacao.addItem("")
self.comboBox_Orientacao.setItemText(0, "Selecione...")
self.comboBox_Orientacao.setItemText(1, "Eixo x")
self.comboBox_Orientacao.setItemText(2, "Eixo y")
self.comboBox_Elemento = QComboBox(self)
self.comboBox_Elemento.setGeometry(QRect(75, 105, 80, 22))
self.comboBox_Elemento.addItem("")
self.comboBox_Elemento.setItemText(0, "Selecione...")


self.popular_elementos()
def popular_elementos(self):
"Função para extrair dados do dicionário Elem e popular o ComboBox
Elementos"
Elementos.sort()
134
self.comboBox_Elemento.addItem("")
self.comboBox_Elemento.setItemText(id_elem, str(id_elem))
def aplicar(self):
elem = int(float(self.comboBox_Elemento.currentText()))
orientacao = self.comboBox_Orientacao.currentText()
wi = float(self.lineEdit_Wi.text())
wf = float(self.lineEdit_Wf.text())
if orientacao == "Eixo x":

n = "Eixo x"
elif orientacao == "Eixo y":
n = "Eixo y"
self.db.inserir_Wdist(elem, n, wi, wf)
self.close()
self.show()
self.lineEdit_Wi.setText('0.00')
self.lineEdit_Wf.setText('0.00')
self.comboBox_Orientacao.setCurrentIndex(0)
self.comboBox_Elemento.setCurrentIndex(0)
self.lineEdit_Wi.setFocus()
def salvar(self):
self.db.inserir_eq()
print("\nCargas Distribuídas")
print(self.db.ord_wdist())
print("\nNós")
print(self.db.ord_nos())
self.close()
self.destroy()
if __name__ == '__main__':
import sys
app = J_Carga_D()
app.show()
root.exec_()
Código responsável por efetuar os cálculos da análise estrutural
import numpy as np
import math as m
class Calculos(object):
def __init__(self):
"Executando o Banco de Dados e Buscando os Dicionários para Uso de

Dados"
self.db = Dados()
self.Nos = self.db.abrir_nos()
self.Nos_des = self.db.abrir_nos_des()
self.Elem = self.db.abrir_elem()
self.W_dist = self.db.abrir_w_dist()
135
#print("\n",self.db.ord_nos())
#print("\n", self.db.ord_elem())
def T(self, elem):

"Matriz de Tansformação do Sistema de Coordenadas (Local --->
Global)"
self.xi = self.Elem[elem]["noi"]["x"]
self.yi = self.Elem[elem]["noi"]["y"]
self.xf = self.Elem[elem]["nof"]["x"]
self.yf = self.Elem[elem]["nof"]["y"]
self.L = m.sqrt(m.pow((self.xf-self.xi),2)+m.pow((self.yf-
self.yi),2))
self.Lamb_X = (self.xf - self.xi) / self.L
self.Lamb_y = (self.yf-self.yi) / self.L
T = np.array([[ self.Lamb_X, self.Lamb_y, 0, 0, 0, 0],

[-self.Lamb_y, self.Lamb_X, 0, 0, 0, 0],
[0, 0, 1, 0, 0, 0],
[0, 0, 0, self.Lamb_X, self.Lamb_y, 0],
[0, 0, 0, -self.Lamb_y, self.Lamb_X, 0],
[0, 0, 0, 0, 0, 1]])
return T
def k_(self, elem):

"Matriz de rigidez [k_] do elemnto no sistema de coordenadas local"
self.xi = self.Elem[elem]["noi"]["x"]
self.yi = self.Elem[elem]["noi"]["y"]
self.xf = self.Elem[elem]["nof"]["x"]
self.yf = self.Elem[elem]["nof"]["y"]
self.L = m.sqrt(m.pow((self.xf-self.xi),2)+m.pow((self.yf-
self.yi),2))
A = (self.Elem[elem]["Prop."]["area"]) * 1e-4
I = (self.Elem[elem]["Prop."]["inercia"]) * 1e-8
E = (self.Elem[elem]["Prop."]["elast."]) * 1e3
a1 = (E*A)/self.L
a2 = (E*I)/m.pow(self.L, 3)
L = self.L
k_ = np.array([[a1, 0, 0, -a1, 0, 0],

[0, 12 * a2, 6 * L * a2, 0, -12 * a2, 6 * L * a2],
[0, 6 * L * a2, 4 * (m.pow(L, 2)) * a2, 0, -6 * L *
a2, 2 * (m.pow(L, 2)) * a2],
[-a1, 0, 0, a1, 0, 0],
[0, -12 * a2, -6 * L * a2, 0, 12 * a2, -6 * L * a2],
[0, 6 * L * a2, 2 * (m.pow(L, 2)) * a2, 0, -6 * L *
a2, 4 * (m.pow(L, 2)) * a2]])
return k_
def k(self,elem):
"Matriz de rigidez [k] do elemento no sistema de coordenadas
global"
T = self.T(elem)
k_ = self.k_(elem)
k = ((T.transpose()).dot(k_)).dot(T)
136
return k
def K(self):
"Matriz de rigidez global da estrutura [K] - Acoplamento dos
elementos do pórtico"
nos = 0
for no in self.Nos:
nos += 1
ordem_K = 3*nos
K = np.zeros((ordem_K,ordem_K))
print("\nNós da Estrutura:\n", nos)

print("\nOrdem da Matriz de Rigidez Global: ( %d x %d )\n" %
(ordem_K, ordem_K))
print("Matriz de Rigidez Global\n", K)

self.elem = elem
i_ = self.Elem[elem]["noi"]["id"]
j_ = self.Elem[elem]["nof"]["id"]
k = self.k(self.elem)
i = (i_*3)-3
j = (j_*3)-3
# __Primeiro Quadrante Local ---> inserido em K

K[i:i + 3, i:i + 3] = K[i:i + 3, i:i + 3] + k[0:3, 0:3]
# __Segundo Quadrante Local ---> inserido em K
K[i:i + 3, j:j + 3] = K[i:i + 3, j:j + 3] + k[0:3, 3:6]
# __Terceiro Quadrante Local ---> inserido em K
K[j:j + 3, j:j + 3] = K[j:j + 3, j:j + 3] + k[3:6, 3:6]
# __Quarto Quadrante Local ---> inserido em K
K[j:j + 3, i:i + 3] = K[j:j + 3, i:i + 3] + k[3:6, 0:3]
#print("\nElemento:", elem)
#print("i = ", i, "j = ", j)
#print("\nMatriz k Global - Elemento\n", np.around(k,
decimals=1))
#print('\nMatriz K Global - Estrutura\n', np.around(K,
decimals=1))
#print('\n', np.around(K, decimals=4),'\n')
return K
def Ko(self):
'''Aplicação das condições de contorno na Matriz de Rigidez Global
para
zerar as linhas e colunas dos vínculos (u, v, t) restringidos por
apoios'''
Ko = self.K()
for no in self.Nos:
u = self.Nos[no]["Restr."]["u"]
v = self.Nos[no]["Restr."]["v"]
t = self.Nos[no]["Restr."]["t"]
id_no = no
137
if u == 1:
i = j = (id_no*3-3)
Ko[i,: ] = 0
Ko[:, j] = 0
Ko[i, j] = 1
if v == 1:
i = j = (id_no*3-3)+1
Ko[i, :] = 0
Ko[:, j] = 0
Ko[i, j] = 1
if t == 1:
i = j = (id_no*3-3)+2
Ko[i, :] = 0
Ko[:, j] = 0
Ko[i, j] = 1
#print("\nMatriz Ko\n", np.around(Ko, decimals=1))
return Ko
def Q_nodal(self):
"Vetor de cargas nodais equivalentes {Q} no sistema de coordenadas
global"
nos = 0
for no in self.Nos:
nos += 1
self.ordem_Q = 3*nos
Q = np.zeros((self.ordem_Q, 1))
#print("\nNós da Estrutura:\n", self.ordem_Q)

#print("\nMatriz Q: \n",Q)
for no in self.Nos:
id_no = no
fx = self.Nos[id_no]["Q_nodal"]["fx"]+self.Nos[id_no]["Q_eq"]
["fx_eq"]
fy = self.Nos[id_no]["Q_nodal"]["fy"]+self.Nos[id_no]["Q_eq"]
["fy_eq"]
mz = self.Nos[id_no]["Q_nodal"]["mz"]+self.Nos[id_no]["Q_eq"]
["mz_eq"]
if fx != 0:
i = (id_no*3-3)
Q[i, 0] = fx
if fy != 0:
i = (id_no*3-3)+1
Q[i, 0] = fy
if mz != 0:
i = (id_no*3-3)+2
Q[i, 0] = mz
print("\nMatriz Q\n", Q)
return Q
def deslocamentos(self):
"Vetor dos deslocamentos nodais {D} no sistema de coordenadas
global"
K = self.Ko()
Q = self.Q_nodal()
138
D = np.linalg.solve(K, Q)
for no in self.Nos:
id_no = no
i = (id_no*3-3)
if self.Nos[id_no]["Restr."]["u"] == 1:
D[i,0]=0
#dx = np.around(D[i, 0], decimals=9)
dx = D[i,0]
i = (id_no*3-3)+1
if self.Nos[id_no]["Restr."]["v"] == 1:
D[i,0] = 0
#dy = np.around(D[i, 0], decimals=9)
dy = D[i,0]
i = (id_no*3-3)+2
if self.Nos[id_no]["Restr."]["t"] == 1:
D[i, 0] = 0
#rz = np.around(D[i, 0], decimals=9)
rz = D[i,0]
self.db.deslocamentos(id_no, dx, dy, rz)
print("\nVetor de Deslocamentos Nodais (m):\n",np.around(D,

decimals=10))
return D
def reacoes(self):
"Vetor das reações nos apoios {F}"
K = self.K()
D = self.deslocamentos()
F = K.dot(D)
for no in self.Nos:
id_no = no
fx_eq = self.Nos[id_no]["Q_nodal"]["fx"] + self.Nos[id_no]
["Q_eq"]["fx_eq"]
fy_eq = self.Nos[id_no]["Q_nodal"]["fy"] + self.Nos[id_no]
["Q_eq"]["fy_eq"]
fz_eq = self.Nos[id_no]["Q_nodal"]["mz"] + self.Nos[id_no]
["Q_eq"]["mz_eq"]
i = (id_no*3-3)
F[i,0] = F[i,0]-fx_eq
fx = F[i,0]
#fx = np.around(F[i, 0], decimals=2)
i = (id_no*3-3)+1
F[i,0] = F[i,0]-fy_eq
fy = F[i,0]
#fy = np.around(F[i, 0], decimals=2)
i = (id_no*3-3)+2
F[i,0] = F[i,0]-fz_eq
mz = F[i,0]
#mz = np.around(F[i, 0], decimals=2)
#print("fx_eq = ", fx_eq, "fy_eq = ", fy_eq, "fz_eq = ", fz_eq)
#fx = fx - fx_eq
if abs(fx) < 1e-10:
fx = 0
#fy = fy - fy_eq
139
if abs(fy) < 1e-10:
fy = 0
if mz != 0:
mz = mz - fz_eq
"Condicional para zerar as reações nos vínculos restringidos"

if self.Nos[id_no]["Restr."]["u"] == 0:
fx = 0
if self.Nos[id_no]["Restr."]["v"] == 0:
fy = 0
if self.Nos[id_no]["Restr."]["t"] == 0:
mz = 0
self.db.reacoes(id_no, fx, fy, mz)
no_des = self.db.conv_real(id_no)
if no_des % 1 == 0:
self.db.reacoes_des(no_des, fx, fy, mz)
#print("no:",id_no,"fx:",fx,"fy:",fy,"mz:",mz)
print("\nVetor de Forças Nodais (KN):\n",np.around(F, decimals=4))
def esforcos(self):
"Função para cálculo dos esforços internos"
"Vetor dos deslocamentos nodais calculados"

d = np.zeros((6, 1))

id_elem = elem
T = self.T(id_elem)
self.xi = self.Elem[id_elem]["noi"]["x"]
self.yi = self.Elem[id_elem]["noi"]["y"]
self.xf = self.Elem[id_elem]["nof"]["x"]
self.yf = self.Elem[id_elem]["nof"]["y"]
L = m.sqrt(m.pow((self.xf - self.xi), 2) + m.pow((self.yf -
self.yi), 2))
#print("\nElemento:", elem)
#print("Matriz T:\n", T)
A = (self.Elem[elem]["Prop."]["area"]) * 1e-4
I = (self.Elem[elem]["Prop."]["inercia"]) * 1e-8
E = (self.Elem[elem]["Prop."]["elast."]) * 1e3
N = ((A*E)/L)*np.array([[1, -1],
[-1, 1]])
V_M = ((E*I)/m.pow(L,3))*np.array([ [12,6*L,-12,6*L],

[6*L,4*m.pow(L,2),-
6*L,2*m.pow(L,2)],
[-12,-6*L,12,-6*L],
[6*L,2*m.pow(L,2),-
6*L,4*m.pow(L,2)]])
noi = self.Elem[id_elem]["noi"]["id"]
nof = self.Elem[id_elem]["nof"]["id"]
d[0,0] = self.Nos[noi]["Desloc."]["dx"]
140
d[1,0] = self.Nos[noi]["Desloc."]["dy"]
d[2,0] = self.Nos[noi]["Desloc."]["rz"]
d[3,0] = self.Nos[nof]["Desloc."]["dx"]
d[4,0] = self.Nos[nof]["Desloc."]["dy"]
d[5,0] = self.Nos[nof]["Desloc."]["rz"]
d_ = T.dot(d) #__Graus de liberdade no sistema local
d_N = np.array([[d_[0,0],d_[3,0]]]).reshape(2,1)
d_V_M =
np.array([[d_[1,0],d_[2,0],d_[4,0],d_[5,0]]]).reshape(4,1)
Normal = N.dot(d_N)
Fletor = V_M.dot(d_V_M)
"Os índices 1 e 2 indicam respectivamente os nós iniciais e

finais de cada elemento gerado pelo programa"
fx1 = self.Elem[id_elem]["noi"]["Q_eq"]["fx_eq"]
fy1 = self.Elem[id_elem]["noi"]["Q_eq"]["fy_eq"]
mz1 = self.Elem[id_elem]["noi"]["Q_eq"]["mz_eq"]
fx2 = self.Elem[id_elem]["nof"]["Q_eq"]["fx_eq"]
fy2 = self.Elem[id_elem]["nof"]["Q_eq"]["fy_eq"]
mz2 = self.Elem[id_elem]["nof"]["Q_eq"]["mz_eq"]
Normal[0] = fx1 - Normal[0]

Normal[1] = fx2 - Normal[1]
Fletor[0,0] = Fletor[0,0] - fy1

Fletor[2,0] = Fletor[2,0] - fy2
Fletor[1,0] = mz1 - Fletor[1,0]

Fletor[3,0] = mz2 - Fletor[3,0]
if Normal[1, 0] > 0:
tipo = "Tração"
else:
tipo = "Compressão"
self.db.esforcos(noi,Normal[0,0],Fletor[0,0],Fletor[1,0])
self.db.esforcos(nof,Normal[1,0],Fletor[2,0],Fletor[3,0])
self.db.esforcos_elem(elem, Normal[0,0], Fletor[0,0],
Fletor[1,0], Normal[1,0], Fletor[2,0], Fletor[3,0])
Códogo da janela para apresentação dos esforços calculados

import matplotlib.pyplot as plt

import math as m
class J_Res_Esforcos(QDialog):
super(J_Res_Esforcos, self).__init__(parent)
self.db = Dados()
141
self.setWindowTitle("ESFORÇOS INTERNOS ( Normal / Cortante / Fletor
)")
#self.label = QLabel("Resultados - Esforços (Normal / Cortante /

Fletor)", self)
#self.label.setGeometry(QRect(20, 20, 410, 20))
#font = QFont()
#font.setPointSize(10)
#font.setBold(True)
#font.setWeight(75)
#self.label.setFont(font)
#self.label.setAlignment(Qt.AlignCenter)
self.tableWidget.setGeometry(QRect(20, 10, 410, 487))
font = QFont()
self.tableWidget.setFont(font)
#self.tableWidget.setRowCount(20)
item.setText("x (m)")
item.setText("y (m)")
item.setText("N (KN)")
item.setText("V (KN)")
item.setText("M (KN.m)")
for i in range(0):
self.tableWidget.horizontalHeader().setVisible(True)
#__Para inserir o fator de apliação dos diagramas

self.label_Instrucao = QLabel("Selecione um fator\npara ampliação",
self)
self.label_Instrucao.setGeometry(QRect(20, 495, 110, 60))
self.label_Instrucao.setMinimumSize(QSize(110, 60))
self.label_Instrucao.setMaximumSize(QSize(110, 60))
self.label_Instrucao.setAlignment(Qt.AlignCenter)
self.label_Instrucao.setStyleSheet("color: red")
font = QFont()
142
self.label_Instrucao.setFont(font)
self.horizontalSlider = QSlider(self)
self.horizontalSlider.setGeometry(QRect(145, 518.5, 230, 20))
self.horizontalSlider.setMinimumSize(QSize(230, 20))
self.horizontalSlider.setMaximumSize(QSize(230, 20))
self.horizontalSlider.setMaximum(500)
self.horizontalSlider.setSingleStep(1)
self.horizontalSlider.setPageStep(10)
self.horizontalSlider.setProperty("value", 1)
self.horizontalSlider.setSliderPosition(1)
self.horizontalSlider.setOrientation(Qt.Horizontal)
self.label_Fator = QLabel(self)
self.label_Fator.setGeometry(QRect(390, 516, 40, 24))
self.label_Fator.setMinimumSize(QSize(40, 24))
self.label_Fator.setMaximumSize(QSize(40, 24))
self.label_Fator.setFrameShape(QFrame.Box)
self.label_Fator.setFrameShadow(QFrame.Sunken)
self.label_Fator.setAlignment(Qt.AlignCenter)
self.horizontalSlider.connect(self.horizontalSlider,
SIGNAL(("valueChanged(int)")), self.label_Fator.setNum)
self.label_Fator.setText("1")
self.bt_Normal = QPushButton("Diag. Normal", self)

self.bt_Normal.setGeometry(QRect(85, 550, 85, 25))
self.bt_Normal.setFocusPolicy(Qt.NoFocus)
self.bt_Normal.clicked.connect(self.des_normal)
self.bt_Cortante = QPushButton("Diag. Cortante", self)

self.bt_Cortante.setGeometry(QRect(175, 550, 85, 25))
self.bt_Cortante.setFocusPolicy(Qt.NoFocus)
self.bt_Cortante.clicked.connect(self.des_cortante)
self.bt_Fletor = QPushButton("Diag. M. Fletor", self)

self.bt_Fletor.setGeometry(QRect(265, 550, 85, 25))
self.bt_Fletor.setFocusPolicy(Qt.NoFocus)
self.bt_Fletor.clicked.connect(self.des_fletor)
self.bt_Fechar = QPushButton("Fechar", self)

self.bt_Fechar.setGeometry(QRect(355, 550, 75, 25))
self.bt_Fechar.setFocusPolicy(Qt.NoFocus)
self.bt_Fechar.clicked.connect(self.fechar)
self.inserir_resultados()
def inserir_resultados(self):
"Função para extrair resultados do dicionário Elementos e inserir
na tabela"
# __Listas de apoio para inserção de dados
L_elem = []
coord_x = []
coord_y = []
L_N = []
L_V = []
L_M = []
Elem = list(self.Elem.keys())
Elem.sort()
143
for elem in Elem:
id_elem = int(elem)
elem_usuario = int(self.db.conv_real(elem))
xi = self.Elem[id_elem]["noi"]["x"]
yi = self.Elem[id_elem]["noi"]["y"]
xf = self.Elem[id_elem]["nof"]["x"]
yf = self.Elem[id_elem]["nof"]["y"]
L = m.sqrt(m.pow((xf - xi), 2) + m.pow((yf - yi), 2))
Lamb_x = ((xf - xi) / L)
Lamb_y = ((yf - yi) / L)
if Lamb_x > 0:
x = xi
y = yi
N = self.Elem[id_elem]["noi"]["Esforcos"]["N"]
V = self.Elem[id_elem]["noi"]["Esforcos"]["V"]
M = self.Elem[id_elem]["noi"]["Esforcos"]["M"]
if abs(M) < 1e-10:
M = 0
if id_elem % self.n == 0:
x = xf
y = yf
N = - self.Elem[id_elem]["nof"]["Esforcos"]["N"]
V = - self.Elem[id_elem]["nof"]["Esforcos"]["V"]
M = - self.Elem[id_elem]["nof"]["Esforcos"]["M"]
if abs(M) < 1e-10:
M = 0
elif Lamb_x < 0:

x = xi
y = yi
M = - self.Elem[id_elem]["noi"]["Esforcos"]["M"]
if abs(M) < 1e-10:
M = 0
x = xf
y = yf
M = self.Elem[id_elem]["nof"]["Esforcos"]["M"]
if abs(M) < 1e-10:
M = 0
elif Lamb_x == 0 and Lamb_y > 0:

x = xi
y = yi
M = self.Elem[id_elem]["noi"]["Esforcos"]["M"]
if abs(M) < 1e-10:
M = 0
x = xf
y = yf
M = - self.Elem[id_elem]["nof"]["Esforcos"]["M"]
if abs(M) < 1e-10:
M = 0
144
elif Lamb_x == 0 and Lamb_y < 0:
x = xi
y = yi
M = - self.Elem[id_elem]["noi"]["Esforcos"]["M"]
if abs(M) < 1e-10:
M = 0
x = xf
y = yf
M = self.Elem[id_elem]["nof"]["Esforcos"]["M"]
if abs(M) < 1e-10:
M = 0
L_elem.append(elem_usuario)
coord_x.append(x)
coord_y.append(y)
L_N.append(N)
L_V.append(V)
L_M.append(M)
for i, j in enumerate(L_elem):
# __Laço para inserir os dados na tabela
item.setText(str(L_elem[i]))
self.tableWidget.setItem(i, 0, item)
Qt.AlignCenter)
item.setFlags(Qt.ItemIsEnabled) # __Para desabilitar a ediçao
dos campos da coluna 0 da tabela
item.setText(str(coord_x[i]))
Qt.AlignCenter)
item.setText(str(coord_y[i]))
Qt.AlignCenter)
item.setText(str("%.2f" % (L_N[i])))
Qt.AlignCenter)
145
item.setText(str("%.2f" % (L_V[i])))
Qt.AlignCenter)
item.setText(str("%.2f" % (L_M[i])))
Qt.AlignCenter)
def des_normal(self):
"Funçao para desenhar a estrutura deslocada"
fator = int(self.label_Fator.text())
Nos.sort()
for no in Nos:
#__Desenha os NÓS da estrutura
x = self.Nos[no]["x"]
y = self.Nos[no]["y"]
plt.scatter(x, y, color="red", s=1)
Elem.sort()
for elem in Elem:
#__Desenha os ELEMENTOS da estrutura
xi = self.Elem[elem]["noi"]["x"]
xf = self.Elem[elem]["nof"]["x"]
yi = self.Elem[elem]["noi"]["y"]
yf = self.Elem[elem]["nof"]["y"]
plt.plot([xi, xf], [yi, yf], color="black", linewidth=1)
Ni = self.Elem[elem]["noi"]["Esforcos"]["N"] / fator
Nf = - self.Elem[elem]["nof"]["Esforcos"]["N"] / fator
print(Ni*fator,Nf*fator)

Lamb_x = abs((xf-xi)/L)
Lamb_y = abs((yf-yi)/L)
delta_xi = 0
delta_xf = 0
delta_yi = 0
delta_yf = 0
#__Para elemento na posição vertical

if Lamb_x == 0:
if Ni < 0:
delta_xi = - Ni
elif Ni > 0:
delta_xi = - Ni
if Nf < 0:
delta_xf = - Nf
elif Nf > 0:
146
delta_xf = - Nf
#__Para elemento na posição horizontal

elif Lamb_y == 0:
if Ni < 0:
delta_yi = + Ni
elif Ni > 0:
delta_yi = + Ni
if Nf < 0:
delta_yf = + Nf
elif Nf > 0:
delta_yf = + Nf
#__Para elemento inclinado

elif Lamb_x != 0 and Lamb_y != 0:
if Ni < 0:
delta_xi = - Ni*Lamb_x
delta_yi = + Ni*Lamb_y
elif Ni > 0:
delta_xi = - Ni*Lamb_x
delta_yi = + Ni*Lamb_y
if Nf < 0:
delta_xf = - Nf*Lamb_x
delta_yf = + Nf*Lamb_y
elif Nf > 0:
delta_xf = - Nf*Lamb_x
delta_yf = + Nf*Lamb_y
Nx_i = xi + delta_xi
Nx_f = xf + delta_xf
Ny_i = yi + delta_yi
Ny_f = yf + delta_yf
"Plotando os diagramas"
if Lamb_x == 0:
plt.plot([Nx_i, Nx_f], [Ny_i, Ny_f], color="blue",
linewidth=0.7)
plt.plot([xi, Nx_i], [yi, Ny_i], color="blue",
linewidth=0.7)
plt.plot([xf, Nx_f], [yf, Ny_f], color="blue",
linewidth=0.7)
elif Lamb_y == 0:
plt.plot([Nx_i, Nx_f], [Ny_i, Ny_f], color="red",
linewidth=0.7)
plt.plot([xi, Nx_i], [yi, Ny_i], color="red",
linewidth=0.7)
plt.plot([xf, Nx_f], [yf, Ny_f], color="red",
linewidth=0.7)
plt.plot([Nx_i, Nx_f], [Ny_i, Ny_f], color="green",
linewidth=0.7)
plt.plot([xi, Nx_i], [yi, Ny_i], color="green",
linewidth=0.7)
plt.plot([xf, Nx_f], [yf, Ny_f], color="green",
linewidth=0.7)
"Plotando os valores dos esforços normais"

if elem % self.n != 0:
x = Nx_i
y = Ny_i
N = Ni * fator
147
plt.text(x,y,"%.2f" %(N), rotation="0",
horizontalalignment="left", verticalalignment="center")
else:
xi = Nx_i
yi = Ny_i
Ni = Ni * fator
plt.text(xi, yi, "%.2f" % (Ni), rotation="0",
horizontalalignment="left",
verticalalignment="center")
xf = Nx_f
yf = Ny_f
Nf = Nf * fator
plt.text(xf, yf, "%.2f" % (Nf), rotation="0",
'''Para desenhar somente os nós inseridos pelo usuário'''

# no_usuario = self.db.conv_real(no)
# if no_usuario % 1 == 0:
# x = self.Nos[no]["x"]
# y = self.Nos[no]["y"]
# plt.scatter(x, y, color="red", s=6)
plt.title("Diagrama de Esforços Normais (%d KN:m)" % fator)

plt.xlabel("Eixo X (m) - Global")
plt.ylabel("Eixo Y (m) - Global")
plt.grid()
plt.show()
def des_cortante(self):
Nos.sort()
for no in Nos:
Elem.sort()
for elem in Elem:
Vi = self.Elem[elem]["noi"]["Esforcos"]["V"] / fator
Vf = - self.Elem[elem]["nof"]["Esforcos"]["V"] / fator

Lamb_x = abs((xf-xi)/L)
Lamb_y = abs((yf-yi)/L)
delta_xi = 0
delta_xf = 0
delta_yi = 0
delta_yf = 0
148
if Lamb_x == 0:
if Vi < 0:
delta_xi = - Vi
elif Vi > 0:
delta_xi = - Vi
if Vf < 0:
delta_xf = - Vf
elif Vf > 0:
delta_xf = - Vf

elif Lamb_y == 0:
if Vi < 0:
delta_yi = + Vi
elif Vi > 0:
delta_yi = + Vi
if Vf < 0:
delta_yf = + Vf
elif Vf > 0:
delta_yf = + Vf

if Vi < 0:
delta_xi = - Vi*Lamb_x
delta_yi = + Vi*Lamb_y
elif Vi > 0:
delta_xi = - Vi*Lamb_x
delta_yi = + Vi*Lamb_y
if Vf < 0:
delta_xf = - Vf*Lamb_x
delta_yf = + Vf*Lamb_y
elif Vf > 0:
delta_xf = - Vf*Lamb_x
delta_yf = + Vf*Lamb_y
Vx_i = xi + delta_xi
Vx_f = xf + delta_xf
Vy_i = yi + delta_yi
Vy_f = yf + delta_yf
if Lamb_x == 0:
plt.plot([Vx_i, Vx_f], [Vy_i, Vy_f], color="blue",
linewidth=0.7)
plt.plot([xi, Vx_i], [yi, Vy_i], color="blue",
linewidth=0.7)
plt.plot([xf, Vx_f], [yf, Vy_f], color="blue",
linewidth=0.7)
elif Lamb_y == 0:
plt.plot([Vx_i, Vx_f], [Vy_i, Vy_f], color="red",
linewidth=0.7)
plt.plot([xi, Vx_i], [yi, Vy_i], color="red",
linewidth=0.7)
plt.plot([xf, Vx_f], [yf, Vy_f], color="red",
linewidth=0.7)
plt.plot([Vx_i, Vx_f], [Vy_i, Vy_f], color="green",
linewidth=0.7)
149
plt.plot([xi, Vx_i], [yi, Vy_i], color="green",
linewidth=0.7)
plt.plot([xf, Vx_f], [yf, Vy_f], color="green",
linewidth=0.7)
"Plotando os valores dos esforços cortantes"

x = Vx_i
y = Vy_i
V = Vi * fator
plt.text(x, y, "%.2f" % (V), rotation="0",
else:
xi = Vx_i
yi = Vy_i
Vi = Vi * fator
plt.text(xi, yi, "%.2f" % (Vi), rotation="0",
xf = Vx_f
yf = Vy_f
Vf = Vf * fator
plt.text(xf, yf, "%.2f" % (Vf), rotation="0",

plt.title("Diagrama de Esforços Cortantes (%d KN:m)" % fator)

plt.grid()
plt.show()
def des_fletor(self):
Nos.sort()
for no in Nos:
Elem.sort()
for elem in Elem:
150
Mi = self.Elem[elem]["noi"]["Esforcos"]["M"] / fator
Mf = - self.Elem[elem]["nof"]["Esforcos"]["M"] / fator
#print(Mi,Mf)

Lamb_x = (xf-xi)/L
Lamb_y = (yf-yi)/L
delta_xi = 0
delta_xf = 0
delta_yi = 0
delta_yf = 0

if Lamb_x == 0:
if Mi < 0:
delta_xi = + Mi*Lamb_y
elif Mi > 0:
delta_xi = + Mi*Lamb_y
if Mf < 0:
delta_xf = + Mf*Lamb_y
elif Mf > 0:
delta_xf = + Mf*Lamb_y

elif Lamb_y == 0:
if Mi < 0:
delta_yi = - Mi*Lamb_x
elif Mi > 0:
delta_yi = - Mi*Lamb_x
if Mf < 0:
delta_yf = - Mf*Lamb_x
elif Mf > 0:
delta_yf = - Mf*Lamb_x

if Mi < 0:
delta_xi = + Mi*Lamb_x
delta_yi = - Mi*Lamb_y
elif Mi > 0:
delta_xi = + Mi*Lamb_x
delta_yi = - Mi*Lamb_y
if Mf < 0:
delta_xf = + Mf*Lamb_x
delta_yf = - Mf*Lamb_y
elif Mf > 0:
delta_xf = + Mf*Lamb_x
delta_yf = - Mf*Lamb_y
Mx_i = xi + delta_xi
Mx_f = xf + delta_xf
My_i = yi + delta_yi
My_f = yf + delta_yf
if Lamb_x == 0:
plt.plot([Mx_i, Mx_f], [My_i, My_f], color="blue",
linewidth=0.7)
plt.plot([xi, Mx_i], [yi, My_i], color="blue",
linewidth=0.7)
151
plt.plot([xf, Mx_f], [yf, My_f], color="blue",
linewidth=0.7)
elif Lamb_y == 0:
plt.plot([Mx_i, Mx_f], [My_i, My_f], color="red",
linewidth=0.7)
plt.plot([xi, Mx_i], [yi, My_i], color="red",
linewidth=0.7)
plt.plot([xf, Mx_f], [yf, My_f], color="red",
linewidth=0.7)
plt.plot([Mx_i, Mx_f], [My_i, My_f], color="green",
linewidth=0.7)
plt.plot([xi, Mx_i], [yi, My_i], color="green",
linewidth=0.7)
plt.plot([xf, Mx_f], [yf, My_f], color="green",
linewidth=0.7)
"Plotando os valores dos momentos fletores"

x = Mx_i
y = My_i
M = Mi * fator
plt.text(x, y, "%.2f" % (M), rotation="0",
else:
xi = Mx_i
yi = My_i
Mi = Mi * fator
plt.text(xi, yi, "%.2f" % (Mi), rotation="0",
xf = Mx_f
yf = My_f
Mf = Mf * fator
plt.text(xf, yf, "%.2f" % (Mf), rotation="0",

plt.title("Diagrama de Momentos Fletores (%d KN:m)" % fator)

plt.grid()
plt.show()
def fechar(self):
self.close()
self.destroy()
if __name__ == '__main__':
import sys
app = J_Res_Esforcos()
152
app.show()
root.exec_()
Códogo da janela para apresentação dos deslocamentos calculados

import matplotlib.pyplot as plt
class J_Res_Desloc(QDialog):
super(J_Res_Desloc, self).__init__(parent)
self.db = Dados()
self.setWindowTitle("DESLOCAMENTOS DA ESTRUTURA")
#self.label_Resultados = QLabel("Resultados - Deslocamentos", self)

#self.label_Resultados.setGeometry(QRect(20, 20, 560, 15))
#font = QFont()
#font.setPointSize(10)
#font.setBold(True)
#font.setWeight(75)
#self.label_Resultados.setFont(font)
#self.label_Resultados.setAlignment(Qt.AlignCenter)
self.tableWidget.setGeometry(QRect(20, 10, 560, 487))
font = QFont()
self.tableWidget.setFont(font)
item.setText("x (m)")
item.setText("y (m)")
item.setText("dx (m)")
item.setText("dy (m)")
item.setText("rot. z (rad)")
153
for i in range(0):
self.horizontalSlider = QSlider(self)
self.horizontalSlider.setGeometry(QRect(130, 518.5, 200, 20))
self.horizontalSlider.setMinimumSize(QSize(200, 20))
self.horizontalSlider.setMaximumSize(QSize(200, 20))
self.horizontalSlider.setMaximum(300)
self.horizontalSlider.setSingleStep(1)
self.horizontalSlider.setPageStep(10)
self.horizontalSlider.setProperty("value", 1)
self.horizontalSlider.setSliderPosition(1)
self.horizontalSlider.setOrientation(Qt.Horizontal)
self.label_Instrucao = QLabel("Selecione um fator\npara ampliação\n

dos deslocamentos", self)
self.label_Instrucao.setGeometry(QRect(15, 495, 110, 60))
self.label_Instrucao.setMinimumSize(QSize(110, 60))
self.label_Instrucao.setMaximumSize(QSize(110, 60))
self.label_Instrucao.setAlignment(Qt.AlignCenter)
self.label_Instrucao.setStyleSheet("color: red")
font = QFont()
self.label_Instrucao.setFont(font)
self.label_Fator = QLabel(self)
self.label_Fator.setGeometry(QRect(340, 516, 40, 24))
self.label_Fator.setMinimumSize(QSize(40, 24))
self.label_Fator.setMaximumSize(QSize(40, 24))
self.label_Fator.setFrameShape(QFrame.Box)
self.label_Fator.setFrameShadow(QFrame.Sunken)
self.label_Fator.setAlignment(Qt.AlignCenter)
self.horizontalSlider.connect(self.horizontalSlider,
SIGNAL(("valueChanged(int)")), self.label_Fator.setNum)
self.label_Fator.setText("1")
self.bt_Diagrama = QPushButton("Diag. Deslocamentos", self)

self.bt_Diagrama.setGeometry(QRect(385, 515, 115, 25))
self.bt_Diagrama.setFocusPolicy(Qt.NoFocus)
self.bt_Diagrama.clicked.connect(self.des_deslocamentos)
self.bt_Fechar = QPushButton("Fechar", self)

self.bt_Fechar.setGeometry(QRect(505, 515, 75, 25))
self.bt_Fechar.setFocusPolicy(Qt.NoFocus)
self.bt_Fechar.clicked.connect(self.fechar)
self.inserir_resultados()
def inserir_resultados(self):
"Função para extrair resultados do dicionário Nós e inserir na
tabela"
#__Listas de apoio para inserção de dados
L_elem = []
coord_x = []
coord_y = []
154
L_dx = []
L_dy = []
L_rz = []
Elem.sort()
for elem in Elem:
id_elem = int(elem)
elem_usuario = int(self.db.conv_real(elem))
noi = self.Elem[id_elem]["noi"]["id"]
nof = self.Elem[id_elem]["nof"]["id"]
x = self.Nos[noi]["x"]
y = self.Nos[noi]["y"]
dx = self.Nos[noi]["Desloc."]["dx"]
dy = self.Nos[noi]["Desloc."]["dy"]
rz = self.Nos[noi]["Desloc."]["rz"]
coord_x.append(x)
coord_y.append(y)
L_dx.append(dx)
L_dy.append(dy)
L_rz.append(rz)
x = self.Nos[nof]["x"]
y = self.Nos[nof]["y"]
dx = self.Nos[nof]["Desloc."]["dx"]
dy = self.Nos[nof]["Desloc."]["dy"]
rz = self.Nos[nof]["Desloc."]["rz"]
coord_x.append(x)
coord_y.append(y)
L_dx.append(dx)
L_dy.append(dy)
L_rz.append(rz)
for i,j in enumerate(L_elem):

#__Laço para inserir os dados na tabela
item.setText(str(L_elem[i]))
Qt.AlignCenter)
item.setFlags(Qt.ItemIsEnabled) #__Para desabilitar a ediçao
item.setText(str(coord_x[i]))
Qt.AlignCenter)
item.setText(str(coord_y[i]))
Qt.AlignCenter)
155
item.setText(str("%.5e" %(L_dx[i])))
Qt.AlignCenter)
item.setText(str("%.5e" %(L_dy[i])))
Qt.AlignCenter)
item.setText(str("%.5e" %(L_rz[i])))
Qt.AlignCenter)
def des_deslocamentos(self):
fator_desloc = int(self.label_Fator.text())
Nos.sort()
for no in Nos:
Elem.sort()
for elem in Elem:
noi = self.Elem[elem]["noi"]["id"]
nof = self.Elem[elem]["nof"]["id"]
#__Desenha os DESLOCAMENTOS da estrutura

dx_i = (fator_desloc * self.Nos[noi]["Desloc."]["dx"]) + xi
dx_f = (fator_desloc * self.Nos[nof]["Desloc."]["dx"]) + xf
dy_i = (fator_desloc * self.Nos[noi]["Desloc."]["dy"]) + yi
dy_f = (fator_desloc * self.Nos[nof]["Desloc."]["dy"]) + yf
plt.plot([dx_i, dx_f], [dy_i, dy_f], color="red",
linewidth=0.7)
156
#no_usuario = self.db.conv_real(no)
#if no_usuario % 1 == 0:
plt.title("Deslocamentos da Estrutura (fat. desloc. %dx)"

%fator_desloc)
plt.xlabel("Eixo X - Global")
plt.ylabel("Eixo Y - Global")
'''Para plotar legenda'''

#plt.plot ([], [], label="Est.", color="gray", linewidth=1.5)
#plt.plot ([], [], label="Deslc.", color="red", linewidth=1.5)
#plt.scatter([], [], label="Pnts.", color="red", s=5)
#plt.legend()
plt.grid()
plt.show()
def fechar(self):
self.close()
self.destroy()
if __name__ == '__main__':
import sys
app = J_Res_Desloc()
app.show()
root.exec_()
Código da janela para dimensionamento das armaduras longitudinais

import math
import numpy as np
class J_Dimensionamento(QDialog):
super(J_Dimensionamento, self).__init__(parent)
self.setWindowTitle("DIMENSIONAMENTO")
icon = QIcon()
icon.addPixmap(QPixmap("examples/painting/basicdrawing/images/qt-
logo.png"), QIcon.Normal, QIcon.On)
self.setWindowIcon(icon)
self.label_1 = QLabel("Proriedades dos Materiais:", self)

font = QFont(self)
font.setBold(True)
font.setWeight(100)
157
self.label_2 = QLabel("Coeficientes de ponderação das resistências
- ELU:", self)
self.label_2.setAlignment(Qt.AlignRight | Qt.AlignTrailing |
Qt.AlignVCenter)
self.label_3 = QLabel("Classe de Agressividade Ambiental (CAA):",
self)
Qt.AlignVCenter)
self.label_4 = QLabel("Dimensão do agregado - DMC (mm):", self)
Qt.AlignVCenter)
self.label_5 = QLabel("Tipo do agregado graúdo:", self)
Qt.AlignVCenter)
self.label_6 = QLabel("Classe do Aço:", self)
Qt.AlignVCenter)
self.label_7 = QLabel("Resistência do concreto - Fck (MPa):", self)
Qt.AlignVCenter)
self.label_8 = QLabel("Propriedades da seção transversal (m):",
self)
self.label_9 = QLabel("Geometria da seção transversall:", self)
font = QFont()
font.setBold(True)
font.setWeight(50)
self.label_10 = QLabel("h (cm):", self)
Qt.AlignVCenter)
self.label_11 = QLabel("bw (cm):", self)
Qt.AlignVCenter)
self.label_12 = QLabel("cnom (cm):", self)
Qt.AlignVCenter)
self.label_13 = QLabel("Momento Fletor Solicitante - Msd (KN.m):",
self)
font = QFont()
font.setBold(True)
font.setWeight(75)
self.label_Fck = QLabel(self)
self.label_Fck.setGeometry(QRect(425, 235, 150, 20))
self.label_Cnom = QLabel(self)
self.label_Cnom.setGeometry(QRect(180, 420, 150, 20))
158
self.line_h = QLineEdit(self)
self.line_h.setGeometry(QRect(110, 360, 60, 20))
self.line_h.setAlignment(Qt.AlignCenter)
self.line_bw = QLineEdit(self)
self.line_bw.setGeometry(QRect(110, 390, 60, 20))
self.line_bw.setAlignment(Qt.AlignCenter)
self.line_Cnom = QLineEdit(self)
self.line_Cnom.setGeometry(QRect(110, 420, 60, 20))
self.line_Cnom.setAlignment(Qt.AlignCenter)
self.line_Msd = QLineEdit(self)
self.line_Msd.setGeometry(QRect(280, 460, 60, 20))
self.line_Msd.setAlignment(Qt.AlignCenter)
self.combobox_Combinacoes = QComboBox(self)
self.combobox_Combinacoes.setGeometry(QRect(290, 60, 125, 22))
self.combobox_Combinacoes.addItem("")
self.combobox_Combinacoes.setItemText(0, "Selecione...")
self.combobox_Combinacoes.setItemText(1, "Normal")
self.combobox_Combinacoes.setItemText(2, "Especiais/Construção")
self.combobox_Combinacoes.setItemText(3, "Excepcionais")
self.comboBox_CAA = QComboBox(self)
self.comboBox_CAA.setEnabled(True)
self.comboBox_CAA.setGeometry(QRect(290, 95, 125, 22))
self.comboBox_CAA.setMouseTracking(False)
self.comboBox_CAA.setLayoutDirection(Qt.LeftToRight)
self.comboBox_CAA.setAutoFillBackground(False)
self.comboBox_CAA.addItem("")
self.comboBox_CAA.setItemText(0, "Selecione...")
self.comboBox_CAA.setItemText(1, "I - Fraca")
self.comboBox_CAA.setItemText(2, "II - Moderada")
self.comboBox_CAA.setItemText(3, "III - Forte")
self.comboBox_CAA.setItemText(4, "IV - Muito Forte")
self.combobox_DMC = QComboBox(self)
self.combobox_DMC.setGeometry(QRect(290, 130, 125, 22))
self.combobox_DMC.addItem("")
self.combobox_DMC.setItemText(0, "Selecione...")
self.combobox_DMC.setItemText(1, "6.3")
self.combobox_DMC.setItemText(4, "19")
159
self.combobox_Agregado = QComboBox(self)
self.combobox_Agregado.setGeometry(QRect(290, 165, 125, 22))
self.combobox_Agregado.addItem("")
self.combobox_Agregado.setItemText(0, "Selecione...")
self.combobox_Agregado.setItemText(1, "Basalto ou Diabásio")
self.combobox_Agregado.setItemText(2, "Granito ou Gnaise")
self.combobox_Agregado.setItemText(3, "Calcário")
self.combobox_Agregado.setItemText(4, "Arenito")
self.combobox_ClasseAco = QComboBox(self)
self.combobox_ClasseAco.setGeometry(QRect(290, 200, 125, 22))
self.combobox_ClasseAco.addItem("")
self.combobox_ClasseAco.setItemText(0, "Selecione...")
self.combobox_ClasseAco.setItemText(1, "CA-50")
self.combobox_ClasseAco.setItemText(2, "CA-60")
self.combobox_Fck = QComboBox(self)
self.combobox_Fck.setGeometry(QRect(290, 235, 125, 20))
self.combobox_Fck.addItem("")
self.combobox_Fck.setItemText(0, "Selecione...")
self.combobox_Fck.setItemText(1, "20")
self.radioButton_1 = QRadioButton("Retangular", self)

self.radioButton_1.setGeometry(QRect(40, 330, 75, 20))
self.radioButton_1.setFocusPolicy(Qt.NoFocus)
160
self.radioButton_1.setVisible(False)
self.radioButton_2 = QRadioButton("Seção T", self)
self.radioButton_3 = QRadioButton("Seção I-1", self)
self.radioButton_4 = QRadioButton("Seção I_2", self)
self.bt_Dimensionar = QPushButton("Dimensionar",self)
self.bt_Dimensionar.setGeometry(QRect(40, 510, 130, 25))
self.bt_Dimensionar.setShortcut("Enter")
self.bt_Dimensionar.setFocusPolicy(Qt.NoFocus)
self.bt_Limpar = QPushButton("Limpar",self)
self.bt_Limpar.setGeometry(QRect(190, 510, 80, 25))
self.bt_Limpar.setFocusPolicy(Qt.NoFocus)
self.list_Dimensionamento = QListWidget(self)
self.list_Dimensionamento.setEnabled(True)
self.list_Dimensionamento.setGeometry(QRect(640, 20, 511, 741))
font = QFont()
font.setBold(False)
font.setItalic(False)
font.setWeight(50)
font.setKerning(True)
font.setStyleStrategy(QFont.PreferAntialias)
self.list_Dimensionamento.setFont(font)
self.list_Dimensionamento.setMouseTracking(False)
self.list_Dimensionamento.setFocusPolicy(Qt.NoFocus)
self.list_Dimensionamento.setAutoFillBackground(False)
self.list_Dimensionamento.setFrameShape(QFrame.NoFrame)
self.list_Dimensionamento.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.list_Dimensionamento.setProperty("showDropIndicator", False)
self.list_Dimensionamento.setSelectionMode(QAbstractItemView.NoSelection)
self.list_Dimensionamento.setViewMode(QListView.ListMode)
self.combobox_Combinacoes.setFocus(True)
self.setTabOrder(self.combobox_Combinacoes, self.comboBox_CAA)
self.setTabOrder(self.comboBox_CAA, self.combobox_DMC)
self.setTabOrder(self.combobox_DMC, self.combobox_Agregado)
self.setTabOrder(self.combobox_Agregado, self.combobox_ClasseAco)
self.setTabOrder(self.combobox_ClasseAco, self.combobox_Fck)
self.setTabOrder(self.combobox_Fck, self.line_h)
self.setTabOrder(self.line_h, self.line_bw)
self.setTabOrder(self.line_bw, self.line_Cnom)
self.setTabOrder(self.line_Cnom, self.line_Msd)
self.setTabOrder(self.line_Msd, self.bt_Dimensionar)
self.setTabOrder(self.bt_Dimensionar, self.bt_Limpar)
self.list_Dimensionamento.setSortingEnabled(False)
# Conectando Sinais
161
self.comboBox_CAA.currentIndexChanged.connect(self.FckNorma)
#self.combobox_Agregado.currentIndexChanged.connect(self.Agregado)
self.bt_Dimensionar.clicked.connect(self.Limpar)
self.bt_Limpar.clicked.connect(self.Limpar)
self.bt_Dimensionar.clicked.connect(self.Dimensionar)
#self.combobox_DMC.currentIndexChanged.connect(self.DMC)
###########################################################################
#############################################
#######################################_____FUNÇÕES VINCULADAS AOS
MATERIAIS_____#######################################
###########################################################################
#############################################
# Definindo a função FckNorma e inserindo os valores nas LineEdit

def FckNorma(self):
if self.comboBox_CAA.currentText() == "I - Fraca":

self.label_Fck.setText("Fck >= 20 Mpa - NBR 6118")
self.label_Cnom.setText("Cnom >= 2.5 cm - NBR 6118")
if self.comboBox_CAA.currentText() == "II - Moderada":
if self.comboBox_CAA.currentText() == "III - Forte":
if self.comboBox_CAA.currentText() == "IV - Muito Forte":
if self.comboBox_CAA.currentText() == "Selecione...":
self.label_Fck.clear()
self.label_Cnom.clear()
###########################################################################
#############################################
##################################_____DIMENSIONAMENTO - ARMADURAS
LONGITUDINAIS_____###################################
###########################################################################
#############################################
def Limpar(self):
self.list_Dimensionamento.clear()
def Dimensionar(self):
#__Unidades utilizadas
#__global CAA #__Classe de Agressividade Ambiental
#__global fck #__(MPa)
#__global p_espec_conc #__(KN/m^3)
#__global agregado
#__global aE #__Parâmetro em função do tipo de agregado
- Influencia no módulo de elasticidade "E"
#__global DMC #__(mm)
#__global aco
#__global fyk #__(MPa)
#__global comb_ELU
#__global h #__(cm)
#__global bw #__(cm)
#__global cnom #__(cm)
162
CAA = self.comboBox_CAA.currentText()
fck = float(self.combobox_Fck.currentText())
p_espec_conc = 2500 #__(KN/m^3) - Peso específico do concreto
cnom = float(self.line_Cnom.text())
agregado = self.combobox_Agregado.currentText()
if self.combobox_Agregado.currentText() == "Basalto ou Diabásio":

aE = 1.2
if self.combobox_Agregado.currentText() == "Granito ou Gnaise":
aE = 1.0
if self.combobox_Agregado.currentText() == "Calcário":
aE = 0.9
if self.combobox_Agregado.currentText() == "Arenito":
aE = 0.7
DMC = float(self.combobox_DMC.currentText())
aco = self.combobox_ClasseAco.currentText()
if self.combobox_ClasseAco.currentText() == "CA-50":
fyk = 500
if self.combobox_ClasseAco.currentText() == "CA-60":
fyk = 600
comb_ELU = self.combobox_Combinacoes.currentText()
h = float(self.line_h.text())
bw = float(self.line_bw.text())
# Coeficientes de ponderação das resistências (yc e ys) no estado

limite último - ELU - Itens 12.3.3 e 12.4.1 NBR 6118
#global yc
#global ys
if self.combobox_Combinacoes.currentText() == "Normal":
yc = 1.4
ys = 1.15
if self.combobox_Combinacoes.currentText() ==
"Especiais/Construção":
yc = 1.2
ys = 1.15
if self.combobox_Combinacoes.currentText() == "Excepcionais":
yc = 1.2
ys = 1.00
# Propriedades e variáveis relacionadas às classes do concreto e do aço
#__fctm #__(MPa) - Resistência característica à

compressão do concreoto - Média
#__fctk_inf #__(MPa) - Resistência característica à
compressão do concreoto - Inferior
#__fctk_sup #__(MPa) - Resistência característica à
compressão do concreoto - Superior
#__ai #__________Parâmetro para a determinação do
módulo de elasticidade secante "Ecs"
#__Eci #__(MPa) - Módulo de elasticidade inicial do
concreto
#__Ecs #__(MPa) - Módulo de elasticidade secante do
concreto
#__lamb #__________Parâmetro de redução da altura da
linha neutra - Parábola retângulo
#__ac #__________Parâmetro de redução da resistência
do concreto na compressão
163
#__fcd #__(MPa) - Resistência a compressão do concreto
- Valor de projeto
#__sigma_c #__(MPa) - Tensão de compressão no concreto
#__Es #__(MPa) - Módulo de Elasticidade do aço
#__fyd #__(MPa) - Resistência à tração do aço - Valor
de Prajeto
ai = 0.8+0.2*(fck/80)
if fck <= 50:

fctm = 0.3*math.pow(fck,2/3)
fctk_inf = 0.7*fctm
fctk_sup = 1.3*fctm
Eci = aE*5600*math.sqrt(fck)
lamb = 0.8
ac = 0.85
if 50 < fck <= 90:
fctm = 2.12*math.log(1+11*fck)
fctk_inf = 0.7*fctm
fctk_sup = 1.3*fctm
Eci = 21500*aE*(math.pow(((fck/10)+1.25), 1/3))
lamb = 0.8-((fck-50)/400)
ac = 0.85*(1-(fck-50)/200)
Ecs = ai*Eci
fcd = fck/yc
sigma_c = ac*fcd
Es = 210000
fyd = fyk/ys
# Propriedades da seção transversal - Retangular

#__Unidades de Entrada
#__Ac #__(cm^2) - Área bruta de concreto
#__yCG #__( cm ) - Centro de gravidade da seção
transversal
#__I #__(cm^4) - Momento de inércia da seção
transversal
#__d #__( cm ) - Distância entre o ponto mais
comprimido e a barra mais tracionada
#__d_ #__( cm ) - Distância entre o ponto mais
comprimido e a barra mais comprimida
#__x #__( cm ) - Altura da linha neutra com relação
ao ponto mais comprimido
#__y #__( cm ) - Altura considarada pela
simplificação do diagrama parábola retângulo com relação ao ponto mais
comprimido
#__z #__( cm ) - Distância entre as cargas atuantes
na seção tranversal (tração e compressão)
#__Fi_ti #__( mm ) - Diâmetro inicial da armadura
transversal
#__Fi_li #__( mm ) - Diâmetro inicial da armadura
longitudinal
Ac = bw*h
As_max = 0.04*Ac #__Armadura máxima (cm^2)
As_min = 0.0015*Ac #__Armadura mínima (cm^2)
yCG = h/2
I = (bw*math.pow(h,3))/12
#__Diâmetros iniciais das barras
Fi_ti = 5.0
164
Fi_li = 8.0
d = h-cnom-(Fi_ti*1e-1)-((Fi_li*1e-1)/2)
d_ = cnom+(Fi_ti*1e-1)+(Fi_li*1e-1)/2
# Relação x/d Para domínio 3 - Conforme Item 14.6.4.3 da NBR 6118
''''Fazer cálculo de verificação do valor de x e verificar em que

domínio se encontra'''
if fck <= 50:

x = 0.45 * d
if 50 < fck <= 90:
x = 0.35 * d
y = lamb*x
z = (d-y/2) # Distância entre os pontos de aplicação das cargas Fc
e Fs (Braço de momento na seção)
# Cálculo do Momento Resistente da Seção - Mrd

#global Ac_comp #__(cm^2)
#global Fc #__(KN)
#global Mrd #__(KN.m)
#global Mrd_1 #__(KN.m)
#global Mrd_2 #__(KN.m)
#global Msd #__(KN.m)
#global As #__(cm^2)
#global As_1 #__(cm^2)
#global As_2 #__(cm^2)
Msd = float(self.line_Msd.text())
Ac_comp = bw*y
Fc = (sigma_c*1e3)*(Ac_comp*1e-4)
Mrd = Fc*(z*1e-2)
# Verificação do tipo de armaduras que devem ser utilizadas na viga

e cálculo da área de Aço
if Msd <= Mrd:
As_1 = (Msd/((fyd*1e3)*(z*1e-2)))*1e4
As = As_1
self.list_Dimensionamento.addItem("Resumo do Dimensionamento")
self.list_Dimensionamento.addItem("")
self.list_Dimensionamento.addItem("Armaduras Longitudinais:
Tração")
self.list_Dimensionamento.addItem("Msd = %.2f KN.m" %Msd)
self.list_Dimensionamento.addItem("Mrd = %.2f KN.m" %Mrd)
self.list_Dimensionamento.addItem("As = %.2f cm²" %(As))
if Msd > Mrd:

Mrd_1 = Mrd
As_1 = (Mrd_1/((fyd*1e3)*(z*1e-2)))*1e4
Mrd_2 = Msd-Mrd
As_2 = (Mrd_2/(fyd*1e3*((d*1e-2)-(d_*1e-2))))*1e4
As = As_1+As_2
self.list_Dimensionamento.addItem("Resumo do Dimensionamento")
self.list_Dimensionamento.addItem("Armaduras Longitudinais:
Tração e Compressão")
self.list_Dimensionamento.addItem("Msd = %.2f KN.m" %Msd)
self.list_Dimensionamento.addItem("Mrd = %.2f KN.m" %Mrd)
self.list_Dimensionamento.addItem("Mrd_1 = %.2f KN.m" %Mrd_1)
self.list_Dimensionamento.addItem("Mrd_2 = %.2f KN.m" %Mrd_2)
self.list_Dimensionamento.addItem("As = %.2f cm²" %(As_1)+" -
165
Tração")
self.list_Dimensionamento.addItem("As' = %.2f cm²" %(As_2)+" -
Compressão")
self.list_Dimensionamento.addItem("As_tot = %.2f cm²" %(As)+" -
Total")
self.list_Dimensionamento.addItem("As_máx = %.2f cm²" % (As_max) +

" - Armadura Máxima")
self.list_Dimensionamento.addItem("As_mín = %.2f cm²" % (As_min) +
" - Armadura Mínima")
if As <= As_max and As >= As_min:

self.list_Dimensionamento.addItem("Densidade de Armadura OK!")
if As > As_max:
self.list_Dimensionamento.addItem("Armadura Superior ao Valor
Máximo")
if As < As_min:
self.list_Dimensionamento.addItem("Armadura Inferior ao Valor
Mínimo")
# Definição da armadura Longitudinal

# Criando as listas de diâmeros, áreas e quantidades de barras
#global Diametros_Aco #__(cm)

#global Areas_Aco #__(cm^2)
#global N_Barras_1
#global N_Barras_2
Diametros_Aco = [0.63,0.8,1.0,1.25,1.6,2.0,2.2,2.5,3.2,4.0]
#__(cm)
#Diametros_Aco = np.array(Diametros_Aco, dtype=float)
Areas_Aco = []
N_Barras_1 = []
N_Barras_2 = []
for i in Diametros_Aco:
A_secao = (math.pi*math.pow(i,2))/4
Areas_Aco.append(A_secao)
Areas_Aco = np.array(Areas_Aco, dtype=float)
if Msd <= Mrd:

for i in Areas_Aco:
if (As_1//i)<1:
break
n = (As_1//i)+1
N_Barras_1.append(n)
if Msd > Mrd:
for i in Areas_Aco:
if (As_1//i)<1:
break
n_1 = (As_1//i)+1
N_Barras_1.append(n_1)
for i in Areas_Aco:
if (As_2//i)<1:
break
n_2 = (As_2//i)+1
N_Barras_2.append(n_2)
N_Barras_1 = np.array(N_Barras_1, dtype=float)

N_Barras_2 = np.array(N_Barras_2, dtype=float)
166
# Verificação para barras em em quantidade par
#if Msd>Mrd:
D = []
N = []
eh = []
ev = []
Camadas = []
for i,qtotal in enumerate(N_Barras_1):

qntd = qtotal
Fi_L = Diametros_Aco[i]
ev_min = max(2,Fi_L,0.5*(DMC*1e-1))
eh_min = max(2,1.2*(DMC*1e-1),Fi_L)
eh_barra = (bw-2*(cnom+(Fi_ti*1e-1))-(qntd*Fi_L))/(qntd-1)
soma = 0
c = 0
if ((qtotal/2)*Fi_L+(ev_min*((qtotal/2)-1))+cnom+Fi_ti*1e-1) <
0.80*yCG:
while qntd>1:
while eh_barra < eh_min and c<1:
qntd-=1
if qntd<=2:
break
eh_barra = (bw-2*(cnom+(Fi_ti*1e-
1))-(qntd*Fi_L))/(qntd-1)
# PAR___PAR
if qtotal%2==0 and qntd%2==0 and qntd>1:
c+=1
print("Camada %.2f recebe %.2f barras de %.2f mm
com eh = %.2f cm e ev = %.2f cm ---> Reastam %.2f barras" \
% (c, qntd, (Fi_L*1e1), eh_barra, ev_min,
qtotal - qntd))
N.append(qntd)
D.append(Fi_L*1e1)
Camadas.append(c)
soma = soma + qntd
qtotal = qtotal - qntd
qntd = qtotal
if qntd>=2:
qntd=2
else:
qntd=0
eh.append(eh_min)
ev.append(ev_min)
# ÍMPAR___ÍMPAR
elif qtotal%2!=0 and qntd%2!=0 and qntd>1:
c+=1
% (c, qntd, (Fi_L * 1e1), eh_barra, ev_min,
qtotal-qntd))
N.append(qntd)
D.append(Fi_L*1e1)
Camadas.append(c)
soma = soma + qntd
qntd = qtotal
167
if qntd>=2:
qntd=2
else:
qntd=0
eh.append(eh_min)
ev.append(ev_min)
# ÍMPAR___PAR
elif qtotal%2!=0 and qntd%2==0 and qntd>1:
c+=1
if c==1:
qntd-=1
if qntd==1:
break
qtotal-qntd))
N.append(qntd)
D.append(Fi_L*1e1)
Camadas.append(c)
soma = soma + qntd
qntd = qtotal
if qntd>=2:
qntd=2
else:
qntd=0
eh.append(eh_min)
ev.append(ev_min)
# PAR___ÍMPAR
elif qtotal%2==0 and qntd%2!=0 and qntd>1:
c+=1
if c==1:
qntd-=1
com eh = %.2f cm e ev = %.2f cm ---> Reastam %.2f barras"\
qtotal - qntd))
N.append(qntd)
D.append(Fi_L*1e1)
Camadas.append(c)
soma = soma + qntd
qntd = qtotal
if qntd>=2:
qntd=2
else:
qntd=0
eh.append(eh_min)
ev.append(ev_min)
#else:
#break
'''if ((valor/2)*Fi_L*1e-1+(ev_min*((valor/2)-1))
+cnom+Fi_ti*1e-1)<0.5*h:
D.append(Diametros_Aco[indice])
Q.append(valor)
for i,v in enumerate(Q):
diam = D[i]
n = Q[i]
eh_min = max (2,1.2*(DMC*1e-1),diam*1e-1)
168
ev_min = max(2, diam * 1e-1, 0.5 * (DMC * 1e-1))
eh_barra = (bw-2*((cnom+Fi_ti*1e-1))-(n*diam*1e-1))/(n-1)
soma=0
cam = 0
while n>0:
while eh_barra<eh_min:
n-=1
eh_barra = (bw-2*((cnom+Fi_ti*1e-1))-(n*diam*1e-
1))/(n-1)
if eh_barra>eh_min:
n=2
eh_b = (bw-2*((cnom+Fi_ti*1e-1))-(n*diam*1e-1))/(n-
1)
cam+=1
soma=soma+n
n=Q[i]-soma
eh.append(eh_b)
ev.append(ev_min)
Camadas.append(cam)'''
D = np.around(D, decimals=3)
print("\nDiâmetros: ",D)
print("Quantidades: ",N)
print("Camadas: ",Camadas,"\n")
#print(eh)
#print(ev)
###########################################################################
#############################################
#____________________________________INSERINDO PROPRIEDADES DOS MATERIAIS
NO RESUMO_____________________________________
###########################################################################
#############################################
#self.list_Dimensionamento.addItem("")
#self.list_Dimensionamento.addItem("Propriedades dos Materiais:")
# Propriedades do Concreto
#self.list_Dimensionamento.addItem("Concreto:")
#self.list_Dimensionamento.addItem("Coeficiente de ponderação da
resistência (Combinação %s) = %.2f" %(comb_ELU,yc))
#self.list_Dimensionamento.addItem("Classe de agressividade
ambiental (CAA) = %s" % CAA)
#self.list_Dimensionamento.addItem("Resistência à compressão (fck)
= %.2f MPa" % fck)
#self.list_Dimensionamento.addItem("Resistência média à tração
(fct,m) = %.2f MPa" %fctm)
#self.list_Dimensionamento.addItem("Resistência média à tração
indireta (fctk,sup) = %.2f MPa" % fctk_sup)
#self.list_Dimensionamento.addItem("Resistência média à tração na
flexão (fctk,inf) = %.2f MPa" % fctk_inf)
#self.list_Dimensionamento.addItem("Peso específico = 2500 KN/m³")
#self.list_Dimensionamento.addItem("Módulo de elasticidade inicial
(Eci) = %.2f GPa" %(Eci*1e-3))
#self.list_Dimensionamento.addItem("Módulo de elasticidade secante
(Ecs) = %.2f GPa" %(Ecs*1e-3))
# Propriedades do Aço #####_____INSERIR_____

#self.list_Dimensionamento.addItem("***___INSERIR PROPRIEDADES DO
169
AÇO___***")
# Propriedades dos Agregados

#self.list_Dimensionamento.addItem("Aregados:")
#self.list_Dimensionamento.addItem("Tipo do agregado = %s"
%agregado)
#self.list_Dimensionamento.addItem("Dimensão máxima característica
(DMC) = %.2f mm" %DMC)
# Propriedades da Seção Transversal

self.list_Dimensionamento.addItem("Propriedades da Seção
Transversal:")
self.list_Dimensionamento.addItem("Largura da base (bw) = %.2f cm"
%bw)
self.list_Dimensionamento.addItem("Altura (h) = %.2f cm" %h)
self.list_Dimensionamento.addItem("Cobrimento da armadura (cnom) =
%.2f cm" %cnom)
self.list_Dimensionamento.addItem("Área da seção = %.2f cm²" % Ac)
#self.list_Dimensionamento.addItem("Área comprimida = %.2f cm²" %
Ac_comp)
#self.list_Dimensionamento.addItem("Posição da Linha Neutra = %.2f
cm" %yCG)
self.list_Dimensionamento.addItem("Momento de Inércia = %.2f cm^4"
%I)
#self.list_Dimensionamento.addItem("d = %.2f cm" % d)
#self.list_Dimensionamento.addItem("d' = %.2f cm" % d_)
#self.list_Dimensionamento.addItem("x = %.2f cm" % x)
print("\nLista de Barra: ", Diametros_Aco)

print("\nLista de Áreas: ", Areas_Aco)
print("\nQuantidade de Barra (T): ", N_Barras_1)
print("\nQuantidade de Barra (C): ", N_Barras_2)
print("\nCobrimento da Armadura = %.2f cm" % cnom)
print("Tipo de Agregado = %s" % agregado)
print("aE = %.2f" % aE)
print("Dimensão Máx. do Agregado = %.2f mm" % DMC)
print("Classe do Aço = %s" % aco)
print("fyk = %.2f MPa" % fyk)
print("yc = %.2f" % yc)
print("ys = %.2f" % ys)
print("Altuta h = %.2f m" %h)
print("Largura bw = %.2f m" % bw)
print("Altura da Linha Neutra = %.2f m" % yCG)
print("Momento de Inércia = %.2f cm^4" % I)
print("Diam. Inicial do Estribo = %.2f mm" % Fi_ti)
print("Diam. Inicial da Barra Longitudinal = %.2f mm" % Fi_li)
print("Valor de d = %.4f m" % d)
print("Valor de d_ = %.4f m" % d_)
print("ai = %.4f" %ai)
print("ac = %.4f" %ac)
print("lamb = %.2f" %lamb)
print("fcd = %.2f Mpa" %fcd)
print("sigma_c = %.2f MPa" %sigma_c)
print("Área da Seção = %.6f m^2" % Ac)
print("Área Comprimida = %.6f m^2" % Ac_comp)
print("Fc = %.2f Kn" % Fc)
print("Mrd = %.2f KN.m" % Mrd)
print("As = %.6f m^2" % As + "\n")
170
if __name__ == '__main__':
import sys
app = J_Dimensionamento()
app.show()
#app.showMaximized()
root.exec_()
171

TCC - II - FINAL - Eduardo Viali - 04-07-2020

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

TCC - II - FINAL - Eduardo Viali - 04-07-2020

Enviado por

Direitos autorais:

Formatos disponíveis

Ministério da Educação

Universidade Federal da Integração Latino-Americana

DESENVOLVIMENTO DE SOFTWARE PARA ANÁLISE ESTRUTURAL

EDUARDO DE PADUA VIALI

DESENVOLVIMENTO DE SOFTWARE PARA ANÁLISE ESTRUTURAL

EDUARDO DE PADUA VIALI

Trabalho de Conclusão de Curso apresentado a

Orientador: Prof. Dr. AREF KALILO LIMA KZAM

VIALI, E. P. Desenvolvimento De Software Para Análise Estrutural E Dimensionamento

Com o intuito de reduzir o tempo dispensado na análise e dimensionamento de estruturas,

Palavras-chave: Análise estrutural; Dimensionamento de vigas; Concreto armado;

VIALI, E. P. Desenvolvimento De Software Para Análise Estrutural E Dimensionamento

Keywords: Structural analysis; Beam design; Reinforced concrete; Software.

FIGURA 1. INTERFACE GRÁFICA DO PROGRAMA FTOOL....................................16

FIGURA 23 DIAGRAMAS TENSÃO X DEFORMAÇÃO DO CONCRETO E AÇO –

FIGURA 63. REAÇÕES NOS APOIOS CALCULADAS PELO SOFTWARE

2.1 OBJETIVO GERAL................................................................................................14

2.2 OBJETIVOS ESPECÍFICOS..................................................................................14

3.1 FERRAMENTAS COMPUTACIONAIS ACADÊMICAS VOLTADAS À ANÁLISE

3.2 A LINGUAGEM DE PROGRAMAÇÃO PYTHON...................................................18

3.2.1 Biblioteca NumPy................................................................................................18

3.2.2 Biblioteca Matplotlib............................................................................................18

3.2.3 Biblioteca PyQt e Qt Designer.............................................................................19

3.3 ANÁLISE ESTRUTURAL.......................................................................................20

3.3.1 Modelo Estrutural................................................................................................20

3.3.2 Teoria Elementar De Vigas.................................................................................22

3.3.3 Método Dos Elementos Finitos – MEF................................................................27

3.3.4 Método De Galerkin – Resíduos Ponderados.....................................................27

3.3.5 Transformação Do Sistema De Coordenadas –Local Vs Global.........................28

3.3.6 Funções Aproximadoras E De Forma.................................................................30

3.3.7 Matriz De Rigidez Do Elemento Finito.................................................................31

3.3.8 Matriz De Rigidez Global Da Estrutura................................................................33

3.3.9 Vetor De Cargas Nodais Equivalentes................................................................37

3.3.10 Esforços Nodais Atuantes No Elemento Finito..................................................39

3.4 DIMENSIONAMENTO ESTRUTURAL...................................................................40

3.4.1 Verificação Da Segurança..................................................................................40

3.4.2 Capacidade Resistente.......................................................................................41

3.4.2.1 Estádio I...........................................................................................................41

3.4.2.2 Estádio II.......................................................................................................... 42

3.4.2.3 Estádio III.........................................................................................................43

3.4.3 Hipóteses de dimensionamento..........................................................................44

3.4.4 Diagramas tensão deformação...........................................................................44

3.4.5 Domínios de deformação....................................................................................45

3.4.5.1 Domínio 2.........................................................................................................46

3.4.5.2 Domínio 3.........................................................................................................46

3.4.6 Dimensionamento da seção retangular com armadura simples..........................46

4.2 APRESENTAÇÃO DA INTERFACE GRÁFICA DO PROGRAMA..........................50

4.3 ARMAZENAMENTO E FLUXO DE MANIPULAÇÃO DE DADOS..........................56

4.3.1 Inserção dos nós.................................................................................................57

4.3.2 Inserção dos elementos......................................................................................57

4.3.3 Inserção das propriedades físicas e mecânicas dos elementos..........................58

4.3.4 Inserção das condições de contorno...................................................................59

4.3.5 Inserção das cargas nodais................................................................................59

4.3.6 Inserção das cargas distribuídas.........................................................................59

4.4 METODOLOGIA DE CÁLCULO DO SISTEMA......................................................60

4.5 DIMENSIONAMENTO DAS ARMADURAS LONGITUDINAIS...............................63

4.6 MODELOS PARA VALIDAÇÃO DO SOFTWARE..................................................64

4.6.1 Modelos para validação da análise estrutural.....................................................64

5.1 ANÁLISE DO MODELO-01....................................................................................67

5.1.1 Reações nos apoios da estrutura........................................................................67

5.1.2 Esforços internos................................................................................................67

5.1.2.1 Esforços normais.............................................................................................67

5.1.2.2 Esforços cortantes...........................................................................................68