Skip to content

Programming Very Large Arrays (VLAs)

Share this Post:

The Karl G. Jansky Very Large Array (VLA) is a radio astronomy observatory located in western New Mexico. It consists of 27 large dish type antennas. Astronomers reconfigure the array every few months into new alignments to better explore the universe. This requires intense computer programming to coordinate the movement and alignment of the large receivers. I am sure that programming for this very large array presents a level of complexity to its team of programmers. However, when I find myself programming a very large array of lighting fixtures, I think that their scope must pale in comparison to my task at hand. Programming very large arrays is quite a task for any automated lighting programmer.

Lighting VLA’s in Action

Today’s lighting designers are always looking to make the most impressive use of technology to provide the proper lighting needs for a production. With the plethora of fixture types and abilities, they often place fixtures in arrays for greater impact. I have worked on productions that had massive walls of LED PARs, strobes, moving lights and more. In some cases there were many small arrays spaced out across the stage. For others, there was a single large surface. In any case, there are always many options to choose from to program creative looks on the array. It is important to understand the different methods of control, and to select the one that best fits the production’s needs and budget.

Direct Control of a VLA

When the production only allows a typical lighting console for use with a large array of lighting fixtures, the only choice is to hand-program the lighting as you would any other fixtures in your desk. Usually this means you need to first think about your fixture numbering. Some fixtures in an array will be a single fixture number, while others might have multiple cells that require multiple fixture numbers. Recently, I programmed an array of six-celled LED fixtures. This meant that my desk used seven fixture numbers for each physical fixture on stage (one master and six cells per unit). With 30 of these fixtures in the array, I had to keep up with more than 200 discrete fixture numbers just for the array!

Exactly how you choose to number the fixtures is actually only important to you, but I strongly recommend that you draw it out on paper (or a computer screen). This will provide you with a quick, easy map of the fixture numbers that will assist in making fixture selections. The next step in preparing to program the array is to create fixture groups. Most automated lighting consoles store the “order of fixture selection” within a group. This means you could have the same group of fixtures (all of the array) in multiple groups, but they are stored in different orders (vertically down each column, horizontally across each row, random, etc.). You might also make geometric patterns and store these as unique groups.

Once you have built your basic groups, then you can begin programming. Depending on your desk, you may want to program chases (individual steps of looks that are played repeatedly) or use an effects engine. With the effects engine and a well-planned order of fixture selection, you should be able to produce many interesting looks on the array. By further editing the effects using offsets, fanning, aligning and more, you will stumble onto lots of creative and interesting array looks. It is also helpful to remember that you do not always have to use all the fixtures in the array; sometimes less is more.

Getting Help from the Console

Hand-programming a very large array is very time-consuming and tasking. Luckily, some lighting consoles have built-in systems to help you program arrays or a matrix of fixtures. With these systems, you must first arrange your fixtures into the specialized editor. This way the desk has a picture of the layout within your array. Then the console will provide tools that create effects or chases based on the known layout. Usually, you can quickly create several different types of common looks, such as linear bars, spinning objects, alphanumerics and more. This saves you valuable time when programming, but may take a bit of an investment in time to set up. Once created, they are stored, either as effects or as part of a cue, depending on the console system.

Pixel Mapping to the Rescue

The easiest method for creating very dynamic and interesting looks on an array is to use a pixel mapping media server or software. Some lighting consoles even have a mini-media server built in to provide pixel-mapping abilities direct from the desk. In all cases, the process is the same. You must first build your layout of fixtures into the pixel mapper. The software will need to understand where the fixtures are located in relation to each other as well as what parameters they entail. Most pixels mappers utilize a fixture library system similar to lighting consoles. The map then needs to be aligned with the video playback of the media server so that the individual fixtures fit properly into the video image. As the video image plays, each video pixel will be translated into DMX values for the parameters of the lighting fixture in that location of the map.

This lets you simply play different media files and quickly create many different looks on the array without actually having to program anything more than a file selection. For instance, to create an animated wave look scrolling across the array, you simply need to play a wave movie, and the pixel mapper will take care of the rest. If you were to try to create this by hand programming, it would be a very daunting task. Pixel mapping changes your array from being a group of lighting fixtures controlled in your desk to a low-resolution video wall.

Speaking of resolution, it is important that you understand the relationship between the resolution used on the mapping application and the abilities of your fixtures. For example, if you have a wall made of 30 LED PARs and you choose to pixel map these, you will actually only see 30 pixels of the media at a time. So if your wave-shaped image is too large or too small, then the effect on the array will only appear as random flashing lights. You will need to change the size of the pixel-mapping image accordingly so the pattern created by the media looks good at the low resolution of 30 pixels. The content you select to play will also be very important for this same reason. In some cases, you may even find it better to not use a media server at all. I recently had a small array of 16 LED PARs connected to a media server. For this particular production, I found I could create more looks faster by using typical hand programming than trying to select and adjust content on the media server.

Choose Wisely

Programming very large arrays of lighting fixtures is an enormous task for any programmer. Many productions are creating huge walls of LED products, with some tours out right now that have arrays of more than 400 three-celled fixtures! That’s more than 1,200 pixels of control, just for a single array. When preparing to program an array, you must first determine the needs of the production and then select the best tools for the job. You may find that combining technologies might provide the best option, or you may select one method of control and run with it. Either way, it is important for you to understand the possibilities and always be prepared to hand-program very large arrays of lighting fixtures.