py_windblade_opa 0.6.6__tar.gz

py_windblade_opa-0.6.6/.gitignore

@@ -0,0 +1,93 @@
+# --- Core Python ---
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+.installed.cfg
+*.egg
+*.manifest
+*.spec
+
+# --- Distribution / Packaging ---
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+MANIFEST
+
+# --- Installer Logs ---
+pip-log.txt
+pip-delete-this-directory.txt
+
+# --- Testing & Code Quality ---
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# --- Modern Tooling (2026 Standards) ---
+# Ruff (Linter/Formatter cache)
+.ruff_cache/
+
+# MyPy (Type checking cache)
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Hatch (Build artifacts)
+.hatch/
+
+# --- Documentation ---
+# Sphinx
+docs/_build/
+# MkDocs
+/site
+
+# --- Jupyter Notebooks ---
+.ipynb_checkpoints
+profile_default/
+ipython_config.py
+
+# --- Environments ---
+# Note: We do NOT ignore uv.lock. Commit it!
+.env
+.venv
+env/
+venv/
+ENV/
+
+# --- IDEs & Editors ---
+# VS Code (User settings)
+.vscode/
+# PyCharm
+.idea/
+# Spyder
+.spyderproject
+.spyproject
+# Rope
+.ropeproject
+
+# --- OS Generated Files (Windows/Mac) ---
+Thumbs.db
+Desktop.ini
+.DS_Store

py_windblade_opa-0.6.6/.python-version

@@ -0,0 +1 @@
+3.13

py_windblade_opa-0.6.6/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Work in progress
+
+- [x] replace logging with the recommended logger pattern in all src
+
+# v0.6.5
+
+**MAIN CHANGES:**:
+
+- [x] Add a functionality that export into an md file the results of the analysis for the deol and the bem hansen
+- [x] Streamlined the deol_orch and bem_hansen to use the new PerformanceCurve contract and remove the clean_data param from the PerformancePostProcessor. See design/ongoing/PerformancePostProcessor-and-MDReport.md §5.
+
+
+
+# v0.6.1
+
+**Main changes:**
+
+- refactor: Cleaning up the deol code, to use the orchestrator version which is cleaner and more maintanable. 

py_windblade_opa-0.6.6/History.md

@@ -0,0 +1,47 @@
+# History/TODO
+
+# TODO
+
+- [ ] BladeGeometry v2
+  - Create a class method for reading from json file
+  - Create Save to json method.
+  - Modifyt BladeAuxFunction class to have (composition) a BladeGeometryContainer instance. 
+  - Decide whether this class will only hold geometry data or if it will alos provide convenience methods (that the BladeAuxFunction class currently implements)
+  - modify the deol code to use the BladeGeometryContainer class (instead of the previous implementation.)
+
+
+- [ ] FEAT: add airfoils in geometry JSON (Use Airfoil Factory)
+- [ ] REF: merge steps 2 and 3 (create a single method for the calculation of the Cf, Cm and lambda0_final parametes)
+- [ ] REF: merge steps 4,5
+- [ ] FEAT: Save data to file in a useful way
+  - [ ] xlsx  or csv
+  - [ ] decide if wide or long format is better (maybe provie both options?)
+
+
+
+## DONE: 
+- Blade Geometry Container class
+  - Refactored BladeCalc Class
+- [x] REF: merge steps 5,6 (create a single method for the all curves)
+
+Testing:
+- [x] TEST: test the curves_df method (brutal)
+- [x] TEST: test the curves_df method (clean)
+- [x] FEAT: add option for cleaning the data 
+- [x] TEST: Test option for cleaning the data (step5_curves_to_df)
+- [x] FEAT: Added a state machine that will allow software to automatically collect only the curves_df data that have a physical meaning 
+- [x] FEAT: add an argument that enables or disables the state machine (Defaults to true)
+- [x] FEAT: USE_LOOPS attribute inside class to allow quicker change
+- [x] TEST: Added tests of LOOPS and ARRAY versions of code
+- [x] TEST: use  @pytest.mark.parametrize to reduce repetition in the tests (the loops and arrays methods should yield the same results)
+
+
+## 0.1 (2024/07/03)
+
+Released v0.1 which:
+- has a Separate Blade Geometry Container class which is separate from the BladeCalc class
+- Refactored BladeCalc Class to be more readble 
+- Different airfoils for a specific $\lambda_0$ are permitted (in the loops version - not yet in the arrays)
+- Added an option for Using the different versions (arrays or loops) in the as aa module constant. 
+- Have enough tests
+- Added several mermaid flowcharts for the main calculation steps (for the original and refactored)

py_windblade_opa-0.6.6/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Nikolaos Papadakis
+
+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.

py_windblade_opa-0.6.6/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: py_windblade_opa
+Version: 0.6.6
+Summary: A package for the performance analysis and optimisation of wind turbine blades performance
+Project-URL: Documentation, https://npapnet.github.io/py_windblade_opa/
+Project-URL: Source, https://github.com/npapnet/py_windblade_opa
+Author-email: "N. Papadakis" <npapnet@gmail.com>
+License: MIT
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: openpyxl
+Requires-Dist: pandas
+Requires-Dist: plotnine>=0.15.2
+Requires-Dist: scipy
+Provides-Extra: docs
+Requires-Dist: furo; extra == 'docs'
+Requires-Dist: myst-parser; extra == 'docs'
+Requires-Dist: sphinx-autobuild; extra == 'docs'
+Requires-Dist: sphinx>=7.0; extra == 'docs'
+Requires-Dist: sphinxcontrib-mermaid; extra == 'docs'
+Description-Content-Type: text/markdown
+
+# py_windblade_opa
+
+A python package for Windblade Optimization and Performance Assessment
+
+Author: [N. Papadakis](https://github.com/npapnet).
+
+## Scope
+
+This package is intended to provide a set of tools for the optimization and performance assessment of wind turbine blades. 
+
+## Installation
+
+## For Users
+If you just want to use py_windblade_opa in your own projects, install the latest stable version from PyPI:
+
+> pip install py-windblade-opa
+
+## For Developers and Contributors
+
+We offer two ways to set up the development environment. We strongly recommend using uv (the modern method) as it guarantees you are using the exact same dependencies and Python version as the maintainers.
+
+### Option A: Using uv (Recommended)
+
+This method automatically handles Python version management and dependency locking.
+
+1. **Clone the repository**:
+
+```bash
+git clone https://github.com/npapnet/py_windblade_opa.git
+cd py_windblade_opa
+```
+
+2. **Sync the environment**: This command creates the virtual environment, installs the specific Python version required, and sets up the package in editable mode, installing also all the development dependencies. 
+
+```Bash
+uv sync --extra dev
+```
+
+3. **Run tests or scripts**: You can run commands inside the environment using `uv run`:
+
+
+```Bash
+# Run the test suite
+uv run pytest
+
+
+# Run a script
+uv run python examples/my_script.py
+``` 
+
+### Option B: Using Conda (Legacy)
+If you prefer managing your own environments with Conda, you can install the package in "editable" mode using standard pip.
+
+1. Clone the repository:
+
+```Bash
+git clone https://github.com/npapnet/py_windblade_opa.git
+cd py_windblade_opa
+```
+
+2. Create and activate your Conda environment:
+
+```Bash
+conda create -n windblade python=3.13
+conda activate windblade
+``` 
+
+Install in editable mode: Note: You must use the [dev] flag to get testing tools like pytest and ruff.
+
+```Bash
+pip install -e .[dev]
+```
+
+Verify Installation
+To confirm everything is working, run the following command (works for both methods):
+
+```cmd
+python -c "import py_windblade_opa; print(f'Successfully installed version {py_windblade_opa.__version__}')"
+``` 
+
+## Usage
+
+The package is still under development. The following is an example of how to use the package:
+
+```python   
+import py_windblade_opa as wbo
+
+power = 1000
+Cp = 0.45
+n_elec = 0.95
+v_nom = 10
+reqs = Reqs(power_w=power, n_elec=n_elec, v_nom=v_nom, Cp=Cp)
+
+constants = .wbo.Constants()
+config = wbo.Config(lambda0=4.8,  no_blades=3, pitch=0)
+r_m = wbo.reqs.estimate_blade_r()
+blade = wbo.Blade(r_m=r_m, wt_config=config)
+blade_calc = wbo.BladeCalc(blade=blade)
+
+blade.main_calculation()
+blade_calc.calculate_i_flow(verbosePlot=False)
+blade_calc.step3_eleven_coeffs(verbosePlot=False)
+blade_calc.step4_coeffs_collection()
+blade_calc.step5_rpm_power(verbosePlot=False)
+blade_calc.step6_torque_calcs(verbosePlot=True)
+
+plt.show()
+```

py_windblade_opa-0.6.6/README.md

@@ -0,0 +1,108 @@
+# py_windblade_opa
+
+A python package for Windblade Optimization and Performance Assessment
+
+Author: [N. Papadakis](https://github.com/npapnet).
+
+## Scope
+
+This package is intended to provide a set of tools for the optimization and performance assessment of wind turbine blades. 
+
+## Installation
+
+## For Users
+If you just want to use py_windblade_opa in your own projects, install the latest stable version from PyPI:
+
+> pip install py-windblade-opa
+
+## For Developers and Contributors
+
+We offer two ways to set up the development environment. We strongly recommend using uv (the modern method) as it guarantees you are using the exact same dependencies and Python version as the maintainers.
+
+### Option A: Using uv (Recommended)
+
+This method automatically handles Python version management and dependency locking.
+
+1. **Clone the repository**:
+
+```bash
+git clone https://github.com/npapnet/py_windblade_opa.git
+cd py_windblade_opa
+```
+
+2. **Sync the environment**: This command creates the virtual environment, installs the specific Python version required, and sets up the package in editable mode, installing also all the development dependencies. 
+
+```Bash
+uv sync --extra dev
+```
+
+3. **Run tests or scripts**: You can run commands inside the environment using `uv run`:
+
+
+```Bash
+# Run the test suite
+uv run pytest
+
+
+# Run a script
+uv run python examples/my_script.py
+``` 
+
+### Option B: Using Conda (Legacy)
+If you prefer managing your own environments with Conda, you can install the package in "editable" mode using standard pip.
+
+1. Clone the repository:
+
+```Bash
+git clone https://github.com/npapnet/py_windblade_opa.git
+cd py_windblade_opa
+```
+
+2. Create and activate your Conda environment:
+
+```Bash
+conda create -n windblade python=3.13
+conda activate windblade
+``` 
+
+Install in editable mode: Note: You must use the [dev] flag to get testing tools like pytest and ruff.
+
+```Bash
+pip install -e .[dev]
+```
+
+Verify Installation
+To confirm everything is working, run the following command (works for both methods):
+
+```cmd
+python -c "import py_windblade_opa; print(f'Successfully installed version {py_windblade_opa.__version__}')"
+``` 
+
+## Usage
+
+The package is still under development. The following is an example of how to use the package:
+
+```python   
+import py_windblade_opa as wbo
+
+power = 1000
+Cp = 0.45
+n_elec = 0.95
+v_nom = 10
+reqs = Reqs(power_w=power, n_elec=n_elec, v_nom=v_nom, Cp=Cp)
+
+constants = .wbo.Constants()
+config = wbo.Config(lambda0=4.8,  no_blades=3, pitch=0)
+r_m = wbo.reqs.estimate_blade_r()
+blade = wbo.Blade(r_m=r_m, wt_config=config)
+blade_calc = wbo.BladeCalc(blade=blade)
+
+blade.main_calculation()
+blade_calc.calculate_i_flow(verbosePlot=False)
+blade_calc.step3_eleven_coeffs(verbosePlot=False)
+blade_calc.step4_coeffs_collection()
+blade_calc.step5_rpm_power(verbosePlot=False)
+blade_calc.step6_torque_calcs(verbosePlot=True)
+
+plt.show()
+```

py_windblade_opa-0.6.6/design/.gitkeep

@@ -0,0 +1 @@
+

py_windblade_opa-0.6.6/design/TODOs-NOTE.md

@@ -0,0 +1,79 @@
+# Design Vision
+
+- I am inclined to move away from delegating to the engine the job of getting the
+  power curve. As this project pans out it makes more sense to have an overall object
+  that **HAS-A** geometry, an engine that consumes that geometry, and a post-processor
+  that consumes the output from the engine's contract. That will require reworking the
+  examples, so it might make sense to delegate that elsewhere. Develop contracts for
+  the geometry, engine, and post-processor.
+- The current architecture, contracts, and the rule that **pitch and airfoil are not
+  part of geometry** are written up in [architecture.md](architecture.md). Keep it
+  current.
+
+# Roadmap
+
+**New session? Start with
+[next_refactor/IMPLEMENTATION-STATUS.md](next_refactor/IMPLEMENTATION-STATUS.md)**
+(status, house rules, decision log). Full rationale: [architecture.md](architecture.md)
+§6. Four staged plans, 0.6.5 → 0.10.0:
+
+- **Stage 2** — geometry V2 + pitch decoupling →
+  [next_refactor/Stage2-AddingGeometryV2.md](next_refactor/Stage2-AddingGeometryV2.md)
+- **Stage 3** — airfoil abstraction (`AirfoilPolar` / `AirfoilProvider`; single +
+  family + custom data) →
+  [next_refactor/Stage3-AirfoilProvider.md](next_refactor/Stage3-AirfoilProvider.md)
+- **Stage 4** — `Blade`/`Rotor` assembly + declarative definition →
+  [next_refactor/Stage4-RotorAssembly.md](next_refactor/Stage4-RotorAssembly.md)
+- **Stage 5 / future** — top-level analysis object.
+
+# Tasks
+
+[x] Create an architecture.md describing the overall architecture → `design/architecture.md`.
+
+[ ] **Stage 2** — geometry unification + pitch/airfoil decoupling (see doc; 0.6.5 → 0.8.0):
+    [ ] `BladeGeometryContainer` accepts scalar / `None` tcratio + extrapolating interpolators (`fix` 0.6.6).
+    [ ] Remove `pitch_deg` from geometry; designer twist is pitch-free; pitch applied once at the engine (`fix` 0.6.6).
+    [ ] `WELBladeDesigner.main_calculation()` returns `BladeGeometrySpec` with `to_v1()` / `to_v2()` (`feat` 0.6.7).
+    [ ] D1: add `NACA4415poly` (poly-sampled table), delete `NACAtest`; DEOL airfoil re-baseline on V1 (breaking minor 0.7.0).
+    [ ] D2: DEOL `BladeCalcOrchestrator` consumes V2 geometry; airfoil a separate (single) arg; `delta_r`/`np.trapz` grid re-baseline (breaking minor 0.8.0).
+    [ ] Update deol tests, fixtures, examples, docs.
+
+
+
+[ ] **Stage 3** — airfoil abstraction (see doc; 0.8.0 → 0.9.0):
+    [ ] R1 `feat` 0.8.1 — `AirfoilPolar` + `AirfoilProvider` + `UniformAirfoil` + `ThicknessInterpolatedFamily` + custom-data loaders (CSV/arrays/df/files); equivalence-gated vs `NACA4415` / `NACA4415poly` / `AeroCoefficientInterpolator`.
+    [ ] R2 `feat` 0.8.2 — engines + designer consume the provider; `t/c`→fraction normalization (BEM Cp–λ unchanged); WEL schedule isolated; DEOL family path enabled.
+    [ ] R3 minor 0.9.0 — retire V1 `BladeGeometry` (value-neutral, breaking API).
+
+[ ] **Stage 4** — Blade/Rotor assembly + declarative definition (see doc; 0.9.0 → 0.10.0):
+    [ ] R1 `feat` 0.9.1 — `Blade`, `Rotor`, `OperatingPoint` (additive) + `Rotor.from_definition`/`to_definition` schema; `from_dtu`/`from_json` become adapters.
+    [ ] R2 minor 0.10.0 — engines adopt `analyze(rotor, op)`; `B`/set-pitch relocated to `Rotor`; geometry becomes single-blade; values unchanged vs 0.9.0.
+    [x] Naming review: `Blade` kept (decided 2026-06-19). `Rotor`/`OperatingPoint` names still open for Stage 4.
+
+[ ] **Stage 5 / Future** — top-level analysis object (`RotorAnalysis`, name TBD) that
+    HAS-A {rotor, engine, post-processor}; reworks examples to one high-level API.
+    Formalize the GeometryProvider / AirfoilProvider / Engine→PerformanceCurve contracts.
+
+# Chores
+
+# Agent behaviour
+
+- [x] make sure that the agent **recommends** freely a rename of the classes when a clearer name is available, and that it **does not** freely rename. The agent should be able to explain why a rename is recommended or not. *(Recorded as policy in architecture.md §7.)*
+
+# REVISIT
+
+[ ] **REVISIT (post Stage 2): fixed assembly-time pitch in `WELBladeDesigner`.**
+    Phase B made the designer twist pitch-free and moved pitch to a *runtime* engine
+    condition (removing the DEOL double-count). But `WELBladeDesigner` was intended for
+    **fixed-pitch blades**, where a `pitch` argument is meaningful: a fixed build/mounting
+    pitch baked into the *manufactured* twist, so `bl_a_i = bl_IiFlow - bl_ir - pitch` is
+    the as-built installed twist. The original term is preserved (commented, with a term
+    explanation) at `wel_blade_designer.py` `bl_a_i`. Decide later whether the designer
+    should expose an explicit *assembly-time* pitch (distinct from the engine's runtime
+    pitch) — likely settles alongside Stage 4 `Rotor`/`OperatingPoint` (where pitch lives).
+    Raised by N. Papadakis 2026-06-20.
+
+# Private notes — (agent: do not modify this section and below without explicit instruction)
+
+- scrub abandoned contracts, classes, and methods from the documents. e.g. cl_approx or cl_model in the airfoil context, after verifying the abandoment.
+- consolidate the design notes to remove duplication, redudancy, and outdated information. Ensure that the design notes reflect the current architecture and decisions made. check numbering consistency,  etc.