Independent compute and solar block modelling

GlobalGrid2050 enumerates its engineering arithmetic on its own hardware rather than estimating it. This page states the method, the figures it has produced, and — as plainly — what it does not establish.

Why it matters commercially

A design question such as how many modules may be placed in series on this site has a finite number of answers. The usual practice is to test a handful of representative cases and reason about the rest. Enumerating the whole space instead removes the reasoning step, and with it the cases nobody thought to test.

The constraint has always been time. A complete solar string-and-block design space of a billion configurations is not something a spreadsheet finishes. On a consumer graphics card, using the open CuPy library, it now takes under six seconds. That is the whole finding: the space became small enough to read in full.

The method

• Closed forms first. The rules are written and asserted before any sweep runs, so the sweep can only confirm or break them — never discover them.
• Three independent implementations. A plain scalar reference, a vectorised processor version, and a graphics-card version. All three must agree before a single figure is quoted.
• Conditions travel with every number. A rate without the conditions it was taken under is not evidence, and is not published as though it were.
• A check that reached nothing fails. A run over zero cases raises an error rather than returning a clean result. This is enforced in the code, not by discipline.

What has been produced

All figures below were taken on one machine on 20 September 2026, on a 16 GB consumer card that was shared with other work during the runs.

Verification. 100,000 cases on a coprime stride through the space: 0 differ between the scalar reference, the processor version and the card. Worst relative difference 0.00e+00 against a 1e-9 tolerance. Seven of seven previously published library answers reproduced. Single precision was run against double precision over the entire billion and changed 0 verdicts.

A claim that failed, published as failed. A fourth kernel was expected to reach tens of millions of evaluations a second. It did not — it fell 3.0× short. The shortfall is recorded rather than quietly dropped, and its cause is understood: the gain came from batch size, which is the signature of launch overhead rather than arithmetic.

What it does not establish

• No figure describes any hardware other than the one machine named.
• Processor power draw was never recorded — no wall meter, no direct read — so no efficiency comparison between processor and card is stated, here or anywhere in this work.
• A speed ratio belongs to a particular calculation, not to a card. The three ratios above differ by a factor of eight for exactly that reason.
• The card was shared during every run. Where that limited a figure, the limit is stated rather than corrected for.

Solar block modelling

The first engineering use is the DC side of a utility solar plant: what a string may contain, how many strings a machine may carry, and what that gives across a whole site. The array is a parameter, not a preset — series count, strings per machine, module rating and site minimum temperature are all supplied by the user.

The worked reference block

Five modules in portrait per plane, east–west, 30 in series, 24 strings on one 352 kVA class machine:

19.80 kW DC per string      = 30 x 660 Wp
475.20 kW DC per machine    = 19.80 x 24
1.350 DC:AC ratio
48 mated pairs, machine side = 24 strings x 2 poles

At site scale, 1,000 machines

The string does not scale with the machine. Thirty modules in series is fixed by the 1500 V system ceiling and the temperature clause, not by the inverter rating. A larger machine therefore changes only how many strings connect to it. The 500 kW figures above are that ratio, and nothing more: the input architecture of that machine has not been published, so its string count is arithmetic rather than a specification.

The finding worth a designer's attention

Across 463,590 configurations of the east–west block, 4.35% are buildable under one reading of the cold-voltage clause and not under the other. The reference block is among them: it holds to −10 °C on the strict reading, and at −11 °C the reading of the clause alone decides it.

Both readings are therefore computed and printed everywhere in this work, and never collapsed into one answer. Thirty modules in series should not be quoted without the site minimum temperature beside it.

Not included, and not implied

Yield, energy, export, land area, cable schedules and cost are not computed by these models and no such figure appears in them. Nothing here is a design. Every published view states the limitations of what it draws, and a qualified engineer should be consulted before any commitment.

Enumeration for the Kuiper

One program sweeps the whole box of designs around every module class in the feed on a graphics card and writes only what survives: the hot-current surface, the bifacial current chain per family kept apart, and the series envelope against the equipment rating with the margin given in degrees of further cold rather than only in volts. Nine and a half billion cases, ten classes, in under three seconds, with zero partings between the two arithmetic routes.

Three things it found. Judging current at the cold point changes no verdict that rests on a limit printed in a document — because the only sourced current limit does not fire anywhere in the box; every verdict the distinction changes is decided by a number with no source, and every one of them flatters the design. Two of the four limits turn out to be one predicate written twice. And one class sits under two degrees from the equipment rating at the series count it can carry, where its four siblings sit eight to sixteen degrees away.

The code, the method and the honest limits are at compute/enumeration. Every quantity is computed twice by different routes and compared on the verdict; on a disagreement the run aborts rather than logging it. A limit with no source may be enumerated and may not be published as a finding. Which two have no source, and how much of the space each decides.

Method and code

The implementations, the verification runs and the results files are published at gpu-drivers-for-global-grid — lanes cuda-maths (the three benchmarked workloads) and engine (the arithmetic engine and the solar block models).

GlobalGrid2050 explores current technology with Claude and Codex AI, and actively studies CuPy for faster independent compute on local machines. This page is technical documentation for research purposes. Code: Apache-2.0. No warranty is given.

Return to GlobalGrid2050 · The Kuiper manual · The plant drawing · All builds