pvlib 0.9.4a1__py3-none-any.whl → 0.10.0__py3-none-any.whl

pvlib/tests/bifacial/test_infinite_sheds.py

@@ -5,7 +5,6 @@ test infinite sheds
 import numpy as np
 import pandas as pd
 from pvlib.bifacial import infinite_sheds
-from pvlib.tools import cosd
 from ..conftest import assert_series_equal
 
 import pytest
@@ -42,107 +41,6 @@ def test_system():
     return syst, pts, vfs_ground_sky
 
 
-def test__vf_ground_sky_integ(test_system):
-    ts, pts, vfs_gnd_sky = test_system
-    # pass rotation here since max_rows=1 for the hand-solved case in
-    # the fixture test_system, which means the ground-to-sky view factor
-    # isn't summed over enough rows for symmetry to hold.
-    vf_integ = infinite_sheds._vf_ground_sky_integ(
-        ts['rotation'], ts['surface_azimuth'],
-        ts['gcr'], ts['height'], ts['pitch'],
-        max_rows=1, npoints=3)
-    expected_vf_integ = np.trapz(vfs_gnd_sky, pts)
-    assert np.isclose(vf_integ, expected_vf_integ, rtol=0.1)
-
-
-def test__vf_row_sky_integ(test_system):
-    ts, _, _ = test_system
-    gcr = ts['gcr']
-    surface_tilt = ts['surface_tilt']
-    f_x = np.array([0., 0.5, 1.])
-    shaded = []
-    noshade = []
-    for x in f_x:
-        s, ns = infinite_sheds._vf_row_sky_integ(
-            x, surface_tilt, gcr, npoints=100)
-        shaded.append(s)
-        noshade.append(ns)
-
-    def analytic(gcr, surface_tilt, x):
-        c = cosd(surface_tilt)
-        a = 1. / gcr
-        dx = np.sqrt(a**2 - 2 * a * c * x + x**2)
-        return - a * (c**2 - 1) * np.arctanh((x - a * c) / dx) - c * dx
-
-    expected_shade = 0.5 * (f_x * cosd(surface_tilt)
-                            - analytic(gcr, surface_tilt, 1 - f_x)
-                            + analytic(gcr, surface_tilt, 1.))
-    expected_noshade = 0.5 * ((1 - f_x) * cosd(surface_tilt)
-                              + analytic(gcr, surface_tilt, 1. - f_x)
-                              - analytic(gcr, surface_tilt, 0.))
-    shaded = np.array(shaded)
-    noshade = np.array(noshade)
-    assert np.allclose(shaded, expected_shade)
-    assert np.allclose(noshade, expected_noshade)
-
-
-def test__poa_sky_diffuse_pv():
-    dhi = np.array([np.nan, 0.0, 500.])
-    f_x = np.array([0.2, 0.2, 0.5])
-    vf_shade_sky_integ = np.array([1.0, 0.5, 0.2])
-    vf_noshade_sky_integ = np.array([0.0, 0.5, 0.8])
-    poa = infinite_sheds._poa_sky_diffuse_pv(
-        f_x, dhi, vf_shade_sky_integ, vf_noshade_sky_integ)
-    expected_poa = np.array([np.nan, 0.0, 500 * (0.5 * 0.2 + 0.5 * 0.8)])
-    assert np.allclose(poa, expected_poa, equal_nan=True)
-
-
-def test__ground_angle(test_system):
-    ts, _, _ = test_system
-    x = np.array([0., 0.5, 1.0])
-    angles = infinite_sheds._ground_angle(
-        x, ts['surface_tilt'], ts['gcr'])
-    expected_angles = np.array([0., 5.866738789543952, 9.896090638982903])
-    assert np.allclose(angles, expected_angles)
-
-
-def test__vf_row_ground(test_system):
-    ts, _, _ = test_system
-    x = np.array([0., 0.5, 1.0])
-    sqr3 = np.sqrt(3)
-    vfs = infinite_sheds._vf_row_ground(
-        x, ts['surface_tilt'], ts['gcr'])
-    expected_vfs = np.array([
-        0.5 * (1. - sqr3 / 2),
-        0.5 * ((4 + sqr3 / 2) / np.sqrt(17 + 4 * sqr3) - sqr3 / 2),
-        0.5 * ((4 + sqr3) / np.sqrt(20 + 8 * sqr3) - sqr3 / 2)])
-    assert np.allclose(vfs, expected_vfs)
-
-
-def test__vf_row_ground_integ(test_system):
-    ts, _, _ = test_system
-    gcr = ts['gcr']
-    surface_tilt = ts['surface_tilt']
-    f_x = np.array([0., 0.5, 1.0])
-    shaded, noshade = infinite_sheds._vf_row_ground_integ(
-        f_x, surface_tilt, gcr)
-
-    def analytic(x, surface_tilt, gcr):
-        c = cosd(surface_tilt)
-        a = 1. / gcr
-        dx = np.sqrt(a**2 + 2 * a * c * x + x**2)
-        return c * dx - a * (c**2 - 1) * np.arctanh((a * c + x) / dx)
-
-    expected_shade = 0.5 * (analytic(f_x, surface_tilt, gcr)
-                            - analytic(0., surface_tilt, gcr)
-                            - f_x * cosd(surface_tilt))
-    expected_noshade = 0.5 * (analytic(1., surface_tilt, gcr)
-                              - analytic(f_x, surface_tilt, gcr)
-                              - (1. - f_x) * cosd(surface_tilt))
-    assert np.allclose(shaded, expected_shade)
-    assert np.allclose(noshade, expected_noshade)
-
-
 def test__poa_ground_shadows():
     poa_ground, f_gnd_beam, df, vf_gnd_sky = (300., 0.5, 0.5, 0.2)
     result = infinite_sheds._poa_ground_shadows(
@@ -254,7 +152,8 @@ def test__backside_tilt():
     assert np.allclose(back_az, np.array([0., 330., 90., 180.]))
 
 
-def test_get_irradiance():
+@pytest.mark.parametrize("vectorize", [True, False])
+def test_get_irradiance(vectorize):
     # singleton inputs
     solar_zenith = 0.
     solar_azimuth = 180.
@@ -274,7 +173,7 @@ def test_get_irradiance():
         surface_tilt, surface_azimuth, solar_zenith, solar_azimuth,
         gcr, height, pitch, ghi, dhi, dni, albedo, iam_front, iam_back,
         bifaciality=0.8, shade_factor=-0.02, transmission_factor=0,
-        npoints=npoints)
+        npoints=npoints, vectorize=vectorize)
     expected_front_diffuse = np.array([300.])
     expected_front_direct = np.array([700.])
     expected_front_global = expected_front_diffuse + expected_front_direct
@@ -292,11 +191,11 @@ def test_get_irradiance():
         surface_tilt, surface_azimuth, solar_zenith, solar_azimuth,
         gcr, height, pitch, ghi, dhi, dni, albedo, iam_front, iam_back,
         bifaciality=0.8, shade_factor=-0.02, transmission_factor=0,
-        npoints=npoints)
+        npoints=npoints, vectorize=vectorize)
     result_front = infinite_sheds.get_irradiance_poa(
         surface_tilt, surface_azimuth, solar_zenith, solar_azimuth,
         gcr, height, pitch, ghi, dhi, dni,
-        albedo, iam=iam_front)
+        albedo, iam=iam_front, vectorize=vectorize)
     assert isinstance(result, pd.DataFrame)
     expected_poa_global = pd.Series(
         [1000., 500., result_front['poa_global'][2] * (1 + 0.8 * 0.98),
@@ -345,3 +244,42 @@ def test_get_irradiance_limiting_gcr():
                       result['poa_back_sky_diffuse'])
     assert np.isclose(result['poa_front_ground_diffuse'],
                       result['poa_back_ground_diffuse'])
+
+
+def test_get_irradiance_with_haydavies():
+    # singleton inputs
+    solar_zenith = 0.
+    solar_azimuth = 180.
+    surface_tilt = 0.
+    surface_azimuth = 180.
+    gcr = 0.5
+    height = 1.
+    pitch = 1.
+    ghi = 1000.
+    dhi = 300.
+    dni = 700.
+    albedo = 0.
+    dni_extra = 1413.
+    model = 'haydavies'
+    iam_front = 1.0
+    iam_back = 1.0
+    npoints = 100
+    result = infinite_sheds.get_irradiance(
+        surface_tilt, surface_azimuth, solar_zenith, solar_azimuth,
+        gcr, height, pitch, ghi, dhi, dni, albedo, model, dni_extra,
+        iam_front, iam_back, bifaciality=0.8, shade_factor=-0.02,
+        transmission_factor=0, npoints=npoints)
+    expected_front_diffuse = np.array([151.38])
+    expected_front_direct = np.array([848.62])
+    expected_front_global = expected_front_diffuse + expected_front_direct
+    assert np.isclose(result['poa_front'], expected_front_global)
+    assert np.isclose(result['poa_front_diffuse'], expected_front_diffuse)
+    assert np.isclose(result['poa_front_direct'], expected_front_direct)
+    assert np.isclose(result['poa_global'], result['poa_front'])
+    # test for when dni_extra is not supplied
+    with pytest.raises(ValueError, match='supply dni_extra for haydavies'):
+        result = infinite_sheds.get_irradiance(
+            surface_tilt, surface_azimuth, solar_zenith, solar_azimuth,
+            gcr, height, pitch, ghi, dhi, dni, albedo, model, None,
+            iam_front, iam_back, bifaciality=0.8, shade_factor=-0.02,
+            transmission_factor=0, npoints=npoints)

pvlib/tests/bifacial/test_utils.py

@@ -4,6 +4,8 @@ test bifical.utils
 import numpy as np
 import pytest
 from pvlib.bifacial import utils
+from pvlib.shading import masking_angle, ground_angle
+from pvlib.tools import cosd
 
 
 @pytest.fixture
@@ -35,7 +37,7 @@ def test_system_fixed_tilt():
     c22 = (-2 - sqr3) / np.sqrt(1.25**2 + (2 + sqr3)**2)  # right edge row 0
     c23 = (0 - sqr3) / np.sqrt(1.25**2 + (0 - sqr3)**2)  # right edge row 1
     vf_2 = 0.5 * (c23 - c22 + c21 - c20)  # vf at point 1
-    vfs_ground_sky = np.array([vf_0, vf_1, vf_2])
+    vfs_ground_sky = np.array([[vf_0], [vf_1], [vf_2]])
     return syst, pts, vfs_ground_sky
 
 
@@ -79,10 +81,105 @@ def test__unshaded_ground_fraction(
 def test__vf_ground_sky_2d(test_system_fixed_tilt):
     # vector input
     ts, pts, vfs_gnd_sky = test_system_fixed_tilt
-    vfs, _ = utils._vf_ground_sky_2d(pts, ts['rotation'], ts['gcr'],
-                                     ts['pitch'], ts['height'], max_rows=1)
+    vfs = utils.vf_ground_sky_2d(ts['rotation'], ts['gcr'], pts,
+                                 ts['pitch'], ts['height'], max_rows=1)
     assert np.allclose(vfs, vfs_gnd_sky, rtol=0.1)  # middle point vf is off
     # test with singleton x
-    vf, _ = utils._vf_ground_sky_2d(pts[0], ts['rotation'], ts['gcr'],
-                                    ts['pitch'], ts['height'], max_rows=1)
+    vf = utils.vf_ground_sky_2d(ts['rotation'], ts['gcr'], pts[0],
+                                ts['pitch'], ts['height'], max_rows=1)
     assert np.isclose(vf, vfs_gnd_sky[0])
+
+
+@pytest.mark.parametrize("vectorize", [True, False])
+def test_vf_ground_sky_2d_integ(test_system_fixed_tilt, vectorize):
+    ts, pts, vfs_gnd_sky = test_system_fixed_tilt
+    # pass rotation here since max_rows=1 for the hand-solved case in
+    # the fixture test_system, which means the ground-to-sky view factor
+    # isn't summed over enough rows for symmetry to hold.
+    vf_integ = utils.vf_ground_sky_2d_integ(
+        ts['rotation'], ts['gcr'], ts['height'], ts['pitch'],
+        max_rows=1, npoints=3, vectorize=vectorize)
+    expected_vf_integ = np.trapz(vfs_gnd_sky, pts, axis=0)
+    assert np.isclose(vf_integ, expected_vf_integ, rtol=0.1)
+
+
+def test_vf_row_sky_2d(test_system_fixed_tilt):
+    ts, _, _ = test_system_fixed_tilt
+    # with float input, fx at top of row
+    vf = utils.vf_row_sky_2d(ts['surface_tilt'], ts['gcr'], 1.)
+    expected = 0.5 * (1 + cosd(ts['surface_tilt']))
+    assert np.isclose(vf, expected)
+    # with array input
+    fx = np.array([0., 0.5, 1.])
+    vf = utils.vf_row_sky_2d(ts['surface_tilt'], ts['gcr'], fx)
+    phi = masking_angle(ts['surface_tilt'], ts['gcr'], fx)
+    expected = 0.5 * (1 + cosd(ts['surface_tilt'] + phi))
+    assert np.allclose(vf, expected)
+
+
+def test_vf_row_sky_2d_integ(test_system_fixed_tilt):
+    ts, _, _ = test_system_fixed_tilt
+    # with float input, check end position
+    vf = utils.vf_row_sky_2d_integ(ts['surface_tilt'], ts['gcr'], 1., 1.)
+    expected = utils.vf_row_sky_2d(ts['surface_tilt'], ts['gcr'], 1.)
+    assert np.isclose(vf, expected)
+    # with array input
+    fx0 = np.array([0., 0.5])
+    fx1 = np.array([0., 0.8])
+    vf = utils.vf_row_sky_2d_integ(ts['surface_tilt'], ts['gcr'], fx0, fx1)
+    phi = masking_angle(ts['surface_tilt'], ts['gcr'], fx0[0])
+    y0 = 0.5 * (1 + cosd(ts['surface_tilt'] + phi))
+    x = np.arange(fx0[1], fx1[1], 1e-4)
+    phi_y = masking_angle(ts['surface_tilt'], ts['gcr'], x)
+    y = 0.5 * (1 + cosd(ts['surface_tilt'] + phi_y))
+    y1 = np.trapz(y, x) / (fx1[1] - fx0[1])
+    expected = np.array([y0, y1])
+    assert np.allclose(vf, expected, rtol=1e-3)
+    # with defaults (0, 1)
+    vf = utils.vf_row_sky_2d_integ(ts['surface_tilt'], ts['gcr'])
+    x = np.arange(0, 1, 1e-4)
+    phi_y = masking_angle(ts['surface_tilt'], ts['gcr'], x)
+    y = 0.5 * (1 + cosd(ts['surface_tilt'] + phi_y))
+    y1 = np.trapz(y, x) / (1 - 0)
+    assert np.allclose(vf, y1, rtol=1e-3)
+
+
+def test_vf_row_ground_2d(test_system_fixed_tilt):
+    ts, _, _ = test_system_fixed_tilt
+    # with float input, fx at bottom of row
+    vf = utils.vf_row_ground_2d(ts['surface_tilt'], ts['gcr'], 0.)
+    expected = 0.5 * (1. - cosd(ts['surface_tilt']))
+    assert np.isclose(vf, expected)
+    # with array input
+    fx = np.array([0., 0.5, 1.0])
+    vf = utils.vf_row_ground_2d(ts['surface_tilt'], ts['gcr'], fx)
+    phi = ground_angle(ts['surface_tilt'], ts['gcr'], fx)
+    expected = 0.5 * (1 - cosd(phi - ts['surface_tilt']))
+    assert np.allclose(vf, expected)
+
+
+def test_vf_ground_2d_integ(test_system_fixed_tilt):
+    ts, _, _ = test_system_fixed_tilt
+    # with float input, check end position
+    vf = utils.vf_row_ground_2d_integ(ts['surface_tilt'], ts['gcr'], 0., 0.)
+    expected = utils.vf_row_ground_2d(ts['surface_tilt'], ts['gcr'], 0.)
+    assert np.isclose(vf, expected)
+    # with array input
+    fx0 = np.array([0., 0.5])
+    fx1 = np.array([0., 0.8])
+    vf = utils.vf_row_ground_2d_integ(ts['surface_tilt'], ts['gcr'], fx0, fx1)
+    phi = ground_angle(ts['surface_tilt'], ts['gcr'], fx0[0])
+    y0 = 0.5 * (1 - cosd(phi - ts['surface_tilt']))
+    x = np.arange(fx0[1], fx1[1], 1e-4)
+    phi_y = ground_angle(ts['surface_tilt'], ts['gcr'], x)
+    y = 0.5 * (1 - cosd(phi_y - ts['surface_tilt']))
+    y1 = np.trapz(y, x) / (fx1[1] - fx0[1])
+    expected = np.array([y0, y1])
+    assert np.allclose(vf, expected, rtol=1e-2)
+    # with defaults (0, 1)
+    vf = utils.vf_row_ground_2d_integ(ts['surface_tilt'], ts['gcr'], 0, 1)
+    x = np.arange(0, 1, 1e-4)
+    phi_y = ground_angle(ts['surface_tilt'], ts['gcr'], x)
+    y = 0.5 * (1 - cosd(phi_y - ts['surface_tilt']))
+    y1 = np.trapz(y, x) / (1 - 0)
+    assert np.allclose(vf, y1, rtol=1e-2)

pvlib/tests/conftest.py

@@ -141,23 +141,6 @@ def has_numba():
 
 requires_numba = pytest.mark.skipif(not has_numba(), reason="requires numba")
 
-try:
-    import siphon
-    has_siphon = True
-except ImportError:
-    has_siphon = False
-
-requires_siphon = pytest.mark.skipif(not has_siphon,
-                                     reason='requires siphon')
-
-try:
-    import netCDF4  # noqa: F401
-    has_netCDF4 = True
-except ImportError:
-    has_netCDF4 = False
-
-requires_netCDF4 = pytest.mark.skipif(not has_netCDF4,
-                                      reason='requires netCDF4')
 
 try:
     import pvfactors  # noqa: F401
@@ -178,20 +161,6 @@ except ImportError:
 requires_pysam = pytest.mark.skipif(not has_pysam, reason="requires PySAM")
 
 
-try:
-    import cftime  # noqa: F401
-
-    has_recent_cftime = parse_version(cftime.__version__) > parse_version(
-        "1.1.0"
-    )
-except ImportError:
-    has_recent_cftime = False
-
-requires_recent_cftime = pytest.mark.skipif(
-    not has_recent_cftime, reason="requires cftime > 1.1.0"
-)
-
-
 @pytest.fixture()
 def golden():
     return Location(39.742476, -105.1786, 'America/Denver', 1830.14)

pvlib/tests/iotools/test_acis.py

@@ -0,0 +1,213 @@
+"""
+tests for :mod:`pvlib.iotools.acis`
+"""
+
+import pandas as pd
+import numpy as np
+import pytest
+from pvlib.iotools import (
+    get_acis_prism, get_acis_nrcc, get_acis_mpe,
+    get_acis_station_data, get_acis_available_stations
+)
+from ..conftest import RERUNS, RERUNS_DELAY, assert_frame_equal
+from requests import HTTPError
+
+
+@pytest.mark.remote_data
+@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
+def test_get_acis_prism():
+    # map_variables=True
+    df, meta = get_acis_prism(40.001, -80.001, '2020-01-01', '2020-01-02')
+    expected = pd.DataFrame(
+        [
+            [0.5, 5, 0, 2.5, 0, 62, 0],
+            [0, 5, -3, 1, 0, 64, 0]
+        ],
+        columns=['precipitation', 'temp_air_max', 'temp_air_min',
+                 'temp_air_average', 'cooling_degree_days',
+                 'heating_degree_days', 'growing_degree_days'],
+        index=pd.to_datetime(['2020-01-01', '2020-01-02']),
+    )
+    assert_frame_equal(df, expected)
+    expected_meta = {'latitude': 40, 'longitude': -80, 'altitude': 298.0944}
+    assert meta == expected_meta
+
+    # map_variables=False
+    df, meta = get_acis_prism(40.001, -80.001, '2020-01-01', '2020-01-02',
+                              map_variables=False)
+    expected.columns = ['pcpn', 'maxt', 'mint', 'avgt', 'cdd', 'hdd', 'gdd']
+    assert_frame_equal(df, expected)
+    expected_meta = {'lat': 40, 'lon': -80, 'elev': 298.0944}
+    assert meta == expected_meta
+
+
+@pytest.mark.remote_data
+@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
+@pytest.mark.parametrize('grid, expected', [
+    (1, [[0.51, 5, 0, 2.5, 0, 62, 0]]),
+    (3, [[0.51, 5, -1, 2.0, 0, 63, 0]])
+])
+def test_get_acis_nrcc(grid, expected):
+    # map_variables=True
+    df, meta = get_acis_nrcc(40.001, -80.001, '2020-01-01', '2020-01-01', grid)
+    expected = pd.DataFrame(
+        expected,
+        columns=['precipitation', 'temp_air_max', 'temp_air_min',
+                 'temp_air_average', 'cooling_degree_days',
+                 'heating_degree_days', 'growing_degree_days'],
+        index=pd.to_datetime(['2020-01-01']),
+    )
+    assert_frame_equal(df, expected)
+    expected_meta = {'latitude': 40., 'longitude': -80., 'altitude': 356.9208}
+    assert meta == pytest.approx(expected_meta)
+
+    # map_variables=False
+    df, meta = get_acis_nrcc(40.001, -80.001, '2020-01-01', '2020-01-01', grid,
+                             map_variables=False)
+    expected.columns = ['pcpn', 'maxt', 'mint', 'avgt', 'cdd', 'hdd', 'gdd']
+    assert_frame_equal(df, expected)
+    expected_meta = {'lat': 40., 'lon': -80., 'elev': 356.9208}
+    assert meta == pytest.approx(expected_meta)
+
+
+@pytest.mark.remote_data
+@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
+def test_get_acis_nrcc_error():
+    with pytest.raises(HTTPError, match='invalid grid'):
+        # 50 is not a valid dataset (or "grid", in ACIS lingo)
+        _ = get_acis_nrcc(40, -80, '2012-01-01', '2012-01-01', 50)
+
+
+@pytest.mark.remote_data
+@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
+def test_get_acis_mpe():
+    # map_variables=True
+    df, meta = get_acis_mpe(40.001, -80.001, '2020-01-01', '2020-01-02')
+    expected = pd.DataFrame(
+        {'precipitation': [0.4, 0.0]},
+        index=pd.to_datetime(['2020-01-01', '2020-01-02']),
+    )
+    assert_frame_equal(df, expected)
+    expected_meta = {'latitude': 40.0083, 'longitude': -79.9653}
+    assert meta == expected_meta
+
+    # map_variables=False
+    df, meta = get_acis_mpe(40.001, -80.001, '2020-01-01', '2020-01-02',
+                            map_variables=False)
+    expected.columns = ['pcpn']
+    assert_frame_equal(df, expected)
+    expected_meta = {'lat': 40.0083, 'lon': -79.9653}
+    assert meta == expected_meta
+
+
+@pytest.mark.remote_data
+@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
+def test_get_acis_station_data():
+    # map_variables=True
+    df, meta = get_acis_station_data('ORD', '2020-01-10', '2020-01-12',
+                                     trace_val=-99)
+    expected = pd.DataFrame(
+        [[10., 2., 6., np.nan, 21.34, 0., 0., 0., 59., 0.],
+         [3., -4., -0.5, np.nan, 9.4, 5.3, 0., 0., 65., 0.],
+         [-1., -5., -3., np.nan, -99, -99, 5., 0., 68., 0.]],
+        columns=['temp_air_max', 'temp_air_min', 'temp_air_average',
+                 'temp_air_observation', 'precipitation', 'snowfall',
+                 'snowdepth', 'cooling_degree_days',
+                 'heating_degree_days', 'growing_degree_days'],
+        index=pd.to_datetime(['2020-01-10', '2020-01-11', '2020-01-12']),
+    )
+    assert_frame_equal(df, expected)
+    expected_meta = {
+        'uid': 48,
+        'state': 'IL',
+        'name': 'CHICAGO OHARE INTL AP',
+        'altitude': 204.8256,
+        'latitude': 41.96017,
+        'longitude': -87.93164
+    }
+    expected_meta = {
+        'valid_daterange': [
+            ['1958-11-01', '2023-06-15'],
+            ['1958-11-01', '2023-06-15'],
+            ['1958-11-01', '2023-06-15'],
+            [],
+            ['1958-11-01', '2023-06-15'],
+            ['1958-11-01', '2023-06-15'],
+            ['1958-11-01', '2023-06-15'],
+            ['1958-11-01', '2023-06-15'],
+            ['1958-11-01', '2023-06-15'],
+            ['1958-11-01', '2023-06-15']
+        ],
+        'name': 'CHICAGO OHARE INTL AP',
+        'sids': ['94846 1', '111549 2', 'ORD 3', '72530 4', 'KORD 5',
+                 'USW00094846 6', 'ORD 7', 'USW00094846 32'],
+        'county': '17031',
+        'state': 'IL',
+        'climdiv': 'IL02',
+        'uid': 48,
+        'tzo': -6.0,
+        'sid_dates': [
+            ['94846 1', '1989-01-19', '9999-12-31'],
+            ['94846 1', '1958-10-30', '1989-01-01'],
+            ['111549 2', '1989-01-19', '9999-12-31'],
+            ['111549 2', '1958-10-30', '1989-01-01'],
+            ['ORD 3', '1989-01-19', '9999-12-31'],
+            ['ORD 3', '1958-10-30', '1989-01-01'],
+            ['72530 4', '1989-01-19', '9999-12-31'],
+            ['72530 4', '1958-10-30', '1989-01-01'],
+            ['KORD 5', '1989-01-19', '9999-12-31'],
+            ['KORD 5', '1958-10-30', '1989-01-01'],
+            ['USW00094846 6', '1989-01-19', '9999-12-31'],
+            ['USW00094846 6', '1958-10-30', '1989-01-01'],
+            ['ORD 7', '1989-01-19', '9999-12-31'],
+            ['ORD 7', '1958-10-30', '1989-01-01'],
+            ['USW00094846 32', '1989-01-19', '9999-12-31'],
+            ['USW00094846 32', '1958-10-30', '1989-01-01']],
+        'altitude': 204.8256,
+        'longitude': -87.93164,
+        'latitude': 41.96017
+    }
+    # don't check valid dates since they get extended every day
+    meta.pop("valid_daterange")
+    expected_meta.pop("valid_daterange")
+    assert meta == expected_meta
+
+    # map_variables=False
+    df, meta = get_acis_station_data('ORD', '2020-01-10', '2020-01-12',
+                                     trace_val=-99, map_variables=False)
+    expected.columns = ['maxt', 'mint', 'avgt', 'obst', 'pcpn', 'snow',
+                        'snwd', 'cdd', 'hdd', 'gdd']
+    assert_frame_equal(df, expected)
+    expected_meta['lat'] = expected_meta.pop('latitude')
+    expected_meta['lon'] = expected_meta.pop('longitude')
+    expected_meta['elev'] = expected_meta.pop('altitude')
+    meta.pop("valid_daterange")
+    assert meta == expected_meta
+
+
+@pytest.mark.remote_data
+@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
+def test_get_acis_available_stations():
+    # use a very narrow bounding box to hopefully make this test less likely
+    # to fail due to new stations being added in the future
+    lat, lon = 39.8986, -80.1656
+    stations = get_acis_available_stations([lat - 0.0001, lat + 0.0001],
+                                           [lon - 0.0001, lon + 0.0001])
+    assert len(stations) == 1
+    station = stations.iloc[0]
+
+    # test the more relevant values
+    assert station['name'] == 'WAYNESBURG 1 E'
+    assert station['sids'] == ['369367 2', 'USC00369367 6', 'WYNP1 7']
+    assert station['state'] == 'PA'
+    assert station['altitude'] == 940.
+    assert station['tzo'] == -5.0
+    assert station['latitude'] == lat
+    assert station['longitude'] == lon
+
+    # check that start/end work as filters
+    stations = get_acis_available_stations([lat - 0.0001, lat + 0.0001],
+                                           [lon - 0.0001, lon + 0.0001],
+                                           start='1900-01-01',
+                                           end='1900-01-02')
+    assert stations.empty

pvlib/tests/iotools/test_midc.py

@@ -27,9 +27,9 @@ MIDC_RAW_SHORT_HEADER_TESTFILE = (
 #                          '?site=UAT&begin=20181018&end=20181019')
 
 
-def test_midc_format_index():
+def test_midc__format_index():
     data = pd.read_csv(MIDC_TESTFILE)
-    data = midc.format_index(data)
+    data = midc._format_index(data)
     start = pd.Timestamp("20181014 00:00")
     start = start.tz_localize("MST")
     end = pd.Timestamp("20181014 23:59")
@@ -39,16 +39,16 @@ def test_midc_format_index():
     assert data.index[-1] == end
 
 
-def test_midc_format_index_tz_conversion():
+def test_midc__format_index_tz_conversion():
     data = pd.read_csv(MIDC_TESTFILE)
     data = data.rename(columns={'MST': 'PST'})
-    data = midc.format_index(data)
+    data = midc._format_index(data)
     assert data.index[0].tz == pytz.timezone('Etc/GMT+8')
 
 
-def test_midc_format_index_raw():
+def test_midc__format_index_raw():
     data = pd.read_csv(MIDC_RAW_TESTFILE)
-    data = midc.format_index_raw(data)
+    data = midc._format_index_raw(data)
     start = pd.Timestamp('20181018 00:00')
     start = start.tz_localize('MST')
     end = pd.Timestamp('20181018 23:59')

pvlib/tests/iotools/test_psm3.py

@@ -170,11 +170,11 @@ def test_read_psm3():
 def test_read_psm3_map_variables():
     """test read_psm3 map_variables=True"""
     data, metadata = psm3.read_psm3(MANUAL_TEST_DATA, map_variables=True)
-    columns_mapped = ['Year', 'Month', 'Day', 'Hour', 'Minute', 'dhi', 'dni',
-                      'ghi', 'dhi_clear', 'dni_clear', 'ghi_clear',
+    columns_mapped = ['Year', 'Month', 'Day', 'Hour', 'Minute', 'dhi', 'ghi',
+                      'dni', 'ghi_clear', 'dhi_clear', 'dni_clear',
                       'Cloud Type', 'Dew Point', 'solar_zenith',
                       'Fill Flag', 'albedo', 'wind_speed',
-                      'precipitable_water', 'wind_direction',
+                      'wind_direction', 'precipitable_water',
                       'relative_humidity', 'temp_air', 'pressure']
     data, metadata = psm3.read_psm3(MANUAL_TEST_DATA, map_variables=True)
     assert_index_equal(data.columns, pd.Index(columns_mapped))
@@ -189,8 +189,10 @@ def test_get_psm3_attribute_mapping(nrel_api_key):
                                names=2019, interval=60,
                                attributes=['ghi', 'wind_speed'],
                                leap_day=False, map_variables=True)
-    assert 'ghi' in data.columns
-    assert 'wind_speed' in data.columns
+    # Check that columns are in the correct order (GH1647)
+    expected_columns = [
+        'Year', 'Month', 'Day', 'Hour', 'Minute', 'ghi', 'wind_speed']
+    pd.testing.assert_index_equal(pd.Index(expected_columns), data.columns)
     assert 'latitude' in meta.keys()
     assert 'longitude' in meta.keys()
     assert 'altitude' in meta.keys()