turbulence.h

Go to the documentation of this file.

/** @file turbulence.h
 */
// Generated automatically by gotm.awk from
// /home/popinet/local/src/code-5.2.1//src/turbulence/turbulence.F90
extern realtype_1d __turbulence_MOD_tke;
#define turbulence_tke __turbulence_MOD_tke
extern realtype_1d __turbulence_MOD_eps;
#define turbulence_eps __turbulence_MOD_eps
extern realtype_1d __turbulence_MOD_l;
#define turbulence_l __turbulence_MOD_l
extern realtype_1d __turbulence_MOD_tkeo;
#define turbulence_tkeo __turbulence_MOD_tkeo
extern realtype_1d __turbulence_MOD_kb;
#define turbulence_kb __turbulence_MOD_kb
extern realtype_1d __turbulence_MOD_epsb;
#define turbulence_epsb __turbulence_MOD_epsb
extern realtype_1d __turbulence_MOD_p;
#define turbulence_p __turbulence_MOD_p
extern realtype_1d __turbulence_MOD_b;
#define turbulence_b __turbulence_MOD_b
extern realtype_1d __turbulence_MOD_pb;
#define turbulence_pb __turbulence_MOD_pb
extern realtype_1d __turbulence_MOD_num;
#define turbulence_num __turbulence_MOD_num
extern realtype_1d __turbulence_MOD_nuh;
#define turbulence_nuh __turbulence_MOD_nuh
extern realtype_1d __turbulence_MOD_nus;
#define turbulence_nus __turbulence_MOD_nus
extern realtype_1d __turbulence_MOD_gamu;
#define turbulence_gamu __turbulence_MOD_gamu
extern realtype_1d __turbulence_MOD_gamv;
#define turbulence_gamv __turbulence_MOD_gamv
extern realtype_1d __turbulence_MOD_gamb;
#define turbulence_gamb __turbulence_MOD_gamb
extern realtype_1d __turbulence_MOD_gamh;
#define turbulence_gamh __turbulence_MOD_gamh
extern realtype_1d __turbulence_MOD_gams;
#define turbulence_gams __turbulence_MOD_gams
extern realtype_1d __turbulence_MOD_cmue1;
#define turbulence_cmue1 __turbulence_MOD_cmue1
extern realtype_1d __turbulence_MOD_cmue2;
#define turbulence_cmue2 __turbulence_MOD_cmue2
extern realtype_1d __turbulence_MOD_gam;
#define turbulence_gam __turbulence_MOD_gam
extern realtype_1d __turbulence_MOD_as;
#define turbulence_as __turbulence_MOD_as
extern realtype_1d __turbulence_MOD_an;
#define turbulence_an __turbulence_MOD_an
extern realtype_1d __turbulence_MOD_at;
#define turbulence_at __turbulence_MOD_at
extern realtype_1d __turbulence_MOD_r;
#define turbulence_r __turbulence_MOD_r
extern realtype_1d __turbulence_MOD_rig;
#define turbulence_rig __turbulence_MOD_rig
extern realtype_1d __turbulence_MOD_xrf;
#define turbulence_xrf __turbulence_MOD_xrf
extern realtype_1d __turbulence_MOD_uu;
#define turbulence_uu __turbulence_MOD_uu
extern realtype_1d __turbulence_MOD_vv;
#define turbulence_vv __turbulence_MOD_vv
extern realtype_1d __turbulence_MOD_ww;
#define turbulence_ww __turbulence_MOD_ww
extern realtype_1d __turbulence_MOD_turb1;
#define turbulence_turb1 __turbulence_MOD_turb1
extern realtype_1d __turbulence_MOD_turb2;
#define turbulence_turb2 __turbulence_MOD_turb2
extern realtype_1d __turbulence_MOD_turb3;
#define turbulence_turb3 __turbulence_MOD_turb3
extern realtype_1d __turbulence_MOD_turb4;
#define turbulence_turb4 __turbulence_MOD_turb4
extern realtype_1d __turbulence_MOD_turb5;
#define turbulence_turb5 __turbulence_MOD_turb5
extern realtype __turbulence_MOD_cm0;
#define turbulence_cm0 __turbulence_MOD_cm0
extern realtype __turbulence_MOD_cmsf;
#define turbulence_cmsf __turbulence_MOD_cmsf
extern realtype __turbulence_MOD_cde;
#define turbulence_cde __turbulence_MOD_cde
extern realtype __turbulence_MOD_rcm;
#define turbulence_rcm __turbulence_MOD_rcm
extern realtype __turbulence_MOD_b1;
#define turbulence_b1 __turbulence_MOD_b1
extern realtype __turbulence_MOD_prandtl0;
#define turbulence_prandtl0 __turbulence_MOD_prandtl0
extern realtype __turbulence_MOD_craig_m;
#define turbulence_craig_m __turbulence_MOD_craig_m
extern realtype __turbulence_MOD_sig_e0;
#define turbulence_sig_e0 __turbulence_MOD_sig_e0
extern integer __turbulence_MOD_turb_method;
#define turbulence_turb_method __turbulence_MOD_turb_method
extern integer __turbulence_MOD_tke_method;
#define turbulence_tke_method __turbulence_MOD_tke_method
extern integer __turbulence_MOD_len_scale_method;
#define turbulence_len_scale_method __turbulence_MOD_len_scale_method
extern integer __turbulence_MOD_stab_method;
#define turbulence_stab_method __turbulence_MOD_stab_method
extern integer __turbulence_MOD_k_ubc;
#define turbulence_k_ubc __turbulence_MOD_k_ubc
extern integer __turbulence_MOD_k_lbc;
#define turbulence_k_lbc __turbulence_MOD_k_lbc
extern integer __turbulence_MOD_kb_ubc;
#define turbulence_kb_ubc __turbulence_MOD_kb_ubc
extern integer __turbulence_MOD_kb_lbc;
#define turbulence_kb_lbc __turbulence_MOD_kb_lbc
extern integer __turbulence_MOD_psi_ubc;
#define turbulence_psi_ubc __turbulence_MOD_psi_ubc
extern integer __turbulence_MOD_psi_lbc;
#define turbulence_psi_lbc __turbulence_MOD_psi_lbc
extern integer __turbulence_MOD_ubc_type;
#define turbulence_ubc_type __turbulence_MOD_ubc_type
extern integer __turbulence_MOD_lbc_type;
#define turbulence_lbc_type __turbulence_MOD_lbc_type
extern realtype __turbulence_MOD_cm0_fix;
#define turbulence_cm0_fix __turbulence_MOD_cm0_fix
extern realtype __turbulence_MOD_prandtl0_fix;
#define turbulence_prandtl0_fix __turbulence_MOD_prandtl0_fix
extern realtype __turbulence_MOD_cw;
#define turbulence_cw __turbulence_MOD_cw
extern logical __turbulence_MOD_compute_kappa;
#define turbulence_compute_kappa __turbulence_MOD_compute_kappa
extern realtype __turbulence_MOD_kappa;
#define turbulence_kappa __turbulence_MOD_kappa
extern logical __turbulence_MOD_compute_c3;
#define turbulence_compute_c3 __turbulence_MOD_compute_c3
extern realtype __turbulence_MOD_ri_st;
#define turbulence_ri_st __turbulence_MOD_ri_st
extern logical __turbulence_MOD_length_lim;
#define turbulence_length_lim __turbulence_MOD_length_lim
extern realtype __turbulence_MOD_galp;
#define turbulence_galp __turbulence_MOD_galp
extern realtype __turbulence_MOD_const_num;
#define turbulence_const_num __turbulence_MOD_const_num
extern realtype __turbulence_MOD_const_nuh;
#define turbulence_const_nuh __turbulence_MOD_const_nuh
extern realtype __turbulence_MOD_k_min;
#define turbulence_k_min __turbulence_MOD_k_min
extern realtype __turbulence_MOD_eps_min;
#define turbulence_eps_min __turbulence_MOD_eps_min
extern realtype __turbulence_MOD_kb_min;
#define turbulence_kb_min __turbulence_MOD_kb_min
extern realtype __turbulence_MOD_epsb_min;
#define turbulence_epsb_min __turbulence_MOD_epsb_min
extern logical __turbulence_MOD_compute_param;
#define turbulence_compute_param __turbulence_MOD_compute_param
extern realtype __turbulence_MOD_gen_m;
#define turbulence_gen_m __turbulence_MOD_gen_m
extern realtype __turbulence_MOD_gen_n;
#define turbulence_gen_n __turbulence_MOD_gen_n
extern realtype __turbulence_MOD_gen_p;
#define turbulence_gen_p __turbulence_MOD_gen_p
extern realtype __turbulence_MOD_cpsi1;
#define turbulence_cpsi1 __turbulence_MOD_cpsi1
extern realtype __turbulence_MOD_cpsi2;
#define turbulence_cpsi2 __turbulence_MOD_cpsi2
extern realtype __turbulence_MOD_cpsi3minus;
#define turbulence_cpsi3minus __turbulence_MOD_cpsi3minus
extern realtype __turbulence_MOD_cpsi3plus;
#define turbulence_cpsi3plus __turbulence_MOD_cpsi3plus
extern realtype __turbulence_MOD_sig_kpsi;
#define turbulence_sig_kpsi __turbulence_MOD_sig_kpsi
extern realtype __turbulence_MOD_sig_psi;
#define turbulence_sig_psi __turbulence_MOD_sig_psi
extern realtype __turbulence_MOD_gen_d;
#define turbulence_gen_d __turbulence_MOD_gen_d
extern realtype __turbulence_MOD_gen_alpha;
#define turbulence_gen_alpha __turbulence_MOD_gen_alpha
extern realtype __turbulence_MOD_gen_l;
#define turbulence_gen_l __turbulence_MOD_gen_l
extern realtype __turbulence_MOD_ce1;
#define turbulence_ce1 __turbulence_MOD_ce1
extern realtype __turbulence_MOD_ce2;
#define turbulence_ce2 __turbulence_MOD_ce2
extern realtype __turbulence_MOD_ce3minus;
#define turbulence_ce3minus __turbulence_MOD_ce3minus
extern realtype __turbulence_MOD_ce3plus;
#define turbulence_ce3plus __turbulence_MOD_ce3plus
extern realtype __turbulence_MOD_sig_k;
#define turbulence_sig_k __turbulence_MOD_sig_k
extern realtype __turbulence_MOD_sig_e;
#define turbulence_sig_e __turbulence_MOD_sig_e
extern logical __turbulence_MOD_sig_peps;
#define turbulence_sig_peps __turbulence_MOD_sig_peps
extern realtype __turbulence_MOD_e1;
#define turbulence_e1 __turbulence_MOD_e1
extern realtype __turbulence_MOD_e2;
#define turbulence_e2 __turbulence_MOD_e2
extern realtype __turbulence_MOD_e3;
#define turbulence_e3 __turbulence_MOD_e3
extern realtype __turbulence_MOD_sq;
#define turbulence_sq __turbulence_MOD_sq
extern realtype __turbulence_MOD_sl;
#define turbulence_sl __turbulence_MOD_sl
extern integer __turbulence_MOD_my_length;
#define turbulence_my_length __turbulence_MOD_my_length
extern logical __turbulence_MOD_new_constr;
#define turbulence_new_constr __turbulence_MOD_new_constr
extern integer __turbulence_MOD_scnd_method;
#define turbulence_scnd_method __turbulence_MOD_scnd_method
extern integer __turbulence_MOD_kb_method;
#define turbulence_kb_method __turbulence_MOD_kb_method
extern integer __turbulence_MOD_epsb_method;
#define turbulence_epsb_method __turbulence_MOD_epsb_method
extern integer __turbulence_MOD_scnd_coeff;
#define turbulence_scnd_coeff __turbulence_MOD_scnd_coeff
extern realtype __turbulence_MOD_cc1;
#define turbulence_cc1 __turbulence_MOD_cc1
extern realtype __turbulence_MOD_ct1;
#define turbulence_ct1 __turbulence_MOD_ct1
extern realtype __turbulence_MOD_ctt;
#define turbulence_ctt __turbulence_MOD_ctt
extern realtype __turbulence_MOD_cc2;
#define turbulence_cc2 __turbulence_MOD_cc2
extern realtype __turbulence_MOD_cc3;
#define turbulence_cc3 __turbulence_MOD_cc3
extern realtype __turbulence_MOD_cc4;
#define turbulence_cc4 __turbulence_MOD_cc4
extern realtype __turbulence_MOD_cc5;
#define turbulence_cc5 __turbulence_MOD_cc5
extern realtype __turbulence_MOD_cc6;
#define turbulence_cc6 __turbulence_MOD_cc6
extern realtype __turbulence_MOD_ct2;
#define turbulence_ct2 __turbulence_MOD_ct2
extern realtype __turbulence_MOD_ct3;
#define turbulence_ct3 __turbulence_MOD_ct3
extern realtype __turbulence_MOD_ct4;
#define turbulence_ct4 __turbulence_MOD_ct4
extern realtype __turbulence_MOD_ct5;
#define turbulence_ct5 __turbulence_MOD_ct5
extern realtype __turbulence_MOD_a1;
#define turbulence_a1 __turbulence_MOD_a1
extern realtype __turbulence_MOD_a2;
#define turbulence_a2 __turbulence_MOD_a2
extern realtype __turbulence_MOD_a3;
#define turbulence_a3 __turbulence_MOD_a3
extern realtype __turbulence_MOD_a4;
#define turbulence_a4 __turbulence_MOD_a4
extern realtype __turbulence_MOD_a5;
#define turbulence_a5 __turbulence_MOD_a5
extern realtype __turbulence_MOD_at1;
#define turbulence_at1 __turbulence_MOD_at1
extern realtype __turbulence_MOD_at2;
#define turbulence_at2 __turbulence_MOD_at2
extern realtype __turbulence_MOD_at3;
#define turbulence_at3 __turbulence_MOD_at3
extern realtype __turbulence_MOD_at4;
#define turbulence_at4 __turbulence_MOD_at4
extern realtype __turbulence_MOD_at5;
#define turbulence_at5 __turbulence_MOD_at5
extern integer __turbulence_MOD_iw_model;
#define turbulence_iw_model __turbulence_MOD_iw_model
extern realtype __turbulence_MOD_alpha;
#define turbulence_alpha __turbulence_MOD_alpha
extern realtype __turbulence_MOD_klimiw;
#define turbulence_klimiw __turbulence_MOD_klimiw
extern realtype __turbulence_MOD_rich_cr;
#define turbulence_rich_cr __turbulence_MOD_rich_cr
extern realtype __turbulence_MOD_numiw;
#define turbulence_numiw __turbulence_MOD_numiw
extern realtype __turbulence_MOD_nuhiw;
#define turbulence_nuhiw __turbulence_MOD_nuhiw
extern realtype __turbulence_MOD_numshear;
#define turbulence_numshear __turbulence_MOD_numshear
static const integer turbulence_convective = 0;
static const integer turbulence_algebraic = 1;
static const integer turbulence_first_order = 2;
static const integer turbulence_second_order = 3;
static const integer turbulence_tke_local_eq = 1;
static const integer turbulence_tke_keps = 2;
static const integer turbulence_tke_my = 3;
static const integer turbulence_constant = 1;
static const integer turbulence_munkanderson = 2;
static const integer turbulence_schumgerz = 3;
static const integer turbulence_eiflerschrimpf = 4;
static const integer turbulence_diss_eq = 8;
static const integer turbulence_length_eq = 9;
static const integer turbulence_generic_eq = 10;
static const integer turbulence_dirichlet = 0;
static const integer turbulence_neumann = 1;
static const integer turbulence_viscous = 0;
static const integer turbulence_logarithmic = 1;
static const integer turbulence_injection = 2;
 
extern void __turbulence_MOD_init_turbulence (
  integer * namlst,
  char * fn,
  integer * nlev,
  long int _slfn
);
static inline void turbulence_init_turbulence (
  integer * namlst,
  char * fn,
  integer * nlev) {
  __turbulence_MOD_init_turbulence (namlst, fn, nlev, strlencheck(fn));
}
 
extern void __turbulence_MOD_post_init_turbulence (
  integer * nlev
);
static inline void turbulence_post_init_turbulence (
  integer * nlev) {
  __turbulence_MOD_post_init_turbulence (nlev);
}
 
extern void __turbulence_MOD_init_scnd (
  integer * scnd_coeff
);
static inline void turbulence_init_scnd (
  integer * scnd_coeff) {
  __turbulence_MOD_init_scnd (scnd_coeff);
}
 
extern void __turbulence_MOD_generate_model (
 
);
static inline void turbulence_generate_model (void) {
  __turbulence_MOD_generate_model();
}
 
extern void __turbulence_MOD_analyse_model (
 
);
static inline void turbulence_analyse_model (void) {
  __turbulence_MOD_analyse_model();
}
 
extern void __turbulence_MOD_report_model (
 
);
static inline void turbulence_report_model (void) {
  __turbulence_MOD_report_model();
}
 
extern void __turbulence_MOD_do_turbulence (
  integer * nlev,
  realtype * dt,
  realtype * depth,
  realtype * u_taus,
  realtype * u_taub,
  realtype * z0s,
  realtype * z0b,
  realtype * h,
  realtype * nn,
  realtype * ss,
  realtype * xp
);
static inline void turbulence_do_turbulence (
  integer * nlev,
  realtype * dt,
  realtype * depth,
  realtype * u_taus,
  realtype * u_taub,
  realtype * z0s,
  realtype * z0b,
  realtype * h,
  realtype * nn,
  realtype * ss,
  realtype * xp) {
  __turbulence_MOD_do_turbulence (nlev, dt, depth, u_taus, u_taub, z0s, z0b, h, nn, ss, xp);
}
 
extern void __turbulence_MOD_do_tke (
  integer * nlev,
  realtype * dt,
  realtype * u_taus,
  realtype * u_taub,
  realtype * z0s,
  realtype * z0b,
  realtype * h,
  realtype * nn,
  realtype * ss
);
static inline void turbulence_do_tke (
  integer * nlev,
  realtype * dt,
  realtype * u_taus,
  realtype * u_taub,
  realtype * z0s,
  realtype * z0b,
  realtype * h,
  realtype * nn,
  realtype * ss) {
  __turbulence_MOD_do_tke (nlev, dt, u_taus, u_taub, z0s, z0b, h, nn, ss);
}
 
extern void __turbulence_MOD_do_kb (
  integer * nlev,
  realtype * dt,
  realtype * u_taus,
  realtype * u_taub,
  realtype * z0s,
  realtype * z0b,
  realtype * h,
  realtype * nn,
  realtype * ss
);
static inline void turbulence_do_kb (
  integer * nlev,
  realtype * dt,
  realtype * u_taus,
  realtype * u_taub,
  realtype * z0s,
  realtype * z0b,
  realtype * h,
  realtype * nn,
  realtype * ss) {
  __turbulence_MOD_do_kb (nlev, dt, u_taus, u_taub, z0s, z0b, h, nn, ss);
}
 
extern void __turbulence_MOD_do_lengthscale (
  integer * nlev,
  realtype * dt,
  realtype * depth,
  realtype * u_taus,
  realtype * u_taub,
  realtype * z0s,
  realtype * z0b,
  realtype * h,
  realtype * nn,
  realtype * ss
);
static inline void turbulence_do_lengthscale (
  integer * nlev,
  realtype * dt,
  realtype * depth,
  realtype * u_taus,
  realtype * u_taub,
  realtype * z0s,
  realtype * z0b,
  realtype * h,
  realtype * nn,
  realtype * ss) {
  __turbulence_MOD_do_lengthscale (nlev, dt, depth, u_taus, u_taub, z0s, z0b, h, nn, ss);
}
 
extern void __turbulence_MOD_do_epsb (
  integer * nlev,
  realtype * dt,
  realtype * u_taus,
  realtype * u_taub,
  realtype * z0s,
  realtype * z0b,
  realtype * h,
  realtype * nn,
  realtype * ss
);
static inline void turbulence_do_epsb (
  integer * nlev,
  realtype * dt,
  realtype * u_taus,
  realtype * u_taub,
  realtype * z0s,
  realtype * z0b,
  realtype * h,
  realtype * nn,
  realtype * ss) {
  __turbulence_MOD_do_epsb (nlev, dt, u_taus, u_taub, z0s, z0b, h, nn, ss);
}
 
extern void __turbulence_MOD_kolpran (
  integer * nlev
);
static inline void turbulence_kolpran (
  integer * nlev) {
  __turbulence_MOD_kolpran (nlev);
}
 
extern void __turbulence_MOD_stabilityfunctions (
  integer * nlev
);
static inline void turbulence_stabilityfunctions (
  integer * nlev) {
  __turbulence_MOD_stabilityfunctions (nlev);
}
 
extern realtype __turbulence_MOD_k_bc (
  integer * bc,
  integer * type,
  realtype * zi,
  realtype * z0,
  realtype * u_tau
);
static inline realtype turbulence_k_bc (
  integer * bc,
  integer * type,
  realtype * zi,
  realtype * z0,
  realtype * u_tau) {
  return __turbulence_MOD_k_bc (bc, type, zi, z0, u_tau);
}
 
extern realtype __turbulence_MOD_q2over2_bc (
  integer * bc,
  integer * type,
  realtype * zi,
  realtype * z0,
  realtype * u_tau
);
static inline realtype turbulence_q2over2_bc (
  integer * bc,
  integer * type,
  realtype * zi,
  realtype * z0,
  realtype * u_tau) {
  return __turbulence_MOD_q2over2_bc (bc, type, zi, z0, u_tau);
}
 
extern realtype __turbulence_MOD_epsilon_bc (
  integer * bc,
  integer * type,
  realtype * zi,
  realtype * ki,
  realtype * z0,
  realtype * u_tau
);
static inline realtype turbulence_epsilon_bc (
  integer * bc,
  integer * type,
  realtype * zi,
  realtype * ki,
  realtype * z0,
  realtype * u_tau) {
  return __turbulence_MOD_epsilon_bc (bc, type, zi, ki, z0, u_tau);
}
 
extern realtype __turbulence_MOD_psi_bc (
  integer * bc,
  integer * type,
  realtype * zi,
  realtype * ki,
  realtype * z0,
  realtype * u_tau
);
static inline realtype turbulence_psi_bc (
  integer * bc,
  integer * type,
  realtype * zi,
  realtype * ki,
  realtype * z0,
  realtype * u_tau) {
  return __turbulence_MOD_psi_bc (bc, type, zi, ki, z0, u_tau);
}
 
extern realtype __turbulence_MOD_q2l_bc (
  integer * bc,
  integer * type,
  realtype * zi,
  realtype * ki,
  realtype * z0,
  realtype * u_tau
);
static inline realtype turbulence_q2l_bc (
  integer * bc,
  integer * type,
  realtype * zi,
  realtype * ki,
  realtype * z0,
  realtype * u_tau) {
  return __turbulence_MOD_q2l_bc (bc, type, zi, ki, z0, u_tau);
}
 
extern void __turbulence_MOD_clean_turbulence (
 
);
static inline void turbulence_clean_turbulence (void) {
  __turbulence_MOD_clean_turbulence();
}
 
extern void __turbulence_MOD_print_state_turbulence (
 
);
static inline void turbulence_print_state_turbulence (void) {
  __turbulence_MOD_print_state_turbulence();
}
realtype turbulence_get_global (const char * name) {
  if (!strcmp (name, "cm0"))
    return turbulence_cm0;
  if (!strcmp (name, "cmsf"))
    return turbulence_cmsf;
  if (!strcmp (name, "cde"))
    return turbulence_cde;
  if (!strcmp (name, "rcm"))
    return turbulence_rcm;
  if (!strcmp (name, "b1"))
    return turbulence_b1;
  if (!strcmp (name, "prandtl0"))
    return turbulence_prandtl0;
  if (!strcmp (name, "craig_m"))
    return turbulence_craig_m;
  if (!strcmp (name, "sig_e0"))
    return turbulence_sig_e0;
  if (!strcmp (name, "turb_method"))
    return turbulence_turb_method;
  if (!strcmp (name, "tke_method"))
    return turbulence_tke_method;
  if (!strcmp (name, "len_scale_method"))
    return turbulence_len_scale_method;
  if (!strcmp (name, "stab_method"))
    return turbulence_stab_method;
  if (!strcmp (name, "k_ubc"))
    return turbulence_k_ubc;
  if (!strcmp (name, "k_lbc"))
    return turbulence_k_lbc;
  if (!strcmp (name, "kb_ubc"))
    return turbulence_kb_ubc;
  if (!strcmp (name, "kb_lbc"))
    return turbulence_kb_lbc;
  if (!strcmp (name, "psi_ubc"))
    return turbulence_psi_ubc;
  if (!strcmp (name, "psi_lbc"))
    return turbulence_psi_lbc;
  if (!strcmp (name, "ubc_type"))
    return turbulence_ubc_type;
  if (!strcmp (name, "lbc_type"))
    return turbulence_lbc_type;
  if (!strcmp (name, "cm0_fix"))
    return turbulence_cm0_fix;
  if (!strcmp (name, "prandtl0_fix"))
    return turbulence_prandtl0_fix;
  if (!strcmp (name, "cw"))
    return turbulence_cw;
  if (!strcmp (name, "compute_kappa"))
    return turbulence_compute_kappa;
  if (!strcmp (name, "kappa"))
    return turbulence_kappa;
  if (!strcmp (name, "compute_c3"))
    return turbulence_compute_c3;
  if (!strcmp (name, "ri_st"))
    return turbulence_ri_st;
  if (!strcmp (name, "length_lim"))
    return turbulence_length_lim;
  if (!strcmp (name, "galp"))
    return turbulence_galp;
  if (!strcmp (name, "const_num"))
    return turbulence_const_num;
  if (!strcmp (name, "const_nuh"))
    return turbulence_const_nuh;
  if (!strcmp (name, "k_min"))
    return turbulence_k_min;
  if (!strcmp (name, "eps_min"))
    return turbulence_eps_min;
  if (!strcmp (name, "kb_min"))
    return turbulence_kb_min;
  if (!strcmp (name, "epsb_min"))
    return turbulence_epsb_min;
  if (!strcmp (name, "compute_param"))
    return turbulence_compute_param;
  if (!strcmp (name, "gen_m"))
    return turbulence_gen_m;
  if (!strcmp (name, "gen_n"))
    return turbulence_gen_n;
  if (!strcmp (name, "gen_p"))
    return turbulence_gen_p;
  if (!strcmp (name, "cpsi1"))
    return turbulence_cpsi1;
  if (!strcmp (name, "cpsi2"))
    return turbulence_cpsi2;
  if (!strcmp (name, "cpsi3minus"))
    return turbulence_cpsi3minus;
  if (!strcmp (name, "cpsi3plus"))
    return turbulence_cpsi3plus;
  if (!strcmp (name, "sig_kpsi"))
    return turbulence_sig_kpsi;
  if (!strcmp (name, "sig_psi"))
    return turbulence_sig_psi;
  if (!strcmp (name, "gen_d"))
    return turbulence_gen_d;
  if (!strcmp (name, "gen_alpha"))
    return turbulence_gen_alpha;
  if (!strcmp (name, "gen_l"))
    return turbulence_gen_l;
  if (!strcmp (name, "ce1"))
    return turbulence_ce1;
  if (!strcmp (name, "ce2"))
    return turbulence_ce2;
  if (!strcmp (name, "ce3minus"))
    return turbulence_ce3minus;
  if (!strcmp (name, "ce3plus"))
    return turbulence_ce3plus;
  if (!strcmp (name, "sig_k"))
    return turbulence_sig_k;
  if (!strcmp (name, "sig_e"))
    return turbulence_sig_e;
  if (!strcmp (name, "sig_peps"))
    return turbulence_sig_peps;
  if (!strcmp (name, "e1"))
    return turbulence_e1;
  if (!strcmp (name, "e2"))
    return turbulence_e2;
  if (!strcmp (name, "e3"))
    return turbulence_e3;
  if (!strcmp (name, "sq"))
    return turbulence_sq;
  if (!strcmp (name, "sl"))
    return turbulence_sl;
  if (!strcmp (name, "my_length"))
    return turbulence_my_length;
  if (!strcmp (name, "new_constr"))
    return turbulence_new_constr;
  if (!strcmp (name, "scnd_method"))
    return turbulence_scnd_method;
  if (!strcmp (name, "kb_method"))
    return turbulence_kb_method;
  if (!strcmp (name, "epsb_method"))
    return turbulence_epsb_method;
  if (!strcmp (name, "scnd_coeff"))
    return turbulence_scnd_coeff;
  if (!strcmp (name, "cc1"))
    return turbulence_cc1;
  if (!strcmp (name, "ct1"))
    return turbulence_ct1;
  if (!strcmp (name, "ctt"))
    return turbulence_ctt;
  if (!strcmp (name, "cc2"))
    return turbulence_cc2;
  if (!strcmp (name, "cc3"))
    return turbulence_cc3;
  if (!strcmp (name, "cc4"))
    return turbulence_cc4;
  if (!strcmp (name, "cc5"))
    return turbulence_cc5;
  if (!strcmp (name, "cc6"))
    return turbulence_cc6;
  if (!strcmp (name, "ct2"))
    return turbulence_ct2;
  if (!strcmp (name, "ct3"))
    return turbulence_ct3;
  if (!strcmp (name, "ct4"))
    return turbulence_ct4;
  if (!strcmp (name, "ct5"))
    return turbulence_ct5;
  if (!strcmp (name, "a1"))
    return turbulence_a1;
  if (!strcmp (name, "a2"))
    return turbulence_a2;
  if (!strcmp (name, "a3"))
    return turbulence_a3;
  if (!strcmp (name, "a4"))
    return turbulence_a4;
  if (!strcmp (name, "a5"))
    return turbulence_a5;
  if (!strcmp (name, "at1"))
    return turbulence_at1;
  if (!strcmp (name, "at2"))
    return turbulence_at2;
  if (!strcmp (name, "at3"))
    return turbulence_at3;
  if (!strcmp (name, "at4"))
    return turbulence_at4;
  if (!strcmp (name, "at5"))
    return turbulence_at5;
  if (!strcmp (name, "iw_model"))
    return turbulence_iw_model;
  if (!strcmp (name, "alpha"))
    return turbulence_alpha;
  if (!strcmp (name, "klimiw"))
    return turbulence_klimiw;
  if (!strcmp (name, "rich_cr"))
    return turbulence_rich_cr;
  if (!strcmp (name, "numiw"))
    return turbulence_numiw;
  if (!strcmp (name, "nuhiw"))
    return turbulence_nuhiw;
  if (!strcmp (name, "numshear"))
    return turbulence_numshear;
  return HUGE;
}