Published: September 10, 2024

Combining PV Arrays

This article aims to review the process of simulating solar PV output and in particular the issue of misaligned arrays. For example when we have many multiples of PV arrays which are configured in different directions and with different tilt angles, how can we simplify in order to reduce the amount of simulation required, while keeping good sufficiently accurate output?

Article Contents

What is this all about?
Why combine arrays?
How to approach PV array combination
Tolerance and rigour
Article Summary

What is this all about?

One of the challenges in developing a software tool like Solar Proof, is ensuring accurate and efficient calculations are performed. In particular, the solar PV output calculations.

Solar Proof uses the NREL api in order to generate a simulated solar PV output scenario. When we have multiple arrays facing different directions, we need to perform multiple calculations. This is no problem when we have less than 5 combinations as it only adds marginally to the processing (still 5x compared to 1!). But when we start looking at more complex array configurations, or even when there are unintentional misalignments of panels, we really would prefer to group arrays when possible to perform less calculations!

So, let's see how this is done!

Why Combine Arrays?

There are a number of considerations on combining PV arrays. The big ones that come to mind being:

• Fix unintentional misalignments - Sometimes during design, the user might place one line of panels at 23.4 degrees and the next line at 23.2 degrees. Clearly the performance difference here is negligible and the user has intended to include just one array.
• Allow Complex arrangements - Larger PV systems can have a variety of orientations and tilts. I just recently had a client with over 100 different orientation/tilt combinations using Solar Proof on 1 project!
• Performance improvement - With simulation, we will never get the perfect number. What we want to do is offer a very close-to-real-life number as quickly as possible. Every query in programming will take time and resources to complete so every improvement that can be made, should be made as long as the output isn't compromised.

How to approach PV array combination

The easy scenario: Slight misalignements

These are pretty easy to handle. If you have a series of arrays (capacity, orientation and tilt) then you can just loop through and see if any of these have:

1. The same tilt
2. Orientation within a given tolerance

Simple Example

let tolerance = 1.5;
let pv_array = [
  {capacity: 3, orientation: 3, tilt: 22}, 
  {capacity: 3, orientation: 3.5, tilt: 22}
];

If the conditions are met, we just add the capacities together and take an average of the orientations!

A little more complex: Multiple slight misalignements

When you have 3 or more arrays with slight misalignements

Medium Example

let tolerance = 1.5;
let pv_array = [
  {capacity: 3, orientation: 0.15, tilt: 22}, 
  {capacity: 4, orientation: 1.5, tilt: 22},
  {capacity: 15.2, orientation: 359.67, tilt: 22}
];

Here we need to consider some other things... First when the orientation wraps-around the 360 mark, and secondly the combination of 3 arrays instead of just 2... This requires some extra feedback which can re-assess already combined portions.

A complex example: Multiple misalignements, many arrays

When you have many arrays with misalignements and tilt differences

Complex Example

let tolerance = 1.5;
let pv_array = [
  {capacity: 3, orientation: 0.15, tilt: 22}, 
  {capacity: 4, orientation: 1.5, tilt: 22},
  {capacity: 15.2, orientation: 359.67, tilt: 22},
  {capacity: 14.3, orientation: 0.45, tilt: 22}, 
  {capacity: 4, orientation: 261.3, tilt: 22},
  {capacity: 15.2, orientation: 259.67, tilt: 22},
  {capacity: 56.33, orientation: 33, tilt: 12}, 
  {capacity: 8.9, orientation: 31.7, tilt: 15},
  {capacity: 15.2, orientation: 76.4, tilt: 21},
  {capacity: 15.2, orientation: 17.3, tilt: 22}
];

As you can see, with many different combinations, this task becomes more elaborate. But thankfully with some clever feedback, we can get the job done. Another consideration is that with a growing group, it becomes apparent that the priority shifts a little bit. So Solar Proof will auto-adjust the tolerance to favour performance when there are many array groups. This ensures that we reach the targets of accurate production estimate and fast performance!

Tolerance and rigour

Naturally as with anything, there are trade-offs to be made. An "acceptable" tolerance may be determined first of all from the standpoint that no simulation will be 100% accurate. In Solar Proof, we have come up with a 1.5 degree tolerance for the basis of combinations of arrays with less than 5 array parts, 3.5 degrees for 5 - 7 parts, 5.5 degrees for 8 - 10 and 8.5 degrees for more than 10 array parts.

Summary

It's important to have a system for combining arrays with a tool like Solar Proof. It should be done quickly, and with adequate consideration. The combination methods adopted by Solar Proof have been chosen to prioritise both performance and production estimation.

While Solar Proof best practise involves using group joining and panel extension to ensure exact matches of orientation are achieved, when the user does not employ these methods, we have got your back!