def shuttleworth_wallace(T_A_K, u, ea, p, Sn_C, Sn_S, L_dn, LAI, h_C, emis_C, emis_S, z_0M, d_0, z_u, z_T, leaf_width=0.1, z0_soil=0.01, x_LAD=1, f_c=1, f_g=1, w_C=1, Rst_min=100, R_ss=500, resistance_form=[0, {}], calcG_params=[[1], 0.35], const_L=None, massman_profile=[0, []], leaf_type=TSEB.res.AMPHISTOMATOUS, kB=0): '''Shuttleworth and Wallace [Shuttleworth1995]_ dual source energy combination model. Calculates turbulent fluxes using meteorological and crop data for a dual source system in series. T_A_K : float Air temperature (Kelvin). u : float Wind speed above the canopy (m s-1). ea : float Water vapour pressure above the canopy (mb). p : float Atmospheric pressure (mb), use 1013 mb by default. Sn_C : float Canopy net shortwave radiation (W m-2). Sn_S : float Soil net shortwave radiation (W m-2). L_dn : float Downwelling longwave radiation (W m-2). LAI : float Effective Leaf Area Index (m2 m-2). h_C : float Canopy height (m). emis_C : float Leaf emissivity. emis_S : flaot Soil emissivity. z_0M : float Aerodynamic surface roughness length for momentum transfer (m). d_0 : float Zero-plane displacement height (m). z_u : float Height of measurement of windspeed (m). z_T : float Height of measurement of air temperature (m). leaf_width : float, optional average/effective leaf width (m). z0_soil : float, optional bare soil aerodynamic roughness length (m). x_LAD : float, optional Campbell 1990 leaf inclination distribution function chi parameter. f_c : float, optional Fractional cover. w_C : float, optional Canopy width to height ratio. Rst_min : float Minimum (unstress) single-leaf stomatal coductance (s m -1), Default = 100 s m-1 Rss : float Resistance to water vapour transport in the soil surface (s m-1), Default = 500 s m-1 (moderately dry soil) resistance_form : int, optional Flag to determine which Resistances R_x, R_S model to use. * 0 [Default] Norman et al 1995 and Kustas et al 1999. * 1 : Choudhury and Monteith 1988. * 2 : McNaughton and Van der Hurk 1995. * 4 : Haghighi and Orr 2015 calcG_params : list[list,float or array], optional Method to calculate soil heat flux,parameters. * [[1],G_ratio]: default, estimate G as a ratio of Rn_S, default Gratio=0.35. * [[0],G_constant] : Use a constant G, usually use 0 to ignore the computation of G. * [[2,Amplitude,phase_shift,shape],time] : estimate G from Santanello and Friedl with G_param list of parameters (see :func:`~TSEB.calc_G_time_diff`). const_L : float or None, optional If included, its value will be used to force the Moning-Obukhov stability length. leaf_type : int 1: Hipostomatous leaves (stomata only in one side of the leaf) 2: Amphistomatous leaves (stomata in both sides of the leaf) Returns ------- flag : int Quality flag, see Appendix for description. T_S : float Soil temperature (Kelvin). T_C : float Canopy temperature (Kelvin). vpd_0 : float Water pressure deficit at the canopy interface (mb). L_nS : float Soil net longwave radiation (W m-2) L_nC : float Canopy net longwave radiation (W m-2) LE : float Latent heat flux (W m-2). H : float Sensible heat flux (W m-2). LE_C : float Canopy latent heat flux (W m-2). H_C : float Canopy sensible heat flux (W m-2). LE_S : float Soil latent heat flux (W m-2). H_S : float Soil sensible heat flux (W m-2). G : float Soil heat flux (W m-2). R_S : float Soil aerodynamic resistance to heat transport (s m-1). R_x : float Bulk canopy aerodynamic resistance to heat transport (s m-1). R_A : float Aerodynamic resistance to heat transport (s m-1). u_friction : float Friction velocity (m s-1). L : float Monin-Obuhkov length (m). n_iterations : int number of iterations until convergence of L. References ---------- .. [Shuttleworth1995] W.J. Shuttleworth, J.S. Wallace, Evaporation from sparse crops - an energy combinatino theory, Quarterly Journal of the Royal Meteorological Society , Volume 111, Issue 469, Pages 839-855, http://dx.doi.org/10.1002/qj.49711146910. ''' # Convert float scalars into numpy arrays and check parameters size T_A_K = np.asarray(T_A_K) [ u, ea, p, Sn_C, Sn_S, L_dn, LAI, emis_C, emis_S, h_C, z_0M, d_0, z_u, z_T, leaf_width, z0_soil, x_LAD, f_c, f_g, w_C, Rst_min, R_ss, calcG_array, leaf_type ] = map(TSEB._check_default_parameter_size, [ u, ea, p, Sn_C, Sn_S, L_dn, LAI, emis_C, emis_S, h_C, z_0M, d_0, z_u, z_T, leaf_width, z0_soil, x_LAD, f_c, f_g, w_C, Rst_min, R_ss, calcG_params[1], leaf_type ], [T_A_K] * 24) res_params = resistance_form[1] resistance_form = resistance_form[0] # Create the output variables [ flag, vpd_0, LE, H, LE_C, H_C, LE_S, H_S, G, R_S, R_x, R_A, Rn, Rn_C, Rn_S, C_s, C_c, PM_C, PM_S, iterations ] = [np.full(T_A_K.shape, np.NaN) for i in range(20)] # Calculate the general parameters rho_a = TSEB.met.calc_rho(p, ea, T_A_K) # Air density Cp = TSEB.met.calc_c_p(p, ea) # Heat capacity of air delta = 10. * TSEB.met.calc_delta_vapor_pressure( T_A_K) # slope of saturation water vapour pressure in mb K-1 lambda_ = TSEB.met.calc_lambda( T_A_K) # latent heat of vaporization MJ kg-1 psicr = TSEB.met.calc_psicr(Cp, p, lambda_) # Psicrometric constant (mb K-1) es = TSEB.met.calc_vapor_pressure( T_A_K) # saturation water vapour pressure in mb rho_cp = rho_a * Cp vpd = es - ea del es, ea F = np.asarray(LAI / f_c) # Real LAI omega0 = TSEB.CI.calc_omega0_Kustas(LAI, f_c, x_LAD=x_LAD, isLAIeff=True) # Calculate bulk stomatal conductance R_c = bulk_stomatal_resistance(LAI * f_g, Rst_min, leaf_type=leaf_type) del leaf_type, Rst_min # Initially assume stable atmospheric conditions and set variables for # iteration of the Monin-Obukhov length if const_L is None: # Initially assume stable atmospheric conditions and set variables for L = np.asarray(np.zeros(T_A_K.shape) + np.inf) max_iterations = ITERATIONS else: # We force Monin-Obukhov lenght to the provided array/value L = np.asarray(np.ones(T_A_K.shape) * const_L) max_iterations = 1 # No iteration u_friction = TSEB.MO.calc_u_star(u, z_u, L, d_0, z_0M) u_friction = np.asarray(np.maximum(TSEB.U_FRICTION_MIN, u_friction)) L_queue = deque([np.array(L)], 6) L_converged = np.asarray(np.zeros(T_A_K.shape)).astype(bool) L_diff_max = np.inf z_0H = TSEB.res.calc_z_0H(z_0M, kB=kB) # Roughness length for heat transport zol = np.zeros(T_A_K.shape) # First assume that temperatures equals the Air Temperature T_C, T_S, T_0 = T_A_K.copy(), T_A_K.copy(), T_A_K.copy() _, _, _, taudl = TSEB.rad.calc_spectra_Cambpell(LAI, np.zeros(emis_C.shape), 1.0 - emis_C, np.zeros(emis_S.shape), 1.0 - emis_S, x_lad=x_LAD, lai_eff=None) emiss = taudl * emis_S + (1 - taudl) * emis_C Ln = emiss * (L_dn - TSEB.met.calc_stephan_boltzmann(T_0)) Ln_C = (1. - taudl) * Ln Ln_S = taudl * Ln # Outer loop for estimating stability. # Stops when difference in consecutives L is below a given threshold start_time = time.time() loop_time = time.time() for n_iterations in range(max_iterations): i = ~L_converged if np.all(L_converged): if L_converged.size == 0: print("Finished iterations with no valid solution") else: print("Finished interations with a max. L diff: " + str(L_diff_max)) break current_time = time.time() loop_duration = current_time - loop_time loop_time = current_time total_duration = loop_time - start_time print( "Iteration: %d, non-converged pixels: %d, max L diff: %f, total time: %f, loop time: %f" % (n_iterations, np.sum(i), L_diff_max, total_duration, loop_duration)) iterations[i] = n_iterations flag[i] = 0 T_C_old = np.zeros(T_C.shape) T_S_old = np.zeros(T_S.shape) for nn_interations in range(max_iterations): # Calculate aerodynamic resistances R_A[i], R_x[i], R_S[i] = TSEB.calc_resistances( resistance_form, { "R_A": { "z_T": z_T[i], "u_friction": u_friction[i], "L": L[i], "d_0": d_0[i], "z_0H": z_0H[i], }, "R_x": { "u_friction": u_friction[i], "h_C": h_C[i], "d_0": d_0[i], "z_0M": z_0M[i], "L": L[i], "LAI": LAI[i], "leaf_width": leaf_width[i], "massman_profile": massman_profile, "res_params": {k: res_params[k][i] for k in res_params.keys()} }, "R_S": { "u_friction": u_friction[i], 'u': u[i], "h_C": h_C[i], "d_0": d_0[i], "z_0M": z_0M[i], "L": L[i], "F": F[i], "omega0": omega0[i], "LAI": LAI[i], "leaf_width": leaf_width[i], "z0_soil": z0_soil[i], "z_u": z_u[i], "deltaT": T_S[i] - T_0[i], "massman_profile": massman_profile, 'rho': rho_a[i], 'c_p': Cp[i], 'f_cover': f_c[i], 'w_C': w_C[i], "res_params": {k: res_params[k][i] for k in res_params.keys()} } }) _, _, _, C_s[i], C_c[i] = calc_effective_resistances_SW( R_A[i], R_x[i], R_S[i], R_c[i], R_ss[i], delta[i], psicr[i]) # Compute net bulk longwave radiation and split between canopy and soil Ln[i] = emiss[i] * (L_dn[i] - TSEB.met.calc_stephan_boltzmann(T_0[i])) Ln_C[i] = (1. - taudl[i]) * Ln[i] Ln_S[i] = taudl[i] * Ln[i] Rn_C[i] = Sn_C[i] + Ln_C[i] Rn_S[i] = Sn_S[i] + Ln_S[i] Rn[i] = Rn_C[i] + Rn_S[i] # Compute Soil Heat Flux Ratio G[i] = TSEB.calc_G([calcG_params[0], calcG_array], Rn_S, i) # Eq. 12 in [Shuttleworth1988]_ PM_C[i] = (delta[i] * (Rn[i] - G[i]) + ( rho_cp[i] * vpd[i] - delta[i] * R_x[i] * (Rn_S[i] - G[i])) / ( R_A[i] + R_x[i])) / \ (delta[i] + psicr[i] * (1. + R_c[i] / (R_A[i] + R_x[i]))) # Avoid arithmetic error with no LAI PM_C[np.isnan(PM_C)] = 0 # Eq. 13 in [Shuttleworth1988]_ PM_S[i] = (delta[i] * (Rn[i] - G[i]) + ( rho_cp[i] * vpd[i] - delta[i] * R_S[i] * Rn_C[i]) / ( R_A[i] + R_S[i])) / \ (delta[i] + psicr[i] * (1. + R_ss[i] / (R_A[i] + R_S[i]))) PM_S[np.isnan(PM_S)] = 0 # Eq. 11 in [Shuttleworth1988]_ LE[i] = C_c[i] * PM_C[i] + C_s[i] * PM_S[i] H[i] = Rn[i] - G[i] - LE[i] # Compute canopy and soil fluxes # Vapor pressure deficit at canopy source height (mb) # Eq. 8 in [Shuttleworth1988]_ vpd_0[i] = vpd[i] + ( delta[i] * (Rn[i] - G[i]) - (delta[i] + psicr[i]) * LE[i]) * \ R_A[i] / (rho_cp[i]) # Eq. 9 in Shuttleworth & Wallace 1985 LE_S[i] = (delta[i] * (Rn_S[i] - G[i]) + rho_cp[i] * vpd_0[i] / R_S[i]) / \ (delta[i] + psicr[i] * (1. + R_ss[i] / R_S[i])) LE_S[np.isnan(LE_S)] = 0 H_S[i] = Rn_S[i] - G[i] - LE_S[i] # Eq. 10 in Shuttleworth & Wallace 1985 LE_C[i] = (delta[i] * Rn_C[i] + rho_cp[i] * vpd_0[i] / R_x[i]) / \ (delta[i] + psicr[i] * (1. + R_c[i] / R_x[i])) H_C[i] = Rn_C[i] - LE_C[i] no_canopy = np.logical_and(i, np.isnan(LE_C)) H_C[no_canopy] = np.nan T_0[i] = calc_T(H[i], T_A_K[i], R_A[i], rho_a[i], Cp[i]) T_C[i] = calc_T(H_C[i], T_0[i], R_x[i], rho_a[i], Cp[i]) T_S[i] = calc_T(H_S[i], T_0[i], R_S[i], rho_a[i], Cp[i]) no_valid_T = np.logical_and.reduce( (i, T_C <= T_A_K - LOWEST_TC_DIFF, T_S <= T_A_K - LOWEST_TS_DIFF)) flag[no_valid_T] = F_LOW_TS_TC T_C[no_valid_T] = T_A_K[no_valid_T] - LOWEST_TC_DIFF T_S[no_valid_T] = T_A_K[no_valid_T] - LOWEST_TS_DIFF no_valid_T = np.logical_and(i, T_C <= T_A_K - LOWEST_TC_DIFF) flag[no_valid_T] = F_LOW_TC T_C[no_valid_T] = T_A_K[no_valid_T] - LOWEST_TC_DIFF no_valid_T = np.logical_and(i, T_S <= T_A_K - LOWEST_TS_DIFF) flag[no_valid_T] = F_LOW_TS T_S[no_valid_T] = T_A_K[no_valid_T] - LOWEST_TS_DIFF if np.all(np.abs(T_C - T_C_old) < T_DIFF_THRES) \ and np.all(np.abs(T_S - T_S_old) < T_DIFF_THRES): break else: T_C_old = T_C.copy() T_S_old = T_S.copy() # Now L can be recalculated and the difference between iterations # derived if const_L is None: L[i] = TSEB.MO.calc_mo_length(u_friction[i], T_A_K[i], rho_a[i], Cp[i], H[i]) zol[i] = z_0M[i] / L[i] stable = np.logical_and(i, zol > STABILITY_THRES) L[stable] = 1e36 # Calculate again the friction velocity with the new stability # correctios u_friction[i] = TSEB.MO.calc_u_star(u[i], z_u[i], L[i], d_0[i], z_0M[i]) u_friction[i] = np.asarray( np.maximum(TSEB.U_FRICTION_MIN, u_friction[i])) # We check convergence against the value of L from previous iteration but as well # against values from 2 or 3 iterations back. This is to catch situations (not # infrequent) where L oscillates between 2 or 3 steady state values. L_new = L.copy() L_new[L_new == 0] = 1e-6 L_queue.appendleft(L_new) L_converged[i] = TSEB._L_diff(L_queue[0][i], L_queue[1][i]) < TSEB.L_thres L_diff_max = np.max(TSEB._L_diff(L_queue[0][i], L_queue[1][i])) if len(L_queue) >= 4: L_converged[i] = np.logical_and( TSEB._L_diff(L_queue[0][i], L_queue[2][i]) < TSEB.L_thres, TSEB._L_diff(L_queue[1][i], L_queue[3][i]) < TSEB.L_thres) if len(L_queue) == 6: L_converged[i] = np.logical_and.reduce( (TSEB._L_diff(L_queue[0][i], L_queue[3][i]) < TSEB.L_thres, TSEB._L_diff(L_queue[1][i], L_queue[4][i]) < TSEB.L_thres, TSEB._L_diff(L_queue[2][i], L_queue[5][i]) < TSEB.L_thres)) (flag, T_S, T_C, vpd_0, L_nS, L_nC, LE_C, H_C, LE_S, H_S, G, R_S, R_x, R_A, u_friction, L, n_iterations) = map(np.asarray, (flag, T_S, T_C, vpd_0, Ln_S, Ln_C, LE_C, H_C, LE_S, H_S, G, R_S, R_x, R_A, u_friction, L, iterations)) return flag, T_S, T_C, vpd_0, Ln_S, Ln_C, LE, H, LE_C, H_C, LE_S, H_S, G, R_S, R_x, R_A, u_friction, L, n_iterations
def penman_monteith(T_A_K, u, ea, p, Sn, L_dn, emis, LAI, z_0M, d_0, z_u, z_T, calcG_params=[[1], 0.35], const_L=None, Rst_min=400, leaf_type=TSEB.res.AMPHISTOMATOUS, f_cd=None, kB=0): '''Penman Monteith [Allen1998]_ energy combination model. Calculates the Penman Monteith one source fluxes using meteorological and crop data. Parameters ---------- T_A_K : float Air temperature (Kelvin). u : float Wind speed above the canopy (m s-1). ea : float Water vapour pressure above the canopy (mb). p : float Atmospheric pressure (mb), use 1013 mb by default. Sn : float Net shortwave radiation (W m-2). L_dn : float Downwelling longwave radiation (W m-2). emis : float Surface emissivity. LAI : float Effective Leaf Area Index (m2 m-2). z_0M : float Aerodynamic surface roughness length for momentum transfer (m). d_0 : float Zero-plane displacement height (m). z_u : float Height of measurement of windspeed (m). z_T : float Height of measurement of air temperature (m). calcG_params : list[list,float or array], optional Method to calculate soil heat flux,parameters. * [[1],G_ratio]: default, estimate G as a ratio of Rn_S, default Gratio=0.35. * [[0],G_constant] : Use a constant G, usually use 0 to ignore the computation of G. * [[2,Amplitude,phase_shift,shape],time] : estimate G from Santanello and Friedl with G_param list of parameters (see :func:`~TSEB.calc_G_time_diff`). const_L : float or None, optional If included, its value will be used to force the Moning-Obukhov stability length. Rst_min : float Minimum (unstress) single-leaf stomatal coductance (s m -1), Default = 400 s m-1 leaf_type : int 1: Hipostomatous leaves (stomata only in one side of the leaf) 2: Amphistomatous leaves (stomata in both sides of the leaf) Returns ------- flag : int Quality flag, see Appendix for description. L_n : float Net longwave radiation (W m-2) LE : float Latent heat flux (W m-2). H : float Sensible heat flux (W m-2). G : float Soil heat flux (W m-2). R_A : float Aerodynamic resistance to heat transport (s m-1). u_friction : float Friction velocity (m s-1). L : float Monin-Obuhkov length (m). n_iterations : int number of iterations until convergence of L. References ---------- .. [Allen1998] R.G. Allen, L.S. Pereira, D. Raes, M. Smith. Crop Evapotranspiration (guidelines for computing crop water requirements), FAO Irrigation and Drainage Paper No. 56. 1998 ''' # Convert float scalars into numpy arrays and check parameters size T_A_K = np.asarray(T_A_K) [ u, ea, p, Sn, L_dn, emis, LAI, z_0M, d_0, z_u, z_T, calcG_array, Rst_min, leaf_type ] = map(TSEB._check_default_parameter_size, [ u, ea, p, Sn, L_dn, emis, LAI, z_0M, d_0, z_u, z_T, calcG_params[1], Rst_min, leaf_type ], [T_A_K] * 14) # Create the output variables [flag, Ln, LE, H, G, R_A, iterations] = [np.zeros(T_A_K.shape) + np.NaN for i in range(7)] # Calculate the general parameters rho_a = TSEB.met.calc_rho(p, ea, T_A_K) # Air density Cp = TSEB.met.calc_c_p(p, ea) # Heat capacity of air delta = 10. * TSEB.met.calc_delta_vapor_pressure( T_A_K) # slope of saturation water vapour pressure in mb K-1 lambda_ = TSEB.met.calc_lambda( T_A_K) # latent heat of vaporization MJ kg-1 psicr = TSEB.met.calc_psicr(Cp, p, lambda_) # Psicrometric constant (mb K-1) es = TSEB.met.calc_vapor_pressure( T_A_K) # saturation water vapour pressure in mb z_0H = TSEB.res.calc_z_0H(z_0M, kB=kB) # Roughness length for heat transport rho_cp = rho_a * Cp vpd = es - ea # Calculate bulk stomatal conductance R_c = bulk_stomatal_resistance(LAI, Rst_min, leaf_type=leaf_type) # iteration of the Monin-Obukhov length if const_L is None: # Initially assume stable atmospheric conditions and set variables for L = np.asarray(np.zeros(T_A_K.shape) + np.inf) max_iterations = ITERATIONS else: # We force Monin-Obukhov lenght to the provided array/value L = np.asarray(np.ones(T_A_K.shape) * const_L) max_iterations = 1 # No iteration u_friction = TSEB.MO.calc_u_star(u, z_u, L, d_0, z_0M) u_friction = np.asarray(np.maximum(TSEB.U_FRICTION_MIN, u_friction)) L_queue = deque([np.array(L)], 6) L_converged = np.asarray(np.zeros(T_A_K.shape)).astype(bool) L_diff_max = np.inf zol = np.zeros(T_A_K.shape) T_0_K = T_A_K.copy() # Outer loop for estimating stability. # Stops when difference in consecutives L is below a given threshold start_time = time.time() loop_time = time.time() for n_iterations in range(max_iterations): i = ~L_converged if np.all(L_converged): if L_converged.size == 0: print("Finished iterations with no valid solution") else: print("Finished interations with a max. L diff: " + str(L_diff_max)) break current_time = time.time() loop_duration = current_time - loop_time loop_time = current_time total_duration = loop_time - start_time print( "Iteration: %d, non-converged pixels: %d, max L diff: %f, total time: %f, loop time: %f" % (n_iterations, np.sum(i), L_diff_max, total_duration, loop_duration)) iterations[i] = n_iterations flag[i] = 0 T_0_old = np.zeros(T_0_K.shape) for nn_interations in range(max_iterations): if f_cd is None: Ln = emis * (L_dn - TSEB.met.calc_stephan_boltzmann(T_0_K)) else: # As the original equation in FAO56 uses net outgoing radiation Ln = -calc_Ln(T_A_K, ea, f_cd=f_cd) Rn = np.asarray(Sn + Ln) # Compute Soil Heat Flux G[i] = TSEB.calc_G([calcG_params[0], calcG_array], Rn, i) # Calculate aerodynamic resistances R_A[i] = TSEB.res.calc_R_A(z_T[i], u_friction[i], L[i], d_0[i], z_0H[i]) # Apply Penman Monteith Combination equation LE[i] = le_penman_monteith(Rn[i], G[[i]], vpd[i], R_A[i], R_c[i], delta[i], rho_a[i], Cp[i], psicr[i]) H[i] = Rn[i] - G[i] - LE[i] # Recomputue aerodynamic temperature T_0_K[i] = calc_T(H[i], T_A_K[i], R_A[i], rho_a[i], Cp[i]) if np.all(np.abs(T_0_K - T_0_old) < T_DIFF_THRES): break else: T_0_old = T_0_K.copy() # Now L can be recalculated and the difference between iterations # derived if const_L is None: L[i] = TSEB.MO.calc_L(u_friction[i], T_A_K[i], rho_a[i], Cp[i], H[i], LE[i]) # Check stability zol[i] = z_0M[i] / L[i] stable = np.logical_and(i, zol > STABILITY_THRES) L[stable] = 1e36 # Calculate again the friction velocity with the new stability # correctios u_friction[i] = TSEB.MO.calc_u_star(u[i], z_u[i], L[i], d_0[i], z_0M[i]) u_friction = np.asarray(np.maximum(TSEB.U_FRICTION_MIN, u_friction)) # We check convergence against the value of L from previous iteration but as well # against values from 2 or 3 iterations back. This is to catch situations (not # infrequent) where L oscillates between 2 or 3 steady state values. L_new = L.copy() L_new[L_new == 0] = 1e-36 L_queue.appendleft(L_new) L_converged[i] = TSEB._L_diff(L_queue[0][i], L_queue[1][i]) < TSEB.L_thres L_diff_max = np.max(TSEB._L_diff(L_queue[0][i], L_queue[1][i])) if len(L_queue) >= 4: L_converged[i] = np.logical_and( TSEB._L_diff(L_queue[0][i], L_queue[2][i]) < TSEB.L_thres, TSEB._L_diff(L_queue[1][i], L_queue[3][i]) < TSEB.L_thres) if len(L_queue) == 6: L_converged[i] = np.logical_and.reduce( (TSEB._L_diff(L_queue[0][i], L_queue[3][i]) < TSEB.L_thres, TSEB._L_diff(L_queue[1][i], L_queue[4][i]) < TSEB.L_thres, TSEB._L_diff(L_queue[2][i], L_queue[5][i]) < TSEB.L_thres)) flag, Ln, LE, H, G, R_A, u_friction, L, n_iterations = map( np.asarray, (flag, Ln, LE, H, G, R_A, u_friction, L, n_iterations)) return flag, Ln, LE, H, G, R_A, u_friction, L, n_iterations
def ESVEP(Tr_K, vza, T_A_K, u, ea, p, Sn_C, Sn_S, L_dn, LAI, emis_C, emis_S, z_0M, d_0, z_u, z_T, z0_soil=0.001, x_LAD=1, f_c=1.0, f_g=1.0, w_C=1.0, calcG_params=[[1], 0.35], UseL=False): '''ESVEP Calculates soil and vegetation energy fluxes using Soil and Vegetation Energy Patrtitioning `ESVEP` model and a single observation of composite radiometric temperature. Parameters ---------- Tr_K : float Radiometric composite temperature (Kelvin). vza : float View Zenith Angle (degrees). T_A_K : float Air temperature (Kelvin). u : float Wind speed above the canopy (m s-1). ea : float Water vapour pressure above the canopy (mb). p : float Atmospheric pressure (mb), use 1013 mb by default. Sn_C : float Canopy net shortwave radiation (W m-2). Sn_S : float Soil net shortwave radiation (W m-2). L_dn : float Downwelling longwave radiation (W m-2). LAI : float Effective Leaf Area Index (m2 m-2). emis_C : float Leaf emissivity. emis_S : flaot Soil emissivity. z_0M : float Aerodynamic surface roughness length for momentum transfer (m). d_0 : float Zero-plane displacement height (m). z_u : float Height of measurement of windspeed (m). z_T : float Height of measurement of air temperature (m). z0_soil : float, optional bare soil aerodynamic roughness length (m). x_LAD : float, optional Campbell 1990 leaf inclination distribution function chi parameter. f_c : float, optional Fractional cover. f_g : float, optional Fraction of vegetation that is green. w_C : float, optional Canopy width to height ratio. calcG_params : list[list,float or array], optional Method to calculate soil heat flux,parameters. * [[1],G_ratio]: default, estimate G as a ratio of Rn_S, default Gratio=0.35. * [[0],G_constant] : Use a constant G, usually use 0 to ignore the computation of G. * [[2,Amplitude,phase_shift,shape],time] : estimate G from Santanello and Friedl with G_param list of parameters (see :func:`~TSEB.calc_G_time_diff`). UseL : float or None, optional If included, its value will be used to force the Moning-Obukhov stability length. Returns ------- flag : int Quality flag, see Appendix for description. T_S : float Soil temperature (Kelvin). T_C : float Canopy temperature (Kelvin). T_sd: float End-member temperature of dry soil (Kelvin) T_vd: float End-member temperature of dry vegetation (Kelvin) T_sw: float End-member temperature of saturated soil (Kelvin) T_vw: float End-member temperature of well-watered vegetation (Kelvin) T_star: float Critical surface temperature (Kelvin) L_nS : float Soil net longwave radiation (W m-2) L_nC : float Canopy net longwave radiation (W m-2) LE_C : float Canopy latent heat flux (W m-2). H_C : float Canopy sensible heat flux (W m-2). LE_S : float Soil latent heat flux (W m-2). H_S : float Soil sensible heat flux (W m-2). G : float Soil heat flux (W m-2). r_vw: float Canopy resistance to heat transport of well-watered vegetation (s m-1) r_vd: float Canopy resistance to heat transport of vegetation with zero soil water avaiability (s m-1) r_av: float Aerodynamic resistance to heat transport of the vegetation (s m-1) r_as: float Aerodynamic resistance to heat transport of the soil (s m-1) L : float Monin-Obuhkov length (m). n_iterations : int number of iterations until convergence of L. References ---------- .. [Tang2017] Tang, R., and Z. L. Li. An End-Member-Based Two-Source Approach for Estimating Land Surface Evapotranspiration From Remote Sensing Data. IEEE Transactions on Geoscience and Remote Sensing 55, no. 10 (October 2017): 5818–32. https://doi.org/10.1109/TGRS.2017.2715361. ''' # Convert input float scalars to arrays and check parameters size Tr_K = np.asarray(Tr_K) (vza, T_A_K, u, ea, p, Sn_C, Sn_S, L_dn, LAI, emis_C, emis_S, z_0M, d_0, z_u, z_T, z0_soil, x_LAD, f_c, f_g, w_C, calcG_array) = map(tseb._check_default_parameter_size, [ vza, T_A_K, u, ea, p, Sn_C, Sn_S, L_dn, LAI, emis_C, emis_S, z_0M, d_0, z_u, z_T, z0_soil, x_LAD, f_c, f_g, w_C, calcG_params[1] ], [Tr_K] * 21) # Create the output variables [flag, T_S, T_C, T_sd, T_vd, T_sw, T_vw, T_star, Rn_C, Rn_S, Ln_S, Ln_C, LE, H, LE_C, H_C, LE_S, H_S, G, r_vw, r_vd, r_av, r_as, iterations] =\ [np.zeros(Tr_K.shape)+np.NaN for i in range(24)] # iteration of the Monin-Obukhov length if isinstance(UseL, bool): # Initially assume stable atmospheric conditions and set variables for L = np.asarray(np.zeros(T_S.shape) + np.inf) max_iterations = ITERATIONS else: # We force Monin-Obukhov lenght to the provided array/value L = np.asarray(np.ones(T_S.shape) * UseL) max_iterations = 1 # No iteration # Calculate the general parameters rho = met.calc_rho(p, ea, T_A_K) # Air density (kg m-3) c_p = met.calc_c_p(p, ea) # Heat capacity of air (J/(kg·K)) z_0H = res.calc_z_0H(z_0M, kB=kB) # Roughness length for heat transport z_0H_soil = res.calc_z_0H(z0_soil, kB=kB) # Roughness length for heat transport s = met.calc_delta_vapor_pressure( T_A_K) # slope of the saturation pressure curve (kPa K-1) lbd = met.calc_lambda(T_A_K) # latent heat of vaporisation (J kg-1) gama = met.calc_psicr(c_p, p, lbd) * 0.1 # psychrometric constant (kPa K-1) vpd = (met.calc_vapor_pressure(T_A_K) - ea) * 0.1 # vapor pressure deficit (kPa) # Calculate LAI dependent parameters for dataset where LAI > 0 omega0 = CI.calc_omega0_Kustas(LAI, f_c, x_LAD=x_LAD, isLAIeff=True) F = np.asarray(LAI / f_c) # Real LAI # Fraction of vegetation observed by the sensor f_theta = tseb.calc_F_theta_campbell(vza, F, w_C=w_C, Omega0=omega0, x_LAD=x_LAD) # Initially assume stable atmospheric conditions and set variables for # iteration of the Monin-Obukhov length u_friction = MO.calc_u_star(u, z_u, L, d_0, z_0M) u_friction = np.asarray(np.maximum(u_friction_min, u_friction)) u_friction_s = MO.calc_u_star(u, z_u, L, np.zeros(d_0.shape), z0_soil) u_friction_s = np.asarray(np.maximum(u_friction_min, u_friction_s)) L_queue = deque([np.array(L)], 6) L_converged = np.asarray(np.zeros(Tr_K.shape)).astype(bool) L_diff_max = np.inf # First assume that canopy temperature equals the minumum of Air or # radiometric T T_C = np.asarray(np.minimum(Tr_K, T_A_K)) flag, T_S = tseb.calc_T_S(Tr_K, T_C, f_theta) # Loop for estimating stability. # Stops when difference in consecutives L is below a given threshold start_time = time.time() loop_time = time.time() for n_iterations in range(max_iterations): i = flag != F_INVALID if np.all(L_converged[i]): if L_converged[i].size == 0: print("Finished iterations with no valid solution") else: print("Finished interations with a max. L diff: " + str(L_diff_max)) break current_time = time.time() loop_duration = current_time - loop_time loop_time = current_time total_duration = loop_time - start_time print( "Iteration: %d, non-converged pixels: %d, max L diff: %f, total time: %f, loop time: %f" % (n_iterations, np.sum(~L_converged[i]), L_diff_max, total_duration, loop_duration)) i = np.logical_and(~L_converged, flag != F_INVALID) iterations[i] = n_iterations # Calculate net longwave radiation with current values of T_C and T_S Ln_C[i], Ln_S[i] = rad.calc_L_n_Kustas(T_C[i], T_S[i], L_dn[i], LAI[i], emis_C[i], emis_S[i]) Rn_C[i] = Sn_C[i] + Ln_C[i] Rn_S[i] = Sn_S[i] + Ln_S[i] # Compute Soil Heat Flux G[i] = tseb.calc_G([calcG_params[0], calcG_array], Rn_S, i) # Calculate aerodynamic resistances r_vw[i] = 100.0 / LAI[i] r_vd[i] = np.zeros(LAI[i].shape) + 2000.0 r_av_params = { "z_T": z_T[i], "u_friction": u_friction[i], "L": L[i], "d_0": d_0[i], "z_0H": z_0H[i] } r_av[i] = tseb.calc_resistances(tseb.KUSTAS_NORMAN_1999, {"R_A": r_av_params})[0] r_as_params = { "z_T": z_T[i], "u_friction": u_friction_s[i], "L": L[i], "d_0": np.zeros(d_0[i].shape), "z_0H": z_0H_soil[i] } r_as[i] = tseb.calc_resistances(tseb.KUSTAS_NORMAN_1999, {"R_A": r_as_params})[0] # Estimate the surface temperatures of the end-members # Eq 8a T_sd[i] = r_as[i] * (Rn_S[i] - G[i]) / (rho[i] * c_p[i]) + T_A_K[i] # Eq 8b T_vd[i] = r_av[i] * Rn_C[i] / (rho[i] * c_p[i]) *\ gama[i] * (1 + r_vd[i] / r_av[i]) / (s[i] + gama[i] * (1 + r_vd[i] / r_av[i])) -\ vpd[i] / (s[i] + gama[i] * (1 + r_vd[i] / r_av[i])) + T_A_K[i] # Eq 8c T_sw[i] = r_as[i] * (Rn_S[i] - G[i]) / (rho[i] * c_p[i]) *\ gama[i] / (s[i] + gama[i]) - vpd[i] / (s[i] + gama[i]) + T_A_K[i] # Eq 8d T_vw[i] = r_av[i] * Rn_C[i] / (rho[i] * c_p[i]) *\ gama[i] * (1 + r_vw[i] / r_av[i]) / (s[i] + gama[i] * (1 + r_vw[i] / r_av[i])) -\ vpd[i] / (s[i] + gama[i] * (1 + r_vw[i] / r_av[i])) + T_A_K[i] # Estimate critical surface temperature - eq 10 T_star[i] = (T_sd[i]**4 * (1 - f_theta[i]) + T_vw[i]**4 * f_theta[i])**0.25 # Estimate latent heat fluxes when water in the top-soil is avaiable for evaporation j = np.logical_and(Tr_K <= T_star, i) # Eq 12a T_C[j] = T_vw[j] # Eq 12b T_S[j] = ((Tr_K[j]**4 - f_theta[j] * T_C[j]**4) / (1 - f_theta[j]))**0.25 # Eq 13a LE_C[j] = (s[j] * Rn_C[j] + rho[j] * c_p[j] * vpd[j] / r_av[j]) /\ (s[j] + gama[j] * (1 + r_vw[j] / r_av[j])) # Eq 13b LE_S[j] = (T_sd[j] - T_S[j]) / (T_sd[j] - T_sw[j]) *\ ((s[j] * (Rn_S[j] - G[j]) + rho[j] * c_p[j] * vpd[j] / r_as[j]) / (s[j] + gama[j])) # Estimate latent heat fluxes when no water in the top-soil is avaiable for evaporation j = np.logical_and(Tr_K > T_star, i) # Eq 14a T_S[j] = T_sd[j] # Eq 14b T_C[j] = ((Tr_K[j]**4 - (1 - f_theta[j]) * T_S[j]**4) / f_theta[j])**0.25 # Eq 15a LE_C[j] = (T_vd[j] - T_C[j]) / (T_vd[j] - T_vw[j]) *\ ((s[j] * Rn_C[j] + rho[j] * c_p[j] * vpd [j] / r_av[j]) / (s[j] + gama[j] * (1 + r_vw[j] / r_av[j]))) # Eq 15b LE_S[j] = 0 # Estimate sensible heat fluxes as residuals H_C[i] = Rn_C[i] - LE_C[i] H_S[i] = Rn_S[i] - G[i] - LE_S[i] # Calculate total fluxes H[i] = np.asarray(H_C[i] + H_S[i]) LE[i] = np.asarray(LE_C[i] + LE_S[i]) # Now L can be recalculated and the difference between iterations # derived if isinstance(UseL, bool): L[i] = MO.calc_L(u_friction[i], T_A_K[i], rho[i], c_p[i], H[i], LE[i]) # Calculate again the friction velocity with the new stability # correctios u_friction[i] = MO.calc_u_star(u[i], z_u[i], L[i], d_0[i], z_0M[i]) u_friction[i] = np.asarray( np.maximum(u_friction_min, u_friction[i])) u_friction_s[i] = MO.calc_u_star(u[i], z_u[i], L[i], np.zeros(d_0[i].shape), z0_soil[i]) u_friction_s[i] = np.asarray( np.maximum(u_friction_min, u_friction_s[i])) # We check convergence against the value of L from previous iteration but as well # against values from 2 or 3 iterations back. This is to catch situations (not # infrequent) where L oscillates between 2 or 3 steady state values. L_new = np.array(L) L_new[L_new == 0] = 1e-36 L_queue.appendleft(L_new) i = np.logical_and(~L_converged, flag != F_INVALID) L_converged[i] = tseb._L_diff(L_queue[0][i], L_queue[1][i]) < L_thres L_diff_max = np.max(tseb._L_diff(L_queue[0][i], L_queue[1][i])) if len(L_queue) >= 4: i = np.logical_and(~L_converged, flag != F_INVALID) L_converged[i] = np.logical_and( tseb._L_diff(L_queue[0][i], L_queue[2][i]) < L_thres, tseb._L_diff(L_queue[1][i], L_queue[3][i]) < L_thres) if len(L_queue) == 6: i = np.logical_and(~L_converged, flag != F_INVALID) L_converged[i] = np.logical_and.reduce( (tseb._L_diff(L_queue[0][i], L_queue[3][i]) < L_thres, tseb._L_diff(L_queue[1][i], L_queue[4][i]) < L_thres, tseb._L_diff(L_queue[2][i], L_queue[5][i]) < L_thres)) return [ flag, T_S, T_C, T_sd, T_vd, T_sw, T_vw, T_star, Ln_S, Ln_C, LE_C, H_C, LE_S, H_S, G, r_vw, r_vd, r_av, r_as, u_friction, L, n_iterations ]