pvlib 0.11.2__py3-none-any.whl → 0.12.1a1__py3-none-any.whl

pvlib/tests/test_snow.py

@@ -1,212 +0,0 @@
-import numpy as np
-import pandas as pd
-
-from .conftest import assert_series_equal
-
-from pvlib import snow
-from pvlib.tools import sind
-
-import pytest
-
-
-def test_fully_covered_nrel():
-    dt = pd.date_range(start="2019-1-1 12:00:00", end="2019-1-1 18:00:00",
-                       freq='1h')
-    snowfall_data = pd.Series([1, 5, .6, 4, .23, -5, 19], index=dt)
-    expected = pd.Series([False, True, False, True, False, False, True],
-                         index=dt)
-    fully_covered = snow.fully_covered_nrel(snowfall_data)
-    assert_series_equal(expected, fully_covered)
-
-
-def test_coverage_nrel_hourly():
-    surface_tilt = 45
-    slide_amount_coefficient = 0.197
-    dt = pd.date_range(start="2019-1-1 10:00:00", end="2019-1-1 17:00:00",
-                       freq='1h')
-    poa_irradiance = pd.Series([400, 200, 100, 1234, 134, 982, 100, 100],
-                               index=dt)
-    temp_air = pd.Series([10, 2, 10, 1234, 34, 982, 10, 10], index=dt)
-    snowfall_data = pd.Series([1, .5, .6, .4, .23, -5, .1, .1], index=dt)
-    snow_coverage = snow.coverage_nrel(
-        snowfall_data, poa_irradiance, temp_air, surface_tilt,
-        threshold_snowfall=0.6)
-
-    slide_amt = slide_amount_coefficient * sind(surface_tilt)
-    covered = 1.0 - slide_amt * np.array([0, 1, 2, 3, 4, 5, 6, 7])
-    expected = pd.Series(covered, index=dt)
-    assert_series_equal(expected, snow_coverage)
-
-
-def test_coverage_nrel_subhourly():
-    surface_tilt = 45
-    slide_amount_coefficient = 0.197
-    dt = pd.date_range(start="2019-1-1 11:00:00", end="2019-1-1 14:00:00",
-                       freq='15min')
-    poa_irradiance = pd.Series([400, 200, 100, 1234, 134, 982, 100, 100, 100,
-                                100, 100, 100, 0],
-                               index=dt)
-    temp_air = pd.Series([10, 2, 10, 1234, 34, 982, 10, 10, 10, 10, -10, -10,
-                          10], index=dt)
-    snowfall_data = pd.Series([1, .5, .6, .4, .23, -5, .1, .1, 0., 1., 0., 0.,
-                               0.], index=dt)
-    snow_coverage = snow.coverage_nrel(
-        snowfall_data, poa_irradiance, temp_air, surface_tilt)
-    slide_amt = slide_amount_coefficient * sind(surface_tilt) * 0.25
-    covered = np.append(np.array([1., 1., 1., 1.]),
-                        1.0 - slide_amt * np.array([1, 2, 3, 4, 5]))
-    covered = np.append(covered, np.array([1., 1., 1., 1. - slide_amt]))
-    expected = pd.Series(covered, index=dt)
-    assert_series_equal(expected, snow_coverage)
-
-
-def test_fully_covered_nrel_irregular():
-    # test when frequency is not specified and can't be inferred
-    dt = pd.DatetimeIndex(["2019-1-1 11:00:00", "2019-1-1 14:30:00",
-                           "2019-1-1 15:07:00", "2019-1-1 14:00:00"])
-    snowfall_data = pd.Series([1, .5, .6, .4], index=dt)
-    snow_coverage = snow.fully_covered_nrel(snowfall_data,
-                                            threshold_snowfall=0.5)
-    covered = np.array([False, False, True, False])
-    expected = pd.Series(covered, index=dt)
-    assert_series_equal(expected, snow_coverage)
-
-
-def test_coverage_nrel_initial():
-    surface_tilt = 45
-    slide_amount_coefficient = 0.197
-    dt = pd.date_range(start="2019-1-1 10:00:00", end="2019-1-1 17:00:00",
-                       freq='1h')
-    poa_irradiance = pd.Series([400, 200, 100, 1234, 134, 982, 100, 100],
-                               index=dt)
-    temp_air = pd.Series([10, 2, 10, 1234, 34, 982, 10, 10], index=dt)
-    snowfall_data = pd.Series([0, .5, .6, .4, .23, -5, .1, .1], index=dt)
-    snow_coverage = snow.coverage_nrel(
-        snowfall_data, poa_irradiance, temp_air, surface_tilt,
-        initial_coverage=0.5, threshold_snowfall=1.)
-    slide_amt = slide_amount_coefficient * sind(surface_tilt)
-    covered = 0.5 - slide_amt * np.array([0, 1, 2, 3, 4, 5, 6, 7])
-    covered = np.where(covered < 0, 0., covered)
-    expected = pd.Series(covered, index=dt)
-    assert_series_equal(expected, snow_coverage)
-
-
-def test_dc_loss_nrel():
-    num_strings = 8
-    snow_coverage = pd.Series([1, 1, .5, .6, .2, .4, 0])
-    expected = pd.Series([1, 1, .5, .625, .25, .5, 0])
-    actual = snow.dc_loss_nrel(snow_coverage, num_strings)
-    assert_series_equal(expected, actual)
-
-
-def test__townsend_effective_snow():
-    snow_total = np.array([25.4, 25.4, 12.7, 2.54, 0, 0, 0, 0, 0, 0, 12.7,
-                           25.4])
-    snow_events = np.array([2, 2, 1, 0, 0, 0, 0, 0, 0, 0, 2, 3])
-    expected = np.array([19.05, 19.05, 12.7, 0, 0, 0, 0, 0, 0, 0, 9.525,
-                         254 / 15])
-    actual = snow._townsend_effective_snow(snow_total, snow_events)
-    np.testing.assert_allclose(expected, actual, rtol=1e-07)
-
-
-def test_loss_townsend():
-    # hand-calculated solution
-    snow_total = np.array([25.4, 25.4, 12.7, 2.54, 0, 0, 0, 0, 0, 0, 12.7,
-                           25.4])
-    snow_events = np.array([2, 2, 1, 0, 0, 0, 0, 0, 0, 0, 2, 3])
-    surface_tilt = 20
-    relative_humidity = np.array([80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
-                                  80, 80])
-    temp_air = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
-    poa_global = np.array([350000, 350000, 350000, 350000, 350000, 350000,
-                           350000, 350000, 350000, 350000, 350000, 350000])
-    angle_of_repose = 40
-    string_factor = 1.0
-    slant_height = 2.54
-    lower_edge_height = 0.254
-    expected = np.array([0.07696253, 0.07992262, 0.06216201, 0.01715392, 0, 0,
-                         0, 0, 0, 0, 0.02643821, 0.06068194])
-    actual = snow.loss_townsend(snow_total, snow_events, surface_tilt,
-                                relative_humidity, temp_air,
-                                poa_global, slant_height,
-                                lower_edge_height, string_factor,
-                                angle_of_repose)
-    np.testing.assert_allclose(expected, actual, rtol=1e-05)
-
-
-@pytest.mark.parametrize(
-    'poa_global,surface_tilt,slant_height,lower_edge_height,string_factor,expected',  # noQA: E501
-    [
-        (np.asarray(
-            [60., 80., 100., 125., 175., 225., 225., 210., 175., 125., 90.,
-             60.], dtype=float) * 1000.,
-         2.,
-         79. / 39.37,
-         3. / 39.37,
-         1.0,
-         np.asarray(
-            [44, 34, 20, 9, 3, 1, 0, 0, 0, 2, 6, 25], dtype=float)
-         ),
-        (np.asarray(
-            [60., 80., 100., 125., 175., 225., 225., 210., 175., 125., 90.,
-             60.], dtype=float) * 1000.,
-         5.,
-         316 / 39.37,
-         120. / 39.37,
-         0.75,
-         np.asarray(
-            [22, 16, 9, 4, 1, 0, 0, 0, 0, 1, 2, 12], dtype=float)
-         ),
-        (np.asarray(
-            [60., 80., 100., 125., 175., 225., 225., 210., 175., 125., 90.,
-             60.], dtype=float) * 1000.,
-         23.,
-         158 / 39.27,
-         12 / 39.37,
-         0.75,
-         np.asarray(
-            [28, 21, 13, 6, 2, 0, 0, 0, 0, 1, 4, 16], dtype=float)
-         ),
-        (np.asarray(
-            [80., 100., 125., 150., 225., 300., 300., 275., 225., 150., 115.,
-             80.], dtype=float) * 1000.,
-         52.,
-         39.5 / 39.37,
-         34. / 39.37,
-         0.75,
-         np.asarray(
-             [7, 5, 3, 1, 0, 0, 0, 0, 0, 0, 1, 4], dtype=float)
-         ),
-        (np.asarray(
-            [80., 100., 125., 150., 225., 300., 300., 275., 225., 150., 115.,
-             80.], dtype=float) * 1000.,
-         60.,
-         39.5 / 39.37,
-         25. / 39.37,
-         1.,
-         np.asarray(
-             [7, 5, 3, 1, 0, 0, 0, 0, 0, 0, 1, 3], dtype=float)
-         )
-    ]
-)
-def test_loss_townsend_cases(poa_global, surface_tilt, slant_height,
-                             lower_edge_height, string_factor, expected):
-    # test cases from Townsend, 1/27/2023, addeed by cwh
-    # snow_total in inches, convert to cm for pvlib
-    snow_total = np.asarray(
-        [20, 15, 10, 4, 1.5, 0, 0, 0, 0, 1.5, 4, 15], dtype=float) * 2.54
-    # snow events are an average for each month
-    snow_events = np.asarray(
-        [5, 4.2, 2.8, 1.3, 0.8, 0, 0, 0, 0, 0.5, 1.5, 4.5], dtype=float)
-    # air temperature in C
-    temp_air = np.asarray(
-        [-6., -2., 1., 4., 7., 10., 13., 16., 14., 12., 7., -3.], dtype=float)
-    # relative humidity in %
-    relative_humidity = np.asarray(
-        [78., 80., 75., 65., 60., 55., 55., 55., 50., 55., 60., 70.],
-        dtype=float)
-    actual = snow.loss_townsend(
-        snow_total, snow_events, surface_tilt, relative_humidity, temp_air,
-        poa_global, slant_height, lower_edge_height, string_factor)
-    actual = np.around(actual * 100)
-    assert np.allclose(expected, actual)

pvlib/tests/test_soiling.py

@@ -1,230 +0,0 @@
-"""Test losses"""
-
-import datetime
-import numpy as np
-import pandas as pd
-from .conftest import assert_series_equal
-from pvlib.soiling import hsu, kimber
-from pvlib.iotools import read_tmy3
-from .conftest import DATA_DIR
-import pytest
-
-
-@pytest.fixture
-def expected_output():
-    # Sample output (calculated manually)
-    dt = pd.date_range(start=pd.Timestamp(2019, 1, 1, 0, 0, 0),
-                       end=pd.Timestamp(2019, 1, 1, 23, 59, 0), freq='1h')
-
-    expected_no_cleaning = pd.Series(
-        data=[0.96998483, 0.94623958, 0.92468139, 0.90465654, 0.88589707,
-              0.86826366, 0.85167258, 0.83606715, 0.82140458, 0.80764919,
-              0.79476875, 0.78273241, 0.77150951, 0.76106905, 0.75137932,
-              0.74240789, 0.73412165, 0.72648695, 0.71946981, 0.7130361,
-              0.70715176, 0.70178307, 0.69689677, 0.69246034],
-        index=dt)
-    return expected_no_cleaning
-
-
-@pytest.fixture
-def expected_output_1():
-    dt = pd.date_range(start=pd.Timestamp(2019, 1, 1, 0, 0, 0),
-                       end=pd.Timestamp(2019, 1, 1, 23, 59, 0), freq='1h')
-    expected_output_1 = pd.Series(
-        data=[0.98484972, 0.97277367, 0.96167471, 0.95119603, 1.,
-              0.98484972, 0.97277367, 0.96167471, 1., 1.,
-              0.98484972, 0.97277367, 0.96167471, 0.95119603, 0.94118234,
-              0.93154854, 0.922242, 0.91322759, 0.90448058, 0.89598283,
-              0.88772062, 0.87968325, 0.8718622, 0.86425049],
-        index=dt)
-    return expected_output_1
-
-
-@pytest.fixture
-def expected_output_2():
-    dt = pd.date_range(start=pd.Timestamp(2019, 1, 1, 0, 0, 0),
-                       end=pd.Timestamp(2019, 1, 1, 23, 59, 0), freq='1h')
-    expected_output_2 = pd.Series(
-        data=[0.95036261, 0.91178179, 0.87774818, 0.84732079, 1.,
-              1., 1., 0.95036261, 1., 1.,
-              1., 1., 0.95036261, 0.91178179, 0.87774818,
-              0.84732079, 0.8201171, 1., 1., 1.,
-              1., 0.95036261, 0.91178179, 0.87774818],
-        index=dt)
-    return expected_output_2
-
-
-@pytest.fixture
-def expected_output_3():
-    dt = pd.date_range(start=pd.Timestamp(2019, 1, 1, 0, 0, 0),
-                       end=pd.Timestamp(2019, 1, 1, 23, 59, 0), freq='1h')
-    timedelta = [0, 0, 0, 0, 0, 30, 0, 30, 0, 30, 0, -30,
-                 -30, -30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
-    dt_new = dt + pd.to_timedelta(timedelta, 'm')
-    expected_output_3 = pd.Series(
-        data=[0.96576705, 0.9387675, 0.91437615, 0.89186852, 1.,
-              1., 0.98093819, 0.9387675, 1., 1.,
-              1., 1., 0.96576705, 0.9387675, 0.90291005,
-              0.88122293, 0.86104089, 1., 1., 1.,
-              0.96576705, 0.9387675, 0.91437615, 0.89186852],
-        index=dt_new)
-    return expected_output_3
-
-
-@pytest.fixture
-def rainfall_input():
-
-    dt = pd.date_range(start=pd.Timestamp(2019, 1, 1, 0, 0, 0),
-                       end=pd.Timestamp(2019, 1, 1, 23, 59, 0), freq='1h')
-    rainfall = pd.Series(
-        data=[0., 0., 0., 0., 1., 0., 0., 0., 0.5, 0.5, 0., 0., 0., 0., 0.,
-              0., 0.3, 0.3, 0.3, 0.3, 0., 0., 0., 0.], index=dt)
-    return rainfall
-
-
-def test_hsu_no_cleaning(rainfall_input, expected_output):
-    """Test Soiling HSU function"""
-
-    rainfall = rainfall_input
-    pm2_5 = 1.0
-    pm10 = 2.0
-    depo_veloc = {'2_5': 1.0e-5, '10': 1.0e-4}
-    tilt = 0.
-    expected_no_cleaning = expected_output
-
-    result = hsu(rainfall=rainfall, cleaning_threshold=10., surface_tilt=tilt,
-                 pm2_5=pm2_5, pm10=pm10, depo_veloc=depo_veloc,
-                 rain_accum_period=pd.Timedelta('1h'))
-    assert_series_equal(result, expected_no_cleaning)
-
-
-def test_hsu(rainfall_input, expected_output_2):
-    """Test Soiling HSU function with cleanings"""
-
-    rainfall = rainfall_input
-    pm2_5 = 1.0
-    pm10 = 2.0
-    depo_veloc = {'2_5': 1.0e-4, '10': 1.0e-4}
-    tilt = 0.
-
-    # three cleaning events at 4:00-6:00, 8:00-11:00, and 17:00-20:00
-    result = hsu(rainfall=rainfall, cleaning_threshold=0.5, surface_tilt=tilt,
-                 pm2_5=pm2_5, pm10=pm10, depo_veloc=depo_veloc,
-                 rain_accum_period=pd.Timedelta('3h'))
-
-    assert_series_equal(result, expected_output_2)
-
-
-def test_hsu_defaults(rainfall_input, expected_output_1):
-    """
-    Test Soiling HSU function with default deposition velocity and default rain
-    accumulation period.
-    """
-    result = hsu(rainfall=rainfall_input, cleaning_threshold=0.5,
-                 surface_tilt=0.0, pm2_5=1.0e-2, pm10=2.0e-2)
-    assert np.allclose(result.values, expected_output_1)
-
-
-def test_hsu_variable_time_intervals(rainfall_input, expected_output_3):
-    """
-    Test Soiling HSU function with variable time intervals.
-    """
-    depo_veloc = {'2_5': 1.0e-4, '10': 1.0e-4}
-    rain = pd.DataFrame(data=rainfall_input)
-    # define time deltas in minutes
-    timedelta = [0, 0, 0, 0, 0, 30, 0, 30, 0, 30, 0, -30,
-                 -30, -30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
-    rain['mins_added'] = pd.to_timedelta(timedelta, 'm')
-    rain['new_time'] = rain.index + rain['mins_added']
-    rain_var_times = rain.set_index('new_time').iloc[:, 0]
-    result = hsu(
-        rainfall=rain_var_times, cleaning_threshold=0.5, surface_tilt=50.0,
-        pm2_5=1, pm10=2, depo_veloc=depo_veloc,
-        rain_accum_period=pd.Timedelta('2h'))
-    assert np.allclose(result, expected_output_3)
-
-
-@pytest.fixture
-def greensboro_rain():
-    # get TMY3 data with rain
-    greensboro, _ = read_tmy3(DATA_DIR / '723170TYA.CSV', coerce_year=1990,
-                              map_variables=True)
-    return greensboro['Lprecip depth (mm)']
-
-
-@pytest.fixture
-def expected_kimber_nowash():
-    return pd.read_csv(
-        DATA_DIR / 'greensboro_kimber_soil_nowash.dat',
-        parse_dates=True, index_col='timestamp')
-
-
-def test_kimber_nowash(greensboro_rain, expected_kimber_nowash):
-    """Test Kimber soiling model with no manual washes"""
-    # Greensboro typical expected annual rainfall is 8345mm
-    assert greensboro_rain.sum() == 8345
-    # calculate soiling with no wash dates
-    nowash = kimber(greensboro_rain)
-    # test no washes
-    assert np.allclose(nowash.values, expected_kimber_nowash['soiling'].values)
-
-
-@pytest.fixture
-def expected_kimber_manwash():
-    return pd.read_csv(
-        DATA_DIR / 'greensboro_kimber_soil_manwash.dat',
-        parse_dates=True, index_col='timestamp')
-
-
-def test_kimber_manwash(greensboro_rain, expected_kimber_manwash):
-    """Test Kimber soiling model with a manual wash"""
-    # a manual wash date
-    manwash = [datetime.date(1990, 2, 15), ]
-    # calculate soiling with manual wash
-    manwash = kimber(greensboro_rain, manual_wash_dates=manwash)
-    # test manual wash
-    assert np.allclose(
-        manwash.values,
-        expected_kimber_manwash['soiling'].values)
-
-
-@pytest.fixture
-def expected_kimber_norain():
-    # expected soiling reaches maximum
-    soiling_loss_rate = 0.0015
-    max_loss_rate = 0.3
-    norain = np.ones(8760) * soiling_loss_rate/24
-    norain[0] = 0.0
-    norain = np.cumsum(norain)
-    return np.where(norain > max_loss_rate, max_loss_rate, norain)
-
-
-def test_kimber_norain(greensboro_rain, expected_kimber_norain):
-    """Test Kimber soiling model with no rain"""
-    # a year with no rain
-    norain = pd.Series(0, index=greensboro_rain.index)
-    # calculate soiling with no rain
-    norain = kimber(norain)
-    # test no rain, soiling reaches maximum
-    assert np.allclose(norain.values, expected_kimber_norain)
-
-
-@pytest.fixture
-def expected_kimber_initial_soil():
-    # expected soiling reaches maximum
-    soiling_loss_rate = 0.0015
-    max_loss_rate = 0.3
-    norain = np.ones(8760) * soiling_loss_rate/24
-    norain[0] = 0.1
-    norain = np.cumsum(norain)
-    return np.where(norain > max_loss_rate, max_loss_rate, norain)
-
-
-def test_kimber_initial_soil(greensboro_rain, expected_kimber_initial_soil):
-    """Test Kimber soiling model with initial soiling"""
-    # a year with no rain
-    norain = pd.Series(0, index=greensboro_rain.index)
-    # calculate soiling with no rain
-    norain = kimber(norain, initial_soiling=0.1)
-    # test no rain, soiling reaches maximum
-    assert np.allclose(norain.values, expected_kimber_initial_soil)