MÉTODO DOS ELEMENTOS FINITOS I – COC752.

TRABALHO FINAL: IMPLEMENTAÇÃO DO MÉTODO DE ELEMENTOS

FINITOS PARA UM EXEMPLO DE ESTADO PLANO DE DEFORMAÇÃO

Professor: Fernando Luiz Bastos Ribeiro

Alunos:
Alex Duarte de Oliveira
Felipe di Napoli Garcia
Marzieh Paravi
Nathália Rodrigues Julião

Rio de Janeiro
Junho de 2017
 SUMÁRIO

1 INTRODUÇÃO ................................................................................................... 1

1.1 ESTRUTURA ORIGINAL DO SOFTWARE UTILIZADO ...................... 1

2 METODOLOGIA ............................................................................................... 3

2.1 ELEMENTO QUADRILÁTERO BI LINEAR ........................................... 3

2.1.1 Mapeamento Isoparamétrico ................................................................ 3

2.1.2 Funções de Interpolação ........................................................................ 4

2.1.3 Matriz do Operador Diferencial ........................................................... 4

2.1.4 Matriz Jacobiana ................................................................................... 5

2.1.5 Matriz de Rigidez................................................................................... 6

2.1.6 Integração Numérica ............................................................................. 6

2.1.7 Armazenamento Skyline........................................................................ 7

2.2 MÉTODO DOS GRADIENTES CONJUGADOS ...................................... 8

2.3 O SOFTWARE PARAVIEW ..................................................................... 11

3 APLICAÇÃO DO SOFTWARE ALTERADO ................................................ 12

3.1 DESCRIÇÃO DO PROBLEMA SIMULADO .......................................... 12

3.2 RESULTADOS ........................................................................................... 13

4 CONCLUSÕES ................................................................................................. 21

REFERÊNCIAS BIBLIOGRÁFICAS ..................................................................... 22

ANEXO – SUB-ROTINAS IMPLEMENTADAS.................................................... 23

 1

1 INTRODUÇÃO

Este trabalho constitui requisito parcial para a disciplina de Método dos Elementos Finitos I,
ministrada pelo professor Fernando Luiz Bastos Ribeiro, e foi elaborado utilizando um software
de elementos finitos disponibilizado pelo professor, durante o curso.

O primeiro objetivo deste trabalho é alterar o programa fornecido para incluir: (1) um elemento
quadrilátero bilinear, para problemas de elasticidade plana; (2) um solver iterativo, utilizando
o Método dos Gradientes Conjugados, com pré-condicionamento diagonal; e (3) uma rotina
para escrever o arquivo de saída no formato VTK, compatível com o software Paraview.

O segundo objetivo do trabalho é utilizar o programa alterado para simular um problema de

elasticidade plana, empregando malhas estruturadas de elementos triangulares e
quadrangulares, com diferentes números de nós, para verificar o funcionamento das rotinas
implementadas e para comparar os resultados obtidos com os dois tipos de elementos.

1.1 ESTRUTURA ORIGINAL DO SOFTWARE UTILIZADO

O programa fornecido possui a seguinte estrutura:

Figura 1. Estrutura do programa fornecido.

Descrição das principais sub-rotinas existentes no programa:

 2

contr: Sub-rotina de controle geral do programa.

rdata: Sub-rotina que faz a leitura de dados no arquivo de entrada.

elmt(0x): Sub-rotina que define o tipo de elemento utilizado, incluindo:

Definição do tipo de problema de elasticidade (EPT ou EPD);

Cálculo das derivadas das funções de interpolação;

Cálculo da matriz Jacobiana e sua inversa;

Cálculo da matriz constitutiva do problema;

Cálculo da matriz de rigidez.

elmlib: Sub-rotina que faz o direcionamento da sub-rotina do elemento.

numeq: Sub-rotina que faz a numeração das equações.

profil: Sub-rotina que monta o perfil da matriz de rigidez e o vetor apontador (jdiag), seguindo
o método de armazenamento Skyline.

pload: Sub-rotina que monta o vetor de forças nodais equivalentes.

pform: Sub-rotina que corrige o vetor de forças, através da introdução dos deslocamentos
prescritos. Também faz a definição da numeração global das equações dos elementos e
associação dos vetores locais aos vetores globais da estrutura.

addst: Sub-rotina que distribui os arranjos locais nos arranjos globais.

actcol: Sub-rotina que implementa o método de solução direta do sistema de equações,

utilizando a eliminação de Gauss com decomposição de Crout.

tform: Sub-rotina que cálculo das tensões e deformações.

wdata: Sub-rotina que escreve os resultados no arquivo de saída.

 3

2 METODOLOGIA

2.1 ELEMENTO QUADRILÁTERO BI LINEAR

2.1.1 Mapeamento Isoparamétrico

O mapeamento isoparamétrico consiste em mapear os elementos de coordenadas naturais em

um domínio regular, sendo este mapeamento dado por funções polinomiais idênticas às que são
utilizadas na aproximação da solução. Quando é feita a mesma parametrização para a geometria
do elemento e para a solução aproximada, o elemento denominado de isoparamétrico.

No elemento bidimensional com quatro pontos nodais (quadrilátero bilinear), para a

convergência do MEF, é suficiente a utilização de funções de interpolação lineares nas
coordenadas regulares  e h, cujo domínio é [-1,1]. Nas coordenadas cartesianas x e y, cada
lado do elemento é um segmento de reta definido pelos respectivos nós de vértice. Assim, no
mapeamento, o elemento distorcido no domínio físico real fica regular no domínio de
coordenadas naturais, conforme ilustra a Figura 2.

y h
1
2 2 1


3

4
x 3 4

Figura 2. Mapeamento isoparamétrico de um elemento quadrilátero.

Para o elemento quadrilátero da figura acima, a aproximação dos deslocamentos nodais,

( , ), escrita em termos de coordenadas naturais ( , ), é dada por:

( , )= ( , )

Onde:

Nj (ξ , η) é a função de interpolação local do nó;

 4

uj é o deslocamento do nó.

A geometria do elemento é descrita por:

( , )= ( , )

( , )= ( , )

Sendo (xj , yj) as coordenadas dos nós do elemento.

2.1.2 Funções de Interpolação

As funções de interpolação (Ni) para um elemento quadrilátero são obtidas a partir do produto
de polinômios de Lagrange de grau p, em cada direção, resultando em elementos com (p + 1)²
nós. Desta forma, as funções para o elemento quadrilátero bi linear são dadas por:

1
= (1 + )(1 + )
4
1
= (1 − )(1 + )
4
1
= (1 − )(1 − )
4
1
= (1 + )(1 − )
4
E suas derivadas são dadas por:

= (1 + ), = (−1)(1 + ), = (−1)(1 − ) e = (1 − )

= (1 + ), = (1 − ), = (−1)(1 − ) e = (−1)(1 + )

2.1.3 Matriz do Operador Diferencial

Para montar a matriz de rigidez da estrutura, é necessário estabelecer a matriz do operador

diferencial B, dada por:

[ ] = [ℒ][ ]
 5

⎡ 0 0 0 0 ⎤
⎢ ⎥
⎢ ⎥
[ ]=⎢ 0 0 0 0 ⎥
⎢ ⎥
⎢ ⎥
⎣ ⎦

2.1.4 Matriz Jacobiana

Para a montagem da matriz B do operador diferencial, é necessário calcular as derivadas das

funções de interpolação em relação às coordenadas cartesianas x e y. As funções de interpolação
são expressas em termos das coordenadas naturais ξ e η. Usando a regra da cadeia, as derivadas
das funções de interpolação em relação às coordenadas naturais ξ e η podem ser obtidas a partir
de:

( , )
= +

( , )
= +

Escrevendo na forma matricial, tem-se:

⎡ ⎤ ⎡ ⎤⎡ ⎤
⎢ ⎥=⎢ ⎥⎢ ⎥
⎢ ⎥ ⎢ ⎥
⎢ ⎥ ⎢ ⎥⎢ ⎥
⎣ ⎦ ⎣ ⎦⎣ ⎦

A matriz que relaciona as derivadas nos dois sistemas de coordenadas é a matriz Jacobiana:

⎡ ⎤
[ ] = ⎢⎢ ⎥
⎥
⎢ ⎥
⎣ ⎦

Sendo suas componentes:

= e =

= e =

Obtidas as derivadas de Ni em relação a ξ e η através da matriz Jacobiana [J], pode-se obter as

 6

derivadas em relação às coordenadas cartesianas e através da utilização da inversa da matriz

Jacobiana [J]-1:

⎡ ⎤
=[ ] ⎢ ⎥
⎢ ⎥
⎢ ⎥
⎣ ⎦

2.1.5 Matriz de Rigidez

A matriz de rigidez de um elemento parametrizado no domínio natural de coordenadas

adimensionais (ξ , η) pode ser obtida a partir da seguinte expressão:

= [ ( , )] ∙ [ ] ∙ ( , )

Sendo dΩ = dx dy

Pode-se provar que: dΩ = det[J].dξ.dη. Assim, a integral pode ser reescrita da forma:

= [ ( , )] ∙ [ ] ∙ ( , ) [ ]

Onde D é a matriz constitutiva do estado plano de deformação, dada pela seguinte expressão:

⎡ 1 1− ⎤ 0
(1 − ) ⎢ ⎥
= ⎢ 1 0 ⎥
(1 + )(1 − 2 ) ⎢1 − ⎥
⎢ 0 1−2 ⎥
0
⎣ 2(1 − )⎦

2.1.6 Integração Numérica

Numericamente, a integral acima pode ser resolvida como um somatório, aplicando a integração
numérica de Gauss, onde o domínio das coordenadas naturais (ξ, η) é alterado para o domínio
dos pontos de Gauss (ξi, ηi ), inserindo, na expressão, os pesos destes pontos de integração,
conforme a expressão abaixo:

= ( , ) = ,
 7

Sendo n o número de pontos de integração e:

, =[ ] ∙[ ]∙ ∙ []

O número de pontos de integração deve satisfazer a seguinte equação, onde p é o grau do

polinômio a ser integrado:

≤ (2 − 1)

2.1.6.1 No caso multidimensional, a integração numérica é empregada em cada coordenada

separadamente. As funções de interpolação do elemento quadrilátero bi linear tem
grau p = 2, então são necessários 2 pontos de integração (n = 2) e o somatório a ser
calculado será o seguinte:

= [ ( , )] [ ] ( , )

ξi e ηi são os pontos de integração e i e j os pesos dos pontos de integração, definidos na de

acordo com a quantidade de pontos de integração necessários para o cálculo. Para n = 2, i e j
serão iguais a 1,0 e as coordenadas desses pontos serão:

= −0.577350269189626 = −0.577350269189626

= +0.577350269189626 = +0.577350269189626

Conhecida a matriz de rigidez e as forças nodais da malha, é possível montar um sistema de

equações do tipo Ax = b, onde a solução desse sistema é feita apenas para os graus de liberdade
não restritos dos nós da malha. O vetor de forças nodais deve ser então corrigido com o valor
das forças internas decorrentes dos graus de liberdade restringidos. O sistema de equações a ser
resolvido é da forma:

{ } = [ ]{ }

Onde {F} é o vetor de forças nodais e [K] é a matriz de rigidez global da malha.

2.1.7 Armazenamento Skyline

A matriz K do sistema de equações a ser resolvido é simétrica, o que permite que o seu
armazenamento seja feito considerando apenas a sua parte superior (ou inferior). Além de ser
simétrica, a matriz K também é esparsa, o que permite que o seu armazenamento seja feito
 8

utilizando a estrutura de dados Skyline.

Na estrutura de dados Skyline, os coeficientes da matriz são armazenados em um vetor,

seguindo a sequência das colunas da matriz, armazenando apenas a parte superior da matriz (de
cima para baixo até o elemento da diagonal), começando a partir do primeiro termo não nulo
de cada coluna. Esse tipo de armazenamento serve para reduzir a quantidade de dados
armazenado e aumentar a eficiência computacional.

Após a matriz do sistema ser armazenada no formato Skyline, é criado um vetor apontador
(jdiag) que armazena as posições que os elementos da diagonal da matriz ocupam no vetor
Skyline. Este vetor apontador é utilizado para realizar as operações com a matriz do sistema,
na forma de produto entre vetores.

2.2 MÉTODO DOS GRADIENTES CONJUGADOS

A resolução de sistemas lineares de equações algébricas pode ser dividida em dois grupos de
métodos: os diretos e os iterativos.

Nos métodos diretos é possível determinar previamente o número de operações matemáticas

necessárias para obter a resolução do sistema. Entre os principais métodos diretos destacam-se
o método da eliminação de Gauss e os métodos baseados na prévia decomposição da matriz dos
coeficientes por um produto de matrizes, entre eles são: método de Crout, Doolitle e o
Cholesky.

Os métodos iterativos têm por finalidade o melhoramento da solução aproximada até que esta
esteja precisa o suficiente. Esses métodos consistem em calcular uma sequência de
aproximações da solução do sistema linear, condicionados a uma aproximação inicial e uma
tolerância. O Método dos Gradientes Conjugados foi o método iterativo implementado neste
trabalho.

O método do gradiente conjugado (CG) é um algoritmo utilizado para soluções numéricas de

sistemas particulares de equações, sendo resolvido a partir de produto matriz-vetor, até que se
obtenha a convergência da solução. O método teve origem a partir do estudo das funções
quadráticas, definidas como:

1
( )= − +
2
Onde:
 9

A – é uma matriz simétrica;

b e x – são vetores;

c – é um escalar.

Ao longo das curvas de nível desta função, o valor de f(x) é constante. O gradiente de f(x)
representa a direção de maior crescimento da função, sendo, portanto, ortogonal às curvas de
nível e é expresso por:

  f  x  f  x 
f  x    , 
 x y 

O ponto central das elipses formadas representa o ponto em que a derivada de f(x) é nula, ou
seja, f '(x) = 0 e, portanto, o gradiente da função neste ponto é nulo.

A derivada de uma função quadrática é dada por:

1 1
′( ) = + −
2 2

Como a matriz A é simétrica, tem-se que:

(x) = −

Para o cálculo do gradiente igual à zero, ou seja, ponto de máximo ou mínimo tem-se:

( )=0 ∴0= − ∴ =

A função quadrática terá um ponto de mínimo onde a derivada se anula sempre que a matriz A
for positiva definida, caso contrário, o ponto poderá será de máximo. Desta maneira, sempre
que A for simétrica e positiva definida, a função quadrática será um paraboloide voltado para
cima e, ao solucionar novamente o sistema A.x = b, é encontrado o ponto de mínimo da função.
Portanto, o método objetiva basicamente encontrar os pontos xi caminhando para o ponto de
mínimo do paraboloide, seguindo sempre a direção de maior decréscimo da função, que será a
direção de f '(xi).

Neste método, inicia-se a partir de um ponto xo ao longo da direção de maior variação da função
e geram-se uma sequência de pontos xi subsequentes para seguir a direção do vetor de f '(xi). O
resíduo em xi será ri = b – A.xi e o erro em xi será e = x* - xi. O resíduo pode ser visto como a
direção de máxima descida da função f(x) em xi, ou seja, ri = f '(x).

Dado xo pode-se encontrar um ponto xi que diminua o resíduo, ou seja, f '(x), dando um passo
na direção de –f'(xo). Em outras palavras, pode-se encontrar x1 definindo-o como x1 = xo + ∝.ro,
 10

onde o parâmetro ∝ é o comprimento do passo. Para encontrar o melhor valor de ∝, minimiza-

se f(x) ao longo da direção definida por ro. Assim, iguala-se a zero a derivada de f(xo + ∝.ro)
com relação a ∝:

∝ =

Resumidamente, partindo de um ponto xo, fazendo i = 0,…,n e tomando-se = +∝ =

= − é feita a seguinte sequência:

(minimiza a função f ao longo da direção do resíduo)

∝=

= +∝ (próximo ponto)

= −∝ (resíduo, sem retorno de xi )

(constante de Gram-Schmidt)
=

= − (search direction)

O processo é feito até que o xn se aproxime o suficiente da solução exata, de acordo com a
tolerância adotada e requerida no problema.

Embora essa formulação reduza o esforço por iteração, a desvantagem é que o cálculo de r(i +1)
é feito sem nenhum valor de retorno de xi, apenas de xo, fazendo com que este cálculo acumule
erros de arredondamento. Isto pode ser minimizado retornando-se periodicamente, a cada
determinado número de iterações, à equação inicial ri = b – A.xi para o novo cálculo do resíduo
correto.

A utilização de um pré-condicionador é uma técnica que objetiva aprimorar o número de

coeficientes de uma matriz, de forma a ocupar o menor espaço possível. Pode-se considerar um
pré-condicionamento qualquer alteração feita no sistema original tal que o novo sistema seja
equivalente ao anterior, tenha a mesma solução, porém seja mais fácil de solucionar. Em geral,
essa técnica é feita através da utilização de uma matriz M (matriz pré-condicionadora)
responsável pela transformação do sistema.

O pré-condicionamento pode ser feito pelo lado esquerdo: = , ou pelo lado

direito: = , sendo = . Pode-se também, utilizar a combinação dos dois.
 11

Alguns dos principais pré-condicionadores utilizados para resolver sistema são:

– Pré-condicionador Diagonal;

– Pré-condicionador Lumped;

– Pré-condicionador ILU (0);

– Pré-condicionador ILUT.

O pré-condicionador diagonal, que foi utilizado neste trabalho, consiste em uma matriz
diagonal M que contém os valores da diagonal da matriz A.

A matriz pré-condicionadora diagonal M é então:

()= ( ( ))

Onde jdiag é o vetor apontador dos elementos da diagonal da matriz A.

Uma matriz diagonal é simples de ser invertida, porém há de se observar que em boa parte dos
casos não remete aos pré-condicionadores ideais.

2.3 O SOFTWARE PARAVIEW

O ParaView é um software aberto, multi-plataforma, que permite a criação rápida de

visualizações para analisar dados usando técnicas qualitativas e quantitativas. A exploração de
dados pode ser feita de forma interativa em 3D ou programaticamente. O programa foi
desenvolvido para analisar conjuntos de dados extremamente grandes, usando recursos de
computação de memória distribuída.

A base de código ParaView foi projetada de tal forma que todos os seus componentes podem
ser reutilizados para desenvolver aplicativos verticais. Essa flexibilidade permite que os
usuários desenvolvam rapidamente aplicativos que possuem funcionalidades específicas para
um problema específico. O ParaView é executado em sistemas de processamento de memória
compartilhada ou distribuída e utiliza o Visualization Toolkit (VTK) como o mecanismo de
processamento e renderização de dados.
 12

3 APLICAÇÃO DO SOFTWARE ALTERADO

3.1 DESCRIÇÃO DO PROBLEMA SIMULADO

O problema analisado é o exemplo de estado plano de deformação de uma chapa engastada,

com uma carga uniformemente distribuída, como mostrado na Figura 3. A seção transversal
tem dimensões 1x1, está engastada em uma das extremidades laterais e submetida a um
carregamento uniformemente distribuído na direção y de valor unitário. Adota-se um módulo
de elasticidade E = 1,0 e coeficiente de Poisson =0,3.

Figura 3. Representação do problema proposto.

O problema foi simulado utilizando elementos triangulares e quadriláteros, com cinco malhas
estruturadas diferentes para cada tipo elemento. Para um mesmo tipo de elemento, a diferença
entre as malhas utilizadas está no número de divisões das arestas, consequentemente, no número
de nós e elementos. As discretizações utilizadas foram de 8x8, 16x16, 32x32, 64x64 e 128x128.
Desta forma, para os dois tipos de elementos, foram utilizadas malhas com os mesmos números
de nós, variando apenas a quantidade de elementos. A Tabela 1 apresenta um resumo das
características das malhas utilizadas.

Tabela 1. Resumo das malhas utilizadas.

Número de Elementos
Discretização Número de nós
Quadrilátero Triangular
8x8 81 64 128
16x16 289 256 512
32x32 1089 1024 2048
64x64 4225 4096 8192
128x128 16641 16384 32768
 13

Para este problema, considerou-se que a norma de energia da solução exata seria igual a ‖u‖E
=1,379745. Este valor foi utilizado, juntamente com os valores da norma de energia obtidos nas
simulações, para calcular a norma de energia do erro de cada um dos casos simulados.

3.2 RESULTADOS

Os resultados obtidos serão apresentados nesta seção, em termos dos deslocamentos absolutos
e das normas de energia das soluções aproximadas. As Figuras 4 a 13 apresentam os
deslocamentos, visualizados pelo software ParaView, enquanto as normas de energia e os
valores de erro são apresentados na Tabela 3.

Figura 4. Deslocamento absoluto para a malha quadrangular (8x8).

Figura 5. Deslocamento absoluto para a malha triangular (8x8).

 14

Figura 6. Deslocamento absoluto para a malha quadrangular (16x16).

Figura 7. Deslocamento absoluto para a malha triangular (16x16).

 15

Figura 8. Deslocamento absoluto para a malha quadrangular (32x32).

Figura 9. Deslocamento absoluto para a malha triangular (32x32).

 16

Figura 10. Deslocamento absoluto para a malha quadrangular (64x64).

Figura 11. Deslocamento absoluto para a malha triangular (64x64).

 17

Figura 12. Deslocamento absoluto para a malha quadrangular (128x128).

Figura 13. Deslocamento absoluto para a malha triangular (128x128).

Analisando as Figuras 4 a 13, percebe-se que, nos dois tipos de elementos, os valores de
deslocamento absoluto aumentaram com o refinamento da malha, tendendo para um valor
limite máximo, que seria, teoricamente, o valor da solução exata.

Comparando os resultados entre os dois tipos de malha, percebe-se que a malha quadrangular
apresenta valores ligeiramente superiores para todos os casos, tendendo a atingir o valor
máximo teórico com um grau de refinamento menor que o da malha triangular (menor número
de nós e elementos).

A Tabela 2 apresenta os valores de norma de energia e erro percentual para todos os casos
 18

simulados. Os valores da norma de energia das soluções aproximadas (||u||E), da norma dos
erros (||e||), e do erro relativo (h), apresentados na Tabela 3, foram calculados utilizando as
seguintes expressões, respectivamente:

‖û‖ = ( û) ( û) Ω =

‖ ‖ =‖ ‖ −‖ ‖

= 100 ∗ ‖ ‖ ⁄‖ ‖

A norma de energia da solução exata foi considerada igual a ||u||E = 1,379745. Este valor foi
obtido com uma malha de alto grau de refinamento e fornecido pelo professor.

Tabela 2. Resultados da análise de convergência e comparação dos tipos de elementos.

ELEMENTOS TRIANGULARES
Malha h nnode numel neq ||û||E ||e||E h (%)
8×8 0,125 81 128 144 1,326407 0,379922 27,54
16 × 16 0,0625 289 512 544 1,359485 0,235578 17,07
32 × 32 0,03125 1089 1089 2112 1,372203 0,144067 10,44
64 × 64 0,015625 4225 8192 8320 1,376942 0,087903 6,37
128 × 128 0,0078125 16641 32768 33024 1,378699 0,053715 3,89
ELEMENTOS QUADRILÁTEROS
Malha h nnode numel neq ||û||E ||e||E h (%)
8×8 0,125 81 64 144 1,358335 0,242120 17,55
16 × 16 0,0625 289 256 544 1,371771 0,148124 10,74
32 × 32 0,03125 1089 1024 2112 1,376786 0,090314 6,55
64 × 64 0,015625 4225 4096 8320 1,378642 0,055159 4,00
128 × 128 0,0078125 16641 16384 33024 1,379330 0,033838 2,45

Pela Tabela 2, percebe-se que a norma de energia da solução aumenta com o refinamento da
malha, enquanto a norma do erro e o erro relativo diminuem. Isso indica que a solução obtida
está se aproximando da solução exata do problema que, neste caso, foi assumida como sendo
igual a solução obtida com a malha de alto grau de refinamento. Além da influência do grau de
refinamento, também pode-se perceber a influência do tipo de elemento. Para todos os casos
simulados, as malhas com elementos quadriláteros apresentaram maiores valores de norma de
energia da solução e menores erros relativos que os elementos triangulares.

As malhas com elementos quadriláteros apresentaram, de maneira geral, resultados melhores

que as malhas de elementos triangulares. Isso ocorre porque as funções de interpolação
 19

utilizadas nos elementos quadriláteros são bi lineares, enquanto as funções dos elementos
triangulares são apenas lineares.

A aproximação por MEF converge para a solução exata quando é atendida a expressão:
‖ ‖ ≤ ℎ
Onde:

C – constante independente;

h – dimensão do elemento;

μ – valor mínimo de p e λ;

p – grau dos polinômios;

λ – real positivo.

Fixando o grau do polinômio, a mesma expressão fica:

‖ ‖ ≤ ℎ

Onde é a taxa de convergência de ℎ.

Finalmente, a expressão pode ser reescrita em função do número de equações, fazendo ≈
⁄ℎ :
‖ ‖ ≤ /

‖ ‖ ≤ −
2
Utilizando esta expressão e os dados da Tabela 3, foram plotados os gráficos apresentados na
Figura 14.
 20

0,00
Elementos Triangulares
-0,20

-0,40 Elementos Quadrangulares

y = -0,3602x + 0,3570

-0,60
Log(|e|)

-0,80

-1,00

-1,20
y = -0,3621x + 0,1625
-1,40

-1,60
2,00 2,50 3,00 3,50 4,00 4,50 5,00
Log(neq)

Figura 14. Variação de Log(||e||) X Log(neq).

Os resultados apresentados na Figura 14, assim como os resultados anteriores, mostram que o
erro da solução obtida com os elementos triangulares é sempre superior ao erro associados aos
elementos quadriláteros. A partir destes resultados, foram quantificadas as taxas de
convergência () de cada tipo de elemento. Os valores de μ, obtidos a partir dos coeficientes
angulares das curvas, foram de 0,7204 para as malhas com elementos triangulares e 0,7242 para
as malhas com elementos quadriláteros. Assim, como esperado, os elementos quadriláteros
forneceram melhores resultados, com uma taxa de convergência ligeiramente maior que os
elementos triangulares.
 21

4 CONCLUSÕES

No presente trabalho foram feitas alterações no software de elementos finitos da disciplina,

program.for, escrito na linguagem Fortran. As alterações feitas incluíram um elemento
quadrilátero de elasticidade plana, um solver iterativo pelo Método dos Gradientes Conjugados
e o arquivo de saída do programa foi adaptado para o formato vtk, compatível com o
visualizador Paraview.

O programa alterado foi empregado para simular um problema de elasticidade plana (estado
plano de deformações), utilizando 10 malhas diferentes. Os resultados obtidos foram
consistentes e dentro do esperado. Os valores obtidos com o Método dos Gradientes
Conjugados implementado, para as malhas triangulares e quadrangulares, foram iguais aos
valores obtidos com o método direto, originalmente implementado no programa. Isso indica
que as alterações feitas no programa foram bem-sucedidas

Observou-se que as soluções obtidas apresentaram uma tendência de convergência, em função

do aumento do grau de refinamento da malha. Esta tendência de convergência pode ser
observada tanto nos valores de deslocamento como nos valores de norma de energia para as
soluções e para o erro.

Observou-se também, como esperado, que, para o mesmo número de nós, as malhas de
elementos quadriláteros apresentaram sempre valores de deslocamento ligeiramente superiores
aos valores obtidos com as malhas triangulares. Consequentemente, os valores da norma de
energia do erro e o erro relativo foram sempre menores. Também foi verificado que a taxa de
convergência da malha de elementos quadriláteros é maior que a de elementos triangulares. Isso
ocorre porque as funções de interpolações do quadrilátero são bi lineares, enquanto as do
elemento triangular são lineares.

Em resumo, as alterações feitas no software foram bem-sucedidas, gerando resultados coerentes

e dentro do esperado, que foram exportados corretamente para o formato VTK. E as simulações
mostraram que os elementos quadriláteros apresentaram melhores resultados e possuem maior
taxa de convergência.
 22

REFERÊNCIAS BIBLIOGRÁFICAS

FISH, J.; BELYTSCHKO, T. (2009). Um Primeiro Curso em Elementos Finitos. Livros

Técnicos e Científicos Editora S.A.

KITWARE INCORPORATED. The Visualization Toolkit User's Guide, Kitware Inc.

RIBEIRO, F.L.B. Introdução ao Método dos Elementos Finitos. Notas de aula da disciplina
Elementos Finitos I (COC752). Programa de Engenharia Civil, COPPE/UFRJ.

RIBEIRO, F.L.B., Arquivo program.for. Disciplina Elementos Finitos I (COC752).

Programa de Engenharia Civil, COPPE/UFRJ.

SHEWCHUK, J. R (1994). An Introduction to the Conjugate Gradient Method Without

the Agonizing Pain. Edition 114 - School of Computer Science - Carnegie Mellon University.

SCHROEDER, W.; MARTIN, K.; LORENSEN, B (1998). The Visualization Toolkit, An

Object-Oriented Approach to 3D Graphics. Prentice Hall, ISBN: 0139546944, LC:
QA76.64.S36.

SQUILLACOTE, A. H (2007). The ParaView Guide. Kitware Inc, ISBN13: 978-1-930934-

21-4.

ZIENKIEWICZ, O.C.; TAYLOR, R.L. (1989). The finite element method. 4thEdition, Vol.1:
Basic formulation and Linear Problems, MacGraw-Hill.
 23

ANEXO – SUB-ROTINAS IMPLEMENTADAS

Sub-Rotina para o Elemento Quadrilátero de Estado Plano de Deformação

4: subroutine elmt03 (e,x,u,p,s,nel,ndm,nst,isw,nin)

5: integer ndm,isw,nst,j,i,k,l,m,n,nel
6: real*8 e(*),me,cp,a,b,c,d11,d12,d21,d22,d33,eta_eta,ksi_ksi
7: real*8 dN_eta(4),dN_ksi(4),xj(ndm,2),x(ndm,*),detj,xjinv(ndm,2)
8: real*8 dNx(4),dNy(4),s(nst,nst),u(nst),p(nst)
9: goto (100,200) isw
10: 100 continue
11: read (nin,*) e(1), e(2)
12: return
13: 200 continue
14: me = e(1)
15: cp = e(2)
16: a = 1+cp
17: b = a*(1-2*cp)
18: c = me*(1-cp)/b
19: d11 = c
20: d12 = me*cp/b
21: d21 = d12
22: d22 = c
23: d33 = me/(2*a)
24: c **** montagem da matriz de rigidez
25: do j=1, nst
26: do i=1, nst
27: s(j,i)=0
28: enddo
29: enddo
30: do j=1, 2
31: do i=1, 2
32: if (j.eq.1.and.i.eq.1) then
33: eta_eta=0.577350269189626
34: ksi_ksi=-0.577350269189626
35: else if (j.eq.1.and.i.eq.2) then
36: eta_eta=0.577350269189626
37: ksi_ksi=0.577350269189626
38: else if (j.eq.2.and.i.eq.1) then
39: eta_eta=-0.577350269189626
40: ksi_ksi=0.577350269189626
41: else if (j.eq.2.and.i.eq.2) then
42: eta_eta=-0.577350269189626
43: ksi_ksi=-0.577350269189626
44: endif
45: c **** derivadas das funcoes de interpolacao em relacao a eta
46: dN_eta(1)=(1+ksi_ksi)/4
47: dN_eta(2)=-(1+ksi_ksi)/4
48: dN_eta(3)=-(1-ksi_ksi)/4
 24

49: dN_eta(4)=(1-ksi_ksi)/4
50: c **** derivadas das funcoes de interpolacao em relacao a ksi
51: dN_ksi(1)=(1+eta_eta)/4
52: dN_ksi(2)=(1-eta_eta)/4
53: dN_ksi(3)=-(1-eta_eta)/4
54: dN_ksi(4)=-(1+eta_eta)/4
55: c **** montagem da matriz jacobiana
56: do k=1,2
57: xj(1,k)=0
58: xj(2,k)=0
59: do l=1,4
60: xj(1,k)=xj(1,k)+dN_eta(l)*x(k,l)
61: xj(2,k)=xj(2,k)+dN_ksi(l)*x(k,l)
62: enddo
63: enddo
64: c **** calculo do determinante da matriz jacobiana
65: detj = xj(1,1)*xj(2,2)-xj(2,1)*xj(1,2)
66: c **** obtendo a inversa da matriz jacobiana
67: xjinv(1,1)=xj(2,2)/detj
68: xjinv(1,2)=-xj(1,2)/detj
69: xjinv(2,1)=-xj(2,1)/detj
70: xjinv(2,2)=xj(1,1)/detj
71: c **** derivadas das funcoes de interpolacao com relacao a x e a y

Sub-Rotina para Calcular a Norma de Energia

3: subroutine normaenergia (a,b,jdiag,neq)

4: implicit real*8 (a-h,o-z)
5: integer i,neq
6: real*8 va(neq),norma_energia
7: dimension a(*),b(*),jdiag(*)
8: do i=1,neq
9: va(i)=b(i)
10: enddo
11: call prodmatvet(jdiag,a,va,neq)
12: norma_energia = (prodvetvet(va,b,neq))**(0.5)
13: write (*,'(a,F8.6)') "Solver iterativo. |u| =", norma_energia
14: end

Sub-Rotina para o Produto Matriz x Vetor no Formato Skyline

3: subroutine prodmatvet (jdiag,a,y,neq)

4: implicit real*8 (a-h,o-z)
5: integer i,j,k,m,neq
6: real*8 y(neq),va(neq)
7: dimension a(*),jdiag(*)
8: do i=1,neq
9: va(i)=0
10: enddo
 25

11: va(1)= a(1)*y(1)

12: do i=2, neq
13: j= jdiag(i)
14: c **** produto da diagonal principal
15: va(i)= va(i) + a(j)*y(i)
16: c **** altura de cada coluna
17: k= jdiag(i)-jdiag(i-1)-1
18: c **** loop para produto fora da diagonal
19: do m=1, k
20: c **** produto da parte superior da matriz
21: va(i-m)= va(i-m) + a(j-m)*y(i)
22: c **** produto da parte inferior da matriz
23: va(i)= va(i) + a(j-m)*y(i-m)
24: enddo
25: enddo
26: y = va
27: end

Sub-Rotina para o Método dos Gradientes Conjugados

3: c metodo dos gradientes conjugados com pre-condicionador diagonal

4: subroutine gc(a,b,jdiag,neq)
5: implicit real*8 (a-h,o-z)
6: parameter (imax = 1000)
7: integer i/0/,neq,j,k
8: dimension a(*),b(*),jdiag(*)
9: real*8 x(neq),r(neq),Minv(neq),d(neq),delta_novo,delta_zero
10: real*8 q(neq),alfa,s(neq),delta_antigo,beta,vaux(neq)
11: do k=1,neq
12: x(k)=0
13: j=jdiag(k)
14: Minv(k)=1/(a(j))
15: enddo
16: vaux=x
17: call prodmatvet(jdiag,a,vaux,neq)
18: do k=1,neq
19: r(k)=b(k)-vaux(k)
20: d(k)=Minv(k)*r(k)
21: enddo
22: delta_novo=prodvetvet(r,d,neq)
23: delta_zero=delta_novo
24: do while(i.lt.imax.and.delta_novo.gt.delta_zero*10E-6**2)
25: vaux=d
26: call prodmatvet(jdiag, a, vaux, neq)
27: q=vaux
28: alfa=delta_novo/prodvetvet(d,q,neq)
29: do k=1,neq
30: x(k)=x(k)+alfa*d(k)
31: enddo
32: if (i.gt.50.and.mod(i,50)*50.eq.i) then
 26

33: vaux=x
34: call prodmatvet(jdiag,a,vaux,neq)
35: do k=1,neq
36: r(k)=b(k)-vaux(k)
37: enddo
38: else
39: do k=1,neq
40: r(k)=r(k)-alfa*q(k)
41: enddo
42: endif
43: do k=1,neq
44: s(k)=Minv(k)*r(k)
45: enddo
46: delta_antigo=delta_novo
47: delta_novo=prodvetvet(r,s,neq)
48: beta=delta_novo/delta_antigo
49: do k=1,neq
50: d(k)=s(k)+beta*d(k)
51: enddo
52: i=i+1
53: enddo
54: do k=1,neq
55: b(k)=x(k)
56: enddo
57: call normaenergia (a,b,jdiag,neq)
58: end

Sub-Rotina para Escrever o Arquivo de Saída no Formato VTK

3: c Saida para o paraview

4: subroutine wdata(ix,id,x,f,u,nnode,numel,ndm,nen,ndf,nout)
5: integer nnode,numel,ndm,nen,ndf,ix(nen+1,*),id(ndf,*),numelt
6: real*8 x(ndm,*),f(ndf,*),u(*),aux(6),nnorm
7: write(nout,'(a)') '# vtk DataFile Version 3.0'
8: write(nout,'(a)') 'Malha de elementos finitos'
9: write(nout,'(a)') 'ASCII'
10: write(nout,'(a)') 'DATASET UNSTRUCTURED_GRID'
11: write(nout,'(a,i8,a)') 'POINTS',nnode,' double'
12: do i = 1, nnode
13: write(nout,'(3e15.5)') (x(j,i),j=1,2),0.0
14: enddo
15: if( nen .eq. 3 ) numelt = numel*4
16: if( nen .eq. 4 ) numelt = numel*5
17: write(nout,'(a,i10,i10)') 'CELLS ', numel, numelt
18: do i = 1, numel
19: if(nen.eq.3)write(nout,'(10i10)') 3,(ix(j,i)-1,j=1,nen)
20: if(nen.eq.4)write(nout,'(10i10)') 4,(ix(j,i)-1,j=1,nen)
21: enddo
22: write(nout,'(a,i8)') 'CELL_TYPES ',numel
23: do i = 1, numel
 27

24: if(nen.eq.3)write(nout,'(i10)') 5
25: if(nen.eq.4)write(nout,'(i10)') 9
26: enddo
27: write(nout,'(a,i8)') 'CELL_DATA ',numel
28: write(nout,'(a)') 'SCALARS mesh_mat int'
29: write(nout,'(a)') 'LOOKUP_TABLE default'
30: do i = 1, numel
31: write(nout,'(i10)') ix(nen+1,i)
32: enddo
33: write(nout,'(a,i8)') 'POINT_DATA ',nnode
34: write(nout,'(a)') 'VECTORS Deslocamentos double'
35: do i = 1, nnode
36: do j = 1, ndf
37: aux(j) = f(j,i)
38: k = id(j,i)
39: if(k .gt. 0) aux(j) = u(k)
40: enddo
41: write(nout,'(3e15.5)') (aux(j),j=1,ndf),0.0
42: enddo
43: return
44: end