Sizing a 50 W Flood Light Layout With Python: Lux, Lumens and Mounting Height

Ibrahim Nauman — Tue, 27 Oct 2026 12:55:31 +0000

We sell outdoor LED lighting in Pakistan, and the question we get most from site engineers is a numbers question. How many fittings does this yard need, and how high do they go? Very often someone has already decided on a 50 W flood light because it's the familiar size, and what they actually want to know is whether six of them is enough or whether they need twelve.

This post walks through the method we use for a first estimate, written up as a small Python script you can run and adapt. It's the lumen method, which gives you an average illuminance over an area. It's a sanity check and a starting point, not a substitute for a proper photometric calculation in DIALux or similar using the manufacturer's IES file, which you should still do for anything safety-critical.

The inputs you need before writing any code
Five numbers drive the whole calculation. Get these right and the arithmetic is trivial. Get them wrong and no script will save you.

Target illuminance (E), in lux. This comes from the client's requirement or the standard they work to. For outdoor workplaces, EN 12464-2 is the usual reference. Agree the figure in writing before you start.
Area (A), in square metres. The area that actually needs lighting, not the whole plot.
Luminous flux per fitting, in lumens. Take this from the datasheet. Never estimate it from wattage, because two fittings with the same wattage can differ a lot.
Utilisation factor (UF). The fraction of the fitting's lumens that actually lands on the target area. Flood lights aimed at a yard spill a good share of their light past the edges, onto walls and into the sky.
Maintenance factor (MF). Allowance for dirt on the glass and the gradual drop in LED output over time.
UF and MF are where judgement comes in. In the script we default to 0.5 and 0.8 as placeholder assumptions. A real photometric file replaces the UF guess, and the MF should reflect how often the glass actually gets cleaned. On a site in Faisalabad or Multan that gets a couple of dust storms every summer and is cleaned once a year, be more pessimistic than you would for a sealed canopy in a clean area.

The lumen method in one line
The number of fittings is:

N = (E × A) / (Φ × UF × MF)

where Φ is the rated flux of one fitting. You need E × A lumens on the ground. Each fitting contributes Φ × UF × MF of useful, maintained lumens. Divide, then round up, because you can't install 4.5 fittings.

Run it backwards and you get the average lux a given number of fittings will deliver, which is handy for checking a layout someone else has already drawn.

A small calculator
Here's the whole thing. It uses only the standard library, so it runs anywhere Python 3.7 or later is installed.

import math
from dataclasses import dataclass

@dataclass
class Fitting:
name: str
lumens: float # rated luminous flux from the datasheet
beam_deg: float # full beam angle in degrees

def fittings_needed(target_lux, area_m2, fitting, uf=0.5, mf=0.8):
"""Lumen method: N = (E x A) / (flux x UF x MF), rounded up."""
n = (target_lux * area_m2) / (fitting.lumens * uf * mf)
return math.ceil(n)

def average_lux(n, area_m2, fitting, uf=0.5, mf=0.8):
"""Average maintained illuminance that n fittings give over the area."""
return n * fitting.lumens * uf * mf / area_m2

def footprint_m(height_m, beam_deg):
"""Beam diameter on the ground for a fitting aimed straight down."""
return 2 * height_m * math.tan(math.radians(beam_deg / 2))

if name == "main":
yard_l, yard_w = 30, 20 # metres
area = yard_l * yard_w
target = 20 # lux, the figure agreed with the client

options = [
    Fitting("50 W, 90 deg beam", lumens=5000, beam_deg=90),
    Fitting("50 W, 120 deg beam", lumens=5500, beam_deg=120),
]

print(f"Yard {yard_l} x {yard_w} m = {area} m2, target {target} lux")
for f in options:
    n = fittings_needed(target, area, f)
    lux = average_lux(n, area, f)
    print(f"\n{f.name}: {n} fittings, about {lux:.1f} lux average")
    for h in (5, 6, 8):
        print(f"  at {h} m the beam is about {footprint_m(h, f.beam_deg):.1f} m across")

Running it for a 50 W flood light on a factory yard
The example is a 30 by 20 metre loading yard behind a factory, with an assumed target of 20 lux for this walkthrough. Treat that figure as an example only, not a recommendation for your site. The two fittings are a 50 W flood light with a 90° beam rated at 5,000 lumens, and a 50 W model with a 120° beam at 5,500 lumens, which are the kind of figures you'll find on real datasheets in this class.

The script prints:

Yard 30 x 20 m = 600 m2, target 20 lux

50 W, 90 deg beam: 6 fittings, about 20.0 lux average
at 5 m the beam is about 10.0 m across
at 6 m the beam is about 12.0 m across
at 8 m the beam is about 16.0 m across

50 W, 120 deg beam: 6 fittings, about 22.0 lux average
at 5 m the beam is about 17.3 m across
at 6 m the beam is about 20.8 m across
at 8 m the beam is about 27.7 m across
Both options land on six fittings. That's where the second function earns its place.

Checking the beam footprint against mounting height
An average can hide a lot. Six fittings giving 20 lux on average might mean a bright patch under each pole and dark bands between them. The footprint function is a crude check for that: for a fitting aimed straight down, the lit circle on the ground has a diameter of 2 × h × tan(beam / 2).

A 50 W flood light with a 90° beam at 6 metres lights a circle roughly 12 metres across. Spread six of them over a 30 by 20 metre yard and the circles barely touch, so expect visible gaps. The 120° fitting at the same height covers about 21 metres, so the pools overlap and the yard looks far more even. The catch is that a wider beam also throws more light past the yard edges, so its real UF is probably lower than the 0.5 we assumed. Change the uf argument per fitting and rerun to see how sensitive your answer is.

Flood lights are rarely aimed straight down in practice, so treat the footprint as an approximation. Tilting a fitting stretches its pool into an ellipse and pushes more light toward the far side.

What the script doesn't know
A few things matter on Pakistani sites that no lumen calculation captures. Glare toward a road or a neighbour's house depends on aiming, not on the maths. Heat matters too: a 50 W flood light on a south-facing wall in a Lahore June runs hotter than one under a shade, and that affects how long it lasts. And dust is constant, which is why we'd rather be pessimistic on MF than promise a client 20 lux that turns into 14 after one andhi season.

If you're filling in the lumen and beam inputs, our flood light models with published lumen and beam figures give you real numbers from 50W upward to plug straight into the script.

Questions about a specific yard or layout can go to our engineering team at Hyundai LED, and we're happy to sanity-check your numbers.

DEV Community: Ibrahim Nauman

Sizing a 50 W Flood Light Layout With Python: Lux, Lumens and Mounting Height