# Source code for pvlib.bifacial.infinite_sheds

```
r"""
Functions for the infinite sheds bifacial irradiance model.
"""
import numpy as np
import pandas as pd
from pvlib.tools import cosd, sind, tand
from pvlib.bifacial import utils
from pvlib.shading import masking_angle
from pvlib.irradiance import beam_component, aoi
def _vf_ground_sky_integ(surface_tilt, surface_azimuth, gcr, height,
pitch, max_rows=10, npoints=100):
"""
Integrated and per-point view factors from the ground to the sky at points
between interior rows of the array.
Parameters
----------
surface_tilt : numeric
Surface tilt angle in degrees from horizontal, e.g., surface facing up
= 0, surface facing horizon = 90. [degree]
surface_azimuth : numeric
Surface azimuth angles in decimal degrees east of north
(e.g. North = 0, South = 180, East = 90, West = 270).
``surface_azimuth`` must be >=0 and <=360.
gcr : float
Ratio of row slant length to row spacing (pitch). [unitless]
height : float
Height of the center point of the row above the ground; must be in the
same units as ``pitch``.
pitch : float
Distance between two rows. Must be in the same units as ``height``.
max_rows : int, default 10
Maximum number of rows to consider in front and behind the current row.
npoints : int, default 100
Number of points used to discretize distance along the ground.
Returns
-------
fgnd_sky : float
Integration of view factor over the length between adjacent, interior
rows. [unitless]
fz : ndarray
Fraction of distance from the previous row to the next row. [unitless]
fz_sky : ndarray
View factors at discrete points between adjacent, interior rows.
[unitless]
"""
# TODO: vectorize over surface_tilt
# Abuse utils._vf_ground_sky_2d by supplying surface_tilt in place
# of a signed rotation. This is OK because
# 1) z span the full distance between 2 rows, and
# 2) max_rows is set to be large upstream, and
# 3) _vf_ground_sky_2d considers [-max_rows, +max_rows]
# The VFs to the sky will thus be symmetric around z=0.5
z = np.linspace(0, 1, npoints)
rotation = np.atleast_1d(surface_tilt)
fz_sky = np.zeros((len(rotation), npoints))
for k, r in enumerate(rotation):
vf, _ = utils._vf_ground_sky_2d(z, r, gcr, pitch, height, max_rows)
fz_sky[k, :] = vf
# calculate the integrated view factor for all of the ground between rows
return np.trapz(fz_sky, z, axis=1)
def _poa_ground_shadows(poa_ground, f_gnd_beam, df, vf_gnd_sky):
"""
Reduce ground-reflected irradiance to the tilted plane (poa_ground) to
account for shadows on the ground.
Parameters
----------
poa_ground : numeric
Ground reflected irradiance on the tilted surface, assuming full GHI
illumination on all of the ground. [W/m^2]
f_gnd_beam : numeric
Fraction of the distance between rows that is illuminated (unshaded).
[unitless]
df : numeric
Diffuse fraction, the ratio of DHI to GHI. [unitless]
vf_gnd_sky : numeric
View factor from the ground to the sky, integrated along the distance
between rows. [unitless]
Returns
-------
poa_gnd_sky : numeric
Adjusted ground-reflected irradiance accounting for shadows on the
ground. [W/m^2]
"""
return poa_ground * (f_gnd_beam*(1 - df) + df*vf_gnd_sky)
def _vf_row_sky_integ(f_x, surface_tilt, gcr, npoints=100):
"""
Integrated view factors from the shaded and unshaded parts of
the row slant height to the sky.
Parameters
----------
f_x : numeric
Fraction of row slant height from the bottom that is shaded. [unitless]
surface_tilt : numeric
Surface tilt angle in degrees from horizontal, e.g., surface facing up
= 0, surface facing horizon = 90. [degree]
gcr : float
Ratio of row slant length to row spacing (pitch). [unitless]
npoints : int, default 100
Number of points for integration. [unitless]
Returns
-------
vf_shade_sky_integ : numeric
Integrated view factor from the shaded part of the row to the sky.
[unitless]
vf_noshade_sky_integ : numeric
Integrated view factor from the unshaded part of the row to the sky.
[unitless]
Notes
-----
The view factor to the sky at a point x along the row slant height is
given by
.. math ::
\\large{f_{sky} = \frac{1}{2} \\left(\\cos\\left(\\psi_t\\right) +
\\cos \\left(\\beta\\right) \\right)
where :math:`\\psi_t` is the angle from horizontal of the line from point
x to the top of the facing row, and :math:`\\beta` is the surface tilt.
View factors are integrated separately over shaded and unshaded portions
of the row slant height.
"""
# handle Series inputs
surface_tilt = np.array(surface_tilt)
cst = cosd(surface_tilt)
# shaded portion
x = np.linspace(0, f_x, num=npoints)
psi_t_shaded = masking_angle(surface_tilt, gcr, x)
y = 0.5 * (cosd(psi_t_shaded) + cst)
# integrate view factors from each point in the discretization. This is an
# improvement over the algorithm described in [2]
vf_shade_sky_integ = np.trapz(y, x, axis=0)
# unshaded portion
x = np.linspace(f_x, 1., num=npoints)
psi_t_unshaded = masking_angle(surface_tilt, gcr, x)
y = 0.5 * (cosd(psi_t_unshaded) + cst)
vf_noshade_sky_integ = np.trapz(y, x, axis=0)
return vf_shade_sky_integ, vf_noshade_sky_integ
def _poa_sky_diffuse_pv(f_x, dhi, vf_shade_sky_integ, vf_noshade_sky_integ):
"""
Sky diffuse POA from integrated view factors combined for both shaded and
unshaded parts of the surface.
Parameters
----------
f_x : numeric
Fraction of row slant height from the bottom that is shaded. [unitless]
dhi : numeric
Diffuse horizontal irradiance (DHI). [W/m^2]
vf_shade_sky_integ : numeric
Integrated view factor from the shaded part of the row to the sky.
[unitless]
vf_noshade_sky_integ : numeric
Integrated view factor from the unshaded part of the row to the sky.
[unitless]
Returns
-------
poa_sky_diffuse_pv : numeric
Total sky diffuse irradiance incident on the PV surface. [W/m^2]
"""
return dhi * (f_x * vf_shade_sky_integ + (1 - f_x) * vf_noshade_sky_integ)
def _ground_angle(x, surface_tilt, gcr):
"""
Angle from horizontal of the line from a point x on the row slant length
to the bottom of the facing row.
The angles are clockwise from horizontal, rather than the usual
counterclockwise direction.
Parameters
----------
x : numeric
fraction of row slant length from bottom, ``x = 0`` is at the row
bottom, ``x = 1`` is at the top of the row.
surface_tilt : numeric
Surface tilt angle in degrees from horizontal, e.g., surface facing up
= 0, surface facing horizon = 90. [degree]
gcr : float
ground coverage ratio, ratio of row slant length to row spacing.
[unitless]
Returns
-------
psi : numeric
Angle [degree].
"""
# : \\ \
# : \\ \
# : \\ \
# : \\ \ facing row
# : \\.___________\
# : \ ^*-. psi \
# : \ x *-. \
# : \ v *-.\
# : \<-----P---->\
x1 = gcr * x * sind(surface_tilt)
x2 = gcr * x * cosd(surface_tilt) + 1
psi = np.arctan2(x1, x2) # do this first because it handles 0 / 0
return np.rad2deg(psi)
def _vf_row_ground(x, surface_tilt, gcr):
"""
View factor from a point x on the row to the ground.
Parameters
----------
x : numeric
Fraction of row slant height from the bottom. [unitless]
surface_tilt : numeric
Surface tilt angle in degrees from horizontal, e.g., surface facing up
= 0, surface facing horizon = 90. [degree]
gcr : float
Ground coverage ratio, ratio of row slant length to row spacing.
[unitless]
Returns
-------
vf : numeric
View factor from the point at x to the ground. [unitless]
"""
cst = cosd(surface_tilt)
# angle from horizontal at the point x on the row slant height to the
# bottom of the facing row
psi_t_shaded = _ground_angle(x, surface_tilt, gcr)
# view factor from the point on the row to the ground
return 0.5 * (cosd(psi_t_shaded) - cst)
def _vf_row_ground_integ(f_x, surface_tilt, gcr, npoints=100):
"""
View factors to the ground from shaded and unshaded parts of a row.
Parameters
----------
f_x : numeric
Fraction of row slant height from the bottom that is shaded. [unitless]
surface_tilt : numeric
Surface tilt angle in degrees from horizontal, e.g., surface facing up
= 0, surface facing horizon = 90. [degree]
gcr : float
Ground coverage ratio, ratio of row slant length to row spacing.
[unitless]
npoints : int, default 100
Number of points for integration. [unitless]
Returns
-------
vf_shade_ground_integ : numeric
View factor from the shaded portion of the row to the ground.
[unitless]
vf_noshade_ground_integ : numeric
View factor from the unshaded portion of the row to the ground.
[unitless]
Notes
-----
The view factor to the ground at a point x along the row slant height is
given by
.. math ::
\\large{f_{gr} = \frac{1}{2} \\left(\\cos\\left(\\psi_t\\right) -
\\cos \\left(\\beta\\right) \\right)
where :math:`\\psi_t` is the angle from horizontal of the line from point
x to the bottom of the facing row, and :math:`\\beta` is the surface tilt.
Each view factor is integrated over the relevant portion of the row
slant height.
"""
# handle Series inputs
surface_tilt = np.array(surface_tilt)
# shaded portion of row slant height
x = np.linspace(0, f_x, num=npoints)
# view factor from the point on the row to the ground
y = _vf_row_ground(x, surface_tilt, gcr)
# integrate view factors along the shaded portion of the row slant height.
# This is an improvement over the algorithm described in [2]
vf_shade_ground_integ = np.trapz(y, x, axis=0)
# unshaded portion of row slant height
x = np.linspace(f_x, 1., num=npoints)
# view factor from the point on the row to the ground
y = _vf_row_ground(x, surface_tilt, gcr)
# integrate view factors along the unshaded portion.
# This is an improvement over the algorithm described in [2]
vf_noshade_ground_integ = np.trapz(y, x, axis=0)
return vf_shade_ground_integ, vf_noshade_ground_integ
def _poa_ground_pv(f_x, poa_ground, f_gnd_pv_shade, f_gnd_pv_noshade):
"""
Reduce ground-reflected irradiance to account for limited view of the
ground from the row surface.
Parameters
----------
f_x : numeric
Fraction of row slant height from the bottom that is shaded. [unitless]
poa_ground : numeric
Ground-reflected irradiance that would reach the row surface if the
full ground was visible. poa_gnd_sky accounts for limited view of the
sky from the ground. [W/m^2]
f_gnd_pv_shade : numeric
fraction of ground visible from shaded part of PV surface. [unitless]
f_gnd_pv_noshade : numeric
fraction of ground visible from unshaded part of PV surface. [unitless]
Returns
-------
numeric
Ground diffuse irradiance on the row plane. [W/m^2]
"""
return poa_ground * (f_x * f_gnd_pv_shade + (1 - f_x) * f_gnd_pv_noshade)
def _shaded_fraction(solar_zenith, solar_azimuth, surface_tilt,
surface_azimuth, gcr):
"""
Calculate fraction (from the bottom) of row slant height that is shaded
from direct irradiance by the row in front toward the sun.
See [1], Eq. 14 and also [2], Eq. 32.
.. math::
F_x = \\max \\left( 0, \\min \\left(\\frac{\\text{GCR} \\cos \\theta
+ \\left( \\text{GCR} \\sin \\theta - \\tan \\beta_{c} \\right)
\\tan Z - 1}
{\\text{GCR} \\left( \\cos \\theta + \\sin \\theta \\tan Z \\right)},
1 \\right) \\right)
Parameters
----------
solar_zenith : numeric
Apparent (refraction-corrected) solar zenith. [degrees]
solar_azimuth : numeric
Solar azimuth. [degrees]
surface_tilt : numeric
Row tilt from horizontal, e.g. surface facing up = 0, surface facing
horizon = 90. [degrees]
surface_azimuth : numeric
Azimuth angle of the row surface. North=0, East=90, South=180,
West=270. [degrees]
gcr : numeric
Ground coverage ratio, which is the ratio of row slant length to row
spacing (pitch). [unitless]
Returns
-------
f_x : numeric
Fraction of row slant height from the bottom that is shaded from
direct irradiance.
References
----------
.. [1] Mikofski, M., Darawali, R., Hamer, M., Neubert, A., and Newmiller,
J. "Bifacial Performance Modeling in Large Arrays". 2019 IEEE 46th
Photovoltaic Specialists Conference (PVSC), 2019, pp. 1282-1287.
:doi:`10.1109/PVSC40753.2019.8980572`.
.. [2] Kevin Anderson and Mark Mikofski, "Slope-Aware Backtracking for
Single-Axis Trackers", Technical Report NREL/TP-5K00-76626, July 2020.
https://www.nrel.gov/docs/fy20osti/76626.pdf
"""
tan_phi = utils._solar_projection_tangent(
solar_zenith, solar_azimuth, surface_azimuth)
# length of shadow behind a row as a fraction of pitch
x = gcr * (sind(surface_tilt) * tan_phi + cosd(surface_tilt))
f_x = 1 - 1. / x
# set f_x to be 1 when sun is behind the array
ao = aoi(surface_tilt, surface_azimuth, solar_zenith, solar_azimuth)
f_x = np.where(ao < 90, f_x, 1.)
# when x < 1, the shadow is not long enough to fall on the row surface
f_x = np.where(x > 1., f_x, 0.)
return f_x
[docs]def get_irradiance_poa(surface_tilt, surface_azimuth, solar_zenith,
solar_azimuth, gcr, height, pitch, ghi, dhi, dni,
albedo, iam=1.0, npoints=100):
r"""
Calculate plane-of-array (POA) irradiance on one side of a row of modules.
The infinite sheds model [1] assumes the PV system comprises parallel,
evenly spaced rows on a level, horizontal surface. Rows can be on fixed
racking or single axis trackers. The model calculates irradiance at a
location far from the ends of any rows, in effect, assuming that the
rows (sheds) are infinitely long.
POA irradiance components include direct, diffuse and global (total).
Irradiance values are reduced to account for reflection of direct light,
but are not adjusted for solar spectrum or reduced by a module's
bifaciality factor.
Parameters
----------
surface_tilt : numeric
Tilt of the surface from horizontal. Must be between 0 and 180. For
example, for a fixed tilt module mounted at 30 degrees from
horizontal, use ``surface_tilt=30`` to get front-side irradiance and
``surface_tilt=150`` to get rear-side irradiance. [degree]
surface_azimuth : numeric
Surface azimuth in decimal degrees east of north
(e.g. North = 0, South = 180, East = 90, West = 270). [degree]
solar_zenith : numeric
Refraction-corrected solar zenith. [degree]
solar_azimuth : numeric
Solar azimuth. [degree]
gcr : float
Ground coverage ratio, ratio of row slant length to row spacing.
[unitless]
height : float
Height of the center point of the row above the ground; must be in the
same units as ``pitch``.
pitch : float
Distance between two rows; must be in the same units as ``height``.
ghi : numeric
Global horizontal irradiance. [W/m2]
dhi : numeric
Diffuse horizontal irradiance. [W/m2]
dni : numeric
Direct normal irradiance. [W/m2]
albedo : numeric
Surface albedo. [unitless]
iam : numeric, default 1.0
Incidence angle modifier, the fraction of direct irradiance incident
on the surface that is not reflected away. [unitless]
npoints : int, default 100
Number of points used to discretize distance along the ground.
Returns
-------
output : dict or DataFrame
Output is a DataFrame when input ghi is a Series. See Notes for
descriptions of content.
Notes
-----
Input parameters ``height`` and ``pitch`` must have the same unit.
``output`` always includes:
- ``poa_global`` : total POA irradiance. [W/m^2]
- ``poa_diffuse`` : total diffuse POA irradiance from all sources. [W/m^2]
- ``poa_direct`` : total direct POA irradiance. [W/m^2]
- ``poa_sky_diffuse`` : total sky diffuse irradiance on the plane of array.
[W/m^2]
- ``poa_ground_diffuse`` : total ground-reflected diffuse irradiance on the
plane of array. [W/m^2]
References
----------
.. [1] Mikofski, M., Darawali, R., Hamer, M., Neubert, A., and Newmiller,
J. "Bifacial Performance Modeling in Large Arrays". 2019 IEEE 46th
Photovoltaic Specialists Conference (PVSC), 2019, pp. 1282-1287.
:doi:`10.1109/PVSC40753.2019.8980572`.
See also
--------
get_irradiance
"""
# Calculate some geometric quantities
# rows to consider in front and behind current row
# ensures that view factors to the sky are computed to within 5 degrees
# of the horizon
max_rows = np.ceil(height / (pitch * tand(5)))
# fraction of ground between rows that is illuminated accounting for
# shade from panels. [1], Eq. 4
f_gnd_beam = utils._unshaded_ground_fraction(
surface_tilt, surface_azimuth, solar_zenith, solar_azimuth, gcr)
# integrated view factor from the ground to the sky, integrated between
# adjacent rows interior to the array
# method differs from [1], Eq. 7 and Eq. 8; height is defined at row
# center rather than at row lower edge as in [1].
vf_gnd_sky = _vf_ground_sky_integ(
surface_tilt, surface_azimuth, gcr, height, pitch, max_rows, npoints)
# fraction of row slant height that is shaded from direct irradiance
f_x = _shaded_fraction(solar_zenith, solar_azimuth, surface_tilt,
surface_azimuth, gcr)
# Integrated view factors to the sky from the shaded and unshaded parts of
# the row slant height
# Differs from [1] Eq. 15 and Eq. 16. Here, we integrate over each
# interval (shaded or unshaded) rather than averaging values at each
# interval's end points.
vf_shade_sky, vf_noshade_sky = _vf_row_sky_integ(
f_x, surface_tilt, gcr, npoints)
# view factors from the ground to shaded and unshaded portions of the row
# slant height
# Differs from [1] Eq. 17 and Eq. 18. Here, we integrate over each
# interval (shaded or unshaded) rather than averaging values at each
# interval's end points.
f_gnd_pv_shade, f_gnd_pv_noshade = _vf_row_ground_integ(
f_x, surface_tilt, gcr, npoints)
# Total sky diffuse received by both shaded and unshaded portions
poa_sky_pv = _poa_sky_diffuse_pv(
f_x, dhi, vf_shade_sky, vf_noshade_sky)
# irradiance reflected from the ground before accounting for shadows
# and restricted views
# this is a deviation from [1], because the row to ground view factor
# is accounted for in a different manner
ground_diffuse = ghi * albedo
# diffuse fraction
diffuse_fraction = np.clip(dhi / ghi, 0., 1.)
# make diffuse fraction 0 when ghi is small
diffuse_fraction = np.where(ghi < 0.0001, 0., diffuse_fraction)
# Reduce ground-reflected irradiance because other rows in the array
# block irradiance from reaching the ground.
# [2], Eq. 9
ground_diffuse = _poa_ground_shadows(
ground_diffuse, f_gnd_beam, diffuse_fraction, vf_gnd_sky)
# Ground-reflected irradiance on the row surface accounting for
# the view to the ground. This deviates from [1], Eq. 10, 11 and
# subsequent. Here, the row to ground view factor is computed. In [1],
# the usual ground-reflected irradiance includes the single row to ground
# view factor (1 - cos(tilt))/2, and Eq. 10, 11 and later multiply
# this quantity by a ratio of view factors.
poa_gnd_pv = _poa_ground_pv(
f_x, ground_diffuse, f_gnd_pv_shade, f_gnd_pv_noshade)
# add sky and ground-reflected irradiance on the row by irradiance
# component
poa_diffuse = poa_gnd_pv + poa_sky_pv
# beam on plane, make an array for consistency with poa_diffuse
poa_beam = np.atleast_1d(beam_component(
surface_tilt, surface_azimuth, solar_zenith, solar_azimuth, dni))
poa_direct = poa_beam * (1 - f_x) * iam # direct only on the unshaded part
poa_global = poa_direct + poa_diffuse
output = {
'poa_global': poa_global, 'poa_direct': poa_direct,
'poa_diffuse': poa_diffuse, 'poa_ground_diffuse': poa_gnd_pv,
'poa_sky_diffuse': poa_sky_pv}
if isinstance(poa_global, pd.Series):
output = pd.DataFrame(output)
return output
[docs]def get_irradiance(surface_tilt, surface_azimuth, solar_zenith, solar_azimuth,
gcr, height, pitch, ghi, dhi, dni,
albedo, iam_front=1.0, iam_back=1.0,
bifaciality=0.8, shade_factor=-0.02,
transmission_factor=0, npoints=100):
"""
Get front and rear irradiance using the infinite sheds model.
The infinite sheds model [1] assumes the PV system comprises parallel,
evenly spaced rows on a level, horizontal surface. Rows can be on fixed
racking or single axis trackers. The model calculates irradiance at a
location far from the ends of any rows, in effect, assuming that the
rows (sheds) are infinitely long.
The model accounts for the following effects:
- restricted view of the sky from module surfaces due to the nearby rows.
- restricted view of the ground from module surfaces due to nearby rows.
- restricted view of the sky from the ground due to rows.
- shading of module surfaces by nearby rows.
- shading of rear cells of a module by mounting structure and by
module features.
The model implicitly assumes that diffuse irradiance from the sky is
isotropic, and that module surfaces do not allow irradiance to transmit
through the module to the ground through gaps between cells.
Parameters
----------
surface_tilt : numeric
Tilt from horizontal of the front-side surface. [degree]
surface_azimuth : numeric
Surface azimuth in decimal degrees east of north
(e.g. North = 0, South = 180, East = 90, West = 270). [degree]
solar_zenith : numeric
Refraction-corrected solar zenith. [degree]
solar_azimuth : numeric
Solar azimuth. [degree]
gcr : float
Ground coverage ratio, ratio of row slant length to row spacing.
[unitless]
height : float
Height of the center point of the row above the ground; must be in the
same units as ``pitch``.
pitch : float
Distance between two rows; must be in the same units as ``height``.
ghi : numeric
Global horizontal irradiance. [W/m2]
dhi : numeric
Diffuse horizontal irradiance. [W/m2]
dni : numeric
Direct normal irradiance. [W/m2]
albedo : numeric
Surface albedo. [unitless]
iam_front : numeric, default 1.0
Incidence angle modifier, the fraction of direct irradiance incident
on the front surface that is not reflected away. [unitless]
iam_back : numeric, default 1.0
Incidence angle modifier, the fraction of direct irradiance incident
on the back surface that is not reflected away. [unitless]
bifaciality : numeric, default 0.8
Ratio of the efficiency of the module's rear surface to the efficiency
of the front surface. [unitless]
shade_factor : numeric, default -0.02
Fraction of back surface irradiance that is blocked by array mounting
structures. Negative value is a reduction in back irradiance.
[unitless]
transmission_factor : numeric, default 0.0
Fraction of irradiance on the back surface that does not reach the
module's cells due to module features such as busbars, junction box,
etc. A negative value is a reduction in back irradiance. [unitless]
npoints : int, default 100
Number of points used to discretize distance along the ground.
Returns
-------
output : dict or DataFrame
Output is a DataFrame when input ghi is a Series. See Notes for
descriptions of content.
Notes
-----
``output`` includes:
- ``poa_global`` : total irradiance reaching the module cells from both
front and back surfaces. [W/m^2]
- ``poa_front`` : total irradiance reaching the module cells from the front
surface. [W/m^2]
- ``poa_back`` : total irradiance reaching the module cells from the back
surface. [W/m^2]
- ``poa_front_direct`` : direct irradiance reaching the module cells from
the front surface. [W/m^2]
- ``poa_front_diffuse`` : total diffuse irradiance reaching the module
cells from the front surface. [W/m^2]
- ``poa_front_sky_diffuse`` : sky diffuse irradiance reaching the module
cells from the front surface. [W/m^2]
- ``poa_front_ground_diffuse`` : ground-reflected diffuse irradiance
reaching the module cells from the front surface. [W/m^2]
- ``poa_back_direct`` : direct irradiance reaching the module cells from
the back surface. [W/m^2]
- ``poa_back_diffuse`` : total diffuse irradiance reaching the module
cells from the back surface. [W/m^2]
- ``poa_back_sky_diffuse`` : sky diffuse irradiance reaching the module
cells from the back surface. [W/m^2]
- ``poa_back_ground_diffuse`` : ground-reflected diffuse irradiance
reaching the module cells from the back surface. [W/m^2]
References
----------
.. [1] Mikofski, M., Darawali, R., Hamer, M., Neubert, A., and Newmiller,
J. "Bifacial Performance Modeling in Large Arrays". 2019 IEEE 46th
Photovoltaic Specialists Conference (PVSC), 2019, pp. 1282-1287.
:doi:`10.1109/PVSC40753.2019.8980572`.
See also
--------
get_irradiance_poa
"""
# backside is rotated and flipped relative to front
backside_tilt, backside_sysaz = _backside(surface_tilt, surface_azimuth)
# front side POA irradiance
irrad_front = get_irradiance_poa(
surface_tilt=surface_tilt, surface_azimuth=surface_azimuth,
solar_zenith=solar_zenith, solar_azimuth=solar_azimuth,
gcr=gcr, height=height, pitch=pitch, ghi=ghi, dhi=dhi, dni=dni,
albedo=albedo, iam=iam_front, npoints=npoints)
# back side POA irradiance
irrad_back = get_irradiance_poa(
surface_tilt=backside_tilt, surface_azimuth=backside_sysaz,
solar_zenith=solar_zenith, solar_azimuth=solar_azimuth,
gcr=gcr, height=height, pitch=pitch, ghi=ghi, dhi=dhi, dni=dni,
albedo=albedo, iam=iam_back, npoints=npoints)
colmap_front = {
'poa_global': 'poa_front',
'poa_direct': 'poa_front_direct',
'poa_diffuse': 'poa_front_diffuse',
'poa_sky_diffuse': 'poa_front_sky_diffuse',
'poa_ground_diffuse': 'poa_front_ground_diffuse',
}
colmap_back = {
'poa_global': 'poa_back',
'poa_direct': 'poa_back_direct',
'poa_diffuse': 'poa_back_diffuse',
'poa_sky_diffuse': 'poa_back_sky_diffuse',
'poa_ground_diffuse': 'poa_back_ground_diffuse',
}
if isinstance(ghi, pd.Series):
irrad_front = irrad_front.rename(columns=colmap_front)
irrad_back = irrad_back.rename(columns=colmap_back)
output = pd.concat([irrad_front, irrad_back], axis=1)
else:
for old_key, new_key in colmap_front.items():
irrad_front[new_key] = irrad_front.pop(old_key)
for old_key, new_key in colmap_back.items():
irrad_back[new_key] = irrad_back.pop(old_key)
irrad_front.update(irrad_back)
output = irrad_front
effects = (1 + shade_factor) * (1 + transmission_factor)
output['poa_global'] = output['poa_front'] + \
output['poa_back'] * bifaciality * effects
return output
def _backside(tilt, surface_azimuth):
backside_tilt = 180. - tilt
backside_sysaz = (180. + surface_azimuth) % 360.
return backside_tilt, backside_sysaz
```