Você está na página 1de 44

INSTITUTO TECNOLÓGICO DE AERONAÚTICA

PROF. JOÃO L. F. AZEVEDO

CC-297
Elementos de Mecânica dos Fluidos
Computacional
Projeto No.2

ALEXANDRE FELIPE MEDINA CORRÊA

São José dos Campos – SP – Brasil


Lista de ilustrações

Figura 1 – Matriz tridiagonal periódica. . . . . . . . . . . . . . . . . . . . . . . . . 5


Figura 2 – Breve esquema para resolução do algorítmo de Thomas. . . . . . . . . 6
Figura 3 – Figura de estêncil para o método implícito de direção alternada, ADI,
em equações de diferenças finitas. Retirado de [8]. . . . . . . . . . . . . 8
Figura 4 – Análise do resíduo de cada método iterativo para geração de malha
para cilíndro circular. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Figura 5 – Obtenção da malha parabólica (esq.) e elíptica (dir.) para cilíndro
circular bidimensional com método AF1. . . . . . . . . . . . . . . . . . 13
Figura 6 – Obtenção da malha parabólica (esq.) e elíptica (dir.) para cilíndro
circular bidimensional com método AF1. . . . . . . . . . . . . . . . . . 14
Figura 7 – Análise do resíduo de cada método iterativo para geração de malha
para aerofólio biconvexo. . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Figura 8 – Obtenção da malha parabólica (esq.) e elíptica (dir.) para aerofólio
biconvexo com método AF1. . . . . . . . . . . . . . . . . . . . . . . . . 15
Figura 9 – Obtenção da malha parabólica (esq.) e elíptica (dir.) para aerofólio
biconvexo com método AF1. . . . . . . . . . . . . . . . . . . . . . . . . 16
Figura 10 – Obtenção da malha parabólica (esq.) e elíptica (dir.) para aerofólio
NACA 0012 com método AF1. . . . . . . . . . . . . . . . . . . . . . . 16
Figura 11 – Análise do resíduo de cada método iterativo para geração de malha
para aerofólio NACA 0012. . . . . . . . . . . . . . . . . . . . . . . . . 17
Figura 12 – Obtenção da malha parabólica (esq.) e elíptica (dir.) para aerofólio
NACA 0012 com método AF1. . . . . . . . . . . . . . . . . . . . . . . 17
Figura 13 – Obtenção da malha elíptica sem estiramento (esq.) e com estiramento
com taxa de crescimento de 1, 15 (dir.) para aerofólio NACA 0012 com
método AF1. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
Figura 14 – Obtenção da malha elíptica sem estiramento (esq.) e com estiramento
com taxa de crescimento de 1, 15 (dir.) para aerofólio NACA 0012 com
método AF1. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
Figura 15 – Análise do resíduo de cada método iterativo para geração de malha
para aerofólio NACA0012 com e sem estiramento da fronteira interna. . 19
Figura 16 – Obtenção da malha elíptica sem estiramento para aerofólio NACA 0012
com método AF2, utilizando α = 1, 3. . . . . . . . . . . . . . . . . . . 20
Figura 17 – Análise do resíduo do método AF2 para geração de malha para aerofólio
NACA0012 para diferentes fatores de aceleração. . . . . . . . . . . . . 20
Sumário

1 CONTEXTUALIZAÇÃO . . . . . . . . . . . . . . . . . . . . . . . . . 1

2 METODOLOGIA . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
2.1 Implementação de Malhas Parabólicas . . . . . . . . . . . . . . . . . 2
2.2 Implementação de Malhas Elípticas . . . . . . . . . . . . . . . . . . . 7
2.2.1 Método AF1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2.2 Método SLOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.2.3 Método AF2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

3 RESULTADOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.1 Caso I: Cilíndro Bidimensional . . . . . . . . . . . . . . . . . . . . . . 12
3.2 Caso II: Aerofólio Biconvexo . . . . . . . . . . . . . . . . . . . . . . . 14
3.3 Caso III: Aerofólio NACA 0012 . . . . . . . . . . . . . . . . . . . . . 16
3.3.1 Estiramento na Parede . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.3.2 Estabilidade AF2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

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

REFERÊNCIAS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

APÊNDICES 23

APÊNDICE A – CÓDIGO COMPUTACIONAL . . . . . . . . . . . 24


1

1 Contextualização

Como vimos durante o avanço do curso, utilizamos equações diferenciais parciais para
modelar o comportamento de nosso fluido. Para tal análise o domínio a ser avaliado
é então discretizado em pequenos subdomínios, que podem ter formas variadas, desde
pequenos triângulos e quadriláteros para casos bidimensionais, a tetraédros e hexágonos
para casos tridimensionais, entre outros elementos geométricos. As equações que modelam
a física do fenômeno são então discretizadas e resolvidas em cada um desses subdomínios.
Esses subdomínios podem ser chamados de elementos ou células, e o conjunto de todos as
células células computacionais é chamado de malha. A origem do termo malha remonta às
primeiras análises realizadas em CFD, quando a maioria das análises eram de natureza
bidimensional. Para análises 2D, um domínio dividido em elementos se assemelha a uma
malha de arame, daí o nome.
Nosso objetivo é gerar uma malha bidimensional, para uso em futuras análises
utilizando o método de potencial completo. Para isso devemos gerar uma malha adequada,
afinal, nossa solução é tão boa quanto nossa malha. Nesse estudo avaliaremos malhas
elípticas, inicializadas a partir de malhas parabólicas. Esta é escolhida para garantir um
certo nível de ortogonalidade em nossa malha, que depois é suavizada através do método
elíptico, como veremos nos capítulos a seguir.
A análise apresentada neste documento foi realizada através de um código escrito
para o ambiente MATLAB, porém todas as funções utilizadas foram escritas pelo autor.
2

2 Metodologia

Esse capítulo tem como objetivo realizar uma breve descrição do modelamento do problema.
Nossa abordagem parte primariamente de uma análise de geração de malhas parabólicas,
em seguida partimos para a descrição da geração de malhas elípticas. Em seguida são
apresentados os métodos iterativos utilizados.

2.1 Implementação de Malhas Parabólicas


Partimos primeiramente da análise de malhas parabólicas, como apresentado no
trabalho de [1]. O equacionamento de malhas elípticas e parabólicas é similar entre si, já
que em ambos os casos solucionamos uma equação de Poisson. Porém, fazemos aqui uma
análise no domínio computacional (ξ, η). Na nossa análise, ξ e η são variáveis dependentes
enquanto tratamos x e y como variáveis independentes. Portanto:

Arξξ − 2Brξη + Crηη + D(P rξ + Qrη ) = 0 (2.1)

Onde na equação 2.1, r representa tanto x quanto y, de modo que o usamos para
facilitar nossa análise. Neste caso temos que:

A = x2ξ + yξ2 B = x ξ xη + y ξ y η (2.2)

C = x2η + yη2 D = (xξ yη − yξ xη )2 (2.3)

P e Q observadas na equação 2.1 são especificadas pelo usuário para concentração


de pontos de malha em determinadas regiões, porém não serão abordados neste relatório,
sendo tratados como nulos. Portanto, chegamos a:

Arξξ − 2Brξη + Crηη = 0 (2.4)

Equação que pode ser aplicada tanto para malhas elípticas quanto para malhas
parabólicas. Como veremos futuramente, geradores de malhas elípticas necessitam ser
inicializados por ’campo’ inicial para variáveis x e y. Portanto, abordaremos primeiramente
a malha parabólica, que será utilizada como malha inicial para o gerador elíptico. Assim,
Capítulo 2. Metodologia 3

como explicado em [1], nosso primeiro passo é discretizar as derivadas da equação 2.4
através de um esquema centrado de segunda ordem. De modo que podemos chegar a:

B
A(ri+1,j − 2ri,j + ri−1,j ) = (ri+1,j+1 − ri+1,j−1 − ri−1,j+1 + ri−1,j−1 )−
2 (2.5)
C(ri,j+1 − 2ri,j + ri,j−1 )

Que pode ser rearranjada como:

2Ari+1,j − 4(A + C)ri,j + 2Ari−1,j =


(2.6)
B(ri+1,j+1 − ri+1,j−1 − ri−1,j+1 + ri−1,j−1 ) − 2C(ri,j+1 + ri,j−1 )

Onde i representa o índice na direção ξ e j na direção η. Podemos observar da


equação 2.6 que chegamos a um sistema tridiagonal dado pelo lado esquerdo da equação,
onde podemos escrever:

2Ari+1,j − 4(A + C)ri,j + 2Ari−1,j = B(2A, −4(A + C), 2A)ri,j (2.7)

Temos assim uma tridiagonal em i para cada j avaliado. Das equações 2.6 e 2.7
vemos que dependemos de termos j − 1 e j + 1. Se aplicamos condições de contorno nas
fronteiras interna e externa, ou seja, condições de variável imposta ou Dirichlet, então
conhecemos o valor j − 1 para j = 2, pois j = 1 corresponde à minha fronteira interna.
Já j + 1 é desconhecido e precisa ser estimado, portanto fazemos uso de uma malha de
referência local, método proposto por [2]. A malha de referência local é gerada por um
esquema hiperbólico algébrico, que necessita inicialmente da especificação da inversa do
Jacobiano J −1 e da métrica de ortogonalidade B, dados respectivamente por:

J −1 = xξ yη − xη yξ B = xξ xη + yη yξ (2.8)

De modo que as derivadas em η para a malha re referência local são dadas por:

−yξ Sη xξ S η
xη = q yη = q (2.9)
x2ξ + yξ2 x2ξ + yξ2

Onde consideramos η nossa direção de malha, ou seja, a cada iteração em j,


calculamos todos os i pela tridiagonal, ou seja, determinamos os pontos ξ da linha
η = constante. Também impomos que neste caso a malha de referência local é ortogonal
fazendo B = 0 na equação 2.8. Na equação 2.9, S corresponde ao arco para ξ = constante,
de modo que aproximamos sua derivada por:

Sη = ∆sR (2.10)
Capítulo 2. Metodologia 4

Podemos determinar s considerando-o como elemento de uma progressão geométrica


de soma unitária [3], de modo que determinamos seu primeiro elemento como:

(q − 1)
s1 = (2.11)
(q Nj − 1)

sj+1 = sj + q ∗ (sj − sj−1 ) (2.12)

Assim, conhecida a taxa de crescimento da malha, q, podemos determinar todos os


termos da P.G., sabendo que trata-se de uma P.G. normalizada para somatório unitário.
Já R, apresentado na equação 2.10, trata-se da distância entre o ponto (i, j − 1) até a
fronteira exterior em (i, Nj ). Já ∆s é dada por:

sj − sj−1
∆s = (2.13)
sN j − sj−1
q
R= (xi,N j − xi,j−1 )2 + (yi,N j − yi,j−1 ) (2.14)

Também determinamos, para η = constante, a derivada na direção ξ, considerando


um esquema centrado de primeira ordem:

1
rξ = (ri+1,j−1 − ri−1,j−1 ) (2.15)
2
De modo que a derivada em ξ depende da malha em j − 1, ou seja, a malha
parabólica da linha anterior. Assim, através das equações 2.9 a 2.15, podemos determinar
a parcela ortogonal de nossa malha de referência local, dada por:


ri,j = ri,j−1 + rη (2.16)

Lembrando, mais uma vez, que r representa tanto x quanto y. Podemos também
determinar nossa malha interpolada dada por:

i
ri,j = ri,j−1 + ∆s(ri,N j − ri,j−1 ) (2.17)

Determinados r◦ e ri , podemos prosseguir com o cálculo de nossa malha de referência


local, que pode ser considerada como nosso passo preditor do esquema para malha
parabólica. Portanto:

i ◦
ri,j = εri,j + (1 − ε)ri,j (2.18)
Capítulo 2. Metodologia 5

Sendo ε uma função que alterna entre a fronteira interna e externa de modo a
garantir a malha ortogonal ao aerofólio, podendo ser escrita da forma:

j−1
ε= (2.19)
Nj − 1

E assim, determinamos nossa malha de referência local para ri,j . É importante


ressaltar que fazemos todo esse processo para η = constante e que calculamos tal malha
para os termos j e j + 1 como passo preditor, para depois realizar o cálculo corretor para
obtenção da malha parabólica em j. Antes disso, é preciso do cálculo dos coeficientes A,B,
e C, que são calculados utilizando agora a malha de referência local em j + 1 para nosso
esquema centrado de primeira ordem.

1
rξ = (ri+1,j+1 − ri−1,j+1 ) (2.20)
2
Já as derivadas em η, como descrito por [1], podem ser calculadas da seguinte
forma, também utilizando a malha de referência local:

rη = ri,j+1 − xi,j (2.21)

Assim, determinados os coeficientes A,B, e C, retornamos à equação 2.6, determi-


nando nossa matriz tridiagonal pela equação 2.22, para calcular através de nosso passo
corretor a malha parabólica.

2Ari+1,j − 4(A + C)ri,j + 2Ari−1,j = B(2A, −4(A + C), 2A)ri,j (2.22)

Neste caso, a malha tridiagonal se trata de uma tridiagonal periódica, já que nosso
elemento r1,j corresponde ao mesmo elemento rN i,j , de modo que o algorítmo de Thomas
[4], descrito a seguir, não pode ser utilizado para a marcha em η.

Figura 1 – Matriz tridiagonal periódica.


Capítulo 2. Metodologia 6

Assim, o que fazemos é aplicar um novo método, compatível com a solução de


tridiagonais periódicas. Nesse caso podemos fazer uso do algorítmo de Sherman-Morrison
[5] para evitar operações adicionais da eliminação Gaussiana e ainda sim utilizar o algorítmo
de Thomas, já discuto em nosso Projeto N o.1.

Figura 2 – Breve esquema para resolução do algorítmo de Thomas.

O que o algorítmo de Sherman-Morrison faz é basicamente secionar nossa matriz


tridiagonal periódica numa matriz tridiagonal somada a uma matriz esparsa que possui,
em suas extremidades nordeste e sudoeste os elementos que garantem a periodicidade.
Capítulo 2. Metodologia 7

Escrevemos portanto:

(A)x = (A0 + uv T )x = d (2.23)

Onde os vetores que formam a matriz de periodicidade podem ser escritos como:

uT = [−b1 0 ... 0 cn ]
−a1 (2.24)
v T = [1 0 ... 0 ]
b1

De modo que:

A0 = A − uv T (2.25)

E, segundo o método de Sherman-Morrison, fazemos:

A0 y = d
(2.26)
A0 q = u

Utilizamos o algorítmo de Thomas para determinar os vetores y e q. Estes vetores


são então utilizados para resolver a equação 2.23 fazendo:

vT y
x=y− ·q (2.27)
1 + vT q
A partir do algorítmo de Sherman-Morrison então determinamos então r1:N i,j , ou
seja, determinamos nossa linha η = constante, que corresponde à nossa malha parabólica,
e seguimos marchando em η até chegarmos à linha j = N j − 1 anterior à fronteira externa.

2.2 Implementação de Malhas Elípticas


Determinada portanto a nossa malha inicial, que neste caso é parabólica e obtida
pelo procedimento apresentado anteriormente, então podemos agora partir para o cálculo de
nossa malha elíptica. Vimos que, para isso teremos de resolver a equação 2.1, inicialmente
para P e Q nulos, chegando à equação 2.4. Para a solução numérica destas equações
utilizamos um método de relaxação, fazendo uso da forma padrão de correção, ou forma
delta. Definimos nosso operador resíduo como:

L ( )i,j = [Ai,j δξξ − 2Bi,j δξη + Ci,j δηη ] (2.28)


Capítulo 2. Metodologia 8

Onde os operadores derivadas, de primeira e segunda ordem, são dados através do


método de diferenças finitas, utilizando esquema centrado de segunda ordem. É importante
ressaltar que, no espaço computacional (ξ, η), ∆ξ e ∆η são unitários. Definido o operador
resíduo, podemos então escrever a forma delta de correção [6, 7].

n n
N · ∆ri,j + ωLri,j =0 (2.29)

Onde ω é o parâmetro de relaxação. Definido nosso operador resíduo, para a


correção delta falta agora determinar o operador correção N . Neste estudo utilizamos
três diferentes métodos iterativos: AF 1 ou ADI (Alternating Direction Implicit Method),
SLOR (Successive Line Over-relaxation), e finalmente o método AF 2.

2.2.1 Método AF1


O primeiro método que iremos avaliar é o ADI, ou também conhecido como AF1.
O ADI é um método de diferenças finitas para solução de equações parciais diferenciais
parabólicas, hiperbólicas e elípticas, ou seja, tem aplicação para nosso problema. Ele é
um exemplo de esquemas de fatoração aproximada. A vantagem do método ADI é sua
capacidade de resolver as equações de interesse por passos, numa estrutura simples e pode
ser resolvido eficientemente através de matrizes tridiagonais. A estrutura de cálculo para o
método pode ser melhor observada na Figura 3.

Figura 3 – Figura de estêncil para o método implícito de direção alternada, ADI, em


equações de diferenças finitas. Retirado de [8].
Capítulo 2. Metodologia 9

O operador correção para o método ADI pode ser escrito da seguinte forma:

1  
N ( )i,j = − α − Ani,j δξξ α − Ci,j
n
δηη ( )i,j (2.30)
α
Onde α representa aqui o parâmetro de aceleração de convergência. Podemos aplicar
a equação 2.30 na equação 2.29 para obter a equação de solução de nossa malha. Desse
modo chegamos a:

1  
− n
α − Ani,j δξξ α − Ci,j n
δηη ∆ri,j n
+ ωLri,j =0 (2.31)
α
Como comentado, o método ADI é um método de fatoração aproximada. Portanto
dividimos a equação 2.31 em dois estágios de cálculo. Para uma malha parabólica marcha-
mos no espaço, na direção η, portanto, selecionamos nosso estágio de modo a primeiro
resolver a direção ξ para depois resolver a direção η da forma:

 
α − Ani,j δξξ Ki,j
n n
= αωLri,j
  (2.32)
n n n
α − Ci,j δηη ∆ri,j = Ki,j

Assim, fazendo a varredura do primeiro estágio, em ξ, fazemos o seguinte:

 
α − Ani,j δξξ Ki,j
n n
= αωLri,j (2.33)

n
αKi,j − Ani,j Ki+1,j
n
+ 2Ani,j Ki,j
n
− Ani,j Ki−1,j
n n
= αωLri,j (2.34)

A varredura em ξ, para a linha η = constante é feita para 1 ≤ i ≤ N i − 1, pois


temos uma matriz periódica e sabemos que r1,j = rN i,j . Para o passo n, escrevemos:

 
B −Ani,j , α + 2Ani,j , −Ani,j Ki−1,j
n n
= αωLri,j (2.35)

Chegamos portanto à nossa primeira matriz tridiagonal, que, neste caso, é uma
matriz periódica pois avaliamos na direção ξ. Assim, a solução é dada resolvendo o
algorítmo de Sherman-Morrison, discutido nas equações 2.23 a 2.27. Realizada a varredura
em ξ, fazemos o mesmo para η, agora utilizando a seguinte tridiagonal:

 
n n n n n
B −Ci,j , α + 2Ci,j , −Ci,j ∆ri,j = Ki−1,j (2.36)

Agora fazemos a varredura para 2 ≤ i ≤ N j − 1, pois são conhecidas as fronteiras


em j = 1 e j = N j, aplicadas pela condição de contorno de Dirichlet. A tridiagonal
Capítulo 2. Metodologia 10

acima pode ser resolvida utilizando o algorítmo de Thomas, pois neste caso não existe
periodicidade. Foram realizados alguns testes numéricos e nâo foi encontrada diferença ao
se inverter a ordem dos estágios, a solução foi encontrada para mesmo resíduo em mesmo
número de iterações gastas, também para ordem:

 
n n n
α − Ci,j δηη Ki,j = αωLri,j
  (2.37)
α − Ani,j δξξ ∆ri,j
n n
= Ki,j

2.2.2 Método SLOR


Para o método SLOR, no domínio computacional, podemos escrever:

" #
  δ ξξ
N ( )i,j = Eη−1 − 2/α + ( )i,j (2.38)
α

Onde temos agora o operador δ ξξ , definido por:

δ ξξ ( )i,j = ( )i+1,j − 2( )i,j + ( )i−1,j (2.39)

n
Portanto, escrevemos para nosso método aplicado em ∆ri,j a seguinte equação, que
representa o cálculo da correção tanto para x quanto y.

n n n
B(−1, 4, −1)∆ri,j = αωLri,j + α∆ri,j−1 (2.40)

Mais uma vez, chegamos a uma matriz tridiagonal periódica, que pode ser resolvida
através do algorítimo de Sherman-Morrison, já discutido no tratamento de nossa malha
periódica. Comparado ao passo anterior temos um método relativamente simples, e que
depende do cálculo de apenas uma matriz tridiagonal periódica. Porém, equanto o cálculo
de ∆r em i é feito considerando i − 1 e i + 1, o cálculo em j considera apenas j − 1. Porém,
há de ressaltar que apesar de o cálculo se tornar mais barato por iteração, isso não o torna
necessariamente mais robusto.

2.2.3 Método AF2


O método AF2 é derivado do método AF1, porém ao invés de utilizar dois operadores
derivadas em esquema centrado de segunda ordem, ele o transforma em dois operadores
de primeira ordem, um forward e outro backward, de modo que podemos escrever:

δηη = ∆η ∇η (2.41)
Capítulo 2. Metodologia 11

Assim, o operador correção para o método AF2 pode ser escrito da seguinte forma:

1 n
 
N ( )i,j = − α − Ci,j ∆η α∇η − Ani,j δξξ ( )i,j (2.42)
α
De forma similar ao método ADI, o método AF2 também é um método de fatoração
aproximada. Portanto dividimos a equação 2.31 em dois estágios de cálculo. Porém,
diferentemente do caso anterior, temos agora somente uma matriz tridiagonal. Assim,
podemos escrever os estágios para o método da forma:

 
n n n
α − Ci,j ∆η Ki,j = αωLri,j
  (2.43)
α∇η − Ani,j δξξ ∆ri,j
n n
= Ki,j

Assim, fazendo a varredura do primeiro estágio, em η, fazemos o seguinte:

n n n n n
(α + Ci,j )Ki,j − Ci,j Ki+1,j = αωLri,j (2.44)

n n
n αωLri,j + (α + Ci,j )
Ki,j = n
(2.45)
(α + Ci,j )

Dessa forma, resolvemos o primeiro estágio varrendo j de N j − 1 a 2, reversamente.


Poderíamos inverter o operador ∆η por ∇η no primeiro estágio, de modo que a varredura
seria feita de 2 a N j − 1, sem prejuízo algum.
A varredura em ξ, para o segundo estágio, na linha η = constante é feita para
1 ≤ i ≤ N i − 1, pois temos uma matriz periódica e sabemos que r1,j = rN i,j . Para o passo
n, escrevemos:

 
B −Ani,j , α + 2Ani,j , −Ani,j ∆ri,j
n n
= Ki,j n
+ α∆ri,j−1 (2.46)

Como o método AF2 utiliza somente uma matriz tridiagonal isso o torna mais
barato de se resolver que o método AF1. Porém, não necessariamente ser menos custoso
o torna mais robusto, ou até mesmo mais rápido. Isso é portanto um caso de estudo
que é interessante avaliar. Assim, cada esquema foi brevemente apresentado, e como
resolvê-los considerando nosso domínio computacional bidimensional. Também vimos que
o método iterativo necessita ser iniciado, neste caso utilizando uma malha parabólica.
Assim utilizamos o domínio computacional (ξ, η) para solucionar nosso domínio real (x, y),
de modo a obter nossa malha elíptica. Mostraremos, no capítulo que segue a obtenção das
malhas parabólicas e elípticas para diferentes geometrias bidimensionais, partindo de um
cilíndro bidimensional à aerofólios, de modo que avaliaremos os métodos aqui descritos.
12

3 Resultados

Neste capítulo apresentamos as diferentes malhas e métodos iterativos implementados no


código computacional. Para o código, anexo a este relatório, o usuário necessita determinar
a geometria de interesse, que compreende o cilíndro bidimensional, aerofólio biconvexo e
aerofólio NACA 00XX, onde o usuário pode escolher a classe do último especificando sua
espessura. Em seguida, o usuário impões o número de pontos (N i) para discretização da
fronteira e o número de linhas paralelas (N j) à fronteira até a fronteira externa. Existem
dois procedimentos de parada do código, impostos pelo usuário: a magnitude do resíduo e
o número máximo de iterações a serem executadas.
A seguir, serão apresentados os resultados que demonstram as capacidades do
código computacional desenvolvido.

3.1 Caso I:Cilíndro Bidimensional


Para o primeiro caso, avaliamos as capacidades do código na geração de uma
malha para um cilíndro circular bidimensional. O teste indicaria, com facilidade, se a
implementação do código havia sido feita de forma correta. Para a malha parabólica foi
selecionada uma taxa de crescimento q = 1, 5. Para a malha elíptica todos os métodos
iterativos possuem ω = 1, enquanto os métodos AF1 e AF2 possuem α = 0, 1 e α = 1, 6.
O método AF2 se mostrou extremamente sensível ao valor de α, enquanto o método AF1
se mostrou estável. Se consideramos α inversamente proporcional a um passo de tempo
virtual, isso mostra que o método AF1 conseguiu avançar mesmo para um alto passo de
tempo. O método SLOR necessitou de um fator de relaxação r = 1, 15 (α).
Dentre os métodos iterativos, o AF1 apresentou melhor desempenho, como mostrado
na figura 4. Apesar de ser o método mais caro, por iteração, devido às duas matrizes
tridiagonais que necessitam de serem resolvidas, o mesmo alcançou um resíduo equivalente
ao erro de máquina do computador em menos de 5000 iterações, enquanto seu par, AF2
necessitou aproximadamente 11000 iterações, mais do que o dobro que o anterior. O método
SLOR apresentou o pior desempenho, chegando a quase 30000 iterações necessárias para
atingir erro de máquina. É importante ressaltar que o parâmetro de relaxação α tem
papel fundamental no excelente desempenho do método AF1, enquanto os métodos AF2 e
SLOR se mostraram sensíveis ao mesmo, e portanto tiveram um desempenho pobre em
comparação.
Capítulo 3. Resultados 13

Figura 4 – Análise do resíduo de cada método iterativo para geração de malha para
cilíndro circular.

Na figura 5 vemos ambas as malhas parabólica e elíptica obtidas com o método


AF1. Para a parabólica vemos a influência da taxa de crescimento q, onde concentramos
elementos próximos à fronteira interna. Observamos que na malha elíptica essa propriedade
parece ser afetada.

Figura 5 – Obtenção da malha parabólica (esq.) e elíptica (dir.) para cilíndro circular
bidimensional com método AF1.
Capítulo 3. Resultados 14

Ao focarmos na região próxima à fronteira interna, vemos que parte da taxa de


crescimento é perdida, apesar de podermos observar uma pequena taxa de crescimento ao
avaliarmos as distâncias entre cada linha paralela à fronteira. Como nossa fronteira interna
se trata de um cilíndro circular, não vemos grande diferença na qualidade de ambas as
malhas. Neste caso o autor consideraria apenas a malha parabólica para análise, por ser
mais barata e de rápida obtenção.

Figura 6 – Obtenção da malha parabólica (esq.) e elíptica (dir.) para cilíndro circular
bidimensional com método AF1.

3.2 Caso II: Aerofólio Biconvexo


Para o segundo caso a geometria utilizada foi o aerofólio biconvexo. Para a malha
parabólica foi selecionada uma taxa de crescimento q = 1, 5. Para a malha elíptica todos
os métodos iterativos possuem ω = 1, enquanto os métodos AF1 e AF2 possuem α = 0, 1
e α = 1, 9. O método AF2 se mostrou, novamente, sensível ao valor de α, enquanto o
método AF1 se mostrou estável. O método SLOR necessitou de um fator de relaxação
1, 05, e apresentou instabilidade para outros valores.
Devido à nova geometria, mais complexa e com presença de descontinuidades nos
bordos, o método AF1 necessitou mais iterações para alcançar erro de máquina, comparado
ao cilíndro circular. Foram necessárias aproximadamente 25000 iterações. Novamente os
métodos AF2 e SLOR tiveram pior desempenho, com aproximadamente 15000 e 250000
iterações para atingir erro de máquina, como mostrado na figura 7
Capítulo 3. Resultados 15

Figura 7 – Análise do resíduo de cada método iterativo para geração de malha para
aerofólio biconvexo.

Na figura 8 vemos ambas as malhas parabólica e elíptica obtidas com o método


AF1. Para a parabólica vemos a influência da taxa de crescimento q, onde concentramos
elementos próximos à fronteira interna. Observamos, novamente, que na malha elíptica
essa propriedade parece ser afetada, como mostrado na figura 8.

Figura 8 – Obtenção da malha parabólica (esq.) e elíptica (dir.) para aerofólio biconvexo
com método AF1.

Porém, agora ao focarmos nas regiões próximas à fronteira interna podemos ver
Capítulo 3. Resultados 16

a suavização da malha ao redor quando comparada ao caso parabólico. Podemos ver tal
suavização principalmente nas regiões próximas aos bordos de ataque e fuga do aerofólio,
onde a malha tinha elementos de mairo área anteriormente no caso parabólico

Figura 9 – Obtenção da malha parabólica (esq.) e elíptica (dir.) para aerofólio biconvexo
com método AF1.

3.3 Caso III: Aerofólio NACA 0012


Por fim implementamos a geometria para aerofólios simétricos NACA 00XX, onde
avaliamos o NACA 0012. As condições aplicadas para este caso foram as mesmas do caso
biconvexo, para α e ω.

Figura 10 – Obtenção da malha parabólica (esq.) e elíptica (dir.) para aerofólio NACA
0012 com método AF1.
Capítulo 3. Resultados 17

Figura 11 – Análise do resíduo de cada método iterativo para geração de malha para
aerofólio NACA 0012.

Figura 12 – Obtenção da malha parabólica (esq.) e elíptica (dir.) para aerofólio NACA
0012 com método AF1.

Como o NACA 0012 tem uma geometria mais suave em seu bordo de ataque,
aparentemente isso contribui para uma melhor convergência do código, porém, o aumento
do desempenho não chega a ser expressivo, como vemos a seguir. Observa-se melhor ganho
de desempenho para AF2 e SLOR, AF1 permanece praticamente atingindo erro de máquina
de forma similar ao biconvexo. O comportamento obtido para as malhas parabólicas e
Capítulo 3. Resultados 18

elípticas são similares ao caso anterior, biconvexo, quando avaliamos as malhas.

3.3.1 Estiramento na Parede


Em todos os casos anteriores a malha foi igualmente espaçada ao longo da fronteira
interna e externa. Porém, podemos concentrar elementos próximos aos bordos de ataque e
fuga do aerofólio NACA 0012.

Figura 13 – Obtenção da malha elíptica sem estiramento (esq.) e com estiramento com
taxa de crescimento de 1, 15 (dir.) para aerofólio NACA 0012 com método
AF1.

Figura 14 – Obtenção da malha elíptica sem estiramento (esq.) e com estiramento com
taxa de crescimento de 1, 15 (dir.) para aerofólio NACA 0012 com método
AF1.
Capítulo 3. Resultados 19

Para avaliar a redistirbuição dos pontos sobre a fronteira, fazemos uso de uma
P.G. cujo somatório corresponde à meia-corda do aerofólio em análise, e espelhamos a
variação geométrica para obter uma distribuição simétrica ao longo da fronteira interna,
ou seja, do aerofólio em questão. Isso sem alterar a distribuição de pontos da fronteira
externa. Para avaliar o efeito do estiramento na fronteira interna, utilizamos o método AF1
e discretizamos a fronteira utilizando uma P.G. com taxa de crescimento 1.15, conforme
apresentado na figura 13. Quando avaliamos o domínio, percebemos, visualmente, poucas
diferenças entre ambos os casos. Apesar de apresentar uma melhor qualidade, a taxa de
convergência para o método AF1 diminui utilizando o estiramento da malha próximo
à parede, como podemos ver a seguir. Isso ocorre também ao se aumentar a taxa de
estiramento para 1, 30, a despeito da expectativa do autor.

Figura 15 – Análise do resíduo de cada método iterativo para geração de malha para
aerofólio NACA0012 com e sem estiramento da fronteira interna.

3.3.2 Estabilidade AF2


Também é possível apresentar um breve estudo quanto à estabilidade do método
AF2, para avaliação realizada empiricamente. Ao variarmos o parâmetro de aceleração
α considerando que o melhor valor encontrado foi de 1, 9 e compararmos com 1, 6 e 2, 2
percebemos que valores superiores a 1, 9 são estáveis, apesar de apresentarem menor taxa
de convergência, já valores inferiores a 1, 6 são instáveis, levando a resultados como o
mostrado a seguir.
Capítulo 3. Resultados 20

Figura 16 – Obtenção da malha elíptica sem estiramento para aerofólio NACA 0012 com
método AF2, utilizando α = 1, 3.

O resíduo para α = 1, 6 reflete a malha obtida, como vemos a seguir, levando à


rápida divergência. O cálculo é interrompido automáticamente se o resíduo alcança níveis
superiores a 105

Figura 17 – Análise do resíduo do método AF2 para geração de malha para aerofólio
NACA0012 para diferentes fatores de aceleração.
21

4 Conclusões

O objetivo deste projeto era a construção de um código capaz de resolver gerar uma
malha bidimensional elíptica a partir de uma malha parabólica, e que o mesmo fosse
independente da geometria. Objetivo este alcançado, demonstrado pela capacidade do
código em produzir malhas para um cilíndro circular, aerofólio biconvexo e aerofólio NACA
0012 (ou família 00XX).
Entre os métodos AF1, AF2 e SLOR implementados para o código, melhor desem-
penho foi obtido para o método AF1, que se mostrou estável mesmo para um alto passo
de tempo virtual, representado pelo parâmetro de aceleração de convergência α = 0, 1.
Os métodos AF2 e SLOR apresentaram desempenho inferior, comparados a este, e se
mostraram sensíveis ao parâmetro α, diferentemente do caso anterior.
Foi possível alcançar erro de máquina para todos os métodos avaliados, e obter
malhas implícitas de boa qualidade, e suavizadas pelo método elíptico utilizado. Além
disso, foram feitos breves estudos quanto à obtenção de uma malha com estiramento na
fronteira interior, que representa a parede da geometria a ser estudade, e também quanto à
sensibilidade do método AF2 frente ao parâmetro de aceleração, ambos estudos realizados
para o aerofólio NACA 0012.
22

Referências

[1] Uller, M., Azevedo, J. L. F. Grid generation Technique Effects on Transonic Full
Potential Solutions of Airfoil Flows, In.: Anais do XI Congresso Brasileiro de Engenharia
Mecânica - XI COBEM, São Paulo, Brasil, pp. 197–200, 1991.

[2] Noack, R. W., Anderson, D. A. Solution-adaptative Grid Generation Using Parabolic


Partial Differential Equations, AIAA Journal, Vol. 28, No. 6, pp. 1016–1023, 1990.

[3] Azevedo, J. L. F. Notas de Aula: CC-297 Elementos de Mecânica dos Fluidos Compu-
tacional - Projeto No. 2, Instituto Tecnológico da Aeronáutica, Brasil, 2018.

[4] Thomas, L.H. Elliptic Problems in Linear Differential Equations over a Network,
Watson Sci. Comput. Lab Report, Columbia University, New York, 1949.

[5] Conte, S.D., deBoor, C. Elementary Numerical Analysis, McGraw-Hill, New York, 1972

[6] Lomax, H., Pulliam, T. H., Zingg, D. W. Fundamentals of Computational Fluid


Dynamics, Springer-Verlag, Heidelberg, 1st edition, 2001.

[7] Fletcher, C.A.J. Computational Techniques for Fluid Dynamics 1: Fundamentals and
General Techniques, Springer-Verlag, Heidelberg, 2nd edition, 1991.

[8] Wikipedia, the free encyclopedia. Alternating Direction Implicit Method, Acessado em
21 de Abril de 2018, <https://en.wikipedia.org/wiki/Alternating_direction_implicit_
method>
Apêndices
24

APÊNDICE A – Código Computacional

Este apêndice contém as rotinas MATLAB para os geradores de malhas elíptica e


parabólica.
25

% Rotina Template para geração de malhas implícitas


clear
close all
clc
%% Dados de fronteira:
% Fronteira interna:
% Número de pontos da fronteira (qsi):
Ni = 93;
% Taxa de estiramento na fronteira interna em (qsi):
XSF = 1.15;
% Seleção de forma:
% 1 - Aerofólio biconvexo:
% 2 - Cilíndro:
% 3 - Aerofólio NACA 00XX:
sel = 1;
% Espessura do aerofólio:
t = 0.1;
% Corda do aerofólio ou raio interno do cilíndro:
c = 1;
%% Dados iniciais da malha:
% Número de pontos em eta:
Nj = 15;
% Deslocamentos horizontais das fronteiras:
OXi = 0;
OXe = 1.5;
%% Escolha do Esquema de Iteração:
% 1 - AF1
% 2 - SLOR
% 3 - AF2
esc = 1;
%% Escolha do critério de parada:
% 1 - Operador resíduo
% 2 - Sem resíduo: número máximo de passos (máximo de 12000)
% STP corresponde ao resíduo ou critério de parada (1E-6).
% n corresponde ao número de passos máximo (12000).
res = 2;
% Condições de parada:
STP = 1E-4;
N = 50;
%% Cálculo da malha parabólica:
% Determinação da P.G. de crescimento:
% Fator de estiramento em eta:
q = 1.5;
%% Cálculo da malha elíptica:
[Xo,Yo,X,Y,ERR] = A_SOLV(Ni,Nj,sel,t,c,XSF,OXi,OXe,esc,res,STP,N,q);

figure
for ii = 1:Nj
plot(X(ii,1:Ni),Y(ii,1:Ni),'b'); hold on; axis square
end
for ii = 1:Ni
plot(X(1:Nj,ii),Y(1:Nj,ii),'r'); hold on; axis square
end
hold off; grid on; grid minor
xlabel('x')
ylabel('y')
xlim([-10 10]); ylim([-10 10])

figure
semilogy(ERR,'Linewidth',2)
grid on; grid minor
26

function [Xo,Yo,X,Y,ERR] = ...


A_SOLV(Ni,Nj,sel,t,c,XSF,OXi,OXe,esc,res,STP,N,q)
% Função para chamada de cálculo de malha elíptica através de malha inicial
% parabólica.

%% Dados iniciais da malha:


% Obtenção do domínio de cálculo com inserção das fronteiras:
[X,Y] = J_GEOM(sel,Ni,Nj,c,t,OXi,OXe,XSF);

%% Escolha do Esquema de Iteração:


% 1 - AF1
% 2 - SLOR
% 3 - AF2
% Seleção do esquema para cálculo:
if esc == 1
alpha = 0.1;
omega = 1;
fprintf('Método iterativo: AF1.')
fprintf('\n');
elseif esc == 2
alpha = 1.05;
omega = 1;
if sel == 1
alpha = 1.05;
omega = 1;
elseif sel == 2
alpha = 1.15;
omega = 1;
elseif sel == 3
alpha = 1.05;
omega = 1;
end
fprintf('Método iterativo: SLOR.')
fprintf('\n');
elseif esc == 3
if sel == 1
alpha = 1.9;
omega = 1;
elseif sel == 2
alpha = 1.6;
omega = 1;
elseif sel == 3
alpha = 1.9;
omega = 1;
end
fprintf('Método iterativo: AF2.')
fprintf('\n');
end
%% Escolha do critério de parada:
% 1 - Operador resíduo
% 2 - Sem resíduo: número máximo de passos (máximo de 12000)
% STP corresponde ao resíduo ou critério de parada (1E-6).
% n corresponde ao número de passos máximo (12000).
if res == 2
STP = 1/N;
end
%% Cálculo da malha parabólica:
% Visualizar malha parabólica:
% 1 - Executar plot:
graph = 0;
% Chamada da função para cálculo da malha parabólica:
27

[Xo,Yo] = B_NOACK(Ni,X,Nj,Y,q,graph);

%% Cálculo da malha elíptica:


[X,Y,ERR] = F_ELIP(Ni,Xo,Nj,Yo,alpha,omega,N,STP,res,esc);
N = length(ERR);
%% Saída para fim de cálculo:
fprintf('-Fim de cálculo para %d iterações e resíduo %13.12f.',...
N,ERR(N))
fprintf('\n');
fprintf('\n');
end
28

function [X,Y] = B_NOACK(Ni,X,Nj,Y,q,graph)


% Implementação do algorítmo de cálculo para Malha Parabólica segundo os
% trabalhos de B_NOACK & Anderson (1990) e Uller & Azevedo (1991).

%% Cálculo da malha parabólica:


% No cálculo da malha parabólica, marchamos espacialmente em eta, ou seja,
% varíamos jj de 1:Nj.
% Declaração dos termos da P.G.:
s(1:Nj,1) = 0;
% Cálculo do primeiro termo da P.G.:
if q == 1
s(1) = q/Nj;
else
s(1) = (q - 1)/((q^Nj) - 1);
end
% Cálculo dos termos da restantes da P.G.:
for jj = 1:(Nj - 1)
s(jj+1) = q*s(jj);
end
% Loop de cálculo, marchando em eta:
for jj = 2:(Nj-1)
% Cálculo da malha de referência local em eta(jj):
% - Lembrando que a malha é periódica, portanto r(jj,1) = r(jj,Ni)
% Análise em qsi:
% Malha de referência local em eta(jj):
[X,Y] = C_REFLOC(jj,s,X,Y,Ni,Nj);
% Malha de referência local em eta(jj+1):
[X,Y] = C_REFLOC(jj+1,s,X,Y,Ni,Nj);
% Tendo posse da malha de referència local em jj e jj+1:
%% Cálculo da malha parabólica:
Ar(1:Ni) = 0;
Br(1:Ni) = 0;
Cr(1:Ni) = 0;
Dx(1:Ni) = 0;
Dy(1:Ni) = 0;
% Como a malha é periódica, varremos apenas de 1:(Ni-1):
for ii = 1:Ni-1
% Cálculo das derivadas em eta:
% - Esquema forward de primeira ordem:
Xn = X(jj+1,ii) - X(jj,ii);
Yn = Y(jj+1,ii) - Y(jj,ii);
% Cálculo das derivadas em qsi:
% - Esquema centrado de primeira ordem:
if ii == 1
Xq = 0.5*(X(jj+1,ii+1) - X(jj+1,Ni-1));
Yq = 0.5*(Y(jj+1,ii+1) - Y(jj+1,Ni-1));
else
Xq = 0.5*(X(jj+1,ii+1) - X(jj+1,ii-1));
Yq = 0.5*(Y(jj+1,ii+1) - Y(jj+1,ii-1));
end
% Cálculo dos coeficientes para malha parabólica:
Ar(ii) = Xn^2 + Yn^2;
Cr(ii) = Xq^2 + Yq^2;
Br(ii) = Xq*Xn + Yq*Yn;
% Cálculo em X - Vetor resposta:
if ii == 1
Dx(ii) = Br(ii)*(X(jj+1,ii+1) - X(jj+1,Ni-1) - ...
X(jj-1,ii+1) + X(jj-1,Ni-1)) - ...
2*Cr(ii)*(X(jj+1,ii) + X(jj-1,ii));
else
Dx(ii) = Br(ii)*(X(jj+1,ii+1) - X(jj+1,ii-1) - ...
29

X(jj-1,ii+1) + X(jj-1,ii-1)) - ...


2*Cr(ii)*(X(jj+1,ii) + X(jj-1,ii));
end
% Cálculo em Y - Vetor resposta:
if ii == 1
Dy(ii) = Br(ii)*(Y(jj+1,ii+1) - Y(jj+1,Ni-1) - ...
Y(jj-1,ii+1) + Y(jj-1,Ni-1)) - ...
2*Cr(ii)*(Y(jj+1,ii) + Y(jj-1,ii));
else
Dy(ii) = Br(ii)*(Y(jj+1,ii+1) - Y(jj+1,ii-1) - ...
Y(jj-1,ii+1) + Y(jj-1,ii-1)) - ...
2*Cr(ii)*(Y(jj+1,ii) + Y(jj-1,ii));
end
% Os coeficientes A, B, C e a resposta D são utilizadas para
% montar o sistema de matriz tridiagonal, que neste caso é
% periódica.
end
% Obtenção dos valores atualizados de malha parabólica na linha eta:
X(jj,:) = D_SHER(Ar,Cr,Dx,Ni-1);
Y(jj,:) = D_SHER(Ar,Cr,Dy,Ni-1);
end
if graph == 1
figure
for ii = 1:Nj
plot(X(ii,1:Ni),Y(ii,1:Ni))
hold on
axis square
end
for ii = 1:Ni
plot(X(1:Nj,ii),Y(1:Nj,ii))
hold on
axis square
end
hold off
grid on
grid minor
xlabel('x')
ylabel('y')
xlim([-10 10])
ylim([-10 10])
end
end
30

function [X,Y] = C_REFLOC(jj,s,X,Y,Ni,Nj)


% Função para cálculo da malha de referência local.

% Cálculo da malha de referência local em eta(jj):


% - Lembrando que a malha é periódica, portanto r(jj,1) = r(jj,Ni)
% Análise em qsi:
for ii = 2:Ni
% Controle de espaçamento de malha:
ds = (s(jj) - s(jj-1))/(s(Nj) - s(jj-1));
% Distância entre fronteira externa e ponto em eta(jj-1):
RR = sqrt((X(Nj,ii) - X(jj-1,ii))^2 + ...
(Y(Nj,ii) - Y(jj-1,ii))^2);
% Derivativa do arco na direção eta:
Sn = ds*RR;
% Derivadas locais de X e Y na direção qsi:
% - Determinadas por DIFF em esquema centrado de 1a ordem:
if ii == Ni
Xq = 0.5*(X(jj-1,2) - X(jj-1,ii-1));
Yq = 0.5*(Y(jj-1,2) - Y(jj-1,ii-1));
else
Xq = 0.5*(X(jj-1,ii+1) - X(jj-1,ii-1));
Yq = 0.5*(Y(jj-1,ii+1) - Y(jj-1,ii-1));
end
% Derivadas locais de X e Y na direção eta:
Xn = Yq*(-1)*Sn/sqrt((Xq)^2 + (Yq)^2);
Yn = Xq*Sn/sqrt((Xq)^2 + (Yq)^2);
% Cálculo da parcela ortogonal:
Xo = X(jj-1,ii) + Xn;
Yo = Y(jj-1,ii) + Yn;
% Cálculo da parcela interpolada:
Xi = X(jj-1,ii) + ds*(X(Nj,ii) - X(jj-1,ii));
Yi = Y(jj-1,ii) + ds*(Y(Nj,ii) - Y(jj-1,ii));
% Função alternadora:
EE = (jj - 1)/(Nj - 1);
% Ponto de referência local:
X(jj,ii) = EE*Xi + (1 - EE)*Xo;
Y(jj,ii) = EE*Yi + (1 - EE)*Yo;
end
% Implementação da condição periódica em ii = 1:
X(jj,1) = X(jj,Ni);
Y(jj,1) = Y(jj,Ni);
end
31

function [X] = D_SHER(A,C,D,Ni)


% D_SHER realiza o cálculo da Equação de Sherman-Morrison para avaliação
% linha a linha, para malha parabólica.

%% Criação da matriz A:
AA(1:Ni,1:Ni) = 0;
% Contador:
n = 0;
for ii = 1:Ni
n = n + 1;
if ii == 1
AA(ii,Ni) = 2*(A(ii));
AA(ii,n) = 4*(A(ii) + C(ii))*(-1);
AA(ii,n+1) = 2*(A(ii));
elseif ii == Ni
AA(ii,n-1) = 2*(A(ii));
AA(ii,n) = 4*(A(ii) + C(ii))*(-1);
AA(ii,1) = 2*(A(ii));
else
AA(ii,n-1) = 2*(A(ii));
AA(ii,n) = 4*(A(ii) + C(ii))*(-1);
AA(ii,n+1) = 2*(A(ii));
end
end
%% Criação dos vetores u e v:
u(1:Ni,1) = 0;
u(1,1) = 4*(A(1) + C(1))*(-1)*(-1);
u(Ni,1) = 2*(A(Ni));
v(1:Ni,1) = 0;
v(1,1) = 1;
v(Ni,1) = (2*A(1))*(-1)/(4*(A(1) + C(1))*(-1));
%% Cálculo da matriz A':
AL = AA - u*v';
%% Identificação dos coeficientes de A':
M(1:Ni,1) = 0;
N(1:Ni,1) = 0;
O(1:Ni,1) = 0;
for ii = 1:Ni
if ii == 1
M(ii) = 0;
N(ii) = AL(ii,ii);
O(ii) = AL(ii,ii+1);
elseif ii == Ni
M(ii) = AL(ii,ii-1);
N(ii) = AL(ii,ii);
O(ii) = 0;
else
M(ii) = AL(ii,ii-1);
N(ii) = AL(ii,ii);
O(ii) = AL(ii,ii+1);
end
end
%% Cálculo do vetor resposta Y (utilizando o Alg. de E_THOMas):
[Y] = E_THOM(M,N,O,D,Ni);
%% Cálculo do vetor resposta Q (utilizando o Alg. de E_THOMas):
[Q] = E_THOM(M,N,O,u,Ni);
%% Cálculo do vetor resposta do sistema AX = R:
X = Y - ((v'*Y)/(1 + v'*Q))*Q;
X = X';
X = [X X(1)];
end
32

function [S] = E_THOM(a,b,c,R,M)


% E_THOM realiza o cálculo do Algorítmo de E_THOMas para avaliação linha a
% linha.

%% Método Forward Sweep para uso da elminação gaussiana (pivotamento):


for jj = 1:M-1
% Cálculo dos novos coeficientes A, B, C e D:
if jj == 1
c(jj) = c(jj)/b(jj);
R(jj) = R(jj)/b(jj);
else
c(jj) = (c(jj))/(b(jj) - a(jj)*c(jj-1));
R(jj) = (R(jj) - a(jj)*R(jj-1))/(b(jj) - a(jj)*c(jj-1));
end
end
jj = M;
R(jj) = (R(jj) - a(jj)*R(jj-1))/(b(jj) - a(jj)*c(jj-1));
%% Obtenção do vetor de resposta:
% Cálculo do último elemento:
S(M) = R(M);
% Varredura descendente:
for jj=(M-1):-1:1
S(jj) = R(jj) - c(jj)*S(jj+1);
end
%% Conversão de vetor linha para vetor coluna:
S = S';
end
33

function [X,Y,ERR] = F_ELIP(Ni,X,Nj,Y,alpha,omega,E,STP,res,esc)


% F_ELIP faz o cálculo da malha elíptica, chamando os métodos iterativos
% AF1, AF2 ou SLOR, conforme escolha do usuário.
% Declaração da matriz do operador resíduo:
LX(1:Nj,1:Ni) = 0;
LY(1:Nj,1:Ni) = 0;
% Declaração dos coeficientes de Poisson:
A(1:Nj,1:Ni) = 0;
B(1:Nj,1:Ni) = 0;
C(1:Nj,1:Ni) = 0;
D(1:Nj,1:Ni) = 0;
% Declaração da função erro:
err = 1;
% Declaração do contador de passos:
cont = 0;
while err > STP
%% Inicialização da iteração:
% Atualização do contador:
cont = cont + 1;
% Declaração da matriz do operador resíduo:
LX(1:Nj,1:Ni) = 0;
LY(1:Nj,1:Ni) = 0;
% Declaração dos coeficientes de Poisson:
A(1:Nj,1:Ni) = 0;
B(1:Nj,1:Ni) = 0;
C(1:Nj,1:Ni) = 0;
D(1:Nj,1:Ni) = 0;
%% Cálculo do operador resíduo:
% Entrada de linha -> caminho em (eta):
for jj = 2:(Nj-1)
% Entrada de coluna -> caminho em (qsi):
for ii = 1:(Ni-1)
% Cálculo das derivadas em (eta) e (qsi):
% - Esquema centrado de primeira ordem:
if ii == 1
% Derivadas em (qsi):
Xq = 0.5*(X(jj,ii+1) - X(jj,Ni-1));
Yq = 0.5*(Y(jj,ii+1) - Y(jj,Ni-1));
else
Xq = 0.5*(X(jj,ii+1) - X(jj,ii-1));
Yq = 0.5*(Y(jj,ii+1) - Y(jj,ii-1));
end
% Derivadas em (eta):
Xn = 0.5*(X(jj+1,ii) - X(jj-1,ii));
Yn = 0.5*(Y(jj+1,ii) - Y(jj-1,ii));
% Cálculo dos coeficientes da Eq. de Poisson:
A(jj,ii) = (Xn^2 + Yn^2);
B(jj,ii) = (Xq*Xn + Yq*Yn);
C(jj,ii) = (Xq^2 + Yq^2);
D(jj,ii) = (Xq*Yn - Xn*Yq)^2;
% Cálculo das Derivadas de Segunda Ordem:
if ii == 1
% Em (x):
Xqq = (X(jj,ii+1) - 2*X(jj,ii) + X(jj,Ni-1));
Xqn = (X(jj+1,ii+1) - X(jj-1,ii+1) - ...
X(jj+1,Ni-1) + X(jj-1,Ni-1))*0.25;
Xnn = (X(jj+1,ii) - 2*X(jj,ii) + X(jj-1,ii));
% Em (y):
Yqq = (Y(jj,ii+1) - 2*Y(jj,ii) + Y(jj,Ni-1));
Yqn = (Y(jj+1,ii+1) - Y(jj-1,ii+1) - ...
Y(jj+1,Ni-1) + Y(jj-1,Ni-1))*0.25;
34

Ynn = (Y(jj+1,ii) - 2*Y(jj,ii) + Y(jj-1,ii));


else
% Em (x):
Xqq = (X(jj,ii+1) - 2*X(jj,ii) + X(jj,ii-1));
Xqn = (X(jj+1,ii+1) - X(jj-1,ii+1) - ...
X(jj+1,ii-1) + X(jj-1,ii-1))*0.25;
Xnn = (X(jj+1,ii) - 2*X(jj,ii) + X(jj-1,ii));
% Em (y):
Yqq = (Y(jj,ii+1) - 2*Y(jj,ii) + Y(jj,ii-1));
Yqn = (Y(jj+1,ii+1) - Y(jj-1,ii+1) - ...
Y(jj+1,ii-1) + Y(jj-1,ii-1))*0.25;
Ynn = (Y(jj+1,ii) - 2*Y(jj,ii) + Y(jj-1,ii));
end
% Cálculo do operador resíduo em (x) e (y):
LX(jj,ii) = A(jj,ii)*Xqq - 2*B(jj,ii)*Xqn + C(jj,ii)*Xnn;
LY(jj,ii) = A(jj,ii)*Yqq - 2*B(jj,ii)*Yqn + C(jj,ii)*Ynn;
end
% Inserção da periodicidade em (qsi):
LX(jj,Ni) = LX(jj,1);
LY(jj,Ni) = LY(jj,1);
end
%% Análise de convergência:
erx = I_MAX(LX);
ery = I_MAX(LY);
% Critério de parada: convergência para operador resíduo.
if erx > ery
ERR(cont) = erx;
else
ERR(cont) = ery;
end
if res == 1
err = ERR(cont);
% Critério de parada: número máximo de iterações.
elseif res == 2
err = 1/cont;
end
%% Parada de simulaçâo:
% Critério de parada: número máximo de iterações:
if cont > (E-1)
fprintf('-Número máximo de iterações alcançado: %d.',E)
fprintf('\n');
break
end
% Divergência encontrada:
if ERR(cont) > 1E5
fprintf('-Divergência. Resíduo: %13.12f.',ERR(cont))
fprintf('\n');
break
end
%% Método AF1 (ADI)
if esc == 1
[X,Y] = G_AF1(Ni,X,LX,Nj,Y,LY,alpha,omega,A,C);
%% Método SLOR
elseif esc == 2
[X,Y] = G_SLOR(Ni,X,LX,Nj,Y,LY,alpha,omega);
%% Método AF2
elseif esc == 3
[X,Y] = G_AF2(Ni,X,LX,Nj,Y,LY,alpha,omega,A,C);
end
end
end
35

function [X,Y] = G_AF1(Ni,X,LX,Nj,Y,LY,alpha,omega,A,C)


% G_AF1 implementa o algorítmo para método AF1.

% Declaração do operador correção intermediário para AF1:


KX(1:Nj,1:Ni) = 0;
KY(1:Nj,1:Ni) = 0;
RX(1:Nj,1:Ni) = 0;
RY(1:Nj,1:Ni) = 0;
% Declaração do operador correção:
CX(1:Nj,1:Ni) = 0;
CY(1:Nj,1:Ni) = 0;
%% Cálculo do operador correção intermediário:
% Entrada de coluna -> caminho em (qsi):
for ii = 1:(Ni-1)
% Declaração das constantes da matriz tridiagonal:
F(1:Nj-2) = 0;
G(1:Nj-2) = 0;
H(1:Nj-2) = 0;
% Entrada de linha -> caminho em (eta):
for jj = 2:(Nj-1)
% Cálculo do RHS da equação de correção padrão (delta):
RX(jj,ii) = alpha*omega*LX(jj,ii);
RY(jj,ii) = alpha*omega*LY(jj,ii);
% Cálculo dos coeficientes da Tridiagonal Periódica:
F(jj-1) = -C(jj,ii);
G(jj-1) = C(jj,ii)*2 + alpha;
H(jj-1) = -C(jj,ii);
end
% Cálculo do operador correção:
KX(2:(Nj-1),ii) = E_THOM(F,G,H,RX(2:(Nj-1),ii),Nj-2);
KY(2:(Nj-1),ii) = E_THOM(F,G,H,RY(2:(Nj-1),ii),Nj-2);
end
% Inserção da periodicidade em (qsi):
KX(:,Ni) = KX(:,1);
KY(:,Ni) = KY(:,1);
%% Cálculo do operador correção para forma delta:
% Entrada de linha -> caminho em (eta):
for jj = 2:(Nj-1)
% Declaração das constantes da matriz tridiagonal:
M(1:Ni-1) = 0;
N(1:Ni-1) = 0;
O(1:Ni-1) = 0;
% Entrada de coluna -> caminho em (qsi):
for ii = 1:(Ni-1)
% Cálculo dos coeficientes da Tridiagonal Periódica:
M(ii) = -A(jj,ii);
N(ii) = A(jj,ii)*2 + alpha;
O(ii) = -A(jj,ii);
end
% Cálculo do operador correção intermediário:
CX(jj,:) = H_MORR(M,N,O,KX(jj,:),Ni-1);
CY(jj,:) = H_MORR(M,N,O,KY(jj,:),Ni-1);
end
% Inserção da condição de periodicidade:
CX(:,Ni) = CX(:,1);
CY(:,Ni) = CY(:,1);
%% Cálculo da malha atualizada em (n+1):
% Atualização da malha computacional:
X(1:Nj,1:Ni) = X(1:Nj,1:Ni) + CX(1:Nj,1:Ni);
Y(1:Nj,1:Ni) = Y(1:Nj,1:Ni) + CY(1:Nj,1:Ni);
end
36

function [X,Y] = G_AF2(Ni,X,LX,Nj,Y,LY,alpha,omega,A,C)


% G_AF2 implementa o algorítmo para método AF2.

% Declaração do operador correção intermediário para AF1:


KX(1:Nj,1:Ni) = 0;
KY(1:Nj,1:Ni) = 0;
RX(1:Nj,1:Ni) = 0;
RY(1:Nj,1:Ni) = 0;
% Declaração do operador correção:
CX(1:Nj,1:Ni) = 0;
CY(1:Nj,1:Ni) = 0;
%% Cálculo do operador correção intermediário:
% Entrada de coluna -> caminho em (qsi):
for ii = 1:(Ni-1)
% Entrada de linha -> caminho em (eta):
for jj = (Nj-1):-1:2
DEN = alpha + C(jj,ii);
KX(jj,ii) = (alpha*omega*LX(jj,ii) + C(jj,ii)*KX(jj+1,ii))/DEN;
KY(jj,ii) = (alpha*omega*LY(jj,ii) + C(jj,ii)*KY(jj+1,ii))/DEN;
end
end
% Inserção da periodicidade em (qsi):
KX(:,Ni) = KX(:,1);
KY(:,Ni) = KY(:,1);
%% Cálculo do operador correção para forma delta:
% Entrada de linha -> caminho em (eta):
for jj = 2:(Nj-1)
% Declaração das constantes da matriz tridiagonal:
M(1:Ni-1) = 0;
N(1:Ni-1) = 0;
O(1:Ni-1) = 0;
% Entrada de coluna -> caminho em (qsi):
for ii = 2:Ni
% Cálculo do RHS da equação de correção padrão (delta):
RX(jj,ii) = KX(jj,ii) + alpha*CX(jj-1,ii);
RY(jj,ii) = KY(jj,ii) + alpha*CY(jj-1,ii);
% Cálculo dos coeficientes da Tridiagonal Periódica:
M(ii-1) = -A(jj,ii);
N(ii-1) = A(jj,ii)*2 + alpha;
O(ii-1) = -A(jj,ii);
end
% Inserção da periodicidade em (qsi):
RX(jj,1) = RX(jj,Ni);
RY(jj,1) = RY(jj,Ni);
% Cálculo do operador correção para forma delta:
CX(jj,:) = H_MORR(M,N,O,RX(jj,:),Ni-1);
CY(jj,:) = H_MORR(M,N,O,RY(jj,:),Ni-1);
end
%% Cálculo da malha atualizada em (n+1):
% Atualização da malha computacional:
X(1:Nj,1:Ni) = X(1:Nj,1:Ni) + CX(1:Nj,1:Ni);
Y(1:Nj,1:Ni) = Y(1:Nj,1:Ni) + CY(1:Nj,1:Ni);
end
37

function [X,Y] = G_SLOR(Ni,X,LX,Nj,Y,LY,alpha,omega)


% G_SLOR implementa o algorítmo para método SLOR.

% Declaração do operador correção:


CX(1:Nj,1:Ni) = 0;
CY(1:Nj,1:Ni) = 0;
% Declaração do operador resposta para Método SLOR:
RX(1:Nj,1:Ni) = 0;
RY(1:Nj,1:Ni) = 0;
% Declaração das constantes da matriz tridiagonal:
M(1:Ni-1) = -1;
N(1:Ni-1) = 4;
O(1:Ni-1) = -1;
% Neste caso os coeficientes independem de
% características da malha, como já
% observamos no método AF1, assumindo
% sempre os valores impostos acima.
%% Cálculo do operador correção para forma delta:
% Entrada de linha -> caminho em (eta):
for jj = 2:(Nj-1)
% Entrada de coluna -> caminho em (qsi):
for ii = 1:(Ni-1)
% Cálculo do RHS da equação de correção padrão (delta):
RX(jj,ii) = alpha*omega*LX(jj,ii) + alpha*CX(jj-1,ii);
RY(jj,ii) = alpha*omega*LY(jj,ii) + alpha*CY(jj-1,ii);
end
% Inserção da periodicidade em (qsi):
RX(jj,Ni) = RX(jj,1);
RY(jj,Ni) = RY(jj,1);
% Cálculo do operador correção:
CX(jj,:) = H_MORR(M,N,O,RX(jj,:),Ni-1);
CY(jj,:) = H_MORR(M,N,O,RY(jj,:),Ni-1);
end
%% Cálculo da malha atualizada em (n+1):
% Atualização da malha computacional:
X(1:Nj,1:Ni) = X(1:Nj,1:Ni) + CX(1:Nj,1:Ni);
Y(1:Nj,1:Ni) = Y(1:Nj,1:Ni) + CY(1:Nj,1:Ni);
end
38

function [K] = H_MORR(M,N,O,D,Ni)


% H_MORR realiza o cálculo da Equação de Sherman-Morrison para avaliação
% linha a linha, para os métodos AF1 e AF2 periódicos.
%% Criação da matriz A:
AA(1:Ni,1:Ni) = 0;
% Contador:
n = 0;
for ii = 1:Ni
n = n + 1;
if ii == 1
AA(ii,Ni) = M(ii);
AA(ii,n) = N(ii);
AA(ii,n+1) = O(ii);
elseif ii == Ni
AA(ii,n-1) = M(ii);
AA(ii,n) = N(ii);
AA(ii,1) = O(ii);
else
AA(ii,n-1) = M(ii);
AA(ii,n) = N(ii);
AA(ii,n+1) = O(ii);

end
end
%% Criação dos vetores u e v:
u(1:Ni,1) = 0;
u(1,1) = N(1)*(-1);
u(Ni,1) = O(Ni);
v(1:Ni,1) = 0;
v(1,1) = 1;
v(Ni,1) = M(1)*(-1)/N(1);
%% Cálculo da matriz A':
AL = AA - u*v';
%% Identificação dos coeficientes de A':
P(1:Ni,1) = 0;
Q(1:Ni,1) = 0;
R(1:Ni,1) = 0;
for ii = 1:Ni
if ii == 1
P(ii) = 0;
Q(ii) = AL(ii,ii);
R(ii) = AL(ii,ii+1);
elseif ii == Ni
P(ii) = AL(ii,ii-1);
Q(ii) = AL(ii,ii);
R(ii) = 0;
else
P(ii) = AL(ii,ii-1);
Q(ii) = AL(ii,ii);
R(ii) = AL(ii,ii+1);
end
end
%% Cálculo do vetor resposta Y (utilizando o Alg. de E_THOMas):
[Y] = E_THOM(P,Q,R,D,Ni);
%% Cálculo do vetor resposta Q (utilizando o Alg. de E_THOMas):
[Q] = E_THOM(P,Q,R,u,Ni);
%% Cálculo do vetor resposta do sistema AX = R:
K = Y - ((v'*Y)/(1 + v'*Q))*Q;
K = K';
K = [K K(1)];
end
39

function [ANS] = I_MAX(FUN)


% I_MAX determina o valor máximo absoluto de uma matriz ou vetor.

% Declaração do valor resposta a ser avaliado:


ANS = 0;
% Leitura do tamanho da matriz ou vetor de entrada:
[m,n] = size(FUN);
% Início do cálculo para determinação do máximo valor de FUN:
for jj = 1:m
for ii = 1:n
% Leitura do valor local:
AUX = FUN(jj,ii);
% Avaliação se o mesmo é negativo:
if AUX < 0
% Caso negativo, avaliamos seu valor absoluto:
AUX = AUX*(-1);
end
% Avaliação se o valor é maior que nosso valor ANS inicial:
if AUX > ANS
% Caso positivo, o valor de ANS é atualizado:
ANS = AUX;
end
end
end
end
40

function [X,Y] = J_GEOM(sel,Ni,Nj,c,t,OXi,OXe,XSF)


% Função para seleção de geometria:
%% Aerofólio Biconvexo
if sel == 1
%% Dados de fronteira:
% Fronteira interna:
if XSF == 1
Xi = c:-2*c/(Ni-1):0;
else
% Soma da PG:
SPG = -c/2;
% Elementos da PG:
MPG = (Ni-1)/4 + 1;
dX(1,1:MPG-1) = 0;
dX(1) = (XSF-1)*SPG/(XSF^(MPG-1)-1);
for ii = 2:MPG-1
dX(ii) = dX(ii-1)*XSF;
end
% Discretização em (qsi):
Xi(1,1:MPG) = 0;
Xi(1) = c;
for ii = 2:MPG
Xi(ii) = Xi(ii-1) + dX(ii-1);
end
Xi = [Xi (1 - Xi(MPG-1:-1:1))];
end
Mo = (Ni-1)/2 + 1;
Yi = t.*Xi.*(1 - Xi);
Xi = [ Xi Xi(Mo-1:-1:1)];
Yi = [-Yi Yi(Mo-1:-1:1)];

% Fronteira externa:
do = 0:2*pi/(Ni-1):pi;
Re = 6.5*c;
Xe = Re*cos(do);
Ye = Re*sin(do);
Xe = [ Xe Xe(Mo-1:-1:1)];
Ye = [-Ye Ye(Mo-1:-1:1)];
%% Circunferência
elseif sel == 2
%% Dados de fronteira:
% Fronteira interna:
Mo = (Ni-1)/2 + 1;
do = 0:2*pi/(Ni-1):pi;
Ri = c;
Xi = Ri*cos(do);
Yi = Ri*sin(do);
Xi = [ Xi Xi(Mo-1:-1:1)];
Yi = [-Yi Yi(Mo-1:-1:1)];

% Fronteira externa:
Re = 6.5*c;
Xe = Re*cos(do);
Ye = Re*sin(do);
Xe = [ Xe Xe(Mo-1:-1:1)];
Ye = [-Ye Ye(Mo-1:-1:1)];
%% NACA 00XX
elseif sel == 3
%% Dados de fronteira:
% Fronteira interna:
if XSF == 1
41

Xi = c:-2*c/(Ni-1):0;
else
% Soma da PG:
SPG = -c/2;
% Elementos da PG:
MPG = (Ni-1)/4 + 1;
dX(1,1:MPG-1) = 0;
dX(1) = (XSF-1)*SPG/(XSF^(MPG-1)-1);
for ii = 2:MPG-1
dX(ii) = dX(ii-1)*XSF;
end
% Discretização em (qsi):
Xi(1,1:MPG) = 0;
Xi(1) = c;
for ii = 2:MPG
Xi(ii) = Xi(ii-1) + dX(ii-1);
end
Xi = [Xi (1 - Xi(MPG-1:-1:1))];
end
Mo = (Ni-1)/2 + 1;
Yi(1,1:Mo) = 0;
for ii = 2:Mo
Yi(ii) = t*c*(1.4845*sqrt(Xi(ii)/c) - 0.6300*(Xi(ii)/c) -
...
1.7580*(Xi(ii)/c)^2 + 1.4215*(Xi(ii)/c)^3 -
...
0.5075*(Xi(ii)/c)^4);
end
Xi = [ Xi Xi(Mo-1:-1:1)];
Yi = [-Yi Yi(Mo-1:-1:1)];
% Fronteira externa:
Mo = (Ni-1)/2 + 1;
do = 0:2*pi/(Ni-1):pi;
Re = 6.5*c;
Xe = Re*cos(do);
Ye = Re*sin(do);
Xe = [ Xe Xe(Mo-1:-1:1)];
Ye = [-Ye Ye(Mo-1:-1:1)];
end
%% Translação horizonzal:
Xi = Xi + OXi;
Xe = Xe + OXe;
%% Dados iniciais da malha:
% Determinação da malha computacional:
X(1:Nj,1:Ni) = 0;
Y(1:Nj,1:Ni) = 0;
% Inserção dos dados:
X(1,1:Ni) = Xi;
Y(1,1:Ni) = Yi;
% Inserção dos dados:
X(Nj,1:Ni) = Xe;
Y(Nj,1:Ni) = Ye;

end