Onda solitária sobre barras submersas

Nesta subsecção, a propagação de ondas solitárias sobre barras submersas é simulada através do código DOLFWAVE. Em particular, consideramos barras com geometrias trapezoidais e triangulares. Note-se que as soluções do modelo BEP/ZTC obtidas pelo código DOLFWAVE são comparadas com as soluções das equações do modelo BEV de Nwogu. Estas últimas soluções são obtidas através de outro código desenvolvido neste trabalho de investigação científica (ver dolfwave/tools/Nwogu). Especificamente, as equações de Nwogu são discretizadas através de uma formulação mista de elementos finitos (ver Walkley (1999)) bem como um esquema implícito de Runge-Kutta do tipo Radau IIA para a integração no tempo (ver Hairer e Wanner (1991)).

Começamos pela descrição do problema conjuntamente com o código DOLFWAVE usado para a sua resolução numérica. O código C++ deve ser inicializado com a inclusão da biblioteca DOLFWAVE.

#include <dolfwave.h>

using namespace dolfin::dolfwave;

A condição inicial para a elevação da superfície da onda marítima é dada por (2.30) e implementada como segue:

class ElevationInit : public Expression {

void eval(Array<double> & values,const Array<double> & x) const {

// Wave parameters (see Walkley [1999]) double c=sqrt(1.025), H=0.4;

double ca=-0.4, cb=ca+1.0/3.0; double center=-5.0; double a1=(H/3.0)*(sqr(c)-1)/(cb-ca*sqr(c)); double a2=-(H/2.0)*sqr((sqr(c)-1)/c)*(cb+2.0*ca*sqr(c))/(cb-ca*sqr(c)); double k=(1.0/(2.0*H))*sqrt((sqr(c)-1)/(cb-ca*sqr(c))); values[0]=a1/sqr(cosh(k*(x[0]-center)))+a2/sqr(sqr(cosh(k*(x[0]-center)))); } };

A condição inicial para o potencial da velocidade do fluido é definida por (2.41) e implementada usando o código seguinte:

class PotentialInit : public Expression {

void eval(Array<double> & values,const Array<double> & x) const {

//Wave parameters

double c=sqrt(1.025), H=0.4; double ca=-0.4, cb=ca+1.0/3.0; double center=-5.0;

double a3=sqrt(H*g_e)*(sqr(c)-1)/c;

//Constant of integration

double cnst=4.0*a3/(2.0*k*(1+exp(2.0*k*(-25.))));

values[0]=-4.0*a3/(2.0*k*(1+exp(2.0*k*(x[0]-center))))+cnst; }

};

O fundo de geometria trapezoidal z = −h(x) é descrito pela função contínua e diferenciável por ramos h(x) (m), a qual é expressa pela equação seguinte:

h(x) =                  0.4 se − 25 ≤ x ≤ 6 −0.05x + 0.7 se 6 < x ≤ 12 0.1 se 12 < x ≤ 14 0.1x − 1.3 se 14 < x ≤ 17 0.4 se 17 < x ≤ 25 (m). (2.55)

Este fundo trapezoidal é implementado através do código que segue:

class Depth : public Expression {

void eval(Array<double> & values,const Array<double> & x) const { double retrn=0.0; if(x[0]<=6.0) retrn=0.4; else if(x[0]<=12.0) retrn=-0.05*x[0]+0.7; else if(x[0]<=14.0) retrn=0.1; else if(x[0]<=17.0) retrn=0.1*x[0]-1.3; else retrn=0.4; values[0]=retrn; } };

O código da demonstração inicia-se com a criação de um objecto da classe Dolfwave. Aqui, simulamos a propagação de uma onda durante 25 s usando um passo de tempo de 0.001 s. O ficheiro UFL “Zhao_1D”, que contém a formulação variacional usada neste problema, corresponde à versão do problema a uma dimensão horizontal descrito por (2.27). Neste exemplo usamos um método LU disponibilizado pela biblioteca PETSc (ver Logg et al. (2012)). A pré-visualização das soluções numéricas é realizada pelo programa Viper, o qual está integrado nas bibliotecas do projecto FEniCS. Para o pós-processamento, as soluções são gravadas na directoria “output” usando um formato ASCII denotado por “xyz”.

int main( ) {

Dolfwave dw(25000 /*Number of steps*/, 0.001 /*Time step*/,

100 /*Gap for saving the solutions*/, "Zhao_1D" /*Variational form identifier*/, "LU_P" /*Linear solver type*/,

"viper" /*Preview program*/, "output" /*Output directory*/, "xyz" /*File output format*/);

O domínio espacial usado no caso da barra submersa com geometria trapezoidal é definido pelo intervalo [−25, 25](m) discretizado usando 201 nós.

Interval mesh(201,-25,25);

As funções conhecidas são inicializadas de seguida. Neste exemplo não consideramos camadas de esponja ou funções de fonte.

// Depth função Depth depth;

// Initial condition for the surface elevation ElevationInit eta_init;

// Initial condition for the velocity potential PotentialInit phi_init;

// Sponge layers and source function are zero Constant zero(0.0);

Todas as matrizes e vectores associados ao método dos elementos finitos são criados a partir das formas bilinear e linear da formulação variacional.

// Initialization of the function spaces dw.FunçãoSpaceInit(mesh);

// Initialization of the bilinear form ’a’ dw.BilinearFormInit(mesh,depth);

// Initialization of the system matrices dw.MatricesAssemble( );

// Initialization of the surface elevation and velocity potential dw.FunçãosInit( );

// Initialization of the linear form ’L’

dw.LinearFormsInit(depth, zero, zero, zero, zero, zero); // Setting the initial conditions

dw.InitialCondition(eta_init,phi_init);

// Initialization of the auxiliary vectors for the time integration schemes dw.VectorInit( );

Apenas necessitamos de fazer uma factorização LU uma vez que a matriz do sistema de elementos finitos não depende do tempo.

// Reuse the LU factorization throughout the time integration routines dw.LUFactorization(true);

Para o pós-processamento dos dados, a função simétrica da função que descreve a batimetria é gravada.

// Plot the symmetric of the depth função h dw.DepthPlot(mesh,depth,true);

As rotinas de integração no tempo são usadas agora. O esquema de Adams-Bashforth-Moulton descrito pelas equações (2.29) é inicializado por um esquema explícito de Runge-Kutta de quarta ordem.

// Choose the explicit 4th-order Runge-Kutta for initialization dw.RKInit("exp4");

// Use the Runge-Kutta for the 3 initial steps dw.RKSolve( );

// Initialization of the predictor-corrector with multi-step corrector dw.PCInit(mesh,true);

// Advance in time with the predictor-corrector scheme for(dolfin::uint i=4; i<dw.MaxSteps+1;i++)

{

// Adams-Bashforth-Moulton method dw.PCSolve( );

// Save and preview the surf. elevation with a gap of 100 iterations if (!(i%dw.WriteGap))

dw.Plot(mesh,true /*eta preview*/, false /*phi preview*/, true /*eta save*/, false /*phi save*/);

}

return (EXIT_SUCCESS); // Finish the process }

Neste exemplo, apenas visualizamos e gravamos a elevação da superfície da onda usando a função Plot. A solução obtida pelo código, para o caso da barra submersa com geometria trapezoidal com x ∈ [−10, 25] (m), é representada na figura 2.12. Note-se que o efeito de empolamento da onda é claramente observado tanto para as ondas incidentes como para as ondas reflectidas.

Na figura 2.13, as soluções obtidas pelos dois modelos independentes podem ser comparadas. Note-se que as equações (2.30) e (2.31) são usadas para definir a condição inicial correspondente às equações de Nwogu. Observamos que existe uma boa concordância entre as soluções numéricas, apesar destas serem provenientes de modelos e discretizações distintas. Para além disto, estas soluções são ainda concordantes com as de outro modelo desenvolvido por nós e implementado na aplicação DOLFWAVE (ver dolfwave/demo/1HD/submergedbar e o capítulo 3).

Nas simulações numéricas da onda solitária a passar sobre a barra submersa com geometria triangular, investigamos os efeitos não lineares e a influência de hm na propagação da onda

para os modelos fracamente não lineares BEP/ZTC e BEV/Nwogu (ver figura 2.14). Através da figura 2.15, podemos concluir que estes modelos estão em concordância no caso da barra submersa com geometria triangular com hm = 0.1 m. Estes modelos podem ainda ser

−10 −5 0 5 10 15 20 25

x (m)

t∈

[0

,25]

(s

)

Figura 2.12: Vista em detalhe da onda passando sobre a barra submersa com geometria trapezoidal

usando o modelo BEP/ZTC implementado pelo código DOLFWAVE.

de h_m tais como h_m = 0.04 m. Contudo, o modelo BEV/Nwogu apresenta oscilações de alta frequência e de baixa amplitude após a interacção da onda com a barra submersa (ver figura 2.16). Com o decréscimo do valor de hm o modelo BEV/Nwogu torna-se instável (ver

figura 2.17). Na figura 2.17, observamos a explosão da solução numérica obtida através do modelo de Nwogu para hm = 0.02 m. Salienta-se que a noção de explosão de uma solução

numérica está relacionada com o facto de esta se tornar ilimitada num dado instante. Note-se que os valores de referência de ε no ponto (15, −h_m)(m) são de ε = 0.1, ε = 0.25 e ε = 0.5 para h_m = 0.1 m, h_m = 0.04 m e h_m = 0.02 m, respectivamente. Ainda que para ε = 0.5 estejamos fora do domínio de validade para a aplicação dos modelos BEP/ZTC e BEV/Nwogu, o primeiro modelo mostra-se mais robusto perante os efeitos não lineares. Como iremos ver na secção seguinte, estas propriedades de estabilidade para o modelo BEP/ZTC são também observadas em testes numéricos envolvendo o refinamento das malhas.