simpleFoam: Estudando o fvSchemes

Seguindo a mesma linha de raciocínio do tópico no qual apresentei o controlDict do simpleFoam chegou o momento de apresentar o fvSchemes (não deixe de ler esse texto se não entendeu porque estou fazendo isso agora).

O fvSchemes contém informações sobre os esquemas numéricos que são utilizados nas diferentes partes de discretização do modelo. O arquivo em questão está replicado abaixo.

FoamFile
{
    version     2.0;
    format      ascii;
    class       dictionary;
    object      fvSchemes;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

ddtSchemes
{
    default steadyState;
}

gradSchemes
{
    default         Gauss linear;
    grad(p)         Gauss linear;
    grad(U)         Gauss linear;
}

divSchemes
{
    default         none;
    div(phi,U)      Gauss upwind;
    div(phi,k)      Gauss upwind;
    div(phi,epsilon) Gauss upwind;
    div(phi,R)      Gauss upwind;
    div(R)          Gauss linear;
    div(phi,nuTilda) Gauss upwind;
    div((nuEff*dev(grad(U).T()))) Gauss linear;
}

laplacianSchemes
{
    default         none;
    laplacian(nuEff,U) Gauss linear corrected;
    laplacian((1|A(U)),p) Gauss linear corrected;
    laplacian(DkEff,k) Gauss linear corrected;
    laplacian(DepsilonEff,epsilon) Gauss linear corrected;
    laplacian(DREff,R) Gauss linear corrected;
    laplacian(DnuTildaEff,nuTilda) Gauss linear corrected;
}

interpolationSchemes
{
    default         linear;
    interpolate(U)  linear;
}

snGradSchemes
{
    default         corrected;
}

fluxRequired
{
    default         no;
    p;
}

// ************************************************************************* // 

Da mesma forma que no caso do controlDict, esse arquivo também começa com o dicionário FoamFile e possui 7 outros dicionários (que na verdade o manual chama de sub-dicionário, porque é um dicionário dentro de outro dicionário, mas eu continuarei a defini-lo como dicionário nesse texto).

Todos os dicionários são obrigatórios, ainda que seja para dizer que não há termos dessa ou daquela característica no modelo/aplicativo que se está utilizando:

• ddtSchemes -  Discretiza o termo da derivada temporal do modelo, se existir. No caso, se o problema for estacionário (como o simpleFoam), usa-se steadyState como opção. Se o problema for transiente, as opções, segundo o manual, são: Euler, método de Euler de primeira ordem explícito, backward, método de Euler de segunda ordem implícito, CrankNicholson, método de Crank-Nicholson.
  
• snGradSchemes - esse dicionário contém informações de como discretizar os gradientes normais da superfície, avaliado na face da célula.
  
  As opções básicas são: corrected, correção explícita de não ortogonalidade da malha, uncorrected, sem correção não-ortogonal e limited, "correção" não-ortogonal baseada no valor de um parâmetro (phi).
  
  O uso da opção limited consiste informar 'limited phi' na opção desejada e phi é um valor que varia de 0 a 1 tal que, de acordo com a tabela 4.7 do manual, :
  
  
  
  
• gradSchemes - esquemas para discretização do gradiente. A rigor, há três métodos disponíveis, Gauss, leastSquare e fourth. São métodos tradicionais, onde os primeiros são de segunda ordem e o terceiro é de quarta ordem. O método de Gauss requer que o usuário defina o tipo de interpolação, dos quais linear e upwind são opções típicas.
  
  No caso do simpleFoam, esse dicionário é responsável por discretizar o gradiente de pressão, grad(p), e o gradiente de velocidade grad(U).

• divSchemes - esquema para discretização do termo divergente. Segundo o manual, há apenas uma única opção disponível, Gauss (existem a opção não documentada explicit, mas não vou falar sobre isso). Porém, há vários esquemas de interpolação e isso faz as coisas serem bem mais complicadas nesse dicionário.
  
  Nem todos os tipos de metodologia de interpolação são indicadas para o divergente, é preciso saber escolher.
  
  
• laplacianSchemes - esquema para discretizar o laplaciano. Segundo o manual, há apenas uma única opção disponível, Gauss, e não imagina a minha surpresa ao constatar que isso é verdade. A sintaxe é:
  
  Gauss EsquemaDeInterpolacao snGradScheme
  
  Tudo que eu posso fazer nesse ponto do estudo é contemplar as escolhas feitas nos tutoriais, ou melhor, a escolha feita. Todos usam Gauss linear. Pelo que pude entender, isso é mesmo o usual.
  
  Também parece ser usual usar corrected ou limited e ajustar o valor do parâmetro phi conforme a necessidade entre 0, 0.333, 0.5 e 1. A maior parte dos tutoriais utilizaria 1. Digo utilizaria e não utiliza, por que, na verdade, os tutoriais utilizam a opção corrected.
  
  
• fluxRequired - esse dicionário lista as variáveis que são acopladas com o calculo do fluxo, em outras palavras, são variáveis que dependem do fluxo para serem determinadas. Na dinâmica dos fluidos, a principal variável nessa lista é a pressão (quando há acoplamento pressão-velocidade). Há casos, em análise de sólidos, onde pode ser necessário calcular o fluxo de calor.
  
  Nesse termo, ou o usuário está utilizando um aplicativo existente e o tutorial vai esclarecer quais são as variáveis que devem ser listadas aqui, ou o usuário é um programador que está criando o novo aplicativo e, portanto, saberá perfeitamente o que deve ser resolvido antes do fluxo ser calculado (afinal, a modelagem e a programação do código fará isso ser claro a ele!).
  
  
• interpolationScheme - esse dicionário define o método de interpolação de uma certa variável na face. Embora exista uma grande quantidade de opções, isso não chega a ser um problema pois trata-se de uma simples interpolação da variável. No caso do simpleFoam, esse termos é responsável por calcular o valor da velocidade das faces do volume.

Importância do método numérico

Na descrição de todos os dicionários eu poderia ter escrito: "é necessário compreender bem o problema e o método numérico para fazer as escolhas adequadas". De fato, é fundamental conhecer o método numérico para escolher adequadamente as opções em cada termo.

O método numérico é o coração do código. É o que realmente é feito desde o começo. A modelagem é apenas um produto que deve ser visto com detalhes, claro, mas que é obtido com a "máquina". Dessa forma, é ilusão pensar que um usuário será capaz de dominar o OpenFOAM se não conhecer o mínimo dos métodos numéricos. Para dizer a verdade, é possível que ele tenha que conhecer os métodos numéricos de forma muito mais ampla do que se poderia imaginar. O fvScheme é a interface que seleciona o método de discretização e interpolação e, portanto, de funcionamento da máquina e depende do usuário fazer com que a metodologia seja suficiente para obter uma forma final adequada. Portanto, concluí-se que o usuário deve aprender como o método numérico funciona.

Entendendo um pouco mais sobre os dicionários de discretização

Permito-me copiar o termo de divergente descrito acima para esse ponto do texto.

divSchemes
{
    default         none;
    div(phi,U)      Gauss upwind;
    div(phi,k)      Gauss upwind;
    div(phi,epsilon) Gauss upwind;
    div(phi,R)      Gauss upwind;
    div(R)          Gauss linear;
    div(phi,nuTilda) Gauss upwind;
    div((nuEff*dev(grad(U).T()))) Gauss linear;
}

Esse termo possui uma chave definida como default e tanto aqui como na maioria dos dicionários desse e de todos os tutoriais, a opção para essa chave é 'none'. Nesse caso em especial, isso significa que todos os divergentes que vão ser resolvidos devem ser declarados manualmente no arquivo fvSchemes. Isso não é um grande problema quando se quer apenas resolver alguma coisa com mesma modelagem de um tutorial, mas se experimentar modificar o modelo de turbulência verá que há outras declarações que devem ser feitas. Nota: ao tentar resolver o caso, o OpenFOAM com definições incompletas o o programa vai emitir uma mensagem de erro, bem direta. É simples, mas chato e nem sempre rápido.

Usar uma opção diferente de none como default não evita que alguns termos tenham que ser declarados. Isso acontece porque o programador possui meios de forçar o usuário a declarar manualmente um certo termo. O programador faz isso porque acredita que o usuário deve olhar para aquele termo com mais atenção e carinho.

A grande questão da interpolação dos termos de divergente, gradiente e laplaciano

Descobri ao estudar o OpenFOAM que apenas depois de eu ter lido o manual do programador vou ser capaz de explicar melhor cada termo que aparece nesse arquivo.

Esse arquivo é, sem dúvida alguma, o mais complicado de todos os arquivos de configuração do OpenFOAM.

Mas eu insisto em colocar um recomendação básica simples nesse texto, além da evidente "aprenda métodos numéricos e estudo melhor o código do OpenFOAM". E a recomendação para o usuário considerar com carinho as opções usadas nos tutoriais e na ausência dessas usar linear ou upwind com um bom refino de malha. Não raro, o ideal é usar o método muito mais robusto, mas para fazer isso o usuário precisa aprender métodos numéricos. Se ele não quiser fazer isso, vai ter que se contentar com o que está escrito aqui.

Repito novamente para quem não está prestando atenção no texto: Para usar o OpenFOAM, com todo o poder que ele possui, é fundamental conhecer o método numérico.

Sim, estou sendo chato nisso, porque não é algo trivial e os usuários do FLUENT e do CFX não possuem esse pré-requisito para usar o que os programas possuem de bom. Por exemplo, esse programas possuem apenas 4 métodos de interpolação dos termos de divergente, gradiente e laplaciano. Eles normalmente escolhem o básico (tal qual foi minha recomendação aqui) e usualmente aplica os mesmo método a todos os termos mencionados. O OpenFOAM possui quase 70 métodos de interpolação que podem (e não que devem) ser usados nos termos de divergente, gradiente e laplaciano. E cada termo pode ter uma definição diferente. Faça uma escolha errada e adeus solução.

Informações adicionais e o manual do OpenFOAM

Infelizmente, o manual do OpenFOAM não é completo. O manual é muito, mas muito incompleto. Ok, todos os manuais são superficiais, mas informações como "algumas vezes o usuário será obrigado a declarar um dado termo no fvScheme que o programador exige que assim seja feito" ou mesmo a simples lista dos métodos disponíveis devia ser um pouco mais completa. Ter referências seria perfeito, mas não espere isso do manual do OpenFOAM.

Portanto, a melhor, senão a única, forma de aprender sobre os métodos do OpenFOAM é colocar a mão na massa e estudar o código. Sim, o código. A vantagem do OpenFOAM é o fato de ser código livre e lhe dar direito de ver exatamente aquilo que está implementado. Usar isso é o que torna possível ir além.

O manual do programador também ajudará muito na análise do problema, mas assim como o manual do usuário não vai dizer tudo que nós gostaríamos de saber.

Agradecimentos

Por fim, lembre-se, você certamente precisa de ajuda. Esse tópico, por exemplo, somente tem a quantidade de informações que ele possui porque eu tirei dúvidas com a Livia, o Jovani e o Luiz. Eles possuem mais experiências que eu, tanto no uso prático do programa, pois eu estou começando no OpenFOAM, quanto nos conceitos teóricos, pois o Luiz já lecionou uma disciplina apenas para falar sobre isso e eu, até hoje, não conheço os métodos além da superfície e não tenho grandes experiências com os diferentes métodos numéricos e de discretização disponíveis. Na verdade, isso é uma conclusão rápida derivada do fato de que os aplicativos são mal documentados. Não há caminho fácil se quiser realmente mergulhar no entendimento do OpenFOAM, mesmo como simples usuário.


Para não esquecer
Quero lembrar que ainda estou utilizando o OpenFOAM-1.6-dev. Apesar de haver algumas diferenças, nada do que apresentei aqui difere muito das versões posteriores. Isso não será sempre verdade no futuro, portanto, fique atento ao fato de que estou utilizando o OpenFOAM-1.6-dev.