test_pvsystem.py

from collections import OrderedDict
import itertools

import numpy as np
from numpy import nan, array
import pandas as pd

import pytest
from .conftest import assert_series_equal, assert_frame_equal
from numpy.testing import assert_allclose
import unittest.mock as mock

from pvlib import inverter, pvsystem
from pvlib import iam as _iam
from pvlib import irradiance
from pvlib import spectrum
from pvlib.location import Location
from pvlib.pvsystem import FixedMount
from pvlib import temperature
from pvlib.tools import cosd
from pvlib.singlediode import VOLTAGE_BUILTIN

from tests.test_singlediode import get_pvsyst_fs_495

from .conftest import chandrupatla, chandrupatla_available


@pytest.mark.parametrize('iam_model,model_params', [
    ('ashrae', {'b': 0.05}),
    ('physical', {'K': 4, 'L': 0.002, 'n': 1.526}),
    ('martin_ruiz', {'a_r': 0.16}),
])
def test_PVSystem_get_iam(mocker, iam_model, model_params):
    m = mocker.spy(_iam, iam_model)
    system = pvsystem.PVSystem(module_parameters=model_params)
    thetas = 1
    iam = system.get_iam(thetas, iam_model=iam_model)
    m.assert_called_with(thetas, **model_params)
    assert iam < 1.


def test_PVSystem_multi_array_get_iam():
    model_params = {'b': 0.05}
    system = pvsystem.PVSystem(
        arrays=[pvsystem.Array(mount=pvsystem.FixedMount(0, 180),
                               module_parameters=model_params),
                pvsystem.Array(mount=pvsystem.FixedMount(0, 180),
                               module_parameters=model_params)]
    )
    iam = system.get_iam((1, 5), iam_model='ashrae')
    assert len(iam) == 2
    assert iam[0] != iam[1]
    with pytest.raises(ValueError,
                       match="Length mismatch for per-array parameter"):
        system.get_iam((1,), iam_model='ashrae')


def test_PVSystem_get_iam_sapm(sapm_module_params, mocker):
    system = pvsystem.PVSystem(module_parameters=sapm_module_params)
    mocker.spy(_iam, 'sapm')
    aoi = 0
    out = system.get_iam(aoi, 'sapm')
    _iam.sapm.assert_called_once_with(aoi, sapm_module_params)
    assert_allclose(out, 1.0, atol=0.01)


def test_PVSystem_get_iam_interp(mocker):
    interp_module_params = {'iam_ref': (1., 0.8), 'theta_ref': (0., 80.)}
    system = pvsystem.PVSystem(module_parameters=interp_module_params)
    spy = mocker.spy(_iam, 'interp')
    aoi = ((0., 40., 80.),)
    expected = (1., 0.9, 0.8)
    out = system.get_iam(aoi, iam_model='interp')
    assert_allclose(out, expected)
    spy.assert_called_once_with(aoi[0], **interp_module_params)


def test__normalize_sam_product_names():

    BAD_NAMES  = [' -.()[]:+/",', 'Module[1]']
    NORM_NAMES = ['____________', 'Module_1_']

    norm_names = pvsystem._normalize_sam_product_names(BAD_NAMES)
    assert list(norm_names) == NORM_NAMES

    BAD_NAMES  = ['Module[1]', 'Module(1)']
    NORM_NAMES = ['Module_1_', 'Module_1_']

    with pytest.warns(UserWarning):
        norm_names = pvsystem._normalize_sam_product_names(BAD_NAMES)
    assert list(norm_names) == NORM_NAMES

    BAD_NAMES  = ['Module[1]', 'Module[1]']
    NORM_NAMES = ['Module_1_', 'Module_1_']

    with pytest.warns(UserWarning):
        norm_names = pvsystem._normalize_sam_product_names(BAD_NAMES)
    assert list(norm_names) == NORM_NAMES


def test_PVSystem_get_iam_invalid(sapm_module_params, mocker):
    system = pvsystem.PVSystem(module_parameters=sapm_module_params)
    with pytest.raises(ValueError):
        system.get_iam(45, iam_model='not_a_model')


def test_retrieve_sam_raises_exceptions():
    """
    Raise an exception if an invalid parameter is provided to `retrieve_sam()`.
    """
    with pytest.raises(ValueError, match="Please provide either"):
        pvsystem.retrieve_sam()
    with pytest.raises(ValueError, match="Please provide either.*, not both."):
        pvsystem.retrieve_sam(name="this_surely_wont_work", path="wont_work")
    with pytest.raises(KeyError, match="Invalid name"):
        pvsystem.retrieve_sam(name="this_surely_wont_work")
    with pytest.raises(FileNotFoundError):
        pvsystem.retrieve_sam(path="this_surely_wont_work.csv")


def test_retrieve_sam_databases():
    """Test the expected keys are retrieved from each database."""
    keys_per_database = {
        "cecmod": {'Technology', 'Bifacial', 'STC', 'PTC', 'A_c', 'Length',
                   'Width', 'N_s', 'I_sc_ref', 'V_oc_ref', 'I_mp_ref',
                   'V_mp_ref', 'alpha_sc', 'beta_oc', 'T_NOCT', 'a_ref',
                   'I_L_ref', 'I_o_ref', 'R_s', 'R_sh_ref', 'Adjust',
                   'gamma_r', 'BIPV', 'Version', 'Date'},
        "sandiamod": {'Vintage', 'Area', 'Material', 'Cells_in_Series',
                      'Parallel_Strings', 'Isco', 'Voco', 'Impo', 'Vmpo',
                      'Aisc', 'Aimp', 'C0', 'C1', 'Bvoco', 'Mbvoc', 'Bvmpo',
                      'Mbvmp', 'N', 'C2', 'C3', 'A0', 'A1', 'A2', 'A3', 'A4',
                      'B0', 'B1', 'B2', 'B3', 'B4', 'B5', 'DTC', 'FD', 'A',
                      'B', 'C4', 'C5', 'IXO', 'IXXO', 'C6', 'C7', 'Notes'},
        "adrinverter": {'Manufacturer', 'Model', 'Source', 'Vac', 'Vintage',
                        'Pacmax', 'Pnom', 'Vnom', 'Vmin', 'Vmax',
                        'ADRCoefficients', 'Pnt', 'Vdcmax', 'Idcmax',
                        'MPPTLow', 'MPPTHi', 'TambLow', 'TambHi', 'Weight',
                        'PacFitErrMax', 'YearOfData'},
        "cecinverter": {'Vac', 'Paco', 'Pdco', 'Vdco', 'Pso', 'C0', 'C1', 'C2',
                        'C3', 'Pnt', 'Vdcmax', 'Idcmax', 'Mppt_low',
                        'Mppt_high', 'CEC_Date', 'CEC_Type'}
    }  # fmt: skip
    item_per_database = {
        "cecmod": "Itek_Energy_LLC_iT_300_HE",
        "sandiamod": "Canadian_Solar_CS6X_300M__2013_",
        "adrinverter": "Sainty_Solar__SSI_4K4U_240V__CEC_2011_",
        "cecinverter": "ABB__PVI_3_0_OUTD_S_US__208V_",
    }
    # duplicate the cecinverter items for sandiainverter, for backwards compat
    keys_per_database["sandiainverter"] = keys_per_database["cecinverter"]
    item_per_database["sandiainverter"] = item_per_database["cecinverter"]

    for database in keys_per_database.keys():
        data = pvsystem.retrieve_sam(database)
        assert set(data.index) == keys_per_database[database]
        assert item_per_database[database] in data.columns


def test_sapm(sapm_module_params):

    times = pd.date_range(start='2015-01-01', periods=5, freq='12h')
    effective_irradiance = pd.Series([-1000, 500, 1100, np.nan, 1000],
                                     index=times)
    temp_cell = pd.Series([10, 25, 50, 25, np.nan], index=times)

    out = pvsystem.sapm(effective_irradiance, temp_cell, sapm_module_params)

    expected = pd.DataFrame(np.array(
        [[-5.0608322, -4.65037767, np.nan, np.nan, np.nan,
          -4.91119927, -4.16721569],
         [2.545575, 2.28773882, 56.86182059, 47.21121608, 108.00693168,
          2.48357383, 1.71782772],
         [5.65584763, 5.01709903, 54.1943277, 42.51861718, 213.32011294,
          5.52987899, 3.46796463],
         [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan],
         [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan]]),
        columns=['i_sc', 'i_mp', 'v_oc', 'v_mp', 'p_mp', 'i_x', 'i_xx'],
        index=times)

    assert_frame_equal(out, expected, check_less_precise=4)

    out = pvsystem.sapm(1000, 25, sapm_module_params)

    expected = OrderedDict()
    expected['i_sc'] = sapm_module_params['Isco']
    expected['i_mp'] = sapm_module_params['Impo']
    expected['v_oc'] = sapm_module_params['Voco']
    expected['v_mp'] = sapm_module_params['Vmpo']
    expected['p_mp'] = sapm_module_params['Impo'] * sapm_module_params['Vmpo']
    expected['i_x'] = sapm_module_params['IXO']
    expected['i_xx'] = sapm_module_params['IXXO']

    for k, v in expected.items():
        assert_allclose(out[k], v, atol=1e-4)

    # just make sure it works with Series input
    pvsystem.sapm(effective_irradiance, temp_cell,
                  pd.Series(sapm_module_params))

    # ensure C4-C7 are optional
    optional_keys = ['IXO', 'IXXO', 'C4', 'C5', 'C6', 'C7']
    params_no_c4c7 = {
        k: v for k, v in sapm_module_params.items() if k not in optional_keys
    }
    out = pvsystem.sapm(effective_irradiance, temp_cell, params_no_c4c7)
    assert 'i_x' not in out.keys()
    assert 'i_xx' not in out.keys()


def test_PVSystem_sapm(sapm_module_params, mocker):
    mocker.spy(pvsystem, 'sapm')
    system = pvsystem.PVSystem(module_parameters=sapm_module_params)
    effective_irradiance = 500
    temp_cell = 25
    out = system.sapm(effective_irradiance, temp_cell)
    pvsystem.sapm.assert_called_once_with(effective_irradiance, temp_cell,
                                          sapm_module_params)
    assert_allclose(out['p_mp'], 100, 10)


def test_PVSystem_multi_array_sapm(sapm_module_params):
    system = pvsystem.PVSystem(
        arrays=[pvsystem.Array(pvsystem.FixedMount(0, 180),
                               module_parameters=sapm_module_params),
                pvsystem.Array(pvsystem.FixedMount(0, 180),
                               module_parameters=sapm_module_params)]
    )
    effective_irradiance = (100, 500)
    temp_cell = (15, 25)
    sapm_one, sapm_two = system.sapm(effective_irradiance, temp_cell)
    assert sapm_one['p_mp'] != sapm_two['p_mp']
    sapm_one_flip, sapm_two_flip = system.sapm(
        (effective_irradiance[1], effective_irradiance[0]),
        (temp_cell[1], temp_cell[0])
    )
    assert sapm_one_flip['p_mp'] == sapm_two['p_mp']
    assert sapm_two_flip['p_mp'] == sapm_one['p_mp']
    with pytest.raises(ValueError,
                       match="Length mismatch for per-array parameter"):
        system.sapm(effective_irradiance, 10)
    with pytest.raises(ValueError,
                       match="Length mismatch for per-array parameter"):
        system.sapm(500, temp_cell)


def test_PVSystem_sapm_spectral_loss(sapm_module_params, mocker):
    mocker.spy(spectrum, 'spectral_factor_sapm')
    system = pvsystem.PVSystem(module_parameters=sapm_module_params)
    airmass = 2
    out = system.sapm_spectral_loss(airmass)
    spectrum.spectral_factor_sapm.assert_called_once_with(airmass,
                                                          sapm_module_params)
    assert_allclose(out, 1, atol=0.5)


def test_PVSystem_multi_array_sapm_spectral_loss(sapm_module_params):
    system = pvsystem.PVSystem(
        arrays=[pvsystem.Array(pvsystem.FixedMount(0, 180),
                               module_parameters=sapm_module_params),
                pvsystem.Array(pvsystem.FixedMount(0, 180),
                               module_parameters=sapm_module_params)]
    )
    loss_one, loss_two = system.sapm_spectral_loss(2)
    assert loss_one == loss_two


# this test could be improved to cover all cell types.
# could remove the need for specifying spectral coefficients if we don't
# care about the return value at all
@pytest.mark.parametrize('module_parameters,module_type,coefficients', [
    ({'Technology': 'mc-Si'}, 'multisi', None),
    ({'Material': 'Multi-c-Si'}, 'multisi', None),
    ({'first_solar_spectral_coefficients': (
        0.84, -0.03, -0.008, 0.14, 0.04, -0.002)},
     None,
     (0.84, -0.03, -0.008, 0.14, 0.04, -0.002))
    ])
def test_PVSystem_first_solar_spectral_loss(module_parameters, module_type,
                                            coefficients, mocker):
    mocker.spy(spectrum, 'spectral_factor_firstsolar')
    system = pvsystem.PVSystem(module_parameters=module_parameters)
    pw = 3
    airmass_absolute = 3
    out = system.first_solar_spectral_loss(pw, airmass_absolute)
    spectrum.spectral_factor_firstsolar.assert_called_once_with(
        pw, airmass_absolute, module_type, coefficients)
    assert_allclose(out, 1, atol=0.5)


def test_PVSystem_multi_array_first_solar_spectral_loss():
    system = pvsystem.PVSystem(
        arrays=[
            pvsystem.Array(
                mount=pvsystem.FixedMount(0, 180),
                module_parameters={'Technology': 'mc-Si'},
                module_type='multisi'
            ),
            pvsystem.Array(
                mount=pvsystem.FixedMount(0, 180),
                module_parameters={'Technology': 'mc-Si'},
                module_type='multisi'
            )
        ]
    )
    loss_one, loss_two = system.first_solar_spectral_loss(1, 3)
    assert loss_one == loss_two


@pytest.mark.parametrize('test_input,expected', [
    ([1000, 100, 5, 45], 1140.0510967821877),
    ([np.array([np.nan, 1000, 1000]),
      np.array([100, np.nan, 100]),
      np.array([1.1, 1.1, 1.1]),
      np.array([10, 10, 10])],
     np.array([np.nan, np.nan, 1081.1574])),
    ([pd.Series([1000]), pd.Series([100]), pd.Series([1.1]),
      pd.Series([10])],
     pd.Series([1081.1574]))
])
def test_sapm_effective_irradiance(sapm_module_params, test_input, expected):
    test_input.append(sapm_module_params)
    out = pvsystem.sapm_effective_irradiance(*test_input)
    if isinstance(test_input, pd.Series):
        assert_series_equal(out, expected, check_less_precise=4)
    else:
        assert_allclose(out, expected, atol=1e-1)


def test_PVSystem_sapm_effective_irradiance(sapm_module_params, mocker):
    system = pvsystem.PVSystem(module_parameters=sapm_module_params)
    mocker.spy(pvsystem, 'sapm_effective_irradiance')

    poa_direct = 900
    poa_diffuse = 100
    airmass_absolute = 1.5
    aoi = 0
    p = (sapm_module_params['A4'], sapm_module_params['A3'],
         sapm_module_params['A2'], sapm_module_params['A1'],
         sapm_module_params['A0'])
    f1 = np.polyval(p, airmass_absolute)
    expected = f1 * (poa_direct + sapm_module_params['FD'] * poa_diffuse)
    out = system.sapm_effective_irradiance(
        poa_direct, poa_diffuse, airmass_absolute, aoi)
    pvsystem.sapm_effective_irradiance.assert_called_once_with(
        poa_direct, poa_diffuse, airmass_absolute, aoi, sapm_module_params)
    assert_allclose(out, expected, atol=0.1)


def test_PVSystem_multi_array_sapm_effective_irradiance(sapm_module_params):
    system = pvsystem.PVSystem(
        arrays=[pvsystem.Array(pvsystem.FixedMount(0, 180),
                               module_parameters=sapm_module_params),
                pvsystem.Array(pvsystem.FixedMount(0, 180),
                               module_parameters=sapm_module_params)]
    )
    poa_direct = (500, 900)
    poa_diffuse = (50, 100)
    aoi = (0, 10)
    airmass_absolute = 1.5
    irrad_one, irrad_two = system.sapm_effective_irradiance(
        poa_direct, poa_diffuse, airmass_absolute, aoi
    )
    assert irrad_one != irrad_two


@pytest.fixture
def two_array_system(pvsyst_module_params, cec_module_params):
    """Two-array PVSystem.

    Both arrays are identical.
    """
    temperature_model = temperature.TEMPERATURE_MODEL_PARAMETERS['sapm'][
        'open_rack_glass_glass'
    ]
    # Need u_v to be non-zero so wind-speed changes cell temperature
    # under the pvsyst model.
    temperature_model['u_v'] = 1.0
    # parameter for fuentes temperature model
    temperature_model['noct_installed'] = 45
    # parameters for noct_sam temperature model
    temperature_model['noct'] = 45.
    temperature_model['module_efficiency'] = 0.2
    module_params = {**pvsyst_module_params, **cec_module_params}
    return pvsystem.PVSystem(
        arrays=[
            pvsystem.Array(
                mount=pvsystem.FixedMount(0, 180),
                temperature_model_parameters=temperature_model,
                module_parameters=module_params
            ),
            pvsystem.Array(
                mount=pvsystem.FixedMount(0, 180),
                temperature_model_parameters=temperature_model,
                module_parameters=module_params
            )
        ]
    )


@pytest.mark.parametrize("poa_direct, poa_diffuse, aoi",
                         [(20, (10, 10), (20, 20)),
                          ((20, 20), (10,), (20, 20)),
                          ((20, 20), (10, 10), 20)])
def test_PVSystem_sapm_effective_irradiance_value_error(
        poa_direct, poa_diffuse, aoi, two_array_system):
    with pytest.raises(ValueError,
                       match="Length mismatch for per-array parameter"):
        two_array_system.sapm_effective_irradiance(
            poa_direct, poa_diffuse, 10, aoi
        )


def test_PVSystem_sapm_celltemp(mocker):
    a, b, deltaT = (-3.47, -0.0594, 3)  # open_rack_glass_glass
    temp_model_params = {'a': a, 'b': b, 'deltaT': deltaT}
    system = pvsystem.PVSystem(temperature_model_parameters=temp_model_params)
    mocker.spy(temperature, 'sapm_cell')
    temps = 25
    irrads = 1000
    winds = 1
    out = system.get_cell_temperature(irrads, temps, winds, model='sapm')
    temperature.sapm_cell.assert_called_once_with(irrads, temps, winds, a, b,
                                                  deltaT)
    assert_allclose(out, 57, atol=1)


def test_PVSystem_sapm_celltemp_kwargs(mocker):
    temp_model_params = temperature.TEMPERATURE_MODEL_PARAMETERS['sapm'][
        'open_rack_glass_glass']
    system = pvsystem.PVSystem(temperature_model_parameters=temp_model_params)
    mocker.spy(temperature, 'sapm_cell')
    temps = 25
    irrads = 1000
    winds = 1
    out = system.get_cell_temperature(irrads, temps, winds, model='sapm')
    temperature.sapm_cell.assert_called_once_with(irrads, temps, winds,
                                                  temp_model_params['a'],
                                                  temp_model_params['b'],
                                                  temp_model_params['deltaT'])
    assert_allclose(out, 57, atol=1)


def test_PVSystem_multi_array_sapm_celltemp_different_arrays():
    temp_model_one = temperature.TEMPERATURE_MODEL_PARAMETERS['sapm'][
        'open_rack_glass_glass']
    temp_model_two = temperature.TEMPERATURE_MODEL_PARAMETERS['sapm'][
        'close_mount_glass_glass']
    system = pvsystem.PVSystem(
        arrays=[pvsystem.Array(pvsystem.FixedMount(0, 180),
                               temperature_model_parameters=temp_model_one),
                pvsystem.Array(pvsystem.FixedMount(0, 180),
                               temperature_model_parameters=temp_model_two)]
    )
    temp_one, temp_two = system.get_cell_temperature(
        (1000, 1000), 25, 1, model='sapm'
    )
    assert temp_one != temp_two


def test_PVSystem_pvsyst_celltemp(mocker):
    parameter_set = 'insulated'
    temp_model_params = temperature.TEMPERATURE_MODEL_PARAMETERS['pvsyst'][
        parameter_set]
    alpha_absorption = 0.85
    module_efficiency = 0.17
    module_parameters = {'alpha_absorption': alpha_absorption,
                         'module_efficiency': module_efficiency}
    system = pvsystem.PVSystem(module_parameters=module_parameters,
                               temperature_model_parameters=temp_model_params)
    mocker.spy(temperature, 'pvsyst_cell')
    irrad = 800
    temp = 45
    wind = 0.5
    out = system.get_cell_temperature(irrad, temp, wind_speed=wind,
                                      model='pvsyst')
    temperature.pvsyst_cell.assert_called_once_with(
        irrad, temp, wind_speed=wind, u_c=temp_model_params['u_c'],
        u_v=temp_model_params['u_v'], module_efficiency=module_efficiency,
        alpha_absorption=alpha_absorption)
    assert (out < 90) and (out > 70)


def test_PVSystem_faiman_celltemp(mocker):
    u0, u1 = 25.0, 6.84  # default values
    temp_model_params = {'u0': u0, 'u1': u1}
    system = pvsystem.PVSystem(temperature_model_parameters=temp_model_params)
    mocker.spy(temperature, 'faiman')
    temps = 25
    irrads = 1000
    winds = 1
    out = system.get_cell_temperature(irrads, temps, winds, model='faiman')
    temperature.faiman.assert_called_once_with(irrads, temps, winds, u0, u1)
    assert_allclose(out, 56.4, atol=1e-1)


def test_PVSystem_noct_celltemp(mocker):
    poa_global, temp_air, wind_speed, noct, module_efficiency = (
        1000., 25., 1., 45., 0.2)
    expected = 55.230790492
    temp_model_params = {'noct': noct, 'module_efficiency': module_efficiency}
    system = pvsystem.PVSystem(temperature_model_parameters=temp_model_params)
    mocker.spy(temperature, 'noct_sam')
    out = system.get_cell_temperature(poa_global, temp_air, wind_speed,
                                      model='noct_sam')
    temperature.noct_sam.assert_called_once_with(
        poa_global, temp_air, wind_speed, noct, module_efficiency,
        effective_irradiance=None)
    assert_allclose(out, expected)
    # different types
    out = system.get_cell_temperature(np.array(poa_global), np.array(temp_air),
                                      np.array(wind_speed), model='noct_sam')
    assert_allclose(out, expected)
    dr = pd.date_range(start='2020-01-01 12:00:00', end='2020-01-01 13:00:00',
                       freq='1h')
    out = system.get_cell_temperature(pd.Series(index=dr, data=poa_global),
                                      pd.Series(index=dr, data=temp_air),
                                      pd.Series(index=dr, data=wind_speed),
                                      model='noct_sam')
    assert_series_equal(out, pd.Series(index=dr, data=expected))
    # now use optional arguments
    temp_model_params.update({'transmittance_absorptance': 0.8,
                              'array_height': 2,
                              'mount_standoff': 2.0})
    expected = 60.477703576
    system = pvsystem.PVSystem(temperature_model_parameters=temp_model_params)
    out = system.get_cell_temperature(poa_global, temp_air, wind_speed,
                                      effective_irradiance=1100.,
                                      model='noct_sam')
    assert_allclose(out, expected)


def test_PVSystem_noct_celltemp_error():
    poa_global, temp_air, wind_speed, module_efficiency = (1000., 25., 1., 0.2)
    temp_model_params = {'module_efficiency': module_efficiency}
    system = pvsystem.PVSystem(temperature_model_parameters=temp_model_params)
    with pytest.raises(KeyError):
        system.get_cell_temperature(poa_global, temp_air, wind_speed,
                                    model='noct_sam')


@pytest.mark.parametrize("model",
                         ['faiman', 'pvsyst', 'sapm', 'fuentes', 'noct_sam'])
def test_PVSystem_multi_array_celltemp_functions(model, two_array_system):
    times = pd.date_range(start='2020-08-25 11:00', freq='h', periods=3)
    irrad_one = pd.Series(1000, index=times)
    irrad_two = pd.Series(500, index=times)
    temp_air = pd.Series(25, index=times)
    wind_speed = pd.Series(1, index=times)

    temp_one, temp_two = two_array_system.get_cell_temperature(
        (irrad_one, irrad_two), temp_air, wind_speed, model=model)
    assert (temp_one != temp_two).all()


@pytest.mark.parametrize("model",
                         ['faiman', 'pvsyst', 'sapm', 'fuentes', 'noct_sam'])
def test_PVSystem_multi_array_celltemp_multi_temp(model, two_array_system):
    times = pd.date_range(start='2020-08-25 11:00', freq='h', periods=3)
    irrad = pd.Series(1000, index=times)
    temp_air_one = pd.Series(25, index=times)
    temp_air_two = pd.Series(5, index=times)
    wind_speed = pd.Series(1, index=times)
    temp_one, temp_two = two_array_system.get_cell_temperature(
        (irrad, irrad),
        (temp_air_one, temp_air_two),
        wind_speed,
        model=model
    )
    assert (temp_one != temp_two).all()
    temp_one_swtich, temp_two_switch = two_array_system.get_cell_temperature(
        (irrad, irrad),
        (temp_air_two, temp_air_one),
        wind_speed,
        model=model
    )
    assert_series_equal(temp_one, temp_two_switch)
    assert_series_equal(temp_two, temp_one_swtich)


@pytest.mark.parametrize("model",
                         ['faiman', 'pvsyst', 'sapm', 'fuentes', 'noct_sam'])
def test_PVSystem_multi_array_celltemp_multi_wind(model, two_array_system):
    times = pd.date_range(start='2020-08-25 11:00', freq='h', periods=3)
    irrad = pd.Series(1000, index=times)
    temp_air = pd.Series(25, index=times)
    wind_speed_one = pd.Series(1, index=times)
    wind_speed_two = pd.Series(5, index=times)
    temp_one, temp_two = two_array_system.get_cell_temperature(
        (irrad, irrad),
        temp_air,
        (wind_speed_one, wind_speed_two),
        model=model
    )
    assert (temp_one != temp_two).all()
    temp_one_swtich, temp_two_switch = two_array_system.get_cell_temperature(
        (irrad, irrad),
        temp_air,
        (wind_speed_two, wind_speed_one),
        model=model
    )
    assert_series_equal(temp_one, temp_two_switch)
    assert_series_equal(temp_two, temp_one_swtich)


def test_PVSystem_get_cell_temperature_invalid():
    system = pvsystem.PVSystem()
    with pytest.raises(ValueError, match='not a valid'):
        system.get_cell_temperature(1000, 25, 1, 'not_a_model')


@pytest.mark.parametrize("model",
                         ['faiman', 'pvsyst', 'sapm', 'fuentes', 'noct_sam'])
def test_PVSystem_multi_array_celltemp_temp_too_short(
        model, two_array_system):
    with pytest.raises(ValueError,
                       match="Length mismatch for per-array parameter"):
        two_array_system.get_cell_temperature((1000, 1000), (1,), 1,
                                              model=model)


@pytest.mark.parametrize("model",
                         ['faiman', 'pvsyst', 'sapm', 'fuentes', 'noct_sam'])
def test_PVSystem_multi_array_celltemp_temp_too_long(
        model, two_array_system):
    with pytest.raises(ValueError,
                       match="Length mismatch for per-array parameter"):
        two_array_system.get_cell_temperature((1000, 1000), (1, 1, 1), 1,
                                              model=model)


@pytest.mark.parametrize("model",
                         ['faiman', 'pvsyst', 'sapm', 'fuentes', 'noct_sam'])
def test_PVSystem_multi_array_celltemp_wind_too_short(
        model, two_array_system):
    with pytest.raises(ValueError,
                       match="Length mismatch for per-array parameter"):
        two_array_system.get_cell_temperature((1000, 1000), 25, (1,),
                                              model=model)


@pytest.mark.parametrize("model",
                         ['faiman', 'pvsyst', 'sapm', 'fuentes', 'noct_sam'])
def test_PVSystem_multi_array_celltemp_wind_too_long(
        model, two_array_system):
    with pytest.raises(ValueError,
                       match="Length mismatch for per-array parameter"):
        two_array_system.get_cell_temperature((1000, 1000), 25, (1, 1, 1),
                                              model=model)


@pytest.mark.parametrize("model",
                         ['faiman', 'pvsyst', 'sapm', 'fuentes', 'noct_sam'])
def test_PVSystem_multi_array_celltemp_poa_length_mismatch(
        model, two_array_system):
    with pytest.raises(ValueError,
                       match="Length mismatch for per-array parameter"):
        two_array_system.get_cell_temperature(1000, 25, 1, model=model)


def test_PVSystem_fuentes_celltemp(mocker):
    noct_installed = 45
    temp_model_params = {'noct_installed': noct_installed, 'surface_tilt': 0}
    system = pvsystem.PVSystem(temperature_model_parameters=temp_model_params)
    spy = mocker.spy(temperature, 'fuentes')
    index = pd.date_range('2019-01-01 11:00', freq='h', periods=3)
    temps = pd.Series(25, index)
    irrads = pd.Series(1000, index)
    winds = pd.Series(1, index)
    out = system.get_cell_temperature(irrads, temps, winds, model='fuentes')
    assert_series_equal(spy.call_args[0][0], irrads)
    assert_series_equal(spy.call_args[0][1], temps)
    assert_series_equal(spy.call_args[0][2], winds)
    assert spy.call_args[0][3] == noct_installed
    assert_series_equal(out, pd.Series([52.85, 55.85, 55.85], index,
                                       name='tmod'))


def test_PVSystem_fuentes_module_height(mocker):
    # check that fuentes picks up Array.mount.module_height correctly
    # (temperature.fuentes defaults to 5 for module_height)
    array = pvsystem.Array(mount=FixedMount(module_height=3),
                           temperature_model_parameters={'noct_installed': 45})
    spy = mocker.spy(temperature, 'fuentes')
    index = pd.date_range('2019-01-01 11:00', freq='h', periods=3)
    temps = pd.Series(25, index)
    irrads = pd.Series(1000, index)
    winds = pd.Series(1, index)
    _ = array.get_cell_temperature(irrads, temps, winds, model='fuentes')
    assert spy.call_args[1]['module_height'] == 3


def test_Array__infer_temperature_model_params():
    array = pvsystem.Array(mount=FixedMount(0, 180,
                                            racking_model='open_rack'),
                           module_parameters={},
                           module_type='glass_polymer')
    expected = temperature.TEMPERATURE_MODEL_PARAMETERS[
        'sapm']['open_rack_glass_polymer']
    assert expected == array._infer_temperature_model_params()
    array = pvsystem.Array(mount=FixedMount(0, 180,
                                            racking_model='freestanding'),
                           module_parameters={},
                           module_type='glass_polymer')
    expected = temperature.TEMPERATURE_MODEL_PARAMETERS[
        'pvsyst']['freestanding']
    assert expected == array._infer_temperature_model_params()
    array = pvsystem.Array(mount=FixedMount(0, 180,
                                            racking_model='insulated'),
                           module_parameters={},
                           module_type=None)
    expected = temperature.TEMPERATURE_MODEL_PARAMETERS[
        'pvsyst']['insulated']
    assert expected == array._infer_temperature_model_params()
    array = pvsystem.Array(mount=FixedMount(0, 180,
                                            racking_model='semi_integrated'),
                           module_parameters={},
                           module_type=None)
    expected = temperature.TEMPERATURE_MODEL_PARAMETERS[
        'pvsyst']['semi_integrated']
    assert expected == array._infer_temperature_model_params()


def test_Array__infer_cell_type():
    array = pvsystem.Array(mount=pvsystem.FixedMount(0, 180),
                           module_parameters={})
    assert array._infer_cell_type() is None


def _calcparams_correct_Python_type_numeric_type_cases():
    """
    An auxilary function used in the unit tests named
    ``test_calcparams_*_returns_correct_Python_type``.

    Returns
    -------
        Returns a list of tuples of functions intended for transforming a
        Python scalar into a numeric type: scalar, np.ndarray, or pandas.Series
    """
    return list(itertools.product(*(2 * [[
        # scalars (e.g. Python floats)
        lambda x: x,
        # np.ndarrays (0d and 1d-arrays)
        np.array,
        lambda x: np.array([x]),
        # pd.Series (1d-arrays)
        pd.Series
    ]])))


def _calcparams_correct_Python_type_check(out_value, numeric_args):
    """
    An auxilary function used in the unit tests named
    ``test_calcparams_*_returns_correct_Python_type``.

    Parameters
    ----------
    out_value: numeric
        A value returned by a pvsystem.calcparams_ function.

    numeric_args: numeric
        An iterable of the numeric-type arguments to the pvsystem.calcparams_
        functions: ``effective_irradiance`` and ``temp_cell``.

    Returns
    -------
        bool indicating whether ``out_value`` has the correct Python type
        based on the Python types of ``effective_irradiance`` and
        ``temp_cell``.
    """
    if any(isinstance(a, pd.Series) for a in numeric_args):
        return isinstance(out_value, pd.Series)
    elif any(isinstance(a, np.ndarray) for a in numeric_args):
        return isinstance(out_value, np.ndarray)  # 0d or 1d-arrays
    return np.isscalar(out_value)


@pytest.mark.parametrize('numeric_type_funcs',
                         _calcparams_correct_Python_type_numeric_type_cases())
def test_calcparams_desoto_returns_correct_Python_type(numeric_type_funcs,
                                                       cec_module_params):
    numeric_args = dict(
        effective_irradiance=numeric_type_funcs[0](800.0),
        temp_cell=numeric_type_funcs[1](25),
    )
    out = pvsystem.calcparams_desoto(
        **numeric_args,
        alpha_sc=cec_module_params['alpha_sc'],
        a_ref=cec_module_params['a_ref'],
        I_L_ref=cec_module_params['I_L_ref'],
        I_o_ref=cec_module_params['I_o_ref'],
        R_sh_ref=cec_module_params['R_sh_ref'],
        R_s=cec_module_params['R_s'],
        EgRef=1.121,
        dEgdT=-0.0002677
    )

    assert all(_calcparams_correct_Python_type_check(a, numeric_args.values())
               for a in out)


@pytest.mark.parametrize('numeric_type_funcs',
                         _calcparams_correct_Python_type_numeric_type_cases())
def test_calcparams_cec_returns_correct_Python_type(numeric_type_funcs,
                                                    cec_module_params):
    numeric_args = dict(
        effective_irradiance=numeric_type_funcs[0](800.0),
        temp_cell=numeric_type_funcs[1](25),
    )
    out = pvsystem.calcparams_cec(
        **numeric_args,
        alpha_sc=cec_module_params['alpha_sc'],
        a_ref=cec_module_params['a_ref'],
        I_L_ref=cec_module_params['I_L_ref'],
        I_o_ref=cec_module_params['I_o_ref'],
        R_sh_ref=cec_module_params['R_sh_ref'],
        R_s=cec_module_params['R_s'],
        Adjust=cec_module_params['Adjust'],
        EgRef=1.121,
        dEgdT=-0.0002677
    )

    assert all(_calcparams_correct_Python_type_check(a, numeric_args.values())
               for a in out)


@pytest.mark.parametrize('numeric_type_funcs',
                         _calcparams_correct_Python_type_numeric_type_cases())
def test_calcparams_pvsyst_returns_correct_Python_type(numeric_type_funcs,
                                                       pvsyst_module_params):
    numeric_args = dict(
        effective_irradiance=numeric_type_funcs[0](800.0),
        temp_cell=numeric_type_funcs[1](25),
    )
    out = pvsystem.calcparams_pvsyst(
        **numeric_args,
        alpha_sc=pvsyst_module_params['alpha_sc'],
        gamma_ref=pvsyst_module_params['gamma_ref'],
        mu_gamma=pvsyst_module_params['mu_gamma'],
        I_L_ref=pvsyst_module_params['I_L_ref'],
        I_o_ref=pvsyst_module_params['I_o_ref'],
        R_sh_ref=pvsyst_module_params['R_sh_ref'],
        R_sh_0=pvsyst_module_params['R_sh_0'],
        R_s=pvsyst_module_params['R_s'],
        cells_in_series=pvsyst_module_params['cells_in_series'],
        EgRef=pvsyst_module_params['EgRef']
    )

    assert all(_calcparams_correct_Python_type_check(a, numeric_args.values())
               for a in out)


def test_calcparams_desoto_all_scalars(cec_module_params):
    IL, I0, Rs, Rsh, nNsVth = pvsystem.calcparams_desoto(
        effective_irradiance=800.0,
        temp_cell=25,
        alpha_sc=cec_module_params['alpha_sc'],
        a_ref=cec_module_params['a_ref'],
        I_L_ref=cec_module_params['I_L_ref'],
        I_o_ref=cec_module_params['I_o_ref'],
        R_sh_ref=cec_module_params['R_sh_ref'],
        R_s=cec_module_params['R_s'],
        EgRef=1.121,
        dEgdT=-0.0002677
    )

    assert np.isclose(IL, 6.036, atol=1e-4, rtol=0)
    assert np.isclose(I0, 1.94e-9, atol=1e-4, rtol=0)
    assert np.isclose(Rs, 0.094, atol=1e-4, rtol=0)
    assert np.isclose(Rsh, 19.65, atol=1e-4, rtol=0)
    assert np.isclose(nNsVth, 0.473, atol=1e-4, rtol=0)


def test_calcparams_cec_all_scalars(cec_module_params):
    IL, I0, Rs, Rsh, nNsVth = pvsystem.calcparams_cec(
        effective_irradiance=800.0,
        temp_cell=25,
        alpha_sc=cec_module_params['alpha_sc'],
        a_ref=cec_module_params['a_ref'],
        I_L_ref=cec_module_params['I_L_ref'],
        I_o_ref=cec_module_params['I_o_ref'],
        R_sh_ref=cec_module_params['R_sh_ref'],
        R_s=cec_module_params['R_s'],
        Adjust=cec_module_params['Adjust'],
        EgRef=1.121,
        dEgdT=-0.0002677
    )

    assert np.isclose(IL, 6.036, atol=1e-4, rtol=0)
    assert np.isclose(I0, 1.94e-9, atol=1e-4, rtol=0)
    assert np.isclose(Rs, 0.094, atol=1e-4, rtol=0)
    assert np.isclose(Rsh, 19.65, atol=1e-4, rtol=0)
    assert np.isclose(nNsVth, 0.473, atol=1e-4, rtol=0)


def test_calcparams_pvsyst_all_scalars(pvsyst_module_params):
    IL, I0, Rs, Rsh, nNsVth = pvsystem.calcparams_pvsyst(
        effective_irradiance=800.0,
        temp_cell=50,
        alpha_sc=pvsyst_module_params['alpha_sc'],
        gamma_ref=pvsyst_module_params['gamma_ref'],
        mu_gamma=pvsyst_module_params['mu_gamma'],
        I_L_ref=pvsyst_module_params['I_L_ref'],
        I_o_ref=pvsyst_module_params['I_o_ref'],
        R_sh_ref=pvsyst_module_params['R_sh_ref'],
        R_sh_0=pvsyst_module_params['R_sh_0'],
        R_s=pvsyst_module_params['R_s'],
        cells_in_series=pvsyst_module_params['cells_in_series'],
        EgRef=pvsyst_module_params['EgRef'])

    assert np.isclose(IL, 4.8200, atol=1e-4, rtol=0)
    assert np.isclose(I0, 1.47e-7, atol=1e-4, rtol=0)
    assert np.isclose(Rs, 0.500, atol=1e-4, rtol=0)
    assert np.isclose(Rsh, 305.757, atol=1e-4, rtol=0)
    assert np.isclose(nNsVth, 1.7961, atol=1e-4, rtol=0)


def test_calcparams_desoto(cec_module_params):
    times = pd.date_range(start='2015-01-01', periods=3, freq='12h')
    df = pd.DataFrame({
        'effective_irradiance': [0.0, 800.0, 800.0],
        'temp_cell': [25, 25, 50]
    }, index=times)

    IL, I0, Rs, Rsh, nNsVth = pvsystem.calcparams_desoto(
        df['effective_irradiance'],
        df['temp_cell'],
        alpha_sc=cec_module_params['alpha_sc'],
        a_ref=cec_module_params['a_ref'],
        I_L_ref=cec_module_params['I_L_ref'],
        I_o_ref=cec_module_params['I_o_ref'],
        R_sh_ref=cec_module_params['R_sh_ref'],
        R_s=cec_module_params['R_s'],
        EgRef=1.121,
        dEgdT=-0.0002677
    )

    assert_series_equal(IL, pd.Series([0.0, 6.036, 6.096], index=times),
                        check_less_precise=3)
    assert_series_equal(I0, pd.Series([0.0, 1.94e-9, 7.419e-8], index=times),
                        check_less_precise=3)
    assert_series_equal(Rs, pd.Series([0.094, 0.094, 0.094], index=times),
                        check_less_precise=3)
    assert_series_equal(Rsh, pd.Series([np.inf, 19.65, 19.65], index=times),
                        check_less_precise=3)
    assert_series_equal(nNsVth, pd.Series([0.473, 0.473, 0.5127], index=times),
                        check_less_precise=3)


def test_calcparams_cec(cec_module_params):
    times = pd.date_range(start='2015-01-01', periods=3, freq='12h')
    df = pd.DataFrame({
        'effective_irradiance': [0.0, 800.0, 800.0],
        'temp_cell': [25, 25, 50]
    }, index=times)

    IL, I0, Rs, Rsh, nNsVth = pvsystem.calcparams_cec(
        df['effective_irradiance'],
        df['temp_cell'],
        alpha_sc=cec_module_params['alpha_sc'],
        a_ref=cec_module_params['a_ref'],
        I_L_ref=cec_module_params['I_L_ref'],
        I_o_ref=cec_module_params['I_o_ref'],
        R_sh_ref=cec_module_params['R_sh_ref'],
        R_s=cec_module_params['R_s'],
        Adjust=cec_module_params['Adjust'],
        EgRef=1.121,
        dEgdT=-0.0002677
    )

    assert_series_equal(IL, pd.Series([0.0, 6.036, 6.0896], index=times),
                        check_less_precise=3)
    assert_series_equal(I0, pd.Series([0.0, 1.94e-9, 7.419e-8], index=times),
                        check_less_precise=3)
    assert_series_equal(Rs, pd.Series([0.094, 0.094, 0.094], index=times),
                        check_less_precise=3)
    assert_series_equal(Rsh, pd.Series([np.inf, 19.65, 19.65], index=times),
                        check_less_precise=3)
    assert_series_equal(nNsVth, pd.Series([0.473, 0.473, 0.5127], index=times),
                        check_less_precise=3)


def test_calcparams_cec_extra_params_propagation(cec_module_params, mocker):
    """
    See bug #1215.

    When calling `calcparams_cec`, the parameters `EgRef`, `dEgdT`, `irrad_ref`
    and `temp_ref` must not be ignored.

    Since, internally, this function is calling `calcparams_desoto`, this test
    checks that the latter is called with the expected parameters instead of
    some default values.
    """
    times = pd.date_range(start='2015-01-01', periods=3, freq='12h')
    effective_irradiance = pd.Series([0.0, 800.0, 800.0], index=times)
    temp_cell = pd.Series([25, 25, 50], index=times)
    extra_parameters = dict(
        EgRef=1.123,
        dEgdT=-0.0002688,
        irrad_ref=1100,
        temp_ref=23,
    )
    m = mocker.spy(pvsystem, 'calcparams_desoto')
    pvsystem.calcparams_cec(
        effective_irradiance=effective_irradiance,
        temp_cell=temp_cell,
        alpha_sc=cec_module_params['alpha_sc'],
        a_ref=cec_module_params['a_ref'],
        I_L_ref=cec_module_params['I_L_ref'],
        I_o_ref=cec_module_params['I_o_ref'],
        R_sh_ref=cec_module_params['R_sh_ref'],
        R_s=cec_module_params['R_s'],
        Adjust=cec_module_params['Adjust'],
        **extra_parameters,
    )
    assert m.call_count == 1
    assert m.call_args[1] == extra_parameters


def test_calcparams_pvsyst(pvsyst_module_params):
    times = pd.date_range(start='2015-01-01', periods=2, freq='12h')
    df = pd.DataFrame({
        'effective_irradiance': [0.0, 800.0],
        'temp_cell': [25, 50]
    }, index=times)

    IL, I0, Rs, Rsh, nNsVth = pvsystem.calcparams_pvsyst(
        df['effective_irradiance'],
        df['temp_cell'],
        alpha_sc=pvsyst_module_params['alpha_sc'],
        gamma_ref=pvsyst_module_params['gamma_ref'],
        mu_gamma=pvsyst_module_params['mu_gamma'],
        I_L_ref=pvsyst_module_params['I_L_ref'],
        I_o_ref=pvsyst_module_params['I_o_ref'],
        R_sh_ref=pvsyst_module_params['R_sh_ref'],
        R_sh_0=pvsyst_module_params['R_sh_0'],
        R_s=pvsyst_module_params['R_s'],
        cells_in_series=pvsyst_module_params['cells_in_series'],
        EgRef=pvsyst_module_params['EgRef'])

    assert_series_equal(
        IL.round(decimals=3), pd.Series([0.0, 4.8200], index=times))
    assert_series_equal(
        I0.round(decimals=3), pd.Series([0.0, 1.47e-7], index=times))
    assert_series_equal(
        Rs.round(decimals=3), pd.Series([0.500, 0.500], index=times))
    assert_series_equal(
        Rsh.round(decimals=3), pd.Series([1000.0, 305.757], index=times))
    assert_series_equal(
        nNsVth.round(decimals=4), pd.Series([1.6186, 1.7961], index=times))


def test_PVSystem_calcparams_desoto(cec_module_params, mocker):
    mocker.spy(pvsystem, 'calcparams_desoto')
    module_parameters = cec_module_params.copy()
    module_parameters['EgRef'] = 1.121
    module_parameters['dEgdT'] = -0.0002677
    system = pvsystem.PVSystem(module_parameters=module_parameters)
    effective_irradiance = np.array([0, 800])
    temp_cell = 25
    IL, I0, Rs, Rsh, nNsVth = system.calcparams_desoto(effective_irradiance,
                                                       temp_cell)
    pvsystem.calcparams_desoto.assert_called_once_with(
        effective_irradiance,
        temp_cell,
        alpha_sc=cec_module_params['alpha_sc'],
        a_ref=cec_module_params['a_ref'],
        I_L_ref=cec_module_params['I_L_ref'],
        I_o_ref=cec_module_params['I_o_ref'],
        R_sh_ref=cec_module_params['R_sh_ref'],
        R_s=cec_module_params['R_s'],
        EgRef=module_parameters['EgRef'],
        dEgdT=module_parameters['dEgdT']
    )

    assert_allclose(IL, np.array([0.0, 6.036]), atol=1e-1)
    assert_allclose(I0, np.array([2.0e-9, 2.0e-9]), atol=1.0e-9)
    assert_allclose(Rs, np.array([0.1, 0.1]), atol=0.1)
    assert_allclose(Rsh, np.array([np.inf, 20]), atol=1)
    assert_allclose(nNsVth, np.array([0.5, 0.5]), atol=0.1)


def test_PVSystem_calcparams_pvsyst(pvsyst_module_params, mocker):
    mocker.spy(pvsystem, 'calcparams_pvsyst')
    module_parameters = pvsyst_module_params.copy()
    system = pvsystem.PVSystem(module_parameters=module_parameters)
    effective_irradiance = np.array([0, 800])
    temp_cell = np.array([25, 50])
    IL, I0, Rs, Rsh, nNsVth = system.calcparams_pvsyst(effective_irradiance,
                                                       temp_cell)
    pvsystem.calcparams_pvsyst.assert_called_once_with(
        effective_irradiance,
        temp_cell,
        alpha_sc=pvsyst_module_params['alpha_sc'],
        gamma_ref=pvsyst_module_params['gamma_ref'],
        mu_gamma=pvsyst_module_params['mu_gamma'],
        I_L_ref=pvsyst_module_params['I_L_ref'],
        I_o_ref=pvsyst_module_params['I_o_ref'],
        R_sh_ref=pvsyst_module_params['R_sh_ref'],
        R_sh_0=pvsyst_module_params['R_sh_0'],
        R_s=pvsyst_module_params['R_s'],
        cells_in_series=pvsyst_module_params['cells_in_series'],
        EgRef=pvsyst_module_params['EgRef'],
        R_sh_exp=pvsyst_module_params['R_sh_exp']
    )

    assert_allclose(IL, np.array([0.0, 4.8200]), atol=1)
    assert_allclose(I0, np.array([0.0, 1.47e-7]), atol=1.0e-5)
    assert_allclose(Rs, np.array([0.5, 0.5]), atol=0.1)
    assert_allclose(Rsh, np.array([1000, 305.757]), atol=50)
    assert_allclose(nNsVth, np.array([1.6186, 1.7961]), atol=0.1)


@pytest.mark.parametrize('calcparams', [pvsystem.PVSystem.calcparams_pvsyst,
                                        pvsystem.PVSystem.calcparams_desoto,
                                        pvsystem.PVSystem.calcparams_cec])
def test_PVSystem_multi_array_calcparams(calcparams, two_array_system):
    params_one, params_two = calcparams(
        two_array_system, (1000, 500), (30, 20)
    )
    assert params_one != params_two


@pytest.mark.parametrize('calcparams, irrad, celltemp',
                         [ (f, irrad, celltemp)
                           for f in (pvsystem.PVSystem.calcparams_desoto,
                                     pvsystem.PVSystem.calcparams_cec,
                                     pvsystem.PVSystem.calcparams_pvsyst)
                           for irrad, celltemp in [(1, (1, 1)), ((1, 1), 1)]])
def test_PVSystem_multi_array_calcparams_value_error(
        calcparams, irrad, celltemp, two_array_system):
    with pytest.raises(ValueError,
                       match='Length mismatch for per-array parameter'):
        calcparams(two_array_system, irrad, celltemp)


@pytest.fixture(params=[
    {  # Can handle all python scalar inputs
     'Rsh': 20.,
     'Rs': 0.1,
     'nNsVth': 0.5,
     'I': 3.,
     'I0': 6.e-7,
     'IL': 7.,
     'V_expected': 7.5049875193450521
    },
    {  # Can handle all rank-0 array inputs
     'Rsh': np.array(20.),
     'Rs': np.array(0.1),
     'nNsVth': np.array(0.5),
     'I': np.array(3.),
     'I0': np.array(6.e-7),
     'IL': np.array(7.),
     'V_expected': np.array(7.5049875193450521)
    },
    {  # Can handle all rank-1 singleton array inputs
     'Rsh': np.array([20.]),
     'Rs': np.array([0.1]),
     'nNsVth': np.array([0.5]),
     'I': np.array([3.]),
     'I0': np.array([6.e-7]),
     'IL': np.array([7.]),
     'V_expected': np.array([7.5049875193450521])
    },
    {  # Can handle all rank-1 non-singleton array inputs with infinite shunt
      #  resistance, Rsh=inf gives V=Voc=nNsVth*(np.log(IL + I0) - np.log(I0)
      #  at I=0
      'Rsh': np.array([np.inf, 20.]),
      'Rs': np.array([0.1, 0.1]),
      'nNsVth': np.array([0.5, 0.5]),
      'I': np.array([0., 3.]),
      'I0': np.array([6.e-7, 6.e-7]),
      'IL': np.array([7., 7.]),
      'V_expected': np.array([0.5*(np.log(7. + 6.e-7) - np.log(6.e-7)),
                             7.5049875193450521])
    },
    {  # Can handle mixed inputs with a rank-2 array with infinite shunt
      #  resistance, Rsh=inf gives V=Voc=nNsVth*(np.log(IL + I0) - np.log(I0)
      #  at I=0
      'Rsh': np.array([[np.inf, np.inf], [np.inf, np.inf]]),
      'Rs': np.array([0.1]),
      'nNsVth': np.array(0.5),
      'I': 0.,
      'I0': np.array([6.e-7]),
      'IL': np.array([7.]),
      'V_expected': 0.5*(np.log(7. + 6.e-7) - np.log(6.e-7))*np.ones((2, 2))
    },
    {  # Can handle ideal series and shunt, Rsh=inf and Rs=0 give
      #  V = nNsVth*(np.log(IL - I + I0) - np.log(I0))
      'Rsh': np.inf,
      'Rs': 0.,
      'nNsVth': 0.5,
      'I': np.array([7., 7./2., 0.]),
      'I0': 6.e-7,
      'IL': 7.,
      'V_expected': np.array([0., 0.5*(np.log(7. - 7./2. + 6.e-7) -
                              np.log(6.e-7)), 0.5*(np.log(7. + 6.e-7) -
                              np.log(6.e-7))])
    },
    {  # Can handle only ideal series resistance, no closed form solution
      'Rsh': 20.,
      'Rs': 0.,
      'nNsVth': 0.5,
      'I': 3.,
      'I0': 6.e-7,
      'IL': 7.,
      'V_expected': 7.804987519345062
    },
    {  # Can handle all python scalar inputs with big LambertW arg
      'Rsh': 500.,
      'Rs': 10.,
      'nNsVth': 4.06,
      'I': 0.,
      'I0': 6.e-10,
      'IL': 1.2,
      'V_expected': 86.320000493521079
    },
    {  # Can handle all python scalar inputs with bigger LambertW arg
      #  1000 W/m^2 on a Canadian Solar 220M with 20 C ambient temp
      #  github issue 225 (this appears to be from PR 226 not issue 225)
      'Rsh': 190.,
      'Rs': 1.065,
      'nNsVth': 2.89,
      'I': 0.,
      'I0': 7.05196029e-08,
      'IL': 10.491262,
      'V_expected': 54.303958833791455
    },
    {  # Can handle all python scalar inputs with bigger LambertW arg
      #  1000 W/m^2 on a Canadian Solar 220M with 20 C ambient temp
      #  github issue 225
      'Rsh': 381.68,
      'Rs': 1.065,
      'nNsVth': 2.681527737715915,
      'I': 0.,
      'I0': 1.8739027472625636e-09,
      'IL': 5.1366949999999996,
      'V_expected': 58.19323124611128
    },
    {  # Verify mixed solution type indexing logic
      'Rsh': np.array([np.inf, 190., 381.68]),
      'Rs': 1.065,
      'nNsVth': np.array([2.89, 2.89, 2.681527737715915]),
      'I': 0.,
      'I0': np.array([7.05196029e-08, 7.05196029e-08, 1.8739027472625636e-09]),
      'IL': np.array([10.491262, 10.491262, 5.1366949999999996]),
      'V_expected': np.array([2.89*np.log1p(10.491262/7.05196029e-08),
                              54.303958833791455, 58.19323124611128])
    }])
def fixture_v_from_i(request):
    return request.param


@pytest.mark.parametrize(
    'method, atol', [('lambertw', 1e-11), ('brentq', 1e-11), ('newton', 1e-8)]
)
def test_v_from_i(fixture_v_from_i, method, atol):
    # Solution set loaded from fixture
    Rsh = fixture_v_from_i['Rsh']
    Rs = fixture_v_from_i['Rs']
    nNsVth = fixture_v_from_i['nNsVth']
    I = fixture_v_from_i['I']
    I0 = fixture_v_from_i['I0']
    IL = fixture_v_from_i['IL']
    V_expected = fixture_v_from_i['V_expected']

    V = pvsystem.v_from_i(I, IL, I0, Rs, Rsh, nNsVth, method=method)

    assert isinstance(V, type(V_expected))
    if isinstance(V, np.ndarray):
        assert isinstance(V.dtype, type(V_expected.dtype))
        assert V.shape == V_expected.shape
    assert_allclose(V, V_expected, atol=atol)


def test_i_from_v_from_i(fixture_v_from_i):
    # Solution set loaded from fixture
    Rsh = fixture_v_from_i['Rsh']
    Rs = fixture_v_from_i['Rs']
    nNsVth = fixture_v_from_i['nNsVth']
    current = fixture_v_from_i['I']
    I0 = fixture_v_from_i['I0']
    IL = fixture_v_from_i['IL']
    V = fixture_v_from_i['V_expected']

    # Convergence criteria
    atol = 1.e-11

    I_expected = pvsystem.i_from_v(V, IL, I0, Rs, Rsh, nNsVth,
                                   method='lambertw')
    assert_allclose(current, I_expected, atol=atol)

    current = pvsystem.i_from_v(V, IL, I0, Rs, Rsh, nNsVth)

    assert isinstance(current, type(I_expected))
    if isinstance(current, np.ndarray):
        assert isinstance(current.dtype, type(I_expected.dtype))
        assert current.shape == I_expected.shape
    assert_allclose(current, I_expected, atol=atol)


@pytest.fixture(params=[
    {  # Can handle all python scalar inputs
      'Rsh': 20.,
      'Rs': 0.1,
      'nNsVth': 0.5,
      'V': 7.5049875193450521,
      'I0': 6.e-7,
      'IL': 7.,
      'I_expected': 3.
    },
    {  # Can handle all rank-0 array inputs
      'Rsh': np.array(20.),
      'Rs': np.array(0.1),
      'nNsVth': np.array(0.5),
      'V': np.array(7.5049875193450521),
      'I0': np.array(6.e-7),
      'IL': np.array(7.),
      'I_expected': np.array(3.)
    },
    {  # Can handle all rank-1 singleton array inputs
      'Rsh': np.array([20.]),
      'Rs': np.array([0.1]),
      'nNsVth': np.array([0.5]),
      'V': np.array([7.5049875193450521]),
      'I0': np.array([6.e-7]),
      'IL': np.array([7.]),
      'I_expected': np.array([3.])
    },
    {  # Can handle all rank-1 non-singleton array inputs with a zero
      #  series resistance, Rs=0 gives I=IL=Isc at V=0
      'Rsh': np.array([20., 20.]),
      'Rs': np.array([0., 0.1]),
      'nNsVth': np.array([0.5, 0.5]),
      'V': np.array([0., 7.5049875193450521]),
      'I0': np.array([6.e-7, 6.e-7]),
      'IL': np.array([7., 7.]),
      'I_expected': np.array([7., 3.])
    },
    {  # Can handle mixed inputs with a rank-2 array with zero series
      #  resistance, Rs=0 gives I=IL=Isc at V=0
      'Rsh': np.array([20.]),
      'Rs': np.array([[0., 0.], [0., 0.]]),
      'nNsVth': np.array(0.5),
      'V': 0.,
      'I0': np.array([6.e-7]),
      'IL': np.array([7.]),
      'I_expected': np.array([[7., 7.], [7., 7.]])
    },
    {  # Can handle ideal series and shunt, Rsh=inf and Rs=0 give
      #  V_oc = nNsVth*(np.log(IL + I0) - np.log(I0))
      'Rsh': np.inf,
      'Rs': 0.,
      'nNsVth': 0.5,
      'V': np.array([0., 0.5*(np.log(7. + 6.e-7) - np.log(6.e-7))/2.,
                     0.5*(np.log(7. + 6.e-7) - np.log(6.e-7))]),
      'I0': 6.e-7,
      'IL': 7.,
      'I_expected': np.array([7., 7. - 6.e-7*np.expm1((np.log(7. + 6.e-7) -
                              np.log(6.e-7))/2.), 0.])
    },
    {  # Can handle only ideal shunt resistance, no closed form solution
      'Rsh': np.inf,
      'Rs': 0.1,
      'nNsVth': 0.5,
      'V': 7.5049875193450521,
      'I0': 6.e-7,
      'IL': 7.,
      'I_expected': 3.2244873645510923
    }])
def fixture_i_from_v(request):
    return request.param


@pytest.mark.parametrize(
    'method, atol', [
        ('lambertw', 1e-11), ('brentq', 1e-11), ('newton', 1e-11),
        pytest.param("chandrupatla", 1e-11,
                     marks=pytest.mark.skipif(not chandrupatla_available,
                                              reason="needs scipy 1.15")),
    ]
)
def test_i_from_v(fixture_i_from_v, method, atol):
    # Solution set loaded from fixture
    Rsh = fixture_i_from_v['Rsh']
    Rs = fixture_i_from_v['Rs']
    nNsVth = fixture_i_from_v['nNsVth']
    V = fixture_i_from_v['V']
    I0 = fixture_i_from_v['I0']
    IL = fixture_i_from_v['IL']
    I_expected = fixture_i_from_v['I_expected']

    current = pvsystem.i_from_v(V, IL, I0, Rs, Rsh, nNsVth, method=method)

    assert isinstance(current, type(I_expected))
    if isinstance(current, np.ndarray):
        assert isinstance(current.dtype, type(I_expected.dtype))
        assert current.shape == I_expected.shape
    assert_allclose(current, I_expected, atol=atol)


def test_PVSystem_i_from_v(mocker):
    system = pvsystem.PVSystem()
    m = mocker.patch('pvlib.pvsystem.i_from_v', autospec=True)
    args = (7.5049875193450521, 7, 6e-7, 0.1, 20, 0.5)
    system.i_from_v(*args)
    m.assert_called_once_with(*args)


@pytest.mark.parametrize('method', ['lambertw', 'brentq', 'newton',
                                    chandrupatla])
def test_i_from_v_size(method):
    if method == 'newton':
        args = ([7.5] * 3, np.array([7., 7.]), 6e-7, 0.1, 20, 0.5)
    else:
        args = ([7.5] * 3, 7., 6e-7, [0.1] * 2, 20, 0.5)
    with pytest.raises(ValueError):
        pvsystem.i_from_v(*args, method=method)


@pytest.mark.parametrize('method', ['lambertw', 'brentq', 'newton',
                                    chandrupatla])
def test_v_from_i_size(method):
    if method == 'newton':
        args = ([3.] * 3, np.array([7., 7.]), 6e-7, [0.1], 20, 0.5)
    else:
        args = ([3.] * 3, 7., 6e-7, [0.1] * 2, 20, 0.5)
    with pytest.raises(ValueError):
        pvsystem.v_from_i(*args, method=method)


@pytest.mark.parametrize('method', ['brentq', 'newton', chandrupatla])
def test_mpp_floats(method):
    """test max_power_point"""
    IL, I0, Rs, Rsh, nNsVth = (7, 6e-7, .1, 20, .5)
    out = pvsystem.max_power_point(IL, I0, Rs, Rsh, nNsVth, method=method)
    expected = {'i_mp': 6.1362673597376753,  # 6.1390251797935704, lambertw
                'v_mp': 6.2243393757884284,  # 6.221535886625464, lambertw
                'p_mp': 38.194210547580511}  # 38.194165464983037} lambertw
    assert isinstance(out, dict)
    for k, v in out.items():
        assert np.isclose(v, expected[k])


@pytest.mark.parametrize('method', ['brentq', 'newton', chandrupatla])
def test_mpp_recombination(method):
    """test max_power_point"""
    pvsyst_fs_495 = get_pvsyst_fs_495()
    IL, I0, Rs, Rsh, nNsVth = pvsystem.calcparams_pvsyst(
        effective_irradiance=pvsyst_fs_495['irrad_ref'],
        temp_cell=pvsyst_fs_495['temp_ref'],
        alpha_sc=pvsyst_fs_495['alpha_sc'],
        gamma_ref=pvsyst_fs_495['gamma_ref'],
        mu_gamma=pvsyst_fs_495['mu_gamma'], I_L_ref=pvsyst_fs_495['I_L_ref'],
        I_o_ref=pvsyst_fs_495['I_o_ref'], R_sh_ref=pvsyst_fs_495['R_sh_ref'],
        R_sh_0=pvsyst_fs_495['R_sh_0'], R_sh_exp=pvsyst_fs_495['R_sh_exp'],
        R_s=pvsyst_fs_495['R_s'],
        cells_in_series=pvsyst_fs_495['cells_in_series'],
        EgRef=pvsyst_fs_495['EgRef'])
    out = pvsystem.max_power_point(
        IL, I0, Rs, Rsh, nNsVth,
        d2mutau=pvsyst_fs_495['d2mutau'],
        NsVbi=VOLTAGE_BUILTIN*pvsyst_fs_495['cells_in_series'],
        method=method)
    expected_imp = pvsyst_fs_495['I_mp_ref']
    expected_vmp = pvsyst_fs_495['V_mp_ref']
    expected_pmp = expected_imp*expected_vmp
    expected = {'i_mp': expected_imp,
                'v_mp': expected_vmp,
                'p_mp': expected_pmp}
    assert isinstance(out, dict)
    for k, v in out.items():
        assert np.isclose(v, expected[k], 0.01)


@pytest.mark.parametrize('method', ['brentq', 'newton', chandrupatla])
def test_mpp_array(method):
    """test max_power_point"""
    IL, I0, Rs, Rsh, nNsVth = (np.array([7, 7]), 6e-7, .1, 20, .5)
    out = pvsystem.max_power_point(IL, I0, Rs, Rsh, nNsVth, method=method)
    expected = {'i_mp': [6.1362673597376753] * 2,
                'v_mp': [6.2243393757884284] * 2,
                'p_mp': [38.194210547580511] * 2}
    assert isinstance(out, dict)
    for k, v in out.items():
        assert np.allclose(v, expected[k])


@pytest.mark.parametrize('method', ['brentq', 'newton', chandrupatla])
def test_mpp_series(method):
    """test max_power_point"""
    idx = ['2008-02-17T11:30:00-0800', '2008-02-17T12:30:00-0800']
    IL, I0, Rs, Rsh, nNsVth = (np.array([7, 7]), 6e-7, .1, 20, .5)
    IL = pd.Series(IL, index=idx)
    out = pvsystem.max_power_point(IL, I0, Rs, Rsh, nNsVth, method=method)
    expected = pd.DataFrame({'i_mp': [6.1362673597376753] * 2,
                             'v_mp': [6.2243393757884284] * 2,
                             'p_mp': [38.194210547580511] * 2},
                            index=idx)
    assert isinstance(out, pd.DataFrame)
    for k, v in out.items():
        assert np.allclose(v, expected[k])


def test_singlediode_series(cec_module_params):
    times = pd.date_range(start='2015-01-01', periods=2, freq='12h')
    effective_irradiance = pd.Series([0.0, 800.0], index=times)
    IL, I0, Rs, Rsh, nNsVth = pvsystem.calcparams_desoto(
        effective_irradiance,
        temp_cell=25,
        alpha_sc=cec_module_params['alpha_sc'],
        a_ref=cec_module_params['a_ref'],
        I_L_ref=cec_module_params['I_L_ref'],
        I_o_ref=cec_module_params['I_o_ref'],
        R_sh_ref=cec_module_params['R_sh_ref'],
        R_s=cec_module_params['R_s'],
        EgRef=1.121,
        dEgdT=-0.0002677
    )
    out = pvsystem.singlediode(IL, I0, Rs, Rsh, nNsVth)
    assert isinstance(out, pd.DataFrame)


def test_singlediode_array():
    # github issue 221
    photocurrent = np.linspace(0, 10, 11)
    resistance_shunt = 16
    resistance_series = 0.094
    nNsVth = 0.473
    saturation_current = 1.943e-09

    sd = pvsystem.singlediode(photocurrent, saturation_current,
                              resistance_series, resistance_shunt, nNsVth,
                              method='lambertw')

    expected_i = np.array([
        0., 0.54614798740338, 1.435026463529, 2.3621366610078, 3.2953968319952,
        4.2303869378787, 5.1655276691892, 6.1000269648604, 7.0333996177802,
        7.9653036915959, 8.8954716265647])
    expected_v = np.array([
        0., 7.0966259059555, 7.9961986643428, 8.2222496810656, 8.3255927555753,
        8.3766915453915, 8.3988872440242, 8.4027948807891, 8.3941399580559,
        8.3763655188855, 8.3517057522791])

    assert_allclose(sd['i_mp'], expected_i, atol=1e-8)
    assert_allclose(sd['v_mp'], expected_v, atol=1e-8)

    sd = pvsystem.singlediode(photocurrent, saturation_current,
                              resistance_series, resistance_shunt, nNsVth)
    expected = pvsystem.i_from_v(sd['v_mp'], photocurrent, saturation_current,
                                 resistance_series, resistance_shunt, nNsVth,
                                 method='lambertw')
    assert_allclose(sd['i_mp'], expected, atol=1e-8)


def test_singlediode_floats():
    out = pvsystem.singlediode(7., 6.e-7, .1, 20., .5, method='lambertw')
    expected = {'i_xx': 4.264060478,
                'i_mp': 6.136267360,
                'v_oc': 8.106300147,
                'p_mp': 38.19421055,
                'i_x': 6.7558815684,
                'i_sc': 6.965172322,
                'v_mp': 6.224339375,
                'i': None,
                'v': None}
    assert isinstance(out, dict)
    for k, v in out.items():
        if k in ['i', 'v']:
            assert v is None
        else:
            assert_allclose(v, expected[k], atol=1e-6)


def test_singlediode_floats_expected():
    out = pvsystem.singlediode(7., 6e-7, .1, 20., .5, method='lambertw')
    expected = {'i_xx': 4.264060478,
                'i_mp': 6.136267360,
                'v_oc': 8.106300147,
                'p_mp': 38.19421055,
                'i_x': 6.7558815684,
                'i_sc': 6.965172322,
                'v_mp': 6.224339375}
    assert isinstance(out, dict)
    for k, v in out.items():
        assert_allclose(v, expected[k], atol=1e-6)


def test_singlediode_series_expected(cec_module_params):
    times = pd.date_range(start='2015-06-01', periods=3, freq='6h')
    effective_irradiance = pd.Series([0.0, 400.0, 800.0], index=times)
    IL, I0, Rs, Rsh, nNsVth = pvsystem.calcparams_desoto(
                                  effective_irradiance,
                                  temp_cell=25,
                                  alpha_sc=cec_module_params['alpha_sc'],
                                  a_ref=cec_module_params['a_ref'],
                                  I_L_ref=cec_module_params['I_L_ref'],
                                  I_o_ref=cec_module_params['I_o_ref'],
                                  R_sh_ref=cec_module_params['R_sh_ref'],
                                  R_s=cec_module_params['R_s'],
                                  EgRef=1.121,
                                  dEgdT=-0.0002677)

    out = pvsystem.singlediode(IL, I0, Rs, Rsh, nNsVth, method='lambertw')

    expected = OrderedDict([('i_sc', array([0., 3.01079860, 6.00726296])),
                            ('v_oc', array([0., 9.96959733, 10.29603253])),
                            ('i_mp', array([0., 2.656285960, 5.290525645])),
                            ('v_mp', array([0., 8.321092255, 8.409413795])),
                            ('p_mp', array([0., 22.10320053, 44.49021934])),
                            ('i_x', array([0., 2.884132006, 5.746202281])),
                            ('i_xx', array([0., 2.052691562, 3.909673879]))])

    for k, v in out.items():
        assert_allclose(v, expected[k], atol=1e-2)

    out = pvsystem.singlediode(IL, I0, Rs, Rsh, nNsVth)

    expected['i_mp'] = pvsystem.i_from_v(out['v_mp'], IL, I0, Rs, Rsh, nNsVth,
                                         method='lambertw')
    expected['v_mp'] = pvsystem.v_from_i(out['i_mp'], IL, I0, Rs, Rsh, nNsVth,
                                         method='lambertw')

    for k, v in out.items():
        assert_allclose(v, expected[k], atol=1e-6)


def test_scale_voltage_current_power():
    data = pd.DataFrame(
        np.array([[2, 1.5, 10, 8, 12, 0.5, 1.5]]),
        columns=['i_sc', 'i_mp', 'v_oc', 'v_mp', 'p_mp', 'i_x', 'i_xx'],
        index=[0])
    expected = pd.DataFrame(
        np.array([[6, 4.5, 20, 16, 72, 1.5, 4.5]]),
        columns=['i_sc', 'i_mp', 'v_oc', 'v_mp', 'p_mp', 'i_x', 'i_xx'],
        index=[0])
    out = pvsystem.scale_voltage_current_power(data, voltage=2, current=3)
    assert_frame_equal(out, expected, check_less_precise=5)


def test_PVSystem_scale_voltage_current_power(mocker):
    data = None
    system = pvsystem.PVSystem(modules_per_string=2, strings_per_inverter=3)
    m = mocker.patch(
        'pvlib.pvsystem.scale_voltage_current_power', autospec=True)
    system.scale_voltage_current_power(data)
    m.assert_called_once_with(data, voltage=2, current=3)


def test_PVSystem_multi_scale_voltage_current_power(mocker):
    data = (1, 2)
    system = pvsystem.PVSystem(
        arrays=[pvsystem.Array(pvsystem.FixedMount(0, 180),
                               modules_per_string=2, strings=3),
                pvsystem.Array(pvsystem.FixedMount(0, 180),
                               modules_per_string=3, strings=5)]
    )
    m = mocker.patch(
        'pvlib.pvsystem.scale_voltage_current_power', autospec=True
    )
    system.scale_voltage_current_power(data)
    m.assert_has_calls(
        [mock.call(1, voltage=2, current=3),
         mock.call(2, voltage=3, current=5)],
        any_order=True
    )
    with pytest.raises(ValueError,
                       match="Length mismatch for per-array parameter"):
        system.scale_voltage_current_power(None)


def test_PVSystem_get_ac_sandia(cec_inverter_parameters, mocker):
    inv_fun = mocker.spy(inverter, 'sandia')
    system = pvsystem.PVSystem(
        inverter=cec_inverter_parameters['Name'],
        inverter_parameters=cec_inverter_parameters,
    )
    vdcs = pd.Series(np.linspace(0, 50, 3))
    idcs = pd.Series(np.linspace(0, 11, 3))
    pdcs = idcs * vdcs
    pacs = system.get_ac('sandia', pdcs, v_dc=vdcs)
    inv_fun.assert_called_once()
    assert_series_equal(pacs, pd.Series([-0.020000, 132.004308, 250.000000]))


def test_PVSystem_get_ac_sandia_multi(cec_inverter_parameters, mocker):
    inv_fun = mocker.spy(inverter, 'sandia_multi')
    system = pvsystem.PVSystem(
        arrays=[pvsystem.Array(pvsystem.FixedMount(0, 180)),
                pvsystem.Array(pvsystem.FixedMount(0, 180))],
        inverter=cec_inverter_parameters['Name'],
        inverter_parameters=cec_inverter_parameters,
    )
    vdcs = pd.Series(np.linspace(0, 50, 3))
    idcs = pd.Series(np.linspace(0, 11, 3)) / 2
    pdcs = idcs * vdcs
    pacs = system.get_ac('sandia', (pdcs, pdcs), v_dc=(vdcs, vdcs))
    inv_fun.assert_called_once()
    assert_series_equal(pacs, pd.Series([-0.020000, 132.004308, 250.000000]))
    with pytest.raises(ValueError,
                       match="Length mismatch for per-array parameter"):
        system.get_ac('sandia', vdcs, (pdcs, pdcs))
    with pytest.raises(ValueError,
                       match="Length mismatch for per-array parameter"):
        system.get_ac('sandia', vdcs, (pdcs,))
    with pytest.raises(ValueError,
                       match="Length mismatch for per-array parameter"):
        system.get_ac('sandia', (vdcs, vdcs), (pdcs, pdcs, pdcs))


def test_PVSystem_get_ac_pvwatts(pvwatts_system_defaults, mocker):
    mocker.spy(inverter, 'pvwatts')
    pdc = 50
    out = pvwatts_system_defaults.get_ac('pvwatts', pdc)
    inverter.pvwatts.assert_called_once_with(
        pdc, **pvwatts_system_defaults.inverter_parameters)
    assert out < pdc


def test_PVSystem_get_ac_pvwatts_kwargs(pvwatts_system_kwargs, mocker):
    mocker.spy(inverter, 'pvwatts')
    pdc = 50
    out = pvwatts_system_kwargs.get_ac('pvwatts', pdc)
    inverter.pvwatts.assert_called_once_with(
        pdc, **pvwatts_system_kwargs.inverter_parameters)
    assert out < pdc


def test_PVSystem_get_ac_pvwatts_multi(
        pvwatts_system_defaults, pvwatts_system_kwargs, mocker):
    mocker.spy(inverter, 'pvwatts_multi')
    expected = [pd.Series([0.0, 48.123524, 86.400000]),
                pd.Series([0.0, 45.893550, 85.500000])]
    systems = [pvwatts_system_defaults, pvwatts_system_kwargs]
    for base_sys, exp in zip(systems, expected):
        system = pvsystem.PVSystem(
            arrays=[pvsystem.Array(pvsystem.FixedMount(0, 180)),
                    pvsystem.Array(pvsystem.FixedMount(0, 180),)],
            inverter_parameters=base_sys.inverter_parameters,
        )
        pdcs = pd.Series([0., 25., 50.])
        pacs = system.get_ac('pvwatts', (pdcs, pdcs))
        assert_series_equal(pacs, exp)
    assert inverter.pvwatts_multi.call_count == 2
    with pytest.raises(ValueError,
                       match="Length mismatch for per-array parameter"):
        system.get_ac('pvwatts', (pdcs,))
    with pytest.raises(ValueError,
                       match="Length mismatch for per-array parameter"):
        system.get_ac('pvwatts', pdcs)
    with pytest.raises(ValueError,
                       match="Length mismatch for per-array parameter"):
        system.get_ac('pvwatts', (pdcs, pdcs, pdcs))


@pytest.mark.parametrize('model', ['sandia', 'adr', 'pvwatts'])
def test_PVSystem_get_ac_single_array_tuple_input(
        model,
        pvwatts_system_defaults,
        cec_inverter_parameters,
        adr_inverter_parameters):
    vdcs = {
        'sandia': pd.Series(np.linspace(0, 50, 3)),
        'pvwatts': None,
        'adr': pd.Series([135, 154, 390, 420, 551])
    }
    pdcs = {'adr': pd.Series([135, 1232, 1170, 420, 551]),
            'sandia': pd.Series(np.linspace(0, 11, 3)) * vdcs['sandia'],
            'pvwatts': 50}
    inverter_parameters = {
        'sandia': cec_inverter_parameters,
        'adr': adr_inverter_parameters,
        'pvwatts': pvwatts_system_defaults.inverter_parameters
    }
    expected = {
        'adr': pd.Series([np.nan, 1161.5745, 1116.4459, 382.6679, np.nan]),
        'sandia': pd.Series([-0.020000, 132.004308, 250.000000])
    }
    system = pvsystem.PVSystem(
        arrays=[pvsystem.Array(pvsystem.FixedMount(0, 180))],
        inverter_parameters=inverter_parameters[model]
    )
    ac = system.get_ac(p_dc=(pdcs[model],), v_dc=(vdcs[model],), model=model)
    if model == 'pvwatts':
        assert ac < pdcs['pvwatts']
    else:
        assert_series_equal(ac, expected[model])


def test_PVSystem_get_ac_adr(adr_inverter_parameters, mocker):
    mocker.spy(inverter, 'adr')
    system = pvsystem.PVSystem(
        inverter_parameters=adr_inverter_parameters,
    )
    vdcs = pd.Series([135, 154, 390, 420, 551])
    pdcs = pd.Series([135, 1232, 1170, 420, 551])
    pacs = system.get_ac('adr', pdcs, vdcs)
    assert_series_equal(pacs, pd.Series([np.nan, 1161.5745, 1116.4459,
                                         382.6679, np.nan]))
    inverter.adr.assert_called_once_with(vdcs, pdcs,
                                         system.inverter_parameters)


def test_PVSystem_get_ac_adr_multi(adr_inverter_parameters):
    system = pvsystem.PVSystem(
        arrays=[pvsystem.Array(pvsystem.FixedMount(0, 180)),
                pvsystem.Array(pvsystem.FixedMount(0, 180))],
        inverter_parameters=adr_inverter_parameters,
    )
    pdcs = pd.Series([135, 1232, 1170, 420, 551])
    with pytest.raises(ValueError,
                       match="The adr inverter function cannot be used"):
        system.get_ac(model='adr', p_dc=pdcs)


def test_PVSystem_get_ac_invalid(cec_inverter_parameters):
    system = pvsystem.PVSystem(
        inverter_parameters=cec_inverter_parameters,
    )
    pdcs = pd.Series(np.linspace(0, 50, 3))
    with pytest.raises(ValueError, match="is not a valid AC power model"):
        system.get_ac(model='not_a_model', p_dc=pdcs)


def test_PVSystem_creation():
    pv_system = pvsystem.PVSystem(module='blah', inverter='blarg')
    # ensure that parameter attributes are dict-like. GH 294
    pv_system.inverter_parameters['Paco'] = 1


def test_PVSystem_multiple_array_creation():
    array_one = pvsystem.Array(pvsystem.FixedMount(surface_tilt=32))
    array_two = pvsystem.Array(pvsystem.FixedMount(surface_tilt=15),
                               module_parameters={'pdc0': 1})
    pv_system = pvsystem.PVSystem(arrays=[array_one, array_two])
    assert pv_system.arrays[0].module_parameters == {}
    assert pv_system.arrays[1].module_parameters == {'pdc0': 1}
    assert pv_system.arrays == (array_one, array_two)


def test_PVSystem_get_aoi():
    system = pvsystem.PVSystem(surface_tilt=32, surface_azimuth=135)
    aoi = system.get_aoi(30, 225)
    assert np.round(aoi, 4) == 42.7408


def test_PVSystem_multiple_array_get_aoi():
    system = pvsystem.PVSystem(
        arrays=[pvsystem.Array(pvsystem.FixedMount(surface_tilt=15,
                                                   surface_azimuth=135)),
                pvsystem.Array(pvsystem.FixedMount(surface_tilt=32,
                                                   surface_azimuth=135))]
    )
    aoi_one, aoi_two = system.get_aoi(30, 225)
    assert np.round(aoi_two, 4) == 42.7408
    assert aoi_two != aoi_one
    assert aoi_one > 0


@pytest.fixture
def solar_pos():
    times = pd.date_range(start='20160101 1200-0700',
                          end='20160101 1800-0700', freq='6h')
    location = Location(latitude=32, longitude=-111)
    return location.get_solarposition(times)


def test_PVSystem_get_irradiance(solar_pos):
    system = pvsystem.PVSystem(surface_tilt=32, surface_azimuth=135)
    irrads = pd.DataFrame({'dni':[900,0], 'ghi':[600,0], 'dhi':[100,0]},
                          index=solar_pos.index)

    irradiance = system.get_irradiance(solar_pos['apparent_zenith'],
                                       solar_pos['azimuth'],
                                       irrads['dni'],
                                       irrads['ghi'],
                                       irrads['dhi'])
    expected = pd.DataFrame(data=np.array(
        [[883.65494055, 745.86141676, 137.79352379, 126.397131, 11.39639279],
         [0., -0., 0., 0., 0.]]),
                            columns=['poa_global', 'poa_direct',
                                     'poa_diffuse', 'poa_sky_diffuse',
                                     'poa_ground_diffuse'],
                            index=solar_pos.index)
    assert_frame_equal(irradiance, expected, check_less_precise=2)


def test_PVSystem_get_irradiance_float():
    system = pvsystem.PVSystem(surface_tilt=32, surface_azimuth=135)
    irrads = {'dni': 900., 'ghi': 600., 'dhi': 100.}
    zenith = 55.366831
    azimuth = 172.320038
    irradiance = system.get_irradiance(zenith,
                                       azimuth,
                                       irrads['dni'],
                                       irrads['ghi'],
                                       irrads['dhi'])
    expected = {'poa_global': 884.80903423, 'poa_direct': 745.84258835,
                'poa_diffuse': 138.96644588, 'poa_sky_diffuse': 127.57005309,
                'poa_ground_diffuse': 11.39639279}
    for k, v in irradiance.items():
        assert np.isclose(v, expected[k], rtol=1e-6)


def test_PVSystem_get_irradiance_albedo(solar_pos):
    system = pvsystem.PVSystem(surface_tilt=32, surface_azimuth=135)
    irrads = pd.DataFrame({'dni': [900, 0], 'ghi': [600, 0], 'dhi': [100, 0],
                           'albedo': [0.5, 0.5]},
                          index=solar_pos.index)
    # albedo as a Series
    irradiance = system.get_irradiance(solar_pos['apparent_zenith'],
                                       solar_pos['azimuth'],
                                       irrads['dni'],
                                       irrads['ghi'],
                                       irrads['dhi'],
                                       albedo=irrads['albedo'])
    expected = pd.DataFrame(data=np.array(
        [[895.05134334, 745.86141676, 149.18992658, 126.397131, 22.79279558],
         [0., -0., 0., 0., 0.]]),
        columns=['poa_global', 'poa_direct', 'poa_diffuse', 'poa_sky_diffuse',
                 'poa_ground_diffuse'],
        index=solar_pos.index)
    assert_frame_equal(irradiance, expected, check_less_precise=2)


def test_PVSystem_get_irradiance_model(mocker, solar_pos):
    spy_perez = mocker.spy(irradiance, 'perez')
    spy_haydavies = mocker.spy(irradiance, 'haydavies')
    system = pvsystem.PVSystem(surface_tilt=32, surface_azimuth=135)
    irrads = pd.DataFrame({'dni': [900, 0], 'ghi': [600, 0], 'dhi': [100, 0]},
                          index=solar_pos.index)
    system.get_irradiance(solar_pos['apparent_zenith'],
                          solar_pos['azimuth'],
                          irrads['dni'],
                          irrads['ghi'],
                          irrads['dhi'])
    spy_haydavies.assert_called_once()
    system.get_irradiance(solar_pos['apparent_zenith'],
                          solar_pos['azimuth'],
                          irrads['dni'],
                          irrads['ghi'],
                          irrads['dhi'],
                          model='perez')
    spy_perez.assert_called_once()


def test_PVSystem_multi_array_get_irradiance(solar_pos):
    array_one = pvsystem.Array(pvsystem.FixedMount(surface_tilt=32,
                                                   surface_azimuth=135))
    array_two = pvsystem.Array(pvsystem.FixedMount(surface_tilt=5,
                                                   surface_azimuth=150))
    system = pvsystem.PVSystem(arrays=[array_one, array_two])

    irrads = pd.DataFrame({'dni': [900, 0], 'ghi': [600, 0], 'dhi': [100, 0]},
                          index=solar_pos.index)
    array_one_expected = array_one.get_irradiance(
        solar_pos['apparent_zenith'],
        solar_pos['azimuth'],
        irrads['dni'], irrads['ghi'], irrads['dhi']
    )
    array_two_expected = array_two.get_irradiance(
        solar_pos['apparent_zenith'],
        solar_pos['azimuth'],
        irrads['dni'], irrads['ghi'], irrads['dhi']
    )
    array_one_irrad, array_two_irrad = system.get_irradiance(
        solar_pos['apparent_zenith'],
        solar_pos['azimuth'],
        irrads['dni'], irrads['ghi'], irrads['dhi']
    )
    assert_frame_equal(
        array_one_irrad, array_one_expected, check_less_precise=2
    )
    assert_frame_equal(
        array_two_irrad, array_two_expected, check_less_precise=2
    )


def test_PVSystem_multi_array_get_irradiance_multi_irrad(solar_pos):
    """Test a system with two identical arrays but different irradiance.

    Because only the irradiance is different we expect the same output
    when only one GHI/DHI/DNI input is given, but different output
    for each array when different GHI/DHI/DNI input is given. For the later
    case we verify that the correct irradiance data is passed to each array.
    """
    array_one = pvsystem.Array(pvsystem.FixedMount(0, 180))
    array_two = pvsystem.Array(pvsystem.FixedMount(0, 180))
    system = pvsystem.PVSystem(arrays=[array_one, array_two])

    irrads = pd.DataFrame({'dni': [900, 0], 'ghi': [600, 0], 'dhi': [100, 0]},
                          index=solar_pos.index)
    irrads_two = pd.DataFrame(
        {'dni': [0, 900], 'ghi': [0, 600], 'dhi': [0, 100]},
        index=solar_pos.index
    )
    array_irrad = system.get_irradiance(
        solar_pos['apparent_zenith'],
        solar_pos['azimuth'],
        (irrads['dhi'], irrads['dhi']),
        (irrads['ghi'], irrads['ghi']),
        (irrads['dni'], irrads['dni'])
    )
    assert_frame_equal(array_irrad[0], array_irrad[1])
    array_irrad = system.get_irradiance(
        solar_pos['apparent_zenith'],
        solar_pos['azimuth'],
        (irrads['dhi'], irrads_two['dhi']),
        (irrads['ghi'], irrads_two['ghi']),
        (irrads['dni'], irrads_two['dni'])
    )
    array_one_expected = array_one.get_irradiance(
        solar_pos['apparent_zenith'],
        solar_pos['azimuth'],
        irrads['dhi'], irrads['ghi'], irrads['dni']
    )
    array_two_expected = array_two.get_irradiance(
        solar_pos['apparent_zenith'],
        solar_pos['azimuth'],
        irrads_two['dhi'], irrads_two['ghi'], irrads_two['dni']
    )
    assert not array_irrad[0].equals(array_irrad[1])
    assert_frame_equal(array_irrad[0], array_one_expected)
    assert_frame_equal(array_irrad[1], array_two_expected)
    with pytest.raises(ValueError,
                       match="Length mismatch for per-array parameter"):
        system.get_irradiance(
            solar_pos['apparent_zenith'],
            solar_pos['azimuth'],
            (irrads['dhi'], irrads_two['dhi'], irrads['dhi']),
            (irrads['ghi'], irrads_two['ghi']),
            irrads['dni']
        )
    array_irrad = system.get_irradiance(
        solar_pos['apparent_zenith'],
        solar_pos['azimuth'],
        (irrads['dhi'], irrads_two['dhi']),
        irrads['ghi'],
        irrads['dni']
    )
    assert_frame_equal(array_irrad[0], array_one_expected)
    assert not array_irrad[0].equals(array_irrad[1])


def test_Array_get_irradiance(solar_pos):
    array = pvsystem.Array(pvsystem.FixedMount(surface_tilt=32,
                                               surface_azimuth=135))
    irrads = pd.DataFrame({'dni': [900, 0], 'ghi': [600, 0], 'dhi': [100, 0]},
                          index=solar_pos.index)
    # defaults for kwargs
    modeled = array.get_irradiance(
        solar_pos['apparent_zenith'],
        solar_pos['azimuth'],
        irrads['dni'], irrads['ghi'], irrads['dhi']
    )
    expected = pd.DataFrame(
        data=np.array(
            [[883.65494055, 745.86141676, 137.79352379, 126.397131,
              11.39639279],
             [0., -0., 0., 0., 0.]]),
        columns=['poa_global', 'poa_direct', 'poa_diffuse', 'poa_sky_diffuse',
                 'poa_ground_diffuse'],
        index=solar_pos.index
    )
    assert_frame_equal(modeled, expected, check_less_precise=5)
    # with specified kwargs, use isotropic sky diffuse because it's easier
    modeled = array.get_irradiance(
        solar_pos['apparent_zenith'],
        solar_pos['azimuth'],
        irrads['dni'], irrads['ghi'], irrads['dhi'],
        albedo=0.5, model='isotropic'
    )
    sky_diffuse = irradiance.isotropic(array.mount.surface_tilt, irrads['dhi'])
    ground_diff = irradiance.get_ground_diffuse(
        array.mount.surface_tilt, irrads['ghi'], 0.5, surface_type=None)
    aoi = irradiance.aoi(array.mount.surface_tilt, array.mount.surface_azimuth,
                         solar_pos['apparent_zenith'], solar_pos['azimuth'])
    direct = irrads['dni'] * cosd(aoi)
    expected = sky_diffuse + ground_diff + direct
    assert_series_equal(expected, expected, check_less_precise=5)


def test_PVSystem___repr__():
    system = pvsystem.PVSystem(
        module='blah', inverter='blarg', name='pv ftw',
        temperature_model_parameters={'a': -3.56})

    expected = """PVSystem:
  name: pv ftw
  Array:
    name: None
    mount: FixedMount(surface_tilt=0, surface_azimuth=180, racking_model=None, module_height=None)
    module: blah
    albedo: 0.25
    module_type: None
    temperature_model_parameters: {'a': -3.56}
    strings: 1
    modules_per_string: 1
  inverter: blarg"""  # noqa: E501
    assert system.__repr__() == expected


def test_PVSystem_multi_array___repr__():
    system = pvsystem.PVSystem(
        arrays=[pvsystem.Array(pvsystem.FixedMount(surface_tilt=30,
                                                   surface_azimuth=100)),
                pvsystem.Array(pvsystem.FixedMount(surface_tilt=20,
                                                   surface_azimuth=220),
                               name='foo')],
        inverter='blarg',
    )
    expected = """PVSystem:
  name: None
  Array:
    name: None
    mount: FixedMount(surface_tilt=30, surface_azimuth=100, racking_model=None, module_height=None)
    module: None
    albedo: 0.25
    module_type: None
    temperature_model_parameters: {}
    strings: 1
    modules_per_string: 1
  Array:
    name: foo
    mount: FixedMount(surface_tilt=20, surface_azimuth=220, racking_model=None, module_height=None)
    module: None
    albedo: 0.25
    module_type: None
    temperature_model_parameters: {}
    strings: 1
    modules_per_string: 1
  inverter: blarg"""  # noqa: E501
    assert expected == system.__repr__()


def test_Array___repr__():
    array = pvsystem.Array(
        mount=pvsystem.FixedMount(surface_tilt=10, surface_azimuth=100,
                                  racking_model='close_mount'),
        albedo=0.15, module_type='glass_glass',
        temperature_model_parameters={'a': -3.56},
        module_parameters={'foo': 'bar'},
        modules_per_string=100,
        strings=10, module='baz',
        name='biz'
    )
    expected = """Array:
  name: biz
  mount: FixedMount(surface_tilt=10, surface_azimuth=100, racking_model='close_mount', module_height=None)
  module: baz
  albedo: 0.15
  module_type: glass_glass
  temperature_model_parameters: {'a': -3.56}
  strings: 10
  modules_per_string: 100"""  # noqa: E501
    assert array.__repr__() == expected


def test_pvwatts_dc_scalars():
    expected = 88.65
    out = pvsystem.pvwatts_dc(900, 30, 100, -0.003)
    assert_allclose(out, expected)


def test_pvwatts_dc_arrays():
    irrad_trans = np.array([np.nan, 900, 900])
    temp_cell = np.array([30, np.nan, 30])
    irrad_trans, temp_cell = np.meshgrid(irrad_trans, temp_cell)
    expected = np.array([[nan,  88.65,  88.65],
                         [nan,    nan,    nan],
                         [nan,  88.65,  88.65]])
    out = pvsystem.pvwatts_dc(irrad_trans, temp_cell, 100, -0.003)
    assert_allclose(out, expected, equal_nan=True)


def test_pvwatts_dc_series():
    irrad_trans = pd.Series([np.nan, 900, 900])
    temp_cell = pd.Series([30, np.nan, 30])
    expected = pd.Series(np.array([   nan,    nan,  88.65]))
    out = pvsystem.pvwatts_dc(irrad_trans, temp_cell, 100, -0.003)
    assert_series_equal(expected, out)


def test_pvwatts_dc_scalars_with_k():
    expected = 8.9125
    out = pvsystem.pvwatts_dc(100, 30, 100, -0.003, k=0.01)
    assert_allclose(out, expected)


def test_pvwatts_dc_arrays_with_k():
    irrad_trans = np.array([np.nan, 100, 1200])
    temp_cell = np.array([30, np.nan, 30])
    irrad_trans, temp_cell = np.meshgrid(irrad_trans, temp_cell)
    expected = np.array([[nan,  8.9125,  118.45],
                         [nan,    nan,    nan],
                         [nan,  8.9125,  118.45]])
    out = pvsystem.pvwatts_dc(irrad_trans, temp_cell, 100, -0.003, k=0.01)
    assert_allclose(out, expected, equal_nan=True)


def test_pvwatts_dc_series_with_k():
    irrad_trans = pd.Series([np.nan, 100, 100, 1200])
    temp_cell = pd.Series([30, np.nan, 30, 30])
    expected = pd.Series(np.array([   nan,    nan,  8.9125, 118.45]))
    out = pvsystem.pvwatts_dc(irrad_trans, temp_cell, 100, -0.003, k=0.01)
    assert_series_equal(expected, out)


def test_pvwatts_dc_with_k_and_cap_adjustment():
    irrad_trans = [100, 1200]
    temp_cell = 25
    out = []
    expected = [0, 120.0]
    for irrad in irrad_trans:
        out.append(pvsystem.pvwatts_dc(irrad, temp_cell, 100, -0.003, k=0.15,
                                       cap_adjustment=True))
    assert_allclose(out, expected)


def test_pvwatts_dc_arrays_with_k_and_cap_adjustment():
    irrad_trans = np.array([np.nan, 100, 1200])
    temp_cell = np.array([30, np.nan, 30])
    irrad_trans, temp_cell = np.meshgrid(irrad_trans, temp_cell)
    expected = np.array([[nan,  8.9125,  118.2],
                         [nan,    nan,    nan],
                         [nan,  8.9125,  118.2]])
    out = pvsystem.pvwatts_dc(irrad_trans, temp_cell, 100, -0.003, k=0.01,
                              cap_adjustment=True)
    assert_allclose(out, expected, equal_nan=True)


def test_pvwatts_losses_default():
    expected = 14.075660688264469
    out = pvsystem.pvwatts_losses()
    assert_allclose(out, expected)


def test_pvwatts_losses_arrays():
    expected = np.array([nan, 14.934904])
    age = np.array([nan, 1])
    out = pvsystem.pvwatts_losses(age=age)
    assert_allclose(out, expected)


def test_pvwatts_losses_series():
    expected = pd.Series([nan, 14.934904])
    age = pd.Series([nan, 1])
    out = pvsystem.pvwatts_losses(age=age)
    assert_series_equal(expected, out)


@pytest.fixture
def pvwatts_system_defaults():
    module_parameters = {'pdc0': 100, 'gamma_pdc': -0.003}
    inverter_parameters = {'pdc0': 90}
    system = pvsystem.PVSystem(module_parameters=module_parameters,
                               inverter_parameters=inverter_parameters)
    return system


@pytest.fixture
def pvwatts_system_kwargs():
    module_parameters = {'pdc0': 100, 'gamma_pdc': -0.003, 'temp_ref': 20}
    inverter_parameters = {'pdc0': 90, 'eta_inv_nom': 0.95, 'eta_inv_ref': 1.0}
    system = pvsystem.PVSystem(module_parameters=module_parameters,
                               inverter_parameters=inverter_parameters)
    return system


def test_PVSystem_pvwatts_dc(pvwatts_system_defaults, mocker):
    mocker.spy(pvsystem, 'pvwatts_dc')
    irrad = 900
    temp_cell = 30
    expected = 90
    out = pvwatts_system_defaults.pvwatts_dc(irrad, temp_cell)
    pvsystem.pvwatts_dc.assert_called_once_with(
        irrad, temp_cell,
        **pvwatts_system_defaults.arrays[0].module_parameters)
    assert_allclose(expected, out, atol=10)


def test_PVSystem_pvwatts_dc_kwargs(pvwatts_system_kwargs, mocker):
    mocker.spy(pvsystem, 'pvwatts_dc')
    irrad = 900
    temp_cell = 30
    expected = 90
    out = pvwatts_system_kwargs.pvwatts_dc(irrad, temp_cell)
    pvsystem.pvwatts_dc.assert_called_once_with(
        irrad, temp_cell, **pvwatts_system_kwargs.arrays[0].module_parameters)
    assert_allclose(expected, out, atol=10)


def test_PVSystem_multiple_array_pvwatts_dc():
    array_one_module_parameters = {
        'pdc0': 100, 'gamma_pdc': -0.003, 'temp_ref': 20
    }
    array_one = pvsystem.Array(
        pvsystem.FixedMount(0, 180),
        module_parameters=array_one_module_parameters
    )
    array_two_module_parameters = {
        'pdc0': 150, 'gamma_pdc': -0.002, 'temp_ref': 25
    }
    array_two = pvsystem.Array(
        pvsystem.FixedMount(0, 180),
        module_parameters=array_two_module_parameters
    )
    system = pvsystem.PVSystem(arrays=[array_one, array_two])
    irrad_one = 900
    irrad_two = 500
    temp_cell_one = 30
    temp_cell_two = 20
    expected_one = pvsystem.pvwatts_dc(irrad_one, temp_cell_one,
                                       **array_one_module_parameters)
    expected_two = pvsystem.pvwatts_dc(irrad_two, temp_cell_two,
                                       **array_two_module_parameters)
    dc_one, dc_two = system.pvwatts_dc((irrad_one, irrad_two),
                                       (temp_cell_one, temp_cell_two))
    assert dc_one == expected_one
    assert dc_two == expected_two


def test_PVSystem_multiple_array_pvwatts_dc_value_error():
    system = pvsystem.PVSystem(
        arrays=[pvsystem.Array(pvsystem.FixedMount(0, 180)),
                pvsystem.Array(pvsystem.FixedMount(0, 180)),
                pvsystem.Array(pvsystem.FixedMount(0, 180))]
    )
    error_message = 'Length mismatch for per-array parameter'
    with pytest.raises(ValueError, match=error_message):
        system.pvwatts_dc(10, (1, 1, 1))
    with pytest.raises(ValueError, match=error_message):
        system.pvwatts_dc((10, 10), (1, 1, 1))
    with pytest.raises(ValueError, match=error_message):
        system.pvwatts_dc((10, 10, 10, 10), (1, 1, 1))
    with pytest.raises(ValueError, match=error_message):
        system.pvwatts_dc((1, 1, 1), 1)
    with pytest.raises(ValueError, match=error_message):
        system.pvwatts_dc((1, 1, 1), (1,))
    with pytest.raises(ValueError, match=error_message):
        system.pvwatts_dc((1,), 1)
    with pytest.raises(ValueError, match=error_message):
        system.pvwatts_dc((1, 1, 1, 1), (1, 1))
    with pytest.raises(ValueError, match=error_message):
        system.pvwatts_dc(2, 3)
    with pytest.raises(ValueError, match=error_message):
        # ValueError is raised for non-tuple iterable with correct length
        system.pvwatts_dc((1, 1, 1), pd.Series([1, 2, 3]))


def test_PVSystem_pvwatts_losses(pvwatts_system_defaults, mocker):
    mocker.spy(pvsystem, 'pvwatts_losses')
    age = 1
    pvwatts_system_defaults.losses_parameters = dict(age=age)
    expected = 15
    out = pvwatts_system_defaults.pvwatts_losses()
    pvsystem.pvwatts_losses.assert_called_once_with(age=age)
    assert out < expected


def test_PVSystem_num_arrays():
    system_one = pvsystem.PVSystem()
    system_two = pvsystem.PVSystem(arrays=[
        pvsystem.Array(pvsystem.FixedMount(0, 180)),
        pvsystem.Array(pvsystem.FixedMount(0, 180))])
    assert system_one.num_arrays == 1
    assert system_two.num_arrays == 2


def test_PVSystem_at_least_one_array():
    with pytest.raises(ValueError,
                       match="PVSystem must have at least one Array"):
        pvsystem.PVSystem(arrays=[])


def test_PVSystem_single_array():
    # GH 1831
    single_array = pvsystem.Array(pvsystem.FixedMount())
    system = pvsystem.PVSystem(arrays=single_array)
    assert isinstance(system.arrays, tuple)
    assert system.arrays[0] is single_array


def test_combine_loss_factors():
    test_index = pd.date_range(start='1990/01/01T12:00', periods=365, freq='d')
    loss_1 = pd.Series(.10, index=test_index)
    loss_2 = pd.Series(.05, index=pd.date_range(start='1990/01/01T12:00',
                                                periods=365*2, freq='d'))
    loss_3 = pd.Series(.02, index=pd.date_range(start='1990/01/01',
                                                periods=12, freq='MS'))
    expected = pd.Series(.1621, index=test_index)
    out = pvsystem.combine_loss_factors(test_index, loss_1, loss_2, loss_3)
    assert_series_equal(expected, out)


def test_no_extra_kwargs():
    with pytest.raises(TypeError, match="arbitrary_kwarg"):
        pvsystem.PVSystem(arbitrary_kwarg='value')


def test_AbstractMount_constructor():
    match = "Can't instantiate abstract class AbstractMount"
    with pytest.raises(TypeError, match=match):
        _ = pvsystem.AbstractMount()


@pytest.fixture
def fixed_mount():
    return pvsystem.FixedMount(20, 180)


@pytest.fixture
def single_axis_tracker_mount():
    return pvsystem.SingleAxisTrackerMount(axis_tilt=10, axis_azimuth=170,
                                           max_angle=45, backtrack=False,
                                           gcr=0.4, cross_axis_tilt=-5)


def test_FixedMount_constructor(fixed_mount):
    assert fixed_mount.surface_tilt == 20
    assert fixed_mount.surface_azimuth == 180


def test_FixedMount_get_orientation(fixed_mount):
    expected = {'surface_tilt': 20, 'surface_azimuth': 180}
    assert fixed_mount.get_orientation(45, 130) == expected


def test_SingleAxisTrackerMount_constructor(single_axis_tracker_mount):
    expected = dict(axis_tilt=10, axis_azimuth=170, max_angle=45,
                    backtrack=False, gcr=0.4, cross_axis_tilt=-5)
    for attr_name, expected_value in expected.items():
        assert getattr(single_axis_tracker_mount, attr_name) == expected_value


def test_SingleAxisTrackerMount_get_orientation(single_axis_tracker_mount):
    expected = {'surface_tilt': 19.29835284, 'surface_azimuth': 229.7643755}
    actual = single_axis_tracker_mount.get_orientation(45, 190)
    for key, expected_value in expected.items():
        err_msg = f"{key} value incorrect"
        assert actual[key] == pytest.approx(expected_value), err_msg


def test_SingleAxisTrackerMount_get_orientation_asymmetric_max():
    mount = pvsystem.SingleAxisTrackerMount(max_angle=(-30, 45))
    expected = {'surface_tilt': [45, 30], 'surface_azimuth': [90, 270]}
    actual = mount.get_orientation([60, 60], [90, 270])
    for key, expected_value in expected.items():
        err_msg = f"{key} value incorrect"
        assert actual[key] == pytest.approx(expected_value), err_msg


def test_dc_ohms_from_percent():
    expected = .1425
    out = pvsystem.dc_ohms_from_percent(38, 8, 3, 1, 1)
    assert_allclose(out, expected)


def test_PVSystem_dc_ohms_from_percent(mocker):
    mocker.spy(pvsystem, 'dc_ohms_from_percent')

    expected = .1425
    system = pvsystem.PVSystem(losses_parameters={'dc_ohmic_percent': 3},
                               module_parameters={'I_mp_ref': 8,
                                                  'V_mp_ref': 38})
    out = system.dc_ohms_from_percent()

    pvsystem.dc_ohms_from_percent.assert_called_once_with(
        dc_ohmic_percent=3,
        vmp_ref=38,
        imp_ref=8,
        modules_per_string=1,
        strings=1
    )

    assert_allclose(out, expected)


def test_dc_ohmic_losses():
    expected = 9.12
    out = pvsystem.dc_ohmic_losses(.1425, 8)
    assert_allclose(out, expected)


def test_Array_dc_ohms_from_percent(mocker):
    mocker.spy(pvsystem, 'dc_ohms_from_percent')

    expected = .1425

    array = pvsystem.Array(pvsystem.FixedMount(0, 180),
                           array_losses_parameters={'dc_ohmic_percent': 3},
                           module_parameters={'I_mp_ref': 8,
                                              'V_mp_ref': 38})
    out = array.dc_ohms_from_percent()
    pvsystem.dc_ohms_from_percent.assert_called_with(
        dc_ohmic_percent=3,
        vmp_ref=38,
        imp_ref=8,
        modules_per_string=1,
        strings=1
    )
    assert_allclose(out, expected)

    array = pvsystem.Array(pvsystem.FixedMount(0, 180),
                           array_losses_parameters={'dc_ohmic_percent': 3},
                           module_parameters={'Impo': 8,
                                              'Vmpo': 38})
    out = array.dc_ohms_from_percent()
    pvsystem.dc_ohms_from_percent.assert_called_with(
        dc_ohmic_percent=3,
        vmp_ref=38,
        imp_ref=8,
        modules_per_string=1,
        strings=1
    )
    assert_allclose(out, expected)

    array = pvsystem.Array(pvsystem.FixedMount(0, 180),
                           array_losses_parameters={'dc_ohmic_percent': 3},
                           module_parameters={'Impp': 8,
                                              'Vmpp': 38})
    out = array.dc_ohms_from_percent()

    pvsystem.dc_ohms_from_percent.assert_called_with(
        dc_ohmic_percent=3,
        vmp_ref=38,
        imp_ref=8,
        modules_per_string=1,
        strings=1
    )
    assert_allclose(out, expected)

    with pytest.raises(ValueError,
                       match=('Parameters for Vmp and Imp could not be found '
                              'in the array module parameters. Module '
                              'parameters must include one set of '
                              '{"V_mp_ref", "I_mp_Ref"}, '
                              '{"Vmpo", "Impo"}, or '
                              '{"Vmpp", "Impp"}.')):
        array = pvsystem.Array(pvsystem.FixedMount(0, 180),
                               array_losses_parameters={'dc_ohmic_percent': 3})
        out = array.dc_ohms_from_percent()


@pytest.mark.parametrize('model,keys', [
    ('sapm', ('a', 'b', 'deltaT')),
    ('fuentes', ('noct_installed',)),
    ('noct_sam', ('noct', 'module_efficiency'))
])
def test_Array_temperature_missing_parameters(model, keys):
    # test that a nice error is raised when required temp params are missing
    array = pvsystem.Array(pvsystem.FixedMount(0, 180))
    index = pd.date_range('2019-01-01', freq='h', periods=5)
    temps = pd.Series(25, index)
    irrads = pd.Series(1000, index)
    winds = pd.Series(1, index)

    for key in keys:
        match = f"Missing required parameter '{key}'"
        params = {k: 1 for k in keys}  # dummy values
        params.pop(key)  # remove each key in turn
        array.temperature_model_parameters = params
        with pytest.raises(KeyError, match=match):
            array.get_cell_temperature(irrads, temps, winds, model)