A matrix approach to the Moog ladder filter

[JCJR]

One thing of interest was discussion of the wave digital filter for electronics, a network grid of "reflection nodes". Which may be incredibly old info for all I know.

Am typically ignorant, but had seen references about its use in reverb emulation, and acoustic room simulation. For room simulation as best I recall, every node in the grid might represent a cube of air in the room, and each cube would follow rules interacting with all its neighbors.

Mr Yeh in the introduction tries to limit his discussion to subsystems bounded by high impedance input and low impedance output.

Maybe some commercial modelers do very detailed emulation of power tube <-> transformer <-> speaker <-> air + cabinet. Dunno.

But that chain is a big ball of components, and each component is complicated in its own right. The air and cabinet affects the speaker, the speaker affects the transformer, the transformer affects the power tubes. The signal isn't going only one way from high impedance to low.

Had wondered how one would try to model such a complicated interaction. Perhaps that wave digital filter would be a valuable notion in trying to model the complicated interaction.

[aciddose]

To the best of my understanding of modern circuit simulators, they essentially break down to large matrices or "networks" and operations on those matrices.

E.g. http://www.linear.com/solutions/5739

[Miles1981]

That's when you want model everything. The issue is that these simulations cannot be made real time...
So then, you can have to compare the full system with smaller subsystems that are easier to solve, and see if you can make the assumption, the split being made on high imp/low imp "barriers".

[mystran]

One thing of interest was discussion of the wave digital filter for electronics, a network grid of "reflection nodes". Which may be incredibly old info for all I know.

While WDF is kinda cool formulation, it turns out that a standard MNA is basically equivalent (or rather, your MNA matrix becomes a general N-port scattering junction) if you apply a simple trick: encode the integration rule into your capacitor/inductor "stamps" and your state variables become pure delays just like in WDF. This is probably the most useful contribution of the WDF approach, since it saves you from a separate integration step (which can translate into slight computational speedup in practice). That said, it works perfectly fine with a generic matrix solver too.

The process of calculating scattering coefficients is almost exactly like the process of LU factoring a matrix. Your reflection free port then is the bottom row of the matrix: after forward substitution, before you solve backwards this node does not depend on anything else and you can order your matrix to put your non-linearities there (and in fact, you can also order multiple non-linearities to the bottom rows to iterate a reduced order system).

Whether you find it easier to formulate circuits into parallel series connections (such that you can use the WDF connection rules) or simply to stamp it all into a general matrix is up to you. For simple circuits WDF might be slightly less error-prone when done manually, where as for complex circuits you'll probably want to automate it either way, and it is generally easier to do this working with MNA directly (since you can just build it from a generic netlist, without having to worry about what to connect where).

[Smashed Transistors]

Surely, all these studies will converge to some real time audio Spice solver.
By the way, how far from real time are Spice or gnucap ?

Back to the initial topic. here is some java code for the step invariant linear 24 dB filter. It implements an iterative method that uses many simplifications for squaring the transition matrix.
It's slightly simpler than the analytic version. Six iterations provide a nice result.

Code: Select all

   public class MExpon {
            /*
      Step invariant 24dB filter        T.Rochebois oct15
            Transition matrix
            x  yA  yB  yC  yD
            
    new yA  a   e  -kh -kg -kf
    new yB  b   f   e  -kh -kg
    new yC  c   g   f   e  -kh
    new yD  d   h   g   f   e
            */

        double yA, yB, yC, yD;
        double nyA, nyB, nyC, nyD;

        double a, b, c, d, e, f, g, h;

        double proc(double x, double ff, double k, int iter) {
            //_____________________________________________________
            //                              CONTROL
            double ne, nf, ng, nh;
            double w = PI * ff * pow(2, -iter);
            // init with open loop step invariant coefs
            e = exp(-w);
            f = w * e;
            g = 0.5 * w * f;
            h = (1/3.0) * w * g;

            for (int i = 0; i < iter; i++) {

                ne = k * (-2 * f * h - g * g) + e * e;
                nf = 2 * (e * f - g * h * k);
                ng = -h * h * k + 2 * e * g + f * f;
                nh = 2 * (e * h + f * g);

                e = ne;
                f = nf;
                g = ng;
                h = nh;
            }

            d = (1 - e - f - g - h) / (k + 1);
            c = d + h;
            b = c + g;
            a = b + f;
            //_____________________________________________________
            //                                    AUDIO
            nyA = e * yA + a * x - k * (f * yD + g * yC + h * yB);
            nyB = e * yB + f * yA + b * x - k * (g * yD + h * yC);
            nyC = e * yC + f * yB + g * yA + c * x - k * h * yD;
            nyD = e * yD + f * yC + g * yB + h * yA + d * x;
            yA = nyA;
            yB = nyB;
            yC = nyC;
            yD = nyD;
            return yD;
        }  
    }

[Miles1981]

Non linear equation solving is a rich field, but I don't think we will see a real time simulation of say a full amplifier in the near future. That would require lots of processing power. And the SPU speed is stagnating...