#include <ABLMost.H>

Collaboration diagram for ABLMost:

[legend]

Public Types
enum class	FluxCalcType { MOENG = 0 , DONELAN , CUSTOM }

enum class	ThetaCalcType { ADIABATIC = 0 , HEAT_FLUX , SURFACE_TEMPERATURE }

enum class	RoughCalcType { CONSTANT = 0 , CHARNOCK , MODIFIED_CHARNOCK }

Public Member Functions
	ABLMost (const amrex::Vector< amrex::Geometry > &geom, bool &use_exp_most, amrex::Vector< amrex::Vector< amrex::MultiFab >> &vars_old, amrex::Vector< std::unique_ptr< amrex::MultiFab >> &Theta_prim, amrex::Vector< std::unique_ptr< amrex::MultiFab >> &Qv_prim, amrex::Vector< std::unique_ptr< amrex::MultiFab >> &z_phys_nd, amrex::Vector< amrex::Vector< std::unique_ptr< amrex::MultiFab >>> &sst_lev, amrex::Vector< amrex::Vector< std::unique_ptr< amrex::iMultiFab >>> &lmask_lev, amrex::Vector< amrex::Vector< amrex::MultiFab * >> lsm_data, amrex::Vector< amrex::Vector< amrex::MultiFab * >> lsm_flux, amrex::Real start_bdy_time=0.0, amrex::Real bdy_time_interval=0.0)

void	update_fluxes (const int &lev, const amrex::Real &time, int max_iters=25)

template<typename FluxIter >
void	compute_fluxes (const int &lev, const int &max_iters, const FluxIter &most_flux)

void	impose_most_bcs (const int &lev, const amrex::Vector< amrex::MultiFab * > &mfs, amrex::MultiFab xzmom_flux, amrex::MultiFab zxmom_flux, amrex::MultiFab yzmom_flux, amrex::MultiFab zymom_flux, amrex::MultiFab heat_flux, amrex::MultiFab eddyDiffs, amrex::MultiFab *z_phys)

template<typename FluxCalc >
void	compute_most_bcs (const int &lev, const amrex::Vector< amrex::MultiFab * > &mfs, amrex::MultiFab xzmom_flux, amrex::MultiFab zxmom_flux, amrex::MultiFab yzmom_flux, amrex::MultiFab zymom_flux, amrex::MultiFab heat_flux, amrex::MultiFab eddyDiffs, amrex::MultiFab *z_phys, const amrex::Real &dz_no_terrain, const FluxCalc &flux_comp)

void	time_interp_sst (const int &lev, const amrex::Real &time)

void	get_lsm_tsurf (const int &lev)

void	update_surf_temp (const amrex::Real &time)

void	update_mac_ptrs (const int &lev, amrex::Vector< amrex::Vector< amrex::MultiFab >> &vars_old, amrex::Vector< std::unique_ptr< amrex::MultiFab >> &Theta_prim, amrex::Vector< std::unique_ptr< amrex::MultiFab >> &Qv_prim)

const amrex::MultiFab *	get_u_star (const int &lev)

const amrex::MultiFab *	get_t_star (const int &lev)

const amrex::MultiFab *	get_olen (const int &lev)

const amrex::MultiFab *	get_mac_avg (const int &lev, int comp)

const amrex::MultiFab *	get_t_surf (const int &lev)

amrex::Real	get_zref ()

const amrex::FArrayBox *	get_z0 (const int &lev)

template<typename FluxCalc >
void	compute_most_bcs (const int &lev, const Vector< MultiFab * > &mfs, MultiFab xzmom_flux, MultiFab zxmom_flux, MultiFab yzmom_flux, MultiFab zymom_flux, MultiFab heat_flux, MultiFab eddyDiffs, MultiFab *z_phys, const Real &dz_no_terrain, const FluxCalc &flux_comp)

Public Attributes
FluxCalcType	flux_type {FluxCalcType::MOENG}

ThetaCalcType	theta_type {ThetaCalcType::ADIABATIC}

RoughCalcType	rough_type {RoughCalcType::CONSTANT}

Private Attributes
bool	use_moisture

bool	m_exp_most = false

amrex::Real	z0_const

amrex::Real	surf_temp

amrex::Real	surf_heating_rate {0}

amrex::Real	surf_temp_flux {0}

amrex::Real	custom_ustar {0}

amrex::Real	custom_tstar {0}

amrex::Real	custom_qstar {0}

amrex::Real	cnk_a {0.0185}

amrex::Real	depth {30.0}

amrex::Real	m_start_bdy_time

amrex::Real	m_bdy_time_interval

amrex::Vector< amrex::Geometry >	m_geom

amrex::Vector< amrex::FArrayBox >	z_0

MOSTAverage	m_ma

amrex::Vector< std::unique_ptr< amrex::MultiFab > >	u_star

amrex::Vector< std::unique_ptr< amrex::MultiFab > >	t_star

amrex::Vector< std::unique_ptr< amrex::MultiFab > >	q_star

amrex::Vector< std::unique_ptr< amrex::MultiFab > >	olen

amrex::Vector< std::unique_ptr< amrex::MultiFab > >	t_surf

amrex::Vector< amrex::Vector< amrex::MultiFab * > >	m_sst_lev

amrex::Vector< amrex::Vector< amrex::iMultiFab * > >	m_lmask_lev

amrex::Vector< amrex::Vector< amrex::MultiFab * > >	m_lsm_data_lev

amrex::Vector< amrex::Vector< amrex::MultiFab * > >	m_lsm_flux_lev

Detailed Description

Monin-Obukhov surface layer profile

van der Laan, P., Kelly, M. C., & Sørensen, N. N. (2017). A new k-epsilon model consistent with Monin-Obukhov similarity theory. Wind Energy, 20(3), 479–489. https://doi.org/10.1002/we.2017

Consistent with Dyer (1974) formulation from page 57, Chapter 2, Modeling the vertical ABL structure in Modelling of Atmospheric Flow Fields, Demetri P Lalas and Corrado F Ratto, January 1996, https://doi.org/10.1142/2975.

Member Enumeration Documentation

◆ FluxCalcType

enum ABLMost::FluxCalcType

strong

Enumerator
MOENG	Moeng functional form.
DONELAN	Donelan functional form.
CUSTOM	Custom constant flux functional form.

                              {
         MOENG = 0,      ///< Moeng functional form
         DONELAN,        ///< Donelan functional form
         CUSTOM          ///< Custom constant flux functional form
     };

◆ RoughCalcType

enum ABLMost::RoughCalcType

strong

Enumerator
CONSTANT	Constant z0.
CHARNOCK
MODIFIED_CHARNOCK

                               {
         CONSTANT = 0,      ///< Constant z0
         CHARNOCK,
         MODIFIED_CHARNOCK
     };

◆ ThetaCalcType

enum ABLMost::ThetaCalcType

strong

Enumerator
ADIABATIC
HEAT_FLUX	Heat-flux specified.
SURFACE_TEMPERATURE	Surface temperature specified.

                               {
         ADIABATIC = 0,
         HEAT_FLUX,          ///< Heat-flux specified
         SURFACE_TEMPERATURE ///< Surface temperature specified
     };

Constructor & Destructor Documentation

◆ ABLMost()

ABLMost::ABLMost	(	const amrex::Vector< amrex::Geometry > &	geom,
		bool &	use_exp_most,
		amrex::Vector< amrex::Vector< amrex::MultiFab >> &	vars_old,
		amrex::Vector< std::unique_ptr< amrex::MultiFab >> &	Theta_prim,
		amrex::Vector< std::unique_ptr< amrex::MultiFab >> &	Qv_prim,
		amrex::Vector< std::unique_ptr< amrex::MultiFab >> &	z_phys_nd,
		amrex::Vector< amrex::Vector< std::unique_ptr< amrex::MultiFab >>> &	sst_lev,
		amrex::Vector< amrex::Vector< std::unique_ptr< amrex::iMultiFab >>> &	lmask_lev,
		amrex::Vector< amrex::Vector< amrex::MultiFab * >>	lsm_data,
		amrex::Vector< amrex::Vector< amrex::MultiFab * >>	lsm_flux,
		amrex::Real	start_bdy_time = `0.0`,
		amrex::Real	bdy_time_interval = `0.0`
	)

inlineexplicit

     : m_exp_most(use_exp_most),
       m_start_bdy_time(start_bdy_time),
       m_bdy_time_interval(bdy_time_interval),
       m_geom(geom),
       m_ma(geom,vars_old,Theta_prim,Qv_prim,z_phys_nd)
     {
         // We have a moisture model if Qv_prim is a valid pointer
         use_moisture = (Qv_prim[0].get());
  
         // Get roughness
         amrex::ParmParse pp("erf");
         pp.query("most.z0", z0_const);
  
         // Specify how to compute the flux
         std::string flux_string{"moeng"};
         pp.query("most.flux_type", flux_string);
         if (flux_string == "donelan") {
             flux_type = FluxCalcType::DONELAN;
         } else if (flux_string == "moeng") {
             flux_type = FluxCalcType::MOENG;
         } else if (flux_string == "custom") {
             flux_type = FluxCalcType::CUSTOM;
         } else {
             amrex::Abort("Undefined MOST flux type!");
         }
  
         // Get surface temperature
         auto erf_st = pp.query("most.surf_temp", surf_temp);
  
         // Custom type user must specify the fluxes
         if (flux_type == FluxCalcType::CUSTOM) {
             theta_type = ThetaCalcType::HEAT_FLUX;
             pp.query("most.ustar", custom_ustar);
             pp.query("most.tstar", custom_tstar);
             pp.query("most.qstar", custom_qstar);
             if (custom_qstar != 0) {
                 AMREX_ASSERT_WITH_MESSAGE(use_moisture, "Specified custom MOST qv flux without moisture model!");
             }
             amrex::Print() << "Using specified ustar, tstar, qstar for MOST = "
                 << custom_ustar << " "
                 << custom_tstar << " "
                 << custom_qstar << std::endl;
  
         // Specify surface temperature or surface flux
         } else {
             if (erf_st) {
                 theta_type = ThetaCalcType::SURFACE_TEMPERATURE;
                 pp.query("most.surf_heating_rate", surf_heating_rate); // [K/h]
                 surf_heating_rate = surf_heating_rate / 3600.0; // [K/s]
                 if (pp.query("most.surf_temp_flux", surf_temp_flux)) {
                     amrex::Abort("Can only specify one of surf_temp_flux or surf_heating_rate");
                 }
             } else {
                 pp.query("most.surf_temp_flux", surf_temp_flux);
                 if (pp.query("most.surf_heating_rate", surf_heating_rate)) {
                     amrex::Abort("Can only specify one of surf_temp_flux or surf_heating_rate");
                 }
                 if (std::abs(surf_temp_flux) > std::numeric_limits<amrex::Real>::epsilon()) {
                     theta_type = ThetaCalcType::HEAT_FLUX;
                 } else {
                     theta_type = ThetaCalcType::ADIABATIC;
                 }
             }
         }
  
         // Specify how to compute the flux
         std::string rough_string{"constant"};
         pp.query("most.roughness_type", rough_string);
         if (rough_string == "constant") {
             rough_type = RoughCalcType::CONSTANT;
         } else if (rough_string == "charnock") {
             rough_type = RoughCalcType::CHARNOCK;
             pp.query("most.charnock_constant",cnk_a);
         } else if (rough_string == "modified_charnock") {
             rough_type = RoughCalcType::MODIFIED_CHARNOCK;
             pp.query("most.modified_charnock_depth",depth);
         } else {
             amrex::Abort("Undefined MOST roughness type!");
         }
  
         // Size the MOST params for all levels
         int nlevs = m_geom.size();
         z_0.resize(nlevs);
         u_star.resize(nlevs);
         t_star.resize(nlevs);
         q_star.resize(nlevs);
         t_surf.resize(nlevs);
         olen.resize(nlevs);
  
         // Get pointers to SST and LANDMASK data
         m_sst_lev.resize(nlevs);
         m_lmask_lev.resize(nlevs);
         for (int lev(0); lev<nlevs; ++lev) {
             int nt_tot = sst_lev[lev].size();
             m_sst_lev[lev].resize(nt_tot);
             m_lmask_lev[lev].resize(nt_tot);
             for (int nt(0); nt<nt_tot; ++nt) {
                 m_sst_lev[lev][nt]   = sst_lev[lev][nt].get();
                 m_lmask_lev[lev][nt] = lmask_lev[lev][nt].get();
             }
         }
  
         // Get pointers to LSM data and Fluxes
         m_lsm_data_lev.resize(nlevs);
         m_lsm_flux_lev.resize(nlevs);
         for (int lev(0); lev<nlevs; ++lev) {
             int nvar = lsm_data[lev].size();
             m_lsm_data_lev[lev].resize(nvar);
             m_lsm_flux_lev[lev].resize(nvar);
             for (int n(0); n<nvar; ++n) {
                 m_lsm_data_lev[lev][n] = lsm_data[lev][n];
                 m_lsm_flux_lev[lev][n] = lsm_flux[lev][n];
             }
         }
  
         for (int lev = 0; lev < nlevs; lev++) {
             // Attributes for MFs and FABs
             //--------------------------------------------------------
             auto& mf = vars_old[lev][Vars::cons];
             // Create a 2D ba, dm, & ghost cells
             amrex::BoxArray ba  = mf.boxArray();
             amrex::BoxList bl2d = ba.boxList();
             for (auto& b : bl2d) {
                 b.setRange(2,0);
             }
             amrex::BoxArray ba2d(std::move(bl2d));
             const amrex::DistributionMapping& dm = mf.DistributionMap();
             const int ncomp   = 1;
             amrex::IntVect ng = mf.nGrowVect(); ng[2]=0;
  
             // Z0 heights FAB
             //--------------------------------------------------------
             amrex::Box bx = amrex::grow(m_geom[lev].Domain(),ng);
             bx.setSmall(2,0);
             bx.setBig(2,0);
             z_0[lev].resize(bx,1);
             z_0[lev].setVal<amrex::RunOn::Device>(z0_const);
  
             // 2D MFs for U*, T*, T_surf
             //--------------------------------------------------------
             u_star[lev] = std::make_unique<amrex::MultiFab>(ba2d,dm,ncomp,ng);
             u_star[lev]->setVal(1.E34);
  
             t_star[lev] = std::make_unique<amrex::MultiFab>(ba2d,dm,ncomp,ng);
             t_star[lev]->setVal(1.E34);
  
             q_star[lev] = std::make_unique<amrex::MultiFab>(ba2d,dm,ncomp,ng);
             q_star[lev]->setVal(1.E34);
  
             olen[lev] = std::make_unique<amrex::MultiFab>(ba2d,dm,ncomp,ng);
             olen[lev]->setVal(1.E34);
  
             t_surf[lev] = std::make_unique<amrex::MultiFab>(ba2d,dm,ncomp,ng);
  
             // TODO: Do we want lsm_data to have theta at 0 index always?
             //       Do we want an external enum struct for indexing?
             if (m_sst_lev[lev][0] || m_lsm_data_lev[lev][0]) {
                 // Valid SST or LSM data; t_surf set before computing fluxes (avoids extended lambda capture)
                 theta_type = ThetaCalcType::SURFACE_TEMPERATURE;
             } else if (erf_st) {
                 t_surf[lev]->setVal(surf_temp);
             } else {
                 t_surf[lev]->setVal(0.0);
             }
         }// lev
     }

Here is the call graph for this function:

Member Function Documentation

◆ compute_fluxes()

template<typename FluxIter >

void ABLMost::compute_fluxes	(	const int &	lev,
		const int &	max_iters,
		const FluxIter &	most_flux
	)

Function to compute the fluxes (u^star and t^star) for Monin Obukhov similarity theory.

Parameters

[in]	lev	Current level
[in]	max_iters	maximum iterations to use
[in]	most_flux	structure to iteratively compute ustar and tstar

 {
     // Pointers to the computed averages
     const auto *const tm_ptr  = m_ma.get_average(lev,2);
     const auto *const umm_ptr = m_ma.get_average(lev,4);
  
     for (MFIter mfi(*u_star[lev]); mfi.isValid(); ++mfi)
     {
         Box gtbx = mfi.growntilebox();
  
         auto u_star_arr = u_star[lev]->array(mfi);
         auto t_star_arr = t_star[lev]->array(mfi);
         auto t_surf_arr = t_surf[lev]->array(mfi);
         auto olen_arr   = olen[lev]->array(mfi);
  
         const auto tm_arr  = tm_ptr->array(mfi);
         const auto umm_arr = umm_ptr->array(mfi);
         const auto z0_arr  = z_0[lev].array();
  
         ParallelFor(gtbx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
         {
             most_flux.iterate_flux(i, j, k, max_iters, z0_arr, umm_arr, tm_arr,
                                    u_star_arr, t_star_arr, t_surf_arr, olen_arr);
         });
     }
 }

◆ compute_most_bcs() [1/2]

template<typename FluxCalc >

void ABLMost::compute_most_bcs	(	const int &	lev,
		const amrex::Vector< amrex::MultiFab * > &	mfs,
		amrex::MultiFab *	xzmom_flux,
		amrex::MultiFab *	zxmom_flux,
		amrex::MultiFab *	yzmom_flux,
		amrex::MultiFab *	zymom_flux,
		amrex::MultiFab *	heat_flux,
		amrex::MultiFab *	eddyDiffs,
		amrex::MultiFab *	z_phys,
		const amrex::Real &	dz_no_terrain,
		const FluxCalc &	flux_comp
	)

◆ compute_most_bcs() [2/2]

template<typename FluxCalc >

void ABLMost::compute_most_bcs	(	const int &	lev,
		const Vector< MultiFab * > &	mfs,
		MultiFab *	xzmom_flux,
		MultiFab *	zxmom_flux,
		MultiFab *	yzmom_flux,
		MultiFab *	zymom_flux,
		MultiFab *	heat_flux,
		MultiFab *	eddyDiffs,
		MultiFab *	z_phys,
		const Real &	dz_no_terrain,
		const FluxCalc &	flux_comp
	)

Function to calculate MOST fluxes for populating ghost cells.

Parameters

[in]	lev	Current level
[in,out]	mfs	Multifabs to populate
[in]	eddyDiffs	Diffusion coefficients from turbulence model
[in]	flux_comp	structure to compute fluxes

 {
     const int klo   = 0;
     const int icomp = 0;
     for (MFIter mfi(*mfs[0]); mfi.isValid(); ++mfi)
     {
         // TODO: No LSM lateral ghost cells, should this change?
         // Valid CC box
         Box vbx = mfi.validbox(); vbx.makeSlab(2,klo-1);
  
         Box vbxx = surroundingNodes(vbx,0);
         Box vbxy = surroundingNodes(vbx,1);
  
         // Expose for GPU
         bool exp_most = m_exp_most;
  
         // Get field arrays
         const auto cons_arr  = mfs[Vars::cons]->array(mfi);
         const auto velx_arr  = mfs[Vars::xvel]->array(mfi);
         const auto vely_arr  = mfs[Vars::yvel]->array(mfi);
  
         auto t13_arr = (m_exp_most) ? xzmom_flux->array(mfi) : Array4<Real>{};
         auto t23_arr = (m_exp_most) ? yzmom_flux->array(mfi) : Array4<Real>{};
         auto t31_arr = (zxmom_flux && m_exp_most) ? zxmom_flux->array(mfi) : Array4<Real>{};
         auto t32_arr = (zymom_flux && m_exp_most) ? zymom_flux->array(mfi) : Array4<Real>{};
         auto hfx_arr = (m_exp_most) ? heat_flux->array(mfi) : Array4<Real>{};
  
         const auto  eta_arr  = eddyDiffs->array(mfi);
  
         const auto zphys_arr = (z_phys) ? z_phys->const_array(mfi) : Array4<const Real>{};
  
         // Get average arrays
         const auto *const u_mean     = m_ma.get_average(lev,0);
         const auto *const v_mean     = m_ma.get_average(lev,1);
         const auto *const t_mean     = m_ma.get_average(lev,2);
         const auto *const q_mean     = m_ma.get_average(lev,3);
         const auto *const u_mag_mean = m_ma.get_average(lev,4);
  
         const auto um_arr  = u_mean->array(mfi);
         const auto vm_arr  = v_mean->array(mfi);
         const auto tm_arr  = t_mean->array(mfi);
         const auto qm_arr  = q_mean->array(mfi);
         const auto umm_arr = u_mag_mean->array(mfi);
  
         // Get derived arrays
         const auto u_star_arr = u_star[lev]->array(mfi);
         const auto t_star_arr = t_star[lev]->array(mfi);
         const auto q_star_arr = q_star[lev]->array(mfi);
         const auto t_surf_arr = t_surf[lev]->array(mfi);
  
         // Get LSM fluxes
         auto lmask_arr    = (m_lmask_lev[lev][0])    ? m_lmask_lev[lev][0]->array(mfi) :
                                                        Array4<int> {};
         auto lsm_flux_arr = (m_lsm_flux_lev[lev][0]) ? m_lsm_flux_lev[lev][0]->array(mfi) :
                                                        Array4<Real> {};
  
         for (int var_idx = 0; var_idx < Vars::NumTypes; ++var_idx)
         {
             const Box& bx = (*mfs[var_idx])[mfi].box();
             auto dest_arr = (*mfs[var_idx])[mfi].array();
  
             if (var_idx == Vars::cons) {
                 Box b2d = bx;
                 b2d.setBig(2,klo-1);
                 int n = RhoTheta_comp;
                 ParallelFor(b2d, [=] AMREX_GPU_DEVICE (int i, int j, int k)
                 {
                     Real dz  = (zphys_arr) ? ( zphys_arr(i,j,klo  ) - zphys_arr(i,j,klo-1) ) : dz_no_terrain;
                     Real dz1 = (zphys_arr) ? ( zphys_arr(i,j,klo+1) - zphys_arr(i,j,klo  ) ) : dz_no_terrain;
                     Real Tflux = flux_comp.compute_t_flux(i, j, k, n, icomp, dz, dz1, exp_most, eta_arr,
                                                           cons_arr, velx_arr, vely_arr,
                                                           umm_arr, tm_arr, u_star_arr, t_star_arr, t_surf_arr,
                                                           dest_arr);
  
  
                     // TODO: make sure not to double-count surface heat flux if using a LSM
                     int is_land = (lmask_arr) ? lmask_arr(i,j,klo) : 1;
                     if (is_land && lsm_flux_arr && vbx.contains(i,j,k)) {
                         lsm_flux_arr(i,j,klo) = Tflux;
                     }
                     else if ((k == klo-1) && vbx.contains(i,j,k) && exp_most) {
                         hfx_arr(i,j,klo-1) = Tflux;
                     }
                 });
  
                 // TODO: Generalize MOST q flux with MOENG & DONELAN flux types
                 if ((flux_type == FluxCalcType::CUSTOM) && use_moisture) {
                     n = RhoQ1_comp;
                     ParallelFor(b2d, [=] AMREX_GPU_DEVICE (int i, int j, int k)
                     {
                         Real dz  = (zphys_arr) ? ( zphys_arr(i,j,klo  ) - zphys_arr(i,j,klo-1) ) : dz_no_terrain;
                         Real dz1 = (zphys_arr) ? ( zphys_arr(i,j,klo+1) - zphys_arr(i,j,klo  ) ) : dz_no_terrain;
                         Real Qflux = flux_comp.compute_q_flux(i, j, k, n, icomp, dz, dz1, exp_most, eta_arr,
                                                               cons_arr, velx_arr, vely_arr,
                                                               umm_arr, qm_arr, u_star_arr, q_star_arr, t_surf_arr,
                                                               dest_arr);
                         amrex::ignore_unused(Qflux);
                     });
                 }
  
             } else if (var_idx == Vars::xvel) {
  
                 Box xb2d = surroundingNodes(bx,0);
                 xb2d.setBig(2,klo-1);
  
                 ParallelFor(xb2d, [=] AMREX_GPU_DEVICE (int i, int j, int k)
                 {
                     Real dz  = (zphys_arr) ? ( zphys_arr(i,j,klo  ) - zphys_arr(i,j,klo-1) ) : dz_no_terrain;
                     Real dz1 = (zphys_arr) ? ( zphys_arr(i,j,klo+1) - zphys_arr(i,j,klo  ) ) : dz_no_terrain;
                     Real stressx = flux_comp.compute_u_flux(i, j, k, icomp, dz, dz1, exp_most, eta_arr,
                                                             cons_arr, velx_arr, vely_arr,
                                                             umm_arr, um_arr, u_star_arr,
                                                             dest_arr);
                     if ((k == klo-1) && vbxx.contains(i,j,k) && exp_most) {
                         t13_arr(i,j,klo) = -stressx;
                         if (t31_arr) t31_arr(i,j,klo) = -stressx;
                     }
                     amrex::ignore_unused(stressx);
                 });
  
             } else if (var_idx == Vars::yvel) {
  
                 Box yb2d = surroundingNodes(bx,1);
                 yb2d.setBig(2,klo-1);
  
                 ParallelFor(yb2d, [=] AMREX_GPU_DEVICE (int i, int j, int k)
                 {
                     Real dz  = (zphys_arr) ? ( zphys_arr(i,j,klo  ) - zphys_arr(i,j,klo-1) ) : dz_no_terrain;
                     Real dz1 = (zphys_arr) ? ( zphys_arr(i,j,klo+1) - zphys_arr(i,j,klo  ) ) : dz_no_terrain;
                     Real stressy = flux_comp.compute_v_flux(i, j, k, icomp, dz, dz1, exp_most, eta_arr,
                                                             cons_arr, velx_arr, vely_arr,
                                                             umm_arr, vm_arr, u_star_arr,
                                                             dest_arr);
                     if ((k == klo-1) && vbxy.contains(i,j,k) && exp_most) {
                         t23_arr(i,j,klo) = -stressy;
                         if (t32_arr) t32_arr(i,j,klo) = -stressy;
                     }
                     amrex::ignore_unused(stressy);
                 });
             }
         } // var_idx
     } // mfiter
 }

◆ get_lsm_tsurf()

void ABLMost::get_lsm_tsurf ( const int & lev )

 {
     for (MFIter mfi(*t_surf[lev]); mfi.isValid(); ++mfi)
     {
         Box gtbx = mfi.growntilebox();
  
         // TODO: LSM does not carry lateral ghost cells.
         //       This copies the valid box into the ghost cells.
         //       Fillboundary is called after this to pick up the
         //       interior ghost and periodic directions. Is there
         //       a better approach?
         Box vbx  = mfi.validbox();
         int i_lo = vbx.smallEnd(0); int i_hi = vbx.bigEnd(0);
         int j_lo = vbx.smallEnd(1); int j_hi = vbx.bigEnd(1);
  
         auto t_surf_arr = t_surf[lev]->array(mfi);
         auto lmask_arr  = (m_lmask_lev[lev][0]) ? m_lmask_lev[lev][0]->array(mfi) :
                                                   Array4<int> {};
         const auto lsm_arr = m_lsm_data_lev[lev][0]->const_array(mfi);
  
         ParallelFor(gtbx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
         {
             int is_land = (lmask_arr) ? lmask_arr(i,j,k) : 1;
             if (is_land) {
                 int li = amrex::min(amrex::max(i, i_lo), i_hi);
                 int lj = amrex::min(amrex::max(j, j_lo), j_hi);
                 t_surf_arr(i,j,k) = lsm_arr(li,lj,k);
             }
         });
     }
 }

◆ get_mac_avg()

const amrex::MultiFab* ABLMost::get_mac_avg	(	const int &	lev,
		int	comp
	)

inline

283 { return m_ma.get_average(lev,comp); }

Here is the call graph for this function:

◆ get_olen()

const amrex::MultiFab* ABLMost::get_olen ( const int & lev )

inline

280 { return olen[lev].get(); }

◆ get_t_star()

const amrex::MultiFab* ABLMost::get_t_star ( const int & lev )

inline

277 { return t_star[lev].get(); }

◆ get_t_surf()

const amrex::MultiFab* ABLMost::get_t_surf ( const int & lev )

inline

286 { return t_surf[lev].get(); }

◆ get_u_star()

const amrex::MultiFab* ABLMost::get_u_star ( const int & lev )

inline

274 { return u_star[lev].get(); }

◆ get_z0()

const amrex::FArrayBox* ABLMost::get_z0 ( const int & lev )

inline

292 {return &z_0[lev];}

◆ get_zref()

amrex::Real ABLMost::get_zref ( )

inline

289 {return m_ma.get_zref();}

MOSTAverage::get_zref

amrex::Real get_zref() const

Definition: MOSTAverage.H:90

Here is the call graph for this function:

◆ impose_most_bcs()

void ABLMost::impose_most_bcs	(	const int &	lev,
		const amrex::Vector< amrex::MultiFab * > &	mfs,
		amrex::MultiFab *	xzmom_flux,
		amrex::MultiFab *	zxmom_flux,
		amrex::MultiFab *	yzmom_flux,
		amrex::MultiFab *	zymom_flux,
		amrex::MultiFab *	heat_flux,
		amrex::MultiFab *	eddyDiffs,
		amrex::MultiFab *	z_phys
	)

Wrapper to impose Monin Obukhov similarity theory fluxes by populating ghost cells.

Parameters

[in]	lev	Current level
[in,out]	mfs	Multifabs to populate
[in]	eddyDiffs	Diffusion coefficients from turbulence model

 {
     const int klo = 0;
     if (flux_type == FluxCalcType::MOENG) {
         moeng_flux flux_comp(klo);
         compute_most_bcs(lev, mfs,
                          xzmom_flux, zxmom_flux,
                          yzmom_flux, zymom_flux,
                          heat_flux,
                          eddyDiffs,
                          z_phys, m_geom[lev].CellSize(2), flux_comp);
     } else if (flux_type == FluxCalcType::DONELAN) {
         donelan_flux flux_comp(klo);
         compute_most_bcs(lev, mfs,
                          xzmom_flux, zxmom_flux,
                          yzmom_flux, zymom_flux,
                          heat_flux,
                          eddyDiffs,
                          z_phys, m_geom[lev].CellSize(2), flux_comp);
     } else {
         custom_flux flux_comp(klo);
         compute_most_bcs(lev, mfs,
                          xzmom_flux, zxmom_flux,
                          yzmom_flux, zymom_flux,
                          heat_flux,
                          eddyDiffs,
                          z_phys, m_geom[lev].CellSize(2), flux_comp);
     }
 }

◆ time_interp_sst()

void ABLMost::time_interp_sst	(	const int &	lev,
		const amrex::Real &	time
	)

 {
     // Time interpolation
     Real dT = m_bdy_time_interval;
     Real time_since_start = time - m_start_bdy_time;
     int n_time = static_cast<int>( time_since_start /  dT);
     Real alpha = (time_since_start - n_time * dT) / dT;
     AMREX_ALWAYS_ASSERT( alpha >= 0. && alpha <= 1.0);
     Real oma   = 1.0 - alpha;
     AMREX_ALWAYS_ASSERT( (n_time >= 0) && (n_time < (m_sst_lev[lev].size()-1)));
  
     // Populate t_surf
     for (MFIter mfi(*t_surf[lev]); mfi.isValid(); ++mfi)
     {
         Box gtbx = mfi.growntilebox();
  
         auto t_surf_arr = t_surf[lev]->array(mfi);
         const auto sst_hi_arr = m_sst_lev[lev][n_time+1]->const_array(mfi);
         const auto sst_lo_arr = m_sst_lev[lev][n_time  ]->const_array(mfi);
         auto lmask_arr  = (m_lmask_lev[lev][0]) ? m_lmask_lev[lev][0]->array(mfi) :
                                                   Array4<int> {};
  
         ParallelFor(gtbx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
         {
             int is_land = (lmask_arr) ? lmask_arr(i,j,k) : 1;
             if (!is_land) {
                 t_surf_arr(i,j,k) = oma   * sst_lo_arr(i,j,k)
                                   + alpha * sst_hi_arr(i,j,k);
             }
         });
     }
 }

◆ update_fluxes()

void ABLMost::update_fluxes	(	const int &	lev,
		const amrex::Real &	time,
		int	max_iters = `25`
	)

Wrapper to update ustar and tstar for Monin Obukhov similarity theory.

Parameters

[in]	lev	Current level
[in]	max_iters	maximum iterations to use

 {
     // Update SST data if we have a valid pointer
     if (m_sst_lev[lev][0]) time_interp_sst(lev, time);
  
     // TODO: we want 0 index to always be theta?
     // Update land surface temp if we have a valid pointer
     if (m_lsm_data_lev[lev][0]) get_lsm_tsurf(lev);
  
     // Fill interior ghost cells
     t_surf[lev]->FillBoundary(m_geom[lev].periodicity());
  
     // Compute plane averages for all vars (regardless of flux type)
     m_ma.compute_averages(lev);
  
     // Iterate the fluxes if moeng type
     if (flux_type == FluxCalcType::MOENG) {
         if (theta_type == ThetaCalcType::HEAT_FLUX) {
             if (rough_type == RoughCalcType::CONSTANT) {
                 surface_flux most_flux(m_ma.get_zref(), surf_temp_flux);
                 compute_fluxes(lev, max_iters, most_flux);
             } else if (rough_type == RoughCalcType::CHARNOCK) {
                 surface_flux_charnock most_flux(m_ma.get_zref(), surf_temp_flux, cnk_a);
                 compute_fluxes(lev, max_iters, most_flux);
             } else {
                 surface_flux_mod_charnock most_flux(m_ma.get_zref(), surf_temp_flux, depth);
                 compute_fluxes(lev, max_iters, most_flux);
             }
         } else if (theta_type == ThetaCalcType::SURFACE_TEMPERATURE) {
             update_surf_temp(time);
             if (rough_type == RoughCalcType::CONSTANT) {
                 surface_temp most_flux(m_ma.get_zref(), surf_temp_flux);
                 compute_fluxes(lev, max_iters, most_flux);
             } else if (rough_type == RoughCalcType::CHARNOCK) {
                 surface_temp_charnock most_flux(m_ma.get_zref(), surf_temp_flux, cnk_a);
                 compute_fluxes(lev, max_iters, most_flux);
             } else {
                 surface_temp_mod_charnock most_flux(m_ma.get_zref(), surf_temp_flux, depth);
                 compute_fluxes(lev, max_iters, most_flux);
             }
         } else {
             if (rough_type == RoughCalcType::CONSTANT) {
                 adiabatic most_flux(m_ma.get_zref(), surf_temp_flux);
                 compute_fluxes(lev, max_iters, most_flux);
             } else if (rough_type == RoughCalcType::CHARNOCK) {
                 adiabatic_charnock most_flux(m_ma.get_zref(), surf_temp_flux, cnk_a);
                 compute_fluxes(lev, max_iters, most_flux);
             } else {
                 adiabatic_mod_charnock most_flux(m_ma.get_zref(), surf_temp_flux, depth);
                 compute_fluxes(lev, max_iters, most_flux);
             }
         } // theta flux
     } else if (flux_type == FluxCalcType::CUSTOM) {
         u_star[lev]->setVal(custom_ustar);
         t_star[lev]->setVal(custom_tstar);
         q_star[lev]->setVal(custom_qstar);
     }
 }

◆ update_mac_ptrs()

void ABLMost::update_mac_ptrs	(	const int &	lev,
		amrex::Vector< amrex::Vector< amrex::MultiFab >> &	vars_old,
		amrex::Vector< std::unique_ptr< amrex::MultiFab >> &	Theta_prim,
		amrex::Vector< std::unique_ptr< amrex::MultiFab >> &	Qv_prim
	)

inline

271 { m_ma.update_field_ptrs(lev,vars_old,Theta_prim,Qv_prim); }

MOSTAverage::update_field_ptrs

void update_field_ptrs(int lev, amrex::Vector< amrex::Vector< amrex::MultiFab >> &vars_old, amrex::Vector< std::unique_ptr< amrex::MultiFab >> &Theta_prim, amrex::Vector< std::unique_ptr< amrex::MultiFab >> &Qv_prim)

Definition: MOSTAverage.cpp:181

Here is the call graph for this function:

◆ update_surf_temp()

void ABLMost::update_surf_temp ( const amrex::Real & time )

inline

     {
         if (surf_heating_rate != 0) {
             int nlevs = m_geom.size();
             for (int lev = 0; lev < nlevs; lev++)
             {
                t_surf[lev]->setVal(surf_temp + surf_heating_rate*time);
                amrex::Print() << "Surface temp at t=" << time
                    << ": "
                    << surf_temp + surf_heating_rate*time
                    << std::endl;
             }
         }
     }

Member Data Documentation

◆ cnk_a

amrex::Real ABLMost::cnk_a {0.0185}

private

Referenced by ABLMost().

◆ custom_qstar

amrex::Real ABLMost::custom_qstar {0}

private

Referenced by ABLMost().

◆ custom_tstar

amrex::Real ABLMost::custom_tstar {0}

private

Referenced by ABLMost().

◆ custom_ustar

amrex::Real ABLMost::custom_ustar {0}

private

Referenced by ABLMost().

◆ depth

amrex::Real ABLMost::depth {30.0}

private

Referenced by ABLMost().

◆ flux_type

FluxCalcType ABLMost::flux_type {FluxCalcType::MOENG}

Referenced by ABLMost().

◆ m_bdy_time_interval

amrex::Real ABLMost::m_bdy_time_interval

private

◆ m_exp_most

bool ABLMost::m_exp_most = false

private

◆ m_geom

amrex::Vector<amrex::Geometry> ABLMost::m_geom

private

Referenced by ABLMost(), and update_surf_temp().

◆ m_lmask_lev

amrex::Vector<amrex::Vector<amrex::iMultiFab*> > ABLMost::m_lmask_lev

private

Referenced by ABLMost().

◆ m_lsm_data_lev

amrex::Vector<amrex::Vector<amrex::MultiFab*> > ABLMost::m_lsm_data_lev

private

Referenced by ABLMost().

◆ m_lsm_flux_lev

amrex::Vector<amrex::Vector<amrex::MultiFab*> > ABLMost::m_lsm_flux_lev

private

Referenced by ABLMost().

◆ m_ma

MOSTAverage ABLMost::m_ma

private

Referenced by get_mac_avg(), get_zref(), and update_mac_ptrs().

◆ m_sst_lev

amrex::Vector<amrex::Vector<amrex::MultiFab*> > ABLMost::m_sst_lev

private

Referenced by ABLMost().

◆ m_start_bdy_time

amrex::Real ABLMost::m_start_bdy_time

private

◆ olen

amrex::Vector<std::unique_ptr<amrex::MultiFab> > ABLMost::olen

private

Referenced by ABLMost(), and get_olen().

◆ q_star

amrex::Vector<std::unique_ptr<amrex::MultiFab> > ABLMost::q_star

private

Referenced by ABLMost().

◆ rough_type

RoughCalcType ABLMost::rough_type {RoughCalcType::CONSTANT}

Referenced by ABLMost().

◆ surf_heating_rate

amrex::Real ABLMost::surf_heating_rate {0}

private

Referenced by ABLMost(), and update_surf_temp().

◆ surf_temp

amrex::Real ABLMost::surf_temp

private

Referenced by ABLMost(), and update_surf_temp().

◆ surf_temp_flux

amrex::Real ABLMost::surf_temp_flux {0}

private

Referenced by ABLMost().

◆ t_star

amrex::Vector<std::unique_ptr<amrex::MultiFab> > ABLMost::t_star

private

Referenced by ABLMost(), and get_t_star().

◆ t_surf

amrex::Vector<std::unique_ptr<amrex::MultiFab> > ABLMost::t_surf

private

Referenced by ABLMost(), get_t_surf(), and update_surf_temp().

◆ theta_type

ThetaCalcType ABLMost::theta_type {ThetaCalcType::ADIABATIC}

Referenced by ABLMost().

◆ u_star

amrex::Vector<std::unique_ptr<amrex::MultiFab> > ABLMost::u_star

private

Referenced by ABLMost(), and get_u_star().

◆ use_moisture

bool ABLMost::use_moisture

private

Referenced by ABLMost().

◆ z0_const

amrex::Real ABLMost::z0_const

private

Referenced by ABLMost().

◆ z_0

amrex::Vector<amrex::FArrayBox> ABLMost::z_0

private

Referenced by ABLMost(), and get_z0().

The documentation for this class was generated from the following files:

Source/BoundaryConditions/ABLMost.H
Source/BoundaryConditions/ABLMost.cpp

Public Types

Public Member Functions

Public Attributes

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ FluxCalcType

◆ RoughCalcType

◆ ThetaCalcType

Constructor & Destructor Documentation

◆ ABLMost()

Member Function Documentation

◆ compute_fluxes()

◆ compute_most_bcs() [1/2]

◆ compute_most_bcs() [2/2]

◆ get_lsm_tsurf()

◆ get_mac_avg()

◆ get_olen()

◆ get_t_star()

◆ get_t_surf()

◆ get_u_star()

◆ get_z0()

◆ get_zref()

◆ impose_most_bcs()

◆ time_interp_sst()

◆ update_fluxes()

◆ update_mac_ptrs()

◆ update_surf_temp()

Member Data Documentation

◆ cnk_a

◆ custom_qstar

◆ custom_tstar

◆ custom_ustar

◆ depth

◆ flux_type

◆ m_bdy_time_interval

◆ m_exp_most

◆ m_geom

◆ m_lmask_lev

◆ m_lsm_data_lev

◆ m_lsm_flux_lev

◆ m_ma

◆ m_sst_lev

◆ m_start_bdy_time

◆ olen

◆ q_star

◆ rough_type

◆ surf_heating_rate

◆ surf_temp

◆ surf_temp_flux

◆ t_star

◆ t_surf

◆ theta_type

◆ u_star

◆ use_moisture

◆ z0_const

◆ z_0