JFM notebooks for Effects of pressure gradient histories on skin friction and mean flow of high Reynolds number turbulent boundary layers over smooth and rough walls

JFM-Notebooks / Figure 9 / JFM Model Notebook.ipynb

¹²² views

unlisted

ubuntu2204

Kernel: Python 3 (system-wide)

Model for predicting skin friction from effects of pressure gradient histories on skin-friction and mean flow of high Reynolds number turbulent boundary layers over smooth and rough walls

This code presents the work given in the paper to calulate the skin friction assuming the ZPG conditions along with the pressure gradient history. The model is based on the $\Delta \beta$ parameter which is defined as the following -

$\Delta \beta = \left(\frac{\delta^*}{\tau_w}\right)_{DS} \left[\frac{1}{x_{DS}-x_{US}}\int_{x_{US}}^{x_{DS}}\left(\frac{dP}{dx}\right) w(x) dx\right]~~{\rm where}~w(x) = \frac{x-x_{US}}{x_{DS}-x_{US}}$

It is based on the weighted average of the pressure gradient and the local conditions at the measurement station. Furthermore, we can predict skin friction based on the following equation -

$\sqrt{\frac{2}{C_f^{PG}}} - \sqrt{\frac{2}{C_f^{ZPG}}} = \frac{1}{\kappa} ln \left(\frac{y_0^{ZPG}}{y_0^{PG}}\right) + \frac{2}{\kappa} (\Pi^{PG} - \Pi^{ZPG}) + \frac{1}{\kappa} ln\left(\frac{\delta_{PG}^+}{\delta_{ZPG}^+}\right)$

We can assume the last two terms to be negligible at matched $Re_\tau$ since this work found $y_0$ to be independent of the pressure gradient history. This model uses a calibration based on the smooth wall data to predict the rough wall data, this function is based on the relationship between $\Pi_{PG} - \Pi_{ZPG}$ and $\Delta \beta$ . An iterative function is then used to solve for the $C_f$ , $\Pi$ and $\delta^*$ .

This first cell imports the required functions for the model

In [3]:

import numpy as np  # Numerical computing
import matplotlib.pyplot as plt  # Plotting
from scipy.optimize import curve_fit, fmin  # Curve fitting and optimization
import pickle  # Object serialization
from scipy.special import erf  # Error function

This next cell imports the date required for the model as well as defines the velocity and angle of attack arrays along with the symbols used for plotting.

In [4]:

# Import the data required for the model
with open('Cf_predictive_model_data.pkl', 'rb') as f:
    Model_Data = pickle.load(f)  # Load model data from a pickle file

# Define arrays of variables
AOA_array = [-8, -4, 0, 4, 8]  # Angles of Attack 500mm (AOA)
AOA_array_400mm_RW = [-10, -8, -4]  # AOA for 400mm Right Wing (RW)
AOA_array_400mm_SW = [-10, -8]  # AOA for 400mm Side Wing (SW)

Vel_array_400mm_RW = [20, 25, 30]  # Velocity array for 400mm RW
Vel_array_400mm_SW = [10, 20, 30]  # Velocity array for 400mm SW
Vel_array_RW = [10, 15, 20, 25, 30]  # Velocity array for RW
Vel_array_zpg = [15, 20, 25, 30, 35, 40]  # Velocity array for zero pressure gradient (zpg)
Vel_array_SW_all = [10, 15, 20, 25, 30]  # Velocity array for all SW
Vel_array_SW = [10, 20, 30]  # Velocity array for SW

Vel_array_upstream_SW = [10, 20, 30]  # Velocity array for upstream SW

# Symbols and colors for plotting
symbol = ['s', 'v', 'D', '^', 'H']  # Symbols for 500mm cases
symbol_400mm = ['>', 'd', '<']  # Symbols for 400mm cases
symbol_400mm_SW = ['>', 'd']  # Symbols for 400mm SW cases

colors_SW = ['tab:blue', 'tab:orange', 'tab:green', 'tab:red', 'tab:purple']  # Colors for SW

colors_SW_400mm = ['tab:brown', 'tab:cyan']  # Colors for 400mm SW
colors_RW_400mm = ['tab:brown', 'tab:cyan', 'tab:pink']  # Colors for 400mm RW

kappa = 0.39  # Constant value for kappa

This cell defines some common functions required for the code. The first is the functional fit assumed between the difference in PI and the $\Delta \beta$ . The next function defines the fit used for the wake fit based on Lewkowicz, A. 1982. The next two define the musker function for which we use the average value of a found from the fitting of the 500mm pressure gradient cases. For a smooth wall, the velocity profile is defined as using fit_composite_yplus, which combines Musker with the normal outer region func. Finally, a weight function is defined to be linear; however, it can be varied to use the error function if required.

In [5]:

def deltabeta_func(deltabeta, A):
    return A * deltabeta  # Linear relationship between deltabeta and A used for curve fitting

def W_func(eta):
    term1 = 2 * eta**2 * (3 - 2 * eta)
    term2 = (1 / np.pi) * eta**2 * (1 - eta) * (1 - 2 * eta)
    return term1 - term2  # Computes the weighting based on eta which is y/delta

def musker_func(yplus, a):
    alpha = (-1 / kappa - a) / 2
    beta = np.sqrt(-2 * a * alpha - alpha**2)
    R = np.sqrt(alpha**2 + beta**2)
    term1 = (1 / kappa) * np.log((yplus - a) / (-a))
    term2a = R**2 / (a * (4 * alpha - a))
    term2b = (4 * alpha + a) * np.log(-(a / R) * (np.sqrt((yplus - alpha)**2 + beta**2) / (yplus - a)))
    term2c = (alpha / beta) * (4 * alpha + 5 * a) * (np.arctan((yplus - alpha) / beta) + np.arctan(alpha / beta))
    term2 = term2a * (term2b + term2c)
    Uplusinner = term1 + term2
    return Uplusinner  # Computes inner layer (Musker profile) for turbulent flow over a smooth wall

def fit_composite_yplus(yplus, a, PI, retau):
    musk = musker_func(yplus, a) + np.exp(-np.log(yplus / 30)**2) / 2.85
    eta = yplus / retau
    W = 2 * eta**2 * (3 - 2 * eta) - (1 / np.pi) * eta**2 * (1 - eta) * (1 - 2 * eta)
    outer = PI / kappa * W
    return musk + outer  # Combines Musker and outer-layer profile

downstream_hw = 9.03 # defines where pressure gradient history for the integral ends
upstream_reference = 9.03 - 1.25 * 3  # defines where pressure gradient history starts from 

def weight_func(x):
    # Linear weight
    weight = (x - upstream_reference) / (downstream_hw - upstream_reference)

    # Error function-based weighting (commented out alternative)
    # mean, sigma = 0.5, 0.15
    # xnorm = (x - x[0]) / (x[-1] - x[0])
    # weight = 0.5 * (1 + erf((xnorm - mean) / (sigma * np.sqrt(2))))

    return weight  # Computes weight for the intergral of the history, it can be changed to use ERF function to show effect of weighting

The following cell produces a calibration function using the smooth wall data between the $\Pi_{PG} - \Pi_{ZPG}$ and $\Delta \beta$ and then plots the result. We calibrate the function by calculating $\delta^*$ from the composite velocity profile.

In [9]:

downstream_hw = 9.03  # Downstream reference limit where local conditions are to be evalualted
upstream_reference = 9.03 - 1.25 * 3  # Upstream reference limit

Vel = str(20)  # Velocity key as string

# Create figure and axes for plotting using a subplot mosaic
fig, axs = plt.subplot_mosaic([['a)']])

def beta_func(beta, A):
    return A * beta  # Defines a linear relationship for beta

# Initialize arrays for storing results
beta_all = []
pi_all = []

# Loop through AOA_array to process 500mm smooth wall (SW) data
for j in range(len(AOA_array)):
    AOA = str(AOA_array[j])
    Key_AOA = f"{AOA}_500mm_SW"  # Construct key for 500mm SW data
    Key_ZPG = 'ZPG_SW'  # Key for Zero-Pressure-Gradient (ZPG) SW data

    Tap_positons_m = Model_Data[Vel][Key_AOA]['Pressure Taps (m)']
    indexes_fit = np.where((Tap_positons_m < downstream_hw) & (Tap_positons_m > upstream_reference))  # Select fitting range

    weight = weight_func(Tap_positons_m[indexes_fit])  # Compute weight
    grad = Model_Data[Vel][Key_AOA]['ddeltaP/dx'][indexes_fit]  # Pressure gradient

    # Calculate difference in PI between AOA and ZPG
    delta_PI = Model_Data[Vel][Key_AOA]['PI'] - Model_Data[Vel][Key_ZPG]['PI']
    tau0 = Model_Data[Vel][Key_AOA]['rho'] * Model_Data[Vel][Key_AOA]['utau']**2  # Compute tau0

    # Compute composite profile for U+ and boundary layer integral parameters
    zplus = np.logspace(np.log10(5), np.log10(Model_Data[Vel][Key_AOA]['Re_tau']), 100)
    Uplus_profile = fit_composite_yplus(zplus, -10.36590192, Model_Data[Vel][Key_AOA]['PI'], Model_Data[Vel][Key_AOA]['Re_tau'])
    Cf = Model_Data[Vel][Key_AOA]['Cf']
    zfit = zplus * Model_Data[Vel][Key_AOA]['nu'] / Model_Data[Vel][Key_AOA]['utau']
    deltastar = np.trapz((1 - (Uplus_profile / np.sqrt(2 / Cf))), zfit) + 0.5 * (1 - (Uplus_profile[0] / np.sqrt(2 / Cf))) * zfit[0]

    # Calculate Δβ integral using weighted gradient
    Delta_beta_int = (deltastar / tau0) * (1 / (Tap_positons_m[indexes_fit][-1] - Tap_positons_m[indexes_fit][0])) * \
        np.trapz(grad * weight, Tap_positons_m[indexes_fit])
    
    # Plot results
    axs['a)'].plot(Delta_beta_int, delta_PI, marker=symbol[j], color=colors_SW[j], markerfacecolor='none', linestyle='none')

    # Store results in arrays
    beta_all.append(Delta_beta_int)
    pi_all.append(delta_PI)

# Plot reference point at (0, 0) for ZPG results
axs['a)'].plot(0, 0, marker='o', color='k', markerfacecolor='none', linestyle='none')

# Loop through AOA_array_400mm_SW to process 400mm smooth wall (SW) data
for j in range(len(AOA_array_400mm_SW)):
    AOA = str(AOA_array_400mm_SW[j])
    Key_AOA = f"{AOA}_400mm_SW"  # Construct key for 400mm SW data
    Key_ZPG = 'ZPG_SW'  # Key for Zero-Pressure-Gradient (ZPG) SW data

    Tap_positons_m = Model_Data[Vel][Key_AOA]['Pressure Taps (m)']
    indexes_fit = np.where((Tap_positons_m < downstream_hw) & (Tap_positons_m > upstream_reference))  # Select fitting range

    weight = weight_func(Tap_positons_m[indexes_fit])  # Compute weight
    grad = Model_Data[Vel][Key_AOA]['ddeltaP/dx'][indexes_fit]  # Pressure gradient

    delta_PI = Model_Data[Vel][Key_AOA]['PI'] - Model_Data[Vel][Key_ZPG]['PI']
    tau0 = Model_Data[Vel][Key_AOA]['rho'] * Model_Data[Vel][Key_AOA]['utau']**2  # Compute tau0

    # Compute composite profile for U+ and boundary layer integral parameters
    zplus = np.logspace(np.log10(5), np.log10(Model_Data[Vel][Key_AOA]['Re_tau']), 100)
    Uplus_profile = fit_composite_yplus(zplus, -10.36590192, Model_Data[Vel][Key_AOA]['PI'], Model_Data[Vel][Key_AOA]['Re_tau'])
    Cf = Model_Data[Vel][Key_AOA]['Cf']
    zfit = zplus * Model_Data[Vel][Key_AOA]['nu'] / Model_Data[Vel][Key_AOA]['utau']
    deltastar = np.trapz((1 - (Uplus_profile / np.sqrt(2 / Cf))), zfit) + 0.5 * (1 - (Uplus_profile[0] / np.sqrt(2 / Cf))) * zfit[0]

    # Calculate Δβ integral using weighted gradient
    Delta_beta_int = (deltastar / tau0) * (1 / (Tap_positons_m[indexes_fit][-1] - Tap_positons_m[indexes_fit][0])) * \
        np.trapz(grad * weight, Tap_positons_m[indexes_fit])

    # Plot results
    axs['a)'].plot(Delta_beta_int, delta_PI, marker=symbol_400mm[j], color=colors_SW_400mm[j], markerfacecolor='none', linestyle='none')

    # Store results in arrays
    beta_all.append(Delta_beta_int)
    pi_all.append(delta_PI)

# Fit Δβ func to data Δβ and ΔPI using curve fitting
pi_all = np.array(pi_all)
beta_all = np.array(beta_all)
fit_SW_only, _ = curve_fit(beta_func, beta_all, pi_all)

def beta_to_pi_diff(beta):
    return beta_func(beta, *fit_SW_only)  # Function to predict ΔPI from Δβ

# Generate fitted curve
beta_fit = np.linspace(np.min(beta_all) - 0.2, np.max(beta_all) + 0.2, 20)
axs['a)'].plot(beta_fit, beta_to_pi_diff(beta_fit), 'k--')  # Plot fitted curve

# Configure plot appearance
axs['a)'].grid()
axs['a)'].set_xlabel(r'$\Delta \beta$')
axs['a)'].set_ylabel(r'$\Pi_{PG} - \Pi_{ZPG}$')
axs['a)'].set_aspect(1.0 / axs['a)'].get_data_ratio(), adjustable='box')
axs['a)'].set_title(r'Smooth Wall Data Only')
plt.show()

# Print fit parameters for SW data only
print(fit_SW_only)

Out[9]:

[0.94942519]

The next cell is the important cell which defines the model and gives the error function for which we minimise. We have two versions of the function non where $\delta^*$ is provided from HWA data and one where we assume the velocity profile based on $\Pi$ .

In [7]:

# Define the downstream and upstream boundaries for fitting
Tap_positons_RW = Model_Data[Vel]['ZPG_RW']['Pressure Taps (m)']
downstream_hw = 9.03
upstream_reference = 9.03 - 1.25 * 3

# Error function assuming given deltastar value
def error_func_assume_deltastar(PI_PG, PI_ZPG, Cf_ZPG, rho, grad, deltastar, y0, d, U99):
    PI_PG = PI_PG[0]  # Extract single value for PI_PG
    X1 = (PI_PG - PI_ZPG)  # Compute difference in PI based on imput value of PI
    Cf = 2 / ((2 / kappa) * (PI_PG - PI_ZPG) + np.sqrt(2 / Cf_ZPG)) ** 2  # Compute friction coefficient
    utau = np.sqrt(Cf / 2) * U99  # Calculate friction velocity

    # Get indexes in the range of interest and compute weighted integral
    indexes_fit = np.where((Tap_positons_RW < downstream_hw) & (Tap_positons_RW > upstream_reference))
    weight = weight_func(Tap_positons_RW)[indexes_fit]
    int_len = (Tap_positons_RW[indexes_fit][-1] - Tap_positons_RW[indexes_fit][0])
    int_dpdx = 1 / int_len * np.trapz(grad[indexes_fit] * weight, Tap_positons_RW[indexes_fit])

    # Calculate Δβ on deltastar and pressure gradient
    delta_beta = (deltastar / (rho * utau ** 2)) * int_dpdx
    X2 = fit_SW_only[0] * delta_beta  # Compute model-predicted value of PI difference

    error = abs(X1 - X2)  # Calculate error between observed and predicted values
    return error

# Error function calculating deltastar from the profile
def error_func_no_profile(PI_PG, PI_ZPG, Cf_ZPG, rho, grad, retau, nu, y0, d, U99):
    PI_PG = PI_PG[0]  # Extract single value for PI_PG
    X1 = (PI_PG - PI_ZPG)  # Compute difference in PI based on imput value of PI
    Cf = 2 / ((2 / kappa) * (PI_PG - PI_ZPG) + np.sqrt(2 / Cf_ZPG)) ** 2  # Compute friction coefficient
    utau = np.sqrt(Cf / 2) * U99  # Calculate friction velocity

    delta = retau * nu / utau  # Calculate boundary layer thickness
    y_start = 3e-3  # Set minimum y-position for integration this is the height of the roughness
    zfit = np.logspace(np.log10(y_start), np.log10(delta), 100)  # Generate logarithmically spaced points

    # Compute velocity profile using log-law and defect law
    profile = ((1 / kappa) * np.log((zfit - d) / y0) + (PI_PG / kappa) * W_func((zfit - d) / (delta - d)))
    # Calculate displacement thickness using trapezoidal integration from estimated profile
    deltastar = np.trapz((1 - (profile / profile[-1])), zfit) + 0.5 * (1 - (profile[0] / profile[-1])) * zfit[0]

    # Get indexes in the range of interest and compute weighted integral
    indexes_fit = np.where((Tap_positons_RW < downstream_hw) & (Tap_positons_RW > upstream_reference))
    weight = weight_func(Tap_positons_RW)[indexes_fit]
    int_len = (Tap_positons_RW[indexes_fit][-1] - Tap_positons_RW[indexes_fit][0])
    int_dpdx = 1 / int_len * np.trapz(grad[indexes_fit] * weight, Tap_positons_RW[indexes_fit])

    # Calculate Δβ on deltastar and pressure gradient
    delta_beta = (deltastar / (rho * utau ** 2)) * int_dpdx
    X2 = fit_SW_only[0] * delta_beta  # Compute model-predicted value of PI difference

    error = abs(X1 - X2)  # Calculate error between observed and predicted values
    return error

# Compute friction velocity (utau) given parameters
def get_utau(PI_PG, PI_ZPG, Cf_ZPG, rho, grad, deltastar, y0, d, U99):
    Cf = 2 / ((2 / kappa) * (PI_PG - PI_ZPG) + np.sqrt(2 / Cf_ZPG)) ** 2  # Calculate friction coefficient
    utau = np.sqrt(Cf / 2) * U99  # Calculate friction velocity
    return utau

# Compute friction velocity (utau) and displacement thickness (deltastar)
def get_utau_find_deltastar(PI_PG, PI_ZPG, Cf_ZPG, rho, grad, retau, nu, y0, d, U99):
    X1 = (PI_PG - PI_ZPG)  # Compute pressure gradient difference
    Cf = 2 / ((2 / kappa) * (PI_PG - PI_ZPG) + np.sqrt(2 / Cf_ZPG)) ** 2  # Calculate friction coefficient
    utau = np.sqrt(Cf / 2) * U99  # Calculate friction velocity

    delta = retau * nu / utau  # Calculate boundary layer thickness
    y_start = 3e-3  # Set minimum y-position for integration
    zfit = np.logspace(np.log10(y_start), np.log10(delta), 100)  # Generate logarithmically spaced points

    # Compute velocity profile using log-law and defect law
    profile = ((1 / kappa) * np.log((zfit - d) / y0) + (PI_PG / kappa) * W_func((zfit - d) / (delta - d)))

    # Calculate displacement thickness using trapezoidal integration
    deltastar = np.trapz((1 - (profile * (utau / U99))), zfit) + 0.5 * (1 - (profile[0] * (utau / U99))) * zfit[0]

    return utau, deltastar

This cell runs the model and plots the results of the skin friction prediction. The user can choose to plot other variables as desired. Both versions with and without provide the $\delta^*$ depending on the function type.

In [8]:

# ZPG Conditions required for the model
Key_ZPG = 'ZPG_RW'  # Key for zero pressure gradient data
PI_ZPG = Model_Data[Vel][Key_ZPG]['PI']  # Pressure gradient index for ZPG
y0_ZPG = Model_Data[Vel][Key_ZPG]['y0']  # Reference distance y0
d_ZPG = Model_Data[Vel][Key_ZPG]['d']    # Reference distance d
Cf_ZPG = Model_Data[Vel][Key_ZPG]['Cf']  # Skin friction coefficient for ZPG

# Create subplots with labels 'a)' and 'b)' using a mosaic layout
fig, axs = plt.subplot_mosaic([['a)', 'b)']])

# Loop through all angles of attack for 500mm RW cases
for j in range(len(AOA_array)):
    Vel = str(20)  # Set velocity to 20
    Key_AOA = str(AOA_array[j]) + '_500mm_RW'  # Key for current AOA data
    
    # Extract relevant data for the current AOA
    rho = Model_Data[Vel][Key_AOA]['rho']  # Density
    nu = Model_Data[Vel][Key_AOA]['nu']    # Kinematic viscosity
    Retau = Model_Data[Vel][Key_AOA]['Re_tau']  # Reynolds number
    grad = Model_Data[Vel][Key_AOA]['ddeltaP/dx']  # Pressure gradient
    U99 = Model_Data[Vel][Key_AOA]['U99']  # Boundary layer edge velocity
    deltastar_HWA = Model_Data[Vel][Key_AOA]['delta*']  # Displacement thickness from HWA

    # Estimate PI using the error function assuming given deltastar
    PI = fmin(error_func_assume_deltastar, 1.5, 
               args=(PI_ZPG, Cf_ZPG, rho, grad, deltastar_HWA, y0_ZPG, d_ZPG, U99),
               xtol=1e-6, ftol=1e-6, maxfun=1e4)  # Optimize PI
               
    utau = get_utau(PI, PI_ZPG, Cf_ZPG, rho, grad, deltastar_HWA, y0_ZPG, d_ZPG, U99)  # Calculate friction velocity
    
    # Plot Cf values in subplot 'a)'
    axs['a)'].plot(Model_Data[Vel][Key_AOA]['Cf'], 
                   2 * (utau / U99) ** 2, 
                   marker=symbol[j], color=colors_SW[j], linestyle='None', 
                   label=str(AOA_array[j]))

    # Estimate PI using the error function considering velocity profile
    PI = fmin(error_func_no_profile, 1.5, 
               args=(PI_ZPG, Cf_ZPG, rho, grad, Retau, nu, y0_ZPG, d_ZPG, U99),
               xtol=1e-6, ftol=1e-6, maxfun=1e4)  # Optimize PI
               
    utau, deltastar = get_utau_find_deltastar(PI, PI_ZPG, Cf_ZPG, rho, grad, Retau, nu, y0_ZPG, d_ZPG, U99)  # Get friction velocity and displacement thickness
    
    # Plot Cf values in subplot 'b)'
    axs['b)'].plot(Model_Data[Vel][Key_AOA]['Cf'], 
                   2 * (utau / U99) ** 2, 
                   marker=symbol[j], color=colors_SW[j], linestyle='None', 
                   label=str(AOA_array[j]))

# Loop through all angles of attack for 400mm RW cases
for j in range(len(AOA_array_400mm_RW)):
    Vel = str(20)  # Set velocity to 20
    Key_AOA = str(AOA_array_400mm_RW[j]) + '_400mm_RW'  # Key for current AOA data
    
    # Extract relevant data for the current AOA
    rho = Model_Data[Vel][Key_AOA]['rho']  # Density
    nu = Model_Data[Vel][Key_AOA]['nu']    # Kinematic viscosity
    Retau = Model_Data[Vel][Key_AOA]['Re_tau']  # Reynolds number
    grad = Model_Data[Vel][Key_AOA]['ddeltaP/dx']  # Pressure gradient
    U99 = Model_Data[Vel][Key_AOA]['U99']  # Boundary layer edge velocity
    deltastar_HWA = Model_Data[Vel][Key_AOA]['delta*']  # Displacement thickness from HWA

    # Estimate PI using the error function assuming given deltastar
    PI = fmin(error_func_assume_deltastar, 2, 
               args=(PI_ZPG, Cf_ZPG, rho, grad, deltastar_HWA, y0_ZPG, d_ZPG, U99),
               xtol=1e-6, ftol=1e-6, maxfun=1e4)  # Optimize PI
               
    utau = get_utau(PI, PI_ZPG, Cf_ZPG, rho, grad, deltastar_HWA, y0_ZPG, d_ZPG, U99)  # Calculate friction velocity
    
    # Plot Cf values in subplot 'a)' with labels for 400mm RW cases
    axs['a)'].plot(Model_Data[Vel][Key_AOA]['Cf'], 
                   2 * (utau / U99) ** 2, 
                   marker=symbol_400mm[j], color=colors_RW_400mm[j], linestyle='None', 
                   label=str(AOA_array_400mm_RW[j]) + r'$^\circ$ 400mm')

    # Estimate PI using the error function considering velocity profile
    PI = fmin(error_func_no_profile, 2, 
               args=(PI_ZPG, Cf_ZPG, rho, grad, Retau, nu, y0_ZPG, d_ZPG, U99),
               xtol=1e-6, ftol=1e-6, maxfun=1e4)  # Optimize PI
               
    utau, deltastar = get_utau_find_deltastar(PI, PI_ZPG, Cf_ZPG, rho, grad, Retau, nu, y0_ZPG, d_ZPG, U99)  # Get friction velocity and displacement thickness
    
    # Plot Cf values in subplot 'b)' with labels for 400mm RW cases
    axs['b)'].plot(Model_Data[Vel][Key_AOA]['Cf'], 
                   2 * (utau / U99) ** 2, 
                   marker=symbol_400mm[j], color=colors_RW_400mm[j], linestyle='None', 
                   label=str(AOA_array_400mm_RW[j]) + r'$^\circ$ 400mm')

# Add a reference dashed line in both subplots
axs['a)'].plot(np.linspace(0.002, 0.009, 5), 
                np.linspace(0.002, 0.009, 5), 'k--')
axs['b)'].plot(np.linspace(0.002, 0.009, 5), 
                np.linspace(0.002, 0.009, 5), 'k--')

# Set labels and titles for both subplots
axs['a)'].set_xlabel(r'$C_f \: Measured$')  # X-axis label for subplot 'a)'
axs['a)'].set_ylabel(r'$C_f \: Predicted$')  # Y-axis label for subplot 'a)'

axs['b)'].set_xlabel(r'$C_f \: Measured$')  # X-axis label for subplot 'b)'
axs['b)'].set_ylabel(r'$C_f \: Predicted$')  # Y-axis label for subplot 'b)'

# Add grid lines and adjust aspect ratio
axs['b)'].grid()
axs['a)'].grid()
axs['b)'].set_aspect(1.0 / axs['b)'].get_data_ratio(), adjustable='box')
axs['a)'].set_aspect(1.0 / axs['a)'].get_data_ratio(), adjustable='box')

# Set subplot titles
axs['a)'].set_title(r'$\delta^*$ from HWA')  # Title for subplot 'a)'
axs['b)'].set_title(r'$\delta^*$ Predicted')  # Title for subplot 'b)'

# Adjust layout and show the plot
plt.tight_layout()
plt.show()

Out[8]:

Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 22
         Function evaluations: 44
Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 22
         Function evaluations: 44
Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 23
         Function evaluations: 46
Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 23
         Function evaluations: 46
Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 24
         Function evaluations: 48
Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 24
         Function evaluations: 48
Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 24
         Function evaluations: 48
Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 24
         Function evaluations: 48
Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 25
         Function evaluations: 50
Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 25
         Function evaluations: 50
Optimization terminated successfully.
         Current function value: 0.179769
         Iterations: 23
         Function evaluations: 46
Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 20
         Function evaluations: 40
Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 18
         Function evaluations: 36
Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 20
         Function evaluations: 40
Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 24
         Function evaluations: 48
Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 24
         Function evaluations: 48

In [0]:

Model for predicting skin friction from effects of pressure gradient histories on skin-friction and mean flow of high Reynolds number turbulent boundary layers over smooth and rough walls

Product

Resources

Company