'sapm': {

'A0', 'A1', 'A2', 'A3', 'A4', 'B0', 'B1', 'B2', 'B3',

'B4', 'B5', 'C0', 'C1', 'C2', 'C3', 'C4', 'C5', 'C6',

'C7', 'Isco', 'Impo', 'Voco', 'Vmpo', 'Aisc', 'Aimp', 'Bvoco',

'Mbvoc', 'Bvmpo', 'Mbvmp', 'N', 'Cells_in_Series',

'IXO', 'IXXO', 'FD'},

'desoto': {

'alpha_sc', 'a_ref', 'I_L_ref', 'I_o_ref',

'R_sh_ref', 'R_s'},

'cec': {

'alpha_sc', 'a_ref', 'I_L_ref', 'I_o_ref',

'R_sh_ref', 'R_s', 'Adjust'},

'pvsyst': {

'gamma_ref', 'mu_gamma', 'I_L_ref', 'I_o_ref',

'R_sh_ref', 'R_sh_0', 'R_s', 'alpha_sc', 'EgRef',

'cells_in_series'},

'singlediode': {

'alpha_sc', 'a_ref', 'I_L_ref', 'I_o_ref',

'R_sh_ref', 'R_s'},

'pvwatts': {'pdc0', 'gamma_pdc'}

"""Decorator for functions that return iterables.

@functools.wraps(func)

def f(*args, **kwargs):

unwrap = kwargs.pop('unwrap', True)

x = func(*args, **kwargs)

if unwrap and len(x) == 1:

return x[0]

return x

"""

def __init__(self,

arrays=None,

surface_tilt=0, surface_azimuth=180,

albedo=None, surface_type=None,

module=None, module_type=None,

module_parameters=None,

temperature_model_parameters=None,

modules_per_string=1, strings_per_inverter=1,

inverter=None, inverter_parameters=None,

racking_model=None, losses_parameters=None, name=None):

if arrays is None:

if losses_parameters is None:

array_losses_parameters = {}

else:

array_losses_parameters = _build_kwargs(['dc_ohmic_percent'],

losses_parameters)

self.arrays = (Array(

FixedMount(surface_tilt, surface_azimuth, racking_model),

albedo,

surface_type,

module,

module_type,

module_parameters,

temperature_model_parameters,

modules_per_string,

strings_per_inverter,

array_losses_parameters,

),)

elif isinstance(arrays, Array):

self.arrays = (arrays,)

elif len(arrays) == 0:

raise ValueError("PVSystem must have at least one Array. "

"If you want to create a PVSystem instance "

"with a single Array pass `arrays=None` and pass "

"values directly to PVSystem attributes, e.g., "

"`surface_tilt=30`")

else:

self.arrays = tuple(arrays)

self.inverter = inverter

if inverter_parameters is None:

self.inverter_parameters = {}

else:

self.inverter_parameters = inverter_parameters

if losses_parameters is None:

self.losses_parameters = {}

else:

self.losses_parameters = losses_parameters

self.name = name

def __repr__(self):

repr = f'PVSystem:\n name: {self.name}\n '

for array in self.arrays:

repr += '\n '.join(array.__repr__().split('\n'))

repr += '\n '

repr += f'inverter: {self.inverter}'

return repr

def _validate_per_array(self, values, system_wide=False):

"""Check that `values` is a tuple of the same length as

if system_wide and not isinstance(values, tuple):

return (values,) * self.num_arrays

if not isinstance(values, tuple):

values = (values,)

if len(values) != len(self.arrays):

raise ValueError("Length mismatch for per-array parameter")

return values

@_unwrap_single_value

def _infer_cell_type(self):

"""

return tuple(array._infer_cell_type() for array in self.arrays)

@_unwrap_single_value

def get_aoi(self, solar_zenith, solar_azimuth):

"""Get the angle of incidence on the Array(s) in the system.

return tuple(array.get_aoi(solar_zenith, solar_azimuth)

for array in self.arrays)

@_unwrap_single_value

def get_irradiance(self, solar_zenith, solar_azimuth, dni, ghi, dhi,

dni_extra=None, airmass=None, albedo=None,

model='haydavies', **kwargs):

"""

dni = self._validate_per_array(dni, system_wide=True)

ghi = self._validate_per_array(ghi, system_wide=True)

dhi = self._validate_per_array(dhi, system_wide=True)

albedo = self._validate_per_array(albedo, system_wide=True)

return tuple(

array.get_irradiance(solar_zenith, solar_azimuth,

dni, ghi, dhi,

dni_extra=dni_extra, airmass=airmass,

albedo=albedo, model=model, **kwargs)

for array, dni, ghi, dhi, albedo in zip(

self.arrays, dni, ghi, dhi, albedo

)

)

@_unwrap_single_value

def get_iam(self, aoi, iam_model='physical'):

"""

aoi = self._validate_per_array(aoi)

return tuple(array.get_iam(aoi, iam_model)

for array, aoi in zip(self.arrays, aoi))

@_unwrap_single_value

def get_cell_temperature(self, poa_global, temp_air, wind_speed, model,

effective_irradiance=None):

"""

poa_global = self._validate_per_array(poa_global)

temp_air = self._validate_per_array(temp_air, system_wide=True)

wind_speed = self._validate_per_array(wind_speed, system_wide=True)

# Not used for all models, but Array.get_cell_temperature handles it

effective_irradiance = self._validate_per_array(effective_irradiance,

system_wide=True)

return tuple(

array.get_cell_temperature(poa_global, temp_air, wind_speed,

model, effective_irradiance)

for array, poa_global, temp_air, wind_speed, effective_irradiance

in zip(

self.arrays, poa_global, temp_air, wind_speed,

effective_irradiance

)

)

@_unwrap_single_value

def calcparams_desoto(self, effective_irradiance, temp_cell):

"""

effective_irradiance = self._validate_per_array(effective_irradiance)

temp_cell = self._validate_per_array(temp_cell)

build_kwargs = functools.partial(

_build_kwargs,

['a_ref', 'I_L_ref', 'I_o_ref', 'R_sh_ref',

'R_s', 'alpha_sc', 'EgRef', 'dEgdT',

'irrad_ref', 'temp_ref']

)

return tuple(

calcparams_desoto(

effective_irradiance, temp_cell,

**build_kwargs(array.module_parameters)

)

for array, effective_irradiance, temp_cell

in zip(self.arrays, effective_irradiance, temp_cell)

)

@_unwrap_single_value

def calcparams_cec(self, effective_irradiance, temp_cell):

"""

effective_irradiance = self._validate_per_array(effective_irradiance)

temp_cell = self._validate_per_array(temp_cell)

build_kwargs = functools.partial(

_build_kwargs,

['a_ref', 'I_L_ref', 'I_o_ref', 'R_sh_ref',

'R_s', 'alpha_sc', 'Adjust', 'EgRef', 'dEgdT',

'irrad_ref', 'temp_ref']

)

return tuple(

calcparams_cec(

effective_irradiance, temp_cell,

**build_kwargs(array.module_parameters)

)

for array, effective_irradiance, temp_cell

in zip(self.arrays, effective_irradiance, temp_cell)

)

@_unwrap_single_value

def calcparams_pvsyst(self, effective_irradiance, temp_cell):

"""

effective_irradiance = self._validate_per_array(effective_irradiance)

temp_cell = self._validate_per_array(temp_cell)

build_kwargs = functools.partial(

_build_kwargs,

['gamma_ref', 'mu_gamma', 'I_L_ref', 'I_o_ref',

'R_sh_ref', 'R_sh_0', 'R_sh_exp',

'R_s', 'alpha_sc', 'EgRef',

'irrad_ref', 'temp_ref',

'cells_in_series']

)

return tuple(

calcparams_pvsyst(

effective_irradiance, temp_cell,

**build_kwargs(array.module_parameters)

)

for array, effective_irradiance, temp_cell

in zip(self.arrays, effective_irradiance, temp_cell)

)

@_unwrap_single_value

def sapm(self, effective_irradiance, temp_cell):

"""

effective_irradiance = self._validate_per_array(effective_irradiance)

temp_cell = self._validate_per_array(temp_cell)

return tuple(

sapm(effective_irradiance, temp_cell, array.module_parameters)

for array, effective_irradiance, temp_cell

in zip(self.arrays, effective_irradiance, temp_cell)

)

@_unwrap_single_value

def sapm_spectral_loss(self, airmass_absolute):

"""

return tuple(

spectrum.spectral_factor_sapm(airmass_absolute,

array.module_parameters)

for array in self.arrays

)

@_unwrap_single_value

def sapm_effective_irradiance(self, poa_direct, poa_diffuse,

airmass_absolute, aoi,

reference_irradiance=1000):

"""

poa_direct = self._validate_per_array(poa_direct)

poa_diffuse = self._validate_per_array(poa_diffuse)

aoi = self._validate_per_array(aoi)

return tuple(

sapm_effective_irradiance(

poa_direct, poa_diffuse, airmass_absolute, aoi,

array.module_parameters)

for array, poa_direct, poa_diffuse, aoi

in zip(self.arrays, poa_direct, poa_diffuse, aoi)

)

@_unwrap_single_value

def first_solar_spectral_loss(self, pw, airmass_absolute):

"""

pw = self._validate_per_array(pw, system_wide=True)

def _spectral_correction(array, pw):

if 'first_solar_spectral_coefficients' in \

array.module_parameters.keys():

coefficients = \

array.module_parameters[

'first_solar_spectral_coefficients'

]

module_type = None

else:

module_type = array._infer_cell_type()

coefficients = None

return spectrum.spectral_factor_firstsolar(

pw, airmass_absolute, module_type, coefficients

)

return tuple(

itertools.starmap(_spectral_correction, zip(self.arrays, pw))

)

def singlediode(self, photocurrent, saturation_current,

resistance_series, resistance_shunt, nNsVth,

ivcurve_pnts=None):

"""Wrapper around the :py:func:`pvlib.pvsystem.singlediode` function.

return singlediode(photocurrent, saturation_current,

resistance_series, resistance_shunt, nNsVth,

ivcurve_pnts=ivcurve_pnts)

def i_from_v(self, voltage, photocurrent, saturation_current,

resistance_series, resistance_shunt, nNsVth):

"""Wrapper around the :py:func:`pvlib.pvsystem.i_from_v` function.

return i_from_v(voltage, photocurrent, saturation_current,

resistance_series, resistance_shunt, nNsVth)

def get_ac(self, model, p_dc, v_dc=None):

r"""Calculates AC power from p_dc using the inverter model indicated

model = model.lower()

multiple_arrays = self.num_arrays > 1

if model == 'sandia':

p_dc = self._validate_per_array(p_dc)

v_dc = self._validate_per_array(v_dc)

if multiple_arrays:

return inverter.sandia_multi(

v_dc, p_dc, self.inverter_parameters)

return inverter.sandia(v_dc[0], p_dc[0], self.inverter_parameters)

elif model == 'pvwatts':

kwargs = _build_kwargs(['eta_inv_nom', 'eta_inv_ref'],

self.inverter_parameters)

p_dc = self._validate_per_array(p_dc)

if multiple_arrays:

return inverter.pvwatts_multi(

p_dc, self.inverter_parameters['pdc0'], **kwargs)

return inverter.pvwatts(

p_dc[0], self.inverter_parameters['pdc0'], **kwargs)

elif model == 'adr':

if multiple_arrays:

raise ValueError(

'The adr inverter function cannot be used for an inverter',

' with multiple MPPT inputs')

# While this is only used for single-array systems, calling

# _validate_per_arry lets us pass in singleton tuples.

p_dc = self._validate_per_array(p_dc)

v_dc = self._validate_per_array(v_dc)

return inverter.adr(v_dc[0], p_dc[0], self.inverter_parameters)

else:

raise ValueError(

model + ' is not a valid AC power model.',

' model must be one of "sandia", "adr" or "pvwatts"')

@_unwrap_single_value

def scale_voltage_current_power(self, data):

"""

data = self._validate_per_array(data)

return tuple(

scale_voltage_current_power(data,

voltage=array.modules_per_string,

current=array.strings)

for array, data in zip(self.arrays, data)

)

@_unwrap_single_value

def pvwatts_dc(self, g_poa_effective, temp_cell):

"""

g_poa_effective = self._validate_per_array(g_poa_effective)

temp_cell = self._validate_per_array(temp_cell)

return tuple(

pvwatts_dc(g_poa_effective, temp_cell,

array.module_parameters['pdc0'],

array.module_parameters['gamma_pdc'],

**_build_kwargs(['temp_ref'], array.module_parameters))

for array, g_poa_effective, temp_cell

in zip(self.arrays, g_poa_effective, temp_cell)

)

def pvwatts_losses(self):

"""

kwargs = _build_kwargs(['soiling', 'shading', 'snow', 'mismatch',

'wiring', 'connections', 'lid',

'nameplate_rating', 'age', 'availability'],

self.losses_parameters)

return pvwatts_losses(**kwargs)

@_unwrap_single_value

def dc_ohms_from_percent(self):

"""

return tuple(array.dc_ohms_from_percent() for array in self.arrays)

@property

def num_arrays(self):

"""The number of Arrays in the system."""

"""

def __init__(self, mount,

albedo=None, surface_type=None,

module=None, module_type=None,

module_parameters=None,

temperature_model_parameters=None,

modules_per_string=1, strings=1,

array_losses_parameters=None,

name=None):

self.mount = mount

self.surface_type = surface_type

if albedo is None:

self.albedo = irradiance.SURFACE_ALBEDOS.get(surface_type, 0.25)

else:

self.albedo = albedo

self.module = module

if module_parameters is None:

self.module_parameters = {}

else:

self.module_parameters = module_parameters

self.module_type = module_type

self.strings = strings

self.modules_per_string = modules_per_string

if temperature_model_parameters is None:

self.temperature_model_parameters = \

self._infer_temperature_model_params()

else:

self.temperature_model_parameters = temperature_model_parameters

if array_losses_parameters is None:

self.array_losses_parameters = {}

else:

self.array_losses_parameters = array_losses_parameters

self.name = name

def __repr__(self):

attrs = ['name', 'mount', 'module',

'albedo', 'module_type',

'temperature_model_parameters',

'strings', 'modules_per_string']

return 'Array:\n ' + '\n '.join(

f'{attr}: {getattr(self, attr)}' for attr in attrs

)

def _infer_temperature_model_params(self):

# try to infer temperature model parameters from racking_model

# and module_type

param_set = f'{self.mount.racking_model}_{self.module_type}'