Resumo Técnico: Uma Abordagem Geral para Executar Códigos Python em OpenFOAM Usando um Interpretador Python Incorporado via pybind11

Definição do Problema

A interseção entre a mecânica computacional tradicional e o aprendizado de máquina (ML) criou uma demanda por interfaces contínuas entre procedimentos baseados em Python e solvers baseados em C++ como o OpenFOAM. Embora o Python ofereça prototipagem rápida, legibilidade e acesso a um vasto ecossistema de ferramentas científicas e de ML (ex: TensorFlow, Keras, scikit-learn), o OpenFOAM é construído em C++ para eficiência computacional.

Os métodos existentes para unir essa lacuna frequentemente exigem a tradução de códigos ou modelos Python para C++, o que anula a principal vantagem do Python: a simplicidade de codificação. As abordagens atuais incluem:

• Ferramentas de pré/pós-processamento: Bibliotecas como PyFoam e fluidfoam lidam com manipulação de casos e plotagem, mas não integram o Python dentro do loop do solver.
• Tradução de Código: Conversão de redes neurais para C++ via ferramentas como frugally-deep ou vinculação direta às APIs de C++ do TensorFlow. Esses métodos exigem configurações de compilação complexas e integração ao nível do código-fonte, criando uma barreira de entrada.
• Parsers de Expressões: Ferramentas como swak4Foam permitem alguma execução de Python, mas frequentemente dependem de interfaces de nível inferior ou parsers específicos.

Há uma falta de uma metodologia padrão e geral para executar código "puro" Python diretamente dentro de um solver OpenFOAM sem tradução de código, particularmente para tarefas complexas como condições de contorno, prototipagem de solvers e leis constitutivas baseadas em ML.

Metodologia

Os autores propõem uma abordagem geral usando a biblioteca pybind11 para incorporar um interpretador Python diretamente dentro de uma aplicação OpenFOAM. Este método permite que o OpenFOAM chame funções e scripts Python, transfira dados e recupere resultados sem converter o código Python para C++.

Etapas Principais de Implementação

1. Integração: A biblioteca header-only pybind11 é instalada (ex: via Conda) e vinculada ao sistema de build do OpenFOAM através da modificação do arquivo Make/options para incluir os cabeçalhos e bibliotecas Python necessários. Uma modificação específica ao setRootCase.H é necessária para evitar conflitos com módulos Python, como o TensorFlow, em relação aos argumentos de linha de comando.
2. Inicialização do Interpretador: O interpretador Python é inicializado uma única vez dentro do código OpenFOAM (ex: no construtor de um solver ou em createFields.H) usando py::initialize_interpreter().
3. Mecanismos de Transferência de Dados:
   • Objeto de Escopo (Scope Object): Um py::object scope é criado para gerenciar o namespace Python, permitindo que variáveis C++ sejam injetadas no Python e vice-versa.
   • Passagem por Cópia (Pass-by-Copy): Os dados são transferidos convertendo containers OpenFOAM (ex: Field, List) para std::vector, e então realizando o cast para py::array (arrays NumPy) para o Python. Os resultados são convertidos de volta para tipos C++. Isso suporta tanto tipos primitivos quanto arrays multidimensionais.
   • Passagem por Referência (Pass-by-Reference): Para evitar o overhead de copiar grandes conjuntos de dados, os autores utilizam ctypes no Python. O endereço de memória e o tamanho de um campo OpenFOAM são passados para o Python, que cria uma visualização (view) de um array NumPy diretamente sobre a memória C++. Modificações no Python são imediatamente refletidas no OpenFOAM sem duplicação de dados.
4. Execução: Scripts Python são carregados em tempo de execução usando py::eval_file, e funções específicas são executadas via py::exec.

Contribuições Principais e Casos de Teste

O artigo valida esta metodologia através de três casos de teste complementares:

1. Condição de Contorno de Perfil de Velocidade Baseada em Python:

   • Uma condição de contorno customizada (pythonVelocity) foi criada onde o perfil de velocidade é definido por um script Python em tempo de execução.
   • O script recebe coordenadas de centro de face e o tempo, calcula as velocidades e as retorna para o OpenFOAM.
   • Resultado: Aplicado com sucesso ao tutorial clássico da cavidade (cavity), reproduzindo perfis de velocidade analíticos.

2. Prototipagem de Solver de Transferência de Calor Baseado em Python:

   • Um wrapper para o solver laplacianFoam foi desenvolvido para demonstrar prototipagem rápida.
   • As equações governantes (equação de Laplace) foram resolvidas usando um método simples de diferença finita explícita implementado inteiramente em Python.
   • Resultado: O solver Python produziu campos de temperatura consistentes com o laplacianFoam nativo em C++, demonstrando a viabilidade de prototipar estratégias de solução em Python.

3. Cálculos de Campo com Aprendizado de Máquina (Solids4foam):

   • Uma lei constitutiva mecânica para o solids4foam foi implementada para calcular tensores de tensão a partir de tensores de deformação.
   • Comparação: Sete abordagens foram testadas:
     1. C++ Nativo (Referência).
     2. Expressão analítica em Python.
     3. Rede Neural (NN) via API Keras Sequential.
     4. NN via API Keras Funcional.
     5. NN com execução eager do TensorFlow desativada.
     6. NN traduzida para NumPy puro.
     7. NN traduzida para NumPy com compilação JIT do Numba.
   • Transferência de Dados: Cada abordagem foi testada tanto com transferência "célula a célula" quanto "campo inteiro", além de "passagem por cópia" vs. "passagem por referência".

Resultados e Análise de Desempenho

O estudo gerou insights críticos sobre eficiência e estratégias de implementação:

• Precisão: Todas as abordagens baseadas em Python (analíticas e de ML) produziram resultados indistinguíveis do caso de referência em C++ nativo, com erros negligenciáveis na tensão de von Mises e na magnitude do deslocamento.
• Estratégia de Transferência de Dados:
  • Célula a Célula vs. Campo Inteiro: Passar dados como um campo inteiro é significativamente mais rápido do que a transferência célula a célula. Para o método Python analítico, a abordagem de campo inteiro foi ~3x mais rápida; para redes neurais, a diferença foi de ordens de magnitude.
  • Cópia vs. Referência: A passagem por referência (usando endereços de memória) proporcionou ganhos de velocidade significativos sobre a passagem por cópia. O método Python analítico usando passagem por referência alcançou tempos de execução quase idênticos ao solver C++ nativo.
• Overhead:
  • Overhead de ML: Redes neurais introduziram um overhead fixo (carregamento do interpretador e do modelo). Em uma malha grossa (1.000 células), esse overhead foi substancial (>600%). Em uma malha fina (400.000 células), o overhead caiu para ~18% para modelos baseados em Keras.
  • Otimização: A passagem por referência reduziu o overhead da rede neural de melhor desempenho (Base Keras) para menos de 4% na malha fina.
• Eficiência de Implementação:
  • A abordagem Analytical-Python foi a mais eficiente, adicionando apenas ~8% de overhead (passagem por cópia) ou ~1% (passagem por referência) em comparação ao C++.
  • Pure NumPy/Numba: Contrário às expectativas, traduzir modelos Keras para NumPy puro ou usar Numba não proporcionou vantagem de desempenho sobre as implementações nativas de TensorFlow/Keras neste contexto; em alguns casos, foram mais lentos.

Significância e Alegações

O artigo afirma que esta abordagem oferece um método direto para integrar Python ao OpenFOAM sem tradução de código, preservando a simplicidade do desenvolvimento em Python enquanto se aproveita o robusto framework do OpenFOAM.

• Viabilidade: Os autores demonstram que tarefas complexas, incluindo condições de contorno, algoritmos de solver e leis constitutivas baseadas em ML, podem ser implementadas em Python com modificações mínimas no código-fonte do OpenFOAM.
• Eficiência: O estudo conclui que a abordagem computacionalmente menos dispendiosa é passar dados como campos inteiros por referência. Com este método, o overhead para redes neurais de feed-forward pode ser reduzido a poucos por cento, tornando-a viável para uso em produção.
• Limitações das Alternativas Atuais: O artigo observa que, embora a transferência célula a célula seja possível, ela é proibitivamente cara para campos grandes. Além disso, o esforço para converter modelos Python para C++ (ex: via frugally-deep) conflita com o objetivo de prototipagem rápida.
• Perspectiva Futura: Os autores afirmam que a abordagem roda em paralelo via MPI padrão do OpenFOAM (com cada processador detendo um interpretador local) e antecipam sua utilidade na expansão da aplicação de ML em mecânica computacional, como em problemas de elastoplasticidade.

O trabalho posiciona-se não como um substituto para solvers C++, mas como uma ponte flexível que permite aos pesquisadores utilizar o ecossistema Python para componentes específicos do solver sem sacrificar a capacidade de realizar simulações de larga escala.