From 6465387deb4345f6bdd5c3d8e045443aad5671b4 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Mon, 19 Mar 2018 16:31:45 -0700 Subject: [PATCH 001/136] playing with buoyancy sorting --- EDMF_Environment.pyx | 2 +- Turbulence_PrognosticTKE.pyx | 16 +++-- turbulence_functions.pxd | 9 ++- turbulence_functions.pyx | 114 +++++++++++++++++++++++------------ 4 files changed, 92 insertions(+), 49 deletions(-) diff --git a/EDMF_Environment.pyx b/EDMF_Environment.pyx index 5644b9b1..0cc63a9d 100644 --- a/EDMF_Environment.pyx +++ b/EDMF_Environment.pyx @@ -12,7 +12,7 @@ from ReferenceState cimport ReferenceState from Variables cimport VariableDiagnostic, GridMeanVariables from libc.math cimport fmax, fmin, sqrt, exp from thermodynamic_functions cimport * - +import pylab as plt cdef class EnvironmentVariable: def __init__(self, nz, loc, kind, name, units): self.values = np.zeros((nz,),dtype=np.double, order='c') diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 61e2f884..f10fefa3 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -21,7 +21,7 @@ from turbulence_functions cimport * from utility_functions cimport * from libc.math cimport fmax, sqrt, exp, pow, cbrt, fmin from cpython.mem cimport PyMem_Malloc, PyMem_Realloc, PyMem_Free - +import pylab as plt cdef class EDMF_PrognosticTKE(ParameterizationBase): # Initialize the class @@ -622,7 +622,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): input.zi = self.UpdVar.cloud_base[i] for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): input.b = self.UpdVar.B.values[i,k] + input.b_mean = GMV.B.values[k] input.w = interp2pt(self.UpdVar.W.values[i,k],self.UpdVar.W.values[i,k-1]) + input.dw = (self.UpdVar.W.values[i,k]-self.UpdVar.W.values[i,k-1])/self.Gr.dz input.z = self.Gr.z_half[k] input.af = self.UpdVar.Area.values[i,k] input.tke = self.EnvVar.TKE.values[k] @@ -630,15 +632,16 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): input.qt_env = self.EnvVar.QT.values[k] input.ql_env = self.EnvVar.QL.values[k] input.H_env = self.EnvVar.H.values[k] - input.b_env = self.EnvVar.B.values[k] - input.w_env = self.EnvVar.W.values[k] + input.w_env = interp2pt(self.EnvVar.W.values[k],self.EnvVar.W.values[k-1]) + input.dw_env = (self.EnvVar.W.values[k]-self.EnvVar.W.values[k-1])/self.Gr.dz input.H_up = self.UpdVar.H.values[i,k] input.qt_up = self.UpdVar.QT.values[i,k] input.ql_up = self.UpdVar.QL.values[i,k] input.p0 = self.Ref.p0_half[k] input.alpha0 = self.Ref.alpha0_half[k] input.tke_ed_coeff = self.tke_ed_coeff - input.T_mean = (self.EnvVar.T.values[k]+self.UpdVar.T.values[i,k])/2 + input.T_env = self.EnvVar.T.values[k] + input.T_up = self.UpdVar.T.values[i,k] input.L = 20000.0 # need to define the scale of the GCM grid resolution ret = self.entr_detr_fp(input) self.entr_sc[i,k] = ret.entr_sc * self.entrainment_factor @@ -1234,8 +1237,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # alpha = alpha_c(self.Ref.p0_half[k], GMV.T.values[k], GMV.QT.values[k], qv) # GMV.B.values[k] = buoyancy_c(self.Ref.alpha0_half[k], alpha) - GMV.B.values[k] = (self.UpdVar.Area.bulkvalues[k] * self.UpdVar.B.bulkvalues[k] - + (1.0 - self.UpdVar.Area.bulkvalues[k]) * self.EnvVar.B.values[k]) + + #GMV.B.values[k] = (self.UpdVar.Area.bulkvalues[k] * self.UpdVar.B.bulkvalues[k] + # + (1.0 - self.UpdVar.Area.bulkvalues[k]) * self.EnvVar.B.values[k]) return diff --git a/turbulence_functions.pxd b/turbulence_functions.pxd index 41362b17..837568f0 100644 --- a/turbulence_functions.pxd +++ b/turbulence_functions.pxd @@ -13,21 +13,26 @@ cdef struct entr_in_struct: double wstar double z double w + double dw double b + double dt + double b_mean double af double tke double ml double T_mean double p0 double alpha0 + double T_up double qt_up double ql_up + double T_env double qt_env double ql_env double H_up double H_env - double b_env double w_env + double dw_env double L double tke_ed_coeff @@ -36,7 +41,7 @@ cdef entr_struct entr_detr_inverse_z(entr_in_struct entr_in) nogil cdef entr_struct entr_detr_inverse_w(entr_in_struct entr_in) nogil cdef entr_struct entr_detr_b_w2(entr_in_struct entr_in) nogil cdef entr_struct entr_detr_buoyancy_sorting(entr_in_struct entr_in) nogil -cdef evap_struct evap_sat_adjust(double p0, double thetal_, double qt_mix, double T_1, double qs_1, double ql_mix) nogil +cdef evap_struct evap_sat_adjust(double p0, double thetal_, double qt_mix) nogil cdef double get_wstar(double bflux, double zi ) diff --git a/turbulence_functions.pyx b/turbulence_functions.pyx index d5a5b499..7a23a38e 100644 --- a/turbulence_functions.pyx +++ b/turbulence_functions.pyx @@ -40,32 +40,59 @@ cdef entr_struct entr_detr_inverse_w(entr_in_struct entr_in) nogil: cdef entr_struct entr_detr_buoyancy_sorting(entr_in_struct entr_in) nogil: cdef: entr_struct _ret - double cp_d, Lv + double wdw_mix, wdw_env + w_mix = (entr_in.w+entr_in.w_env)/2 + dw_mix = (entr_in.dw+entr_in.dw_env)/2 + T_mean = (entr_in.T_up+entr_in.T_env)/2 qt_mix = (entr_in.qt_up+entr_in.qt_env)/2 ql_mix = (entr_in.ql_up+entr_in.ql_env)/2 qv_mix = qt_mix-ql_mix - thetal_ = t_to_thetali_c(entr_in.p0, entr_in.T_mean, qt_mix, ql_mix, 0.0) - qs_1 =qv_star_t(entr_in.p0, entr_in.T_mean) - evap = evap_sat_adjust(entr_in.p0, thetal_, qt_mix, entr_in.T_mean, qs_1, ql_mix) - - qv_2 = qt_mix-evap.ql - alpha_mix = alpha_c(entr_in.p0, evap.T, qt_mix, qv_2) - bmix = buoyancy_c(entr_in.alpha0, alpha_mix) - eps_w = 1.0/(500.0 * fmax(fabs(entr_in.w),0.1)) # inverse w + alpha_env = alpha_c(entr_in.p0, entr_in.T_env, entr_in.qt_env, entr_in.qt_env-entr_in.ql_env) + b_env = buoyancy_c(entr_in.alpha0, alpha_env) - entr_in.b_mean + alpha_up = alpha_c(entr_in.p0, entr_in.T_up, entr_in.qt_up, entr_in.qt_up-entr_in.ql_up) + b_up = buoyancy_c(entr_in.alpha0, alpha_up) - entr_in.b_mean + thetal_ = t_to_thetali_c(entr_in.p0, T_mean, qt_mix, ql_mix, 0.0) + evap = evap_sat_adjust(entr_in.p0, thetal_, qt_mix) + qv_mix = qt_mix-evap.ql + Tmix = evap.T + alpha_mix = alpha_c(entr_in.p0, Tmix, qt_mix, qv_mix) + bmix = buoyancy_c(entr_in.alpha0, alpha_mix) - entr_in.b_mean + #eps_w = 1.0/(500.0 * fmax(fabs(entr_in.w),0.1)) # inverse w + #eps_w = fabs(entr_in.b/fmax(w_mix * w_mix, 1e-2)) + eps_w = 0.12 * fmax(entr_in.b,0.0) / fmax(entr_in.w * entr_in.w, 1e-1) + wdw_mix = w_mix*dw_mix + wdw_env = entr_in.w_env*entr_in.dw_env if entr_in.af>0.0: - if bmix >= 0.0: - _ret.entr_sc = eps_w - _ret.detr_sc = 0.0 - else: - _ret.entr_sc = 0.0 - _ret.detr_sc = eps_w + #if entr_in.w - entr_in.dt*(bmix-entr_in.b_mean + wdw_mix) > 0.0: + _ret.entr_sc = fmax((1.0-((b_up-bmix)/(b_up+bmix))**2),0.0)*eps_w + _ret.detr_sc = fmax((1.0-((b_env-bmix)/(b_env+bmix))**2),0.0)*eps_w + with gil: + print 'net', _ret.entr_sc- _ret.detr_sc else: _ret.entr_sc = 0.0 _ret.detr_sc = 0.0 return _ret + # if entr_in.af>0.0: + # #if entr_in.w - entr_in.dt*(bmix-entr_in.b_mean + wdw_mix) > 0.0: + # if bmix> b_env: + # with gil: + # print entr_in.b + # _ret.entr_sc = eps_w + # _ret.detr_sc = 0.0 + # else: + # _ret.entr_sc = eps_w + # _ret.detr_sc = fmax(entr_in.b,0.0) / fmax(entr_in.w * entr_in.w, 1e-1) + # with gil: + # print 'entrainment', _ret.entr_sc, 'detrainment', _ret.detr_sc + # + # else: + # _ret.entr_sc = 0.0 + # _ret.detr_sc = 0.0 + # return _ret + cdef entr_struct entr_detr_tke2(entr_in_struct entr_in) nogil: cdef entr_struct _ret @@ -114,46 +141,53 @@ cdef entr_struct entr_detr_b_w2(entr_in_struct entr_in) nogil: return _ret -cdef evap_struct evap_sat_adjust(double p0, double thetal_, double qt_mix, double T_1, double qs_1, double ql_mix) nogil: +cdef evap_struct evap_sat_adjust(double p0, double thetal_, double qt_mix) nogil: cdef: evap_struct evap - double ql_1, T_2, ql_2, f_1, f_2, cp, Lv + double ql_1, T_2, ql_2, f_1, f_2, qv_mix, T_1 - evap.T = T_1 - evap.ql = ql_mix - cp = cpm_c(qt_mix) - Lv = latent_heat(T_1) + qv_mix = qt_mix + ql = 0.0 + + pv_1 = pv_c(p0,qt_mix,qt_mix) + pd_1 = p0 - pv_1 # evaporate and cool - T_1 = T_1 + ql_mix * Lv / cp - - if qt_mix >= qs_1: # is the mixture is saturated - run saturation adjust - ql_1 = qt_mix - qs_1 - f_1 = thetal_ - t_to_thetali_c(p0, T_1, qt_mix, ql_1, 0.0) - cp = cpm_c(qt_mix) - Lv = latent_heat(T_1) - T_2 = T_1 + Lv* ql_1 / cp - pv_star_2 = pv_star(T_2) - qs_2 = qv_star_c(p0, qt_mix, pv_star_2) - ql_2 = qt_mix - qs_2 - - while fabs(T_2 - T_1) >= 1e-9: + T_1 = eos_first_guess_thetal(thetal_, pd_1, pv_1, qt_mix) + pv_star_1 = pv_star(T_1) + qv_star_1 = qv_star_c(p0,qt_mix,pv_star_1) + + if(qt_mix <= qv_star_1): + evap.T = T_1 + evap.ql = 0.0 + + else: + ql_1 = qt_mix - qv_star_1 + prog_1 = t_to_thetali_c(p0, T_1, qt_mix, ql_1, 0.0) + f_1 = thetal_ - prog_1 + T_2 = T_1 + ql_1 * latent_heat(T_1) /((1.0 - qt_mix)*cpd + qv_star_1 * cpv) + delta_T = fabs(T_2 - T_1) + + while delta_T > 1.0e-3 or ql_2 < 0.0: pv_star_2 = pv_star(T_2) - qs_2 = qv_star_c(p0, qt_mix, pv_star_2) - ql_2 = qt_mix - qs_2 - f_2 = thetal_ - t_to_thetali_c(p0, T_2, qt_mix, ql_1, 0.0) - T_n = T_2 - f_2 * (T_2 - T_1)/(f_2 - f_1) + qv_star_2 = qv_star_c(p0,qt_mix,pv_star_2) + pv_2 = pv_c(p0, qt_mix, qv_star_2) + pd_2 = p0 - pv_2 + ql_2 = qt_mix - qv_star_2 + prog_2 = t_to_thetali_c(p0,T_2,qt_mix, ql_2, 0.0) + f_2 = thetal_ - prog_2 + T_n = T_2 - f_2*(T_2 - T_1)/(f_2 - f_1) T_1 = T_2 T_2 = T_n f_1 = f_2 + delta_T = fabs(T_2 - T_1) evap.T = T_2 - qv = qs_2 + qv = qv_star_2 evap.ql = ql_2 return evap - # convective velocity scale cdef double get_wstar(double bflux, double zi ): return cbrt(fmax(bflux * zi, 0.0)) From c0b82db24451d7ab7277d6c11ec1023635565472 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Thu, 22 Mar 2018 12:01:26 -0700 Subject: [PATCH 002/136] testing entrainment --- turbulence_functions.pyx | 63 +++++++++++++++++++++++++++++++--------- 1 file changed, 49 insertions(+), 14 deletions(-) diff --git a/turbulence_functions.pyx b/turbulence_functions.pyx index 7a23a38e..724b1cf9 100644 --- a/turbulence_functions.pyx +++ b/turbulence_functions.pyx @@ -1,6 +1,6 @@ import numpy as np cimport numpy as np -from libc.math cimport cbrt, sqrt, log, fabs,atan, exp, fmax, pow, fmin +from libc.math cimport cbrt, sqrt, log, fabs,atan, exp, fmax, pow, fmin, tanh from cpython.mem cimport PyMem_Malloc, PyMem_Realloc, PyMem_Free include "parameters.pxi" from thermodynamic_functions cimport * @@ -48,28 +48,62 @@ cdef entr_struct entr_detr_buoyancy_sorting(entr_in_struct entr_in) nogil: qt_mix = (entr_in.qt_up+entr_in.qt_env)/2 ql_mix = (entr_in.ql_up+entr_in.ql_env)/2 qv_mix = qt_mix-ql_mix + thetal_ = t_to_thetali_c(entr_in.p0, T_mean, qt_mix, ql_mix, 0.0) + #if entr_in.z >= entr_in.zi: + if ql_mix > 0.0: + evap = evap_sat_adjust(entr_in.p0, thetal_, qt_mix) + qv_mix = qt_mix-evap.ql + Tmix = evap.T + alpha_mix = alpha_c(entr_in.p0, Tmix, qt_mix, qv_mix) + bmix = buoyancy_c(entr_in.alpha0, alpha_mix) - entr_in.b_mean + else: + alpha_mix = alpha_c(entr_in.p0, T_mean, qt_mix, qv_mix) + bmix = buoyancy_c(entr_in.alpha0, alpha_mix) - entr_in.b_mean + alpha_env = alpha_c(entr_in.p0, entr_in.T_env, entr_in.qt_env, entr_in.qt_env-entr_in.ql_env) - b_env = buoyancy_c(entr_in.alpha0, alpha_env) - entr_in.b_mean alpha_up = alpha_c(entr_in.p0, entr_in.T_up, entr_in.qt_up, entr_in.qt_up-entr_in.ql_up) + b_env = buoyancy_c(entr_in.alpha0, alpha_env) - entr_in.b_mean b_up = buoyancy_c(entr_in.alpha0, alpha_up) - entr_in.b_mean - thetal_ = t_to_thetali_c(entr_in.p0, T_mean, qt_mix, ql_mix, 0.0) - evap = evap_sat_adjust(entr_in.p0, thetal_, qt_mix) - qv_mix = qt_mix-evap.ql - Tmix = evap.T - alpha_mix = alpha_c(entr_in.p0, Tmix, qt_mix, qv_mix) - bmix = buoyancy_c(entr_in.alpha0, alpha_mix) - entr_in.b_mean + wdw_mix = w_mix*dw_mix + + if bmix+wdw_mix>0.0: + buoyancy_ratio = (bmix+wdw_mix-b_env)/(bmix+wdw_mix) + with gil: + print buoyancy_ratio + + else: + buoyancy_ratio = 0.0 + #eps_w = 1.0/(500.0 * fmax(fabs(entr_in.w),0.1)) # inverse w #eps_w = fabs(entr_in.b/fmax(w_mix * w_mix, 1e-2)) - eps_w = 0.12 * fmax(entr_in.b,0.0) / fmax(entr_in.w * entr_in.w, 1e-1) - wdw_mix = w_mix*dw_mix + eps_w = (0.1 * fabs(bmix+wdw_mix) / fmax(w_mix * w_mix, 1e-2)) + wdw_env = entr_in.w_env*entr_in.dw_env + wdw_up = entr_in.w*entr_in.dw + # first attempt + # if bmix>b_env: + # partiation_func = 1.0 + # else: + # partiation_func = fmin(pow((b_up-b_env),2.0)/fmax( pow((b_up-bmix),2.0) + (b_up-bmix)*(b_env-bmix),0.00001),1.0) + # second attempt + # b1 = (b_up + b_env)/2 + # + # + # if b1>b_env: + # partiation_func = 1.0 + # else: + # partiation_func = fmin(pow((b_up-b_env),2.0)/fmax( pow((b_up-bmix),2.0) + (b_up-bmix)*(b_env-bmix),0.00001),1.0) + # with gil: + # print 'partiation_func',partiation_func + # #partiation_func = pow(fmax((bmix-b_env),0.0)/fmax(bmix+b_env,0.05),2.0) + partiation_func = tanh(fmax(buoyancy_ratio,0.0)) if entr_in.af>0.0: - #if entr_in.w - entr_in.dt*(bmix-entr_in.b_mean + wdw_mix) > 0.0: - _ret.entr_sc = fmax((1.0-((b_up-bmix)/(b_up+bmix))**2),0.0)*eps_w - _ret.detr_sc = fmax((1.0-((b_env-bmix)/(b_env+bmix))**2),0.0)*eps_w +# if entr_in.w - entr_in.dt*(bmix-entr_in.b_mean + wdw_mix) > 0.0: + _ret.entr_sc = partiation_func*eps_w+(1-partiation_func)*1e-3 + _ret.detr_sc = (1.0-partiation_func)*eps_w +partiation_func*1e-3 with gil: - print 'net', _ret.entr_sc- _ret.detr_sc + print 'partiation_func', partiation_func, 'entr', _ret.entr_sc, 'detr', _ret.detr_sc else: _ret.entr_sc = 0.0 _ret.detr_sc = 0.0 @@ -132,6 +166,7 @@ cdef entr_struct entr_detr_b_w2(entr_in_struct entr_in) nogil: cdef entr_struct _ret # in cloud portion from Soares 2004 if entr_in.z >= entr_in.zi : + #if entr_in.ql_up >= 0.0: _ret.detr_sc= 4.0e-3 + 0.12* fabs(fmin(entr_in.b,0.0)) / fmax(entr_in.w * entr_in.w, 1e-2) else: _ret.detr_sc = 0.0 From 062159dad1fe9f0db29c1eda7e012b62caa7ae5b Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Mon, 26 Mar 2018 14:42:03 -0700 Subject: [PATCH 003/136] playing with buoayncy sorting --- Turbulence_PrognosticTKE.pyx | 36 ++++++++--------- turbulence_functions.pyx | 75 ++++++++---------------------------- 2 files changed, 33 insertions(+), 78 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index f10fefa3..25d24781 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -712,26 +712,26 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.W.new[i,k] = (self.Ref.rho0[k] * a_k * self.UpdVar.W.values[i,k] * dti_ -adv + exch + buoy + press)/(self.Ref.rho0[k] * anew_k * dti_) - if self.UpdVar.W.new[i,k] <= 0.0: - self.UpdVar.W.new[i,k:] = 0.0 - self.UpdVar.Area.new[i,k+1:] = 0.0 - break - else: - self.UpdVar.W.new[i,k:] = 0.0 - self.UpdVar.Area.new[i,k+1:] = 0.0 - # keep this in mind if we modify updraft top treatment! - self.updraft_pressure_sink[i,k:] = 0.0 - break + # if self.UpdVar.W.new[i,k] <= 0.0: + # self.UpdVar.W.new[i,k:] = 0.0 + # self.UpdVar.Area.new[i,k+1:] = 0.0 + # break + # else: + # self.UpdVar.W.new[i,k:] = 0.0 + # self.UpdVar.Area.new[i,k+1:] = 0.0 + # # keep this in mind if we modify updraft top treatment! + # self.updraft_pressure_sink[i,k:] = 0.0 + # break # the above lines were replaced by the followings to allow integration above negative w # the model output is sensitive to the choice of value inthe condition : <= 0.01 - # if self.UpdVar.W.new[i,k] <= 0.01: - # self.UpdVar.W.new[i,k] = 0.0 - # self.UpdVar.Area.new[i,k+1] = 0.0 - # #break - # else: - # self.UpdVar.W.new[i,k] = 0.0 - # self.UpdVar.Area.new[i,k+1] = 0.0 - # #break + if self.UpdVar.W.new[i,k] <= 0.01: + self.UpdVar.W.new[i,k] = 0.0 + self.UpdVar.Area.new[i,k+1] = 0.0 + #break + else: + self.UpdVar.W.new[i,k] = 0.0 + self.UpdVar.Area.new[i,k+1] = 0.0 + #break # plt.figure('area') # plt.plot(self.UpdVar.Area.new[0,:], self.Gr.z_half) # plt.show() diff --git a/turbulence_functions.pyx b/turbulence_functions.pyx index 724b1cf9..a5e43a57 100644 --- a/turbulence_functions.pyx +++ b/turbulence_functions.pyx @@ -50,15 +50,11 @@ cdef entr_struct entr_detr_buoyancy_sorting(entr_in_struct entr_in) nogil: qv_mix = qt_mix-ql_mix thetal_ = t_to_thetali_c(entr_in.p0, T_mean, qt_mix, ql_mix, 0.0) #if entr_in.z >= entr_in.zi: - if ql_mix > 0.0: - evap = evap_sat_adjust(entr_in.p0, thetal_, qt_mix) - qv_mix = qt_mix-evap.ql - Tmix = evap.T - alpha_mix = alpha_c(entr_in.p0, Tmix, qt_mix, qv_mix) - bmix = buoyancy_c(entr_in.alpha0, alpha_mix) - entr_in.b_mean - else: - alpha_mix = alpha_c(entr_in.p0, T_mean, qt_mix, qv_mix) - bmix = buoyancy_c(entr_in.alpha0, alpha_mix) - entr_in.b_mean + evap = evap_sat_adjust(entr_in.p0, thetal_, qt_mix) + qv_mix = qt_mix-evap.ql + Tmix = evap.T + alpha_mix = alpha_c(entr_in.p0, Tmix, qt_mix, qv_mix) + bmix = buoyancy_c(entr_in.alpha0, alpha_mix) - entr_in.b_mean alpha_env = alpha_c(entr_in.p0, entr_in.T_env, entr_in.qt_env, entr_in.qt_env-entr_in.ql_env) alpha_up = alpha_c(entr_in.p0, entr_in.T_up, entr_in.qt_up, entr_in.qt_up-entr_in.ql_up) @@ -66,68 +62,27 @@ cdef entr_struct entr_detr_buoyancy_sorting(entr_in_struct entr_in) nogil: b_up = buoyancy_c(entr_in.alpha0, alpha_up) - entr_in.b_mean wdw_mix = w_mix*dw_mix - if bmix+wdw_mix>0.0: - buoyancy_ratio = (bmix+wdw_mix-b_env)/(bmix+wdw_mix) - with gil: - print buoyancy_ratio - - else: + if bmix==0.0: buoyancy_ratio = 0.0 + else: + buoyancy_ratio = (bmix-b_env)/fabs(bmix) - #eps_w = 1.0/(500.0 * fmax(fabs(entr_in.w),0.1)) # inverse w - #eps_w = fabs(entr_in.b/fmax(w_mix * w_mix, 1e-2)) - eps_w = (0.1 * fabs(bmix+wdw_mix) / fmax(w_mix * w_mix, 1e-2)) + eps_w = (0.1 * fabs(bmix) / fmax(w_mix* w_mix, 1e-2)) wdw_env = entr_in.w_env*entr_in.dw_env wdw_up = entr_in.w*entr_in.dw - # first attempt - # if bmix>b_env: - # partiation_func = 1.0 - # else: - # partiation_func = fmin(pow((b_up-b_env),2.0)/fmax( pow((b_up-bmix),2.0) + (b_up-bmix)*(b_env-bmix),0.00001),1.0) - - # second attempt - # b1 = (b_up + b_env)/2 - # - # - # if b1>b_env: - # partiation_func = 1.0 - # else: - # partiation_func = fmin(pow((b_up-b_env),2.0)/fmax( pow((b_up-bmix),2.0) + (b_up-bmix)*(b_env-bmix),0.00001),1.0) - # with gil: - # print 'partiation_func',partiation_func - # #partiation_func = pow(fmax((bmix-b_env),0.0)/fmax(bmix+b_env,0.05),2.0) - partiation_func = tanh(fmax(buoyancy_ratio,0.0)) + + partiation_func = 0.9*(1.0+tanh(buoyancy_ratio))/2.0 if entr_in.af>0.0: -# if entr_in.w - entr_in.dt*(bmix-entr_in.b_mean + wdw_mix) > 0.0: - _ret.entr_sc = partiation_func*eps_w+(1-partiation_func)*1e-3 - _ret.detr_sc = (1.0-partiation_func)*eps_w +partiation_func*1e-3 - with gil: - print 'partiation_func', partiation_func, 'entr', _ret.entr_sc, 'detr', _ret.detr_sc + _ret.entr_sc = partiation_func*eps_w#+(1-partiation_func)*1e-3 + _ret.detr_sc = (1.0-partiation_func)*eps_w#+partiation_func*1e-3 +# with gil: +# print 'partiation_func', partiation_func, 'entr', _ret.entr_sc, 'detr', _ret.detr_sc else: _ret.entr_sc = 0.0 _ret.detr_sc = 0.0 return _ret - # if entr_in.af>0.0: - # #if entr_in.w - entr_in.dt*(bmix-entr_in.b_mean + wdw_mix) > 0.0: - # if bmix> b_env: - # with gil: - # print entr_in.b - # _ret.entr_sc = eps_w - # _ret.detr_sc = 0.0 - # else: - # _ret.entr_sc = eps_w - # _ret.detr_sc = fmax(entr_in.b,0.0) / fmax(entr_in.w * entr_in.w, 1e-1) - # with gil: - # print 'entrainment', _ret.entr_sc, 'detrainment', _ret.detr_sc - # - # else: - # _ret.entr_sc = 0.0 - # _ret.detr_sc = 0.0 - # return _ret - - cdef entr_struct entr_detr_tke2(entr_in_struct entr_in) nogil: cdef entr_struct _ret # in cloud portion from Soares 2004 From cdce551138ceb49484a7360e1241cb5305b1a585 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Thu, 29 Mar 2018 13:30:49 -0700 Subject: [PATCH 004/136] testing entrainemnt --- Turbulence_PrognosticTKE.pyx | 41 ++++++++++++++++++------------------ turbulence_functions.pyx | 24 +++++++++++++++------ 2 files changed, 39 insertions(+), 26 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 25d24781..28938f03 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -631,17 +631,18 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): input.ml = self.mixing_length[k] input.qt_env = self.EnvVar.QT.values[k] input.ql_env = self.EnvVar.QL.values[k] + input.T_env = self.EnvVar.T.values[k] input.H_env = self.EnvVar.H.values[k] input.w_env = interp2pt(self.EnvVar.W.values[k],self.EnvVar.W.values[k-1]) input.dw_env = (self.EnvVar.W.values[k]-self.EnvVar.W.values[k-1])/self.Gr.dz input.H_up = self.UpdVar.H.values[i,k] input.qt_up = self.UpdVar.QT.values[i,k] input.ql_up = self.UpdVar.QL.values[i,k] + input.T_up = self.UpdVar.T.values[i,k] input.p0 = self.Ref.p0_half[k] input.alpha0 = self.Ref.alpha0_half[k] input.tke_ed_coeff = self.tke_ed_coeff - input.T_env = self.EnvVar.T.values[k] - input.T_up = self.UpdVar.T.values[i,k] + input.L = 20000.0 # need to define the scale of the GCM grid resolution ret = self.entr_detr_fp(input) self.entr_sc[i,k] = ret.entr_sc * self.entrainment_factor @@ -712,26 +713,26 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.W.new[i,k] = (self.Ref.rho0[k] * a_k * self.UpdVar.W.values[i,k] * dti_ -adv + exch + buoy + press)/(self.Ref.rho0[k] * anew_k * dti_) - # if self.UpdVar.W.new[i,k] <= 0.0: - # self.UpdVar.W.new[i,k:] = 0.0 - # self.UpdVar.Area.new[i,k+1:] = 0.0 - # break - # else: - # self.UpdVar.W.new[i,k:] = 0.0 - # self.UpdVar.Area.new[i,k+1:] = 0.0 - # # keep this in mind if we modify updraft top treatment! - # self.updraft_pressure_sink[i,k:] = 0.0 - # break + if self.UpdVar.W.new[i,k] <= 0.0: + self.UpdVar.W.new[i,k:] = 0.0 + self.UpdVar.Area.new[i,k+1:] = 0.0 + break + else: + self.UpdVar.W.new[i,k:] = 0.0 + self.UpdVar.Area.new[i,k+1:] = 0.0 + # keep this in mind if we modify updraft top treatment! + self.updraft_pressure_sink[i,k:] = 0.0 + break # the above lines were replaced by the followings to allow integration above negative w # the model output is sensitive to the choice of value inthe condition : <= 0.01 - if self.UpdVar.W.new[i,k] <= 0.01: - self.UpdVar.W.new[i,k] = 0.0 - self.UpdVar.Area.new[i,k+1] = 0.0 - #break - else: - self.UpdVar.W.new[i,k] = 0.0 - self.UpdVar.Area.new[i,k+1] = 0.0 - #break + # if self.UpdVar.W.new[i,k] <= 0.01: + # self.UpdVar.W.new[i,k] = 0.0 + # self.UpdVar.Area.new[i,k+1] = 0.0 + # #break + # else: + # self.UpdVar.W.new[i,k] = 0.0 + # self.UpdVar.Area.new[i,k+1] = 0.0 + # #break # plt.figure('area') # plt.plot(self.UpdVar.Area.new[0,:], self.Gr.z_half) # plt.show() diff --git a/turbulence_functions.pyx b/turbulence_functions.pyx index a5e43a57..f29e1b02 100644 --- a/turbulence_functions.pyx +++ b/turbulence_functions.pyx @@ -49,7 +49,7 @@ cdef entr_struct entr_detr_buoyancy_sorting(entr_in_struct entr_in) nogil: ql_mix = (entr_in.ql_up+entr_in.ql_env)/2 qv_mix = qt_mix-ql_mix thetal_ = t_to_thetali_c(entr_in.p0, T_mean, qt_mix, ql_mix, 0.0) - #if entr_in.z >= entr_in.zi: + evap = evap_sat_adjust(entr_in.p0, thetal_, qt_mix) qv_mix = qt_mix-evap.ql Tmix = evap.T @@ -61,23 +61,35 @@ cdef entr_struct entr_detr_buoyancy_sorting(entr_in_struct entr_in) nogil: b_env = buoyancy_c(entr_in.alpha0, alpha_env) - entr_in.b_mean b_up = buoyancy_c(entr_in.alpha0, alpha_up) - entr_in.b_mean wdw_mix = w_mix*dw_mix - + #b_rel = b_up-b_env+(entr_in.w-entr_in.w_env)*(entr_in.w-entr_in.w_env)/40.0 if bmix==0.0: buoyancy_ratio = 0.0 else: buoyancy_ratio = (bmix-b_env)/fabs(bmix) + # with gil: + # print 'T', entr_in.T_up-entr_in.T_env + # print 'qt', entr_in.qt_up - entr_in.qt_env + # print 'ql', entr_in.ql_up-entr_in.ql_env + + # if entr_in.z < entr_in.zi and entr_in.zi < 9999.0: + # if buoyancy_ratio<0.0: + # with gil: + # print buoyancy_ratio + # print 'Tmix', bmix + # print 'T_env', b_env - eps_w = (0.1 * fabs(bmix) / fmax(w_mix* w_mix, 1e-2)) + eps_w = (0.12 * fabs(bmix) / fmax(w_mix* w_mix, 1e-2)) + #eps_w = 1.0/(fmax(w_mix,1.0)* 400) wdw_env = entr_in.w_env*entr_in.dw_env wdw_up = entr_in.w*entr_in.dw - partiation_func = 0.9*(1.0+tanh(buoyancy_ratio))/2.0 + partiation_func = 1.0*(1.0+tanh(buoyancy_ratio))/2.0 if entr_in.af>0.0: _ret.entr_sc = partiation_func*eps_w#+(1-partiation_func)*1e-3 _ret.detr_sc = (1.0-partiation_func)*eps_w#+partiation_func*1e-3 -# with gil: -# print 'partiation_func', partiation_func, 'entr', _ret.entr_sc, 'detr', _ret.detr_sc + with gil: + print 'partiation_func', partiation_func #, 'entr', _ret.entr_sc, 'detr', _ret.detr_sc else: _ret.entr_sc = 0.0 _ret.detr_sc = 0.0 From 3a8a686db7378128ead2f76832267dc6550d4326 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Wed, 9 May 2018 10:15:08 -0700 Subject: [PATCH 005/136] fix dissipation terms in coavarinaces --- Turbulence_PrognosticTKE.pyx | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index cd5ab596..05bcc5e9 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -1573,8 +1573,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): b[kk] = (self.Ref.rho0_half[k] * ae[k] * dti - self.Ref.rho0_half[k] * ae[k] * whalf[k] * dzi + rho_ae_K_m[k] * dzi * dzi + rho_ae_K_m[k-1] * dzi * dzi + D_env - + self.Ref.rho0_half[k] * ae[k] * self.EnvVar.Hvar.values[k] - *sqrt(fmax(self.EnvVar.TKE.values[k],0))/fmax(self.mixing_length[k],1.0) * self.tke_diss_coeff) + + self.Ref.rho0_half[k] * ae[k] * self.tke_diss_coeff + *sqrt(fmax(self.EnvVar.TKE.values[k],0))/fmax(self.mixing_length[k],1.0) ) c[kk] = (self.Ref.rho0_half[k+1] * ae[k+1] * whalf[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) x[kk] = (self.Ref.rho0_half[k] * ae_old[k] * self.EnvVar.Hvar.values[k] * dti + self.Hvar_shear[k] + self.Hvar_entr_gain[k]) # @@ -1611,8 +1611,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): b[kk] = (self.Ref.rho0_half[k] * ae[k] * dti - self.Ref.rho0_half[k] * ae[k] * whalf[k] * dzi + rho_ae_K_m[k] * dzi * dzi + rho_ae_K_m[k-1] * dzi * dzi + D_env - + self.Ref.rho0_half[k] * ae[k] * self.EnvVar.QTvar.values[k] - *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0) * self.tke_diss_coeff) + + self.Ref.rho0_half[k] * ae[k] * self.tke_diss_coeff + *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0)) c[kk] = (self.Ref.rho0_half[k+1] * ae[k+1] * whalf[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) x[kk] = (self.Ref.rho0_half[k] * ae_old[k] * self.EnvVar.QTvar.values[k] * dti + self.QTvar_shear[k] + self.QTvar_entr_gain[k]) # @@ -1651,8 +1651,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): b[kk] = (self.Ref.rho0_half[k] * ae[k] * dti - self.Ref.rho0_half[k] * ae[k] * whalf[k] * dzi + rho_ae_K_m[k] * dzi * dzi + rho_ae_K_m[k-1] * dzi * dzi + D_env - + self.Ref.rho0_half[k] * ae[k] * self.EnvVar.HQTcov.values[k] - *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0) * self.tke_diss_coeff) + + self.Ref.rho0_half[k] * ae[k] * self.tke_diss_coeff + *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0) ) c[kk] = (self.Ref.rho0_half[k+1] * ae[k+1] * whalf[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) x[kk] = (self.Ref.rho0_half[k] * ae_old[k] * self.EnvVar.HQTcov.values[k] * dti + self.HQTcov_shear[k] + self.HQTcov_entr_gain[k]) # From db622aa80b195468d14805927929b1c3e53420cf Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Wed, 9 May 2018 10:19:31 -0700 Subject: [PATCH 006/136] fix dissipation terms in coavarinaces --- Turbulence_PrognosticTKE.pyx | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index cd5ab596..e2ecaa82 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -1573,8 +1573,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): b[kk] = (self.Ref.rho0_half[k] * ae[k] * dti - self.Ref.rho0_half[k] * ae[k] * whalf[k] * dzi + rho_ae_K_m[k] * dzi * dzi + rho_ae_K_m[k-1] * dzi * dzi + D_env - + self.Ref.rho0_half[k] * ae[k] * self.EnvVar.Hvar.values[k] - *sqrt(fmax(self.EnvVar.TKE.values[k],0))/fmax(self.mixing_length[k],1.0) * self.tke_diss_coeff) + + self.Ref.rho0_half[k] * ae[k] * self.tke_diss_coeff + *sqrt(fmax(self.EnvVar.TKE.values[k],0))/fmax(self.mixing_length[k],1.0)) c[kk] = (self.Ref.rho0_half[k+1] * ae[k+1] * whalf[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) x[kk] = (self.Ref.rho0_half[k] * ae_old[k] * self.EnvVar.Hvar.values[k] * dti + self.Hvar_shear[k] + self.Hvar_entr_gain[k]) # @@ -1611,8 +1611,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): b[kk] = (self.Ref.rho0_half[k] * ae[k] * dti - self.Ref.rho0_half[k] * ae[k] * whalf[k] * dzi + rho_ae_K_m[k] * dzi * dzi + rho_ae_K_m[k-1] * dzi * dzi + D_env - + self.Ref.rho0_half[k] * ae[k] * self.EnvVar.QTvar.values[k] - *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0) * self.tke_diss_coeff) + + self.Ref.rho0_half[k] * ae[k] * self.tke_diss_coeff + *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0)) c[kk] = (self.Ref.rho0_half[k+1] * ae[k+1] * whalf[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) x[kk] = (self.Ref.rho0_half[k] * ae_old[k] * self.EnvVar.QTvar.values[k] * dti + self.QTvar_shear[k] + self.QTvar_entr_gain[k]) # @@ -1651,8 +1651,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): b[kk] = (self.Ref.rho0_half[k] * ae[k] * dti - self.Ref.rho0_half[k] * ae[k] * whalf[k] * dzi + rho_ae_K_m[k] * dzi * dzi + rho_ae_K_m[k-1] * dzi * dzi + D_env - + self.Ref.rho0_half[k] * ae[k] * self.EnvVar.HQTcov.values[k] - *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0) * self.tke_diss_coeff) + + self.Ref.rho0_half[k] * ae[k] * self.tke_diss_coeff + *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0)) c[kk] = (self.Ref.rho0_half[k+1] * ae[k+1] * whalf[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) x[kk] = (self.Ref.rho0_half[k] * ae_old[k] * self.EnvVar.HQTcov.values[k] * dti + self.HQTcov_shear[k] + self.HQTcov_entr_gain[k]) # From 120a1b0d8a3e434c81b2e97ec7154cc94cb37188 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Fri, 11 May 2018 14:49:21 -0700 Subject: [PATCH 007/136] add Ellison mixing length --- Turbulence_PrognosticTKE.pxd | 1 + Turbulence_PrognosticTKE.pyx | 42 ++++++++++++++++++++++++------------ generate_namelist.py | 1 + 3 files changed, 30 insertions(+), 14 deletions(-) diff --git a/Turbulence_PrognosticTKE.pxd b/Turbulence_PrognosticTKE.pxd index f666a1da..45a10e8f 100644 --- a/Turbulence_PrognosticTKE.pxd +++ b/Turbulence_PrognosticTKE.pxd @@ -23,6 +23,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): bint use_local_micro bint similarity_diffusivity bint use_steady_updrafts + str mixing_length_fp double surface_area double minimum_area double entrainment_factor diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 05bcc5e9..f3ea8b2a 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -19,7 +19,7 @@ from NetCDFIO cimport NetCDFIO_Stats from thermodynamic_functions cimport * from turbulence_functions cimport * from utility_functions cimport * -from libc.math cimport fmax, sqrt, exp, pow, cbrt, fmin +from libc.math cimport fmax, sqrt, exp, pow, cbrt, fmin, fabs from cpython.mem cimport PyMem_Malloc, PyMem_Realloc, PyMem_Free cdef class EDMF_PrognosticTKE(ParameterizationBase): @@ -59,6 +59,14 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): except: self.entr_detr_fp = entr_detr_b_w2 print('Turbulence--EDMF_PrognosticTKE: defaulting to cloudy entrainment formulation') + + try: + if namelist['turbulence']['EDMF_PrognosticTKE']['mixing length'] == 'Ellison_scale': + self.mixing_length_fp = 'Ellison_scale' # thetal variance based accounting for for stability + except: + self.mixing_length_fp = 'tke' + print('Turbulence--EDMF_PrognosticTKE: defaulting to tke formulation') + try: self.similarity_diffusivity = namelist['turbulence']['EDMF_PrognosticTKE']['use_similarity_diffusivity'] except: @@ -522,18 +530,24 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double l1, l2, z_ double grad, grad2, H - - with nogil: - for k in xrange(gw, self.Gr.nzg-gw): - l1 = tau * sqrt(fmax(self.EnvVar.TKE.values[k],0.0)) - z_ = self.Gr.z_half[k] - if obukhov_length < 0.0: #unstable - l2 = vkb * z_ * ( (1.0 - 100.0 * z_/obukhov_length)**0.2 ) - elif obukhov_length > 0.0: #stable - l2 = vkb * z_ / (1. + 2.7 *z_/obukhov_length) - else: - l2 = vkb * z_ - self.mixing_length[k] = fmax( 1.0/(1.0/fmax(l1,1e-10) + 1.0/l2), 1e-3) + if self.mixing_length_fp=='Ellison_scale': + with nogil: + for k in xrange(gw, self.Gr.nzg-gw): + l1 = sqrt(self.EnvVar.Hvar.values[k])*2.0*self.Gr.dz/fmax((self.EnvVar.H.values[k+1]-self.EnvVar.H.values[k-1]),0.001) + l2 = vkb * self.Gr.z_half[k] + self.mixing_length[k] = fmin(fabs(l1),fabs(l2/2.0)) + else: + with nogil: + for k in xrange(gw, self.Gr.nzg-gw): + l1 = tau * sqrt(fmax(self.EnvVar.TKE.values[k],0.0)) + z_ = self.Gr.z_half[k] + if obukhov_length < 0.0: #unstable + l2 = vkb * z_ * ( (1.0 - 100.0 * z_/obukhov_length)**0.2 ) + elif obukhov_length > 0.0: #stable + l2 = vkb * z_ / (1. + 2.7 *z_/obukhov_length) + else: + l2 = vkb * z_ + self.mixing_length[k] = fmax( 1.0/(1.0/fmax(l1,1e-10) + 1.0/l2), 1e-3) return cpdef compute_eddy_diffusivities_tke(self, GridMeanVariables GMV, CasesBase Case): @@ -883,7 +897,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.updraft_pressure_sink[i,k:] = 0.0 break # the above lines were replaced by the followings to allow integration above negative w - # the model output is sensitive to the choice of value inthe condition : <= 0.01 + # the model output is sensitive to the choice of value in the condition : <= 0.01 # if self.UpdVar.W.new[i,k] <= 0.01: # self.UpdVar.W.new[i,k] = 0.0 # self.UpdVar.Area.new[i,k+1] = 0.0 diff --git a/generate_namelist.py b/generate_namelist.py index 60c942e8..bc0b5862 100644 --- a/generate_namelist.py +++ b/generate_namelist.py @@ -118,6 +118,7 @@ def Bomex(): namelist['turbulence']['EDMF_PrognosticTKE']['extrapolate_buoyancy'] = True namelist['turbulence']['EDMF_PrognosticTKE']['use_steady_updrafts'] = False namelist['turbulence']['EDMF_PrognosticTKE']['use_scalar_var'] = True + namelist['turbulence']['EDMF_PrognosticTKE']['mixing length'] = 'thatal variance' namelist['output'] = {} namelist['output']['output_root'] = './' From a040cabd87c2b929b47e09c278bda612b4aaa39b Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Sat, 19 May 2018 13:30:42 -0700 Subject: [PATCH 008/136] new miing length --- Turbulence_PrognosticTKE.pxd | 2 +- Turbulence_PrognosticTKE.pyx | 41 ++++++++++++++++++++++++++---------- generate_namelist.py | 2 +- utility_functions.pxd | 1 + utility_functions.pyx | 4 ++++ 5 files changed, 37 insertions(+), 13 deletions(-) diff --git a/Turbulence_PrognosticTKE.pxd b/Turbulence_PrognosticTKE.pxd index 45a10e8f..950633c8 100644 --- a/Turbulence_PrognosticTKE.pxd +++ b/Turbulence_PrognosticTKE.pxd @@ -88,7 +88,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cpdef compute_prognostic_updrafts(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS) cpdef compute_diagnostic_updrafts(self, GridMeanVariables GMV, CasesBase Case) cpdef update_inversion(self, GridMeanVariables GMV, option) - cpdef compute_mixing_length(self, double obukhov_length) + cpdef compute_mixing_length(self, double obukhov_length, GridMeanVariables GMV) cpdef compute_eddy_diffusivities_tke(self, GridMeanVariables GMV, CasesBase Case) cpdef reset_surface_tke(self, GridMeanVariables GMV, CasesBase Case) cpdef reset_surface_covariance(self, GridMeanVariables GMV, CasesBase Case) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index f3ea8b2a..d945c001 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -62,7 +62,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): try: if namelist['turbulence']['EDMF_PrognosticTKE']['mixing length'] == 'Ellison_scale': - self.mixing_length_fp = 'Ellison_scale' # thetal variance based accounting for for stability + if namelist['turbulence']['EDMF_PrognosticTKE']['use_scalar_var']: + self.mixing_length_fp = 'Ellison_scale' # thetal variance based accounting for for stability + else: + print 'scalar va riances must be used for Ellison scale mixing length' + return except: self.mixing_length_fp = 'tke' print('Turbulence--EDMF_PrognosticTKE: defaulting to tke formulation') @@ -487,7 +491,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cpdef compute_tke(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS): if self.similarity_diffusivity: # otherwise, we computed mixing length when we computed D_T - self.compute_mixing_length(Case.Sur.obukhov_length) + self.compute_mixing_length(Case.Sur.obukhov_length, GMV) self.compute_tke_buoy(GMV) self.compute_tke_entr() @@ -514,28 +518,43 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.reset_surface_tke(GMV, Case) - self.compute_mixing_length(Case.Sur.obukhov_length) + self.compute_mixing_length(Case.Sur.obukhov_length, GMV) return cpdef update_inversion(self,GridMeanVariables GMV, option): ParameterizationBase.update_inversion(self, GMV,option) return - cpdef compute_mixing_length(self, double obukhov_length): + cpdef compute_mixing_length(self, double obukhov_length, GridMeanVariables GMV): cdef: Py_ssize_t k Py_ssize_t gw = self.Gr.gw double tau = get_mixing_tau(self.zi, self.wstar) - double l1, l2, z_ + double l1, l2, l3, l4, l5, z_ double grad, grad2, H + double du_high = 0.0 + double dv_high = 0.0 + double dw_high = 2.0 * self.EnvVar.W.values[gw] * self.Gr.dzi + double du_low, dv_low, dw_low, if self.mixing_length_fp=='Ellison_scale': with nogil: for k in xrange(gw, self.Gr.nzg-gw): - l1 = sqrt(self.EnvVar.Hvar.values[k])*2.0*self.Gr.dz/fmax((self.EnvVar.H.values[k+1]-self.EnvVar.H.values[k-1]),0.001) - l2 = vkb * self.Gr.z_half[k] - self.mixing_length[k] = fmin(fabs(l1),fabs(l2/2.0)) + du_low = du_high + dv_low = dv_high + dw_low = dw_high + du_high = (GMV.U.values[k+1] - GMV.U.values[k]) * self.Gr.dzi + dv_high = (GMV.V.values[k+1] - GMV.V.values[k]) * self.Gr.dzi + dw_high = (self.EnvVar.W.values[k+1] - self.EnvVar.W.values[k]) * self.Gr.dzi + shear = ( pow(interp2pt(du_low, du_high),2.0) + pow(interp2pt(dv_low, dv_high),2.0)+ + pow(interp2pt(dw_low, dw_high),2.0)) + l1 = vkb * self.Gr.z_half[k] + l2 = sqrt(self.EnvVar.Hvar.values[k])*2.0*self.Gr.dz/fmax((self.EnvVar.H.values[k+1]-self.EnvVar.H.values[k-1]),0.001) + l3 = sqrt(self.EnvVar.QTvar.values[k])*2.0*self.Gr.dz/fmax((self.EnvVar.QT.values[k+1]-self.EnvVar.QT.values[k-1]),0.001) + l4 = sqrt(self.tke_diss_coeff/self.tke_ed_coeff*self.EnvVar.TKE.values[k]/fmax(fabs(shear),0.01)) + l5 = 10000.0 # GCM grid box + self.mixing_length[k] = smooth_minimum(fabs(l1),fabs(l2),fabs(l3),fabs(l4),fabs(l5),10.0) else: with nogil: for k in xrange(gw, self.Gr.nzg-gw): @@ -560,7 +579,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): if self.similarity_diffusivity: ParameterizationBase.compute_eddy_diffusivities_similarity(self,GMV, Case) else: - self.compute_mixing_length(Case.Sur.obukhov_length) + self.compute_mixing_length(Case.Sur.obukhov_length, GMV) with nogil: for k in xrange(gw, self.Gr.nzg-gw): lm = self.mixing_length[k] @@ -1419,7 +1438,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): if TS.nstep > 0: if self.similarity_diffusivity: # otherwise, we computed mixing length when we computed - self.compute_mixing_length(Case.Sur.obukhov_length) + self.compute_mixing_length(Case.Sur.obukhov_length, GMV) self.compute_covariance_entr() self.compute_covariance_shear(GMV) @@ -1447,7 +1466,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): GMV.QTvar.values[k] = GMV.QTvar.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) GMV.HQTcov.values[k] = GMV.HQTcov.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) - self.compute_mixing_length(Case.Sur.obukhov_length) + self.compute_mixing_length(Case.Sur.obukhov_length, GMV) return diff --git a/generate_namelist.py b/generate_namelist.py index bc0b5862..5caf2c98 100644 --- a/generate_namelist.py +++ b/generate_namelist.py @@ -118,7 +118,7 @@ def Bomex(): namelist['turbulence']['EDMF_PrognosticTKE']['extrapolate_buoyancy'] = True namelist['turbulence']['EDMF_PrognosticTKE']['use_steady_updrafts'] = False namelist['turbulence']['EDMF_PrognosticTKE']['use_scalar_var'] = True - namelist['turbulence']['EDMF_PrognosticTKE']['mixing length'] = 'thatal variance' + namelist['turbulence']['EDMF_PrognosticTKE']['mixing length'] = 'Ellison_scale' namelist['output'] = {} namelist['output']['output_root'] = './' diff --git a/utility_functions.pxd b/utility_functions.pxd index 108a86e6..f00056fa 100644 --- a/utility_functions.pxd +++ b/utility_functions.pxd @@ -1,4 +1,5 @@ cdef double interp2pt(double val1, double val2) nogil cdef double logistic(double x, double slope, double mid) nogil +cdef double smooth_minimum(double x1, double x2,double x3, double x4,double x5, double a) nogil cpdef double percentile_mean_norm(double percentile, Py_ssize_t nsamples) cpdef double percentile_bounds_mean_norm(double low_percentile, double high_percentile, Py_ssize_t nsamples) \ No newline at end of file diff --git a/utility_functions.pyx b/utility_functions.pyx index 78698c33..caa98bf7 100644 --- a/utility_functions.pyx +++ b/utility_functions.pyx @@ -27,3 +27,7 @@ cdef double interp2pt(double val1, double val2) nogil: cdef double logistic(double x, double slope, double mid) nogil: return 1.0/(1.0 + exp( -slope * (x-mid))) +cdef double smooth_minimum(double x1, double x2,double x3, double x4,double x5, double a) nogil: + smin = (x1*exp(-a*x1)+x2*exp(-a*x2)+x3*exp(-a*x3)+x4*exp(-a*x4)+x5*exp(-a*x5))\ + / (exp(-a*x1)+exp(-a*x2)+exp(-a*x3)+exp(-a*x4)+exp(-a*x5)) + return smin From e8d83248e84ac24f8ca66be4efbd92ff65bab8dd Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Thu, 24 May 2018 11:35:27 -0700 Subject: [PATCH 009/136] random process in entrainment --- Turbulence_PrognosticTKE.pyx | 66 +++++++++++++++++---------------- turbulence_functions.pxd | 2 + turbulence_functions.pyx | 72 ++++++++++++++++++++++++++++++++---- 3 files changed, 100 insertions(+), 40 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index d945c001..a93423e1 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -52,8 +52,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.entr_detr_fp = entr_detr_inverse_w elif namelist['turbulence']['EDMF_PrognosticTKE']['entrainment'] == 'b_w2': self.entr_detr_fp = entr_detr_b_w2 - elif namelist['turbulence']['EDMF_PrognosticTKE']['entrainment'] == 'buoyancy_sorting': - self.entr_detr_fp = entr_detr_buoyancy_sorting + elif namelist['turbulence']['EDMF_PrognosticTKE']['entrainment'] == 'buoyancy_sorting': self.entr_detr_fp = entr_detr_buoyancy_sorting else: print('Turbulence--EDMF_PrognosticTKE: Entrainment rate namelist option is not recognized') except: @@ -803,42 +802,45 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): entr_struct ret entr_in_struct input eos_struct sa + #double [:] Poisson_rand + double [:] Poisson_rand self.UpdVar.get_cloud_base_top() input.wstar = self.wstar - with nogil: - for i in xrange(self.n_updrafts): - input.zi = self.UpdVar.cloud_base[i] - for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - input.b = self.UpdVar.B.values[i,k] - input.b_mean = GMV.B.values[k] - input.w = interp2pt(self.UpdVar.W.values[i,k],self.UpdVar.W.values[i,k-1]) - input.dw = (self.UpdVar.W.values[i,k]-self.UpdVar.W.values[i,k-1])/self.Gr.dz - input.z = self.Gr.z_half[k] - input.af = self.UpdVar.Area.values[i,k] - input.tke = self.EnvVar.TKE.values[k] - input.ml = self.mixing_length[k] - input.qt_env = self.EnvVar.QT.values[k] - input.ql_env = self.EnvVar.QL.values[k] - input.T_env = self.EnvVar.T.values[k] - input.H_env = self.EnvVar.H.values[k] - input.w_env = interp2pt(self.EnvVar.W.values[k],self.EnvVar.W.values[k-1]) - input.dw_env = (self.EnvVar.W.values[k]-self.EnvVar.W.values[k-1])/self.Gr.dz - input.H_up = self.UpdVar.H.values[i,k] - input.qt_up = self.UpdVar.QT.values[i,k] - input.ql_up = self.UpdVar.QL.values[i,k] - input.T_up = self.UpdVar.T.values[i,k] - input.p0 = self.Ref.p0_half[k] - input.alpha0 = self.Ref.alpha0_half[k] - input.tke_ed_coeff = self.tke_ed_coeff - - input.L = 20000.0 # need to define the scale of the GCM grid resolution - ret = self.entr_detr_fp(input) - self.entr_sc[i,k] = ret.entr_sc * self.entrainment_factor - self.detr_sc[i,k] = ret.detr_sc * self.detrainment_factor + #with nogil: + for i in xrange(self.n_updrafts): + input.zi = self.UpdVar.cloud_base[i] + Poisson_rand = np.random.poisson(4,100).astype(np.float) + for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): + input.b = self.UpdVar.B.values[i,k] + input.b_mean = GMV.B.values[k] + input.w = interp2pt(self.UpdVar.W.values[i,k],self.UpdVar.W.values[i,k-1]) + input.dw = (self.UpdVar.W.values[i,k]-self.UpdVar.W.values[i,k-1])/self.Gr.dz + input.z = self.Gr.z_half[k] + input.af = self.UpdVar.Area.values[i,k] + input.tke = self.EnvVar.TKE.values[k] + input.ml = self.mixing_length[k] + input.qt_env = self.EnvVar.QT.values[k] + input.ql_env = self.EnvVar.QL.values[k] + input.T_env = self.EnvVar.T.values[k] + input.H_env = self.EnvVar.H.values[k] + input.w_env = interp2pt(self.EnvVar.W.values[k],self.EnvVar.W.values[k-1]) + input.dw_env = (self.EnvVar.W.values[k]-self.EnvVar.W.values[k-1])/self.Gr.dz + input.H_up = self.UpdVar.H.values[i,k] + input.qt_up = self.UpdVar.QT.values[i,k] + input.ql_up = self.UpdVar.QL.values[i,k] + input.T_up = self.UpdVar.T.values[i,k] + input.p0 = self.Ref.p0_half[k] + input.alpha0 = self.Ref.alpha0_half[k] + input.tke_ed_coeff = self.tke_ed_coeff + input.Poisson_rand = (Poisson_rand[i]-5.0)/10.0 + input.L = 20000.0 # need to define the scale of the GCM grid resolution + ret = self.entr_detr_fp(input) + self.entr_sc[i,k] = ret.entr_sc * self.entrainment_factor + self.detr_sc[i,k] = ret.detr_sc * self.detrainment_factor return diff --git a/turbulence_functions.pxd b/turbulence_functions.pxd index 837568f0..df92209b 100644 --- a/turbulence_functions.pxd +++ b/turbulence_functions.pxd @@ -35,6 +35,7 @@ cdef struct entr_in_struct: double dw_env double L double tke_ed_coeff + double Poisson_rand cdef entr_struct entr_detr_dry(entr_in_struct entr_in) nogil cdef entr_struct entr_detr_inverse_z(entr_in_struct entr_in) nogil @@ -44,6 +45,7 @@ cdef entr_struct entr_detr_buoyancy_sorting(entr_in_struct entr_in) nogil cdef evap_struct evap_sat_adjust(double p0, double thetal_, double qt_mix) nogil + cdef double get_wstar(double bflux, double zi ) cdef double get_inversion(double *theta_rho, double *u, double *v, double *z_half, Py_ssize_t kmin, Py_ssize_t kmax, double Ri_bulk_crit) diff --git a/turbulence_functions.pyx b/turbulence_functions.pyx index f29e1b02..f379c729 100644 --- a/turbulence_functions.pyx +++ b/turbulence_functions.pyx @@ -40,7 +40,7 @@ cdef entr_struct entr_detr_inverse_w(entr_in_struct entr_in) nogil: cdef entr_struct entr_detr_buoyancy_sorting(entr_in_struct entr_in) nogil: cdef: entr_struct _ret - double wdw_mix, wdw_env + double wdw_mix, wdw_env, a1 w_mix = (entr_in.w+entr_in.w_env)/2 dw_mix = (entr_in.dw+entr_in.dw_env)/2 @@ -62,10 +62,11 @@ cdef entr_struct entr_detr_buoyancy_sorting(entr_in_struct entr_in) nogil: b_up = buoyancy_c(entr_in.alpha0, alpha_up) - entr_in.b_mean wdw_mix = w_mix*dw_mix #b_rel = b_up-b_env+(entr_in.w-entr_in.w_env)*(entr_in.w-entr_in.w_env)/40.0 + a1 = fabs(entr_in.Poisson_rand) if bmix==0.0: buoyancy_ratio = 0.0 else: - buoyancy_ratio = (bmix-b_env)/fabs(bmix) + buoyancy_ratio = (a1*bmix-(1-a1)*b_env)/fabs(bmix) # with gil: # print 'T', entr_in.T_up-entr_in.T_env # print 'qt', entr_in.qt_up - entr_in.qt_env @@ -78,18 +79,16 @@ cdef entr_struct entr_detr_buoyancy_sorting(entr_in_struct entr_in) nogil: # print 'Tmix', bmix # print 'T_env', b_env - eps_w = (0.12 * fabs(bmix) / fmax(w_mix* w_mix, 1e-2)) - #eps_w = 1.0/(fmax(w_mix,1.0)* 400) + #eps_w = (0.12 * fabs(bmix) / fmax(w_mix* w_mix, 1e-2)) + eps_w = 0.1/(fmax(w_mix,1.0)* 280) wdw_env = entr_in.w_env*entr_in.dw_env wdw_up = entr_in.w*entr_in.dw partiation_func = 1.0*(1.0+tanh(buoyancy_ratio))/2.0 if entr_in.af>0.0: - _ret.entr_sc = partiation_func*eps_w#+(1-partiation_func)*1e-3 - _ret.detr_sc = (1.0-partiation_func)*eps_w#+partiation_func*1e-3 - with gil: - print 'partiation_func', partiation_func #, 'entr', _ret.entr_sc, 'detr', _ret.detr_sc + _ret.entr_sc = partiation_func*eps_w+(1-partiation_func)*1e-4 + _ret.detr_sc = (1.0-partiation_func)*eps_w+partiation_func*1e-4 else: _ret.entr_sc = 0.0 _ret.detr_sc = 0.0 @@ -143,6 +142,63 @@ cdef entr_struct entr_detr_b_w2(entr_in_struct entr_in) nogil: return _ret +cdef entr_struct entr_detr_buoyancy_sorting(entr_in_struct entr_in) nogil: + cdef: + entr_struct _ret + double wdw_mix, wdw_env, a1 + + w_mix = (entr_in.w+entr_in.w_env)/2 + dw_mix = (entr_in.dw+entr_in.dw_env)/2 + T_mean = (entr_in.T_up+entr_in.T_env)/2 + qt_mix = (entr_in.qt_up+entr_in.qt_env)/2 + ql_mix = (entr_in.ql_up+entr_in.ql_env)/2 + qv_mix = qt_mix-ql_mix + thetal_ = t_to_thetali_c(entr_in.p0, T_mean, qt_mix, ql_mix, 0.0) + + evap = evap_sat_adjust(entr_in.p0, thetal_, qt_mix) + qv_mix = qt_mix-evap.ql + Tmix = evap.T + alpha_mix = alpha_c(entr_in.p0, Tmix, qt_mix, qv_mix) + bmix = buoyancy_c(entr_in.alpha0, alpha_mix) - entr_in.b_mean + + alpha_env = alpha_c(entr_in.p0, entr_in.T_env, entr_in.qt_env, entr_in.qt_env-entr_in.ql_env) + alpha_up = alpha_c(entr_in.p0, entr_in.T_up, entr_in.qt_up, entr_in.qt_up-entr_in.ql_up) + b_env = buoyancy_c(entr_in.alpha0, alpha_env) - entr_in.b_mean + b_up = buoyancy_c(entr_in.alpha0, alpha_up) - entr_in.b_mean + wdw_mix = w_mix*dw_mix + #b_rel = b_up-b_env+(entr_in.w-entr_in.w_env)*(entr_in.w-entr_in.w_env)/40.0 + a1 = fabs(entr_in.Poisson_rand) + if bmix==0.0: + buoyancy_ratio = 0.0 + else: + buoyancy_ratio = (a1*bmix-(1-a1)*b_env)/fabs(bmix) + # with gil: + # print 'T', entr_in.T_up-entr_in.T_env + # print 'qt', entr_in.qt_up - entr_in.qt_env + # print 'ql', entr_in.ql_up-entr_in.ql_env + + # if entr_in.z < entr_in.zi and entr_in.zi < 9999.0: + # if buoyancy_ratio<0.0: + # with gil: + # print buoyancy_ratio + # print 'Tmix', bmix + # print 'T_env', b_env + + #eps_w = (0.12 * fabs(bmix) / fmax(w_mix* w_mix, 1e-2)) + eps_w = 0.1/(fmax(w_mix,1.0)* 280) + + wdw_env = entr_in.w_env*entr_in.dw_env + wdw_up = entr_in.w*entr_in.dw + + partiation_func = 1.0*(1.0+tanh(buoyancy_ratio))/2.0 + if entr_in.af>0.0: + _ret.entr_sc = partiation_func*eps_w+(1-partiation_func)*1e-4 + _ret.detr_sc = (1.0-partiation_func)*eps_w+partiation_func*1e-4 + else: + _ret.entr_sc = 0.0 + _ret.detr_sc = 0.0 + return _ret + cdef evap_struct evap_sat_adjust(double p0, double thetal_, double qt_mix) nogil: cdef: evap_struct evap From 2ce65072f4bd6f227b76cb9e77fe56bed5419ef1 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Tue, 5 Jun 2018 16:03:54 -0700 Subject: [PATCH 010/136] .. --- Turbulence_PrognosticTKE.pyx | 31 ++++---- turbulence_functions.pxd | 6 +- turbulence_functions.pyx | 145 ++++++++++++----------------------- utility_functions.pxd | 3 +- utility_functions.pyx | 11 ++- 5 files changed, 76 insertions(+), 120 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index a93423e1..861a24c7 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -21,6 +21,7 @@ from turbulence_functions cimport * from utility_functions cimport * from libc.math cimport fmax, sqrt, exp, pow, cbrt, fmin, fabs from cpython.mem cimport PyMem_Malloc, PyMem_Realloc, PyMem_Free +import sys cdef class EDMF_PrognosticTKE(ParameterizationBase): # Initialize the class @@ -52,7 +53,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.entr_detr_fp = entr_detr_inverse_w elif namelist['turbulence']['EDMF_PrognosticTKE']['entrainment'] == 'b_w2': self.entr_detr_fp = entr_detr_b_w2 - elif namelist['turbulence']['EDMF_PrognosticTKE']['entrainment'] == 'buoyancy_sorting': self.entr_detr_fp = entr_detr_buoyancy_sorting else: print('Turbulence--EDMF_PrognosticTKE: Entrainment rate namelist option is not recognized') except: @@ -64,7 +64,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): if namelist['turbulence']['EDMF_PrognosticTKE']['use_scalar_var']: self.mixing_length_fp = 'Ellison_scale' # thetal variance based accounting for for stability else: - print 'scalar va riances must be used for Ellison scale mixing length' + print 'scalar variances must be used for Ellison scale mixing length' return except: self.mixing_length_fp = 'tke' @@ -530,12 +530,12 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Py_ssize_t k Py_ssize_t gw = self.Gr.gw double tau = get_mixing_tau(self.zi, self.wstar) - double l1, l2, l3, l4, l5, z_ + double l1, l2, l3, l4, l5, l234, z_ double grad, grad2, H double du_high = 0.0 double dv_high = 0.0 double dw_high = 2.0 * self.EnvVar.W.values[gw] * self.Gr.dzi - double du_low, dv_low, dw_low, + double du_low, dv_low, dw_low, H_lapse_rate ,QT_lapse_rate if self.mixing_length_fp=='Ellison_scale': with nogil: @@ -546,14 +546,18 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): du_high = (GMV.U.values[k+1] - GMV.U.values[k]) * self.Gr.dzi dv_high = (GMV.V.values[k+1] - GMV.V.values[k]) * self.Gr.dzi dw_high = (self.EnvVar.W.values[k+1] - self.EnvVar.W.values[k]) * self.Gr.dzi - shear = ( pow(interp2pt(du_low, du_high),2.0) + pow(interp2pt(dv_low, dv_high),2.0)+ - pow(interp2pt(dw_low, dw_high),2.0)) + shear = fmax(fabs( pow(interp2pt(du_low, du_high),2.0) + pow(interp2pt(dv_low, dv_high),2.0)+ + pow(interp2pt(dw_low, dw_high),2.0)),1e-10) + H_lapse_rate = fmax(fabs((self.EnvVar.H.values[k+1]-self.EnvVar.H.values[k-1])*0.5*self.Gr.dzi),1e-30) + QT_lapse_rate = fmax(fabs((self.EnvVar.QT.values[k+1]-self.EnvVar.QT.values[k-1])*0.5*self.Gr.dzi),1e-30) l1 = vkb * self.Gr.z_half[k] - l2 = sqrt(self.EnvVar.Hvar.values[k])*2.0*self.Gr.dz/fmax((self.EnvVar.H.values[k+1]-self.EnvVar.H.values[k-1]),0.001) - l3 = sqrt(self.EnvVar.QTvar.values[k])*2.0*self.Gr.dz/fmax((self.EnvVar.QT.values[k+1]-self.EnvVar.QT.values[k-1]),0.001) - l4 = sqrt(self.tke_diss_coeff/self.tke_ed_coeff*self.EnvVar.TKE.values[k]/fmax(fabs(shear),0.01)) - l5 = 10000.0 # GCM grid box - self.mixing_length[k] = smooth_minimum(fabs(l1),fabs(l2),fabs(l3),fabs(l4),fabs(l5),10.0) + #l2 = fmin(sqrt(self.tke_diss_coeff/self.tke_ed_coeff*0.5*self.EnvVar.Hvar.values[k]/H_lapse_rate**2),1000.0) + #l2 = fmin(sqrt(self.tke_diss_coeff/self.tke_ed_coeff*0.5*self.EnvVar.QTvar.values[k]/QT_lapse_rate**2),1000.0) + l2 = fmin(sqrt(self.tke_diss_coeff/self.tke_ed_coeff*self.EnvVar.TKE.values[k]/shear),1000.0) + l3 = 10000.0 # GCM grid box + self.mixing_length[k] = smooth_minimum(fabs(l1/self.zi),fabs(l2/self.zi),fabs(l3/self.zi),1.0) # + #self.mixing_length[k] = smooth_minimum(fabs(l1/self.zi),fabs(l2/self.zi),fabs(l3/self.zi),fabs(l4/self.zi),fabs(l5/self.zi),10.0) + self.mixing_length[k] = self.zi*self.mixing_length[k] else: with nogil: for k in xrange(gw, self.Gr.nzg-gw): @@ -813,7 +817,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): #with nogil: for i in xrange(self.n_updrafts): input.zi = self.UpdVar.cloud_base[i] - Poisson_rand = np.random.poisson(4,100).astype(np.float) + Poisson_rand = np.random.poisson(10.0,self.Gr.nzg).astype(np.float) + Poisson_rand= np.clip(Poisson_rand,0.01,100.0) for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): input.b = self.UpdVar.B.values[i,k] input.b_mean = GMV.B.values[k] @@ -836,7 +841,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): input.p0 = self.Ref.p0_half[k] input.alpha0 = self.Ref.alpha0_half[k] input.tke_ed_coeff = self.tke_ed_coeff - input.Poisson_rand = (Poisson_rand[i]-5.0)/10.0 + input.Poisson_rand = Poisson_rand[k]/10.0 input.L = 20000.0 # need to define the scale of the GCM grid resolution ret = self.entr_detr_fp(input) self.entr_sc[i,k] = ret.entr_sc * self.entrainment_factor diff --git a/turbulence_functions.pxd b/turbulence_functions.pxd index df92209b..c32ae52c 100644 --- a/turbulence_functions.pxd +++ b/turbulence_functions.pxd @@ -6,8 +6,6 @@ cdef struct evap_struct: double T double ql - - cdef struct entr_in_struct: double zi double wstar @@ -41,11 +39,9 @@ cdef entr_struct entr_detr_dry(entr_in_struct entr_in) nogil cdef entr_struct entr_detr_inverse_z(entr_in_struct entr_in) nogil cdef entr_struct entr_detr_inverse_w(entr_in_struct entr_in) nogil cdef entr_struct entr_detr_b_w2(entr_in_struct entr_in) nogil -cdef entr_struct entr_detr_buoyancy_sorting(entr_in_struct entr_in) nogil cdef evap_struct evap_sat_adjust(double p0, double thetal_, double qt_mix) nogil - - +cdef double entr_detr_buoyancy_sorting(entr_in_struct entr_in) nogil cdef double get_wstar(double bflux, double zi ) cdef double get_inversion(double *theta_rho, double *u, double *v, double *z_half, Py_ssize_t kmin, Py_ssize_t kmax, double Ri_bulk_crit) diff --git a/turbulence_functions.pyx b/turbulence_functions.pyx index f379c729..84a946a5 100644 --- a/turbulence_functions.pyx +++ b/turbulence_functions.pyx @@ -1,6 +1,6 @@ import numpy as np cimport numpy as np -from libc.math cimport cbrt, sqrt, log, fabs,atan, exp, fmax, pow, fmin, tanh +from libc.math cimport cbrt, sqrt, log, fabs,atan, exp, fmax, pow, fmin, tanh, erf from cpython.mem cimport PyMem_Malloc, PyMem_Realloc, PyMem_Free include "parameters.pxi" from thermodynamic_functions cimport * @@ -27,73 +27,24 @@ cdef entr_struct entr_detr_inverse_z(entr_in_struct entr_in) nogil: cdef entr_struct entr_detr_inverse_w(entr_in_struct entr_in) nogil: cdef: entr_struct _ret - double tau = get_mixing_tau(entr_in.zi, entr_in.wstar) - # in cloud portion from Soares 2004 - if entr_in.z >= entr_in.zi : - _ret.detr_sc= 3.0e-3 - else: - _ret.detr_sc = 0.0 - - _ret.entr_sc = 1.0/(tau * fmax(entr_in.w,0.1)) #sets baseline to avoid errors - return _ret - -cdef entr_struct entr_detr_buoyancy_sorting(entr_in_struct entr_in) nogil: - cdef: - entr_struct _ret - double wdw_mix, wdw_env, a1 w_mix = (entr_in.w+entr_in.w_env)/2 - dw_mix = (entr_in.dw+entr_in.dw_env)/2 - T_mean = (entr_in.T_up+entr_in.T_env)/2 - qt_mix = (entr_in.qt_up+entr_in.qt_env)/2 - ql_mix = (entr_in.ql_up+entr_in.ql_env)/2 - qv_mix = qt_mix-ql_mix - thetal_ = t_to_thetali_c(entr_in.p0, T_mean, qt_mix, ql_mix, 0.0) - - evap = evap_sat_adjust(entr_in.p0, thetal_, qt_mix) - qv_mix = qt_mix-evap.ql - Tmix = evap.T - alpha_mix = alpha_c(entr_in.p0, Tmix, qt_mix, qv_mix) - bmix = buoyancy_c(entr_in.alpha0, alpha_mix) - entr_in.b_mean + #eps_w = 1.0/(fmax(w_mix,1.0)* 500) + eps_w = 0.15*fabs(entr_in.b) / fmax(entr_in.w * entr_in.w, 1e-2) - alpha_env = alpha_c(entr_in.p0, entr_in.T_env, entr_in.qt_env, entr_in.qt_env-entr_in.ql_env) - alpha_up = alpha_c(entr_in.p0, entr_in.T_up, entr_in.qt_up, entr_in.qt_up-entr_in.ql_up) - b_env = buoyancy_c(entr_in.alpha0, alpha_env) - entr_in.b_mean - b_up = buoyancy_c(entr_in.alpha0, alpha_up) - entr_in.b_mean - wdw_mix = w_mix*dw_mix - #b_rel = b_up-b_env+(entr_in.w-entr_in.w_env)*(entr_in.w-entr_in.w_env)/40.0 - a1 = fabs(entr_in.Poisson_rand) - if bmix==0.0: - buoyancy_ratio = 0.0 - else: - buoyancy_ratio = (a1*bmix-(1-a1)*b_env)/fabs(bmix) - # with gil: - # print 'T', entr_in.T_up-entr_in.T_env - # print 'qt', entr_in.qt_up - entr_in.qt_env - # print 'ql', entr_in.ql_up-entr_in.ql_env - - # if entr_in.z < entr_in.zi and entr_in.zi < 9999.0: - # if buoyancy_ratio<0.0: - # with gil: - # print buoyancy_ratio - # print 'Tmix', bmix - # print 'T_env', b_env - - #eps_w = (0.12 * fabs(bmix) / fmax(w_mix* w_mix, 1e-2)) - eps_w = 0.1/(fmax(w_mix,1.0)* 280) - - wdw_env = entr_in.w_env*entr_in.dw_env - wdw_up = entr_in.w*entr_in.dw - - partiation_func = 1.0*(1.0+tanh(buoyancy_ratio))/2.0 if entr_in.af>0.0: - _ret.entr_sc = partiation_func*eps_w+(1-partiation_func)*1e-4 - _ret.detr_sc = (1.0-partiation_func)*eps_w+partiation_func*1e-4 + + partiation_func = entr_detr_buoyancy_sorting(entr_in) + #with gil: + # print partiation_func + _ret.entr_sc = partiation_func*eps_w/2.0 + _ret.detr_sc = (1.0-partiation_func/2.0)*eps_w else: _ret.entr_sc = 0.0 _ret.detr_sc = 0.0 return _ret + cdef entr_struct entr_detr_tke2(entr_in_struct entr_in) nogil: cdef entr_struct _ret # in cloud portion from Soares 2004 @@ -141,69 +92,67 @@ cdef entr_struct entr_detr_b_w2(entr_in_struct entr_in) nogil: return _ret - -cdef entr_struct entr_detr_buoyancy_sorting(entr_in_struct entr_in) nogil: + # w_mix = (entr_in.w+entr_in.w_env)/2 + # eps_w = 0.12* fabs(fmin(entr_in.b,0.0)) / fmax(entr_in.w * entr_in.w, 1e-2) + # + # if entr_in.af>0.0: + # + # partiation_func = entr_detr_buoyancy_sorting(entr_in) + # + # _ret.entr_sc = partiation_func*eps_w + # _ret.detr_sc = (1.0-partiation_func)*eps_w + # else: + # _ret.entr_sc = 0.0 + # _ret.detr_sc = 0.0 + # return _ret + + +cdef double entr_detr_buoyancy_sorting(entr_in_struct entr_in) nogil: cdef: - entr_struct _ret - double wdw_mix, wdw_env, a1 + + double wdw_mix, wdw_env, sigma, brel_mix, brel_env, w_env, dw_env + # take random fractions of upd and env air to mix w_mix = (entr_in.w+entr_in.w_env)/2 - dw_mix = (entr_in.dw+entr_in.dw_env)/2 T_mean = (entr_in.T_up+entr_in.T_env)/2 qt_mix = (entr_in.qt_up+entr_in.qt_env)/2 ql_mix = (entr_in.ql_up+entr_in.ql_env)/2 - qv_mix = qt_mix-ql_mix + dw_mix = (entr_in.dw+entr_in.dw_env)/2 + # calculate thermo. properties + #qv_mix = qt_mix-ql_mix thetal_ = t_to_thetali_c(entr_in.p0, T_mean, qt_mix, ql_mix, 0.0) - evap = evap_sat_adjust(entr_in.p0, thetal_, qt_mix) qv_mix = qt_mix-evap.ql Tmix = evap.T alpha_mix = alpha_c(entr_in.p0, Tmix, qt_mix, qv_mix) bmix = buoyancy_c(entr_in.alpha0, alpha_mix) - entr_in.b_mean - alpha_env = alpha_c(entr_in.p0, entr_in.T_env, entr_in.qt_env, entr_in.qt_env-entr_in.ql_env) alpha_up = alpha_c(entr_in.p0, entr_in.T_up, entr_in.qt_up, entr_in.qt_up-entr_in.ql_up) b_env = buoyancy_c(entr_in.alpha0, alpha_env) - entr_in.b_mean b_up = buoyancy_c(entr_in.alpha0, alpha_up) - entr_in.b_mean wdw_mix = w_mix*dw_mix - #b_rel = b_up-b_env+(entr_in.w-entr_in.w_env)*(entr_in.w-entr_in.w_env)/40.0 - a1 = fabs(entr_in.Poisson_rand) - if bmix==0.0: - buoyancy_ratio = 0.0 - else: - buoyancy_ratio = (a1*bmix-(1-a1)*b_env)/fabs(bmix) - # with gil: - # print 'T', entr_in.T_up-entr_in.T_env - # print 'qt', entr_in.qt_up - entr_in.qt_env - # print 'ql', entr_in.ql_up-entr_in.ql_env - - # if entr_in.z < entr_in.zi and entr_in.zi < 9999.0: - # if buoyancy_ratio<0.0: - # with gil: - # print buoyancy_ratio - # print 'Tmix', bmix - # print 'T_env', b_env - - #eps_w = (0.12 * fabs(bmix) / fmax(w_mix* w_mix, 1e-2)) - eps_w = 0.1/(fmax(w_mix,1.0)* 280) - wdw_env = entr_in.w_env*entr_in.dw_env wdw_up = entr_in.w*entr_in.dw - - partiation_func = 1.0*(1.0+tanh(buoyancy_ratio))/2.0 - if entr_in.af>0.0: - _ret.entr_sc = partiation_func*eps_w+(1-partiation_func)*1e-4 - _ret.detr_sc = (1.0-partiation_func)*eps_w+partiation_func*1e-4 - else: - _ret.entr_sc = 0.0 - _ret.detr_sc = 0.0 - return _ret + # b_rel = buoy + momentum + brel_mix = bmix# + wdw_mix + brel_env = b_env# + wdw_env + brel_up = b_up# + wdw_up + x0 = brel_mix/fabs(brel_env) + #sigma = entr_in.Poisson_rand*fmax(fabs((brel_mix-brel_up)/fabs(brel_env)),fabs((brel_mix-brel_env)/fabs(brel_env))) + sigma = entr_in.Poisson_rand*(brel_up-brel_env)/fabs(brel_env) + partiation_func = (1-erf((brel_env/fabs(brel_env)-x0)/(1.4142135623*sigma)))/2 + #with gil: + # print partiation_func, brel_env/fabs(brel_env), sigma, fabs((brel_mix-brel_up)/fabs(brel_env)), fabs((brel_mix-brel_env)/fabs(brel_env)) + + return partiation_func cdef evap_struct evap_sat_adjust(double p0, double thetal_, double qt_mix) nogil: cdef: evap_struct evap double ql_1, T_2, ql_2, f_1, f_2, qv_mix, T_1 - + if qt_mix>10.0: + with gil: + print qt_mix qv_mix = qt_mix ql = 0.0 diff --git a/utility_functions.pxd b/utility_functions.pxd index f00056fa..1a2de24d 100644 --- a/utility_functions.pxd +++ b/utility_functions.pxd @@ -1,5 +1,6 @@ cdef double interp2pt(double val1, double val2) nogil cdef double logistic(double x, double slope, double mid) nogil -cdef double smooth_minimum(double x1, double x2,double x3, double x4,double x5, double a) nogil +#cdef double smooth_minimum(double x1, double x2,double x3, double x4,double x5, double a) nogil +cdef double smooth_minimum(double x1, double x2 ,double x3, double a) nogil # cpdef double percentile_mean_norm(double percentile, Py_ssize_t nsamples) cpdef double percentile_bounds_mean_norm(double low_percentile, double high_percentile, Py_ssize_t nsamples) \ No newline at end of file diff --git a/utility_functions.pyx b/utility_functions.pyx index caa98bf7..e59a549d 100644 --- a/utility_functions.pyx +++ b/utility_functions.pyx @@ -27,7 +27,12 @@ cdef double interp2pt(double val1, double val2) nogil: cdef double logistic(double x, double slope, double mid) nogil: return 1.0/(1.0 + exp( -slope * (x-mid))) -cdef double smooth_minimum(double x1, double x2,double x3, double x4,double x5, double a) nogil: - smin = (x1*exp(-a*x1)+x2*exp(-a*x2)+x3*exp(-a*x3)+x4*exp(-a*x4)+x5*exp(-a*x5))\ - / (exp(-a*x1)+exp(-a*x2)+exp(-a*x3)+exp(-a*x4)+exp(-a*x5)) +# cdef double smooth_minimum(double x1, double x2,double x3, double x4,double x5, double a) nogil: +# smin = (x1*exp(-a*x1)+x2*exp(-a*x2)+x3*exp(-a*x3)+x4*exp(-a*x4)+x5*exp(-a*x5))\ +# / (exp(-a*x1)+exp(-a*x2)+exp(-a*x3)+exp(-a*x4)+exp(-a*x5)) +# return smin +cdef double smooth_minimum(double x1, double x2,double x3,double a) nogil: + smin = (x1*exp(-a*x1)+x2*exp(-a*x2)+x3*exp(-a*x3))/ (exp(-a*x1)+exp(-a*x2)+exp(-a*x3)) return smin + + From 0b486d3052f1806c413af07051b6e2fe613568f5 Mon Sep 17 00:00:00 2001 From: yairchn Date: Mon, 23 Jul 2018 12:02:04 -0700 Subject: [PATCH 011/136] first attempt --- EDMF_Environment.pyx | 48 ++--- EDMF_Updrafts.pyx | 28 +-- Grid.pyx | 2 +- Surface.pyx | 10 +- Turbulence.pyx | 18 +- Turbulence_PrognosticTKE.pyx | 369 +++++++++++++++++------------------ Variables.pyx | 50 ++--- 7 files changed, 257 insertions(+), 268 deletions(-) diff --git a/EDMF_Environment.pyx b/EDMF_Environment.pyx index b451a9f3..32e62826 100644 --- a/EDMF_Environment.pyx +++ b/EDMF_Environment.pyx @@ -207,11 +207,11 @@ cdef class EnvironmentThermodynamics: inner_int_T_dry = 0.0 for m_h in xrange(self.quadrature_order): h_hat = sqrt2 * sigma_h_star * abscissas[m_h] + mu_h_star - sa = eos(self.t_to_prog_fp,self.prog_to_t_fp, self.Ref.p0_half[k], qt_hat, h_hat) + sa = eos(self.t_to_prog_fp,self.prog_to_t_fp, self.Ref.p0[k], qt_hat, h_hat) temp_m = sa.T ql_m = sa.ql qv_m = EnvVar.QT.values[k] - ql_m - alpha_m = alpha_c(self.Ref.p0_half[k], temp_m, qt_hat, qv_m) + alpha_m = alpha_c(self.Ref.p0[k], temp_m, qt_hat, qv_m) inner_int_ql += ql_m * weights[m_h] * sqpi_inv inner_int_T += temp_m * weights[m_h] * sqpi_inv inner_int_alpha += alpha_m * weights[m_h] * sqpi_inv @@ -235,16 +235,16 @@ cdef class EnvironmentThermodynamics: outer_int_T_dry += inner_int_T_dry * weights[m_q] * sqpi_inv # anna's fix (changed outer to inner) EnvVar.QL.values[k] = outer_int_ql - EnvVar.B.values[k] = g * (outer_int_alpha - self.Ref.alpha0_half[k])/self.Ref.alpha0_half[k] #- GMV_B.values[k] + EnvVar.B.values[k] = g * (outer_int_alpha - self.Ref.alpha0[k])/self.Ref.alpha0[k] #- GMV_B.values[k] EnvVar.T.values[k] = outer_int_T EnvVar.CF.values[k] = outer_int_cf - EnvVar.THL.values[k] = t_to_thetali_c(self.Ref.p0_half[k], EnvVar.T.values[k], EnvVar.QT.values[k], EnvVar.QL.values[k], 0.0) # anna's fix + EnvVar.THL.values[k] = t_to_thetali_c(self.Ref.p0[k], EnvVar.T.values[k], EnvVar.QT.values[k], EnvVar.QL.values[k], 0.0) # anna's fix self.qt_dry[k] = outer_int_qt_dry - self.th_dry[k] = outer_int_T_dry/exner_c(self.Ref.p0_half[k]) + self.th_dry[k] = outer_int_T_dry/exner_c(self.Ref.p0[k]) self.t_cloudy[k] = outer_int_T_cloudy self.qv_cloudy[k] = outer_int_qt_cloudy - outer_int_ql self.qt_cloudy[k] = outer_int_qt_cloudy - self.th_cloudy[k] = outer_int_T_cloudy/exner_c(self.Ref.p0_half[k]) + self.th_cloudy[k] = outer_int_T_cloudy/exner_c(self.Ref.p0[k]) elif EnvVar.H.name == 's': @@ -279,12 +279,12 @@ cdef class EnvironmentThermodynamics: inner_int_T_dry = 0.0 for m_h in xrange(self.quadrature_order): h_hat = sqrt2 * sigma_h_star * abscissas[m_h] + mu_h_star - sa = eos(self.t_to_prog_fp,self.prog_to_t_fp, self.Ref.p0_half[k], qt_hat, h_hat) + sa = eos(self.t_to_prog_fp,self.prog_to_t_fp, self.Ref.p0[k], qt_hat, h_hat) temp_m = sa.T ql_m = sa.ql qv_m = EnvVar.QT.values[k] - ql_m - alpha_m = alpha_c(self.Ref.p0_half[k], temp_m, qt_hat, qv_m) - #thetal_m = t_to_thetali_c(self.Ref.p0_half[k], temp_m, qt_hat, ql_m, 0.0) + alpha_m = alpha_c(self.Ref.p0[k], temp_m, qt_hat, qv_m) + #thetal_m = t_to_thetali_c(self.Ref.p0[k], temp_m, qt_hat, ql_m, 0.0) inner_int_ql += ql_m * weights[m_h] * sqpi_inv inner_int_T += temp_m * weights[m_h] * sqpi_inv inner_int_alpha += alpha_m * weights[m_h] * sqpi_inv @@ -306,15 +306,15 @@ cdef class EnvironmentThermodynamics: EnvVar.QL.values[k] = outer_int_ql - EnvVar.B.values[k] = g * (outer_int_alpha - self.Ref.alpha0_half[k])/self.Ref.alpha0_half[k] # - GMV_B.values[k] + EnvVar.B.values[k] = g * (outer_int_alpha - self.Ref.alpha0[k])/self.Ref.alpha0[k] # - GMV_B.values[k] EnvVar.T.values[k] = outer_int_T EnvVar.CF.values[k] = outer_int_cf self.qt_dry[k] = outer_int_qt_dry - self.th_dry[k] = outer_int_T_dry/exner_c(self.Ref.p0_half[k]) + self.th_dry[k] = outer_int_T_dry/exner_c(self.Ref.p0[k]) self.t_cloudy[k] = outer_int_T_cloudy self.qv_cloudy[k] = outer_int_qt_cloudy - outer_int_ql self.qt_cloudy[k] = outer_int_qt_cloudy - self.t_cloudy[k] = outer_int_T_cloudy/exner_c(self.Ref.p0_half[k]) + self.t_cloudy[k] = outer_int_T_cloudy/exner_c(self.Ref.p0[k]) return cdef void sommeria_deardorff(self, EnvironmentVariables EnvVar): @@ -331,7 +331,7 @@ cdef class EnvironmentThermodynamics: Lv = latent_heat(EnvVar.T.values[k]) cp = cpd # paper notation used below - Tl = EnvVar.H.values[k]*exner_c(self.Ref.p0_half[k]) + Tl = EnvVar.H.values[k]*exner_c(self.Ref.p0[k]) q_sl = qv_star_t(self.Ref.p0[k], Tl) # using the qv_star_c function instead of the approximation in eq. (4) in SD beta1 = 0.622*Lv**2/(Rd*cp*Tl**2) # eq. (8) in SD #q_s = q_sl*(1+beta1*EnvVar.QT.values[k])/(1+beta1*q_sl) # eq. (7) in SD @@ -356,17 +356,17 @@ cdef class EnvironmentThermodynamics: EnvVar.T.values[k] = Tl + Lv/cp*EnvVar.QL.values[k] # should this be the differnece in ql - would it work for evaporation as well ? EnvVar.CF.values[k] = R qv = EnvVar.QT.values[k] - EnvVar.QL.values[k] - alpha = alpha_c(self.Ref.p0_half[k], EnvVar.T.values[k], EnvVar.QT.values[k], qv) - EnvVar.B.values[k] = buoyancy_c(self.Ref.alpha0_half[k], alpha) #- GMV.B.values[k] - EnvVar.THL.values[k] = t_to_thetali_c(self.Ref.p0_half[k], EnvVar.T.values[k], EnvVar.QT.values[k], + alpha = alpha_c(self.Ref.p0[k], EnvVar.T.values[k], EnvVar.QT.values[k], qv) + EnvVar.B.values[k] = buoyancy_c(self.Ref.alpha0[k], alpha) #- GMV.B.values[k] + EnvVar.THL.values[k] = t_to_thetali_c(self.Ref.p0[k], EnvVar.T.values[k], EnvVar.QT.values[k], EnvVar.QL.values[k], 0.0) self.qt_dry[k] = EnvVar.QT.values[k] - self.th_dry[k] = EnvVar.T.values[k]/exner_c(self.Ref.p0_half[k]) + self.th_dry[k] = EnvVar.T.values[k]/exner_c(self.Ref.p0[k]) self.t_cloudy[k] = EnvVar.T.values[k] self.qv_cloudy[k] = EnvVar.QT.values[k] - EnvVar.QL.values[k] self.qt_cloudy[k] = EnvVar.QT.values[k] - self.th_cloudy[k] = EnvVar.T.values[k]/exner_c(self.Ref.p0_half[k]) + self.th_cloudy[k] = EnvVar.T.values[k]/exner_c(self.Ref.p0[k]) #using the approximation in eq. (25) in SD, noting that in the paper there is a typo in the first @@ -402,22 +402,22 @@ cdef class EnvironmentThermodynamics: else: with nogil: for k in xrange(gw,self.Gr.nzg-gw): - sa = eos(self.t_to_prog_fp,self.prog_to_t_fp, self.Ref.p0_half[k], EnvVar.QT.values[k], EnvVar.H.values[k]) + sa = eos(self.t_to_prog_fp,self.prog_to_t_fp, self.Ref.p0[k], EnvVar.QT.values[k], EnvVar.H.values[k]) EnvVar.QL.values[k] = sa.ql EnvVar.T.values[k] = sa.T qv = EnvVar.QT.values[k] - EnvVar.QL.values[k] - alpha = alpha_c(self.Ref.p0_half[k], EnvVar.T.values[k], EnvVar.QT.values[k], qv) - EnvVar.B.values[k] = buoyancy_c(self.Ref.alpha0_half[k], alpha) #- GMV.B.values[k] - EnvVar.THL.values[k] = t_to_thetali_c(self.Ref.p0_half[k], EnvVar.T.values[k], EnvVar.QT.values[k], + alpha = alpha_c(self.Ref.p0[k], EnvVar.T.values[k], EnvVar.QT.values[k], qv) + EnvVar.B.values[k] = buoyancy_c(self.Ref.alpha0[k], alpha) #- GMV.B.values[k] + EnvVar.THL.values[k] = t_to_thetali_c(self.Ref.p0[k], EnvVar.T.values[k], EnvVar.QT.values[k], EnvVar.QL.values[k], 0.0) if EnvVar.QL.values[k] > 0.0: EnvVar.CF.values[k] = 1.0 else: EnvVar.CF.values[k] = 0.0 self.qt_dry[k] = EnvVar.QT.values[k] - self.th_dry[k] = EnvVar.T.values[k]/exner_c(self.Ref.p0_half[k]) + self.th_dry[k] = EnvVar.T.values[k]/exner_c(self.Ref.p0[k]) self.t_cloudy[k] = EnvVar.T.values[k] self.qv_cloudy[k] = EnvVar.QT.values[k] - EnvVar.QL.values[k] self.qt_cloudy[k] = EnvVar.QT.values[k] - self.th_cloudy[k] = EnvVar.T.values[k]/exner_c(self.Ref.p0_half[k]) + self.th_cloudy[k] = EnvVar.T.values[k]/exner_c(self.Ref.p0[k]) return \ No newline at end of file diff --git a/EDMF_Updrafts.pyx b/EDMF_Updrafts.pyx index 3adb992d..cab0db4a 100644 --- a/EDMF_Updrafts.pyx +++ b/EDMF_Updrafts.pyx @@ -249,8 +249,8 @@ cdef class UpdraftVariables: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): if self.QL.bulkvalues[k] >0.0: cloud_cover = fmax(cloud_cover, self.Area.bulkvalues[k]) - cloud_base = fmin(cloud_base,self.Gr.z_half[k]) - cloud_top = fmax(cloud_top, self.Gr.z_half[k]) + cloud_base = fmin(cloud_base,self.Gr.z[k]) + cloud_top = fmax(cloud_top, self.Gr.z[k]) Stats.write_ts('cloud_cover', cloud_cover) Stats.write_ts('cloud_base', cloud_base) Stats.write_ts('cloud_top', cloud_top) @@ -265,8 +265,8 @@ cdef class UpdraftVariables: self.cloud_top[i] = -99999.0 for k in xrange(self.Gr.gw,self.Gr.nzg-self.Gr.gw): if self.QL.values[i,k] > 0.0: - self.cloud_base[i] = fmin(self.cloud_base[i], self.Gr.z_half[k]) - self.cloud_top[i] = fmax(self.cloud_top[i], self.Gr.z_half[k]) + self.cloud_base[i] = fmin(self.cloud_base[i], self.Gr.z[k]) + self.cloud_top[i] = fmax(self.cloud_top[i], self.Gr.z[k]) return @@ -293,7 +293,7 @@ cdef class UpdraftThermodynamics: with nogil: for i in xrange(self.n_updraft): for k in xrange(self.Gr.nzg): - sa = eos(self.t_to_prog_fp,self.prog_to_t_fp, self.Ref.p0_half[k], + sa = eos(self.t_to_prog_fp,self.prog_to_t_fp, self.Ref.p0[k], UpdVar.QT.values[i,k], UpdVar.H.values[i,k]) UpdVar.QL.values[i,k] = sa.ql UpdVar.T.values[i,k] = sa.T @@ -313,8 +313,8 @@ cdef class UpdraftThermodynamics: for i in xrange(self.n_updraft): for k in xrange(self.Gr.nzg): qv = UpdVar.QT.values[i,k] - UpdVar.QL.values[i,k] - alpha = alpha_c(self.Ref.p0_half[k], UpdVar.T.values[i,k], UpdVar.QT.values[i,k], qv) - UpdVar.B.values[i,k] = buoyancy_c(self.Ref.alpha0_half[k], alpha) #- GMV.B.values[k] + alpha = alpha_c(self.Ref.p0[k], UpdVar.T.values[i,k], UpdVar.QT.values[i,k], qv) + UpdVar.B.values[i,k] = buoyancy_c(self.Ref.alpha0[k], alpha) #- GMV.B.values[k] else: with nogil: for i in xrange(self.n_updraft): @@ -324,17 +324,17 @@ cdef class UpdraftThermodynamics: qv = UpdVar.QT.values[i,k] - UpdVar.QL.values[i,k] h = UpdVar.H.values[i,k] t = UpdVar.T.values[i,k] - alpha = alpha_c(self.Ref.p0_half[k], t, qt, qv) - UpdVar.B.values[i,k] = buoyancy_c(self.Ref.alpha0_half[k], alpha) + alpha = alpha_c(self.Ref.p0[k], t, qt, qv) + UpdVar.B.values[i,k] = buoyancy_c(self.Ref.alpha0[k], alpha) else: - sa = eos(self.t_to_prog_fp, self.prog_to_t_fp, self.Ref.p0_half[k], + sa = eos(self.t_to_prog_fp, self.prog_to_t_fp, self.Ref.p0[k], qt, h) qt -= sa.ql qv = qt t = sa.T - alpha = alpha_c(self.Ref.p0_half[k], t, qt, qv) - UpdVar.B.values[i,k] = buoyancy_c(self.Ref.alpha0_half[k], alpha) + alpha = alpha_c(self.Ref.p0[k], t, qt, qv) + UpdVar.B.values[i,k] = buoyancy_c(self.Ref.alpha0[k], alpha) with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): GMV.B.values[k] = (1.0 - UpdVar.Area.bulkvalues[k]) * EnvVar.B.values[k] @@ -370,10 +370,10 @@ cdef class UpdraftMicrophysics: for k in xrange(self.Gr.nzg): lh = latent_heat(UpdVar.T.values[i,k]) psat = pv_star(UpdVar.T.values[i,k]) - qsat = qv_star_c(self.Ref.p0_half[k], UpdVar.QT.values[i,k], psat) + qsat = qv_star_c(self.Ref.p0[k], UpdVar.QT.values[i,k], psat) self.prec_source_qt[i,k] = -fmax(0.0, UpdVar.QL.values[i,k] - self.max_supersaturation*qsat ) - self.prec_source_h[i,k] = -self.prec_source_qt[i,k] /exner_c(self.Ref.p0_half[k]) * lh/cpd + self.prec_source_h[i,k] = -self.prec_source_qt[i,k] /exner_c(self.Ref.p0[k]) * lh/cpd self.prec_source_h_tot = np.sum(np.multiply(self.prec_source_h,UpdVar.Area.values), axis=0) diff --git a/Grid.pyx b/Grid.pyx index fae7575b..f1901e3c 100644 --- a/Grid.pyx +++ b/Grid.pyx @@ -40,7 +40,7 @@ cdef class Grid: cdef int i, count = 0 for i in xrange(-self.gw,self.nz+self.gw,1): self.z[count] = (i + 1) * self.dz - self.z_half[count] = (i+0.5)*self.dz + self.z_half[count] = self.z[count] count += 1 diff --git a/Surface.pyx b/Surface.pyx index a2969b84..df9c905d 100644 --- a/Surface.pyx +++ b/Surface.pyx @@ -35,8 +35,8 @@ cdef class SurfaceBase: with nogil: for k in xrange(self.Gr.nzg): qv = GMV.QT.values[k] - GMV.QL.values[k] - theta_rho[k] = theta_rho_c(self.Ref.p0_half[k], GMV.T.values[k], GMV.QT.values[k], qv) - zi = get_inversion(&theta_rho[0], &GMV.U.values[0], &GMV.V.values[0], &self.Gr.z_half[0], kmin, kmax, self.Ri_bulk_crit) + theta_rho[k] = theta_rho_c(self.Ref.p0[k], GMV.T.values[k], GMV.QT.values[k], qv) + zi = get_inversion(&theta_rho[0], &GMV.U.values[0], &GMV.V.values[0], &self.Gr.z[0], kmin, kmax, self.Ri_bulk_crit) wstar = get_wstar(self.bflux, zi) # yair here zi in TRMM should be adjusted self.windspeed = np.sqrt(self.windspeed*self.windspeed + (1.2 *wstar)*(1.2 * wstar) ) return @@ -61,7 +61,7 @@ cdef class SurfaceFixedFlux(SurfaceBase): self.rho_hflux = rho_tflux / exner_c(self.Ref.Pg) elif GMV.H.name == 's': self.rho_hflux = entropy_flux(rho_tflux/self.Ref.rho0[gw-1],self.rho_qtflux/self.Ref.rho0[gw-1], - self.Ref.p0_half[gw], GMV.T.values[gw], GMV.QT.values[gw]) + self.Ref.p0[gw], GMV.T.values[gw], GMV.QT.values[gw]) self.bflux = buoyancy_flux(self.shf, self.lhf, GMV.T.values[gw], GMV.QT.values[gw],self.Ref.alpha0[gw-1] ) if not self.ustar_fixed: @@ -80,7 +80,7 @@ cdef class SurfaceFixedFlux(SurfaceBase): print('GMV.QT.values[gw] ==>',GMV.QT.values[gw]) print('self.Ref.alpha0[gw-1] ==>',self.Ref.alpha0[gw-1]) - self.ustar = compute_ustar(self.windspeed, self.bflux, self.zrough, self.Gr.z_half[gw]) + self.ustar = compute_ustar(self.windspeed, self.bflux, self.zrough, self.Gr.z[gw]) self.obukhov_length = -self.ustar *self.ustar *self.ustar /self.bflux /vkb self.rho_uflux = - self.Ref.rho0[gw-1] * self.ustar * self.ustar / self.windspeed * GMV.U.values[gw] @@ -122,7 +122,7 @@ cdef class SurfaceFixedCoeffs(SurfaceBase): elif GMV.H.name == 's': self.rho_hflux = -self.ch * windspeed * (GMV.H.values[gw] - self.s_surface) * self.Ref.rho0[gw-1] pv = pv_star(GMV.T.values[gw]) - pd = self.Ref.p0_half[gw] - pv + pd = self.Ref.p0[gw] - pv sv = sv_c(pv,GMV.T.values[gw]) sd = sd_c(pd, GMV.T.values[gw]) self.shf = (self.rho_hflux - self.lhf/lv * (sv-sd)) * GMV.T.values[gw] diff --git a/Turbulence.pyx b/Turbulence.pyx index 7ff232d2..a046db84 100644 --- a/Turbulence.pyx +++ b/Turbulence.pyx @@ -85,14 +85,14 @@ cdef class ParameterizationBase: with nogil: for k in xrange(gw, self.Gr.nzg-gw): qv = GMV.QT.values[k] - GMV.QL.values[k] - theta_rho[k] = theta_rho_c(self.Ref.p0_half[k], GMV.T.values[k], GMV.QT.values[k], qv) + theta_rho[k] = theta_rho_c(self.Ref.p0[k], GMV.T.values[k], GMV.QT.values[k], qv) if option == 'theta_rho': with nogil: for k in xrange(kmin,kmax): if theta_rho[k] > theta_rho[kmin]: - self.zi = self.Gr.z_half[k] + self.zi = self.Gr.z[k] break elif option == 'thetal_maxgrad': @@ -103,7 +103,7 @@ cdef class ParameterizationBase: maxgrad = grad self.zi = self.Gr.z[k] elif option == 'critical_Ri': - self.zi = get_inversion(&theta_rho[0], &GMV.U.values[0], &GMV.V.values[0], &self.Gr.z_half[0], kmin, kmax, self.Ri_bulk_crit) + self.zi = get_inversion(&theta_rho[0], &GMV.U.values[0], &GMV.V.values[0], &self.Gr.z[0], kmin, kmax, self.Ri_bulk_crit) else: print('INVERSION HEIGHT OPTION NOT RECOGNIZED') @@ -129,7 +129,7 @@ cdef class ParameterizationBase: with nogil: for k in xrange(gw,nzg-gw): - zzi = self.Gr.z_half[k]/self.zi + zzi = self.Gr.z[k]/self.zi if zzi <= 1.0: self.KH.values[k] = vkb * ( (ustar/self.wstar)**3 + 39.0*vkb*zzi)**(1.0/3.0) * zzi * (1.0-zzi) * (1.0-zzi) * self.wstar * self.zi self.KM.values[k] = self.KH.values[k] * self.prandtl_number @@ -196,13 +196,13 @@ cdef class SimilarityED(ParameterizationBase): # Matrix is the same for all variables that use the same eddy diffusivity construct_tridiag_diffusion(nzg, gw, self.Gr.dzi, TS.dt, &rho_K_m[0], - &self.Ref.rho0_half[0], &dummy_ae[0] ,&a[0], &b[0], &c[0]) + &self.Ref.rho0[0], &dummy_ae[0] ,&a[0], &b[0], &c[0]) # Solve QT with nogil: for k in xrange(nz): x[k] = GMV.QT.values[k+gw] - x[0] = x[0] + TS.dt * Case.Sur.rho_qtflux * self.Gr.dzi * self.Ref.alpha0_half[gw] + x[0] = x[0] + TS.dt * Case.Sur.rho_qtflux * self.Gr.dzi * self.Ref.alpha0[gw] tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) with nogil: @@ -214,7 +214,7 @@ cdef class SimilarityED(ParameterizationBase): with nogil: for k in xrange(nz): x[k] = GMV.H.values[k+gw] - x[0] = x[0] + TS.dt * Case.Sur.rho_hflux * self.Gr.dzi * self.Ref.alpha0_half[gw] + x[0] = x[0] + TS.dt * Case.Sur.rho_hflux * self.Gr.dzi * self.Ref.alpha0[gw] tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) with nogil: @@ -226,7 +226,7 @@ cdef class SimilarityED(ParameterizationBase): with nogil: for k in xrange(nz): x[k] = GMV.U.values[k+gw] - x[0] = x[0] + TS.dt * Case.Sur.rho_uflux * self.Gr.dzi * self.Ref.alpha0_half[gw] + x[0] = x[0] + TS.dt * Case.Sur.rho_uflux * self.Gr.dzi * self.Ref.alpha0[gw] tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) with nogil: @@ -237,7 +237,7 @@ cdef class SimilarityED(ParameterizationBase): with nogil: for k in xrange(nz): x[k] = GMV.V.values[k+gw] - x[0] = x[0] + TS.dt * Case.Sur.rho_vflux * self.Gr.dzi * self.Ref.alpha0_half[gw] + x[0] = x[0] + TS.dt * Case.Sur.rho_vflux * self.Gr.dzi * self.Ref.alpha0[gw] tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) with nogil: diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 861a24c7..10ea1df8 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -246,9 +246,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Stats.write_profile('eddy_diffusivity', self.KH.values[self.Gr.gw:self.Gr.nzg-self.Gr.gw]) with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - mf_h[k] = interp2pt(self.massflux_h[k], self.massflux_h[k-1]) - mf_qt[k] = interp2pt(self.massflux_qt[k], self.massflux_qt[k-1]) - massflux[k] = interp2pt(self.m[0,k], self.m[0,k-1]) + mf_h[k] = self.massflux_h[k] + mf_qt[k] = self.massflux_qt[k] + massflux[k] = self.m[0,k] if self.UpdVar.Area.bulkvalues[k] > 0.0: for i in xrange(self.n_updrafts): mean_entr_sc[k] += self.UpdVar.Area.values[i,k] * self.entr_sc[i,k]/self.UpdVar.Area.bulkvalues[k] @@ -392,11 +392,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.H.values[i,gw] = self.h_surface_bc[i] self.UpdVar.QT.values[i,gw] = self.qt_surface_bc[i] # Find the cloud liquid content - sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_half[gw], + sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0[gw], self.UpdVar.QT.values[i,gw], self.UpdVar.H.values[i,gw]) self.UpdVar.QL.values[i,gw] = sa.ql self.UpdVar.T.values[i,gw] = sa.T - self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0_half[gw], self.UpdVar.T.values[i,gw], + self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0[gw], self.UpdVar.T.values[i,gw], &self.UpdVar.QT.values[i,gw], &self.UpdVar.QL.values[i,gw], &self.UpdVar.H.values[i,gw], i, gw) for k in xrange(gw+1, self.Gr.nzg-gw): @@ -405,11 +405,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.QT.values[i,k] = (self.UpdVar.QT.values[i,k-1] + self.entr_sc[i,k] * dz * GMV.QT.values[k])/denom - sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_half[k], + sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0[k], self.UpdVar.QT.values[i,k], self.UpdVar.H.values[i,k]) self.UpdVar.QL.values[i,k] = sa.ql self.UpdVar.T.values[i,k] = sa.T - self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0_half[k], self.UpdVar.T.values[i,k], + self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0[k], self.UpdVar.T.values[i,k], &self.UpdVar.QT.values[i,k], &self.UpdVar.QL.values[i,k], &self.UpdVar.H.values[i,k], i, k) @@ -426,12 +426,12 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.entr_sc[i,gw] = 2.0 /dz self.detr_sc[i,gw] = 0.0 for k in range(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - area_k = interp2pt(self.UpdVar.Area.values[i,k], self.UpdVar.Area.values[i,k+1]) + area_k = self.UpdVar.Area.values[i,k] if area_k >= self.minimum_area: w_km = self.UpdVar.W.values[i,k-1] - entr_w = interp2pt(self.entr_sc[i,k], self.entr_sc[i,k+1]) - detr_w = interp2pt(self.detr_sc[i,k], self.detr_sc[i,k+1]) - B_k = interp2pt(self.UpdVar.B.values[i,k], self.UpdVar.B.values[i,k+1]) + entr_w = self.entr_sc[i,k] + detr_w = self.detr_sc[i,k] + B_k = self.UpdVar.B.values[i,k] w2 = ((self.vel_buoy_coeff * B_k + 0.5 * w_km * w_km * dzi) /(0.5 * dzi +entr_w + self.vel_pressure_coeff/sqrt(fmax(area_k,self.minimum_area)))) if w2 > 0.0: @@ -455,24 +455,24 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): w_mid = 0.5* (self.UpdVar.W.values[i,gw]) for k in xrange(gw+1, self.Gr.nzg): w_low = w_mid - w_mid = interp2pt(self.UpdVar.W.values[i,k],self.UpdVar.W.values[i,k-1]) + w_mid = self.UpdVar.W.values[i,k] if w_mid > 0.0: if self.entr_sc[i,k]>(0.9/dz): self.entr_sc[i,k] = 0.9/dz - self.UpdVar.Area.values[i,k] = (self.Ref.rho0_half[k-1]*self.UpdVar.Area.values[i,k-1]*w_low/ - (1.0-(self.entr_sc[i,k]-self.detr_sc[i,k])*dz)/w_mid/self.Ref.rho0_half[k]) + self.UpdVar.Area.values[i,k] = (self.Ref.rho0[k-1]*self.UpdVar.Area.values[i,k-1]*w_low/ + (1.0-(self.entr_sc[i,k]-self.detr_sc[i,k])*dz)/w_mid/self.Ref.rho0[k]) # # Limit the increase in updraft area when the updraft decelerates if self.UpdVar.Area.values[i,k] > au_lim: self.UpdVar.Area.values[i,k] = au_lim - self.detr_sc[i,k] =(self.Ref.rho0_half[k-1] * self.UpdVar.Area.values[i,k-1] - * w_low / au_lim / w_mid / self.Ref.rho0_half[k] + self.entr_sc[i,k] * dz -1.0)/dz + self.detr_sc[i,k] =(self.Ref.rho0[k-1] * self.UpdVar.Area.values[i,k-1] + * w_low / au_lim / w_mid / self.Ref.rho0[k] + self.entr_sc[i,k] * dz -1.0)/dz else: # the updraft has terminated so set its area fraction to zero at this height and all heights above self.UpdVar.Area.values[i,k] = 0.0 self.UpdVar.H.values[i,k] = GMV.H.values[k] self.UpdVar.QT.values[i,k] = GMV.QT.values[k] - sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_half[k], + sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0[k], self.UpdVar.QT.values[i,k], self.UpdVar.H.values[i,k]) self.UpdVar.QL.values[i,k] = sa.ql self.UpdVar.T.values[i,k] = sa.T @@ -512,7 +512,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): if ws > 0.0: with nogil: for k in xrange(self.Gr.nzg): - z = self.Gr.z_half[k] + z = self.Gr.z[k] GMV.TKE.values[k] = ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) @@ -532,25 +532,21 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double tau = get_mixing_tau(self.zi, self.wstar) double l1, l2, l3, l4, l5, l234, z_ double grad, grad2, H - double du_high = 0.0 - double dv_high = 0.0 - double dw_high = 2.0 * self.EnvVar.W.values[gw] * self.Gr.dzi - double du_low, dv_low, dw_low, H_lapse_rate ,QT_lapse_rate + double du = 0.0 + double dv = 0.0 + double dw = 2.0 * self.EnvVar.W.values[gw] * self.Gr.dzi + double H_lapse_rate ,QT_lapse_rate if self.mixing_length_fp=='Ellison_scale': with nogil: for k in xrange(gw, self.Gr.nzg-gw): - du_low = du_high - dv_low = dv_high - dw_low = dw_high - du_high = (GMV.U.values[k+1] - GMV.U.values[k]) * self.Gr.dzi - dv_high = (GMV.V.values[k+1] - GMV.V.values[k]) * self.Gr.dzi - dw_high = (self.EnvVar.W.values[k+1] - self.EnvVar.W.values[k]) * self.Gr.dzi - shear = fmax(fabs( pow(interp2pt(du_low, du_high),2.0) + pow(interp2pt(dv_low, dv_high),2.0)+ - pow(interp2pt(dw_low, dw_high),2.0)),1e-10) + du = (GMV.U.values[k+1] - GMV.U.values[k]) * self.Gr.dzi + dv = (GMV.V.values[k+1] - GMV.V.values[k]) * self.Gr.dzi + dw = (self.EnvVar.W.values[k+1] - self.EnvVar.W.values[k]) * self.Gr.dzi + shear = fmax(fabs( pow(du,2.0) + pow(dv,2.0)+pow(dw,2.0)),1e-10) H_lapse_rate = fmax(fabs((self.EnvVar.H.values[k+1]-self.EnvVar.H.values[k-1])*0.5*self.Gr.dzi),1e-30) QT_lapse_rate = fmax(fabs((self.EnvVar.QT.values[k+1]-self.EnvVar.QT.values[k-1])*0.5*self.Gr.dzi),1e-30) - l1 = vkb * self.Gr.z_half[k] + l1 = vkb * self.Gr.z[k] #l2 = fmin(sqrt(self.tke_diss_coeff/self.tke_ed_coeff*0.5*self.EnvVar.Hvar.values[k]/H_lapse_rate**2),1000.0) #l2 = fmin(sqrt(self.tke_diss_coeff/self.tke_ed_coeff*0.5*self.EnvVar.QTvar.values[k]/QT_lapse_rate**2),1000.0) l2 = fmin(sqrt(self.tke_diss_coeff/self.tke_ed_coeff*self.EnvVar.TKE.values[k]/shear),1000.0) @@ -562,7 +558,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(gw, self.Gr.nzg-gw): l1 = tau * sqrt(fmax(self.EnvVar.TKE.values[k],0.0)) - z_ = self.Gr.z_half[k] + z_ = self.Gr.z[k] if obukhov_length < 0.0: #unstable l2 = vkb * z_ * ( (1.0 - 100.0 * z_/obukhov_length)**0.2 ) elif obukhov_length > 0.0: #stable @@ -577,7 +573,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Py_ssize_t k Py_ssize_t gw = self.Gr.gw double lm - double we_half + double we if self.similarity_diffusivity: ParameterizationBase.compute_eddy_diffusivities_similarity(self,GMV, Case) @@ -598,9 +594,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cdef: Py_ssize_t i, gw = self.Gr.gw - double zLL = self.Gr.z_half[gw] + double zLL = self.Gr.z[gw] double ustar = Case.Sur.ustar, oblength = Case.Sur.obukhov_length - double alpha0LL = self.Ref.alpha0_half[gw] + double alpha0LL = self.Ref.alpha0[gw] double qt_var = get_surface_variance(Case.Sur.rho_qtflux*alpha0LL, Case.Sur.rho_qtflux*alpha0LL, ustar, zLL, oblength) double h_var = get_surface_variance(Case.Sur.rho_hflux*alpha0LL, @@ -623,7 +619,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cpdef reset_surface_tke(self, GridMeanVariables GMV, CasesBase Case): GMV.TKE.values[self.Gr.gw] = get_surface_tke(Case.Sur.ustar, self.wstar, - self.Gr.z_half[self.Gr.gw], + self.Gr.z[self.Gr.gw], Case.Sur.obukhov_length) return @@ -632,9 +628,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): flux1 = Case.Sur.rho_hflux flux2 = Case.Sur.rho_qtflux cdef: - double zLL = self.Gr.z_half[self.Gr.gw] + double zLL = self.Gr.z[self.Gr.gw] double ustar = Case.Sur.ustar, oblength = Case.Sur.obukhov_length - double alpha0LL = self.Ref.alpha0_half[self.Gr.gw] + double alpha0LL = self.Ref.alpha0[self.Gr.gw] #double get_surface_variance = get_surface_variance(flux1, flux2 ,ustar, zLL, oblength) GMV.Hvar.values[self.Gr.gw] = get_surface_variance(flux1*alpha0LL,flux1*alpha0LL, ustar, zLL, oblength) @@ -660,7 +656,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): if whichvals == 'values': with nogil: - for k in xrange(self.Gr.nzg-1): + for k in xrange(self.Gr.nzg): val1 = 1.0/(1.0-self.UpdVar.Area.bulkvalues[k]) val2 = self.UpdVar.Area.bulkvalues[k] * val1 self.EnvVar.QT.values[k] = val1 * GMV.QT.values[k] - val2 * self.UpdVar.QT.bulkvalues[k] @@ -684,7 +680,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # same as above but replace GMV.SomeVar.values with GMV.SomeVar.mf_update with nogil: - for k in xrange(self.Gr.nzg-1): + for k in xrange(self.Gr.nzg): val1 = 1.0/(1.0-self.UpdVar.Area.bulkvalues[k]) val2 = self.UpdVar.Area.bulkvalues[k] * val1 @@ -716,7 +712,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(self.Gr.nzg): - interp_w_diff = interp2pt(we.values[k-1]-gmv_w[k-1],we.values[k]-gmv_w[k]) + interp_w_diff = we.values[k]-gmv_w[k] gmv_tke[k] = ae[k] * interp_w_diff * interp_w_diff + ae[k] * tke_e.values[k] for i in xrange(self.n_updrafts): interp_w_diff = interp2pt(wu.values[i,k-1]-gmv_w[k-1],wu.values[i,k]-gmv_w[k]) @@ -822,9 +818,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): input.b = self.UpdVar.B.values[i,k] input.b_mean = GMV.B.values[k] - input.w = interp2pt(self.UpdVar.W.values[i,k],self.UpdVar.W.values[i,k-1]) - input.dw = (self.UpdVar.W.values[i,k]-self.UpdVar.W.values[i,k-1])/self.Gr.dz - input.z = self.Gr.z_half[k] + input.w = self.UpdVar.W.values[i,k] + input.dw = (self.UpdVar.W.values[i,k+1]-self.UpdVar.W.values[i,k-1])/self.Gr.dz/2.0 + input.z = self.Gr.z[k] input.af = self.UpdVar.Area.values[i,k] input.tke = self.EnvVar.TKE.values[k] input.ml = self.mixing_length[k] @@ -832,14 +828,14 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): input.ql_env = self.EnvVar.QL.values[k] input.T_env = self.EnvVar.T.values[k] input.H_env = self.EnvVar.H.values[k] - input.w_env = interp2pt(self.EnvVar.W.values[k],self.EnvVar.W.values[k-1]) - input.dw_env = (self.EnvVar.W.values[k]-self.EnvVar.W.values[k-1])/self.Gr.dz + input.w_env = self.EnvVar.W.values[k] + input.dw_env = (self.EnvVar.W.values[k+1]-self.EnvVar.W.values[k-1])/self.Gr.dz/2.0 input.H_up = self.UpdVar.H.values[i,k] input.qt_up = self.UpdVar.QT.values[i,k] input.ql_up = self.UpdVar.QL.values[i,k] input.T_up = self.UpdVar.T.values[i,k] - input.p0 = self.Ref.p0_half[k] - input.alpha0 = self.Ref.alpha0_half[k] + input.p0 = self.Ref.p0[k] + input.alpha0 = self.Ref.alpha0[k] input.tke_ed_coeff = self.tke_ed_coeff input.Poisson_rand = Poisson_rand[k]/10.0 input.L = 20000.0 # need to define the scale of the GCM grid resolution @@ -856,10 +852,10 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double dzi = self.Gr.dzi double dti_ = 1.0/self.dt_upd double dt_ = 1.0/dti_ - double whalf_kp, whalf_k + double whalf_kp, whalf_k,whalf_km double a1, a2 # groupings of terms in area fraction discrete equation double au_lim - double anew_k, a_k, a_km, entr_w, detr_w, B_k, entr_term, detr_term, rho_ratio + double anew_k, a_k, a_km, entr_w, detr_w, B_k, entr_term, detr_term, rho_ratio, a_kp double adv, buoy, exch, press, press_buoy, press_drag # groupings of terms in velocity discrete equation with nogil: @@ -870,35 +866,37 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.Area.new[i,gw] = self.area_surface_bc[i] au_lim = self.area_surface_bc[i] * self.max_area_factor - for k in range(gw, self.Gr.nzg-gw): + for k in range(gw+1, self.Gr.nzg-gw): # First solve for updated area fraction at k+1 - whalf_kp = interp2pt(self.UpdVar.W.values[i,k], self.UpdVar.W.values[i,k+1]) - whalf_k = interp2pt(self.UpdVar.W.values[i,k-1], self.UpdVar.W.values[i,k]) - adv = -self.Ref.alpha0_half[k+1] * dzi *( self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * whalf_kp - -self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * whalf_k) - entr_term = self.UpdVar.Area.values[i,k+1] * whalf_kp * (self.entr_sc[i,k+1] ) - detr_term = self.UpdVar.Area.values[i,k+1] * whalf_kp * (- self.detr_sc[i,k+1]) - - - self.UpdVar.Area.new[i,k+1] = fmax(dt_ * (adv + entr_term + detr_term) + self.UpdVar.Area.values[i,k+1], 0.0) - if self.UpdVar.Area.new[i,k+1] > au_lim: - self.UpdVar.Area.new[i,k+1] = au_lim - if self.UpdVar.Area.values[i,k+1] > 0.0: - self.detr_sc[i,k+1] = (((au_lim-self.UpdVar.Area.values[i,k+1])* dti_ - adv -entr_term)/(-self.UpdVar.Area.values[i,k+1] * whalf_kp)) + whalf_kp = self.UpdVar.W.values[i,k+1] + whalf_k = self.UpdVar.W.values[i,k] + whalf_km = self.UpdVar.W.values[i,k-1] + adv = -self.Ref.alpha0[k] * dzi *( self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * whalf_k + -self.Ref.rho0[k-1] * self.UpdVar.Area.values[i,k-1] * whalf_km) + entr_term = self.UpdVar.Area.values[i,k] * whalf_k * (self.entr_sc[i,k] ) + detr_term = self.UpdVar.Area.values[i,k] * whalf_k * (- self.detr_sc[i,k]) + + + self.UpdVar.Area.new[i,k] = fmax(dt_ * (adv + entr_term + detr_term) + self.UpdVar.Area.values[i,k], 0.0) + if self.UpdVar.Area.new[i,k] > au_lim: + self.UpdVar.Area.new[i,k] = au_lim + if self.UpdVar.Area.values[i,k] > 0.0: + self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ - adv -entr_term)/(-self.UpdVar.Area.values[i,k] * whalf_k)) else: # this detrainment rate won't affect scalars but would affect velocity - self.detr_sc[i,k+1] = (((au_lim-self.UpdVar.Area.values[i,k+1])* dti_ - adv -entr_term)/(-au_lim * whalf_kp)) + self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ - adv -entr_term)/(-au_lim * whalf_kp)) # Now solve for updraft velocity at k rho_ratio = self.Ref.rho0[k-1]/self.Ref.rho0[k] - anew_k = interp2pt(self.UpdVar.Area.new[i,k], self.UpdVar.Area.new[i,k+1]) + anew_k = self.UpdVar.Area.new[i,k] if anew_k >= self.minimum_area: - a_k = interp2pt(self.UpdVar.Area.values[i,k], self.UpdVar.Area.values[i,k+1]) - a_km = interp2pt(self.UpdVar.Area.values[i,k-1], self.UpdVar.Area.values[i,k]) - entr_w = interp2pt(self.entr_sc[i,k], self.entr_sc[i,k+1]) - detr_w = interp2pt(self.detr_sc[i,k], self.detr_sc[i,k+1]) - B_k = interp2pt(self.UpdVar.B.values[i,k], self.UpdVar.B.values[i,k+1]) + a_k = self.UpdVar.Area.values[i,k] + a_km = self.UpdVar.Area.values[i,k-1] + a_kp = self.UpdVar.Area.values[i,k+1] + entr_w = self.entr_sc[i,k] + detr_w = self.detr_sc[i,k] + B_k = self.UpdVar.B.values[i,k] adv = (self.Ref.rho0[k] * a_k * self.UpdVar.W.values[i,k] * self.UpdVar.W.values[i,k] * dzi - self.Ref.rho0[k-1] * a_km * self.UpdVar.W.values[i,k-1] * self.UpdVar.W.values[i,k-1] * dzi) exch = (self.Ref.rho0[k] * a_k * self.UpdVar.W.values[i,k] @@ -933,7 +931,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # self.UpdVar.Area.new[i,k+1] = 0.0 # #break # plt.figure('area') - # plt.plot(self.UpdVar.Area.new[0,:], self.Gr.z_half) + # plt.plot(self.UpdVar.Area.new[0,:], self.Gr.z) # plt.show() return @@ -957,10 +955,10 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.QT.new[i,gw] = self.qt_surface_bc[i] sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, - self.Ref.p0_half[gw], self.UpdVar.QT.new[i,gw], self.UpdVar.H.new[i,gw]) + self.Ref.p0[gw], self.UpdVar.QT.new[i,gw], self.UpdVar.H.new[i,gw]) self.UpdVar.QL.new[i,gw] = sa.ql self.UpdVar.T.new[i,gw] = sa.T - self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0_half[gw], self.UpdVar.T.new[i,gw], + self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0[gw], self.UpdVar.T.new[i,gw], &self.UpdVar.QT.new[i,gw], &self.UpdVar.QL.new[i,gw], &self.UpdVar.H.new[i,gw], i, gw) for k in xrange(gw+1, self.Gr.nzg-gw): @@ -969,12 +967,10 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # write the discrete equations in form: # c1 * phi_new[k] = c2 * phi[k] + c3 * phi[k-1] + c4 * phi_entr if self.UpdVar.Area.new[i,k] >= self.minimum_area: - m_k = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] - * interp2pt(self.UpdVar.W.values[i,k-1], self.UpdVar.W.values[i,k])) - m_km = (self.Ref.rho0_half[k-1] * self.UpdVar.Area.values[i,k-1] - * interp2pt(self.UpdVar.W.values[i,k-2], self.UpdVar.W.values[i,k-1])) - c1 = self.Ref.rho0_half[k] * self.UpdVar.Area.new[i,k] * dti_ - c2 = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * dti_ + m_k = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k]*self.UpdVar.W.values[i,k]) + m_km = (self.Ref.rho0[k-1] * self.UpdVar.Area.values[i,k-1]* self.UpdVar.W.values[i,k-1]) + c1 = self.Ref.rho0[k] * self.UpdVar.Area.new[i,k] * dti_ + c2 = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * dti_ - m_k * (dzi + self.detr_sc[i,k])) c3 = m_km * dzi c4 = m_k * self.entr_sc[i,k] @@ -986,11 +982,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): else: self.UpdVar.H.new[i,k] = GMV.H.values[k] self.UpdVar.QT.new[i,k] = GMV.QT.values[k] - sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_half[k], + sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0[k], self.UpdVar.QT.new[i,k], self.UpdVar.H.new[i,k]) self.UpdVar.QL.new[i,k] = sa.ql self.UpdVar.T.new[i,k] = sa.T - self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0_half[k], self.UpdVar.T.new[i,k], + self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0[k], self.UpdVar.T.new[i,k], &self.UpdVar.QT.new[i,k], &self.UpdVar.QL.new[i,k], &self.UpdVar.H.new[i,k], i, k) self.UpdMicro.prec_source_h_tot = np.sum(np.multiply(self.UpdMicro.prec_source_h, @@ -1010,12 +1006,10 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # write the discrete equations in form: # c1 * phi_new[k] = c2 * phi[k] + c3 * phi[k-1] + c4 * phi_entr if self.UpdVar.Area.new[i,k] >= self.minimum_area: - m_k = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] - * interp2pt(self.UpdVar.W.values[i,k-1], self.UpdVar.W.values[i,k])) - m_km = (self.Ref.rho0_half[k-1] * self.UpdVar.Area.values[i,k-1] - * interp2pt(self.UpdVar.W.values[i,k-2], self.UpdVar.W.values[i,k-1])) - c1 = self.Ref.rho0_half[k] * self.UpdVar.Area.new[i,k] * dti_ - c2 = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * dti_ + m_k = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k]* self.UpdVar.W.values[i,k]) + m_km = (self.Ref.rho0[k-1] * self.UpdVar.Area.values[i,k-1]* self.UpdVar.W.values[i,k-1]) + c1 = self.Ref.rho0[k] * self.UpdVar.Area.new[i,k] * dti_ + c2 = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * dti_ - m_k * (dzi + self.detr_sc[i,k])) c3 = m_km * dzi c4 = m_k * self.entr_sc[i,k] @@ -1027,7 +1021,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): else: self.UpdVar.H.new[i,k] = GMV.H.values[k] self.UpdVar.QT.new[i,k] = GMV.QT.values[k] - sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_half[k], + sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0[k], self.UpdVar.QT.new[i,k], self.UpdVar.H.new[i,k]) self.UpdVar.QL.new[i,k] = sa.ql self.UpdVar.T.new[i,k] = sa.T @@ -1058,31 +1052,28 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for i in xrange(self.n_updrafts): self.m[i,gw-1] = 0.0 - for k in xrange(self.Gr.gw, self.Gr.nzg-1): - self.m[i,k] = ((self.UpdVar.W.values[i,k] - self.EnvVar.W.values[k] )* self.Ref.rho0[k] - * interp2pt(self.UpdVar.Area.values[i,k],self.UpdVar.Area.values[i,k+1])) + for k in xrange(self.Gr.gw, self.Gr.nzg): + self.m[i,k] = ((self.UpdVar.W.values[i,k] - self.EnvVar.W.values[k] )* self.Ref.rho0[k] * self.UpdVar.Area.values[i,k]) self.massflux_h[gw-1] = 0.0 self.massflux_qt[gw-1] = 0.0 with nogil: - for k in xrange(gw, self.Gr.nzg-gw-1): + for k in xrange(gw, self.Gr.nzg-gw): self.massflux_h[k] = 0.0 self.massflux_qt[k] = 0.0 - env_h_interp = interp2pt(self.EnvVar.H.values[k], self.EnvVar.H.values[k+1]) - env_qt_interp = interp2pt(self.EnvVar.QT.values[k], self.EnvVar.QT.values[k+1]) + env_h_interp = self.EnvVar.H.values[k] + env_qt_interp = self.EnvVar.QT.values[k] for i in xrange(self.n_updrafts): - self.massflux_h[k] += self.m[i,k] * (interp2pt(self.UpdVar.H.values[i,k], - self.UpdVar.H.values[i,k+1]) - env_h_interp ) - self.massflux_qt[k] += self.m[i,k] * (interp2pt(self.UpdVar.QT.values[i,k], - self.UpdVar.QT.values[i,k+1]) - env_qt_interp ) + self.massflux_h[k] += self.m[i,k] * (self.UpdVar.H.values[i,k] - env_h_interp ) + self.massflux_qt[k] += self.m[i,k] * (self.UpdVar.QT.values[i,k] - env_qt_interp ) # Compute the mass flux tendencies # Adjust the values of the grid mean variables with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg): - mf_tend_h = -(self.massflux_h[k] - self.massflux_h[k-1]) * (self.Ref.alpha0_half[k] * self.Gr.dzi) - mf_tend_qt = -(self.massflux_qt[k] - self.massflux_qt[k-1]) * (self.Ref.alpha0_half[k] * self.Gr.dzi) + mf_tend_h = -(self.massflux_h[k] - self.massflux_h[k-1]) * (self.Ref.alpha0[k] * self.Gr.dzi) + mf_tend_qt = -(self.massflux_qt[k] - self.massflux_qt[k-1]) * (self.Ref.alpha0[k] * self.Gr.dzi) GMV.H.mf_update[k] = GMV.H.values[k] + TS.dt * mf_tend_h + self.UpdMicro.prec_source_h_tot[k] GMV.QT.mf_update[k] = GMV.QT.values[k] + TS.dt * mf_tend_qt + self.UpdMicro.prec_source_qt_tot[k] @@ -1127,14 +1118,14 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): rho_ae_K_m[k] = 0.5 * (ae[k]*self.KH.values[k]+ ae[k+1]*self.KH.values[k+1]) * self.Ref.rho0[k] # Matrix is the same for all variables that use the same eddy diffusivity, we can construct once and reuse - construct_tridiag_diffusion(nzg, gw, dzi, TS.dt, &rho_ae_K_m[0], &self.Ref.rho0_half[0], + construct_tridiag_diffusion(nzg, gw, dzi, TS.dt, &rho_ae_K_m[0], &self.Ref.rho0[0], &ae[0], &a[0], &b[0], &c[0]) # Solve QT with nogil: for k in xrange(nz): x[k] = self.EnvVar.QT.values[k+gw] - x[0] = x[0] + TS.dt * Case.Sur.rho_qtflux * dzi * self.Ref.alpha0_half[gw]/ae[gw] + x[0] = x[0] + TS.dt * Case.Sur.rho_qtflux * dzi * self.Ref.alpha0[gw]/ae[gw] tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) with nogil: @@ -1144,13 +1135,13 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # get the diffusive flux self.diffusive_flux_qt[gw] = interp2pt(Case.Sur.rho_qtflux, -rho_ae_K_m[gw] * dzi *(self.EnvVar.QT.values[gw+1]-self.EnvVar.QT.values[gw]) ) for k in xrange(self.Gr.gw+1, self.Gr.nzg-self.Gr.gw): - self.diffusive_flux_qt[k] = -0.5 * self.Ref.rho0_half[k]*ae[k] * self.KH.values[k] * dzi * (self.EnvVar.QT.values[k+1]-self.EnvVar.QT.values[k-1]) + self.diffusive_flux_qt[k] = -0.5 * self.Ref.rho0[k]*ae[k] * self.KH.values[k] * dzi * (self.EnvVar.QT.values[k+1]-self.EnvVar.QT.values[k-1]) # Solve H with nogil: for k in xrange(nz): x[k] = self.EnvVar.H.values[k+gw] - x[0] = x[0] + TS.dt * Case.Sur.rho_hflux * dzi * self.Ref.alpha0_half[gw]/ae[gw] + x[0] = x[0] + TS.dt * Case.Sur.rho_hflux * dzi * self.Ref.alpha0[gw]/ae[gw] tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) with nogil: @@ -1160,7 +1151,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # get the diffusive flux self.diffusive_flux_h[gw] = interp2pt(Case.Sur.rho_hflux, -rho_ae_K_m[gw] * dzi *(self.EnvVar.H.values[gw+1]-self.EnvVar.H.values[gw]) ) for k in xrange(self.Gr.gw+1, self.Gr.nzg-self.Gr.gw): - self.diffusive_flux_h[k] = -0.5 * self.Ref.rho0_half[k]*ae[k] * self.KH.values[k] * dzi * (self.EnvVar.H.values[k+1]-self.EnvVar.H.values[k-1]) + self.diffusive_flux_h[k] = -0.5 * self.Ref.rho0[k]*ae[k] * self.KH.values[k] * dzi * (self.EnvVar.H.values[k+1]-self.EnvVar.H.values[k-1]) # Solve U with nogil: @@ -1168,12 +1159,12 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): rho_ae_K_m[k] = 0.5 * (ae[k]*self.KM.values[k]+ ae[k+1]*self.KM.values[k+1]) * self.Ref.rho0[k] # Matrix is the same for all variables that use the same eddy diffusivity, we can construct once and reuse - construct_tridiag_diffusion(nzg, gw, dzi, TS.dt, &rho_ae_K_m[0], &self.Ref.rho0_half[0], + construct_tridiag_diffusion(nzg, gw, dzi, TS.dt, &rho_ae_K_m[0], &self.Ref.rho0[0], &ae[0], &a[0], &b[0], &c[0]) with nogil: for k in xrange(nz): x[k] = GMV.U.values[k+gw] - x[0] = x[0] + TS.dt * Case.Sur.rho_uflux * dzi * self.Ref.alpha0_half[gw]/ae[gw] + x[0] = x[0] + TS.dt * Case.Sur.rho_uflux * dzi * self.Ref.alpha0[gw]/ae[gw] tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) with nogil: @@ -1184,7 +1175,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(nz): x[k] = GMV.V.values[k+gw] - x[0] = x[0] + TS.dt * Case.Sur.rho_vflux * dzi * self.Ref.alpha0_half[gw]/ae[gw] + x[0] = x[0] + TS.dt * Case.Sur.rho_vflux * dzi * self.Ref.alpha0[gw]/ae[gw] tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) with nogil: @@ -1228,7 +1219,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): grad_thl_plus = (self.EnvVar.THL.values[k+1] - self.EnvVar.THL.values[k]) * self.Gr.dzi grad_qt_plus = (self.EnvVar.QT.values[k+1] - self.EnvVar.QT.values[k]) * self.Gr.dzi - prefactor = Rd * exner_c(self.Ref.p0_half[k])/self.Ref.p0_half[k] + prefactor = Rd * exner_c(self.Ref.p0[k])/self.Ref.p0[k] d_alpha_thetal_dry = prefactor * (1.0 + (eps_vi-1.0) * qt_dry) d_alpha_qt_dry = prefactor * th_dry * (eps_vi-1.0) @@ -1247,9 +1238,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): + (1.0-self.EnvVar.CF.values[k]) * d_alpha_qt_dry) - self.tke_buoy[k] = g / self.Ref.alpha0_half[k] * ae[k] * self.Ref.rho0_half[k] \ - * ( -self.KH.values[k] *interp2pt(grad_thl_plus, grad_thl_minus) * d_alpha_thetal_total - - self.KH.values[k] * interp2pt(grad_qt_plus, grad_qt_minus) * d_alpha_qt_total) + self.tke_buoy[k] = g / self.Ref.alpha0[k] * ae[k] * self.Ref.rho0[k] \ + * ( -self.KH.values[k] *grad_thl_plus * d_alpha_thetal_total + - self.KH.values[k] * grad_qt_plus * d_alpha_qt_total) return @@ -1266,7 +1257,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # Using the "semi-implicit formulation" with dissipation averaged over timestep with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - self.tke_dissipation[k] = (self.Ref.rho0_half[k] * ae[k] * pow(fmax(self.EnvVar.TKE.values[k],0), 1.5) + self.tke_dissipation[k] = (self.Ref.rho0[k] * ae[k] * pow(fmax(self.EnvVar.TKE.values[k],0), 1.5) /fmax(self.mixing_length[k],1.0) * self.tke_diss_coeff) return @@ -1282,11 +1273,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): self.tke_entr_gain[k] = 0.0 - w_e = interp2pt(self.EnvVar.W.values[k-1], self.EnvVar.W.values[k]) + w_e = self.EnvVar.W.values[k] for i in xrange(self.n_updrafts): - w_u = interp2pt(self.UpdVar.W.values[i,k-1], self.UpdVar.W.values[i,k]) + w_u = self.UpdVar.W.values[i,k] self.tke_entr_gain[k] += self.UpdVar.Area.values[i,k] * w_u * self.detr_sc[i,k] * (w_u - w_e) * (w_u - w_e) - self.tke_entr_gain[k] *= 0.5 * self.Ref.rho0_half[k] + self.tke_entr_gain[k] *= 0.5 * self.Ref.rho0[k] return @@ -1299,9 +1290,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): self.tke_detr_loss[k] = 0.0 for i in xrange(self.n_updrafts): - w_u = interp2pt(self.UpdVar.W.values[i,k-1], self.UpdVar.W.values[i,k]) + w_u = self.UpdVar.W.values[i,k] self.tke_detr_loss[k] += self.UpdVar.Area.values[i,k] * w_u * self.entr_sc[i,k] - self.tke_detr_loss[k] *= self.Ref.rho0_half[k] * self.EnvVar.TKE.values[k] + self.tke_detr_loss[k] *= self.Ref.rho0[k] * self.EnvVar.TKE.values[k] return cpdef compute_tke_shear(self, GridMeanVariables GMV): @@ -1319,32 +1310,31 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): du_low = du_high dv_low = dv_high dw_low = dw_high - du_high = (GMV.U.values[k+1] - GMV.U.values[k]) * self.Gr.dzi - dv_high = (GMV.V.values[k+1] - GMV.V.values[k]) * self.Gr.dzi + du_high = (GMV.U.values[k+1] - GMV.U.values[k-1]) * self.Gr.dzi + dv_high = (GMV.V.values[k+1] - GMV.V.values[k-1]) * self.Gr.dzi dw_high = (self.EnvVar.W.values[k+1] - self.EnvVar.W.values[k]) * self.Gr.dzi - self.tke_shear[k] =( self.Ref.rho0_half[k] * ae[k] * self.KM.values[k] * - ( pow(interp2pt(du_low, du_high),2.0) + pow(interp2pt(dv_low, dv_high),2.0) - + pow(interp2pt(dw_low, dw_high),2.0))) + self.tke_shear[k] =( self.Ref.rho0[k] * ae[k] * self.KM.values[k] * + ( pow(du_high,2.0) + pow(dv_high,2.0)+ pow(dw_high,2.0))) return cpdef compute_tke_pressure(self): cdef: Py_ssize_t k Py_ssize_t gw = self.Gr.gw - double wu_half, we_half + double wu, we double press_buoy, press_drag with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): self.tke_pressure[k] = 0.0 for i in xrange(self.n_updrafts): - wu_half = interp2pt(self.UpdVar.W.values[i,k-1], self.UpdVar.W.values[i,k]) - we_half = interp2pt(self.EnvVar.W.values[k-1], self.EnvVar.W.values[k]) - press_buoy= (-1.0 * self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] + wu = self.UpdVar.W.values[i,k] + we = self.EnvVar.W.values[k] + press_buoy= (-1.0 * self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] * self.pressure_buoy_coeff) - press_drag = (-1.0 * self.Ref.rho0_half[k] * sqrt(self.UpdVar.Area.values[i,k]) - * (self.pressure_drag_coeff/self.pressure_plume_spacing* (wu_half -we_half)**2.0)) - self.tke_pressure[k] += (we_half - wu_half) * (press_buoy + press_drag) + press_drag = (-1.0 * self.Ref.rho0[k] * sqrt(self.UpdVar.Area.values[i,k]) + * (self.pressure_drag_coeff/self.pressure_plume_spacing* (wu -we)**2.0)) + self.tke_pressure[k] += (we - wu) * (press_buoy + press_drag) return cpdef update_tke_ED(self, GridMeanVariables GMV, CasesBase Case,TimeStepping TS): @@ -1364,16 +1354,16 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double [:] rho_ae_K_m = np.zeros((nzg,),dtype=np.double, order='c') double [:] whalf = np.zeros((nzg,),dtype=np.double, order='c') double D_env = 0.0 - double wu_half, we_half,a_half, tke_0_surf,press_k + double wu, we, tke_0_surf,press_k with nogil: for k in xrange(1,nzg-1): rho_ae_K_m[k] = 0.5 * (ae[k]*self.KM.values[k]+ ae[k+1]*self.KM.values[k+1]) * self.Ref.rho0[k] - whalf[k] = interp2pt(self.EnvVar.W.values[k-1], self.EnvVar.W.values[k]) - wu_half = interp2pt(self.UpdVar.W.bulkvalues[gw-1], self.UpdVar.W.bulkvalues[gw]) - GMV.TKE.values[gw] = get_surface_tke(Case.Sur.ustar, self.wstar, self.Gr.z_half[gw], Case.Sur.obukhov_length) + whalf[k] = self.EnvVar.W.values[k] + wu = self.UpdVar.W.bulkvalues[gw] + GMV.TKE.values[gw] = get_surface_tke(Case.Sur.ustar, self.wstar, self.Gr.z[gw], Case.Sur.obukhov_length) self.get_env_tke_from_GMV(self.UpdVar.Area, self.UpdVar.W, self.EnvVar.W, self.EnvVar.TKE, &GMV.W.values[0], &GMV.TKE.values[0]) @@ -1386,16 +1376,16 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): D_env = 0.0 for i in xrange(self.n_updrafts): - wu_half = interp2pt(self.UpdVar.W.values[i,k-1], self.UpdVar.W.values[i,k]) - D_env += self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * wu_half * self.entr_sc[i,k] + wu = self.UpdVar.W.values[i,k] + D_env += self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * wu * self.entr_sc[i,k] a[kk] = (- rho_ae_K_m[k-1] * dzi * dzi ) - b[kk] = (self.Ref.rho0_half[k] * ae[k] * dti - self.Ref.rho0_half[k] * ae[k] * whalf[k] * dzi + b[kk] = (self.Ref.rho0[k] * ae[k] * dti - self.Ref.rho0[k] * ae[k] * whalf[k] * dzi + rho_ae_K_m[k] * dzi * dzi + rho_ae_K_m[k-1] * dzi * dzi + D_env - + self.Ref.rho0_half[k] * ae[k] * self.tke_diss_coeff * sqrt(fmax(self.EnvVar.TKE.values[k],0.0))/fmax(self.mixing_length[k],1.0)) - c[kk] = (self.Ref.rho0_half[k+1] * ae[k+1] * whalf[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) - x[kk] = (self.Ref.rho0_half[k] * ae_old[k] * self.EnvVar.TKE.values[k] * dti + + self.Ref.rho0[k] * ae[k] * self.tke_diss_coeff * sqrt(fmax(self.EnvVar.TKE.values[k],0.0))/fmax(self.mixing_length[k],1.0)) + c[kk] = (self.Ref.rho0[k+1] * ae[k+1] * whalf[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) + x[kk] = (self.Ref.rho0[k] * ae_old[k] * self.EnvVar.TKE.values[k] * dti + self.tke_shear[k] + self.tke_buoy[k] + self.tke_entr_gain[k] + self.tke_pressure[k]) a[0] = 0.0 b[0] = 1.0 @@ -1410,7 +1400,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for kk in xrange(nz): k = kk + gw self.EnvVar.TKE.values[k] = fmax(x[kk], 0.0) - wu_half = interp2pt(self.UpdVar.W.bulkvalues[k-1], self.UpdVar.W.bulkvalues[k]) + wu = self.UpdVar.W.bulkvalues[k] self.get_GMV_TKE(self.UpdVar.Area,self.UpdVar.W, self.EnvVar.W, self.EnvVar.TKE, &GMV.W.values[0], &GMV.TKE.values[0]) @@ -1432,7 +1422,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): + (1.0 - self.UpdVar.Area.bulkvalues[k]) * self.EnvVar.T.values[k]) qv = GMV.QT.values[k] - GMV.QL.values[k] - GMV.THL.values[k] = t_to_thetali_c(self.Ref.p0_half[k], GMV.T.values[k], GMV.QT.values[k], + GMV.THL.values[k] = t_to_thetali_c(self.Ref.p0[k], GMV.T.values[k], GMV.QT.values[k], GMV.QL.values[k], 0.0) GMV.B.values[k] = (self.UpdVar.Area.bulkvalues[k] * self.UpdVar.B.bulkvalues[k] + (1.0 - self.UpdVar.Area.bulkvalues[k]) * self.EnvVar.B.values[k]) @@ -1467,7 +1457,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(self.Gr.nzg): - z = self.Gr.z_half[k] + z = self.Gr.z[k] # need to rethink of how to initilize the covarinace profiles - for nowmI took the TKE profile GMV.Hvar.values[k] = GMV.Hvar.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) GMV.QTvar.values[k] = GMV.QTvar.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) @@ -1491,18 +1481,18 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): dH_low = dH_high - dH_high = (self.EnvVar.H.values[k+1] - self.EnvVar.H.values[k]) * self.Gr.dzi + dH_high = (self.EnvVar.H.values[k+1] - self.EnvVar.H.values[k-1]) * self.Gr.dzi dQT_low = dQT_high - dQT_high = (self.EnvVar.QT.values[k+1] - self.EnvVar.QT.values[k]) * self.Gr.dzi - self.Hvar_shear[k] = 2.0*(self.Ref.rho0_half[k] * ae[k] * self.KH.values[k] *pow(interp2pt(dH_low, dH_high),2.0)) - self.QTvar_shear[k] = 2.0*(self.Ref.rho0_half[k] * ae[k] * self.KH.values[k] *pow(interp2pt(dQT_low, dQT_high),2.0)) - self.HQTcov_shear[k] = 2.0*(self.Ref.rho0_half[k] * ae[k] * self.KH.values[k] *interp2pt(dH_low, dH_high)*interp2pt(dQT_low, dQT_high)) + dQT_high = (self.EnvVar.QT.values[k+1] - self.EnvVar.QT.values[k-1]) * self.Gr.dzi + self.Hvar_shear[k] = 2.0*(self.Ref.rho0[k] * ae[k] * self.KH.values[k] *pow(dH_high,2.0)) + self.QTvar_shear[k] = 2.0*(self.Ref.rho0[k] * ae[k] * self.KH.values[k] *pow(dQT_high,2.0)) + self.HQTcov_shear[k] = 2.0*(self.Ref.rho0[k] * ae[k] * self.KH.values[k] *dH_high*dQT_high) return cpdef compute_covariance_entr(self): cdef: Py_ssize_t i, k - double H_u, H_env, QT_u, QT_env + double H_u, H_env, QT_u, QT_env, w_u with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): @@ -1514,31 +1504,31 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for i in xrange(self.n_updrafts): H_u = self.UpdVar.H.values[i,k] QT_u = self.UpdVar.QT.values[i,k] - w_u = interp2pt(self.UpdVar.W.values[i,k-1], self.UpdVar.W.values[i,k]) + w_u = self.UpdVar.W.values[i,k] self.Hvar_entr_gain[k] += self.UpdVar.Area.values[i,k] * w_u * self.detr_sc[i,k] * (H_u - H_env) * (H_u - H_env) self.QTvar_entr_gain[k] += self.UpdVar.Area.values[i,k] * w_u * self.detr_sc[i,k] * (QT_u - QT_env) * (QT_u - QT_env) self.HQTcov_entr_gain[k] += self.UpdVar.Area.values[i,k] * w_u * self.detr_sc[i,k] * (H_u - H_env) * (QT_u - QT_env) - self.Hvar_entr_gain[k] *= self.Ref.rho0_half[k] - self.QTvar_entr_gain[k] *= self.Ref.rho0_half[k] - self.HQTcov_entr_gain[k] *= self.Ref.rho0_half[k] + self.Hvar_entr_gain[k] *= self.Ref.rho0[k] + self.QTvar_entr_gain[k] *= self.Ref.rho0[k] + self.HQTcov_entr_gain[k] *= self.Ref.rho0[k] return cpdef compute_covariance_detr(self): cdef: Py_ssize_t i, k - double Thetal_u, QT_u + double Thetal_u, QT_u, w_u with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): self.Hvar_detr_loss[k] = 0.0 self.QTvar_detr_loss[k] = 0.0 for i in xrange(self.n_updrafts): - w_u = interp2pt(self.UpdVar.W.values[i,k-1], self.UpdVar.W.values[i,k]) + w_u = self.UpdVar.W.values[i,k] self.Hvar_detr_loss[k] += self.UpdVar.Area.values[i,k] * w_u * self.entr_sc[i,k] self.QTvar_detr_loss[k] += self.UpdVar.Area.values[i,k] * w_u * self.entr_sc[i,k] self.HQTcov_detr_loss[k] += self.UpdVar.Area.values[i,k] * w_u * self.entr_sc[i,k] - self.Hvar_detr_loss[k] *= self.Ref.rho0_half[k] * self.EnvVar.Hvar.values[k] - self.QTvar_detr_loss[k] *= self.Ref.rho0_half[k] * self.EnvVar.QTvar.values[k] - self.HQTcov_detr_loss[k] *= self.Ref.rho0_half[k] * self.EnvVar.HQTcov.values[k] + self.Hvar_detr_loss[k] *= self.Ref.rho0[k] * self.EnvVar.Hvar.values[k] + self.QTvar_detr_loss[k] *= self.Ref.rho0[k] * self.EnvVar.QTvar.values[k] + self.HQTcov_detr_loss[k] *= self.Ref.rho0[k] * self.EnvVar.HQTcov.values[k] return cpdef update_covariance_ED(self, GridMeanVariables GMV, CasesBase Case,TimeStepping TS): @@ -1549,8 +1539,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Py_ssize_t nz = self.Gr.nz double dzi = self.Gr.dzi double dti = TS.dti - double alpha0LL = self.Ref.alpha0_half[self.Gr.gw] - double zLL = self.Gr.z_half[self.Gr.gw] + double alpha0LL = self.Ref.alpha0[self.Gr.gw] + double zLL = self.Gr.z[self.Gr.gw] double [:] a = np.zeros((nz,),dtype=np.double, order='c') # for tridiag solver double [:] b = np.zeros((nz,),dtype=np.double, order='c') # for tridiag solver double [:] c = np.zeros((nz,),dtype=np.double, order='c') # for tridiag solver @@ -1567,19 +1557,19 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double Hvar_gmv_surf = get_surface_variance(Case.Sur.rho_hflux * alpha0LL, Case.Sur.rho_hflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) double QTvar_gmv_surf = get_surface_variance(Case.Sur.rho_qtflux * alpha0LL, Case.Sur.rho_qtflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) double HQTcov_gmv_surf = get_surface_variance(Case.Sur.rho_hflux * alpha0LL, Case.Sur.rho_qtflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) - double Hu_half, He_half, a_half, QTu_half, QTe_half - double wu_half, we_half, Hvar_0_surf, QTvar_0_surf, HQTcov_0_surf + double Hu, He, QTu, QTe + double wu, we, Hvar_0_surf, QTvar_0_surf, HQTcov_0_surf with nogil: for k in xrange(1,nzg-1): rho_ae_K_m[k] = 0.5 * (ae[k]*self.KH.values[k]+ ae[k+1]*self.KH.values[k+1]) * self.Ref.rho0[k] - whalf[k] = interp2pt(self.EnvVar.W.values[k-1], self.EnvVar.W.values[k]) + whalf[k] = self.EnvVar.W.values[k] Hhalf[k] = self.EnvVar.H.values[k] QThalf[k] = self.EnvVar.QT.values[k] - wu_half = interp2pt(self.UpdVar.W.bulkvalues[gw-1], self.UpdVar.W.bulkvalues[gw]) - Hu_half = self.UpdVar.H.bulkvalues[gw] - QTu_half = self.UpdVar.QT.bulkvalues[gw] + wu = self.UpdVar.W.bulkvalues[gw] + Hu = self.UpdVar.H.bulkvalues[gw] + QTu = self.UpdVar.QT.bulkvalues[gw] GMV.Hvar.values[gw] = get_surface_variance(Case.Sur.rho_hflux * alpha0LL, Case.Sur.rho_hflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) GMV.QTvar.values[gw] = get_surface_variance(Case.Sur.rho_qtflux * alpha0LL, Case.Sur.rho_qtflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) @@ -1591,9 +1581,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.get_env_covar_from_GMV(self.UpdVar.Area, self.UpdVar.H, self.UpdVar.QT, self.EnvVar.H, self.EnvVar.QT, self.EnvVar.HQTcov, &GMV.H.values[0], &GMV.QT.values[0], &GMV.HQTcov.values[0]) - - - # BC at the surface Hvar_0_surf = self.EnvVar.Hvar.values[gw] QTvar_0_surf = self.EnvVar.QTvar.values[gw] @@ -1606,17 +1593,17 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): D_env = 0.0 for i in xrange(self.n_updrafts): - wu_half = interp2pt(self.UpdVar.W.values[i,k-1], self.UpdVar.W.values[i,k]) - D_env += self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * wu_half * self.entr_sc[i,k] + wu = self.UpdVar.W.values[i,k] + D_env += self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * wu * self.entr_sc[i,k] a[kk] = (- rho_ae_K_m[k-1] * dzi * dzi ) - b[kk] = (self.Ref.rho0_half[k] * ae[k] * dti - self.Ref.rho0_half[k] * ae[k] * whalf[k] * dzi + b[kk] = (self.Ref.rho0[k] * ae[k] * dti - self.Ref.rho0[k] * ae[k] * whalf[k] * dzi + rho_ae_K_m[k] * dzi * dzi + rho_ae_K_m[k-1] * dzi * dzi + D_env - + self.Ref.rho0_half[k] * ae[k] * self.tke_diss_coeff + + self.Ref.rho0[k] * ae[k] * self.tke_diss_coeff *sqrt(fmax(self.EnvVar.TKE.values[k],0))/fmax(self.mixing_length[k],1.0) ) - c[kk] = (self.Ref.rho0_half[k+1] * ae[k+1] * whalf[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) - x[kk] = (self.Ref.rho0_half[k] * ae_old[k] * self.EnvVar.Hvar.values[k] * dti + c[kk] = (self.Ref.rho0[k+1] * ae[k+1] * whalf[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) + x[kk] = (self.Ref.rho0[k] * ae_old[k] * self.EnvVar.Hvar.values[k] * dti + self.Hvar_shear[k] + self.Hvar_entr_gain[k]) # a[0] = 0.0 @@ -1644,17 +1631,17 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): D_env = 0.0 for i in xrange(self.n_updrafts): - wu_half = interp2pt(self.UpdVar.W.values[i,k-1], self.UpdVar.W.values[i,k]) - D_env += self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * wu_half * self.entr_sc[i,k] + wu = self.UpdVar.W.values[i,k] + D_env += self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * wu * self.entr_sc[i,k] a[kk] = (- rho_ae_K_m[k-1] * dzi * dzi ) - b[kk] = (self.Ref.rho0_half[k] * ae[k] * dti - self.Ref.rho0_half[k] * ae[k] * whalf[k] * dzi + b[kk] = (self.Ref.rho0[k] * ae[k] * dti - self.Ref.rho0[k] * ae[k] * whalf[k] * dzi + rho_ae_K_m[k] * dzi * dzi + rho_ae_K_m[k-1] * dzi * dzi + D_env - + self.Ref.rho0_half[k] * ae[k] * self.tke_diss_coeff + + self.Ref.rho0[k] * ae[k] * self.tke_diss_coeff *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0)) - c[kk] = (self.Ref.rho0_half[k+1] * ae[k+1] * whalf[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) - x[kk] = (self.Ref.rho0_half[k] * ae_old[k] * self.EnvVar.QTvar.values[k] * dti + c[kk] = (self.Ref.rho0[k+1] * ae[k+1] * whalf[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) + x[kk] = (self.Ref.rho0[k] * ae_old[k] * self.EnvVar.QTvar.values[k] * dti + self.QTvar_shear[k] + self.QTvar_entr_gain[k]) # a[0] = 0.0 @@ -1684,17 +1671,17 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): D_env = 0.0 for i in xrange(self.n_updrafts): - wu_half = self.UpdVar.W.values[i,k] - D_env += self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * wu_half * self.entr_sc[i,k] + wu = self.UpdVar.W.values[i,k] + D_env += self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * wu * self.entr_sc[i,k] a[kk] = (- rho_ae_K_m[k-1] * dzi * dzi ) - b[kk] = (self.Ref.rho0_half[k] * ae[k] * dti - self.Ref.rho0_half[k] * ae[k] * whalf[k] * dzi + b[kk] = (self.Ref.rho0[k] * ae[k] * dti - self.Ref.rho0[k] * ae[k] * whalf[k] * dzi + rho_ae_K_m[k] * dzi * dzi + rho_ae_K_m[k-1] * dzi * dzi + D_env - + self.Ref.rho0_half[k] * ae[k] * self.tke_diss_coeff + + self.Ref.rho0[k] * ae[k] * self.tke_diss_coeff *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0) ) - c[kk] = (self.Ref.rho0_half[k+1] * ae[k+1] * whalf[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) - x[kk] = (self.Ref.rho0_half[k] * ae_old[k] * self.EnvVar.HQTcov.values[k] * dti + c[kk] = (self.Ref.rho0[k+1] * ae[k+1] * whalf[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) + x[kk] = (self.Ref.rho0[k] * ae_old[k] * self.EnvVar.HQTcov.values[k] * dti + self.HQTcov_shear[k] + self.HQTcov_entr_gain[k]) # a[0] = 0.0 @@ -1725,11 +1712,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - self.Hvar_dissipation[k] = (self.Ref.rho0_half[k] * ae[k] * self.EnvVar.Hvar.values[k] + self.Hvar_dissipation[k] = (self.Ref.rho0[k] * ae[k] * self.EnvVar.Hvar.values[k] *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0) * self.tke_diss_coeff) - self.QTvar_dissipation[k] = (self.Ref.rho0_half[k] * ae[k] * self.EnvVar.QTvar.values[k] + self.QTvar_dissipation[k] = (self.Ref.rho0[k] * ae[k] * self.EnvVar.QTvar.values[k] *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0) * self.tke_diss_coeff) - self.HQTcov_dissipation[k] = (self.Ref.rho0_half[k] * ae[k] * self.EnvVar.HQTcov.values[k] + self.HQTcov_dissipation[k] = (self.Ref.rho0[k] * ae[k] * self.EnvVar.HQTcov.values[k] *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0) * self.tke_diss_coeff) return diff --git a/Variables.pyx b/Variables.pyx index 7e74d823..393c08d9 100644 --- a/Variables.pyx +++ b/Variables.pyx @@ -25,6 +25,7 @@ cdef class VariablePrognostic: self.mf_update = np.zeros((nz_tot,),dtype=np.double, order='c') self.tendencies = np.zeros((nz_tot,),dtype=np.double, order='c') # Placement on staggered grid + loc = 'full' if loc != 'half' and loc != 'full': print('Invalid location setting for variable! Must be half or full') self.loc = loc @@ -92,6 +93,7 @@ cdef class VariableDiagnostic: # Value at the current timestep self.values = np.zeros((nz_tot,),dtype=np.double, order='c') # Placement on staggered grid + loc = 'full' if loc != 'half' and loc != 'full': print('Invalid location setting for variable! Must be half or full') self.loc = loc @@ -132,20 +134,20 @@ cdef class GridMeanVariables: self.Gr = Gr self.Ref = Ref - self.U = VariablePrognostic(Gr.nzg, 'half', 'velocity', 'sym','u', 'm/s' ) - self.V = VariablePrognostic(Gr.nzg, 'half', 'velocity','sym', 'v', 'm/s' ) + self.U = VariablePrognostic(Gr.nzg, 'full', 'velocity', 'sym','u', 'm/s' ) + self.V = VariablePrognostic(Gr.nzg, 'full', 'velocity','sym', 'v', 'm/s' ) # Just leave this zero for now! self.W = VariablePrognostic(Gr.nzg, 'full', 'velocity','sym', 'v', 'm/s' ) # Create thermodynamic variables - self.QT = VariablePrognostic(Gr.nzg, 'half', 'scalar','sym', 'qt', 'kg/kg') + self.QT = VariablePrognostic(Gr.nzg, 'full', 'scalar','sym', 'qt', 'kg/kg') if namelist['thermodynamics']['thermal_variable'] == 'entropy': - self.H = VariablePrognostic(Gr.nzg, 'half', 'scalar', 'sym','s', 'J/kg/K' ) + self.H = VariablePrognostic(Gr.nzg, 'full', 'scalar', 'sym','s', 'J/kg/K' ) self.t_to_prog_fp = t_to_entropy_c self.prog_to_t_fp = eos_first_guess_entropy elif namelist['thermodynamics']['thermal_variable'] == 'thetal': - self.H = VariablePrognostic(Gr.nzg, 'half', 'scalar', 'sym','thetal', 'K') + self.H = VariablePrognostic(Gr.nzg, 'full', 'scalar', 'sym','thetal', 'K') self.t_to_prog_fp = t_to_thetali_c self.prog_to_t_fp = eos_first_guess_thetal else: @@ -155,10 +157,10 @@ cdef class GridMeanVariables: # Diagnostic Variables--same class as the prognostic variables, but we append to diagnostics list # self.diagnostics_list = [] - self.QL = VariableDiagnostic(Gr.nzg,'half', 'scalar','sym', 'ql', 'kg/kg') - self.T = VariableDiagnostic(Gr.nzg,'half', 'scalar','sym', 'temperature', 'K') - self.B = VariableDiagnostic(Gr.nzg, 'half', 'scalar','sym', 'buoyancy', 'm^2/s^3') - self.THL = VariableDiagnostic(Gr.nzg, 'half', 'scalar', 'sym', 'thetal','K') + self.QL = VariableDiagnostic(Gr.nzg,'full', 'scalar','sym', 'ql', 'kg/kg') + self.T = VariableDiagnostic(Gr.nzg,'full', 'scalar','sym', 'temperature', 'K') + self.B = VariableDiagnostic(Gr.nzg, 'full', 'scalar','sym', 'buoyancy', 'm^2/s^3') + self.THL = VariableDiagnostic(Gr.nzg, 'full', 'scalar', 'sym', 'thetal','K') # Determine whether we need 2nd moment variables if namelist['turbulence']['scheme'] == 'EDMF_PrognosticTKE': @@ -186,25 +188,25 @@ cdef class GridMeanVariables: #Now add the 2nd moment variables if self.use_tke: - self.TKE = VariableDiagnostic(Gr.nzg, 'half', 'scalar','sym', 'tke','m^2/s^2' ) - self.QTvar = VariableDiagnostic(Gr.nzg, 'half', 'scalar','sym', 'qt_var','kg^2/kg^2' ) + self.TKE = VariableDiagnostic(Gr.nzg, 'full', 'scalar','sym', 'tke','m^2/s^2' ) + self.QTvar = VariableDiagnostic(Gr.nzg, 'full', 'scalar','sym', 'qt_var','kg^2/kg^2' ) if namelist['thermodynamics']['thermal_variable'] == 'entropy': - self.Hvar = VariableDiagnostic(Gr.nzg, 'half', 'scalar', 'sym', 's_var', '(J/kg/K)^2') - self.HQTcov = VariableDiagnostic(Gr.nzg, 'half', 'scalar', 'sym' ,'s_qt_covar', '(J/kg/K)(kg/kg)' ) + self.Hvar = VariableDiagnostic(Gr.nzg, 'full', 'scalar', 'sym', 's_var', '(J/kg/K)^2') + self.HQTcov = VariableDiagnostic(Gr.nzg, 'full', 'scalar', 'sym' ,'s_qt_covar', '(J/kg/K)(kg/kg)' ) elif namelist['thermodynamics']['thermal_variable'] == 'thetal': - self.Hvar = VariableDiagnostic(Gr.nzg, 'half', 'scalar', 'sym' ,'thetal_var', 'K^2') - self.HQTcov = VariableDiagnostic(Gr.nzg, 'half', 'scalar','sym' ,'thetal_qt_covar', 'K(kg/kg)' ) + self.Hvar = VariableDiagnostic(Gr.nzg, 'full', 'scalar', 'sym' ,'thetal_var', 'K^2') + self.HQTcov = VariableDiagnostic(Gr.nzg, 'full', 'scalar','sym' ,'thetal_qt_covar', 'K(kg/kg)' ) if self.use_scalar_var: - self.QTvar = VariableDiagnostic(Gr.nzg, 'half', 'scalar','sym', 'qt_var','kg^2/kg^2' ) + self.QTvar = VariableDiagnostic(Gr.nzg, 'full', 'scalar','sym', 'qt_var','kg^2/kg^2' ) if namelist['thermodynamics']['thermal_variable'] == 'entropy': - self.Hvar = VariableDiagnostic(Gr.nzg, 'half', 'scalar', 'sym', 's_var', '(J/kg/K)^2') - self.HQTcov = VariableDiagnostic(Gr.nzg, 'half', 'scalar', 'sym' ,'s_qt_covar', '(J/kg/K)(kg/kg)' ) + self.Hvar = VariableDiagnostic(Gr.nzg, 'full', 'scalar', 'sym', 's_var', '(J/kg/K)^2') + self.HQTcov = VariableDiagnostic(Gr.nzg, 'full', 'scalar', 'sym' ,'s_qt_covar', '(J/kg/K)(kg/kg)' ) elif namelist['thermodynamics']['thermal_variable'] == 'thetal': - self.Hvar = VariableDiagnostic(Gr.nzg, 'half', 'scalar', 'sym' ,'thetal_var', 'K^2') - self.HQTcov = VariableDiagnostic(Gr.nzg, 'half', 'scalar','sym' ,'thetal_qt_covar', 'K(kg/kg)' ) + self.Hvar = VariableDiagnostic(Gr.nzg, 'full', 'scalar', 'sym' ,'thetal_var', 'K^2') + self.HQTcov = VariableDiagnostic(Gr.nzg, 'full', 'scalar','sym' ,'thetal_qt_covar', 'K(kg/kg)' ) if self.EnvThermo_scheme == 'sommeria_deardorff': - self.THVvar = VariableDiagnostic(Gr.nzg, 'half', 'scalar','sym', 'thatav_var','K^2' ) + self.THVvar = VariableDiagnostic(Gr.nzg, 'full', 'scalar','sym', 'thatav_var','K^2' ) return @@ -286,7 +288,7 @@ cdef class GridMeanVariables: Stats.write_profile('QTvar_mean',self.QTvar.values[self.Gr.gw:self.Gr.nzg-self.Gr.gw]) Stats.write_profile('HQTcov_mean',self.HQTcov.values[self.Gr.gw:self.Gr.nzg-self.Gr.gw]) for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - lwp += self.Ref.rho0_half[k]*self.QL.values[k]*self.Gr.dz + lwp += self.Ref.rho0[k]*self.QL.values[k]*self.Gr.dz Stats.write_ts('lwp', lwp) @@ -303,14 +305,14 @@ cdef class GridMeanVariables: for k in xrange(self.Gr.nzg): h = self.H.values[k] qt = self.QT.values[k] - p0 = self.Ref.p0_half[k] + p0 = self.Ref.p0[k] sa = eos(self.t_to_prog_fp,self.prog_to_t_fp, p0, qt, h ) self.QL.values[k] = sa.ql self.T.values[k] = sa.T qv = qt - sa.ql self.THL.values[k] = t_to_thetali_c(p0, sa.T, qt, sa.ql,0.0) alpha = alpha_c(p0, sa.T, qt, qv) - self.B.values[k] = buoyancy_c(self.Ref.alpha0_half[k], alpha) + self.B.values[k] = buoyancy_c(self.Ref.alpha0[k], alpha) return From 44c031927b8a3cb994e8e2f2db5e8fa3dcc33902 Mon Sep 17 00:00:00 2001 From: yairchn Date: Fri, 27 Jul 2018 16:31:18 -0700 Subject: [PATCH 012/136] .. --- Cases.pyx | 278 +++++++++++++++++------------------ EDMF_Environment.pyx | 34 ++--- EDMF_Updrafts.pyx | 18 +-- Forcing.pyx | 12 +- Grid.pxd | 1 - Grid.pyx | 2 - NetCDFIO.pyx | 6 - ReferenceState.pxd | 3 - ReferenceState.pyx | 42 +----- Turbulence.pyx | 4 +- Turbulence_PrognosticTKE.pxd | 4 +- Turbulence_PrognosticTKE.pyx | 193 ++++++++++++------------ Variables.pyx | 8 +- turbulence_functions.pxd | 2 +- turbulence_functions.pyx | 8 +- 15 files changed, 287 insertions(+), 328 deletions(-) diff --git a/Cases.pyx b/Cases.pyx index f34a3aa6..45221df7 100644 --- a/Cases.pyx +++ b/Cases.pyx @@ -87,13 +87,13 @@ cdef class Soares(CasesBase): Py_ssize_t k for k in xrange(Gr.gw, Gr.nzg-Gr.gw): - if Gr.z_half[k] <= 1350.0: - GMV.QT.values[k] = 5.0e-3 - 3.7e-4* Gr.z_half[k]/1000.0 + if Gr.z[k] <= 1350.0: + GMV.QT.values[k] = 5.0e-3 - 3.7e-4* Gr.z[k]/1000.0 theta[k] = 300.0 else: - GMV.QT.values[k] = 5.0e-3 - 3.7e-4 * 1.35 - 9.4e-4 * (Gr.z_half[k]-1350.0)/1000.0 - theta[k] = 300.0 + 2.0 * (Gr.z_half[k]-1350.0)/1000.0 + GMV.QT.values[k] = 5.0e-3 - 3.7e-4 * 1.35 - 9.4e-4 * (Gr.z[k]-1350.0)/1000.0 + theta[k] = 300.0 + 2.0 * (Gr.z[k]-1350.0)/1000.0 GMV.U.values[k] = 0.01 GMV.U.set_bcs(Gr) @@ -102,14 +102,14 @@ cdef class Soares(CasesBase): if GMV.H.name == 'thetal': for k in xrange(Gr.gw,Gr.nzg-Gr.gw): GMV.H.values[k] = theta[k] - GMV.T.values[k] = theta[k] * exner_c(Ref.p0_half[k]) + GMV.T.values[k] = theta[k] * exner_c(Ref.p0[k]) GMV.THL.values[k] = theta[k] elif GMV.H.name == 's': for k in xrange(Gr.gw,Gr.nzg-Gr.gw): - GMV.T.values[k] = theta[k] * exner_c(Ref.p0_half[k]) - GMV.H.values[k] = t_to_entropy_c(Ref.p0_half[k],GMV.T.values[k], + GMV.T.values[k] = theta[k] * exner_c(Ref.p0[k]) + GMV.H.values[k] = t_to_entropy_c(Ref.p0[k],GMV.T.values[k], GMV.QT.values[k], ql, qi) - GMV.THL.values[k] = thetali_c(Ref.p0_half[k],GMV.T.values[k], + GMV.THL.values[k] = thetali_c(Ref.p0[k],GMV.T.values[k], GMV.QT.values[k], ql, qi, latent_heat(GMV.T.values[k])) GMV.H.set_bcs(Gr) @@ -175,43 +175,43 @@ cdef class Bomex(CasesBase): for k in xrange(Gr.gw,Gr.nzg-Gr.gw): #Set Thetal profile - if Gr.z_half[k] <= 520.: + if Gr.z[k] <= 520.: thetal[k] = 298.7 - if Gr.z_half[k] > 520.0 and Gr.z_half[k] <= 1480.0: - thetal[k] = 298.7 + (Gr.z_half[k] - 520) * (302.4 - 298.7)/(1480.0 - 520.0) - if Gr.z_half[k] > 1480.0 and Gr.z_half[k] <= 2000: - thetal[k] = 302.4 + (Gr.z_half[k] - 1480.0) * (308.2 - 302.4)/(2000.0 - 1480.0) - if Gr.z_half[k] > 2000.0: - thetal[k] = 308.2 + (Gr.z_half[k] - 2000.0) * (311.85 - 308.2)/(3000.0 - 2000.0) + if Gr.z[k] > 520.0 and Gr.z[k] <= 1480.0: + thetal[k] = 298.7 + (Gr.z[k] - 520) * (302.4 - 298.7)/(1480.0 - 520.0) + if Gr.z[k] > 1480.0 and Gr.z[k] <= 2000: + thetal[k] = 302.4 + (Gr.z[k] - 1480.0) * (308.2 - 302.4)/(2000.0 - 1480.0) + if Gr.z[k] > 2000.0: + thetal[k] = 308.2 + (Gr.z[k] - 2000.0) * (311.85 - 308.2)/(3000.0 - 2000.0) #Set qt profile - if Gr.z_half[k] <= 520: - GMV.QT.values[k] = (17.0 + (Gr.z_half[k]) * (16.3-17.0)/520.0)/1000.0 - if Gr.z_half[k] > 520.0 and Gr.z_half[k] <= 1480.0: - GMV.QT.values[k] = (16.3 + (Gr.z_half[k] - 520.0)*(10.7 - 16.3)/(1480.0 - 520.0))/1000.0 - if Gr.z_half[k] > 1480.0 and Gr.z_half[k] <= 2000.0: - GMV.QT.values[k] = (10.7 + (Gr.z_half[k] - 1480.0) * (4.2 - 10.7)/(2000.0 - 1480.0))/1000.0 - if Gr.z_half[k] > 2000.0: - GMV.QT.values[k] = (4.2 + (Gr.z_half[k] - 2000.0) * (3.0 - 4.2)/(3000.0 - 2000.0))/1000.0 + if Gr.z[k] <= 520: + GMV.QT.values[k] = (17.0 + (Gr.z[k]) * (16.3-17.0)/520.0)/1000.0 + if Gr.z[k] > 520.0 and Gr.z[k] <= 1480.0: + GMV.QT.values[k] = (16.3 + (Gr.z[k] - 520.0)*(10.7 - 16.3)/(1480.0 - 520.0))/1000.0 + if Gr.z[k] > 1480.0 and Gr.z[k] <= 2000.0: + GMV.QT.values[k] = (10.7 + (Gr.z[k] - 1480.0) * (4.2 - 10.7)/(2000.0 - 1480.0))/1000.0 + if Gr.z[k] > 2000.0: + GMV.QT.values[k] = (4.2 + (Gr.z[k] - 2000.0) * (3.0 - 4.2)/(3000.0 - 2000.0))/1000.0 #Set u profile - if Gr.z_half[k] <= 700.0: + if Gr.z[k] <= 700.0: GMV.U.values[k] = -8.75 - if Gr.z_half[k] > 700.0: - GMV.U.values[k] = -8.75 + (Gr.z_half[k] - 700.0) * (-4.61 - -8.75)/(3000.0 - 700.0) + if Gr.z[k] > 700.0: + GMV.U.values[k] = -8.75 + (Gr.z[k] - 700.0) * (-4.61 - -8.75)/(3000.0 - 700.0) if GMV.H.name == 'thetal': for k in xrange(Gr.gw,Gr.nzg-Gr.gw): GMV.H.values[k] = thetal[k] - GMV.T.values[k] = thetal[k] * exner_c(Ref.p0_half[k]) + GMV.T.values[k] = thetal[k] * exner_c(Ref.p0[k]) GMV.THL.values[k] = thetal[k] elif GMV.H.name == 's': for k in xrange(Gr.gw,Gr.nzg-Gr.gw): - GMV.T.values[k] = thetal[k] * exner_c(Ref.p0_half[k]) - GMV.H.values[k] = t_to_entropy_c(Ref.p0_half[k],GMV.T.values[k], + GMV.T.values[k] = thetal[k] * exner_c(Ref.p0[k]) + GMV.H.values[k] = t_to_entropy_c(Ref.p0[k],GMV.T.values[k], GMV.QT.values[k], ql, qi) - GMV.THL.values[k] = thetali_c(Ref.p0_half[k],GMV.T.values[k], + GMV.THL.values[k] = thetali_c(Ref.p0[k],GMV.T.values[k], GMV.QT.values[k], ql, qi, latent_heat(GMV.T.values[k])) GMV.U.set_bcs(Gr) @@ -240,24 +240,24 @@ cdef class Bomex(CasesBase): cdef Py_ssize_t k for k in xrange(Gr.gw, Gr.nzg-Gr.gw): # Geostrophic velocity profiles. vg = 0 - self.Fo.ug[k] = -10.0 + (1.8e-3)*Gr.z_half[k] + self.Fo.ug[k] = -10.0 + (1.8e-3)*Gr.z[k] # Set large-scale cooling - if Gr.z_half[k] <= 1500.0: - self.Fo.dTdt[k] = (-2.0/(3600 * 24.0)) * exner_c(Ref.p0_half[k]) + if Gr.z[k] <= 1500.0: + self.Fo.dTdt[k] = (-2.0/(3600 * 24.0)) * exner_c(Ref.p0[k]) else: - self.Fo.dTdt[k] = (-2.0/(3600 * 24.0) + (Gr.z_half[k] - 1500.0) - * (0.0 - -2.0/(3600 * 24.0)) / (3000.0 - 1500.0)) * exner_c(Ref.p0_half[k]) + self.Fo.dTdt[k] = (-2.0/(3600 * 24.0) + (Gr.z[k] - 1500.0) + * (0.0 - -2.0/(3600 * 24.0)) / (3000.0 - 1500.0)) * exner_c(Ref.p0[k]) # Set large-scale drying - if Gr.z_half[k] <= 300.0: + if Gr.z[k] <= 300.0: self.Fo.dqtdt[k] = -1.2e-8 #kg/(kg * s) - if Gr.z_half[k] > 300.0 and Gr.z_half[k] <= 500.0: - self.Fo.dqtdt[k] = -1.2e-8 + (Gr.z_half[k] - 300.0)*(0.0 - -1.2e-8)/(500.0 - 300.0) #kg/(kg * s) + if Gr.z[k] > 300.0 and Gr.z[k] <= 500.0: + self.Fo.dqtdt[k] = -1.2e-8 + (Gr.z[k] - 300.0)*(0.0 - -1.2e-8)/(500.0 - 300.0) #kg/(kg * s) #Set large scale subsidence - if Gr.z_half[k] <= 1500.0: - self.Fo.subsidence[k] = 0.0 + Gr.z_half[k]*(-0.65/100.0 - 0.0)/(1500.0 - 0.0) - if Gr.z_half[k] > 1500.0 and Gr.z_half[k] <= 2100.0: - self.Fo.subsidence[k] = -0.65/100 + (Gr.z_half[k] - 1500.0)* (0.0 - -0.65/100.0)/(2100.0 - 1500.0) + if Gr.z[k] <= 1500.0: + self.Fo.subsidence[k] = 0.0 + Gr.z[k]*(-0.65/100.0 - 0.0)/(1500.0 - 0.0) + if Gr.z[k] > 1500.0 and Gr.z[k] <= 2100.0: + self.Fo.subsidence[k] = -0.65/100 + (Gr.z[k] - 1500.0)* (0.0 - -0.65/100.0)/(2100.0 - 1500.0) return cpdef initialize_io(self, NetCDFIO_Stats Stats): @@ -299,44 +299,44 @@ cdef class life_cycle_Tan2018(CasesBase): double ql=0.0, qi =0.0 # IC of Bomex is cloud-free for k in xrange(Gr.gw,Gr.nzg-Gr.gw): #Set Thetal profile - if Gr.z_half[k] <= 520.: + if Gr.z[k] <= 520.: thetal[k] = 298.7 - if Gr.z_half[k] > 520.0 and Gr.z_half[k] <= 1480.0: - thetal[k] = 298.7 + (Gr.z_half[k] - 520) * (302.4 - 298.7)/(1480.0 - 520.0) - if Gr.z_half[k] > 1480.0 and Gr.z_half[k] <= 2000: - thetal[k] = 302.4 + (Gr.z_half[k] - 1480.0) * (308.2 - 302.4)/(2000.0 - 1480.0) - if Gr.z_half[k] > 2000.0: - thetal[k] = 308.2 + (Gr.z_half[k] - 2000.0) * (311.85 - 308.2)/(3000.0 - 2000.0) + if Gr.z[k] > 520.0 and Gr.z[k] <= 1480.0: + thetal[k] = 298.7 + (Gr.z[k] - 520) * (302.4 - 298.7)/(1480.0 - 520.0) + if Gr.z[k] > 1480.0 and Gr.z[k] <= 2000: + thetal[k] = 302.4 + (Gr.z[k] - 1480.0) * (308.2 - 302.4)/(2000.0 - 1480.0) + if Gr.z[k] > 2000.0: + thetal[k] = 308.2 + (Gr.z[k] - 2000.0) * (311.85 - 308.2)/(3000.0 - 2000.0) #Set qt profile - if Gr.z_half[k] <= 520: - GMV.QT.values[k] = (17.0 + (Gr.z_half[k]) * (16.3-17.0)/520.0)/1000.0 - if Gr.z_half[k] > 520.0 and Gr.z_half[k] <= 1480.0: - GMV.QT.values[k] = (16.3 + (Gr.z_half[k] - 520.0)*(10.7 - 16.3)/(1480.0 - 520.0))/1000.0 - if Gr.z_half[k] > 1480.0 and Gr.z_half[k] <= 2000.0: - GMV.QT.values[k] = (10.7 + (Gr.z_half[k] - 1480.0) * (4.2 - 10.7)/(2000.0 - 1480.0))/1000.0 - if Gr.z_half[k] > 2000.0: - GMV.QT.values[k] = (4.2 + (Gr.z_half[k] - 2000.0) * (3.0 - 4.2)/(3000.0 - 2000.0))/1000.0 + if Gr.z[k] <= 520: + GMV.QT.values[k] = (17.0 + (Gr.z[k]) * (16.3-17.0)/520.0)/1000.0 + if Gr.z[k] > 520.0 and Gr.z[k] <= 1480.0: + GMV.QT.values[k] = (16.3 + (Gr.z[k] - 520.0)*(10.7 - 16.3)/(1480.0 - 520.0))/1000.0 + if Gr.z[k] > 1480.0 and Gr.z[k] <= 2000.0: + GMV.QT.values[k] = (10.7 + (Gr.z[k] - 1480.0) * (4.2 - 10.7)/(2000.0 - 1480.0))/1000.0 + if Gr.z[k] > 2000.0: + GMV.QT.values[k] = (4.2 + (Gr.z[k] - 2000.0) * (3.0 - 4.2)/(3000.0 - 2000.0))/1000.0 #Set u profile - if Gr.z_half[k] <= 700.0: + if Gr.z[k] <= 700.0: GMV.U.values[k] = -8.75 - if Gr.z_half[k] > 700.0: - GMV.U.values[k] = -8.75 + (Gr.z_half[k] - 700.0) * (-4.61 - -8.75)/(3000.0 - 700.0) + if Gr.z[k] > 700.0: + GMV.U.values[k] = -8.75 + (Gr.z[k] - 700.0) * (-4.61 - -8.75)/(3000.0 - 700.0) if GMV.H.name == 'thetal': for k in xrange(Gr.gw,Gr.nzg-Gr.gw): GMV.H.values[k] = thetal[k] - GMV.T.values[k] = thetal[k] * exner_c(Ref.p0_half[k]) + GMV.T.values[k] = thetal[k] * exner_c(Ref.p0[k]) GMV.THL.values[k] = thetal[k] elif GMV.H.name == 's': for k in xrange(Gr.gw,Gr.nzg-Gr.gw): - GMV.T.values[k] = thetal[k] * exner_c(Ref.p0_half[k]) - GMV.H.values[k] = t_to_entropy_c(Ref.p0_half[k],GMV.T.values[k], + GMV.T.values[k] = thetal[k] * exner_c(Ref.p0[k]) + GMV.H.values[k] = t_to_entropy_c(Ref.p0[k],GMV.T.values[k], GMV.QT.values[k], ql, qi) - GMV.THL.values[k] = thetali_c(Ref.p0_half[k],GMV.T.values[k], + GMV.THL.values[k] = thetali_c(Ref.p0[k],GMV.T.values[k], GMV.QT.values[k], ql, qi, latent_heat(GMV.T.values[k])) GMV.U.set_bcs(Gr) @@ -367,24 +367,24 @@ cdef class life_cycle_Tan2018(CasesBase): self.Fo.initialize(GMV) for k in xrange(Gr.gw, Gr.nzg-Gr.gw): # Geostrophic velocity profiles. vg = 0 - self.Fo.ug[k] = -10.0 + (1.8e-3)*Gr.z_half[k] + self.Fo.ug[k] = -10.0 + (1.8e-3)*Gr.z[k] # Set large-scale cooling - if Gr.z_half[k] <= 1500.0: - self.Fo.dTdt[k] = (-2.0/(3600 * 24.0)) * exner_c(Ref.p0_half[k]) + if Gr.z[k] <= 1500.0: + self.Fo.dTdt[k] = (-2.0/(3600 * 24.0)) * exner_c(Ref.p0[k]) else: - self.Fo.dTdt[k] = (-2.0/(3600 * 24.0) + (Gr.z_half[k] - 1500.0) - * (0.0 - -2.0/(3600 * 24.0)) / (3000.0 - 1500.0)) * exner_c(Ref.p0_half[k]) + self.Fo.dTdt[k] = (-2.0/(3600 * 24.0) + (Gr.z[k] - 1500.0) + * (0.0 - -2.0/(3600 * 24.0)) / (3000.0 - 1500.0)) * exner_c(Ref.p0[k]) # Set large-scale drying - if Gr.z_half[k] <= 300.0: + if Gr.z[k] <= 300.0: self.Fo.dqtdt[k] = -1.2e-8 #kg/(kg * s) - if Gr.z_half[k] > 300.0 and Gr.z_half[k] <= 500.0: - self.Fo.dqtdt[k] = -1.2e-8 + (Gr.z_half[k] - 300.0)*(0.0 - -1.2e-8)/(500.0 - 300.0) #kg/(kg * s) + if Gr.z[k] > 300.0 and Gr.z[k] <= 500.0: + self.Fo.dqtdt[k] = -1.2e-8 + (Gr.z[k] - 300.0)*(0.0 - -1.2e-8)/(500.0 - 300.0) #kg/(kg * s) #Set large scale subsidence - if Gr.z_half[k] <= 1500.0: - self.Fo.subsidence[k] = 0.0 + Gr.z_half[k]*(-0.65/100.0 - 0.0)/(1500.0 - 0.0) - if Gr.z_half[k] > 1500.0 and Gr.z_half[k] <= 2100.0: - self.Fo.subsidence[k] = -0.65/100 + (Gr.z_half[k] - 1500.0)* (0.0 - -0.65/100.0)/(2100.0 - 1500.0) + if Gr.z[k] <= 1500.0: + self.Fo.subsidence[k] = 0.0 + Gr.z[k]*(-0.65/100.0 - 0.0)/(1500.0 - 0.0) + if Gr.z[k] > 1500.0 and Gr.z[k] <= 2100.0: + self.Fo.subsidence[k] = -0.65/100 + (Gr.z[k] - 1500.0)* (0.0 - -0.65/100.0)/(2100.0 - 1500.0) return cpdef initialize_io(self, NetCDFIO_Stats Stats): @@ -432,33 +432,33 @@ cdef class Rico(CasesBase): Py_ssize_t k for k in xrange(Gr.gw,Gr.nzg-Gr.gw): - GMV.U.values[k] = -9.9 + 2.0e-3 * Gr.z_half[k] + GMV.U.values[k] = -9.9 + 2.0e-3 * Gr.z[k] GMV.V.values[k] = -3.8 #Set Thetal profile - if Gr.z_half[k] <= 740.0: + if Gr.z[k] <= 740.0: thetal[k] = 297.9 else: - thetal[k] = 297.9 + (317.0-297.9)/(4000.0-740.0)*(Gr.z_half[k] - 740.0) + thetal[k] = 297.9 + (317.0-297.9)/(4000.0-740.0)*(Gr.z[k] - 740.0) #Set qt profile - if Gr.z_half[k] <= 740.0: - GMV.QT.values[k] = (16.0 + (13.8 - 16.0)/740.0 * Gr.z_half[k])/1000.0 - elif Gr.z_half[k] > 740.0 and Gr.z_half[k] <= 3260.0: - GMV.QT.values[k] = (13.8 + (2.4 - 13.8)/(3260.0-740.0) * (Gr.z_half[k] - 740.0))/1000.0 + if Gr.z[k] <= 740.0: + GMV.QT.values[k] = (16.0 + (13.8 - 16.0)/740.0 * Gr.z[k])/1000.0 + elif Gr.z[k] > 740.0 and Gr.z[k] <= 3260.0: + GMV.QT.values[k] = (13.8 + (2.4 - 13.8)/(3260.0-740.0) * (Gr.z[k] - 740.0))/1000.0 else: - GMV.QT.values[k] = (2.4 + (1.8-2.4)/(4000.0-3260.0)*(Gr.z_half[k] - 3260.0))/1000.0 + GMV.QT.values[k] = (2.4 + (1.8-2.4)/(4000.0-3260.0)*(Gr.z[k] - 3260.0))/1000.0 if GMV.H.name == 'thetal': for k in xrange(Gr.gw,Gr.nzg-Gr.gw): GMV.H.values[k] = thetal[k] - GMV.T.values[k] = thetal[k] * exner_c(Ref.p0_half[k]) + GMV.T.values[k] = thetal[k] * exner_c(Ref.p0[k]) GMV.THL.values[k] = thetal[k] elif GMV.H.name == 's': for k in xrange(Gr.gw,Gr.nzg-Gr.gw): - GMV.T.values[k] = thetal[k] * exner_c(Ref.p0_half[k]) - GMV.H.values[k] = t_to_entropy_c(Ref.p0_half[k],GMV.T.values[k], + GMV.T.values[k] = thetal[k] * exner_c(Ref.p0[k]) + GMV.H.values[k] = t_to_entropy_c(Ref.p0[k],GMV.T.values[k], GMV.QT.values[k], ql, qi) - GMV.THL.values[k] = thetali_c(Ref.p0_half[k],GMV.T.values[k], + GMV.THL.values[k] = thetali_c(Ref.p0[k],GMV.T.values[k], GMV.QT.values[k], ql, qi, latent_heat(GMV.T.values[k])) GMV.U.set_bcs(Gr) @@ -477,7 +477,7 @@ cdef class Rico(CasesBase): self.Sur.ch = 0.001094 self.Sur.cq = 0.001133 # Adjust for non-IC grid spacing - grid_adjust = (np.log(20.0/self.Sur.zrough)/np.log(Gr.z_half[Gr.gw]/self.Sur.zrough))**2 + grid_adjust = (np.log(20.0/self.Sur.zrough)/np.log(Gr.z[Gr.gw]/self.Sur.zrough))**2 self.Sur.cm = self.Sur.cm * grid_adjust self.Sur.ch = self.Sur.ch * grid_adjust self.Sur.cq = self.Sur.cq * grid_adjust @@ -491,20 +491,20 @@ cdef class Rico(CasesBase): self.Fo.initialize(GMV) for k in xrange(Gr.nzg): # Geostrophic velocity profiles - self.Fo.ug[k] = -9.9 + 2.0e-3 * Gr.z_half[k] + self.Fo.ug[k] = -9.9 + 2.0e-3 * Gr.z[k] self.Fo.vg[k] = -3.8 # Set large-scale cooling - self.Fo.dTdt[k] = (-2.5/(3600.0 * 24.0)) * exner_c(Ref.p0_half[k]) + self.Fo.dTdt[k] = (-2.5/(3600.0 * 24.0)) * exner_c(Ref.p0[k]) # Set large-scale moistening - if Gr.z_half[k] <= 2980.0: - self.Fo.dqtdt[k] = (-1.0 + 1.3456/2980.0 * Gr.z_half[k])/86400.0/1000.0 #kg/(kg * s) + if Gr.z[k] <= 2980.0: + self.Fo.dqtdt[k] = (-1.0 + 1.3456/2980.0 * Gr.z[k])/86400.0/1000.0 #kg/(kg * s) else: self.Fo.dqtdt[k] = 0.3456/86400.0/1000.0 #Set large scale subsidence - if Gr.z_half[k] <= 2260.0: - self.Fo.subsidence[k] = -(0.005/2260.0) * Gr.z_half[k] + if Gr.z[k] <= 2260.0: + self.Fo.subsidence[k] = -(0.005/2260.0) * Gr.z[k] else: self.Fo.subsidence[k] = -0.005 return @@ -597,19 +597,19 @@ cdef class TRMM_LBA(CasesBase): 5.32, 1.14, -0.65, 5.27, 5.27]) # interpolate to the model grid-points - p1 = np.interp(Gr.z_half,z_in,p_in) - GMV.U.values = np.interp(Gr.z_half,z_in,u_in) - GMV.V.values = np.interp(Gr.z_half,z_in,v_in) + p1 = np.interp(Gr.z,z_in,p_in) + GMV.U.values = np.interp(Gr.z,z_in,u_in) + GMV.V.values = np.interp(Gr.z,z_in,v_in) # get the entropy from RH, p, T RH = np.zeros(Gr.nzg) - RH[Gr.gw:Gr.nzg-Gr.gw] = np.interp(Gr.z_half[Gr.gw:Gr.nzg-Gr.gw],z_in,RH_in) + RH[Gr.gw:Gr.nzg-Gr.gw] = np.interp(Gr.z[Gr.gw:Gr.nzg-Gr.gw],z_in,RH_in) RH[0] = RH[3] RH[1] = RH[2] RH[Gr.nzg-Gr.gw+1] = RH[Gr.nzg-Gr.gw-1] T = np.zeros(Gr.nzg) - T[Gr.gw:Gr.nzg-Gr.gw] = np.interp(Gr.z_half[Gr.gw:Gr.nzg-Gr.gw],z_in,T_in) + T[Gr.gw:Gr.nzg-Gr.gw] = np.interp(Gr.z[Gr.gw:Gr.nzg-Gr.gw],z_in,T_in) GMV.T.values = T theta_rho = RH*0.0 epsi = 287.1/461.5 @@ -626,15 +626,15 @@ cdef class TRMM_LBA(CasesBase): qv = GMV.QT.values[k] - GMV.QL.values[k] GMV.QT.values[k] = qv_star*RH[k]/100.0 if GMV.H.name == 's': - GMV.H.values[k] = t_to_entropy_c(Ref.p0_half[k],GMV.T.values[k], + GMV.H.values[k] = t_to_entropy_c(Ref.p0[k],GMV.T.values[k], GMV.QT.values[k], 0.0, 0.0) elif GMV.H.name == 'thetal': - GMV.H.values[k] = thetali_c(Ref.p0_half[k],GMV.T.values[k], + GMV.H.values[k] = thetali_c(Ref.p0[k],GMV.T.values[k], GMV.QT.values[k], 0.0, 0.0, latent_heat(GMV.T.values[k])) - GMV.THL.values[k] = thetali_c(Ref.p0_half[k],GMV.T.values[k], + GMV.THL.values[k] = thetali_c(Ref.p0[k],GMV.T.values[k], GMV.QT.values[k], 0.0, 0.0, latent_heat(GMV.T.values[k])) - theta_rho[k] = theta_rho_c(Ref.p0_half[k], GMV.T.values[k], GMV.QT.values[k], qv) + theta_rho[k] = theta_rho_c(Ref.p0[k], GMV.T.values[k], GMV.QT.values[k], qv) GMV.QT.set_bcs(Gr) GMV.H.set_bcs(Gr) @@ -775,9 +775,9 @@ cdef class TRMM_LBA(CasesBase): cdef: Py_ssize_t tt, k, ind1, ind2 - A = np.interp(Gr.z_half,z_in,rad_in[0,:]) + A = np.interp(Gr.z,z_in,rad_in[0,:]) for tt in xrange(1,36): - A = np.vstack((A, np.interp(Gr.z_half,z_in,rad_in[tt,:]))) + A = np.vstack((A, np.interp(Gr.z,z_in,rad_in[tt,:]))) self.rad = np.multiply(A,1.0) # store matrix in self ind1 = int(mt.trunc(10.0/600.0)) @@ -828,7 +828,7 @@ cdef class TRMM_LBA(CasesBase): self.Fo.dTdt[k] = self.rad[ind1,k] else: # in all other cases - interpolate for k in xrange(self.Fo.Gr.nzg): - if self.Fo.Gr.z_half[k] < 22699.48: + if self.Fo.Gr.z[k] < 22699.48: self.Fo.dTdt[k] = (self.rad[ind2,k]-self.rad[ind1,k])\ /(self.rad_time[ind2]-self.rad_time[ind1])\ *(TS.t/60.0-self.rad_time[ind1])+self.rad[ind1,k] @@ -870,22 +870,22 @@ cdef class ARM_SGP(CasesBase): print qt_in # interpolate to the model grid-points - Theta = np.interp(Gr.z_half,z_in,Theta_in) - qt = np.interp(Gr.z_half,z_in,qt_in) + Theta = np.interp(Gr.z,z_in,Theta_in) + qt = np.interp(Gr.z,z_in,qt_in) for k in xrange(Gr.gw,Gr.nzg-Gr.gw): GMV.U.values[k] = 10.0 GMV.QT.values[k] = qt[k] - GMV.T.values[k] = Theta[k]*exner_c(Ref.p0_half[k]) + GMV.T.values[k] = Theta[k]*exner_c(Ref.p0[k]) if GMV.H.name == 's': - GMV.H.values[k] = t_to_entropy_c(Ref.p0_half[k],GMV.T.values[k], + GMV.H.values[k] = t_to_entropy_c(Ref.p0[k],GMV.T.values[k], GMV.QT.values[k], 0.0, 0.0) elif GMV.H.name == 'thetal': - GMV.H.values[k] = thetali_c(Ref.p0_half[k],GMV.T.values[k], + GMV.H.values[k] = thetali_c(Ref.p0[k],GMV.T.values[k], GMV.QT.values[k], 0.0, 0.0, latent_heat(GMV.T.values[k])) - GMV.THL.values[k] = thetali_c(Ref.p0_half[k],GMV.T.values[k], + GMV.THL.values[k] = thetali_c(Ref.p0[k],GMV.T.values[k], GMV.QT.values[k], 0.0, 0.0, latent_heat(GMV.T.values[k])) @@ -958,13 +958,13 @@ cdef class ARM_SGP(CasesBase): double dTdt = np.interp(TS.t,t_in,AT_in) + np.interp(TS.t,t_in,RT_in) double dqtdt = np.interp(TS.t,t_in,Rqt_in) for k in xrange(self.Fo.Gr.nzg): # correct dims - if self.Fo.Gr.z_half[k] <=1000.0: + if self.Fo.Gr.z[k] <=1000.0: self.Fo.dTdt[k] = dTdt - self.Fo.dqtdt[k] = dqtdt * exner_c(self.Fo.Ref.p0_half[k]) - elif self.Fo.Gr.z_half[k] > 1000.0 and self.Fo.Gr.z_half[k] <= 2000.0: - self.Fo.dTdt[k] = dTdt*(1-(self.Fo.Gr.z_half[k]-1000.0)/1000.0) - self.Fo.dqtdt[k] = dqtdt * exner_c(self.Fo.Ref.p0_half[k])\ - *(1-(self.Fo.Gr.z_half[k]-1000.0)/1000.0) + self.Fo.dqtdt[k] = dqtdt * exner_c(self.Fo.Ref.p0[k]) + elif self.Fo.Gr.z[k] > 1000.0 and self.Fo.Gr.z[k] <= 2000.0: + self.Fo.dTdt[k] = dTdt*(1-(self.Fo.Gr.z[k]-1000.0)/1000.0) + self.Fo.dqtdt[k] = dqtdt * exner_c(self.Fo.Ref.p0[k])\ + *(1-(self.Fo.Gr.z[k]-1000.0)/1000.0) self.Fo.update(GMV) return @@ -1013,9 +1013,9 @@ cdef class GATE_III(CasesBase): z_T_in = np.array([0.0, 0.492, 0.700, 1.698, 3.928, 6.039, 7.795, 9.137, 11.055, 12.645, 13.521, 14.486, 15.448, 16.436, 17.293, 22.0])*1000.0 # for km # interpolate to the model grid-points - T = np.interp(Gr.z_half,z_T_in,T_in) # interpolate to ref pressure level - qt = np.interp(Gr.z_half,z_in,qt_in) - U = np.interp(Gr.z_half,z_in,U_in) + T = np.interp(Gr.z,z_T_in,T_in) # interpolate to ref pressure level + qt = np.interp(Gr.z,z_in,qt_in) + U = np.interp(Gr.z,z_in,U_in) for k in xrange(Gr.gw,Gr.nzg-Gr.gw): @@ -1024,13 +1024,13 @@ cdef class GATE_III(CasesBase): GMV.U.values[k] = U[k] if GMV.H.name == 's': - GMV.H.values[k] = t_to_entropy_c(Ref.p0_half[k],GMV.T.values[k], + GMV.H.values[k] = t_to_entropy_c(Ref.p0[k],GMV.T.values[k], GMV.QT.values[k], 0.0, 0.0) elif GMV.H.name == 'thetal': - GMV.H.values[k] = thetali_c(Ref.p0_half[k],GMV.T.values[k], + GMV.H.values[k] = thetali_c(Ref.p0[k],GMV.T.values[k], GMV.QT.values[k], 0.0, 0.0, latent_heat(GMV.T.values[k])) - GMV.THL.values[k] = thetali_c(Ref.p0_half[k],GMV.T.values[k], + GMV.THL.values[k] = thetali_c(Ref.p0[k],GMV.T.values[k], GMV.QT.values[k], 0.0, 0.0, latent_heat(GMV.T.values[k])) GMV.U.set_bcs(Gr) GMV.QT.set_bcs(Gr) @@ -1078,8 +1078,8 @@ cdef class GATE_III(CasesBase): Qtend_in = np.divide(r_tend_in,(1+r_tend_in)) # convert mixing ratio to specific humidity - self.Fo.dqtdt = np.interp(Gr.z_half,z_in,Qtend_in) - self.Fo.dTdt = np.interp(Gr.z_half,z_in,Ttend_in) + np.interp(Gr.z_half,z_in,RAD_in) + self.Fo.dqtdt = np.interp(Gr.z,z_in,Qtend_in) + self.Fo.dTdt = np.interp(Gr.z,z_in,Ttend_in) + np.interp(Gr.z,z_in,RAD_in) return @@ -1180,35 +1180,35 @@ cdef class DYCOMS_RF01(CasesBase): for k in xrange(Gr.gw, Gr.nzg-Gr.gw): # thetal profile as defined in DYCOMS - if Gr.z_half[k] <= 840.0: + if Gr.z[k] <= 840.0: thetal[k] = 289.0 - if Gr.z_half[k] > 840.0: - thetal[k] = (297.5 + (Gr.z_half[k] - 840.0)**(1.0/3.0)) + if Gr.z[k] > 840.0: + thetal[k] = (297.5 + (Gr.z[k] - 840.0)**(1.0/3.0)) # qt profile as defined in DYCOMS - if Gr.z_half[k] <= 840.0: + if Gr.z[k] <= 840.0: GMV.QT.values[k] = 9. / 1000.0 - if Gr.z_half[k] > 840.0: + if Gr.z[k] > 840.0: GMV.QT.values[k] = 1.5 / 1000.0 # ql and T profile # (calculated by saturation adjustment using thetal and qt values provided in DYCOMS # and using Rd, cp and L constants as defined in DYCOMS) - GMV.T.values[k], GMV.QL.values[k] = self.dycoms_sat_adjst(Ref.p0_half[k], thetal[k], GMV.QT.values[k]) + GMV.T.values[k], GMV.QL.values[k] = self.dycoms_sat_adjst(Ref.p0[k], thetal[k], GMV.QT.values[k]) # thermodynamic variable profile (either entropy or thetal) # (calculated based on T and ql profiles. # Here we use Rd, cp and L constants as defined in scampy) - GMV.THL.values[k] = t_to_thetali_c(Ref.p0_half[k], GMV.T.values[k], GMV.QT.values[k], GMV.QL.values[k], qi) + GMV.THL.values[k] = t_to_thetali_c(Ref.p0[k], GMV.T.values[k], GMV.QT.values[k], GMV.QL.values[k], qi) if GMV.H.name == 'thetal': - GMV.H.values[k] = t_to_thetali_c(Ref.p0_half[k], GMV.T.values[k], GMV.QT.values[k], GMV.QL.values[k], qi) + GMV.H.values[k] = t_to_thetali_c(Ref.p0[k], GMV.T.values[k], GMV.QT.values[k], GMV.QL.values[k], qi) elif GMV.H.name == 's': - GMV.H.values[k] = t_to_entropy_c(Ref.p0_half[k], GMV.T.values[k], GMV.QT.values[k], GMV.QL.values[k], qi) + GMV.H.values[k] = t_to_entropy_c(Ref.p0[k], GMV.T.values[k], GMV.QT.values[k], GMV.QL.values[k], qi) # buoyancy profile qv = GMV.QT.values[k] - qi - GMV.QL.values[k] - alpha = alpha_c(Ref.p0_half[k], GMV.T.values[k], GMV.QT.values[k], qv) - GMV.B.values[k] = buoyancy_c(Ref.alpha0_half[k], alpha) + alpha = alpha_c(Ref.p0[k], GMV.T.values[k], GMV.QT.values[k], qv) + GMV.B.values[k] = buoyancy_c(Ref.alpha0[k], alpha) # velocity profile (geostrophic) GMV.U.values[k] = 7.0 @@ -1266,7 +1266,7 @@ cdef class DYCOMS_RF01(CasesBase): # To be able to have self.Fo.divergence available here, # we would have to change the signature of ForcingBase class for k in xrange(Gr.gw, Gr.nzg-Gr.gw): - self.Fo.subsidence[k] = - Gr.z_half[k] * divergence + self.Fo.subsidence[k] = - Gr.z[k] * divergence # no large-scale drying self.Fo.dqtdt[:] = 0. #kg/(kg * s) diff --git a/EDMF_Environment.pyx b/EDMF_Environment.pyx index 32e62826..1ad92258 100644 --- a/EDMF_Environment.pyx +++ b/EDMF_Environment.pyx @@ -17,8 +17,8 @@ cdef class EnvironmentVariable: def __init__(self, nz, loc, kind, name, units): self.values = np.zeros((nz,),dtype=np.double, order='c') self.flux = np.zeros((nz,),dtype=np.double, order='c') - if loc != 'half' and loc != 'full': - print('Invalid location setting for variable! Must be half or full') + if loc != 'full': + print('Invalid location setting for variable! Must be full') self.loc = loc if kind != 'scalar' and kind != 'velocity': print ('Invalid kind setting for variable! Must be scalar or velocity') @@ -37,16 +37,16 @@ cdef class EnvironmentVariables: self.W = EnvironmentVariable(nz, 'full', 'velocity', 'w','m/s' ) - self.QT = EnvironmentVariable( nz, 'half', 'scalar', 'qt','kg/kg' ) - self.QL = EnvironmentVariable( nz, 'half', 'scalar', 'w','kg/kg' ) + self.QT = EnvironmentVariable( nz, 'full', 'scalar', 'qt','kg/kg' ) + self.QL = EnvironmentVariable( nz, 'full', 'scalar', 'w','kg/kg' ) if namelist['thermodynamics']['thermal_variable'] == 'entropy': - self.H = EnvironmentVariable( nz, 'half', 'scalar', 's','J/kg/K' ) + self.H = EnvironmentVariable( nz, 'full', 'scalar', 's','J/kg/K' ) elif namelist['thermodynamics']['thermal_variable'] == 'thetal': - self.H = EnvironmentVariable( nz, 'half', 'scalar', 'thetal','K' ) - self.THL = EnvironmentVariable(nz, 'half', 'scalar', 'thetal', 'K') - self.T = EnvironmentVariable( nz, 'half', 'scalar', 'temperature','K' ) - self.B = EnvironmentVariable( nz, 'half', 'scalar', 'buoyancy','m^2/s^3' ) - self.CF = EnvironmentVariable(nz, 'half', 'scalar','cloud_fraction', '-') + self.H = EnvironmentVariable( nz, 'full', 'scalar', 'thetal','K' ) + self.THL = EnvironmentVariable(nz, 'full', 'scalar', 'thetal', 'K') + self.T = EnvironmentVariable( nz, 'full', 'scalar', 'temperature','K' ) + self.B = EnvironmentVariable( nz, 'full', 'scalar', 'buoyancy','m^2/s^3' ) + self.CF = EnvironmentVariable(nz, 'full', 'scalar','cloud_fraction', '-') # Determine whether we need 2nd moment variables if namelist['turbulence']['scheme'] == 'EDMF_PrognosticTKE': @@ -68,18 +68,18 @@ cdef class EnvironmentVariables: if self.use_tke: - self.TKE = EnvironmentVariable( nz, 'half', 'scalar', 'tke','m^2/s^2' ) + self.TKE = EnvironmentVariable( nz, 'full', 'scalar', 'tke','m^2/s^2' ) if self.use_scalar_var: - self.QTvar = EnvironmentVariable( nz, 'half', 'scalar', 'qt_var','kg^2/kg^2' ) + self.QTvar = EnvironmentVariable( nz, 'full', 'scalar', 'qt_var','kg^2/kg^2' ) if namelist['thermodynamics']['thermal_variable'] == 'entropy': - self.Hvar = EnvironmentVariable(nz, 'half', 'scalar', 's_var', '(J/kg/K)^2') - self.HQTcov = EnvironmentVariable(nz, 'half', 'scalar', 's_qt_covar', '(J/kg/K)(kg/kg)' ) + self.Hvar = EnvironmentVariable(nz, 'full', 'scalar', 's_var', '(J/kg/K)^2') + self.HQTcov = EnvironmentVariable(nz, 'full', 'scalar', 's_qt_covar', '(J/kg/K)(kg/kg)' ) elif namelist['thermodynamics']['thermal_variable'] == 'thetal': - self.Hvar = EnvironmentVariable(nz, 'half', 'scalar', 'thetal_var', 'K^2') - self.HQTcov = EnvironmentVariable(nz, 'half', 'scalar', 'thetal_qt_covar', 'K(kg/kg)' ) + self.Hvar = EnvironmentVariable(nz, 'full', 'scalar', 'thetal_var', 'K^2') + self.HQTcov = EnvironmentVariable(nz, 'full', 'scalar', 'thetal_qt_covar', 'K(kg/kg)' ) if self.EnvThermo_scheme == 'sommeria_deardorff': - self.THVvar = EnvironmentVariable(nz, 'half', 'scalar', 'thetav_var', 'K^2' ) + self.THVvar = EnvironmentVariable(nz, 'full', 'scalar', 'thetav_var', 'K^2' ) # return diff --git a/EDMF_Updrafts.pyx b/EDMF_Updrafts.pyx index cab0db4a..72be6c0c 100644 --- a/EDMF_Updrafts.pyx +++ b/EDMF_Updrafts.pyx @@ -25,8 +25,8 @@ cdef class UpdraftVariable: self.tendencies = np.zeros((nu,nz),dtype=np.double, order='c') self.flux = np.zeros((nu,nz),dtype=np.double, order='c') self.bulkvalues = np.zeros((nz,), dtype=np.double, order = 'c') - if loc != 'half' and loc != 'full': - print('Invalid location setting for variable! Must be half or full') + if loc != 'full': + print('Invalid location setting for variable! Must be full') self.loc = loc if kind != 'scalar' and kind != 'velocity': print ('Invalid kind setting for variable! Must be scalar or velocity') @@ -68,16 +68,16 @@ cdef class UpdraftVariables: self.W = UpdraftVariable(nu, nzg, 'full', 'velocity', 'w','m/s' ) self.Area = UpdraftVariable(nu, nzg, 'full', 'scalar', 'area_fraction','[-]' ) - self.QT = UpdraftVariable(nu, nzg, 'half', 'scalar', 'qt','kg/kg' ) - self.QL = UpdraftVariable(nu, nzg, 'half', 'scalar', 'ql','kg/kg' ) + self.QT = UpdraftVariable(nu, nzg, 'full', 'scalar', 'qt','kg/kg' ) + self.QL = UpdraftVariable(nu, nzg, 'full', 'scalar', 'ql','kg/kg' ) if namelist['thermodynamics']['thermal_variable'] == 'entropy': - self.H = UpdraftVariable(nu, nzg, 'half', 'scalar', 's','J/kg/K' ) + self.H = UpdraftVariable(nu, nzg, 'full', 'scalar', 's','J/kg/K' ) elif namelist['thermodynamics']['thermal_variable'] == 'thetal': - self.H = UpdraftVariable(nu, nzg, 'half', 'scalar', 'thetal','K' ) + self.H = UpdraftVariable(nu, nzg, 'full', 'scalar', 'thetal','K' ) - self.THL = UpdraftVariable(nu, nzg, 'half', 'scalar', 'thetal', 'K') - self.T = UpdraftVariable(nu, nzg, 'half', 'scalar', 'temperature','K' ) - self.B = UpdraftVariable(nu, nzg, 'half', 'scalar', 'buoyancy','m^2/s^3' ) + self.THL = UpdraftVariable(nu, nzg, 'full', 'scalar', 'thetal', 'K') + self.T = UpdraftVariable(nu, nzg, 'full', 'scalar', 'temperature','K' ) + self.B = UpdraftVariable(nu, nzg, 'full', 'scalar', 'buoyancy','m^2/s^3' ) if namelist['turbulence']['scheme'] == 'EDMF_PrognosticTKE': try: diff --git a/Forcing.pyx b/Forcing.pyx index de2ee0ef..6a28caac 100644 --- a/Forcing.pyx +++ b/Forcing.pyx @@ -75,7 +75,7 @@ cdef class ForcingStandard(ForcingBase): for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): # Apply large-scale horizontal advection tendencies qv = GMV.QT.values[k] - GMV.QL.values[k] - GMV.H.tendencies[k] += self.convert_forcing_prog_fp(self.Ref.p0_half[k],GMV.QT.values[k], + GMV.H.tendencies[k] += self.convert_forcing_prog_fp(self.Ref.p0[k],GMV.QT.values[k], qv, GMV.T.values[k], self.dqtdt[k], self.dTdt[k]) GMV.QT.tendencies[k] += self.dqtdt[k] # Apply large-scale subsidence tendencies @@ -112,7 +112,7 @@ cdef class ForcingStandard(ForcingBase): # for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): # # Apply large-scale horizontal advection tendencies # qv = GMV.QT.values[k] - GMV.QL.values[k] -# GMV.H.tendencies[k] += self.convert_forcing_prog_fp(self.Ref.p0_half[k],GMV.QT.values[k], qv, +# GMV.H.tendencies[k] += self.convert_forcing_prog_fp(self.Ref.p0[k],GMV.QT.values[k], qv, # GMV.T.values[k], self.dqtdt[k], self.dTdt[k]) # GMV.QT.tendencies[k] += self.dqtdt[k] # @@ -166,14 +166,14 @@ cdef class ForcingDYCOMS_RF01(ForcingBase): q_0 = 0.0 self.f_rad[self.Gr.nzg] = self.F0 * np.exp(-q_0) for k in xrange(self.Gr.nzg - 1, -1, -1): - q_0 += self.kappa * self.Ref.rho0_half[k] * GMV.QL.values[k] * self.Gr.dz + q_0 += self.kappa * self.Ref.rho0[k] * GMV.QL.values[k] * self.Gr.dz self.f_rad[k] = self.F0 * np.exp(-q_0) # cloud-base warming q_1 = 0.0 self.f_rad[0] += self.F1 * np.exp(-q_1) for k in xrange(1, self.Gr.nzg + 1): - q_1 += self.kappa * self.Ref.rho0_half[k - 1] * GMV.QL.values[k - 1] * self.Gr.dz + q_1 += self.kappa * self.Ref.rho0[k - 1] * GMV.QL.values[k - 1] * self.Gr.dz self.f_rad[k] += self.F1 * np.exp(-q_1) # cooling in free troposphere @@ -186,7 +186,7 @@ cdef class ForcingDYCOMS_RF01(ForcingBase): self.f_rad[self.Gr.nzg] += rhoi * dycoms_cp * self.divergence * self.alpha_z * (np.power(cbrt_z, 4) / 4.0 + zi * cbrt_z) for k in xrange(self.Gr.gw, self.Gr.nzg - self.Gr.gw): - self.dTdt[k] = - (self.f_rad[k + 1] - self.f_rad[k]) / self.Gr.dz / self.Ref.rho0_half[k] / dycoms_cp + self.dTdt[k] = - (self.f_rad[k + 1] - self.f_rad[k]) / self.Gr.dz / self.Ref.rho0[k] / dycoms_cp return @@ -204,7 +204,7 @@ cdef class ForcingDYCOMS_RF01(ForcingBase): for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): # Apply large-scale horizontal advection tendencies qv = GMV.QT.values[k] - GMV.QL.values[k] - GMV.H.tendencies[k] += self.convert_forcing_prog_fp(self.Ref.p0_half[k],GMV.QT.values[k], qv, GMV.T.values[k], self.dqtdt[k], self.dTdt[k]) + GMV.H.tendencies[k] += self.convert_forcing_prog_fp(self.Ref.p0[k],GMV.QT.values[k], qv, GMV.T.values[k], self.dqtdt[k], self.dTdt[k]) GMV.QT.tendencies[k] += self.dqtdt[k] # Apply large-scale subsidence tendencies GMV.H.tendencies[k] -= (GMV.H.values[k+1]-GMV.H.values[k]) * self.Gr.dzi * self.subsidence[k] diff --git a/Grid.pxd b/Grid.pxd index 5232ae16..a9cf0ad4 100644 --- a/Grid.pxd +++ b/Grid.pxd @@ -13,4 +13,3 @@ cdef class Grid: Py_ssize_t nz Py_ssize_t nzg double [:] z - double [:] z_half diff --git a/Grid.pyx b/Grid.pyx index f1901e3c..2fdab484 100644 --- a/Grid.pyx +++ b/Grid.pyx @@ -33,14 +33,12 @@ cdef class Grid: self.nz = namelist['grid']['nz'] self.nzg = self.nz + 2 * self.gw - self.z_half = np.empty((self.nz+2*self.gw),dtype=np.double,order='c') self.z = np.empty((self.nz+2*self.gw),dtype=np.double,order='c') cdef int i, count = 0 for i in xrange(-self.gw,self.nz+self.gw,1): self.z[count] = (i + 1) * self.dz - self.z_half[count] = self.z[count] count += 1 diff --git a/NetCDFIO.pyx b/NetCDFIO.pyx index 298bcdfb..1b42445f 100644 --- a/NetCDFIO.pyx +++ b/NetCDFIO.pyx @@ -90,20 +90,14 @@ cdef class NetCDFIO_Stats: profile_grp.createDimension('t', None) z = profile_grp.createVariable('z', 'f8', ('z')) z[:] = np.array(self.Gr.z[kmin:kmax]) - z_half = profile_grp.createVariable('z_half', 'f8', ('z')) - z_half[:] = np.array(self.Gr.z_half[kmin:kmax]) profile_grp.createVariable('t', 'f8', ('t')) del z - del z_half reference_grp = root_grp.createGroup('reference') reference_grp.createDimension('z', self.Gr.nz) z = reference_grp.createVariable('z', 'f8', ('z')) z[:] = np.array(self.Gr.z[kmin:kmax]) - z_half = reference_grp.createVariable('z_half', 'f8', ('z')) - z_half[:] = np.array(self.Gr.z_half[kmin:kmax]) del z - del z_half ts_grp = root_grp.createGroup('timeseries') ts_grp.createDimension('t', None) diff --git a/ReferenceState.pxd b/ReferenceState.pxd index d63d2d77..f0c2caec 100644 --- a/ReferenceState.pxd +++ b/ReferenceState.pxd @@ -4,11 +4,8 @@ from NetCDFIO cimport NetCDFIO_Stats cdef class ReferenceState: cdef: double [:] p0 - double [:] p0_half double [:] alpha0 - double [:] alpha0_half double [:] rho0 - double [:] rho0_half double sg diff --git a/ReferenceState.pyx b/ReferenceState.pyx index 72058ba9..f38129ec 100644 --- a/ReferenceState.pyx +++ b/ReferenceState.pyx @@ -21,11 +21,8 @@ cdef class ReferenceState: def __init__(self, Grid Gr ): self.p0 = np.zeros(Gr.nzg, dtype=np.double, order='c') - self.p0_half = np.zeros(Gr.nzg, dtype=np.double, order='c') self.alpha0 = np.zeros(Gr.nzg, dtype=np.double, order='c') - self.alpha0_half = np.zeros(Gr.nzg, dtype=np.double, order='c') self.rho0 = np.zeros(Gr.nzg, dtype=np.double, order='c') - self.rho0_half = np.zeros(Gr.nzg, dtype=np.double, order='c') return @@ -62,45 +59,32 @@ cdef class ReferenceState: # Construct arrays for integration points z = np.array(Gr.z[Gr.gw - 1:-Gr.gw + 1]) - z_half = np.append([0.0], np.array(Gr.z_half[Gr.gw:-Gr.gw])) # We are integrating the log pressure so need to take the log of the # surface pressure p0 = np.log(self.Pg) p = np.zeros(Gr.nzg, dtype=np.double, order='c') - p_half = np.zeros(Gr.nzg, dtype=np.double, order='c') # Perform the integration p[Gr.gw - 1:-Gr.gw +1] = odeint(rhs, p0, z, hmax=1.0)[:, 0] - p_half[Gr.gw:-Gr.gw] = odeint(rhs, p0, z_half, hmax=1.0)[1:, 0] # Set boundary conditions p[:Gr.gw - 1] = p[2 * Gr.gw - 2:Gr.gw - 1:-1] p[-Gr.gw + 1:] = p[-Gr.gw - 1:-2 * Gr.gw:-1] - p_half[:Gr.gw] = p_half[2 * Gr.gw - 1:Gr.gw - 1:-1] - p_half[-Gr.gw:] = p_half[-Gr.gw - 1:-2 * Gr.gw - 1:-1] p = np.exp(p) - p_half = np.exp(p_half) cdef double[:] p_ = p - cdef double[:] p_half_ = p_half cdef double[:] temperature = np.zeros(Gr.nzg, dtype=np.double, order='c') - cdef double[:] temperature_half = np.zeros(Gr.nzg, dtype=np.double, order='c') cdef double[:] alpha = np.zeros(Gr.nzg, dtype=np.double, order='c') - cdef double[:] alpha_half = np.zeros(Gr.nzg, dtype=np.double, order='c') cdef double[:] ql = np.zeros(Gr.nzg, dtype=np.double, order='c') cdef double[:] qi = np.zeros(Gr.nzg, dtype=np.double, order='c') cdef double[:] qv = np.zeros(Gr.nzg, dtype=np.double, order='c') - cdef double[:] ql_half = np.zeros(Gr.nzg, dtype=np.double, order='c') - cdef double[:] qi_half = np.zeros(Gr.nzg, dtype=np.double, order='c') - cdef double[:] qv_half = np.zeros(Gr.nzg, dtype=np.double, order='c') - # Compute reference state thermodynamic profiles #_____COMMENTED TO TEST COMPILATION_____________________ for k in xrange(Gr.nzg): @@ -109,58 +93,34 @@ cdef class ReferenceState: ql[k] = ret.ql qv[k] = self.qtg - (ql[k] + qi[k]) alpha[k] = alpha_c(p_[k], temperature[k], self.qtg, qv[k]) - ret = eos(t_to_entropy_c, eos_first_guess_entropy, p_half_[k], self.qtg, self.sg) - temperature_half[k] = ret.T - ql_half[k] = ret.ql - qv_half[k] = self.qtg - (ql_half[k] + qi_half[k]) - alpha_half[k] = alpha_c(p_half_[k], temperature_half[k], self.qtg, qv_half[k]) # Now do a sanity check to make sure that the Reference State entropy profile is uniform following # saturation adjustment cdef double s for k in xrange(Gr.nzg): - s = t_to_entropy_c(p_half[k],temperature_half[k],self.qtg,ql_half[k],qi_half[k]) + s = t_to_entropy_c(p[k],temperature[k],self.qtg,ql[k],qi[k]) if np.abs(s - self.sg)/self.sg > 0.01: print('Error in reference profiles entropy not constant !') print('Likely error in saturation adjustment') - - - - - # print(np.array(Gr.extract_local_ghosted(alpha_half,2))) - self.alpha0_half = alpha_half self.alpha0 = alpha self.p0 = p_ - self.p0_half = p_half self.rho0 = 1.0 / np.array(self.alpha0) - self.rho0_half = 1.0 / np.array(self.alpha0_half) Stats.add_reference_profile('alpha0') Stats.write_reference_profile('alpha0', alpha[Gr.gw:-Gr.gw]) - Stats.add_reference_profile('alpha0_half') - Stats.write_reference_profile('alpha0_half', alpha_half[Gr.gw:-Gr.gw]) Stats.add_reference_profile('p0') Stats.write_reference_profile('p0', p_[Gr.gw:-Gr.gw]) - Stats.add_reference_profile('p0_half') - Stats.write_reference_profile('p0_half', p_half[Gr.gw:-Gr.gw]) Stats.add_reference_profile('rho0') Stats.write_reference_profile('rho0', 1.0 / np.array(alpha[Gr.gw:-Gr.gw])) - Stats.add_reference_profile('rho0_half') - Stats.write_reference_profile('rho0_half', 1.0 / np.array(alpha_half[Gr.gw:-Gr.gw])) # Stats.add_reference_profile('temperature0', Gr, Pa) - # Stats.write_reference_profile('temperature0', temperature_half[Gr.dims.gw:-Gr.dims.gw], Pa) # Stats.add_reference_profile('ql0', Gr, Pa) - # Stats.write_reference_profile('ql0', ql_half[Gr.dims.gw:-Gr.dims.gw], Pa) # Stats.add_reference_profile('qv0', Gr, Pa) - # Stats.write_reference_profile('qv0', qv_half[Gr.dims.gw:-Gr.dims.gw], Pa) # Stats.add_reference_profile('qi0', Gr, Pa) - # Stats.write_reference_profile('qi0', qi_half[Gr.dims.gw:-Gr.dims.gw], Pa) - return diff --git a/Turbulence.pyx b/Turbulence.pyx index a046db84..6aeeb411 100644 --- a/Turbulence.pyx +++ b/Turbulence.pyx @@ -39,8 +39,8 @@ cdef class ParameterizationBase: self.turbulence_tendency = np.zeros((Gr.nzg,), dtype=np.double, order='c') self.Gr = Gr # grid class self.Ref = Ref # reference state class - self.KM = VariableDiagnostic(Gr.nzg,'half', 'scalar','sym', 'diffusivity', 'm^2/s') # eddy viscosity - self.KH = VariableDiagnostic(Gr.nzg,'half', 'scalar','sym', 'viscosity', 'm^2/s') # eddy diffusivity + self.KM = VariableDiagnostic(Gr.nzg,'full', 'scalar','sym', 'diffusivity', 'm^2/s') # eddy viscosity + self.KH = VariableDiagnostic(Gr.nzg,'full', 'scalar','sym', 'viscosity', 'm^2/s') # eddy diffusivity # get values from paramlist self.prandtl_number = paramlist['turbulence']['prandtl_number'] self.Ri_bulk_crit = paramlist['turbulence']['Ri_bulk_crit'] diff --git a/Turbulence_PrognosticTKE.pxd b/Turbulence_PrognosticTKE.pxd index 950633c8..928cfcb0 100644 --- a/Turbulence_PrognosticTKE.pxd +++ b/Turbulence_PrognosticTKE.pxd @@ -86,13 +86,13 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cpdef io(self, NetCDFIO_Stats Stats) cpdef update(self,GridMeanVariables GMV, CasesBase Case, TimeStepping TS) cpdef compute_prognostic_updrafts(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS) - cpdef compute_diagnostic_updrafts(self, GridMeanVariables GMV, CasesBase Case) + cpdef compute_diagnostic_updrafts(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS) cpdef update_inversion(self, GridMeanVariables GMV, option) cpdef compute_mixing_length(self, double obukhov_length, GridMeanVariables GMV) cpdef compute_eddy_diffusivities_tke(self, GridMeanVariables GMV, CasesBase Case) cpdef reset_surface_tke(self, GridMeanVariables GMV, CasesBase Case) cpdef reset_surface_covariance(self, GridMeanVariables GMV, CasesBase Case) - cpdef set_updraft_surface_bc(self, GridMeanVariables GMV, CasesBase Case) + cpdef set_updraft_surface_bc(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS) cpdef decompose_environment(self, GridMeanVariables GMV, whichvals) cpdef compute_entrainment_detrainment(self, GridMeanVariables GMV, CasesBase Case) cpdef solve_updraft_velocity_area(self, GridMeanVariables GMV, TimeStepping TS) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 10ea1df8..82a35c85 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -22,6 +22,7 @@ from utility_functions cimport * from libc.math cimport fmax, sqrt, exp, pow, cbrt, fmin, fabs from cpython.mem cimport PyMem_Malloc, PyMem_Realloc, PyMem_Free import sys +import pylab as plt cdef class EDMF_PrognosticTKE(ParameterizationBase): # Initialize the class @@ -327,7 +328,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.decompose_environment(GMV, 'values') if self.use_steady_updrafts: - self.compute_diagnostic_updrafts(GMV, Case) + self.compute_diagnostic_updrafts(GMV, Case, TS) else: self.compute_prognostic_updrafts(GMV, Case, TS) @@ -357,7 +358,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.set_new_with_values() self.UpdVar.set_old_with_values() - self.set_updraft_surface_bc(GMV, Case) + self.set_updraft_surface_bc(GMV, Case, TS) self.dt_upd = np.minimum(TS.dt, 0.5 * self.Gr.dz/fmax(np.max(self.UpdVar.W.values),1e-10)) while time_elapsed < TS.dt: self.compute_entrainment_detrainment(GMV, Case) @@ -371,7 +372,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdThermo.buoyancy(self.UpdVar, self.EnvVar, GMV, self.extrapolate_buoyancy) return - cpdef compute_diagnostic_updrafts(self, GridMeanVariables GMV, CasesBase Case): + cpdef compute_diagnostic_updrafts(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS): cdef: Py_ssize_t i, k Py_ssize_t gw = self.Gr.gw @@ -383,7 +384,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double a,b,c, w, w_km, w_mid, w_low, denom, arg double entr_w, detr_w, B_k, area_k, w2 - self.set_updraft_surface_bc(GMV, Case) + self.set_updraft_surface_bc(GMV, Case, TS) self.compute_entrainment_detrainment(GMV, Case) @@ -587,7 +588,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): return - cpdef set_updraft_surface_bc(self, GridMeanVariables GMV, CasesBase Case): + cpdef set_updraft_surface_bc(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS): self.update_inversion(GMV, Case.inversion_option) self.wstar = get_wstar(Case.Sur.bflux, self.zi) @@ -595,6 +596,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cdef: Py_ssize_t i, gw = self.Gr.gw double zLL = self.Gr.z[gw] + double dzi = self.Gr.dzi + double dti_ = 0.1 + double adv, buoy, exch, press, press_buoy, press_drag double ustar = Case.Sur.ustar, oblength = Case.Sur.obukhov_length double alpha0LL = self.Ref.alpha0[gw] double qt_var = get_surface_variance(Case.Sur.rho_qtflux*alpha0LL, @@ -605,13 +609,29 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double a_ = self.surface_area/self.n_updrafts double surface_scalar_coeff + if self.dt_upd>0.0: + dti_ = 1.0/self.dt_upd + + # with nogil: for i in xrange(self.n_updrafts): surface_scalar_coeff= percentile_bounds_mean_norm(1.0-self.surface_area+i*a_, 1.0-self.surface_area + (i+1)*a_ , 1000) - + # use the w equation with w[gw-1] = 0 and dzi divided by 2 to obtain w[gw] - this need to change for diagnostic updrafts self.area_surface_bc[i] = self.surface_area/self.n_updrafts - self.w_surface_bc[i] = 0.0 + adv = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * self.UpdVar.W.values[i,gw] * dzi/2.0) + exch = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] + * (self.entr_sc[i,gw] * self.EnvVar.W.values[gw] - self.detr_sc[i,gw] * self.UpdVar.W.values[i,gw] )) + buoy= self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.B.values[i,gw] + press_buoy = -1.0 * self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.B.values[i,gw] * self.pressure_buoy_coeff + press_drag = -1.0 * self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * (self.pressure_drag_coeff/self.pressure_plume_spacing + * (self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])**2.0/sqrt(fmax(self.UpdVar.Area.values[i,gw],self.minimum_area))) + press = press_buoy + press_drag + self.w_surface_bc[i] = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * dti_ + -adv + exch + buoy + press)/(self.Ref.rho0[gw] * self.UpdVar.Area.new[i,gw] * dti_) + print 'BC', -adv ,exch ,buoy ,press, 'self.UpdVar.B.values[i,gw]', self.UpdVar.B.values[i,gw] + self.updraft_pressure_sink[i,gw] = press + self.h_surface_bc[i] = (GMV.H.values[gw] + surface_scalar_coeff * sqrt(h_var)) self.qt_surface_bc[i] = (GMV.QT.values[gw] + surface_scalar_coeff * sqrt(qt_var)) return @@ -715,7 +735,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): interp_w_diff = we.values[k]-gmv_w[k] gmv_tke[k] = ae[k] * interp_w_diff * interp_w_diff + ae[k] * tke_e.values[k] for i in xrange(self.n_updrafts): - interp_w_diff = interp2pt(wu.values[i,k-1]-gmv_w[k-1],wu.values[i,k]-gmv_w[k]) + interp_w_diff = wu.values[i,k]-gmv_w[k] gmv_tke[k] += au.values[i,k] *interp_w_diff * interp_w_diff return @@ -732,11 +752,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(self.Gr.nzg): if ae[k] > 0.0: - interp_w_diff = interp2pt(we.values[k-1]-gmv_w[k-1],we.values[k]-gmv_w[k]) + interp_w_diff = we.values[k]-gmv_w[k] tke_e.values[k] = gmv_tke[k] - ae[k] * interp_w_diff * interp_w_diff for i in xrange(self.n_updrafts): - interp_w_diff = interp2pt(wu.values[i,k-1]-gmv_w[k-1],wu.values[i,k]-gmv_w[k]) + interp_w_diff = wu.values[i,k]-gmv_w[k] tke_e.values[k] -= au.values[i,k] *interp_w_diff * interp_w_diff tke_e.values[k] = tke_e.values[k]/ae[k] else: @@ -852,87 +872,74 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double dzi = self.Gr.dzi double dti_ = 1.0/self.dt_upd double dt_ = 1.0/dti_ - double whalf_kp, whalf_k,whalf_km double a1, a2 # groupings of terms in area fraction discrete equation double au_lim - double anew_k, a_k, a_km, entr_w, detr_w, B_k, entr_term, detr_term, rho_ratio, a_kp + double entr_w, detr_w, entr_term, detr_term, rho_ratio, a_kp double adv, buoy, exch, press, press_buoy, press_drag # groupings of terms in velocity discrete equation - with nogil: - for i in xrange(self.n_updrafts): - self.entr_sc[i,gw] = 2.0 * dzi - self.detr_sc[i,gw] = 0.0 - self.UpdVar.W.new[i,gw-1] = self.w_surface_bc[i] - self.UpdVar.Area.new[i,gw] = self.area_surface_bc[i] - au_lim = self.area_surface_bc[i] * self.max_area_factor - - for k in range(gw+1, self.Gr.nzg-gw): - - # First solve for updated area fraction at k+1 - whalf_kp = self.UpdVar.W.values[i,k+1] - whalf_k = self.UpdVar.W.values[i,k] - whalf_km = self.UpdVar.W.values[i,k-1] - adv = -self.Ref.alpha0[k] * dzi *( self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * whalf_k - -self.Ref.rho0[k-1] * self.UpdVar.Area.values[i,k-1] * whalf_km) - entr_term = self.UpdVar.Area.values[i,k] * whalf_k * (self.entr_sc[i,k] ) - detr_term = self.UpdVar.Area.values[i,k] * whalf_k * (- self.detr_sc[i,k]) - - - self.UpdVar.Area.new[i,k] = fmax(dt_ * (adv + entr_term + detr_term) + self.UpdVar.Area.values[i,k], 0.0) - if self.UpdVar.Area.new[i,k] > au_lim: - self.UpdVar.Area.new[i,k] = au_lim - if self.UpdVar.Area.values[i,k] > 0.0: - self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ - adv -entr_term)/(-self.UpdVar.Area.values[i,k] * whalf_k)) - else: - # this detrainment rate won't affect scalars but would affect velocity - self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ - adv -entr_term)/(-au_lim * whalf_kp)) - - # Now solve for updraft velocity at k - rho_ratio = self.Ref.rho0[k-1]/self.Ref.rho0[k] - anew_k = self.UpdVar.Area.new[i,k] - if anew_k >= self.minimum_area: - a_k = self.UpdVar.Area.values[i,k] - a_km = self.UpdVar.Area.values[i,k-1] - a_kp = self.UpdVar.Area.values[i,k+1] - entr_w = self.entr_sc[i,k] - detr_w = self.detr_sc[i,k] - B_k = self.UpdVar.B.values[i,k] - adv = (self.Ref.rho0[k] * a_k * self.UpdVar.W.values[i,k] * self.UpdVar.W.values[i,k] * dzi - - self.Ref.rho0[k-1] * a_km * self.UpdVar.W.values[i,k-1] * self.UpdVar.W.values[i,k-1] * dzi) - exch = (self.Ref.rho0[k] * a_k * self.UpdVar.W.values[i,k] - * (entr_w * self.EnvVar.W.values[k] - detr_w * self.UpdVar.W.values[i,k] )) - buoy= self.Ref.rho0[k] * a_k * B_k - press_buoy = -1.0 * self.Ref.rho0[k] * a_k * B_k * self.pressure_buoy_coeff - press_drag = -1.0 * self.Ref.rho0[k] * a_k * (self.pressure_drag_coeff/self.pressure_plume_spacing - * (self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k])**2.0/sqrt(fmax(a_k,self.minimum_area))) - press = press_buoy + press_drag - self.updraft_pressure_sink[i,k] = press - self.UpdVar.W.new[i,k] = (self.Ref.rho0[k] * a_k * self.UpdVar.W.values[i,k] * dti_ - -adv + exch + buoy + press)/(self.Ref.rho0[k] * anew_k * dti_) - - if self.UpdVar.W.new[i,k] <= 0.0: - self.UpdVar.W.new[i,k:] = 0.0 - self.UpdVar.Area.new[i,k+1:] = 0.0 - break + #with nogil: + # issues wth whether the BC is applied to values or new and at which k + for i in xrange(self.n_updrafts): + self.entr_sc[i,gw] = 2.0 * dzi + self.detr_sc[i,gw] = 0.0 + self.UpdVar.W.new[i,gw] = self.w_surface_bc[i] + self.UpdVar.Area.new[i,gw] = self.area_surface_bc[i] + au_lim = self.area_surface_bc[i] * self.max_area_factor + #self.UpdVar.W.values[i,gw] = sqrt(2.0*self.UpdVar.B.values[i,gw]) + for k in range(gw+1, self.Gr.nzg-gw): + # First solve for updated area fraction at k+1 + adv = -self.Ref.alpha0[k] * dzi *( self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] + -self.Ref.rho0[k-1] * self.UpdVar.Area.values[i,k-1] * self.UpdVar.W.values[i,k-1]) + entr_term = self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * (self.entr_sc[i,k] ) + detr_term = self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * (- self.detr_sc[i,k]) + + + self.UpdVar.Area.new[i,k] = fmax(dt_ * (adv + entr_term + detr_term) + self.UpdVar.Area.values[i,k], 0.0) + print '.Area.new[i,k]', self.UpdVar.Area.new[i,k], 'Area.values[i,k],', self.UpdVar.Area.values[i,k], 'adv',adv,'entr',entr_term ,'detr', detr_term + plt.figure() + plt.show() + + #print self.UpdVar.Area.new[i,k], adv ,entr_term ,detr_term, self.UpdVar.Area.values[i,k] + if self.UpdVar.Area.new[i,k] > au_lim: + self.UpdVar.Area.new[i,k] = au_lim + if self.UpdVar.Area.values[i,k] > 0.0: + self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ - adv -entr_term)/(-self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k])) else: + # this detrainment rate won't affect scalars but would affect velocity + self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ - adv -entr_term)/(-au_lim * self.UpdVar.W.values[i,k+1])) + + # Now solve for updraft velocity at k + rho_ratio = self.Ref.rho0[k-1]/self.Ref.rho0[k] + print '912', self.UpdVar.Area.new[i,k], self.minimum_area, self.UpdVar.Area.new[i,gw], self.UpdVar.W.new[i,gw] + if self.UpdVar.Area.new[i,k] >= self.minimum_area: + print '914 - inside' + entr_w = self.entr_sc[i,k] + detr_w = self.detr_sc[i,k] + adv = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.UpdVar.W.values[i,k] * dzi + - self.Ref.rho0[k-1] * self.UpdVar.Area.values[i,k-1] * self.UpdVar.W.values[i,k-1] * self.UpdVar.W.values[i,k-1] * dzi) + exch = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] + * (entr_w * self.EnvVar.W.values[k] - detr_w * self.UpdVar.W.values[i,k] )) + buoy= self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] + press_buoy = -1.0 * self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] * self.pressure_buoy_coeff + press_drag = -1.0 * self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * (self.pressure_drag_coeff/self.pressure_plume_spacing + * (self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k])**2.0/sqrt(fmax(self.UpdVar.Area.values[i,k],self.minimum_area))) + press = press_buoy + press_drag + self.updraft_pressure_sink[i,k] = press + self.UpdVar.W.new[i,k] = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * dti_ + -adv + exch + buoy + press)/(self.Ref.rho0[k] * self.UpdVar.Area.new[i,k] * dti_) + + print '924', k, 'W.new', self.UpdVar.W.new[i,k], 'W.values[i,k]', self.UpdVar.W.values[i,k], 'W.values[i,k-1]', self.UpdVar.W.values[i,k-1], 'adv',adv ,'exch', exch, 'buoy', buoy, 'press', press + if self.UpdVar.W.new[i,k] <= 0.0: self.UpdVar.W.new[i,k:] = 0.0 self.UpdVar.Area.new[i,k+1:] = 0.0 - # keep this in mind if we modify updraft top treatment! - self.updraft_pressure_sink[i,k:] = 0.0 break - # the above lines were replaced by the followings to allow integration above negative w - # the model output is sensitive to the choice of value in the condition : <= 0.01 - # if self.UpdVar.W.new[i,k] <= 0.01: - # self.UpdVar.W.new[i,k] = 0.0 - # self.UpdVar.Area.new[i,k+1] = 0.0 - # #break - # else: - # self.UpdVar.W.new[i,k] = 0.0 - # self.UpdVar.Area.new[i,k+1] = 0.0 - # #break - # plt.figure('area') - # plt.plot(self.UpdVar.Area.new[0,:], self.Gr.z) - # plt.show() + + else: + self.UpdVar.W.new[i,k:] = 0.0 + self.UpdVar.Area.new[i,k+1:] = 0.0 + # keep this in mind if we modify updraft top treatment! + self.updraft_pressure_sink[i,k:] = 0.0 + break return @@ -951,16 +958,16 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): if self.use_local_micro: with nogil: for i in xrange(self.n_updrafts): - self.UpdVar.H.new[i,gw] = self.h_surface_bc[i] - self.UpdVar.QT.new[i,gw] = self.qt_surface_bc[i] + self.UpdVar.H.values[i,gw] = self.h_surface_bc[i] + self.UpdVar.QT.values[i,gw] = self.qt_surface_bc[i] sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, - self.Ref.p0[gw], self.UpdVar.QT.new[i,gw], self.UpdVar.H.new[i,gw]) - self.UpdVar.QL.new[i,gw] = sa.ql - self.UpdVar.T.new[i,gw] = sa.T - self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0[gw], self.UpdVar.T.new[i,gw], - &self.UpdVar.QT.new[i,gw], &self.UpdVar.QL.new[i,gw], - &self.UpdVar.H.new[i,gw], i, gw) + self.Ref.p0[gw], self.UpdVar.QT.values[i,gw], self.UpdVar.H.values[i,gw]) + self.UpdVar.QL.values[i,gw] = sa.ql + self.UpdVar.T.values[i,gw] = sa.T + self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0[gw], self.UpdVar.T.values[i,gw], + &self.UpdVar.QT.values[i,gw], &self.UpdVar.QL.values[i,gw], + &self.UpdVar.H.values[i,gw], i, gw) for k in xrange(gw+1, self.Gr.nzg-gw): H_entr = self.EnvVar.H.values[k] QT_entr = self.EnvVar.QT.values[k] @@ -982,8 +989,12 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): else: self.UpdVar.H.new[i,k] = GMV.H.values[k] self.UpdVar.QT.new[i,k] = GMV.QT.values[k] + sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0[k], self.UpdVar.QT.new[i,k], self.UpdVar.H.new[i,k]) + if self.UpdVar.H.new[i,k] > 330.0 or self.UpdVar.H.new[i,k] <290.0: + with gil: + print 'sa.ql',sa.ql, 'sa.T', sa.T, 'self.UpdVar.H.new[i,k]', self.UpdVar.H.new[i,k], 'self.UpdVar.QT.new[i,k] ',self.UpdVar.QT.new[i,k] self.UpdVar.QL.new[i,k] = sa.ql self.UpdVar.T.new[i,k] = sa.T self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0[k], self.UpdVar.T.new[i,k], diff --git a/Variables.pyx b/Variables.pyx index 393c08d9..ee0fe691 100644 --- a/Variables.pyx +++ b/Variables.pyx @@ -26,8 +26,8 @@ cdef class VariablePrognostic: self.tendencies = np.zeros((nz_tot,),dtype=np.double, order='c') # Placement on staggered grid loc = 'full' - if loc != 'half' and loc != 'full': - print('Invalid location setting for variable! Must be half or full') + if loc != 'full': + print('Invalid location setting for variable! Must be full') self.loc = loc if kind != 'scalar' and kind != 'velocity': print ('Invalid kind setting for variable! Must be scalar or velocity') @@ -94,8 +94,8 @@ cdef class VariableDiagnostic: self.values = np.zeros((nz_tot,),dtype=np.double, order='c') # Placement on staggered grid loc = 'full' - if loc != 'half' and loc != 'full': - print('Invalid location setting for variable! Must be half or full') + if loc != 'full': + print('Invalid location setting for variable! Must be full') self.loc = loc if kind != 'scalar' and kind != 'velocity': print ('Invalid kind setting for variable! Must be scalar or velocity') diff --git a/turbulence_functions.pxd b/turbulence_functions.pxd index c32ae52c..8e82e4f5 100644 --- a/turbulence_functions.pxd +++ b/turbulence_functions.pxd @@ -43,7 +43,7 @@ cdef evap_struct evap_sat_adjust(double p0, double thetal_, double qt_mix) nogil cdef double entr_detr_buoyancy_sorting(entr_in_struct entr_in) nogil cdef double get_wstar(double bflux, double zi ) -cdef double get_inversion(double *theta_rho, double *u, double *v, double *z_half, +cdef double get_inversion(double *theta_rho, double *u, double *v, double *z, Py_ssize_t kmin, Py_ssize_t kmax, double Ri_bulk_crit) cdef double get_mixing_tau(double zi, double wstar) nogil diff --git a/turbulence_functions.pyx b/turbulence_functions.pyx index 84a946a5..3b5f8f98 100644 --- a/turbulence_functions.pyx +++ b/turbulence_functions.pyx @@ -200,7 +200,7 @@ cdef double get_wstar(double bflux, double zi ): return cbrt(fmax(bflux * zi, 0.0)) # BL height -cdef double get_inversion(double *theta_rho, double *u, double *v, double *z_half, +cdef double get_inversion(double *theta_rho, double *u, double *v, double *z, Py_ssize_t kmin, Py_ssize_t kmax, double Ri_bulk_crit): cdef: double theta_rho_b = theta_rho[kmin] @@ -214,15 +214,15 @@ cdef double get_inversion(double *theta_rho, double *u, double *v, double *z_hal for k in xrange(kmin,kmax): if theta_rho[k] > theta_rho_b: break - h = (z_half[k] - z_half[k-1])/(theta_rho[k] - theta_rho[k-1]) * (theta_rho_b - theta_rho[k-1]) + z_half[k-1] + h = (z[k] - z[k-1])/(theta_rho[k] - theta_rho[k-1]) * (theta_rho_b - theta_rho[k-1]) + z[k-1] else: with nogil: for k in xrange(kmin,kmax): Ri_bulk_low = Ri_bulk - Ri_bulk = g * (theta_rho[k] - theta_rho_b) * z_half[k]/theta_rho_b / (u[k] * u[k] + v[k] * v[k]) + Ri_bulk = g * (theta_rho[k] - theta_rho_b) * z[k]/theta_rho_b / (u[k] * u[k] + v[k] * v[k]) if Ri_bulk > Ri_bulk_crit: break - h = (z_half[k] - z_half[k-1])/(Ri_bulk - Ri_bulk_low) * (Ri_bulk_crit - Ri_bulk_low) + z_half[k-1] + h = (z[k] - z[k-1])/(Ri_bulk - Ri_bulk_low) * (Ri_bulk_crit - Ri_bulk_low) + z[k-1] return h From e5e1af5b4c8b636e077782eae3960005c4ad9a1b Mon Sep 17 00:00:00 2001 From: yairchn Date: Mon, 30 Jul 2018 11:32:56 -0700 Subject: [PATCH 013/136] .. --- Turbulence_PrognosticTKE.pyx | 29 +++++++++++++++++------------ 1 file changed, 17 insertions(+), 12 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 82a35c85..76e5cb25 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -619,21 +619,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): 1.0-self.surface_area + (i+1)*a_ , 1000) # use the w equation with w[gw-1] = 0 and dzi divided by 2 to obtain w[gw] - this need to change for diagnostic updrafts self.area_surface_bc[i] = self.surface_area/self.n_updrafts - adv = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * self.UpdVar.W.values[i,gw] * dzi/2.0) - exch = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] - * (self.entr_sc[i,gw] * self.EnvVar.W.values[gw] - self.detr_sc[i,gw] * self.UpdVar.W.values[i,gw] )) - buoy= self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.B.values[i,gw] - press_buoy = -1.0 * self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.B.values[i,gw] * self.pressure_buoy_coeff - press_drag = -1.0 * self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * (self.pressure_drag_coeff/self.pressure_plume_spacing - * (self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])**2.0/sqrt(fmax(self.UpdVar.Area.values[i,gw],self.minimum_area))) - press = press_buoy + press_drag - self.w_surface_bc[i] = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * dti_ - -adv + exch + buoy + press)/(self.Ref.rho0[gw] * self.UpdVar.Area.new[i,gw] * dti_) - print 'BC', -adv ,exch ,buoy ,press, 'self.UpdVar.B.values[i,gw]', self.UpdVar.B.values[i,gw] self.updraft_pressure_sink[i,gw] = press self.h_surface_bc[i] = (GMV.H.values[gw] + surface_scalar_coeff * sqrt(h_var)) self.qt_surface_bc[i] = (GMV.QT.values[gw] + surface_scalar_coeff * sqrt(qt_var)) + return cpdef reset_surface_tke(self, GridMeanVariables GMV, CasesBase Case): @@ -882,9 +872,24 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for i in xrange(self.n_updrafts): self.entr_sc[i,gw] = 2.0 * dzi self.detr_sc[i,gw] = 0.0 - self.UpdVar.W.new[i,gw] = self.w_surface_bc[i] self.UpdVar.Area.new[i,gw] = self.area_surface_bc[i] au_lim = self.area_surface_bc[i] * self.max_area_factor + + self.UpdVar.B.values[i,gw]= self.UpdThermo.buoyancy(self.UpdVar, self.EnvVar, GMV, self.extrapolate_buoyancy) + adv = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * self.UpdVar.W.values[i,gw] * dzi/2.0) + exch = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] + * (self.entr_sc[i,gw] * self.EnvVar.W.values[gw] - self.detr_sc[i,gw] * self.UpdVar.W.values[i,gw] )) + buoy= self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.B.values[i,gw] + press_buoy = -1.0 * self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.B.values[i,gw] * self.pressure_buoy_coeff + press_drag = -1.0 * self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * (self.pressure_drag_coeff/self.pressure_plume_spacing + * (self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])**2.0/sqrt(fmax(self.UpdVar.Area.values[i,gw],self.minimum_area))) + press = press_buoy + press_drag + self.UpdVar.W.new[i,gw] = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * dti_ + -adv + exch + buoy + press)/(self.Ref.rho0[gw] * self.UpdVar.Area.new[i,gw] * dti_) + print adv ,exch, buoy, press,self.UpdVar.W.new[i,gw] + plt.figure() + plt.show() + #self.UpdVar.W.values[i,gw] = sqrt(2.0*self.UpdVar.B.values[i,gw]) for k in range(gw+1, self.Gr.nzg-gw): # First solve for updated area fraction at k+1 From f259b75d76c9561277e2e6db6c582e3c36c9c817 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Mon, 30 Jul 2018 13:14:44 -0700 Subject: [PATCH 014/136] .. --- Turbulence_PrognosticTKE.pyx | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 76e5cb25..4ca15e17 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -454,7 +454,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): au_lim = self.max_area_factor * self.area_surface_bc[i] self.UpdVar.Area.values[i,gw] = self.area_surface_bc[i] w_mid = 0.5* (self.UpdVar.W.values[i,gw]) - for k in xrange(gw+1, self.Gr.nzg): + for k in xrange(gw, self.Gr.nzg): # yair +1 w_low = w_mid w_mid = self.UpdVar.W.values[i,k] if w_mid > 0.0: @@ -863,7 +863,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double dti_ = 1.0/self.dt_upd double dt_ = 1.0/dti_ double a1, a2 # groupings of terms in area fraction discrete equation - double au_lim + double au_lim,alpha_srf double entr_w, detr_w, entr_term, detr_term, rho_ratio, a_kp double adv, buoy, exch, press, press_buoy, press_drag # groupings of terms in velocity discrete equation @@ -874,8 +874,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.detr_sc[i,gw] = 0.0 self.UpdVar.Area.new[i,gw] = self.area_surface_bc[i] au_lim = self.area_surface_bc[i] * self.max_area_factor + #self.UpdThermo.buoyancy(self.UpdVar, self.EnvVar, GMV, self.extrapolate_buoyancy) + #alpha_srf = alpha_c(self.Ref.p0[gw], self.UpdVar.T.values[i,gw], self.UpdVar.QT.values[i,gw],self.UpdVar.QT.values[i,gw]) + #self.UpdVar.B.values[i,gw]= buoyancy_c(self.Ref.alpha0[gw], alpha_srf) + print 'self.UpdVar.B.values[i,gw]',self.UpdVar.B.values[i,gw], self.EnvVar.B.values[gw] - self.UpdVar.B.values[i,gw]= self.UpdThermo.buoyancy(self.UpdVar, self.EnvVar, GMV, self.extrapolate_buoyancy) adv = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * self.UpdVar.W.values[i,gw] * dzi/2.0) exch = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * (self.entr_sc[i,gw] * self.EnvVar.W.values[gw] - self.detr_sc[i,gw] * self.UpdVar.W.values[i,gw] )) From d35484158de6decc19d8c010ab305a5330bde904 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Mon, 30 Jul 2018 16:17:55 -0700 Subject: [PATCH 015/136] .. --- Turbulence_PrognosticTKE.pyx | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 4ca15e17..0dcafd23 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -878,6 +878,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): #alpha_srf = alpha_c(self.Ref.p0[gw], self.UpdVar.T.values[i,gw], self.UpdVar.QT.values[i,gw],self.UpdVar.QT.values[i,gw]) #self.UpdVar.B.values[i,gw]= buoyancy_c(self.Ref.alpha0[gw], alpha_srf) print 'self.UpdVar.B.values[i,gw]',self.UpdVar.B.values[i,gw], self.EnvVar.B.values[gw] + print 'self.h_surface_bc[i]', self.h_surface_bc[i] + print 'self.UpdVar.QT.values[i,gw]', self.UpdVar.QT.values[i,gw] adv = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * self.UpdVar.W.values[i,gw] * dzi/2.0) exch = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] From 5db9c9d9a80f1f0981f251f5fc3414724cdec502 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Mon, 30 Jul 2018 16:41:21 -0700 Subject: [PATCH 016/136] .. --- Turbulence_PrognosticTKE.pyx | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 0dcafd23..2622fecf 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -877,7 +877,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): #self.UpdThermo.buoyancy(self.UpdVar, self.EnvVar, GMV, self.extrapolate_buoyancy) #alpha_srf = alpha_c(self.Ref.p0[gw], self.UpdVar.T.values[i,gw], self.UpdVar.QT.values[i,gw],self.UpdVar.QT.values[i,gw]) #self.UpdVar.B.values[i,gw]= buoyancy_c(self.Ref.alpha0[gw], alpha_srf) - print 'self.UpdVar.B.values[i,gw]',self.UpdVar.B.values[i,gw], self.EnvVar.B.values[gw] + print 'self.UpdVar.B.values[i,gw]',self.UpdVar.B.values[i,gw] + print 'self.UpdVar.B.values[i,gw]',self.UpdVar.B.new[i,gw] print 'self.h_surface_bc[i]', self.h_surface_bc[i] print 'self.UpdVar.QT.values[i,gw]', self.UpdVar.QT.values[i,gw] From 57cc55e8eb0123fa3251254da8b8ecac2a20d7f9 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Mon, 30 Jul 2018 18:18:16 -0700 Subject: [PATCH 017/136] .. --- Grid.pyx | 2 +- ReferenceState.pyx | 16 ++++++++++++---- Turbulence_PrognosticTKE.pxd | 4 ++-- Turbulence_PrognosticTKE.pyx | 17 ++++++++++------- 4 files changed, 25 insertions(+), 14 deletions(-) diff --git a/Grid.pyx b/Grid.pyx index 2fdab484..60c2e876 100644 --- a/Grid.pyx +++ b/Grid.pyx @@ -38,7 +38,7 @@ cdef class Grid: cdef int i, count = 0 for i in xrange(-self.gw,self.nz+self.gw,1): - self.z[count] = (i + 1) * self.dz + self.z[count] = (i + 0.5) * self.dz count += 1 diff --git a/ReferenceState.pyx b/ReferenceState.pyx index f38129ec..b9b2fdbf 100644 --- a/ReferenceState.pyx +++ b/ReferenceState.pyx @@ -58,7 +58,9 @@ cdef class ReferenceState: ##_____________TO COMPILE______________ # Construct arrays for integration points - z = np.array(Gr.z[Gr.gw - 1:-Gr.gw + 1]) + z = np.array(Gr.z[Gr.gw-1:-Gr.gw+1]) + print + #z = np.append([0.0], np.array(Gr.z[Gr.gw:-Gr.gw])) # We are integrating the log pressure so need to take the log of the # surface pressure @@ -70,9 +72,8 @@ cdef class ReferenceState: p[Gr.gw - 1:-Gr.gw +1] = odeint(rhs, p0, z, hmax=1.0)[:, 0] # Set boundary conditions - p[:Gr.gw - 1] = p[2 * Gr.gw - 2:Gr.gw - 1:-1] - p[-Gr.gw + 1:] = p[-Gr.gw - 1:-2 * Gr.gw:-1] - + p[:Gr.gw] = p[2 * Gr.gw - 1:Gr.gw - 1:-1] + p[-Gr.gw:] = p[-Gr.gw - 1:-2 * Gr.gw - 1:-1] p = np.exp(p) @@ -93,6 +94,13 @@ cdef class ReferenceState: ql[k] = ret.ql qv[k] = self.qtg - (ql[k] + qi[k]) alpha[k] = alpha_c(p_[k], temperature[k], self.qtg, qv[k]) + ret = eos(t_to_entropy_c, eos_first_guess_entropy, p_[k], self.qtg, self.sg) + temperature[k] = ret.T + ql[k] = ret.ql + qv[k] = self.qtg - (ql[k] + qi[k]) + alpha[k] = alpha_c(p_[k], temperature[k], self.qtg, qv[k]) + + # Now do a sanity check to make sure that the Reference State entropy profile is uniform following # saturation adjustment diff --git a/Turbulence_PrognosticTKE.pxd b/Turbulence_PrognosticTKE.pxd index 928cfcb0..950633c8 100644 --- a/Turbulence_PrognosticTKE.pxd +++ b/Turbulence_PrognosticTKE.pxd @@ -86,13 +86,13 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cpdef io(self, NetCDFIO_Stats Stats) cpdef update(self,GridMeanVariables GMV, CasesBase Case, TimeStepping TS) cpdef compute_prognostic_updrafts(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS) - cpdef compute_diagnostic_updrafts(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS) + cpdef compute_diagnostic_updrafts(self, GridMeanVariables GMV, CasesBase Case) cpdef update_inversion(self, GridMeanVariables GMV, option) cpdef compute_mixing_length(self, double obukhov_length, GridMeanVariables GMV) cpdef compute_eddy_diffusivities_tke(self, GridMeanVariables GMV, CasesBase Case) cpdef reset_surface_tke(self, GridMeanVariables GMV, CasesBase Case) cpdef reset_surface_covariance(self, GridMeanVariables GMV, CasesBase Case) - cpdef set_updraft_surface_bc(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS) + cpdef set_updraft_surface_bc(self, GridMeanVariables GMV, CasesBase Case) cpdef decompose_environment(self, GridMeanVariables GMV, whichvals) cpdef compute_entrainment_detrainment(self, GridMeanVariables GMV, CasesBase Case) cpdef solve_updraft_velocity_area(self, GridMeanVariables GMV, TimeStepping TS) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 2622fecf..127cc6bc 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -328,7 +328,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.decompose_environment(GMV, 'values') if self.use_steady_updrafts: - self.compute_diagnostic_updrafts(GMV, Case, TS) + self.compute_diagnostic_updrafts(GMV, Case) else: self.compute_prognostic_updrafts(GMV, Case, TS) @@ -358,7 +358,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.set_new_with_values() self.UpdVar.set_old_with_values() - self.set_updraft_surface_bc(GMV, Case, TS) + self.set_updraft_surface_bc(GMV, Case) self.dt_upd = np.minimum(TS.dt, 0.5 * self.Gr.dz/fmax(np.max(self.UpdVar.W.values),1e-10)) while time_elapsed < TS.dt: self.compute_entrainment_detrainment(GMV, Case) @@ -372,7 +372,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdThermo.buoyancy(self.UpdVar, self.EnvVar, GMV, self.extrapolate_buoyancy) return - cpdef compute_diagnostic_updrafts(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS): + cpdef compute_diagnostic_updrafts(self, GridMeanVariables GMV, CasesBase Case): cdef: Py_ssize_t i, k Py_ssize_t gw = self.Gr.gw @@ -384,7 +384,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double a,b,c, w, w_km, w_mid, w_low, denom, arg double entr_w, detr_w, B_k, area_k, w2 - self.set_updraft_surface_bc(GMV, Case, TS) + self.set_updraft_surface_bc(GMV, Case) self.compute_entrainment_detrainment(GMV, Case) @@ -392,6 +392,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for i in xrange(self.n_updrafts): self.UpdVar.H.values[i,gw] = self.h_surface_bc[i] self.UpdVar.QT.values[i,gw] = self.qt_surface_bc[i] + with gil: + print '393:','self.h_surface_bc[i]', self.h_surface_bc[i], 'self.qt_surface_bc[i]', self.qt_surface_bc[i] # Find the cloud liquid content sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0[gw], self.UpdVar.QT.values[i,gw], self.UpdVar.H.values[i,gw]) @@ -588,7 +590,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): return - cpdef set_updraft_surface_bc(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS): + cpdef set_updraft_surface_bc(self, GridMeanVariables GMV, CasesBase Case): self.update_inversion(GMV, Case.inversion_option) self.wstar = get_wstar(Case.Sur.bflux, self.zi) @@ -609,8 +611,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double a_ = self.surface_area/self.n_updrafts double surface_scalar_coeff - if self.dt_upd>0.0: - dti_ = 1.0/self.dt_upd + #if self.dt_upd>0.0: + # dti_ = 1.0/self.dt_upd # with nogil: @@ -623,6 +625,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.h_surface_bc[i] = (GMV.H.values[gw] + surface_scalar_coeff * sqrt(h_var)) self.qt_surface_bc[i] = (GMV.QT.values[gw] + surface_scalar_coeff * sqrt(qt_var)) + print 'self.h_surface_bc[i]', self.h_surface_bc[i], 'self.qt_surface_bc[i]', self.qt_surface_bc[i] return From 767b78c84ac9f7b64e4734d9c6e97fd4f3864802 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Mon, 30 Jul 2018 18:34:07 -0700 Subject: [PATCH 018/136] .. --- ReferenceState.pyx | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/ReferenceState.pyx b/ReferenceState.pyx index b9b2fdbf..47a7dfdf 100644 --- a/ReferenceState.pyx +++ b/ReferenceState.pyx @@ -59,7 +59,7 @@ cdef class ReferenceState: # Construct arrays for integration points z = np.array(Gr.z[Gr.gw-1:-Gr.gw+1]) - print + #z = np.append([0.0], np.array(Gr.z[Gr.gw:-Gr.gw])) # We are integrating the log pressure so need to take the log of the @@ -67,7 +67,10 @@ cdef class ReferenceState: p0 = np.log(self.Pg) p = np.zeros(Gr.nzg, dtype=np.double, order='c') - + print Gr.gw + print np.shape(np.multiply(Gr.z,1.0)) + print np.shape(np.multiply(z,1.0)) + print np.shape(np.multiply(p,1.0)) # Perform the integration p[Gr.gw - 1:-Gr.gw +1] = odeint(rhs, p0, z, hmax=1.0)[:, 0] From e57b6395168df5c454d4a635b5a5d14300789139 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Mon, 30 Jul 2018 19:13:14 -0700 Subject: [PATCH 019/136] .. --- ReferenceState.pyx | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/ReferenceState.pyx b/ReferenceState.pyx index 47a7dfdf..cc0be528 100644 --- a/ReferenceState.pyx +++ b/ReferenceState.pyx @@ -58,7 +58,8 @@ cdef class ReferenceState: ##_____________TO COMPILE______________ # Construct arrays for integration points - z = np.array(Gr.z[Gr.gw-1:-Gr.gw+1]) + #z = np.array(Gr.z[Gr.gw-1:-Gr.gw+1]) + z = np.append([0.0], np.array(Gr.z[Gr.gw:-Gr.gw])) #z = np.append([0.0], np.array(Gr.z[Gr.gw:-Gr.gw])) @@ -67,10 +68,10 @@ cdef class ReferenceState: p0 = np.log(self.Pg) p = np.zeros(Gr.nzg, dtype=np.double, order='c') - print Gr.gw - print np.shape(np.multiply(Gr.z,1.0)) - print np.shape(np.multiply(z,1.0)) - print np.shape(np.multiply(p,1.0)) + print 'Gr.z[0]', Gr.z[0] + print 'np.shape(np.multiply(z,1.0))',np.shape(np.multiply(z,1.0)) + print 'np.shape(np.multiply(Gr.z[Gr.gw:-Gr.gw],1.0))',np.shape(np.multiply(Gr.z[Gr.gw:-Gr.gw],1.0)) + print 'np.shape(np.multiply(p,1.0))',np.shape(np.multiply(p,1.0)) # Perform the integration p[Gr.gw - 1:-Gr.gw +1] = odeint(rhs, p0, z, hmax=1.0)[:, 0] From bcf52b1c364de83aa58bae48138a778d68c77097 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Mon, 30 Jul 2018 20:29:05 -0700 Subject: [PATCH 020/136] .. --- ReferenceState.pyx | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ReferenceState.pyx b/ReferenceState.pyx index cc0be528..78b57342 100644 --- a/ReferenceState.pyx +++ b/ReferenceState.pyx @@ -73,7 +73,8 @@ cdef class ReferenceState: print 'np.shape(np.multiply(Gr.z[Gr.gw:-Gr.gw],1.0))',np.shape(np.multiply(Gr.z[Gr.gw:-Gr.gw],1.0)) print 'np.shape(np.multiply(p,1.0))',np.shape(np.multiply(p,1.0)) # Perform the integration - p[Gr.gw - 1:-Gr.gw +1] = odeint(rhs, p0, z, hmax=1.0)[:, 0] + p[Gr.gw:-Gr.gw] = odeint(rhs, p0, z, hmax=1.0)[:, 0] + print 'p[Gr.gw]',p[Gr.gw] # Set boundary conditions p[:Gr.gw] = p[2 * Gr.gw - 1:Gr.gw - 1:-1] From fd9f3e26d77e537718d8e384e8f2eb4f1d42b1ed Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Mon, 30 Jul 2018 20:46:08 -0700 Subject: [PATCH 021/136] .. --- ReferenceState.pyx | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ReferenceState.pyx b/ReferenceState.pyx index 78b57342..987f5fba 100644 --- a/ReferenceState.pyx +++ b/ReferenceState.pyx @@ -73,8 +73,9 @@ cdef class ReferenceState: print 'np.shape(np.multiply(Gr.z[Gr.gw:-Gr.gw],1.0))',np.shape(np.multiply(Gr.z[Gr.gw:-Gr.gw],1.0)) print 'np.shape(np.multiply(p,1.0))',np.shape(np.multiply(p,1.0)) # Perform the integration - p[Gr.gw:-Gr.gw] = odeint(rhs, p0, z, hmax=1.0)[:, 0] + p[Gr.gw:-Gr.gw] = odeint(rhs, p0, z, hmax=1.0)[1:, 0] print 'p[Gr.gw]',p[Gr.gw] + print 'Gr.z[Gr.gw]',Gr.z[Gr.gw] # Set boundary conditions p[:Gr.gw] = p[2 * Gr.gw - 1:Gr.gw - 1:-1] From d26faa0742cd859d72afcd9b8cbfcf189c183370 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Tue, 31 Jul 2018 09:33:25 -0700 Subject: [PATCH 022/136] .. --- ReferenceState.pyx | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/ReferenceState.pyx b/ReferenceState.pyx index 987f5fba..e422d012 100644 --- a/ReferenceState.pyx +++ b/ReferenceState.pyx @@ -107,7 +107,9 @@ cdef class ReferenceState: alpha[k] = alpha_c(p_[k], temperature[k], self.qtg, qv[k]) - + print alpha[Gr.gw] + plt.figure() + plt.show() # Now do a sanity check to make sure that the Reference State entropy profile is uniform following # saturation adjustment cdef double s From 4a9198693992391ddcf73c08c8738adbf76dfaf9 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Tue, 31 Jul 2018 09:55:36 -0700 Subject: [PATCH 023/136] .. --- EDMF_Updrafts.pyx | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/EDMF_Updrafts.pyx b/EDMF_Updrafts.pyx index 72be6c0c..6b726430 100644 --- a/EDMF_Updrafts.pyx +++ b/EDMF_Updrafts.pyx @@ -335,6 +335,15 @@ cdef class UpdraftThermodynamics: t = sa.T alpha = alpha_c(self.Ref.p0[k], t, qt, qv) UpdVar.B.values[i,k] = buoyancy_c(self.Ref.alpha0[k], alpha) + if k==self.Gr.gw: + with gil: + print k, self.Gr.gw + print 'UpdVar.B.values[i,k] ', UpdVar.B.values[i,k] + print 'alpha', alpha + print self.Ref.p0[k], t, qt, qv + plt.figure() + plt.plot() + with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): GMV.B.values[k] = (1.0 - UpdVar.Area.bulkvalues[k]) * EnvVar.B.values[k] From 1a236479da25a47c56defc637002b76f27763614 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Tue, 31 Jul 2018 10:13:18 -0700 Subject: [PATCH 024/136] .. --- EDMF_Updrafts.pyx | 2 +- ReferenceState.pyx | 10 ++++------ 2 files changed, 5 insertions(+), 7 deletions(-) diff --git a/EDMF_Updrafts.pyx b/EDMF_Updrafts.pyx index 6b726430..993e4e99 100644 --- a/EDMF_Updrafts.pyx +++ b/EDMF_Updrafts.pyx @@ -337,7 +337,7 @@ cdef class UpdraftThermodynamics: UpdVar.B.values[i,k] = buoyancy_c(self.Ref.alpha0[k], alpha) if k==self.Gr.gw: with gil: - print k, self.Gr.gw + print k, self.Gr.gw, self.Gr.z[k] print 'UpdVar.B.values[i,k] ', UpdVar.B.values[i,k] print 'alpha', alpha print self.Ref.p0[k], t, qt, qv diff --git a/ReferenceState.pyx b/ReferenceState.pyx index e422d012..e58af0ee 100644 --- a/ReferenceState.pyx +++ b/ReferenceState.pyx @@ -41,6 +41,9 @@ cdef class ReferenceState: ''' self.sg = t_to_entropy_c(self.Pg, self.Tg, self.qtg, 0.0, 0.0) + print 'self.Pg, self.Tg, self.qtg', self.Pg, self.Tg, self.qtg + plt.figure() + plt.show() # Form a right hand side for integrating the hydrostatic equation to @@ -68,14 +71,9 @@ cdef class ReferenceState: p0 = np.log(self.Pg) p = np.zeros(Gr.nzg, dtype=np.double, order='c') - print 'Gr.z[0]', Gr.z[0] - print 'np.shape(np.multiply(z,1.0))',np.shape(np.multiply(z,1.0)) - print 'np.shape(np.multiply(Gr.z[Gr.gw:-Gr.gw],1.0))',np.shape(np.multiply(Gr.z[Gr.gw:-Gr.gw],1.0)) - print 'np.shape(np.multiply(p,1.0))',np.shape(np.multiply(p,1.0)) + # Perform the integration p[Gr.gw:-Gr.gw] = odeint(rhs, p0, z, hmax=1.0)[1:, 0] - print 'p[Gr.gw]',p[Gr.gw] - print 'Gr.z[Gr.gw]',Gr.z[Gr.gw] # Set boundary conditions p[:Gr.gw] = p[2 * Gr.gw - 1:Gr.gw - 1:-1] From 2859920c5678b52105af3a07662cc4af2541aa6b Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Tue, 31 Jul 2018 10:59:33 -0700 Subject: [PATCH 025/136] .. --- ReferenceState.pyx | 8 -------- 1 file changed, 8 deletions(-) diff --git a/ReferenceState.pyx b/ReferenceState.pyx index e58af0ee..381734e5 100644 --- a/ReferenceState.pyx +++ b/ReferenceState.pyx @@ -10,7 +10,6 @@ from Grid cimport Grid from NetCDFIO cimport NetCDFIO_Stats cimport numpy as np import numpy as np -import pylab as plt from scipy.integrate import odeint from thermodynamic_functions cimport t_to_entropy_c, eos_first_guess_entropy, eos, alpha_c @@ -41,10 +40,6 @@ cdef class ReferenceState: ''' self.sg = t_to_entropy_c(self.Pg, self.Tg, self.qtg, 0.0, 0.0) - print 'self.Pg, self.Tg, self.qtg', self.Pg, self.Tg, self.qtg - plt.figure() - plt.show() - # Form a right hand side for integrating the hydrostatic equation to # determine the reference pressure @@ -105,9 +100,6 @@ cdef class ReferenceState: alpha[k] = alpha_c(p_[k], temperature[k], self.qtg, qv[k]) - print alpha[Gr.gw] - plt.figure() - plt.show() # Now do a sanity check to make sure that the Reference State entropy profile is uniform following # saturation adjustment cdef double s From 886d6071addcc7372f2d44dc2115f19aa40e40fc Mon Sep 17 00:00:00 2001 From: yairchn Date: Sun, 5 Aug 2018 08:05:25 -0700 Subject: [PATCH 026/136] change a_full to a in decomposed env --- Turbulence_PrognosticTKE.pyx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 127cc6bc..eba5817e 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -676,7 +676,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.EnvVar.H.values[k] = val1 * GMV.H.values[k] - val2 * self.UpdVar.H.bulkvalues[k] # Have to account for staggering of W--interpolate area fraction to the "full" grid points # Assuming GMV.W = 0! - au_full = 0.5 * (self.UpdVar.Area.bulkvalues[k+1] + self.UpdVar.Area.bulkvalues[k]) + au_full = self.UpdVar.Area.bulkvalues[k] self.EnvVar.W.values[k] = -au_full/(1.0-au_full) * self.UpdVar.W.bulkvalues[k] self.get_GMV_TKE(self.UpdVar.Area,self.UpdVar.W, self.EnvVar.W, self.EnvVar.TKE, @@ -701,7 +701,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.EnvVar.H.values[k] = val1 * GMV.H.mf_update[k] - val2 * self.UpdVar.H.bulkvalues[k] # Have to account for staggering of W # Assuming GMV.W = 0! - au_full = 0.5 * (self.UpdVar.Area.bulkvalues[k+1] + self.UpdVar.Area.bulkvalues[k]) + au_full = self.UpdVar.Area.bulkvalues[k] self.EnvVar.W.values[k] = -au_full/(1.0-au_full) * self.UpdVar.W.bulkvalues[k] self.get_GMV_TKE(self.UpdVar.Area,self.UpdVar.W, self.EnvVar.W, self.EnvVar.TKE, From 3e94c35fbc6ce5445821245ad12d0900f662a6bf Mon Sep 17 00:00:00 2001 From: yairchn Date: Sun, 5 Aug 2018 19:07:59 -0700 Subject: [PATCH 027/136] . --- EDMF_Updrafts.pyx | 3 +++ ReferenceState.pyx | 6 ------ Turbulence_PrognosticTKE.pyx | 34 ++++++++++++++++++++++------------ 3 files changed, 25 insertions(+), 18 deletions(-) diff --git a/EDMF_Updrafts.pyx b/EDMF_Updrafts.pyx index 72be6c0c..471d42c6 100644 --- a/EDMF_Updrafts.pyx +++ b/EDMF_Updrafts.pyx @@ -335,6 +335,9 @@ cdef class UpdraftThermodynamics: t = sa.T alpha = alpha_c(self.Ref.p0[k], t, qt, qv) UpdVar.B.values[i,k] = buoyancy_c(self.Ref.alpha0[k], alpha) + if k==self.Gr.gw: + with gil: + print 'alpha in upd the', alpha, UpdVar.B.values[i,k] with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): GMV.B.values[k] = (1.0 - UpdVar.Area.bulkvalues[k]) * EnvVar.B.values[k] diff --git a/ReferenceState.pyx b/ReferenceState.pyx index 987f5fba..2f9846de 100644 --- a/ReferenceState.pyx +++ b/ReferenceState.pyx @@ -68,14 +68,8 @@ cdef class ReferenceState: p0 = np.log(self.Pg) p = np.zeros(Gr.nzg, dtype=np.double, order='c') - print 'Gr.z[0]', Gr.z[0] - print 'np.shape(np.multiply(z,1.0))',np.shape(np.multiply(z,1.0)) - print 'np.shape(np.multiply(Gr.z[Gr.gw:-Gr.gw],1.0))',np.shape(np.multiply(Gr.z[Gr.gw:-Gr.gw],1.0)) - print 'np.shape(np.multiply(p,1.0))',np.shape(np.multiply(p,1.0)) # Perform the integration p[Gr.gw:-Gr.gw] = odeint(rhs, p0, z, hmax=1.0)[1:, 0] - print 'p[Gr.gw]',p[Gr.gw] - print 'Gr.z[Gr.gw]',Gr.z[Gr.gw] # Set boundary conditions p[:Gr.gw] = p[2 * Gr.gw - 1:Gr.gw - 1:-1] diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index eba5817e..0cb6a77d 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -325,6 +325,10 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.EnvVar.Hvar.values[k] = GMV.Hvar.values[k] self.EnvVar.QTvar.values[k] = GMV.QTvar.values[k] self.EnvVar.HQTcov.values[k] = GMV.HQTcov.values[k] + self.decompose_environment(GMV, 'values') + self.EnvThermo.satadjust(self.EnvVar, GMV) + self.UpdThermo.buoyancy(self.UpdVar, self.EnvVar,GMV, self.extrapolate_buoyancy) + print '331', self.UpdVar.B.values[0,self.Gr.gw] self.decompose_environment(GMV, 'values') if self.use_steady_updrafts: @@ -338,6 +342,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.decompose_environment(GMV, 'mf_update') self.EnvThermo.satadjust(self.EnvVar, GMV) self.UpdThermo.buoyancy(self.UpdVar, self.EnvVar,GMV, self.extrapolate_buoyancy) + print '346', self.UpdVar.B.values[0,self.Gr.gw] self.compute_eddy_diffusivities_tke(GMV, Case) @@ -362,6 +367,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.dt_upd = np.minimum(TS.dt, 0.5 * self.Gr.dz/fmax(np.max(self.UpdVar.W.values),1e-10)) while time_elapsed < TS.dt: self.compute_entrainment_detrainment(GMV, Case) + print '374', self.UpdVar.B.values[0,self.Gr.gw] self.solve_updraft_velocity_area(GMV,TS) self.solve_updraft_scalars(GMV, Case, TS) self.UpdVar.set_values_with_new() @@ -370,6 +376,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.decompose_environment(GMV, 'values') self.EnvThermo.satadjust(self.EnvVar, GMV) self.UpdThermo.buoyancy(self.UpdVar, self.EnvVar, GMV, self.extrapolate_buoyancy) + return cpdef compute_diagnostic_updrafts(self, GridMeanVariables GMV, CasesBase Case): @@ -392,8 +399,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for i in xrange(self.n_updrafts): self.UpdVar.H.values[i,gw] = self.h_surface_bc[i] self.UpdVar.QT.values[i,gw] = self.qt_surface_bc[i] - with gil: - print '393:','self.h_surface_bc[i]', self.h_surface_bc[i], 'self.qt_surface_bc[i]', self.qt_surface_bc[i] # Find the cloud liquid content sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0[gw], self.UpdVar.QT.values[i,gw], self.UpdVar.H.values[i,gw]) @@ -421,6 +426,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.decompose_environment(GMV, 'values') self.EnvThermo.satadjust(self.EnvVar, GMV) self.UpdThermo.buoyancy(self.UpdVar, self.EnvVar, GMV, self.extrapolate_buoyancy) + print '424', self.UpdVar.B.values[0,self.Gr.gw] # Solve updraft velocity equation with nogil: @@ -483,6 +489,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.decompose_environment(GMV, 'values') self.EnvThermo.satadjust(self.EnvVar, GMV) self.UpdThermo.buoyancy(self.UpdVar, self.EnvVar, GMV, self.extrapolate_buoyancy) + print '487', self.UpdVar.B.values[0,self.Gr.gw] self.UpdVar.Area.set_bcs(self.Gr) @@ -621,11 +628,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): 1.0-self.surface_area + (i+1)*a_ , 1000) # use the w equation with w[gw-1] = 0 and dzi divided by 2 to obtain w[gw] - this need to change for diagnostic updrafts self.area_surface_bc[i] = self.surface_area/self.n_updrafts - self.updraft_pressure_sink[i,gw] = press - self.h_surface_bc[i] = (GMV.H.values[gw] + surface_scalar_coeff * sqrt(h_var)) self.qt_surface_bc[i] = (GMV.QT.values[gw] + surface_scalar_coeff * sqrt(qt_var)) - print 'self.h_surface_bc[i]', self.h_surface_bc[i], 'self.qt_surface_bc[i]', self.qt_surface_bc[i] + print '624 qt_var, h_var', qt_var, h_var, GMV.H.values[gw], GMV.QT.values[gw], surface_scalar_coeff + plt.figure() + plt.show() return @@ -880,10 +887,10 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): #self.UpdThermo.buoyancy(self.UpdVar, self.EnvVar, GMV, self.extrapolate_buoyancy) #alpha_srf = alpha_c(self.Ref.p0[gw], self.UpdVar.T.values[i,gw], self.UpdVar.QT.values[i,gw],self.UpdVar.QT.values[i,gw]) #self.UpdVar.B.values[i,gw]= buoyancy_c(self.Ref.alpha0[gw], alpha_srf) - print 'self.UpdVar.B.values[i,gw]',self.UpdVar.B.values[i,gw] - print 'self.UpdVar.B.values[i,gw]',self.UpdVar.B.new[i,gw] - print 'self.h_surface_bc[i]', self.h_surface_bc[i] - print 'self.UpdVar.QT.values[i,gw]', self.UpdVar.QT.values[i,gw] + #print 'self.UpdVar.B.values[i,gw]',self.UpdVar.B.values[i,gw] + #print 'self.UpdVar.B.values[i,gw]',self.UpdVar.B.new[i,gw] + #print 'self.h_surface_bc[i]', self.h_surface_bc[i] + #print 'self.UpdVar.QT.values[i,gw]', self.UpdVar.QT.values[i,gw] adv = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * self.UpdVar.W.values[i,gw] * dzi/2.0) exch = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] @@ -895,7 +902,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): press = press_buoy + press_drag self.UpdVar.W.new[i,gw] = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * dti_ -adv + exch + buoy + press)/(self.Ref.rho0[gw] * self.UpdVar.Area.new[i,gw] * dti_) - print adv ,exch, buoy, press,self.UpdVar.W.new[i,gw] + self.UpdVar.W.values[i,gw] = sqrt(2.0*self.UpdVar.B.values[i,gw]) + print 'first print ', adv ,exch, buoy, press,self.UpdVar.W.new[i,gw], self.UpdVar.Area.values[i,gw] + print 'self.UpdVar.B.values[i,gw]', self.UpdVar.B.values[i,gw], 'self.Ref.rho0[gw]',self.Ref.rho0[gw], plt.figure() plt.show() @@ -913,7 +922,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): plt.figure() plt.show() - #print self.UpdVar.Area.new[i,k], adv ,entr_term ,detr_term, self.UpdVar.Area.values[i,k] + print self.UpdVar.Area.new[i,k], adv ,entr_term ,detr_term, self.UpdVar.Area.values[i,k] if self.UpdVar.Area.new[i,k] > au_lim: self.UpdVar.Area.new[i,k] = au_lim if self.UpdVar.Area.values[i,k] > 0.0: @@ -926,7 +935,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): rho_ratio = self.Ref.rho0[k-1]/self.Ref.rho0[k] print '912', self.UpdVar.Area.new[i,k], self.minimum_area, self.UpdVar.Area.new[i,gw], self.UpdVar.W.new[i,gw] if self.UpdVar.Area.new[i,k] >= self.minimum_area: - print '914 - inside' entr_w = self.entr_sc[i,k] detr_w = self.detr_sc[i,k] adv = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.UpdVar.W.values[i,k] * dzi @@ -943,6 +951,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): -adv + exch + buoy + press)/(self.Ref.rho0[k] * self.UpdVar.Area.new[i,k] * dti_) print '924', k, 'W.new', self.UpdVar.W.new[i,k], 'W.values[i,k]', self.UpdVar.W.values[i,k], 'W.values[i,k-1]', self.UpdVar.W.values[i,k-1], 'adv',adv ,'exch', exch, 'buoy', buoy, 'press', press + plt.figure() + plt.show() if self.UpdVar.W.new[i,k] <= 0.0: self.UpdVar.W.new[i,k:] = 0.0 self.UpdVar.Area.new[i,k+1:] = 0.0 From 5a94a1d4c1c618f44fa7115d245f14d2c3a2e76f Mon Sep 17 00:00:00 2001 From: yairchn Date: Mon, 6 Aug 2018 09:33:35 -0700 Subject: [PATCH 028/136] . --- Turbulence_PrognosticTKE.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 0cb6a77d..d92ea2cd 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -902,7 +902,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): press = press_buoy + press_drag self.UpdVar.W.new[i,gw] = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * dti_ -adv + exch + buoy + press)/(self.Ref.rho0[gw] * self.UpdVar.Area.new[i,gw] * dti_) - self.UpdVar.W.values[i,gw] = sqrt(2.0*self.UpdVar.B.values[i,gw]) + #self.UpdVar.W.values[i,gw] = sqrt(2.0*self.UpdVar.B.values[i,gw]) print 'first print ', adv ,exch, buoy, press,self.UpdVar.W.new[i,gw], self.UpdVar.Area.values[i,gw] print 'self.UpdVar.B.values[i,gw]', self.UpdVar.B.values[i,gw], 'self.Ref.rho0[gw]',self.Ref.rho0[gw], plt.figure() From 885ed9f979ea66c19b8ca175513ef33801626770 Mon Sep 17 00:00:00 2001 From: yairchn Date: Mon, 6 Aug 2018 15:55:55 -0700 Subject: [PATCH 029/136] working --- EDMF_Updrafts.pyx | 28 ++++++++++++++-------------- Turbulence_PrognosticTKE.pyx | 32 +++++++------------------------- 2 files changed, 21 insertions(+), 39 deletions(-) diff --git a/EDMF_Updrafts.pyx b/EDMF_Updrafts.pyx index 471d42c6..d41ca014 100644 --- a/EDMF_Updrafts.pyx +++ b/EDMF_Updrafts.pyx @@ -42,18 +42,18 @@ cdef class UpdraftVariable: n_updrafts = np.shape(self.values)[0] - if self.name == 'w': + # if self.name == 'w': + # for i in xrange(n_updrafts): + # self.values[i,start_high] = 0.0 + # self.values[i,start_low] = 0.0 + # for k in xrange(1,Gr.gw): + # self.values[i,start_high+ k] = -self.values[i,start_high - k ] + # self.values[i,start_low- k] = -self.values[i,start_low + k ] + # else: + for k in xrange(Gr.gw): for i in xrange(n_updrafts): - self.values[i,start_high] = 0.0 - self.values[i,start_low] = 0.0 - for k in xrange(1,Gr.gw): - self.values[i,start_high+ k] = -self.values[i,start_high - k ] - self.values[i,start_low- k] = -self.values[i,start_low + k ] - else: - for k in xrange(Gr.gw): - for i in xrange(n_updrafts): - self.values[i,start_high + k +1] = self.values[i,start_high - k] - self.values[i,start_low - k] = self.values[i,start_low + 1 + k] + self.values[i,start_high + k +1] = self.values[i,start_high - k] + self.values[i,start_low - k] = self.values[i,start_low + 1 + k] return @@ -335,9 +335,9 @@ cdef class UpdraftThermodynamics: t = sa.T alpha = alpha_c(self.Ref.p0[k], t, qt, qv) UpdVar.B.values[i,k] = buoyancy_c(self.Ref.alpha0[k], alpha) - if k==self.Gr.gw: - with gil: - print 'alpha in upd the', alpha, UpdVar.B.values[i,k] + #if k==self.Gr.gw: + # with gil: + # print 'alpha in upd is:', alpha, UpdVar.B.values[i,k] with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): GMV.B.values[k] = (1.0 - UpdVar.Area.bulkvalues[k]) * EnvVar.B.values[k] diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index d92ea2cd..0abc113f 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -328,7 +328,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.decompose_environment(GMV, 'values') self.EnvThermo.satadjust(self.EnvVar, GMV) self.UpdThermo.buoyancy(self.UpdVar, self.EnvVar,GMV, self.extrapolate_buoyancy) - print '331', self.UpdVar.B.values[0,self.Gr.gw] self.decompose_environment(GMV, 'values') if self.use_steady_updrafts: @@ -342,7 +341,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.decompose_environment(GMV, 'mf_update') self.EnvThermo.satadjust(self.EnvVar, GMV) self.UpdThermo.buoyancy(self.UpdVar, self.EnvVar,GMV, self.extrapolate_buoyancy) - print '346', self.UpdVar.B.values[0,self.Gr.gw] self.compute_eddy_diffusivities_tke(GMV, Case) @@ -367,7 +365,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.dt_upd = np.minimum(TS.dt, 0.5 * self.Gr.dz/fmax(np.max(self.UpdVar.W.values),1e-10)) while time_elapsed < TS.dt: self.compute_entrainment_detrainment(GMV, Case) - print '374', self.UpdVar.B.values[0,self.Gr.gw] self.solve_updraft_velocity_area(GMV,TS) self.solve_updraft_scalars(GMV, Case, TS) self.UpdVar.set_values_with_new() @@ -426,7 +423,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.decompose_environment(GMV, 'values') self.EnvThermo.satadjust(self.EnvVar, GMV) self.UpdThermo.buoyancy(self.UpdVar, self.EnvVar, GMV, self.extrapolate_buoyancy) - print '424', self.UpdVar.B.values[0,self.Gr.gw] # Solve updraft velocity equation with nogil: @@ -489,7 +485,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.decompose_environment(GMV, 'values') self.EnvThermo.satadjust(self.EnvVar, GMV) self.UpdThermo.buoyancy(self.UpdVar, self.EnvVar, GMV, self.extrapolate_buoyancy) - print '487', self.UpdVar.B.values[0,self.Gr.gw] self.UpdVar.Area.set_bcs(self.Gr) @@ -630,9 +625,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.area_surface_bc[i] = self.surface_area/self.n_updrafts self.h_surface_bc[i] = (GMV.H.values[gw] + surface_scalar_coeff * sqrt(h_var)) self.qt_surface_bc[i] = (GMV.QT.values[gw] + surface_scalar_coeff * sqrt(qt_var)) - print '624 qt_var, h_var', qt_var, h_var, GMV.H.values[gw], GMV.QT.values[gw], surface_scalar_coeff - plt.figure() - plt.show() return @@ -902,11 +894,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): press = press_buoy + press_drag self.UpdVar.W.new[i,gw] = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * dti_ -adv + exch + buoy + press)/(self.Ref.rho0[gw] * self.UpdVar.Area.new[i,gw] * dti_) - #self.UpdVar.W.values[i,gw] = sqrt(2.0*self.UpdVar.B.values[i,gw]) - print 'first print ', adv ,exch, buoy, press,self.UpdVar.W.new[i,gw], self.UpdVar.Area.values[i,gw] - print 'self.UpdVar.B.values[i,gw]', self.UpdVar.B.values[i,gw], 'self.Ref.rho0[gw]',self.Ref.rho0[gw], - plt.figure() - plt.show() + self.UpdVar.W.new[i,gw] = sqrt(2.0*fmax(self.UpdVar.B.values[i,gw],0.0)) + #print 'self.UpdVar.W.new[i,gw]', self.UpdVar.W.new[i,gw] #self.UpdVar.W.values[i,gw] = sqrt(2.0*self.UpdVar.B.values[i,gw]) for k in range(gw+1, self.Gr.nzg-gw): @@ -918,11 +907,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.Area.new[i,k] = fmax(dt_ * (adv + entr_term + detr_term) + self.UpdVar.Area.values[i,k], 0.0) - print '.Area.new[i,k]', self.UpdVar.Area.new[i,k], 'Area.values[i,k],', self.UpdVar.Area.values[i,k], 'adv',adv,'entr',entr_term ,'detr', detr_term - plt.figure() - plt.show() - print self.UpdVar.Area.new[i,k], adv ,entr_term ,detr_term, self.UpdVar.Area.values[i,k] if self.UpdVar.Area.new[i,k] > au_lim: self.UpdVar.Area.new[i,k] = au_lim if self.UpdVar.Area.values[i,k] > 0.0: @@ -933,7 +918,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # Now solve for updraft velocity at k rho_ratio = self.Ref.rho0[k-1]/self.Ref.rho0[k] - print '912', self.UpdVar.Area.new[i,k], self.minimum_area, self.UpdVar.Area.new[i,gw], self.UpdVar.W.new[i,gw] + if self.UpdVar.Area.new[i,k] >= self.minimum_area: entr_w = self.entr_sc[i,k] detr_w = self.detr_sc[i,k] @@ -950,9 +935,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.W.new[i,k] = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * dti_ -adv + exch + buoy + press)/(self.Ref.rho0[k] * self.UpdVar.Area.new[i,k] * dti_) - print '924', k, 'W.new', self.UpdVar.W.new[i,k], 'W.values[i,k]', self.UpdVar.W.values[i,k], 'W.values[i,k-1]', self.UpdVar.W.values[i,k-1], 'adv',adv ,'exch', exch, 'buoy', buoy, 'press', press - plt.figure() - plt.show() if self.UpdVar.W.new[i,k] <= 0.0: self.UpdVar.W.new[i,k:] = 0.0 self.UpdVar.Area.new[i,k+1:] = 0.0 @@ -982,13 +964,13 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): if self.use_local_micro: with nogil: for i in xrange(self.n_updrafts): - self.UpdVar.H.values[i,gw] = self.h_surface_bc[i] - self.UpdVar.QT.values[i,gw] = self.qt_surface_bc[i] + self.UpdVar.H.new[i,gw] = self.h_surface_bc[i] + self.UpdVar.QT.new[i,gw] = self.qt_surface_bc[i] sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0[gw], self.UpdVar.QT.values[i,gw], self.UpdVar.H.values[i,gw]) - self.UpdVar.QL.values[i,gw] = sa.ql - self.UpdVar.T.values[i,gw] = sa.T + self.UpdVar.QL.new[i,gw] = sa.ql + self.UpdVar.T.new[i,gw] = sa.T self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0[gw], self.UpdVar.T.values[i,gw], &self.UpdVar.QT.values[i,gw], &self.UpdVar.QL.values[i,gw], &self.UpdVar.H.values[i,gw], i, gw) From 1bf821c564de77653917a738d581d82de0756fc1 Mon Sep 17 00:00:00 2001 From: yairchn Date: Mon, 6 Aug 2018 16:00:47 -0700 Subject: [PATCH 030/136] .. --- Turbulence_PrognosticTKE.pyx | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 0abc113f..e9d9d0af 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -935,10 +935,10 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.W.new[i,k] = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * dti_ -adv + exch + buoy + press)/(self.Ref.rho0[k] * self.UpdVar.Area.new[i,k] * dti_) - if self.UpdVar.W.new[i,k] <= 0.0: - self.UpdVar.W.new[i,k:] = 0.0 - self.UpdVar.Area.new[i,k+1:] = 0.0 - break + # if self.UpdVar.W.new[i,k] <= 0.0: + # self.UpdVar.W.new[i,k:] = 0.0 + # self.UpdVar.Area.new[i,k+1:] = 0.0 + # break else: self.UpdVar.W.new[i,k:] = 0.0 From 91529ce4d6c41be45c31cd8be93d6a0fd08d29e2 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Mon, 6 Aug 2018 18:43:55 -0700 Subject: [PATCH 031/136] .. --- Turbulence_PrognosticTKE.pyx | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 00b85c3c..19be5d3c 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -892,9 +892,10 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): press_drag = -1.0 * self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * (self.pressure_drag_coeff/self.pressure_plume_spacing * (self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])**2.0/sqrt(fmax(self.UpdVar.Area.values[i,gw],self.minimum_area))) press = press_buoy + press_drag - self.UpdVar.W.new[i,gw] = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * dti_ - -adv + exch + buoy + press)/(self.Ref.rho0[gw] * self.UpdVar.Area.new[i,gw] * dti_) - self.UpdVar.W.new[i,gw] = sqrt(2.0*fmax(self.UpdVar.B.values[i,gw],0.0)) + #self.UpdVar.W.new[i,gw] = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * dti_ + # -adv + exch + buoy + press)/(self.Ref.rho0[gw] * self.UpdVar.Area.new[i,gw] * dti_) + self.UpdVar.W.values[i,gw] = sqrt(2.0*fmax(self.UpdVar.B.values[i,gw],0.0)) + self.UpdVar.W.new[i,gw] = self.UpdVar.W.values[i,gw] #print 'self.UpdVar.W.new[i,gw]', self.UpdVar.W.new[i,gw] #self.UpdVar.W.values[i,gw] = sqrt(2.0*self.UpdVar.B.values[i,gw]) @@ -922,7 +923,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ - adv -entr_term)/(-self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k])) else: # this detrainment rate won't affect scalars but would affect velocity - self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ - adv -entr_term)/(-au_lim * self.UpdVar.W.values[i,k+1])) + self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ - adv -entr_term)/(-au_lim * self.UpdVar.W.values[i,k])) # Now solve for updraft velocity at k rho_ratio = self.Ref.rho0[k-1]/self.Ref.rho0[k] From 19846f72ccc5d8aa3c05d76fa23490f58b96cdd9 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Mon, 6 Aug 2018 21:12:15 -0700 Subject: [PATCH 032/136] fixing reversed entr --- Turbulence_PrognosticTKE.pyx | 44 +++++++++++++++++++++++++----------- 1 file changed, 31 insertions(+), 13 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 19be5d3c..76b2113d 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -896,7 +896,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # -adv + exch + buoy + press)/(self.Ref.rho0[gw] * self.UpdVar.Area.new[i,gw] * dti_) self.UpdVar.W.values[i,gw] = sqrt(2.0*fmax(self.UpdVar.B.values[i,gw],0.0)) self.UpdVar.W.new[i,gw] = self.UpdVar.W.values[i,gw] - #print 'self.UpdVar.W.new[i,gw]', self.UpdVar.W.new[i,gw] + #self.UpdVar.W.values[i,gw] = sqrt(2.0*self.UpdVar.B.values[i,gw]) for k in range(gw+1, self.Gr.nzg-gw): @@ -913,9 +913,12 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): -self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k]) adv = sgn_w*adv_up + (1.0-sgn_w)*adv_dw - entr_term = self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * (self.entr_sc[i,k] ) - detr_term = self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * (- self.detr_sc[i,k]) + entr_term = self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * (2.0*sgn_w-1.0)*(self.entr_sc[i,k] ) + detr_term = self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * (1.0-2.0*sgn_w)*(- self.detr_sc[i,k]) self.UpdVar.Area.new[i,k] = fmax(dt_ * (adv + entr_term + detr_term) + self.UpdVar.Area.values[i,k], 0.0) + #print '----------------------------------------------------' + #print 'self.UpdVar.Area.new[i,k]', self.UpdVar.Area.new[i,k], 'adv', adv, 'sgn_w', sgn_w + if self.UpdVar.Area.new[i,k] > au_lim: self.UpdVar.Area.new[i,k] = au_lim @@ -939,7 +942,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): adv = sgn_w*adv_up + (1.0-sgn_w)*adv_dw exch = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] - * (entr_w * self.EnvVar.W.values[k] - detr_w * self.UpdVar.W.values[i,k] )) + * ((2.0*sgn_w-1.0)**entr_w * self.EnvVar.W.values[k] - (2.0*sgn_w-1.0)**detr_w * self.UpdVar.W.values[i,k] )) buoy= self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] press_buoy = -1.0 * self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] * self.pressure_buoy_coeff press_drag = -1.0 * self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * (self.pressure_drag_coeff/self.pressure_plume_spacing @@ -948,12 +951,19 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.updraft_pressure_sink[i,k] = press self.UpdVar.W.new[i,k] = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * dti_ -adv + exch + buoy + press)/(self.Ref.rho0[k] * self.UpdVar.Area.new[i,k] * dti_) + #print '----------------------------------------------------' + #print 'self.UpdVar.W.new[i,k]', self.UpdVar.W.new[i,k], 'adv', adv, 'sgn_w', sgn_w + # if self.UpdVar.W.new[i,k] <= 0.0: # self.UpdVar.W.new[i,k:] = 0.0 # self.UpdVar.Area.new[i,k:] = 0.0 # break + + # plt.figure() + # plt.show() + else: self.UpdVar.W.new[i,k:] = 0.0 self.UpdVar.Area.new[i,k:] = 0.0 @@ -1005,14 +1015,20 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): c1 = self.Ref.rho0[k] * self.UpdVar.Area.new[i,k] * dti_ c2 = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * dti_ - - m_k * (dzi + self.detr_sc[i,k])) - c3 = m_km * dzi - c4 = m_k * self.entr_sc[i,k] + - (2.0*sgn_w-1.0)*m_k * (dzi + self.detr_sc[i,k])) + c3 = sgn_w*m_km * dzi - (1.0-sgn_w)*m_kp*dzi + c4 = (2.0*sgn_w-1.0)*m_k * self.entr_sc[i,k] + + self.UpdVar.H.new[i,k] = (c2 * self.UpdVar.H.values[i,k] + c3*sgn_w * self.UpdVar.H.values[i,k-1] + + c3*(1.0-sgn_w) * self.UpdVar.H.values[i,k+1] + c4 * H_entr )/c1 + self.UpdVar.QT.new[i,k] = (c2 * self.UpdVar.QT.values[i,k] + c3*sgn_w * self.UpdVar.QT.values[i,k-1] + + c3*(1.0-sgn_w) * self.UpdVar.QT.values[i,k+1] + c4* QT_entr)/c1 - self.UpdVar.H.new[i,k] = (c2 * self.UpdVar.H.values[i,k] + c3 * self.UpdVar.H.values[i,k-1] - + c4 * H_entr)/c1 - self.UpdVar.QT.new[i,k] = (c2 * self.UpdVar.QT.values[i,k] + c3 * self.UpdVar.QT.values[i,k-1] - + c4* QT_entr)/c1 + if self.UpdVar.H.new[i,k]>310.0 or self.UpdVar.H.new[i,k]<290.0: + with gil: + print'self.UpdVar.H.new[i,k]', self.UpdVar.H.new[i,k], 'self.UpdVar.QT.new[i,k] ',self.UpdVar.QT.new[i,k] + print 'self.UpdVar.Area.values[i,k+1]', self.UpdVar.Area.values[i,k+1], 'self.UpdVar.Area.values[i,k]', self.UpdVar.Area.values[i,k], 'self.UpdVar.Area.values[i,k-1]', self.UpdVar.Area.values[i,k-1] + print c1,c2,c3,c4 else: self.UpdVar.H.new[i,k] = GMV.H.values[k] @@ -1020,9 +1036,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0[k], self.UpdVar.QT.new[i,k], self.UpdVar.H.new[i,k]) - if self.UpdVar.H.new[i,k] > 330.0 or self.UpdVar.H.new[i,k] <290.0: + if self.UpdVar.H.new[i,k]>310.0 or self.UpdVar.H.new[i,k]<290.0: with gil: - print 'sa.ql',sa.ql, 'sa.T', sa.T, 'self.UpdVar.H.new[i,k]', self.UpdVar.H.new[i,k], 'self.UpdVar.QT.new[i,k] ',self.UpdVar.QT.new[i,k] + print 'sa.ql',sa.ql, 'self.UpdVar.QT.new[i,k]', self.UpdVar.QT.new[i,k], 'sa.T', sa.T, 'self.UpdVar.H.new[i,k]',self.UpdVar.H.new[i,k] + + self.UpdVar.QL.new[i,k] = sa.ql self.UpdVar.T.new[i,k] = sa.T self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0[k], self.UpdVar.T.new[i,k], From c045a76ab917aa85eb95ab6bed01cb922c99b570 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Mon, 6 Aug 2018 21:35:24 -0700 Subject: [PATCH 033/136] working version --- Turbulence_PrognosticTKE.pyx | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 76b2113d..16e2ba28 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -902,7 +902,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for k in range(gw+1, self.Gr.nzg-gw): # First solve for updated area fraction at k+1 - if self.UpdVar.W.new[i,k]<0: + if self.UpdVar.W.values[i,k]<0: sgn_w = 0.0 else: sgn_w = 1.0 @@ -913,8 +913,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): -self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k]) adv = sgn_w*adv_up + (1.0-sgn_w)*adv_dw - entr_term = self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * (2.0*sgn_w-1.0)*(self.entr_sc[i,k] ) - detr_term = self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * (1.0-2.0*sgn_w)*(- self.detr_sc[i,k]) + entr_term = self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * (2.0*sgn_w-1.0)*self.entr_sc[i,k] + detr_term = self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * (1.0-2.0*sgn_w)*self.detr_sc[i,k] self.UpdVar.Area.new[i,k] = fmax(dt_ * (adv + entr_term + detr_term) + self.UpdVar.Area.values[i,k], 0.0) #print '----------------------------------------------------' #print 'self.UpdVar.Area.new[i,k]', self.UpdVar.Area.new[i,k], 'adv', adv, 'sgn_w', sgn_w @@ -942,11 +942,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): adv = sgn_w*adv_up + (1.0-sgn_w)*adv_dw exch = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] - * ((2.0*sgn_w-1.0)**entr_w * self.EnvVar.W.values[k] - (2.0*sgn_w-1.0)**detr_w * self.UpdVar.W.values[i,k] )) + * ((2.0*sgn_w-1.0)*entr_w * self.EnvVar.W.values[k] - (2.0*sgn_w-1.0)*detr_w * self.UpdVar.W.values[i,k] )) buoy= self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] press_buoy = -1.0 * self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] * self.pressure_buoy_coeff - press_drag = -1.0 * self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * (self.pressure_drag_coeff/self.pressure_plume_spacing - * (self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k])**2.0/sqrt(fmax(self.UpdVar.Area.values[i,k],self.minimum_area))) + press_drag = -1.0 * self.Ref.rho0[k]*(sqrt(self.UpdVar.Area.values[i,k] )*self.pressure_drag_coeff/self.pressure_plume_spacing + * (self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k])**2.0) press = press_buoy + press_drag self.updraft_pressure_sink[i,k] = press self.UpdVar.W.new[i,k] = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * dti_ @@ -1004,7 +1004,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # write the discrete equations in form: # c1 * phi_new[k] = c2 * phi[k] + c3 * phi[k-1] + c4 * phi_entr if self.UpdVar.Area.new[i,k] >= self.minimum_area: - if self.UpdVar.W.values[i,k-1]<0: + if self.UpdVar.W.values[i,k]<0: sgn_w = 0.0 else: sgn_w = 1.0 From 3a266e333fe6608931da4c3e520f7627c02abcca Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Mon, 6 Aug 2018 21:42:17 -0700 Subject: [PATCH 034/136] working version --- Turbulence_PrognosticTKE.pyx | 35 +++++++---------------------------- 1 file changed, 7 insertions(+), 28 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 16e2ba28..bd127889 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -876,13 +876,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.detr_sc[i,gw] = 0.0 self.UpdVar.Area.new[i,gw] = self.area_surface_bc[i] au_lim = self.area_surface_bc[i] * self.max_area_factor - #self.UpdThermo.buoyancy(self.UpdVar, self.EnvVar, GMV, self.extrapolate_buoyancy) - #alpha_srf = alpha_c(self.Ref.p0[gw], self.UpdVar.T.values[i,gw], self.UpdVar.QT.values[i,gw],self.UpdVar.QT.values[i,gw]) - #self.UpdVar.B.values[i,gw]= buoyancy_c(self.Ref.alpha0[gw], alpha_srf) - #print 'self.UpdVar.B.values[i,gw]',self.UpdVar.B.values[i,gw] - #print 'self.UpdVar.B.values[i,gw]',self.UpdVar.B.new[i,gw] - #print 'self.h_surface_bc[i]', self.h_surface_bc[i] - #print 'self.UpdVar.QT.values[i,gw]', self.UpdVar.QT.values[i,gw] adv = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * self.UpdVar.W.values[i,gw] * dzi/2.0) exch = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] @@ -906,7 +899,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): sgn_w = 0.0 else: sgn_w = 1.0 - #sgn_w=1.0 + adv_up = -self.Ref.alpha0[k] * dzi *( self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] -self.Ref.rho0[k-1] * self.UpdVar.Area.values[i,k-1] * self.UpdVar.W.values[i,k-1]) adv_dw = -self.Ref.alpha0[k] * dzi *( self.Ref.rho0[k+1] * self.UpdVar.Area.values[i,k+1] * self.UpdVar.W.values[i,k+1] @@ -916,8 +909,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): entr_term = self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * (2.0*sgn_w-1.0)*self.entr_sc[i,k] detr_term = self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * (1.0-2.0*sgn_w)*self.detr_sc[i,k] self.UpdVar.Area.new[i,k] = fmax(dt_ * (adv + entr_term + detr_term) + self.UpdVar.Area.values[i,k], 0.0) - #print '----------------------------------------------------' - #print 'self.UpdVar.Area.new[i,k]', self.UpdVar.Area.new[i,k], 'adv', adv, 'sgn_w', sgn_w if self.UpdVar.Area.new[i,k] > au_lim: @@ -951,19 +942,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.updraft_pressure_sink[i,k] = press self.UpdVar.W.new[i,k] = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * dti_ -adv + exch + buoy + press)/(self.Ref.rho0[k] * self.UpdVar.Area.new[i,k] * dti_) - #print '----------------------------------------------------' - #print 'self.UpdVar.W.new[i,k]', self.UpdVar.W.new[i,k], 'adv', adv, 'sgn_w', sgn_w - - - # if self.UpdVar.W.new[i,k] <= 0.0: - # self.UpdVar.W.new[i,k:] = 0.0 - # self.UpdVar.Area.new[i,k:] = 0.0 - # break - # plt.figure() - # plt.show() - else: self.UpdVar.W.new[i,k:] = 0.0 self.UpdVar.Area.new[i,k:] = 0.0 @@ -1001,6 +981,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for k in xrange(gw+1, self.Gr.nzg-gw): H_entr = self.EnvVar.H.values[k] QT_entr = self.EnvVar.QT.values[k] + # write the discrete equations in form: # c1 * phi_new[k] = c2 * phi[k] + c3 * phi[k-1] + c4 * phi_entr if self.UpdVar.Area.new[i,k] >= self.minimum_area: @@ -1008,7 +989,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): sgn_w = 0.0 else: sgn_w = 1.0 - #sgn_w = 1.0 m_kp = (self.Ref.rho0[k+1] * self.UpdVar.Area.values[i,k+1]*self.UpdVar.W.values[i,k+1]) m_k = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k]*self.UpdVar.W.values[i,k]) m_km = (self.Ref.rho0[k-1] * self.UpdVar.Area.values[i,k-1]* self.UpdVar.W.values[i,k-1]) @@ -1024,11 +1004,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.QT.new[i,k] = (c2 * self.UpdVar.QT.values[i,k] + c3*sgn_w * self.UpdVar.QT.values[i,k-1] + c3*(1.0-sgn_w) * self.UpdVar.QT.values[i,k+1] + c4* QT_entr)/c1 - if self.UpdVar.H.new[i,k]>310.0 or self.UpdVar.H.new[i,k]<290.0: - with gil: - print'self.UpdVar.H.new[i,k]', self.UpdVar.H.new[i,k], 'self.UpdVar.QT.new[i,k] ',self.UpdVar.QT.new[i,k] - print 'self.UpdVar.Area.values[i,k+1]', self.UpdVar.Area.values[i,k+1], 'self.UpdVar.Area.values[i,k]', self.UpdVar.Area.values[i,k], 'self.UpdVar.Area.values[i,k-1]', self.UpdVar.Area.values[i,k-1] - print c1,c2,c3,c4 + # if self.UpdVar.H.new[i,k]>310.0 or self.UpdVar.H.new[i,k]<290.0: + # with gil: + # print'self.UpdVar.H.new[i,k]', self.UpdVar.H.new[i,k], 'self.UpdVar.QT.new[i,k] ',self.UpdVar.QT.new[i,k] + # print 'self.UpdVar.Area.values[i,k+1]', self.UpdVar.Area.values[i,k+1], 'self.UpdVar.Area.values[i,k]', self.UpdVar.Area.values[i,k], 'self.UpdVar.Area.values[i,k-1]', self.UpdVar.Area.values[i,k-1] + # print c1,c2,c3,c4 else: self.UpdVar.H.new[i,k] = GMV.H.values[k] @@ -1067,7 +1047,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): sgn_w = 0.0 else: sgn_w = 1.0 - sgn_w = 1.0 m_kp = (self.Ref.rho0[k+1] * self.UpdVar.Area.values[i,k+1]*self.UpdVar.W.values[i,k+1]) m_k = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k]*self.UpdVar.W.values[i,k]) m_km = (self.Ref.rho0[k-1] * self.UpdVar.Area.values[i,k-1]* self.UpdVar.W.values[i,k-1]) From b82f35430d7f2033575dc6b820c6ee7286bcd4ce Mon Sep 17 00:00:00 2001 From: yairchn Date: Tue, 7 Aug 2018 12:26:32 -0700 Subject: [PATCH 035/136] working for Tan2018 with w_bc from momentum equation --- Turbulence_PrognosticTKE.pyx | 152 ++++++++++++++++++----------------- 1 file changed, 78 insertions(+), 74 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index bd127889..97cb36bc 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -869,87 +869,91 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double entr_w, detr_w, entr_term, detr_term, rho_ratio double adv, buoy, exch, press, press_buoy, press_drag # groupings of terms in velocity discrete equation - #with nogil: - # issues wth whether the BC is applied to values or new and at which k - for i in xrange(self.n_updrafts): - self.entr_sc[i,gw] = 2.0 * dzi - self.detr_sc[i,gw] = 0.0 - self.UpdVar.Area.new[i,gw] = self.area_surface_bc[i] - au_lim = self.area_surface_bc[i] * self.max_area_factor - - adv = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * self.UpdVar.W.values[i,gw] * dzi/2.0) - exch = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] - * (self.entr_sc[i,gw] * self.EnvVar.W.values[gw] - self.detr_sc[i,gw] * self.UpdVar.W.values[i,gw] )) - buoy= self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.B.values[i,gw] - press_buoy = -1.0 * self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.B.values[i,gw] * self.pressure_buoy_coeff - press_drag = -1.0 * self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * (self.pressure_drag_coeff/self.pressure_plume_spacing - * (self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])**2.0/sqrt(fmax(self.UpdVar.Area.values[i,gw],self.minimum_area))) - press = press_buoy + press_drag - #self.UpdVar.W.new[i,gw] = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * dti_ - # -adv + exch + buoy + press)/(self.Ref.rho0[gw] * self.UpdVar.Area.new[i,gw] * dti_) - self.UpdVar.W.values[i,gw] = sqrt(2.0*fmax(self.UpdVar.B.values[i,gw],0.0)) - self.UpdVar.W.new[i,gw] = self.UpdVar.W.values[i,gw] - - - #self.UpdVar.W.values[i,gw] = sqrt(2.0*self.UpdVar.B.values[i,gw]) - for k in range(gw+1, self.Gr.nzg-gw): - # First solve for updated area fraction at k+1 - - if self.UpdVar.W.values[i,k]<0: - sgn_w = 0.0 - else: - sgn_w = 1.0 + with nogil: + # issues wth whether the BC is applied to values or new and at which k + for i in xrange(self.n_updrafts): + self.entr_sc[i,gw] = 20.0 * dzi + self.detr_sc[i,gw] = 0.0 + self.UpdVar.Area.new[i,gw] = self.area_surface_bc[i] + au_lim = self.area_surface_bc[i] * self.max_area_factor + + adv = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * self.UpdVar.W.values[i,gw] * dzi*2.0) + exch = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] + * (self.entr_sc[i,gw] * self.EnvVar.W.values[gw] - self.detr_sc[i,gw] * self.UpdVar.W.values[i,gw] )) + buoy= self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.B.values[i,gw] + press_buoy = -1.0 * self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.B.values[i,gw] * self.pressure_buoy_coeff + #press_drag = -1.0 * self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * (self.pressure_drag_coeff/self.pressure_plume_spacing + # * (self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])**2.0/sqrt(fmax(self.UpdVar.Area.values[i,gw],self.minimum_area))) + press_drag = -1.0 * self.Ref.rho0[gw]*sqrt(self.UpdVar.Area.values[i,gw])*self.pressure_drag_coeff/self.pressure_plume_spacing \ + * (self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])*fabs(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw]) + press = press_buoy + press_drag + self.UpdVar.W.values[i,gw] = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * dti_ + -adv + exch + buoy + press)/(self.Ref.rho0[gw] * self.UpdVar.Area.new[i,gw] * dti_) + #self.UpdVar.W.values[i,gw] = sqrt(2.0*fmax(self.UpdVar.B.values[i,gw],0.0)) + self.UpdVar.W.new[i,gw] = self.UpdVar.W.values[i,gw] + with gil: + print self.UpdVar.W.new[i,gw], -adv, exch, buoy , press + + + #self.UpdVar.W.values[i,gw] = sqrt(2.0*self.UpdVar.B.values[i,gw]) + for k in range(gw+1, self.Gr.nzg-gw): + # First solve for updated area fraction at k+1 + + if self.UpdVar.W.values[i,k]<0: + sgn_w = 0.0 + else: + sgn_w = 1.0 - adv_up = -self.Ref.alpha0[k] * dzi *( self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] - -self.Ref.rho0[k-1] * self.UpdVar.Area.values[i,k-1] * self.UpdVar.W.values[i,k-1]) - adv_dw = -self.Ref.alpha0[k] * dzi *( self.Ref.rho0[k+1] * self.UpdVar.Area.values[i,k+1] * self.UpdVar.W.values[i,k+1] - -self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k]) - adv = sgn_w*adv_up + (1.0-sgn_w)*adv_dw + adv_up = -self.Ref.alpha0[k] * dzi *( self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] + -self.Ref.rho0[k-1] * self.UpdVar.Area.values[i,k-1] * self.UpdVar.W.values[i,k-1]) + adv_dw = -self.Ref.alpha0[k] * dzi *( self.Ref.rho0[k+1] * self.UpdVar.Area.values[i,k+1] * self.UpdVar.W.values[i,k+1] + -self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k]) + adv = sgn_w*adv_up + (1.0-sgn_w)*adv_dw - entr_term = self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * (2.0*sgn_w-1.0)*self.entr_sc[i,k] - detr_term = self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * (1.0-2.0*sgn_w)*self.detr_sc[i,k] - self.UpdVar.Area.new[i,k] = fmax(dt_ * (adv + entr_term + detr_term) + self.UpdVar.Area.values[i,k], 0.0) + entr_term = self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * (2.0*sgn_w-1.0)*self.entr_sc[i,k] + detr_term = self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * (1.0-2.0*sgn_w)*self.detr_sc[i,k] + self.UpdVar.Area.new[i,k] = fmax(dt_ * (adv + entr_term + detr_term) + self.UpdVar.Area.values[i,k], 0.0) - if self.UpdVar.Area.new[i,k] > au_lim: - self.UpdVar.Area.new[i,k] = au_lim - if self.UpdVar.Area.values[i,k] > 0.0: - self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ - adv -entr_term)/(-self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k])) - else: - # this detrainment rate won't affect scalars but would affect velocity - self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ - adv -entr_term)/(-au_lim * self.UpdVar.W.values[i,k])) + if self.UpdVar.Area.new[i,k] > au_lim: + self.UpdVar.Area.new[i,k] = au_lim + if self.UpdVar.Area.values[i,k] > 0.0: + self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ - adv -entr_term)/(-self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k])) + else: + # this detrainment rate won't affect scalars but would affect velocity + self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ - adv -entr_term)/(-au_lim * self.UpdVar.W.values[i,k])) - # Now solve for updraft velocity at k - rho_ratio = self.Ref.rho0[k-1]/self.Ref.rho0[k] + # Now solve for updraft velocity at k + rho_ratio = self.Ref.rho0[k-1]/self.Ref.rho0[k] - if self.UpdVar.Area.new[i,k] >= self.minimum_area: - entr_w = self.entr_sc[i,k] - detr_w = self.detr_sc[i,k] + if self.UpdVar.Area.new[i,k] >= self.minimum_area: + entr_w = self.entr_sc[i,k] + detr_w = self.detr_sc[i,k] - adv_up = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.UpdVar.W.values[i,k] * dzi - - self.Ref.rho0[k-1] * self.UpdVar.Area.values[i,k-1] * self.UpdVar.W.values[i,k-1] * self.UpdVar.W.values[i,k-1] * dzi) - adv_dw = (self.Ref.rho0[k+1] * self.UpdVar.Area.values[i,k+1] * self.UpdVar.W.values[i,k+1] * self.UpdVar.W.values[i,k+1] * dzi - - self.Ref.rho0[k] *self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.UpdVar.W.values[i,k] * dzi)# -res_dw - adv = sgn_w*adv_up + (1.0-sgn_w)*adv_dw + adv_up = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.UpdVar.W.values[i,k] * dzi + - self.Ref.rho0[k-1] * self.UpdVar.Area.values[i,k-1] * self.UpdVar.W.values[i,k-1] * self.UpdVar.W.values[i,k-1] * dzi) + adv_dw = (self.Ref.rho0[k+1] * self.UpdVar.Area.values[i,k+1] * self.UpdVar.W.values[i,k+1] * self.UpdVar.W.values[i,k+1] * dzi + - self.Ref.rho0[k] *self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.UpdVar.W.values[i,k] * dzi)# -res_dw + adv = sgn_w*adv_up + (1.0-sgn_w)*adv_dw - exch = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] - * ((2.0*sgn_w-1.0)*entr_w * self.EnvVar.W.values[k] - (2.0*sgn_w-1.0)*detr_w * self.UpdVar.W.values[i,k] )) - buoy= self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] - press_buoy = -1.0 * self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] * self.pressure_buoy_coeff - press_drag = -1.0 * self.Ref.rho0[k]*(sqrt(self.UpdVar.Area.values[i,k] )*self.pressure_drag_coeff/self.pressure_plume_spacing - * (self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k])**2.0) - press = press_buoy + press_drag - self.updraft_pressure_sink[i,k] = press - self.UpdVar.W.new[i,k] = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * dti_ - -adv + exch + buoy + press)/(self.Ref.rho0[k] * self.UpdVar.Area.new[i,k] * dti_) + exch = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] + * ((2.0*sgn_w-1.0)*entr_w * self.EnvVar.W.values[k] - (2.0*sgn_w-1.0)*detr_w * self.UpdVar.W.values[i,k] )) + buoy= self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] + press_buoy = -1.0 * self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] * self.pressure_buoy_coeff + press_drag = -1.0 * self.Ref.rho0[k]*(sqrt(self.UpdVar.Area.values[i,k] )*self.pressure_drag_coeff/self.pressure_plume_spacing + * (self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k])*fabs(self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k])) + press = press_buoy + press_drag + self.updraft_pressure_sink[i,k] = press + self.UpdVar.W.new[i,k] = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * dti_ + -adv + exch + buoy + press)/(self.Ref.rho0[k] * self.UpdVar.Area.new[i,k] * dti_) - else: - self.UpdVar.W.new[i,k:] = 0.0 - self.UpdVar.Area.new[i,k:] = 0.0 - # keep this in mind if we modify updraft top treatment! - self.updraft_pressure_sink[i,k:] = 0.0 - break + else: + self.UpdVar.W.new[i,k:] = 0.0 + self.UpdVar.Area.new[i,k:] = 0.0 + # keep this in mind if we modify updraft top treatment! + self.updraft_pressure_sink[i,k:] = 0.0 + break return @@ -1016,9 +1020,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0[k], self.UpdVar.QT.new[i,k], self.UpdVar.H.new[i,k]) - if self.UpdVar.H.new[i,k]>310.0 or self.UpdVar.H.new[i,k]<290.0: - with gil: - print 'sa.ql',sa.ql, 'self.UpdVar.QT.new[i,k]', self.UpdVar.QT.new[i,k], 'sa.T', sa.T, 'self.UpdVar.H.new[i,k]',self.UpdVar.H.new[i,k] + # if self.UpdVar.H.new[i,k]>310.0 or self.UpdVar.H.new[i,k]<290.0: + # with gil: + # print 'sa.ql',sa.ql, 'self.UpdVar.QT.new[i,k]', self.UpdVar.QT.new[i,k], 'sa.T', sa.T, 'self.UpdVar.H.new[i,k]',self.UpdVar.H.new[i,k] self.UpdVar.QL.new[i,k] = sa.ql From 9aa7aa708222bc5a6bafed6b8c910cd35583e1bf Mon Sep 17 00:00:00 2001 From: yairchn Date: Tue, 7 Aug 2018 14:58:15 -0700 Subject: [PATCH 036/136] :..: --- Turbulence_PrognosticTKE.pyx | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 97cb36bc..e5bc598b 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -870,7 +870,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double adv, buoy, exch, press, press_buoy, press_drag # groupings of terms in velocity discrete equation with nogil: - # issues wth whether the BC is applied to values or new and at which k for i in xrange(self.n_updrafts): self.entr_sc[i,gw] = 20.0 * dzi self.detr_sc[i,gw] = 0.0 @@ -882,14 +881,12 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): * (self.entr_sc[i,gw] * self.EnvVar.W.values[gw] - self.detr_sc[i,gw] * self.UpdVar.W.values[i,gw] )) buoy= self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.B.values[i,gw] press_buoy = -1.0 * self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.B.values[i,gw] * self.pressure_buoy_coeff - #press_drag = -1.0 * self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * (self.pressure_drag_coeff/self.pressure_plume_spacing - # * (self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])**2.0/sqrt(fmax(self.UpdVar.Area.values[i,gw],self.minimum_area))) press_drag = -1.0 * self.Ref.rho0[gw]*sqrt(self.UpdVar.Area.values[i,gw])*self.pressure_drag_coeff/self.pressure_plume_spacing \ * (self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])*fabs(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw]) press = press_buoy + press_drag self.UpdVar.W.values[i,gw] = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * dti_ -adv + exch + buoy + press)/(self.Ref.rho0[gw] * self.UpdVar.Area.new[i,gw] * dti_) - #self.UpdVar.W.values[i,gw] = sqrt(2.0*fmax(self.UpdVar.B.values[i,gw],0.0)) + self.UpdVar.W.new[i,gw] = self.UpdVar.W.values[i,gw] with gil: print self.UpdVar.W.new[i,gw], -adv, exch, buoy , press From de721cb18c50c7c67b79e7dd19fe30d486daf7ec Mon Sep 17 00:00:00 2001 From: yairchn Date: Tue, 7 Aug 2018 16:28:45 -0700 Subject: [PATCH 037/136] working version cleeanup --- Turbulence_PrognosticTKE.pyx | 83 +++++++++--------------------------- 1 file changed, 21 insertions(+), 62 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index e5bc598b..3b3389be 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -663,7 +663,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cdef: Py_ssize_t k, gw = self.Gr.gw - double val1, val2, au_full + double val1, val2 double Hvar_e, QTvar_e, HQTcov_e, Hvar_u, QTvar_u, HQTcov_u if whichvals == 'values': @@ -675,8 +675,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.EnvVar.H.values[k] = val1 * GMV.H.values[k] - val2 * self.UpdVar.H.bulkvalues[k] # Have to account for staggering of W--interpolate area fraction to the "full" grid points # Assuming GMV.W = 0! - au_full = self.UpdVar.Area.bulkvalues[k] - self.EnvVar.W.values[k] = -au_full/(1.0-au_full) * self.UpdVar.W.bulkvalues[k] + self.EnvVar.W.values[k] = -self.UpdVar.Area.bulkvalues[k]/(1.0-self.UpdVar.Area.bulkvalues[k]) * self.UpdVar.W.bulkvalues[k] self.get_GMV_TKE(self.UpdVar.Area,self.UpdVar.W, self.EnvVar.W, self.EnvVar.TKE, &GMV.W.values[0], &GMV.TKE.values[0]) @@ -700,8 +699,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.EnvVar.H.values[k] = val1 * GMV.H.mf_update[k] - val2 * self.UpdVar.H.bulkvalues[k] # Have to account for staggering of W # Assuming GMV.W = 0! - au_full = self.UpdVar.Area.bulkvalues[k] - self.EnvVar.W.values[k] = -au_full/(1.0-au_full) * self.UpdVar.W.bulkvalues[k] + self.EnvVar.W.values[k] = -self.UpdVar.Area.bulkvalues[k]/(1.0-self.UpdVar.Area.bulkvalues[k]) * self.UpdVar.W.bulkvalues[k] self.get_GMV_TKE(self.UpdVar.Area,self.UpdVar.W, self.EnvVar.W, self.EnvVar.TKE, &GMV.W.values[0], &GMV.TKE.values[0]) @@ -866,12 +864,12 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double dt_ = 1.0/dti_ double a1, a2 # groupings of terms in area fraction discrete equation double au_lim, sgn_w, adv_up, adv_dw, m_km, m_k, m_kp - double entr_w, detr_w, entr_term, detr_term, rho_ratio + double entr_term, detr_term double adv, buoy, exch, press, press_buoy, press_drag # groupings of terms in velocity discrete equation with nogil: for i in xrange(self.n_updrafts): - self.entr_sc[i,gw] = 20.0 * dzi + self.entr_sc[i,gw] = 2.0 * dzi self.detr_sc[i,gw] = 0.0 self.UpdVar.Area.new[i,gw] = self.area_surface_bc[i] au_lim = self.area_surface_bc[i] * self.max_area_factor @@ -886,32 +884,23 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): press = press_buoy + press_drag self.UpdVar.W.values[i,gw] = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * dti_ -adv + exch + buoy + press)/(self.Ref.rho0[gw] * self.UpdVar.Area.new[i,gw] * dti_) - self.UpdVar.W.new[i,gw] = self.UpdVar.W.values[i,gw] - with gil: - print self.UpdVar.W.new[i,gw], -adv, exch, buoy , press - - #self.UpdVar.W.values[i,gw] = sqrt(2.0*self.UpdVar.B.values[i,gw]) for k in range(gw+1, self.Gr.nzg-gw): # First solve for updated area fraction at k+1 - if self.UpdVar.W.values[i,k]<0: sgn_w = 0.0 else: sgn_w = 1.0 - adv_up = -self.Ref.alpha0[k] * dzi *( self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] -self.Ref.rho0[k-1] * self.UpdVar.Area.values[i,k-1] * self.UpdVar.W.values[i,k-1]) adv_dw = -self.Ref.alpha0[k] * dzi *( self.Ref.rho0[k+1] * self.UpdVar.Area.values[i,k+1] * self.UpdVar.W.values[i,k+1] -self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k]) adv = sgn_w*adv_up + (1.0-sgn_w)*adv_dw - entr_term = self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * (2.0*sgn_w-1.0)*self.entr_sc[i,k] detr_term = self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * (1.0-2.0*sgn_w)*self.detr_sc[i,k] self.UpdVar.Area.new[i,k] = fmax(dt_ * (adv + entr_term + detr_term) + self.UpdVar.Area.values[i,k], 0.0) - if self.UpdVar.Area.new[i,k] > au_lim: self.UpdVar.Area.new[i,k] = au_lim if self.UpdVar.Area.values[i,k] > 0.0: @@ -921,11 +910,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ - adv -entr_term)/(-au_lim * self.UpdVar.W.values[i,k])) # Now solve for updraft velocity at k - rho_ratio = self.Ref.rho0[k-1]/self.Ref.rho0[k] - if self.UpdVar.Area.new[i,k] >= self.minimum_area: - entr_w = self.entr_sc[i,k] - detr_w = self.detr_sc[i,k] adv_up = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.UpdVar.W.values[i,k] * dzi - self.Ref.rho0[k-1] * self.UpdVar.Area.values[i,k-1] * self.UpdVar.W.values[i,k-1] * self.UpdVar.W.values[i,k-1] * dzi) @@ -934,7 +919,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): adv = sgn_w*adv_up + (1.0-sgn_w)*adv_dw exch = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] - * ((2.0*sgn_w-1.0)*entr_w * self.EnvVar.W.values[k] - (2.0*sgn_w-1.0)*detr_w * self.UpdVar.W.values[i,k] )) + * ((2.0*sgn_w-1.0)*self.entr_sc[i,k] * self.EnvVar.W.values[k] - (2.0*sgn_w-1.0)*self.detr_sc[i,k] * self.UpdVar.W.values[i,k] )) buoy= self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] press_buoy = -1.0 * self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] * self.pressure_buoy_coeff press_drag = -1.0 * self.Ref.rho0[k]*(sqrt(self.UpdVar.Area.values[i,k] )*self.pressure_drag_coeff/self.pressure_plume_spacing @@ -944,7 +929,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.W.new[i,k] = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * dti_ -adv + exch + buoy + press)/(self.Ref.rho0[k] * self.UpdVar.Area.new[i,k] * dti_) - else: self.UpdVar.W.new[i,k:] = 0.0 self.UpdVar.Area.new[i,k:] = 0.0 @@ -961,7 +945,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double dti_ = 1.0/self.dt_upd double m_k, m_km, m_kp, sgn_w Py_ssize_t gw = self.Gr.gw - double H_entr, QT_entr double c1, c2, c3, c4 eos_struct sa double qt_var, h_var @@ -980,9 +963,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): &self.UpdVar.QT.values[i,gw], &self.UpdVar.QL.values[i,gw], &self.UpdVar.H.values[i,gw], i, gw) for k in xrange(gw+1, self.Gr.nzg-gw): - H_entr = self.EnvVar.H.values[k] - QT_entr = self.EnvVar.QT.values[k] - # write the discrete equations in form: # c1 * phi_new[k] = c2 * phi[k] + c3 * phi[k-1] + c4 * phi_entr if self.UpdVar.Area.new[i,k] >= self.minimum_area: @@ -1001,15 +981,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): c4 = (2.0*sgn_w-1.0)*m_k * self.entr_sc[i,k] self.UpdVar.H.new[i,k] = (c2 * self.UpdVar.H.values[i,k] + c3*sgn_w * self.UpdVar.H.values[i,k-1] - + c3*(1.0-sgn_w) * self.UpdVar.H.values[i,k+1] + c4 * H_entr )/c1 + + c3*(1.0-sgn_w) * self.UpdVar.H.values[i,k+1] + c4 * self.EnvVar.H.values[k] )/c1 self.UpdVar.QT.new[i,k] = (c2 * self.UpdVar.QT.values[i,k] + c3*sgn_w * self.UpdVar.QT.values[i,k-1] - + c3*(1.0-sgn_w) * self.UpdVar.QT.values[i,k+1] + c4* QT_entr)/c1 - - # if self.UpdVar.H.new[i,k]>310.0 or self.UpdVar.H.new[i,k]<290.0: - # with gil: - # print'self.UpdVar.H.new[i,k]', self.UpdVar.H.new[i,k], 'self.UpdVar.QT.new[i,k] ',self.UpdVar.QT.new[i,k] - # print 'self.UpdVar.Area.values[i,k+1]', self.UpdVar.Area.values[i,k+1], 'self.UpdVar.Area.values[i,k]', self.UpdVar.Area.values[i,k], 'self.UpdVar.Area.values[i,k-1]', self.UpdVar.Area.values[i,k-1] - # print c1,c2,c3,c4 + + c3*(1.0-sgn_w) * self.UpdVar.QT.values[i,k+1] + c4* self.EnvVar.QT.values[k])/c1 else: self.UpdVar.H.new[i,k] = GMV.H.values[k] @@ -1017,10 +991,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0[k], self.UpdVar.QT.new[i,k], self.UpdVar.H.new[i,k]) - # if self.UpdVar.H.new[i,k]>310.0 or self.UpdVar.H.new[i,k]<290.0: - # with gil: - # print 'sa.ql',sa.ql, 'self.UpdVar.QT.new[i,k]', self.UpdVar.QT.new[i,k], 'sa.T', sa.T, 'self.UpdVar.H.new[i,k]',self.UpdVar.H.new[i,k] - self.UpdVar.QL.new[i,k] = sa.ql self.UpdVar.T.new[i,k] = sa.T @@ -1038,9 +1008,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.H.new[i,gw] = self.h_surface_bc[i] self.UpdVar.QT.new[i,gw] = self.qt_surface_bc[i] for k in xrange(gw+1, self.Gr.nzg-gw): - H_entr = self.EnvVar.H.values[k] - QT_entr = self.EnvVar.QT.values[k] - # write the discrete equations in form: # c1 * phi_new[k] = c2 * phi[k] + c3 * phi[k-1] + c4 * phi_entr if self.UpdVar.Area.new[i,k] >= self.minimum_area: @@ -1058,9 +1025,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): c4 = (2*sgn_w-1.0)*(m_k * self.entr_sc[i,k]) self.UpdVar.H.new[i,k] = (c2 * self.UpdVar.H.values[i,k] + c3*sgn_w * self.UpdVar.H.values[i,k-1] - + c3*(1.0-sgn_w) * self.UpdVar.H.values[i,k+1] + c4 * H_entr )/c1 + + c3*(1.0-sgn_w) * self.UpdVar.H.values[i,k+1] + c4 * self.EnvVar.H.values[k] )/c1 self.UpdVar.QT.new[i,k] = (c2 * self.UpdVar.QT.values[i,k] + c3*sgn_w * self.UpdVar.QT.values[i,k-1] - + c3*(1.0-sgn_w) * self.UpdVar.QT.values[i,k+1] + c4* QT_entr)/c1 + + c3*(1.0-sgn_w) * self.UpdVar.QT.values[i,k+1] + c4* self.EnvVar.QT.values[k])/c1 else: self.UpdVar.H.new[i,k] = GMV.H.values[k] @@ -1396,7 +1363,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double [:] ae = np.subtract(np.ones((nzg,),dtype=np.double, order='c'),self.UpdVar.Area.bulkvalues) # area of environment double [:] ae_old = np.subtract(np.ones((nzg,),dtype=np.double, order='c'), np.sum(self.UpdVar.Area.old,axis=0)) double [:] rho_ae_K_m = np.zeros((nzg,),dtype=np.double, order='c') - double [:] whalf = np.zeros((nzg,),dtype=np.double, order='c') double D_env = 0.0 double wu, we, tke_0_surf,press_k @@ -1405,7 +1371,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(1,nzg-1): rho_ae_K_m[k] = 0.5 * (ae[k]*self.KM.values[k]+ ae[k+1]*self.KM.values[k+1]) * self.Ref.rho0[k] - whalf[k] = self.EnvVar.W.values[k] wu = self.UpdVar.W.bulkvalues[gw] GMV.TKE.values[gw] = get_surface_tke(Case.Sur.ustar, self.wstar, self.Gr.z[gw], Case.Sur.obukhov_length) self.get_env_tke_from_GMV(self.UpdVar.Area, self.UpdVar.W, self.EnvVar.W, @@ -1424,11 +1389,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): D_env += self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * wu * self.entr_sc[i,k] a[kk] = (- rho_ae_K_m[k-1] * dzi * dzi ) - b[kk] = (self.Ref.rho0[k] * ae[k] * dti - self.Ref.rho0[k] * ae[k] * whalf[k] * dzi + b[kk] = (self.Ref.rho0[k] * ae[k] * dti - self.Ref.rho0[k] * ae[k] * self.EnvVar.W.values[k] * dzi + rho_ae_K_m[k] * dzi * dzi + rho_ae_K_m[k-1] * dzi * dzi + D_env + self.Ref.rho0[k] * ae[k] * self.tke_diss_coeff * sqrt(fmax(self.EnvVar.TKE.values[k],0.0))/fmax(self.mixing_length[k],1.0)) - c[kk] = (self.Ref.rho0[k+1] * ae[k+1] * whalf[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) + c[kk] = (self.Ref.rho0[k+1] * ae[k+1] * self.EnvVar.W.values[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) x[kk] = (self.Ref.rho0[k] * ae_old[k] * self.EnvVar.TKE.values[k] * dti + self.tke_shear[k] + self.tke_buoy[k] + self.tke_entr_gain[k] + self.tke_pressure[k]) a[0] = 0.0 @@ -1592,9 +1557,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double [:] ae = np.subtract(np.ones((nzg,),dtype=np.double, order='c'),self.UpdVar.Area.bulkvalues) # area of environment double [:] ae_old = np.subtract(np.ones((nzg,),dtype=np.double, order='c'), np.sum(self.UpdVar.Area.old,axis=0)) double [:] rho_ae_K_m = np.zeros((nzg,),dtype=np.double, order='c') - double [:] whalf = np.zeros((nzg,),dtype=np.double, order='c') - double [:] Hhalf = np.zeros((nzg,),dtype=np.double, order='c') - double [:] QThalf = np.zeros((nzg,),dtype=np.double, order='c') double D_env = 0.0 # missing flux1 and 2 in get_surface_variance @@ -1608,9 +1570,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(1,nzg-1): rho_ae_K_m[k] = 0.5 * (ae[k]*self.KH.values[k]+ ae[k+1]*self.KH.values[k+1]) * self.Ref.rho0[k] - whalf[k] = self.EnvVar.W.values[k] - Hhalf[k] = self.EnvVar.H.values[k] - QThalf[k] = self.EnvVar.QT.values[k] wu = self.UpdVar.W.bulkvalues[gw] Hu = self.UpdVar.H.bulkvalues[gw] QTu = self.UpdVar.QT.bulkvalues[gw] @@ -1641,12 +1600,12 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): D_env += self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * wu * self.entr_sc[i,k] a[kk] = (- rho_ae_K_m[k-1] * dzi * dzi ) - b[kk] = (self.Ref.rho0[k] * ae[k] * dti - self.Ref.rho0[k] * ae[k] * whalf[k] * dzi + b[kk] = (self.Ref.rho0[k] * ae[k] * dti - self.Ref.rho0[k] * ae[k] * self.EnvVar.W.values[k] * dzi + rho_ae_K_m[k] * dzi * dzi + rho_ae_K_m[k-1] * dzi * dzi + D_env + self.Ref.rho0[k] * ae[k] * self.tke_diss_coeff *sqrt(fmax(self.EnvVar.TKE.values[k],0))/fmax(self.mixing_length[k],1.0) ) - c[kk] = (self.Ref.rho0[k+1] * ae[k+1] * whalf[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) + c[kk] = (self.Ref.rho0[k+1] * ae[k+1] * self.EnvVar.W.values[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) x[kk] = (self.Ref.rho0[k] * ae_old[k] * self.EnvVar.Hvar.values[k] * dti + self.Hvar_shear[k] + self.Hvar_entr_gain[k]) # @@ -1663,7 +1622,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for kk in xrange(nz): k = kk + gw self.EnvVar.Hvar.values[k] = x[kk] - GMV.Hvar.values[k] = (ae[k] * (self.EnvVar.Hvar.values[k] + (Hhalf[k]-GMV.H.values[k]) * (Hhalf[k]-GMV.H.values[k])) + GMV.Hvar.values[k] = (ae[k] * (self.EnvVar.Hvar.values[k] + (self.EnvVar.H.values[k]-GMV.H.values[k]) * (self.EnvVar.H.values[k]-GMV.H.values[k])) + self.UpdVar.Area.bulkvalues[k] * (self.UpdVar.H.bulkvalues[k]-GMV.H.values[k]) * (self.UpdVar.H.bulkvalues[k]-GMV.H.values[k])) self.get_GMV_CoVar(self.UpdVar.Area, self.UpdVar.H, self.UpdVar.H, self.EnvVar.H, self.EnvVar.H, self.EnvVar.Hvar, @@ -1679,12 +1638,12 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): D_env += self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * wu * self.entr_sc[i,k] a[kk] = (- rho_ae_K_m[k-1] * dzi * dzi ) - b[kk] = (self.Ref.rho0[k] * ae[k] * dti - self.Ref.rho0[k] * ae[k] * whalf[k] * dzi + b[kk] = (self.Ref.rho0[k] * ae[k] * dti - self.Ref.rho0[k] * ae[k] * self.EnvVar.W.values[k] * dzi + rho_ae_K_m[k] * dzi * dzi + rho_ae_K_m[k-1] * dzi * dzi + D_env + self.Ref.rho0[k] * ae[k] * self.tke_diss_coeff *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0)) - c[kk] = (self.Ref.rho0[k+1] * ae[k+1] * whalf[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) + c[kk] = (self.Ref.rho0[k+1] * ae[k+1] * self.EnvVar.W.values[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) x[kk] = (self.Ref.rho0[k] * ae_old[k] * self.EnvVar.QTvar.values[k] * dti + self.QTvar_shear[k] + self.QTvar_entr_gain[k]) # @@ -1702,7 +1661,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): k = kk + gw #self.EnvVar.Hvar.values[k] = fmax(x[kk], 0.0) self.EnvVar.QTvar.values[k] = x[kk] - GMV.QTvar.values[k] = (ae[k] * (self.EnvVar.QTvar.values[k] + (QThalf[k]-GMV.QT.values[k]) * (QThalf[k]-GMV.QT.values[k])) + GMV.QTvar.values[k] = (ae[k] * (self.EnvVar.QTvar.values[k] + (self.EnvVar.QT.values[k]-GMV.QT.values[k]) * (self.EnvVar.QT.values[k]-GMV.QT.values[k])) + self.UpdVar.Area.bulkvalues[k] * (self.UpdVar.QT.bulkvalues[k]-GMV.QT.values[k]) * (self.UpdVar.QT.bulkvalues[k]-GMV.QT.values[k])) self.get_GMV_CoVar(self.UpdVar.Area, self.UpdVar.QT, self.UpdVar.QT, self.EnvVar.QT, self.EnvVar.QT, self.EnvVar.QTvar, @@ -1719,12 +1678,12 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): D_env += self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * wu * self.entr_sc[i,k] a[kk] = (- rho_ae_K_m[k-1] * dzi * dzi ) - b[kk] = (self.Ref.rho0[k] * ae[k] * dti - self.Ref.rho0[k] * ae[k] * whalf[k] * dzi + b[kk] = (self.Ref.rho0[k] * ae[k] * dti - self.Ref.rho0[k] * ae[k] * self.EnvVar.W.values[k] * dzi + rho_ae_K_m[k] * dzi * dzi + rho_ae_K_m[k-1] * dzi * dzi + D_env + self.Ref.rho0[k] * ae[k] * self.tke_diss_coeff *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0) ) - c[kk] = (self.Ref.rho0[k+1] * ae[k+1] * whalf[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) + c[kk] = (self.Ref.rho0[k+1] * ae[k+1] * self.EnvVar.W.values[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) x[kk] = (self.Ref.rho0[k] * ae_old[k] * self.EnvVar.HQTcov.values[k] * dti + self.HQTcov_shear[k] + self.HQTcov_entr_gain[k]) # @@ -1741,7 +1700,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for kk in xrange(nz): k = kk + gw self.EnvVar.HQTcov.values[k] = x[kk] - GMV.HQTcov.values[k] = (ae[k] * (self.EnvVar.HQTcov.values[k] + (Hhalf[k]-GMV.H.values[k]) * (QThalf[k]-GMV.QT.values[k])) + GMV.HQTcov.values[k] = (ae[k] * (self.EnvVar.HQTcov.values[k] + (self.EnvVar.H.values[k]-GMV.H.values[k]) * (self.EnvVar.QT.values[k]-GMV.QT.values[k])) + self.UpdVar.Area.bulkvalues[k] * (self.UpdVar.H.bulkvalues[k]-GMV.H.values[k]) * (self.UpdVar.QT.bulkvalues[k]-GMV.QT.values[k])) self.get_GMV_CoVar(self.UpdVar.Area, self.UpdVar.H, self.UpdVar.QT, self.EnvVar.H, self.EnvVar.QT, self.EnvVar.HQTcov, From 8409a74c543fb98ad77e6af9526184b6a29aee69 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Tue, 7 Aug 2018 20:23:43 -0700 Subject: [PATCH 038/136] working --- Turbulence_PrognosticTKE.pxd | 5 +- Turbulence_PrognosticTKE.pyx | 289 +++++++++++++++-------------------- 2 files changed, 126 insertions(+), 168 deletions(-) diff --git a/Turbulence_PrognosticTKE.pxd b/Turbulence_PrognosticTKE.pxd index 950633c8..8da83ba1 100644 --- a/Turbulence_PrognosticTKE.pxd +++ b/Turbulence_PrognosticTKE.pxd @@ -95,8 +95,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cpdef set_updraft_surface_bc(self, GridMeanVariables GMV, CasesBase Case) cpdef decompose_environment(self, GridMeanVariables GMV, whichvals) cpdef compute_entrainment_detrainment(self, GridMeanVariables GMV, CasesBase Case) - cpdef solve_updraft_velocity_area(self, GridMeanVariables GMV, TimeStepping TS) - cpdef solve_updraft_scalars(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS) + cpdef solve_updraft(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS) + cpdef upwind_integration(self, EDMF_Updrafts.UpdraftVariable area, + EDMF_Updrafts.UpdraftVariable var, int k, int i, double env_var) cpdef update_GMV_MF(self, GridMeanVariables GMV, TimeStepping TS) cpdef update_GMV_ED(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS) cpdef compute_tke(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 3b3389be..2d1117b6 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -365,8 +365,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.dt_upd = np.minimum(TS.dt, 0.5 * self.Gr.dz/fmax(np.max(self.UpdVar.W.values),1e-10)) while time_elapsed < TS.dt: self.compute_entrainment_detrainment(GMV, Case) - self.solve_updraft_velocity_area(GMV,TS) - self.solve_updraft_scalars(GMV, Case, TS) + self.solve_updraft(GMV, Case, TS) self.UpdVar.set_values_with_new() time_elapsed += self.dt_upd self.dt_upd = np.minimum(TS.dt-time_elapsed, 0.5 * self.Gr.dz/fmax(np.max(self.UpdVar.W.values),1e-10)) @@ -855,7 +854,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): return - cpdef solve_updraft_velocity_area(self, GridMeanVariables GMV, TimeStepping TS): + cpdef solve_updraft(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS): cdef: Py_ssize_t i, k Py_ssize_t gw = self.Gr.gw @@ -866,176 +865,70 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double au_lim, sgn_w, adv_up, adv_dw, m_km, m_k, m_kp double entr_term, detr_term double adv, buoy, exch, press, press_buoy, press_drag # groupings of terms in velocity discrete equation - - with nogil: - for i in xrange(self.n_updrafts): - self.entr_sc[i,gw] = 2.0 * dzi - self.detr_sc[i,gw] = 0.0 - self.UpdVar.Area.new[i,gw] = self.area_surface_bc[i] - au_lim = self.area_surface_bc[i] * self.max_area_factor - - adv = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * self.UpdVar.W.values[i,gw] * dzi*2.0) - exch = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] - * (self.entr_sc[i,gw] * self.EnvVar.W.values[gw] - self.detr_sc[i,gw] * self.UpdVar.W.values[i,gw] )) - buoy= self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.B.values[i,gw] - press_buoy = -1.0 * self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.B.values[i,gw] * self.pressure_buoy_coeff - press_drag = -1.0 * self.Ref.rho0[gw]*sqrt(self.UpdVar.Area.values[i,gw])*self.pressure_drag_coeff/self.pressure_plume_spacing \ - * (self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])*fabs(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw]) - press = press_buoy + press_drag - self.UpdVar.W.values[i,gw] = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * dti_ - -adv + exch + buoy + press)/(self.Ref.rho0[gw] * self.UpdVar.Area.new[i,gw] * dti_) - self.UpdVar.W.new[i,gw] = self.UpdVar.W.values[i,gw] - - for k in range(gw+1, self.Gr.nzg-gw): - # First solve for updated area fraction at k+1 - if self.UpdVar.W.values[i,k]<0: - sgn_w = 0.0 - else: - sgn_w = 1.0 - adv_up = -self.Ref.alpha0[k] * dzi *( self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] - -self.Ref.rho0[k-1] * self.UpdVar.Area.values[i,k-1] * self.UpdVar.W.values[i,k-1]) - adv_dw = -self.Ref.alpha0[k] * dzi *( self.Ref.rho0[k+1] * self.UpdVar.Area.values[i,k+1] * self.UpdVar.W.values[i,k+1] - -self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k]) - adv = sgn_w*adv_up + (1.0-sgn_w)*adv_dw - entr_term = self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * (2.0*sgn_w-1.0)*self.entr_sc[i,k] - detr_term = self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * (1.0-2.0*sgn_w)*self.detr_sc[i,k] - self.UpdVar.Area.new[i,k] = fmax(dt_ * (adv + entr_term + detr_term) + self.UpdVar.Area.values[i,k], 0.0) - - if self.UpdVar.Area.new[i,k] > au_lim: - self.UpdVar.Area.new[i,k] = au_lim - if self.UpdVar.Area.values[i,k] > 0.0: - self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ - adv -entr_term)/(-self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k])) - else: - # this detrainment rate won't affect scalars but would affect velocity - self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ - adv -entr_term)/(-au_lim * self.UpdVar.W.values[i,k])) - - # Now solve for updraft velocity at k - if self.UpdVar.Area.new[i,k] >= self.minimum_area: - - adv_up = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.UpdVar.W.values[i,k] * dzi - - self.Ref.rho0[k-1] * self.UpdVar.Area.values[i,k-1] * self.UpdVar.W.values[i,k-1] * self.UpdVar.W.values[i,k-1] * dzi) - adv_dw = (self.Ref.rho0[k+1] * self.UpdVar.Area.values[i,k+1] * self.UpdVar.W.values[i,k+1] * self.UpdVar.W.values[i,k+1] * dzi - - self.Ref.rho0[k] *self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.UpdVar.W.values[i,k] * dzi)# -res_dw - adv = sgn_w*adv_up + (1.0-sgn_w)*adv_dw - - exch = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] - * ((2.0*sgn_w-1.0)*self.entr_sc[i,k] * self.EnvVar.W.values[k] - (2.0*sgn_w-1.0)*self.detr_sc[i,k] * self.UpdVar.W.values[i,k] )) - buoy= self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] - press_buoy = -1.0 * self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] * self.pressure_buoy_coeff - press_drag = -1.0 * self.Ref.rho0[k]*(sqrt(self.UpdVar.Area.values[i,k] )*self.pressure_drag_coeff/self.pressure_plume_spacing - * (self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k])*fabs(self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k])) - press = press_buoy + press_drag - self.updraft_pressure_sink[i,k] = press - self.UpdVar.W.new[i,k] = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * dti_ - -adv + exch + buoy + press)/(self.Ref.rho0[k] * self.UpdVar.Area.new[i,k] * dti_) - - else: - self.UpdVar.W.new[i,k:] = 0.0 - self.UpdVar.Area.new[i,k:] = 0.0 - # keep this in mind if we modify updraft top treatment! - self.updraft_pressure_sink[i,k:] = 0.0 - break - - return - - cpdef solve_updraft_scalars(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS): - cdef: - Py_ssize_t k, i - double dzi = self.Gr.dzi - double dti_ = 1.0/self.dt_upd - double m_k, m_km, m_kp, sgn_w - Py_ssize_t gw = self.Gr.gw - double c1, c2, c3, c4 eos_struct sa double qt_var, h_var - if self.use_local_micro: - with nogil: - for i in xrange(self.n_updrafts): - self.UpdVar.H.new[i,gw] = self.h_surface_bc[i] - self.UpdVar.QT.new[i,gw] = self.qt_surface_bc[i] - - sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, - self.Ref.p0[gw], self.UpdVar.QT.values[i,gw], self.UpdVar.H.values[i,gw]) - self.UpdVar.QL.new[i,gw] = sa.ql - self.UpdVar.T.new[i,gw] = sa.T - self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0[gw], self.UpdVar.T.values[i,gw], - &self.UpdVar.QT.values[i,gw], &self.UpdVar.QL.values[i,gw], - &self.UpdVar.H.values[i,gw], i, gw) - for k in xrange(gw+1, self.Gr.nzg-gw): - # write the discrete equations in form: - # c1 * phi_new[k] = c2 * phi[k] + c3 * phi[k-1] + c4 * phi_entr - if self.UpdVar.Area.new[i,k] >= self.minimum_area: - if self.UpdVar.W.values[i,k]<0: - sgn_w = 0.0 - else: - sgn_w = 1.0 - m_kp = (self.Ref.rho0[k+1] * self.UpdVar.Area.values[i,k+1]*self.UpdVar.W.values[i,k+1]) - m_k = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k]*self.UpdVar.W.values[i,k]) - m_km = (self.Ref.rho0[k-1] * self.UpdVar.Area.values[i,k-1]* self.UpdVar.W.values[i,k-1]) - - c1 = self.Ref.rho0[k] * self.UpdVar.Area.new[i,k] * dti_ - c2 = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * dti_ - - (2.0*sgn_w-1.0)*m_k * (dzi + self.detr_sc[i,k])) - c3 = sgn_w*m_km * dzi - (1.0-sgn_w)*m_kp*dzi - c4 = (2.0*sgn_w-1.0)*m_k * self.entr_sc[i,k] - - self.UpdVar.H.new[i,k] = (c2 * self.UpdVar.H.values[i,k] + c3*sgn_w * self.UpdVar.H.values[i,k-1] - + c3*(1.0-sgn_w) * self.UpdVar.H.values[i,k+1] + c4 * self.EnvVar.H.values[k] )/c1 - self.UpdVar.QT.new[i,k] = (c2 * self.UpdVar.QT.values[i,k] + c3*sgn_w * self.UpdVar.QT.values[i,k-1] - + c3*(1.0-sgn_w) * self.UpdVar.QT.values[i,k+1] + c4* self.EnvVar.QT.values[k])/c1 + #with nogil: + for i in xrange(self.n_updrafts): + self.entr_sc[i,gw] = 2.0 * dzi + self.detr_sc[i,gw] = 0.0 + self.UpdVar.Area.new[i,gw] = self.area_surface_bc[i] + au_lim = self.area_surface_bc[i] * self.max_area_factor + + adv = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * self.UpdVar.W.values[i,gw] * dzi*2.0) + exch = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] + * (self.entr_sc[i,gw] * self.EnvVar.W.values[gw] - self.detr_sc[i,gw] * self.UpdVar.W.values[i,gw] )) + buoy= self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.B.values[i,gw] + press_buoy = -1.0 * self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.B.values[i,gw] * self.pressure_buoy_coeff + press_drag = -1.0 * self.Ref.rho0[gw]*sqrt(self.UpdVar.Area.values[i,gw])*self.pressure_drag_coeff/self.pressure_plume_spacing \ + * (self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])*fabs(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw]) + press = press_buoy + press_drag + self.UpdVar.W.values[i,gw] = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * dti_ + -adv + exch + buoy + press)/(self.Ref.rho0[gw] * self.UpdVar.Area.new[i,gw] * dti_) + self.UpdVar.W.new[i,gw] = self.UpdVar.W.values[i,gw] + + + self.UpdVar.H.new[i,gw] = self.h_surface_bc[i] + self.UpdVar.QT.new[i,gw] = self.qt_surface_bc[i] + + sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, + self.Ref.p0[gw], self.UpdVar.QT.values[i,gw], self.UpdVar.H.values[i,gw]) + self.UpdVar.QL.new[i,gw] = sa.ql + self.UpdVar.T.new[i,gw] = sa.T + self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0[gw], self.UpdVar.T.values[i,gw], + &self.UpdVar.QT.values[i,gw], &self.UpdVar.QL.values[i,gw], + &self.UpdVar.H.values[i,gw], i, gw) + + for k in range(gw+1, self.Gr.nzg-gw): + #print '903', self.UpdVar.Area.values[i,gw], self.UpdVar.W.values[i,gw] + self.upwind_integration(self.UpdVar.Area, self.UpdVar.Area, k, i, 1.0) + print self.UpdVar.Area.new[i,k] + if self.UpdVar.Area.new[i,k] >= self.minimum_area: + self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, k, i, self.EnvVar.W.values[k]) + self.upwind_integration(self.UpdVar.Area, self.UpdVar.H, k, i, self.EnvVar.H.values[k]) + self.upwind_integration(self.UpdVar.Area, self.UpdVar.QT, k, i, self.EnvVar.QT.values[k]) + else: + self.UpdVar.W.new[i,k] = 0.0 + self.UpdVar.Area.new[i,k] = 0.0 + self.updraft_pressure_sink[i,k] = 0.0 # keep this in mind if we modify updraft top treatment! - else: - self.UpdVar.H.new[i,k] = GMV.H.values[k] - self.UpdVar.QT.new[i,k] = GMV.QT.values[k] + self.UpdVar.H.new[i,k] = GMV.H.values[k] + self.UpdVar.QT.new[i,k] = GMV.QT.values[k] - sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0[k], - self.UpdVar.QT.new[i,k], self.UpdVar.H.new[i,k]) - - self.UpdVar.QL.new[i,k] = sa.ql - self.UpdVar.T.new[i,k] = sa.T - self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0[k], self.UpdVar.T.new[i,k], - &self.UpdVar.QT.new[i,k], &self.UpdVar.QL.new[i,k], - &self.UpdVar.H.new[i,k], i, k) - self.UpdMicro.prec_source_h_tot = np.sum(np.multiply(self.UpdMicro.prec_source_h, - self.UpdVar.Area.values), axis=0) - self.UpdMicro.prec_source_qt_tot = np.sum(np.multiply(self.UpdMicro.prec_source_qt, - self.UpdVar.Area.values), axis=0) + sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0[k], + self.UpdVar.QT.new[i,k], self.UpdVar.H.new[i,k]) - else: - with nogil: - for i in xrange(self.n_updrafts): - self.UpdVar.H.new[i,gw] = self.h_surface_bc[i] - self.UpdVar.QT.new[i,gw] = self.qt_surface_bc[i] - for k in xrange(gw+1, self.Gr.nzg-gw): - # write the discrete equations in form: - # c1 * phi_new[k] = c2 * phi[k] + c3 * phi[k-1] + c4 * phi_entr - if self.UpdVar.Area.new[i,k] >= self.minimum_area: - if self.UpdVar.W.values[i,k-1]<0: - sgn_w = 0.0 - else: - sgn_w = 1.0 - m_kp = (self.Ref.rho0[k+1] * self.UpdVar.Area.values[i,k+1]*self.UpdVar.W.values[i,k+1]) - m_k = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k]*self.UpdVar.W.values[i,k]) - m_km = (self.Ref.rho0[k-1] * self.UpdVar.Area.values[i,k-1]* self.UpdVar.W.values[i,k-1]) - c1 = self.Ref.rho0[k] * self.UpdVar.Area.new[i,k] * dti_ - c2 = (self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * dti_ - - (2*sgn_w-1.0)*m_k * (dzi + self.detr_sc[i,k])) - c3 = sgn_w*m_km * dzi-(1.0-sgn_w)*m_kp * dzi - c4 = (2*sgn_w-1.0)*(m_k * self.entr_sc[i,k]) - - self.UpdVar.H.new[i,k] = (c2 * self.UpdVar.H.values[i,k] + c3*sgn_w * self.UpdVar.H.values[i,k-1] - + c3*(1.0-sgn_w) * self.UpdVar.H.values[i,k+1] + c4 * self.EnvVar.H.values[k] )/c1 - self.UpdVar.QT.new[i,k] = (c2 * self.UpdVar.QT.values[i,k] + c3*sgn_w * self.UpdVar.QT.values[i,k-1] - + c3*(1.0-sgn_w) * self.UpdVar.QT.values[i,k+1] + c4* self.EnvVar.QT.values[k])/c1 + self.UpdVar.QL.new[i,k] = sa.ql + self.UpdVar.T.new[i,k] = sa.T - else: - self.UpdVar.H.new[i,k] = GMV.H.values[k] - self.UpdVar.QT.new[i,k] = GMV.QT.values[k] - sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0[k], - self.UpdVar.QT.new[i,k], self.UpdVar.H.new[i,k]) - self.UpdVar.QL.new[i,k] = sa.ql - self.UpdVar.T.new[i,k] = sa.T + if self.use_local_micro: + self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0[k], self.UpdVar.T.new[i,k], + &self.UpdVar.QT.new[i,k], &self.UpdVar.QL.new[i,k],&self.UpdVar.H.new[i,k], i, k) + + if self.use_local_micro: + self.UpdMicro.prec_source_h_tot = np.sum(np.multiply(self.UpdMicro.prec_source_h,self.UpdVar.Area.values), axis=0) + self.UpdMicro.prec_source_qt_tot = np.sum(np.multiply(self.UpdMicro.prec_source_qt,self.UpdVar.Area.values), axis=0) + else: self.UpdMicro.compute_sources(self.UpdVar) self.UpdMicro.update_updraftvars(self.UpdVar) @@ -1043,6 +936,70 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.QT.set_bcs(self.Gr) return + cpdef upwind_integration(self, EDMF_Updrafts.UpdraftVariable area, EDMF_Updrafts.UpdraftVariable var, int k, int i, double env_var): + + cdef: + double dzi = self.Gr.dzi + double dti_ = 1.0/self.dt_upd + double adv, buoy, exch, press, press_buoy, press_drag, area_new + double var_km, var_k, var_kp + + if var.name == 'area_fraction': + buoy = 0.0 + press = 0.0 + area_new = 1.0 + var_kp = 1.0 + var_k = 1.0 + var_km = 1.0 + + elif var.name == 'w': + buoy = self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] + press_buoy = -1.0 * self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] * self.pressure_buoy_coeff + press_drag = -1.0 * self.Ref.rho0[k]*(sqrt(self.UpdVar.Area.values[i,k] )*self.pressure_drag_coeff/self.pressure_plume_spacing + * (self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k])*fabs(self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k])) + press = press_buoy + press_drag + area_new = area.new[i,k] + var_kp = var.values[i,k+1] + var_k = var.values[i,k] + var_km = var.values[i,k-1] + + + elif var.name == 'thetal' or var.name == 'qt': + buoy = 0.0 + press = 0.0 + area_new = area.new[i,k] + var_kp = var.values[i,k+1] + var_k = var.values[i,k] + var_km = var.values[i,k-1] + + + if self.UpdVar.W.values[i,k]<0: + adv = (self.Ref.rho0[k+1] * area.values[i,k+1] * self.UpdVar.W.values[i,k+1] * var_kp + - self.Ref.rho0[k] *area.values[i,k] * self.UpdVar.W.values[i,k] * var_k )* dzi + exch = (self.Ref.rho0[k] * area.values[i,k] * self.UpdVar.W.values[i,k] + * (-self.entr_sc[i,k] * env_var + self.detr_sc[i,k] * var_k )) + else: + adv = (self.Ref.rho0[k] * area.values[i,k] * self.UpdVar.W.values[i,k] * var_k + - self.Ref.rho0[k-1] * area.values[i,k-1] * self.UpdVar.W.values[i,k-1] * var_km)* dzi + exch = (self.Ref.rho0[k] * area.values[i,k] * self.UpdVar.W.values[i,k] + * (self.entr_sc[i,k] * env_var - self.detr_sc[i,k] * var_k )) + + #print adv, exch, press, buoy, var1new, dti_ + #print var1.name, var2.name , k , i, env_var + + self.updraft_pressure_sink[i,k] = press + if area_new== 0.0: + print var.name, k + plt.figure() + plt.show() + var.new[i,k] = (self.Ref.rho0[k] * area.values[i,k] * var_k * dti_ -adv + exch + buoy + press)\ + /(self.Ref.rho0[k] * area_new * dti_) + print var.new[i,k], var_k , adv , exch ,buoy , press + + # plt.figure() + # plt.show() + + # After updating the updraft variables themselves: # 1. compute the mass fluxes (currently not stored as class members, probably will want to do this # for output purposes) From f5232abc926c762f9b886c70785545ecea085f2d Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Wed, 8 Aug 2018 14:12:16 -0700 Subject: [PATCH 039/136] cleanup --- Turbulence_PrognosticTKE.pyx | 42 +++++++++--------------------------- 1 file changed, 10 insertions(+), 32 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 2d1117b6..e039043d 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -900,9 +900,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): &self.UpdVar.H.values[i,gw], i, gw) for k in range(gw+1, self.Gr.nzg-gw): - #print '903', self.UpdVar.Area.values[i,gw], self.UpdVar.W.values[i,gw] self.upwind_integration(self.UpdVar.Area, self.UpdVar.Area, k, i, 1.0) - print self.UpdVar.Area.new[i,k] if self.UpdVar.Area.new[i,k] >= self.minimum_area: self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, k, i, self.EnvVar.W.values[k]) self.upwind_integration(self.UpdVar.Area, self.UpdVar.H, k, i, self.EnvVar.H.values[k]) @@ -937,42 +935,33 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): return cpdef upwind_integration(self, EDMF_Updrafts.UpdraftVariable area, EDMF_Updrafts.UpdraftVariable var, int k, int i, double env_var): - cdef: double dzi = self.Gr.dzi double dti_ = 1.0/self.dt_upd - double adv, buoy, exch, press, press_buoy, press_drag, area_new - double var_km, var_k, var_kp - - if var.name == 'area_fraction': - buoy = 0.0 - press = 0.0 - area_new = 1.0 - var_kp = 1.0 - var_k = 1.0 - var_km = 1.0 - - elif var.name == 'w': + double adv, exch, press_buoy, press_drag + double buoy = 0.0 + double press = 0.0 + double var_kp = 1.0 + double var_k = 1.0 + double var_km = 1.0 + double area_new = 1.0 + + if var.name == 'w': buoy = self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] press_buoy = -1.0 * self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] * self.pressure_buoy_coeff press_drag = -1.0 * self.Ref.rho0[k]*(sqrt(self.UpdVar.Area.values[i,k] )*self.pressure_drag_coeff/self.pressure_plume_spacing - * (self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k])*fabs(self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k])) + * (self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k])*fabs(self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k])) press = press_buoy + press_drag area_new = area.new[i,k] var_kp = var.values[i,k+1] var_k = var.values[i,k] var_km = var.values[i,k-1] - - elif var.name == 'thetal' or var.name == 'qt': - buoy = 0.0 - press = 0.0 area_new = area.new[i,k] var_kp = var.values[i,k+1] var_k = var.values[i,k] var_km = var.values[i,k-1] - if self.UpdVar.W.values[i,k]<0: adv = (self.Ref.rho0[k+1] * area.values[i,k+1] * self.UpdVar.W.values[i,k+1] * var_kp - self.Ref.rho0[k] *area.values[i,k] * self.UpdVar.W.values[i,k] * var_k )* dzi @@ -984,20 +973,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): exch = (self.Ref.rho0[k] * area.values[i,k] * self.UpdVar.W.values[i,k] * (self.entr_sc[i,k] * env_var - self.detr_sc[i,k] * var_k )) - #print adv, exch, press, buoy, var1new, dti_ - #print var1.name, var2.name , k , i, env_var - self.updraft_pressure_sink[i,k] = press - if area_new== 0.0: - print var.name, k - plt.figure() - plt.show() var.new[i,k] = (self.Ref.rho0[k] * area.values[i,k] * var_k * dti_ -adv + exch + buoy + press)\ /(self.Ref.rho0[k] * area_new * dti_) - print var.new[i,k], var_k , adv , exch ,buoy , press - - # plt.figure() - # plt.show() # After updating the updraft variables themselves: From 383e7389a3ab1689a99cf42d42b06b9b821de9b3 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Wed, 8 Aug 2018 15:05:47 -0700 Subject: [PATCH 040/136] :..: --- Turbulence_PrognosticTKE.pyx | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index e039043d..58bd6651 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -901,6 +901,15 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for k in range(gw+1, self.Gr.nzg-gw): self.upwind_integration(self.UpdVar.Area, self.UpdVar.Area, k, i, 1.0) + + if self.UpdVar.Area.new[i,k] > au_lim: + self.UpdVar.Area.new[i,k] = au_lim + if self.UpdVar.Area.values[i,k] > 0.0: + self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ - adv -entr_term)/(-self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k])) + else: + # this detrainment rate won't affect scalars but would affect velocity + self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ - adv -entr_term)/(-au_lim * self.UpdVar.W.values[i,k])) + if self.UpdVar.Area.new[i,k] >= self.minimum_area: self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, k, i, self.EnvVar.W.values[k]) self.upwind_integration(self.UpdVar.Area, self.UpdVar.H, k, i, self.EnvVar.H.values[k]) From aa8910974fc05053d9ae12d77055252570796316 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Thu, 9 Aug 2018 14:23:50 -0700 Subject: [PATCH 041/136] .. --- Turbulence_PrognosticTKE.pyx | 1 + 1 file changed, 1 insertion(+) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 58bd6651..ad4cd619 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -1631,6 +1631,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): x[kk] = (self.Ref.rho0[k] * ae_old[k] * self.EnvVar.HQTcov.values[k] * dti + self.HQTcov_shear[k] + self.HQTcov_entr_gain[k]) # + a[0] = 0.0 b[0] = 1.0 c[0] = 0.0 From efc3d7ca237d0e847984de2bdfd78f87612d9f32 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Thu, 9 Aug 2018 17:57:19 -0700 Subject: [PATCH 042/136] converting to unified functions --- EDMF_Environment.pxd | 15 ++ EDMF_Environment.pyx | 32 +++-- Turbulence_PrognosticTKE.pxd | 14 +- Turbulence_PrognosticTKE.pyx | 272 ++++++++++++++--------------------- turbulence_functions.pyx | 2 - 5 files changed, 151 insertions(+), 184 deletions(-) diff --git a/EDMF_Environment.pxd b/EDMF_Environment.pxd index 25479c66..2fa6ebb1 100644 --- a/EDMF_Environment.pxd +++ b/EDMF_Environment.pxd @@ -12,6 +12,21 @@ cdef class EnvironmentVariable: str name str units + +cdef class EnvironmentVariable: + cdef: + double [:] values + double [:] dissipation + double [:] shear + double [:] entr_gain + double [:] detr_loss + double [:] buoy_src + double [:] press + str loc + str kind + str name + str units + cdef class EnvironmentVariables: cdef: diff --git a/EDMF_Environment.pyx b/EDMF_Environment.pyx index 1ad92258..d1ddde7f 100644 --- a/EDMF_Environment.pyx +++ b/EDMF_Environment.pyx @@ -26,7 +26,23 @@ cdef class EnvironmentVariable: self.name = name self.units = units - +cdef class EnvironmentVariable_2m: + def __init__(self, nz, loc, kind, name, units): + self.values = np.zeros((nz,),dtype=np.double, order='c') + self.dissipation = np.zeros((nz,),dtype=np.double, order='c') + self.entr_gain = np.zeros((nz,),dtype=np.double, order='c') + self.detr_loss = np.zeros((nz,),dtype=np.double, order='c') + self.buoy_src = np.zeros((nz,),dtype=np.double, order='c') + self.press = np.zeros((nz,),dtype=np.double, order='c') + self.shear = np.zeros((nz,),dtype=np.double, order='c') # think of a more general name as "mean_grad_production" or something + if loc != 'full': + print('Invalid location setting for variable! Must be full') + self.loc = loc + if kind != 'scalar' and kind != 'velocity': + print ('Invalid kind setting for variable! Must be scalar or velocity') + self.kind = kind + self.name = name + self.units = units @@ -68,18 +84,18 @@ cdef class EnvironmentVariables: if self.use_tke: - self.TKE = EnvironmentVariable( nz, 'full', 'scalar', 'tke','m^2/s^2' ) + self.TKE = EnvironmentVariable_2m( nz, 'full', 'scalar', 'tke','m^2/s^2' ) if self.use_scalar_var: - self.QTvar = EnvironmentVariable( nz, 'full', 'scalar', 'qt_var','kg^2/kg^2' ) + self.QTvar = EnvironmentVariable_2m( nz, 'full', 'scalar', 'qt_var','kg^2/kg^2' ) if namelist['thermodynamics']['thermal_variable'] == 'entropy': - self.Hvar = EnvironmentVariable(nz, 'full', 'scalar', 's_var', '(J/kg/K)^2') - self.HQTcov = EnvironmentVariable(nz, 'full', 'scalar', 's_qt_covar', '(J/kg/K)(kg/kg)' ) + self.Hvar = EnvironmentVariable_2m(nz, 'full', 'scalar', 's_var', '(J/kg/K)^2') + self.HQTcov = EnvironmentVariable_2m(nz, 'full', 'scalar', 's_qt_covar', '(J/kg/K)(kg/kg)' ) elif namelist['thermodynamics']['thermal_variable'] == 'thetal': - self.Hvar = EnvironmentVariable(nz, 'full', 'scalar', 'thetal_var', 'K^2') - self.HQTcov = EnvironmentVariable(nz, 'full', 'scalar', 'thetal_qt_covar', 'K(kg/kg)' ) + self.Hvar = EnvironmentVariable_2m(nz, 'full', 'scalar', 'thetal_var', 'K^2') + self.HQTcov = EnvironmentVariable_2m(nz, 'full', 'scalar', 'thetal_qt_covar', 'K(kg/kg)' ) if self.EnvThermo_scheme == 'sommeria_deardorff': - self.THVvar = EnvironmentVariable(nz, 'full', 'scalar', 'thetav_var', 'K^2' ) + self.THVvar = EnvironmentVariable_2m(nz, 'full', 'scalar', 'thetav_var', 'K^2' ) # return diff --git a/Turbulence_PrognosticTKE.pxd b/Turbulence_PrognosticTKE.pxd index 8da83ba1..ff2eaedb 100644 --- a/Turbulence_PrognosticTKE.pxd +++ b/Turbulence_PrognosticTKE.pxd @@ -102,18 +102,14 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cpdef update_GMV_ED(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS) cpdef compute_tke(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS) cpdef compute_covariance(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS) - cpdef initialize_tke(self, GridMeanVariables GMV, CasesBase Case) cpdef initialize_covariance(self, GridMeanVariables GMV, CasesBase Case) cpdef compute_tke_buoy(self, GridMeanVariables GMV) - cpdef compute_tke_dissipation(self) - cpdef compute_covariance_dissipation(self) - cpdef compute_tke_entr(self) - cpdef compute_covariance_entr(self) - cpdef compute_tke_detr(self) - cpdef compute_covariance_detr(self) - cpdef compute_tke_shear(self, GridMeanVariables GMV) - cpdef compute_covariance_shear(self, GridMeanVariables GMV) cpdef compute_tke_pressure(self) + cdef void compute_covariance_detr(self, double *detr_loss, double *Var) + cdef void compute_covariance_entr(self, double *entr_gain, double *Var, double *UpdVar1, double *UpdVar2, double *EnvVar1, double *EnvVar2) + cdef void compute_covariance_entr(self, double *covar_entr_gain, double *Var, double *UpdVar1, double *UpdVar2, double *EnvVar1, double *EnvVar2) + cdef void compute_covariance_dissipation(self, double *var) + cdef void compute_covariance_shear(self,GridMeanVariables GMV, double *shear, double *Var, double *UpdVar1, double *UpdVar2, double *EnvVar1, double *EnvVar2) cpdef update_tke_ED(self, GridMeanVariables GMV, CasesBase Case,TimeStepping TS) cpdef update_covariance_ED(self, GridMeanVariables GMV, CasesBase Case,TimeStepping TS) cpdef update_GMV_diagnostics(self, GridMeanVariables GMV) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 2d1117b6..8f605366 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -140,12 +140,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): #self.Hvar = np.zeros((Gr.nzg,),dtype=np.double, order='c') #self.QTvar = np.zeros((Gr.nzg,),dtype=np.double, order='c') #self.HQTcov = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.Hvar_dissipation = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.QTvar_dissipation = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.HQTcov_dissipation = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.Hvar_entr_gain = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.QTvar_entr_gain = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.HQTcov_entr_gain = np.zeros((Gr.nzg,),dtype=np.double, order='c') + self.covariance_dissipation = np.zeros((Gr.nzg,),dtype=np.double, order='c') + self.covar_entr_gain = np.zeros((Gr.nzg,),dtype=np.double, order='c') self.Hvar_detr_loss = np.zeros((Gr.nzg,),dtype=np.double, order='c') self.QTvar_detr_loss = np.zeros((Gr.nzg,),dtype=np.double, order='c') self.HQTcov_detr_loss = np.zeros((Gr.nzg,),dtype=np.double, order='c') @@ -220,10 +216,10 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Stats.add_profile('HQTcov_dissipation') Stats.add_profile('Hvar_entr_gain') Stats.add_profile('QTvar_entr_gain') - Stats.add_profile('HQTcov_entr_gain') Stats.add_profile('Hvar_detr_loss') Stats.add_profile('QTvar_detr_loss') Stats.add_profile('HQTcov_detr_loss') + Stats.add_profile('HQTcov_entr_gain') Stats.add_profile('Hvar_shear') Stats.add_profile('QTvar_shear') Stats.add_profile('HQTcov_shear') @@ -286,10 +282,15 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): #Stats.write_profile('Hvar', self.Hvar[kmin:kmax]) #Stats.write_profile('QTvar', self.QTvar[kmin:kmax]) #Stats.write_profile('HQTcov', self.HQTcov[kmin:kmax]) - self.compute_covariance_dissipation() - Stats.write_profile('Hvar_dissipation', self.Hvar_dissipation[kmin:kmax]) - Stats.write_profile('QTvar_dissipation', self.QTvar_dissipation[kmin:kmax]) - Stats.write_profile('HQTcov_dissipation', self.HQTcov_dissipation[kmin:kmax]) + + # can these pointer function called inside the write command , or should they be called before it? + self.compute_covariance_dissipation(self, &self.covariance_dissipation, &self.EnvVar.Hvar) + Stats.write_profile('Hvar_dissipation', self.EnvVar.Hvar.dissipation) + self.compute_covariance_dissipation(self, &self.covariance_dissipation, &self.EnvVar.QTvar) + Stats.write_profile('Hvar_dissipation', self.EnvVar.QTvar.dissipation) + self.compute_covariance_dissipation(self, &self.covariance_dissipation, &self.EnvVar.HQTcov) + Stats.write_profile('Hvar_dissipation', self.EnvVar.HQTcov.dissipation) + Stats.write_profile('Hvar_entr_gain', self.Hvar_entr_gain[kmin:kmax]) Stats.write_profile('QTvar_entr_gain', self.QTvar_entr_gain[kmin:kmax]) Stats.write_profile('HQTcov_entr_gain', self.HQTcov_entr_gain[kmin:kmax]) @@ -317,7 +318,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.update_inversion(GMV, Case.inversion_option) self.wstar = get_wstar(Case.Sur.bflux, self.zi) if TS.nstep == 0: - self.initialize_tke(GMV, Case) self.initialize_covariance(GMV, Case) with nogil: for k in xrange(self.Gr.nzg): @@ -507,23 +507,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): return - cpdef initialize_tke(self, GridMeanVariables GMV, CasesBase Case): - cdef: - Py_ssize_t k - double ws= self.wstar, us = Case.Sur.ustar, zs = self.zi, z - # Similarity profile initialization of TKE - # Need to consider what to do when neutral/stable - if ws > 0.0: - with nogil: - for k in xrange(self.Gr.nzg): - z = self.Gr.z[k] - GMV.TKE.values[k] = ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) - - - self.reset_surface_tke(GMV, Case) - self.compute_mixing_length(Case.Sur.obukhov_length, GMV) - return - cpdef update_inversion(self,GridMeanVariables GMV, option): ParameterizationBase.update_inversion(self, GMV,option) return @@ -627,30 +610,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): return - cpdef reset_surface_tke(self, GridMeanVariables GMV, CasesBase Case): - GMV.TKE.values[self.Gr.gw] = get_surface_tke(Case.Sur.ustar, - self.wstar, - self.Gr.z[self.Gr.gw], - Case.Sur.obukhov_length) - return - - - cpdef reset_surface_covariance(self, GridMeanVariables GMV, CasesBase Case): - flux1 = Case.Sur.rho_hflux - flux2 = Case.Sur.rho_qtflux - cdef: - double zLL = self.Gr.z[self.Gr.gw] - double ustar = Case.Sur.ustar, oblength = Case.Sur.obukhov_length - double alpha0LL = self.Ref.alpha0[self.Gr.gw] - #double get_surface_variance = get_surface_variance(flux1, flux2 ,ustar, zLL, oblength) - - GMV.Hvar.values[self.Gr.gw] = get_surface_variance(flux1*alpha0LL,flux1*alpha0LL, ustar, zLL, oblength) - GMV.QTvar.values[self.Gr.gw] = get_surface_variance(flux2*alpha0LL,flux2*alpha0LL, ustar, zLL, oblength) - GMV.HQTcov.values[self.Gr.gw] = get_surface_variance(flux1 * alpha0LL,flux2 * alpha0LL, ustar, zLL, oblength) - - - return - # Find values of environmental variables by subtracting updraft values from grid mean values # whichvals used to check which substep we are on--correspondingly use 'GMV.SomeVar.value' (last timestep value) @@ -1233,57 +1192,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # and updrafts' (total) detrainment rate = environment's (total) entrainment rate # Therefore, fractional xxtrainment rates must be properly multiplied by the right component mass fluxes # Here we use the terminology entrainment/detrainment relative to the __environment__ - cpdef compute_tke_entr(self): - cdef: - Py_ssize_t i, k - double w_u, w_e - with nogil: - for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - self.tke_entr_gain[k] = 0.0 - w_e = self.EnvVar.W.values[k] - for i in xrange(self.n_updrafts): - w_u = self.UpdVar.W.values[i,k] - self.tke_entr_gain[k] += self.UpdVar.Area.values[i,k] * w_u * self.detr_sc[i,k] * (w_u - w_e) * (w_u - w_e) - self.tke_entr_gain[k] *= 0.5 * self.Ref.rho0[k] - return - cpdef compute_tke_detr(self): - cdef: - Py_ssize_t i, k - double w_u - - with nogil: - for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - self.tke_detr_loss[k] = 0.0 - for i in xrange(self.n_updrafts): - w_u = self.UpdVar.W.values[i,k] - self.tke_detr_loss[k] += self.UpdVar.Area.values[i,k] * w_u * self.entr_sc[i,k] - self.tke_detr_loss[k] *= self.Ref.rho0[k] * self.EnvVar.TKE.values[k] - return - - cpdef compute_tke_shear(self, GridMeanVariables GMV): - cdef: - Py_ssize_t k - Py_ssize_t gw = self.Gr.gw - double [:] ae = np.subtract(np.ones((self.Gr.nzg,),dtype=np.double, order='c'),self.UpdVar.Area.bulkvalues) # area of environment - double du_high = 0.0 - double dv_high = 0.0 - double dw_high = 2.0 * self.EnvVar.W.values[gw] * self.Gr.dzi - double du_low, dv_low, dw_low, - - with nogil: - for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - du_low = du_high - dv_low = dv_high - dw_low = dw_high - du_high = (GMV.U.values[k+1] - GMV.U.values[k-1]) * self.Gr.dzi - dv_high = (GMV.V.values[k+1] - GMV.V.values[k-1]) * self.Gr.dzi - dw_high = (self.EnvVar.W.values[k+1] - self.EnvVar.W.values[k]) * self.Gr.dzi - self.tke_shear[k] =( self.Ref.rho0[k] * ae[k] * self.KM.values[k] * - ( pow(du_high,2.0) + pow(dv_high,2.0)+ pow(dw_high,2.0))) - return cpdef compute_tke_pressure(self): cdef: @@ -1320,8 +1231,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double [:] ae = np.subtract(np.ones((nzg,),dtype=np.double, order='c'),self.UpdVar.Area.bulkvalues) # area of environment double [:] ae_old = np.subtract(np.ones((nzg,),dtype=np.double, order='c'), np.sum(self.UpdVar.Area.old,axis=0)) double [:] rho_ae_K_m = np.zeros((nzg,),dtype=np.double, order='c') - double D_env = 0.0 - double wu, we, tke_0_surf,press_k + @@ -1403,8 +1313,18 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): if self.similarity_diffusivity: # otherwise, we computed mixing length when we computed self.compute_mixing_length(Case.Sur.obukhov_length, GMV) - self.compute_covariance_entr() - self.compute_covariance_shear(GMV) + self.compute_covariance_entr(self, &self.EnvVar.Hvar.entr_gain, &self.EnvVar.Hvar, &self.UpdVar.H, &self.UpdVar.H, &self.EnvVar.H, &self.EnvVar.H) + self.compute_covariance_entr(self, &self.EnvVar.QTvar.entr_gain, &self.EnvVar.QTvar, &self.UpdVar.QT, &self.UpdVar.QT, &self.EnvVar.QT, &self.EnvVar.QT) + self.compute_covariance_entr(self, &self.EnvVar.HQTcov.entr_gain, &self.EnvVar.HQTcov, &self.UpdVar.H, &self.UpdVar.QT, &self.EnvVar.H, &self.EnvVar.QT) + self.compute_covariance_entr(self, &self.EnvVar.TKE.entr_gain, &self.EnvVar.TKE, &self.UpdVar.W, &self.UpdVar.W, &self.EnvVar.W, &self.EnvVar.W) + + self.compute_covariance_shear(self,GMV, &self.EnvVar.Hvar.shear, &self.EnvVar.Hvar, &self.UpdVar.H, &self.UpdVar.H, &self.EnvVar.H, &self.EnvVar.H) + self.compute_covariance_shear(self,GMV, &self.EnvVar.QTvar.shear, &self.EnvVar.QTvar, &self.UpdVar.QT, &self.UpdVar.QT, &self.EnvVar.QT, &self.EnvVar.QT) + self.compute_covariance_shear(self,GMV, &self.EnvVar.HQTcov.shear, &self.EnvVar.HQTcov, &self.UpdVar.H, &self.UpdVar.QT, &self.EnvVar.H, &self.EnvVar.QT) + self.compute_covariance_shear(self,GMV, &self.EnvVar.TKE.shear, &self.EnvVar.TKE, &self.UpdVar.W, &self.UpdVar.W, &self.EnvVar.W, &self.EnvVar.W) + self.compute_tke_buoy(GMV) + self.compute_tke_pressure() + self.reset_surface_covariance(GMV, Case) self.update_covariance_ED(GMV, Case, TS) else: @@ -1417,9 +1337,15 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cdef: Py_ssize_t k + double ws= self.wstar, us = Case.Sur.ustar, zs = self.zi, z double ws= self.wstar, us = Case.Sur.ustar, zs = self.zi, z self.reset_surface_covariance(GMV, Case) + if ws > 0.0: + with nogil: + for k in xrange(self.Gr.nzg): + z = self.Gr.z[k] + GMV.TKE.values[k] = ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) with nogil: for k in xrange(self.Gr.nzg): @@ -1429,75 +1355,104 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): GMV.QTvar.values[k] = GMV.QTvar.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) GMV.HQTcov.values[k] = GMV.HQTcov.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) + self.reset_surface_tke(GMV, Case) + self.reset_surface_covariance(self, GMV, Case) # double check this should be here - it was not in the orignal covariance branch self.compute_mixing_length(Case.Sur.obukhov_length, GMV) return + cpdef reset_surface_tke(self, GridMeanVariables GMV, CasesBase Case): + GMV.TKE.values[self.Gr.gw] = get_surface_tke(Case.Sur.ustar, + self.wstar, + self.Gr.z[self.Gr.gw], + Case.Sur.obukhov_length) + return + + + cpdef reset_surface_covariance(self, GridMeanVariables GMV, CasesBase Case): + flux1 = Case.Sur.rho_hflux + flux2 = Case.Sur.rho_qtflux + cdef: + double zLL = self.Gr.z[self.Gr.gw] + double ustar = Case.Sur.ustar, oblength = Case.Sur.obukhov_length + double alpha0LL = self.Ref.alpha0[self.Gr.gw] + #double get_surface_variance = get_surface_variance(flux1, flux2 ,ustar, zLL, oblength) + + GMV.Hvar.values[self.Gr.gw] = get_surface_variance(flux1*alpha0LL,flux1*alpha0LL, ustar, zLL, oblength) + GMV.QTvar.values[self.Gr.gw] = get_surface_variance(flux2*alpha0LL,flux2*alpha0LL, ustar, zLL, oblength) + GMV.HQTcov.values[self.Gr.gw] = get_surface_variance(flux1 * alpha0LL,flux2 * alpha0LL, ustar, zLL, oblength) + + + return + + cdef void compute_covariance_shear(self,GridMeanVariables GMV, double *shear, double *Var, double *UpdVar1, double *UpdVar2, double *EnvVar1, double *EnvVar2): + cdef: + Py_ssize_t k + double var1_high = 0.0 + double var2_high = 0.0 + double du_high = 0.0 + double dv_high = 0.0 + double var1_low, var2_low + double tke_factor = 1.0 + with nogil: + for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): + var1_low = var1_high + var2_low = var2_high + du_low = du_high + dv_low = dv_high + if Var.name == 'TKE': + du_high = (GMV.U.values[k+1] - GMV.U.values[k-1]) * self.Gr.dzi + dv_high = (GMV.V.values[k+1] - GMV.V.values[k-1]) * self.Gr.dzi + tke_factor = 0.5 + var1_high = (EnvVar1.values[k+1] - EnvVar1.values[k-1]) * self.Gr.dzi + var2_high = (EnvVar2.values[k+1] - EnvVar2.values[k-1]) * self.Gr.dzi + Var.shear[k] = tke_factor*2.0*(self.Ref.rho0[k] * (1.0-self.UpdVar.Area.bulkvalues) * self.KH.values[k] * + (var1_high*var2_high + pow(du_high,2.0) + pow(dv_high,2.0))) + return - cpdef compute_covariance_shear(self, GridMeanVariables GMV): + cdef void compute_covariance_dissipation(self, double *covariance_dissipation, double *Var): cdef: + Py_ssize_t i + double m Py_ssize_t k - Py_ssize_t gw = self.Gr.gw - double [:] ae = np.subtract(np.ones((self.Gr.nzg,),dtype=np.double, order='c'),self.UpdVar.Area.bulkvalues) # area of environment - double dH_high = 0.0 - double dQT_high = 0.0 - double dH_low, dQT_low with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - dH_low = dH_high - dH_high = (self.EnvVar.H.values[k+1] - self.EnvVar.H.values[k-1]) * self.Gr.dzi - dQT_low = dQT_high - dQT_high = (self.EnvVar.QT.values[k+1] - self.EnvVar.QT.values[k-1]) * self.Gr.dzi - self.Hvar_shear[k] = 2.0*(self.Ref.rho0[k] * ae[k] * self.KH.values[k] *pow(dH_high,2.0)) - self.QTvar_shear[k] = 2.0*(self.Ref.rho0[k] * ae[k] * self.KH.values[k] *pow(dQT_high,2.0)) - self.HQTcov_shear[k] = 2.0*(self.Ref.rho0[k] * ae[k] * self.KH.values[k] *dH_high*dQT_high) + Var.covariance_dissipation[k] = (self.Ref.rho0[k] * (1.0-self.UpdVar.Area.bulkvalues[k]) * Var.values[k] + *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0) * self.tke_diss_coeff) + return - cpdef compute_covariance_entr(self): + + + cdef void compute_covariance_entr(self, double *entr_gain, double *Var, double *UpdVar1, double *UpdVar2, double *EnvVar1, double *EnvVar2): cdef: Py_ssize_t i, k - double H_u, H_env, QT_u, QT_env, w_u with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - self.Hvar_entr_gain[k] = 0.0 - self.QTvar_entr_gain[k] = 0.0 - self.HQTcov_entr_gain[k] = 0.0 - H_env = self.EnvVar.H.values[k] - QT_env = self.EnvVar.QT.values[k] + Var.Hvar.entr_gain[k] = 0.0 for i in xrange(self.n_updrafts): - H_u = self.UpdVar.H.values[i,k] - QT_u = self.UpdVar.QT.values[i,k] - w_u = self.UpdVar.W.values[i,k] - self.Hvar_entr_gain[k] += self.UpdVar.Area.values[i,k] * w_u * self.detr_sc[i,k] * (H_u - H_env) * (H_u - H_env) - self.QTvar_entr_gain[k] += self.UpdVar.Area.values[i,k] * w_u * self.detr_sc[i,k] * (QT_u - QT_env) * (QT_u - QT_env) - self.HQTcov_entr_gain[k] += self.UpdVar.Area.values[i,k] * w_u * self.detr_sc[i,k] * (H_u - H_env) * (QT_u - QT_env) - self.Hvar_entr_gain[k] *= self.Ref.rho0[k] - self.QTvar_entr_gain[k] *= self.Ref.rho0[k] - self.HQTcov_entr_gain[k] *= self.Ref.rho0[k] + Var.Hvar.entr_gain[k] += self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.detr_sc[i,k] * \ + (UpdVar1.values[i,k] - EnvVar1.values[i,k]) * (UpdVar2.values[i,k] - EnvVar2.values[i,k]) + Var.Hvar.entr_gain[k] *= self.Ref.rho0[k] return - cpdef compute_covariance_detr(self): + #cpdef compute_covariance_detr(self, EDMF_Environment.EnvironmentVariable, var): + cdef void compute_covariance_detr(self, double *detr_loss, double *Var): cdef: Py_ssize_t i, k - double Thetal_u, QT_u, w_u with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - self.Hvar_detr_loss[k] = 0.0 - self.QTvar_detr_loss[k] = 0.0 + Var.detr_loss[k] = 0.0 for i in xrange(self.n_updrafts): - w_u = self.UpdVar.W.values[i,k] - self.Hvar_detr_loss[k] += self.UpdVar.Area.values[i,k] * w_u * self.entr_sc[i,k] - self.QTvar_detr_loss[k] += self.UpdVar.Area.values[i,k] * w_u * self.entr_sc[i,k] - self.HQTcov_detr_loss[k] += self.UpdVar.Area.values[i,k] * w_u * self.entr_sc[i,k] - self.Hvar_detr_loss[k] *= self.Ref.rho0[k] * self.EnvVar.Hvar.values[k] - self.QTvar_detr_loss[k] *= self.Ref.rho0[k] * self.EnvVar.QTvar.values[k] - self.HQTcov_detr_loss[k] *= self.Ref.rho0[k] * self.EnvVar.HQTcov.values[k] - return + Var.detr_loss[k] += self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.entr_sc[i,k] + Var.detr_loss[k] *= self.Ref.rho0[k] * Var.values[k] - cpdef update_covariance_ED(self, GridMeanVariables GMV, CasesBase Case,TimeStepping TS): + return +# verfy that everythong from tke is here and unify and cvert to pointers with cdef void + cdef void update_covariance_ED(self, GridMeanVariables GMV, CasesBase Case,TimeStepping TS, double *Var): cdef: Py_ssize_t k, kk, i Py_ssize_t gw = self.Gr.gw @@ -1514,8 +1469,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double [:] ae = np.subtract(np.ones((nzg,),dtype=np.double, order='c'),self.UpdVar.Area.bulkvalues) # area of environment double [:] ae_old = np.subtract(np.ones((nzg,),dtype=np.double, order='c'), np.sum(self.UpdVar.Area.old,axis=0)) double [:] rho_ae_K_m = np.zeros((nzg,),dtype=np.double, order='c') - double D_env = 0.0 + double wu, we, tke_0_surf,press_k + # missing flux1 and 2 in get_surface_variance double Hvar_gmv_surf = get_surface_variance(Case.Sur.rho_hflux * alpha0LL, Case.Sur.rho_hflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) double QTvar_gmv_surf = get_surface_variance(Case.Sur.rho_qtflux * alpha0LL, Case.Sur.rho_qtflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) @@ -1642,7 +1598,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0) ) c[kk] = (self.Ref.rho0[k+1] * ae[k+1] * self.EnvVar.W.values[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) x[kk] = (self.Ref.rho0[k] * ae_old[k] * self.EnvVar.HQTcov.values[k] * dti - + self.HQTcov_shear[k] + self.HQTcov_entr_gain[k]) # + + self.HQTcov_shear[k] + self.EnvVar.HQTcov.entr_gain[k]) # a[0] = 0.0 b[0] = 1.0 @@ -1665,20 +1621,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): return - cpdef compute_covariance_dissipation(self): - cdef: - Py_ssize_t k - double [:] ae = np.subtract(np.ones((self.Gr.nzg,),dtype=np.double, order='c'),self.UpdVar.Area.bulkvalues) - - with nogil: - for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - self.Hvar_dissipation[k] = (self.Ref.rho0[k] * ae[k] * self.EnvVar.Hvar.values[k] - *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0) * self.tke_diss_coeff) - self.QTvar_dissipation[k] = (self.Ref.rho0[k] * ae[k] * self.EnvVar.QTvar.values[k] - *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0) * self.tke_diss_coeff) - self.HQTcov_dissipation[k] = (self.Ref.rho0[k] * ae[k] * self.EnvVar.HQTcov.values[k] - *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0) * self.tke_diss_coeff) - - return - +# compute_covariance_dissipation(self, &self.covariance_dissipation, &self.variable you eed ) +# to use the grid mean variable : VariablePrognostic var, \ No newline at end of file diff --git a/turbulence_functions.pyx b/turbulence_functions.pyx index 3b5f8f98..891c6550 100644 --- a/turbulence_functions.pyx +++ b/turbulence_functions.pyx @@ -352,8 +352,6 @@ cdef void tridiag_solve(Py_ssize_t nz, double *x, double *a, double *b, double * - - # Dustbin cdef bint set_cloudbase_flag(double ql, bint current_flag) nogil: From 5209881b64cb9445eeb6b5e329dfabed25414316 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Fri, 10 Aug 2018 17:31:32 -0700 Subject: [PATCH 043/136] compiling --- EDMF_Environment.pxd | 3 +- Turbulence_PrognosticTKE.pxd | 27 +- Turbulence_PrognosticTKE.pyx | 599 +++++++++++------------------------ 3 files changed, 205 insertions(+), 424 deletions(-) diff --git a/EDMF_Environment.pxd b/EDMF_Environment.pxd index 2fa6ebb1..55d49ba3 100644 --- a/EDMF_Environment.pxd +++ b/EDMF_Environment.pxd @@ -13,7 +13,7 @@ cdef class EnvironmentVariable: str units -cdef class EnvironmentVariable: +cdef class EnvironmentVariable_m2: cdef: double [:] values double [:] dissipation @@ -22,6 +22,7 @@ cdef class EnvironmentVariable: double [:] detr_loss double [:] buoy_src double [:] press + double [:] buoy str loc str kind str name diff --git a/Turbulence_PrognosticTKE.pxd b/Turbulence_PrognosticTKE.pxd index ff2eaedb..d34de428 100644 --- a/Turbulence_PrognosticTKE.pxd +++ b/Turbulence_PrognosticTKE.pxd @@ -100,32 +100,27 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): EDMF_Updrafts.UpdraftVariable var, int k, int i, double env_var) cpdef update_GMV_MF(self, GridMeanVariables GMV, TimeStepping TS) cpdef update_GMV_ED(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS) - cpdef compute_tke(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS) cpdef compute_covariance(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS) cpdef initialize_covariance(self, GridMeanVariables GMV, CasesBase Case) cpdef compute_tke_buoy(self, GridMeanVariables GMV) cpdef compute_tke_pressure(self) - cdef void compute_covariance_detr(self, double *detr_loss, double *Var) - cdef void compute_covariance_entr(self, double *entr_gain, double *Var, double *UpdVar1, double *UpdVar2, double *EnvVar1, double *EnvVar2) - cdef void compute_covariance_entr(self, double *covar_entr_gain, double *Var, double *UpdVar1, double *UpdVar2, double *EnvVar1, double *EnvVar2) - cdef void compute_covariance_dissipation(self, double *var) - cdef void compute_covariance_shear(self,GridMeanVariables GMV, double *shear, double *Var, double *UpdVar1, double *UpdVar2, double *EnvVar1, double *EnvVar2) - cpdef update_tke_ED(self, GridMeanVariables GMV, CasesBase Case,TimeStepping TS) - cpdef update_covariance_ED(self, GridMeanVariables GMV, CasesBase Case,TimeStepping TS) + cdef void compute_covariance_detr(self, EDMF_Environment.EnvironmentVariable_m2 Covar) + cdef void compute_covariance_entr(self, EDMF_Environment.EnvironmentVariable_m2 Covar, EDMF_Updrafts.UpdraftVariable UpdVar1, + EDMF_Updrafts.UpdraftVariable UpdVar2, EDMF_Environment.EnvironmentVariable EnvVar1, EDMF_Environment.EnvironmentVariable_m2 EnvVar2) + cdef void compute_covariance_dissipation(self, EDMF_Environment.EnvironmentVariable_m2 Covar) + cdef void compute_covariance_shear(self,GridMeanVariables GMV, EDMF_Environment.EnvironmentVariable_m2 Covar, double *UpdVar1, double *UpdVar2, double *EnvVar1, double *EnvVar2) + cdef void update_covariance_ED(self, GridMeanVariables GMV, CasesBase Case,TimeStepping TS, VariablePrognostic GmvVar1, VariablePrognostic GmvVar2, + VariablePrognostic GmvCovar, EDMF_Environment.EnvironmentVariable_m2 Covar, EDMF_Environment.EnvironmentVariable EnvVar1, EDMF_Environment.EnvironmentVariable EnvVar2, + EDMF_Updrafts.UpdraftVariable UpdVar1, EDMF_Updrafts.UpdraftVariable UpdVar2) cpdef update_GMV_diagnostics(self, GridMeanVariables GMV) - cdef get_GMV_TKE(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable wu, - EDMF_Environment.EnvironmentVariable we, EDMF_Environment.EnvironmentVariable tke_e, - double *gmv_w, double *gmv_tke) - cdef get_env_tke_from_GMV(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable wu, - EDMF_Environment.EnvironmentVariable we, EDMF_Environment.EnvironmentVariable tke_e, - double *gmv_w, double *gmv_tke) - + # cdef get_env_tke_from_GMV(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable wu, + # EDMF_Environment.EnvironmentVariable we, EDMF_Environment.EnvironmentVariable tke_e, + # double *gmv_w, double *gmv_tke) cdef get_GMV_CoVar(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable phi_u, EDMF_Updrafts.UpdraftVariable psi_u, EDMF_Environment.EnvironmentVariable phi_e, EDMF_Environment.EnvironmentVariable psi_e, EDMF_Environment.EnvironmentVariable covar_e, double *gmv_phi, double *gmv_psi, double *gmv_covar) - cdef get_env_covar_from_GMV(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable phi_u, EDMF_Updrafts.UpdraftVariable psi_u, EDMF_Environment.EnvironmentVariable phi_e, EDMF_Environment.EnvironmentVariable psi_e, diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 8f605366..db106732 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -140,14 +140,14 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): #self.Hvar = np.zeros((Gr.nzg,),dtype=np.double, order='c') #self.QTvar = np.zeros((Gr.nzg,),dtype=np.double, order='c') #self.HQTcov = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.covariance_dissipation = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.covar_entr_gain = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.Hvar_detr_loss = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.QTvar_detr_loss = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.HQTcov_detr_loss = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.Hvar_shear = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.QTvar_shear = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.HQTcov_shear = np.zeros((Gr.nzg,),dtype=np.double, order='c') + #self.covariance_dissipation = np.zeros((Gr.nzg,),dtype=np.double, order='c') + #self.covar_entr_gain = np.zeros((Gr.nzg,),dtype=np.double, order='c') + #self.Hvar_detr_loss = np.zeros((Gr.nzg,),dtype=np.double, order='c') + #self.QTvar_detr_loss = np.zeros((Gr.nzg,),dtype=np.double, order='c') + #self.HQTcov_detr_loss = np.zeros((Gr.nzg,),dtype=np.double, order='c') + #self.Hvar_shear = np.zeros((Gr.nzg,),dtype=np.double, order='c') + #self.QTvar_shear = np.zeros((Gr.nzg,),dtype=np.double, order='c') + #self.HQTcov_shear = np.zeros((Gr.nzg,),dtype=np.double, order='c') # Near-surface BC of updraft area fraction self.area_surface_bc= np.zeros((self.n_updrafts,),dtype=np.double, order='c') @@ -200,29 +200,29 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Stats.add_profile('total_flux_qt') Stats.add_profile('massflux_tke') Stats.add_profile('mixing_length') - Stats.add_profile('tke_buoy') - Stats.add_profile('tke_dissipation') - Stats.add_profile('tke_entr_gain') - Stats.add_profile('tke_detr_loss') - Stats.add_profile('tke_shear') - Stats.add_profile('tke_pressure') + # Stats.add_profile('tke_buoy') + # Stats.add_profile('tke_dissipation') + # Stats.add_profile('tke_entr_gain') + # Stats.add_profile('tke_detr_loss') + # Stats.add_profile('tke_shear') + # Stats.add_profile('tke_pressure') Stats.add_profile('updraft_qt_precip') Stats.add_profile('updraft_thetal_precip') #Stats.add_profile('Hvar') #Stats.add_profile('QTvar') #Stats.add_profile('HQTcov') - Stats.add_profile('Hvar_dissipation') - Stats.add_profile('QTvar_dissipation') - Stats.add_profile('HQTcov_dissipation') - Stats.add_profile('Hvar_entr_gain') - Stats.add_profile('QTvar_entr_gain') - Stats.add_profile('Hvar_detr_loss') - Stats.add_profile('QTvar_detr_loss') - Stats.add_profile('HQTcov_detr_loss') - Stats.add_profile('HQTcov_entr_gain') - Stats.add_profile('Hvar_shear') - Stats.add_profile('QTvar_shear') - Stats.add_profile('HQTcov_shear') + # Stats.add_profile('Hvar_dissipation') + # Stats.add_profile('QTvar_dissipation') + # Stats.add_profile('HQTcov_dissipation') + # Stats.add_profile('Hvar_entr_gain') + # Stats.add_profile('QTvar_entr_gain') + # Stats.add_profile('Hvar_detr_loss') + # Stats.add_profile('QTvar_detr_loss') + # Stats.add_profile('HQTcov_detr_loss') + # Stats.add_profile('HQTcov_entr_gain') + # Stats.add_profile('Hvar_shear') + # Stats.add_profile('QTvar_shear') + # Stats.add_profile('HQTcov_shear') return @@ -269,14 +269,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.diffusive_flux_qt[self.Gr.gw:self.Gr.nzg-self.Gr.gw])) Stats.write_profile('massflux_tke', self.massflux_tke[kmin-1:kmax-1]) Stats.write_profile('mixing_length', self.mixing_length[kmin:kmax]) - Stats.write_profile('tke_buoy', self.tke_buoy[kmin:kmax]) - self.compute_tke_dissipation() - Stats.write_profile('tke_dissipation', self.tke_dissipation[kmin:kmax]) - Stats.write_profile('tke_entr_gain', self.tke_entr_gain[kmin:kmax]) - self.compute_tke_detr() - Stats.write_profile('tke_detr_loss', self.tke_detr_loss[kmin:kmax]) - Stats.write_profile('tke_shear', self.tke_shear[kmin:kmax]) - Stats.write_profile('tke_pressure', self.tke_pressure[kmin:kmax]) Stats.write_profile('updraft_qt_precip', self.UpdMicro.prec_source_qt_tot[kmin:kmax]) Stats.write_profile('updraft_thetal_precip', self.UpdMicro.prec_source_h_tot[kmin:kmax]) #Stats.write_profile('Hvar', self.Hvar[kmin:kmax]) @@ -284,23 +276,34 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): #Stats.write_profile('HQTcov', self.HQTcov[kmin:kmax]) # can these pointer function called inside the write command , or should they be called before it? - self.compute_covariance_dissipation(self, &self.covariance_dissipation, &self.EnvVar.Hvar) + self.compute_covariance_dissipation(self.EnvVar.TKE) + Stats.write_profile('TKE_dissipation', self.EnvVar.TKE.dissipation) + self.compute_covariance_dissipation(self.EnvVar.Hvar) Stats.write_profile('Hvar_dissipation', self.EnvVar.Hvar.dissipation) - self.compute_covariance_dissipation(self, &self.covariance_dissipation, &self.EnvVar.QTvar) + self.compute_covariance_dissipation(self.EnvVar.QTvar) Stats.write_profile('Hvar_dissipation', self.EnvVar.QTvar.dissipation) - self.compute_covariance_dissipation(self, &self.covariance_dissipation, &self.EnvVar.HQTcov) + self.compute_covariance_dissipation(self.EnvVar.HQTcov) Stats.write_profile('Hvar_dissipation', self.EnvVar.HQTcov.dissipation) - Stats.write_profile('Hvar_entr_gain', self.Hvar_entr_gain[kmin:kmax]) - Stats.write_profile('QTvar_entr_gain', self.QTvar_entr_gain[kmin:kmax]) - Stats.write_profile('HQTcov_entr_gain', self.HQTcov_entr_gain[kmin:kmax]) - self.compute_covariance_detr() - Stats.write_profile('Hvar_detr_loss', self.Hvar_detr_loss[kmin:kmax]) - Stats.write_profile('QTvar_detr_loss', self.QTvar_detr_loss[kmin:kmax]) - Stats.write_profile('HQTcov_detr_loss', self.HQTcov_detr_loss[kmin:kmax]) - Stats.write_profile('Hvar_shear', self.Hvar_shear[kmin:kmax]) - Stats.write_profile('QTvar_shear', self.QTvar_shear[kmin:kmax]) - Stats.write_profile('HQTcov_shear', self.HQTcov_shear[kmin:kmax]) + Stats.write_profile('TKE_entr_gain', self.EnvVar.TKE.entr_gain[kmin:kmax]) + Stats.write_profile('Hvar_entr_gain', self.EnvVar.Hvar.entr_gain[kmin:kmax]) + Stats.write_profile('QTvar_entr_gain', self.EnvVar.QTvar.entr_gain[kmin:kmax]) + Stats.write_profile('HQTcov_entr_gain', self.EnvVar.HQTcov.entr_gain[kmin:kmax]) + self.compute_covariance_detr(self.EnvVar.TKE) + self.compute_covariance_detr(self.EnvVar.Hvar) + self.compute_covariance_detr(self.EnvVar.QTvar) + self.compute_covariance_detr(self.EnvVar.HQTcov) + Stats.write_profile('TKE_detr_loss', self.EnvVar.TKE.detr_loss[kmin:kmax]) + Stats.write_profile('Hvar_detr_loss', self.EnvVar.Hvar.detr_loss[kmin:kmax]) + Stats.write_profile('QTvar_detr_loss', self.EnvVar.QTvar.detr_loss[kmin:kmax]) + Stats.write_profile('HQTcov_detr_loss', self.EnvVar.HQTcov.detr_loss[kmin:kmax]) + Stats.write_profile('TKE_shear', self.EnvVar.TKE.shear[kmin:kmax]) + Stats.write_profile('Hvar_shear', self.EnvVar.Hvar.shear[kmin:kmax]) + Stats.write_profile('QTvar_shear', self.EnvVar.QTvar.shear[kmin:kmax]) + Stats.write_profile('HQTcov_shear', self.EnvVar.HQTcov.shear[kmin:kmax]) + + Stats.write_profile('tke_buoy', self.tke_buoy[kmin:kmax]) + Stats.write_profile('tke_pressure', self.tke_pressure[kmin:kmax]) return @@ -343,9 +346,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdThermo.buoyancy(self.UpdVar, self.EnvVar,GMV, self.extrapolate_buoyancy) self.compute_eddy_diffusivities_tke(GMV, Case) - self.update_GMV_ED(GMV, Case, TS) - self.compute_tke(GMV, Case, TS) self.compute_covariance(GMV, Case, TS) # Back out the tendencies of the grid mean variables for the whole timestep by differencing GMV.new and @@ -492,20 +493,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): return - cpdef compute_tke(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS): - if self.similarity_diffusivity: # otherwise, we computed mixing length when we computed D_T - self.compute_mixing_length(Case.Sur.obukhov_length, GMV) - - self.compute_tke_buoy(GMV) - self.compute_tke_entr() - self.compute_tke_shear(GMV) - self.compute_tke_pressure() - - self.reset_surface_tke(GMV, Case) - self.update_tke_ED(GMV, Case, TS) - - - return cpdef update_inversion(self,GridMeanVariables GMV, option): ParameterizationBase.update_inversion(self, GMV,option) @@ -635,14 +622,10 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # Assuming GMV.W = 0! self.EnvVar.W.values[k] = -self.UpdVar.Area.bulkvalues[k]/(1.0-self.UpdVar.Area.bulkvalues[k]) * self.UpdVar.W.bulkvalues[k] - self.get_GMV_TKE(self.UpdVar.Area,self.UpdVar.W, self.EnvVar.W, self.EnvVar.TKE, - &GMV.W.values[0], &GMV.TKE.values[0]) - self.get_GMV_CoVar(self.UpdVar.Area,self.UpdVar.H, self.UpdVar.H, self.EnvVar.H, self.EnvVar.H, self.EnvVar.Hvar, - &GMV.H.values[0],&GMV.H.values[0], &GMV.Hvar.values[0]) - self.get_GMV_CoVar(self.UpdVar.Area,self.UpdVar.QT, self.UpdVar.QT, self.EnvVar.QT, self.EnvVar.QT, self.EnvVar.QTvar, - &GMV.QT.values[0],&GMV.QT.values[0], &GMV.QTvar.values[0]) - self.get_GMV_CoVar(self.UpdVar.Area,self.UpdVar.H, self.UpdVar.QT, self.EnvVar.H, self.EnvVar.QT, self.EnvVar.HQTcov, - &GMV.H.values[0], &GMV.QT.values[0], &GMV.HQTcov.values[0]) + self.get_GMV_CoVar(self.UpdVar.Area,self.UpdVar.W, self.UpdVar.W, self.EnvVar.W, self.EnvVar.W, self.EnvVar.TKE, &GMV.W.values[0],&GMV.W.values[0], &GMV.TKE.values[0]) + self.get_GMV_CoVar(self.UpdVar.Area,self.UpdVar.H, self.UpdVar.H, self.EnvVar.H, self.EnvVar.H, self.EnvVar.Hvar, &GMV.H.values[0],&GMV.H.values[0], &GMV.Hvar.values[0]) + self.get_GMV_CoVar(self.UpdVar.Area,self.UpdVar.QT,self.UpdVar.QT,self.EnvVar.QT,self.EnvVar.QT,self.EnvVar.QTvar, &GMV.QT.values[0],&GMV.QT.values[0], &GMV.QTvar.values[0]) + self.get_GMV_CoVar(self.UpdVar.Area,self.UpdVar.H, self.UpdVar.QT,self.EnvVar.H, self.EnvVar.QT,self.EnvVar.HQTcov, &GMV.H.values[0],&GMV.QT.values[0], &GMV.HQTcov.values[0]) elif whichvals == 'mf_update': @@ -659,59 +642,17 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # Assuming GMV.W = 0! self.EnvVar.W.values[k] = -self.UpdVar.Area.bulkvalues[k]/(1.0-self.UpdVar.Area.bulkvalues[k]) * self.UpdVar.W.bulkvalues[k] - self.get_GMV_TKE(self.UpdVar.Area,self.UpdVar.W, self.EnvVar.W, self.EnvVar.TKE, - &GMV.W.values[0], &GMV.TKE.values[0]) - self.get_GMV_CoVar(self.UpdVar.Area,self.UpdVar.H, self.UpdVar.H, self.EnvVar.H, self.EnvVar.H, self.EnvVar.Hvar, - &GMV.H.values[0],&GMV.H.values[0], &GMV.Hvar.values[0]) - self.get_GMV_CoVar(self.UpdVar.Area,self.UpdVar.QT, self.UpdVar.QT, self.EnvVar.QT, self.EnvVar.QT, self.EnvVar.QTvar, - &GMV.QT.values[0],&GMV.QT.values[0], &GMV.QTvar.values[0]) - self.get_GMV_CoVar(self.UpdVar.Area,self.UpdVar.H, self.UpdVar.QT, self.EnvVar.H, self.EnvVar.QT, self.EnvVar.HQTcov, - &GMV.H.values[0], &GMV.QT.values[0], &GMV.HQTcov.values[0]) + self.get_GMV_CoVar(self.UpdVar.Area,self.UpdVar.W, self.UpdVar.W, self.EnvVar.W, self.EnvVar.W, self.EnvVar.TKE, &GMV.W.values[0],&GMV.W.values[0], &GMV.TKE.values[0]) + self.get_GMV_CoVar(self.UpdVar.Area,self.UpdVar.H, self.UpdVar.H, self.EnvVar.H, self.EnvVar.H, self.EnvVar.Hvar, &GMV.H.values[0],&GMV.H.values[0], &GMV.Hvar.values[0]) + self.get_GMV_CoVar(self.UpdVar.Area,self.UpdVar.QT,self.UpdVar.QT,self.EnvVar.QT,self.EnvVar.QT,self.EnvVar.QTvar, &GMV.QT.values[0],&GMV.QT.values[0], &GMV.QTvar.values[0]) + self.get_GMV_CoVar(self.UpdVar.Area,self.UpdVar.H, self.UpdVar.QT,self.EnvVar.H, self.EnvVar.QT,self.EnvVar.HQTcov, &GMV.H.values[0],&GMV.QT.values[0], &GMV.HQTcov.values[0]) return - cdef get_GMV_TKE(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable wu, - EDMF_Environment.EnvironmentVariable we, EDMF_Environment.EnvironmentVariable tke_e, - double *gmv_w, double *gmv_tke): - cdef: - Py_ssize_t i,k - double [:] ae = np.subtract(np.ones((self.Gr.nzg,),dtype=np.double, order='c'),au.bulkvalues) - double interp_w_diff - with nogil: - for k in xrange(self.Gr.nzg): - interp_w_diff = we.values[k]-gmv_w[k] - gmv_tke[k] = ae[k] * interp_w_diff * interp_w_diff + ae[k] * tke_e.values[k] - for i in xrange(self.n_updrafts): - interp_w_diff = wu.values[i,k]-gmv_w[k] - gmv_tke[k] += au.values[i,k] *interp_w_diff * interp_w_diff - return - cdef get_env_tke_from_GMV(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable wu, - EDMF_Environment.EnvironmentVariable we, EDMF_Environment.EnvironmentVariable tke_e, - double *gmv_w, double *gmv_tke): - cdef: - Py_ssize_t i,k - double [:] ae = np.subtract(np.ones((self.Gr.nzg,),dtype=np.double, order='c'),au.bulkvalues) - double interp_w_diff - - with nogil: - for k in xrange(self.Gr.nzg): - if ae[k] > 0.0: - interp_w_diff = we.values[k]-gmv_w[k] - tke_e.values[k] = gmv_tke[k] - ae[k] * interp_w_diff * interp_w_diff - - for i in xrange(self.n_updrafts): - interp_w_diff = wu.values[i,k]-gmv_w[k] - tke_e.values[k] -= au.values[i,k] *interp_w_diff * interp_w_diff - tke_e.values[k] = tke_e.values[k]/ae[k] - else: - tke_e.values[k] = 0.0 - return - - # Note: this assumes all variables are defined on half levels not full levels (i.e. phi, psi are not w) cdef get_GMV_CoVar(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable phi_u, EDMF_Updrafts.UpdraftVariable psi_u, @@ -725,17 +666,18 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(self.Gr.nzg): - phi_diff = phi_e.values[k]-gmv_phi[k] - psi_diff = psi_e.values[k]-gmv_psi[k] - gmv_covar[k] = ae[k] * phi_diff * psi_diff + ae[k] * covar_e.values[k] - for i in xrange(self.n_updrafts): - phi_diff = phi_u.values[i,k]-gmv_phi[k] - psi_diff = psi_u.values[i,k]-gmv_psi[k] - gmv_covar[k] += au.values[i,k] * phi_diff * psi_diff + if ae[k] > 0.0: + phi_diff = phi_e.values[k]-gmv_phi[k] + psi_diff = psi_e.values[k]-gmv_psi[k] + gmv_covar[k] = ae[k] * phi_diff * psi_diff + ae[k] * covar_e.values[k] + for i in xrange(self.n_updrafts): + phi_diff = phi_u.values[i,k]-gmv_phi[k] + psi_diff = psi_u.values[i,k]-gmv_psi[k] + gmv_covar[k] += au.values[i,k] * phi_diff * psi_diff + else: + gmv_covar[k] = 0.0 return - - cdef get_env_covar_from_GMV(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable phi_u, EDMF_Updrafts.UpdraftVariable psi_u, EDMF_Environment.EnvironmentVariable phi_e, EDMF_Environment.EnvironmentVariable psi_e, @@ -761,8 +703,27 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): covar_e.values[k] = 0.0 return - - + # cdef get_env_tke_from_GMV(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable wu, + # EDMF_Environment.EnvironmentVariable we, EDMF_Environment.EnvironmentVariable tke_e, + # double *gmv_w, double *gmv_tke): + # cdef: + # Py_ssize_t i,k + # double [:] ae = np.subtract(np.ones((self.Gr.nzg,),dtype=np.double, order='c'),au.bulkvalues) + # double interp_w_diff + # + # with nogil: + # for k in xrange(self.Gr.nzg): + # if ae[k] > 0.0: + # interp_w_diff = we.values[k]-gmv_w[k] + # tke_e.values[k] = gmv_tke[k] - ae.values[k] * interp_w_diff * interp_w_diff + # + # for i in xrange(self.n_updrafts): + # interp_w_diff = wu.values[i,k]-gmv_w[k] + # tke_e.values[k] -= au.values[i,k] *interp_w_diff * interp_w_diff + # tke_e.values[k] = tke_e.values[k]/ae[k] + # else: + # tke_e.values[k] = 0.0 + # return cpdef compute_entrainment_detrainment(self, GridMeanVariables GMV, CasesBase Case): cdef: @@ -1170,32 +1131,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): - self.KH.values[k] * grad_qt_plus * d_alpha_qt_total) return - - # Note we need mixing length again here.... - cpdef compute_tke_dissipation(self): - cdef: - Py_ssize_t k - double [:] ae = np.subtract(np.ones((self.Gr.nzg,),dtype=np.double, order='c'),self.UpdVar.Area.bulkvalues) - #tke diss coeff - - # does mixing length need to be recomputed? Even if no change in GMV.TKE, if updraft area changes - # this would change environmental tke (assuming it is still adjusted based on tke) - # first pass...assume we can re-use - # Using the "semi-implicit formulation" with dissipation averaged over timestep - with nogil: - for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - self.tke_dissipation[k] = (self.Ref.rho0[k] * ae[k] * pow(fmax(self.EnvVar.TKE.values[k],0), 1.5) - /fmax(self.mixing_length[k],1.0) * self.tke_diss_coeff) - return - - # Note updrafts' (total) entrainment rate = environment's (total) detrainment rate - # and updrafts' (total) detrainment rate = environment's (total) entrainment rate - # Therefore, fractional xxtrainment rates must be properly multiplied by the right component mass fluxes - # Here we use the terminology entrainment/detrainment relative to the __environment__ - - - - cpdef compute_tke_pressure(self): cdef: Py_ssize_t k @@ -1216,73 +1151,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.tke_pressure[k] += (we - wu) * (press_buoy + press_drag) return - cpdef update_tke_ED(self, GridMeanVariables GMV, CasesBase Case,TimeStepping TS): - cdef: - Py_ssize_t k, kk, i - Py_ssize_t gw = self.Gr.gw - Py_ssize_t nzg = self.Gr.nzg - Py_ssize_t nz = self.Gr.nz - double dzi = self.Gr.dzi - double dti = TS.dti - double [:] a = np.zeros((nz,),dtype=np.double, order='c') # for tridiag solver - double [:] b = np.zeros((nz,),dtype=np.double, order='c') # for tridiag solver - double [:] c = np.zeros((nz,),dtype=np.double, order='c') # for tridiag solver - double [:] x = np.zeros((nz,),dtype=np.double, order='c') # for tridiag solver - double [:] ae = np.subtract(np.ones((nzg,),dtype=np.double, order='c'),self.UpdVar.Area.bulkvalues) # area of environment - double [:] ae_old = np.subtract(np.ones((nzg,),dtype=np.double, order='c'), np.sum(self.UpdVar.Area.old,axis=0)) - double [:] rho_ae_K_m = np.zeros((nzg,),dtype=np.double, order='c') - - - - - with nogil: - for k in xrange(1,nzg-1): - rho_ae_K_m[k] = 0.5 * (ae[k]*self.KM.values[k]+ ae[k+1]*self.KM.values[k+1]) * self.Ref.rho0[k] - wu = self.UpdVar.W.bulkvalues[gw] - GMV.TKE.values[gw] = get_surface_tke(Case.Sur.ustar, self.wstar, self.Gr.z[gw], Case.Sur.obukhov_length) - self.get_env_tke_from_GMV(self.UpdVar.Area, self.UpdVar.W, self.EnvVar.W, - self.EnvVar.TKE, &GMV.W.values[0], &GMV.TKE.values[0]) - - tke_0_surf = self.EnvVar.TKE.values[gw] - - - with nogil: - for kk in xrange(nz): - k = kk+gw - D_env = 0.0 - - for i in xrange(self.n_updrafts): - wu = self.UpdVar.W.values[i,k] - D_env += self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * wu * self.entr_sc[i,k] - - a[kk] = (- rho_ae_K_m[k-1] * dzi * dzi ) - b[kk] = (self.Ref.rho0[k] * ae[k] * dti - self.Ref.rho0[k] * ae[k] * self.EnvVar.W.values[k] * dzi - + rho_ae_K_m[k] * dzi * dzi + rho_ae_K_m[k-1] * dzi * dzi - + D_env - + self.Ref.rho0[k] * ae[k] * self.tke_diss_coeff * sqrt(fmax(self.EnvVar.TKE.values[k],0.0))/fmax(self.mixing_length[k],1.0)) - c[kk] = (self.Ref.rho0[k+1] * ae[k+1] * self.EnvVar.W.values[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) - x[kk] = (self.Ref.rho0[k] * ae_old[k] * self.EnvVar.TKE.values[k] * dti - + self.tke_shear[k] + self.tke_buoy[k] + self.tke_entr_gain[k] + self.tke_pressure[k]) - a[0] = 0.0 - b[0] = 1.0 - c[0] = 0.0 - x[0] = tke_0_surf - - b[nz-1] += c[nz-1] - c[nz-1] = 0.0 - tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) - - with nogil: - for kk in xrange(nz): - k = kk + gw - self.EnvVar.TKE.values[k] = fmax(x[kk], 0.0) - wu = self.UpdVar.W.bulkvalues[k] - - self.get_GMV_TKE(self.UpdVar.Area,self.UpdVar.W, self.EnvVar.W, self.EnvVar.TKE, - &GMV.W.values[0], &GMV.TKE.values[0]) - - return - cpdef update_GMV_diagnostics(self, GridMeanVariables GMV): cdef: Py_ssize_t k @@ -1302,34 +1170,36 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): GMV.QL.values[k], 0.0) GMV.B.values[k] = (self.UpdVar.Area.bulkvalues[k] * self.UpdVar.B.bulkvalues[k] + (1.0 - self.UpdVar.Area.bulkvalues[k]) * self.EnvVar.B.values[k]) - return - cpdef compute_covariance(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS): - if TS.nstep > 0: if self.similarity_diffusivity: # otherwise, we computed mixing length when we computed self.compute_mixing_length(Case.Sur.obukhov_length, GMV) - self.compute_covariance_entr(self, &self.EnvVar.Hvar.entr_gain, &self.EnvVar.Hvar, &self.UpdVar.H, &self.UpdVar.H, &self.EnvVar.H, &self.EnvVar.H) - self.compute_covariance_entr(self, &self.EnvVar.QTvar.entr_gain, &self.EnvVar.QTvar, &self.UpdVar.QT, &self.UpdVar.QT, &self.EnvVar.QT, &self.EnvVar.QT) - self.compute_covariance_entr(self, &self.EnvVar.HQTcov.entr_gain, &self.EnvVar.HQTcov, &self.UpdVar.H, &self.UpdVar.QT, &self.EnvVar.H, &self.EnvVar.QT) - self.compute_covariance_entr(self, &self.EnvVar.TKE.entr_gain, &self.EnvVar.TKE, &self.UpdVar.W, &self.UpdVar.W, &self.EnvVar.W, &self.EnvVar.W) + self.compute_covariance_entr(self.EnvVar.TKE, self.UpdVar.W, self.UpdVar.W, self.EnvVar.W, self.EnvVar.W) + self.compute_covariance_entr(self.EnvVar.Hvar, self.UpdVar.H, self.UpdVar.H, self.EnvVar.H, self.EnvVar.H) + self.compute_covariance_entr(self.EnvVar.QTvar, self.UpdVar.QT, self.UpdVar.QT, self.EnvVar.QT, self.EnvVar.QT) + self.compute_covariance_entr(self.EnvVar.HQTcov, self.UpdVar.H, self.UpdVar.QT, self.EnvVar.H, self.EnvVar.QT) + + self.compute_covariance_shear(GMV, self.EnvVar.TKE, &self.UpdVar.W.values[0,0], &self.UpdVar.W.values[0,0], &self.EnvVar.W.values[0], &self.EnvVar.W.values[0]) + self.compute_covariance_shear(GMV, self.EnvVar.Hvar, &self.UpdVar.H.values[0,0], &self.UpdVar.H.values[0,0], &self.EnvVar.H.values[0], &self.EnvVar.H.values[0]) + self.compute_covariance_shear(GMV, self.EnvVar.QTvar, &self.UpdVar.QT.values[0,0], &self.UpdVar.QT.values[0,0], &self.EnvVar.QT.values[0], &self.EnvVar.QT.values[0]) + self.compute_covariance_shear(GMV, self.EnvVar.HQTcov, &self.UpdVar.H.values[0,0], &self.UpdVar.QT.values[0,0], &self.EnvVar.H.values[0], &self.EnvVar.QT.values[0]) - self.compute_covariance_shear(self,GMV, &self.EnvVar.Hvar.shear, &self.EnvVar.Hvar, &self.UpdVar.H, &self.UpdVar.H, &self.EnvVar.H, &self.EnvVar.H) - self.compute_covariance_shear(self,GMV, &self.EnvVar.QTvar.shear, &self.EnvVar.QTvar, &self.UpdVar.QT, &self.UpdVar.QT, &self.EnvVar.QT, &self.EnvVar.QT) - self.compute_covariance_shear(self,GMV, &self.EnvVar.HQTcov.shear, &self.EnvVar.HQTcov, &self.UpdVar.H, &self.UpdVar.QT, &self.EnvVar.H, &self.EnvVar.QT) - self.compute_covariance_shear(self,GMV, &self.EnvVar.TKE.shear, &self.EnvVar.TKE, &self.UpdVar.W, &self.UpdVar.W, &self.EnvVar.W, &self.EnvVar.W) self.compute_tke_buoy(GMV) self.compute_tke_pressure() self.reset_surface_covariance(GMV, Case) - self.update_covariance_ED(GMV, Case, TS) + + self.update_covariance_ED(GMV, Case,TS, GMV.W, GMV.W, GMV.TKE, self.EnvVar.TKE, self.EnvVar.W, self.EnvVar.W, self.UpdVar.W, self.UpdVar.W) + self.update_covariance_ED(GMV, Case,TS, GMV.H, GMV.H, GMV.Hvar, self.EnvVar.Hvar, self.EnvVar.H, self.EnvVar.H, self.UpdVar.H, self.UpdVar.H) + self.update_covariance_ED(GMV, Case,TS, GMV.QT,GMV.QT,GMV.QTvar, self.EnvVar.QTvar, self.EnvVar.QT, self.EnvVar.QT, self.UpdVar.QT, self.UpdVar.QT) + self.update_covariance_ED(GMV, Case,TS, GMV.H, GMV.H, GMV.HQTcov, self.EnvVar.HQTcov, self.EnvVar.H, self.EnvVar.QT, self.UpdVar.H, self.UpdVar.QT) + else: self.initialize_covariance(GMV, Case) - return @@ -1338,25 +1208,23 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cdef: Py_ssize_t k double ws= self.wstar, us = Case.Sur.ustar, zs = self.zi, z - - double ws= self.wstar, us = Case.Sur.ustar, zs = self.zi, z self.reset_surface_covariance(GMV, Case) + if ws > 0.0: with nogil: for k in xrange(self.Gr.nzg): z = self.Gr.z[k] GMV.TKE.values[k] = ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) - with nogil: - for k in xrange(self.Gr.nzg): - z = self.Gr.z[k] - # need to rethink of how to initilize the covarinace profiles - for nowmI took the TKE profile - GMV.Hvar.values[k] = GMV.Hvar.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) - GMV.QTvar.values[k] = GMV.QTvar.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) - GMV.HQTcov.values[k] = GMV.HQTcov.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) - + #with nogil: + for k in xrange(self.Gr.nzg): + z = self.Gr.z[k] + # need to rethink of how to initilize the covarinace profiles - for nowmI took the TKE profile + GMV.Hvar.values[k] = GMV.Hvar.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) + GMV.QTvar.values[k] = GMV.QTvar.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) + GMV.HQTcov.values[k] = GMV.HQTcov.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) self.reset_surface_tke(GMV, Case) - self.reset_surface_covariance(self, GMV, Case) # double check this should be here - it was not in the orignal covariance branch + self.reset_surface_covariance(GMV, Case) # double check this should be here - it was not in the orignal covariance branch self.compute_mixing_length(Case.Sur.obukhov_length, GMV) return @@ -1381,12 +1249,10 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): GMV.Hvar.values[self.Gr.gw] = get_surface_variance(flux1*alpha0LL,flux1*alpha0LL, ustar, zLL, oblength) GMV.QTvar.values[self.Gr.gw] = get_surface_variance(flux2*alpha0LL,flux2*alpha0LL, ustar, zLL, oblength) GMV.HQTcov.values[self.Gr.gw] = get_surface_variance(flux1 * alpha0LL,flux2 * alpha0LL, ustar, zLL, oblength) - - return - cdef void compute_covariance_shear(self,GridMeanVariables GMV, double *shear, double *Var, double *UpdVar1, double *UpdVar2, double *EnvVar1, double *EnvVar2): + cdef void compute_covariance_shear(self,GridMeanVariables GMV, EDMF_Environment.EnvironmentVariable_m2 Covar, double *UpdVar1, double *UpdVar2, double *EnvVar1, double *EnvVar2): cdef: Py_ssize_t k double var1_high = 0.0 @@ -1395,64 +1261,64 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double dv_high = 0.0 double var1_low, var2_low double tke_factor = 1.0 - with nogil: - for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - var1_low = var1_high - var2_low = var2_high - du_low = du_high - dv_low = dv_high - if Var.name == 'TKE': - du_high = (GMV.U.values[k+1] - GMV.U.values[k-1]) * self.Gr.dzi - dv_high = (GMV.V.values[k+1] - GMV.V.values[k-1]) * self.Gr.dzi - tke_factor = 0.5 - var1_high = (EnvVar1.values[k+1] - EnvVar1.values[k-1]) * self.Gr.dzi - var2_high = (EnvVar2.values[k+1] - EnvVar2.values[k-1]) * self.Gr.dzi - Var.shear[k] = tke_factor*2.0*(self.Ref.rho0[k] * (1.0-self.UpdVar.Area.bulkvalues) * self.KH.values[k] * - (var1_high*var2_high + pow(du_high,2.0) + pow(dv_high,2.0))) + #with nogil: + for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): + var1_low = var1_high + var2_low = var2_high + du_low = du_high + dv_low = dv_high + if Covar.name == 'TKE': + du_high = (GMV.U.values[k+1] - GMV.U.values[k-1]) * self.Gr.dzi + dv_high = (GMV.V.values[k+1] - GMV.V.values[k-1]) * self.Gr.dzi + tke_factor = 0.5 + var1_high = (EnvVar1[k+1] - EnvVar1[k-1]) * self.Gr.dzi + var2_high = (EnvVar2[k+1] - EnvVar2[k-1]) * self.Gr.dzi + Covar.shear[k] = tke_factor*2.0*(self.Ref.rho0[k] * (1.0-self.UpdVar.Area.bulkvalues[k]) * self.KH.values[k] * + (var1_high*var2_high + pow(du_high,2.0) + pow(dv_high,2.0))) return - cdef void compute_covariance_dissipation(self, double *covariance_dissipation, double *Var): + cdef void compute_covariance_dissipation(self, EDMF_Environment.EnvironmentVariable_m2 Covar): cdef: Py_ssize_t i double m Py_ssize_t k - with nogil: - for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - Var.covariance_dissipation[k] = (self.Ref.rho0[k] * (1.0-self.UpdVar.Area.bulkvalues[k]) * Var.values[k] - *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0) * self.tke_diss_coeff) - + #with nogil: + for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): + Covar[k] = (self.Ref.rho0[k] * (1.0-self.UpdVar.Area.bulkvalues[k]) * Covar[k] + *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0) * self.tke_diss_coeff) return - - - cdef void compute_covariance_entr(self, double *entr_gain, double *Var, double *UpdVar1, double *UpdVar2, double *EnvVar1, double *EnvVar2): + #cdef void compute_covariance_entr(self, Covar, UpdVar1, UpdVar2, EnvVar1, EnvVar2): + cdef void compute_covariance_entr(self, EDMF_Environment.EnvironmentVariable_m2 Covar, EDMF_Updrafts.UpdraftVariable UpdVar1, + EDMF_Updrafts.UpdraftVariable UpdVar2, EDMF_Environment.EnvironmentVariable EnvVar1, EDMF_Environment.EnvironmentVariable_m2 EnvVar2): cdef: Py_ssize_t i, k - with nogil: - for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - Var.Hvar.entr_gain[k] = 0.0 - for i in xrange(self.n_updrafts): - Var.Hvar.entr_gain[k] += self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.detr_sc[i,k] * \ - (UpdVar1.values[i,k] - EnvVar1.values[i,k]) * (UpdVar2.values[i,k] - EnvVar2.values[i,k]) - Var.Hvar.entr_gain[k] *= self.Ref.rho0[k] + #with nogil: + for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): + Covar.entr_gain[k] = 0.0 + for i in xrange(self.n_updrafts): + Covar.entr_gain[k] += self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.detr_sc[i,k] * \ + (UpdVar1.values[i,k] - EnvVar1.values[k]) * (UpdVar2.values[i,k] - EnvVar2.values[k]) + Covar.entr_gain[k] *= self.Ref.rho0[k] return - #cpdef compute_covariance_detr(self, EDMF_Environment.EnvironmentVariable, var): - cdef void compute_covariance_detr(self, double *detr_loss, double *Var): + cdef void compute_covariance_detr(self, EDMF_Environment.EnvironmentVariable_m2 Covar): cdef: Py_ssize_t i, k - with nogil: - for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - Var.detr_loss[k] = 0.0 - for i in xrange(self.n_updrafts): - Var.detr_loss[k] += self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.entr_sc[i,k] - Var.detr_loss[k] *= self.Ref.rho0[k] * Var.values[k] - + #with nogil: + for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): + Covar.detr_loss[k] = 0.0 + for i in xrange(self.n_updrafts): + Covar.detr_loss[k] += self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.entr_sc[i,k] + Covar.detr_loss[k] *= self.Ref.rho0[k] * Covar.values[k] return + # verfy that everythong from tke is here and unify and cvert to pointers with cdef void - cdef void update_covariance_ED(self, GridMeanVariables GMV, CasesBase Case,TimeStepping TS, double *Var): + cdef void update_covariance_ED(self, GridMeanVariables GMV, CasesBase Case,TimeStepping TS, VariablePrognostic GmvVar1, VariablePrognostic GmvVar2, + VariablePrognostic GmvCovar, EDMF_Environment.EnvironmentVariable_m2 Covar, EDMF_Environment.EnvironmentVariable EnvVar1, EDMF_Environment.EnvironmentVariable EnvVar2, + EDMF_Updrafts.UpdraftVariable UpdVar1, EDMF_Updrafts.UpdraftVariable UpdVar2): cdef: Py_ssize_t k, kk, i Py_ssize_t gw = self.Gr.gw @@ -1470,154 +1336,73 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double [:] ae_old = np.subtract(np.ones((nzg,),dtype=np.double, order='c'), np.sum(self.UpdVar.Area.old,axis=0)) double [:] rho_ae_K_m = np.zeros((nzg,),dtype=np.double, order='c') double D_env = 0.0 - double wu, we, tke_0_surf,press_k + double tke_0_surf,press_k # missing flux1 and 2 in get_surface_variance double Hvar_gmv_surf = get_surface_variance(Case.Sur.rho_hflux * alpha0LL, Case.Sur.rho_hflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) double QTvar_gmv_surf = get_surface_variance(Case.Sur.rho_qtflux * alpha0LL, Case.Sur.rho_qtflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) double HQTcov_gmv_surf = get_surface_variance(Case.Sur.rho_hflux * alpha0LL, Case.Sur.rho_qtflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) double Hu, He, QTu, QTe - double wu, we, Hvar_0_surf, QTvar_0_surf, HQTcov_0_surf + double Hvar_0_surf, QTvar_0_surf, HQTcov_0_surf with nogil: for k in xrange(1,nzg-1): rho_ae_K_m[k] = 0.5 * (ae[k]*self.KH.values[k]+ ae[k+1]*self.KH.values[k+1]) * self.Ref.rho0[k] - wu = self.UpdVar.W.bulkvalues[gw] Hu = self.UpdVar.H.bulkvalues[gw] QTu = self.UpdVar.QT.bulkvalues[gw] - GMV.Hvar.values[gw] = get_surface_variance(Case.Sur.rho_hflux * alpha0LL, Case.Sur.rho_hflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) - GMV.QTvar.values[gw] = get_surface_variance(Case.Sur.rho_qtflux * alpha0LL, Case.Sur.rho_qtflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) - GMV.HQTcov.values[gw] = get_surface_variance(Case.Sur.rho_hflux * alpha0LL, Case.Sur.rho_qtflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) - self.get_env_covar_from_GMV(self.UpdVar.Area, self.UpdVar.H, self.UpdVar.H, self.EnvVar.H, self.EnvVar.H, - self.EnvVar.Hvar, &GMV.H.values[0], &GMV.H.values[0], &GMV.Hvar.values[0]) - self.get_env_covar_from_GMV(self.UpdVar.Area, self.UpdVar.QT, self.UpdVar.QT, self.EnvVar.QT, self.EnvVar.QT, - self.EnvVar.QTvar, &GMV.QT.values[0], &GMV.QT.values[0], &GMV.QTvar.values[0]) - self.get_env_covar_from_GMV(self.UpdVar.Area, self.UpdVar.H, self.UpdVar.QT, self.EnvVar.H, self.EnvVar.QT, - self.EnvVar.HQTcov, &GMV.H.values[0], &GMV.QT.values[0], &GMV.HQTcov.values[0]) + # if Covar.name =='TKE': + # GmvCovar.values[gw] = get_surface_tke(Case.Sur.ustar, self.wstar, self.Gr.z[gw], Case.Sur.obukhov_length) + # self.get_env_tke_from_GMV(self.UpdVar.Area, UpdVar1, EnvVar1, Covar, GmvVar1, GmvCovar) + # + # else: + GmvCovar.values[gw] = get_surface_variance(Case.Sur.rho_hflux * alpha0LL, Case.Sur.rho_hflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) + self.get_env_covar_from_GMV(self.UpdVar.Area, UpdVar1, UpdVar2, EnvVar1, EnvVar2,Covar, &GmvVar1.values[0], &GmvVar2.values[0], &GmvCovar.values[0]) + + Var_0_surf = Covar.values[gw] # BC at the surface - Hvar_0_surf = self.EnvVar.Hvar.values[gw] - QTvar_0_surf = self.EnvVar.QTvar.values[gw] - HQTcov_0_surf = self.EnvVar.HQTcov.values[gw] + #Hvar_0_surf = self.EnvVar.Hvar.values[gw] + #QTvar_0_surf = self.EnvVar.QTvar.values[gw] + #HQTcov_0_surf = self.EnvVar.HQTcov.values[gw] # run tridiagonal solver for Hvar - with nogil: - for kk in xrange(nz): - k = kk+gw - D_env = 0.0 - - for i in xrange(self.n_updrafts): - wu = self.UpdVar.W.values[i,k] - D_env += self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * wu * self.entr_sc[i,k] - - a[kk] = (- rho_ae_K_m[k-1] * dzi * dzi ) - b[kk] = (self.Ref.rho0[k] * ae[k] * dti - self.Ref.rho0[k] * ae[k] * self.EnvVar.W.values[k] * dzi - + rho_ae_K_m[k] * dzi * dzi + rho_ae_K_m[k-1] * dzi * dzi - + D_env - + self.Ref.rho0[k] * ae[k] * self.tke_diss_coeff - *sqrt(fmax(self.EnvVar.TKE.values[k],0))/fmax(self.mixing_length[k],1.0) ) - c[kk] = (self.Ref.rho0[k+1] * ae[k+1] * self.EnvVar.W.values[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) - x[kk] = (self.Ref.rho0[k] * ae_old[k] * self.EnvVar.Hvar.values[k] * dti - + self.Hvar_shear[k] + self.Hvar_entr_gain[k]) # - - a[0] = 0.0 - b[0] = 1.0 - c[0] = 0.0 - x[0] = Hvar_0_surf - - b[nz-1] += c[nz-1] - c[nz-1] = 0.0 - tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) - - with nogil: - for kk in xrange(nz): - k = kk + gw - self.EnvVar.Hvar.values[k] = x[kk] - GMV.Hvar.values[k] = (ae[k] * (self.EnvVar.Hvar.values[k] + (self.EnvVar.H.values[k]-GMV.H.values[k]) * (self.EnvVar.H.values[k]-GMV.H.values[k])) - + self.UpdVar.Area.bulkvalues[k] * (self.UpdVar.H.bulkvalues[k]-GMV.H.values[k]) * (self.UpdVar.H.bulkvalues[k]-GMV.H.values[k])) - - self.get_GMV_CoVar(self.UpdVar.Area, self.UpdVar.H, self.UpdVar.H, self.EnvVar.H, self.EnvVar.H, self.EnvVar.Hvar, - &GMV.H.values[0],&GMV.H.values[0], &GMV.Hvar.values[0]) - # run tridiagonal solver for QTvar - with nogil: - for kk in xrange(nz): - k = kk+gw - D_env = 0.0 + #with nogil: + for kk in xrange(nz): + k = kk+gw + D_env = 0.0 - for i in xrange(self.n_updrafts): - wu = self.UpdVar.W.values[i,k] - D_env += self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * wu * self.entr_sc[i,k] - - a[kk] = (- rho_ae_K_m[k-1] * dzi * dzi ) - b[kk] = (self.Ref.rho0[k] * ae[k] * dti - self.Ref.rho0[k] * ae[k] * self.EnvVar.W.values[k] * dzi - + rho_ae_K_m[k] * dzi * dzi + rho_ae_K_m[k-1] * dzi * dzi - + D_env - + self.Ref.rho0[k] * ae[k] * self.tke_diss_coeff - *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0)) - c[kk] = (self.Ref.rho0[k+1] * ae[k+1] * self.EnvVar.W.values[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) - x[kk] = (self.Ref.rho0[k] * ae_old[k] * self.EnvVar.QTvar.values[k] * dti - + self.QTvar_shear[k] + self.QTvar_entr_gain[k]) # + for i in xrange(self.n_updrafts): + D_env += self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.entr_sc[i,k] + + a[kk] = (- rho_ae_K_m[k-1] * dzi * dzi ) + b[kk] = (self.Ref.rho0[k] * ae[k] * dti - self.Ref.rho0[k] * ae[k] * self.EnvVar.W.values[k] * dzi + + rho_ae_K_m[k] * dzi * dzi + rho_ae_K_m[k-1] * dzi * dzi + + D_env + + self.Ref.rho0[k] * ae[k] * self.tke_diss_coeff + *sqrt(fmax(self.EnvVar.TKE.values[k],0))/fmax(self.mixing_length[k],1.0) ) + c[kk] = (self.Ref.rho0[k+1] * ae[k+1] * self.EnvVar.W.values[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) + x[kk] = (self.Ref.rho0[k] * ae_old[k] * Covar.values[k] * dti + + Covar.press[k] + Covar.buoy[k] + Covar.shear[k] + Covar.entr_gain[k]) # a[0] = 0.0 b[0] = 1.0 c[0] = 0.0 - x[0] = QTvar_0_surf + x[0] = Var_0_surf b[nz-1] += c[nz-1] c[nz-1] = 0.0 tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) - with nogil: - for kk in xrange(nz): - k = kk + gw - #self.EnvVar.Hvar.values[k] = fmax(x[kk], 0.0) - self.EnvVar.QTvar.values[k] = x[kk] - GMV.QTvar.values[k] = (ae[k] * (self.EnvVar.QTvar.values[k] + (self.EnvVar.QT.values[k]-GMV.QT.values[k]) * (self.EnvVar.QT.values[k]-GMV.QT.values[k])) - + self.UpdVar.Area.bulkvalues[k] * (self.UpdVar.QT.bulkvalues[k]-GMV.QT.values[k]) * (self.UpdVar.QT.bulkvalues[k]-GMV.QT.values[k])) - - self.get_GMV_CoVar(self.UpdVar.Area, self.UpdVar.QT, self.UpdVar.QT, self.EnvVar.QT, self.EnvVar.QT, self.EnvVar.QTvar, - &GMV.QT.values[0],&GMV.QT.values[0], &GMV.QTvar.values[0]) - - # run tridiagonal solver for HQTcov - with nogil: - for kk in xrange(nz): - k = kk+gw - D_env = 0.0 - - for i in xrange(self.n_updrafts): - wu = self.UpdVar.W.values[i,k] - D_env += self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * wu * self.entr_sc[i,k] - - a[kk] = (- rho_ae_K_m[k-1] * dzi * dzi ) - b[kk] = (self.Ref.rho0[k] * ae[k] * dti - self.Ref.rho0[k] * ae[k] * self.EnvVar.W.values[k] * dzi - + rho_ae_K_m[k] * dzi * dzi + rho_ae_K_m[k-1] * dzi * dzi - + D_env - + self.Ref.rho0[k] * ae[k] * self.tke_diss_coeff - *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0) ) - c[kk] = (self.Ref.rho0[k+1] * ae[k+1] * self.EnvVar.W.values[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) - x[kk] = (self.Ref.rho0[k] * ae_old[k] * self.EnvVar.HQTcov.values[k] * dti - + self.HQTcov_shear[k] + self.EnvVar.HQTcov.entr_gain[k]) # - - a[0] = 0.0 - b[0] = 1.0 - c[0] = 0.0 - x[0] = HQTcov_0_surf - - b[nz-1] += c[nz-1] - c[nz-1] = 0.0 - tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) + #with nogil: + for kk in xrange(nz): + k = kk + gw + Covar.values[k] = x[kk] + GmvCovar.values[k] = (ae[k] * (Covar.values[k] + (EnvVar1.values[k]-GmvVar1.values[k]) * (EnvVar2.values[k]-GmvVar2.values[k])) + + self.UpdVar.Area.bulkvalues[k] * (UpdVar1.bulkvalues[k]-GmvVar1.values[k]) * (UpdVar2.bulkvalues[k]-GmvVar2.values[k])) - with nogil: - for kk in xrange(nz): - k = kk + gw - self.EnvVar.HQTcov.values[k] = x[kk] - GMV.HQTcov.values[k] = (ae[k] * (self.EnvVar.HQTcov.values[k] + (self.EnvVar.H.values[k]-GMV.H.values[k]) * (self.EnvVar.QT.values[k]-GMV.QT.values[k])) - + self.UpdVar.Area.bulkvalues[k] * (self.UpdVar.H.bulkvalues[k]-GMV.H.values[k]) * (self.UpdVar.QT.bulkvalues[k]-GMV.QT.values[k])) - - self.get_GMV_CoVar(self.UpdVar.Area, self.UpdVar.H, self.UpdVar.QT, self.EnvVar.H, self.EnvVar.QT, self.EnvVar.HQTcov, - &GMV.H.values[0], &GMV.QT.values[0], &GMV.HQTcov.values[0]) + self.get_GMV_CoVar(self.UpdVar.Area, UpdVar1, UpdVar2, EnvVar1, EnvVar2, Covar, &GmvVar1.values[0], &GmvVar2.values[0], &GmvCovar.values[0]) return From 2dd8a94aaa2d59e386861b5081b723e3fa3fc7b8 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Fri, 10 Aug 2018 18:06:34 -0700 Subject: [PATCH 044/136] compile with nogil added and checked factor 2 in TKE fuctions --- Turbulence_PrognosticTKE.pyx | 243 ++++++++++++++++------------------- 1 file changed, 112 insertions(+), 131 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index db106732..57c97bd2 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -739,38 +739,39 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): input.wstar = self.wstar - #with nogil: + for i in xrange(self.n_updrafts): input.zi = self.UpdVar.cloud_base[i] Poisson_rand = np.random.poisson(10.0,self.Gr.nzg).astype(np.float) Poisson_rand= np.clip(Poisson_rand,0.01,100.0) for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - input.b = self.UpdVar.B.values[i,k] - input.b_mean = GMV.B.values[k] - input.w = self.UpdVar.W.values[i,k] - input.dw = (self.UpdVar.W.values[i,k+1]-self.UpdVar.W.values[i,k-1])/self.Gr.dz/2.0 - input.z = self.Gr.z[k] - input.af = self.UpdVar.Area.values[i,k] - input.tke = self.EnvVar.TKE.values[k] - input.ml = self.mixing_length[k] - input.qt_env = self.EnvVar.QT.values[k] - input.ql_env = self.EnvVar.QL.values[k] - input.T_env = self.EnvVar.T.values[k] - input.H_env = self.EnvVar.H.values[k] - input.w_env = self.EnvVar.W.values[k] - input.dw_env = (self.EnvVar.W.values[k+1]-self.EnvVar.W.values[k-1])/self.Gr.dz/2.0 - input.H_up = self.UpdVar.H.values[i,k] - input.qt_up = self.UpdVar.QT.values[i,k] - input.ql_up = self.UpdVar.QL.values[i,k] - input.T_up = self.UpdVar.T.values[i,k] - input.p0 = self.Ref.p0[k] - input.alpha0 = self.Ref.alpha0[k] - input.tke_ed_coeff = self.tke_ed_coeff - input.Poisson_rand = Poisson_rand[k]/10.0 - input.L = 20000.0 # need to define the scale of the GCM grid resolution - ret = self.entr_detr_fp(input) - self.entr_sc[i,k] = ret.entr_sc * self.entrainment_factor - self.detr_sc[i,k] = ret.detr_sc * self.detrainment_factor + with nogil: + input.b = self.UpdVar.B.values[i,k] + input.b_mean = GMV.B.values[k] + input.w = self.UpdVar.W.values[i,k] + input.dw = (self.UpdVar.W.values[i,k+1]-self.UpdVar.W.values[i,k-1])/self.Gr.dz/2.0 + input.z = self.Gr.z[k] + input.af = self.UpdVar.Area.values[i,k] + input.tke = self.EnvVar.TKE.values[k] + input.ml = self.mixing_length[k] + input.qt_env = self.EnvVar.QT.values[k] + input.ql_env = self.EnvVar.QL.values[k] + input.T_env = self.EnvVar.T.values[k] + input.H_env = self.EnvVar.H.values[k] + input.w_env = self.EnvVar.W.values[k] + input.dw_env = (self.EnvVar.W.values[k+1]-self.EnvVar.W.values[k-1])/self.Gr.dz/2.0 + input.H_up = self.UpdVar.H.values[i,k] + input.qt_up = self.UpdVar.QT.values[i,k] + input.ql_up = self.UpdVar.QL.values[i,k] + input.T_up = self.UpdVar.T.values[i,k] + input.p0 = self.Ref.p0[k] + input.alpha0 = self.Ref.alpha0[k] + input.tke_ed_coeff = self.tke_ed_coeff + input.Poisson_rand = Poisson_rand[k]/10.0 + input.L = 20000.0 # need to define the scale of the GCM grid resolution + ret = self.entr_detr_fp(input) + self.entr_sc[i,k] = ret.entr_sc * self.entrainment_factor + self.detr_sc[i,k] = ret.detr_sc * self.detrainment_factor return @@ -788,7 +789,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): eos_struct sa double qt_var, h_var - #with nogil: + for i in xrange(self.n_updrafts): self.entr_sc[i,gw] = 2.0 * dzi self.detr_sc[i,gw] = 0.0 @@ -820,9 +821,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): &self.UpdVar.H.values[i,gw], i, gw) for k in range(gw+1, self.Gr.nzg-gw): - #print '903', self.UpdVar.Area.values[i,gw], self.UpdVar.W.values[i,gw] self.upwind_integration(self.UpdVar.Area, self.UpdVar.Area, k, i, 1.0) - print self.UpdVar.Area.new[i,k] if self.UpdVar.Area.new[i,k] >= self.minimum_area: self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, k, i, self.EnvVar.W.values[k]) self.upwind_integration(self.UpdVar.Area, self.UpdVar.H, k, i, self.EnvVar.H.values[k]) @@ -852,7 +851,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdMicro.compute_sources(self.UpdVar) self.UpdMicro.update_updraftvars(self.UpdVar) - self.UpdVar.H.set_bcs(self.Gr) + self.UpdVar.H.set_bcs(self.Gr) # do we need to set BC for a ad w as well ? self.UpdVar.QT.set_bcs(self.Gr) return @@ -892,33 +891,21 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): var_k = var.values[i,k] var_km = var.values[i,k-1] + with nogil: + if self.UpdVar.W.values[i,k]<0: + adv = (self.Ref.rho0[k+1] * area.values[i,k+1] * self.UpdVar.W.values[i,k+1] * var_kp + - self.Ref.rho0[k] *area.values[i,k] * self.UpdVar.W.values[i,k] * var_k )* dzi + exch = (self.Ref.rho0[k] * area.values[i,k] * self.UpdVar.W.values[i,k] + * (-self.entr_sc[i,k] * env_var + self.detr_sc[i,k] * var_k )) + else: + adv = (self.Ref.rho0[k] * area.values[i,k] * self.UpdVar.W.values[i,k] * var_k + - self.Ref.rho0[k-1] * area.values[i,k-1] * self.UpdVar.W.values[i,k-1] * var_km)* dzi + exch = (self.Ref.rho0[k] * area.values[i,k] * self.UpdVar.W.values[i,k] + * (self.entr_sc[i,k] * env_var - self.detr_sc[i,k] * var_k )) - if self.UpdVar.W.values[i,k]<0: - adv = (self.Ref.rho0[k+1] * area.values[i,k+1] * self.UpdVar.W.values[i,k+1] * var_kp - - self.Ref.rho0[k] *area.values[i,k] * self.UpdVar.W.values[i,k] * var_k )* dzi - exch = (self.Ref.rho0[k] * area.values[i,k] * self.UpdVar.W.values[i,k] - * (-self.entr_sc[i,k] * env_var + self.detr_sc[i,k] * var_k )) - else: - adv = (self.Ref.rho0[k] * area.values[i,k] * self.UpdVar.W.values[i,k] * var_k - - self.Ref.rho0[k-1] * area.values[i,k-1] * self.UpdVar.W.values[i,k-1] * var_km)* dzi - exch = (self.Ref.rho0[k] * area.values[i,k] * self.UpdVar.W.values[i,k] - * (self.entr_sc[i,k] * env_var - self.detr_sc[i,k] * var_k )) - - #print adv, exch, press, buoy, var1new, dti_ - #print var1.name, var2.name , k , i, env_var - - self.updraft_pressure_sink[i,k] = press - if area_new== 0.0: - print var.name, k - plt.figure() - plt.show() - var.new[i,k] = (self.Ref.rho0[k] * area.values[i,k] * var_k * dti_ -adv + exch + buoy + press)\ - /(self.Ref.rho0[k] * area_new * dti_) - print var.new[i,k], var_k , adv , exch ,buoy , press - - # plt.figure() - # plt.show() - + self.updraft_pressure_sink[i,k] = press + var.new[i,k] = (self.Ref.rho0[k] * area.values[i,k] * var_k * dti_ -adv + exch + buoy + press)\ + /(self.Ref.rho0[k] * area_new * dti_) # After updating the updraft variables themselves: # 1. compute the mass fluxes (currently not stored as class members, probably will want to do this @@ -1216,13 +1203,13 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): z = self.Gr.z[k] GMV.TKE.values[k] = ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) - #with nogil: - for k in xrange(self.Gr.nzg): - z = self.Gr.z[k] - # need to rethink of how to initilize the covarinace profiles - for nowmI took the TKE profile - GMV.Hvar.values[k] = GMV.Hvar.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) - GMV.QTvar.values[k] = GMV.QTvar.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) - GMV.HQTcov.values[k] = GMV.HQTcov.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) + with nogil: + for k in xrange(self.Gr.nzg): + z = self.Gr.z[k] + # need to rethink of how to initilize the covarinace profiles - for nowmI took the TKE profile + GMV.Hvar.values[k] = GMV.Hvar.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) + GMV.QTvar.values[k] = GMV.QTvar.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) + GMV.HQTcov.values[k] = GMV.HQTcov.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) self.reset_surface_tke(GMV, Case) self.reset_surface_covariance(GMV, Case) # double check this should be here - it was not in the orignal covariance branch self.compute_mixing_length(Case.Sur.obukhov_length, GMV) @@ -1261,20 +1248,21 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double dv_high = 0.0 double var1_low, var2_low double tke_factor = 1.0 - #with nogil: + for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - var1_low = var1_high - var2_low = var2_high - du_low = du_high - dv_low = dv_high if Covar.name == 'TKE': du_high = (GMV.U.values[k+1] - GMV.U.values[k-1]) * self.Gr.dzi dv_high = (GMV.V.values[k+1] - GMV.V.values[k-1]) * self.Gr.dzi tke_factor = 0.5 - var1_high = (EnvVar1[k+1] - EnvVar1[k-1]) * self.Gr.dzi - var2_high = (EnvVar2[k+1] - EnvVar2[k-1]) * self.Gr.dzi - Covar.shear[k] = tke_factor*2.0*(self.Ref.rho0[k] * (1.0-self.UpdVar.Area.bulkvalues[k]) * self.KH.values[k] * - (var1_high*var2_high + pow(du_high,2.0) + pow(dv_high,2.0))) + with nogil: + var1_low = var1_high + var2_low = var2_high + du_low = du_high + dv_low = dv_high + var1_high = (EnvVar1[k+1] - EnvVar1[k-1]) * self.Gr.dzi + var2_high = (EnvVar2[k+1] - EnvVar2[k-1]) * self.Gr.dzi + Covar.shear[k] = tke_factor*2.0*(self.Ref.rho0[k] * (1.0-self.UpdVar.Area.bulkvalues[k]) * self.KH.values[k] * + (var1_high*var2_high + pow(du_high,2.0) + pow(dv_high,2.0))) return cdef void compute_covariance_dissipation(self, EDMF_Environment.EnvironmentVariable_m2 Covar): @@ -1283,36 +1271,37 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double m Py_ssize_t k - #with nogil: - for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - Covar[k] = (self.Ref.rho0[k] * (1.0-self.UpdVar.Area.bulkvalues[k]) * Covar[k] - *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0) * self.tke_diss_coeff) + with nogil: + for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): + Covar.values[k] = (self.Ref.rho0[k] * (1.0-self.UpdVar.Area.bulkvalues[k]) * Covar.values[k] + *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0) * self.tke_diss_coeff) return - #cdef void compute_covariance_entr(self, Covar, UpdVar1, UpdVar2, EnvVar1, EnvVar2): cdef void compute_covariance_entr(self, EDMF_Environment.EnvironmentVariable_m2 Covar, EDMF_Updrafts.UpdraftVariable UpdVar1, EDMF_Updrafts.UpdraftVariable UpdVar2, EDMF_Environment.EnvironmentVariable EnvVar1, EDMF_Environment.EnvironmentVariable_m2 EnvVar2): cdef: Py_ssize_t i, k - - #with nogil: - for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - Covar.entr_gain[k] = 0.0 - for i in xrange(self.n_updrafts): - Covar.entr_gain[k] += self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.detr_sc[i,k] * \ - (UpdVar1.values[i,k] - EnvVar1.values[k]) * (UpdVar2.values[i,k] - EnvVar2.values[k]) - Covar.entr_gain[k] *= self.Ref.rho0[k] + double tke_factor = 1.0 + if Covar.name =='TKE': + tke_factor = 0.5 + with nogil: + for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): + Covar.entr_gain[k] = 0.0 + for i in xrange(self.n_updrafts): + Covar.entr_gain[k] += tke_factor*self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.detr_sc[i,k] * \ + (UpdVar1.values[i,k] - EnvVar1.values[k]) * (UpdVar2.values[i,k] - EnvVar2.values[k]) + Covar.entr_gain[k] *= self.Ref.rho0[k] return cdef void compute_covariance_detr(self, EDMF_Environment.EnvironmentVariable_m2 Covar): cdef: Py_ssize_t i, k - #with nogil: - for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - Covar.detr_loss[k] = 0.0 - for i in xrange(self.n_updrafts): - Covar.detr_loss[k] += self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.entr_sc[i,k] - Covar.detr_loss[k] *= self.Ref.rho0[k] * Covar.values[k] + with nogil: + for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): + Covar.detr_loss[k] = 0.0 + for i in xrange(self.n_updrafts): + Covar.detr_loss[k] += self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.entr_sc[i,k] + Covar.detr_loss[k] *= self.Ref.rho0[k] * Covar.values[k] return # verfy that everythong from tke is here and unify and cvert to pointers with cdef void @@ -1336,14 +1325,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double [:] ae_old = np.subtract(np.ones((nzg,),dtype=np.double, order='c'), np.sum(self.UpdVar.Area.old,axis=0)) double [:] rho_ae_K_m = np.zeros((nzg,),dtype=np.double, order='c') double D_env = 0.0 - double tke_0_surf,press_k - # missing flux1 and 2 in get_surface_variance double Hvar_gmv_surf = get_surface_variance(Case.Sur.rho_hflux * alpha0LL, Case.Sur.rho_hflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) double QTvar_gmv_surf = get_surface_variance(Case.Sur.rho_qtflux * alpha0LL, Case.Sur.rho_qtflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) double HQTcov_gmv_surf = get_surface_variance(Case.Sur.rho_hflux * alpha0LL, Case.Sur.rho_qtflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) - double Hu, He, QTu, QTe - double Hvar_0_surf, QTvar_0_surf, HQTcov_0_surf + double Var_0_surf with nogil: @@ -1352,11 +1338,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Hu = self.UpdVar.H.bulkvalues[gw] QTu = self.UpdVar.QT.bulkvalues[gw] - # if Covar.name =='TKE': - # GmvCovar.values[gw] = get_surface_tke(Case.Sur.ustar, self.wstar, self.Gr.z[gw], Case.Sur.obukhov_length) - # self.get_env_tke_from_GMV(self.UpdVar.Area, UpdVar1, EnvVar1, Covar, GmvVar1, GmvCovar) - # - # else: GmvCovar.values[gw] = get_surface_variance(Case.Sur.rho_hflux * alpha0LL, Case.Sur.rho_hflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) self.get_env_covar_from_GMV(self.UpdVar.Area, UpdVar1, UpdVar2, EnvVar1, EnvVar2,Covar, &GmvVar1.values[0], &GmvVar2.values[0], &GmvCovar.values[0]) @@ -1368,39 +1349,39 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): #HQTcov_0_surf = self.EnvVar.HQTcov.values[gw] # run tridiagonal solver for Hvar - #with nogil: - for kk in xrange(nz): - k = kk+gw - D_env = 0.0 + with nogil: + for kk in xrange(nz): + k = kk+gw + D_env = 0.0 - for i in xrange(self.n_updrafts): - D_env += self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.entr_sc[i,k] - - a[kk] = (- rho_ae_K_m[k-1] * dzi * dzi ) - b[kk] = (self.Ref.rho0[k] * ae[k] * dti - self.Ref.rho0[k] * ae[k] * self.EnvVar.W.values[k] * dzi - + rho_ae_K_m[k] * dzi * dzi + rho_ae_K_m[k-1] * dzi * dzi - + D_env - + self.Ref.rho0[k] * ae[k] * self.tke_diss_coeff - *sqrt(fmax(self.EnvVar.TKE.values[k],0))/fmax(self.mixing_length[k],1.0) ) - c[kk] = (self.Ref.rho0[k+1] * ae[k+1] * self.EnvVar.W.values[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) - x[kk] = (self.Ref.rho0[k] * ae_old[k] * Covar.values[k] * dti - + Covar.press[k] + Covar.buoy[k] + Covar.shear[k] + Covar.entr_gain[k]) # - - a[0] = 0.0 - b[0] = 1.0 - c[0] = 0.0 - x[0] = Var_0_surf - - b[nz-1] += c[nz-1] - c[nz-1] = 0.0 + for i in xrange(self.n_updrafts): + D_env += self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.entr_sc[i,k] + + a[kk] = (- rho_ae_K_m[k-1] * dzi * dzi ) + b[kk] = (self.Ref.rho0[k] * ae[k] * dti - self.Ref.rho0[k] * ae[k] * self.EnvVar.W.values[k] * dzi + + rho_ae_K_m[k] * dzi * dzi + rho_ae_K_m[k-1] * dzi * dzi + + D_env + + self.Ref.rho0[k] * ae[k] * self.tke_diss_coeff + *sqrt(fmax(self.EnvVar.TKE.values[k],0))/fmax(self.mixing_length[k],1.0) ) + c[kk] = (self.Ref.rho0[k+1] * ae[k+1] * self.EnvVar.W.values[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) + x[kk] = (self.Ref.rho0[k] * ae_old[k] * Covar.values[k] * dti + + Covar.press[k] + Covar.buoy[k] + Covar.shear[k] + Covar.entr_gain[k]) # + + a[0] = 0.0 + b[0] = 1.0 + c[0] = 0.0 + x[0] = Var_0_surf + + b[nz-1] += c[nz-1] + c[nz-1] = 0.0 tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) - #with nogil: - for kk in xrange(nz): - k = kk + gw - Covar.values[k] = x[kk] - GmvCovar.values[k] = (ae[k] * (Covar.values[k] + (EnvVar1.values[k]-GmvVar1.values[k]) * (EnvVar2.values[k]-GmvVar2.values[k])) - + self.UpdVar.Area.bulkvalues[k] * (UpdVar1.bulkvalues[k]-GmvVar1.values[k]) * (UpdVar2.bulkvalues[k]-GmvVar2.values[k])) + with nogil: + for kk in xrange(nz): + k = kk + gw + Covar.values[k] = x[kk] + GmvCovar.values[k] = (ae[k] * (Covar.values[k] + (EnvVar1.values[k]-GmvVar1.values[k]) * (EnvVar2.values[k]-GmvVar2.values[k])) + + self.UpdVar.Area.bulkvalues[k] * (UpdVar1.bulkvalues[k]-GmvVar1.values[k]) * (UpdVar2.bulkvalues[k]-GmvVar2.values[k])) self.get_GMV_CoVar(self.UpdVar.Area, UpdVar1, UpdVar2, EnvVar1, EnvVar2, Covar, &GmvVar1.values[0], &GmvVar2.values[0], &GmvCovar.values[0]) From fe81ae86c4d10f47d285b73b5c4170165bca8759 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Sat, 11 Aug 2018 14:42:26 -0700 Subject: [PATCH 045/136] running version --- EDMF_Environment.pxd | 13 ++++--- EDMF_Environment.pyx | 5 +-- Turbulence_PrognosticTKE.pxd | 16 ++++----- Turbulence_PrognosticTKE.pyx | 67 ++++++++++++++++++------------------ 4 files changed, 51 insertions(+), 50 deletions(-) diff --git a/EDMF_Environment.pxd b/EDMF_Environment.pxd index 55d49ba3..b11c1543 100644 --- a/EDMF_Environment.pxd +++ b/EDMF_Environment.pxd @@ -13,14 +13,13 @@ cdef class EnvironmentVariable: str units -cdef class EnvironmentVariable_m2: +cdef class EnvironmentVariable_2m: cdef: double [:] values double [:] dissipation double [:] shear double [:] entr_gain double [:] detr_loss - double [:] buoy_src double [:] press double [:] buoy str loc @@ -38,12 +37,12 @@ cdef class EnvironmentVariables: EnvironmentVariable THL EnvironmentVariable T EnvironmentVariable B - EnvironmentVariable TKE - EnvironmentVariable Hvar - EnvironmentVariable QTvar - EnvironmentVariable HQTcov + EnvironmentVariable_2m TKE + EnvironmentVariable_2m Hvar + EnvironmentVariable_2m QTvar + EnvironmentVariable_2m HQTcov EnvironmentVariable CF - EnvironmentVariable THVvar + EnvironmentVariable_2m THVvar Grid Gr bint use_tke bint use_scalar_var diff --git a/EDMF_Environment.pyx b/EDMF_Environment.pyx index d1ddde7f..f5dc706a 100644 --- a/EDMF_Environment.pyx +++ b/EDMF_Environment.pyx @@ -13,6 +13,7 @@ from Variables cimport VariableDiagnostic, GridMeanVariables from libc.math cimport fmax, fmin, sqrt, exp, erf from thermodynamic_functions cimport * import pylab as plt + cdef class EnvironmentVariable: def __init__(self, nz, loc, kind, name, units): self.values = np.zeros((nz,),dtype=np.double, order='c') @@ -32,7 +33,7 @@ cdef class EnvironmentVariable_2m: self.dissipation = np.zeros((nz,),dtype=np.double, order='c') self.entr_gain = np.zeros((nz,),dtype=np.double, order='c') self.detr_loss = np.zeros((nz,),dtype=np.double, order='c') - self.buoy_src = np.zeros((nz,),dtype=np.double, order='c') + self.buoy = np.zeros((nz,),dtype=np.double, order='c') self.press = np.zeros((nz,),dtype=np.double, order='c') self.shear = np.zeros((nz,),dtype=np.double, order='c') # think of a more general name as "mean_grad_production" or something if loc != 'full': @@ -47,7 +48,7 @@ cdef class EnvironmentVariable_2m: cdef class EnvironmentVariables: - def __init__(self, namelist, Grid Gr ): + def __init__(self, namelist, Grid Gr): cdef Py_ssize_t nz = Gr.nzg self.Gr = Gr diff --git a/Turbulence_PrognosticTKE.pxd b/Turbulence_PrognosticTKE.pxd index d34de428..e3833666 100644 --- a/Turbulence_PrognosticTKE.pxd +++ b/Turbulence_PrognosticTKE.pxd @@ -104,13 +104,13 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cpdef initialize_covariance(self, GridMeanVariables GMV, CasesBase Case) cpdef compute_tke_buoy(self, GridMeanVariables GMV) cpdef compute_tke_pressure(self) - cdef void compute_covariance_detr(self, EDMF_Environment.EnvironmentVariable_m2 Covar) - cdef void compute_covariance_entr(self, EDMF_Environment.EnvironmentVariable_m2 Covar, EDMF_Updrafts.UpdraftVariable UpdVar1, - EDMF_Updrafts.UpdraftVariable UpdVar2, EDMF_Environment.EnvironmentVariable EnvVar1, EDMF_Environment.EnvironmentVariable_m2 EnvVar2) - cdef void compute_covariance_dissipation(self, EDMF_Environment.EnvironmentVariable_m2 Covar) - cdef void compute_covariance_shear(self,GridMeanVariables GMV, EDMF_Environment.EnvironmentVariable_m2 Covar, double *UpdVar1, double *UpdVar2, double *EnvVar1, double *EnvVar2) + cdef void compute_covariance_detr(self, EDMF_Environment.EnvironmentVariable_2m Covar) + cdef void compute_covariance_entr(self, EDMF_Environment.EnvironmentVariable_2m Covar, EDMF_Updrafts.UpdraftVariable UpdVar1, + EDMF_Updrafts.UpdraftVariable UpdVar2, EDMF_Environment.EnvironmentVariable EnvVar1, EDMF_Environment.EnvironmentVariable EnvVar2) + cdef void compute_covariance_dissipation(self, EDMF_Environment.EnvironmentVariable_2m Covar) + cdef void compute_covariance_shear(self,GridMeanVariables GMV, EDMF_Environment.EnvironmentVariable_2m Covar, double *UpdVar1, double *UpdVar2, double *EnvVar1, double *EnvVar2) cdef void update_covariance_ED(self, GridMeanVariables GMV, CasesBase Case,TimeStepping TS, VariablePrognostic GmvVar1, VariablePrognostic GmvVar2, - VariablePrognostic GmvCovar, EDMF_Environment.EnvironmentVariable_m2 Covar, EDMF_Environment.EnvironmentVariable EnvVar1, EDMF_Environment.EnvironmentVariable EnvVar2, + VariableDiagnostic GmvCovar, EDMF_Environment.EnvironmentVariable_2m Covar, EDMF_Environment.EnvironmentVariable EnvVar1, EDMF_Environment.EnvironmentVariable EnvVar2, EDMF_Updrafts.UpdraftVariable UpdVar1, EDMF_Updrafts.UpdraftVariable UpdVar2) cpdef update_GMV_diagnostics(self, GridMeanVariables GMV) # cdef get_env_tke_from_GMV(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable wu, @@ -119,11 +119,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cdef get_GMV_CoVar(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable phi_u, EDMF_Updrafts.UpdraftVariable psi_u, EDMF_Environment.EnvironmentVariable phi_e, EDMF_Environment.EnvironmentVariable psi_e, - EDMF_Environment.EnvironmentVariable covar_e, + EDMF_Environment.EnvironmentVariable_2m covar_e, double *gmv_phi, double *gmv_psi, double *gmv_covar) cdef get_env_covar_from_GMV(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable phi_u, EDMF_Updrafts.UpdraftVariable psi_u, EDMF_Environment.EnvironmentVariable phi_e, EDMF_Environment.EnvironmentVariable psi_e, - EDMF_Environment.EnvironmentVariable covar_e, + EDMF_Environment.EnvironmentVariable_2m covar_e, double *gmv_phi, double *gmv_psi, double *gmv_covar) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 57c97bd2..92b1af24 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -200,29 +200,29 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Stats.add_profile('total_flux_qt') Stats.add_profile('massflux_tke') Stats.add_profile('mixing_length') - # Stats.add_profile('tke_buoy') - # Stats.add_profile('tke_dissipation') - # Stats.add_profile('tke_entr_gain') - # Stats.add_profile('tke_detr_loss') - # Stats.add_profile('tke_shear') - # Stats.add_profile('tke_pressure') + Stats.add_profile('tke_buoy') + Stats.add_profile('tke_dissipation') + Stats.add_profile('tke_entr_gain') + Stats.add_profile('tke_detr_loss') + Stats.add_profile('tke_shear') + Stats.add_profile('tke_pressure') Stats.add_profile('updraft_qt_precip') Stats.add_profile('updraft_thetal_precip') #Stats.add_profile('Hvar') #Stats.add_profile('QTvar') #Stats.add_profile('HQTcov') - # Stats.add_profile('Hvar_dissipation') - # Stats.add_profile('QTvar_dissipation') - # Stats.add_profile('HQTcov_dissipation') - # Stats.add_profile('Hvar_entr_gain') - # Stats.add_profile('QTvar_entr_gain') - # Stats.add_profile('Hvar_detr_loss') - # Stats.add_profile('QTvar_detr_loss') - # Stats.add_profile('HQTcov_detr_loss') - # Stats.add_profile('HQTcov_entr_gain') - # Stats.add_profile('Hvar_shear') - # Stats.add_profile('QTvar_shear') - # Stats.add_profile('HQTcov_shear') + Stats.add_profile('Hvar_dissipation') + Stats.add_profile('QTvar_dissipation') + Stats.add_profile('HQTcov_dissipation') + Stats.add_profile('Hvar_entr_gain') + Stats.add_profile('QTvar_entr_gain') + Stats.add_profile('Hvar_detr_loss') + Stats.add_profile('QTvar_detr_loss') + Stats.add_profile('HQTcov_detr_loss') + Stats.add_profile('HQTcov_entr_gain') + Stats.add_profile('Hvar_shear') + Stats.add_profile('QTvar_shear') + Stats.add_profile('HQTcov_shear') return @@ -277,15 +277,15 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # can these pointer function called inside the write command , or should they be called before it? self.compute_covariance_dissipation(self.EnvVar.TKE) - Stats.write_profile('TKE_dissipation', self.EnvVar.TKE.dissipation) + Stats.write_profile('tke_dissipation', self.EnvVar.TKE.dissipation[kmin:kmax]) self.compute_covariance_dissipation(self.EnvVar.Hvar) - Stats.write_profile('Hvar_dissipation', self.EnvVar.Hvar.dissipation) + Stats.write_profile('Hvar_dissipation', self.EnvVar.Hvar.dissipation[kmin:kmax]) self.compute_covariance_dissipation(self.EnvVar.QTvar) - Stats.write_profile('Hvar_dissipation', self.EnvVar.QTvar.dissipation) + Stats.write_profile('Hvar_dissipation', self.EnvVar.QTvar.dissipation[kmin:kmax]) self.compute_covariance_dissipation(self.EnvVar.HQTcov) - Stats.write_profile('Hvar_dissipation', self.EnvVar.HQTcov.dissipation) + Stats.write_profile('Hvar_dissipation', self.EnvVar.HQTcov.dissipation[kmin:kmax]) - Stats.write_profile('TKE_entr_gain', self.EnvVar.TKE.entr_gain[kmin:kmax]) + Stats.write_profile('tke_entr_gain', self.EnvVar.TKE.entr_gain[kmin:kmax]) Stats.write_profile('Hvar_entr_gain', self.EnvVar.Hvar.entr_gain[kmin:kmax]) Stats.write_profile('QTvar_entr_gain', self.EnvVar.QTvar.entr_gain[kmin:kmax]) Stats.write_profile('HQTcov_entr_gain', self.EnvVar.HQTcov.entr_gain[kmin:kmax]) @@ -293,11 +293,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.compute_covariance_detr(self.EnvVar.Hvar) self.compute_covariance_detr(self.EnvVar.QTvar) self.compute_covariance_detr(self.EnvVar.HQTcov) - Stats.write_profile('TKE_detr_loss', self.EnvVar.TKE.detr_loss[kmin:kmax]) + Stats.write_profile('tke_detr_loss', self.EnvVar.TKE.detr_loss[kmin:kmax]) Stats.write_profile('Hvar_detr_loss', self.EnvVar.Hvar.detr_loss[kmin:kmax]) Stats.write_profile('QTvar_detr_loss', self.EnvVar.QTvar.detr_loss[kmin:kmax]) Stats.write_profile('HQTcov_detr_loss', self.EnvVar.HQTcov.detr_loss[kmin:kmax]) - Stats.write_profile('TKE_shear', self.EnvVar.TKE.shear[kmin:kmax]) + Stats.write_profile('tke_shear', self.EnvVar.TKE.shear[kmin:kmax]) Stats.write_profile('Hvar_shear', self.EnvVar.Hvar.shear[kmin:kmax]) Stats.write_profile('QTvar_shear', self.EnvVar.QTvar.shear[kmin:kmax]) Stats.write_profile('HQTcov_shear', self.EnvVar.HQTcov.shear[kmin:kmax]) @@ -657,7 +657,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cdef get_GMV_CoVar(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable phi_u, EDMF_Updrafts.UpdraftVariable psi_u, EDMF_Environment.EnvironmentVariable phi_e, EDMF_Environment.EnvironmentVariable psi_e, - EDMF_Environment.EnvironmentVariable covar_e, + EDMF_Environment.EnvironmentVariable_2m covar_e, double *gmv_phi, double *gmv_psi, double *gmv_covar): cdef: Py_ssize_t i,k @@ -681,7 +681,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cdef get_env_covar_from_GMV(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable phi_u, EDMF_Updrafts.UpdraftVariable psi_u, EDMF_Environment.EnvironmentVariable phi_e, EDMF_Environment.EnvironmentVariable psi_e, - EDMF_Environment.EnvironmentVariable covar_e, + EDMF_Environment.EnvironmentVariable_2m covar_e, double *gmv_phi, double *gmv_psi, double *gmv_covar): cdef: Py_ssize_t i,k @@ -1185,6 +1185,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.update_covariance_ED(GMV, Case,TS, GMV.QT,GMV.QT,GMV.QTvar, self.EnvVar.QTvar, self.EnvVar.QT, self.EnvVar.QT, self.UpdVar.QT, self.UpdVar.QT) self.update_covariance_ED(GMV, Case,TS, GMV.H, GMV.H, GMV.HQTcov, self.EnvVar.HQTcov, self.EnvVar.H, self.EnvVar.QT, self.UpdVar.H, self.UpdVar.QT) + else: self.initialize_covariance(GMV, Case) return @@ -1239,7 +1240,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): return - cdef void compute_covariance_shear(self,GridMeanVariables GMV, EDMF_Environment.EnvironmentVariable_m2 Covar, double *UpdVar1, double *UpdVar2, double *EnvVar1, double *EnvVar2): + cdef void compute_covariance_shear(self,GridMeanVariables GMV, EDMF_Environment.EnvironmentVariable_2m Covar, double *UpdVar1, double *UpdVar2, double *EnvVar1, double *EnvVar2): cdef: Py_ssize_t k double var1_high = 0.0 @@ -1265,7 +1266,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): (var1_high*var2_high + pow(du_high,2.0) + pow(dv_high,2.0))) return - cdef void compute_covariance_dissipation(self, EDMF_Environment.EnvironmentVariable_m2 Covar): + cdef void compute_covariance_dissipation(self, EDMF_Environment.EnvironmentVariable_2m Covar): cdef: Py_ssize_t i double m @@ -1277,8 +1278,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0) * self.tke_diss_coeff) return - cdef void compute_covariance_entr(self, EDMF_Environment.EnvironmentVariable_m2 Covar, EDMF_Updrafts.UpdraftVariable UpdVar1, - EDMF_Updrafts.UpdraftVariable UpdVar2, EDMF_Environment.EnvironmentVariable EnvVar1, EDMF_Environment.EnvironmentVariable_m2 EnvVar2): + cdef void compute_covariance_entr(self, EDMF_Environment.EnvironmentVariable_2m Covar, EDMF_Updrafts.UpdraftVariable UpdVar1, + EDMF_Updrafts.UpdraftVariable UpdVar2, EDMF_Environment.EnvironmentVariable EnvVar1, EDMF_Environment.EnvironmentVariable EnvVar2): cdef: Py_ssize_t i, k double tke_factor = 1.0 @@ -1293,7 +1294,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Covar.entr_gain[k] *= self.Ref.rho0[k] return - cdef void compute_covariance_detr(self, EDMF_Environment.EnvironmentVariable_m2 Covar): + cdef void compute_covariance_detr(self, EDMF_Environment.EnvironmentVariable_2m Covar): cdef: Py_ssize_t i, k with nogil: @@ -1306,7 +1307,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # verfy that everythong from tke is here and unify and cvert to pointers with cdef void cdef void update_covariance_ED(self, GridMeanVariables GMV, CasesBase Case,TimeStepping TS, VariablePrognostic GmvVar1, VariablePrognostic GmvVar2, - VariablePrognostic GmvCovar, EDMF_Environment.EnvironmentVariable_m2 Covar, EDMF_Environment.EnvironmentVariable EnvVar1, EDMF_Environment.EnvironmentVariable EnvVar2, + VariableDiagnostic GmvCovar, EDMF_Environment.EnvironmentVariable_2m Covar, EDMF_Environment.EnvironmentVariable EnvVar1, EDMF_Environment.EnvironmentVariable EnvVar2, EDMF_Updrafts.UpdraftVariable UpdVar1, EDMF_Updrafts.UpdraftVariable UpdVar2): cdef: Py_ssize_t k, kk, i From 7070e8faaaa3f3b003fbc55c7c77b38d9bbe7417 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Sat, 11 Aug 2018 15:42:38 -0700 Subject: [PATCH 046/136] .. --- Turbulence_PrognosticTKE.pxd | 1 - Turbulence_PrognosticTKE.pyx | 29 ++++++++++++----------------- 2 files changed, 12 insertions(+), 18 deletions(-) diff --git a/Turbulence_PrognosticTKE.pxd b/Turbulence_PrognosticTKE.pxd index e3833666..7290b373 100644 --- a/Turbulence_PrognosticTKE.pxd +++ b/Turbulence_PrognosticTKE.pxd @@ -90,7 +90,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cpdef update_inversion(self, GridMeanVariables GMV, option) cpdef compute_mixing_length(self, double obukhov_length, GridMeanVariables GMV) cpdef compute_eddy_diffusivities_tke(self, GridMeanVariables GMV, CasesBase Case) - cpdef reset_surface_tke(self, GridMeanVariables GMV, CasesBase Case) cpdef reset_surface_covariance(self, GridMeanVariables GMV, CasesBase Case) cpdef set_updraft_surface_bc(self, GridMeanVariables GMV, CasesBase Case) cpdef decompose_environment(self, GridMeanVariables GMV, whichvals) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 92b1af24..1e41a085 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -302,8 +302,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Stats.write_profile('QTvar_shear', self.EnvVar.QTvar.shear[kmin:kmax]) Stats.write_profile('HQTcov_shear', self.EnvVar.HQTcov.shear[kmin:kmax]) - Stats.write_profile('tke_buoy', self.tke_buoy[kmin:kmax]) - Stats.write_profile('tke_pressure', self.tke_pressure[kmin:kmax]) + Stats.write_profile('tke_buoy', self.EnvVar.TKE.buoy[kmin:kmax]) + Stats.write_profile('tke_pressure', self.EnvVar.TKE.press[kmin:kmax]) return @@ -677,6 +677,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): else: gmv_covar[k] = 0.0 return +# self.get_env_covar_from_GMV(self.UpdVar.Area, UpdVar1, UpdVar2, EnvVar1, EnvVar2,Covar, &GmvVar1.values[0], &GmvVar2.values[0], &GmvCovar.values[0]) cdef get_env_covar_from_GMV(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable phi_u, EDMF_Updrafts.UpdraftVariable psi_u, @@ -1113,7 +1114,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): + (1.0-self.EnvVar.CF.values[k]) * d_alpha_qt_dry) - self.tke_buoy[k] = g / self.Ref.alpha0[k] * ae[k] * self.Ref.rho0[k] \ + self.EnvVar.TKE.buoy[k] = g / self.Ref.alpha0[k] * ae[k] * self.Ref.rho0[k] \ * ( -self.KH.values[k] *grad_thl_plus * d_alpha_thetal_total - self.KH.values[k] * grad_qt_plus * d_alpha_qt_total) return @@ -1127,15 +1128,15 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - self.tke_pressure[k] = 0.0 + self.EnvVar.TKE.press[k] = 0.0 for i in xrange(self.n_updrafts): wu = self.UpdVar.W.values[i,k] we = self.EnvVar.W.values[k] press_buoy= (-1.0 * self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] * self.pressure_buoy_coeff) press_drag = (-1.0 * self.Ref.rho0[k] * sqrt(self.UpdVar.Area.values[i,k]) - * (self.pressure_drag_coeff/self.pressure_plume_spacing* (wu -we)**2.0)) - self.tke_pressure[k] += (we - wu) * (press_buoy + press_drag) + * (self.pressure_drag_coeff/self.pressure_plume_spacing*(wu -we)*fabs(wu -we))) + self.EnvVar.TKE.press[k] += (we - wu) * (press_buoy + press_drag) return cpdef update_GMV_diagnostics(self, GridMeanVariables GMV): @@ -1165,6 +1166,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): if self.similarity_diffusivity: # otherwise, we computed mixing length when we computed self.compute_mixing_length(Case.Sur.obukhov_length, GMV) + self.compute_tke_buoy(GMV) self.compute_covariance_entr(self.EnvVar.TKE, self.UpdVar.W, self.UpdVar.W, self.EnvVar.W, self.EnvVar.W) self.compute_covariance_entr(self.EnvVar.Hvar, self.UpdVar.H, self.UpdVar.H, self.EnvVar.H, self.EnvVar.H) self.compute_covariance_entr(self.EnvVar.QTvar, self.UpdVar.QT, self.UpdVar.QT, self.EnvVar.QT, self.EnvVar.QT) @@ -1174,8 +1176,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.compute_covariance_shear(GMV, self.EnvVar.Hvar, &self.UpdVar.H.values[0,0], &self.UpdVar.H.values[0,0], &self.EnvVar.H.values[0], &self.EnvVar.H.values[0]) self.compute_covariance_shear(GMV, self.EnvVar.QTvar, &self.UpdVar.QT.values[0,0], &self.UpdVar.QT.values[0,0], &self.EnvVar.QT.values[0], &self.EnvVar.QT.values[0]) self.compute_covariance_shear(GMV, self.EnvVar.HQTcov, &self.UpdVar.H.values[0,0], &self.UpdVar.QT.values[0,0], &self.EnvVar.H.values[0], &self.EnvVar.QT.values[0]) - - self.compute_tke_buoy(GMV) self.compute_tke_pressure() self.reset_surface_covariance(GMV, Case) @@ -1211,20 +1211,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): GMV.Hvar.values[k] = GMV.Hvar.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) GMV.QTvar.values[k] = GMV.QTvar.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) GMV.HQTcov.values[k] = GMV.HQTcov.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) - self.reset_surface_tke(GMV, Case) self.reset_surface_covariance(GMV, Case) # double check this should be here - it was not in the orignal covariance branch self.compute_mixing_length(Case.Sur.obukhov_length, GMV) return - cpdef reset_surface_tke(self, GridMeanVariables GMV, CasesBase Case): - GMV.TKE.values[self.Gr.gw] = get_surface_tke(Case.Sur.ustar, - self.wstar, - self.Gr.z[self.Gr.gw], - Case.Sur.obukhov_length) - return - - cpdef reset_surface_covariance(self, GridMeanVariables GMV, CasesBase Case): flux1 = Case.Sur.rho_hflux flux2 = Case.Sur.rho_qtflux @@ -1234,6 +1225,10 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double alpha0LL = self.Ref.alpha0[self.Gr.gw] #double get_surface_variance = get_surface_variance(flux1, flux2 ,ustar, zLL, oblength) + GMV.TKE.values[self.Gr.gw] = get_surface_tke(Case.Sur.ustar, + self.wstar, + self.Gr.z[self.Gr.gw], + Case.Sur.obukhov_length) GMV.Hvar.values[self.Gr.gw] = get_surface_variance(flux1*alpha0LL,flux1*alpha0LL, ustar, zLL, oblength) GMV.QTvar.values[self.Gr.gw] = get_surface_variance(flux2*alpha0LL,flux2*alpha0LL, ustar, zLL, oblength) GMV.HQTcov.values[self.Gr.gw] = get_surface_variance(flux1 * alpha0LL,flux2 * alpha0LL, ustar, zLL, oblength) From 77ab0c102f2937f4c79a658ee8bda60f4f9c596f Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Sat, 11 Aug 2018 15:45:26 -0700 Subject: [PATCH 047/136] .. --- Turbulence_PrognosticTKE.pyx | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index ad4cd619..9e54ac6b 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -717,15 +717,15 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cdef: Py_ssize_t i,k double [:] ae = np.subtract(np.ones((self.Gr.nzg,),dtype=np.double, order='c'),au.bulkvalues) - double interp_w_diff + double w_diff with nogil: for k in xrange(self.Gr.nzg): - interp_w_diff = we.values[k]-gmv_w[k] - gmv_tke[k] = ae[k] * interp_w_diff * interp_w_diff + ae[k] * tke_e.values[k] + w_diff = we.values[k]-gmv_w[k] + gmv_tke[k] = ae[k] * w_diff * w_diff + ae[k] * tke_e.values[k] for i in xrange(self.n_updrafts): - interp_w_diff = wu.values[i,k]-gmv_w[k] - gmv_tke[k] += au.values[i,k] *interp_w_diff * interp_w_diff + w_diff = wu.values[i,k]-gmv_w[k] + gmv_tke[k] += au.values[i,k] *w_diff * w_diff return @@ -736,17 +736,17 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cdef: Py_ssize_t i,k double [:] ae = np.subtract(np.ones((self.Gr.nzg,),dtype=np.double, order='c'),au.bulkvalues) - double interp_w_diff + double w_diff with nogil: for k in xrange(self.Gr.nzg): if ae[k] > 0.0: - interp_w_diff = we.values[k]-gmv_w[k] - tke_e.values[k] = gmv_tke[k] - ae[k] * interp_w_diff * interp_w_diff + w_diff = we.values[k]-gmv_w[k] + tke_e.values[k] = gmv_tke[k] - ae[k] * w_diff * w_diff for i in xrange(self.n_updrafts): - interp_w_diff = wu.values[i,k]-gmv_w[k] - tke_e.values[k] -= au.values[i,k] *interp_w_diff * interp_w_diff + w_diff = wu.values[i,k]-gmv_w[k] + tke_e.values[k] -= au.values[i,k] *w_diff * w_diff tke_e.values[k] = tke_e.values[k]/ae[k] else: tke_e.values[k] = 0.0 @@ -999,7 +999,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Py_ssize_t k, i Py_ssize_t gw = self.Gr.gw double mf_tend_h=0.0, mf_tend_qt=0.0 - double env_h_interp, env_qt_interp + double env_h, env_qt self.massflux_h[:] = 0.0 self.massflux_qt[:] = 0.0 @@ -1016,11 +1016,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for k in xrange(gw, self.Gr.nzg-gw): self.massflux_h[k] = 0.0 self.massflux_qt[k] = 0.0 - env_h_interp = self.EnvVar.H.values[k] - env_qt_interp = self.EnvVar.QT.values[k] + env_h = self.EnvVar.H.values[k] + env_qt = self.EnvVar.QT.values[k] for i in xrange(self.n_updrafts): - self.massflux_h[k] += self.m[i,k] * (self.UpdVar.H.values[i,k] - env_h_interp ) - self.massflux_qt[k] += self.m[i,k] * (self.UpdVar.QT.values[i,k] - env_qt_interp ) + self.massflux_h[k] += self.m[i,k] * (self.UpdVar.H.values[i,k] - env_h ) + self.massflux_qt[k] += self.m[i,k] * (self.UpdVar.QT.values[i,k] - env_qt ) # Compute the mass flux tendencies # Adjust the values of the grid mean variables From a12687cd5a2a11b8929557bfc2cffb71d79c3172 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Sat, 11 Aug 2018 15:45:45 -0700 Subject: [PATCH 048/136] .. --- Turbulence_PrognosticTKE.pyx | 2 -- 1 file changed, 2 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 9e54ac6b..2178667d 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -672,8 +672,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): val2 = self.UpdVar.Area.bulkvalues[k] * val1 self.EnvVar.QT.values[k] = val1 * GMV.QT.values[k] - val2 * self.UpdVar.QT.bulkvalues[k] self.EnvVar.H.values[k] = val1 * GMV.H.values[k] - val2 * self.UpdVar.H.bulkvalues[k] - # Have to account for staggering of W--interpolate area fraction to the "full" grid points - # Assuming GMV.W = 0! self.EnvVar.W.values[k] = -self.UpdVar.Area.bulkvalues[k]/(1.0-self.UpdVar.Area.bulkvalues[k]) * self.UpdVar.W.bulkvalues[k] self.get_GMV_TKE(self.UpdVar.Area,self.UpdVar.W, self.EnvVar.W, self.EnvVar.TKE, From c52dacdb161b710dd904e787cd3b387363f4f31d Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Sat, 11 Aug 2018 16:34:05 -0700 Subject: [PATCH 049/136] .. --- Turbulence_PrognosticTKE.pyx | 60 ++++++++---------------------------- 1 file changed, 13 insertions(+), 47 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 1e41a085..33e5ef35 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -618,7 +618,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): val2 = self.UpdVar.Area.bulkvalues[k] * val1 self.EnvVar.QT.values[k] = val1 * GMV.QT.values[k] - val2 * self.UpdVar.QT.bulkvalues[k] self.EnvVar.H.values[k] = val1 * GMV.H.values[k] - val2 * self.UpdVar.H.bulkvalues[k] - # Have to account for staggering of W--interpolate area fraction to the "full" grid points # Assuming GMV.W = 0! self.EnvVar.W.values[k] = -self.UpdVar.Area.bulkvalues[k]/(1.0-self.UpdVar.Area.bulkvalues[k]) * self.UpdVar.W.bulkvalues[k] @@ -638,7 +637,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.EnvVar.QT.values[k] = val1 * GMV.QT.mf_update[k] - val2 * self.UpdVar.QT.bulkvalues[k] self.EnvVar.H.values[k] = val1 * GMV.H.mf_update[k] - val2 * self.UpdVar.H.bulkvalues[k] - # Have to account for staggering of W # Assuming GMV.W = 0! self.EnvVar.W.values[k] = -self.UpdVar.Area.bulkvalues[k]/(1.0-self.UpdVar.Area.bulkvalues[k]) * self.UpdVar.W.bulkvalues[k] @@ -649,11 +647,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): return - - - - - # Note: this assumes all variables are defined on half levels not full levels (i.e. phi, psi are not w) cdef get_GMV_CoVar(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable phi_u, EDMF_Updrafts.UpdraftVariable psi_u, EDMF_Environment.EnvironmentVariable phi_e, EDMF_Environment.EnvironmentVariable psi_e, @@ -666,18 +659,14 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(self.Gr.nzg): - if ae[k] > 0.0: - phi_diff = phi_e.values[k]-gmv_phi[k] - psi_diff = psi_e.values[k]-gmv_psi[k] - gmv_covar[k] = ae[k] * phi_diff * psi_diff + ae[k] * covar_e.values[k] - for i in xrange(self.n_updrafts): - phi_diff = phi_u.values[i,k]-gmv_phi[k] - psi_diff = psi_u.values[i,k]-gmv_psi[k] - gmv_covar[k] += au.values[i,k] * phi_diff * psi_diff - else: - gmv_covar[k] = 0.0 + phi_diff = phi_e.values[k]-gmv_phi[k] + psi_diff = psi_e.values[k]-gmv_psi[k] + gmv_covar[k] = ae[k] * phi_diff * psi_diff + ae[k] * covar_e.values[k] + for i in xrange(self.n_updrafts): + phi_diff = phi_u.values[i,k]-gmv_phi[k] + psi_diff = psi_u.values[i,k]-gmv_psi[k] + gmv_covar[k] += au.values[i,k] * phi_diff * psi_diff return -# self.get_env_covar_from_GMV(self.UpdVar.Area, UpdVar1, UpdVar2, EnvVar1, EnvVar2,Covar, &GmvVar1.values[0], &GmvVar2.values[0], &GmvCovar.values[0]) cdef get_env_covar_from_GMV(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable phi_u, EDMF_Updrafts.UpdraftVariable psi_u, @@ -696,7 +685,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): psi_diff = psi_e.values[k] - gmv_psi[k] covar_e.values[k] = gmv_covar[k] - ae[k] * phi_diff * psi_diff for i in xrange(self.n_updrafts): - phi_diff = phi_u.values[i,k]-gmv_phi[k] + phi_diff = phi_u.values[i,k] - gmv_phi[k] psi_diff = psi_u.values[i,k] - gmv_psi[k] covar_e.values[k] -= au.values[i,k] * phi_diff * psi_diff covar_e.values[k] = covar_e.values[k]/ae[k] @@ -704,35 +693,12 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): covar_e.values[k] = 0.0 return - # cdef get_env_tke_from_GMV(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable wu, - # EDMF_Environment.EnvironmentVariable we, EDMF_Environment.EnvironmentVariable tke_e, - # double *gmv_w, double *gmv_tke): - # cdef: - # Py_ssize_t i,k - # double [:] ae = np.subtract(np.ones((self.Gr.nzg,),dtype=np.double, order='c'),au.bulkvalues) - # double interp_w_diff - # - # with nogil: - # for k in xrange(self.Gr.nzg): - # if ae[k] > 0.0: - # interp_w_diff = we.values[k]-gmv_w[k] - # tke_e.values[k] = gmv_tke[k] - ae.values[k] * interp_w_diff * interp_w_diff - # - # for i in xrange(self.n_updrafts): - # interp_w_diff = wu.values[i,k]-gmv_w[k] - # tke_e.values[k] -= au.values[i,k] *interp_w_diff * interp_w_diff - # tke_e.values[k] = tke_e.values[k]/ae[k] - # else: - # tke_e.values[k] = 0.0 - # return - cpdef compute_entrainment_detrainment(self, GridMeanVariables GMV, CasesBase Case): cdef: Py_ssize_t k entr_struct ret entr_in_struct input eos_struct sa - #double [:] Poisson_rand double [:] Poisson_rand @@ -920,7 +886,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Py_ssize_t k, i Py_ssize_t gw = self.Gr.gw double mf_tend_h=0.0, mf_tend_qt=0.0 - double env_h_interp, env_qt_interp + double env_h, env_qt self.massflux_h[:] = 0.0 self.massflux_qt[:] = 0.0 @@ -937,11 +903,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for k in xrange(gw, self.Gr.nzg-gw): self.massflux_h[k] = 0.0 self.massflux_qt[k] = 0.0 - env_h_interp = self.EnvVar.H.values[k] - env_qt_interp = self.EnvVar.QT.values[k] + env_h = self.EnvVar.H.values[k] + env_qt = self.EnvVar.QT.values[k] for i in xrange(self.n_updrafts): - self.massflux_h[k] += self.m[i,k] * (self.UpdVar.H.values[i,k] - env_h_interp ) - self.massflux_qt[k] += self.m[i,k] * (self.UpdVar.QT.values[i,k] - env_qt_interp ) + self.massflux_h[k] += self.m[i,k] * (self.UpdVar.H.values[i,k] - env_h ) + self.massflux_qt[k] += self.m[i,k] * (self.UpdVar.QT.values[i,k] - env_qt ) # Compute the mass flux tendencies # Adjust the values of the grid mean variables From bd9390f834adc1db693e646e98ed010d5b291bd9 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Sat, 11 Aug 2018 17:30:16 -0700 Subject: [PATCH 050/136] .. --- Turbulence_PrognosticTKE.pyx | 50 +++++++++++++++--------------------- Variables.pyx | 2 +- 2 files changed, 21 insertions(+), 31 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 33e5ef35..ba6b69fe 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -667,7 +667,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): psi_diff = psi_u.values[i,k]-gmv_psi[k] gmv_covar[k] += au.values[i,k] * phi_diff * psi_diff return - +# self.get_env_covar_from_GMV(self.UpdVar.Area, UpdVar1, UpdVar2, EnvVar1, EnvVar2,Covar, &GmvVar1.values[0], &GmvVar2.values[0], &GmvCovar.values[0] cdef get_env_covar_from_GMV(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable phi_u, EDMF_Updrafts.UpdraftVariable psi_u, EDMF_Environment.EnvironmentVariable phi_e, EDMF_Environment.EnvironmentVariable psi_e, @@ -681,7 +681,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(self.Gr.nzg): if ae[k] > 0.0: - phi_diff = phi_e.values[k]-gmv_phi[k] + phi_diff = phi_e.values[k] - gmv_phi[k] psi_diff = psi_e.values[k] - gmv_psi[k] covar_e.values[k] = gmv_covar[k] - ae[k] * phi_diff * psi_diff for i in xrange(self.n_updrafts): @@ -1266,7 +1266,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Covar.detr_loss[k] *= self.Ref.rho0[k] * Covar.values[k] return -# verfy that everythong from tke is here and unify and cvert to pointers with cdef void cdef void update_covariance_ED(self, GridMeanVariables GMV, CasesBase Case,TimeStepping TS, VariablePrognostic GmvVar1, VariablePrognostic GmvVar2, VariableDiagnostic GmvCovar, EDMF_Environment.EnvironmentVariable_2m Covar, EDMF_Environment.EnvironmentVariable EnvVar1, EDMF_Environment.EnvironmentVariable EnvVar2, EDMF_Updrafts.UpdraftVariable UpdVar1, EDMF_Updrafts.UpdraftVariable UpdVar2): @@ -1279,38 +1278,33 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double dti = TS.dti double alpha0LL = self.Ref.alpha0[self.Gr.gw] double zLL = self.Gr.z[self.Gr.gw] - double [:] a = np.zeros((nz,),dtype=np.double, order='c') # for tridiag solver - double [:] b = np.zeros((nz,),dtype=np.double, order='c') # for tridiag solver - double [:] c = np.zeros((nz,),dtype=np.double, order='c') # for tridiag solver - double [:] x = np.zeros((nz,),dtype=np.double, order='c') # for tridiag solver - double [:] ae = np.subtract(np.ones((nzg,),dtype=np.double, order='c'),self.UpdVar.Area.bulkvalues) # area of environment + double [:] a = np.zeros((nz,),dtype=np.double, order='c') + double [:] b = np.zeros((nz,),dtype=np.double, order='c') + double [:] c = np.zeros((nz,),dtype=np.double, order='c') + double [:] x = np.zeros((nz,),dtype=np.double, order='c') + double [:] ae = np.subtract(np.ones((nzg,),dtype=np.double, order='c'),self.UpdVar.Area.bulkvalues) double [:] ae_old = np.subtract(np.ones((nzg,),dtype=np.double, order='c'), np.sum(self.UpdVar.Area.old,axis=0)) double [:] rho_ae_K_m = np.zeros((nzg,),dtype=np.double, order='c') double D_env = 0.0 - # missing flux1 and 2 in get_surface_variance - double Hvar_gmv_surf = get_surface_variance(Case.Sur.rho_hflux * alpha0LL, Case.Sur.rho_hflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) - double QTvar_gmv_surf = get_surface_variance(Case.Sur.rho_qtflux * alpha0LL, Case.Sur.rho_qtflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) - double HQTcov_gmv_surf = get_surface_variance(Case.Sur.rho_hflux * alpha0LL, Case.Sur.rho_qtflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) - double Var_0_surf - + double Covar_surf with nogil: for k in xrange(1,nzg-1): rho_ae_K_m[k] = 0.5 * (ae[k]*self.KH.values[k]+ ae[k+1]*self.KH.values[k+1]) * self.Ref.rho0[k] - Hu = self.UpdVar.H.bulkvalues[gw] - QTu = self.UpdVar.QT.bulkvalues[gw] - GmvCovar.values[gw] = get_surface_variance(Case.Sur.rho_hflux * alpha0LL, Case.Sur.rho_hflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) - self.get_env_covar_from_GMV(self.UpdVar.Area, UpdVar1, UpdVar2, EnvVar1, EnvVar2,Covar, &GmvVar1.values[0], &GmvVar2.values[0], &GmvCovar.values[0]) + if GmvCovar.name=='tke': + GmvCovar.values[gw] =get_surface_tke(Case.Sur.ustar, self.wstar, self.Gr.z[gw], Case.Sur.obukhov_length) + elif GmvCovar.name=='thetal_var': + GmvCovar.values[gw] = get_surface_variance(Case.Sur.rho_hflux * alpha0LL, Case.Sur.rho_hflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) + elif GmvCovar.name=='qt_var': + GmvCovar.values[gw] = get_surface_variance(Case.Sur.rho_qtflux * alpha0LL, Case.Sur.rho_qtflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) + elif GmvCovar.name=='thetal_qt_covar': + GmvCovar.values[gw] = get_surface_variance(Case.Sur.rho_hflux * alpha0LL, Case.Sur.rho_qtflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) - Var_0_surf = Covar.values[gw] + self.get_env_covar_from_GMV(self.UpdVar.Area, UpdVar1, UpdVar2, EnvVar1, EnvVar2,Covar, &GmvVar1.values[0], &GmvVar2.values[0], &GmvCovar.values[0]) - # BC at the surface - #Hvar_0_surf = self.EnvVar.Hvar.values[gw] - #QTvar_0_surf = self.EnvVar.QTvar.values[gw] - #HQTcov_0_surf = self.EnvVar.HQTcov.values[gw] + Covar_surf = Covar.values[gw] - # run tridiagonal solver for Hvar with nogil: for kk in xrange(nz): k = kk+gw @@ -1332,7 +1326,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): a[0] = 0.0 b[0] = 1.0 c[0] = 0.0 - x[0] = Var_0_surf + x[0] = Covar_surf b[nz-1] += c[nz-1] c[nz-1] = 0.0 @@ -1347,8 +1341,4 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.get_GMV_CoVar(self.UpdVar.Area, UpdVar1, UpdVar2, EnvVar1, EnvVar2, Covar, &GmvVar1.values[0], &GmvVar2.values[0], &GmvCovar.values[0]) - return - - -# compute_covariance_dissipation(self, &self.covariance_dissipation, &self.variable you eed ) -# to use the grid mean variable : VariablePrognostic var, \ No newline at end of file + return \ No newline at end of file diff --git a/Variables.pyx b/Variables.pyx index ee0fe691..fc732a74 100644 --- a/Variables.pyx +++ b/Variables.pyx @@ -137,7 +137,7 @@ cdef class GridMeanVariables: self.U = VariablePrognostic(Gr.nzg, 'full', 'velocity', 'sym','u', 'm/s' ) self.V = VariablePrognostic(Gr.nzg, 'full', 'velocity','sym', 'v', 'm/s' ) # Just leave this zero for now! - self.W = VariablePrognostic(Gr.nzg, 'full', 'velocity','sym', 'v', 'm/s' ) + self.W = VariablePrognostic(Gr.nzg, 'full', 'velocity','sym', 'w', 'm/s' ) # Create thermodynamic variables self.QT = VariablePrognostic(Gr.nzg, 'full', 'scalar','sym', 'qt', 'kg/kg') From 7582e82ac83847a49b4819604f66f516d600e279 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Sat, 11 Aug 2018 19:11:35 -0700 Subject: [PATCH 051/136] fix cov dissipation, bomex simualtions works --- Turbulence_PrognosticTKE.pyx | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index ba6b69fe..ca9fdcb8 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -1162,14 +1162,13 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cdef: Py_ssize_t k double ws= self.wstar, us = Case.Sur.ustar, zs = self.zi, z - self.reset_surface_covariance(GMV, Case) + if ws > 0.0: with nogil: for k in xrange(self.Gr.nzg): z = self.Gr.z[k] GMV.TKE.values[k] = ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) - with nogil: for k in xrange(self.Gr.nzg): z = self.Gr.z[k] @@ -1177,7 +1176,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): GMV.Hvar.values[k] = GMV.Hvar.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) GMV.QTvar.values[k] = GMV.QTvar.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) GMV.HQTcov.values[k] = GMV.HQTcov.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) - self.reset_surface_covariance(GMV, Case) # double check this should be here - it was not in the orignal covariance branch + self.reset_surface_covariance(GMV, Case) self.compute_mixing_length(Case.Sur.obukhov_length, GMV) return @@ -1204,15 +1203,18 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cdef void compute_covariance_shear(self,GridMeanVariables GMV, EDMF_Environment.EnvironmentVariable_2m Covar, double *UpdVar1, double *UpdVar2, double *EnvVar1, double *EnvVar2): cdef: Py_ssize_t k + Py_ssize_t gw = self.Gr.gw + double [:] ae = np.subtract(np.ones((self.Gr.nzg,),dtype=np.double, order='c'),self.UpdVar.Area.bulkvalues) double var1_high = 0.0 double var2_high = 0.0 double du_high = 0.0 double dv_high = 0.0 double var1_low, var2_low + double du_low, dv_low double tke_factor = 1.0 for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - if Covar.name == 'TKE': + if Covar.name == 'tke': du_high = (GMV.U.values[k+1] - GMV.U.values[k-1]) * self.Gr.dzi dv_high = (GMV.V.values[k+1] - GMV.V.values[k-1]) * self.Gr.dzi tke_factor = 0.5 @@ -1223,7 +1225,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): dv_low = dv_high var1_high = (EnvVar1[k+1] - EnvVar1[k-1]) * self.Gr.dzi var2_high = (EnvVar2[k+1] - EnvVar2[k-1]) * self.Gr.dzi - Covar.shear[k] = tke_factor*2.0*(self.Ref.rho0[k] * (1.0-self.UpdVar.Area.bulkvalues[k]) * self.KH.values[k] * + Covar.shear[k] = tke_factor*2.0*(self.Ref.rho0[k] * ae[k] * self.KH.values[k] * (var1_high*var2_high + pow(du_high,2.0) + pow(dv_high,2.0))) return @@ -1232,10 +1234,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Py_ssize_t i double m Py_ssize_t k + double [:] ae = np.subtract(np.ones((self.Gr.nzg,),dtype=np.double, order='c'),self.UpdVar.Area.bulkvalues) with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - Covar.values[k] = (self.Ref.rho0[k] * (1.0-self.UpdVar.Area.bulkvalues[k]) * Covar.values[k] + Covar.dissipation[k] = (self.Ref.rho0[k] * ae[k] * Covar.values[k] *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0) * self.tke_diss_coeff) return @@ -1244,7 +1247,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cdef: Py_ssize_t i, k double tke_factor = 1.0 - if Covar.name =='TKE': + if Covar.name =='tke': tke_factor = 0.5 with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): From 5920fb26f85f69af84c16fbd82c9273b16ccbb22 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Sat, 11 Aug 2018 19:33:54 -0700 Subject: [PATCH 052/136] cleanup of prints --- EDMF_Environment.pyx | 40 +++++++++++++------------- EDMF_Updrafts.pyx | 22 +++++++------- Turbulence_PrognosticTKE.pyx | 15 ---------- Variables.pyx | 56 ++++++++++++++++++------------------ 4 files changed, 59 insertions(+), 74 deletions(-) diff --git a/EDMF_Environment.pyx b/EDMF_Environment.pyx index f5dc706a..3241db5f 100644 --- a/EDMF_Environment.pyx +++ b/EDMF_Environment.pyx @@ -18,8 +18,8 @@ cdef class EnvironmentVariable: def __init__(self, nz, loc, kind, name, units): self.values = np.zeros((nz,),dtype=np.double, order='c') self.flux = np.zeros((nz,),dtype=np.double, order='c') - if loc != 'full': - print('Invalid location setting for variable! Must be full') + if loc != 'half': + print('Invalid location setting for variable! Must be half') self.loc = loc if kind != 'scalar' and kind != 'velocity': print ('Invalid kind setting for variable! Must be scalar or velocity') @@ -36,8 +36,8 @@ cdef class EnvironmentVariable_2m: self.buoy = np.zeros((nz,),dtype=np.double, order='c') self.press = np.zeros((nz,),dtype=np.double, order='c') self.shear = np.zeros((nz,),dtype=np.double, order='c') # think of a more general name as "mean_grad_production" or something - if loc != 'full': - print('Invalid location setting for variable! Must be full') + if loc != 'half': + print('Invalid location setting for variable! Must be half') self.loc = loc if kind != 'scalar' and kind != 'velocity': print ('Invalid kind setting for variable! Must be scalar or velocity') @@ -52,18 +52,18 @@ cdef class EnvironmentVariables: cdef Py_ssize_t nz = Gr.nzg self.Gr = Gr - self.W = EnvironmentVariable(nz, 'full', 'velocity', 'w','m/s' ) + self.W = EnvironmentVariable(nz, 'half', 'velocity', 'w','m/s' ) - self.QT = EnvironmentVariable( nz, 'full', 'scalar', 'qt','kg/kg' ) - self.QL = EnvironmentVariable( nz, 'full', 'scalar', 'w','kg/kg' ) + self.QT = EnvironmentVariable( nz, 'half', 'scalar', 'qt','kg/kg' ) + self.QL = EnvironmentVariable( nz, 'half', 'scalar', 'w','kg/kg' ) if namelist['thermodynamics']['thermal_variable'] == 'entropy': - self.H = EnvironmentVariable( nz, 'full', 'scalar', 's','J/kg/K' ) + self.H = EnvironmentVariable( nz, 'half', 'scalar', 's','J/kg/K' ) elif namelist['thermodynamics']['thermal_variable'] == 'thetal': - self.H = EnvironmentVariable( nz, 'full', 'scalar', 'thetal','K' ) - self.THL = EnvironmentVariable(nz, 'full', 'scalar', 'thetal', 'K') - self.T = EnvironmentVariable( nz, 'full', 'scalar', 'temperature','K' ) - self.B = EnvironmentVariable( nz, 'full', 'scalar', 'buoyancy','m^2/s^3' ) - self.CF = EnvironmentVariable(nz, 'full', 'scalar','cloud_fraction', '-') + self.H = EnvironmentVariable( nz, 'half', 'scalar', 'thetal','K' ) + self.THL = EnvironmentVariable(nz, 'half', 'scalar', 'thetal', 'K') + self.T = EnvironmentVariable( nz, 'half', 'scalar', 'temperature','K' ) + self.B = EnvironmentVariable( nz, 'half', 'scalar', 'buoyancy','m^2/s^3' ) + self.CF = EnvironmentVariable(nz, 'half', 'scalar','cloud_fraction', '-') # Determine whether we need 2nd moment variables if namelist['turbulence']['scheme'] == 'EDMF_PrognosticTKE': @@ -85,18 +85,18 @@ cdef class EnvironmentVariables: if self.use_tke: - self.TKE = EnvironmentVariable_2m( nz, 'full', 'scalar', 'tke','m^2/s^2' ) + self.TKE = EnvironmentVariable_2m( nz, 'half', 'scalar', 'tke','m^2/s^2' ) if self.use_scalar_var: - self.QTvar = EnvironmentVariable_2m( nz, 'full', 'scalar', 'qt_var','kg^2/kg^2' ) + self.QTvar = EnvironmentVariable_2m( nz, 'half', 'scalar', 'qt_var','kg^2/kg^2' ) if namelist['thermodynamics']['thermal_variable'] == 'entropy': - self.Hvar = EnvironmentVariable_2m(nz, 'full', 'scalar', 's_var', '(J/kg/K)^2') - self.HQTcov = EnvironmentVariable_2m(nz, 'full', 'scalar', 's_qt_covar', '(J/kg/K)(kg/kg)' ) + self.Hvar = EnvironmentVariable_2m(nz, 'half', 'scalar', 's_var', '(J/kg/K)^2') + self.HQTcov = EnvironmentVariable_2m(nz, 'half', 'scalar', 's_qt_covar', '(J/kg/K)(kg/kg)' ) elif namelist['thermodynamics']['thermal_variable'] == 'thetal': - self.Hvar = EnvironmentVariable_2m(nz, 'full', 'scalar', 'thetal_var', 'K^2') - self.HQTcov = EnvironmentVariable_2m(nz, 'full', 'scalar', 'thetal_qt_covar', 'K(kg/kg)' ) + self.Hvar = EnvironmentVariable_2m(nz, 'half', 'scalar', 'thetal_var', 'K^2') + self.HQTcov = EnvironmentVariable_2m(nz, 'half', 'scalar', 'thetal_qt_covar', 'K(kg/kg)' ) if self.EnvThermo_scheme == 'sommeria_deardorff': - self.THVvar = EnvironmentVariable_2m(nz, 'full', 'scalar', 'thetav_var', 'K^2' ) + self.THVvar = EnvironmentVariable_2m(nz, 'half', 'scalar', 'thetav_var', 'K^2' ) # return diff --git a/EDMF_Updrafts.pyx b/EDMF_Updrafts.pyx index 54d44e0c..c5e6fef1 100644 --- a/EDMF_Updrafts.pyx +++ b/EDMF_Updrafts.pyx @@ -25,8 +25,8 @@ cdef class UpdraftVariable: self.tendencies = np.zeros((nu,nz),dtype=np.double, order='c') self.flux = np.zeros((nu,nz),dtype=np.double, order='c') self.bulkvalues = np.zeros((nz,), dtype=np.double, order = 'c') - if loc != 'full': - print('Invalid location setting for variable! Must be full') + if loc != 'half': + print('Invalid location setting for variable! Must be half') self.loc = loc if kind != 'scalar' and kind != 'velocity': print ('Invalid kind setting for variable! Must be scalar or velocity') @@ -66,18 +66,18 @@ cdef class UpdraftVariables: Py_ssize_t nzg = Gr.nzg Py_ssize_t i, k - self.W = UpdraftVariable(nu, nzg, 'full', 'velocity', 'w','m/s' ) - self.Area = UpdraftVariable(nu, nzg, 'full', 'scalar', 'area_fraction','[-]' ) - self.QT = UpdraftVariable(nu, nzg, 'full', 'scalar', 'qt','kg/kg' ) - self.QL = UpdraftVariable(nu, nzg, 'full', 'scalar', 'ql','kg/kg' ) + self.W = UpdraftVariable(nu, nzg, 'half', 'velocity', 'w','m/s' ) + self.Area = UpdraftVariable(nu, nzg, 'half', 'scalar', 'area_fraction','[-]' ) + self.QT = UpdraftVariable(nu, nzg, 'half', 'scalar', 'qt','kg/kg' ) + self.QL = UpdraftVariable(nu, nzg, 'half', 'scalar', 'ql','kg/kg' ) if namelist['thermodynamics']['thermal_variable'] == 'entropy': - self.H = UpdraftVariable(nu, nzg, 'full', 'scalar', 's','J/kg/K' ) + self.H = UpdraftVariable(nu, nzg, 'half', 'scalar', 's','J/kg/K' ) elif namelist['thermodynamics']['thermal_variable'] == 'thetal': - self.H = UpdraftVariable(nu, nzg, 'full', 'scalar', 'thetal','K' ) + self.H = UpdraftVariable(nu, nzg, 'half', 'scalar', 'thetal','K' ) - self.THL = UpdraftVariable(nu, nzg, 'full', 'scalar', 'thetal', 'K') - self.T = UpdraftVariable(nu, nzg, 'full', 'scalar', 'temperature','K' ) - self.B = UpdraftVariable(nu, nzg, 'full', 'scalar', 'buoyancy','m^2/s^3' ) + self.THL = UpdraftVariable(nu, nzg, 'half', 'scalar', 'thetal', 'K') + self.T = UpdraftVariable(nu, nzg, 'half', 'scalar', 'temperature','K' ) + self.B = UpdraftVariable(nu, nzg, 'half', 'scalar', 'buoyancy','m^2/s^3' ) if namelist['turbulence']['scheme'] == 'EDMF_PrognosticTKE': try: diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index ca9fdcb8..80eef80d 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -137,18 +137,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.tke_shear = np.zeros((Gr.nzg,),dtype=np.double, order='c') self.tke_pressure = np.zeros((Gr.nzg,),dtype=np.double, order='c') - #self.Hvar = np.zeros((Gr.nzg,),dtype=np.double, order='c') - #self.QTvar = np.zeros((Gr.nzg,),dtype=np.double, order='c') - #self.HQTcov = np.zeros((Gr.nzg,),dtype=np.double, order='c') - #self.covariance_dissipation = np.zeros((Gr.nzg,),dtype=np.double, order='c') - #self.covar_entr_gain = np.zeros((Gr.nzg,),dtype=np.double, order='c') - #self.Hvar_detr_loss = np.zeros((Gr.nzg,),dtype=np.double, order='c') - #self.QTvar_detr_loss = np.zeros((Gr.nzg,),dtype=np.double, order='c') - #self.HQTcov_detr_loss = np.zeros((Gr.nzg,),dtype=np.double, order='c') - #self.Hvar_shear = np.zeros((Gr.nzg,),dtype=np.double, order='c') - #self.QTvar_shear = np.zeros((Gr.nzg,),dtype=np.double, order='c') - #self.HQTcov_shear = np.zeros((Gr.nzg,),dtype=np.double, order='c') - # Near-surface BC of updraft area fraction self.area_surface_bc= np.zeros((self.n_updrafts,),dtype=np.double, order='c') self.w_surface_bc= np.zeros((self.n_updrafts,),dtype=np.double, order='c') @@ -208,9 +196,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Stats.add_profile('tke_pressure') Stats.add_profile('updraft_qt_precip') Stats.add_profile('updraft_thetal_precip') - #Stats.add_profile('Hvar') - #Stats.add_profile('QTvar') - #Stats.add_profile('HQTcov') Stats.add_profile('Hvar_dissipation') Stats.add_profile('QTvar_dissipation') Stats.add_profile('HQTcov_dissipation') diff --git a/Variables.pyx b/Variables.pyx index fc732a74..6c5f5c8a 100644 --- a/Variables.pyx +++ b/Variables.pyx @@ -25,9 +25,9 @@ cdef class VariablePrognostic: self.mf_update = np.zeros((nz_tot,),dtype=np.double, order='c') self.tendencies = np.zeros((nz_tot,),dtype=np.double, order='c') # Placement on staggered grid - loc = 'full' - if loc != 'full': - print('Invalid location setting for variable! Must be full') + loc = 'half' + if loc != 'half': + print('Invalid location setting for variable! Must be half') self.loc = loc if kind != 'scalar' and kind != 'velocity': print ('Invalid kind setting for variable! Must be scalar or velocity') @@ -93,9 +93,9 @@ cdef class VariableDiagnostic: # Value at the current timestep self.values = np.zeros((nz_tot,),dtype=np.double, order='c') # Placement on staggered grid - loc = 'full' - if loc != 'full': - print('Invalid location setting for variable! Must be full') + loc = 'half' + if loc != 'half': + print('Invalid location setting for variable! Must be half') self.loc = loc if kind != 'scalar' and kind != 'velocity': print ('Invalid kind setting for variable! Must be scalar or velocity') @@ -134,20 +134,20 @@ cdef class GridMeanVariables: self.Gr = Gr self.Ref = Ref - self.U = VariablePrognostic(Gr.nzg, 'full', 'velocity', 'sym','u', 'm/s' ) - self.V = VariablePrognostic(Gr.nzg, 'full', 'velocity','sym', 'v', 'm/s' ) + self.U = VariablePrognostic(Gr.nzg, 'half', 'velocity', 'sym','u', 'm/s' ) + self.V = VariablePrognostic(Gr.nzg, 'half', 'velocity','sym', 'v', 'm/s' ) # Just leave this zero for now! - self.W = VariablePrognostic(Gr.nzg, 'full', 'velocity','sym', 'w', 'm/s' ) + self.W = VariablePrognostic(Gr.nzg, 'half', 'velocity','sym', 'w', 'm/s' ) # Create thermodynamic variables - self.QT = VariablePrognostic(Gr.nzg, 'full', 'scalar','sym', 'qt', 'kg/kg') + self.QT = VariablePrognostic(Gr.nzg, 'half', 'scalar','sym', 'qt', 'kg/kg') if namelist['thermodynamics']['thermal_variable'] == 'entropy': - self.H = VariablePrognostic(Gr.nzg, 'full', 'scalar', 'sym','s', 'J/kg/K' ) + self.H = VariablePrognostic(Gr.nzg, 'half', 'scalar', 'sym','s', 'J/kg/K' ) self.t_to_prog_fp = t_to_entropy_c self.prog_to_t_fp = eos_first_guess_entropy elif namelist['thermodynamics']['thermal_variable'] == 'thetal': - self.H = VariablePrognostic(Gr.nzg, 'full', 'scalar', 'sym','thetal', 'K') + self.H = VariablePrognostic(Gr.nzg, 'half', 'scalar', 'sym','thetal', 'K') self.t_to_prog_fp = t_to_thetali_c self.prog_to_t_fp = eos_first_guess_thetal else: @@ -157,10 +157,10 @@ cdef class GridMeanVariables: # Diagnostic Variables--same class as the prognostic variables, but we append to diagnostics list # self.diagnostics_list = [] - self.QL = VariableDiagnostic(Gr.nzg,'full', 'scalar','sym', 'ql', 'kg/kg') - self.T = VariableDiagnostic(Gr.nzg,'full', 'scalar','sym', 'temperature', 'K') - self.B = VariableDiagnostic(Gr.nzg, 'full', 'scalar','sym', 'buoyancy', 'm^2/s^3') - self.THL = VariableDiagnostic(Gr.nzg, 'full', 'scalar', 'sym', 'thetal','K') + self.QL = VariableDiagnostic(Gr.nzg,'half', 'scalar','sym', 'ql', 'kg/kg') + self.T = VariableDiagnostic(Gr.nzg,'half', 'scalar','sym', 'temperature', 'K') + self.B = VariableDiagnostic(Gr.nzg, 'half', 'scalar','sym', 'buoyancy', 'm^2/s^3') + self.THL = VariableDiagnostic(Gr.nzg, 'half', 'scalar', 'sym', 'thetal','K') # Determine whether we need 2nd moment variables if namelist['turbulence']['scheme'] == 'EDMF_PrognosticTKE': @@ -188,25 +188,25 @@ cdef class GridMeanVariables: #Now add the 2nd moment variables if self.use_tke: - self.TKE = VariableDiagnostic(Gr.nzg, 'full', 'scalar','sym', 'tke','m^2/s^2' ) - self.QTvar = VariableDiagnostic(Gr.nzg, 'full', 'scalar','sym', 'qt_var','kg^2/kg^2' ) + self.TKE = VariableDiagnostic(Gr.nzg, 'half', 'scalar','sym', 'tke','m^2/s^2' ) + self.QTvar = VariableDiagnostic(Gr.nzg, 'half', 'scalar','sym', 'qt_var','kg^2/kg^2' ) if namelist['thermodynamics']['thermal_variable'] == 'entropy': - self.Hvar = VariableDiagnostic(Gr.nzg, 'full', 'scalar', 'sym', 's_var', '(J/kg/K)^2') - self.HQTcov = VariableDiagnostic(Gr.nzg, 'full', 'scalar', 'sym' ,'s_qt_covar', '(J/kg/K)(kg/kg)' ) + self.Hvar = VariableDiagnostic(Gr.nzg, 'half', 'scalar', 'sym', 's_var', '(J/kg/K)^2') + self.HQTcov = VariableDiagnostic(Gr.nzg, 'half', 'scalar', 'sym' ,'s_qt_covar', '(J/kg/K)(kg/kg)' ) elif namelist['thermodynamics']['thermal_variable'] == 'thetal': - self.Hvar = VariableDiagnostic(Gr.nzg, 'full', 'scalar', 'sym' ,'thetal_var', 'K^2') - self.HQTcov = VariableDiagnostic(Gr.nzg, 'full', 'scalar','sym' ,'thetal_qt_covar', 'K(kg/kg)' ) + self.Hvar = VariableDiagnostic(Gr.nzg, 'half', 'scalar', 'sym' ,'thetal_var', 'K^2') + self.HQTcov = VariableDiagnostic(Gr.nzg, 'half', 'scalar','sym' ,'thetal_qt_covar', 'K(kg/kg)' ) if self.use_scalar_var: - self.QTvar = VariableDiagnostic(Gr.nzg, 'full', 'scalar','sym', 'qt_var','kg^2/kg^2' ) + self.QTvar = VariableDiagnostic(Gr.nzg, 'half', 'scalar','sym', 'qt_var','kg^2/kg^2' ) if namelist['thermodynamics']['thermal_variable'] == 'entropy': - self.Hvar = VariableDiagnostic(Gr.nzg, 'full', 'scalar', 'sym', 's_var', '(J/kg/K)^2') - self.HQTcov = VariableDiagnostic(Gr.nzg, 'full', 'scalar', 'sym' ,'s_qt_covar', '(J/kg/K)(kg/kg)' ) + self.Hvar = VariableDiagnostic(Gr.nzg, 'half', 'scalar', 'sym', 's_var', '(J/kg/K)^2') + self.HQTcov = VariableDiagnostic(Gr.nzg, 'half', 'scalar', 'sym' ,'s_qt_covar', '(J/kg/K)(kg/kg)' ) elif namelist['thermodynamics']['thermal_variable'] == 'thetal': - self.Hvar = VariableDiagnostic(Gr.nzg, 'full', 'scalar', 'sym' ,'thetal_var', 'K^2') - self.HQTcov = VariableDiagnostic(Gr.nzg, 'full', 'scalar','sym' ,'thetal_qt_covar', 'K(kg/kg)' ) + self.Hvar = VariableDiagnostic(Gr.nzg, 'half', 'scalar', 'sym' ,'thetal_var', 'K^2') + self.HQTcov = VariableDiagnostic(Gr.nzg, 'half', 'scalar','sym' ,'thetal_qt_covar', 'K(kg/kg)' ) if self.EnvThermo_scheme == 'sommeria_deardorff': - self.THVvar = VariableDiagnostic(Gr.nzg, 'full', 'scalar','sym', 'thatav_var','K^2' ) + self.THVvar = VariableDiagnostic(Gr.nzg, 'half', 'scalar','sym', 'thatav_var','K^2' ) return From 8fdc8bc882669b4e3f248c779cbbff36527041af Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Mon, 20 Aug 2018 09:40:54 -0700 Subject: [PATCH 053/136] .. --- Turbulence_PrognosticTKE.pyx | 6 ++++++ turbulence_functions.pyx | 10 +++++----- 2 files changed, 11 insertions(+), 5 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 94c57a51..8e703c42 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -806,8 +806,14 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.H.new[i,k] = GMV.H.values[k] self.UpdVar.QT.new[i,k] = GMV.QT.values[k] + + if self.UpdVar.H.new[i,k] < 280 or self.UpdVar.H.new[i,k] > 450: + print 'yair,', k, self.UpdVar.H.new[i,k], self.UpdVar.H.values[i,k], self.UpdVar.W.values[i,k], self.UpdVar.H.values[i,k-1], self.UpdVar.H.values[i,k], self.UpdVar.H.values[i,k+1], self.EnvVar.H.values[k+1], GMV.H.values[k+1] + sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0[k], self.UpdVar.QT.new[i,k], self.UpdVar.H.new[i,k]) + if np.isnan(sa.T): + print 'sa_mean,', k, self.UpdVar.H.new[i,k], self.UpdVar.H.values[i,k], self.UpdVar.W.values[i,k], self.UpdVar.H.values[i,k-1], self.UpdVar.H.values[i,k], self.UpdVar.H.values[i,k+1], self.EnvVar.H.values[k+1], GMV.H.values[k+1] self.UpdVar.QL.new[i,k] = sa.ql self.UpdVar.T.new[i,k] = sa.T diff --git a/turbulence_functions.pyx b/turbulence_functions.pyx index 891c6550..df4685ce 100644 --- a/turbulence_functions.pyx +++ b/turbulence_functions.pyx @@ -137,12 +137,12 @@ cdef double entr_detr_buoyancy_sorting(entr_in_struct entr_in) nogil: brel_mix = bmix# + wdw_mix brel_env = b_env# + wdw_env brel_up = b_up# + wdw_up - x0 = brel_mix/fabs(brel_env) + x0 = brel_mix/fmax(fabs(brel_env),1e-6) #sigma = entr_in.Poisson_rand*fmax(fabs((brel_mix-brel_up)/fabs(brel_env)),fabs((brel_mix-brel_env)/fabs(brel_env))) - sigma = entr_in.Poisson_rand*(brel_up-brel_env)/fabs(brel_env) - partiation_func = (1-erf((brel_env/fabs(brel_env)-x0)/(1.4142135623*sigma)))/2 - #with gil: - # print partiation_func, brel_env/fabs(brel_env), sigma, fabs((brel_mix-brel_up)/fabs(brel_env)), fabs((brel_mix-brel_env)/fabs(brel_env)) + sigma = entr_in.Poisson_rand*(brel_up-brel_env)/fmax(fabs(brel_env),1e-6) + partiation_func = (1-erf((brel_env/fmax(fabs(brel_env),1e-6)-x0)/(1.4142135623*sigma)))/2 + # with gil: + # print alpha_env, entr_in.p0, entr_in.T_env, entr_in.qt_env, entr_in.qt_env-entr_in.ql_env return partiation_func From c456da0bd0f04337dbdca2ccced248a2335bf6e0 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Mon, 20 Aug 2018 10:26:57 -0700 Subject: [PATCH 054/136] .. --- turbulence_functions.pyx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/turbulence_functions.pyx b/turbulence_functions.pyx index df4685ce..819c5a83 100644 --- a/turbulence_functions.pyx +++ b/turbulence_functions.pyx @@ -29,8 +29,8 @@ cdef entr_struct entr_detr_inverse_w(entr_in_struct entr_in) nogil: entr_struct _ret w_mix = (entr_in.w+entr_in.w_env)/2 - #eps_w = 1.0/(fmax(w_mix,1.0)* 500) - eps_w = 0.15*fabs(entr_in.b) / fmax(entr_in.w * entr_in.w, 1e-2) + eps_w = 1.0/(fmax(entr_in.w,1.0)* 500) + #eps_w = 0.15*fabs(entr_in.b) / fmax(entr_in.w * entr_in.w, 1e-2) if entr_in.af>0.0: From e6e9164aa61e4116114b9098f0b77d6c7465dfc3 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Wed, 22 Aug 2018 18:53:41 -0700 Subject: [PATCH 055/136] .. --- generate_namelist.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/generate_namelist.py b/generate_namelist.py index 4a10f939..1931c436 100644 --- a/generate_namelist.py +++ b/generate_namelist.py @@ -154,7 +154,7 @@ def life_cycle_Tan2018(): namelist['turbulence']['EDMF_PrognosticTKE']['extrapolate_buoyancy'] = True namelist['turbulence']['EDMF_PrognosticTKE']['use_steady_updrafts'] = False # namelist['turbulence']['EDMF_PrognosticTKE']['use_scalar_var'] = True - namelist['turbulence']['EDMF_PrognosticTKE']['mixing length'] = 'Ellison_scale' + namelist['turbulence']['EDMF_PrognosticTKE']['mixing length'] = 'tke' namelist['turbulence']['EDMF_PrognosticTKE']['use_local_micro'] = True namelist['turbulence']['EDMF_PrognosticTKE']['use_similarity_diffusivity'] = False namelist['turbulence']['EDMF_PrognosticTKE']['constant_area'] = False @@ -225,9 +225,9 @@ def TRMM_LBA(): # yair namelist['grid'] = {} namelist['grid']['dims'] = 1 - namelist['grid']['nz'] = 2000 + namelist['grid']['nz'] = 400 namelist['grid']['gw'] = 2 - namelist['grid']['dz'] = 10 + namelist['grid']['dz'] = 40 namelist['thermodynamics'] = {} namelist['thermodynamics']['saturation'] = 'sa_mean' @@ -241,14 +241,14 @@ def TRMM_LBA(): # yair namelist['turbulence']['scheme'] = 'EDMF_PrognosticTKE' namelist['turbulence']['EDMF_PrognosticTKE'] = {} namelist['turbulence']['EDMF_PrognosticTKE']['updraft_number'] = 1 - namelist['turbulence']['EDMF_PrognosticTKE']['entrainment'] = 'b_w2' + namelist['turbulence']['EDMF_PrognosticTKE']['entrainment'] = 'inverse_w' namelist['turbulence']['EDMF_PrognosticTKE']['use_local_micro'] = True namelist['turbulence']['EDMF_PrognosticTKE']['use_similarity_diffusivity'] = True #False namelist['turbulence']['EDMF_PrognosticTKE']['updraft_surface_height'] = 0.0 namelist['turbulence']['EDMF_PrognosticTKE']['extrapolate_buoyancy'] = True namelist['turbulence']['EDMF_PrognosticTKE']['use_steady_updrafts'] = False namelist['turbulence']['EDMF_PrognosticTKE']['calculate_tke'] = True - #namelist['turbulence']['EDMF_PrognosticTKE']['calc_scalar_var'] = False + namelist['turbulence']['EDMF_PrognosticTKE']['calc_scalar_var'] = True namelist['output'] = {} namelist['output']['output_root'] = './' From 1ebf0a70ff6f2a3de068ff1477fb89be038d7b6c Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Thu, 23 Aug 2018 10:01:27 -0700 Subject: [PATCH 056/136] testing teh surface buoyancy calc --- EDMF_Environment.pyx | 3 +++ EDMF_Updrafts.pyx | 11 +++++++++++ Turbulence_PrognosticTKE.pyx | 26 +++++++++++++++++--------- turbulence_functions.pyx | 5 ++++- 4 files changed, 35 insertions(+), 10 deletions(-) diff --git a/EDMF_Environment.pyx b/EDMF_Environment.pyx index 229b3513..693c9ce4 100644 --- a/EDMF_Environment.pyx +++ b/EDMF_Environment.pyx @@ -204,6 +204,9 @@ cdef class EnvironmentThermodynamics: EnvVar.QL.values[k] = ql EnvVar.QR.values[k] += qr EnvVar.B.values[k] = buoyancy_c(self.Ref.alpha0[k], alpha) + if k==2: + with gil: + print 'cal envvar Buoy', k, EnvVar.B.values[k] return cdef void update_cloud_dry(self, long k, EnvironmentVariables EnvVar, double T, double th, double qt, double ql, double qv) nogil : diff --git a/EDMF_Updrafts.pyx b/EDMF_Updrafts.pyx index 91d60115..12c37c7a 100644 --- a/EDMF_Updrafts.pyx +++ b/EDMF_Updrafts.pyx @@ -325,6 +325,7 @@ cdef class UpdraftThermodynamics: qv = UpdVar.QT.values[i,k] - UpdVar.QL.values[i,k] alpha = alpha_c(self.Ref.p0[k], UpdVar.T.values[i,k], UpdVar.QT.values[i,k], qv) UpdVar.B.values[i,k] = buoyancy_c(self.Ref.alpha0[k], alpha) #- GMV.B.values[k] + else: with nogil: for i in xrange(self.n_updraft): @@ -337,6 +338,7 @@ cdef class UpdraftThermodynamics: alpha = alpha_c(self.Ref.p0[k], t, qt, qv) UpdVar.B.values[i,k] = buoyancy_c(self.Ref.alpha0[k], alpha) + else: sa = eos(self.t_to_prog_fp, self.prog_to_t_fp, self.Ref.p0[k], qt, h) @@ -349,11 +351,20 @@ cdef class UpdraftThermodynamics: with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): GMV.B.values[k] = (1.0 - UpdVar.Area.bulkvalues[k]) * EnvVar.B.values[k] + if k==2: + with gil: + print 'befroe:', k, 'upd', UpdVar.B.values[0,k], 'gmv', GMV.B.values[k], 'env',EnvVar.B.values[k], UpdVar.Area.bulkvalues[k] for i in xrange(self.n_updraft): GMV.B.values[k] += UpdVar.Area.values[i,k] * UpdVar.B.values[i,k] + if k==2: + with gil: + print GMV.B.values[k], UpdVar.Area.values[i,k] * UpdVar.B.values[i,k] for i in xrange(self.n_updraft): UpdVar.B.values[i,k] -= GMV.B.values[k] EnvVar.B.values[k] -= GMV.B.values[k] + if k==2: + with gil: + print 'after:', k, 'upd', UpdVar.B.values[0,k], 'gmv', GMV.B.values[k], 'env',EnvVar.B.values[k], UpdVar.Area.bulkvalues[k] return diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 7611a726..c28727ea 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -322,6 +322,12 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): if TS.nstep == 0: self.initialize_covariance(GMV, Case) + self.decompose_environment(GMV, 'values') + self.EnvThermo.satadjust(self.EnvVar, GMV) + self.UpdThermo.buoyancy(self.UpdVar, self.EnvVar,GMV, self.extrapolate_buoyancy) + print 'update', self.Gr.gw, self.UpdVar.B.values[0,self.Gr.gw], self.EnvVar.B.values[self.Gr.gw], self.Ref.alpha0[self.Gr.gw], self.Ref.p0[self.Gr.gw], self.UpdVar.T.values[0,self.Gr.gw], self.UpdVar.QT.values[0,self.Gr.gw] + plt.figure() + plt.show() with nogil: for k in xrange(self.Gr.nzg): if self.calc_tke: @@ -806,15 +812,17 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.H.new[i,gw] = self.h_surface_bc[i] self.UpdVar.QT.new[i,gw] = self.qt_surface_bc[i] - sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, - self.Ref.p0[gw], self.UpdVar.QT.values[i,gw], self.UpdVar.H.values[i,gw]) - self.UpdVar.QL.new[i,gw] = sa.ql - self.UpdVar.T.new[i,gw] = sa.T - self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0[gw], self.UpdVar.T.values[i,gw], - &self.UpdVar.QT.values[i,gw], &self.UpdVar.QL.values[i,gw], - &self.UpdVar.QR.values[i,gw], &self.UpdVar.H.values[i,gw], - i, gw) - + # sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, + # self.Ref.p0[gw], self.UpdVar.QT.values[i,gw], self.UpdVar.H.values[i,gw]) + # self.UpdVar.QL.new[i,gw] = sa.ql + # self.UpdVar.T.new[i,gw] = sa.T + # self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0[gw], self.UpdVar.T.values[i,gw], + # &self.UpdVar.QT.values[i,gw], &self.UpdVar.QL.values[i,gw], + # &self.UpdVar.QR.values[i,gw], &self.UpdVar.H.values[i,gw], + # i, gw) + print self.UpdVar.W.new[i,gw], self.UpdVar.B.values[i,gw], self.EnvVar.B.values[gw], GMV.B.values[gw] + plt.figure() + plt.show() for k in range(gw+1, self.Gr.nzg-gw): self.upwind_integration(self.UpdVar.Area, self.UpdVar.Area, k, i, 1.0) if self.UpdVar.Area.new[i,k] > au_lim: diff --git a/turbulence_functions.pyx b/turbulence_functions.pyx index 819c5a83..1347f727 100644 --- a/turbulence_functions.pyx +++ b/turbulence_functions.pyx @@ -29,7 +29,7 @@ cdef entr_struct entr_detr_inverse_w(entr_in_struct entr_in) nogil: entr_struct _ret w_mix = (entr_in.w+entr_in.w_env)/2 - eps_w = 1.0/(fmax(entr_in.w,1.0)* 500) + eps_w = 1.0/(fmax(fabs(entr_in.w),1.0)* 500) #eps_w = 0.15*fabs(entr_in.b) / fmax(entr_in.w * entr_in.w, 1e-2) if entr_in.af>0.0: @@ -137,7 +137,10 @@ cdef double entr_detr_buoyancy_sorting(entr_in_struct entr_in) nogil: brel_mix = bmix# + wdw_mix brel_env = b_env# + wdw_env brel_up = b_up# + wdw_up + x0 = brel_mix/fmax(fabs(brel_env),1e-6) + with gil: + print 'after x0-', brel_env #sigma = entr_in.Poisson_rand*fmax(fabs((brel_mix-brel_up)/fabs(brel_env)),fabs((brel_mix-brel_env)/fabs(brel_env))) sigma = entr_in.Poisson_rand*(brel_up-brel_env)/fmax(fabs(brel_env),1e-6) partiation_func = (1-erf((brel_env/fmax(fabs(brel_env),1e-6)-x0)/(1.4142135623*sigma)))/2 From 8f205f0618927328f56f711921b840d8fb48abdc Mon Sep 17 00:00:00 2001 From: yairchn Date: Sat, 1 Sep 2018 17:45:37 -0700 Subject: [PATCH 057/136] fix double eos calcualtion in ReferenceStates.pyx --- ReferenceState.pyx | 5 ----- 1 file changed, 5 deletions(-) diff --git a/ReferenceState.pyx b/ReferenceState.pyx index 389113c9..a69109dd 100644 --- a/ReferenceState.pyx +++ b/ReferenceState.pyx @@ -92,11 +92,6 @@ cdef class ReferenceState: ql[k] = ret.ql qv[k] = self.qtg - (ql[k] + qi[k]) alpha[k] = alpha_c(p_[k], temperature[k], self.qtg, qv[k]) - ret = eos(t_to_entropy_c, eos_first_guess_entropy, p_[k], self.qtg, self.sg) - temperature[k] = ret.T - ql[k] = ret.ql - qv[k] = self.qtg - (ql[k] + qi[k]) - alpha[k] = alpha_c(p_[k], temperature[k], self.qtg, qv[k]) # Now do a sanity check to make sure that the Reference State entropy profile is uniform following From 47bb1a3570b8a3a7d046231b894e3bedaa5da295 Mon Sep 17 00:00:00 2001 From: yairchn Date: Sun, 2 Sep 2018 12:11:03 -0700 Subject: [PATCH 058/136] .. --- Turbulence_PrognosticTKE.pyx | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 7611a726..d8a8a00f 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -1114,9 +1114,15 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): + (1.0-self.EnvVar.CF.values[k]) * d_alpha_thetal_dry) d_alpha_qt_total = (self.EnvVar.CF.values[k] * d_alpha_qt_cloudy + (1.0-self.EnvVar.CF.values[k]) * d_alpha_qt_dry) + #self.EnvVar.TKE.buoy[k] = g / self.Ref.alpha0[k] * ae[k] * self.Ref.rho0[k] \ + # * ( -self.KH.values[k] *grad_thl_plus * d_alpha_thetal_total + # - self.KH.values[k] * grad_qt_plus * d_alpha_qt_total) + self.EnvVar.TKE.buoy[k] = g / self.Ref.alpha0[k] * ae[k] * self.Ref.rho0[k] \ - * ( -self.KH.values[k] *grad_thl_plus * d_alpha_thetal_total - - self.KH.values[k] * grad_qt_plus * d_alpha_qt_total) + * ( \ + - self.KH.values[k] * interp2pt(grad_thl_plus, grad_thl_minus) * d_alpha_thetal_total \ + - self.KH.values[k] * interp2pt(grad_qt_plus, grad_qt_minus) * d_alpha_qt_total\ + ) return From 8466d0029bbbb7824ed38320835ff661dbc442a6 Mon Sep 17 00:00:00 2001 From: yairchn Date: Sun, 2 Sep 2018 13:57:04 -0700 Subject: [PATCH 059/136] set p at the surface to Pg in Ref --- ReferenceState.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ReferenceState.pyx b/ReferenceState.pyx index a69109dd..51ae6374 100644 --- a/ReferenceState.pyx +++ b/ReferenceState.pyx @@ -72,7 +72,7 @@ cdef class ReferenceState: # Set boundary conditions p[:Gr.gw] = p[2 * Gr.gw - 1:Gr.gw - 1:-1] p[-Gr.gw:] = p[-Gr.gw - 1:-2 * Gr.gw - 1:-1] - + p[1] = p0 p = np.exp(p) From 66100e59cf2f143935b4df1d75ba54ac9230d35e Mon Sep 17 00:00:00 2001 From: yairchn Date: Sun, 2 Sep 2018 16:14:31 -0700 Subject: [PATCH 060/136] .. --- ReferenceState.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ReferenceState.pyx b/ReferenceState.pyx index 51ae6374..4e1b1a8d 100644 --- a/ReferenceState.pyx +++ b/ReferenceState.pyx @@ -72,7 +72,7 @@ cdef class ReferenceState: # Set boundary conditions p[:Gr.gw] = p[2 * Gr.gw - 1:Gr.gw - 1:-1] p[-Gr.gw:] = p[-Gr.gw - 1:-2 * Gr.gw - 1:-1] - p[1] = p0 + p = np.exp(p) From 779616ed52aa2f7d1b4127642fc33fcffb390651 Mon Sep 17 00:00:00 2001 From: yairchn Date: Wed, 5 Sep 2018 11:09:26 -0700 Subject: [PATCH 061/136] fix values -> new in first level thermodynamic sa --- Turbulence_PrognosticTKE.pyx | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index d8a8a00f..d4459979 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -807,12 +807,12 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.QT.new[i,gw] = self.qt_surface_bc[i] sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, - self.Ref.p0[gw], self.UpdVar.QT.values[i,gw], self.UpdVar.H.values[i,gw]) + self.Ref.p0[gw], self.UpdVar.QT.new[i,gw], self.UpdVar.H.new[i,gw]) self.UpdVar.QL.new[i,gw] = sa.ql self.UpdVar.T.new[i,gw] = sa.T - self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0[gw], self.UpdVar.T.values[i,gw], - &self.UpdVar.QT.values[i,gw], &self.UpdVar.QL.values[i,gw], - &self.UpdVar.QR.values[i,gw], &self.UpdVar.H.values[i,gw], + self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0[gw], self.UpdVar.T.new[i,gw], + &self.UpdVar.QT.new[i,gw], &self.UpdVar.QL.new[i,gw], + &self.UpdVar.QR.new[i,gw], &self.UpdVar.H.new[i,gw], i, gw) for k in range(gw+1, self.Gr.nzg-gw): From 7785faaea57df141df2f0b1f5a4b264ffc3d4bec Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Thu, 6 Sep 2018 11:29:20 -0700 Subject: [PATCH 062/136] adding quadrature based buoyancy_sorting --- EDMF_Environment.pyx | 3 -- EDMF_Updrafts.pyx | 9 ---- Turbulence_PrognosticTKE.pyx | 95 +++++++++++++++++------------------- generate_namelist.py | 4 +- generate_paramlist.py | 6 +-- turbulence_functions.pxd | 7 +++ turbulence_functions.pyx | 79 ++++++++++++++++++++++++------ 7 files changed, 123 insertions(+), 80 deletions(-) diff --git a/EDMF_Environment.pyx b/EDMF_Environment.pyx index 693c9ce4..229b3513 100644 --- a/EDMF_Environment.pyx +++ b/EDMF_Environment.pyx @@ -204,9 +204,6 @@ cdef class EnvironmentThermodynamics: EnvVar.QL.values[k] = ql EnvVar.QR.values[k] += qr EnvVar.B.values[k] = buoyancy_c(self.Ref.alpha0[k], alpha) - if k==2: - with gil: - print 'cal envvar Buoy', k, EnvVar.B.values[k] return cdef void update_cloud_dry(self, long k, EnvironmentVariables EnvVar, double T, double th, double qt, double ql, double qv) nogil : diff --git a/EDMF_Updrafts.pyx b/EDMF_Updrafts.pyx index 12c37c7a..0798513c 100644 --- a/EDMF_Updrafts.pyx +++ b/EDMF_Updrafts.pyx @@ -351,20 +351,11 @@ cdef class UpdraftThermodynamics: with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): GMV.B.values[k] = (1.0 - UpdVar.Area.bulkvalues[k]) * EnvVar.B.values[k] - if k==2: - with gil: - print 'befroe:', k, 'upd', UpdVar.B.values[0,k], 'gmv', GMV.B.values[k], 'env',EnvVar.B.values[k], UpdVar.Area.bulkvalues[k] for i in xrange(self.n_updraft): GMV.B.values[k] += UpdVar.Area.values[i,k] * UpdVar.B.values[i,k] - if k==2: - with gil: - print GMV.B.values[k], UpdVar.Area.values[i,k] * UpdVar.B.values[i,k] for i in xrange(self.n_updraft): UpdVar.B.values[i,k] -= GMV.B.values[k] EnvVar.B.values[k] -= GMV.B.values[k] - if k==2: - with gil: - print 'after:', k, 'upd', UpdVar.B.values[0,k], 'gmv', GMV.B.values[k], 'env',EnvVar.B.values[k], UpdVar.Area.bulkvalues[k] return diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index c28727ea..3b544205 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -325,9 +325,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.decompose_environment(GMV, 'values') self.EnvThermo.satadjust(self.EnvVar, GMV) self.UpdThermo.buoyancy(self.UpdVar, self.EnvVar,GMV, self.extrapolate_buoyancy) - print 'update', self.Gr.gw, self.UpdVar.B.values[0,self.Gr.gw], self.EnvVar.B.values[self.Gr.gw], self.Ref.alpha0[self.Gr.gw], self.Ref.p0[self.Gr.gw], self.UpdVar.T.values[0,self.Gr.gw], self.UpdVar.QT.values[0,self.Gr.gw] - plt.figure() - plt.show() with nogil: for k in xrange(self.Gr.nzg): if self.calc_tke: @@ -730,52 +727,54 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): entr_struct ret entr_in_struct input eos_struct sa + #double [:] Poisson_rand double [:] Poisson_rand + double logfn + long quadrature_order = 3 self.UpdVar.get_cloud_base_top_cover() input.wstar = self.wstar - - for i in xrange(self.n_updrafts): input.zi = self.UpdVar.cloud_base[i] Poisson_rand = np.random.poisson(10.0,self.Gr.nzg).astype(np.float) Poisson_rand= np.clip(Poisson_rand,0.01,100.0) for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - with nogil: - input.b = self.UpdVar.B.values[i,k] - input.b_mean = GMV.B.values[k] - input.w = self.UpdVar.W.values[i,k] - input.dw = (self.UpdVar.W.values[i,k+1]-self.UpdVar.W.values[i,k-1])/self.Gr.dz/2.0 - input.z = self.Gr.z[k] - input.af = self.UpdVar.Area.values[i,k] - input.ml = self.mixing_length[k] - input.qt_env = self.EnvVar.QT.values[k] - input.ql_env = self.EnvVar.QL.values[k] - input.T_env = self.EnvVar.T.values[k] - input.H_env = self.EnvVar.H.values[k] - input.w_env = self.EnvVar.W.values[k] - input.dw_env = (self.EnvVar.W.values[k+1]-self.EnvVar.W.values[k-1])/self.Gr.dz/2.0 - input.H_up = self.UpdVar.H.values[i,k] - input.qt_up = self.UpdVar.QT.values[i,k] - input.ql_up = self.UpdVar.QL.values[i,k] - input.T_up = self.UpdVar.T.values[i,k] - input.p0 = self.Ref.p0[k] - input.alpha0 = self.Ref.alpha0[k] - input.tke_ed_coeff = self.tke_ed_coeff - input.Poisson_rand = Poisson_rand[k]/10.0 - input.L = 20000.0 # need to define the scale of the GCM grid resolution - if self.calc_tke: - input.tke = self.EnvVar.TKE.values[k] - input.tke_ed_coeff = self.tke_ed_coeff - - ret = self.entr_detr_fp(input) - self.entr_sc[i,k] = ret.entr_sc * self.entrainment_factor - self.detr_sc[i,k] = ret.detr_sc * self.detrainment_factor + input.quadrature_order = quadrature_order + input.b = self.UpdVar.B.values[i,k] + input.b_mean = GMV.B.values[k] + input.w = interp2pt(self.UpdVar.W.values[i,k],self.UpdVar.W.values[i,k-1]) + input.dw = (self.UpdVar.W.values[i,k]-self.UpdVar.W.values[i,k-1])/self.Gr.dz + input.z = self.Gr.z[k] + input.af = self.UpdVar.Area.values[i,k] + input.tke = self.EnvVar.TKE.values[k] + input.ml = self.mixing_length[k] + input.qt_env = self.EnvVar.QT.values[k] + input.ql_env = self.EnvVar.QL.values[k] + input.T_env = self.EnvVar.T.values[k] + input.H_env = self.EnvVar.H.values[k] + input.env_Hvar = self.EnvVar.Hvar.values[k] + input.env_QTvar = self.EnvVar.QTvar.values[k] + input.env_HQTcov = self.EnvVar.HQTcov.values[k] + input.w_env = interp2pt(self.EnvVar.W.values[k],self.EnvVar.W.values[k-1]) + input.dw_env = (self.EnvVar.W.values[k]-self.EnvVar.W.values[k-1])/self.Gr.dz + input.H_up = self.UpdVar.H.values[i,k] + input.qt_up = self.UpdVar.QT.values[i,k] + input.ql_up = self.UpdVar.QL.values[i,k] + input.T_up = self.UpdVar.T.values[i,k] + input.p0 = self.Ref.p0[k] + input.alpha0 = self.Ref.alpha0[k] + input.tke_ed_coeff = self.tke_ed_coeff + input.Poisson_rand = Poisson_rand[k]/10.0 + input.L = 20000.0 # need to define the scale of the GCM grid resolution + ret = self.entr_detr_fp(input) + self.entr_sc[i,k] = ret.entr_sc * self.entrainment_factor + self.detr_sc[i,k] = ret.detr_sc * self.detrainment_factor return + cpdef solve_updraft(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS): cdef: Py_ssize_t i, k @@ -804,25 +803,23 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): press_drag = -1.0 * self.Ref.rho0[gw]*sqrt(self.UpdVar.Area.values[i,gw])*self.pressure_drag_coeff/self.pressure_plume_spacing \ * (self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])*fabs(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw]) press = press_buoy + press_drag - self.UpdVar.W.values[i,gw] = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * dti_ + self.UpdVar.W.new[i,gw] = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * dti_ -adv + exch + buoy + press)/(self.Ref.rho0[gw] * self.UpdVar.Area.new[i,gw] * dti_) - self.UpdVar.W.new[i,gw] = self.UpdVar.W.values[i,gw] + self.UpdVar.H.new[i,gw] = self.h_surface_bc[i] self.UpdVar.QT.new[i,gw] = self.qt_surface_bc[i] - # sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, - # self.Ref.p0[gw], self.UpdVar.QT.values[i,gw], self.UpdVar.H.values[i,gw]) - # self.UpdVar.QL.new[i,gw] = sa.ql - # self.UpdVar.T.new[i,gw] = sa.T - # self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0[gw], self.UpdVar.T.values[i,gw], - # &self.UpdVar.QT.values[i,gw], &self.UpdVar.QL.values[i,gw], - # &self.UpdVar.QR.values[i,gw], &self.UpdVar.H.values[i,gw], - # i, gw) - print self.UpdVar.W.new[i,gw], self.UpdVar.B.values[i,gw], self.EnvVar.B.values[gw], GMV.B.values[gw] - plt.figure() - plt.show() + sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, + self.Ref.p0[gw], self.UpdVar.QT.new[i,gw], self.UpdVar.H.new[i,gw]) + self.UpdVar.QL.new[i,gw] = sa.ql + self.UpdVar.T.new[i,gw] = sa.T + self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0[gw], self.UpdVar.T.new[i,gw], + &self.UpdVar.QT.new[i,gw], &self.UpdVar.QL.new[i,gw], + &self.UpdVar.QR.new[i,gw], &self.UpdVar.H.new[i,gw], + i, gw) + for k in range(gw+1, self.Gr.nzg-gw): self.upwind_integration(self.UpdVar.Area, self.UpdVar.Area, k, i, 1.0) if self.UpdVar.Area.new[i,k] > au_lim: @@ -846,7 +843,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.QT.new[i,k] = GMV.QT.values[k] if self.UpdVar.H.new[i,k] < 280 or self.UpdVar.H.new[i,k] > 450: - print 'yair,', k, self.UpdVar.H.new[i,k], self.UpdVar.H.values[i,k], self.UpdVar.W.values[i,k], self.UpdVar.H.values[i,k-1], self.UpdVar.H.values[i,k], self.UpdVar.H.values[i,k+1], self.EnvVar.H.values[k+1], GMV.H.values[k+1] + print 'before sa mean,', k, self.UpdVar.H.new[i,k], self.UpdVar.H.values[i,k], self.UpdVar.W.values[i,k], self.UpdVar.H.values[i,k-1], self.UpdVar.H.values[i,k], self.UpdVar.H.values[i,k+1], self.EnvVar.H.values[k+1], GMV.H.values[k+1] sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0[k], self.UpdVar.QT.new[i,k], self.UpdVar.H.new[i,k]) diff --git a/generate_namelist.py b/generate_namelist.py index 1931c436..1da8d8e1 100644 --- a/generate_namelist.py +++ b/generate_namelist.py @@ -234,7 +234,7 @@ def TRMM_LBA(): # yair namelist['thermodynamics']['thermal_variable'] = 'thetal' namelist['time_stepping'] = {} - namelist['time_stepping']['dt'] = 5.0 + namelist['time_stepping']['dt'] = 30.0 namelist['time_stepping']['t_max'] = 21590.0 namelist['turbulence'] = {} @@ -243,7 +243,7 @@ def TRMM_LBA(): # yair namelist['turbulence']['EDMF_PrognosticTKE']['updraft_number'] = 1 namelist['turbulence']['EDMF_PrognosticTKE']['entrainment'] = 'inverse_w' namelist['turbulence']['EDMF_PrognosticTKE']['use_local_micro'] = True - namelist['turbulence']['EDMF_PrognosticTKE']['use_similarity_diffusivity'] = True #False + namelist['turbulence']['EDMF_PrognosticTKE']['use_similarity_diffusivity'] = True namelist['turbulence']['EDMF_PrognosticTKE']['updraft_surface_height'] = 0.0 namelist['turbulence']['EDMF_PrognosticTKE']['extrapolate_buoyancy'] = True namelist['turbulence']['EDMF_PrognosticTKE']['use_steady_updrafts'] = False diff --git a/generate_paramlist.py b/generate_paramlist.py index 8aff192d..b1e05962 100644 --- a/generate_paramlist.py +++ b/generate_paramlist.py @@ -195,14 +195,14 @@ def TRMM_LBA(): paramlist['turbulence']['EDMF_PrognosticTKE']['surface_area'] = 0.1 paramlist['turbulence']['EDMF_PrognosticTKE']['tke_ed_coeff'] = 0.1 paramlist['turbulence']['EDMF_PrognosticTKE']['tke_diss_coeff'] = 2.0 - paramlist['turbulence']['EDMF_PrognosticTKE']['max_area_factor'] = 9.9 + paramlist['turbulence']['EDMF_PrognosticTKE']['max_area_factor'] = 5.0 paramlist['turbulence']['EDMF_PrognosticTKE']['entrainment_factor'] = 1.0 paramlist['turbulence']['EDMF_PrognosticTKE']['detrainment_factor'] = 1.0 paramlist['turbulence']['EDMF_PrognosticTKE']['pressure_buoy_coeff'] = 1.0 / 3.0 paramlist['turbulence']['EDMF_PrognosticTKE']['pressure_drag_coeff'] = 0.375 - paramlist['turbulence']['EDMF_PrognosticTKE']['pressure_plume_spacing'] = 500.0 + paramlist['turbulence']['EDMF_PrognosticTKE']['pressure_plume_spacing'] = 1000.0 paramlist['turbulence']['updraft_microphysics'] = {} - paramlist['turbulence']['updraft_microphysics']['max_supersaturation'] = 0.1 + paramlist['turbulence']['updraft_microphysics']['max_supersaturation'] = 0.01 return paramlist diff --git a/turbulence_functions.pxd b/turbulence_functions.pxd index 9933a3c3..77478a42 100644 --- a/turbulence_functions.pxd +++ b/turbulence_functions.pxd @@ -30,16 +30,23 @@ cdef struct entr_in_struct: double H_up double H_env double w_env + double env_Hvar + double env_QTvar + double env_HQTcov double dw_env double L double tke_ed_coeff double Poisson_rand + double logfn + double dynamic_entr_detr + long quadrature_order cdef entr_struct entr_detr_dry(entr_in_struct entr_in) nogil cdef entr_struct entr_detr_inverse_z(entr_in_struct entr_in) nogil cdef entr_struct entr_detr_inverse_w(entr_in_struct entr_in) nogil cdef entr_struct entr_detr_b_w2(entr_in_struct entr_in) nogil cdef evap_struct evap_sat_adjust(double p0, double thetal_, double qt_mix) nogil +cdef double entr_detr_buoyancy_sorting_old(entr_in_struct entr_in) nogil cdef double entr_detr_buoyancy_sorting(entr_in_struct entr_in) nogil cdef entr_struct entr_detr_tke(entr_in_struct entr_in) nogil cdef entr_struct entr_detr_tke2(entr_in_struct entr_in) nogil diff --git a/turbulence_functions.pyx b/turbulence_functions.pyx index 1347f727..9665e2ba 100644 --- a/turbulence_functions.pyx +++ b/turbulence_functions.pyx @@ -28,15 +28,9 @@ cdef entr_struct entr_detr_inverse_w(entr_in_struct entr_in) nogil: cdef: entr_struct _ret - w_mix = (entr_in.w+entr_in.w_env)/2 eps_w = 1.0/(fmax(fabs(entr_in.w),1.0)* 500) - #eps_w = 0.15*fabs(entr_in.b) / fmax(entr_in.w * entr_in.w, 1e-2) - if entr_in.af>0.0: - partiation_func = entr_detr_buoyancy_sorting(entr_in) - #with gil: - # print partiation_func _ret.entr_sc = partiation_func*eps_w/2.0 _ret.detr_sc = (1.0-partiation_func/2.0)*eps_w else: @@ -105,9 +99,68 @@ cdef entr_struct entr_detr_b_w2(entr_in_struct entr_in) nogil: # _ret.entr_sc = 0.0 # _ret.detr_sc = 0.0 # return _ret - - cdef double entr_detr_buoyancy_sorting(entr_in_struct entr_in) nogil: + + cdef: + Py_ssize_t m_q, m_h + #double[:] inner + int i_b + + double h_hat, qt_hat, sd_h, sd_q, corr, mu_h_star, sigma_h_star, qt_var + double sqpi_inv = 1.0/sqrt(pi) + double sqrt2 = sqrt(2.0) + double sd_q_lim, bmix, qv_ + double partiation_func = 0.0 + double inner_partiation_func = 0.0 + eos_struct sa + double [:] weights + double [:] abscissas + with gil: + abscissas, weights = np.polynomial.hermite.hermgauss(entr_in.quadrature_order) + #print np.multiply(weights[0],1.0), np.multiply(weights[1],1.0), np.multiply(weights[2],1.0) + + if entr_in.env_QTvar != 0.0 and entr_in.env_Hvar != 0.0: + sd_q = sqrt(entr_in.env_QTvar) + sd_h = sqrt(entr_in.env_Hvar) + corr = fmax(fmin(entr_in.env_HQTcov/fmax(sd_h*sd_q, 1e-13),1.0),-1.0) + + # limit sd_q to prevent negative qt_hat + sd_q_lim = (1e-10 - entr_in.qt_env)/(sqrt2 * abscissas[0]) + sd_q = fmin(sd_q, sd_q_lim) + qt_var = sd_q * sd_q + sigma_h_star = sqrt(fmax(1.0-corr*corr,0.0)) * sd_h + + for m_q in xrange(entr_in.quadrature_order): + qt_hat = (entr_in.qt_env + sqrt2 * sd_q * abscissas[m_q] + entr_in.qt_up)/2.0 + mu_h_star = entr_in.H_env + sqrt2 * corr * sd_h * abscissas[m_q] + inner_partiation_func = 0.0 + for m_h in xrange(entr_in.quadrature_order): + h_hat = (sqrt2 * sigma_h_star * abscissas[m_h] + mu_h_star + entr_in.H_up)/2.0 + # condensation + sa = eos(t_to_thetali_c, eos_first_guess_thetal, entr_in.p0, qt_hat, h_hat) + # calcualte buoyancy + qv_ = qt_hat - sa.ql + alpha_mix = alpha_c(entr_in.p0, sa.T, qt_hat, qv_) + bmix = buoyancy_c(entr_in.alpha0, alpha_mix) - entr_in.b_mean + + # sum only the points with positive buoyancy to get the buoyant fraction + if bmix >0.0: + inner_partiation_func += weights[m_h] * sqpi_inv + partiation_func += inner_partiation_func * weights[m_q] * sqpi_inv + + else: + h_hat = ( entr_in.H_env + entr_in.H_up)/2.0 + qt_hat = ( entr_in.qt_env + entr_in.qt_up)/2.0 + + # condensation + sa = eos(t_to_thetali_c, eos_first_guess_thetal, entr_in.p0, qt_hat, h_hat) + # calcualte buoyancy + alpha_mix = alpha_c(entr_in.p0, sa.T, qt_hat, qt_hat - sa.ql) + bmix = buoyancy_c(entr_in.alpha0, alpha_mix) - entr_in.b_mean + + return partiation_func + +cdef double entr_detr_buoyancy_sorting_old(entr_in_struct entr_in) nogil: cdef: double wdw_mix, wdw_env, sigma, brel_mix, brel_env, w_env, dw_env @@ -139,13 +192,11 @@ cdef double entr_detr_buoyancy_sorting(entr_in_struct entr_in) nogil: brel_up = b_up# + wdw_up x0 = brel_mix/fmax(fabs(brel_env),1e-6) - with gil: - print 'after x0-', brel_env - #sigma = entr_in.Poisson_rand*fmax(fabs((brel_mix-brel_up)/fabs(brel_env)),fabs((brel_mix-brel_env)/fabs(brel_env))) sigma = entr_in.Poisson_rand*(brel_up-brel_env)/fmax(fabs(brel_env),1e-6) - partiation_func = (1-erf((brel_env/fmax(fabs(brel_env),1e-6)-x0)/(1.4142135623*sigma)))/2 - # with gil: - # print alpha_env, entr_in.p0, entr_in.T_env, entr_in.qt_env, entr_in.qt_env-entr_in.ql_env + if sigma == 0.0: + partiation_func = 0.5 + else: + partiation_func = (1-erf((brel_env/fmax(fabs(brel_env),1e-6)-x0)/(1.4142135623*sigma)))/2 return partiation_func From c8f291e5b5b30f45a7d110ebc14d9c92638537d9 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Thu, 6 Sep 2018 15:46:35 -0700 Subject: [PATCH 063/136] adding quadrature buoyacy sorting - tested version --- Turbulence_PrognosticTKE.pyx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 3b544205..3a9c88e6 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -695,7 +695,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): psi_diff = psi_u.values[i,k]-gmv_psi[k] gmv_covar[k] += au.values[i,k] * phi_diff * psi_diff return -# self.get_env_covar_from_GMV(self.UpdVar.Area, UpdVar1, UpdVar2, EnvVar1, EnvVar2,Covar, &GmvVar1.values[0], &GmvVar2.values[0], &GmvCovar.values[0] + cdef get_env_covar_from_GMV(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable phi_u, EDMF_Updrafts.UpdraftVariable psi_u, EDMF_Environment.EnvironmentVariable phi_e, EDMF_Environment.EnvironmentVariable psi_e, @@ -730,7 +730,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): #double [:] Poisson_rand double [:] Poisson_rand double logfn - long quadrature_order = 3 + long quadrature_order = 2 self.UpdVar.get_cloud_base_top_cover() From dca908acd0a43d7543e6909743e8a4db0e0fd695 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Thu, 6 Sep 2018 21:59:39 -0700 Subject: [PATCH 064/136] minor fixed for var_dissipiation writing --- Turbulence_PrognosticTKE.pyx | 47 ++++++++++++++++-------------------- 1 file changed, 21 insertions(+), 26 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 3a9c88e6..9beac452 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -278,9 +278,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.compute_covariance_dissipation(self.EnvVar.Hvar) Stats.write_profile('Hvar_dissipation', self.EnvVar.Hvar.dissipation[kmin:kmax]) self.compute_covariance_dissipation(self.EnvVar.QTvar) - Stats.write_profile('Hvar_dissipation', self.EnvVar.QTvar.dissipation[kmin:kmax]) + Stats.write_profile('QTvar_dissipation', self.EnvVar.QTvar.dissipation[kmin:kmax]) self.compute_covariance_dissipation(self.EnvVar.HQTcov) - Stats.write_profile('Hvar_dissipation', self.EnvVar.HQTcov.dissipation[kmin:kmax]) + Stats.write_profile('HQTcov_dissipation', self.EnvVar.HQTcov.dissipation[kmin:kmax]) Stats.write_profile('tke_entr_gain', self.EnvVar.TKE.entr_gain[kmin:kmax]) Stats.write_profile('Hvar_entr_gain', self.EnvVar.Hvar.entr_gain[kmin:kmax]) @@ -744,8 +744,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): input.quadrature_order = quadrature_order input.b = self.UpdVar.B.values[i,k] input.b_mean = GMV.B.values[k] - input.w = interp2pt(self.UpdVar.W.values[i,k],self.UpdVar.W.values[i,k-1]) - input.dw = (self.UpdVar.W.values[i,k]-self.UpdVar.W.values[i,k-1])/self.Gr.dz + input.w = self.UpdVar.W.values[i,k] + input.dw = (self.UpdVar.W.values[i,k+1]-self.UpdVar.W.values[i,k-1])/self.Gr.dz/2.0 input.z = self.Gr.z[k] input.af = self.UpdVar.Area.values[i,k] input.tke = self.EnvVar.TKE.values[k] @@ -757,8 +757,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): input.env_Hvar = self.EnvVar.Hvar.values[k] input.env_QTvar = self.EnvVar.QTvar.values[k] input.env_HQTcov = self.EnvVar.HQTcov.values[k] - input.w_env = interp2pt(self.EnvVar.W.values[k],self.EnvVar.W.values[k-1]) - input.dw_env = (self.EnvVar.W.values[k]-self.EnvVar.W.values[k-1])/self.Gr.dz + input.w_env = self.EnvVar.W.values[k] + input.dw_env = (self.EnvVar.W.values[k+1]-self.EnvVar.W.values[k-1])/self.Gr.dz/2.0 input.H_up = self.UpdVar.H.values[i,k] input.qt_up = self.UpdVar.QT.values[i,k] input.ql_up = self.UpdVar.QL.values[i,k] @@ -806,7 +806,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.W.new[i,gw] = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * dti_ -adv + exch + buoy + press)/(self.Ref.rho0[gw] * self.UpdVar.Area.new[i,gw] * dti_) - + #self.UpdVar.W.values[i,gw] = self.UpdVar.W.new[i,gw] self.UpdVar.H.new[i,gw] = self.h_surface_bc[i] self.UpdVar.QT.new[i,gw] = self.qt_surface_bc[i] @@ -998,7 +998,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(nzg-1): - rho_ae_K_m[k] = 0.5 * (ae[k]*self.KH.values[k]+ ae[k+1]*self.KH.values[k+1]) * self.Ref.rho0[k] + rho_ae_K_m[k] = 0.5 * (ae[k]*self.KH.values[k] * self.Ref.rho0[k]+ ae[k+1]*self.KH.values[k+1] * self.Ref.rho0[k+1]) # Matrix is the same for all variables that use the same eddy diffusivity, we can construct once and reuse construct_tridiag_diffusion(nzg, gw, dzi, TS.dt, &rho_ae_K_m[0], &self.Ref.rho0[0], @@ -1273,28 +1273,22 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Py_ssize_t k Py_ssize_t gw = self.Gr.gw double [:] ae = np.subtract(np.ones((self.Gr.nzg,),dtype=np.double, order='c'),self.UpdVar.Area.bulkvalues) - double var1_high = 0.0 - double var2_high = 0.0 - double du_high = 0.0 - double dv_high = 0.0 - double var1_low, var2_low - double du_low, dv_low + double diff_var1 = 0.0 + double diff_var2 = 0.0 + double du = 0.0 + double dv = 0.0 double tke_factor = 1.0 for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): if Covar.name == 'tke': - du_high = (GMV.U.values[k+1] - GMV.U.values[k-1]) * self.Gr.dzi - dv_high = (GMV.V.values[k+1] - GMV.V.values[k-1]) * self.Gr.dzi + du = (GMV.U.values[k+1] - GMV.U.values[k-1]) * self.Gr.dzi/2.0 + dv = (GMV.V.values[k+1] - GMV.V.values[k-1]) * self.Gr.dzi/2.0 tke_factor = 0.5 with nogil: - var1_low = var1_high - var2_low = var2_high - du_low = du_high - dv_low = dv_high - var1_high = (EnvVar1[k+1] - EnvVar1[k-1]) * self.Gr.dzi - var2_high = (EnvVar2[k+1] - EnvVar2[k-1]) * self.Gr.dzi + diff_var1 = (EnvVar1[k+1] - EnvVar1[k-1]) * self.Gr.dzi/2.0 + diff_var2 = (EnvVar2[k+1] - EnvVar2[k-1]) * self.Gr.dzi/2.0 Covar.shear[k] = tke_factor*2.0*(self.Ref.rho0[k] * ae[k] * self.KH.values[k] * - (var1_high*var2_high + pow(du_high,2.0) + pow(dv_high,2.0))) + (diff_var1*diff_var2 + pow(du,2.0) + pow(dv,2.0))) return cdef void compute_covariance_dissipation(self, EDMF_Environment.EnvironmentVariable_2m Covar): @@ -1345,6 +1339,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): + self.EnvVar.TKE.rain_src[k] = 0.0 self.EnvVar.Hvar.rain_src[k] = self.Ref.rho0[k] * ae[k] * 2. * self.EnvThermo.Hvar_rain_dt[k] * TS.dti self.EnvVar.QTvar.rain_src[k] = self.Ref.rho0[k] * ae[k] * 2. * self.EnvThermo.QTvar_rain_dt[k] * TS.dti self.EnvVar.HQTcov.rain_src[k] = self.Ref.rho0[k] * ae[k] * self.EnvThermo.HQTcov_rain_dt[k] * TS.dti @@ -1375,7 +1370,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(1,nzg-1): - rho_ae_K_m[k] = 0.5 * (ae[k]*self.KH.values[k]+ ae[k+1]*self.KH.values[k+1]) * self.Ref.rho0[k] + rho_ae_K_m[k] = 0.5 * (ae[k]*self.KH.values[k]* self.Ref.rho0[k]+ ae[k+1]*self.KH.values[k+1]* self.Ref.rho0[k+1]) if GmvCovar.name=='tke': GmvCovar.values[gw] =get_surface_tke(Case.Sur.ustar, self.wstar, self.Gr.z[gw], Case.Sur.obukhov_length) @@ -1406,7 +1401,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): *sqrt(fmax(self.EnvVar.TKE.values[k],0))/fmax(self.mixing_length[k],1.0) ) c[kk] = (self.Ref.rho0[k+1] * ae[k+1] * self.EnvVar.W.values[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) x[kk] = (self.Ref.rho0[k] * ae_old[k] * Covar.values[k] * dti - + Covar.press[k] + Covar.buoy[k] + Covar.shear[k] + Covar.entr_gain[k]) # + + Covar.press[k] + Covar.buoy[k] + Covar.shear[k] + Covar.entr_gain[k] + Covar.rain_src[k]) # a[0] = 0.0 b[0] = 1.0 @@ -1420,7 +1415,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for kk in xrange(nz): k = kk + gw - Covar.values[k] = x[kk] + Covar.values[k] = fmax(x[kk],0.0) GmvCovar.values[k] = (ae[k] * (Covar.values[k] + (EnvVar1.values[k]-GmvVar1.values[k]) * (EnvVar2.values[k]-GmvVar2.values[k])) + self.UpdVar.Area.bulkvalues[k] * (UpdVar1.bulkvalues[k]-GmvVar1.values[k]) * (UpdVar2.bulkvalues[k]-GmvVar2.values[k])) From e25ee6bc200ae8fc1b540c606c9f679fe4a1b221 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Thu, 6 Sep 2018 22:13:04 -0700 Subject: [PATCH 065/136] .. --- Turbulence_PrognosticTKE.pyx | 41 ++++++++++-------------------------- generate_namelist.py | 5 ++--- 2 files changed, 13 insertions(+), 33 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 9beac452..233b5c62 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -533,36 +533,17 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double dv = 0.0 double dw = 2.0 * self.EnvVar.W.values[gw] * self.Gr.dzi double H_lapse_rate ,QT_lapse_rate - - if self.mixing_length_fp=='Ellison_scale': - with nogil: - for k in xrange(gw, self.Gr.nzg-gw): - du = (GMV.U.values[k+1] - GMV.U.values[k]) * self.Gr.dzi - dv = (GMV.V.values[k+1] - GMV.V.values[k]) * self.Gr.dzi - dw = (self.EnvVar.W.values[k+1] - self.EnvVar.W.values[k]) * self.Gr.dzi - shear = fmax(fabs( pow(du,2.0) + pow(dv,2.0)+pow(dw,2.0)),1e-10) - H_lapse_rate = fmax(fabs((self.EnvVar.H.values[k+1]-self.EnvVar.H.values[k-1])*0.5*self.Gr.dzi),1e-30) - QT_lapse_rate = fmax(fabs((self.EnvVar.QT.values[k+1]-self.EnvVar.QT.values[k-1])*0.5*self.Gr.dzi),1e-30) - l1 = vkb * self.Gr.z[k] - #l2 = fmin(sqrt(self.tke_diss_coeff/self.tke_ed_coeff*0.5*self.EnvVar.Hvar.values[k]/H_lapse_rate**2),1000.0) - #l2 = fmin(sqrt(self.tke_diss_coeff/self.tke_ed_coeff*0.5*self.EnvVar.QTvar.values[k]/QT_lapse_rate**2),1000.0) - l2 = fmin(sqrt(self.tke_diss_coeff/self.tke_ed_coeff*self.EnvVar.TKE.values[k]/shear),1000.0) - l3 = 10000.0 # GCM grid box - self.mixing_length[k] = smooth_minimum(fabs(l1/self.zi),fabs(l2/self.zi),fabs(l3/self.zi),1.0) # - #self.mixing_length[k] = smooth_minimum(fabs(l1/self.zi),fabs(l2/self.zi),fabs(l3/self.zi),fabs(l4/self.zi),fabs(l5/self.zi),10.0) - self.mixing_length[k] = self.zi*self.mixing_length[k] - else: - with nogil: - for k in xrange(gw, self.Gr.nzg-gw): - l1 = tau * sqrt(fmax(self.EnvVar.TKE.values[k],0.0)) - z_ = self.Gr.z[k] - if obukhov_length < 0.0: #unstable - l2 = vkb * z_ * ( (1.0 - 100.0 * z_/obukhov_length)**0.2 ) - elif obukhov_length > 0.0: #stable - l2 = vkb * z_ / (1. + 2.7 *z_/obukhov_length) - else: - l2 = vkb * z_ - self.mixing_length[k] = fmax( 1.0/(1.0/fmax(l1,1e-10) + 1.0/l2), 1e-3) + with nogil: + for k in xrange(gw, self.Gr.nzg-gw): + l1 = tau * sqrt(fmax(self.EnvVar.TKE.values[k],0.0)) + z_ = self.Gr.z[k] + if obukhov_length < 0.0: #unstable + l2 = vkb * z_ * ( (1.0 - 100.0 * z_/obukhov_length)**0.2 ) + elif obukhov_length > 0.0: #stable + l2 = vkb * z_ / (1. + 2.7 *z_/obukhov_length) + else: + l2 = vkb * z_ + self.mixing_length[k] = fmax( 1.0/(1.0/fmax(l1,1e-10) + 1.0/l2), 1e-3) return cpdef compute_eddy_diffusivities_tke(self, GridMeanVariables GMV, CasesBase Case): diff --git a/generate_namelist.py b/generate_namelist.py index 1da8d8e1..394eab1e 100644 --- a/generate_namelist.py +++ b/generate_namelist.py @@ -107,13 +107,12 @@ def Bomex(): namelist['turbulence']['EDMF_PrognosticTKE']['entrainment'] = 'b_w2' namelist['turbulence']['EDMF_PrognosticTKE']['extrapolate_buoyancy'] = True namelist['turbulence']['EDMF_PrognosticTKE']['use_steady_updrafts'] = False - #namelist['turbulence']['EDMF_PrognosticTKE']['use_scalar_var'] = True - namelist['turbulence']['EDMF_PrognosticTKE']['mixing length'] = 'Ellison_scale' + namelist['turbulence']['EDMF_PrognosticTKE']['calc_scalar_var'] = True namelist['turbulence']['EDMF_PrognosticTKE']['use_local_micro'] = True namelist['turbulence']['EDMF_PrognosticTKE']['use_similarity_diffusivity'] = False namelist['turbulence']['EDMF_PrognosticTKE']['constant_area'] = False namelist['turbulence']['EDMF_PrognosticTKE']['calculate_tke'] = True - namelist['turbulence']['EDMF_PrognosticTKE']['calc_scalar_var'] = True + namelist['output'] = {} namelist['output']['output_root'] = './' From 5aa00342371d9cf0b4cf1c9a69c41872a64a6ab1 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Fri, 7 Sep 2018 16:35:33 -0700 Subject: [PATCH 066/136] fixing update_GMV_MF so that self.m is at full levels and the tendency is at half levels --- Turbulence_PrognosticTKE.pyx | 20 +++++++++++--------- 1 file changed, 11 insertions(+), 9 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 233b5c62..821039a0 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -904,12 +904,12 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # thereby updating to GMV.SomeVar.mf_update # mass flux tendency is computed as 1st order upwind - cpdef update_GMV_MF(self, GridMeanVariables GMV, TimeStepping TS): +cpdef update_GMV_MF(self, GridMeanVariables GMV, TimeStepping TS): cdef: Py_ssize_t k, i Py_ssize_t gw = self.Gr.gw double mf_tend_h=0.0, mf_tend_qt=0.0 - double env_h, env_qt + double env_h_interp, env_qt_interp, upd_h_interp, upd_qt_interp, m_kp, m_k self.massflux_h[:] = 0.0 self.massflux_qt[:] = 0.0 @@ -918,7 +918,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for i in xrange(self.n_updrafts): self.m[i,gw-1] = 0.0 for k in xrange(self.Gr.gw, self.Gr.nzg): - self.m[i,k] = ((self.UpdVar.W.values[i,k] - self.EnvVar.W.values[k] )* self.Ref.rho0[k] * self.UpdVar.Area.values[i,k]) + m_kp = ((self.UpdVar.W.values[i,k+1] - self.EnvVar.W.values[k+1] )* self.Ref.rho0[k+1] * self.UpdVar.Area.values[i,k+1]) + m_k = ((self.UpdVar.W.values[i,k] - self.EnvVar.W.values[k] )* self.Ref.rho0[k] * self.UpdVar.Area.values[i,k]) + self.m[i,k] = interp2pt(m_kp,m_k) self.massflux_h[gw-1] = 0.0 self.massflux_qt[gw-1] = 0.0 @@ -926,11 +928,13 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for k in xrange(gw, self.Gr.nzg-gw): self.massflux_h[k] = 0.0 self.massflux_qt[k] = 0.0 - env_h = self.EnvVar.H.values[k] - env_qt = self.EnvVar.QT.values[k] + env_h_interp = interp2pt(self.EnvVar.H.values[k], self.EnvVar.H.values[k+1]) + env_qt_interp = interp2pt(self.EnvVar.QT.values[k], self.EnvVar.QT.values[k+1]) for i in xrange(self.n_updrafts): - self.massflux_h[k] += self.m[i,k] * (self.UpdVar.H.values[i,k] - env_h ) - self.massflux_qt[k] += self.m[i,k] * (self.UpdVar.QT.values[i,k] - env_qt ) + upd_h_interp = interp2pt(self.UpdVar.H.values[i,k], self.UpdVar.H.values[i,k+1]) + upd_qt_interp = interp2pt(self.UpdVar.QT.values[i,k], self.UpdVar.QT.values[i,k+1]) + self.massflux_h[k] += self.m[i,k] * (upd_h_interp - env_h_interp ) + self.massflux_qt[k] += self.m[i,k] * (upd_qt_interp - env_qt_interp ) # Compute the mass flux tendencies # Adjust the values of the grid mean variables @@ -950,10 +954,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.massflux_tendency_h[k] = mf_tend_h self.massflux_tendency_qt[k] = mf_tend_qt - GMV.H.set_bcs(self.Gr) GMV.QT.set_bcs(self.Gr) - GMV.QR.set_bcs(self.Gr) GMV.U.set_bcs(self.Gr) GMV.V.set_bcs(self.Gr) From caa09c2f3d757bbf0581e3be897808d597df6b50 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Fri, 7 Sep 2018 16:36:23 -0700 Subject: [PATCH 067/136] fixing update_GMV_MF so that self.m is at full levels and the tendency is at half levels --- Turbulence_PrognosticTKE.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 821039a0..74d251c6 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -904,7 +904,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # thereby updating to GMV.SomeVar.mf_update # mass flux tendency is computed as 1st order upwind -cpdef update_GMV_MF(self, GridMeanVariables GMV, TimeStepping TS): + cpdef update_GMV_MF(self, GridMeanVariables GMV, TimeStepping TS): cdef: Py_ssize_t k, i Py_ssize_t gw = self.Gr.gw From 63b5ef4ae563047c5fca139f51464cca4a5507f3 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Fri, 7 Sep 2018 17:02:26 -0700 Subject: [PATCH 068/136] cleanup of prints --- Turbulence_PrognosticTKE.pyx | 5 ----- 1 file changed, 5 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 74d251c6..c0e257c7 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -823,13 +823,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.H.new[i,k] = GMV.H.values[k] self.UpdVar.QT.new[i,k] = GMV.QT.values[k] - if self.UpdVar.H.new[i,k] < 280 or self.UpdVar.H.new[i,k] > 450: - print 'before sa mean,', k, self.UpdVar.H.new[i,k], self.UpdVar.H.values[i,k], self.UpdVar.W.values[i,k], self.UpdVar.H.values[i,k-1], self.UpdVar.H.values[i,k], self.UpdVar.H.values[i,k+1], self.EnvVar.H.values[k+1], GMV.H.values[k+1] - sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0[k], self.UpdVar.QT.new[i,k], self.UpdVar.H.new[i,k]) - if np.isnan(sa.T): - print 'sa_mean,', k, self.UpdVar.H.new[i,k], self.UpdVar.H.values[i,k], self.UpdVar.W.values[i,k], self.UpdVar.H.values[i,k-1], self.UpdVar.H.values[i,k], self.UpdVar.H.values[i,k+1], self.EnvVar.H.values[k+1], GMV.H.values[k+1] self.UpdVar.QL.new[i,k] = sa.ql self.UpdVar.T.new[i,k] = sa.T From 7b753e89b86a7c67e4130aa14bdf0f49af625ed3 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Sat, 8 Sep 2018 12:40:20 -0700 Subject: [PATCH 069/136] add conditios to calc tke and cov in stats_io prog TKE --- Cases.pyx | 1 - Turbulence_PrognosticTKE.pyx | 67 +++++++++++++++++------------------- generate_namelist.py | 30 ++++++++-------- generate_paramlist.py | 13 ++++--- 4 files changed, 52 insertions(+), 59 deletions(-) diff --git a/Cases.pyx b/Cases.pyx index b0f7dc28..14fc41b6 100644 --- a/Cases.pyx +++ b/Cases.pyx @@ -867,7 +867,6 @@ cdef class ARM_SGP(CasesBase): Theta_in = np.array([299.0, 301.5, 302.5, 303.53, 303.7, 307.13, 314.0, 343.2]) # K r_in = np.array([15.2,15.17,14.98,14.8,14.7,13.5,3.0,3.0])/1000 # qt should be in kg/kg qt_in = np.divide(r_in,(1+r_in)) - print qt_in # interpolate to the model grid-points Theta = np.interp(Gr.z,z_in,Theta_in) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index c0e257c7..e5aa3227 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -273,40 +273,38 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Stats.write_profile('updraft_thetal_precip', self.UpdMicro.prec_source_h_tot[kmin:kmax]) # can these pointer function called inside the write command , or should they be called before it? - self.compute_covariance_dissipation(self.EnvVar.TKE) - Stats.write_profile('tke_dissipation', self.EnvVar.TKE.dissipation[kmin:kmax]) - self.compute_covariance_dissipation(self.EnvVar.Hvar) - Stats.write_profile('Hvar_dissipation', self.EnvVar.Hvar.dissipation[kmin:kmax]) - self.compute_covariance_dissipation(self.EnvVar.QTvar) - Stats.write_profile('QTvar_dissipation', self.EnvVar.QTvar.dissipation[kmin:kmax]) - self.compute_covariance_dissipation(self.EnvVar.HQTcov) - Stats.write_profile('HQTcov_dissipation', self.EnvVar.HQTcov.dissipation[kmin:kmax]) - - Stats.write_profile('tke_entr_gain', self.EnvVar.TKE.entr_gain[kmin:kmax]) - Stats.write_profile('Hvar_entr_gain', self.EnvVar.Hvar.entr_gain[kmin:kmax]) - Stats.write_profile('QTvar_entr_gain', self.EnvVar.QTvar.entr_gain[kmin:kmax]) - Stats.write_profile('HQTcov_entr_gain', self.EnvVar.HQTcov.entr_gain[kmin:kmax]) - self.compute_covariance_detr(self.EnvVar.TKE) - self.compute_covariance_detr(self.EnvVar.Hvar) - self.compute_covariance_detr(self.EnvVar.QTvar) - self.compute_covariance_detr(self.EnvVar.HQTcov) - Stats.write_profile('tke_detr_loss', self.EnvVar.TKE.detr_loss[kmin:kmax]) - Stats.write_profile('Hvar_detr_loss', self.EnvVar.Hvar.detr_loss[kmin:kmax]) - Stats.write_profile('QTvar_detr_loss', self.EnvVar.QTvar.detr_loss[kmin:kmax]) - Stats.write_profile('HQTcov_detr_loss', self.EnvVar.HQTcov.detr_loss[kmin:kmax]) - Stats.write_profile('tke_shear', self.EnvVar.TKE.shear[kmin:kmax]) - Stats.write_profile('Hvar_shear', self.EnvVar.Hvar.shear[kmin:kmax]) - Stats.write_profile('QTvar_shear', self.EnvVar.QTvar.shear[kmin:kmax]) - Stats.write_profile('HQTcov_shear', self.EnvVar.HQTcov.shear[kmin:kmax]) - Stats.write_profile('Hvar_rain', self.EnvVar.Hvar.rain_src[kmin:kmax]) - Stats.write_profile('QTvar_rain', self.EnvVar.QTvar.rain_src[kmin:kmax]) - Stats.write_profile('HQTcov_rain', self.EnvVar.HQTcov.rain_src[kmin:kmax]) - - Stats.write_profile('tke_buoy', self.EnvVar.TKE.buoy[kmin:kmax]) - Stats.write_profile('tke_pressure', self.EnvVar.TKE.press[kmin:kmax]) - - + if self.calc_tke: + self.compute_covariance_dissipation(self.EnvVar.TKE) + Stats.write_profile('tke_dissipation', self.EnvVar.TKE.dissipation[kmin:kmax]) + Stats.write_profile('tke_entr_gain', self.EnvVar.TKE.entr_gain[kmin:kmax]) + self.compute_covariance_detr(self.EnvVar.TKE) + Stats.write_profile('tke_detr_loss', self.EnvVar.TKE.detr_loss[kmin:kmax]) + Stats.write_profile('tke_shear', self.EnvVar.TKE.shear[kmin:kmax]) + Stats.write_profile('tke_buoy', self.EnvVar.TKE.buoy[kmin:kmax]) + Stats.write_profile('tke_pressure', self.EnvVar.TKE.press[kmin:kmax]) + if self.calc_scalar_var: + self.compute_covariance_dissipation(self.EnvVar.Hvar) + Stats.write_profile('Hvar_dissipation', self.EnvVar.Hvar.dissipation[kmin:kmax]) + self.compute_covariance_dissipation(self.EnvVar.QTvar) + Stats.write_profile('QTvar_dissipation', self.EnvVar.QTvar.dissipation[kmin:kmax]) + self.compute_covariance_dissipation(self.EnvVar.HQTcov) + Stats.write_profile('HQTcov_dissipation', self.EnvVar.HQTcov.dissipation[kmin:kmax]) + Stats.write_profile('Hvar_entr_gain', self.EnvVar.Hvar.entr_gain[kmin:kmax]) + Stats.write_profile('QTvar_entr_gain', self.EnvVar.QTvar.entr_gain[kmin:kmax]) + Stats.write_profile('HQTcov_entr_gain', self.EnvVar.HQTcov.entr_gain[kmin:kmax]) + self.compute_covariance_detr(self.EnvVar.Hvar) + self.compute_covariance_detr(self.EnvVar.QTvar) + self.compute_covariance_detr(self.EnvVar.HQTcov) + Stats.write_profile('Hvar_detr_loss', self.EnvVar.Hvar.detr_loss[kmin:kmax]) + Stats.write_profile('QTvar_detr_loss', self.EnvVar.QTvar.detr_loss[kmin:kmax]) + Stats.write_profile('HQTcov_detr_loss', self.EnvVar.HQTcov.detr_loss[kmin:kmax]) + Stats.write_profile('Hvar_shear', self.EnvVar.Hvar.shear[kmin:kmax]) + Stats.write_profile('QTvar_shear', self.EnvVar.QTvar.shear[kmin:kmax]) + Stats.write_profile('HQTcov_shear', self.EnvVar.HQTcov.shear[kmin:kmax]) + Stats.write_profile('Hvar_rain', self.EnvVar.Hvar.rain_src[kmin:kmax]) + Stats.write_profile('QTvar_rain', self.EnvVar.QTvar.rain_src[kmin:kmax]) + Stats.write_profile('HQTcov_rain', self.EnvVar.HQTcov.rain_src[kmin:kmax]) # Perform the update of the scheme @@ -315,11 +313,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Py_ssize_t k Py_ssize_t kmin = self.Gr.gw Py_ssize_t kmax = self.Gr.nzg - self.Gr.gw - self.update_inversion(GMV, Case.inversion_option) - self.wstar = get_wstar(Case.Sur.bflux, self.zi) - if TS.nstep == 0: self.initialize_covariance(GMV, Case) self.decompose_environment(GMV, 'values') diff --git a/generate_namelist.py b/generate_namelist.py index 394eab1e..5aaecfc4 100644 --- a/generate_namelist.py +++ b/generate_namelist.py @@ -90,7 +90,7 @@ def Bomex(): namelist['grid']['dims'] = 1 namelist['grid']['nz'] = 75 namelist['grid']['gw'] = 2 - namelist['grid']['dz'] = 100 / 2.5 + namelist['grid']['dz'] = 40 namelist['thermodynamics'] = {} namelist['thermodynamics']['thermal_variable'] = 'thetal' @@ -135,7 +135,7 @@ def life_cycle_Tan2018(): namelist['grid']['dims'] = 1 namelist['grid']['nz'] = 75 namelist['grid']['gw'] = 2 - namelist['grid']['dz'] = 100 / 2.5 + namelist['grid']['dz'] = 40 namelist['thermodynamics'] = {} namelist['thermodynamics']['saturation'] = 'sa_mean' @@ -152,7 +152,6 @@ def life_cycle_Tan2018(): namelist['turbulence']['EDMF_PrognosticTKE']['entrainment'] = 'b_w2' namelist['turbulence']['EDMF_PrognosticTKE']['extrapolate_buoyancy'] = True namelist['turbulence']['EDMF_PrognosticTKE']['use_steady_updrafts'] = False - # namelist['turbulence']['EDMF_PrognosticTKE']['use_scalar_var'] = True namelist['turbulence']['EDMF_PrognosticTKE']['mixing length'] = 'tke' namelist['turbulence']['EDMF_PrognosticTKE']['use_local_micro'] = True namelist['turbulence']['EDMF_PrognosticTKE']['use_similarity_diffusivity'] = False @@ -197,7 +196,6 @@ def Rico(): namelist['turbulence']['EDMF_PrognosticTKE']['entrainment'] = 'b_w2' namelist['turbulence']['EDMF_PrognosticTKE']['extrapolate_buoyancy'] = True namelist['turbulence']['EDMF_PrognosticTKE']['use_steady_updrafts'] = False - # namelist['turbulence']['EDMF_PrognosticTKE']['use_scalar_var'] = True namelist['turbulence']['EDMF_PrognosticTKE']['mixing length'] = 'Ellison_scale' namelist['turbulence']['EDMF_PrognosticTKE']['use_local_micro'] = True namelist['turbulence']['EDMF_PrognosticTKE']['use_similarity_diffusivity'] = False @@ -218,7 +216,7 @@ def Rico(): return namelist -def TRMM_LBA(): # yair +def TRMM_LBA(): namelist = {} @@ -290,7 +288,8 @@ def ARM_SGP(): namelist['turbulence']['EDMF_PrognosticTKE']['updraft_surface_height'] = 0.0 namelist['turbulence']['EDMF_PrognosticTKE']['extrapolate_buoyancy'] = True namelist['turbulence']['EDMF_PrognosticTKE']['use_steady_updrafts'] = False - #namelist['turbulence']['EDMF_PrognosticTKE']['calc_scalar_var'] = False + namelist['turbulence']['EDMF_PrognosticTKE']['calculate_tke'] = True + namelist['turbulence']['EDMF_PrognosticTKE']['calc_scalar_var'] = True namelist['output'] = {} namelist['output']['output_root'] = './' @@ -305,36 +304,37 @@ def ARM_SGP(): return namelist -def GATE_III(): # yair +def GATE_III(): # adopted from: "Large eddy simulation of Maritime Deep Tropical Convection", # By Khairoutdinov et al (2009) JAMES, vol. 1, article #15 namelist = {} namelist['grid'] = {} namelist['grid']['dims'] = 1 - namelist['grid']['nz'] = 1700 + namelist['grid']['nz'] = 400 namelist['grid']['gw'] = 2 - namelist['grid']['dz'] = 10 + namelist['grid']['dz'] = 40 namelist['thermodynamics'] = {} namelist['thermodynamics']['saturation'] = 'sa_mean' namelist['thermodynamics']['thermal_variable'] = 'thetal' namelist['time_stepping'] = {} - namelist['time_stepping']['dt'] = 5.0 + namelist['time_stepping']['dt'] = 30.0 namelist['time_stepping']['t_max'] = 3600.0 * 24.0 namelist['turbulence'] = {} namelist['turbulence']['scheme'] = 'EDMF_PrognosticTKE' namelist['turbulence']['EDMF_PrognosticTKE'] = {} namelist['turbulence']['EDMF_PrognosticTKE']['updraft_number'] = 1 - namelist['turbulence']['EDMF_PrognosticTKE']['entrainment'] = 'b_w2' + namelist['turbulence']['EDMF_PrognosticTKE']['entrainment'] = 'inverse_w' namelist['turbulence']['EDMF_PrognosticTKE']['use_local_micro'] = True - namelist['turbulence']['EDMF_PrognosticTKE']['use_similarity_diffusivity'] = True # False + namelist['turbulence']['EDMF_PrognosticTKE']['use_similarity_diffusivity'] = True namelist['turbulence']['EDMF_PrognosticTKE']['updraft_surface_height'] = 0.0 namelist['turbulence']['EDMF_PrognosticTKE']['extrapolate_buoyancy'] = True namelist['turbulence']['EDMF_PrognosticTKE']['use_steady_updrafts'] = False - #namelist['turbulence']['EDMF_PrognosticTKE']['calc_scalar_var'] = False + namelist['turbulence']['EDMF_PrognosticTKE']['calculate_tke'] = True + namelist['turbulence']['EDMF_PrognosticTKE']['calc_scalar_var'] = True namelist['output'] = {} namelist['output']['output_root'] = './' @@ -376,8 +376,8 @@ def DYCOMS_RF01(): namelist['turbulence']['EDMF_PrognosticTKE']['use_local_micro'] = True namelist['turbulence']['EDMF_PrognosticTKE']['use_similarity_diffusivity'] = False namelist['turbulence']['EDMF_PrognosticTKE']['extrapolate_buoyancy'] = True - #namelist['turbulence']['EDMF_PrognosticTKE']['constant_area'] = False - #namelist['turbulence']['EDMF_PrognosticTKE']['calc_scalar_var'] = True + namelist['turbulence']['EDMF_PrognosticTKE']['calculate_tke'] = True + namelist['turbulence']['EDMF_PrognosticTKE']['calc_scalar_var'] = True namelist['output'] = {} namelist['output']['output_root'] = './' diff --git a/generate_paramlist.py b/generate_paramlist.py index b1e05962..fad7d5e6 100644 --- a/generate_paramlist.py +++ b/generate_paramlist.py @@ -233,10 +233,9 @@ def ARM_SGP(): def GATE_III(): - paramlist = {} paramlist['meta'] = {} - paramlist['meta']['casename'] = 'GATE_III' + paramlist['meta']['casename'] = 'TRMM_LBA' paramlist['turbulence'] = {} paramlist['turbulence']['prandtl_number'] = 1.0 @@ -245,15 +244,15 @@ def GATE_III(): paramlist['turbulence']['EDMF_PrognosticTKE'] = {} paramlist['turbulence']['EDMF_PrognosticTKE']['surface_area'] = 0.1 paramlist['turbulence']['EDMF_PrognosticTKE']['tke_ed_coeff'] = 0.1 - paramlist['turbulence']['EDMF_PrognosticTKE']['tke_diss_coeff'] = 0.7 - paramlist['turbulence']['EDMF_PrognosticTKE']['max_area_factor'] = 9.9 + paramlist['turbulence']['EDMF_PrognosticTKE']['tke_diss_coeff'] = 2.0 + paramlist['turbulence']['EDMF_PrognosticTKE']['max_area_factor'] = 5.0 paramlist['turbulence']['EDMF_PrognosticTKE']['entrainment_factor'] = 1.0 paramlist['turbulence']['EDMF_PrognosticTKE']['detrainment_factor'] = 1.0 paramlist['turbulence']['EDMF_PrognosticTKE']['pressure_buoy_coeff'] = 1.0 / 3.0 - paramlist['turbulence']['EDMF_PrognosticTKE']['pressure_drag_coeff'] = 0.075 - paramlist['turbulence']['EDMF_PrognosticTKE']['pressure_plume_spacing'] = 100.0 + paramlist['turbulence']['EDMF_PrognosticTKE']['pressure_drag_coeff'] = 0.375 + paramlist['turbulence']['EDMF_PrognosticTKE']['pressure_plume_spacing'] = 1000.0 paramlist['turbulence']['updraft_microphysics'] = {} - paramlist['turbulence']['updraft_microphysics']['max_supersaturation'] = 0.1 + paramlist['turbulence']['updraft_microphysics']['max_supersaturation'] = 0.01 return paramlist From e7bea043c07c01f8a83aad4dc25f42cab1349832 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Tue, 11 Sep 2018 16:51:39 -0700 Subject: [PATCH 070/136] set_bc for w and a --- Turbulence_PrognosticTKE.pyx | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index e5aa3227..5b7e3e89 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -838,9 +838,12 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # Update updraft variables with microphysical source tendencies self.UpdMicro.update_updraftvars(self.UpdVar) - self.UpdVar.H.set_bcs(self.Gr) # do we need to set BC for a ad w as well ? + self.UpdVar.H.set_bcs(self.Gr) self.UpdVar.QT.set_bcs(self.Gr) self.UpdVar.QR.set_bcs(self.Gr) + self.UpdVar.W.set_bcs(self.Gr) + self.UpdVar.Area.set_bcs(self.Gr) + return cpdef upwind_integration(self, EDMF_Updrafts.UpdraftVariable area, EDMF_Updrafts.UpdraftVariable var, int k, int i, double env_var): From 4c44be161172fc417168de413eb660c78f05e386 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Tue, 11 Sep 2018 17:10:12 -0700 Subject: [PATCH 071/136] add if ws<0 flag in initialize_covariances --- Turbulence_PrognosticTKE.pyx | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 5b7e3e89..cbd89dc3 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -1196,13 +1196,14 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): z = self.Gr.z[k] GMV.TKE.values[k] = ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) if self.calc_scalar_var: - with nogil: - for k in xrange(self.Gr.nzg): - z = self.Gr.z[k] - # need to rethink of how to initilize the covarinace profiles - for nowmI took the TKE profile - GMV.Hvar.values[k] = GMV.Hvar.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) - GMV.QTvar.values[k] = GMV.QTvar.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) - GMV.HQTcov.values[k] = GMV.HQTcov.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) + if ws > 0.0: + with nogil: + for k in xrange(self.Gr.nzg): + z = self.Gr.z[k] + # need to rethink of how to initilize the covarinace profiles - for nowmI took the TKE profile + GMV.Hvar.values[k] = GMV.Hvar.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) + GMV.QTvar.values[k] = GMV.QTvar.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) + GMV.HQTcov.values[k] = GMV.HQTcov.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) self.reset_surface_covariance(GMV, Case) self.compute_mixing_length(Case.Sur.obukhov_length, GMV) From 941571ce7af488033d23935e337c3fb3ee8ef649 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Wed, 12 Sep 2018 16:48:02 -0700 Subject: [PATCH 072/136] adding _f and _c for Ref profiles and adding function for calc the MF term for variances --- Cases.pyx | 298 +++++++++++++++++------------------ EDMF_Environment.pxd | 1 + EDMF_Environment.pyx | 35 ++-- EDMF_Updrafts.pyx | 26 +-- Forcing.pyx | 14 +- Grid.pxd | 3 +- Grid.pyx | 10 +- NetCDFIO.pyx | 18 ++- ReferenceState.pxd | 10 +- ReferenceState.pyx | 101 +++++++----- Surface.pyx | 34 ++-- Turbulence.pyx | 22 +-- Turbulence_PrognosticTKE.pxd | 2 + Turbulence_PrognosticTKE.pyx | 194 +++++++++++++---------- Variables.pyx | 6 +- 15 files changed, 421 insertions(+), 353 deletions(-) diff --git a/Cases.pyx b/Cases.pyx index 14fc41b6..b19890b4 100644 --- a/Cases.pyx +++ b/Cases.pyx @@ -87,13 +87,13 @@ cdef class Soares(CasesBase): Py_ssize_t k for k in xrange(Gr.gw, Gr.nzg-Gr.gw): - if Gr.z[k] <= 1350.0: - GMV.QT.values[k] = 5.0e-3 - 3.7e-4* Gr.z[k]/1000.0 + if Gr.z_c[k] <= 1350.0: + GMV.QT.values[k] = 5.0e-3 - 3.7e-4* Gr.z_c[k]/1000.0 theta[k] = 300.0 else: - GMV.QT.values[k] = 5.0e-3 - 3.7e-4 * 1.35 - 9.4e-4 * (Gr.z[k]-1350.0)/1000.0 - theta[k] = 300.0 + 2.0 * (Gr.z[k]-1350.0)/1000.0 + GMV.QT.values[k] = 5.0e-3 - 3.7e-4 * 1.35 - 9.4e-4 * (Gr.z_c[k]-1350.0)/1000.0 + theta[k] = 300.0 + 2.0 * (Gr.z_c[k]-1350.0)/1000.0 GMV.U.values[k] = 0.01 GMV.U.set_bcs(Gr) @@ -102,14 +102,14 @@ cdef class Soares(CasesBase): if GMV.H.name == 'thetal': for k in xrange(Gr.gw,Gr.nzg-Gr.gw): GMV.H.values[k] = theta[k] - GMV.T.values[k] = theta[k] * exner_c(Ref.p0[k]) + GMV.T.values[k] = theta[k] * exner_c(Ref.p0_c[k]) GMV.THL.values[k] = theta[k] elif GMV.H.name == 's': for k in xrange(Gr.gw,Gr.nzg-Gr.gw): - GMV.T.values[k] = theta[k] * exner_c(Ref.p0[k]) - GMV.H.values[k] = t_to_entropy_c(Ref.p0[k],GMV.T.values[k], + GMV.T.values[k] = theta[k] * exner_c(Ref.p0_c[k]) + GMV.H.values[k] = t_to_entropy_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], ql, qi) - GMV.THL.values[k] = thetali_c(Ref.p0[k],GMV.T.values[k], + GMV.THL.values[k] = thetali_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], ql, qi, latent_heat(GMV.T.values[k])) GMV.H.set_bcs(Gr) @@ -122,8 +122,8 @@ cdef class Soares(CasesBase): self.Sur.zrough = 1.0e-4 self.Sur.Tsurface = 300.0 self.Sur.qsurface = 5e-3 - self.Sur.lhf = 2.5e-5 * Ref.rho0[Gr.gw -1] * latent_heat(self.Sur.Tsurface) - self.Sur.shf = 6.0e-2 * cpm_c(self.Sur.qsurface) * Ref.rho0[Gr.gw-1] + self.Sur.lhf = 2.5e-5 * Ref.rho0_f[Gr.gw -1] * latent_heat(self.Sur.Tsurface) + self.Sur.shf = 6.0e-2 * cpm_c(self.Sur.qsurface) * Ref.rho0_f[Gr.gw-1] self.Sur.ustar_fixed = False self.Sur.Gr = Gr self.Sur.Ref = Ref @@ -175,43 +175,43 @@ cdef class Bomex(CasesBase): for k in xrange(Gr.gw,Gr.nzg-Gr.gw): #Set Thetal profile - if Gr.z[k] <= 520.: + if Gr.z_c[k] <= 520.: thetal[k] = 298.7 - if Gr.z[k] > 520.0 and Gr.z[k] <= 1480.0: - thetal[k] = 298.7 + (Gr.z[k] - 520) * (302.4 - 298.7)/(1480.0 - 520.0) - if Gr.z[k] > 1480.0 and Gr.z[k] <= 2000: - thetal[k] = 302.4 + (Gr.z[k] - 1480.0) * (308.2 - 302.4)/(2000.0 - 1480.0) - if Gr.z[k] > 2000.0: - thetal[k] = 308.2 + (Gr.z[k] - 2000.0) * (311.85 - 308.2)/(3000.0 - 2000.0) + if Gr.z_c[k] > 520.0 and Gr.z_c[k] <= 1480.0: + thetal[k] = 298.7 + (Gr.z_c[k] - 520) * (302.4 - 298.7)/(1480.0 - 520.0) + if Gr.z_c[k] > 1480.0 and Gr.z_c[k] <= 2000: + thetal[k] = 302.4 + (Gr.z_c[k] - 1480.0) * (308.2 - 302.4)/(2000.0 - 1480.0) + if Gr.z_c[k] > 2000.0: + thetal[k] = 308.2 + (Gr.z_c[k] - 2000.0) * (311.85 - 308.2)/(3000.0 - 2000.0) #Set qt profile - if Gr.z[k] <= 520: - GMV.QT.values[k] = (17.0 + (Gr.z[k]) * (16.3-17.0)/520.0)/1000.0 - if Gr.z[k] > 520.0 and Gr.z[k] <= 1480.0: - GMV.QT.values[k] = (16.3 + (Gr.z[k] - 520.0)*(10.7 - 16.3)/(1480.0 - 520.0))/1000.0 - if Gr.z[k] > 1480.0 and Gr.z[k] <= 2000.0: - GMV.QT.values[k] = (10.7 + (Gr.z[k] - 1480.0) * (4.2 - 10.7)/(2000.0 - 1480.0))/1000.0 - if Gr.z[k] > 2000.0: - GMV.QT.values[k] = (4.2 + (Gr.z[k] - 2000.0) * (3.0 - 4.2)/(3000.0 - 2000.0))/1000.0 + if Gr.z_c[k] <= 520: + GMV.QT.values[k] = (17.0 + (Gr.z_c[k]) * (16.3-17.0)/520.0)/1000.0 + if Gr.z_c[k] > 520.0 and Gr.z_c[k] <= 1480.0: + GMV.QT.values[k] = (16.3 + (Gr.z_c[k] - 520.0)*(10.7 - 16.3)/(1480.0 - 520.0))/1000.0 + if Gr.z_c[k] > 1480.0 and Gr.z_c[k] <= 2000.0: + GMV.QT.values[k] = (10.7 + (Gr.z_c[k] - 1480.0) * (4.2 - 10.7)/(2000.0 - 1480.0))/1000.0 + if Gr.z_c[k] > 2000.0: + GMV.QT.values[k] = (4.2 + (Gr.z_c[k] - 2000.0) * (3.0 - 4.2)/(3000.0 - 2000.0))/1000.0 #Set u profile - if Gr.z[k] <= 700.0: + if Gr.z_c[k] <= 700.0: GMV.U.values[k] = -8.75 - if Gr.z[k] > 700.0: - GMV.U.values[k] = -8.75 + (Gr.z[k] - 700.0) * (-4.61 - -8.75)/(3000.0 - 700.0) + if Gr.z_c[k] > 700.0: + GMV.U.values[k] = -8.75 + (Gr.z_c[k] - 700.0) * (-4.61 - -8.75)/(3000.0 - 700.0) if GMV.H.name == 'thetal': for k in xrange(Gr.gw,Gr.nzg-Gr.gw): GMV.H.values[k] = thetal[k] - GMV.T.values[k] = thetal[k] * exner_c(Ref.p0[k]) + GMV.T.values[k] = thetal[k] * exner_c(Ref.p0_c[k]) GMV.THL.values[k] = thetal[k] elif GMV.H.name == 's': for k in xrange(Gr.gw,Gr.nzg-Gr.gw): - GMV.T.values[k] = thetal[k] * exner_c(Ref.p0[k]) - GMV.H.values[k] = t_to_entropy_c(Ref.p0[k],GMV.T.values[k], + GMV.T.values[k] = thetal[k] * exner_c(Ref.p0_c[k]) + GMV.H.values[k] = t_to_entropy_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], ql, qi) - GMV.THL.values[k] = thetali_c(Ref.p0[k],GMV.T.values[k], + GMV.THL.values[k] = thetali_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], ql, qi, latent_heat(GMV.T.values[k])) GMV.U.set_bcs(Gr) @@ -225,8 +225,8 @@ cdef class Bomex(CasesBase): self.Sur.zrough = 1.0e-4 # not actually used, but initialized to reasonable value self.Sur.Tsurface = 299.1 * exner_c(Ref.Pg) self.Sur.qsurface = 22.45e-3 # kg/kg - self.Sur.lhf = 5.2e-5 * Ref.rho0[Gr.gw -1] * latent_heat(self.Sur.Tsurface) - self.Sur.shf = 8.0e-3 * cpm_c(self.Sur.qsurface) * Ref.rho0[Gr.gw-1] + self.Sur.lhf = 5.2e-5 * Ref.rho0_f[Gr.gw -1] * latent_heat(self.Sur.Tsurface) + self.Sur.shf = 8.0e-3 * cpm_c(self.Sur.qsurface) * Ref.rho0_f[Gr.gw-1] self.Sur.ustar_fixed = True self.Sur.ustar = 0.28 # m/s self.Sur.Gr = Gr @@ -240,24 +240,24 @@ cdef class Bomex(CasesBase): cdef Py_ssize_t k for k in xrange(Gr.gw, Gr.nzg-Gr.gw): # Geostrophic velocity profiles. vg = 0 - self.Fo.ug[k] = -10.0 + (1.8e-3)*Gr.z[k] + self.Fo.ug[k] = -10.0 + (1.8e-3)*Gr.z_c[k] # Set large-scale cooling - if Gr.z[k] <= 1500.0: - self.Fo.dTdt[k] = (-2.0/(3600 * 24.0)) * exner_c(Ref.p0[k]) + if Gr.z_c[k] <= 1500.0: + self.Fo.dTdt[k] = (-2.0/(3600 * 24.0)) * exner_c(Ref.p0_c[k]) else: - self.Fo.dTdt[k] = (-2.0/(3600 * 24.0) + (Gr.z[k] - 1500.0) - * (0.0 - -2.0/(3600 * 24.0)) / (3000.0 - 1500.0)) * exner_c(Ref.p0[k]) + self.Fo.dTdt[k] = (-2.0/(3600 * 24.0) + (Gr.z_c[k] - 1500.0) + * (0.0 - -2.0/(3600 * 24.0)) / (3000.0 - 1500.0)) * exner_c(Ref.p0_c[k]) # Set large-scale drying - if Gr.z[k] <= 300.0: + if Gr.z_c[k] <= 300.0: self.Fo.dqtdt[k] = -1.2e-8 #kg/(kg * s) - if Gr.z[k] > 300.0 and Gr.z[k] <= 500.0: - self.Fo.dqtdt[k] = -1.2e-8 + (Gr.z[k] - 300.0)*(0.0 - -1.2e-8)/(500.0 - 300.0) #kg/(kg * s) + if Gr.z_c[k] > 300.0 and Gr.z_c[k] <= 500.0: + self.Fo.dqtdt[k] = -1.2e-8 + (Gr.z_c[k] - 300.0)*(0.0 - -1.2e-8)/(500.0 - 300.0) #kg/(kg * s) #Set large scale subsidence - if Gr.z[k] <= 1500.0: - self.Fo.subsidence[k] = 0.0 + Gr.z[k]*(-0.65/100.0 - 0.0)/(1500.0 - 0.0) - if Gr.z[k] > 1500.0 and Gr.z[k] <= 2100.0: - self.Fo.subsidence[k] = -0.65/100 + (Gr.z[k] - 1500.0)* (0.0 - -0.65/100.0)/(2100.0 - 1500.0) + if Gr.z_c[k] <= 1500.0: + self.Fo.subsidence[k] = 0.0 + Gr.z_c[k]*(-0.65/100.0 - 0.0)/(1500.0 - 0.0) + if Gr.z_c[k] > 1500.0 and Gr.z_c[k] <= 2100.0: + self.Fo.subsidence[k] = -0.65/100 + (Gr.z_c[k] - 1500.0)* (0.0 - -0.65/100.0)/(2100.0 - 1500.0) return cpdef initialize_io(self, NetCDFIO_Stats Stats): @@ -299,44 +299,44 @@ cdef class life_cycle_Tan2018(CasesBase): double ql=0.0, qi =0.0 # IC of Bomex is cloud-free for k in xrange(Gr.gw,Gr.nzg-Gr.gw): #Set Thetal profile - if Gr.z[k] <= 520.: + if Gr.z_c[k] <= 520.: thetal[k] = 298.7 - if Gr.z[k] > 520.0 and Gr.z[k] <= 1480.0: - thetal[k] = 298.7 + (Gr.z[k] - 520) * (302.4 - 298.7)/(1480.0 - 520.0) - if Gr.z[k] > 1480.0 and Gr.z[k] <= 2000: - thetal[k] = 302.4 + (Gr.z[k] - 1480.0) * (308.2 - 302.4)/(2000.0 - 1480.0) - if Gr.z[k] > 2000.0: - thetal[k] = 308.2 + (Gr.z[k] - 2000.0) * (311.85 - 308.2)/(3000.0 - 2000.0) + if Gr.z_c[k] > 520.0 and Gr.z_c[k] <= 1480.0: + thetal[k] = 298.7 + (Gr.z_c[k] - 520) * (302.4 - 298.7)/(1480.0 - 520.0) + if Gr.z_c[k] > 1480.0 and Gr.z_c[k] <= 2000: + thetal[k] = 302.4 + (Gr.z_c[k] - 1480.0) * (308.2 - 302.4)/(2000.0 - 1480.0) + if Gr.z_c[k] > 2000.0: + thetal[k] = 308.2 + (Gr.z_c[k] - 2000.0) * (311.85 - 308.2)/(3000.0 - 2000.0) #Set qt profile - if Gr.z[k] <= 520: - GMV.QT.values[k] = (17.0 + (Gr.z[k]) * (16.3-17.0)/520.0)/1000.0 - if Gr.z[k] > 520.0 and Gr.z[k] <= 1480.0: - GMV.QT.values[k] = (16.3 + (Gr.z[k] - 520.0)*(10.7 - 16.3)/(1480.0 - 520.0))/1000.0 - if Gr.z[k] > 1480.0 and Gr.z[k] <= 2000.0: - GMV.QT.values[k] = (10.7 + (Gr.z[k] - 1480.0) * (4.2 - 10.7)/(2000.0 - 1480.0))/1000.0 - if Gr.z[k] > 2000.0: - GMV.QT.values[k] = (4.2 + (Gr.z[k] - 2000.0) * (3.0 - 4.2)/(3000.0 - 2000.0))/1000.0 + if Gr.z_c[k] <= 520: + GMV.QT.values[k] = (17.0 + (Gr.z_c[k]) * (16.3-17.0)/520.0)/1000.0 + if Gr.z_c[k] > 520.0 and Gr.z_c[k] <= 1480.0: + GMV.QT.values[k] = (16.3 + (Gr.z_c[k] - 520.0)*(10.7 - 16.3)/(1480.0 - 520.0))/1000.0 + if Gr.z_c[k] > 1480.0 and Gr.z_c[k] <= 2000.0: + GMV.QT.values[k] = (10.7 + (Gr.z_c[k] - 1480.0) * (4.2 - 10.7)/(2000.0 - 1480.0))/1000.0 + if Gr.z_c[k] > 2000.0: + GMV.QT.values[k] = (4.2 + (Gr.z_c[k] - 2000.0) * (3.0 - 4.2)/(3000.0 - 2000.0))/1000.0 #Set u profile - if Gr.z[k] <= 700.0: + if Gr.z_c[k] <= 700.0: GMV.U.values[k] = -8.75 - if Gr.z[k] > 700.0: - GMV.U.values[k] = -8.75 + (Gr.z[k] - 700.0) * (-4.61 - -8.75)/(3000.0 - 700.0) + if Gr.z_c[k] > 700.0: + GMV.U.values[k] = -8.75 + (Gr.z_c[k] - 700.0) * (-4.61 - -8.75)/(3000.0 - 700.0) if GMV.H.name == 'thetal': for k in xrange(Gr.gw,Gr.nzg-Gr.gw): GMV.H.values[k] = thetal[k] - GMV.T.values[k] = thetal[k] * exner_c(Ref.p0[k]) + GMV.T.values[k] = thetal[k] * exner_c(Ref.p0_c[k]) GMV.THL.values[k] = thetal[k] elif GMV.H.name == 's': for k in xrange(Gr.gw,Gr.nzg-Gr.gw): - GMV.T.values[k] = thetal[k] * exner_c(Ref.p0[k]) - GMV.H.values[k] = t_to_entropy_c(Ref.p0[k],GMV.T.values[k], + GMV.T.values[k] = thetal[k] * exner_c(Ref.p0_c[k]) + GMV.H.values[k] = t_to_entropy_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], ql, qi) - GMV.THL.values[k] = thetali_c(Ref.p0[k],GMV.T.values[k], + GMV.THL.values[k] = thetali_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], ql, qi, latent_heat(GMV.T.values[k])) GMV.U.set_bcs(Gr) @@ -350,8 +350,8 @@ cdef class life_cycle_Tan2018(CasesBase): self.Sur.zrough = 1.0e-4 # not actually used, but initialized to reasonable value self.Sur.Tsurface = 299.1 * exner_c(Ref.Pg) self.Sur.qsurface = 22.45e-3 # kg/kg - self.Sur.lhf = 5.2e-5 * Ref.rho0[Gr.gw -1] * latent_heat(self.Sur.Tsurface) - self.Sur.shf = 8.0e-3 * cpm_c(self.Sur.qsurface) * Ref.rho0[Gr.gw-1] + self.Sur.lhf = 5.2e-5 * Ref.rho0_f[Gr.gw -1] * latent_heat(self.Sur.Tsurface) + self.Sur.shf = 8.0e-3 * cpm_c(self.Sur.qsurface) * Ref.rho0_f[Gr.gw-1] self.lhf0 = self.Sur.lhf self.shf0 = self.Sur.shf self.Sur.ustar_fixed = True @@ -367,24 +367,24 @@ cdef class life_cycle_Tan2018(CasesBase): self.Fo.initialize(GMV) for k in xrange(Gr.gw, Gr.nzg-Gr.gw): # Geostrophic velocity profiles. vg = 0 - self.Fo.ug[k] = -10.0 + (1.8e-3)*Gr.z[k] + self.Fo.ug[k] = -10.0 + (1.8e-3)*Gr.z_c[k] # Set large-scale cooling - if Gr.z[k] <= 1500.0: - self.Fo.dTdt[k] = (-2.0/(3600 * 24.0)) * exner_c(Ref.p0[k]) + if Gr.z_c[k] <= 1500.0: + self.Fo.dTdt[k] = (-2.0/(3600 * 24.0)) * exner_c(Ref.p0_c[k]) else: - self.Fo.dTdt[k] = (-2.0/(3600 * 24.0) + (Gr.z[k] - 1500.0) - * (0.0 - -2.0/(3600 * 24.0)) / (3000.0 - 1500.0)) * exner_c(Ref.p0[k]) + self.Fo.dTdt[k] = (-2.0/(3600 * 24.0) + (Gr.z_c[k] - 1500.0) + * (0.0 - -2.0/(3600 * 24.0)) / (3000.0 - 1500.0)) * exner_c(Ref.p0_c[k]) # Set large-scale drying - if Gr.z[k] <= 300.0: + if Gr.z_c[k] <= 300.0: self.Fo.dqtdt[k] = -1.2e-8 #kg/(kg * s) - if Gr.z[k] > 300.0 and Gr.z[k] <= 500.0: - self.Fo.dqtdt[k] = -1.2e-8 + (Gr.z[k] - 300.0)*(0.0 - -1.2e-8)/(500.0 - 300.0) #kg/(kg * s) + if Gr.z_c[k] > 300.0 and Gr.z_c[k] <= 500.0: + self.Fo.dqtdt[k] = -1.2e-8 + (Gr.z_c[k] - 300.0)*(0.0 - -1.2e-8)/(500.0 - 300.0) #kg/(kg * s) #Set large scale subsidence - if Gr.z[k] <= 1500.0: - self.Fo.subsidence[k] = 0.0 + Gr.z[k]*(-0.65/100.0 - 0.0)/(1500.0 - 0.0) - if Gr.z[k] > 1500.0 and Gr.z[k] <= 2100.0: - self.Fo.subsidence[k] = -0.65/100 + (Gr.z[k] - 1500.0)* (0.0 - -0.65/100.0)/(2100.0 - 1500.0) + if Gr.z_c[k] <= 1500.0: + self.Fo.subsidence[k] = 0.0 + Gr.z_c[k]*(-0.65/100.0 - 0.0)/(1500.0 - 0.0) + if Gr.z_c[k] > 1500.0 and Gr.z_c[k] <= 2100.0: + self.Fo.subsidence[k] = -0.65/100 + (Gr.z_c[k] - 1500.0)* (0.0 - -0.65/100.0)/(2100.0 - 1500.0) return cpdef initialize_io(self, NetCDFIO_Stats Stats): @@ -432,33 +432,33 @@ cdef class Rico(CasesBase): Py_ssize_t k for k in xrange(Gr.gw,Gr.nzg-Gr.gw): - GMV.U.values[k] = -9.9 + 2.0e-3 * Gr.z[k] + GMV.U.values[k] = -9.9 + 2.0e-3 * Gr.z_c[k] GMV.V.values[k] = -3.8 #Set Thetal profile - if Gr.z[k] <= 740.0: + if Gr.z_c[k] <= 740.0: thetal[k] = 297.9 else: - thetal[k] = 297.9 + (317.0-297.9)/(4000.0-740.0)*(Gr.z[k] - 740.0) + thetal[k] = 297.9 + (317.0-297.9)/(4000.0-740.0)*(Gr.z_c[k] - 740.0) #Set qt profile - if Gr.z[k] <= 740.0: - GMV.QT.values[k] = (16.0 + (13.8 - 16.0)/740.0 * Gr.z[k])/1000.0 - elif Gr.z[k] > 740.0 and Gr.z[k] <= 3260.0: - GMV.QT.values[k] = (13.8 + (2.4 - 13.8)/(3260.0-740.0) * (Gr.z[k] - 740.0))/1000.0 + if Gr.z_c[k] <= 740.0: + GMV.QT.values[k] = (16.0 + (13.8 - 16.0)/740.0 * Gr.z_c[k])/1000.0 + elif Gr.z_c[k] > 740.0 and Gr.z_c[k] <= 3260.0: + GMV.QT.values[k] = (13.8 + (2.4 - 13.8)/(3260.0-740.0) * (Gr.z_c[k] - 740.0))/1000.0 else: - GMV.QT.values[k] = (2.4 + (1.8-2.4)/(4000.0-3260.0)*(Gr.z[k] - 3260.0))/1000.0 + GMV.QT.values[k] = (2.4 + (1.8-2.4)/(4000.0-3260.0)*(Gr.z_c[k] - 3260.0))/1000.0 if GMV.H.name == 'thetal': for k in xrange(Gr.gw,Gr.nzg-Gr.gw): GMV.H.values[k] = thetal[k] - GMV.T.values[k] = thetal[k] * exner_c(Ref.p0[k]) + GMV.T.values[k] = thetal[k] * exner_c(Ref.p0_c[k]) GMV.THL.values[k] = thetal[k] elif GMV.H.name == 's': for k in xrange(Gr.gw,Gr.nzg-Gr.gw): - GMV.T.values[k] = thetal[k] * exner_c(Ref.p0[k]) - GMV.H.values[k] = t_to_entropy_c(Ref.p0[k],GMV.T.values[k], + GMV.T.values[k] = thetal[k] * exner_c(Ref.p0_c[k]) + GMV.H.values[k] = t_to_entropy_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], ql, qi) - GMV.THL.values[k] = thetali_c(Ref.p0[k],GMV.T.values[k], + GMV.THL.values[k] = thetali_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], ql, qi, latent_heat(GMV.T.values[k])) GMV.U.set_bcs(Gr) @@ -477,7 +477,7 @@ cdef class Rico(CasesBase): self.Sur.ch = 0.001094 self.Sur.cq = 0.001133 # Adjust for non-IC grid spacing - grid_adjust = (np.log(20.0/self.Sur.zrough)/np.log(Gr.z[Gr.gw]/self.Sur.zrough))**2 + grid_adjust = (np.log(20.0/self.Sur.zrough)/np.log(Gr.z_c[Gr.gw]/self.Sur.zrough))**2 self.Sur.cm = self.Sur.cm * grid_adjust self.Sur.ch = self.Sur.ch * grid_adjust self.Sur.cq = self.Sur.cq * grid_adjust @@ -491,20 +491,20 @@ cdef class Rico(CasesBase): self.Fo.initialize(GMV) for k in xrange(Gr.nzg): # Geostrophic velocity profiles - self.Fo.ug[k] = -9.9 + 2.0e-3 * Gr.z[k] + self.Fo.ug[k] = -9.9 + 2.0e-3 * Gr.z_c[k] self.Fo.vg[k] = -3.8 # Set large-scale cooling - self.Fo.dTdt[k] = (-2.5/(3600.0 * 24.0)) * exner_c(Ref.p0[k]) + self.Fo.dTdt[k] = (-2.5/(3600.0 * 24.0)) * exner_c(Ref.p0_c[k]) # Set large-scale moistening - if Gr.z[k] <= 2980.0: - self.Fo.dqtdt[k] = (-1.0 + 1.3456/2980.0 * Gr.z[k])/86400.0/1000.0 #kg/(kg * s) + if Gr.z_c[k] <= 2980.0: + self.Fo.dqtdt[k] = (-1.0 + 1.3456/2980.0 * Gr.z_c[k])/86400.0/1000.0 #kg/(kg * s) else: self.Fo.dqtdt[k] = 0.3456/86400.0/1000.0 #Set large scale subsidence - if Gr.z[k] <= 2260.0: - self.Fo.subsidence[k] = -(0.005/2260.0) * Gr.z[k] + if Gr.z_c[k] <= 2260.0: + self.Fo.subsidence[k] = -(0.005/2260.0) * Gr.z_c[k] else: self.Fo.subsidence[k] = -0.005 return @@ -597,19 +597,19 @@ cdef class TRMM_LBA(CasesBase): 5.32, 1.14, -0.65, 5.27, 5.27]) # interpolate to the model grid-points - p1 = np.interp(Gr.z,z_in,p_in) - GMV.U.values = np.interp(Gr.z,z_in,u_in) - GMV.V.values = np.interp(Gr.z,z_in,v_in) + p1 = np.interp(Gr.z_c,z_in,p_in) + GMV.U.values = np.interp(Gr.z_c,z_in,u_in) + GMV.V.values = np.interp(Gr.z_c,z_in,v_in) # get the entropy from RH, p, T RH = np.zeros(Gr.nzg) - RH[Gr.gw:Gr.nzg-Gr.gw] = np.interp(Gr.z[Gr.gw:Gr.nzg-Gr.gw],z_in,RH_in) + RH[Gr.gw:Gr.nzg-Gr.gw] = np.interp(Gr.z_c[Gr.gw:Gr.nzg-Gr.gw],z_in,RH_in) RH[0] = RH[3] RH[1] = RH[2] RH[Gr.nzg-Gr.gw+1] = RH[Gr.nzg-Gr.gw-1] T = np.zeros(Gr.nzg) - T[Gr.gw:Gr.nzg-Gr.gw] = np.interp(Gr.z[Gr.gw:Gr.nzg-Gr.gw],z_in,T_in) + T[Gr.gw:Gr.nzg-Gr.gw] = np.interp(Gr.z_c[Gr.gw:Gr.nzg-Gr.gw],z_in,T_in) GMV.T.values = T theta_rho = RH*0.0 epsi = 287.1/461.5 @@ -626,15 +626,15 @@ cdef class TRMM_LBA(CasesBase): qv = GMV.QT.values[k] - GMV.QL.values[k] GMV.QT.values[k] = qv_star*RH[k]/100.0 if GMV.H.name == 's': - GMV.H.values[k] = t_to_entropy_c(Ref.p0[k],GMV.T.values[k], + GMV.H.values[k] = t_to_entropy_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], 0.0, 0.0) elif GMV.H.name == 'thetal': - GMV.H.values[k] = thetali_c(Ref.p0[k],GMV.T.values[k], + GMV.H.values[k] = thetali_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], 0.0, 0.0, latent_heat(GMV.T.values[k])) - GMV.THL.values[k] = thetali_c(Ref.p0[k],GMV.T.values[k], + GMV.THL.values[k] = thetali_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], 0.0, 0.0, latent_heat(GMV.T.values[k])) - theta_rho[k] = theta_rho_c(Ref.p0[k], GMV.T.values[k], GMV.QT.values[k], qv) + theta_rho[k] = theta_rho_c(Ref.p0_c[k], GMV.T.values[k], GMV.QT.values[k], qv) GMV.QT.set_bcs(Gr) GMV.H.set_bcs(Gr) @@ -645,8 +645,8 @@ cdef class TRMM_LBA(CasesBase): #self.Sur.zrough = 1.0e-4 # not actually used, but initialized to reasonable value self.Sur.Tsurface = (273.15+23) * exner_c(Ref.Pg) self.Sur.qsurface = 22.45e-3 # kg/kg - self.Sur.lhf = 5.2e-5 * Ref.rho0[Gr.gw -1] * latent_heat(self.Sur.Tsurface) - self.Sur.shf = 8.0e-3 * cpm_c(self.Sur.qsurface) * Ref.rho0[Gr.gw-1] + self.Sur.lhf = 5.2e-5 * Ref.rho0_f[Gr.gw -1] * latent_heat(self.Sur.Tsurface) + self.Sur.shf = 8.0e-3 * cpm_c(self.Sur.qsurface) * Ref.rho0_f[Gr.gw-1] self.Sur.ustar_fixed = True self.Sur.ustar = 0.28 # this is taken from Bomex -- better option is to approximate from LES tke above the surface self.Sur.Gr = Gr @@ -775,9 +775,9 @@ cdef class TRMM_LBA(CasesBase): cdef: Py_ssize_t tt, k, ind1, ind2 - A = np.interp(Gr.z,z_in,rad_in[0,:]) + A = np.interp(Gr.z_c,z_in,rad_in[0,:]) for tt in xrange(1,36): - A = np.vstack((A, np.interp(Gr.z,z_in,rad_in[tt,:]))) + A = np.vstack((A, np.interp(Gr.z_c,z_in,rad_in[tt,:]))) self.rad = np.multiply(A,1.0) # store matrix in self ind1 = int(mt.trunc(10.0/600.0)) @@ -828,7 +828,7 @@ cdef class TRMM_LBA(CasesBase): self.Fo.dTdt[k] = self.rad[ind1,k] else: # in all other cases - interpolate for k in xrange(self.Fo.Gr.nzg): - if self.Fo.Gr.z[k] < 22699.48: + if self.Fo.Gr.z_c[k] < 22699.48: self.Fo.dTdt[k] = (self.rad[ind2,k]-self.rad[ind1,k])\ /(self.rad_time[ind2]-self.rad_time[ind1])\ *(TS.t/60.0-self.rad_time[ind1])+self.rad[ind1,k] @@ -869,22 +869,22 @@ cdef class ARM_SGP(CasesBase): qt_in = np.divide(r_in,(1+r_in)) # interpolate to the model grid-points - Theta = np.interp(Gr.z,z_in,Theta_in) - qt = np.interp(Gr.z,z_in,qt_in) + Theta = np.interp(Gr.z_c,z_in,Theta_in) + qt = np.interp(Gr.z_c,z_in,qt_in) for k in xrange(Gr.gw,Gr.nzg-Gr.gw): GMV.U.values[k] = 10.0 GMV.QT.values[k] = qt[k] - GMV.T.values[k] = Theta[k]*exner_c(Ref.p0[k]) + GMV.T.values[k] = Theta[k]*exner_c(Ref.p0_c[k]) if GMV.H.name == 's': - GMV.H.values[k] = t_to_entropy_c(Ref.p0[k],GMV.T.values[k], + GMV.H.values[k] = t_to_entropy_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], 0.0, 0.0) elif GMV.H.name == 'thetal': - GMV.H.values[k] = thetali_c(Ref.p0[k],GMV.T.values[k], + GMV.H.values[k] = thetali_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], 0.0, 0.0, latent_heat(GMV.T.values[k])) - GMV.THL.values[k] = thetali_c(Ref.p0[k],GMV.T.values[k], + GMV.THL.values[k] = thetali_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], 0.0, 0.0, latent_heat(GMV.T.values[k])) @@ -957,13 +957,13 @@ cdef class ARM_SGP(CasesBase): double dTdt = np.interp(TS.t,t_in,AT_in) + np.interp(TS.t,t_in,RT_in) double dqtdt = np.interp(TS.t,t_in,Rqt_in) for k in xrange(self.Fo.Gr.nzg): # correct dims - if self.Fo.Gr.z[k] <=1000.0: + if self.Fo.Gr.z_c[k] <=1000.0: self.Fo.dTdt[k] = dTdt - self.Fo.dqtdt[k] = dqtdt * exner_c(self.Fo.Ref.p0[k]) - elif self.Fo.Gr.z[k] > 1000.0 and self.Fo.Gr.z[k] <= 2000.0: - self.Fo.dTdt[k] = dTdt*(1-(self.Fo.Gr.z[k]-1000.0)/1000.0) - self.Fo.dqtdt[k] = dqtdt * exner_c(self.Fo.Ref.p0[k])\ - *(1-(self.Fo.Gr.z[k]-1000.0)/1000.0) + self.Fo.dqtdt[k] = dqtdt * exner_c(self.Fo.Ref.p0_c[k]) + elif self.Fo.Gr.z_c[k] > 1000.0 and self.Fo.Gr.z_c[k] <= 2000.0: + self.Fo.dTdt[k] = dTdt*(1-(self.Fo.Gr.z_c[k]-1000.0)/1000.0) + self.Fo.dqtdt[k] = dqtdt * exner_c(self.Fo.Ref.p0_c[k])\ + *(1-(self.Fo.Gr.z_c[k]-1000.0)/1000.0) self.Fo.update(GMV) return @@ -1012,9 +1012,9 @@ cdef class GATE_III(CasesBase): z_T_in = np.array([0.0, 0.492, 0.700, 1.698, 3.928, 6.039, 7.795, 9.137, 11.055, 12.645, 13.521, 14.486, 15.448, 16.436, 17.293, 22.0])*1000.0 # for km # interpolate to the model grid-points - T = np.interp(Gr.z,z_T_in,T_in) # interpolate to ref pressure level - qt = np.interp(Gr.z,z_in,qt_in) - U = np.interp(Gr.z,z_in,U_in) + T = np.interp(Gr.z_c,z_T_in,T_in) # interpolate to ref pressure level + qt = np.interp(Gr.z_c,z_in,qt_in) + U = np.interp(Gr.z_c,z_in,U_in) for k in xrange(Gr.gw,Gr.nzg-Gr.gw): @@ -1023,13 +1023,13 @@ cdef class GATE_III(CasesBase): GMV.U.values[k] = U[k] if GMV.H.name == 's': - GMV.H.values[k] = t_to_entropy_c(Ref.p0[k],GMV.T.values[k], + GMV.H.values[k] = t_to_entropy_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], 0.0, 0.0) elif GMV.H.name == 'thetal': - GMV.H.values[k] = thetali_c(Ref.p0[k],GMV.T.values[k], + GMV.H.values[k] = thetali_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], 0.0, 0.0, latent_heat(GMV.T.values[k])) - GMV.THL.values[k] = thetali_c(Ref.p0[k],GMV.T.values[k], + GMV.THL.values[k] = thetali_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], 0.0, 0.0, latent_heat(GMV.T.values[k])) GMV.U.set_bcs(Gr) GMV.QT.set_bcs(Gr) @@ -1077,8 +1077,8 @@ cdef class GATE_III(CasesBase): Qtend_in = np.divide(r_tend_in,(1+r_tend_in)) # convert mixing ratio to specific humidity - self.Fo.dqtdt = np.interp(Gr.z,z_in,Qtend_in) - self.Fo.dTdt = np.interp(Gr.z,z_in,Ttend_in) + np.interp(Gr.z,z_in,RAD_in) + self.Fo.dqtdt = np.interp(Gr.z_c,z_in,Qtend_in) + self.Fo.dTdt = np.interp(Gr.z_c,z_in,Ttend_in) + np.interp(Gr.z_c,z_in,RAD_in) return @@ -1179,35 +1179,35 @@ cdef class DYCOMS_RF01(CasesBase): for k in xrange(Gr.gw, Gr.nzg-Gr.gw): # thetal profile as defined in DYCOMS - if Gr.z[k] <= 840.0: + if Gr.z_c[k] <= 840.0: thetal[k] = 289.0 - if Gr.z[k] > 840.0: - thetal[k] = (297.5 + (Gr.z[k] - 840.0)**(1.0/3.0)) + if Gr.z_c[k] > 840.0: + thetal[k] = (297.5 + (Gr.z_c[k] - 840.0)**(1.0/3.0)) # qt profile as defined in DYCOMS - if Gr.z[k] <= 840.0: + if Gr.z_c[k] <= 840.0: GMV.QT.values[k] = 9. / 1000.0 - if Gr.z[k] > 840.0: + if Gr.z_c[k] > 840.0: GMV.QT.values[k] = 1.5 / 1000.0 # ql and T profile # (calculated by saturation adjustment using thetal and qt values provided in DYCOMS # and using Rd, cp and L constants as defined in DYCOMS) - GMV.T.values[k], GMV.QL.values[k] = self.dycoms_sat_adjst(Ref.p0[k], thetal[k], GMV.QT.values[k]) + GMV.T.values[k], GMV.QL.values[k] = self.dycoms_sat_adjst(Ref.p0_c[k], thetal[k], GMV.QT.values[k]) # thermodynamic variable profile (either entropy or thetal) # (calculated based on T and ql profiles. # Here we use Rd, cp and L constants as defined in scampy) - GMV.THL.values[k] = t_to_thetali_c(Ref.p0[k], GMV.T.values[k], GMV.QT.values[k], GMV.QL.values[k], qi) + GMV.THL.values[k] = t_to_thetali_c(Ref.p0_c[k], GMV.T.values[k], GMV.QT.values[k], GMV.QL.values[k], qi) if GMV.H.name == 'thetal': - GMV.H.values[k] = t_to_thetali_c(Ref.p0[k], GMV.T.values[k], GMV.QT.values[k], GMV.QL.values[k], qi) + GMV.H.values[k] = t_to_thetali_c(Ref.p0_c[k], GMV.T.values[k], GMV.QT.values[k], GMV.QL.values[k], qi) elif GMV.H.name == 's': - GMV.H.values[k] = t_to_entropy_c(Ref.p0[k], GMV.T.values[k], GMV.QT.values[k], GMV.QL.values[k], qi) + GMV.H.values[k] = t_to_entropy_c(Ref.p0_c[k], GMV.T.values[k], GMV.QT.values[k], GMV.QL.values[k], qi) # buoyancy profile qv = GMV.QT.values[k] - qi - GMV.QL.values[k] - alpha = alpha_c(Ref.p0[k], GMV.T.values[k], GMV.QT.values[k], qv) - GMV.B.values[k] = buoyancy_c(Ref.alpha0[k], alpha) + alpha = alpha_c(Ref.p0_c[k], GMV.T.values[k], GMV.QT.values[k], qv) + GMV.B.values[k] = buoyancy_c(Ref.alpha0_c[k], alpha) # velocity profile (geostrophic) GMV.U.values[k] = 7.0 @@ -1240,8 +1240,8 @@ cdef class DYCOMS_RF01(CasesBase): #density_surface = 1.22 # kg/m^3 # buoyancy flux - theta_flux = self.Sur.shf / cpm_c(self.Sur.qsurface) / Ref.rho0[Gr.gw-1] - qt_flux = self.Sur.lhf / latent_heat(self.Sur.Tsurface) / Ref.rho0[Gr.gw-1] + theta_flux = self.Sur.shf / cpm_c(self.Sur.qsurface) / Ref.rho0_f[Gr.gw-1] + qt_flux = self.Sur.lhf / latent_heat(self.Sur.Tsurface) / Ref.rho0_f[Gr.gw-1] theta_surface = self.Sur.Tsurface / exner_c(Ref.Pg) self.Sur.bflux = g * ((theta_flux + (eps_vi - 1.0) * (theta_surface * qt_flux + self.Sur.qsurface * theta_flux)) / (theta_surface * (1.0 + (eps_vi-1) * self.Sur.qsurface))) @@ -1265,7 +1265,7 @@ cdef class DYCOMS_RF01(CasesBase): # To be able to have self.Fo.divergence available here, # we would have to change the signature of ForcingBase class for k in xrange(Gr.gw, Gr.nzg-Gr.gw): - self.Fo.subsidence[k] = - Gr.z[k] * divergence + self.Fo.subsidence[k] = - Gr.z_c[k] * divergence # no large-scale drying self.Fo.dqtdt[:] = 0. #kg/(kg * s) diff --git a/EDMF_Environment.pxd b/EDMF_Environment.pxd index 97e7a2ed..fa5b4e5a 100644 --- a/EDMF_Environment.pxd +++ b/EDMF_Environment.pxd @@ -23,6 +23,7 @@ cdef class EnvironmentVariable_2m: double [:] detr_loss double [:] press double [:] buoy + double [:] massflux double [:] rain_src str loc str kind diff --git a/EDMF_Environment.pyx b/EDMF_Environment.pyx index 229b3513..4a3a7102 100644 --- a/EDMF_Environment.pyx +++ b/EDMF_Environment.pyx @@ -39,6 +39,7 @@ cdef class EnvironmentVariable_2m: self.buoy = np.zeros((nz,),dtype=np.double, order='c') self.press = np.zeros((nz,),dtype=np.double, order='c') self.shear = np.zeros((nz,),dtype=np.double, order='c') + self.massflux = np.zeros((nz,),dtype=np.double, order='c') self.rain_src = np.zeros((nz,),dtype=np.double, order='c') if loc != 'half': print('Invalid location setting for variable! Must be half') @@ -203,7 +204,7 @@ cdef class EnvironmentThermodynamics: EnvVar.QT.values[k] = qt EnvVar.QL.values[k] = ql EnvVar.QR.values[k] += qr - EnvVar.B.values[k] = buoyancy_c(self.Ref.alpha0[k], alpha) + EnvVar.B.values[k] = buoyancy_c(self.Ref.alpha0_c[k], alpha) return cdef void update_cloud_dry(self, long k, EnvironmentVariables EnvVar, double T, double th, double qt, double ql, double qv) nogil : @@ -235,8 +236,8 @@ cdef class EnvironmentThermodynamics: with nogil: for k in xrange(gw,self.Gr.nzg-gw): # condensation + autoconversion - sa = eos(self.t_to_prog_fp, self.prog_to_t_fp, self.Ref.p0[k], EnvVar.QT.values[k], EnvVar.H.values[k]) - mph = microphysics(sa.T, sa.ql, self.Ref.p0[k], EnvVar.QT.values[k], self.max_supersaturation, in_Env) + sa = eos(self.t_to_prog_fp, self.prog_to_t_fp, self.Ref.p0_c[k], EnvVar.QT.values[k], EnvVar.H.values[k]) + mph = microphysics(sa.T, sa.ql, self.Ref.p0_c[k], EnvVar.QT.values[k], self.max_supersaturation, in_Env) self.update_EnvVar( k, EnvVar, mph.T, mph.thl, mph.qt, mph.ql, mph.qr, mph.alpha) self.update_cloud_dry(k, EnvVar, mph.T, mph.th, mph.qt, mph.ql, mph.qv) return @@ -330,8 +331,8 @@ cdef class EnvironmentThermodynamics: h_hat = sqrt2 * sigma_h_star * abscissas[m_h] + mu_h_star # condensation + autoconversion - sa = eos(self.t_to_prog_fp, self.prog_to_t_fp, self.Ref.p0[k], qt_hat, h_hat) - mph = microphysics(sa.T, sa.ql, self.Ref.p0[k], qt_hat, self.max_supersaturation, in_Env) + sa = eos(self.t_to_prog_fp, self.prog_to_t_fp, self.Ref.p0_c[k], qt_hat, h_hat) + mph = microphysics(sa.T, sa.ql, self.Ref.p0_c[k], qt_hat, self.max_supersaturation, in_Env) # environmental variables inner_env[i_ql] += mph.ql * weights[m_h] * sqpi_inv @@ -369,11 +370,11 @@ cdef class EnvironmentThermodynamics: # update cloudy/dry variables for buoyancy in TKE EnvVar.CF.values[k] = outer_env[i_cf] self.qt_dry[k] = outer_env[i_qt_dry] - self.th_dry[k] = theta_c(self.Ref.p0[k], outer_env[i_T_dry]) + self.th_dry[k] = theta_c(self.Ref.p0_c[k], outer_env[i_T_dry]) self.t_cloudy[k] = outer_env[i_T_cld] self.qv_cloudy[k] = outer_env[i_qt_cld] - outer_env[i_ql] self.qt_cloudy[k] = outer_env[i_qt_cld] - self.th_cloudy[k] = theta_c(self.Ref.p0[k], outer_env[i_T_cld]) + self.th_cloudy[k] = theta_c(self.Ref.p0_c[k], outer_env[i_T_cld]) # update var/covar rain sources if in_Env: self.Hvar_rain_dt[k] = outer_src[i_SH_H] - outer_src[i_SH] * EnvVar.H.values[k] @@ -383,8 +384,8 @@ cdef class EnvironmentThermodynamics: else: # the same as in SA_mean - sa = eos(self.t_to_prog_fp, self.prog_to_t_fp, self.Ref.p0[k], EnvVar.QT.values[k], EnvVar.H.values[k]) - mph = microphysics(sa.T, sa.ql, self.Ref.p0[k], EnvVar.QT.values[k], self.max_supersaturation, in_Env) + sa = eos(self.t_to_prog_fp, self.prog_to_t_fp, self.Ref.p0_c[k], EnvVar.QT.values[k], EnvVar.H.values[k]) + mph = microphysics(sa.T, sa.ql, self.Ref.p0_c[k], EnvVar.QT.values[k], self.max_supersaturation, in_Env) self.update_EnvVar( k, EnvVar, mph.T, mph.thl, mph.qt, mph.ql, mph.qr, mph.alpha) self.update_cloud_dry(k, EnvVar, mph.T, mph.th, mph.qt, mph.ql, mph.qv) @@ -410,13 +411,13 @@ cdef class EnvironmentThermodynamics: Lv = latent_heat(EnvVar.T.values[k]) cp = cpd # paper notation used below - Tl = EnvVar.H.values[k]*exner_c(self.Ref.p0[k]) - q_sl = qv_star_t(self.Ref.p0[k], Tl) # using the qv_star_c function instead of the approximation in eq. (4) in SD + Tl = EnvVar.H.values[k]*exner_c(self.Ref.p0_c[k]) + q_sl = qv_star_t(self.Ref.p0_c[k], Tl) # using the qv_star_c function instead of the approximation in eq. (4) in SD beta1 = 0.622*Lv**2/(Rd*cp*Tl**2) # eq. (8) in SD #q_s = q_sl*(1+beta1*EnvVar.QT.values[k])/(1+beta1*q_sl) # eq. (7) in SD lambda1 = 1/(1+beta1*q_sl) # text under eq. (20) in SD # check the pressure units - mb vs pa - alpha1 = (self.Ref.p0[k]/100000.0)**0.286*0.622*Lv*q_sl/Rd/Tl**2 # eq. (14) and eq. (6) in SD + alpha1 = (self.Ref.p0_c[k]/100000.0)**0.286*0.622*Lv*q_sl/Rd/Tl**2 # eq. (14) and eq. (6) in SD # see if there is another way to calculate dq/dT from scmapy sigma1 = EnvVar.QTvar.values[k]-2*alpha1*EnvVar.HQTcov.values[k]+alpha1**2*EnvVar.Hvar.values[k] # eq. (18) in SD , with r from (11) Q1 = (EnvVar.QT.values[k]-q_sl)/sigma1 # eq. (17) in SD @@ -435,17 +436,17 @@ cdef class EnvironmentThermodynamics: EnvVar.T.values[k] = Tl + Lv/cp*EnvVar.QL.values[k] # should this be the differnece in ql - would it work for evaporation as well ? EnvVar.CF.values[k] = R qv = EnvVar.QT.values[k] - EnvVar.QL.values[k] - alpha = alpha_c(self.Ref.p0[k], EnvVar.T.values[k], EnvVar.QT.values[k], qv) - EnvVar.B.values[k] = buoyancy_c(self.Ref.alpha0[k], alpha) - EnvVar.THL.values[k] = t_to_thetali_c(self.Ref.p0[k], EnvVar.T.values[k], EnvVar.QT.values[k], + alpha = alpha_c(self.Ref.p0_c[k], EnvVar.T.values[k], EnvVar.QT.values[k], qv) + EnvVar.B.values[k] = buoyancy_c(self.Ref.alpha0_c[k], alpha) + EnvVar.THL.values[k] = t_to_thetali_c(self.Ref.p0_c[k], EnvVar.T.values[k], EnvVar.QT.values[k], EnvVar.QL.values[k], 0.0) self.qt_dry[k] = EnvVar.QT.values[k] - self.th_dry[k] = EnvVar.T.values[k]/exner_c(self.Ref.p0[k]) + self.th_dry[k] = EnvVar.T.values[k]/exner_c(self.Ref.p0_c[k]) self.t_cloudy[k] = EnvVar.T.values[k] self.qv_cloudy[k] = EnvVar.QT.values[k] - EnvVar.QL.values[k] self.qt_cloudy[k] = EnvVar.QT.values[k] - self.th_cloudy[k] = EnvVar.T.values[k]/exner_c(self.Ref.p0[k]) + self.th_cloudy[k] = EnvVar.T.values[k]/exner_c(self.Ref.p0_c[k]) #using the approximation in eq. (25) in SD, noting that in the paper there is a typo in the first # condition and 1.6 there should be -1.6 diff --git a/EDMF_Updrafts.pyx b/EDMF_Updrafts.pyx index 0798513c..87ad74bc 100644 --- a/EDMF_Updrafts.pyx +++ b/EDMF_Updrafts.pyx @@ -268,13 +268,13 @@ cdef class UpdraftVariables: for i in xrange(self.n_updrafts): # Todo check the setting of ghost point z_half - self.cloud_base[i] = self.Gr.z[self.Gr.nzg-self.Gr.gw-1] + self.cloud_base[i] = self.Gr.z_c[self.Gr.nzg-self.Gr.gw-1] self.cloud_top[i] = 0.0 self.cloud_cover[i] = 0.0 for k in xrange(self.Gr.gw,self.Gr.nzg-self.Gr.gw): if self.QL.values[i,k] > 1e-8 and self.Area.values[i,k] > 1e-3: - self.cloud_base[i] = fmin(self.cloud_base[i], self.Gr.z[k]) - self.cloud_top[i] = fmax(self.cloud_top[i], self.Gr.z[k]) + self.cloud_base[i] = fmin(self.cloud_base[i], self.Gr.z_c[k]) + self.cloud_top[i] = fmax(self.cloud_top[i], self.Gr.z_c[k]) self.cloud_cover[i] = fmax(self.cloud_cover[i], self.Area.values[i,k]) @@ -303,7 +303,7 @@ cdef class UpdraftThermodynamics: with nogil: for i in xrange(self.n_updraft): for k in xrange(self.Gr.nzg): - sa = eos(self.t_to_prog_fp,self.prog_to_t_fp, self.Ref.p0[k], + sa = eos(self.t_to_prog_fp,self.prog_to_t_fp, self.Ref.p0_c[k], UpdVar.QT.values[i,k], UpdVar.H.values[i,k]) UpdVar.QL.values[i,k] = sa.ql UpdVar.T.values[i,k] = sa.T @@ -323,8 +323,8 @@ cdef class UpdraftThermodynamics: for i in xrange(self.n_updraft): for k in xrange(self.Gr.nzg): qv = UpdVar.QT.values[i,k] - UpdVar.QL.values[i,k] - alpha = alpha_c(self.Ref.p0[k], UpdVar.T.values[i,k], UpdVar.QT.values[i,k], qv) - UpdVar.B.values[i,k] = buoyancy_c(self.Ref.alpha0[k], alpha) #- GMV.B.values[k] + alpha = alpha_c(self.Ref.p0_c[k], UpdVar.T.values[i,k], UpdVar.QT.values[i,k], qv) + UpdVar.B.values[i,k] = buoyancy_c(self.Ref.alpha0_c[k], alpha) #- GMV.B.values[k] else: with nogil: @@ -335,18 +335,18 @@ cdef class UpdraftThermodynamics: qv = UpdVar.QT.values[i,k] - UpdVar.QL.values[i,k] h = UpdVar.H.values[i,k] t = UpdVar.T.values[i,k] - alpha = alpha_c(self.Ref.p0[k], t, qt, qv) - UpdVar.B.values[i,k] = buoyancy_c(self.Ref.alpha0[k], alpha) + alpha = alpha_c(self.Ref.p0_c[k], t, qt, qv) + UpdVar.B.values[i,k] = buoyancy_c(self.Ref.alpha0_c[k], alpha) else: - sa = eos(self.t_to_prog_fp, self.prog_to_t_fp, self.Ref.p0[k], + sa = eos(self.t_to_prog_fp, self.prog_to_t_fp, self.Ref.p0_c[k], qt, h) qt -= sa.ql qv = qt t = sa.T - alpha = alpha_c(self.Ref.p0[k], t, qt, qv) - UpdVar.B.values[i,k] = buoyancy_c(self.Ref.alpha0[k], alpha) + alpha = alpha_c(self.Ref.p0_c[k], t, qt, qv) + UpdVar.B.values[i,k] = buoyancy_c(self.Ref.alpha0_c[k], alpha) with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): @@ -385,9 +385,9 @@ cdef class UpdraftMicrophysics: for i in xrange(self.n_updraft): for k in xrange(self.Gr.nzg): tmp_qr = acnv_instant(UpdVar.QL.values[i,k], UpdVar.QT.values[i,k], self.max_supersaturation,\ - UpdVar.T.values[i,k], self.Ref.p0[k]) + UpdVar.T.values[i,k], self.Ref.p0_c[k]) self.prec_source_qt[i,k] = -tmp_qr - self.prec_source_h[i,k] = rain_source_to_thetal(self.Ref.p0[k], UpdVar.T.values[i,k],\ + self.prec_source_h[i,k] = rain_source_to_thetal(self.Ref.p0_c[k], UpdVar.T.values[i,k],\ UpdVar.QT.values[i,k], UpdVar.QL.values[i,k], 0.0, tmp_qr) #TODO assumes no ice self.prec_source_h_tot = np.sum(np.multiply(self.prec_source_h, UpdVar.Area.values), axis=0) diff --git a/Forcing.pyx b/Forcing.pyx index 434cd409..727bfd41 100644 --- a/Forcing.pyx +++ b/Forcing.pyx @@ -75,7 +75,7 @@ cdef class ForcingStandard(ForcingBase): for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): # Apply large-scale horizontal advection tendencies qv = GMV.QT.values[k] - GMV.QL.values[k] - GMV.H.tendencies[k] += self.convert_forcing_prog_fp(self.Ref.p0[k],GMV.QT.values[k], + GMV.H.tendencies[k] += self.convert_forcing_prog_fp(self.Ref.p0_c[k],GMV.QT.values[k], qv, GMV.T.values[k], self.dqtdt[k], self.dTdt[k]) GMV.QT.tendencies[k] += self.dqtdt[k] if self.apply_subsidence: @@ -109,7 +109,7 @@ cdef class ForcingStandard(ForcingBase): # for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): # # Apply large-scale horizontal advection tendencies # qv = GMV.QT.values[k] - GMV.QL.values[k] -# GMV.H.tendencies[k] += self.convert_forcing_prog_fp(self.Ref.p0[k],GMV.QT.values[k], qv, +# GMV.H.tendencies[k] += self.convert_forcing_prog_fp(self.Ref.p0_c[k],GMV.QT.values[k], qv, # GMV.T.values[k], self.dqtdt[k], self.dTdt[k]) # GMV.QT.tendencies[k] += self.dqtdt[k] # @@ -160,21 +160,21 @@ cdef class ForcingDYCOMS_RF01(ForcingBase): idx_zi = k # will be used at cell edges zi = self.Gr.z[idx_zi] - rhoi = self.Ref.rho0[idx_zi] + rhoi = self.Ref.rho0_c[idx_zi] break # cloud-top cooling q_0 = 0.0 self.f_rad[self.Gr.nzg] = self.F0 * np.exp(-q_0) for k in xrange(self.Gr.nzg - 1, -1, -1): - q_0 += self.kappa * self.Ref.rho0[k] * GMV.QL.values[k] * self.Gr.dz + q_0 += self.kappa * self.Ref.rho0_c[k] * GMV.QL.values[k] * self.Gr.dz self.f_rad[k] = self.F0 * np.exp(-q_0) # cloud-base warming q_1 = 0.0 self.f_rad[0] += self.F1 * np.exp(-q_1) for k in xrange(1, self.Gr.nzg + 1): - q_1 += self.kappa * self.Ref.rho0[k - 1] * GMV.QL.values[k - 1] * self.Gr.dz + q_1 += self.kappa * self.Ref.rho0_c[k - 1] * GMV.QL.values[k - 1] * self.Gr.dz self.f_rad[k] += self.F1 * np.exp(-q_1) # cooling in free troposphere @@ -187,7 +187,7 @@ cdef class ForcingDYCOMS_RF01(ForcingBase): self.f_rad[self.Gr.nzg] += rhoi * dycoms_cp * self.divergence * self.alpha_z * (np.power(cbrt_z, 4) / 4.0 + zi * cbrt_z) for k in xrange(self.Gr.gw, self.Gr.nzg - self.Gr.gw): - self.dTdt[k] = - (self.f_rad[k + 1] - self.f_rad[k]) / self.Gr.dz / self.Ref.rho0[k] / dycoms_cp + self.dTdt[k] = - (self.f_rad[k + 1] - self.f_rad[k]) / self.Gr.dz / self.Ref.rho0_c[k] / dycoms_cp return @@ -205,7 +205,7 @@ cdef class ForcingDYCOMS_RF01(ForcingBase): for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): # Apply large-scale horizontal advection tendencies qv = GMV.QT.values[k] - GMV.QL.values[k] - GMV.H.tendencies[k] += self.convert_forcing_prog_fp(self.Ref.p0[k],GMV.QT.values[k], qv, GMV.T.values[k], self.dqtdt[k], self.dTdt[k]) + GMV.H.tendencies[k] += self.convert_forcing_prog_fp(self.Ref.p0_c[k],GMV.QT.values[k], qv, GMV.T.values[k], self.dqtdt[k], self.dTdt[k]) GMV.QT.tendencies[k] += self.dqtdt[k] # Apply large-scale subsidence tendencies GMV.H.tendencies[k] -= (GMV.H.values[k+1]-GMV.H.values[k]) * self.Gr.dzi * self.subsidence[k] diff --git a/Grid.pxd b/Grid.pxd index a9cf0ad4..a442b807 100644 --- a/Grid.pxd +++ b/Grid.pxd @@ -12,4 +12,5 @@ cdef class Grid: Py_ssize_t gw Py_ssize_t nz Py_ssize_t nzg - double [:] z + double [:] z_f + double [:] z_c diff --git a/Grid.pyx b/Grid.pyx index 60c2e876..208f78e4 100644 --- a/Grid.pyx +++ b/Grid.pyx @@ -15,7 +15,6 @@ cdef class Grid: ''' def __init__(self,namelist): ''' - :param namelist: Namelist dictionary :param Parallel: ParallelMPI class :return: @@ -33,17 +32,16 @@ cdef class Grid: self.nz = namelist['grid']['nz'] self.nzg = self.nz + 2 * self.gw - self.z = np.empty((self.nz+2*self.gw),dtype=np.double,order='c') - + self.z_f = np.empty((self.nz+2*self.gw),dtype=np.double,order='c') + self.z_c = np.empty((self.nz+2*self.gw),dtype=np.double,order='c') cdef int i, count = 0 for i in xrange(-self.gw,self.nz+self.gw,1): - self.z[count] = (i + 0.5) * self.dz + self.z_f[count] = (i + 1) * self.dz + self.z_c[count] = (i+0.5)*self.dz count += 1 return - - diff --git a/NetCDFIO.pyx b/NetCDFIO.pyx index 1b42445f..34df8740 100644 --- a/NetCDFIO.pyx +++ b/NetCDFIO.pyx @@ -88,16 +88,22 @@ cdef class NetCDFIO_Stats: profile_grp = root_grp.createGroup('profiles') profile_grp.createDimension('z', self.Gr.nz) profile_grp.createDimension('t', None) - z = profile_grp.createVariable('z', 'f8', ('z')) - z[:] = np.array(self.Gr.z[kmin:kmax]) + z_f = profile_grp.createVariable('z', 'f8', ('z')) + z_f[:] = np.array(self.Gr.z_f[kmin:kmax]) + z_c = profile_grp.createVariable('z_half', 'f8', ('z')) + z_c[:] = np.array(self.Gr.z_c[kmin:kmax]) profile_grp.createVariable('t', 'f8', ('t')) - del z + del z_f + del z_c reference_grp = root_grp.createGroup('reference') reference_grp.createDimension('z', self.Gr.nz) - z = reference_grp.createVariable('z', 'f8', ('z')) - z[:] = np.array(self.Gr.z[kmin:kmax]) - del z + z_f = reference_grp.createVariable('z', 'f8', ('z')) + z_f[:] = np.array(self.Gr.z_f[kmin:kmax]) + z_c = reference_grp.createVariable('z_half', 'f8', ('z')) + z_c[:] = np.array(self.Gr.z_c[kmin:kmax]) + del z_f + del z_c ts_grp = root_grp.createGroup('timeseries') ts_grp.createDimension('t', None) diff --git a/ReferenceState.pxd b/ReferenceState.pxd index f0c2caec..46924061 100644 --- a/ReferenceState.pxd +++ b/ReferenceState.pxd @@ -3,10 +3,12 @@ from NetCDFIO cimport NetCDFIO_Stats cdef class ReferenceState: cdef: - double [:] p0 - double [:] alpha0 - double [:] rho0 - + double [:] p0_f + double [:] alpha0_f + double [:] rho0_f + double [:] p0_c + double [:] alpha0_c + double [:] rho0_c double sg double Tg #Temperature at ground level diff --git a/ReferenceState.pyx b/ReferenceState.pyx index 389113c9..ff84e3d5 100644 --- a/ReferenceState.pyx +++ b/ReferenceState.pyx @@ -19,9 +19,12 @@ include 'parameters.pxi' cdef class ReferenceState: def __init__(self, Grid Gr ): - self.p0 = np.zeros(Gr.nzg, dtype=np.double, order='c') - self.alpha0 = np.zeros(Gr.nzg, dtype=np.double, order='c') - self.rho0 = np.zeros(Gr.nzg, dtype=np.double, order='c') + self.p0_f = np.zeros(Gr.nzg, dtype=np.double, order='c') + self.p0_c = np.zeros(Gr.nzg, dtype=np.double, order='c') + self.alpha0_f = np.zeros(Gr.nzg, dtype=np.double, order='c') + self.alpha0_c = np.zeros(Gr.nzg, dtype=np.double, order='c') + self.rho0_f = np.zeros(Gr.nzg, dtype=np.double, order='c') + self.rho0_c = np.zeros(Gr.nzg, dtype=np.double, order='c') return @@ -56,71 +59,93 @@ cdef class ReferenceState: ##_____________TO COMPILE______________ # Construct arrays for integration points - #z = np.array(Gr.z[Gr.gw-1:-Gr.gw+1]) - z = np.append([0.0], np.array(Gr.z[Gr.gw:-Gr.gw])) - - #z = np.append([0.0], np.array(Gr.z[Gr.gw:-Gr.gw])) + z_f = np.array(Gr.z_f[Gr.gw - 1:-Gr.gw + 1]) + z_c = np.append([0.0], np.array(Gr.z_c[Gr.gw:-Gr.gw])) # We are integrating the log pressure so need to take the log of the # surface pressure p0 = np.log(self.Pg) - p = np.zeros(Gr.nzg, dtype=np.double, order='c') + p_f = np.zeros(Gr.nzg, dtype=np.double, order='c') + p_c = np.zeros(Gr.nzg, dtype=np.double, order='c') + # Perform the integration - p[Gr.gw:-Gr.gw] = odeint(rhs, p0, z, hmax=1.0)[1:, 0] + p_f[Gr.gw - 1:-Gr.gw +1] = odeint(rhs, p0, z_f, hmax=1.0)[:, 0] + p_c[Gr.gw:-Gr.gw] = odeint(rhs, p0, z_c, hmax=1.0)[1:, 0] # Set boundary conditions - p[:Gr.gw] = p[2 * Gr.gw - 1:Gr.gw - 1:-1] - p[-Gr.gw:] = p[-Gr.gw - 1:-2 * Gr.gw - 1:-1] + p_f[:Gr.gw - 1] = p_f[2 * Gr.gw - 2:Gr.gw - 1:-1] + p_f[-Gr.gw + 1:] = p_f[-Gr.gw - 1:-2 * Gr.gw:-1] + + p_c[:Gr.gw] = p_c[2 * Gr.gw - 1:Gr.gw - 1:-1] + p_c[-Gr.gw:] = p_c[-Gr.gw - 1:-2 * Gr.gw - 1:-1] - p = np.exp(p) + p_f = np.exp(p_f) + p_c = np.exp(p_c) - cdef double[:] p_ = p - cdef double[:] temperature = np.zeros(Gr.nzg, dtype=np.double, order='c') - cdef double[:] alpha = np.zeros(Gr.nzg, dtype=np.double, order='c') + cdef double[:] p_f_ = p_f + cdef double[:] p_c_ = p_c + cdef double[:] temperature_f = np.zeros(Gr.nzg, dtype=np.double, order='c') + cdef double[:] temperature_c = np.zeros(Gr.nzg, dtype=np.double, order='c') + cdef double[:] alpha0_f = np.zeros(Gr.nzg, dtype=np.double, order='c') + cdef double[:] alpha0_c = np.zeros(Gr.nzg, dtype=np.double, order='c') - cdef double[:] ql = np.zeros(Gr.nzg, dtype=np.double, order='c') - cdef double[:] qi = np.zeros(Gr.nzg, dtype=np.double, order='c') - cdef double[:] qv = np.zeros(Gr.nzg, dtype=np.double, order='c') + cdef double[:] ql_f = np.zeros(Gr.nzg, dtype=np.double, order='c') + cdef double[:] qi_f = np.zeros(Gr.nzg, dtype=np.double, order='c') + cdef double[:] qv_f = np.zeros(Gr.nzg, dtype=np.double, order='c') + + cdef double[:] ql_c = np.zeros(Gr.nzg, dtype=np.double, order='c') + cdef double[:] qi_c = np.zeros(Gr.nzg, dtype=np.double, order='c') + cdef double[:] qv_c = np.zeros(Gr.nzg, dtype=np.double, order='c') # Compute reference state thermodynamic profiles #_____COMMENTED TO TEST COMPILATION_____________________ for k in xrange(Gr.nzg): - ret = eos(t_to_entropy_c, eos_first_guess_entropy, p_[k], self.qtg, self.sg) - temperature[k] = ret.T - ql[k] = ret.ql - qv[k] = self.qtg - (ql[k] + qi[k]) - alpha[k] = alpha_c(p_[k], temperature[k], self.qtg, qv[k]) - ret = eos(t_to_entropy_c, eos_first_guess_entropy, p_[k], self.qtg, self.sg) - temperature[k] = ret.T - ql[k] = ret.ql - qv[k] = self.qtg - (ql[k] + qi[k]) - alpha[k] = alpha_c(p_[k], temperature[k], self.qtg, qv[k]) + ret = eos(t_to_entropy_c, eos_first_guess_entropy, p_f_[k], self.qtg, self.sg) + temperature_f[k] = ret.T + ql_f[k] = ret.ql + qv_f[k] = self.qtg - (ql_f[k] + qi_f[k]) + alpha0_f[k] = alpha_c(p_f_[k], temperature_f[k], self.qtg, qv_f[k]) + ret = eos(t_to_entropy_c, eos_first_guess_entropy, p_c_[k], self.qtg, self.sg) + temperature_c[k] = ret.T + ql_c[k] = ret.ql + qv_c[k] = self.qtg - (ql_c[k] + qi_c[k]) + alpha0_c[k] = alpha_c(p_c_[k], temperature_c[k], self.qtg, qv_c[k]) + # Now do a sanity check to make sure that the Reference State entropy profile is uniform following # saturation adjustment cdef double s for k in xrange(Gr.nzg): - s = t_to_entropy_c(p[k],temperature[k],self.qtg,ql[k],qi[k]) + s = t_to_entropy_c(p_c[k],temperature_c[k],self.qtg,ql_c[k],qi_c[k]) if np.abs(s - self.sg)/self.sg > 0.01: print('Error in reference profiles entropy not constant !') print('Likely error in saturation adjustment') - self.alpha0 = alpha - self.p0 = p_ - self.rho0 = 1.0 / np.array(self.alpha0) + self.alpha0_c = alpha0_c + self.alpha0_f = alpha0_f + self.p0_f = p_f_ + self.p0_c = p_c_ + self.rho0_c = 1.0 / np.array(self.alpha0_c) + self.rho0_f = 1.0 / np.array(self.alpha0_f) - Stats.add_reference_profile('alpha0') - Stats.write_reference_profile('alpha0', alpha[Gr.gw:-Gr.gw]) + Stats.add_reference_profile('alpha0_f') + Stats.write_reference_profile('alpha0_f', alpha0_f[Gr.gw:-Gr.gw]) + Stats.add_reference_profile('alpha0_c') + Stats.write_reference_profile('alpha0_c', alpha0_c[Gr.gw:-Gr.gw]) - Stats.add_reference_profile('p0') - Stats.write_reference_profile('p0', p_[Gr.gw:-Gr.gw]) + Stats.add_reference_profile('p0_f') + Stats.write_reference_profile('p0_f', p_f[Gr.gw:-Gr.gw]) + Stats.add_reference_profile('p0_c') + Stats.write_reference_profile('p0_c', p_c[Gr.gw:-Gr.gw]) - Stats.add_reference_profile('rho0') - Stats.write_reference_profile('rho0', 1.0 / np.array(alpha[Gr.gw:-Gr.gw])) + Stats.add_reference_profile('rho0_f') + Stats.write_reference_profile('rho0_f', 1.0 / np.array(alpha0_f[Gr.gw:-Gr.gw])) + Stats.add_reference_profile('rho0_c') + Stats.write_reference_profile('rho0_c', 1.0 / np.array(alpha0_c[Gr.gw:-Gr.gw])) # Stats.add_reference_profile('temperature0', Gr, Pa) # Stats.add_reference_profile('ql0', Gr, Pa) diff --git a/Surface.pyx b/Surface.pyx index df9c905d..fe7b593c 100644 --- a/Surface.pyx +++ b/Surface.pyx @@ -35,8 +35,8 @@ cdef class SurfaceBase: with nogil: for k in xrange(self.Gr.nzg): qv = GMV.QT.values[k] - GMV.QL.values[k] - theta_rho[k] = theta_rho_c(self.Ref.p0[k], GMV.T.values[k], GMV.QT.values[k], qv) - zi = get_inversion(&theta_rho[0], &GMV.U.values[0], &GMV.V.values[0], &self.Gr.z[0], kmin, kmax, self.Ri_bulk_crit) + theta_rho[k] = theta_rho_c(self.Ref.p0_c[k], GMV.T.values[k], GMV.QT.values[k], qv) + zi = get_inversion(&theta_rho[0], &GMV.U.values[0], &GMV.V.values[0], &self.Gr.z_c[0], kmin, kmax, self.Ri_bulk_crit) wstar = get_wstar(self.bflux, zi) # yair here zi in TRMM should be adjusted self.windspeed = np.sqrt(self.windspeed*self.windspeed + (1.2 *wstar)*(1.2 * wstar) ) return @@ -60,9 +60,9 @@ cdef class SurfaceFixedFlux(SurfaceBase): if GMV.H.name == 'thetal': self.rho_hflux = rho_tflux / exner_c(self.Ref.Pg) elif GMV.H.name == 's': - self.rho_hflux = entropy_flux(rho_tflux/self.Ref.rho0[gw-1],self.rho_qtflux/self.Ref.rho0[gw-1], - self.Ref.p0[gw], GMV.T.values[gw], GMV.QT.values[gw]) - self.bflux = buoyancy_flux(self.shf, self.lhf, GMV.T.values[gw], GMV.QT.values[gw],self.Ref.alpha0[gw-1] ) + self.rho_hflux = entropy_flux(rho_tflux/self.Ref.rho0_f[gw-1],self.rho_qtflux/self.Ref.rho0_f[gw-1], + self.Ref.p0_f[gw], GMV.T.values[gw], GMV.QT.values[gw]) + self.bflux = buoyancy_flux(self.shf, self.lhf, GMV.T.values[gw], GMV.QT.values[gw],self.Ref.alpha0_f[gw-1] ) if not self.ustar_fixed: # Correction to windspeed for free convective cases (Beljaars, QJRMS (1994), 121, pp. 255-270) @@ -78,13 +78,13 @@ cdef class SurfaceFixedFlux(SurfaceBase): print('GMV.U.values[gw] ==>',GMV.U.values[gw]) print('GMV.v.values[gw] ==>',GMV.V.values[gw]) print('GMV.QT.values[gw] ==>',GMV.QT.values[gw]) - print('self.Ref.alpha0[gw-1] ==>',self.Ref.alpha0[gw-1]) + print('self.Ref.alpha0_f[gw-1] ==>',self.Ref.alpha0_f[gw-1]) - self.ustar = compute_ustar(self.windspeed, self.bflux, self.zrough, self.Gr.z[gw]) + self.ustar = compute_ustar(self.windspeed, self.bflux, self.zrough, self.Gr.z_c[gw]) self.obukhov_length = -self.ustar *self.ustar *self.ustar /self.bflux /vkb - self.rho_uflux = - self.Ref.rho0[gw-1] * self.ustar * self.ustar / self.windspeed * GMV.U.values[gw] - self.rho_vflux = - self.Ref.rho0[gw-1] * self.ustar * self.ustar / self.windspeed * GMV.V.values[gw] + self.rho_uflux = - self.Ref.rho0_f[gw-1] * self.ustar * self.ustar / self.windspeed * GMV.U.values[gw] + self.rho_vflux = - self.Ref.rho0_f[gw-1] * self.ustar * self.ustar / self.windspeed * GMV.V.values[gw] return cpdef free_convection_windspeed(self, GridMeanVariables GMV): SurfaceBase.free_convection_windspeed(self, GMV) @@ -112,23 +112,21 @@ cdef class SurfaceFixedCoeffs(SurfaceBase): double lv = latent_heat(GMV.T.values[gw]) double pv, pd, sv, sd - - self.rho_qtflux = -self.cq * windspeed * (GMV.QT.values[gw] - self.qsurface) * self.Ref.rho0[gw-1] + self.rho_qtflux = -self.cq * windspeed * (GMV.QT.values[gw] - self.qsurface) * self.Ref.rho0_f[gw-1] self.lhf = lv * self.rho_qtflux if GMV.H.name == 'thetal': - self.rho_hflux = -self.ch * windspeed * (GMV.H.values[gw] - self.Tsurface/exner_c(self.Ref.Pg)) * self.Ref.rho0[gw-1] + self.rho_hflux = -self.ch * windspeed * (GMV.H.values[gw] - self.Tsurface/exner_c(self.Ref.Pg)) * self.Ref.rho0_f[gw-1] self.shf = cp_ * self.rho_hflux elif GMV.H.name == 's': - self.rho_hflux = -self.ch * windspeed * (GMV.H.values[gw] - self.s_surface) * self.Ref.rho0[gw-1] + self.rho_hflux = -self.ch * windspeed * (GMV.H.values[gw] - self.s_surface) * self.Ref.rho0_f[gw-1] pv = pv_star(GMV.T.values[gw]) - pd = self.Ref.p0[gw] - pv + pd = self.Ref.p0_c[gw] - pv sv = sv_c(pv,GMV.T.values[gw]) sd = sd_c(pd, GMV.T.values[gw]) self.shf = (self.rho_hflux - self.lhf/lv * (sv-sd)) * GMV.T.values[gw] - - self.bflux = buoyancy_flux(self.shf, self.lhf, GMV.T.values[gw], GMV.QT.values[gw],self.Ref.alpha0[gw-1] ) + self.bflux = buoyancy_flux(self.shf, self.lhf, GMV.T.values[gw], GMV.QT.values[gw],self.Ref.alpha0_f[gw-1] ) self.ustar = np.sqrt(self.cm) * windspeed @@ -138,8 +136,8 @@ cdef class SurfaceFixedCoeffs(SurfaceBase): else: self.obukhov_length = -self.ustar *self.ustar *self.ustar /self.bflux /vkb - self.rho_uflux = - self.Ref.rho0[gw-1] * self.ustar * self.ustar / windspeed * GMV.U.values[gw] - self.rho_vflux = - self.Ref.rho0[gw-1] * self.ustar * self.ustar / windspeed * GMV.V.values[gw] + self.rho_uflux = - self.Ref.rho0_f[gw-1] * self.ustar * self.ustar / windspeed * GMV.U.values[gw] + self.rho_vflux = - self.Ref.rho0_f[gw-1] * self.ustar * self.ustar / windspeed * GMV.V.values[gw] return cpdef free_convection_windspeed(self, GridMeanVariables GMV): SurfaceBase.free_convection_windspeed(self, GMV) diff --git a/Turbulence.pyx b/Turbulence.pyx index 6aeeb411..425d8e14 100644 --- a/Turbulence.pyx +++ b/Turbulence.pyx @@ -85,14 +85,14 @@ cdef class ParameterizationBase: with nogil: for k in xrange(gw, self.Gr.nzg-gw): qv = GMV.QT.values[k] - GMV.QL.values[k] - theta_rho[k] = theta_rho_c(self.Ref.p0[k], GMV.T.values[k], GMV.QT.values[k], qv) + theta_rho[k] = theta_rho_c(self.Ref.p0_c[k], GMV.T.values[k], GMV.QT.values[k], qv) if option == 'theta_rho': with nogil: for k in xrange(kmin,kmax): if theta_rho[k] > theta_rho[kmin]: - self.zi = self.Gr.z[k] + self.zi = self.Gr.z_c[k] break elif option == 'thetal_maxgrad': @@ -101,9 +101,9 @@ cdef class ParameterizationBase: grad = (GMV.THL.values[k+1] - GMV.THL.values[k])*self.Gr.dzi if grad > maxgrad: maxgrad = grad - self.zi = self.Gr.z[k] + self.zi = self.Gr.z_c[k] elif option == 'critical_Ri': - self.zi = get_inversion(&theta_rho[0], &GMV.U.values[0], &GMV.V.values[0], &self.Gr.z[0], kmin, kmax, self.Ri_bulk_crit) + self.zi = get_inversion(&theta_rho[0], &GMV.U.values[0], &GMV.V.values[0], &self.Gr.z_c[0], kmin, kmax, self.Ri_bulk_crit) else: print('INVERSION HEIGHT OPTION NOT RECOGNIZED') @@ -129,7 +129,7 @@ cdef class ParameterizationBase: with nogil: for k in xrange(gw,nzg-gw): - zzi = self.Gr.z[k]/self.zi + zzi = self.Gr.z_c[k]/self.zi if zzi <= 1.0: self.KH.values[k] = vkb * ( (ustar/self.wstar)**3 + 39.0*vkb*zzi)**(1.0/3.0) * zzi * (1.0-zzi) * (1.0-zzi) * self.wstar * self.zi self.KM.values[k] = self.KH.values[k] * self.prandtl_number @@ -191,18 +191,18 @@ cdef class SimilarityED(ParameterizationBase): with nogil: for k in xrange(nzg-1): - rho_K_m[k] = 0.5 * (self.KH.values[k]+ self.KH.values[k+1]) * self.Ref.rho0[k] + rho_K_m[k] = 0.5 * (self.KH.values[k]+ self.KH.values[k+1]) * self.Ref.rho0_f[k] # Matrix is the same for all variables that use the same eddy diffusivity construct_tridiag_diffusion(nzg, gw, self.Gr.dzi, TS.dt, &rho_K_m[0], - &self.Ref.rho0[0], &dummy_ae[0] ,&a[0], &b[0], &c[0]) + &self.Ref.rho0_f[0], &dummy_ae[0] ,&a[0], &b[0], &c[0]) # Solve QT with nogil: for k in xrange(nz): x[k] = GMV.QT.values[k+gw] - x[0] = x[0] + TS.dt * Case.Sur.rho_qtflux * self.Gr.dzi * self.Ref.alpha0[gw] + x[0] = x[0] + TS.dt * Case.Sur.rho_qtflux * self.Gr.dzi * self.Ref.alpha0_f[gw] tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) with nogil: @@ -214,7 +214,7 @@ cdef class SimilarityED(ParameterizationBase): with nogil: for k in xrange(nz): x[k] = GMV.H.values[k+gw] - x[0] = x[0] + TS.dt * Case.Sur.rho_hflux * self.Gr.dzi * self.Ref.alpha0[gw] + x[0] = x[0] + TS.dt * Case.Sur.rho_hflux * self.Gr.dzi * self.Ref.alpha0_f[gw] tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) with nogil: @@ -226,7 +226,7 @@ cdef class SimilarityED(ParameterizationBase): with nogil: for k in xrange(nz): x[k] = GMV.U.values[k+gw] - x[0] = x[0] + TS.dt * Case.Sur.rho_uflux * self.Gr.dzi * self.Ref.alpha0[gw] + x[0] = x[0] + TS.dt * Case.Sur.rho_uflux * self.Gr.dzi * self.Ref.alpha0_f[gw] tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) with nogil: @@ -237,7 +237,7 @@ cdef class SimilarityED(ParameterizationBase): with nogil: for k in xrange(nz): x[k] = GMV.V.values[k+gw] - x[0] = x[0] + TS.dt * Case.Sur.rho_vflux * self.Gr.dzi * self.Ref.alpha0[gw] + x[0] = x[0] + TS.dt * Case.Sur.rho_vflux * self.Gr.dzi * self.Ref.alpha0_f[gw] tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) with nogil: diff --git a/Turbulence_PrognosticTKE.pxd b/Turbulence_PrognosticTKE.pxd index 15191dce..96c0c5b3 100644 --- a/Turbulence_PrognosticTKE.pxd +++ b/Turbulence_PrognosticTKE.pxd @@ -113,6 +113,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): EDMF_Updrafts.UpdraftVariable UpdVar2, EDMF_Environment.EnvironmentVariable EnvVar1, EDMF_Environment.EnvironmentVariable EnvVar2) cdef void compute_covariance_dissipation(self, EDMF_Environment.EnvironmentVariable_2m Covar) cdef void compute_covariance_shear(self,GridMeanVariables GMV, EDMF_Environment.EnvironmentVariable_2m Covar, double *UpdVar1, double *UpdVar2, double *EnvVar1, double *EnvVar2) + cdef void compute_covariance_massflux(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable phi_u, EDMF_Updrafts.UpdraftVariable psi_u, + EDMF_Environment.EnvironmentVariable phi_e, EDMF_Environment.EnvironmentVariable psi_e, EDMF_Environment.EnvironmentVariable_2m covar_e) cdef void update_covariance_ED(self, GridMeanVariables GMV, CasesBase Case,TimeStepping TS, VariablePrognostic GmvVar1, VariablePrognostic GmvVar2, VariableDiagnostic GmvCovar, EDMF_Environment.EnvironmentVariable_2m Covar, EDMF_Environment.EnvironmentVariable EnvVar1, EDMF_Environment.EnvironmentVariable EnvVar2, EDMF_Updrafts.UpdraftVariable UpdVar1, EDMF_Updrafts.UpdraftVariable UpdVar2) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index cbd89dc3..c7323819 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -23,7 +23,6 @@ from utility_functions cimport * from libc.math cimport fmax, sqrt, exp, pow, cbrt, fmin, fabs from cpython.mem cimport PyMem_Malloc, PyMem_Realloc, PyMem_Free import sys -import pylab as plt cdef class EDMF_PrognosticTKE(ParameterizationBase): # Initialize the class @@ -206,7 +205,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Stats.add_profile('tke_detr_loss') Stats.add_profile('tke_shear') Stats.add_profile('tke_pressure') - Stats.add_profile('massflux_tke') + Stats.add_profile('tke_massflux') if self.calc_scalar_var: Stats.add_profile('Hvar_dissipation') @@ -224,6 +223,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Stats.add_profile('Hvar_rain') Stats.add_profile('QTvar_rain') Stats.add_profile('HQTcov_rain') + Stats.add_profile('Hvar_massflux') + Stats.add_profile('QTvar_massflux') + Stats.add_profile('HQTcov_massflux') return @@ -282,6 +284,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Stats.write_profile('tke_shear', self.EnvVar.TKE.shear[kmin:kmax]) Stats.write_profile('tke_buoy', self.EnvVar.TKE.buoy[kmin:kmax]) Stats.write_profile('tke_pressure', self.EnvVar.TKE.press[kmin:kmax]) + Stats.write_profile('tke_massflux', self.EnvVar.TKE.massflux[kmin:kmax]) if self.calc_scalar_var: self.compute_covariance_dissipation(self.EnvVar.Hvar) @@ -305,6 +308,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Stats.write_profile('Hvar_rain', self.EnvVar.Hvar.rain_src[kmin:kmax]) Stats.write_profile('QTvar_rain', self.EnvVar.QTvar.rain_src[kmin:kmax]) Stats.write_profile('HQTcov_rain', self.EnvVar.HQTcov.rain_src[kmin:kmax]) + Stats.write_profile('Hvar_massflux', self.EnvVar.Hvar.massflux[kmin:kmax]) + Stats.write_profile('QTvar_massflux', self.EnvVar.QTvar.massflux[kmin:kmax]) + Stats.write_profile('HQTcov_massflux', self.EnvVar.HQTcov.massflux[kmin:kmax]) # Perform the update of the scheme @@ -412,11 +418,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.H.values[i,gw] = self.h_surface_bc[i] self.UpdVar.QT.values[i,gw] = self.qt_surface_bc[i] # Find the cloud liquid content - sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0[gw], + sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_c[gw], self.UpdVar.QT.values[i,gw], self.UpdVar.H.values[i,gw]) self.UpdVar.QL.values[i,gw] = sa.ql self.UpdVar.T.values[i,gw] = sa.T - self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0[gw], self.UpdVar.T.values[i,gw], + self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0_c[gw], self.UpdVar.T.values[i,gw], &self.UpdVar.QT.values[i,gw], &self.UpdVar.QL.values[i,gw], &self.UpdVar.QR.values[i,gw], &self.UpdVar.H.values[i,gw], i, gw) @@ -426,11 +432,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.QT.values[i,k] = (self.UpdVar.QT.values[i,k-1] + self.entr_sc[i,k] * dz * GMV.QT.values[k])/denom - sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0[k], + sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_c[k], self.UpdVar.QT.values[i,k], self.UpdVar.H.values[i,k]) self.UpdVar.QL.values[i,k] = sa.ql self.UpdVar.T.values[i,k] = sa.T - self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0[k], self.UpdVar.T.values[i,k], + self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0_c[k], self.UpdVar.T.values[i,k], &self.UpdVar.QT.values[i,k], &self.UpdVar.QL.values[i,k], &self.UpdVar.QR.values[i,k], &self.UpdVar.H.values[i,k], i, k) @@ -483,19 +489,19 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): if self.entr_sc[i,k]>(0.9/dz): self.entr_sc[i,k] = 0.9/dz - self.UpdVar.Area.values[i,k] = (self.Ref.rho0[k-1]*self.UpdVar.Area.values[i,k-1]*w_low/ - (1.0-(self.entr_sc[i,k]-self.detr_sc[i,k])*dz)/w_mid/self.Ref.rho0[k]) + self.UpdVar.Area.values[i,k] = (self.Ref.rho0_c[k-1]*self.UpdVar.Area.values[i,k-1]*w_low/ + (1.0-(self.entr_sc[i,k]-self.detr_sc[i,k])*dz)/w_mid/self.Ref.rho0_c[k]) # # Limit the increase in updraft area when the updraft decelerates if self.UpdVar.Area.values[i,k] > au_lim: self.UpdVar.Area.values[i,k] = au_lim - self.detr_sc[i,k] =(self.Ref.rho0[k-1] * self.UpdVar.Area.values[i,k-1] - * w_low / au_lim / w_mid / self.Ref.rho0[k] + self.entr_sc[i,k] * dz -1.0)/dz + self.detr_sc[i,k] =(self.Ref.rho0_c[k-1] * self.UpdVar.Area.values[i,k-1] + * w_low / au_lim / w_mid / self.Ref.rho0_c[k] + self.entr_sc[i,k] * dz -1.0)/dz else: # the updraft has terminated so set its area fraction to zero at this height and all heights above self.UpdVar.Area.values[i,k] = 0.0 self.UpdVar.H.values[i,k] = GMV.H.values[k] self.UpdVar.QT.values[i,k] = GMV.QT.values[k] - sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0[k], + sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_c[k], self.UpdVar.QT.values[i,k], self.UpdVar.H.values[i,k]) self.UpdVar.QL.values[i,k] = sa.ql self.UpdVar.T.values[i,k] = sa.T @@ -531,7 +537,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(gw, self.Gr.nzg-gw): l1 = tau * sqrt(fmax(self.EnvVar.TKE.values[k],0.0)) - z_ = self.Gr.z[k] + z_ = self.Gr.z_c[k] if obukhov_length < 0.0: #unstable l2 = vkb * z_ * ( (1.0 - 100.0 * z_/obukhov_length)**0.2 ) elif obukhov_length > 0.0: #stable @@ -567,12 +573,12 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cdef: Py_ssize_t i, gw = self.Gr.gw - double zLL = self.Gr.z[gw] + double zLL = self.Gr.z_c[gw] double dzi = self.Gr.dzi double dti_ = 0.1 double adv, buoy, exch, press, press_buoy, press_drag double ustar = Case.Sur.ustar, oblength = Case.Sur.obukhov_length - double alpha0LL = self.Ref.alpha0[gw] + double alpha0LL = self.Ref.alpha0_c[gw] double qt_var = get_surface_variance(Case.Sur.rho_qtflux*alpha0LL, Case.Sur.rho_qtflux*alpha0LL, ustar, zLL, oblength) double h_var = get_surface_variance(Case.Sur.rho_hflux*alpha0LL, @@ -672,6 +678,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): gmv_covar[k] += au.values[i,k] * phi_diff * psi_diff return + cdef get_env_covar_from_GMV(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable phi_u, EDMF_Updrafts.UpdraftVariable psi_u, EDMF_Environment.EnvironmentVariable phi_e, EDMF_Environment.EnvironmentVariable psi_e, @@ -703,7 +710,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): entr_struct ret entr_in_struct input eos_struct sa - #double [:] Poisson_rand + double [:] Poisson_rand double logfn long quadrature_order = 2 @@ -722,7 +729,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): input.b_mean = GMV.B.values[k] input.w = self.UpdVar.W.values[i,k] input.dw = (self.UpdVar.W.values[i,k+1]-self.UpdVar.W.values[i,k-1])/self.Gr.dz/2.0 - input.z = self.Gr.z[k] + input.z = self.Gr.z_c[k] input.af = self.UpdVar.Area.values[i,k] input.tke = self.EnvVar.TKE.values[k] input.ml = self.mixing_length[k] @@ -739,8 +746,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): input.qt_up = self.UpdVar.QT.values[i,k] input.ql_up = self.UpdVar.QL.values[i,k] input.T_up = self.UpdVar.T.values[i,k] - input.p0 = self.Ref.p0[k] - input.alpha0 = self.Ref.alpha0[k] + input.p0 = self.Ref.p0_c[k] + input.alpha0 = self.Ref.alpha0_c[k] input.tke_ed_coeff = self.tke_ed_coeff input.Poisson_rand = Poisson_rand[k]/10.0 input.L = 20000.0 # need to define the scale of the GCM grid resolution @@ -771,16 +778,16 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.Area.new[i,gw] = self.area_surface_bc[i] au_lim = self.area_surface_bc[i] * self.max_area_factor - adv = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * self.UpdVar.W.values[i,gw] * dzi*2.0) - exch = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] + adv = (self.Ref.rho0_c[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * self.UpdVar.W.values[i,gw] * dzi*2.0) + exch = (self.Ref.rho0_c[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * (self.entr_sc[i,gw] * self.EnvVar.W.values[gw] - self.detr_sc[i,gw] * self.UpdVar.W.values[i,gw] )) - buoy= self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.B.values[i,gw] - press_buoy = -1.0 * self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.B.values[i,gw] * self.pressure_buoy_coeff - press_drag = -1.0 * self.Ref.rho0[gw]*sqrt(self.UpdVar.Area.values[i,gw])*self.pressure_drag_coeff/self.pressure_plume_spacing \ + buoy= self.Ref.rho0_c[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.B.values[i,gw] + press_buoy = -1.0 * self.Ref.rho0_c[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.B.values[i,gw] * self.pressure_buoy_coeff + press_drag = -1.0 * self.Ref.rho0_c[gw]*sqrt(self.UpdVar.Area.values[i,gw])*self.pressure_drag_coeff/self.pressure_plume_spacing \ * (self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])*fabs(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw]) press = press_buoy + press_drag - self.UpdVar.W.new[i,gw] = (self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * dti_ - -adv + exch + buoy + press)/(self.Ref.rho0[gw] * self.UpdVar.Area.new[i,gw] * dti_) + self.UpdVar.W.new[i,gw] = (self.Ref.rho0_c[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * dti_ + -adv + exch + buoy + press)/(self.Ref.rho0_c[gw] * self.UpdVar.Area.new[i,gw] * dti_) #self.UpdVar.W.values[i,gw] = self.UpdVar.W.new[i,gw] @@ -788,10 +795,10 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.QT.new[i,gw] = self.qt_surface_bc[i] sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, - self.Ref.p0[gw], self.UpdVar.QT.new[i,gw], self.UpdVar.H.new[i,gw]) + self.Ref.p0_c[gw], self.UpdVar.QT.new[i,gw], self.UpdVar.H.new[i,gw]) self.UpdVar.QL.new[i,gw] = sa.ql self.UpdVar.T.new[i,gw] = sa.T - self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0[gw], self.UpdVar.T.new[i,gw], + self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0_c[gw], self.UpdVar.T.new[i,gw], &self.UpdVar.QT.new[i,gw], &self.UpdVar.QL.new[i,gw], &self.UpdVar.QR.new[i,gw], &self.UpdVar.H.new[i,gw], i, gw) @@ -818,14 +825,14 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.H.new[i,k] = GMV.H.values[k] self.UpdVar.QT.new[i,k] = GMV.QT.values[k] - sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0[k], + sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_c[k], self.UpdVar.QT.new[i,k], self.UpdVar.H.new[i,k]) self.UpdVar.QL.new[i,k] = sa.ql self.UpdVar.T.new[i,k] = sa.T if self.use_local_micro: - self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0[k], self.UpdVar.T.new[i,k], + self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0_c[k], self.UpdVar.T.new[i,k], &self.UpdVar.QT.new[i,k], &self.UpdVar.QL.new[i,k], &self.UpdVar.QR.new[i,k], &self.UpdVar.H.new[i,k], i, k) @@ -859,9 +866,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double area_new = 1.0 if var.name == 'w': - buoy = self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] - press_buoy = -1.0 * self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] * self.pressure_buoy_coeff - press_drag = -1.0 * self.Ref.rho0[k]*(sqrt(self.UpdVar.Area.values[i,k] )*self.pressure_drag_coeff/self.pressure_plume_spacing + buoy = self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] + press_buoy = -1.0 * self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] * self.pressure_buoy_coeff + press_drag = -1.0 * self.Ref.rho0_c[k]*(sqrt(self.UpdVar.Area.values[i,k] )*self.pressure_drag_coeff/self.pressure_plume_spacing * (self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k])*fabs(self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k])) press = press_buoy + press_drag area_new = area.new[i,k] @@ -876,19 +883,19 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: if self.UpdVar.W.values[i,k]<0: - adv = (self.Ref.rho0[k+1] * area.values[i,k+1] * self.UpdVar.W.values[i,k+1] * var_kp - - self.Ref.rho0[k] *area.values[i,k] * self.UpdVar.W.values[i,k] * var_k )* dzi - exch = (self.Ref.rho0[k] * area.values[i,k] * self.UpdVar.W.values[i,k] + adv = (self.Ref.rho0_c[k+1] * area.values[i,k+1] * self.UpdVar.W.values[i,k+1] * var_kp + - self.Ref.rho0_c[k] *area.values[i,k] * self.UpdVar.W.values[i,k] * var_k )* dzi + exch = (self.Ref.rho0_c[k] * area.values[i,k] * self.UpdVar.W.values[i,k] * (-self.entr_sc[i,k] * env_var + self.detr_sc[i,k] * var_k )) else: - adv = (self.Ref.rho0[k] * area.values[i,k] * self.UpdVar.W.values[i,k] * var_k - - self.Ref.rho0[k-1] * area.values[i,k-1] * self.UpdVar.W.values[i,k-1] * var_km)* dzi - exch = (self.Ref.rho0[k] * area.values[i,k] * self.UpdVar.W.values[i,k] + adv = (self.Ref.rho0_c[k] * area.values[i,k] * self.UpdVar.W.values[i,k] * var_k + - self.Ref.rho0_c[k-1] * area.values[i,k-1] * self.UpdVar.W.values[i,k-1] * var_km)* dzi + exch = (self.Ref.rho0_c[k] * area.values[i,k] * self.UpdVar.W.values[i,k] * (self.entr_sc[i,k] * env_var - self.detr_sc[i,k] * var_k )) self.updraft_pressure_sink[i,k] = press - var.new[i,k] = (self.Ref.rho0[k] * area.values[i,k] * var_k * dti_ -adv + exch + buoy + press)\ - /(self.Ref.rho0[k] * area_new * dti_) + var.new[i,k] = (self.Ref.rho0_c[k] * area.values[i,k] * var_k * dti_ -adv + exch + buoy + press)\ + /(self.Ref.rho0_c[k] * area_new * dti_) # After updating the updraft variables themselves: # 1. compute the mass fluxes (currently not stored as class members, probably will want to do this @@ -911,8 +918,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for i in xrange(self.n_updrafts): self.m[i,gw-1] = 0.0 for k in xrange(self.Gr.gw, self.Gr.nzg): - m_kp = ((self.UpdVar.W.values[i,k+1] - self.EnvVar.W.values[k+1] )* self.Ref.rho0[k+1] * self.UpdVar.Area.values[i,k+1]) - m_k = ((self.UpdVar.W.values[i,k] - self.EnvVar.W.values[k] )* self.Ref.rho0[k] * self.UpdVar.Area.values[i,k]) + m_kp = ((self.UpdVar.W.values[i,k+1] - self.EnvVar.W.values[k+1] )* self.Ref.rho0_c[k+1] * self.UpdVar.Area.values[i,k+1]) + m_k = ((self.UpdVar.W.values[i,k] - self.EnvVar.W.values[k] )* self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k]) self.m[i,k] = interp2pt(m_kp,m_k) self.massflux_h[gw-1] = 0.0 @@ -934,8 +941,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg): - mf_tend_h = -(self.massflux_h[k] - self.massflux_h[k-1]) * (self.Ref.alpha0[k] * self.Gr.dzi) - mf_tend_qt = -(self.massflux_qt[k] - self.massflux_qt[k-1]) * (self.Ref.alpha0[k] * self.Gr.dzi) + mf_tend_h = -(self.massflux_h[k] - self.massflux_h[k-1]) * (self.Ref.alpha0_c[k] * self.Gr.dzi) + mf_tend_qt = -(self.massflux_qt[k] - self.massflux_qt[k-1]) * (self.Ref.alpha0_c[k] * self.Gr.dzi) GMV.H.mf_update[k] = GMV.H.values[k] + TS.dt * mf_tend_h + self.UpdMicro.prec_source_h_tot[k] GMV.QT.mf_update[k] = GMV.QT.values[k] + TS.dt * mf_tend_qt + self.UpdMicro.prec_source_qt_tot[k] @@ -974,17 +981,17 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(nzg-1): - rho_ae_K_m[k] = 0.5 * (ae[k]*self.KH.values[k] * self.Ref.rho0[k]+ ae[k+1]*self.KH.values[k+1] * self.Ref.rho0[k+1]) + rho_ae_K_m[k] = 0.5 * (ae[k]*self.KH.values[k] + ae[k+1]*self.KH.values[k+1])* self.Ref.rho0_f[k] # Matrix is the same for all variables that use the same eddy diffusivity, we can construct once and reuse - construct_tridiag_diffusion(nzg, gw, dzi, TS.dt, &rho_ae_K_m[0], &self.Ref.rho0[0], + construct_tridiag_diffusion(nzg, gw, dzi, TS.dt, &rho_ae_K_m[0], &self.Ref.rho0_c[0], &ae[0], &a[0], &b[0], &c[0]) # Solve QT with nogil: for k in xrange(nz): x[k] = self.EnvVar.QT.values[k+gw] - x[0] = x[0] + TS.dt * Case.Sur.rho_qtflux * dzi * self.Ref.alpha0[gw]/ae[gw] + x[0] = x[0] + TS.dt * Case.Sur.rho_qtflux * dzi * self.Ref.alpha0_c[gw]/ae[gw] tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) with nogil: @@ -993,13 +1000,13 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # get the diffusive flux self.diffusive_flux_qt[gw] = interp2pt(Case.Sur.rho_qtflux, -rho_ae_K_m[gw] * dzi *(self.EnvVar.QT.values[gw+1]-self.EnvVar.QT.values[gw]) ) for k in xrange(self.Gr.gw+1, self.Gr.nzg-self.Gr.gw): - self.diffusive_flux_qt[k] = -0.5 * self.Ref.rho0[k]*ae[k] * self.KH.values[k] * dzi * (self.EnvVar.QT.values[k+1]-self.EnvVar.QT.values[k-1]) + self.diffusive_flux_qt[k] = -0.5 * self.Ref.rho0_c[k]*ae[k] * self.KH.values[k] * dzi * (self.EnvVar.QT.values[k+1]-self.EnvVar.QT.values[k-1]) # Solve H with nogil: for k in xrange(nz): x[k] = self.EnvVar.H.values[k+gw] - x[0] = x[0] + TS.dt * Case.Sur.rho_hflux * dzi * self.Ref.alpha0[gw]/ae[gw] + x[0] = x[0] + TS.dt * Case.Sur.rho_hflux * dzi * self.Ref.alpha0_c[gw]/ae[gw] tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) with nogil: @@ -1009,20 +1016,20 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # get the diffusive flux self.diffusive_flux_h[gw] = interp2pt(Case.Sur.rho_hflux, -rho_ae_K_m[gw] * dzi *(self.EnvVar.H.values[gw+1]-self.EnvVar.H.values[gw]) ) for k in xrange(self.Gr.gw+1, self.Gr.nzg-self.Gr.gw): - self.diffusive_flux_h[k] = -0.5 * self.Ref.rho0[k]*ae[k] * self.KH.values[k] * dzi * (self.EnvVar.H.values[k+1]-self.EnvVar.H.values[k-1]) + self.diffusive_flux_h[k] = -0.5 * self.Ref.rho0_c[k]*ae[k] * self.KH.values[k] * dzi * (self.EnvVar.H.values[k+1]-self.EnvVar.H.values[k-1]) # Solve U with nogil: for k in xrange(nzg-1): - rho_ae_K_m[k] = 0.5 * (ae[k]*self.KM.values[k]+ ae[k+1]*self.KM.values[k+1]) * self.Ref.rho0[k] + rho_ae_K_m[k] = 0.5 * (ae[k]*self.KM.values[k]+ ae[k+1]*self.KM.values[k+1]) * self.Ref.rho0_f[k] # Matrix is the same for all variables that use the same eddy diffusivity, we can construct once and reuse - construct_tridiag_diffusion(nzg, gw, dzi, TS.dt, &rho_ae_K_m[0], &self.Ref.rho0[0], + construct_tridiag_diffusion(nzg, gw, dzi, TS.dt, &rho_ae_K_m[0], &self.Ref.rho0_c[0], &ae[0], &a[0], &b[0], &c[0]) with nogil: for k in xrange(nz): x[k] = GMV.U.values[k+gw] - x[0] = x[0] + TS.dt * Case.Sur.rho_uflux * dzi * self.Ref.alpha0[gw]/ae[gw] + x[0] = x[0] + TS.dt * Case.Sur.rho_uflux * dzi * self.Ref.alpha0_c[gw]/ae[gw] tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) with nogil: @@ -1033,7 +1040,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(nz): x[k] = GMV.V.values[k+gw] - x[0] = x[0] + TS.dt * Case.Sur.rho_vflux * dzi * self.Ref.alpha0[gw]/ae[gw] + x[0] = x[0] + TS.dt * Case.Sur.rho_vflux * dzi * self.Ref.alpha0_c[gw]/ae[gw] tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) with nogil: @@ -1078,7 +1085,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): grad_thl_plus = (self.EnvVar.THL.values[k+1] - self.EnvVar.THL.values[k]) * self.Gr.dzi grad_qt_plus = (self.EnvVar.QT.values[k+1] - self.EnvVar.QT.values[k]) * self.Gr.dzi - prefactor = Rd * exner_c(self.Ref.p0[k])/self.Ref.p0[k] + prefactor = Rd * exner_c(self.Ref.p0_c[k])/self.Ref.p0_c[k] d_alpha_thetal_dry = prefactor * (1.0 + (eps_vi-1.0) * qt_dry) d_alpha_qt_dry = prefactor * th_dry * (eps_vi-1.0) @@ -1095,7 +1102,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): + (1.0-self.EnvVar.CF.values[k]) * d_alpha_thetal_dry) d_alpha_qt_total = (self.EnvVar.CF.values[k] * d_alpha_qt_cloudy + (1.0-self.EnvVar.CF.values[k]) * d_alpha_qt_dry) - self.EnvVar.TKE.buoy[k] = g / self.Ref.alpha0[k] * ae[k] * self.Ref.rho0[k] \ + self.EnvVar.TKE.buoy[k] = g / self.Ref.alpha0_c[k] * ae[k] * self.Ref.rho0_c[k] \ * ( -self.KH.values[k] *grad_thl_plus * d_alpha_thetal_total - self.KH.values[k] * grad_qt_plus * d_alpha_qt_total) return @@ -1114,9 +1121,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for i in xrange(self.n_updrafts): wu = self.UpdVar.W.values[i,k] we = self.EnvVar.W.values[k] - press_buoy= (-1.0 * self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] + press_buoy= (-1.0 * self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] * self.pressure_buoy_coeff) - press_drag = (-1.0 * self.Ref.rho0[k] * sqrt(self.UpdVar.Area.values[i,k]) + press_drag = (-1.0 * self.Ref.rho0_c[k] * sqrt(self.UpdVar.Area.values[i,k]) * (self.pressure_drag_coeff/self.pressure_plume_spacing*(wu -we)*fabs(wu -we))) self.EnvVar.TKE.press[k] += (we - wu) * (press_buoy + press_drag) return @@ -1140,13 +1147,14 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): + (1.0 - self.UpdVar.Area.bulkvalues[k]) * self.EnvVar.T.values[k]) qv = GMV.QT.values[k] - GMV.QL.values[k] - GMV.THL.values[k] = t_to_thetali_c(self.Ref.p0[k], GMV.T.values[k], GMV.QT.values[k], + GMV.THL.values[k] = t_to_thetali_c(self.Ref.p0_c[k], GMV.T.values[k], GMV.QT.values[k], GMV.QL.values[k], 0.0) GMV.B.values[k] = (self.UpdVar.Area.bulkvalues[k] * self.UpdVar.B.bulkvalues[k] + (1.0 - self.UpdVar.Area.bulkvalues[k]) * self.EnvVar.B.values[k]) return + cpdef compute_covariance(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS): if TS.nstep > 0: @@ -1156,6 +1164,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.compute_tke_buoy(GMV) self.compute_covariance_entr(self.EnvVar.TKE, self.UpdVar.W, self.UpdVar.W, self.EnvVar.W, self.EnvVar.W) self.compute_covariance_shear(GMV, self.EnvVar.TKE, &self.UpdVar.W.values[0,0], &self.UpdVar.W.values[0,0], &self.EnvVar.W.values[0], &self.EnvVar.W.values[0]) + self.compute_covariance_massflux(self.UpdVar.Area,self.UpdVar.W,self.UpdVar.W,self.EnvVar.W, self.EnvVar.W, self.EnvVar.TKE) self.compute_tke_pressure() if self.calc_scalar_var: self.compute_covariance_entr(self.EnvVar.Hvar, self.UpdVar.H, self.UpdVar.H, self.EnvVar.H, self.EnvVar.H) @@ -1164,6 +1173,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.compute_covariance_shear(GMV, self.EnvVar.Hvar, &self.UpdVar.H.values[0,0], &self.UpdVar.H.values[0,0], &self.EnvVar.H.values[0], &self.EnvVar.H.values[0]) self.compute_covariance_shear(GMV, self.EnvVar.QTvar, &self.UpdVar.QT.values[0,0], &self.UpdVar.QT.values[0,0], &self.EnvVar.QT.values[0], &self.EnvVar.QT.values[0]) self.compute_covariance_shear(GMV, self.EnvVar.HQTcov, &self.UpdVar.H.values[0,0], &self.UpdVar.QT.values[0,0], &self.EnvVar.H.values[0], &self.EnvVar.QT.values[0]) + self.compute_covariance_massflux(self.UpdVar.Area,self.UpdVar.H,self.UpdVar.H,self.EnvVar.H, self.EnvVar.H, self.EnvVar.Hvar) + self.compute_covariance_massflux(self.UpdVar.Area,self.UpdVar.QT,self.UpdVar.QT,self.EnvVar.QT, self.EnvVar.QT, self.EnvVar.QTvar) + self.compute_covariance_massflux(self.UpdVar.Area,self.UpdVar.H,self.UpdVar.QT,self.EnvVar.H, self.EnvVar.QT, self.EnvVar.HQTcov) self.compute_covariance_rain(TS, GMV) # need to update this one self.reset_surface_covariance(GMV, Case) @@ -1193,13 +1205,13 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): if ws > 0.0: with nogil: for k in xrange(self.Gr.nzg): - z = self.Gr.z[k] + z = self.Gr.z_c[k] GMV.TKE.values[k] = ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) if self.calc_scalar_var: if ws > 0.0: with nogil: for k in xrange(self.Gr.nzg): - z = self.Gr.z[k] + z = self.Gr.z_c[k] # need to rethink of how to initilize the covarinace profiles - for nowmI took the TKE profile GMV.Hvar.values[k] = GMV.Hvar.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) GMV.QTvar.values[k] = GMV.QTvar.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) @@ -1213,14 +1225,14 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): flux1 = Case.Sur.rho_hflux flux2 = Case.Sur.rho_qtflux cdef: - double zLL = self.Gr.z[self.Gr.gw] + double zLL = self.Gr.z_c[self.Gr.gw] double ustar = Case.Sur.ustar, oblength = Case.Sur.obukhov_length - double alpha0LL = self.Ref.alpha0[self.Gr.gw] + double alpha0LL = self.Ref.alpha0_c[self.Gr.gw] #double get_surface_variance = get_surface_variance(flux1, flux2 ,ustar, zLL, oblength) if self.calc_tke: GMV.TKE.values[self.Gr.gw] = get_surface_tke(Case.Sur.ustar, self.wstar, - self.Gr.z[self.Gr.gw], + self.Gr.z_c[self.Gr.gw], Case.Sur.obukhov_length) if self.calc_scalar_var: GMV.Hvar.values[self.Gr.gw] = get_surface_variance(flux1*alpha0LL,flux1*alpha0LL, ustar, zLL, oblength) @@ -1264,10 +1276,32 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: diff_var1 = (EnvVar1[k+1] - EnvVar1[k-1]) * self.Gr.dzi/2.0 diff_var2 = (EnvVar2[k+1] - EnvVar2[k-1]) * self.Gr.dzi/2.0 - Covar.shear[k] = tke_factor*2.0*(self.Ref.rho0[k] * ae[k] * self.KH.values[k] * + Covar.shear[k] = tke_factor*2.0*(self.Ref.rho0_c[k] * ae[k] * self.KH.values[k] * (diff_var1*diff_var2 + pow(du,2.0) + pow(dv,2.0))) return + cdef void compute_covariance_massflux(self, EDMF_Updrafts.UpdraftVariable au, + EDMF_Updrafts.UpdraftVariable phi_u, EDMF_Updrafts.UpdraftVariable psi_u, + EDMF_Environment.EnvironmentVariable phi_e, EDMF_Environment.EnvironmentVariable psi_e, + EDMF_Environment.EnvironmentVariable_2m Covar): + cdef: + Py_ssize_t i,k + double phi_diff, psi_diff, tke_factor + + if Covar.name == 'tke': + tke_factor = 0.5 + else: + tke_factor = 1.0 + + with nogil: + for k in xrange(self.Gr.nzg): + Covar.massflux[k] = 0.0 + for i in xrange(self.n_updrafts): + phi_diff = phi_u.values[i,k]-phi_e.values[k] + psi_diff = psi_u.values[i,k]-psi_e.values[k] + Covar.massflux[k] += tke_factor*au.values[i,k] * (1.0-au.values[i,k]) * phi_diff * psi_diff + return + cdef void compute_covariance_dissipation(self, EDMF_Environment.EnvironmentVariable_2m Covar): cdef: Py_ssize_t i @@ -1277,7 +1311,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - Covar.dissipation[k] = (self.Ref.rho0[k] * ae[k] * Covar.values[k] + Covar.dissipation[k] = (self.Ref.rho0_c[k] * ae[k] * Covar.values[k] *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0) * self.tke_diss_coeff) return @@ -1294,7 +1328,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for i in xrange(self.n_updrafts): Covar.entr_gain[k] += tke_factor*self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.detr_sc[i,k] * \ (UpdVar1.values[i,k] - EnvVar1.values[k]) * (UpdVar2.values[i,k] - EnvVar2.values[k]) - Covar.entr_gain[k] *= self.Ref.rho0[k] + Covar.entr_gain[k] *= self.Ref.rho0_c[k] return cdef void compute_covariance_detr(self, EDMF_Environment.EnvironmentVariable_2m Covar): @@ -1305,7 +1339,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Covar.detr_loss[k] = 0.0 for i in xrange(self.n_updrafts): Covar.detr_loss[k] += self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.entr_sc[i,k] - Covar.detr_loss[k] *= self.Ref.rho0[k] * Covar.values[k] + Covar.detr_loss[k] *= self.Ref.rho0_c[k] * Covar.values[k] return cpdef compute_covariance_rain(self, TimeStepping TS, GridMeanVariables GMV): @@ -1317,9 +1351,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): self.EnvVar.TKE.rain_src[k] = 0.0 - self.EnvVar.Hvar.rain_src[k] = self.Ref.rho0[k] * ae[k] * 2. * self.EnvThermo.Hvar_rain_dt[k] * TS.dti - self.EnvVar.QTvar.rain_src[k] = self.Ref.rho0[k] * ae[k] * 2. * self.EnvThermo.QTvar_rain_dt[k] * TS.dti - self.EnvVar.HQTcov.rain_src[k] = self.Ref.rho0[k] * ae[k] * self.EnvThermo.HQTcov_rain_dt[k] * TS.dti + self.EnvVar.Hvar.rain_src[k] = self.Ref.rho0_c[k] * ae[k] * 2. * self.EnvThermo.Hvar_rain_dt[k] * TS.dti + self.EnvVar.QTvar.rain_src[k] = self.Ref.rho0_c[k] * ae[k] * 2. * self.EnvThermo.QTvar_rain_dt[k] * TS.dti + self.EnvVar.HQTcov.rain_src[k] = self.Ref.rho0_c[k] * ae[k] * self.EnvThermo.HQTcov_rain_dt[k] * TS.dti return @@ -1333,8 +1367,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Py_ssize_t nz = self.Gr.nz double dzi = self.Gr.dzi double dti = TS.dti - double alpha0LL = self.Ref.alpha0[self.Gr.gw] - double zLL = self.Gr.z[self.Gr.gw] + double alpha0LL = self.Ref.alpha0_c[self.Gr.gw] + double zLL = self.Gr.z_c[self.Gr.gw] double [:] a = np.zeros((nz,),dtype=np.double, order='c') double [:] b = np.zeros((nz,),dtype=np.double, order='c') double [:] c = np.zeros((nz,),dtype=np.double, order='c') @@ -1347,10 +1381,10 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(1,nzg-1): - rho_ae_K_m[k] = 0.5 * (ae[k]*self.KH.values[k]* self.Ref.rho0[k]+ ae[k+1]*self.KH.values[k+1]* self.Ref.rho0[k+1]) + rho_ae_K_m[k] = 0.5 * (ae[k]*self.KH.values[k]+ ae[k+1]*self.KH.values[k+1])* self.Ref.rho0_f[k] if GmvCovar.name=='tke': - GmvCovar.values[gw] =get_surface_tke(Case.Sur.ustar, self.wstar, self.Gr.z[gw], Case.Sur.obukhov_length) + GmvCovar.values[gw] =get_surface_tke(Case.Sur.ustar, self.wstar, self.Gr.z_c[gw], Case.Sur.obukhov_length) elif GmvCovar.name=='thetal_var': GmvCovar.values[gw] = get_surface_variance(Case.Sur.rho_hflux * alpha0LL, Case.Sur.rho_hflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) elif GmvCovar.name=='qt_var': @@ -1368,16 +1402,16 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): D_env = 0.0 for i in xrange(self.n_updrafts): - D_env += self.Ref.rho0[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.entr_sc[i,k] + D_env += self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.entr_sc[i,k] a[kk] = (- rho_ae_K_m[k-1] * dzi * dzi ) - b[kk] = (self.Ref.rho0[k] * ae[k] * dti - self.Ref.rho0[k] * ae[k] * self.EnvVar.W.values[k] * dzi + b[kk] = (self.Ref.rho0_c[k] * ae[k] * dti - self.Ref.rho0_c[k] * ae[k] * self.EnvVar.W.values[k] * dzi + rho_ae_K_m[k] * dzi * dzi + rho_ae_K_m[k-1] * dzi * dzi + D_env - + self.Ref.rho0[k] * ae[k] * self.tke_diss_coeff + + self.Ref.rho0_c[k] * ae[k] * self.tke_diss_coeff *sqrt(fmax(self.EnvVar.TKE.values[k],0))/fmax(self.mixing_length[k],1.0) ) - c[kk] = (self.Ref.rho0[k+1] * ae[k+1] * self.EnvVar.W.values[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) - x[kk] = (self.Ref.rho0[k] * ae_old[k] * Covar.values[k] * dti + c[kk] = (self.Ref.rho0_c[k+1] * ae[k+1] * self.EnvVar.W.values[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) + x[kk] = (self.Ref.rho0_c[k] * ae_old[k] * Covar.values[k] * dti + Covar.press[k] + Covar.buoy[k] + Covar.shear[k] + Covar.entr_gain[k] + Covar.rain_src[k]) # a[0] = 0.0 diff --git a/Variables.pyx b/Variables.pyx index b4a597cd..fec1f00a 100644 --- a/Variables.pyx +++ b/Variables.pyx @@ -288,7 +288,7 @@ cdef class GridMeanVariables: Stats.write_profile('HQTcov_mean',self.HQTcov.values[self.Gr.gw:self.Gr.nzg-self.Gr.gw]) for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - lwp += self.Ref.rho0[k]*self.QL.values[k]*self.Gr.dz + lwp += self.Ref.rho0_c[k]*self.QL.values[k]*self.Gr.dz Stats.write_ts('lwp', lwp) return @@ -303,13 +303,13 @@ cdef class GridMeanVariables: for k in xrange(self.Gr.nzg): h = self.H.values[k] qt = self.QT.values[k] - p0 = self.Ref.p0[k] + p0 = self.Ref.p0_c[k] sa = eos(self.t_to_prog_fp,self.prog_to_t_fp, p0, qt, h ) self.QL.values[k] = sa.ql self.T.values[k] = sa.T qv = qt - sa.ql self.THL.values[k] = t_to_thetali_c(p0, sa.T, qt, sa.ql,0.0) alpha = alpha_c(p0, sa.T, qt, qv) - self.B.values[k] = buoyancy_c(self.Ref.alpha0[k], alpha) + self.B.values[k] = buoyancy_c(self.Ref.alpha0_c[k], alpha) return From 2a02d9ee7ed2e150a9dec9e1e32a2cd5a4bf8fb1 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Wed, 12 Sep 2018 18:14:49 -0700 Subject: [PATCH 073/136] .. --- turbulence_functions.pyx | 1 + 1 file changed, 1 insertion(+) diff --git a/turbulence_functions.pyx b/turbulence_functions.pyx index 9665e2ba..f685b0a8 100644 --- a/turbulence_functions.pyx +++ b/turbulence_functions.pyx @@ -29,6 +29,7 @@ cdef entr_struct entr_detr_inverse_w(entr_in_struct entr_in) nogil: entr_struct _ret eps_w = 1.0/(fmax(fabs(entr_in.w),1.0)* 500) + #eps_w = 0.12*fabs(entr_in.b) / fmax(entr_in.w * entr_in.w, 1.0) if entr_in.af>0.0: partiation_func = entr_detr_buoyancy_sorting(entr_in) _ret.entr_sc = partiation_func*eps_w/2.0 From a5a743e6566566fab8139c075f3ec0581b7b9b28 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Thu, 13 Sep 2018 18:27:52 -0700 Subject: [PATCH 074/136] change cov_massflux to interdomain --- EDMF_Environment.pxd | 2 +- EDMF_Environment.pyx | 2 +- Turbulence_PrognosticTKE.pxd | 2 +- Turbulence_PrognosticTKE.pyx | 32 +++++++++++++++----------------- 4 files changed, 18 insertions(+), 20 deletions(-) diff --git a/EDMF_Environment.pxd b/EDMF_Environment.pxd index fa5b4e5a..db89f941 100644 --- a/EDMF_Environment.pxd +++ b/EDMF_Environment.pxd @@ -23,7 +23,7 @@ cdef class EnvironmentVariable_2m: double [:] detr_loss double [:] press double [:] buoy - double [:] massflux + double [:] interdomain double [:] rain_src str loc str kind diff --git a/EDMF_Environment.pyx b/EDMF_Environment.pyx index 4a3a7102..4d2f28ae 100644 --- a/EDMF_Environment.pyx +++ b/EDMF_Environment.pyx @@ -39,7 +39,7 @@ cdef class EnvironmentVariable_2m: self.buoy = np.zeros((nz,),dtype=np.double, order='c') self.press = np.zeros((nz,),dtype=np.double, order='c') self.shear = np.zeros((nz,),dtype=np.double, order='c') - self.massflux = np.zeros((nz,),dtype=np.double, order='c') + self.interdomain = np.zeros((nz,),dtype=np.double, order='c') self.rain_src = np.zeros((nz,),dtype=np.double, order='c') if loc != 'half': print('Invalid location setting for variable! Must be half') diff --git a/Turbulence_PrognosticTKE.pxd b/Turbulence_PrognosticTKE.pxd index 96c0c5b3..3416bd33 100644 --- a/Turbulence_PrognosticTKE.pxd +++ b/Turbulence_PrognosticTKE.pxd @@ -113,7 +113,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): EDMF_Updrafts.UpdraftVariable UpdVar2, EDMF_Environment.EnvironmentVariable EnvVar1, EDMF_Environment.EnvironmentVariable EnvVar2) cdef void compute_covariance_dissipation(self, EDMF_Environment.EnvironmentVariable_2m Covar) cdef void compute_covariance_shear(self,GridMeanVariables GMV, EDMF_Environment.EnvironmentVariable_2m Covar, double *UpdVar1, double *UpdVar2, double *EnvVar1, double *EnvVar2) - cdef void compute_covariance_massflux(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable phi_u, EDMF_Updrafts.UpdraftVariable psi_u, + cdef void compute_covariance_interdomain_src(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable phi_u, EDMF_Updrafts.UpdraftVariable psi_u, EDMF_Environment.EnvironmentVariable phi_e, EDMF_Environment.EnvironmentVariable psi_e, EDMF_Environment.EnvironmentVariable_2m covar_e) cdef void update_covariance_ED(self, GridMeanVariables GMV, CasesBase Case,TimeStepping TS, VariablePrognostic GmvVar1, VariablePrognostic GmvVar2, VariableDiagnostic GmvCovar, EDMF_Environment.EnvironmentVariable_2m Covar, EDMF_Environment.EnvironmentVariable EnvVar1, EDMF_Environment.EnvironmentVariable EnvVar2, diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index c7323819..0c1350ba 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -164,8 +164,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.massflux_qt = np.zeros((Gr.nzg,),dtype=np.double,order='c') self.diffusive_flux_h = np.zeros((Gr.nzg,),dtype=np.double,order='c') self.diffusive_flux_qt = np.zeros((Gr.nzg,),dtype=np.double,order='c') - if self.calc_tke: - self.massflux_tke = np.zeros((Gr.nzg,),dtype=np.double,order='c') return @@ -205,7 +203,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Stats.add_profile('tke_detr_loss') Stats.add_profile('tke_shear') Stats.add_profile('tke_pressure') - Stats.add_profile('tke_massflux') + Stats.add_profile('tke_interdomain') if self.calc_scalar_var: Stats.add_profile('Hvar_dissipation') @@ -223,9 +221,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Stats.add_profile('Hvar_rain') Stats.add_profile('QTvar_rain') Stats.add_profile('HQTcov_rain') - Stats.add_profile('Hvar_massflux') - Stats.add_profile('QTvar_massflux') - Stats.add_profile('HQTcov_massflux') + Stats.add_profile('Hvar_interdomain') + Stats.add_profile('QTvar_interdomain') + Stats.add_profile('HQTcov_interdomain') return @@ -284,7 +282,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Stats.write_profile('tke_shear', self.EnvVar.TKE.shear[kmin:kmax]) Stats.write_profile('tke_buoy', self.EnvVar.TKE.buoy[kmin:kmax]) Stats.write_profile('tke_pressure', self.EnvVar.TKE.press[kmin:kmax]) - Stats.write_profile('tke_massflux', self.EnvVar.TKE.massflux[kmin:kmax]) + Stats.write_profile('tke_interdomain', self.EnvVar.TKE.interdomain[kmin:kmax]) if self.calc_scalar_var: self.compute_covariance_dissipation(self.EnvVar.Hvar) @@ -308,9 +306,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Stats.write_profile('Hvar_rain', self.EnvVar.Hvar.rain_src[kmin:kmax]) Stats.write_profile('QTvar_rain', self.EnvVar.QTvar.rain_src[kmin:kmax]) Stats.write_profile('HQTcov_rain', self.EnvVar.HQTcov.rain_src[kmin:kmax]) - Stats.write_profile('Hvar_massflux', self.EnvVar.Hvar.massflux[kmin:kmax]) - Stats.write_profile('QTvar_massflux', self.EnvVar.QTvar.massflux[kmin:kmax]) - Stats.write_profile('HQTcov_massflux', self.EnvVar.HQTcov.massflux[kmin:kmax]) + Stats.write_profile('Hvar_interdomain', self.EnvVar.Hvar.interdomain[kmin:kmax]) + Stats.write_profile('QTvar_interdomain', self.EnvVar.QTvar.interdomain[kmin:kmax]) + Stats.write_profile('HQTcov_interdomain', self.EnvVar.HQTcov.interdomain[kmin:kmax]) # Perform the update of the scheme @@ -1164,7 +1162,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.compute_tke_buoy(GMV) self.compute_covariance_entr(self.EnvVar.TKE, self.UpdVar.W, self.UpdVar.W, self.EnvVar.W, self.EnvVar.W) self.compute_covariance_shear(GMV, self.EnvVar.TKE, &self.UpdVar.W.values[0,0], &self.UpdVar.W.values[0,0], &self.EnvVar.W.values[0], &self.EnvVar.W.values[0]) - self.compute_covariance_massflux(self.UpdVar.Area,self.UpdVar.W,self.UpdVar.W,self.EnvVar.W, self.EnvVar.W, self.EnvVar.TKE) + self.compute_covariance_interdomain_src(self.UpdVar.Area,self.UpdVar.W,self.UpdVar.W,self.EnvVar.W, self.EnvVar.W, self.EnvVar.TKE) self.compute_tke_pressure() if self.calc_scalar_var: self.compute_covariance_entr(self.EnvVar.Hvar, self.UpdVar.H, self.UpdVar.H, self.EnvVar.H, self.EnvVar.H) @@ -1173,9 +1171,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.compute_covariance_shear(GMV, self.EnvVar.Hvar, &self.UpdVar.H.values[0,0], &self.UpdVar.H.values[0,0], &self.EnvVar.H.values[0], &self.EnvVar.H.values[0]) self.compute_covariance_shear(GMV, self.EnvVar.QTvar, &self.UpdVar.QT.values[0,0], &self.UpdVar.QT.values[0,0], &self.EnvVar.QT.values[0], &self.EnvVar.QT.values[0]) self.compute_covariance_shear(GMV, self.EnvVar.HQTcov, &self.UpdVar.H.values[0,0], &self.UpdVar.QT.values[0,0], &self.EnvVar.H.values[0], &self.EnvVar.QT.values[0]) - self.compute_covariance_massflux(self.UpdVar.Area,self.UpdVar.H,self.UpdVar.H,self.EnvVar.H, self.EnvVar.H, self.EnvVar.Hvar) - self.compute_covariance_massflux(self.UpdVar.Area,self.UpdVar.QT,self.UpdVar.QT,self.EnvVar.QT, self.EnvVar.QT, self.EnvVar.QTvar) - self.compute_covariance_massflux(self.UpdVar.Area,self.UpdVar.H,self.UpdVar.QT,self.EnvVar.H, self.EnvVar.QT, self.EnvVar.HQTcov) + self.compute_covariance_interdomain_src(self.UpdVar.Area,self.UpdVar.H,self.UpdVar.H,self.EnvVar.H, self.EnvVar.H, self.EnvVar.Hvar) + self.compute_covariance_interdomain_src(self.UpdVar.Area,self.UpdVar.QT,self.UpdVar.QT,self.EnvVar.QT, self.EnvVar.QT, self.EnvVar.QTvar) + self.compute_covariance_interdomain_src(self.UpdVar.Area,self.UpdVar.H,self.UpdVar.QT,self.EnvVar.H, self.EnvVar.QT, self.EnvVar.HQTcov) self.compute_covariance_rain(TS, GMV) # need to update this one self.reset_surface_covariance(GMV, Case) @@ -1280,7 +1278,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): (diff_var1*diff_var2 + pow(du,2.0) + pow(dv,2.0))) return - cdef void compute_covariance_massflux(self, EDMF_Updrafts.UpdraftVariable au, + cdef void compute_covariance_interdomain_src(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable phi_u, EDMF_Updrafts.UpdraftVariable psi_u, EDMF_Environment.EnvironmentVariable phi_e, EDMF_Environment.EnvironmentVariable psi_e, EDMF_Environment.EnvironmentVariable_2m Covar): @@ -1295,11 +1293,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(self.Gr.nzg): - Covar.massflux[k] = 0.0 + Covar.interdomain[k] = 0.0 for i in xrange(self.n_updrafts): phi_diff = phi_u.values[i,k]-phi_e.values[k] psi_diff = psi_u.values[i,k]-psi_e.values[k] - Covar.massflux[k] += tke_factor*au.values[i,k] * (1.0-au.values[i,k]) * phi_diff * psi_diff + Covar.interdomain[k] += tke_factor*au.values[i,k] * (1.0-au.values[i,k]) * phi_diff * psi_diff return cdef void compute_covariance_dissipation(self, EDMF_Environment.EnvironmentVariable_2m Covar): From ff0f03f69309db658d36d7f04c1c3aed354c68fa Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Thu, 13 Sep 2018 19:03:15 -0700 Subject: [PATCH 075/136] change cov_massflux to interdomain --- generate_paramlist.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/generate_paramlist.py b/generate_paramlist.py index fad7d5e6..3a0f9769 100644 --- a/generate_paramlist.py +++ b/generate_paramlist.py @@ -235,7 +235,7 @@ def ARM_SGP(): def GATE_III(): paramlist = {} paramlist['meta'] = {} - paramlist['meta']['casename'] = 'TRMM_LBA' + paramlist['meta']['casename'] = 'GATE_III' paramlist['turbulence'] = {} paramlist['turbulence']['prandtl_number'] = 1.0 From 3affa455f2d47f4046c2c4e312abf017b665f958 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Fri, 14 Sep 2018 14:40:02 -0700 Subject: [PATCH 076/136] fix p_f and p_c in Surface bflux --- Surface.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Surface.pyx b/Surface.pyx index fe7b593c..eb76dae5 100644 --- a/Surface.pyx +++ b/Surface.pyx @@ -61,7 +61,7 @@ cdef class SurfaceFixedFlux(SurfaceBase): self.rho_hflux = rho_tflux / exner_c(self.Ref.Pg) elif GMV.H.name == 's': self.rho_hflux = entropy_flux(rho_tflux/self.Ref.rho0_f[gw-1],self.rho_qtflux/self.Ref.rho0_f[gw-1], - self.Ref.p0_f[gw], GMV.T.values[gw], GMV.QT.values[gw]) + self.Ref.p0_c[gw], GMV.T.values[gw], GMV.QT.values[gw]) self.bflux = buoyancy_flux(self.shf, self.lhf, GMV.T.values[gw], GMV.QT.values[gw],self.Ref.alpha0_f[gw-1] ) if not self.ustar_fixed: From 5d6c8b867a478d926cd60ec9f7fc60f93d3b1f55 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Mon, 17 Sep 2018 10:33:56 -0700 Subject: [PATCH 077/136] condition positive covariances only for TKE, Hvar and QTvar --- Turbulence_PrognosticTKE.pyx | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 0c1350ba..d3b04225 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -1424,7 +1424,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for kk in xrange(nz): k = kk + gw - Covar.values[k] = fmax(x[kk],0.0) + if Covar.name != 'HQTcov': + Covar.values[k] = fmax(x[kk],0.0) GmvCovar.values[k] = (ae[k] * (Covar.values[k] + (EnvVar1.values[k]-GmvVar1.values[k]) * (EnvVar2.values[k]-GmvVar2.values[k])) + self.UpdVar.Area.bulkvalues[k] * (UpdVar1.bulkvalues[k]-GmvVar1.values[k]) * (UpdVar2.bulkvalues[k]-GmvVar2.values[k])) From 8d469de997e3f20f8726ec2ec39210edbf9f9b71 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Mon, 17 Sep 2018 10:45:02 -0700 Subject: [PATCH 078/136] condition positive covariances only for TKE, Hvar and QTvar --- Turbulence_PrognosticTKE.pyx | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index d3b04225..2573e58a 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -1421,13 +1421,14 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): c[nz-1] = 0.0 tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) - with nogil: - for kk in xrange(nz): - k = kk + gw - if Covar.name != 'HQTcov': - Covar.values[k] = fmax(x[kk],0.0) + + for kk in xrange(nz): + k = kk + gw + if Covar.name != 'HQTcov': + Covar.values[k] = fmax(x[kk],0.0) + with nogil: GmvCovar.values[k] = (ae[k] * (Covar.values[k] + (EnvVar1.values[k]-GmvVar1.values[k]) * (EnvVar2.values[k]-GmvVar2.values[k])) - + self.UpdVar.Area.bulkvalues[k] * (UpdVar1.bulkvalues[k]-GmvVar1.values[k]) * (UpdVar2.bulkvalues[k]-GmvVar2.values[k])) + + self.UpdVar.Area.bulkvalues[k] * (UpdVar1.bulkvalues[k]-GmvVar1.values[k]) * (UpdVar2.bulkvalues[k]-GmvVar2.values[k])) self.get_GMV_CoVar(self.UpdVar.Area, UpdVar1, UpdVar2, EnvVar1, EnvVar2, Covar, &GmvVar1.values[0], &GmvVar2.values[0], &GmvCovar.values[0]) From 0775869bc86becef0beba2b4124aeeb79366ad89 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Mon, 17 Sep 2018 15:11:36 -0700 Subject: [PATCH 079/136] fixing problems in calling update_covariance for HQTcov with GMV.H only --- EDMF_Updrafts.pyx | 3 +++ Turbulence_PrognosticTKE.pyx | 12 ++++++++---- 2 files changed, 11 insertions(+), 4 deletions(-) diff --git a/EDMF_Updrafts.pyx b/EDMF_Updrafts.pyx index 87ad74bc..ec9e9cf2 100644 --- a/EDMF_Updrafts.pyx +++ b/EDMF_Updrafts.pyx @@ -178,6 +178,9 @@ cdef class UpdraftVariables: self.H.bulkvalues[k] += self.Area.values[i,k] * self.H.values[i,k]/self.Area.bulkvalues[k] self.T.bulkvalues[k] += self.Area.values[i,k] * self.T.values[i,k]/self.Area.bulkvalues[k] self.B.bulkvalues[k] += self.Area.values[i,k] * self.B.values[i,k]/self.Area.bulkvalues[k] + with gil: + if self.B.bulkvalues[k]>1.0: + print self.B.bulkvalues[k], self.B.values[i,k], self.Area.values[i,k], self.Area.bulkvalues[k] self.W.bulkvalues[k] += ((self.Area.values[i,k] + self.Area.values[i,k+1]) * self.W.values[i,k] /(self.Area.bulkvalues[k] + self.Area.bulkvalues[k+1])) else: diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 2573e58a..c62a5017 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -1131,7 +1131,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Py_ssize_t k double qv, alpha - with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): GMV.QL.values[k] = (self.UpdVar.Area.bulkvalues[k] * self.UpdVar.QL.bulkvalues[k] @@ -1182,7 +1181,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): if self.calc_scalar_var: self.update_covariance_ED(GMV, Case,TS, GMV.H, GMV.H, GMV.Hvar, self.EnvVar.Hvar, self.EnvVar.H, self.EnvVar.H, self.UpdVar.H, self.UpdVar.H) self.update_covariance_ED(GMV, Case,TS, GMV.QT,GMV.QT,GMV.QTvar, self.EnvVar.QTvar, self.EnvVar.QT, self.EnvVar.QT, self.UpdVar.QT, self.UpdVar.QT) - self.update_covariance_ED(GMV, Case,TS, GMV.H, GMV.H, GMV.HQTcov, self.EnvVar.HQTcov, self.EnvVar.H, self.EnvVar.QT, self.UpdVar.H, self.UpdVar.QT) + self.update_covariance_ED(GMV, Case,TS, GMV.H, GMV.QT, GMV.HQTcov, self.EnvVar.HQTcov, self.EnvVar.H, self.EnvVar.QT, self.UpdVar.H, self.UpdVar.QT) self.cleanup_covariance(GMV) @@ -1235,7 +1234,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): if self.calc_scalar_var: GMV.Hvar.values[self.Gr.gw] = get_surface_variance(flux1*alpha0LL,flux1*alpha0LL, ustar, zLL, oblength) GMV.QTvar.values[self.Gr.gw] = get_surface_variance(flux2*alpha0LL,flux2*alpha0LL, ustar, zLL, oblength) - GMV.HQTcov.values[self.Gr.gw] = get_surface_variance(flux1 * alpha0LL,flux2 * alpha0LL, ustar, zLL, oblength) + GMV.HQTcov.values[self.Gr.gw] = get_surface_variance(flux1*alpha0LL,flux2*alpha0LL, ustar, zLL, oblength) return cpdef cleanup_covariance(self, GridMeanVariables GMV): @@ -1248,10 +1247,15 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): GMV.Hvar.values[k] = 0.0 if GMV.QTvar.values[k] < tmp_eps: GMV.QTvar.values[k] = 0.0 + if fabs(GMV.HQTcov.values[k]) < tmp_eps: + GMV.HQTcov.values[k] = 0.0 if self.EnvVar.Hvar.values[k] < tmp_eps: self.EnvVar.Hvar.values[k] = 0.0 if self.EnvVar.QTvar.values[k] < tmp_eps: self.EnvVar.QTvar.values[k] = 0.0 + if fabs(self.EnvVar.HQTcov.values[k]) < tmp_eps: + self.EnvVar.HQTcov.values[k] = 0.0 + return @@ -1424,7 +1428,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for kk in xrange(nz): k = kk + gw - if Covar.name != 'HQTcov': + if Covar.name != 'thetal_qt_covar': Covar.values[k] = fmax(x[kk],0.0) with nogil: GmvCovar.values[k] = (ae[k] * (Covar.values[k] + (EnvVar1.values[k]-GmvVar1.values[k]) * (EnvVar2.values[k]-GmvVar2.values[k])) From 41eb4844c99d1a55875a71bd4b33a7b27de48b48 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Mon, 17 Sep 2018 17:10:37 -0700 Subject: [PATCH 080/136] factor 0.5 for TKE in calcualtion form GMV --- Turbulence_PrognosticTKE.pyx | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index c62a5017..bc388380 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -664,16 +664,19 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Py_ssize_t i,k double [:] ae = np.subtract(np.ones((self.Gr.nzg,),dtype=np.double, order='c'),au.bulkvalues) double phi_diff, psi_diff + double tke_factor = 1.0 + if covar_e.name == 'tke': + tke_factor = 0.5 with nogil: for k in xrange(self.Gr.nzg): phi_diff = phi_e.values[k]-gmv_phi[k] psi_diff = psi_e.values[k]-gmv_psi[k] - gmv_covar[k] = ae[k] * phi_diff * psi_diff + ae[k] * covar_e.values[k] + gmv_covar[k] = tke_factor * ae[k] * phi_diff * psi_diff + ae[k] * covar_e.values[k] for i in xrange(self.n_updrafts): phi_diff = phi_u.values[i,k]-gmv_phi[k] psi_diff = psi_u.values[i,k]-gmv_psi[k] - gmv_covar[k] += au.values[i,k] * phi_diff * psi_diff + gmv_covar[k] += tke_factor * au.values[i,k] * phi_diff * psi_diff return @@ -686,17 +689,20 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Py_ssize_t i,k double [:] ae = np.subtract(np.ones((self.Gr.nzg,),dtype=np.double, order='c'),au.bulkvalues) double phi_diff, psi_diff + double tke_factor = 1.0 + if covar_e.name == 'tke': + tke_factor = 0.5 with nogil: for k in xrange(self.Gr.nzg): if ae[k] > 0.0: phi_diff = phi_e.values[k] - gmv_phi[k] psi_diff = psi_e.values[k] - gmv_psi[k] - covar_e.values[k] = gmv_covar[k] - ae[k] * phi_diff * psi_diff + covar_e.values[k] = gmv_covar[k] - tke_factor * ae[k] * phi_diff * psi_diff for i in xrange(self.n_updrafts): phi_diff = phi_u.values[i,k] - gmv_phi[k] psi_diff = psi_u.values[i,k] - gmv_psi[k] - covar_e.values[k] -= au.values[i,k] * phi_diff * psi_diff + covar_e.values[k] -= tke_factor * au.values[i,k] * phi_diff * psi_diff covar_e.values[k] = covar_e.values[k]/ae[k] else: covar_e.values[k] = 0.0 From 10cbf58329af133141af63609148fb0cd657e273 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Tue, 18 Sep 2018 10:44:27 -0700 Subject: [PATCH 081/136] add bounds for theal_qt_covar in covariance_update --- Turbulence_PrognosticTKE.pyx | 9 ++++++--- utility_functions.pxd | 4 ++-- utility_functions.pyx | 4 +++- 3 files changed, 11 insertions(+), 6 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index bc388380..832ca588 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -1186,7 +1186,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.update_covariance_ED(GMV, Case,TS, GMV.W, GMV.W, GMV.TKE, self.EnvVar.TKE, self.EnvVar.W, self.EnvVar.W, self.UpdVar.W, self.UpdVar.W) if self.calc_scalar_var: self.update_covariance_ED(GMV, Case,TS, GMV.H, GMV.H, GMV.Hvar, self.EnvVar.Hvar, self.EnvVar.H, self.EnvVar.H, self.UpdVar.H, self.UpdVar.H) - self.update_covariance_ED(GMV, Case,TS, GMV.QT,GMV.QT,GMV.QTvar, self.EnvVar.QTvar, self.EnvVar.QT, self.EnvVar.QT, self.UpdVar.QT, self.UpdVar.QT) + self.update_covariance_ED(GMV, Case,TS, GMV.QT,GMV.QT, GMV.QTvar, self.EnvVar.QTvar, self.EnvVar.QT, self.EnvVar.QT, self.UpdVar.QT, self.UpdVar.QT) self.update_covariance_ED(GMV, Case,TS, GMV.H, GMV.QT, GMV.HQTcov, self.EnvVar.HQTcov, self.EnvVar.H, self.EnvVar.QT, self.UpdVar.H, self.UpdVar.QT) self.cleanup_covariance(GMV) @@ -1434,11 +1434,14 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for kk in xrange(nz): k = kk + gw - if Covar.name != 'thetal_qt_covar': + if Covar.name == 'thetal_qt_covar': + Covar.values[k] = fmax(x[kk], - sqrt(self.EnvVar.Hvar.values[k]*self.EnvVar.QTvar.values[k])) + Covar.values[k] = fmin(x[kk], sqrt(self.EnvVar.Hvar.values[k]*self.EnvVar.QTvar.values[k])) + else: Covar.values[k] = fmax(x[kk],0.0) with nogil: GmvCovar.values[k] = (ae[k] * (Covar.values[k] + (EnvVar1.values[k]-GmvVar1.values[k]) * (EnvVar2.values[k]-GmvVar2.values[k])) - + self.UpdVar.Area.bulkvalues[k] * (UpdVar1.bulkvalues[k]-GmvVar1.values[k]) * (UpdVar2.bulkvalues[k]-GmvVar2.values[k])) + + self.UpdVar.Area.bulkvalues[k] * (UpdVar1.bulkvalues[k]-GmvVar1.values[k]) * (UpdVar2.bulkvalues[k]-GmvVar2.values[k])) self.get_GMV_CoVar(self.UpdVar.Area, UpdVar1, UpdVar2, EnvVar1, EnvVar2, Covar, &GmvVar1.values[0], &GmvVar2.values[0], &GmvCovar.values[0]) diff --git a/utility_functions.pxd b/utility_functions.pxd index 1a2de24d..8c4a21d3 100644 --- a/utility_functions.pxd +++ b/utility_functions.pxd @@ -1,6 +1,6 @@ cdef double interp2pt(double val1, double val2) nogil cdef double logistic(double x, double slope, double mid) nogil -#cdef double smooth_minimum(double x1, double x2,double x3, double x4,double x5, double a) nogil -cdef double smooth_minimum(double x1, double x2 ,double x3, double a) nogil # +cdef double smooth_minimum(double x1, double x2 ,double x3, double a) nogil +cdef double smooth_maximum(double x1, double x2 ,double x3, double a) nogil cpdef double percentile_mean_norm(double percentile, Py_ssize_t nsamples) cpdef double percentile_bounds_mean_norm(double low_percentile, double high_percentile, Py_ssize_t nsamples) \ No newline at end of file diff --git a/utility_functions.pyx b/utility_functions.pyx index e59a549d..6cf61743 100644 --- a/utility_functions.pyx +++ b/utility_functions.pyx @@ -35,4 +35,6 @@ cdef double smooth_minimum(double x1, double x2,double x3,double a) nogil: smin = (x1*exp(-a*x1)+x2*exp(-a*x2)+x3*exp(-a*x3))/ (exp(-a*x1)+exp(-a*x2)+exp(-a*x3)) return smin - +cdef double smooth_maximum(double x1, double x2,double x3,double a) nogil: + smax = (x1*exp(a*x1)+x2*exp(a*x2)+x3*exp(a*x3))/(exp(a*x1)+exp(a*x2)+exp(a*x3)) + return smax From 8d8010349fa71424805852d681d9c2dbd87611dd Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Tue, 18 Sep 2018 10:53:25 -0700 Subject: [PATCH 082/136] add bounds for theal_qt_covar in covariance_update --- EDMF_Updrafts.pyx | 3 --- 1 file changed, 3 deletions(-) diff --git a/EDMF_Updrafts.pyx b/EDMF_Updrafts.pyx index ec9e9cf2..87ad74bc 100644 --- a/EDMF_Updrafts.pyx +++ b/EDMF_Updrafts.pyx @@ -178,9 +178,6 @@ cdef class UpdraftVariables: self.H.bulkvalues[k] += self.Area.values[i,k] * self.H.values[i,k]/self.Area.bulkvalues[k] self.T.bulkvalues[k] += self.Area.values[i,k] * self.T.values[i,k]/self.Area.bulkvalues[k] self.B.bulkvalues[k] += self.Area.values[i,k] * self.B.values[i,k]/self.Area.bulkvalues[k] - with gil: - if self.B.bulkvalues[k]>1.0: - print self.B.bulkvalues[k], self.B.values[i,k], self.Area.values[i,k], self.Area.bulkvalues[k] self.W.bulkvalues[k] += ((self.Area.values[i,k] + self.Area.values[i,k+1]) * self.W.values[i,k] /(self.Area.bulkvalues[k] + self.Area.bulkvalues[k+1])) else: From 523edba7c76aeb5a2c2ea2dea9b2aaeeae018557 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Tue, 18 Sep 2018 11:01:27 -0700 Subject: [PATCH 083/136] .. --- Turbulence_PrognosticTKE.pyx | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 832ca588..0f211aba 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -793,13 +793,14 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.W.new[i,gw] = (self.Ref.rho0_c[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * dti_ -adv + exch + buoy + press)/(self.Ref.rho0_c[gw] * self.UpdVar.Area.new[i,gw] * dti_) - #self.UpdVar.W.values[i,gw] = self.UpdVar.W.new[i,gw] + self.UpdVar.H.new[i,gw] = self.h_surface_bc[i] self.UpdVar.QT.new[i,gw] = self.qt_surface_bc[i] sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_c[gw], self.UpdVar.QT.new[i,gw], self.UpdVar.H.new[i,gw]) + print self.UpdVar.W.new[i,gw], self.UpdVar.B.values[i,gw], self.UpdVar.QT.new[i,gw], self.UpdVar.H.new[i,gw], sa.T, sa.ql self.UpdVar.QL.new[i,gw] = sa.ql self.UpdVar.T.new[i,gw] = sa.T self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0_c[gw], self.UpdVar.T.new[i,gw], From 61593a1d12b19ef9117696ab5ceb0e536a80f1a4 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Thu, 20 Sep 2018 18:01:17 -0700 Subject: [PATCH 084/136] checking for nans in Soares --- Turbulence_PrognosticTKE.pxd | 1 + Turbulence_PrognosticTKE.pyx | 110 ++++++++++++++++++++++++++++++----- 2 files changed, 98 insertions(+), 13 deletions(-) diff --git a/Turbulence_PrognosticTKE.pxd b/Turbulence_PrognosticTKE.pxd index 3416bd33..ac914474 100644 --- a/Turbulence_PrognosticTKE.pxd +++ b/Turbulence_PrognosticTKE.pxd @@ -133,4 +133,5 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): EDMF_Environment.EnvironmentVariable phi_e, EDMF_Environment.EnvironmentVariable psi_e, EDMF_Environment.EnvironmentVariable_2m covar_e, double *gmv_phi, double *gmv_psi, double *gmv_covar) + cpdef nan_check(self, line, GridMeanVariables GMV, int k) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 0f211aba..ebe45f11 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -23,6 +23,7 @@ from utility_functions cimport * from libc.math cimport fmax, sqrt, exp, pow, cbrt, fmin, fabs from cpython.mem cimport PyMem_Malloc, PyMem_Realloc, PyMem_Free import sys +import pylab as plt cdef class EDMF_PrognosticTKE(ParameterizationBase): # Initialize the class @@ -793,23 +794,35 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.W.new[i,gw] = (self.Ref.rho0_c[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * dti_ -adv + exch + buoy + press)/(self.Ref.rho0_c[gw] * self.UpdVar.Area.new[i,gw] * dti_) + # GMV.H.values[0] = GMV.H.values[3] + # GMV.H.values[1] = GMV.H.values[2] + # GMV.QT.values[0] = GMV.QT.values[3] + # GMV.QT.values[1] = GMV.QT.values[2] - + self.nan_check(798, GMV, 0) + self.nan_check(798, GMV, 1) + self.nan_check(798, GMV, gw) self.UpdVar.H.new[i,gw] = self.h_surface_bc[i] self.UpdVar.QT.new[i,gw] = self.qt_surface_bc[i] - + self.nan_check(801, GMV, gw) sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_c[gw], self.UpdVar.QT.new[i,gw], self.UpdVar.H.new[i,gw]) - print self.UpdVar.W.new[i,gw], self.UpdVar.B.values[i,gw], self.UpdVar.QT.new[i,gw], self.UpdVar.H.new[i,gw], sa.T, sa.ql + self.UpdVar.QL.new[i,gw] = sa.ql self.UpdVar.T.new[i,gw] = sa.T self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0_c[gw], self.UpdVar.T.new[i,gw], &self.UpdVar.QT.new[i,gw], &self.UpdVar.QL.new[i,gw], &self.UpdVar.QR.new[i,gw], &self.UpdVar.H.new[i,gw], i, gw) - + self.nan_check(811, GMV, gw) for k in range(gw+1, self.Gr.nzg-gw): + if self.UpdVar.QT.new[i,k] <=0: + print k, self.UpdVar.QT.new[i,k], self.UpdVar.QT.values[i,k] + plt.figure() + plt.show() + self.nan_check(813, GMV, k) self.upwind_integration(self.UpdVar.Area, self.UpdVar.Area, k, i, 1.0) + self.nan_check(815, GMV, k) if self.UpdVar.Area.new[i,k] > au_lim: self.UpdVar.Area.new[i,k] = au_lim entr_term = self.UpdVar.Area.values[i,k]*self.UpdVar.W.values[i,k]*self.entr_sc[i,k] @@ -818,24 +831,44 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): else: # this detrainment rate won't affect scalars but would affect velocity self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ - adv - entr_term)/(-au_lim * self.UpdVar.W.values[i,k])) + self.nan_check(822, GMV, k) + print 'self.detr_sc[i,k]', self.detr_sc[i,k], k + + + self.nan_check(828, GMV, k) if self.UpdVar.Area.new[i,k] >= self.minimum_area: self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, k, i, self.EnvVar.W.values[k]) + self.nan_check(831, GMV, k) + if self.UpdVar.W.new[i,k]<=0: + print 'clipping',k, self.UpdVar.W.new[i,k],self.UpdVar.Area.new[i,k] + self.UpdVar.W.new[i,k:]=0.0 + self.UpdVar.Area.new[i,k:]=0.0 + self.updraft_pressure_sink[i,k:] = 0.0 + break + + else: + self.nan_check(840, GMV, k) + self.UpdVar.W.new[i,k:] = 0.0 + self.UpdVar.Area.new[i,k:] = 0.0 + self.updraft_pressure_sink[i,k:] = 0.0 # keep this in mind if we modify updraft top treatment! + break + + if self.UpdVar.Area.new[i,k] >= self.minimum_area: + self.nan_check(847, GMV, k) self.upwind_integration(self.UpdVar.Area, self.UpdVar.H, k, i, self.EnvVar.H.values[k]) self.upwind_integration(self.UpdVar.Area, self.UpdVar.QT, k, i, self.EnvVar.QT.values[k]) else: - self.UpdVar.W.new[i,k] = 0.0 - self.UpdVar.Area.new[i,k] = 0.0 - self.updraft_pressure_sink[i,k] = 0.0 # keep this in mind if we modify updraft top treatment! - + self.nan_check(851, GMV, k) self.UpdVar.H.new[i,k] = GMV.H.values[k] self.UpdVar.QT.new[i,k] = GMV.QT.values[k] - + self.nan_check(854, GMV, k) sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_c[k], self.UpdVar.QT.new[i,k], self.UpdVar.H.new[i,k]) + self.nan_check(857, GMV, k) self.UpdVar.QL.new[i,k] = sa.ql self.UpdVar.T.new[i,k] = sa.T - + self.nan_check(861, GMV, k) if self.use_local_micro: self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0_c[k], self.UpdVar.T.new[i,k], &self.UpdVar.QT.new[i,k], &self.UpdVar.QL.new[i,k], @@ -872,8 +905,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): if var.name == 'w': buoy = self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] - press_buoy = -1.0 * self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] * self.pressure_buoy_coeff - press_drag = -1.0 * self.Ref.rho0_c[k]*(sqrt(self.UpdVar.Area.values[i,k] )*self.pressure_drag_coeff/self.pressure_plume_spacing + press_buoy = - self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] * self.pressure_buoy_coeff + press_drag = - self.Ref.rho0_c[k]*(sqrt(self.UpdVar.Area.values[i,k] )*self.pressure_drag_coeff/self.pressure_plume_spacing * (self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k])*fabs(self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k])) press = press_buoy + press_drag area_new = area.new[i,k] @@ -888,7 +921,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: if self.UpdVar.W.values[i,k]<0: - adv = (self.Ref.rho0_c[k+1] * area.values[i,k+1] * self.UpdVar.W.values[i,k+1] * var_kp + with gil: + print '========================== integrating downwards ==========================' + adv = (self.Ref.rho0_c[k+1] * area.values[i,k+1] * self.UpdVar.W.values[i,k+1] * var_kp - self.Ref.rho0_c[k] *area.values[i,k] * self.UpdVar.W.values[i,k] * var_k )* dzi exch = (self.Ref.rho0_c[k] * area.values[i,k] * self.UpdVar.W.values[i,k] * (-self.entr_sc[i,k] * env_var + self.detr_sc[i,k] * var_k )) @@ -961,6 +996,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): GMV.H.set_bcs(self.Gr) GMV.QT.set_bcs(self.Gr) + GMV.QR.set_bcs(self.Gr) GMV.U.set_bcs(self.Gr) GMV.V.set_bcs(self.Gr) @@ -1446,4 +1482,52 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.get_GMV_CoVar(self.UpdVar.Area, UpdVar1, UpdVar2, EnvVar1, EnvVar2, Covar, &GmvVar1.values[0], &GmvVar2.values[0], &GmvCovar.values[0]) + return + + cpdef nan_check(self, line, GridMeanVariables GMV, int k): + cdef: + double var + + var = np.sum(self.UpdVar.W.values[0,k])*np.sum(self.UpdVar.H.values[0,k])*np.sum(self.UpdVar.QT.values[0,k])*\ + np.sum(self.UpdVar.T.values[0,k])*np.sum(self.UpdVar.Area.values[0,k])*np.sum(self.UpdVar.QL.values[0,k])*\ + np.sum(self.EnvVar.T.values[k])*np.sum(self.EnvVar.QL.values[k])*\ + np.sum(self.EnvVar.W.values[k])*np.sum(self.EnvVar.H.values[k])*np.sum(self.EnvVar.QT.values[k])*\ + np.sum(GMV.W.values[k])*np.sum(GMV.H.values[k])*np.sum(GMV.QT.values[k])*\ + np.sum(GMV.T.values[k])*np.sum(GMV.QL.values)*\ + np.sum(self.UpdVar.W.new[0,k])*np.sum(self.UpdVar.H.new[0,k])*np.sum(self.UpdVar.QT.new[0,k])*\ + np.sum(self.UpdVar.T.new[0,k])*np.sum(self.UpdVar.Area.new[0,k])*np.sum(self.UpdVar.QL.new[0,k]) + + # var = np.sum(self.UpdVar.H.values)*np.sum(self.UpdVar.QT.values)*\ + # np.sum(self.UpdVar.T.values)*np.sum(self.UpdVar.Area.values)*np.sum(self.UpdVar.QL.values)*\ + # np.sum(self.UpdVar.W.new)*np.sum(self.UpdVar.H.new)*np.sum(self.UpdVar.QT.new)*\ + # np.sum(self.UpdVar.T.new)*np.sum(self.UpdVar.Area.new)*np.sum(self.UpdVar.QL.new) + + if np.isnan(var): + print 'nan check' + print line, k, var + print 'H ',self.UpdVar.H.new[0,k], self.UpdVar.H.values[0,k] + print 'QT ', self.UpdVar.QT.new[0,k],self.UpdVar.QT.values[0,k] + print 'T ', self.UpdVar.T.new[0,k], self.UpdVar.T.values[0,k] + print 'a ', self.UpdVar.Area.new[0,k], self.UpdVar.Area.values[0,k] + print 'QL ', self.UpdVar.QL.new[0,k], self.UpdVar.QL.values[0,k] + print 'W ',self.UpdVar.W.new[0,k], self.UpdVar.W.values[0,k] + print 'GMV.H ',GMV.H.new[k], GMV.H.values[k] + print 'GMV.QT ',GMV.QT.new[k], GMV.QT.values[k] + print 'GMV.T ', GMV.T.values[k] + print 'GMV.QL ', GMV.QL.values[k] + print 'Env', self.EnvVar.T.values[k], self.EnvVar.QL.values[k], self.EnvVar.W.values[k] ,self.EnvVar.H.values[k] ,self.EnvVar.QT.values[k] + + plt.figure() + plt.show() + + if self.UpdVar.QT.new[0,k] <= 0: + print 'negative qt', line, k, self.UpdVar.QT.values[0,k] ,self.UpdVar.QT.new[0,k] + plt.figure() + plt.show() + if self.UpdVar.H.new[0,k] < 290 or self.UpdVar.H.new[0,k] > 320: + print 'wrong H', line, k, self.UpdVar.H.values[0,k] ,self.UpdVar.H.new[0,k] + plt.figure() + plt.show() + + return \ No newline at end of file From eecf8f17d1c5cf8afe09527c2f36a9e2fdef5e9c Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Fri, 21 Sep 2018 10:01:16 -0700 Subject: [PATCH 085/136] testing Soares cleanup needed --- Turbulence_PrognosticTKE.pyx | 52 ++++++++++++++++++++++++++++-------- 1 file changed, 41 insertions(+), 11 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index ebe45f11..51691544 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -24,6 +24,7 @@ from libc.math cimport fmax, sqrt, exp, pow, cbrt, fmin, fabs from cpython.mem cimport PyMem_Malloc, PyMem_Realloc, PyMem_Free import sys import pylab as plt +import netCDF4 as nc cdef class EDMF_PrognosticTKE(ParameterizationBase): # Initialize the class @@ -794,16 +795,41 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.W.new[i,gw] = (self.Ref.rho0_c[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * dti_ -adv + exch + buoy + press)/(self.Ref.rho0_c[gw] * self.UpdVar.Area.new[i,gw] * dti_) + self.UpdVar.H.new[i,gw] = self.h_surface_bc[i] + self.UpdVar.QT.new[i,gw] = self.qt_surface_bc[i] + + + # data = nc.Dataset('/Users/yaircohen/PycharmProjects/scampy/Output.Soares.0763a/stats/Stats.Soares.master.nc', 'r') + # w = np.multiply(data.groups['profiles'].variables['updraft_w'],1.0) + # H = np.multiply(data.groups['profiles'].variables['updraft_thetal'],1.0) + # QT = np.multiply(data.groups['profiles'].variables['updraft_qt'],1.0) + # a = np.multiply(data.groups['profiles'].variables['updraft_area'],1.0) + # t = np.multiply(data.groups['profiles'].variables['t'],1.0) + # + # if TS.t<=t[0]: + # self.UpdVar.H.new[i,gw] = self.h_surface_bc[i] + # self.UpdVar.QT.new[i,gw] = self.qt_surface_bc[i] + # + # + # else: + # self.UpdVar.W.new[i,gw] = (np.interp(TS.t, t, w[:,1])+np.interp(TS.t, t, w[:,2]))/2.0 + # self.UpdVar.H.new[i,gw] = np.interp(TS.t, t, H[:,1]) + # self.UpdVar.QT.new[i,gw] = np.interp(TS.t, t, QT[:,1]) + # self.UpdVar.Area.new[i,gw] = np.interp(TS.t, t, a[:,1]) + + #print TS.t, w[:,1], w[:,2], H[:,1], QT[:,1], a[:,1] + #print self.UpdVar.W.new[i,gw], self.UpdVar.H.new[i,gw],self.UpdVar.QT.new[i,gw] , self.UpdVar.Area.new[i,gw] + + # GMV.H.values[0] = GMV.H.values[3] # GMV.H.values[1] = GMV.H.values[2] # GMV.QT.values[0] = GMV.QT.values[3] # GMV.QT.values[1] = GMV.QT.values[2] - self.nan_check(798, GMV, 0) - self.nan_check(798, GMV, 1) - self.nan_check(798, GMV, gw) - self.UpdVar.H.new[i,gw] = self.h_surface_bc[i] - self.UpdVar.QT.new[i,gw] = self.qt_surface_bc[i] + #self.nan_check(798, GMV, 0) + #self.nan_check(798, GMV, 1) + #self.nan_check(798, GMV, gw) + self.nan_check(801, GMV, gw) sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_c[gw], self.UpdVar.QT.new[i,gw], self.UpdVar.H.new[i,gw]) @@ -854,14 +880,14 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): break if self.UpdVar.Area.new[i,k] >= self.minimum_area: - self.nan_check(847, GMV, k) self.upwind_integration(self.UpdVar.Area, self.UpdVar.H, k, i, self.EnvVar.H.values[k]) self.upwind_integration(self.UpdVar.Area, self.UpdVar.QT, k, i, self.EnvVar.QT.values[k]) - else: self.nan_check(851, GMV, k) + else: + self.UpdVar.H.new[i,k] = GMV.H.values[k] self.UpdVar.QT.new[i,k] = GMV.QT.values[k] - self.nan_check(854, GMV, k) + self.nan_check(854, GMV, k) sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_c[k], self.UpdVar.QT.new[i,k], self.UpdVar.H.new[i,k]) self.nan_check(857, GMV, k) @@ -913,6 +939,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): var_kp = var.values[i,k+1] var_k = var.values[i,k] var_km = var.values[i,k-1] + self.updraft_pressure_sink[i,k] = press elif var.name == 'thetal' or var.name == 'qt': area_new = area.new[i,k] var_kp = var.values[i,k+1] @@ -933,9 +960,12 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): exch = (self.Ref.rho0_c[k] * area.values[i,k] * self.UpdVar.W.values[i,k] * (self.entr_sc[i,k] * env_var - self.detr_sc[i,k] * var_k )) - self.updraft_pressure_sink[i,k] = press + var.new[i,k] = (self.Ref.rho0_c[k] * area.values[i,k] * var_k * dti_ -adv + exch + buoy + press)\ /(self.Ref.rho0_c[k] * area_new * dti_) + if var.name =='thetal': + print adv ,exch ,buoy ,press + #if var.new[i,k] <290 or var.new[i,k] >310: # After updating the updraft variables themselves: # 1. compute the mass fluxes (currently not stored as class members, probably will want to do this @@ -1520,11 +1550,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): plt.figure() plt.show() - if self.UpdVar.QT.new[0,k] <= 0: + if self.UpdVar.QT.new[0,k] < 0: print 'negative qt', line, k, self.UpdVar.QT.values[0,k] ,self.UpdVar.QT.new[0,k] plt.figure() plt.show() - if self.UpdVar.H.new[0,k] < 290 or self.UpdVar.H.new[0,k] > 320: + if self.UpdVar.H.new[0,k] < 290 or self.UpdVar.H.new[0,k] > 310: print 'wrong H', line, k, self.UpdVar.H.values[0,k] ,self.UpdVar.H.new[0,k] plt.figure() plt.show() From 8da0ce10d16f668b3106b915ef17776d7363c55f Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Fri, 21 Sep 2018 16:59:40 -0700 Subject: [PATCH 086/136] testing for fake_collocated --- Turbulence_PrognosticTKE.pyx | 24 ++++++++++++++++++++++-- 1 file changed, 22 insertions(+), 2 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 32b7389e..63e51335 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -20,7 +20,7 @@ from NetCDFIO cimport NetCDFIO_Stats from thermodynamic_functions cimport * from turbulence_functions cimport * from utility_functions cimport * -from libc.math cimport fmax, sqrt, exp, pow, cbrt, fmin +from libc.math cimport fmax, sqrt, exp, pow, cbrt, fmin, fabs from cpython.mem cimport PyMem_Malloc, PyMem_Realloc, PyMem_Free cdef class EDMF_PrognosticTKE(ParameterizationBase): @@ -899,7 +899,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double whalf_kp, whalf_k double a1, a2 # groupings of terms in area fraction discrete equation double au_lim - double anew_k, a_k, a_km, entr_w, detr_w, B_k, entr_term, detr_term, rho_ratio + double anew_k, a_k, a_km, entr_w, detr_w, B_k, entr_term, detr_term, rho_ratio, w_temp double adv, buoy, exch, press, press_buoy, press_drag # groupings of terms in velocity discrete equation with nogil: @@ -910,6 +910,22 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.Area.new[i,gw] = self.area_surface_bc[i] au_lim = self.area_surface_bc[i] * self.max_area_factor + a_k = interp2pt(self.UpdVar.Area.values[i,gw], self.UpdVar.Area.values[i,gw+1]) + entr_w = interp2pt(self.entr_sc[i,gw], self.entr_sc[i,gw+1]) + detr_w = interp2pt(self.detr_sc[i,gw], self.detr_sc[i,gw+1]) + B_k = interp2pt(self.UpdVar.B.values[i,gw], self.UpdVar.B.values[i,gw+1]) + adv = self.Ref.rho0[gw] * a_k * self.UpdVar.W.values[i,gw] * self.UpdVar.W.values[i,gw] * dzi + exch = (self.Ref.rho0[gw] * a_k * self.UpdVar.W.values[i,gw] + * (entr_w * self.EnvVar.W.values[gw] - detr_w * self.UpdVar.W.values[i,gw] )) + buoy= self.Ref.rho0[gw] * a_k * B_k + press_buoy = -1.0 * self.Ref.rho0[gw] * a_k * B_k * self.pressure_buoy_coeff + press_drag = -1.0 * self.Ref.rho0[gw] * a_k * (self.pressure_drag_coeff/self.pressure_plume_spacing + * (self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])**2.0/sqrt(a_k)) + press = press_buoy + press_drag + self.updraft_pressure_sink[i,gw] = press + w_temp= (self.Ref.rho0[gw] * a_k * self.UpdVar.W.values[i,gw] * dti_ + -adv + exch + buoy + press)/(self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * dti_) + for k in range(gw, self.Gr.nzg-gw): # First solve for updated area fraction at k+1 @@ -951,6 +967,10 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.updraft_pressure_sink[i,k] = press self.UpdVar.W.new[i,k] = (self.Ref.rho0[k] * a_k * self.UpdVar.W.values[i,k] * dti_ -adv + exch + buoy + press)/(self.Ref.rho0[k] * anew_k * dti_) + with gil: + if k==gw: + print self.UpdVar.W.new[i,k]/fmax(w_temp,0.001) + self.UpdVar.W.new[i,k] = w_temp*1.4 if self.UpdVar.W.new[i,k] <= 0.0: self.UpdVar.W.new[i,k:] = 0.0 From edbb227dad0f16725d3c96571e9d305ac9f038a9 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Fri, 21 Sep 2018 17:34:15 -0700 Subject: [PATCH 087/136] collocated that runs soares --- Turbulence_PrognosticTKE.pyx | 36 +++++++++++++++++++++++------------- 1 file changed, 23 insertions(+), 13 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 63e51335..b94e4c0e 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -899,8 +899,10 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double whalf_kp, whalf_k double a1, a2 # groupings of terms in area fraction discrete equation double au_lim - double anew_k, a_k, a_km, entr_w, detr_w, B_k, entr_term, detr_term, rho_ratio, w_temp + double anew_k, a_k, a_km, entr_w, detr_w, B_k, entr_term, detr_term, rho_ratio, w_temp, whalf_k_env double adv, buoy, exch, press, press_buoy, press_drag # groupings of terms in velocity discrete equation + double [:] w_new = np.zeros((self.Gr.nzg,), dtype=np.double, order='c') + with nogil: for i in xrange(self.n_updrafts): @@ -931,6 +933,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # First solve for updated area fraction at k+1 whalf_kp = interp2pt(self.UpdVar.W.values[i,k], self.UpdVar.W.values[i,k+1]) whalf_k = interp2pt(self.UpdVar.W.values[i,k-1], self.UpdVar.W.values[i,k]) + whalf_k_env = interp2pt(self.EnvVar.W.values[k-1], self.EnvVar.W.values[k]) adv = -self.Ref.alpha0_half[k+1] * dzi *( self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * whalf_kp -self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * whalf_k) entr_term = self.UpdVar.Area.values[i,k+1] * whalf_kp * (self.entr_sc[i,k+1] ) @@ -948,29 +951,36 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # Now solve for updraft velocity at k rho_ratio = self.Ref.rho0[k-1]/self.Ref.rho0[k] - anew_k = interp2pt(self.UpdVar.Area.new[i,k], self.UpdVar.Area.new[i,k+1]) + if TS.t/TS.dt ==1 and k==gw: + anew_k = interp2pt(self.UpdVar.Area.new[i,k], self.UpdVar.Area.new[i,k+1]) + with gil: + print 'setting anew' + else: + anew_k = self.UpdVar.Area.new[i,k+1] if anew_k >= self.minimum_area: - a_k = interp2pt(self.UpdVar.Area.values[i,k], self.UpdVar.Area.values[i,k+1]) - a_km = interp2pt(self.UpdVar.Area.values[i,k-1], self.UpdVar.Area.values[i,k]) - entr_w = interp2pt(self.entr_sc[i,k], self.entr_sc[i,k+1]) - detr_w = interp2pt(self.detr_sc[i,k], self.detr_sc[i,k+1]) - B_k = interp2pt(self.UpdVar.B.values[i,k], self.UpdVar.B.values[i,k+1]) - adv = (self.Ref.rho0[k] * a_k * self.UpdVar.W.values[i,k] * self.UpdVar.W.values[i,k] * dzi - - self.Ref.rho0[k-1] * a_km * self.UpdVar.W.values[i,k-1] * self.UpdVar.W.values[i,k-1] * dzi) + entr_w = self.entr_sc[i,k+1] + detr_w = self.detr_sc[i,k+1] + a_k = self.UpdVar.Area.values[i,k+1] + a_km = self.UpdVar.Area.values[i,k] + B_k = self.UpdVar.B.values[i,k+1] + adv = (self.Ref.rho0[k] * a_k * whalf_kp * whalf_kp * dzi + - self.Ref.rho0[k-1] * a_km * whalf_k*whalf_k * dzi) exch = (self.Ref.rho0[k] * a_k * self.UpdVar.W.values[i,k] - * (entr_w * self.EnvVar.W.values[k] - detr_w * self.UpdVar.W.values[i,k] )) + * (entr_w * whalf_k_env - detr_w * whalf_k )) buoy= self.Ref.rho0[k] * a_k * B_k press_buoy = -1.0 * self.Ref.rho0[k] * a_k * B_k * self.pressure_buoy_coeff press_drag = -1.0 * self.Ref.rho0[k] * a_k * (self.pressure_drag_coeff/self.pressure_plume_spacing - * (self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k])**2.0/sqrt(fmax(a_k,self.minimum_area))) + * (whalf_k -whalf_k_env )**2.0/sqrt(fmax(a_k,self.minimum_area))) press = press_buoy + press_drag self.updraft_pressure_sink[i,k] = press - self.UpdVar.W.new[i,k] = (self.Ref.rho0[k] * a_k * self.UpdVar.W.values[i,k] * dti_ + w_new[k+1] = (self.Ref.rho0[k] * a_k * self.UpdVar.W.values[i,k] * dti_ -adv + exch + buoy + press)/(self.Ref.rho0[k] * anew_k * dti_) + + self.UpdVar.W.new[i,k] =interp2pt(w_new[k+1],w_new[k]) with gil: if k==gw: print self.UpdVar.W.new[i,k]/fmax(w_temp,0.001) - self.UpdVar.W.new[i,k] = w_temp*1.4 + self.UpdVar.W.new[i,k] = w_temp/1.4 if self.UpdVar.W.new[i,k] <= 0.0: self.UpdVar.W.new[i,k:] = 0.0 From c7e6c786c83bf73e63d27a5a2deddbd6194b5662 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Fri, 21 Sep 2018 17:38:59 -0700 Subject: [PATCH 088/136] .. --- Turbulence_PrognosticTKE.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index b94e4c0e..6993c2ec 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -980,7 +980,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with gil: if k==gw: print self.UpdVar.W.new[i,k]/fmax(w_temp,0.001) - self.UpdVar.W.new[i,k] = w_temp/1.4 + self.UpdVar.W.new[i,k] = w_temp if self.UpdVar.W.new[i,k] <= 0.0: self.UpdVar.W.new[i,k:] = 0.0 From c1ab2d2097b3237a128626356cf1245b25d6d5b9 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Fri, 21 Sep 2018 18:24:38 -0700 Subject: [PATCH 089/136] .. --- Turbulence_PrognosticTKE.pyx | 56 +++++++++--------------------------- 1 file changed, 14 insertions(+), 42 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 51691544..05d5f872 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -826,11 +826,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # GMV.QT.values[0] = GMV.QT.values[3] # GMV.QT.values[1] = GMV.QT.values[2] - #self.nan_check(798, GMV, 0) - #self.nan_check(798, GMV, 1) - #self.nan_check(798, GMV, gw) - - self.nan_check(801, GMV, gw) sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_c[gw], self.UpdVar.QT.new[i,gw], self.UpdVar.H.new[i,gw]) @@ -840,31 +835,10 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): &self.UpdVar.QT.new[i,gw], &self.UpdVar.QL.new[i,gw], &self.UpdVar.QR.new[i,gw], &self.UpdVar.H.new[i,gw], i, gw) - self.nan_check(811, GMV, gw) for k in range(gw+1, self.Gr.nzg-gw): - if self.UpdVar.QT.new[i,k] <=0: - print k, self.UpdVar.QT.new[i,k], self.UpdVar.QT.values[i,k] - plt.figure() - plt.show() - self.nan_check(813, GMV, k) self.upwind_integration(self.UpdVar.Area, self.UpdVar.Area, k, i, 1.0) - self.nan_check(815, GMV, k) - if self.UpdVar.Area.new[i,k] > au_lim: - self.UpdVar.Area.new[i,k] = au_lim - entr_term = self.UpdVar.Area.values[i,k]*self.UpdVar.W.values[i,k]*self.entr_sc[i,k] - if self.UpdVar.Area.values[i,k] > 0.0: - self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ - adv - entr_term)/(-self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k])) - else: - # this detrainment rate won't affect scalars but would affect velocity - self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ - adv - entr_term)/(-au_lim * self.UpdVar.W.values[i,k])) - self.nan_check(822, GMV, k) - print 'self.detr_sc[i,k]', self.detr_sc[i,k], k - - - self.nan_check(828, GMV, k) if self.UpdVar.Area.new[i,k] >= self.minimum_area: self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, k, i, self.EnvVar.W.values[k]) - self.nan_check(831, GMV, k) if self.UpdVar.W.new[i,k]<=0: print 'clipping',k, self.UpdVar.W.new[i,k],self.UpdVar.Area.new[i,k] self.UpdVar.W.new[i,k:]=0.0 @@ -873,7 +847,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): break else: - self.nan_check(840, GMV, k) self.UpdVar.W.new[i,k:] = 0.0 self.UpdVar.Area.new[i,k:] = 0.0 self.updraft_pressure_sink[i,k:] = 0.0 # keep this in mind if we modify updraft top treatment! @@ -882,19 +855,16 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): if self.UpdVar.Area.new[i,k] >= self.minimum_area: self.upwind_integration(self.UpdVar.Area, self.UpdVar.H, k, i, self.EnvVar.H.values[k]) self.upwind_integration(self.UpdVar.Area, self.UpdVar.QT, k, i, self.EnvVar.QT.values[k]) - self.nan_check(851, GMV, k) else: self.UpdVar.H.new[i,k] = GMV.H.values[k] self.UpdVar.QT.new[i,k] = GMV.QT.values[k] - self.nan_check(854, GMV, k) + sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_c[k], self.UpdVar.QT.new[i,k], self.UpdVar.H.new[i,k]) - self.nan_check(857, GMV, k) self.UpdVar.QL.new[i,k] = sa.ql self.UpdVar.T.new[i,k] = sa.T - self.nan_check(861, GMV, k) if self.use_local_micro: self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0_c[k], self.UpdVar.T.new[i,k], &self.UpdVar.QT.new[i,k], &self.UpdVar.QL.new[i,k], @@ -921,7 +891,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cdef: double dzi = self.Gr.dzi double dti_ = 1.0/self.dt_upd - double adv, exch, press_buoy, press_drag + double adv, exch, press_buoy, press_drag, au_lim, entr_term double buoy = 0.0 double press = 0.0 double var_kp = 1.0 @@ -963,16 +933,18 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): var.new[i,k] = (self.Ref.rho0_c[k] * area.values[i,k] * var_k * dti_ -adv + exch + buoy + press)\ /(self.Ref.rho0_c[k] * area_new * dti_) - if var.name =='thetal': - print adv ,exch ,buoy ,press - #if var.new[i,k] <290 or var.new[i,k] >310: - - # After updating the updraft variables themselves: - # 1. compute the mass fluxes (currently not stored as class members, probably will want to do this - # for output purposes) - # 2. Apply mass flux tendencies and updraft microphysical tendencies to GMV.SomeVar.Values (old time step values) - # thereby updating to GMV.SomeVar.mf_update - # mass flux tendency is computed as 1st order upwind + + if var.name =='area_fraction': + with nogil: + au_lim = self.area_surface_bc[i] * self.max_area_factor + if var.new[i,k] > au_lim: + var.new[i,k] = au_lim + entr_term = var.values[i,k]*self.UpdVar.W.values[i,k]*self.entr_sc[i,k] + if var.values[i,k] > 0.0: + self.detr_sc[i,k] = (((au_lim-var.values[i,k])* dti_ - adv - entr_term)/(-var.values[i,k] * self.UpdVar.W.values[i,k])) + else: + self.detr_sc[i,k] = (((au_lim-var.values[i,k])* dti_ - adv - entr_term)/(-au_lim * self.UpdVar.W.values[i,k])) + cpdef update_GMV_MF(self, GridMeanVariables GMV, TimeStepping TS): cdef: From c4b5df915e3133a01366cff4b639de92cda07e38 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Fri, 21 Sep 2018 21:34:25 -0700 Subject: [PATCH 090/136] calcualte w[gw] with the upwind function --- Turbulence_PrognosticTKE.pxd | 2 +- Turbulence_PrognosticTKE.pyx | 57 +++++++----------------------------- 2 files changed, 11 insertions(+), 48 deletions(-) diff --git a/Turbulence_PrognosticTKE.pxd b/Turbulence_PrognosticTKE.pxd index ac914474..315b59f3 100644 --- a/Turbulence_PrognosticTKE.pxd +++ b/Turbulence_PrognosticTKE.pxd @@ -100,7 +100,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cpdef compute_entrainment_detrainment(self, GridMeanVariables GMV, CasesBase Case) cpdef solve_updraft(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS) cpdef upwind_integration(self, EDMF_Updrafts.UpdraftVariable area, - EDMF_Updrafts.UpdraftVariable var, int k, int i, double env_var) + EDMF_Updrafts.UpdraftVariable var, int k, int i, double env_var, double dzi) cpdef update_GMV_MF(self, GridMeanVariables GMV, TimeStepping TS) cpdef update_GMV_ED(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS) cpdef compute_covariance(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 05d5f872..052b7354 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -772,7 +772,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double dti_ = 1.0/self.dt_upd double dt_ = 1.0/dti_ double a1, a2 # groupings of terms in area fraction discrete equation - double au_lim, sgn_w, adv_up, adv_dw, m_km, m_k, m_kp + double au_lim, sgn_w, adv_up, adv_dw, m_km, m_k, m_kp, a_k, entr_w, detr_w, B_k, w_temp, wf_upd, wf_env double adv, buoy, exch, press, press_buoy, press_drag, entr_term # groupings of terms in velocity discrete equation eos_struct sa double qt_var, h_var @@ -783,48 +783,10 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.detr_sc[i,gw] = 0.0 self.UpdVar.Area.new[i,gw] = self.area_surface_bc[i] au_lim = self.area_surface_bc[i] * self.max_area_factor - - adv = (self.Ref.rho0_c[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * self.UpdVar.W.values[i,gw] * dzi*2.0) - exch = (self.Ref.rho0_c[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] - * (self.entr_sc[i,gw] * self.EnvVar.W.values[gw] - self.detr_sc[i,gw] * self.UpdVar.W.values[i,gw] )) - buoy= self.Ref.rho0_c[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.B.values[i,gw] - press_buoy = -1.0 * self.Ref.rho0_c[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.B.values[i,gw] * self.pressure_buoy_coeff - press_drag = -1.0 * self.Ref.rho0_c[gw]*sqrt(self.UpdVar.Area.values[i,gw])*self.pressure_drag_coeff/self.pressure_plume_spacing \ - * (self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])*fabs(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw]) - press = press_buoy + press_drag - self.UpdVar.W.new[i,gw] = (self.Ref.rho0_c[gw] * self.UpdVar.Area.values[i,gw] * self.UpdVar.W.values[i,gw] * dti_ - -adv + exch + buoy + press)/(self.Ref.rho0_c[gw] * self.UpdVar.Area.new[i,gw] * dti_) - self.UpdVar.H.new[i,gw] = self.h_surface_bc[i] self.UpdVar.QT.new[i,gw] = self.qt_surface_bc[i] - - - # data = nc.Dataset('/Users/yaircohen/PycharmProjects/scampy/Output.Soares.0763a/stats/Stats.Soares.master.nc', 'r') - # w = np.multiply(data.groups['profiles'].variables['updraft_w'],1.0) - # H = np.multiply(data.groups['profiles'].variables['updraft_thetal'],1.0) - # QT = np.multiply(data.groups['profiles'].variables['updraft_qt'],1.0) - # a = np.multiply(data.groups['profiles'].variables['updraft_area'],1.0) - # t = np.multiply(data.groups['profiles'].variables['t'],1.0) - # - # if TS.t<=t[0]: - # self.UpdVar.H.new[i,gw] = self.h_surface_bc[i] - # self.UpdVar.QT.new[i,gw] = self.qt_surface_bc[i] - # - # - # else: - # self.UpdVar.W.new[i,gw] = (np.interp(TS.t, t, w[:,1])+np.interp(TS.t, t, w[:,2]))/2.0 - # self.UpdVar.H.new[i,gw] = np.interp(TS.t, t, H[:,1]) - # self.UpdVar.QT.new[i,gw] = np.interp(TS.t, t, QT[:,1]) - # self.UpdVar.Area.new[i,gw] = np.interp(TS.t, t, a[:,1]) - - #print TS.t, w[:,1], w[:,2], H[:,1], QT[:,1], a[:,1] - #print self.UpdVar.W.new[i,gw], self.UpdVar.H.new[i,gw],self.UpdVar.QT.new[i,gw] , self.UpdVar.Area.new[i,gw] - - - # GMV.H.values[0] = GMV.H.values[3] - # GMV.H.values[1] = GMV.H.values[2] - # GMV.QT.values[0] = GMV.QT.values[3] - # GMV.QT.values[1] = GMV.QT.values[2] + self.UpdVar.W.new[i,gw-1] = 0.0 + self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, gw, i, self.EnvVar.W.values[gw], 2.0 * dzi) sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_c[gw], self.UpdVar.QT.new[i,gw], self.UpdVar.H.new[i,gw]) @@ -835,10 +797,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): &self.UpdVar.QT.new[i,gw], &self.UpdVar.QL.new[i,gw], &self.UpdVar.QR.new[i,gw], &self.UpdVar.H.new[i,gw], i, gw) + print self.UpdVar.W.new[i,gw] for k in range(gw+1, self.Gr.nzg-gw): - self.upwind_integration(self.UpdVar.Area, self.UpdVar.Area, k, i, 1.0) + self.upwind_integration(self.UpdVar.Area, self.UpdVar.Area, k, i, 1.0, dzi) if self.UpdVar.Area.new[i,k] >= self.minimum_area: - self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, k, i, self.EnvVar.W.values[k]) + self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, k, i, self.EnvVar.W.values[k],dzi) if self.UpdVar.W.new[i,k]<=0: print 'clipping',k, self.UpdVar.W.new[i,k],self.UpdVar.Area.new[i,k] self.UpdVar.W.new[i,k:]=0.0 @@ -853,8 +816,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): break if self.UpdVar.Area.new[i,k] >= self.minimum_area: - self.upwind_integration(self.UpdVar.Area, self.UpdVar.H, k, i, self.EnvVar.H.values[k]) - self.upwind_integration(self.UpdVar.Area, self.UpdVar.QT, k, i, self.EnvVar.QT.values[k]) + self.upwind_integration(self.UpdVar.Area, self.UpdVar.H, k, i, self.EnvVar.H.values[k], dzi) + self.upwind_integration(self.UpdVar.Area, self.UpdVar.QT, k, i, self.EnvVar.QT.values[k], dzi) else: self.UpdVar.H.new[i,k] = GMV.H.values[k] @@ -887,9 +850,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): return - cpdef upwind_integration(self, EDMF_Updrafts.UpdraftVariable area, EDMF_Updrafts.UpdraftVariable var, int k, int i, double env_var): + cpdef upwind_integration(self, EDMF_Updrafts.UpdraftVariable area, EDMF_Updrafts.UpdraftVariable var, int k, int i, double env_var, double dzi): cdef: - double dzi = self.Gr.dzi + double dti_ = 1.0/self.dt_upd double adv, exch, press_buoy, press_drag, au_lim, entr_term double buoy = 0.0 From f15daf5ffaf4916d4c3207b44d4cfdcc5cba74e3 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Sat, 22 Sep 2018 10:42:46 -0700 Subject: [PATCH 091/136] .. --- Turbulence_PrognosticTKE.pyx | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 6993c2ec..c4dad3a5 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -906,7 +906,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for i in xrange(self.n_updrafts): - self.entr_sc[i,gw] = 2.0 * dzi + self.entr_sc[i,gw] = 4.0 * dzi self.detr_sc[i,gw] = 0.0 self.UpdVar.W.new[i,gw-1] = self.w_surface_bc[i] self.UpdVar.Area.new[i,gw] = self.area_surface_bc[i] @@ -927,7 +927,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.updraft_pressure_sink[i,gw] = press w_temp= (self.Ref.rho0[gw] * a_k * self.UpdVar.W.values[i,gw] * dti_ -adv + exch + buoy + press)/(self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * dti_) - + w_temp = 0.5 for k in range(gw, self.Gr.nzg-gw): # First solve for updated area fraction at k+1 @@ -980,7 +980,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with gil: if k==gw: print self.UpdVar.W.new[i,k]/fmax(w_temp,0.001) - self.UpdVar.W.new[i,k] = w_temp + self.UpdVar.W.new[i,k] = 1.4*w_temp if self.UpdVar.W.new[i,k] <= 0.0: self.UpdVar.W.new[i,k:] = 0.0 From 3e67532d01d52f71f4856b439ee344e078a35f99 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Sat, 22 Sep 2018 11:31:45 -0700 Subject: [PATCH 092/136] .. --- Turbulence_PrognosticTKE.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index c4dad3a5..33b191d2 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -927,7 +927,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.updraft_pressure_sink[i,gw] = press w_temp= (self.Ref.rho0[gw] * a_k * self.UpdVar.W.values[i,gw] * dti_ -adv + exch + buoy + press)/(self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * dti_) - w_temp = 0.5 + for k in range(gw, self.Gr.nzg-gw): # First solve for updated area fraction at k+1 From c2642956c08021123f898019cb1999f93f7c4fdc Mon Sep 17 00:00:00 2001 From: yairchn Date: Sat, 22 Sep 2018 13:49:39 -0700 Subject: [PATCH 093/136] merge with origin --- Cases.pyx | 1 + Turbulence_PrognosticTKE.pyx | 3 +++ 2 files changed, 4 insertions(+) diff --git a/Cases.pyx b/Cases.pyx index b19890b4..b5de54c2 100644 --- a/Cases.pyx +++ b/Cases.pyx @@ -12,6 +12,7 @@ from NetCDFIO cimport NetCDFIO_Stats from thermodynamic_functions cimport * import math as mt from libc.math cimport sqrt, log, fabs,atan, exp, fmax +import pylab as plt def CasesFactory(namelist, paramlist): if namelist['meta']['casename'] == 'Soares': diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index be243064..0759c40e 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -787,6 +787,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.QT.new[i,gw] = self.qt_surface_bc[i] self.UpdVar.W.new[i,gw-1] = 0.0 self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, gw, i, self.EnvVar.W.values[gw], 2.0 * dzi) + print self.UpdVar.W.new[i,gw] + plt.figure() + plt.show() sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_c[gw], self.UpdVar.QT.new[i,gw], self.UpdVar.H.new[i,gw]) From ce3ca64b9f6a7c4fb9edaa48733962eba9202a35 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Sat, 22 Sep 2018 14:56:38 -0700 Subject: [PATCH 094/136] adding the downward integration parts --- Turbulence_PrognosticTKE.pyx | 106 +++++++++++++++++++++++------------ 1 file changed, 71 insertions(+), 35 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 33b191d2..de8904c0 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -22,6 +22,7 @@ from turbulence_functions cimport * from utility_functions cimport * from libc.math cimport fmax, sqrt, exp, pow, cbrt, fmin, fabs from cpython.mem cimport PyMem_Malloc, PyMem_Realloc, PyMem_Free +import pylab as plt cdef class EDMF_PrognosticTKE(ParameterizationBase): # Initialize the class @@ -897,9 +898,10 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double dti_ = 1.0/self.dt_upd double dt_ = 1.0/dti_ double whalf_kp, whalf_k + double adv_up, adv_dw, whalf_kpp double a1, a2 # groupings of terms in area fraction discrete equation double au_lim - double anew_k, a_k, a_km, entr_w, detr_w, B_k, entr_term, detr_term, rho_ratio, w_temp, whalf_k_env + double a_k, a_km, entr_w, detr_w, B_k, entr_term, detr_term, rho_ratio, w_temp, whalf_k_env double adv, buoy, exch, press, press_buoy, press_drag # groupings of terms in velocity discrete equation double [:] w_new = np.zeros((self.Gr.nzg,), dtype=np.double, order='c') @@ -925,8 +927,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): * (self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])**2.0/sqrt(a_k)) press = press_buoy + press_drag self.updraft_pressure_sink[i,gw] = press - w_temp= (self.Ref.rho0[gw] * a_k * self.UpdVar.W.values[i,gw] * dti_ + self.UpdVar.W.new[i,gw] = (self.Ref.rho0[gw] * a_k * self.UpdVar.W.values[i,gw] * dti_ -adv + exch + buoy + press)/(self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * dti_) + self.UpdVar.W.values[i,gw] = self.UpdVar.W.new[i,gw] for k in range(gw, self.Gr.nzg-gw): @@ -934,11 +937,22 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): whalf_kp = interp2pt(self.UpdVar.W.values[i,k], self.UpdVar.W.values[i,k+1]) whalf_k = interp2pt(self.UpdVar.W.values[i,k-1], self.UpdVar.W.values[i,k]) whalf_k_env = interp2pt(self.EnvVar.W.values[k-1], self.EnvVar.W.values[k]) - adv = -self.Ref.alpha0_half[k+1] * dzi *( self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * whalf_kp - -self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * whalf_k) entr_term = self.UpdVar.Area.values[i,k+1] * whalf_kp * (self.entr_sc[i,k+1] ) detr_term = self.UpdVar.Area.values[i,k+1] * whalf_kp * (- self.detr_sc[i,k+1]) + adv = -self.Ref.alpha0_half[k+1] * dzi *( self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * whalf_kp + -self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * whalf_k) + if whalf_kp<0: + sgn_w = 0.0 + else: + sgn_w = 1.0 + #sgn_w = 1.0 + + adv_up = -self.Ref.alpha0_half[k+1] * dzi *( self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * whalf_kp + -self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * whalf_k) + adv_dw = -self.Ref.alpha0_half[k+1] * dzi *( self.Ref.rho0_half[k+2] * self.UpdVar.Area.values[i,k+2] * whalf_kpp + -self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * whalf_kp) + adv = sgn_w*adv_up + (1.0-sgn_w)*adv_dw self.UpdVar.Area.new[i,k+1] = fmax(dt_ * (adv + entr_term + detr_term) + self.UpdVar.Area.values[i,k+1], 0.0) if self.UpdVar.Area.new[i,k+1] > au_lim: @@ -951,41 +965,42 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # Now solve for updraft velocity at k rho_ratio = self.Ref.rho0[k-1]/self.Ref.rho0[k] - if TS.t/TS.dt ==1 and k==gw: - anew_k = interp2pt(self.UpdVar.Area.new[i,k], self.UpdVar.Area.new[i,k+1]) - with gil: - print 'setting anew' - else: - anew_k = self.UpdVar.Area.new[i,k+1] - if anew_k >= self.minimum_area: + + + if self.UpdVar.Area.new[i,k+1] >= self.minimum_area: entr_w = self.entr_sc[i,k+1] detr_w = self.detr_sc[i,k+1] a_k = self.UpdVar.Area.values[i,k+1] a_km = self.UpdVar.Area.values[i,k] B_k = self.UpdVar.B.values[i,k+1] - adv = (self.Ref.rho0[k] * a_k * whalf_kp * whalf_kp * dzi - - self.Ref.rho0[k-1] * a_km * whalf_k*whalf_k * dzi) - exch = (self.Ref.rho0[k] * a_k * self.UpdVar.W.values[i,k] + #adv = (self.Ref.rho0_half[k] * a_k * whalf_kp * whalf_kp * dzi + # - self.Ref.rho0_half[k-1] * a_km * whalf_k*whalf_k * dzi) + + adv_up = (self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * whalf_kp * whalf_kp * dzi + - self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * whalf_k * whalf_k * dzi) + adv_dw = (self.Ref.rho0_half[k+2] * self.UpdVar.Area.values[i,k+2] * whalf_kpp * whalf_kpp + - self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * whalf_kp * whalf_kp )* dzi + adv = sgn_w*adv_up + (1.0-sgn_w)*adv_dw + + exch = (self.Ref.rho0_half[k+1] * a_k * self.UpdVar.W.values[i,k] * (entr_w * whalf_k_env - detr_w * whalf_k )) - buoy= self.Ref.rho0[k] * a_k * B_k - press_buoy = -1.0 * self.Ref.rho0[k] * a_k * B_k * self.pressure_buoy_coeff - press_drag = -1.0 * self.Ref.rho0[k] * a_k * (self.pressure_drag_coeff/self.pressure_plume_spacing + buoy= self.Ref.rho0_half[k] * a_k * B_k + press_buoy = -1.0 * self.Ref.rho0_half[k] * a_k * B_k * self.pressure_buoy_coeff + press_drag = -1.0 * self.Ref.rho0_half[k] * a_k * (self.pressure_drag_coeff/self.pressure_plume_spacing * (whalf_k -whalf_k_env )**2.0/sqrt(fmax(a_k,self.minimum_area))) press = press_buoy + press_drag self.updraft_pressure_sink[i,k] = press - w_new[k+1] = (self.Ref.rho0[k] * a_k * self.UpdVar.W.values[i,k] * dti_ - -adv + exch + buoy + press)/(self.Ref.rho0[k] * anew_k * dti_) + w_new[k+1] = (self.Ref.rho0_half[k] * a_k * self.UpdVar.W.values[i,k] * dti_ + -adv + exch + buoy + press)/(self.Ref.rho0_half[k] * self.UpdVar.Area.new[i,k+1] * dti_) self.UpdVar.W.new[i,k] =interp2pt(w_new[k+1],w_new[k]) with gil: - if k==gw: - print self.UpdVar.W.new[i,k]/fmax(w_temp,0.001) - self.UpdVar.W.new[i,k] = 1.4*w_temp + print self.UpdVar.W.new[i,k] - if self.UpdVar.W.new[i,k] <= 0.0: - self.UpdVar.W.new[i,k:] = 0.0 - self.UpdVar.Area.new[i,k+1:] = 0.0 - break + # if self.UpdVar.W.new[i,k] <= 0.0: + # self.UpdVar.W.new[i,k:] = 0.0 + # self.UpdVar.Area.new[i,k+1:] = 0.0 + # break else: self.UpdVar.W.new[i,k:] = 0.0 self.UpdVar.Area.new[i,k+1:] = 0.0 @@ -1013,7 +1028,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Py_ssize_t k, i double dzi = self.Gr.dzi double dti_ = 1.0/self.dt_upd - double m_k, m_km + double m_k, m_km, m_kp, sgn_w Py_ssize_t gw = self.Gr.gw double H_entr, QT_entr double c1, c2, c3, c4 @@ -1046,20 +1061,41 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # write the discrete equations in form: # c1 * phi_new[k] = c2 * phi[k] + c3 * phi[k-1] + c4 * phi_entr if self.UpdVar.Area.new[i,k] >= self.minimum_area: + + if interp2pt(self.UpdVar.W.values[i,k-1], self.UpdVar.W.values[i,k])<0: # and interp2pt(self.UpdVar.W.new[i,k-1], self.UpdVar.W.new[i,k])<=0: + sgn_w = 0.0 + else: + sgn_w = 1.0 + #sgn_w = 1.0 + + m_kp = (self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] + * interp2pt(self.UpdVar.W.values[i,k], self.UpdVar.W.values[i,k+1])) m_k = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * interp2pt(self.UpdVar.W.values[i,k-1], self.UpdVar.W.values[i,k])) m_km = (self.Ref.rho0_half[k-1] * self.UpdVar.Area.values[i,k-1] * interp2pt(self.UpdVar.W.values[i,k-2], self.UpdVar.W.values[i,k-1])) + + #c1 = self.Ref.rho0_half[k] * self.UpdVar.Area.new[i,k] * dti_ + #c2 = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * dti_ + # - m_k * (dzi + self.detr_sc[i,k])) + #c3 = m_km * dzi + #c4 = m_k * self.entr_sc[i,k] + c1 = self.Ref.rho0_half[k] * self.UpdVar.Area.new[i,k] * dti_ c2 = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * dti_ - - m_k * (dzi + self.detr_sc[i,k])) - c3 = m_km * dzi - c4 = m_k * self.entr_sc[i,k] - - self.UpdVar.H.new[i,k] = (c2 * self.UpdVar.H.values[i,k] + c3 * self.UpdVar.H.values[i,k-1] - + c4 * H_entr)/c1 - self.UpdVar.QT.new[i,k] = (c2 * self.UpdVar.QT.values[i,k] + c3 * self.UpdVar.QT.values[i,k-1] - + c4* QT_entr)/c1 + - (2*sgn_w-1.0)*m_k * (dzi + self.detr_sc[i,k])) + c3 = sgn_w*m_km * dzi-(1.0-sgn_w)*m_kp * dzi + c4 = (2*sgn_w-1.0)*(m_k * self.entr_sc[i,k]) + + self.UpdVar.H.new[i,k] = (c2 * self.UpdVar.H.values[i,k] + c3*sgn_w * self.UpdVar.H.values[i,k-1] + + c3*(1.0-sgn_w) * self.UpdVar.H.values[i,k+1] + c4 * H_entr )/c1 + self.UpdVar.QT.new[i,k] = (c2 * self.UpdVar.QT.values[i,k] + c3*sgn_w * self.UpdVar.QT.values[i,k-1] + + c3*(1.0-sgn_w) * self.UpdVar.QT.values[i,k+1] + c4* QT_entr)/c1 + + #self.UpdVar.H.new[i,k] = (c2 * self.UpdVar.H.values[i,k] + c3 * self.UpdVar.H.values[i,k-1] + # + c4 * H_entr)/c1 + #self.UpdVar.QT.new[i,k] = (c2 * self.UpdVar.QT.values[i,k] + c3 * self.UpdVar.QT.values[i,k-1] + # + c4* QT_entr)/c1 else: self.UpdVar.H.new[i,k] = GMV.H.values[k] self.UpdVar.QT.new[i,k] = GMV.QT.values[k] From afe401246ec13cb521f50425750b4922124989fd Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Sat, 22 Sep 2018 15:12:23 -0700 Subject: [PATCH 095/136] fully fake_collocated that integrates downwards on Soares --- Turbulence_PrognosticTKE.pyx | 40 +++++------------------------------- 1 file changed, 5 insertions(+), 35 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index de8904c0..2f43afbd 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -934,13 +934,12 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for k in range(gw, self.Gr.nzg-gw): # First solve for updated area fraction at k+1 + whalf_kpp = interp2pt(self.UpdVar.W.values[i,k+1], self.UpdVar.W.values[i,k+2]) whalf_kp = interp2pt(self.UpdVar.W.values[i,k], self.UpdVar.W.values[i,k+1]) whalf_k = interp2pt(self.UpdVar.W.values[i,k-1], self.UpdVar.W.values[i,k]) whalf_k_env = interp2pt(self.EnvVar.W.values[k-1], self.EnvVar.W.values[k]) entr_term = self.UpdVar.Area.values[i,k+1] * whalf_kp * (self.entr_sc[i,k+1] ) detr_term = self.UpdVar.Area.values[i,k+1] * whalf_kp * (- self.detr_sc[i,k+1]) - adv = -self.Ref.alpha0_half[k+1] * dzi *( self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * whalf_kp - -self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * whalf_k) if whalf_kp<0: sgn_w = 0.0 @@ -973,8 +972,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): a_k = self.UpdVar.Area.values[i,k+1] a_km = self.UpdVar.Area.values[i,k] B_k = self.UpdVar.B.values[i,k+1] - #adv = (self.Ref.rho0_half[k] * a_k * whalf_kp * whalf_kp * dzi - # - self.Ref.rho0_half[k-1] * a_km * whalf_k*whalf_k * dzi) adv_up = (self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * whalf_kp * whalf_kp * dzi - self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * whalf_k * whalf_k * dzi) @@ -982,8 +979,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): - self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * whalf_kp * whalf_kp )* dzi adv = sgn_w*adv_up + (1.0-sgn_w)*adv_dw - exch = (self.Ref.rho0_half[k+1] * a_k * self.UpdVar.W.values[i,k] - * (entr_w * whalf_k_env - detr_w * whalf_k )) + exch = (self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * whalf_kp + * ((2*sgn_w-1.0)*entr_w * whalf_k_env - (2*sgn_w-1.0)*detr_w*whalf_kp)) buoy= self.Ref.rho0_half[k] * a_k * B_k press_buoy = -1.0 * self.Ref.rho0_half[k] * a_k * B_k * self.pressure_buoy_coeff press_drag = -1.0 * self.Ref.rho0_half[k] * a_k * (self.pressure_drag_coeff/self.pressure_plume_spacing @@ -997,29 +994,12 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with gil: print self.UpdVar.W.new[i,k] - # if self.UpdVar.W.new[i,k] <= 0.0: - # self.UpdVar.W.new[i,k:] = 0.0 - # self.UpdVar.Area.new[i,k+1:] = 0.0 - # break else: self.UpdVar.W.new[i,k:] = 0.0 - self.UpdVar.Area.new[i,k+1:] = 0.0 + self.UpdVar.Area.new[i,k+1] = 0.0 # keep this in mind if we modify updraft top treatment! - self.updraft_pressure_sink[i,k:] = 0.0 + self.updraft_pressure_sink[i,k] = 0.0 break - # the above lines were replaced by the followings to allow integration above negative w - # the model output is sensitive to the choice of value inthe condition : <= 0.01 - # if self.UpdVar.W.new[i,k] <= 0.01: - # self.UpdVar.W.new[i,k] = 0.0 - # self.UpdVar.Area.new[i,k+1] = 0.0 - # #break - # else: - # self.UpdVar.W.new[i,k] = 0.0 - # self.UpdVar.Area.new[i,k+1] = 0.0 - # #break - # plt.figure('area') - # plt.plot(self.UpdVar.Area.new[0,:], self.Gr.z_half) - # plt.show() return @@ -1075,12 +1055,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): m_km = (self.Ref.rho0_half[k-1] * self.UpdVar.Area.values[i,k-1] * interp2pt(self.UpdVar.W.values[i,k-2], self.UpdVar.W.values[i,k-1])) - #c1 = self.Ref.rho0_half[k] * self.UpdVar.Area.new[i,k] * dti_ - #c2 = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * dti_ - # - m_k * (dzi + self.detr_sc[i,k])) - #c3 = m_km * dzi - #c4 = m_k * self.entr_sc[i,k] - c1 = self.Ref.rho0_half[k] * self.UpdVar.Area.new[i,k] * dti_ c2 = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * dti_ - (2*sgn_w-1.0)*m_k * (dzi + self.detr_sc[i,k])) @@ -1092,10 +1066,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.QT.new[i,k] = (c2 * self.UpdVar.QT.values[i,k] + c3*sgn_w * self.UpdVar.QT.values[i,k-1] + c3*(1.0-sgn_w) * self.UpdVar.QT.values[i,k+1] + c4* QT_entr)/c1 - #self.UpdVar.H.new[i,k] = (c2 * self.UpdVar.H.values[i,k] + c3 * self.UpdVar.H.values[i,k-1] - # + c4 * H_entr)/c1 - #self.UpdVar.QT.new[i,k] = (c2 * self.UpdVar.QT.values[i,k] + c3 * self.UpdVar.QT.values[i,k-1] - # + c4* QT_entr)/c1 else: self.UpdVar.H.new[i,k] = GMV.H.values[k] self.UpdVar.QT.new[i,k] = GMV.QT.values[k] From 9ccaadb9fff8c9748cd0992fc416e977c829816a Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Sat, 22 Sep 2018 15:29:01 -0700 Subject: [PATCH 096/136] add fabs in pressure terms --- Turbulence_PrognosticTKE.pyx | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 2f43afbd..d4ebac35 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -923,8 +923,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): * (entr_w * self.EnvVar.W.values[gw] - detr_w * self.UpdVar.W.values[i,gw] )) buoy= self.Ref.rho0[gw] * a_k * B_k press_buoy = -1.0 * self.Ref.rho0[gw] * a_k * B_k * self.pressure_buoy_coeff - press_drag = -1.0 * self.Ref.rho0[gw] * a_k * (self.pressure_drag_coeff/self.pressure_plume_spacing - * (self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])**2.0/sqrt(a_k)) + press_drag = -1.0 * self.Ref.rho0[gw] * sqrt(a_k) * (self.pressure_drag_coeff/self.pressure_plume_spacing + * fabs(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])*(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])) press = press_buoy + press_drag self.updraft_pressure_sink[i,gw] = press self.UpdVar.W.new[i,gw] = (self.Ref.rho0[gw] * a_k * self.UpdVar.W.values[i,gw] * dti_ @@ -983,8 +983,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): * ((2*sgn_w-1.0)*entr_w * whalf_k_env - (2*sgn_w-1.0)*detr_w*whalf_kp)) buoy= self.Ref.rho0_half[k] * a_k * B_k press_buoy = -1.0 * self.Ref.rho0_half[k] * a_k * B_k * self.pressure_buoy_coeff - press_drag = -1.0 * self.Ref.rho0_half[k] * a_k * (self.pressure_drag_coeff/self.pressure_plume_spacing - * (whalf_k -whalf_k_env )**2.0/sqrt(fmax(a_k,self.minimum_area))) + press_drag = -1.0 * self.Ref.rho0_half[k] * sqrt(a_k) * (self.pressure_drag_coeff/self.pressure_plume_spacing + *fabs(whalf_k -whalf_k_env) * (whalf_k -whalf_k_env)) press = press_buoy + press_drag self.updraft_pressure_sink[i,k] = press w_new[k+1] = (self.Ref.rho0_half[k] * a_k * self.UpdVar.W.values[i,k] * dti_ From 4b1349fcf77de08cf598857af226495b8e9e7043 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Sat, 22 Sep 2018 15:33:07 -0700 Subject: [PATCH 097/136] ... --- Turbulence_PrognosticTKE.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index d4ebac35..dc8a1ebf 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -1407,7 +1407,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): press_buoy= (-1.0 * self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] * self.pressure_buoy_coeff) press_drag = (-1.0 * self.Ref.rho0_half[k] * sqrt(self.UpdVar.Area.values[i,k]) - * (self.pressure_drag_coeff/self.pressure_plume_spacing* (wu_half -we_half)**2.0)) + * (self.pressure_drag_coeff/self.pressure_plume_spacing* fabs(wu_half -we_half)*(wu_half -we_half))) self.tke_pressure[k] += (we_half - wu_half) * (press_buoy + press_drag) return From 14d57f35ac4a13a5dedfe105897cd3a6139bcbb9 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Sat, 22 Sep 2018 15:49:15 -0700 Subject: [PATCH 098/136] add sgn_w for entr and detr in a equation --- Turbulence_PrognosticTKE.pyx | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index dc8a1ebf..99ad2402 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -938,15 +938,15 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): whalf_kp = interp2pt(self.UpdVar.W.values[i,k], self.UpdVar.W.values[i,k+1]) whalf_k = interp2pt(self.UpdVar.W.values[i,k-1], self.UpdVar.W.values[i,k]) whalf_k_env = interp2pt(self.EnvVar.W.values[k-1], self.EnvVar.W.values[k]) - entr_term = self.UpdVar.Area.values[i,k+1] * whalf_kp * (self.entr_sc[i,k+1] ) - detr_term = self.UpdVar.Area.values[i,k+1] * whalf_kp * (- self.detr_sc[i,k+1]) - if whalf_kp<0: sgn_w = 0.0 else: sgn_w = 1.0 #sgn_w = 1.0 + entr_term = self.UpdVar.Area.values[i,k+1] * whalf_kp * (2*sgn_w-1.0)*( self.entr_sc[i,k+1]) + detr_term = self.UpdVar.Area.values[i,k+1] * whalf_kp * (2*sgn_w-1.0)*(-self.detr_sc[i,k+1]) + adv_up = -self.Ref.alpha0_half[k+1] * dzi *( self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * whalf_kp -self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * whalf_k) adv_dw = -self.Ref.alpha0_half[k+1] * dzi *( self.Ref.rho0_half[k+2] * self.UpdVar.Area.values[i,k+2] * whalf_kpp From 00e3c48c2e8744b2a2670dcb3f17ffdeddf2f6d8 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Sat, 22 Sep 2018 16:24:12 -0700 Subject: [PATCH 099/136] .. --- Turbulence_PrognosticTKE.pyx | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 052b7354..f11e85c1 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -247,9 +247,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Stats.write_profile('eddy_diffusivity', self.KH.values[self.Gr.gw:self.Gr.nzg-self.Gr.gw]) with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - mf_h[k] = self.massflux_h[k] - mf_qt[k] = self.massflux_qt[k] - massflux[k] = self.m[0,k] + mf_h[k] = interp2pt(self.massflux_h[k], self.massflux_h[k-1]) + mf_qt[k] = interp2pt(self.massflux_qt[k], self.massflux_qt[k-1]) + massflux[k] = interp2pt(self.m[0,k], self.m[0,k-1]) if self.UpdVar.Area.bulkvalues[k] > 0.0: for i in xrange(self.n_updrafts): mean_entr_sc[k] += self.UpdVar.Area.values[i,k] * self.entr_sc[i,k]/self.UpdVar.Area.bulkvalues[k] @@ -737,7 +737,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): input.dw = (self.UpdVar.W.values[i,k+1]-self.UpdVar.W.values[i,k-1])/self.Gr.dz/2.0 input.z = self.Gr.z_c[k] input.af = self.UpdVar.Area.values[i,k] - input.tke = self.EnvVar.TKE.values[k] input.ml = self.mixing_length[k] input.qt_env = self.EnvVar.QT.values[k] input.ql_env = self.EnvVar.QL.values[k] @@ -754,7 +753,10 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): input.T_up = self.UpdVar.T.values[i,k] input.p0 = self.Ref.p0_c[k] input.alpha0 = self.Ref.alpha0_c[k] - input.tke_ed_coeff = self.tke_ed_coeff + if self.calc_tke: + input.tke = self.EnvVar.TKE.values[k] + input.tke_ed_coeff = self.tke_ed_coeff + input.Poisson_rand = Poisson_rand[k]/10.0 input.L = 20000.0 # need to define the scale of the GCM grid resolution ret = self.entr_detr_fp(input) From 06934465a46ba198539b53fc203d5022eff33f88 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Sat, 22 Sep 2018 16:28:00 -0700 Subject: [PATCH 100/136] .. --- Turbulence_PrognosticTKE.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 99ad2402..eed916ff 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -913,7 +913,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.W.new[i,gw-1] = self.w_surface_bc[i] self.UpdVar.Area.new[i,gw] = self.area_surface_bc[i] au_lim = self.area_surface_bc[i] * self.max_area_factor - + # here W is calculated at full levels for the first step - later is calcualted as "collocated" and interpolated a_k = interp2pt(self.UpdVar.Area.values[i,gw], self.UpdVar.Area.values[i,gw+1]) entr_w = interp2pt(self.entr_sc[i,gw], self.entr_sc[i,gw+1]) detr_w = interp2pt(self.detr_sc[i,gw], self.detr_sc[i,gw+1]) From a7d174754b5ed27dd3761bb08fd44d79ec75e22c Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Sat, 22 Sep 2018 16:45:41 -0700 Subject: [PATCH 101/136] fix factor 0.5 for tkr in get_GMV_tke and below it --- Turbulence_PrognosticTKE.pyx | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index eed916ff..a9ca2595 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -759,10 +759,10 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(self.Gr.nzg): interp_w_diff = interp2pt(we.values[k-1]-gmv_w[k-1],we.values[k]-gmv_w[k]) - gmv_tke[k] = ae[k] * interp_w_diff * interp_w_diff + ae[k] * tke_e.values[k] + gmv_tke[k] = ae[k] * 0.5 * interp_w_diff * interp_w_diff + ae[k] * tke_e.values[k] for i in xrange(self.n_updrafts): interp_w_diff = interp2pt(wu.values[i,k-1]-gmv_w[k-1],wu.values[i,k]-gmv_w[k]) - gmv_tke[k] += au.values[i,k] *interp_w_diff * interp_w_diff + gmv_tke[k] += au.values[i,k] * 0.5 * interp_w_diff * interp_w_diff return @@ -779,11 +779,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for k in xrange(self.Gr.nzg): if ae[k] > 0.0: interp_w_diff = interp2pt(we.values[k-1]-gmv_w[k-1],we.values[k]-gmv_w[k]) - tke_e.values[k] = gmv_tke[k] - ae[k] * interp_w_diff * interp_w_diff + tke_e.values[k] = gmv_tke[k] - ae[k] * 0.5 * interp_w_diff * interp_w_diff for i in xrange(self.n_updrafts): interp_w_diff = interp2pt(wu.values[i,k-1]-gmv_w[k-1],wu.values[i,k]-gmv_w[k]) - tke_e.values[k] -= au.values[i,k] *interp_w_diff * interp_w_diff + tke_e.values[k] -= au.values[i,k] * 0.5 * interp_w_diff * interp_w_diff tke_e.values[k] = tke_e.values[k]/ae[k] else: tke_e.values[k] = 0.0 From 65e27754e384fcfac4277345d797b3abbbf66b40 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Sat, 22 Sep 2018 17:29:06 -0700 Subject: [PATCH 102/136] .. --- Turbulence_PrognosticTKE.pyx | 76 +++++++++++++++++++----------------- turbulence_functions.pxd | 2 +- turbulence_functions.pyx | 8 ++-- 3 files changed, 46 insertions(+), 40 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index f11e85c1..47c0eafb 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -1164,39 +1164,39 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cpdef compute_covariance(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS): - if TS.nstep > 0: - if self.similarity_diffusivity: # otherwise, we computed mixing length when we computed - self.compute_mixing_length(Case.Sur.obukhov_length, GMV) - if self.calc_tke: - self.compute_tke_buoy(GMV) - self.compute_covariance_entr(self.EnvVar.TKE, self.UpdVar.W, self.UpdVar.W, self.EnvVar.W, self.EnvVar.W) - self.compute_covariance_shear(GMV, self.EnvVar.TKE, &self.UpdVar.W.values[0,0], &self.UpdVar.W.values[0,0], &self.EnvVar.W.values[0], &self.EnvVar.W.values[0]) - self.compute_covariance_interdomain_src(self.UpdVar.Area,self.UpdVar.W,self.UpdVar.W,self.EnvVar.W, self.EnvVar.W, self.EnvVar.TKE) - self.compute_tke_pressure() - if self.calc_scalar_var: - self.compute_covariance_entr(self.EnvVar.Hvar, self.UpdVar.H, self.UpdVar.H, self.EnvVar.H, self.EnvVar.H) - self.compute_covariance_entr(self.EnvVar.QTvar, self.UpdVar.QT, self.UpdVar.QT, self.EnvVar.QT, self.EnvVar.QT) - self.compute_covariance_entr(self.EnvVar.HQTcov, self.UpdVar.H, self.UpdVar.QT, self.EnvVar.H, self.EnvVar.QT) - self.compute_covariance_shear(GMV, self.EnvVar.Hvar, &self.UpdVar.H.values[0,0], &self.UpdVar.H.values[0,0], &self.EnvVar.H.values[0], &self.EnvVar.H.values[0]) - self.compute_covariance_shear(GMV, self.EnvVar.QTvar, &self.UpdVar.QT.values[0,0], &self.UpdVar.QT.values[0,0], &self.EnvVar.QT.values[0], &self.EnvVar.QT.values[0]) - self.compute_covariance_shear(GMV, self.EnvVar.HQTcov, &self.UpdVar.H.values[0,0], &self.UpdVar.QT.values[0,0], &self.EnvVar.H.values[0], &self.EnvVar.QT.values[0]) - self.compute_covariance_interdomain_src(self.UpdVar.Area,self.UpdVar.H,self.UpdVar.H,self.EnvVar.H, self.EnvVar.H, self.EnvVar.Hvar) - self.compute_covariance_interdomain_src(self.UpdVar.Area,self.UpdVar.QT,self.UpdVar.QT,self.EnvVar.QT, self.EnvVar.QT, self.EnvVar.QTvar) - self.compute_covariance_interdomain_src(self.UpdVar.Area,self.UpdVar.H,self.UpdVar.QT,self.EnvVar.H, self.EnvVar.QT, self.EnvVar.HQTcov) - self.compute_covariance_rain(TS, GMV) # need to update this one + #if TS.nstep > 0: + if self.similarity_diffusivity: # otherwise, we computed mixing length when we computed + self.compute_mixing_length(Case.Sur.obukhov_length, GMV) + if self.calc_tke: + self.compute_tke_buoy(GMV) + self.compute_covariance_entr(self.EnvVar.TKE, self.UpdVar.W, self.UpdVar.W, self.EnvVar.W, self.EnvVar.W) + self.compute_covariance_shear(GMV, self.EnvVar.TKE, &self.UpdVar.W.values[0,0], &self.UpdVar.W.values[0,0], &self.EnvVar.W.values[0], &self.EnvVar.W.values[0]) + self.compute_covariance_interdomain_src(self.UpdVar.Area,self.UpdVar.W,self.UpdVar.W,self.EnvVar.W, self.EnvVar.W, self.EnvVar.TKE) + self.compute_tke_pressure() + if self.calc_scalar_var: + self.compute_covariance_entr(self.EnvVar.Hvar, self.UpdVar.H, self.UpdVar.H, self.EnvVar.H, self.EnvVar.H) + self.compute_covariance_entr(self.EnvVar.QTvar, self.UpdVar.QT, self.UpdVar.QT, self.EnvVar.QT, self.EnvVar.QT) + self.compute_covariance_entr(self.EnvVar.HQTcov, self.UpdVar.H, self.UpdVar.QT, self.EnvVar.H, self.EnvVar.QT) + self.compute_covariance_shear(GMV, self.EnvVar.Hvar, &self.UpdVar.H.values[0,0], &self.UpdVar.H.values[0,0], &self.EnvVar.H.values[0], &self.EnvVar.H.values[0]) + self.compute_covariance_shear(GMV, self.EnvVar.QTvar, &self.UpdVar.QT.values[0,0], &self.UpdVar.QT.values[0,0], &self.EnvVar.QT.values[0], &self.EnvVar.QT.values[0]) + self.compute_covariance_shear(GMV, self.EnvVar.HQTcov, &self.UpdVar.H.values[0,0], &self.UpdVar.QT.values[0,0], &self.EnvVar.H.values[0], &self.EnvVar.QT.values[0]) + self.compute_covariance_interdomain_src(self.UpdVar.Area,self.UpdVar.H,self.UpdVar.H,self.EnvVar.H, self.EnvVar.H, self.EnvVar.Hvar) + self.compute_covariance_interdomain_src(self.UpdVar.Area,self.UpdVar.QT,self.UpdVar.QT,self.EnvVar.QT, self.EnvVar.QT, self.EnvVar.QTvar) + self.compute_covariance_interdomain_src(self.UpdVar.Area,self.UpdVar.H,self.UpdVar.QT,self.EnvVar.H, self.EnvVar.QT, self.EnvVar.HQTcov) + self.compute_covariance_rain(TS, GMV) # need to update this one - self.reset_surface_covariance(GMV, Case) - if self.calc_tke: - self.update_covariance_ED(GMV, Case,TS, GMV.W, GMV.W, GMV.TKE, self.EnvVar.TKE, self.EnvVar.W, self.EnvVar.W, self.UpdVar.W, self.UpdVar.W) - if self.calc_scalar_var: - self.update_covariance_ED(GMV, Case,TS, GMV.H, GMV.H, GMV.Hvar, self.EnvVar.Hvar, self.EnvVar.H, self.EnvVar.H, self.UpdVar.H, self.UpdVar.H) - self.update_covariance_ED(GMV, Case,TS, GMV.QT,GMV.QT, GMV.QTvar, self.EnvVar.QTvar, self.EnvVar.QT, self.EnvVar.QT, self.UpdVar.QT, self.UpdVar.QT) - self.update_covariance_ED(GMV, Case,TS, GMV.H, GMV.QT, GMV.HQTcov, self.EnvVar.HQTcov, self.EnvVar.H, self.EnvVar.QT, self.UpdVar.H, self.UpdVar.QT) - self.cleanup_covariance(GMV) + self.reset_surface_covariance(GMV, Case) + if self.calc_tke: + self.update_covariance_ED(GMV, Case,TS, GMV.W, GMV.W, GMV.TKE, self.EnvVar.TKE, self.EnvVar.W, self.EnvVar.W, self.UpdVar.W, self.UpdVar.W) + if self.calc_scalar_var: + self.update_covariance_ED(GMV, Case,TS, GMV.H, GMV.H, GMV.Hvar, self.EnvVar.Hvar, self.EnvVar.H, self.EnvVar.H, self.UpdVar.H, self.UpdVar.H) + self.update_covariance_ED(GMV, Case,TS, GMV.QT,GMV.QT, GMV.QTvar, self.EnvVar.QTvar, self.EnvVar.QT, self.EnvVar.QT, self.UpdVar.QT, self.UpdVar.QT) + self.update_covariance_ED(GMV, Case,TS, GMV.H, GMV.QT, GMV.HQTcov, self.EnvVar.HQTcov, self.EnvVar.H, self.EnvVar.QT, self.UpdVar.H, self.UpdVar.QT) + self.cleanup_covariance(GMV) - else: - self.initialize_covariance(GMV, Case) + #else: + # self.initialize_covariance(GMV, Case) return @@ -1242,7 +1242,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.Gr.z_c[self.Gr.gw], Case.Sur.obukhov_length) if self.calc_scalar_var: - GMV.Hvar.values[self.Gr.gw] = get_surface_variance(flux1*alpha0LL,flux1*alpha0LL, ustar, zLL, oblength) + GMV.Hvar.values[self.Gr.gw] = get_surface_variance(flux1*alpha0LL,flux1*alpha0LL, ustar, zLL, oblength) GMV.QTvar.values[self.Gr.gw] = get_surface_variance(flux2*alpha0LL,flux2*alpha0LL, ustar, zLL, oblength) GMV.HQTcov.values[self.Gr.gw] = get_surface_variance(flux1*alpha0LL,flux2*alpha0LL, ustar, zLL, oblength) return @@ -1397,6 +1397,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): if GmvCovar.name=='tke': GmvCovar.values[gw] =get_surface_tke(Case.Sur.ustar, self.wstar, self.Gr.z_c[gw], Case.Sur.obukhov_length) + elif GmvCovar.name=='thetal_var': GmvCovar.values[gw] = get_surface_variance(Case.Sur.rho_hflux * alpha0LL, Case.Sur.rho_hflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) elif GmvCovar.name=='qt_var': @@ -1404,7 +1405,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): elif GmvCovar.name=='thetal_qt_covar': GmvCovar.values[gw] = get_surface_variance(Case.Sur.rho_hflux * alpha0LL, Case.Sur.rho_qtflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) - self.get_env_covar_from_GMV(self.UpdVar.Area, UpdVar1, UpdVar2, EnvVar1, EnvVar2,Covar, &GmvVar1.values[0], &GmvVar2.values[0], &GmvCovar.values[0]) + self.get_env_covar_from_GMV(self.UpdVar.Area, UpdVar1, UpdVar2, EnvVar1, EnvVar2, Covar, &GmvVar1.values[0], &GmvVar2.values[0], &GmvCovar.values[0]) Covar_surf = Covar.values[gw] @@ -1435,6 +1436,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): c[nz-1] = 0.0 tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) + # if Covar.name == 'tke': + # tke_factor = 0.5 + # else: + # tke_factor = 1.0 + for kk in xrange(nz): k = kk + gw @@ -1443,9 +1449,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Covar.values[k] = fmin(x[kk], sqrt(self.EnvVar.Hvar.values[k]*self.EnvVar.QTvar.values[k])) else: Covar.values[k] = fmax(x[kk],0.0) - with nogil: - GmvCovar.values[k] = (ae[k] * (Covar.values[k] + (EnvVar1.values[k]-GmvVar1.values[k]) * (EnvVar2.values[k]-GmvVar2.values[k])) - + self.UpdVar.Area.bulkvalues[k] * (UpdVar1.bulkvalues[k]-GmvVar1.values[k]) * (UpdVar2.bulkvalues[k]-GmvVar2.values[k])) + #with nogil: + # GmvCovar.values[k] = (ae[k] * (Covar.values[k] + (EnvVar1.values[k]-GmvVar1.values[k]) * (EnvVar2.values[k]-GmvVar2.values[k])) + # + self.UpdVar.Area.bulkvalues[k] * (UpdVar1.bulkvalues[k]-GmvVar1.values[k]) * (UpdVar2.bulkvalues[k]-GmvVar2.values[k])) self.get_GMV_CoVar(self.UpdVar.Area, UpdVar1, UpdVar2, EnvVar1, EnvVar2, Covar, &GmvVar1.values[0], &GmvVar2.values[0], &GmvCovar.values[0]) diff --git a/turbulence_functions.pxd b/turbulence_functions.pxd index 77478a42..c9c2089f 100644 --- a/turbulence_functions.pxd +++ b/turbulence_functions.pxd @@ -51,7 +51,7 @@ cdef double entr_detr_buoyancy_sorting(entr_in_struct entr_in) nogil cdef entr_struct entr_detr_tke(entr_in_struct entr_in) nogil cdef entr_struct entr_detr_tke2(entr_in_struct entr_in) nogil cdef double get_wstar(double bflux, double zi ) -cdef double get_inversion(double *theta_rho, double *u, double *v, double *z, +cdef double get_inversion(double *theta_rho, double *u, double *v, double *z_c, Py_ssize_t kmin, Py_ssize_t kmax, double Ri_bulk_crit) cdef double get_mixing_tau(double zi, double wstar) nogil diff --git a/turbulence_functions.pyx b/turbulence_functions.pyx index f685b0a8..d01d1ec1 100644 --- a/turbulence_functions.pyx +++ b/turbulence_functions.pyx @@ -255,7 +255,7 @@ cdef double get_wstar(double bflux, double zi ): return cbrt(fmax(bflux * zi, 0.0)) # BL height -cdef double get_inversion(double *theta_rho, double *u, double *v, double *z, +cdef double get_inversion(double *theta_rho, double *u, double *v, double *z_c, Py_ssize_t kmin, Py_ssize_t kmax, double Ri_bulk_crit): cdef: double theta_rho_b = theta_rho[kmin] @@ -269,15 +269,15 @@ cdef double get_inversion(double *theta_rho, double *u, double *v, double *z, for k in xrange(kmin,kmax): if theta_rho[k] > theta_rho_b: break - h = (z[k] - z[k-1])/(theta_rho[k] - theta_rho[k-1]) * (theta_rho_b - theta_rho[k-1]) + z[k-1] + h = (z_c[k] - z_c[k-1])/(theta_rho[k] - theta_rho[k-1]) * (theta_rho_b - theta_rho[k-1]) + z_c[k-1] else: with nogil: for k in xrange(kmin,kmax): Ri_bulk_low = Ri_bulk - Ri_bulk = g * (theta_rho[k] - theta_rho_b) * z[k]/theta_rho_b / (u[k] * u[k] + v[k] * v[k]) + Ri_bulk = g * (theta_rho[k] - theta_rho_b) * z_c[k]/theta_rho_b / (u[k] * u[k] + v[k] * v[k]) if Ri_bulk > Ri_bulk_crit: break - h = (z[k] - z[k-1])/(Ri_bulk - Ri_bulk_low) * (Ri_bulk_crit - Ri_bulk_low) + z[k-1] + h = (z_c[k] - z_c[k-1])/(Ri_bulk - Ri_bulk_low) * (Ri_bulk_crit - Ri_bulk_low) + z_c[k-1] return h From 772495effd7479142a6aee295eebe8f771e9c9ff Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Sat, 22 Sep 2018 17:37:50 -0700 Subject: [PATCH 103/136] fix _c in Turbulance.pyx --- Turbulence.pyx | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/Turbulence.pyx b/Turbulence.pyx index 425d8e14..a99c8327 100644 --- a/Turbulence.pyx +++ b/Turbulence.pyx @@ -196,13 +196,13 @@ cdef class SimilarityED(ParameterizationBase): # Matrix is the same for all variables that use the same eddy diffusivity construct_tridiag_diffusion(nzg, gw, self.Gr.dzi, TS.dt, &rho_K_m[0], - &self.Ref.rho0_f[0], &dummy_ae[0] ,&a[0], &b[0], &c[0]) + &self.Ref.rho0_c[0], &dummy_ae[0] ,&a[0], &b[0], &c[0]) # Solve QT with nogil: for k in xrange(nz): x[k] = GMV.QT.values[k+gw] - x[0] = x[0] + TS.dt * Case.Sur.rho_qtflux * self.Gr.dzi * self.Ref.alpha0_f[gw] + x[0] = x[0] + TS.dt * Case.Sur.rho_qtflux * self.Gr.dzi * self.Ref.alpha0_c[gw] tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) with nogil: @@ -214,7 +214,7 @@ cdef class SimilarityED(ParameterizationBase): with nogil: for k in xrange(nz): x[k] = GMV.H.values[k+gw] - x[0] = x[0] + TS.dt * Case.Sur.rho_hflux * self.Gr.dzi * self.Ref.alpha0_f[gw] + x[0] = x[0] + TS.dt * Case.Sur.rho_hflux * self.Gr.dzi * self.Ref.alpha0_c[gw] tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) with nogil: @@ -226,7 +226,7 @@ cdef class SimilarityED(ParameterizationBase): with nogil: for k in xrange(nz): x[k] = GMV.U.values[k+gw] - x[0] = x[0] + TS.dt * Case.Sur.rho_uflux * self.Gr.dzi * self.Ref.alpha0_f[gw] + x[0] = x[0] + TS.dt * Case.Sur.rho_uflux * self.Gr.dzi * self.Ref.alpha0_c[gw] tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) with nogil: @@ -237,7 +237,7 @@ cdef class SimilarityED(ParameterizationBase): with nogil: for k in xrange(nz): x[k] = GMV.V.values[k+gw] - x[0] = x[0] + TS.dt * Case.Sur.rho_vflux * self.Gr.dzi * self.Ref.alpha0_f[gw] + x[0] = x[0] + TS.dt * Case.Sur.rho_vflux * self.Gr.dzi * self.Ref.alpha0_c[gw] tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) with nogil: From b6bfaed72d88fcfebab3c1f614afd370db8c6ef2 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Sun, 23 Sep 2018 10:39:38 -0700 Subject: [PATCH 104/136] .. --- Turbulence_PrognosticTKE.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 47c0eafb..55706b7b 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -909,7 +909,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.detr_sc[i,k] = (((au_lim-var.values[i,k])* dti_ - adv - entr_term)/(-var.values[i,k] * self.UpdVar.W.values[i,k])) else: self.detr_sc[i,k] = (((au_lim-var.values[i,k])* dti_ - adv - entr_term)/(-au_lim * self.UpdVar.W.values[i,k])) - + return cpdef update_GMV_MF(self, GridMeanVariables GMV, TimeStepping TS): cdef: From a9f757bdf38b5e75295f99e501979d869467eba0 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Sun, 23 Sep 2018 11:00:46 -0700 Subject: [PATCH 105/136] .. --- Turbulence_PrognosticTKE.pxd | 2 + Turbulence_PrognosticTKE.pyx | 159 ++++++++++++++++++++++++++++++++++- 2 files changed, 159 insertions(+), 2 deletions(-) diff --git a/Turbulence_PrognosticTKE.pxd b/Turbulence_PrognosticTKE.pxd index e30c243e..950ecaf4 100644 --- a/Turbulence_PrognosticTKE.pxd +++ b/Turbulence_PrognosticTKE.pxd @@ -101,6 +101,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cpdef compute_entrainment_detrainment(self, GridMeanVariables GMV, CasesBase Case) cpdef solve_updraft_velocity_area(self, GridMeanVariables GMV, TimeStepping TS) cpdef solve_updraft_scalars(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS) + cpdef solve_updraft(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS) + cpdef upwind_integration(self, EDMF_Updrafts.UpdraftVariable area, EDMF_Updrafts.UpdraftVariable var, int k, int i, double env_var, double dzi) cpdef update_GMV_MF(self, GridMeanVariables GMV, TimeStepping TS) cpdef update_GMV_ED(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS) cpdef compute_tke(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index a9ca2595..3a9f7149 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -412,8 +412,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.dt_upd = np.minimum(TS.dt, 0.5 * self.Gr.dz/fmax(np.max(self.UpdVar.W.values),1e-10)) while time_elapsed < TS.dt: self.compute_entrainment_detrainment(GMV, Case) - self.solve_updraft_velocity_area(GMV,TS) - self.solve_updraft_scalars(GMV, Case, TS) + self.solve_updraft(GMV,Case,TS) + #self.solve_updraft_velocity_area(GMV,TS) + #self.solve_updraft_scalars(GMV, Case, TS) self.UpdVar.set_values_with_new() time_elapsed += self.dt_upd self.dt_upd = np.minimum(TS.dt-time_elapsed, 0.5 * self.Gr.dz/fmax(np.max(self.UpdVar.W.values),1e-10)) @@ -1109,6 +1110,160 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # thereby updating to GMV.SomeVar.mf_update # mass flux tendency is computed as 1st order upwind + + cpdef solve_updraft(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS): + cdef: + Py_ssize_t i, k + Py_ssize_t gw = self.Gr.gw + double dzi = self.Gr.dzi + double dti_ = 1.0/self.dt_upd + double dt_ = 1.0/dti_ + double a1, a2 # groupings of terms in area fraction discrete equation + double au_lim, sgn_w, adv_up, adv_dw, m_km, m_k, m_kp, a_k, entr_w, detr_w, B_k, w_temp, wf_upd, wf_env + double adv, buoy, exch, press, press_buoy, press_drag, entr_term # groupings of terms in velocity discrete equation + eos_struct sa + double qt_var, h_var + + + for i in xrange(self.n_updrafts): + self.entr_sc[i,gw] = 2.0 * dzi + self.detr_sc[i,gw] = 0.0 + self.UpdVar.Area.new[i,gw] = self.area_surface_bc[i] + au_lim = self.area_surface_bc[i] * self.max_area_factor + self.UpdVar.H.new[i,gw] = self.h_surface_bc[i] + self.UpdVar.QT.new[i,gw] = self.qt_surface_bc[i] + + #self.UpdVar.W.new[i,gw-1] = 0.0 + #self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, gw, i, self.EnvVar.W.values[gw], 2.0 * dzi) + + # here W is calculated at full levels for the first step - later is calcualted as "collocated" and interpolated + a_k = interp2pt(self.UpdVar.Area.values[i,gw], self.UpdVar.Area.values[i,gw+1]) + entr_w = interp2pt(self.entr_sc[i,gw], self.entr_sc[i,gw+1]) + detr_w = interp2pt(self.detr_sc[i,gw], self.detr_sc[i,gw+1]) + B_k = interp2pt(self.UpdVar.B.values[i,gw], self.UpdVar.B.values[i,gw+1]) + adv = self.Ref.rho0[gw] * a_k * self.UpdVar.W.values[i,gw] * self.UpdVar.W.values[i,gw] * dzi + exch = (self.Ref.rho0[gw] * a_k * self.UpdVar.W.values[i,gw] + * (entr_w * self.EnvVar.W.values[gw] - detr_w * self.UpdVar.W.values[i,gw] )) + buoy= self.Ref.rho0[gw] * a_k * B_k + press_buoy = -1.0 * self.Ref.rho0[gw] * a_k * B_k * self.pressure_buoy_coeff + press_drag = -1.0 * self.Ref.rho0[gw] * sqrt(a_k) * (self.pressure_drag_coeff/self.pressure_plume_spacing + * fabs(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])*(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])) + press = press_buoy + press_drag + self.updraft_pressure_sink[i,gw] = press + self.UpdVar.W.new[i,gw] = (self.Ref.rho0[gw] * a_k * self.UpdVar.W.values[i,gw] * dti_ + -adv + exch + buoy + press)/(self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * dti_) + self.UpdVar.W.values[i,gw] = self.UpdVar.W.new[i,gw] + + sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, + self.Ref.p0_half[gw], self.UpdVar.QT.new[i,gw], self.UpdVar.H.new[i,gw]) + + self.UpdVar.QL.new[i,gw] = sa.ql + self.UpdVar.T.new[i,gw] = sa.T + self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0_half[gw], self.UpdVar.T.new[i,gw], + &self.UpdVar.QT.new[i,gw], &self.UpdVar.QL.new[i,gw], + &self.UpdVar.QR.new[i,gw], &self.UpdVar.H.new[i,gw], + i, gw) + print self.UpdVar.W.new[i,gw] + for k in range(gw+1, self.Gr.nzg-gw): + self.upwind_integration(self.UpdVar.Area, self.UpdVar.Area, k, i, 1.0, dzi) + if self.UpdVar.Area.new[i,k] >= self.minimum_area: + self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, k, i, self.EnvVar.W.values[k],dzi) + # if self.UpdVar.W.new[i,k]<=0: + # print 'clipping',k, self.UpdVar.W.new[i,k],self.UpdVar.Area.new[i,k] + # self.UpdVar.W.new[i,k:]=0.0 + # self.UpdVar.Area.new[i,k:]=0.0 + # self.updraft_pressure_sink[i,k:] = 0.0 + # break + else: + self.UpdVar.W.new[i,k] = 0.0 + self.UpdVar.Area.new[i,k] = 0.0 + self.updraft_pressure_sink[i,k] = 0.0 # keep this in mind if we modify updraft top treatment! + + + if self.UpdVar.Area.new[i,k] >= self.minimum_area: + self.upwind_integration(self.UpdVar.Area, self.UpdVar.H, k, i, self.EnvVar.H.values[k], dzi) + self.upwind_integration(self.UpdVar.Area, self.UpdVar.QT, k, i, self.EnvVar.QT.values[k], dzi) + else: + + self.UpdVar.H.new[i,k] = GMV.H.values[k] + self.UpdVar.QT.new[i,k] = GMV.QT.values[k] + + sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_half[k], + self.UpdVar.QT.new[i,k], self.UpdVar.H.new[i,k]) + + self.UpdVar.QL.new[i,k] = sa.ql + self.UpdVar.T.new[i,k] = sa.T + if self.use_local_micro: + self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0_half[k], self.UpdVar.T.new[i,k], + &self.UpdVar.QT.new[i,k], &self.UpdVar.QL.new[i,k], + &self.UpdVar.QR.new[i,k], &self.UpdVar.H.new[i,k], + i, k) + + if self.use_local_micro: + self.UpdMicro.prec_source_h_tot = np.sum(np.multiply(self.UpdMicro.prec_source_h,self.UpdVar.Area.values), axis=0) + self.UpdMicro.prec_source_qt_tot = np.sum(np.multiply(self.UpdMicro.prec_source_qt,self.UpdVar.Area.values), axis=0) + else: + self.UpdMicro.compute_sources(self.UpdVar) + # Update updraft variables with microphysical source tendencies + self.UpdMicro.update_updraftvars(self.UpdVar) + + self.UpdVar.H.set_bcs(self.Gr) + self.UpdVar.QT.set_bcs(self.Gr) + self.UpdVar.QR.set_bcs(self.Gr) + self.UpdVar.W.set_bcs(self.Gr) + self.UpdVar.Area.set_bcs(self.Gr) + + return + + cpdef upwind_integration(self, EDMF_Updrafts.UpdraftVariable area, EDMF_Updrafts.UpdraftVariable var, int k, int i, double env_var, double dzi): + cdef: + + double dti_ = 1.0/self.dt_upd + double adv, exch, press_buoy, press_drag, au_lim, entr_term + double buoy = 0.0 + double press = 0.0 + double var_kp = 1.0 + double var_k = 1.0 + double var_km = 1.0 + double area_new = 1.0 + + if var.name == 'w': + buoy = self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] + press_buoy = - self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] * self.pressure_buoy_coeff + press_drag = - self.Ref.rho0_half[k]*(sqrt(self.UpdVar.Area.values[i,k] )*self.pressure_drag_coeff/self.pressure_plume_spacing + * (self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k])*fabs(self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k])) + press = press_buoy + press_drag + area_new = area.new[i,k] + var_kp = var.values[i,k+1] + var_k = var.values[i,k] + var_km = var.values[i,k-1] + self.updraft_pressure_sink[i,k] = press + elif var.name == 'thetal' or var.name == 'qt': + area_new = area.new[i,k] + var_kp = var.values[i,k+1] + var_k = var.values[i,k] + var_km = var.values[i,k-1] + + with nogil: + if self.UpdVar.W.values[i,k]<0: + with gil: + print '========================== integrating downwards ==========================' + adv = (self.Ref.rho0_half[k+1] * area.values[i,k+1] * self.UpdVar.W.values[i,k+1] * var_kp + - self.Ref.rho0_half[k] *area.values[i,k] * self.UpdVar.W.values[i,k] * var_k )* dzi + exch = (self.Ref.rho0_half[k] * area.values[i,k] * self.UpdVar.W.values[i,k] + * (-self.entr_sc[i,k] * env_var + self.detr_sc[i,k] * var_k )) + else: + adv = (self.Ref.rho0_half[k] * area.values[i,k] * self.UpdVar.W.values[i,k] * var_k + - self.Ref.rho0_half[k-1] * area.values[i,k-1] * self.UpdVar.W.values[i,k-1] * var_km)* dzi + exch = (self.Ref.rho0_half[k] * area.values[i,k] * self.UpdVar.W.values[i,k] + * (self.entr_sc[i,k] * env_var - self.detr_sc[i,k] * var_k )) + + + var.new[i,k] = (self.Ref.rho0_half[k] * area.values[i,k] * var_k * dti_ -adv + exch + buoy + press)\ + /(self.Ref.rho0_half[k] * area_new * dti_) + + return + cpdef update_GMV_MF(self, GridMeanVariables GMV, TimeStepping TS): cdef: Py_ssize_t k, i From 1b9a0257a8c55ace72a73e89f71d17fc9e8c9f52 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Sun, 23 Sep 2018 11:08:44 -0700 Subject: [PATCH 106/136] .. --- Turbulence_PrognosticTKE.pyx | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 55706b7b..b586c3bc 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -916,7 +916,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Py_ssize_t k, i Py_ssize_t gw = self.Gr.gw double mf_tend_h=0.0, mf_tend_qt=0.0 - double env_h_interp, env_qt_interp, upd_h_interp, upd_qt_interp, m_kp, m_k + double env_h_interp, env_qt_interp, dw_kp, dw_k self.massflux_h[:] = 0.0 self.massflux_qt[:] = 0.0 @@ -925,9 +925,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for i in xrange(self.n_updrafts): self.m[i,gw-1] = 0.0 for k in xrange(self.Gr.gw, self.Gr.nzg): - m_kp = ((self.UpdVar.W.values[i,k+1] - self.EnvVar.W.values[k+1] )* self.Ref.rho0_c[k+1] * self.UpdVar.Area.values[i,k+1]) - m_k = ((self.UpdVar.W.values[i,k] - self.EnvVar.W.values[k] )* self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k]) - self.m[i,k] = interp2pt(m_kp,m_k) + dw_kp = (self.UpdVar.W.values[i,k+1] - self.EnvVar.W.values[k+1] )#* self.Ref.rho0_c[k+1] * self.UpdVar.Area.values[i,k+1]) + dw_k = (self.UpdVar.W.values[i,k] - self.EnvVar.W.values[k] )#* self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k]) + self.m[i,k] = interp2pt(dw_kp,dw_k)*self.Ref.rho0_f[k]*interp2pt(self.UpdVar.Area.values[i,k+1],self.UpdVar.Area.values[i,k]) self.massflux_h[gw-1] = 0.0 self.massflux_qt[gw-1] = 0.0 @@ -938,10 +938,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): env_h_interp = interp2pt(self.EnvVar.H.values[k], self.EnvVar.H.values[k+1]) env_qt_interp = interp2pt(self.EnvVar.QT.values[k], self.EnvVar.QT.values[k+1]) for i in xrange(self.n_updrafts): - upd_h_interp = interp2pt(self.UpdVar.H.values[i,k], self.UpdVar.H.values[i,k+1]) - upd_qt_interp = interp2pt(self.UpdVar.QT.values[i,k], self.UpdVar.QT.values[i,k+1]) - self.massflux_h[k] += self.m[i,k] * (upd_h_interp - env_h_interp ) - self.massflux_qt[k] += self.m[i,k] * (upd_qt_interp - env_qt_interp ) + self.massflux_h[k] += self.m[i,k] * (interp2pt(self.UpdVar.H.values[i,k], + self.UpdVar.H.values[i,k+1]) - env_h_interp ) + self.massflux_qt[k] += self.m[i,k] * (interp2pt(self.UpdVar.QT.values[i,k], + self.UpdVar.QT.values[i,k+1]) - env_qt_interp ) + # Compute the mass flux tendencies # Adjust the values of the grid mean variables From 94c20a064bd6d94dfb6e599d7afebfd25763ea5d Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Sun, 23 Sep 2018 18:48:11 -0700 Subject: [PATCH 107/136] turned collocated not running --- EDMF_Updrafts.pyx | 19 ++--- Turbulence_PrognosticTKE.pyx | 154 ++++++++++++++++------------------- Variables.pyx | 16 +--- 3 files changed, 77 insertions(+), 112 deletions(-) diff --git a/EDMF_Updrafts.pyx b/EDMF_Updrafts.pyx index 5c2c5950..728f82af 100644 --- a/EDMF_Updrafts.pyx +++ b/EDMF_Updrafts.pyx @@ -42,19 +42,10 @@ cdef class UpdraftVariable: Py_ssize_t start_high = Gr.nzg - Gr.gw - 1 n_updrafts = np.shape(self.values)[0] - - if self.name == 'w': + for k in xrange(Gr.gw): for i in xrange(n_updrafts): - self.values[i,start_high] = 0.0 - self.values[i,start_low] = 0.0 - for k in xrange(1,Gr.gw): - self.values[i,start_high+ k] = -self.values[i,start_high - k ] - self.values[i,start_low- k] = -self.values[i,start_low + k ] - else: - for k in xrange(Gr.gw): - for i in xrange(n_updrafts): - self.values[i,start_high + k +1] = self.values[i,start_high - k] - self.values[i,start_low - k] = self.values[i,start_low + 1 + k] + self.values[i,start_high + k +1] = self.values[i,start_high - k] + self.values[i,start_low - k] = self.values[i,start_low + 1 + k] return @@ -67,8 +58,8 @@ cdef class UpdraftVariables: Py_ssize_t nzg = Gr.nzg Py_ssize_t i, k - self.W = UpdraftVariable(nu, nzg, 'full', 'velocity', 'w','m/s' ) - self.Area = UpdraftVariable(nu, nzg, 'full', 'scalar', 'area_fraction','[-]' ) + self.W = UpdraftVariable(nu, nzg, 'half', 'velocity', 'w','m/s' ) + self.Area = UpdraftVariable(nu, nzg, 'half', 'scalar', 'area_fraction','[-]' ) self.QT = UpdraftVariable(nu, nzg, 'half', 'scalar', 'qt','kg/kg' ) self.QL = UpdraftVariable(nu, nzg, 'half', 'scalar', 'ql','kg/kg' ) self.QR = UpdraftVariable(nu, nzg, 'half', 'scalar', 'qr','kg/kg' ) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 3a9f7149..afa7b56d 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -412,9 +412,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.dt_upd = np.minimum(TS.dt, 0.5 * self.Gr.dz/fmax(np.max(self.UpdVar.W.values),1e-10)) while time_elapsed < TS.dt: self.compute_entrainment_detrainment(GMV, Case) - self.solve_updraft(GMV,Case,TS) - #self.solve_updraft_velocity_area(GMV,TS) - #self.solve_updraft_scalars(GMV, Case, TS) + #self.solve_updraft(GMV,Case,TS) + self.solve_updraft_velocity_area(GMV,TS) + self.solve_updraft_scalars(GMV, Case, TS) self.UpdVar.set_values_with_new() time_elapsed += self.dt_upd self.dt_upd = np.minimum(TS.dt-time_elapsed, 0.5 * self.Gr.dz/fmax(np.max(self.UpdVar.W.values),1e-10)) @@ -654,7 +654,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): 1.0-self.surface_area + (i+1)*a_ , 1000) self.area_surface_bc[i] = self.surface_area/self.n_updrafts - self.w_surface_bc[i] = 0.0 + self.h_surface_bc[i] = (GMV.H.values[gw] + surface_scalar_coeff * sqrt(h_var)) self.qt_surface_bc[i] = (GMV.QT.values[gw] + surface_scalar_coeff * sqrt(qt_var)) return @@ -704,7 +704,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.EnvVar.H.values[k] = val1 * GMV.H.values[k] - val2 * self.UpdVar.H.bulkvalues[k] # Have to account for staggering of W--interpolate area fraction to the "full" grid points # Assuming GMV.W = 0! - au_full = 0.5 * (self.UpdVar.Area.bulkvalues[k+1] + self.UpdVar.Area.bulkvalues[k]) + au_full = self.UpdVar.Area.bulkvalues[k] self.EnvVar.W.values[k] = -au_full/(1.0-au_full) * self.UpdVar.W.bulkvalues[k] if self.calc_tke: @@ -732,7 +732,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.EnvVar.H.values[k] = val1 * GMV.H.mf_update[k] - val2 * self.UpdVar.H.bulkvalues[k] # Have to account for staggering of W # Assuming GMV.W = 0! - au_full = 0.5 * (self.UpdVar.Area.bulkvalues[k+1] + self.UpdVar.Area.bulkvalues[k]) + au_full = self.UpdVar.Area.bulkvalues[k] self.EnvVar.W.values[k] = -au_full/(1.0-au_full) * self.UpdVar.W.bulkvalues[k] if self.calc_tke: @@ -759,10 +759,10 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(self.Gr.nzg): - interp_w_diff = interp2pt(we.values[k-1]-gmv_w[k-1],we.values[k]-gmv_w[k]) + interp_w_diff = we.values[k]-gmv_w[k] gmv_tke[k] = ae[k] * 0.5 * interp_w_diff * interp_w_diff + ae[k] * tke_e.values[k] for i in xrange(self.n_updrafts): - interp_w_diff = interp2pt(wu.values[i,k-1]-gmv_w[k-1],wu.values[i,k]-gmv_w[k]) + interp_w_diff = wu.values[i,k]-gmv_w[k] gmv_tke[k] += au.values[i,k] * 0.5 * interp_w_diff * interp_w_diff return @@ -779,11 +779,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(self.Gr.nzg): if ae[k] > 0.0: - interp_w_diff = interp2pt(we.values[k-1]-gmv_w[k-1],we.values[k]-gmv_w[k]) + interp_w_diff = we.values[k]-gmv_w[k] tke_e.values[k] = gmv_tke[k] - ae[k] * 0.5 * interp_w_diff * interp_w_diff for i in xrange(self.n_updrafts): - interp_w_diff = interp2pt(wu.values[i,k-1]-gmv_w[k-1],wu.values[i,k]-gmv_w[k]) + interp_w_diff = wu.values[i,k]-gmv_w[k] tke_e.values[k] -= au.values[i,k] * 0.5 * interp_w_diff * interp_w_diff tke_e.values[k] = tke_e.values[k]/ae[k] else: @@ -861,7 +861,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): input.b = self.UpdVar.B.values[i,k] input.b_mean = GMV.B.values[k] - input.w = interp2pt(self.UpdVar.W.values[i,k],self.UpdVar.W.values[i,k-1]) + input.w = self.UpdVar.W.values[i,k] input.dw = (self.UpdVar.W.values[i,k]-self.UpdVar.W.values[i,k-1])/self.Gr.dz input.z = self.Gr.z_half[k] input.af = self.UpdVar.Area.values[i,k] @@ -870,7 +870,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): input.ql_env = self.EnvVar.QL.values[k] input.T_env = self.EnvVar.T.values[k] input.H_env = self.EnvVar.H.values[k] - input.w_env = interp2pt(self.EnvVar.W.values[k],self.EnvVar.W.values[k-1]) + input.w_env = self.EnvVar.W.values[k] input.dw_env = (self.EnvVar.W.values[k]-self.EnvVar.W.values[k-1])/self.Gr.dz input.H_up = self.UpdVar.H.values[i,k] input.qt_up = self.UpdVar.QT.values[i,k] @@ -911,34 +911,33 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for i in xrange(self.n_updrafts): self.entr_sc[i,gw] = 4.0 * dzi self.detr_sc[i,gw] = 0.0 - self.UpdVar.W.new[i,gw-1] = self.w_surface_bc[i] self.UpdVar.Area.new[i,gw] = self.area_surface_bc[i] au_lim = self.area_surface_bc[i] * self.max_area_factor # here W is calculated at full levels for the first step - later is calcualted as "collocated" and interpolated - a_k = interp2pt(self.UpdVar.Area.values[i,gw], self.UpdVar.Area.values[i,gw+1]) - entr_w = interp2pt(self.entr_sc[i,gw], self.entr_sc[i,gw+1]) - detr_w = interp2pt(self.detr_sc[i,gw], self.detr_sc[i,gw+1]) - B_k = interp2pt(self.UpdVar.B.values[i,gw], self.UpdVar.B.values[i,gw+1]) - adv = self.Ref.rho0[gw] * a_k * self.UpdVar.W.values[i,gw] * self.UpdVar.W.values[i,gw] * dzi - exch = (self.Ref.rho0[gw] * a_k * self.UpdVar.W.values[i,gw] + a_k = self.UpdVar.Area.values[i,gw] + entr_w = self.entr_sc[i,gw] + detr_w = self.detr_sc[i,gw] + B_k = self.UpdVar.B.values[i,gw] + adv = self.Ref.rho0_half[gw] * a_k * self.UpdVar.W.values[i,gw] * self.UpdVar.W.values[i,gw] * dzi*2.0 + exch = (self.Ref.rho0_half[gw] * a_k * self.UpdVar.W.values[i,gw] * (entr_w * self.EnvVar.W.values[gw] - detr_w * self.UpdVar.W.values[i,gw] )) - buoy= self.Ref.rho0[gw] * a_k * B_k - press_buoy = -1.0 * self.Ref.rho0[gw] * a_k * B_k * self.pressure_buoy_coeff - press_drag = -1.0 * self.Ref.rho0[gw] * sqrt(a_k) * (self.pressure_drag_coeff/self.pressure_plume_spacing + buoy= self.Ref.rho0_half[gw] * a_k * B_k + press_buoy = -1.0 * self.Ref.rho0_half[gw] * a_k * B_k * self.pressure_buoy_coeff + press_drag = -1.0 * self.Ref.rho0_half[gw] * sqrt(a_k) * (self.pressure_drag_coeff/self.pressure_plume_spacing * fabs(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])*(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])) press = press_buoy + press_drag self.updraft_pressure_sink[i,gw] = press - self.UpdVar.W.new[i,gw] = (self.Ref.rho0[gw] * a_k * self.UpdVar.W.values[i,gw] * dti_ + self.UpdVar.W.new[i,gw] = (self.Ref.rho0_half[gw] * a_k * self.UpdVar.W.values[i,gw] * dti_ -adv + exch + buoy + press)/(self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * dti_) self.UpdVar.W.values[i,gw] = self.UpdVar.W.new[i,gw] for k in range(gw, self.Gr.nzg-gw): # First solve for updated area fraction at k+1 - whalf_kpp = interp2pt(self.UpdVar.W.values[i,k+1], self.UpdVar.W.values[i,k+2]) - whalf_kp = interp2pt(self.UpdVar.W.values[i,k], self.UpdVar.W.values[i,k+1]) - whalf_k = interp2pt(self.UpdVar.W.values[i,k-1], self.UpdVar.W.values[i,k]) - whalf_k_env = interp2pt(self.EnvVar.W.values[k-1], self.EnvVar.W.values[k]) + whalf_kpp = self.UpdVar.W.values[i,k+2] + whalf_kp = self.UpdVar.W.values[i,k+1] + whalf_k = self.UpdVar.W.values[i,k] + whalf_k_env = self.EnvVar.W.values[k+1] if whalf_kp<0: sgn_w = 0.0 else: @@ -971,7 +970,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): entr_w = self.entr_sc[i,k+1] detr_w = self.detr_sc[i,k+1] a_k = self.UpdVar.Area.values[i,k+1] - a_km = self.UpdVar.Area.values[i,k] B_k = self.UpdVar.B.values[i,k+1] adv_up = (self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * whalf_kp * whalf_kp * dzi @@ -982,24 +980,28 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): exch = (self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * whalf_kp * ((2*sgn_w-1.0)*entr_w * whalf_k_env - (2*sgn_w-1.0)*detr_w*whalf_kp)) - buoy= self.Ref.rho0_half[k] * a_k * B_k - press_buoy = -1.0 * self.Ref.rho0_half[k] * a_k * B_k * self.pressure_buoy_coeff - press_drag = -1.0 * self.Ref.rho0_half[k] * sqrt(a_k) * (self.pressure_drag_coeff/self.pressure_plume_spacing + buoy= self.Ref.rho0_half[k+1] * a_k * B_k + press_buoy = -1.0 * self.Ref.rho0_half[k+1] * a_k * B_k * self.pressure_buoy_coeff + press_drag = -1.0 * self.Ref.rho0_half[k+1] * sqrt(a_k) * (self.pressure_drag_coeff/self.pressure_plume_spacing *fabs(whalf_k -whalf_k_env) * (whalf_k -whalf_k_env)) press = press_buoy + press_drag - self.updraft_pressure_sink[i,k] = press - w_new[k+1] = (self.Ref.rho0_half[k] * a_k * self.UpdVar.W.values[i,k] * dti_ - -adv + exch + buoy + press)/(self.Ref.rho0_half[k] * self.UpdVar.Area.new[i,k+1] * dti_) + self.updraft_pressure_sink[i,k+1] = press + self.UpdVar.W.new[i,k+1] = (self.Ref.rho0_half[k+1] * a_k * self.UpdVar.W.values[i,k] * dti_ + -adv + exch + buoy + press)/(self.Ref.rho0_half[k+1] * self.UpdVar.Area.new[i,k+1] * dti_) - self.UpdVar.W.new[i,k] =interp2pt(w_new[k+1],w_new[k]) with gil: print self.UpdVar.W.new[i,k] + if self.UpdVar.W.new[i,k+1] <= 0.0: + self.UpdVar.W.new[i,k+1:] = 0.0 + self.UpdVar.Area.new[i,k+1:] = 0.0 + break + else: - self.UpdVar.W.new[i,k:] = 0.0 - self.UpdVar.Area.new[i,k+1] = 0.0 + self.UpdVar.W.new[i,k+1:] = 0.0 + self.UpdVar.Area.new[i,k+1:] = 0.0 # keep this in mind if we modify updraft top treatment! - self.updraft_pressure_sink[i,k] = 0.0 + self.updraft_pressure_sink[i,k+1:] = 0.0 break return @@ -1043,18 +1045,15 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # c1 * phi_new[k] = c2 * phi[k] + c3 * phi[k-1] + c4 * phi_entr if self.UpdVar.Area.new[i,k] >= self.minimum_area: - if interp2pt(self.UpdVar.W.values[i,k-1], self.UpdVar.W.values[i,k])<0: # and interp2pt(self.UpdVar.W.new[i,k-1], self.UpdVar.W.new[i,k])<=0: + if self.UpdVar.W.values[i,k]<0: sgn_w = 0.0 else: sgn_w = 1.0 #sgn_w = 1.0 - m_kp = (self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] - * interp2pt(self.UpdVar.W.values[i,k], self.UpdVar.W.values[i,k+1])) - m_k = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] - * interp2pt(self.UpdVar.W.values[i,k-1], self.UpdVar.W.values[i,k])) - m_km = (self.Ref.rho0_half[k-1] * self.UpdVar.Area.values[i,k-1] - * interp2pt(self.UpdVar.W.values[i,k-2], self.UpdVar.W.values[i,k-1])) + m_kp = (self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1]* self.UpdVar.W.values[i,k+1]) + m_k = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k]) + m_km = (self.Ref.rho0_half[k-1] * self.UpdVar.Area.values[i,k-1] * self.UpdVar.W.values[i,k-1]) c1 = self.Ref.rho0_half[k] * self.UpdVar.Area.new[i,k] * dti_ c2 = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * dti_ @@ -1134,25 +1133,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.QT.new[i,gw] = self.qt_surface_bc[i] #self.UpdVar.W.new[i,gw-1] = 0.0 - #self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, gw, i, self.EnvVar.W.values[gw], 2.0 * dzi) + self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, gw, i, self.EnvVar.W.values[gw], 2.0 * dzi) # here W is calculated at full levels for the first step - later is calcualted as "collocated" and interpolated - a_k = interp2pt(self.UpdVar.Area.values[i,gw], self.UpdVar.Area.values[i,gw+1]) - entr_w = interp2pt(self.entr_sc[i,gw], self.entr_sc[i,gw+1]) - detr_w = interp2pt(self.detr_sc[i,gw], self.detr_sc[i,gw+1]) - B_k = interp2pt(self.UpdVar.B.values[i,gw], self.UpdVar.B.values[i,gw+1]) - adv = self.Ref.rho0[gw] * a_k * self.UpdVar.W.values[i,gw] * self.UpdVar.W.values[i,gw] * dzi - exch = (self.Ref.rho0[gw] * a_k * self.UpdVar.W.values[i,gw] - * (entr_w * self.EnvVar.W.values[gw] - detr_w * self.UpdVar.W.values[i,gw] )) - buoy= self.Ref.rho0[gw] * a_k * B_k - press_buoy = -1.0 * self.Ref.rho0[gw] * a_k * B_k * self.pressure_buoy_coeff - press_drag = -1.0 * self.Ref.rho0[gw] * sqrt(a_k) * (self.pressure_drag_coeff/self.pressure_plume_spacing - * fabs(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])*(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])) - press = press_buoy + press_drag - self.updraft_pressure_sink[i,gw] = press - self.UpdVar.W.new[i,gw] = (self.Ref.rho0[gw] * a_k * self.UpdVar.W.values[i,gw] * dti_ - -adv + exch + buoy + press)/(self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * dti_) - self.UpdVar.W.values[i,gw] = self.UpdVar.W.new[i,gw] sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_half[gw], self.UpdVar.QT.new[i,gw], self.UpdVar.H.new[i,gw]) @@ -1269,7 +1252,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Py_ssize_t k, i Py_ssize_t gw = self.Gr.gw double mf_tend_h=0.0, mf_tend_qt=0.0 - double env_h_interp, env_qt_interp + double env_h_interp, env_qt_interp, dw_kp, dw_k self.massflux_h[:] = 0.0 self.massflux_qt[:] = 0.0 @@ -1278,8 +1261,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for i in xrange(self.n_updrafts): self.m[i,gw-1] = 0.0 for k in xrange(self.Gr.gw, self.Gr.nzg-1): - self.m[i,k] = ((self.UpdVar.W.values[i,k] - self.EnvVar.W.values[k] )* self.Ref.rho0[k] - * interp2pt(self.UpdVar.Area.values[i,k],self.UpdVar.Area.values[i,k+1])) + dw_kp = (self.UpdVar.W.values[i,k+1] - self.EnvVar.W.values[k+1] )#* self.Ref.rho0_c[k+1] * self.UpdVar.Area.values[i,k+1]) + dw_k = (self.UpdVar.W.values[i,k] - self.EnvVar.W.values[k] )#* self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k]) + self.m[i,k] = interp2pt(dw_kp,dw_k)*self.Ref.rho0[k]*interp2pt(self.UpdVar.Area.values[i,k+1],self.UpdVar.Area.values[i,k]) self.massflux_h[gw-1] = 0.0 self.massflux_qt[gw-1] = 0.0 @@ -1501,9 +1485,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): self.tke_entr_gain[k] = 0.0 - w_e = interp2pt(self.EnvVar.W.values[k-1], self.EnvVar.W.values[k]) + w_e = self.EnvVar.W.values[k] for i in xrange(self.n_updrafts): - w_u = interp2pt(self.UpdVar.W.values[i,k-1], self.UpdVar.W.values[i,k]) + w_u = self.UpdVar.W.values[i,k] self.tke_entr_gain[k] += self.UpdVar.Area.values[i,k] * w_u * self.detr_sc[i,k] * (w_u - w_e) * (w_u - w_e) self.tke_entr_gain[k] *= 0.5 * self.Ref.rho0_half[k] return @@ -1518,7 +1502,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): self.tke_detr_loss[k] = 0.0 for i in xrange(self.n_updrafts): - w_u = interp2pt(self.UpdVar.W.values[i,k-1], self.UpdVar.W.values[i,k]) + w_u = self.UpdVar.W.values[i,k] self.tke_detr_loss[k] += self.UpdVar.Area.values[i,k] * w_u * self.entr_sc[i,k] self.tke_detr_loss[k] *= self.Ref.rho0_half[k] * self.EnvVar.TKE.values[k] return @@ -1557,8 +1541,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): self.tke_pressure[k] = 0.0 for i in xrange(self.n_updrafts): - wu_half = interp2pt(self.UpdVar.W.values[i,k-1], self.UpdVar.W.values[i,k]) - we_half = interp2pt(self.EnvVar.W.values[k-1], self.EnvVar.W.values[k]) + wu_half = self.UpdVar.W.values[i,k] + we_half = self.EnvVar.W.values[k] press_buoy= (-1.0 * self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] * self.pressure_buoy_coeff) press_drag = (-1.0 * self.Ref.rho0_half[k] * sqrt(self.UpdVar.Area.values[i,k]) @@ -1590,8 +1574,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(1,nzg-1): rho_ae_K_m[k] = 0.5 * (ae[k]*self.KM.values[k]+ ae[k+1]*self.KM.values[k+1]) * self.Ref.rho0[k] - whalf[k] = interp2pt(self.EnvVar.W.values[k-1], self.EnvVar.W.values[k]) - wu_half = interp2pt(self.UpdVar.W.bulkvalues[gw-1], self.UpdVar.W.bulkvalues[gw]) + whalf[k] = self.EnvVar.W.values[k] + wu_half = self.UpdVar.W.bulkvalues[gw] GMV.TKE.values[gw] = get_surface_tke(Case.Sur.ustar, self.wstar, self.Gr.z_half[gw], Case.Sur.obukhov_length) self.get_env_tke_from_GMV(self.UpdVar.Area, self.UpdVar.W, self.EnvVar.W, self.EnvVar.TKE, &GMV.W.values[0], &GMV.TKE.values[0]) @@ -1605,7 +1589,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): D_env = 0.0 for i in xrange(self.n_updrafts): - wu_half = interp2pt(self.UpdVar.W.values[i,k-1], self.UpdVar.W.values[i,k]) + wu_half = self.UpdVar.W.values[i,k] D_env += self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * wu_half * self.entr_sc[i,k] a[kk] = (- rho_ae_K_m[k-1] * dzi * dzi ) @@ -1629,7 +1613,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for kk in xrange(nz): k = kk + gw self.EnvVar.TKE.values[k] = fmax(x[kk], 0.0) - wu_half = interp2pt(self.UpdVar.W.bulkvalues[k-1], self.UpdVar.W.bulkvalues[k]) + wu_half = self.UpdVar.W.bulkvalues[k] self.get_GMV_TKE(self.UpdVar.Area,self.UpdVar.W, self.EnvVar.W, self.EnvVar.TKE, &GMV.W.values[0], &GMV.TKE.values[0]) @@ -1753,10 +1737,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for i in xrange(self.n_updrafts): H_u = self.UpdVar.H.values[i,k] QT_u = self.UpdVar.QT.values[i,k] - w_u = interp2pt(self.UpdVar.W.values[i,k-1], self.UpdVar.W.values[i,k]) - self.Hvar_entr_gain[k] += self.UpdVar.Area.values[i,k] * w_u * self.detr_sc[i,k] * (H_u - H_env) * (H_u - H_env) - self.QTvar_entr_gain[k] += self.UpdVar.Area.values[i,k] * w_u * self.detr_sc[i,k] * (QT_u - QT_env) * (QT_u - QT_env) - self.HQTcov_entr_gain[k] += self.UpdVar.Area.values[i,k] * w_u * self.detr_sc[i,k] * (H_u - H_env) * (QT_u - QT_env) + self.Hvar_entr_gain[k] += self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.detr_sc[i,k] * (H_u - H_env) * (H_u - H_env) + self.QTvar_entr_gain[k] += self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.detr_sc[i,k] * (QT_u - QT_env) * (QT_u - QT_env) + self.HQTcov_entr_gain[k] += self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.detr_sc[i,k] * (H_u - H_env) * (QT_u - QT_env) self.Hvar_entr_gain[k] *= self.Ref.rho0_half[k] self.QTvar_entr_gain[k] *= self.Ref.rho0_half[k] self.HQTcov_entr_gain[k] *= self.Ref.rho0_half[k] @@ -1772,10 +1755,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.QTvar_detr_loss[k] = 0.0 self.HQTcov_detr_loss[k] = 0.0 for i in xrange(self.n_updrafts): - w_u = interp2pt(self.UpdVar.W.values[i,k-1], self.UpdVar.W.values[i,k]) - self.Hvar_detr_loss[k] += self.UpdVar.Area.values[i,k] * w_u * self.entr_sc[i,k] - self.QTvar_detr_loss[k] += self.UpdVar.Area.values[i,k] * w_u * self.entr_sc[i,k] - self.HQTcov_detr_loss[k] += self.UpdVar.Area.values[i,k] * w_u * self.entr_sc[i,k] + self.Hvar_detr_loss[k] += self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.entr_sc[i,k] + self.QTvar_detr_loss[k] += self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.entr_sc[i,k] + self.HQTcov_detr_loss[k] += self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.entr_sc[i,k] self.Hvar_detr_loss[k] *= self.Ref.rho0_half[k] * self.EnvVar.Hvar.values[k] self.QTvar_detr_loss[k] *= self.Ref.rho0_half[k] * self.EnvVar.QTvar.values[k] self.HQTcov_detr_loss[k] *= self.Ref.rho0_half[k] * self.EnvVar.HQTcov.values[k] @@ -1828,10 +1810,10 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(1,nzg-1): rho_ae_K_m[k] = 0.5 * (ae[k]*self.KH.values[k]+ ae[k+1]*self.KH.values[k+1]) * self.Ref.rho0[k] - whalf[k] = interp2pt(self.EnvVar.W.values[k-1], self.EnvVar.W.values[k]) + whalf[k] = self.EnvVar.W.values[k] Hhalf[k] = self.EnvVar.H.values[k] QThalf[k] = self.EnvVar.QT.values[k] - wu_half = interp2pt(self.UpdVar.W.bulkvalues[gw-1], self.UpdVar.W.bulkvalues[gw]) + wu_half = self.UpdVar.W.bulkvalues[gw] Hu_half = self.UpdVar.H.bulkvalues[gw] QTu_half = self.UpdVar.QT.bulkvalues[gw] @@ -1860,7 +1842,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): D_env = 0.0 for i in xrange(self.n_updrafts): - wu_half = interp2pt(self.UpdVar.W.values[i,k-1], self.UpdVar.W.values[i,k]) + wu_half = self.UpdVar.W.values[i,k] D_env += self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * wu_half * self.entr_sc[i,k] a[kk] = (- rho_ae_K_m[k-1] * dzi * dzi ) @@ -1898,7 +1880,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): D_env = 0.0 for i in xrange(self.n_updrafts): - wu_half = interp2pt(self.UpdVar.W.values[i,k-1], self.UpdVar.W.values[i,k]) + wu_half = self.UpdVar.W.values[i,k] D_env += self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * wu_half * self.entr_sc[i,k] a[kk] = (- rho_ae_K_m[k-1] * dzi * dzi ) diff --git a/Variables.pyx b/Variables.pyx index fb7fe586..009089a4 100644 --- a/Variables.pyx +++ b/Variables.pyx @@ -109,18 +109,10 @@ cdef class VariableDiagnostic: Py_ssize_t start_high = Gr.nzg - Gr.gw - if self.bc == 'sym': - for k in xrange(Gr.gw): - self.values[start_high + k] = self.values[start_high - 1] - self.values[start_low - k] = self.values[start_low + 1] - - else: - self.values[start_high] = 0.0 - self.values[start_low] = 0.0 - for k in xrange(1,Gr.gw): - self.values[start_high+ k] = 0.0 #-self.values[start_high - k ] - self.values[start_low- k] = 0.0 #-self.values[start_low + k ] + for k in xrange(Gr.gw): + self.values[start_high + k] = self.values[start_high - 1] + self.values[start_low - k] = self.values[start_low + 1] return @@ -135,7 +127,7 @@ cdef class GridMeanVariables: self.U = VariablePrognostic(Gr.nzg, 'half', 'velocity', 'sym','u', 'm/s' ) self.V = VariablePrognostic(Gr.nzg, 'half', 'velocity','sym', 'v', 'm/s' ) # Just leave this zero for now! - self.W = VariablePrognostic(Gr.nzg, 'full', 'velocity','sym', 'v', 'm/s' ) + self.W = VariablePrognostic(Gr.nzg, 'half', 'velocity','sym', 'v', 'm/s' ) # Create thermodynamic variables self.QT = VariablePrognostic(Gr.nzg, 'half', 'scalar','sym', 'qt', 'kg/kg') From 462a597c2acf37be141a25a9594cf44daeccd534 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Sun, 23 Sep 2018 19:00:17 -0700 Subject: [PATCH 108/136] turned collocated not running --- EDMF_Environment.pyx | 6 ++--- EDMF_Updrafts.pyx | 4 ++-- Turbulence_PrognosticTKE.pyx | 2 +- Variables.pyx | 46 +++++++++--------------------------- 4 files changed, 17 insertions(+), 41 deletions(-) diff --git a/EDMF_Environment.pyx b/EDMF_Environment.pyx index 5b219779..f208c927 100644 --- a/EDMF_Environment.pyx +++ b/EDMF_Environment.pyx @@ -20,8 +20,8 @@ cdef class EnvironmentVariable: def __init__(self, nz, loc, kind, name, units): self.values = np.zeros((nz,),dtype=np.double, order='c') self.flux = np.zeros((nz,),dtype=np.double, order='c') - if loc != 'half' and loc != 'full': - print('Invalid location setting for variable! Must be half or full') + if loc != 'half': + print('Invalid location setting for variable! Must be half') self.loc = loc if kind != 'scalar' and kind != 'velocity': print ('Invalid kind setting for variable! Must be scalar or velocity') @@ -35,7 +35,7 @@ cdef class EnvironmentVariables: cdef Py_ssize_t nz = Gr.nzg self.Gr = Gr - self.W = EnvironmentVariable(nz, 'full', 'velocity', 'w','m/s' ) + self.W = EnvironmentVariable(nz, 'half', 'velocity', 'w','m/s' ) self.QT = EnvironmentVariable( nz, 'half', 'scalar', 'qt','kg/kg' ) self.QL = EnvironmentVariable( nz, 'half', 'scalar', 'ql','kg/kg' ) self.QR = EnvironmentVariable( nz, 'half', 'scalar', 'qr','kg/kg' ) diff --git a/EDMF_Updrafts.pyx b/EDMF_Updrafts.pyx index 728f82af..f49c0dc7 100644 --- a/EDMF_Updrafts.pyx +++ b/EDMF_Updrafts.pyx @@ -26,8 +26,8 @@ cdef class UpdraftVariable: self.tendencies = np.zeros((nu,nz),dtype=np.double, order='c') self.flux = np.zeros((nu,nz),dtype=np.double, order='c') self.bulkvalues = np.zeros((nz,), dtype=np.double, order = 'c') - if loc != 'half' and loc != 'full': - print('Invalid location setting for variable! Must be half or full') + if loc != 'half': + print('Invalid location setting for variable! Must be half') self.loc = loc if kind != 'scalar' and kind != 'velocity': print ('Invalid kind setting for variable! Must be scalar or velocity') diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index afa7b56d..4f951be3 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -990,7 +990,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): -adv + exch + buoy + press)/(self.Ref.rho0_half[k+1] * self.UpdVar.Area.new[i,k+1] * dti_) with gil: - print self.UpdVar.W.new[i,k] + print self.UpdVar.W.new[i,k+1] if self.UpdVar.W.new[i,k+1] <= 0.0: self.UpdVar.W.new[i,k+1:] = 0.0 diff --git a/Variables.pyx b/Variables.pyx index 009089a4..a9a380d7 100644 --- a/Variables.pyx +++ b/Variables.pyx @@ -25,8 +25,8 @@ cdef class VariablePrognostic: self.mf_update = np.zeros((nz_tot,),dtype=np.double, order='c') self.tendencies = np.zeros((nz_tot,),dtype=np.double, order='c') # Placement on staggered grid - if loc != 'half' and loc != 'full': - print('Invalid location setting for variable! Must be half or full') + if loc != 'half': + print('Invalid location setting for variable! Must be half') self.loc = loc if kind != 'scalar' and kind != 'velocity': print ('Invalid kind setting for variable! Must be scalar or velocity') @@ -50,39 +50,15 @@ cdef class VariablePrognostic: Py_ssize_t start_low = Gr.gw - 1 Py_ssize_t start_high = Gr.nzg - Gr.gw - 1 + for k in xrange(Gr.gw): + self.values[start_high + k +1] = self.values[start_high - k] + self.values[start_low - k] = self.values[start_low + 1 + k] - if self.bc == 'sym': - for k in xrange(Gr.gw): - self.values[start_high + k +1] = self.values[start_high - k] - self.values[start_low - k] = self.values[start_low + 1 + k] - - self.mf_update[start_high + k +1] = self.mf_update[start_high - k] - self.mf_update[start_low - k] = self.mf_update[start_low + 1 + k] - - self.new[start_high + k +1] = self.new[start_high - k] - self.new[start_low - k] = self.new[start_low + 1 + k] - - - - else: - self.values[start_high] = 0.0 - self.values[start_low] = 0.0 - - self.mf_update[start_high] = 0.0 - self.mf_update[start_low] = 0.0 - - self.new[start_high] = 0.0 - self.new[start_low] = 0.0 - - for k in xrange(1,Gr.gw): - self.values[start_high+ k] = -self.values[start_high - k ] - self.values[start_low- k] = -self.values[start_low + k ] - - self.mf_update[start_high+ k] = -self.mf_update[start_high - k ] - self.mf_update[start_low- k] = -self.mf_update[start_low + k ] + self.mf_update[start_high + k +1] = self.mf_update[start_high - k] + self.mf_update[start_low - k] = self.mf_update[start_low + 1 + k] - self.new[start_high+ k] = -self.new[start_high - k ] - self.new[start_low- k] = -self.new[start_low + k ] + self.new[start_high + k +1] = self.new[start_high - k] + self.new[start_low - k] = self.new[start_low + 1 + k] return @@ -92,8 +68,8 @@ cdef class VariableDiagnostic: # Value at the current timestep self.values = np.zeros((nz_tot,),dtype=np.double, order='c') # Placement on staggered grid - if loc != 'half' and loc != 'full': - print('Invalid location setting for variable! Must be half or full') + if loc != 'half': + print('Invalid location setting for variable! Must be half') self.loc = loc if kind != 'scalar' and kind != 'velocity': print ('Invalid kind setting for variable! Must be scalar or velocity') From dc3b5db6f61f7ac6b95bf2d0716f850fb9df4a3b Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Mon, 24 Sep 2018 09:43:13 -0700 Subject: [PATCH 109/136] ... --- Turbulence_PrognosticTKE.pyx | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 4f951be3..7a832c65 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -942,7 +942,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): sgn_w = 0.0 else: sgn_w = 1.0 - #sgn_w = 1.0 + sgn_w = 1.0 entr_term = self.UpdVar.Area.values[i,k+1] * whalf_kp * (2*sgn_w-1.0)*( self.entr_sc[i,k+1]) detr_term = self.UpdVar.Area.values[i,k+1] * whalf_kp * (2*sgn_w-1.0)*(-self.detr_sc[i,k+1]) @@ -954,6 +954,14 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): adv = sgn_w*adv_up + (1.0-sgn_w)*adv_dw self.UpdVar.Area.new[i,k+1] = fmax(dt_ * (adv + entr_term + detr_term) + self.UpdVar.Area.values[i,k+1], 0.0) + if self.UpdVar.Area.new[i,k+1] == 0: + with gil: + print k , self.UpdVar.Area.new[i,k+1],self.UpdVar.Area.new[i,k], adv , entr_term , detr_term + print sgn_w, self.UpdVar.W.values[i,k+1] , self.UpdVar.W.values[i,k], B_k + #plt.figure() + #plt.show() + + if self.UpdVar.Area.new[i,k+1] > au_lim: self.UpdVar.Area.new[i,k+1] = au_lim if self.UpdVar.Area.values[i,k+1] > 0.0: @@ -963,9 +971,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.detr_sc[i,k+1] = (((au_lim-self.UpdVar.Area.values[i,k+1])* dti_ - adv -entr_term)/(-au_lim * whalf_kp)) # Now solve for updraft velocity at k - rho_ratio = self.Ref.rho0[k-1]/self.Ref.rho0[k] - - if self.UpdVar.Area.new[i,k+1] >= self.minimum_area: entr_w = self.entr_sc[i,k+1] detr_w = self.detr_sc[i,k+1] @@ -990,7 +995,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): -adv + exch + buoy + press)/(self.Ref.rho0_half[k+1] * self.UpdVar.Area.new[i,k+1] * dti_) with gil: - print self.UpdVar.W.new[i,k+1] + print k, self.UpdVar.Area.new[i,k+1], self.UpdVar.W.new[i,k+1] if self.UpdVar.W.new[i,k+1] <= 0.0: self.UpdVar.W.new[i,k+1:] = 0.0 @@ -1049,7 +1054,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): sgn_w = 0.0 else: sgn_w = 1.0 - #sgn_w = 1.0 + sgn_w = 1.0 m_kp = (self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1]* self.UpdVar.W.values[i,k+1]) m_k = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k]) From 3b67403efdad847f7833b48fef8058f4b02f66b8 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Mon, 24 Sep 2018 10:30:43 -0700 Subject: [PATCH 110/136] .. --- Surface.pyx | 10 +++++++++- Turbulence_PrognosticTKE.pyx | 18 +++++++++--------- 2 files changed, 18 insertions(+), 10 deletions(-) diff --git a/Surface.pyx b/Surface.pyx index a2969b84..3dfc9250 100644 --- a/Surface.pyx +++ b/Surface.pyx @@ -12,6 +12,7 @@ from surface_functions cimport entropy_flux, compute_ustar, buoyancy_flux from turbulence_functions cimport get_wstar, get_inversion from Variables cimport GridMeanVariables from libc.math cimport cbrt,fabs +import pylab as plt @@ -71,15 +72,22 @@ cdef class SurfaceFixedFlux(SurfaceBase): if self.bflux > 0.0: self.free_convection_windspeed(GMV) else: + print 'Lv = ',latent_heat(self.Tsurface) + print 'cp = ', cpm_c(GMV.QT.values[gw]) print('WARNING: Low windspeed + stable conditions, need to check ustar computation') print('self.bflux ==>',self.bflux ) print('self.shf ==>',self.shf) print('self.lhf ==>',self.lhf) print('GMV.U.values[gw] ==>',GMV.U.values[gw]) - print('GMV.v.values[gw] ==>',GMV.V.values[gw]) + print('GMV.V.values[gw] ==>',GMV.V.values[gw]) print('GMV.QT.values[gw] ==>',GMV.QT.values[gw]) + print('GMV.T.values[gw] ==>',GMV.T.values[gw]) + print('GMV.H.values[gw] ==>',GMV.H.values[gw]) print('self.Ref.alpha0[gw-1] ==>',self.Ref.alpha0[gw-1]) + plt.figure() + plt.show() + self.ustar = compute_ustar(self.windspeed, self.bflux, self.zrough, self.Gr.z_half[gw]) self.obukhov_length = -self.ustar *self.ustar *self.ustar /self.bflux /vkb diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 7a832c65..3ba85522 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -412,9 +412,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.dt_upd = np.minimum(TS.dt, 0.5 * self.Gr.dz/fmax(np.max(self.UpdVar.W.values),1e-10)) while time_elapsed < TS.dt: self.compute_entrainment_detrainment(GMV, Case) - #self.solve_updraft(GMV,Case,TS) - self.solve_updraft_velocity_area(GMV,TS) - self.solve_updraft_scalars(GMV, Case, TS) + self.solve_updraft(GMV,Case,TS) + #self.solve_updraft_velocity_area(GMV,TS) + #self.solve_updraft_scalars(GMV, Case, TS) self.UpdVar.set_values_with_new() time_elapsed += self.dt_upd self.dt_upd = np.minimum(TS.dt-time_elapsed, 0.5 * self.Gr.dz/fmax(np.max(self.UpdVar.W.values),1e-10)) @@ -1156,12 +1156,12 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.upwind_integration(self.UpdVar.Area, self.UpdVar.Area, k, i, 1.0, dzi) if self.UpdVar.Area.new[i,k] >= self.minimum_area: self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, k, i, self.EnvVar.W.values[k],dzi) - # if self.UpdVar.W.new[i,k]<=0: - # print 'clipping',k, self.UpdVar.W.new[i,k],self.UpdVar.Area.new[i,k] - # self.UpdVar.W.new[i,k:]=0.0 - # self.UpdVar.Area.new[i,k:]=0.0 - # self.updraft_pressure_sink[i,k:] = 0.0 - # break + if self.UpdVar.W.new[i,k]<=0: + print 'clipping',k, self.UpdVar.W.new[i,k],self.UpdVar.Area.new[i,k] + self.UpdVar.W.new[i,k:]=0.0 + self.UpdVar.Area.new[i,k:]=0.0 + self.updraft_pressure_sink[i,k:] = 0.0 + break else: self.UpdVar.W.new[i,k] = 0.0 self.UpdVar.Area.new[i,k] = 0.0 From fcb1808aafa25497c06b0c485b3251331accf1ae Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Mon, 24 Sep 2018 10:46:59 -0700 Subject: [PATCH 111/136] add fabs in entr and detr on covarinaces --- Turbulence_PrognosticTKE.pyx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index b586c3bc..e2be91db 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -1339,7 +1339,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): Covar.entr_gain[k] = 0.0 for i in xrange(self.n_updrafts): - Covar.entr_gain[k] += tke_factor*self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.detr_sc[i,k] * \ + Covar.entr_gain[k] += tke_factor*self.UpdVar.Area.values[i,k] * fabs(self.UpdVar.W.values[i,k]) * self.detr_sc[i,k] * \ (UpdVar1.values[i,k] - EnvVar1.values[k]) * (UpdVar2.values[i,k] - EnvVar2.values[k]) Covar.entr_gain[k] *= self.Ref.rho0_c[k] return @@ -1351,7 +1351,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): Covar.detr_loss[k] = 0.0 for i in xrange(self.n_updrafts): - Covar.detr_loss[k] += self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.entr_sc[i,k] + Covar.detr_loss[k] += self.UpdVar.Area.values[i,k] * fabs(self.UpdVar.W.values[i,k]) * self.entr_sc[i,k] Covar.detr_loss[k] *= self.Ref.rho0_c[k] * Covar.values[k] return From b847a25ea60aeaa8fd75f74023038684ce5a1355 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Mon, 24 Sep 2018 10:51:36 -0700 Subject: [PATCH 112/136] add fabs in entr and detr on covarinaces --- Turbulence_PrognosticTKE.pyx | 5 ----- 1 file changed, 5 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index e2be91db..36ea4feb 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -1471,11 +1471,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): np.sum(self.UpdVar.W.new[0,k])*np.sum(self.UpdVar.H.new[0,k])*np.sum(self.UpdVar.QT.new[0,k])*\ np.sum(self.UpdVar.T.new[0,k])*np.sum(self.UpdVar.Area.new[0,k])*np.sum(self.UpdVar.QL.new[0,k]) - # var = np.sum(self.UpdVar.H.values)*np.sum(self.UpdVar.QT.values)*\ - # np.sum(self.UpdVar.T.values)*np.sum(self.UpdVar.Area.values)*np.sum(self.UpdVar.QL.values)*\ - # np.sum(self.UpdVar.W.new)*np.sum(self.UpdVar.H.new)*np.sum(self.UpdVar.QT.new)*\ - # np.sum(self.UpdVar.T.new)*np.sum(self.UpdVar.Area.new)*np.sum(self.UpdVar.QL.new) - if np.isnan(var): print 'nan check' print line, k, var From 0d3c514fbcac703747bf50074db81c7f1cfc59bf Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Mon, 24 Sep 2018 14:47:43 -0700 Subject: [PATCH 113/136] collocated works for Soares with clipping --- Turbulence_PrognosticTKE.pxd | 2 + Turbulence_PrognosticTKE.pyx | 208 +++++++++++++++++++++-------------- 2 files changed, 129 insertions(+), 81 deletions(-) diff --git a/Turbulence_PrognosticTKE.pxd b/Turbulence_PrognosticTKE.pxd index 950ecaf4..8c1481a6 100644 --- a/Turbulence_PrognosticTKE.pxd +++ b/Turbulence_PrognosticTKE.pxd @@ -143,3 +143,5 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): EDMF_Environment.EnvironmentVariable covar_e, double *gmv_phi, double *gmv_psi, double *gmv_covar) + cpdef nan_check(self, line, GridMeanVariables GMV, int k) + diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 3ba85522..0d5a7a6e 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -405,17 +405,22 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cdef: Py_ssize_t iter_ double time_elapsed = 0.0 - + self.nan_check(408, GMV, 2) self.UpdVar.set_new_with_values() self.UpdVar.set_old_with_values() self.set_updraft_surface_bc(GMV, Case) self.dt_upd = np.minimum(TS.dt, 0.5 * self.Gr.dz/fmax(np.max(self.UpdVar.W.values),1e-10)) + self.nan_check(413, GMV, 2) while time_elapsed < TS.dt: + self.nan_check(414, GMV, 2) self.compute_entrainment_detrainment(GMV, Case) - self.solve_updraft(GMV,Case,TS) - #self.solve_updraft_velocity_area(GMV,TS) - #self.solve_updraft_scalars(GMV, Case, TS) + self.nan_check(416, GMV, 2) + #self.solve_updraft(GMV,Case,TS) + #self.nan_check(418, GMV, 2) + self.solve_updraft_velocity_area(GMV,TS) + self.solve_updraft_scalars(GMV, Case, TS) self.UpdVar.set_values_with_new() + self.nan_check(422, GMV, 2) time_elapsed += self.dt_upd self.dt_upd = np.minimum(TS.dt-time_elapsed, 0.5 * self.Gr.dz/fmax(np.max(self.UpdVar.W.values),1e-10)) # (####) @@ -423,9 +428,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # It would be better to have a simple linear rule for updating environment here # instead of calling EnvThermo saturation adjustment scheme for every updraft. # If we are using quadratures this is expensive and probably unnecessary. + self.nan_check(430, GMV, 2) self.decompose_environment(GMV, 'values') self.EnvThermo.satadjust(self.EnvVar, False) self.UpdThermo.buoyancy(self.UpdVar, self.EnvVar, GMV, self.extrapolate_buoyancy) + self.nan_check(432, GMV, 2) return cpdef compute_diagnostic_updrafts(self, GridMeanVariables GMV, CasesBase Case): @@ -909,7 +916,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for i in xrange(self.n_updrafts): - self.entr_sc[i,gw] = 4.0 * dzi + self.entr_sc[i,gw] = 2.0 * dzi self.detr_sc[i,gw] = 0.0 self.UpdVar.Area.new[i,gw] = self.area_surface_bc[i] au_lim = self.area_surface_bc[i] * self.max_area_factor @@ -918,7 +925,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): entr_w = self.entr_sc[i,gw] detr_w = self.detr_sc[i,gw] B_k = self.UpdVar.B.values[i,gw] - adv = self.Ref.rho0_half[gw] * a_k * self.UpdVar.W.values[i,gw] * self.UpdVar.W.values[i,gw] * dzi*2.0 + adv = self.Ref.rho0_half[gw] * a_k * self.UpdVar.W.values[i,gw] * self.UpdVar.W.values[i,gw] * dzi *2.0 exch = (self.Ref.rho0_half[gw] * a_k * self.UpdVar.W.values[i,gw] * (entr_w * self.EnvVar.W.values[gw] - detr_w * self.UpdVar.W.values[i,gw] )) buoy= self.Ref.rho0_half[gw] * a_k * B_k @@ -928,89 +935,87 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): press = press_buoy + press_drag self.updraft_pressure_sink[i,gw] = press self.UpdVar.W.new[i,gw] = (self.Ref.rho0_half[gw] * a_k * self.UpdVar.W.values[i,gw] * dti_ - -adv + exch + buoy + press)/(self.Ref.rho0[gw] * self.UpdVar.Area.values[i,gw] * dti_) + -adv + exch + buoy + press)/(self.Ref.rho0_half[gw] * self.UpdVar.Area.values[i,gw] * dti_) self.UpdVar.W.values[i,gw] = self.UpdVar.W.new[i,gw] - for k in range(gw, self.Gr.nzg-gw): + for k in range(gw+1, self.Gr.nzg-gw): # First solve for updated area fraction at k+1 - whalf_kpp = self.UpdVar.W.values[i,k+2] - whalf_kp = self.UpdVar.W.values[i,k+1] - whalf_k = self.UpdVar.W.values[i,k] - whalf_k_env = self.EnvVar.W.values[k+1] + whalf_kpp = self.UpdVar.W.values[i,k+1] + whalf_kp = self.UpdVar.W.values[i,k] + whalf_k = self.UpdVar.W.values[i,k-1] + whalf_k_env = self.EnvVar.W.values[k] if whalf_kp<0: sgn_w = 0.0 else: sgn_w = 1.0 sgn_w = 1.0 - entr_term = self.UpdVar.Area.values[i,k+1] * whalf_kp * (2*sgn_w-1.0)*( self.entr_sc[i,k+1]) - detr_term = self.UpdVar.Area.values[i,k+1] * whalf_kp * (2*sgn_w-1.0)*(-self.detr_sc[i,k+1]) - - adv_up = -self.Ref.alpha0_half[k+1] * dzi *( self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * whalf_kp - -self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * whalf_k) - adv_dw = -self.Ref.alpha0_half[k+1] * dzi *( self.Ref.rho0_half[k+2] * self.UpdVar.Area.values[i,k+2] * whalf_kpp - -self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * whalf_kp) - adv = sgn_w*adv_up + (1.0-sgn_w)*adv_dw - - self.UpdVar.Area.new[i,k+1] = fmax(dt_ * (adv + entr_term + detr_term) + self.UpdVar.Area.values[i,k+1], 0.0) - if self.UpdVar.Area.new[i,k+1] == 0: - with gil: - print k , self.UpdVar.Area.new[i,k+1],self.UpdVar.Area.new[i,k], adv , entr_term , detr_term - print sgn_w, self.UpdVar.W.values[i,k+1] , self.UpdVar.W.values[i,k], B_k - #plt.figure() - #plt.show() - - - if self.UpdVar.Area.new[i,k+1] > au_lim: - self.UpdVar.Area.new[i,k+1] = au_lim - if self.UpdVar.Area.values[i,k+1] > 0.0: - self.detr_sc[i,k+1] = (((au_lim-self.UpdVar.Area.values[i,k+1])* dti_ - adv -entr_term)/(-self.UpdVar.Area.values[i,k+1] * whalf_kp)) + entr_term = self.UpdVar.Area.values[i,k] * whalf_kp * (2*sgn_w-1.0)*( self.entr_sc[i,k]) + detr_term = self.UpdVar.Area.values[i,k] * whalf_kp * (2*sgn_w-1.0)*(-self.detr_sc[i,k]) + + adv_up = -self.Ref.alpha0_half[k] * dzi *( self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * whalf_kp + -self.Ref.rho0_half[k-1] * self.UpdVar.Area.values[i,k-1] * whalf_k) + #adv_dw = -self.Ref.alpha0_half[k] * dzi *( self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * whalf_kpp + # -self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * whalf_kp) + #adv = sgn_w*adv_up + (1.0-sgn_w)*adv_dw + adv = adv_up + + self.UpdVar.Area.new[i,k] = fmax(dt_ * (adv + entr_term + detr_term) + self.UpdVar.Area.values[i,k], 0.0) + if self.UpdVar.Area.new[i,k] > au_lim: + self.UpdVar.Area.new[i,k] = au_lim + if self.UpdVar.Area.values[i,k] > 0.0: + self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ - adv -entr_term)/(-self.UpdVar.Area.values[i,k] * whalf_kp)) else: # this detrainment rate won't affect scalars but would affect velocity - self.detr_sc[i,k+1] = (((au_lim-self.UpdVar.Area.values[i,k+1])* dti_ - adv -entr_term)/(-au_lim * whalf_kp)) - - # Now solve for updraft velocity at k - if self.UpdVar.Area.new[i,k+1] >= self.minimum_area: - entr_w = self.entr_sc[i,k+1] - detr_w = self.detr_sc[i,k+1] - a_k = self.UpdVar.Area.values[i,k+1] - B_k = self.UpdVar.B.values[i,k+1] - - adv_up = (self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * whalf_kp * whalf_kp * dzi - - self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * whalf_k * whalf_k * dzi) - adv_dw = (self.Ref.rho0_half[k+2] * self.UpdVar.Area.values[i,k+2] * whalf_kpp * whalf_kpp - - self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * whalf_kp * whalf_kp )* dzi - adv = sgn_w*adv_up + (1.0-sgn_w)*adv_dw - - exch = (self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * whalf_kp + self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ - adv -entr_term)/(-au_lim * whalf_kp)) + + + if self.UpdVar.Area.new[i,k] >= self.minimum_area: + entr_w = self.entr_sc[i,k] + detr_w = self.detr_sc[i,k] + a_k = self.UpdVar.Area.values[i,k] + B_k = self.UpdVar.B.values[i,k] + + adv_up = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * whalf_kp * whalf_kp * dzi + - self.Ref.rho0_half[k-1] * self.UpdVar.Area.values[i,k-1] * whalf_k * whalf_k * dzi) + #adv_dw = (self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * whalf_kpp * whalf_kpp + # - self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * whalf_kp * whalf_kp )* dzi + #adv = sgn_w*adv_up + (1.0-sgn_w)*adv_dw + adv = adv_up + + exch = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * whalf_kp * ((2*sgn_w-1.0)*entr_w * whalf_k_env - (2*sgn_w-1.0)*detr_w*whalf_kp)) buoy= self.Ref.rho0_half[k+1] * a_k * B_k - press_buoy = -1.0 * self.Ref.rho0_half[k+1] * a_k * B_k * self.pressure_buoy_coeff - press_drag = -1.0 * self.Ref.rho0_half[k+1] * sqrt(a_k) * (self.pressure_drag_coeff/self.pressure_plume_spacing + press_buoy = -1.0 * self.Ref.rho0_half[k] * a_k * B_k * self.pressure_buoy_coeff + press_drag = -1.0 * self.Ref.rho0_half[k] * sqrt(a_k) * (self.pressure_drag_coeff/self.pressure_plume_spacing *fabs(whalf_k -whalf_k_env) * (whalf_k -whalf_k_env)) press = press_buoy + press_drag - self.updraft_pressure_sink[i,k+1] = press - self.UpdVar.W.new[i,k+1] = (self.Ref.rho0_half[k+1] * a_k * self.UpdVar.W.values[i,k] * dti_ - -adv + exch + buoy + press)/(self.Ref.rho0_half[k+1] * self.UpdVar.Area.new[i,k+1] * dti_) + self.updraft_pressure_sink[i,k] = press + self.UpdVar.W.new[i,k] = (self.Ref.rho0_half[k] * a_k * self.UpdVar.W.values[i,k] * dti_ + -adv + exch + buoy + press)/(self.Ref.rho0_half[k] * self.UpdVar.Area.new[i,k] * dti_) with gil: - print k, self.UpdVar.Area.new[i,k+1], self.UpdVar.W.new[i,k+1] + self.nan_check(1003, GMV,2) + print self.UpdVar.W.new[i,k], B_k + - if self.UpdVar.W.new[i,k+1] <= 0.0: - self.UpdVar.W.new[i,k+1:] = 0.0 - self.UpdVar.Area.new[i,k+1:] = 0.0 + if self.UpdVar.W.new[i,k] <= 0.0: + self.UpdVar.W.new[i,k:] = 0.0 + self.UpdVar.Area.new[i,k:] = 0.0 break + else: - self.UpdVar.W.new[i,k+1:] = 0.0 - self.UpdVar.Area.new[i,k+1:] = 0.0 + self.UpdVar.W.new[i,k:] = 0.0 + self.UpdVar.Area.new[i,k+1] = 0.0 # keep this in mind if we modify updraft top treatment! - self.updraft_pressure_sink[i,k+1:] = 0.0 + self.updraft_pressure_sink[i,k] = 0.0 break return + cpdef solve_updraft_scalars(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS): cdef: Py_ssize_t k, i @@ -1050,14 +1055,14 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # c1 * phi_new[k] = c2 * phi[k] + c3 * phi[k-1] + c4 * phi_entr if self.UpdVar.Area.new[i,k] >= self.minimum_area: - if self.UpdVar.W.values[i,k]<0: + if self.UpdVar.W.values[i,k]<0.0: sgn_w = 0.0 else: sgn_w = 1.0 sgn_w = 1.0 - m_kp = (self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1]* self.UpdVar.W.values[i,k+1]) - m_k = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k]) + m_kp = (self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * self.UpdVar.W.values[i,k+1]) + m_k = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k]) m_km = (self.Ref.rho0_half[k-1] * self.UpdVar.Area.values[i,k-1] * self.UpdVar.W.values[i,k-1]) c1 = self.Ref.rho0_half[k] * self.UpdVar.Area.new[i,k] * dti_ @@ -1140,8 +1145,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): #self.UpdVar.W.new[i,gw-1] = 0.0 self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, gw, i, self.EnvVar.W.values[gw], 2.0 * dzi) - # here W is calculated at full levels for the first step - later is calcualted as "collocated" and interpolated - sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_half[gw], self.UpdVar.QT.new[i,gw], self.UpdVar.H.new[i,gw]) @@ -1156,12 +1159,12 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.upwind_integration(self.UpdVar.Area, self.UpdVar.Area, k, i, 1.0, dzi) if self.UpdVar.Area.new[i,k] >= self.minimum_area: self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, k, i, self.EnvVar.W.values[k],dzi) - if self.UpdVar.W.new[i,k]<=0: - print 'clipping',k, self.UpdVar.W.new[i,k],self.UpdVar.Area.new[i,k] - self.UpdVar.W.new[i,k:]=0.0 - self.UpdVar.Area.new[i,k:]=0.0 - self.updraft_pressure_sink[i,k:] = 0.0 - break + # if self.UpdVar.W.new[i,k]<=0: + # print 'clipping',k, self.UpdVar.W.new[i,k],self.UpdVar.Area.new[i,k] + # self.UpdVar.W.new[i,k:]=0.0 + # self.UpdVar.Area.new[i,k:]=0.0 + # self.updraft_pressure_sink[i,k:] = 0.0 + # break else: self.UpdVar.W.new[i,k] = 0.0 self.UpdVar.Area.new[i,k] = 0.0 @@ -1493,7 +1496,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): w_e = self.EnvVar.W.values[k] for i in xrange(self.n_updrafts): w_u = self.UpdVar.W.values[i,k] - self.tke_entr_gain[k] += self.UpdVar.Area.values[i,k] * w_u * self.detr_sc[i,k] * (w_u - w_e) * (w_u - w_e) + self.tke_entr_gain[k] += self.UpdVar.Area.values[i,k] * fabs(w_u) * self.detr_sc[i,k] * (w_u - w_e) * (w_u - w_e) self.tke_entr_gain[k] *= 0.5 * self.Ref.rho0_half[k] return @@ -1508,7 +1511,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.tke_detr_loss[k] = 0.0 for i in xrange(self.n_updrafts): w_u = self.UpdVar.W.values[i,k] - self.tke_detr_loss[k] += self.UpdVar.Area.values[i,k] * w_u * self.entr_sc[i,k] + self.tke_detr_loss[k] += self.UpdVar.Area.values[i,k] * fabs(w_u) * self.entr_sc[i,k] self.tke_detr_loss[k] *= self.Ref.rho0_half[k] * self.EnvVar.TKE.values[k] return @@ -1742,9 +1745,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for i in xrange(self.n_updrafts): H_u = self.UpdVar.H.values[i,k] QT_u = self.UpdVar.QT.values[i,k] - self.Hvar_entr_gain[k] += self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.detr_sc[i,k] * (H_u - H_env) * (H_u - H_env) - self.QTvar_entr_gain[k] += self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.detr_sc[i,k] * (QT_u - QT_env) * (QT_u - QT_env) - self.HQTcov_entr_gain[k] += self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.detr_sc[i,k] * (H_u - H_env) * (QT_u - QT_env) + self.Hvar_entr_gain[k] += self.UpdVar.Area.values[i,k] * fabs(self.UpdVar.W.values[i,k]) * self.detr_sc[i,k] * (H_u - H_env) * (H_u - H_env) + self.QTvar_entr_gain[k] += self.UpdVar.Area.values[i,k] * fabs(self.UpdVar.W.values[i,k]) * self.detr_sc[i,k] * (QT_u - QT_env) * (QT_u - QT_env) + self.HQTcov_entr_gain[k] += self.UpdVar.Area.values[i,k] * fabs(self.UpdVar.W.values[i,k]) * self.detr_sc[i,k] * (H_u - H_env) * (QT_u - QT_env) self.Hvar_entr_gain[k] *= self.Ref.rho0_half[k] self.QTvar_entr_gain[k] *= self.Ref.rho0_half[k] self.HQTcov_entr_gain[k] *= self.Ref.rho0_half[k] @@ -1760,9 +1763,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.QTvar_detr_loss[k] = 0.0 self.HQTcov_detr_loss[k] = 0.0 for i in xrange(self.n_updrafts): - self.Hvar_detr_loss[k] += self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.entr_sc[i,k] - self.QTvar_detr_loss[k] += self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.entr_sc[i,k] - self.HQTcov_detr_loss[k] += self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.entr_sc[i,k] + self.Hvar_detr_loss[k] += self.UpdVar.Area.values[i,k] * fabs(self.UpdVar.W.values[i,k]) * self.entr_sc[i,k] + self.QTvar_detr_loss[k] += self.UpdVar.Area.values[i,k] * fabs(self.UpdVar.W.values[i,k]) * self.entr_sc[i,k] + self.HQTcov_detr_loss[k] += self.UpdVar.Area.values[i,k] * fabs(self.UpdVar.W.values[i,k]) * self.entr_sc[i,k] self.Hvar_detr_loss[k] *= self.Ref.rho0_half[k] * self.EnvVar.Hvar.values[k] self.QTvar_detr_loss[k] *= self.Ref.rho0_half[k] * self.EnvVar.QTvar.values[k] self.HQTcov_detr_loss[k] *= self.Ref.rho0_half[k] * self.EnvVar.HQTcov.values[k] @@ -1973,4 +1976,47 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.HQTcov_dissipation[k] = (self.Ref.rho0_half[k] * ae[k] * self.EnvVar.HQTcov.values[k] *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0) * self.tke_diss_coeff) + return + + cpdef nan_check(self, line, GridMeanVariables GMV, int k): + cdef: + double var + + var = np.sum(self.UpdVar.W.values[0,k])*np.sum(self.UpdVar.H.values[0,k])*np.sum(self.UpdVar.QT.values[0,k])*\ + np.sum(self.UpdVar.T.values[0,k])*np.sum(self.UpdVar.Area.values[0,k])*np.sum(self.UpdVar.QL.values[0,k])*\ + np.sum(self.EnvVar.T.values[k])*np.sum(self.EnvVar.QL.values[k])*\ + np.sum(self.EnvVar.W.values[k])*np.sum(self.EnvVar.H.values[k])*np.sum(self.EnvVar.QT.values[k])*\ + np.sum(GMV.W.values[k])*np.sum(GMV.H.values[k])*np.sum(GMV.QT.values[k])*\ + np.sum(GMV.T.values[k])*np.sum(GMV.QL.values)*\ + np.sum(self.UpdVar.W.new[0,k])*np.sum(self.UpdVar.H.new[0,k])*np.sum(self.UpdVar.QT.new[0,k])*\ + np.sum(self.UpdVar.T.new[0,k])*np.sum(self.UpdVar.Area.new[0,k])*np.sum(self.UpdVar.QL.new[0,k]) + + if np.isnan(var): + print 'nan check' + print line, k, var + print 'H ',self.UpdVar.H.new[0,k], self.UpdVar.H.values[0,k] + print 'QT ', self.UpdVar.QT.new[0,k],self.UpdVar.QT.values[0,k] + print 'T ', self.UpdVar.T.new[0,k], self.UpdVar.T.values[0,k] + print 'a ', self.UpdVar.Area.new[0,k], self.UpdVar.Area.values[0,k] + print 'QL ', self.UpdVar.QL.new[0,k], self.UpdVar.QL.values[0,k] + print 'W ',self.UpdVar.W.new[0,k], self.UpdVar.W.values[0,k] + print 'GMV.H ',GMV.H.new[k], GMV.H.values[k] + print 'GMV.QT ',GMV.QT.new[k], GMV.QT.values[k] + print 'GMV.T ', GMV.T.values[k] + print 'GMV.QL ', GMV.QL.values[k] + print 'Env', self.EnvVar.T.values[k], self.EnvVar.QL.values[k], self.EnvVar.W.values[k] ,self.EnvVar.H.values[k] ,self.EnvVar.QT.values[k] + + plt.figure() + plt.show() + + if self.UpdVar.QT.new[0,k] < 0: + print 'negative qt', line, k, self.UpdVar.QT.values[0,k] ,self.UpdVar.QT.new[0,k], self.UpdVar.QL.values[0,k] + plt.figure() + plt.show() + if self.UpdVar.H.new[0,k] < 290 or self.UpdVar.H.new[0,k] > 310: + print 'wrong H', line, k, self.UpdVar.H.values[0,k] ,self.UpdVar.H.new[0,k] + plt.figure() + plt.show() + + return \ No newline at end of file From a295d0641e5abf13e82ae23bef0811d38f8da1c2 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Mon, 24 Sep 2018 15:05:35 -0700 Subject: [PATCH 114/136] .. --- Turbulence_PrognosticTKE.pyx | 29 ++++++++++++++--------------- 1 file changed, 14 insertions(+), 15 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 0d5a7a6e..d1e768b5 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -949,17 +949,17 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): sgn_w = 0.0 else: sgn_w = 1.0 - sgn_w = 1.0 + entr_term = self.UpdVar.Area.values[i,k] * whalf_kp * (2*sgn_w-1.0)*( self.entr_sc[i,k]) detr_term = self.UpdVar.Area.values[i,k] * whalf_kp * (2*sgn_w-1.0)*(-self.detr_sc[i,k]) adv_up = -self.Ref.alpha0_half[k] * dzi *( self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * whalf_kp -self.Ref.rho0_half[k-1] * self.UpdVar.Area.values[i,k-1] * whalf_k) - #adv_dw = -self.Ref.alpha0_half[k] * dzi *( self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * whalf_kpp - # -self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * whalf_kp) - #adv = sgn_w*adv_up + (1.0-sgn_w)*adv_dw - adv = adv_up + adv_dw = -self.Ref.alpha0_half[k] * dzi *( self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * whalf_kpp + -self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * whalf_kp) + adv = sgn_w*adv_up + (1.0-sgn_w)*adv_dw + self.UpdVar.Area.new[i,k] = fmax(dt_ * (adv + entr_term + detr_term) + self.UpdVar.Area.values[i,k], 0.0) if self.UpdVar.Area.new[i,k] > au_lim: @@ -979,10 +979,10 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): adv_up = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * whalf_kp * whalf_kp * dzi - self.Ref.rho0_half[k-1] * self.UpdVar.Area.values[i,k-1] * whalf_k * whalf_k * dzi) - #adv_dw = (self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * whalf_kpp * whalf_kpp - # - self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * whalf_kp * whalf_kp )* dzi - #adv = sgn_w*adv_up + (1.0-sgn_w)*adv_dw - adv = adv_up + adv_dw = (self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * whalf_kpp * whalf_kpp + - self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * whalf_kp * whalf_kp )* dzi + adv = sgn_w*adv_up + (1.0-sgn_w)*adv_dw + #adv = adv_up exch = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * whalf_kp * ((2*sgn_w-1.0)*entr_w * whalf_k_env - (2*sgn_w-1.0)*detr_w*whalf_kp)) @@ -996,14 +996,14 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): -adv + exch + buoy + press)/(self.Ref.rho0_half[k] * self.UpdVar.Area.new[i,k] * dti_) with gil: - self.nan_check(1003, GMV,2) + self.nan_check(1003, GMV,k) print self.UpdVar.W.new[i,k], B_k - if self.UpdVar.W.new[i,k] <= 0.0: - self.UpdVar.W.new[i,k:] = 0.0 - self.UpdVar.Area.new[i,k:] = 0.0 - break + # if self.UpdVar.W.new[i,k] <= 0.0: + # self.UpdVar.W.new[i,k:] = 0.0 + # self.UpdVar.Area.new[i,k:] = 0.0 + # break else: @@ -1059,7 +1059,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): sgn_w = 0.0 else: sgn_w = 1.0 - sgn_w = 1.0 m_kp = (self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * self.UpdVar.W.values[i,k+1]) m_k = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k]) From 1d4fc6f35b2239374c3ce4bb49d163b70b69c4cb Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Tue, 25 Sep 2018 12:59:33 -0700 Subject: [PATCH 115/136] unified upwind works for soares with clipping --- Turbulence_PrognosticTKE.pyx | 175 +++++++++++++++++++++++------------ 1 file changed, 117 insertions(+), 58 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index d1e768b5..f575fd2a 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -409,16 +409,16 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.set_new_with_values() self.UpdVar.set_old_with_values() self.set_updraft_surface_bc(GMV, Case) - self.dt_upd = np.minimum(TS.dt, 0.5 * self.Gr.dz/fmax(np.max(self.UpdVar.W.values),1e-10)) + self.dt_upd = np.minimum(TS.dt, 0.2 * self.Gr.dz/fmax(np.max(self.UpdVar.W.values),1e-10)) self.nan_check(413, GMV, 2) while time_elapsed < TS.dt: self.nan_check(414, GMV, 2) self.compute_entrainment_detrainment(GMV, Case) self.nan_check(416, GMV, 2) - #self.solve_updraft(GMV,Case,TS) + self.solve_updraft(GMV,Case,TS) #self.nan_check(418, GMV, 2) - self.solve_updraft_velocity_area(GMV,TS) - self.solve_updraft_scalars(GMV, Case, TS) + #self.solve_updraft_velocity_area(GMV,TS) + #self.solve_updraft_scalars(GMV, Case, TS) self.UpdVar.set_values_with_new() self.nan_check(422, GMV, 2) time_elapsed += self.dt_upd @@ -905,13 +905,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double dzi = self.Gr.dzi double dti_ = 1.0/self.dt_upd double dt_ = 1.0/dti_ - double whalf_kp, whalf_k - double adv_up, adv_dw, whalf_kpp + double adv_up, adv_dw double a1, a2 # groupings of terms in area fraction discrete equation double au_lim - double a_k, a_km, entr_w, detr_w, B_k, entr_term, detr_term, rho_ratio, w_temp, whalf_k_env + double a_k, a_km, entr_w, detr_w, B_k, entr_term, detr_term, rho_ratio double adv, buoy, exch, press, press_buoy, press_drag # groupings of terms in velocity discrete equation - double [:] w_new = np.zeros((self.Gr.nzg,), dtype=np.double, order='c') with nogil: @@ -941,34 +939,31 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for k in range(gw+1, self.Gr.nzg-gw): # First solve for updated area fraction at k+1 - whalf_kpp = self.UpdVar.W.values[i,k+1] - whalf_kp = self.UpdVar.W.values[i,k] - whalf_k = self.UpdVar.W.values[i,k-1] - whalf_k_env = self.EnvVar.W.values[k] - if whalf_kp<0: + if self.UpdVar.W.values[i,k]<0: sgn_w = 0.0 else: sgn_w = 1.0 + sgn_w = 1.0 + entr_term = self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * (2*sgn_w-1.0)*( self.entr_sc[i,k]) + detr_term = self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * (2*sgn_w-1.0)*(-self.detr_sc[i,k]) - entr_term = self.UpdVar.Area.values[i,k] * whalf_kp * (2*sgn_w-1.0)*( self.entr_sc[i,k]) - detr_term = self.UpdVar.Area.values[i,k] * whalf_kp * (2*sgn_w-1.0)*(-self.detr_sc[i,k]) - - adv_up = -self.Ref.alpha0_half[k] * dzi *( self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * whalf_kp - -self.Ref.rho0_half[k-1] * self.UpdVar.Area.values[i,k-1] * whalf_k) - adv_dw = -self.Ref.alpha0_half[k] * dzi *( self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * whalf_kpp - -self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * whalf_kp) - adv = sgn_w*adv_up + (1.0-sgn_w)*adv_dw + adv_up = -self.Ref.alpha0_half[k] * dzi *( self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] + -self.Ref.rho0_half[k-1] * self.UpdVar.Area.values[i,k-1] * self.UpdVar.W.values[i,k-1]) + #adv_dw = -self.Ref.alpha0_half[k] * dzi *( self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * self.UpdVar.W.values[i,k+1] + # -self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k]) + #adv = sgn_w*adv_up + (1.0-sgn_w)*adv_dw + adv = adv_up self.UpdVar.Area.new[i,k] = fmax(dt_ * (adv + entr_term + detr_term) + self.UpdVar.Area.values[i,k], 0.0) if self.UpdVar.Area.new[i,k] > au_lim: self.UpdVar.Area.new[i,k] = au_lim if self.UpdVar.Area.values[i,k] > 0.0: - self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ - adv -entr_term)/(-self.UpdVar.Area.values[i,k] * whalf_kp)) + self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ - adv - (2*sgn_w-1.0)*entr_term)/(-self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k])) else: # this detrainment rate won't affect scalars but would affect velocity - self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ - adv -entr_term)/(-au_lim * whalf_kp)) + self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ - adv - (2*sgn_w-1.0)*entr_term)/(-au_lim * self.UpdVar.W.values[i,k])) if self.UpdVar.Area.new[i,k] >= self.minimum_area: @@ -977,33 +972,33 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): a_k = self.UpdVar.Area.values[i,k] B_k = self.UpdVar.B.values[i,k] - adv_up = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * whalf_kp * whalf_kp * dzi - - self.Ref.rho0_half[k-1] * self.UpdVar.Area.values[i,k-1] * whalf_k * whalf_k * dzi) - adv_dw = (self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * whalf_kpp * whalf_kpp - - self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * whalf_kp * whalf_kp )* dzi - adv = sgn_w*adv_up + (1.0-sgn_w)*adv_dw - #adv = adv_up + adv_up = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] **2 * dzi + - self.Ref.rho0_half[k-1] * self.UpdVar.Area.values[i,k-1] * self.UpdVar.W.values[i,k-1] **2 * dzi) + #adv_dw = (self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * self.UpdVar.W.values[i,k+1]**2 + # - self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k]**2)* dzi + #adv = sgn_w*adv_up + (1.0-sgn_w)*adv_dw + adv = adv_up - exch = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * whalf_kp - * ((2*sgn_w-1.0)*entr_w * whalf_k_env - (2*sgn_w-1.0)*detr_w*whalf_kp)) + exch = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] + * ((2*sgn_w-1.0)*entr_w * self.EnvVar.W.values[k] - (2*sgn_w-1.0)*detr_w*self.UpdVar.W.values[i,k])) buoy= self.Ref.rho0_half[k+1] * a_k * B_k press_buoy = -1.0 * self.Ref.rho0_half[k] * a_k * B_k * self.pressure_buoy_coeff press_drag = -1.0 * self.Ref.rho0_half[k] * sqrt(a_k) * (self.pressure_drag_coeff/self.pressure_plume_spacing - *fabs(whalf_k -whalf_k_env) * (whalf_k -whalf_k_env)) + *fabs(self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k]) * (self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k])) press = press_buoy + press_drag self.updraft_pressure_sink[i,k] = press self.UpdVar.W.new[i,k] = (self.Ref.rho0_half[k] * a_k * self.UpdVar.W.values[i,k] * dti_ -adv + exch + buoy + press)/(self.Ref.rho0_half[k] * self.UpdVar.Area.new[i,k] * dti_) with gil: - self.nan_check(1003, GMV,k) + #self.nan_check(1003, GMV,k) print self.UpdVar.W.new[i,k], B_k - # if self.UpdVar.W.new[i,k] <= 0.0: - # self.UpdVar.W.new[i,k:] = 0.0 - # self.UpdVar.Area.new[i,k:] = 0.0 - # break + if self.UpdVar.W.new[i,k] <= 0.0: + self.UpdVar.W.new[i,k:] = 0.0 + self.UpdVar.Area.new[i,k:] = 0.0 + break else: @@ -1027,6 +1022,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double c1, c2, c3, c4 eos_struct sa double qt_var, h_var + double adv,exch, adv_up, adv_dw with nogil: for i in xrange(self.n_updrafts): @@ -1059,6 +1055,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): sgn_w = 0.0 else: sgn_w = 1.0 + sgn_w = 1.0 m_kp = (self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * self.UpdVar.W.values[i,k+1]) m_k = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k]) @@ -1075,6 +1072,31 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.QT.new[i,k] = (c2 * self.UpdVar.QT.values[i,k] + c3*sgn_w * self.UpdVar.QT.values[i,k-1] + c3*(1.0-sgn_w) * self.UpdVar.QT.values[i,k+1] + c4* QT_entr)/c1 + + # adv_up = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] *self.UpdVar.H.values[i,k] * dzi + # - self.Ref.rho0_half[k-1] * self.UpdVar.Area.values[i,k-1] * self.UpdVar.W.values[i,k-1] *self.UpdVar.H.values[i,k-1] * dzi) + # adv_dw = (self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * self.UpdVar.W.values[i,k+1] *self.UpdVar.H.values[i,k+1] * dzi + # - self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] *self.UpdVar.H.values[i,k] * dzi) + # adv = adv_up + # exch = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] + # * ((2*sgn_w-1.0)*self.entr_sc[i,k] * self.EnvVar.H.values[k] - (2*sgn_w-1.0)*self.detr_sc[i,k]*self.UpdVar.H.values[i,k])) + # self.UpdVar.H.new[i,k] = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.H.values[i,k] * dti_ + # -adv + exch )/(self.Ref.rho0_half[k] * self.UpdVar.Area.new[i,k] * dti_) + # + # adv_up = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] *self.UpdVar.QT.values[i,k] * dzi + # - self.Ref.rho0_half[k-1] * self.UpdVar.Area.values[i,k-1] * self.UpdVar.W.values[i,k-1] *self.UpdVar.QT.values[i,k-1] * dzi) + # adv_dw = (self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * self.UpdVar.W.values[i,k+1] *self.UpdVar.QT.values[i,k+1] * dzi + # - self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] *self.UpdVar.QT.values[i,k] * dzi) + # adv = adv_up + # exch = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] + # * ((2*sgn_w-1.0)*self.entr_sc[i,k] * self.EnvVar.QT.values[k] - (2*sgn_w-1.0)*self.detr_sc[i,k]*self.UpdVar.QT.values[i,k])) + # + # self.UpdVar.QT.new[i,k] = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.QT.values[i,k] * dti_ + # -adv + exch )/(self.Ref.rho0_half[k] * self.UpdVar.Area.new[i,k] * dti_) + + + + else: self.UpdVar.H.new[i,k] = GMV.H.values[k] self.UpdVar.QT.new[i,k] = GMV.QT.values[k] @@ -1127,22 +1149,36 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double dti_ = 1.0/self.dt_upd double dt_ = 1.0/dti_ double a1, a2 # groupings of terms in area fraction discrete equation - double au_lim, sgn_w, adv_up, adv_dw, m_km, m_k, m_kp, a_k, entr_w, detr_w, B_k, w_temp, wf_upd, wf_env - double adv, buoy, exch, press, press_buoy, press_drag, entr_term # groupings of terms in velocity discrete equation + double adv, buoy, exch, press, press_buoy, press_drag , entr_w, detr_w , B_k, a_k# groupings of terms in velocity discrete equation eos_struct sa - double qt_var, h_var - for i in xrange(self.n_updrafts): self.entr_sc[i,gw] = 2.0 * dzi self.detr_sc[i,gw] = 0.0 self.UpdVar.Area.new[i,gw] = self.area_surface_bc[i] - au_lim = self.area_surface_bc[i] * self.max_area_factor self.UpdVar.H.new[i,gw] = self.h_surface_bc[i] self.UpdVar.QT.new[i,gw] = self.qt_surface_bc[i] #self.UpdVar.W.new[i,gw-1] = 0.0 - self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, gw, i, self.EnvVar.W.values[gw], 2.0 * dzi) + #self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, gw, i, self.EnvVar.W.values[gw], 2.0 * dzi) + + + a_k = self.UpdVar.Area.values[i,gw] + entr_w = self.entr_sc[i,gw] + detr_w = self.detr_sc[i,gw] + B_k = self.UpdVar.B.values[i,gw] + adv = self.Ref.rho0_half[gw] * a_k * self.UpdVar.W.values[i,gw] * self.UpdVar.W.values[i,gw] * dzi *2.0 + exch = (self.Ref.rho0_half[gw] * a_k * self.UpdVar.W.values[i,gw] + * (entr_w * self.EnvVar.W.values[gw] - detr_w * self.UpdVar.W.values[i,gw] )) + buoy= self.Ref.rho0_half[gw] * a_k * B_k + press_buoy = -1.0 * self.Ref.rho0_half[gw] * a_k * B_k * self.pressure_buoy_coeff + press_drag = -1.0 * self.Ref.rho0_half[gw] * sqrt(a_k) * (self.pressure_drag_coeff/self.pressure_plume_spacing + * fabs(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])*(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])) + press = press_buoy + press_drag + self.updraft_pressure_sink[i,gw] = press + self.UpdVar.W.new[i,gw] = (self.Ref.rho0_half[gw] * a_k * self.UpdVar.W.values[i,gw] * dti_ + -adv + exch + buoy + press)/(self.Ref.rho0_half[gw] * self.UpdVar.Area.values[i,gw] * dti_) + self.UpdVar.W.values[i,gw] = self.UpdVar.W.new[i,gw] sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_half[gw], self.UpdVar.QT.new[i,gw], self.UpdVar.H.new[i,gw]) @@ -1153,23 +1189,18 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): &self.UpdVar.QT.new[i,gw], &self.UpdVar.QL.new[i,gw], &self.UpdVar.QR.new[i,gw], &self.UpdVar.H.new[i,gw], i, gw) - print self.UpdVar.W.new[i,gw] + for k in range(gw+1, self.Gr.nzg-gw): self.upwind_integration(self.UpdVar.Area, self.UpdVar.Area, k, i, 1.0, dzi) + if self.UpdVar.Area.new[i,k] >= self.minimum_area: self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, k, i, self.EnvVar.W.values[k],dzi) - # if self.UpdVar.W.new[i,k]<=0: - # print 'clipping',k, self.UpdVar.W.new[i,k],self.UpdVar.Area.new[i,k] - # self.UpdVar.W.new[i,k:]=0.0 - # self.UpdVar.Area.new[i,k:]=0.0 - # self.updraft_pressure_sink[i,k:] = 0.0 - # break + else: self.UpdVar.W.new[i,k] = 0.0 self.UpdVar.Area.new[i,k] = 0.0 self.updraft_pressure_sink[i,k] = 0.0 # keep this in mind if we modify updraft top treatment! - if self.UpdVar.Area.new[i,k] >= self.minimum_area: self.upwind_integration(self.UpdVar.Area, self.UpdVar.H, k, i, self.EnvVar.H.values[k], dzi) self.upwind_integration(self.UpdVar.Area, self.UpdVar.QT, k, i, self.EnvVar.QT.values[k], dzi) @@ -1183,6 +1214,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.QL.new[i,k] = sa.ql self.UpdVar.T.new[i,k] = sa.T + self.nan_check(1197, GMV,k) if self.use_local_micro: self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0_half[k], self.UpdVar.T.new[i,k], &self.UpdVar.QT.new[i,k], &self.UpdVar.QL.new[i,k], @@ -1209,13 +1241,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cdef: double dti_ = 1.0/self.dt_upd - double adv, exch, press_buoy, press_drag, au_lim, entr_term - double buoy = 0.0 - double press = 0.0 - double var_kp = 1.0 - double var_k = 1.0 - double var_km = 1.0 - double area_new = 1.0 + double dt_ = self.dt_upd + double adv, exch, press_buoy, press_drag, entr_term, buoy, press + double var_kp ,var_k, var_km, area_new + double au_lim = self.area_surface_bc[i] * self.max_area_factor + double sgn_w = 1.0 if var.name == 'w': buoy = self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] @@ -1228,11 +1258,23 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): var_k = var.values[i,k] var_km = var.values[i,k-1] self.updraft_pressure_sink[i,k] = press + elif var.name == 'thetal' or var.name == 'qt': area_new = area.new[i,k] var_kp = var.values[i,k+1] var_k = var.values[i,k] var_km = var.values[i,k-1] + press = 0.0 + buoy = 0.0 + + elif var.name =='area_fraction': + area_new = 1.0 + var_kp = 1.0 + var_k = 1.0 + var_km = 1.0 + press = 0.0 + buoy = 0.0 + env_var = 1.0 with nogil: if self.UpdVar.W.values[i,k]<0: @@ -1252,6 +1294,23 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): var.new[i,k] = (self.Ref.rho0_half[k] * area.values[i,k] * var_k * dti_ -adv + exch + buoy + press)\ /(self.Ref.rho0_half[k] * area_new * dti_) + if var.name =='area_fraction': + var.new[i,k] = fmax(var.new[i,k] , 0.0) + entr_term = self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * ( self.entr_sc[i,k]) + + if self.UpdVar.Area.new[i,k] > au_lim: + self.UpdVar.Area.new[i,k] = au_lim + if self.UpdVar.Area.values[i,k] > 0.0: + self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ +self.Ref.alpha0_half[k] * adv - entr_term)/(-self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k])) + else: + self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ +self.Ref.alpha0_half[k] * adv - entr_term)/(-au_lim * self.UpdVar.W.values[i,k])) + + if var.name == 'w': + if self.UpdVar.W.new[i,k] <= 0.0: + print 'clipping',k, self.UpdVar.W.new[i,k],self.UpdVar.Area.new[i,k] + self.UpdVar.W.new[i,k] = 0.0 + self.UpdVar.Area.new[i,k] = 0.0 + return cpdef update_GMV_MF(self, GridMeanVariables GMV, TimeStepping TS): From 497afba76d1cfbb1533336c007e9c0f8037a1933 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Tue, 25 Sep 2018 13:18:40 -0700 Subject: [PATCH 116/136] . .. --- Turbulence_PrognosticTKE.pyx | 44 +++++++++++++++++++----------------- 1 file changed, 23 insertions(+), 21 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 36ea4feb..d4f30aa8 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -799,23 +799,16 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): &self.UpdVar.QT.new[i,gw], &self.UpdVar.QL.new[i,gw], &self.UpdVar.QR.new[i,gw], &self.UpdVar.H.new[i,gw], i, gw) - print self.UpdVar.W.new[i,gw] for k in range(gw+1, self.Gr.nzg-gw): self.upwind_integration(self.UpdVar.Area, self.UpdVar.Area, k, i, 1.0, dzi) + if self.UpdVar.Area.new[i,k] >= self.minimum_area: self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, k, i, self.EnvVar.W.values[k],dzi) - if self.UpdVar.W.new[i,k]<=0: - print 'clipping',k, self.UpdVar.W.new[i,k],self.UpdVar.Area.new[i,k] - self.UpdVar.W.new[i,k:]=0.0 - self.UpdVar.Area.new[i,k:]=0.0 - self.updraft_pressure_sink[i,k:] = 0.0 - break else: - self.UpdVar.W.new[i,k:] = 0.0 - self.UpdVar.Area.new[i,k:] = 0.0 - self.updraft_pressure_sink[i,k:] = 0.0 # keep this in mind if we modify updraft top treatment! - break + self.UpdVar.W.new[i,k] = 0.0 + self.UpdVar.Area.new[i,k] = 0.0 + self.updraft_pressure_sink[i,k] = 0.0 # keep this in mind if we modify updraft top treatment! if self.UpdVar.Area.new[i,k] >= self.minimum_area: self.upwind_integration(self.UpdVar.Area, self.UpdVar.H, k, i, self.EnvVar.H.values[k], dzi) @@ -830,6 +823,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.QL.new[i,k] = sa.ql self.UpdVar.T.new[i,k] = sa.T + if self.use_local_micro: self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0_c[k], self.UpdVar.T.new[i,k], &self.UpdVar.QT.new[i,k], &self.UpdVar.QL.new[i,k], @@ -856,7 +850,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cdef: double dti_ = 1.0/self.dt_upd - double adv, exch, press_buoy, press_drag, au_lim, entr_term + double adv, exch, press_buoy, press_drag, entr_term + double au_lim = self.area_surface_bc[i] * self.max_area_factor double buoy = 0.0 double press = 0.0 double var_kp = 1.0 @@ -900,15 +895,22 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): /(self.Ref.rho0_c[k] * area_new * dti_) if var.name =='area_fraction': - with nogil: - au_lim = self.area_surface_bc[i] * self.max_area_factor - if var.new[i,k] > au_lim: - var.new[i,k] = au_lim - entr_term = var.values[i,k]*self.UpdVar.W.values[i,k]*self.entr_sc[i,k] - if var.values[i,k] > 0.0: - self.detr_sc[i,k] = (((au_lim-var.values[i,k])* dti_ - adv - entr_term)/(-var.values[i,k] * self.UpdVar.W.values[i,k])) - else: - self.detr_sc[i,k] = (((au_lim-var.values[i,k])* dti_ - adv - entr_term)/(-au_lim * self.UpdVar.W.values[i,k])) + var.new[i,k] = fmax(var.new[i,k] , 0.0) + entr_term = self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * ( self.entr_sc[i,k]) + + if self.UpdVar.Area.new[i,k] > au_lim: + self.UpdVar.Area.new[i,k] = au_lim + if self.UpdVar.Area.values[i,k] > 0.0: + self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ +self.Ref.alpha0_c[k] * adv - entr_term)/(-self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k])) + else: + self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ +self.Ref.alpha0_c[k] * adv - entr_term)/(-au_lim * self.UpdVar.W.values[i,k])) + + if var.name == 'w': + if self.UpdVar.W.new[i,k] <= 0.0: + print 'clipping',k, self.UpdVar.W.new[i,k],self.UpdVar.Area.new[i,k] + self.UpdVar.W.new[i,k] = 0.0 + self.UpdVar.Area.new[i,k] = 0.0 + return cpdef update_GMV_MF(self, GridMeanVariables GMV, TimeStepping TS): From b47658d0b9920052c0b0a1d439a89f83c273a476 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Tue, 25 Sep 2018 13:36:25 -0700 Subject: [PATCH 117/136] .. --- Turbulence_PrognosticTKE.pyx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index d4f30aa8..32ba5935 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -927,8 +927,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for i in xrange(self.n_updrafts): self.m[i,gw-1] = 0.0 for k in xrange(self.Gr.gw, self.Gr.nzg): - dw_kp = (self.UpdVar.W.values[i,k+1] - self.EnvVar.W.values[k+1] )#* self.Ref.rho0_c[k+1] * self.UpdVar.Area.values[i,k+1]) - dw_k = (self.UpdVar.W.values[i,k] - self.EnvVar.W.values[k] )#* self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k]) + dw_kp = (self.UpdVar.W.values[i,k+1] - self.EnvVar.W.values[k+1] ) + dw_k = (self.UpdVar.W.values[i,k] - self.EnvVar.W.values[k] ) self.m[i,k] = interp2pt(dw_kp,dw_k)*self.Ref.rho0_f[k]*interp2pt(self.UpdVar.Area.values[i,k+1],self.UpdVar.Area.values[i,k]) self.massflux_h[gw-1] = 0.0 From 1f49bbf7d7ae049a9427ec61f273ffd346cc1647 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Tue, 25 Sep 2018 13:37:53 -0700 Subject: [PATCH 118/136] .. --- Turbulence_PrognosticTKE.pyx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index f575fd2a..a7f07171 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -1327,8 +1327,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for i in xrange(self.n_updrafts): self.m[i,gw-1] = 0.0 for k in xrange(self.Gr.gw, self.Gr.nzg-1): - dw_kp = (self.UpdVar.W.values[i,k+1] - self.EnvVar.W.values[k+1] )#* self.Ref.rho0_c[k+1] * self.UpdVar.Area.values[i,k+1]) - dw_k = (self.UpdVar.W.values[i,k] - self.EnvVar.W.values[k] )#* self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k]) + dw_kp = (self.UpdVar.W.values[i,k+1] - self.EnvVar.W.values[k+1] ) + dw_k = (self.UpdVar.W.values[i,k] - self.EnvVar.W.values[k] ) self.m[i,k] = interp2pt(dw_kp,dw_k)*self.Ref.rho0[k]*interp2pt(self.UpdVar.Area.values[i,k+1],self.UpdVar.Area.values[i,k]) self.massflux_h[gw-1] = 0.0 From 05d01ebfea519a28152e78727875ce5debd1ab49 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Tue, 25 Sep 2018 14:29:01 -0700 Subject: [PATCH 119/136] fix min max for HQTcov --- Turbulence_PrognosticTKE.pyx | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index a7f07171..c4a3abc3 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -1933,7 +1933,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for kk in xrange(nz): k = kk + gw - self.EnvVar.Hvar.values[k] = x[kk] + self.EnvVar.Hvar.values[k] = fmax(x[kk], 0.0) GMV.Hvar.values[k] = (ae[k] * (self.EnvVar.Hvar.values[k] + (Hhalf[k]-GMV.H.values[k]) * (Hhalf[k]-GMV.H.values[k])) + self.UpdVar.Area.bulkvalues[k] * (self.UpdVar.H.bulkvalues[k]-GMV.H.values[k]) * (self.UpdVar.H.bulkvalues[k]-GMV.H.values[k])) @@ -1971,8 +1971,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for kk in xrange(nz): k = kk + gw - #self.EnvVar.Hvar.values[k] = fmax(x[kk], 0.0) - self.EnvVar.QTvar.values[k] = x[kk] + self.EnvVar.QTvar.values[k] = fmax(x[kk], 0.0) GMV.QTvar.values[k] = (ae[k] * (self.EnvVar.QTvar.values[k] + (QThalf[k]-GMV.QT.values[k]) * (QThalf[k]-GMV.QT.values[k])) + self.UpdVar.Area.bulkvalues[k] * (self.UpdVar.QT.bulkvalues[k]-GMV.QT.values[k]) * (self.UpdVar.QT.bulkvalues[k]-GMV.QT.values[k])) @@ -2011,7 +2010,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for kk in xrange(nz): k = kk + gw - self.EnvVar.HQTcov.values[k] = x[kk] + self.EnvVar.HQTcov.values[k] = fmax(x[kk], -self.EnvVar.QTvar.values[k]*self.EnvVar.Hvar.values[k]) + self.EnvVar.HQTcov.values[k] = fmin(x[kk], self.EnvVar.QTvar.values[k]*self.EnvVar.Hvar.values[k]) GMV.HQTcov.values[k] = (ae[k] * (self.EnvVar.HQTcov.values[k] + (Hhalf[k]-GMV.H.values[k]) * (QThalf[k]-GMV.QT.values[k])) + self.UpdVar.Area.bulkvalues[k] * (self.UpdVar.H.bulkvalues[k]-GMV.H.values[k]) * (self.UpdVar.QT.bulkvalues[k]-GMV.QT.values[k])) From 47dafa4aafb81f94a987f9339cdd0f3a38d25a38 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Tue, 25 Sep 2018 15:01:04 -0700 Subject: [PATCH 120/136] replace _half by _c and add _f --- Cases.pyx | 298 ++++++++++++++++----------------- EDMF_Environment.pyx | 34 ++-- EDMF_Updrafts.pyx | 28 ++-- Forcing.pyx | 12 +- Grid.pxd | 4 +- Grid.pyx | 8 +- NetCDFIO.pyx | 24 +-- ReferenceState.pxd | 12 +- ReferenceState.pyx | 120 +++++++------- Surface.pyx | 32 ++-- Turbulence.pyx | 22 +-- Turbulence_PrognosticTKE.pyx | 310 +++++++++++++++++------------------ Variables.pyx | 6 +- 13 files changed, 454 insertions(+), 456 deletions(-) diff --git a/Cases.pyx b/Cases.pyx index fde4cf75..5b3e64d5 100644 --- a/Cases.pyx +++ b/Cases.pyx @@ -87,13 +87,13 @@ cdef class Soares(CasesBase): Py_ssize_t k for k in xrange(Gr.gw, Gr.nzg-Gr.gw): - if Gr.z_half[k] <= 1350.0: - GMV.QT.values[k] = 5.0e-3 - 3.7e-4* Gr.z_half[k]/1000.0 + if Gr.z_c[k] <= 1350.0: + GMV.QT.values[k] = 5.0e-3 - 3.7e-4* Gr.z_c[k]/1000.0 theta[k] = 300.0 else: - GMV.QT.values[k] = 5.0e-3 - 3.7e-4 * 1.35 - 9.4e-4 * (Gr.z_half[k]-1350.0)/1000.0 - theta[k] = 300.0 + 2.0 * (Gr.z_half[k]-1350.0)/1000.0 + GMV.QT.values[k] = 5.0e-3 - 3.7e-4 * 1.35 - 9.4e-4 * (Gr.z_c[k]-1350.0)/1000.0 + theta[k] = 300.0 + 2.0 * (Gr.z_c[k]-1350.0)/1000.0 GMV.U.values[k] = 0.01 GMV.U.set_bcs(Gr) @@ -102,14 +102,14 @@ cdef class Soares(CasesBase): if GMV.H.name == 'thetal': for k in xrange(Gr.gw,Gr.nzg-Gr.gw): GMV.H.values[k] = theta[k] - GMV.T.values[k] = theta[k] * exner_c(Ref.p0_half[k]) + GMV.T.values[k] = theta[k] * exner_c(Ref.p0_c[k]) GMV.THL.values[k] = theta[k] elif GMV.H.name == 's': for k in xrange(Gr.gw,Gr.nzg-Gr.gw): - GMV.T.values[k] = theta[k] * exner_c(Ref.p0_half[k]) - GMV.H.values[k] = t_to_entropy_c(Ref.p0_half[k],GMV.T.values[k], + GMV.T.values[k] = theta[k] * exner_c(Ref.p0_c[k]) + GMV.H.values[k] = t_to_entropy_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], ql, qi) - GMV.THL.values[k] = thetali_c(Ref.p0_half[k],GMV.T.values[k], + GMV.THL.values[k] = thetali_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], ql, qi, latent_heat(GMV.T.values[k])) GMV.H.set_bcs(Gr) @@ -122,8 +122,8 @@ cdef class Soares(CasesBase): self.Sur.zrough = 1.0e-4 self.Sur.Tsurface = 300.0 self.Sur.qsurface = 5e-3 - self.Sur.lhf = 2.5e-5 * Ref.rho0[Gr.gw -1] * latent_heat(self.Sur.Tsurface) - self.Sur.shf = 6.0e-2 * cpm_c(self.Sur.qsurface) * Ref.rho0[Gr.gw-1] + self.Sur.lhf = 2.5e-5 * Ref.rho0_f[Gr.gw -1] * latent_heat(self.Sur.Tsurface) + self.Sur.shf = 6.0e-2 * cpm_c(self.Sur.qsurface) * Ref.rho0_f[Gr.gw-1] self.Sur.ustar_fixed = False self.Sur.Gr = Gr self.Sur.Ref = Ref @@ -175,43 +175,43 @@ cdef class Bomex(CasesBase): for k in xrange(Gr.gw,Gr.nzg-Gr.gw): #Set Thetal profile - if Gr.z_half[k] <= 520.: + if Gr.z_c[k] <= 520.: thetal[k] = 298.7 - if Gr.z_half[k] > 520.0 and Gr.z_half[k] <= 1480.0: - thetal[k] = 298.7 + (Gr.z_half[k] - 520) * (302.4 - 298.7)/(1480.0 - 520.0) - if Gr.z_half[k] > 1480.0 and Gr.z_half[k] <= 2000: - thetal[k] = 302.4 + (Gr.z_half[k] - 1480.0) * (308.2 - 302.4)/(2000.0 - 1480.0) - if Gr.z_half[k] > 2000.0: - thetal[k] = 308.2 + (Gr.z_half[k] - 2000.0) * (311.85 - 308.2)/(3000.0 - 2000.0) + if Gr.z_c[k] > 520.0 and Gr.z_c[k] <= 1480.0: + thetal[k] = 298.7 + (Gr.z_c[k] - 520) * (302.4 - 298.7)/(1480.0 - 520.0) + if Gr.z_c[k] > 1480.0 and Gr.z_c[k] <= 2000: + thetal[k] = 302.4 + (Gr.z_c[k] - 1480.0) * (308.2 - 302.4)/(2000.0 - 1480.0) + if Gr.z_c[k] > 2000.0: + thetal[k] = 308.2 + (Gr.z_c[k] - 2000.0) * (311.85 - 308.2)/(3000.0 - 2000.0) #Set qt profile - if Gr.z_half[k] <= 520: - GMV.QT.values[k] = (17.0 + (Gr.z_half[k]) * (16.3-17.0)/520.0)/1000.0 - if Gr.z_half[k] > 520.0 and Gr.z_half[k] <= 1480.0: - GMV.QT.values[k] = (16.3 + (Gr.z_half[k] - 520.0)*(10.7 - 16.3)/(1480.0 - 520.0))/1000.0 - if Gr.z_half[k] > 1480.0 and Gr.z_half[k] <= 2000.0: - GMV.QT.values[k] = (10.7 + (Gr.z_half[k] - 1480.0) * (4.2 - 10.7)/(2000.0 - 1480.0))/1000.0 - if Gr.z_half[k] > 2000.0: - GMV.QT.values[k] = (4.2 + (Gr.z_half[k] - 2000.0) * (3.0 - 4.2)/(3000.0 - 2000.0))/1000.0 + if Gr.z_c[k] <= 520: + GMV.QT.values[k] = (17.0 + (Gr.z_c[k]) * (16.3-17.0)/520.0)/1000.0 + if Gr.z_c[k] > 520.0 and Gr.z_c[k] <= 1480.0: + GMV.QT.values[k] = (16.3 + (Gr.z_c[k] - 520.0)*(10.7 - 16.3)/(1480.0 - 520.0))/1000.0 + if Gr.z_c[k] > 1480.0 and Gr.z_c[k] <= 2000.0: + GMV.QT.values[k] = (10.7 + (Gr.z_c[k] - 1480.0) * (4.2 - 10.7)/(2000.0 - 1480.0))/1000.0 + if Gr.z_c[k] > 2000.0: + GMV.QT.values[k] = (4.2 + (Gr.z_c[k] - 2000.0) * (3.0 - 4.2)/(3000.0 - 2000.0))/1000.0 #Set u profile - if Gr.z_half[k] <= 700.0: + if Gr.z_c[k] <= 700.0: GMV.U.values[k] = -8.75 - if Gr.z_half[k] > 700.0: - GMV.U.values[k] = -8.75 + (Gr.z_half[k] - 700.0) * (-4.61 - -8.75)/(3000.0 - 700.0) + if Gr.z_c[k] > 700.0: + GMV.U.values[k] = -8.75 + (Gr.z_c[k] - 700.0) * (-4.61 - -8.75)/(3000.0 - 700.0) if GMV.H.name == 'thetal': for k in xrange(Gr.gw,Gr.nzg-Gr.gw): GMV.H.values[k] = thetal[k] - GMV.T.values[k] = thetal[k] * exner_c(Ref.p0_half[k]) + GMV.T.values[k] = thetal[k] * exner_c(Ref.p0_c[k]) GMV.THL.values[k] = thetal[k] elif GMV.H.name == 's': for k in xrange(Gr.gw,Gr.nzg-Gr.gw): - GMV.T.values[k] = thetal[k] * exner_c(Ref.p0_half[k]) - GMV.H.values[k] = t_to_entropy_c(Ref.p0_half[k],GMV.T.values[k], + GMV.T.values[k] = thetal[k] * exner_c(Ref.p0_c[k]) + GMV.H.values[k] = t_to_entropy_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], ql, qi) - GMV.THL.values[k] = thetali_c(Ref.p0_half[k],GMV.T.values[k], + GMV.THL.values[k] = thetali_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], ql, qi, latent_heat(GMV.T.values[k])) GMV.U.set_bcs(Gr) @@ -225,8 +225,8 @@ cdef class Bomex(CasesBase): self.Sur.zrough = 1.0e-4 # not actually used, but initialized to reasonable value self.Sur.Tsurface = 299.1 * exner_c(Ref.Pg) self.Sur.qsurface = 22.45e-3 # kg/kg - self.Sur.lhf = 5.2e-5 * Ref.rho0[Gr.gw -1] * latent_heat(self.Sur.Tsurface) - self.Sur.shf = 8.0e-3 * cpm_c(self.Sur.qsurface) * Ref.rho0[Gr.gw-1] + self.Sur.lhf = 5.2e-5 * Ref.rho0_f[Gr.gw -1] * latent_heat(self.Sur.Tsurface) + self.Sur.shf = 8.0e-3 * cpm_c(self.Sur.qsurface) * Ref.rho0_f[Gr.gw-1] self.Sur.ustar_fixed = True self.Sur.ustar = 0.28 # m/s self.Sur.Gr = Gr @@ -240,24 +240,24 @@ cdef class Bomex(CasesBase): cdef Py_ssize_t k for k in xrange(Gr.gw, Gr.nzg-Gr.gw): # Geostrophic velocity profiles. vg = 0 - self.Fo.ug[k] = -10.0 + (1.8e-3)*Gr.z_half[k] + self.Fo.ug[k] = -10.0 + (1.8e-3)*Gr.z_c[k] # Set large-scale cooling - if Gr.z_half[k] <= 1500.0: - self.Fo.dTdt[k] = (-2.0/(3600 * 24.0)) * exner_c(Ref.p0_half[k]) + if Gr.z_c[k] <= 1500.0: + self.Fo.dTdt[k] = (-2.0/(3600 * 24.0)) * exner_c(Ref.p0_c[k]) else: - self.Fo.dTdt[k] = (-2.0/(3600 * 24.0) + (Gr.z_half[k] - 1500.0) - * (0.0 - -2.0/(3600 * 24.0)) / (3000.0 - 1500.0)) * exner_c(Ref.p0_half[k]) + self.Fo.dTdt[k] = (-2.0/(3600 * 24.0) + (Gr.z_c[k] - 1500.0) + * (0.0 - -2.0/(3600 * 24.0)) / (3000.0 - 1500.0)) * exner_c(Ref.p0_c[k]) # Set large-scale drying - if Gr.z_half[k] <= 300.0: + if Gr.z_c[k] <= 300.0: self.Fo.dqtdt[k] = -1.2e-8 #kg/(kg * s) - if Gr.z_half[k] > 300.0 and Gr.z_half[k] <= 500.0: - self.Fo.dqtdt[k] = -1.2e-8 + (Gr.z_half[k] - 300.0)*(0.0 - -1.2e-8)/(500.0 - 300.0) #kg/(kg * s) + if Gr.z_c[k] > 300.0 and Gr.z_c[k] <= 500.0: + self.Fo.dqtdt[k] = -1.2e-8 + (Gr.z_c[k] - 300.0)*(0.0 - -1.2e-8)/(500.0 - 300.0) #kg/(kg * s) #Set large scale subsidence - if Gr.z_half[k] <= 1500.0: - self.Fo.subsidence[k] = 0.0 + Gr.z_half[k]*(-0.65/100.0 - 0.0)/(1500.0 - 0.0) - if Gr.z_half[k] > 1500.0 and Gr.z_half[k] <= 2100.0: - self.Fo.subsidence[k] = -0.65/100 + (Gr.z_half[k] - 1500.0)* (0.0 - -0.65/100.0)/(2100.0 - 1500.0) + if Gr.z_c[k] <= 1500.0: + self.Fo.subsidence[k] = 0.0 + Gr.z_c[k]*(-0.65/100.0 - 0.0)/(1500.0 - 0.0) + if Gr.z_c[k] > 1500.0 and Gr.z_c[k] <= 2100.0: + self.Fo.subsidence[k] = -0.65/100 + (Gr.z_c[k] - 1500.0)* (0.0 - -0.65/100.0)/(2100.0 - 1500.0) return cpdef initialize_io(self, NetCDFIO_Stats Stats): @@ -299,44 +299,44 @@ cdef class life_cycle_Tan2018(CasesBase): double ql=0.0, qi =0.0 # IC of Bomex is cloud-free for k in xrange(Gr.gw,Gr.nzg-Gr.gw): #Set Thetal profile - if Gr.z_half[k] <= 520.: + if Gr.z_c[k] <= 520.: thetal[k] = 298.7 - if Gr.z_half[k] > 520.0 and Gr.z_half[k] <= 1480.0: - thetal[k] = 298.7 + (Gr.z_half[k] - 520) * (302.4 - 298.7)/(1480.0 - 520.0) - if Gr.z_half[k] > 1480.0 and Gr.z_half[k] <= 2000: - thetal[k] = 302.4 + (Gr.z_half[k] - 1480.0) * (308.2 - 302.4)/(2000.0 - 1480.0) - if Gr.z_half[k] > 2000.0: - thetal[k] = 308.2 + (Gr.z_half[k] - 2000.0) * (311.85 - 308.2)/(3000.0 - 2000.0) + if Gr.z_c[k] > 520.0 and Gr.z_c[k] <= 1480.0: + thetal[k] = 298.7 + (Gr.z_c[k] - 520) * (302.4 - 298.7)/(1480.0 - 520.0) + if Gr.z_c[k] > 1480.0 and Gr.z_c[k] <= 2000: + thetal[k] = 302.4 + (Gr.z_c[k] - 1480.0) * (308.2 - 302.4)/(2000.0 - 1480.0) + if Gr.z_c[k] > 2000.0: + thetal[k] = 308.2 + (Gr.z_c[k] - 2000.0) * (311.85 - 308.2)/(3000.0 - 2000.0) #Set qt profile - if Gr.z_half[k] <= 520: - GMV.QT.values[k] = (17.0 + (Gr.z_half[k]) * (16.3-17.0)/520.0)/1000.0 - if Gr.z_half[k] > 520.0 and Gr.z_half[k] <= 1480.0: - GMV.QT.values[k] = (16.3 + (Gr.z_half[k] - 520.0)*(10.7 - 16.3)/(1480.0 - 520.0))/1000.0 - if Gr.z_half[k] > 1480.0 and Gr.z_half[k] <= 2000.0: - GMV.QT.values[k] = (10.7 + (Gr.z_half[k] - 1480.0) * (4.2 - 10.7)/(2000.0 - 1480.0))/1000.0 - if Gr.z_half[k] > 2000.0: - GMV.QT.values[k] = (4.2 + (Gr.z_half[k] - 2000.0) * (3.0 - 4.2)/(3000.0 - 2000.0))/1000.0 + if Gr.z_c[k] <= 520: + GMV.QT.values[k] = (17.0 + (Gr.z_c[k]) * (16.3-17.0)/520.0)/1000.0 + if Gr.z_c[k] > 520.0 and Gr.z_c[k] <= 1480.0: + GMV.QT.values[k] = (16.3 + (Gr.z_c[k] - 520.0)*(10.7 - 16.3)/(1480.0 - 520.0))/1000.0 + if Gr.z_c[k] > 1480.0 and Gr.z_c[k] <= 2000.0: + GMV.QT.values[k] = (10.7 + (Gr.z_c[k] - 1480.0) * (4.2 - 10.7)/(2000.0 - 1480.0))/1000.0 + if Gr.z_c[k] > 2000.0: + GMV.QT.values[k] = (4.2 + (Gr.z_c[k] - 2000.0) * (3.0 - 4.2)/(3000.0 - 2000.0))/1000.0 #Set u profile - if Gr.z_half[k] <= 700.0: + if Gr.z_c[k] <= 700.0: GMV.U.values[k] = -8.75 - if Gr.z_half[k] > 700.0: - GMV.U.values[k] = -8.75 + (Gr.z_half[k] - 700.0) * (-4.61 - -8.75)/(3000.0 - 700.0) + if Gr.z_c[k] > 700.0: + GMV.U.values[k] = -8.75 + (Gr.z_c[k] - 700.0) * (-4.61 - -8.75)/(3000.0 - 700.0) if GMV.H.name == 'thetal': for k in xrange(Gr.gw,Gr.nzg-Gr.gw): GMV.H.values[k] = thetal[k] - GMV.T.values[k] = thetal[k] * exner_c(Ref.p0_half[k]) + GMV.T.values[k] = thetal[k] * exner_c(Ref.p0_c[k]) GMV.THL.values[k] = thetal[k] elif GMV.H.name == 's': for k in xrange(Gr.gw,Gr.nzg-Gr.gw): - GMV.T.values[k] = thetal[k] * exner_c(Ref.p0_half[k]) - GMV.H.values[k] = t_to_entropy_c(Ref.p0_half[k],GMV.T.values[k], + GMV.T.values[k] = thetal[k] * exner_c(Ref.p0_c[k]) + GMV.H.values[k] = t_to_entropy_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], ql, qi) - GMV.THL.values[k] = thetali_c(Ref.p0_half[k],GMV.T.values[k], + GMV.THL.values[k] = thetali_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], ql, qi, latent_heat(GMV.T.values[k])) GMV.U.set_bcs(Gr) @@ -350,8 +350,8 @@ cdef class life_cycle_Tan2018(CasesBase): self.Sur.zrough = 1.0e-4 # not actually used, but initialized to reasonable value self.Sur.Tsurface = 299.1 * exner_c(Ref.Pg) self.Sur.qsurface = 22.45e-3 # kg/kg - self.Sur.lhf = 5.2e-5 * Ref.rho0[Gr.gw -1] * latent_heat(self.Sur.Tsurface) - self.Sur.shf = 8.0e-3 * cpm_c(self.Sur.qsurface) * Ref.rho0[Gr.gw-1] + self.Sur.lhf = 5.2e-5 * Ref.rho0_f[Gr.gw -1] * latent_heat(self.Sur.Tsurface) + self.Sur.shf = 8.0e-3 * cpm_c(self.Sur.qsurface) * Ref.rho0_f[Gr.gw-1] self.lhf0 = self.Sur.lhf self.shf0 = self.Sur.shf self.Sur.ustar_fixed = True @@ -367,24 +367,24 @@ cdef class life_cycle_Tan2018(CasesBase): self.Fo.initialize(GMV) for k in xrange(Gr.gw, Gr.nzg-Gr.gw): # Geostrophic velocity profiles. vg = 0 - self.Fo.ug[k] = -10.0 + (1.8e-3)*Gr.z_half[k] + self.Fo.ug[k] = -10.0 + (1.8e-3)*Gr.z_c[k] # Set large-scale cooling - if Gr.z_half[k] <= 1500.0: - self.Fo.dTdt[k] = (-2.0/(3600 * 24.0)) * exner_c(Ref.p0_half[k]) + if Gr.z_c[k] <= 1500.0: + self.Fo.dTdt[k] = (-2.0/(3600 * 24.0)) * exner_c(Ref.p0_c[k]) else: - self.Fo.dTdt[k] = (-2.0/(3600 * 24.0) + (Gr.z_half[k] - 1500.0) - * (0.0 - -2.0/(3600 * 24.0)) / (3000.0 - 1500.0)) * exner_c(Ref.p0_half[k]) + self.Fo.dTdt[k] = (-2.0/(3600 * 24.0) + (Gr.z_c[k] - 1500.0) + * (0.0 - -2.0/(3600 * 24.0)) / (3000.0 - 1500.0)) * exner_c(Ref.p0_c[k]) # Set large-scale drying - if Gr.z_half[k] <= 300.0: + if Gr.z_c[k] <= 300.0: self.Fo.dqtdt[k] = -1.2e-8 #kg/(kg * s) - if Gr.z_half[k] > 300.0 and Gr.z_half[k] <= 500.0: - self.Fo.dqtdt[k] = -1.2e-8 + (Gr.z_half[k] - 300.0)*(0.0 - -1.2e-8)/(500.0 - 300.0) #kg/(kg * s) + if Gr.z_c[k] > 300.0 and Gr.z_c[k] <= 500.0: + self.Fo.dqtdt[k] = -1.2e-8 + (Gr.z_c[k] - 300.0)*(0.0 - -1.2e-8)/(500.0 - 300.0) #kg/(kg * s) #Set large scale subsidence - if Gr.z_half[k] <= 1500.0: - self.Fo.subsidence[k] = 0.0 + Gr.z_half[k]*(-0.65/100.0 - 0.0)/(1500.0 - 0.0) - if Gr.z_half[k] > 1500.0 and Gr.z_half[k] <= 2100.0: - self.Fo.subsidence[k] = -0.65/100 + (Gr.z_half[k] - 1500.0)* (0.0 - -0.65/100.0)/(2100.0 - 1500.0) + if Gr.z_c[k] <= 1500.0: + self.Fo.subsidence[k] = 0.0 + Gr.z_c[k]*(-0.65/100.0 - 0.0)/(1500.0 - 0.0) + if Gr.z_c[k] > 1500.0 and Gr.z_c[k] <= 2100.0: + self.Fo.subsidence[k] = -0.65/100 + (Gr.z_c[k] - 1500.0)* (0.0 - -0.65/100.0)/(2100.0 - 1500.0) return cpdef initialize_io(self, NetCDFIO_Stats Stats): @@ -432,33 +432,33 @@ cdef class Rico(CasesBase): Py_ssize_t k for k in xrange(Gr.gw,Gr.nzg-Gr.gw): - GMV.U.values[k] = -9.9 + 2.0e-3 * Gr.z_half[k] + GMV.U.values[k] = -9.9 + 2.0e-3 * Gr.z_c[k] GMV.V.values[k] = -3.8 #Set Thetal profile - if Gr.z_half[k] <= 740.0: + if Gr.z_c[k] <= 740.0: thetal[k] = 297.9 else: - thetal[k] = 297.9 + (317.0-297.9)/(4000.0-740.0)*(Gr.z_half[k] - 740.0) + thetal[k] = 297.9 + (317.0-297.9)/(4000.0-740.0)*(Gr.z_c[k] - 740.0) #Set qt profile - if Gr.z_half[k] <= 740.0: - GMV.QT.values[k] = (16.0 + (13.8 - 16.0)/740.0 * Gr.z_half[k])/1000.0 - elif Gr.z_half[k] > 740.0 and Gr.z_half[k] <= 3260.0: - GMV.QT.values[k] = (13.8 + (2.4 - 13.8)/(3260.0-740.0) * (Gr.z_half[k] - 740.0))/1000.0 + if Gr.z_c[k] <= 740.0: + GMV.QT.values[k] = (16.0 + (13.8 - 16.0)/740.0 * Gr.z_c[k])/1000.0 + elif Gr.z_c[k] > 740.0 and Gr.z_c[k] <= 3260.0: + GMV.QT.values[k] = (13.8 + (2.4 - 13.8)/(3260.0-740.0) * (Gr.z_c[k] - 740.0))/1000.0 else: - GMV.QT.values[k] = (2.4 + (1.8-2.4)/(4000.0-3260.0)*(Gr.z_half[k] - 3260.0))/1000.0 + GMV.QT.values[k] = (2.4 + (1.8-2.4)/(4000.0-3260.0)*(Gr.z_c[k] - 3260.0))/1000.0 if GMV.H.name == 'thetal': for k in xrange(Gr.gw,Gr.nzg-Gr.gw): GMV.H.values[k] = thetal[k] - GMV.T.values[k] = thetal[k] * exner_c(Ref.p0_half[k]) + GMV.T.values[k] = thetal[k] * exner_c(Ref.p0_c[k]) GMV.THL.values[k] = thetal[k] elif GMV.H.name == 's': for k in xrange(Gr.gw,Gr.nzg-Gr.gw): - GMV.T.values[k] = thetal[k] * exner_c(Ref.p0_half[k]) - GMV.H.values[k] = t_to_entropy_c(Ref.p0_half[k],GMV.T.values[k], + GMV.T.values[k] = thetal[k] * exner_c(Ref.p0_c[k]) + GMV.H.values[k] = t_to_entropy_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], ql, qi) - GMV.THL.values[k] = thetali_c(Ref.p0_half[k],GMV.T.values[k], + GMV.THL.values[k] = thetali_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], ql, qi, latent_heat(GMV.T.values[k])) GMV.U.set_bcs(Gr) @@ -477,7 +477,7 @@ cdef class Rico(CasesBase): self.Sur.ch = 0.001094 self.Sur.cq = 0.001133 # Adjust for non-IC grid spacing - grid_adjust = (np.log(20.0/self.Sur.zrough)/np.log(Gr.z_half[Gr.gw]/self.Sur.zrough))**2 + grid_adjust = (np.log(20.0/self.Sur.zrough)/np.log(Gr.z_c[Gr.gw]/self.Sur.zrough))**2 self.Sur.cm = self.Sur.cm * grid_adjust self.Sur.ch = self.Sur.ch * grid_adjust self.Sur.cq = self.Sur.cq * grid_adjust @@ -491,20 +491,20 @@ cdef class Rico(CasesBase): self.Fo.initialize(GMV) for k in xrange(Gr.nzg): # Geostrophic velocity profiles - self.Fo.ug[k] = -9.9 + 2.0e-3 * Gr.z_half[k] + self.Fo.ug[k] = -9.9 + 2.0e-3 * Gr.z_c[k] self.Fo.vg[k] = -3.8 # Set large-scale cooling - self.Fo.dTdt[k] = (-2.5/(3600.0 * 24.0)) * exner_c(Ref.p0_half[k]) + self.Fo.dTdt[k] = (-2.5/(3600.0 * 24.0)) * exner_c(Ref.p0_c[k]) # Set large-scale moistening - if Gr.z_half[k] <= 2980.0: - self.Fo.dqtdt[k] = (-1.0 + 1.3456/2980.0 * Gr.z_half[k])/86400.0/1000.0 #kg/(kg * s) + if Gr.z_c[k] <= 2980.0: + self.Fo.dqtdt[k] = (-1.0 + 1.3456/2980.0 * Gr.z_c[k])/86400.0/1000.0 #kg/(kg * s) else: self.Fo.dqtdt[k] = 0.3456/86400.0/1000.0 #Set large scale subsidence - if Gr.z_half[k] <= 2260.0: - self.Fo.subsidence[k] = -(0.005/2260.0) * Gr.z_half[k] + if Gr.z_c[k] <= 2260.0: + self.Fo.subsidence[k] = -(0.005/2260.0) * Gr.z_c[k] else: self.Fo.subsidence[k] = -0.005 return @@ -597,19 +597,19 @@ cdef class TRMM_LBA(CasesBase): 5.32, 1.14, -0.65, 5.27, 5.27]) # interpolate to the model grid-points - p1 = np.interp(Gr.z_half,z_in,p_in) - GMV.U.values = np.interp(Gr.z_half,z_in,u_in) - GMV.V.values = np.interp(Gr.z_half,z_in,v_in) + p1 = np.interp(Gr.z_c,z_in,p_in) + GMV.U.values = np.interp(Gr.z_c,z_in,u_in) + GMV.V.values = np.interp(Gr.z_c,z_in,v_in) # get the entropy from RH, p, T RH = np.zeros(Gr.nzg) - RH[Gr.gw:Gr.nzg-Gr.gw] = np.interp(Gr.z_half[Gr.gw:Gr.nzg-Gr.gw],z_in,RH_in) + RH[Gr.gw:Gr.nzg-Gr.gw] = np.interp(Gr.z_c[Gr.gw:Gr.nzg-Gr.gw],z_in,RH_in) RH[0] = RH[3] RH[1] = RH[2] RH[Gr.nzg-Gr.gw+1] = RH[Gr.nzg-Gr.gw-1] T = np.zeros(Gr.nzg) - T[Gr.gw:Gr.nzg-Gr.gw] = np.interp(Gr.z_half[Gr.gw:Gr.nzg-Gr.gw],z_in,T_in) + T[Gr.gw:Gr.nzg-Gr.gw] = np.interp(Gr.z_c[Gr.gw:Gr.nzg-Gr.gw],z_in,T_in) GMV.T.values = T theta_rho = RH*0.0 epsi = 287.1/461.5 @@ -626,15 +626,15 @@ cdef class TRMM_LBA(CasesBase): qv = GMV.QT.values[k] - GMV.QL.values[k] GMV.QT.values[k] = qv_star*RH[k]/100.0 if GMV.H.name == 's': - GMV.H.values[k] = t_to_entropy_c(Ref.p0_half[k],GMV.T.values[k], + GMV.H.values[k] = t_to_entropy_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], 0.0, 0.0) elif GMV.H.name == 'thetal': - GMV.H.values[k] = thetali_c(Ref.p0_half[k],GMV.T.values[k], + GMV.H.values[k] = thetali_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], 0.0, 0.0, latent_heat(GMV.T.values[k])) - GMV.THL.values[k] = thetali_c(Ref.p0_half[k],GMV.T.values[k], + GMV.THL.values[k] = thetali_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], 0.0, 0.0, latent_heat(GMV.T.values[k])) - theta_rho[k] = theta_rho_c(Ref.p0_half[k], GMV.T.values[k], GMV.QT.values[k], qv) + theta_rho[k] = theta_rho_c(Ref.p0_c[k], GMV.T.values[k], GMV.QT.values[k], qv) GMV.QT.set_bcs(Gr) GMV.H.set_bcs(Gr) @@ -645,8 +645,8 @@ cdef class TRMM_LBA(CasesBase): #self.Sur.zrough = 1.0e-4 # not actually used, but initialized to reasonable value self.Sur.Tsurface = (273.15+23) * exner_c(Ref.Pg) self.Sur.qsurface = 22.45e-3 # kg/kg - self.Sur.lhf = 5.2e-5 * Ref.rho0[Gr.gw -1] * latent_heat(self.Sur.Tsurface) - self.Sur.shf = 8.0e-3 * cpm_c(self.Sur.qsurface) * Ref.rho0[Gr.gw-1] + self.Sur.lhf = 5.2e-5 * Ref.rho0_f[Gr.gw -1] * latent_heat(self.Sur.Tsurface) + self.Sur.shf = 8.0e-3 * cpm_c(self.Sur.qsurface) * Ref.rho0_f[Gr.gw-1] self.Sur.ustar_fixed = True self.Sur.ustar = 0.28 # this is taken from Bomex -- better option is to approximate from LES tke above the surface self.Sur.Gr = Gr @@ -775,9 +775,9 @@ cdef class TRMM_LBA(CasesBase): cdef: Py_ssize_t tt, k, ind1, ind2 - A = np.interp(Gr.z_half,z_in,rad_in[0,:]) + A = np.interp(Gr.z_c,z_in,rad_in[0,:]) for tt in xrange(1,36): - A = np.vstack((A, np.interp(Gr.z_half,z_in,rad_in[tt,:]))) + A = np.vstack((A, np.interp(Gr.z_c,z_in,rad_in[tt,:]))) self.rad = np.multiply(A,1.0) # store matrix in self ind1 = int(mt.trunc(10.0/600.0)) @@ -828,7 +828,7 @@ cdef class TRMM_LBA(CasesBase): self.Fo.dTdt[k] = self.rad[ind1,k] else: # in all other cases - interpolate for k in xrange(self.Fo.Gr.nzg): - if self.Fo.Gr.z_half[k] < 22699.48: + if self.Fo.Gr.z_c[k] < 22699.48: self.Fo.dTdt[k] = (self.rad[ind2,k]-self.rad[ind1,k])\ /(self.rad_time[ind2]-self.rad_time[ind1])\ *(TS.t/60.0-self.rad_time[ind1])+self.rad[ind1,k] @@ -870,22 +870,22 @@ cdef class ARM_SGP(CasesBase): print qt_in # interpolate to the model grid-points - Theta = np.interp(Gr.z_half,z_in,Theta_in) - qt = np.interp(Gr.z_half,z_in,qt_in) + Theta = np.interp(Gr.z_c,z_in,Theta_in) + qt = np.interp(Gr.z_c,z_in,qt_in) for k in xrange(Gr.gw,Gr.nzg-Gr.gw): GMV.U.values[k] = 10.0 GMV.QT.values[k] = qt[k] - GMV.T.values[k] = Theta[k]*exner_c(Ref.p0_half[k]) + GMV.T.values[k] = Theta[k]*exner_c(Ref.p0_c[k]) if GMV.H.name == 's': - GMV.H.values[k] = t_to_entropy_c(Ref.p0_half[k],GMV.T.values[k], + GMV.H.values[k] = t_to_entropy_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], 0.0, 0.0) elif GMV.H.name == 'thetal': - GMV.H.values[k] = thetali_c(Ref.p0_half[k],GMV.T.values[k], + GMV.H.values[k] = thetali_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], 0.0, 0.0, latent_heat(GMV.T.values[k])) - GMV.THL.values[k] = thetali_c(Ref.p0_half[k],GMV.T.values[k], + GMV.THL.values[k] = thetali_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], 0.0, 0.0, latent_heat(GMV.T.values[k])) @@ -958,13 +958,13 @@ cdef class ARM_SGP(CasesBase): double dTdt = np.interp(TS.t,t_in,AT_in) + np.interp(TS.t,t_in,RT_in) double dqtdt = np.interp(TS.t,t_in,Rqt_in) for k in xrange(self.Fo.Gr.nzg): # correct dims - if self.Fo.Gr.z_half[k] <=1000.0: + if self.Fo.Gr.z_c[k] <=1000.0: self.Fo.dTdt[k] = dTdt - self.Fo.dqtdt[k] = dqtdt * exner_c(self.Fo.Ref.p0_half[k]) - elif self.Fo.Gr.z_half[k] > 1000.0 and self.Fo.Gr.z_half[k] <= 2000.0: - self.Fo.dTdt[k] = dTdt*(1-(self.Fo.Gr.z_half[k]-1000.0)/1000.0) - self.Fo.dqtdt[k] = dqtdt * exner_c(self.Fo.Ref.p0_half[k])\ - *(1-(self.Fo.Gr.z_half[k]-1000.0)/1000.0) + self.Fo.dqtdt[k] = dqtdt * exner_c(self.Fo.Ref.p0_c[k]) + elif self.Fo.Gr.z_c[k] > 1000.0 and self.Fo.Gr.z_c[k] <= 2000.0: + self.Fo.dTdt[k] = dTdt*(1-(self.Fo.Gr.z_c[k]-1000.0)/1000.0) + self.Fo.dqtdt[k] = dqtdt * exner_c(self.Fo.Ref.p0_c[k])\ + *(1-(self.Fo.Gr.z_c[k]-1000.0)/1000.0) self.Fo.update(GMV) return @@ -1013,9 +1013,9 @@ cdef class GATE_III(CasesBase): z_T_in = np.array([0.0, 0.492, 0.700, 1.698, 3.928, 6.039, 7.795, 9.137, 11.055, 12.645, 13.521, 14.486, 15.448, 16.436, 17.293, 22.0])*1000.0 # for km # interpolate to the model grid-points - T = np.interp(Gr.z_half,z_T_in,T_in) # interpolate to ref pressure level - qt = np.interp(Gr.z_half,z_in,qt_in) - U = np.interp(Gr.z_half,z_in,U_in) + T = np.interp(Gr.z_c,z_T_in,T_in) # interpolate to ref pressure level + qt = np.interp(Gr.z_c,z_in,qt_in) + U = np.interp(Gr.z_c,z_in,U_in) for k in xrange(Gr.gw,Gr.nzg-Gr.gw): @@ -1024,13 +1024,13 @@ cdef class GATE_III(CasesBase): GMV.U.values[k] = U[k] if GMV.H.name == 's': - GMV.H.values[k] = t_to_entropy_c(Ref.p0_half[k],GMV.T.values[k], + GMV.H.values[k] = t_to_entropy_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], 0.0, 0.0) elif GMV.H.name == 'thetal': - GMV.H.values[k] = thetali_c(Ref.p0_half[k],GMV.T.values[k], + GMV.H.values[k] = thetali_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], 0.0, 0.0, latent_heat(GMV.T.values[k])) - GMV.THL.values[k] = thetali_c(Ref.p0_half[k],GMV.T.values[k], + GMV.THL.values[k] = thetali_c(Ref.p0_c[k],GMV.T.values[k], GMV.QT.values[k], 0.0, 0.0, latent_heat(GMV.T.values[k])) GMV.U.set_bcs(Gr) GMV.QT.set_bcs(Gr) @@ -1078,8 +1078,8 @@ cdef class GATE_III(CasesBase): Qtend_in = np.divide(r_tend_in,(1+r_tend_in)) # convert mixing ratio to specific humidity - self.Fo.dqtdt = np.interp(Gr.z_half,z_in,Qtend_in) - self.Fo.dTdt = np.interp(Gr.z_half,z_in,Ttend_in) + np.interp(Gr.z_half,z_in,RAD_in) + self.Fo.dqtdt = np.interp(Gr.z_c,z_in,Qtend_in) + self.Fo.dTdt = np.interp(Gr.z_c,z_in,Ttend_in) + np.interp(Gr.z_c,z_in,RAD_in) return @@ -1180,35 +1180,35 @@ cdef class DYCOMS_RF01(CasesBase): for k in xrange(Gr.gw, Gr.nzg-Gr.gw): # thetal profile as defined in DYCOMS - if Gr.z_half[k] <= 840.0: + if Gr.z_c[k] <= 840.0: thetal[k] = 289.0 - if Gr.z_half[k] > 840.0: - thetal[k] = (297.5 + (Gr.z_half[k] - 840.0)**(1.0/3.0)) + if Gr.z_c[k] > 840.0: + thetal[k] = (297.5 + (Gr.z_c[k] - 840.0)**(1.0/3.0)) # qt profile as defined in DYCOMS - if Gr.z_half[k] <= 840.0: + if Gr.z_c[k] <= 840.0: GMV.QT.values[k] = 9. / 1000.0 - if Gr.z_half[k] > 840.0: + if Gr.z_c[k] > 840.0: GMV.QT.values[k] = 1.5 / 1000.0 # ql and T profile # (calculated by saturation adjustment using thetal and qt values provided in DYCOMS # and using Rd, cp and L constants as defined in DYCOMS) - GMV.T.values[k], GMV.QL.values[k] = self.dycoms_sat_adjst(Ref.p0_half[k], thetal[k], GMV.QT.values[k]) + GMV.T.values[k], GMV.QL.values[k] = self.dycoms_sat_adjst(Ref.p0_c[k], thetal[k], GMV.QT.values[k]) # thermodynamic variable profile (either entropy or thetal) # (calculated based on T and ql profiles. # Here we use Rd, cp and L constants as defined in scampy) - GMV.THL.values[k] = t_to_thetali_c(Ref.p0_half[k], GMV.T.values[k], GMV.QT.values[k], GMV.QL.values[k], qi) + GMV.THL.values[k] = t_to_thetali_c(Ref.p0_c[k], GMV.T.values[k], GMV.QT.values[k], GMV.QL.values[k], qi) if GMV.H.name == 'thetal': - GMV.H.values[k] = t_to_thetali_c(Ref.p0_half[k], GMV.T.values[k], GMV.QT.values[k], GMV.QL.values[k], qi) + GMV.H.values[k] = t_to_thetali_c(Ref.p0_c[k], GMV.T.values[k], GMV.QT.values[k], GMV.QL.values[k], qi) elif GMV.H.name == 's': - GMV.H.values[k] = t_to_entropy_c(Ref.p0_half[k], GMV.T.values[k], GMV.QT.values[k], GMV.QL.values[k], qi) + GMV.H.values[k] = t_to_entropy_c(Ref.p0_c[k], GMV.T.values[k], GMV.QT.values[k], GMV.QL.values[k], qi) # buoyancy profile qv = GMV.QT.values[k] - qi - GMV.QL.values[k] - alpha = alpha_c(Ref.p0_half[k], GMV.T.values[k], GMV.QT.values[k], qv) - GMV.B.values[k] = buoyancy_c(Ref.alpha0_half[k], alpha) + alpha = alpha_c(Ref.p0_c[k], GMV.T.values[k], GMV.QT.values[k], qv) + GMV.B.values[k] = buoyancy_c(Ref.alpha0_c[k], alpha) # velocity profile (geostrophic) GMV.U.values[k] = 7.0 @@ -1241,8 +1241,8 @@ cdef class DYCOMS_RF01(CasesBase): #density_surface = 1.22 # kg/m^3 # buoyancy flux - theta_flux = self.Sur.shf / cpm_c(self.Sur.qsurface) / Ref.rho0[Gr.gw-1] - qt_flux = self.Sur.lhf / latent_heat(self.Sur.Tsurface) / Ref.rho0[Gr.gw-1] + theta_flux = self.Sur.shf / cpm_c(self.Sur.qsurface) / Ref.rho0_f[Gr.gw-1] + qt_flux = self.Sur.lhf / latent_heat(self.Sur.Tsurface) / Ref.rho0_f[Gr.gw-1] theta_surface = self.Sur.Tsurface / exner_c(Ref.Pg) self.Sur.bflux = g * ((theta_flux + (eps_vi - 1.0) * (theta_surface * qt_flux + self.Sur.qsurface * theta_flux)) / (theta_surface * (1.0 + (eps_vi-1) * self.Sur.qsurface))) @@ -1266,7 +1266,7 @@ cdef class DYCOMS_RF01(CasesBase): # To be able to have self.Fo.divergence available here, # we would have to change the signature of ForcingBase class for k in xrange(Gr.gw, Gr.nzg-Gr.gw): - self.Fo.subsidence[k] = - Gr.z_half[k] * divergence + self.Fo.subsidence[k] = - Gr.z_c[k] * divergence # no large-scale drying self.Fo.dqtdt[:] = 0. #kg/(kg * s) diff --git a/EDMF_Environment.pyx b/EDMF_Environment.pyx index f208c927..a684a134 100644 --- a/EDMF_Environment.pyx +++ b/EDMF_Environment.pyx @@ -186,7 +186,7 @@ cdef class EnvironmentThermodynamics: EnvVar.QT.values[k] = qt EnvVar.QL.values[k] = ql EnvVar.QR.values[k] += qr - EnvVar.B.values[k] = buoyancy_c(self.Ref.alpha0_half[k], alpha) + EnvVar.B.values[k] = buoyancy_c(self.Ref.alpha0_c[k], alpha) return cdef void update_cloud_dry(self, long k, EnvironmentVariables EnvVar, double T, double th, double qt, double ql, double qv) nogil : @@ -218,8 +218,8 @@ cdef class EnvironmentThermodynamics: with nogil: for k in xrange(gw,self.Gr.nzg-gw): # condensation + autoconversion - sa = eos(self.t_to_prog_fp, self.prog_to_t_fp, self.Ref.p0_half[k], EnvVar.QT.values[k], EnvVar.H.values[k]) - mph = microphysics(sa.T, sa.ql, self.Ref.p0_half[k], EnvVar.QT.values[k], self.max_supersaturation, in_Env) + sa = eos(self.t_to_prog_fp, self.prog_to_t_fp, self.Ref.p0_c[k], EnvVar.QT.values[k], EnvVar.H.values[k]) + mph = microphysics(sa.T, sa.ql, self.Ref.p0_c[k], EnvVar.QT.values[k], self.max_supersaturation, in_Env) self.update_EnvVar( k, EnvVar, mph.T, mph.thl, mph.qt, mph.ql, mph.qr, mph.alpha) self.update_cloud_dry(k, EnvVar, mph.T, mph.th, mph.qt, mph.ql, mph.qv) @@ -314,8 +314,8 @@ cdef class EnvironmentThermodynamics: h_hat = sqrt2 * sigma_h_star * abscissas[m_h] + mu_h_star # condensation + autoconversion - sa = eos(self.t_to_prog_fp, self.prog_to_t_fp, self.Ref.p0_half[k], qt_hat, h_hat) - mph = microphysics(sa.T, sa.ql, self.Ref.p0_half[k], qt_hat, self.max_supersaturation, in_Env) + sa = eos(self.t_to_prog_fp, self.prog_to_t_fp, self.Ref.p0_c[k], qt_hat, h_hat) + mph = microphysics(sa.T, sa.ql, self.Ref.p0_c[k], qt_hat, self.max_supersaturation, in_Env) # environmental variables inner_env[i_ql] += mph.ql * weights[m_h] * sqpi_inv @@ -353,11 +353,11 @@ cdef class EnvironmentThermodynamics: # update cloudy/dry variables for buoyancy in TKE EnvVar.CF.values[k] = outer_env[i_cf] self.qt_dry[k] = outer_env[i_qt_dry] - self.th_dry[k] = theta_c(self.Ref.p0_half[k], outer_env[i_T_dry]) + self.th_dry[k] = theta_c(self.Ref.p0_c[k], outer_env[i_T_dry]) self.t_cloudy[k] = outer_env[i_T_cld] self.qv_cloudy[k] = outer_env[i_qt_cld] - outer_env[i_ql] self.qt_cloudy[k] = outer_env[i_qt_cld] - self.th_cloudy[k] = theta_c(self.Ref.p0_half[k], outer_env[i_T_cld]) + self.th_cloudy[k] = theta_c(self.Ref.p0_c[k], outer_env[i_T_cld]) # update var/covar rain sources if in_Env: self.Hvar_rain_dt[k] = outer_src[i_SH_H] - outer_src[i_SH] * EnvVar.H.values[k] @@ -367,8 +367,8 @@ cdef class EnvironmentThermodynamics: else: # the same as in SA_mean - sa = eos(self.t_to_prog_fp, self.prog_to_t_fp, self.Ref.p0_half[k], EnvVar.QT.values[k], EnvVar.H.values[k]) - mph = microphysics(sa.T, sa.ql, self.Ref.p0_half[k], EnvVar.QT.values[k], self.max_supersaturation, in_Env) + sa = eos(self.t_to_prog_fp, self.prog_to_t_fp, self.Ref.p0_c[k], EnvVar.QT.values[k], EnvVar.H.values[k]) + mph = microphysics(sa.T, sa.ql, self.Ref.p0_c[k], EnvVar.QT.values[k], self.max_supersaturation, in_Env) self.update_EnvVar( k, EnvVar, mph.T, mph.thl, mph.qt, mph.ql, mph.qr, mph.alpha) self.update_cloud_dry(k, EnvVar, mph.T, mph.th, mph.qt, mph.ql, mph.qv) @@ -394,13 +394,13 @@ cdef class EnvironmentThermodynamics: Lv = latent_heat(EnvVar.T.values[k]) cp = cpd # paper notation used below - Tl = EnvVar.H.values[k]*exner_c(self.Ref.p0_half[k]) - q_sl = qv_star_t(self.Ref.p0[k], Tl) # using the qv_star_c function instead of the approximation in eq. (4) in SD + Tl = EnvVar.H.values[k]*exner_c(self.Ref.p0_c[k]) + q_sl = qv_star_t(self.Ref.p0_c[k], Tl) # using the qv_star_c function instead of the approximation in eq. (4) in SD beta1 = 0.622*Lv**2/(Rd*cp*Tl**2) # eq. (8) in SD #q_s = q_sl*(1+beta1*EnvVar.QT.values[k])/(1+beta1*q_sl) # eq. (7) in SD lambda1 = 1/(1+beta1*q_sl) # text under eq. (20) in SD # check the pressure units - mb vs pa - alpha1 = (self.Ref.p0[k]/100000.0)**0.286*0.622*Lv*q_sl/Rd/Tl**2 # eq. (14) and eq. (6) in SD + alpha1 = (self.Ref.p0_c[k]/100000.0)**0.286*0.622*Lv*q_sl/Rd/Tl**2 # eq. (14) and eq. (6) in SD # see if there is another way to calculate dq/dT from scmapy sigma1 = EnvVar.QTvar.values[k]-2*alpha1*EnvVar.HQTcov.values[k]+alpha1**2*EnvVar.Hvar.values[k] # eq. (18) in SD , with r from (11) Q1 = (EnvVar.QT.values[k]-q_sl)/sigma1 # eq. (17) in SD @@ -419,17 +419,17 @@ cdef class EnvironmentThermodynamics: EnvVar.T.values[k] = Tl + Lv/cp*EnvVar.QL.values[k] # should this be the differnece in ql - would it work for evaporation as well ? EnvVar.CF.values[k] = R qv = EnvVar.QT.values[k] - EnvVar.QL.values[k] - alpha = alpha_c(self.Ref.p0_half[k], EnvVar.T.values[k], EnvVar.QT.values[k], qv) - EnvVar.B.values[k] = buoyancy_c(self.Ref.alpha0_half[k], alpha) - EnvVar.THL.values[k] = t_to_thetali_c(self.Ref.p0_half[k], EnvVar.T.values[k], EnvVar.QT.values[k], + alpha = alpha_c(self.Ref.p0_c[k], EnvVar.T.values[k], EnvVar.QT.values[k], qv) + EnvVar.B.values[k] = buoyancy_c(self.Ref.alpha0_c[k], alpha) + EnvVar.THL.values[k] = t_to_thetali_c(self.Ref.p0_c[k], EnvVar.T.values[k], EnvVar.QT.values[k], EnvVar.QL.values[k], 0.0) self.qt_dry[k] = EnvVar.QT.values[k] - self.th_dry[k] = EnvVar.T.values[k]/exner_c(self.Ref.p0_half[k]) + self.th_dry[k] = EnvVar.T.values[k]/exner_c(self.Ref.p0_c[k]) self.t_cloudy[k] = EnvVar.T.values[k] self.qv_cloudy[k] = EnvVar.QT.values[k] - EnvVar.QL.values[k] self.qt_cloudy[k] = EnvVar.QT.values[k] - self.th_cloudy[k] = EnvVar.T.values[k]/exner_c(self.Ref.p0_half[k]) + self.th_cloudy[k] = EnvVar.T.values[k]/exner_c(self.Ref.p0_c[k]) #using the approximation in eq. (25) in SD, noting that in the paper there is a typo in the first # condition and 1.6 there should be -1.6 diff --git a/EDMF_Updrafts.pyx b/EDMF_Updrafts.pyx index f49c0dc7..07c9bb82 100644 --- a/EDMF_Updrafts.pyx +++ b/EDMF_Updrafts.pyx @@ -258,14 +258,14 @@ cdef class UpdraftVariables: cdef Py_ssize_t i, k for i in xrange(self.n_updrafts): - # Todo check the setting of ghost point z_half - self.cloud_base[i] = self.Gr.z_half[self.Gr.nzg-self.Gr.gw-1] + # Todo check the setting of ghost point z_c + self.cloud_base[i] = self.Gr.z_c[self.Gr.nzg-self.Gr.gw-1] self.cloud_top[i] = 0.0 self.cloud_cover[i] = 0.0 for k in xrange(self.Gr.gw,self.Gr.nzg-self.Gr.gw): if self.QL.values[i,k] > 1e-8 and self.Area.values[i,k] > 1e-3: - self.cloud_base[i] = fmin(self.cloud_base[i], self.Gr.z_half[k]) - self.cloud_top[i] = fmax(self.cloud_top[i], self.Gr.z_half[k]) + self.cloud_base[i] = fmin(self.cloud_base[i], self.Gr.z_c[k]) + self.cloud_top[i] = fmax(self.cloud_top[i], self.Gr.z_c[k]) self.cloud_cover[i] = fmax(self.cloud_cover[i], self.Area.values[i,k]) @@ -293,7 +293,7 @@ cdef class UpdraftThermodynamics: with nogil: for i in xrange(self.n_updraft): for k in xrange(self.Gr.nzg): - sa = eos(self.t_to_prog_fp,self.prog_to_t_fp, self.Ref.p0_half[k], + sa = eos(self.t_to_prog_fp,self.prog_to_t_fp, self.Ref.p0_c[k], UpdVar.QT.values[i,k], UpdVar.H.values[i,k]) UpdVar.QL.values[i,k] = sa.ql UpdVar.T.values[i,k] = sa.T @@ -313,8 +313,8 @@ cdef class UpdraftThermodynamics: for i in xrange(self.n_updraft): for k in xrange(self.Gr.nzg): qv = UpdVar.QT.values[i,k] - UpdVar.QL.values[i,k] - alpha = alpha_c(self.Ref.p0_half[k], UpdVar.T.values[i,k], UpdVar.QT.values[i,k], qv) - UpdVar.B.values[i,k] = buoyancy_c(self.Ref.alpha0_half[k], alpha) #- GMV.B.values[k] + alpha = alpha_c(self.Ref.p0_c[k], UpdVar.T.values[i,k], UpdVar.QT.values[i,k], qv) + UpdVar.B.values[i,k] = buoyancy_c(self.Ref.alpha0_c[k], alpha) #- GMV.B.values[k] else: with nogil: for i in xrange(self.n_updraft): @@ -324,17 +324,17 @@ cdef class UpdraftThermodynamics: qv = UpdVar.QT.values[i,k] - UpdVar.QL.values[i,k] h = UpdVar.H.values[i,k] t = UpdVar.T.values[i,k] - alpha = alpha_c(self.Ref.p0_half[k], t, qt, qv) - UpdVar.B.values[i,k] = buoyancy_c(self.Ref.alpha0_half[k], alpha) + alpha = alpha_c(self.Ref.p0_c[k], t, qt, qv) + UpdVar.B.values[i,k] = buoyancy_c(self.Ref.alpha0_c[k], alpha) else: - sa = eos(self.t_to_prog_fp, self.prog_to_t_fp, self.Ref.p0_half[k], + sa = eos(self.t_to_prog_fp, self.prog_to_t_fp, self.Ref.p0_c[k], qt, h) qt -= sa.ql qv = qt t = sa.T - alpha = alpha_c(self.Ref.p0_half[k], t, qt, qv) - UpdVar.B.values[i,k] = buoyancy_c(self.Ref.alpha0_half[k], alpha) + alpha = alpha_c(self.Ref.p0_c[k], t, qt, qv) + UpdVar.B.values[i,k] = buoyancy_c(self.Ref.alpha0_c[k], alpha) with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): GMV.B.values[k] = (1.0 - UpdVar.Area.bulkvalues[k]) * EnvVar.B.values[k] @@ -372,9 +372,9 @@ cdef class UpdraftMicrophysics: for i in xrange(self.n_updraft): for k in xrange(self.Gr.nzg): tmp_qr = acnv_instant(UpdVar.QL.values[i,k], UpdVar.QT.values[i,k], self.max_supersaturation,\ - UpdVar.T.values[i,k], self.Ref.p0_half[k]) + UpdVar.T.values[i,k], self.Ref.p0_c[k]) self.prec_source_qt[i,k] = -tmp_qr - self.prec_source_h[i,k] = rain_source_to_thetal(self.Ref.p0_half[k], UpdVar.T.values[i,k],\ + self.prec_source_h[i,k] = rain_source_to_thetal(self.Ref.p0_c[k], UpdVar.T.values[i,k],\ UpdVar.QT.values[i,k], UpdVar.QL.values[i,k], 0.0, tmp_qr) #TODO assumes no ice self.prec_source_h_tot = np.sum(np.multiply(self.prec_source_h, UpdVar.Area.values), axis=0) diff --git a/Forcing.pyx b/Forcing.pyx index 156c1064..eb086383 100644 --- a/Forcing.pyx +++ b/Forcing.pyx @@ -75,7 +75,7 @@ cdef class ForcingStandard(ForcingBase): for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): # Apply large-scale horizontal advection tendencies qv = GMV.QT.values[k] - GMV.QL.values[k] - GMV.H.tendencies[k] += self.convert_forcing_prog_fp(self.Ref.p0_half[k],GMV.QT.values[k], + GMV.H.tendencies[k] += self.convert_forcing_prog_fp(self.Ref.p0_c[k],GMV.QT.values[k], qv, GMV.T.values[k], self.dqtdt[k], self.dTdt[k]) GMV.QT.tendencies[k] += self.dqtdt[k] if self.apply_subsidence: @@ -109,7 +109,7 @@ cdef class ForcingStandard(ForcingBase): # for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): # # Apply large-scale horizontal advection tendencies # qv = GMV.QT.values[k] - GMV.QL.values[k] -# GMV.H.tendencies[k] += self.convert_forcing_prog_fp(self.Ref.p0_half[k],GMV.QT.values[k], qv, +# GMV.H.tendencies[k] += self.convert_forcing_prog_fp(self.Ref.p0_c[k],GMV.QT.values[k], qv, # GMV.T.values[k], self.dqtdt[k], self.dTdt[k]) # GMV.QT.tendencies[k] += self.dqtdt[k] # @@ -167,14 +167,14 @@ cdef class ForcingDYCOMS_RF01(ForcingBase): q_0 = 0.0 self.f_rad[self.Gr.nzg] = self.F0 * np.exp(-q_0) for k in xrange(self.Gr.nzg - 1, -1, -1): - q_0 += self.kappa * self.Ref.rho0_half[k] * GMV.QL.values[k] * self.Gr.dz + q_0 += self.kappa * self.Ref.rho0_c[k] * GMV.QL.values[k] * self.Gr.dz self.f_rad[k] = self.F0 * np.exp(-q_0) # cloud-base warming q_1 = 0.0 self.f_rad[0] += self.F1 * np.exp(-q_1) for k in xrange(1, self.Gr.nzg + 1): - q_1 += self.kappa * self.Ref.rho0_half[k - 1] * GMV.QL.values[k - 1] * self.Gr.dz + q_1 += self.kappa * self.Ref.rho0_c[k - 1] * GMV.QL.values[k - 1] * self.Gr.dz self.f_rad[k] += self.F1 * np.exp(-q_1) # cooling in free troposphere @@ -187,7 +187,7 @@ cdef class ForcingDYCOMS_RF01(ForcingBase): self.f_rad[self.Gr.nzg] += rhoi * dycoms_cp * self.divergence * self.alpha_z * (np.power(cbrt_z, 4) / 4.0 + zi * cbrt_z) for k in xrange(self.Gr.gw, self.Gr.nzg - self.Gr.gw): - self.dTdt[k] = - (self.f_rad[k + 1] - self.f_rad[k]) / self.Gr.dz / self.Ref.rho0_half[k] / dycoms_cp + self.dTdt[k] = - (self.f_rad[k + 1] - self.f_rad[k]) / self.Gr.dz / self.Ref.rho0_c[k] / dycoms_cp return @@ -205,7 +205,7 @@ cdef class ForcingDYCOMS_RF01(ForcingBase): for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): # Apply large-scale horizontal advection tendencies qv = GMV.QT.values[k] - GMV.QL.values[k] - GMV.H.tendencies[k] += self.convert_forcing_prog_fp(self.Ref.p0_half[k],GMV.QT.values[k], qv, GMV.T.values[k], self.dqtdt[k], self.dTdt[k]) + GMV.H.tendencies[k] += self.convert_forcing_prog_fp(self.Ref.p0_c[k],GMV.QT.values[k], qv, GMV.T.values[k], self.dqtdt[k], self.dTdt[k]) GMV.QT.tendencies[k] += self.dqtdt[k] # Apply large-scale subsidence tendencies GMV.H.tendencies[k] -= (GMV.H.values[k+1]-GMV.H.values[k]) * self.Gr.dzi * self.subsidence[k] diff --git a/Grid.pxd b/Grid.pxd index 5232ae16..a442b807 100644 --- a/Grid.pxd +++ b/Grid.pxd @@ -12,5 +12,5 @@ cdef class Grid: Py_ssize_t gw Py_ssize_t nz Py_ssize_t nzg - double [:] z - double [:] z_half + double [:] z_f + double [:] z_c diff --git a/Grid.pyx b/Grid.pyx index fae7575b..67b866f7 100644 --- a/Grid.pyx +++ b/Grid.pyx @@ -33,14 +33,14 @@ cdef class Grid: self.nz = namelist['grid']['nz'] self.nzg = self.nz + 2 * self.gw - self.z_half = np.empty((self.nz+2*self.gw),dtype=np.double,order='c') - self.z = np.empty((self.nz+2*self.gw),dtype=np.double,order='c') + self.z_c = np.empty((self.nz+2*self.gw),dtype=np.double,order='c') + self.z_f = np.empty((self.nz+2*self.gw),dtype=np.double,order='c') cdef int i, count = 0 for i in xrange(-self.gw,self.nz+self.gw,1): - self.z[count] = (i + 1) * self.dz - self.z_half[count] = (i+0.5)*self.dz + self.z_f[count] = (i + 1) * self.dz + self.z_c[count] = (i+0.5)*self.dz count += 1 diff --git a/NetCDFIO.pyx b/NetCDFIO.pyx index 298bcdfb..55a9d3f9 100644 --- a/NetCDFIO.pyx +++ b/NetCDFIO.pyx @@ -88,22 +88,22 @@ cdef class NetCDFIO_Stats: profile_grp = root_grp.createGroup('profiles') profile_grp.createDimension('z', self.Gr.nz) profile_grp.createDimension('t', None) - z = profile_grp.createVariable('z', 'f8', ('z')) - z[:] = np.array(self.Gr.z[kmin:kmax]) - z_half = profile_grp.createVariable('z_half', 'f8', ('z')) - z_half[:] = np.array(self.Gr.z_half[kmin:kmax]) + z_f = profile_grp.createVariable('z', 'f8', ('z')) + z_f[:] = np.array(self.Gr.z_f[kmin:kmax]) + z_c = profile_grp.createVariable('z_c', 'f8', ('z')) + z_c[:] = np.array(self.Gr.z_c[kmin:kmax]) profile_grp.createVariable('t', 'f8', ('t')) - del z - del z_half + del z_f + del z_c reference_grp = root_grp.createGroup('reference') reference_grp.createDimension('z', self.Gr.nz) - z = reference_grp.createVariable('z', 'f8', ('z')) - z[:] = np.array(self.Gr.z[kmin:kmax]) - z_half = reference_grp.createVariable('z_half', 'f8', ('z')) - z_half[:] = np.array(self.Gr.z_half[kmin:kmax]) - del z - del z_half + z_f = reference_grp.createVariable('z', 'f8', ('z')) + z_f[:] = np.array(self.Gr.z_f[kmin:kmax]) + z_c = reference_grp.createVariable('z_c', 'f8', ('z')) + z_c[:] = np.array(self.Gr.z_c[kmin:kmax]) + del z_f + del z_c ts_grp = root_grp.createGroup('timeseries') ts_grp.createDimension('t', None) diff --git a/ReferenceState.pxd b/ReferenceState.pxd index d63d2d77..e0a0e61a 100644 --- a/ReferenceState.pxd +++ b/ReferenceState.pxd @@ -3,12 +3,12 @@ from NetCDFIO cimport NetCDFIO_Stats cdef class ReferenceState: cdef: - double [:] p0 - double [:] p0_half - double [:] alpha0 - double [:] alpha0_half - double [:] rho0 - double [:] rho0_half + double [:] p0_f + double [:] p0_c + double [:] alpha0_f + double [:] alpha0_c + double [:] rho0_f + double [:] rho0_c double sg diff --git a/ReferenceState.pyx b/ReferenceState.pyx index 72058ba9..95101776 100644 --- a/ReferenceState.pyx +++ b/ReferenceState.pyx @@ -20,12 +20,12 @@ include 'parameters.pxi' cdef class ReferenceState: def __init__(self, Grid Gr ): - self.p0 = np.zeros(Gr.nzg, dtype=np.double, order='c') - self.p0_half = np.zeros(Gr.nzg, dtype=np.double, order='c') - self.alpha0 = np.zeros(Gr.nzg, dtype=np.double, order='c') - self.alpha0_half = np.zeros(Gr.nzg, dtype=np.double, order='c') - self.rho0 = np.zeros(Gr.nzg, dtype=np.double, order='c') - self.rho0_half = np.zeros(Gr.nzg, dtype=np.double, order='c') + self.p0_f = np.zeros(Gr.nzg, dtype=np.double, order='c') + self.p0_c = np.zeros(Gr.nzg, dtype=np.double, order='c') + self.alpha0_f = np.zeros(Gr.nzg, dtype=np.double, order='c') + self.alpha0_c = np.zeros(Gr.nzg, dtype=np.double, order='c') + self.rho0_f = np.zeros(Gr.nzg, dtype=np.double, order='c') + self.rho0_c = np.zeros(Gr.nzg, dtype=np.double, order='c') return @@ -61,65 +61,65 @@ cdef class ReferenceState: ##_____________TO COMPILE______________ # Construct arrays for integration points - z = np.array(Gr.z[Gr.gw - 1:-Gr.gw + 1]) - z_half = np.append([0.0], np.array(Gr.z_half[Gr.gw:-Gr.gw])) + z_f = np.array(Gr.z_f[Gr.gw - 1:-Gr.gw + 1]) + z_c = np.append([0.0], np.array(Gr.z_c[Gr.gw:-Gr.gw])) # We are integrating the log pressure so need to take the log of the # surface pressure p0 = np.log(self.Pg) - p = np.zeros(Gr.nzg, dtype=np.double, order='c') - p_half = np.zeros(Gr.nzg, dtype=np.double, order='c') + p_f = np.zeros(Gr.nzg, dtype=np.double, order='c') + p_c = np.zeros(Gr.nzg, dtype=np.double, order='c') # Perform the integration - p[Gr.gw - 1:-Gr.gw +1] = odeint(rhs, p0, z, hmax=1.0)[:, 0] - p_half[Gr.gw:-Gr.gw] = odeint(rhs, p0, z_half, hmax=1.0)[1:, 0] + p_f[Gr.gw - 1:-Gr.gw +1] = odeint(rhs, p0, z_f, hmax=1.0)[:, 0] + p_c[Gr.gw:-Gr.gw] = odeint(rhs, p0, z_c, hmax=1.0)[1:, 0] # Set boundary conditions - p[:Gr.gw - 1] = p[2 * Gr.gw - 2:Gr.gw - 1:-1] - p[-Gr.gw + 1:] = p[-Gr.gw - 1:-2 * Gr.gw:-1] + p_f[:Gr.gw - 1] = p_f[2 * Gr.gw - 2:Gr.gw - 1:-1] + p_f[-Gr.gw + 1:] = p_f[-Gr.gw - 1:-2 * Gr.gw:-1] - p_half[:Gr.gw] = p_half[2 * Gr.gw - 1:Gr.gw - 1:-1] - p_half[-Gr.gw:] = p_half[-Gr.gw - 1:-2 * Gr.gw - 1:-1] + p_c[:Gr.gw] = p_c[2 * Gr.gw - 1:Gr.gw - 1:-1] + p_c[-Gr.gw:] = p_c[-Gr.gw - 1:-2 * Gr.gw - 1:-1] - p = np.exp(p) - p_half = np.exp(p_half) + p_f = np.exp(p_f) + p_c = np.exp(p_c) - cdef double[:] p_ = p - cdef double[:] p_half_ = p_half - cdef double[:] temperature = np.zeros(Gr.nzg, dtype=np.double, order='c') - cdef double[:] temperature_half = np.zeros(Gr.nzg, dtype=np.double, order='c') - cdef double[:] alpha = np.zeros(Gr.nzg, dtype=np.double, order='c') - cdef double[:] alpha_half = np.zeros(Gr.nzg, dtype=np.double, order='c') + cdef double[:] p_f_ = p_f + cdef double[:] p_c_ = p_c + cdef double[:] temperature_f = np.zeros(Gr.nzg, dtype=np.double, order='c') + cdef double[:] temperature_c = np.zeros(Gr.nzg, dtype=np.double, order='c') + cdef double[:] alpha0_f = np.zeros(Gr.nzg, dtype=np.double, order='c') + cdef double[:] alpha0_c = np.zeros(Gr.nzg, dtype=np.double, order='c') - cdef double[:] ql = np.zeros(Gr.nzg, dtype=np.double, order='c') - cdef double[:] qi = np.zeros(Gr.nzg, dtype=np.double, order='c') - cdef double[:] qv = np.zeros(Gr.nzg, dtype=np.double, order='c') + cdef double[:] ql_f = np.zeros(Gr.nzg, dtype=np.double, order='c') + cdef double[:] qi_f = np.zeros(Gr.nzg, dtype=np.double, order='c') + cdef double[:] qv_f = np.zeros(Gr.nzg, dtype=np.double, order='c') - cdef double[:] ql_half = np.zeros(Gr.nzg, dtype=np.double, order='c') - cdef double[:] qi_half = np.zeros(Gr.nzg, dtype=np.double, order='c') - cdef double[:] qv_half = np.zeros(Gr.nzg, dtype=np.double, order='c') + cdef double[:] ql_c = np.zeros(Gr.nzg, dtype=np.double, order='c') + cdef double[:] qi_c = np.zeros(Gr.nzg, dtype=np.double, order='c') + cdef double[:] qv_c = np.zeros(Gr.nzg, dtype=np.double, order='c') # Compute reference state thermodynamic profiles #_____COMMENTED TO TEST COMPILATION_____________________ for k in xrange(Gr.nzg): - ret = eos(t_to_entropy_c, eos_first_guess_entropy, p_[k], self.qtg, self.sg) - temperature[k] = ret.T - ql[k] = ret.ql - qv[k] = self.qtg - (ql[k] + qi[k]) - alpha[k] = alpha_c(p_[k], temperature[k], self.qtg, qv[k]) - ret = eos(t_to_entropy_c, eos_first_guess_entropy, p_half_[k], self.qtg, self.sg) - temperature_half[k] = ret.T - ql_half[k] = ret.ql - qv_half[k] = self.qtg - (ql_half[k] + qi_half[k]) - alpha_half[k] = alpha_c(p_half_[k], temperature_half[k], self.qtg, qv_half[k]) + ret = eos(t_to_entropy_c, eos_first_guess_entropy, p_f_[k], self.qtg, self.sg) + temperature_f[k] = ret.T + ql_f[k] = ret.ql + qv_f[k] = self.qtg - (ql_f[k] + qi_f[k]) + alpha0_f[k] = alpha_c(p_f_[k], temperature_f[k], self.qtg, qv_f[k]) + ret = eos(t_to_entropy_c, eos_first_guess_entropy, p_c_[k], self.qtg, self.sg) + temperature_c[k] = ret.T + ql_c[k] = ret.ql + qv_c[k] = self.qtg - (ql_c[k] + qi_c[k]) + alpha0_c[k] = alpha_c(p_c_[k], temperature_c[k], self.qtg, qv_c[k]) # Now do a sanity check to make sure that the Reference State entropy profile is uniform following # saturation adjustment cdef double s for k in xrange(Gr.nzg): - s = t_to_entropy_c(p_half[k],temperature_half[k],self.qtg,ql_half[k],qi_half[k]) + s = t_to_entropy_c(p_c[k],temperature_c[k],self.qtg,ql_c[k],qi_c[k]) if np.abs(s - self.sg)/self.sg > 0.01: print('Error in reference profiles entropy not constant !') print('Likely error in saturation adjustment') @@ -128,29 +128,29 @@ cdef class ReferenceState: - # print(np.array(Gr.extract_local_ghosted(alpha_half,2))) - self.alpha0_half = alpha_half - self.alpha0 = alpha - self.p0 = p_ - self.p0_half = p_half - self.rho0 = 1.0 / np.array(self.alpha0) - self.rho0_half = 1.0 / np.array(self.alpha0_half) + # print(np.array(Gr.extract_local_ghosted(alpha_c,2))) + self.alpha0_c = alpha0_c + self.alpha0_f = alpha0_f + self.p0_f = p_f + self.p0_c = p_c + self.rho0_f = 1.0 / np.array(self.alpha0_f) + self.rho0_c = 1.0 / np.array(self.alpha0_c) - Stats.add_reference_profile('alpha0') - Stats.write_reference_profile('alpha0', alpha[Gr.gw:-Gr.gw]) - Stats.add_reference_profile('alpha0_half') - Stats.write_reference_profile('alpha0_half', alpha_half[Gr.gw:-Gr.gw]) + Stats.add_reference_profile('alpha0_f') + Stats.write_reference_profile('alpha0_f', alpha0_f[Gr.gw:-Gr.gw]) + Stats.add_reference_profile('alpha0_c') + Stats.write_reference_profile('alpha0_c', alpha0_c[Gr.gw:-Gr.gw]) - Stats.add_reference_profile('p0') - Stats.write_reference_profile('p0', p_[Gr.gw:-Gr.gw]) - Stats.add_reference_profile('p0_half') - Stats.write_reference_profile('p0_half', p_half[Gr.gw:-Gr.gw]) + Stats.add_reference_profile('p0_f') + Stats.write_reference_profile('p0_f', p_f[Gr.gw:-Gr.gw]) + Stats.add_reference_profile('p0_c') + Stats.write_reference_profile('p0_c', p_c[Gr.gw:-Gr.gw]) - Stats.add_reference_profile('rho0') - Stats.write_reference_profile('rho0', 1.0 / np.array(alpha[Gr.gw:-Gr.gw])) - Stats.add_reference_profile('rho0_half') - Stats.write_reference_profile('rho0_half', 1.0 / np.array(alpha_half[Gr.gw:-Gr.gw])) + Stats.add_reference_profile('rho0_f') + Stats.write_reference_profile('rho0_f', 1.0 / np.array(alpha0_f[Gr.gw:-Gr.gw])) + Stats.add_reference_profile('rho0_c') + Stats.write_reference_profile('rho0_c', 1.0 / np.array(alpha0_c[Gr.gw:-Gr.gw])) # Stats.add_reference_profile('temperature0', Gr, Pa) # Stats.write_reference_profile('temperature0', temperature_half[Gr.dims.gw:-Gr.dims.gw], Pa) diff --git a/Surface.pyx b/Surface.pyx index 3dfc9250..87dcaa45 100644 --- a/Surface.pyx +++ b/Surface.pyx @@ -36,8 +36,8 @@ cdef class SurfaceBase: with nogil: for k in xrange(self.Gr.nzg): qv = GMV.QT.values[k] - GMV.QL.values[k] - theta_rho[k] = theta_rho_c(self.Ref.p0_half[k], GMV.T.values[k], GMV.QT.values[k], qv) - zi = get_inversion(&theta_rho[0], &GMV.U.values[0], &GMV.V.values[0], &self.Gr.z_half[0], kmin, kmax, self.Ri_bulk_crit) + theta_rho[k] = theta_rho_c(self.Ref.p0_c[k], GMV.T.values[k], GMV.QT.values[k], qv) + zi = get_inversion(&theta_rho[0], &GMV.U.values[0], &GMV.V.values[0], &self.Gr.z_c[0], kmin, kmax, self.Ri_bulk_crit) wstar = get_wstar(self.bflux, zi) # yair here zi in TRMM should be adjusted self.windspeed = np.sqrt(self.windspeed*self.windspeed + (1.2 *wstar)*(1.2 * wstar) ) return @@ -61,9 +61,9 @@ cdef class SurfaceFixedFlux(SurfaceBase): if GMV.H.name == 'thetal': self.rho_hflux = rho_tflux / exner_c(self.Ref.Pg) elif GMV.H.name == 's': - self.rho_hflux = entropy_flux(rho_tflux/self.Ref.rho0[gw-1],self.rho_qtflux/self.Ref.rho0[gw-1], - self.Ref.p0_half[gw], GMV.T.values[gw], GMV.QT.values[gw]) - self.bflux = buoyancy_flux(self.shf, self.lhf, GMV.T.values[gw], GMV.QT.values[gw],self.Ref.alpha0[gw-1] ) + self.rho_hflux = entropy_flux(rho_tflux/self.Ref.rho0_f[gw-1],self.rho_qtflux/self.Ref.rho0_f[gw-1], + self.Ref.p0_c[gw], GMV.T.values[gw], GMV.QT.values[gw]) + self.bflux = buoyancy_flux(self.shf, self.lhf, GMV.T.values[gw], GMV.QT.values[gw],self.Ref.alpha0_f[gw-1] ) if not self.ustar_fixed: # Correction to windspeed for free convective cases (Beljaars, QJRMS (1994), 121, pp. 255-270) @@ -83,16 +83,16 @@ cdef class SurfaceFixedFlux(SurfaceBase): print('GMV.QT.values[gw] ==>',GMV.QT.values[gw]) print('GMV.T.values[gw] ==>',GMV.T.values[gw]) print('GMV.H.values[gw] ==>',GMV.H.values[gw]) - print('self.Ref.alpha0[gw-1] ==>',self.Ref.alpha0[gw-1]) + print('self.Ref.alpha0_f[gw-1] ==>',self.Ref.alpha0_f[gw-1]) plt.figure() plt.show() - self.ustar = compute_ustar(self.windspeed, self.bflux, self.zrough, self.Gr.z_half[gw]) + self.ustar = compute_ustar(self.windspeed, self.bflux, self.zrough, self.Gr.z_c[gw]) self.obukhov_length = -self.ustar *self.ustar *self.ustar /self.bflux /vkb - self.rho_uflux = - self.Ref.rho0[gw-1] * self.ustar * self.ustar / self.windspeed * GMV.U.values[gw] - self.rho_vflux = - self.Ref.rho0[gw-1] * self.ustar * self.ustar / self.windspeed * GMV.V.values[gw] + self.rho_uflux = - self.Ref.rho0_f[gw-1] * self.ustar * self.ustar / self.windspeed * GMV.U.values[gw] + self.rho_vflux = - self.Ref.rho0_f[gw-1] * self.ustar * self.ustar / self.windspeed * GMV.V.values[gw] return cpdef free_convection_windspeed(self, GridMeanVariables GMV): SurfaceBase.free_convection_windspeed(self, GMV) @@ -121,22 +121,22 @@ cdef class SurfaceFixedCoeffs(SurfaceBase): double pv, pd, sv, sd - self.rho_qtflux = -self.cq * windspeed * (GMV.QT.values[gw] - self.qsurface) * self.Ref.rho0[gw-1] + self.rho_qtflux = -self.cq * windspeed * (GMV.QT.values[gw] - self.qsurface) * self.Ref.rho0_f[gw-1] self.lhf = lv * self.rho_qtflux if GMV.H.name == 'thetal': - self.rho_hflux = -self.ch * windspeed * (GMV.H.values[gw] - self.Tsurface/exner_c(self.Ref.Pg)) * self.Ref.rho0[gw-1] + self.rho_hflux = -self.ch * windspeed * (GMV.H.values[gw] - self.Tsurface/exner_c(self.Ref.Pg)) * self.Ref.rho0_f[gw-1] self.shf = cp_ * self.rho_hflux elif GMV.H.name == 's': - self.rho_hflux = -self.ch * windspeed * (GMV.H.values[gw] - self.s_surface) * self.Ref.rho0[gw-1] + self.rho_hflux = -self.ch * windspeed * (GMV.H.values[gw] - self.s_surface) * self.Ref.rho0_f[gw-1] pv = pv_star(GMV.T.values[gw]) - pd = self.Ref.p0_half[gw] - pv + pd = self.Ref.p0_c[gw] - pv sv = sv_c(pv,GMV.T.values[gw]) sd = sd_c(pd, GMV.T.values[gw]) self.shf = (self.rho_hflux - self.lhf/lv * (sv-sd)) * GMV.T.values[gw] - self.bflux = buoyancy_flux(self.shf, self.lhf, GMV.T.values[gw], GMV.QT.values[gw],self.Ref.alpha0[gw-1] ) + self.bflux = buoyancy_flux(self.shf, self.lhf, GMV.T.values[gw], GMV.QT.values[gw],self.Ref.alpha0_f[gw-1] ) self.ustar = np.sqrt(self.cm) * windspeed @@ -146,8 +146,8 @@ cdef class SurfaceFixedCoeffs(SurfaceBase): else: self.obukhov_length = -self.ustar *self.ustar *self.ustar /self.bflux /vkb - self.rho_uflux = - self.Ref.rho0[gw-1] * self.ustar * self.ustar / windspeed * GMV.U.values[gw] - self.rho_vflux = - self.Ref.rho0[gw-1] * self.ustar * self.ustar / windspeed * GMV.V.values[gw] + self.rho_uflux = - self.Ref.rho0_f[gw-1] * self.ustar * self.ustar / windspeed * GMV.U.values[gw] + self.rho_vflux = - self.Ref.rho0_f[gw-1] * self.ustar * self.ustar / windspeed * GMV.V.values[gw] return cpdef free_convection_windspeed(self, GridMeanVariables GMV): SurfaceBase.free_convection_windspeed(self, GMV) diff --git a/Turbulence.pyx b/Turbulence.pyx index 7ff232d2..d291f6a9 100644 --- a/Turbulence.pyx +++ b/Turbulence.pyx @@ -85,14 +85,14 @@ cdef class ParameterizationBase: with nogil: for k in xrange(gw, self.Gr.nzg-gw): qv = GMV.QT.values[k] - GMV.QL.values[k] - theta_rho[k] = theta_rho_c(self.Ref.p0_half[k], GMV.T.values[k], GMV.QT.values[k], qv) + theta_rho[k] = theta_rho_c(self.Ref.p0_c[k], GMV.T.values[k], GMV.QT.values[k], qv) if option == 'theta_rho': with nogil: for k in xrange(kmin,kmax): if theta_rho[k] > theta_rho[kmin]: - self.zi = self.Gr.z_half[k] + self.zi = self.Gr.z_c[k] break elif option == 'thetal_maxgrad': @@ -101,9 +101,9 @@ cdef class ParameterizationBase: grad = (GMV.THL.values[k+1] - GMV.THL.values[k])*self.Gr.dzi if grad > maxgrad: maxgrad = grad - self.zi = self.Gr.z[k] + self.zi = self.Gr.z_f[k] elif option == 'critical_Ri': - self.zi = get_inversion(&theta_rho[0], &GMV.U.values[0], &GMV.V.values[0], &self.Gr.z_half[0], kmin, kmax, self.Ri_bulk_crit) + self.zi = get_inversion(&theta_rho[0], &GMV.U.values[0], &GMV.V.values[0], &self.Gr.z_c[0], kmin, kmax, self.Ri_bulk_crit) else: print('INVERSION HEIGHT OPTION NOT RECOGNIZED') @@ -129,7 +129,7 @@ cdef class ParameterizationBase: with nogil: for k in xrange(gw,nzg-gw): - zzi = self.Gr.z_half[k]/self.zi + zzi = self.Gr.z_c[k]/self.zi if zzi <= 1.0: self.KH.values[k] = vkb * ( (ustar/self.wstar)**3 + 39.0*vkb*zzi)**(1.0/3.0) * zzi * (1.0-zzi) * (1.0-zzi) * self.wstar * self.zi self.KM.values[k] = self.KH.values[k] * self.prandtl_number @@ -191,18 +191,18 @@ cdef class SimilarityED(ParameterizationBase): with nogil: for k in xrange(nzg-1): - rho_K_m[k] = 0.5 * (self.KH.values[k]+ self.KH.values[k+1]) * self.Ref.rho0[k] + rho_K_m[k] = 0.5 * (self.KH.values[k]+ self.KH.values[k+1]) * self.Ref.rho0_f[k] # Matrix is the same for all variables that use the same eddy diffusivity construct_tridiag_diffusion(nzg, gw, self.Gr.dzi, TS.dt, &rho_K_m[0], - &self.Ref.rho0_half[0], &dummy_ae[0] ,&a[0], &b[0], &c[0]) + &self.Ref.rho0_c[0], &dummy_ae[0] ,&a[0], &b[0], &c[0]) # Solve QT with nogil: for k in xrange(nz): x[k] = GMV.QT.values[k+gw] - x[0] = x[0] + TS.dt * Case.Sur.rho_qtflux * self.Gr.dzi * self.Ref.alpha0_half[gw] + x[0] = x[0] + TS.dt * Case.Sur.rho_qtflux * self.Gr.dzi * self.Ref.alpha0_c[gw] tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) with nogil: @@ -214,7 +214,7 @@ cdef class SimilarityED(ParameterizationBase): with nogil: for k in xrange(nz): x[k] = GMV.H.values[k+gw] - x[0] = x[0] + TS.dt * Case.Sur.rho_hflux * self.Gr.dzi * self.Ref.alpha0_half[gw] + x[0] = x[0] + TS.dt * Case.Sur.rho_hflux * self.Gr.dzi * self.Ref.alpha0_c[gw] tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) with nogil: @@ -226,7 +226,7 @@ cdef class SimilarityED(ParameterizationBase): with nogil: for k in xrange(nz): x[k] = GMV.U.values[k+gw] - x[0] = x[0] + TS.dt * Case.Sur.rho_uflux * self.Gr.dzi * self.Ref.alpha0_half[gw] + x[0] = x[0] + TS.dt * Case.Sur.rho_uflux * self.Gr.dzi * self.Ref.alpha0_c[gw] tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) with nogil: @@ -237,7 +237,7 @@ cdef class SimilarityED(ParameterizationBase): with nogil: for k in xrange(nz): x[k] = GMV.V.values[k+gw] - x[0] = x[0] + TS.dt * Case.Sur.rho_vflux * self.Gr.dzi * self.Ref.alpha0_half[gw] + x[0] = x[0] + TS.dt * Case.Sur.rho_vflux * self.Gr.dzi * self.Ref.alpha0_c[gw] tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) with nogil: diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index c4a3abc3..75bf12ba 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -456,11 +456,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.H.values[i,gw] = self.h_surface_bc[i] self.UpdVar.QT.values[i,gw] = self.qt_surface_bc[i] # Find the cloud liquid content - sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_half[gw], + sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_c[gw], self.UpdVar.QT.values[i,gw], self.UpdVar.H.values[i,gw]) self.UpdVar.QL.values[i,gw] = sa.ql self.UpdVar.T.values[i,gw] = sa.T - self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0_half[gw], self.UpdVar.T.values[i,gw], + self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0_c[gw], self.UpdVar.T.values[i,gw], &self.UpdVar.QT.values[i,gw], &self.UpdVar.QL.values[i,gw], &self.UpdVar.QR.values[i,gw], &self.UpdVar.H.values[i,gw], i, gw) @@ -470,11 +470,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.QT.values[i,k] = (self.UpdVar.QT.values[i,k-1] + self.entr_sc[i,k] * dz * GMV.QT.values[k])/denom - sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_half[k], + sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_c[k], self.UpdVar.QT.values[i,k], self.UpdVar.H.values[i,k]) self.UpdVar.QL.values[i,k] = sa.ql self.UpdVar.T.values[i,k] = sa.T - self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0_half[k], self.UpdVar.T.values[i,k], + self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0_c[k], self.UpdVar.T.values[i,k], &self.UpdVar.QT.values[i,k], &self.UpdVar.QL.values[i,k], &self.UpdVar.QR.values[i,k], &self.UpdVar.H.values[i,k], i, k) @@ -527,13 +527,13 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): if self.entr_sc[i,k]>(0.9/dz): self.entr_sc[i,k] = 0.9/dz - self.UpdVar.Area.values[i,k] = (self.Ref.rho0_half[k-1]*self.UpdVar.Area.values[i,k-1]*w_low/ - (1.0-(self.entr_sc[i,k]-self.detr_sc[i,k])*dz)/w_mid/self.Ref.rho0_half[k]) + self.UpdVar.Area.values[i,k] = (self.Ref.rho0_c[k-1]*self.UpdVar.Area.values[i,k-1]*w_low/ + (1.0-(self.entr_sc[i,k]-self.detr_sc[i,k])*dz)/w_mid/self.Ref.rho0_c[k]) # # Limit the increase in updraft area when the updraft decelerates if self.UpdVar.Area.values[i,k] > au_lim: self.UpdVar.Area.values[i,k] = au_lim - self.detr_sc[i,k] =(self.Ref.rho0_half[k-1] * self.UpdVar.Area.values[i,k-1] - * w_low / au_lim / w_mid / self.Ref.rho0_half[k] + self.entr_sc[i,k] * dz -1.0)/dz + self.detr_sc[i,k] =(self.Ref.rho0_c[k-1] * self.UpdVar.Area.values[i,k-1] + * w_low / au_lim / w_mid / self.Ref.rho0_c[k] + self.entr_sc[i,k] * dz -1.0)/dz else: # the updraft has terminated so set its area fraction to zero at this height and all heights above self.UpdVar.Area.values[i,k] = 0.0 @@ -543,7 +543,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): #TODO wouldnt it be more consistent to have here? #self.UpdVar.QL.values[i,k] = GMV.QL.values[k] #self.UpdVar.T.values[i,k] = GMV.T.values[k] - sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_half[k], + sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_c[k], self.UpdVar.QT.values[i,k], self.UpdVar.H.values[i,k]) self.UpdVar.QL.values[i,k] = sa.ql self.UpdVar.T.values[i,k] = sa.T @@ -584,7 +584,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): if ws > 0.0: with nogil: for k in xrange(self.Gr.nzg): - z = self.Gr.z_half[k] + z = self.Gr.z_c[k] GMV.TKE.values[k] = ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) @@ -608,7 +608,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(gw, self.Gr.nzg-gw): l1 = tau * sqrt(fmax(self.EnvVar.TKE.values[k],0.0)) - z_ = self.Gr.z_half[k] + z_ = self.Gr.z_c[k] if obukhov_length < 0.0: #unstable l2 = vkb * z_ * ( (1.0 - 100.0 * z_/obukhov_length)**0.2 ) elif obukhov_length > 0.0: #stable @@ -644,9 +644,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cdef: Py_ssize_t i, gw = self.Gr.gw - double zLL = self.Gr.z_half[gw] + double zLL = self.Gr.z_c[gw] double ustar = Case.Sur.ustar, oblength = Case.Sur.obukhov_length - double alpha0LL = self.Ref.alpha0_half[gw] + double alpha0LL = self.Ref.alpha0_c[gw] double qt_var = get_surface_variance(Case.Sur.rho_qtflux*alpha0LL, Case.Sur.rho_qtflux*alpha0LL, ustar, zLL, oblength) double h_var = get_surface_variance(Case.Sur.rho_hflux*alpha0LL, @@ -669,7 +669,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cpdef reset_surface_tke(self, GridMeanVariables GMV, CasesBase Case): GMV.TKE.values[self.Gr.gw] = get_surface_tke(Case.Sur.ustar, self.wstar, - self.Gr.z_half[self.Gr.gw], + self.Gr.z_c[self.Gr.gw], Case.Sur.obukhov_length) return @@ -677,10 +677,10 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cpdef reset_surface_covariance(self, GridMeanVariables GMV, CasesBase Case): cdef: - double zLL = self.Gr.z_half[self.Gr.gw] + double zLL = self.Gr.z_c[self.Gr.gw] double ustar = Case.Sur.ustar, oblength = Case.Sur.obukhov_length - double flux1 = Case.Sur.rho_hflux * self.Ref.alpha0_half[self.Gr.gw] - double flux2 = Case.Sur.rho_qtflux * self.Ref.alpha0_half[self.Gr.gw] + double flux1 = Case.Sur.rho_hflux * self.Ref.alpha0_c[self.Gr.gw] + double flux2 = Case.Sur.rho_qtflux * self.Ref.alpha0_c[self.Gr.gw] GMV.Hvar.values[self.Gr.gw] = get_surface_variance(flux1, flux1, ustar, zLL, oblength) GMV.QTvar.values[self.Gr.gw] = get_surface_variance(flux2, flux2, ustar, zLL, oblength) @@ -870,7 +870,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): input.b_mean = GMV.B.values[k] input.w = self.UpdVar.W.values[i,k] input.dw = (self.UpdVar.W.values[i,k]-self.UpdVar.W.values[i,k-1])/self.Gr.dz - input.z = self.Gr.z_half[k] + input.z = self.Gr.z_c[k] input.af = self.UpdVar.Area.values[i,k] input.ml = self.mixing_length[k] input.qt_env = self.EnvVar.QT.values[k] @@ -883,8 +883,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): input.qt_up = self.UpdVar.QT.values[i,k] input.ql_up = self.UpdVar.QL.values[i,k] input.T_up = self.UpdVar.T.values[i,k] - input.p0 = self.Ref.p0_half[k] - input.alpha0 = self.Ref.alpha0_half[k] + input.p0 = self.Ref.p0_c[k] + input.alpha0 = self.Ref.alpha0_c[k] input.tke_ed_coeff = self.tke_ed_coeff input.T_mean = (self.EnvVar.T.values[k]+self.UpdVar.T.values[i,k])/2 input.L = 20000.0 # need to define the scale of the GCM grid resolution @@ -923,17 +923,17 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): entr_w = self.entr_sc[i,gw] detr_w = self.detr_sc[i,gw] B_k = self.UpdVar.B.values[i,gw] - adv = self.Ref.rho0_half[gw] * a_k * self.UpdVar.W.values[i,gw] * self.UpdVar.W.values[i,gw] * dzi *2.0 - exch = (self.Ref.rho0_half[gw] * a_k * self.UpdVar.W.values[i,gw] + adv = self.Ref.rho0_c[gw] * a_k * self.UpdVar.W.values[i,gw] * self.UpdVar.W.values[i,gw] * dzi *2.0 + exch = (self.Ref.rho0_c[gw] * a_k * self.UpdVar.W.values[i,gw] * (entr_w * self.EnvVar.W.values[gw] - detr_w * self.UpdVar.W.values[i,gw] )) - buoy= self.Ref.rho0_half[gw] * a_k * B_k - press_buoy = -1.0 * self.Ref.rho0_half[gw] * a_k * B_k * self.pressure_buoy_coeff - press_drag = -1.0 * self.Ref.rho0_half[gw] * sqrt(a_k) * (self.pressure_drag_coeff/self.pressure_plume_spacing + buoy= self.Ref.rho0_c[gw] * a_k * B_k + press_buoy = -1.0 * self.Ref.rho0_c[gw] * a_k * B_k * self.pressure_buoy_coeff + press_drag = -1.0 * self.Ref.rho0_c[gw] * sqrt(a_k) * (self.pressure_drag_coeff/self.pressure_plume_spacing * fabs(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])*(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])) press = press_buoy + press_drag self.updraft_pressure_sink[i,gw] = press - self.UpdVar.W.new[i,gw] = (self.Ref.rho0_half[gw] * a_k * self.UpdVar.W.values[i,gw] * dti_ - -adv + exch + buoy + press)/(self.Ref.rho0_half[gw] * self.UpdVar.Area.values[i,gw] * dti_) + self.UpdVar.W.new[i,gw] = (self.Ref.rho0_c[gw] * a_k * self.UpdVar.W.values[i,gw] * dti_ + -adv + exch + buoy + press)/(self.Ref.rho0_c[gw] * self.UpdVar.Area.values[i,gw] * dti_) self.UpdVar.W.values[i,gw] = self.UpdVar.W.new[i,gw] for k in range(gw+1, self.Gr.nzg-gw): @@ -948,10 +948,10 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): entr_term = self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * (2*sgn_w-1.0)*( self.entr_sc[i,k]) detr_term = self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * (2*sgn_w-1.0)*(-self.detr_sc[i,k]) - adv_up = -self.Ref.alpha0_half[k] * dzi *( self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] - -self.Ref.rho0_half[k-1] * self.UpdVar.Area.values[i,k-1] * self.UpdVar.W.values[i,k-1]) - #adv_dw = -self.Ref.alpha0_half[k] * dzi *( self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * self.UpdVar.W.values[i,k+1] - # -self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k]) + adv_up = -self.Ref.alpha0_c[k] * dzi *( self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] + -self.Ref.rho0_c[k-1] * self.UpdVar.Area.values[i,k-1] * self.UpdVar.W.values[i,k-1]) + #adv_dw = -self.Ref.alpha0_c[k] * dzi *( self.Ref.rho0_c[k+1] * self.UpdVar.Area.values[i,k+1] * self.UpdVar.W.values[i,k+1] + # -self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k]) #adv = sgn_w*adv_up + (1.0-sgn_w)*adv_dw adv = adv_up @@ -972,23 +972,23 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): a_k = self.UpdVar.Area.values[i,k] B_k = self.UpdVar.B.values[i,k] - adv_up = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] **2 * dzi - - self.Ref.rho0_half[k-1] * self.UpdVar.Area.values[i,k-1] * self.UpdVar.W.values[i,k-1] **2 * dzi) - #adv_dw = (self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * self.UpdVar.W.values[i,k+1]**2 - # - self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k]**2)* dzi + adv_up = (self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] **2 * dzi + - self.Ref.rho0_c[k-1] * self.UpdVar.Area.values[i,k-1] * self.UpdVar.W.values[i,k-1] **2 * dzi) + #adv_dw = (self.Ref.rho0_c[k+1] * self.UpdVar.Area.values[i,k+1] * self.UpdVar.W.values[i,k+1]**2 + # - self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k]**2)* dzi #adv = sgn_w*adv_up + (1.0-sgn_w)*adv_dw adv = adv_up - exch = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] + exch = (self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * ((2*sgn_w-1.0)*entr_w * self.EnvVar.W.values[k] - (2*sgn_w-1.0)*detr_w*self.UpdVar.W.values[i,k])) - buoy= self.Ref.rho0_half[k+1] * a_k * B_k - press_buoy = -1.0 * self.Ref.rho0_half[k] * a_k * B_k * self.pressure_buoy_coeff - press_drag = -1.0 * self.Ref.rho0_half[k] * sqrt(a_k) * (self.pressure_drag_coeff/self.pressure_plume_spacing + buoy= self.Ref.rho0_c[k+1] * a_k * B_k + press_buoy = -1.0 * self.Ref.rho0_c[k] * a_k * B_k * self.pressure_buoy_coeff + press_drag = -1.0 * self.Ref.rho0_c[k] * sqrt(a_k) * (self.pressure_drag_coeff/self.pressure_plume_spacing *fabs(self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k]) * (self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k])) press = press_buoy + press_drag self.updraft_pressure_sink[i,k] = press - self.UpdVar.W.new[i,k] = (self.Ref.rho0_half[k] * a_k * self.UpdVar.W.values[i,k] * dti_ - -adv + exch + buoy + press)/(self.Ref.rho0_half[k] * self.UpdVar.Area.new[i,k] * dti_) + self.UpdVar.W.new[i,k] = (self.Ref.rho0_c[k] * a_k * self.UpdVar.W.values[i,k] * dti_ + -adv + exch + buoy + press)/(self.Ref.rho0_c[k] * self.UpdVar.Area.new[i,k] * dti_) with gil: #self.nan_check(1003, GMV,k) @@ -1033,11 +1033,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): if self.use_local_micro: # do saturation adjustment sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, - self.Ref.p0_half[gw], self.UpdVar.QT.new[i,gw], self.UpdVar.H.new[i,gw]) + self.Ref.p0_c[gw], self.UpdVar.QT.new[i,gw], self.UpdVar.H.new[i,gw]) self.UpdVar.QL.new[i,gw] = sa.ql self.UpdVar.T.new[i,gw] = sa.T # remove precipitation (update QT, QL and H) - self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0_half[gw], self.UpdVar.T.new[i,gw], + self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0_c[gw], self.UpdVar.T.new[i,gw], &self.UpdVar.QT.new[i,gw], &self.UpdVar.QL.new[i,gw], &self.UpdVar.QR.new[i,gw], &self.UpdVar.H.new[i,gw], i, gw) @@ -1057,12 +1057,12 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): sgn_w = 1.0 sgn_w = 1.0 - m_kp = (self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * self.UpdVar.W.values[i,k+1]) - m_k = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k]) - m_km = (self.Ref.rho0_half[k-1] * self.UpdVar.Area.values[i,k-1] * self.UpdVar.W.values[i,k-1]) + m_kp = (self.Ref.rho0_c[k+1] * self.UpdVar.Area.values[i,k+1] * self.UpdVar.W.values[i,k+1]) + m_k = (self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k]) + m_km = (self.Ref.rho0_c[k-1] * self.UpdVar.Area.values[i,k-1] * self.UpdVar.W.values[i,k-1]) - c1 = self.Ref.rho0_half[k] * self.UpdVar.Area.new[i,k] * dti_ - c2 = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * dti_ + c1 = self.Ref.rho0_c[k] * self.UpdVar.Area.new[i,k] * dti_ + c2 = (self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * dti_ - (2*sgn_w-1.0)*m_k * (dzi + self.detr_sc[i,k])) c3 = sgn_w*m_km * dzi-(1.0-sgn_w)*m_kp * dzi c4 = (2*sgn_w-1.0)*(m_k * self.entr_sc[i,k]) @@ -1073,26 +1073,26 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): + c3*(1.0-sgn_w) * self.UpdVar.QT.values[i,k+1] + c4* QT_entr)/c1 - # adv_up = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] *self.UpdVar.H.values[i,k] * dzi - # - self.Ref.rho0_half[k-1] * self.UpdVar.Area.values[i,k-1] * self.UpdVar.W.values[i,k-1] *self.UpdVar.H.values[i,k-1] * dzi) - # adv_dw = (self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * self.UpdVar.W.values[i,k+1] *self.UpdVar.H.values[i,k+1] * dzi - # - self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] *self.UpdVar.H.values[i,k] * dzi) + # adv_up = (self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] *self.UpdVar.H.values[i,k] * dzi + # - self.Ref.rho0_c[k-1] * self.UpdVar.Area.values[i,k-1] * self.UpdVar.W.values[i,k-1] *self.UpdVar.H.values[i,k-1] * dzi) + # adv_dw = (self.Ref.rho0_c[k+1] * self.UpdVar.Area.values[i,k+1] * self.UpdVar.W.values[i,k+1] *self.UpdVar.H.values[i,k+1] * dzi + # - self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] *self.UpdVar.H.values[i,k] * dzi) # adv = adv_up - # exch = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] + # exch = (self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] # * ((2*sgn_w-1.0)*self.entr_sc[i,k] * self.EnvVar.H.values[k] - (2*sgn_w-1.0)*self.detr_sc[i,k]*self.UpdVar.H.values[i,k])) - # self.UpdVar.H.new[i,k] = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.H.values[i,k] * dti_ - # -adv + exch )/(self.Ref.rho0_half[k] * self.UpdVar.Area.new[i,k] * dti_) + # self.UpdVar.H.new[i,k] = (self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.H.values[i,k] * dti_ + # -adv + exch )/(self.Ref.rho0_c[k] * self.UpdVar.Area.new[i,k] * dti_) # - # adv_up = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] *self.UpdVar.QT.values[i,k] * dzi - # - self.Ref.rho0_half[k-1] * self.UpdVar.Area.values[i,k-1] * self.UpdVar.W.values[i,k-1] *self.UpdVar.QT.values[i,k-1] * dzi) - # adv_dw = (self.Ref.rho0_half[k+1] * self.UpdVar.Area.values[i,k+1] * self.UpdVar.W.values[i,k+1] *self.UpdVar.QT.values[i,k+1] * dzi - # - self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] *self.UpdVar.QT.values[i,k] * dzi) + # adv_up = (self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] *self.UpdVar.QT.values[i,k] * dzi + # - self.Ref.rho0_c[k-1] * self.UpdVar.Area.values[i,k-1] * self.UpdVar.W.values[i,k-1] *self.UpdVar.QT.values[i,k-1] * dzi) + # adv_dw = (self.Ref.rho0_c[k+1] * self.UpdVar.Area.values[i,k+1] * self.UpdVar.W.values[i,k+1] *self.UpdVar.QT.values[i,k+1] * dzi + # - self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] *self.UpdVar.QT.values[i,k] * dzi) # adv = adv_up - # exch = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] + # exch = (self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] # * ((2*sgn_w-1.0)*self.entr_sc[i,k] * self.EnvVar.QT.values[k] - (2*sgn_w-1.0)*self.detr_sc[i,k]*self.UpdVar.QT.values[i,k])) # - # self.UpdVar.QT.new[i,k] = (self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.QT.values[i,k] * dti_ - # -adv + exch )/(self.Ref.rho0_half[k] * self.UpdVar.Area.new[i,k] * dti_) + # self.UpdVar.QT.new[i,k] = (self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.QT.values[i,k] * dti_ + # -adv + exch )/(self.Ref.rho0_c[k] * self.UpdVar.Area.new[i,k] * dti_) @@ -1102,14 +1102,14 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.QT.new[i,k] = GMV.QT.values[k] # find new temperature - sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_half[k], + sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_c[k], self.UpdVar.QT.new[i,k], self.UpdVar.H.new[i,k]) self.UpdVar.QL.new[i,k] = sa.ql self.UpdVar.T.new[i,k] = sa.T if self.use_local_micro: # remove precipitation (pdate QT, QL and H) - self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0_half[k], self.UpdVar.T.new[i,k], + self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0_c[k], self.UpdVar.T.new[i,k], &self.UpdVar.QT.new[i,k], &self.UpdVar.QL.new[i,k], &self.UpdVar.QR.new[i,k], &self.UpdVar.H.new[i,k], i, k) @@ -1167,25 +1167,25 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): entr_w = self.entr_sc[i,gw] detr_w = self.detr_sc[i,gw] B_k = self.UpdVar.B.values[i,gw] - adv = self.Ref.rho0_half[gw] * a_k * self.UpdVar.W.values[i,gw] * self.UpdVar.W.values[i,gw] * dzi *2.0 - exch = (self.Ref.rho0_half[gw] * a_k * self.UpdVar.W.values[i,gw] + adv = self.Ref.rho0_c[gw] * a_k * self.UpdVar.W.values[i,gw] * self.UpdVar.W.values[i,gw] * dzi *2.0 + exch = (self.Ref.rho0_c[gw] * a_k * self.UpdVar.W.values[i,gw] * (entr_w * self.EnvVar.W.values[gw] - detr_w * self.UpdVar.W.values[i,gw] )) - buoy= self.Ref.rho0_half[gw] * a_k * B_k - press_buoy = -1.0 * self.Ref.rho0_half[gw] * a_k * B_k * self.pressure_buoy_coeff - press_drag = -1.0 * self.Ref.rho0_half[gw] * sqrt(a_k) * (self.pressure_drag_coeff/self.pressure_plume_spacing + buoy= self.Ref.rho0_c[gw] * a_k * B_k + press_buoy = -1.0 * self.Ref.rho0_c[gw] * a_k * B_k * self.pressure_buoy_coeff + press_drag = -1.0 * self.Ref.rho0_c[gw] * sqrt(a_k) * (self.pressure_drag_coeff/self.pressure_plume_spacing * fabs(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])*(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])) press = press_buoy + press_drag self.updraft_pressure_sink[i,gw] = press - self.UpdVar.W.new[i,gw] = (self.Ref.rho0_half[gw] * a_k * self.UpdVar.W.values[i,gw] * dti_ - -adv + exch + buoy + press)/(self.Ref.rho0_half[gw] * self.UpdVar.Area.values[i,gw] * dti_) + self.UpdVar.W.new[i,gw] = (self.Ref.rho0_c[gw] * a_k * self.UpdVar.W.values[i,gw] * dti_ + -adv + exch + buoy + press)/(self.Ref.rho0_c[gw] * self.UpdVar.Area.values[i,gw] * dti_) self.UpdVar.W.values[i,gw] = self.UpdVar.W.new[i,gw] sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, - self.Ref.p0_half[gw], self.UpdVar.QT.new[i,gw], self.UpdVar.H.new[i,gw]) + self.Ref.p0_c[gw], self.UpdVar.QT.new[i,gw], self.UpdVar.H.new[i,gw]) self.UpdVar.QL.new[i,gw] = sa.ql self.UpdVar.T.new[i,gw] = sa.T - self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0_half[gw], self.UpdVar.T.new[i,gw], + self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0_c[gw], self.UpdVar.T.new[i,gw], &self.UpdVar.QT.new[i,gw], &self.UpdVar.QL.new[i,gw], &self.UpdVar.QR.new[i,gw], &self.UpdVar.H.new[i,gw], i, gw) @@ -1209,14 +1209,14 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.H.new[i,k] = GMV.H.values[k] self.UpdVar.QT.new[i,k] = GMV.QT.values[k] - sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_half[k], + sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_c[k], self.UpdVar.QT.new[i,k], self.UpdVar.H.new[i,k]) self.UpdVar.QL.new[i,k] = sa.ql self.UpdVar.T.new[i,k] = sa.T self.nan_check(1197, GMV,k) if self.use_local_micro: - self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0_half[k], self.UpdVar.T.new[i,k], + self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0_c[k], self.UpdVar.T.new[i,k], &self.UpdVar.QT.new[i,k], &self.UpdVar.QL.new[i,k], &self.UpdVar.QR.new[i,k], &self.UpdVar.H.new[i,k], i, k) @@ -1248,9 +1248,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double sgn_w = 1.0 if var.name == 'w': - buoy = self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] - press_buoy = - self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] * self.pressure_buoy_coeff - press_drag = - self.Ref.rho0_half[k]*(sqrt(self.UpdVar.Area.values[i,k] )*self.pressure_drag_coeff/self.pressure_plume_spacing + buoy = self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] + press_buoy = - self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] * self.pressure_buoy_coeff + press_drag = - self.Ref.rho0_c[k]*(sqrt(self.UpdVar.Area.values[i,k] )*self.pressure_drag_coeff/self.pressure_plume_spacing * (self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k])*fabs(self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k])) press = press_buoy + press_drag area_new = area.new[i,k] @@ -1280,19 +1280,19 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): if self.UpdVar.W.values[i,k]<0: with gil: print '========================== integrating downwards ==========================' - adv = (self.Ref.rho0_half[k+1] * area.values[i,k+1] * self.UpdVar.W.values[i,k+1] * var_kp - - self.Ref.rho0_half[k] *area.values[i,k] * self.UpdVar.W.values[i,k] * var_k )* dzi - exch = (self.Ref.rho0_half[k] * area.values[i,k] * self.UpdVar.W.values[i,k] + adv = (self.Ref.rho0_c[k+1] * area.values[i,k+1] * self.UpdVar.W.values[i,k+1] * var_kp + - self.Ref.rho0_c[k] *area.values[i,k] * self.UpdVar.W.values[i,k] * var_k )* dzi + exch = (self.Ref.rho0_c[k] * area.values[i,k] * self.UpdVar.W.values[i,k] * (-self.entr_sc[i,k] * env_var + self.detr_sc[i,k] * var_k )) else: - adv = (self.Ref.rho0_half[k] * area.values[i,k] * self.UpdVar.W.values[i,k] * var_k - - self.Ref.rho0_half[k-1] * area.values[i,k-1] * self.UpdVar.W.values[i,k-1] * var_km)* dzi - exch = (self.Ref.rho0_half[k] * area.values[i,k] * self.UpdVar.W.values[i,k] + adv = (self.Ref.rho0_c[k] * area.values[i,k] * self.UpdVar.W.values[i,k] * var_k + - self.Ref.rho0_c[k-1] * area.values[i,k-1] * self.UpdVar.W.values[i,k-1] * var_km)* dzi + exch = (self.Ref.rho0_c[k] * area.values[i,k] * self.UpdVar.W.values[i,k] * (self.entr_sc[i,k] * env_var - self.detr_sc[i,k] * var_k )) - var.new[i,k] = (self.Ref.rho0_half[k] * area.values[i,k] * var_k * dti_ -adv + exch + buoy + press)\ - /(self.Ref.rho0_half[k] * area_new * dti_) + var.new[i,k] = (self.Ref.rho0_c[k] * area.values[i,k] * var_k * dti_ -adv + exch + buoy + press)\ + /(self.Ref.rho0_c[k] * area_new * dti_) if var.name =='area_fraction': var.new[i,k] = fmax(var.new[i,k] , 0.0) @@ -1301,9 +1301,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): if self.UpdVar.Area.new[i,k] > au_lim: self.UpdVar.Area.new[i,k] = au_lim if self.UpdVar.Area.values[i,k] > 0.0: - self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ +self.Ref.alpha0_half[k] * adv - entr_term)/(-self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k])) + self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ +self.Ref.alpha0_c[k] * adv - entr_term)/(-self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k])) else: - self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ +self.Ref.alpha0_half[k] * adv - entr_term)/(-au_lim * self.UpdVar.W.values[i,k])) + self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ +self.Ref.alpha0_c[k] * adv - entr_term)/(-au_lim * self.UpdVar.W.values[i,k])) if var.name == 'w': if self.UpdVar.W.new[i,k] <= 0.0: @@ -1329,7 +1329,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for k in xrange(self.Gr.gw, self.Gr.nzg-1): dw_kp = (self.UpdVar.W.values[i,k+1] - self.EnvVar.W.values[k+1] ) dw_k = (self.UpdVar.W.values[i,k] - self.EnvVar.W.values[k] ) - self.m[i,k] = interp2pt(dw_kp,dw_k)*self.Ref.rho0[k]*interp2pt(self.UpdVar.Area.values[i,k+1],self.UpdVar.Area.values[i,k]) + self.m[i,k] = interp2pt(dw_kp,dw_k)*self.Ref.rho0_f[k]*interp2pt(self.UpdVar.Area.values[i,k+1],self.UpdVar.Area.values[i,k]) self.massflux_h[gw-1] = 0.0 self.massflux_qt[gw-1] = 0.0 @@ -1350,8 +1350,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg): - mf_tend_h = -(self.massflux_h[k] - self.massflux_h[k-1]) * (self.Ref.alpha0_half[k] * self.Gr.dzi) - mf_tend_qt = -(self.massflux_qt[k] - self.massflux_qt[k-1]) * (self.Ref.alpha0_half[k] * self.Gr.dzi) + mf_tend_h = -(self.massflux_h[k] - self.massflux_h[k-1]) * (self.Ref.alpha0_c[k] * self.Gr.dzi) + mf_tend_qt = -(self.massflux_qt[k] - self.massflux_qt[k-1]) * (self.Ref.alpha0_c[k] * self.Gr.dzi) GMV.H.mf_update[k] = GMV.H.values[k] + TS.dt * mf_tend_h + self.UpdMicro.prec_source_h_tot[k] GMV.QT.mf_update[k] = GMV.QT.values[k] + TS.dt * mf_tend_qt + self.UpdMicro.prec_source_qt_tot[k] @@ -1392,17 +1392,17 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(nzg-1): - rho_ae_K_m[k] = 0.5 * (ae[k]*self.KH.values[k]+ ae[k+1]*self.KH.values[k+1]) * self.Ref.rho0[k] + rho_ae_K_m[k] = 0.5 * (ae[k]*self.KH.values[k]+ ae[k+1]*self.KH.values[k+1]) * self.Ref.rho0_f[k] # Matrix is the same for all variables that use the same eddy diffusivity, we can construct once and reuse - construct_tridiag_diffusion(nzg, gw, dzi, TS.dt, &rho_ae_K_m[0], &self.Ref.rho0_half[0], + construct_tridiag_diffusion(nzg, gw, dzi, TS.dt, &rho_ae_K_m[0], &self.Ref.rho0_c[0], &ae[0], &a[0], &b[0], &c[0]) # Solve QT with nogil: for k in xrange(nz): x[k] = self.EnvVar.QT.values[k+gw] - x[0] = x[0] + TS.dt * Case.Sur.rho_qtflux * dzi * self.Ref.alpha0_half[gw]/ae[gw] + x[0] = x[0] + TS.dt * Case.Sur.rho_qtflux * dzi * self.Ref.alpha0_c[gw]/ae[gw] tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) with nogil: @@ -1411,13 +1411,13 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # get the diffusive flux self.diffusive_flux_qt[gw] = interp2pt(Case.Sur.rho_qtflux, -rho_ae_K_m[gw] * dzi *(self.EnvVar.QT.values[gw+1]-self.EnvVar.QT.values[gw]) ) for k in xrange(self.Gr.gw+1, self.Gr.nzg-self.Gr.gw): - self.diffusive_flux_qt[k] = -0.5 * self.Ref.rho0_half[k]*ae[k] * self.KH.values[k] * dzi * (self.EnvVar.QT.values[k+1]-self.EnvVar.QT.values[k-1]) + self.diffusive_flux_qt[k] = -0.5 * self.Ref.rho0_c[k]*ae[k] * self.KH.values[k] * dzi * (self.EnvVar.QT.values[k+1]-self.EnvVar.QT.values[k-1]) # Solve H with nogil: for k in xrange(nz): x[k] = self.EnvVar.H.values[k+gw] - x[0] = x[0] + TS.dt * Case.Sur.rho_hflux * dzi * self.Ref.alpha0_half[gw]/ae[gw] + x[0] = x[0] + TS.dt * Case.Sur.rho_hflux * dzi * self.Ref.alpha0_c[gw]/ae[gw] tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) with nogil: @@ -1427,20 +1427,20 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # get the diffusive flux self.diffusive_flux_h[gw] = interp2pt(Case.Sur.rho_hflux, -rho_ae_K_m[gw] * dzi *(self.EnvVar.H.values[gw+1]-self.EnvVar.H.values[gw]) ) for k in xrange(self.Gr.gw+1, self.Gr.nzg-self.Gr.gw): - self.diffusive_flux_h[k] = -0.5 * self.Ref.rho0_half[k]*ae[k] * self.KH.values[k] * dzi * (self.EnvVar.H.values[k+1]-self.EnvVar.H.values[k-1]) + self.diffusive_flux_h[k] = -0.5 * self.Ref.rho0_c[k]*ae[k] * self.KH.values[k] * dzi * (self.EnvVar.H.values[k+1]-self.EnvVar.H.values[k-1]) # Solve U with nogil: for k in xrange(nzg-1): - rho_ae_K_m[k] = 0.5 * (ae[k]*self.KM.values[k]+ ae[k+1]*self.KM.values[k+1]) * self.Ref.rho0[k] + rho_ae_K_m[k] = 0.5 * (ae[k]*self.KM.values[k]+ ae[k+1]*self.KM.values[k+1]) * self.Ref.rho0_f[k] # Matrix is the same for all variables that use the same eddy diffusivity, we can construct once and reuse - construct_tridiag_diffusion(nzg, gw, dzi, TS.dt, &rho_ae_K_m[0], &self.Ref.rho0_half[0], + construct_tridiag_diffusion(nzg, gw, dzi, TS.dt, &rho_ae_K_m[0], &self.Ref.rho0_c[0], &ae[0], &a[0], &b[0], &c[0]) with nogil: for k in xrange(nz): x[k] = GMV.U.values[k+gw] - x[0] = x[0] + TS.dt * Case.Sur.rho_uflux * dzi * self.Ref.alpha0_half[gw]/ae[gw] + x[0] = x[0] + TS.dt * Case.Sur.rho_uflux * dzi * self.Ref.alpha0_c[gw]/ae[gw] tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) with nogil: @@ -1451,7 +1451,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(nz): x[k] = GMV.V.values[k+gw] - x[0] = x[0] + TS.dt * Case.Sur.rho_vflux * dzi * self.Ref.alpha0_half[gw]/ae[gw] + x[0] = x[0] + TS.dt * Case.Sur.rho_vflux * dzi * self.Ref.alpha0_c[gw]/ae[gw] tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) with nogil: @@ -1496,7 +1496,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): grad_thl_plus = (self.EnvVar.THL.values[k+1] - self.EnvVar.THL.values[k]) * self.Gr.dzi grad_qt_plus = (self.EnvVar.QT.values[k+1] - self.EnvVar.QT.values[k]) * self.Gr.dzi - prefactor = Rd * exner_c(self.Ref.p0_half[k])/self.Ref.p0_half[k] + prefactor = Rd * exner_c(self.Ref.p0_c[k])/self.Ref.p0_c[k] d_alpha_thetal_dry = prefactor * (1.0 + (eps_vi-1.0) * qt_dry) d_alpha_qt_dry = prefactor * th_dry * (eps_vi-1.0) @@ -1515,7 +1515,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): + (1.0-self.EnvVar.CF.values[k]) * d_alpha_qt_dry) # TODO - check - self.tke_buoy[k] = g / self.Ref.alpha0_half[k] * ae[k] * self.Ref.rho0_half[k] \ + self.tke_buoy[k] = g / self.Ref.alpha0_c[k] * ae[k] * self.Ref.rho0_c[k] \ * ( \ - self.KH.values[k] * interp2pt(grad_thl_plus, grad_thl_minus) * d_alpha_thetal_total \ - self.KH.values[k] * interp2pt(grad_qt_plus, grad_qt_minus) * d_alpha_qt_total\ @@ -1535,7 +1535,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # first pass...assume we can re-use with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - self.tke_dissipation[k] = (self.Ref.rho0_half[k] * ae[k] * pow(fmax(self.EnvVar.TKE.values[k],0), 1.5) + self.tke_dissipation[k] = (self.Ref.rho0_c[k] * ae[k] * pow(fmax(self.EnvVar.TKE.values[k],0), 1.5) /fmax(self.mixing_length[k],1.0) * self.tke_diss_coeff) return @@ -1555,7 +1555,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for i in xrange(self.n_updrafts): w_u = self.UpdVar.W.values[i,k] self.tke_entr_gain[k] += self.UpdVar.Area.values[i,k] * fabs(w_u) * self.detr_sc[i,k] * (w_u - w_e) * (w_u - w_e) - self.tke_entr_gain[k] *= 0.5 * self.Ref.rho0_half[k] + self.tke_entr_gain[k] *= 0.5 * self.Ref.rho0_c[k] return @@ -1570,7 +1570,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for i in xrange(self.n_updrafts): w_u = self.UpdVar.W.values[i,k] self.tke_detr_loss[k] += self.UpdVar.Area.values[i,k] * fabs(w_u) * self.entr_sc[i,k] - self.tke_detr_loss[k] *= self.Ref.rho0_half[k] * self.EnvVar.TKE.values[k] + self.tke_detr_loss[k] *= self.Ref.rho0_c[k] * self.EnvVar.TKE.values[k] return cpdef compute_tke_shear(self, GridMeanVariables GMV): @@ -1591,7 +1591,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): du_high = (GMV.U.values[k+1] - GMV.U.values[k]) * self.Gr.dzi dv_high = (GMV.V.values[k+1] - GMV.V.values[k]) * self.Gr.dzi dw_high = (self.EnvVar.W.values[k+1] - self.EnvVar.W.values[k]) * self.Gr.dzi - self.tke_shear[k] =( self.Ref.rho0_half[k] * ae[k] * self.KM.values[k] * + self.tke_shear[k] =( self.Ref.rho0_c[k] * ae[k] * self.KM.values[k] * ( pow(interp2pt(du_low, du_high),2.0) + pow(interp2pt(dv_low, dv_high),2.0) + pow(interp2pt(dw_low, dw_high),2.0))) return @@ -1600,20 +1600,18 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cdef: Py_ssize_t k Py_ssize_t gw = self.Gr.gw - double wu_half, we_half double press_buoy, press_drag with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): self.tke_pressure[k] = 0.0 for i in xrange(self.n_updrafts): - wu_half = self.UpdVar.W.values[i,k] - we_half = self.EnvVar.W.values[k] - press_buoy= (-1.0 * self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] + press_buoy= (-1.0 * self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] * self.pressure_buoy_coeff) - press_drag = (-1.0 * self.Ref.rho0_half[k] * sqrt(self.UpdVar.Area.values[i,k]) - * (self.pressure_drag_coeff/self.pressure_plume_spacing* fabs(wu_half -we_half)*(wu_half -we_half))) - self.tke_pressure[k] += (we_half - wu_half) * (press_buoy + press_drag) + press_drag = (-1.0 * self.Ref.rho0_c[k] * sqrt(self.UpdVar.Area.values[i,k]) + * (self.pressure_drag_coeff/self.pressure_plume_spacing*\ + fabs(self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k])*(self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k]))) + self.tke_pressure[k] += (self.EnvVar.W.values[k] - self.UpdVar.W.values[i,k]) * (press_buoy + press_drag) return cpdef update_tke_ED(self, GridMeanVariables GMV, CasesBase Case,TimeStepping TS): @@ -1639,10 +1637,10 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(1,nzg-1): - rho_ae_K_m[k] = 0.5 * (ae[k]*self.KM.values[k]+ ae[k+1]*self.KM.values[k+1]) * self.Ref.rho0[k] + rho_ae_K_m[k] = 0.5 * (ae[k]*self.KM.values[k]+ ae[k+1]*self.KM.values[k+1]) * self.Ref.rho0_f[k] whalf[k] = self.EnvVar.W.values[k] wu_half = self.UpdVar.W.bulkvalues[gw] - GMV.TKE.values[gw] = get_surface_tke(Case.Sur.ustar, self.wstar, self.Gr.z_half[gw], Case.Sur.obukhov_length) + GMV.TKE.values[gw] = get_surface_tke(Case.Sur.ustar, self.wstar, self.Gr.z_c[gw], Case.Sur.obukhov_length) self.get_env_tke_from_GMV(self.UpdVar.Area, self.UpdVar.W, self.EnvVar.W, self.EnvVar.TKE, &GMV.W.values[0], &GMV.TKE.values[0]) @@ -1656,15 +1654,15 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for i in xrange(self.n_updrafts): wu_half = self.UpdVar.W.values[i,k] - D_env += self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * wu_half * self.entr_sc[i,k] + D_env += self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * wu_half * self.entr_sc[i,k] a[kk] = (- rho_ae_K_m[k-1] * dzi * dzi ) - b[kk] = (self.Ref.rho0_half[k] * ae[k] * dti - self.Ref.rho0_half[k] * ae[k] * whalf[k] * dzi + b[kk] = (self.Ref.rho0_c[k] * ae[k] * dti - self.Ref.rho0_c[k] * ae[k] * whalf[k] * dzi + rho_ae_K_m[k] * dzi * dzi + rho_ae_K_m[k-1] * dzi * dzi + D_env - + self.Ref.rho0_half[k] * ae[k] * self.tke_diss_coeff * sqrt(fmax(self.EnvVar.TKE.values[k],0.0))/fmax(self.mixing_length[k],1.0)) - c[kk] = (self.Ref.rho0_half[k+1] * ae[k+1] * whalf[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) - x[kk] = (self.Ref.rho0_half[k] * ae_old[k] * self.EnvVar.TKE.values[k] * dti + + self.Ref.rho0_c[k] * ae[k] * self.tke_diss_coeff * sqrt(fmax(self.EnvVar.TKE.values[k],0.0))/fmax(self.mixing_length[k],1.0)) + c[kk] = (self.Ref.rho0_c[k+1] * ae[k+1] * whalf[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) + x[kk] = (self.Ref.rho0_c[k] * ae_old[k] * self.EnvVar.TKE.values[k] * dti + self.tke_shear[k] + self.tke_buoy[k] + self.tke_entr_gain[k] + self.tke_pressure[k]) a[0] = 0.0 b[0] = 1.0 @@ -1705,7 +1703,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): + (1.0 - self.UpdVar.Area.bulkvalues[k]) * self.EnvVar.T.values[k]) qv = GMV.QT.values[k] - GMV.QL.values[k] - GMV.THL.values[k] = t_to_thetali_c(self.Ref.p0_half[k], GMV.T.values[k], GMV.QT.values[k], + GMV.THL.values[k] = t_to_thetali_c(self.Ref.p0_c[k], GMV.T.values[k], GMV.QT.values[k], GMV.QL.values[k], 0.0) GMV.B.values[k] = (self.UpdVar.Area.bulkvalues[k] * self.UpdVar.B.bulkvalues[k] + (1.0 - self.UpdVar.Area.bulkvalues[k]) * self.EnvVar.B.values[k]) @@ -1743,7 +1741,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(self.Gr.nzg): - z = self.Gr.z_half[k] + z = self.Gr.z_c[k] GMV.Hvar.values[k] = GMV.Hvar.values[self.Gr.gw] * GMV.TKE.values[k] / GMV.TKE.values[self.Gr.gw] GMV.QTvar.values[k] = GMV.QTvar.values[self.Gr.gw] * GMV.TKE.values[k] / GMV.TKE.values[self.Gr.gw] GMV.HQTcov.values[k] = GMV.HQTcov.values[self.Gr.gw] * GMV.TKE.values[k] / GMV.TKE.values[self.Gr.gw] @@ -1783,9 +1781,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): dH_high = (self.EnvVar.H.values[k+1] - self.EnvVar.H.values[k]) * self.Gr.dzi dQT_low = dQT_high dQT_high = (self.EnvVar.QT.values[k+1] - self.EnvVar.QT.values[k]) * self.Gr.dzi - self.Hvar_shear[k] = 2.0*(self.Ref.rho0_half[k] * ae[k] * self.KH.values[k] *pow(interp2pt(dH_low, dH_high),2.0)) - self.QTvar_shear[k] = 2.0*(self.Ref.rho0_half[k] * ae[k] * self.KH.values[k] *pow(interp2pt(dQT_low, dQT_high),2.0)) - self.HQTcov_shear[k] = 2.0*(self.Ref.rho0_half[k] * ae[k] * self.KH.values[k] *interp2pt(dH_low, dH_high)*interp2pt(dQT_low, dQT_high)) + self.Hvar_shear[k] = 2.0*(self.Ref.rho0_c[k] * ae[k] * self.KH.values[k] *pow(interp2pt(dH_low, dH_high),2.0)) + self.QTvar_shear[k] = 2.0*(self.Ref.rho0_c[k] * ae[k] * self.KH.values[k] *pow(interp2pt(dQT_low, dQT_high),2.0)) + self.HQTcov_shear[k] = 2.0*(self.Ref.rho0_c[k] * ae[k] * self.KH.values[k] *interp2pt(dH_low, dH_high)*interp2pt(dQT_low, dQT_high)) return cpdef compute_covariance_entr(self): @@ -1806,9 +1804,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.Hvar_entr_gain[k] += self.UpdVar.Area.values[i,k] * fabs(self.UpdVar.W.values[i,k]) * self.detr_sc[i,k] * (H_u - H_env) * (H_u - H_env) self.QTvar_entr_gain[k] += self.UpdVar.Area.values[i,k] * fabs(self.UpdVar.W.values[i,k]) * self.detr_sc[i,k] * (QT_u - QT_env) * (QT_u - QT_env) self.HQTcov_entr_gain[k] += self.UpdVar.Area.values[i,k] * fabs(self.UpdVar.W.values[i,k]) * self.detr_sc[i,k] * (H_u - H_env) * (QT_u - QT_env) - self.Hvar_entr_gain[k] *= self.Ref.rho0_half[k] - self.QTvar_entr_gain[k] *= self.Ref.rho0_half[k] - self.HQTcov_entr_gain[k] *= self.Ref.rho0_half[k] + self.Hvar_entr_gain[k] *= self.Ref.rho0_c[k] + self.QTvar_entr_gain[k] *= self.Ref.rho0_c[k] + self.HQTcov_entr_gain[k] *= self.Ref.rho0_c[k] return cpdef compute_covariance_detr(self): @@ -1824,9 +1822,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.Hvar_detr_loss[k] += self.UpdVar.Area.values[i,k] * fabs(self.UpdVar.W.values[i,k]) * self.entr_sc[i,k] self.QTvar_detr_loss[k] += self.UpdVar.Area.values[i,k] * fabs(self.UpdVar.W.values[i,k]) * self.entr_sc[i,k] self.HQTcov_detr_loss[k] += self.UpdVar.Area.values[i,k] * fabs(self.UpdVar.W.values[i,k]) * self.entr_sc[i,k] - self.Hvar_detr_loss[k] *= self.Ref.rho0_half[k] * self.EnvVar.Hvar.values[k] - self.QTvar_detr_loss[k] *= self.Ref.rho0_half[k] * self.EnvVar.QTvar.values[k] - self.HQTcov_detr_loss[k] *= self.Ref.rho0_half[k] * self.EnvVar.HQTcov.values[k] + self.Hvar_detr_loss[k] *= self.Ref.rho0_c[k] * self.EnvVar.Hvar.values[k] + self.QTvar_detr_loss[k] *= self.Ref.rho0_c[k] * self.EnvVar.QTvar.values[k] + self.HQTcov_detr_loss[k] *= self.Ref.rho0_c[k] * self.EnvVar.HQTcov.values[k] return cpdef compute_covariance_rain(self, TimeStepping TS, GridMeanVariables GMV): @@ -1837,9 +1835,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - self.Hvar_rain[k] = self.Ref.rho0_half[k] * ae[k] * 2. * self.EnvThermo.Hvar_rain_dt[k] * TS.dti - self.QTvar_rain[k] = self.Ref.rho0_half[k] * ae[k] * 2. * self.EnvThermo.QTvar_rain_dt[k] * TS.dti - self.HQTcov_rain[k] = self.Ref.rho0_half[k] * ae[k] * self.EnvThermo.HQTcov_rain_dt[k] * TS.dti + self.Hvar_rain[k] = self.Ref.rho0_c[k] * ae[k] * 2. * self.EnvThermo.Hvar_rain_dt[k] * TS.dti + self.QTvar_rain[k] = self.Ref.rho0_c[k] * ae[k] * 2. * self.EnvThermo.QTvar_rain_dt[k] * TS.dti + self.HQTcov_rain[k] = self.Ref.rho0_c[k] * ae[k] * self.EnvThermo.HQTcov_rain_dt[k] * TS.dti return @@ -1851,8 +1849,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Py_ssize_t nz = self.Gr.nz double dzi = self.Gr.dzi double dti = TS.dti - double alpha0LL = self.Ref.alpha0_half[self.Gr.gw] - double zLL = self.Gr.z_half[self.Gr.gw] + double alpha0LL = self.Ref.alpha0_c[self.Gr.gw] + double zLL = self.Gr.z_c[self.Gr.gw] double [:] a = np.zeros((nz,),dtype=np.double, order='c') # for tridiag solver double [:] b = np.zeros((nz,),dtype=np.double, order='c') # for tridiag solver double [:] c = np.zeros((nz,),dtype=np.double, order='c') # for tridiag solver @@ -1875,7 +1873,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(1,nzg-1): - rho_ae_K_m[k] = 0.5 * (ae[k]*self.KH.values[k]+ ae[k+1]*self.KH.values[k+1]) * self.Ref.rho0[k] + rho_ae_K_m[k] = 0.5 * (ae[k]*self.KH.values[k]+ ae[k+1]*self.KH.values[k+1]) * self.Ref.rho0_f[k] whalf[k] = self.EnvVar.W.values[k] Hhalf[k] = self.EnvVar.H.values[k] QThalf[k] = self.EnvVar.QT.values[k] @@ -1909,16 +1907,16 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for i in xrange(self.n_updrafts): wu_half = self.UpdVar.W.values[i,k] - D_env += self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * wu_half * self.entr_sc[i,k] + D_env += self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * wu_half * self.entr_sc[i,k] a[kk] = (- rho_ae_K_m[k-1] * dzi * dzi ) - b[kk] = (self.Ref.rho0_half[k] * ae[k] * dti - self.Ref.rho0_half[k] * ae[k] * whalf[k] * dzi + b[kk] = (self.Ref.rho0_c[k] * ae[k] * dti - self.Ref.rho0_c[k] * ae[k] * whalf[k] * dzi + rho_ae_K_m[k] * dzi * dzi + rho_ae_K_m[k-1] * dzi * dzi + D_env - + self.Ref.rho0_half[k] * ae[k] * self.tke_diss_coeff + + self.Ref.rho0_c[k] * ae[k] * self.tke_diss_coeff *sqrt(fmax(self.EnvVar.TKE.values[k],0))/fmax(self.mixing_length[k],1.0)) - c[kk] = (self.Ref.rho0_half[k+1] * ae[k+1] * whalf[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) - x[kk] = (self.Ref.rho0_half[k] * ae_old[k] * self.EnvVar.Hvar.values[k] * dti + c[kk] = (self.Ref.rho0_c[k+1] * ae[k+1] * whalf[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) + x[kk] = (self.Ref.rho0_c[k] * ae_old[k] * self.EnvVar.Hvar.values[k] * dti + self.Hvar_shear[k] + self.Hvar_entr_gain[k]) # a[0] = 0.0 @@ -1947,16 +1945,16 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for i in xrange(self.n_updrafts): wu_half = self.UpdVar.W.values[i,k] - D_env += self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * wu_half * self.entr_sc[i,k] + D_env += self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * wu_half * self.entr_sc[i,k] a[kk] = (- rho_ae_K_m[k-1] * dzi * dzi ) - b[kk] = (self.Ref.rho0_half[k] * ae[k] * dti - self.Ref.rho0_half[k] * ae[k] * whalf[k] * dzi + b[kk] = (self.Ref.rho0_c[k] * ae[k] * dti - self.Ref.rho0_c[k] * ae[k] * whalf[k] * dzi + rho_ae_K_m[k] * dzi * dzi + rho_ae_K_m[k-1] * dzi * dzi + D_env - + self.Ref.rho0_half[k] * ae[k] * self.tke_diss_coeff + + self.Ref.rho0_c[k] * ae[k] * self.tke_diss_coeff *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0)) - c[kk] = (self.Ref.rho0_half[k+1] * ae[k+1] * whalf[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) - x[kk] = (self.Ref.rho0_half[k] * ae_old[k] * self.EnvVar.QTvar.values[k] * dti + c[kk] = (self.Ref.rho0_c[k+1] * ae[k+1] * whalf[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) + x[kk] = (self.Ref.rho0_c[k] * ae_old[k] * self.EnvVar.QTvar.values[k] * dti + self.QTvar_shear[k] + self.QTvar_entr_gain[k] + self.QTvar_rain[k]) a[0] = 0.0 @@ -1986,16 +1984,16 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): for i in xrange(self.n_updrafts): wu_half = self.UpdVar.W.values[i,k] - D_env += self.Ref.rho0_half[k] * self.UpdVar.Area.values[i,k] * wu_half * self.entr_sc[i,k] + D_env += self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * wu_half * self.entr_sc[i,k] a[kk] = (- rho_ae_K_m[k-1] * dzi * dzi ) - b[kk] = (self.Ref.rho0_half[k] * ae[k] * dti - self.Ref.rho0_half[k] * ae[k] * whalf[k] * dzi + b[kk] = (self.Ref.rho0_c[k] * ae[k] * dti - self.Ref.rho0_c[k] * ae[k] * whalf[k] * dzi + rho_ae_K_m[k] * dzi * dzi + rho_ae_K_m[k-1] * dzi * dzi + D_env - + self.Ref.rho0_half[k] * ae[k] * self.tke_diss_coeff + + self.Ref.rho0_c[k] * ae[k] * self.tke_diss_coeff *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0)) - c[kk] = (self.Ref.rho0_half[k+1] * ae[k+1] * whalf[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) - x[kk] = (self.Ref.rho0_half[k] * ae_old[k] * self.EnvVar.HQTcov.values[k] * dti + c[kk] = (self.Ref.rho0_c[k+1] * ae[k+1] * whalf[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) + x[kk] = (self.Ref.rho0_c[k] * ae_old[k] * self.EnvVar.HQTcov.values[k] * dti + self.HQTcov_shear[k] + self.HQTcov_entr_gain[k] + self.HQTcov_rain[k]) a[0] = 0.0 @@ -2027,11 +2025,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - self.Hvar_dissipation[k] = (self.Ref.rho0_half[k] * ae[k] * self.EnvVar.Hvar.values[k] + self.Hvar_dissipation[k] = (self.Ref.rho0_c[k] * ae[k] * self.EnvVar.Hvar.values[k] *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0) * self.tke_diss_coeff) - self.QTvar_dissipation[k] = (self.Ref.rho0_half[k] * ae[k] * self.EnvVar.QTvar.values[k] + self.QTvar_dissipation[k] = (self.Ref.rho0_c[k] * ae[k] * self.EnvVar.QTvar.values[k] *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0) * self.tke_diss_coeff) - self.HQTcov_dissipation[k] = (self.Ref.rho0_half[k] * ae[k] * self.EnvVar.HQTcov.values[k] + self.HQTcov_dissipation[k] = (self.Ref.rho0_c[k] * ae[k] * self.EnvVar.HQTcov.values[k] *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0) * self.tke_diss_coeff) return diff --git a/Variables.pyx b/Variables.pyx index a9a380d7..706d6d40 100644 --- a/Variables.pyx +++ b/Variables.pyx @@ -254,7 +254,7 @@ cdef class GridMeanVariables: Stats.write_profile('HQTcov_mean',self.HQTcov.values[self.Gr.gw:self.Gr.nzg-self.Gr.gw]) for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - lwp += self.Ref.rho0_half[k]*self.QL.values[k]*self.Gr.dz + lwp += self.Ref.rho0_c[k]*self.QL.values[k]*self.Gr.dz Stats.write_ts('lwp', lwp) return @@ -269,13 +269,13 @@ cdef class GridMeanVariables: for k in xrange(self.Gr.nzg): h = self.H.values[k] qt = self.QT.values[k] - p0 = self.Ref.p0_half[k] + p0 = self.Ref.p0_c[k] sa = eos(self.t_to_prog_fp,self.prog_to_t_fp, p0, qt, h ) self.QL.values[k] = sa.ql self.T.values[k] = sa.T qv = qt - sa.ql self.THL.values[k] = t_to_thetali_c(p0, sa.T, qt, sa.ql,0.0) alpha = alpha_c(p0, sa.T, qt, qv) - self.B.values[k] = buoyancy_c(self.Ref.alpha0_half[k], alpha) + self.B.values[k] = buoyancy_c(self.Ref.alpha0_c[k], alpha) return From 1c11c249bcfb67fb20258e9e46fce682f7b3df23 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Tue, 25 Sep 2018 15:52:47 -0700 Subject: [PATCH 121/136] unified covariances running for Soares with clipping --- EDMF_Environment.pxd | 26 +- EDMF_Environment.pyx | 32 +- Turbulence_PrognosticTKE.pxd | 40 +- Turbulence_PrognosticTKE.pyx | 836 +++++++++++------------------------ 4 files changed, 327 insertions(+), 607 deletions(-) diff --git a/EDMF_Environment.pxd b/EDMF_Environment.pxd index b04feeff..388ede27 100644 --- a/EDMF_Environment.pxd +++ b/EDMF_Environment.pxd @@ -13,6 +13,22 @@ cdef class EnvironmentVariable: str name str units +cdef class EnvironmentVariable_2m: + cdef: + double [:] values + double [:] dissipation + double [:] shear + double [:] entr_gain + double [:] detr_loss + double [:] press + double [:] buoy + double [:] interdomain + double [:] rain_src + str loc + str kind + str name + str units + cdef class EnvironmentVariables: cdef: @@ -24,12 +40,12 @@ cdef class EnvironmentVariables: EnvironmentVariable THL EnvironmentVariable T EnvironmentVariable B - EnvironmentVariable TKE - EnvironmentVariable Hvar - EnvironmentVariable QTvar - EnvironmentVariable HQTcov + EnvironmentVariable_2m TKE + EnvironmentVariable_2m Hvar + EnvironmentVariable_2m QTvar + EnvironmentVariable_2m HQTcov EnvironmentVariable CF - EnvironmentVariable THVvar + EnvironmentVariable_2m THVvar Grid Gr bint calc_tke bint calc_scalar_var diff --git a/EDMF_Environment.pyx b/EDMF_Environment.pyx index a684a134..47e8d337 100644 --- a/EDMF_Environment.pyx +++ b/EDMF_Environment.pyx @@ -29,6 +29,26 @@ cdef class EnvironmentVariable: self.name = name self.units = units +cdef class EnvironmentVariable_2m: + def __init__(self, nz, loc, kind, name, units): + self.values = np.zeros((nz,),dtype=np.double, order='c') + self.dissipation = np.zeros((nz,),dtype=np.double, order='c') + self.entr_gain = np.zeros((nz,),dtype=np.double, order='c') + self.detr_loss = np.zeros((nz,),dtype=np.double, order='c') + self.buoy = np.zeros((nz,),dtype=np.double, order='c') + self.press = np.zeros((nz,),dtype=np.double, order='c') + self.shear = np.zeros((nz,),dtype=np.double, order='c') + self.interdomain = np.zeros((nz,),dtype=np.double, order='c') + self.rain_src = np.zeros((nz,),dtype=np.double, order='c') + if loc != 'half': + print('Invalid location setting for variable! Must be half') + self.loc = loc + if kind != 'scalar' and kind != 'velocity': + print ('Invalid kind setting for variable! Must be scalar or velocity') + self.kind = kind + self.name = name + self.units = units + cdef class EnvironmentVariables: def __init__(self, namelist, Grid Gr ): @@ -71,16 +91,16 @@ cdef class EnvironmentVariables: print('Defaulting to saturation adjustment with respect to environmental means') if self.calc_tke: - self.TKE = EnvironmentVariable( nz, 'half', 'scalar', 'tke','m^2/s^2' ) + self.TKE = EnvironmentVariable_2m( nz, 'half', 'scalar', 'tke','m^2/s^2' ) if self.calc_scalar_var: - self.QTvar = EnvironmentVariable( nz, 'half', 'scalar', 'qt_var','kg^2/kg^2' ) + self.QTvar = EnvironmentVariable_2m( nz, 'half', 'scalar', 'qt_var','kg^2/kg^2' ) if namelist['thermodynamics']['thermal_variable'] == 'entropy': - self.Hvar = EnvironmentVariable(nz, 'half', 'scalar', 's_var', '(J/kg/K)^2') - self.HQTcov = EnvironmentVariable(nz, 'half', 'scalar', 's_qt_covar', '(J/kg/K)(kg/kg)' ) + self.Hvar = EnvironmentVariable_2m(nz, 'half', 'scalar', 's_var', '(J/kg/K)^2') + self.HQTcov = EnvironmentVariable_2m(nz, 'half', 'scalar', 's_qt_covar', '(J/kg/K)(kg/kg)' ) elif namelist['thermodynamics']['thermal_variable'] == 'thetal': - self.Hvar = EnvironmentVariable(nz, 'half', 'scalar', 'thetal_var', 'K^2') - self.HQTcov = EnvironmentVariable(nz, 'half', 'scalar', 'thetal_qt_covar', 'K(kg/kg)' ) + self.Hvar = EnvironmentVariable_2m(nz, 'half', 'scalar', 'thetal_var', 'K^2') + self.HQTcov = EnvironmentVariable_2m(nz, 'half', 'scalar', 'thetal_qt_covar', 'K(kg/kg)' ) if self.EnvThermo_scheme == 'sommeria_deardorff': self.THVvar = EnvironmentVariable(nz, 'half', 'scalar', 'thetav_var', 'K^2' ) diff --git a/Turbulence_PrognosticTKE.pxd b/Turbulence_PrognosticTKE.pxd index 8c1481a6..8c81f8cb 100644 --- a/Turbulence_PrognosticTKE.pxd +++ b/Turbulence_PrognosticTKE.pxd @@ -92,9 +92,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cpdef compute_prognostic_updrafts(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS) cpdef compute_diagnostic_updrafts(self, GridMeanVariables GMV, CasesBase Case) cpdef update_inversion(self, GridMeanVariables GMV, option) - cpdef compute_mixing_length(self, double obukhov_length) + cpdef compute_mixing_length(self, double obukhov_length, GridMeanVariables GMV) cpdef compute_eddy_diffusivities_tke(self, GridMeanVariables GMV, CasesBase Case) - cpdef reset_surface_tke(self, GridMeanVariables GMV, CasesBase Case) cpdef reset_surface_covariance(self, GridMeanVariables GMV, CasesBase Case) cpdef set_updraft_surface_bc(self, GridMeanVariables GMV, CasesBase Case) cpdef decompose_environment(self, GridMeanVariables GMV, whichvals) @@ -105,42 +104,35 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cpdef upwind_integration(self, EDMF_Updrafts.UpdraftVariable area, EDMF_Updrafts.UpdraftVariable var, int k, int i, double env_var, double dzi) cpdef update_GMV_MF(self, GridMeanVariables GMV, TimeStepping TS) cpdef update_GMV_ED(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS) - cpdef compute_tke(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS) cpdef compute_covariance(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS) - cpdef initialize_tke(self, GridMeanVariables GMV, CasesBase Case) cpdef initialize_covariance(self, GridMeanVariables GMV, CasesBase Case) cpdef cleanup_covariance(self, GridMeanVariables GMV) cpdef compute_tke_buoy(self, GridMeanVariables GMV) - cpdef compute_tke_dissipation(self) - cpdef compute_covariance_dissipation(self) - cpdef compute_tke_entr(self) - cpdef compute_covariance_entr(self) - cpdef compute_tke_detr(self) - cpdef compute_covariance_detr(self) - cpdef compute_tke_shear(self, GridMeanVariables GMV) - cpdef compute_covariance_shear(self, GridMeanVariables GMV) cpdef compute_tke_pressure(self) + cdef void compute_covariance_detr(self, EDMF_Environment.EnvironmentVariable_2m Covar) + cdef void compute_covariance_entr(self, EDMF_Environment.EnvironmentVariable_2m Covar, EDMF_Updrafts.UpdraftVariable UpdVar1, + EDMF_Updrafts.UpdraftVariable UpdVar2, EDMF_Environment.EnvironmentVariable EnvVar1, EDMF_Environment.EnvironmentVariable EnvVar2) + cdef void compute_covariance_dissipation(self, EDMF_Environment.EnvironmentVariable_2m Covar) + cdef void compute_covariance_shear(self,GridMeanVariables GMV, EDMF_Environment.EnvironmentVariable_2m Covar, double *UpdVar1, double *UpdVar2, double *EnvVar1, double *EnvVar2) + cdef void compute_covariance_interdomain_src(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable phi_u, EDMF_Updrafts.UpdraftVariable psi_u, + EDMF_Environment.EnvironmentVariable phi_e, EDMF_Environment.EnvironmentVariable psi_e, EDMF_Environment.EnvironmentVariable_2m covar_e) + cdef void update_covariance_ED(self, GridMeanVariables GMV, CasesBase Case,TimeStepping TS, VariablePrognostic GmvVar1, VariablePrognostic GmvVar2, + VariableDiagnostic GmvCovar, EDMF_Environment.EnvironmentVariable_2m Covar, EDMF_Environment.EnvironmentVariable EnvVar1, EDMF_Environment.EnvironmentVariable EnvVar2, + EDMF_Updrafts.UpdraftVariable UpdVar1, EDMF_Updrafts.UpdraftVariable UpdVar2) cpdef compute_covariance_rain(self, TimeStepping TS, GridMeanVariables GMV) - cpdef update_tke_ED(self, GridMeanVariables GMV, CasesBase Case,TimeStepping TS) - cpdef update_covariance_ED(self, GridMeanVariables GMV, CasesBase Case,TimeStepping TS) cpdef update_GMV_diagnostics(self, GridMeanVariables GMV) - cdef get_GMV_TKE(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable wu, - EDMF_Environment.EnvironmentVariable we, EDMF_Environment.EnvironmentVariable tke_e, - double *gmv_w, double *gmv_tke) - cdef get_env_tke_from_GMV(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable wu, - EDMF_Environment.EnvironmentVariable we, EDMF_Environment.EnvironmentVariable tke_e, - double *gmv_w, double *gmv_tke) - + # cdef get_env_tke_from_GMV(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable wu, + # EDMF_Environment.EnvironmentVariable we, EDMF_Environment.EnvironmentVariable tke_e, + # double *gmv_w, double *gmv_tke) cdef get_GMV_CoVar(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable phi_u, EDMF_Updrafts.UpdraftVariable psi_u, EDMF_Environment.EnvironmentVariable phi_e, EDMF_Environment.EnvironmentVariable psi_e, - EDMF_Environment.EnvironmentVariable covar_e, + EDMF_Environment.EnvironmentVariable_2m covar_e, double *gmv_phi, double *gmv_psi, double *gmv_covar) - cdef get_env_covar_from_GMV(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable phi_u, EDMF_Updrafts.UpdraftVariable psi_u, EDMF_Environment.EnvironmentVariable phi_e, EDMF_Environment.EnvironmentVariable psi_e, - EDMF_Environment.EnvironmentVariable covar_e, + EDMF_Environment.EnvironmentVariable_2m covar_e, double *gmv_phi, double *gmv_psi, double *gmv_covar) cpdef nan_check(self, line, GridMeanVariables GMV, int k) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 75bf12ba..af345278 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -67,8 +67,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.entr_detr_fp = entr_detr_inverse_w elif str(namelist['turbulence']['EDMF_PrognosticTKE']['entrainment']) == 'b_w2': self.entr_detr_fp = entr_detr_b_w2 - elif str(namelist['turbulence']['EDMF_PrognosticTKE']['entrainment']) == 'buoyancy_sorting': - self.entr_detr_fp = entr_detr_buoyancy_sorting elif str(namelist['turbulence']['EDMF_PrognosticTKE']['entrainment']) == 'entr_detr_tke': self.entr_detr_fp = entr_detr_tke elif str(namelist['turbulence']['EDMF_PrognosticTKE']['entrainment']) == 'entr_detr_tke2': @@ -145,35 +143,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # mixing length self.mixing_length = np.zeros((Gr.nzg,),dtype=np.double, order='c') - if self.calc_tke: - # environmental tke source terms - self.tke_buoy = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.tke_dissipation = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.tke_entr_gain = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.tke_detr_loss = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.tke_shear = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.tke_pressure = np.zeros((Gr.nzg,),dtype=np.double, order='c') - - if self.calc_scalar_var: - #self.Hvar = np.zeros((Gr.nzg,),dtype=np.double, order='c') - #self.QTvar = np.zeros((Gr.nzg,),dtype=np.double, order='c') - #self.HQTcov = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.Hvar_dissipation = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.QTvar_dissipation = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.HQTcov_dissipation = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.Hvar_entr_gain = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.QTvar_entr_gain = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.HQTcov_entr_gain = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.Hvar_detr_loss = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.QTvar_detr_loss = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.HQTcov_detr_loss = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.Hvar_shear = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.QTvar_shear = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.HQTcov_shear = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.Hvar_rain = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.QTvar_rain = np.zeros((Gr.nzg,),dtype=np.double, order='c') - self.HQTcov_rain = np.zeros((Gr.nzg,),dtype=np.double, order='c') - # Near-surface BC of updraft area fraction self.area_surface_bc= np.zeros((self.n_updrafts,),dtype=np.double, order='c') self.w_surface_bc= np.zeros((self.n_updrafts,),dtype=np.double, order='c') @@ -194,8 +163,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.massflux_qt = np.zeros((Gr.nzg,),dtype=np.double,order='c') self.diffusive_flux_h = np.zeros((Gr.nzg,),dtype=np.double,order='c') self.diffusive_flux_qt = np.zeros((Gr.nzg,),dtype=np.double,order='c') - if self.calc_tke: - self.massflux_tke = np.zeros((Gr.nzg,),dtype=np.double,order='c') return @@ -235,7 +202,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Stats.add_profile('tke_detr_loss') Stats.add_profile('tke_shear') Stats.add_profile('tke_pressure') - Stats.add_profile('massflux_tke') + Stats.add_profile('tke_interdomain') if self.calc_scalar_var: Stats.add_profile('Hvar_dissipation') @@ -243,16 +210,19 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Stats.add_profile('HQTcov_dissipation') Stats.add_profile('Hvar_entr_gain') Stats.add_profile('QTvar_entr_gain') - Stats.add_profile('HQTcov_entr_gain') Stats.add_profile('Hvar_detr_loss') Stats.add_profile('QTvar_detr_loss') Stats.add_profile('HQTcov_detr_loss') + Stats.add_profile('HQTcov_entr_gain') Stats.add_profile('Hvar_shear') Stats.add_profile('QTvar_shear') Stats.add_profile('HQTcov_shear') Stats.add_profile('Hvar_rain') Stats.add_profile('QTvar_rain') Stats.add_profile('HQTcov_rain') + Stats.add_profile('Hvar_interdomain') + Stats.add_profile('QTvar_interdomain') + Stats.add_profile('HQTcov_interdomain') return @@ -302,37 +272,41 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Stats.write_profile('updraft_thetal_precip', self.UpdMicro.prec_source_h_tot[kmin:kmax]) if self.calc_tke: - Stats.write_profile('tke_buoy', self.tke_buoy[kmin:kmax]) - self.compute_tke_dissipation() - Stats.write_profile('tke_dissipation', self.tke_dissipation[kmin:kmax]) - Stats.write_profile('tke_entr_gain', self.tke_entr_gain[kmin:kmax]) - self.compute_tke_detr() - Stats.write_profile('tke_detr_loss', self.tke_detr_loss[kmin:kmax]) - Stats.write_profile('tke_shear', self.tke_shear[kmin:kmax]) - Stats.write_profile('tke_pressure', self.tke_pressure[kmin:kmax]) - Stats.write_profile('massflux_tke', self.massflux_tke[kmin-1:kmax-1]) + self.compute_covariance_dissipation(self.EnvVar.TKE) + Stats.write_profile('tke_dissipation', self.EnvVar.TKE.dissipation[kmin:kmax]) + Stats.write_profile('tke_entr_gain', self.EnvVar.TKE.entr_gain[kmin:kmax]) + self.compute_covariance_detr(self.EnvVar.TKE) + Stats.write_profile('tke_detr_loss', self.EnvVar.TKE.detr_loss[kmin:kmax]) + Stats.write_profile('tke_shear', self.EnvVar.TKE.shear[kmin:kmax]) + Stats.write_profile('tke_buoy', self.EnvVar.TKE.buoy[kmin:kmax]) + Stats.write_profile('tke_pressure', self.EnvVar.TKE.press[kmin:kmax]) + Stats.write_profile('tke_interdomain', self.EnvVar.TKE.interdomain[kmin:kmax]) if self.calc_scalar_var: - #Stats.write_profile('Hvar', self.Hvar[kmin:kmax]) - #Stats.write_profile('QTvar', self.QTvar[kmin:kmax]) - #Stats.write_profile('HQTcov', self.HQTcov[kmin:kmax]) - self.compute_covariance_dissipation() - Stats.write_profile('Hvar_dissipation', self.Hvar_dissipation[kmin:kmax]) - Stats.write_profile('QTvar_dissipation', self.QTvar_dissipation[kmin:kmax]) - Stats.write_profile('HQTcov_dissipation', self.HQTcov_dissipation[kmin:kmax]) - Stats.write_profile('Hvar_entr_gain', self.Hvar_entr_gain[kmin:kmax]) - Stats.write_profile('QTvar_entr_gain', self.QTvar_entr_gain[kmin:kmax]) - Stats.write_profile('HQTcov_entr_gain', self.HQTcov_entr_gain[kmin:kmax]) - self.compute_covariance_detr() - Stats.write_profile('Hvar_detr_loss', self.Hvar_detr_loss[kmin:kmax]) - Stats.write_profile('QTvar_detr_loss', self.QTvar_detr_loss[kmin:kmax]) - Stats.write_profile('HQTcov_detr_loss', self.HQTcov_detr_loss[kmin:kmax]) - Stats.write_profile('Hvar_shear', self.Hvar_shear[kmin:kmax]) - Stats.write_profile('QTvar_shear', self.QTvar_shear[kmin:kmax]) - Stats.write_profile('HQTcov_shear', self.HQTcov_shear[kmin:kmax]) - Stats.write_profile('Hvar_rain', self.Hvar_rain[kmin:kmax]) - Stats.write_profile('QTvar_rain', self.QTvar_rain[kmin:kmax]) - Stats.write_profile('HQTcov_rain', self.HQTcov_rain[kmin:kmax]) + self.compute_covariance_dissipation(self.EnvVar.Hvar) + Stats.write_profile('Hvar_dissipation', self.EnvVar.Hvar.dissipation[kmin:kmax]) + self.compute_covariance_dissipation(self.EnvVar.QTvar) + Stats.write_profile('QTvar_dissipation', self.EnvVar.QTvar.dissipation[kmin:kmax]) + self.compute_covariance_dissipation(self.EnvVar.HQTcov) + Stats.write_profile('HQTcov_dissipation', self.EnvVar.HQTcov.dissipation[kmin:kmax]) + Stats.write_profile('Hvar_entr_gain', self.EnvVar.Hvar.entr_gain[kmin:kmax]) + Stats.write_profile('QTvar_entr_gain', self.EnvVar.QTvar.entr_gain[kmin:kmax]) + Stats.write_profile('HQTcov_entr_gain', self.EnvVar.HQTcov.entr_gain[kmin:kmax]) + self.compute_covariance_detr(self.EnvVar.Hvar) + self.compute_covariance_detr(self.EnvVar.QTvar) + self.compute_covariance_detr(self.EnvVar.HQTcov) + Stats.write_profile('Hvar_detr_loss', self.EnvVar.Hvar.detr_loss[kmin:kmax]) + Stats.write_profile('QTvar_detr_loss', self.EnvVar.QTvar.detr_loss[kmin:kmax]) + Stats.write_profile('HQTcov_detr_loss', self.EnvVar.HQTcov.detr_loss[kmin:kmax]) + Stats.write_profile('Hvar_shear', self.EnvVar.Hvar.shear[kmin:kmax]) + Stats.write_profile('QTvar_shear', self.EnvVar.QTvar.shear[kmin:kmax]) + Stats.write_profile('HQTcov_shear', self.EnvVar.HQTcov.shear[kmin:kmax]) + Stats.write_profile('Hvar_rain', self.EnvVar.Hvar.rain_src[kmin:kmax]) + Stats.write_profile('QTvar_rain', self.EnvVar.QTvar.rain_src[kmin:kmax]) + Stats.write_profile('HQTcov_rain', self.EnvVar.HQTcov.rain_src[kmin:kmax]) + Stats.write_profile('Hvar_interdomain', self.EnvVar.Hvar.interdomain[kmin:kmax]) + Stats.write_profile('QTvar_interdomain', self.EnvVar.QTvar.interdomain[kmin:kmax]) + Stats.write_profile('HQTcov_interdomain', self.EnvVar.HQTcov.interdomain[kmin:kmax]) return @@ -351,10 +325,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.wstar = get_wstar(Case.Sur.bflux, self.zi) if TS.nstep == 0: - if self.calc_tke: - self.initialize_tke(GMV, Case) - if self.calc_scalar_var: - self.initialize_covariance(GMV, Case) + self.initialize_covariance(GMV, Case) with nogil: for k in xrange(self.Gr.nzg): if self.calc_tke: @@ -387,12 +358,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdThermo.buoyancy(self.UpdVar, self.EnvVar, GMV, self.extrapolate_buoyancy) self.compute_eddy_diffusivities_tke(GMV, Case) - self.update_GMV_ED(GMV, Case, TS) - if self.calc_tke: - self.compute_tke(GMV, Case, TS) - if self.calc_scalar_var: - self.compute_covariance(GMV, Case, TS) + self.compute_covariance(GMV, Case, TS) # Back out the tendencies of the grid mean variables for the whole timestep by differencing GMV.new and # GMV.values @@ -405,22 +372,14 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cdef: Py_ssize_t iter_ double time_elapsed = 0.0 - self.nan_check(408, GMV, 2) self.UpdVar.set_new_with_values() self.UpdVar.set_old_with_values() self.set_updraft_surface_bc(GMV, Case) self.dt_upd = np.minimum(TS.dt, 0.2 * self.Gr.dz/fmax(np.max(self.UpdVar.W.values),1e-10)) - self.nan_check(413, GMV, 2) while time_elapsed < TS.dt: - self.nan_check(414, GMV, 2) self.compute_entrainment_detrainment(GMV, Case) - self.nan_check(416, GMV, 2) self.solve_updraft(GMV,Case,TS) - #self.nan_check(418, GMV, 2) - #self.solve_updraft_velocity_area(GMV,TS) - #self.solve_updraft_scalars(GMV, Case, TS) self.UpdVar.set_values_with_new() - self.nan_check(422, GMV, 2) time_elapsed += self.dt_upd self.dt_upd = np.minimum(TS.dt-time_elapsed, 0.5 * self.Gr.dz/fmax(np.max(self.UpdVar.W.values),1e-10)) # (####) @@ -428,11 +387,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # It would be better to have a simple linear rule for updating environment here # instead of calling EnvThermo saturation adjustment scheme for every updraft. # If we are using quadratures this is expensive and probably unnecessary. - self.nan_check(430, GMV, 2) self.decompose_environment(GMV, 'values') self.EnvThermo.satadjust(self.EnvVar, False) self.UpdThermo.buoyancy(self.UpdVar, self.EnvVar, GMV, self.extrapolate_buoyancy) - self.nan_check(432, GMV, 2) return cpdef compute_diagnostic_updrafts(self, GridMeanVariables GMV, CasesBase Case): @@ -560,51 +517,21 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): return - cpdef compute_tke(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS): - if self.similarity_diffusivity: # otherwise, we computed mixing length when we computed D_T - self.compute_mixing_length(Case.Sur.obukhov_length) - - self.compute_tke_buoy(GMV) - self.compute_tke_entr() - self.compute_tke_shear(GMV) - self.compute_tke_pressure() - - self.reset_surface_tke(GMV, Case) - self.update_tke_ED(GMV, Case, TS) - - - return - - cpdef initialize_tke(self, GridMeanVariables GMV, CasesBase Case): - cdef: - Py_ssize_t k - double ws= self.wstar, us = Case.Sur.ustar, zs = self.zi, z - # Similarity profile initialization of TKE - # Need to consider what to do when neutral/stable - if ws > 0.0: - with nogil: - for k in xrange(self.Gr.nzg): - z = self.Gr.z_c[k] - GMV.TKE.values[k] = ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) - - - self.reset_surface_tke(GMV, Case) - self.compute_mixing_length(Case.Sur.obukhov_length) - return - cpdef update_inversion(self,GridMeanVariables GMV, option): ParameterizationBase.update_inversion(self, GMV,option) return - cpdef compute_mixing_length(self, double obukhov_length): + cpdef compute_mixing_length(self, double obukhov_length, GridMeanVariables GMV): cdef: Py_ssize_t k Py_ssize_t gw = self.Gr.gw double tau = get_mixing_tau(self.zi, self.wstar) - double l1, l2, z_ + double l1, l2, l3, l4, l5, l234, z_ double grad, grad2, H - - + double du = 0.0 + double dv = 0.0 + double dw = 2.0 * self.EnvVar.W.values[gw] * self.Gr.dzi + double H_lapse_rate ,QT_lapse_rate with nogil: for k in xrange(gw, self.Gr.nzg-gw): l1 = tau * sqrt(fmax(self.EnvVar.TKE.values[k],0.0)) @@ -618,6 +545,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.mixing_length[k] = fmax( 1.0/(1.0/fmax(l1,1e-10) + 1.0/l2), 1e-3) return + cpdef compute_eddy_diffusivities_tke(self, GridMeanVariables GMV, CasesBase Case): cdef: Py_ssize_t k @@ -628,7 +556,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): if self.similarity_diffusivity: ParameterizationBase.compute_eddy_diffusivities_similarity(self,GMV, Case) else: - self.compute_mixing_length(Case.Sur.obukhov_length) + self.compute_mixing_length(Case.Sur.obukhov_length, GMV) with nogil: for k in xrange(gw, self.Gr.nzg-gw): lm = self.mixing_length[k] @@ -666,26 +594,24 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.qt_surface_bc[i] = (GMV.QT.values[gw] + surface_scalar_coeff * sqrt(qt_var)) return - cpdef reset_surface_tke(self, GridMeanVariables GMV, CasesBase Case): - GMV.TKE.values[self.Gr.gw] = get_surface_tke(Case.Sur.ustar, - self.wstar, - self.Gr.z_c[self.Gr.gw], - Case.Sur.obukhov_length) - return - cpdef reset_surface_covariance(self, GridMeanVariables GMV, CasesBase Case): - + flux1 = Case.Sur.rho_hflux + flux2 = Case.Sur.rho_qtflux cdef: double zLL = self.Gr.z_c[self.Gr.gw] double ustar = Case.Sur.ustar, oblength = Case.Sur.obukhov_length - double flux1 = Case.Sur.rho_hflux * self.Ref.alpha0_c[self.Gr.gw] - double flux2 = Case.Sur.rho_qtflux * self.Ref.alpha0_c[self.Gr.gw] - - GMV.Hvar.values[self.Gr.gw] = get_surface_variance(flux1, flux1, ustar, zLL, oblength) - GMV.QTvar.values[self.Gr.gw] = get_surface_variance(flux2, flux2, ustar, zLL, oblength) - GMV.HQTcov.values[self.Gr.gw] = get_surface_variance(flux1,flux2, ustar, zLL, oblength) - + double alpha0LL = self.Ref.alpha0_c[self.Gr.gw] + #double get_surface_variance = get_surface_variance(flux1, flux2 ,ustar, zLL, oblength) + if self.calc_tke: + GMV.TKE.values[self.Gr.gw] = get_surface_tke(Case.Sur.ustar, + self.wstar, + self.Gr.z_c[self.Gr.gw], + Case.Sur.obukhov_length) + if self.calc_scalar_var: + GMV.Hvar.values[self.Gr.gw] = get_surface_variance(flux1*alpha0LL,flux1*alpha0LL, ustar, zLL, oblength) + GMV.QTvar.values[self.Gr.gw] = get_surface_variance(flux2*alpha0LL,flux2*alpha0LL, ustar, zLL, oblength) + GMV.HQTcov.values[self.Gr.gw] = get_surface_variance(flux1*alpha0LL,flux2*alpha0LL, ustar, zLL, oblength) return @@ -699,53 +625,41 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cdef: Py_ssize_t k, gw = self.Gr.gw - double val1, val2, au_full + double val1, val2 double Hvar_e, QTvar_e, HQTcov_e, Hvar_u, QTvar_u, HQTcov_u if whichvals == 'values': with nogil: - for k in xrange(self.Gr.nzg-1): + for k in xrange(self.Gr.nzg): val1 = 1.0/(1.0-self.UpdVar.Area.bulkvalues[k]) val2 = self.UpdVar.Area.bulkvalues[k] * val1 self.EnvVar.QT.values[k] = val1 * GMV.QT.values[k] - val2 * self.UpdVar.QT.bulkvalues[k] self.EnvVar.H.values[k] = val1 * GMV.H.values[k] - val2 * self.UpdVar.H.bulkvalues[k] - # Have to account for staggering of W--interpolate area fraction to the "full" grid points - # Assuming GMV.W = 0! - au_full = self.UpdVar.Area.bulkvalues[k] - self.EnvVar.W.values[k] = -au_full/(1.0-au_full) * self.UpdVar.W.bulkvalues[k] + self.EnvVar.W.values[k] = -self.UpdVar.Area.bulkvalues[k]/(1.0-self.UpdVar.Area.bulkvalues[k]) * self.UpdVar.W.bulkvalues[k] if self.calc_tke: - self.get_GMV_TKE(self.UpdVar.Area,self.UpdVar.W, self.EnvVar.W, self.EnvVar.TKE, - &GMV.W.values[0], &GMV.TKE.values[0]) - + self.get_GMV_CoVar(self.UpdVar.Area,self.UpdVar.W, self.UpdVar.W, self.EnvVar.W, self.EnvVar.W, self.EnvVar.TKE, &GMV.W.values[0],&GMV.W.values[0], &GMV.TKE.values[0]) if self.calc_scalar_var: - self.get_GMV_CoVar(self.UpdVar.Area,self.UpdVar.H, self.UpdVar.H, self.EnvVar.H, self.EnvVar.H, self.EnvVar.Hvar, - &GMV.H.values[0],&GMV.H.values[0], &GMV.Hvar.values[0]) - self.get_GMV_CoVar(self.UpdVar.Area,self.UpdVar.QT, self.UpdVar.QT, self.EnvVar.QT, self.EnvVar.QT, self.EnvVar.QTvar, - &GMV.QT.values[0],&GMV.QT.values[0], &GMV.QTvar.values[0]) - self.get_GMV_CoVar(self.UpdVar.Area,self.UpdVar.H, self.UpdVar.QT, self.EnvVar.H, self.EnvVar.QT, self.EnvVar.HQTcov, - &GMV.H.values[0], &GMV.QT.values[0], &GMV.HQTcov.values[0]) + self.get_GMV_CoVar(self.UpdVar.Area,self.UpdVar.H, self.UpdVar.H, self.EnvVar.H, self.EnvVar.H, self.EnvVar.Hvar, &GMV.H.values[0],&GMV.H.values[0], &GMV.Hvar.values[0]) + self.get_GMV_CoVar(self.UpdVar.Area,self.UpdVar.QT,self.UpdVar.QT,self.EnvVar.QT,self.EnvVar.QT,self.EnvVar.QTvar, &GMV.QT.values[0],&GMV.QT.values[0], &GMV.QTvar.values[0]) + self.get_GMV_CoVar(self.UpdVar.Area,self.UpdVar.H, self.UpdVar.QT,self.EnvVar.H, self.EnvVar.QT,self.EnvVar.HQTcov, &GMV.H.values[0],&GMV.QT.values[0], &GMV.HQTcov.values[0]) elif whichvals == 'mf_update': # same as above but replace GMV.SomeVar.values with GMV.SomeVar.mf_update with nogil: - for k in xrange(self.Gr.nzg-1): + for k in xrange(self.Gr.nzg): val1 = 1.0/(1.0-self.UpdVar.Area.bulkvalues[k]) val2 = self.UpdVar.Area.bulkvalues[k] * val1 self.EnvVar.QT.values[k] = val1 * GMV.QT.mf_update[k] - val2 * self.UpdVar.QT.bulkvalues[k] self.EnvVar.H.values[k] = val1 * GMV.H.mf_update[k] - val2 * self.UpdVar.H.bulkvalues[k] - # Have to account for staggering of W # Assuming GMV.W = 0! - au_full = self.UpdVar.Area.bulkvalues[k] - self.EnvVar.W.values[k] = -au_full/(1.0-au_full) * self.UpdVar.W.bulkvalues[k] - + self.EnvVar.W.values[k] = -self.UpdVar.Area.bulkvalues[k]/(1.0-self.UpdVar.Area.bulkvalues[k]) * self.UpdVar.W.bulkvalues[k] if self.calc_tke: - self.get_GMV_TKE(self.UpdVar.Area,self.UpdVar.W, self.EnvVar.W, self.EnvVar.TKE, - &GMV.W.values[0], &GMV.TKE.values[0]) - + self.get_GMV_CoVar(self.UpdVar.Area,self.UpdVar.W, self.UpdVar.W, self.EnvVar.W, self.EnvVar.W, self.EnvVar.TKE, + &GMV.W.values[0],&GMV.W.values[0], &GMV.TKE.values[0]) if self.calc_scalar_var: self.get_GMV_CoVar(self.UpdVar.Area,self.UpdVar.H, self.UpdVar.H, self.EnvVar.H, self.EnvVar.H, self.EnvVar.Hvar, &GMV.H.values[0],&GMV.H.values[0], &GMV.Hvar.values[0]) @@ -756,100 +670,61 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): return - cdef get_GMV_TKE(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable wu, - EDMF_Environment.EnvironmentVariable we, EDMF_Environment.EnvironmentVariable tke_e, - double *gmv_w, double *gmv_tke): - cdef: - Py_ssize_t i,k - double [:] ae = np.subtract(np.ones((self.Gr.nzg,),dtype=np.double, order='c'),au.bulkvalues) - double interp_w_diff - - with nogil: - for k in xrange(self.Gr.nzg): - interp_w_diff = we.values[k]-gmv_w[k] - gmv_tke[k] = ae[k] * 0.5 * interp_w_diff * interp_w_diff + ae[k] * tke_e.values[k] - for i in xrange(self.n_updrafts): - interp_w_diff = wu.values[i,k]-gmv_w[k] - gmv_tke[k] += au.values[i,k] * 0.5 * interp_w_diff * interp_w_diff - return - - - - cdef get_env_tke_from_GMV(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable wu, - EDMF_Environment.EnvironmentVariable we, EDMF_Environment.EnvironmentVariable tke_e, - double *gmv_w, double *gmv_tke): - cdef: - Py_ssize_t i,k - double [:] ae = np.subtract(np.ones((self.Gr.nzg,),dtype=np.double, order='c'),au.bulkvalues) - double interp_w_diff - - with nogil: - for k in xrange(self.Gr.nzg): - if ae[k] > 0.0: - interp_w_diff = we.values[k]-gmv_w[k] - tke_e.values[k] = gmv_tke[k] - ae[k] * 0.5 * interp_w_diff * interp_w_diff - - for i in xrange(self.n_updrafts): - interp_w_diff = wu.values[i,k]-gmv_w[k] - tke_e.values[k] -= au.values[i,k] * 0.5 * interp_w_diff * interp_w_diff - tke_e.values[k] = tke_e.values[k]/ae[k] - else: - tke_e.values[k] = 0.0 - return - - # Note: this assumes all variables are defined on half levels not full levels (i.e. phi, psi are not w) cdef get_GMV_CoVar(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable phi_u, EDMF_Updrafts.UpdraftVariable psi_u, EDMF_Environment.EnvironmentVariable phi_e, EDMF_Environment.EnvironmentVariable psi_e, - EDMF_Environment.EnvironmentVariable covar_e, + EDMF_Environment.EnvironmentVariable_2m covar_e, double *gmv_phi, double *gmv_psi, double *gmv_covar): cdef: Py_ssize_t i,k double [:] ae = np.subtract(np.ones((self.Gr.nzg,),dtype=np.double, order='c'),au.bulkvalues) double phi_diff, psi_diff + double tke_factor = 1.0 + if covar_e.name == 'tke': + tke_factor = 0.5 with nogil: for k in xrange(self.Gr.nzg): phi_diff = phi_e.values[k]-gmv_phi[k] psi_diff = psi_e.values[k]-gmv_psi[k] - gmv_covar[k] = ae[k] * phi_diff * psi_diff + ae[k] * covar_e.values[k] + gmv_covar[k] = tke_factor * ae[k] * phi_diff * psi_diff + ae[k] * covar_e.values[k] for i in xrange(self.n_updrafts): phi_diff = phi_u.values[i,k]-gmv_phi[k] psi_diff = psi_u.values[i,k]-gmv_psi[k] - gmv_covar[k] += au.values[i,k] * phi_diff * psi_diff + gmv_covar[k] += tke_factor * au.values[i,k] * phi_diff * psi_diff return - cdef get_env_covar_from_GMV(self, EDMF_Updrafts.UpdraftVariable au, EDMF_Updrafts.UpdraftVariable phi_u, EDMF_Updrafts.UpdraftVariable psi_u, EDMF_Environment.EnvironmentVariable phi_e, EDMF_Environment.EnvironmentVariable psi_e, - EDMF_Environment.EnvironmentVariable covar_e, + EDMF_Environment.EnvironmentVariable_2m covar_e, double *gmv_phi, double *gmv_psi, double *gmv_covar): cdef: Py_ssize_t i,k double [:] ae = np.subtract(np.ones((self.Gr.nzg,),dtype=np.double, order='c'),au.bulkvalues) double phi_diff, psi_diff + double tke_factor = 1.0 + if covar_e.name == 'tke': + tke_factor = 0.5 with nogil: for k in xrange(self.Gr.nzg): if ae[k] > 0.0: - phi_diff = phi_e.values[k]-gmv_phi[k] + phi_diff = phi_e.values[k] - gmv_phi[k] psi_diff = psi_e.values[k] - gmv_psi[k] - covar_e.values[k] = gmv_covar[k] - ae[k] * phi_diff * psi_diff + covar_e.values[k] = gmv_covar[k] - tke_factor * ae[k] * phi_diff * psi_diff for i in xrange(self.n_updrafts): - phi_diff = phi_u.values[i,k]-gmv_phi[k] + phi_diff = phi_u.values[i,k] - gmv_phi[k] psi_diff = psi_u.values[i,k] - gmv_psi[k] - covar_e.values[k] -= au.values[i,k] * phi_diff * psi_diff + covar_e.values[k] -= tke_factor * au.values[i,k] * phi_diff * psi_diff covar_e.values[k] = covar_e.values[k]/ae[k] else: covar_e.values[k] = 0.0 return - - cpdef compute_entrainment_detrainment(self, GridMeanVariables GMV, CasesBase Case): cdef: Py_ssize_t k @@ -1515,173 +1390,36 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): + (1.0-self.EnvVar.CF.values[k]) * d_alpha_qt_dry) # TODO - check - self.tke_buoy[k] = g / self.Ref.alpha0_c[k] * ae[k] * self.Ref.rho0_c[k] \ + self.EnvVar.TKE.buoy[k] = g / self.Ref.alpha0_c[k] * ae[k] * self.Ref.rho0_c[k] \ * ( \ - self.KH.values[k] * interp2pt(grad_thl_plus, grad_thl_minus) * d_alpha_thetal_total \ - self.KH.values[k] * interp2pt(grad_qt_plus, grad_qt_minus) * d_alpha_qt_total\ ) return - - # Note we need mixing length again here.... - cpdef compute_tke_dissipation(self): - cdef: - Py_ssize_t k - double [:] ae = np.subtract(np.ones((self.Gr.nzg,),dtype=np.double, order='c'),self.UpdVar.Area.bulkvalues) - #tke diss coeff - - # does mixing length need to be recomputed? Even if no change in GMV.TKE, if updraft area changes - # this would change environmental tke (assuming it is still adjusted based on tke) - # first pass...assume we can re-use - with nogil: - for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - self.tke_dissipation[k] = (self.Ref.rho0_c[k] * ae[k] * pow(fmax(self.EnvVar.TKE.values[k],0), 1.5) - /fmax(self.mixing_length[k],1.0) * self.tke_diss_coeff) - return - # Note updrafts' (total) entrainment rate = environment's (total) detrainment rate # and updrafts' (total) detrainment rate = environment's (total) entrainment rate # Therefore, fractional xxtrainment rates must be properly multiplied by the right component mass fluxes # Here we use the terminology entrainment/detrainment relative to the __environment__ - cpdef compute_tke_entr(self): - cdef: - Py_ssize_t i, k - double w_u, w_e - - with nogil: - for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - self.tke_entr_gain[k] = 0.0 - w_e = self.EnvVar.W.values[k] - for i in xrange(self.n_updrafts): - w_u = self.UpdVar.W.values[i,k] - self.tke_entr_gain[k] += self.UpdVar.Area.values[i,k] * fabs(w_u) * self.detr_sc[i,k] * (w_u - w_e) * (w_u - w_e) - self.tke_entr_gain[k] *= 0.5 * self.Ref.rho0_c[k] - return - - - cpdef compute_tke_detr(self): - cdef: - Py_ssize_t i, k - double w_u - - with nogil: - for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - self.tke_detr_loss[k] = 0.0 - for i in xrange(self.n_updrafts): - w_u = self.UpdVar.W.values[i,k] - self.tke_detr_loss[k] += self.UpdVar.Area.values[i,k] * fabs(w_u) * self.entr_sc[i,k] - self.tke_detr_loss[k] *= self.Ref.rho0_c[k] * self.EnvVar.TKE.values[k] - return - - cpdef compute_tke_shear(self, GridMeanVariables GMV): - cdef: - Py_ssize_t k - Py_ssize_t gw = self.Gr.gw - double [:] ae = np.subtract(np.ones((self.Gr.nzg,),dtype=np.double, order='c'),self.UpdVar.Area.bulkvalues) # area of environment - double du_high = 0.0 - double dv_high = 0.0 - double dw_high = 2.0 * self.EnvVar.W.values[gw] * self.Gr.dzi - double du_low, dv_low, dw_low, - - with nogil: - for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - du_low = du_high - dv_low = dv_high - dw_low = dw_high - du_high = (GMV.U.values[k+1] - GMV.U.values[k]) * self.Gr.dzi - dv_high = (GMV.V.values[k+1] - GMV.V.values[k]) * self.Gr.dzi - dw_high = (self.EnvVar.W.values[k+1] - self.EnvVar.W.values[k]) * self.Gr.dzi - self.tke_shear[k] =( self.Ref.rho0_c[k] * ae[k] * self.KM.values[k] * - ( pow(interp2pt(du_low, du_high),2.0) + pow(interp2pt(dv_low, dv_high),2.0) - + pow(interp2pt(dw_low, dw_high),2.0))) - return cpdef compute_tke_pressure(self): cdef: Py_ssize_t k Py_ssize_t gw = self.Gr.gw + double wu, we double press_buoy, press_drag with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - self.tke_pressure[k] = 0.0 + self.EnvVar.TKE.press[k] = 0.0 for i in xrange(self.n_updrafts): + wu = self.UpdVar.W.values[i,k] + we = self.EnvVar.W.values[k] press_buoy= (-1.0 * self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] * self.pressure_buoy_coeff) press_drag = (-1.0 * self.Ref.rho0_c[k] * sqrt(self.UpdVar.Area.values[i,k]) - * (self.pressure_drag_coeff/self.pressure_plume_spacing*\ - fabs(self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k])*(self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k]))) - self.tke_pressure[k] += (self.EnvVar.W.values[k] - self.UpdVar.W.values[i,k]) * (press_buoy + press_drag) - return - - cpdef update_tke_ED(self, GridMeanVariables GMV, CasesBase Case,TimeStepping TS): - cdef: - Py_ssize_t k, kk, i - Py_ssize_t gw = self.Gr.gw - Py_ssize_t nzg = self.Gr.nzg - Py_ssize_t nz = self.Gr.nz - double dzi = self.Gr.dzi - double dti = TS.dti - double [:] a = np.zeros((nz,),dtype=np.double, order='c') # for tridiag solver - double [:] b = np.zeros((nz,),dtype=np.double, order='c') # for tridiag solver - double [:] c = np.zeros((nz,),dtype=np.double, order='c') # for tridiag solver - double [:] x = np.zeros((nz,),dtype=np.double, order='c') # for tridiag solver - double [:] ae = np.subtract(np.ones((nzg,),dtype=np.double, order='c'),self.UpdVar.Area.bulkvalues) # area of environment - double [:] ae_old = np.subtract(np.ones((nzg,),dtype=np.double, order='c'), np.sum(self.UpdVar.Area.old,axis=0)) - double [:] rho_ae_K_m = np.zeros((nzg,),dtype=np.double, order='c') - double [:] whalf = np.zeros((nzg,),dtype=np.double, order='c') - double D_env = 0.0 - double wu_half, we_half,a_half, tke_0_surf,press_k - - - - with nogil: - for k in xrange(1,nzg-1): - rho_ae_K_m[k] = 0.5 * (ae[k]*self.KM.values[k]+ ae[k+1]*self.KM.values[k+1]) * self.Ref.rho0_f[k] - whalf[k] = self.EnvVar.W.values[k] - wu_half = self.UpdVar.W.bulkvalues[gw] - GMV.TKE.values[gw] = get_surface_tke(Case.Sur.ustar, self.wstar, self.Gr.z_c[gw], Case.Sur.obukhov_length) - self.get_env_tke_from_GMV(self.UpdVar.Area, self.UpdVar.W, self.EnvVar.W, - self.EnvVar.TKE, &GMV.W.values[0], &GMV.TKE.values[0]) - - tke_0_surf = self.EnvVar.TKE.values[gw] - - - with nogil: - for kk in xrange(nz): - k = kk+gw - D_env = 0.0 - - for i in xrange(self.n_updrafts): - wu_half = self.UpdVar.W.values[i,k] - D_env += self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * wu_half * self.entr_sc[i,k] - - a[kk] = (- rho_ae_K_m[k-1] * dzi * dzi ) - b[kk] = (self.Ref.rho0_c[k] * ae[k] * dti - self.Ref.rho0_c[k] * ae[k] * whalf[k] * dzi - + rho_ae_K_m[k] * dzi * dzi + rho_ae_K_m[k-1] * dzi * dzi - + D_env - + self.Ref.rho0_c[k] * ae[k] * self.tke_diss_coeff * sqrt(fmax(self.EnvVar.TKE.values[k],0.0))/fmax(self.mixing_length[k],1.0)) - c[kk] = (self.Ref.rho0_c[k+1] * ae[k+1] * whalf[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) - x[kk] = (self.Ref.rho0_c[k] * ae_old[k] * self.EnvVar.TKE.values[k] * dti - + self.tke_shear[k] + self.tke_buoy[k] + self.tke_entr_gain[k] + self.tke_pressure[k]) - a[0] = 0.0 - b[0] = 1.0 - c[0] = 0.0 - x[0] = tke_0_surf - - b[nz-1] += c[nz-1] - c[nz-1] = 0.0 - tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) - - with nogil: - for kk in xrange(nz): - k = kk + gw - self.EnvVar.TKE.values[k] = fmax(x[kk], 0.0) - wu_half = self.UpdVar.W.bulkvalues[k] - - self.get_GMV_TKE(self.UpdVar.Area,self.UpdVar.W, self.EnvVar.W, self.EnvVar.TKE, - &GMV.W.values[0], &GMV.TKE.values[0]) - + * (self.pressure_drag_coeff/self.pressure_plume_spacing*(wu -we)*fabs(wu -we))) + self.EnvVar.TKE.press[k] += (we - wu) * (press_buoy + press_drag) return cpdef update_GMV_diagnostics(self, GridMeanVariables GMV): @@ -1710,43 +1448,68 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): return - - cpdef compute_covariance(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS): - #if TS.nstep > 0: #TODO - its already initialized in t=0 here + #if TS.nstep > 0: if self.similarity_diffusivity: # otherwise, we computed mixing length when we computed - self.compute_mixing_length(Case.Sur.obukhov_length) + self.compute_mixing_length(Case.Sur.obukhov_length, GMV) + if self.calc_tke: + self.compute_tke_buoy(GMV) + self.compute_covariance_entr(self.EnvVar.TKE, self.UpdVar.W, self.UpdVar.W, self.EnvVar.W, self.EnvVar.W) + self.compute_covariance_shear(GMV, self.EnvVar.TKE, &self.UpdVar.W.values[0,0], &self.UpdVar.W.values[0,0], &self.EnvVar.W.values[0], &self.EnvVar.W.values[0]) + self.compute_covariance_interdomain_src(self.UpdVar.Area,self.UpdVar.W,self.UpdVar.W,self.EnvVar.W, self.EnvVar.W, self.EnvVar.TKE) + self.compute_tke_pressure() + if self.calc_scalar_var: + self.compute_covariance_entr(self.EnvVar.Hvar, self.UpdVar.H, self.UpdVar.H, self.EnvVar.H, self.EnvVar.H) + self.compute_covariance_entr(self.EnvVar.QTvar, self.UpdVar.QT, self.UpdVar.QT, self.EnvVar.QT, self.EnvVar.QT) + self.compute_covariance_entr(self.EnvVar.HQTcov, self.UpdVar.H, self.UpdVar.QT, self.EnvVar.H, self.EnvVar.QT) + self.compute_covariance_shear(GMV, self.EnvVar.Hvar, &self.UpdVar.H.values[0,0], &self.UpdVar.H.values[0,0], &self.EnvVar.H.values[0], &self.EnvVar.H.values[0]) + self.compute_covariance_shear(GMV, self.EnvVar.QTvar, &self.UpdVar.QT.values[0,0], &self.UpdVar.QT.values[0,0], &self.EnvVar.QT.values[0], &self.EnvVar.QT.values[0]) + self.compute_covariance_shear(GMV, self.EnvVar.HQTcov, &self.UpdVar.H.values[0,0], &self.UpdVar.QT.values[0,0], &self.EnvVar.H.values[0], &self.EnvVar.QT.values[0]) + self.compute_covariance_interdomain_src(self.UpdVar.Area,self.UpdVar.H,self.UpdVar.H,self.EnvVar.H, self.EnvVar.H, self.EnvVar.Hvar) + self.compute_covariance_interdomain_src(self.UpdVar.Area,self.UpdVar.QT,self.UpdVar.QT,self.EnvVar.QT, self.EnvVar.QT, self.EnvVar.QTvar) + self.compute_covariance_interdomain_src(self.UpdVar.Area,self.UpdVar.H,self.UpdVar.QT,self.EnvVar.H, self.EnvVar.QT, self.EnvVar.HQTcov) + self.compute_covariance_rain(TS, GMV) # need to update this one - self.compute_covariance_entr() - self.compute_covariance_shear(GMV) - self.compute_covariance_rain(TS, GMV) self.reset_surface_covariance(GMV, Case) - self.update_covariance_ED(GMV, Case, TS) - self.cleanup_covariance(GMV) - #else: #TODO - its initialized in the update calls - # self.initialize_covariance(GMV, Case) + if self.calc_tke: + self.update_covariance_ED(GMV, Case,TS, GMV.W, GMV.W, GMV.TKE, self.EnvVar.TKE, self.EnvVar.W, self.EnvVar.W, self.UpdVar.W, self.UpdVar.W) + if self.calc_scalar_var: + self.update_covariance_ED(GMV, Case,TS, GMV.H, GMV.H, GMV.Hvar, self.EnvVar.Hvar, self.EnvVar.H, self.EnvVar.H, self.UpdVar.H, self.UpdVar.H) + self.update_covariance_ED(GMV, Case,TS, GMV.QT,GMV.QT, GMV.QTvar, self.EnvVar.QTvar, self.EnvVar.QT, self.EnvVar.QT, self.UpdVar.QT, self.UpdVar.QT) + self.update_covariance_ED(GMV, Case,TS, GMV.H, GMV.QT, GMV.HQTcov, self.EnvVar.HQTcov, self.EnvVar.H, self.EnvVar.QT, self.UpdVar.H, self.UpdVar.QT) + self.cleanup_covariance(GMV) - return + #else: + # self.initialize_covariance(GMV, Case) + return cpdef initialize_covariance(self, GridMeanVariables GMV, CasesBase Case): cdef: Py_ssize_t k - double ws= self.wstar, us = Case.Sur.ustar, zs = self.zi, z self.reset_surface_covariance(GMV, Case) - with nogil: - for k in xrange(self.Gr.nzg): - z = self.Gr.z_c[k] - GMV.Hvar.values[k] = GMV.Hvar.values[self.Gr.gw] * GMV.TKE.values[k] / GMV.TKE.values[self.Gr.gw] - GMV.QTvar.values[k] = GMV.QTvar.values[self.Gr.gw] * GMV.TKE.values[k] / GMV.TKE.values[self.Gr.gw] - GMV.HQTcov.values[k] = GMV.HQTcov.values[self.Gr.gw] * GMV.TKE.values[k] / GMV.TKE.values[self.Gr.gw] - - self.compute_mixing_length(Case.Sur.obukhov_length) + if self.calc_tke: + if ws > 0.0: + with nogil: + for k in xrange(self.Gr.nzg): + z = self.Gr.z_c[k] + GMV.TKE.values[k] = ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) + if self.calc_scalar_var: + if ws > 0.0: + with nogil: + for k in xrange(self.Gr.nzg): + z = self.Gr.z_c[k] + # need to rethink of how to initilize the covarinace profiles - for nowmI took the TKE profile + GMV.Hvar.values[k] = GMV.Hvar.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) + GMV.QTvar.values[k] = GMV.QTvar.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) + GMV.HQTcov.values[k] = GMV.HQTcov.values[self.Gr.gw] * ws * 1.3 * cbrt((us*us*us)/(ws*ws*ws) + 0.6 * z/zs) * sqrt(fmax(1.0-z/zs,0.0)) + self.reset_surface_covariance(GMV, Case) + self.compute_mixing_length(Case.Sur.obukhov_length, GMV) return @@ -1760,73 +1523,105 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): GMV.Hvar.values[k] = 0.0 if GMV.QTvar.values[k] < tmp_eps: GMV.QTvar.values[k] = 0.0 + if fabs(GMV.HQTcov.values[k]) < tmp_eps: + GMV.HQTcov.values[k] = 0.0 if self.EnvVar.Hvar.values[k] < tmp_eps: self.EnvVar.Hvar.values[k] = 0.0 if self.EnvVar.QTvar.values[k] < tmp_eps: self.EnvVar.QTvar.values[k] = 0.0 + if fabs(self.EnvVar.HQTcov.values[k]) < tmp_eps: + self.EnvVar.HQTcov.values[k] = 0.0 + + return - cpdef compute_covariance_shear(self, GridMeanVariables GMV): + cdef void compute_covariance_shear(self,GridMeanVariables GMV, EDMF_Environment.EnvironmentVariable_2m Covar, double *UpdVar1, double *UpdVar2, double *EnvVar1, double *EnvVar2): cdef: Py_ssize_t k Py_ssize_t gw = self.Gr.gw - double [:] ae = np.subtract(np.ones((self.Gr.nzg,),dtype=np.double, order='c'),self.UpdVar.Area.bulkvalues) # area of environment - double dH_high = 0.0 - double dQT_high = 0.0 - double dH_low, dQT_low + double [:] ae = np.subtract(np.ones((self.Gr.nzg,),dtype=np.double, order='c'),self.UpdVar.Area.bulkvalues) + double diff_var1 = 0.0 + double diff_var2 = 0.0 + double du = 0.0 + double dv = 0.0 + double tke_factor = 1.0 + + for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): + if Covar.name == 'tke': + du = (GMV.U.values[k+1] - GMV.U.values[k-1]) * self.Gr.dzi/2.0 + dv = (GMV.V.values[k+1] - GMV.V.values[k-1]) * self.Gr.dzi/2.0 + tke_factor = 0.5 + with nogil: + diff_var1 = (EnvVar1[k+1] - EnvVar1[k-1]) * self.Gr.dzi/2.0 + diff_var2 = (EnvVar2[k+1] - EnvVar2[k-1]) * self.Gr.dzi/2.0 + Covar.shear[k] = tke_factor*2.0*(self.Ref.rho0_c[k] * ae[k] * self.KH.values[k] * + (diff_var1*diff_var2 + pow(du,2.0) + pow(dv,2.0))) + return + + cdef void compute_covariance_interdomain_src(self, EDMF_Updrafts.UpdraftVariable au, + EDMF_Updrafts.UpdraftVariable phi_u, EDMF_Updrafts.UpdraftVariable psi_u, + EDMF_Environment.EnvironmentVariable phi_e, EDMF_Environment.EnvironmentVariable psi_e, + EDMF_Environment.EnvironmentVariable_2m Covar): + cdef: + Py_ssize_t i,k + double phi_diff, psi_diff, tke_factor + + if Covar.name == 'tke': + tke_factor = 0.5 + else: + tke_factor = 1.0 + + with nogil: + for k in xrange(self.Gr.nzg): + Covar.interdomain[k] = 0.0 + for i in xrange(self.n_updrafts): + phi_diff = phi_u.values[i,k]-phi_e.values[k] + psi_diff = psi_u.values[i,k]-psi_e.values[k] + Covar.interdomain[k] += tke_factor*au.values[i,k] * (1.0-au.values[i,k]) * phi_diff * psi_diff + return + + cdef void compute_covariance_dissipation(self, EDMF_Environment.EnvironmentVariable_2m Covar): + cdef: + Py_ssize_t i + double m + Py_ssize_t k + double [:] ae = np.subtract(np.ones((self.Gr.nzg,),dtype=np.double, order='c'),self.UpdVar.Area.bulkvalues) with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - dH_low = dH_high - dH_high = (self.EnvVar.H.values[k+1] - self.EnvVar.H.values[k]) * self.Gr.dzi - dQT_low = dQT_high - dQT_high = (self.EnvVar.QT.values[k+1] - self.EnvVar.QT.values[k]) * self.Gr.dzi - self.Hvar_shear[k] = 2.0*(self.Ref.rho0_c[k] * ae[k] * self.KH.values[k] *pow(interp2pt(dH_low, dH_high),2.0)) - self.QTvar_shear[k] = 2.0*(self.Ref.rho0_c[k] * ae[k] * self.KH.values[k] *pow(interp2pt(dQT_low, dQT_high),2.0)) - self.HQTcov_shear[k] = 2.0*(self.Ref.rho0_c[k] * ae[k] * self.KH.values[k] *interp2pt(dH_low, dH_high)*interp2pt(dQT_low, dQT_high)) + Covar.dissipation[k] = (self.Ref.rho0_c[k] * ae[k] * Covar.values[k] + *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0) * self.tke_diss_coeff) return - cpdef compute_covariance_entr(self): + cdef void compute_covariance_entr(self, EDMF_Environment.EnvironmentVariable_2m Covar, EDMF_Updrafts.UpdraftVariable UpdVar1, + EDMF_Updrafts.UpdraftVariable UpdVar2, EDMF_Environment.EnvironmentVariable EnvVar1, EDMF_Environment.EnvironmentVariable EnvVar2): cdef: Py_ssize_t i, k - double H_u, H_env, QT_u, QT_env - + double tke_factor = 1.0 + if Covar.name =='tke': + tke_factor = 0.5 with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - self.Hvar_entr_gain[k] = 0.0 - self.QTvar_entr_gain[k] = 0.0 - self.HQTcov_entr_gain[k] = 0.0 - H_env = self.EnvVar.H.values[k] - QT_env = self.EnvVar.QT.values[k] + Covar.entr_gain[k] = 0.0 for i in xrange(self.n_updrafts): - H_u = self.UpdVar.H.values[i,k] - QT_u = self.UpdVar.QT.values[i,k] - self.Hvar_entr_gain[k] += self.UpdVar.Area.values[i,k] * fabs(self.UpdVar.W.values[i,k]) * self.detr_sc[i,k] * (H_u - H_env) * (H_u - H_env) - self.QTvar_entr_gain[k] += self.UpdVar.Area.values[i,k] * fabs(self.UpdVar.W.values[i,k]) * self.detr_sc[i,k] * (QT_u - QT_env) * (QT_u - QT_env) - self.HQTcov_entr_gain[k] += self.UpdVar.Area.values[i,k] * fabs(self.UpdVar.W.values[i,k]) * self.detr_sc[i,k] * (H_u - H_env) * (QT_u - QT_env) - self.Hvar_entr_gain[k] *= self.Ref.rho0_c[k] - self.QTvar_entr_gain[k] *= self.Ref.rho0_c[k] - self.HQTcov_entr_gain[k] *= self.Ref.rho0_c[k] + Covar.entr_gain[k] += tke_factor*self.UpdVar.Area.values[i,k] * fabs(self.UpdVar.W.values[i,k]) * self.detr_sc[i,k] * \ + (UpdVar1.values[i,k] - EnvVar1.values[k]) * (UpdVar2.values[i,k] - EnvVar2.values[k]) + Covar.entr_gain[k] *= self.Ref.rho0_c[k] return - cpdef compute_covariance_detr(self): + + cdef void compute_covariance_detr(self, EDMF_Environment.EnvironmentVariable_2m Covar): cdef: Py_ssize_t i, k - with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - self.Hvar_detr_loss[k] = 0.0 - self.QTvar_detr_loss[k] = 0.0 - self.HQTcov_detr_loss[k] = 0.0 + Covar.detr_loss[k] = 0.0 for i in xrange(self.n_updrafts): - self.Hvar_detr_loss[k] += self.UpdVar.Area.values[i,k] * fabs(self.UpdVar.W.values[i,k]) * self.entr_sc[i,k] - self.QTvar_detr_loss[k] += self.UpdVar.Area.values[i,k] * fabs(self.UpdVar.W.values[i,k]) * self.entr_sc[i,k] - self.HQTcov_detr_loss[k] += self.UpdVar.Area.values[i,k] * fabs(self.UpdVar.W.values[i,k]) * self.entr_sc[i,k] - self.Hvar_detr_loss[k] *= self.Ref.rho0_c[k] * self.EnvVar.Hvar.values[k] - self.QTvar_detr_loss[k] *= self.Ref.rho0_c[k] * self.EnvVar.QTvar.values[k] - self.HQTcov_detr_loss[k] *= self.Ref.rho0_c[k] * self.EnvVar.HQTcov.values[k] + Covar.detr_loss[k] += self.UpdVar.Area.values[i,k] * fabs(self.UpdVar.W.values[i,k]) * self.entr_sc[i,k] + Covar.detr_loss[k] *= self.Ref.rho0_c[k] * Covar.values[k] return + cpdef compute_covariance_rain(self, TimeStepping TS, GridMeanVariables GMV): cdef: Py_ssize_t i, k @@ -1835,13 +1630,16 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - self.Hvar_rain[k] = self.Ref.rho0_c[k] * ae[k] * 2. * self.EnvThermo.Hvar_rain_dt[k] * TS.dti - self.QTvar_rain[k] = self.Ref.rho0_c[k] * ae[k] * 2. * self.EnvThermo.QTvar_rain_dt[k] * TS.dti - self.HQTcov_rain[k] = self.Ref.rho0_c[k] * ae[k] * self.EnvThermo.HQTcov_rain_dt[k] * TS.dti + self.EnvVar.TKE.rain_src[k] = 0.0 + self.EnvVar.Hvar.rain_src[k] = self.Ref.rho0_c[k] * ae[k] * 2. * self.EnvThermo.Hvar_rain_dt[k] * TS.dti + self.EnvVar.QTvar.rain_src[k] = self.Ref.rho0_c[k] * ae[k] * 2. * self.EnvThermo.QTvar_rain_dt[k] * TS.dti + self.EnvVar.HQTcov.rain_src[k] = self.Ref.rho0_c[k] * ae[k] * self.EnvThermo.HQTcov_rain_dt[k] * TS.dti return - cpdef update_covariance_ED(self, GridMeanVariables GMV, CasesBase Case,TimeStepping TS): + cdef void update_covariance_ED(self, GridMeanVariables GMV, CasesBase Case,TimeStepping TS, VariablePrognostic GmvVar1, VariablePrognostic GmvVar2, + VariableDiagnostic GmvCovar, EDMF_Environment.EnvironmentVariable_2m Covar, EDMF_Environment.EnvironmentVariable EnvVar1, EDMF_Environment.EnvironmentVariable EnvVar2, + EDMF_Updrafts.UpdraftVariable UpdVar1, EDMF_Updrafts.UpdraftVariable UpdVar2): cdef: Py_ssize_t k, kk, i Py_ssize_t gw = self.Gr.gw @@ -1851,188 +1649,82 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double dti = TS.dti double alpha0LL = self.Ref.alpha0_c[self.Gr.gw] double zLL = self.Gr.z_c[self.Gr.gw] - double [:] a = np.zeros((nz,),dtype=np.double, order='c') # for tridiag solver - double [:] b = np.zeros((nz,),dtype=np.double, order='c') # for tridiag solver - double [:] c = np.zeros((nz,),dtype=np.double, order='c') # for tridiag solver - double [:] x = np.zeros((nz,),dtype=np.double, order='c') # for tridiag solver - double [:] ae = np.subtract(np.ones((nzg,),dtype=np.double, order='c'),self.UpdVar.Area.bulkvalues) # area of environment + double [:] a = np.zeros((nz,),dtype=np.double, order='c') + double [:] b = np.zeros((nz,),dtype=np.double, order='c') + double [:] c = np.zeros((nz,),dtype=np.double, order='c') + double [:] x = np.zeros((nz,),dtype=np.double, order='c') + double [:] ae = np.subtract(np.ones((nzg,),dtype=np.double, order='c'),self.UpdVar.Area.bulkvalues) double [:] ae_old = np.subtract(np.ones((nzg,),dtype=np.double, order='c'), np.sum(self.UpdVar.Area.old,axis=0)) double [:] rho_ae_K_m = np.zeros((nzg,),dtype=np.double, order='c') - double [:] whalf = np.zeros((nzg,),dtype=np.double, order='c') - double [:] Hhalf = np.zeros((nzg,),dtype=np.double, order='c') - double [:] QThalf = np.zeros((nzg,),dtype=np.double, order='c') - double D_env = 0.0 - # missing flux1 and 2 in get_surface_variance - double Hvar_gmv_surf = get_surface_variance(Case.Sur.rho_hflux * alpha0LL, Case.Sur.rho_hflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) - double QTvar_gmv_surf = get_surface_variance(Case.Sur.rho_qtflux * alpha0LL, Case.Sur.rho_qtflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) - double HQTcov_gmv_surf = get_surface_variance(Case.Sur.rho_hflux * alpha0LL, Case.Sur.rho_qtflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) - double Hu_half, He_half, a_half, QTu_half, QTe_half - double wu_half, we_half, Hvar_0_surf, QTvar_0_surf, HQTcov_0_surf - + double Covar_surf with nogil: for k in xrange(1,nzg-1): - rho_ae_K_m[k] = 0.5 * (ae[k]*self.KH.values[k]+ ae[k+1]*self.KH.values[k+1]) * self.Ref.rho0_f[k] - whalf[k] = self.EnvVar.W.values[k] - Hhalf[k] = self.EnvVar.H.values[k] - QThalf[k] = self.EnvVar.QT.values[k] - wu_half = self.UpdVar.W.bulkvalues[gw] - Hu_half = self.UpdVar.H.bulkvalues[gw] - QTu_half = self.UpdVar.QT.bulkvalues[gw] + rho_ae_K_m[k] = 0.5 * (ae[k]*self.KH.values[k]+ ae[k+1]*self.KH.values[k+1])* self.Ref.rho0_f[k] - GMV.Hvar.values[gw] = get_surface_variance(Case.Sur.rho_hflux * alpha0LL, Case.Sur.rho_hflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) - GMV.QTvar.values[gw] = get_surface_variance(Case.Sur.rho_qtflux * alpha0LL, Case.Sur.rho_qtflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) - GMV.HQTcov.values[gw] = get_surface_variance(Case.Sur.rho_hflux * alpha0LL, Case.Sur.rho_qtflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) - self.get_env_covar_from_GMV(self.UpdVar.Area, self.UpdVar.H, self.UpdVar.H, self.EnvVar.H, self.EnvVar.H, - self.EnvVar.Hvar, &GMV.H.values[0], &GMV.H.values[0], &GMV.Hvar.values[0]) - self.get_env_covar_from_GMV(self.UpdVar.Area, self.UpdVar.QT, self.UpdVar.QT, self.EnvVar.QT, self.EnvVar.QT, - self.EnvVar.QTvar, &GMV.QT.values[0], &GMV.QT.values[0], &GMV.QTvar.values[0]) - self.get_env_covar_from_GMV(self.UpdVar.Area, self.UpdVar.H, self.UpdVar.QT, self.EnvVar.H, self.EnvVar.QT, - self.EnvVar.HQTcov, &GMV.H.values[0], &GMV.QT.values[0], &GMV.HQTcov.values[0]) + if GmvCovar.name=='tke': + GmvCovar.values[gw] =get_surface_tke(Case.Sur.ustar, self.wstar, self.Gr.z_c[gw], Case.Sur.obukhov_length) + elif GmvCovar.name=='thetal_var': + GmvCovar.values[gw] = get_surface_variance(Case.Sur.rho_hflux * alpha0LL, Case.Sur.rho_hflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) + elif GmvCovar.name=='qt_var': + GmvCovar.values[gw] = get_surface_variance(Case.Sur.rho_qtflux * alpha0LL, Case.Sur.rho_qtflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) + elif GmvCovar.name=='thetal_qt_covar': + GmvCovar.values[gw] = get_surface_variance(Case.Sur.rho_hflux * alpha0LL, Case.Sur.rho_qtflux * alpha0LL, Case.Sur.ustar, zLL, Case.Sur.obukhov_length) + self.get_env_covar_from_GMV(self.UpdVar.Area, UpdVar1, UpdVar2, EnvVar1, EnvVar2, Covar, &GmvVar1.values[0], &GmvVar2.values[0], &GmvCovar.values[0]) + Covar_surf = Covar.values[gw] - # BC at the surface - Hvar_0_surf = self.EnvVar.Hvar.values[gw] - QTvar_0_surf = self.EnvVar.QTvar.values[gw] - HQTcov_0_surf = self.EnvVar.HQTcov.values[gw] - - # run tridiagonal solver for Hvar with nogil: for kk in xrange(nz): k = kk+gw D_env = 0.0 for i in xrange(self.n_updrafts): - wu_half = self.UpdVar.W.values[i,k] - D_env += self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * wu_half * self.entr_sc[i,k] + D_env += self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.entr_sc[i,k] a[kk] = (- rho_ae_K_m[k-1] * dzi * dzi ) - b[kk] = (self.Ref.rho0_c[k] * ae[k] * dti - self.Ref.rho0_c[k] * ae[k] * whalf[k] * dzi + b[kk] = (self.Ref.rho0_c[k] * ae[k] * dti - self.Ref.rho0_c[k] * ae[k] * self.EnvVar.W.values[k] * dzi + rho_ae_K_m[k] * dzi * dzi + rho_ae_K_m[k-1] * dzi * dzi + D_env + self.Ref.rho0_c[k] * ae[k] * self.tke_diss_coeff - *sqrt(fmax(self.EnvVar.TKE.values[k],0))/fmax(self.mixing_length[k],1.0)) - c[kk] = (self.Ref.rho0_c[k+1] * ae[k+1] * whalf[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) - x[kk] = (self.Ref.rho0_c[k] * ae_old[k] * self.EnvVar.Hvar.values[k] * dti - + self.Hvar_shear[k] + self.Hvar_entr_gain[k]) # - - a[0] = 0.0 - b[0] = 1.0 - c[0] = 0.0 - x[0] = Hvar_0_surf - - b[nz-1] += c[nz-1] - c[nz-1] = 0.0 + *sqrt(fmax(self.EnvVar.TKE.values[k],0))/fmax(self.mixing_length[k],1.0) ) + c[kk] = (self.Ref.rho0_c[k+1] * ae[k+1] * self.EnvVar.W.values[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) + x[kk] = (self.Ref.rho0_c[k] * ae_old[k] * Covar.values[k] * dti + + Covar.press[k] + Covar.buoy[k] + Covar.shear[k] + Covar.entr_gain[k] + Covar.rain_src[k]) # + + a[0] = 0.0 + b[0] = 1.0 + c[0] = 0.0 + x[0] = Covar_surf + + b[nz-1] += c[nz-1] + c[nz-1] = 0.0 tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) - with nogil: - for kk in xrange(nz): - k = kk + gw - self.EnvVar.Hvar.values[k] = fmax(x[kk], 0.0) - GMV.Hvar.values[k] = (ae[k] * (self.EnvVar.Hvar.values[k] + (Hhalf[k]-GMV.H.values[k]) * (Hhalf[k]-GMV.H.values[k])) - + self.UpdVar.Area.bulkvalues[k] * (self.UpdVar.H.bulkvalues[k]-GMV.H.values[k]) * (self.UpdVar.H.bulkvalues[k]-GMV.H.values[k])) - - self.get_GMV_CoVar(self.UpdVar.Area, self.UpdVar.H, self.UpdVar.H, self.EnvVar.H, self.EnvVar.H, self.EnvVar.Hvar, - &GMV.H.values[0],&GMV.H.values[0], &GMV.Hvar.values[0]) - # run tridiagonal solver for QTvar - with nogil: - for kk in xrange(nz): - k = kk+gw - D_env = 0.0 - - for i in xrange(self.n_updrafts): - wu_half = self.UpdVar.W.values[i,k] - D_env += self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * wu_half * self.entr_sc[i,k] + # if Covar.name == 'tke': + # tke_factor = 0.5 + # else: + # tke_factor = 1.0 - a[kk] = (- rho_ae_K_m[k-1] * dzi * dzi ) - b[kk] = (self.Ref.rho0_c[k] * ae[k] * dti - self.Ref.rho0_c[k] * ae[k] * whalf[k] * dzi - + rho_ae_K_m[k] * dzi * dzi + rho_ae_K_m[k-1] * dzi * dzi - + D_env - + self.Ref.rho0_c[k] * ae[k] * self.tke_diss_coeff - *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0)) - c[kk] = (self.Ref.rho0_c[k+1] * ae[k+1] * whalf[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) - x[kk] = (self.Ref.rho0_c[k] * ae_old[k] * self.EnvVar.QTvar.values[k] * dti - + self.QTvar_shear[k] + self.QTvar_entr_gain[k] + self.QTvar_rain[k]) - - a[0] = 0.0 - b[0] = 1.0 - c[0] = 0.0 - x[0] = QTvar_0_surf - - b[nz-1] += c[nz-1] - c[nz-1] = 0.0 - tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) - with nogil: - for kk in xrange(nz): - k = kk + gw - self.EnvVar.QTvar.values[k] = fmax(x[kk], 0.0) - GMV.QTvar.values[k] = (ae[k] * (self.EnvVar.QTvar.values[k] + (QThalf[k]-GMV.QT.values[k]) * (QThalf[k]-GMV.QT.values[k])) - + self.UpdVar.Area.bulkvalues[k] * (self.UpdVar.QT.bulkvalues[k]-GMV.QT.values[k]) * (self.UpdVar.QT.bulkvalues[k]-GMV.QT.values[k])) - - self.get_GMV_CoVar(self.UpdVar.Area, self.UpdVar.QT, self.UpdVar.QT, self.EnvVar.QT, self.EnvVar.QT, self.EnvVar.QTvar, - &GMV.QT.values[0],&GMV.QT.values[0], &GMV.QTvar.values[0]) - - # run tridiagonal solver for HQTcov - with nogil: - for kk in xrange(nz): - k = kk+gw - D_env = 0.0 - - for i in xrange(self.n_updrafts): - wu_half = self.UpdVar.W.values[i,k] - D_env += self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * wu_half * self.entr_sc[i,k] - - a[kk] = (- rho_ae_K_m[k-1] * dzi * dzi ) - b[kk] = (self.Ref.rho0_c[k] * ae[k] * dti - self.Ref.rho0_c[k] * ae[k] * whalf[k] * dzi - + rho_ae_K_m[k] * dzi * dzi + rho_ae_K_m[k-1] * dzi * dzi - + D_env - + self.Ref.rho0_c[k] * ae[k] * self.tke_diss_coeff - *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0)) - c[kk] = (self.Ref.rho0_c[k+1] * ae[k+1] * whalf[k+1] * dzi - rho_ae_K_m[k] * dzi * dzi) - x[kk] = (self.Ref.rho0_c[k] * ae_old[k] * self.EnvVar.HQTcov.values[k] * dti - + self.HQTcov_shear[k] + self.HQTcov_entr_gain[k] + self.HQTcov_rain[k]) - - a[0] = 0.0 - b[0] = 1.0 - c[0] = 0.0 - x[0] = HQTcov_0_surf - - b[nz-1] += c[nz-1] - c[nz-1] = 0.0 - tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) - - with nogil: - for kk in xrange(nz): - k = kk + gw - self.EnvVar.HQTcov.values[k] = fmax(x[kk], -self.EnvVar.QTvar.values[k]*self.EnvVar.Hvar.values[k]) - self.EnvVar.HQTcov.values[k] = fmin(x[kk], self.EnvVar.QTvar.values[k]*self.EnvVar.Hvar.values[k]) - GMV.HQTcov.values[k] = (ae[k] * (self.EnvVar.HQTcov.values[k] + (Hhalf[k]-GMV.H.values[k]) * (QThalf[k]-GMV.QT.values[k])) - + self.UpdVar.Area.bulkvalues[k] * (self.UpdVar.H.bulkvalues[k]-GMV.H.values[k]) * (self.UpdVar.QT.bulkvalues[k]-GMV.QT.values[k])) + for kk in xrange(nz): + k = kk + gw + if Covar.name == 'thetal_qt_covar': + Covar.values[k] = fmax(x[kk], - sqrt(self.EnvVar.Hvar.values[k]*self.EnvVar.QTvar.values[k])) + Covar.values[k] = fmin(x[kk], sqrt(self.EnvVar.Hvar.values[k]*self.EnvVar.QTvar.values[k])) + else: + Covar.values[k] = fmax(x[kk],0.0) + #with nogil: + # GmvCovar.values[k] = (ae[k] * (Covar.values[k] + (EnvVar1.values[k]-GmvVar1.values[k]) * (EnvVar2.values[k]-GmvVar2.values[k])) + # + self.UpdVar.Area.bulkvalues[k] * (UpdVar1.bulkvalues[k]-GmvVar1.values[k]) * (UpdVar2.bulkvalues[k]-GmvVar2.values[k])) - self.get_GMV_CoVar(self.UpdVar.Area, self.UpdVar.H, self.UpdVar.QT, self.EnvVar.H, self.EnvVar.QT, self.EnvVar.HQTcov, - &GMV.H.values[0], &GMV.QT.values[0], &GMV.HQTcov.values[0]) + self.get_GMV_CoVar(self.UpdVar.Area, UpdVar1, UpdVar2, EnvVar1, EnvVar2, Covar, &GmvVar1.values[0], &GmvVar2.values[0], &GmvCovar.values[0]) return - cpdef compute_covariance_dissipation(self): - cdef: - Py_ssize_t k - double [:] ae = np.subtract(np.ones((self.Gr.nzg,),dtype=np.double, order='c'),self.UpdVar.Area.bulkvalues) - - with nogil: - for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): - self.Hvar_dissipation[k] = (self.Ref.rho0_c[k] * ae[k] * self.EnvVar.Hvar.values[k] - *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0) * self.tke_diss_coeff) - self.QTvar_dissipation[k] = (self.Ref.rho0_c[k] * ae[k] * self.EnvVar.QTvar.values[k] - *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0) * self.tke_diss_coeff) - self.HQTcov_dissipation[k] = (self.Ref.rho0_c[k] * ae[k] * self.EnvVar.HQTcov.values[k] - *pow(fmax(self.EnvVar.TKE.values[k],0), 0.5)/fmax(self.mixing_length[k],1.0) * self.tke_diss_coeff) - - return cpdef nan_check(self, line, GridMeanVariables GMV, int k): cdef: @@ -2066,7 +1758,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): plt.show() if self.UpdVar.QT.new[0,k] < 0: - print 'negative qt', line, k, self.UpdVar.QT.values[0,k] ,self.UpdVar.QT.new[0,k], self.UpdVar.QL.values[0,k] + print 'negative qt', line, k, self.UpdVar.QT.values[0,k] ,self.UpdVar.QT.new[0,k] plt.figure() plt.show() if self.UpdVar.H.new[0,k] < 290 or self.UpdVar.H.new[0,k] > 310: From 2325c3379c4810906db264d5f8c9ae1926f61e7a Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Tue, 25 Sep 2018 15:56:14 -0700 Subject: [PATCH 122/136] cleanup --- Turbulence_PrognosticTKE.pxd | 2 - Turbulence_PrognosticTKE.pyx | 251 ----------------------------------- 2 files changed, 253 deletions(-) diff --git a/Turbulence_PrognosticTKE.pxd b/Turbulence_PrognosticTKE.pxd index 8c81f8cb..2be05fa0 100644 --- a/Turbulence_PrognosticTKE.pxd +++ b/Turbulence_PrognosticTKE.pxd @@ -98,8 +98,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cpdef set_updraft_surface_bc(self, GridMeanVariables GMV, CasesBase Case) cpdef decompose_environment(self, GridMeanVariables GMV, whichvals) cpdef compute_entrainment_detrainment(self, GridMeanVariables GMV, CasesBase Case) - cpdef solve_updraft_velocity_area(self, GridMeanVariables GMV, TimeStepping TS) - cpdef solve_updraft_scalars(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS) cpdef solve_updraft(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS) cpdef upwind_integration(self, EDMF_Updrafts.UpdraftVariable area, EDMF_Updrafts.UpdraftVariable var, int k, int i, double env_var, double dzi) cpdef update_GMV_MF(self, GridMeanVariables GMV, TimeStepping TS) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index af345278..390ad863 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -773,248 +773,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): return - cpdef solve_updraft_velocity_area(self, GridMeanVariables GMV, TimeStepping TS): - cdef: - Py_ssize_t i, k - Py_ssize_t gw = self.Gr.gw - double dzi = self.Gr.dzi - double dti_ = 1.0/self.dt_upd - double dt_ = 1.0/dti_ - double adv_up, adv_dw - double a1, a2 # groupings of terms in area fraction discrete equation - double au_lim - double a_k, a_km, entr_w, detr_w, B_k, entr_term, detr_term, rho_ratio - double adv, buoy, exch, press, press_buoy, press_drag # groupings of terms in velocity discrete equation - - - with nogil: - for i in xrange(self.n_updrafts): - self.entr_sc[i,gw] = 2.0 * dzi - self.detr_sc[i,gw] = 0.0 - self.UpdVar.Area.new[i,gw] = self.area_surface_bc[i] - au_lim = self.area_surface_bc[i] * self.max_area_factor - # here W is calculated at full levels for the first step - later is calcualted as "collocated" and interpolated - a_k = self.UpdVar.Area.values[i,gw] - entr_w = self.entr_sc[i,gw] - detr_w = self.detr_sc[i,gw] - B_k = self.UpdVar.B.values[i,gw] - adv = self.Ref.rho0_c[gw] * a_k * self.UpdVar.W.values[i,gw] * self.UpdVar.W.values[i,gw] * dzi *2.0 - exch = (self.Ref.rho0_c[gw] * a_k * self.UpdVar.W.values[i,gw] - * (entr_w * self.EnvVar.W.values[gw] - detr_w * self.UpdVar.W.values[i,gw] )) - buoy= self.Ref.rho0_c[gw] * a_k * B_k - press_buoy = -1.0 * self.Ref.rho0_c[gw] * a_k * B_k * self.pressure_buoy_coeff - press_drag = -1.0 * self.Ref.rho0_c[gw] * sqrt(a_k) * (self.pressure_drag_coeff/self.pressure_plume_spacing - * fabs(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])*(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])) - press = press_buoy + press_drag - self.updraft_pressure_sink[i,gw] = press - self.UpdVar.W.new[i,gw] = (self.Ref.rho0_c[gw] * a_k * self.UpdVar.W.values[i,gw] * dti_ - -adv + exch + buoy + press)/(self.Ref.rho0_c[gw] * self.UpdVar.Area.values[i,gw] * dti_) - self.UpdVar.W.values[i,gw] = self.UpdVar.W.new[i,gw] - - for k in range(gw+1, self.Gr.nzg-gw): - - # First solve for updated area fraction at k+1 - if self.UpdVar.W.values[i,k]<0: - sgn_w = 0.0 - else: - sgn_w = 1.0 - sgn_w = 1.0 - - entr_term = self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * (2*sgn_w-1.0)*( self.entr_sc[i,k]) - detr_term = self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * (2*sgn_w-1.0)*(-self.detr_sc[i,k]) - - adv_up = -self.Ref.alpha0_c[k] * dzi *( self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] - -self.Ref.rho0_c[k-1] * self.UpdVar.Area.values[i,k-1] * self.UpdVar.W.values[i,k-1]) - #adv_dw = -self.Ref.alpha0_c[k] * dzi *( self.Ref.rho0_c[k+1] * self.UpdVar.Area.values[i,k+1] * self.UpdVar.W.values[i,k+1] - # -self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k]) - #adv = sgn_w*adv_up + (1.0-sgn_w)*adv_dw - adv = adv_up - - - self.UpdVar.Area.new[i,k] = fmax(dt_ * (adv + entr_term + detr_term) + self.UpdVar.Area.values[i,k], 0.0) - if self.UpdVar.Area.new[i,k] > au_lim: - self.UpdVar.Area.new[i,k] = au_lim - if self.UpdVar.Area.values[i,k] > 0.0: - self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ - adv - (2*sgn_w-1.0)*entr_term)/(-self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k])) - else: - # this detrainment rate won't affect scalars but would affect velocity - self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ - adv - (2*sgn_w-1.0)*entr_term)/(-au_lim * self.UpdVar.W.values[i,k])) - - - if self.UpdVar.Area.new[i,k] >= self.minimum_area: - entr_w = self.entr_sc[i,k] - detr_w = self.detr_sc[i,k] - a_k = self.UpdVar.Area.values[i,k] - B_k = self.UpdVar.B.values[i,k] - - adv_up = (self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] **2 * dzi - - self.Ref.rho0_c[k-1] * self.UpdVar.Area.values[i,k-1] * self.UpdVar.W.values[i,k-1] **2 * dzi) - #adv_dw = (self.Ref.rho0_c[k+1] * self.UpdVar.Area.values[i,k+1] * self.UpdVar.W.values[i,k+1]**2 - # - self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k]**2)* dzi - #adv = sgn_w*adv_up + (1.0-sgn_w)*adv_dw - adv = adv_up - - exch = (self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] - * ((2*sgn_w-1.0)*entr_w * self.EnvVar.W.values[k] - (2*sgn_w-1.0)*detr_w*self.UpdVar.W.values[i,k])) - buoy= self.Ref.rho0_c[k+1] * a_k * B_k - press_buoy = -1.0 * self.Ref.rho0_c[k] * a_k * B_k * self.pressure_buoy_coeff - press_drag = -1.0 * self.Ref.rho0_c[k] * sqrt(a_k) * (self.pressure_drag_coeff/self.pressure_plume_spacing - *fabs(self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k]) * (self.UpdVar.W.values[i,k] -self.EnvVar.W.values[k])) - press = press_buoy + press_drag - self.updraft_pressure_sink[i,k] = press - self.UpdVar.W.new[i,k] = (self.Ref.rho0_c[k] * a_k * self.UpdVar.W.values[i,k] * dti_ - -adv + exch + buoy + press)/(self.Ref.rho0_c[k] * self.UpdVar.Area.new[i,k] * dti_) - - with gil: - #self.nan_check(1003, GMV,k) - print self.UpdVar.W.new[i,k], B_k - - - if self.UpdVar.W.new[i,k] <= 0.0: - self.UpdVar.W.new[i,k:] = 0.0 - self.UpdVar.Area.new[i,k:] = 0.0 - break - - - else: - self.UpdVar.W.new[i,k:] = 0.0 - self.UpdVar.Area.new[i,k+1] = 0.0 - # keep this in mind if we modify updraft top treatment! - self.updraft_pressure_sink[i,k] = 0.0 - break - - return - - - cpdef solve_updraft_scalars(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS): - cdef: - Py_ssize_t k, i - double dzi = self.Gr.dzi - double dti_ = 1.0/self.dt_upd - double m_k, m_km, m_kp, sgn_w - Py_ssize_t gw = self.Gr.gw - double H_entr, QT_entr - double c1, c2, c3, c4 - eos_struct sa - double qt_var, h_var - double adv,exch, adv_up, adv_dw - - with nogil: - for i in xrange(self.n_updrafts): - self.UpdVar.H.new[i,gw] = self.h_surface_bc[i] - self.UpdVar.QT.new[i,gw] = self.qt_surface_bc[i] - self.UpdVar.QR.new[i,gw] = 0.0 #TODO - - if self.use_local_micro: - # do saturation adjustment - sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, - self.Ref.p0_c[gw], self.UpdVar.QT.new[i,gw], self.UpdVar.H.new[i,gw]) - self.UpdVar.QL.new[i,gw] = sa.ql - self.UpdVar.T.new[i,gw] = sa.T - # remove precipitation (update QT, QL and H) - self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0_c[gw], self.UpdVar.T.new[i,gw], - &self.UpdVar.QT.new[i,gw], &self.UpdVar.QL.new[i,gw], - &self.UpdVar.QR.new[i,gw], &self.UpdVar.H.new[i,gw], - i, gw) - - # starting from the bottom do entrainment at each level - for k in xrange(gw+1, self.Gr.nzg-gw): - H_entr = self.EnvVar.H.values[k] - QT_entr = self.EnvVar.QT.values[k] - - # write the discrete equations in form: - # c1 * phi_new[k] = c2 * phi[k] + c3 * phi[k-1] + c4 * phi_entr - if self.UpdVar.Area.new[i,k] >= self.minimum_area: - - if self.UpdVar.W.values[i,k]<0.0: - sgn_w = 0.0 - else: - sgn_w = 1.0 - sgn_w = 1.0 - - m_kp = (self.Ref.rho0_c[k+1] * self.UpdVar.Area.values[i,k+1] * self.UpdVar.W.values[i,k+1]) - m_k = (self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k]) - m_km = (self.Ref.rho0_c[k-1] * self.UpdVar.Area.values[i,k-1] * self.UpdVar.W.values[i,k-1]) - - c1 = self.Ref.rho0_c[k] * self.UpdVar.Area.new[i,k] * dti_ - c2 = (self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * dti_ - - (2*sgn_w-1.0)*m_k * (dzi + self.detr_sc[i,k])) - c3 = sgn_w*m_km * dzi-(1.0-sgn_w)*m_kp * dzi - c4 = (2*sgn_w-1.0)*(m_k * self.entr_sc[i,k]) - - self.UpdVar.H.new[i,k] = (c2 * self.UpdVar.H.values[i,k] + c3*sgn_w * self.UpdVar.H.values[i,k-1] - + c3*(1.0-sgn_w) * self.UpdVar.H.values[i,k+1] + c4 * H_entr )/c1 - self.UpdVar.QT.new[i,k] = (c2 * self.UpdVar.QT.values[i,k] + c3*sgn_w * self.UpdVar.QT.values[i,k-1] - + c3*(1.0-sgn_w) * self.UpdVar.QT.values[i,k+1] + c4* QT_entr)/c1 - - - # adv_up = (self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] *self.UpdVar.H.values[i,k] * dzi - # - self.Ref.rho0_c[k-1] * self.UpdVar.Area.values[i,k-1] * self.UpdVar.W.values[i,k-1] *self.UpdVar.H.values[i,k-1] * dzi) - # adv_dw = (self.Ref.rho0_c[k+1] * self.UpdVar.Area.values[i,k+1] * self.UpdVar.W.values[i,k+1] *self.UpdVar.H.values[i,k+1] * dzi - # - self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] *self.UpdVar.H.values[i,k] * dzi) - # adv = adv_up - # exch = (self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] - # * ((2*sgn_w-1.0)*self.entr_sc[i,k] * self.EnvVar.H.values[k] - (2*sgn_w-1.0)*self.detr_sc[i,k]*self.UpdVar.H.values[i,k])) - # self.UpdVar.H.new[i,k] = (self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.H.values[i,k] * dti_ - # -adv + exch )/(self.Ref.rho0_c[k] * self.UpdVar.Area.new[i,k] * dti_) - # - # adv_up = (self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] *self.UpdVar.QT.values[i,k] * dzi - # - self.Ref.rho0_c[k-1] * self.UpdVar.Area.values[i,k-1] * self.UpdVar.W.values[i,k-1] *self.UpdVar.QT.values[i,k-1] * dzi) - # adv_dw = (self.Ref.rho0_c[k+1] * self.UpdVar.Area.values[i,k+1] * self.UpdVar.W.values[i,k+1] *self.UpdVar.QT.values[i,k+1] * dzi - # - self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] *self.UpdVar.QT.values[i,k] * dzi) - # adv = adv_up - # exch = (self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] - # * ((2*sgn_w-1.0)*self.entr_sc[i,k] * self.EnvVar.QT.values[k] - (2*sgn_w-1.0)*self.detr_sc[i,k]*self.UpdVar.QT.values[i,k])) - # - # self.UpdVar.QT.new[i,k] = (self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.QT.values[i,k] * dti_ - # -adv + exch )/(self.Ref.rho0_c[k] * self.UpdVar.Area.new[i,k] * dti_) - - - - - else: - self.UpdVar.H.new[i,k] = GMV.H.values[k] - self.UpdVar.QT.new[i,k] = GMV.QT.values[k] - - # find new temperature - sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_c[k], - self.UpdVar.QT.new[i,k], self.UpdVar.H.new[i,k]) - self.UpdVar.QL.new[i,k] = sa.ql - self.UpdVar.T.new[i,k] = sa.T - - if self.use_local_micro: - # remove precipitation (pdate QT, QL and H) - self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0_c[k], self.UpdVar.T.new[i,k], - &self.UpdVar.QT.new[i,k], &self.UpdVar.QL.new[i,k], - &self.UpdVar.QR.new[i,k], &self.UpdVar.H.new[i,k], - i, k) - - if self.use_local_micro: - # save the total source terms for H and QT due to precipitation - # TODO - add QR source - self.UpdMicro.prec_source_h_tot = np.sum(np.multiply(self.UpdMicro.prec_source_h, - self.UpdVar.Area.values), axis=0) - self.UpdMicro.prec_source_qt_tot = np.sum(np.multiply(self.UpdMicro.prec_source_qt, - self.UpdVar.Area.values), axis=0) - else: - # Compute the updraft microphysical sources (precipitation) - #after the entrainment loop is finished - self.UpdMicro.compute_sources(self.UpdVar) - # Update updraft variables with microphysical source tendencies - self.UpdMicro.update_updraftvars(self.UpdVar) - - self.UpdVar.H.set_bcs(self.Gr) - self.UpdVar.QT.set_bcs(self.Gr) - self.UpdVar.QR.set_bcs(self.Gr) - return - - # After updating the updraft variables themselves: - # 1. compute the mass fluxes (currently not stored as class members, probably will want to do this - # for output purposes) - # 2. Apply mass flux tendencies and updraft microphysical tendencies to GMV.SomeVar.Values (old time step values) - # thereby updating to GMV.SomeVar.mf_update - # mass flux tendency is computed as 1st order upwind - cpdef solve_updraft(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS): cdef: @@ -1704,12 +1462,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): c[nz-1] = 0.0 tridiag_solve(self.Gr.nz, &x[0],&a[0], &b[0], &c[0]) - # if Covar.name == 'tke': - # tke_factor = 0.5 - # else: - # tke_factor = 1.0 - - for kk in xrange(nz): k = kk + gw if Covar.name == 'thetal_qt_covar': @@ -1717,9 +1469,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Covar.values[k] = fmin(x[kk], sqrt(self.EnvVar.Hvar.values[k]*self.EnvVar.QTvar.values[k])) else: Covar.values[k] = fmax(x[kk],0.0) - #with nogil: - # GmvCovar.values[k] = (ae[k] * (Covar.values[k] + (EnvVar1.values[k]-GmvVar1.values[k]) * (EnvVar2.values[k]-GmvVar2.values[k])) - # + self.UpdVar.Area.bulkvalues[k] * (UpdVar1.bulkvalues[k]-GmvVar1.values[k]) * (UpdVar2.bulkvalues[k]-GmvVar2.values[k])) self.get_GMV_CoVar(self.UpdVar.Area, UpdVar1, UpdVar2, EnvVar1, EnvVar2, Covar, &GmvVar1.values[0], &GmvVar2.values[0], &GmvCovar.values[0]) From d7991a164b367623387159bc9bd1600207e802ff Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Tue, 25 Sep 2018 16:02:28 -0700 Subject: [PATCH 123/136] ..: --- Cases.pyx | 1 - EDMF_Environment.pyx | 1 - 2 files changed, 2 deletions(-) diff --git a/Cases.pyx b/Cases.pyx index 5b3e64d5..b19890b4 100644 --- a/Cases.pyx +++ b/Cases.pyx @@ -867,7 +867,6 @@ cdef class ARM_SGP(CasesBase): Theta_in = np.array([299.0, 301.5, 302.5, 303.53, 303.7, 307.13, 314.0, 343.2]) # K r_in = np.array([15.2,15.17,14.98,14.8,14.7,13.5,3.0,3.0])/1000 # qt should be in kg/kg qt_in = np.divide(r_in,(1+r_in)) - print qt_in # interpolate to the model grid-points Theta = np.interp(Gr.z_c,z_in,Theta_in) diff --git a/EDMF_Environment.pyx b/EDMF_Environment.pyx index 47e8d337..8183337b 100644 --- a/EDMF_Environment.pyx +++ b/EDMF_Environment.pyx @@ -240,7 +240,6 @@ cdef class EnvironmentThermodynamics: # condensation + autoconversion sa = eos(self.t_to_prog_fp, self.prog_to_t_fp, self.Ref.p0_c[k], EnvVar.QT.values[k], EnvVar.H.values[k]) mph = microphysics(sa.T, sa.ql, self.Ref.p0_c[k], EnvVar.QT.values[k], self.max_supersaturation, in_Env) - self.update_EnvVar( k, EnvVar, mph.T, mph.thl, mph.qt, mph.ql, mph.qr, mph.alpha) self.update_cloud_dry(k, EnvVar, mph.T, mph.th, mph.qt, mph.ql, mph.qv) return From 3c77f8ab67c60be750f708739bab63a8a6c59ede Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Tue, 25 Sep 2018 17:11:05 -0700 Subject: [PATCH 124/136] working with Soares for downward integration --- Turbulence_PrognosticTKE.pyx | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 5be2556e..992cdbc5 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -869,9 +869,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double dti_ = 1.0/self.dt_upd double dt_ = self.dt_upd double adv, exch, press_buoy, press_drag, entr_term, buoy, press - double var_kp ,var_k, var_km, area_new + double var_kp ,var_k, var_km, area_new, sgn_w double au_lim = self.area_surface_bc[i] * self.max_area_factor - double sgn_w = 1.0 if var.name == 'w': buoy = self.Ref.rho0_c[k] * self.UpdVar.Area.values[i,k] * self.UpdVar.B.values[i,k] @@ -904,13 +903,13 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: if self.UpdVar.W.values[i,k]<0: - with gil: - print '========================== integrating downwards ==========================' + sgn_w = -1.0 adv = (self.Ref.rho0_c[k+1] * area.values[i,k+1] * self.UpdVar.W.values[i,k+1] * var_kp - self.Ref.rho0_c[k] *area.values[i,k] * self.UpdVar.W.values[i,k] * var_k )* dzi exch = (self.Ref.rho0_c[k] * area.values[i,k] * self.UpdVar.W.values[i,k] * (-self.entr_sc[i,k] * env_var + self.detr_sc[i,k] * var_k )) else: + sgn_w = 1.0 adv = (self.Ref.rho0_c[k] * area.values[i,k] * self.UpdVar.W.values[i,k] * var_k - self.Ref.rho0_c[k-1] * area.values[i,k-1] * self.UpdVar.W.values[i,k-1] * var_km)* dzi exch = (self.Ref.rho0_c[k] * area.values[i,k] * self.UpdVar.W.values[i,k] @@ -922,7 +921,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): if var.name =='area_fraction': var.new[i,k] = fmax(var.new[i,k] , 0.0) - entr_term = self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * ( self.entr_sc[i,k]) + entr_term = sgn_w *self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.entr_sc[i,k] if self.UpdVar.Area.new[i,k] > au_lim: self.UpdVar.Area.new[i,k] = au_lim @@ -931,11 +930,12 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): else: self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ +self.Ref.alpha0_c[k] * adv - entr_term)/(-au_lim * self.UpdVar.W.values[i,k])) - if var.name == 'w': - if self.UpdVar.W.new[i,k] <= 0.0: - print 'clipping',k, self.UpdVar.W.new[i,k],self.UpdVar.Area.new[i,k] - self.UpdVar.W.new[i,k] = 0.0 - self.UpdVar.Area.new[i,k] = 0.0 + # uncomment this for clipping and avoiding downward integration + # if var.name == 'w': + # if self.UpdVar.W.new[i,k] <= 0.0: + # print 'clipping',k, self.UpdVar.W.new[i,k],self.UpdVar.Area.new[i,k] + # self.UpdVar.W.new[i,k] = 0.0 + # self.UpdVar.Area.new[i,k] = 0.0 return @@ -1364,6 +1364,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double tke_factor = 1.0 if Covar.name =='tke': tke_factor = 0.5 + with nogil: for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): Covar.entr_gain[k] = 0.0 From aa259bd976b010803cd5c2785d336a10ba71c009 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Wed, 26 Sep 2018 17:18:57 -0700 Subject: [PATCH 125/136] .. --- NetCDFIO.pyx | 4 ++-- Turbulence_PrognosticTKE.pyx | 3 +-- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/NetCDFIO.pyx b/NetCDFIO.pyx index 55a9d3f9..34df8740 100644 --- a/NetCDFIO.pyx +++ b/NetCDFIO.pyx @@ -90,7 +90,7 @@ cdef class NetCDFIO_Stats: profile_grp.createDimension('t', None) z_f = profile_grp.createVariable('z', 'f8', ('z')) z_f[:] = np.array(self.Gr.z_f[kmin:kmax]) - z_c = profile_grp.createVariable('z_c', 'f8', ('z')) + z_c = profile_grp.createVariable('z_half', 'f8', ('z')) z_c[:] = np.array(self.Gr.z_c[kmin:kmax]) profile_grp.createVariable('t', 'f8', ('t')) del z_f @@ -100,7 +100,7 @@ cdef class NetCDFIO_Stats: reference_grp.createDimension('z', self.Gr.nz) z_f = reference_grp.createVariable('z', 'f8', ('z')) z_f[:] = np.array(self.Gr.z_f[kmin:kmax]) - z_c = reference_grp.createVariable('z_c', 'f8', ('z')) + z_c = reference_grp.createVariable('z_half', 'f8', ('z')) z_c[:] = np.array(self.Gr.z_c[kmin:kmax]) del z_f del z_c diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 992cdbc5..da44ef11 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -720,7 +720,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double [:] Poisson_rand double logfn - long quadrature_order = 2 + long quadrature_order = 5 self.UpdVar.get_cloud_base_top_cover() @@ -840,7 +840,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.QL.new[i,k] = sa.ql self.UpdVar.T.new[i,k] = sa.T - self.nan_check(1197, GMV,k) if self.use_local_micro: self.UpdMicro.compute_update_combined_local_thetal(self.Ref.p0_c[k], self.UpdVar.T.new[i,k], &self.UpdVar.QT.new[i,k], &self.UpdVar.QL.new[i,k], From 0c69d9f15fde0f51de37138210c28039cf66c41e Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Thu, 27 Sep 2018 14:40:34 -0700 Subject: [PATCH 126/136] .. --- Cases.pyx | 7 +++-- EDMF_Environment.pyx | 2 +- Turbulence_PrognosticTKE.pyx | 51 ++++++++++++++++++------------------ Variables.pyx | 4 +-- 4 files changed, 33 insertions(+), 31 deletions(-) diff --git a/Cases.pyx b/Cases.pyx index b19890b4..c4e40cf0 100644 --- a/Cases.pyx +++ b/Cases.pyx @@ -975,8 +975,8 @@ cdef class GATE_III(CasesBase): def __init__(self, paramlist): self.casename = 'GATE_III' self.Sur = Surface.SurfaceFixedCoeffs(paramlist) - self.Fo = Forcing.ForcingStandard() # it was forcing standard - self.inversion_option = 'thetal_maxgrad' + self.Fo = Forcing.ForcingStandard() + self.inversion_option = 'critical_Ri'# 'thetal_maxgrad' self.Fo.apply_subsidence = False self.Fo.apply_coriolis = False @@ -1041,6 +1041,7 @@ cdef class GATE_III(CasesBase): cpdef initialize_surface(self, Grid Gr, ReferenceState Ref): self.Sur.Gr = Gr self.Sur.Ref = Ref + self.Sur.zrough = 0.00015 self.Sur.qsurface = 16.5/1000.0 # kg/kg self.Sur.Gr = Gr self.Sur.Ref = Ref @@ -1079,6 +1080,8 @@ cdef class GATE_III(CasesBase): self.Fo.dqtdt = np.interp(Gr.z_c,z_in,Qtend_in) self.Fo.dTdt = np.interp(Gr.z_c,z_in,Ttend_in) + np.interp(Gr.z_c,z_in,RAD_in) + self.Fo.ug = np.interp(Gr.z_c,z_in,u_in) + self.Fo.ug = np.multiply(0.0,self.Fo.ug) return diff --git a/EDMF_Environment.pyx b/EDMF_Environment.pyx index 4d2f28ae..ebbc5c42 100644 --- a/EDMF_Environment.pyx +++ b/EDMF_Environment.pyx @@ -22,7 +22,7 @@ cdef class EnvironmentVariable: self.values = np.zeros((nz,),dtype=np.double, order='c') self.flux = np.zeros((nz,),dtype=np.double, order='c') if loc != 'half': - print('Invalid location setting for variable! Must be half') + print('Invalid location setting for variable! Must be half ') self.loc = loc if kind != 'scalar' and kind != 'velocity': print ('Invalid kind setting for variable! Must be scalar or velocity') diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index da44ef11..7e5deebf 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -326,9 +326,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.wstar = get_wstar(Case.Sur.bflux, self.zi) if TS.nstep == 0: self.initialize_covariance(GMV, Case) - #self.decompose_environment(GMV, 'values') try without this - #self.EnvThermo.satadjust(self.EnvVar, GMV) - #self.UpdThermo.buoyancy(self.UpdVar, self.EnvVar,GMV, self.extrapolate_buoyancy) with nogil: for k in xrange(self.Gr.nzg): if self.calc_tke: @@ -337,9 +334,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.EnvVar.Hvar.values[k] = GMV.Hvar.values[k] self.EnvVar.QTvar.values[k] = GMV.QTvar.values[k] self.EnvVar.HQTcov.values[k] = GMV.HQTcov.values[k] - self.decompose_environment(GMV, 'values') - self.EnvThermo.satadjust(self.EnvVar, GMV) - self.UpdThermo.buoyancy(self.UpdVar, self.EnvVar,GMV, self.extrapolate_buoyancy) + #self.decompose_environment(GMV, 'values') + #self.EnvThermo.satadjust(self.EnvVar, GMV) + #self.UpdThermo.buoyancy(self.UpdVar, self.EnvVar,GMV, self.extrapolate_buoyancy) self.decompose_environment(GMV, 'values') @@ -785,26 +782,28 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.H.new[i,gw] = self.h_surface_bc[i] self.UpdVar.QT.new[i,gw] = self.qt_surface_bc[i] - #self.UpdVar.W.new[i,gw-1] = 0.0 - #self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, gw, i, self.EnvVar.W.values[gw], 2.0 * dzi) - - - a_k = self.UpdVar.Area.values[i,gw] - entr_w = self.entr_sc[i,gw] - detr_w = self.detr_sc[i,gw] - B_k = self.UpdVar.B.values[i,gw] - adv = self.Ref.rho0_c[gw] * a_k * self.UpdVar.W.values[i,gw] * self.UpdVar.W.values[i,gw] * dzi *2.0 - exch = (self.Ref.rho0_c[gw] * a_k * self.UpdVar.W.values[i,gw] - * (entr_w * self.EnvVar.W.values[gw] - detr_w * self.UpdVar.W.values[i,gw] )) - buoy= self.Ref.rho0_c[gw] * a_k * B_k - press_buoy = -1.0 * self.Ref.rho0_c[gw] * a_k * B_k * self.pressure_buoy_coeff - press_drag = -1.0 * self.Ref.rho0_c[gw] * sqrt(a_k) * (self.pressure_drag_coeff/self.pressure_plume_spacing - * fabs(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])*(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])) - press = press_buoy + press_drag - self.updraft_pressure_sink[i,gw] = press - self.UpdVar.W.new[i,gw] = (self.Ref.rho0_c[gw] * a_k * self.UpdVar.W.values[i,gw] * dti_ - -adv + exch + buoy + press)/(self.Ref.rho0_c[gw] * self.UpdVar.Area.values[i,gw] * dti_) - self.UpdVar.W.values[i,gw] = self.UpdVar.W.new[i,gw] + self.UpdVar.W.new[i,gw-1] = 0.0 + self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, gw, i, self.EnvVar.W.values[gw], 2.0 * dzi) + + + # a_k = self.UpdVar.Area.values[i,gw] + # entr_w = self.entr_sc[i,gw] + # detr_w = self.detr_sc[i,gw] + # B_k = self.UpdVar.B.values[i,gw] + # adv = self.Ref.rho0_c[gw] * a_k * self.UpdVar.W.values[i,gw] * self.UpdVar.W.values[i,gw] * dzi *2.0 + # exch = (self.Ref.rho0_c[gw] * a_k * self.UpdVar.W.values[i,gw] + # * (entr_w * self.EnvVar.W.values[gw] - detr_w * self.UpdVar.W.values[i,gw] )) + # buoy= self.Ref.rho0_c[gw] * a_k * B_k + # press_buoy = -1.0 * self.Ref.rho0_c[gw] * a_k * B_k * self.pressure_buoy_coeff + # press_drag = -1.0 * self.Ref.rho0_c[gw] * sqrt(a_k) * (self.pressure_drag_coeff/self.pressure_plume_spacing + # * fabs(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])*(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])) + # press = press_buoy + press_drag + # self.updraft_pressure_sink[i,gw] = press + # self.UpdVar.W.new[i,gw] = (self.Ref.rho0_c[gw] * a_k * self.UpdVar.W.values[i,gw] * dti_ + # -adv + exch + buoy + press)/(self.Ref.rho0_c[gw] * self.UpdVar.Area.values[i,gw] * dti_) + + #self.UpdVar.W.values[i,gw] = self.UpdVar.W.new[i,gw] + sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_c[gw], self.UpdVar.QT.new[i,gw], self.UpdVar.H.new[i,gw]) diff --git a/Variables.pyx b/Variables.pyx index 706d6d40..1465ce5c 100644 --- a/Variables.pyx +++ b/Variables.pyx @@ -68,8 +68,8 @@ cdef class VariableDiagnostic: # Value at the current timestep self.values = np.zeros((nz_tot,),dtype=np.double, order='c') # Placement on staggered grid - if loc != 'half': - print('Invalid location setting for variable! Must be half') + if loc != 'half' and loc != 'full': + print('Invalid location setting for variable! Must be half or full') self.loc = loc if kind != 'scalar' and kind != 'velocity': print ('Invalid kind setting for variable! Must be scalar or velocity') From 025d123ed6eff7bff5b35b70527de666d8643ce1 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Thu, 27 Sep 2018 15:44:53 -0700 Subject: [PATCH 127/136] merge with new unified and running soares --- Turbulence_PrognosticTKE.pyx | 22 ++-------------------- 1 file changed, 2 insertions(+), 20 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 7e5deebf..c2edbc0a 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -782,29 +782,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.H.new[i,gw] = self.h_surface_bc[i] self.UpdVar.QT.new[i,gw] = self.qt_surface_bc[i] + + # this is set here for BC at z=0 given the factor 2 in dzi below, but will be overwriteen when setting new to values self.UpdVar.W.new[i,gw-1] = 0.0 self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, gw, i, self.EnvVar.W.values[gw], 2.0 * dzi) - - # a_k = self.UpdVar.Area.values[i,gw] - # entr_w = self.entr_sc[i,gw] - # detr_w = self.detr_sc[i,gw] - # B_k = self.UpdVar.B.values[i,gw] - # adv = self.Ref.rho0_c[gw] * a_k * self.UpdVar.W.values[i,gw] * self.UpdVar.W.values[i,gw] * dzi *2.0 - # exch = (self.Ref.rho0_c[gw] * a_k * self.UpdVar.W.values[i,gw] - # * (entr_w * self.EnvVar.W.values[gw] - detr_w * self.UpdVar.W.values[i,gw] )) - # buoy= self.Ref.rho0_c[gw] * a_k * B_k - # press_buoy = -1.0 * self.Ref.rho0_c[gw] * a_k * B_k * self.pressure_buoy_coeff - # press_drag = -1.0 * self.Ref.rho0_c[gw] * sqrt(a_k) * (self.pressure_drag_coeff/self.pressure_plume_spacing - # * fabs(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])*(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])) - # press = press_buoy + press_drag - # self.updraft_pressure_sink[i,gw] = press - # self.UpdVar.W.new[i,gw] = (self.Ref.rho0_c[gw] * a_k * self.UpdVar.W.values[i,gw] * dti_ - # -adv + exch + buoy + press)/(self.Ref.rho0_c[gw] * self.UpdVar.Area.values[i,gw] * dti_) - - #self.UpdVar.W.values[i,gw] = self.UpdVar.W.new[i,gw] - - sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_c[gw], self.UpdVar.QT.new[i,gw], self.UpdVar.H.new[i,gw]) From 294671d6de60e6141c61f178066831674e938b1d Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Fri, 28 Sep 2018 17:52:53 -0700 Subject: [PATCH 128/136] adding DyCOMS and GABLS required functions from Ignacio's branch --- Cases.pxd | 11 +++ Cases.pyx | 99 ++++++++++++++++++- Forcing.pyx | 8 +- Surface.pxd | 1 + Surface.pyx | 49 +++++++++- Turbulence_PrognosticTKE.pxd | 4 + Turbulence_PrognosticTKE.pyx | 180 +++++++++++++++++++++++++++++++++-- generate_namelist.py | 47 +++++++++ generate_paramlist.py | 27 ++++++ surface_functions.pxd | 9 +- surface_functions.pyx | 43 +++++++++ thermodynamic_functions.pxd | 1 + thermodynamic_functions.pyx | 4 + turbulence_functions.pxd | 10 ++ turbulence_functions.pyx | 57 +++++++++++ utility_functions.pxd | 7 +- utility_functions.pyx | 30 +++++- 17 files changed, 556 insertions(+), 31 deletions(-) diff --git a/Cases.pxd b/Cases.pxd index 67461ad0..1752afc5 100644 --- a/Cases.pxd +++ b/Cases.pxd @@ -107,3 +107,14 @@ cdef class DYCOMS_RF01(CasesBase): cpdef io(self, NetCDFIO_Stats Stats) cpdef update_surface(self, GridMeanVariables GMV, TimeStepping TS) cpdef update_forcing(self, GridMeanVariables GMV, TimeStepping TS) + + +cdef class GABLS(CasesBase): + cpdef initialize_reference(self, Grid Gr, ReferenceState Ref, NetCDFIO_Stats Stats) + cpdef initialize_profiles(self, Grid Gr, GridMeanVariables GMV, ReferenceState Ref ) + cpdef initialize_surface(self, Grid Gr, ReferenceState Ref ) + cpdef initialize_forcing(self, Grid Gr, ReferenceState Ref, GridMeanVariables GMV ) + cpdef initialize_io(self, NetCDFIO_Stats Stats) + cpdef io(self, NetCDFIO_Stats Stats) + cpdef update_surface(self, GridMeanVariables GMV, TimeStepping TS) + cpdef update_forcing(self, GridMeanVariables GMV, TimeStepping TS) \ No newline at end of file diff --git a/Cases.pyx b/Cases.pyx index c4e40cf0..f01f4530 100644 --- a/Cases.pyx +++ b/Cases.pyx @@ -30,6 +30,8 @@ def CasesFactory(namelist, paramlist): return GATE_III(paramlist) elif namelist['meta']['casename'] == 'DYCOMS_RF01': return DYCOMS_RF01(paramlist) + elif namelist['meta']['casename'] == 'GABLS': + return GABLS(paramlist) else: print('case not recognized') @@ -982,8 +984,8 @@ cdef class GATE_III(CasesBase): return cpdef initialize_reference(self, Grid Gr, ReferenceState Ref, NetCDFIO_Stats Stats): - Ref.Pg = 1013.0*100 #Pressure at ground - Ref.Tg = 299.184 # surface values for reference state (RS) which outputs p0 rho0 alpha0 + Ref.Pg = 1000.0*100 #Pressure at ground + Ref.Tg = 299.88 # surface values for reference state (RS) which outputs p0 rho0 alpha0 Ref.qtg = 16.5/1000#Total water mixing ratio at surface Ref.initialize(Gr, Stats) return @@ -1294,3 +1296,96 @@ cdef class DYCOMS_RF01(CasesBase): cpdef update_forcing(self, GridMeanVariables GMV, TimeStepping TS): self.Fo.update(GMV) return + +cdef class GABLS(CasesBase): + def __init__(self, paramlist): + self.casename = 'GABLS' + self.Sur = Surface.SurfaceMoninObukhov(paramlist) + self.Fo = Forcing.ForcingStandard() + self.inversion_option = 'critical_Ri' + self.Fo.apply_coriolis = True + cdef double latitude = 73.0 + self.Fo.coriolis_param = 1.39e-4 # s^{-1} + # self.Fo.coriolis_param = 2.0 * omega * np.sin(latitude * pi / 180.0 ) # s^{-1} + self.Fo.apply_subsidence = False + return + + cpdef initialize_reference(self, Grid Gr, ReferenceState Ref, NetCDFIO_Stats Stats): + Ref.Pg = 1.0e5 #Pressure at ground + Ref.Tg = 265.0 #Temperature at ground + Ref.qtg = 1.0e-4 #0.02 #Total water mixing ratio at surface. if set to 0, alpha0, rho0, p0 are NaN. + Ref.initialize(Gr, Stats) + return + cpdef initialize_profiles(self, Grid Gr, GridMeanVariables GMV, ReferenceState Ref): + cdef: + double [:] thetal = np.zeros((Gr.nzg,), dtype=np.double, order='c') + double ql=0.0, qi =0.0 # IC of GABLS cloud-free + double [:] theta_pert = np.random.random_sample(Gr.nzg) + Py_ssize_t k + + for k in xrange(Gr.gw,Gr.nzg-Gr.gw): + GMV.U.values[k] = 8.0 + GMV.V.values[k] = 0.0 + #Set Thetal profile + if Gr.z_c[k] <= 100.0: + thetal[k] = 265.0 + else: + thetal[k] = 265.0 + (Gr.z_c[k] - 100.0) * 0.01 + + #Set qt profile + GMV.QT.values[k] = 0.0 + + if GMV.H.name == 'thetal': + for k in xrange(Gr.gw,Gr.nzg-Gr.gw): + GMV.H.values[k] = thetal[k] + GMV.T.values[k] = thetal[k] * exner_c(Ref.p0_c[k]) + GMV.THL.values[k] = thetal[k] + elif GMV.H.name == 's': + for k in xrange(Gr.gw,Gr.nzg-Gr.gw): + GMV.T.values[k] = thetal[k] * exner_c(Ref.p0_c[k]) + GMV.H.values[k] = t_to_entropy_c(Ref.p0_c[k],GMV.T.values[k], + GMV.QT.values[k], ql, qi) + GMV.THL.values[k] = thetali_c(Ref.p0_c[k],GMV.T.values[k], + GMV.QT.values[k], ql, qi, latent_heat(GMV.T.values[k])) + + GMV.U.set_bcs(Gr) + GMV.V.set_bcs(Gr) + GMV.QT.set_bcs(Gr) + GMV.H.set_bcs(Gr) + GMV.T.set_bcs(Gr) + GMV.satadjust() + return + + cpdef initialize_surface(self, Grid Gr, ReferenceState Ref): + self.Sur.Gr = Gr + self.Sur.Ref = Ref + self.Sur.zrough = 0.1 + self.Sur.Tsurface = 265.0 + self.Sur.initialize() + return + + cpdef initialize_forcing(self, Grid Gr, ReferenceState Ref, GridMeanVariables GMV): + self.Fo.Gr = Gr + self.Fo.Ref = Ref + self.Fo.initialize(GMV) + cdef Py_ssize_t k + for k in xrange(Gr.gw, Gr.nzg - Gr.gw): + # Geostrophic velocity profiles. vg = 0 + self.Fo.ug[k] = 8.0 + self.Fo.vg[k] = 0.0 + return + + cpdef initialize_io(self, NetCDFIO_Stats Stats): + CasesBase.initialize_io(self, Stats) + return + cpdef io(self, NetCDFIO_Stats Stats): + CasesBase.io(self,Stats) + return + cpdef update_surface(self, GridMeanVariables GMV, TimeStepping TS): + self.Sur.Tsurface = 265.0 - (0.25/3600.0)*TS.t + self.Sur.update(GMV) + return + + cpdef update_forcing(self, GridMeanVariables GMV, TimeStepping TS): + self.Fo.update(GMV) + return diff --git a/Forcing.pyx b/Forcing.pyx index 727bfd41..9c34cf65 100644 --- a/Forcing.pyx +++ b/Forcing.pyx @@ -159,7 +159,7 @@ cdef class ForcingDYCOMS_RF01(ForcingBase): if (GMV.QT.values[k] < 8.0 / 1000): idx_zi = k # will be used at cell edges - zi = self.Gr.z[idx_zi] + zi = self.Gr.z_f[idx_zi] rhoi = self.Ref.rho0_c[idx_zi] break @@ -179,11 +179,11 @@ cdef class ForcingDYCOMS_RF01(ForcingBase): # cooling in free troposphere for k in xrange(0, self.Gr.nzg): - if self.Gr.z[k] > zi: - cbrt_z = cbrt(self.Gr.z[k] - zi) + if self.Gr.z_f[k] > zi: + cbrt_z = cbrt(self.Gr.z_f[k] - zi) self.f_rad[k] += rhoi * dycoms_cp * self.divergence * self.alpha_z * (np.power(cbrt_z, 4) / 4.0 + zi * cbrt_z) # condition at the top - cbrt_z = cbrt(self.Gr.z[k] + self.Gr.dz - zi) + cbrt_z = cbrt(self.Gr.z_f[k] + self.Gr.dz - zi) self.f_rad[self.Gr.nzg] += rhoi * dycoms_cp * self.divergence * self.alpha_z * (np.power(cbrt_z, 4) / 4.0 + zi * cbrt_z) for k in xrange(self.Gr.gw, self.Gr.nzg - self.Gr.gw): diff --git a/Surface.pxd b/Surface.pxd index a1804dc9..b51d1929 100644 --- a/Surface.pxd +++ b/Surface.pxd @@ -26,6 +26,7 @@ cdef class SurfaceBase: bint ustar_fixed Grid Gr ReferenceState Ref + cpdef initialize(self) cpdef update(self, GridMeanVariables GMV) cpdef free_convection_windspeed(self, GridMeanVariables GMV) diff --git a/Surface.pyx b/Surface.pyx index 26e5b640..04ce1a97 100644 --- a/Surface.pyx +++ b/Surface.pyx @@ -7,11 +7,11 @@ import numpy as np include "parameters.pxi" import cython -from thermodynamic_functions cimport latent_heat, cpm_c, exner_c, qv_star_t, sd_c, sv_c, pv_star, theta_rho_c -from surface_functions cimport entropy_flux, compute_ustar, buoyancy_flux +from thermodynamic_functions cimport latent_heat, cpm_c, exner_c, qv_star_t, sd_c, sv_c, pv_star, theta_rho_c, t_to_entropy_c, t_to_thetali_c +from surface_functions cimport entropy_flux, compute_ustar, buoyancy_flux, exchange_coefficients_byun from turbulence_functions cimport get_wstar, get_inversion from Variables cimport GridMeanVariables -from libc.math cimport cbrt,fabs +from libc.math cimport cbrt,fabs, sqrt, cos import pylab as plt @@ -149,6 +149,7 @@ cdef class SurfaceFixedCoeffs(SurfaceBase): SurfaceBase.free_convection_windspeed(self, GMV) return + cdef class SurfaceMoninObukhov(SurfaceBase): def __init__(self, paramlist): SurfaceBase.__init__(self, paramlist) @@ -156,10 +157,52 @@ cdef class SurfaceMoninObukhov(SurfaceBase): cpdef initialize(self): return cpdef update(self, GridMeanVariables GMV): + self.qsurface = qv_star_t(self.Ref.Pg, self.Tsurface) cdef: Py_ssize_t k, gw = self.Gr.gw + double zb = self.Gr.z_c[gw] + double theta_rho_g = theta_rho_c(self.Ref.Pg, self.Tsurface, self.qsurface, self.qsurface) + double theta_rho_b = theta_rho_c(self.Ref.p0_c[gw], GMV.T.values[gw], self.qsurface, self.qsurface) + double Nb2, + double h_star + double pv, pd, sv, sd + double lv = latent_heat(GMV.T.values[gw]) + + if GMV.H.name == 'thetal': + h_star = t_to_thetali_c(self.Ref.Pg, self.Tsurface, self.qsurface, 0.0, 0.0) + elif GMV.H.name == 's': + h_star = t_to_entropy_c(self.Ref.Pg, self.Tsurface, self.qsurface, 0.0, 0.0) + self.windspeed = np.sqrt(GMV.U.values[gw]*GMV.U.values[gw] + GMV.V.values[gw] * GMV.V.values[gw]) + Nb2 = g/theta_rho_g*(theta_rho_b-theta_rho_g)/zb + Ri = Nb2 * zb * zb/(self.windspeed * self.windspeed) + + exchange_coefficients_byun(Ri, self.Gr.z_c[gw], self.zrough, &self.cm, &self.ch, &self.obukhov_length) + self.rho_uflux = -self.cm * self.windspeed * (GMV.U.values[gw] ) * self.Ref.rho0_f[gw-1] + self.rho_vflux = -self.cm * self.windspeed * (GMV.V.values[gw] ) * self.Ref.rho0_f[gw-1] + + self.rho_hflux = -self.ch * self.windspeed * (GMV.H.values[gw] - h_star) * self.Ref.rho0_f[gw-1] + self.rho_qtflux = -self.ch * self.windspeed * (GMV.QT.values[gw] - self.qsurface) * self.Ref.rho0_f[gw-1] + self.lhf = lv * self.rho_qtflux + + if GMV.H.name == 'thetal': + self.shf = cpm_c(GMV.QT.values[gw]) * self.rho_hflux + + elif GMV.H.name == 's': + pv = pv_star(GMV.T.values[gw]) + pd = self.Ref.p0_c[gw] - pv + sv = sv_c(pv,GMV.T.values[gw]) + sd = sd_c(pd, GMV.T.values[gw]) + self.shf = (self.rho_hflux - self.lhf/lv * (sv-sd)) * GMV.T.values[gw] + + self.bflux = buoyancy_flux(self.shf, self.lhf, GMV.T.values[gw], GMV.QT.values[gw],self.Ref.alpha0_f[gw-1] ) + self.ustar = sqrt(self.cm) * self.windspeed + # CK--testing this--EDMF scheme checks greater or less than zero, + if fabs(self.bflux) < 1e-10: + self.obukhov_length = 0.0 + else: + self.obukhov_length = -self.ustar *self.ustar *self.ustar /self.bflux /vkb return diff --git a/Turbulence_PrognosticTKE.pxd b/Turbulence_PrognosticTKE.pxd index 0be26ee1..ce587b4c 100644 --- a/Turbulence_PrognosticTKE.pxd +++ b/Turbulence_PrognosticTKE.pxd @@ -63,6 +63,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double max_area_factor double tke_ed_coeff double tke_diss_coeff + double [:] MLS + double [:] ml_ratio + str mixing_scheme double [:] Hvar_shear @@ -108,6 +111,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): cpdef cleanup_covariance(self, GridMeanVariables GMV) cpdef compute_tke_buoy(self, GridMeanVariables GMV) cpdef compute_tke_pressure(self) + cpdef double compute_zbl_qt_grad(self, GridMeanVariables GMV) cdef void compute_covariance_detr(self, EDMF_Environment.EnvironmentVariable_2m Covar) cdef void compute_covariance_entr(self, EDMF_Environment.EnvironmentVariable_2m Covar, EDMF_Updrafts.UpdraftVariable UpdVar1, EDMF_Updrafts.UpdraftVariable UpdVar2, EDMF_Environment.EnvironmentVariable EnvVar1, EDMF_Environment.EnvironmentVariable EnvVar2) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index c2edbc0a..d2d4fed0 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -70,10 +70,14 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.entr_detr_fp = entr_detr_inverse_w elif str(namelist['turbulence']['EDMF_PrognosticTKE']['entrainment']) == 'b_w2': self.entr_detr_fp = entr_detr_b_w2 + elif str(namelist['turbulence']['EDMF_PrognosticTKE']['entrainment']) == 'smean': + self.entr_detr_fp = entr_detr_smean elif str(namelist['turbulence']['EDMF_PrognosticTKE']['entrainment']) == 'entr_detr_tke': self.entr_detr_fp = entr_detr_tke elif str(namelist['turbulence']['EDMF_PrognosticTKE']['entrainment']) == 'entr_detr_tke2': self.entr_detr_fp = entr_detr_tke2 + elif str(namelist['turbulence']['EDMF_PrognosticTKE']['entrainment']) == 'suselj': + self.entr_detr_fp = entr_detr_suselj else: print('Turbulence--EDMF_PrognosticTKE: Entrainment rate namelist option is not recognized') except: @@ -99,6 +103,12 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.extrapolate_buoyancy = True print('Turbulence--EDMF_PrognosticTKE: defaulting to extrapolation of updraft buoyancy along a pseudoadiabat') + try: + self.mixing_scheme = namelist['turbulence']['EDMF_PrognosticTKE']['mixing_length'] + except: + self.mixing_scheme = 'Default' + + # Get values from paramlist # set defaults at some point? self.surface_area = paramlist['turbulence']['EDMF_PrognosticTKE']['surface_area'] @@ -167,6 +177,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.diffusive_flux_h = np.zeros((Gr.nzg,),dtype=np.double,order='c') self.diffusive_flux_qt = np.zeros((Gr.nzg,),dtype=np.double,order='c') + self.MLS = np.zeros((Gr.nzg,),dtype=np.double, order='c') + self.ml_ratio = np.zeros((Gr.nzg,),dtype=np.double, order='c') + return cpdef initialize(self, GridMeanVariables GMV): @@ -197,6 +210,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Stats.add_profile('mixing_length') Stats.add_profile('updraft_qt_precip') Stats.add_profile('updraft_thetal_precip') + Stats.add_profile('ed_length_scheme') + Stats.add_profile('mixing_length_ratio') if self.calc_tke: Stats.add_profile('tke_buoy') @@ -273,6 +288,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): Stats.write_profile('mixing_length', self.mixing_length[kmin:kmax]) Stats.write_profile('updraft_qt_precip', self.UpdMicro.prec_source_qt_tot[kmin:kmax]) Stats.write_profile('updraft_thetal_precip', self.UpdMicro.prec_source_h_tot[kmin:kmax]) + Stats.write_profile('ed_length_scheme', self.MLS[kmin:kmax]) + Stats.write_profile('mixing_length_ratio', self.ml_ratio[kmin:kmax]) # can these pointer function called inside the write command , or should they be called before it? if self.calc_tke: @@ -337,7 +354,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): #self.decompose_environment(GMV, 'values') #self.EnvThermo.satadjust(self.EnvVar, GMV) #self.UpdThermo.buoyancy(self.UpdVar, self.EnvVar,GMV, self.extrapolate_buoyancy) - + #print TS.t self.decompose_environment(GMV, 'values') if self.use_steady_updrafts: @@ -536,6 +553,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double dv = 0.0 double dw = 2.0 * self.EnvVar.W.values[gw] * self.Gr.dzi double H_lapse_rate ,QT_lapse_rate + double l[5], pr_vec[2] with nogil: for k in xrange(gw, self.Gr.nzg-gw): l1 = tau * sqrt(fmax(self.EnvVar.TKE.values[k],0.0)) @@ -547,9 +565,113 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): else: l2 = vkb * z_ self.mixing_length[k] = fmax( 1.0/(1.0/fmax(l1,1e-10) + 1.0/l2), 1e-3) - return + if (self.mixing_scheme == 'SBL_trial'): + #print 'Shear mixing length and Von Karman scaling' + g = 9.81 + for k in xrange(gw, self.Gr.nzg-gw): + z_ = self.Gr.z_c[k] + shear2 = pow((GMV.U.values[k+1] - GMV.U.values[k-1]) * 0.5 * self.Gr.dzi, 2) + \ + pow((GMV.V.values[k+1] - GMV.V.values[k-1]) * 0.5 * self.Gr.dzi, 2) + ri_bulk = g * (GMV.THL.values[k] - GMV.THL.values[gw]) * self.Gr.z_c[k]/ \ + GMV.THL.values[gw] / (GMV.U.values[k] * GMV.U.values[k] + GMV.V.values[k] * GMV.V.values[k]) + THL_lapse_rate = fmax(fabs((self.EnvVar.THL.values[k+1]-self.EnvVar.THL.values[k-1])*0.5*self.Gr.dzi),1e-10) + QT_lapse_rate = fmax(fabs((self.EnvVar.QT.values[k+1]-self.EnvVar.QT.values[k-1])*0.5*self.Gr.dzi),1e-10) + + # kz scale (surface layer terms) + if obukhov_length < 0.0: #unstable + l2 = vkb * z_ # * ( (1.0 - 100.0 * z_/obukhov_length)**0.2 ) + elif obukhov_length > 0.0: #stable + l2 = vkb * z_ #/ (1. + 2.7 *z_/obukhov_length) + else: + l2 = vkb * z_ + + # Shear-dissipation TKE equilibrium scale (Stable) + qt_dry = self.EnvThermo.qt_dry[k] + th_dry = self.EnvThermo.th_dry[k] + t_cloudy = self.EnvThermo.t_cloudy[k] + qv_cloudy = self.EnvThermo.qv_cloudy[k] + qt_cloudy = self.EnvThermo.qt_cloudy[k] + th_cloudy = self.EnvThermo.th_cloudy[k] + + lh = latent_heat(t_cloudy) + cpm = cpm_c(qt_cloudy) + grad_thl_plus = (self.EnvVar.THL.values[k+1] - self.EnvVar.THL.values[k]) * self.Gr.dzi + grad_qt_plus = (self.EnvVar.QT.values[k+1] - self.EnvVar.QT.values[k]) * self.Gr.dzi + + prefactor = g * ( Rd / self.Ref.alpha0_c[k] /self.Ref.p0_c[k]) * exner_c(self.Ref.p0_c[k]) + + d_alpha_thetal_dry = prefactor * (1.0 + (eps_vi-1.0) * qt_dry) + d_alpha_qt_dry = prefactor * th_dry * (eps_vi-1.0) + + if self.EnvVar.CF.values[k] > 0.0: + d_alpha_thetal_cloudy = (prefactor * (1.0 + eps_vi * (1.0 + lh / Rv / t_cloudy) * qv_cloudy - qt_cloudy ) + / (1.0 + lh * lh / cpm / Rv / t_cloudy / t_cloudy * qv_cloudy)) + d_alpha_qt_cloudy = (lh / cpm / t_cloudy * d_alpha_thetal_cloudy - prefactor) * th_cloudy + else: + d_alpha_thetal_cloudy = 0.0 + d_alpha_qt_cloudy = 0.0 + + d_alpha_thetal_total = (self.EnvVar.CF.values[k] * d_alpha_thetal_cloudy + + (1.0-self.EnvVar.CF.values[k]) * d_alpha_thetal_dry) + d_alpha_qt_total = (self.EnvVar.CF.values[k] * d_alpha_qt_cloudy + + (1.0-self.EnvVar.CF.values[k]) * d_alpha_qt_dry) + + ri_thl = grad_thl_plus * d_alpha_thetal_total / fmax(shear2, 1e-10) + ri_qt = grad_qt_plus * d_alpha_qt_total / fmax(shear2, 1e-10) + + # if (z_<50.0): + # prandtl = 0.8 + 0.8 * z_/50.0 + # else: + # prandtl = 1.6 + + # if (ri_bulk<.05): + # prandtl = 0.8 + 0.8 * ri_bulk/0.05 + # else: + # prandtl = 1.6 + pr_vec[0] = 1.6; pr_vec[1] = 0.6 + 1.0 * (ri_thl+ri_qt)/0.066 + prandtl = smooth_minimum2(pr_vec, 7.0) + + l3 = sqrt(self.tke_diss_coeff/self.tke_ed_coeff) * sqrt(fmax(self.EnvVar.TKE.values[k],0.0))/fmax(sqrt(shear2), 1.0e-10) + l3 /= sqrt(fmax(1.0 - ri_thl/prandtl - ri_qt/prandtl, 1e-7)) + if (sqrt(shear2)< 1.0e-10 or 1.0 - ri_thl/prandtl - ri_qt/prandtl < 1e-7): + l3 = 1.0e6 + l3 = fmin(l3, 1.0e7) + # print(z_, (1.0 - ri_thl/1.5 - ri_qt/1.5)) + # Temp variance length scale + l4 = sqrt(self.tke_diss_coeff/self.tke_ed_coeff) * sqrt(fmax(self.EnvVar.Hvar.values[k],0.0))/fmax(sqrt(grad_thl_plus*grad_thl_plus), 1.0e-10) + l5 = sqrt(self.tke_diss_coeff/self.tke_ed_coeff) * sqrt(fmax(self.EnvVar.QTvar.values[k],0.0))/fmax(sqrt(grad_qt_plus*grad_qt_plus), 1.0e-10) + + # Limiting stratification scale + N = fmax( 1e-8, sqrt(fmax(g/GMV.THL.values[k]*grad_thl_plus, 0.0))) + l1 = fmin(sqrt(fmax(0.35*self.EnvVar.TKE.values[k],0.0))/N, 1000.0) + if (N<1e-7): + l1 = 1.0e5 + l2 = fmin(l2, 1000.0) + l[0]=l2; l[1]=l1; l[2]=l3; l[3]=1.0e5; l[4]=1.0e5 + # self.mixing_length[k] = smooth_minimum2(l, 0.1*self.Gr.dz) # + j = 0 + while(j 0.0: + input.poisson = np.random.poisson(self.Gr.dz/((input.zbl-self.UpdVar.cloud_base[i])/10.0)) + else: + input.poisson = 0.0 ret = self.entr_detr_fp(input) self.entr_sc[i,k] = ret.entr_sc * self.entrainment_factor self.detr_sc[i,k] = ret.detr_sc * self.detrainment_factor return + cpdef double compute_zbl_qt_grad(self, GridMeanVariables GMV): + cdef: + double qt_up, qt_, z_, zbl_qt, qt_grad = 0.0 + + for k in xrange(self.Gr.gw, self.Gr.nzg-self.Gr.gw): + z_ = self.Gr.z_c[k] + qt_up = GMV.QT.values[k+1] + qt_ = GMV.QT.values[k] + + if fabs(qt_up-qt_)*self.Gr.dzi > qt_grad: + qt_grad = fabs(qt_up-qt_)*self.Gr.dzi + zbl_qt = z_ + return zbl_qt cpdef solve_updraft(self, GridMeanVariables GMV, CasesBase Case, TimeStepping TS): cdef: @@ -796,7 +965,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): &self.UpdVar.QT.new[i,gw], &self.UpdVar.QL.new[i,gw], &self.UpdVar.QR.new[i,gw], &self.UpdVar.H.new[i,gw], i, gw) - for k in range(gw+1, self.Gr.nzg-gw): self.upwind_integration(self.UpdVar.Area, self.UpdVar.Area, k, i, 1.0, dzi) @@ -912,7 +1080,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # uncomment this for clipping and avoiding downward integration # if var.name == 'w': - # if self.UpdVar.W.new[i,k] <= 0.0: + # if self.UpdVar.W.new[i,k] < 0.0: # print 'clipping',k, self.UpdVar.W.new[i,k],self.UpdVar.Area.new[i,k] # self.UpdVar.W.new[i,k] = 0.0 # self.UpdVar.Area.new[i,k] = 0.0 diff --git a/generate_namelist.py b/generate_namelist.py index 5aaecfc4..bcb70810 100644 --- a/generate_namelist.py +++ b/generate_namelist.py @@ -31,6 +31,8 @@ def main(): namelist = GATE_III() elif case_name == 'DYCOMS_RF01': namelist = DYCOMS_RF01() + elif case_name == 'GABLS': + namelist = GABLS() else: print('Not a valid case name') exit() @@ -349,6 +351,51 @@ def GATE_III(): return namelist +def GABLS(): + + namelist = {} + + namelist['grid'] = {} + namelist['grid']['dims'] = 1 + namelist['grid']['nz'] = 128 + namelist['grid']['gw'] = 2 + namelist['grid']['dz'] = 3.125 + + namelist['thermodynamics'] = {} + namelist['thermodynamics']['thermal_variable'] = 'thetal' + namelist['thermodynamics']['saturation'] = 'sa_mean' + + namelist['time_stepping'] = {} + namelist['time_stepping']['dt'] = 0.4 + namelist['time_stepping']['t_max'] = 9 * 3600.0 + + namelist['turbulence'] = {} + namelist['turbulence']['scheme'] = 'EDMF_PrognosticTKE' + namelist['turbulence']['EDMF_PrognosticTKE'] = {} + namelist['turbulence']['EDMF_PrognosticTKE']['updraft_number'] = 1 + namelist['turbulence']['EDMF_PrognosticTKE']['constant_area'] = False + namelist['turbulence']['EDMF_PrognosticTKE']['entrainment'] = 'b_w2' + namelist['turbulence']['EDMF_PrognosticTKE']['use_local_micro'] = False + namelist['turbulence']['EDMF_PrognosticTKE']['use_similarity_diffusivity'] = False + namelist['turbulence']['EDMF_PrognosticTKE']['updraft_surface_height'] = 0.0 + namelist['turbulence']['EDMF_PrognosticTKE']['extrapolate_buoyancy'] = True + namelist['turbulence']['EDMF_PrognosticTKE']['use_steady_updrafts'] = False + namelist['turbulence']['EDMF_PrognosticTKE']['calculate_tke'] = True + namelist['turbulence']['EDMF_PrognosticTKE']['calc_scalar_var'] = True + + namelist['output'] = {} + namelist['output']['output_root'] = './' + + namelist['stats_io'] = {} + namelist['stats_io']['stats_dir'] = 'stats' + namelist['stats_io']['frequency'] = 60.0 + + namelist['meta'] = {} + namelist['meta']['simname'] = 'GABLS' + namelist['meta']['casename'] = 'GABLS' + return namelist + + def DYCOMS_RF01(): namelist = {} diff --git a/generate_paramlist.py b/generate_paramlist.py index 3a0f9769..ccf6bc0b 100644 --- a/generate_paramlist.py +++ b/generate_paramlist.py @@ -48,6 +48,8 @@ def main(): paramlist = GATE_III() elif case_name == 'DYCOMS_RF01': paramlist = DYCOMS_RF01() + elif case_name == 'GABLS': + paramlist = GABLS() else: print('Not a valid case name') exit() @@ -289,6 +291,31 @@ def DYCOMS_RF01(): return paramlist +def GABLS(): + + paramlist = {} + paramlist['meta'] = {} + paramlist['meta']['casename'] = 'GABLS' + + paramlist['turbulence'] = {} + paramlist['turbulence']['prandtl_number'] = 0.8 + paramlist['turbulence']['Ri_bulk_crit'] = 0.2 + + paramlist['turbulence']['EDMF_PrognosticTKE'] = {} + paramlist['turbulence']['EDMF_PrognosticTKE']['surface_area'] = 0.1 + paramlist['turbulence']['EDMF_PrognosticTKE']['tke_ed_coeff'] = 0.15 + paramlist['turbulence']['EDMF_PrognosticTKE']['tke_diss_coeff'] = 0.14 + paramlist['turbulence']['EDMF_PrognosticTKE']['max_area_factor'] = 9.9 + paramlist['turbulence']['EDMF_PrognosticTKE']['entrainment_factor'] = 1.0 + paramlist['turbulence']['EDMF_PrognosticTKE']['detrainment_factor'] = 1.0 + paramlist['turbulence']['EDMF_PrognosticTKE']['pressure_buoy_coeff'] = 1.0 / 3.0 + paramlist['turbulence']['EDMF_PrognosticTKE']['pressure_drag_coeff'] = 0.075 + paramlist['turbulence']['EDMF_PrognosticTKE']['pressure_plume_spacing'] = 100.0 + paramlist['turbulence']['updraft_microphysics'] = {} + paramlist['turbulence']['updraft_microphysics']['max_supersaturation'] = 0.1 + + return paramlist + def write_file(paramlist): diff --git a/surface_functions.pxd b/surface_functions.pxd index 50410e8c..dfdc0363 100644 --- a/surface_functions.pxd +++ b/surface_functions.pxd @@ -9,18 +9,11 @@ include "parameters.pxi" import cython cdef double buoyancy_flux(double shf, double lhf, double T_b, double qt_b, double alpha0_0) - cdef double psi_m_unstable(double zeta, double zeta0) - cdef double psi_m_unstable(double zeta, double zeta0) - cdef double psi_h_unstable(double zeta, double zeta0) - cdef double psi_m_stable(double zeta, double zeta0) - cdef double psi_h_stable(double zeta, double zeta0) - cpdef double entropy_flux(tflux,qtflux, p0_1, T_1, qt_1) - - cpdef double compute_ustar(double windspeed, double buoyancy_flux, double z0, double z1) +cdef void exchange_coefficients_byun(double Ri, double zb, double z0, double* cm, double* ch, double* lmo) \ No newline at end of file diff --git a/surface_functions.pyx b/surface_functions.pyx index a856d215..e273faa8 100644 --- a/surface_functions.pyx +++ b/surface_functions.pyx @@ -1,6 +1,7 @@ import numpy as np from thermodynamic_functions cimport latent_heat, pd_c, pv_c, sd_c, sv_c, cpm_c, theta_rho_c from turbulence_functions cimport get_wstar, get_inversion +from libc.math cimport acos, sqrt, cbrt, fabs, cos include "parameters.pxi" #Adapated from PyCLES: https://github.com/pressel/pycles @@ -101,3 +102,45 @@ cpdef double compute_ustar(double windspeed, double buoyancy_flux, double z0, do return ustar + + +cdef void exchange_coefficients_byun(double Ri, double zb, double z0, double *cm, double *ch, double *lmo): + + #Monin-Obukhov similarity based on + #Daewon W. Byun, 1990: On the Analytical Solutions of Flux-Profile Relationships for the Atmospheric Surface Layer. J. Appl. Meteor., 29, 652–657. + #doi: http://dx.doi.org/10.1175/1520-0450(1990)029<0652:OTASOF>2.0.CO;2 + cdef: + double logz = np.log(zb/z0) + double zfactor = zb/(zb-z0)*logz + double zeta, zeta0, psi_m, psi_h + double sb = Ri/Pr0 + double qb, pb, crit, angle, tb + double cu, cth + + + if Ri > 0.0: + zeta = zfactor/(2.0*beta_h*(beta_m*Ri -1.0))*((1.0-2.0*beta_h*Ri)-sqrt(1.0+4.0*(beta_h - beta_m)*sb)) + lmo[0] = zb/zeta + zeta0 = z0/lmo[0] + psi_m = psi_m_stable(zeta, zeta0) + psi_h = psi_h_stable(zeta,zeta0) + else: + qb = 1.0/9.0 * (1.0 /(gamma_m * gamma_m) + 3.0 * gamma_h/gamma_m * sb * sb) + pb = 1.0/54.0 * (-2.0/(gamma_m*gamma_m*gamma_m) + 9.0/gamma_m * (-gamma_h/gamma_m + 3.0)*sb * sb) + crit = qb * qb *qb - pb * pb + if crit < 0.0: + tb = cbrt(sqrt(-crit) + fabs(pb)) + zeta = zfactor * (1.0/(3.0*gamma_m)-(tb + qb/tb)) + else: + angle = acos(pb/sqrt(qb * qb * qb)) + zeta = zfactor * (-2.0 * sqrt(qb) * cos(angle/3.0)+1.0/(3.0*gamma_m)) + lmo[0] = zb/zeta + zeta0 = z0/lmo[0] + psi_m = psi_m_unstable(zeta, zeta0) + psi_h = psi_h_unstable(zeta,zeta0) + + cu = vkb/(logz-psi_m) + cth = vkb/(logz-psi_h)/Pr0 + cm[0] = cu * cu + ch[0] = cu * cth + return \ No newline at end of file diff --git a/thermodynamic_functions.pxd b/thermodynamic_functions.pxd index 73010cc8..f6b3f518 100644 --- a/thermodynamic_functions.pxd +++ b/thermodynamic_functions.pxd @@ -14,6 +14,7 @@ cdef double density_temperature_c(double T, double qt, double qv) nogil cdef double theta_rho_c(double p0, double T, double qt, double qv) nogil cdef double cpm_c(double qt) nogil cdef double thetas_entropy_c(double s, double qt) nogil +cdef double theta_virt_c(double p0, double T, double qt, double ql, double qr) nogil cdef double thetas_t_c(double p0, double T, double qt, double qv, double qc, double L) nogil cdef double entropy_from_thetas_c(double thetas, double qt) nogil cdef double buoyancy_c(double alpha0, double alpha) nogil diff --git a/thermodynamic_functions.pyx b/thermodynamic_functions.pyx index 2933ac48..34dc0604 100644 --- a/thermodynamic_functions.pyx +++ b/thermodynamic_functions.pyx @@ -72,6 +72,10 @@ cdef double qv_star_c(const double p0, const double qt, const double pv) nogil cdef double alpha_c(double p0, double T, double qt, double qv) nogil : return (Rd * T)/p0 * (1.0 - qt + eps_vi * qv) +cdef double theta_virt_c( double p0, double T, double qt, double ql, double qr) nogil : + # Virtual potential temperature, mixing ratios are approximated by specific humidities. + return theta_c(p0, T) * (1.0 + 0.61 * (qr) - ql) + cdef double t_to_entropy_c(double p0, double T, double qt, double ql, double qi) nogil : cdef double qv = qt - ql - qi diff --git a/turbulence_functions.pxd b/turbulence_functions.pxd index c9c2089f..31402c4e 100644 --- a/turbulence_functions.pxd +++ b/turbulence_functions.pxd @@ -10,6 +10,7 @@ cdef struct entr_in_struct: double zi double wstar double z + double dz double w double dw double b @@ -38,6 +39,13 @@ cdef struct entr_in_struct: double tke_ed_coeff double Poisson_rand double logfn + double zbl + double poisson + double n_up + double thv_e + double thv_u + double dwdz + double transport_der double dynamic_entr_detr long quadrature_order @@ -45,10 +53,12 @@ cdef entr_struct entr_detr_dry(entr_in_struct entr_in) nogil cdef entr_struct entr_detr_inverse_z(entr_in_struct entr_in) nogil cdef entr_struct entr_detr_inverse_w(entr_in_struct entr_in) nogil cdef entr_struct entr_detr_b_w2(entr_in_struct entr_in) nogil +cdef entr_struct entr_detr_smean(entr_in_struct entr_in) nogil cdef evap_struct evap_sat_adjust(double p0, double thetal_, double qt_mix) nogil cdef double entr_detr_buoyancy_sorting_old(entr_in_struct entr_in) nogil cdef double entr_detr_buoyancy_sorting(entr_in_struct entr_in) nogil cdef entr_struct entr_detr_tke(entr_in_struct entr_in) nogil +cdef entr_struct entr_detr_suselj(entr_in_struct entr_in) nogil cdef entr_struct entr_detr_tke2(entr_in_struct entr_in) nogil cdef double get_wstar(double bflux, double zi ) cdef double get_inversion(double *theta_rho, double *u, double *v, double *z_c, diff --git a/turbulence_functions.pyx b/turbulence_functions.pyx index d01d1ec1..9d284cae 100644 --- a/turbulence_functions.pyx +++ b/turbulence_functions.pyx @@ -4,6 +4,7 @@ from libc.math cimport cbrt, sqrt, log, fabs,atan, exp, fmax, pow, fmin, tanh, e from cpython.mem cimport PyMem_Malloc, PyMem_Realloc, PyMem_Free include "parameters.pxi" from thermodynamic_functions cimport * +from utility_functions cimport smooth_minimum, smooth_maximum # Entrainment Rates cdef entr_struct entr_detr_dry(entr_in_struct entr_in)nogil: @@ -39,6 +40,62 @@ cdef entr_struct entr_detr_inverse_w(entr_in_struct entr_in) nogil: _ret.detr_sc = 0.0 return _ret +cdef entr_struct entr_detr_smean(entr_in_struct entr_in) nogil: + cdef: + entr_struct _ret + double eps_w, eps_b_w2, eps_max, eps_min, partiation_func + double del_w, del_b_w2, del_max, del_min, inv_w, eps_z + + if entr_in.af>0.0: + if entr_in.z >= entr_in.zi : + del_b_w2= 4.0e-3 + 0.12* fabs(fmin(entr_in.b,0.0)) / fmax(entr_in.w * entr_in.w, 1e-2) + else: + del_b_w2 = 0.0 + eps_b_w2 = 0.12*fabs(entr_in.b) / fmax(entr_in.w * entr_in.w, 1.0) + else: + eps_w = 0.0 + del_w = 0.0 + + eps_z = vkb/entr_in.z + + inv_w = 1.0/(fmax(fabs(entr_in.w),1.0)* 500) + if entr_in.af>0.0: + partiation_func = entr_detr_buoyancy_sorting(entr_in) + #with gil: + # print partiation_func + eps_w = partiation_func*inv_w/2.0 + del_w = (1.0-partiation_func/2.0)*inv_w + else: + eps_w = 0.0 + del_w = 0.0 + + eps_min = smooth_minimum(eps_w,eps_w, 1.0) # ,eps_z + eps_max = smooth_maximum(eps_w,eps_w,1.0) + del_min = smooth_minimum(del_w,del_w,1.0) # del_w+del_w/2, + del_max = smooth_maximum(del_w,del_w,1.0) + _ret.entr_sc = (eps_min + eps_max)/2.0 + _ret.detr_sc = (del_min + del_max)/2.0 + + return _ret + +cdef entr_struct entr_detr_suselj(entr_in_struct entr_in) nogil: + cdef: + entr_struct _ret + double entr_dry = 2.5e-3 + double l0 + double mc, mg_prod, turb_trans, buoy_prod + + l0 = (entr_in.zbl - entr_in.zi)/10.0 + if entr_in.z >= entr_in.zi : + _ret.detr_sc= 4.0e-3 + 0.12* fabs(fmin(entr_in.b,0.0)) / fmax(entr_in.w * entr_in.w, 1e-2) + _ret.entr_sc = 0.1 / fmax(entr_in.dz * entr_in.poisson,1.0) + + else: + _ret.detr_sc = 0.0 + _ret.entr_sc = 0.0 #entr_dry # Very low entrainment rate needed for Dycoms to work + + return _ret + cdef entr_struct entr_detr_tke2(entr_in_struct entr_in) nogil: cdef entr_struct _ret diff --git a/utility_functions.pxd b/utility_functions.pxd index 8c4a21d3..4dd2b1fb 100644 --- a/utility_functions.pxd +++ b/utility_functions.pxd @@ -1,6 +1,7 @@ cdef double interp2pt(double val1, double val2) nogil cdef double logistic(double x, double slope, double mid) nogil -cdef double smooth_minimum(double x1, double x2 ,double x3, double a) nogil -cdef double smooth_maximum(double x1, double x2 ,double x3, double a) nogil +cdef double smooth_minimum(double x1, double x2 , double a) nogil +cdef double smooth_maximum(double x1, double x2 , double a) nogil # double x3 , cpdef double percentile_mean_norm(double percentile, Py_ssize_t nsamples) -cpdef double percentile_bounds_mean_norm(double low_percentile, double high_percentile, Py_ssize_t nsamples) \ No newline at end of file +cpdef double percentile_bounds_mean_norm(double low_percentile, double high_percentile, Py_ssize_t nsamples) +cdef double smooth_minimum2(double [:] x, double a) nogil \ No newline at end of file diff --git a/utility_functions.pyx b/utility_functions.pyx index 6cf61743..226e943d 100644 --- a/utility_functions.pyx +++ b/utility_functions.pyx @@ -1,7 +1,8 @@ import numpy as np import scipy.special as sp -from libc.math cimport exp +from libc.math cimport exp, fmax, log from scipy.stats import norm +cimport cython # compute the mean of the values above a given percentile (0 to 1) for a standard normal distribution # this gives the surface scalar coefficient for a single updraft or nth updraft of n updrafts @@ -31,10 +32,29 @@ cdef double logistic(double x, double slope, double mid) nogil: # smin = (x1*exp(-a*x1)+x2*exp(-a*x2)+x3*exp(-a*x3)+x4*exp(-a*x4)+x5*exp(-a*x5))\ # / (exp(-a*x1)+exp(-a*x2)+exp(-a*x3)+exp(-a*x4)+exp(-a*x5)) # return smin -cdef double smooth_minimum(double x1, double x2,double x3,double a) nogil: - smin = (x1*exp(-a*x1)+x2*exp(-a*x2)+x3*exp(-a*x3))/ (exp(-a*x1)+exp(-a*x2)+exp(-a*x3)) +cdef double smooth_minimum(double x1, double x2, double a) nogil: + smin = (x1*exp(-a*x1)+x2*exp(-a*x2))/fmax(exp(-a*x1)+exp(-a*x2),0.0) + #smin = (x1*exp(-a*x1)+x2*exp(-a*x2)+x3*exp(-a*x3))/fmax(exp(-a*x1)+exp(-a*x2)+exp(-a*x3),0.0) return smin -cdef double smooth_maximum(double x1, double x2,double x3,double a) nogil: - smax = (x1*exp(a*x1)+x2*exp(a*x2)+x3*exp(a*x3))/(exp(a*x1)+exp(a*x2)+exp(a*x3)) +cdef double smooth_maximum(double x1, double x2, double a) nogil: + smax = (x1*exp(a*x1)+x2*exp(a*x2))/fmax(exp(a*x1)+exp(a*x2),1e-18) + #smax = (x1*exp(a*x1)+x2*exp(a*x2)+x3*exp(a*x3))/fmax(exp(a*x1)+exp(a*x2)+exp(a*x3),1e-18) return smax + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef double smooth_minimum2(double [:] x, double a) nogil: + cdef: + unsigned int i = 0 + double num, den, leng + with gil: + leng = len(x) + num = 0; den = 0 + while(i1.0e-5): + num += x[i]*exp(-a*(x[i])) + den += exp(-a*(x[i])) + i += 1 + smin = num/den + return smin \ No newline at end of file From 26b6eabe60135b80f3e4c831cae3713505631554 Mon Sep 17 00:00:00 2001 From: yairchn Date: Sat, 29 Sep 2018 08:33:00 -0400 Subject: [PATCH 129/136] .. --- Turbulence_PrognosticTKE.pyx | 3 --- generate_namelist.py | 1 + 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index e4b97a74..a2c94346 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -955,9 +955,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # this is set here for BC at z=0 given the factor 2 in dzi below, but will be overwriteen when setting new to values self.UpdVar.W.new[i,gw-1] = 0.0 self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, gw, i, self.EnvVar.W.values[gw], 2.0 * dzi) - print self.UpdVar.W.new[i,gw] - plt.figure() - plt.show() sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_c[gw], self.UpdVar.QT.new[i,gw], self.UpdVar.H.new[i,gw]) diff --git a/generate_namelist.py b/generate_namelist.py index d2e115a3..69f06d7b 100644 --- a/generate_namelist.py +++ b/generate_namelist.py @@ -107,6 +107,7 @@ def Bomex(): namelist['turbulence']['EDMF_PrognosticTKE'] = {} namelist['turbulence']['EDMF_PrognosticTKE']['updraft_number'] = 1 namelist['turbulence']['EDMF_PrognosticTKE']['entrainment'] = 'b_w2' + namelist['turbulence']['EDMF_PrognosticTKE']['mixing_length'] = 'SBL' namelist['turbulence']['EDMF_PrognosticTKE']['extrapolate_buoyancy'] = True namelist['turbulence']['EDMF_PrognosticTKE']['use_steady_updrafts'] = False namelist['turbulence']['EDMF_PrognosticTKE']['calc_scalar_var'] = True From 3e025dee2e4046a3cd140df3dd0b67b563caaed5 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Sat, 29 Sep 2018 21:29:42 -0700 Subject: [PATCH 130/136] temp fix for ml flag --- Turbulence_PrognosticTKE.pyx | 33 ++++++++++++++++++--------------- 1 file changed, 18 insertions(+), 15 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index a2c94346..d75948f6 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -103,9 +103,9 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.extrapolate_buoyancy = True print('Turbulence--EDMF_PrognosticTKE: defaulting to extrapolation of updraft buoyancy along a pseudoadiabat') - try: - self.mixing_scheme = namelist['turbulence']['EDMF_PrognosticTKE']['mixing_length'] - except: + if namelist['turbulence']['EDMF_PrognosticTKE']['mixing_length'] == 'SBL': + self.mixing_scheme = 'SBL' + else: self.mixing_scheme = 'Default' @@ -554,21 +554,10 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double dw = 2.0 * self.EnvVar.W.values[gw] * self.Gr.dzi double H_lapse_rate ,QT_lapse_rate double l[5], pr_vec[2] - with nogil: - for k in xrange(gw, self.Gr.nzg-gw): - l1 = tau * sqrt(fmax(self.EnvVar.TKE.values[k],0.0)) - z_ = self.Gr.z_c[k] - if obukhov_length < 0.0: #unstable - l2 = vkb * z_ * ( (1.0 - 100.0 * z_/obukhov_length)**0.2 ) - elif obukhov_length > 0.0: #stable - l2 = vkb * z_ / (1. + 2.7 *z_/obukhov_length) - else: - l2 = vkb * z_ - self.mixing_length[k] = fmax( 1.0/(1.0/fmax(l1,1e-10) + 1.0/l2), 1e-3) if (self.mixing_scheme == 'SBL'): - #print 'Shear mixing length and Von Karman scaling' + print 'Shear mixing length and Von Karman scaling' g = 9.81 for k in xrange(gw, self.Gr.nzg-gw): z_ = self.Gr.z_c[k] @@ -670,6 +659,20 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # For mesh convergence study Bomex self.mixing_length[k] = smooth_minimum2(l, 1.0/(0.1*40.0)) self.ml_ratio[k] = self.mixing_length[k]/l[int(self.MLS[k])] + else: + with nogil: + for k in xrange(gw, self.Gr.nzg-gw): + l1 = tau * sqrt(fmax(self.EnvVar.TKE.values[k],0.0)) + z_ = self.Gr.z_c[k] + if obukhov_length < 0.0: #unstable + l2 = vkb * z_ * ( (1.0 - 100.0 * z_/obukhov_length)**0.2 ) + elif obukhov_length > 0.0: #stable + l2 = vkb * z_ / (1. + 2.7 *z_/obukhov_length) + else: + l2 = vkb * z_ + self.mixing_length[k] = fmax( 1.0/(1.0/fmax(l1,1e-10) + 1.0/l2), 1e-3) + + return cpdef compute_eddy_diffusivities_tke(self, GridMeanVariables GMV, CasesBase Case): From 58dfb81e7709259e3611a9420baa283c40bdd1e6 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Sun, 30 Sep 2018 13:34:23 -0700 Subject: [PATCH 131/136] changing the flags of mixing scheme --- Turbulence_PrognosticTKE.pyx | 52 +++++++++++++++++++----------------- 1 file changed, 28 insertions(+), 24 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index d75948f6..c62454de 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -103,11 +103,16 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.extrapolate_buoyancy = True print('Turbulence--EDMF_PrognosticTKE: defaulting to extrapolation of updraft buoyancy along a pseudoadiabat') - if namelist['turbulence']['EDMF_PrognosticTKE']['mixing_length'] == 'SBL': - self.mixing_scheme = 'SBL' - else: - self.mixing_scheme = 'Default' - + try: + if str(namelist['turbulence']['EDMF_PrognosticTKE']['mixing_length']) == 'SBL': + self.mixing_scheme = 'SBL' + elif str(namelist['turbulence']['EDMF_PrognosticTKE']['mixing_length']) == 'tke': + self.mixing_scheme = 'tke' + else: + print('Turbulence--EDMF_PrognosticTKE: mixing scheme namelist option is not recognized') + except: + self.mixing_scheme = 'tke' + print('Turbulence--EDMF_PrognosticTKE: defaulting to tke based mixing scheme') # Get values from paramlist # set defaults at some point? @@ -351,10 +356,10 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.EnvVar.Hvar.values[k] = GMV.Hvar.values[k] self.EnvVar.QTvar.values[k] = GMV.QTvar.values[k] self.EnvVar.HQTcov.values[k] = GMV.HQTcov.values[k] - #self.decompose_environment(GMV, 'values') - #self.EnvThermo.satadjust(self.EnvVar, GMV) - #self.UpdThermo.buoyancy(self.UpdVar, self.EnvVar,GMV, self.extrapolate_buoyancy) - #print TS.t + self.decompose_environment(GMV, 'values') + self.EnvThermo.satadjust(self.EnvVar, GMV) + self.UpdThermo.buoyancy(self.UpdVar, self.EnvVar,GMV, self.extrapolate_buoyancy) + self.decompose_environment(GMV, 'values') if self.use_steady_updrafts: @@ -556,7 +561,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double l[5], pr_vec[2] - if (self.mixing_scheme == 'SBL'): + if self.mixing_scheme == 'SBL': print 'Shear mixing length and Von Karman scaling' g = 9.81 for k in xrange(gw, self.Gr.nzg-gw): @@ -627,7 +632,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): if (sqrt(shear2)< 1.0e-10 or 1.0 - ri_thl/prandtl - ri_qt/prandtl < 1e-7): l3 = 1.0e6 l3 = fmin(l3, 1.0e7) - # print(z_, (1.0 - ri_thl/1.5 - ri_qt/1.5)) + # Temp variance length scale l4 = sqrt(self.tke_diss_coeff/self.tke_ed_coeff) * sqrt(fmax(self.EnvVar.Hvar.values[k],0.0))/fmax(sqrt(grad_thl_plus*grad_thl_plus), 1.0e-10) l5 = sqrt(self.tke_diss_coeff/self.tke_ed_coeff) * sqrt(fmax(self.EnvVar.QTvar.values[k],0.0))/fmax(sqrt(grad_qt_plus*grad_qt_plus), 1.0e-10) @@ -659,19 +664,19 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # For mesh convergence study Bomex self.mixing_length[k] = smooth_minimum2(l, 1.0/(0.1*40.0)) self.ml_ratio[k] = self.mixing_length[k]/l[int(self.MLS[k])] - else: - with nogil: - for k in xrange(gw, self.Gr.nzg-gw): - l1 = tau * sqrt(fmax(self.EnvVar.TKE.values[k],0.0)) - z_ = self.Gr.z_c[k] - if obukhov_length < 0.0: #unstable - l2 = vkb * z_ * ( (1.0 - 100.0 * z_/obukhov_length)**0.2 ) - elif obukhov_length > 0.0: #stable - l2 = vkb * z_ / (1. + 2.7 *z_/obukhov_length) - else: - l2 = vkb * z_ - self.mixing_length[k] = fmax( 1.0/(1.0/fmax(l1,1e-10) + 1.0/l2), 1e-3) + elif self.mixing_scheme == 'tke': + with nogil: + for k in xrange(gw, self.Gr.nzg-gw): + l1 = tau * sqrt(fmax(self.EnvVar.TKE.values[k],0.0)) + z_ = self.Gr.z_c[k] + if obukhov_length < 0.0: #unstable + l2 = vkb * z_ * ( (1.0 - 100.0 * z_/obukhov_length)**0.2 ) + elif obukhov_length > 0.0: #stable + l2 = vkb * z_ / (1. + 2.7 *z_/obukhov_length) + else: + l2 = vkb * z_ + self.mixing_length[k] = fmax( 1.0/(1.0/fmax(l1,1e-10) + 1.0/l2), 1e-3) return @@ -954,7 +959,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.H.new[i,gw] = self.h_surface_bc[i] self.UpdVar.QT.new[i,gw] = self.qt_surface_bc[i] - # this is set here for BC at z=0 given the factor 2 in dzi below, but will be overwriteen when setting new to values self.UpdVar.W.new[i,gw-1] = 0.0 self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, gw, i, self.EnvVar.W.values[gw], 2.0 * dzi) From 29c03294667a9d069b53141106fdca86108d4fdd Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Mon, 1 Oct 2018 20:41:20 -0700 Subject: [PATCH 132/136] tests --- Turbulence_PrognosticTKE.pyx | 39 ++++++++++++++++++++++-------------- turbulence_functions.pyx | 23 ++++++++++++++------- utility_functions.pxd | 5 ++--- utility_functions.pyx | 32 ++++++++++++++++------------- 4 files changed, 60 insertions(+), 39 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index c62454de..fd01e800 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -103,16 +103,25 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.extrapolate_buoyancy = True print('Turbulence--EDMF_PrognosticTKE: defaulting to extrapolation of updraft buoyancy along a pseudoadiabat') + # try: + # if str(namelist['turbulence']['EDMF_PrognosticTKE']['mixing_length']) == 'SBL': + # self.mixing_scheme = 'SBL' + # elif str(namelist['turbulence']['EDMF_PrognosticTKE']['mixing_length']) == 'tke': + # self.mixing_scheme = 'tke' + # else: + # print('Turbulence--EDMF_PrognosticTKE: mixing scheme namelist option is not recognized') + # except: + # self.mixing_scheme = 'tke' + # print('Turbulence--EDMF_PrognosticTKE: defaulting to tke based mixing scheme') + try: - if str(namelist['turbulence']['EDMF_PrognosticTKE']['mixing_length']) == 'SBL': - self.mixing_scheme = 'SBL' - elif str(namelist['turbulence']['EDMF_PrognosticTKE']['mixing_length']) == 'tke': - self.mixing_scheme = 'tke' - else: - print('Turbulence--EDMF_PrognosticTKE: mixing scheme namelist option is not recognized') + self.mixing_scheme = namelist['turbulence']['EDMF_PrognosticTKE']['mixing_length'] except: - self.mixing_scheme = 'tke' - print('Turbulence--EDMF_PrognosticTKE: defaulting to tke based mixing scheme') + self.mixing_scheme = 'Default' + + print self.mixing_scheme, namelist['turbulence']['EDMF_PrognosticTKE']['mixing_length'] + plt.figure() + plt.show() # Get values from paramlist # set defaults at some point? @@ -625,7 +634,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # else: # prandtl = 1.6 pr_vec[0] = 1.6; pr_vec[1] = 0.6 + 1.0 * (ri_thl+ri_qt)/0.066 - prandtl = smooth_minimum2(pr_vec, 7.0) + prandtl = smooth_minimum(pr_vec, 7.0) l3 = sqrt(self.tke_diss_coeff/self.tke_ed_coeff) * sqrt(fmax(self.EnvVar.TKE.values[k],0.0))/fmax(sqrt(shear2), 1.0e-10) l3 /= sqrt(fmax(1.0 - ri_thl/prandtl - ri_qt/prandtl, 1e-7)) @@ -644,7 +653,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): l1 = 1.0e5 l2 = fmin(l2, 1000.0) l[0]=l2; l[1]=l1; l[2]=l3; l[3]=1.0e5; l[4]=1.0e5 - # self.mixing_length[k] = smooth_minimum2(l, 0.1*self.Gr.dz) # + # self.mixing_length[k] = smooth_minimum(l, 0.1*self.Gr.dz) # j = 0 while(j0.0: if entr_in.z >= entr_in.zi : @@ -68,13 +71,19 @@ cdef entr_struct entr_detr_smean(entr_in_struct entr_in) nogil: else: eps_w = 0.0 del_w = 0.0 - - eps_min = smooth_minimum(eps_w,eps_w, 1.0) # ,eps_z - eps_max = smooth_maximum(eps_w,eps_w,1.0) - del_min = smooth_minimum(del_w,del_w,1.0) # del_w+del_w/2, - del_max = smooth_maximum(del_w,del_w,1.0) - _ret.entr_sc = (eps_min + eps_max)/2.0 - _ret.detr_sc = (del_min + del_max)/2.0 + with gil: + + epsi = [eps_w , eps_b_w2] + delt = [del_w , del_b_w2] + + # eps_min = smooth_minimum(epsi, 1.0) + # eps_max = smooth_maximum(epsi,1.0) + # del_min = smooth_minimum(delt,1.0) + # del_max = smooth_maximum(delt,1.0) + # _ret.entr_sc = (eps_min + eps_max)/2.0 + # _ret.detr_sc = (del_min + del_max)/2.0 + _ret.entr_sc = 2.0 + _ret.detr_sc = 2.0 return _ret diff --git a/utility_functions.pxd b/utility_functions.pxd index 4dd2b1fb..e79d791c 100644 --- a/utility_functions.pxd +++ b/utility_functions.pxd @@ -1,7 +1,6 @@ cdef double interp2pt(double val1, double val2) nogil cdef double logistic(double x, double slope, double mid) nogil -cdef double smooth_minimum(double x1, double x2 , double a) nogil -cdef double smooth_maximum(double x1, double x2 , double a) nogil # double x3 , cpdef double percentile_mean_norm(double percentile, Py_ssize_t nsamples) cpdef double percentile_bounds_mean_norm(double low_percentile, double high_percentile, Py_ssize_t nsamples) -cdef double smooth_minimum2(double [:] x, double a) nogil \ No newline at end of file +cdef double smooth_minimum(double [:] x, double a) nogil +cdef double smooth_maximum(double [:] x, double a) nogil \ No newline at end of file diff --git a/utility_functions.pyx b/utility_functions.pyx index 226e943d..710424d1 100644 --- a/utility_functions.pyx +++ b/utility_functions.pyx @@ -28,23 +28,27 @@ cdef double interp2pt(double val1, double val2) nogil: cdef double logistic(double x, double slope, double mid) nogil: return 1.0/(1.0 + exp( -slope * (x-mid))) -# cdef double smooth_minimum(double x1, double x2,double x3, double x4,double x5, double a) nogil: -# smin = (x1*exp(-a*x1)+x2*exp(-a*x2)+x3*exp(-a*x3)+x4*exp(-a*x4)+x5*exp(-a*x5))\ -# / (exp(-a*x1)+exp(-a*x2)+exp(-a*x3)+exp(-a*x4)+exp(-a*x5)) -# return smin -cdef double smooth_minimum(double x1, double x2, double a) nogil: - smin = (x1*exp(-a*x1)+x2*exp(-a*x2))/fmax(exp(-a*x1)+exp(-a*x2),0.0) - #smin = (x1*exp(-a*x1)+x2*exp(-a*x2)+x3*exp(-a*x3))/fmax(exp(-a*x1)+exp(-a*x2)+exp(-a*x3),0.0) +@cython.boundscheck(False) +@cython.wraparound(False) +cdef double smooth_minimum(double [:] x, double a) nogil: + cdef: + unsigned int i = 0 + double num, den, leng + with gil: + leng = len(x) + num = 0; den = 0 + while(i1.0e-5): + num += x[i]*exp(-a*(x[i])) + den += exp(-a*(x[i])) + i += 1 + smin = num/den return smin -cdef double smooth_maximum(double x1, double x2, double a) nogil: - smax = (x1*exp(a*x1)+x2*exp(a*x2))/fmax(exp(a*x1)+exp(a*x2),1e-18) - #smax = (x1*exp(a*x1)+x2*exp(a*x2)+x3*exp(a*x3))/fmax(exp(a*x1)+exp(a*x2)+exp(a*x3),1e-18) - return smax @cython.boundscheck(False) @cython.wraparound(False) -cdef double smooth_minimum2(double [:] x, double a) nogil: +cdef double smooth_maximum(double [:] x, double a) nogil: cdef: unsigned int i = 0 double num, den, leng @@ -53,8 +57,8 @@ cdef double smooth_minimum2(double [:] x, double a) nogil: num = 0; den = 0 while(i1.0e-5): - num += x[i]*exp(-a*(x[i])) - den += exp(-a*(x[i])) + num += x[i]*exp(a*(x[i])) + den += exp(a*(x[i])) i += 1 smin = num/den return smin \ No newline at end of file From d827c6b05cc37b0ef70fa000fc354dd670743080 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Wed, 3 Oct 2018 13:24:05 -0700 Subject: [PATCH 133/136] cleanup --- EDMF_Updrafts.pyx | 7 +++++++ Turbulence_PrognosticTKE.pyx | 30 +++--------------------------- 2 files changed, 10 insertions(+), 27 deletions(-) diff --git a/EDMF_Updrafts.pyx b/EDMF_Updrafts.pyx index ab7f6a81..baae2ea4 100644 --- a/EDMF_Updrafts.pyx +++ b/EDMF_Updrafts.pyx @@ -227,6 +227,13 @@ cdef class UpdraftVariables: self.THL.values[i,k] = self.THL.new[i,k] self.T.values[i,k] = self.T.new[i,k] self.B.values[i,k] = self.B.new[i,k] + + self.H.set_bcs(self.Gr) + self.QT.set_bcs(self.Gr) + self.QR.set_bcs(self.Gr) + self.W.set_bcs(self.Gr) + self.Area.set_bcs(self.Gr) + return diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index fd01e800..6cb4d59a 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -103,25 +103,11 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.extrapolate_buoyancy = True print('Turbulence--EDMF_PrognosticTKE: defaulting to extrapolation of updraft buoyancy along a pseudoadiabat') - # try: - # if str(namelist['turbulence']['EDMF_PrognosticTKE']['mixing_length']) == 'SBL': - # self.mixing_scheme = 'SBL' - # elif str(namelist['turbulence']['EDMF_PrognosticTKE']['mixing_length']) == 'tke': - # self.mixing_scheme = 'tke' - # else: - # print('Turbulence--EDMF_PrognosticTKE: mixing scheme namelist option is not recognized') - # except: - # self.mixing_scheme = 'tke' - # print('Turbulence--EDMF_PrognosticTKE: defaulting to tke based mixing scheme') - try: - self.mixing_scheme = namelist['turbulence']['EDMF_PrognosticTKE']['mixing_length'] + self.mixing_scheme = str(namelist['turbulence']['EDMF_PrognosticTKE']['mixing_length']) except: self.mixing_scheme = 'Default' - print self.mixing_scheme, namelist['turbulence']['EDMF_PrognosticTKE']['mixing_length'] - plt.figure() - plt.show() # Get values from paramlist # set defaults at some point? @@ -571,7 +557,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): if self.mixing_scheme == 'SBL': - print 'Shear mixing length and Von Karman scaling' g = 9.81 for k in xrange(gw, self.Gr.nzg-gw): z_ = self.Gr.z_c[k] @@ -957,8 +942,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double dzi = self.Gr.dzi double dti_ = 1.0/self.dt_upd double dt_ = 1.0/dti_ - double a1, a2 # groupings of terms in area fraction discrete equation - double adv, buoy, exch, press, press_buoy, press_drag , entr_w, detr_w , B_k, a_k# groupings of terms in velocity discrete equation + #double a1, a2 # groupings of terms in area fraction discrete equation eos_struct sa for i in xrange(self.n_updrafts): @@ -968,9 +952,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.H.new[i,gw] = self.h_surface_bc[i] self.UpdVar.QT.new[i,gw] = self.qt_surface_bc[i] - # this is set here for BC at z=0 given the factor 2 in dzi below, but will be overwriteen when setting new to values - self.UpdVar.W.new[i,gw-1] = 0.0 - self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, gw, i, self.EnvVar.W.values[gw], 2.0 * dzi) + self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, gw, i, self.EnvVar.W.values[gw], dzi) sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_c[gw], self.UpdVar.QT.new[i,gw], self.UpdVar.H.new[i,gw]) @@ -1019,12 +1001,6 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): # Update updraft variables with microphysical source tendencies self.UpdMicro.update_updraftvars(self.UpdVar) - self.UpdVar.H.set_bcs(self.Gr) - self.UpdVar.QT.set_bcs(self.Gr) - self.UpdVar.QR.set_bcs(self.Gr) - self.UpdVar.W.set_bcs(self.Gr) - self.UpdVar.Area.set_bcs(self.Gr) - return cpdef upwind_integration(self, EDMF_Updrafts.UpdraftVariable area, EDMF_Updrafts.UpdraftVariable var, int k, int i, double env_var, double dzi): From 70a1f6a9684c12bda458354a0563677f9b1c8d36 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Wed, 3 Oct 2018 15:18:25 -0700 Subject: [PATCH 134/136] .. --- Turbulence_PrognosticTKE.pyx | 37 ++++++++++++++++++++++++++++++++---- 1 file changed, 33 insertions(+), 4 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 6cb4d59a..8531d136 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -106,7 +106,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): try: self.mixing_scheme = str(namelist['turbulence']['EDMF_PrognosticTKE']['mixing_length']) except: - self.mixing_scheme = 'Default' + self.mixing_scheme = 'tke' # Get values from paramlist @@ -659,7 +659,8 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.mixing_length[k] = smooth_minimum(l, 1.0/(0.1*40.0)) self.ml_ratio[k] = self.mixing_length[k]/l[int(self.MLS[k])] - elif self.mixing_scheme == 'tke': + #elif self.mixing_scheme == 'tke': + else: with nogil: for k in xrange(gw, self.Gr.nzg-gw): l1 = tau * sqrt(fmax(self.EnvVar.TKE.values[k],0.0)) @@ -942,7 +943,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): double dzi = self.Gr.dzi double dti_ = 1.0/self.dt_upd double dt_ = 1.0/dti_ - #double a1, a2 # groupings of terms in area fraction discrete equation + double wtemp eos_struct sa for i in xrange(self.n_updrafts): @@ -952,7 +953,35 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.H.new[i,gw] = self.h_surface_bc[i] self.UpdVar.QT.new[i,gw] = self.qt_surface_bc[i] - self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, gw, i, self.EnvVar.W.values[gw], dzi) + #self.UpdVar.W.values[i,gw-1] = 0.0 + #self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, gw, i, self.EnvVar.W.values[gw], dzi*2.0) + + #wtemp = self.UpdVar.W.new[i,gw] + + a_k = self.UpdVar.Area.values[i,gw] + entr_w = self.entr_sc[i,gw] + detr_w = self.detr_sc[i,gw] + B_k = self.UpdVar.B.values[i,gw] + adv = self.Ref.rho0_c[gw] * a_k * self.UpdVar.W.values[i,gw] * self.UpdVar.W.values[i,gw] * dzi *2.0 + exch = (self.Ref.rho0_c[gw] * a_k * self.UpdVar.W.values[i,gw] + * (entr_w * self.EnvVar.W.values[gw] - detr_w * self.UpdVar.W.values[i,gw] )) + buoy= self.Ref.rho0_c[gw] * a_k * B_k + press_buoy = -1.0 * self.Ref.rho0_c[gw] * a_k * B_k * self.pressure_buoy_coeff + press_drag = -1.0 * self.Ref.rho0_c[gw] * sqrt(a_k) * (self.pressure_drag_coeff/self.pressure_plume_spacing + * fabs(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])*(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])) + press = press_buoy + press_drag + self.updraft_pressure_sink[i,gw] = press + self.UpdVar.W.new[i,gw] = (self.Ref.rho0_c[gw] * a_k * self.UpdVar.W.values[i,gw] * dti_ + -adv + exch + buoy + press)/(self.Ref.rho0_c[gw] * self.UpdVar.Area.values[i,gw] * dti_) + #self.UpdVar.W.values[i,gw] = self.UpdVar.W.new[i,gw] + #print wtemp - self.UpdVar.W.new[i,gw] + #if fabs(wtemp - self.UpdVar.W.new[i,gw])>0.0: + # print wtemp-self.UpdVar.W.values[i,gw] + #plt.figure() + #plt.show() + + # self.UpdVar.W.new[i,gw-1] = 0.0 + # self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, gw, i, self.EnvVar.W.values[gw], dzi*2.0) sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_c[gw], self.UpdVar.QT.new[i,gw], self.UpdVar.H.new[i,gw]) From 2155a779d1b604e05e76db1d2efb7fa82801f410 Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Wed, 3 Oct 2018 17:57:17 -0700 Subject: [PATCH 135/136] fixing issues with the sign of w[gw-1] --- EDMF_Updrafts.pyx | 17 ++++++++++---- Turbulence_PrognosticTKE.pyx | 34 +++------------------------- Variables.pyx | 44 +++++++++++++++++++++++++++--------- 3 files changed, 49 insertions(+), 46 deletions(-) diff --git a/EDMF_Updrafts.pyx b/EDMF_Updrafts.pyx index baae2ea4..44d77f52 100644 --- a/EDMF_Updrafts.pyx +++ b/EDMF_Updrafts.pyx @@ -43,10 +43,17 @@ cdef class UpdraftVariable: n_updrafts = np.shape(self.values)[0] - for k in xrange(Gr.gw): - for i in xrange(n_updrafts): - self.values[i,start_high + k +1] = self.values[i,start_high - k] - self.values[i,start_low - k] = self.values[i,start_low + 1 + k] + if self.name == 'w': + for k in xrange(Gr.gw): + for i in xrange(n_updrafts): + self.values[i,start_high + k +1] = -self.values[i,start_high - k] + self.values[i,start_low - k] = -self.values[i,start_low + 1 + k] + else: + for k in xrange(Gr.gw): + for i in xrange(n_updrafts): + self.values[i,start_high + k +1] = self.values[i,start_high - k] + self.values[i,start_low - k] = self.values[i,start_low + 1 + k] + return @@ -122,6 +129,8 @@ cdef class UpdraftVariables: self.QT.set_bcs(self.Gr) self.QR.set_bcs(self.Gr) self.H.set_bcs(self.Gr) + self.W.set_bcs(self.Gr) + self.Area.set_bcs(self.Gr) return diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index 8531d136..a04ffc59 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -953,35 +953,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.H.new[i,gw] = self.h_surface_bc[i] self.UpdVar.QT.new[i,gw] = self.qt_surface_bc[i] - #self.UpdVar.W.values[i,gw-1] = 0.0 - #self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, gw, i, self.EnvVar.W.values[gw], dzi*2.0) - - #wtemp = self.UpdVar.W.new[i,gw] - - a_k = self.UpdVar.Area.values[i,gw] - entr_w = self.entr_sc[i,gw] - detr_w = self.detr_sc[i,gw] - B_k = self.UpdVar.B.values[i,gw] - adv = self.Ref.rho0_c[gw] * a_k * self.UpdVar.W.values[i,gw] * self.UpdVar.W.values[i,gw] * dzi *2.0 - exch = (self.Ref.rho0_c[gw] * a_k * self.UpdVar.W.values[i,gw] - * (entr_w * self.EnvVar.W.values[gw] - detr_w * self.UpdVar.W.values[i,gw] )) - buoy= self.Ref.rho0_c[gw] * a_k * B_k - press_buoy = -1.0 * self.Ref.rho0_c[gw] * a_k * B_k * self.pressure_buoy_coeff - press_drag = -1.0 * self.Ref.rho0_c[gw] * sqrt(a_k) * (self.pressure_drag_coeff/self.pressure_plume_spacing - * fabs(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])*(self.UpdVar.W.values[i,gw] -self.EnvVar.W.values[gw])) - press = press_buoy + press_drag - self.updraft_pressure_sink[i,gw] = press - self.UpdVar.W.new[i,gw] = (self.Ref.rho0_c[gw] * a_k * self.UpdVar.W.values[i,gw] * dti_ - -adv + exch + buoy + press)/(self.Ref.rho0_c[gw] * self.UpdVar.Area.values[i,gw] * dti_) - #self.UpdVar.W.values[i,gw] = self.UpdVar.W.new[i,gw] - #print wtemp - self.UpdVar.W.new[i,gw] - #if fabs(wtemp - self.UpdVar.W.new[i,gw])>0.0: - # print wtemp-self.UpdVar.W.values[i,gw] - #plt.figure() - #plt.show() - - # self.UpdVar.W.new[i,gw-1] = 0.0 - # self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, gw, i, self.EnvVar.W.values[gw], dzi*2.0) + self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, gw, i, self.EnvVar.W.values[gw], dzi) sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_c[gw], self.UpdVar.QT.new[i,gw], self.UpdVar.H.new[i,gw]) @@ -1121,7 +1093,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): with nogil: for i in xrange(self.n_updrafts): self.m[i,gw-1] = 0.0 - for k in xrange(self.Gr.gw, self.Gr.nzg): # Yair did removing -1 here had any effect ? + for k in xrange(self.Gr.gw, self.Gr.nzg-1): dw_kp = (self.UpdVar.W.values[i,k+1] - self.EnvVar.W.values[k+1] ) dw_k = (self.UpdVar.W.values[i,k] - self.EnvVar.W.values[k] ) self.m[i,k] = interp2pt(dw_kp,dw_k)*self.Ref.rho0_f[k]*interp2pt(self.UpdVar.Area.values[i,k+1],self.UpdVar.Area.values[i,k]) @@ -1129,7 +1101,7 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.massflux_h[gw-1] = 0.0 self.massflux_qt[gw-1] = 0.0 with nogil: - for k in xrange(gw, self.Gr.nzg-gw): + for k in xrange(gw, self.Gr.nzg-gw-1): self.massflux_h[k] = 0.0 self.massflux_qt[k] = 0.0 env_h_interp = interp2pt(self.EnvVar.H.values[k], self.EnvVar.H.values[k+1]) diff --git a/Variables.pyx b/Variables.pyx index 1465ce5c..e3c79c15 100644 --- a/Variables.pyx +++ b/Variables.pyx @@ -50,15 +50,30 @@ cdef class VariablePrognostic: Py_ssize_t start_low = Gr.gw - 1 Py_ssize_t start_high = Gr.nzg - Gr.gw - 1 - for k in xrange(Gr.gw): - self.values[start_high + k +1] = self.values[start_high - k] - self.values[start_low - k] = self.values[start_low + 1 + k] + if self.bc == 'sym': + for k in xrange(Gr.gw): + self.values[start_high + k +1] = self.values[start_high - k] + self.values[start_low - k] = self.values[start_low + 1 + k] - self.mf_update[start_high + k +1] = self.mf_update[start_high - k] - self.mf_update[start_low - k] = self.mf_update[start_low + 1 + k] + self.mf_update[start_high + k +1] = self.mf_update[start_high - k] + self.mf_update[start_low - k] = self.mf_update[start_low + 1 + k] + + self.new[start_high + k +1] = self.new[start_high - k] + self.new[start_low - k] = self.new[start_low + 1 + k] + + + + else: + for k in xrange(Gr.gw): + self.values[start_high + k +1] = -self.values[start_high - k] + self.values[start_low - k] = -self.values[start_low + 1 + k] + + self.mf_update[start_high + k +1] = -self.mf_update[start_high - k] + self.mf_update[start_low - k] = -self.mf_update[start_low + 1 + k] + + self.new[start_high + k +1] = -self.new[start_high - k] + self.new[start_low - k] = -self.new[start_low + 1 + k] - self.new[start_high + k +1] = self.new[start_high - k] - self.new[start_low - k] = self.new[start_low + 1 + k] return @@ -86,11 +101,17 @@ cdef class VariableDiagnostic: - for k in xrange(Gr.gw): - self.values[start_high + k] = self.values[start_high - 1] - self.values[start_low - k] = self.values[start_low + 1] + if self.bc == 'sym': + for k in xrange(Gr.gw): + self.values[start_high + k] = self.values[start_high - 1] + self.values[start_low - k] = self.values[start_low + 1] + else: + for k in xrange(1,Gr.gw): + self.values[start_high+ k] = -self.values[start_high - k ] + self.values[start_low- k] = -self.values[start_low + k ] + return @@ -103,7 +124,7 @@ cdef class GridMeanVariables: self.U = VariablePrognostic(Gr.nzg, 'half', 'velocity', 'sym','u', 'm/s' ) self.V = VariablePrognostic(Gr.nzg, 'half', 'velocity','sym', 'v', 'm/s' ) # Just leave this zero for now! - self.W = VariablePrognostic(Gr.nzg, 'half', 'velocity','sym', 'v', 'm/s' ) + self.W = VariablePrognostic(Gr.nzg, 'half', 'velocity','asym', 'v', 'm/s' ) # Create thermodynamic variables self.QT = VariablePrognostic(Gr.nzg, 'half', 'scalar','sym', 'qt', 'kg/kg') @@ -190,6 +211,7 @@ cdef class GridMeanVariables: self.H.set_bcs(self.Gr) self.QT.set_bcs(self.Gr) self.QR.set_bcs(self.Gr) + self.W.set_bcs(self.Gr) if self.calc_tke: self.TKE.set_bcs(self.Gr) From e92db56203301f54c800801ca4d9a3054b600b8b Mon Sep 17 00:00:00 2001 From: Yair Cohen Date: Thu, 4 Oct 2018 09:35:41 -0700 Subject: [PATCH 136/136] .. --- Turbulence_PrognosticTKE.pyx | 20 +++++++++++--------- 1 file changed, 11 insertions(+), 9 deletions(-) diff --git a/Turbulence_PrognosticTKE.pyx b/Turbulence_PrognosticTKE.pyx index a04ffc59..28158002 100644 --- a/Turbulence_PrognosticTKE.pyx +++ b/Turbulence_PrognosticTKE.pyx @@ -954,6 +954,10 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): self.UpdVar.QT.new[i,gw] = self.qt_surface_bc[i] self.upwind_integration(self.UpdVar.Area, self.UpdVar.W, gw, i, self.EnvVar.W.values[gw], dzi) + if self.UpdVar.W.new[i,gw]<=0.0: + print self.UpdVar.W.new[i,gw], self.UpdVar.B.values[i,gw] + plt.figure() + plt.show() sa = eos(self.UpdThermo.t_to_prog_fp,self.UpdThermo.prog_to_t_fp, self.Ref.p0_c[gw], self.UpdVar.QT.new[i,gw], self.UpdVar.H.new[i,gw]) @@ -1047,15 +1051,13 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): sgn_w = -1.0 adv = (self.Ref.rho0_c[k+1] * area.values[i,k+1] * self.UpdVar.W.values[i,k+1] * var_kp - self.Ref.rho0_c[k] *area.values[i,k] * self.UpdVar.W.values[i,k] * var_k )* dzi - exch = (self.Ref.rho0_c[k] * area.values[i,k] * self.UpdVar.W.values[i,k] - * (-self.entr_sc[i,k] * env_var + self.detr_sc[i,k] * var_k )) else: sgn_w = 1.0 adv = (self.Ref.rho0_c[k] * area.values[i,k] * self.UpdVar.W.values[i,k] * var_k - self.Ref.rho0_c[k-1] * area.values[i,k-1] * self.UpdVar.W.values[i,k-1] * var_km)* dzi - exch = (self.Ref.rho0_c[k] * area.values[i,k] * self.UpdVar.W.values[i,k] - * (self.entr_sc[i,k] * env_var - self.detr_sc[i,k] * var_k )) + exch = sgn_w*(self.Ref.rho0_c[k] * area.values[i,k] * self.UpdVar.W.values[i,k] + * (self.entr_sc[i,k] * env_var - self.detr_sc[i,k] * var_k )) var.new[i,k] = (self.Ref.rho0_c[k] * area.values[i,k] * var_k * dti_ -adv + exch + buoy + press)\ /(self.Ref.rho0_c[k] * area_new * dti_) @@ -1064,12 +1066,12 @@ cdef class EDMF_PrognosticTKE(ParameterizationBase): var.new[i,k] = fmax(var.new[i,k] , 0.0) entr_term = sgn_w *self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k] * self.entr_sc[i,k] - if self.UpdVar.Area.new[i,k] > au_lim: - self.UpdVar.Area.new[i,k] = au_lim - if self.UpdVar.Area.values[i,k] > 0.0: - self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ +self.Ref.alpha0_c[k] * adv - entr_term)/(-self.UpdVar.Area.values[i,k] * self.UpdVar.W.values[i,k])) + if var.new[i,k] > au_lim: + var.new[i,k] = au_lim + if var.values[i,k] > 0.0: + self.detr_sc[i,k] = (((au_lim-var.values[i,k])* dti_ +self.Ref.alpha0_c[k] * adv - entr_term)/(-var.values[i,k] * self.UpdVar.W.values[i,k])) else: - self.detr_sc[i,k] = (((au_lim-self.UpdVar.Area.values[i,k])* dti_ +self.Ref.alpha0_c[k] * adv - entr_term)/(-au_lim * self.UpdVar.W.values[i,k])) + self.detr_sc[i,k] = (((au_lim-var.values[i,k])* dti_ +self.Ref.alpha0_c[k] * adv - entr_term)/(-au_lim * self.UpdVar.W.values[i,k])) # uncomment this for clipping and avoiding downward integration # if var.name == 'w':