Conservando Massa em Simulação Líquida

Estou tentando implementar uma versão 2D do artigo de Foster e Fedkiw, "Animação prática de líquidos" aqui: http://physbam.stanford.edu/~fedkiw/papers/stanford2001-02.pdf

Principalmente tudo funciona, exceto a seção 8: "Conservação de massa". Lá, montamos uma matriz de equações para calcular as pressões necessárias para tornar o líquido livre de divergências.

Acredito que meu código coincide com o artigo, no entanto, estou obtendo uma matriz insolúvel durante a etapa de conservação da massa.

Aqui estão meus passos para gerar a matriz A:

Defina as entradas diagonais $A_{i,i}$ para o número negativo de células líquidas adjacentes à célula i.
Defina as entradas $A_{i,j}$ e $A_{j,i}$ para 1 se ambas as células iej tiverem líquido.

Observe que, na minha implementação, o cell $i$ , $j$ na grade líquida corresponde à linha $i +$ gridWidth $* j$ na matriz.

O artigo menciona: "Objeto estático e células vazias não perturbam essa estrutura. Nesse caso, os termos de pressão e velocidade podem desaparecer dos dois lados", então excluo as colunas e linhas de células que não têm líquido.

Então, minha pergunta é: Por que minha matriz é singular? Estou perdendo algum tipo de condição de contorno em algum outro lugar do jornal? É o fato de que minha implementação é 2D?

Aqui está um exemplo de matriz da minha implementação para uma grade 2x2 em que a célula em 0,0 não possui líquido:

Editar

Minha pesquisa me levou a acreditar que não estou lidando adequadamente com as condições de contorno.

Antes de tudo, neste momento, posso dizer que minha matriz representa a equação de Poisson de pressão discreta. É o análogo discreto da aplicação do operador laplaciano que acopla as alterações de pressão local à divergência celular.

Pelo que entendi, como estamos lidando com diferenças de pressão, são necessárias condições de contorno para "ancorar" as pressões a um valor de referência absoluto. Caso contrário, pode haver um número infinito de soluções para o conjunto de equações.

Em essas notas , 3 maneiras diferentes são dadas para aplicar condições de contorno, para o melhor de meu entendimento:

Dirichlet - especifica valores absolutos nos limites.
Neummann - especifica a derivada nos limites.
Robin - especifica algum tipo de combinação linear do valor absoluto e a derivada nos limites.

O artigo de Foster e Fedki não menciona nada disso, mas acredito que eles impõem condições de contorno de Dirichlet, notáveis por causa dessa afirmação no final de 7.1.2, "A pressão em uma célula de superfície é definida como pressão atmosférica".

Eu li as anotações que vinculei algumas vezes e ainda não entendi direito a matemática. Como exatamente aplicamos essas condições de contorno? Olhando para outras implementações, parece haver algum tipo de noção de uma célula "fantasma" que se encontra na fronteira.

Aqui, vinculei a algumas fontes que podem ser úteis para outras pessoas que estão lendo isso.

Notas sobre condições de contorno para matrizes de Poisson

Computational Science StackExchange post sobre condições de contorno de Neumann

Ciência da Computação StackExchange post on Poisson Solver

Implementação de Physbam de Água

Aqui está o código que eu uso para gerar a matriz. Observe que, em vez de excluir explicitamente colunas e linhas, eu gero e uso um mapa dos índices de células líquidas para as colunas / linhas finais da matriz.

for (int i = 0; i < cells.length; i++) {
  for (int j = 0; j < cells[i].length; j++) {
    FluidGridCell cell = cells[i][j];

    if (!cell.hasLiquid)
      continue;

    // get indices for the grid and matrix
    int gridIndex = i + cells.length * j;
    int matrixIndex = gridIndexToMatrixIndex.get((Integer)gridIndex);

    // count the number of adjacent liquid cells
    int adjacentLiquidCellCount = 0;
    if (i != 0) {
      if (cells[i-1][j].hasLiquid)
        adjacentLiquidCellCount++;
    }
    if (i != cells.length-1) {
      if (cells[i+1][j].hasLiquid)
        adjacentLiquidCellCount++;
    }
    if (j != 0) {
      if (cells[i][j-1].hasLiquid)
      adjacentLiquidCellCount++;
    }
    if (j != cells[0].length-1) {
      if (cells[i][j+1].hasLiquid)
        adjacentLiquidCellCount++;
    }

    // the diagonal entries are the negative count of liquid cells
    liquidMatrix.setEntry(matrixIndex, // column
                          matrixIndex, // row
                          -adjacentLiquidCellCount); // value

    // set off-diagonal values of the pressure matrix
    if (cell.hasLiquid) {
      if (i != 0) {
        if (cells[i-1][j].hasLiquid) {
          int adjacentGridIndex = (i-1) + j * cells.length;
          int adjacentMatrixIndex = gridIndexToMatrixIndex.get((Integer)adjacentGridIndex);
          liquidMatrix.setEntry(matrixIndex, // column
                                adjacentMatrixIndex, // row
                                1.0); // value
          liquidMatrix.setEntry(adjacentMatrixIndex, // column
                                matrixIndex, // row
                                1.0); // value
        }
      }
      if (i != cells.length-1) {
        if (cells[i+1][j].hasLiquid) {
          int adjacentGridIndex = (i+1) + j * cells.length;
          int adjacentMatrixIndex = gridIndexToMatrixIndex.get((Integer)adjacentGridIndex);
          liquidMatrix.setEntry(matrixIndex, // column
                                adjacentMatrixIndex, // row
                                1.0); // value
          liquidMatrix.setEntry(adjacentMatrixIndex, // column
                                matrixIndex, // row
                                1.0); // value
        }
      }
      if (j != 0) {
        if (cells[i][j-1].hasLiquid) {
          int adjacentGridIndex = i + (j-1) * cells.length;
          int adjacentMatrixIndex = gridIndexToMatrixIndex.get((Integer)adjacentGridIndex);
          liquidMatrix.setEntry(matrixIndex, // column
                                adjacentMatrixIndex, // row
                                1.0); // value
          liquidMatrix.setEntry(adjacentMatrixIndex, // column
                                matrixIndex, // row
                                1.0); // value
        }
      }
      if (j != cells[0].length-1) {
        if (cells[i][j+1].hasLiquid) {
          int adjacentGridIndex = i + (j+1) * cells.length;
          int adjacentMatrixIndex = gridIndexToMatrixIndex.get((Integer)adjacentGridIndex);
          liquidMatrix.setEntry(matrixIndex, // column
                                adjacentMatrixIndex, // row
                                1.0); // value
          liquidMatrix.setEntry(adjacentMatrixIndex, // column
                                matrixIndex, // row
                                1.0); // value
        }
      }
    }

simulation fluid-sim

— Jared Counts
fonte

Não está claro por que objetos estáticos e células vazias devem permitir a exclusão de linhas e colunas. Você está configurando essas linhas e colunas para zero ou removendo-as completamente para fornecer uma matriz menor?

— precisa saber é o seguinte

Caso o problema esteja em algum lugar diferente do que você imagina, seria útil ver o código, se é algo que você deseja compartilhar. O ideal é um MCVE

— trichoplax 03/03

Hey trichoplax. Uma matriz com uma linha ou coluna totalmente zero seria singular, tanto quanto eu sei, então eu as removo da matriz para criar uma matriz menor (assim como suas entradas correspondentes no vetor b).

— Jared Counts

Editarei um MCVE hoje à noite quando estiver perto do meu computador com a fonte.

— Jared Counts

Eu também suspeitava que talvez estivesse fazendo uma suposição errada em algum outro lugar do código, no entanto, isso pertence apenas à estrutura da matriz (e se é singular ou não). A única coisa em que consigo pensar é o que se qualifica como uma "célula superficial" versus uma célula aérea ou uma célula líquida. Se esta é uma célula líquida adjacente a uma célula aérea, há algo diferente que eu deveria estar fazendo com suas colunas / linhas correspondentes?

— Jared Counts

No seu snippet de código e no resultado do exemplo 2x2, posso ver que você está realmente simulando um domínio apenas com condições de contorno de Neumann (slip wall). Nesse caso, o sistema contém um espaço nulo e sua matriz é singular.

Se esta é a configuração de simulação que você deseja (ou seja, sem Dirichlet (pressão) BC), será necessário projetar o espaço nulo da sua solução. Isso é direto se você estiver usando o gradiente conjugado (CG), conforme sugerido nesse artigo. Em cada iteração da iteração de CG, basta usar o vetor de solução atual $\mathbf{x}$ , e fazer

\begin{aligned} x^{'} & = (I - \hat{u} {\hat{u}}^{T}) x \\ = x - (\hat{u} \cdot x) \hat{u} \end{aligned}

$\begin{align} \mathbf{x}' &= (\mathbf{I}-\mathbf{\hat{u}}\mathbf{\hat{u}}^T)\mathbf{x}\\ &= \mathbf{x} - (\mathbf{\hat{u}} \cdot \mathbf{x} )\mathbf{\hat{u}} \end{align}$ Onde

\hat{u}

$\mathbf{\hat{u}}$ é o espaço nulo normalizado do operador de gradiente:

u = (1, 1, \dots, 1)

$\mathbf{u} = (1,1,\dots,1)$ ,

\hat{u} = \frac{u}{‖ u ‖}

$\mathbf{\hat{u}}=\frac{\mathbf{u}}{\lVert \mathbf{u} \rVert}$ .

Caso contrário, se você deseja simular o ar (limite livre ou Dirichlet BC), será necessário distinguir uma parede e uma célula do ar (por exemplo, ter um booleano hasLiquidnão é suficiente) e aplicar a discretização correta para eles (veja abaixo).

Como nota final, suas entradas diagonais são negativas. Você pode virar os sinais para que o método CG funcione.

Abaixo eu gostaria de mostrar mais detalhes. Considere o processo de projeção de pressão. Denote a velocidade antes da projeção da pressão como $\mathbf{v}^*$ . Pode ser divergente, por isso calculamos a pressão para corrigi-la e obter a velocidade livre de divergência $\mathbf{v}^{n+1}$ . Isso é,

\begin{aligned} v^{n + 1} & = v^{*} - \frac{Δ t}{ρ} \nabla P \end{aligned}

$\begin{align} \mathbf{v}^{n+1} &= \mathbf{v}^* - \frac{\Delta t}{\rho} \nabla P \end{align}$ Tome divergência disso, e desde

v^{n + 1}

$\mathbf{v}^{n+1}$ é livre de divergências,

\begin{aligned} \nabla \cdot \nabla P & = \nabla \cdot v^{*} \end{aligned}

$\begin{align} \nabla \cdot \nabla P &= \nabla \cdot \mathbf{v}^* \end{align}$ Suponha que não haja pressão que o Dirichlet BC faça e tenhamos uma solução

P_{0}

$P_0$ , então

P_{0} + c

$P_0+c$ para qualquer constante

c

$c$ também é uma solução porque

\nabla \cdot \nabla (P_{0} + c) = \nabla \cdot \nabla P_{0} = \nabla \cdot v^{*}

$\nabla \cdot \nabla (P_0+c) = \nabla \cdot \nabla P_0 = \nabla \cdot \mathbf{v}^*$ .

c

$c$ é o espaço nulo que queremos projetar.

Para lidar com o Dirichlet BC, vamos considerar o caso 1D como um exemplo. Suponha que você esteja usando uma grade escalonada, onde as pressões $p_i$ estão localizados nos centros e velocidades da grade $v_{i+1/2}$ estão localizados nas faces entre os nós $i$ e $i+1$ . Então a discretização geral para uma célula é

\frac{p_{i + 1} - p_{i} - (p_{i} - p_{i - 1})}{Δ x^{2}} = rhs

$\frac{p_{i+1}-p_i-(p_i-p_{i-1})}{\Delta x^2} = \text{rhs}$ Suponha que

p_{i + 1}

$p_{i+1}$ é uma célula de ar, ou seja, sua pressão foi especificada, então o

p_{i + 1}

$p_{i+1}$ O termo é movido para o lado direito e desaparece da matriz. Observe que a contagem do termo diagonal

p_{i}

$p_i$ ainda são dois. Foi por isso que eu disse que o seu exemplo 2x2 não continha um Dirichlet BC.

Com Dirichlet ou Neumann BC, a matriz é sempre positiva simétrica definida. Por isso os autores disseram

Static object and empty cells don’t disrupt this structure.
In that case pressure and velocity terms can disappear from both sides

— TheBusyTypist
fonte