windrex 0.1.0__tar.gz

windrex-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 WindreX Development Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

windrex-0.1.0/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: windrex
+Version: 0.1.0
+Summary: WindreX - Wind Resource eXchange: wind resource assessment, wake modeling, and site analysis
+Author: WindreX Development Team
+License: MIT
+Project-URL: Homepage, https://github.com/windrex-dev/windrex
+Project-URL: Repository, https://github.com/windrex-dev/windrex
+Keywords: wind energy,wind resource,renewable energy,Weibull,wake model,MCDA,capacity factor
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.22
+Requires-Dist: scipy>=1.8
+Requires-Dist: requests>=2.28
+Provides-Extra: era5
+Requires-Dist: atlite>=0.2.10; extra == "era5"
+Requires-Dist: xarray>=0.19; extra == "era5"
+Requires-Dist: dask>=2022.1; extra == "era5"
+Provides-Extra: viz
+Requires-Dist: matplotlib>=3.4; extra == "viz"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: ruff>=0.1; extra == "dev"
+Requires-Dist: build>=1.0; extra == "dev"
+Requires-Dist: twine>=4.0; extra == "dev"
+Provides-Extra: all
+Requires-Dist: atlite>=0.2.10; extra == "all"
+Requires-Dist: xarray>=0.19; extra == "all"
+Requires-Dist: dask>=2022.1; extra == "all"
+Requires-Dist: matplotlib>=3.4; extra == "all"
+Requires-Dist: pytest>=7.0; extra == "all"
+Requires-Dist: pytest-cov>=4.0; extra == "all"
+Dynamic: license-file
+
+# WindreX — Wind Resource eXchange
+
+[![Tests](https://github.com/msotocalvo/windrex/actions/workflows/tests.yml/badge.svg)](https://github.com/msotocalvo/windrex/actions/workflows/tests.yml)
+[![DOI](https://zenodo.org/badge/1175040723.svg)](https://doi.org/10.5281/zenodo.18898424)
+
+A Python library for wind resource assessment, wake modeling, turbine database
+management, MCDA-based site suitability analysis, and capacity factor computation.
+
+## Features
+
+- **Weibull Analysis**: MLE fitting, PDF, mean power density
+- **Wind Rose**: Directional frequency and speed distributions
+- **Wind Shear**: Power-law extrapolation to hub height
+- **Wake Modeling**: Jensen/Park single-wake deficit, array efficiency with RSS superposition
+- **Capacity Factor**: Hourly CF from Open-Meteo, NASA POWER, or ERA5 data
+- **Turbine Database**: atlite YAML + OEDB REST API
+- **MCDA**: Multi-criteria site suitability (entropy, PCA, manual weights)
+- **Economics**: LCOE, NPV, IRR, sensitivity analysis
+- **Regional Analysis**: Grid-based resource assessment with development zones
+
+## Installation
+
+```bash
+pip install windrex
+```
+
+With ERA5 support:
+```bash
+pip install windrex[era5]
+```
+
+## Quick Start
+
+```python
+from windrex import fit_weibull, weibull_pdf, compute_wind_rose
+import numpy as np
+
+# Fit Weibull to measured speeds
+speeds = np.random.weibull(2.0, 10000) * 7.0
+k, A = fit_weibull(speeds)
+print(f"Weibull k={k:.2f}, A={A:.2f}")
+
+# Compute wind rose
+directions = np.random.uniform(0, 360, len(speeds))
+rose = compute_wind_rose(speeds, directions)
+```
+
+## License
+
+MIT

windrex-0.1.0/README.md

@@ -0,0 +1,50 @@
+# WindreX — Wind Resource eXchange
+
+[![Tests](https://github.com/msotocalvo/windrex/actions/workflows/tests.yml/badge.svg)](https://github.com/msotocalvo/windrex/actions/workflows/tests.yml)
+[![DOI](https://zenodo.org/badge/1175040723.svg)](https://doi.org/10.5281/zenodo.18898424)
+
+A Python library for wind resource assessment, wake modeling, turbine database
+management, MCDA-based site suitability analysis, and capacity factor computation.
+
+## Features
+
+- **Weibull Analysis**: MLE fitting, PDF, mean power density
+- **Wind Rose**: Directional frequency and speed distributions
+- **Wind Shear**: Power-law extrapolation to hub height
+- **Wake Modeling**: Jensen/Park single-wake deficit, array efficiency with RSS superposition
+- **Capacity Factor**: Hourly CF from Open-Meteo, NASA POWER, or ERA5 data
+- **Turbine Database**: atlite YAML + OEDB REST API
+- **MCDA**: Multi-criteria site suitability (entropy, PCA, manual weights)
+- **Economics**: LCOE, NPV, IRR, sensitivity analysis
+- **Regional Analysis**: Grid-based resource assessment with development zones
+
+## Installation
+
+```bash
+pip install windrex
+```
+
+With ERA5 support:
+```bash
+pip install windrex[era5]
+```
+
+## Quick Start
+
+```python
+from windrex import fit_weibull, weibull_pdf, compute_wind_rose
+import numpy as np
+
+# Fit Weibull to measured speeds
+speeds = np.random.weibull(2.0, 10000) * 7.0
+k, A = fit_weibull(speeds)
+print(f"Weibull k={k:.2f}, A={A:.2f}")
+
+# Compute wind rose
+directions = np.random.uniform(0, 360, len(speeds))
+rose = compute_wind_rose(speeds, directions)
+```
+
+## License
+
+MIT

windrex-0.1.0/pyproject.toml

@@ -0,0 +1,100 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "windrex"
+version = "0.1.0"
+description = "WindreX - Wind Resource eXchange: wind resource assessment, wake modeling, and site analysis"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.9"
+authors = [
+    {name = "WindreX Development Team"},
+]
+keywords = [
+    "wind energy",
+    "wind resource",
+    "renewable energy",
+    "Weibull",
+    "wake model",
+    "MCDA",
+    "capacity factor",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Scientific/Engineering :: Physics",
+]
+
+dependencies = [
+    "numpy>=1.22",
+    "scipy>=1.8",
+    "requests>=2.28",
+]
+
+[project.optional-dependencies]
+era5 = [
+    "atlite>=0.2.10",
+    "xarray>=0.19",
+    "dask>=2022.1",
+]
+viz = ["matplotlib>=3.4"]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov>=4.0",
+    "ruff>=0.1",
+    "build>=1.0",
+    "twine>=4.0",
+]
+all = [
+    "atlite>=0.2.10",
+    "xarray>=0.19",
+    "dask>=2022.1",
+    "matplotlib>=3.4",
+    "pytest>=7.0",
+    "pytest-cov>=4.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/windrex-dev/windrex"
+Repository = "https://github.com/windrex-dev/windrex"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["windrex*"]
+exclude = ["tests*"]
+
+[tool.pytest.ini_options]
+minversion = "7.0"
+addopts = "-ra -q --strict-markers"
+testpaths = ["tests"]
+filterwarnings = [
+    "ignore::DeprecationWarning",
+    "ignore::UserWarning",
+]
+markers = [
+    "slow: marks tests as slow",
+    "integration: marks tests as integration tests",
+    "requires_atlite: marks tests that require atlite",
+]
+
+[tool.ruff]
+target-version = "py39"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "W", "F", "I", "B", "C4", "UP"]
+ignore = ["E501", "B008", "C901"]
+
+[tool.ruff.lint.per-file-ignores]
+"__init__.py" = ["F401"]
+"tests/*" = ["B011"]

windrex-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

windrex-0.1.0/src/windrex/__init__.py

@@ -0,0 +1,57 @@
+"""
+WindreX — Wind Resource eXchange
+
+A Python library for wind resource assessment, wake modeling, turbine database
+management, and capacity factor computation.
+
+Modules:
+- windrex.core: Weibull, wind rose, shear, temporal, wake, capacity factor
+- windrex.data: Open-Meteo, NASA POWER, ERA5, terrain, LULC, turbine DB
+- windrex.economics: Financial analysis and LCOE sensitivity
+- windrex.analysis: MCDA engine and grid evaluation
+- windrex.regional: Regional analyzer and zone generation
+"""
+
+__version__ = "0.1.0"
+__author__ = "WindreX Development Team"
+
+from .core.weibull import fit_weibull, weibull_pdf, weibull_mean_power_density
+from .core.wind_rose import compute_wind_rose, WindRoseData
+from .core.shear import compute_wind_shear, extrapolate_speed
+from .core.temporal import compute_diurnal_pattern, compute_seasonal_pattern
+from .core.wake import jensen_wake_deficit, compute_array_efficiency, compute_spacing_curve
+
+__all__ = [
+    "__version__",
+    # Weibull
+    "fit_weibull",
+    "weibull_pdf",
+    "weibull_mean_power_density",
+    # Wind rose
+    "compute_wind_rose",
+    "WindRoseData",
+    # Shear
+    "compute_wind_shear",
+    "extrapolate_speed",
+    # Temporal
+    "compute_diurnal_pattern",
+    "compute_seasonal_pattern",
+    # Wake
+    "jensen_wake_deficit",
+    "compute_array_efficiency",
+    "compute_spacing_curve",
+]
+
+
+def __getattr__(name):
+    """Lazy import for heavy modules."""
+    if name == "compute_wind_hourly_cf":
+        from .core.capacity_factor import compute_wind_hourly_cf
+        return compute_wind_hourly_cf
+    if name == "WindAnalyzer":
+        from .regional.analyzer import WindAnalyzer
+        return WindAnalyzer
+    if name == "compute_wind_financials":
+        from .economics.financial import compute_wind_financials
+        return compute_wind_financials
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")

windrex-0.1.0/src/windrex/analysis/__init__.py

@@ -0,0 +1,9 @@
+"""Analysis modules for wind resource assessment."""
+
+from .mcda import compute_mcda_scores, entropy_weights, pca_weights
+
+__all__ = [
+    "compute_mcda_scores",
+    "entropy_weights",
+    "pca_weights",
+]

windrex-0.1.0/src/windrex/analysis/grid.py

@@ -0,0 +1,117 @@
+"""Grid evaluation and zone generation for wind assessment."""
+
+from __future__ import annotations
+
+import math
+
+import numpy as np
+
+
+def build_grid(
+    bounds: tuple[float, float, float, float],
+    resolution: float = 0.25,
+) -> tuple[np.ndarray, np.ndarray]:
+    """Build regular lat/lon grid within domain bounds.
+
+    Parameters
+    ----------
+    bounds : tuple
+        (south, west, north, east) in degrees.
+    resolution : float
+        Grid spacing in degrees.
+
+    Returns
+    -------
+    tuple[np.ndarray, np.ndarray]
+        (lats, lons) — 1D arrays of grid coordinates.
+    """
+    south, west, north, east = bounds
+    lats = np.arange(south + resolution / 2, north, resolution)
+    lons = np.arange(west + resolution / 2, east, resolution)
+    if len(lats) == 0:
+        lats = np.array([(south + north) / 2])
+    if len(lons) == 0:
+        lons = np.array([(west + east) / 2])
+    return lats, lons
+
+
+def compute_distance_to_grid(
+    grid_points: list[dict],
+    transmission_lines: list[dict],
+    bounds: tuple[float, float, float, float],
+) -> list[float]:
+    """Compute minimum distance from each grid point to nearest transmission line.
+
+    Parameters
+    ----------
+    grid_points : list[dict]
+        List of dicts with 'lat' and 'lon' keys.
+    transmission_lines : list[dict]
+        List of line dicts with 'coords' key (list of [lat, lon] pairs).
+    bounds : tuple
+        (south, west, north, east) for latitude correction.
+
+    Returns
+    -------
+    list[float]
+        Distance in km per grid point.
+    """
+    n = len(grid_points)
+    if not transmission_lines:
+        return [0.0] * n
+
+    line_coords = []
+    for line in transmission_lines:
+        coords = line.get("coords", [])
+        for coord in coords:
+            line_coords.append((coord[0], coord[1]))
+
+    if not line_coords:
+        return [0.0] * n
+
+    south, west, north, east = bounds
+    lc = np.array(line_coords)
+    km_per_deg_lat = 111.32
+    mid_lat = (south + north) / 2
+    km_per_deg_lon = 111.32 * math.cos(math.radians(mid_lat))
+
+    pt_lats = np.array([pt["lat"] for pt in grid_points])
+    pt_lons = np.array([pt["lon"] for pt in grid_points])
+
+    dy = (pt_lats[:, None] - lc[None, :, 0]) * km_per_deg_lat
+    dx = (pt_lons[:, None] - lc[None, :, 1]) * km_per_deg_lon
+    dist = np.sqrt(dx ** 2 + dy ** 2)
+
+    return np.min(dist, axis=1).tolist()
+
+
+def wind_cf_from_speed(
+    ws_hourly: np.ndarray,
+    pc_wind_speeds: list[float],
+    pc_power_mw: list[float],
+    rated_mw: float,
+) -> float:
+    """Compute mean capacity factor from hourly wind speeds and power curve.
+
+    Parameters
+    ----------
+    ws_hourly : np.ndarray
+        Hourly wind speed at hub height (m/s).
+    pc_wind_speeds : list[float]
+        Power curve wind speeds (m/s).
+    pc_power_mw : list[float]
+        Power curve output (MW).
+    rated_mw : float
+        Turbine rated power (MW).
+
+    Returns
+    -------
+    float
+        Mean capacity factor.
+    """
+    if not pc_wind_speeds or not pc_power_mw or rated_mw <= 0:
+        return 0.0
+
+    ws = np.asarray(ws_hourly, dtype=float)
+    power_out = np.interp(ws, pc_wind_speeds, pc_power_mw, left=0.0, right=0.0)
+    return float(np.nanmean(power_out) / rated_mw)

windrex-0.1.0/src/windrex/analysis/mcda.py

@@ -0,0 +1,143 @@
+"""Multi-Criteria Decision Analysis (MCDA) engine.
+
+Supports three weighting methods:
+- Shannon entropy weights
+- PCA-based weights (first principal component loadings)
+- Manual weights (user-supplied)
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+
+def compute_mcda_scores(
+    grid_points: list[dict],
+    criteria: dict[str, dict],
+    method: str = "entropy",
+) -> tuple[np.ndarray, dict[str, float]]:
+    """Compute MCDA composite scores for grid points.
+
+    Parameters
+    ----------
+    grid_points : list[dict]
+        List of dicts with criterion values as keys.
+    criteria : dict[str, dict]
+        Criteria configuration. Each key maps to a dict with:
+        - 'enabled': bool
+        - 'weight': float (for manual method)
+        - 'direction': 'maximize' or 'minimize'
+    method : str
+        Weighting method: 'entropy', 'pca', or 'manual'.
+
+    Returns
+    -------
+    tuple[np.ndarray, dict[str, float]]
+        (scores, computed_weights) — composite scores per grid point
+        and the weights used.
+    """
+    enabled = {name: c for name, c in criteria.items() if c.get("enabled", True)}
+    criteria_names = list(enabled.keys())
+    n_cells = len(grid_points)
+    n_criteria = len(criteria_names)
+
+    if n_cells == 0 or n_criteria == 0:
+        return np.zeros(n_cells), {}
+
+    # Build raw matrix
+    raw_matrix = np.zeros((n_cells, n_criteria))
+    for j, name in enumerate(criteria_names):
+        for i, pt in enumerate(grid_points):
+            raw_matrix[i, j] = pt.get(name, 0.0)
+
+    # Min-max normalization
+    norm_matrix = np.zeros_like(raw_matrix)
+    for j in range(n_criteria):
+        col = raw_matrix[:, j]
+        col_min, col_max = col.min(), col.max()
+        if col_max - col_min > 1e-10:
+            norm_matrix[:, j] = (col - col_min) / (col_max - col_min)
+        else:
+            norm_matrix[:, j] = 0.5
+
+        # Invert for minimize criteria
+        if enabled[criteria_names[j]].get("direction", "maximize") == "minimize":
+            norm_matrix[:, j] = 1.0 - norm_matrix[:, j]
+
+    # Compute weights
+    if method == "entropy":
+        weights = entropy_weights(norm_matrix)
+    elif method == "pca":
+        weights = pca_weights(norm_matrix)
+    else:
+        raw_w = np.array([enabled[name].get("weight", 1.0) for name in criteria_names])
+        total_w = raw_w.sum()
+        weights = raw_w / total_w if total_w > 0 else np.ones(n_criteria) / n_criteria
+
+    computed = {name: float(weights[j]) for j, name in enumerate(criteria_names)}
+    scores = norm_matrix @ weights
+
+    return scores, computed
+
+
+def entropy_weights(norm_matrix: np.ndarray) -> np.ndarray:
+    """Compute weights using Shannon entropy method.
+
+    Parameters
+    ----------
+    norm_matrix : np.ndarray
+        Normalized decision matrix, shape (n_alternatives, n_criteria).
+
+    Returns
+    -------
+    np.ndarray
+        Weights per criterion.
+    """
+    n, m = norm_matrix.shape
+    if n <= 1:
+        return np.ones(m) / m
+
+    shifted = norm_matrix + 1e-10
+    col_sums = shifted.sum(axis=0)
+    col_sums[col_sums == 0] = 1
+    p = shifted / col_sums
+
+    k = 1.0 / np.log(n)
+    with np.errstate(divide="ignore", invalid="ignore"):
+        H = -k * np.nansum(p * np.log(p + 1e-30), axis=0)
+
+    d = np.maximum(1.0 - H, 0)
+    total = d.sum()
+    if total > 0:
+        return d / total
+    return np.ones(m) / m
+
+
+def pca_weights(norm_matrix: np.ndarray) -> np.ndarray:
+    """Compute weights from first principal component loadings.
+
+    Parameters
+    ----------
+    norm_matrix : np.ndarray
+        Normalized decision matrix.
+
+    Returns
+    -------
+    np.ndarray
+        Weights per criterion.
+    """
+    n, m = norm_matrix.shape
+    if n <= m or m <= 1:
+        return np.ones(m) / m
+
+    std = norm_matrix.std(axis=0)
+    std[std == 0] = 1
+    standardized = (norm_matrix - norm_matrix.mean(axis=0)) / std
+
+    # SVD-based PCA (no sklearn dependency)
+    _, _, Vt = np.linalg.svd(standardized, full_matrices=False)
+    loadings = np.abs(Vt[0])
+    total = loadings.sum()
+    if total > 0:
+        return loadings / total
+    return np.ones(m) / m