Merge pull request #2 from AssessingSolar/add_initial_tests

Add initial tests

Author: AdamRJensen

tests/test_example.py

@@ -0,0 +1,15 @@
+# import pandas as pd
+import numpy as np
+import pytest
+from solposx.refraction import hughes
+
+
+@pytest.fixture
+def elevation_angles():
+    return np.array([0, 10, 86])
+
+
+def test_hughes_refraction(elevation_angles):
+    expected = np.array([0.47856238, 0.08750312, 0.])
+    result = hughes(elevation_angles)
+    np.testing.assert_allclose(result, expected)

tests/test_refraction.py

@@ -0,0 +1,343 @@
+import pandas as pd
+import numpy as np
+import pytest
+from solposx.solarposition import iqbal
+# from solposx.solarposition import michalsky
+# from solposx.solarposition import noaa
+# from solposx.solarposition import psa
+# from solposx.solarposition import usno
+# from solposx.solarposition import sg2
+# from solposx.solarposition import walraven
+
+
+def expected_iqbal():
+    columns = ['elevation', 'zenith', 'azimuth']
+    values = [
+        [32.3933559, 57.6066441, 205.057264],
+        [32.3808669, 57.6191331, 205.103653],
+        [35.10239415, 54.89760585, 169.4252099],
+        [18.79386827, 71.20613173, 234.3799454],
+        [35.58304355, 54.41695645, 197.47158811],
+        [-9.32664685, 99.32664685, 201.24829056],
+        [66.88194467, 23.11805533, 245.62133739],
+        [9.32664685, 80.67335315, 338.75170944],
+        [49.89989703, 40.10010297, 326.27538784],
+        [35.56795719, 54.43204281, 175.44720266],
+        [-53.03010805, 143.03010805, 18.66654047],
+        [-53.03010805, 143.03010805, 18.66654047],
+        [32.7577876, 57.2422124, 205.13681576],
+        [32.7577876, 57.2422124, 205.13681576],
+        [-23.30557846, 113.30557846, 79.558556],
+        [1.23252489, 88.76747511, 104.52245037],
+        [32.3933559, 57.6066441, 205.057264],
+        [32.3933559, 57.6066441, 205.057264],
+        [32.3933559, 57.6066441, 205.057264],
+    ]
+    data = pd.DataFrame(data=values, columns=columns)
+    return data
+
+
+def expected_michalsky_original_julian():
+    columns = ['elevation', 'apparent_elevation', 'zenith', 'apparent_zenith',
+               'azimuth']
+    values = [
+        [32.21780263, 32.24498279, 57.78219737, 57.75501721, 204.91751387],
+        [32.20533693, 32.23252757, 57.79466307, 57.76747243, 204.96379895],
+        [34.92279261, 34.9478766, 55.07720739, 55.0521234, 169.37618059],
+        [18.63629794, 18.68330498, 71.36370206, 71.31669502, 234.18898285],
+        [35.75816111, 35.78266275, 54.24183889, 54.21733725, 197.6747502],
+        [-9.52972383, -9.55300057, 99.52972383, 99.55300057, 201.18805829],
+        [66.85774447, 66.87103396, 23.14225553, 23.12896604, 245.08622522],
+        [9.52972383, 9.62043934, 80.47027617, 80.37956066, 338.81194171],
+        [50.10984044, 50.1274089, 39.89015956, 39.8725911, 326.23438218],
+        [35.36181097, 35.38658543, 54.63818903, 54.61341457, 175.38864631],
+        [-53.24139895, -53.25501504, 143.24139895, 143.25501504, 18.64775639],
+        [-53.24139895, -53.25501504, 143.24139895, 143.25501504, 18.64775639],
+        [33.19773834, 33.2241191, 56.80226166, 56.7758809, 205.09146059],
+        [32.08343676, 32.11073039, 57.91656324, 57.88926961, 204.90619448],
+        [-23.40757803, -23.43615939, 113.40757803, 113.43615939, 79.54939414],
+        [1.10847034, 1.49128689, 88.89152966, 88.50871311, 104.54053775],
+        [32.21780263, 32.24498279, 57.78219737, 57.75501721, 204.91751387],
+        [32.21780263, 32.24498279, 57.78219737, 57.75501721, 204.91751387],
+        [32.21780263, 32.24498279, 57.78219737, 57.75501721, 204.91751387],
+    ]
+    data = pd.DataFrame(data=values, columns=columns)
+    return data
+
+
+def expected_michalsky_correct_julian():
+    columns = ['elevation', 'apparent_elevation', 'zenith', 'apparent_zenith',
+               'azimuth']
+    values = [
+        [32.21780263, 32.24498279, 57.78219737, 57.75501721, 204.91751387],
+        [32.20533693, 32.23252757, 57.79466307, 57.76747243, 204.96379895],
+        [34.92279261, 34.9478766, 55.07720739, 55.0521234, 169.37618059],
+        [18.63629794, 18.68330498, 71.36370206, 71.31669502, 234.18898285],
+        [35.75816111, 35.78266275, 54.24183889, 54.21733725, 197.6747502],
+        [-9.52972383, -9.55300057, 99.52972383, 99.55300057, 201.18805829],
+        [66.85774447, 66.87103396, 23.14225553, 23.12896604, 294.91377478],
+        [9.52972383, 9.62043934, 80.47027617, 80.37956066, 201.18805829],
+        [50.10984044, 50.1274089, 39.89015956, 39.8725911, 213.76561781],
+        [35.36181097, 35.38658543, 54.63818903, 54.61341457, 175.38864631],
+        [-53.24139895, -53.25501504, 143.24139895, 143.25501504, 18.64775638],
+        [-53.24139895, -53.25501504, 143.24139895, 143.25501504, 18.64775638],
+        [32.46357112, 32.49054619, 57.53642888, 57.50945381, 204.94138737],
+        [32.44484719, 32.47183777, 57.55515281, 57.52816223, 204.97918825],
+        [-23.40757803, -23.43615939, 113.40757803, 113.43615939, 79.54939414],
+        [1.10847034, 1.49128689, 88.89152966, 88.50871311, 104.54053775],
+        [32.21780263, 32.24498279, 57.78219737, 57.75501721, 204.91751387],
+        [32.21780263, 32.24498279, 57.78219737, 57.75501721, 204.91751387],
+        [32.21780263, 32.24498279, 57.78219737, 57.75501721, 204.91751387],
+    ]
+    data = pd.DataFrame(data=values, columns=columns)
+    return data
+
+
+def expected_noaa():
+    columns = ['elevation', 'apparent_elevation', 'zenith', 'apparent_zenith',
+               'azimuth']
+    values = [
+        [32.21715174, 32.24268539, 57.78284826, 57.75731461, 204.92232395],
+        [32.20468378, 32.23022967, 57.79531622, 57.76977033, 204.96860803],
+        [34.92392895, 34.94698595, 55.07607105, 55.05301405, 169.38094302],
+        [18.63438988, 18.68174893, 71.36561012, 71.31825107, 234.19290241],
+        [35.75618186, 35.77854313, 54.24381814, 54.22145687, 197.67357003],
+        [-9.52911488, -9.49473872, 99.52911488, 99.49473872, 336.8166928],
+        [66.85423515, 66.8611327, 23.14576485, 23.1388673, 245.09172279],
+        [9.52911488, 9.62132546, 80.47088512, 80.37867454, np.nan],
+        [50.10765752, 50.12113671, 39.89234248, 39.87886329, 326.22893168],
+        [35.36265374, 35.38534047, 54.63734626, 54.61465953, 175.39359304],
+        [-53.23987161, -53.23556094, 143.23987161, 143.23556094, 18.65415239],
+        [-53.23987161, -53.23556094, 143.23987161, 143.23556094, 18.65415239],
+        [32.46248831, 32.48778263, 57.53751169, 57.51221737, 204.95376627],
+        [32.44117331, 32.4664883, 57.55882669, 57.5335117, 204.97518601],
+        [-23.40444445, -23.39111232, 113.40444445, 113.39111232, 79.55187937],
+        [1.11161226, 1.46445929, 88.88838774, 88.53554071, 104.54291476],
+        [32.21715174, 32.24268539, 57.78284826, 57.75731461, 204.92232395],
+        [32.21715174, 32.24268539, 57.78284826, 57.75731461, 204.92232395],
+        [32.21715174, 32.24268539, 57.78284826, 57.75731461, 204.92232395],
+    ]
+    data = pd.DataFrame(data=values, columns=columns)
+    return data
+
+
+def expected_psa_2001():
+    columns = ['elevation', 'zenith', 'azimuth']
+    values = [
+        [32.21434385, 57.78565615, 204.91957868],
+        [32.20187689, 57.79812311, 204.96586258],
+        [34.92027644, 55.07972356, 169.3788305],
+        [18.63211707, 71.36788293, 234.19028111],
+        [35.75446859, 54.24553141, 197.67713395],
+        [-9.53293173, 99.53293173, 201.19017401],
+        [66.85455175, 23.14544825, 245.08643499],
+        [9.52811892, 80.47188108, 338.80982599],
+        [50.10817913, 39.89182087, 326.23090017],
+        [35.35914111, 54.64085889, 175.39125721],
+        [-53.24316093, 143.24316093, 18.65145716],
+        [-53.24316093, 143.24316093, 18.65145716],
+        [32.46428802, 57.53571198, 204.93415982],
+        [32.43981197, 57.56018803, 204.98955089],
+        [-23.40890746, 113.40890746, 79.55160745],
+        [1.10690714, 88.89309286, 104.54258663],
+        [32.21434385, 57.78565615, 204.91957868],
+        [32.21434385, 57.78565615, 204.91957868],
+        [32.21434385, 57.78565615, 204.91957868],
+    ]
+    data = pd.DataFrame(data=values, columns=columns)
+    return data
+
+
+def expected_psa_2020():
+    columns = ['elevation', 'zenith', 'azimuth']
+    values = [
+        [32.21595946, 57.78404054, 204.9167547],
+        [32.20349382, 57.79650618, 204.96304003],
+        [34.92071906, 55.07928094, 169.37535422],
+        [18.63439275, 71.36560725, 234.1884117],
+        [35.7535716, 54.2464284, 197.67796274],
+        [-9.5321134, 99.5321134, 201.18736969],
+        [66.85741664, 23.14258336, 245.08558596],
+        [9.52730057, 80.47269943, 338.81263031],
+        [50.10853074, 39.89146926, 326.23536385],
+        [35.35979872, 54.64020128, 175.38781378],
+        [-53.24299848, 143.24299848, 18.64664538],
+        [-53.24299848, 143.24299848, 18.64664538],
+        [32.47215358, 57.52784642, 204.9305477],
+        [32.43510874, 57.56489126, 204.98638231],
+        [-23.41028925, 113.41028925, 79.54884709],
+        [1.10556787, 88.89443213, 104.54003062],
+        [32.21595946, 57.78404054, 204.9167547],
+        [32.21595946, 57.78404054, 204.9167547],
+        [32.21595946, 57.78404054, 204.9167547],
+    ]
+    data = pd.DataFrame(data=values, columns=columns)
+    return data
+
+
+def expected_usno():
+    columns = ['elevation', 'zenith', 'azimuth']
+    values = [
+       [32.21913058, 57.78086942, 204.91396212],
+       [32.20666654, 57.79333346, 204.9602485],
+       [34.92271632, 55.07728368, 169.37217155],
+       [18.63848631, 71.36151369, 234.18640074],
+       [35.75823472, 54.24176528, 197.67107057],
+       [-9.52936557, 99.52936557, 201.18474698],
+       [66.86088833, 23.13911167, 245.08379957],
+       [9.52936557,  80.47063443, 338.81525302],
+       [50.11081313, 39.88918687, 326.23927513],
+       [35.36198031, 54.63801969, 175.38462327],
+       [-53.24179879, 143.24179879, 18.6423076],
+       [-53.24179879, 143.24179879, 18.6423076],
+       [32.46463884, 57.53536116, 204.9389006],
+       [32.44304455, 57.55695545, 204.98724112],
+       [-23.40963192, 113.40963192, 79.54658304],
+       [1.10645791, 88.89354209, 104.53792899],
+       [32.21913058, 57.78086942, 204.91396212],
+       [32.21913058, 57.78086942, 204.91396212],
+       [32.21913058, 57.78086942, 204.91396212],
+    ]
+    data = pd.DataFrame(data=values, columns=columns)
+    return data
+
+
+def expected_sg2():
+    # The expected values were generated using the official SG2 Python wrapper
+    # and the SG2 SAE refraction correction
+    columns = ['elevation', 'apparent_elevation', 'zenith', 'apparent_zenith',
+               'azimuth']
+    values = [
+        [32.21696737, 32.24355729, 57.78303263, 57.75644271, 204.91857639],
+        [32.2045009, 32.2311035, 57.7954991, 57.7688965, 204.96486201],
+        [34.92230526, 34.94633034, 55.07769474, 55.05366966, 169.37656689],
+        [18.63488143, 18.6838735, 71.36511857, 71.3161265, 234.19025564],
+        [35.75666309, 35.77996471, 54.24333691, 54.22003529, 197.67009822],
+        [-9.53068757, -9.49650419, 99.53068757, 99.49650419, 201.18854894],
+        [66.85690391, 66.86409239, 23.14309609, 23.13590761, 245.09007204],
+        [9.52588549, 9.61972777, 80.47411451, 80.38027223, 338.81145106],
+        [50.10677054, 50.1208336, 39.89322946, 39.8791664, 326.23457619],
+        [35.36128972, 35.38493054, 54.63871028, 54.61506946, 175.38913627],
+        [-53.24134227, -53.23705528, 143.24134227, 143.23705528, 18.64798841],
+        [-53.24134227, -53.23705528, 143.24134227, 143.23705528, 18.64798841],
+        [np.nan, np.nan, np.nan, np.nan, np.nan],
+        [np.nan, np.nan, np.nan, np.nan, np.nan],
+        [-23.40828474, -23.39502759, 113.40828474, 113.39502759, 79.54872263],
+        [1.10752265, 1.45828141, 88.89247735, 88.54171859, 104.53992596],
+        [32.21696737, 32.24355729, 57.78303263, 57.75644271, 204.91857639],
+        [32.21696737, 32.24355729, 57.78303263, 57.75644271, 204.91857639],
+        [32.21696737, 32.24355729, 57.78303263, 57.75644271, 204.91857639],
+    ]
+    data = pd.DataFrame(data=values, columns=columns)
+    return data
+
+
+def expected_walraven():
+    columns = ['elevation', 'zenith', 'azimuth']
+    values = [
+        [32.21577184, 57.78422816, 204.9145408],
+        [32.20330752, 57.79669248, 204.96082497],
+        [34.91988403, 55.08011597, 169.37445826],
+        [18.63514306, 71.36485694, 234.18579686],
+        [35.75942569, 54.24057431, 197.67543014],
+        [-9.53241956, 99.53241956, 201.18624892],
+        [66.85832643, 23.14167357, 245.07813388],
+        [9.53241956, 80.46758044, 338.81375108],
+        [50.11302395, 39.88697605, 326.23525905],
+        [35.35901685, 54.64098315, 175.38665251],
+        [-53.24443195, 143.24443195, 18.64588668],
+        [-53.24443195, 143.24443195, 18.64588668],
+        [33.19945919, 56.80054081, 205.08690939],
+        [32.078221, 57.921779, 204.90430273],
+        [-23.41074972, 113.41074972, 79.55008786],
+        [1.10528968, 88.89471032, 104.541125],
+        [32.21577184, 57.78422816, 204.9145408],
+        [32.21577184, 57.78422816, 204.9145408],
+        [32.21577184, 57.78422816, 204.9145408],
+    ]
+    data = pd.DataFrame(data=values, columns=columns)
+    return data
+
+
+@pytest.fixture()
+def test_conditions():
+    inputs = pd.DataFrame(
+        columns=['time', 'latitude', 'longitude', 'altitude'],
+        data=(
+            # Units: time, degrees, degrees, m
+            ['2020-10-17T12:30+00:00', 45, 10, None],  # reference
+            ['2020-10-17T12:30:10+00:00', 45, 10, None],  # non-zero seconds
+            ['2020-10-17T12:30+02:00', 45, 10, None],  # positive timezone
+            ['2020-10-17T12:30-02:00', 45, 10, None],  # negative timezone
+            ['2020-02-29T12:30+00:00', 45, 10, None],  # leap day
+            ['2020-10-17T12:30+00:00', 90, 10, None],  # 90 degree latitude
+            ['2020-10-17T12:30+00:00', 0, 10, None],  # zero latitude
+            ['2020-10-17T12:30+00:00', -90, 10, None],  # -90 degree latitude
+            ['2020-10-17T12:30+00:00', -45, 10, None],  # negative mid-latitude
+            ['2020-10-17T12:30+00:00', 45, -15, None],  # negative longitude
+            ['2020-10-17T12:30+00:00', 45, -180, None],  # 180-degree longitude
+            ['2020-10-17T12:30+00:00', 45, 180, None],  # 180-degree longitude
+            ['1800-10-17T12:30+00:00', 45, 10, None],  # 200 years in the past
+            ['2200-10-17T12:30+00:00', 45, 10, None],  # 200 years ahead
+            ['2020-10-17T03:30+00:00', 45, 10, None],  # negative sun elevation
+            ['2020-10-17T05:50+00:00', 45, 10, None],  # ~1-deg sun elevation
+            ['2020-10-17T12:30+00:00', 45, 10, 0],  # zero altitude
+            ['2020-10-17T12:30+00:00', 45, 10, -100],  # negative altitude
+            ['2020-10-17T12:30+00:00', 45, 10, 4000],  # positive altitude
+        ),
+    )
+    inputs = inputs.set_index('time')
+    inputs.index = [pd.Timestamp(ii) for ii in inputs.index]
+    return inputs
+
+
+def _generate_solarposition_dataframe(inputs, algorithm, **kwargs):
+    """
+    Generate DataFrame with solar positions.
+
+    Each row is calculated separately due pd.DatetimeIndex being unable to
+    handle different timezones.
+    """
+    dfs = []
+    for index, row in inputs.iterrows():
+        try:
+            dfi = algorithm(
+                pd.DatetimeIndex([index]),
+                row['latitude'],
+                row['longitude'],
+                **kwargs,
+            )
+        except ValueError:
+            # Add empty row (nans)
+            dfi = pd.DataFrame(index=[index])
+        dfs.append(dfi)
+    return pd.concat(dfs, axis='rows')
+
+
+@pytest.mark.parametrize('algorithm,expected,kwargs', [
+    (iqbal, expected_iqbal, {}),
+    # (michalsky, expected_michalsky_original_julian,
+    #  {'spencer_correction': True, 'julian_date': 'original'}),
+    # (michalsky, expected_michalsky_correct_julian,
+    #  {'spencer_correction': False, 'julian_date': 'pandas'}),
+    # (noaa, expected_noaa, {}),
+    # (psa, expected_psa_2001, {'coefficients': 2001}),
+    # (psa, expected_psa_2020, {'coefficients': 2020}),
+    # (usno, expected_usno, {}),
+    # (sg2, expected_sg2, {}),
+    # (sg2_c.sg2, expected_sg2, {}),
+    # (walraven, expected_walraven, {}),
+])
+def test_algorithm(algorithm, expected, kwargs, test_conditions):
+    expected = expected().set_index(test_conditions.index)
+    result = _generate_solarposition_dataframe(
+        test_conditions, algorithm, **kwargs)
+    result.name = algorithm.__module__
+
+    pd.testing.assert_index_equal(expected.index, result.index)
+    rtol = 1e-3 if algorithm.__name__ == 'sg2' else 1e-6
+    print(algorithm.__name__)
+    pd.testing.assert_frame_equal(
+        expected, result, check_like=False, rtol=rtol)
+    for c in expected.columns:
+        pd.testing.assert_series_equal(expected[c], result[c], rtol=rtol)