#include <ERF_ShocDriver.H>

Collaboration diagram for ShocDriver:

[legend]

Public Member Functions
	ShocDriver (int lev, const SolverChoice &solver_choice)

void	advance (amrex::MultiFab &cons, amrex::MultiFab &xvel, amrex::MultiFab &yvel, amrex::MultiFab &zvel, amrex::MultiFab tau13, amrex::MultiFab tau23, amrex::MultiFab hfx3, amrex::MultiFab qfx3, amrex::MultiFab *eddy_diffs, amrex::MultiFab &z_phys_nd, const amrex::Geometry &geom, double dt)

void	set_eddy_diffs () const

void	set_diff_stresses () const

void	add_fast_tend (amrex::Vector< amrex::MultiFab > &S_rhs) const

void	add_slow_tend (const amrex::MFIter &mfi, const amrex::Box &tbx, const amrex::Array4< amrex::Real > &cell_rhs) const

bool	uses_state_update () const

bool	uses_host_diffusion () const

bool	uses_momentum_state_update () const

bool	uses_momentum_host_diffusion () const

bool	disables_momentum_transport () const

bool	owns_scalar_surface_fluxes () const

bool	owns_momentum_surface_stresses () const

bool	needs_host_surface_momentum_stresses () const

bool	owns_surface_fluxes () const

bool	debug_summary_enabled () const

bool	has_native_diagnostics () const

bool	has_consumed_surface_flux_diagnostics () const

const amrex::MultiFab &	native_diagnostics () const

const amrex::MultiFab &	pblh_diagnostics () const

const amrex::MultiFab &	consumed_sens_flux_diagnostics () const

const amrex::MultiFab &	consumed_laten_flux_diagnostics () const

const amrex::MultiFab &	shoc_ustar_diagnostics () const

const amrex::MultiFab &	shoc_olen_diagnostics () const

const amrex::MultiFab &	shoc_cldfrac_diagnostics () const

const amrex::MultiFab &	shoc_ql_diagnostics () const

const amrex::MultiFab &	shoc_ql2_diagnostics () const

const amrex::MultiFab &	shoc_cond_diagnostics () const

const amrex::MultiFab &	w_sec_diagnostics () const

const amrex::MultiFab &	wqls_sec_diagnostics () const

const amrex::MultiFab &	wthv_sec_diagnostics () const

const amrex::MultiFab &	thl_sec_diagnostics () const

const amrex::MultiFab &	qw_sec_diagnostics () const

const amrex::MultiFab &	qwthl_sec_diagnostics () const

const amrex::MultiFab &	wthl_sec_diagnostics () const

const amrex::MultiFab &	wqw_sec_diagnostics () const

const amrex::MultiFab &	w3_diagnostics () const

const amrex::MultiFab &	brunt_diagnostics () const

const amrex::MultiFab &	isotropy_diagnostics () const

const amrex::MultiFab &	shear_prod_diagnostics () const

const amrex::MultiFab &	buoy_prod_diagnostics () const

const amrex::MultiFab &	diss_tke_diagnostics () const

Private Member Functions
void	ensure_storage (const amrex::MultiFab &cons, const amrex::MultiFab &xvel, const amrex::MultiFab &yvel, const amrex::MultiFab &eddy_diffs)

void	seed_carried_turbulence (ShocColumnData &col, const amrex::MFIter &mfi, const amrex::MultiFab &cons, const amrex::MultiFab &eddy_diffs) const

void	store_carried_turbulence (const ShocColumnData &col, const amrex::MFIter &mfi)

void	seed_carried_buoyancy_flux (ShocColumnData &col, const amrex::MFIter &mfi) const

void	store_carried_buoyancy_flux (const ShocColumnData &col, const amrex::MFIter &mfi)

void	apply_state_update (amrex::MultiFab &cons, amrex::MultiFab &xvel, amrex::MultiFab &yvel, double dt) const

void	debug_check_bad_column (const ShocColumnData &col, const amrex::MFIter &mfi, const amrex::MultiFab &z_phys_nd, const amrex::MultiFab hfx3, const amrex::MultiFab qfx3, const amrex::MultiFab tau13, const amrex::MultiFab tau23, const amrex::Geometry &geom, double dt) const

void	print_debug_summary (double dt) const

Private Attributes
int	m_lev

ShocRuntimeOptions	m_opts

MoistureType	m_moisture_type

MoistureComponentIndices	m_moisture_indices

amrex::MultiFab	m_theta_tend_cc

amrex::MultiFab	m_qv_tend_cc

amrex::MultiFab	m_qc_tend_cc

amrex::MultiFab	m_qi_tend_cc

amrex::MultiFab	m_tke_tend_cc

amrex::MultiFab	m_u_tend_cc

amrex::MultiFab	m_v_tend_cc

amrex::MultiFab	m_u_tend_fc

amrex::MultiFab	m_v_tend_fc

amrex::MultiFab	m_eddy_coeffs_cc

amrex::MultiFab	m_prev_turb_cc

amrex::MultiFab	m_prev_wthv_sec_cc

amrex::MultiFab	m_consumed_sens_flux_cc

amrex::MultiFab	m_consumed_laten_flux_cc

amrex::MultiFab	m_pblh_cc

amrex::MultiFab	m_shoc_ustar_cc

amrex::MultiFab	m_shoc_olen_cc

amrex::MultiFab	m_shoc_cldfrac_cc

amrex::MultiFab	m_shoc_ql_cc

amrex::MultiFab	m_shoc_ql2_cc

amrex::MultiFab	m_shoc_cond_cc

amrex::MultiFab	m_w_sec_cc

amrex::MultiFab	m_wqls_sec_cc

amrex::MultiFab	m_wthv_sec_cc

amrex::MultiFab	m_thl_sec_cc

amrex::MultiFab	m_qw_sec_cc

amrex::MultiFab	m_qwthl_sec_cc

amrex::MultiFab	m_wthl_sec_cc

amrex::MultiFab	m_wqw_sec_cc

amrex::MultiFab	m_w3_cc

amrex::MultiFab	m_brunt_cc

amrex::MultiFab	m_isotropy_cc

amrex::MultiFab	m_shear_prod_cc

amrex::MultiFab	m_buoy_prod_cc

amrex::MultiFab	m_diss_tke_cc

amrex::MultiFab *	m_cons_ptr = nullptr

amrex::MultiFab *	m_hfx3_ptr = nullptr

amrex::MultiFab *	m_qfx3_ptr = nullptr

amrex::MultiFab *	m_tau13_ptr = nullptr

amrex::MultiFab *	m_tau23_ptr = nullptr

amrex::MultiFab *	m_eddy_diffs_ptr = nullptr

amrex::Vector< std::unique_ptr< ShocColumnWorkspace > >	m_column_workspaces

const amrex::Geometry *	m_geom_ptr = nullptr

int	m_advance_calls = 0

bool	m_prev_turb_valid = false

Constructor & Destructor Documentation

◆ ShocDriver()

ShocDriver::ShocDriver	(	int	lev,
		const SolverChoice &	solver_choice
	)

explicit

     : m_lev(lev),
       m_moisture_type(solver_choice.moisture_type),
       m_moisture_indices(solver_choice.moisture_indices)
 {
     read_shoc_runtime_options(m_opts);
     validate_shoc_runtime_options(m_opts);
     warn_if_shoc_debug_overrides_active_once(m_opts);
  
     std::string error_message;
     if (!shoc_driver_host_diffusion_moisture_supported(m_opts, m_moisture_type, error_message)) {
         amrex::Abort(error_message.c_str());
     }
 }

Here is the call graph for this function:

Member Function Documentation

◆ add_fast_tend()

void ShocDriver::add_fast_tend ( amrex::Vector< amrex::MultiFab > & S_rhs ) const

 {
     AMREX_ALWAYS_ASSERT(m_cons_ptr != nullptr);
  
     amrex::ignore_unused(S_rhs);
 }

Here is the call graph for this function:

◆ add_slow_tend()

void ShocDriver::add_slow_tend	(	const amrex::MFIter &	mfi,
		const amrex::Box &	tbx,
		const amrex::Array4< amrex::Real > &	cell_rhs
	)		const

 {
     AMREX_ALWAYS_ASSERT(m_cons_ptr != nullptr);
     amrex::ignore_unused(mfi, tbx, cell_rhs);
 }

Here is the call graph for this function:

◆ advance()

void ShocDriver::advance	(	amrex::MultiFab &	cons,
		amrex::MultiFab &	xvel,
		amrex::MultiFab &	yvel,
		amrex::MultiFab &	zvel,
		amrex::MultiFab *	tau13,
		amrex::MultiFab *	tau23,
		amrex::MultiFab *	hfx3,
		amrex::MultiFab *	qfx3,
		amrex::MultiFab *	eddy_diffs,
		amrex::MultiFab &	z_phys_nd,
		const amrex::Geometry &	geom,
		double	dt
	)

 {
     BL_PROFILE("SHOC::advance");
  
     require_full_height_shoc_boxes(cons.boxArray(), geom.Domain());
  
     m_cons_ptr = &cons;
     m_hfx3_ptr = hfx3;
     m_qfx3_ptr = qfx3;
     m_tau13_ptr = tau13;
     m_tau23_ptr = tau23;
     m_eddy_diffs_ptr = eddy_diffs;
     m_geom_ptr = &geom;
  
     sync_face_multifab_impl(xvel, geom);
     sync_face_multifab_impl(yvel, geom);
     if (m_tau13_ptr) {
         sync_face_multifab_impl(*m_tau13_ptr, geom);
     }
     if (m_tau23_ptr) {
         sync_face_multifab_impl(*m_tau23_ptr, geom);
     }
  
     {
         BL_PROFILE("SHOC::advance::ensure_storage");
         ensure_storage(cons, xvel, yvel, *eddy_diffs);
     }
  
     std::string error_message;
     if (!shoc_driver_state_update_layout_supported(m_opts, m_moisture_indices, cons.nComp(),
                                                     error_message)) {
         amrex::Abort(error_message.c_str());
     }
  
     // Keep one SHOC column workspace per local box so GPU writeback kernels
     // can finish reading a box's scratch before it is reused.
     const amrex::Long n_local = cons.local_size();
     AMREX_ALWAYS_ASSERT(n_local >= amrex::Long{0});
     const amrex::Long current_size = static_cast<amrex::Long>(m_column_workspaces.size());
     if (current_size < n_local) {
         const amrex::Long old_size = current_size;
         m_column_workspaces.resize(static_cast<std::size_t>(n_local));
         for (amrex::Long n = old_size; n < n_local; ++n) {
             m_column_workspaces[static_cast<std::size_t>(n)] =
                 std::make_unique<ShocColumnWorkspace>();
         }
     }
  
     amrex::Long local_index = 0;
     for (MFIter mfi(cons, false); mfi.isValid(); ++mfi, ++local_index) {
         AMREX_ALWAYS_ASSERT(
             local_index < static_cast<amrex::Long>(m_column_workspaces.size()));
         ShocColumnWorkspace& workspace =
             *m_column_workspaces[static_cast<std::size_t>(local_index)];
         const Box& vbx = mfi.validbox();
         const ShocColumnLayout active_layout = make_shoc_layout(vbx, geom);
         {
             BL_PROFILE("SHOC::advance::define_column_data");
             workspace.ensure_capacity(active_layout, amrex::The_Async_Arena(),
                                       shoc::default_init_run_on());
         }
         ShocColumnData& col = workspace.col;
         {
             BL_PROFILE("SHOC::advance::preprocess");
             ShocPreprocess::fill_columns(col, mfi, cons, xvel, yvel, zvel,
                                          hfx3, qfx3, tau13, tau23, z_phys_nd, geom,
                                          m_moisture_indices);
         }
         {
             BL_PROFILE("SHOC::advance::seed_carried_buoyancy_flux");
             seed_carried_buoyancy_flux(col, mfi);
         }
         {
             BL_PROFILE("SHOC::advance::seed_carried_turbulence");
             seed_carried_turbulence(col, mfi, cons, *eddy_diffs);
         }
         const auto dx = geom.CellSizeArray();
         if (uses_state_update()) {
             BL_PROFILE("SHOC::advance::cache_baseline_state");
             ShocImplicit::cache_baseline_state(col);
         }
         ShocDiagnostics::diagnose_pre_implicit(col, m_opts, dx[0], dx[1], dt);
         if (uses_state_update()) {
             BL_PROFILE("SHOC::advance::implicit");
             ShocImplicit::advance_implicit_state(col, m_opts, dt);
         }
         ShocDiagnostics::diagnose_post_implicit(col, m_opts, dt);
         if (uses_state_update()) {
             BL_PROFILE("SHOC::advance::finalize");
             ShocImplicit::finalize_from_pdf(col, m_opts, dt);
             BL_PROFILE("SHOC::advance::debug_bad_column");
             debug_check_bad_column(col, mfi, z_phys_nd, hfx3, qfx3, tau13, tau23, geom, dt);
         }
         {
             BL_PROFILE("SHOC::advance::store_carried_buoyancy_flux");
             store_carried_buoyancy_flux(col, mfi);
         }
         {
             BL_PROFILE("SHOC::advance::store_carried_turbulence");
             store_carried_turbulence(col, mfi);
         }
  
         auto tk_arr = m_eddy_coeffs_cc.array(mfi);
         auto th_tend = m_theta_tend_cc.array(mfi);
         auto qv_tend = m_qv_tend_cc.array(mfi);
         auto qc_tend = m_qc_tend_cc.array(mfi);
         auto qi_tend = m_qi_tend_cc.array(mfi);
         auto tke_tend = m_tke_tend_cc.array(mfi);
         auto u_tend_cc = m_u_tend_cc.array(mfi);
         auto v_tend_cc = m_v_tend_cc.array(mfi);
         auto pblh_arr = m_pblh_cc.array(mfi);
         auto consumed_sens_flux_arr = m_consumed_sens_flux_cc.array(mfi);
         auto consumed_laten_flux_arr = m_consumed_laten_flux_cc.array(mfi);
         auto shoc_ustar_arr = m_shoc_ustar_cc.array(mfi);
         auto shoc_olen_arr = m_shoc_olen_cc.array(mfi);
         auto shoc_cldfrac_arr = m_shoc_cldfrac_cc.array(mfi);
         auto shoc_ql_arr = m_shoc_ql_cc.array(mfi);
         auto shoc_ql2_arr = m_shoc_ql2_cc.array(mfi);
         auto shoc_cond_arr = m_shoc_cond_cc.array(mfi);
         auto w_sec_arr = m_w_sec_cc.array(mfi);
         auto wqls_sec_arr = m_wqls_sec_cc.array(mfi);
         auto wthv_sec_arr = m_wthv_sec_cc.array(mfi);
         auto thl_sec_arr = m_thl_sec_cc.array(mfi);
         auto qw_sec_arr = m_qw_sec_cc.array(mfi);
         auto qwthl_sec_arr = m_qwthl_sec_cc.array(mfi);
         auto wthl_sec_arr = m_wthl_sec_cc.array(mfi);
         auto wqw_sec_arr = m_wqw_sec_cc.array(mfi);
         auto w3_arr = m_w3_cc.array(mfi);
         auto brunt_arr = m_brunt_cc.array(mfi);
         auto isotropy_arr = m_isotropy_cc.array(mfi);
         auto shear_prod_arr = m_shear_prod_cc.array(mfi);
         auto buoy_prod_arr = m_buoy_prod_cc.array(mfi);
         auto diss_tke_arr = m_diss_tke_cc.array(mfi);
  
         const auto shoc_mix = col.shoc_mix.const_array();
         const auto pblh = col.pblh.const_array();
         const auto surf_sens_flux = col.surf_sens_flux.const_array();
         const auto surf_lat_flux = col.surf_lat_flux.const_array();
         const auto ustar = col.ustar.const_array();
         const auto obklen = col.obklen.const_array();
         const auto shoc_cldfrac = col.shoc_cldfrac.const_array();
         const auto shoc_ql = col.shoc_ql.const_array();
         const auto shoc_ql2 = col.shoc_ql2.const_array();
         const auto shoc_cond = col.shoc_cond.const_array();
         const auto w_sec = col.w_sec.const_array();
         const auto wqls_sec = col.wqls_sec.const_array();
         const auto wthv_sec = col.wthv_sec.const_array();
         const auto thl_sec = col.thl_sec.const_array();
         const auto qw_sec = col.qw_sec.const_array();
         const auto qwthl_sec = col.qwthl_sec.const_array();
         const auto wthl_sec = col.wthl_sec.const_array();
         const auto wqw_sec = col.wqw_sec.const_array();
         const auto w3 = col.w3.const_array();
         const auto brunt = col.brunt.const_array();
         const auto isotropy = col.isotropy.const_array();
         const auto shear_prod = col.shear_prod.const_array();
         const auto buoy_prod = col.buoy_prod.const_array();
         const auto diss_tke = col.diss_tke.const_array();
         const auto tk = col.tk.const_array();
         const auto tkh = col.tkh.const_array();
         const auto rho = col.rho.const_array();
         const auto zt = col.zt.const_array();
         const auto zi = col.zi.const_array();
         const auto col_theta_tend = col.theta_tend.const_array();
         const auto col_qv_tend = col.qv_tend.const_array();
         const auto col_qc_tend = col.qc_tend.const_array();
         const auto col_qi_tend = col.qi_tend.const_array();
         const auto col_tke_tend = col.tke_tend.const_array();
         const auto col_u_tend = col.u_tend.const_array();
         const auto col_v_tend = col.v_tend.const_array();
         const auto layout = col.layout;
         const Box xy_box = amrex::makeSlab(vbx, 2, layout.kmin);
         {
             BL_PROFILE("SHOC::advance::writeback");
             ParallelFor(xy_box, [=] AMREX_GPU_DEVICE (int i, int j, int) noexcept
             {
                 const int ic = shoc_column_index(layout, i, j);
                 const int k0 = layout.kmin;
                 const Real rho_sfc = rho(ic,0,0);
                 for (int kk = 0; kk < layout.nlev; ++kk) {
                     const int k = layout.kmin + kk;
                     const Real l = shoc_mix(ic,kk,0);
                     const Real km = tk(ic,kk,0);
                     const Real kh = tkh(ic,kk,0);
  
                     tk_arr(i,j,k,EddyDiff::Mom_v) = rho(ic,kk,0) * km;
                     tk_arr(i,j,k,EddyDiff::Theta_v) = rho(ic,kk,0) * kh;
                     tk_arr(i,j,k,EddyDiff::KE_v) = rho(ic,kk,0) * kh;
                     tk_arr(i,j,k,EddyDiff::Scalar_v) = rho(ic,kk,0) * kh;
                     tk_arr(i,j,k,EddyDiff::Q_v) = rho(ic,kk,0) * kh;
                     tk_arr(i,j,k,EddyDiff::Turb_lengthscale) = l;
  
                     th_tend(i,j,k) = col_theta_tend(ic,kk,0);
                     qv_tend(i,j,k) = col_qv_tend(ic,kk,0);
                     qc_tend(i,j,k) = col_qc_tend(ic,kk,0);
                     qi_tend(i,j,k) = col_qi_tend(ic,kk,0);
                     tke_tend(i,j,k) = col_tke_tend(ic,kk,0);
                     u_tend_cc(i,j,k) = col_u_tend(ic,kk,0);
                     v_tend_cc(i,j,k) = col_v_tend(ic,kk,0);
                     // Native SHOC pblh is diagnosed as meters AGL and is
                     // copied directly into the plotfile diagnostic field.
                     pblh_arr(i,j,k) = pblh(ic,0,0);
                     shoc_cldfrac_arr(i,j,k) = shoc_cldfrac(ic,kk,0);
                     shoc_ql_arr(i,j,k) = shoc_ql(ic,kk,0);
                     shoc_ql2_arr(i,j,k) = shoc_ql2(ic,kk,0);
                     shoc_cond_arr(i,j,k) = shoc_cond(ic,kk,0);
                     w_sec_arr(i,j,k) = w_sec(ic,kk,0);
                     wqls_sec_arr(i,j,k) = wqls_sec(ic,kk,0);
                     wthv_sec_arr(i,j,k) = wthv_sec(ic,kk,0);
                     brunt_arr(i,j,k) = brunt(ic,kk,0);
                     isotropy_arr(i,j,k) = isotropy(ic,kk,0);
                     thl_sec_arr(i,j,k) = weighted_linear_interp(zi(ic,kk,0), zi(ic,kk+1,0),
                                                                 thl_sec(ic,kk,0), thl_sec(ic,kk+1,0),
                                                                 zt(ic,kk,0));
                     qw_sec_arr(i,j,k) = weighted_linear_interp(zi(ic,kk,0), zi(ic,kk+1,0),
                                                                qw_sec(ic,kk,0), qw_sec(ic,kk+1,0),
                                                                zt(ic,kk,0));
                     qwthl_sec_arr(i,j,k) = weighted_linear_interp(zi(ic,kk,0), zi(ic,kk+1,0),
                                                                   qwthl_sec(ic,kk,0), qwthl_sec(ic,kk+1,0),
                                                                   zt(ic,kk,0));
                     wthl_sec_arr(i,j,k) = weighted_linear_interp(zi(ic,kk,0), zi(ic,kk+1,0),
                                                                  wthl_sec(ic,kk,0), wthl_sec(ic,kk+1,0),
                                                                  zt(ic,kk,0));
                     wqw_sec_arr(i,j,k) = weighted_linear_interp(zi(ic,kk,0), zi(ic,kk+1,0),
                                                                 wqw_sec(ic,kk,0), wqw_sec(ic,kk+1,0),
                                                                 zt(ic,kk,0));
                     w3_arr(i,j,k) = weighted_linear_interp(zi(ic,kk,0), zi(ic,kk+1,0),
                                                            w3(ic,kk,0), w3(ic,kk+1,0),
                                                            zt(ic,kk,0));
                     shear_prod_arr(i,j,k) = shear_prod(ic,kk,0);
                     buoy_prod_arr(i,j,k) = buoy_prod(ic,kk,0);
                     diss_tke_arr(i,j,k) = diss_tke(ic,kk,0);
                 }
                 // Motivation: Native SHOC state_update consumes SurfaceLayer
                 // fluxes before the host diffusion path clears the overlapping
                 // SFS arrays. Preserve the consumed conservative fluxes here
                 // so 2D diagnostics report the surface forcing SHOC actually
                 // used, not the cleared host arrays.
                 consumed_sens_flux_arr(i,j,k0) = rho_sfc * surf_sens_flux(ic,0,0);
                 consumed_laten_flux_arr(i,j,k0) = rho_sfc * surf_lat_flux(ic,0,0);
                 shoc_ustar_arr(i,j,k0) = ustar(ic,0,0);
                 shoc_olen_arr(i,j,k0) = obklen(ic,0,0);
                 });
         }
  
     }
  
     {
         BL_PROFILE("SHOC::advance::tendency_interpolation");
         m_u_tend_cc.FillBoundary(geom.periodicity());
         m_v_tend_cc.FillBoundary(geom.periodicity());
  
         const auto dom = geom.Domain();
         const int ilo = dom.smallEnd(0);
         const int ihi = dom.bigEnd(0);
         const int jlo = dom.smallEnd(1);
         const int jhi = dom.bigEnd(1);
         const bool xper = geom.isPeriodic(0);
         const bool yper = geom.isPeriodic(1);
  
         for (MFIter mfi(m_u_tend_cc, false); mfi.isValid(); ++mfi) {
             const Box& cc_bx = mfi.validbox();
             const Box xface_bx = amrex::surroundingNodes(cc_bx, 0);
             const Box yface_bx = amrex::surroundingNodes(cc_bx, 1);
             const auto u_cc = m_u_tend_cc.const_array(mfi);
             const auto v_cc = m_v_tend_cc.const_array(mfi);
             auto u_fc = m_u_tend_fc.array(mfi);
             auto v_fc = m_v_tend_fc.array(mfi);
  
             ParallelFor(xface_bx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
             {
                 const int il = face_neighbor_cell(i - 1, ilo, ihi, xper);
                 const int ir = face_neighbor_cell(i,     ilo, ihi, xper);
                 u_fc(i,j,k) = 0.5_rt * (u_cc(il,j,k) + u_cc(ir,j,k));
             });
  
             ParallelFor(yface_bx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
             {
                 const int jb = face_neighbor_cell(j - 1, jlo, jhi, yper);
                 const int jt = face_neighbor_cell(j,     jlo, jhi, yper);
                 v_fc(i,j,k) = 0.5_rt * (v_cc(i,jb,k) + v_cc(i,jt,k));
             });
         }
     }
  
     if (uses_state_update()) {
         sync_face_multifab_impl(m_u_tend_fc, geom);
         sync_face_multifab_impl(m_v_tend_fc, geom);
     }
  
     if (uses_state_update()) {
         BL_PROFILE("SHOC::advance::state_update");
         apply_state_update(cons, xvel, yvel, dt);
     }
  
     if (uses_momentum_state_update()) {
         sync_face_multifab_impl(xvel, geom);
         sync_face_multifab_impl(yvel, geom);
     }
  
     m_prev_turb_valid = true;
     ++m_advance_calls;
     if (m_opts.debug_summary) {
         BL_PROFILE("SHOC::advance::debug_summary");
         print_debug_summary(dt);
     }
 }

Here is the call graph for this function:

◆ apply_state_update()

void ShocDriver::apply_state_update	(	amrex::MultiFab &	cons,
		amrex::MultiFab &	xvel,
		amrex::MultiFab &	yvel,
		double	dt
	)		const

private

 {
     AMREX_ALWAYS_ASSERT(dt > 0.0);
  
     apply_state_update_cons_impl(cons,
                                  m_theta_tend_cc,
                                  m_qv_tend_cc,
                                  m_qc_tend_cc,
                                  m_qi_tend_cc,
                                  m_tke_tend_cc,
                                  m_moisture_indices.qv,
                                  m_moisture_indices.qc,
                                  m_moisture_indices.qi,
                                  m_opts,
                                  dt);
  
     if (uses_momentum_state_update()) {
         apply_state_update_face_velocity_impl(xvel, m_u_tend_fc, dt);
         apply_state_update_face_velocity_impl(yvel, m_v_tend_fc, dt);
     }
 }

Referenced by advance().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ brunt_diagnostics()

const amrex::MultiFab& ShocDriver::brunt_diagnostics ( ) const

inline

126 { return m_brunt_cc; }

◆ buoy_prod_diagnostics()

const amrex::MultiFab& ShocDriver::buoy_prod_diagnostics ( ) const

inline

129 { return m_buoy_prod_cc; }

◆ consumed_laten_flux_diagnostics()

const amrex::MultiFab& ShocDriver::consumed_laten_flux_diagnostics ( ) const

inline

     {
         return m_consumed_laten_flux_cc;
     }

Referenced by ERF::Write2DPlotFile().

Here is the caller graph for this function:

◆ consumed_sens_flux_diagnostics()

const amrex::MultiFab& ShocDriver::consumed_sens_flux_diagnostics ( ) const

inline

     {
         return m_consumed_sens_flux_cc;
     }

Referenced by ERF::Write2DPlotFile().

Here is the caller graph for this function:

◆ debug_check_bad_column()

void ShocDriver::debug_check_bad_column	(	const ShocColumnData &	col,
		const amrex::MFIter &	mfi,
		const amrex::MultiFab &	z_phys_nd,
		const amrex::MultiFab *	hfx3,
		const amrex::MultiFab *	qfx3,
		const amrex::MultiFab *	tau13,
		const amrex::MultiFab *	tau23,
		const amrex::Geometry &	geom,
		double	dt
	)		const

private

 {
     amrex::ignore_unused(geom, dt_d);
  
     if (!m_opts.debug_bad_column) {
         return;
     }
  
     AMREX_ALWAYS_ASSERT(m_cons_ptr != nullptr);
     print_shoc_debug_settings_once(m_opts);
  
     const auto cons_host = copy_fab_to_host((*m_cons_ptr)[mfi]);
     const auto z_host = copy_fab_to_host(z_phys_nd[mfi]);
     const auto theta_tend_host = copy_fab_to_host(col.theta_tend);
     const auto qv_tend_host = copy_fab_to_host(col.qv_tend);
     const auto qc_tend_host = copy_fab_to_host(col.qc_tend);
     const auto qi_tend_host = copy_fab_to_host(col.qi_tend);
     const auto tke_tend_host = copy_fab_to_host(col.tke_tend);
     const auto u_tend_host = copy_fab_to_host(col.u_tend);
     const auto v_tend_host = copy_fab_to_host(col.v_tend);
     const auto p_mid_host = copy_fab_to_host(col.p_mid);
     const auto p_int_host = copy_fab_to_host(col.p_int);
     const auto zt_host = copy_fab_to_host(col.zt);
     const auto zi_host = copy_fab_to_host(col.zi);
     const auto dz_host = copy_fab_to_host(col.dz);
     const auto rho_host = copy_fab_to_host(col.rho);
     const auto theta_host = copy_fab_to_host(col.theta);
     const auto thetal_host = copy_fab_to_host(col.thetal);
     const auto theta_base_host = copy_fab_to_host(col.theta_base);
     const auto thetal_base_host = copy_fab_to_host(col.thetal_base);
     const auto qv_base_host = copy_fab_to_host(col.qv_base);
     const auto qc_base_host = copy_fab_to_host(col.qc_base);
     const auto qi_base_host = copy_fab_to_host(col.qi_base);
     const auto tke_base_host = copy_fab_to_host(col.tke_base_state);
     const auto theta_v_host = copy_fab_to_host(col.theta_v);
     const auto qv_host = copy_fab_to_host(col.qv);
     const auto qc_host = copy_fab_to_host(col.qc);
     const auto qi_host = copy_fab_to_host(col.qi);
     const auto qw_host = copy_fab_to_host(col.qw);
     const auto tabs_host = copy_fab_to_host(col.tabs);
     const auto exner_host = copy_fab_to_host(col.exner);
     const auto host_dse_host = copy_fab_to_host(col.host_dse);
     const auto pblh_host = copy_fab_to_host(col.pblh);
     const auto obklen_host = copy_fab_to_host(col.obklen);
     const auto ustar_host = copy_fab_to_host(col.ustar);
     const auto shoc_mix_host = copy_fab_to_host(col.shoc_mix);
     const auto brunt_host = copy_fab_to_host(col.brunt);
     const auto isotropy_host = copy_fab_to_host(col.isotropy);
     const auto tk_host = copy_fab_to_host(col.tk);
     const auto tkh_host = copy_fab_to_host(col.tkh);
     const auto shear_prod_host = copy_fab_to_host(col.shear_prod);
     const auto buoy_prod_host = copy_fab_to_host(col.buoy_prod);
     const auto diss_tke_host = copy_fab_to_host(col.diss_tke);
     const auto tke_host = copy_fab_to_host(col.tke);
     const auto w_sec_host = copy_fab_to_host(col.w_sec);
     const auto wthv_sec_host = copy_fab_to_host(col.wthv_sec);
     const auto shoc_cldfrac_host = copy_fab_to_host(col.shoc_cldfrac);
     const auto shoc_ql_host = copy_fab_to_host(col.shoc_ql);
     const auto shoc_ql2_host = copy_fab_to_host(col.shoc_ql2);
     const auto shoc_cond_host = copy_fab_to_host(col.shoc_cond);
     const auto shoc_evap_host = copy_fab_to_host(col.shoc_evap);
     const auto wqls_sec_host = copy_fab_to_host(col.wqls_sec);
     const auto thl_sec_host = copy_fab_to_host(col.thl_sec);
     const auto qw_sec_host = copy_fab_to_host(col.qw_sec);
     const auto qwthl_sec_host = copy_fab_to_host(col.qwthl_sec);
     const auto wthl_sec_host = copy_fab_to_host(col.wthl_sec);
     const auto wqw_sec_host = copy_fab_to_host(col.wqw_sec);
     const auto uw_sec_host = copy_fab_to_host(col.uw_sec);
     const auto vw_sec_host = copy_fab_to_host(col.vw_sec);
     const auto wtke_sec_host = copy_fab_to_host(col.wtke_sec);
     const auto w3_host = copy_fab_to_host(col.w3);
     const auto surf_sens_flux_host = copy_fab_to_host(col.surf_sens_flux);
     const auto surf_lat_flux_host = copy_fab_to_host(col.surf_lat_flux);
     const auto surf_tau_u_host = copy_fab_to_host(col.surf_tau_u);
     const auto surf_tau_v_host = copy_fab_to_host(col.surf_tau_v);
     const auto hfx3_host = hfx3 ? copy_fab_to_host((*hfx3)[mfi]) : FArrayBox();
     const auto qfx3_host = qfx3 ? copy_fab_to_host((*qfx3)[mfi]) : FArrayBox();
     const auto tau13_host = tau13 ? copy_fab_to_host((*tau13)[mfi]) : FArrayBox();
     const auto tau23_host = tau23 ? copy_fab_to_host((*tau23)[mfi]) : FArrayBox();
  
     const auto z_arr = z_host.const_array();
     const auto cons_arr = cons_host.const_array();
     const auto theta_tend_arr = theta_tend_host.const_array();
     const auto qv_tend_arr = qv_tend_host.const_array();
     const auto qc_tend_arr = qc_tend_host.const_array();
     const auto qi_tend_arr = qi_tend_host.const_array();
     const auto tke_tend_arr = tke_tend_host.const_array();
     const auto u_tend_arr = u_tend_host.const_array();
     const auto v_tend_arr = v_tend_host.const_array();
     const auto dz_arr = dz_host.const_array();
  
     std::vector<ShocBadColumnReport> reports;
     reports.reserve(static_cast<std::size_t>(col.layout.ncell * col.layout.nlev));
  
     auto maybe_add = [&] (int i, int j, int k, int kk, int ic,
                           const char* name, Real value, Real threshold) {
         if (!std::isfinite(value)) {
             reports.push_back(ShocBadColumnReport{
                 std::numeric_limits<Real>::infinity(),
                 std::string(name) + " nonfinite",
                 mfi.index(), i, j, k, kk, ic
             });
             return;
         }
         const Real abs_value = amrex::Math::abs(value);
         const Real ratio = abs_value / threshold;
         if (ratio > 1.0_rt) {
             std::ostringstream oss;
             oss << name << " |value|=" << abs_value << " threshold=" << threshold;
             reports.push_back(ShocBadColumnReport{ratio, oss.str(), mfi.index(), i, j, k, kk, ic});
         }
     };
  
     auto maybe_add_geom = [&] (int i, int j, int k, int kk, int ic, Real dz_val) {
         if (!std::isfinite(dz_val)) {
             reports.push_back(ShocBadColumnReport{
                 std::numeric_limits<Real>::infinity(),
                 "dz nonfinite",
                 mfi.index(), i, j, k, kk, ic
             });
         } else if (dz_val <= 0.0_rt) {
             reports.push_back(ShocBadColumnReport{
                 std::numeric_limits<Real>::infinity(),
                 "dz <= 0",
                 mfi.index(), i, j, k, kk, ic
             });
         } else if (dz_val < m_opts.debug_bad_column_min_dz) {
             std::ostringstream oss;
             oss << "dz below minimum |dz|=" << dz_val
                 << " min_dz=" << m_opts.debug_bad_column_min_dz;
             reports.push_back(ShocBadColumnReport{
                 m_opts.debug_bad_column_min_dz / dz_val,
                 oss.str(),
                 mfi.index(), i, j, k, kk, ic
             });
         }
     };
  
     for (int j = col.layout.jmin; j < col.layout.jmin + col.layout.ny; ++j) {
         for (int i = col.layout.imin; i < col.layout.imin + col.layout.nx; ++i) {
             const int ic = shoc_column_index(col.layout, i, j);
             for (int kk = 0; kk < col.layout.nlev; ++kk) {
                 const int k = col.layout.kmin + kk;
                 const Real dz_val = dz_arr(ic, kk, 0);
                 maybe_add_geom(i, j, k, kk, ic, dz_val);
  
                 maybe_add(i, j, k, kk, ic, "theta_tend", theta_tend_arr(ic, kk, 0), m_opts.debug_bad_column_theta_tend_threshold);
                 maybe_add(i, j, k, kk, ic, "qv_tend", qv_tend_arr(ic, kk, 0), m_opts.debug_bad_column_q_tend_threshold);
                 maybe_add(i, j, k, kk, ic, "qc_tend", qc_tend_arr(ic, kk, 0), m_opts.debug_bad_column_q_tend_threshold);
                 maybe_add(i, j, k, kk, ic, "qi_tend", qi_tend_arr(ic, kk, 0), m_opts.debug_bad_column_q_tend_threshold);
                 maybe_add(i, j, k, kk, ic, "brunt", brunt_host.const_array()(ic, kk, 0), m_opts.debug_bad_column_brunt_threshold);
                 maybe_add(i, j, k, kk, ic, "thl_sec", thl_sec_host.const_array()(ic, kk, 0), m_opts.debug_bad_column_scalar_moment_threshold);
                 maybe_add(i, j, k, kk, ic, "qw_sec", qw_sec_host.const_array()(ic, kk, 0), m_opts.debug_bad_column_scalar_moment_threshold);
                 maybe_add(i, j, k, kk, ic, "qwthl_sec", qwthl_sec_host.const_array()(ic, kk, 0), m_opts.debug_bad_column_scalar_moment_threshold);
                 maybe_add(i, j, k, kk, ic, "wthl_sec", wthl_sec_host.const_array()(ic, kk, 0), m_opts.debug_bad_column_scalar_moment_threshold);
                 maybe_add(i, j, k, kk, ic, "wqw_sec", wqw_sec_host.const_array()(ic, kk, 0), m_opts.debug_bad_column_scalar_moment_threshold);
  
                 // Treat NaN/Inf in the key state and diagnostic fields as bad.
                 const Real key_values[] = {
                     rho_host.const_array()(ic, kk, 0),
                     theta_host.const_array()(ic, kk, 0),
                     thetal_host.const_array()(ic, kk, 0),
                     theta_v_host.const_array()(ic, kk, 0),
                     qv_host.const_array()(ic, kk, 0),
                     qc_host.const_array()(ic, kk, 0),
                     qi_host.const_array()(ic, kk, 0),
                     qw_host.const_array()(ic, kk, 0),
                     tabs_host.const_array()(ic, kk, 0),
                     exner_host.const_array()(ic, kk, 0),
                     p_mid_host.const_array()(ic, kk, 0),
                     host_dse_host.const_array()(ic, kk, 0),
                     pblh_host.const_array()(ic, 0, 0),
                     obklen_host.const_array()(ic, 0, 0),
                     ustar_host.const_array()(ic, 0, 0),
                     shoc_mix_host.const_array()(ic, kk, 0),
                     isotropy_host.const_array()(ic, kk, 0),
                     tk_host.const_array()(ic, kk, 0),
                     tkh_host.const_array()(ic, kk, 0),
                     shear_prod_host.const_array()(ic, kk, 0),
                     buoy_prod_host.const_array()(ic, kk, 0),
                     diss_tke_host.const_array()(ic, kk, 0),
                     w_sec_host.const_array()(ic, kk, 0),
                     wthv_sec_host.const_array()(ic, kk, 0),
                     shoc_cldfrac_host.const_array()(ic, kk, 0),
                     shoc_ql_host.const_array()(ic, kk, 0),
                     shoc_ql2_host.const_array()(ic, kk, 0),
                     shoc_cond_host.const_array()(ic, kk, 0),
                     shoc_evap_host.const_array()(ic, kk, 0),
                     wqls_sec_host.const_array()(ic, kk, 0),
                     thl_sec_host.const_array()(ic, kk, 0),
                     qw_sec_host.const_array()(ic, kk, 0),
                     qwthl_sec_host.const_array()(ic, kk, 0),
                     wthl_sec_host.const_array()(ic, kk, 0),
                     wqw_sec_host.const_array()(ic, kk, 0),
                     uw_sec_host.const_array()(ic, kk, 0),
                     vw_sec_host.const_array()(ic, kk, 0),
                     wtke_sec_host.const_array()(ic, kk, 0),
                     w3_host.const_array()(ic, kk, 0),
                     theta_tend_arr(ic, kk, 0),
                     qv_tend_arr(ic, kk, 0),
                     qc_tend_arr(ic, kk, 0),
                     qi_tend_arr(ic, kk, 0),
                     tke_tend_arr(ic, kk, 0),
                     u_tend_arr(ic, kk, 0),
                     v_tend_arr(ic, kk, 0)
                 };
                 for (Real value : key_values) {
                     if (!std::isfinite(value)) {
                         reports.push_back(ShocBadColumnReport{
                             std::numeric_limits<Real>::infinity(),
                             "key field nonfinite",
                             mfi.index(), i, j, k, kk, ic
                         });
                         break;
                     }
                 }
             }
         }
     }
  
     if (reports.empty()) {
         return;
     }
  
     std::stable_sort(reports.begin(), reports.end(),
                      [] (const ShocBadColumnReport& a, const ShocBadColumnReport& b) {
                          return a.score > b.score;
                      });
  
     const int max_reports = std::min(m_opts.debug_bad_column_max_reports,
                                      static_cast<int>(reports.size()));
  
     const auto rho_arr = rho_host.const_array();
     const auto theta_arr = theta_host.const_array();
     const auto thetal_arr = thetal_host.const_array();
     const auto theta_base_arr = theta_base_host.const_array();
     const auto thetal_base_arr = thetal_base_host.const_array();
     const auto qv_base_arr = qv_base_host.const_array();
     const auto qc_base_arr = qc_base_host.const_array();
     const auto qi_base_arr = qi_base_host.const_array();
     const auto theta_v_arr = theta_v_host.const_array();
     const auto qv_arr = qv_host.const_array();
     const auto qc_arr = qc_host.const_array();
     const auto qi_arr = qi_host.const_array();
     const auto qw_arr = qw_host.const_array();
     const auto tabs_arr = tabs_host.const_array();
     const auto exner_arr = exner_host.const_array();
     const auto p_mid_arr = p_mid_host.const_array();
     const auto p_int_arr = p_int_host.const_array();
     const auto host_dse_arr = host_dse_host.const_array();
     const auto pblh_arr = pblh_host.const_array();
     const auto obklen_arr = obklen_host.const_array();
     const auto ustar_arr = ustar_host.const_array();
     const auto shoc_mix_arr = shoc_mix_host.const_array();
     const auto brunt_arr = brunt_host.const_array();
     const auto isotropy_arr = isotropy_host.const_array();
     const auto tk_arr = tk_host.const_array();
     const auto tkh_arr = tkh_host.const_array();
     const auto shear_prod_arr = shear_prod_host.const_array();
     const auto buoy_prod_arr = buoy_prod_host.const_array();
     const auto diss_tke_arr = diss_tke_host.const_array();
     const auto tke_state_arr = tke_host.const_array();
     const auto tke_base_arr = tke_base_host.const_array();
     const auto w_sec_arr = w_sec_host.const_array();
     const auto wthv_sec_arr = wthv_sec_host.const_array();
     const auto shoc_cldfrac_arr = shoc_cldfrac_host.const_array();
     const auto shoc_ql_arr = shoc_ql_host.const_array();
     const auto shoc_ql2_arr = shoc_ql2_host.const_array();
     const auto shoc_cond_arr = shoc_cond_host.const_array();
     const auto shoc_evap_arr = shoc_evap_host.const_array();
     const auto wqls_sec_arr = wqls_sec_host.const_array();
     const auto thl_sec_arr = thl_sec_host.const_array();
     const auto qw_sec_arr = qw_sec_host.const_array();
     const auto qwthl_sec_arr = qwthl_sec_host.const_array();
     const auto wthl_sec_arr = wthl_sec_host.const_array();
     const auto wqw_sec_arr = wqw_sec_host.const_array();
     const auto uw_sec_arr = uw_sec_host.const_array();
     const auto vw_sec_arr = vw_sec_host.const_array();
     const auto wtke_sec_arr = wtke_sec_host.const_array();
     const auto w3_arr = w3_host.const_array();
     const auto surf_sens_flux_arr = surf_sens_flux_host.const_array();
     const auto surf_lat_flux_arr = surf_lat_flux_host.const_array();
     const auto surf_tau_u_arr = surf_tau_u_host.const_array();
     const auto surf_tau_v_arr = surf_tau_v_host.const_array();
     const bool has_hfx3 = hfx3 && hfx3_host.box().ok();
     const bool has_qfx3 = qfx3 && qfx3_host.box().ok();
     const bool has_tau13 = tau13 && tau13_host.box().ok();
     const bool has_tau23 = tau23 && tau23_host.box().ok();
  
     for (int n = 0; n < max_reports; ++n) {
         const auto& rep = reports[static_cast<std::size_t>(n)];
         const int i = rep.i;
         const int j = rep.j;
         const int k = rep.k;
         const int kk = rep.kk;
         const int ic = rep.ic;
  
         const auto node_value = [&] (int iii, int jjj, int kkk) -> Real {
             const IntVect iv(iii, jjj, kkk);
             return z_host.box().contains(iv) ? z_arr(iii, jjj, kkk) : std::numeric_limits<Real>::quiet_NaN();
         };
  
         const Real z_nd_ijk = node_value(i, j, k);
         const Real z_nd_ip1jk = node_value(i + 1, j, k);
         const Real z_nd_ijp1k = node_value(i, j + 1, k);
         const Real z_nd_ip1jp1k = node_value(i + 1, j + 1, k);
         const Real z_nd_ijkp1 = node_value(i, j, k + 1);
         const Real z_nd_ip1jkp1 = node_value(i + 1, j, k + 1);
         const Real z_nd_ijp1kp1 = node_value(i, j + 1, k + 1);
         const Real z_nd_ip1jp1kp1 = node_value(i + 1, j + 1, k + 1);
         const Real four_node_zlo = 0.25_rt * (z_nd_ijk + z_nd_ip1jk + z_nd_ijp1k + z_nd_ip1jp1k);
         const Real four_node_zhi = 0.25_rt * (z_nd_ijkp1 + z_nd_ip1jkp1 + z_nd_ijp1kp1 + z_nd_ip1jp1kp1);
         const Real four_node_dz = four_node_zhi - four_node_zlo;
         const Real corner_dz = z_nd_ijkp1 - z_nd_ijk;
         const Real theta_base_val = theta_base_arr(ic, kk, 0);
         const Real theta_new_val = theta_arr(ic, kk, 0);
         const Real thetal_base_val = thetal_base_arr(ic, kk, 0);
         const Real thetal_new_val = thetal_arr(ic, kk, 0);
         const Real qv_base_val = qv_base_arr(ic, kk, 0);
         const Real qc_base_val = qc_base_arr(ic, kk, 0);
         const Real qi_base_val = qi_base_arr(ic, kk, 0);
         const Real qv_new_val = qv_arr(ic, kk, 0);
         const Real qc_new_val = qc_arr(ic, kk, 0);
         const Real qi_new_val = qi_arr(ic, kk, 0);
         const Real ql_base = qc_base_val + qi_base_val;
         const Real ql_new = qc_new_val + qi_new_val;
         const Real qw_base = qv_base_val + qc_base_val + qi_base_val;
         const Real qw_new = qv_new_val + qc_new_val + qi_new_val;
         const Real delta_theta = theta_new_val - theta_base_val;
         const Real delta_qv = qv_new_val - qv_base_val;
         const Real delta_qc = qc_new_val - qc_base_val;
         const Real delta_qi = qi_new_val - qi_base_val;
         const Real delta_ql = ql_new - ql_base;
         const Real delta_qw = qw_new - qw_base;
  
         const Real dt = static_cast<Real>(dt_d);
  
         const Real dt_theta_tend = theta_tend_arr(ic, kk, 0) * dt;
         const Real dt_qv_tend = qv_tend_arr(ic, kk, 0) * dt;
         const Real dt_qc_tend = qc_tend_arr(ic, kk, 0) * dt;
         const Real dt_qi_tend = qi_tend_arr(ic, kk, 0) * dt;
         const Real dt_tke_tend = tke_tend_arr(ic, kk, 0) * dt;
         const Real cond_dt = shoc_cond_arr(ic, kk, 0) * dt;
         const Real evap_dt = shoc_evap_arr(ic, kk, 0) * dt;
         const Real tke_base_val = tke_base_arr(ic, kk, 0);
         std::ostringstream msg;
         msg << "NATIVE_SHOC_BAD_COLUMN_BEGIN\n"
             << "  rank=" << ParallelDescriptor::MyProc()
             << " level=" << m_lev
             << " shoc_call=" << (m_advance_calls + 1)
             << " mfi_index=" << rep.mfi_index
             << " box_valid_lo=(" << mfi.validbox().smallEnd(0) << ","
             << mfi.validbox().smallEnd(1) << ","
             << mfi.validbox().smallEnd(2) << ")"
             << " box_valid_hi=(" << mfi.validbox().bigEnd(0) << ","
             << mfi.validbox().bigEnd(1) << ","
             << mfi.validbox().bigEnd(2) << ")"
             << " layout.nx=" << col.layout.nx
             << " layout.ny=" << col.layout.ny
             << " layout.ncell=" << col.layout.ncell
             << " layout.nlev=" << col.layout.nlev
             << " layout.imin=" << col.layout.imin
             << " layout.jmin=" << col.layout.jmin
             << " layout.kmin=" << col.layout.kmin
             << " layout.kmax=" << col.layout.kmax
             << "\n"
             << "  i=" << i << " j=" << j << " k=" << k
             << " kk=" << kk << " ic=" << ic
             << " score=" << rep.score
             << " reason=" << rep.reason
             << "\n"
             << "  geometry z_nd(i,j,k)=" << z_nd_ijk
             << " z_nd(i+1,j,k)=" << z_nd_ip1jk
             << " z_nd(i,j+1,k)=" << z_nd_ijp1k
             << " z_nd(i+1,j+1,k)=" << z_nd_ip1jp1k
             << " z_nd(i,j,k+1)=" << z_nd_ijkp1
             << " z_nd(i+1,j,k+1)=" << z_nd_ip1jkp1
             << " z_nd(i,j+1,k+1)=" << z_nd_ijp1kp1
             << " z_nd(i+1,j+1,k+1)=" << z_nd_ip1jp1kp1
             << "\n"
             << "  four_node_zlo=" << four_node_zlo
             << " four_node_zhi=" << four_node_zhi
             << " four_node_dz=" << four_node_dz
             << " corner_dz=" << corner_dz
             << " dz=" << dz_arr(ic, kk, 0)
             << "\n"
             << "  rho=" << rho_arr(ic, kk, 0)
             << " theta=" << theta_arr(ic, kk, 0)
             << " thetal=" << thetal_arr(ic, kk, 0)
             << " theta_v=" << theta_v_arr(ic, kk, 0)
             << " qv=" << qv_arr(ic, kk, 0)
             << " qc=" << qc_arr(ic, kk, 0)
             << " qi=" << qi_arr(ic, kk, 0)
             << " qw=" << qw_arr(ic, kk, 0)
             << " tabs=" << tabs_arr(ic, kk, 0)
             << " exner=" << exner_arr(ic, kk, 0)
             << " p_mid=" << p_mid_arr(ic, kk, 0)
             << " p_int_lower=" << p_int_arr(ic, kk, 0)
             << " p_int_upper=" << p_int_arr(ic, kk + 1, 0)
             << " host_dse=" << host_dse_arr(ic, kk, 0)
             << "\n"
             << "  pblh=" << pblh_arr(ic, 0, 0)
             << " obklen=" << obklen_arr(ic, 0, 0)
             << " ustar=" << ustar_arr(ic, 0, 0)
             << " shoc_mix=" << shoc_mix_arr(ic, kk, 0)
             << " Lturb=" << shoc_mix_arr(ic, kk, 0)
             << " brunt=" << brunt_arr(ic, kk, 0)
             << " isotropy=" << isotropy_arr(ic, kk, 0)
             << " tk=" << tk_arr(ic, kk, 0)
             << " tkh=" << tkh_arr(ic, kk, 0)
             << " shear_prod=" << shear_prod_arr(ic, kk, 0)
             << " buoy_prod=" << buoy_prod_arr(ic, kk, 0)
             << " diss_tke=" << diss_tke_arr(ic, kk, 0)
             << " tke=" << tke_state_arr(ic, kk, 0)
             << "\n"
             << "  w_sec=" << w_sec_arr(ic, kk, 0)
             << " wthv_sec=" << wthv_sec_arr(ic, kk, 0)
             << " shoc_cldfrac=" << shoc_cldfrac_arr(ic, kk, 0)
             << " shoc_ql=" << shoc_ql_arr(ic, kk, 0)
             << " shoc_ql2=" << shoc_ql2_arr(ic, kk, 0)
             << " shoc_cond=" << shoc_cond_arr(ic, kk, 0)
             << " shoc_evap=" << shoc_evap_arr(ic, kk, 0)
             << " wqls_sec=" << wqls_sec_arr(ic, kk, 0)
             << "\n"
             << "  thl_sec_lower=" << thl_sec_arr(ic, kk, 0)
             << " thl_sec_upper=" << thl_sec_arr(ic, kk + 1, 0)
             << " qw_sec_lower=" << qw_sec_arr(ic, kk, 0)
             << " qw_sec_upper=" << qw_sec_arr(ic, kk + 1, 0)
             << " qwthl_sec_lower=" << qwthl_sec_arr(ic, kk, 0)
             << " qwthl_sec_upper=" << qwthl_sec_arr(ic, kk + 1, 0)
             << " wthl_sec_lower=" << wthl_sec_arr(ic, kk, 0)
             << " wthl_sec_upper=" << wthl_sec_arr(ic, kk + 1, 0)
             << " wqw_sec_lower=" << wqw_sec_arr(ic, kk, 0)
             << " wqw_sec_upper=" << wqw_sec_arr(ic, kk + 1, 0)
             << " w3_lower=" << w3_arr(ic, kk, 0)
             << " w3_upper=" << w3_arr(ic, kk + 1, 0)
             << " uw_sec_lower=" << uw_sec_arr(ic, kk, 0)
             << " uw_sec_upper=" << uw_sec_arr(ic, kk + 1, 0)
             << " vw_sec_lower=" << vw_sec_arr(ic, kk, 0)
             << " vw_sec_upper=" << vw_sec_arr(ic, kk + 1, 0)
             << " wtke_sec_lower=" << wtke_sec_arr(ic, kk, 0)
             << " wtke_sec_upper=" << wtke_sec_arr(ic, kk + 1, 0)
             << "\n"
             << "  theta_tend=" << theta_tend_arr(ic, kk, 0)
             << " qv_tend=" << qv_tend_arr(ic, kk, 0)
             << " qc_tend=" << qc_tend_arr(ic, kk, 0)
             << " qi_tend=" << qi_tend_arr(ic, kk, 0)
             << " tke_tend=" << tke_tend_arr(ic, kk, 0)
             << " u_tend=" << u_tend_arr(ic, kk, 0)
             << " v_tend=" << v_tend_arr(ic, kk, 0)
             << "\n"
             << "  baseline theta=" << theta_base_val
             << " thetal=" << thetal_base_val
             << " qv=" << qv_base_val
             << " qc=" << qc_base_val
             << " qi=" << qi_base_val
             << " ql=" << ql_base
             << " qw=" << qw_base
             << " tke=" << tke_base_val
             << "\n"
             << "  updated  theta=" << theta_new_val
             << " thetal=" << thetal_new_val
             << " qv=" << qv_new_val
             << " qc=" << qc_new_val
             << " qi=" << qi_new_val
             << " ql=" << ql_new
             << " qw=" << qw_new
             << " tke=" << tke_state_arr(ic, kk, 0)
             << "\n"
             << "  deltas   dtheta=" << delta_theta
             << " dqv=" << delta_qv
             << " dqc=" << delta_qc
             << " dqi=" << delta_qi
             << " dql=" << delta_ql
             << " dqw=" << delta_qw
             << "\n"
             << "  tend_dt  theta=" << dt_theta_tend
             << " qv=" << dt_qv_tend
             << " qc=" << dt_qc_tend
             << " qi=" << dt_qi_tend
             << " tke=" << dt_tke_tend
             << "\n"
             << "  consistency dtheta_minus_tenddt=" << (delta_theta - dt_theta_tend)
             << " dqv_minus_tenddt=" << (delta_qv - dt_qv_tend)
             << " dqc_minus_tenddt=" << (delta_qc - dt_qc_tend)
             << " dqi_minus_tenddt=" << (delta_qi - dt_qi_tend)
             << "\n"
             << "  pdf_cloud shoc_ql=" << shoc_ql_arr(ic, kk, 0)
             << " shoc_cond_dt=" << cond_dt
             << " shoc_evap_dt=" << evap_dt
             << " delta_ql=" << delta_ql
             << " delta_ql_minus_cond_minus_evap=" << (delta_ql - (cond_dt - evap_dt))
             << "\n"
             << "  surf_sens_flux=" << surf_sens_flux_arr(ic, 0, 0)
             << " surf_lat_flux=" << surf_lat_flux_arr(ic, 0, 0)
             << " surf_tau_u=" << surf_tau_u_arr(ic, 0, 0)
             << " surf_tau_v=" << surf_tau_v_arr(ic, 0, 0)
             << " rho_sfc=" << cons_arr(i, j, k, Rho_comp)
             << "\n";
  
         if (has_hfx3) {
             msg << "  raw hfx3(i,j,klo)=" << hfx3_host.const_array()(rep.i, rep.j, rep.k) << "\n";
         }
         if (has_qfx3) {
             msg << "  raw qfx3(i,j,klo)=" << qfx3_host.const_array()(rep.i, rep.j, rep.k) << "\n";
         }
         if (has_tau13) {
             msg << "  raw tau13(i,j,klo)=" << tau13_host.const_array()(rep.i, rep.j, rep.k)
                 << " raw tau13(i+1,j,klo)=" << tau13_host.const_array()(rep.i + 1, rep.j, rep.k)
                 << "\n";
         }
         if (has_tau23) {
             msg << "  raw tau23(i,j,klo)=" << tau23_host.const_array()(rep.i, rep.j, rep.k)
                 << " raw tau23(i,j+1,klo)=" << tau23_host.const_array()(rep.i, rep.j + 1, rep.k)
                 << "\n";
         }
         msg << "NATIVE_SHOC_BAD_COLUMN_END\n";
         amrex::AllPrint() << msg.str() << std::flush;
     }
  
     if (m_opts.debug_bad_column_abort) {
         amrex::Abort("Native SHOC debug_bad_column abort: bad SHOC column detected before state update");
     }
 }

Referenced by advance().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ debug_summary_enabled()

bool ShocDriver::debug_summary_enabled ( ) const

inline

93 { return m_opts.debug_summary; }

◆ disables_momentum_transport()

bool ShocDriver::disables_momentum_transport ( ) const

 {
     return shoc_disables_momentum_transport(m_opts.momentum_transport);
 }

Referenced by set_diff_stresses().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ diss_tke_diagnostics()

const amrex::MultiFab& ShocDriver::diss_tke_diagnostics ( ) const

inline

130 { return m_diss_tke_cc; }

◆ ensure_storage()

void ShocDriver::ensure_storage	(	const amrex::MultiFab &	cons,
		const amrex::MultiFab &	xvel,
		const amrex::MultiFab &	yvel,
		const amrex::MultiFab &	eddy_diffs
	)

private

 {
     const bool storage_changed =
         !m_theta_tend_cc.isDefined() ||
         !m_u_tend_fc.isDefined() ||
         !m_v_tend_fc.isDefined() ||
         !m_eddy_coeffs_cc.isDefined() ||
         m_theta_tend_cc.boxArray() != cons.boxArray() ||
         m_theta_tend_cc.DistributionMap() != cons.DistributionMap() ||
         m_u_tend_fc.boxArray() != xvel.boxArray() ||
         m_u_tend_fc.DistributionMap() != xvel.DistributionMap() ||
         m_v_tend_fc.boxArray() != yvel.boxArray() ||
         m_v_tend_fc.DistributionMap() != yvel.DistributionMap() ||
         m_eddy_coeffs_cc.boxArray() != eddy_diffs.boxArray() ||
         m_eddy_coeffs_cc.DistributionMap() != eddy_diffs.DistributionMap();
  
     if (storage_changed) {
         m_column_workspaces.clear();
         m_prev_turb_valid = false;
         m_theta_tend_cc.define(cons.boxArray(), cons.DistributionMap(), 1, 0);
         m_qv_tend_cc.define(cons.boxArray(), cons.DistributionMap(), 1, 0);
         m_qc_tend_cc.define(cons.boxArray(), cons.DistributionMap(), 1, 0);
         m_qi_tend_cc.define(cons.boxArray(), cons.DistributionMap(), 1, 0);
         m_tke_tend_cc.define(cons.boxArray(), cons.DistributionMap(), 1, 0);
         m_u_tend_cc.define(cons.boxArray(), cons.DistributionMap(), 1, 1);
         m_v_tend_cc.define(cons.boxArray(), cons.DistributionMap(), 1, 1);
         m_u_tend_fc.define(xvel.boxArray(), xvel.DistributionMap(), 1, 0);
         m_v_tend_fc.define(yvel.boxArray(), yvel.DistributionMap(), 1, 0);
         m_eddy_coeffs_cc.define(eddy_diffs.boxArray(), eddy_diffs.DistributionMap(),
                                 EddyDiff::NumDiffs, 0);
         m_prev_turb_cc.define(cons.boxArray(), cons.DistributionMap(), 2, 0);
         m_prev_wthv_sec_cc.define(cons.boxArray(), cons.DistributionMap(), 1, 0);
         m_consumed_sens_flux_cc.define(cons.boxArray(), cons.DistributionMap(), 1, 0);
         m_consumed_laten_flux_cc.define(cons.boxArray(), cons.DistributionMap(), 1, 0);
         m_pblh_cc.define(cons.boxArray(), cons.DistributionMap(), 1, 0);
         m_shoc_ustar_cc.define(cons.boxArray(), cons.DistributionMap(), 1, 0);
         m_shoc_olen_cc.define(cons.boxArray(), cons.DistributionMap(), 1, 0);
         m_shoc_cldfrac_cc.define(cons.boxArray(), cons.DistributionMap(), 1, 0);
         m_shoc_ql_cc.define(cons.boxArray(), cons.DistributionMap(), 1, 0);
         m_shoc_ql2_cc.define(cons.boxArray(), cons.DistributionMap(), 1, 0);
         m_shoc_cond_cc.define(cons.boxArray(), cons.DistributionMap(), 1, 0);
         m_w_sec_cc.define(cons.boxArray(), cons.DistributionMap(), 1, 0);
         m_wqls_sec_cc.define(cons.boxArray(), cons.DistributionMap(), 1, 0);
         m_wthv_sec_cc.define(cons.boxArray(), cons.DistributionMap(), 1, 0);
         m_thl_sec_cc.define(cons.boxArray(), cons.DistributionMap(), 1, 0);
         m_qw_sec_cc.define(cons.boxArray(), cons.DistributionMap(), 1, 0);
         m_qwthl_sec_cc.define(cons.boxArray(), cons.DistributionMap(), 1, 0);
         m_wthl_sec_cc.define(cons.boxArray(), cons.DistributionMap(), 1, 0);
         m_wqw_sec_cc.define(cons.boxArray(), cons.DistributionMap(), 1, 0);
         m_w3_cc.define(cons.boxArray(), cons.DistributionMap(), 1, 0);
         m_brunt_cc.define(cons.boxArray(), cons.DistributionMap(), 1, 0);
         m_isotropy_cc.define(cons.boxArray(), cons.DistributionMap(), 1, 0);
         m_shear_prod_cc.define(cons.boxArray(), cons.DistributionMap(), 1, 0);
         m_buoy_prod_cc.define(cons.boxArray(), cons.DistributionMap(), 1, 0);
         m_diss_tke_cc.define(cons.boxArray(), cons.DistributionMap(), 1, 0);
         m_prev_turb_cc.setVal(0.0);
         m_prev_wthv_sec_cc.setVal(0.0);
     }
     m_theta_tend_cc.setVal(0.0);
     m_qv_tend_cc.setVal(0.0);
     m_qc_tend_cc.setVal(0.0);
     m_qi_tend_cc.setVal(0.0);
     m_tke_tend_cc.setVal(0.0);
     m_u_tend_cc.setVal(0.0);
     m_v_tend_cc.setVal(0.0);
     m_u_tend_fc.setVal(0.0);
     m_v_tend_fc.setVal(0.0);
     m_eddy_coeffs_cc.setVal(0.0);
     m_consumed_sens_flux_cc.setVal(0.0);
     m_consumed_laten_flux_cc.setVal(0.0);
     m_pblh_cc.setVal(0.0);
     m_shoc_ustar_cc.setVal(0.0);
     m_shoc_olen_cc.setVal(0.0);
     m_shoc_cldfrac_cc.setVal(0.0);
     m_shoc_ql_cc.setVal(0.0);
     m_shoc_ql2_cc.setVal(0.0);
     m_shoc_cond_cc.setVal(0.0);
     m_w_sec_cc.setVal(0.0);
     m_wqls_sec_cc.setVal(0.0);
     m_wthv_sec_cc.setVal(0.0);
     m_thl_sec_cc.setVal(0.0);
     m_qw_sec_cc.setVal(0.0);
     m_qwthl_sec_cc.setVal(0.0);
     m_wthl_sec_cc.setVal(0.0);
     m_wqw_sec_cc.setVal(0.0);
     m_w3_cc.setVal(0.0);
     m_brunt_cc.setVal(0.0);
     m_isotropy_cc.setVal(0.0);
     m_shear_prod_cc.setVal(0.0);
     m_buoy_prod_cc.setVal(0.0);
     m_diss_tke_cc.setVal(0.0);
 }

Referenced by advance().

Here is the caller graph for this function:

◆ has_consumed_surface_flux_diagnostics()

bool ShocDriver::has_consumed_surface_flux_diagnostics ( ) const

inline

     {
         return m_consumed_sens_flux_cc.isDefined() && m_consumed_laten_flux_cc.isDefined();
     }

Referenced by ERF::Write2DPlotFile().

Here is the caller graph for this function:

◆ has_native_diagnostics()

bool ShocDriver::has_native_diagnostics ( ) const

inline

94 { return m_eddy_coeffs_cc.isDefined(); }

Referenced by ERF::Write2DPlotFile().

Here is the caller graph for this function:

◆ isotropy_diagnostics()

const amrex::MultiFab& ShocDriver::isotropy_diagnostics ( ) const

inline

127 { return m_isotropy_cc; }

◆ native_diagnostics()

const amrex::MultiFab& ShocDriver::native_diagnostics ( ) const

inline

99 { return m_eddy_coeffs_cc; }

◆ needs_host_surface_momentum_stresses()

bool ShocDriver::needs_host_surface_momentum_stresses ( ) const

 {
     return uses_momentum_host_diffusion();
 }

Here is the call graph for this function:

◆ owns_momentum_surface_stresses()

bool ShocDriver::owns_momentum_surface_stresses ( ) const

 {
     return uses_momentum_state_update();
 }

Referenced by set_diff_stresses().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ owns_scalar_surface_fluxes()

bool ShocDriver::owns_scalar_surface_fluxes ( ) const

 {
     return uses_state_update();
 }

Referenced by owns_surface_fluxes(), and ERF::Write2DPlotFile().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ owns_surface_fluxes()

bool ShocDriver::owns_surface_fluxes ( ) const

 {
     return owns_scalar_surface_fluxes();
 }

Here is the call graph for this function:

◆ pblh_diagnostics()

const amrex::MultiFab& ShocDriver::pblh_diagnostics ( ) const

inline

101 { return m_pblh_cc; }

Referenced by ERF::Write2DPlotFile().

Here is the caller graph for this function:

◆ print_debug_summary()

void ShocDriver::print_debug_summary ( double dt ) const

private

 {
     BL_PROFILE("SHOC::print_debug_summary");
  
     auto print_minmax = [] (const char* name, const MultiFab& mf, int comp) {
         amrex::Print() << "    " << std::setw(12) << std::left << name
                        << " min=" << mf.min(comp)
                        << " max=" << mf.max(comp) << "\n";
     };
  
     amrex::Print() << "SHOC debug summary:"
                    << " level=" << m_lev
                    << " call=" << m_advance_calls
                    << " dt=" << dt
                    << " transport_mode=" << shoc_transport_mode_name(m_opts.transport_mode)
                    << " momentum_transport=" << shoc_momentum_transport_name(m_opts.momentum_transport)
                    << " state_update=" << (uses_state_update() ? "on" : "off")
                    << "\n";
     print_shoc_debug_settings_once(m_opts);
  
     print_minmax("Kmv", m_eddy_coeffs_cc, EddyDiff::Mom_v);
     print_minmax("Khv", m_eddy_coeffs_cc, EddyDiff::Theta_v);
     print_minmax("KE_v", m_eddy_coeffs_cc, EddyDiff::KE_v);
     print_minmax("Q_v", m_eddy_coeffs_cc, EddyDiff::Q_v);
     print_minmax("l_turb", m_eddy_coeffs_cc, EddyDiff::Turb_lengthscale);
     print_minmax("pblh", m_pblh_cc, 0);
  
     print_minmax("th_tend", m_theta_tend_cc, 0);
     print_minmax("qv_tend", m_qv_tend_cc, 0);
     print_minmax("qc_tend", m_qc_tend_cc, 0);
     print_minmax("qi_tend", m_qi_tend_cc, 0);
     print_minmax("tke_tend", m_tke_tend_cc, 0);
     print_minmax("u_tend", m_u_tend_fc, 0);
     print_minmax("v_tend", m_v_tend_fc, 0);
     print_minmax("w_sec", m_w_sec_cc, 0);
     print_minmax("thl_sec", m_thl_sec_cc, 0);
     print_minmax("qw_sec", m_qw_sec_cc, 0);
     print_minmax("qwthl_sec", m_qwthl_sec_cc, 0);
     print_minmax("wthl_sec", m_wthl_sec_cc, 0);
     print_minmax("wqw_sec", m_wqw_sec_cc, 0);
     print_minmax("w3", m_w3_cc, 0);
     print_minmax("brunt", m_brunt_cc, 0);
     print_minmax("isotropy", m_isotropy_cc, 0);
     print_minmax("shear_prod", m_shear_prod_cc, 0);
     print_minmax("buoy_prod", m_buoy_prod_cc, 0);
     print_minmax("diss_tke", m_diss_tke_cc, 0);
     print_minmax("cldfrac", m_shoc_cldfrac_cc, 0);
     print_minmax("shoc_ql", m_shoc_ql_cc, 0);
     print_minmax("shoc_ql2", m_shoc_ql2_cc, 0);
     print_minmax("shoc_cond", m_shoc_cond_cc, 0);
     print_minmax("wqls_sec", m_wqls_sec_cc, 0);
     print_minmax("wthv_sec", m_wthv_sec_cc, 0);
  
     if (m_hfx3_ptr)  print_minmax("hfx3_in", *m_hfx3_ptr, 0);
     if (m_qfx3_ptr)  print_minmax("qfx3_in", *m_qfx3_ptr, 0);
     if (m_tau13_ptr) print_minmax("tau13_in", *m_tau13_ptr, 0);
     if (m_tau23_ptr) print_minmax("tau23_in", *m_tau23_ptr, 0);
 }

Referenced by advance().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ qw_sec_diagnostics()

const amrex::MultiFab& ShocDriver::qw_sec_diagnostics ( ) const

inline

121 { return m_qw_sec_cc; }

◆ qwthl_sec_diagnostics()

const amrex::MultiFab& ShocDriver::qwthl_sec_diagnostics ( ) const

inline

122 { return m_qwthl_sec_cc; }

◆ seed_carried_buoyancy_flux()

void ShocDriver::seed_carried_buoyancy_flux	(	ShocColumnData &	col,
		const amrex::MFIter &	mfi
	)		const

private

 {
     if (!m_prev_turb_valid) {
         return;
     }
  
     const auto carried = m_prev_wthv_sec_cc.const_array(mfi);
     auto wthv_sec = col.wthv_sec.array();
     const auto layout = col.layout;
     const Box xy_box = amrex::makeSlab(mfi.validbox(), 2, layout.kmin);
  
     seed_carried_buoyancy_flux_impl(xy_box, layout, carried, wthv_sec);
 }

Referenced by advance().

Here is the caller graph for this function:

◆ seed_carried_turbulence()

void ShocDriver::seed_carried_turbulence	(	ShocColumnData &	col,
		const amrex::MFIter &	mfi,
		const amrex::MultiFab &	cons,
		const amrex::MultiFab &	eddy_diffs
	)		const

private

 {
     const auto rho_host = cons.const_array(mfi);
     const auto carried = m_prev_turb_cc.const_array(mfi);
     const auto host_diff = eddy_diffs.const_array(mfi);
     auto tk = col.tk.array();
     auto tkh = col.tkh.array();
     const bool prev_turb_valid = m_prev_turb_valid;
     const auto layout = col.layout;
     const Box xy_box = amrex::makeSlab(mfi.validbox(), 2, layout.kmin);
  
     seed_carried_turbulence_impl(xy_box, layout, rho_host, carried, host_diff,
                                  tk, tkh, prev_turb_valid);
 }

Referenced by advance().

Here is the caller graph for this function:

◆ set_diff_stresses()

void ShocDriver::set_diff_stresses ( ) const

 {
     BL_PROFILE("SHOC::set_diff_stresses");
  
     if (uses_host_diffusion()) {
         // Full host-diffusion mode preserves the existing host-owned lower
         // boundary fluxes and stresses.
         return;
     }
  
     if (!m_hfx3_ptr || !m_qfx3_ptr) {
         return;
     }
  
     for (MFIter mfi(*m_hfx3_ptr, false); mfi.isValid(); ++mfi) {
         const Box& vbx_cc = mfi.validbox();
         const Box& vbx_xz = convert(vbx_cc, IntVect(1,0,1));
         const Box& vbx_yz = convert(vbx_cc, IntVect(0,1,1));
         auto hfx = m_hfx3_ptr->array(mfi);
         auto qfx = m_qfx3_ptr->array(mfi);
  
         ParallelFor(vbx_cc, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
             hfx(i,j,k) = 0.0;
             qfx(i,j,k) = 0.0;
         });
  
         if ((owns_momentum_surface_stresses() || disables_momentum_transport()) &&
             m_tau13_ptr && m_tau23_ptr) {
             auto tau13 = m_tau13_ptr->array(mfi);
             auto tau23 = m_tau23_ptr->array(mfi);
             ParallelFor(vbx_xz, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
                 tau13(i,j,k) = 0.0;
             });
             ParallelFor(vbx_yz, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
                 tau23(i,j,k) = 0.0;
             });
         }
     }
 }

Here is the call graph for this function:

◆ set_eddy_diffs()

void ShocDriver::set_eddy_diffs ( ) const

 {
     BL_PROFILE("SHOC::set_eddy_diffs");
  
     AMREX_ALWAYS_ASSERT(m_eddy_diffs_ptr != nullptr);
     m_eddy_diffs_ptr->setVal(0.0, k_shoc_vertical_diff_comp, k_shoc_vertical_diff_count,
                              m_eddy_diffs_ptr->nGrow());
     MultiFab::Copy(*m_eddy_diffs_ptr, m_eddy_coeffs_cc,
                    EddyDiff::Turb_lengthscale, EddyDiff::Turb_lengthscale, 1, 0);
  
     if (uses_host_diffusion()) {
         MultiFab::Copy(*m_eddy_diffs_ptr, m_eddy_coeffs_cc,
                        k_shoc_vertical_diff_comp, k_shoc_vertical_diff_comp,
                        k_shoc_vertical_diff_count, 0);
     } else if (uses_momentum_host_diffusion()) {
         MultiFab::Copy(*m_eddy_diffs_ptr, m_eddy_coeffs_cc,
                        EddyDiff::Mom_v, EddyDiff::Mom_v, 1, 0);
     }
     const bool export_host_diff =
         uses_host_diffusion() || uses_momentum_host_diffusion();
     if (!export_host_diff) {
         return;
     }
  
     AMREX_ALWAYS_ASSERT(m_geom_ptr != nullptr);
     const Geometry& geom = *m_geom_ptr;
     const int comp = uses_host_diffusion() ? k_shoc_vertical_diff_comp : EddyDiff::Mom_v;
     const int ncomp = uses_host_diffusion() ? k_shoc_vertical_diff_count : 1;
  
     shoc_fill_physical_boundary_ghosts(*m_eddy_diffs_ptr, geom, comp, ncomp);
 }

Here is the call graph for this function:

◆ shear_prod_diagnostics()

const amrex::MultiFab& ShocDriver::shear_prod_diagnostics ( ) const

inline

128 { return m_shear_prod_cc; }

◆ shoc_cldfrac_diagnostics()

const amrex::MultiFab& ShocDriver::shoc_cldfrac_diagnostics ( ) const

inline

113 { return m_shoc_cldfrac_cc; }

◆ shoc_cond_diagnostics()

const amrex::MultiFab& ShocDriver::shoc_cond_diagnostics ( ) const

inline

116 { return m_shoc_cond_cc; }

◆ shoc_olen_diagnostics()

const amrex::MultiFab& ShocDriver::shoc_olen_diagnostics ( ) const

inline

112 { return m_shoc_olen_cc; }

Referenced by ERF::Write2DPlotFile().

Here is the caller graph for this function:

◆ shoc_ql2_diagnostics()

const amrex::MultiFab& ShocDriver::shoc_ql2_diagnostics ( ) const

inline

115 { return m_shoc_ql2_cc; }

◆ shoc_ql_diagnostics()

const amrex::MultiFab& ShocDriver::shoc_ql_diagnostics ( ) const

inline

114 { return m_shoc_ql_cc; }

◆ shoc_ustar_diagnostics()

const amrex::MultiFab& ShocDriver::shoc_ustar_diagnostics ( ) const

inline

111 { return m_shoc_ustar_cc; }

Referenced by ERF::Write2DPlotFile().

Here is the caller graph for this function:

◆ store_carried_buoyancy_flux()

void ShocDriver::store_carried_buoyancy_flux	(	const ShocColumnData &	col,
		const amrex::MFIter &	mfi
	)

private

 {
     auto carried = m_prev_wthv_sec_cc.array(mfi);
     const auto wthv_sec = col.wthv_sec.const_array();
     const auto layout = col.layout;
     const Box xy_box = amrex::makeSlab(mfi.validbox(), 2, layout.kmin);
  
     store_carried_buoyancy_flux_impl(xy_box, layout, carried, wthv_sec);
 }

Referenced by advance().

Here is the caller graph for this function:

◆ store_carried_turbulence()

void ShocDriver::store_carried_turbulence	(	const ShocColumnData &	col,
		const amrex::MFIter &	mfi
	)

private

 {
     auto carried = m_prev_turb_cc.array(mfi);
     const auto tk = col.tk.const_array();
     const auto tkh = col.tkh.const_array();
     const auto layout = col.layout;
     const Box xy_box = amrex::makeSlab(mfi.validbox(), 2, layout.kmin);
  
     store_carried_turbulence_impl(xy_box, layout, carried, tk, tkh);
 }

Referenced by advance().

Here is the caller graph for this function:

◆ thl_sec_diagnostics()

const amrex::MultiFab& ShocDriver::thl_sec_diagnostics ( ) const

inline

120 { return m_thl_sec_cc; }

◆ uses_host_diffusion()

bool ShocDriver::uses_host_diffusion ( ) const

 {
     return shoc_uses_host_diffusion(m_opts.transport_mode);
 }

Referenced by set_diff_stresses(), and set_eddy_diffs().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ uses_momentum_host_diffusion()

bool ShocDriver::uses_momentum_host_diffusion ( ) const

 {
     return shoc_uses_momentum_host_diffusion(m_opts.momentum_transport);
 }

Referenced by needs_host_surface_momentum_stresses(), and set_eddy_diffs().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ uses_momentum_state_update()

bool ShocDriver::uses_momentum_state_update ( ) const

 {
     return shoc_uses_momentum_state_update(m_opts.momentum_transport);
 }

Referenced by advance(), apply_state_update(), and owns_momentum_surface_stresses().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ uses_state_update()

bool ShocDriver::uses_state_update ( ) const

 {
     return shoc_uses_state_update(m_opts.transport_mode);
 }

Referenced by advance(), owns_scalar_surface_fluxes(), and print_debug_summary().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ w3_diagnostics()

const amrex::MultiFab& ShocDriver::w3_diagnostics ( ) const

inline

125 { return m_w3_cc; }

◆ w_sec_diagnostics()

const amrex::MultiFab& ShocDriver::w_sec_diagnostics ( ) const

inline

117 { return m_w_sec_cc; }

◆ wqls_sec_diagnostics()

const amrex::MultiFab& ShocDriver::wqls_sec_diagnostics ( ) const

inline

118 { return m_wqls_sec_cc; }

◆ wqw_sec_diagnostics()

const amrex::MultiFab& ShocDriver::wqw_sec_diagnostics ( ) const

inline

124 { return m_wqw_sec_cc; }

◆ wthl_sec_diagnostics()

const amrex::MultiFab& ShocDriver::wthl_sec_diagnostics ( ) const

inline

123 { return m_wthl_sec_cc; }

◆ wthv_sec_diagnostics()

const amrex::MultiFab& ShocDriver::wthv_sec_diagnostics ( ) const

inline

119 { return m_wthv_sec_cc; }

Referenced by ERF::Write2DPlotFile().

Here is the caller graph for this function:

Member Data Documentation

◆ m_advance_calls

int ShocDriver::m_advance_calls = 0

private

Referenced by advance(), debug_check_bad_column(), and print_debug_summary().

◆ m_brunt_cc

amrex::MultiFab ShocDriver::m_brunt_cc

private

Referenced by advance(), brunt_diagnostics(), ensure_storage(), and print_debug_summary().

◆ m_buoy_prod_cc

amrex::MultiFab ShocDriver::m_buoy_prod_cc

private

Referenced by advance(), buoy_prod_diagnostics(), ensure_storage(), and print_debug_summary().

◆ m_column_workspaces

amrex::Vector<std::unique_ptr<ShocColumnWorkspace> > ShocDriver::m_column_workspaces

private

Referenced by advance(), and ensure_storage().

◆ m_cons_ptr

amrex::MultiFab* ShocDriver::m_cons_ptr = nullptr

private

Referenced by add_fast_tend(), add_slow_tend(), advance(), and debug_check_bad_column().

◆ m_consumed_laten_flux_cc

amrex::MultiFab ShocDriver::m_consumed_laten_flux_cc

private

Referenced by advance(), consumed_laten_flux_diagnostics(), ensure_storage(), and has_consumed_surface_flux_diagnostics().

◆ m_consumed_sens_flux_cc

amrex::MultiFab ShocDriver::m_consumed_sens_flux_cc

private

Referenced by advance(), consumed_sens_flux_diagnostics(), ensure_storage(), and has_consumed_surface_flux_diagnostics().

◆ m_diss_tke_cc

amrex::MultiFab ShocDriver::m_diss_tke_cc

private

Referenced by advance(), diss_tke_diagnostics(), ensure_storage(), and print_debug_summary().

◆ m_eddy_coeffs_cc

amrex::MultiFab ShocDriver::m_eddy_coeffs_cc

private

Referenced by advance(), ensure_storage(), has_native_diagnostics(), native_diagnostics(), print_debug_summary(), and set_eddy_diffs().

◆ m_eddy_diffs_ptr

amrex::MultiFab* ShocDriver::m_eddy_diffs_ptr = nullptr

private

Referenced by advance(), and set_eddy_diffs().

◆ m_geom_ptr

const amrex::Geometry* ShocDriver::m_geom_ptr = nullptr

private

Referenced by advance(), and set_eddy_diffs().

◆ m_hfx3_ptr

amrex::MultiFab* ShocDriver::m_hfx3_ptr = nullptr

private

Referenced by advance(), print_debug_summary(), and set_diff_stresses().

◆ m_isotropy_cc

amrex::MultiFab ShocDriver::m_isotropy_cc

private

Referenced by advance(), ensure_storage(), isotropy_diagnostics(), and print_debug_summary().

◆ m_lev

int ShocDriver::m_lev

private

Referenced by debug_check_bad_column(), and print_debug_summary().

◆ m_moisture_indices

MoistureComponentIndices ShocDriver::m_moisture_indices

private

Referenced by advance(), and apply_state_update().

◆ m_moisture_type

MoistureType ShocDriver::m_moisture_type

private

Referenced by ShocDriver().

◆ m_opts

ShocRuntimeOptions ShocDriver::m_opts

private

Referenced by advance(), apply_state_update(), debug_check_bad_column(), debug_summary_enabled(), disables_momentum_transport(), print_debug_summary(), ShocDriver(), uses_host_diffusion(), uses_momentum_host_diffusion(), uses_momentum_state_update(), and uses_state_update().

◆ m_pblh_cc

amrex::MultiFab ShocDriver::m_pblh_cc

private

Referenced by advance(), ensure_storage(), pblh_diagnostics(), and print_debug_summary().

◆ m_prev_turb_cc

amrex::MultiFab ShocDriver::m_prev_turb_cc

private

Referenced by ensure_storage(), seed_carried_turbulence(), and store_carried_turbulence().

◆ m_prev_turb_valid

bool ShocDriver::m_prev_turb_valid = false

private

Referenced by advance(), ensure_storage(), seed_carried_buoyancy_flux(), and seed_carried_turbulence().

◆ m_prev_wthv_sec_cc

amrex::MultiFab ShocDriver::m_prev_wthv_sec_cc

private

Referenced by ensure_storage(), seed_carried_buoyancy_flux(), and store_carried_buoyancy_flux().

◆ m_qc_tend_cc

amrex::MultiFab ShocDriver::m_qc_tend_cc

private

Referenced by advance(), apply_state_update(), ensure_storage(), and print_debug_summary().

◆ m_qfx3_ptr

amrex::MultiFab* ShocDriver::m_qfx3_ptr = nullptr

private

Referenced by advance(), print_debug_summary(), and set_diff_stresses().

◆ m_qi_tend_cc

amrex::MultiFab ShocDriver::m_qi_tend_cc

private

Referenced by advance(), apply_state_update(), ensure_storage(), and print_debug_summary().

◆ m_qv_tend_cc

amrex::MultiFab ShocDriver::m_qv_tend_cc

private

Referenced by advance(), apply_state_update(), ensure_storage(), and print_debug_summary().

◆ m_qw_sec_cc

amrex::MultiFab ShocDriver::m_qw_sec_cc

private

Referenced by advance(), ensure_storage(), print_debug_summary(), and qw_sec_diagnostics().

◆ m_qwthl_sec_cc

amrex::MultiFab ShocDriver::m_qwthl_sec_cc

private

Referenced by advance(), ensure_storage(), print_debug_summary(), and qwthl_sec_diagnostics().

◆ m_shear_prod_cc

amrex::MultiFab ShocDriver::m_shear_prod_cc

private

Referenced by advance(), ensure_storage(), print_debug_summary(), and shear_prod_diagnostics().

◆ m_shoc_cldfrac_cc

amrex::MultiFab ShocDriver::m_shoc_cldfrac_cc

private

Referenced by advance(), ensure_storage(), print_debug_summary(), and shoc_cldfrac_diagnostics().

◆ m_shoc_cond_cc

amrex::MultiFab ShocDriver::m_shoc_cond_cc

private

Referenced by advance(), ensure_storage(), print_debug_summary(), and shoc_cond_diagnostics().

◆ m_shoc_olen_cc

amrex::MultiFab ShocDriver::m_shoc_olen_cc

private

Referenced by advance(), ensure_storage(), and shoc_olen_diagnostics().

◆ m_shoc_ql2_cc

amrex::MultiFab ShocDriver::m_shoc_ql2_cc

private

Referenced by advance(), ensure_storage(), print_debug_summary(), and shoc_ql2_diagnostics().

◆ m_shoc_ql_cc

amrex::MultiFab ShocDriver::m_shoc_ql_cc

private

Referenced by advance(), ensure_storage(), print_debug_summary(), and shoc_ql_diagnostics().

◆ m_shoc_ustar_cc

amrex::MultiFab ShocDriver::m_shoc_ustar_cc

private

Referenced by advance(), ensure_storage(), and shoc_ustar_diagnostics().

◆ m_tau13_ptr

amrex::MultiFab* ShocDriver::m_tau13_ptr = nullptr

private

Referenced by advance(), print_debug_summary(), and set_diff_stresses().

◆ m_tau23_ptr

amrex::MultiFab* ShocDriver::m_tau23_ptr = nullptr

private

Referenced by advance(), print_debug_summary(), and set_diff_stresses().

◆ m_theta_tend_cc

amrex::MultiFab ShocDriver::m_theta_tend_cc

private

Referenced by advance(), apply_state_update(), ensure_storage(), and print_debug_summary().

◆ m_thl_sec_cc

amrex::MultiFab ShocDriver::m_thl_sec_cc

private

Referenced by advance(), ensure_storage(), print_debug_summary(), and thl_sec_diagnostics().

◆ m_tke_tend_cc

amrex::MultiFab ShocDriver::m_tke_tend_cc

private

Referenced by advance(), apply_state_update(), ensure_storage(), and print_debug_summary().

◆ m_u_tend_cc

amrex::MultiFab ShocDriver::m_u_tend_cc

private

Referenced by advance(), and ensure_storage().

◆ m_u_tend_fc

amrex::MultiFab ShocDriver::m_u_tend_fc

private

Referenced by advance(), apply_state_update(), ensure_storage(), and print_debug_summary().

◆ m_v_tend_cc

amrex::MultiFab ShocDriver::m_v_tend_cc

private

Referenced by advance(), and ensure_storage().

◆ m_v_tend_fc

amrex::MultiFab ShocDriver::m_v_tend_fc

private

Referenced by advance(), apply_state_update(), ensure_storage(), and print_debug_summary().

◆ m_w3_cc

amrex::MultiFab ShocDriver::m_w3_cc

private

Referenced by advance(), ensure_storage(), print_debug_summary(), and w3_diagnostics().

◆ m_w_sec_cc

amrex::MultiFab ShocDriver::m_w_sec_cc

private

Referenced by advance(), ensure_storage(), print_debug_summary(), and w_sec_diagnostics().

◆ m_wqls_sec_cc

amrex::MultiFab ShocDriver::m_wqls_sec_cc

private

Referenced by advance(), ensure_storage(), print_debug_summary(), and wqls_sec_diagnostics().

◆ m_wqw_sec_cc

amrex::MultiFab ShocDriver::m_wqw_sec_cc

private

Referenced by advance(), ensure_storage(), print_debug_summary(), and wqw_sec_diagnostics().

◆ m_wthl_sec_cc

amrex::MultiFab ShocDriver::m_wthl_sec_cc

private

Referenced by advance(), ensure_storage(), print_debug_summary(), and wthl_sec_diagnostics().

◆ m_wthv_sec_cc

amrex::MultiFab ShocDriver::m_wthv_sec_cc

private

Referenced by advance(), ensure_storage(), print_debug_summary(), and wthv_sec_diagnostics().

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

Source/PBL/Shoc/ERF_ShocDriver.H
Source/PBL/Shoc/ERF_ShocDriver.cpp

Public Member Functions

Private Member Functions

Private Attributes

Constructor & Destructor Documentation

◆ ShocDriver()

Member Function Documentation

◆ add_fast_tend()

◆ add_slow_tend()

◆ advance()

◆ apply_state_update()

◆ brunt_diagnostics()

◆ buoy_prod_diagnostics()

◆ consumed_laten_flux_diagnostics()

◆ consumed_sens_flux_diagnostics()

◆ debug_check_bad_column()

◆ debug_summary_enabled()

◆ disables_momentum_transport()

◆ diss_tke_diagnostics()

◆ ensure_storage()

◆ has_consumed_surface_flux_diagnostics()

◆ has_native_diagnostics()

◆ isotropy_diagnostics()

◆ native_diagnostics()

◆ needs_host_surface_momentum_stresses()

◆ owns_momentum_surface_stresses()

◆ owns_scalar_surface_fluxes()

◆ owns_surface_fluxes()

◆ pblh_diagnostics()

◆ print_debug_summary()

◆ qw_sec_diagnostics()

◆ qwthl_sec_diagnostics()

◆ seed_carried_buoyancy_flux()

◆ seed_carried_turbulence()

◆ set_diff_stresses()

◆ set_eddy_diffs()

◆ shear_prod_diagnostics()

◆ shoc_cldfrac_diagnostics()

◆ shoc_cond_diagnostics()

◆ shoc_olen_diagnostics()

◆ shoc_ql2_diagnostics()

◆ shoc_ql_diagnostics()

◆ shoc_ustar_diagnostics()

◆ store_carried_buoyancy_flux()

◆ store_carried_turbulence()

◆ thl_sec_diagnostics()

◆ uses_host_diffusion()

◆ uses_momentum_host_diffusion()

◆ uses_momentum_state_update()

◆ uses_state_update()

◆ w3_diagnostics()

◆ w_sec_diagnostics()

◆ wqls_sec_diagnostics()

◆ wqw_sec_diagnostics()

◆ wthl_sec_diagnostics()

◆ wthv_sec_diagnostics()

Member Data Documentation

◆ m_advance_calls

◆ m_brunt_cc

◆ m_buoy_prod_cc

◆ m_column_workspaces

◆ m_cons_ptr

◆ m_consumed_laten_flux_cc

◆ m_consumed_sens_flux_cc

◆ m_diss_tke_cc

◆ m_eddy_coeffs_cc

◆ m_eddy_diffs_ptr

◆ m_geom_ptr

◆ m_hfx3_ptr

◆ m_isotropy_cc

◆ m_lev

◆ m_moisture_indices

◆ m_moisture_type

◆ m_opts

◆ m_pblh_cc

◆ m_prev_turb_cc

◆ m_prev_turb_valid

◆ m_prev_wthv_sec_cc

◆ m_qc_tend_cc

◆ m_qfx3_ptr

◆ m_qi_tend_cc