pvlib 0.10.4__py3-none-any.whl → 0.11.0__py3-none-any.whl

pvlib/tests/test_spectrum.py

@@ -3,11 +3,13 @@ from numpy.testing import assert_allclose, assert_approx_equal, assert_equal
 import pandas as pd
 import numpy as np
 from pvlib import spectrum
+from pvlib._deprecation import pvlibDeprecationWarning
 
-from .conftest import DATA_DIR, assert_series_equal
+from .conftest import DATA_DIR, assert_series_equal, fail_on_pvlib_version
 
 SPECTRL2_TEST_DATA = DATA_DIR / 'spectrl2_example_spectra.csv'
 
+
 @pytest.fixture
 def spectrl2_data():
     # reference spectra generated with solar_utils==0.3
@@ -123,24 +125,75 @@ def test_get_example_spectral_response():
     assert_allclose(sr, expected, rtol=1e-5)
 
 
+@fail_on_pvlib_version('0.12')
 def test_get_am15g():
     # test that the reference spectrum is read and interpolated correctly
-    e = spectrum.get_am15g()
+    with pytest.warns(pvlibDeprecationWarning,
+                      match="get_reference_spectra instead"):
+        e = spectrum.get_am15g()
     assert_equal(len(e), 2002)
     assert_equal(np.sum(e.index), 2761442)
     assert_approx_equal(np.sum(e), 1002.88, significant=6)
 
-    wavelength = [270, 850, 950, 1200, 4001]
-    expected = [0.0, 0.893720, 0.147260, 0.448250, 0.0]
+    wavelength = [270, 850, 950, 1200, 1201.25, 4001]
+    expected = [0.0, 0.893720, 0.147260, 0.448250, 0.4371025, 0.0]
 
-    e = spectrum.get_am15g(wavelength)
+    with pytest.warns(pvlibDeprecationWarning,
+                      match="get_reference_spectra instead"):
+        e = spectrum.get_am15g(wavelength)
     assert_equal(len(e), len(wavelength))
     assert_allclose(e, expected, rtol=1e-6)
 
 
+@pytest.mark.parametrize(
+    "reference_identifier,expected_sums",
+    [
+        (
+            "ASTM G173-03",  # reference_identifier
+            {  # expected_sums
+                "extraterrestrial": 1356.15,
+                "global": 1002.88,
+                "direct": 887.65,
+            },
+        ),
+    ],
+)
+def test_get_reference_spectra(reference_identifier, expected_sums):
+    # test reading of a standard spectrum
+    standard = spectrum.get_reference_spectra(standard=reference_identifier)
+    assert set(standard.columns) == expected_sums.keys()
+    assert standard.index.name == "wavelength"
+    assert standard.index.is_monotonic_increasing is True
+    expected_sums = pd.Series(expected_sums)  # convert prior to comparison
+    assert_series_equal(np.sum(standard, axis=0), expected_sums, atol=1e-2)
+
+
+def test_get_reference_spectra_custom_wavelengths():
+    # test that the spectrum is interpolated correctly when custom wavelengths
+    # are specified
+    # only checked for ASTM G173-03 reference spectrum
+    wavelength = [270, 850, 951.634, 1200, 4001]
+    expected_sums = pd.Series(
+        {"extraterrestrial": 2.23266, "global": 1.68952, "direct": 1.58480}
+    )  # for given ``wavelength``
+    standard = spectrum.get_reference_spectra(
+        wavelength, standard="ASTM G173-03"
+    )
+    assert_equal(len(standard), len(wavelength))
+    # check no NaN values were returned
+    assert not standard.isna().any().any()  # double any to return one value
+    assert_series_equal(np.sum(standard, axis=0), expected_sums, atol=1e-4)
+
+
+def test_get_reference_spectra_invalid_reference():
+    # test that an invalid reference identifier raises a ValueError
+    with pytest.raises(ValueError, match="Invalid standard identifier"):
+        spectrum.get_reference_spectra(standard="invalid")
+
+
 def test_calc_spectral_mismatch_field(spectrl2_data):
     # test that the mismatch is calculated correctly with
-    # - default and custom reference sepctrum
+    # - default and custom reference spectrum
     # - single or multiple sun spectra
 
     # sample data
@@ -148,7 +201,7 @@ def test_calc_spectral_mismatch_field(spectrl2_data):
     e_sun = e_sun.set_index('wavelength')
     e_sun = e_sun.transpose()
 
-    e_ref = spectrum.get_am15g()
+    e_ref = spectrum.get_reference_spectra(standard='ASTM G173-03')["global"]
     sr = spectrum.get_example_spectral_response()
 
     # test with single sun spectrum, same as ref spectrum
@@ -175,25 +228,25 @@ def test_calc_spectral_mismatch_field(spectrl2_data):
 
 @pytest.mark.parametrize("module_type,expect", [
     ('cdte', np.array(
-        [[ 0.99051020, 0.97640320, 0.93975028],
-         [ 1.02928735, 1.01881074, 0.98578821],
-         [ 1.04750335, 1.03814456, 1.00623986]])),
+        [[0.99051020, 0.97640320, 0.93975028],
+         [1.02928735, 1.01881074, 0.98578821],
+         [1.04750335, 1.03814456, 1.00623986]])),
     ('monosi', np.array(
-        [[ 0.97769770, 1.02043409, 1.03574032],
-         [ 0.98630905, 1.03055092, 1.04736262],
-         [ 0.98828494, 1.03299036, 1.05026561]])),
+        [[0.97769770, 1.02043409, 1.03574032],
+         [0.98630905, 1.03055092, 1.04736262],
+         [0.98828494, 1.03299036, 1.05026561]])),
     ('polysi', np.array(
-        [[ 0.97704080, 1.01705849, 1.02613202],
-         [ 0.98992828, 1.03173953, 1.04260662],
-         [ 0.99352435, 1.03588785, 1.04730718]])),
+        [[0.97704080, 1.01705849, 1.02613202],
+         [0.98992828, 1.03173953, 1.04260662],
+         [0.99352435, 1.03588785, 1.04730718]])),
     ('cigs', np.array(
-        [[ 0.97459190, 1.02821696, 1.05067895],
-         [ 0.97529378, 1.02967497, 1.05289307],
-         [ 0.97269159, 1.02730558, 1.05075651]])),
+        [[0.97459190, 1.02821696, 1.05067895],
+         [0.97529378, 1.02967497, 1.05289307],
+         [0.97269159, 1.02730558, 1.05075651]])),
     ('asi', np.array(
-        [[ 1.05552750, 0.87707583, 0.72243772],
-         [ 1.11225204, 0.93665901, 0.78487953],
-         [ 1.14555295, 0.97084011, 0.81994083]]))
+        [[1.05552750, 0.87707583, 0.72243772],
+         [1.11225204, 0.93665901, 0.78487953],
+         [1.14555295, 0.97084011, 0.81994083]]))
 ])
 def test_spectral_factor_firstsolar(module_type, expect):
     ams = np.array([1, 3, 5])
@@ -315,3 +368,211 @@ def test_spectral_factor_caballero_supplied_ambiguous():
     with pytest.raises(ValueError):
         spectrum.spectral_factor_caballero(1, 1, 1, module_type=None,
                                            coefficients=None)
+
+
+@pytest.mark.parametrize("module_type,expected", [
+    ('asi', np.array([1.15534029, 1.1123772, 1.08286684, 1.01915462])),
+    ('fs-2', np.array([1.0694323, 1.04948777, 1.03556288, 0.9881471])),
+    ('fs-4', np.array([1.05234725, 1.037771, 1.0275516, 0.98820533])),
+    ('multisi', np.array([1.03310403, 1.02391703, 1.01744833, 0.97947605])),
+    ('monosi', np.array([1.03225083, 1.02335353, 1.01708734, 0.97950110])),
+    ('cigs', np.array([1.01475834, 1.01143927, 1.00909094, 0.97852966])),
+])
+def test_spectral_factor_pvspec(module_type, expected):
+    ams = np.array([1.0, 1.5, 2.0, 1.5])
+    kcs = np.array([0.4, 0.6, 0.8, 1.4])
+    out = spectrum.spectral_factor_pvspec(ams, kcs,
+                                          module_type=module_type)
+    assert np.allclose(expected, out, atol=1e-8)
+
+
+@pytest.mark.parametrize("module_type,expected", [
+    ('asi', pd.Series([1.15534029, 1.1123772, 1.08286684, 1.01915462])),
+    ('fs-2', pd.Series([1.0694323, 1.04948777, 1.03556288, 0.9881471])),
+    ('fs-4', pd.Series([1.05234725, 1.037771, 1.0275516, 0.98820533])),
+    ('multisi', pd.Series([1.03310403, 1.02391703, 1.01744833, 0.97947605])),
+    ('monosi', pd.Series([1.03225083, 1.02335353, 1.01708734, 0.97950110])),
+    ('cigs', pd.Series([1.01475834, 1.01143927, 1.00909094, 0.97852966])),
+])
+def test_spectral_factor_pvspec_series(module_type, expected):
+    ams = pd.Series([1.0, 1.5, 2.0, 1.5])
+    kcs = pd.Series([0.4, 0.6, 0.8, 1.4])
+    out = spectrum.spectral_factor_pvspec(ams, kcs,
+                                          module_type=module_type)
+    assert isinstance(out, pd.Series)
+    assert np.allclose(expected, out, atol=1e-8)
+
+
+def test_spectral_factor_pvspec_supplied():
+    # use the multisi coeffs
+    coeffs = (0.9847, -0.05237, 0.03034)
+    out = spectrum.spectral_factor_pvspec(1.5, 0.8, coefficients=coeffs)
+    expected = 1.00860641
+    assert_allclose(out, expected, atol=1e-8)
+
+
+def test_spectral_factor_pvspec_supplied_redundant():
+    # Error when specifying both module_type and coefficients
+    coeffs = (0.9847, -0.05237, 0.03034)
+    with pytest.raises(ValueError, match='supply only one of'):
+        spectrum.spectral_factor_pvspec(1.5, 0.8, module_type='multisi',
+                                        coefficients=coeffs)
+
+
+def test_spectral_factor_pvspec_supplied_ambiguous():
+    # Error when specifying neither module_type nor coefficients
+    with pytest.raises(ValueError, match='No valid input provided'):
+        spectrum.spectral_factor_pvspec(1.5, 0.8, module_type=None,
+                                        coefficients=None)
+
+
+@pytest.mark.parametrize("module_type,expected", [
+    ('multisi', np.array([1.06129, 1.03098, 1.01155, 0.99849])),
+    ('cdte', np.array([1.09657,  1.05594, 1.02763, 0.97740])),
+])
+def test_spectral_factor_jrc(module_type, expected):
+    ams = np.array([1.0, 1.5, 2.0, 1.5])
+    kcs = np.array([0.4, 0.6, 0.8, 1.4])
+    out = spectrum.spectral_factor_jrc(ams, kcs,
+                                       module_type=module_type)
+    assert np.allclose(expected, out, atol=1e-4)
+
+
+@pytest.mark.parametrize("module_type,expected", [
+    ('multisi', np.array([1.06129, 1.03098, 1.01155, 0.99849])),
+    ('cdte', np.array([1.09657,  1.05594, 1.02763, 0.97740])),
+])
+def test_spectral_factor_jrc_series(module_type, expected):
+    ams = pd.Series([1.0, 1.5, 2.0, 1.5])
+    kcs = pd.Series([0.4, 0.6, 0.8, 1.4])
+    out = spectrum.spectral_factor_jrc(ams, kcs,
+                                       module_type=module_type)
+    assert isinstance(out, pd.Series)
+    assert np.allclose(expected, out, atol=1e-4)
+
+
+def test_spectral_factor_jrc_supplied():
+    # use the multisi coeffs
+    coeffs = (0.494, 0.146, 0.00103)
+    out = spectrum.spectral_factor_jrc(1.0, 0.8, coefficients=coeffs)
+    expected = 1.01052106
+    assert_allclose(out, expected, atol=1e-4)
+
+
+def test_spectral_factor_jrc_supplied_redundant():
+    # Error when specifying both module_type and coefficients
+    coeffs = (0.494, 0.146, 0.00103)
+    with pytest.raises(ValueError, match='supply only one of'):
+        spectrum.spectral_factor_jrc(1.0, 0.8, module_type='multisi',
+                                     coefficients=coeffs)
+
+
+def test_spectral_factor_jrc_supplied_ambiguous():
+    # Error when specifying neither module_type nor coefficients
+    with pytest.raises(ValueError, match='No valid input provided'):
+        spectrum.spectral_factor_jrc(1.0, 0.8, module_type=None,
+                                     coefficients=None)
+
+
+@pytest.fixture
+def sr_and_eqe_fixture():
+    # Just some arbitrary data for testing the conversion functions
+    df = pd.DataFrame(
+        columns=("wavelength", "quantum_efficiency", "spectral_response"),
+        data=[
+            # nm, [0,1], A/W
+            [300, 0.85, 0.205671370402405],
+            [350, 0.86, 0.242772872514211],
+            [400, 0.87, 0.280680929019753],
+            [450, 0.88, 0.319395539919029],
+            [500, 0.89, 0.358916705212040],
+            [550, 0.90, 0.399244424898786],
+            [600, 0.91, 0.440378698979267],
+            [650, 0.92, 0.482319527453483],
+            [700, 0.93, 0.525066910321434],
+            [750, 0.94, 0.568620847583119],
+            [800, 0.95, 0.612981339238540],
+            [850, 0.90, 0.617014111207215],
+            [900, 0.80, 0.580719163489143],
+            [950, 0.70, 0.536358671833723],
+            [1000, 0.6, 0.483932636240953],
+            [1050, 0.4, 0.338752845368667],
+        ],
+    )
+    df.set_index("wavelength", inplace=True)
+    return df
+
+
+def test_sr_to_qe(sr_and_eqe_fixture):
+    # vector type
+    qe = spectrum.sr_to_qe(
+        sr_and_eqe_fixture["spectral_response"].values,
+        sr_and_eqe_fixture.index.values,  # wavelength, nm
+    )
+    assert_allclose(qe, sr_and_eqe_fixture["quantum_efficiency"])
+    # pandas series type
+    # note: output Series' name should match the input
+    qe = spectrum.sr_to_qe(
+        sr_and_eqe_fixture["spectral_response"]
+    )
+    pd.testing.assert_series_equal(
+        qe, sr_and_eqe_fixture["quantum_efficiency"],
+        check_names=False
+    )
+    assert qe.name == "spectral_response"
+    # series normalization
+    qe = spectrum.sr_to_qe(
+        sr_and_eqe_fixture["spectral_response"] * 10, normalize=True
+    )
+    pd.testing.assert_series_equal(
+        qe,
+        sr_and_eqe_fixture["quantum_efficiency"]
+        / max(sr_and_eqe_fixture["quantum_efficiency"]),
+        check_names=False,
+    )
+    # error on lack of wavelength parameter if no pandas object is provided
+    with pytest.raises(TypeError, match="must have an '.index' attribute"):
+        _ = spectrum.sr_to_qe(sr_and_eqe_fixture["spectral_response"].values)
+
+
+def test_qe_to_sr(sr_and_eqe_fixture):
+    # vector type
+    sr = spectrum.qe_to_sr(
+        sr_and_eqe_fixture["quantum_efficiency"].values,
+        sr_and_eqe_fixture.index.values,  # wavelength, nm
+    )
+    assert_allclose(sr, sr_and_eqe_fixture["spectral_response"])
+    # pandas series type
+    # note: output Series' name should match the input
+    sr = spectrum.qe_to_sr(
+        sr_and_eqe_fixture["quantum_efficiency"]
+    )
+    pd.testing.assert_series_equal(
+        sr, sr_and_eqe_fixture["spectral_response"],
+        check_names=False
+    )
+    assert sr.name == "quantum_efficiency"
+    # series normalization
+    sr = spectrum.qe_to_sr(
+        sr_and_eqe_fixture["quantum_efficiency"] * 10, normalize=True
+    )
+    pd.testing.assert_series_equal(
+        sr,
+        sr_and_eqe_fixture["spectral_response"]
+        / max(sr_and_eqe_fixture["spectral_response"]),
+        check_names=False,
+    )
+    # error on lack of wavelength parameter if no pandas object is provided
+    with pytest.raises(TypeError, match="must have an '.index' attribute"):
+        _ = spectrum.qe_to_sr(
+            sr_and_eqe_fixture["quantum_efficiency"].values
+        )
+
+
+def test_qe_and_sr_reciprocal_conversion(sr_and_eqe_fixture):
+    # test that the conversion functions are reciprocal
+    qe = spectrum.sr_to_qe(sr_and_eqe_fixture["spectral_response"])
+    sr = spectrum.qe_to_sr(qe)
+    assert_allclose(sr, sr_and_eqe_fixture["spectral_response"])
+    qe = spectrum.sr_to_qe(sr)
+    assert_allclose(qe, sr_and_eqe_fixture["quantum_efficiency"])

pvlib/tests/test_temperature.py

@@ -20,13 +20,13 @@ def sapm_default():
 def test_sapm_cell(sapm_default):
     default = temperature.sapm_cell(900, 20, 5, sapm_default['a'],
                                     sapm_default['b'], sapm_default['deltaT'])
-    assert_allclose(default, 43.509, 3)
+    assert_allclose(default, 43.509, 1e-3)
 
 
 def test_sapm_module(sapm_default):
     default = temperature.sapm_module(900, 20, 5, sapm_default['a'],
                                       sapm_default['b'])
-    assert_allclose(default, 40.809, 3)
+    assert_allclose(default, 40.809, 1e-3)
 
 
 def test_sapm_cell_from_module(sapm_default):
@@ -47,8 +47,8 @@ def test_sapm_ndarray(sapm_default):
                                            sapm_default['b'])
     expected_cell = np.array([0., 23.06066166, 5.])
     expected_module = np.array([0., 21.56066166, 5.])
-    assert_allclose(expected_cell, cell_temps, 3)
-    assert_allclose(expected_module, module_temps, 3)
+    assert_allclose(expected_cell, cell_temps, 1e-3)
+    assert_allclose(expected_module, module_temps, 1e-3)
 
 
 def test_sapm_series(sapm_default):
@@ -84,8 +84,8 @@ def test_pvsyst_cell_ndarray():
     irrads = np.array([0, 500, 0])
     winds = np.array([10, 5, 0])
     result = temperature.pvsyst_cell(irrads, temps, wind_speed=winds)
-    expected = np.array([0.0, 23.96551, 5.0])
-    assert_allclose(expected, result, 3)
+    expected = np.array([0.0, 23.965517, 5.0])
+    assert_allclose(expected, result)
 
 
 def test_pvsyst_cell_series():
@@ -95,7 +95,7 @@ def test_pvsyst_cell_series():
     winds = pd.Series([10, 5, 0], index=times)
 
     result = temperature.pvsyst_cell(irrads, temps, wind_speed=winds)
-    expected = pd.Series([0.0, 23.96551, 5.0], index=times)
+    expected = pd.Series([0.0, 23.965517, 5.0], index=times)
     assert_series_equal(expected, result)
 
 

pvlib/tests/test_tools.py

@@ -3,6 +3,7 @@ import pytest
 from pvlib import tools
 import numpy as np
 import pandas as pd
+from numpy.testing import assert_allclose
 
 
 @pytest.mark.parametrize('keys, input_dict, expected', [
@@ -120,3 +121,26 @@ def test_get_pandas_index(args, args_idx):
         assert index is None
     else:
         pd.testing.assert_index_equal(args[args_idx].index, index)
+
+
+@pytest.mark.parametrize('data_in,expected', [
+    (np.array([1, 2, 3, 4, 5]),
+     np.array([0.2, 0.4, 0.6, 0.8, 1])),
+    (np.array([[0, 1, 2], [0, 3, 6]]),
+     np.array([[0, 0.5, 1], [0, 0.5, 1]])),
+    (pd.Series([1, 2, 3, 4, 5]),
+     pd.Series([0.2, 0.4, 0.6, 0.8, 1])),
+    (pd.DataFrame({"a": [0, 1, 2], "b": [0, 2, 8]}),
+     pd.DataFrame({"a": [0, 0.5, 1], "b": [0, 0.25, 1]})),
+    # test with NaN and all zeroes
+    (pd.DataFrame({"a": [0, np.nan, 1], "b": [0, 0, 0]}),
+     pd.DataFrame({"a": [0, np.nan, 1], "b": [np.nan]*3})),
+    # test with negative values
+    (np.array([1, 2, -3, 4, -5]),
+     np.array([0.2, 0.4, -0.6, 0.8, -1])),
+    (pd.Series([-2, np.nan, 1]),
+     pd.Series([-1, np.nan, 0.5])),
+])
+def test_normalize_max2one(data_in, expected):
+    result = tools.normalize_max2one(data_in)
+    assert_allclose(result, expected)

pvlib/tests/test_transformer.py

@@ -0,0 +1,60 @@
+import pandas as pd
+
+from numpy.testing import assert_allclose
+
+from pvlib import transformer
+
+
+def test_simple_efficiency():
+
+    # define test inputs
+    input_power = pd.Series([
+        -800.0,
+        436016.609823837,
+        1511820.16603752,
+        1580687.44677249,
+        1616441.79660171
+    ])
+    no_load_loss = 0.002
+    load_loss = 0.007
+    transformer_rating = 2750000
+
+    # define expected test results
+    expected_output_power = pd.Series([
+        -6300.10103234071,
+        430045.854892526,
+        1500588.39919874,
+        1568921.77089526,
+        1604389.62839879
+    ])
+
+    # run test function with test inputs
+    calculated_output_power = transformer.simple_efficiency(
+        input_power=input_power,
+        no_load_loss=no_load_loss,
+        load_loss=load_loss,
+        transformer_rating=transformer_rating
+    )
+
+    # determine if expected results are obtained
+    assert_allclose(calculated_output_power, expected_output_power)
+
+
+def test_simple_efficiency_known_values():
+    no_load_loss = 0.005
+    load_loss = 0.01
+    rating = 1000
+    args = (no_load_loss, load_loss, rating)
+
+    # verify correct behavior at no-load condition
+    assert_allclose(
+        transformer.simple_efficiency(no_load_loss*rating, *args),
+        0.0
+    )
+
+    # verify correct behavior at rated condition
+    assert_allclose(
+        transformer.simple_efficiency(rating*(1 + no_load_loss + load_loss),
+                                      *args),
+        rating,
+    )

pvlib/tools.py

@@ -507,3 +507,30 @@ def get_pandas_index(*args):
         (a.index for a in args if isinstance(a, (pd.DataFrame, pd.Series))),
         None
     )
+
+
+def normalize_max2one(a):
+    r"""
+    Normalize an array so that the largest absolute value is ±1.
+
+    Handles both numpy arrays and pandas objects.
+    On 2D arrays, normalization is row-wise.
+    On pandas DataFrame, normalization is column-wise.
+
+    If all values of row are 0, the array is set to NaNs.
+
+    Parameters
+    ----------
+    a : array-like
+        The array to normalize.
+
+    Returns
+    -------
+    array-like
+        The normalized array.
+    """
+    try:  # expect numpy array
+        res = a / np.max(np.absolute(a), axis=-1, keepdims=True)
+    except ValueError:  # fails for pandas objects
+        res = a.div(a.abs().max(axis=0, skipna=True))
+    return res

pvlib/transformer.py

@@ -0,0 +1,117 @@
+"""
+This module contains functions for transformer modeling.
+
+Transformer models calculate AC power output and losses at a given input power.
+"""
+
+
+def simple_efficiency(
+        input_power, no_load_loss, load_loss, transformer_rating
+):
+    r'''
+    Calculate the power at the output terminal of the transformer
+    after taking into account efficiency using a simple calculation.
+
+    The equation used in this function can be derived from [1]_.
+
+    For a zero input power, the output power will be negative.
+    This means the transformer will consume energy from the grid at night if
+    it stays connected (due to the parallel impedance in the equivalent
+    circuit).
+    If the input power is negative, the output power will be even more
+    negative; so the model can be used bidirectionally when drawing
+    energy from the grid.
+
+    Parameters
+    ----------
+    input_power : numeric
+        The real AC power input to the transformer. [W]
+
+    no_load_loss : numeric
+        The constant losses experienced by a transformer, even
+        when the transformer is not under load. Fraction of transformer rating,
+        value from 0 to 1. [unitless]
+
+    load_loss:  numeric
+        The load dependent losses experienced by the transformer.
+        Fraction of transformer rating, value from 0 to 1. [unitless]
+
+    transformer_rating: numeric
+        The nominal output power of the transformer. [VA]
+
+    Returns
+    -------
+    output_power : numeric
+        Real AC power output. [W]
+
+    Notes
+    -------
+    First, assume that the load loss :math:`L_{load}` (as a fraction of rated power
+    :math:`P_{nom}`) is proportional to the square of output power:
+
+    .. math::
+
+       L_{load}(P_{out}) &= L_{load}(P_{rated}) \times (P_{out} / P_{nom})^2
+
+                         &= L_{full, load} \times (P_{out} / P_{nom})^2
+
+    Total loss is the constant no-load loss plus the variable load loss:
+
+    .. math::
+
+       L_{total}(P_{out}) &= L_{no, load} + L_{load}(P_{out})
+
+                          &= L_{no, load} + L_{full, load} \times (P_{out} / P_{nom})^2
+
+
+    By conservation of energy, total loss is the difference between input and
+    output power:
+
+    .. math::
+
+       \frac{P_{in}}{P_{nom}} &= \frac{P_{out}}{P_{nom}} + L_{total}(P_{out})
+
+                              &= \frac{P_{out}}{P_{nom}} + L_{no, load} + L_{full, load} \times (P_{out} / P_{nom})^2
+
+    Now use the quadratic formula to solve for :math:`P_{out}` as a function of
+    :math:`P_{in}`.
+
+    .. math::
+
+       \frac{P_{out}}{P_{nom}} &= \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}
+
+       a &= L_{full, load}
+
+       b &= 1
+
+       c &= L_{no, load} - P_{in} / P_{nom}
+
+    Therefore:
+
+    .. math::
+
+       P_{out} = P_{nom} \frac{-1 \pm \sqrt{1 - 4 L_{full, load}
+
+       \times (L_{no, load} - P_{in}/P_{nom})}}{2 L_{full, load}}
+
+    The positive root should be chosen, so that the output power is
+    positive.
+
+
+    References
+    ----------
+    .. [1] Central Station Engineers of the Westinghouse Electric Corporation,
+       "Electrical Transmission and Distribution Reference Book" 4th Edition.
+       pg. 101.
+    '''  # noqa: E501
+
+    input_power_normalized = input_power / transformer_rating
+
+    a = load_loss
+    b = 1
+    c = no_load_loss - input_power_normalized
+
+    output_power_normalized = (-b + (b**2 - 4*a*c)**0.5) / (2 * a)
+
+    output_power = output_power_normalized * transformer_rating
+    return output_power

pvlib/version.py

@@ -1,8 +1,4 @@
-try:
-    from importlib.metadata import PackageNotFoundError, version
-except ImportError:
-    # for python < 3.8
-    from importlib_metadata import PackageNotFoundError, version
+from importlib.metadata import PackageNotFoundError, version
 
 try:
     __version__ = version(__package__)

{pvlib-0.10.4.dist-info → pvlib-0.11.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pvlib
-Version: 0.10.4
+Version: 0.11.0
 Summary: A set of functions and classes for simulating the performance of photovoltaic energy systems.
 Home-page: https://github.com/pvlib/pvlib-python
 Author-email: pvlib python Developers <pvlib-admin@googlegroups.com>
@@ -15,7 +15,7 @@ Classifier: Intended Audience :: Science/Research
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Scientific/Engineering
-Requires-Python: >=3.7
+Requires-Python: >=3.8
 Description-Content-Type: text/x-rst
 License-File: LICENSE
 License-File: AUTHORS.md
@@ -23,9 +23,8 @@ Requires-Dist: numpy >=1.17.3
 Requires-Dist: pandas >=1.3.0
 Requires-Dist: pytz
 Requires-Dist: requests
-Requires-Dist: scipy >=1.5.0
+Requires-Dist: scipy >=1.6.0
 Requires-Dist: h5py
-Requires-Dist: importlib-metadata ; python_version < "3.8"
 Provides-Extra: all
 Requires-Dist: pvlib[doc,optional,test] ; extra == 'all'
 Provides-Extra: doc