simulacao-openfoam

Execute uma simulação CFD (Dinâmica dos Fluidos Computacional) de volumes finitos com o software livre OpenFOAM a partir de uma conversa em português: obtenha a geometria, o fluido e as condições de operação em linguagem natural, converta-os em um caso de simulação verificado, construa e execute o caso OpenFOAM pela linha de comando e converta o torque na parede de volta em um resultado físico (por exemplo, uma curva de fluxo de Couette). Use quando o usuário quiser uma simulação CFD gratuita e sem licença — um reômetro de Couette, um canal, um tanque agitado — ou pedir o equivalente de código aberto a uma simulação do M-Star.

O que é simulacao-openfoam?

Esta skill habilita assistentes de IA (como Claude Code, Cursor ou Codex) a executar simulações CFD (Dinâmica dos Fluidos Computacional) de volumes finitos usando o software livre OpenFOAM, partindo de uma descrição em linguagem natural. O fluxo de trabalho consiste em: elicitar a geometria, propriedades do fluido e condições de operação; escrever um arquivo de configuração `case.yaml` para validação com o usuário; gerar a malha com `blockMesh`; configurar e executar o solver (steady-state `simpleFoam` ou transiente `pimpleFoam`); pós-processar o torque para obter tensão de cisalhamento, taxa de cisalhamento e viscosidade aparente; e gerar um relatório com a curva de fluxo, diagnóstico de validação e resultados. A skill foi projetada para o reômetro de Couette como caso de validação principal, usando um setor de cunha 2D axisimétrico (wedge) para eficiência e precisão. Modelos reológicos Newtonianos e não-Newtonianos (Herschel–Bulkley, Bird–Carreau, potência, etc.) são suportados, com uma 'porteira de validação' Newtoniana obrigatória antes de prosseguir para fluidos não-Newtonianos. A skill funciona em Linux Debian/Ubuntu com OpenFOAM v2412 instalado via script. Suporta plataformas de agentes: GitHub Copilot CLI, Claude Code, Cursor, Codex CLI, e outros que consomem SKILL.md. O foco principal é a curva de fluxo de Couette como prova de conceito, não substituindo M-Star para tanques ou fluxos multifásicos nesta versão.

Funciona com✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/marcocaggioni/openfoam-skill/tree/HEAD/.github/skills/openfoam-simulation

Installed? Explore more Programação e Desenvolvimento skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Simulação OpenFOAM

OpenFOAM (openfoam.com, ESI/OpenCFD) é o padrão de código aberto para CFD de volumes finitos, GPL, C++ com MPI. Não é um código de reticulado de Boltzmann como M-Star ou Palabos: ele resolve as equações de Navier–Stokes em uma malha, com modelos de viscosidade embutidos (Newtoniano, lei de potência, Herschel–Bulkley, Bird–Carreau, Cross, Casson), uma condição de contorno rotatingWallVelocity, e solvers estacionário (simpleFoam) e transiente (pimpleFoam). O torque vem do functionObject forces. Esta skill é a contraparte de código aberto da skill mstar-simulation no repositório privado mstar-skill e de palabos-simulation: mesmo fluxo de trabalho discussão → caso → execução → relatório, mesmo exemplo de Couette, solver diferente — sem licença, sem GUI, sem arquivo .msb. Em vez disso, você escreve arquivos de dicionário e executa os solvers pela linha de comando.

O fluxo de trabalho, em ordem

1. Discutir (Português)  -> que fluido, que geometria, o que você quer medir?
2. Escrever case.yaml     -> cada número em um arquivo, com unidades. Mostre. Obtenha um sim.
3. Malha                  -> blockMeshDict: setor de cunha para Couette. Verifique com checkMesh.
4. Construir o caso       -> copiar o template, substituir Omega. Sem GUI.
5. Varredura / execução   -> uma execução simpleFoam por taxa de cisalhamento, torque CSV por execução.
6. Pós-processamento      -> torque -> tensão, omega -> taxa de cisalhamento, curva de fluxo + validação.
7. Relatório              -> gráfico + CSV + o que foi assumido, verificado e não verificado.

Nunca pule a etapa 2. Mesma regra das skills M-Star e Palabos: uma simulação com uma faixa de taxa de cisalhamento, modelo de fluido ou geometria não confirmados é uma execução desperdiçada. Se o usuário não nomeou um número, pergunte — não invente um e o enterre em um dicionário. Os padrões nos exemplos são rotulados como default: e devem ser confirmados.

Executar é gratuito aqui (sem licença), mas não é de graça: uma execução 3D em resolução fina custa tempo real de CPU. Padrão para uma primeira execução barata (malha grossa, uma taxa de cisalhamento) e só então varra.

1. Discutir — o que obter

Mesma lista de verificação da skill M-Star, mais itens específicos do OpenFOAM:

Geometria

  • Raio interno (rotativo) R_i, raio externo (fixo) R_o, comprimento imerso L. Metros.
  • A primeira versão é um setor de cunha, não um anel completo. OpenFOAM é volumes finitos 3D, então uma célula de Couette é modelada como uma cunha fina (4°, eixo ao longo de X, fatia axial de 1 mm, 1 célula axial) com patches wedge nas duas faces do setor e patches empty nas duas faces axiais. A condição de contorno de cunha torna a solução axisimétrica: sem vórtices de Taylor, sem efeitos de extremidade — a célula de Couette de comprimento infinito ideal, exatamente o que o torque analítico assume. Diga qual você está executando. Um anel 3D completo é o acompanhamento: adiciona efeitos de extremidade e, acima do número de Taylor crítico Ta_c ≈ 41,3, vórtices de Taylor que elevam o torque acima do valor laminar analítico e quebram a porteira de validação. Para este caso (η = 1 Pa·s, ρ = 1000 kg/m³) Re ≤ 1,8 e Ta ≤ 0,9 em toda a varredura, então um anel completo permaneceria laminar — mas a cunha ainda é a validação mais barata e limpa.

Fluido — escolha uma reologia, com números

OpenFOAM tem um menu suspenso de reologia, em constant/transportProperties: transportModel Newtonian; é o caso de validação, e HerschelBulkley, BirdCarreau, Casson, powerLaw, CrossPowerLaw são modelos generalisedNewtonian embutidos. Herschel–Bulkley e Bird–Carreau são o acompanhamento documentado, não o caso de validação. Duas armadilhas:

  • A viscosidade em transportProperties é a viscosidade cinemática nu = η/ρ (m²/s), não a viscosidade dinâmica η. Para η = 1,0 Pa·s e ρ = 1000 kg/m³, nu = 1e-03 — não 1e-06 (o valor para água, η = 1e-3 Pa·s). Um rascunho inicial deste repositório usou 1e-06 e o torque saiu exatamente 1000× menor enquanto o perfil de velocidade parecia correto — o perfil de Couette Newtoniano é independente da viscosidade, então o perfil não pega esse erro. O torque pega.
  • Os coeficientes não-Newtonianos também são cinemáticos (nu0 = η0/ρ, k = K/ρ); a tensão de escoamento tau0 está em Pa. Verifique com o código-fonte do modelo antes de confiar em uma execução não-Newtoniana. Se o usuário nomear um material real, não invente seus parâmetros: peça uma curva de fluxo medida, um ajuste rheofit ou um valor da literatura, ou comece com Newtoniano.

Condições de operação — a varredura

  • Faixa e espaçamento da taxa de cisalhamento, ex.: 0,1 → 100 s⁻¹, espaçamento log.
  • Resolução da malha: células na folga (padrão 40, ou seja, dx = 0,125 mm). Mais células = cisalhamento na parede mais preciso, custo muito maior.
  • Duração da execução: simpleFoam executa em iterações, não em segundos. endTime 3000 com residualControl 1e-8 — o solver para cedo quando convergido (γ̇ = 10 converge em ~2050 iterações, ~2 s). A janela estacionária para média do torque são os últimos 20% das amostras de moment.dat.

O que está sendo medido

  • Couette: torque no rotor → tensão de cisalhamento, taxa de rotação → taxa de cisalhamento. A curva de fluxo. Nomeie o arquivo de onde vem (postProcessing/forces/0/moment.dat, escrito pelo functionObject forces) antes de executar.

2. Escreva case.yaml

Um arquivo por simulação, em examples/<nome>/case.yaml. É o contrato: os scripts o leem, eles não rededuzem números da conversa. Modelo: examples/couette/case.yaml. Mostre ao usuário e obtenha um sim antes de construir.

3. Malha — o passo que o M-Star esconde

OpenFOAM precisa de uma malha, construída aqui com blockMesh a partir de system/blockMeshDict. A malha de Couette é um único bloco hexaédrico:

eixo = X (eixo do cilindro), radial = Y, cunha abre no plano Y-Z
ângulo da cunha 4 graus total (OpenFOAM requer < 5 graus), semi-ângulo 2 graus
extensão axial x = 0..0,001 m, UMA célula (sem variação axial)
radial: 40 células na folga de 5 mm, simpleGrading (1 1 1)
patches: innerWall, outerWall, back/front (tipo wedge),
         left/right (tipo empty)

Verifique com checkMesh antes de resolver: deve relatar Mesh OK., ângulo de cunha 2° por lado, não-ortogonalidade 0. A combinação empty + wedge em uma malha é aceita pelo v2412 (verificado aqui); se uma versão futura rejeitá-la, troque as faces axiais para symmetry.

Escalonamento do torque: o setor é uma fatia de 4° de uma fatia de 1 mm do cilindro de 60 mm, então:

T_total = M_x(setor) * (360/4) * (0,060/0,001) = M_x * 5400

onde M_x é o momento em torno do eixo X do functionObject forces em innerWall (CofR na origem, no eixo). O sinal é negativo (o arrasto do fluido se opõe à rotação); o torque motor é a magnitude.

4. Construir o caso

OpenFOAM é um conjunto de aplicações, não uma biblioteca: você escreve arquivos de dicionário e os executa. A estrutura do repositório:

bash scripts/install-openfoam.sh   # repositório oficial Debian, v2412
source /usr/lib/openfoam/openfoam2412/etc/bashrc
bash scripts/check-setup.sh        # simpleFoam, blockMesh, checkMesh, uv
./run-couette.sh                   # execução seca: construir malha + checkMesh apenas

couette_build.py copia o template (examples/couette/case/) para um diretório de execução e substitui __OMEGA__ em 0/U com a velocidade angular para a taxa de cisalhamento:

Omega = gamma * (Ro^2 - Ri^2) / (2 * Ro^2)

Condições de contorno (verificadas com os tutoriais do v2412):

  • innerWall: rotatingWallVelocity, axis (1 0 0), omega constant <Omega> (rad/s), origin (0 0 0). Padrão: o rotatingWallVelocity do tutorial climbingRod.
  • outerWall: noSlip.
  • back/front: wedge; left/right: empty.
  • Pressão: fixedFluxPressure em ambas as paredes (caso só com paredes).
  • constant/transportProperties: transportModel Newtonian; nu 1e-03; (veja §1 — cinemática, não dinâmica).
  • constant/turbulenceProperties: simulationType laminar;. v2412 lê turbulenceProperties; versões mais novas renomearam para momentumTransport — se seu solver reclamar que não encontra o outro nome, renomeie o arquivo e seu object interno.
  • system/fvSolution: SIMPLE com pRefCell 0; pRefValue 0; (obrigatório: toda fronteira é uma parede, então a pressão precisa de uma célula de referência — sem ela simpleFoam sai com "Unable to set reference cell for field p"), GAMG para p, smoothSolver para U, residualControl p/U 1e-8.
  • system/controlDict: simpleFoam, endTime 3000 iterações, functionObject forces (patches (innerWall), rho rhoInf; rhoInf 1000;, CofR (0 0 0), writeInterval 5). v2412 escreve force.dat e moment.dat (arquivos separados), não forces.dat.

Status: o caso estacionário foi executado de verdade nesta VM (OpenFOAM v2412, 2026-11-17) e a validação Newtoniana na §6 passa (0,03% de erro no torque analítico em γ̇ = 10 — veja examples/couette/RUN_REPORT.md). A variante transiente pimpleFoam (case-transient/, para o vídeo de aceleração) também executa: 1000 passos em ~2 s, convergindo para o mesmo torque.

Não-Newtoniano: mude transportModel em transportProperties (Herschel–Bulkley primeiro, Bird–Carreau depois). Mantenha o caminho Newtoniano como padrão e a porteira de validação — nunca depure um modelo não-Newtoniano em uma geometria não validada.

5. Executar

./run-couette.sh --run           # uma execução por taxa de cisalhamento, em examples/couette/runs/
# ou, por ponto:
python3 couette_build.py --gamma 10 --out runs/gamma_10
cd runs/gamma_10 && blockMesh && simpleFoam

Cada execução escreve torque.csv (iteração, momento do setor, torque do cilindro completo) e run_info.json (flag de convergência, iterações, tempo de parede). Se uma execução for lenta, refine a malha ou o tempo de execução primeiro — não mude silenciosamente a geometria para torná-la rápida. Uma execução que atinge endTime sem o resíduo de Uz cair abaixo de 1e-7 é sinalizada converged: false — diagnostique antes de confiar em seu torque (malha, condições de contorno, relaxação).

6. Pós-processamento — torque para curva de fluxo (Couette)

Mesma conversão das skills M-Star e Palabos:

taxa de cisalhamento na parede interna:  gamma_i = 2*Omega*Ro^2 / (Ro^2 - Ri^2)
tensão de cisalhamento na parede interna: tau_i  = T / (2*pi*Ri^2*L)
viscosidade aparente:                   eta_app = tau_i / gamma_i

Calcule a média do torque na janela estacionária nomeada em case.yaml (últimos 20% das amostras), relate seu desvio padrão como a verificação de estacionaridade.

Porteira de validação (obrigatória para a primeira execução de uma nova geometria). Execute um fluido Newtoniano de eta conhecido primeiro e compare com o torque analítico de Couette:

T_analitico = 4*pi*L*eta*Omega*Ri^2*Ro^2 / (Ro^2 - Ri^2)

Se o torque simulado diferir em mais de ~10%, não prossiga para uma curva de fluxo não-Newtoniana. Pare e diagnostique: resolução da malha na folga, nu (cinemática vs dinâmica — veja §1), tempo de execução / convergência, contorno de parede rotativa, escalonamento do torque. Registre o número de validação no relatório. couette_post.py impõe esta porteira e sai com código não zero em caso de falha.

Em seguida, cada ponto da varredura dá um ponto (gamma_i, tau_i). Plote tau vs gamma (log-log) e eta_app vs gamma, escreva flow_curve.csv, e — se o usuário quiser parâmetros — ajuste a curva com rheofit (Herschel–Bulkley, Carreau, …) em uma etapa separada.

7. Relatório

Entregue, por execução: case.yaml (como executado), flow_curve.csv, flow_curve.png, e uma nota curta informando a geometria (setor de cunha, ângulo, células na folga), fluido, varredura, resultado validação, critério de estado estacionário e qualquer coisa não verificada. Se uma execução falhou, relate o final do log do solver — não descarte silenciosamente o ponto da curva.

Iniciando uma sessão com GitHub Copilot CLI

Mesma configuração do mstar-skill e palabos-skill: o Copilot CLI descobre skills do projeto em .github/skills/, e esta skill é espelhada lá. A partir da raiz do repositório:

git clone https://github.com/marcocaggioni/openfoam-skill.git
cd openfoam-skill
bash scripts/install-openfoam.sh
bash scripts/check-setup.sh
copilot

Em seguida, /skills list (você deve ver openfoam-simulation), e:

/openfoam-simulation execute o exemplo Couette em examples/couette/case.yaml

Esta skill deliberadamente não tem frontmatter allowed-tools: Copilot deve perguntar antes de executar comandos shell, e em particular antes de uma execução longa do solver. Se a skill foi adicionada durante uma sessão, execute /skills reload primeiro.

O que esta skill NÃO faz

  • Ela não instala o OpenFOAM para você além do script apt em scripts/install-openfoam.sh: você precisa de uma máquina Debian/Ubuntu e sudo.
  • Ela não afirma que um caso está verificado até que ele seja executado contra um OpenFOAM instalado e a validação Newtoniana passe.
  • Ela não substitui o M-Star para tanques, impelidores, fluxos multifásicos ou com partículas — esses estão fora do escopo da v0.1. Este repositório é a curva de fluxo de Couette, feita abertamente, como a primeira prova de que a rota de volumes finitos aberta funciona.

Arquivos neste repositório

  • skills/openfoam-simulation/SKILL.md — este arquivo. Espelhado byte por byte em .github/skills/openfoam-simulation/SKILL.md (a cópia que o GitHub Copilot CLI descobre). Mantenha as duas cópias sincronizadas — edite ambas no mesmo commit.
  • docs/openfoam-guide.md — instalação, malha, condições de contorno, notas sobre não-Newtoniano, limites.
  • examples/couette/ — o exemplo Couette trabalhado: case.yaml, case/ (template simpleFoam estacionário), case-transient/ (template pimpleFoam de aceleração), couette_build.py, couette_sweep.py, couette_post.py, make_video.py, README.md.
  • OpenFOAM em si: https://www.openfoam.com (GPL)

Habilidades Relacionadas