Como você determina a resistência efetiva de uma grade finita de resistores?

Disclaimer: Eu sou um geofísico com experiência limitada em engenharia elétrica. Não tenho certeza se esse problema é incrivelmente fácil, incrivelmente complexo ou completamente sem sentido.

Meu objetivo: determinar a resistividade a granel de uma amostra de rocha usando redes de resistores.

A amostra de rocha deve ser modelada usando uma rede de resistores com certos resistores com alta resistência (representando rocha sólida) e outros resistores com baixa resistência (representando vias de fluido na rocha).

Suponha que eu tenha uma rede de resistores em uma grade uniforme, como mostrado abaixo. No exemplo mostrado, cada segmento de linha possui um resistor associado rotulado de 1 a 24 em uma grade de 3 por 3. As resistências de cada segmento de linha são conhecidas.

O comprimento total da grade é e a "área" é $L$$A$ (neste caso, é um exemplo 2D, portanto a área também é apenas um comprimento). A resistividade a granel da amostra é então dada por:

$$\rho_{bulk} = \frac{R_{eff}A}{L}$$

Minha pergunta: Como determino a resistência efetiva, $R_{eff}$ da rede?

Procurei on-line, mas tudo o que consigo encontrar são discussões sobre redes infinitas , fontes e correntes de dissipador, etc. Não estou interessado na corrente ou na tensão.

Esse problema pode ser resolvido como está?

A ideia básica é bastante simples. Você organiza uma matriz ( $V$ ) que representa "nós" ou vértices no seu sistema. Cada um desses nós tem uma "tensão" com valor escalar associada a ele que pode ser alterada ou atualizada à medida que o algoritmo prossegue. Também haverá dois nós cuja tensão não pode ser alterada. Vamos aplicar uma espécie de "bateria" aqui, para que esses dois nós representem as duas extremidades dessa bateria.

Separadamente, outras duas matrizes ( e R $Rv$$Rh$ ) representa as arestas no sistema, horizontal e vertical. Esses são seus valores de resistência, eu acho. Não tenho certeza de como você pretende preenchê-las. Mas esse é o seu problema. Essa técnica supõe que você também possa preencher essas matrizes.

Dependendo do idioma do computador usado, você pode ou não conseguir usar índices negativos. Não importa. É apenas uma questão de ter em mente o que você enfrenta.

Vamos supor que o comprimento seja dividido em seções N L e que o "comprimento" A seja dividido em seções N A. Então você precisará construir uma matriz com vértices ( N L + 1 ) ⋅ ( N A + 1 ) para os valores de tensão escalar. (ou maior.) Você também precisará dessas outras duas matrizes com arestas verticais N A ⋅ ( N L + 1 ) e N L ⋅ ( N A + $L$$N_L$$A$$N_A$$\left(N_L+1\right)\cdot\left(N_A+1\right)$$N_A\cdot\left(N_L+1\right)$ arestas horizontais entre esses vértices.$N_L\cdot\left(N_A+1\right)$

Agora. Inicialize todos os vértices com . Escolha um dos vértices à esquerda (no meio, de preferência) e observe-o como$0\:\textrm{V}$Valor V que NÃO pode mudar nunca. Use o método que desejar para isso. Escolha um dos vértices à direita (no meio, de preferência) e altere seu valor para$0\:\textrm{V}$ , observando novamente que seu valor NÃO pode mudar. Uma técnica que funciona aqui é simplesmente deixá-lo mudar normalmente, mas depois substituir o valor a cada passo. Mas não importa como você consegue isso, desde que você consiga.$1\:\textrm{V}$

(Existem outras técnicas por razões de eficiência. Mas provavelmente não vale a pena incomodá-las aqui.)

Agora, o algoritmo, que às vezes é chamado de xadrez ou algoritmo vermelho-preto . Movendo-se pela matriz de tensão do nó, processe cada nó em que a soma dos dois índices, é par, executando a seguinte atribuição simples:$i+j$

$$\begin{align*} V_{i,j}&=\frac{Rh_{i,j-1}\cdot Rh_{i,j}\cdot\left(V_{i-1,j}\cdot Rv_{i,j}+V_{i+1,j}\cdot Rv_{i-1,j}\right)}{Rh_{i,j-1}\cdot Rh_{i,j}\cdot \left(Rv_{i,j}+Rv_{i-1,j}\right)+Rv_{i-1,j}\cdot Rv_{i,j}\left(Rh_{i,j}+Rh_{i,j-1}\right)}\\\\ &+\frac{Rv_{i-1,j}\cdot Rv_{i,j}\cdot \left(V_{i,j-1}\cdot Rh_{i,j}+V_{i,j+1}\cdot Rh_{i,j-1}\right)}{Rh_{i,j-1}\cdot Rh_{i,j}\cdot \left(Rv_{i,j}+Rv_{i-1,j}\right)+Rv_{i-1,j}\cdot Rv_{i,j}\left(Rh_{i,j}+Rh_{i,j-1}\right)} \end{align*}$$

A equação acima nada mais é do que calcular a tensão de um nó central com quatro resistores conectados a ele, onde as tensões nas outras extremidades dos quatro resistores são conhecidas. A tensão do nó central é então calculada a partir da equação acima. Como o divisor é o mesmo para cada termo, você pode calcular a soma dos numeradores e dividir uma vez pelo denominador.

Isso atualizará todos os nós em que a soma é par. Agora você executa o mesmo procedimento para todos os nós em que a soma i + j é ímpar. Depois que essas duas etapas foram executadas, você completou um ciclo.$i+j$$i+j$

Se necessário, redefina os dois nós especiais (para e para$0\:\textrm{V}$ como discutido anteriormente.) Ou, se você protegeu esses dois nós, não há necessidade de redefini-los.$1\:\textrm{V}$

Você está pronto para o próximo ciclo. Execute esses ciclos quantas vezes achar necessário para que o estado geral se acalme (e assim será).

Quando você interrompe o processo, pode resolver facilmente a resistência escolhendo olhar para os nós ao redor do nó protegido do lado esquerdo ou para os nós ao redor do nó protegido do lado direito. (Pode ser uma boa idéia aumentar sua matriz apenas o suficiente [em 1 em todas as direções] para que você tenha quatro nós em torno de qualquer opção.) A diferença de voltagem entre os nós circundantes e o nó especial, dividida pelo a resistência nas bordas entre eles informa a saída / entrada atual do nó especial. Como este é um nó "bateria", essa corrente deve ser TODA da corrente. Como a tensão é , por definição, dividir 1 pela soma dessas quatro correntes que você encontrar indica a resistência total.$1\:\textrm{V}$

Estou olhando para um código que escrevi que totaliza, com muitos comentários, apenas 67 linhas. Portanto, não é difícil escrever.

O "breve resumo" dessa idéia é que você aplica e observe como as tensões se espalham pelo sistema. Uma vez que as tensões se estabilizam (seus critérios para isso), tudo o que você precisa fazer é observar a corrente que entra ou sai de um terminal da bateria ou do outro. Ambos devem ter o mesmo valor atual (dentro de alguns limites numéricos) por razões óbvias.$1\:\textrm{V}$

---

Por que você deve separar o sistema em i + j = par e i + j = ímpar?

$V_{5,5}=f\left(V_{4,5},V_{6,5},V_{5,4},V_{5,6}\right)$$V_{5,5}$$V_{5,6}=f\left(V_{4,6},V_{6,6},V_{5,5},V_{5,7}\right)$$V_{5,5}$$V_{5,7}=f\left(V_{4,7},V_{6,7},V_{5,6},V_{5,8}\right)$ because none of the inputs to the function are nodes that were changed during this step. Then you swing around and compute the alternates, avoiding the smudging but now updating the alternates. You really do have to do it this way.

Also, is the formula identical for both even and odd steps through?

Yes, it's the same.

Can it all be solved in one step using some sort of linear system Ax=b where A is a linear operator and b provides the boundary conditions? Looking at it, it seems somewhat analogous to finite difference methods for solving partial differential equations..

There is a connection. I think it's called a 'matrix-free' implementation.

---

Here's an example. The following set of resistor values were placed into LTSpice for simulation:

I kept it short and simple. As you can see, the approximate computed current from the $1\:\textrm{V}$ power supply is given as $30.225\:\textrm{mA}$. (The actual value computed by Spice was $30.224552\:\textrm{mA}$.)

I ran the following VB.NET program:

Module GEOGRID

    Const NL As Integer = 2
    Const NA As Integer = 2
    Const INF As Double = 1.0E+32

    Sub Main()

        Static Rh As Double(,) = New Double(NL + 2, NA + 1) {
                    {INF, INF, INF, INF},
                    {INF, 5, 21, INF},
                    {INF, 76, 10, INF},
                    {INF, 32, 22, INF},
                    {INF, INF, INF, INF}}
        Static Rv As Double(,) = New Double(NA + 1, NL + 2) {
                    {INF, INF, INF, INF, INF},
                    {INF, 61, 50, 16, INF},
                    {INF, 56, 45, 18, INF},
                    {INF, INF, INF, INF, INF}}
        Dim V As Double(,) = New Double(NL + 2, NA + 2) {
                    {0, 0, 0, 0, 0},
                    {0, 0, 0, 0, 0},
                    {0, 0, 0, 1, 0},
                    {0, 0, 0, 0, 0},
                    {0, 0, 0, 0, 0}}
        Dim PDE As Func(Of Integer, Integer, Double) = Function(ByVal i As Integer, ByVal j As Integer) (
                    Rh(i, j - 1) * Rh(i, j) * (V(i - 1, j) * Rv(i, j) + V(i + 1, j) * Rv(i - 1, j)) +
                    Rv(i - 1, j) * Rv(i, j) * (V(i, j - 1) * Rh(i, j) + V(i, j + 1) * Rh(i, j - 1))
                  ) / (
                    Rh(i, j - 1) * Rh(i, j) * (Rv(i, j) + Rv(i - 1, j)) +
                    Rv(i - 1, j) * Rv(i, j) * (Rh(i, j) + Rh(i, j - 1))
                  )
        Dim IV As Func(Of Integer, Integer, Double) = Function(ByVal i As Integer, ByVal j As Integer) 0 +
                    (V(i, j) - V(i - 1, j)) / Rv(i - 1, j) + (V(i, j) - V(i + 1, j)) / Rv(i, j) +
                    (V(i, j) - V(i, j - 1)) / Rh(i, j - 1) + (V(i, j) - V(i, j + 1)) / Rh(i, j)
        Dim idx As Integer = NA \ 2 + 1
        Dim jdx1 As Integer = NL + 1
        Dim jdx2 As Integer = 1
        For x As Integer = 1 To 1000
            For k As Integer = 0 To (NA + 1) * (NL + 1) - 1 Step 2
                Dim i As Integer = k \ (NL + 1)
                Dim j As Integer = k - i * (NL + 1) + 1
                i += 1
                If Not (i = idx AndAlso (j = jdx1 OrElse j = jdx2)) Then V(i, j) = PDE(i, j)
            Next
            For k As Integer = 1 To (NA + 1) * (NL + 1) - 1 Step 2
                Dim i As Integer = k \ (NL + 1)
                Dim j As Integer = k - i * (NL + 1) + 1
                i += 1
                If Not (i = idx AndAlso (j = jdx1 OrElse j = jdx2)) Then V(i, j) = PDE(i, j)
            Next
        Next
        Console.WriteLine("R = " & (1.0 / IV(idx, jdx1)).ToString)
        Console.WriteLine("R = " & (-1.0 / IV(idx, jdx2)).ToString)
    End Sub

End Module

With the following result printed out: $R = 33.0856844038614\:\Omega$. Which is the correct answer.

The above program shows a way of setting up the resistors, vertical and horizontal, as well as the voltage matrix, so that it simplifies some of the tests for non-existent nodes and/or resistor values. The code is a little cleaner, this way, though it does require some more array elements. (I've simply made the extra resistor values infinite in value.) Just compare how I've set up the arrays with the way the schematic was laid out, as well, and I think you will be able to work out all the exact details here.

I've also hacked in the resistors and node values, of course, without making this in any way a general purpose program for reading up a table of values. But that generality is pretty easy to add. And this code should make everything I wrote absolutely unambiguous.

Note that I also just ran the $x$ loop 1000 types, alternating red and black within the $x$ loop. I just picked a number. To make this more general purpose, you may prefer a different way of determining how many iterations to perform.

And a final note. Just to prove that you can use either fixed voltage node's current to compute the resistor, I've used two lines in order to print out both values: one computed from the $0\:\textrm{V}$ side and one computed from the $1\:\textrm{V}$ side. Either way, you should see the same number.

(Okay. One more final note. This would be much better targeted at F# or any decent compiler targeting a massively parallel computing system. Each calculation in either "red" or "black" can be performed in parallel; completely independently of each other. F# makes this trivial. So coded in F#, you could run this on all of your available cores without anything special to do. It just works. Just a note in case you are collecting a LOT of data in some fashion and might want to take full advantage of a multi-core system.)

---

END NOTE:

The derivation is pretty simple from KCL. Place four resistors into the following arrangement:

^{simulate this circuit – Schematic created using CircuitLab}

Apply KCL:

$$\begin{align*} \frac{V}{R_1}+\frac{V}{R_2}+\frac{V}{R_3}+\frac{V}{R_4} &= \frac{V_1}{R_1}+\frac{V_2}{R_2}+\frac{V_3}{R_3}+\frac{V_4}{R_4}\\\\ &\therefore\\\\ V &=\left(\frac{V_1}{R_1}+\frac{V_2}{R_2}+\frac{V_3}{R_3}+\frac{V_4}{R_4}\right)\bigg(R_1 \mid\mid R_2 \mid\mid R_3 \mid\mid R_4\bigg) \end{align*}$$

Some playing around with algebra gets the result I used in the code.

You can certainly take the approach of a 2D resistor network to model a 2D problem but that can get somewhat tricky when moving to 3 dimensions. You might want to consider using a more traditional (these days) approach with volume conductors defined in your domains with an appropriate conductivity assigned to each. The FEMM freeware code (http://www.femm.info/wiki/HomePage) is very capable and can be used for 2D, axial symmetry and 3D. From there you can consider moving to much more capable codes like SCIrun (https://www.sci.utah.edu/) which is an academic code for volume conductor problems of substantial complexity. I use it routinely for meshes of more than a million tetrahedrons. Even though it was primarily developed for biological modeling it should work great for what you are doing. The examples of forward problems in the forward/inverse toolkit should get you going. You might find the inverse problems valuable for impedance tomography, too. I generally use version 4 since version 5 is still a work in progress. The software also has an interface to tetgen which is a great mesh building code.

Finally, if you are not opposed to spending money there is always COMSOL, which is very easy to use (and quite expensive).