Come si determina la resistenza effettiva di una griglia finita di resistori?

Disclaimer: sono un geofisico con un limitato background in ingegneria elettrica. Non sono sicuro che questo problema sia incredibilmente facile, incredibilmente complesso o completamente privo di senso.

Il mio obiettivo: determinare la resistività di massa di un campione di roccia utilizzando reti di resistori.

Il campione di roccia deve essere modellato utilizzando una rete di resistori con alcuni resistori ad alta resistenza (che rappresentano la roccia solida) e altri resistori con bassa resistenza (che rappresentano i percorsi dei fluidi nella roccia).

Supponiamo che io abbia una rete di resistori su una griglia uniforme come mostrato di seguito. Nell'esempio mostrato, ogni segmento di linea ha un resistore associato etichettato da 1 a 24 su una griglia 3 per 3. Le resistenze di ciascun segmento di linea sono note.

La lunghezza totale della griglia è $L$ e "area" è $A$ (in questo caso è un esempio 2-D, quindi anche l'area è solo una lunghezza). La resistività di massa del campione è quindi data da:

ρ_{b u l k} = \frac{R_{e f f} A}{L}

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

La mia domanda: come posso determinare la resistenza effettiva, $R_{eff}$ della rete?

Ho cercato online, ma tutto ciò che posso trovare sono discussioni su reti infinite , correnti di source e sink, ecc. Non sono interessato alla corrente o alla tensione.

Questo problema può essere risolto così com'è?

— Darcy
fonte

Vorrei collegarlo a un simulatore e lasciare che il simulatore lo risolva. Puoi costruire il tuo modello come un circuito di spezie. Quindi per trovare resistenza, basta usare la legge di Ohm (V = I * R). Spice ti dirà la corrente in modo da poter calcolare R.

— mkeith il

L'intera cosa può essere potenzialmente automatizzata usando la spezia della riga di comando, ma per la prova del concetto, puoi entrare nel tuo circuito in una spezia gratuita come LTSpice. Applicare una tensione e visualizzare la corrente. LTspice può anche visualizzare funzioni semplici come una tensione divisa per una corrente (resistenza).

— mkeith,

Darcy, ci sono una serie di approcci. Vorrei porre alcune domande prima di offrire qualsiasi pensiero. (1) Esiste un software molto semplice da scrivere. Stai cercando questo tipo di approccio? (2) Potresti risolverlo usando la tradizionale analisi nodale. Stai cercando questo tipo di approccio? (3) Il problema si scompone in vertici e bordi . (Dato il tuo background di geofisico, mi aspetto che tu conosca il significato di quei due termini.) Come fai, a priori, a capire i valori che inseriresti per i bordi?

— Jon

@jonk Sarei principalmente interessato all'opzione (1) di scrivere un breve pezzo di codice per farlo. Determino le resistenze dei bordi in base alla geometria dei pori a priori e alla resistività nota di un minerale o fluido di roccia.

— Darcy,

Darcy, ci sono anche tecniche che attingono da reti irregolari triangolate che mi vengono subito in mente quando scrivi "percorsi fluidi". Hai letto qualcosa su questo argomento? Non so quali siano i tuoi obiettivi in definitiva, ma potresti anche volerli cercare. Sarebbe fantastico usarli per gradienti che ti aiutino a capire dove "correnti" tendono a concentrarsi. Se questa è una preoccupazione.

— Jon

L'idea di base è abbastanza semplice. Disponi una matrice ( ) che rappresenta "nodi" o vertici nel tuo sistema. A ciascuno di questi nodi è associata una "tensione" a valori scalari che può essere modificata o aggiornata man mano che l'algoritmo procede. Ci saranno anche due nodi la cui tensione non può essere modificata. Qui applicheremo una sorta di "batteria", quindi quei due nodi rappresentano le due estremità di questa batteria. $V$

Separatamente, altre due matrici ( e $Rv$ ) rappresentano i bordi nel sistema, orizzontale e verticale. Questi sono i tuoi valori di resistenza, immagino. Non sono sicuro di come intendi compilarli. Ma questo è il tuo problema. Questa tecnica presuppone che tu sia in grado di popolare anche queste matrici. $Rh$

A seconda del linguaggio utilizzato, è possibile o meno utilizzare indici negativi. Non importa È solo una questione di tenere a mente ciò che devi affrontare.

Supponiamo che la lunghezza sia divisa in sezioni e che la "lunghezza" sia divisa in sezioni Quindi dovrai costruire una matrice con vertici per i valori di tensione scalare. (o più grande) Avrai anche bisogno di quelle altre due matrici con bordi verticali e $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)$ bordi orizzontali tra quei vertici. $N_L\cdot\left(N_A+1\right)$

Adesso. Inizializza tutti i vertici con . Scegli uno dei vertici a sinistra (al centro, preferibilmente) e annotalo come $0\:\textrm{V}$ Valore che NON può mai cambiare. Usa qualunque metodo tu voglia per questo. Scegli uno dei vertici a destra (al centro, preferibilmente) e cambia il suo valore in $0\:\textrm{V}$ , pur prendendo di nuovo atto che il suo valore NON può mai cambiare. Una tecnica che funziona qui è semplicemente lasciarlo cambiare normalmente ma poi sostituire il valore ogni singolo passaggio. Ma non importa come raggiungi questo, purché lo raggiungi. $1\:\textrm{V}$

(Esistono altre tecniche per motivi di efficienza. Ma probabilmente non vale la pena preoccuparsene qui.)

Ora per l'algoritmo, che a volte viene chiamato scacchiera o algoritmo rosso-nero . Muovendosi attraverso la matrice di tensione del nodo, elaborare ciascun nodo in cui la somma dei due indici, è pari, eseguendo la seguente semplice assegnazione: $i+j$

\begin{aligned} V_{i, j} & = \frac{R h_{i, j - 1} \cdot R h_{i, j} \cdot (V_{i - 1, j} \cdot R v_{i, j} + V_{i + 1, j} \cdot R v_{i - 1, j})}{R h_{i, j - 1} \cdot R h_{i, j} \cdot (R v_{i, j} + R v_{i - 1, j}) + R v_{i - 1, j} \cdot R v_{i, j} (R h_{i, j} + R h_{i, j - 1})} \\ + \frac{R v_{i - 1, j} \cdot R v_{i, j} \cdot (V_{i, j - 1} \cdot R h_{i, j} + V_{i, j + 1} \cdot R h_{i, j - 1})}{R h_{i, j - 1} \cdot R h_{i, j} \cdot (R v_{i, j} + R v_{i - 1, j}) + R v_{i - 1, j} \cdot R v_{i, j} (R h_{i, j} + R h_{i, j - 1})} \end{aligned}

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

L'equazione di cui sopra non è altro che calcolare la tensione di un nodo centrale avente quattro resistori collegati ad esso, dove sono note le tensioni alle altre estremità dei quattro resistori. La tensione del nodo centrale viene quindi calcolata dall'equazione sopra. Poiché il divisore è lo stesso per ogni termine, puoi semplicemente calcolare la somma dei numeratori e quindi dividere una volta per il denominatore.

Ciò aggiornerà tutti i nodi in cui la somma è pari. Ora esegui la stessa procedura per tutti i nodi in cui la somma $i+j$ $i+j$ è dispari. Una volta eseguiti entrambi questi passaggi, hai completato un ciclo.

Se necessario, ripristinare i due nodi speciali (per e per $0\:\textrm{V}$ come discusso in precedenza.) Oppure, se hai protetto questi due nodi, non è necessario ripristinarli. $1\:\textrm{V}$

Sei pronto per il ciclo successivo. Esegui questi cicli tutte le volte che ritieni necessario affinché lo stato generale si stabilizzi (e lo farà).

Quando interrompi il processo, puoi facilmente calcolare la resistenza scegliendo di esaminare i nodi che circondano il nodo protetto sul lato sinistro oppure i nodi che circondano il nodo protetto sul lato destro. (Potrebbe essere una buona idea rendere la tua matrice appena più grande [di 1 in tutte le direzioni] in modo da avere effettivamente quattro nodi che circondano entrambe le scelte.) La differenza di tensione tra i nodi circostanti e il nodo speciale, divisa per la resistenza nei bordi tra loro ti dice l'attuale partenza / entrata nel tuo nodo speciale. Poiché si tratta di un nodo "batteria", questa corrente deve essere TUTTA la corrente. Poiché la tensione è $1\:\textrm{V}$

Sto fissando un codice che ho scritto che totalizza, con molti commenti, solo 67 righe. Quindi NON è difficile da scrivere.

$1\:\textrm{V}$

Perché è necessario separare il sistema in i + j = pari e i + j = dispari?

$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)$ perché nessuno degli input per la funzione sono nodi che sono stati modificati durante questo passaggio. Quindi ti muovi e calcoli gli alternati, evitando le sbavature ma ora aggiornando gli alternati. Devi davvero farlo in questo modo.

Inoltre, la formula è identica per i passaggi pari e dispari?

Sì, è lo stesso.

Tutto può essere risolto in un solo passaggio usando una sorta di sistema lineare Ax = b dove A è un operatore lineare e b fornisce le condizioni al contorno? Guardandolo, sembra in qualche modo analogo ai metodi a differenza finita per risolvere equazioni differenziali parziali.

C'è una connessione Penso che sia chiamata un'implementazione 'senza matrice'.

Ecco un esempio Il seguente set di valori di resistenza è stato inserito in LTSpice per la simulazione:

$1\:\textrm{V}$ $30.225\:\textrm{mA}$ $30.224552\:\textrm{mA}$

Ho eseguito il seguente programma 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

$R = 33.0856844038614\:\Omega$

Il programma sopra mostra un modo per impostare i resistori, verticali e orizzontali, nonché la matrice di tensione, in modo da semplificare alcuni dei test per nodi inesistenti e / o valori di resistori. Il codice è un po 'più pulito, in questo modo, anche se richiede più elementi dell'array. (Ho semplicemente reso infiniti i valori dei resistori extra.) Basta confrontare il modo in cui ho impostato gli array con il modo in cui è stato disposto lo schema, e penso che sarai in grado di elaborare esattamente dettagli qui.

Ho anche hackerato i resistori e i valori dei nodi, ovviamente, senza renderlo in alcun modo un programma generico per la lettura di una tabella di valori. Ma questa generalità è abbastanza facile da aggiungere. E questo codice dovrebbe rendere tutto inequivocabile tutto ciò che ho scritto.

$x$ $x$

$0\:\textrm{V}$ $1\:\textrm{V}$

(Va bene. Un'altra nota finale. Questo sarebbe molto più mirato su F # o su qualsiasi compilatore decente destinato a un sistema di elaborazione massicciamente parallelo. Ogni calcolo in "rosso" o "nero" può essere eseguito in parallelo, completamente indipendentemente l'uno dall'altro. F # lo rende banale. Così codificato in F #, potresti eseguirlo su tutti i tuoi core disponibili senza nulla di speciale da fare. Funziona. Solo una nota nel caso in cui stai raccogliendo MOLTI dati in qualche modo e potresti voler prendere pieno vantaggio di un sistema multi-core.)

NOTA FINE:

La derivazione è piuttosto semplice da KCL. Posizionare quattro resistori nella seguente disposizione:

schematico

^{simula questo circuito - Schema creato usando CircuitLab}

Applica KCL:

\begin{aligned} \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}} \\ ∴ \\ V & = (\frac{V_{1}}{R_{1}} + \frac{V_{2}}{R_{2}} + \frac{V_{3}}{R_{3}} + \frac{V_{4}}{R_{4}}) (R_{1} || R_{2} || R_{3} || R_{4}) \end{aligned}

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

Alcuni che giocano con l'algebra ottengono il risultato che ho usato nel codice.

— Jonk
fonte

Grazie per la magnifica risposta. Ho alcune domande di chiarimento. 1) Perché è necessario separare il sistema

i + j

$i+j$ = pari e

i + j

$i+j$ = dispari? 2) Può tutto essere risolto in un solo passaggio usando una sorta di sistema lineare

A x = b

$\mathrm{Ax}=\mathrm{b}$ dove

A

$\mathrm{A}$ è un operatore lineare e

b

$\mathrm{b}$ fornisce le condizioni al contorno? Guardandolo, sembra in qualche modo analogo ai metodi a differenza finita per risolvere equazioni differenziali parziali ...

— Darcy,

Inoltre, la formula è identica per i passaggi pari e dispari?

— Darcy,

@Darcy scriverò ancora un po 'per aiutare a risolvere questi problemi.

— Jon

Grazie ancora per i dettagli. Un'ultima domanda (e forse questa potrebbe andare come una domanda completamente separata ma la farò qui): se tutti i resistori nella rete hanno la stessa resistenza (diciamo 1 Ohm), ne consegue che anche la resistenza effettiva dovrebbe essere 1 Ohm? La mia intuizione dice che dovrebbe, ma non ne sono sicuro.

— Darcy,

@Darcy La tua intuizione è sbagliata e il risultato MATLAB è corretto.

— Jon

Puoi certamente adottare l'approccio di una rete di resistori 2D per modellare un problema 2D, ma può diventare un po 'complicato quando si passa a 3 dimensioni. Potresti prendere in considerazione l'utilizzo di un approccio più tradizionale (in questi giorni) con i conduttori di volume definiti nei tuoi domini con una conduttività appropriata assegnata a ciascuno. Il codice freeware FEMM ( http://www.femm.info/wiki/HomePage ) è molto capace e può essere usato per 2D, simmetria assiale e 3D. Da lì puoi prendere in considerazione il passaggio a codici molto più capaci come SCIrun ( https://www.sci.utah.edu/) che è un codice accademico per problemi di volume conduttore di notevole complessità. Lo uso regolarmente per maglie di oltre un milione di tetraedri. Anche se è stato sviluppato principalmente per la modellazione biologica, dovrebbe funzionare benissimo per quello che stai facendo. Gli esempi di problemi forward nel toolkit forward / inverse dovrebbero iniziare. Potresti trovare utili anche i problemi inversi per la tomografia ad impedenza. In genere uso la versione 4 poiché la versione 5 è ancora in fase di elaborazione. Il software ha anche un'interfaccia per tetgen che è un ottimo codice di costruzione mesh.

Infine, se non sei contrario a spendere soldi, c'è sempre COMSOL, che è molto facile da usare (e piuttosto costoso).

— Wilk
fonte