Soluções numéricas da equação de Blasius

Nelson Luís Diasnldias@ufpr.br

2 de julho de 2009

Uma camada-limite laminar sobre uma placa plana sem gradiente de pressão longitudinal podeser resolvida com

f ′′′+12

f f ′′ = 0 (1)

sujeita às condições de contorno

f (0) = 0, f ′(0) = 0, f ′(∞) = 1 (2)

onde

f (η) =Ψ(x,y)U∞δ (x)

(3)

η =y

δ (x)(4)

e

δ (x) =√

νxU∞

. (5)

As condições 2 não configuram um problema de valor inicial clássico, mas sim um problema devalor de contorno. Mesmo assim, vale a pena a seguinte abordagem. A mudança de variáveis

u1 = f , u2 = f ′, u3 = f ′′, (6)

produz o seguinte sistema autônomo de equações diferenciais ordinárias:

ddη

u1u2u3

=

u2,u3,

−12u1u3

(7)

Este sistema pode agora ser resolvido com 3 condições iniciais

u1(0) = 0, u2(0) = 0, u3(0) = γ (8)

1

onde γ é um valor inicial arbitrário para f ′′(0). A solução de 7 pode ser obtida com o seguinteprograma em C:〈blasius.c〉≡

// --------------------------------------------------------------// blasius.c: tentativa de resolver a camada-limite laminar//// Nelson Luís Dias// 2002-06-05T00:00:00// 2009-07-02T08:43:57 atualizado para TT770 Teoria de Camadas-Limite// --------------------------------------------------------------#include <assert.h>#include <stdio.h>#include <stdlib.h>// --------------------------------------------------------------// rkvetor: uma implementação de um runge-kutta multidimensional//// Nelson Luís Dias// 20020528// 20020528// --------------------------------------------------------------void rkvetor(

long m, // número de equações diferenciais ordinárias do sistema == tamanho de ydouble xn, // ponto de avaliaçãodouble h, // passo que vou dardouble *yn, // valor atual da funçãovoid ff(long, double, double *, double *),double *ynew // novo valor da função

) {// --------------------------------------------------------------// variáveis// --------------------------------------------------------------long

i; // contadordouble

h2 = h/2.0, // h/2h3 = h/3.0, // h/3h6 = h/6.0 ; // h/6

double

*k1, // array

*k2, // array

*k3, // array

*k4, // array

*yaux ; // array auxiliar// -------------------------------------------------------------// aloca memória// -------------------------------------------------------------

k1 = (double *) calloc(m,sizeof(double));k2 = (double *) calloc(m,sizeof(double));k3 = (double *) calloc(m,sizeof(double));k4 = (double *) calloc(m,sizeof(double));yaux = (double *) calloc(m,sizeof(double));

// --------------------------------------------------------------// primeira chamada de ff// --------------------------------------------------------------

ff(m,xn,yn,k1);// -----------------------// mais uma linha de comentários// -----------------------

for ( i = 0 ; i < m ; i++ ) {yaux[i] = yn[i] + k1[i]*h2 ;

}// --------------------------------------------------------------// segunda chamada de ff// --------------------------------------------------------------

ff(m,xn+h2,yaux,k2);for ( i = 0 ; i < m ; i++ ) {

yaux[i] = yn[i] + k2[i]*h2 ;

2

}// --------------------------------------------------------------// terceira chamada de ff// --------------------------------------------------------------

ff(m,xn+h2,yaux,k3) ;for ( i = 0 ; i < m ; i++ ) {

yaux[i] = yn[i] + k3[i]*h ;}

// --------------------------------------------------------------// quarta e última chamda de ff// --------------------------------------------------------------

ff(m,xn+h,yaux,k4);// --------------------------------------------------------------// finalmente, avalia a função// --------------------------------------------------------------

for ( i = 0 ; i < m ; i++ ) {ynew[i] = yn[i] + k1[i]*h6 + k2[i]*h3 + k3[i]*h3 + k4[i]*h6 ;

}// --------------------------------------------------------------// desaloca memória// --------------------------------------------------------------

free(k1) ;free(k2) ;free(k3) ;free(k4) ;free(yaux) ;

// -------------------------------------------------------------// retorna// -------------------------------------------------------------

return ;}// -------------------------------------------------------------// aqui eu declaro o sistema de equações diferenciais na forma de uma function// -------------------------------------------------------------void blasius(long m, // o número de equações: deve ser sempre igual a 3!double t, // o instante de tempodouble *omega, // o vetor de velocidades angularesdouble *domdt // as derivadas) {// -------------------------------------------------------------// calcula as derivadas// -------------------------------------------------------------

domdt[0] = omega[1] ;domdt[1] = omega[2] ;domdt[2] = -omega[0]*omega[2]/2.0 ;return ;

}// -------------------------------------------------------------// outros parâmetros da simulação// -------------------------------------------------------------#define deltat 0.1 // intervalo de tempo da simulação#define tmax 20.0 // tempo de simulação// -------------------------------------------------------------// pointers to pointers ...// -------------------------------------------------------------typedef double *vetor ;// -------------------------------------------------------------// aqui começa o programa principal// -------------------------------------------------------------int main(int argc, char* argv[]) {long

old, // índice do vetor de incógnitasnew, // idemit, // índice do tempont = tmax/deltat ; // número de intervalos de tempo de simulação

doublet ; // um instante de tempo qualquer

3

vetoromega[2] ;

// --------------------------------------------------------------// o único argumento de blasius é o valor inicial// --------------------------------------------------------------

assert (argc == 2) ;double gamma ;sscanf(argv[1],"%lf",&gamma) ;

// --------------------------------------------------------------// aloca memória para omega ;// --------------------------------------------------------------

omega[0] = (double *) calloc(3,sizeof(double));omega[1] = (double *) calloc(3,sizeof(double));

// --------------------------------------------------------------// inicializa omega// --------------------------------------------------------------

omega[0][0] = 0.0 ;omega[0][1] = 0.0 ;omega[0][2] = gamma ;

// --------------------------------------------------------------// imprime um cabeçalho// --------------------------------------------------------------

printf("#123456789012345678901234567890123456789012345678901234567890123456789\n");printf("# tempo f f\’ f\’\’ \n");printf("%15.8lf %12.6le %12.6le %12.6e\n",0.0,omega[0][0],omega[0][1],omega[0][2]);

// --------------------------------------------------------------// sem mais delongas, faço um loop no tempo// --------------------------------------------------------------

old = 0 ;new = 1 ;for ( it = 0 ; it < nt ; it++ ) {

t = it*deltat ;rkvetor(3,t,deltat,omega[old],blasius,omega[new]) ;

// -------------------------------------------------------------// imprime uma linha de simulação// -------------------------------------------------------------

printf("%15.8lf %+12.6e %+12.6e %+12.6e\n",t+deltat,omega[new][0],omega[new][1],omega[new][2]);

////// olá// -------------------------------------------------------------// troca os índices de old e new// -------------------------------------------------------------

old = new ;new = ! new ;

}return(0);

// -------------------------------------------------------------// último comentário do programa !// -------------------------------------------------------------}

4

Sucessivas rodadas de blasius.c produzem a seguinte tabela:

γ f ′(∞)

0.1 0.4490.2 0.7310.3 0.9340.4 1.132

0.35 1.0350.32 0.9750.33 0.995

0.335 1.0050.334 1.0030.333 1.001

0.3325 1.00080.3322 1.0002

1.0 2.085409

Se o processo todo estiver certo, então a última saída deve ter gerado o perfil de velocidade

f ′(η) =u

U∞

(9)

O seguinte script de gnuplot deve plotar o resultado:〈blasius.plt〉≡

set terminal postscript eps enhanced "Times-Roman" 18set xlabel ’{/Symbol h}’set ylabel ’{/Times-Italic u/U_{/Symbol \245}}’set output ’blasius.eps’set gridplot ’blasius.out’ using 1:3 notitle with lines lt 1 lw 2!epstopdf blasius.eps

5

O resultado pode ser visto na figura abaixo:

0

0.2

0.4

0.6

0.8

1

1.2

0 5 10 15 20

u/U

∞

η

1 Uma alternativa(Liggett, 1994, p. 196) Sugere a seguinte alternativa para definir condições de contorno em η = 0,e consequentemente produzir um problema de valor inicial desde o início:

f = αg, (10)ξ = βη (11)

Agora, em ξ = η = 0, a derivada segunda de f (que nós acabamos de determinar por tentativa-e-erro acima) é f ′′(0) = γ . A derivada segunda de g em relação a ξ será

d2gdξ 2 =

ddξ

dgdξ

=d

dξ

dgdη

dη

dξ=

1β

ddξ

dgdη

=1β

d2gdη2

dη

dξ

=1

β 2d2gdη2

=1

αβ 2d2gdη2

=1

αβ 2d2 fdη2 . (12)

6

Então,d2gdξ 2

∣∣∣∣0=

1αβ 2

d2 fdη2

∣∣∣∣0=

γ

αβ 2 . (13)

Agora, imponha γ/(αβ 2) = 1, de tal modo que d2g(0)/dξ 2 = 1.

dgdξ

=d( f /α)d(βη)

=1

αβ

d fdη

(14)

d2gdξ 2 =

1αβ 2

d2 fdη2 (15)

d3gdξ 3 =

1αβ 3

d3 fdη3 (16)

Voltando à equação diferencial original,

2 f ′′′+ f f ′′ = 0,

2αβ3g′′′+αgαβ

2g′′ = 0 (17)

É conveniente agora fazer α = β , de modo que a equação (17) torna-se

2g′′′+gg′′ = 0. (18)

Trata-se evidentemente da mesma equação de Blasius, porém com condições iniciais diferentes. Asua solução levará à obtenção do valor de α: de (14),

limξ→∞

dgdξ

=1

α2 limη→∞

d fdη

=1

α2 . (19)

Rodando blasius de novo com f ′′(0) = 1 (na verdade, g′′(0) = 1!), g′(∞) = 2.085409 (veja a úl-tima linha da tabela, convenientemente inserida à espera deste momento); α = 0.69247544534044858,e γ = α3 = 0.33205737835621146 = f ′′(0), o que concorda com nosso resultado anterior obtidopor tentativa-e-erro.

ReferênciasLiggett, J. A. (1994). Fluid Mechanics. McGraw-Hill, New York.

7