hefty 0.0.2__py3-none-any.whl

hefty/utilities.py

@@ -0,0 +1,261 @@
+import pandas as pd
+import warnings
+
+
+def model_input_formatter(init_date, run_length, lead_time_to_start=0,
+                          model='gfs', resource_type='solar'):
+    """
+    Helper function to format model-specific inputs for Herbie.
+
+    In the case where the user selects an invalid intitialization date, or
+    combination of init date and lead time, it tries to update the init date
+    and lead time to match a valid init date for the selected model, but this
+    hasn't been fully tested.
+
+    Parameters
+    ----------
+    init_date : pandas-parsable datetime
+        Targetted initialization datetime.
+
+    run_length : int
+        Length of the forecast in hours.
+
+    lead_time_to_start : int
+        Number of hours from the init_date to the first interval in the
+        forecast.
+
+    model : {'gfs', 'ifs', 'aifs', 'hrrr', 'gefs'}
+        Forecast model name, case insensitive. Default is 'gfs'.
+
+    resource_type : {'solar, 'wind'}
+        Resrouce type. Default is 'solar'.
+
+    Returns
+    -------
+    date : pandas-parsable datetime
+        initialization date, rounded down to the last valid date for the given
+        model if needed.
+
+    fxx_range : int or list of ints
+        fxx (lead time) values.
+
+    product : string
+        model product, e.g., 'pgrb2.0p25' for 'gfs'
+
+    search_str : string
+        wgrib2-style search string for Herbie to select variables of interest.
+    """
+
+    if model == 'gfs':
+        # GFS:
+        # 0 to 120 by 1, 123 to 384 by 3
+        # runs every 6 hours starting at 00z
+        update_freq = '6h'
+        # round down to last actual initialization time
+        date = init_date.floor(update_freq)
+
+        # offset in hours between selected init_date and fcast run
+        init_offset = int((init_date - date).total_seconds()/3600)
+        lead_time_to_start = lead_time_to_start + init_offset
+
+        # maximum forecast horizon, update with new lead time
+        fxx_max = run_length + lead_time_to_start
+
+        # set forecast lead times
+        if lead_time_to_start <= 120 and fxx_max > 120:
+            fxx_max = round(fxx_max/3)*3
+            fxx_range = [*range(lead_time_to_start, 120+1, 1),
+                         *range(123, fxx_max + 1, 3)]
+        elif lead_time_to_start > 120:
+            fxx_max = round(fxx_max/3)*3
+            lead_time_to_start = round(lead_time_to_start/3)*3
+            fxx_range = range(lead_time_to_start, fxx_max, 3)
+        else:
+            fxx_range = range(lead_time_to_start, fxx_max, 1)
+
+        # Herbie inputs
+        product = 'pgrb2.0p25'
+        if resource_type == 'solar':
+            search_str = 'DSWRF|:TMP:2 m above|[UV]GRD:10 m above'
+        elif resource_type == 'wind':
+            search_str = (
+                '[UV]GRD:10 m above|[UV]GRD:80 m above|'
+                '[UV]GRD:100 m above|:TMP:2 m above|PRES:surface|'
+                ':TMP:80 m above|PRES:80 m above'
+            )
+
+    elif model == 'gefs':
+        # GEFS:
+        # 0.5 deg:
+        #   0 to 384 by 3, 390 to 840 by 6 for 00z cycle only
+        # 0.25 deg:
+        #   0 to 240 by 3
+        # runs every 6 hours starting at 00z
+        update_freq = '6h'
+        # round down to last actual initialization time
+        date = init_date.floor(update_freq)
+
+        # offset in hours between selected init_date and fcast run
+        init_offset = int((init_date - date).total_seconds()/3600)
+        lead_time_to_start = lead_time_to_start + init_offset
+
+        # maximum forecast horizon, update with new lead time
+        fxx_max = run_length + lead_time_to_start
+
+        # set forecast lead times
+        fxx_range = range(lead_time_to_start, fxx_max + 1, 3)
+
+        # Herbie inputs
+        if resource_type == 'solar':
+            # solar radiation is not available for f00 (lead_time_to_start=0)
+            # adjust accordingly
+            if lead_time_to_start < 3:
+                lead_time_to_start = 3
+                warnings.warn(
+                        ("You have specified a lead_time_to_start less"
+                         "than 3 h. GHI in GEFS is only available "
+                         "starting at F03. The lead_time_to_start has been"
+                         "changed to 3 h."))
+
+            if fxx_max <= 240:
+                product = 'atmos.25'  # 0.25 deg, 'pgrb2.0p25'
+                search_str = 'DSWRF|:TMP:2 m above|[UV]GRD:10 m above'
+            else:
+                product = 'atmos.5'  # 0.5 deg, 'pgrb2.0p5'
+                search_str = 'DSWRF|:TMP:2 m above|[UV]GRD:10 m above'
+        elif resource_type == 'wind':
+            product = 'atmos.5b'  # 0.5 deg, 'pgrb2.0p5
+            search_str = (
+                '[UV]GRD:80 m above|[UV]GRD:100 m above|'
+                ':TMP:80 m above|PRES:80 m above'
+            )
+
+    elif model == 'ifs':
+        # From https://www.ecmwf.int/en/forecasts/datasets/open-data
+        # For times 00z &12z: 0 to 144 by 3, 150 to 240 by 6.
+        # For times 06z & 18z: 0 to 90 by 3.
+        # From:
+        # https://confluence.ecmwf.int/display/DAC/ECMWF+open+data%3A+real-time+forecasts+from+IFS+and+AIFS
+        # Product "oper" runs 00z, 12z, 0h to 144h by 3h, 144h to 240h by 6h
+        # Product "scda" runs 06z, 18z, 0h to 90h by 3h
+        # **BUT**, see https://github.com/blaylockbk/Herbie/discussions/421
+        # Starting 2024-11-12 06:00, 'scda' runs to 144h by 3h
+
+        # round to last 6 hours to start
+        date = init_date.floor('6h')
+        init_offset = int((init_date - date).total_seconds()/3600)
+        lead_time_to_start = lead_time_to_start + init_offset
+        fxx_max = run_length + lead_time_to_start
+
+        # pick init time based on forecast max lead time:
+        # check if 'scda' product is ideal
+        if init_date.hour == 6 or init_date.hour == 18:
+            if init_date >= pd.to_datetime('2024-11-12 06:00'):
+                scda_fxx_max = 144
+            else:
+                scda_fxx_max = 90
+            if fxx_max > scda_fxx_max:  # forecast beyond scda
+                update_freq = '12h'  # must use 'oper' runs
+                warnings.warn(
+                    ("You have specified an init_date which would have mapped "
+                     "to a 06z or 18z. Those runs the IFS 'scda' product, and "
+                     "'scda' only goes out 144 hours (90h prior to 2024-11-12)"
+                     ". You will get forecasts from the 'oper' run 6 hours "
+                     "earlier, instead."))
+            else:
+                update_freq = '6h'  # can use 'oper' or 'scda'
+        else:
+            update_freq = '6h'  # can use 'oper' or 'scda'
+        # round down to last actual initialization time
+        date = init_date.floor(update_freq)
+
+        # offset in hours between selected init_date and fcast run
+        init_offset = int((init_date - date).total_seconds()/3600)
+        lead_time_to_start = lead_time_to_start + init_offset
+        if lead_time_to_start > 141:
+            run_length = max(run_length, 6)  # make sure it's long enough
+        fxx_max = run_length + lead_time_to_start  # update this
+
+        # set forecast intervals
+        if lead_time_to_start <= 144 and fxx_max > 144:
+            lead_time_to_start = round(lead_time_to_start/3)*3
+            fxx_max = round(fxx_max/6)*6
+            # make sure it goes to at least the next interval
+            fxx_max = max(fxx_max, 150)
+            fxx_range = [*range(lead_time_to_start, 145, 3),
+                         *range(150, fxx_max + 1, 6)]
+        elif lead_time_to_start > 144:
+            lead_time_to_start = round(lead_time_to_start/6)*6
+            fxx_max = round(fxx_max/6)*6
+            fxx_range = range(lead_time_to_start, fxx_max + 1, 6)
+        else:
+            lead_time_to_start = round(lead_time_to_start/3)*3
+            fxx_max = round(fxx_max/3)*3
+            fxx_range = range(lead_time_to_start, fxx_max + 1, 3)
+
+        # Herbie inputs
+        if date.hour == 6 or date.hour == 18:
+            product = 'scda'
+        else:
+            product = 'oper'
+
+        if resource_type == 'solar':
+            search_str = ':ssrd|10[uv]|2t:sfc'
+        elif resource_type == 'wind':
+            search_str = ':10[uv]|:100[uv]|:2t:sfc|:sp:'
+
+    elif model == 'aifs':
+        # From https://www.ecmwf.int/en/forecasts/datasets/set-ix,
+        # https://www.ecmwf.int/en/forecasts/dataset/set-x
+        # 4 forecast runs per day (00/06/12/18)
+        # 6 hourly steps to 360 (15 days)
+
+        # round to last 6 hours to start
+        date = init_date.floor('6h')
+        init_offset = int((init_date - date).total_seconds()/3600)
+        lead_time_to_start = lead_time_to_start + init_offset
+        fxx_max = run_length + lead_time_to_start
+
+        update_freq = '6h'
+        # round down to last actual initialization time
+        date = init_date.floor(update_freq)
+
+        # offset in hours between selected init_date and fcast run
+        init_offset = int((init_date - date).total_seconds()/3600)
+        lead_time_to_start = lead_time_to_start + init_offset
+        if lead_time_to_start > 141:
+            run_length = max(run_length, 6)  # make sure it's long enough
+        fxx_max = run_length + lead_time_to_start  # update this
+
+        # set forecast intervals
+        fxx_range = range(lead_time_to_start, fxx_max + 1, 6)
+
+        # Herbie inputs
+        product = 'oper'  # deterministic
+
+        if resource_type == 'solar':
+            search_str = ':ssrd|10[uv]|2t:sfc'
+        elif resource_type == 'wind':
+            search_str = ':10[uv]|:100[uv]|:2t:sfc|:sp:'
+
+    elif model == 'hrrr':
+        # maximum forecast horizon
+        fxx_max = run_length + lead_time_to_start
+        product = 'sfc'
+
+        if resource_type == 'solar':
+            search_str = 'DSWRF|:TMP:2 m above|[UV]GRD:10 m above'
+        elif resource_type == 'wind':
+            search_str = (
+                '[UV]GRD:10 m above|[UV]GRD:80 m above|'
+                ':TMP:2 m above|PRES:surface'
+            )
+
+        update_freq = '1h'
+
+        # round down to last actual initialization time
+        date = init_date.floor(update_freq)
+
+        fxx_range = range(lead_time_to_start, fxx_max, 1)
+
+    return date, fxx_range, product, search_str

hefty/wind.py

@@ -0,0 +1,269 @@
+import pandas as pd
+import xarray as xr
+from herbie import Herbie
+import time
+from hefty.utilities import model_input_formatter
+
+
+def get_wind_forecast(latitude, longitude, init_date, run_length,
+                      lead_time_to_start=0, model='gfs', member=None,
+                      attempts=2, hrrr_hour_middle=True,
+                      hrrr_coursen_window=None, priority=None):
+    """
+    Get a wind resource forecast for one or several sites from one of several
+    NWPs. This function uses Herbie [1]_ and pvlib [2]_.
+
+    Parameters
+    ----------
+    latitude : float or list of floats
+        Latitude in decimal degrees. Positive north of equator, negative
+        to south.
+
+    longitude : float or list of floats
+        Longitude in decimal degrees. Positive east of prime meridian,
+        negative to west.
+
+    init_date : pandas-parsable datetime
+        Model initialization datetime.
+
+    run_length : int
+        Length of the forecast in hours - number of hours forecasted
+
+    lead_time_to_start : int, optional
+        Number of hours between init_date (initialization) and
+        the first forecasted interval. NOAA GFS data goes out
+        384 hours, so run_length + lead_time_to_start must be less
+        than or equal to 384.
+
+    model : string, default 'gfs'
+        Forecast model. Default is NOAA GFS ('gfs'), but can also be
+        ECMWF IFS ('ifs'), NOAA HRRR ('hrrr'), or NOAA GEFS ('gefs').
+
+    member: string or int
+        For models that are ensembles, pass an appropriate single member label.
+
+    attempts : int, optional
+        Number of times to try getting forecast data. The function will pause
+        for n^2 minutes after each n attempt, e.g., 1 min after the first
+        attempt, 4 minutes after the second, etc.
+
+    hrrr_hour_middle : bool, default True
+        If model is 'hrrr', setting this False keeps the forecast at the
+        native instantaneous top-of-hour format. True (default) shifts
+        the forecast to middle of the hour, more closely representing an
+        integrated hourly forecast that is centered in the middle of the
+        hour.
+
+    hrrr_coursen_window : int or None, default None
+        If model is 'hrrr', optional setting that is the x and y window size
+        for coarsening the xarray dataset, effectively applying spatial
+        smoothing to the HRRR model. The HRRR has a native resolution of
+        about 3 km, so a value of 10 results in approx. 30 x 30 km grid.
+
+    priority : list or string
+        List of model sources to get the data in the order of download
+        priority, or string for a single source. See Herbie docs.
+        Typical values would be 'aws' or 'google'.
+
+    Returns
+    -------
+    data : pandas.DataFrane
+        timeseries forecasted wind resource data
+
+    References
+    ----------
+
+    .. [1] `Blaylock, B. K. (YEAR). Herbie: Retrieve Numerical Weather
+       Prediction Model Data (Version 20xx.x.x) [Computer software].
+       <https://doi.org/10.5281/zenodo.4567540>`_
+    .. [2] `Anderson, K., et al. “pvlib python: 2023 project update.” Journal
+       of Open Source Software, 8(92), 5994, (2023).
+       <http://dx.doi.org/10.21105/joss.05994>`_
+    """
+
+    # # set clear sky model. could be an input variable at some point
+    # model_cs = 'haurwitz'
+
+    # variable formatting
+    # if lat, lon are single values, convert to lists for pickpoints later
+    if type(latitude) is float or type(latitude) is int:
+        latitude = [latitude]
+        longitude = [longitude]
+    # convert init_date to datetime
+    init_date = pd.to_datetime(init_date)
+
+    # get model-specific Herbie inputs
+    date, fxx_range, product, search_str = model_input_formatter(
+        init_date, run_length, lead_time_to_start, model, resource_type='wind')
+
+    i = []
+    for fxx in fxx_range:
+        # get solar, 10m wind, and 2m temp data
+        # try n times based loosely on
+        # https://thingspython.wordpress.com/2021/12/05/how-to-try-something-n-times-in-python/
+        for attempts_remaining in reversed(range(attempts)):
+            attempt_num = attempts - attempts_remaining
+            try:
+                if attempt_num == 1:
+                    # try downloading
+                    ds = Herbie(
+                        date,
+                        model=model,
+                        product=product,
+                        fxx=fxx,
+                        member=member,
+                        priority=priority
+                        ).xarray(search_str)
+                else:
+                    # after first attempt, set overwrite=True to overwrite
+                    # partial files
+                    ds = Herbie(
+                        date,
+                        model=model,
+                        product=product,
+                        fxx=fxx,
+                        member=member,
+                        priority=priority
+                        ).xarray(search_str, overwrite=True)
+            except Exception:
+                if attempts_remaining:
+                    print('attempt ' + str(attempt_num) + ' failed, pause for '
+                          + str((attempt_num)**2) + ' min')
+                    time.sleep(60*(attempt_num)**2)
+            else:
+                break
+        else:
+            raise ValueError('download failed, ran out of attempts')
+
+        # merge - override avoids hight conflict between 2m temp and 10m wind
+        ds = xr.merge(ds, compat='override')
+        # calculate wind speed from u and v components
+        ds = ds.herbie.with_wind('both')
+
+        if model == 'hrrr' and hrrr_coursen_window is not None:
+            ds = ds.coarsen(x=hrrr_coursen_window,
+                            y=hrrr_coursen_window,
+                            boundary='trim').mean()
+
+        # use pick_points for single point or list of points
+        i.append(
+            ds.herbie.pick_points(
+                pd.DataFrame(
+                    {
+                        "latitude": latitude,
+                        "longitude": longitude,
+                    }
+                )
+            )
+        )
+    ts = xr.concat(i, dim="valid_time")  # concatenate
+
+    # convert to dataframe, convert names and units
+    if model == 'gfs':
+        df_temp = ts.to_dataframe()[
+            ['si10',
+             'ws',
+             'si100',
+             'wdir10',
+             'wdir',
+             'wdir100',
+             # 't2m', # not really needed but could be used
+             't',
+             # 'sp', # not really needed but could be used
+             'pres']
+            ]
+        # df_temp['t2m'] = df_temp['t2m'] - 273.15
+        df_temp['t'] = df_temp['t'] - 273.15
+        df_temp.rename(columns={
+            'si10': 'wind_speed_10m',
+            'ws': 'wind_speed_80m',
+            'si100': 'wind_speed_100m',
+            'wdir10': 'wind_direction_10m',
+            'wdir': 'wind_direction_80m',
+            'wdir100': 'wind_direction_100m',
+            # 't2m': 'temp_air_2m', # not really needed but could be used
+            't': 'temp_air_80m',
+            # 'sp': 'pressure_0m', # not really needed but could be used
+            'pres': 'pressure_80m',
+            }, inplace=True)
+    elif model == 'gefs':
+        df_temp = ts.to_dataframe()[
+            ['ws', 'si100', 'wdir', 'wdir100', 't', 'pres']
+            ]
+        df_temp['t'] = df_temp['t'] - 273.15
+        df_temp.rename(columns={
+            'ws': 'wind_speed_80m',
+            'si100': 'wind_speed_100m',
+            'wdir': 'wind_direction_80m',
+            'wdir100': 'wind_direction_100m',
+            't': 'temp_air_80m',
+            'pres': 'pressure_80m',
+            }, inplace=True)
+    elif model == 'hrrr':
+        df_temp = ts.to_dataframe()[
+            ['si10', 'ws', 'wdir10', 'wdir', 't2m', 'sp']
+            ]
+        df_temp['t2m'] = df_temp['t2m'] - 273.15
+        df_temp.rename(columns={
+            'si10': 'wind_speed_10m',
+            'ws': 'wind_speed_80m',
+            'wdir10': 'wind_direction_10m',
+            'wdir': 'wind_direction_80m',
+            't2m': 'temp_air_2m',
+            'sp': 'pressure_0m',
+            }, inplace=True)
+    elif model == 'ifs' or model == 'aifs':
+        df_temp = ts.to_dataframe()[
+            ['si10', 'si100', 'wdir10', 'wdir100', 't2m', 'sp']
+            ]
+        df_temp['t2m'] = df_temp['t2m'] - 273.15
+        df_temp.rename(columns={
+            'si10': 'wind_speed_10m',
+            'si100': 'wind_speed_100m',
+            'wdir10': 'wind_direction_10m',
+            'wdir100': 'wind_direction_100m',
+            't2m': 'temp_air_2m',
+            'sp': 'pressure_0m',
+            }, inplace=True)
+
+    # work through sites
+    dfs = {}  # empty list of dataframes
+    if type(latitude) is float or type(latitude) is int:
+        num_sites = 1
+    else:
+        num_sites = len(latitude)
+
+    for j in range(num_sites):
+        df = df_temp[df_temp.index.get_level_values('point') == j]
+        df = df.droplevel('point')
+
+        if model == 'hrrr' and hrrr_hour_middle is False:
+            # keep top of hour instantaneous HRRR convention
+            dfs[j] = df
+        else:
+            # 60min version of data, centered at bottom of the hour
+            # 1min interpolation, then 60min mean
+            df_60min = (
+                df
+                .resample('1min')
+                .interpolate()
+                .resample('60min').mean()
+            )
+            df_60min.index = df_60min.index + pd.Timedelta('30min')
+            dfs[j] = df_60min
+
+    # concatenate creating multiindex with keys of the list of point numbers
+    # assigned to 'point', reorder indices, and sort by valid_time
+    df_60min = (
+        pd.concat(dfs, keys=list(range(num_sites)), names=['point'])
+        .reorder_levels(["valid_time", "point"])
+        .sort_index(level='valid_time')
+    )
+
+    # set "point" index as a column
+    df_60min = df_60min.reset_index().set_index('valid_time')
+
+    # drop unneeded columns if they exist
+    # df_60min = df_60min.drop(['t2m', 'sdswrf'], axis=1, errors='ignore')
+
+    return df_60min

hefty-0.0.2.dist-info/METADATA

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: hefty
+Version: 0.0.2
+Summary: Some (relatively) lightweight short-term energy forecasting tools for solar, wind, and load.
+Author: Will Hobbs
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://github.com/williamhobbs/hefty
+Project-URL: Issues, https://github.com/williamhobbs/hefty/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: herbie-data[extras]>=2025.11.2
+Requires-Dist: pvlib>=0.13.1
+Dynamic: license-file
+
+# hEFTy
+Some (relatively) lightweight short-term **e**nergy **f**orecasting **t**ools for solar, wind, and load.
+
+This repository currently includes solar and wind tools, but may expand one day to include electric load. Forecasts can be created using the NOAA GFS, NOAA GEFS, NOAA HRRR, and ECMWF IFS and AIFS (open data versions) models. 
+
+For solar, look at the notebook [solar_example.ipynb](examples/solar_example.ipynb) for some examples, and [more_solar_examples.ipynb](examples/more_solar_examples.ipynb) for more examples. Both of these convert the resource forecasts to power.
+
+There are also solar ensemble forecasts demonstrated in [ensemble_example.ipynb](examples/ensemble_example.ipynb).
+
+For wind, look at the notebook [wind_example.ipynb](examples/wind_example.ipynb). The wind tools are not as developed at the solar tools.
+
+The [custom.py](src/hefty/custom.py) module is intended to help with getting forecasts of "custom" weather parameters, not necessarily specific to wind or solar, which migh be useful for load forecasting.
+
+## Quick examples
+
+Here's a quick example of getting a solar resource data forecast:
+
+```python
+from hefty.solar import get_solar_forecast
+
+latitude = 33.5
+longitude = -86.8
+init_date = '2024-06-05 6:00' # datetime the forecast model was initialized
+resource_data = get_solar_forecast(
+    latitude,
+    longitude,
+    init_date,
+    run_length=18, # 18 hours are included in the forecast
+    lead_time_to_start=3, # forecast starts 3 hours out from the init_date
+    model='hrrr', # use NOAA HRRR
+)
+resource_data[
+    ['ghi','dni','dhi','temp_air','wind_speed']
+              ].plot(drawstyle='steps-mid')
+```
+
+with this output:
+
+<img src="images/output.png" width="500"/>
+
+Here's a wind resource forecast:
+
+```python
+from hefty.wind import get_wind_forecast
+
+latitude = 33.5
+longitude = -86.8
+init_date = '2024-06-05 6:00' # datetime the forecast model was initialized
+resource_data = get_wind_forecast(
+    latitude,
+    longitude,
+    init_date,
+    run_length=18, # 18 hours are included in the forecast
+    lead_time_to_start=3, # forecast starts 3 hours out from the init_date
+    model='gfs', # use NOAA GFS
+)
+resource_data[
+    ['wind_speed_10m', 'wind_speed_80m',
+    'wind_speed_100m', 'temp_air_2m', 
+    'pressure_0m']
+    ].plot(secondary_y=['pressure_0m'], drawstyle='steps-mid')
+```
+with this output (note that pressure is on the secondary y-axis):
+
+<img src="images/output_wind.png" width="500"/>
+
+## Installation
+
+A virtual environment is strongly recommended. You can install from PyPi with:
+
+```
+pip install hefty
+```
+
+To run the example jupyter notebooks:
+
+```
+pip install jupyter
+```
+
+## References
+This project uses several Python packages, including pvlib, an open-source solar PV modeling package [1, 2], and Herbie [3, 4], a package for accessing weather forecast data from NOAA. `pv_model.py` (with the `model_pv_power()` function used here) comes from [5] which leverages some functions from [6].
+
+<img src="images/pvlib_powered_logo_horiz.png" width="200"/>
+
+
+[1] Anderson, K., Hansen, C., Holmgren, W., Jensen, A., Mikofski, M., and Driesse, A. “pvlib python: 2023 project update.” Journal of Open Source Software, 8(92), 5994, (2023). [DOI: 10.21105/joss.05994](http://dx.doi.org/10.21105/joss.05994).
+
+[2] https://github.com/pvlib/pvlib-python
+
+[3] Blaylock, B. K. (2025). Herbie: Retrieve Numerical Weather Prediction Model Data (Version 2025.3.1) [Computer software]. https://doi.org/10.5281/zenodo.4567540
+
+[4] https://github.com/blaylockbk/Herbie
+
+[5] https://github.com/williamhobbs/pv-system-model
+
+[6] Hobbs, W., Anderson, K., Mikofski, M., and Ghiz, M. "An approach to modeling linear and non-linear self-shading losses with pvlib." 2024 PV Performance Modeling Collaborative (PVPMC). https://github.com/williamhobbs/2024_pvpmc_self_shade 

hefty-0.0.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+hefty/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hefty/custom.py,sha256=kiAJCepJCTfMSh05bHqPQ8nwV0qNek7Q4pE93gaVsmw,7787
+hefty/pv_model.py,sha256=a6CjnXtuTBX9YRzW3RPHQnXB3YvVo5tDNo-UNYmi8xw,24946
+hefty/solar.py,sha256=QLE7N4fvw7NfQI83ZtunZkOQgLGAm_EqEtESRR47i0A,71981
+hefty/utilities.py,sha256=p-cJm3LFb8zx_w2eAXYSqJOL52vxJkCjmhG0hX5wZ6c,10475
+hefty/wind.py,sha256=H05HeANWZU4A4SNZoTZOQDu_qglxdq9ajhWyyFfguHI,10358
+hefty-0.0.2.dist-info/licenses/LICENSE,sha256=uhu6UMO7Y0MMk8CdVYEZ2qkKAhd7uqmC2A8HSZFCjpA,1525
+hefty-0.0.2.dist-info/METADATA,sha256=fYALaE7lLDKjaMVikibWRTH67gxJ-xdAnvkcFxGntic,4695
+hefty-0.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+hefty-0.0.2.dist-info/top_level.txt,sha256=IlYG3mUbbVkE-8qbgF93CunyWNsflRLZfGgDzMvG5sE,6
+hefty-0.0.2.dist-info/RECORD,,

hefty-0.0.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+