#include <ERF_Radiation.H>

Inheritance diagram for Radiation:

Collaboration diagram for Radiation:

[legend]

Public Member Functions
	Radiation (const int &lev, SolverChoice &sc)

	~Radiation ()

virtual void	Init (const amrex::Geometry &geom, const amrex::BoxArray &ba, amrex::MultiFab *cons_in) override

virtual void	Run (int &level, int &step, amrex::Real &time, const amrex::Real &dt, const amrex::BoxArray &ba, amrex::Geometry &geom, amrex::MultiFab cons_in, amrex::MultiFab lsm_fluxes, amrex::MultiFab lsm_zenith, amrex::Vector< amrex::MultiFab > &lsm_input_ptrs, amrex::Vector< amrex::MultiFab * > &lsm_output_ptrs, amrex::MultiFab qheating_rates, amrex::MultiFab z_phys, amrex::MultiFab lat, amrex::MultiFab lon) override

void	set_grids (int &level, int &step, amrex::Real &time, const amrex::Real &dt, const amrex::BoxArray &ba, amrex::Geometry &geom, amrex::MultiFab cons_in, amrex::MultiFab lsm_fluxes, amrex::MultiFab lsm_zenith, amrex::Vector< amrex::MultiFab > &lsm_input_ptrs, amrex::MultiFab qheating_rates, amrex::MultiFab z_phys, amrex::MultiFab lat, amrex::MultiFab lon)

void	alloc_buffers ()

void	dealloc_buffers ()

void	mf_to_kokkos_buffers (amrex::Vector< amrex::MultiFab * > &lsm_input_ptrs)

void	kokkos_buffers_to_mf (amrex::Vector< amrex::MultiFab * > &lsm_output_ptrs)

void	write_rrtmgp_fluxes ()

void	initialize_impl ()

void	run_impl ()

void	finalize_impl (amrex::Vector< amrex::MultiFab * > &lsm_output_ptrs)

void	rad_run_impl (amrex::Vector< amrex::MultiFab * > &lsm_output_ptrs)

virtual amrex::Vector< std::string >	get_lsm_input_varnames () override

virtual amrex::Vector< std::string >	get_lsm_output_varnames () override

void	populateDatalogMF ()

virtual void	WriteDataLog (const amrex::Real &time) override

Public Member Functions inherited from IRadiation
virtual	~IRadiation ()=default

void	setupDataLog ()

void	setDataLogFrequency (const int nstep)

bool	hasDatalog ()

Private Attributes
int	m_lev

int	m_step

amrex::Real	m_time

amrex::Real	m_dt

amrex::Geometry	m_geom

amrex::BoxArray	m_ba

bool	m_update_rad = false

bool	m_rad_write_fluxes = false

bool	m_first_step = true

bool	m_moist = false

bool	m_ice = false

bool	m_lsm = false

amrex::Vector< std::string >	m_lsm_input_names

amrex::Vector< std::string >	m_lsm_output_names = {"sw_flux_dn", "lw_flux_dn"}

amrex::Real	m_rad_t_sfc = -1

amrex::MultiFab *	m_cons_in = nullptr

amrex::MultiFab *	m_qheating_rates = nullptr

amrex::MultiFab *	m_z_phys = nullptr

amrex::MultiFab *	m_lat = nullptr

amrex::MultiFab *	m_lon = nullptr

amrex::Real	m_lat_cons = 39.809860

amrex::Real	m_lon_cons = -98.555183

amrex::MultiFab *	m_lsm_fluxes = nullptr

amrex::MultiFab *	m_lsm_zenith = nullptr

amrex::MultiFab	datalog_mf

std::string	rrtmgp_file_path = "."

std::string	rrtmgp_coeffs_sw = "rrtmgp-data-sw-g224-2018-12-04.nc"

std::string	rrtmgp_coeffs_lw = "rrtmgp-data-lw-g224-2018-12-04.nc"

std::string	rrtmgp_cloud_optics_sw = "rrtmgp-cloud-optics-coeffs-sw.nc"

std::string	rrtmgp_cloud_optics_lw = "rrtmgp-cloud-optics-coeffs-lw.nc"

std::string	rrtmgp_coeffs_file_sw

std::string	rrtmgp_coeffs_file_lw

std::string	rrtmgp_cloud_optics_file_sw

std::string	rrtmgp_cloud_optics_file_lw

int	m_ngas = 8

const std::vector< std::string >	m_gas_names

const std::vector< amrex::Real >	m_mol_weight_gas

amrex::Real	m_co2vmr = 388.717e-6

amrex::Vector< amrex::Real >	m_o3vmr

amrex::Real	m_n2ovmr = 323.141e-9

amrex::Real	m_covmr = 1.0e-7

amrex::Real	m_ch4vmr = 1807.851e-9

amrex::Real	m_o2vmr = 0.209448

amrex::Real	m_n2vmr = 0.7906

int	m_o3_size

real1d_k	m_gas_mol_weights

std::vector< std::string >	gas_names_offset

GasConcsK< amrex::Real, layout_t, KokkosDefaultDevice >	m_gas_concs

int	m_ncol

int	m_nlay

amrex::Vector< int >	m_col_offsets

bool	m_do_aerosol_rad = true

bool	m_extra_clnsky_diag = false

bool	m_extra_clnclrsky_diag = false

int	m_orbital_year = -9999

int	m_orbital_mon = -9999

int	m_orbital_day = -9999

int	m_orbital_sec = -9999

bool	m_fixed_orbital_year = false

amrex::Real	m_orbital_eccen = -9999.

amrex::Real	m_orbital_obliq = -9999.

amrex::Real	m_orbital_mvelp = -9999.

amrex::Real	m_fixed_total_solar_irradiance = -9999.

amrex::Real	m_fixed_solar_zenith_angle = -9999.

int	m_nswbands = 14

int	m_nlwbands = 16

int	m_nswgpts = 112

int	m_nlwgpts = 128

int	m_rad_freq_in_steps = 1

bool	m_do_subcol_sampling = true

real1d_k	o3_lay

real1d_k	cosine_zenith

real1d_k	mu0

real1d_k	sfc_alb_dir_vis

real1d_k	sfc_alb_dir_nir

real1d_k	sfc_alb_dif_vis

real1d_k	sfc_alb_dif_nir

real1d_k	sfc_flux_dir_vis

real1d_k	sfc_flux_dir_nir

real1d_k	sfc_flux_dif_vis

real1d_k	sfc_flux_dif_nir

real1d_k	lat

real1d_k	lon

real1d_k	sfc_emis

real1d_k	t_sfc

real1d_k	lw_src

real2d_k	r_lay

real2d_k	p_lay

real2d_k	t_lay

real2d_k	z_del

real2d_k	p_del

real2d_k	qv_lay

real2d_k	qc_lay

real2d_k	qi_lay

real2d_k	cldfrac_tot

real2d_k	eff_radius_qc

real2d_k	eff_radius_qi

real2d_k	tmp2d

real2d_k	lwp

real2d_k	iwp

real2d_k	sw_heating

real2d_k	lw_heating

real2d_k	sw_clrsky_heating

real2d_k	lw_clrsky_heating

real2d_k	d_tint

real2d_k	p_lev

real2d_k	t_lev

real2d_k	sw_flux_up

real2d_k	sw_flux_dn

real2d_k	sw_flux_dn_dir

real2d_k	lw_flux_up

real2d_k	lw_flux_dn

real2d_k	sw_clnclrsky_flux_up

real2d_k	sw_clnclrsky_flux_dn

real2d_k	sw_clnclrsky_flux_dn_dir

real2d_k	sw_clrsky_flux_up

real2d_k	sw_clrsky_flux_dn

real2d_k	sw_clrsky_flux_dn_dir

real2d_k	sw_clnsky_flux_up

real2d_k	sw_clnsky_flux_dn

real2d_k	sw_clnsky_flux_dn_dir

real2d_k	lw_clnclrsky_flux_up

real2d_k	lw_clnclrsky_flux_dn

real2d_k	lw_clrsky_flux_up

real2d_k	lw_clrsky_flux_dn

real2d_k	lw_clnsky_flux_up

real2d_k	lw_clnsky_flux_dn

real3d_k	sw_bnd_flux_up

real3d_k	sw_bnd_flux_dn

real3d_k	sw_bnd_flux_dir

real3d_k	sw_bnd_flux_dif

real3d_k	lw_bnd_flux_up

real3d_k	lw_bnd_flux_dn

real2d_k	sfc_alb_dir

real2d_k	sfc_alb_dif

real2d_k	emis_sfc

real3d_k	aero_tau_sw

real3d_k	aero_ssa_sw

real3d_k	aero_g_sw

real3d_k	aero_tau_lw

real3d_k	cld_tau_sw_bnd

real3d_k	cld_tau_lw_bnd

real3d_k	cld_tau_sw_gpt

real3d_k	cld_tau_lw_gpt

Additional Inherited Members
Protected Attributes inherited from IRadiation
std::unique_ptr< std::fstream >	datalog = nullptr

std::string	datalogname

int	datalog_int = -1

Constructor & Destructor Documentation

◆ Radiation()

Radiation::Radiation	(	const int &	lev,
		SolverChoice &	sc
	)

 {
     // Note that Kokkos is now initialized in main.cpp
  
     // Check if we have a valid moisture model
     if (sc.moisture_type != MoistureType::None) { m_moist = true; }
  
     // Check if we have a moisture model with ice
     if (sc.moisture_type == MoistureType::SAM)  { m_ice = true; }
  
     // Check if we have a land surface model enabled
     if (sc.lsm_type != LandSurfaceType::None) { m_lsm = true; }
  
     // Construct parser object for following reads
     ParmParse pp("erf");
  
     // Must specify a surface temp without a LSM
     if (!m_lsm) { pp.get("rad_t_sfc",m_rad_t_sfc); }
  
     // Radiation timestep, as a number of atm steps
     pp.query("rad_freq_in_steps", m_rad_freq_in_steps);
  
     // Flag to write fluxes to plt file
     pp.query("rad_write_fluxes", m_rad_write_fluxes);
  
     // Do MCICA subcolumn sampling
     pp.query("rad_do_subcol_sampling", m_do_subcol_sampling);
  
     // Determine orbital year. If orbital_year is negative, use current year
     // from timestamp for orbital year; if positive, use provided orbital year
     // for duration of simulation.
     m_fixed_orbital_year = pp.query("rad_orbital_year", m_orbital_year);
  
     // Get orbital parameters from inputs file
     pp.query("rad_orbital_eccentricity", m_orbital_eccen);
     pp.query("rad_orbital_obliquity"   , m_orbital_obliq);
     pp.query("rad_orbital_mvelp"       , m_orbital_mvelp);
  
     // Get a constant lat/lon for idealized simulations
     pp.query("rad_cons_lat", m_lat_cons);
     pp.query("rad_cons_lon", m_lon_cons);
  
     // Value for prescribing an invariant solar constant (i.e. total solar irradiance at
     // TOA).  Used for idealized experiments such as RCE. Disabled when value is less than 0.
     pp.query("fixed_total_solar_irradiance", m_fixed_total_solar_irradiance);
  
     // Determine whether or not we are using a fixed solar zenith angle (positive value)
     pp.query("fixed_solar_zenith_angle", m_fixed_solar_zenith_angle);
  
     // Get prescribed surface values of greenhouse gases
     pp.query("co2vmr", m_co2vmr);
     pp.queryarr("o3vmr" , m_o3vmr );
     pp.query("n2ovmr", m_n2ovmr);
     pp.query("covmr" , m_covmr );
     pp.query("ch4vmr", m_ch4vmr);
     pp.query("o2vmr" , m_o2vmr );
     pp.query("n2vmr" , m_n2vmr );
  
     // Required aerosol optical properties from SPA
     pp.query("rad_do_aerosol", m_do_aerosol_rad);
  
     // Whether we do extra clean/clear sky calculations
     pp.query("rad_extra_clnclrsky_diag", m_extra_clnclrsky_diag);
     pp.query("rad_extra_clnsky_diag"   , m_extra_clnsky_diag);
  
     // Parse the band and gauss pt sizes
     pp.query("nswbands", m_nswbands);
     pp.query("nlwbands", m_nlwbands);
     pp.query("nswgpts" , m_nswgpts );
     pp.query("nlwgpts" , m_nlwgpts );
  
     // Parse path and file names
     pp.query("rrtmgp_file_path"      , rrtmgp_file_path);
     pp.query("rrtmgp_coeffs_sw"      , rrtmgp_coeffs_sw  );
     pp.query("rrtmgp_coeffs_lw"      , rrtmgp_coeffs_lw  );
     pp.query("rrtmgp_cloud_optics_sw", rrtmgp_cloud_optics_sw);
     pp.query("rrtmgp_cloud_optics_lw", rrtmgp_cloud_optics_lw);
  
     // Append file names to path
     rrtmgp_coeffs_file_sw       = rrtmgp_file_path + "/" + rrtmgp_coeffs_sw;
     rrtmgp_coeffs_file_lw       = rrtmgp_file_path + "/" + rrtmgp_coeffs_lw;
     rrtmgp_cloud_optics_file_sw = rrtmgp_file_path + "/" + rrtmgp_cloud_optics_sw;
     rrtmgp_cloud_optics_file_lw = rrtmgp_file_path + "/" + rrtmgp_cloud_optics_lw;
  
     // Output for user
     if (lev == 0) {
         Print() << "Radiation interface constructed:\n";
         Print() << "========================================================\n";
         Print() << "Coeff SW file: " << rrtmgp_coeffs_file_sw << "\n";
         Print() << "Coeff LW file: " << rrtmgp_coeffs_file_lw << "\n";
         Print() << "Cloud SW file: " << rrtmgp_cloud_optics_file_sw << "\n";
         Print() << "Cloud LW file: " << rrtmgp_cloud_optics_file_lw << "\n";
         Print() << "========================================================\n";
     }
 }

Here is the call graph for this function:

◆ ~Radiation()

Radiation::~Radiation ( )

inline

     {
         // Note that Kokkos is now finalized in main.cpp
     }

Member Function Documentation

◆ alloc_buffers()

void Radiation::alloc_buffers ( )

 {
     // 1d size (m_ngas)
     const Real* mol_weight_gas_p = m_mol_weight_gas.data();
     const std::string* gas_names_p = m_gas_names.data();
     m_gas_mol_weights = real1d_k("m_gas_mol_weights", m_ngas);
     realHost1d_k m_gas_mol_weights_h("m_gas_mol_weights_h", m_ngas);
     gas_names_offset.clear(); gas_names_offset.resize(m_ngas);
     std::string* gas_names_offset_p = gas_names_offset.data();
     Kokkos::parallel_for(Kokkos::RangePolicy<Kokkos::Serial>(0, m_ngas),
                          KOKKOS_LAMBDA (int igas)
     {
         m_gas_mol_weights_h(igas) = mol_weight_gas_p[igas];
         gas_names_offset_p[igas]  = gas_names_p[igas];
     });
     Kokkos::deep_copy(m_gas_mol_weights, m_gas_mol_weights_h);
  
     // 1d size (1 or nlay)
     m_o3_size = m_o3vmr.size();
     AMREX_ALWAYS_ASSERT_WITH_MESSAGE(((m_o3_size==1) || (m_o3_size==m_nlay)),
                                      "O3 VMR array must be length 1 or nlay");
     Real* o3vmr_p = m_o3vmr.data();
     o3_lay = real1d_k("o3_lay", m_o3_size);
     realHost1d_k o3_lay_h("o3_lay_h", m_o3_size);
     Kokkos::parallel_for(Kokkos::RangePolicy<Kokkos::Serial>(0, m_o3_size),
                          KOKKOS_LAMBDA (int io3)
     {
         o3_lay_h(io3) = o3vmr_p[io3];
     });
     Kokkos::deep_copy(o3_lay, o3_lay_h);
  
     // 1d size (ncol)
     cosine_zenith    = real1d_k("cosine_zenith"   , m_ncol);
     mu0              = real1d_k("mu0"             , m_ncol);
     sfc_alb_dir_vis  = real1d_k("sfc_alb_dir_vis" , m_ncol);
     sfc_alb_dir_nir  = real1d_k("sfc_alb_dir_nir" , m_ncol);
     sfc_alb_dif_vis  = real1d_k("sfc_alb_dif_vis" , m_ncol);
     sfc_alb_dif_nir  = real1d_k("sfc_alb_dif_nir" , m_ncol);
     sfc_flux_dir_vis = real1d_k("sfc_flux_dir_vis", m_ncol);
     sfc_flux_dir_nir = real1d_k("sfc_flux_dir_nir", m_ncol);
     sfc_flux_dif_vis = real1d_k("sfc_flux_dif_vis", m_ncol);
     sfc_flux_dif_nir = real1d_k("sfc_flux_dif_nir", m_ncol);
     lat              = real1d_k("lat"             , m_ncol);
     lon              = real1d_k("lon"             , m_ncol);
     sfc_emis         = real1d_k("sfc_emis"        , m_ncol);
     t_sfc            = real1d_k("t_sfc"           , m_ncol);
     lw_src           = real1d_k("lw_src"          , m_ncol);
  
     // 2d size (ncol, nlay)
     r_lay         = real2d_k("r_lay"        , m_ncol, m_nlay);
     p_lay         = real2d_k("p_lay"        , m_ncol, m_nlay);
     t_lay         = real2d_k("t_lay"        , m_ncol, m_nlay);
     z_del         = real2d_k("z_del"        , m_ncol, m_nlay);
     p_del         = real2d_k("p_del"        , m_ncol, m_nlay);
     qv_lay        = real2d_k("qv"           , m_ncol, m_nlay);
     qc_lay        = real2d_k("qc"           , m_ncol, m_nlay);
     qi_lay        = real2d_k("qi"           , m_ncol, m_nlay);
     cldfrac_tot   = real2d_k("cldfrac_tot"  , m_ncol, m_nlay);
     eff_radius_qc = real2d_k("eff_radius_qc", m_ncol, m_nlay);
     eff_radius_qi = real2d_k("eff_radius_qi", m_ncol, m_nlay);
     tmp2d         = real2d_k("tmp2d"        , m_ncol, m_nlay);
     lwp           = real2d_k("lwp"          , m_ncol, m_nlay);
     iwp           = real2d_k("iwp"          , m_ncol, m_nlay);
     sw_heating    = real2d_k("sw_heating"   , m_ncol, m_nlay);
     lw_heating    = real2d_k("lw_heating"   , m_ncol, m_nlay);
     sw_clrsky_heating = real2d_k("sw_clrsky_heating", m_ncol, m_nlay);
     lw_clrsky_heating = real2d_k("lw_clrsky_heating", m_ncol, m_nlay);
  
     // 2d size (ncol, nlay+1)
     d_tint                   = real2d_k("d_tint"                  , m_ncol, m_nlay+1);
     p_lev                    = real2d_k("p_lev"                   , m_ncol, m_nlay+1);
     t_lev                    = real2d_k("t_lev"                   , m_ncol, m_nlay+1);
     sw_flux_up               = real2d_k("sw_flux_up"              , m_ncol, m_nlay+1);
     sw_flux_dn               = real2d_k("sw_flux_dn"              , m_ncol, m_nlay+1);
     sw_flux_dn_dir           = real2d_k("sw_flux_dn_dir"          , m_ncol, m_nlay+1);
     lw_flux_up               = real2d_k("sw_flux_up"              , m_ncol, m_nlay+1);
     lw_flux_dn               = real2d_k("sw_flux_dn"              , m_ncol, m_nlay+1);
     sw_clnclrsky_flux_up     = real2d_k("sw_clnclrsky_flux_up"    , m_ncol, m_nlay+1);
     sw_clnclrsky_flux_dn     = real2d_k("sw_clnclrsky_flux_dn"    , m_ncol, m_nlay+1);
     sw_clnclrsky_flux_dn_dir = real2d_k("sw_clnclrsky_flux_dn_dir", m_ncol, m_nlay+1);
     sw_clrsky_flux_up        = real2d_k("sw_clrsky_flux_up"       , m_ncol, m_nlay+1);
     sw_clrsky_flux_dn        = real2d_k("sw_clrsky_flux_dn"       , m_ncol, m_nlay+1);
     sw_clrsky_flux_dn_dir    = real2d_k("sw_clrsky_flux_dn_dir"   , m_ncol, m_nlay+1);
     sw_clnsky_flux_up        = real2d_k("sw_clnsky_flux_up"       , m_ncol, m_nlay+1);
     sw_clnsky_flux_dn        = real2d_k("sw_clnsky_flux_dn"       , m_ncol, m_nlay+1);
     sw_clnsky_flux_dn_dir    = real2d_k("sw_clnsky_flux_dn_dir"   , m_ncol, m_nlay+1);
     lw_clnclrsky_flux_up     = real2d_k("lw_clnclrsky_flux_up"    , m_ncol, m_nlay+1);
     lw_clnclrsky_flux_dn     = real2d_k("lw_clnclrsky_flux_dn"    , m_ncol, m_nlay+1);
     lw_clrsky_flux_up        = real2d_k("lw_clrsky_flux_up"       , m_ncol, m_nlay+1);
     lw_clrsky_flux_dn        = real2d_k("lw_clrsky_flux_dn"       , m_ncol, m_nlay+1);
     lw_clnsky_flux_up        = real2d_k("lw_clnsky_flux_up"       , m_ncol, m_nlay+1);
     lw_clnsky_flux_dn        = real2d_k("lw_clnsky_flux_dn"       , m_ncol, m_nlay+1);
  
     // 3d size (ncol, nlay+1, nswbands)
     sw_bnd_flux_up  = real3d_k("sw_bnd_flux_up" , m_ncol, m_nlay+1, m_nswbands);
     sw_bnd_flux_dn  = real3d_k("sw_bnd_flux_dn" , m_ncol, m_nlay+1, m_nswbands);
     sw_bnd_flux_dir = real3d_k("sw_bnd_flux_dir", m_ncol, m_nlay+1, m_nswbands);
     sw_bnd_flux_dif = real3d_k("sw_bnd_flux_dif", m_ncol, m_nlay+1, m_nswbands);
  
     // 3d size (ncol, nlay+1, nlwbands)
     lw_bnd_flux_up = real3d_k("lw_bnd_flux_up" , m_ncol, m_nlay+1, m_nlwbands);
     lw_bnd_flux_dn = real3d_k("lw_bnd_flux_up" , m_ncol, m_nlay+1, m_nlwbands);
  
     // 2d size (ncol, nswbands)
     sfc_alb_dir = real2d_k("sfc_alb_dir", m_ncol, m_nswbands);
     sfc_alb_dif = real2d_k("sfc_alb_dif", m_ncol, m_nswbands);
  
     // 2d size (ncol, nlwbands)
     emis_sfc    = real2d_k("emis_sfc", m_ncol, m_nlwbands);
  
     // 3d size (ncol, nlay, n[sw,lw]bands)
     aero_tau_sw = real3d_k("aero_tau_sw", m_ncol, m_nlay, m_nswbands);
     aero_ssa_sw = real3d_k("aero_ssa_sw", m_ncol, m_nlay, m_nswbands);
     aero_g_sw   = real3d_k("aero_g_sw"  , m_ncol, m_nlay, m_nswbands);
     aero_tau_lw = real3d_k("aero_tau_lw", m_ncol, m_nlay, m_nlwbands);
  
     // 3d size (ncol, nlay, n[sw,lw]bnds)
     cld_tau_sw_bnd = real3d_k("cld_tau_sw_bnd", m_ncol, m_nlay, m_nswbands);
     cld_tau_lw_bnd = real3d_k("cld_tau_lw_bnd", m_ncol, m_nlay, m_nlwbands);
  
     // 3d size (ncol, nlay, n[sw,lw]gpts)
     cld_tau_sw_gpt = real3d_k("cld_tau_sw_gpt", m_ncol, m_nlay, m_nswgpts);
     cld_tau_lw_gpt = real3d_k("cld_tau_lw_gpt", m_ncol, m_nlay, m_nlwgpts);
 }

◆ dealloc_buffers()

void Radiation::dealloc_buffers ( )

 {
     // 1d size (m_ngas)
     m_gas_mol_weights = real1d_k();
  
     // 1d size (1 or nlay)
     o3_lay = real1d_k();
  
     // 1d size (ncol)
     cosine_zenith    = real1d_k();
     mu0              = real1d_k();
     sfc_alb_dir_vis  = real1d_k();
     sfc_alb_dir_nir  = real1d_k();
     sfc_alb_dif_vis  = real1d_k();
     sfc_alb_dif_nir  = real1d_k();
     sfc_flux_dir_vis = real1d_k();
     sfc_flux_dir_nir = real1d_k();
     sfc_flux_dif_vis = real1d_k();
     sfc_flux_dif_nir = real1d_k();
     lat              = real1d_k();
     lon              = real1d_k();
     sfc_emis         = real1d_k();
     t_sfc            = real1d_k();
     lw_src           = real1d_k();
  
     // 2d size (ncol, nlay)
     r_lay             = real2d_k();
     p_lay             = real2d_k();
     t_lay             = real2d_k();
     z_del             = real2d_k();
     p_del             = real2d_k();
     qv_lay            = real2d_k();
     qc_lay            = real2d_k();
     qi_lay            = real2d_k();
     cldfrac_tot       = real2d_k();
     eff_radius_qc     = real2d_k();
     eff_radius_qi     = real2d_k();
     tmp2d             = real2d_k();
     lwp               = real2d_k();
     iwp               = real2d_k();
     sw_heating        = real2d_k();
     lw_heating        = real2d_k();
     sw_clrsky_heating = real2d_k();
     lw_clrsky_heating = real2d_k();
     sw_heating        = real2d_k();
     lw_heating        = real2d_k();
     sw_clrsky_heating = real2d_k();
     lw_clrsky_heating = real2d_k();
  
     // 2d size (ncol, nlay+1)
     d_tint                   = real2d_k();
     p_lev                    = real2d_k();
     t_lev                    = real2d_k();
     sw_flux_up               = real2d_k();
     sw_flux_dn               = real2d_k();
     sw_flux_dn_dir           = real2d_k();
     lw_flux_up               = real2d_k();
     lw_flux_dn               = real2d_k();
     sw_clnclrsky_flux_up     = real2d_k();
     sw_clnclrsky_flux_dn     = real2d_k();
     sw_clnclrsky_flux_dn_dir = real2d_k();
     sw_clrsky_flux_up        = real2d_k();
     sw_clrsky_flux_dn        = real2d_k();
     sw_clrsky_flux_dn_dir    = real2d_k();
     sw_clnsky_flux_up        = real2d_k();
     sw_clnsky_flux_dn        = real2d_k();
     sw_clnsky_flux_dn_dir    = real2d_k();
     lw_clnclrsky_flux_up     = real2d_k();
     lw_clnclrsky_flux_dn     = real2d_k();
     lw_clrsky_flux_up        = real2d_k();
     lw_clrsky_flux_dn        = real2d_k();
     lw_clnsky_flux_up        = real2d_k();
     lw_clnsky_flux_dn        = real2d_k();
  
     // 3d size (ncol, nlay+1, nswbands)
     sw_bnd_flux_up  = real3d_k();
     sw_bnd_flux_dn  = real3d_k();
     sw_bnd_flux_dir = real3d_k();
     sw_bnd_flux_dif = real3d_k();
  
     // 3d size (ncol, nlay+1, nlwbands)
     lw_bnd_flux_up = real3d_k();
     lw_bnd_flux_dn = real3d_k();
  
     // 2d size (ncol, nswbands)
     sfc_alb_dir = real2d_k();
     sfc_alb_dif = real2d_k();
  
     // 2d size (ncol, nlwbands)
     emis_sfc = real2d_k();
  
     // 3d size (ncol, nlay, n[sw,lw]bands)
     aero_tau_sw = real3d_k();
     aero_ssa_sw = real3d_k();
     aero_g_sw   = real3d_k();
     aero_tau_lw = real3d_k();
  
     // 3d size (ncol, nlay, n[sw,lw]bnds)
     cld_tau_sw_bnd = real3d_k();
     cld_tau_lw_bnd = real3d_k();
  
     // 3d size (ncol, nlay, n[sw,lw]gpts)
     cld_tau_sw_gpt = real3d_k();
     cld_tau_lw_gpt = real3d_k();
 }

◆ finalize_impl()

void Radiation::finalize_impl ( amrex::Vector< amrex::MultiFab * > & lsm_output_ptrs )

 {
     // Finish rrtmgp
     m_gas_concs.reset();
     rrtmgp::rrtmgp_finalize();
  
     // Fill the AMReX MFs from Kokkos Views
     kokkos_buffers_to_mf(lsm_output_ptrs);
  
     // Write fluxes if requested
     if (m_rad_write_fluxes) { write_rrtmgp_fluxes(); }
  
     // Fill output data for datalog before deallocating
     if (datalog_int > 0) {
         rrtmgp::compute_heating_rate(sw_clrsky_flux_up, sw_clrsky_flux_dn, r_lay, z_del, sw_clrsky_heating);
         rrtmgp::compute_heating_rate(lw_clrsky_flux_up, lw_clrsky_flux_dn, r_lay, z_del, lw_clrsky_heating);
  
         populateDatalogMF();
     }
  
     // Deallocate the buffer arrays
     dealloc_buffers();
 }

Referenced by rad_run_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_lsm_input_varnames()

virtual amrex::Vector<std::string> Radiation::get_lsm_input_varnames ( )

inlineoverridevirtual

Reimplemented from IRadiation.

     {
         return m_lsm_input_names;
     }

◆ get_lsm_output_varnames()

virtual amrex::Vector<std::string> Radiation::get_lsm_output_varnames ( )

inlineoverridevirtual

Reimplemented from IRadiation.

     {
         return m_lsm_output_names;
     }

◆ Init()

virtual void Radiation::Init	(	const amrex::Geometry &	geom,
		const amrex::BoxArray &	ba,
		amrex::MultiFab *	cons_in
	)

inlineoverridevirtual

Implements IRadiation.

     {
         // Ensure the boxes span klo -> khi
         int klo = geom.Domain().smallEnd(2);
         int khi = geom.Domain().bigEnd(2);
  
         // Reset vector of offsets for columnar data
         m_nlay = geom.Domain().length(2);
  
         m_ncol = 0;
         m_col_offsets.clear();
         m_col_offsets.resize(int(ba.size()));
         for (amrex::MFIter mfi(*cons_in); mfi.isValid(); ++mfi) {
             const amrex::Box& vbx = mfi.validbox();
             AMREX_ALWAYS_ASSERT_WITH_MESSAGE((klo == vbx.smallEnd(2)) &&
                                              (khi == vbx.bigEnd(2)),
                                              "Vertical decomposition with radiation is not allowed.");
             int nx = vbx.length(0);
             int ny = vbx.length(1);
             m_col_offsets[mfi.index()] = m_ncol;
             m_ncol += nx * ny;
         }
     };

◆ initialize_impl()

void Radiation::initialize_impl ( )

 {
     // Call API to initialize
     m_gas_concs.init(gas_names_offset, m_ncol, m_nlay);
     rrtmgp::rrtmgp_initialize(m_gas_concs,
                               rrtmgp_coeffs_file_sw      , rrtmgp_coeffs_file_lw      ,
                               rrtmgp_cloud_optics_file_sw, rrtmgp_cloud_optics_file_lw);
 }

Referenced by rad_run_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ kokkos_buffers_to_mf()

void Radiation::kokkos_buffers_to_mf ( amrex::Vector< amrex::MultiFab * > & lsm_output_ptrs )

 {
     // Heating rate, fluxes, zenith, lsm ptrs
     Vector<real2d_k> rrtmgp_out_vars = {sw_flux_dn, lw_flux_dn};
  
     // Expose for device
     auto sw_heating_d = sw_heating;
     auto lw_heating_d = lw_heating;
     auto p_lay_d = p_lay;
     auto sfc_flux_dir_vis_d = sfc_flux_dir_vis;
     auto sfc_flux_dir_nir_d = sfc_flux_dir_nir;
     auto sfc_flux_dif_vis_d = sfc_flux_dif_vis;
     auto sfc_flux_dif_nir_d = sfc_flux_dif_nir;
     auto lw_flux_dn_d = lw_flux_dn;
     auto mu0_d = mu0;
  
     for (MFIter mfi(*m_cons_in); mfi.isValid(); ++mfi) {
         const auto& vbx      = mfi.validbox();
         const auto& sbx      = makeSlab(vbx,2,vbx.smallEnd(2));
         const int nx         = vbx.length(0);
         const int imin       = vbx.smallEnd(0);
         const int jmin       = vbx.smallEnd(1);
         const int offset     = m_col_offsets[mfi.index()];
         const Array4<Real>& q_arr = m_qheating_rates->array(mfi);
         ParallelFor(vbx, [=] AMREX_GPU_DEVICE (int i, int j, int k)
         {
             // map [i,j,k] 0-based to [icol, ilay] 0-based
             const int icol = (j-jmin)*nx + (i-imin) + offset;
             const int ilay = k;
  
             // Temperature heating rate for SW and LW
             q_arr(i,j,k,0) = sw_heating_d(icol,ilay);
             q_arr(i,j,k,1) = lw_heating_d(icol,ilay);
  
             // Convert the rates for theta_d
             Real exner = getExnergivenP(Real(p_lay_d(icol,ilay)), R_d/Cp_d);
             q_arr(i,j,k,0) *= exner;
             q_arr(i,j,k,1) *= exner;
         });
         if (m_lsm_fluxes) {
             const Array4<Real>& lsm_arr =  m_lsm_fluxes->array(mfi);
             ParallelFor(sbx, [=] AMREX_GPU_DEVICE (int i, int j, int k)
             {
                 // map [i,j,k] 0-based to [icol, ilay] 0-based
                 const int icol = (j-jmin)*nx + (i-imin) + offset;
  
                 // SW fluxes for LSM
                 lsm_arr(i,j,k,0) = sfc_flux_dir_vis_d(icol);
                 lsm_arr(i,j,k,1) = sfc_flux_dir_nir_d(icol);
                 lsm_arr(i,j,k,2) = sfc_flux_dif_vis_d(icol);
                 lsm_arr(i,j,k,3) = sfc_flux_dif_nir_d(icol);
  
                 // Net SW flux for LSM
                 lsm_arr(i,j,k,4) = sfc_flux_dir_vis_d(icol) + sfc_flux_dir_nir_d(icol)
                                  + sfc_flux_dif_vis_d(icol) + sfc_flux_dif_nir_d(icol);
  
                 // LW flux for LSM (at bottom surface)
                 lsm_arr(i,j,k,5) = lw_flux_dn_d(icol,0);
             });
         }
         if (m_lsm_zenith) {
             const Array4<Real>& lsm_zenith_arr =  m_lsm_zenith->array(mfi);
             ParallelFor(sbx, [=] AMREX_GPU_DEVICE (int i, int j, int k)
             {
                 // map [i,j,k] 0-based to [icol, ilay] 0-based
                 const int icol = (j-jmin)*nx + (i-imin) + offset;
  
                 // export cosine zenith angle for LSM
                 lsm_zenith_arr(i,j,k) = mu0_d(icol);
             });
         }
         for (int ivar(0); ivar<lsm_output_ptrs.size(); ivar++) {
             auto rrtmgp_for_fill = rrtmgp_out_vars[ivar];
             if (lsm_output_ptrs[ivar]) {
                 const Array4<Real>& lsm_out_arr = lsm_output_ptrs[ivar]->array(mfi);
                 ParallelFor(sbx, [=] AMREX_GPU_DEVICE (int i, int j, int k)
                 {
                     // map [i,j,k] 0-based to [icol, ilay] 0-based
                     const int icol   = (j-jmin)*nx + (i-imin) + offset;
  
                     // export the desired variable at surface
                     lsm_out_arr(i,j,k) = rrtmgp_for_fill(icol,0);
                 });
             } // valid ptr
         } // ivar
     }// mfi
 }

Here is the call graph for this function:

◆ mf_to_kokkos_buffers()

void Radiation::mf_to_kokkos_buffers ( amrex::Vector< amrex::MultiFab * > & lsm_input_ptrs )

 {
     // Expose for device
     auto r_lay_d  = r_lay;
     auto p_lay_d  = p_lay;
     auto t_lay_d  = t_lay;
     auto z_del_d  = z_del;
     auto qv_lay_d = qv_lay;
     auto qc_lay_d = qc_lay;
     auto qi_lay_d = qi_lay;
     auto cldfrac_tot_d = cldfrac_tot;
     auto lwp_d = lwp;
     auto iwp_d = iwp;
     auto eff_radius_qc_d = eff_radius_qc;
     auto eff_radius_qi_d = eff_radius_qi;
     auto p_lev_d = p_lev;
     auto t_lev_d = t_lev;
     auto lat_d = lat;
     auto lon_d = lon;
     auto t_sfc_d = t_sfc;
     auto p_del_d = p_del;
  
     bool moist = m_moist;
     bool ice   = m_ice;
     const bool has_lsm = m_lsm;
     const bool has_lat = m_lat;
     const bool has_lon = m_lon;
     int  ncol  = m_ncol;
     int  nlay  = m_nlay;
     Real dz    = m_geom.CellSize(2);
     Real cons_lat = m_lat_cons;
     Real cons_lon = m_lon_cons;
     Real rad_t_sfc = m_rad_t_sfc;
     for (MFIter mfi(*m_cons_in); mfi.isValid(); ++mfi) {
         const auto& vbx  = mfi.validbox();
         const int nx     = vbx.length(0);
         const int imin   = vbx.smallEnd(0);
         const int jmin   = vbx.smallEnd(1);
         const int offset = m_col_offsets[mfi.index()];
         const Array4<const Real>& cons_arr = m_cons_in->const_array(mfi);
         const Array4<const Real>& z_arr    = (m_z_phys) ? m_z_phys->const_array(mfi) :
                                                           Array4<const Real>{};
         const Array4<const Real>& lat_arr  = (m_lat)    ? m_lat->const_array(mfi) :
                                                           Array4<const Real>{};
         const Array4<const Real>& lon_arr  = (m_lon)    ? m_lon->const_array(mfi) :
                                                           Array4<const Real>{};
         ParallelFor(vbx, [=] AMREX_GPU_DEVICE (int i, int j, int k)
         {
             // map [i,j,k] 0-based to [icol, ilay] 0-based
             const int icol   = (j-jmin)*nx + (i-imin) + offset;
             const int ilay   = k;
  
             // EOS input (at CC)
             Real r  = cons_arr(i,j,k,Rho_comp);
             Real rt = cons_arr(i,j,k,RhoTheta_comp);
             Real qv = (moist) ? std::max(cons_arr(i,j,k,RhoQ1_comp)/r,0.0) : 0.0;
             Real qc = (moist) ? std::max(cons_arr(i,j,k,RhoQ2_comp)/r,0.0) : 0.0;
             Real qi = (ice)   ? std::max(cons_arr(i,j,k,RhoQ3_comp)/r,0.0) : 0.0;
  
             // EOS avg to z-face
             Real r_lo   = cons_arr(i,j,k-1,Rho_comp);
             Real rt_lo  = cons_arr(i,j,k-1,RhoTheta_comp);
             Real qv_lo  = (moist) ? cons_arr(i,j,k-1,RhoQ1_comp)/r_lo : 0.0;
             Real r_avg  = 0.5 * (r  + r_lo);
             Real rt_avg = 0.5 * (rt + rt_lo);
             Real qv_avg = 0.5 * (qv + qv_lo);
  
             // Views at CC
             r_lay_d(icol,ilay) = r;
             p_lay_d(icol,ilay) = getPgivenRTh(rt, qv);
             t_lay_d(icol,ilay) = getTgivenRandRTh(r, rt, qv);
             z_del_d(icol,ilay) = (z_arr) ? 0.25 * ( (z_arr(i  ,j  ,k+1) - z_arr(i  ,j  ,k))
                                                   + (z_arr(i+1,j  ,k+1) - z_arr(i+1,j  ,k))
                                                   + (z_arr(i  ,j+1,k+1) - z_arr(i  ,j+1,k))
                                                   + (z_arr(i+1,j+1,k+1) - z_arr(i+1,j+1,k)) ) : dz;
             qv_lay_d(icol,ilay) = qv;
             qc_lay_d(icol,ilay) = qc;
             qi_lay_d(icol,ilay) = qi;
             cldfrac_tot_d(icol,ilay) = ((qc+qi)>0.0) ? 1. : 0.;
  
             // NOTE: These are populated in 'mixing_ratio_to_cloud_mass'
             lwp_d(icol,ilay) = 0.0;
             iwp_d(icol,ilay) = 0.0;
  
             // NOTE: These would be populated from P3 (we use the constants in p3_main_impl.hpp)
             eff_radius_qc_d(icol,ilay) = (qc>0.0) ? 10.0e-6 : 0.0;
             eff_radius_qi_d(icol,ilay) = (qi>0.0) ? 25.0e-6 : 0.0;
  
             // Buffers on z-faces (nlay+1)
             p_lev_d(icol,ilay) = getPgivenRTh(rt_avg, qv_avg);
             t_lev_d(icol,ilay) = getTgivenRandRTh(r_avg, rt_avg, qv_avg);
             if (ilay==(nlay-1)) {
                 Real r_hi  = cons_arr(i,j,k+1,Rho_comp);
                 Real rt_hi = cons_arr(i,j,k+1,RhoTheta_comp);
                 Real qv_hi = (moist) ? std::max(cons_arr(i,j,k+1,RhoQ1_comp)/r_hi,0.0) : 0.0;
                 r_avg  = 0.5 * (r  + r_hi);
                 rt_avg = 0.5 * (rt + rt_hi);
                 qv_avg = 0.5 * (qv + qv_hi);
                 p_lev_d(icol,ilay+1) = getPgivenRTh(rt_avg, qv_avg);
                 t_lev_d(icol,ilay+1) = getTgivenRandRTh(r_avg, rt_avg, qv_avg);
             }
  
             // 1D data structures
             if (k==0) {
                 lat_d(icol) = (has_lat) ? lat_arr(i,j,0) : cons_lat;
                 lon_d(icol) = (has_lon) ? lon_arr(i,j,0) : cons_lon;
             }
  
         });
     } // mfi
  
     // EAMXX delP is positive
     Kokkos::parallel_for(Kokkos::MDRangePolicy<Kokkos::Rank<2>>({0, 0}, {ncol, nlay}),
                          KOKKOS_LAMBDA (int icol, int ilay)
     {
         p_del_d(icol,ilay)  = std::abs(p_lev_d(icol,ilay+1) - p_lev_d(icol,ilay));
     });
  
     // Populate vars LSM would provide
     if (!has_lsm) {
         // Parsed surface temp
         Kokkos::deep_copy(t_sfc, rad_t_sfc);
  
         // EAMXX dummy atmos constants
         Kokkos::deep_copy(sfc_alb_dir_vis, 0.06);
         Kokkos::deep_copy(sfc_alb_dir_nir, 0.06);
         Kokkos::deep_copy(sfc_alb_dif_vis, 0.06);
         Kokkos::deep_copy(sfc_alb_dif_nir, 0.06);
  
         // AML NOTE: These are not used in current EAMXX, I've left
         //           the code to plug into these if we need it.
         //
         // Current EAMXX constants
         Kokkos::deep_copy(emis_sfc, 0.98);
         Kokkos::deep_copy(lw_src  , 0.0 );
     } else {
         Vector<real1d_k> rrtmgp_in_vars = {t_sfc, sfc_emis,
                                            sfc_alb_dir_vis, sfc_alb_dir_nir,
                                            sfc_alb_dif_vis, sfc_alb_dif_nir};
         Vector<Real> rrtmgp_default_vals = {rad_t_sfc, 0.98,
                                             0.06, 0.06,
                                             0.06, 0.06};
         for (int ivar(0); ivar<lsm_input_ptrs.size(); ivar++) {
             auto rrtmgp_to_fill = rrtmgp_in_vars[ivar];
             if (!lsm_input_ptrs[ivar]) {
                 Kokkos::deep_copy(rrtmgp_to_fill, rrtmgp_default_vals[ivar]);
             } else {
                 for (MFIter mfi(*m_cons_in); mfi.isValid(); ++mfi) {
                     const auto& vbx  = mfi.validbox();
                     const auto& sbx  = makeSlab(vbx,2,vbx.smallEnd(2));
                     const int nx     = vbx.length(0);
                     const int imin   = vbx.smallEnd(0);
                     const int jmin   = vbx.smallEnd(1);
                     const int offset = m_col_offsets[mfi.index()];
                     const Array4<const Real>& lsm_in_arr = lsm_input_ptrs[ivar]->const_array(mfi);
                     ParallelFor(sbx, [=] AMREX_GPU_DEVICE (int i, int j, int k)
                     {
                         // map [i,j,k] 0-based to [icol, ilay] 0-based
                         const int icol   = (j-jmin)*nx + (i-imin) + offset;
  
                         // 2D mf and 1D view
                         rrtmgp_to_fill(icol) = lsm_in_arr(i,j,k);
                     });
                 } //mfi
             } // valid lsm ptr
         } // ivar
         Kokkos::deep_copy(lw_src, 0.0 );
     } // have lsm
  
     // Enforce consistency between t_sfc and t_lev at bottom surface
     Kokkos::parallel_for(Kokkos::RangePolicy(0, ncol),
                          KOKKOS_LAMBDA (int icol)
     {
         t_lev_d(icol,0) = t_sfc_d(icol);
     });
 }

Here is the call graph for this function:

◆ populateDatalogMF()

void Radiation::populateDatalogMF ( )

 {
     // Expose for device
     auto sw_flux_up_d = sw_flux_up;
     auto sw_flux_dn_d = sw_flux_dn;
     auto sw_flux_dn_dir_d = sw_flux_dn_dir;
     auto lw_flux_up_d = lw_flux_up;
     auto lw_flux_dn_d = lw_flux_dn;
     auto mu0_d = mu0;
     auto sw_clrsky_heating_d = sw_clrsky_heating;
     auto lw_clrsky_heating_d = lw_clrsky_heating;
  
     auto sw_clrsky_flux_up_d = sw_clrsky_flux_up;
     auto sw_clrsky_flux_dn_d = sw_clrsky_flux_dn;
     auto sw_clrsky_flux_dn_dir_d = sw_clrsky_flux_dn_dir;
     auto lw_clrsky_flux_up_d = lw_clrsky_flux_up;
     auto lw_clrsky_flux_dn_d = lw_clrsky_flux_dn;
     auto sw_clnsky_flux_up_d = sw_clnsky_flux_up;
     auto sw_clnsky_flux_dn_d = sw_clnsky_flux_dn;
     auto sw_clnsky_flux_dn_dir_d = sw_clnsky_flux_dn_dir;
     auto lw_clnsky_flux_up_d = lw_clnsky_flux_up;
     auto lw_clnsky_flux_dn_d = lw_clnsky_flux_dn;
     auto sw_clnclrsky_flux_up_d = sw_clnclrsky_flux_up;
     auto sw_clnclrsky_flux_dn_d = sw_clnclrsky_flux_dn;
     auto sw_clnclrsky_flux_dn_dir_d = sw_clnclrsky_flux_dn_dir;
     auto lw_clnclrsky_flux_up_d = lw_clnclrsky_flux_up;
     auto lw_clnclrsky_flux_dn_d = lw_clnclrsky_flux_dn;
  
     auto extra_clnsky_diag = m_extra_clnsky_diag;
     auto extra_clnclrsky_diag = m_extra_clnclrsky_diag;
  
     for (MFIter mfi(datalog_mf); mfi.isValid(); ++mfi) {
         const auto& vbx      = mfi.validbox();
         const int nx         = vbx.length(0);
         const int imin       = vbx.smallEnd(0);
         const int jmin       = vbx.smallEnd(1);
         const int offset     = m_col_offsets[mfi.index()];
         const Array4<Real>& dst_arr = datalog_mf.array(mfi);
         const Array4<Real>&   q_arr = m_qheating_rates->array(mfi);
         ParallelFor(vbx, [=] AMREX_GPU_DEVICE (int i, int j, int k)
         {
             // map [i,j,k] 0-based to [icol, ilay] 0-based
             const int icol = (j-jmin)*nx + (i-imin) + offset;
             const int ilay = k;
  
             dst_arr(i,j,k,0) = q_arr(i, j, k, 0);
             dst_arr(i,j,k,1) = q_arr(i, j, k, 1);
  
             // SW and LW fluxes
             dst_arr(i,j,k,2) = sw_flux_up_d(icol,ilay);
             dst_arr(i,j,k,3) = sw_flux_dn_d(icol,ilay);
             dst_arr(i,j,k,4) = sw_flux_dn_dir_d(icol,ilay);
             dst_arr(i,j,k,5) = lw_flux_up_d(icol,ilay);
             dst_arr(i,j,k,6) = lw_flux_dn_d(icol,ilay);
  
             // Cosine zenith angle
             dst_arr(i,j,k,7) = mu0_d(icol);
  
             // Clear sky heating rates and fluxes:
             dst_arr(i,j,k,8) = sw_clrsky_heating_d(icol, ilay);
             dst_arr(i,j,k,9) = lw_clrsky_heating_d(icol, ilay);
  
             dst_arr(i,j,k,10) = sw_clrsky_flux_up_d(icol,ilay);
             dst_arr(i,j,k,11) = sw_clrsky_flux_dn_d(icol,ilay);
             dst_arr(i,j,k,12) = sw_clrsky_flux_dn_dir_d(icol,ilay);
             dst_arr(i,j,k,13) = lw_clrsky_flux_up_d(icol,ilay);
             dst_arr(i,j,k,14) = lw_clrsky_flux_dn_d(icol,ilay);
  
             // Clean sky fluxes:
             if (extra_clnsky_diag) {
                 dst_arr(i,j,k,15) = sw_clnsky_flux_up_d(icol,ilay);
                 dst_arr(i,j,k,16) = sw_clnsky_flux_dn_d(icol,ilay);
                 dst_arr(i,j,k,17) = sw_clnsky_flux_dn_dir_d(icol,ilay);
                 dst_arr(i,j,k,18) = lw_clnsky_flux_up_d(icol,ilay);
                 dst_arr(i,j,k,19) = lw_clnsky_flux_dn_d(icol,ilay);
             }
  
             // Clean-clear sky fluxes:
             if (extra_clnclrsky_diag) {
                 dst_arr(i,j,k,20) = sw_clnclrsky_flux_up_d(icol,ilay);
                 dst_arr(i,j,k,21) = sw_clnclrsky_flux_dn_d(icol,ilay);
                 dst_arr(i,j,k,22) = sw_clnclrsky_flux_dn_dir_d(icol,ilay);
                 dst_arr(i,j,k,23) = lw_clnclrsky_flux_up_d(icol,ilay);
                 dst_arr(i,j,k,24) = lw_clnclrsky_flux_dn_d(icol,ilay);
             }
         });
    }
 }

Here is the call graph for this function:

◆ rad_run_impl()

void Radiation::rad_run_impl ( amrex::Vector< amrex::MultiFab * > & lsm_output_ptrs )

inline

     {
         if (m_update_rad) {
             amrex::Print() << "Advancing radiation at level: " << m_lev << " ...";
             this->initialize_impl();
             this->run_impl();
             this->finalize_impl(lsm_output_ptrs);
             amrex::Print() << "DONE\n";
         }
     }

Referenced by Run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Run()

virtual void Radiation::Run	(	int &	level,
		int &	step,
		amrex::Real &	time,
		const amrex::Real &	dt,
		const amrex::BoxArray &	ba,
		amrex::Geometry &	geom,
		amrex::MultiFab *	cons_in,
		amrex::MultiFab *	lsm_fluxes,
		amrex::MultiFab *	lsm_zenith,
		amrex::Vector< amrex::MultiFab * > &	lsm_input_ptrs,
		amrex::Vector< amrex::MultiFab * > &	lsm_output_ptrs,
		amrex::MultiFab *	qheating_rates,
		amrex::MultiFab *	z_phys,
		amrex::MultiFab *	lat,
		amrex::MultiFab *	lon
	)

inlineoverridevirtual

Implements IRadiation.

     {
         set_grids(level, step, time, dt, ba, geom,
                   cons_in, lsm_fluxes, lsm_zenith,
                   lsm_input_ptrs, qheating_rates,
                   z_phys, lat, lon);
         rad_run_impl(lsm_output_ptrs);
     }

Here is the call graph for this function:

◆ run_impl()

void Radiation::run_impl ( )

 {
     // Local copies
     const auto ncol     = m_ncol;
     const auto nlay     = m_nlay;
     const auto nswbands = m_nswbands;
  
     // Compute orbital parameters; these are used both for computing
     // the solar zenith angle and also for computing total solar
     // irradiance scaling (tsi_scaling).
     double obliqr, lambm0, mvelpp;
     int  orbital_year = m_orbital_year;
     double eccen      = m_orbital_eccen;
     double obliq      = m_orbital_obliq;
     double mvelp      = m_orbital_mvelp;
     if (eccen >= 0 && obliq >= 0 && mvelp >= 0) {
       // fixed orbital parameters forced with orbital_year == ORB_UNDEF_INT
       orbital_year = ORB_UNDEF_INT;
     }
     orbital_params(orbital_year, eccen, obliq,
                    mvelp, obliqr, lambm0, mvelpp);
  
  
     // Use the orbital parameters to calculate the solar declination and eccentricity factor
     double delta, eccf;
     // Want day + fraction; calday 1 == Jan 1 0Z
     static constexpr double dpy[] = {0.0  ,  31.0,  59.0,  90.0, 120.0, 151.0,
                                      181.0, 212.0, 243.0, 273.0, 304.0, 334.0};
     bool leap = (m_orbital_year % 4 == 0 && (!(m_orbital_year % 100 == 0) || (m_orbital_year % 400 == 0))) ? true : false;
     double calday = dpy[m_orbital_mon-1] + (m_orbital_day-1.0) + m_orbital_sec/86400.0;
     // add extra day if leap year
     if (leap) { calday += 1.0; }
     orbital_decl(calday, eccen, mvelpp, lambm0, obliqr, delta, eccf);
  
     // Overwrite eccf if using a fixed solar constant.
     auto fixed_total_solar_irradiance = m_fixed_total_solar_irradiance;
     if (fixed_total_solar_irradiance >= 0){
        eccf = fixed_total_solar_irradiance/1360.9;
     }
  
     // Precompute volume mixing ratio (VMR) for all gases
     //
     // H2O is obtained from qv.
     // O3 may be a constant or a 1D vector
     // All other comps are set to constants for now
     for (int igas(0); igas < m_ngas; ++igas) {
         auto tmp2d_d = tmp2d;
         auto name = m_gas_names[igas];
         auto gas_mol_weight = m_mol_weight_gas[igas];
         if (name == "H2O") {
             auto qv_lay_d = qv_lay;
             Kokkos::parallel_for(Kokkos::MDRangePolicy<Kokkos::Rank<2>>({0, 0}, {ncol, nlay}),
                                  KOKKOS_LAMBDA (int icol, int ilay)
             {
                 tmp2d_d(icol,ilay) = qv_lay_d(icol,ilay) * mwdair/ gas_mol_weight;
             });
         } else if (name == "CO2") {
             Kokkos::deep_copy(tmp2d, m_co2vmr);
         } else if (name == "O3")  {
             if (m_o3_size==1) {
                 Kokkos::deep_copy(tmp2d, m_o3vmr[0] );
             } else {
                 auto o3_lay_d = o3_lay;
                 Kokkos::parallel_for(Kokkos::MDRangePolicy<Kokkos::Rank<2>>({0, 0}, {ncol, nlay}),
                                      KOKKOS_LAMBDA (int icol, int ilay)
                 {
                     tmp2d_d(icol,ilay) = o3_lay_d(ilay);
                 });
             }
         } else if (name == "N2O") {
             Kokkos::deep_copy(tmp2d, m_n2ovmr);
         } else if (name == "CO")  {
             Kokkos::deep_copy(tmp2d, m_covmr );
         } else if (name == "CH4") {
             Kokkos::deep_copy(tmp2d, m_ch4vmr);
         } else if (name == "O2") {
             Kokkos::deep_copy(tmp2d, m_o2vmr );
         } else if (name == "N2") {
             Kokkos::deep_copy(tmp2d, m_n2vmr );
         } else {
             Abort("Radiation: Unknown gas component.");
         }
  
         // Populate GasConcs object
         m_gas_concs.set_vmr(name, tmp2d);
     }
  
     // Populate mu0 1D array
     // This must be done on HOST and copied to device.
     auto h_mu0 = Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), mu0);
     if (m_fixed_solar_zenith_angle > 0) {
         Kokkos::deep_copy(h_mu0, m_fixed_solar_zenith_angle);
     } else {
         auto h_lat = Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), lat);
         auto h_lon = Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), lon);
         double dt  = double(m_dt);
         auto rad_freq_in_steps = m_rad_freq_in_steps;
         Kokkos::parallel_for(Kokkos::RangePolicy<Kokkos::Serial>(0, ncol),
                              KOKKOS_LAMBDA (int icol)
         {
             // Convert lat/lon to radians
             double lat_col = h_lat(icol)*PI/180.0;
             double lon_col = h_lon(icol)*PI/180.0;
             double lcalday = calday;
             double ldelta  = delta;
             h_mu0(icol)    = Real(orbital_cos_zenith(lcalday, lat_col, lon_col, ldelta, rad_freq_in_steps * dt));
         });
     }
     Kokkos::deep_copy(mu0, h_mu0);
  
     // Compute layer cloud mass per unit area (populates lwp/iwp)
     rrtmgp::mixing_ratio_to_cloud_mass(qc_lay, cldfrac_tot, r_lay, z_del, lwp);
     rrtmgp::mixing_ratio_to_cloud_mass(qi_lay, cldfrac_tot, r_lay, z_del, iwp);
  
     // Convert to g/m2 (needed by RRTMGP)
     auto lwp_d = lwp;
     auto iwp_d = iwp;
     Kokkos::parallel_for(Kokkos::MDRangePolicy<Kokkos::Rank<2>>({0, 0}, {ncol, nlay}),
                          KOKKOS_LAMBDA (int icol, int ilay)
     {
         lwp_d(icol,ilay) *= 1.e3;
         iwp_d(icol,ilay) *= 1.e3;
     });
  
     // Expand surface_albedos along nswbands.
     // This is needed since rrtmgp require band-by-band.
     rrtmgp::compute_band_by_band_surface_albedos(ncol, nswbands,
                                                  sfc_alb_dir_vis, sfc_alb_dir_nir,
                                                  sfc_alb_dif_vis, sfc_alb_dif_nir,
                                                  sfc_alb_dir    , sfc_alb_dif);
  
     // Run RRTMGP driver
     rrtmgp::rrtmgp_main(ncol, m_nlay,
                         p_lay, t_lay,
                         p_lev, t_lev,
                         m_gas_concs,
                         sfc_alb_dir, sfc_alb_dif, mu0,
                         t_sfc, emis_sfc, lw_src,
                         lwp, iwp, eff_radius_qc, eff_radius_qi, cldfrac_tot,
                         aero_tau_sw, aero_ssa_sw, aero_g_sw, aero_tau_lw,
                         cld_tau_sw_bnd, cld_tau_lw_bnd,
                         cld_tau_sw_gpt, cld_tau_lw_gpt,
                         sw_flux_up, sw_flux_dn, sw_flux_dn_dir,
                         lw_flux_up, lw_flux_dn,
                         sw_clnclrsky_flux_up, sw_clnclrsky_flux_dn, sw_clnclrsky_flux_dn_dir,
                         sw_clrsky_flux_up, sw_clrsky_flux_dn, sw_clrsky_flux_dn_dir,
                         sw_clnsky_flux_up, sw_clnsky_flux_dn, sw_clnsky_flux_dn_dir,
                         lw_clnclrsky_flux_up, lw_clnclrsky_flux_dn,
                         lw_clrsky_flux_up, lw_clrsky_flux_dn,
                         lw_clnsky_flux_up, lw_clnsky_flux_dn,
                         sw_bnd_flux_up, sw_bnd_flux_dn, sw_bnd_flux_dir,
                         lw_bnd_flux_up, lw_bnd_flux_dn,
                         eccf, m_extra_clnclrsky_diag, m_extra_clnsky_diag);
  
 #if 0
     // UNIT TEST
     //================================================================================
     Kokkos::deep_copy(mu0, 0.86);
     Kokkos::deep_copy(sfc_alb_dir_vis, 0.06);
     Kokkos::deep_copy(sfc_alb_dir_nir, 0.06);
     Kokkos::deep_copy(sfc_alb_dif_vis, 0.06);
     Kokkos::deep_copy(sfc_alb_dif_nir, 0.06);
  
     Kokkos::deep_copy(aero_tau_sw, 0.0);
     Kokkos::deep_copy(aero_ssa_sw, 0.0);
     Kokkos::deep_copy(aero_g_sw  , 0.0);
     Kokkos::deep_copy(aero_tau_lw, 0.0);
  
     // Generate some fake liquid and ice water data. We pick values to be midway between
     // the min and max of the valid lookup table values for effective radii
     real rel_val = 0.5 * (rrtmgp::cloud_optics_sw_k->get_min_radius_liq()
                         + rrtmgp::cloud_optics_sw_k->get_max_radius_liq());
     real rei_val = 0.5 * (rrtmgp::cloud_optics_sw_k->get_min_radius_ice()
                         + rrtmgp::cloud_optics_sw_k->get_max_radius_ice());
  
     // Restrict clouds to troposphere (> 100 hPa = 100*100 Pa) and not very close to the ground (< 900 hPa), and
     // put them in 2/3 of the columns since that's roughly the total cloudiness of earth.
     // Set sane values for liquid and ice water path.
     // NOTE: these "sane" values are in g/m2!
     Kokkos::parallel_for(Kokkos::MDRangePolicy<Kokkos::Rank<2>>({0, 0}, {ncol, nlay}),
                          KOKKOS_LAMBDA (int icol, int ilay)
     {
         cldfrac_tot(icol,ilay) = (p_lay(icol,ilay) > 100. * 100.) &&
                                  (p_lay(icol,ilay) < 900. * 100.) &&
                                  (icol%3 != 0);
         // Ice and liquid will overlap in a few layers
         lwp(icol,ilay) = (cldfrac_tot(icol,ilay) && t_lay(icol,ilay) > 263.) ? 10. : 0.;
         iwp(icol,ilay) = (cldfrac_tot(icol,ilay) && t_lay(icol,ilay) < 273.) ? 10. : 0.;
         eff_radius_qc(icol,ilay) = (lwp(icol,ilay) > 0.) ? rel_val : 0.;
         eff_radius_qi(icol,ilay) = (iwp(icol,ilay) > 0.) ? rei_val : 0.;
     });
  
     rrtmgp::compute_band_by_band_surface_albedos(ncol, nswbands,
                                                  sfc_alb_dir_vis, sfc_alb_dir_nir,
                                                  sfc_alb_dif_vis, sfc_alb_dif_nir,
                                                  sfc_alb_dir    , sfc_alb_dif);
  
     rrtmgp::rrtmgp_main(ncol, m_nlay,
                         p_lay, t_lay,
                         p_lev, t_lev,
                         m_gas_concs,
                         sfc_alb_dir, sfc_alb_dif, mu0,
                         t_sfc, emis_sfc, lw_src,
                         lwp, iwp, eff_radius_qc, eff_radius_qi, cldfrac_tot,
                         aero_tau_sw, aero_ssa_sw, aero_g_sw, aero_tau_lw,
                         cld_tau_sw_bnd, cld_tau_lw_bnd,
                         cld_tau_sw_gpt, cld_tau_lw_gpt,
                         sw_flux_up, sw_flux_dn, sw_flux_dn_dir,
                         lw_flux_up, lw_flux_dn,
                         sw_clnclrsky_flux_up, sw_clnclrsky_flux_dn, sw_clnclrsky_flux_dn_dir,
                         sw_clrsky_flux_up, sw_clrsky_flux_dn, sw_clrsky_flux_dn_dir,
                         sw_clnsky_flux_up, sw_clnsky_flux_dn, sw_clnsky_flux_dn_dir,
                         lw_clnclrsky_flux_up, lw_clnclrsky_flux_dn,
                         lw_clrsky_flux_up, lw_clrsky_flux_dn,
                         lw_clnsky_flux_up, lw_clnsky_flux_dn,
                         sw_bnd_flux_up, sw_bnd_flux_dn, sw_bnd_flux_dir,
                         lw_bnd_flux_up, lw_bnd_flux_dn,
                         1.0, false, false);
     //================================================================================
 #endif
  
     // Update heating tendency
     rrtmgp::compute_heating_rate(sw_flux_up, sw_flux_dn, r_lay, z_del, sw_heating);
     rrtmgp::compute_heating_rate(lw_flux_up, lw_flux_dn, r_lay, z_del, lw_heating);
  
     /*
     // AML DEBUG
     Kokkos::parallel_for(nlay+1, KOKKOS_LAMBDA (int ilay)
     {
         printf("Fluxes: %i %e %e %e %e %e\n",ilay,
                                              sw_flux_up(5,ilay), sw_flux_dn(5,ilay), sw_flux_dn_dir(5,ilay),
                                              lw_flux_up(5,ilay), lw_flux_dn(5,ilay));
     });
     Kokkos::parallel_for(nlay, KOKKOS_LAMBDA (int ilay)
     {
         printf("Heating Rate: %i %e %e\n",ilay,sw_heating(5,ilay),lw_heating(5,ilay));
     });
     */
  
     // Compute surface fluxes
     const int kbot = 0;
     auto sw_bnd_flux_dif_d = sw_bnd_flux_dif;
     auto sw_bnd_flux_dn_d  = sw_bnd_flux_dn;
     auto sw_bnd_flux_dir_d = sw_bnd_flux_dir;
     Kokkos::parallel_for(Kokkos::MDRangePolicy<Kokkos::Rank<3>>({0, 0, 0}, {ncol, nlay+1, nswbands}),
                          KOKKOS_LAMBDA (int icol, int ilay, int ibnd)
     {
         sw_bnd_flux_dif_d(icol,ilay,ibnd) = sw_bnd_flux_dn_d(icol,ilay,ibnd) - sw_bnd_flux_dir_d(icol,ilay,ibnd);
     });
     rrtmgp::compute_broadband_surface_fluxes(ncol, kbot, nswbands,
                                              sw_bnd_flux_dir , sw_bnd_flux_dif ,
                                              sfc_flux_dir_vis, sfc_flux_dir_nir,
                                              sfc_flux_dif_vis, sfc_flux_dif_nir);
 }

Referenced by rad_run_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_grids()

void Radiation::set_grids	(	int &	level,
		int &	step,
		amrex::Real &	time,
		const amrex::Real &	dt,
		const amrex::BoxArray &	ba,
		amrex::Geometry &	geom,
		amrex::MultiFab *	cons_in,
		amrex::MultiFab *	lsm_fluxes,
		amrex::MultiFab *	lsm_zenith,
		amrex::Vector< amrex::MultiFab * > &	lsm_input_ptrs,
		amrex::MultiFab *	qheating_rates,
		amrex::MultiFab *	z_phys,
		amrex::MultiFab *	lat,
		amrex::MultiFab *	lon
	)

 {
     // Set data members that may change
     m_lev            = level;
     m_step           = step;
     m_time           = time;
     m_dt             = dt;
     m_geom           = geom;
     m_cons_in        = cons_in;
     m_lsm_fluxes     = lsm_fluxes;
     m_lsm_zenith     = lsm_zenith;
     m_qheating_rates = qheating_rates;
     m_z_phys         = z_phys;
     m_lat            = lat;
     m_lon            = lon;
  
     // Update the day and month
     time_t timestamp = time_t(time);
     struct tm *timeinfo = gmtime(&timestamp);
     if (m_fixed_orbital_year) {
         m_orbital_mon  = timeinfo->tm_mon + 1;
         m_orbital_day  = timeinfo->tm_mday;
         m_orbital_sec  = timeinfo->tm_hour*3600 + timeinfo->tm_min*60 + timeinfo->tm_sec;
     } else {
         m_orbital_year = timeinfo->tm_year + 1900;
         m_orbital_mon  = timeinfo->tm_mon  + 1;
         m_orbital_day  = timeinfo->tm_mday;
         m_orbital_sec  = timeinfo->tm_hour*3600 + timeinfo->tm_min*60 + timeinfo->tm_sec;
     }
  
     // Only allocate and proceed if we are going to update radiation
     m_update_rad = false;
     if (m_rad_freq_in_steps > 0) { m_update_rad = ( (m_step == 0) || (m_step % m_rad_freq_in_steps == 0) ); }
  
     if (m_update_rad) {
         // Call to Init() has set the dimensions: ncol & nlay
  
         // Allocate the buffer arrays
         alloc_buffers();
  
         // Fill the KOKKOS Views from AMReX MFs
         mf_to_kokkos_buffers(lsm_input_ptrs);
  
         // Initialize datalog MF on first step
         if (m_first_step) {
             m_first_step = false;
             datalog_mf.define(cons_in->boxArray(), cons_in->DistributionMap(), 25, 0);
             datalog_mf.setVal(0.0);
         }
     }
 }

Referenced by Run().

Here is the caller graph for this function:

◆ write_rrtmgp_fluxes()

void Radiation::write_rrtmgp_fluxes ( )

 {
     // Expose for device
     auto sw_flux_up_d = sw_flux_up;
     auto sw_flux_dn_d = sw_flux_dn;
     auto sw_flux_dn_dir_d = sw_flux_dn_dir;
     auto lw_flux_up_d = lw_flux_up;
     auto lw_flux_dn_d = lw_flux_dn;
  
     int n_fluxes = 5;
     MultiFab mf_flux(m_cons_in->boxArray(), m_cons_in->DistributionMap(), n_fluxes, 0);
  
    for (MFIter mfi(mf_flux); mfi.isValid(); ++mfi) {
         const auto& vbx      = mfi.validbox();
         const int nx         = vbx.length(0);
         const int imin       = vbx.smallEnd(0);
         const int jmin       = vbx.smallEnd(1);
         const int offset     = m_col_offsets[mfi.index()];
         const Array4<Real>& dst_arr = mf_flux.array(mfi);
         ParallelFor(vbx, [=] AMREX_GPU_DEVICE (int i, int j, int k)
         {
             // map [i,j,k] 0-based to [icol, ilay] 0-based
             const int icol = (j-jmin)*nx + (i-imin) + offset;
             const int ilay = k;
  
             // SW and LW fluxes
             dst_arr(i,j,k,0) = sw_flux_up_d(icol,ilay);
             dst_arr(i,j,k,1) = sw_flux_dn_d(icol,ilay);
             dst_arr(i,j,k,2) = sw_flux_dn_dir_d(icol,ilay);
             dst_arr(i,j,k,3) = lw_flux_up_d(icol,ilay);
             dst_arr(i,j,k,4) = lw_flux_dn_d(icol,ilay);
         });
    }
  
  
    std::string plotfilename = amrex::Concatenate("plt_rad", m_step, 5);
    Vector<std::string> flux_names = {"sw_flux_up", "sw_flux_dn", "sw_flux_dir",
                                      "lw_flux_up", "lw_flux_dn"};
    WriteSingleLevelPlotfile(plotfilename, mf_flux, flux_names, m_geom, m_time, m_step);
 }

Here is the call graph for this function:

◆ WriteDataLog()

void Radiation::WriteDataLog ( const amrex::Real & time )

overridevirtual

Implements IRadiation.

 {
     constexpr int datwidth = 14;
     constexpr int datprecision = 9;
     constexpr int timeprecision = 13;
  
     Gpu::HostVector<Real> h_avg_radqrsw, h_avg_radqrlw, h_avg_sw_up, h_avg_sw_dn, h_avg_sw_dn_dir, h_avg_lw_up, h_avg_lw_dn, h_avg_zenith;
     // Clear sky
     Gpu::HostVector<Real> h_avg_radqrcsw, h_avg_radqrclw, h_avg_sw_clr_up, h_avg_sw_clr_dn, h_avg_sw_clr_dn_dir, h_avg_lw_clr_up, h_avg_lw_clr_dn;
     // Clean sky
     Gpu::HostVector<Real> h_avg_sw_cln_up, h_avg_sw_cln_dn, h_avg_sw_cln_dn_dir, h_avg_lw_cln_up, h_avg_lw_cln_dn;
     // Clean clear sky
     Gpu::HostVector<Real> h_avg_sw_clnclr_up, h_avg_sw_clnclr_dn, h_avg_sw_clnclr_dn_dir, h_avg_lw_clnclr_up, h_avg_lw_clnclr_dn;
  
  
     auto domain = m_geom.Domain();
     h_avg_radqrsw    = sumToLine(datalog_mf, 0, 1, domain, 2);
     h_avg_radqrlw    = sumToLine(datalog_mf, 1, 1, domain, 2);
     h_avg_sw_up      = sumToLine(datalog_mf, 2, 1, domain, 2);
     h_avg_sw_dn      = sumToLine(datalog_mf, 3, 1, domain, 2);
     h_avg_sw_dn_dir  = sumToLine(datalog_mf, 4, 1, domain, 2);
     h_avg_lw_up      = sumToLine(datalog_mf, 5, 1, domain, 2);
     h_avg_lw_dn      = sumToLine(datalog_mf, 6, 1, domain, 2);
     h_avg_zenith     = sumToLine(datalog_mf, 7, 1, domain, 2);
  
     h_avg_radqrcsw       = sumToLine(datalog_mf, 8, 1, domain, 2);
     h_avg_radqrclw       = sumToLine(datalog_mf, 9, 1, domain, 2);
     h_avg_sw_clr_up      = sumToLine(datalog_mf, 10, 1, domain, 2);
     h_avg_sw_clr_dn      = sumToLine(datalog_mf, 11, 1, domain, 2);
     h_avg_sw_clr_dn_dir  = sumToLine(datalog_mf, 12, 1, domain, 2);
     h_avg_lw_clr_up      = sumToLine(datalog_mf, 13, 1, domain, 2);
     h_avg_lw_clr_dn      = sumToLine(datalog_mf, 14, 1, domain, 2);
  
     if (m_extra_clnsky_diag) {
         h_avg_sw_cln_up      = sumToLine(datalog_mf, 15, 1, domain, 2);
         h_avg_sw_cln_dn      = sumToLine(datalog_mf, 16, 1, domain, 2);
         h_avg_sw_cln_dn_dir  = sumToLine(datalog_mf, 17, 1, domain, 2);
         h_avg_lw_cln_up      = sumToLine(datalog_mf, 18, 1, domain, 2);
         h_avg_lw_cln_dn      = sumToLine(datalog_mf, 19, 1, domain, 2);
     }
  
     if (m_extra_clnclrsky_diag) {
         h_avg_sw_clnclr_up      = sumToLine(datalog_mf, 20, 1, domain, 2);
         h_avg_sw_clnclr_dn      = sumToLine(datalog_mf, 21, 1, domain, 2);
         h_avg_sw_clnclr_dn_dir  = sumToLine(datalog_mf, 22, 1, domain, 2);
         h_avg_lw_clnclr_up      = sumToLine(datalog_mf, 23, 1, domain, 2);
         h_avg_lw_clnclr_dn      = sumToLine(datalog_mf, 24, 1, domain, 2);
     }
  
     Real area_z = static_cast<Real>(domain.length(0)*domain.length(1));
     int nz = domain.length(2);
     for (int k = 0; k < nz; k++) {
         h_avg_radqrsw[k] /= area_z;
         h_avg_radqrlw[k] /= area_z;
         h_avg_sw_up[k] /= area_z;
         h_avg_sw_dn[k] /= area_z;
         h_avg_sw_dn_dir[k] /= area_z;
         h_avg_lw_up[k] /= area_z;
         h_avg_lw_dn[k] /= area_z;
         h_avg_zenith[k] /= area_z;
  
         h_avg_radqrcsw[k] /= area_z;
         h_avg_radqrclw[k] /= area_z;
         h_avg_sw_clr_up[k] /= area_z;
         h_avg_sw_clr_dn[k] /= area_z;
         h_avg_sw_clr_dn_dir[k] /= area_z;
         h_avg_lw_clr_up[k] /= area_z;
         h_avg_lw_clr_dn[k] /= area_z;
     }
  
     if (m_extra_clnsky_diag) {
         for (int k = 0; k < nz; k++) {
             h_avg_sw_cln_up[k] /= area_z;
             h_avg_sw_cln_dn[k] /= area_z;
             h_avg_sw_cln_dn_dir[k] /= area_z;
             h_avg_lw_cln_up[k] /= area_z;
             h_avg_lw_cln_dn[k] /= area_z;
         }
     }
  
     if (m_extra_clnclrsky_diag) {
         for (int k = 0; k < nz; k++) {
             h_avg_sw_clnclr_up[k] /= area_z;
             h_avg_sw_clnclr_dn[k] /= area_z;
             h_avg_sw_clnclr_dn_dir[k] /= area_z;
             h_avg_lw_clnclr_up[k] /= area_z;
             h_avg_lw_clnclr_dn[k] /= area_z;
         }
     }
  
     if (ParallelDescriptor::IOProcessor()) {
         std::ostream& log = *datalog;
         if (log.good()) {
  
             for (int k = 0; k < nz; k++)
             {
                 Real z = k * m_geom.CellSize(2);
                 log << std::setw(datwidth) << std::setprecision(timeprecision) << time << " "
                     << std::setw(datwidth) << std::setprecision(datprecision) << z << " "
                     << h_avg_radqrsw[k]   << " " << h_avg_radqrlw[k]       << " " << h_avg_sw_up[k] << " "
                     << h_avg_sw_dn[k]     << " " << h_avg_sw_dn_dir[k]     << " " << h_avg_lw_up[k] << " "
                     << h_avg_lw_dn[k]     << " " << h_avg_zenith[k]        << " "
                     << h_avg_radqrcsw[k]  << " " << h_avg_radqrclw[k]      << " " << h_avg_sw_clr_up[k] << " "
                     << h_avg_sw_clr_dn[k] << " " << h_avg_sw_clr_dn_dir[k] << " " << h_avg_lw_clr_up[k] << " "
                     << h_avg_lw_clr_dn[k] << " ";
                     if (m_extra_clnsky_diag) {
                         log << h_avg_sw_cln_up[k] << " " << h_avg_sw_cln_dn[k] << " " << h_avg_sw_cln_dn_dir[k] << " "
                             << h_avg_lw_cln_up[k] << " " << h_avg_lw_cln_dn[k] << " ";
                     } else {
                         log << 0.0 << " " << 0.0 << " " << 0.0 << " " << 0.0 << " " << 0.0 << " ";
                     }
  
                     if (m_extra_clnclrsky_diag) {
                         log << h_avg_sw_clnclr_up[k] << " " << h_avg_sw_clnclr_dn[k] << " " << h_avg_sw_clnclr_dn_dir[k] << " "
                             << h_avg_lw_clnclr_up[k] << " " << h_avg_lw_clnclr_dn[k] << std::endl;
                     } else {
                         log << 0.0 << " " << 0.0 << " " << 0.0 << " " << 0.0 << " " << 0.0 << std::endl;
                     }
             }
             // Write top face values
             Real z = nz * m_geom.CellSize(2);
             log << std::setw(datwidth) << std::setprecision(timeprecision) << time << " "
                 << std::setw(datwidth) << std::setprecision(datprecision) << z << " "
                 << 0.0 << " " << 0.0 << " " << 0.0 << " " << 0.0 << " " << 0.0 << " " << 0.0 << " "
                 << 0.0 << " " << 0.0 << " "
                 << 0.0 << " " << 0.0 << " " << 0.0 << " " << 0.0 << " " << 0.0 << " " << 0.0 << " "
                 << 0.0 << " "
                 << 0.0 << " " << 0.0 << " " << 0.0 << " " << 0.0 << " " << 0.0 << " "
                 << 0.0 << " " << 0.0 << " " << 0.0 << " " << 0.0 << " " << 0.0
                 << std::endl;
         }
     }
 }

Member Data Documentation

◆ aero_g_sw

real3d_k Radiation::aero_g_sw

private

◆ aero_ssa_sw

real3d_k Radiation::aero_ssa_sw

private

◆ aero_tau_lw

real3d_k Radiation::aero_tau_lw

private

◆ aero_tau_sw

real3d_k Radiation::aero_tau_sw

private

◆ cld_tau_lw_bnd

real3d_k Radiation::cld_tau_lw_bnd

private

◆ cld_tau_lw_gpt

real3d_k Radiation::cld_tau_lw_gpt

private

◆ cld_tau_sw_bnd

real3d_k Radiation::cld_tau_sw_bnd

private

◆ cld_tau_sw_gpt

real3d_k Radiation::cld_tau_sw_gpt

private

◆ cldfrac_tot

real2d_k Radiation::cldfrac_tot

private

◆ cosine_zenith

real1d_k Radiation::cosine_zenith

private

◆ d_tint

real2d_k Radiation::d_tint

private

◆ datalog_mf

amrex::MultiFab Radiation::datalog_mf

private

◆ eff_radius_qc

real2d_k Radiation::eff_radius_qc

private

◆ eff_radius_qi

real2d_k Radiation::eff_radius_qi

private

◆ emis_sfc

real2d_k Radiation::emis_sfc

private

◆ gas_names_offset

std::vector<std::string> Radiation::gas_names_offset

private

◆ iwp

real2d_k Radiation::iwp

private

◆ lat

real1d_k Radiation::lat

private

Referenced by Run().

◆ lon

real1d_k Radiation::lon

private

Referenced by Run().

◆ lw_bnd_flux_dn

real3d_k Radiation::lw_bnd_flux_dn

private

◆ lw_bnd_flux_up

real3d_k Radiation::lw_bnd_flux_up

private

◆ lw_clnclrsky_flux_dn

real2d_k Radiation::lw_clnclrsky_flux_dn

private

◆ lw_clnclrsky_flux_up

real2d_k Radiation::lw_clnclrsky_flux_up

private

◆ lw_clnsky_flux_dn

real2d_k Radiation::lw_clnsky_flux_dn

private

◆ lw_clnsky_flux_up

real2d_k Radiation::lw_clnsky_flux_up

private

◆ lw_clrsky_flux_dn

real2d_k Radiation::lw_clrsky_flux_dn

private

◆ lw_clrsky_flux_up

real2d_k Radiation::lw_clrsky_flux_up

private

◆ lw_clrsky_heating

real2d_k Radiation::lw_clrsky_heating

private

◆ lw_flux_dn

real2d_k Radiation::lw_flux_dn

private

◆ lw_flux_up

real2d_k Radiation::lw_flux_up

private

◆ lw_heating

real2d_k Radiation::lw_heating

private

◆ lw_src

real1d_k Radiation::lw_src

private

◆ lwp

real2d_k Radiation::lwp

private

◆ m_ba

amrex::BoxArray Radiation::m_ba

private

◆ m_ch4vmr

amrex::Real Radiation::m_ch4vmr = 1807.851e-9

private

◆ m_co2vmr

amrex::Real Radiation::m_co2vmr = 388.717e-6

private

◆ m_col_offsets

amrex::Vector<int> Radiation::m_col_offsets

private

Referenced by Init().

◆ m_cons_in

amrex::MultiFab* Radiation::m_cons_in = nullptr

private

◆ m_covmr

amrex::Real Radiation::m_covmr = 1.0e-7

private

◆ m_do_aerosol_rad

bool Radiation::m_do_aerosol_rad = true

private

◆ m_do_subcol_sampling

bool Radiation::m_do_subcol_sampling = true

private

◆ m_dt

amrex::Real Radiation::m_dt

private

◆ m_extra_clnclrsky_diag

bool Radiation::m_extra_clnclrsky_diag = false

private

◆ m_extra_clnsky_diag

bool Radiation::m_extra_clnsky_diag = false

private

◆ m_first_step

bool Radiation::m_first_step = true

private

◆ m_fixed_orbital_year

bool Radiation::m_fixed_orbital_year = false

private

◆ m_fixed_solar_zenith_angle

amrex::Real Radiation::m_fixed_solar_zenith_angle = -9999.

private

◆ m_fixed_total_solar_irradiance

amrex::Real Radiation::m_fixed_total_solar_irradiance = -9999.

private

◆ m_gas_concs

GasConcsK<amrex::Real, layout_t, KokkosDefaultDevice> Radiation::m_gas_concs

private

◆ m_gas_mol_weights

real1d_k Radiation::m_gas_mol_weights

private

◆ m_gas_names

const std::vector<std::string> Radiation::m_gas_names

private

Initial value:

= {"H2O", "CO2", "O3", "N2O",

"CO" , "CH4", "O2", "N2" }

◆ m_geom

amrex::Geometry Radiation::m_geom

private

◆ m_ice

bool Radiation::m_ice = false

private

◆ m_lat

amrex::MultiFab* Radiation::m_lat = nullptr

private

◆ m_lat_cons

amrex::Real Radiation::m_lat_cons = 39.809860

private

◆ m_lev

int Radiation::m_lev

private

Referenced by rad_run_impl().

◆ m_lon

amrex::MultiFab* Radiation::m_lon = nullptr

private

◆ m_lon_cons

amrex::Real Radiation::m_lon_cons = -98.555183

private

◆ m_lsm

bool Radiation::m_lsm = false

private

◆ m_lsm_fluxes

amrex::MultiFab* Radiation::m_lsm_fluxes = nullptr

private

◆ m_lsm_input_names

amrex::Vector<std::string> Radiation::m_lsm_input_names

private

Initial value:

= {"t_sfc"          , "sfc_emis"       ,
                                                    "sfc_alb_dir_vis", "sfc_alb_dir_nir",
                                                    "sfc_alb_dif_vis", "sfc_alb_dif_nir"}

Referenced by get_lsm_input_varnames().

◆ m_lsm_output_names

amrex::Vector<std::string> Radiation::m_lsm_output_names = {"sw_flux_dn", "lw_flux_dn"}

private

Referenced by get_lsm_output_varnames().

◆ m_lsm_zenith

amrex::MultiFab* Radiation::m_lsm_zenith = nullptr

private

◆ m_moist

bool Radiation::m_moist = false

private

◆ m_mol_weight_gas

const std::vector<amrex::Real> Radiation::m_mol_weight_gas

private

Initial value:

= {18.01528, 44.00950, 47.9982, 44.0128,

28.01010, 16.04246, 31.9980, 28.0134}

◆ m_n2ovmr

amrex::Real Radiation::m_n2ovmr = 323.141e-9

private

◆ m_n2vmr

amrex::Real Radiation::m_n2vmr = 0.7906

private

◆ m_ncol

int Radiation::m_ncol

private

Referenced by Init().

◆ m_ngas

int Radiation::m_ngas = 8

private

◆ m_nlay

int Radiation::m_nlay

private

Referenced by Init().

◆ m_nlwbands

int Radiation::m_nlwbands = 16

private

◆ m_nlwgpts

int Radiation::m_nlwgpts = 128

private

◆ m_nswbands

int Radiation::m_nswbands = 14

private

◆ m_nswgpts

int Radiation::m_nswgpts = 112

private

◆ m_o2vmr

amrex::Real Radiation::m_o2vmr = 0.209448

private

◆ m_o3_size

int Radiation::m_o3_size

private

◆ m_o3vmr

amrex::Vector<amrex::Real> Radiation::m_o3vmr

private

◆ m_orbital_day

int Radiation::m_orbital_day = -9999

private

◆ m_orbital_eccen

amrex::Real Radiation::m_orbital_eccen = -9999.

private

◆ m_orbital_mon

int Radiation::m_orbital_mon = -9999

private

◆ m_orbital_mvelp

amrex::Real Radiation::m_orbital_mvelp = -9999.

private

◆ m_orbital_obliq

amrex::Real Radiation::m_orbital_obliq = -9999.

private

◆ m_orbital_sec

int Radiation::m_orbital_sec = -9999

private

◆ m_orbital_year

int Radiation::m_orbital_year = -9999

private

◆ m_qheating_rates

amrex::MultiFab* Radiation::m_qheating_rates = nullptr

private

◆ m_rad_freq_in_steps

int Radiation::m_rad_freq_in_steps = 1

private

◆ m_rad_t_sfc

amrex::Real Radiation::m_rad_t_sfc = -1

private

◆ m_rad_write_fluxes

bool Radiation::m_rad_write_fluxes = false

private

◆ m_step

int Radiation::m_step

private

◆ m_time

amrex::Real Radiation::m_time

private

◆ m_update_rad

bool Radiation::m_update_rad = false

private

Referenced by rad_run_impl().

◆ m_z_phys

amrex::MultiFab* Radiation::m_z_phys = nullptr

private

◆ mu0

real1d_k Radiation::mu0

private

◆ o3_lay

real1d_k Radiation::o3_lay

private

◆ p_del

real2d_k Radiation::p_del

private

◆ p_lay

real2d_k Radiation::p_lay

private

◆ p_lev

real2d_k Radiation::p_lev

private

◆ qc_lay

real2d_k Radiation::qc_lay

private

◆ qi_lay

real2d_k Radiation::qi_lay

private

◆ qv_lay

real2d_k Radiation::qv_lay

private

◆ r_lay

real2d_k Radiation::r_lay

private

◆ rrtmgp_cloud_optics_file_lw

std::string Radiation::rrtmgp_cloud_optics_file_lw

private

◆ rrtmgp_cloud_optics_file_sw

std::string Radiation::rrtmgp_cloud_optics_file_sw

private

◆ rrtmgp_cloud_optics_lw

std::string Radiation::rrtmgp_cloud_optics_lw = "rrtmgp-cloud-optics-coeffs-lw.nc"

private

◆ rrtmgp_cloud_optics_sw

std::string Radiation::rrtmgp_cloud_optics_sw = "rrtmgp-cloud-optics-coeffs-sw.nc"

private

◆ rrtmgp_coeffs_file_lw

std::string Radiation::rrtmgp_coeffs_file_lw

private

◆ rrtmgp_coeffs_file_sw

std::string Radiation::rrtmgp_coeffs_file_sw

private

◆ rrtmgp_coeffs_lw

std::string Radiation::rrtmgp_coeffs_lw = "rrtmgp-data-lw-g224-2018-12-04.nc"

private

◆ rrtmgp_coeffs_sw

std::string Radiation::rrtmgp_coeffs_sw = "rrtmgp-data-sw-g224-2018-12-04.nc"

private

◆ rrtmgp_file_path

std::string Radiation::rrtmgp_file_path = "."

private

◆ sfc_alb_dif

real2d_k Radiation::sfc_alb_dif

private

◆ sfc_alb_dif_nir

real1d_k Radiation::sfc_alb_dif_nir

private

◆ sfc_alb_dif_vis

real1d_k Radiation::sfc_alb_dif_vis

private

◆ sfc_alb_dir

real2d_k Radiation::sfc_alb_dir

private

◆ sfc_alb_dir_nir

real1d_k Radiation::sfc_alb_dir_nir

private

◆ sfc_alb_dir_vis

real1d_k Radiation::sfc_alb_dir_vis

private

◆ sfc_emis

real1d_k Radiation::sfc_emis

private

◆ sfc_flux_dif_nir

real1d_k Radiation::sfc_flux_dif_nir

private

◆ sfc_flux_dif_vis

real1d_k Radiation::sfc_flux_dif_vis

private

◆ sfc_flux_dir_nir

real1d_k Radiation::sfc_flux_dir_nir

private

◆ sfc_flux_dir_vis

real1d_k Radiation::sfc_flux_dir_vis

private

◆ sw_bnd_flux_dif

real3d_k Radiation::sw_bnd_flux_dif

private

◆ sw_bnd_flux_dir

real3d_k Radiation::sw_bnd_flux_dir

private

◆ sw_bnd_flux_dn

real3d_k Radiation::sw_bnd_flux_dn

private

◆ sw_bnd_flux_up

real3d_k Radiation::sw_bnd_flux_up

private

◆ sw_clnclrsky_flux_dn

real2d_k Radiation::sw_clnclrsky_flux_dn

private

◆ sw_clnclrsky_flux_dn_dir

real2d_k Radiation::sw_clnclrsky_flux_dn_dir

private

◆ sw_clnclrsky_flux_up

real2d_k Radiation::sw_clnclrsky_flux_up

private

◆ sw_clnsky_flux_dn

real2d_k Radiation::sw_clnsky_flux_dn

private

◆ sw_clnsky_flux_dn_dir

real2d_k Radiation::sw_clnsky_flux_dn_dir

private

◆ sw_clnsky_flux_up

real2d_k Radiation::sw_clnsky_flux_up

private

◆ sw_clrsky_flux_dn

real2d_k Radiation::sw_clrsky_flux_dn

private

◆ sw_clrsky_flux_dn_dir

real2d_k Radiation::sw_clrsky_flux_dn_dir

private

◆ sw_clrsky_flux_up

real2d_k Radiation::sw_clrsky_flux_up

private

◆ sw_clrsky_heating

real2d_k Radiation::sw_clrsky_heating

private

◆ sw_flux_dn

real2d_k Radiation::sw_flux_dn

private

◆ sw_flux_dn_dir

real2d_k Radiation::sw_flux_dn_dir

private

◆ sw_flux_up

real2d_k Radiation::sw_flux_up

private

◆ sw_heating

real2d_k Radiation::sw_heating

private

◆ t_lay

real2d_k Radiation::t_lay

private

◆ t_lev

real2d_k Radiation::t_lev

private

◆ t_sfc

real1d_k Radiation::t_sfc

private

◆ tmp2d

real2d_k Radiation::tmp2d

private

◆ z_del

real2d_k Radiation::z_del

private

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

Source/PhysicsInterfaces/Radiation/ERF_Radiation.H
Source/PhysicsInterfaces/Radiation/ERF_Radiation.cpp

Public Member Functions

Private Attributes

Additional Inherited Members

Constructor & Destructor Documentation

◆ Radiation()

◆ ~Radiation()

Member Function Documentation

◆ alloc_buffers()

◆ dealloc_buffers()

◆ finalize_impl()

◆ get_lsm_input_varnames()

◆ get_lsm_output_varnames()

◆ Init()

◆ initialize_impl()

◆ kokkos_buffers_to_mf()

◆ mf_to_kokkos_buffers()

◆ populateDatalogMF()

◆ rad_run_impl()

◆ Run()

◆ run_impl()

◆ set_grids()

◆ write_rrtmgp_fluxes()

◆ WriteDataLog()

Member Data Documentation

◆ aero_g_sw

◆ aero_ssa_sw

◆ aero_tau_lw

◆ aero_tau_sw

◆ cld_tau_lw_bnd

◆ cld_tau_lw_gpt

◆ cld_tau_sw_bnd

◆ cld_tau_sw_gpt

◆ cldfrac_tot

◆ cosine_zenith

◆ d_tint

◆ datalog_mf

◆ eff_radius_qc

◆ eff_radius_qi

◆ emis_sfc

◆ gas_names_offset

◆ iwp

◆ lat

◆ lon

◆ lw_bnd_flux_dn

◆ lw_bnd_flux_up

◆ lw_clnclrsky_flux_dn

◆ lw_clnclrsky_flux_up

◆ lw_clnsky_flux_dn

◆ lw_clnsky_flux_up

◆ lw_clrsky_flux_dn

◆ lw_clrsky_flux_up

◆ lw_clrsky_heating

◆ lw_flux_dn

◆ lw_flux_up

◆ lw_heating

◆ lw_src

◆ lwp

◆ m_ba

◆ m_ch4vmr

◆ m_co2vmr

◆ m_col_offsets

◆ m_cons_in

◆ m_covmr

◆ m_do_aerosol_rad

◆ m_do_subcol_sampling

◆ m_dt

◆ m_extra_clnclrsky_diag

◆ m_extra_clnsky_diag

◆ m_first_step

◆ m_fixed_orbital_year

◆ m_fixed_solar_zenith_angle

◆ m_fixed_total_solar_irradiance

◆ m_gas_concs

◆ m_gas_mol_weights

◆ m_gas_names

◆ m_geom

◆ m_ice

◆ m_lat

◆ m_lat_cons

◆ m_lev