CCBlade

https://github.com/wisdem/ccblade
Admin
CCBlade is a blade element momentum method for analyzing wind turbine aerodynamic performance with...
Tokens:10,218
Snippets:90
Trust Score:1.3
License:Apache-2.0
Update:6 months ago
Show doc for...
Tokens:
Raw
### Install CCBlade

Source: https://github.com/wisdem/ccblade/blob/master/README.md

Install CCBlade using pip. Ensure you have the necessary build prerequisites like meson, ninja, and gfortran if building from source.

```bash
pip install CCBlade
```

--------------------------------

### Run CCBlade Unit Tests

Source: https://github.com/wisdem/ccblade/blob/master/README.md

Execute unit tests to verify a successful installation of CCBlade.

```bash
python test/test_ccblade.py
```

```bash
python test/test_gradients.py
```

--------------------------------

### Run CCBlade unit tests

Source: https://github.com/wisdem/ccblade/blob/master/docs/installation.rst

Execute these tests to confirm a successful installation of CCBlade. An 'OK' message indicates all tests passed.

```bash
python test/test_ccblade.py
```

--------------------------------

### Simulate Blade with Precurve

Source: https://github.com/wisdem/ccblade/blob/master/docs/tutorial.rst

Example of simulating a blade with precurve and presweep using the 'precurve' and 'presweep' parameters, corresponding to 'Rhub' and 'Rtip' respectively. It's advisable to set 'precone=0' when using precurve.

```python
# 1 ---
from ccblade import CCBlade
import numpy as np

r = np.array([0.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0, 22.0, 24.0, 26.0, 28.0, 30.0])
chord = np.array([3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0])
theta = np.deg2rad(np.array([13.3, 13.3, 13.3, 13.3, 13.3, 11.4, 9.5, 7.6, 5.7, 3.8, 1.9, 0.0, -1.9, -3.8, -5.7]))

# Airfoil data
af = CCAirfoil.initFromAerodynFile(r, "NREL5MW/5MW_Aero_Data.txt")

# Rotor properties
B = 3
Rhub = 3.0
Rtip = 63.0
precone = 0.0 # set to 0 for precurve
tilt = np.deg2rad(0.0)
yaw = np.deg2rad(0.0)

# Precurve and presweep
precurve = np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]) # in meters
presweep = np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]) # in meters

# Create CCBlade object with precurve and presweep
rotor = CCBlade(r, chord, theta, af, Rhub, Rtip, B, rho, mu,
                precone, tilt, yaw, shearExp, hubHt, nSector,
                precurve=precurve, presweep=presweep)
```

--------------------------------

### Setup CCBlade rotor object

Source: https://context7.com/wisdem/ccblade/llms.txt

Configure a CCBlade rotor object by defining blade geometry, atmospheric conditions, and turbine parameters. Airfoils must be mapped to specific radial stations along the blade.

```python
import numpy as np
from math import pi
from ccblade import CCAirfoil, CCBlade

# Define blade geometry (NREL 5-MW example)
Rhub = 1.5   # hub radius (m)
Rtip = 63.0  # tip radius (m)

# Radial stations along blade (m)
r = np.array([2.8667, 5.6000, 8.3333, 11.7500, 15.8500, 19.9500, 24.0500,
              28.1500, 32.2500, 36.3500, 40.4500, 44.5500, 48.6500, 52.7500,
              56.1667, 58.9000, 61.6333])

# Chord distribution (m)
chord = np.array([3.542, 3.854, 4.167, 4.557, 4.652, 4.458, 4.249, 4.007,
                  3.748, 3.502, 3.256, 3.010, 2.764, 2.518, 2.313, 2.086, 1.419])

# Twist distribution (deg) - positive decreases angle of attack
theta = np.array([13.308, 13.308, 13.308, 13.308, 11.480, 10.162, 9.011, 7.795,
                  6.544, 5.361, 4.188, 3.125, 2.319, 1.526, 0.863, 0.370, 0.106])

B = 3  # number of blades

# Turbine configuration
tilt = 5.0      # shaft tilt (deg)
precone = 2.5   # hub precone (deg)
yaw = 0.0       # yaw error (deg)

# Atmospheric conditions
rho = 1.225       # air density (kg/m^3)
mu = 1.81206e-5   # dynamic viscosity (kg/m/s)

# Wind profile
shearExp = 0.2  # power-law shear exponent
hubHt = 90.0    # hub height (m)
nSector = 8     # azimuthal sectors for averaging

# Load airfoils for each station
afinit = CCAirfoil.initFromAerodynFile
airfoil_types = [
    afinit('Cylinder1.dat'),
    afinit('Cylinder2.dat'),
    afinit('DU40_A17.dat'),
    afinit('DU35_A17.dat'),
    afinit('DU30_A17.dat'),
    afinit('DU25_A17.dat'),
    afinit('DU21_A17.dat'),
    afinit('NACA64_A17.dat')
]

# Map airfoils to radial stations
af_idx = [0, 0, 1, 2, 3, 3, 4, 5, 5, 6, 6, 7, 7, 7, 7, 7, 7]
af = [airfoil_types[i] for i in af_idx]

# Create CCBlade object
rotor = CCBlade(r, chord, theta, af, Rhub, Rtip, B, rho, mu,
                precone, tilt, yaw, shearExp, hubHt, nSector)
```

--------------------------------

### CCBlade Constructor with Optional Parameters

Source: https://github.com/wisdem/ccblade/blob/master/docs/tutorial.rst

Demonstrates the CCBlade constructor, highlighting optional parameters like tiploss, hubloss, wakerotation, usecd, and iterRe. Defaults are generally True for losses and rotation, and True for usecd.

```python
# create CCBlade object
rotor = CCBlade(r, chord, theta, af, Rhub, Rtip, B, rho, mu,
                precone, tilt, yaw, shearExp, hubHt, nSector,
                tiploss=True, hubloss=True, wakerotation=True, usecd=True, iterRe=1)
```

--------------------------------

### Initialize CCAirfoil with manual data

Source: https://context7.com/wisdem/ccblade/llms.txt

Create a CCAirfoil instance by providing arrays for angle of attack, Reynolds numbers, and aerodynamic coefficients. This approach requires manual definition of lift, drag, and moment coefficient matrices.

```python
import numpy as np
from ccblade import CCAirfoil

# Define airfoil data arrays
alpha = np.linspace(-180, 180, 100)  # angles of attack in degrees
Re = [1e6, 5e6, 10e6]  # Reynolds numbers

# 2D arrays for coefficients: shape (alpha.size, Re.size)
cl = np.zeros((len(alpha), len(Re)))  # lift coefficients
cd = np.zeros((len(alpha), len(Re)))  # drag coefficients
cm = np.zeros((len(alpha), len(Re)))  # moment coefficients (optional)

# Fill in coefficient data (simplified example)
for j, reynolds in enumerate(Re):
    cl[:, j] = 2 * np.pi * np.deg2rad(alpha) * 0.9  # simplified linear lift
    cd[:, j] = 0.01 + 0.05 * np.deg2rad(alpha)**2   # simplified drag polar

# Create CCAirfoil instance
airfoil = CCAirfoil(alpha, Re, cl, cd, cm=cm, AFName="DU25_A17")

# Evaluate lift and drag at specific conditions
alpha_rad = np.deg2rad(5.0)  # angle of attack in radians
Re_eval = 3e6  # Reynolds number
cl_val, cd_val = airfoil.evaluate(alpha_rad, Re_eval)
print(f"At alpha=5 deg, Re=3e6: Cl={cl_val:.4f}, Cd={cd_val:.4f}")
```

--------------------------------

### Compare Scalar Performance Gradients with Finite Differencing

Source: https://github.com/wisdem/ccblade/blob/master/docs/tutorial.rst

Verify analytic power gradients with respect to scalar design variables like precone using finite differences.

```python
# analytic
dP_dprecone = dP['precone'][0]

# finite difference
precone_eps = precone + 1e-6
_, _, P_eps, _, _, _ = CCBlade(r, chord, theta, af, Rhub, Rtip, nSector, rho, mu, precone_eps, tilt, yaw, shearExp, hubHt).rotorAeroParameters(r, chord, theta, twist, Uinf, Omega, pitch)
dP_fd = (P_eps - P) / 1e-6

print('(analytic) dP/dprecone =', dP_dprecone)
print('(fin diff) dP/dprecone =', dP_fd)
```

--------------------------------

### Define NREL 5-MW Model Geometry and Atmosphere

Source: https://github.com/wisdem/ccblade/blob/master/docs/tutorial.rst

Sets up the geometric and atmospheric properties for the NREL 5-MW reference model simulation. Ensure all necessary parameters are defined before proceeding.

```python
from ccblade import CCBlade, CCAirfoil
import numpy as np

# NREL 5-MW model parameters
r = np.array([0.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0, 22.0, 24.0, 26.0, 28.0, 30.0])
chord = np.array([3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0])
theta = np.deg2rad(np.array([13.3, 13.3, 13.3, 13.3, 13.3, 11.4, 9.5, 7.6, 5.7, 3.8, 1.9, 0.0, -1.9, -3.8, -5.7]))

# Atmospheric properties
rho = 1.225 # kg/m^3
mu = 1.81e-5 # Pa*s

# Rotor properties
B = 3 # number of blades
Rhub = 3.0 # radius of hub
Rtip = 63.0 # radius of tip
precone = np.deg2rad(2.5) # precone angle
tilt = np.deg2rad(0.0) # tilt angle
yaw = np.deg2rad(0.0) # yaw angle

# Other parameters
shearExp = 0.14 # exponent for wind shear
hubHt = 90.0 # hub height
nSector = 8 # number of sectors for integration
```

--------------------------------

### Run CCBlade gradient tests

Source: https://github.com/wisdem/ccblade/blob/master/docs/installation.rst

Run these additional tests to verify the gradients for CCBlade. An 'OK' message indicates all tests passed.

```bash
python test/test_gradients.py
```

--------------------------------

### Compare Distributed Load Gradients with Finite Differencing

Source: https://github.com/wisdem/ccblade/blob/master/docs/tutorial.rst

Verify analytic gradients against finite difference approximations for distributed load components.

```python
i = 5
# analytic
dNp_dr = dNp['r'][i, i]

# finite difference
r_eps = r.copy()
r_eps[i] += 1e-6
Np_eps, _, _, _ = blade.distributedAeroLoads(r_eps, chord, theta, twist, Uinf, Omega, pitch)
dNp_fd = (Np_eps[i] - Np[i]) / 1e-6

print('(analytic) dNp_i/dr_i =', dNp_dr)
print('(fin diff) dNp_i/dr_i =', dNp_fd)
```

--------------------------------

### Enable Analytic Gradients in CCBlade

Source: https://github.com/wisdem/ccblade/blob/master/docs/tutorial.rst

Initialize the CCBlade object with the derivatives=True keyword to enable analytic gradient computation.

```python
af = CCAirfoil.initFromAerodynFile(af_files)
blade = CCBlade(r, chord, theta, af, Rhub, Rtip, nSector, rho, mu, precone, tilt, yaw, shearExp, hubHt, derivatives=True)
```

--------------------------------

### Compare Vector Performance Gradients with Finite Differencing

Source: https://github.com/wisdem/ccblade/blob/master/docs/tutorial.rst

Verify analytic power gradients with respect to vector design variables like blade radius using finite differences.

```python
i = 5
# analytic
dP_dr = dP['r'][0, i]

# finite difference
r_eps = r.copy()
r_eps[i] += 1e-6
_, _, P_eps, _, _, _ = CCBlade(r_eps, chord, theta, af, Rhub, Rtip, nSector, rho, mu, precone, tilt, yaw, shearExp, hubHt).rotorAeroParameters(r_eps, chord, theta, twist, Uinf, Omega, pitch)
dP_fd = (P_eps - P) / 1e-6

print('(analytic) dP/dr_i =', dP_dr)
print('(fin diff) dP/dr_i =', dP_fd)
```

--------------------------------

### Initialize CCAirfoil from AeroDyn file

Source: https://context7.com/wisdem/ccblade/llms.txt

Load airfoil aerodynamic data directly from standard AeroDyn-formatted files. This method also provides access to derivative calculations for gradient-based optimization.

```python
from ccblade import CCAirfoil

# Load airfoil from AeroDyn file
airfoil = CCAirfoil.initFromAerodynFile('DU25_A17.dat')

# Evaluate coefficients
alpha_rad = np.deg2rad(8.0)
Re = 5e6
cl, cd = airfoil.evaluate(alpha_rad, Re)
print(f"Cl={cl:.4f}, Cd={cd:.4f}")

# Get lift/drag derivatives for gradient calculations
dcl_dalpha, dcl_dRe, dcd_dalpha, dcd_dRe = airfoil.derivatives(alpha_rad, Re)
print(f"dCl/dalpha={dcl_dalpha:.4f}")
```

--------------------------------

### Prepare Airfoil Polars with CCBlade Airfoilprep

Source: https://context7.com/wisdem/ccblade/llms.txt

Use the airfoilprep module to apply 3D rotational corrections and extrapolate airfoil polars to full 360-degree angle of attack range using Viterna method.

```python
from ccblade.airfoilprep import Airfoil, Polar

# Load airfoil from AeroDyn file
af = Airfoil.initFromAerodynFile('DU25_A17.dat')

# Apply 3D rotational stall delay corrections (Du-Selig method)
r_over_R = 0.5        # radial position / rotor radius
chord_over_r = 0.1    # local chord / local radius
tsr = 7.5             # tip-speed ratio
af_3d = af.correction3D(r_over_R, chord_over_r, tsr)

# Extrapolate to +/-180 degrees using Viterna method
cdmax = 1.5  # maximum drag coefficient estimate
af_extrap = af_3d.extrapolate(cdmax)

# Create data grid for CCBlade
alpha, Re, cl, cd, cm = af_extrap.createDataGrid()

# Write back to AeroDyn format
af_extrap.writeToAerodynFile('DU25_A17_prepared.dat')

print(f"Alpha range: {alpha.min():.1f} to {alpha.max():.1f} degrees")
print(f"Reynolds numbers: {Re}")
```

--------------------------------

### Configure Advanced BEM Options in CCBlade

Source: https://context7.com/wisdem/ccblade/llms.txt

Configure advanced BEM options including tip/hub losses, wake rotation, and drag effects on induction. Use iterRe=2 for higher accuracy if needed.

```python
from ccblade import CCBlade

# Create CCBlade with custom options
rotor = CCBlade(
    r, chord, theta, af, Rhub, Rtip, B, rho, mu,
    precone, tilt, yaw, shearExp, hubHt, nSector,
    # Loss models
    tiploss=True,       # Prandtl tip loss model (default: True)
    hubloss=True,       # Prandtl hub loss model (default: True)
    # Physics options
    wakerotation=True,  # Include wake swirl/tangential induction (default: True)
    usecd=True,         # Use drag in induction calculation (default: True)
    # Convergence options
    iterRe=1,           # Reynolds number iterations (default: 1, use 2 for high accuracy)
    # Gradient computation
    derivatives=False   # Enable analytic gradients (default: False)
)

# Example: Disable tip losses for academic comparison
rotor_no_tiploss = CCBlade(
    r, chord, theta, af, Rhub, Rtip, B, rho, mu,
    precone, tilt, yaw, shearExp, hubHt, nSector,
    tiploss=False, hubloss=False
)

outputs_standard, _ = rotor.evaluate([10.0], [10.0], [0.0], coefficients=True)
outputs_no_loss, _ = rotor_no_tiploss.evaluate([10.0], [10.0], [0.0], coefficients=True)

print(f"CP with losses: {outputs_standard['CP'][0]:.4f}")
print(f"CP without losses: {outputs_no_loss['CP'][0]:.4f}")
```

--------------------------------

### Load Airfoil Data from AeroDyn File

Source: https://github.com/wisdem/ccblade/blob/master/docs/tutorial.rst

Initializes CCAirfoil objects by reading data from AeroDyn files. This is a specialized constructor for handling standard airfoil data formats.

```python
af = CCAirfoil.initFromAerodynFile(r, "NREL5MW/5MW_Aero_Data.txt")
```

--------------------------------

### Access Performance Metric Gradients

Source: https://github.com/wisdem/ccblade/blob/master/docs/tutorial.rst

Retrieve gradients for global performance metrics like thrust, torque, and power.

```python
T, Q, P, dT, dQ, dP = blade.rotorAeroParameters(r, chord, theta, twist, Uinf, Omega, pitch)
```

--------------------------------

### Wind-aligned and Yaw-aligned Transformations

Source: https://github.com/wisdem/ccblade/blob/master/docs/csystem.rst

Methods for converting vectors between the wind-aligned coordinate system and the yaw-aligned coordinate system (tower top).

```APIDOC
## GET /DirectionVector/windToYaw

### Description
Transforms a vector from the wind-aligned coordinate system to the yaw-aligned coordinate system.

### Method
GET

### Endpoint
/DirectionVector/windToYaw

## GET /DirectionVector/yawToWind

### Description
Transforms a vector from the yaw-aligned coordinate system to the wind-aligned coordinate system.

### Method
GET

### Endpoint
/DirectionVector/yawToWind
```

--------------------------------

### Integrate CCBlade with OpenMDAO for MDO

Source: https://context7.com/wisdem/ccblade/llms.txt

Use CCBlade as an OpenMDAO component for integration into larger multidisciplinary optimization frameworks. Ensure all necessary inputs are set before running the model.

```python
import numpy as np
from openmdao.api import Problem, Group
from ccblade.ccblade_component import CCBladeLoads, CCBladeEvaluate

# Define modeling options
modeling_options = {
    'WISDEM': {
        'RotorSE': {
            'n_span': 17,      # number of spanwise stations
            'n_aoa': 200,      # number of angle of attack points
            'n_Re': 1,         # number of Reynolds numbers
            'n_tab': 1         # number of airfoil tables
        }
    }
}

# Create OpenMDAO problem
prob = Problem()
prob.model = Group()

# Add CCBlade loads component
prob.model.add_subsystem('ccblade_loads',
                         CCBladeLoads(modeling_options=modeling_options),
                         promotes=['*'])

prob.setup()

# Set inputs
prob.set_val('V_load', 10.0, units='m/s')
prob.set_val('Omega_load', 10.0, units='rpm')
prob.set_val('pitch_load', 0.0, units='deg')
prob.set_val('azimuth_load', 0.0, units='deg')
prob.set_val('r', r, units='m')
prob.set_val('chord', chord, units='m')
prob.set_val('theta', theta, units='deg')
prob.set_val('Rhub', 1.5, units='m')
prob.set_val('Rtip', 63.0, units='m')
# ... set remaining inputs

prob.run_model()

# Get outputs
Px = prob.get_val('loads_Px', units='N/m')  # flapwise loads
Py = prob.get_val('loads_Py', units='N/m')  # edgewise loads
```

--------------------------------

### Plot Aerodynamic Loading

Source: https://github.com/wisdem/ccblade/blob/master/docs/tutorial.rst

Visualizes the flapwise and lead-lag aerodynamic loading along the blade. This step typically follows the evaluation of distributed loads.

```python
# Plotting code would go here, referencing the 'loads' variable
```

--------------------------------

### Inertial and Wind-aligned Transformations

Source: https://github.com/wisdem/ccblade/blob/master/docs/csystem.rst

Methods for converting vectors between the inertial coordinate system (tower base) and the wind-aligned coordinate system.

```APIDOC
## GET /DirectionVector/inertialToWind

### Description
Transforms a vector from the inertial coordinate system to the wind-aligned coordinate system.

### Method
GET

### Endpoint
/DirectionVector/inertialToWind

## GET /DirectionVector/windToInertial

### Description
Transforms a vector from the wind-aligned coordinate system to the inertial coordinate system.

### Method
GET

### Endpoint
/DirectionVector/windToInertial
```

--------------------------------

### Model Blades with Precurve using CCBlade

Source: https://context7.com/wisdem/ccblade/llms.txt

Model blades with precurvature (out-of-plane sweep) for downwind turbines or advanced blade designs. Ensure precone is set to zero when using precurve.

```python
import numpy as np
from ccblade import CCBlade

# Standard blade geometry (as defined previously)
# ...

# Define precurve distribution - parabolic shape
precone = 0.0  # Set precone to zero when using precurve
precurve = np.linspace(0, 4.9, len(r))**2  # Parabolic precurve (m)
precurveTip = 25.0  # Precurve at tip (m)

# Optional: presweep (in-plane sweep)
presweep = np.zeros(len(r))  # No presweep
presweepTip = 0.0

# Create CCBlade with precurve
rotor_curved = CCBlade(r, chord, theta, af, Rhub, Rtip, B, rho, mu,
                       precone, tilt, yaw, shearExp, hubHt, nSector,
                       precurve=precurve, precurveTip=precurveTip,
                       presweep=presweep, presweepTip=presweepTip)

# Rotor radius is modified by precurve
print(f"Effective rotor radius: {rotor_curved.rotorR:.2f} m")

# Evaluate performance
outputs, _ = rotor_curved.evaluate([10.0], [10.0], [0.0], coefficients=True)
print(f"CP with precurve: {outputs['CP'][0]:.4f}")
```

--------------------------------

### Generate Power Curve

Source: https://context7.com/wisdem/ccblade/llms.txt

Evaluates rotor performance across a range of tip-speed ratios to generate a power curve. Uses matplotlib for visualization.

```python
import numpy as np
from math import pi
import matplotlib.pyplot as plt

# Define tip-speed ratio range
tsr = np.linspace(2, 14, 50)

# Fixed rotor speed, vary wind speed
Omega = 10.0 * np.ones_like(tsr)  # RPM
Uinf = Omega * pi / 30.0 * Rtip / tsr  # corresponding wind speeds
pitch = np.zeros_like(tsr)  # zero pitch

# Evaluate across all conditions
outputs, derivs = rotor.evaluate(Uinf, Omega, pitch, coefficients=True)
CP = outputs['CP']
CT = outputs['CT']

# Find optimal tip-speed ratio
idx_max = np.argmax(CP)
tsr_opt = tsr[idx_max]
CP_max = CP[idx_max]

print(f"Optimal TSR: {tsr_opt:.2f}")
print(f"Maximum CP: {CP_max:.4f}")

# Plot power coefficient curve
plt.figure(figsize=(8, 5))
plt.plot(tsr, CP, 'b-', linewidth=2)
plt.axvline(tsr_opt, color='r', linestyle='--', label=f'Optimal TSR={tsr_opt:.2f}')
plt.xlabel('Tip-Speed Ratio (λ)')
plt.ylabel('Power Coefficient (CP)')
plt.title('Rotor Power Curve')
plt.grid(True)
plt.legend()
plt.show()
```

--------------------------------

### Evaluate Power, Thrust, and Torque Coefficients

Source: https://github.com/wisdem/ccblade/blob/master/docs/tutorial.rst

Calculates the overall power, thrust, and torque coefficients for the rotor at given operating conditions. This method is suitable for generating power curves and expects array-like input.

```python
# Evaluate power, thrust, and torque coefficients
# Input is array_like, so a list of size one is used for a single operating point
CP, CT, CQ = rotor.evaluate(omega, wind_speed_array, rho, mu, coefficients=True)
```

--------------------------------

### Access Distributed Load Gradients

Source: https://github.com/wisdem/ccblade/blob/master/docs/tutorial.rst

Retrieve gradients for distributed loads from the dictionary returned by the load calculation method.

```python
Np, Tp, dNp, dTp = blade.distributedAeroLoads(r, chord, theta, twist, Uinf, Omega, pitch)

# dNp is a dictionary of 2D arrays
print(dNp['r'])
```

--------------------------------

### Construct CCBlade Object

Source: https://github.com/wisdem/ccblade/blob/master/docs/tutorial.rst

Creates an instance of the CCBlade class with specified geometric, atmospheric, and rotor properties. This object is used for aerodynamic performance calculations.

```python
rotor = CCBlade(r, chord, theta, af, Rhub, Rtip, B, rho, mu, precone, tilt, yaw, shearExp, hubHt, nSector)
```

--------------------------------

### Evaluate Distributed Aerodynamic Loads

Source: https://github.com/wisdem/ccblade/blob/master/docs/tutorial.rst

Calculates the distributed flapwise and lead-lag aerodynamic loads along the blade at specified operating conditions. Requires a defined CCBlade rotor object.

```python
omega = np.deg2rad(6.0) # rotational speed in rad/s
wind_speed = 11.0 # m/s
wind_speed_array = np.ones_like(r) * wind_speed

# Evaluate distributed loads
loads = rotor.evaluate(omega, wind_speed_array, rho, mu)
```

--------------------------------

### CCBlade Class

Source: https://github.com/wisdem/ccblade/blob/master/docs/documentation.rst

The CCBlade class performs aerodynamic analysis of wind turbine rotor blades using BEM theory, supporting gradient-based optimization.

```APIDOC
## CCBlade Class

### Description
Provides aerodynamic analysis of wind turbine rotor blades using BEM theory. Computes distributed aerodynamic loads and integrated quantities like power, thrust, and torque.

### Methods
- **distributedAeroLoads**: Computes the distributed aerodynamic loads along the blade.
- **evaluate**: Computes integrated quantities such as power, thrust, and torque.
```

--------------------------------

### Evaluate Rotor Power and Thrust

Source: https://context7.com/wisdem/ccblade/llms.txt

Calculates integrated rotor quantities such as power, thrust, and torque coefficients. Inputs must be provided as arrays.

```python
import numpy as np
from math import pi

# Single operating point
Uinf = [10.0]    # wind speed (m/s) - as array
Omega = [11.5]   # rotor speed (RPM) - as array
pitch = [0.0]    # pitch angle (deg) - as array

# Evaluate rotor performance
outputs, derivs = rotor.evaluate(Uinf, Omega, pitch, coefficients=True)

# Dimensional outputs
P = outputs['P']    # power (W)
T = outputs['T']    # thrust (N)
Q = outputs['Q']    # torque (N*m)
Mb = outputs['Mb']  # blade root flapwise moment (N*m)

# Nondimensional coefficients
CP = outputs['CP']  # power coefficient
CT = outputs['CT']  # thrust coefficient
CQ = outputs['CQ']  # torque coefficient

print(f"Power: {P[0]/1e6:.2f} MW")
print(f"Thrust: {T[0]/1e3:.1f} kN")
print(f"CP = {CP[0]:.4f}, CT = {CT[0]:.4f}")
```

--------------------------------

### Calculate Distributed Aerodynamic Loads

Source: https://context7.com/wisdem/ccblade/llms.txt

Computes normal and tangential forces along the blade span for a specific operating condition. Requires a pre-initialized rotor object.

```python
from math import pi

# Operating conditions
Uinf = 10.0    # wind speed at hub height (m/s)
tsr = 7.55     # tip-speed ratio
pitch = 0.0    # blade pitch angle (deg)
Omega = Uinf * tsr / Rtip * 30.0 / pi  # rotor speed (RPM)
azimuth = 0.0  # blade azimuth position (deg)

# Compute distributed loads
loads, derivs = rotor.distributedAeroLoads(Uinf, Omega, pitch, azimuth)

# Extract results
Np = loads['Np']      # normal force per unit length (N/m) - flapwise
Tp = loads['Tp']      # tangential force per unit length (N/m) - edgewise
a = loads['a']        # axial induction factor
ap = loads['ap']      # tangential induction factor
alpha = loads['alpha'] # angle of attack (deg)
Cl = loads['Cl']      # lift coefficient
Cd = loads['Cd']      # drag coefficient
W = loads['W']        # relative velocity (m/s)
Re = loads['Re']      # Reynolds number

print(f"Max flapwise load: {max(Np):.1f} N/m at r={r[np.argmax(Np)]:.1f} m")
print(f"Max edgewise load: {max(Tp):.1f} N/m")
print(f"Average axial induction: {np.mean(a):.3f}")
```

--------------------------------

### Generate Nondimensional Power Curve

Source: https://github.com/wisdem/ccblade/blob/master/docs/tutorial.rst

Creates a plot of the nondimensional power coefficient (Cp) as a function of the tip-speed ratio (lambda). This is commonly used for analyzing rotor performance across different operating speeds.

```python
# Code to generate lambda and plot Cp vs lambda would go here
```

--------------------------------

### CCAirfoil Class

Source: https://github.com/wisdem/ccblade/blob/master/docs/documentation.rst

The CCAirfoil class evaluates airfoil data using continuously differentiable bivariate splines across angle of attack and Reynolds number.

```APIDOC
## CCAirfoil Class

### Description
Helper class to evaluate airfoil data with a continuously differentiable bivariate spline across the angle of attack and Reynolds number.

### Methods
- **initFromAerodynFile**: Initializes airfoil data from an AeroDyn file.
- **evaluate**: Evaluates the airfoil data at given conditions.
```
Tokens:
Raw