turbx 1.0.2__py3-none-any.whl

turbx/mvp.py

@@ -0,0 +1,385 @@
+import numpy as np
+import scipy as sp
+from scipy.integrate import cumulative_trapezoid
+from scipy.special import exp1
+
+from turbx import gradient
+
+# ======================================================================
+
+def calc_Iww(y,u,ue,utau,j_edge):
+    '''
+    Second moment of the velocity defect
+    Integral of squared velocity defect
+    Defect energy integral
+    Iww = C′ = ∫ (W+)^2 d(y/Δ)
+    Monkewitz Chauhan Nagib (2007) : https://doi.org/10.1063/1.2780196
+    Nagib Chauhan Monkewitz (2007) : https://doi.org/10.1098/rsta.2006.1948
+    '''
+    uplus_defect  = ( ue - u ) / utau ## W+(y)
+    dRC_integral  = cumulative_trapezoid(y=uplus_defect, x=y, initial=0.)
+    dRC           = dRC_integral[j_edge]
+    yovdRC        = y/dRC
+    Iww_integrand = uplus_defect**2 ## (W+)^2
+    Iww_integral  = cumulative_trapezoid(y=Iww_integrand, x=yovdRC, initial=0.)
+    Iww           = Iww_integral[j_edge]
+    return Iww
+
+def comp_transform_TL(y,u,utau,rho,mu,**kwargs):
+    '''
+    Trettel & Larsson (2016)
+    https://doi.org/10.1063/1.4942022
+    '''
+    acc          = kwargs.get('acc',6)
+    edge_stencil = kwargs.get('edge_stencil','full')
+    ddy_rho      = kwargs.get('ddy_rho',None)
+    ddy_mu       = kwargs.get('ddy_mu',None)
+    
+    if ddy_rho is None:
+        ddy_rho = gradient(rho, y, acc=acc, edge_stencil=edge_stencil)
+    if ddy_mu is None:
+        ddy_mu = gradient(mu, y, acc=acc, edge_stencil=edge_stencil)
+    
+    rho_w     = rho[0]
+    mu_w      = mu[0]
+    u_plus    = u / utau
+    tau_wall  = rho_w * utau**2
+    sc_l_in   = mu_w / ( utau * rho_w ) ## δν
+    #y_plus    = y * utau * rho_w / mu_w
+    
+    ## Eq.28
+    bracket   = 1. + ((1./(2.*rho))*ddy_rho*y) - ((1/mu)*ddy_mu*y)
+    integrand = np.sqrt(rho/rho_w) * bracket
+    uTL_plus  = cumulative_trapezoid(y=integrand, x=u_plus, initial=0.) ## U+
+    
+    u_sl = np.sqrt( tau_wall / rho ) ## semilocal friction velocity (NOT transformed U+)
+    y_sl = y * u_sl * rho / mu       ## semilocal coordinate
+    
+    ## Re-dimensionalize first two returned profiles by uτ,δν
+    return uTL_plus*utau, y_sl*sc_l_in, uTL_plus, y_sl
+
+def comp_transform_VD(y,u,rho):
+    '''
+    van Driest velocity transform
+    uVD(y) = ∫ √(ρ/ρ_w) du
+    van Driest (1951)
+    https://doi.org/10.2514/8.1895
+    '''
+    rho_w     = rho[0]
+    integrand = np.sqrt(rho/rho_w)
+    uVD       = cumulative_trapezoid(y=integrand, x=u, initial=0.)
+    return uVD
+
+def comp_transform_VIPL(y,u,rho,mu,a=1.5,b=0.5):
+    '''
+    Volpiani et al. (2020)
+    https://doi.org/10.1103/PhysRevFluids.5.052602
+    '''
+    rho_w = rho[0]
+    mu_w  = mu[0]
+    M     = mu/mu_w
+    R     = rho/rho_w
+    F     = R**b * M**(-a)
+    yVP   = cumulative_trapezoid(y=F, x=y, initial=0.)
+    G     = R**b * M**(1-a)
+    uVP   = cumulative_trapezoid(y=G, x=u, initial=0.)
+    return uVP,yVP
+
+def comp_transform_GFM(y,uFv,rho,mu,r_uII_vII,utau,ddy_uFv=None,acc=6,edge_stencil='full'):
+    '''
+    Griffin, Fu & Moin (2021)
+    https://doi.org/10.1073/pnas.2111144118
+    '''
+    if ddy_uFv is None:
+        ddy_uFv = gradient(uFv, y, acc=acc, edge_stencil=edge_stencil)
+    
+    ny       = y.shape[0]
+    rho_w    = rho[0]
+    mu_w     = mu[0]
+    tau_wall = utau**2 * rho_w
+    sc_l_in  = mu_w / ( utau * rho_w ) ## δν
+    y_plus   = y * utau * rho_w / mu_w
+    uFv_plus = uFv / utau
+    mu_plus  = mu  / mu_w
+    
+    tau_visc_plus = mu * ddy_uFv / tau_wall    ## τv+
+    tau_R_plus    = -1. * r_uII_vII / tau_wall ## τR+
+    tau_plus      = tau_visc_plus + tau_R_plus ## τ+
+    
+    u_sl = np.sqrt( tau_wall / rho ) ## u_{sl} : semilocal friction velocity
+    #sc_l_sl = mu / ( u_sl * rho )    ## ℓ_{sl} : semilocal length scale
+    y_star  = y * u_sl * rho / mu    ## y* = y_{sl} = y/ℓ_{sl} : semilocal coordinate
+    
+    duFvplus_dyplus = gradient(uFv_plus, y_plus, acc=acc, edge_stencil=edge_stencil)
+    duFvplus_dystar = gradient(uFv_plus, y_star, acc=acc, edge_stencil=edge_stencil)
+    
+    #duFvplus_dyplus = ddy_uFv / (utau / sc_l_in) ## ∂[uFv+]/∂y+ -- OK, sc_l_in is a constant over [y]
+    #duFvplus_dystar = ddy_uFv / (utau / sc_l_sl) ## ∂[uFv+]/∂y* -- WRONG, sc_l_sl is NOT constant over [y]
+    
+    # np.testing.assert_allclose(
+    #     duFvplus_dyplus,
+    #     gradient(uFv_plus, y_plus, acc=acc, edge_stencil=edge_stencil),
+    #     rtol=1e-6,
+    #     atol=1e-12,
+    #     )
+    
+    # np.testing.assert_allclose(
+    #     duFvplus_dystar,
+    #     gradient(uFv_plus, y_star, acc=acc, edge_stencil=edge_stencil),
+    #     rtol=1e-6,
+    #     atol=1e-12,
+    #     )
+    
+    S_eq_plus = (1./mu_plus) * duFvplus_dystar ## Eq.1
+    S_TL_plus = mu_plus * duFvplus_dyplus      ## Eq.2
+    
+    ## Eq.4 St+ = [τ+·Seq+] / [ τ+ + Seq+ - STL+ ]
+    A = tau_plus * S_eq_plus
+    B = tau_plus + S_eq_plus - S_TL_plus
+    B = np.where(np.abs(B) < 1e-12, 1e-12, B)
+    S_t_plus = A / B
+    
+    # ## Eq.5
+    # A = S_eq_plus
+    # B = 1. + S_eq_plus - S_TL_plus
+    # B = np.where(np.abs(B) < 1e-12, 1e-12, B)
+    # S_t_plus = A / B
+    
+    ## Eq.3 Assertion
+    if False:
+        ratio_v = np.full((ny,),0.,dtype=np.float64)
+        ratio_R = np.full((ny,),0.,dtype=np.float64)
+        np.divide(tau_visc_plus, S_TL_plus, out=ratio_v, where=np.abs(S_TL_plus) > 1e-12)
+        np.divide(tau_R_plus,    S_eq_plus, out=ratio_R, where=np.abs(S_eq_plus) > 1e-12)
+        tau_plus_chk = S_t_plus * (ratio_v + ratio_R)
+        mask = ( (np.abs(S_TL_plus) > 1e-12) & (np.abs(S_eq_plus) > 1e-12) )
+        np.testing.assert_allclose(
+            tau_plus[mask],
+            tau_plus_chk[mask],
+            rtol=1e-6,
+            )
+    
+    ## Ut+[y*] = ∫St+ dy*
+    uGFM_plus = cumulative_trapezoid(y=S_t_plus, x=y_star, initial=0.)
+    
+    ## Re-dimensionalize first two returned profiles by uτ,δν
+    return uGFM_plus*utau, y_star*sc_l_in, uGFM_plus, y_star
+
+# ======================================================================
+
+def asymptotic_Wplus_eta(eta, y_plus, Re_theta):
+    '''
+    Monkewitz et al. (2007)
+    Full-boundary-layer wake function
+    -----
+    This function generates a Re-dependent full-layer W+
+      (not just W+_outer) using the U+ composite profile
+    '''
+    kappa = 0.384
+    Cstar = 3.354
+    
+    ## Shape factor
+    H12 = asymptotic_H12_Retheta(Re_theta)
+    
+    ## Coles-Fernholz
+    ue_plus = (1./kappa)*np.log(H12*Re_theta) + Cstar
+    
+    ## Composite velocity
+    uplus_composite = asymptotic_uplus_composite(y_plus, eta, Re_theta)
+    
+    ## Wake (velocity defect)
+    return ue_plus - uplus_composite
+
+def asymptotic_uplus_inner(y_plus):
+    '''
+    Monkewitz et al. (2007)
+    Inner mean velocity U^+_{inner}(y^+)
+    Obtained by integrating the Padé indicator function
+    Eqs. (5)-(7)
+    '''
+    y_plus = np.asarray(y_plus)
+    
+    k = 0.384
+    
+    ## Padé P23 coefficients (Eq. 5)
+    b0 = 1.000e-2 / k
+    b1 = 1.100e-2
+    b2 = 1.100e-4
+    
+    P23 = b0 * (1. + b1*y_plus + b2*y_plus**2) / (
+          1. + b1*y_plus + b2*y_plus**2 + k*b0*b2*y_plus**3
+          )
+    
+    ## Padé P25 coefficients (Eq. 6)
+    h1 = -1.000e-2
+    h2 =  6.000e-3
+    h3 =  9.977e-4
+    h4 =  2.200e-5
+    h5 =  1.000e-6
+    
+    P25 = (1. - b0) * (1. + h1*y_plus + h2*y_plus**2) / (
+          1. + h1*y_plus + h2*y_plus**2 + h3*y_plus**3 + h4*y_plus**4 + h5*y_plus**5
+          )
+    
+    d_uplus_d_yplus = P23 + P25 ## d[u+]/dy+
+    
+    ## scipy.integrate.quad() could be used for continuous integration
+    
+    ## discrete trapezoidal integration
+    uplus_inner = cumulative_trapezoid(y=d_uplus_d_yplus, x=y_plus, initial=0.)
+    return uplus_inner
+
+def asymptotic_uplus_composite(y_plus, eta, Re_theta):
+    '''
+    Monkewitz et al. (2007)
+    Composite mean velocity U^+(y^+,η)
+    Eq. (15), with U_e^+ from H12(Re_θ)
+    '''
+    y_plus = np.asarray(y_plus)
+    eta    = np.asarray(eta)
+    n      = y_plus.shape[0]
+    
+    kappa  = 0.384
+    B      = 4.17   ## log-law intercept
+    Cstar  = 3.354  ## C* (Monkewitz / Nagib)
+    
+    ## Inner velocity (Padé-based)
+    uplus_inner = asymptotic_uplus_inner(y_plus)
+    
+    ## Shape factor and edge velocity
+    H12       = asymptotic_H12_Retheta(Re_theta)
+    ue_plus = (1.0/kappa)*np.log(H12*Re_theta) + Cstar
+    
+    ## Outer velocity
+    Wplus_outer = asymptotic_Wplus_eta_outer(eta)
+    uplus_outer = ue_plus - Wplus_outer
+    
+    ## Overlap (log law)
+    uplus_log     = np.full((n,),0.,dtype=np.float64)
+    uplus_log[1:] = (1.0/kappa)*np.log(y_plus[1:]) + B
+    uplus_log[0]  = B
+    
+    ## Additive composite
+    uplus_composite = uplus_inner + uplus_outer - uplus_log
+    uplus_composite[0] = 0.
+    
+    return uplus_composite
+
+def asymptotic_Wplus_eta_outer(eta):
+    '''
+    Monkewitz et al. (2007)
+    https://doi.org/10.1063/1.2780196
+    Eq.9
+    '''
+    ny  = eta.shape[0]
+    k   = 0.384 ## κ
+    w0  = 0.6332
+    wn1 = -0.096 ## w_{-1}
+    w2  = 28.5
+    w8  = 33000.
+    
+    Wplus_outer = np.full((ny,),np.nan,dtype=np.float64)
+    
+    ii = np.where(eta>0)[0]
+    η = eta[ii]
+    
+    ## W_+ = ((1/κ) E1(η) + w0) * 0.5 * [1 - tanh(w_{-1}/η + w2 η^2 + w8 η^8)]
+    Wplus_outer[ii] = ( (1./k)*exp1(eta[ii]) + w0 ) \
+                      * 0.5 \
+                      * ( 1. - np.tanh( (wn1/η) + w2*η**2 + w8*η**8 ) )
+    
+    return Wplus_outer
+
+def asymptotic_H12_Retheta(Re_theta):
+    '''
+    H12 = δ1/δ2 = δ*/θ
+    Reθ = θ·Ue·ρe/μe
+    -----
+    Monkewitz et al. (2007)
+    https://doi.org/10.1063/1.2780196
+    Nagib et al. (2007)
+    https://doi.org/10.1098/rsta.2006.1948
+    '''
+    
+    ## Asymptotic constants
+    Cs  = 3.354 ## C*
+    k   = 0.384 ## κ
+    Iww = 7.135 ## Iww (Monkewitz) | C′ (Nagib)
+    
+    if isinstance(Re_theta,(int,np.int32,np.int64,float,np.float32,np.float64)):
+        Re_theta = np.array([Re_theta,],np.float64)
+    elif isinstance(Re_theta, np.ndarray):
+        pass
+    else:
+        raise ValueError
+    
+    def __f_root_nonlin_H12(H12,Re_theta):
+        ue_plus = (1/k)*np.log(H12*Re_theta) + Cs ## Coles-Fernholz
+        H12_test = 1. / ( 1. - (Iww/ue_plus) )
+        root = H12_test - H12
+        return root
+    
+    def __f_H12_Retheta(Re_theta):
+        n = Re_theta.shape[0]
+        H12_out = np.zeros((n,),dtype=np.float64)
+        for i in range(n):
+            sol = sp.optimize.least_squares(
+                                    fun=__f_root_nonlin_H12,
+                                    args=(Re_theta[i],),
+                                    x0=1.35,
+                                    xtol=1e-15,
+                                    ftol=1e-15,
+                                    gtol=1e-15,
+                                    method='dogbox',
+                                    bounds=(1,2),
+                                    )
+            if not sol.success:
+                raise ValueError
+            H12_out[i] = float(sol.x[0])
+        return H12_out
+    
+    H12 = __f_H12_Retheta(Re_theta)
+    
+    if H12.shape[0]==1:
+        H12 = float(H12)
+    
+    return H12
+
+def asymptotic_H32_Retheta(Re_theta,I3):
+    '''
+    H32 = δ3/δ2
+    Reθ = θ·Ue·ρe/μe
+    '''
+    
+    ## Asymptotic constants (same as H12 function)
+    Cs  = 3.354 ## C*
+    k   = 0.384 ## κ
+    Iww = 7.135 ## Iww (Monkewitz) | C′ (Nagib)
+    I2  = Iww
+    
+    if isinstance(Re_theta,(int,np.int32,np.int64,float,np.float32,np.float64)):
+        Re_theta = np.array([Re_theta,],np.float64)
+    elif isinstance(Re_theta, np.ndarray):
+        pass
+    elif isinstance(Re_theta, list):
+        Re_theta = np.array(Re_theta,np.float64)
+    else:
+        raise ValueError
+    
+    ## H12(Reθ)
+    H12 = asymptotic_H12_Retheta(Re_theta)
+    
+    if isinstance(H12,float):
+        H12 = np.array([H12,],np.float64)
+    
+    n = Re_theta.shape[0]
+    H32 = np.zeros((n,),dtype=np.float64)
+    
+    for i in range(n):
+        ue_plus = (1/k)*np.log(H12[i]*Re_theta[i]) + Cs ## Coles–Fernholz
+        H32[i] = (2. - 3.*(I2/ue_plus) + I3/(ue_plus**2)) / (1. - (I2/ue_plus))
+    
+    if H32.shape[0]==1:
+        H32 = float(H32)
+    
+    return H32