tessl/pypi-pvlib

A comprehensive toolbox for modeling and simulating photovoltaic energy systems.

—

Pending

Overview

Eval results

Files

Solar Position Calculation

Name: tessl/pypi-pvlib
Author: tessl

Calculate precise solar position using multiple high-accuracy algorithms. Provides essential astronomical calculations for PV system modeling including solar zenith and azimuth angles, sunrise and sunset times, and solar transit calculations.

Capabilities

Main Solar Position Function

Calculate solar position using various algorithms with automatic method selection based on requirements.

def get_solarposition(time, latitude, longitude, altitude=0, pressure=101325, 
                     temperature=12, method='nrel_numpy', **kwargs):
    """
    Calculate solar position using various algorithms.
    
    Parameters:
    - time: pandas.DatetimeIndex, times for calculation
    - latitude: float, decimal degrees north
    - longitude: float, decimal degrees east
    - altitude: float, meters above sea level
    - pressure: float, pascals atmospheric pressure
    - temperature: float, degrees C air temperature
    - method: str, calculation method ('nrel_numpy', 'nrel_c', 'pyephem', 'ephemeris')
    - **kwargs: additional method-specific parameters
    
    Returns:
    pandas.DataFrame with columns:
    - apparent_zenith: apparent solar zenith angle (degrees)
    - zenith: solar zenith angle (degrees)
    - apparent_elevation: apparent solar elevation angle (degrees)
    - elevation: solar elevation angle (degrees)
    - azimuth: solar azimuth angle (degrees)
    - equation_of_time: equation of time (minutes)
    """

High-Precision SPA Algorithm

Solar Position Algorithm (SPA) providing highest accuracy solar position calculations.

def spa_c(time, latitude, longitude, pressure=101325, altitude=0, 
         temperature=12, delta_t=67.0, numthreads=4, **kwargs):
    """
    Calculate solar position using SPA algorithm with C implementation.
    
    Parameters:
    - time: pandas.DatetimeIndex
    - latitude: float, decimal degrees
    - longitude: float, decimal degrees  
    - pressure: float, pascals
    - altitude: float, meters
    - temperature: float, degrees C
    - delta_t: float, difference between terrestrial time and UT1 (seconds)
    - numthreads: int, number of threads for parallel processing
    
    Returns:
    pandas.DataFrame with solar position data
    """

def spa_python(time, latitude, longitude, pressure=101325, altitude=0, 
              temperature=12, delta_t=67.0, numthreads=4, **kwargs):
    """
    Calculate solar position using SPA algorithm with Python implementation.
    
    Parameters:
    - time: pandas.DatetimeIndex
    - latitude: float, decimal degrees
    - longitude: float, decimal degrees
    - pressure: float, pascals
    - altitude: float, meters
    - temperature: float, degrees C
    - delta_t: float, difference between terrestrial time and UT1 (seconds)
    - numthreads: int, number of threads for parallel processing
    
    Returns:
    pandas.DataFrame with solar position data
    """

PyEphem Algorithm

Solar position calculations using the PyEphem astronomical library.

def pyephem(time, latitude, longitude, altitude=0, pressure=101325, 
           temperature=12, horizon='+0:00'):
    """
    Calculate solar position using PyEphem library.
    
    Parameters:
    - time: pandas.DatetimeIndex
    - latitude: float, decimal degrees
    - longitude: float, decimal degrees
    - altitude: float, meters
    - pressure: float, pascals
    - temperature: float, degrees C
    - horizon: str, horizon definition for rise/set calculations
    
    Returns:
    pandas.DataFrame with solar position data
    """

Analytical Methods

Fast analytical solar position calculations for less demanding applications.

def ephemeris(time, latitude, longitude, pressure=101325.0, temperature=12.0):
    """
    Calculate solar position using analytical ephemeris calculations.
    
    Parameters:
    - time: pandas.DatetimeIndex
    - latitude: float, decimal degrees
    - longitude: float, decimal degrees
    - pressure: float, pascals
    - temperature: float, degrees C
    
    Returns:
    pandas.DataFrame with solar position data
    """

def solar_zenith_analytical(latitude, hourangle, declination):
    """
    Calculate solar zenith angle analytically.
    
    Parameters:
    - latitude: numeric, decimal degrees
    - hourangle: numeric, hour angle in decimal degrees
    - declination: numeric, solar declination in decimal degrees
    
    Returns:
    numeric, solar zenith angle in degrees
    """

def solar_azimuth_analytical(latitude, hourangle, declination, zenith):
    """
    Calculate solar azimuth angle analytically.
    
    Parameters:
    - latitude: numeric, decimal degrees
    - hourangle: numeric, hour angle in decimal degrees
    - declination: numeric, solar declination in decimal degrees
    - zenith: numeric, solar zenith angle in degrees
    
    Returns:
    numeric, solar azimuth angle in degrees
    """

Sunrise, Sunset, and Transit

Calculate sunrise, sunset, and solar transit times using various methods.

def sun_rise_set_transit_spa(times, latitude, longitude, how='numpy', 
                            delta_t=67.0, numthreads=4):
    """
    Calculate sunrise, sunset, and transit using SPA algorithm.
    
    Parameters:
    - times: pandas.DatetimeIndex, dates for calculation
    - latitude: float, decimal degrees
    - longitude: float, decimal degrees
    - how: str, calculation method ('numpy', 'numba')
    - delta_t: float, seconds
    - numthreads: int, number of threads
    
    Returns:
    pandas.DataFrame with columns: sunrise, sunset, transit
    """

def sun_rise_set_transit_ephem(times, latitude, longitude, 
                              next_rising=False, next_setting=False, 
                              next_transit=False):
    """
    Calculate sunrise, sunset, and transit using PyEphem.
    
    Parameters:
    - times: pandas.DatetimeIndex
    - latitude: float, decimal degrees
    - longitude: float, decimal degrees
    - next_rising: bool, find next sunrise
    - next_setting: bool, find next sunset
    - next_transit: bool, find next transit
    
    Returns:
    pandas.DataFrame with columns: sunrise, sunset, transit
    """

def sun_rise_set_transit_geometric(times, latitude, longitude, declination, 
                                  equation_of_time):
    """
    Calculate sunrise, sunset, and transit using geometric approach.
    
    Parameters:
    - times: pandas.DatetimeIndex
    - latitude: float, decimal degrees
    - longitude: float, decimal degrees
    - declination: numeric, solar declination
    - equation_of_time: numeric, equation of time
    
    Returns:
    pandas.DataFrame with columns: sunrise, sunset, transit
    """

Earth-Sun Distance

Calculate the distance between Earth and Sun for irradiance corrections.

def nrel_earthsun_distance(time, how='numpy', delta_t=67.0, numthreads=4):
    """
    Calculate Earth-Sun distance using NREL algorithm.
    
    Parameters:
    - time: pandas.DatetimeIndex
    - how: str, calculation method ('numpy', 'numba')
    - delta_t: float, seconds
    - numthreads: int, number of threads
    
    Returns:
    pandas.Series, Earth-Sun distance in AU
    """

def pyephem_earthsun_distance(time):
    """
    Calculate Earth-Sun distance using PyEphem.
    
    Parameters:
    - time: pandas.DatetimeIndex
    
    Returns:
    pandas.Series, Earth-Sun distance in AU
    """

Solar Declination and Equation of Time

Calculate fundamental solar parameters for position calculations.

def declination_spencer71(dayofyear):
    """
    Calculate solar declination using Spencer 1971 formula.
    
    Parameters:
    - dayofyear: numeric, day of year (1-366)
    
    Returns:
    numeric, solar declination in degrees
    """

def declination_cooper69(dayofyear):
    """
    Calculate solar declination using Cooper 1969 formula.
    
    Parameters:
    - dayofyear: numeric, day of year (1-366)
    
    Returns:
    numeric, solar declination in degrees
    """

def equation_of_time_spencer71(dayofyear):
    """
    Calculate equation of time using Spencer 1971 formula.
    
    Parameters:
    - dayofyear: numeric, day of year (1-366)
    
    Returns:
    numeric, equation of time in minutes
    """

def equation_of_time_pvcdrom(dayofyear):
    """
    Calculate equation of time using PVCDROM formula.
    
    Parameters:
    - dayofyear: numeric, day of year (1-366)
    
    Returns:
    numeric, equation of time in minutes
    """

Hour Angle Calculation

Calculate solar hour angle for position calculations.

def hour_angle(times, longitude, equation_of_time):
    """
    Calculate solar hour angle.
    
    Parameters:
    - times: pandas.DatetimeIndex
    - longitude: numeric, decimal degrees east
    - equation_of_time: numeric, equation of time in minutes
    
    Returns:
    pandas.Series, hour angle in degrees
    """

Usage Examples

Basic Solar Position Calculation

import pvlib
from pvlib import solarposition
import pandas as pd

# Define location and time range
latitude, longitude = 40.0583, -74.4057  # Princeton, NJ
times = pd.date_range('2023-06-21', periods=24, freq='H', tz='US/Eastern')

# Calculate solar position
solar_pos = solarposition.get_solarposition(times, latitude, longitude)
print(solar_pos[['elevation', 'azimuth']].head())

High-Precision SPA Calculation

import pvlib
from pvlib import solarposition
import pandas as pd

# Use SPA algorithm for highest precision
times = pd.date_range('2023-06-21 12:00', periods=1, tz='UTC')
latitude, longitude = 39.742, -105.178  # NREL, Golden, CO

solar_pos = solarposition.spa_c(
    times, latitude, longitude,
    pressure=82000,  # Pressure at altitude
    temperature=20,
    delta_t=67.0
)
print(f"Solar elevation: {solar_pos['elevation'].iloc[0]:.6f}°")
print(f"Solar azimuth: {solar_pos['azimuth'].iloc[0]:.6f}°")

Sunrise, Sunset, and Transit Times

import pvlib
from pvlib import solarposition
import pandas as pd

# Calculate sunrise/sunset for a week
dates = pd.date_range('2023-06-15', '2023-06-22', tz='US/Eastern')
latitude, longitude = 40.0583, -74.4057

sun_times = solarposition.sun_rise_set_transit_spa(
    dates, latitude, longitude
)

print(sun_times)

Install with Tessl CLI