So far I’ve covered a range of background information on line array; the history (post #2), the very basic theory (post #4), and a preliminary understanding of what happens when we setup multiple coherent sources (posts #5 & #6). A line array is a special example of the latter scenario, which helps to make the effects somewhat more predictable.

Having reached this level of understanding, the next phase in my research involved developing a computational model for arrayed point sources. In the next few posts I’m going to introduce you to version 1 of this model, and we are going to run some tests on it to explore different elements of array behaviour.

**Model Basics**

Towards the end of post #5 (“Phase & Interference”) I introduced two equations which together can be used to describe the phase and amplitude of the superposition of a number of coherent sources at any given frequency. All we need to calculate this superposition is knowledge of the phase and amplitude of the wavefront of each individual source at the listener position. If we know the relative positions of each source and the listener, and we can assume the sources to be performing as perfect, coherent (i.e. generating identical wavefronts, in phase, at exactly the same time), evenly radiating omni-directional point sources then the only other piece of the puzzle is the level of each individual source. From here obtaining the necessary variables for our equations becomes a simple geometry exercise.

The value that we are really interested in is the amplitude of this superposition. This tells us the SPL from the array, at a specific frequency, at a specific listening position. By repeating this calculation over a range of listener positions we can build up a picture of the level across the listener plane in one, two or three dimensions (for reasons I’ll discuss at a later point, my code for version 1 of the model is restricted to a one dimensional analysis). Alternatively we could instead repeat the calculation over a range of frequencies to build a picture of the frequency response at a specific position.

Using GNU Octave (a freeware programming language that is more or less the same as MATLAB) I have created scripts to run these calculations based upon user defined input variables to describe the array and listener positions. I share these scripts below.

**Assumptions**

It is important to be clear on the assumptions that this model is making. We have a made a number of simplifications, some of which are more important than others. This version of the model remains a way off from truly representing the behaviour of a modern line array system, which is fine so long as we understand the implications of this limitation.

In actual fact, our model is difficient in many of the same ways that very early, rudimentary attempts at developing line array systems were deficient. As we go forwards this will prove a very helpful similarity as it will enable us firstly to explore the problems with such rudimentary configurations, and then to explore how modern line array systems resolve those problems by refining later versions of the model to emulate subsequent advances.

The chief assumptions made in this version of the model are:

- Every cabinet in the array is modelled as a single individual point source, the origin of which is located centrally to the front face of the cabinet.
- Cabinets are presumed to be uniformly omni-directional at all frequencies.
- Cabinets are presumed to have a perfect, uniformly flat frequency response across the entire test range.
- SPL attributable to each individual cabinet is presumed to drop in perfect accordance with the inverse square law.
- The model calculates only the level directly attributable to the array and assumes a perfect free-field environment with no reverberation.
- The model ignores attenuation due to atmospheric absorption.
- The model assumes even atmospheric conditions, with no refractive effects and a fixed speed of sound at 343m/s.

I want to suggest that two the most important limitations here are:

- We are not modelling the directivity characteristics of modern line array cabinets (which are typically very narrow in their vertical dispersion).
- We are not modelling the isophasic behaviour created by wave guides in modern line array cabinets (we’ll see in a subsequent post just how important this is).

These will form the basis for later revision of the model, but for now this initial version of the model will suffice to help us understand some basic line array principles whilst maintaining a simplicity that will make this easier to get our heads round in the first instance.

**GNU Octave**

GNU Octave is a free programming language designed primarily for numerical computations. It’s a bit like a graphical calculator on steroids

Readers with an engineering or mathematics background may be familiar with MathWorks’ MATLAB software; Octave is essentially an open-source alternative to MATLAB, available for free (and completely legally) under the GNU General Public Licence. It has been designed to be compatible with MATLAB so scripts should in theory be portable between the two.

Reader’s wishing to experiment and follow along with subsequent posts using the model will need to acquire a copy of either Octave or MATLAB. The latest version of Octave can be downloaded from the GNU website here.

**Model Scripts**

Here is a downloadble zip file containing a number of .m files (MATLAB/Octave script files). To run the model you simply need to download the files and then extract them to your Octave/MATLAB working directory. Once in this directory these scripts become callable functions.

There a number of scripts included, but the main one which you will need to call to run the model is the *arrx.m* script. You don’t need to worry about the remaining scripts, these serve as subfunctions for the *arrx.m* script and are called from within that script so you shouldn’t need to call them directly, just make sure that they are all installed in the same directory.

The code is extensively commented so readers who are interested are at liberty to work through this and see how the script computes SPL based upon the original equations I present in post #5. The code is all open-source and provided freely for your use, feel free to modify this, re-use, build upon, or take snippets from the code for your own developments if you wish, my only request is that you provide attribution anywhere you use the code or any derivative of it (either in part or in full).

In my next post I will talk through the use of these scripts in a bit more detail before we begin to investigate some preliminary results.