September 10, 2009

Resultado da enquete sobre programas CFD

O resultado de nossa enquete sobre "Qual o programa que usualmente utiliza para resolver seus problemas em CFD ?" segue reproduzido abaixo.

Ansys CFX
13 (30%)
Ansys Fluent
3 (6%)
OpenFOAM
9 (20%)
CFX e OpenFOAM
4 (9%)
Fluent e OpenFOAM
3 (6%)
CFX e Fluent
7 (16%)
Outro programa comercial
0 (0%)
Outro programa livre
0 (0%)
Código completamente próprio
4 (9%)


Eu posso escrever esse resultado de outra forma: Ansys CFX (24 votos), Ansys Fluent (13 votos) , OpenFOAM (16 votos) e Código próprio (4 votos).

Esse resultado impressiona, mas não surpreende:
  • A maioria usa programas da Ansys e o CFX é o líder,
  • Temos muitos usuários do OpenFOAM por aqui,
  • Há aqueles que estão criando códigos do zero.
Perguntas que me faço, são: Qual é seu entendimento do manual do CFX ? Já tentou fazer simulações que produziram resultados muito diferentes do esperado, melhor dizendo, já encontrou muito bugs ? Serão maioria os que fazem simulações transientes ou estacionárias ? Acredito que essas perguntas também são aplicáveis ao Fluent. E quanto ao OpenFOAM, somos usuários ou desenvolvedores ou os dois ? Como cria a malha ?

Também me pergunto o objetivo do código feito do zero. Desenvolvimento numérico ? Resolução de um problema específico que seria mais fácil ou produtivo implementar do zero do que em outro conjunto ? Aqui no lab, os que desenvolveram códigos do zero o fizeram antes do OpenFOAM e/ou tinha objetivo muito diferenciado pela aplicação.

Fiquem a vontade para dialogar pelos comentários.

July 19, 2009

Velha enquete e Nova enquete

Da série: dívida MUITO antiga, temos a enquete que foi fechada a meses e que ainda estava na barra lateral do site. Pois, a enquete perguntava: Qual assunto você gostaria que fosse mais abordado no blog?. E 48 leitores responderam:

Conceitos básicos
12 (25%)
Métodos numéricos
4 (8%)
Estudo de casos
8 (16%)
Programas CFD
6 (12%)
Modelagem
13 (27%)
Curiosidades
5 (10%)

Com 48 votos no total

Com zero valor estatístico, mas com uma grande surpresa. Mais de 50 % dos votos foram para conceitos básicos e modelagem. Eu, particularmente, não esperava isso. Eu esperava métodos numéricos. O lado interessante é que pelo menos de conceitos básicos e modelagem eu posso falar alguma coisa ...

Bom, estou tirando a enquete e colocando outra. Agora eu gostaria de saber Qual o programa que usualmente utiliza para resolver seus problemas em CFD ? Há três programas explicitamente escritos, Ansys CFX, Ansys Fluent e OpenFOAM. Há duas combinações desses três. Há opções para outro programa comercial e outro programa livre. Assim como opção para quem utiliza código completamente próprio. Nesse caso, não é para quem usa código livre, mas para quem usa código desenvolvido "em casa", ou seja, em sua própria equipe de trabalho.

May 14, 2009

LaTeX

Quem desenvolve ciência, certamente necessita escrever o que desenvolve (ok, você "necessita" não significa que esteja em dia com isso, mas deixamos isso debaixo do tapete, certo ?).

Como você escreve textos científicos ? Word ? Esqueça. O texto científico com formatação de alta qualidade deve ser feito em LaTeX.

De forma simplificado, podemos definir o LaTeX como uma linguagem de marcação criada para escrever texto formatado a partir de texto não formatado.

O que há de errado com as alternativas ?
  • Quem usa muita equação matemática, vê a diferença. O visual das equações matemáticas em LaTeX é muito superior do equivalente nos editores de texto tradicionais.
  • Em LaTeX você escreve o texto sem se preocupar com a formatação, depois ajusta o estilo. É muito mais fácil, muito mais simples de proceder durante o ato de escrever.
  • O LaTeX é texto puro. Completamente compatível com qualquer coisa.
  • Copiar/Colar nunca falha.
  • O texto longo com muitas equações e referências cruzadas nunca corrompe (é texto puro, lembra ?).
  • Não há chance de esquecer alguma referência na lista de referências.
  • Se alguém pedir para incluir um equação no meio do texto, a renumeração será automática, inteligente, funcional e não haverá chances de erros (o mesmo vale para tabelas, figuras, seções, etc).
  • Existe template em LaTeX para todos os artigos científicos em revistas e congressos internacionais (feitos lá fora, pelo menos).
  • Recentemente, os principais congressos internacionais ou nacionais realizados no Brasil também estão fornecendo templates em LaTeX.
  • Você passa mais tempo escrevendo do que reclamando da Microsoft.
Eu tenho mais argumentos, mas vou presumir que esses foram suficientes, se ainda não estiverem motivados, me avisem nos comentários.

Estou convencido, mas o que isso CFD e LaTeX têm em comum ?

Quando se escreve algo que envolve CFD, escreve-se muitas equações. MUITAS MESMO. Meu exame de qualificação do doutorado teve mais de 300 equações escritas. Sem contas as 53 figuras.

Pense bem, quanto tempo você levaria para rearrumar um texto que seja necessário incluir uma única equação entre a primeiras do documento ? Você quer estudar CFD ou contar equação ?

E nem me diga que o Word possui capacidade de ajustar automaticamente também, porque essa capacidade não funciona quando se tem 300 equações. Temos vários pontos amostrados no lab de quem tentou escrever teses e dissertações em Word e não dava certo.

CFD também envolve figuras. Ajustar as figuras no texto é sempre muito chato em um documento Word, porque a legenda sempre teima em ficar na página seguinte a da figura. Com o LaTeX isso nunca acontece.

Como começar ?

Antes de mais nada você precisa instalar o LaTeX no seu computador.

Se usa o GNU/Linux isso você instala os pacotes que iniciem por texlive- ou tetex- e o mais relevante de tudo será instalado (não inclua os pacotes de linguagens desnecessários a você). Veja um exemplo para sistemas baseados em Debian, no wiki do vimbook. A forma que eu prefiro consiste em instalar o Kile e todos os pacotes recomendados (pelo Synaptics no Ubuntu, isso é o comportamento padrão, em outras distribuições pode requer adicionar mais algum pacote. Leia sobre pacotes recomendados pelo Kile no programa de instalação da sua distribuição). Por sinal, o Kile é uma IDE para edição de textos em LaTeX que eu recomendo para todos que não possuem uma familiaridade muito grande com os comandos em LaTeX, pois ele deixa os comandos acessíveis por ícones clicáveis. Outra alternativa (ainda que eu mantenha a sugestão de instalar o Kile) é utilizar o plugin de LaTeX para o gedit (em algumas distribuições existe um pacote especial para instalar esse plugin. Plugins no gedit trabalham de forma complementar, portanto, não deixe de avaliar os demais existentes.).

Para Windows pode-se usar o MiKTeX, de fato eu não possuo qualquer experiência com relação a uso de LaTeX no Windows, mas experiência de terceiros com esse programa parece bem produtiva. Há outras interfaces ? Sim, mas como eu não conheço nenhuma, deixo para os que conhecem divulgarem nos comentários.

Tudo instalado, como começar a escrever ?

Escrever o básico em LaTeX é muito fácil. Especialmente porque não requer quase nenhum conhecimento sobre a linguagem em si. É apenas texto. Quero dizer, abra seu editor de textos puro predileto (gedit/kate/vim/Bloco de notas) e escreva.

Mas a verdade é que todos os autores desejam fazer algo além de texto puro. Usar negrito, itálico, títulos, etc.
Além de inserir figuras, equações, tabelas, etc.

Para tal segue algumas referências existentes na internet:
Insista e divulgue sua experiência

Há dois tipo de pessoas, as que desistem rápido, achando que não tem tempo para aprender, e as que insistem. O problema é que no meio acadêmico ninguém tem mesmo tempo. O tempo é curto para tudo. Tudo que eu posso dizer é: insista. Supere as dificuldades dos primeiros documentos e insista. Tão logo a curva de aprendizado inicial seja ultrapassada, tudo fica muito mais simples, muito mais produtivo.

No fim, divulgue sua experiência. Seja ela qual for. Isso contribui para avaliar o prós e contras e ajuda a formar opinião e a superar a barreira que divide os crédulos dos incrédulos. Sim, porque tem gente que não acredita quando eu digo nas referências bibliográficas não há citações faltando (entenda, todas as citações mencionadas no texto estão no final do arquivo. Qualidade do texto é outra história.) ou quando eu digo que posso adicionar uma equação no meio do texto facilmente e sem problema algum.

May 13, 2009

Desenvolvimento no OpenFOAM

Este post surgiu em resposta à dúvida do Vitor Henrique no Grupo de Discussão do CFD-Brasil. Para aqueles que queiram mais detalhes, visitem o grupo de discussão.

Para desenvolvimento de códigos próprios, ou seja, novos solvers ou utilitários, tanto faz usar a versão fornecida pelo site da OpenCFD ou as versões de desenvolvimento disponíveis. Em ambas você tem a possibilidade de criar seus códigos. Para quem está iniciando o uso tanto do Linux quanto do OpenFOAM, eu até sugiro que se comece pela versão do site. Quando se sentir mais confiante e com mais traquejo em Linux, migre para uma versão de desenvolvimento. Lógico que não preciso dizer que o conhecimento da linguagem de programação C++ é importante, né?

Porque existem as versões de desenvolvimento?

  • Bugs são possíveis em qualquer código, seja ele livre ou não. Quando se descobre um bug, ele pode ser corrigido e imediatamente incorporado à versão de desenvolvimento. Na versão do site, as correções serão incorporadas apenas na próxima versão do OpenFOAM.
  • Contribuições de terceiros podem ser anexadas ao OpenFOAM a qualquer momento. Ou seja, novos solvers, utilitários, novas funcionalidades, etc. podem ser adicionados a qualquer momento na versão de desenvolvimento.

Existem outras vantagens em usar as versões de desenvolvimento, mas para mim, as principais são as que coloquei acima. Contudo, acredito que o usuário tenha que ter um conhecimento mais profundo tanto do sistema quanto do funcionamento do OpenFOAM para usar essas versões. Imagine você, ainda aprendendo a usar e programar no OpenFOAM e tendo que compilar tudo (!) do zero, tendo que verificar alguns erros de compilação (possíveis de acontecer) quando atualiza o OpenFOAM para a versão mais nova? Eu não vejo isso como vantagem, até que você tenha conhecimento suficiente para poder lidar com isso. Aprenda a compilar seus próprios solvers, depois compile o OpenFOAM por inteiro. Um passo de cada vez.

Mas isso é uma escolha pessoal. Você pode querer começar o seu aprendizado pela compilação, sei lá... Existem vários recursos que podem ser usados para auxiliar e acomodar o OpenFOAM ao sistema. Entre essas funcionalidades, compilação de códigos em paralelo, usar o compilador do próprio sistema, otimização com o processador, bibliotecas diferentes do padrão, etc.

Existem duas versões de desenvolvimento, obtidas através dos programas git e svn.

A versão git é desenvolvida e atualizada pela OpenCFD, mantenedora oficial do OpenFOAM. Já a versão fornecida pelo svn é mantida pelo Prof. Hrvoje Jasak (Wikki). Eu uso essa última e tenho vários motivos para tal, entre eles:

  • Atualização muito rápida. Qualquer erro (e são muito poucos) são corrigidos e atualizados quase que imediatamente.
  • Por filosofia, o Prof. Jasak é muito mais aberto à incorporar contribuições de terceiros. Com isso, possui muito mais solvers e utilitários.
  • Funcionalidades exclusivas, implementadas pela comunidade do OpenFOAM.
  • O Hrvoje faz questão de manter sua versão de desenvolvimento em harmonia com a da OpenCFD. Nota: houve uma grande mudança na estrutura do OpenFOAM-1.4.1 para a 1.5. O Jasak adaptou tudo para ficar de acordo com o padrão escolhido pela OpenCFD.
  • Quando o Hrvoje veio para o Brasil para a minha banca de defesa de doutorado, levei ele e a esposa ao bar Devassa na Barra da Tijuca. Pô, o cara fez questão de pagar a minha cerveja!! Não tem como, uso a versão dele...

Brincadeiras à parte, na minha opinião, a OpenCFD é um pouco fechada em relação a receber e incorporar as contribuições da comunidade do OpenFOAM. E eu, por filosofia, não gosto disso.

Para quem quer tentar compilar a versão OpenFOAM dev do svn, deve ter instalado em seu computador os seguintes pacotes (nomes relativos à distribuição Linux OpenSuse):

subversion
binutils
mpfr
gmp
flex++

Para maiores referências, leia as mensagens no Fórum do OpenFOAM, em especial esta aqui.

Para baixar a versão dev, vá ao diretório ~/OpenFOAM e use o comando:

svn checkout http://openfoam-extend.svn.sourceforge.net/svnroot/openfoam-extend/trunk/Core/OpenFOAM-1.5-dev/ OpenFOAM-1.5-dev/

A última versão do código fonte do OpenFOAM-1.5-dev será baixado em seu computador. Para compilação, vá ao diretório OpenFOAM-1.5-dev e execute:

./Allwmake

Note que TUDO será compilado e esse processo pode ser um pouco demorado, dependendo da configuração da sua máquina e das suas configurações no OpenFOAM.

Então, fica aí a dica para os novos desenvolvedores no OpenFOAM. Boa sorte!
Um abraço!

May 12, 2009

Introdução ao GNU/Linux

No início do ano eu filosofei sobre CFD, Linux e vim, tentando mostrar a relação entre esses pontos.

Em abril desse ano, eu apresentei o curso de extensão `Introdução ao GNU/Linux'' no Programa de Engenharia Química (COPPE/UFRJ).

Com o objetivo de prover uma referência por escrito e atualizada sobre o GNU/Linux, eu comecei a escrever um documento que ganhei volume e corpo de um livro. Livro esse que eu tenho o prazer de anunciar como um projeto livre.

O livro Introdução ao GNU/Linux está disponível para download em PDF, e no código fonte. Esse livro tende a ter novas versões periodicamente, portanto, pode lhe interessar uma visita mensal ao site do projeto para obter as versões mais novas do PDF.

Ele foi escrito para um público que nunca teve contato com o sistema operacional GNU/Linux, mas não para quem nunca teve contato com computadores.

Sobre o Livro "Introdução ao GNU/Linux"

O GNU/Linux é um sistema operacional, que por definição é um programa responsável por conectar o usuário ao hardware, capaz de unificar o núcleo criado por Linus Torvalds em 1991 e diversas ferramentas criadas por terceiros.

Esse livro introduz ao leitor detalhes sobre (i) a arquitetura do GNU/Linux, partindo de um breve histórico até sua estrutura atual, (ii) os principais softwares para uso em computadores pessoais, como gerenciadores de arquivos, editores de texto, navegadores de internet, entre outros, (iii) os principais utilitários para uso de terminal, como man, ls, rm, cat, ssh, scp, entre outros e (iv) completando com um guia de sobrevivência na administração de um sistema GNU/Linux, apresentando os utilitários de configuração de rede, impressora, instalação de programas, além de outros pontos associados a utilização do GNU/Linux em computadores pessoais.

Sobre a licença do livro

O uso deste documento é regido pela licença GNU Free Documentation License, Versão 1.3 ou qualquer outra publicada posteriormente, da Free Software Foundation. Uma cópia dessa licença pode ser lida no anexo D ou no página http://www.gnu.org/copyleft/fdl.html.

Resumindo, a GNU Free Documentation License permite que você copie, modifique e/ou redistribua o documento inteiro ou parte do documento sobre os seus termos e respeitando as seções invariantes (no caso desse documento, são apenas as licenças em si).

A única exigência da GNU FDL é que os autores originais devem ser referenciados (não abre-se mão do direito autoral, algo que eu não poderia fazer nunca no Brasil) e de que a parte do conteúdo utilizado em outros trabalhos proveniente desse projeto (uma figura ou capítulo, por exemplo) também deve ser distribuído pela GNU FDL.

Mais Informações

Para informações adicionais sobre a licença do livro, como colaborar com projeto, etc. podem ser encontradas no tópico do anúncio oficial do livro.

April 19, 2009

CFD em Bioengenharia

As pessoas são tão diferentes por dentro quanto são por fora, tornando difícil predizer que tipo de cirurgia seria a mais adequada para cada paciente. Desde 2005, uma abordagem envolvendo alta tecnologia vem sendo usada pela Universidade de Stantford para predizer o sucesso (ou não) da cirurgia em determinado paciente.

Este método elimina as suposições sobre o sucesso de cirurgias cardiovasculares. Usando modelos matemáticos, os bioengenheiros constroem um modelo 3D personalizado do coração de cada paciente (incluindo sua respectiva doença cardiovascular) e, então, realizam uma cirurgia virtual neste modelo antes que isto seja feito efetivamente no paciente. O objetivo desta abordagem é realizar mais cirurgias com sucesso e eliminar as operações desnecessárias. Foto de uma paciente em um exame de ressonância magnética (autor Gaetan Lee).

A modelagem deve incorporar dados de imagens em um programa de visualização científica 3D que inclua também ferramentas cirúrgicas. Milhões de equações para representar o escoamento do sangue no corpo humano e a fisiologia individual do paciente são usadas para demonstrar o que pode ocorrer em várias situações "E se tentarmos isso...". A flexibilidade das veias e artérias também devem ser consideradas na modelagem.

Por exemplo, é possível verificar o sucesso de uma cirurgia para melhorar a irrigação de sangue nas pernas do paciente durante uma cirurgia. Com os modelos 3D das veias na perna, verifica-se quais seriam os possíveis caminhos (veias) para o sangue escoar até o local desejado. Por sua vez, os modelos matemáticos seriam capazes de predizer se, nas condições da cirurgia, as veias seriam capazes de suportar o fluxo de sangue ou arrebentariam. Neste último caso, obviamente a cirurgia não seria bem sucedida.

Ao final de 2006, pesquisadore do Instituto de Tecnologia da Georgia e da Universidade de Emory verificaram a aplicação destas técnicas em cirurgias pediátricas. Neste caso, toda a modelagem 3D (geometria) do coração do paciente vem de diversas imagens de ressonância magnética (IRM) obtidas durante o ciclo cardíaco.

Hoje em dia, o uso de CFD aplicado ao corpo humano de modo a avaliar melhor o seu funcionamento e predizer o sucesso de cirurgias já está sendo bem difundido.

Projeto de válvulas cardíacas mecânicas
Em outra linha de pesquisa, existe o projeto de válvulas artificiais para o coração usando CFD. A válvula cardíaca consiste de duas membranas (válvulas) que são livre para abrir e fechar conforme o sangue escoa para dentro e fora do coração durante o ciclo cardíaco. Para modelar esta interação fluido/estrutura, deve-se considerar algumas características fisiológicas de modo a acoplar o movimento de abertura e fechamento das válvulas de acordo com o escoamento do sangue. Diferente de aplicações de engenharia hidráulica, onde o escoamento é rápido o bastante para permanecer turbulento, a batida do coração promove uma mudança contínua na velocidade e direção do escoamento do sangue através da válvula. Foto abaixo de um coração artificial tirada por Green Flames.


Em sua maioria, o escoamento é ordenado e laminar exceto por um breve período de tempo próximo ao pico da sístole, onde o escoamento se torna caótico e turbulento. Justamente durante este curto período, os pesquisadores suspeitam que o ambiente se torne mais prejudicial aos elementos do sangue. Um grupo de pesquisa numérica do Instituto de Tecnologia da Georgia está desbravando o desenvolvimento e aplicação de modelos para turbulência capazes de captar de forma acurada esta transição contínua entre os comportamentos laminar e turbulento.

Links para os interessados e curiosos: Predizendo o sucesso nas cirurgias, CFD em válvulas cardíacas e CFD com IRM 4D. Mais alguns sites interessantes com informações sobre o assunto (contendo várias imagens e vídeos):
Um abraço e até mais!

April 13, 2009

Congressos em 2009

Junto neste post um levantamento dos congressos e encontros brasileiros, a serem realizados em 2009, mais relevantes para CFD, fenômenos de transporte em geral e métodos numéricos. Estou colocando apenas os congressos cujas datas limite para envio de trabalho ainda não foram atingidas. Portanto, ainda dá tempo de participar!

  • COBEM 2009 : Congresso Internacional de Engenharia Mecânica, a ser realizado em Gramado, RS. Contém temas relevantes, como combustão, engenharia aeroespacial, ciências térmicas, mecânica dos fluidos e reologia.
  • COBEQ-IC 2009 : Congresso Brasileiro de Engenharia Química em Iniciação Científica, a ser realizado em Uberlândia, MG. Congresso com temas bem gerais (fenômenos de transporte, transferência de calor e massa, métodos numéricos, etc) e voltado para os alunos de graduação em engenharia química. Já participei em 2001 e recomendo o envio de trabalhos. Foi uma experiência muito boa para mim.
  • CNMAC 2009 : Congresso Nacional de Matemática Aplicada e Computacional, a ser realizado em Cuiabá, MT. Como o nome diz, seria mais voltado aos pesquisadores em métodos e algoritmos numéricos em CFD.
  • [UPDATE] ENEMP 2009 : Congresso Brasileiro de Sistemas Particulados. É um congresso famoso na minha área e normalmente com trabalhos de peso. Antigamente era bastante voltado para a área experimental, mas hoje abrange também as simulações CFD de sistemas particulados. A ser realizado em Campinas - SP, de 18 a 21 de outubro. Os resumos podem ser enviados até final de junho.
  • [UPDATE] PACAM XI 2010: Pan American Congress of Applied Mechanics, com foco em mecânica aplicada e inclui temas como Mecânica dos Fluidos e Fluidos não Newtonianos (simulação de fluidos complexos). Este congresso será realizado no início de 2010, mas o deadline para submissão de trabalhos se encerra em 30 de março de 2009. Ainda dá tempo!
Estes são apenas alguns dos eventos deste ano. Se você conhece mais um congresso relevante ou tem alguma sugestão, por favor, deixe um comentário aqui. Vou ir atualizando este post conforme as novas informações cheguem. Fique de olho!

Para congressos em geral, acesse ABEQ e ABCM.

Um abraço e até mais!

April 9, 2009

Concurso Científico Tecnoclasta 2008/2009

Apesar do pouco tempo, ainda há tempo. O prazo para o Concurso Científico Tecnoclasta 2008/2009 vai até amanhã, 10 de abril.

Já fiz a minha inscrição - veja os inscritos nos comentários - e talvez o Luiz faça a dele amanhã. Eu quase perdi o prazo... Talvez, considerando que o prazo termina na sexta-feira santa, ele seja estendido (mas não conte com isso). O prazo foi prorrogado até o dia 17 de abril.

Esse ano o concurso incluí duas categorias, uma das quais permite que quem não tenha blogs também participe. Veja as regras no tópico do Tecnoclasta.

Vale lembrar que mais do que um concurso com prêmios, essa iniciativa é uma forma divulgar informação científica de qualidade pela net.

Lamento de ter esquecido de divulgar o concurso antes e espero mesmo que tenha uma pequena prorrogação em função do feriado.

April 8, 2009

Parabéns ao Luiz !

Senhoras e Senhores,
o Luiz acaba de ser aprovado como professor da Escola de Química da UFRJ.

O resultado do concurso saiu a alguma horas ... ainda falta uns 2 meses para cumprir a burocracia, mas ...

Eu deixo aqui meus sinceros parabéns e boa sorte ao Luiz em sua nova e promissora carreira. E de quebra me deixa mais orgulhoso de dividir o blog com alguém que agora é importante.

Esperamos que ele agora tenha mais tempo para escrever nesse blog ...

March 18, 2009

Curso no COBEQ-IC 2009

Fui convidado pela Profa. Valéria Murata, da Universidade Federal de Uberlândia, a ministrar um minicurso de CFD no próximo Congresso Brasileiro de Engenharia Química em Iniciação Científica (COBEQ-IC). O congresso será realizado em Uberlândia - MG, entre os dias 27 e 30 de julho de 2009.

O minicurso terá carga horária de 8 horas e será ministrado no dia 27, de 8:00 às 12:00 (parte teórica sobre CFD) e de 14:00 às 18:00 (parte prática usando o OpenFOAM). O curso será realizado no laboratório de informática da Faculdade de Engenharia Química e terá vagas limitadas. A ementa geral do curso se encontra abaixo:
  • Conceitos gerais sobre fluidodinâmica computacional
  • Características do OpenFOAM
  • Aplicações na Engenharia Química
Eu já tinha preparado um curso de CFD que ministrei no passado (UFRJ, UERJ e UFF), mas quero atualizá-lo e estendê-lo, visando o pessoal da graduação. Como me conheço, sei que no fim devo ter um curso todo novo para ministrar. O que é muito bom!!

Outros dois minicursos também estão disponíveis. Veja mais detalhes no site do COBEQ-IC (aba Instruções -> Minicursos). Aproveito a oportunidade para agradecer a Profa. Valéria pelo convite.

Um abraço e, para quem for ao COBEQ-IC, encontro você lá!

February 10, 2009

Análise de código no OpenFOAM - laplacianFoam

Para explicar a estrutura e o algoritmo de solução de um código no OpenFOAM, vou usar como base o solver laplacianFoam. Para acompanhar melhor esse post, é interessante que o leitor tenha alguns conhecimentos básicos da sintaxe de C++. Porém, vou apresentar alguns detalhes referentes aos comandos e funções que são membros das classes e templates, facilitando a leitura do código para os leitores sem experiência em linguagens orientadas a objetos.

O solver laplacianFoam é usado para resolver o problema da difusão pura de um campo escalar T, sem considerar nenhum termo fonte. Esta equação está colocada abaixo, sendo D o coeficiente de difusão.

Os arquivos referentes aos solvers do OpenFOAM ficam no diretório OpenFOAM-version/applications/solvers., onde version se refere a versão do OpenFOAM. O código do laplacianFoam fica no diretório basic e está colocado abaixo.
00001 /*---------------------------------------------------------------------------*\
00002 ========= |
00003 \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
00004 \\ / O peration |
00005 \\ / A nd | Copyright (C) 1991-2008 OpenCFD Ltd.
00006 \\/ M anipulation |
00007 -------------------------------------------------------------------------------
00008 License
00009 This file is part of OpenFOAM.
00010
00011 OpenFOAM is free software; you can redistribute it and/or modify it
00012 under the terms of the GNU General Public License as published by the
00013 Free Software Foundation; either version 2 of the License, or (at your
00014 option) any later version.
00015
00016 OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
00017 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
00018 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
00019 for more details.
00020
00021 You should have received a copy of the GNU General Public License
00022 along with OpenFOAM; if not, write to the Free Software Foundation,
00023 Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
00024
00025 Application
00026 laplacianFoam
00027
00028 Description
00029 Solves a simple Laplace equation, e.g. for thermal diffusion in a solid.
00030
00031 \*---------------------------------------------------------------------------*/
00032
00033 #include "fvCFD.H"
00034
00035
00036 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
00037
00038 int main(int argc, char *argv[])
00039 {
00040
00041 # include "setRootCase.H"
00042
00043 # include "createTime.H"
00044 # include "createMesh.H"
00045 # include "createFields.H"
00046
00047 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
00048
00049 Info<< "\nCalculating temperature distribution\n" << endl;
00050
00051 for (runTime++; !runTime.end(); runTime++)
00052 {
00053 Info<< "Time = " << runTime.timeName() << nl << endl;
00055 # include "readSIMPLEControls.H"
00056
00057 for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
00058 {
00059 solve
00060 (
00061 fvm::ddt(T) - fvm::laplacian(DT, T)
00062 );
00063 }
00064
00065 # include "write.H"
00066
00067 Info<< "ExecutionTime = " << runTime.elapsedCpuTime() <<" s"
00068 << " ClockTime = " << runTime.elapsedClockTime() <<" s"
00069 << nl << endl;
00070 }
00071
00072 Info<< "End\n" << endl;
00074 return(0);
00075 }
00076
00077
00078 // ************************************************************************* //
Para acompanhar a leitura, sugiro que você abra diretamente o arquivo laplacianFoam.C em um editor de textos de sua preferência. De forma mais direta, você também acessar o código do laplacianFoam abrindo este link em uma outra aba do seu navegador.

A primeira linha a ser executada no código (linha 33) declara a biblioteca fvCFD.H, que fornece ao solver acesso a todas as classes e propriedades descritas em meu post anterior. Deve-se frisar que é vital declarar esta biblioteca. Na linha 38, a função main engloba todo o código fonte principal e possui dois argumentos de entrada: o inteiro argc e a cadeia de caracteres argv. Estes parâmetros contém informações sobre a simulação, como o diretório e o nome do caso a ser simulado. Os argumentos são lidos pelo programa diretamente na linha de comando para execução do solver.

A biblioteca setRootCase.H é usada para testar a validade dos argumentos argc e argv da simulação. O conteúdo desta biblioteca está colocado abaixo.
00001 Foam::argList args(argc, argv);
00002
00003 if (!args.checkRootCase())
00004 {
00005 Foam::FatalError.exit();
00006 }
O primeiro comando do código acima declara a variável args construída com os argumentos argc e argv, a partir da classe argList. Em seguida, o comando checkRootCase() verifica a validade e a existência do diretório e do nome do caso simulado. Caso o retorno de checkRootCase() seja False, a execução do solver é interrompida pelo comando padrão de erro do OpenFOAM FatalError.

As duas próximas bibliotecas declaradas, createTime.H e createMesh.H, são responsáveis pela criação de bancos de dados para armazenar dados sobre o caso simulado e a estrutura da malha utilizada. O código colocado abaixo refere-se à biblioteca createTime.H.
00001     Foam::Info<< "Create time\n" << Foam::endl;
00002
00003 Foam::Time runTime
00004 (
00005 Foam::Time::controlDictName,
00006 args.rootPath(),
00007 args.caseName()
00008 );
Sendo construída a partir de informações sobre o nome e o diretório do caso simulado (provindas de args), a variável runTime do template Time é declarada no código acima. Desta forma, runTime obtém a localização do arquivo de configuração controlDict do caso e, utilizando as informações contidas neste último, monta um banco de dados para controle da simulação. Por exemplo, pode-se citar alguns dos dados contidos em runTime: (i) instante inicial e final; (ii) controle do passo de tempo (fixo, adaptativo, etc.); (iii) diretórios que contém os arquivos com os campos iniciais das propriedades transportadas; (iv) controle de escrita em arquivo (formato de saída, compressão de dados, etc.); entre outros.

A biblioteca createMesh.H usa o template fvMesh para declarar a variável mesh, construída a partir de outro template chamado IOobject, como mostra o código a seguir.
00001     Foam::Info<< "Create mesh for time = "
00002 << runTime.timeName()<< Foam::nl << Foam::endl;

00003
00004 Foam::fvMesh mesh
00005 (
00006 Foam::IOobject
00007 (
00008 Foam::fvMesh::defaultRegion,
00009 runTime.timeName(),
00010 runTime,
00011 Foam::IOobject::MUST_READ
00012 )
00013 );
O template IOobject define os atributos de um objeto de modo a fornecer meios para entrada e/ou saída de dados (usualmente em arquivo). Com as informações de runTime, o template fvMesh é capaz de localizar os arquivos cells, faces, points e boundary para construção da malha. Note que o último parâmetro na construção de IOobject refere-se à regras de leitura e escrita de arquivos. Neste caso, a leitura dos dados deve ser obrigatória (MUST_READ).

Todas as bibliotecas supracitadas são gerais e podem ser usadas em qualquer código do OpenFOAM (salvo pequenas modificações já comentadas). Contudo, a biblioteca createFields.H é usada para criação e leitura dos campos iniciais das incógnitas do problema e leitura de propriedades físicas aplicadas a cada caso (propriedades de transporte, termodinâmicas, termofísicas, etc.). Desta forma, este header é específico para cada solver e deve ser desenvolvido com cuidado pelo programador, pois todas as incógnitas e todas as propriedades físicas do problema devem ser definidas neste arquivo. Portanto, deve-se ter domínio do modelo fluidodinâmico e qual a melhor forma de armazenar suas variáveis de modo a otimizar o código. A biblioteca createFields.H específica para o laplacianFoam está colocada abaixo.
00001     Info<< "Reading field T\n" << endl;
00002
00003 volScalarField T
00004 (
00005 IOobject
00006 (
00007 "T",
00008 runTime.timeName(),
00009 mesh,
00010 IOobject::MUST_READ,
00011 IOobject::AUTO_WRITE
00012 ),
00013 mesh
00014 );
00015
00016
00017 Info<< "Reading transportProperties\n" << endl;
00018
00019 IOdictionary transportProperties
00020 (
00021 IOobject
00022 (
00023 "transportProperties",
00024 runTime.constant(),
00025 mesh,
00026 IOobject::MUST_READ,
00027 IOobject::NO_WRITE
00028 )
00029 );
00030
00031
00032 Info<< "Reading diffusivity DT\n" << name="l00033">00033
00034 dimensionedScalar DT
00035 (
00036 transportProperties.lookup("DT")
00037 );
Para resolver o problema, a temperatura deve ser definida em um campo geométrico (template geometricField). Fisicamente, a temperatura é uma variável escalar e, portanto, deve-se criar um campo geométrico de um escalar. O template volScalarField constrói um campo escalar da variável T, definida no centro das células da malha mesh. A criação deste campo depende dos templates IOobject e fvMesh como argumentos de entrada. O primeiro constrói o objeto, definindo o nome da variável e do arquivo que contém os valores do campo inicial de T (O nome do arquivo que contém o campo inicial da variável é idêntico ao nome da própria variável), o registro das informações contidas em runTime (por exemplo, o diretório e a periodicidade da saída de resultados em arquivo) e as opções de entrada e saída de dados (MUST_READ indica que o campo inicial de T deve ser necessariamente lido e AUTO_WRITE configura a saída automática de T em arquivo ao longo do tempo). O segundo parâmetro para a criação de T é o template fvMesh definido como mesh, que indica onde o campo escalar T será alocado e inserido.

A equação da difusão possui apenas uma propriedade física de transporte, a condutividade térmica DT (representada pela letra D na equação da difusão). A leitura das propriedades de transporte é realizada através do template IOdictionary, construída a partir do template IOobject como argumento. O template IOdictionary, por sua vez, é derivada de outros dois templates, dictionary e IOobject, proporcionando funcionalidade na entrada e saída de dados automática a partir de um banco de dados. O template dictionary define uma lista de palavras chave, onde cada uma destas é associada a um número arbitrário de valores. A construção de transportProperties declara o nome do arquivo que contém as propriedades de transporte e seu diretório (runTime.constant()) e as regras de leitura (MUST_READ) e saída (NO_WRITE) de dados em arquivo. Por fim, a criação da variável escalar dimensional DT é construída pelo comando transportProperties.lookup("DT"), que procura no arquivo transportProperties a palavra-chave "DT" e associa um valor dimensional a essa variável.

As etapas descritas acima apenas inicializam os dados para runTime, a malha mesh, o campo inicial de T e a propriedade de transporte DT do código principal. O próximo passo é programar o algoritmo de solução do problema específico.

O laço for, iniciado na linha 51 do código principal, tem o intuito de repetir as instruções no interior do laço para cada passo de tempo (incrementado por runTime++). O laço é realizado até que a condição de runTime.end() seja satisfeita (retorne true).

O primeiro comando no interior do laço é a declaração do header readSIMPLEControls.H para leitura dos parâmetros do método SIMPLE de acoplamento pressão-velocidade e das condições de ortogonalidade da malha. Estes parâmetros são lidos no arquivo fvSolution do caso analisado. Apesar de não ser necessário aplicar o método SIMPLE para resolver a equação da difusão pura, esta biblioteca lê o número de iterações para correção dos fluxos devido à não-ortogonalidade da malha. Isso é necessário pois o OpenFOAM divide o cálculo do fluxo através das faces em duas parcelas chamadas contribuição ortogonal e a correção não ortogonal. Esta correção é realizada um laço para ajustar o fluxo das propriedades nas faces dos volumes, semelhante ao esquema defferred correction. Maiores detalhes podem ser encontrados na tese do Prof. Jasak.

A discretização por volumes finitos é realizada pelo template fvm, armazenando as equações discretizadas em sua forma matricial com o template fvMatrix e montando um sistema de equações lineares resolvido pelo comando solve. Este último comando retorna na tela para o usuário dados estatísticos da solução, como a convergência do sistema, número de iterações, etc. A definição das formulações de discretização usadas na simulação estão colocadas no arquivo fvShemes. A solução do sistema algébrico, cujo método de solução está selecionado no arquivo fvSolution, retorna a temperatura em cada célula da malha. A biblioteca write.H, colocada abaixo, escreve os arquivos de resultados quando o comando de classe runTime.output() for válido.
00001     if (runTime.outputTime())
00002 {
00003 volVectorField gradT = fvc::grad(T);
00004
00005 volScalarField gradTx
00006 (
00007 IOobject
00008 (
00009 "gradTx",
00010 runTime.timeName(),
00011 mesh,
00012 IOobject::NO_READ,
00013 IOobject::AUTO_WRITE
00014 ),
00015 gradT.component(vector::X)
00016 );
00017
00018 volScalarField gradTy
00019 (
00020 IOobject
00021 (
00022 "gradTy",
00023 runTime.timeName(),
00024 mesh,
00025 IOobject::NO_READ,
00026 IOobject::AUTO_WRITE
00027 ),
00028 gradT.component(vector::Y)
00029 );
00030
00031 volScalarField gradTz
00032 (
00033 IOobject
00034 (
00035 "gradTz",
00036 runTime.timeName(),
00037 mesh,
00038 IOobject::NO_READ,
00039 IOobject::AUTO_WRITE
00040 ),
00041 gradT.component(vector::Z)
00042 );
00043
00044
00045 runTime.write();
00046 }
Com o intuito de também escrever em arquivo os componentes do gradiente da temperatura, calcula-se gradT pela classe fvc que realiza operações tensoriais explícitas com os dados da malha. Note que, como a temperatura é uma variável escalar, seu gradiente será uma entidade vetorial, e portanto o tipo da variável gradT deve ser um volVectorField. As linhas 5, 18 e 31 do código acima decompõem gradT nas direções X, Y e Z do domínio e definem esta variável como AUTO_WRITE para que a saída em arquivo seja automática. Cada decomposição é, portanto, um volScalarField e será formado pela componente do vetor de gradT da respectiva direção. O comando runTime.write() escreve em arquivos os valores de temperatura nos centros das células, seus gradientes e os componentes do gradiente.

O algoritmo repete-se até o fim do laço no tempo e, por consequência, o final da simulação. Na minha opinião, o solver laplacianFoam possui o código mais simples de todos. A complexidade dos códigos aumenta junto com o detalhamento dos fenômenos físicos considerados, sendo necessário o desenvolvimento de algoritmos mais elaborados, o uso de mais templates, classes e comandos.

Espero que este post seja de ajuda aos que estão começando a estudar e desbravar a programação no OpenFOAM. Se quiserem discutir mais sobre o assunto ou mesmo trocar idéias, deixe um comentário aqui.

Um abraço!

January 21, 2009

CFD, Linux e vim

Quem usa amplamente o CFD, usa cluster. Quem quer grande eficiência no uso do cluster, usa GNU/Linux. E quem usa GNU/Linux, usa o vim.

A questão que fica é que nem sempre quem estuda/usa CFD conhece o suficiente do GNU/Linux para lidar corretamente com as ferramentas de terminal. Tudo bem, todo mundo tem sua curva de aprendizado, e é verdade que o terminal, mesmo não sendo complicado, não é o melhor lugar para começar a aprender.

E o problema fica por conta do fato de que clusters nem sempre possuem interface gráfica. Ou possuí interface gráfica, mas você sempre trabalha via ssh, o que nem sempre fornece uma velocidade de conexão agradável se você for abrir três/quatro programas gráficos para utilização remota junto com outros 20 usuários fazendo a mesma coisa. O outro problema é que na nossa área não são raros os usuários do windows que fazem o acesso a clusters com linux via terminal, o que raramente permite uma fácil conexão gráfica (eu realmente sugiro que instale uma distribuição linux para trabalhar com CFD). Por essas e outras não mencionadas, conhecer o terminal do GNU/Linux é fundamental para quem usa CFD.

Tenho certeza de que todos rapidamente aprenderam a listar os arquivos com o ls, a copiar arquivos com o cp, a mover arquivos com o mv, a mudar de diretório com o cd. Mas e editar um arquivo ? O que você faz ?

Existem três opções aqui. Copiar o arquivo para sua máquina de trabalho, modificar e voltar o arquivo para o lugar (isso nem sempre é possível, porque as vezes queremos editar o arquivo que controla a solução do seu problema que está atualmente rodando no cluster, qualquer erro aqui pode ser faltal). Utilizar um aplicativo gráfico remotamente para editar o arquivo (nem sempre é possível por motivos já mencionados) ou editar o arquivo com um editor de terminal (o que é sempre possível).

Ficaria impressionado se eu dissesse que os melhores editores de texto são os feitos para o terminal ? Pois é, parece contraditório, mas não é. Reza a lenda (bem próxima da verdade) que são os editores utilizados por 10 entre 10 dos maiores programadores do mundo. E entre eles temos o vim.

O vim é um dos mais poderosos editores de texto do mundo. Eu costumo dizer que é um sistema operacional disfarçado de editor de textos. Seus inúmeros recursos mal podem ser listados, de tão numerosos e valiosos que são. Devem ser experimentados, para perceber a mesma coisa que eu percebo quando preciso editar um texto e meu instinto abre o terminal para usar o vim, mas não abre o gedit. E ainda conta com inúmeros plugins fazem quase tudo que uma pessoa precisa para sobreviver diante de um computador.

Quer a melhor parte ? O Sergio Luiz Araújo Silva, o autor do VIVAOTUX, lançou um livro em português sobre o vim. Você pode ajudar a melhorar ele, enviando sugestões e correções, ou até, para o caso de quem já conhece bem o vim, enviando novas dicas. O livro é um projeto colaborativo. Também foi criado um grupo em torno do livro para unir quem deseja colaborar com o mesmo diretamente, você também pode ajudar divulgando o livro e o grupo.

De qualquer forma, eu considero um livro obrigatório para qualquer um que utiliza linux para resolver CFD, especialmente, para os usuários do OpenFOAM. E um livro muito importante para qualquer um que queira aprender um pouco mais sobre o GNU/Linux.

January 4, 2009

Ajustando a escala dos resultados

Há muitos "anos" atrás, eu escrevi sobre a apresentação dos resultados, como tornar os resultados algo claro ao ouvinte/leitor.

[update] Oopps!!! Havia um erro básico na ordem das figuras nessa pequena introdução. Corrigido! Grato [/update]

Uma das questões que surge é o ajuste de escala. Acompanha comigo. Você vai fazer um gráfico de velocidade. O gráfico vai de um valor negativo a um valor positivo. O que você deve evitar a todo custo, é uma escala dessa forma:Sabe o que há de errado com ela ? Simples. O zero não aparece na escala. Oras, há uma cor que começa em um valor negativo e termina em um valor positivo. Essa cor pode ser qualquer coisa. Pode ter apenas valores positivos ou apenas valores negativos (muito embora, nesse caso específico, exista ambos). O adequado é ajustar a escala de forma que fique claro ao ouvinte/leitor quais são os valores negativos e quais são os valores positivos. Como essa escala:
Ok. Nessa escala existe um "zero negativo". Isso é um erro de truncamento. Desconsidere. Na margem de erro que eu estou trabalhando, três casas decimais, isso é zero.

Agora, como fazer isso ? Tentativa e erro ? Bem, isso até é possível, mas pode dar muito trabalho se tiver que achar os números ótimos que representam sua escala totalmente na base da tentativa e erro.

Ante de tudo, note que existem dois tipos de escalas. As simétricas, que vão de "-x" a "x" e as não simétricas, que vão de "-x" a "y" onde x é diferente de y em módulo.

O primeiro tipo, que foi a que eu representei nas escalas acima, é fácil de acertar. Coloque a escala de -x a x literalmente, ou seja, force limites simétricos, e coloque um número ímpar de divisórias (ou seja, um número par de cores). Nesse caso, obrigatoriamente, metade as cores representam números negativos e a outra metade representa números positivos.

O outro tipo de escala é mais complexa de ser construída. Mas existe uma equação que rege as "leis de escala". A regra é a seguinte:
Nela você relaciona a razão entre o módulo de limite superior e o módulo do limite inferior da escala (lado esquerdo da equação) com o número total de divisórias (cores, N) e o número de cores que representam a escala negativa (p).

É óbvio que você tem que definir alguma coisa. Por exemplo, eu tenho hábito de definir o número de cores que representa o lado negativo, o número total de cores que representa a escala e um dos limites. E uso a relação dada acima para encontrar o outro limite. Aí você vai me perguntar: qual limite ?. A reposta não pode ser mais antipática. Não sei ! Observe que há uma variável que não é descrita pela matemática. A qualidade do gráfico. Você teve que chutar o valor do número total de cores (10 é um bom valor) e o número de cores que representa a face negativa da escala (que depende do problema). Agora você vai ter que chutar mais alguma coisa. O valor de um limite da escala... então, tudo isso ainda vai ter que satisfazer a qualidade visual do gráfico.

Observe as duas escalas construídas abaixo. As duas tiveram N = 10 e p = 2. Porém, a primeira eu acertei o valor de -0.12 (note em módulo é 0.12) para o limite inferior da escala e calculei o limite superior (que foi 0.48). Enquanto na segunda eu coloquei chutei o limite superior de 0.60 e calculei o limite inferior (que foi 0.15, como eu sei que esse é o módulo de um número negativo, eu acertei a escala para -0.15). As duas escalas são possuem limites inferiores muito próximos, então, se eu tivesse chutado o valor de -0.15 no primeiro gráfico, eu teria achado o valor de 0.60 e não o 0.48. Mas eu te afirmo, que para o problema trabalhado, a primeira escala é muito ruim e a segunda escala é muito boa.

Agora você tem todo o direito de perguntar: o que eu ganhei com isso ? Bom. Você deve acertar os valores da escala de tal forma que o zero esteja claro. Além disso, ela deve ter qualidade para reproduzir seu problema. Então, a pergunta que fica é a seguinte: você quer fazer tudo na mão ? Certamente é mais fácil acertar a escala de forma visual ficando claro quais são os valores aproximados que devem ser utilizados como limites e também o número de cores que escala negativa deve ter e depois utilizar uma equação matemática para definir com precisão quais são os valores adequados dos limites.

Minha opinião pessoal é de que podemos quase sempre manter o número de cores em 10. Assim, o número de cores negativas oscila entre 1 e 4 ou 6 e 9 (não pode ser 5, do contrário caímos na caso simétrico). Logo, o primeiro passo é definir qual das escalas possuí maior número de cores. Se for a escala negativa, ajuste o limite inferior da escala e calcule a o limite positivo considerando que a escala negativa tenha 8 divisões. Faça o ajuste fino depois desse primeiro cálculo. Se a maior escala for a positiva, ajuste o limite superior e calcule o limite inferior considerando que a escala negativa tenha 2 divisões. Faça um ajuste fino após esse primeiro cálculo. Essa regra pessoal tende a funcionar na maior parte dos problemas.