¿Cómo se determina la resistencia efectiva de una red finita de resistencias?

La idea básica es bastante simple. Organizas una matriz ($V$) que representa "nodos" o vértices en su sistema. Cada uno de estos nodos tiene un "voltaje" de valor escalar asociado que se puede cambiar o actualizar a medida que avanza el algoritmo. También habrá dos nodos cuyo voltaje no se puede cambiar. Vamos a aplicar una especie de "batería" aquí, por lo que esos dos nodos representan los dos extremos de esta batería.

Por separado, otras dos matrices ($Rv$y$Rh$) representa los bordes en el sistema, horizontal y vertical. Estos son tus valores de resistencia, supongo. No estoy seguro de cómo pretendes llenarlos. Pero ese es tu problema. Esta técnica asume que usted también puede completar estas matrices.

Según el lenguaje informático que utilice, es posible que pueda o no utilizar índices negativos. No importa Solo es cuestión de tener en cuenta a lo que te enfrentas.

Supongamos longitud$L$se divide en$N_L$secciones y esa "longitud"$A$se divide en$N_A$secciones. Entonces necesitarás construir una matriz con$\left(N_L+1\right)\cdot\left(N_A+1\right)$vértices para los valores de voltaje escalar. (o más grande). También necesitará esas otras dos matrices con$N_A\cdot\left(N_L+1\right)$bordes verticales y$N_L\cdot\left(N_A+1\right)$bordes horizontales entre esos vértices.

Ahora. Inicializar todos los vértices con$0\:\textrm{V}$. Elija uno de los vértices de la izquierda (en el medio, preferiblemente) y anótelo como un$0\:\textrm{V}$valor que NO se permite cambiar nunca. Usa el método que quieras para esto. Elija uno de los vértices de la derecha (en el medio, preferiblemente) y cambie su valor a$1\:\textrm{V}$, mientras toma nota nuevamente de que NO se permite que su valor cambie nunca. Una técnica que funciona aquí es simplemente dejar que cambie normalmente pero luego reemplazar el valor en todos y cada uno de los pasos. Pero no importa cómo lo consigas, siempre y cuando lo consigas.

(Hay otras técnicas por razones de eficiencia. Pero probablemente no valga la pena molestarse con ellas aquí).

Ahora para el algoritmo, que a veces se llama tablero de ajedrez o algoritmo rojo-negro . Moviéndose a través de su matriz de voltaje de nodo, procese cada nodo donde la suma de los dos índices,$i+j$es par, realizando la siguiente asignación simple:

$$\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*}$$

La ecuación anterior no es más que calcular el voltaje de un nodo central que tiene cuatro resistencias conectadas a él, donde se conocen los voltajes en los otros extremos de las cuatro resistencias. Luego, el voltaje del nodo central se calcula a partir de la ecuación anterior. Dado que el divisor es el mismo para cada término, podría calcular la suma de los numeradores y luego dividir una vez por el denominador.

Eso actualizará todos los nodos donde la suma$i+j$incluso. Ahora realiza el mismo procedimiento para todos los nodos donde la suma$i+j$es impar. Una vez que se hayan realizado estos dos pasos, habrá completado un ciclo.

Si es necesario, reinicie los dos nodos especiales (por$0\:\textrm{V}$y para$1\:\textrm{V}$como se discutió anteriormente). O, si protegió esos dos nodos, no hay necesidad de restablecerlos.

Estás listo para el próximo ciclo. Realice estos ciclos tantas veces como considere necesario para que el estado general se estabilice (y lo hará).

Cuando detiene el proceso, puede calcular fácilmente la resistencia eligiendo mirar los nodos que rodean el nodo protegido del lado izquierdo o mirar los nodos que rodean el nodo protegido del lado derecho. (Puede ser una buena idea hacer que su matriz sea lo suficientemente grande [en 1 en todas las direcciones] para que tenga cuatro nodos alrededor de cada opción). La diferencia de voltajes entre los nodos circundantes y el nodo especial, dividida por el la resistencia en los bordes entre ellos le indica la salida/entrada actual de su nodo especial. Dado que este es un nodo de "batería", esta corriente debe ser TODA la corriente. Dado que el voltaje es$1\:\textrm{V}$, por definición, dividir 1 por la suma de estas cuatro corrientes que encuentra le indica la resistencia total.

Estoy mirando un código que escribí que totaliza, con muchos comentarios, solo 67 líneas. Así que NO es difícil de escribir.

El "breve resumen" de esta idea es que se aplica un$1\:\textrm{V}$batería y luego observe cómo los voltajes se propagan por todo el sistema. Una vez que los voltajes se estabilizan (su criterio para eso), todo lo que tiene que hacer es mirar la corriente que entra o sale de un terminal de la batería o del otro. Ambos deben tener el mismo valor actual (dentro de algunos límites numéricos) por razones obvias.

---

¿Por qué debes separar el sistema en i+j = par e i+j = impar?

Supongamos que calcula$V_{5,5}=f\left(V_{4,5},V_{6,5},V_{5,4},V_{5,6}\right)$. Esto hace referencia a los nodos que rodean$V_{5,5}$. Esta bien. Supongamos que a continuación calcula$V_{5,6}=f\left(V_{4,6},V_{6,6},V_{5,5},V_{5,7}\right)$. Tenga en cuenta que en la lista de parámetros está el valor que acaba de calcular para$V_{5,5}$? Esto "mancharía" mucho las cosas. No es sonido. En cambio, cada ciclo de pares/impares debería "aparecer como si" ocurriera en el mismo momento. Así que tu próximo cálculo debería ser$V_{5,7}=f\left(V_{4,7},V_{6,7},V_{5,6},V_{5,8}\right)$porque ninguna de las entradas de la función son nodos que se cambiaron durante este paso. Luego gira y calcula las alternativas, evitando las manchas pero ahora actualizando las alternativas. Realmente tienes que hacerlo de esta manera.

Además, ¿la fórmula es idéntica para los pasos pares e impares?

Sí, es lo mismo.

¿Se puede resolver todo en un solo paso usando algún tipo de sistema lineal Ax=b donde A es un operador lineal yb proporciona las condiciones de contorno? Mirándolo, parece algo análogo a los métodos de diferencias finitas para resolver ecuaciones diferenciales parciales.

Hay una conexión. Creo que se llama implementación 'sin matriz'.

---

Aquí hay un ejemplo. El siguiente conjunto de valores de resistencia se colocó en LTSpice para la simulación:

Lo mantuve breve y simple. Como puede ver, la corriente calculada aproximada del$1\:\textrm{V}$la fuente de alimentación se da como$30.225\:\textrm{mA}$. (El valor real calculado por Spice fue$30.224552\:\textrm{mA}$.)

Ejecuté el siguiente programa VB.NET:

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

Con el siguiente resultado impreso:$R = 33.0856844038614\:\Omega$. Cuál es la respuesta correcta.

El programa anterior muestra una forma de configurar las resistencias, verticales y horizontales, así como la matriz de voltaje, de modo que simplifica algunas de las pruebas para nodos inexistentes y/o valores de resistencia. El código es un poco más limpio, de esta manera, aunque requiere algunos elementos de matriz más. (Simplemente he hecho que los valores de la resistencia extra tengan un valor infinito). Simplemente compare cómo configuré las matrices con la forma en que se presentó el esquema, y ​​creo que podrá resolver todo exactamente. detalles aquí.

También he pirateado las resistencias y los valores de los nodos, por supuesto, sin convertirlo de ninguna manera en un programa de propósito general para leer una tabla de valores. Pero esa generalidad es bastante fácil de agregar. Y este código debería hacer que todo lo que escribí sea absolutamente inequívoco.

Tenga en cuenta que también acabo de ejecutar el$x$loop 1000 tipos, alternando rojo y negro dentro del$x$círculo. Acabo de elegir un número. Para que este propósito sea más general, es posible que prefiera una forma diferente de determinar cuántas iteraciones realizar.

Y una nota final. Solo para demostrar que puede usar la corriente de cualquier nodo de voltaje fijo para calcular la resistencia, he usado dos líneas para imprimir ambos valores: uno calculado a partir del$0\:\textrm{V}$lado y uno calculado a partir del$1\:\textrm{V}$lado. De cualquier manera, deberías ver el mismo número.

(Está bien. Una nota final más. Esto estaría mucho mejor dirigido a F# o a cualquier compilador decente que se dirija a un sistema de computación paralelo masivo. Cada cálculo en "rojo" o "negro" se puede realizar en paralelo, de manera completamente independiente entre sí. F# hace que esto sea trivial. Entonces, codificado en F#, puede ejecutarlo en todos sus núcleos disponibles sin nada especial que hacer. Simplemente funciona. Solo una nota en caso de que esté recopilando MUCHOS datos de alguna manera y desee tomar todas las ventajas de un sistema multinúcleo).

---

NOTA FINAL:

La derivación es bastante simple de KCL. Coloque cuatro resistencias en el siguiente arreglo:

^{simular este circuito : esquema creado con CircuitLab}

Aplicar 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*}$$

Algunos juegos con álgebra obtienen el resultado que usé en el código.

Sin duda, puede adoptar el enfoque de una red de resistencias 2D para modelar un problema 2D, pero eso puede ser algo complicado cuando se pasa a 3 dimensiones. Es posible que desee considerar el uso de un enfoque más tradicional (actualmente) con conductores de volumen definidos en sus dominios con una conductividad apropiada asignada a cada uno. El código gratuito FEMM ( http://www.femm.info/wiki/HomePage ) es muy capaz y se puede utilizar para 2D, simetría axial y 3D. A partir de ahí, puede considerar pasar a códigos mucho más capaces como SCIrun ( https://www.sci.utah.edu/) que es un código académico para problemas de conductores de volumen de complejidad sustancial. Lo uso habitualmente para mallas de más de un millón de tetraedros. Aunque se desarrolló principalmente para el modelado biológico, debería funcionar muy bien para lo que está haciendo. Los ejemplos de problemas de reenvío en el conjunto de herramientas de reenvío/inverso deberían ayudarlo a comenzar. También puede encontrar valiosos los problemas inversos para la tomografía de impedancia. Generalmente uso la versión 4 ya que la versión 5 todavía es un trabajo en progreso. El software también tiene una interfaz para tetgen, que es un gran código de construcción de mallas.

Finalmente, si no se opone a gastar dinero, siempre está COMSOL, que es muy fácil de usar (y bastante caro).

No me interesa la corriente ni el voltaje.

Usted está interesado en él. La resistencia es solo la relación entre la corriente y el voltaje, suponiendo que tenga una solución para la corriente para algún voltaje externo. Y podría resolverlo usando cualquier paquete SPICE directamente.

Este enfoque para determinar la resistencia tiene una advertencia: necesita un sistema lineal. Cualquier cosa con condensadores, inductores y resistencias como los únicos elementos sería un sistema de este tipo. De lo contrario, la resistencia se vuelve una función del voltaje aplicado y potencialmente también de la historia del circuito, y es mejor llamarla resistencia incremental o diferencial.