pvlib 0.10.3__py3-none-any.whl → 0.10.5__py3-none-any.whl

pvlib/__init__.py

@@ -14,6 +14,7 @@ from pvlib import (  # noqa: F401
     ivtools,
     location,
     modelchain,
+    pvarray,
     pvsystem,
     scaling,
     shading,

pvlib/bifacial/utils.py

@@ -4,6 +4,7 @@ modeling.
 """
 import numpy as np
 from pvlib.tools import sind, cosd, tand
+from scipy.integrate import trapezoid
 
 
 def _solar_projection_tangent(solar_zenith, solar_azimuth, surface_azimuth):
@@ -220,7 +221,7 @@ def vf_ground_sky_2d_integ(surface_tilt, gcr, height, pitch, max_rows=10,
             vf = vf_ground_sky_2d(r, gcr, z, pitch, height, max_rows)
             fz_sky[:, k] = vf[:, 0]  # remove spurious rotation dimension
     # calculate the integrated view factor for all of the ground between rows
-    return np.trapz(fz_sky, z, axis=0)
+    return trapezoid(fz_sky, z, axis=0)
 
 
 def _vf_poly(surface_tilt, gcr, x, delta):

pvlib/clearsky.py

@@ -25,11 +25,11 @@ def ineichen(apparent_zenith, airmass_absolute, linke_turbidity,
     Implements the Ineichen and Perez clear sky model for global
     horizontal irradiance (GHI), direct normal irradiance (DNI), and
     calculates the clear-sky diffuse horizontal (DHI) component as the
-    difference between GHI and DNI*cos(zenith) as presented in [1, 2]. A
+    difference between GHI and DNI*cos(zenith) as presented in [1]_ [2]_. A
     report on clear sky models found the Ineichen/Perez model to have
-    excellent performance with a minimal input data set [3].
+    excellent performance with a minimal input data set [3]_.
 
-    Default values for monthly Linke turbidity provided by SoDa [4, 5].
+    Default values for monthly Linke turbidity provided by SoDa [4]_, [5]_.
 
     Parameters
     -----------
@@ -80,12 +80,12 @@ def ineichen(apparent_zenith, airmass_absolute, linke_turbidity,
        Clear Sky Models: Implementation and Analysis", Sandia National
        Laboratories, SAND2012-2389, 2012.
 
-    .. [4] http://www.soda-is.com/eng/services/climat_free_eng.php#c5 (obtained
-       July 17, 2012).
+    .. [4] https://www.soda-pro.com/help/general-knowledge/linke-turbidity-factor
+       (accessed February 2, 2024).
 
     .. [5] J. Remund, et. al., "Worldwide Linke Turbidity Information", Proc.
        ISES Solar World Congress, June 2003. Goteborg, Sweden.
-    '''
+    '''  # noqa: E501
 
     # ghi is calculated using either the equations in [1] by setting
     # perez_enhancement=False (default behavior) or using the model
@@ -993,8 +993,7 @@ def bird(zenith, airmass_relative, aod380, aod500, precipitable_water,
     .. [3] `NREL Bird Clear Sky Model <http://rredc.nrel.gov/solar/models/
        clearsky/>`_
 
-    .. [4] `SERI/TR-642-761 <http://rredc.nrel.gov/solar/pubs/pdfs/
-       tr-642-761.pdf>`_
+    .. [4] `SERI/TR-642-761 <https://www.nrel.gov/docs/legosti/old/761.pdf>`_
 
     .. [5] `Error Reports <http://rredc.nrel.gov/solar/models/clearsky/
        error_reports.html>`_

pvlib/iam.py

@@ -69,9 +69,9 @@ def ashrae(aoi, b=0.05):
 
     .. [2] ASHRAE standard 93-77
 
-    .. [3] PVsyst Contextual Help.
-       https://files.pvsyst.com/help/index.html?iam_loss.htm retrieved on
-       October 14, 2019
+    .. [3] PVsyst 7 Help.
+       https://www.pvsyst.com/help/index.html?iam_loss.htm retrieved on
+       January 30, 2024
 
     See Also
     --------

pvlib/inverter.py

@@ -532,9 +532,9 @@ def fit_sandia(ac_power, dc_power, dc_voltage, dc_voltage_level, p_ac_0, p_nt):
         p_s0 = solve_quad(a, b, c)
 
         # Add values to dataframe at index d
-        coeffs['a'][d] = a
-        coeffs['p_dc'][d] = p_dc
-        coeffs['p_s0'][d] = p_s0
+        coeffs.loc[d, 'a'] = a
+        coeffs.loc[d, 'p_dc'] = p_dc
+        coeffs.loc[d, 'p_s0'] = p_s0
 
     b_dc0, b_dc1, c1 = extract_c(x_d, coeffs['p_dc'])
     b_s0, b_s1, c2 = extract_c(x_d, coeffs['p_s0'])

pvlib/iotools/__init__.py

@@ -8,6 +8,7 @@ from pvlib.iotools.midc import read_midc  # noqa: F401
 from pvlib.iotools.midc import read_midc_raw_data_from_nrel  # noqa: F401
 from pvlib.iotools.crn import read_crn  # noqa: F401
 from pvlib.iotools.solrad import read_solrad  # noqa: F401
+from pvlib.iotools.solrad import get_solrad  # noqa: F401
 from pvlib.iotools.psm3 import get_psm3  # noqa: F401
 from pvlib.iotools.psm3 import read_psm3  # noqa: F401
 from pvlib.iotools.psm3 import parse_psm3  # noqa: F401
@@ -33,3 +34,4 @@ from pvlib.iotools.solcast import get_solcast_forecast  # noqa: F401
 from pvlib.iotools.solcast import get_solcast_live  # noqa: F401
 from pvlib.iotools.solcast import get_solcast_historic  # noqa: F401
 from pvlib.iotools.solcast import get_solcast_tmy  # noqa: F401
+from pvlib.iotools.solargis import get_solargis  # noqa: F401

pvlib/iotools/solargis.py

@@ -0,0 +1,214 @@
+"""Functions to retrieve and parse irradiance data from Solargis."""
+
+import pandas as pd
+import requests
+from dataclasses import dataclass
+import io
+
+URL = 'https://solargis.info/ws/rest/datadelivery/request'
+
+
+TIME_RESOLUTION_MAP = {
+    5: 'MIN_5', 10: 'MIN_10', 15: 'MIN_15', 30:  'MIN_30', 60: 'HOURLY',
+    'PT05M': 'MIN_5', 'PT5M': 'MIN_5', 'PT10M': 'MIN_10', 'PT15M': 'MIN_15',
+    'PT30': 'MIN_30', 'PT60M': 'HOURLY', 'PT1H': 'HOURLY', 'P1D': 'DAILY',
+    'P1M': 'MONTHLY', 'P1Y': 'YEARLY'}
+
+
+@dataclass
+class ParameterMap:
+    solargis_name: str
+    pvlib_name: str
+    conversion: callable = lambda x: x
+
+
+# define the conventions between Solargis and pvlib nomenclature and units
+VARIABLE_MAP = [
+    # Irradiance (unit varies based on time resolution)
+    ParameterMap('GHI', 'ghi'),
+    ParameterMap('GHI_C', 'ghi_clear'),  # this is stated in documentation
+    ParameterMap('GHIc', 'ghi_clear'),  # this is used in practice
+    ParameterMap('DNI', 'dni'),
+    ParameterMap('DNI_C', 'dni_clear'),
+    ParameterMap('DNIc', 'dni_clear'),
+    ParameterMap('DIF', 'dhi'),
+    ParameterMap('GTI', 'poa_global'),
+    ParameterMap('GTI_C', 'poa_global_clear'),
+    ParameterMap('GTIc', 'poa_global_clear'),
+    # Solar position
+    ParameterMap('SE', 'solar_elevation'),
+    # SA -> solar_azimuth (degrees) (different convention)
+    ParameterMap("SA", "solar_azimuth", lambda x: x + 180),
+    # Weather / atmospheric parameters
+    ParameterMap('TEMP', 'temp_air'),
+    ParameterMap('TD', 'temp_dew'),
+    # surface_pressure (hPa) -> pressure (Pa)
+    ParameterMap('AP', 'pressure', lambda x: x*100),
+    ParameterMap('RH', 'relative_humidity'),
+    ParameterMap('WS', 'wind_speed'),
+    ParameterMap('WD', 'wind_direction'),
+    ParameterMap('INC', 'aoi'),  # angle of incidence of direct irradiance
+    # precipitable_water (kg/m2) -> precipitable_water (cm)
+    ParameterMap('PWAT', 'precipitable_water', lambda x: x/10),
+]
+
+METADATA_FIELDS = [
+    'issued', 'site name', 'latitude', 'longitude', 'elevation',
+    'summarization type', 'summarization period'
+]
+
+
+# Variables that use "-9" as nan values
+NA_9_COLUMNS = ['GHI', 'GHIc', 'DNI', 'DNIc', 'DIF', 'GTI', 'GIc', 'KT', 'PAR',
+                'PREC', 'PWAT', 'SDWE', 'SFWE']
+
+
+def get_solargis(latitude, longitude, start, end, variables, api_key,
+                 time_resolution, timestamp_type='center', tz='GMT+00',
+                 terrain_shading=True, url=URL, map_variables=True,
+                 timeout=30):
+    """
+    Retrieve irradiance time series data from Solargis.
+
+    The Solargis [1]_ API is described in [2]_.
+
+    Parameters
+    ----------
+    latitude: float
+        In decimal degrees, between -90 and 90, north is positive (ISO 19115)
+    longitude: float
+        In decimal degrees, between -180 and 180, east is positive (ISO 19115)
+    start : datetime-like
+        Start date of time series.
+    end : datetime-like
+        End date of time series.
+    variables : list
+        List of variables to request, see [2]_ for options.
+    api_key : str
+        API key.
+    time_resolution : str, {'PT05M', 'PT10M', 'PT15M', 'PT30', 'PT1H', 'P1D', 'P1M', 'P1Y'}
+        Time resolution as an integer number of minutes (e.g. 5, 60)
+        or an ISO 8601 duration string (e.g. "PT05M", "PT60M", "P1M").
+    timestamp_type : {'start', 'center', 'end'}, default: 'center'
+        Labeling of time stamps of the return data.
+    tz : str, default : 'GMT+00'
+        Timezone of `start` and `end` in the format "GMT+hh" or "GMT-hh".
+    terrain_shading : boolean, default: True
+        Whether to account for horizon shading.
+    url : str, default : :const:`pvlib.iotools.solargis.URL`
+        Base url of Solargis API.
+    map_variables : boolean, default: True
+        When true, renames columns of the Dataframe to pvlib variable names
+        where applicable. See variable :const:`VARIABLE_MAP`.
+    timeout : int or float, default: 30
+        Time in seconds to wait for server response before timeout
+
+    Returns
+    -------
+    data : DataFrame
+        DataFrame containing time series data.
+    meta : dict
+        Dictionary containing metadata.
+
+    Raises
+    ------
+    requests.HTTPError
+        A message from the Solargis server if the request is rejected
+
+    Notes
+    -----
+    Each XML request is limited to retrieving 31 days of data.
+
+    The variable units depends on the time frequency, e.g., the unit for
+    sub-hourly irradiance data is :math:`W/m^2`, for hourly data it is
+    :math:`Wh/m^2`, and for daily data it is :math:`kWh/m^2`.
+
+    References
+    ----------
+    .. [1] `Solargis <https://solargis.com>`_
+    .. [2] `Solargis API User Guide
+       <https://solargis.atlassian.net/wiki/spaces/public/pages/7602367/Solargis+API+User+Guide>`_
+
+    Examples
+    --------
+    >>> # Retrieve two days of irradiance data from Solargis
+    >>> data, meta = response = pvlib.iotools.get_solargis(
+    >>>     latitude=48.61259, longitude=20.827079,
+    >>>     start='2022-01-01', end='2022-01-02',
+    >>>     variables=['GHI', 'DNI'], time_resolution='PT05M', api_key='demo')
+    """  # noqa: E501
+    # Use pd.to_datetime so that strings (e.g. '2021-01-01') are accepted
+    start = pd.to_datetime(start)
+    end = pd.to_datetime(end)
+
+    headers = {'Content-Type': 'application/xml'}
+
+    # Solargis recommends creating a unique site_id for each location request.
+    # The site_id does not impact the data retrieval and is used for debugging.
+    site_id = f"latitude_{latitude}_longitude_{longitude}"
+
+    request_xml = f'''<ws:dataDeliveryRequest
+    dateFrom="{start.strftime('%Y-%m-%d')}"
+    dateTo="{end.strftime('%Y-%m-%d')}"
+    xmlns="http://geomodel.eu/schema/data/request"
+    xmlns:ws="http://geomodel.eu/schema/ws/data"
+    xmlns:geo="http://geomodel.eu/schema/common/geo"
+    xmlns:pv="http://geomodel.eu/schema/common/pv"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <site id="{site_id}" name="" lat="{latitude}" lng="{longitude}">
+    </site>
+    <processing key="{' '.join(variables)}"
+    summarization="{TIME_RESOLUTION_MAP.get(time_resolution, time_resolution).upper()}"
+    terrainShading="{str(terrain_shading).lower()}">
+    <timestampType>{timestamp_type.upper()}</timestampType>
+    <timeZone>{tz}</timeZone>
+    </processing>
+    </ws:dataDeliveryRequest>'''  # noqa: E501
+
+    response = requests.post(url + "?key=" + api_key, headers=headers,
+                             data=request_xml.encode('utf8'), timeout=timeout)
+
+    if response.ok is False:
+        raise requests.HTTPError(response.json())
+
+    # Parse metadata
+    header = pd.read_xml(io.StringIO(response.text),  parser='etree')
+    meta_lines = header['metadata'].iloc[0].split('#')
+    meta_lines = [line.strip() for line in meta_lines]
+    meta = {}
+    for line in meta_lines:
+        if ':' in line:
+            key = line.split(':')[0].lower()
+            if key in METADATA_FIELDS:
+                meta[key] = ':'.join(line.split(':')[1:])
+    meta['latitude'] = float(meta['latitude'])
+    meta['longitude'] = float(meta['longitude'])
+    meta['altitude'] = float(meta.pop('elevation').replace('m a.s.l.', ''))
+
+    # Parse data
+    data = pd.read_xml(io.StringIO(response.text), xpath='.//doc:row',
+                       namespaces={'doc': 'http://geomodel.eu/schema/ws/data'},
+                       parser='etree')
+    data.index = pd.to_datetime(data['dateTime'])
+    # when requesting one variable, it is necessary to convert dataframe to str
+    data = data['values'].astype(str).str.split(' ', expand=True)
+    data = data.astype(float)
+    data.columns = header['columns'].iloc[0].split()
+
+    # Replace "-9" with nan values for specific columns
+    for variable in data.columns:
+        if variable in NA_9_COLUMNS:
+            data[variable] = data[variable].replace(-9, pd.NA)
+
+    # rename and convert variables
+    if map_variables:
+        for variable in VARIABLE_MAP:
+            if variable.solargis_name in data.columns:
+                data.rename(
+                    columns={variable.solargis_name: variable.pvlib_name},
+                    inplace=True
+                )
+                data[variable.pvlib_name] = data[
+                    variable.pvlib_name].apply(variable.conversion)
+
+    return data, meta

pvlib/iotools/solcast.py

@@ -35,7 +35,7 @@ VARIABLE_MAP = [
         "azimuth", "solar_azimuth", lambda x: -x % 360
     ),
     # precipitable_water (kg/m2) -> precipitable_water (cm)
-    ParameterMap("precipitable_water", "precipitable_water", lambda x: x*10),
+    ParameterMap("precipitable_water", "precipitable_water", lambda x: x/10),
     # zenith -> solar_zenith
     ParameterMap("zenith", "solar_zenith"),
     # clearsky
@@ -413,14 +413,9 @@ def _solcast2pvlib(data):
     a pandas.DataFrame with the data cast to pvlib's conventions
     """
     # move from period_end to period_middle as per pvlib convention
-    # to support Pandas 0.25 we cast PTXX to XX as ISO8601
-    # durations without days aren't supported:
-    # https://github.com/pandas-dev/pandas/pull/37159\
-    # Can remove once minimum supported Pandas version is >=1.2
-    periods = data.period.str.replace("PT", "").str.replace("M", "m")
 
     data["period_mid"] = pd.to_datetime(
-        data.period_end) - pd.to_timedelta(periods) / 2
+        data.period_end) - pd.to_timedelta(data.period.values) / 2
     data = data.set_index("period_mid").drop(columns=["period_end", "period"])
 
     # rename and convert variables

pvlib/iotools/solrad.py

@@ -1,8 +1,9 @@
-"""Functions to read data from the NOAA SOLRAD network.
-"""
+"""Functions to read data from the NOAA SOLRAD network."""
 
-import numpy as np
 import pandas as pd
+import warnings
+import requests
+import io
 
 # pvlib conventions
 BASE_HEADERS = (
@@ -49,8 +50,15 @@ MADISON_DTYPES = [
 
 def read_solrad(filename):
     """
-    Read NOAA SOLRAD fixed-width file into pandas dataframe.  The SOLRAD
-    network is described in [1]_ and [2]_.
+    Read NOAA SOLRAD fixed-width file into pandas dataframe.
+
+    The SOLRAD network is described in [1]_ and [2]_.
+
+    .. versionchanged:: 0.10.4
+       The function now returns a tuple where the first element is a dataframe
+       and the second element is a dictionary containing metadata. Previous
+       versions of this function only returned a dataframe.
+
 
     Parameters
     ----------
@@ -62,6 +70,12 @@ def read_solrad(filename):
     data: Dataframe
         A dataframe with DatetimeIndex and all of the variables in the
         file.
+    metadata : dict
+        Metadata.
+
+    See Also
+    --------
+    get_solrad
 
     Notes
     -----
@@ -91,19 +105,30 @@ def read_solrad(filename):
         widths = WIDTHS
         dtypes = DTYPES
 
+    meta = {}
+
+    if str(filename).startswith('ftp') or str(filename).startswith('http'):
+        response = requests.get(filename)
+        response.raise_for_status()
+        file_buffer = io.StringIO(response.content.decode())
+    else:
+        with open(str(filename), 'r') as file_buffer:
+            file_buffer = io.StringIO(file_buffer.read())
+
+    # The first line has the name of the station, and the second gives the
+    # station's latitude, longitude, elevation above mean sea level in meters,
+    # and the displacement in hours from local standard time.
+    meta['station_name'] = file_buffer.readline().strip()
+
+    meta_line = file_buffer.readline().split()
+    meta['latitude'] = float(meta_line[0])
+    meta['longitude'] = float(meta_line[1])
+    meta['altitude'] = float(meta_line[2])
+    meta['TZ'] = int(meta_line[3])
+
     # read in data
-    data = pd.read_fwf(filename, header=None, skiprows=2, names=names,
-                       widths=widths, na_values=-9999.9)
-
-    # loop here because dtype kwarg not supported in read_fwf until 0.20
-    for (col, _dtype) in zip(data.columns, dtypes):
-        ser = data[col].astype(_dtype)
-        if _dtype == 'float64':
-            # older verions of pandas/numpy read '-9999.9' as
-            # -9999.8999999999996 and fail to set nan in read_fwf,
-            # so manually set nan
-            ser = ser.where(ser > -9999, other=np.nan)
-        data[col] = ser
+    data = pd.read_fwf(file_buffer, header=None, names=names,
+                       widths=widths, na_values=-9999.9, dtypes=dtypes)
 
     # set index
     # columns do not have leading 0s, so must zfill(2) to comply
@@ -114,10 +139,83 @@ def read_solrad(filename):
         data['year'].astype(str) + dts['month'] + dts['day'] + dts['hour'] +
         dts['minute'], format='%Y%m%d%H%M', utc=True)
     data = data.set_index(dtindex)
-    try:
-        # to_datetime(utc=True) does not work in older versions of pandas
-        data = data.tz_localize('UTC')
-    except TypeError:
-        pass
 
-    return data
+    return data, meta
+
+
+def get_solrad(station, start, end,
+               url="https://gml.noaa.gov/aftp/data/radiation/solrad/"):
+    """Request data from NOAA SOLRAD and read it into a Dataframe.
+
+    A list of stations and their descriptions can be found in [1]_,
+    The data files are described in [2]_.
+
+    Data is returned for complete days, including ``start`` and ``end``.
+
+    Parameters
+    ----------
+    station : str
+        Three letter station abbreviation.
+    start : datetime-like
+        First day of the requested period
+    end : datetime-like
+        Last day of the requested period
+    url : str, default: 'https://gml.noaa.gov/aftp/data/radiation/solrad/'
+        API endpoint URL
+
+    Returns
+    -------
+    data : pd.DataFrame
+        Dataframe with data from SOLRAD.
+    meta : dict
+        Metadata.
+
+    See Also
+    --------
+    read_solrad
+
+    Notes
+    -----
+    Recent SOLRAD data is 1-minute averages.  Prior to 2015-01-01, it was
+    3-minute averages.
+
+    References
+    ----------
+    .. [1] https://gml.noaa.gov/grad/solrad/index.html
+    .. [2] https://gml.noaa.gov/aftp/data/radiation/solrad/README_SOLRAD.txt
+
+    Examples
+    --------
+    >>> # Retrieve one month of irradiance data from the ABQ SOLRAD station
+    >>> data, metadata = pvlib.iotools.get_solrad(
+    >>>     station='abq', start="2020-01-01", end="2020-01-31")
+    """
+    # Use pd.to_datetime so that strings (e.g. '2021-01-01') are accepted
+    start = pd.to_datetime(start)
+    end = pd.to_datetime(end)
+
+    # Generate list of filenames
+    dates = pd.date_range(start.floor('d'), end, freq='d')
+    station = station.lower()
+    filenames = [
+        f"{station}/{d.year}/{station}{d.strftime('%y')}{d.dayofyear:03}.dat"
+        for d in dates
+    ]
+
+    dfs = []  # Initialize list of monthly dataframes
+    for f in filenames:
+        try:
+            dfi, file_metadata = read_solrad(url + f)
+            dfs.append(dfi)
+        except requests.exceptions.HTTPError:
+            warnings.warn(f"The following file was not found: {f}")
+
+    data = pd.concat(dfs, axis='rows')
+
+    meta = {'station': station,
+            'filenames': filenames,
+            # all file should have the same metadata, so just merge in the
+            # metadata from the last file
+            **file_metadata}
+
+    return data, meta

pvlib/iotools/srml.py

@@ -12,7 +12,7 @@ from pvlib._deprecation import deprecated
 # pvlib names. For most variables, only the first three digits are used,
 # the fourth indicating the instrument. Spectral data (7xxx) uses all
 # four digits to indicate the variable. See a full list of data element
-# numbers `here. <http://solardat.uoregon.edu/DataElementNumbers.html>`_
+# numbers `here. <http://solardata.uoregon.edu/DataElementNumbers.html>`_
 
 VARIABLE_MAP = {
     '100': 'ghi',
@@ -60,9 +60,9 @@ def read_srml(filename, map_variables=True):
     References
     ----------
     .. [1] University of Oregon Solar Radiation Monitoring Laboratory
-       `http://solardat.uoregon.edu/ <http://solardat.uoregon.edu/>`_
+       http://solardata.uoregon.edu/
     .. [2] `Archival (short interval) data files
-       <http://solardat.uoregon.edu/ArchivalFiles.html>`_
+       <http://solardata.uoregon.edu/ArchivalFiles.html>`_
     """
     tsv_data = pd.read_csv(filename, delimiter='\t')
     data = _format_index(tsv_data)
@@ -92,7 +92,7 @@ def read_srml(filename, map_variables=True):
     # Mask data marked with quality flag 99 (bad or missing data)
     for col in columns[::2]:
         missing = data[col + '_flag'] == 99
-        data[col] = data[col].where(~(missing), np.NaN)
+        data[col] = data[col].where(~(missing), np.nan)
     return data
 
 
@@ -175,7 +175,8 @@ def _format_index(df):
 @deprecated('0.10.0', alternative='pvlib.iotools.get_srml', removal='0.11.0')
 def read_srml_month_from_solardat(station, year, month, filetype='PO',
                                   map_variables=True):
-    """Request a month of SRML data and read it into a Dataframe.
+    """
+    Request a month of SRML data and read it into a Dataframe.
 
     The SRML is described in [1]_.
 
@@ -218,20 +219,20 @@ def read_srml_month_from_solardat(station, year, month, filetype='PO',
     References
     ----------
     .. [1] University of Oregon Solar Radiation Measurement Laboratory
-       `http://solardat.uoregon.edu/ <http://solardat.uoregon.edu/>`_
+       http://solardata.uoregon.edu/
     """
     file_name = "{station}{filetype}{year:02d}{month:02d}.txt".format(
         station=station,
         filetype=filetype,
         year=year % 100,
         month=month)
-    url = "http://solardat.uoregon.edu/download/Archive/"
+    url = "http://solardata.uoregon.edu/download/Archive/"
     data = read_srml(url + file_name, map_variables=map_variables)
     return data
 
 
 def get_srml(station, start, end, filetype='PO', map_variables=True,
-             url="http://solardat.uoregon.edu/download/Archive/"):
+             url="http://solardata.uoregon.edu/download/Archive/"):
     """Request data from UoO SRML and read it into a Dataframe.
 
     The University of Oregon Solar Radiation Monitoring Laboratory (SRML) is
@@ -252,7 +253,7 @@ def get_srml(station, start, end, filetype='PO', map_variables=True,
     map_variables : bool, default: True
         When true, renames columns of the DataFrame to pvlib variable names
         where applicable. See variable :const:`VARIABLE_MAP`.
-    url : str, default: 'http://solardat.uoregon.edu/download/Archive/'
+    url : str, default: 'http://solardata.uoregon.edu/download/Archive/'
         API endpoint URL
 
     Returns
@@ -287,10 +288,9 @@ def get_srml(station, start, end, filetype='PO', map_variables=True,
     References
     ----------
     .. [1] University of Oregon Solar Radiation Measurement Laboratory
-       `http://solardat.uoregon.edu/ <http://solardat.uoregon.edu/>`_
+       http://solardata.uoregon.edu/
     .. [2] Station ID codes - Solar Radiation Measurement Laboratory
-       `http://solardat.uoregon.edu/StationIDCodes.html
-       <http://solardat.uoregon.edu/StationIDCodes.html>`_
+       http://solardata.uoregon.edu/StationIDCodes.html
     """
     # Use pd.to_datetime so that strings (e.g. '2021-01-01') are accepted
     start = pd.to_datetime(start)

pvlib/iotools/surfrad.py

@@ -146,13 +146,13 @@ def read_surfrad(filename, map_variables=True):
     metadata['surfrad_version'] = int(metadata_list[-1])
     metadata['tz'] = 'UTC'
 
-    data = pd.read_csv(file_buffer, delim_whitespace=True,
+    data = pd.read_csv(file_buffer, sep=r'\s+',
                        header=None, names=SURFRAD_COLUMNS)
     file_buffer.close()
 
     data = _format_index(data)
     missing = data == -9999.9
-    data = data.where(~missing, np.NaN)
+    data = data.where(~missing, np.nan)
 
     if map_variables:
         data.rename(columns=VARIABLE_MAP, inplace=True)