pvlib 0.11.0a1__py3-none-any.whl → 0.11.1__py3-none-any.whl

pvlib/pvsystem.py

@@ -841,7 +841,7 @@ class PVSystem:
     @_unwrap_single_value
     def pvwatts_dc(self, g_poa_effective, temp_cell):
         """
-        Calcuates DC power according to the PVWatts model using
+        Calculates DC power according to the PVWatts model using
         :py:func:`pvlib.pvsystem.pvwatts_dc`, `self.module_parameters['pdc0']`,
         and `self.module_parameters['gamma_pdc']`.
 
@@ -1550,7 +1550,7 @@ def calcparams_desoto(effective_irradiance, temp_cell,
         Light-generated current in amperes
 
     saturation_current : numeric
-        Diode saturation curent in amperes
+        Diode saturation current in amperes
 
     resistance_series : numeric
         Series resistance in ohms

pvlib/shading.py

@@ -449,11 +449,11 @@ def shaded_fraction1d(
     Tilted row with a pitch of 3 m, a collector width of
     2 m, and row rotations of 30°. In the morning.
 
-    >>> shaded_fraction1d(solar_zenith=80, solar_azimuth=104.5,
+    >>> shaded_fraction1d(solar_zenith=80, solar_azimuth=135,
     ...     axis_azimuth=90, shaded_row_rotation=30, shading_row_rotation=30,
     ...     collector_width=2, pitch=3, axis_tilt=0,
     ...     surface_to_axis_offset=0.05, cross_axis_slope=0)
-    0.6827437712114521
+    0.47755694708090535
 
     **Fixed-tilt north-facing array on sloped terrain**
 
@@ -463,11 +463,11 @@ def shaded_fraction1d(
     10° slope, where their axis is on the most inclined
     direction (zero cross-axis slope). Shaded in the morning.
 
-    >>> shaded_fraction1d(solar_zenith=65, solar_azimuth=75.5,
+    >>> shaded_fraction1d(solar_zenith=80, solar_azimuth=75.5,
     ...     axis_azimuth=270, shaded_row_rotation=50, shading_row_rotation=30,
     ...     collector_width=2.5, pitch=4, axis_tilt=10,
     ...     surface_to_axis_offset=0.05, cross_axis_slope=0)
-    0.6975923460352351
+    0.793244836197256
 
     **N-S single-axis tracker on sloped terrain**
 
@@ -476,10 +476,10 @@ def shaded_fraction1d(
     in the morning. Terrain slope is 7° west-east (east-most
     tracker is higher than the west-most tracker).
 
-    >>> shaded_fraction1d(solar_zenith=50, solar_azimuth=90, axis_azimuth=180,
+    >>> shaded_fraction1d(solar_zenith=80, solar_azimuth=90, axis_azimuth=180,
     ...     shaded_row_rotation=-30, collector_width=1.4, pitch=3, axis_tilt=0,
     ...     surface_to_axis_offset=0.10, cross_axis_slope=7)
-    0.5828961460616938
+    0.8242176864434579
 
     Note the previous example only is valid for the shaded fraction of the
     west-most tracker in the morning, and assuming it is the
@@ -491,10 +491,10 @@ def shaded_fraction1d(
     tracker, you must input the corresponding ``shaded_row_rotation``
     in the afternoon.
 
-    >>> shaded_fraction1d(solar_zenith=50, solar_azimuth=270, axis_azimuth=180,
+    >>> shaded_fraction1d(solar_zenith=80, solar_azimuth=270, axis_azimuth=180,
     ...     shaded_row_rotation=30, collector_width=1.4, pitch=3, axis_tilt=0,
     ...     surface_to_axis_offset=0.10, cross_axis_slope=7)
-    0.4399034444363955
+    0.018002567182254348
 
     You must switch the input/output depending on the
     sign of the projected solar zenith angle. See

pvlib/singlediode.py

@@ -632,7 +632,7 @@ def _shape_of_max_size(*args):
 def _prepare_newton_inputs(x0, args, method_kwargs):
     """
     Make inputs compatible with Scipy's newton by:
-    - converting all arugments (`x0` and `args`) into numpy.ndarrays if any
+    - converting all arguments (`x0` and `args`) into numpy.ndarrays if any
       argument is not a scalar.
     - broadcasting the initial guess `x0` to the shape of the argument with
       the greatest size.

pvlib/solarposition.py

@@ -22,9 +22,8 @@ import numpy as np
 import pandas as pd
 import scipy.optimize as so
 import warnings
-import datetime
 
-from pvlib import atmosphere
+from pvlib import atmosphere, tools
 from pvlib.tools import datetime_to_djd, djd_to_datetime
 
 
@@ -200,11 +199,7 @@ def spa_c(time, latitude, longitude, pressure=101325, altitude=0,
         raise ImportError('Could not import built-in SPA calculator. ' +
                           'You may need to recompile the SPA code.')
 
-    # if localized, convert to UTC. otherwise, assume UTC.
-    try:
-        time_utc = time.tz_convert('UTC')
-    except TypeError:
-        time_utc = time
+    time_utc = tools._pandas_to_utc(time)
 
     spa_out = []
 
@@ -313,13 +308,11 @@ def spa_python(time, latitude, longitude,
         avg. yearly air pressure in Pascals.
     temperature : int or float, optional, default 12
         avg. yearly air temperature in degrees C.
-    delta_t : float, optional, default 67.0
+    delta_t : float or array, optional, default 67.0
         Difference between terrestrial time and UT1.
         If delta_t is None, uses spa.calculate_deltat
         using time.year and time.month from pandas.DatetimeIndex.
         For most simulations the default delta_t is sufficient.
-        *Note: delta_t = None will break code using nrel_numba,
-        this will be fixed in a future version.*
         The USNO has historical and forecasted delta_t [3]_.
     atmos_refrac : float, optional
         The approximate atmospheric refraction (in degrees)
@@ -379,7 +372,9 @@ def spa_python(time, latitude, longitude,
 
     spa = _spa_python_import(how)
 
-    delta_t = delta_t or spa.calculate_deltat(time.year, time.month)
+    if delta_t is None:
+        time_utc = tools._pandas_to_utc(time)
+        delta_t = spa.calculate_deltat(time_utc.year, time_utc.month)
 
     app_zenith, zenith, app_elevation, elevation, azimuth, eot = \
         spa.solar_position(unixtime, lat, lon, elev, pressure, temperature,
@@ -419,13 +414,11 @@ def sun_rise_set_transit_spa(times, latitude, longitude, how='numpy',
         Options are 'numpy' or 'numba'. If numba >= 0.17.0
         is installed, how='numba' will compile the spa functions
         to machine code and run them multithreaded.
-    delta_t : float, optional, default 67.0
+    delta_t : float or array, optional, default 67.0
         Difference between terrestrial time and UT1.
         If delta_t is None, uses spa.calculate_deltat
         using times.year and times.month from pandas.DatetimeIndex.
         For most simulations the default delta_t is sufficient.
-        *Note: delta_t = None will break code using nrel_numba,
-        this will be fixed in a future version.*
     numthreads : int, optional, default 4
         Number of threads to use if how == 'numba'.
 
@@ -453,12 +446,13 @@ def sun_rise_set_transit_spa(times, latitude, longitude, how='numpy',
         raise ValueError('times must be localized')
 
     # must convert to midnight UTC on day of interest
-    utcday = pd.DatetimeIndex(times.date).tz_localize('UTC')
-    unixtime = _datetime_to_unixtime(utcday)
+    times_utc = times.tz_convert('UTC')
+    unixtime = _datetime_to_unixtime(times_utc.normalize())
 
     spa = _spa_python_import(how)
 
-    delta_t = delta_t or spa.calculate_deltat(times.year, times.month)
+    if delta_t is None:
+        delta_t = spa.calculate_deltat(times_utc.year, times_utc.month)
 
     transit, sunrise, sunset = spa.transit_sunrise_sunset(
         unixtime, lat, lon, delta_t, numthreads)
@@ -582,12 +576,11 @@ def sun_rise_set_transit_ephem(times, latitude, longitude,
     sunrise = []
     sunset = []
     trans = []
-    for thetime in times:
-        thetime = thetime.to_pydatetime()
+    for thetime in tools._pandas_to_utc(times):
         # older versions of pyephem ignore timezone when converting to its
         # internal datetime format, so convert to UTC here to support
         # all versions.  GH #1449
-        obs.date = ephem.Date(thetime.astimezone(datetime.timezone.utc))
+        obs.date = ephem.Date(thetime)
         sunrise.append(_ephem_to_timezone(rising(sun), tzinfo))
         sunset.append(_ephem_to_timezone(setting(sun), tzinfo))
         trans.append(_ephem_to_timezone(transit(sun), tzinfo))
@@ -645,11 +638,7 @@ def pyephem(time, latitude, longitude, altitude=0, pressure=101325,
     except ImportError:
         raise ImportError('PyEphem must be installed')
 
-    # if localized, convert to UTC. otherwise, assume UTC.
-    try:
-        time_utc = time.tz_convert('UTC')
-    except TypeError:
-        time_utc = time
+    time_utc = tools._pandas_to_utc(time)
 
     sun_coords = pd.DataFrame(index=time)
 
@@ -718,11 +707,11 @@ def ephemeris(time, latitude, longitude, pressure=101325, temperature=12):
 
         * apparent_elevation : apparent sun elevation accounting for
           atmospheric refraction.
+          This is the complement of the apparent zenith angle.
         * elevation : actual elevation (not accounting for refraction)
           of the sun in decimal degrees, 0 = on horizon.
           The complement of the zenith angle.
         * azimuth : Azimuth of the sun in decimal degrees East of North.
-          This is the complement of the apparent zenith angle.
         * apparent_zenith : apparent sun zenith accounting for atmospheric
           refraction.
         * zenith : Solar zenith angle
@@ -766,11 +755,7 @@ def ephemeris(time, latitude, longitude, pressure=101325, temperature=12):
     # the SPA algorithm needs time to be expressed in terms of
     # decimal UTC hours of the day of the year.
 
-    # if localized, convert to UTC. otherwise, assume UTC.
-    try:
-        time_utc = time.tz_convert('UTC')
-    except TypeError:
-        time_utc = time
+    time_utc = tools._pandas_to_utc(time)
 
     # strip out the day of the year and calculate the decimal hour
     DayOfYear = time_utc.dayofyear
@@ -957,7 +942,10 @@ def pyephem_earthsun_distance(time):
 
     sun = ephem.Sun()
     earthsun = []
-    for thetime in time:
+    for thetime in tools._pandas_to_utc(time):
+        # older versions of pyephem ignore timezone when converting to its
+        # internal datetime format, so convert to UTC here to support
+        # all versions.  GH #1449
         sun.compute(ephem.Date(thetime))
         earthsun.append(sun.earth_distance)
 
@@ -981,13 +969,11 @@ def nrel_earthsun_distance(time, how='numpy', delta_t=67.0, numthreads=4):
         is installed, how='numba' will compile the spa functions
         to machine code and run them multithreaded.
 
-    delta_t : float, optional, default 67.0
+    delta_t : float or array, optional, default 67.0
         Difference between terrestrial time and UT1.
         If delta_t is None, uses spa.calculate_deltat
         using time.year and time.month from pandas.DatetimeIndex.
         For most simulations the default delta_t is sufficient.
-        *Note: delta_t = None will break code using nrel_numba,
-        this will be fixed in a future version.*
 
     numthreads : int, optional, default 4
         Number of threads to use if how == 'numba'.
@@ -1014,7 +1000,9 @@ def nrel_earthsun_distance(time, how='numpy', delta_t=67.0, numthreads=4):
 
     spa = _spa_python_import(how)
 
-    delta_t = delta_t or spa.calculate_deltat(time.year, time.month)
+    if delta_t is None:
+        time_utc = tools._pandas_to_utc(time)
+        delta_t = spa.calculate_deltat(time_utc.year, time_utc.month)
 
     dist = spa.earthsun_distance(unixtime, delta_t, numthreads)
 
@@ -1387,22 +1375,26 @@ def hour_angle(times, longitude, equation_of_time):
     equation_of_time_spencer71
     equation_of_time_pvcdrom
     """
+
+    # times must be localized
+    if not times.tz:
+        raise ValueError('times must be localized')
+
     # hours - timezone = (times - normalized_times) - (naive_times - times)
-    if times.tz is None:
-        times = times.tz_localize('utc')
     tzs = np.array([ts.utcoffset().total_seconds() for ts in times]) / 3600
 
-    hrs_minus_tzs = (times - times.normalize()) / pd.Timedelta('1h') - tzs
+    hrs_minus_tzs = _times_to_hours_after_local_midnight(times) - tzs
 
-    # ensure array return instead of a version-dependent pandas <T>Index
-    return np.asarray(
-        15. * (hrs_minus_tzs - 12.) + longitude + equation_of_time / 4.)
+    return 15. * (hrs_minus_tzs - 12.) + longitude + equation_of_time / 4.
 
 
 def _hour_angle_to_hours(times, hourangle, longitude, equation_of_time):
     """converts hour angles in degrees to hours as a numpy array"""
-    if times.tz is None:
-        times = times.tz_localize('utc')
+
+    # times must be localized
+    if not times.tz:
+        raise ValueError('times must be localized')
+
     tzs = np.array([ts.utcoffset().total_seconds() for ts in times]) / 3600
     hours = (hourangle - longitude - equation_of_time / 4.) / 15. + 12. + tzs
     return np.asarray(hours)
@@ -1412,18 +1404,26 @@ def _local_times_from_hours_since_midnight(times, hours):
     """
     converts hours since midnight from an array of floats to localized times
     """
-    tz_info = times.tz  # pytz timezone info
-    naive_times = times.tz_localize(None)  # naive but still localized
-    # normalize local, naive times to previous midnight and add the hours until
+
+    # times must be localized
+    if not times.tz:
+        raise ValueError('times must be localized')
+
+    # normalize local times to previous local midnight and add the hours until
     # sunrise, sunset, and transit
-    return pd.DatetimeIndex(
-        naive_times.normalize() + pd.to_timedelta(hours, unit='h'), tz=tz_info)
+    return times.normalize() + pd.to_timedelta(hours, unit='h')
 
 
 def _times_to_hours_after_local_midnight(times):
     """convert local pandas datetime indices to array of hours as floats"""
-    times = times.tz_localize(None)
+
+    # times must be localized
+    if not times.tz:
+        raise ValueError('times must be localized')
+
     hrs = (times - times.normalize()) / pd.Timedelta('1h')
+
+    # ensure array return instead of a version-dependent pandas <T>Index
     return np.array(hrs)
 
 
@@ -1469,6 +1469,11 @@ def sun_rise_set_transit_geometric(times, latitude, longitude, declination,
        CRC Press (2012)
 
     """
+
+    # times must be localized
+    if not times.tz:
+        raise ValueError('times must be localized')
+
     latitude_rad = np.radians(latitude)  # radians
     sunset_angle_rad = np.arccos(-np.tan(declination) * np.tan(latitude_rad))
     sunset_angle = np.degrees(sunset_angle_rad)  # degrees

pvlib/spa.py

@@ -835,24 +835,24 @@ def equation_of_time(sun_mean_longitude, geocentric_sun_right_ascension,
     return E
 
 
-@jcompile('void(float64[:], float64[:], float64[:,:])', nopython=True,
-          nogil=True)
-def solar_position_loop(unixtime, loc_args, out):
+@jcompile('void(float64[:], float64[:], float64[:], float64[:,:])',
+          nopython=True, nogil=True)
+def solar_position_loop(unixtime, delta_t, loc_args, out):
     """Loop through the time array and calculate the solar position"""
     lat = loc_args[0]
     lon = loc_args[1]
     elev = loc_args[2]
     pressure = loc_args[3]
     temp = loc_args[4]
-    delta_t = loc_args[5]
-    atmos_refract = loc_args[6]
-    sst = loc_args[7]
-    esd = loc_args[8]
+    atmos_refract = loc_args[5]
+    sst = loc_args[6]
+    esd = loc_args[7]
 
     for i in range(unixtime.shape[0]):
         utime = unixtime[i]
+        dT = delta_t[i]
         jd = julian_day(utime)
-        jde = julian_ephemeris_day(jd, delta_t)
+        jde = julian_ephemeris_day(jd, dT)
         jc = julian_century(jd)
         jce = julian_ephemeris_century(jde)
         jme = julian_ephemeris_millennium(jce)
@@ -920,8 +920,11 @@ def solar_position_numba(unixtime, lat, lon, elev, pressure, temp, delta_t,
     and multiple threads. Very slow if functions are not numba compiled.
     """
     # these args are the same for each thread
-    loc_args = np.array([lat, lon, elev, pressure, temp, delta_t,
-                         atmos_refract, sst, esd])
+    loc_args = np.array([lat, lon, elev, pressure, temp,
+                         atmos_refract, sst, esd], dtype=np.float64)
+
+    # turn delta_t into an array if it isn't already
+    delta_t = np.full_like(unixtime, delta_t, dtype=np.float64)
 
     # construct dims x ulength array to put the results in
     ulength = unixtime.shape[0]
@@ -937,18 +940,20 @@ def solar_position_numba(unixtime, lat, lon, elev, pressure, temp, delta_t,
         unixtime = unixtime.astype(np.float64)
 
     if ulength < numthreads:
-        warnings.warn('The number of threads is more than the length of '
-                      'the time array. Only using %s threads.'.format(ulength))
         numthreads = ulength
 
     if numthreads <= 1:
-        solar_position_loop(unixtime, loc_args, result)
+        solar_position_loop(unixtime, delta_t, loc_args, result)
         return result
 
     # split the input and output arrays into numthreads chunks
     split0 = np.array_split(unixtime, numthreads)
+    split1 = np.array_split(delta_t, numthreads)
     split2 = np.array_split(result, numthreads, axis=1)
-    chunks = [[a0, loc_args, split2[i]] for i, a0 in enumerate(split0)]
+    chunks = [
+        [a0, a1, loc_args, a2]
+        for a0, a1, a2 in zip(split0, split1, split2)
+    ]
     # Spawn one thread per chunk
     threads = [threading.Thread(target=solar_position_loop, args=chunk)
                for chunk in chunks]
@@ -1035,7 +1040,7 @@ def solar_position(unixtime, lat, lon, elev, pressure, temp, delta_t,
     unixtime : numpy array
         Array of unix/epoch timestamps to calculate solar position for.
         Unixtime is the number of seconds since Jan. 1, 1970 00:00:00 UTC.
-        A pandas.DatetimeIndex is easily converted using .astype(np.int64)/10**9
+        A pandas.DatetimeIndex is easily converted using .view(np.int64)/10**9
     lat : float
         Latitude to calculate solar position for
     lon : float
@@ -1048,7 +1053,7 @@ def solar_position(unixtime, lat, lon, elev, pressure, temp, delta_t,
     temp : int or float
         avg. yearly temperature at location in
         degrees C; used for atmospheric correction
-    delta_t : float
+    delta_t : float or array
         Difference between terrestrial time and UT1.
     atmos_refrac : float
         The approximate atmospheric refraction (in degrees)
@@ -1113,7 +1118,7 @@ def transit_sunrise_sunset(dates, lat, lon, delta_t, numthreads):
         Latitude of location to perform calculation for
     lon : float
         Longitude of location
-    delta_t : float
+    delta_t : float or array
         Difference between terrestrial time and UT. USNO has tables.
     numthreads : int
         Number to threads to use for calculation (if using numba)
@@ -1214,8 +1219,8 @@ def earthsun_distance(unixtime, delta_t, numthreads):
     unixtime : numpy array
         Array of unix/epoch timestamps to calculate solar position for.
         Unixtime is the number of seconds since Jan. 1, 1970 00:00:00 UTC.
-        A pandas.DatetimeIndex is easily converted using .astype(np.int64)/10**9
-    delta_t : float
+        A pandas.DatetimeIndex is easily converted using .view(np.int64)/10**9
+    delta_t : float or array
         Difference between terrestrial time and UT. USNO has tables.
     numthreads : int
         Number to threads to use for calculation (if using numba)
@@ -1242,9 +1247,6 @@ def calculate_deltat(year, month):
     """Calculate the difference between Terrestrial Dynamical Time (TD)
     and Universal Time (UT).
 
-    Note: This function is not yet compatible for calculations using
-    Numba.
-
     Equations taken from http://eclipse.gsfc.nasa.gov/SEcat5/deltatpoly.html
     """
 

pvlib/spectrum/__init__.py

@@ -1,14 +1,19 @@
 from pvlib.spectrum.spectrl2 import spectrl2  # noqa: F401
 from pvlib.spectrum.mismatch import (  # noqa: F401
     calc_spectral_mismatch_field,
-    get_am15g,
-    get_reference_spectra,
-    get_example_spectral_response,
     spectral_factor_caballero,
     spectral_factor_firstsolar,
     spectral_factor_sapm,
     spectral_factor_pvspec,
     spectral_factor_jrc,
+)
+from pvlib.spectrum.irradiance import (  # noqa: F401
+    get_am15g,
+    get_reference_spectra,
+    average_photon_energy,
+)
+from pvlib.spectrum.response import (  # noqa: F401
+    get_example_spectral_response,
     sr_to_qe,
-    qe_to_sr
+    qe_to_sr,
 )