DATA-log

I want to write a little bit more about my studies on waves and automata models. I wrote a vastly improved TLM code on MATLAB which now includes for example first order absorbing boundaries. It is important to distinct this approach from a mathematical model, this is a analogous physical system to wave propagation. You could think of it as using computer memory element grid as an discrete analogy to the vacuum.

This sort of physical modelling and computation was first used by a Hungary born mathematician and electrical engineer Dr. Gabriel Kron in 1943 while working for General Electric (see paper called ‘Equivalent Circuits to Represent the Electromagnetic Field Equations’ on Physical Review Vol.64 Numbers 3-4 1943.) The approach involved analog computing in the form of a RLC network. The approach was then picked up by P.B. Johns and R.L. Beurle (see paper ‘Numerical solution of 2-dimensional scattering problems using a transmission-line matrix’ on Proc. IEE, Vol. 118, No. 9, 1971, pp. 1203-1208) applied to ‘computors’ as they were then called.

The Johns and Beurle numerical method involves applying a simple scattering automata rule to a discrete node grid. This doesn’t exactly involve integration in the sense that a discretisized mathematical model would; only arithmetic needed is addition (floating or fixed-point) for summing up the node incidence and reflection time-step impulses involved in the scattering rule (which are directly derivable from normalized unitary impedance electrical node network.)

The simple TLM here is configured for the classic Young double slit experiment. Although this particular setup could be thought to just propagate the electric field, the corresponding magnetic field can be derived aswell together with different permittivity and permeability coefficients to model material properties.

I recently got excited about cellular automata systems again, which is something that got me interested in computing in the first place. I suppose you could think of it as going back to the roots. Many nights and weekends I’d be obsessed about these seemingly simple but endlessly complex discrete systems as a kid and programming them in Basic. This also led me to study hardware level programming using machine language and assembler, since Basic was far too slow for most things.

Turns out this simple bit flipping is actually useful for something. Complexity is at the core of many important dynamic models, for example in hydrodynamics where in some cases traditional approaches are too prone for truncation and round-off noise errors to model turbulence accurately enough. Lattice gas and lattice Boltzmann models handle this sort of problem far better because of their discrete nature. Discreteness also means that the algorithms are perfect for massive parallel computing.

Here I’ve done a simple transmission line matrix model to simulate wave propagation. You could think of it as applying Huygens wavefront principle to a discrete node system, which turns out to work perfectly. The algorithm is very close to what you get if you discretisize a scalar wave equation.